diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..9d88d863 --- /dev/null +++ b/.gitignore @@ -0,0 +1,59 @@ +# Ignore dataset folder +/dataset/ +dataset/ + +# Python +__pycache__/ +*.py[cod] +*$py.class + +# Jupyter Notebook +.ipynb_checkpoints + +# Virtual environment +venv/ +env/ +.env + +# IDEs and editors +.vscode/ +.idea/ +*.swp +*.swo + +# Operating System Files +.DS_Store +Thumbs.db + +# Model checkpoints and logs +*.pth +*.pt +*.ckpt +logs/ + +# Temporary files +*.tmp +*.temp + +# Compiled source +*.com +*.class +*.dll +*.exe +*.o +*.so + +# Packages +*.7z +*.dmg +*.gz +*.iso +*.jar +*.rar +*.tar +*.zip + +# Logs and databases +*.log +*.sql +*.sqlite diff --git a/EDA/EDA.ipynb b/EDA/EDA.ipynb new file mode 100644 index 00000000..4a714464 --- /dev/null +++ b/EDA/EDA.ipynb @@ -0,0 +1,776 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d26a2b99-615a-43d4-ba96-8770bb42d56b", + "metadata": {}, + "source": [ + "# An EDA (Exploratory Data Analysis) for object detection" + ] + }, + { + "cell_type": "markdown", + "id": "f4a79faf-a6e0-447b-97b5-d55fcd8f99a3", + "metadata": {}, + "source": [ + "## 재활용 품목 분류를 위한 Object detection" + ] + }, + { + "cell_type": "markdown", + "id": "d0adbbbe-4aba-4b08-ad73-d0a3df487b14", + "metadata": {}, + "source": [ + "### Importing libraries & prepare DataFrame" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "34734851-74a7-4b3f-9040-be226ef2d08a", + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "from matplotlib import pyplot as plt\n", + "import numpy as np\n", + "from PIL import Image\n", + "import matplotlib.patches as patches\n", + "import pandas as pd\n", + "from pycocotools.coco import COCO" + ] + }, + { + "cell_type": "markdown", + "id": "b604d973-5168-448e-837d-eb9af73bfa28", + "metadata": {}, + "source": [ + "### Train image analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "6fbfca5e-3640-42fa-92bb-0037510ef9e1", + "metadata": {}, + "outputs": [], + "source": [ + "# check the json file\n", + "with open('./dataset/train.json', 'r', encoding='utf-8') as f:\n", + "\ttrain = json.load(f)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "a5887e13-eace-441a-bdee-641887a27f1b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_keys(['info', 'licenses', 'images', 'categories', 'annotations'])\n" + ] + } + ], + "source": [ + "print(train.keys())" + ] + }, + { + "cell_type": "markdown", + "id": "b0732104-5803-4488-a0d1-19c0eb8d4660", + "metadata": {}, + "source": [ + "- 'info' : metadata\n", + "- 'licenses' : 라이선스 정보\n", + "- 'images' : 이미지 크기, 이름 등\n", + "- 'categories' : 클래스 정보 \n", + "- 'annotations' : bbox 좌표, 박스 크기, 단일 객체만 포함되었는지 여부 등" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "18d97514-3e1c-4261-9e02-44242a18144e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[{'id': 0, 'name': 'General trash', 'supercategory': 'General trash'}, {'id': 1, 'name': 'Paper', 'supercategory': 'Paper'}, {'id': 2, 'name': 'Paper pack', 'supercategory': 'Paper pack'}, {'id': 3, 'name': 'Metal', 'supercategory': 'Metal'}, {'id': 4, 'name': 'Glass', 'supercategory': 'Glass'}, {'id': 5, 'name': 'Plastic', 'supercategory': 'Plastic'}, {'id': 6, 'name': 'Styrofoam', 'supercategory': 'Styrofoam'}, {'id': 7, 'name': 'Plastic bag', 'supercategory': 'Plastic bag'}, {'id': 8, 'name': 'Battery', 'supercategory': 'Battery'}, {'id': 9, 'name': 'Clothing', 'supercategory': 'Clothing'}]\n" + ] + } + ], + "source": [ + "print(train['categories'])" + ] + }, + { + "cell_type": "markdown", + "id": "bad5df9f-96f5-4090-81d7-9057a5eddabe", + "metadata": {}, + "source": [ + "- 위와 같이 10개 클래스가 있음" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "956c2f3e-769f-4939-85d7-30922b8467ac", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4883" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(train['images']) " + ] + }, + { + "cell_type": "markdown", + "id": "68f7055d-b2d6-4c2f-8671-8b31d4408336", + "metadata": {}, + "source": [ + "- train image는 4883개" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "27da9c0f-9630-4eec-8819-0809f7f1254c", + "metadata": {}, + "outputs": [], + "source": [ + "# 이미지 크기 체크\n", + "heights = [x['height'] for x in train['images']]\n", + "widths = [x['width'] for x in train['images']]" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "708e2b64-6447-4d51-aeae-e692a5af637b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'frequency')" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 2, figsize=(10, 4), tight_layout=True)\n", + "ax[0].hist(heights)\n", + "ax[0].set_xlabel('height [pixel]')\n", + "ax[0].set_ylabel('frequency')\n", + "ax[1].hist(widths)\n", + "ax[1].set_xlabel('width [pixel]')\n", + "ax[1].set_ylabel('frequency')" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "6cdaf44c-89df-4604-9f70-376fb15bf40f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{1024} {1024}\n" + ] + } + ], + "source": [ + "width, height = set(widths), set(heights)\n", + "print(width, height)" + ] + }, + { + "cell_type": "markdown", + "id": "c5de797c-053e-4c61-af7c-8fde2e80a016", + "metadata": {}, + "source": [ + "- 4883개 모든 이미지가 1024 $\\times$ 1024 크기이다." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "68eb6302-b68c-45e3-b8ea-bf5b39750db6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "23144\n" + ] + } + ], + "source": [ + "# bounding box의 개수 체크\n", + "print(len(train['annotations']))" + ] + }, + { + "cell_type": "markdown", + "id": "52a47fe1-53ce-490c-97a9-077a5349656b", + "metadata": {}, + "source": [ + "- 4883개의 학습 이미지에는 23144개의 bounding box (=쓰레기 객체)가 포함되어 있다." + ] + }, + { + "cell_type": "markdown", + "id": "74843f0e-8dea-4604-af65-8554dd494b7d", + "metadata": {}, + "source": [ + "### Bounding box analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "e58c9562-ec91-40d2-a5a0-dd6c697db097", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loading annotations into memory...\n", + "Done (t=0.16s)\n", + "creating index...\n", + "index created!\n" + ] + } + ], + "source": [ + "# convert json dictionary to pandas DataFrame\n", + "coco = COCO('./dataset/train.json')\n", + "\n", + "train_df = pd.DataFrame()\n", + "\n", + "image_ids = []\n", + "class_id = []\n", + "x_min = []\n", + "y_min = []\n", + "x_max = []\n", + "y_max = []\n", + "widths = []\n", + "heights = []\n", + "\n", + "for image_id in coco.getImgIds():\n", + " \n", + " image_info = coco.loadImgs(image_id)[0]\n", + " ann_ids = coco.getAnnIds(imgIds=image_info['id'])\n", + " anns = coco.loadAnns(ann_ids)\n", + " \n", + " file_name = image_info['file_name']\n", + " \n", + " for ann in anns:\n", + " image_ids.append(file_name)\n", + " class_id.append(ann['category_id'])\n", + " x_min.append(float(ann['bbox'][0]))\n", + " y_min.append(float(ann['bbox'][1]))\n", + " x_max.append(float(ann['bbox'][0]) + float(ann['bbox'][2]))\n", + " y_max.append(float(ann['bbox'][1]) + float(ann['bbox'][3]))\n", + " widths.append(float(ann['bbox'][2]))\n", + " heights.append(float(ann['bbox'][3]))\n", + " \n", + "train_df['image_id'] = image_ids\n", + "train_df['class_id'] = class_id\n", + "train_df['x_min'] = x_min\n", + "train_df['y_min'] = y_min\n", + "train_df['x_max'] = x_max\n", + "train_df['y_max'] = y_max\n", + "train_df['width'] = widths\n", + "train_df['height'] = heights" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "f19b0fe6-0332-40ea-b4ee-d7cb622c5fad", + "metadata": {}, + "outputs": [], + "source": [ + "# 이미지와 bbox를 눈으로 확인해보자\n", + "img43 = Image.open('./dataset/train/0043.jpg')\n", + "img43_list = train_df[train_df['image_id']=='train/0043.jpg']" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "a11f6fc6-610b-438f-a199-415ab73a1d23", + "metadata": {}, + "outputs": [], + "source": [ + "def draw_bbox(xmin, ymin, width, height, label=None, color='red', alpha=1):\n", + " #import matplotlib.patches as patches\n", + " bbox = patches.Rectangle((xmin, ymin), width, height, ec=color, fc='none', lw=2, label=label, alpha=alpha)\n", + " plt.gca().add_patch(bbox)\n", + "\n", + "def num_to_label(num):\n", + " return train['categories'][num]['name']" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "9f2581e5-11b8-47ac-9004-1614a224f53b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(img43)\n", + "plt.axis('off')\n", + "colors = ['red', 'green', 'blue']\n", + "for i, (index, x) in enumerate(img43_list.iterrows()):\n", + " draw_bbox(x['x_min'], x['y_min'], x['width'], x['height'], label=num_to_label(x['class_id']), color=colors[i]) \n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "7d5faf48-50e1-4654-8541-c0e6a3233d3c", + "metadata": {}, + "outputs": [], + "source": [ + "# 한 이미지에 얼마나 많은 bounding box들이 있을까?\n", + "count_bbox = train_df.image_id.value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "272d197b-dea1-494e-8a93-24a9ba0172d6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'frequency')" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(count_bbox, bins=np.arange(0, 80, 10), ec='white')\n", + "plt.yscale('log')\n", + "plt.xlabel('# of bboxes in one image')\n", + "plt.ylabel('frequency')" + ] + }, + { + "cell_type": "markdown", + "id": "ad6d8114-ce77-440f-afeb-a1705d2c6b81", + "metadata": {}, + "source": [ + "- 한 이미지 내에 bbox가 많다!" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "13b52087-74e1-4ecc-8137-079298efebe1", + "metadata": {}, + "outputs": [], + "source": [ + "has_one = count_bbox[count_bbox==1]\n", + "has_two = count_bbox[count_bbox==2]\n", + "has_three = count_bbox[count_bbox==3]\n", + "has_four = count_bbox[count_bbox==4]\n", + "has_five = count_bbox[count_bbox>=5] # over five" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "919cc73e-c05c-4e2f-a440-b448e115daa6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'number of bboxes in one image')" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "labels = ['1', '2', '3', '4', 'over 5']\n", + "num_of_bbox = [len(has_one)/len(train['images'])*100, len(has_two)/len(train['images'])*100, len(has_three)/len(train['images'])*100,\n", + " len(has_four)/len(train['images'])*100, len(has_five)/len(train['images'])*100]\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.pie(num_of_bbox,labels=labels, autopct='%1.1f%%', startangle=90) \n", + "plt.title('number of bboxes in one image')" + ] + }, + { + "cell_type": "markdown", + "id": "54b9c3dc-d836-4962-8fcf-136f63876ae8", + "metadata": {}, + "source": [ + "- 대부분(40.5%)의 이미지들이 bbox를 1개 포함하고 있다.\n", + "- 5개 이상의 bbox를 가진 이미지도 ~30%나 된다." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f4a4ef4e-2355-4391-8d33-f98b727a8b90", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'frequency')" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAGwCAYAAABIC3rIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA1tklEQVR4nO3de1xVBb7///eOm0CwExQ2HNFDSaZijWEhZGnjPS+Vc8aKQifNy0NTSc1yPHNiZgrKHqElJ1PHh9eMmpmc6cyZSOxCmTckKWUcL+V4BbHCDZiBwvr90bf1O1u8sA1Y4Ho9H4/1eLTX+uy938tHD/fbddnbYRiGIQAAABu7xuoAAAAAVqMQAQAA26MQAQAA26MQAQAA26MQAQAA26MQAQAA26MQAQAA2/O1OkBrUVdXp+PHjyskJEQOh8PqOAAAoAEMw1BlZaWio6N1zTUXPw5EIWqg48ePKyYmxuoYAADgChw5ckQdOnS46HYKUQOFhIRI+uEPNDQ01OI0AACgISoqKhQTE2N+jl8MhaiBfjxNFhoaSiECAKCVudzlLlxUDQAAbI9CBAAAbI9CBAAAbI9CBAAAbI9CBAAAbI9CBAAAbI9CBAAAbI9CBAAAbI9CBAAAbI9CBAAAbI9CBAAAbI9CBAAAbI9CBAAAbI9CBAAAbI9CBAAAbI9ChCtSW2dYHeGKtNbcAICm5Wt1ALROPtc4NCNnpw6UVVkdpcE6R1yrlx/saXUMAEALRCHCFTtQVqXi4xVWxwAA4CfjlBkAALA9ChEAALA9ChEAALA9ChEAALA9ChEAALA9ChEAALA9ChEAALA9ChEAALA9ChEAALA9ChEAALA9ChEAALA9ChEAALA9ChEAALA9ywvRsWPH9Mgjjyg8PFxBQUH62c9+psLCQnO7YRhKT09XdHS0AgMD1a9fPxUXF3u8RnV1taZNm6Z27dopODhYI0eO1NGjRz1mysvLlZqaKqfTKafTqdTUVJ06dao5dhEAALRwlhai8vJy3XHHHfLz89O7776rf/zjH3rppZd03XXXmTPz589XVlaWsrOzVVBQIJfLpYEDB6qystKcSUtL0/r165WTk6NNmzapqqpKw4cPV21trTmTkpKioqIi5ebmKjc3V0VFRUpNTW3O3QUAAC2UwzAMw6o3f/rpp/Xpp5/qk08+ueB2wzAUHR2ttLQ0PfXUU5J+OBoUGRmpF154QZMmTZLb7Vb79u21Zs0aPfDAA5Kk48ePKyYmRn//+981ePBg7dmzR926ddPWrVuVmJgoSdq6dauSkpL0z3/+U126dKn33tXV1aqurjYfV1RUKCYmRm63W6GhoY39R9EqDXvlExUfr7A6RoN1jw7V/06/0+oYAIBmVFFRIafTednPb0uPEL3zzjvq1auXfvnLXyoiIkI9e/bUsmXLzO0HDx5UaWmpBg0aZK4LCAhQ3759tXnzZklSYWGhzp496zETHR2t+Ph4c2bLli1yOp1mGZKk3r17y+l0mjPny8zMNE+vOZ1OxcTENOq+AwCAlsPSQvTVV19p8eLFiouL03vvvafJkydr+vTpWr16tSSptLRUkhQZGenxvMjISHNbaWmp/P391bZt20vORERE1Hv/iIgIc+Z8c+fOldvtNpcjR478tJ0FAAAtlq+Vb15XV6devXopIyNDktSzZ08VFxdr8eLFGjNmjDnncDg8nmcYRr115zt/5kLzl3qdgIAABQQENHhfAABA62XpEaKoqCh169bNY13Xrl11+PBhSZLL5ZKkekdxysrKzKNGLpdLNTU1Ki8vv+TMiRMn6r3/yZMn6x19AgAA9mNpIbrjjju0d+9ej3X79u1Tp06dJEmxsbFyuVzKy8szt9fU1Cg/P1/JycmSpISEBPn5+XnMlJSUaPfu3eZMUlKS3G63tm/fbs5s27ZNbrfbnAEAAPZl6SmzJ554QsnJycrIyNDo0aO1fft2LV26VEuXLpX0w2mutLQ0ZWRkKC4uTnFxccrIyFBQUJBSUlIkSU6nU+PHj9esWbMUHh6usLAwzZ49Wz169NCAAQMk/XDUaciQIZowYYKWLFkiSZo4caKGDx9+wTvMAACAvVhaiG677TatX79ec+fO1e9+9zvFxsZq4cKFevjhh82ZOXPm6MyZM5oyZYrKy8uVmJioDRs2KCQkxJxZsGCBfH19NXr0aJ05c0b9+/fXypUr5ePjY868/vrrmj59unk32siRI5Wdnd18OwsAAFosS7+HqDVp6PcY2AnfQwQAaOlaxfcQAQAAtAQUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgAAYHsUIgBAs6mtM6yO4LXWmBne87U6AADAPnyucWhGzk4dKKuyOkqDdI64Vi8/2NPqGGgGFCIAQLM6UFal4uMVVscAPHDKDAAA2B6FCAAA2B6FCAAA2J6lhSg9PV0Oh8Njcblc5nbDMJSenq7o6GgFBgaqX79+Ki4u9niN6upqTZs2Te3atVNwcLBGjhypo0ePesyUl5crNTVVTqdTTqdTqampOnXqVHPsIgAAaAUsP0LUvXt3lZSUmMuuXbvMbfPnz1dWVpays7NVUFAgl8ulgQMHqrKy0pxJS0vT+vXrlZOTo02bNqmqqkrDhw9XbW2tOZOSkqKioiLl5uYqNzdXRUVFSk1Nbdb9BAAALZfld5n5+vp6HBX6kWEYWrhwoebNm6dRo0ZJklatWqXIyEitW7dOkyZNktvt1vLly7VmzRoNGDBAkrR27VrFxMRo48aNGjx4sPbs2aPc3Fxt3bpViYmJkqRly5YpKSlJe/fuVZcuXZpvZwEAQItk+RGi/fv3Kzo6WrGxsXrwwQf11VdfSZIOHjyo0tJSDRo0yJwNCAhQ3759tXnzZklSYWGhzp496zETHR2t+Ph4c2bLli1yOp1mGZKk3r17y+l0mjMXUl1drYqKCo8FAABcnSwtRImJiVq9erXee+89LVu2TKWlpUpOTtY333yj0tJSSVJkZKTHcyIjI81tpaWl8vf3V9u2bS85ExERUe+9IyIizJkLyczMNK85cjqdiomJ+Un7CgAAWi5LC9HQoUP1i1/8Qj169NCAAQP0v//7v5J+ODX2I4fD4fEcwzDqrTvf+TMXmr/c68ydO1dut9tcjhw50qB9AgAArY/lp8z+r+DgYPXo0UP79+83rys6/yhOWVmZedTI5XKppqZG5eXll5w5ceJEvfc6efJkvaNP/1dAQIBCQ0M9FgAAcHVqUYWourpae/bsUVRUlGJjY+VyuZSXl2dur6mpUX5+vpKTkyVJCQkJ8vPz85gpKSnR7t27zZmkpCS53W5t377dnNm2bZvcbrc5AwAA7M3Su8xmz56tESNGqGPHjiorK9Ozzz6riooKjR07Vg6HQ2lpacrIyFBcXJzi4uKUkZGhoKAgpaSkSJKcTqfGjx+vWbNmKTw8XGFhYZo9e7Z5Ck6SunbtqiFDhmjChAlasmSJJGnixIkaPnw4d5gBAABJFheio0eP6qGHHtLXX3+t9u3bq3fv3tq6das6deokSZozZ47OnDmjKVOmqLy8XImJidqwYYNCQkLM11iwYIF8fX01evRonTlzRv3799fKlSvl4+Njzrz++uuaPn26eTfayJEjlZ2d3bw7CwAAWiyHYRiG1SFag4qKCjmdTrndbq4n+n+GvfJJq/rF6u7Rofrf6XdaHQOwvdb0dwd/b7R+Df38blHXEAEAAFiBQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyPQgQAAGyvxRSizMxMORwOpaWlmesMw1B6erqio6MVGBiofv36qbi42ON51dXVmjZtmtq1a6fg4GCNHDlSR48e9ZgpLy9XamqqnE6nnE6nUlNTderUqWbYKwAA0Bq0iEJUUFCgpUuX6uabb/ZYP3/+fGVlZSk7O1sFBQVyuVwaOHCgKisrzZm0tDStX79eOTk52rRpk6qqqjR8+HDV1taaMykpKSoqKlJubq5yc3NVVFSk1NTUZts/AADQslleiKqqqvTwww9r2bJlatu2rbneMAwtXLhQ8+bN06hRoxQfH69Vq1bpu+++07p16yRJbrdby5cv10svvaQBAwaoZ8+eWrt2rXbt2qWNGzdKkvbs2aPc3Fz94Q9/UFJSkpKSkrRs2TL97W9/0969ey3ZZwAA0LJYXoimTp2qYcOGacCAAR7rDx48qNLSUg0aNMhcFxAQoL59+2rz5s2SpMLCQp09e9ZjJjo6WvHx8ebMli1b5HQ6lZiYaM707t1bTqfTnLmQ6upqVVRUeCwAAODq5Gvlm+fk5Oizzz5TQUFBvW2lpaWSpMjISI/1kZGROnTokDnj7+/vcWTpx5kfn19aWqqIiIh6rx8REWHOXEhmZqZ++9vferdDAACgVbLsCNGRI0c0Y8YMrV27Vm3atLnonMPh8HhsGEa9dec7f+ZC85d7nblz58rtdpvLkSNHLvmeAACg9bKsEBUWFqqsrEwJCQny9fWVr6+v8vPz9corr8jX19c8MnT+UZyysjJzm8vlUk1NjcrLyy85c+LEiXrvf/LkyXpHn/6vgIAAhYaGeixNpbbOaLLXBgAAl2fZKbP+/ftr165dHuseffRR3XTTTXrqqad0/fXXy+VyKS8vTz179pQk1dTUKD8/Xy+88IIkKSEhQX5+fsrLy9Po0aMlSSUlJdq9e7fmz58vSUpKSpLb7db27dt1++23S5K2bdsmt9ut5OTk5trdS/K5xqEZOTt1oKzK6igN0q9Lez05+CarYwAA0GgsK0QhISGKj4/3WBccHKzw8HBzfVpamjIyMhQXF6e4uDhlZGQoKChIKSkpkiSn06nx48dr1qxZCg8PV1hYmGbPnq0ePXqYF2l37dpVQ4YM0YQJE7RkyRJJ0sSJEzV8+HB16dKlGff40g6UVan4eOu4cPuG9sFWRwAAoFF5XYgOHjyo2NjYpshSz5w5c3TmzBlNmTJF5eXlSkxM1IYNGxQSEmLOLFiwQL6+vho9erTOnDmj/v37a+XKlfLx8TFnXn/9dU2fPt28G23kyJHKzs5uln0AAAAtn9eFqHPnzrrrrrs0fvx4/cd//MclL4j21kcffeTx2OFwKD09Xenp6Rd9Tps2bbRo0SItWrToojNhYWFau3ZtI6UEAABXG68vqv7888/Vs2dPzZo1Sy6XS5MmTdL27dubIhsAAECz8LoQxcfHKysrS8eOHdOKFStUWlqqPn36qHv37srKytLJkyebIicAAECTueLb7n19fXX//ffrrbfe0gsvvKAvv/xSs2fPVocOHTRmzBiVlJQ0Zk4AAIAmc8WFaMeOHZoyZYqioqKUlZWl2bNn68svv9QHH3ygY8eO6d57723MnAAAAE3G64uqs7KytGLFCu3du1f33HOPVq9erXvuuUfXXPNDt4qNjdWSJUt00018Tw0AAGgdvC5Eixcv1rhx4/Too4/K5XJdcKZjx45avnz5Tw4HAADQHLwuRPv377/sjL+/v8aOHXtFgQAAAJqb19cQrVixQn/84x/rrf/jH/+oVatWNUooAACA5uR1IXr++efVrl27eusjIiKUkZHRKKEAAACak9eF6NChQxf86Y5OnTrp8OHDjRIKAACgOXldiCIiIvTFF1/UW//5558rPDy8UUIBAAA0J68L0YMPPqjp06frww8/VG1trWpra/XBBx9oxowZevDBB5siIwAAQJPy+i6zZ599VocOHVL//v3l6/vD0+vq6jRmzBiuIQIAAK2S14XI399fb775pn7/+9/r888/V2BgoHr06KFOnTo1RT4AAIAm53Uh+tGNN96oG2+8sTGzAAAAWMLrQlRbW6uVK1fq/fffV1lZmerq6jy2f/DBB40WDgAAoDl4XYhmzJihlStXatiwYYqPj5fD4WiKXAAAAM3G60KUk5Ojt956S/fcc09T5AEAAGh2Xt927+/vr86dOzdFFgAAAEt4XYhmzZqll19+WYZhNEUeAACAZuf1KbNNmzbpww8/1Lvvvqvu3bvLz8/PY/vbb7/daOEAAACag9eF6LrrrtP999/fFFkAAAAs4XUhWrFiRVPkAAAAsIzX1xBJ0rlz57Rx40YtWbJElZWVkqTjx4+rqqqqUcMBAAA0B6+PEB06dEhDhgzR4cOHVV1drYEDByokJETz58/X999/r9dee60pcgIAADQZr48QzZgxQ7169VJ5ebkCAwPN9ffff7/ef//9Rg0HAADQHK7oLrNPP/1U/v7+Hus7deqkY8eONVowAACA5uL1EaK6ujrV1tbWW3/06FGFhIQ0SigAAIDm5HUhGjhwoBYuXGg+djgcqqqq0jPPPMPPeQAAgFbJ61NmCxYs0N13361u3brp+++/V0pKivbv36927drpjTfeaIqMAAAATcrrQhQdHa2ioiK98cYb+uyzz1RXV6fx48fr4Ycf9rjIGgAAoLXwuhBJUmBgoMaNG6dx48Y1dh4AAIBm53UhWr169SW3jxkz5orDAAAAWMHrQjRjxgyPx2fPntV3330nf39/BQUFUYgAAECr4/VdZuXl5R5LVVWV9u7dqz59+nBRNQAAaJWu6LfMzhcXF6fnn3++3tEjAACA1qBRCpEk+fj46Pjx4431cgAAAM3G62uI3nnnHY/HhmGopKRE2dnZuuOOOxotGAAAQHPxuhDdd999Ho8dDofat2+vn//853rppZcaKxcAAECz8boQ1dXVNUUOAAAAyzTaNUQAAACtlddHiGbOnNng2aysLG9fHgAAoNl5XYh27typzz77TOfOnVOXLl0kSfv27ZOPj49uvfVWc87hcDReSgAAgCbkdSEaMWKEQkJCtGrVKrVt21bSD1/W+Oijj+rOO+/UrFmzGj0kAABAU/L6GqKXXnpJmZmZZhmSpLZt2+rZZ5/lLjMAANAqeV2IKioqdOLEiXrry8rKVFlZ6dVrLV68WDfffLNCQ0MVGhqqpKQkvfvuu+Z2wzCUnp6u6OhoBQYGql+/fiouLvZ4jerqak2bNk3t2rVTcHCwRo4cqaNHj3rMlJeXKzU1VU6nU06nU6mpqTp16pRXWQEAwNXL60J0//3369FHH9Wf/vQnHT16VEePHtWf/vQnjR8/XqNGjfLqtTp06KDnn39eO3bs0I4dO/Tzn/9c9957r1l65s+fr6ysLGVnZ6ugoEAul0sDBw70KF5paWlav369cnJytGnTJlVVVWn48OGqra01Z1JSUlRUVKTc3Fzl5uaqqKhIqamp3u46AAC4Snl9DdFrr72m2bNn65FHHtHZs2d/eBFfX40fP14vvviiV681YsQIj8fPPfecFi9erK1bt6pbt25auHCh5s2bZxatVatWKTIyUuvWrdOkSZPkdru1fPlyrVmzRgMGDJAkrV27VjExMdq4caMGDx6sPXv2KDc3V1u3blViYqIkadmyZUpKStLevXvNC8PPV11drerqavNxRUWFV/sGAABaD6+PEAUFBenVV1/VN998Y95x9u233+rVV19VcHDwFQepra1VTk6OTp8+raSkJB08eFClpaUaNGiQORMQEKC+fftq8+bNkqTCwkKdPXvWYyY6Olrx8fHmzJYtW+R0Os0yJEm9e/eW0+k0Zy4kMzPTPMXmdDoVExNzxfsGAABativ+YsaSkhKVlJToxhtvVHBwsAzDuKLX2bVrl6699loFBARo8uTJWr9+vbp166bS0lJJUmRkpMd8ZGSkua20tFT+/v4eF3hfaCYiIqLe+0ZERJgzFzJ37ly53W5zOXLkyBXtHwAAaPm8PmX2zTffaPTo0frwww/lcDi0f/9+XX/99Xrsscd03XXXeX2nWZcuXVRUVKRTp07pz3/+s8aOHav8/Hxz+/nfZ2QYxmW/4+j8mQvNX+51AgICFBAQ0NDdAAAArZjXR4ieeOIJ+fn56fDhwwoKCjLXP/DAA8rNzfU6gL+/vzp37qxevXopMzNTt9xyi15++WW5XC5JqncUp6yszDxq5HK5VFNTo/Ly8kvOXOiuuJMnT9Y7+gQAAOzJ60K0YcMGvfDCC+rQoYPH+ri4OB06dOgnBzIMQ9XV1YqNjZXL5VJeXp65raamRvn5+UpOTpYkJSQkyM/Pz2OmpKREu3fvNmeSkpLkdru1fft2c2bbtm1yu93mDADU1l3ZaX8rtcbMQEvl9Smz06dPexwZ+tHXX3/t9SmmX//61xo6dKhiYmJUWVmpnJwcffTRR8rNzZXD4VBaWpoyMjIUFxenuLg4ZWRkKCgoSCkpKZIkp9Op8ePHa9asWQoPD1dYWJhmz56tHj16mHedde3aVUOGDNGECRO0ZMkSSdLEiRM1fPjwi95hBsB+fK5xaEbOTh0oq7I6SoN0jrhWLz/Y0+oYwFXD60J01113afXq1fr9738v6Yfrc+rq6vTiiy/q7rvv9uq1Tpw4odTUVJWUlMjpdOrmm29Wbm6uBg4cKEmaM2eOzpw5oylTpqi8vFyJiYnasGGDQkJCzNdYsGCBfH19NXr0aJ05c0b9+/fXypUr5ePjY868/vrrmj59unk32siRI5Wdne3trgO4yh0oq1Lxcb5iA7AjrwvRiy++qH79+mnHjh2qqanRnDlzVFxcrG+//VaffvqpV6+1fPnyS253OBxKT09Xenr6RWfatGmjRYsWadGiRRedCQsL09q1a73KBgAA7MPra4i6deumL774QrfffrsGDhyo06dPa9SoUdq5c6duuOGGpsgIAADQpLw6QvTjlyAuWbJEv/3tb5sqEwAAQLPy6giRn5+fdu/efdnvAQIAAGhNvD5lNmbMmMte+wMAANCaeH1RdU1Njf7whz8oLy9PvXr1qvf7ZVlZWY0WDgAAoDk0qBB98cUXio+P1zXXXKPdu3fr1ltvlSTt27fPY45TaQAAoDVqUCHq2bOnSkpKFBERoUOHDqmgoEDh4eFNnQ0AAKBZNOgaouuuu04HDx6UJP3rX/9SXV1dk4YCAABoTg06QvSLX/xCffv2VVRUlBwOh3r16uXxTdD/11dffdWoAQEAAJpagwrR0qVLNWrUKB04cEDTp0/XhAkTPH4+AwAAoDVr8F1mQ4YMkSQVFhZqxowZFCIAAHDV8Pq2+xUrVjRFDgAAAMt4/cWMAAAAVxsKEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD0KEQAAsD1LC1FmZqZuu+02hYSEKCIiQvfdd5/27t3rMWMYhtLT0xUdHa3AwED169dPxcXFHjPV1dWaNm2a2rVrp+DgYI0cOVJHjx71mCkvL1dqaqqcTqecTqdSU1N16tSppt5FAADQClhaiPLz8zV16lRt3bpVeXl5OnfunAYNGqTTp0+bM/Pnz1dWVpays7NVUFAgl8ulgQMHqrKy0pxJS0vT+vXrlZOTo02bNqmqqkrDhw9XbW2tOZOSkqKioiLl5uYqNzdXRUVFSk1Nbdb9BQAALZOvlW+em5vr8XjFihWKiIhQYWGh7rrrLhmGoYULF2revHkaNWqUJGnVqlWKjIzUunXrNGnSJLndbi1fvlxr1qzRgAEDJElr165VTEyMNm7cqMGDB2vPnj3Kzc3V1q1blZiYKElatmyZkpKStHfvXnXp0qV5dxwAALQoLeoaIrfbLUkKCwuTJB08eFClpaUaNGiQORMQEKC+fftq8+bNkqTCwkKdPXvWYyY6Olrx8fHmzJYtW+R0Os0yJEm9e/eW0+k0Z85XXV2tiooKjwUAAFydWkwhMgxDM2fOVJ8+fRQfHy9JKi0tlSRFRkZ6zEZGRprbSktL5e/vr7Zt215yJiIiot57RkREmDPny8zMNK83cjqdiomJ+Wk7CAAAWqwWU4gef/xxffHFF3rjjTfqbXM4HB6PDcOot+58589caP5SrzN37ly53W5zOXLkSEN2AwAAtEItohBNmzZN77zzjj788EN16NDBXO9yuSSp3lGcsrIy86iRy+VSTU2NysvLLzlz4sSJeu978uTJekeffhQQEKDQ0FCPBQAAXJ0sLUSGYejxxx/X22+/rQ8++ECxsbEe22NjY+VyuZSXl2euq6mpUX5+vpKTkyVJCQkJ8vPz85gpKSnR7t27zZmkpCS53W5t377dnNm2bZvcbrc5AwAA7MvSu8ymTp2qdevW6a9//atCQkLMI0FOp1OBgYFyOBxKS0tTRkaG4uLiFBcXp4yMDAUFBSklJcWcHT9+vGbNmqXw8HCFhYVp9uzZ6tGjh3nXWdeuXTVkyBBNmDBBS5YskSRNnDhRw4cP5w4zAABgbSFavHixJKlfv34e61esWKFf/epXkqQ5c+bozJkzmjJlisrLy5WYmKgNGzYoJCTEnF+wYIF8fX01evRonTlzRv3799fKlSvl4+Njzrz++uuaPn26eTfayJEjlZ2d3bQ7CAAAWgVLC5FhGJedcTgcSk9PV3p6+kVn2rRpo0WLFmnRokUXnQkLC9PatWuvJCYAALjKtYiLqgEAAKxEIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQIAALZHIQKAVqj9tQGqrTOsjgFcNXytDgAA8F5ooK98rnFoRs5OHSirsjpOg/Tr0l5PDr7J6hjABVGIAKAVO1BWpeLjFVbHaJAb2gdbHQG4KE6ZAQAA26MQAQAA26MQAQAA26MQAQAA26MQAQAA26MQAQAA26MQAQAA26MQAQAA27O0EH388ccaMWKEoqOj5XA49Je//MVju2EYSk9PV3R0tAIDA9WvXz8VFxd7zFRXV2vatGlq166dgoODNXLkSB09etRjpry8XKmpqXI6nXI6nUpNTdWpU6eaeO8AAEBrYWkhOn36tG655RZlZ2dfcPv8+fOVlZWl7OxsFRQUyOVyaeDAgaqsrDRn0tLStH79euXk5GjTpk2qqqrS8OHDVVtba86kpKSoqKhIubm5ys3NVVFRkVJTU5t8/wAAQOtg6U93DB06VEOHDr3gNsMwtHDhQs2bN0+jRo2SJK1atUqRkZFat26dJk2aJLfbreXLl2vNmjUaMGCAJGnt2rWKiYnRxo0bNXjwYO3Zs0e5ubnaunWrEhMTJUnLli1TUlKS9u7dqy5dulzw/aurq1VdXW0+rqhoHV+NDwAAvNdiryE6ePCgSktLNWjQIHNdQECA+vbtq82bN0uSCgsLdfbsWY+Z6OhoxcfHmzNbtmyR0+k0y5Ak9e7dW06n05y5kMzMTPMUm9PpVExMTGPvIgAAaCFabCEqLS2VJEVGRnqsj4yMNLeVlpbK399fbdu2veRMREREvdePiIgwZy5k7ty5crvd5nLkyJGftD+AndTWGVZHAACvtPhfu3c4HB6PDcOot+58589caP5yrxMQEKCAgAAv0wKQJJ9rHJqRs1MHyqqsjtIg/bq015ODb7I6BgALtdhC5HK5JP1whCcqKspcX1ZWZh41crlcqqmpUXl5ucdRorKyMiUnJ5szJ06cqPf6J0+erHf0CUDjOVBWpeLjrePauxvaB1sdAYDFWuwps9jYWLlcLuXl5ZnrampqlJ+fb5adhIQE+fn5ecyUlJRo9+7d5kxSUpLcbre2b99uzmzbtk1ut9ucAVoyTj8BQNOz9AhRVVWVDhw4YD4+ePCgioqKFBYWpo4dOyotLU0ZGRmKi4tTXFycMjIyFBQUpJSUFEmS0+nU+PHjNWvWLIWHhyssLEyzZ89Wjx49zLvOunbtqiFDhmjChAlasmSJJGnixIkaPnz4Re8wA1oSTj8BQNOztBDt2LFDd999t/l45syZkqSxY8dq5cqVmjNnjs6cOaMpU6aovLxciYmJ2rBhg0JCQsznLFiwQL6+vho9erTOnDmj/v37a+XKlfLx8TFnXn/9dU2fPt28G23kyJEX/e4jXL3aXxug2jpDPtdc+hq0lojTTwDQtCwtRP369ZNhXPx0gMPhUHp6utLT0y8606ZNGy1atEiLFi266ExYWJjWrl37U6LiKhAa6MvRFgDABbXYi6qBpsLRFgDA+VrsRdUAAADNhUIEAABsj0IEAABsj0IEAABsj0IEAABsj0IEAABsj0IEAABsj0IEAABsj0IEAABsj0IEAABsj0IEAABsj0IEAABsj0IEAABsj0IEAABsj0IEAABsj0IEAABsj0IEAABsj0IEAABsj0IEAABsj0IEAABsj0IEAABsj0IEAMBVprbOsDqC16zO7GvpuwMAgEbnc41DM3J26kBZldVRGqRzxLV6+cGelmagEAEAcBU6UFal4uMVVsdoNThlBgAAbI9CBAAAbI9CBAAAbI9CBAAAbI9CBAAAbI9CBAAAbI9CBAAAbI9CBAAAbI9CBAAAbI9CBAAAbI9CBAAAbI9CBAAAbI9CBAAAbI9CBAAAbI9CBADARbS/NkC1dYbVMdAMfK0OAABASxUa6CufaxyakbNTB8qqrI7TIP26tNeTg2+yOkarQyECAOAyDpRVqfh4hdUxGuSG9sFWR2iVOGUGAABsj0IEAABsz1aF6NVXX1VsbKzatGmjhIQEffLJJ1ZHAgAALYBtCtGbb76ptLQ0zZs3Tzt37tSdd96poUOH6vDhw1ZHAwAAFrNNIcrKytL48eP12GOPqWvXrlq4cKFiYmK0ePFiq6MBAACL2eIus5qaGhUWFurpp5/2WD9o0CBt3rz5gs+prq5WdXW1+djtdkuSKiqa5i6DmGuls2E+TfLaja19QJ0qKipaVWapdeYmc/Mgc/Mgc/NojZljrm26z9cfX9cwLvN9UoYNHDt2zJBkfPrppx7rn3vuOePGG2+84HOeeeYZQxILCwsLCwvLVbAcOXLkkl3BFkeIfuRwODweG4ZRb92P5s6dq5kzZ5qP6+rq9O233yo8PPyiz7kSFRUViomJ0ZEjRxQaGtpor9uUWmNmqXXmJnPzIHPzIHPzILMnwzBUWVmp6OjoS87ZohC1a9dOPj4+Ki0t9VhfVlamyMjICz4nICBAAQEBHuuuu+66poqo0NDQVvM/7o9aY2apdeYmc/Mgc/Mgc/Mg8//P6XRedsYWF1X7+/srISFBeXl5Huvz8vKUnJxsUSoAANBS2OIIkSTNnDlTqamp6tWrl5KSkrR06VIdPnxYkydPtjoaAACwmG0K0QMPPKBvvvlGv/vd71RSUqL4+Hj9/e9/V6dOnSzNFRAQoGeeeabe6bmWrDVmllpnbjI3DzI3DzI3DzJfGYdhXO4+NAAAgKubLa4hAgAAuBQKEQAAsD0KEQAAsD0KEQAAsD0KkcVeffVVxcbGqk2bNkpISNAnn3xidaRL+vjjjzVixAhFR0fL4XDoL3/5i9WRLikzM1O33XabQkJCFBERofvuu0979+61OtYlLV68WDfffLP5BWVJSUl69913rY7llczMTDkcDqWlpVkd5aLS09PlcDg8FpfLZXWsyzp27JgeeeQRhYeHKygoSD/72c9UWFhodaxL+vd///d6f9YOh0NTp061OtpFnTt3Tv/5n/+p2NhYBQYG6vrrr9fvfvc71dXVWR3tkiorK5WWlqZOnTopMDBQycnJKigosDqW6XKfIYZhKD09XdHR0QoMDFS/fv1UXFzcLNkoRBZ68803lZaWpnnz5mnnzp268847NXToUB0+fNjqaBd1+vRp3XLLLcrOzrY6SoPk5+dr6tSp2rp1q/Ly8nTu3DkNGjRIp0+ftjraRXXo0EHPP/+8duzYoR07dujnP/+57r333mb7S+GnKigo0NKlS3XzzTdbHeWyunfvrpKSEnPZtWuX1ZEuqby8XHfccYf8/Pz07rvv6h//+IdeeumlJv0W/cZQUFDg8ef845fk/vKXv7Q42cW98MILeu2115Sdna09e/Zo/vz5evHFF7Vo0SKro13SY489pry8PK1Zs0a7du3SoEGDNGDAAB07dszqaJIu/xkyf/58ZWVlKTs7WwUFBXK5XBo4cKAqKyubPlxj/Hgqrsztt99uTJ482WPdTTfdZDz99NMWJfKOJGP9+vVWx/BKWVmZIcnIz8+3OopX2rZta/zhD3+wOsZlVVZWGnFxcUZeXp7Rt29fY8aMGVZHuqhnnnnGuOWWW6yO4ZWnnnrK6NOnj9UxfrIZM2YYN9xwg1FXV2d1lIsaNmyYMW7cOI91o0aNMh555BGLEl3ed999Z/j4+Bh/+9vfPNbfcsstxrx58yxKdXHnf4bU1dUZLpfLeP75581133//veF0Oo3XXnutyfNwhMgiNTU1Kiws1KBBgzzWDxo0SJs3b7Yo1dXP7XZLksLCwixO0jC1tbXKycnR6dOnlZSUZHWcy5o6daqGDRumAQMGWB2lQfbv36/o6GjFxsbqwQcf1FdffWV1pEt655131KtXL/3yl79URESEevbsqWXLllkdyys1NTVau3atxo0b16g/lN3Y+vTpo/fff1/79u2TJH3++efatGmT7rnnHouTXdy5c+dUW1urNm3aeKwPDAzUpk2bLErVcAcPHlRpaanH52JAQID69u3bLJ+Ltvmm6pbm66+/Vm1tbb0fl42MjKz3I7RoHIZhaObMmerTp4/i4+OtjnNJu3btUlJSkr7//ntde+21Wr9+vbp162Z1rEvKycnRZ5991qKuV7iUxMRErV69WjfeeKNOnDihZ599VsnJySouLlZ4eLjV8S7oq6++0uLFizVz5kz9+te/1vbt2zV9+nQFBARozJgxVsdrkL/85S86deqUfvWrX1kd5ZKeeuopud1u3XTTTfLx8VFtba2ee+45PfTQQ1ZHu6iQkBAlJSXp97//vbp27arIyEi98cYb2rZtm+Li4qyOd1k/fvZd6HPx0KFDTf7+FCKLnf8vJMMwWvS/mlqzxx9/XF988UWr+JdSly5dVFRUpFOnTunPf/6zxo4dq/z8/BZbio4cOaIZM2Zow4YN9f512lINHTrU/O8ePXooKSlJN9xwg1atWqWZM2damOzi6urq1KtXL2VkZEiSevbsqeLiYi1evLjVFKLly5dr6NChio6OtjrKJb355ptau3at1q1bp+7du6uoqEhpaWmKjo7W2LFjrY53UWvWrNG4ceP0b//2b/Lx8dGtt96qlJQUffbZZ1ZHazCrPhcpRBZp166dfHx86h0NKisrq9eO8dNNmzZN77zzjj7++GN16NDB6jiX5e/vr86dO0uSevXqpYKCAr388stasmSJxckurLCwUGVlZUpISDDX1dbW6uOPP1Z2draqq6vl4+NjYcLLCw4OVo8ePbR//36ro1xUVFRUvVLctWtX/fnPf7YokXcOHTqkjRs36u2337Y6ymU9+eSTevrpp/Xggw9K+qE0Hzp0SJmZmS26EN1www3Kz8/X6dOnVVFRoaioKD3wwAOKjY21Otpl/XiXZ2lpqaKiosz1zfW5yDVEFvH391dCQoJ5t8WP8vLylJycbFGqq49hGHr88cf19ttv64MPPmgVfylciGEYqq6utjrGRfXv31+7du1SUVGRufTq1UsPP/ywioqKWnwZkqTq6mrt2bPH4y/iluaOO+6o97UR+/bts/xHqhtqxYoVioiI0LBhw6yOclnfffedrrnG8yPSx8enxd92/6Pg4GBFRUWpvLxc7733nu69916rI11WbGysXC6Xx+diTU2N8vPzm+VzkSNEFpo5c6ZSU1PVq1cvJSUlaenSpTp8+LAmT55sdbSLqqqq0oEDB8zHBw8eVFFRkcLCwtSxY0cLk13Y1KlTtW7dOv31r39VSEiIeUTO6XQqMDDQ4nQX9utf/1pDhw5VTEyMKisrlZOTo48++ki5ublWR7uokJCQetdlBQcHKzw8vMVerzV79myNGDFCHTt2VFlZmZ599llVVFS06H/9P/HEE0pOTlZGRoZGjx6t7du3a+nSpVq6dKnV0S6rrq5OK1as0NixY+Xr2/I/ekaMGKHnnntOHTt2VPfu3bVz505lZWVp3LhxVke7pPfee0+GYahLly46cOCAnnzySXXp0kWPPvqo1dEkXf4zJC0tTRkZGYqLi1NcXJwyMjIUFBSklJSUpg/X5Pex4ZL++7//2+jUqZPh7+9v3HrrrS3+dvAPP/zQkFRvGTt2rNXRLuhCWSUZK1assDraRY0bN878f6J9+/ZG//79jQ0bNlgdy2st/bb7Bx54wIiKijL8/PyM6OhoY9SoUUZxcbHVsS7rf/7nf4z4+HgjICDAuOmmm4ylS5daHalB3nvvPUOSsXfvXqujNEhFRYUxY8YMo2PHjkabNm2M66+/3pg3b55RXV1tdbRLevPNN43rr7/e8Pf3N1wulzF16lTj1KlTVscyXe4zpK6uznjmmWcMl8tlBAQEGHfddZexa9euZsnmMAzDaPraBQAA0HJxDREAALA9ChEAALA9ChEAALA9ChEAALA9ChEAALA9ChEAALA9ChEAALA9ChEAALA9ChGAq9q//vUvORwOFRUVWR0FQAtGIQIAALZHIQIAALZHIQJwVairq9MLL7ygzp07KyAgQB07dtRzzz1Xb662tlbjx49XbGysAgMD1aVLF7388sseMx999JFuv/12BQcH67rrrtMdd9yhQ4cOSZI+//xz3X333QoJCVFoaKgSEhK0Y8eOZtlHAE3H1+oAANAY5s6dq2XLlmnBggXq06ePSkpK9M9//rPeXF1dnTp06KC33npL7dq10+bNmzVx4kRFRUVp9OjROnfunO677z5NmDBBb7zxhmpqarR9+3Y5HA5J0sMPP6yePXtq8eLF8vHxUVFRkfz8/Jp7dwE0Mn7tHkCrV1lZqfbt2ys7O1uPPfaYx7Z//etfio2N1c6dO/Wzn/3sgs+fOnWqTpw4oT/96U/69ttvFR4ero8++kh9+/atNxsaGqpFixZp7NixTbErACzCKTMArd6ePXtUXV2t/v37N2j+tddeU69evdS+fXtde+21WrZsmQ4fPixJCgsL069+9SsNHjxYI0aM0Msvv6ySkhLzuTNnztRjjz2mAQMG6Pnnn9eXX37ZJPsEoHlRiAC0eoGBgQ2efeutt/TEE09o3Lhx2rBhg4qKivToo4+qpqbGnFmxYoW2bNmi5ORkvfnmm7rxxhu1detWSVJ6erqKi4s1bNgwffDBB+rWrZvWr1/f6PsEoHlxygxAq/f9998rLCxMr7zyymVPmU2bNk3/+Mc/9P7775szAwYM0Ndff33R7ypKSkrSbbfdpldeeaXetoceekinT5/WO++806j7BKB5cYQIQKvXpk0bPfXUU5ozZ45Wr16tL7/8Ulu3btXy5cvrzXbu3Fk7duzQe++9p3379uk3v/mNCgoKzO0HDx7U3LlztWXLFh06dEgbNmzQvn371LVrV505c0aPP/64PvroIx06dEiffvqpCgoK1LVr1+bcXQBNgLvMAFwVfvOb38jX11f/9V//pePHjysqKkqTJ0+uNzd58mQVFRXpgQcekMPh0EMPPaQpU6bo3XfflSQFBQXpn//8p1atWqVvvvlGUVFRevzxxzVp0iSdO3dO33zzjcaMGaMTJ06oXbt2GjVqlH7729829+4CaGScMgMAALbHKTMAAGB7FCIAAGB7FCIAAGB7FCIAAGB7FCIAAGB7FCIAAGB7FCIAAGB7FCIAAGB7FCIAAGB7FCIAAGB7FCIAAGB7/x8t3GMzkQ7oUwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# class imbalance 체크\n", + "plt.hist(train_df['class_id'], bins=np.arange(0, 11, 1), ec='white')\n", + "plt.xticks(np.arange(0, 11, 1))\n", + "plt.xlabel('class')\n", + "plt.ylabel('frequency')" + ] + }, + { + "cell_type": "markdown", + "id": "beb6653e-b852-4828-80d3-d36752c255f4", + "metadata": {}, + "source": [ + "- class imbalance가 보임\n", + "- 일반 쓰레기, 종이, 플라스틱, 비닐봉지는 상대적으로 많지만 그 외 (종이팩, 철, 유리, 스티로폼, 배터리, 의류)는 수가 적음" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "id": "c2bd9940-011f-4ad4-a149-585c0efd5394", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# bbox area distribution\n", + "area = train_df['width']*train_df['height']\n", + "areaby106 = [x/10**6 for x in area]\n", + "train_df['area'] = areaby106 # DataFrame에 넓이 정보 추가\n", + "\n", + "plt.hist(areaby106, bins=np.arange(0, 1.2, 0.1), ec='white')\n", + "plt.xlabel('area of bounding box [$10^6$]')\n", + "plt.ylabel('frequency')\n", + "plt.yscale('log')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "53cf8e4e-efc3-4463-bb2b-eb180a17d514", + "metadata": {}, + "outputs": [], + "source": [ + "# bbox area distribution by class" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "id": "cce7cab6-1224-4749-9eae-9fedcf6554a5", + "metadata": {}, + "outputs": [], + "source": [ + "# 클래스별로 데이터 분리\n", + "for i in range(10):\n", + " globals()['class{}'.format(i)] = train_df[train_df['class_id']==i]" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "id": "edd7ccce-33bb-43e2-aeb1-50698ce18337", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(2, 5, figsize=(24, 8), tight_layout=True)\n", + "\n", + "for i, ax in enumerate(axes.flat):\n", + " ax.hist(globals()['class{}'.format(i)]['area'], bins=np.arange(0, 1.2, 0.1), ec='white')\n", + " ax.set_xlabel('area of bounding box [$10^6$]')\n", + " ax.set_ylabel('frequency')\n", + " ax.set_yscale('log')\n", + " ax.set_title(num_to_label(i))" + ] + }, + { + "cell_type": "markdown", + "id": "8daec77e-9836-4f62-a161-d59852556050", + "metadata": {}, + "source": [ + "- 클래스 별 area 분포가 대체로 비슷하지만 특이사항을 꼽자면 배터리의 area가 작고, 의류가 크다." + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "id": "bdb77983-0ff1-4340-98d0-b4952224cf65", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/f6/gvt0g3yj5239r97qmydnwbsc0000gn/T/ipykernel_47732/1858640043.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " globals()['class{}'.format(i)]['ratio'] = ratio_list\n" + ] + } + ], + "source": [ + "# 클래스 별 bbox의 가로세로 비\n", + "for i in range(10):\n", + " ratio_list = globals()['class{}'.format(i)]['height']/globals()['class{}'.format(i)]['width']\n", + " globals()['class{}'.format(i)]['ratio'] = ratio_list" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "id": "9f5a834a-03da-436a-a0b6-698e1d00b824", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(2, 5, figsize=(24, 8), tight_layout=True)\n", + "\n", + "for i, ax in enumerate(axes.flat):\n", + " #maxratio = max(globals()['class{}'.format(i)]['ratio'])\n", + " #ax.hist(globals()['class{}'.format(i)]['ratio'], bins=np.arange(0, maxratio+0.5, 0.5), ec='white')\n", + " ax.hist(globals()['class{}'.format(i)]['ratio'], bins=np.arange(0, 18, 0.5), ec='white')\n", + " ax.set_xlabel('bbox aspect ratio [height/width]')\n", + " ax.set_ylabel('frequency')\n", + " ax.set_yscale('log')\n", + " ax.set_title(num_to_label(i))" + ] + }, + { + "cell_type": "markdown", + "id": "b9e97b08-b076-4c62-9d3c-38bddbf8d216", + "metadata": {}, + "source": [ + "- 클래스 불문 정사각형에 가까운 bbox가 가장 많음\n", + "- 유리가 대체로 길쭉한 bbox를 가지는 경우가 많아 보임\n", + "- 일반 쓰레기, 종이, 비닐봉지가 큰 aspect ratio를 가지는 비율이 크며, 배터리, 종이팩이 큰 aspect ratio를 가지는 비율이 적어 보임" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "f1054e48-6f8a-4b35-b16b-fa07451a0e3d", + "metadata": {}, + "outputs": [], + "source": [ + "# 이미지 내에서 bbox의 위치 (클래스 별)\n", + "background = np.ones((1024, 1024), dtype=np.int8)" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "id": "33ff5092-f2fc-4b6f-9ae1-957df1c9db89", + "metadata": {}, + "outputs": [], + "source": [ + "def draw_bbox1(xmin, ymin, width, height, label=None, color='red', alpha=1):\n", + " #import matplotlib.patches as patches\n", + " bbox = patches.Rectangle((xmin, ymin), width, height, ec=color, fc='none', lw=2, label=label, alpha=alpha)\n", + " ax.add_patch(bbox)" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "id": "af9c5805-bf41-4af1-8ff1-357af997f87e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 클래스 별 이미지 내 bbox 위치 분포\n", + "fig, axes = plt.subplots(2, 5, figsize=(20, 8))\n", + "\n", + "for i, ax in enumerate(axes.flat):\n", + " ax.imshow(background)\n", + " ax.set_title(num_to_label(i))\n", + " ax.axis('off')\n", + " for j, x in globals()['class{}'.format(i)].iterrows():\n", + " draw_bbox1(x['x_min'], x['y_min'], x['width'], x['height'], alpha=0.02)" + ] + }, + { + "cell_type": "markdown", + "id": "4d1f907e-c2df-4127-84a2-5f7d99c283f3", + "metadata": {}, + "source": [ + "- 클래스 별 경향성이 보인다기보다 꽤 넓은 범위에 걸쳐 나타나며, 대체로 중간에 위치하는 듯함" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/EDA/heatmap.png b/EDA/heatmap.png new file mode 100644 index 00000000..23ba195b Binary files /dev/null and b/EDA/heatmap.png differ diff --git a/README.md b/README.md new file mode 100644 index 00000000..fefa36ce --- /dev/null +++ b/README.md @@ -0,0 +1,173 @@ +# 재활용 품목 분류를 위한 Object Detection + +## 🥇 팀 구성원 + + + +
+ +## 🗒️ 프로젝트 개요 + +바야흐로 대량 생산, 대량 소비의 시대. 우리는 많은 물건이 대량으로 생산되고, 소비되는 시대를 살고 있습니다. 하지만 이러한 문화는 '쓰레기 대란', '매립지 부족'과 같은 여러 사회 문제를 낳고 있습니다. + +분리수거는 이러한 환경 부담을 줄일 수 있는 방법 중 하나입니다. 잘 분리배출 된 쓰레기는 자원으로서 가치를 인정받아 재활용되지만, 잘못 분리배출 되면 그대로 폐기물로 분류되어 매립 또는 소각되기 때문입니다. + +따라서 우리는 사진에서 쓰레기를 Detection 하는 모델을 만들어 이러한 문제점을 해결해보고자 합니다. 문제 해결을 위한 데이터셋으로는 일반 쓰레기, 플라스틱, 종이, 유리 등 10 종류의 쓰레기가 찍힌 사진 데이터셋이 제공됩니다. + +여러분에 의해 만들어진 우수한 성능의 모델은 쓰레기장에 설치되어 정확한 분리수거를 돕거나, 어린아이들의 분리수거 교육 등에 사용될 수 있을 것입니다. 부디 지구를 위기로부터 구해주세요! 🌎 + + +
+ +## 📅 프로젝트 일정 + +프로젝트 전체 일정 + +- 2024.09.30 (월) 10:00 ~ 2024.10.24 (목) 19:00 + +![image](https://github.com/user-attachments/assets/e6d03619-fe9b-4b14-8266-e169c765f9a0) + + +## 💻 개발 환경 + +```bash +- Language : Python +- Environment + - CPU : Intel(R) Xeon(R) Gold 5120 + - GPU : Tesla V100-SXM2 32GB × 1 +- Framework : PyTorch +- Collaborative Tool : Git, Wandb, Notion +``` + +## 🏆 프로젝트 결과 + +- Public 1등, Private 1등 + + ![image](https://github.com/user-attachments/assets/4956fa94-51b7-498a-b8c8-4cc7dd8cea33) + +## ✏️ Wrap-Up Report + +- 프로젝트의 전반적인 내용은 아래 랩업 리포트를 참고 바랍니다. +- [Wrap-Up Report](https://drive.google.com/file/d/13dfWdaCJQfc2CzF-bT4asWYKytZWTk9m/view?usp=sharing) + +## 📁 데이터셋 구조 + +``` +📦data + ┣ 📜train.json + ┣ 📜test.json + ┃ + ┣ 📂test + ┃ ┣ 📜0000.JPG + ┃ ┣ 📜0001.JPG + ┃ ┣ 📜0002.JPG + ┃ ┗ ... + ┣ 📂train + ┃ ┣ 📜0000.JPG + ┃ ┣ 📜0001.JPG + ┃ ┣ 📜0002.JPG + ┃ ┗ ... +``` + +- 학습에 사용할 이미지는 4,883개, 추론에 사용할 이미지는 4,871개로 각각 data/train/, data/test 아래에 저장되어 있습니다. +- 제공되는 이미지 데이터셋은 10개 클래스의 쓰레기가 찍힌 1024 x 1024 크기의 사진으로 구성되어 있습니다. +- train.json과 test.json은 coco format으로 된 각 이미지에 대한 annotation file 입니다. + +
+ +## 📁 프로젝트 구조 + +``` +📦level2-objectdetection-cv-05 + ┣ 📂.github + ┃ ┗ 📜.keep + ┣ 📂EDA + ┃ ┣ 📜EDA.ipynb + ┃ ┣ 📜heatmap.png + ┣ 📂mmdetection + ┃ ┣ 📜Co-detr + ┃ ┃ ┗ 📜co-detrl.py + ┃ ┣ 📜DiNO + ┃ ┃ ┗ 📜dino_Swin_L_baseline.py + ┃ ┣ 📜_base_ + ┃ ┃ ┗ 📜default_dataset.py + ┃ ┃ ┗ 📜default_multi_dataset.py + ┃ ┃ ┗ 📜simple_augmentation_dataset.py + ┃ ┃ ┗ 📜heavy_augmentation_dataset.py + ┃ ┃ ┗ 📜lsj_mosaic_augmentation_dataset.py + ┃ ┃ ┗ 📜default_runtime.py + ┃ ┃ ┗ 📜default_tta.py + ┃ ┣ 📜cascade-RCNN + ┃ ┃ ┗ 📜cascade-rcbb_convnextV2.py + ┃ ┃ ┗ 📜cascade-rcnn_swin_L.py + ┃ ┣ 📜ddq + ┃ ┃ ┗ 📜ddq_swinl.py + ┣ 📂utils + ┃ ┣ 📜SR_X2_preprocessing + ┃ ┃ ┗ 📜4_crop.ipynb + ┃ ┃ ┗ 📜5_random.ipynb + ┃ ┃ ┗ 📜Update_json.ipynb + ┃ ┣ 📜mmdetection + ┃ ┃ ┗ 📜inference.py + ┃ ┃ ┗ 📜inference_mmdet_v2.py + ┃ ┃ ┗ 📜train.py + ┃ ┣ 📜MultiLabelStratifiedKFold_COCO.py + ┃ ┣ 📜Pascal_to_coco.ipynb + ┃ ┣ 📜StratifiedKFold_COCO.py + ┃ ┣ 📜emsemble.py + ┗ ┗ 📜inference_visualizer.py + +``` +
+ +## 🧱 Structure + +![image](https://github.com/user-attachments/assets/b2e1d2b4-822e-4a39-86b1-97319114f8c8) + +- CO-DETR + DDQ-DETR + Cascade R-CNN + YOLO(emsemble) 모델 사용 + + + + + +
diff --git a/mmdetection/.circleci/config.yml b/mmdetection/.circleci/config.yml new file mode 100644 index 00000000..1a24b82d --- /dev/null +++ b/mmdetection/.circleci/config.yml @@ -0,0 +1,34 @@ +version: 2.1 + +# this allows you to use CircleCI's dynamic configuration feature +setup: true + +# the path-filtering orb is required to continue a pipeline based on +# the path of an updated fileset +orbs: + path-filtering: circleci/path-filtering@0.1.2 + +workflows: + # the always-run workflow is always triggered, regardless of the pipeline parameters. + always-run: + jobs: + # the path-filtering/filter job determines which pipeline + # parameters to update. + - path-filtering/filter: + name: check-updated-files + # 3-column, whitespace-delimited mapping. One mapping per + # line: + # + mapping: | + mmdet/.* lint_only false + requirements/.* lint_only false + tests/.* lint_only false + tools/.* lint_only false + configs/.* lint_only false + .circleci/.* lint_only false + base-revision: dev-3.x + # this is the path of the configuration we should trigger once + # path filtering and pipeline parameter value updates are + # complete. In this case, we are using the parent dynamic + # configuration itself. + config-path: .circleci/test.yml diff --git a/mmdetection/.circleci/docker/Dockerfile b/mmdetection/.circleci/docker/Dockerfile new file mode 100644 index 00000000..d9cf8cc7 --- /dev/null +++ b/mmdetection/.circleci/docker/Dockerfile @@ -0,0 +1,11 @@ +ARG PYTORCH="1.8.1" +ARG CUDA="10.2" +ARG CUDNN="7" + +FROM pytorch/pytorch:${PYTORCH}-cuda${CUDA}-cudnn${CUDNN}-devel + +# To fix GPG key error when running apt-get update +RUN apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/3bf863cc.pub +RUN apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64/7fa2af80.pub + +RUN apt-get update && apt-get install -y ninja-build libglib2.0-0 libsm6 libxrender-dev libxext6 libgl1-mesa-glx diff --git a/mmdetection/.circleci/test.yml b/mmdetection/.circleci/test.yml new file mode 100644 index 00000000..e5e14d3d --- /dev/null +++ b/mmdetection/.circleci/test.yml @@ -0,0 +1,210 @@ +version: 2.1 + +# the default pipeline parameters, which will be updated according to +# the results of the path-filtering orb +parameters: + lint_only: + type: boolean + default: true + +jobs: + lint: + docker: + - image: cimg/python:3.7.4 + steps: + - checkout + - run: + name: Install pre-commit hook + command: | + pip install pre-commit + pre-commit install + - run: + name: Linting + command: pre-commit run --all-files + - run: + name: Check docstring coverage + command: | + pip install interrogate + interrogate -v --ignore-init-method --ignore-module --ignore-nested-functions --ignore-magic --ignore-regex "__repr__" --fail-under 85 mmdet + + build_cpu: + parameters: + # The python version must match available image tags in + # https://circleci.com/developer/images/image/cimg/python + python: + type: string + torch: + type: string + torchvision: + type: string + docker: + - image: cimg/python:<< parameters.python >> + resource_class: large + steps: + - checkout + - run: + name: Install Libraries + command: | + sudo apt-get update + sudo apt-get install -y ninja-build libglib2.0-0 libsm6 libxrender-dev libxext6 libgl1-mesa-glx libjpeg-dev zlib1g-dev libtinfo-dev libncurses5 + - run: + name: Configure Python & pip + command: | + pip install --upgrade pip + pip install wheel + - run: + name: Install PyTorch + command: | + python -V + python -m pip install torch==<< parameters.torch >>+cpu torchvision==<< parameters.torchvision >>+cpu -f https://download.pytorch.org/whl/torch_stable.html + - when: + condition: + equal: ["3.9.0", << parameters.python >>] + steps: + - run: pip install "protobuf <= 3.20.1" && sudo apt-get update && sudo apt-get -y install libprotobuf-dev protobuf-compiler cmake + - run: pip install dsdl + - run: + name: Install mmdet dependencies + # numpy may be downgraded after building pycocotools, which causes `ImportError: numpy.core.multiarray failed to import` + # force reinstall pycocotools to ensure pycocotools being built under the currenct numpy + command: | + python -m pip install git+ssh://git@github.com/open-mmlab/mmengine.git@main + pip install -U openmim + mim install 'mmcv >= 2.0.0rc4' + pip install -r requirements/tests.txt -r requirements/optional.txt + pip install --force-reinstall pycocotools + pip install albumentations>=0.3.2 --no-binary imgaug,albumentations + pip install -r requirements/tracking.txt + pip install git+https://github.com/cocodataset/panopticapi.git + pip install git+https://github.com/JonathonLuiten/TrackEval.git + - run: + name: Build and install + command: | + pip install -e . + - run: + name: Run unittests + command: | + python -m coverage run --branch --source mmdet -m pytest tests/ + python -m coverage xml + python -m coverage report -m + + build_cuda: + parameters: + torch: + type: string + cuda: + type: enum + enum: ["11.1", "11.7", "11.8"] + cudnn: + type: integer + default: 8 + machine: + image: linux-cuda-11:default + # docker_layer_caching: true + resource_class: gpu.nvidia.small.multi + steps: + - checkout + - run: + # CLoning repos in VM since Docker doesn't have access to the private key + name: Clone Repos + command: | + git clone -b main --depth 1 ssh://git@github.com/open-mmlab/mmengine.git /home/circleci/mmengine + - run: + name: Install nvidia-container-toolkit and Restart Docker + command: | + sudo apt-get update + sudo apt-get install -y nvidia-container-toolkit + sudo systemctl restart docker + - run: + name: Build Docker image + command: | + docker build .circleci/docker -t mmdetection:gpu --build-arg PYTORCH=<< parameters.torch >> --build-arg CUDA=<< parameters.cuda >> --build-arg CUDNN=<< parameters.cudnn >> + docker run --gpus all -t -d -v /home/circleci/project:/mmdetection -v /home/circleci/mmengine:/mmengine -w /mmdetection --name mmdetection mmdetection:gpu + docker exec mmdetection apt-get install -y git + - run: + name: Install mmdet dependencies + command: | + docker exec mmdetection pip install -e /mmengine + docker exec mmdetection pip install -U openmim + docker exec mmdetection mim install 'mmcv >= 2.0.0rc4' + docker exec mmdetection pip install -r requirements/tests.txt -r requirements/optional.txt + docker exec mmdetection pip install pycocotools + docker exec mmdetection pip install albumentations>=0.3.2 --no-binary imgaug,albumentations + docker exec mmdetection pip install -r requirements/tracking.txt + docker exec mmdetection pip install git+https://github.com/cocodataset/panopticapi.git + docker exec mmdetection pip install git+https://github.com/JonathonLuiten/TrackEval.git + docker exec mmdetection python -c 'import mmcv; print(mmcv.__version__)' + - run: + name: Build and install + command: | + docker exec mmdetection pip install -e . + - run: + name: Run unittests + command: | + docker exec mmdetection python -m pytest tests/ + +workflows: + pr_stage_lint: + when: << pipeline.parameters.lint_only >> + jobs: + - lint: + name: lint + filters: + branches: + ignore: + - dev-3.x + pr_stage_test: + when: + not: << pipeline.parameters.lint_only >> + jobs: + - lint: + name: lint + filters: + branches: + ignore: + - dev-3.x + - build_cpu: + name: minimum_version_cpu + torch: 1.8.0 + torchvision: 0.9.0 + python: 3.7.16 + requires: + - lint + - build_cpu: + name: maximum_version_cpu + torch: 2.0.0 + torchvision: 0.15.1 + python: 3.9.0 + requires: + - minimum_version_cpu + - hold: + type: approval + requires: + - maximum_version_cpu + - build_cuda: + name: mainstream_version_gpu + torch: 1.8.1 + # Use double quotation mark to explicitly specify its type + # as string instead of number + cuda: "11.1" + requires: + - hold + - build_cuda: + name: maximum_version_gpu + torch: 2.0.0 + cuda: "11.7" + cudnn: 8 + requires: + - hold + merge_stage_test: + when: + not: << pipeline.parameters.lint_only >> + jobs: + - build_cuda: + name: minimum_version_gpu + torch: 1.8.0 + cuda: "11.1" + filters: + branches: + only: + - dev-3.x diff --git a/mmdetection/.dev_scripts/batch_test_list.py b/mmdetection/.dev_scripts/batch_test_list.py new file mode 100644 index 00000000..b28d4034 --- /dev/null +++ b/mmdetection/.dev_scripts/batch_test_list.py @@ -0,0 +1,545 @@ +# Copyright (c) OpenMMLab. All rights reserved. + +# missing wider_face/timm_example/strong_baselines/simple_copy_paste/ +# selfsup_pretrain/seesaw_loss/pascal_voc/openimages/lvis/ld/lad/cityscapes/deepfashion + +# yapf: disable +atss = dict( + config='configs/atss/atss_r50_fpn_1x_coco.py', + checkpoint='atss_r50_fpn_1x_coco_20200209-985f7bd0.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/atss/atss_r50_fpn_1x_coco/atss_r50_fpn_1x_coco_20200209-985f7bd0.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=39.4), +) +autoassign = dict( + config='configs/autoassign/autoassign_r50-caffe_fpn_1x_coco.py', + checkpoint='auto_assign_r50_fpn_1x_coco_20210413_115540-5e17991f.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/autoassign/auto_assign_r50_fpn_1x_coco/auto_assign_r50_fpn_1x_coco_20210413_115540-5e17991f.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=40.4), +) +carafe = dict( + config='configs/carafe/faster-rcnn_r50_fpn-carafe_1x_coco.py', + checkpoint='faster_rcnn_r50_fpn_carafe_1x_coco_bbox_mAP-0.386_20200504_175733-385a75b7.pth', # noqa + url='https://download.openmmlab.com/mmdetection/v2.0/carafe/faster_rcnn_r50_fpn_carafe_1x_coco/faster_rcnn_r50_fpn_carafe_1x_coco_bbox_mAP-0.386_20200504_175733-385a75b7.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=38.6), +) +cascade_rcnn = [ + dict( + config='configs/cascade_rcnn/cascade-rcnn_r50_fpn_1x_coco.py', + checkpoint='cascade_rcnn_r50_fpn_1x_coco_20200316-3dc56deb.pth', + eval='bbox', + url='https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r50_fpn_1x_coco/cascade_rcnn_r50_fpn_1x_coco_20200316-3dc56deb.pth', # noqa + metric=dict(bbox_mAP=40.3), + ), + dict( + config='configs/cascade_rcnn/cascade-mask-rcnn_r50_fpn_1x_coco.py', + checkpoint='cascade_mask_rcnn_r50_fpn_1x_coco_20200203-9d4dcb24.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco/cascade_mask_rcnn_r50_fpn_1x_coco_20200203-9d4dcb24.pth', # noqa + eval=['bbox', 'segm'], + metric=dict(bbox_mAP=41.2, segm_mAP=35.9), + ), +] +cascade_rpn = dict( + config='configs/cascade_rpn/cascade-rpn_faster-rcnn_r50-caffe_fpn_1x_coco.py', # noqa + checkpoint='crpn_faster_rcnn_r50_caffe_fpn_1x_coco-c8283cca.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/cascade_rpn/crpn_faster_rcnn_r50_caffe_fpn_1x_coco/crpn_faster_rcnn_r50_caffe_fpn_1x_coco-c8283cca.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=40.4), +) +centernet = dict( + config='configs/centernet/centernet_r18-dcnv2_8xb16-crop512-140e_coco.py', + checkpoint='centernet_resnet18_dcnv2_140e_coco_20210702_155131-c8cd631f.pth', # noqa + url='https://download.openmmlab.com/mmdetection/v2.0/centernet/centernet_resnet18_dcnv2_140e_coco/centernet_resnet18_dcnv2_140e_coco_20210702_155131-c8cd631f.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=29.5), +) +centripetalnet = dict( + config='configs/centripetalnet/centripetalnet_hourglass104_16xb6-crop511-210e-mstest_coco.py', # noqa + checkpoint='centripetalnet_hourglass104_mstest_16x6_210e_coco_20200915_204804-3ccc61e5.pth', # noqa + url='https://download.openmmlab.com/mmdetection/v2.0/centripetalnet/centripetalnet_hourglass104_mstest_16x6_210e_coco/centripetalnet_hourglass104_mstest_16x6_210e_coco_20200915_204804-3ccc61e5.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=44.7), +) +convnext = dict( + config='configs/convnext/cascade-mask-rcnn_convnext-s-p4-w7_fpn_4conv1fc-giou_amp-ms-crop-3x_coco.py', # noqa + checkpoint='cascade_mask_rcnn_convnext-s_p4_w7_fpn_giou_4conv1f_fp16_ms-crop_3x_coco_20220510_201004-3d24f5a4.pth', # noqa + url='https://download.openmmlab.com/mmdetection/v2.0/convnext/cascade_mask_rcnn_convnext-s_p4_w7_fpn_giou_4conv1f_fp16_ms-crop_3x_coco/cascade_mask_rcnn_convnext-s_p4_w7_fpn_giou_4conv1f_fp16_ms-crop_3x_coco_20220510_201004-3d24f5a4.pth', # noqa + eval=['bbox', 'segm'], + metric=dict(bbox_mAP=51.8, segm_mAP=44.8), +) +cornernet = dict( + config='configs/cornernet/cornernet_hourglass104_8xb6-210e-mstest_coco.py', + checkpoint='cornernet_hourglass104_mstest_8x6_210e_coco_20200825_150618-79b44c30.pth', # noqa + url='https://download.openmmlab.com/mmdetection/v2.0/cornernet/cornernet_hourglass104_mstest_8x6_210e_coco/cornernet_hourglass104_mstest_8x6_210e_coco_20200825_150618-79b44c30.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=41.2), +) +dcn = dict( + config='configs/dcn/faster-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py', + checkpoint='faster_rcnn_r50_fpn_dconv_c3-c5_1x_coco_20200130-d68aed1e.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/dcn/faster_rcnn_r50_fpn_dconv_c3-c5_1x_coco/faster_rcnn_r50_fpn_dconv_c3-c5_1x_coco_20200130-d68aed1e.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=41.3), +) +dcnv2 = dict( + config='configs/dcnv2/faster-rcnn_r50_fpn_mdpool_1x_coco.py', + checkpoint='faster_rcnn_r50_fpn_mdpool_1x_coco_20200307-c0df27ff.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/dcn/faster_rcnn_r50_fpn_mdpool_1x_coco/faster_rcnn_r50_fpn_mdpool_1x_coco_20200307-c0df27ff.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=38.7), +) +ddod = dict( + config='configs/ddod/ddod_r50_fpn_1x_coco.py', + checkpoint='ddod_r50_fpn_1x_coco_20220523_223737-29b2fc67.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/ddod/ddod_r50_fpn_1x_coco/ddod_r50_fpn_1x_coco_20220523_223737-29b2fc67.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=41.7), +) +deformable_detr = dict( + config='configs/deformable_detr/deformable-detr_r50_16xb2-50e_coco.py', + checkpoint='deformable_detr_r50_16x2_50e_coco_20210419_220030-a12b9512.pth', # noqa + url='https://download.openmmlab.com/mmdetection/v2.0/deformable_detr/deformable_detr_r50_16x2_50e_coco/deformable_detr_r50_16x2_50e_coco_20210419_220030-a12b9512.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=44.5), +) +detectors = dict( + config='configs/detectors/detectors_htc-r50_1x_coco.py', + checkpoint='detectors_htc_r50_1x_coco-329b1453.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/detectors/detectors_htc_r50_1x_coco/detectors_htc_r50_1x_coco-329b1453.pth', # noqa + eval=['bbox', 'segm'], + metric=dict(bbox_mAP=49.1, segm_mAP=42.6), +) +detr = dict( + config='configs/detr/detr_r50_8xb2-150e_coco.py', + checkpoint='detr_r50_8x2_150e_coco_20201130_194835-2c4b8974.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/detr/detr_r50_8x2_150e_coco/detr_r50_8x2_150e_coco_20201130_194835-2c4b8974.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=40.1), +) +double_heads = dict( + config='configs/double_heads/dh-faster-rcnn_r50_fpn_1x_coco.py', + checkpoint='dh_faster_rcnn_r50_fpn_1x_coco_20200130-586b67df.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/double_heads/dh_faster_rcnn_r50_fpn_1x_coco/dh_faster_rcnn_r50_fpn_1x_coco_20200130-586b67df.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=40.0), +) +dyhead = dict( + config='configs/dyhead/atss_r50_fpn_dyhead_1x_coco.py', + checkpoint='atss_r50_fpn_dyhead_4x4_1x_coco_20211219_023314-eaa620c6.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/dyhead/atss_r50_fpn_dyhead_4x4_1x_coco/atss_r50_fpn_dyhead_4x4_1x_coco_20211219_023314-eaa620c6.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=43.3), +) +dynamic_rcnn = dict( + config='configs/dynamic_rcnn/dynamic-rcnn_r50_fpn_1x_coco.py', + checkpoint='dynamic_rcnn_r50_fpn_1x-62a3f276.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/dynamic_rcnn/dynamic_rcnn_r50_fpn_1x/dynamic_rcnn_r50_fpn_1x-62a3f276.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=38.9), +) +efficientnet = dict( + config='configs/efficientnet/retinanet_effb3_fpn_8xb4-crop896-1x_coco.py', + checkpoint='retinanet_effb3_fpn_crop896_8x4_1x_coco_20220322_234806-615a0dda.pth', # noqa + url='https://download.openmmlab.com/mmdetection/v2.0/efficientnet/retinanet_effb3_fpn_crop896_8x4_1x_coco/retinanet_effb3_fpn_crop896_8x4_1x_coco_20220322_234806-615a0dda.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=40.5), +) +empirical_attention = dict( + config='configs/empirical_attention/faster-rcnn_r50-attn1111_fpn_1x_coco.py', # noqa + checkpoint='faster_rcnn_r50_fpn_attention_1111_1x_coco_20200130-403cccba.pth', # noqa + url='https://download.openmmlab.com/mmdetection/v2.0/empirical_attention/faster_rcnn_r50_fpn_attention_1111_1x_coco/faster_rcnn_r50_fpn_attention_1111_1x_coco_20200130-403cccba.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=40.0), +) +faster_rcnn = dict( + config='configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py', + checkpoint='faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=37.4), +) +fcos = dict( + config='configs/fcos/fcos_r50-caffe_fpn_gn-head-center-normbbox-centeronreg-giou_1x_coco.py', # noqa + checkpoint='fcos_center-normbbox-centeronreg-giou_r50_caffe_fpn_gn-head_1x_coco-0a0d75a8.pth', # noqa + url='https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_center-normbbox-centeronreg-giou_r50_caffe_fpn_gn-head_1x_coco/fcos_center-normbbox-centeronreg-giou_r50_caffe_fpn_gn-head_1x_coco-0a0d75a8.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=38.7), +) +foveabox = dict( + config='configs/foveabox/fovea_r50_fpn_gn-head-align_4xb4-2x_coco.py', + checkpoint='fovea_align_r50_fpn_gn-head_4x4_2x_coco_20200203-8987880d.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_align_r50_fpn_gn-head_4x4_2x_coco/fovea_align_r50_fpn_gn-head_4x4_2x_coco_20200203-8987880d.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=37.9), +) +fpg = dict( + config='configs/fpg/mask-rcnn_r50_fpg_crop640-50e_coco.py', + checkpoint='mask_rcnn_r50_fpg_crop640_50e_coco_20220311_011857-233b8334.pth', # noqa + url='https://download.openmmlab.com/mmdetection/v2.0/fpg/mask_rcnn_r50_fpg_crop640_50e_coco/mask_rcnn_r50_fpg_crop640_50e_coco_20220311_011857-233b8334.pth', # noqa + eval=['bbox', 'segm'], + metric=dict(bbox_mAP=43.0, segm_mAP=38.1), +) +free_anchor = dict( + config='configs/free_anchor/freeanchor_r50_fpn_1x_coco.py', + checkpoint='retinanet_free_anchor_r50_fpn_1x_coco_20200130-0f67375f.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/free_anchor/retinanet_free_anchor_r50_fpn_1x_coco/retinanet_free_anchor_r50_fpn_1x_coco_20200130-0f67375f.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=38.7), +) +fsaf = dict( + config='configs/fsaf/fsaf_r50_fpn_1x_coco.py', + checkpoint='fsaf_r50_fpn_1x_coco-94ccc51f.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/fsaf/fsaf_r50_fpn_1x_coco/fsaf_r50_fpn_1x_coco-94ccc51f.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=37.4), +) +gcnet = dict( + config='configs/gcnet/mask-rcnn_r50-syncbn-gcb-r16-c3-c5_fpn_1x_coco.py', # noqa + checkpoint='mask_rcnn_r50_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco_20200202-587b99aa.pth', # noqa + url='https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r50_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco/mask_rcnn_r50_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco_20200202-587b99aa.pth', # noqa + eval=['bbox', 'segm'], + metric=dict(bbox_mAP=40.4, segm_mAP=36.2), +) +gfl = dict( + config='configs/gfl/gfl_r50_fpn_1x_coco.py', + checkpoint='gfl_r50_fpn_1x_coco_20200629_121244-25944287.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/gfl/gfl_r50_fpn_1x_coco/gfl_r50_fpn_1x_coco_20200629_121244-25944287.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=40.2), +) +ghm = dict( + config='configs/ghm/retinanet_r50_fpn_ghm-1x_coco.py', + checkpoint='retinanet_ghm_r50_fpn_1x_coco_20200130-a437fda3.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/ghm/retinanet_ghm_r50_fpn_1x_coco/retinanet_ghm_r50_fpn_1x_coco_20200130-a437fda3.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=37.0), +) +gn = dict( + config='configs/gn/mask-rcnn_r50_fpn_gn-all_2x_coco.py', + checkpoint='mask_rcnn_r50_fpn_gn-all_2x_coco_20200206-8eee02a6.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r50_fpn_gn-all_2x_coco/mask_rcnn_r50_fpn_gn-all_2x_coco_20200206-8eee02a6.pth', # noqa + eval=['bbox', 'segm'], + metric=dict(bbox_mAP=40.1, segm_mAP=36.4), +) +gn_ws = dict( + config='configs/gn+ws/faster-rcnn_r50_fpn_gn-ws-all_1x_coco.py', + checkpoint='faster_rcnn_r50_fpn_gn_ws-all_1x_coco_20200130-613d9fe2.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/faster_rcnn_r50_fpn_gn_ws-all_1x_coco/faster_rcnn_r50_fpn_gn_ws-all_1x_coco_20200130-613d9fe2.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=39.7), +) +grid_rcnn = dict( + config='configs/grid_rcnn/grid-rcnn_r50_fpn_gn-head_2x_coco.py', + checkpoint='grid_rcnn_r50_fpn_gn-head_2x_coco_20200130-6cca8223.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/grid_rcnn/grid_rcnn_r50_fpn_gn-head_2x_coco/grid_rcnn_r50_fpn_gn-head_2x_coco_20200130-6cca8223.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=40.4), +) +groie = dict( + config='configs/groie/faste-rcnn_r50_fpn_groie_1x_coco.py', + checkpoint='faster_rcnn_r50_fpn_groie_1x_coco_20200604_211715-66ee9516.pth', # noqa + url='https://download.openmmlab.com/mmdetection/v2.0/groie/faster_rcnn_r50_fpn_groie_1x_coco/faster_rcnn_r50_fpn_groie_1x_coco_20200604_211715-66ee9516.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=38.3), +) +guided_anchoring = dict( + config='configs/guided_anchoring/ga-retinanet_r50-caffe_fpn_1x_coco.py', # noqa + checkpoint='ga_retinanet_r50_caffe_fpn_1x_coco_20201020-39581c6f.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_retinanet_r50_caffe_fpn_1x_coco/ga_retinanet_r50_caffe_fpn_1x_coco_20201020-39581c6f.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=36.9), + ) +hrnet = dict( + config='configs/hrnet/faster-rcnn_hrnetv2p-w18-1x_coco.py', + checkpoint='faster_rcnn_hrnetv2p_w18_1x_coco_20200130-56651a6d.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/hrnet/faster_rcnn_hrnetv2p_w18_1x_coco/faster_rcnn_hrnetv2p_w18_1x_coco_20200130-56651a6d.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=36.9), +) +htc = dict( + config='configs/htc/htc_r50_fpn_1x_coco.py', + checkpoint='htc_r50_fpn_1x_coco_20200317-7332cf16.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/htc/htc_r50_fpn_1x_coco/htc_r50_fpn_1x_coco_20200317-7332cf16.pth', # noqa + eval=['bbox', 'segm'], + metric=dict(bbox_mAP=42.3, segm_mAP=37.4), +) +instaboost = dict( + config='configs/instaboost/mask-rcnn_r50_fpn_instaboost-4x_coco.py', + checkpoint='mask_rcnn_r50_fpn_instaboost_4x_coco_20200307-d025f83a.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/instaboost/mask_rcnn_r50_fpn_instaboost_4x_coco/mask_rcnn_r50_fpn_instaboost_4x_coco_20200307-d025f83a.pth', # noqa + eval=['bbox', 'segm'], + metric=dict(bbox_mAP=40.6, segm_mAP=36.6), +) +libra_rcnn = dict( + config='configs/libra_rcnn/libra-faster-rcnn_r50_fpn_1x_coco.py', + checkpoint='libra_faster_rcnn_r50_fpn_1x_coco_20200130-3afee3a9.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/libra_rcnn/libra_faster_rcnn_r50_fpn_1x_coco/libra_faster_rcnn_r50_fpn_1x_coco_20200130-3afee3a9.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=38.3), +) +mask2former = dict( + config='configs/mask2former/mask2former_r50_8xb2-lsj-50e_coco-panoptic.py', + checkpoint='mask2former_r50_lsj_8x2_50e_coco-panoptic_20220326_224516-11a44721.pth', # noqa + url='https://download.openmmlab.com/mmdetection/v2.0/mask2former/mask2former_r50_lsj_8x2_50e_coco-panoptic/mask2former_r50_lsj_8x2_50e_coco-panoptic_20220326_224516-11a44721.pth', # noqa + eval=['bbox', 'segm', 'PQ'], + metric=dict(PQ=51.9, bbox_mAP=44.8, segm_mAP=41.9), +) +mask_rcnn = dict( + config='configs/mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py', + checkpoint='mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_fpn_1x_coco/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth', # noqa + eval=['bbox', 'segm'], + metric=dict(bbox_mAP=38.2, segm_mAP=34.7), +) +maskformer = dict( + config='configs/maskformer/maskformer_r50_ms-16xb1-75e_coco.py', + checkpoint='maskformer_r50_mstrain_16x1_75e_coco_20220221_141956-bc2699cb.pth', # noqa + url='https://download.openmmlab.com/mmdetection/v2.0/maskformer/maskformer_r50_mstrain_16x1_75e_coco/maskformer_r50_mstrain_16x1_75e_coco_20220221_141956-bc2699cb.pth', # noqa + eval='PQ', + metric=dict(PQ=46.9), +) +ms_rcnn = dict( + config='configs/ms_rcnn/ms-rcnn_r50-caffe_fpn_1x_coco.py', + checkpoint='ms_rcnn_r50_caffe_fpn_1x_coco_20200702_180848-61c9355e.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/ms_rcnn/ms_rcnn_r50_caffe_fpn_1x_coco/ms_rcnn_r50_caffe_fpn_1x_coco_20200702_180848-61c9355e.pth', # noqa + eval=['bbox', 'segm'], + metric=dict(bbox_mAP=38.2, segm_mAP=36.0), +) +nas_fcos = dict( + config='configs/nas_fcos/nas-fcos_r50-caffe_fpn_nashead-gn-head_4xb4-1x_coco.py', # noqa + checkpoint='nas_fcos_nashead_r50_caffe_fpn_gn-head_4x4_1x_coco_20200520-1bdba3ce.pth', # noqa + url='https://download.openmmlab.com/mmdetection/v2.0/nas_fcos/nas_fcos_nashead_r50_caffe_fpn_gn-head_4x4_1x_coco/nas_fcos_nashead_r50_caffe_fpn_gn-head_4x4_1x_coco_20200520-1bdba3ce.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=39.4), +) +nas_fpn = dict( + config='configs/nas_fpn/retinanet_r50_nasfpn_crop640-50e_coco.py', + checkpoint='retinanet_r50_nasfpn_crop640_50e_coco-0ad1f644.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/nas_fpn/retinanet_r50_nasfpn_crop640_50e_coco/retinanet_r50_nasfpn_crop640_50e_coco-0ad1f644.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=40.5), +) +paa = dict( + config='configs/paa/paa_r50_fpn_1x_coco.py', + checkpoint='paa_r50_fpn_1x_coco_20200821-936edec3.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r50_fpn_1x_coco/paa_r50_fpn_1x_coco_20200821-936edec3.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=40.4), +) +pafpn = dict( + config='configs/pafpn/faster-rcnn_r50_pafpn_1x_coco.py', + checkpoint='faster_rcnn_r50_pafpn_1x_coco_bbox_mAP-0.375_20200503_105836-b7b4b9bd.pth', # noqa + url='https://download.openmmlab.com/mmdetection/v2.0/pafpn/faster_rcnn_r50_pafpn_1x_coco/faster_rcnn_r50_pafpn_1x_coco_bbox_mAP-0.375_20200503_105836-b7b4b9bd.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=37.5), +) +panoptic_fpn = dict( + config='configs/panoptic_fpn/panoptic-fpn_r50_fpn_1x_coco.py', + checkpoint='panoptic_fpn_r50_fpn_1x_coco_20210821_101153-9668fd13.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/panoptic_fpn/panoptic_fpn_r50_fpn_1x_coco/panoptic_fpn_r50_fpn_1x_coco_20210821_101153-9668fd13.pth', # noqa + eval='PQ', + metric=dict(PQ=40.2), +) +pisa = dict( + config='configs/pisa/faster-rcnn_r50_fpn_pisa_1x_coco.py', + checkpoint='pisa_faster_rcnn_r50_fpn_1x_coco-dea93523.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/pisa/pisa_faster_rcnn_r50_fpn_1x_coco/pisa_faster_rcnn_r50_fpn_1x_coco-dea93523.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=38.4), +) +point_rend = dict( + config='configs/point_rend/point-rend_r50-caffe_fpn_ms-1x_coco.py', + checkpoint='point_rend_r50_caffe_fpn_mstrain_1x_coco-1bcb5fb4.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/point_rend/point_rend_r50_caffe_fpn_mstrain_1x_coco/point_rend_r50_caffe_fpn_mstrain_1x_coco-1bcb5fb4.pth', # noqa + eval=['bbox', 'segm'], + metric=dict(bbox_mAP=38.4, segm_mAP=36.3), +) +pvt = dict( + config='configs/pvt/retinanet_pvt-s_fpn_1x_coco.py', + checkpoint='retinanet_pvt-s_fpn_1x_coco_20210906_142921-b6c94a5b.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvt-s_fpn_1x_coco/retinanet_pvt-s_fpn_1x_coco_20210906_142921-b6c94a5b.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=40.4), +) +queryinst = dict( + config='configs/queryinst/queryinst_r50_fpn_1x_coco.py', + checkpoint='queryinst_r50_fpn_1x_coco_20210907_084916-5a8f1998.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/queryinst/queryinst_r50_fpn_1x_coco/queryinst_r50_fpn_1x_coco_20210907_084916-5a8f1998.pth', # noqa + eval=['bbox', 'segm'], + metric=dict(bbox_mAP=42.0, segm_mAP=37.5), +) +regnet = dict( + config='configs/regnet/mask-rcnn_regnetx-3.2GF_fpn_1x_coco.py', + checkpoint='mask_rcnn_regnetx-3.2GF_fpn_1x_coco_20200520_163141-2a9d1814.pth', # noqa + url='https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-3.2GF_fpn_1x_coco/mask_rcnn_regnetx-3.2GF_fpn_1x_coco_20200520_163141-2a9d1814.pth', # noqa + eval=['bbox', 'segm'], + metric=dict(bbox_mAP=40.4, segm_mAP=36.7), +) +reppoints = dict( + config='configs/reppoints/reppoints-moment_r50_fpn_1x_coco.py', + checkpoint='reppoints_moment_r50_fpn_1x_coco_20200330-b73db8d1.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r50_fpn_1x_coco/reppoints_moment_r50_fpn_1x_coco_20200330-b73db8d1.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=37.0), +) +res2net = dict( + config='configs/res2net/faster-rcnn_res2net-101_fpn_2x_coco.py', + checkpoint='faster_rcnn_r2_101_fpn_2x_coco-175f1da6.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/res2net/faster_rcnn_r2_101_fpn_2x_coco/faster_rcnn_r2_101_fpn_2x_coco-175f1da6.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=43.0), +) +resnest = dict( + config='configs/resnest/faster-rcnn_s50_fpn_syncbn-backbone+head_ms-range-1x_coco.py', # noqa + checkpoint='faster_rcnn_s50_fpn_syncbn-backbone+head_mstrain-range_1x_coco_20200926_125502-20289c16.pth', # noqa + url='https://download.openmmlab.com/mmdetection/v2.0/resnest/faster_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco/faster_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco_20200926_125502-20289c16.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=42.0), +) +resnet_strikes_back = dict( + config='configs/resnet_strikes_back/mask-rcnn_r50-rsb-pre_fpn_1x_coco.py', # noqa + checkpoint='mask_rcnn_r50_fpn_rsb-pretrain_1x_coco_20220113_174054-06ce8ba0.pth', # noqa + url='https://download.openmmlab.com/mmdetection/v2.0/resnet_strikes_back/mask_rcnn_r50_fpn_rsb-pretrain_1x_coco/mask_rcnn_r50_fpn_rsb-pretrain_1x_coco_20220113_174054-06ce8ba0.pth', # noqa + eval=['bbox', 'segm'], + metric=dict(bbox_mAP=41.2, segm_mAP=38.2), +) +retinanet = dict( + config='configs/retinanet/retinanet_r50_fpn_1x_coco.py', + checkpoint='retinanet_r50_fpn_1x_coco_20200130-c2398f9e.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r50_fpn_1x_coco/retinanet_r50_fpn_1x_coco_20200130-c2398f9e.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=36.5), +) +rpn = dict( + config='configs/rpn/rpn_r50_fpn_1x_coco.py', + checkpoint='rpn_r50_fpn_1x_coco_20200218-5525fa2e.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_r50_fpn_1x_coco/rpn_r50_fpn_1x_coco_20200218-5525fa2e.pth', # noqa + eval='proposal_fast', + metric=dict(AR_1000=58.2), +) +sabl = [ + dict( + config='configs/sabl/sabl-retinanet_r50_fpn_1x_coco.py', + checkpoint='sabl_retinanet_r50_fpn_1x_coco-6c54fd4f.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_retinanet_r50_fpn_1x_coco/sabl_retinanet_r50_fpn_1x_coco-6c54fd4f.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=37.7), + ), + dict( + config='configs/sabl/sabl-faster-rcnn_r50_fpn_1x_coco.py', + checkpoint='sabl_faster_rcnn_r50_fpn_1x_coco-e867595b.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_faster_rcnn_r50_fpn_1x_coco/sabl_faster_rcnn_r50_fpn_1x_coco-e867595b.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=39.9), + ), +] +scnet = dict( + config='configs/scnet/scnet_r50_fpn_1x_coco.py', + checkpoint='scnet_r50_fpn_1x_coco-c3f09857.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/scnet/scnet_r50_fpn_1x_coco/scnet_r50_fpn_1x_coco-c3f09857.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=43.5), +) +scratch = dict( + config='configs/scratch/mask-rcnn_r50-scratch_fpn_gn-all_6x_coco.py', + checkpoint='scratch_mask_rcnn_r50_fpn_gn_6x_bbox_mAP-0.412__segm_mAP-0.374_20200201_193051-1e190a40.pth', # noqa + url='https://download.openmmlab.com/mmdetection/v2.0/scratch/mask_rcnn_r50_fpn_gn-all_scratch_6x_coco/scratch_mask_rcnn_r50_fpn_gn_6x_bbox_mAP-0.412__segm_mAP-0.374_20200201_193051-1e190a40.pth', # noqa + eval=['bbox', 'segm'], + metric=dict(bbox_mAP=41.2, segm_mAP=37.4), +) +solo = dict( + config='configs/solo/decoupled-solo_r50_fpn_1x_coco.py', + checkpoint='decoupled_solo_r50_fpn_1x_coco_20210820_233348-6337c589.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/solo/decoupled_solo_r50_fpn_1x_coco/decoupled_solo_r50_fpn_1x_coco_20210820_233348-6337c589.pth', # noqa + eval='segm', + metric=dict(segm_mAP=33.9), +) +solov2 = dict( + config='configs/solov2/solov2_r50_fpn_1x_coco.py', + checkpoint='solov2_r50_fpn_1x_coco_20220512_125858-a357fa23.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/solov2/solov2_r50_fpn_1x_coco/solov2_r50_fpn_1x_coco_20220512_125858-a357fa23.pth', # noqa + eval='segm', + metric=dict(segm_mAP=34.8), +) +sparse_rcnn = dict( + config='configs/sparse_rcnn/sparse-rcnn_r50_fpn_1x_coco.py', + checkpoint='sparse_rcnn_r50_fpn_1x_coco_20201222_214453-dc79b137.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/sparse_rcnn/sparse_rcnn_r50_fpn_1x_coco/sparse_rcnn_r50_fpn_1x_coco_20201222_214453-dc79b137.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=37.9), +) +ssd = [ + dict( + config='configs/ssd/ssd300_coco.py', + checkpoint='ssd300_coco_20210803_015428-d231a06e.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/ssd/ssd300_coco/ssd300_coco_20210803_015428-d231a06e.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=25.5), + ), + dict( + config='configs/ssd/ssdlite_mobilenetv2-scratch_8xb24-600e_coco.py', + checkpoint='ssdlite_mobilenetv2_scratch_600e_coco_20210629_110627-974d9307.pth', # noqa + url='https://download.openmmlab.com/mmdetection/v2.0/ssd/ssdlite_mobilenetv2_scratch_600e_coco/ssdlite_mobilenetv2_scratch_600e_coco_20210629_110627-974d9307.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=21.3), + ), +] +swin = dict( + config='configs/swin/mask-rcnn_swin-t-p4-w7_fpn_1x_coco.py', + checkpoint='mask_rcnn_swin-t-p4-w7_fpn_1x_coco_20210902_120937-9d6b7cfa.pth', # noqa + url='https://download.openmmlab.com/mmdetection/v2.0/swin/mask_rcnn_swin-t-p4-w7_fpn_1x_coco/mask_rcnn_swin-t-p4-w7_fpn_1x_coco_20210902_120937-9d6b7cfa.pth', # noqa + eval=['bbox', 'segm'], + metric=dict(bbox_mAP=42.7, segm_mAP=39.3), +) +tood = dict( + config='configs/tood/tood_r50_fpn_1x_coco.py', + checkpoint='tood_r50_fpn_1x_coco_20211210_103425-20e20746.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/tood/tood_r50_fpn_1x_coco/tood_r50_fpn_1x_coco_20211210_103425-20e20746.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=42.4), +) +tridentnet = dict( + config='configs/tridentnet/tridentnet_r50-caffe_1x_coco.py', + checkpoint='tridentnet_r50_caffe_1x_coco_20201230_141838-2ec0b530.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/tridentnet/tridentnet_r50_caffe_1x_coco/tridentnet_r50_caffe_1x_coco_20201230_141838-2ec0b530.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=37.6), +) +vfnet = dict( + config='configs/vfnet/vfnet_r50_fpn_1x_coco.py', + checkpoint='vfnet_r50_fpn_1x_coco_20201027-38db6f58.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_r50_fpn_1x_coco/vfnet_r50_fpn_1x_coco_20201027-38db6f58.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=41.6), +) +yolact = dict( + config='configs/yolact/yolact_r50_1xb8-55e_coco.py', + checkpoint='yolact_r50_1x8_coco_20200908-f38d58df.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/yolact/yolact_r50_1x8_coco/yolact_r50_1x8_coco_20200908-f38d58df.pth', # noqa + eval=['bbox', 'segm'], + metric=dict(bbox_mAP=31.2, segm_mAP=29.0), +) +yolo = dict( + config='configs/yolo/yolov3_d53_8xb8-320-273e_coco.py', + checkpoint='yolov3_d53_320_273e_coco-421362b6.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/yolo/yolov3_d53_320_273e_coco/yolov3_d53_320_273e_coco-421362b6.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=27.9), +) +yolof = dict( + config='configs/yolof/yolof_r50-c5_8xb8-1x_coco.py', + checkpoint='yolof_r50_c5_8x8_1x_coco_20210425_024427-8e864411.pth', + url='https://download.openmmlab.com/mmdetection/v2.0/yolof/yolof_r50_c5_8x8_1x_coco/yolof_r50_c5_8x8_1x_coco_20210425_024427-8e864411.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=37.5), +) +yolox = dict( + config='configs/yolox/yolox_tiny_8xb8-300e_coco.py', + checkpoint='yolox_tiny_8x8_300e_coco_20211124_171234-b4047906.pth', # noqa + url='https://download.openmmlab.com/mmdetection/v2.0/yolox/yolox_tiny_8x8_300e_coco/yolox_tiny_8x8_300e_coco_20211124_171234-b4047906.pth', # noqa + eval='bbox', + metric=dict(bbox_mAP=31.8), +) +# yapf: enable diff --git a/mmdetection/.dev_scripts/batch_train_list.txt b/mmdetection/.dev_scripts/batch_train_list.txt new file mode 100644 index 00000000..9a4f6778 --- /dev/null +++ b/mmdetection/.dev_scripts/batch_train_list.txt @@ -0,0 +1,80 @@ +configs/albu_example/mask-rcnn_r50_fpn_albu_1x_coco.py +configs/atss/atss_r50_fpn_1x_coco.py +configs/autoassign/autoassign_r50-caffe_fpn_1x_coco.py +configs/carafe/faster-rcnn_r50_fpn-carafe_1x_coco.py +configs/cascade_rcnn/cascade-rcnn_r50_fpn_1x_coco.py +configs/cascade_rcnn/cascade-mask-rcnn_r50_fpn_1x_coco.py +configs/cascade_rpn/cascade-rpn_faster-rcnn_r50-caffe_fpn_1x_coco.py +configs/centernet/centernet_r18-dcnv2_8xb16-crop512-140e_coco.py +configs/centernet/centernet-update_r50-caffe_fpn_ms-1x_coco.py +configs/centripetalnet/centripetalnet_hourglass104_16xb6-crop511-210e-mstest_coco.py +configs/cornernet/cornernet_hourglass104_8xb6-210e-mstest_coco.py +configs/convnext/mask-rcnn_convnext-t-p4-w7_fpn_amp-ms-crop-3x_coco.py +configs/dcn/faster-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py +configs/dcnv2/faster-rcnn_r50_fpn_mdpool_1x_coco.py +configs/ddod/ddod_r50_fpn_1x_coco.py +configs/detectors/detectors_htc-r50_1x_coco.py +configs/deformable_detr/deformable-detr_r50_16xb2-50e_coco.py +configs/detr/detr_r50_8xb2-150e_coco.py +configs/double_heads/dh-faster-rcnn_r50_fpn_1x_coco.py +configs/dynamic_rcnn/dynamic-rcnn_r50_fpn_1x_coco.py +configs/dyhead/atss_r50_fpn_dyhead_1x_coco.py +configs/efficientnet/retinanet_effb3_fpn_8xb4-crop896-1x_coco.py +configs/empirical_attention/faster-rcnn_r50-attn1111_fpn_1x_coco.py +configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py +configs/faster_rcnn/faster-rcnn_r50-caffe-dc5_ms-1x_coco.py +configs/fcos/fcos_r50-caffe_fpn_gn-head-center-normbbox-centeronreg-giou_1x_coco.py +configs/foveabox/fovea_r50_fpn_gn-head-align_4xb4-2x_coco.py +configs/fpg/mask-rcnn_r50_fpg_crop640-50e_coco.py +configs/free_anchor/freeanchor_r50_fpn_1x_coco.py +configs/fsaf/fsaf_r50_fpn_1x_coco.py +configs/gcnet/mask-rcnn_r50-syncbn-gcb-r16-c3-c5_fpn_1x_coco.py +configs/gfl/gfl_r50_fpn_1x_coco.py +configs/ghm/retinanet_r50_fpn_ghm-1x_coco.py +configs/gn/mask-rcnn_r50_fpn_gn-all_2x_coco.py +configs/gn+ws/faster-rcnn_r50_fpn_gn-ws-all_1x_coco.py +configs/grid_rcnn/grid-rcnn_r50_fpn_gn-head_2x_coco.py +configs/groie/faste-rcnn_r50_fpn_groie_1x_coco.py +configs/guided_anchoring/ga-retinanet_r50-caffe_fpn_1x_coco.py +configs/hrnet/faster-rcnn_hrnetv2p-w18-1x_coco.py +configs/htc/htc_r50_fpn_1x_coco.py +configs/instaboost/mask-rcnn_r50_fpn_instaboost-4x_coco.py +configs/lad/lad_r50-paa-r101_fpn_2xb8_coco_1x.py +configs/ld/ld_r18-gflv1-r101_fpn_1x_coco.py +configs/libra_rcnn/libra-faster-rcnn_r50_fpn_1x_coco.py +configs/mask2former/mask2former_r50_8xb2-lsj-50e_coco-panoptic.py +configs/mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py +configs/maskformer/maskformer_r50_ms-16xb1-75e_coco.py +configs/ms_rcnn/ms-rcnn_r50-caffe_fpn_1x_coco.py +configs/nas_fcos/nas-fcos_r50-caffe_fpn_nashead-gn-head_4xb4-1x_coco.py +configs/nas_fpn/retinanet_r50_nasfpn_crop640-50e_coco.py +configs/paa/paa_r50_fpn_1x_coco.py +configs/pafpn/faster-rcnn_r50_pafpn_1x_coco.py +configs/panoptic_fpn/panoptic-fpn_r50_fpn_1x_coco.py +configs/pisa/mask-rcnn_r50_fpn_pisa_1x_coco.py +configs/point_rend/point-rend_r50-caffe_fpn_ms-1x_coco.py +configs/pvt/retinanet_pvt-t_fpn_1x_coco.py +configs/queryinst/queryinst_r50_fpn_1x_coco.py +configs/regnet/retinanet_regnetx-800MF_fpn_1x_coco.py +configs/reppoints/reppoints-moment_r50_fpn_1x_coco.py +configs/res2net/faster-rcnn_res2net-101_fpn_2x_coco.py +configs/resnest/faster-rcnn_s50_fpn_syncbn-backbone+head_ms-range-1x_coco.py +configs/resnet_strikes_back/retinanet_r50-rsb-pre_fpn_1x_coco.py +configs/retinanet/retinanet_r50-caffe_fpn_1x_coco.py +configs/rpn/rpn_r50_fpn_1x_coco.py +configs/sabl/sabl-retinanet_r50_fpn_1x_coco.py +configs/scnet/scnet_r50_fpn_1x_coco.py +configs/scratch/faster-rcnn_r50-scratch_fpn_gn-all_6x_coco.py +configs/solo/solo_r50_fpn_1x_coco.py +configs/solov2/solov2_r50_fpn_1x_coco.py +configs/sparse_rcnn/sparse-rcnn_r50_fpn_1x_coco.py +configs/ssd/ssd300_coco.py +configs/ssd/ssdlite_mobilenetv2-scratch_8xb24-600e_coco.py +configs/swin/mask-rcnn_swin-t-p4-w7_fpn_1x_coco.py +configs/tood/tood_r50_fpn_1x_coco.py +'configs/tridentnet/tridentnet_r50-caffe_1x_coco.py +configs/vfnet/vfnet_r50_fpn_1x_coco.py +configs/yolact/yolact_r50_8xb8-55e_coco.py +configs/yolo/yolov3_d53_8xb8-320-273e_coco.py +configs/yolof/yolof_r50-c5_8xb8-1x_coco.py +configs/yolox/yolox_tiny_8xb8-300e_coco.py diff --git a/mmdetection/.dev_scripts/benchmark_filter.py b/mmdetection/.dev_scripts/benchmark_filter.py new file mode 100644 index 00000000..178cd9cb --- /dev/null +++ b/mmdetection/.dev_scripts/benchmark_filter.py @@ -0,0 +1,167 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import argparse +import os +import os.path as osp + + +def parse_args(): + parser = argparse.ArgumentParser(description='Filter configs to train') + parser.add_argument( + '--basic-arch', + action='store_true', + help='to train models in basic arch') + parser.add_argument( + '--datasets', action='store_true', help='to train models in dataset') + parser.add_argument( + '--data-pipeline', + action='store_true', + help='to train models related to data pipeline, e.g. augmentations') + parser.add_argument( + '--nn-module', + action='store_true', + help='to train models related to neural network modules') + parser.add_argument( + '--model-options', + nargs='+', + help='custom options to special model benchmark') + parser.add_argument( + '--out', + type=str, + default='batch_train_list.txt', + help='output path of gathered metrics to be stored') + args = parser.parse_args() + return args + + +basic_arch_root = [ + 'atss', 'autoassign', 'cascade_rcnn', 'cascade_rpn', 'centripetalnet', + 'cornernet', 'detectors', 'deformable_detr', 'detr', 'double_heads', + 'dynamic_rcnn', 'faster_rcnn', 'fcos', 'foveabox', 'fp16', 'free_anchor', + 'fsaf', 'gfl', 'ghm', 'grid_rcnn', 'guided_anchoring', 'htc', 'ld', + 'libra_rcnn', 'mask_rcnn', 'ms_rcnn', 'nas_fcos', 'paa', 'pisa', + 'point_rend', 'reppoints', 'retinanet', 'rpn', 'sabl', 'ssd', 'tridentnet', + 'vfnet', 'yolact', 'yolo', 'sparse_rcnn', 'scnet', 'yolof', 'centernet' +] + +datasets_root = [ + 'wider_face', 'pascal_voc', 'cityscapes', 'lvis', 'deepfashion' +] + +data_pipeline_root = ['albu_example', 'instaboost'] + +nn_module_root = [ + 'carafe', 'dcn', 'empirical_attention', 'gcnet', 'gn', 'gn+ws', 'hrnet', + 'pafpn', 'nas_fpn', 'regnet', 'resnest', 'res2net', 'groie' +] + +benchmark_pool = [ + 'configs/albu_example/mask_rcnn_r50_fpn_albu_1x_coco.py', + 'configs/atss/atss_r50_fpn_1x_coco.py', + 'configs/autoassign/autoassign_r50_fpn_8x2_1x_coco.py', + 'configs/carafe/mask_rcnn_r50_fpn_carafe_1x_coco.py', + 'configs/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco.py', + 'configs/cascade_rpn/crpn_faster_rcnn_r50_caffe_fpn_1x_coco.py', + 'configs/centernet/centernet_resnet18_dcnv2_140e_coco.py', + 'configs/centripetalnet/' + 'centripetalnet_hourglass104_mstest_16x6_210e_coco.py', + 'configs/cityscapes/mask_rcnn_r50_fpn_1x_cityscapes.py', + 'configs/cornernet/' + 'cornernet_hourglass104_mstest_8x6_210e_coco.py', + 'configs/dcn/mask_rcnn_r50_fpn_mdconv_c3-c5_1x_coco.py', + 'configs/dcn/faster_rcnn_r50_fpn_dpool_1x_coco.py', + 'configs/dcn/faster_rcnn_r50_fpn_mdpool_1x_coco.py', + 'configs/dcn/mask_rcnn_r50_fpn_dconv_c3-c5_1x_coco.py', + 'configs/deformable_detr/deformable_detr_r50_16x2_50e_coco.py', + 'configs/detectors/detectors_htc_r50_1x_coco.py', + 'configs/detr/detr_r50_8x2_150e_coco.py', + 'configs/double_heads/dh_faster_rcnn_r50_fpn_1x_coco.py', + 'configs/dynamic_rcnn/dynamic_rcnn_r50_fpn_1x_coco.py', + 'configs/empirical_attention/faster_rcnn_r50_fpn_attention_1111_dcn_1x_coco.py', # noqa + 'configs/faster_rcnn/faster_rcnn_r50_fpn_1x_coco.py', + 'configs/faster_rcnn/faster_rcnn_r50_fpn_ohem_1x_coco.py', + 'configs/faster_rcnn/faster_rcnn_r50_caffe_fpn_1x_coco.py', + 'configs/faster_rcnn/faster_rcnn_r50_caffe_fpn_mstrain_1x_coco.py', + 'configs/faster_rcnn/faster_rcnn_r50_caffe_dc5_mstrain_1x_coco.py', + 'configs/fcos/fcos_center_r50_caffe_fpn_gn-head_4x4_1x_coco.py', + 'configs/foveabox/fovea_align_r50_fpn_gn-head_4x4_2x_coco.py', + 'configs/retinanet/retinanet_r50_fpn_fp16_1x_coco.py', + 'configs/mask_rcnn/mask_rcnn_r50_fpn_fp16_1x_coco.py', + 'configs/free_anchor/retinanet_free_anchor_r50_fpn_1x_coco.py', + 'configs/fsaf/fsaf_r50_fpn_1x_coco.py', + 'configs/gcnet/mask_rcnn_r50_fpn_r4_gcb_c3-c5_1x_coco.py', + 'configs/gfl/gfl_r50_fpn_1x_coco.py', + 'configs/ghm/retinanet_ghm_r50_fpn_1x_coco.py', + 'configs/gn/mask_rcnn_r50_fpn_gn-all_2x_coco.py', + 'configs/gn+ws/mask_rcnn_r50_fpn_gn_ws-all_2x_coco.py', + 'configs/grid_rcnn/grid_rcnn_r50_fpn_gn-head_2x_coco.py', + 'configs/groie/faster_rcnn_r50_fpn_groie_1x_coco.py', + 'configs/guided_anchoring/ga_faster_r50_caffe_fpn_1x_coco.py', + 'configs/hrnet/mask_rcnn_hrnetv2p_w18_1x_coco.py', + 'configs/htc/htc_r50_fpn_1x_coco.py', + 'configs/instaboost/mask_rcnn_r50_fpn_instaboost_4x_coco.py', + 'configs/ld/ld_r18_gflv1_r101_fpn_coco_1x.py', + 'configs/libra_rcnn/libra_faster_rcnn_r50_fpn_1x_coco.py', + 'configs/lvis/mask_rcnn_r50_fpn_sample1e-3_mstrain_1x_lvis_v1.py', + 'configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_coco.py', + 'configs/ms_rcnn/ms_rcnn_r50_caffe_fpn_1x_coco.py', + 'configs/nas_fcos/nas_fcos_nashead_r50_caffe_fpn_gn-head_4x4_1x_coco.py', + 'configs/nas_fpn/retinanet_r50_nasfpn_crop640_50e_coco.py', + 'configs/paa/paa_r50_fpn_1x_coco.py', + 'configs/pafpn/faster_rcnn_r50_pafpn_1x_coco.py', + 'configs/pisa/pisa_mask_rcnn_r50_fpn_1x_coco.py', + 'configs/point_rend/point_rend_r50_caffe_fpn_mstrain_1x_coco.py', + 'configs/regnet/mask_rcnn_regnetx-3.2GF_fpn_1x_coco.py', + 'configs/reppoints/reppoints_moment_r50_fpn_gn-neck+head_1x_coco.py', + 'configs/res2net/faster_rcnn_r2_101_fpn_2x_coco.py', + 'configs/resnest/' + 'mask_rcnn_s50_fpn_syncbn-backbone+head_mstrain_1x_coco.py', + 'configs/retinanet/retinanet_r50_caffe_fpn_1x_coco.py', + 'configs/rpn/rpn_r50_fpn_1x_coco.py', + 'configs/sabl/sabl_retinanet_r50_fpn_1x_coco.py', + 'configs/ssd/ssd300_coco.py', + 'configs/tridentnet/tridentnet_r50_caffe_1x_coco.py', + 'configs/vfnet/vfnet_r50_fpn_1x_coco.py', + 'configs/yolact/yolact_r50_1x8_coco.py', + 'configs/yolo/yolov3_d53_320_273e_coco.py', + 'configs/sparse_rcnn/sparse_rcnn_r50_fpn_1x_coco.py', + 'configs/scnet/scnet_r50_fpn_1x_coco.py', + 'configs/yolof/yolof_r50_c5_8x8_1x_coco.py', +] + + +def main(): + args = parse_args() + + benchmark_type = [] + if args.basic_arch: + benchmark_type += basic_arch_root + if args.datasets: + benchmark_type += datasets_root + if args.data_pipeline: + benchmark_type += data_pipeline_root + if args.nn_module: + benchmark_type += nn_module_root + + special_model = args.model_options + if special_model is not None: + benchmark_type += special_model + + config_dpath = 'configs/' + benchmark_configs = [] + for cfg_root in benchmark_type: + cfg_dir = osp.join(config_dpath, cfg_root) + configs = os.scandir(cfg_dir) + for cfg in configs: + config_path = osp.join(cfg_dir, cfg.name) + if (config_path in benchmark_pool + and config_path not in benchmark_configs): + benchmark_configs.append(config_path) + + print(f'Totally found {len(benchmark_configs)} configs to benchmark') + with open(args.out, 'w') as f: + for config in benchmark_configs: + f.write(config + '\n') + + +if __name__ == '__main__': + main() diff --git a/mmdetection/.dev_scripts/benchmark_full_models.txt b/mmdetection/.dev_scripts/benchmark_full_models.txt new file mode 100644 index 00000000..eae7235f --- /dev/null +++ b/mmdetection/.dev_scripts/benchmark_full_models.txt @@ -0,0 +1,96 @@ +albu_example/mask-rcnn_r50_fpn_albu_1x_coco.py +atss/atss_r50_fpn_1x_coco.py +autoassign/autoassign_r50-caffe_fpn_1x_coco.py +boxinst/boxinst_r50_fpn_ms-90k_coco.py +carafe/faster-rcnn_r50_fpn-carafe_1x_coco.py +cascade_rcnn/cascade-rcnn_r50_fpn_1x_coco.py +cascade_rcnn/cascade-mask-rcnn_r50_fpn_1x_coco.py +cascade_rpn/cascade-rpn_faster-rcnn_r50-caffe_fpn_1x_coco.py +centernet/centernet-update_r50-caffe_fpn_ms-1x_coco.py +centripetalnet/centripetalnet_hourglass104_16xb6-crop511-210e-mstest_coco.py +condinst/condinst_r50_fpn_ms-poly-90k_coco_instance.py +conditional_detr/conditional-detr_r50_8xb2-50e_coco.py +convnext/mask-rcnn_convnext-t-p4-w7_fpn_amp-ms-crop-3x_coco.py +cornernet/cornernet_hourglass104_8xb6-210e-mstest_coco.py +dab_detr/dab-detr_r50_8xb2-50e_coco.py +dcn/mask-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py +dcnv2/faster-rcnn_r50_fpn_mdpool_1x_coco.py +ddod/ddod_r50_fpn_1x_coco.py +deformable_detr/deformable-detr_r50_16xb2-50e_coco.py +detectors/detectors_htc-r50_1x_coco.py +detr/detr_r50_8xb2-150e_coco.py +dino/dino-4scale_r50_8xb2-12e_coco.py +double_heads/dh-faster-rcnn_r50_fpn_1x_coco.py +dyhead/atss_r50_fpn_dyhead_1x_coco.py +dynamic_rcnn/dynamic-rcnn_r50_fpn_1x_coco.py +efficientnet/retinanet_effb3_fpn_8xb4-crop896-1x_coco.py +empirical_attention/faster-rcnn_r50-attn0010-dcn_fpn_1x_coco.py +faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py +fcos/fcos_r50-caffe_fpn_gn-head-center-normbbox-centeronreg-giou_1x_coco.py +foveabox/fovea_r50_fpn_gn-head-align_4xb4-2x_coco.py +fpg/retinanet_r50_fpg_crop640_50e_coco.py +free_anchor/freeanchor_r50_fpn_1x_coco.py +fsaf/fsaf_r50_fpn_1x_coco.py +gcnet/mask-rcnn_r50-gcb-r4-c3-c5_fpn_1x_coco.py +gfl/gfl_r50_fpn_1x_coco.py +glip/glip_atss_swin-t_a_fpn_dyhead_pretrain_obj365.py +ghm/retinanet_r50_fpn_ghm-1x_coco.py +gn/mask-rcnn_r50_fpn_gn-all_2x_coco.py +gn+ws/faster-rcnn_r50_fpn_gn-ws-all_1x_coco.py +grid_rcnn/grid-rcnn_r50_fpn_gn-head_2x_coco.py +groie/faste-rcnn_r50_fpn_groie_1x_coco.py +guided_anchoring/ga-faster-rcnn_r50-caffe_fpn_1x_coco.py +hrnet/htc_hrnetv2p-w18_20e_coco.py +htc/htc_r50_fpn_1x_coco.py +instaboost/mask-rcnn_r50_fpn_instaboost-4x_coco.py +lad/lad_r50-paa-r101_fpn_2xb8_coco_1x.py +ld/ld_r18-gflv1-r101_fpn_1x_coco.py +libra_rcnn/libra-faster-rcnn_r50_fpn_1x_coco.py +lvis/mask-rcnn_r50_fpn_sample1e-3_ms-1x_lvis-v1.py +mask2former/mask2former_r50_8xb2-lsj-50e_coco.py +mask2former/mask2former_r50_8xb2-lsj-50e_coco-panoptic.py +mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py +maskformer/maskformer_r50_ms-16xb1-75e_coco.py +ms_rcnn/ms-rcnn_r50-caffe_fpn_1x_coco.py +nas_fcos/nas-fcos_r50-caffe_fpn_nashead-gn-head_4xb4-1x_coco.py +nas_fpn/retinanet_r50_nasfpn_crop640-50e_coco.py +paa/paa_r50_fpn_1x_coco.py +pafpn/faster-rcnn_r50_pafpn_1x_coco.py +panoptic_fpn/panoptic-fpn_r50_fpn_1x_coco.py +pisa/faster-rcnn_r50_fpn_pisa_1x_coco.py +point_rend/point-rend_r50-caffe_fpn_ms-1x_coco.py +pvt/retinanet_pvtv2-b0_fpn_1x_coco.py +queryinst/queryinst_r50_fpn_1x_coco.py +regnet/mask-rcnn_regnetx-3.2GF_fpn_1x_coco.py +reppoints/reppoints-moment_r50_fpn-gn_head-gn_1x_coco.py +res2net/faster-rcnn_res2net-101_fpn_2x_coco.py +resnest/mask-rcnn_s50_fpn_syncbn-backbone+head_ms-1x_coco.py +resnet_strikes_back/faster-rcnn_r50-rsb-pre_fpn_1x_coco.py +retinanet/retinanet_r50_fpn_1x_coco.py +rpn/rpn_r50_fpn_1x_coco.py +rtmdet/rtmdet_s_8xb32-300e_coco.py +rtmdet/rtmdet-ins_s_8xb32-300e_coco.py +sabl/sabl-retinanet_r50_fpn_1x_coco.py +scnet/scnet_r50_fpn_1x_coco.py +scratch/faster-rcnn_r50-scratch_fpn_gn-all_6x_coco.py +seesaw_loss/mask-rcnn_r50_fpn_seesaw-loss_random-ms-2x_lvis-v1.py +simple_copy_paste/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_32xb2-ssj-scp-90k_coco.py +soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.1-coco.py +solo/solo_r50_fpn_1x_coco.py +solov2/solov2_r50_fpn_1x_coco.py +sparse_rcnn/sparse-rcnn_r50_fpn_1x_coco.py +ssd/ssd300_coco.py +swin/mask-rcnn_swin-t-p4-w7_fpn_1x_coco.py +tood/tood_r50_fpn_1x_coco.py +tridentnet/tridentnet_r50-caffe_1x_coco.py +vfnet/vfnet_r50_fpn_1x_coco.py +yolact/yolact_r50_8xb8-55e_coco.py +yolo/yolov3_d53_8xb8-320-273e_coco.py +yolof/yolof_r50-c5_8xb8-1x_coco.py +yolox/yolox_s_8xb8-300e_coco.py +deepsort/deepsort_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py +mask2former_vis/mask2former_r50_8xb2-8e_youtubevis2021.py +masktrack_rcnn/masktrack-rcnn_mask-rcnn_r50_fpn_8xb1-12e_youtubevis2021.py +ocsort/ocsort_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval.py +qdtrack/qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py +strongsort/strongsort_yolox_x_8xb4-80e_crowdhuman-mot17halftrain_test-mot17halfval.py diff --git a/mmdetection/.dev_scripts/benchmark_inference_fps.py b/mmdetection/.dev_scripts/benchmark_inference_fps.py new file mode 100644 index 00000000..6099ed13 --- /dev/null +++ b/mmdetection/.dev_scripts/benchmark_inference_fps.py @@ -0,0 +1,171 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import argparse +import os +import os.path as osp + +from mmengine.config import Config, DictAction +from mmengine.dist import init_dist +from mmengine.fileio import dump +from mmengine.utils import mkdir_or_exist +from terminaltables import GithubFlavoredMarkdownTable + +from tools.analysis_tools.benchmark import repeat_measure_inference_speed + + +def parse_args(): + parser = argparse.ArgumentParser( + description='MMDet benchmark a model of FPS') + parser.add_argument('config', help='test config file path') + parser.add_argument('checkpoint_root', help='Checkpoint file root path') + parser.add_argument( + '--round-num', + type=int, + default=1, + help='round a number to a given precision in decimal digits') + parser.add_argument( + '--repeat-num', + type=int, + default=1, + help='number of repeat times of measurement for averaging the results') + parser.add_argument( + '--out', type=str, help='output path of gathered fps to be stored') + parser.add_argument( + '--max-iter', type=int, default=2000, help='num of max iter') + parser.add_argument( + '--log-interval', type=int, default=50, help='interval of logging') + parser.add_argument( + '--fuse-conv-bn', + action='store_true', + help='Whether to fuse conv and bn, this will slightly increase' + 'the inference speed') + parser.add_argument( + '--cfg-options', + nargs='+', + action=DictAction, + help='override some settings in the used config, the key-value pair ' + 'in xxx=yyy format will be merged into config file. If the value to ' + 'be overwritten is a list, it should be like key="[a,b]" or key=a,b ' + 'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" ' + 'Note that the quotation marks are necessary and that no white space ' + 'is allowed.') + parser.add_argument( + '--launcher', + choices=['none', 'pytorch', 'slurm', 'mpi'], + default='none', + help='job launcher') + parser.add_argument('--local_rank', type=int, default=0) + args = parser.parse_args() + if 'LOCAL_RANK' not in os.environ: + os.environ['LOCAL_RANK'] = str(args.local_rank) + return args + + +def results2markdown(result_dict): + table_data = [] + is_multiple_results = False + for cfg_name, value in result_dict.items(): + name = cfg_name.replace('configs/', '') + fps = value['fps'] + ms_times_pre_image = value['ms_times_pre_image'] + if isinstance(fps, list): + is_multiple_results = True + mean_fps = value['mean_fps'] + mean_times_pre_image = value['mean_times_pre_image'] + fps_str = ','.join([str(s) for s in fps]) + ms_times_pre_image_str = ','.join( + [str(s) for s in ms_times_pre_image]) + table_data.append([ + name, fps_str, mean_fps, ms_times_pre_image_str, + mean_times_pre_image + ]) + else: + table_data.append([name, fps, ms_times_pre_image]) + + if is_multiple_results: + table_data.insert(0, [ + 'model', 'fps', 'mean_fps', 'times_pre_image(ms)', + 'mean_times_pre_image(ms)' + ]) + + else: + table_data.insert(0, ['model', 'fps', 'times_pre_image(ms)']) + table = GithubFlavoredMarkdownTable(table_data) + print(table.table, flush=True) + + +if __name__ == '__main__': + args = parse_args() + assert args.round_num >= 0 + assert args.repeat_num >= 1 + + config = Config.fromfile(args.config) + + if args.launcher == 'none': + raise NotImplementedError('Only supports distributed mode') + else: + init_dist(args.launcher) + + result_dict = {} + for model_key in config: + model_infos = config[model_key] + if not isinstance(model_infos, list): + model_infos = [model_infos] + for model_info in model_infos: + record_metrics = model_info['metric'] + cfg_path = model_info['config'].strip() + cfg = Config.fromfile(cfg_path) + checkpoint = osp.join(args.checkpoint_root, + model_info['checkpoint'].strip()) + try: + fps = repeat_measure_inference_speed(cfg, checkpoint, + args.max_iter, + args.log_interval, + args.fuse_conv_bn, + args.repeat_num) + if args.repeat_num > 1: + fps_list = [round(fps_, args.round_num) for fps_ in fps] + times_pre_image_list = [ + round(1000 / fps_, args.round_num) for fps_ in fps + ] + mean_fps = round( + sum(fps_list) / len(fps_list), args.round_num) + mean_times_pre_image = round( + sum(times_pre_image_list) / len(times_pre_image_list), + args.round_num) + print( + f'{cfg_path} ' + f'Overall fps: {fps_list}[{mean_fps}] img / s, ' + f'times per image: ' + f'{times_pre_image_list}[{mean_times_pre_image}] ' + f'ms / img', + flush=True) + result_dict[cfg_path] = dict( + fps=fps_list, + mean_fps=mean_fps, + ms_times_pre_image=times_pre_image_list, + mean_times_pre_image=mean_times_pre_image) + else: + print( + f'{cfg_path} fps : {fps:.{args.round_num}f} img / s, ' + f'times per image: {1000 / fps:.{args.round_num}f} ' + f'ms / img', + flush=True) + result_dict[cfg_path] = dict( + fps=round(fps, args.round_num), + ms_times_pre_image=round(1000 / fps, args.round_num)) + except Exception as e: + print(f'{cfg_path} error: {repr(e)}') + if args.repeat_num > 1: + result_dict[cfg_path] = dict( + fps=[0], + mean_fps=0, + ms_times_pre_image=[0], + mean_times_pre_image=0) + else: + result_dict[cfg_path] = dict(fps=0, ms_times_pre_image=0) + + if args.out: + mkdir_or_exist(args.out) + dump(result_dict, osp.join(args.out, 'batch_inference_fps.json')) + + results2markdown(result_dict) diff --git a/mmdetection/.dev_scripts/benchmark_options.py b/mmdetection/.dev_scripts/benchmark_options.py new file mode 100644 index 00000000..cdb1f87d --- /dev/null +++ b/mmdetection/.dev_scripts/benchmark_options.py @@ -0,0 +1,16 @@ +# Copyright (c) OpenMMLab. All rights reserved. + +third_part_libs = [ + 'pip install -r ../requirements/albu.txt', + 'pip install instaboostfast', + 'pip install git+https://github.com/cocodataset/panopticapi.git', + 'pip install timm', + 'pip install mmpretrain', + 'pip install git+https://github.com/lvis-dataset/lvis-api.git', + 'pip install -r ../requirements/multimodal.txt', + 'pip install -r ../requirements/tracking.txt', + 'pip install git+https://github.com/JonathonLuiten/TrackEval.git', +] + +default_floating_range = 0.5 +model_floating_ranges = {'atss/atss_r50_fpn_1x_coco.py': 0.3} diff --git a/mmdetection/.dev_scripts/benchmark_test.py b/mmdetection/.dev_scripts/benchmark_test.py new file mode 100644 index 00000000..dddfca15 --- /dev/null +++ b/mmdetection/.dev_scripts/benchmark_test.py @@ -0,0 +1,115 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import logging +import os +import os.path as osp +from argparse import ArgumentParser + +from mmengine.config import Config, DictAction +from mmengine.logging import MMLogger +from mmengine.registry import RUNNERS +from mmengine.runner import Runner + +from mmdet.testing import replace_to_ceph +from mmdet.utils import register_all_modules, replace_cfg_vals + + +def parse_args(): + parser = ArgumentParser() + parser.add_argument('config', help='test config file path') + parser.add_argument('checkpoint_root', help='Checkpoint file root path') + parser.add_argument('--work-dir', help='the dir to save logs') + parser.add_argument('--ceph', action='store_true') + parser.add_argument( + '--cfg-options', + nargs='+', + action=DictAction, + help='override some settings in the used config, the key-value pair ' + 'in xxx=yyy format will be merged into config file. If the value to ' + 'be overwritten is a list, it should be like key="[a,b]" or key=a,b ' + 'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" ' + 'Note that the quotation marks are necessary and that no white space ' + 'is allowed.') + parser.add_argument( + '--launcher', + choices=['none', 'pytorch', 'slurm', 'mpi'], + default='none', + help='job launcher') + parser.add_argument('--local_rank', type=int, default=0) + args = parser.parse_args() + if 'LOCAL_RANK' not in os.environ: + os.environ['LOCAL_RANK'] = str(args.local_rank) + args = parser.parse_args() + return args + + +# TODO: Need to refactor test.py so that it can be reused. +def fast_test_model(config_name, checkpoint, args, logger=None): + cfg = Config.fromfile(config_name) + cfg = replace_cfg_vals(cfg) + cfg.launcher = args.launcher + if args.cfg_options is not None: + cfg.merge_from_dict(args.cfg_options) + + # work_dir is determined in this priority: CLI > segment in file > filename + if args.work_dir is not None: + # update configs according to CLI args if args.work_dir is not None + cfg.work_dir = osp.join(args.work_dir, + osp.splitext(osp.basename(config_name))[0]) + elif cfg.get('work_dir', None) is None: + # use config filename as default work_dir if cfg.work_dir is None + cfg.work_dir = osp.join('./work_dirs', + osp.splitext(osp.basename(config_name))[0]) + + if args.ceph: + replace_to_ceph(cfg) + + cfg.load_from = checkpoint + + # TODO: temporary plan + if 'visualizer' in cfg: + if 'name' in cfg.visualizer: + del cfg.visualizer.name + + # build the runner from config + if 'runner_type' not in cfg: + # build the default runner + runner = Runner.from_cfg(cfg) + else: + # build customized runner from the registry + # if 'runner_type' is set in the cfg + runner = RUNNERS.build(cfg) + + runner.test() + + +# Sample test whether the inference code is correct +def main(args): + # register all modules in mmdet into the registries + register_all_modules(init_default_scope=False) + + config = Config.fromfile(args.config) + + # test all model + logger = MMLogger.get_instance( + name='MMLogger', + log_file='benchmark_test.log', + log_level=logging.ERROR) + + for model_key in config: + model_infos = config[model_key] + if not isinstance(model_infos, list): + model_infos = [model_infos] + for model_info in model_infos: + print('processing: ', model_info['config'], flush=True) + config_name = model_info['config'].strip() + checkpoint = osp.join(args.checkpoint_root, + model_info['checkpoint'].strip()) + try: + fast_test_model(config_name, checkpoint, args, logger) + except Exception as e: + logger.error(f'{config_name} " : {repr(e)}') + + +if __name__ == '__main__': + args = parse_args() + main(args) diff --git a/mmdetection/.dev_scripts/benchmark_test_image.py b/mmdetection/.dev_scripts/benchmark_test_image.py new file mode 100644 index 00000000..62fa57ee --- /dev/null +++ b/mmdetection/.dev_scripts/benchmark_test_image.py @@ -0,0 +1,134 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import logging +import os.path as osp +from argparse import ArgumentParser + +import mmcv +from mmengine.config import Config +from mmengine.logging import MMLogger +from mmengine.utils import mkdir_or_exist + +from mmdet.apis import inference_detector, init_detector +from mmdet.registry import VISUALIZERS +from mmdet.utils import register_all_modules + + +def parse_args(): + parser = ArgumentParser() + parser.add_argument('config', help='test config file path') + parser.add_argument('checkpoint_root', help='Checkpoint file root path') + parser.add_argument('--img', default='demo/demo.jpg', help='Image file') + parser.add_argument('--aug', action='store_true', help='aug test') + parser.add_argument('--model-name', help='model name to inference') + parser.add_argument('--show', action='store_true', help='show results') + parser.add_argument('--out-dir', default=None, help='Dir to output file') + parser.add_argument( + '--wait-time', + type=float, + default=1, + help='the interval of show (s), 0 is block') + parser.add_argument( + '--device', default='cuda:0', help='Device used for inference') + parser.add_argument( + '--palette', + default='coco', + choices=['coco', 'voc', 'citys', 'random'], + help='Color palette used for visualization') + parser.add_argument( + '--score-thr', type=float, default=0.3, help='bbox score threshold') + args = parser.parse_args() + return args + + +def inference_model(config_name, checkpoint, visualizer, args, logger=None): + cfg = Config.fromfile(config_name) + if args.aug: + raise NotImplementedError() + + model = init_detector( + cfg, checkpoint, palette=args.palette, device=args.device) + visualizer.dataset_meta = model.dataset_meta + + # test a single image + result = inference_detector(model, args.img) + + # show the results + if args.show or args.out_dir is not None: + img = mmcv.imread(args.img) + img = mmcv.imconvert(img, 'bgr', 'rgb') + out_file = None + if args.out_dir is not None: + out_dir = args.out_dir + mkdir_or_exist(out_dir) + + out_file = osp.join( + out_dir, + config_name.split('/')[-1].replace('py', 'jpg')) + + visualizer.add_datasample( + 'result', + img, + data_sample=result, + draw_gt=False, + show=args.show, + wait_time=args.wait_time, + out_file=out_file, + pred_score_thr=args.score_thr) + + return result + + +# Sample test whether the inference code is correct +def main(args): + # register all modules in mmdet into the registries + register_all_modules() + + config = Config.fromfile(args.config) + + # init visualizer + visualizer_cfg = dict(type='DetLocalVisualizer', name='visualizer') + visualizer = VISUALIZERS.build(visualizer_cfg) + + # test single model + if args.model_name: + if args.model_name in config: + model_infos = config[args.model_name] + if not isinstance(model_infos, list): + model_infos = [model_infos] + model_info = model_infos[0] + config_name = model_info['config'].strip() + print(f'processing: {config_name}', flush=True) + checkpoint = osp.join(args.checkpoint_root, + model_info['checkpoint'].strip()) + # build the model from a config file and a checkpoint file + inference_model(config_name, checkpoint, visualizer, args) + return + else: + raise RuntimeError('model name input error.') + + # test all model + logger = MMLogger.get_instance( + name='MMLogger', + log_file='benchmark_test_image.log', + log_level=logging.ERROR) + + for model_key in config: + model_infos = config[model_key] + if not isinstance(model_infos, list): + model_infos = [model_infos] + for model_info in model_infos: + print('processing: ', model_info['config'], flush=True) + config_name = model_info['config'].strip() + checkpoint = osp.join(args.checkpoint_root, + model_info['checkpoint'].strip()) + try: + # build the model from a config file and a checkpoint file + inference_model(config_name, checkpoint, visualizer, args, + logger) + except Exception as e: + logger.error(f'{config_name} " : {repr(e)}') + + +if __name__ == '__main__': + args = parse_args() + main(args) diff --git a/mmdetection/.dev_scripts/benchmark_train.py b/mmdetection/.dev_scripts/benchmark_train.py new file mode 100644 index 00000000..cd1e70c9 --- /dev/null +++ b/mmdetection/.dev_scripts/benchmark_train.py @@ -0,0 +1,178 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import logging +import os +import os.path as osp +from argparse import ArgumentParser + +from mmengine.config import Config, DictAction +from mmengine.logging import MMLogger, print_log +from mmengine.registry import RUNNERS +from mmengine.runner import Runner + +from mmdet.testing import replace_to_ceph +from mmdet.utils import register_all_modules, replace_cfg_vals + + +def parse_args(): + parser = ArgumentParser() + parser.add_argument('config', help='test config file path') + parser.add_argument('--work-dir', help='the dir to save logs and models') + parser.add_argument('--ceph', action='store_true') + parser.add_argument('--save-ckpt', action='store_true') + parser.add_argument( + '--amp', + action='store_true', + default=False, + help='enable automatic-mixed-precision training') + parser.add_argument( + '--auto-scale-lr', + action='store_true', + help='enable automatically scaling LR.') + parser.add_argument( + '--resume', + action='store_true', + help='resume from the latest checkpoint in the work_dir automatically') + parser.add_argument( + '--cfg-options', + nargs='+', + action=DictAction, + help='override some settings in the used config, the key-value pair ' + 'in xxx=yyy format will be merged into config file. If the value to ' + 'be overwritten is a list, it should be like key="[a,b]" or key=a,b ' + 'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" ' + 'Note that the quotation marks are necessary and that no white space ' + 'is allowed.') + parser.add_argument( + '--launcher', + choices=['none', 'pytorch', 'slurm', 'mpi'], + default='none', + help='job launcher') + parser.add_argument('--local_rank', type=int, default=0) + args = parser.parse_args() + if 'LOCAL_RANK' not in os.environ: + os.environ['LOCAL_RANK'] = str(args.local_rank) + args = parser.parse_args() + return args + + +# TODO: Need to refactor train.py so that it can be reused. +def fast_train_model(config_name, args, logger=None): + cfg = Config.fromfile(config_name) + cfg = replace_cfg_vals(cfg) + cfg.launcher = args.launcher + if args.cfg_options is not None: + cfg.merge_from_dict(args.cfg_options) + + # work_dir is determined in this priority: CLI > segment in file > filename + if args.work_dir is not None: + # update configs according to CLI args if args.work_dir is not None + cfg.work_dir = osp.join(args.work_dir, + osp.splitext(osp.basename(config_name))[0]) + elif cfg.get('work_dir', None) is None: + # use config filename as default work_dir if cfg.work_dir is None + cfg.work_dir = osp.join('./work_dirs', + osp.splitext(osp.basename(config_name))[0]) + + ckpt_hook = cfg.default_hooks.checkpoint + by_epoch = ckpt_hook.get('by_epoch', True) + fast_stop_hook = dict(type='FastStopTrainingHook') + fast_stop_hook['by_epoch'] = by_epoch + if args.save_ckpt: + if by_epoch: + interval = 1 + stop_iter_or_epoch = 2 + else: + interval = 4 + stop_iter_or_epoch = 10 + fast_stop_hook['stop_iter_or_epoch'] = stop_iter_or_epoch + fast_stop_hook['save_ckpt'] = True + ckpt_hook.interval = interval + + if 'custom_hooks' in cfg: + cfg.custom_hooks.append(fast_stop_hook) + else: + custom_hooks = [fast_stop_hook] + cfg.custom_hooks = custom_hooks + + # TODO: temporary plan + if 'visualizer' in cfg: + if 'name' in cfg.visualizer: + del cfg.visualizer.name + + # enable automatic-mixed-precision training + if args.amp is True: + optim_wrapper = cfg.optim_wrapper.type + if optim_wrapper == 'AmpOptimWrapper': + print_log( + 'AMP training is already enabled in your config.', + logger='current', + level=logging.WARNING) + else: + assert optim_wrapper == 'OptimWrapper', ( + '`--amp` is only supported when the optimizer wrapper type is ' + f'`OptimWrapper` but got {optim_wrapper}.') + cfg.optim_wrapper.type = 'AmpOptimWrapper' + cfg.optim_wrapper.loss_scale = 'dynamic' + + # enable automatically scaling LR + if args.auto_scale_lr: + if 'auto_scale_lr' in cfg and \ + 'enable' in cfg.auto_scale_lr and \ + 'base_batch_size' in cfg.auto_scale_lr: + cfg.auto_scale_lr.enable = True + else: + raise RuntimeError('Can not find "auto_scale_lr" or ' + '"auto_scale_lr.enable" or ' + '"auto_scale_lr.base_batch_size" in your' + ' configuration file.') + + if args.ceph: + replace_to_ceph(cfg) + + cfg.resume = args.resume + + # build the runner from config + if 'runner_type' not in cfg: + # build the default runner + runner = Runner.from_cfg(cfg) + else: + # build customized runner from the registry + # if 'runner_type' is set in the cfg + runner = RUNNERS.build(cfg) + + runner.train() + + +# Sample test whether the train code is correct +def main(args): + # register all modules in mmdet into the registries + register_all_modules(init_default_scope=False) + + config = Config.fromfile(args.config) + + # test all model + logger = MMLogger.get_instance( + name='MMLogger', + log_file='benchmark_train.log', + log_level=logging.ERROR) + + for model_key in config: + model_infos = config[model_key] + if not isinstance(model_infos, list): + model_infos = [model_infos] + for model_info in model_infos: + print('processing: ', model_info['config'], flush=True) + config_name = model_info['config'].strip() + try: + fast_train_model(config_name, args, logger) + except RuntimeError as e: + # quick exit is the normal exit message + if 'quick exit' not in repr(e): + logger.error(f'{config_name} " : {repr(e)}') + except Exception as e: + logger.error(f'{config_name} " : {repr(e)}') + + +if __name__ == '__main__': + args = parse_args() + main(args) diff --git a/mmdetection/.dev_scripts/benchmark_train_models.txt b/mmdetection/.dev_scripts/benchmark_train_models.txt new file mode 100644 index 00000000..30b53c00 --- /dev/null +++ b/mmdetection/.dev_scripts/benchmark_train_models.txt @@ -0,0 +1,22 @@ +atss/atss_r50_fpn_1x_coco.py +faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py +mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py +cascade_rcnn/cascade-mask-rcnn_r50_fpn_1x_coco.py +configs/grounding_dino/grounding_dino_swin-t_finetune_16xb2_1x_coco.py +configs/glip/glip_atss_swin-t_a_fpn_dyhead_16xb2_ms-2x_funtune_coco.py +configs/ddq/ddq-detr-4scale_r50_8xb2-12e_coco.py +panoptic_fpn/panoptic-fpn_r50_fpn_1x_coco.py +retinanet/retinanet_r50_fpn_1x_coco.py +rtmdet/rtmdet_s_8xb32-300e_coco.py +rtmdet/rtmdet-ins_s_8xb32-300e_coco.py +fcos/fcos_r50-caffe_fpn_gn-head-center-normbbox-centeronreg-giou_1x_coco.py +centernet/centernet-update_r50-caffe_fpn_ms-1x_coco.py +dino/dino-4scale_r50_8xb2-12e_coco.py +htc/htc_r50_fpn_1x_coco.py +mask2former/mask2former_r50_8xb2-lsj-50e_coco-panoptic.py +swin/mask-rcnn_swin-t-p4-w7_fpn_1x_coco.py +condinst/condinst_r50_fpn_ms-poly-90k_coco_instance.py +lvis/mask-rcnn_r50_fpn_sample1e-3_ms-1x_lvis-v1.py +mask2former_vis/mask2former_r50_8xb2-8e_youtubevis2021.py +masktrack_rcnn/masktrack-rcnn_mask-rcnn_r50_fpn_8xb1-12e_youtubevis2021.py +qdtrack/qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py diff --git a/mmdetection/.dev_scripts/benchmark_valid_flops.py b/mmdetection/.dev_scripts/benchmark_valid_flops.py new file mode 100644 index 00000000..7dc81f67 --- /dev/null +++ b/mmdetection/.dev_scripts/benchmark_valid_flops.py @@ -0,0 +1,295 @@ +import logging +import re +import tempfile +from argparse import ArgumentParser +from collections import OrderedDict +from functools import partial +from pathlib import Path + +import numpy as np +import pandas as pd +import torch +from mmengine import Config, DictAction +from mmengine.analysis import get_model_complexity_info +from mmengine.analysis.print_helper import _format_size +from mmengine.fileio import FileClient +from mmengine.logging import MMLogger +from mmengine.model import revert_sync_batchnorm +from mmengine.runner import Runner +from modelindex.load_model_index import load +from rich.console import Console +from rich.table import Table +from rich.text import Text +from tqdm import tqdm + +from mmdet.registry import MODELS +from mmdet.utils import register_all_modules + +console = Console() +MMDET_ROOT = Path(__file__).absolute().parents[1] + + +def parse_args(): + parser = ArgumentParser(description='Valid all models in model-index.yml') + parser.add_argument( + '--shape', + type=int, + nargs='+', + default=[1280, 800], + help='input image size') + parser.add_argument( + '--checkpoint_root', + help='Checkpoint file root path. If set, load checkpoint before test.') + parser.add_argument('--img', default='demo/demo.jpg', help='Image file') + parser.add_argument('--models', nargs='+', help='models name to inference') + parser.add_argument( + '--batch-size', + type=int, + default=1, + help='The batch size during the inference.') + parser.add_argument( + '--flops', action='store_true', help='Get Flops and Params of models') + parser.add_argument( + '--flops-str', + action='store_true', + help='Output FLOPs and params counts in a string form.') + parser.add_argument( + '--cfg-options', + nargs='+', + action=DictAction, + help='override some settings in the used config, the key-value pair ' + 'in xxx=yyy format will be merged into config file. If the value to ' + 'be overwritten is a list, it should be like key="[a,b]" or key=a,b ' + 'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" ' + 'Note that the quotation marks are necessary and that no white space ' + 'is allowed.') + parser.add_argument( + '--size_divisor', + type=int, + default=32, + help='Pad the input image, the minimum size that is divisible ' + 'by size_divisor, -1 means do not pad the image.') + args = parser.parse_args() + return args + + +def inference(config_file, checkpoint, work_dir, args, exp_name): + logger = MMLogger.get_instance(name='MMLogger') + logger.warning('if you want test flops, please make sure torch>=1.12') + cfg = Config.fromfile(config_file) + cfg.work_dir = work_dir + cfg.load_from = checkpoint + cfg.log_level = 'WARN' + cfg.experiment_name = exp_name + if args.cfg_options is not None: + cfg.merge_from_dict(args.cfg_options) + + # forward the model + result = {'model': config_file.stem} + + if args.flops: + + if len(args.shape) == 1: + h = w = args.shape[0] + elif len(args.shape) == 2: + h, w = args.shape + else: + raise ValueError('invalid input shape') + divisor = args.size_divisor + if divisor > 0: + h = int(np.ceil(h / divisor)) * divisor + w = int(np.ceil(w / divisor)) * divisor + + input_shape = (3, h, w) + result['resolution'] = input_shape + + try: + cfg = Config.fromfile(config_file) + if hasattr(cfg, 'head_norm_cfg'): + cfg['head_norm_cfg'] = dict(type='SyncBN', requires_grad=True) + cfg['model']['roi_head']['bbox_head']['norm_cfg'] = dict( + type='SyncBN', requires_grad=True) + cfg['model']['roi_head']['mask_head']['norm_cfg'] = dict( + type='SyncBN', requires_grad=True) + + if args.cfg_options is not None: + cfg.merge_from_dict(args.cfg_options) + + model = MODELS.build(cfg.model) + input = torch.rand(1, *input_shape) + if torch.cuda.is_available(): + model.cuda() + input = input.cuda() + model = revert_sync_batchnorm(model) + inputs = (input, ) + model.eval() + outputs = get_model_complexity_info( + model, input_shape, inputs, show_table=False, show_arch=False) + flops = outputs['flops'] + params = outputs['params'] + activations = outputs['activations'] + result['Get Types'] = 'direct' + except: # noqa 772 + logger = MMLogger.get_instance(name='MMLogger') + logger.warning( + 'Direct get flops failed, try to get flops with data') + cfg = Config.fromfile(config_file) + if hasattr(cfg, 'head_norm_cfg'): + cfg['head_norm_cfg'] = dict(type='SyncBN', requires_grad=True) + cfg['model']['roi_head']['bbox_head']['norm_cfg'] = dict( + type='SyncBN', requires_grad=True) + cfg['model']['roi_head']['mask_head']['norm_cfg'] = dict( + type='SyncBN', requires_grad=True) + data_loader = Runner.build_dataloader(cfg.val_dataloader) + data_batch = next(iter(data_loader)) + model = MODELS.build(cfg.model) + if torch.cuda.is_available(): + model = model.cuda() + model = revert_sync_batchnorm(model) + model.eval() + _forward = model.forward + data = model.data_preprocessor(data_batch) + del data_loader + model.forward = partial( + _forward, data_samples=data['data_samples']) + outputs = get_model_complexity_info( + model, + input_shape, + data['inputs'], + show_table=False, + show_arch=False) + flops = outputs['flops'] + params = outputs['params'] + activations = outputs['activations'] + result['Get Types'] = 'dataloader' + + if args.flops_str: + flops = _format_size(flops) + params = _format_size(params) + activations = _format_size(activations) + + result['flops'] = flops + result['params'] = params + + return result + + +def show_summary(summary_data, args): + table = Table(title='Validation Benchmark Regression Summary') + table.add_column('Model') + table.add_column('Validation') + table.add_column('Resolution (c, h, w)') + if args.flops: + table.add_column('Flops', justify='right', width=11) + table.add_column('Params', justify='right') + + for model_name, summary in summary_data.items(): + row = [model_name] + valid = summary['valid'] + color = 'green' if valid == 'PASS' else 'red' + row.append(f'[{color}]{valid}[/{color}]') + if valid == 'PASS': + row.append(str(summary['resolution'])) + if args.flops: + row.append(str(summary['flops'])) + row.append(str(summary['params'])) + table.add_row(*row) + + console.print(table) + table_data = { + x.header: [Text.from_markup(y).plain for y in x.cells] + for x in table.columns + } + table_pd = pd.DataFrame(table_data) + table_pd.to_csv('./mmdetection_flops.csv') + + +# Sample test whether the inference code is correct +def main(args): + register_all_modules() + model_index_file = MMDET_ROOT / 'model-index.yml' + model_index = load(str(model_index_file)) + model_index.build_models_with_collections() + models = OrderedDict({model.name: model for model in model_index.models}) + + logger = MMLogger( + 'validation', + logger_name='validation', + log_file='benchmark_test_image.log', + log_level=logging.INFO) + + if args.models: + patterns = [ + re.compile(pattern.replace('+', '_')) for pattern in args.models + ] + filter_models = {} + for k, v in models.items(): + k = k.replace('+', '_') + if any([re.match(pattern, k) for pattern in patterns]): + filter_models[k] = v + if len(filter_models) == 0: + print('No model found, please specify models in:') + print('\n'.join(models.keys())) + return + models = filter_models + + summary_data = {} + tmpdir = tempfile.TemporaryDirectory() + for model_name, model_info in tqdm(models.items()): + + if model_info.config is None: + continue + + model_info.config = model_info.config.replace('%2B', '+') + config = Path(model_info.config) + + try: + config.exists() + except: # noqa 722 + logger.error(f'{model_name}: {config} not found.') + continue + + logger.info(f'Processing: {model_name}') + + http_prefix = 'https://download.openmmlab.com/mmdetection/' + if args.checkpoint_root is not None: + root = args.checkpoint_root + if 's3://' in args.checkpoint_root: + from petrel_client.common.exception import AccessDeniedError + file_client = FileClient.infer_client(uri=root) + checkpoint = file_client.join_path( + root, model_info.weights[len(http_prefix):]) + try: + exists = file_client.exists(checkpoint) + except AccessDeniedError: + exists = False + else: + checkpoint = Path(root) / model_info.weights[len(http_prefix):] + exists = checkpoint.exists() + if exists: + checkpoint = str(checkpoint) + else: + print(f'WARNING: {model_name}: {checkpoint} not found.') + checkpoint = None + else: + checkpoint = None + + try: + # build the model from a config file and a checkpoint file + result = inference(MMDET_ROOT / config, checkpoint, tmpdir.name, + args, model_name) + result['valid'] = 'PASS' + except Exception: # noqa 722 + import traceback + logger.error(f'"{config}" :\n{traceback.format_exc()}') + result = {'valid': 'FAIL'} + + summary_data[model_name] = result + + tmpdir.cleanup() + show_summary(summary_data, args) + + +if __name__ == '__main__': + args = parse_args() + main(args) diff --git a/mmdetection/.dev_scripts/check_links.py b/mmdetection/.dev_scripts/check_links.py new file mode 100644 index 00000000..ccf4fad5 --- /dev/null +++ b/mmdetection/.dev_scripts/check_links.py @@ -0,0 +1,157 @@ +# Modified from: +# https://github.com/allenai/allennlp/blob/main/scripts/check_links.py + +import argparse +import logging +import os +import pathlib +import re +import sys +from multiprocessing.dummy import Pool +from typing import NamedTuple, Optional, Tuple + +import requests +from mmengine.logging import MMLogger + + +def parse_args(): + parser = argparse.ArgumentParser( + description='Goes through all the inline-links ' + 'in markdown files and reports the breakages') + parser.add_argument( + '--num-threads', + type=int, + default=100, + help='Number of processes to confirm the link') + parser.add_argument('--https-proxy', type=str, help='https proxy') + parser.add_argument( + '--out', + type=str, + default='link_reports.txt', + help='output path of reports') + args = parser.parse_args() + return args + + +OK_STATUS_CODES = ( + 200, + 401, # the resource exists but may require some sort of login. + 403, # ^ same + 405, # HEAD method not allowed. + # the resource exists, but our default 'Accept-' header may not + # match what the server can provide. + 406, +) + + +class MatchTuple(NamedTuple): + source: str + name: str + link: str + + +def check_link( + match_tuple: MatchTuple, + http_session: requests.Session, + logger: logging = None) -> Tuple[MatchTuple, bool, Optional[str]]: + reason: Optional[str] = None + if match_tuple.link.startswith('http'): + result_ok, reason = check_url(match_tuple, http_session) + else: + result_ok = check_path(match_tuple) + if logger is None: + print(f" {'✓' if result_ok else '✗'} {match_tuple.link}") + else: + logger.info(f" {'✓' if result_ok else '✗'} {match_tuple.link}") + return match_tuple, result_ok, reason + + +def check_url(match_tuple: MatchTuple, + http_session: requests.Session) -> Tuple[bool, str]: + """Check if a URL is reachable.""" + try: + result = http_session.head( + match_tuple.link, timeout=5, allow_redirects=True) + return ( + result.ok or result.status_code in OK_STATUS_CODES, + f'status code = {result.status_code}', + ) + except (requests.ConnectionError, requests.Timeout): + return False, 'connection error' + + +def check_path(match_tuple: MatchTuple) -> bool: + """Check if a file in this repository exists.""" + relative_path = match_tuple.link.split('#')[0] + full_path = os.path.join( + os.path.dirname(str(match_tuple.source)), relative_path) + return os.path.exists(full_path) + + +def main(): + args = parse_args() + + # setup logger + logger = MMLogger.get_instance(name='mmdet', log_file=args.out) + + # setup https_proxy + if args.https_proxy: + os.environ['https_proxy'] = args.https_proxy + + # setup http_session + http_session = requests.Session() + for resource_prefix in ('http://', 'https://'): + http_session.mount( + resource_prefix, + requests.adapters.HTTPAdapter( + max_retries=5, + pool_connections=20, + pool_maxsize=args.num_threads), + ) + + logger.info('Finding all markdown files in the current directory...') + + project_root = (pathlib.Path(__file__).parent / '..').resolve() + markdown_files = project_root.glob('**/*.md') + + all_matches = set() + url_regex = re.compile(r'\[([^!][^\]]+)\]\(([^)(]+)\)') + for markdown_file in markdown_files: + with open(markdown_file) as handle: + for line in handle.readlines(): + matches = url_regex.findall(line) + for name, link in matches: + if 'localhost' not in link: + all_matches.add( + MatchTuple( + source=str(markdown_file), + name=name, + link=link)) + + logger.info(f' {len(all_matches)} markdown files found') + logger.info('Checking to make sure we can retrieve each link...') + + with Pool(processes=args.num_threads) as pool: + results = pool.starmap(check_link, [(match, http_session, logger) + for match in list(all_matches)]) + + # collect unreachable results + unreachable_results = [(match_tuple, reason) + for match_tuple, success, reason in results + if not success] + + if unreachable_results: + logger.info('================================================') + logger.info(f'Unreachable links ({len(unreachable_results)}):') + for match_tuple, reason in unreachable_results: + logger.info(' > Source: ' + match_tuple.source) + logger.info(' Name: ' + match_tuple.name) + logger.info(' Link: ' + match_tuple.link) + if reason is not None: + logger.info(' Reason: ' + reason) + sys.exit(1) + logger.info('No Unreachable link found.') + + +if __name__ == '__main__': + main() diff --git a/mmdetection/.dev_scripts/convert_test_benchmark_script.py b/mmdetection/.dev_scripts/convert_test_benchmark_script.py new file mode 100644 index 00000000..6d7ce8a2 --- /dev/null +++ b/mmdetection/.dev_scripts/convert_test_benchmark_script.py @@ -0,0 +1,114 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import argparse +import os +import os.path as osp + +from mmengine import Config + + +def parse_args(): + parser = argparse.ArgumentParser( + description='Convert benchmark model list to script') + parser.add_argument('config', help='test config file path') + parser.add_argument('--port', type=int, default=29666, help='dist port') + parser.add_argument( + '--run', action='store_true', help='run script directly') + parser.add_argument( + '--out', type=str, help='path to save model benchmark script') + + args = parser.parse_args() + return args + + +def process_model_info(model_info, work_dir): + config = model_info['config'].strip() + fname, _ = osp.splitext(osp.basename(config)) + job_name = fname + work_dir = '$WORK_DIR/' + fname + checkpoint = model_info['checkpoint'].strip() + return dict( + config=config, + job_name=job_name, + work_dir=work_dir, + checkpoint=checkpoint) + + +def create_test_bash_info(commands, model_test_dict, port, script_name, + partition): + config = model_test_dict['config'] + job_name = model_test_dict['job_name'] + checkpoint = model_test_dict['checkpoint'] + work_dir = model_test_dict['work_dir'] + + echo_info = f' \necho \'{config}\' &' + commands.append(echo_info) + commands.append('\n') + + command_info = f'GPUS=8 GPUS_PER_NODE=8 ' \ + f'CPUS_PER_TASK=$CPUS_PRE_TASK {script_name} ' + + command_info += f'{partition} ' + command_info += f'{job_name} ' + command_info += f'{config} ' + command_info += f'$CHECKPOINT_DIR/{checkpoint} ' + command_info += f'--work-dir {work_dir} ' + + command_info += f'--cfg-option env_cfg.dist_cfg.port={port} ' + command_info += ' &' + + commands.append(command_info) + + +def main(): + args = parse_args() + if args.out: + out_suffix = args.out.split('.')[-1] + assert args.out.endswith('.sh'), \ + f'Expected out file path suffix is .sh, but get .{out_suffix}' + assert args.out or args.run, \ + ('Please specify at least one operation (save/run/ the ' + 'script) with the argument "--out" or "--run"') + + commands = [] + partition_name = 'PARTITION=$1 ' + commands.append(partition_name) + commands.append('\n') + + checkpoint_root = 'CHECKPOINT_DIR=$2 ' + commands.append(checkpoint_root) + commands.append('\n') + + work_dir = 'WORK_DIR=$3 ' + commands.append(work_dir) + commands.append('\n') + + cpus_pre_task = 'CPUS_PER_TASK=${4:-2} ' + commands.append(cpus_pre_task) + commands.append('\n') + + script_name = osp.join('tools', 'slurm_test.sh') + port = args.port + + cfg = Config.fromfile(args.config) + + for model_key in cfg: + model_infos = cfg[model_key] + if not isinstance(model_infos, list): + model_infos = [model_infos] + for model_info in model_infos: + print('processing: ', model_info['config']) + model_test_dict = process_model_info(model_info, work_dir) + create_test_bash_info(commands, model_test_dict, port, script_name, + '$PARTITION') + port += 1 + + command_str = ''.join(commands) + if args.out: + with open(args.out, 'w') as f: + f.write(command_str) + if args.run: + os.system(command_str) + + +if __name__ == '__main__': + main() diff --git a/mmdetection/.dev_scripts/convert_train_benchmark_script.py b/mmdetection/.dev_scripts/convert_train_benchmark_script.py new file mode 100644 index 00000000..278a76c5 --- /dev/null +++ b/mmdetection/.dev_scripts/convert_train_benchmark_script.py @@ -0,0 +1,104 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import argparse +import os +import os.path as osp + + +def parse_args(): + parser = argparse.ArgumentParser( + description='Convert benchmark model json to script') + parser.add_argument( + 'txt_path', type=str, help='txt path output by benchmark_filter') + parser.add_argument( + '--run', action='store_true', help='run script directly') + parser.add_argument( + '--out', type=str, help='path to save model benchmark script') + + args = parser.parse_args() + return args + + +def determine_gpus(cfg_name): + gpus = 8 + gpus_pre_node = 8 + + if cfg_name.find('16x') >= 0: + gpus = 16 + elif cfg_name.find('4xb4') >= 0: + gpus = 4 + gpus_pre_node = 4 + elif 'lad' in cfg_name: + gpus = 2 + gpus_pre_node = 2 + + return gpus, gpus_pre_node + + +def main(): + args = parse_args() + if args.out: + out_suffix = args.out.split('.')[-1] + assert args.out.endswith('.sh'), \ + f'Expected out file path suffix is .sh, but get .{out_suffix}' + assert args.out or args.run, \ + ('Please specify at least one operation (save/run/ the ' + 'script) with the argument "--out" or "--run"') + + root_name = './tools' + train_script_name = osp.join(root_name, 'slurm_train.sh') + + commands = [] + partition_name = 'PARTITION=$1 ' + commands.append(partition_name) + commands.append('\n') + + work_dir = 'WORK_DIR=$2 ' + commands.append(work_dir) + commands.append('\n') + + cpus_pre_task = 'CPUS_PER_TASK=${3:-4} ' + commands.append(cpus_pre_task) + commands.append('\n') + commands.append('\n') + + with open(args.txt_path, 'r') as f: + model_cfgs = f.readlines() + for i, cfg in enumerate(model_cfgs): + cfg = cfg.strip() + if len(cfg) == 0: + continue + # print cfg name + echo_info = f'echo \'{cfg}\' &' + commands.append(echo_info) + commands.append('\n') + + fname, _ = osp.splitext(osp.basename(cfg)) + out_fname = '$WORK_DIR/' + fname + + gpus, gpus_pre_node = determine_gpus(cfg) + command_info = f'GPUS={gpus} GPUS_PER_NODE={gpus_pre_node} ' \ + f'CPUS_PER_TASK=$CPUS_PRE_TASK {train_script_name} ' + command_info += '$PARTITION ' + command_info += f'{fname} ' + command_info += f'{cfg} ' + command_info += f'{out_fname} ' + + command_info += '--cfg-options default_hooks.checkpoint.' \ + 'max_keep_ckpts=1 ' + command_info += '&' + + commands.append(command_info) + + if i < len(model_cfgs): + commands.append('\n') + + command_str = ''.join(commands) + if args.out: + with open(args.out, 'w') as f: + f.write(command_str) + if args.run: + os.system(command_str) + + +if __name__ == '__main__': + main() diff --git a/mmdetection/.dev_scripts/covignore.cfg b/mmdetection/.dev_scripts/covignore.cfg new file mode 100644 index 00000000..a3de535a --- /dev/null +++ b/mmdetection/.dev_scripts/covignore.cfg @@ -0,0 +1,5 @@ +# Each line should be the relative path to the root directory +# of this repo. Support regular expression as well. +# For example: + +.*/__init__.py diff --git a/mmdetection/.dev_scripts/diff_coverage_test.sh b/mmdetection/.dev_scripts/diff_coverage_test.sh new file mode 100644 index 00000000..8dec2452 --- /dev/null +++ b/mmdetection/.dev_scripts/diff_coverage_test.sh @@ -0,0 +1,40 @@ +#!/bin/bash + +readarray -t IGNORED_FILES < $( dirname "$0" )/covignore.cfg +REUSE_COVERAGE_REPORT=${REUSE_COVERAGE_REPORT:-0} +REPO=${1:-"origin"} +BRANCH=${2:-"refactor_dev"} + +git fetch $REPO $BRANCH + +PY_FILES="" +for FILE_NAME in $(git diff --name-only ${REPO}/${BRANCH}); do + # Only test python files in mmdet/ existing in current branch, and not ignored in covignore.cfg + if [ ${FILE_NAME: -3} == ".py" ] && [ ${FILE_NAME:0:6} == "mmdet/" ] && [ -f "$FILE_NAME" ]; then + IGNORED=false + for IGNORED_FILE_NAME in "${IGNORED_FILES[@]}"; do + # Skip blank lines + if [ -z "$IGNORED_FILE_NAME" ]; then + continue + fi + if [ "${IGNORED_FILE_NAME::1}" != "#" ] && [[ "$FILE_NAME" =~ $IGNORED_FILE_NAME ]]; then + echo "Ignoring $FILE_NAME" + IGNORED=true + break + fi + done + if [ "$IGNORED" = false ]; then + PY_FILES="$PY_FILES $FILE_NAME" + fi + fi +done + +# Only test the coverage when PY_FILES are not empty, otherwise they will test the entire project +if [ ! -z "${PY_FILES}" ] +then + if [ "$REUSE_COVERAGE_REPORT" == "0" ]; then + coverage run --branch --source mmdet -m pytest tests/ + fi + coverage report --fail-under 80 -m $PY_FILES + interrogate -v --ignore-init-method --ignore-module --ignore-nested-functions --ignore-magic --ignore-regex "__repr__" --fail-under 95 $PY_FILES +fi diff --git a/mmdetection/.dev_scripts/download_checkpoints.py b/mmdetection/.dev_scripts/download_checkpoints.py new file mode 100644 index 00000000..fa5ef9dc --- /dev/null +++ b/mmdetection/.dev_scripts/download_checkpoints.py @@ -0,0 +1,83 @@ +# Copyright (c) OpenMMLab. All rights reserved. + +import argparse +import math +import os +import os.path as osp +from multiprocessing import Pool + +import torch +from mmengine.config import Config +from mmengine.utils import mkdir_or_exist + + +def download(url, out_file, min_bytes=math.pow(1024, 2), progress=True): + # math.pow(1024, 2) is mean 1 MB + assert_msg = f"Downloaded url '{url}' does not exist " \ + f'or size is < min_bytes={min_bytes}' + try: + print(f'Downloading {url} to {out_file}...') + torch.hub.download_url_to_file(url, str(out_file), progress=progress) + assert osp.exists( + out_file) and osp.getsize(out_file) > min_bytes, assert_msg + except Exception as e: + if osp.exists(out_file): + os.remove(out_file) + print(f'ERROR: {e}\nRe-attempting {url} to {out_file} ...') + os.system(f"curl -L '{url}' -o '{out_file}' --retry 3 -C -" + ) # curl download, retry and resume on fail + finally: + if osp.exists(out_file) and osp.getsize(out_file) < min_bytes: + os.remove(out_file) # remove partial downloads + + if not osp.exists(out_file): + print(f'ERROR: {assert_msg}\n') + print('=========================================\n') + + +def parse_args(): + parser = argparse.ArgumentParser(description='Download checkpoints') + parser.add_argument('config', help='test config file path') + parser.add_argument( + 'out', type=str, help='output dir of checkpoints to be stored') + parser.add_argument( + '--nproc', type=int, default=16, help='num of Processes') + parser.add_argument( + '--intranet', + action='store_true', + help='switch to internal network url') + args = parser.parse_args() + return args + + +if __name__ == '__main__': + args = parse_args() + mkdir_or_exist(args.out) + + cfg = Config.fromfile(args.config) + + checkpoint_url_list = [] + checkpoint_out_list = [] + + for model in cfg: + model_infos = cfg[model] + if not isinstance(model_infos, list): + model_infos = [model_infos] + for model_info in model_infos: + checkpoint = model_info['checkpoint'] + out_file = osp.join(args.out, checkpoint) + if not osp.exists(out_file): + + url = model_info['url'] + if args.intranet is True: + url = url.replace('.com', '.sensetime.com') + url = url.replace('https', 'http') + + checkpoint_url_list.append(url) + checkpoint_out_list.append(out_file) + + if len(checkpoint_url_list) > 0: + pool = Pool(min(os.cpu_count(), args.nproc)) + pool.starmap(download, zip(checkpoint_url_list, checkpoint_out_list)) + else: + print('No files to download!') diff --git a/mmdetection/.dev_scripts/gather_models.py b/mmdetection/.dev_scripts/gather_models.py new file mode 100644 index 00000000..52acdc3f --- /dev/null +++ b/mmdetection/.dev_scripts/gather_models.py @@ -0,0 +1,308 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import argparse +import glob +import os +import os.path as osp +import shutil +import subprocess +import time +from collections import OrderedDict + +import torch +import yaml +from mmengine.config import Config +from mmengine.fileio import dump +from mmengine.utils import digit_version, mkdir_or_exist, scandir + + +def ordered_yaml_dump(data, stream=None, Dumper=yaml.SafeDumper, **kwds): + + class OrderedDumper(Dumper): + pass + + def _dict_representer(dumper, data): + return dumper.represent_mapping( + yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG, data.items()) + + OrderedDumper.add_representer(OrderedDict, _dict_representer) + return yaml.dump(data, stream, OrderedDumper, **kwds) + + +def process_checkpoint(in_file, out_file): + checkpoint = torch.load(in_file, map_location='cpu') + # remove optimizer for smaller file size + if 'optimizer' in checkpoint: + del checkpoint['optimizer'] + if 'ema_state_dict' in checkpoint: + del checkpoint['ema_state_dict'] + + # remove ema state_dict + for key in list(checkpoint['state_dict']): + if key.startswith('ema_'): + checkpoint['state_dict'].pop(key) + elif key.startswith('data_preprocessor'): + checkpoint['state_dict'].pop(key) + + # if it is necessary to remove some sensitive data in checkpoint['meta'], + # add the code here. + if digit_version(torch.__version__) >= digit_version('1.6'): + torch.save(checkpoint, out_file, _use_new_zipfile_serialization=False) + else: + torch.save(checkpoint, out_file) + sha = subprocess.check_output(['sha256sum', out_file]).decode() + final_file = out_file.rstrip('.pth') + '-{}.pth'.format(sha[:8]) + subprocess.Popen(['mv', out_file, final_file]) + return final_file + + +def is_by_epoch(config): + cfg = Config.fromfile('./configs/' + config) + return cfg.train_cfg.type == 'EpochBasedTrainLoop' + + +def get_final_epoch_or_iter(config): + cfg = Config.fromfile('./configs/' + config) + if cfg.train_cfg.type == 'EpochBasedTrainLoop': + return cfg.train_cfg.max_epochs + else: + return cfg.train_cfg.max_iters + + +def get_best_epoch_or_iter(exp_dir): + best_epoch_iter_full_path = list( + sorted(glob.glob(osp.join(exp_dir, 'best_*.pth'))))[-1] + best_epoch_or_iter_model_path = best_epoch_iter_full_path.split('/')[-1] + best_epoch_or_iter = best_epoch_or_iter_model_path.\ + split('_')[-1].split('.')[0] + return best_epoch_or_iter_model_path, int(best_epoch_or_iter) + + +def get_real_epoch_or_iter(config): + cfg = Config.fromfile('./configs/' + config) + if cfg.train_cfg.type == 'EpochBasedTrainLoop': + epoch = cfg.train_cfg.max_epochs + return epoch + else: + return cfg.train_cfg.max_iters + + +def get_final_results(log_json_path, + epoch_or_iter, + results_lut='coco/bbox_mAP', + by_epoch=True): + result_dict = dict() + with open(log_json_path) as f: + r = f.readlines()[-1] + last_metric = r.split(',')[0].split(': ')[-1].strip() + result_dict[results_lut] = last_metric + return result_dict + + +def get_dataset_name(config): + # If there are more dataset, add here. + name_map = dict( + CityscapesDataset='Cityscapes', + CocoDataset='COCO', + CocoPanopticDataset='COCO', + DeepFashionDataset='Deep Fashion', + LVISV05Dataset='LVIS v0.5', + LVISV1Dataset='LVIS v1', + VOCDataset='Pascal VOC', + WIDERFaceDataset='WIDER Face', + OpenImagesDataset='OpenImagesDataset', + OpenImagesChallengeDataset='OpenImagesChallengeDataset', + Objects365V1Dataset='Objects365 v1', + Objects365V2Dataset='Objects365 v2') + cfg = Config.fromfile('./configs/' + config) + return name_map[cfg.dataset_type] + + +def find_last_dir(model_dir): + dst_times = [] + for time_stamp in os.scandir(model_dir): + if osp.isdir(time_stamp): + dst_time = time.mktime( + time.strptime(time_stamp.name, '%Y%m%d_%H%M%S')) + dst_times.append([dst_time, time_stamp.name]) + return max(dst_times, key=lambda x: x[0])[1] + + +def convert_model_info_to_pwc(model_infos): + pwc_files = {} + for model in model_infos: + cfg_folder_name = osp.split(model['config'])[-2] + pwc_model_info = OrderedDict() + pwc_model_info['Name'] = osp.split(model['config'])[-1].split('.')[0] + pwc_model_info['In Collection'] = 'Please fill in Collection name' + pwc_model_info['Config'] = osp.join('configs', model['config']) + + # get metadata + meta_data = OrderedDict() + if 'epochs' in model: + meta_data['Epochs'] = get_real_epoch_or_iter(model['config']) + else: + meta_data['Iterations'] = get_real_epoch_or_iter(model['config']) + pwc_model_info['Metadata'] = meta_data + + # get dataset name + dataset_name = get_dataset_name(model['config']) + + # get results + results = [] + # if there are more metrics, add here. + if 'bbox_mAP' in model['results']: + metric = round(model['results']['bbox_mAP'] * 100, 1) + results.append( + OrderedDict( + Task='Object Detection', + Dataset=dataset_name, + Metrics={'box AP': metric})) + if 'segm_mAP' in model['results']: + metric = round(model['results']['segm_mAP'] * 100, 1) + results.append( + OrderedDict( + Task='Instance Segmentation', + Dataset=dataset_name, + Metrics={'mask AP': metric})) + if 'PQ' in model['results']: + metric = round(model['results']['PQ'], 1) + results.append( + OrderedDict( + Task='Panoptic Segmentation', + Dataset=dataset_name, + Metrics={'PQ': metric})) + pwc_model_info['Results'] = results + + link_string = 'https://download.openmmlab.com/mmdetection/v3.0/' + link_string += '{}/{}'.format(model['config'].rstrip('.py'), + osp.split(model['model_path'])[-1]) + pwc_model_info['Weights'] = link_string + if cfg_folder_name in pwc_files: + pwc_files[cfg_folder_name].append(pwc_model_info) + else: + pwc_files[cfg_folder_name] = [pwc_model_info] + return pwc_files + + +def parse_args(): + parser = argparse.ArgumentParser(description='Gather benchmarked models') + parser.add_argument( + 'root', + type=str, + default='work_dirs', + help='root path of benchmarked models to be gathered') + parser.add_argument( + '--out', + type=str, + default='gather', + help='output path of gathered models to be stored') + parser.add_argument( + '--best', + action='store_true', + help='whether to gather the best model.') + + args = parser.parse_args() + return args + + +def main(): + args = parse_args() + models_root = args.root + models_out = args.out + mkdir_or_exist(models_out) + + # find all models in the root directory to be gathered + raw_configs = list(scandir('./configs', '.py', recursive=True)) + + # filter configs that is not trained in the experiments dir + used_configs = [] + for raw_config in raw_configs: + if osp.exists(osp.join(models_root, raw_config)): + used_configs.append(raw_config) + print(f'Find {len(used_configs)} models to be gathered') + + # find final_ckpt and log file for trained each config + # and parse the best performance + model_infos = [] + for used_config in used_configs: + exp_dir = osp.join(models_root, used_config) + by_epoch = is_by_epoch(used_config) + # check whether the exps is finished + if args.best is True: + final_model, final_epoch_or_iter = get_best_epoch_or_iter(exp_dir) + else: + final_epoch_or_iter = get_final_epoch_or_iter(used_config) + final_model = '{}_{}.pth'.format('epoch' if by_epoch else 'iter', + final_epoch_or_iter) + + model_path = osp.join(exp_dir, final_model) + # skip if the model is still training + if not osp.exists(model_path): + continue + + # get the latest logs + latest_exp_name = find_last_dir(exp_dir) + latest_exp_json = osp.join(exp_dir, latest_exp_name, 'vis_data', + latest_exp_name + '.json') + + model_performance = get_final_results( + latest_exp_json, final_epoch_or_iter, by_epoch=by_epoch) + + if model_performance is None: + continue + + model_info = dict( + config=used_config, + results=model_performance, + final_model=final_model, + latest_exp_json=latest_exp_json, + latest_exp_name=latest_exp_name) + model_info['epochs' if by_epoch else 'iterations'] =\ + final_epoch_or_iter + model_infos.append(model_info) + + # publish model for each checkpoint + publish_model_infos = [] + for model in model_infos: + model_publish_dir = osp.join(models_out, model['config'].rstrip('.py')) + mkdir_or_exist(model_publish_dir) + + model_name = osp.split(model['config'])[-1].split('.')[0] + + model_name += '_' + model['latest_exp_name'] + publish_model_path = osp.join(model_publish_dir, model_name) + trained_model_path = osp.join(models_root, model['config'], + model['final_model']) + + # convert model + final_model_path = process_checkpoint(trained_model_path, + publish_model_path) + + # copy log + shutil.copy(model['latest_exp_json'], + osp.join(model_publish_dir, f'{model_name}.log.json')) + + # copy config to guarantee reproducibility + config_path = model['config'] + config_path = osp.join( + 'configs', + config_path) if 'configs' not in config_path else config_path + target_config_path = osp.split(config_path)[-1] + shutil.copy(config_path, osp.join(model_publish_dir, + target_config_path)) + + model['model_path'] = final_model_path + publish_model_infos.append(model) + + models = dict(models=publish_model_infos) + print(f'Totally gathered {len(publish_model_infos)} models') + dump(models, osp.join(models_out, 'model_info.json')) + + pwc_files = convert_model_info_to_pwc(publish_model_infos) + for name in pwc_files: + with open(osp.join(models_out, name + '_metafile.yml'), 'w') as f: + ordered_yaml_dump(pwc_files[name], f, encoding='utf-8') + + +if __name__ == '__main__': + main() diff --git a/mmdetection/.dev_scripts/gather_test_benchmark_metric.py b/mmdetection/.dev_scripts/gather_test_benchmark_metric.py new file mode 100644 index 00000000..951bfe6f --- /dev/null +++ b/mmdetection/.dev_scripts/gather_test_benchmark_metric.py @@ -0,0 +1,96 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import argparse +import glob +import os.path as osp + +from mmengine.config import Config +from mmengine.fileio import dump, load +from mmengine.utils import mkdir_or_exist + + +def parse_args(): + parser = argparse.ArgumentParser( + description='Gather benchmarked models metric') + parser.add_argument('config', help='test config file path') + parser.add_argument( + 'root', + type=str, + help='root path of benchmarked models to be gathered') + parser.add_argument( + '--out', type=str, help='output path of gathered metrics to be stored') + parser.add_argument( + '--not-show', action='store_true', help='not show metrics') + parser.add_argument( + '--show-all', action='store_true', help='show all model metrics') + + args = parser.parse_args() + return args + + +if __name__ == '__main__': + args = parse_args() + + root_path = args.root + metrics_out = args.out + result_dict = {} + + cfg = Config.fromfile(args.config) + + for model_key in cfg: + model_infos = cfg[model_key] + if not isinstance(model_infos, list): + model_infos = [model_infos] + for model_info in model_infos: + record_metrics = model_info['metric'] + config = model_info['config'].strip() + fname, _ = osp.splitext(osp.basename(config)) + metric_json_dir = osp.join(root_path, fname) + if osp.exists(metric_json_dir): + json_list = glob.glob(osp.join(metric_json_dir, '*.json')) + if len(json_list) > 0: + log_json_path = list(sorted(json_list))[-1] + + metric = load(log_json_path) + if config in metric.get('config', {}): + + new_metrics = dict() + for record_metric_key in record_metrics: + record_metric_key_bk = record_metric_key + old_metric = record_metrics[record_metric_key] + if record_metric_key == 'AR_1000': + record_metric_key = 'AR@1000' + if record_metric_key not in metric['metric']: + raise KeyError( + 'record_metric_key not exist, please ' + 'check your config') + new_metric = round( + metric['metric'][record_metric_key] * 100, 1) + new_metrics[record_metric_key_bk] = new_metric + + if args.show_all: + result_dict[config] = dict( + before=record_metrics, after=new_metrics) + else: + for record_metric_key in record_metrics: + old_metric = record_metrics[record_metric_key] + new_metric = new_metrics[record_metric_key] + if old_metric != new_metric: + result_dict[config] = dict( + before=record_metrics, + after=new_metrics) + break + else: + print(f'{config} not included in: {log_json_path}') + else: + print(f'{config} not exist file: {metric_json_dir}') + else: + print(f'{config} not exist dir: {metric_json_dir}') + + if metrics_out: + mkdir_or_exist(metrics_out) + dump(result_dict, osp.join(metrics_out, 'batch_test_metric_info.json')) + if not args.not_show: + print('===================================') + for config_name, metrics in result_dict.items(): + print(config_name, metrics) + print('===================================') diff --git a/mmdetection/.dev_scripts/gather_train_benchmark_metric.py b/mmdetection/.dev_scripts/gather_train_benchmark_metric.py new file mode 100644 index 00000000..3d4c9cfc --- /dev/null +++ b/mmdetection/.dev_scripts/gather_train_benchmark_metric.py @@ -0,0 +1,151 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import argparse +import glob +import os.path as osp + +from gather_models import get_final_results +from mmengine.config import Config +from mmengine.fileio import dump +from mmengine.utils import mkdir_or_exist + +try: + import xlrd +except ImportError: + xlrd = None +try: + import xlutils + from xlutils.copy import copy +except ImportError: + xlutils = None + + +def parse_args(): + parser = argparse.ArgumentParser( + description='Gather benchmarked models metric') + parser.add_argument( + 'root', + type=str, + help='root path of benchmarked models to be gathered') + parser.add_argument( + 'txt_path', type=str, help='txt path output by benchmark_filter') + parser.add_argument( + '--out', type=str, help='output path of gathered metrics to be stored') + parser.add_argument( + '--not-show', action='store_true', help='not show metrics') + parser.add_argument( + '--excel', type=str, help='input path of excel to be recorded') + parser.add_argument( + '--ncol', type=int, help='Number of column to be modified or appended') + + args = parser.parse_args() + return args + + +if __name__ == '__main__': + args = parse_args() + + if args.excel: + assert args.ncol, 'Please specify "--excel" and "--ncol" ' \ + 'at the same time' + if xlrd is None: + raise RuntimeError( + 'xlrd is not installed,' + 'Please use “pip install xlrd==1.2.0” to install') + if xlutils is None: + raise RuntimeError( + 'xlutils is not installed,' + 'Please use “pip install xlutils==2.0.0” to install') + readbook = xlrd.open_workbook(args.excel) + sheet = readbook.sheet_by_name('Sheet1') + sheet_info = {} + total_nrows = sheet.nrows + for i in range(3, sheet.nrows): + sheet_info[sheet.row_values(i)[0]] = i + xlrw = copy(readbook) + table = xlrw.get_sheet(0) + + root_path = args.root + metrics_out = args.out + + result_dict = {} + with open(args.txt_path, 'r') as f: + model_cfgs = f.readlines() + for i, config in enumerate(model_cfgs): + config = config.strip() + if len(config) == 0: + continue + + config_name = osp.split(config)[-1] + config_name = osp.splitext(config_name)[0] + result_path = osp.join(root_path, config_name) + if osp.exists(result_path): + # 1 read config + cfg = Config.fromfile(config) + total_epochs = cfg.runner.max_epochs + final_results = cfg.evaluation.metric + if not isinstance(final_results, list): + final_results = [final_results] + final_results_out = [] + for key in final_results: + if 'proposal_fast' in key: + final_results_out.append('AR@1000') # RPN + elif 'mAP' not in key: + final_results_out.append(key + '_mAP') + + # 2 determine whether total_epochs ckpt exists + ckpt_path = f'epoch_{total_epochs}.pth' + if osp.exists(osp.join(result_path, ckpt_path)): + log_json_path = list( + sorted(glob.glob(osp.join(result_path, + '*.log.json'))))[-1] + + # 3 read metric + model_performance = get_final_results( + log_json_path, total_epochs, final_results_out) + if model_performance is None: + print(f'log file error: {log_json_path}') + continue + for performance in model_performance: + if performance in ['AR@1000', 'bbox_mAP', 'segm_mAP']: + metric = round( + model_performance[performance] * 100, 1) + model_performance[performance] = metric + result_dict[config] = model_performance + + # update and append excel content + if args.excel: + if 'AR@1000' in model_performance: + metrics = f'{model_performance["AR@1000"]}' \ + f'(AR@1000)' + elif 'segm_mAP' in model_performance: + metrics = f'{model_performance["bbox_mAP"]}/' \ + f'{model_performance["segm_mAP"]}' + else: + metrics = f'{model_performance["bbox_mAP"]}' + + row_num = sheet_info.get(config, None) + if row_num: + table.write(row_num, args.ncol, metrics) + else: + table.write(total_nrows, 0, config) + table.write(total_nrows, args.ncol, metrics) + total_nrows += 1 + + else: + print(f'{config} not exist: {ckpt_path}') + else: + print(f'not exist: {config}') + + # 4 save or print results + if metrics_out: + mkdir_or_exist(metrics_out) + dump(result_dict, osp.join(metrics_out, 'model_metric_info.json')) + if not args.not_show: + print('===================================') + for config_name, metrics in result_dict.items(): + print(config_name, metrics) + print('===================================') + if args.excel: + filename, sufflx = osp.splitext(args.excel) + xlrw.save(f'{filename}_o{sufflx}') + print(f'>>> Output {filename}_o{sufflx}') diff --git a/mmdetection/.dev_scripts/linter.sh b/mmdetection/.dev_scripts/linter.sh new file mode 100644 index 00000000..b0fe0acf --- /dev/null +++ b/mmdetection/.dev_scripts/linter.sh @@ -0,0 +1,3 @@ +yapf -r -i mmdet/ configs/ tests/ tools/ +isort -rc mmdet/ configs/ tests/ tools/ +flake8 . diff --git a/mmdetection/.dev_scripts/test_benchmark.sh b/mmdetection/.dev_scripts/test_benchmark.sh new file mode 100644 index 00000000..8fae1670 --- /dev/null +++ b/mmdetection/.dev_scripts/test_benchmark.sh @@ -0,0 +1,157 @@ +PARTITION=$1 +CHECKPOINT_DIR=$2 +WORK_DIR=$3 +CPUS_PER_TASK=${4:-2} + +echo 'configs/atss/atss_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION atss_r50_fpn_1x_coco configs/atss/atss_r50_fpn_1x_coco.py $CHECKPOINT_DIR/atss_r50_fpn_1x_coco_20200209-985f7bd0.pth --work-dir $WORK_DIR/atss_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29666 & +echo 'configs/autoassign/autoassign_r50-caffe_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION autoassign_r50-caffe_fpn_1x_coco configs/autoassign/autoassign_r50-caffe_fpn_1x_coco.py $CHECKPOINT_DIR/auto_assign_r50_fpn_1x_coco_20210413_115540-5e17991f.pth --work-dir $WORK_DIR/autoassign_r50-caffe_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29667 & +echo 'configs/carafe/faster-rcnn_r50_fpn-carafe_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION faster-rcnn_r50_fpn-carafe_1x_coco configs/carafe/faster-rcnn_r50_fpn-carafe_1x_coco.py $CHECKPOINT_DIR/faster_rcnn_r50_fpn_carafe_1x_coco_bbox_mAP-0.386_20200504_175733-385a75b7.pth --work-dir $WORK_DIR/faster-rcnn_r50_fpn-carafe_1x_coco --cfg-option env_cfg.dist_cfg.port=29668 & +echo 'configs/cascade_rcnn/cascade-rcnn_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION cascade-rcnn_r50_fpn_1x_coco configs/cascade_rcnn/cascade-rcnn_r50_fpn_1x_coco.py $CHECKPOINT_DIR/cascade_rcnn_r50_fpn_1x_coco_20200316-3dc56deb.pth --work-dir $WORK_DIR/cascade-rcnn_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29669 & +echo 'configs/cascade_rcnn/cascade-mask-rcnn_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION cascade-mask-rcnn_r50_fpn_1x_coco configs/cascade_rcnn/cascade-mask-rcnn_r50_fpn_1x_coco.py $CHECKPOINT_DIR/cascade_mask_rcnn_r50_fpn_1x_coco_20200203-9d4dcb24.pth --work-dir $WORK_DIR/cascade-mask-rcnn_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29670 & +echo 'configs/cascade_rpn/cascade-rpn_faster-rcnn_r50-caffe_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION cascade-rpn_faster-rcnn_r50-caffe_fpn_1x_coco configs/cascade_rpn/cascade-rpn_faster-rcnn_r50-caffe_fpn_1x_coco.py $CHECKPOINT_DIR/crpn_faster_rcnn_r50_caffe_fpn_1x_coco-c8283cca.pth --work-dir $WORK_DIR/cascade-rpn_faster-rcnn_r50-caffe_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29671 & +echo 'configs/centernet/centernet_r18-dcnv2_8xb16-crop512-140e_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION centernet_r18-dcnv2_8xb16-crop512-140e_coco configs/centernet/centernet_r18-dcnv2_8xb16-crop512-140e_coco.py $CHECKPOINT_DIR/centernet_resnet18_dcnv2_140e_coco_20210702_155131-c8cd631f.pth --work-dir $WORK_DIR/centernet_r18-dcnv2_8xb16-crop512-140e_coco --cfg-option env_cfg.dist_cfg.port=29672 & +echo 'configs/centripetalnet/centripetalnet_hourglass104_16xb6-crop511-210e-mstest_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION centripetalnet_hourglass104_16xb6-crop511-210e-mstest_coco configs/centripetalnet/centripetalnet_hourglass104_16xb6-crop511-210e-mstest_coco.py $CHECKPOINT_DIR/centripetalnet_hourglass104_mstest_16x6_210e_coco_20200915_204804-3ccc61e5.pth --work-dir $WORK_DIR/centripetalnet_hourglass104_16xb6-crop511-210e-mstest_coco --cfg-option env_cfg.dist_cfg.port=29673 & +echo 'configs/convnext/cascade-mask-rcnn_convnext-s-p4-w7_fpn_4conv1fc-giou_amp-ms-crop-3x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION cascade-mask-rcnn_convnext-s-p4-w7_fpn_4conv1fc-giou_amp-ms-crop-3x_coco configs/convnext/cascade-mask-rcnn_convnext-s-p4-w7_fpn_4conv1fc-giou_amp-ms-crop-3x_coco.py $CHECKPOINT_DIR/cascade_mask_rcnn_convnext-s_p4_w7_fpn_giou_4conv1f_fp16_ms-crop_3x_coco_20220510_201004-3d24f5a4.pth --work-dir $WORK_DIR/cascade-mask-rcnn_convnext-s-p4-w7_fpn_4conv1fc-giou_amp-ms-crop-3x_coco --cfg-option env_cfg.dist_cfg.port=29674 & +echo 'configs/cornernet/cornernet_hourglass104_8xb6-210e-mstest_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION cornernet_hourglass104_8xb6-210e-mstest_coco configs/cornernet/cornernet_hourglass104_8xb6-210e-mstest_coco.py $CHECKPOINT_DIR/cornernet_hourglass104_mstest_8x6_210e_coco_20200825_150618-79b44c30.pth --work-dir $WORK_DIR/cornernet_hourglass104_8xb6-210e-mstest_coco --cfg-option env_cfg.dist_cfg.port=29675 & +echo 'configs/dcn/faster-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION faster-rcnn_r50-dconv-c3-c5_fpn_1x_coco configs/dcn/faster-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py $CHECKPOINT_DIR/faster_rcnn_r50_fpn_dconv_c3-c5_1x_coco_20200130-d68aed1e.pth --work-dir $WORK_DIR/faster-rcnn_r50-dconv-c3-c5_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29676 & +echo 'configs/dcnv2/faster-rcnn_r50_fpn_mdpool_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION faster-rcnn_r50_fpn_mdpool_1x_coco configs/dcnv2/faster-rcnn_r50_fpn_mdpool_1x_coco.py $CHECKPOINT_DIR/faster_rcnn_r50_fpn_mdpool_1x_coco_20200307-c0df27ff.pth --work-dir $WORK_DIR/faster-rcnn_r50_fpn_mdpool_1x_coco --cfg-option env_cfg.dist_cfg.port=29677 & +echo 'configs/ddod/ddod_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION ddod_r50_fpn_1x_coco configs/ddod/ddod_r50_fpn_1x_coco.py $CHECKPOINT_DIR/ddod_r50_fpn_1x_coco_20220523_223737-29b2fc67.pth --work-dir $WORK_DIR/ddod_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29678 & +echo 'configs/deformable_detr/deformable-detr_r50_16xb2-50e_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION deformable-detr_r50_16xb2-50e_coco configs/deformable_detr/deformable-detr_r50_16xb2-50e_coco.py $CHECKPOINT_DIR/deformable_detr_r50_16x2_50e_coco_20210419_220030-a12b9512.pth --work-dir $WORK_DIR/deformable-detr_r50_16xb2-50e_coco --cfg-option env_cfg.dist_cfg.port=29679 & +echo 'configs/detectors/detectors_htc-r50_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION detectors_htc-r50_1x_coco configs/detectors/detectors_htc-r50_1x_coco.py $CHECKPOINT_DIR/detectors_htc_r50_1x_coco-329b1453.pth --work-dir $WORK_DIR/detectors_htc-r50_1x_coco --cfg-option env_cfg.dist_cfg.port=29680 & +echo 'configs/detr/detr_r50_8xb2-150e_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION detr_r50_8xb2-150e_coco configs/detr/detr_r50_8xb2-150e_coco.py $CHECKPOINT_DIR/detr_r50_8x2_150e_coco_20201130_194835-2c4b8974.pth --work-dir $WORK_DIR/detr_r50_8xb2-150e_coco --cfg-option env_cfg.dist_cfg.port=29681 & +echo 'configs/double_heads/dh-faster-rcnn_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION dh-faster-rcnn_r50_fpn_1x_coco configs/double_heads/dh-faster-rcnn_r50_fpn_1x_coco.py $CHECKPOINT_DIR/dh_faster_rcnn_r50_fpn_1x_coco_20200130-586b67df.pth --work-dir $WORK_DIR/dh-faster-rcnn_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29682 & +echo 'configs/dyhead/atss_r50_fpn_dyhead_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION atss_r50_fpn_dyhead_1x_coco configs/dyhead/atss_r50_fpn_dyhead_1x_coco.py $CHECKPOINT_DIR/atss_r50_fpn_dyhead_4x4_1x_coco_20211219_023314-eaa620c6.pth --work-dir $WORK_DIR/atss_r50_fpn_dyhead_1x_coco --cfg-option env_cfg.dist_cfg.port=29683 & +echo 'configs/dynamic_rcnn/dynamic-rcnn_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION dynamic-rcnn_r50_fpn_1x_coco configs/dynamic_rcnn/dynamic-rcnn_r50_fpn_1x_coco.py $CHECKPOINT_DIR/dynamic_rcnn_r50_fpn_1x-62a3f276.pth --work-dir $WORK_DIR/dynamic-rcnn_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29684 & +echo 'configs/efficientnet/retinanet_effb3_fpn_8xb4-crop896-1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION retinanet_effb3_fpn_8xb4-crop896-1x_coco configs/efficientnet/retinanet_effb3_fpn_8xb4-crop896-1x_coco.py $CHECKPOINT_DIR/retinanet_effb3_fpn_crop896_8x4_1x_coco_20220322_234806-615a0dda.pth --work-dir $WORK_DIR/retinanet_effb3_fpn_8xb4-crop896-1x_coco --cfg-option env_cfg.dist_cfg.port=29685 & +echo 'configs/empirical_attention/faster-rcnn_r50-attn1111_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION faster-rcnn_r50-attn1111_fpn_1x_coco configs/empirical_attention/faster-rcnn_r50-attn1111_fpn_1x_coco.py $CHECKPOINT_DIR/faster_rcnn_r50_fpn_attention_1111_1x_coco_20200130-403cccba.pth --work-dir $WORK_DIR/faster-rcnn_r50-attn1111_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29686 & +echo 'configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION faster-rcnn_r50_fpn_1x_coco configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py $CHECKPOINT_DIR/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth --work-dir $WORK_DIR/faster-rcnn_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29687 & +echo 'configs/fcos/fcos_r50-caffe_fpn_gn-head-center-normbbox-centeronreg-giou_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION fcos_r50-caffe_fpn_gn-head-center-normbbox-centeronreg-giou_1x_coco configs/fcos/fcos_r50-caffe_fpn_gn-head-center-normbbox-centeronreg-giou_1x_coco.py $CHECKPOINT_DIR/fcos_center-normbbox-centeronreg-giou_r50_caffe_fpn_gn-head_1x_coco-0a0d75a8.pth --work-dir $WORK_DIR/fcos_r50-caffe_fpn_gn-head-center-normbbox-centeronreg-giou_1x_coco --cfg-option env_cfg.dist_cfg.port=29688 & +echo 'configs/foveabox/fovea_r50_fpn_gn-head-align_4xb4-2x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION fovea_r50_fpn_gn-head-align_4xb4-2x_coco configs/foveabox/fovea_r50_fpn_gn-head-align_4xb4-2x_coco.py $CHECKPOINT_DIR/fovea_align_r50_fpn_gn-head_4x4_2x_coco_20200203-8987880d.pth --work-dir $WORK_DIR/fovea_r50_fpn_gn-head-align_4xb4-2x_coco --cfg-option env_cfg.dist_cfg.port=29689 & +echo 'configs/fpg/mask-rcnn_r50_fpg_crop640-50e_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION mask-rcnn_r50_fpg_crop640-50e_coco configs/fpg/mask-rcnn_r50_fpg_crop640-50e_coco.py $CHECKPOINT_DIR/mask_rcnn_r50_fpg_crop640_50e_coco_20220311_011857-233b8334.pth --work-dir $WORK_DIR/mask-rcnn_r50_fpg_crop640-50e_coco --cfg-option env_cfg.dist_cfg.port=29690 & +echo 'configs/free_anchor/freeanchor_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION freeanchor_r50_fpn_1x_coco configs/free_anchor/freeanchor_r50_fpn_1x_coco.py $CHECKPOINT_DIR/retinanet_free_anchor_r50_fpn_1x_coco_20200130-0f67375f.pth --work-dir $WORK_DIR/freeanchor_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29691 & +echo 'configs/fsaf/fsaf_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION fsaf_r50_fpn_1x_coco configs/fsaf/fsaf_r50_fpn_1x_coco.py $CHECKPOINT_DIR/fsaf_r50_fpn_1x_coco-94ccc51f.pth --work-dir $WORK_DIR/fsaf_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29692 & +echo 'configs/gcnet/mask-rcnn_r50-syncbn-gcb-r16-c3-c5_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION mask-rcnn_r50-syncbn-gcb-r16-c3-c5_fpn_1x_coco configs/gcnet/mask-rcnn_r50-syncbn-gcb-r16-c3-c5_fpn_1x_coco.py $CHECKPOINT_DIR/mask_rcnn_r50_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco_20200202-587b99aa.pth --work-dir $WORK_DIR/mask-rcnn_r50-syncbn-gcb-r16-c3-c5_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29693 & +echo 'configs/gfl/gfl_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION gfl_r50_fpn_1x_coco configs/gfl/gfl_r50_fpn_1x_coco.py $CHECKPOINT_DIR/gfl_r50_fpn_1x_coco_20200629_121244-25944287.pth --work-dir $WORK_DIR/gfl_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29694 & +echo 'configs/ghm/retinanet_r50_fpn_ghm-1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION retinanet_r50_fpn_ghm-1x_coco configs/ghm/retinanet_r50_fpn_ghm-1x_coco.py $CHECKPOINT_DIR/retinanet_ghm_r50_fpn_1x_coco_20200130-a437fda3.pth --work-dir $WORK_DIR/retinanet_r50_fpn_ghm-1x_coco --cfg-option env_cfg.dist_cfg.port=29695 & +echo 'configs/gn/mask-rcnn_r50_fpn_gn-all_2x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION mask-rcnn_r50_fpn_gn-all_2x_coco configs/gn/mask-rcnn_r50_fpn_gn-all_2x_coco.py $CHECKPOINT_DIR/mask_rcnn_r50_fpn_gn-all_2x_coco_20200206-8eee02a6.pth --work-dir $WORK_DIR/mask-rcnn_r50_fpn_gn-all_2x_coco --cfg-option env_cfg.dist_cfg.port=29696 & +echo 'configs/gn+ws/faster-rcnn_r50_fpn_gn-ws-all_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION faster-rcnn_r50_fpn_gn-ws-all_1x_coco configs/gn+ws/faster-rcnn_r50_fpn_gn-ws-all_1x_coco.py $CHECKPOINT_DIR/faster_rcnn_r50_fpn_gn_ws-all_1x_coco_20200130-613d9fe2.pth --work-dir $WORK_DIR/faster-rcnn_r50_fpn_gn-ws-all_1x_coco --cfg-option env_cfg.dist_cfg.port=29697 & +echo 'configs/grid_rcnn/grid-rcnn_r50_fpn_gn-head_2x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION grid-rcnn_r50_fpn_gn-head_2x_coco configs/grid_rcnn/grid-rcnn_r50_fpn_gn-head_2x_coco.py $CHECKPOINT_DIR/grid_rcnn_r50_fpn_gn-head_2x_coco_20200130-6cca8223.pth --work-dir $WORK_DIR/grid-rcnn_r50_fpn_gn-head_2x_coco --cfg-option env_cfg.dist_cfg.port=29698 & +echo 'configs/groie/faste-rcnn_r50_fpn_groie_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION faste-rcnn_r50_fpn_groie_1x_coco configs/groie/faste-rcnn_r50_fpn_groie_1x_coco.py $CHECKPOINT_DIR/faster_rcnn_r50_fpn_groie_1x_coco_20200604_211715-66ee9516.pth --work-dir $WORK_DIR/faste-rcnn_r50_fpn_groie_1x_coco --cfg-option env_cfg.dist_cfg.port=29699 & +echo 'configs/guided_anchoring/ga-retinanet_r50-caffe_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION ga-retinanet_r50-caffe_fpn_1x_coco configs/guided_anchoring/ga-retinanet_r50-caffe_fpn_1x_coco.py $CHECKPOINT_DIR/ga_retinanet_r50_caffe_fpn_1x_coco_20201020-39581c6f.pth --work-dir $WORK_DIR/ga-retinanet_r50-caffe_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29700 & +echo 'configs/hrnet/faster-rcnn_hrnetv2p-w18-1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION faster-rcnn_hrnetv2p-w18-1x_coco configs/hrnet/faster-rcnn_hrnetv2p-w18-1x_coco.py $CHECKPOINT_DIR/faster_rcnn_hrnetv2p_w18_1x_coco_20200130-56651a6d.pth --work-dir $WORK_DIR/faster-rcnn_hrnetv2p-w18-1x_coco --cfg-option env_cfg.dist_cfg.port=29701 & +echo 'configs/htc/htc_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION htc_r50_fpn_1x_coco configs/htc/htc_r50_fpn_1x_coco.py $CHECKPOINT_DIR/htc_r50_fpn_1x_coco_20200317-7332cf16.pth --work-dir $WORK_DIR/htc_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29702 & +echo 'configs/instaboost/mask-rcnn_r50_fpn_instaboost-4x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION mask-rcnn_r50_fpn_instaboost-4x_coco configs/instaboost/mask-rcnn_r50_fpn_instaboost-4x_coco.py $CHECKPOINT_DIR/mask_rcnn_r50_fpn_instaboost_4x_coco_20200307-d025f83a.pth --work-dir $WORK_DIR/mask-rcnn_r50_fpn_instaboost-4x_coco --cfg-option env_cfg.dist_cfg.port=29703 & +echo 'configs/libra_rcnn/libra-faster-rcnn_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION libra-faster-rcnn_r50_fpn_1x_coco configs/libra_rcnn/libra-faster-rcnn_r50_fpn_1x_coco.py $CHECKPOINT_DIR/libra_faster_rcnn_r50_fpn_1x_coco_20200130-3afee3a9.pth --work-dir $WORK_DIR/libra-faster-rcnn_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29704 & +echo 'configs/mask2former/mask2former_r50_8xb2-lsj-50e_coco-panoptic.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION mask2former_r50_8xb2-lsj-50e_coco-panoptic configs/mask2former/mask2former_r50_8xb2-lsj-50e_coco-panoptic.py $CHECKPOINT_DIR/mask2former_r50_lsj_8x2_50e_coco-panoptic_20220326_224516-11a44721.pth --work-dir $WORK_DIR/mask2former_r50_8xb2-lsj-50e_coco-panoptic --cfg-option env_cfg.dist_cfg.port=29705 & +echo 'configs/mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION mask-rcnn_r50_fpn_1x_coco configs/mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py $CHECKPOINT_DIR/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth --work-dir $WORK_DIR/mask-rcnn_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29706 & +echo 'configs/maskformer/maskformer_r50_ms-16xb1-75e_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION maskformer_r50_ms-16xb1-75e_coco configs/maskformer/maskformer_r50_ms-16xb1-75e_coco.py $CHECKPOINT_DIR/maskformer_r50_mstrain_16x1_75e_coco_20220221_141956-bc2699cb.pth --work-dir $WORK_DIR/maskformer_r50_ms-16xb1-75e_coco --cfg-option env_cfg.dist_cfg.port=29707 & +echo 'configs/ms_rcnn/ms-rcnn_r50-caffe_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION ms-rcnn_r50-caffe_fpn_1x_coco configs/ms_rcnn/ms-rcnn_r50-caffe_fpn_1x_coco.py $CHECKPOINT_DIR/ms_rcnn_r50_caffe_fpn_1x_coco_20200702_180848-61c9355e.pth --work-dir $WORK_DIR/ms-rcnn_r50-caffe_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29708 & +echo 'configs/nas_fcos/nas-fcos_r50-caffe_fpn_nashead-gn-head_4xb4-1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION nas-fcos_r50-caffe_fpn_nashead-gn-head_4xb4-1x_coco configs/nas_fcos/nas-fcos_r50-caffe_fpn_nashead-gn-head_4xb4-1x_coco.py $CHECKPOINT_DIR/nas_fcos_nashead_r50_caffe_fpn_gn-head_4x4_1x_coco_20200520-1bdba3ce.pth --work-dir $WORK_DIR/nas-fcos_r50-caffe_fpn_nashead-gn-head_4xb4-1x_coco --cfg-option env_cfg.dist_cfg.port=29709 & +echo 'configs/nas_fpn/retinanet_r50_nasfpn_crop640-50e_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION retinanet_r50_nasfpn_crop640-50e_coco configs/nas_fpn/retinanet_r50_nasfpn_crop640-50e_coco.py $CHECKPOINT_DIR/retinanet_r50_nasfpn_crop640_50e_coco-0ad1f644.pth --work-dir $WORK_DIR/retinanet_r50_nasfpn_crop640-50e_coco --cfg-option env_cfg.dist_cfg.port=29710 & +echo 'configs/paa/paa_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION paa_r50_fpn_1x_coco configs/paa/paa_r50_fpn_1x_coco.py $CHECKPOINT_DIR/paa_r50_fpn_1x_coco_20200821-936edec3.pth --work-dir $WORK_DIR/paa_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29711 & +echo 'configs/pafpn/faster-rcnn_r50_pafpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION faster-rcnn_r50_pafpn_1x_coco configs/pafpn/faster-rcnn_r50_pafpn_1x_coco.py $CHECKPOINT_DIR/faster_rcnn_r50_pafpn_1x_coco_bbox_mAP-0.375_20200503_105836-b7b4b9bd.pth --work-dir $WORK_DIR/faster-rcnn_r50_pafpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29712 & +echo 'configs/panoptic_fpn/panoptic-fpn_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION panoptic-fpn_r50_fpn_1x_coco configs/panoptic_fpn/panoptic-fpn_r50_fpn_1x_coco.py $CHECKPOINT_DIR/panoptic_fpn_r50_fpn_1x_coco_20210821_101153-9668fd13.pth --work-dir $WORK_DIR/panoptic-fpn_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29713 & +echo 'configs/pisa/faster-rcnn_r50_fpn_pisa_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION faster-rcnn_r50_fpn_pisa_1x_coco configs/pisa/faster-rcnn_r50_fpn_pisa_1x_coco.py $CHECKPOINT_DIR/pisa_faster_rcnn_r50_fpn_1x_coco-dea93523.pth --work-dir $WORK_DIR/faster-rcnn_r50_fpn_pisa_1x_coco --cfg-option env_cfg.dist_cfg.port=29714 & +echo 'configs/point_rend/point-rend_r50-caffe_fpn_ms-1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION point-rend_r50-caffe_fpn_ms-1x_coco configs/point_rend/point-rend_r50-caffe_fpn_ms-1x_coco.py $CHECKPOINT_DIR/point_rend_r50_caffe_fpn_mstrain_1x_coco-1bcb5fb4.pth --work-dir $WORK_DIR/point-rend_r50-caffe_fpn_ms-1x_coco --cfg-option env_cfg.dist_cfg.port=29715 & +echo 'configs/pvt/retinanet_pvt-s_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION retinanet_pvt-s_fpn_1x_coco configs/pvt/retinanet_pvt-s_fpn_1x_coco.py $CHECKPOINT_DIR/retinanet_pvt-s_fpn_1x_coco_20210906_142921-b6c94a5b.pth --work-dir $WORK_DIR/retinanet_pvt-s_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29716 & +echo 'configs/queryinst/queryinst_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION queryinst_r50_fpn_1x_coco configs/queryinst/queryinst_r50_fpn_1x_coco.py $CHECKPOINT_DIR/queryinst_r50_fpn_1x_coco_20210907_084916-5a8f1998.pth --work-dir $WORK_DIR/queryinst_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29717 & +echo 'configs/regnet/mask-rcnn_regnetx-3.2GF_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION mask-rcnn_regnetx-3.2GF_fpn_1x_coco configs/regnet/mask-rcnn_regnetx-3.2GF_fpn_1x_coco.py $CHECKPOINT_DIR/mask_rcnn_regnetx-3.2GF_fpn_1x_coco_20200520_163141-2a9d1814.pth --work-dir $WORK_DIR/mask-rcnn_regnetx-3.2GF_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29718 & +echo 'configs/reppoints/reppoints-moment_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION reppoints-moment_r50_fpn_1x_coco configs/reppoints/reppoints-moment_r50_fpn_1x_coco.py $CHECKPOINT_DIR/reppoints_moment_r50_fpn_1x_coco_20200330-b73db8d1.pth --work-dir $WORK_DIR/reppoints-moment_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29719 & +echo 'configs/res2net/faster-rcnn_res2net-101_fpn_2x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION faster-rcnn_res2net-101_fpn_2x_coco configs/res2net/faster-rcnn_res2net-101_fpn_2x_coco.py $CHECKPOINT_DIR/faster_rcnn_r2_101_fpn_2x_coco-175f1da6.pth --work-dir $WORK_DIR/faster-rcnn_res2net-101_fpn_2x_coco --cfg-option env_cfg.dist_cfg.port=29720 & +echo 'configs/resnest/faster-rcnn_s50_fpn_syncbn-backbone+head_ms-range-1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION faster-rcnn_s50_fpn_syncbn-backbone+head_ms-range-1x_coco configs/resnest/faster-rcnn_s50_fpn_syncbn-backbone+head_ms-range-1x_coco.py $CHECKPOINT_DIR/faster_rcnn_s50_fpn_syncbn-backbone+head_mstrain-range_1x_coco_20200926_125502-20289c16.pth --work-dir $WORK_DIR/faster-rcnn_s50_fpn_syncbn-backbone+head_ms-range-1x_coco --cfg-option env_cfg.dist_cfg.port=29721 & +echo 'configs/resnet_strikes_back/mask-rcnn_r50-rsb-pre_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION mask-rcnn_r50-rsb-pre_fpn_1x_coco configs/resnet_strikes_back/mask-rcnn_r50-rsb-pre_fpn_1x_coco.py $CHECKPOINT_DIR/mask_rcnn_r50_fpn_rsb-pretrain_1x_coco_20220113_174054-06ce8ba0.pth --work-dir $WORK_DIR/mask-rcnn_r50-rsb-pre_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29722 & +echo 'configs/retinanet/retinanet_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION retinanet_r50_fpn_1x_coco configs/retinanet/retinanet_r50_fpn_1x_coco.py $CHECKPOINT_DIR/retinanet_r50_fpn_1x_coco_20200130-c2398f9e.pth --work-dir $WORK_DIR/retinanet_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29723 & +echo 'configs/rpn/rpn_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION rpn_r50_fpn_1x_coco configs/rpn/rpn_r50_fpn_1x_coco.py $CHECKPOINT_DIR/rpn_r50_fpn_1x_coco_20200218-5525fa2e.pth --work-dir $WORK_DIR/rpn_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29724 & +echo 'configs/sabl/sabl-retinanet_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION sabl-retinanet_r50_fpn_1x_coco configs/sabl/sabl-retinanet_r50_fpn_1x_coco.py $CHECKPOINT_DIR/sabl_retinanet_r50_fpn_1x_coco-6c54fd4f.pth --work-dir $WORK_DIR/sabl-retinanet_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29725 & +echo 'configs/sabl/sabl-faster-rcnn_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION sabl-faster-rcnn_r50_fpn_1x_coco configs/sabl/sabl-faster-rcnn_r50_fpn_1x_coco.py $CHECKPOINT_DIR/sabl_faster_rcnn_r50_fpn_1x_coco-e867595b.pth --work-dir $WORK_DIR/sabl-faster-rcnn_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29726 & +echo 'configs/scnet/scnet_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION scnet_r50_fpn_1x_coco configs/scnet/scnet_r50_fpn_1x_coco.py $CHECKPOINT_DIR/scnet_r50_fpn_1x_coco-c3f09857.pth --work-dir $WORK_DIR/scnet_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29727 & +echo 'configs/scratch/mask-rcnn_r50-scratch_fpn_gn-all_6x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION mask-rcnn_r50-scratch_fpn_gn-all_6x_coco configs/scratch/mask-rcnn_r50-scratch_fpn_gn-all_6x_coco.py $CHECKPOINT_DIR/scratch_mask_rcnn_r50_fpn_gn_6x_bbox_mAP-0.412__segm_mAP-0.374_20200201_193051-1e190a40.pth --work-dir $WORK_DIR/mask-rcnn_r50-scratch_fpn_gn-all_6x_coco --cfg-option env_cfg.dist_cfg.port=29728 & +echo 'configs/solo/decoupled-solo_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION decoupled-solo_r50_fpn_1x_coco configs/solo/decoupled-solo_r50_fpn_1x_coco.py $CHECKPOINT_DIR/decoupled_solo_r50_fpn_1x_coco_20210820_233348-6337c589.pth --work-dir $WORK_DIR/decoupled-solo_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29729 & +echo 'configs/solov2/solov2_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION solov2_r50_fpn_1x_coco configs/solov2/solov2_r50_fpn_1x_coco.py $CHECKPOINT_DIR/solov2_r50_fpn_1x_coco_20220512_125858-a357fa23.pth --work-dir $WORK_DIR/solov2_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29730 & +echo 'configs/sparse_rcnn/sparse-rcnn_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION sparse-rcnn_r50_fpn_1x_coco configs/sparse_rcnn/sparse-rcnn_r50_fpn_1x_coco.py $CHECKPOINT_DIR/sparse_rcnn_r50_fpn_1x_coco_20201222_214453-dc79b137.pth --work-dir $WORK_DIR/sparse-rcnn_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29731 & +echo 'configs/ssd/ssd300_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION ssd300_coco configs/ssd/ssd300_coco.py $CHECKPOINT_DIR/ssd300_coco_20210803_015428-d231a06e.pth --work-dir $WORK_DIR/ssd300_coco --cfg-option env_cfg.dist_cfg.port=29732 & +echo 'configs/ssd/ssdlite_mobilenetv2-scratch_8xb24-600e_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION ssdlite_mobilenetv2-scratch_8xb24-600e_coco configs/ssd/ssdlite_mobilenetv2-scratch_8xb24-600e_coco.py $CHECKPOINT_DIR/ssdlite_mobilenetv2_scratch_600e_coco_20210629_110627-974d9307.pth --work-dir $WORK_DIR/ssdlite_mobilenetv2-scratch_8xb24-600e_coco --cfg-option env_cfg.dist_cfg.port=29733 & +echo 'configs/swin/mask-rcnn_swin-t-p4-w7_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION mask-rcnn_swin-t-p4-w7_fpn_1x_coco configs/swin/mask-rcnn_swin-t-p4-w7_fpn_1x_coco.py $CHECKPOINT_DIR/mask_rcnn_swin-t-p4-w7_fpn_1x_coco_20210902_120937-9d6b7cfa.pth --work-dir $WORK_DIR/mask-rcnn_swin-t-p4-w7_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29734 & +echo 'configs/tood/tood_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION tood_r50_fpn_1x_coco configs/tood/tood_r50_fpn_1x_coco.py $CHECKPOINT_DIR/tood_r50_fpn_1x_coco_20211210_103425-20e20746.pth --work-dir $WORK_DIR/tood_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29735 & +echo 'configs/tridentnet/tridentnet_r50-caffe_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION tridentnet_r50-caffe_1x_coco configs/tridentnet/tridentnet_r50-caffe_1x_coco.py $CHECKPOINT_DIR/tridentnet_r50_caffe_1x_coco_20201230_141838-2ec0b530.pth --work-dir $WORK_DIR/tridentnet_r50-caffe_1x_coco --cfg-option env_cfg.dist_cfg.port=29736 & +echo 'configs/vfnet/vfnet_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION vfnet_r50_fpn_1x_coco configs/vfnet/vfnet_r50_fpn_1x_coco.py $CHECKPOINT_DIR/vfnet_r50_fpn_1x_coco_20201027-38db6f58.pth --work-dir $WORK_DIR/vfnet_r50_fpn_1x_coco --cfg-option env_cfg.dist_cfg.port=29737 & +echo 'configs/yolact/yolact_r50_1xb8-55e_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION yolact_r50_1xb8-55e_coco configs/yolact/yolact_r50_1xb8-55e_coco.py $CHECKPOINT_DIR/yolact_r50_1x8_coco_20200908-f38d58df.pth --work-dir $WORK_DIR/yolact_r50_1xb8-55e_coco --cfg-option env_cfg.dist_cfg.port=29738 & +echo 'configs/yolo/yolov3_d53_8xb8-320-273e_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION yolov3_d53_8xb8-320-273e_coco configs/yolo/yolov3_d53_8xb8-320-273e_coco.py $CHECKPOINT_DIR/yolov3_d53_320_273e_coco-421362b6.pth --work-dir $WORK_DIR/yolov3_d53_8xb8-320-273e_coco --cfg-option env_cfg.dist_cfg.port=29739 & +echo 'configs/yolof/yolof_r50-c5_8xb8-1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION yolof_r50-c5_8xb8-1x_coco configs/yolof/yolof_r50-c5_8xb8-1x_coco.py $CHECKPOINT_DIR/yolof_r50_c5_8x8_1x_coco_20210425_024427-8e864411.pth --work-dir $WORK_DIR/yolof_r50-c5_8xb8-1x_coco --cfg-option env_cfg.dist_cfg.port=29740 & +echo 'configs/yolox/yolox_tiny_8xb8-300e_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK tools/slurm_test.sh $PARTITION yolox_tiny_8xb8-300e_coco configs/yolox/yolox_tiny_8xb8-300e_coco.py $CHECKPOINT_DIR/yolox_tiny_8x8_300e_coco_20211124_171234-b4047906.pth --work-dir $WORK_DIR/yolox_tiny_8xb8-300e_coco --cfg-option env_cfg.dist_cfg.port=29741 & diff --git a/mmdetection/.dev_scripts/test_init_backbone.py b/mmdetection/.dev_scripts/test_init_backbone.py new file mode 100644 index 00000000..d38d180b --- /dev/null +++ b/mmdetection/.dev_scripts/test_init_backbone.py @@ -0,0 +1,178 @@ +# Copyright (c) OpenMMLab. All rights reserved. +"""Check out backbone whether successfully load pretrained checkpoint.""" +import copy +import os +from os.path import dirname, exists, join + +import pytest +from mmengine.config import Config +from mmengine.runner import CheckpointLoader +from mmengine.utils import ProgressBar + +from mmdet.registry import MODELS + + +def _get_config_directory(): + """Find the predefined detector config directory.""" + try: + # Assume we are running in the source mmdetection repo + repo_dpath = dirname(dirname(__file__)) + except NameError: + # For IPython development when this __file__ is not defined + import mmdet + repo_dpath = dirname(dirname(mmdet.__file__)) + config_dpath = join(repo_dpath, 'configs') + if not exists(config_dpath): + raise Exception('Cannot find config path') + return config_dpath + + +def _get_config_module(fname): + """Load a configuration as a python module.""" + config_dpath = _get_config_directory() + config_fpath = join(config_dpath, fname) + config_mod = Config.fromfile(config_fpath) + return config_mod + + +def _get_detector_cfg(fname): + """Grab configs necessary to create a detector. + + These are deep copied to allow for safe modification of parameters without + influencing other tests. + """ + config = _get_config_module(fname) + model = copy.deepcopy(config.model) + return model + + +def _traversed_config_file(): + """We traversed all potential config files under the `config` file. If you + need to print details or debug code, you can use this function. + + If the `backbone.init_cfg` is None (do not use `Pretrained` init way), you + need add the folder name in `ignores_folder` (if the config files in this + folder all set backbone.init_cfg is None) or add config name in + `ignores_file` (if the config file set backbone.init_cfg is None) + """ + config_path = _get_config_directory() + check_cfg_names = [] + + # `base`, `legacy_1.x` and `common` ignored by default. + ignores_folder = ['_base_', 'legacy_1.x', 'common'] + # 'ld' need load teacher model, if want to check 'ld', + # please check teacher_config path first. + ignores_folder += ['ld'] + # `selfsup_pretrain` need convert model, if want to check this model, + # need to convert the model first. + ignores_folder += ['selfsup_pretrain'] + + # the `init_cfg` in 'centripetalnet', 'cornernet', 'cityscapes', + # 'scratch' is None. + # the `init_cfg` in ssdlite(`ssdlite_mobilenetv2_scratch_600e_coco.py`) + # is None + # Please confirm `bockbone.init_cfg` is None first. + ignores_folder += ['centripetalnet', 'cornernet', 'cityscapes', 'scratch'] + ignores_file = ['ssdlite_mobilenetv2_scratch_600e_coco.py'] + + for config_file_name in os.listdir(config_path): + if config_file_name not in ignores_folder: + config_file = join(config_path, config_file_name) + if os.path.isdir(config_file): + for config_sub_file in os.listdir(config_file): + if config_sub_file.endswith('py') and \ + config_sub_file not in ignores_file: + name = join(config_file, config_sub_file) + check_cfg_names.append(name) + return check_cfg_names + + +def _check_backbone(config, print_cfg=True): + """Check out backbone whether successfully load pretrained model, by using + `backbone.init_cfg`. + + First, using `CheckpointLoader.load_checkpoint` to load the checkpoint + without loading models. + Then, using `MODELS.build` to build models, and using + `model.init_weights()` to initialize the parameters. + Finally, assert weights and bias of each layer loaded from pretrained + checkpoint are equal to the weights and bias of original checkpoint. + For the convenience of comparison, we sum up weights and bias of + each loaded layer separately. + + Args: + config (str): Config file path. + print_cfg (bool): Whether print logger and return the result. + + Returns: + results (str or None): If backbone successfully load pretrained + checkpoint, return None; else, return config file path. + """ + if print_cfg: + print('-' * 15 + 'loading ', config) + cfg = Config.fromfile(config) + init_cfg = None + try: + init_cfg = cfg.model.backbone.init_cfg + init_flag = True + except AttributeError: + init_flag = False + if init_cfg is None or init_cfg.get('type') != 'Pretrained': + init_flag = False + if init_flag: + checkpoint = CheckpointLoader.load_checkpoint(init_cfg.checkpoint) + if 'state_dict' in checkpoint: + state_dict = checkpoint['state_dict'] + else: + state_dict = checkpoint + + model = MODELS.build(cfg.model) + model.init_weights() + + checkpoint_layers = state_dict.keys() + for name, value in model.backbone.state_dict().items(): + if name in checkpoint_layers: + assert value.equal(state_dict[name]) + + if print_cfg: + print('-' * 10 + 'Successfully load checkpoint' + '-' * 10 + + '\n', ) + return None + else: + if print_cfg: + print(config + '\n' + '-' * 10 + + 'config file do not have init_cfg' + '-' * 10 + '\n') + return config + + +@pytest.mark.parametrize('config', _traversed_config_file()) +def test_load_pretrained(config): + """Check out backbone whether successfully load pretrained model by using + `backbone.init_cfg`. + + Details please refer to `_check_backbone` + """ + _check_backbone(config, print_cfg=False) + + +def _test_load_pretrained(): + """We traversed all potential config files under the `config` file. If you + need to print details or debug code, you can use this function. + + Returns: + check_cfg_names (list[str]): Config files that backbone initialized + from pretrained checkpoint might be problematic. Need to recheck + the config file. The output including the config files that the + backbone.init_cfg is None + """ + check_cfg_names = _traversed_config_file() + need_check_cfg = [] + + prog_bar = ProgressBar(len(check_cfg_names)) + for config in check_cfg_names: + init_cfg_name = _check_backbone(config) + if init_cfg_name is not None: + need_check_cfg.append(init_cfg_name) + prog_bar.update() + print('These config files need to be checked again') + print(need_check_cfg) diff --git a/mmdetection/.dev_scripts/train_benchmark.sh b/mmdetection/.dev_scripts/train_benchmark.sh new file mode 100644 index 00000000..13180a6e --- /dev/null +++ b/mmdetection/.dev_scripts/train_benchmark.sh @@ -0,0 +1,164 @@ +PARTITION=$1 +WORK_DIR=$2 +CPUS_PER_TASK=${3:-4} + +echo 'configs/albu_example/mask-rcnn_r50_fpn_albu_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION mask-rcnn_r50_fpn_albu_1x_coco configs/albu_example/mask-rcnn_r50_fpn_albu_1x_coco.py $WORK_DIR/mask-rcnn_r50_fpn_albu_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/atss/atss_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION atss_r50_fpn_1x_coco configs/atss/atss_r50_fpn_1x_coco.py $WORK_DIR/atss_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/autoassign/autoassign_r50-caffe_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION autoassign_r50-caffe_fpn_1x_coco configs/autoassign/autoassign_r50-caffe_fpn_1x_coco.py $WORK_DIR/autoassign_r50-caffe_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/carafe/faster-rcnn_r50_fpn-carafe_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION faster-rcnn_r50_fpn-carafe_1x_coco configs/carafe/faster-rcnn_r50_fpn-carafe_1x_coco.py $WORK_DIR/faster-rcnn_r50_fpn-carafe_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/cascade_rcnn/cascade-rcnn_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION cascade-rcnn_r50_fpn_1x_coco configs/cascade_rcnn/cascade-rcnn_r50_fpn_1x_coco.py $WORK_DIR/cascade-rcnn_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/cascade_rcnn/cascade-mask-rcnn_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION cascade-mask-rcnn_r50_fpn_1x_coco configs/cascade_rcnn/cascade-mask-rcnn_r50_fpn_1x_coco.py $WORK_DIR/cascade-mask-rcnn_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/cascade_rpn/cascade-rpn_faster-rcnn_r50-caffe_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION cascade-rpn_faster-rcnn_r50-caffe_fpn_1x_coco configs/cascade_rpn/cascade-rpn_faster-rcnn_r50-caffe_fpn_1x_coco.py $WORK_DIR/cascade-rpn_faster-rcnn_r50-caffe_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/centernet/centernet_r18-dcnv2_8xb16-crop512-140e_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION centernet_r18-dcnv2_8xb16-crop512-140e_coco configs/centernet/centernet_r18-dcnv2_8xb16-crop512-140e_coco.py $WORK_DIR/centernet_r18-dcnv2_8xb16-crop512-140e_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/centernet/centernet-update_r50-caffe_fpn_ms-1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION centernet-update_r50-caffe_fpn_ms-1x_coco configs/centernet/centernet-update_r50-caffe_fpn_ms-1x_coco.py $WORK_DIR/centernet-update_r50-caffe_fpn_ms-1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/centripetalnet/centripetalnet_hourglass104_16xb6-crop511-210e-mstest_coco.py' & +GPUS=16 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION centripetalnet_hourglass104_16xb6-crop511-210e-mstest_coco configs/centripetalnet/centripetalnet_hourglass104_16xb6-crop511-210e-mstest_coco.py $WORK_DIR/centripetalnet_hourglass104_16xb6-crop511-210e-mstest_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/cornernet/cornernet_hourglass104_8xb6-210e-mstest_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION cornernet_hourglass104_8xb6-210e-mstest_coco configs/cornernet/cornernet_hourglass104_8xb6-210e-mstest_coco.py $WORK_DIR/cornernet_hourglass104_8xb6-210e-mstest_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/convnext/mask-rcnn_convnext-t-p4-w7_fpn_amp-ms-crop-3x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION mask-rcnn_convnext-t-p4-w7_fpn_amp-ms-crop-3x_coco configs/convnext/mask-rcnn_convnext-t-p4-w7_fpn_amp-ms-crop-3x_coco.py $WORK_DIR/mask-rcnn_convnext-t-p4-w7_fpn_amp-ms-crop-3x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/dcn/faster-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION faster-rcnn_r50-dconv-c3-c5_fpn_1x_coco configs/dcn/faster-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py $WORK_DIR/faster-rcnn_r50-dconv-c3-c5_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/dcnv2/faster-rcnn_r50_fpn_mdpool_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION faster-rcnn_r50_fpn_mdpool_1x_coco configs/dcnv2/faster-rcnn_r50_fpn_mdpool_1x_coco.py $WORK_DIR/faster-rcnn_r50_fpn_mdpool_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/ddod/ddod_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION ddod_r50_fpn_1x_coco configs/ddod/ddod_r50_fpn_1x_coco.py $WORK_DIR/ddod_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/detectors/detectors_htc-r50_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION detectors_htc-r50_1x_coco configs/detectors/detectors_htc-r50_1x_coco.py $WORK_DIR/detectors_htc-r50_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/deformable_detr/deformable-detr_r50_16xb2-50e_coco.py' & +GPUS=16 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION deformable-detr_r50_16xb2-50e_coco configs/deformable_detr/deformable-detr_r50_16xb2-50e_coco.py $WORK_DIR/deformable-detr_r50_16xb2-50e_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/detr/detr_r50_8xb2-150e_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION detr_r50_8xb2-150e_coco configs/detr/detr_r50_8xb2-150e_coco.py $WORK_DIR/detr_r50_8xb2-150e_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/double_heads/dh-faster-rcnn_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION dh-faster-rcnn_r50_fpn_1x_coco configs/double_heads/dh-faster-rcnn_r50_fpn_1x_coco.py $WORK_DIR/dh-faster-rcnn_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/dynamic_rcnn/dynamic-rcnn_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION dynamic-rcnn_r50_fpn_1x_coco configs/dynamic_rcnn/dynamic-rcnn_r50_fpn_1x_coco.py $WORK_DIR/dynamic-rcnn_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/dyhead/atss_r50_fpn_dyhead_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION atss_r50_fpn_dyhead_1x_coco configs/dyhead/atss_r50_fpn_dyhead_1x_coco.py $WORK_DIR/atss_r50_fpn_dyhead_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/efficientnet/retinanet_effb3_fpn_8xb4-crop896-1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION retinanet_effb3_fpn_8xb4-crop896-1x_coco configs/efficientnet/retinanet_effb3_fpn_8xb4-crop896-1x_coco.py $WORK_DIR/retinanet_effb3_fpn_8xb4-crop896-1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/empirical_attention/faster-rcnn_r50-attn1111_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION faster-rcnn_r50-attn1111_fpn_1x_coco configs/empirical_attention/faster-rcnn_r50-attn1111_fpn_1x_coco.py $WORK_DIR/faster-rcnn_r50-attn1111_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION faster-rcnn_r50_fpn_1x_coco configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py $WORK_DIR/faster-rcnn_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/faster_rcnn/faster-rcnn_r50-caffe-dc5_ms-1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION faster-rcnn_r50-caffe-dc5_ms-1x_coco configs/faster_rcnn/faster-rcnn_r50-caffe-dc5_ms-1x_coco.py $WORK_DIR/faster-rcnn_r50-caffe-dc5_ms-1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/fcos/fcos_r50-caffe_fpn_gn-head-center-normbbox-centeronreg-giou_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION fcos_r50-caffe_fpn_gn-head-center-normbbox-centeronreg-giou_1x_coco configs/fcos/fcos_r50-caffe_fpn_gn-head-center-normbbox-centeronreg-giou_1x_coco.py $WORK_DIR/fcos_r50-caffe_fpn_gn-head-center-normbbox-centeronreg-giou_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/foveabox/fovea_r50_fpn_gn-head-align_4xb4-2x_coco.py' & +GPUS=4 GPUS_PER_NODE=4 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION fovea_r50_fpn_gn-head-align_4xb4-2x_coco configs/foveabox/fovea_r50_fpn_gn-head-align_4xb4-2x_coco.py $WORK_DIR/fovea_r50_fpn_gn-head-align_4xb4-2x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/fpg/mask-rcnn_r50_fpg_crop640-50e_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION mask-rcnn_r50_fpg_crop640-50e_coco configs/fpg/mask-rcnn_r50_fpg_crop640-50e_coco.py $WORK_DIR/mask-rcnn_r50_fpg_crop640-50e_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/free_anchor/freeanchor_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION freeanchor_r50_fpn_1x_coco configs/free_anchor/freeanchor_r50_fpn_1x_coco.py $WORK_DIR/freeanchor_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/fsaf/fsaf_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION fsaf_r50_fpn_1x_coco configs/fsaf/fsaf_r50_fpn_1x_coco.py $WORK_DIR/fsaf_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/gcnet/mask-rcnn_r50-syncbn-gcb-r16-c3-c5_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION mask-rcnn_r50-syncbn-gcb-r16-c3-c5_fpn_1x_coco configs/gcnet/mask-rcnn_r50-syncbn-gcb-r16-c3-c5_fpn_1x_coco.py $WORK_DIR/mask-rcnn_r50-syncbn-gcb-r16-c3-c5_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/gfl/gfl_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION gfl_r50_fpn_1x_coco configs/gfl/gfl_r50_fpn_1x_coco.py $WORK_DIR/gfl_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/ghm/retinanet_r50_fpn_ghm-1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION retinanet_r50_fpn_ghm-1x_coco configs/ghm/retinanet_r50_fpn_ghm-1x_coco.py $WORK_DIR/retinanet_r50_fpn_ghm-1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/gn/mask-rcnn_r50_fpn_gn-all_2x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION mask-rcnn_r50_fpn_gn-all_2x_coco configs/gn/mask-rcnn_r50_fpn_gn-all_2x_coco.py $WORK_DIR/mask-rcnn_r50_fpn_gn-all_2x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/gn+ws/faster-rcnn_r50_fpn_gn-ws-all_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION faster-rcnn_r50_fpn_gn-ws-all_1x_coco configs/gn+ws/faster-rcnn_r50_fpn_gn-ws-all_1x_coco.py $WORK_DIR/faster-rcnn_r50_fpn_gn-ws-all_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/grid_rcnn/grid-rcnn_r50_fpn_gn-head_2x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION grid-rcnn_r50_fpn_gn-head_2x_coco configs/grid_rcnn/grid-rcnn_r50_fpn_gn-head_2x_coco.py $WORK_DIR/grid-rcnn_r50_fpn_gn-head_2x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/groie/faste-rcnn_r50_fpn_groie_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION faste-rcnn_r50_fpn_groie_1x_coco configs/groie/faste-rcnn_r50_fpn_groie_1x_coco.py $WORK_DIR/faste-rcnn_r50_fpn_groie_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/guided_anchoring/ga-retinanet_r50-caffe_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION ga-retinanet_r50-caffe_fpn_1x_coco configs/guided_anchoring/ga-retinanet_r50-caffe_fpn_1x_coco.py $WORK_DIR/ga-retinanet_r50-caffe_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/hrnet/faster-rcnn_hrnetv2p-w18-1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION faster-rcnn_hrnetv2p-w18-1x_coco configs/hrnet/faster-rcnn_hrnetv2p-w18-1x_coco.py $WORK_DIR/faster-rcnn_hrnetv2p-w18-1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/htc/htc_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION htc_r50_fpn_1x_coco configs/htc/htc_r50_fpn_1x_coco.py $WORK_DIR/htc_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/instaboost/mask-rcnn_r50_fpn_instaboost-4x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION mask-rcnn_r50_fpn_instaboost-4x_coco configs/instaboost/mask-rcnn_r50_fpn_instaboost-4x_coco.py $WORK_DIR/mask-rcnn_r50_fpn_instaboost-4x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/lad/lad_r50-paa-r101_fpn_2xb8_coco_1x.py' & +GPUS=2 GPUS_PER_NODE=2 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION lad_r50-paa-r101_fpn_2xb8_coco_1x configs/lad/lad_r50-paa-r101_fpn_2xb8_coco_1x.py $WORK_DIR/lad_r50-paa-r101_fpn_2xb8_coco_1x --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/ld/ld_r18-gflv1-r101_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION ld_r18-gflv1-r101_fpn_1x_coco configs/ld/ld_r18-gflv1-r101_fpn_1x_coco.py $WORK_DIR/ld_r18-gflv1-r101_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/libra_rcnn/libra-faster-rcnn_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION libra-faster-rcnn_r50_fpn_1x_coco configs/libra_rcnn/libra-faster-rcnn_r50_fpn_1x_coco.py $WORK_DIR/libra-faster-rcnn_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/mask2former/mask2former_r50_8xb2-lsj-50e_coco-panoptic.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION mask2former_r50_8xb2-lsj-50e_coco-panoptic configs/mask2former/mask2former_r50_8xb2-lsj-50e_coco-panoptic.py $WORK_DIR/mask2former_r50_8xb2-lsj-50e_coco-panoptic --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION mask-rcnn_r50_fpn_1x_coco configs/mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py $WORK_DIR/mask-rcnn_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/maskformer/maskformer_r50_ms-16xb1-75e_coco.py' & +GPUS=16 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION maskformer_r50_ms-16xb1-75e_coco configs/maskformer/maskformer_r50_ms-16xb1-75e_coco.py $WORK_DIR/maskformer_r50_ms-16xb1-75e_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/ms_rcnn/ms-rcnn_r50-caffe_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION ms-rcnn_r50-caffe_fpn_1x_coco configs/ms_rcnn/ms-rcnn_r50-caffe_fpn_1x_coco.py $WORK_DIR/ms-rcnn_r50-caffe_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/nas_fcos/nas-fcos_r50-caffe_fpn_nashead-gn-head_4xb4-1x_coco.py' & +GPUS=4 GPUS_PER_NODE=4 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION nas-fcos_r50-caffe_fpn_nashead-gn-head_4xb4-1x_coco configs/nas_fcos/nas-fcos_r50-caffe_fpn_nashead-gn-head_4xb4-1x_coco.py $WORK_DIR/nas-fcos_r50-caffe_fpn_nashead-gn-head_4xb4-1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/nas_fpn/retinanet_r50_nasfpn_crop640-50e_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION retinanet_r50_nasfpn_crop640-50e_coco configs/nas_fpn/retinanet_r50_nasfpn_crop640-50e_coco.py $WORK_DIR/retinanet_r50_nasfpn_crop640-50e_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/paa/paa_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION paa_r50_fpn_1x_coco configs/paa/paa_r50_fpn_1x_coco.py $WORK_DIR/paa_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/pafpn/faster-rcnn_r50_pafpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION faster-rcnn_r50_pafpn_1x_coco configs/pafpn/faster-rcnn_r50_pafpn_1x_coco.py $WORK_DIR/faster-rcnn_r50_pafpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/panoptic_fpn/panoptic-fpn_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION panoptic-fpn_r50_fpn_1x_coco configs/panoptic_fpn/panoptic-fpn_r50_fpn_1x_coco.py $WORK_DIR/panoptic-fpn_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/pisa/mask-rcnn_r50_fpn_pisa_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION mask-rcnn_r50_fpn_pisa_1x_coco configs/pisa/mask-rcnn_r50_fpn_pisa_1x_coco.py $WORK_DIR/mask-rcnn_r50_fpn_pisa_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/point_rend/point-rend_r50-caffe_fpn_ms-1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION point-rend_r50-caffe_fpn_ms-1x_coco configs/point_rend/point-rend_r50-caffe_fpn_ms-1x_coco.py $WORK_DIR/point-rend_r50-caffe_fpn_ms-1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/pvt/retinanet_pvt-t_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION retinanet_pvt-t_fpn_1x_coco configs/pvt/retinanet_pvt-t_fpn_1x_coco.py $WORK_DIR/retinanet_pvt-t_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/queryinst/queryinst_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION queryinst_r50_fpn_1x_coco configs/queryinst/queryinst_r50_fpn_1x_coco.py $WORK_DIR/queryinst_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/regnet/retinanet_regnetx-800MF_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION retinanet_regnetx-800MF_fpn_1x_coco configs/regnet/retinanet_regnetx-800MF_fpn_1x_coco.py $WORK_DIR/retinanet_regnetx-800MF_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/reppoints/reppoints-moment_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION reppoints-moment_r50_fpn_1x_coco configs/reppoints/reppoints-moment_r50_fpn_1x_coco.py $WORK_DIR/reppoints-moment_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/res2net/faster-rcnn_res2net-101_fpn_2x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION faster-rcnn_res2net-101_fpn_2x_coco configs/res2net/faster-rcnn_res2net-101_fpn_2x_coco.py $WORK_DIR/faster-rcnn_res2net-101_fpn_2x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/resnest/faster-rcnn_s50_fpn_syncbn-backbone+head_ms-range-1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION faster-rcnn_s50_fpn_syncbn-backbone+head_ms-range-1x_coco configs/resnest/faster-rcnn_s50_fpn_syncbn-backbone+head_ms-range-1x_coco.py $WORK_DIR/faster-rcnn_s50_fpn_syncbn-backbone+head_ms-range-1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/resnet_strikes_back/retinanet_r50-rsb-pre_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION retinanet_r50-rsb-pre_fpn_1x_coco configs/resnet_strikes_back/retinanet_r50-rsb-pre_fpn_1x_coco.py $WORK_DIR/retinanet_r50-rsb-pre_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/retinanet/retinanet_r50-caffe_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION retinanet_r50-caffe_fpn_1x_coco configs/retinanet/retinanet_r50-caffe_fpn_1x_coco.py $WORK_DIR/retinanet_r50-caffe_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/rpn/rpn_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION rpn_r50_fpn_1x_coco configs/rpn/rpn_r50_fpn_1x_coco.py $WORK_DIR/rpn_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/sabl/sabl-retinanet_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION sabl-retinanet_r50_fpn_1x_coco configs/sabl/sabl-retinanet_r50_fpn_1x_coco.py $WORK_DIR/sabl-retinanet_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/scnet/scnet_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION scnet_r50_fpn_1x_coco configs/scnet/scnet_r50_fpn_1x_coco.py $WORK_DIR/scnet_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/scratch/faster-rcnn_r50-scratch_fpn_gn-all_6x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION faster-rcnn_r50-scratch_fpn_gn-all_6x_coco configs/scratch/faster-rcnn_r50-scratch_fpn_gn-all_6x_coco.py $WORK_DIR/faster-rcnn_r50-scratch_fpn_gn-all_6x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/solo/solo_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION solo_r50_fpn_1x_coco configs/solo/solo_r50_fpn_1x_coco.py $WORK_DIR/solo_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/solov2/solov2_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION solov2_r50_fpn_1x_coco configs/solov2/solov2_r50_fpn_1x_coco.py $WORK_DIR/solov2_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/sparse_rcnn/sparse-rcnn_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION sparse-rcnn_r50_fpn_1x_coco configs/sparse_rcnn/sparse-rcnn_r50_fpn_1x_coco.py $WORK_DIR/sparse-rcnn_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/ssd/ssd300_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION ssd300_coco configs/ssd/ssd300_coco.py $WORK_DIR/ssd300_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/ssd/ssdlite_mobilenetv2-scratch_8xb24-600e_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION ssdlite_mobilenetv2-scratch_8xb24-600e_coco configs/ssd/ssdlite_mobilenetv2-scratch_8xb24-600e_coco.py $WORK_DIR/ssdlite_mobilenetv2-scratch_8xb24-600e_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/swin/mask-rcnn_swin-t-p4-w7_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION mask-rcnn_swin-t-p4-w7_fpn_1x_coco configs/swin/mask-rcnn_swin-t-p4-w7_fpn_1x_coco.py $WORK_DIR/mask-rcnn_swin-t-p4-w7_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/tood/tood_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION tood_r50_fpn_1x_coco configs/tood/tood_r50_fpn_1x_coco.py $WORK_DIR/tood_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo ''configs/tridentnet/tridentnet_r50-caffe_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION tridentnet_r50-caffe_1x_coco 'configs/tridentnet/tridentnet_r50-caffe_1x_coco.py $WORK_DIR/tridentnet_r50-caffe_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/vfnet/vfnet_r50_fpn_1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION vfnet_r50_fpn_1x_coco configs/vfnet/vfnet_r50_fpn_1x_coco.py $WORK_DIR/vfnet_r50_fpn_1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/yolact/yolact_r50_8xb8-55e_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION yolact_r50_8xb8-55e_coco configs/yolact/yolact_r50_8xb8-55e_coco.py $WORK_DIR/yolact_r50_8xb8-55e_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/yolo/yolov3_d53_8xb8-320-273e_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION yolov3_d53_8xb8-320-273e_coco configs/yolo/yolov3_d53_8xb8-320-273e_coco.py $WORK_DIR/yolov3_d53_8xb8-320-273e_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/yolof/yolof_r50-c5_8xb8-1x_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION yolof_r50-c5_8xb8-1x_coco configs/yolof/yolof_r50-c5_8xb8-1x_coco.py $WORK_DIR/yolof_r50-c5_8xb8-1x_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & +echo 'configs/yolox/yolox_tiny_8xb8-300e_coco.py' & +GPUS=8 GPUS_PER_NODE=8 CPUS_PER_TASK=$CPUS_PRE_TASK ./tools/slurm_train.sh $PARTITION yolox_tiny_8xb8-300e_coco configs/yolox/yolox_tiny_8xb8-300e_coco.py $WORK_DIR/yolox_tiny_8xb8-300e_coco --cfg-options default_hooks.checkpoint.max_keep_ckpts=1 & diff --git a/mmdetection/.github/CODE_OF_CONDUCT.md b/mmdetection/.github/CODE_OF_CONDUCT.md new file mode 100644 index 00000000..92afad1c --- /dev/null +++ b/mmdetection/.github/CODE_OF_CONDUCT.md @@ -0,0 +1,76 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to making participation in our project and +our community a harassment-free experience for everyone, regardless of age, body +size, disability, ethnicity, sex characteristics, gender identity and expression, +level of experience, education, socio-economic status, nationality, personal +appearance, race, religion, or sexual identity and orientation. + +## Our Standards + +Examples of behavior that contributes to creating a positive environment +include: + +- Using welcoming and inclusive language +- Being respectful of differing viewpoints and experiences +- Gracefully accepting constructive criticism +- Focusing on what is best for the community +- Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +- The use of sexualized language or imagery and unwelcome sexual attention or + advances +- Trolling, insulting/derogatory comments, and personal or political attacks +- Public or private harassment +- Publishing others' private information, such as a physical or electronic + address, without explicit permission +- Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviors that they deem inappropriate, +threatening, offensive, or harmful. + +## Scope + +This Code of Conduct applies both within project spaces and in public spaces +when an individual is representing the project or its community. Examples of +representing a project or community include using an official project e-mail +address, posting via an official social media account, or acting as an appointed +representative at an online or offline event. Representation of a project may be +further defined and clarified by project maintainers. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported by contacting the project team at chenkaidev@gmail.com. All +complaints will be reviewed and investigated and will result in a response that +is deemed necessary and appropriate to the circumstances. The project team is +obligated to maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project's leadership. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, +available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html + +For answers to common questions about this code of conduct, see +https://www.contributor-covenant.org/faq + +[homepage]: https://www.contributor-covenant.org diff --git a/mmdetection/.github/CONTRIBUTING.md b/mmdetection/.github/CONTRIBUTING.md new file mode 100644 index 00000000..c6696262 --- /dev/null +++ b/mmdetection/.github/CONTRIBUTING.md @@ -0,0 +1 @@ +We appreciate all contributions to improve MMDetection. Please refer to [CONTRIBUTING.md](https://github.com/open-mmlab/mmcv/blob/master/CONTRIBUTING.md) in MMCV for more details about the contributing guideline. diff --git a/mmdetection/.github/ISSUE_TEMPLATE/config.yml b/mmdetection/.github/ISSUE_TEMPLATE/config.yml new file mode 100644 index 00000000..56bbd88f --- /dev/null +++ b/mmdetection/.github/ISSUE_TEMPLATE/config.yml @@ -0,0 +1,9 @@ +blank_issues_enabled: false + +contact_links: + - name: Common Issues + url: https://mmdetection.readthedocs.io/en/latest/faq.html + about: Check if your issue already has solutions + - name: MMDetection Documentation + url: https://mmdetection.readthedocs.io/en/latest/ + about: Check if your question is answered in docs diff --git a/mmdetection/.github/ISSUE_TEMPLATE/error-report.md b/mmdetection/.github/ISSUE_TEMPLATE/error-report.md new file mode 100644 index 00000000..9dbd3ff1 --- /dev/null +++ b/mmdetection/.github/ISSUE_TEMPLATE/error-report.md @@ -0,0 +1,46 @@ +--- +name: Error report +about: Create a report to help us improve +title: '' +labels: '' +assignees: '' +--- + +Thanks for your error report and we appreciate it a lot. + +**Checklist** + +1. I have searched related issues but cannot get the expected help. +2. I have read the [FAQ documentation](https://mmdetection.readthedocs.io/en/latest/faq.html) but cannot get the expected help. +3. The bug has not been fixed in the latest version. + +**Describe the bug** +A clear and concise description of what the bug is. + +**Reproduction** + +1. What command or script did you run? + +```none +A placeholder for the command. +``` + +2. Did you make any modifications on the code or config? Did you understand what you have modified? +3. What dataset did you use? + +**Environment** + +1. Please run `python mmdet/utils/collect_env.py` to collect necessary environment information and paste it here. +2. You may add addition that may be helpful for locating the problem, such as + - How you installed PyTorch \[e.g., pip, conda, source\] + - Other environment variables that may be related (such as `$PATH`, `$LD_LIBRARY_PATH`, `$PYTHONPATH`, etc.) + +**Error traceback** +If applicable, paste the error trackback here. + +```none +A placeholder for trackback. +``` + +**Bug fix** +If you have already identified the reason, you can provide the information here. If you are willing to create a PR to fix it, please also leave a comment here and that would be much appreciated! diff --git a/mmdetection/.github/ISSUE_TEMPLATE/feature_request.md b/mmdetection/.github/ISSUE_TEMPLATE/feature_request.md new file mode 100644 index 00000000..7bf92e8c --- /dev/null +++ b/mmdetection/.github/ISSUE_TEMPLATE/feature_request.md @@ -0,0 +1,21 @@ +--- +name: Feature request +about: Suggest an idea for this project +title: '' +labels: '' +assignees: '' +--- + +**Describe the feature** + +**Motivation** +A clear and concise description of the motivation of the feature. +Ex1. It is inconvenient when \[....\]. +Ex2. There is a recent paper \[....\], which is very helpful for \[....\]. + +**Related resources** +If there is an official code release or third-party implementations, please also provide the information here, which would be very helpful. + +**Additional context** +Add any other context or screenshots about the feature request here. +If you would like to implement the feature and create a PR, please leave a comment here and that would be much appreciated. diff --git a/mmdetection/.github/ISSUE_TEMPLATE/general_questions.md b/mmdetection/.github/ISSUE_TEMPLATE/general_questions.md new file mode 100644 index 00000000..f02dd63a --- /dev/null +++ b/mmdetection/.github/ISSUE_TEMPLATE/general_questions.md @@ -0,0 +1,7 @@ +--- +name: General questions +about: Ask general questions to get help +title: '' +labels: '' +assignees: '' +--- diff --git a/mmdetection/.github/ISSUE_TEMPLATE/reimplementation_questions.md b/mmdetection/.github/ISSUE_TEMPLATE/reimplementation_questions.md new file mode 100644 index 00000000..83607ac3 --- /dev/null +++ b/mmdetection/.github/ISSUE_TEMPLATE/reimplementation_questions.md @@ -0,0 +1,67 @@ +--- +name: Reimplementation Questions +about: Ask about questions during model reimplementation +title: '' +labels: reimplementation +assignees: '' +--- + +**Notice** + +There are several common situations in the reimplementation issues as below + +1. Reimplement a model in the model zoo using the provided configs +2. Reimplement a model in the model zoo on other dataset (e.g., custom datasets) +3. Reimplement a custom model but all the components are implemented in MMDetection +4. Reimplement a custom model with new modules implemented by yourself + +There are several things to do for different cases as below. + +- For case 1 & 3, please follow the steps in the following sections thus we could help to quick identify the issue. +- For case 2 & 4, please understand that we are not able to do much help here because we usually do not know the full code and the users should be responsible to the code they write. +- One suggestion for case 2 & 4 is that the users should first check whether the bug lies in the self-implemented code or the original code. For example, users can first make sure that the same model runs well on supported datasets. If you still need help, please describe what you have done and what you obtain in the issue, and follow the steps in the following sections and try as clear as possible so that we can better help you. + +**Checklist** + +1. I have searched related issues but cannot get the expected help. +2. The issue has not been fixed in the latest version. + +**Describe the issue** + +A clear and concise description of what the problem you meet and what have you done. + +**Reproduction** + +1. What command or script did you run? + +```none +A placeholder for the command. +``` + +2. What config dir you run? + +```none +A placeholder for the config. +``` + +3. Did you make any modifications on the code or config? Did you understand what you have modified? +4. What dataset did you use? + +**Environment** + +1. Please run `python mmdet/utils/collect_env.py` to collect necessary environment information and paste it here. +2. You may add addition that may be helpful for locating the problem, such as + 1. How you installed PyTorch \[e.g., pip, conda, source\] + 2. Other environment variables that may be related (such as `$PATH`, `$LD_LIBRARY_PATH`, `$PYTHONPATH`, etc.) + +**Results** + +If applicable, paste the related results here, e.g., what you expect and what you get. + +```none +A placeholder for results comparison +``` + +**Issue fix** + +If you have already identified the reason, you can provide the information here. If you are willing to create a PR to fix it, please also leave a comment here and that would be much appreciated! diff --git a/mmdetection/.github/pull_request_template.md b/mmdetection/.github/pull_request_template.md new file mode 100644 index 00000000..7a9f0d90 --- /dev/null +++ b/mmdetection/.github/pull_request_template.md @@ -0,0 +1,25 @@ +Thanks for your contribution and we appreciate it a lot. The following instructions would make your pull request more healthy and more easily get feedback. If you do not understand some items, don't worry, just make the pull request and seek help from maintainers. + +## Motivation + +Please describe the motivation of this PR and the goal you want to achieve through this PR. + +## Modification + +Please briefly describe what modification is made in this PR. + +## BC-breaking (Optional) + +Does the modification introduce changes that break the backward-compatibility of the downstream repos? +If so, please describe how it breaks the compatibility and how the downstream projects should modify their code to keep compatibility with this PR. + +## Use cases (Optional) + +If this PR introduces a new feature, it is better to list some use cases here, and update the documentation. + +## Checklist + +1. Pre-commit or other linting tools are used to fix the potential lint issues. +2. The modification is covered by complete unit tests. If not, please add more unit test to ensure the correctness. +3. If the modification has potential influence on downstream projects, this PR should be tested with downstream projects, like MMDet or MMPreTrain. +4. The documentation has been modified accordingly, like docstring or example tutorials. diff --git a/mmdetection/.github/workflows/deploy.yml b/mmdetection/.github/workflows/deploy.yml new file mode 100644 index 00000000..f5750614 --- /dev/null +++ b/mmdetection/.github/workflows/deploy.yml @@ -0,0 +1,28 @@ +name: deploy + +on: push + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + build-n-publish: + runs-on: ubuntu-latest + if: startsWith(github.event.ref, 'refs/tags') + steps: + - uses: actions/checkout@v2 + - name: Set up Python 3.7 + uses: actions/setup-python@v2 + with: + python-version: 3.7 + - name: Install torch + run: pip install torch + - name: Install wheel + run: pip install wheel + - name: Build MMDetection + run: python setup.py sdist bdist_wheel + - name: Publish distribution to PyPI + run: | + pip install twine + twine upload dist/* -u __token__ -p ${{ secrets.pypi_password }} diff --git a/mmdetection/.gitignore b/mmdetection/.gitignore new file mode 100644 index 00000000..55ad113b --- /dev/null +++ b/mmdetection/.gitignore @@ -0,0 +1,123 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/en/_build/ +docs/zh_cn/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# pyenv +.python-version + +# celery beat schedule file +celerybeat-schedule + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +data/ +data +.vscode +.idea +.DS_Store + +# custom +*.pkl +*.pkl.json +*.log.json +docs/modelzoo_statistics.md +mmdet/.mim +work_dirs/ + +# Pytorch +*.pth +*.py~ +*.sh~ diff --git a/mmdetection/.owners.yml b/mmdetection/.owners.yml new file mode 100644 index 00000000..97296aab --- /dev/null +++ b/mmdetection/.owners.yml @@ -0,0 +1,14 @@ +assign: + strategy: + # random + daily-shift-based + scedule: + '*/1 * * * *' + assignees: + - Czm369 + - hhaAndroid + - jbwang1997 + - RangiLyu + - BIGWangYuDong + - chhluo + - ZwwWayne diff --git a/mmdetection/.pre-commit-config-zh-cn.yaml b/mmdetection/.pre-commit-config-zh-cn.yaml new file mode 100644 index 00000000..38591708 --- /dev/null +++ b/mmdetection/.pre-commit-config-zh-cn.yaml @@ -0,0 +1,61 @@ +exclude: ^tests/data/ +repos: + - repo: https://gitee.com/openmmlab/mirrors-flake8 + rev: 5.0.4 + hooks: + - id: flake8 + - repo: https://gitee.com/openmmlab/mirrors-isort + rev: 5.11.5 + hooks: + - id: isort + - repo: https://gitee.com/openmmlab/mirrors-yapf + rev: v0.32.0 + hooks: + - id: yapf + - repo: https://gitee.com/openmmlab/mirrors-pre-commit-hooks + rev: v4.3.0 + hooks: + - id: trailing-whitespace + - id: check-yaml + - id: end-of-file-fixer + - id: requirements-txt-fixer + - id: double-quote-string-fixer + - id: check-merge-conflict + - id: fix-encoding-pragma + args: ["--remove"] + - id: mixed-line-ending + args: ["--fix=lf"] + - repo: https://gitee.com/openmmlab/mirrors-mdformat + rev: 0.7.9 + hooks: + - id: mdformat + args: ["--number"] + additional_dependencies: + - mdformat-openmmlab + - mdformat_frontmatter + - linkify-it-py + - repo: https://gitee.com/openmmlab/mirrors-codespell + rev: v2.2.1 + hooks: + - id: codespell + - repo: https://gitee.com/openmmlab/mirrors-docformatter + rev: v1.3.1 + hooks: + - id: docformatter + args: ["--in-place", "--wrap-descriptions", "79"] + - repo: https://gitee.com/openmmlab/mirrors-pyupgrade + rev: v3.0.0 + hooks: + - id: pyupgrade + args: ["--py36-plus"] + - repo: https://gitee.com/open-mmlab/pre-commit-hooks + rev: v0.2.0 + hooks: + - id: check-algo-readme + - id: check-copyright + args: ["mmdet"] +# - repo: https://gitee.com/openmmlab/mirrors-mypy +# rev: v0.812 +# hooks: +# - id: mypy +# exclude: "docs" diff --git a/mmdetection/.pre-commit-config.yaml b/mmdetection/.pre-commit-config.yaml new file mode 100644 index 00000000..6ea250c8 --- /dev/null +++ b/mmdetection/.pre-commit-config.yaml @@ -0,0 +1,50 @@ +repos: + - repo: https://github.com/PyCQA/flake8 + rev: 5.0.4 + hooks: + - id: flake8 + - repo: https://github.com/PyCQA/isort + rev: 5.11.5 + hooks: + - id: isort + - repo: https://github.com/pre-commit/mirrors-yapf + rev: v0.32.0 + hooks: + - id: yapf + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v4.3.0 + hooks: + - id: trailing-whitespace + - id: check-yaml + - id: end-of-file-fixer + - id: requirements-txt-fixer + - id: double-quote-string-fixer + - id: check-merge-conflict + - id: fix-encoding-pragma + args: ["--remove"] + - id: mixed-line-ending + args: ["--fix=lf"] + - repo: https://github.com/codespell-project/codespell + rev: v2.2.1 + hooks: + - id: codespell + - repo: https://github.com/executablebooks/mdformat + rev: 0.7.9 + hooks: + - id: mdformat + args: ["--number"] + additional_dependencies: + - mdformat-openmmlab + - mdformat_frontmatter + - linkify-it-py + - repo: https://github.com/myint/docformatter + rev: v1.3.1 + hooks: + - id: docformatter + args: ["--in-place", "--wrap-descriptions", "79"] + - repo: https://github.com/open-mmlab/pre-commit-hooks + rev: v0.2.0 # Use the ref you want to point at + hooks: + - id: check-algo-readme + - id: check-copyright + args: ["mmdet"] # replace the dir_to_check with your expected directory to check diff --git a/mmdetection/.readthedocs.yml b/mmdetection/.readthedocs.yml new file mode 100644 index 00000000..9b597978 --- /dev/null +++ b/mmdetection/.readthedocs.yml @@ -0,0 +1,14 @@ +version: 2 + +build: + os: ubuntu-22.04 + tools: + python: "3.8" + +formats: + - epub + +python: + install: + - requirements: requirements/docs.txt + - requirements: requirements/readthedocs.txt diff --git a/mmdetection/CITATION.cff b/mmdetection/CITATION.cff new file mode 100644 index 00000000..aac93137 --- /dev/null +++ b/mmdetection/CITATION.cff @@ -0,0 +1,8 @@ +cff-version: 1.2.0 +message: "If you use this software, please cite it as below." +authors: + - name: "MMDetection Contributors" +title: "OpenMMLab Detection Toolbox and Benchmark" +date-released: 2018-08-22 +url: "https://github.com/open-mmlab/mmdetection" +license: Apache-2.0 diff --git a/mmdetection/CV_05/Co-detr/co-detrl.py b/mmdetection/CV_05/Co-detr/co-detrl.py new file mode 100644 index 00000000..d8b14e0b --- /dev/null +++ b/mmdetection/CV_05/Co-detr/co-detrl.py @@ -0,0 +1,512 @@ +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/codetr/co_dino_5scale_lsj_swin_large_1x_coco-3af73af2.pth' +work_dir = "/data/ephemeral/home/mmdetection/work_dir/codetr" + + +custom_imports = dict( + imports=['projects.CO-DETR.codetr'], allow_failed_imports=False) + +# data settings +num_classes = 10 +image_size = (1024, 1024) +classes = ("General trash", "Paper", "Paper pack", "Metal", "Glass", + "Plastic", "Styrofoam", "Plastic bag", "Battery", "Clothing") + + +# dataset settings ( 반드시 확인하기 ) +dataset_type = 'CocoDataset' # data format 정의 +data_root = '/data/ephemeral/home/dataset' # json과 train 모두 위치하는 최상단 폴더 +train_ann_file_name = "train_random/train_kfold_0.json" # train ann file +val_ann_file_name = "train_random/val_kfold_0.json" # val ann file +test_ann_file_name = "test.json" +img_folder = "" # 신경안써도 됨 + + +# model settings +num_dec_layer = 6 +loss_lambda = 2.0 + + + +batch_augments = [ + dict(type='BatchFixedSizePad', size=image_size, pad_mask=True) +] +model = dict( + type='CoDETR', + # If using the lsj augmentation, + # it is recommended to set it to True. + use_lsj=True, + # detr: 52.1 + # one-stage: 49.4 + # two-stage: 47.9 + eval_module='detr', # in ['detr', 'one-stage', 'two-stage'] + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_mask=False, + batch_augments=None), + backbone=dict( + type='SwinTransformer', + pretrain_img_size=384, + embed_dims=192, + depths=[2, 2, 18, 2], + num_heads=[6, 12, 24, 48], + window_size=12, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.5, + patch_norm=True, + out_indices=(0, 1, 2, 3), + with_cp=False, + convert_weights=True), + neck=dict( + type='ChannelMapper', + in_channels=[192, 384, 768, 1536], + kernel_size=1, + out_channels=256, + act_cfg=None, + norm_cfg=dict(type='GN', num_groups=32), + num_outs=5), + query_head=dict( + type='CoDINOHead', + num_query=900, + num_classes=num_classes, + in_channels=2048, + as_two_stage=True, + dn_cfg=dict( + label_noise_scale=0.5, + box_noise_scale=1.0, + group_cfg=dict(dynamic=True, num_groups=None, num_dn_queries=100)), + transformer=dict( + type='CoDinoTransformer', + with_coord_feat=False, + num_co_heads=2, # ATSS Aux Head + Faster RCNN Aux Head + num_feature_levels=5, + encoder=dict( + type='DetrTransformerEncoder', + num_layers=6, + # number of layers that use checkpoint. + # The maximum value for the setting is num_layers. + # FairScale must be installed for it to work. + with_cp=6, + transformerlayers=dict( + type='BaseTransformerLayer', + attn_cfgs=dict( + type='MultiScaleDeformableAttention', + embed_dims=256, + num_levels=5, + dropout=0.0), + feedforward_channels=2048, + ffn_dropout=0.0, + operation_order=('self_attn', 'norm', 'ffn', 'norm'))), + decoder=dict( + type='DinoTransformerDecoder', + num_layers=6, + return_intermediate=True, + transformerlayers=dict( + type='DetrTransformerDecoderLayer', + attn_cfgs=[ + dict( + type='MultiheadAttention', + embed_dims=256, + num_heads=8, + dropout=0.0), + dict( + type='MultiScaleDeformableAttention', + embed_dims=256, + num_levels=5, + dropout=0.0), + ], + feedforward_channels=2048, + ffn_dropout=0.0, + operation_order=('self_attn', 'norm', 'cross_attn', 'norm', + 'ffn', 'norm')))), + positional_encoding=dict( + type='SinePositionalEncoding', + num_feats=128, + temperature=20, + normalize=True), + loss_cls=dict( # Different from the DINO + type='QualityFocalLoss', + use_sigmoid=True, + beta=2.0, + loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=5.0), + loss_iou=dict(type='GIoULoss', loss_weight=2.0)), + rpn_head=dict( + type='RPNHead', + in_channels=256, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + octave_base_scale=4, + scales_per_octave=3, + ratios=[0.5, 1.0, 2.0], + strides=[4, 8, 16, 32, 64, 128]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[1.0, 1.0, 1.0, 1.0]), + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=True, + loss_weight=1.0 * num_dec_layer * loss_lambda), + loss_bbox=dict( + type='L1Loss', loss_weight=1.0 * num_dec_layer * loss_lambda)), + roi_head=[ + dict( + type='CoStandardRoIHead', + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict( + type='RoIAlign', output_size=7, sampling_ratio=0), + out_channels=256, + featmap_strides=[4, 8, 16, 32, 64], + finest_scale=56), + bbox_head=dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=num_classes, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=False, + reg_decoded_bbox=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0 * num_dec_layer * loss_lambda), + loss_bbox=dict( + type='GIoULoss', + loss_weight=10.0 * num_dec_layer * loss_lambda))) + ], + bbox_head=[ + dict( + type='CoATSSHead', + num_classes=num_classes, + in_channels=256, + stacked_convs=1, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + octave_base_scale=8, + scales_per_octave=1, + strides=[4, 8, 16, 32, 64, 128]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0 * num_dec_layer * loss_lambda), + loss_bbox=dict( + type='GIoULoss', + loss_weight=2.0 * num_dec_layer * loss_lambda), + loss_centerness=dict( + type='CrossEntropyLoss', + use_sigmoid=True, + loss_weight=1.0 * num_dec_layer * loss_lambda)), + ], + # model training and testing settings + train_cfg=[ + dict( + assigner=dict( + type='HungarianAssigner', + match_costs=[ + dict(type='FocalLossCost', weight=2.0), + dict(type='BBoxL1Cost', weight=5.0, box_format='xywh'), + dict(type='IoUCost', iou_mode='giou', weight=2.0) + ])), + dict( + rpn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.3, + min_pos_iou=0.3, + match_low_quality=True, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=-1, + pos_weight=-1, + debug=False), + rpn_proposal=dict( + nms_pre=4000, + max_per_img=1000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0.5, + match_low_quality=False, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + pos_weight=-1, + debug=False)), + dict( + assigner=dict(type='ATSSAssigner', topk=9), + allowed_border=-1, + pos_weight=-1, + debug=False) + ], + test_cfg=[ + # Deferent from the DINO, we use the NMS. + dict( + max_per_img=300, + # NMS can improve the mAP by 0.2. + nms=dict(type='soft_nms', iou_threshold=0.8)), + dict( + rpn=dict( + nms_pre=1000, + max_per_img=1000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=dict( + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.5), + max_per_img=100)), + dict( + # atss bbox head: + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100), + # soft-nms is also supported for rcnn testing + # e.g., nms=dict(type='soft_nms', iou_threshold=0.5, min_score=0.05) + ]) + + +# LSJ + CopyPaste +backend_args = None +color_space = [ + [dict(type='ColorTransform')], + [dict(type='AutoContrast')], + [dict(type='Equalize')], + [dict(type='Sharpness')], + [dict(type='Posterize')], + [dict(type='Solarize')], + [dict(type='Color')], + [dict(type='Contrast')], + [dict(type='Brightness')], +] +train_pipeline = [ + dict(type='Mosaic', img_scale=(1024, 1024), prob=1.0), + dict( + type='RandomResize', + scale=image_size, + ratio_range=(0.1, 2.0), + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=image_size, + recompute_bbox=True, + allow_negative_crop=True), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict(type='RandomFlip', prob=0.5), + dict(type='RandAugment', aug_space=color_space, aug_num=1), + dict(type='Pad', size=image_size, pad_val=dict(img=(114, 114, 114))), + dict(type='PackDetInputs') +] + + +train_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + # use MultiImageMixDataset wrapper to support mosaic and mixup + type='MultiImageMixDataset', + dataset=dict( + type=dataset_type, + metainfo=dict(classes=classes), + data_root=data_root, + ann_file=train_ann_file_name, + data_prefix=dict(img=img_folder), + pipeline=[ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True) + ], + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + pipeline=train_pipeline) +) + + +# follow ViTDet +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='Resize', scale=image_size, keep_ratio=True), # diff + dict(type='Pad', size=image_size, pad_val=dict(img=(114, 114, 114))), + dict(type='LoadAnnotations', with_bbox=True, with_mask=False), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +tta_model = dict( + type='DetTTAModel', + tta_cfg=dict(nms=dict( + type='nms', + iou_threshold=0.5), + max_per_img=300)) + +img_scales = [(1333, 800), (666, 400), (2000, 1200)] +tta_pipeline = [ + dict(type='LoadImageFromFile', + backend_args=None), + dict( + type='TestTimeAug', + transforms=[[ + dict(type='Resize', scale=s, keep_ratio=True) for s in img_scales + ], [ + dict(type='RandomFlip', prob=1.), + dict(type='RandomFlip', prob=0.) + ], [ + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', + 'img_shape', 'scale_factor', 'flip', + 'flip_direction')) + ]])] +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + metainfo=dict(classes=classes), # 클래스 정보 반드시 적기 + data_root=data_root, # 마찬가지로 data_root + ann_file=val_ann_file_name, # validation_ann_file + data_prefix=dict(img=img_folder), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = ( + dict( + batch_size=1, + num_workers=2, + dataset=dict( + data_root=data_root, + ann_file='test.json', + data_prefix=dict(img=''), + pipeline=tta_pipeline, + metainfo=dict(classes=classes)))) + + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + "/" + val_ann_file_name, + metric='bbox', + format_only=False, + backend_args=backend_args) +test_evaluator = dict( + type='CustomResultDumping', # custom evaluating method를 정의 + img_prefix="/data/ephemeral/home/dataset/", # dataset 최상단 폴더 + outfile_path='/data/ephemeral/home/mmdetection/work_dir/co', + classes=classes # class 정보를 담은 list나 집합 + ) + + + +################################ training setting +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=2e-4, weight_decay=0.0001), + clip_grad=dict(max_norm=0.1, norm_type=2), + accumulative_counts=2, + paramwise_cfg=dict(custom_keys={'backbone': dict(lr_mult=0.1)})) + + +max_epochs = 12 +train_cfg = dict( + type='EpochBasedTrainLoop', + max_epochs=max_epochs, + val_interval=1) +val_cfg = (dict(type='ValLoop')) +test_cfg = (dict(type='TestLoop')) + +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[11], + gamma=0.1) +] + + +###################################### hooks +default_scope = 'mmdet' +default_hooks = dict( + timer=dict(type='IterTimerHook'), + logger=dict(type='LoggerHook', interval=50), + param_scheduler=dict(type='ParamSchedulerHook'), + checkpoint=dict(type='CheckpointHook', + interval=1, + save_best='coco/bbox_mAP_50', + max_keep_ckpts=2), + sampler_seed=dict(type='DistSamplerSeedHook'), + visualization=dict(type='DetVisualizationHook')) +log_processor = dict( + type='LogProcessor', + by_epoch=True, + window_size=50) + + + +vis_backends = [ + dict(type='LocalVisBackend', save_dir='visualizations'), + # dict(type='WandbVisBackend', + # init_kwargs={ + # 'project': 'mmdetection', + # 'name': 'Co_DETR' + # }) +] +visualizer = dict( + type='DetLocalVisualizer', + vis_backends=vis_backends, + name='visualizer') + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=16) +fp16 = dict(loss_scale=512.) + + + +######### seed ######## +seed = 42 +randomness = dict( + seed = seed +) \ No newline at end of file diff --git a/mmdetection/CV_05/DiNO/dino_Swin_L_baseline.py b/mmdetection/CV_05/DiNO/dino_Swin_L_baseline.py new file mode 100644 index 00000000..667f0102 --- /dev/null +++ b/mmdetection/CV_05/DiNO/dino_Swin_L_baseline.py @@ -0,0 +1,281 @@ +_base_ = [ + '../configs/_base_/datasets/coco_detection.py', + '../configs/_base_/default_runtime.py' +] +########################################################################### +#Model +########################################################################### + +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_large_patch4_window12_384_22k.pth' +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/dino/dino-5scale_swin-l_8xb2-12e_coco/dino-5scale_swin-l_8xb2-12e_coco_20230228_072924-a654145f.pth' + +model = dict( + type='DINO', + num_queries=900, # num_matching_queries + with_box_refine=True, + as_two_stage=True, + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=1), + num_feature_levels=5, + backbone=dict( + type='SwinTransformer', + pretrain_img_size=384, + embed_dims=192, + depths=[2, 2, 18, 2], + num_heads=[6, 12, 24, 48], + window_size=12, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.2, + patch_norm=True, + out_indices=(0, 1, 2, 3), + # Please only add indices that would be used + # in FPN, otherwise some parameter will not be used + with_cp=True, + convert_weights=True, + init_cfg=dict(type='Pretrained', checkpoint=pretrained)), + neck=dict( + type='ChannelMapper', + in_channels=[192, 384, 768, 1536], + kernel_size=1, + out_channels=256, + act_cfg=None, + norm_cfg=dict(type='GN', num_groups=32), + num_outs=5), + encoder=dict( + num_layers=6, + layer_cfg=dict( + self_attn_cfg=dict(embed_dims=256, num_levels=5, + dropout=0.0), # 0.1 for DeformDETR + ffn_cfg=dict( + embed_dims=256, + feedforward_channels=2048, # 1024 for DeformDETR + ffn_drop=0.0))), # 0.1 for DeformDETR + decoder=dict( + num_layers=6, + return_intermediate=True, + layer_cfg=dict( + self_attn_cfg=dict(embed_dims=256, num_heads=8, + dropout=0.0), # 0.1 for DeformDETR + cross_attn_cfg=dict(embed_dims=256, num_levels=5, + dropout=0.0), # 0.1 for DeformDETR + ffn_cfg=dict( + embed_dims=256, + feedforward_channels=2048, # 1024 for DeformDETR + ffn_drop=0.0)), # 0.1 for DeformDETR + post_norm_cfg=None), + positional_encoding=dict( + num_feats=128, + normalize=True, + offset=0.0, # -0.5 for DeformDETR + temperature=20), # 10000 for DeformDETR + bbox_head=dict( + type='DINOHead', + ##클래스 수 설정해주기 + num_classes=10, + sync_cls_avg_factor=True, + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), # 2.0 in DeformDETR + loss_bbox=dict(type='L1Loss', loss_weight=5.0), + loss_iou=dict(type='GIoULoss', loss_weight=2.0)), + dn_cfg=dict( # TODO: Move to model.train_cfg ? + label_noise_scale=0.5, + box_noise_scale=1.0, # 0.4 for DN-DETR + group_cfg=dict(dynamic=True, num_groups=None, + num_dn_queries=100)), # TODO: half num_dn_queries + # training and testing settings + train_cfg=dict( + assigner=dict( + type='HungarianAssigner', + match_costs=[ + dict(type='FocalLossCost', weight=2.0), + dict(type='BBoxL1Cost', weight=5.0, box_format='xywh'), + dict(type='IoUCost', iou_mode='giou', weight=2.0) + ])), + test_cfg=dict(max_per_img=300)) # 100 for DeformDETR + +########################################################################### +#pipline +########################################################################### + +data_root ='/data/ephemeral/home/dataset/' +metainfo = { + 'classes': ('General trash', 'Paper', 'Paper pack', 'Metal', 'Glass', + 'Plastic', 'Styrofoam', 'Plastic bag', 'Battery', 'Clothing',), + 'palette': [ + (220, 20, 60), (119, 11, 32), (0, 0, 230), (106, 0, 228), (60, 20, 220), + (0, 80, 100), (0, 0, 70), (50, 0, 192), (250, 170, 30), (255, 0, 0) + ] +} + +backend_args = None +color_space = [ + [dict(type='ColorTransform')], + [dict(type='AutoContrast')], + [dict(type='Equalize')], + [dict(type='Sharpness')], + [dict(type='Posterize')], + [dict(type='Solarize')], + [dict(type='Color')], + [dict(type='Contrast')], + [dict(type='Brightness')], +] + +image_size = (1024, 1024) +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='Resize', scale=image_size, keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomResize', + scale=image_size, + ratio_range=(0.1, 2.0), + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=image_size, + recompute_bbox=True, + allow_negative_crop=True), + # dict(type='RandAugment', aug_space=color_space, aug_num=1), + dict(type='PackDetInputs') +] + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=None), + dict(type='Resize', scale=image_size, keep_ratio=True), + # If you don't have a gt annotation, delete the pipeline + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict( + batch_size=1, + num_workers=4, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + dataset=dict( + data_root=data_root, + ann_file='train_kfold_0.json', + data_prefix=dict(img=''), + pipeline=train_pipeline, + metainfo=metainfo)) + +val_dataloader = ( + dict( + batch_size=1, + num_workers=4, + dataset=dict( + data_root=data_root, + ann_file='val_kfold_0.json', + data_prefix=dict(img=''), + pipeline=test_pipeline, + metainfo=metainfo))) + +test_dataloader = ( + dict( + batch_size=1, + num_workers=4, + dataset=dict( + data_root=data_root, + ann_file='test.json', + data_prefix=dict(img=''), + pipeline=test_pipeline, + metainfo=metainfo))) + +########################################################################### +#evaluator +########################################################################### + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'train_kfold_0.json', + metric=['bbox'], + format_only=False, + classwise=True) + +test_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'test.json', + metric=['bbox'], + format_only=False, + classwise=True) + +########################################################################### +#schedule & optimize +########################################################################### + +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0001), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict(custom_keys={'backbone': dict(lr_mult=0.1)})) + +max_epochs = 25 +train_cfg = dict( + type='EpochBasedTrainLoop', + max_epochs=max_epochs, + val_interval=1) + +param_scheduler = [ + dict( + type='CosineAnnealingLR', + eta_min=0.0, + begin=0, + T_max=max_epochs, + end=max_epochs, + by_epoch=True, + convert_to_iter_based=True) +] + +val_cfg = (dict(type='ValLoop')) +test_cfg = (dict(type='TestLoop')) + +########################################################################### +#visualizer & hooks +########################################################################### + +vis_backends = [ + dict(type='LocalVisBackend', save_dir='visualizations'), + dict(type='WandbVisBackend', + init_kwargs={ + 'project': 'mmdetection', + 'name': 'DINO_NEW' + }) +] + +visualizer = dict( + type='DetLocalVisualizer', + vis_backends=vis_backends, + name='visualizer') + +default_hooks = dict(checkpoint=dict(by_epoch=True, interval=1, max_keep_ckpts=3)) +log_processor = dict(by_epoch=True) + +default_hooks = dict( + timer=dict(type='IterTimerHook'), + logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False), + param_scheduler=dict(type='ParamSchedulerHook'), + checkpoint=dict(type='CheckpointHook', + interval=1, # 매 에폭마다 + by_epoch=True, # 에폭 기준으로 저장 + max_keep_ckpts=3), # 최근 3개만 유지 + sampler_seed=dict(type='DistSamplerSeedHook'), + visualization=dict(type='DetVisualizationHook')) + +auto_scale_lr = dict(base_batch_size=2) \ No newline at end of file diff --git a/mmdetection/CV_05/_base_/default_dataset.py b/mmdetection/CV_05/_base_/default_dataset.py new file mode 100644 index 00000000..45434c30 --- /dev/null +++ b/mmdetection/CV_05/_base_/default_dataset.py @@ -0,0 +1,114 @@ +num_classes = 10 +image_size = (1024, 1024) +classes = ("General trash", "Paper", "Paper pack", "Metal", "Glass", + "Plastic", "Styrofoam", "Plastic bag", "Battery", "Clothing") + + +# dataset settings ( 반드시 확인하기 ) +dataset_type = 'CocoDataset' # data format 정의 +data_root = '/data/ephemeral/home/dataset' # json과 train 모두 위치하는 최상단 폴더 +train_ann_file_name = "MLSK_split/train_fold_2.json" # train ann file +val_ann_file_name = "MLSK_split/val_fold_2.json" # val ann file +test_ann_file_name = "test.json" +img_folder = "" # 신경안써도 됨 + + + +color_space = [ + [dict(type='ColorTransform')], + [dict(type='AutoContrast')], + [dict(type='Equalize')], + [dict(type='Sharpness')], + [dict(type='Posterize')], + [dict(type='Solarize')], + [dict(type='Color')], + [dict(type='Contrast')], + [dict(type='Brightness')], +] + + +backend_args = None +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True), + # dict(type='PhotoMetricDistortion'), + # dict(type='Corrupt', corruption='gaussian_blur'), + dict( + type='RandomResize', + scale=image_size, + ratio_range=(0.1, 2.0), + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=image_size, + recompute_bbox=True, + allow_negative_crop=True), + dict(type='RandomFlip', prob=0.5), + dict(type='RandAugment', aug_space=color_space, aug_num=1), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict(type='PackDetInputs') +] + + +train_dataloader = dict( + batch_size=1, + num_workers=4, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type=dataset_type, + metainfo=dict(classes=classes), + data_root=data_root, + ann_file=train_ann_file_name, + pipeline=train_pipeline, + data_prefix=dict(img=img_folder), + filter_cfg=dict(filter_empty_gt=False, min_size=32)) +) + + +# follow ViTDet +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='Resize', scale=image_size, keep_ratio=True), # diff + dict(type='LoadAnnotations', with_bbox=True, with_mask=False), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + metainfo=dict(classes=classes), # 클래스 정보 반드시 적기 + data_root=data_root, # 마찬가지로 data_root + ann_file=val_ann_file_name, # validation_ann_file + data_prefix=dict(img=img_folder), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) + +test_dataloader = val_dataloader + + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + "/" + val_ann_file_name, + metric='bbox', + format_only=False, + backend_args=backend_args) + + +test_evaluator = dict( + type='CustomResultDumping', # custom evaluating method를 정의 + img_prefix="/data/ephemeral/home/dataset/", # dataset 최상단 폴더 + outfile_path='/data/ephemeral/home/mmdetection/work_dir/co', + classes=classes # class 정보를 담은 list나 집합 + ) \ No newline at end of file diff --git a/mmdetection/CV_05/_base_/default_multi_dataset.py b/mmdetection/CV_05/_base_/default_multi_dataset.py new file mode 100644 index 00000000..7213666b --- /dev/null +++ b/mmdetection/CV_05/_base_/default_multi_dataset.py @@ -0,0 +1,120 @@ +num_classes = 10 +image_size = (1024, 1024) +classes = ("General trash", "Paper", "Paper pack", "Metal", "Glass", + "Plastic", "Styrofoam", "Plastic bag", "Battery", "Clothing") + + +# dataset settings ( 반드시 확인하기 ) +dataset_type = 'CocoDataset' # data format 정의 +data_root = '/data/ephemeral/home/dataset' # json과 train 모두 위치하는 최상단 폴더 +train_ann_file_name = "MLSK_split/train_fold_2.json" # train ann file +val_ann_file_name = "MLSK_split/val_fold_2.json" # val ann file +test_ann_file_name = "test.json" +img_folder = "" # 신경안써도 됨 + + + +color_space = [ + [dict(type='ColorTransform')], + [dict(type='AutoContrast')], + [dict(type='Equalize')], + [dict(type='Sharpness')], + [dict(type='Posterize')], + [dict(type='Solarize')], + [dict(type='Color')], + [dict(type='Contrast')], + [dict(type='Brightness')], +] + + +backend_args = None +train_pipeline = [ + dict(type='Mosaic', img_scale=(1024, 1024), prob=1.0), + dict(type='RandomFlip', prob=0.5), + dict(type='RandAugment', aug_space=color_space, aug_num=1), + # dict(type='PhotoMetricDistortion'), + # dict(type='Corrupt', corruption='gaussian_blur'), + dict( + type='RandomResize', + scale=image_size, + ratio_range=(0.1, 2.0), + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=image_size, + recompute_bbox=True, + allow_negative_crop=True), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict(type='PackDetInputs') +] + + +train_dataloader = dict( + batch_size=1, + num_workers=4, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + # use MultiImageMixDataset wrapper to support mosaic and mixup + type='MultiImageMixDataset', + dataset=dict( + type=dataset_type, + metainfo=dict(classes=classes), + data_root=data_root, + ann_file=train_ann_file_name, + data_prefix=dict(img=img_folder), + pipeline=[ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True) + ], + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + pipeline=train_pipeline) +) + + +# follow ViTDet +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='Resize', scale=image_size, keep_ratio=True), # diff + dict(type='LoadAnnotations', with_bbox=True, with_mask=False), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + metainfo=dict(classes=classes), # 클래스 정보 반드시 적기 + data_root=data_root, # 마찬가지로 data_root + ann_file=val_ann_file_name, # validation_ann_file + data_prefix=dict(img=img_folder), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) + +test_dataloader = val_dataloader + + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + "/" + val_ann_file_name, + metric='bbox', + format_only=False, + backend_args=backend_args) + + +test_evaluator = dict( + type='CustomResultDumping', # custom evaluating method를 정의 + img_prefix="/data/ephemeral/home/dataset/", # dataset 최상단 폴더 + outfile_path='/data/ephemeral/home/mmdetection/work_dir/co', + classes=classes # class 정보를 담은 list나 집합 + ) \ No newline at end of file diff --git a/mmdetection/CV_05/_base_/default_runtime.py b/mmdetection/CV_05/_base_/default_runtime.py new file mode 100644 index 00000000..acfd9a41 --- /dev/null +++ b/mmdetection/CV_05/_base_/default_runtime.py @@ -0,0 +1,76 @@ +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=2e-4, weight_decay=0.0001), + clip_grad=dict(max_norm=0.1, norm_type=2), + accumulative_counts=2, + paramwise_cfg=dict(custom_keys={'backbone': dict(lr_mult=0.1)})) + + +# learning policy +max_epochs = 36 # 에폭 수 증가 +train_cfg = dict( + type='EpochBasedTrainLoop', + max_epochs=max_epochs, + val_interval=1) + +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +param_scheduler = [ + dict( + type='CosineAnnealingLR', + eta_min=0.0, + begin=0, + T_max=max_epochs, + end=max_epochs, + by_epoch=True, + convert_to_iter_based=True) +] + + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=16) + +########################################################################### +#visuallization & hooks +########################################################################### + +vis_backends = [ + dict(type='LocalVisBackend', save_dir='visualizations'), + dict(type='WandbVisBackend', + init_kwargs={ + 'project': 'mmdetection', + 'name': 'cascade_convnext_v2_baseline' + }) +] +default_scope = 'mmdet' +default_hooks = dict( + timer=dict(type='IterTimerHook'), + logger=dict(type='LoggerHook', interval=50), + param_scheduler=dict(type='ParamSchedulerHook'), + checkpoint=dict(type='CheckpointHook', + interval=1, + save_best='coco/bbox_mAP_50', + max_keep_ckpts=2), + sampler_seed=dict(type='DistSamplerSeedHook'), + visualization=dict(type='DetVisualizationHook')) + +env_cfg = dict( + cudnn_benchmark=False, + mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0), + dist_cfg=dict(backend='nccl'), +) + +visualizer = dict( + type='DetLocalVisualizer', vis_backends=vis_backends, name='visualizer') +visualization=dict( + type='DetVisualizationHook', + draw=True, + interval=1, + show=True) +log_processor = dict(type='LogProcessor', window_size=50, by_epoch=True) + +log_level = 'INFO' \ No newline at end of file diff --git a/mmdetection/CV_05/_base_/default_tta.py b/mmdetection/CV_05/_base_/default_tta.py new file mode 100644 index 00000000..2d94f3b6 --- /dev/null +++ b/mmdetection/CV_05/_base_/default_tta.py @@ -0,0 +1,25 @@ +tta_model = dict( + type='DetTTAModel', + tta_cfg=dict(nms=dict( + type='nms', + iou_threshold=0.5), + max_per_img=300)) + +img_scales = [(1333, 800), (666, 400), (2000, 1200)] +tta_pipeline = [ + dict(type='LoadImageFromFile', + backend_args=None), + dict( + type='TestTimeAug', + transforms=[[ + dict(type='Resize', scale=s, keep_ratio=True) for s in img_scales + ], [ + dict(type='RandomFlip', prob=1.), + dict(type='RandomFlip', prob=0.) + ], [ + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', + 'img_shape', 'scale_factor', 'flip', + 'flip_direction')) + ]])] \ No newline at end of file diff --git a/mmdetection/CV_05/_base_/heavy_augmentation_dataset.py b/mmdetection/CV_05/_base_/heavy_augmentation_dataset.py new file mode 100644 index 00000000..a74c4612 --- /dev/null +++ b/mmdetection/CV_05/_base_/heavy_augmentation_dataset.py @@ -0,0 +1,94 @@ +num_classes = 10 +image_size = (1024, 1024) +classes = ("General trash", "Paper", "Paper pack", "Metal", "Glass", + "Plastic", "Styrofoam", "Plastic bag", "Battery", "Clothing") + + +# dataset settings ( 반드시 확인하기 ) +dataset_type = 'CocoDataset' # data format 정의 +data_root = '/data/ephemeral/home/dataset' # json과 train 모두 위치하는 최상단 폴더 +train_ann_file_name = "MLSK_split/train_fold_2.json" # train ann file +val_ann_file_name = "MLSK_split/val_fold_2.json" # val ann file +test_ann_file_name = "test.json" +img_folder = "" # 신경안써도 됨 + + +backend_args = None +train_pipeline = [ + dict(type='Mosaic', img_scale=(1024, 1024), prob=1.0), + dict(type='RandomFlip', prob=0.5), + dict(type='RandomAffine'), + dict(type='PhotoMetricDistortion'), + dict(type='Corrupt', corruption='gaussian_blur'), + dict(type='PackDetInputs') +] + + +train_dataloader = dict( + batch_size=1, + num_workers=4, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + # use MultiImageMixDataset wrapper to support mosaic and mixup + type='MultiImageMixDataset', + dataset=dict( + type=dataset_type, + metainfo=dict(classes=classes), + data_root=data_root, + ann_file=train_ann_file_name, + data_prefix=dict(img=img_folder), + pipeline=[ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True) + ], + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + pipeline=train_pipeline) +) + + +# follow ViTDet +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='Resize', scale=image_size, keep_ratio=True), # diff + dict(type='LoadAnnotations', with_bbox=True, with_mask=False), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + metainfo=dict(classes=classes), # 클래스 정보 반드시 적기 + data_root=data_root, # 마찬가지로 data_root + ann_file=val_ann_file_name, # validation_ann_file + data_prefix=dict(img=img_folder), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) + +test_dataloader = val_dataloader + + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + "/" + val_ann_file_name, + metric='bbox', + format_only=False, + backend_args=backend_args) + + +test_evaluator = dict( + type='CustomResultDumping', # custom evaluating method를 정의 + img_prefix="/data/ephemeral/home/dataset/", # dataset 최상단 폴더 + outfile_path='/data/ephemeral/home/mmdetection/work_dir/co', + classes=classes # class 정보를 담은 list나 집합 + ) \ No newline at end of file diff --git a/mmdetection/CV_05/_base_/lsj_mosaic_augmentation_dataset.py b/mmdetection/CV_05/_base_/lsj_mosaic_augmentation_dataset.py new file mode 100644 index 00000000..380e34be --- /dev/null +++ b/mmdetection/CV_05/_base_/lsj_mosaic_augmentation_dataset.py @@ -0,0 +1,103 @@ +num_classes = 10 +image_size = (1024, 1024) +classes = ("General trash", "Paper", "Paper pack", "Metal", "Glass", + "Plastic", "Styrofoam", "Plastic bag", "Battery", "Clothing") + + +# dataset settings ( 반드시 확인하기 ) +dataset_type = 'CocoDataset' # data format 정의 +data_root = '/data/ephemeral/home/dataset' # json과 train 모두 위치하는 최상단 폴더 +train_ann_file_name = "MLSK_split/train_fold_2.json" # train ann file +val_ann_file_name = "MLSK_split/val_fold_2.json" # val ann file +test_ann_file_name = "test.json" +img_folder = "" # 신경안써도 됨 + + +backend_args = None +train_pipeline = [ + dict(type='Mosaic', img_scale=(1024, 1024), prob=1.0), + dict( + type='RandomResize', + scale=image_size, + ratio_range=(0.1, 2.0), + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=image_size, + recompute_bbox=True, + allow_negative_crop=True), + dict(type='RandomFlip', prob=0.5), + dict(type='Pad', size=image_size, pad_val=dict(img=(114, 114, 114))), + dict(type='PackDetInputs') +] + + +train_dataloader = dict( + batch_size=1, + num_workers=4, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + # use MultiImageMixDataset wrapper to support mosaic and mixup + type='MultiImageMixDataset', + dataset=dict( + type=dataset_type, + metainfo=dict(classes=classes), + data_root=data_root, + ann_file=train_ann_file_name, + data_prefix=dict(img=img_folder), + pipeline=[ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True) + ], + filter_cfg=dict(filter_empty_gt=False, min_size=32)), + pipeline=train_pipeline) +) + + +# follow ViTDet +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='Resize', scale=image_size, keep_ratio=True), # diff + dict(type='LoadAnnotations', with_bbox=True, with_mask=False), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + metainfo=dict(classes=classes), # 클래스 정보 반드시 적기 + data_root=data_root, # 마찬가지로 data_root + ann_file=val_ann_file_name, # validation_ann_file + data_prefix=dict(img=img_folder), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) + +test_dataloader = val_dataloader + + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + "/" + val_ann_file_name, + metric='bbox', + format_only=False, + backend_args=backend_args) + + +test_evaluator = dict( + type='CustomResultDumping', # custom evaluating method를 정의 + img_prefix="/data/ephemeral/home/dataset/", # dataset 최상단 폴더 + outfile_path='/data/ephemeral/home/mmdetection/work_dir/co', + classes=classes # class 정보를 담은 list나 집합 + ) \ No newline at end of file diff --git a/mmdetection/CV_05/_base_/simple_augmentation_dataset.py b/mmdetection/CV_05/_base_/simple_augmentation_dataset.py new file mode 100644 index 00000000..0973f2a9 --- /dev/null +++ b/mmdetection/CV_05/_base_/simple_augmentation_dataset.py @@ -0,0 +1,86 @@ +num_classes = 10 +image_size = (1024, 1024) +classes = ("General trash", "Paper", "Paper pack", "Metal", "Glass", + "Plastic", "Styrofoam", "Plastic bag", "Battery", "Clothing") + + +# dataset settings ( 반드시 확인하기 ) +dataset_type = 'CocoDataset' # data format 정의 +data_root = '/data/ephemeral/home/dataset' # json과 train 모두 위치하는 최상단 폴더 +train_ann_file_name = "MLSK_split/train_fold_2.json" # train ann file +val_ann_file_name = "MLSK_split/val_fold_2.json" # val ann file +test_ann_file_name = "test.json" +img_folder = "" # 신경안써도 됨 + + +backend_args = None +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict(type='PackDetInputs') +] + + +train_dataloader = dict( + batch_size=1, + num_workers=4, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type=dataset_type, + metainfo=dict(classes=classes), + data_root=data_root, + ann_file=train_ann_file_name, + pipeline=train_pipeline, + data_prefix=dict(img=img_folder), + filter_cfg=dict(filter_empty_gt=False, min_size=32)) +) + + +# follow ViTDet +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='Resize', scale=image_size, keep_ratio=True), # diff + dict(type='LoadAnnotations', with_bbox=True, with_mask=False), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + metainfo=dict(classes=classes), # 클래스 정보 반드시 적기 + data_root=data_root, # 마찬가지로 data_root + ann_file=val_ann_file_name, # validation_ann_file + data_prefix=dict(img=img_folder), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) + +test_dataloader = val_dataloader + + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + "/" + val_ann_file_name, + metric='bbox', + format_only=False, + backend_args=backend_args) + + +test_evaluator = dict( + type='CustomResultDumping', # custom evaluating method를 정의 + img_prefix="/data/ephemeral/home/dataset/", # dataset 최상단 폴더 + outfile_path='/data/ephemeral/home/mmdetection/work_dir/co', + classes=classes # class 정보를 담은 list나 집합 + ) \ No newline at end of file diff --git a/mmdetection/CV_05/cascade-RCNN/cascade-rcnn_convnextV2.py b/mmdetection/CV_05/cascade-RCNN/cascade-rcnn_convnextV2.py new file mode 100644 index 00000000..a0340ecf --- /dev/null +++ b/mmdetection/CV_05/cascade-RCNN/cascade-rcnn_convnextV2.py @@ -0,0 +1,210 @@ +_base_ = [ + '../_base_/default_dataset.py', + '../_base_/default_runtime.py', + '../_base_/default_tta.py' +] + + +# model settings +custom_imports = dict( + imports=['mmpretrain.models'], allow_failed_imports=False) +load_from = None +resume = False +checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/convnext-v2/convnext-v2-large_fcmae-in21k-pre_3rdparty_in1k-384px_20230104-9139a1f3.pth' +num_classes = _base_.num_classes + +model = dict( + type='CascadeRCNN', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32), + backbone=dict( + type='mmpretrain.ConvNeXt', + arch='large', + out_indices=[0, 1, 2, 3], + drop_path_rate=0.1, + layer_scale_init_value=0., + gap_before_final_norm=False, + use_grn=True, + init_cfg=dict( + type='Pretrained', checkpoint=checkpoint_file, + prefix='backbone.')), + neck=[ + dict( + type='FPN', + in_channels=[192, 384, 768, 1536], + start_level=0, + out_channels=256, + num_outs=5), + dict( + type='DyHead', + in_channels=256, + out_channels=256, + num_blocks=6, + # disable zero_init_offset to follow official implementation + zero_init_offset=False) + ], + rpn_head=dict( + type='RPNHead', + in_channels=256, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + scales=[8], + ratios=[0.5, 1.0, 2.0], + strides=[4, 8, 16, 32, 64]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[1.0, 1.0, 1.0, 1.0]), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=1.0)), + roi_head=dict( + type='CascadeRoIHead', + num_stages=3, + stage_loss_weights=[1, 0.5, 0.25], + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + bbox_head=[ + dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=num_classes, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, + loss_weight=1.0)), + dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=num_classes, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.05, 0.05, 0.1, 0.1]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, + loss_weight=1.0)), + dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=num_classes, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.033, 0.033, 0.067, 0.067]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0)) + ]), + # model training and testing settings + train_cfg=dict( + rpn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.3, + min_pos_iou=0.3, + match_low_quality=True, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=0, + pos_weight=-1, + debug=False), + rpn_proposal=dict( + nms_pre=2000, + max_per_img=2000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=[ + dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0.5, + match_low_quality=False, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + pos_weight=-1, + debug=False), + dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.6, + neg_iou_thr=0.6, + min_pos_iou=0.6, + match_low_quality=False, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + pos_weight=-1, + debug=False), + dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.7, + min_pos_iou=0.7, + match_low_quality=False, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + pos_weight=-1, + debug=False) + ]), + test_cfg=dict( + rpn=dict( + nms_pre=1000, + max_per_img=1000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=dict( + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.5), + max_per_img=100))) \ No newline at end of file diff --git a/mmdetection/CV_05/cascade-RCNN/cascade-rcnn_swin_L.py b/mmdetection/CV_05/cascade-RCNN/cascade-rcnn_swin_L.py new file mode 100644 index 00000000..cc7e9054 --- /dev/null +++ b/mmdetection/CV_05/cascade-RCNN/cascade-rcnn_swin_L.py @@ -0,0 +1,452 @@ +_base_ = [ + '../configs/_base_/datasets/coco_detection.py', + '../configs/_base_/default_runtime.py' +] + +########################################################################### +#Model +########################################################################### + +pretrained ='https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_large_patch4_window12_384_22k.pth' + +model = dict( + type='CascadeRCNN', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=1), + backbone=dict( + type='SwinTransformer', + pretrain_img_size=384, + embed_dims=192, + depths=[2, 2, 18, 2], + num_heads=[6, 12, 24, 48], + window_size=12, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.2, + patch_norm=True, + out_indices=(0, 1, 2, 3), + with_cp=False, + convert_weights=True, + init_cfg=dict(type='Pretrained', checkpoint=pretrained)), + neck=dict( + type='FPN', + in_channels=[192, 384, 768, 1536], + out_channels=256, + num_outs=5), + rpn_head=dict( + type='RPNHead', + in_channels=256, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + scales=[8], + ratios=[0.5, 1.0, 2.0], + strides=[4, 8, 16, 32, 64]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[1.0, 1.0, 1.0, 1.0]), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=1.0)), + roi_head=dict( + type='CascadeRoIHead', + num_stages=3, + stage_loss_weights=[1, 0.5, 0.25], + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + bbox_head=[ + dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=10, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, + loss_weight=1.0)), + dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=10, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.05, 0.05, 0.1, 0.1]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, + loss_weight=1.0)), + dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=10, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.033, 0.033, 0.067, 0.067]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0)) + ]), + # model training and testing settings + train_cfg=dict( + rpn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.3, + min_pos_iou=0.3, + match_low_quality=True, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=0, + pos_weight=-1, + debug=False), + rpn_proposal=dict( + nms_pre=2000, + max_per_img=2000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=[ + dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0.5, + match_low_quality=False, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + pos_weight=-1, + debug=False), + dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.6, + neg_iou_thr=0.6, + min_pos_iou=0.6, + match_low_quality=False, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + pos_weight=-1, + debug=False), + dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.7, + min_pos_iou=0.7, + match_low_quality=False, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + pos_weight=-1, + debug=False) + ]), + test_cfg=dict( + rpn=dict( + nms_pre=1000, + max_per_img=1000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=dict( + score_thr=0.00, + nms=dict(type='nms', iou_threshold=0.5), + max_per_img=100))) + +########################################################################### +#pipeline +########################################################################### + +dataset_type = 'CocoDataset' +data_root ='/data/ephemeral/home/dataset/' +classes = ("General trash", "Paper", "Paper pack", "Metal", "Glass", + "Plastic", "Styrofoam", "Plastic bag", "Battery", "Clothing") +backend_args = None +image_size = (1024,1024) +color_space = [ + [dict(type='ColorTransform')], + [dict(type='AutoContrast')], + [dict(type='Equalize')], + [dict(type='Sharpness')], + [dict(type='Posterize')], + [dict(type='Solarize')], + [dict(type='Color')], + [dict(type='Contrast')], + [dict(type='Brightness')], +] +albu_transform = [ + dict( + type='OneOf', + transforms=[ + dict(type='CLAHE', clip_limit=4.0, tile_grid_size=(8, 8), p=1.0), + dict(type='RandomGamma', p=1.0), + dict(type='HueSaturationValue', p=1.0), + dict(type='ChannelDropout', p=1.0), + dict(type='ChannelShuffle', p=1.0), + dict(type='RGBShift', p=1.0) + ], + p=0.5 + ), + dict( + type='OneOf', + transforms=[ + dict(type='GaussNoise', p=1.0), + dict(type='GaussianBlur', p=1.0), + dict(type='Blur', p=1.0) + ], + p=0.1 + ), + dict( + type='OneOf', + transforms=[ + dict(type='ShiftScaleRotate', p=1.0), + dict(type='RandomRotate90', p=1.0), + ], + p=0.1 + ) +] + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=[0.5, 0.15], direction=['horizontal', 'vertical']), + # dict(type='RandAugment', aug_space=color_space, aug_num=1), + dict( + type='Albu', + transforms=albu_transform, + bbox_params=dict( + type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', 'gt_ignore_flags'], + min_visibility=0.0, + filter_lost_elements=True), + keymap={ + 'img': 'image', + 'gt_bboxes': 'bboxes' + }, + skip_img_without_anno=True + ), + dict(type='PackDetInputs') +] + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1024, 1024), keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='PackDetInputs') # 이 부분이 있는지 확인 +] +tta_model = dict( + type='DetTTAModel', + tta_cfg=dict(nms=dict( + type='nms', + iou_threshold=0.5), + max_per_img=300)) + +img_scales = [(1333, 800), (666, 400), (2000, 1200)] +tta_pipeline = [ + dict(type='LoadImageFromFile', + backend_args=None), + dict( + type='TestTimeAug', + transforms=[[ + dict(type='Resize', scale=s, keep_ratio=True) for s in img_scales + ], [ + dict(type='RandomFlip', prob=1.), + dict(type='RandomFlip', prob=0.) + ], [ + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', + 'img_shape', 'scale_factor', 'flip', + 'flip_direction')) + ]])] +train_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='train_kfold_1.json', + data_prefix=dict(img=''), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + metainfo=dict(classes=classes), + backend_args=backend_args) +) + +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='val_kfold_1.json', + data_prefix=dict(img=''), + test_mode=True, + pipeline=test_pipeline, + metainfo=dict(classes=classes), + backend_args=backend_args)) + +test_dataloader = ( + dict( + batch_size=2, + num_workers=4, + dataset=dict( + data_root=data_root, + ann_file='test.json', + data_prefix=dict(img=''), + pipeline=test_pipeline, + metainfo=dict(classes=classes)))) + +########################################################################### +#evaluator +########################################################################### + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'val_kfold_1.json', + metric=['bbox'], + format_only=False, + backend_args=backend_args) + +test_evaluator = dict( + _delete_=True, + type='CustomResultDumping', # custom evaluating method를 정의 + img_prefix="/data/ephemeral/home/dataset/", # dataset 최상단 폴더 + outfile_path='/data/ephemeral/home/mmdetection/work_dir/co', + classes=classes # class 정보를 담은 list나 집합 + ) + +########################################################################### +#schedule & optimize +########################################################################### + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.0002, weight_decay=0.05), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict(custom_keys={'backbone': dict(lr_mult=0.05)})) + +# learning policy +max_epochs = 30 # 에폭 수 증가 +train_cfg = dict( + type='EpochBasedTrainLoop', + max_epochs=max_epochs, + val_interval=1) + +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# learning rate scheduler +param_scheduler = [ + dict( + type='LinearLR', + start_factor=0.001, # 웜업 시작 학습률 증가 + by_epoch=False, + begin=0, + end=1000), + dict( + type='CosineAnnealingLR', + eta_min=1e-6, + begin=1000, + end=max_epochs * 1000, + T_max=max_epochs * 1000, + by_epoch=False) +] + + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=16) + +########################################################################### +#visuallization & hooks +########################################################################### + +vis_backends = [ + dict(type='LocalVisBackend', save_dir='visualizations'), + dict(type='WandbVisBackend', + init_kwargs={ + 'project': 'mmdetection', + 'name': 'cascade' + }) +] +default_scope = 'mmdet' +default_hooks = dict( + timer=dict(type='IterTimerHook'), + logger=dict(type='LoggerHook', interval=50), + param_scheduler=dict(type='ParamSchedulerHook'), + checkpoint=dict(type='CheckpointHook', interval=1, max_keep_ckpts=3), + sampler_seed=dict(type='DistSamplerSeedHook'), + visualization=dict(type='DetVisualizationHook')) + +env_cfg = dict( + cudnn_benchmark=False, + mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0), + dist_cfg=dict(backend='nccl'), +) + +visualizer = dict( + type='DetLocalVisualizer', vis_backends=vis_backends, name='visualizer') +log_processor = dict(type='LogProcessor', window_size=50, by_epoch=True) + +log_level = 'INFO' +load_from = None +resume = False \ No newline at end of file diff --git a/mmdetection/CV_05/ddq/ddq_swinl.py b/mmdetection/CV_05/ddq/ddq_swinl.py new file mode 100644 index 00000000..fadddaf5 --- /dev/null +++ b/mmdetection/CV_05/ddq/ddq_swinl.py @@ -0,0 +1,160 @@ +_base_ = [ + '../_base_/default_dataset.py', + '../_base_/default_runtime.py', + '../_base_/default_tta.py' +] + +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_large_patch4_window12_384_22k.pth' # noqa: E501 +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/ddq/ddq_detr_swinl_30e.pth' + +model = dict( + type='DDQDETR', + num_queries=900, # num_matching_queries + # ratio of num_dense queries to num_queries + dense_topk_ratio=1.5, + with_box_refine=True, + as_two_stage=True, + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=1), + backbone=dict( + type='SwinTransformer', + pretrain_img_size=384, + embed_dims=192, + depths=[2, 2, 18, 2], + num_heads=[6, 12, 24, 48], + window_size=12, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.2, + patch_norm=True, + out_indices=(1, 2, 3), + with_cp=False, + convert_weights=True, + init_cfg=dict(type='Pretrained', checkpoint=pretrained)), + neck=dict( + type='ChannelMapper', + in_channels=[384, 768, 1536], + kernel_size=1, + out_channels=256, + act_cfg=None, + norm_cfg=dict(type='GN', num_groups=32), + num_outs=4), + # encoder class name: DeformableDetrTransformerEncoder + encoder=dict( + num_layers=6, + layer_cfg=dict( + self_attn_cfg=dict(embed_dims=256, num_levels=4, + dropout=0.0), # 0.1 for DeformDETR + ffn_cfg=dict( + embed_dims=256, + feedforward_channels=2048, # 1024 for DeformDETR + ffn_drop=0.0))), # 0.1 for DeformDETR + # decoder class name: DDQTransformerDecoder + decoder=dict( + num_layers=6, + return_intermediate=True, + layer_cfg=dict( + self_attn_cfg=dict(embed_dims=256, num_heads=8, + dropout=0.0), # 0.1 for DeformDETR + cross_attn_cfg=dict(embed_dims=256, num_levels=4, + dropout=0.0), # 0.1 for DeformDETR + ffn_cfg=dict( + embed_dims=256, + feedforward_channels=2048, # 1024 for DeformDETR + ffn_drop=0.0)), # 0.1 for DeformDETR + post_norm_cfg=None), + positional_encoding=dict( + num_feats=128, + normalize=True, + offset=0.0, # -0.5 for DeformDETR + temperature=20), # 10000 for DeformDETR + bbox_head=dict( + type='DDQDETRHead', + num_classes=_base_.num_classes, + sync_cls_avg_factor=True, + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=5.0), + loss_iou=dict(type='GIoULoss', loss_weight=2.0)), + dn_cfg=dict( + label_noise_scale=0.5, + box_noise_scale=1.0, + group_cfg=dict(dynamic=True, num_groups=None, num_dn_queries=100)), + dqs_cfg=dict(type='nms', iou_threshold=0.8), + # training and testing settings + train_cfg=dict( + assigner=dict( + type='HungarianAssigner', + match_costs=[ + dict(type='FocalLossCost', weight=2.0), + dict(type='BBoxL1Cost', weight=5.0, box_format='xywh'), + dict(type='IoUCost', iou_mode='giou', weight=2.0) + ])), + test_cfg=dict(max_per_img=300)) + + + +backend_args = None +train_pipeline = [ + dict(type='Mosaic', img_scale=(1024, 1024), prob=1.0), + dict(type='RandomFlip', prob=0.5), + dict(type='RandomAffine'), + dict(type='PhotoMetricDistortion'), + dict(type='Corrupt', corruption='gaussian_blur'), + dict(type='PackDetInputs') +] +train_dataloader = dict( + dataset=dict( + pipeline=train_pipeline + ) +) + + + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.0002, weight_decay=0.05), + clip_grad=dict(max_norm=0.1, norm_type=2), + accumulative_counts=2, + paramwise_cfg=dict(custom_keys={'backbone': dict(lr_mult=0.05)})) + + +# learning policy +max_epochs = 36 # 에폭 수 증가 +train_cfg = dict( + type='EpochBasedTrainLoop', + max_epochs=max_epochs, + val_interval=1) + +param_scheduler = [ + dict( + type='LinearLR', + begin=0, + end=2000, + by_epoch=False, + start_factor=0.0001 + ), + dict( + type='MultiStepLR', + begin=0, + end=30, + gamma=0.1, + by_epoch=True, + milestones=[ + 20, + 26 + ] + ) +] \ No newline at end of file diff --git a/mmdetection/LICENSE b/mmdetection/LICENSE new file mode 100644 index 00000000..1bfc23e4 --- /dev/null +++ b/mmdetection/LICENSE @@ -0,0 +1,203 @@ +Copyright 2018-2023 OpenMMLab. All rights reserved. + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2018-2023 OpenMMLab. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/mmdetection/MANIFEST.in b/mmdetection/MANIFEST.in new file mode 100644 index 00000000..7398e6a6 --- /dev/null +++ b/mmdetection/MANIFEST.in @@ -0,0 +1,7 @@ +include requirements/*.txt +include mmdet/VERSION +include mmdet/.mim/model-index.yml +include mmdet/.mim/dataset-index.yml +include mmdet/.mim/demo/*/* +recursive-include mmdet/.mim/configs *.py *.yml +recursive-include mmdet/.mim/tools *.sh *.py diff --git a/mmdetection/README.md b/mmdetection/README.md new file mode 100644 index 00000000..34f7f0b8 --- /dev/null +++ b/mmdetection/README.md @@ -0,0 +1,455 @@ +
+ +
 
+
+ OpenMMLab website + + + HOT + + +      + OpenMMLab platform + + + TRY IT OUT + + +
+
 
+ +[![PyPI](https://img.shields.io/pypi/v/mmdet)](https://pypi.org/project/mmdet) +[![docs](https://img.shields.io/badge/docs-latest-blue)](https://mmdetection.readthedocs.io/en/latest/) +[![badge](https://github.com/open-mmlab/mmdetection/workflows/build/badge.svg)](https://github.com/open-mmlab/mmdetection/actions) +[![codecov](https://codecov.io/gh/open-mmlab/mmdetection/branch/main/graph/badge.svg)](https://codecov.io/gh/open-mmlab/mmdetection) +[![license](https://img.shields.io/github/license/open-mmlab/mmdetection.svg)](https://github.com/open-mmlab/mmdetection/blob/main/LICENSE) +[![open issues](https://isitmaintained.com/badge/open/open-mmlab/mmdetection.svg)](https://github.com/open-mmlab/mmdetection/issues) +[![issue resolution](https://isitmaintained.com/badge/resolution/open-mmlab/mmdetection.svg)](https://github.com/open-mmlab/mmdetection/issues) +[![Open in OpenXLab](https://cdn-static.openxlab.org.cn/app-center/openxlab_demo.svg)](https://openxlab.org.cn/apps?search=mmdet) + +[📘Documentation](https://mmdetection.readthedocs.io/en/latest/) | +[🛠️Installation](https://mmdetection.readthedocs.io/en/latest/get_started.html) | +[👀Model Zoo](https://mmdetection.readthedocs.io/en/latest/model_zoo.html) | +[🆕Update News](https://mmdetection.readthedocs.io/en/latest/notes/changelog.html) | +[🚀Ongoing Projects](https://github.com/open-mmlab/mmdetection/projects) | +[🤔Reporting Issues](https://github.com/open-mmlab/mmdetection/issues/new/choose) + +
+ +
+ +English | [简体中文](README_zh-CN.md) + +
+ +
+ + + + + + + + + + + + + + + + + +
+ +
+ +
+ +## Introduction + +MMDetection is an open source object detection toolbox based on PyTorch. It is +a part of the [OpenMMLab](https://openmmlab.com/) project. + +The main branch works with **PyTorch 1.8+**. + + + +
+Major features + +- **Modular Design** + + We decompose the detection framework into different components and one can easily construct a customized object detection framework by combining different modules. + +- **Support of multiple tasks out of box** + + The toolbox directly supports multiple detection tasks such as **object detection**, **instance segmentation**, **panoptic segmentation**, and **semi-supervised object detection**. + +- **High efficiency** + + All basic bbox and mask operations run on GPUs. The training speed is faster than or comparable to other codebases, including [Detectron2](https://github.com/facebookresearch/detectron2), [maskrcnn-benchmark](https://github.com/facebookresearch/maskrcnn-benchmark) and [SimpleDet](https://github.com/TuSimple/simpledet). + +- **State of the art** + + The toolbox stems from the codebase developed by the *MMDet* team, who won [COCO Detection Challenge](http://cocodataset.org/#detection-leaderboard) in 2018, and we keep pushing it forward. + The newly released [RTMDet](configs/rtmdet) also obtains new state-of-the-art results on real-time instance segmentation and rotated object detection tasks and the best parameter-accuracy trade-off on object detection. + +
+ +Apart from MMDetection, we also released [MMEngine](https://github.com/open-mmlab/mmengine) for model training and [MMCV](https://github.com/open-mmlab/mmcv) for computer vision research, which are heavily depended on by this toolbox. + +## What's New + +💎 **We have released the pre-trained weights for MM-Grounding-DINO Swin-B and Swin-L, welcome to try and give feedback.** + +### Highlight + +**v3.3.0** was released in 5/1/2024: + +**[MM-Grounding-DINO: An Open and Comprehensive Pipeline for Unified Object Grounding and Detection](https://arxiv.org/abs/2401.02361)** + +Grounding DINO is a grounding pre-training model that unifies 2d open vocabulary object detection and phrase grounding, with wide applications. However, its training part has not been open sourced. Therefore, we propose MM-Grounding-DINO, which not only serves as an open source replication version of Grounding DINO, but also achieves significant performance improvement based on reconstructed data types, exploring different dataset combinations and initialization strategies. Moreover, we conduct evaluations from multiple dimensions, including OOD, REC, Phrase Grounding, OVD, and Fine-tune, to fully excavate the advantages and disadvantages of Grounding pre-training, hoping to provide inspiration for future work. + +code: [mm_grounding_dino/README.md](configs/mm_grounding_dino/README.md) + +
+ +
+ +We are excited to announce our latest work on real-time object recognition tasks, **RTMDet**, a family of fully convolutional single-stage detectors. RTMDet not only achieves the best parameter-accuracy trade-off on object detection from tiny to extra-large model sizes but also obtains new state-of-the-art performance on instance segmentation and rotated object detection tasks. Details can be found in the [technical report](https://arxiv.org/abs/2212.07784). Pre-trained models are [here](configs/rtmdet). + +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/rtmdet-an-empirical-study-of-designing-real/real-time-instance-segmentation-on-mscoco)](https://paperswithcode.com/sota/real-time-instance-segmentation-on-mscoco?p=rtmdet-an-empirical-study-of-designing-real) +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/rtmdet-an-empirical-study-of-designing-real/object-detection-in-aerial-images-on-dota-1)](https://paperswithcode.com/sota/object-detection-in-aerial-images-on-dota-1?p=rtmdet-an-empirical-study-of-designing-real) +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/rtmdet-an-empirical-study-of-designing-real/object-detection-in-aerial-images-on-hrsc2016)](https://paperswithcode.com/sota/object-detection-in-aerial-images-on-hrsc2016?p=rtmdet-an-empirical-study-of-designing-real) + +| Task | Dataset | AP | FPS(TRT FP16 BS1 3090) | +| ------------------------ | ------- | ------------------------------------ | ---------------------- | +| Object Detection | COCO | 52.8 | 322 | +| Instance Segmentation | COCO | 44.6 | 188 | +| Rotated Object Detection | DOTA | 78.9(single-scale)/81.3(multi-scale) | 121 | + +
+ +
+ +## Installation + +Please refer to [Installation](https://mmdetection.readthedocs.io/en/latest/get_started.html) for installation instructions. + +## Getting Started + +Please see [Overview](https://mmdetection.readthedocs.io/en/latest/get_started.html) for the general introduction of MMDetection. + +For detailed user guides and advanced guides, please refer to our [documentation](https://mmdetection.readthedocs.io/en/latest/): + +- User Guides + +
+ + - [Train & Test](https://mmdetection.readthedocs.io/en/latest/user_guides/index.html#train-test) + - [Learn about Configs](https://mmdetection.readthedocs.io/en/latest/user_guides/config.html) + - [Inference with existing models](https://mmdetection.readthedocs.io/en/latest/user_guides/inference.html) + - [Dataset Prepare](https://mmdetection.readthedocs.io/en/latest/user_guides/dataset_prepare.html) + - [Test existing models on standard datasets](https://mmdetection.readthedocs.io/en/latest/user_guides/test.html) + - [Train predefined models on standard datasets](https://mmdetection.readthedocs.io/en/latest/user_guides/train.html) + - [Train with customized datasets](https://mmdetection.readthedocs.io/en/latest/user_guides/train.html#train-with-customized-datasets) + - [Train with customized models and standard datasets](https://mmdetection.readthedocs.io/en/latest/user_guides/new_model.html) + - [Finetuning Models](https://mmdetection.readthedocs.io/en/latest/user_guides/finetune.html) + - [Test Results Submission](https://mmdetection.readthedocs.io/en/latest/user_guides/test_results_submission.html) + - [Weight initialization](https://mmdetection.readthedocs.io/en/latest/user_guides/init_cfg.html) + - [Use a single stage detector as RPN](https://mmdetection.readthedocs.io/en/latest/user_guides/single_stage_as_rpn.html) + - [Semi-supervised Object Detection](https://mmdetection.readthedocs.io/en/latest/user_guides/semi_det.html) + - [Useful Tools](https://mmdetection.readthedocs.io/en/latest/user_guides/index.html#useful-tools) + +
+ +- Advanced Guides + +
+ + - [Basic Concepts](https://mmdetection.readthedocs.io/en/latest/advanced_guides/index.html#basic-concepts) + - [Component Customization](https://mmdetection.readthedocs.io/en/latest/advanced_guides/index.html#component-customization) + - [How to](https://mmdetection.readthedocs.io/en/latest/advanced_guides/index.html#how-to) + +
+ +We also provide object detection colab tutorial [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](demo/MMDet_Tutorial.ipynb) and instance segmentation colab tutorial [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](demo/MMDet_InstanceSeg_Tutorial.ipynb). + +To migrate from MMDetection 2.x, please refer to [migration](https://mmdetection.readthedocs.io/en/latest/migration.html). + +## Overview of Benchmark and Model Zoo + +Results and models are available in the [model zoo](docs/en/model_zoo.md). + +
+ Architectures +
+ + + + + + + + + + + + + + + + + +
+ Object Detection + + Instance Segmentation + + Panoptic Segmentation + + Other +
+ + + + + + + +
  • Contrastive Learning
    • + + +
  • Distillation
    • + +
  • Semi-Supervised Object Detection
    • + + +
    + +
    + Components +
    + + + + + + + + + + + + + + + + + +
    + Backbones + + Necks + + Loss + + Common +
    + + + + + + + +
    + +Some other methods are also supported in [projects using MMDetection](./docs/en/notes/projects.md). + +## FAQ + +Please refer to [FAQ](docs/en/notes/faq.md) for frequently asked questions. + +## Contributing + +We appreciate all contributions to improve MMDetection. Ongoing projects can be found in out [GitHub Projects](https://github.com/open-mmlab/mmdetection/projects). Welcome community users to participate in these projects. Please refer to [CONTRIBUTING.md](.github/CONTRIBUTING.md) for the contributing guideline. + +## Acknowledgement + +MMDetection is an open source project that is contributed by researchers and engineers from various colleges and companies. We appreciate all the contributors who implement their methods or add new features, as well as users who give valuable feedbacks. +We wish that the toolbox and benchmark could serve the growing research community by providing a flexible toolkit to reimplement existing methods and develop their own new detectors. + +## Citation + +If you use this toolbox or benchmark in your research, please cite this project. + +``` +@article{mmdetection, + title = {{MMDetection}: Open MMLab Detection Toolbox and Benchmark}, + author = {Chen, Kai and Wang, Jiaqi and Pang, Jiangmiao and Cao, Yuhang and + Xiong, Yu and Li, Xiaoxiao and Sun, Shuyang and Feng, Wansen and + Liu, Ziwei and Xu, Jiarui and Zhang, Zheng and Cheng, Dazhi and + Zhu, Chenchen and Cheng, Tianheng and Zhao, Qijie and Li, Buyu and + Lu, Xin and Zhu, Rui and Wu, Yue and Dai, Jifeng and Wang, Jingdong + and Shi, Jianping and Ouyang, Wanli and Loy, Chen Change and Lin, Dahua}, + journal= {arXiv preprint arXiv:1906.07155}, + year={2019} +} +``` + +## License + +This project is released under the [Apache 2.0 license](LICENSE). + +## Projects in OpenMMLab + +- [MMEngine](https://github.com/open-mmlab/mmengine): OpenMMLab foundational library for training deep learning models. +- [MMCV](https://github.com/open-mmlab/mmcv): OpenMMLab foundational library for computer vision. +- [MMPreTrain](https://github.com/open-mmlab/mmpretrain): OpenMMLab pre-training toolbox and benchmark. +- [MMagic](https://github.com/open-mmlab/mmagic): Open**MM**Lab **A**dvanced, **G**enerative and **I**ntelligent **C**reation toolbox. +- [MMDetection](https://github.com/open-mmlab/mmdetection): OpenMMLab detection toolbox and benchmark. +- [MMDetection3D](https://github.com/open-mmlab/mmdetection3d): OpenMMLab's next-generation platform for general 3D object detection. +- [MMRotate](https://github.com/open-mmlab/mmrotate): OpenMMLab rotated object detection toolbox and benchmark. +- [MMYOLO](https://github.com/open-mmlab/mmyolo): OpenMMLab YOLO series toolbox and benchmark. +- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation): OpenMMLab semantic segmentation toolbox and benchmark. +- [MMOCR](https://github.com/open-mmlab/mmocr): OpenMMLab text detection, recognition, and understanding toolbox. +- [MMPose](https://github.com/open-mmlab/mmpose): OpenMMLab pose estimation toolbox and benchmark. +- [MMHuman3D](https://github.com/open-mmlab/mmhuman3d): OpenMMLab 3D human parametric model toolbox and benchmark. +- [MMSelfSup](https://github.com/open-mmlab/mmselfsup): OpenMMLab self-supervised learning toolbox and benchmark. +- [MMRazor](https://github.com/open-mmlab/mmrazor): OpenMMLab model compression toolbox and benchmark. +- [MMFewShot](https://github.com/open-mmlab/mmfewshot): OpenMMLab fewshot learning toolbox and benchmark. +- [MMAction2](https://github.com/open-mmlab/mmaction2): OpenMMLab's next-generation action understanding toolbox and benchmark. +- [MMTracking](https://github.com/open-mmlab/mmtracking): OpenMMLab video perception toolbox and benchmark. +- [MMFlow](https://github.com/open-mmlab/mmflow): OpenMMLab optical flow toolbox and benchmark. +- [MMEditing](https://github.com/open-mmlab/mmediting): OpenMMLab image and video editing toolbox. +- [MMGeneration](https://github.com/open-mmlab/mmgeneration): OpenMMLab image and video generative models toolbox. +- [MMDeploy](https://github.com/open-mmlab/mmdeploy): OpenMMLab model deployment framework. +- [MIM](https://github.com/open-mmlab/mim): MIM installs OpenMMLab packages. +- [MMEval](https://github.com/open-mmlab/mmeval): A unified evaluation library for multiple machine learning libraries. +- [Playground](https://github.com/open-mmlab/playground): A central hub for gathering and showcasing amazing projects built upon OpenMMLab. diff --git a/mmdetection/README_zh-CN.md b/mmdetection/README_zh-CN.md new file mode 100644 index 00000000..8d7c060f --- /dev/null +++ b/mmdetection/README_zh-CN.md @@ -0,0 +1,476 @@ +
    + +
     
    +
    + OpenMMLab 官网 + + + HOT + + +      + OpenMMLab 开放平台 + + + TRY IT OUT + + +
    +
     
    + +[![PyPI](https://img.shields.io/pypi/v/mmdet)](https://pypi.org/project/mmdet) +[![docs](https://img.shields.io/badge/docs-latest-blue)](https://mmdetection.readthedocs.io/en/latest/) +[![badge](https://github.com/open-mmlab/mmdetection/workflows/build/badge.svg)](https://github.com/open-mmlab/mmdetection/actions) +[![codecov](https://codecov.io/gh/open-mmlab/mmdetection/branch/main/graph/badge.svg)](https://codecov.io/gh/open-mmlab/mmdetection) +[![license](https://img.shields.io/github/license/open-mmlab/mmdetection.svg)](https://github.com/open-mmlab/mmdetection/blob/main/LICENSE) +[![open issues](https://isitmaintained.com/badge/open/open-mmlab/mmdetection.svg)](https://github.com/open-mmlab/mmdetection/issues) +[![issue resolution](https://isitmaintained.com/badge/resolution/open-mmlab/mmdetection.svg)](https://github.com/open-mmlab/mmdetection/issues) +[![Open in OpenXLab](https://cdn-static.openxlab.org.cn/app-center/openxlab_demo.svg)](https://openxlab.org.cn/apps?search=mmdet) + +[📘使用文档](https://mmdetection.readthedocs.io/zh_CN/latest/) | +[🛠️安装教程](https://mmdetection.readthedocs.io/zh_CN/latest/get_started.html) | +[👀模型库](https://mmdetection.readthedocs.io/zh_CN/latest/model_zoo.html) | +[🆕更新日志](https://mmdetection.readthedocs.io/en/latest/notes/changelog.html) | +[🚀进行中的项目](https://github.com/open-mmlab/mmdetection/projects) | +[🤔报告问题](https://github.com/open-mmlab/mmdetection/issues/new/choose) + +
    + +
    + +[English](README.md) | 简体中文 + +
    + +
    + + + + + + + + + + + + + + + + + +
    + +
    + +
    + +## 简介 + +MMDetection 是一个基于 PyTorch 的目标检测开源工具箱。它是 [OpenMMLab](https://openmmlab.com/) 项目的一部分。 + +主分支代码目前支持 PyTorch 1.8 及其以上的版本。 + + + +
    +主要特性 + +- **模块化设计** + + MMDetection 将检测框架解耦成不同的模块组件，通过组合不同的模块组件，用户可以便捷地构建自定义的检测模型 + +- **支持多种检测任务** + + MMDetection 支持了各种不同的检测任务，包括**目标检测**，**实例分割**，**全景分割**，以及**半监督目标检测**。 + +- **速度快** + + 基本的框和 mask 操作都实现了 GPU 版本，训练速度比其他代码库更快或者相当，包括 [Detectron2](https://github.com/facebookresearch/detectron2), [maskrcnn-benchmark](https://github.com/facebookresearch/maskrcnn-benchmark) 和 [SimpleDet](https://github.com/TuSimple/simpledet)。 + +- **性能高** + + MMDetection 这个算法库源自于 COCO 2018 目标检测竞赛的冠军团队 *MMDet* 团队开发的代码，我们在之后持续进行了改进和提升。 + 新发布的 [RTMDet](configs/rtmdet) 还在实时实例分割和旋转目标检测任务中取得了最先进的成果，同时也在目标检测模型中取得了最佳的的参数量和精度平衡。 + +
    + +除了 MMDetection 之外，我们还开源了深度学习训练库 [MMEngine](https://github.com/open-mmlab/mmengine) 和计算机视觉基础库 [MMCV](https://github.com/open-mmlab/mmcv)，它们是 MMDetection 的主要依赖。 + +## 最新进展 + +💎 **我们已经发布了 MM-Grounding-DINO Swin-B 和 Swin-L 预训练权重，欢迎试用和反馈.** + +### 亮点 + +**v3.3.0** 版本已经在 2024.1.5 发布： + +**MM-Grounding-DINO: 轻松涨点，数据到评测全面开源** + +Grounding DINO 是一个统一了 2d 开放词汇目标检测和 Phrase Grounding 的检测预训练模型，应用广泛，但是其训练部分并未开源，为此提出了 MM-Grounding-DINO。其不仅作为 Grounding DINO 的开源复现版，MM-Grounding-DINO 基于重新构建的数据类型出发，在探索了不同数据集组合和初始化策略基础上实现了 Grounding DINO 的性能极大提升，并且从多个维度包括 OOD、REC、Phrase Grounding、OVD 和 Finetune 等方面进行评测，充分挖掘 Grounding 预训练优缺点，希望能为后续工作提供启发。 + +arxiv 技术报告：https://arxiv.org/abs/2401.02361 + +代码地址: [mm_grounding_dino/README.md](configs/mm_grounding_dino/README.md) + +
    + +
    + +我们很高兴向大家介绍我们在实时目标识别任务方面的最新成果 RTMDet，包含了一系列的全卷积单阶段检测模型。 RTMDet 不仅在从 tiny 到 extra-large 尺寸的目标检测模型上实现了最佳的参数量和精度的平衡，而且在实时实例分割和旋转目标检测任务上取得了最先进的成果。 更多细节请参阅[技术报告](https://arxiv.org/abs/2212.07784)。 预训练模型可以在[这里](configs/rtmdet)找到。 + +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/rtmdet-an-empirical-study-of-designing-real/real-time-instance-segmentation-on-mscoco)](https://paperswithcode.com/sota/real-time-instance-segmentation-on-mscoco?p=rtmdet-an-empirical-study-of-designing-real) +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/rtmdet-an-empirical-study-of-designing-real/object-detection-in-aerial-images-on-dota-1)](https://paperswithcode.com/sota/object-detection-in-aerial-images-on-dota-1?p=rtmdet-an-empirical-study-of-designing-real) +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/rtmdet-an-empirical-study-of-designing-real/object-detection-in-aerial-images-on-hrsc2016)](https://paperswithcode.com/sota/object-detection-in-aerial-images-on-hrsc2016?p=rtmdet-an-empirical-study-of-designing-real) + +| Task | Dataset | AP | FPS(TRT FP16 BS1 3090) | +| ------------------------ | ------- | ------------------------------------ | ---------------------- | +| Object Detection | COCO | 52.8 | 322 | +| Instance Segmentation | COCO | 44.6 | 188 | +| Rotated Object Detection | DOTA | 78.9(single-scale)/81.3(multi-scale) | 121 | + +
    + +
    + +## 安装 + +请参考[快速入门文档](https://mmdetection.readthedocs.io/zh_CN/latest/get_started.html)进行安装。 + +## 教程 + +请阅读[概述](https://mmdetection.readthedocs.io/zh_CN/latest/get_started.html)对 MMDetection 进行初步的了解。 + +为了帮助用户更进一步了解 MMDetection，我们准备了用户指南和进阶指南，请阅读我们的[文档](https://mmdetection.readthedocs.io/zh_CN/latest/)： + +- 用户指南 + +
    + + - [训练 & 测试](https://mmdetection.readthedocs.io/zh_CN/latest/user_guides/index.html#train-test) + - [学习配置文件](https://mmdetection.readthedocs.io/zh_CN/latest/user_guides/config.html) + - [使用已有模型在标准数据集上进行推理](https://mmdetection.readthedocs.io/en/latest/user_guides/inference.html) + - [数据集准备](https://mmdetection.readthedocs.io/zh_CN/latest/user_guides/dataset_prepare.html) + - [测试现有模型](https://mmdetection.readthedocs.io/zh_CN/latest/user_guides/test.html) + - [在标准数据集上训练预定义的模型](https://mmdetection.readthedocs.io/zh_CN/latest/user_guides/train.html) + - [在自定义数据集上进行训练](https://mmdetection.readthedocs.io/zh_CN/latest/user_guides/train.html#train-with-customized-datasets) + - [在标准数据集上训练自定义模型](https://mmdetection.readthedocs.io/zh_CN/latest/user_guides/new_model.html) + - [模型微调](https://mmdetection.readthedocs.io/zh_CN/latest/user_guides/finetune.html) + - [提交测试结果](https://mmdetection.readthedocs.io/zh_CN/latest/user_guides/test_results_submission.html) + - [权重初始化](https://mmdetection.readthedocs.io/zh_CN/latest/user_guides/init_cfg.html) + - [将单阶段检测器作为 RPN](https://mmdetection.readthedocs.io/zh_CN/latest/user_guides/single_stage_as_rpn.html) + - [半监督目标检测](https://mmdetection.readthedocs.io/zh_CN/latest/user_guides/semi_det.html) + - [实用工具](https://mmdetection.readthedocs.io/zh_CN/latest/user_guides/index.html#useful-tools) + +
    + +- 进阶指南 + +
    + + - [基础概念](https://mmdetection.readthedocs.io/zh_CN/latest/advanced_guides/index.html#basic-concepts) + - [组件定制](https://mmdetection.readthedocs.io/zh_CN/latest/advanced_guides/index.html#component-customization) + - [How to](https://mmdetection.readthedocs.io/zh_CN/latest/advanced_guides/index.html#how-to) + +
    + +我们提供了检测的 colab 教程 [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](demo/MMDet_Tutorial.ipynb) 和 实例分割的 colab 教程 [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](demo/MMDet_Tutorial.ipynb) + +同时，我们还提供了 [MMDetection 中文解读文案汇总](docs/zh_cn/article.md) + +若需要将2.x版本的代码迁移至新版，请参考[迁移文档](https://mmdetection.readthedocs.io/en/latest/migration.html)。 + +## 基准测试和模型库 + +测试结果和模型可以在[模型库](docs/zh_cn/model_zoo.md)中找到。 + +
    + 算法架构 +
    + + + + + + + + + + + + + + + + + +
    + Object Detection + + Instance Segmentation + + Panoptic Segmentation + + Other +
    + + + + + + + +
  • Contrastive Learning
    • + + +
  • Distillation
    • + +
  • Semi-Supervised Object Detection
    • + + +
    + +
    + 模块组件 +
    + + + + + + + + + + + + + + + + + +
    + Backbones + + Necks + + Loss + + Common +
    + + + + + + + +
    + +我们在[基于 MMDetection 的项目](./docs/zh_cn/notes/projects.md)中列举了一些其他的支持的算法。 + +## 常见问题 + +请参考 [FAQ](docs/zh_cn/notes/faq.md) 了解其他用户的常见问题。 + +## 贡献指南 + +我们感谢所有的贡献者为改进和提升 MMDetection 所作出的努力。我们将正在进行中的项目添加进了[GitHub Projects](https://github.com/open-mmlab/mmdetection/projects)页面，非常欢迎社区用户能参与进这些项目中来。请参考[贡献指南](.github/CONTRIBUTING.md)来了解参与项目贡献的相关指引。 + +## 致谢 + +MMDetection 是一款由来自不同高校和企业的研发人员共同参与贡献的开源项目。我们感谢所有为项目提供算法复现和新功能支持的贡献者，以及提供宝贵反馈的用户。 我们希望这个工具箱和基准测试可以为社区提供灵活的代码工具，供用户复现已有算法并开发自己的新模型，从而不断为开源社区提供贡献。 + +## 引用 + +如果你在研究中使用了本项目的代码或者性能基准，请参考如下 bibtex 引用 MMDetection。 + +``` +@article{mmdetection, + title = {{MMDetection}: Open MMLab Detection Toolbox and Benchmark}, + author = {Chen, Kai and Wang, Jiaqi and Pang, Jiangmiao and Cao, Yuhang and + Xiong, Yu and Li, Xiaoxiao and Sun, Shuyang and Feng, Wansen and + Liu, Ziwei and Xu, Jiarui and Zhang, Zheng and Cheng, Dazhi and + Zhu, Chenchen and Cheng, Tianheng and Zhao, Qijie and Li, Buyu and + Lu, Xin and Zhu, Rui and Wu, Yue and Dai, Jifeng and Wang, Jingdong + and Shi, Jianping and Ouyang, Wanli and Loy, Chen Change and Lin, Dahua}, + journal= {arXiv preprint arXiv:1906.07155}, + year={2019} +} +``` + +## 开源许可证 + +该项目采用 [Apache 2.0 开源许可证](LICENSE)。 + +## OpenMMLab 的其他项目 + +- [MMEngine](https://github.com/open-mmlab/mmengine): OpenMMLab 深度学习模型训练基础库 +- [MMCV](https://github.com/open-mmlab/mmcv): OpenMMLab 计算机视觉基础库 +- [MMPreTrain](https://github.com/open-mmlab/mmpretrain): OpenMMLab 深度学习预训练工具箱 +- [MMagic](https://github.com/open-mmlab/mmagic): OpenMMLab 新一代人工智能内容生成（AIGC）工具箱 +- [MMDetection](https://github.com/open-mmlab/mmdetection): OpenMMLab 目标检测工具箱 +- [MMDetection3D](https://github.com/open-mmlab/mmdetection3d): OpenMMLab 新一代通用 3D 目标检测平台 +- [MMRotate](https://github.com/open-mmlab/mmrotate): OpenMMLab 旋转框检测工具箱与测试基准 +- [MMYOLO](https://github.com/open-mmlab/mmyolo): OpenMMLab YOLO 系列工具箱与测试基准 +- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation): OpenMMLab 语义分割工具箱 +- [MMOCR](https://github.com/open-mmlab/mmocr): OpenMMLab 全流程文字检测识别理解工具包 +- [MMPose](https://github.com/open-mmlab/mmpose): OpenMMLab 姿态估计工具箱 +- [MMHuman3D](https://github.com/open-mmlab/mmhuman3d): OpenMMLab 人体参数化模型工具箱与测试基准 +- [MMSelfSup](https://github.com/open-mmlab/mmselfsup): OpenMMLab 自监督学习工具箱与测试基准 +- [MMRazor](https://github.com/open-mmlab/mmrazor): OpenMMLab 模型压缩工具箱与测试基准 +- [MMFewShot](https://github.com/open-mmlab/mmfewshot): OpenMMLab 少样本学习工具箱与测试基准 +- [MMAction2](https://github.com/open-mmlab/mmaction2): OpenMMLab 新一代视频理解工具箱 +- [MMTracking](https://github.com/open-mmlab/mmtracking): OpenMMLab 一体化视频目标感知平台 +- [MMFlow](https://github.com/open-mmlab/mmflow): OpenMMLab 光流估计工具箱与测试基准 +- [MMEditing](https://github.com/open-mmlab/mmediting): OpenMMLab 图像视频编辑工具箱 +- [MMGeneration](https://github.com/open-mmlab/mmgeneration): OpenMMLab 图片视频生成模型工具箱 +- [MMDeploy](https://github.com/open-mmlab/mmdeploy): OpenMMLab 模型部署框架 +- [MIM](https://github.com/open-mmlab/mim): OpenMMlab 项目、算法、模型的统一入口 +- [MMEval](https://github.com/open-mmlab/mmeval): 统一开放的跨框架算法评测库 +- [Playground](https://github.com/open-mmlab/playground): 收集和展示 OpenMMLab 相关的前沿、有趣的社区项目 + +## 欢迎加入 OpenMMLab 社区 + +扫描下方的二维码可关注 OpenMMLab 团队的 [知乎官方账号](https://www.zhihu.com/people/openmmlab)，扫描下方微信二维码添加喵喵好友，进入 MMDectection 微信交流社群。【加好友申请格式：研究方向+地区+学校/公司+姓名】 + +
    + +
    + +我们会在 OpenMMLab 社区为大家 + +- 📢 分享 AI 框架的前沿核心技术 +- 💻 解读 PyTorch 常用模块源码 +- 📰 发布 OpenMMLab 的相关新闻 +- 🚀 介绍 OpenMMLab 开发的前沿算法 +- 🏃 获取更高效的问题答疑和意见反馈 +- 🔥 提供与各行各业开发者充分交流的平台 + +干货满满 📘，等你来撩 💗，OpenMMLab 社区期待您的加入 👬 diff --git a/mmdetection/configs/_base_/datasets/ade20k_instance.py b/mmdetection/configs/_base_/datasets/ade20k_instance.py new file mode 100644 index 00000000..57f657aa --- /dev/null +++ b/mmdetection/configs/_base_/datasets/ade20k_instance.py @@ -0,0 +1,53 @@ +# dataset settings +dataset_type = 'ADE20KInstanceDataset' +data_root = 'data/ADEChallengeData2016/' + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/ADEChallengeData2016/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(2560, 640), keep_ratio=True), + # If you don't have a gt annotation, delete the pipeline + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='ade20k_instance_val.json', + data_prefix=dict(img='images/validation'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'ade20k_instance_val.json', + metric=['bbox', 'segm'], + format_only=False, + backend_args=backend_args) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/_base_/datasets/ade20k_panoptic.py b/mmdetection/configs/_base_/datasets/ade20k_panoptic.py new file mode 100644 index 00000000..7be5ddd7 --- /dev/null +++ b/mmdetection/configs/_base_/datasets/ade20k_panoptic.py @@ -0,0 +1,38 @@ +# dataset settings +dataset_type = 'ADE20KPanopticDataset' +data_root = 'data/ADEChallengeData2016/' + +backend_args = None + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(2560, 640), keep_ratio=True), + dict(type='LoadPanopticAnnotations', backend_args=backend_args), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +val_dataloader = dict( + batch_size=1, + num_workers=0, + persistent_workers=False, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='ade20k_panoptic_val.json', + data_prefix=dict(img='images/validation/', seg='ade20k_panoptic_val/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoPanopticMetric', + ann_file=data_root + 'ade20k_panoptic_val.json', + seg_prefix=data_root + 'ade20k_panoptic_val/', + backend_args=backend_args) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/_base_/datasets/ade20k_semantic.py b/mmdetection/configs/_base_/datasets/ade20k_semantic.py new file mode 100644 index 00000000..522a7757 --- /dev/null +++ b/mmdetection/configs/_base_/datasets/ade20k_semantic.py @@ -0,0 +1,48 @@ +dataset_type = 'ADE20KSegDataset' +data_root = 'data/ADEChallengeData2016/' + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/ADEChallengeData2016/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(2048, 512), keep_ratio=True), + dict( + type='LoadAnnotations', + with_bbox=False, + with_mask=False, + with_seg=True, + reduce_zero_label=True), + dict( + type='PackDetInputs', meta_keys=('img_path', 'ori_shape', 'img_shape')) +] + +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + data_prefix=dict( + img_path='images/validation', + seg_map_path='annotations/validation'), + pipeline=test_pipeline)) +test_dataloader = val_dataloader + +val_evaluator = dict(type='SemSegMetric', iou_metrics=['mIoU']) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/_base_/datasets/cityscapes_detection.py b/mmdetection/configs/_base_/datasets/cityscapes_detection.py new file mode 100644 index 00000000..caeba6bf --- /dev/null +++ b/mmdetection/configs/_base_/datasets/cityscapes_detection.py @@ -0,0 +1,84 @@ +# dataset settings +dataset_type = 'CityscapesDataset' +data_root = 'data/cityscapes/' + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/segmentation/cityscapes/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/segmentation/', +# 'data/': 's3://openmmlab/datasets/segmentation/' +# })) +backend_args = None + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomResize', + scale=[(2048, 800), (2048, 1024)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(2048, 1024), keep_ratio=True), + # If you don't have a gt annotation, delete the pipeline + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type='RepeatDataset', + times=8, + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instancesonly_filtered_gtFine_train.json', + data_prefix=dict(img='leftImg8bit/train/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args=backend_args))) + +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instancesonly_filtered_gtFine_val.json', + data_prefix=dict(img='leftImg8bit/val/'), + test_mode=True, + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=test_pipeline, + backend_args=backend_args)) + +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'annotations/instancesonly_filtered_gtFine_val.json', + metric='bbox', + backend_args=backend_args) + +test_evaluator = val_evaluator diff --git a/mmdetection/configs/_base_/datasets/cityscapes_instance.py b/mmdetection/configs/_base_/datasets/cityscapes_instance.py new file mode 100644 index 00000000..13640313 --- /dev/null +++ b/mmdetection/configs/_base_/datasets/cityscapes_instance.py @@ -0,0 +1,113 @@ +# dataset settings +dataset_type = 'CityscapesDataset' +data_root = 'data/cityscapes/' + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/segmentation/cityscapes/' + +# Method 2: Use backend_args, file_client_args in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/segmentation/', +# 'data/': 's3://openmmlab/datasets/segmentation/' +# })) +backend_args = None + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='RandomResize', + scale=[(2048, 800), (2048, 1024)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(2048, 1024), keep_ratio=True), + # If you don't have a gt annotation, delete the pipeline + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type='RepeatDataset', + times=8, + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instancesonly_filtered_gtFine_train.json', + data_prefix=dict(img='leftImg8bit/train/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args=backend_args))) + +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instancesonly_filtered_gtFine_val.json', + data_prefix=dict(img='leftImg8bit/val/'), + test_mode=True, + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=test_pipeline, + backend_args=backend_args)) + +test_dataloader = val_dataloader + +val_evaluator = [ + dict( + type='CocoMetric', + ann_file=data_root + + 'annotations/instancesonly_filtered_gtFine_val.json', + metric=['bbox', 'segm'], + backend_args=backend_args), + dict( + type='CityScapesMetric', + seg_prefix=data_root + 'gtFine/val', + outfile_prefix='./work_dirs/cityscapes_metric/instance', + backend_args=backend_args) +] + +test_evaluator = val_evaluator + +# inference on test dataset and +# format the output results for submission. +# test_dataloader = dict( +# batch_size=1, +# num_workers=2, +# persistent_workers=True, +# drop_last=False, +# sampler=dict(type='DefaultSampler', shuffle=False), +# dataset=dict( +# type=dataset_type, +# data_root=data_root, +# ann_file='annotations/instancesonly_filtered_gtFine_test.json', +# data_prefix=dict(img='leftImg8bit/test/'), +# test_mode=True, +# filter_cfg=dict(filter_empty_gt=True, min_size=32), +# pipeline=test_pipeline)) +# test_evaluator = dict( +# type='CityScapesMetric', +# format_only=True, +# outfile_prefix='./work_dirs/cityscapes_metric/test') diff --git a/mmdetection/configs/_base_/datasets/coco_caption.py b/mmdetection/configs/_base_/datasets/coco_caption.py new file mode 100644 index 00000000..a1bd8983 --- /dev/null +++ b/mmdetection/configs/_base_/datasets/coco_caption.py @@ -0,0 +1,60 @@ +# data settings + +dataset_type = 'CocoCaptionDataset' +data_root = 'data/coco/' + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/coco/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +test_pipeline = [ + dict( + type='LoadImageFromFile', + imdecode_backend='pillow', + backend_args=backend_args), + dict( + type='Resize', + scale=(224, 224), + interpolation='bicubic', + backend='pillow'), + dict(type='PackInputs', meta_keys=['image_id']), +] + +# ann_file download from +# train dataset: https://storage.googleapis.com/sfr-vision-language-research/datasets/coco_karpathy_train.json # noqa +# val dataset: https://storage.googleapis.com/sfr-vision-language-research/datasets/coco_karpathy_val.json # noqa +# test dataset: https://storage.googleapis.com/sfr-vision-language-research/datasets/coco_karpathy_test.json # noqa +# val evaluator: https://storage.googleapis.com/sfr-vision-language-research/datasets/coco_karpathy_val_gt.json # noqa +# test evaluator: https://storage.googleapis.com/sfr-vision-language-research/datasets/coco_karpathy_test_gt.json # noqa +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/coco_karpathy_val.json', + pipeline=test_pipeline, + )) + +val_evaluator = dict( + type='COCOCaptionMetric', + ann_file=data_root + 'annotations/coco_karpathy_val_gt.json', +) + +# # If you want standard test, please manually configure the test dataset +test_dataloader = val_dataloader +test_evaluator = val_evaluator diff --git a/mmdetection/configs/_base_/datasets/coco_detection.py b/mmdetection/configs/_base_/datasets/coco_detection.py new file mode 100644 index 00000000..fdf8dfad --- /dev/null +++ b/mmdetection/configs/_base_/datasets/coco_detection.py @@ -0,0 +1,95 @@ +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/coco/' + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/coco/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + # If you don't have a gt annotation, delete the pipeline + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args=backend_args)) +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'annotations/instances_val2017.json', + metric='bbox', + format_only=False, + backend_args=backend_args) +test_evaluator = val_evaluator + +# inference on test dataset and +# format the output results for submission. +# test_dataloader = dict( +# batch_size=1, +# num_workers=2, +# persistent_workers=True, +# drop_last=False, +# sampler=dict(type='DefaultSampler', shuffle=False), +# dataset=dict( +# type=dataset_type, +# data_root=data_root, +# ann_file=data_root + 'annotations/image_info_test-dev2017.json', +# data_prefix=dict(img='test2017/'), +# test_mode=True, +# pipeline=test_pipeline)) +# test_evaluator = dict( +# type='CocoMetric', +# metric='bbox', +# format_only=True, +# ann_file=data_root + 'annotations/image_info_test-dev2017.json', +# outfile_prefix='./work_dirs/coco_detection/test') diff --git a/mmdetection/configs/_base_/datasets/coco_instance.py b/mmdetection/configs/_base_/datasets/coco_instance.py new file mode 100644 index 00000000..e91cb354 --- /dev/null +++ b/mmdetection/configs/_base_/datasets/coco_instance.py @@ -0,0 +1,95 @@ +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/coco/' + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/coco/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + # If you don't have a gt annotation, delete the pipeline + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args=backend_args)) +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'annotations/instances_val2017.json', + metric=['bbox', 'segm'], + format_only=False, + backend_args=backend_args) +test_evaluator = val_evaluator + +# inference on test dataset and +# format the output results for submission. +# test_dataloader = dict( +# batch_size=1, +# num_workers=2, +# persistent_workers=True, +# drop_last=False, +# sampler=dict(type='DefaultSampler', shuffle=False), +# dataset=dict( +# type=dataset_type, +# data_root=data_root, +# ann_file=data_root + 'annotations/image_info_test-dev2017.json', +# data_prefix=dict(img='test2017/'), +# test_mode=True, +# pipeline=test_pipeline)) +# test_evaluator = dict( +# type='CocoMetric', +# metric=['bbox', 'segm'], +# format_only=True, +# ann_file=data_root + 'annotations/image_info_test-dev2017.json', +# outfile_prefix='./work_dirs/coco_instance/test') diff --git a/mmdetection/configs/_base_/datasets/coco_instance_semantic.py b/mmdetection/configs/_base_/datasets/coco_instance_semantic.py new file mode 100644 index 00000000..cc961863 --- /dev/null +++ b/mmdetection/configs/_base_/datasets/coco_instance_semantic.py @@ -0,0 +1,78 @@ +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/coco/' + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/coco/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict( + type='LoadAnnotations', with_bbox=True, with_mask=True, with_seg=True), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + # If you don't have a gt annotation, delete the pipeline + dict( + type='LoadAnnotations', with_bbox=True, with_mask=True, with_seg=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/', seg='stuffthingmaps/train2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args=backend_args)) + +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) + +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'annotations/instances_val2017.json', + metric=['bbox', 'segm'], + format_only=False, + backend_args=backend_args) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/_base_/datasets/coco_panoptic.py b/mmdetection/configs/_base_/datasets/coco_panoptic.py new file mode 100644 index 00000000..0b95b619 --- /dev/null +++ b/mmdetection/configs/_base_/datasets/coco_panoptic.py @@ -0,0 +1,94 @@ +# dataset settings +dataset_type = 'CocoPanopticDataset' +data_root = 'data/coco/' + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/coco/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadPanopticAnnotations', backend_args=backend_args), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='LoadPanopticAnnotations', backend_args=backend_args), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/panoptic_train2017.json', + data_prefix=dict( + img='train2017/', seg='annotations/panoptic_train2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args=backend_args)) +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/panoptic_val2017.json', + data_prefix=dict(img='val2017/', seg='annotations/panoptic_val2017/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoPanopticMetric', + ann_file=data_root + 'annotations/panoptic_val2017.json', + seg_prefix=data_root + 'annotations/panoptic_val2017/', + backend_args=backend_args) +test_evaluator = val_evaluator + +# inference on test dataset and +# format the output results for submission. +# test_dataloader = dict( +# batch_size=1, +# num_workers=1, +# persistent_workers=True, +# drop_last=False, +# sampler=dict(type='DefaultSampler', shuffle=False), +# dataset=dict( +# type=dataset_type, +# data_root=data_root, +# ann_file='annotations/panoptic_image_info_test-dev2017.json', +# data_prefix=dict(img='test2017/'), +# test_mode=True, +# pipeline=test_pipeline)) +# test_evaluator = dict( +# type='CocoPanopticMetric', +# format_only=True, +# ann_file=data_root + 'annotations/panoptic_image_info_test-dev2017.json', +# outfile_prefix='./work_dirs/coco_panoptic/test') diff --git a/mmdetection/configs/_base_/datasets/coco_semantic.py b/mmdetection/configs/_base_/datasets/coco_semantic.py new file mode 100644 index 00000000..944bbbae --- /dev/null +++ b/mmdetection/configs/_base_/datasets/coco_semantic.py @@ -0,0 +1,78 @@ +# dataset settings +dataset_type = 'CocoSegDataset' +data_root = 'data/coco/' + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/coco/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict( + type='LoadAnnotations', + with_bbox=False, + with_label=False, + with_seg=True), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict( + type='LoadAnnotations', + with_bbox=False, + with_label=False, + with_seg=True), + dict( + type='PackDetInputs', + meta_keys=('img_path', 'ori_shape', 'img_shape', 'scale_factor')) +] + +# For stuffthingmaps_semseg, please refer to +# `docs/en/user_guides/dataset_prepare.md` +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type=dataset_type, + data_root=data_root, + data_prefix=dict( + img_path='train2017/', + seg_map_path='stuffthingmaps_semseg/train2017/'), + pipeline=train_pipeline)) + +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + data_prefix=dict( + img_path='val2017/', + seg_map_path='stuffthingmaps_semseg/val2017/'), + pipeline=test_pipeline)) + +test_dataloader = val_dataloader + +val_evaluator = dict(type='SemSegMetric', iou_metrics=['mIoU']) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/_base_/datasets/deepfashion.py b/mmdetection/configs/_base_/datasets/deepfashion.py new file mode 100644 index 00000000..a93dc715 --- /dev/null +++ b/mmdetection/configs/_base_/datasets/deepfashion.py @@ -0,0 +1,95 @@ +# dataset settings +dataset_type = 'DeepFashionDataset' +data_root = 'data/DeepFashion/In-shop/' + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/coco/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict(type='Resize', scale=(750, 1101), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(750, 1101), keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type='RepeatDataset', + times=2, + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='Anno/segmentation/DeepFashion_segmentation_train.json', + data_prefix=dict(img='Img/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args=backend_args))) +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='Anno/segmentation/DeepFashion_segmentation_query.json', + data_prefix=dict(img='Img/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='Anno/segmentation/DeepFashion_segmentation_gallery.json', + data_prefix=dict(img='Img/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + + 'Anno/segmentation/DeepFashion_segmentation_query.json', + metric=['bbox', 'segm'], + format_only=False, + backend_args=backend_args) +test_evaluator = dict( + type='CocoMetric', + ann_file=data_root + + 'Anno/segmentation/DeepFashion_segmentation_gallery.json', + metric=['bbox', 'segm'], + format_only=False, + backend_args=backend_args) diff --git a/mmdetection/configs/_base_/datasets/dsdl.py b/mmdetection/configs/_base_/datasets/dsdl.py new file mode 100644 index 00000000..1f19e5e4 --- /dev/null +++ b/mmdetection/configs/_base_/datasets/dsdl.py @@ -0,0 +1,62 @@ +dataset_type = 'DSDLDetDataset' +data_root = 'path to dataset folder' +train_ann = 'path to train yaml file' +val_ann = 'path to val yaml file' + +backend_args = None +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': "s3://open_data/", +# 'data/': "s3://open_data/" +# })) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + # If you don't have a gt annotation, delete the pipeline + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'instances')) +] + +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file=train_ann, + filter_cfg=dict(filter_empty_gt=True, min_size=32, bbox_min_size=32), + pipeline=train_pipeline)) + +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file=val_ann, + test_mode=True, + pipeline=test_pipeline)) + +test_dataloader = val_dataloader + +val_evaluator = dict(type='CocoMetric', metric='bbox') +# val_evaluator = dict(type='VOCMetric', metric='mAP', eval_mode='11points') +test_evaluator = val_evaluator diff --git a/mmdetection/configs/_base_/datasets/isaid_instance.py b/mmdetection/configs/_base_/datasets/isaid_instance.py new file mode 100644 index 00000000..09ddcab0 --- /dev/null +++ b/mmdetection/configs/_base_/datasets/isaid_instance.py @@ -0,0 +1,59 @@ +# dataset settings +dataset_type = 'iSAIDDataset' +data_root = 'data/iSAID/' +backend_args = None + +# Please see `projects/iSAID/README.md` for data preparation +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict(type='Resize', scale=(800, 800), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(800, 800), keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='train/instancesonly_filtered_train.json', + data_prefix=dict(img='train/images/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args=backend_args)) +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='val/instancesonly_filtered_val.json', + data_prefix=dict(img='val/images/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'val/instancesonly_filtered_val.json', + metric=['bbox', 'segm'], + format_only=False, + backend_args=backend_args) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/_base_/datasets/lvis_v0.5_instance.py b/mmdetection/configs/_base_/datasets/lvis_v0.5_instance.py new file mode 100644 index 00000000..d0ca44ef --- /dev/null +++ b/mmdetection/configs/_base_/datasets/lvis_v0.5_instance.py @@ -0,0 +1,79 @@ +# dataset settings +dataset_type = 'LVISV05Dataset' +data_root = 'data/lvis_v0.5/' + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/lvis_v0.5/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736), + (1333, 768), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type='ClassBalancedDataset', + oversample_thr=1e-3, + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/lvis_v0.5_train.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args=backend_args))) +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/lvis_v0.5_val.json', + data_prefix=dict(img='val2017/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='LVISMetric', + ann_file=data_root + 'annotations/lvis_v0.5_val.json', + metric=['bbox', 'segm'], + backend_args=backend_args) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/_base_/datasets/lvis_v1_instance.py b/mmdetection/configs/_base_/datasets/lvis_v1_instance.py new file mode 100644 index 00000000..0413f370 --- /dev/null +++ b/mmdetection/configs/_base_/datasets/lvis_v1_instance.py @@ -0,0 +1,22 @@ +# dataset settings +_base_ = 'lvis_v0.5_instance.py' +dataset_type = 'LVISV1Dataset' +data_root = 'data/lvis_v1/' + +train_dataloader = dict( + dataset=dict( + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/lvis_v1_train.json', + data_prefix=dict(img='')))) +val_dataloader = dict( + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/lvis_v1_val.json', + data_prefix=dict(img=''))) +test_dataloader = val_dataloader + +val_evaluator = dict(ann_file=data_root + 'annotations/lvis_v1_val.json') +test_evaluator = val_evaluator diff --git a/mmdetection/configs/_base_/datasets/mot_challenge.py b/mmdetection/configs/_base_/datasets/mot_challenge.py new file mode 100644 index 00000000..ce2828ef --- /dev/null +++ b/mmdetection/configs/_base_/datasets/mot_challenge.py @@ -0,0 +1,90 @@ +# dataset settings +dataset_type = 'MOTChallengeDataset' +data_root = 'data/MOT17/' +img_scale = (1088, 1088) + +backend_args = None +# data pipeline +train_pipeline = [ + dict( + type='UniformRefFrameSample', + num_ref_imgs=1, + frame_range=10, + filter_key_img=True), + dict( + type='TransformBroadcaster', + share_random_params=True, + transforms=[ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadTrackAnnotations'), + dict( + type='RandomResize', + scale=img_scale, + ratio_range=(0.8, 1.2), + keep_ratio=True, + clip_object_border=False), + dict(type='PhotoMetricDistortion') + ]), + dict( + type='TransformBroadcaster', + # different cropped positions for different frames + share_random_params=False, + transforms=[ + dict( + type='RandomCrop', crop_size=img_scale, bbox_clip_border=False) + ]), + dict( + type='TransformBroadcaster', + share_random_params=True, + transforms=[ + dict(type='RandomFlip', prob=0.5), + ]), + dict(type='PackTrackInputs') +] + +test_pipeline = [ + dict( + type='TransformBroadcaster', + transforms=[ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=img_scale, keep_ratio=True), + dict(type='LoadTrackAnnotations') + ]), + dict(type='PackTrackInputs') +] + +# dataloader +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + sampler=dict(type='TrackImgSampler'), # image-based sampling + dataset=dict( + type=dataset_type, + data_root=data_root, + visibility_thr=-1, + ann_file='annotations/half-train_cocoformat.json', + data_prefix=dict(img_path='train'), + metainfo=dict(classes=('pedestrian', )), + pipeline=train_pipeline)) +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + # Now we support two ways to test, image_based and video_based + # if you want to use video_based sampling, you can use as follows + # sampler=dict(type='DefaultSampler', shuffle=False, round_up=False), + sampler=dict(type='TrackImgSampler'), # image-based sampling + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/half-val_cocoformat.json', + data_prefix=dict(img_path='train'), + test_mode=True, + pipeline=test_pipeline)) +test_dataloader = val_dataloader + +# evaluator +val_evaluator = dict( + type='MOTChallengeMetric', metric=['HOTA', 'CLEAR', 'Identity']) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/_base_/datasets/mot_challenge_det.py b/mmdetection/configs/_base_/datasets/mot_challenge_det.py new file mode 100644 index 00000000..a988572c --- /dev/null +++ b/mmdetection/configs/_base_/datasets/mot_challenge_det.py @@ -0,0 +1,66 @@ +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/MOT17/' + +backend_args = None +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args, to_float32=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomResize', + scale=(1088, 1088), + ratio_range=(0.8, 1.2), + keep_ratio=True, + clip_object_border=False), + dict(type='PhotoMetricDistortion'), + dict(type='RandomCrop', crop_size=(1088, 1088), bbox_clip_border=False), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1088, 1088), keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/half-train_cocoformat.json', + data_prefix=dict(img='train/'), + metainfo=dict(classes=('pedestrian', )), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline)) +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/half-val_cocoformat.json', + data_prefix=dict(img='train/'), + metainfo=dict(classes=('pedestrian', )), + test_mode=True, + pipeline=test_pipeline)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'annotations/half-val_cocoformat.json', + metric='bbox', + format_only=False) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/_base_/datasets/mot_challenge_reid.py b/mmdetection/configs/_base_/datasets/mot_challenge_reid.py new file mode 100644 index 00000000..57a95b53 --- /dev/null +++ b/mmdetection/configs/_base_/datasets/mot_challenge_reid.py @@ -0,0 +1,61 @@ +# dataset settings +dataset_type = 'ReIDDataset' +data_root = 'data/MOT17/' + +backend_args = None +# data pipeline +train_pipeline = [ + dict( + type='TransformBroadcaster', + share_random_params=False, + transforms=[ + dict( + type='LoadImageFromFile', + backend_args=backend_args, + to_float32=True), + dict( + type='Resize', + scale=(128, 256), + keep_ratio=False, + clip_object_border=False), + dict(type='RandomFlip', prob=0.5, direction='horizontal'), + ]), + dict(type='PackReIDInputs', meta_keys=('flip', 'flip_direction')) +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args, to_float32=True), + dict(type='Resize', scale=(128, 256), keep_ratio=False), + dict(type='PackReIDInputs') +] + +# dataloader +train_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + dataset=dict( + type=dataset_type, + data_root=data_root, + triplet_sampler=dict(num_ids=8, ins_per_id=4), + data_prefix=dict(img_path='reid/imgs'), + ann_file='reid/meta/train_80.txt', + pipeline=train_pipeline)) +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + triplet_sampler=None, + data_prefix=dict(img_path='reid/imgs'), + ann_file='reid/meta/val_20.txt', + pipeline=test_pipeline)) +test_dataloader = val_dataloader + +# evaluator +val_evaluator = dict(type='ReIDMetrics', metric=['mAP', 'CMC']) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/_base_/datasets/objects365v1_detection.py b/mmdetection/configs/_base_/datasets/objects365v1_detection.py new file mode 100644 index 00000000..ee398698 --- /dev/null +++ b/mmdetection/configs/_base_/datasets/objects365v1_detection.py @@ -0,0 +1,74 @@ +# dataset settings +dataset_type = 'Objects365V1Dataset' +data_root = 'data/Objects365/Obj365_v1/' + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/coco/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + # If you don't have a gt annotation, delete the pipeline + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/objects365_train.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args=backend_args)) +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/objects365_val.json', + data_prefix=dict(img='val/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'annotations/objects365_val.json', + metric='bbox', + sort_categories=True, + format_only=False, + backend_args=backend_args) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/_base_/datasets/objects365v2_detection.py b/mmdetection/configs/_base_/datasets/objects365v2_detection.py new file mode 100644 index 00000000..b25a7ba9 --- /dev/null +++ b/mmdetection/configs/_base_/datasets/objects365v2_detection.py @@ -0,0 +1,73 @@ +# dataset settings +dataset_type = 'Objects365V2Dataset' +data_root = 'data/Objects365/Obj365_v2/' + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/coco/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + # If you don't have a gt annotation, delete the pipeline + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/zhiyuan_objv2_train.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args=backend_args)) +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/zhiyuan_objv2_val.json', + data_prefix=dict(img='val/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'annotations/zhiyuan_objv2_val.json', + metric='bbox', + format_only=False, + backend_args=backend_args) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/_base_/datasets/openimages_detection.py b/mmdetection/configs/_base_/datasets/openimages_detection.py new file mode 100644 index 00000000..129661b4 --- /dev/null +++ b/mmdetection/configs/_base_/datasets/openimages_detection.py @@ -0,0 +1,81 @@ +# dataset settings +dataset_type = 'OpenImagesDataset' +data_root = 'data/OpenImages/' + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/coco/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='Resize', scale=(1024, 800), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1024, 800), keep_ratio=True), + # avoid bboxes being resized + dict(type='LoadAnnotations', with_bbox=True), + # TODO: find a better way to collect image_level_labels + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'instances', 'image_level_labels')) +] + +train_dataloader = dict( + batch_size=2, + num_workers=0, # workers_per_gpu > 0 may occur out of memory + persistent_workers=False, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/oidv6-train-annotations-bbox.csv', + data_prefix=dict(img='OpenImages/train/'), + label_file='annotations/class-descriptions-boxable.csv', + hierarchy_file='annotations/bbox_labels_600_hierarchy.json', + meta_file='annotations/train-image-metas.pkl', + pipeline=train_pipeline, + backend_args=backend_args)) +val_dataloader = dict( + batch_size=1, + num_workers=0, + persistent_workers=False, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/validation-annotations-bbox.csv', + data_prefix=dict(img='OpenImages/validation/'), + label_file='annotations/class-descriptions-boxable.csv', + hierarchy_file='annotations/bbox_labels_600_hierarchy.json', + meta_file='annotations/validation-image-metas.pkl', + image_level_ann_file='annotations/validation-' + 'annotations-human-imagelabels-boxable.csv', + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='OpenImagesMetric', + iou_thrs=0.5, + ioa_thrs=0.5, + use_group_of=True, + get_supercategory=True) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/_base_/datasets/refcoco+.py b/mmdetection/configs/_base_/datasets/refcoco+.py new file mode 100644 index 00000000..ae0278dd --- /dev/null +++ b/mmdetection/configs/_base_/datasets/refcoco+.py @@ -0,0 +1,55 @@ +# dataset settings +dataset_type = 'RefCocoDataset' +data_root = 'data/coco/' + +backend_args = None + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict( + type='LoadAnnotations', + with_mask=True, + with_bbox=False, + with_seg=False, + with_label=False), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'gt_masks', 'text')) +] + +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + data_prefix=dict(img_path='train2014/'), + ann_file='refcoco+/instances.json', + split_file='refcoco+/refs(unc).p', + split='val', + text_mode='select_first', + pipeline=test_pipeline)) + +test_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + data_prefix=dict(img_path='train2014/'), + ann_file='refcoco+/instances.json', + split_file='refcoco+/refs(unc).p', + split='testA', # or 'testB' + text_mode='select_first', + pipeline=test_pipeline)) + +val_evaluator = dict(type='RefSegMetric', metric=['cIoU', 'mIoU']) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/_base_/datasets/refcoco.py b/mmdetection/configs/_base_/datasets/refcoco.py new file mode 100644 index 00000000..7b6caefa --- /dev/null +++ b/mmdetection/configs/_base_/datasets/refcoco.py @@ -0,0 +1,55 @@ +# dataset settings +dataset_type = 'RefCocoDataset' +data_root = 'data/coco/' + +backend_args = None + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict( + type='LoadAnnotations', + with_mask=True, + with_bbox=False, + with_seg=False, + with_label=False), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'gt_masks', 'text')) +] + +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + data_prefix=dict(img_path='train2014/'), + ann_file='refcoco/instances.json', + split_file='refcoco/refs(unc).p', + split='val', + text_mode='select_first', + pipeline=test_pipeline)) + +test_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + data_prefix=dict(img_path='train2014/'), + ann_file='refcoco/instances.json', + split_file='refcoco/refs(unc).p', + split='testA', # or 'testB' + text_mode='select_first', + pipeline=test_pipeline)) + +val_evaluator = dict(type='RefSegMetric', metric=['cIoU', 'mIoU']) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/_base_/datasets/refcocog.py b/mmdetection/configs/_base_/datasets/refcocog.py new file mode 100644 index 00000000..19dbeef1 --- /dev/null +++ b/mmdetection/configs/_base_/datasets/refcocog.py @@ -0,0 +1,55 @@ +# dataset settings +dataset_type = 'RefCocoDataset' +data_root = 'data/coco/' + +backend_args = None + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict( + type='LoadAnnotations', + with_mask=True, + with_bbox=False, + with_seg=False, + with_label=False), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'gt_masks', 'text')) +] + +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + data_prefix=dict(img_path='train2014/'), + ann_file='refcocog/instances.json', + split_file='refcocog/refs(umd).p', + split='val', + text_mode='select_first', + pipeline=test_pipeline)) + +test_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + data_prefix=dict(img_path='train2014/'), + ann_file='refcocog/instances.json', + split_file='refcocog/refs(umd).p', + split='test', + text_mode='select_first', + pipeline=test_pipeline)) + +val_evaluator = dict(type='RefSegMetric', metric=['cIoU', 'mIoU']) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/_base_/datasets/semi_coco_detection.py b/mmdetection/configs/_base_/datasets/semi_coco_detection.py new file mode 100644 index 00000000..694f25f8 --- /dev/null +++ b/mmdetection/configs/_base_/datasets/semi_coco_detection.py @@ -0,0 +1,178 @@ +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/coco/' + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/coco/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +color_space = [ + [dict(type='ColorTransform')], + [dict(type='AutoContrast')], + [dict(type='Equalize')], + [dict(type='Sharpness')], + [dict(type='Posterize')], + [dict(type='Solarize')], + [dict(type='Color')], + [dict(type='Contrast')], + [dict(type='Brightness')], +] + +geometric = [ + [dict(type='Rotate')], + [dict(type='ShearX')], + [dict(type='ShearY')], + [dict(type='TranslateX')], + [dict(type='TranslateY')], +] + +scale = [(1333, 400), (1333, 1200)] + +branch_field = ['sup', 'unsup_teacher', 'unsup_student'] +# pipeline used to augment labeled data, +# which will be sent to student model for supervised training. +sup_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomResize', scale=scale, keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='RandAugment', aug_space=color_space, aug_num=1), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict( + type='MultiBranch', + branch_field=branch_field, + sup=dict(type='PackDetInputs')) +] + +# pipeline used to augment unlabeled data weakly, +# which will be sent to teacher model for predicting pseudo instances. +weak_pipeline = [ + dict(type='RandomResize', scale=scale, keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', + 'homography_matrix')), +] + +# pipeline used to augment unlabeled data strongly, +# which will be sent to student model for unsupervised training. +strong_pipeline = [ + dict(type='RandomResize', scale=scale, keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomOrder', + transforms=[ + dict(type='RandAugment', aug_space=color_space, aug_num=1), + dict(type='RandAugment', aug_space=geometric, aug_num=1), + ]), + dict(type='RandomErasing', n_patches=(1, 5), ratio=(0, 0.2)), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', + 'homography_matrix')), +] + +# pipeline used to augment unlabeled data into different views +unsup_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadEmptyAnnotations'), + dict( + type='MultiBranch', + branch_field=branch_field, + unsup_teacher=weak_pipeline, + unsup_student=strong_pipeline, + ) +] + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +batch_size = 5 +num_workers = 5 +# There are two common semi-supervised learning settings on the coco dataset： +# (1) Divide the train2017 into labeled and unlabeled datasets +# by a fixed percentage, such as 1%, 2%, 5% and 10%. +# The format of labeled_ann_file and unlabeled_ann_file are +# instances_train2017.{fold}@{percent}.json, and +# instances_train2017.{fold}@{percent}-unlabeled.json +# `fold` is used for cross-validation, and `percent` represents +# the proportion of labeled data in the train2017. +# (2) Choose the train2017 as the labeled dataset +# and unlabeled2017 as the unlabeled dataset. +# The labeled_ann_file and unlabeled_ann_file are +# instances_train2017.json and image_info_unlabeled2017.json +# We use this configuration by default. +labeled_dataset = dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=sup_pipeline, + backend_args=backend_args) + +unlabeled_dataset = dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_unlabeled2017.json', + data_prefix=dict(img='unlabeled2017/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=unsup_pipeline, + backend_args=backend_args) + +train_dataloader = dict( + batch_size=batch_size, + num_workers=num_workers, + persistent_workers=True, + sampler=dict( + type='GroupMultiSourceSampler', + batch_size=batch_size, + source_ratio=[1, 4]), + dataset=dict( + type='ConcatDataset', datasets=[labeled_dataset, unlabeled_dataset])) + +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) + +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'annotations/instances_val2017.json', + metric='bbox', + format_only=False, + backend_args=backend_args) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/_base_/datasets/v3det.py b/mmdetection/configs/_base_/datasets/v3det.py new file mode 100644 index 00000000..38ccbf86 --- /dev/null +++ b/mmdetection/configs/_base_/datasets/v3det.py @@ -0,0 +1,69 @@ +# dataset settings +dataset_type = 'V3DetDataset' +data_root = 'data/V3Det/' + +backend_args = None + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736), + (1333, 768), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + # If you don't have a gt annotation, delete the pipeline + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type='ClassBalancedDataset', + oversample_thr=1e-3, + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/v3det_2023_v1_train.json', + data_prefix=dict(img=''), + filter_cfg=dict(filter_empty_gt=True, min_size=4), + pipeline=train_pipeline, + backend_args=backend_args))) +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/v3det_2023_v1_val.json', + data_prefix=dict(img=''), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'annotations/v3det_2023_v1_val.json', + metric='bbox', + format_only=False, + backend_args=backend_args, + use_mp_eval=True, + proposal_nums=[300]) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/_base_/datasets/voc0712.py b/mmdetection/configs/_base_/datasets/voc0712.py new file mode 100644 index 00000000..47f5e656 --- /dev/null +++ b/mmdetection/configs/_base_/datasets/voc0712.py @@ -0,0 +1,92 @@ +# dataset settings +dataset_type = 'VOCDataset' +data_root = 'data/VOCdevkit/' + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically Infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/segmentation/VOCdevkit/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/segmentation/', +# 'data/': 's3://openmmlab/datasets/segmentation/' +# })) +backend_args = None + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='Resize', scale=(1000, 600), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1000, 600), keep_ratio=True), + # avoid bboxes being resized + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type='RepeatDataset', + times=3, + dataset=dict( + type='ConcatDataset', + # VOCDataset will add different `dataset_type` in dataset.metainfo, + # which will get error if using ConcatDataset. Adding + # `ignore_keys` can avoid this error. + ignore_keys=['dataset_type'], + datasets=[ + dict( + type=dataset_type, + data_root=data_root, + ann_file='VOC2007/ImageSets/Main/trainval.txt', + data_prefix=dict(sub_data_root='VOC2007/'), + filter_cfg=dict( + filter_empty_gt=True, min_size=32, bbox_min_size=32), + pipeline=train_pipeline, + backend_args=backend_args), + dict( + type=dataset_type, + data_root=data_root, + ann_file='VOC2012/ImageSets/Main/trainval.txt', + data_prefix=dict(sub_data_root='VOC2012/'), + filter_cfg=dict( + filter_empty_gt=True, min_size=32, bbox_min_size=32), + pipeline=train_pipeline, + backend_args=backend_args) + ]))) + +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='VOC2007/ImageSets/Main/test.txt', + data_prefix=dict(sub_data_root='VOC2007/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = val_dataloader + +# Pascal VOC2007 uses `11points` as default evaluate mode, while PASCAL +# VOC2012 defaults to use 'area'. +val_evaluator = dict(type='VOCMetric', metric='mAP', eval_mode='11points') +test_evaluator = val_evaluator diff --git a/mmdetection/configs/_base_/datasets/wider_face.py b/mmdetection/configs/_base_/datasets/wider_face.py new file mode 100644 index 00000000..7042bc46 --- /dev/null +++ b/mmdetection/configs/_base_/datasets/wider_face.py @@ -0,0 +1,73 @@ +# dataset settings +dataset_type = 'WIDERFaceDataset' +data_root = 'data/WIDERFace/' +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/cityscapes/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +img_scale = (640, 640) # VGA resolution + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='Resize', scale=img_scale, keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=img_scale, keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='train.txt', + data_prefix=dict(img='WIDER_train'), + filter_cfg=dict(filter_empty_gt=True, bbox_min_size=17, min_size=32), + pipeline=train_pipeline)) + +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='val.txt', + data_prefix=dict(img='WIDER_val'), + test_mode=True, + pipeline=test_pipeline)) +test_dataloader = val_dataloader + +val_evaluator = dict( + # TODO: support WiderFace-Evaluation for easy, medium, hard cases + type='VOCMetric', + metric='mAP', + eval_mode='11points') +test_evaluator = val_evaluator diff --git a/mmdetection/configs/_base_/datasets/youtube_vis.py b/mmdetection/configs/_base_/datasets/youtube_vis.py new file mode 100644 index 00000000..ece07cc3 --- /dev/null +++ b/mmdetection/configs/_base_/datasets/youtube_vis.py @@ -0,0 +1,66 @@ +dataset_type = 'YouTubeVISDataset' +data_root = 'data/youtube_vis_2019/' +dataset_version = data_root[-5:-1] # 2019 or 2021 + +backend_args = None + +# dataset settings +train_pipeline = [ + dict( + type='UniformRefFrameSample', + num_ref_imgs=1, + frame_range=100, + filter_key_img=True), + dict( + type='TransformBroadcaster', + share_random_params=True, + transforms=[ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadTrackAnnotations', with_mask=True), + dict(type='Resize', scale=(640, 360), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + ]), + dict(type='PackTrackInputs') +] + +test_pipeline = [ + dict( + type='TransformBroadcaster', + transforms=[ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(640, 360), keep_ratio=True), + dict(type='LoadTrackAnnotations', with_mask=True), + ]), + dict(type='PackTrackInputs') +] + +# dataloader +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + # sampler=dict(type='TrackImgSampler'), # image-based sampling + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='TrackAspectRatioBatchSampler'), + dataset=dict( + type=dataset_type, + data_root=data_root, + dataset_version=dataset_version, + ann_file='annotations/youtube_vis_2019_train.json', + data_prefix=dict(img_path='train/JPEGImages'), + pipeline=train_pipeline)) +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False, round_up=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + dataset_version=dataset_version, + ann_file='annotations/youtube_vis_2019_valid.json', + data_prefix=dict(img_path='valid/JPEGImages'), + test_mode=True, + pipeline=test_pipeline)) +test_dataloader = val_dataloader diff --git a/mmdetection/configs/_base_/default_runtime.py b/mmdetection/configs/_base_/default_runtime.py new file mode 100644 index 00000000..870e5614 --- /dev/null +++ b/mmdetection/configs/_base_/default_runtime.py @@ -0,0 +1,24 @@ +default_scope = 'mmdet' + +default_hooks = dict( + timer=dict(type='IterTimerHook'), + logger=dict(type='LoggerHook', interval=50), + param_scheduler=dict(type='ParamSchedulerHook'), + checkpoint=dict(type='CheckpointHook', interval=1), + sampler_seed=dict(type='DistSamplerSeedHook'), + visualization=dict(type='DetVisualizationHook')) + +env_cfg = dict( + cudnn_benchmark=False, + mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0), + dist_cfg=dict(backend='nccl'), +) + +vis_backends = [dict(type='LocalVisBackend')] +visualizer = dict( + type='DetLocalVisualizer', vis_backends=vis_backends, name='visualizer') +log_processor = dict(type='LogProcessor', window_size=50, by_epoch=True) + +log_level = 'INFO' +load_from = None +resume = False diff --git a/mmdetection/configs/_base_/models/cascade-mask-rcnn_r50_fpn.py b/mmdetection/configs/_base_/models/cascade-mask-rcnn_r50_fpn.py new file mode 100644 index 00000000..c5167f7a --- /dev/null +++ b/mmdetection/configs/_base_/models/cascade-mask-rcnn_r50_fpn.py @@ -0,0 +1,203 @@ +# model settings +model = dict( + type='CascadeRCNN', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_mask=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + num_outs=5), + rpn_head=dict( + type='RPNHead', + in_channels=256, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + scales=[8], + ratios=[0.5, 1.0, 2.0], + strides=[4, 8, 16, 32, 64]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[1.0, 1.0, 1.0, 1.0]), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=1.0)), + roi_head=dict( + type='CascadeRoIHead', + num_stages=3, + stage_loss_weights=[1, 0.5, 0.25], + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + bbox_head=[ + dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, + loss_weight=1.0)), + dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.05, 0.05, 0.1, 0.1]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, + loss_weight=1.0)), + dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.033, 0.033, 0.067, 0.067]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0)) + ], + mask_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + mask_head=dict( + type='FCNMaskHead', + num_convs=4, + in_channels=256, + conv_out_channels=256, + num_classes=80, + loss_mask=dict( + type='CrossEntropyLoss', use_mask=True, loss_weight=1.0))), + # model training and testing settings + train_cfg=dict( + rpn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.3, + min_pos_iou=0.3, + match_low_quality=True, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=0, + pos_weight=-1, + debug=False), + rpn_proposal=dict( + nms_pre=2000, + max_per_img=2000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=[ + dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0.5, + match_low_quality=False, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + mask_size=28, + pos_weight=-1, + debug=False), + dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.6, + neg_iou_thr=0.6, + min_pos_iou=0.6, + match_low_quality=False, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + mask_size=28, + pos_weight=-1, + debug=False), + dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.7, + min_pos_iou=0.7, + match_low_quality=False, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + mask_size=28, + pos_weight=-1, + debug=False) + ]), + test_cfg=dict( + rpn=dict( + nms_pre=1000, + max_per_img=1000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=dict( + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.5), + max_per_img=100, + mask_thr_binary=0.5))) diff --git a/mmdetection/configs/_base_/models/cascade-rcnn_r50_fpn.py b/mmdetection/configs/_base_/models/cascade-rcnn_r50_fpn.py new file mode 100644 index 00000000..50c57f01 --- /dev/null +++ b/mmdetection/configs/_base_/models/cascade-rcnn_r50_fpn.py @@ -0,0 +1,185 @@ +# model settings +model = dict( + type='CascadeRCNN', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + num_outs=5), + rpn_head=dict( + type='RPNHead', + in_channels=256, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + scales=[8], + ratios=[0.5, 1.0, 2.0], + strides=[4, 8, 16, 32, 64]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[1.0, 1.0, 1.0, 1.0]), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=1.0)), + roi_head=dict( + type='CascadeRoIHead', + num_stages=3, + stage_loss_weights=[1, 0.5, 0.25], + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + bbox_head=[ + dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, + loss_weight=1.0)), + dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.05, 0.05, 0.1, 0.1]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, + loss_weight=1.0)), + dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.033, 0.033, 0.067, 0.067]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0)) + ]), + # model training and testing settings + train_cfg=dict( + rpn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.3, + min_pos_iou=0.3, + match_low_quality=True, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=0, + pos_weight=-1, + debug=False), + rpn_proposal=dict( + nms_pre=2000, + max_per_img=2000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=[ + dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0.5, + match_low_quality=False, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + pos_weight=-1, + debug=False), + dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.6, + neg_iou_thr=0.6, + min_pos_iou=0.6, + match_low_quality=False, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + pos_weight=-1, + debug=False), + dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.7, + min_pos_iou=0.7, + match_low_quality=False, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + pos_weight=-1, + debug=False) + ]), + test_cfg=dict( + rpn=dict( + nms_pre=1000, + max_per_img=1000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=dict( + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.5), + max_per_img=100))) diff --git a/mmdetection/configs/_base_/models/fast-rcnn_r50_fpn.py b/mmdetection/configs/_base_/models/fast-rcnn_r50_fpn.py new file mode 100644 index 00000000..2bd45e92 --- /dev/null +++ b/mmdetection/configs/_base_/models/fast-rcnn_r50_fpn.py @@ -0,0 +1,68 @@ +# model settings +model = dict( + type='FastRCNN', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + num_outs=5), + roi_head=dict( + type='StandardRoIHead', + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + bbox_head=dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=False, + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0))), + # model training and testing settings + train_cfg=dict( + rcnn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0.5, + match_low_quality=False, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + pos_weight=-1, + debug=False)), + test_cfg=dict( + rcnn=dict( + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.5), + max_per_img=100))) diff --git a/mmdetection/configs/_base_/models/faster-rcnn_r50-caffe-c4.py b/mmdetection/configs/_base_/models/faster-rcnn_r50-caffe-c4.py new file mode 100644 index 00000000..15d2db72 --- /dev/null +++ b/mmdetection/configs/_base_/models/faster-rcnn_r50-caffe-c4.py @@ -0,0 +1,123 @@ +# model settings +norm_cfg = dict(type='BN', requires_grad=False) +model = dict( + type='FasterRCNN', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=3, + strides=(1, 2, 2), + dilations=(1, 1, 1), + out_indices=(2, ), + frozen_stages=1, + norm_cfg=norm_cfg, + norm_eval=True, + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe')), + rpn_head=dict( + type='RPNHead', + in_channels=1024, + feat_channels=1024, + anchor_generator=dict( + type='AnchorGenerator', + scales=[2, 4, 8, 16, 32], + ratios=[0.5, 1.0, 2.0], + strides=[16]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[1.0, 1.0, 1.0, 1.0]), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0)), + roi_head=dict( + type='StandardRoIHead', + shared_head=dict( + type='ResLayer', + depth=50, + stage=3, + stride=2, + dilation=1, + style='caffe', + norm_cfg=norm_cfg, + norm_eval=True, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe')), + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0), + out_channels=1024, + featmap_strides=[16]), + bbox_head=dict( + type='BBoxHead', + with_avg_pool=True, + roi_feat_size=7, + in_channels=2048, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=False, + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0))), + # model training and testing settings + train_cfg=dict( + rpn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.3, + min_pos_iou=0.3, + match_low_quality=True, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=-1, + pos_weight=-1, + debug=False), + rpn_proposal=dict( + nms_pre=12000, + max_per_img=2000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0.5, + match_low_quality=False, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + pos_weight=-1, + debug=False)), + test_cfg=dict( + rpn=dict( + nms_pre=6000, + max_per_img=1000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=dict( + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.5), + max_per_img=100))) diff --git a/mmdetection/configs/_base_/models/faster-rcnn_r50-caffe-dc5.py b/mmdetection/configs/_base_/models/faster-rcnn_r50-caffe-dc5.py new file mode 100644 index 00000000..189915e3 --- /dev/null +++ b/mmdetection/configs/_base_/models/faster-rcnn_r50-caffe-dc5.py @@ -0,0 +1,111 @@ +# model settings +norm_cfg = dict(type='BN', requires_grad=False) +model = dict( + type='FasterRCNN', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + strides=(1, 2, 2, 1), + dilations=(1, 1, 1, 2), + out_indices=(3, ), + frozen_stages=1, + norm_cfg=norm_cfg, + norm_eval=True, + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe')), + rpn_head=dict( + type='RPNHead', + in_channels=2048, + feat_channels=2048, + anchor_generator=dict( + type='AnchorGenerator', + scales=[2, 4, 8, 16, 32], + ratios=[0.5, 1.0, 2.0], + strides=[16]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[1.0, 1.0, 1.0, 1.0]), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0)), + roi_head=dict( + type='StandardRoIHead', + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0), + out_channels=2048, + featmap_strides=[16]), + bbox_head=dict( + type='Shared2FCBBoxHead', + in_channels=2048, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=False, + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0))), + # model training and testing settings + train_cfg=dict( + rpn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.3, + min_pos_iou=0.3, + match_low_quality=True, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=0, + pos_weight=-1, + debug=False), + rpn_proposal=dict( + nms_pre=12000, + max_per_img=2000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0.5, + match_low_quality=False, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + pos_weight=-1, + debug=False)), + test_cfg=dict( + rpn=dict( + nms=dict(type='nms', iou_threshold=0.7), + nms_pre=6000, + max_per_img=1000, + min_bbox_size=0), + rcnn=dict( + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.5), + max_per_img=100))) diff --git a/mmdetection/configs/_base_/models/faster-rcnn_r50_fpn.py b/mmdetection/configs/_base_/models/faster-rcnn_r50_fpn.py new file mode 100644 index 00000000..31aa1461 --- /dev/null +++ b/mmdetection/configs/_base_/models/faster-rcnn_r50_fpn.py @@ -0,0 +1,114 @@ +# model settings +model = dict( + type='FasterRCNN', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + num_outs=5), + rpn_head=dict( + type='RPNHead', + in_channels=256, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + scales=[8], + ratios=[0.5, 1.0, 2.0], + strides=[4, 8, 16, 32, 64]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[1.0, 1.0, 1.0, 1.0]), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0)), + roi_head=dict( + type='StandardRoIHead', + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + bbox_head=dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=False, + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0))), + # model training and testing settings + train_cfg=dict( + rpn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.3, + min_pos_iou=0.3, + match_low_quality=True, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=-1, + pos_weight=-1, + debug=False), + rpn_proposal=dict( + nms_pre=2000, + max_per_img=1000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0.5, + match_low_quality=False, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + pos_weight=-1, + debug=False)), + test_cfg=dict( + rpn=dict( + nms_pre=1000, + max_per_img=1000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=dict( + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.5), + max_per_img=100) + # soft-nms is also supported for rcnn testing + # e.g., nms=dict(type='soft_nms', iou_threshold=0.5, min_score=0.05) + )) diff --git a/mmdetection/configs/_base_/models/mask-rcnn_r50-caffe-c4.py b/mmdetection/configs/_base_/models/mask-rcnn_r50-caffe-c4.py new file mode 100644 index 00000000..de1131b2 --- /dev/null +++ b/mmdetection/configs/_base_/models/mask-rcnn_r50-caffe-c4.py @@ -0,0 +1,132 @@ +# model settings +norm_cfg = dict(type='BN', requires_grad=False) +model = dict( + type='MaskRCNN', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False, + pad_mask=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=3, + strides=(1, 2, 2), + dilations=(1, 1, 1), + out_indices=(2, ), + frozen_stages=1, + norm_cfg=norm_cfg, + norm_eval=True, + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe')), + rpn_head=dict( + type='RPNHead', + in_channels=1024, + feat_channels=1024, + anchor_generator=dict( + type='AnchorGenerator', + scales=[2, 4, 8, 16, 32], + ratios=[0.5, 1.0, 2.0], + strides=[16]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[1.0, 1.0, 1.0, 1.0]), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0)), + roi_head=dict( + type='StandardRoIHead', + shared_head=dict( + type='ResLayer', + depth=50, + stage=3, + stride=2, + dilation=1, + style='caffe', + norm_cfg=norm_cfg, + norm_eval=True), + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0), + out_channels=1024, + featmap_strides=[16]), + bbox_head=dict( + type='BBoxHead', + with_avg_pool=True, + roi_feat_size=7, + in_channels=2048, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=False, + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0)), + mask_roi_extractor=None, + mask_head=dict( + type='FCNMaskHead', + num_convs=0, + in_channels=2048, + conv_out_channels=256, + num_classes=80, + loss_mask=dict( + type='CrossEntropyLoss', use_mask=True, loss_weight=1.0))), + # model training and testing settings + train_cfg=dict( + rpn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.3, + min_pos_iou=0.3, + match_low_quality=True, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=0, + pos_weight=-1, + debug=False), + rpn_proposal=dict( + nms_pre=12000, + max_per_img=2000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0.5, + match_low_quality=False, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + mask_size=14, + pos_weight=-1, + debug=False)), + test_cfg=dict( + rpn=dict( + nms_pre=6000, + nms=dict(type='nms', iou_threshold=0.7), + max_per_img=1000, + min_bbox_size=0), + rcnn=dict( + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.5), + max_per_img=100, + mask_thr_binary=0.5))) diff --git a/mmdetection/configs/_base_/models/mask-rcnn_r50_fpn.py b/mmdetection/configs/_base_/models/mask-rcnn_r50_fpn.py new file mode 100644 index 00000000..b4ff7a49 --- /dev/null +++ b/mmdetection/configs/_base_/models/mask-rcnn_r50_fpn.py @@ -0,0 +1,127 @@ +# model settings +model = dict( + type='MaskRCNN', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_mask=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + num_outs=5), + rpn_head=dict( + type='RPNHead', + in_channels=256, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + scales=[8], + ratios=[0.5, 1.0, 2.0], + strides=[4, 8, 16, 32, 64]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[1.0, 1.0, 1.0, 1.0]), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0)), + roi_head=dict( + type='StandardRoIHead', + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + bbox_head=dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=False, + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0)), + mask_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + mask_head=dict( + type='FCNMaskHead', + num_convs=4, + in_channels=256, + conv_out_channels=256, + num_classes=80, + loss_mask=dict( + type='CrossEntropyLoss', use_mask=True, loss_weight=1.0))), + # model training and testing settings + train_cfg=dict( + rpn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.3, + min_pos_iou=0.3, + match_low_quality=True, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=-1, + pos_weight=-1, + debug=False), + rpn_proposal=dict( + nms_pre=2000, + max_per_img=1000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0.5, + match_low_quality=True, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + mask_size=28, + pos_weight=-1, + debug=False)), + test_cfg=dict( + rpn=dict( + nms_pre=1000, + max_per_img=1000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=dict( + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.5), + max_per_img=100, + mask_thr_binary=0.5))) diff --git a/mmdetection/configs/_base_/models/retinanet_r50_fpn.py b/mmdetection/configs/_base_/models/retinanet_r50_fpn.py new file mode 100644 index 00000000..53662c9f --- /dev/null +++ b/mmdetection/configs/_base_/models/retinanet_r50_fpn.py @@ -0,0 +1,68 @@ +# model settings +model = dict( + type='RetinaNet', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_input', + num_outs=5), + bbox_head=dict( + type='RetinaHead', + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + octave_base_scale=4, + scales_per_octave=3, + ratios=[0.5, 1.0, 2.0], + strides=[8, 16, 32, 64, 128]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[1.0, 1.0, 1.0, 1.0]), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0)), + # model training and testing settings + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.4, + min_pos_iou=0, + ignore_iof_thr=-1), + sampler=dict( + type='PseudoSampler'), # Focal loss should use PseudoSampler + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.5), + max_per_img=100)) diff --git a/mmdetection/configs/_base_/models/rpn_r50-caffe-c4.py b/mmdetection/configs/_base_/models/rpn_r50-caffe-c4.py new file mode 100644 index 00000000..ed1dbe74 --- /dev/null +++ b/mmdetection/configs/_base_/models/rpn_r50-caffe-c4.py @@ -0,0 +1,64 @@ +# model settings +model = dict( + type='RPN', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=3, + strides=(1, 2, 2), + dilations=(1, 1, 1), + out_indices=(2, ), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=False), + norm_eval=True, + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe')), + neck=None, + rpn_head=dict( + type='RPNHead', + in_channels=1024, + feat_channels=1024, + anchor_generator=dict( + type='AnchorGenerator', + scales=[2, 4, 8, 16, 32], + ratios=[0.5, 1.0, 2.0], + strides=[16]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[1.0, 1.0, 1.0, 1.0]), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0)), + # model training and testing settings + train_cfg=dict( + rpn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.3, + min_pos_iou=0.3, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=-1, + pos_weight=-1, + debug=False)), + test_cfg=dict( + rpn=dict( + nms_pre=12000, + max_per_img=2000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0))) diff --git a/mmdetection/configs/_base_/models/rpn_r50_fpn.py b/mmdetection/configs/_base_/models/rpn_r50_fpn.py new file mode 100644 index 00000000..6bc47904 --- /dev/null +++ b/mmdetection/configs/_base_/models/rpn_r50_fpn.py @@ -0,0 +1,64 @@ +# model settings +model = dict( + type='RPN', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + num_outs=5), + rpn_head=dict( + type='RPNHead', + in_channels=256, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + scales=[8], + ratios=[0.5, 1.0, 2.0], + strides=[4, 8, 16, 32, 64]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[1.0, 1.0, 1.0, 1.0]), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0)), + # model training and testing settings + train_cfg=dict( + rpn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.3, + min_pos_iou=0.3, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=-1, + pos_weight=-1, + debug=False)), + test_cfg=dict( + rpn=dict( + nms_pre=2000, + max_per_img=1000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0))) diff --git a/mmdetection/configs/_base_/models/ssd300.py b/mmdetection/configs/_base_/models/ssd300.py new file mode 100644 index 00000000..fd113c7c --- /dev/null +++ b/mmdetection/configs/_base_/models/ssd300.py @@ -0,0 +1,63 @@ +# model settings +input_size = 300 +model = dict( + type='SingleStageDetector', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[1, 1, 1], + bgr_to_rgb=True, + pad_size_divisor=1), + backbone=dict( + type='SSDVGG', + depth=16, + with_last_pool=False, + ceil_mode=True, + out_indices=(3, 4), + out_feature_indices=(22, 34), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://vgg16_caffe')), + neck=dict( + type='SSDNeck', + in_channels=(512, 1024), + out_channels=(512, 1024, 512, 256, 256, 256), + level_strides=(2, 2, 1, 1), + level_paddings=(1, 1, 0, 0), + l2_norm_scale=20), + bbox_head=dict( + type='SSDHead', + in_channels=(512, 1024, 512, 256, 256, 256), + num_classes=80, + anchor_generator=dict( + type='SSDAnchorGenerator', + scale_major=False, + input_size=input_size, + basesize_ratio_range=(0.15, 0.9), + strides=[8, 16, 32, 64, 100, 300], + ratios=[[2], [2, 3], [2, 3], [2, 3], [2], [2]]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.1, 0.1, 0.2, 0.2])), + # model training and testing settings + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0., + ignore_iof_thr=-1, + gt_max_assign_all=False), + sampler=dict(type='PseudoSampler'), + smoothl1_beta=1., + allowed_border=-1, + pos_weight=-1, + neg_pos_ratio=3, + debug=False), + test_cfg=dict( + nms_pre=1000, + nms=dict(type='nms', iou_threshold=0.45), + min_bbox_size=0, + score_thr=0.02, + max_per_img=200)) +cudnn_benchmark = True diff --git a/mmdetection/configs/_base_/schedules/schedule_1x.py b/mmdetection/configs/_base_/schedules/schedule_1x.py new file mode 100644 index 00000000..95f30be7 --- /dev/null +++ b/mmdetection/configs/_base_/schedules/schedule_1x.py @@ -0,0 +1,28 @@ +# training schedule for 1x +train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=12, val_interval=1) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=12, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)) + +# Default setting for scaling LR automatically +# - `enable` means enable scaling LR automatically +# or not by default. +# - `base_batch_size` = (8 GPUs) x (2 samples per GPU). +auto_scale_lr = dict(enable=False, base_batch_size=16) diff --git a/mmdetection/configs/_base_/schedules/schedule_20e.py b/mmdetection/configs/_base_/schedules/schedule_20e.py new file mode 100644 index 00000000..75f958b0 --- /dev/null +++ b/mmdetection/configs/_base_/schedules/schedule_20e.py @@ -0,0 +1,28 @@ +# training schedule for 20e +train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=20, val_interval=1) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=20, + by_epoch=True, + milestones=[16, 19], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)) + +# Default setting for scaling LR automatically +# - `enable` means enable scaling LR automatically +# or not by default. +# - `base_batch_size` = (8 GPUs) x (2 samples per GPU). +auto_scale_lr = dict(enable=False, base_batch_size=16) diff --git a/mmdetection/configs/_base_/schedules/schedule_2x.py b/mmdetection/configs/_base_/schedules/schedule_2x.py new file mode 100644 index 00000000..5b7b241d --- /dev/null +++ b/mmdetection/configs/_base_/schedules/schedule_2x.py @@ -0,0 +1,28 @@ +# training schedule for 2x +train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=24, val_interval=1) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=24, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)) + +# Default setting for scaling LR automatically +# - `enable` means enable scaling LR automatically +# or not by default. +# - `base_batch_size` = (8 GPUs) x (2 samples per GPU). +auto_scale_lr = dict(enable=False, base_batch_size=16) diff --git a/mmdetection/configs/albu_example/README.md b/mmdetection/configs/albu_example/README.md new file mode 100644 index 00000000..fa362f95 --- /dev/null +++ b/mmdetection/configs/albu_example/README.md @@ -0,0 +1,31 @@ +# Albu Example + +> [Albumentations: fast and flexible image augmentations](https://arxiv.org/abs/1809.06839) + + + +## Abstract + +Data augmentation is a commonly used technique for increasing both the size and the diversity of labeled training sets by leveraging input transformations that preserve output labels. In computer vision domain, image augmentations have become a common implicit regularization technique to combat overfitting in deep convolutional neural networks and are ubiquitously used to improve performance. While most deep learning frameworks implement basic image transformations, the list is typically limited to some variations and combinations of flipping, rotating, scaling, and cropping. Moreover, the image processing speed varies in existing tools for image augmentation. We present Albumentations, a fast and flexible library for image augmentations with many various image transform operations available, that is also an easy-to-use wrapper around other augmentation libraries. We provide examples of image augmentations for different computer vision tasks and show that Albumentations is faster than other commonly used image augmentation tools on the most of commonly used image transformations. + +
    + +
    + +## Results and Models + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :------: | :-----: | :-----: | :------: | :------------: | :----: | :-----: | :-------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | pytorch | 1x | 4.4 | 16.6 | 38.0 | 34.5 | [config](./mask-rcnn_r50_fpn_albu-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/albu_example/mask_rcnn_r50_fpn_albu_1x_coco/mask_rcnn_r50_fpn_albu_1x_coco_20200208-ab203bcd.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/albu_example/mask_rcnn_r50_fpn_albu_1x_coco/mask_rcnn_r50_fpn_albu_1x_coco_20200208_225520.log.json) | + +## Citation + +```latex +@article{2018arXiv180906839B, + author = {A. Buslaev, A. Parinov, E. Khvedchenya, V.~I. Iglovikov and A.~A. Kalinin}, + title = "{Albumentations: fast and flexible image augmentations}", + journal = {ArXiv e-prints}, + eprint = {1809.06839}, + year = 2018 +} +``` diff --git a/mmdetection/configs/albu_example/mask-rcnn_r50_fpn_albu-1x_coco.py b/mmdetection/configs/albu_example/mask-rcnn_r50_fpn_albu-1x_coco.py new file mode 100644 index 00000000..b8a2780e --- /dev/null +++ b/mmdetection/configs/albu_example/mask-rcnn_r50_fpn_albu-1x_coco.py @@ -0,0 +1,66 @@ +_base_ = '../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py' + +albu_train_transforms = [ + dict( + type='ShiftScaleRotate', + shift_limit=0.0625, + scale_limit=0.0, + rotate_limit=0, + interpolation=1, + p=0.5), + dict( + type='RandomBrightnessContrast', + brightness_limit=[0.1, 0.3], + contrast_limit=[0.1, 0.3], + p=0.2), + dict( + type='OneOf', + transforms=[ + dict( + type='RGBShift', + r_shift_limit=10, + g_shift_limit=10, + b_shift_limit=10, + p=1.0), + dict( + type='HueSaturationValue', + hue_shift_limit=20, + sat_shift_limit=30, + val_shift_limit=20, + p=1.0) + ], + p=0.1), + dict(type='JpegCompression', quality_lower=85, quality_upper=95, p=0.2), + dict(type='ChannelShuffle', p=0.1), + dict( + type='OneOf', + transforms=[ + dict(type='Blur', blur_limit=3, p=1.0), + dict(type='MedianBlur', blur_limit=3, p=1.0) + ], + p=0.1), +] +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict( + type='Albu', + transforms=albu_train_transforms, + bbox_params=dict( + type='BboxParams', + format='pascal_voc', + label_fields=['gt_bboxes_labels', 'gt_ignore_flags'], + min_visibility=0.0, + filter_lost_elements=True), + keymap={ + 'img': 'image', + 'gt_masks': 'masks', + 'gt_bboxes': 'bboxes' + }, + skip_img_without_anno=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/mmdetection/configs/albu_example/metafile.yml b/mmdetection/configs/albu_example/metafile.yml new file mode 100644 index 00000000..3b54bdf1 --- /dev/null +++ b/mmdetection/configs/albu_example/metafile.yml @@ -0,0 +1,17 @@ +Models: + - Name: mask-rcnn_r50_fpn_albu-1x_coco + In Collection: Mask R-CNN + Config: mask-rcnn_r50_fpn_albu-1x_coco.py + Metadata: + Training Memory (GB): 4.4 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.0 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 34.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/albu_example/mask_rcnn_r50_fpn_albu_1x_coco/mask_rcnn_r50_fpn_albu_1x_coco_20200208-ab203bcd.pth diff --git a/mmdetection/configs/atss/README.md b/mmdetection/configs/atss/README.md new file mode 100644 index 00000000..1411672e --- /dev/null +++ b/mmdetection/configs/atss/README.md @@ -0,0 +1,31 @@ +# ATSS + +> [Bridging the Gap Between Anchor-based and Anchor-free Detection via Adaptive Training Sample Selection](https://arxiv.org/abs/1912.02424) + + + +## Abstract + +Object detection has been dominated by anchor-based detectors for several years. Recently, anchor-free detectors have become popular due to the proposal of FPN and Focal Loss. In this paper, we first point out that the essential difference between anchor-based and anchor-free detection is actually how to define positive and negative training samples, which leads to the performance gap between them. If they adopt the same definition of positive and negative samples during training, there is no obvious difference in the final performance, no matter regressing from a box or a point. This shows that how to select positive and negative training samples is important for current object detectors. Then, we propose an Adaptive Training Sample Selection (ATSS) to automatically select positive and negative samples according to statistical characteristics of object. It significantly improves the performance of anchor-based and anchor-free detectors and bridges the gap between them. Finally, we discuss the necessity of tiling multiple anchors per location on the image to detect objects. Extensive experiments conducted on MS COCO support our aforementioned analysis and conclusions. With the newly introduced ATSS, we improve state-of-the-art detectors by a large margin to 50.7% AP without introducing any overhead. + +
    + +
    + +## Results and Models + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :------: | :-----: | :-----: | :------: | :------------: | :----: | :----------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | pytorch | 1x | 3.7 | 19.7 | 39.4 | [config](./atss_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/atss/atss_r50_fpn_1x_coco/atss_r50_fpn_1x_coco_20200209-985f7bd0.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/atss/atss_r50_fpn_1x_coco/atss_r50_fpn_1x_coco_20200209_102539.log.json) | +| R-101 | pytorch | 1x | 5.6 | 12.3 | 41.5 | [config](./atss_r101_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/atss/atss_r101_fpn_1x_coco/atss_r101_fpn_1x_20200825-dfcadd6f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/atss/atss_r101_fpn_1x_coco/atss_r101_fpn_1x_20200825-dfcadd6f.log.json) | + +## Citation + +```latex +@article{zhang2019bridging, + title = {Bridging the Gap Between Anchor-based and Anchor-free Detection via Adaptive Training Sample Selection}, + author = {Zhang, Shifeng and Chi, Cheng and Yao, Yongqiang and Lei, Zhen and Li, Stan Z.}, + journal = {arXiv preprint arXiv:1912.02424}, + year = {2019} +} +``` diff --git a/mmdetection/configs/atss/atss_r101_fpn_1x_coco.py b/mmdetection/configs/atss/atss_r101_fpn_1x_coco.py new file mode 100644 index 00000000..5225d2ab --- /dev/null +++ b/mmdetection/configs/atss/atss_r101_fpn_1x_coco.py @@ -0,0 +1,6 @@ +_base_ = './atss_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/atss/atss_r101_fpn_8xb8-amp-lsj-200e_coco.py b/mmdetection/configs/atss/atss_r101_fpn_8xb8-amp-lsj-200e_coco.py new file mode 100644 index 00000000..69999ce4 --- /dev/null +++ b/mmdetection/configs/atss/atss_r101_fpn_8xb8-amp-lsj-200e_coco.py @@ -0,0 +1,7 @@ +_base_ = './atss_r50_fpn_8xb8-amp-lsj-200e_coco.py' + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/atss/atss_r18_fpn_8xb8-amp-lsj-200e_coco.py b/mmdetection/configs/atss/atss_r18_fpn_8xb8-amp-lsj-200e_coco.py new file mode 100644 index 00000000..12d9f132 --- /dev/null +++ b/mmdetection/configs/atss/atss_r18_fpn_8xb8-amp-lsj-200e_coco.py @@ -0,0 +1,7 @@ +_base_ = './atss_r50_fpn_8xb8-amp-lsj-200e_coco.py' + +model = dict( + backbone=dict( + depth=18, + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet18')), + neck=dict(in_channels=[64, 128, 256, 512])) diff --git a/mmdetection/configs/atss/atss_r50_fpn_1x_coco.py b/mmdetection/configs/atss/atss_r50_fpn_1x_coco.py new file mode 100644 index 00000000..306435d7 --- /dev/null +++ b/mmdetection/configs/atss/atss_r50_fpn_1x_coco.py @@ -0,0 +1,71 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +# model settings +model = dict( + type='ATSS', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_output', + num_outs=5), + bbox_head=dict( + type='ATSSHead', + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + octave_base_scale=8, + scales_per_octave=1, + strides=[8, 16, 32, 64, 128]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=2.0), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)), + # training and testing settings + train_cfg=dict( + assigner=dict(type='ATSSAssigner', topk=9), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) +# optimizer +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) diff --git a/mmdetection/configs/atss/atss_r50_fpn_8xb8-amp-lsj-200e_coco.py b/mmdetection/configs/atss/atss_r50_fpn_8xb8-amp-lsj-200e_coco.py new file mode 100644 index 00000000..e3b3c46f --- /dev/null +++ b/mmdetection/configs/atss/atss_r50_fpn_8xb8-amp-lsj-200e_coco.py @@ -0,0 +1,81 @@ +_base_ = '../common/lsj-200e_coco-detection.py' + +image_size = (1024, 1024) +batch_augments = [dict(type='BatchFixedSizePad', size=image_size)] + +model = dict( + type='ATSS', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32, + batch_augments=batch_augments), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_output', + num_outs=5), + bbox_head=dict( + type='ATSSHead', + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + octave_base_scale=8, + scales_per_octave=1, + strides=[8, 16, 32, 64, 128]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=2.0), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)), + # training and testing settings + train_cfg=dict( + assigner=dict(type='ATSSAssigner', topk=9), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) + +train_dataloader = dict(batch_size=8, num_workers=4) + +# Enable automatic-mixed-precision training with AmpOptimWrapper. +optim_wrapper = dict( + type='AmpOptimWrapper', + optimizer=dict( + type='SGD', lr=0.01 * 4, momentum=0.9, weight_decay=0.00004)) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (8 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/atss/metafile.yml b/mmdetection/configs/atss/metafile.yml new file mode 100644 index 00000000..f4c567ef --- /dev/null +++ b/mmdetection/configs/atss/metafile.yml @@ -0,0 +1,60 @@ +Collections: + - Name: ATSS + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - ATSS + - FPN + - ResNet + Paper: + URL: https://arxiv.org/abs/1912.02424 + Title: 'Bridging the Gap Between Anchor-based and Anchor-free Detection via Adaptive Training Sample Selection' + README: configs/atss/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/detectors/atss.py#L6 + Version: v2.0.0 + +Models: + - Name: atss_r50_fpn_1x_coco + In Collection: ATSS + Config: configs/atss/atss_r50_fpn_1x_coco.py + Metadata: + Training Memory (GB): 3.7 + inference time (ms/im): + - value: 50.76 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/atss/atss_r50_fpn_1x_coco/atss_r50_fpn_1x_coco_20200209-985f7bd0.pth + + - Name: atss_r101_fpn_1x_coco + In Collection: ATSS + Config: configs/atss/atss_r101_fpn_1x_coco.py + Metadata: + Training Memory (GB): 5.6 + inference time (ms/im): + - value: 81.3 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/atss/atss_r101_fpn_1x_coco/atss_r101_fpn_1x_20200825-dfcadd6f.pth diff --git a/mmdetection/configs/autoassign/README.md b/mmdetection/configs/autoassign/README.md new file mode 100644 index 00000000..f6b05738 --- /dev/null +++ b/mmdetection/configs/autoassign/README.md @@ -0,0 +1,35 @@ +# AutoAssign + +> [AutoAssign: Differentiable Label Assignment for Dense Object Detection](https://arxiv.org/abs/2007.03496) + + + +## Abstract + +Determining positive/negative samples for object detection is known as label assignment. Here we present an anchor-free detector named AutoAssign. It requires little human knowledge and achieves appearance-aware through a fully differentiable weighting mechanism. During training, to both satisfy the prior distribution of data and adapt to category characteristics, we present Center Weighting to adjust the category-specific prior distributions. To adapt to object appearances, Confidence Weighting is proposed to adjust the specific assign strategy of each instance. The two weighting modules are then combined to generate positive and negative weights to adjust each location's confidence. Extensive experiments on the MS COCO show that our method steadily surpasses other best sampling strategies by large margins with various backbones. Moreover, our best model achieves 52.1% AP, outperforming all existing one-stage detectors. Besides, experiments on other datasets, e.g., PASCAL VOC, Objects365, and WiderFace, demonstrate the broad applicability of AutoAssign. + +
    + +
    + +## Results and Models + +| Backbone | Style | Lr schd | Mem (GB) | box AP | Config | Download | +| :------: | :---: | :-----: | :------: | :----: | :---------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | caffe | 1x | 4.08 | 40.4 | [config](./autoassign_r50-caffe_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/autoassign/auto_assign_r50_fpn_1x_coco/auto_assign_r50_fpn_1x_coco_20210413_115540-5e17991f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/autoassign/auto_assign_r50_fpn_1x_coco/auto_assign_r50_fpn_1x_coco_20210413_115540-5e17991f.log.json) | + +**Note**: + +1. We find that the performance is unstable with 1x setting and may fluctuate by about 0.3 mAP. mAP 40.3 ~ 40.6 is acceptable. Such fluctuation can also be found in the original implementation. +2. You can get a more stable results ~ mAP 40.6 with a schedule total 13 epoch, and learning rate is divided by 10 at 10th and 13th epoch. + +## Citation + +```latex +@article{zhu2020autoassign, + title={AutoAssign: Differentiable Label Assignment for Dense Object Detection}, + author={Zhu, Benjin and Wang, Jianfeng and Jiang, Zhengkai and Zong, Fuhang and Liu, Songtao and Li, Zeming and Sun, Jian}, + journal={arXiv preprint arXiv:2007.03496}, + year={2020} +} +``` diff --git a/mmdetection/configs/autoassign/autoassign_r50-caffe_fpn_1x_coco.py b/mmdetection/configs/autoassign/autoassign_r50-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..76a36195 --- /dev/null +++ b/mmdetection/configs/autoassign/autoassign_r50-caffe_fpn_1x_coco.py @@ -0,0 +1,69 @@ +# We follow the original implementation which +# adopts the Caffe pre-trained backbone. +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +# model settings +model = dict( + type='AutoAssign', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[102.9801, 115.9465, 122.7717], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=False), + norm_eval=True, + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs=True, + num_outs=5, + relu_before_extra_convs=True, + init_cfg=dict(type='Caffe2Xavier', layer='Conv2d')), + bbox_head=dict( + type='AutoAssignHead', + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + strides=[8, 16, 32, 64, 128], + loss_bbox=dict(type='GIoULoss', loss_weight=5.0)), + train_cfg=None, + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, + end=1000), + dict( + type='MultiStepLR', + begin=0, + end=12, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + optimizer=dict(lr=0.01), paramwise_cfg=dict(norm_decay_mult=0.)) diff --git a/mmdetection/configs/autoassign/metafile.yml b/mmdetection/configs/autoassign/metafile.yml new file mode 100644 index 00000000..ab7a4af3 --- /dev/null +++ b/mmdetection/configs/autoassign/metafile.yml @@ -0,0 +1,33 @@ +Collections: + - Name: AutoAssign + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - AutoAssign + - FPN + - ResNet + Paper: + URL: https://arxiv.org/abs/2007.03496 + Title: 'AutoAssign: Differentiable Label Assignment for Dense Object Detection' + README: configs/autoassign/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.12.0/mmdet/models/detectors/autoassign.py#L6 + Version: v2.12.0 + +Models: + - Name: autoassign_r50-caffe_fpn_1x_coco + In Collection: AutoAssign + Config: configs/autoassign/autoassign_r50-caffe_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.08 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/autoassign/auto_assign_r50_fpn_1x_coco/auto_assign_r50_fpn_1x_coco_20210413_115540-5e17991f.pth diff --git a/mmdetection/configs/boxinst/README.md b/mmdetection/configs/boxinst/README.md new file mode 100644 index 00000000..f6f01c5d --- /dev/null +++ b/mmdetection/configs/boxinst/README.md @@ -0,0 +1,32 @@ +# BoxInst + +> [BoxInst: High-Performance Instance Segmentation with Box Annotations](https://arxiv.org/pdf/2012.02310.pdf) + + + +## Abstract + +We present a high-performance method that can achieve mask-level instance segmentation with only bounding-box annotations for training. While this setting has been studied in the literature, here we show significantly stronger performance with a simple design (e.g., dramatically improving previous best reported mask AP of 21.1% to 31.6% on the COCO dataset). Our core idea is to redesign the loss +of learning masks in instance segmentation, with no modification to the segmentation network itself. The new loss functions can supervise the mask training without relying on mask annotations. This is made possible with two loss terms, namely, 1) a surrogate term that minimizes the discrepancy between the projections of the ground-truth box and the predicted mask; 2) a pairwise loss that can exploit the prior that proximal pixels with similar colors are very likely to have the same category label. Experiments demonstrate that the redesigned mask loss can yield surprisingly high-quality instance masks with only box annotations. For example, without using any mask annotations, with a ResNet-101 backbone and 3× training schedule, we achieve 33.2% mask AP on COCO test-dev split (vs. 39.1% of the fully supervised counterpart). Our excellent experiment results on COCO and Pascal VOC indicate that our method dramatically narrows the performance gap between weakly and fully supervised instance segmentation. + +
    + +
    + +## Results and Models + +| Backbone | Style | MS train | Lr schd | bbox AP | mask AP | Config | Download | +| :------: | :-----: | :------: | :-----: | :-----: | :-----: | :-----------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | pytorch | Y | 1x | 39.6 | 31.1 | [config](./boxinst_r50_fpn_ms-90k_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/boxinst/boxinst_r50_fpn_ms-90k_coco/boxinst_r50_fpn_ms-90k_coco_20221228_163052-6add751a.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/boxinst/boxinst_r50_fpn_ms-90k_coco/boxinst_r50_fpn_ms-90k_coco_20221228_163052.log.json) | +| R-101 | pytorch | Y | 1x | 41.8 | 32.7 | [config](./boxinst_r101_fpn_ms-90k_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/boxinst/boxinst_r101_fpn_ms-90k_coco/boxinst_r101_fpn_ms-90k_coco_20221229_145106-facf375b.pth) \|[log](https://download.openmmlab.com/mmdetection/v3.0/boxinst/boxinst_r101_fpn_ms-90k_coco/boxinst_r101_fpn_ms-90k_coco_20221229_145106.log.json) | + +## Citation + +```latex +@inproceedings{tian2020boxinst, + title = {{BoxInst}: High-Performance Instance Segmentation with Box Annotations}, + author = {Tian, Zhi and Shen, Chunhua and Wang, Xinlong and Chen, Hao}, + booktitle = {Proc. IEEE Conf. Computer Vision and Pattern Recognition (CVPR)}, + year = {2021} +} +``` diff --git a/mmdetection/configs/boxinst/boxinst_r101_fpn_ms-90k_coco.py b/mmdetection/configs/boxinst/boxinst_r101_fpn_ms-90k_coco.py new file mode 100644 index 00000000..ab2b1162 --- /dev/null +++ b/mmdetection/configs/boxinst/boxinst_r101_fpn_ms-90k_coco.py @@ -0,0 +1,8 @@ +_base_ = './boxinst_r50_fpn_ms-90k_coco.py' + +# model settings +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/boxinst/boxinst_r50_fpn_ms-90k_coco.py b/mmdetection/configs/boxinst/boxinst_r50_fpn_ms-90k_coco.py new file mode 100644 index 00000000..371f252a --- /dev/null +++ b/mmdetection/configs/boxinst/boxinst_r50_fpn_ms-90k_coco.py @@ -0,0 +1,93 @@ +_base_ = '../common/ms-90k_coco.py' + +# model settings +model = dict( + type='BoxInst', + data_preprocessor=dict( + type='BoxInstDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32, + mask_stride=4, + pairwise_size=3, + pairwise_dilation=2, + pairwise_color_thresh=0.3, + bottom_pixels_removed=10), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50'), + style='pytorch'), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_output', # use P5 + num_outs=5, + relu_before_extra_convs=True), + bbox_head=dict( + type='BoxInstBboxHead', + num_params=593, + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + strides=[8, 16, 32, 64, 128], + norm_on_bbox=True, + centerness_on_reg=True, + dcn_on_last_conv=False, + center_sampling=True, + conv_bias=True, + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=1.0), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)), + mask_head=dict( + type='BoxInstMaskHead', + num_layers=3, + feat_channels=16, + size_of_interest=8, + mask_out_stride=4, + topk_masks_per_img=64, + mask_feature_head=dict( + in_channels=256, + feat_channels=128, + start_level=0, + end_level=2, + out_channels=16, + mask_stride=8, + num_stacked_convs=4, + norm_cfg=dict(type='BN', requires_grad=True)), + loss_mask=dict( + type='DiceLoss', + use_sigmoid=True, + activate=True, + eps=5e-6, + loss_weight=1.0)), + # model training and testing settings + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100, + mask_thr=0.5)) + +# optimizer +optim_wrapper = dict(optimizer=dict(lr=0.01)) + +# evaluator +val_evaluator = dict(metric=['bbox', 'segm']) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/boxinst/metafile.yml b/mmdetection/configs/boxinst/metafile.yml new file mode 100644 index 00000000..c97fcdcd --- /dev/null +++ b/mmdetection/configs/boxinst/metafile.yml @@ -0,0 +1,52 @@ +Collections: + - Name: BoxInst + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x A100 GPUs + Architecture: + - ResNet + - FPN + - CondInst + Paper: + URL: https://arxiv.org/abs/2012.02310 + Title: 'BoxInst: High-Performance Instance Segmentation with Box Annotations' + README: configs/boxinst/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v3.0.0rc6/mmdet/models/detectors/boxinst.py#L8 + Version: v3.0.0rc6 + +Models: + - Name: boxinst_r50_fpn_ms-90k_coco + In Collection: BoxInst + Config: configs/boxinst/boxinst_r50_fpn_ms-90k_coco.py + Metadata: + Iterations: 90000 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.4 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 30.8 + Weights: https://download.openmmlab.com/mmdetection/v3.0/boxinst/boxinst_r50_fpn_ms-90k_coco/boxinst_r50_fpn_ms-90k_coco_20221228_163052-6add751a.pth + + - Name: boxinst_r101_fpn_ms-90k_coco + In Collection: BoxInst + Config: configs/boxinst/boxinst_r101_fpn_ms-90k_coco.py + Metadata: + Iterations: 90000 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 32.7 + Weights: https://download.openmmlab.com/mmdetection/v3.0/boxinst/boxinst_r101_fpn_ms-90k_coco/boxinst_r101_fpn_ms-90k_coco_20221229_145106-facf375b.pth diff --git a/mmdetection/configs/bytetrack/README.md b/mmdetection/configs/bytetrack/README.md new file mode 100644 index 00000000..30b96f07 --- /dev/null +++ b/mmdetection/configs/bytetrack/README.md @@ -0,0 +1,132 @@ +# ByteTrack: Multi-Object Tracking by Associating Every Detection Box + +## Abstract + + + +Multi-object tracking (MOT) aims at estimating bounding boxes and identities of objects in videos. Most methods obtain identities by associating detection boxes whose scores are higher than a threshold. The objects with low detection scores, e.g. occluded objects, are simply thrown away, which brings non-negligible true object missing and fragmented trajectories. To solve this problem, we present a simple, effective and generic association method, tracking by associating every detection box instead of only the high score ones. For the low score detection boxes, we utilize their similarities with tracklets to recover true objects and filter out the background detections. When applied to 9 different state-of-the-art trackers, our method achieves consistent improvement on IDF1 score ranging from 1 to 10 points. To put forwards the state-of-the-art performance of MOT, we design a simple and strong tracker, named ByteTrack. For the first time, we achieve 80.3 MOTA, 77.3 IDF1 and 63.1 HOTA on the test set of MOT17 with 30 FPS running speed on a single V100 GPU. + + + +
    + +
    + +## Citation + + + +```latex +@inproceedings{zhang2021bytetrack, + title={ByteTrack: Multi-Object Tracking by Associating Every Detection Box}, + author={Zhang, Yifu and Sun, Peize and Jiang, Yi and Yu, Dongdong and Yuan, Zehuan and Luo, Ping and Liu, Wenyu and Wang, Xinggang}, + journal={arXiv preprint arXiv:2110.06864}, + year={2021} +} +``` + +## Results and models on MOT17 + +Please note that the performance on `MOT17-half-val` is comparable with the performance reported in the manuscript, while the performance on `MOT17-test` is lower than the performance reported in the manuscript. + +The reason is that ByteTrack tunes customized hyper-parameters (e.g., image resolution and the high threshold of detection score) for each video in `MOT17-test` set, while we use unified parameters. + +| Method | Detector | Train Set | Test Set | Public | Inf time (fps) | HOTA | MOTA | IDF1 | FP | FN | IDSw. | Config | Download | +| :-------: | :------: | :---------------------------: | :------------: | :----: | :------------: | :--: | :--: | :--: | :---: | :---: | :---: | :-------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| ByteTrack | YOLOX-X | CrowdHuman + MOT17-half-train | MOT17-half-val | N | - | 67.5 | 78.6 | 78.5 | 12852 | 21060 | 672 | [config](bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval.py) | [model](https://download.openmmlab.com/mmtracking/mot/bytetrack/bytetrack_yolox_x/bytetrack_yolox_x_crowdhuman_mot17-private-half_20211218_205500-1985c9f0.pth) \| [log](https://download.openmmlab.com/mmtracking/mot/bytetrack/bytetrack_yolox_x/bytetrack_yolox_x_crowdhuman_mot17-private-half_20211218_205500.log.json) | +| ByteTrack | YOLOX-X | CrowdHuman + MOT17-half-train | MOT17-test | N | - | 61.7 | 78.1 | 74.8 | 36705 | 85032 | 2049 | [config](bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17test.py) | [model](https://download.openmmlab.com/mmtracking/mot/bytetrack/bytetrack_yolox_x/bytetrack_yolox_x_crowdhuman_mot17-private-half_20211218_205500-1985c9f0.pth) \| [log](https://download.openmmlab.com/mmtracking/mot/bytetrack/bytetrack_yolox_x/bytetrack_yolox_x_crowdhuman_mot17-private-half_20211218_205500.log.json) | + +## Results and models on MOT20 + +Since there are only 4 videos in `MOT20-train`, ByteTrack is validated on `MOT17-train` rather than `MOT20-half-train`. + +Please note that the MOTA on `MOT20-test` is slightly lower than that reported in the manuscript, because we don't tune the threshold for each video. + +| Method | Detector | Train Set | Test Set | Public | Inf time (fps) | HOTA | MOTA | IDF1 | FP | FN | IDSw. | Config | Download | +| :-------: | :------: | :----------------------: | :---------: | :----: | :------------: | :--: | :--: | :--: | :----: | :----: | :---: | :------------------------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| ByteTrack | YOLOX-X | CrowdHuman + MOT20-train | MOT17-train | N | - | 57.3 | 64.9 | 71.8 | 33,747 | 83,385 | 1,263 | [config](bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot20train_test-mot20test.py) | [model](https://download.openmmlab.com/mmtracking/mot/bytetrack/bytetrack_yolox_x/bytetrack_yolox_x_crowdhuman_mot20-private_20220506_101040-9ce38a60.pth) \| [log](https://download.openmmlab.com/mmtracking/mot/bytetrack/bytetrack_yolox_x/bytetrack_yolox_x_crowdhuman_mot20-private_20220506_101040.log.json) | +| ByteTrack | YOLOX-X | CrowdHuman + MOT20-train | MOT20-test | N | - | 61.5 | 77.0 | 75.4 | 33,083 | 84,433 | 1,345 | [config](bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot20train_test-mot20test.py) | [model](https://download.openmmlab.com/mmtracking/mot/bytetrack/bytetrack_yolox_x/bytetrack_yolox_x_crowdhuman_mot20-private_20220506_101040-9ce38a60.pth) \| [log](https://download.openmmlab.com/mmtracking/mot/bytetrack/bytetrack_yolox_x/bytetrack_yolox_x_crowdhuman_mot20-private_20220506_101040.log.json) | + +## Get started + +### 1. Development Environment Setup + +Tracking Development Environment Setup can refer to this [document](../../docs/en/get_started.md). + +### 2. Dataset Prepare + +Tracking Dataset Prepare can refer to this [document](../../docs/en/user_guides/tracking_dataset_prepare.md). + +### 3. Training + +Due to the influence of parameters such as learning rate in default configuration file, we recommend using 8 GPUs for training in order to reproduce accuracy. You can use the following command to start the training. + +**3.1 Joint training and tracking** + +Some algorithm like ByteTrack, OCSORT don't need reid model, so we provide joint training and tracking for convenient. + +```shell +# Training Bytetrack on crowdhuman and mot17-half-train dataset with following command +# The number after config file represents the number of GPUs used. Here we use 8 GPUs +bash tools/dist_train.sh configs/bytetrack/bytetrack_yolox_x_8xb4-80e_crowdhuman-mot17halftrain_test-mot17halfval.py 8 +``` + +**3.2 Separate training and tracking** + +Of course, we provide train detector independently like SORT, DeepSORT, StrongSORT. Then use this detector to track. + +```shell +# Training Bytetrack on crowdhuman and mot17-half-train dataset with following command +# The number after config file represents the number of GPUs used. Here we use 8 GPUs +bash tools/dist_train.sh configs/bytetrack/yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval.py 8 +``` + +If you want to know about more detailed usage of `train.py/dist_train.sh/slurm_train.sh`, +please refer to this [document](../../docs/en/user_guides/tracking_train_test.md). + +### 4. Testing and evaluation + +### 4.1 Example on MOTxx-halfval dataset + +**4.1.1 use joint trained detector to evaluating and testing** + +```shell +bash tools/dist_test_tracking.sh configs/bytetrack/bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval.py 8 --checkpoint ${CHECKPOINT_FILE} +``` + +**4.1.2 use separate trained detector to evaluating and testing** + +```shell +bash tools/dist_test_tracking.sh configs/bytetrack/bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval.py 8 --detector ${CHECKPOINT_FILE} +``` + +**4.1.3 use video_baesd to evaluating and testing** + +we also provide two_ways(img_based or video_based) to evaluating and testing. +if you want to use video_based to evaluating and testing, you can modify config as follows + +``` +val_dataloader = dict( + sampler=dict(type='DefaultSampler', shuffle=False, round_up=False)) +``` + +#### 4.2 Example on MOTxx-test dataset + +If you want to get the results of the [MOT Challenge](https://motchallenge.net/) test set, please use the following command to generate result files that can be used for submission. It will be stored in `./mot_17_test_res`, you can modify the saved path in `test_evaluator` of the config. + +```shell +bash tools/dist_test_tracking.sh configs/bytetrack/bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17test.py 8 --checkpoint ${CHECKPOINT_FILE} +``` + +If you want to know about more detailed usage of `test_tracking.py/dist_test_tracking.sh/slurm_test_tracking.sh`, +please refer to this [document](../../docs/en/user_guides/tracking_train_test.md). + +### 5.Inference + +Use a single GPU to predict a video and save it as a video. + +```shell +python demo/mot_demo.py demo/demo_mot.mp4 configs/bytetrack/bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval.py --checkpoint ${CHECKPOINT_FILE} --out mot.mp4 +``` + +If you want to know about more detailed usage of `mot_demo.py`, please refer to this [document](../../docs/en/user_guides/tracking_inference.md). diff --git a/mmdetection/configs/bytetrack/bytetrack_yolox_x_8xb4-80e_crowdhuman-mot17halftrain_test-mot17halfval.py b/mmdetection/configs/bytetrack/bytetrack_yolox_x_8xb4-80e_crowdhuman-mot17halftrain_test-mot17halfval.py new file mode 100644 index 00000000..24b3f784 --- /dev/null +++ b/mmdetection/configs/bytetrack/bytetrack_yolox_x_8xb4-80e_crowdhuman-mot17halftrain_test-mot17halfval.py @@ -0,0 +1,249 @@ +_base_ = ['../yolox/yolox_x_8xb8-300e_coco.py'] + +dataset_type = 'MOTChallengeDataset' +data_root = 'data/MOT17/' + +img_scale = (1440, 800) # weight, height +batch_size = 4 + +detector = _base_.model +detector.pop('data_preprocessor') +detector.bbox_head.update(dict(num_classes=1)) +detector.test_cfg.nms.update(dict(iou_threshold=0.7)) +detector['init_cfg'] = dict( + type='Pretrained', + checkpoint= # noqa: E251 + 'https://download.openmmlab.com/mmdetection/v2.0/yolox/yolox_x_8x8_300e_coco/yolox_x_8x8_300e_coco_20211126_140254-1ef88d67.pth' # noqa: E501 +) +del _base_.model + +model = dict( + type='ByteTrack', + data_preprocessor=dict( + type='TrackDataPreprocessor', + pad_size_divisor=32, + # in bytetrack, we provide joint train detector and evaluate tracking + # performance, use_det_processor means use independent detector + # data_preprocessor. of course, you can train detector independently + # like strongsort + use_det_processor=True, + batch_augments=[ + dict( + type='BatchSyncRandomResize', + random_size_range=(576, 1024), + size_divisor=32, + interval=10) + ]), + detector=detector, + tracker=dict( + type='ByteTracker', + motion=dict(type='KalmanFilter'), + obj_score_thrs=dict(high=0.6, low=0.1), + init_track_thr=0.7, + weight_iou_with_det_scores=True, + match_iou_thrs=dict(high=0.1, low=0.5, tentative=0.3), + num_frames_retain=30)) + +train_pipeline = [ + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + bbox_clip_border=False), + dict( + type='RandomAffine', + scaling_ratio_range=(0.1, 2), + border=(-img_scale[0] // 2, -img_scale[1] // 2), + bbox_clip_border=False), + dict( + type='MixUp', + img_scale=img_scale, + ratio_range=(0.8, 1.6), + pad_val=114.0, + bbox_clip_border=False), + dict(type='YOLOXHSVRandomAug'), + dict(type='RandomFlip', prob=0.5), + dict( + type='Resize', + scale=img_scale, + keep_ratio=True, + clip_object_border=False), + dict(type='Pad', size_divisor=32, pad_val=dict(img=(114.0, 114.0, 114.0))), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1, 1), keep_empty=False), + dict(type='PackDetInputs') +] + +test_pipeline = [ + dict( + type='TransformBroadcaster', + transforms=[ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='Resize', scale=img_scale, keep_ratio=True), + dict( + type='Pad', + size_divisor=32, + pad_val=dict(img=(114.0, 114.0, 114.0))), + dict(type='LoadTrackAnnotations'), + ]), + dict(type='PackTrackInputs') +] +train_dataloader = dict( + _delete_=True, + batch_size=batch_size, + num_workers=4, + persistent_workers=True, + pin_memory=True, + sampler=dict(type='DefaultSampler', shuffle=True), + dataset=dict( + type='MultiImageMixDataset', + dataset=dict( + type='ConcatDataset', + datasets=[ + dict( + type='CocoDataset', + data_root='data/MOT17', + ann_file='annotations/half-train_cocoformat.json', + data_prefix=dict(img='train'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + metainfo=dict(classes=('pedestrian', )), + pipeline=[ + dict( + type='LoadImageFromFile', + backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + ]), + dict( + type='CocoDataset', + data_root='data/crowdhuman', + ann_file='annotations/crowdhuman_train.json', + data_prefix=dict(img='train'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + metainfo=dict(classes=('pedestrian', )), + pipeline=[ + dict( + type='LoadImageFromFile', + backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + ]), + dict( + type='CocoDataset', + data_root='data/crowdhuman', + ann_file='annotations/crowdhuman_val.json', + data_prefix=dict(img='val'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + metainfo=dict(classes=('pedestrian', )), + pipeline=[ + dict( + type='LoadImageFromFile', + backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + ]), + ]), + pipeline=train_pipeline)) + +val_dataloader = dict( + _delete_=True, + batch_size=1, + num_workers=2, + persistent_workers=True, + pin_memory=True, + drop_last=False, + # video_based + # sampler=dict(type='DefaultSampler', shuffle=False, round_up=False), + sampler=dict(type='TrackImgSampler'), # image_based + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/half-val_cocoformat.json', + data_prefix=dict(img_path='train'), + test_mode=True, + pipeline=test_pipeline)) +test_dataloader = val_dataloader + +# optimizer +# default 8 gpu +base_lr = 0.001 / 8 * batch_size +optim_wrapper = dict(optimizer=dict(lr=base_lr)) + +# some hyper parameters +# training settings +max_epochs = 80 +num_last_epochs = 10 +interval = 5 + +train_cfg = dict( + type='EpochBasedTrainLoop', + max_epochs=max_epochs, + val_begin=70, + val_interval=1) + +# learning policy +param_scheduler = [ + dict( + # use quadratic formula to warm up 1 epochs + type='QuadraticWarmupLR', + by_epoch=True, + begin=0, + end=1, + convert_to_iter_based=True), + dict( + # use cosine lr from 1 to 70 epoch + type='CosineAnnealingLR', + eta_min=base_lr * 0.05, + begin=1, + T_max=max_epochs - num_last_epochs, + end=max_epochs - num_last_epochs, + by_epoch=True, + convert_to_iter_based=True), + dict( + # use fixed lr during last 10 epochs + type='ConstantLR', + by_epoch=True, + factor=1, + begin=max_epochs - num_last_epochs, + end=max_epochs, + ) +] + +custom_hooks = [ + dict( + type='YOLOXModeSwitchHook', + num_last_epochs=num_last_epochs, + priority=48), + dict(type='SyncNormHook', priority=48), + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + priority=49) +] + +default_hooks = dict( + checkpoint=dict( + _delete_=True, type='CheckpointHook', interval=1, max_keep_ckpts=10), + visualization=dict(type='TrackVisualizationHook', draw=False)) + +vis_backends = [dict(type='LocalVisBackend')] +visualizer = dict( + type='TrackLocalVisualizer', vis_backends=vis_backends, name='visualizer') + +# evaluator +val_evaluator = dict( + _delete_=True, + type='MOTChallengeMetric', + metric=['HOTA', 'CLEAR', 'Identity'], + postprocess_tracklet_cfg=[ + dict(type='InterpolateTracklets', min_num_frames=5, max_num_frames=20) + ]) +test_evaluator = val_evaluator + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (4 samples per GPU) +auto_scale_lr = dict(base_batch_size=32) + +del detector +del _base_.tta_model +del _base_.tta_pipeline +del _base_.train_dataset diff --git a/mmdetection/configs/bytetrack/bytetrack_yolox_x_8xb4-80e_crowdhuman-mot20train_test-mot20test.py b/mmdetection/configs/bytetrack/bytetrack_yolox_x_8xb4-80e_crowdhuman-mot20train_test-mot20test.py new file mode 100644 index 00000000..9202f5fb --- /dev/null +++ b/mmdetection/configs/bytetrack/bytetrack_yolox_x_8xb4-80e_crowdhuman-mot20train_test-mot20test.py @@ -0,0 +1,127 @@ +_base_ = [ + './bytetrack_yolox_x_8xb4-80e_crowdhuman-mot17halftrain_' + 'test-mot17halfval.py' +] + +dataset_type = 'MOTChallengeDataset' + +img_scale = (1600, 896) # weight, height + +model = dict( + data_preprocessor=dict( + type='TrackDataPreprocessor', + use_det_processor=True, + pad_size_divisor=32, + batch_augments=[ + dict(type='BatchSyncRandomResize', random_size_range=(640, 1152)) + ]), + tracker=dict( + weight_iou_with_det_scores=False, + match_iou_thrs=dict(high=0.3), + )) + +train_pipeline = [ + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + bbox_clip_border=True), + dict( + type='RandomAffine', + scaling_ratio_range=(0.1, 2), + border=(-img_scale[0] // 2, -img_scale[1] // 2), + bbox_clip_border=True), + dict( + type='MixUp', + img_scale=img_scale, + ratio_range=(0.8, 1.6), + pad_val=114.0, + bbox_clip_border=True), + dict(type='YOLOXHSVRandomAug'), + dict(type='RandomFlip', prob=0.5), + dict( + type='Resize', + scale=img_scale, + keep_ratio=True, + clip_object_border=True), + dict(type='Pad', size_divisor=32, pad_val=dict(img=(114.0, 114.0, 114.0))), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1, 1), keep_empty=False), + dict(type='PackDetInputs') +] + +test_pipeline = [ + dict( + type='TransformBroadcaster', + transforms=[ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='Resize', scale=img_scale, keep_ratio=True), + dict( + type='Pad', + size_divisor=32, + pad_val=dict(img=(114.0, 114.0, 114.0))), + dict(type='LoadTrackAnnotations'), + ]), + dict(type='PackTrackInputs') +] +train_dataloader = dict( + dataset=dict( + type='MultiImageMixDataset', + dataset=dict( + type='ConcatDataset', + datasets=[ + dict( + type='CocoDataset', + data_root='data/MOT20', + ann_file='annotations/train_cocoformat.json', + # TODO: mmdet use img as key, but img_path is needed + data_prefix=dict(img='train'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + metainfo=dict(classes=('pedestrian', )), + pipeline=[ + dict( + type='LoadImageFromFile', + backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + ]), + dict( + type='CocoDataset', + data_root='data/crowdhuman', + ann_file='annotations/crowdhuman_train.json', + data_prefix=dict(img='train'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + metainfo=dict(classes=('pedestrian', )), + pipeline=[ + dict( + type='LoadImageFromFile', + backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + ]), + dict( + type='CocoDataset', + data_root='data/crowdhuman', + ann_file='annotations/crowdhuman_val.json', + data_prefix=dict(img='val'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + metainfo=dict(classes=('pedestrian', )), + pipeline=[ + dict( + type='LoadImageFromFile', + backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + ]), + ]), + pipeline=train_pipeline)) +val_dataloader = dict( + dataset=dict(ann_file='annotations/train_cocoformat.json')) + +test_dataloader = dict( + dataset=dict( + data_root='data/MOT20', ann_file='annotations/test_cocoformat.json')) + +test_evaluator = dict( + type='MOTChallengeMetrics', + postprocess_tracklet_cfg=[ + dict(type='InterpolateTracklets', min_num_frames=5, max_num_frames=20) + ], + format_only=True, + outfile_prefix='./mot_20_test_res') diff --git a/mmdetection/configs/bytetrack/bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval.py b/mmdetection/configs/bytetrack/bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval.py new file mode 100644 index 00000000..9c211920 --- /dev/null +++ b/mmdetection/configs/bytetrack/bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval.py @@ -0,0 +1,9 @@ +_base_ = [ + './bytetrack_yolox_x_8xb4-80e_crowdhuman-mot17halftrain_' + 'test-mot17halfval.py' +] + +# fp16 settings +optim_wrapper = dict(type='AmpOptimWrapper', loss_scale='dynamic') +val_cfg = dict(type='ValLoop', fp16=True) +test_cfg = dict(type='TestLoop', fp16=True) diff --git a/mmdetection/configs/bytetrack/bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17test.py b/mmdetection/configs/bytetrack/bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17test.py new file mode 100644 index 00000000..3f4427c1 --- /dev/null +++ b/mmdetection/configs/bytetrack/bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17test.py @@ -0,0 +1,17 @@ +_base_ = [ + './bytetrack/bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-' + 'mot17halftrain_test-mot17halfval.py' +] + +test_dataloader = dict( + dataset=dict( + data_root='data/MOT17/', + ann_file='annotations/test_cocoformat.json', + data_prefix=dict(img_path='test'))) +test_evaluator = dict( + type='MOTChallengeMetrics', + postprocess_tracklet_cfg=[ + dict(type='InterpolateTracklets', min_num_frames=5, max_num_frames=20) + ], + format_only=True, + outfile_prefix='./mot_17_test_res') diff --git a/mmdetection/configs/bytetrack/bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot20train_test-mot20test.py b/mmdetection/configs/bytetrack/bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot20train_test-mot20test.py new file mode 100644 index 00000000..10169997 --- /dev/null +++ b/mmdetection/configs/bytetrack/bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot20train_test-mot20test.py @@ -0,0 +1,8 @@ +_base_ = [ + './bytetrack_yolox_x_8xb4-80e_crowdhuman-mot20train_test-mot20test.py' +] + +# fp16 settings +optim_wrapper = dict(type='AmpOptimWrapper', loss_scale='dynamic') +val_cfg = dict(type='ValLoop', fp16=True) +test_cfg = dict(type='TestLoop', fp16=True) diff --git a/mmdetection/configs/bytetrack/metafile.yml b/mmdetection/configs/bytetrack/metafile.yml new file mode 100644 index 00000000..8ed638cf --- /dev/null +++ b/mmdetection/configs/bytetrack/metafile.yml @@ -0,0 +1,53 @@ +Collections: + - Name: ByteTrack + Metadata: + Training Techniques: + - SGD with Momentum + Training Resources: 8x V100 GPUs + Architecture: + - YOLOX + Paper: + URL: https://arxiv.org/abs/2110.06864 + Title: ByteTrack Multi-Object Tracking by Associating Every Detection Box + README: configs/bytetrack/README.md + +Models: + - Name: bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval + In Collection: ByteTrack + Config: configs/bytetrack/bytetrack_yolox_x_8xb4-80e_crowdhuman-mot17halftrain_test-mot17halfval.py + Metadata: + Training Data: CrowdHuman + MOT17-half-train + Results: + - Task: Multiple Object Tracking + Dataset: MOT17-half-val + Metrics: + HOTA: 67.5 + MOTA: 78.6 + IDF1: 78.5 + Weights: https://download.openmmlab.com/mmtracking/mot/bytetrack/bytetrack_yolox_x/bytetrack_yolox_x_crowdhuman_mot17-private-half_20211218_205500-1985c9f0.pth + + - Name: bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17test + In Collection: ByteTrack + Config: configs/bytetrack/bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17test.py + Metadata: + Training Data: CrowdHuman + MOT17-half-train + Results: + - Task: Multiple Object Tracking + Dataset: MOT17-test + Metrics: + MOTA: 78.1 + IDF1: 74.8 + Weights: https://download.openmmlab.com/mmtracking/mot/bytetrack/bytetrack_yolox_x/bytetrack_yolox_x_crowdhuman_mot17-private-half_20211218_205500-1985c9f0.pth + + - Name: bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot20train_test-mot20test + In Collection: ByteTrack + Config: configs/bytetrack/bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot20train_test-mot20test.py + Metadata: + Training Data: CrowdHuman + MOT20-train + Results: + - Task: Multiple Object Tracking + Dataset: MOT20-test + Metrics: + MOTA: 77.0 + IDF1: 75.4 + Weights: https://download.openmmlab.com/mmtracking/mot/bytetrack/bytetrack_yolox_x/bytetrack_yolox_x_crowdhuman_mot20-private_20220506_101040-9ce38a60.pth diff --git a/mmdetection/configs/bytetrack/yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval.py b/mmdetection/configs/bytetrack/yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval.py new file mode 100644 index 00000000..8fc3acd4 --- /dev/null +++ b/mmdetection/configs/bytetrack/yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval.py @@ -0,0 +1,6 @@ +_base_ = [ + '../strongsort/yolox_x_8xb4-80e_crowdhuman-mot17halftrain_test-mot17halfval.py' # noqa: E501 +] + +# fp16 settings +optim_wrapper = dict(type='AmpOptimWrapper', loss_scale='dynamic') diff --git a/mmdetection/configs/carafe/README.md b/mmdetection/configs/carafe/README.md new file mode 100644 index 00000000..61e1fa60 --- /dev/null +++ b/mmdetection/configs/carafe/README.md @@ -0,0 +1,42 @@ +# CARAFE + +> [CARAFE: Content-Aware ReAssembly of FEatures](https://arxiv.org/abs/1905.02188) + + + +## Abstract + +Feature upsampling is a key operation in a number of modern convolutional network architectures, e.g. feature pyramids. Its design is critical for dense prediction tasks such as object detection and semantic/instance segmentation. In this work, we propose Content-Aware ReAssembly of FEatures (CARAFE), a universal, lightweight and highly effective operator to fulfill this goal. CARAFE has several appealing properties: (1) Large field of view. Unlike previous works (e.g. bilinear interpolation) that only exploit sub-pixel neighborhood, CARAFE can aggregate contextual information within a large receptive field. (2) Content-aware handling. Instead of using a fixed kernel for all samples (e.g. deconvolution), CARAFE enables instance-specific content-aware handling, which generates adaptive kernels on-the-fly. (3) Lightweight and fast to compute. CARAFE introduces little computational overhead and can be readily integrated into modern network architectures. We conduct comprehensive evaluations on standard benchmarks in object detection, instance/semantic segmentation and inpainting. CARAFE shows consistent and substantial gains across all the tasks (1.2%, 1.3%, 1.8%, 1.1db respectively) with negligible computational overhead. It has great potential to serve as a strong building block for future research. It has great potential to serve as a strong building block for future research. + +
    + +
    + +## Results and Models + +The results on COCO 2017 val is shown in the below table. + +| Method | Backbone | Style | Lr schd | Test Proposal Num | Inf time (fps) | Box AP | Mask AP | Config | Download | +| :--------------------: | :------: | :-----: | :-----: | :---------------: | :------------: | :----: | :-----: | :-----------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| Faster R-CNN w/ CARAFE | R-50-FPN | pytorch | 1x | 1000 | 16.5 | 38.6 | 38.6 | [config](./faster-rcnn_r50_fpn-carafe_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/carafe/faster_rcnn_r50_fpn_carafe_1x_coco/faster_rcnn_r50_fpn_carafe_1x_coco_bbox_mAP-0.386_20200504_175733-385a75b7.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/carafe/faster_rcnn_r50_fpn_carafe_1x_coco/faster_rcnn_r50_fpn_carafe_1x_coco_20200504_175733.log.json) | +| - | - | - | - | 2000 | | | | | | +| Mask R-CNN w/ CARAFE | R-50-FPN | pytorch | 1x | 1000 | 14.0 | 39.3 | 35.8 | [config](./mask-rcnn_r50_fpn-carafe_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/carafe/mask_rcnn_r50_fpn_carafe_1x_coco/mask_rcnn_r50_fpn_carafe_1x_coco_bbox_mAP-0.393__segm_mAP-0.358_20200503_135957-8687f195.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/carafe/mask_rcnn_r50_fpn_carafe_1x_coco/mask_rcnn_r50_fpn_carafe_1x_coco_20200503_135957.log.json) | +| - | - | - | - | 2000 | | | | | | + +## Implementation + +The CUDA implementation of CARAFE can be find at https://github.com/myownskyW7/CARAFE. + +## Citation + +We provide config files to reproduce the object detection & instance segmentation results in the ICCV 2019 Oral paper for [CARAFE: Content-Aware ReAssembly of FEatures](https://arxiv.org/abs/1905.02188). + +```latex +@inproceedings{Wang_2019_ICCV, + title = {CARAFE: Content-Aware ReAssembly of FEatures}, + author = {Wang, Jiaqi and Chen, Kai and Xu, Rui and Liu, Ziwei and Loy, Chen Change and Lin, Dahua}, + booktitle = {The IEEE International Conference on Computer Vision (ICCV)}, + month = {October}, + year = {2019} +} +``` diff --git a/mmdetection/configs/carafe/faster-rcnn_r50_fpn-carafe_1x_coco.py b/mmdetection/configs/carafe/faster-rcnn_r50_fpn-carafe_1x_coco.py new file mode 100644 index 00000000..388305cc --- /dev/null +++ b/mmdetection/configs/carafe/faster-rcnn_r50_fpn-carafe_1x_coco.py @@ -0,0 +1,20 @@ +_base_ = '../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + data_preprocessor=dict(pad_size_divisor=64), + neck=dict( + type='FPN_CARAFE', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + num_outs=5, + start_level=0, + end_level=-1, + norm_cfg=None, + act_cfg=None, + order=('conv', 'norm', 'act'), + upsample_cfg=dict( + type='carafe', + up_kernel=5, + up_group=1, + encoder_kernel=3, + encoder_dilation=1, + compressed_channels=64))) diff --git a/mmdetection/configs/carafe/mask-rcnn_r50_fpn-carafe_1x_coco.py b/mmdetection/configs/carafe/mask-rcnn_r50_fpn-carafe_1x_coco.py new file mode 100644 index 00000000..6ce621de --- /dev/null +++ b/mmdetection/configs/carafe/mask-rcnn_r50_fpn-carafe_1x_coco.py @@ -0,0 +1,30 @@ +_base_ = '../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py' +model = dict( + data_preprocessor=dict(pad_size_divisor=64), + neck=dict( + type='FPN_CARAFE', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + num_outs=5, + start_level=0, + end_level=-1, + norm_cfg=None, + act_cfg=None, + order=('conv', 'norm', 'act'), + upsample_cfg=dict( + type='carafe', + up_kernel=5, + up_group=1, + encoder_kernel=3, + encoder_dilation=1, + compressed_channels=64)), + roi_head=dict( + mask_head=dict( + upsample_cfg=dict( + type='carafe', + scale_factor=2, + up_kernel=5, + up_group=1, + encoder_kernel=3, + encoder_dilation=1, + compressed_channels=64)))) diff --git a/mmdetection/configs/carafe/metafile.yml b/mmdetection/configs/carafe/metafile.yml new file mode 100644 index 00000000..863c0f49 --- /dev/null +++ b/mmdetection/configs/carafe/metafile.yml @@ -0,0 +1,55 @@ +Collections: + - Name: CARAFE + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RPN + - FPN_CARAFE + - ResNet + - RoIPool + Paper: + URL: https://arxiv.org/abs/1905.02188 + Title: 'CARAFE: Content-Aware ReAssembly of FEatures' + README: configs/carafe/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.12.0/mmdet/models/necks/fpn_carafe.py#L11 + Version: v2.12.0 + +Models: + - Name: faster-rcnn_r50_fpn_carafe_1x_coco + In Collection: CARAFE + Config: configs/carafe/faster-rcnn_r50_fpn-carafe_1x_coco.py + Metadata: + Training Memory (GB): 4.26 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.6 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/carafe/faster_rcnn_r50_fpn_carafe_1x_coco/faster_rcnn_r50_fpn_carafe_1x_coco_bbox_mAP-0.386_20200504_175733-385a75b7.pth + + - Name: mask-rcnn_r50_fpn_carafe_1x_coco + In Collection: CARAFE + Config: configs/carafe/mask-rcnn_r50_fpn-carafe_1x_coco.py + Metadata: + Training Memory (GB): 4.31 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.3 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 35.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/carafe/mask_rcnn_r50_fpn_carafe_1x_coco/mask_rcnn_r50_fpn_carafe_1x_coco_bbox_mAP-0.393__segm_mAP-0.358_20200503_135957-8687f195.pth diff --git a/mmdetection/configs/cascade_rcnn/README.md b/mmdetection/configs/cascade_rcnn/README.md new file mode 100644 index 00000000..81fce448 --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/README.md @@ -0,0 +1,79 @@ +# Cascade R-CNN + +> [Cascade R-CNN: High Quality Object Detection and Instance Segmentation](https://arxiv.org/abs/1906.09756) + + + +## Abstract + +In object detection, the intersection over union (IoU) threshold is frequently used to define positives/negatives. The threshold used to train a detector defines its quality. While the commonly used threshold of 0.5 leads to noisy (low-quality) detections, detection performance frequently degrades for larger thresholds. This paradox of high-quality detection has two causes: 1) overfitting, due to vanishing positive samples for large thresholds, and 2) inference-time quality mismatch between detector and test hypotheses. A multi-stage object detection architecture, the Cascade R-CNN, composed of a sequence of detectors trained with increasing IoU thresholds, is proposed to address these problems. The detectors are trained sequentially, using the output of a detector as training set for the next. This resampling progressively improves hypotheses quality, guaranteeing a positive training set of equivalent size for all detectors and minimizing overfitting. The same cascade is applied at inference, to eliminate quality mismatches between hypotheses and detectors. An implementation of the Cascade R-CNN without bells or whistles achieves state-of-the-art performance on the COCO dataset, and significantly improves high-quality detection on generic and specific object detection datasets, including VOC, KITTI, CityPerson, and WiderFace. Finally, the Cascade R-CNN is generalized to instance segmentation, with nontrivial improvements over the Mask R-CNN. + +
    + +
    + +## Results and Models + +### Cascade R-CNN + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :-------------: | :-----: | :-----: | :------: | :------------: | :----: | :-------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | caffe | 1x | 4.2 | | 40.4 | [config](./cascade-rcnn_r50-caffe_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r50_caffe_fpn_1x_coco/cascade_rcnn_r50_caffe_fpn_1x_coco_bbox_mAP-0.404_20200504_174853-b857be87.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r50_caffe_fpn_1x_coco/cascade_rcnn_r50_caffe_fpn_1x_coco_20200504_174853.log.json) | +| R-50-FPN | pytorch | 1x | 4.4 | 16.1 | 40.3 | [config](./cascade-rcnn_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r50_fpn_1x_coco/cascade_rcnn_r50_fpn_1x_coco_20200316-3dc56deb.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r50_fpn_1x_coco/cascade_rcnn_r50_fpn_1x_coco_20200316_214748.log.json) | +| R-50-FPN | pytorch | 20e | - | - | 41.0 | [config](./cascade-rcnn_r50_fpn_20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r50_fpn_20e_coco/cascade_rcnn_r50_fpn_20e_coco_bbox_mAP-0.41_20200504_175131-e9872a90.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r50_fpn_20e_coco/cascade_rcnn_r50_fpn_20e_coco_20200504_175131.log.json) | +| R-101-FPN | caffe | 1x | 6.2 | | 42.3 | [config](./cascade-rcnn_r101-caffe_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r101_caffe_fpn_1x_coco/cascade_rcnn_r101_caffe_fpn_1x_coco_bbox_mAP-0.423_20200504_175649-cab8dbd5.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r101_caffe_fpn_1x_coco/cascade_rcnn_r101_caffe_fpn_1x_coco_20200504_175649.log.json) | +| R-101-FPN | pytorch | 1x | 6.4 | 13.5 | 42.0 | [config](./cascade-rcnn_r101_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r101_fpn_1x_coco/cascade_rcnn_r101_fpn_1x_coco_20200317-0b6a2fbf.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r101_fpn_1x_coco/cascade_rcnn_r101_fpn_1x_coco_20200317_101744.log.json) | +| R-101-FPN | pytorch | 20e | - | - | 42.5 | [config](./cascade-rcnn_r101_fpn_20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r101_fpn_20e_coco/cascade_rcnn_r101_fpn_20e_coco_bbox_mAP-0.425_20200504_231812-5057dcc5.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r101_fpn_20e_coco/cascade_rcnn_r101_fpn_20e_coco_20200504_231812.log.json) | +| X-101-32x4d-FPN | pytorch | 1x | 7.6 | 10.9 | 43.7 | [config](./cascade-rcnn_x101-32x4d_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_x101_32x4d_fpn_1x_coco/cascade_rcnn_x101_32x4d_fpn_1x_coco_20200316-95c2deb6.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_x101_32x4d_fpn_1x_coco/cascade_rcnn_x101_32x4d_fpn_1x_coco_20200316_055608.log.json) | +| X-101-32x4d-FPN | pytorch | 20e | 7.6 | | 43.7 | [config](./cascade-rcnn_x101-32x4d_fpn_20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_x101_32x4d_fpn_20e_coco/cascade_rcnn_x101_32x4d_fpn_20e_coco_20200906_134608-9ae0a720.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_x101_32x4d_fpn_20e_coco/cascade_rcnn_x101_32x4d_fpn_20e_coco_20200906_134608.log.json) | +| X-101-64x4d-FPN | pytorch | 1x | 10.7 | | 44.7 | [config](./cascade-rcnn_x101-64x4d_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_x101_64x4d_fpn_1x_coco/cascade_rcnn_x101_64x4d_fpn_1x_coco_20200515_075702-43ce6a30.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_x101_64x4d_fpn_1x_coco/cascade_rcnn_x101_64x4d_fpn_1x_coco_20200515_075702.log.json) | +| X-101-64x4d-FPN | pytorch | 20e | 10.7 | | 44.5 | [config](./cascade-rcnn_x101_64x4d_fpn_20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_x101_64x4d_fpn_20e_coco/cascade_rcnn_x101_64x4d_fpn_20e_coco_20200509_224357-051557b1.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_x101_64x4d_fpn_20e_coco/cascade_rcnn_x101_64x4d_fpn_20e_coco_20200509_224357.log.json) | + +### Cascade Mask R-CNN + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :-------------: | :-----: | :-----: | :------: | :------------: | :----: | :-----: | :------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | caffe | 1x | 5.9 | | 41.2 | 36.0 | [config](./cascade-mask-rcnn_r50-caffe_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_caffe_fpn_1x_coco/cascade_mask_rcnn_r50_caffe_fpn_1x_coco_bbox_mAP-0.412__segm_mAP-0.36_20200504_174659-5004b251.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_caffe_fpn_1x_coco/cascade_mask_rcnn_r50_caffe_fpn_1x_coco_20200504_174659.log.json) | +| R-50-FPN | pytorch | 1x | 6.0 | 11.2 | 41.2 | 35.9 | [config](./cascade-mask-rcnn_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco/cascade_mask_rcnn_r50_fpn_1x_coco_20200203-9d4dcb24.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco/cascade_mask_rcnn_r50_fpn_1x_coco_20200203_170449.log.json) | +| R-50-FPN | pytorch | 20e | - | - | 41.9 | 36.5 | [config](./cascade-mask-rcnn_r50_fpn_20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_fpn_20e_coco/cascade_mask_rcnn_r50_fpn_20e_coco_bbox_mAP-0.419__segm_mAP-0.365_20200504_174711-4af8e66e.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_fpn_20e_coco/cascade_mask_rcnn_r50_fpn_20e_coco_20200504_174711.log.json) | +| R-101-FPN | caffe | 1x | 7.8 | | 43.2 | 37.6 | [config](./cascade-mask-rcnn_r101-caffe_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r101_caffe_fpn_1x_coco/cascade_mask_rcnn_r101_caffe_fpn_1x_coco_bbox_mAP-0.432__segm_mAP-0.376_20200504_174813-5c1e9599.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r101_caffe_fpn_1x_coco/cascade_mask_rcnn_r101_caffe_fpn_1x_coco_20200504_174813.log.json) | +| R-101-FPN | pytorch | 1x | 7.9 | 9.8 | 42.9 | 37.3 | [config](./cascade-mask-rcnn_r101_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r101_fpn_1x_coco/cascade_mask_rcnn_r101_fpn_1x_coco_20200203-befdf6ee.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r101_fpn_1x_coco/cascade_mask_rcnn_r101_fpn_1x_coco_20200203_092521.log.json) | +| R-101-FPN | pytorch | 20e | - | - | 43.4 | 37.8 | [config](./cascade-mask-rcnn_r101_fpn_20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r101_fpn_20e_coco/cascade_mask_rcnn_r101_fpn_20e_coco_bbox_mAP-0.434__segm_mAP-0.378_20200504_174836-005947da.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r101_fpn_20e_coco/cascade_mask_rcnn_r101_fpn_20e_coco_20200504_174836.log.json) | +| X-101-32x4d-FPN | pytorch | 1x | 9.2 | 8.6 | 44.3 | 38.3 | [config](./cascade-mask-rcnn_x101-32x4d_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_32x4d_fpn_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_1x_coco_20200201-0f411b1f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_32x4d_fpn_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_1x_coco_20200201_052416.log.json) | +| X-101-32x4d-FPN | pytorch | 20e | 9.2 | - | 45.0 | 39.0 | [config](./cascade-mask-rcnn_x101-32x4d_fpn_20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_32x4d_fpn_20e_coco/cascade_mask_rcnn_x101_32x4d_fpn_20e_coco_20200528_083917-ed1f4751.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_32x4d_fpn_20e_coco/cascade_mask_rcnn_x101_32x4d_fpn_20e_coco_20200528_083917.log.json) | +| X-101-64x4d-FPN | pytorch | 1x | 12.2 | 6.7 | 45.3 | 39.2 | [config](./cascade-mask-rcnn_x101-64x4d_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_64x4d_fpn_1x_coco/cascade_mask_rcnn_x101_64x4d_fpn_1x_coco_20200203-9a2db89d.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_64x4d_fpn_1x_coco/cascade_mask_rcnn_x101_64x4d_fpn_1x_coco_20200203_044059.log.json) | +| X-101-64x4d-FPN | pytorch | 20e | 12.2 | | 45.6 | 39.5 | [config](./cascade-mask-rcnn_x101-64x4d_fpn_20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_64x4d_fpn_20e_coco/cascade_mask_rcnn_x101_64x4d_fpn_20e_coco_20200512_161033-bdb5126a.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_64x4d_fpn_20e_coco/cascade_mask_rcnn_x101_64x4d_fpn_20e_coco_20200512_161033.log.json) | + +**Notes:** + +- The `20e` schedule in Cascade (Mask) R-CNN indicates decreasing the lr at 16 and 19 epochs, with a total of 20 epochs. + +## Pre-trained Models + +We also train some models with longer schedules and multi-scale training for Cascade Mask R-CNN. The users could finetune them for downstream tasks. + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :-------------: | :-----: | :-----: | :------: | :------------: | :----: | :-----: | :--------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | caffe | 3x | 5.7 | | 44.0 | 38.1 | [config](./cascade-mask-rcnn_r50-caffe_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_caffe_fpn_mstrain_3x_coco/cascade_mask_rcnn_r50_caffe_fpn_mstrain_3x_coco_20210707_002651-6e29b3a6.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_caffe_fpn_mstrain_3x_coco/cascade_mask_rcnn_r50_caffe_fpn_mstrain_3x_coco_20210707_002651.log.json) | +| R-50-FPN | pytorch | 3x | 5.9 | | 44.3 | 38.5 | [config](./cascade-mask-rcnn_r50_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_fpn_mstrain_3x_coco/cascade_mask_rcnn_r50_fpn_mstrain_3x_coco_20210628_164719-5bdc3824.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_fpn_mstrain_3x_coco/cascade_mask_rcnn_r50_fpn_mstrain_3x_coco_20210628_164719.log.json) | +| R-101-FPN | caffe | 3x | 7.7 | | 45.4 | 39.5 | [config](./cascade-mask-rcnn_r101-caffe_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r101_caffe_fpn_mstrain_3x_coco/cascade_mask_rcnn_r101_caffe_fpn_mstrain_3x_coco_20210707_002620-a5bd2389.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r101_caffe_fpn_mstrain_3x_coco/cascade_mask_rcnn_r101_caffe_fpn_mstrain_3x_coco_20210707_002620.log.json) | +| R-101-FPN | pytorch | 3x | 7.8 | | 45.5 | 39.6 | [config](./cascade-mask-rcnn_r101_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r101_fpn_mstrain_3x_coco/cascade_mask_rcnn_r101_fpn_mstrain_3x_coco_20210628_165236-51a2d363.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r101_fpn_mstrain_3x_coco/cascade_mask_rcnn_r101_fpn_mstrain_3x_coco_20210628_165236.log.json) | +| X-101-32x4d-FPN | pytorch | 3x | 9.0 | | 46.3 | 40.1 | [config](./cascade-mask-rcnn_x101-32x4d_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_32x4d_fpn_mstrain_3x_coco/cascade_mask_rcnn_x101_32x4d_fpn_mstrain_3x_coco_20210706_225234-40773067.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_32x4d_fpn_mstrain_3x_coco/cascade_mask_rcnn_x101_32x4d_fpn_mstrain_3x_coco_20210706_225234.log.json) | +| X-101-32x8d-FPN | pytorch | 3x | 12.1 | | 46.1 | 39.9 | [config](./cascade-mask-rcnn_x101-32x8d_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_32x8d_fpn_mstrain_3x_coco/cascade_mask_rcnn_x101_32x8d_fpn_mstrain_3x_coco_20210719_180640-9ff7e76f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_32x8d_fpn_mstrain_3x_coco/cascade_mask_rcnn_x101_32x8d_fpn_mstrain_3x_coco_20210719_180640.log.json) | +| X-101-64x4d-FPN | pytorch | 3x | 12.0 | | 46.6 | 40.3 | [config](./cascade-mask-rcnn_x101-64x4d_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_64x4d_fpn_mstrain_3x_coco/cascade_mask_rcnn_x101_64x4d_fpn_mstrain_3x_coco_20210719_210311-d3e64ba0.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_64x4d_fpn_mstrain_3x_coco/cascade_mask_rcnn_x101_64x4d_fpn_mstrain_3x_coco_20210719_210311.log.json) | + +## Citation + +```latex +@article{Cai_2019, + title={Cascade R-CNN: High Quality Object Detection and Instance Segmentation}, + ISSN={1939-3539}, + url={http://dx.doi.org/10.1109/tpami.2019.2956516}, + DOI={10.1109/tpami.2019.2956516}, + journal={IEEE Transactions on Pattern Analysis and Machine Intelligence}, + publisher={Institute of Electrical and Electronics Engineers (IEEE)}, + author={Cai, Zhaowei and Vasconcelos, Nuno}, + year={2019}, + pages={1–1} +} +``` diff --git a/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r101-caffe_fpn_1x_coco.py b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r101-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..6d85340e --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r101-caffe_fpn_1x_coco.py @@ -0,0 +1,7 @@ +_base_ = './cascade-mask-rcnn_r50-caffe_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet101_caffe'))) diff --git a/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r101-caffe_fpn_ms-3x_coco.py b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r101-caffe_fpn_ms-3x_coco.py new file mode 100644 index 00000000..a6855ee8 --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r101-caffe_fpn_ms-3x_coco.py @@ -0,0 +1,7 @@ +_base_ = './cascade-mask-rcnn_r50-caffe_fpn_ms-3x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet101_caffe'))) diff --git a/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r101_fpn_1x_coco.py b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r101_fpn_1x_coco.py new file mode 100644 index 00000000..c3d962c2 --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r101_fpn_1x_coco.py @@ -0,0 +1,6 @@ +_base_ = './cascade-mask-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r101_fpn_20e_coco.py b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r101_fpn_20e_coco.py new file mode 100644 index 00000000..497148f5 --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r101_fpn_20e_coco.py @@ -0,0 +1,6 @@ +_base_ = './cascade-mask-rcnn_r50_fpn_20e_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r101_fpn_ms-3x_coco.py b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r101_fpn_ms-3x_coco.py new file mode 100644 index 00000000..183b5c50 --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r101_fpn_ms-3x_coco.py @@ -0,0 +1,6 @@ +_base_ = './cascade-mask-rcnn_r50_fpn_ms-3x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r50-caffe_fpn_1x_coco.py b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r50-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..497f68c4 --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r50-caffe_fpn_1x_coco.py @@ -0,0 +1,14 @@ +_base_ = ['./cascade-mask-rcnn_r50_fpn_1x_coco.py'] + +model = dict( + data_preprocessor=dict( + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False), + backbone=dict( + norm_cfg=dict(requires_grad=False), + norm_eval=True, + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe'))) diff --git a/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r50-caffe_fpn_ms-3x_coco.py b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r50-caffe_fpn_ms-3x_coco.py new file mode 100644 index 00000000..6677a9fe --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r50-caffe_fpn_ms-3x_coco.py @@ -0,0 +1,18 @@ +_base_ = [ + '../common/ms_3x_coco-instance.py', + '../_base_/models/cascade-mask-rcnn_r50_fpn.py' +] + +model = dict( + # use caffe img_norm + data_preprocessor=dict( + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False), + backbone=dict( + norm_cfg=dict(requires_grad=False), + norm_eval=True, + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe'))) diff --git a/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r50_fpn_1x_coco.py b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r50_fpn_1x_coco.py new file mode 100644 index 00000000..f59bb94e --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r50_fpn_1x_coco.py @@ -0,0 +1,5 @@ +_base_ = [ + '../_base_/models/cascade-mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] diff --git a/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r50_fpn_20e_coco.py b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r50_fpn_20e_coco.py new file mode 100644 index 00000000..35c8aa67 --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r50_fpn_20e_coco.py @@ -0,0 +1,5 @@ +_base_ = [ + '../_base_/models/cascade-mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_20e.py', '../_base_/default_runtime.py' +] diff --git a/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r50_fpn_ms-3x_coco.py b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r50_fpn_ms-3x_coco.py new file mode 100644 index 00000000..b15006f4 --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_r50_fpn_ms-3x_coco.py @@ -0,0 +1,4 @@ +_base_ = [ + '../common/ms_3x_coco-instance.py', + '../_base_/models/cascade-mask-rcnn_r50_fpn.py' +] diff --git a/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_x101-32x4d_fpn_1x_coco.py b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_x101-32x4d_fpn_1x_coco.py new file mode 100644 index 00000000..87a4cc32 --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_x101-32x4d_fpn_1x_coco.py @@ -0,0 +1,14 @@ +_base_ = './cascade-mask-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_x101-32x4d_fpn_20e_coco.py b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_x101-32x4d_fpn_20e_coco.py new file mode 100644 index 00000000..5e8dcaa6 --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_x101-32x4d_fpn_20e_coco.py @@ -0,0 +1,14 @@ +_base_ = './cascade-mask-rcnn_r50_fpn_20e_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_x101-32x4d_fpn_ms-3x_coco.py b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_x101-32x4d_fpn_ms-3x_coco.py new file mode 100644 index 00000000..3a0f61b9 --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_x101-32x4d_fpn_ms-3x_coco.py @@ -0,0 +1,14 @@ +_base_ = './cascade-mask-rcnn_r50_fpn_ms-3x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_x101-32x8d_fpn_ms-3x_coco.py b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_x101-32x8d_fpn_ms-3x_coco.py new file mode 100644 index 00000000..8cf08306 --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_x101-32x8d_fpn_ms-3x_coco.py @@ -0,0 +1,24 @@ +_base_ = './cascade-mask-rcnn_r50_fpn_ms-3x_coco.py' + +model = dict( + # ResNeXt-101-32x8d model trained with Caffe2 at FB, + # so the mean and std need to be changed. + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[103.530, 116.280, 123.675], + std=[57.375, 57.120, 58.395], + bgr_to_rgb=False, + pad_size_divisor=32), + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=8, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=False), + style='pytorch', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnext101_32x8d'))) diff --git a/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_x101-64x4d_fpn_1x_coco.py b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_x101-64x4d_fpn_1x_coco.py new file mode 100644 index 00000000..fb2e6b6b --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_x101-64x4d_fpn_1x_coco.py @@ -0,0 +1,14 @@ +_base_ = './cascade-mask-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_x101-64x4d_fpn_20e_coco.py b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_x101-64x4d_fpn_20e_coco.py new file mode 100644 index 00000000..cc20c171 --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_x101-64x4d_fpn_20e_coco.py @@ -0,0 +1,14 @@ +_base_ = './cascade-mask-rcnn_r50_fpn_20e_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_x101-64x4d_fpn_ms-3x_coco.py b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_x101-64x4d_fpn_ms-3x_coco.py new file mode 100644 index 00000000..f4ecc426 --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-mask-rcnn_x101-64x4d_fpn_ms-3x_coco.py @@ -0,0 +1,14 @@ +_base_ = './cascade-mask-rcnn_r50_fpn_ms-3x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/cascade_rcnn/cascade-rcnn_r101-caffe_fpn_1x_coco.py b/mmdetection/configs/cascade_rcnn/cascade-rcnn_r101-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..b6eaee2d --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-rcnn_r101-caffe_fpn_1x_coco.py @@ -0,0 +1,7 @@ +_base_ = './cascade-rcnn_r50-caffe_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet101_caffe'))) diff --git a/mmdetection/configs/cascade_rcnn/cascade-rcnn_r101_fpn_1x_coco.py b/mmdetection/configs/cascade_rcnn/cascade-rcnn_r101_fpn_1x_coco.py new file mode 100644 index 00000000..1cdf5108 --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-rcnn_r101_fpn_1x_coco.py @@ -0,0 +1,6 @@ +_base_ = './cascade-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/cascade_rcnn/cascade-rcnn_r101_fpn_20e_coco.py b/mmdetection/configs/cascade_rcnn/cascade-rcnn_r101_fpn_20e_coco.py new file mode 100644 index 00000000..84c285fc --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-rcnn_r101_fpn_20e_coco.py @@ -0,0 +1,6 @@ +_base_ = './cascade-rcnn_r50_fpn_20e_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/cascade_rcnn/cascade-rcnn_r101_fpn_8xb8-amp-lsj-200e_coco.py b/mmdetection/configs/cascade_rcnn/cascade-rcnn_r101_fpn_8xb8-amp-lsj-200e_coco.py new file mode 100644 index 00000000..1fc52e9c --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-rcnn_r101_fpn_8xb8-amp-lsj-200e_coco.py @@ -0,0 +1,7 @@ +_base_ = './cascade-rcnn_r50_fpn_8xb8-amp-lsj-200e_coco.py' + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/cascade_rcnn/cascade-rcnn_r18_fpn_8xb8-amp-lsj-200e_coco.py b/mmdetection/configs/cascade_rcnn/cascade-rcnn_r18_fpn_8xb8-amp-lsj-200e_coco.py new file mode 100644 index 00000000..aa30a3d0 --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-rcnn_r18_fpn_8xb8-amp-lsj-200e_coco.py @@ -0,0 +1,7 @@ +_base_ = './cascade-rcnn_r50_fpn_8xb8-amp-lsj-200e_coco.py' + +model = dict( + backbone=dict( + depth=18, + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet18')), + neck=dict(in_channels=[64, 128, 256, 512])) diff --git a/mmdetection/configs/cascade_rcnn/cascade-rcnn_r50-caffe_fpn_1x_coco.py b/mmdetection/configs/cascade_rcnn/cascade-rcnn_r50-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..ad90e259 --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-rcnn_r50-caffe_fpn_1x_coco.py @@ -0,0 +1,16 @@ +_base_ = './cascade-rcnn_r50_fpn_1x_coco.py' + +model = dict( + # use caffe img_norm + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False, + pad_size_divisor=32), + backbone=dict( + norm_cfg=dict(requires_grad=False), + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe'))) diff --git a/mmdetection/configs/cascade_rcnn/cascade-rcnn_r50_fpn_1x_coco.py b/mmdetection/configs/cascade_rcnn/cascade-rcnn_r50_fpn_1x_coco.py new file mode 100644 index 00000000..1a07c8b2 --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-rcnn_r50_fpn_1x_coco.py @@ -0,0 +1,5 @@ +_base_ = [ + '../_base_/models/cascade-rcnn_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] diff --git a/mmdetection/configs/cascade_rcnn/cascade-rcnn_r50_fpn_20e_coco.py b/mmdetection/configs/cascade_rcnn/cascade-rcnn_r50_fpn_20e_coco.py new file mode 100644 index 00000000..30f3ff10 --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-rcnn_r50_fpn_20e_coco.py @@ -0,0 +1,5 @@ +_base_ = [ + '../_base_/models/cascade-rcnn_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_20e.py', '../_base_/default_runtime.py' +] diff --git a/mmdetection/configs/cascade_rcnn/cascade-rcnn_r50_fpn_8xb8-amp-lsj-200e_coco.py b/mmdetection/configs/cascade_rcnn/cascade-rcnn_r50_fpn_8xb8-amp-lsj-200e_coco.py new file mode 100644 index 00000000..cd25f026 --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-rcnn_r50_fpn_8xb8-amp-lsj-200e_coco.py @@ -0,0 +1,23 @@ +_base_ = [ + '../_base_/models/cascade-rcnn_r50_fpn.py', + '../common/lsj-200e_coco-detection.py' +] +image_size = (1024, 1024) +batch_augments = [dict(type='BatchFixedSizePad', size=image_size)] + +# disable allowed_border to avoid potential errors. +model = dict( + data_preprocessor=dict(batch_augments=batch_augments), + train_cfg=dict(rpn=dict(allowed_border=-1))) + +train_dataloader = dict(batch_size=8, num_workers=4) +# Enable automatic-mixed-precision training with AmpOptimWrapper. +optim_wrapper = dict( + type='AmpOptimWrapper', + optimizer=dict( + type='SGD', lr=0.02 * 4, momentum=0.9, weight_decay=0.00004)) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (8 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/cascade_rcnn/cascade-rcnn_x101-32x4d_fpn_1x_coco.py b/mmdetection/configs/cascade_rcnn/cascade-rcnn_x101-32x4d_fpn_1x_coco.py new file mode 100644 index 00000000..50e0b954 --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-rcnn_x101-32x4d_fpn_1x_coco.py @@ -0,0 +1,14 @@ +_base_ = './cascade-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/cascade_rcnn/cascade-rcnn_x101-32x4d_fpn_20e_coco.py b/mmdetection/configs/cascade_rcnn/cascade-rcnn_x101-32x4d_fpn_20e_coco.py new file mode 100644 index 00000000..61201892 --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-rcnn_x101-32x4d_fpn_20e_coco.py @@ -0,0 +1,14 @@ +_base_ = './cascade-rcnn_r50_fpn_20e_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/cascade_rcnn/cascade-rcnn_x101-64x4d_fpn_1x_coco.py b/mmdetection/configs/cascade_rcnn/cascade-rcnn_x101-64x4d_fpn_1x_coco.py new file mode 100644 index 00000000..29475e39 --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-rcnn_x101-64x4d_fpn_1x_coco.py @@ -0,0 +1,15 @@ +_base_ = './cascade-rcnn_r50_fpn_1x_coco.py' +model = dict( + type='CascadeRCNN', + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/cascade_rcnn/cascade-rcnn_x101_64x4d_fpn_20e_coco.py b/mmdetection/configs/cascade_rcnn/cascade-rcnn_x101_64x4d_fpn_20e_coco.py new file mode 100644 index 00000000..e2aa57ea --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/cascade-rcnn_x101_64x4d_fpn_20e_coco.py @@ -0,0 +1,15 @@ +_base_ = './cascade-rcnn_r50_fpn_20e_coco.py' +model = dict( + type='CascadeRCNN', + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/cascade_rcnn/metafile.yml b/mmdetection/configs/cascade_rcnn/metafile.yml new file mode 100644 index 00000000..7e0385da --- /dev/null +++ b/mmdetection/configs/cascade_rcnn/metafile.yml @@ -0,0 +1,545 @@ +Collections: + - Name: Cascade R-CNN + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - Cascade R-CNN + - FPN + - RPN + - ResNet + - RoIAlign + Paper: + URL: http://dx.doi.org/10.1109/tpami.2019.2956516 + Title: 'Cascade R-CNN: Delving into High Quality Object Detection' + README: configs/cascade_rcnn/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/detectors/cascade_rcnn.py#L6 + Version: v2.0.0 + - Name: Cascade Mask R-CNN + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - Cascade R-CNN + - FPN + - RPN + - ResNet + - RoIAlign + Paper: + URL: http://dx.doi.org/10.1109/tpami.2019.2956516 + Title: 'Cascade R-CNN: Delving into High Quality Object Detection' + README: configs/cascade_rcnn/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/detectors/cascade_rcnn.py#L6 + Version: v2.0.0 + +Models: + - Name: cascade-rcnn_r50-caffe_fpn_1x_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-rcnn_r50-caffe_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.2 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r50_caffe_fpn_1x_coco/cascade_rcnn_r50_caffe_fpn_1x_coco_bbox_mAP-0.404_20200504_174853-b857be87.pth + + - Name: cascade-rcnn_r50_fpn_1x_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-rcnn_r50_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.4 + inference time (ms/im): + - value: 62.11 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r50_fpn_1x_coco/cascade_rcnn_r50_fpn_1x_coco_20200316-3dc56deb.pth + + - Name: cascade-rcnn_r50_fpn_20e_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-rcnn_r50_fpn_20e_coco.py + Metadata: + Training Memory (GB): 4.4 + inference time (ms/im): + - value: 62.11 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 20 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r50_fpn_20e_coco/cascade_rcnn_r50_fpn_20e_coco_bbox_mAP-0.41_20200504_175131-e9872a90.pth + + - Name: cascade-rcnn_r101-caffe_fpn_1x_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-rcnn_r101-caffe_fpn_1x_coco.py + Metadata: + Training Memory (GB): 6.2 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r101_caffe_fpn_1x_coco/cascade_rcnn_r101_caffe_fpn_1x_coco_bbox_mAP-0.423_20200504_175649-cab8dbd5.pth + + - Name: cascade-rcnn_r101_fpn_1x_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-rcnn_r101_fpn_1x_coco.py + Metadata: + Training Memory (GB): 6.4 + inference time (ms/im): + - value: 74.07 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r101_fpn_1x_coco/cascade_rcnn_r101_fpn_1x_coco_20200317-0b6a2fbf.pth + + - Name: cascade-rcnn_r101_fpn_20e_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-rcnn_r101_fpn_20e_coco.py + Metadata: + Training Memory (GB): 6.4 + inference time (ms/im): + - value: 74.07 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 20 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r101_fpn_20e_coco/cascade_rcnn_r101_fpn_20e_coco_bbox_mAP-0.425_20200504_231812-5057dcc5.pth + + - Name: cascade-rcnn_x101-32x4d_fpn_1x_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-rcnn_x101-32x4d_fpn_1x_coco.py + Metadata: + Training Memory (GB): 7.6 + inference time (ms/im): + - value: 91.74 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_x101_32x4d_fpn_1x_coco/cascade_rcnn_x101_32x4d_fpn_1x_coco_20200316-95c2deb6.pth + + - Name: cascade-rcnn_x101-32x4d_fpn_20e_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-rcnn_x101-32x4d_fpn_20e_coco.py + Metadata: + Training Memory (GB): 7.6 + Epochs: 20 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_x101_32x4d_fpn_20e_coco/cascade_rcnn_x101_32x4d_fpn_20e_coco_20200906_134608-9ae0a720.pth + + - Name: cascade-rcnn_x101-64x4d_fpn_1x_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-rcnn_x101-64x4d_fpn_1x_coco.py + Metadata: + Training Memory (GB): 10.7 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_x101_64x4d_fpn_1x_coco/cascade_rcnn_x101_64x4d_fpn_1x_coco_20200515_075702-43ce6a30.pth + + - Name: cascade-rcnn_x101_64x4d_fpn_20e_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-rcnn_x101_64x4d_fpn_20e_coco.py + Metadata: + Training Memory (GB): 10.7 + Epochs: 20 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_x101_64x4d_fpn_20e_coco/cascade_rcnn_x101_64x4d_fpn_20e_coco_20200509_224357-051557b1.pth + + - Name: cascade-mask-rcnn_r50-caffe_fpn_1x_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-mask-rcnn_r50-caffe_fpn_1x_coco.py + Metadata: + Training Memory (GB): 5.9 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.2 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_caffe_fpn_1x_coco/cascade_mask_rcnn_r50_caffe_fpn_1x_coco_bbox_mAP-0.412__segm_mAP-0.36_20200504_174659-5004b251.pth + + - Name: cascade-mask-rcnn_r50_fpn_1x_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-mask-rcnn_r50_fpn_1x_coco.py + Metadata: + Training Memory (GB): 6.0 + inference time (ms/im): + - value: 89.29 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.2 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 35.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco/cascade_mask_rcnn_r50_fpn_1x_coco_20200203-9d4dcb24.pth + + - Name: cascade-mask-rcnn_r50_fpn_20e_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-mask-rcnn_r50_fpn_20e_coco.py + Metadata: + Training Memory (GB): 6.0 + inference time (ms/im): + - value: 89.29 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 20 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.9 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_fpn_20e_coco/cascade_mask_rcnn_r50_fpn_20e_coco_bbox_mAP-0.419__segm_mAP-0.365_20200504_174711-4af8e66e.pth + + - Name: cascade-mask-rcnn_r101-caffe_fpn_1x_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-mask-rcnn_r101-caffe_fpn_1x_coco.py + Metadata: + Training Memory (GB): 7.8 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.2 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r101_caffe_fpn_1x_coco/cascade_mask_rcnn_r101_caffe_fpn_1x_coco_bbox_mAP-0.432__segm_mAP-0.376_20200504_174813-5c1e9599.pth + + - Name: cascade-mask-rcnn_r101_fpn_1x_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-mask-rcnn_r101_fpn_1x_coco.py + Metadata: + Training Memory (GB): 7.9 + inference time (ms/im): + - value: 102.04 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.9 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r101_fpn_1x_coco/cascade_mask_rcnn_r101_fpn_1x_coco_20200203-befdf6ee.pth + + - Name: cascade-mask-rcnn_r101_fpn_20e_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-mask-rcnn_r101_fpn_20e_coco.py + Metadata: + Training Memory (GB): 7.9 + inference time (ms/im): + - value: 102.04 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 20 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.4 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r101_fpn_20e_coco/cascade_mask_rcnn_r101_fpn_20e_coco_bbox_mAP-0.434__segm_mAP-0.378_20200504_174836-005947da.pth + + - Name: cascade-mask-rcnn_x101-32x4d_fpn_1x_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-mask-rcnn_x101-32x4d_fpn_1x_coco.py + Metadata: + Training Memory (GB): 9.2 + inference time (ms/im): + - value: 116.28 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.3 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_32x4d_fpn_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_1x_coco_20200201-0f411b1f.pth + + - Name: cascade-mask-rcnn_x101-32x4d_fpn_20e_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-mask-rcnn_x101-32x4d_fpn_20e_coco.py + Metadata: + Training Memory (GB): 9.2 + inference time (ms/im): + - value: 116.28 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 20 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.0 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_32x4d_fpn_20e_coco/cascade_mask_rcnn_x101_32x4d_fpn_20e_coco_20200528_083917-ed1f4751.pth + + - Name: cascade-mask-rcnn_x101-64x4d_fpn_1x_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-mask-rcnn_x101-64x4d_fpn_1x_coco.py + Metadata: + Training Memory (GB): 12.2 + inference time (ms/im): + - value: 149.25 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.3 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_64x4d_fpn_1x_coco/cascade_mask_rcnn_x101_64x4d_fpn_1x_coco_20200203-9a2db89d.pth + + - Name: cascade-mask-rcnn_x101-64x4d_fpn_20e_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-mask-rcnn_x101-64x4d_fpn_20e_coco.py + Metadata: + Training Memory (GB): 12.2 + Epochs: 20 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.6 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_64x4d_fpn_20e_coco/cascade_mask_rcnn_x101_64x4d_fpn_20e_coco_20200512_161033-bdb5126a.pth + + - Name: cascade-mask-rcnn_r50-caffe_fpn_ms-3x_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-mask-rcnn_r50-caffe_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 5.7 + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.0 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_caffe_fpn_mstrain_3x_coco/cascade_mask_rcnn_r50_caffe_fpn_mstrain_3x_coco_20210707_002651-6e29b3a6.pth + + - Name: cascade-mask-rcnn_r50_fpn_mstrain_3x_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-mask-rcnn_r50_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 5.9 + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.3 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_fpn_mstrain_3x_coco/cascade_mask_rcnn_r50_fpn_mstrain_3x_coco_20210628_164719-5bdc3824.pth + + - Name: cascade-mask-rcnn_r101-caffe_fpn_ms-3x_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-mask-rcnn_r101-caffe_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 7.7 + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.4 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r101_caffe_fpn_mstrain_3x_coco/cascade_mask_rcnn_r101_caffe_fpn_mstrain_3x_coco_20210707_002620-a5bd2389.pth + + - Name: cascade-mask-rcnn_r101_fpn_ms-3x_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-mask-rcnn_r101_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 7.8 + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.5 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r101_fpn_mstrain_3x_coco/cascade_mask_rcnn_r101_fpn_mstrain_3x_coco_20210628_165236-51a2d363.pth + + - Name: cascade-mask-rcnn_x101-32x4d_fpn_ms-3x_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-mask-rcnn_x101-32x4d_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 9.0 + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.3 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 40.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_32x4d_fpn_mstrain_3x_coco/cascade_mask_rcnn_x101_32x4d_fpn_mstrain_3x_coco_20210706_225234-40773067.pth + + - Name: cascade-mask-rcnn_x101-32x8d_fpn_ms-3x_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-mask-rcnn_x101-32x8d_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 12.1 + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.1 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_32x8d_fpn_mstrain_3x_coco/cascade_mask_rcnn_x101_32x8d_fpn_mstrain_3x_coco_20210719_180640-9ff7e76f.pth + + - Name: cascade-mask-rcnn_x101-64x4d_fpn_ms-3x_coco + In Collection: Cascade R-CNN + Config: configs/cascade_rcnn/cascade-mask-rcnn_x101-64x4d_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 12.0 + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.6 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 40.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_64x4d_fpn_mstrain_3x_coco/cascade_mask_rcnn_x101_64x4d_fpn_mstrain_3x_coco_20210719_210311-d3e64ba0.pth diff --git a/mmdetection/configs/cascade_rpn/README.md b/mmdetection/configs/cascade_rpn/README.md new file mode 100644 index 00000000..868a25ed --- /dev/null +++ b/mmdetection/configs/cascade_rpn/README.md @@ -0,0 +1,41 @@ +# Cascade RPN + +> [Cascade RPN: Delving into High-Quality Region Proposal Network with Adaptive Convolution](https://arxiv.org/abs/1909.06720) + + + +## Abstract + +This paper considers an architecture referred to as Cascade Region Proposal Network (Cascade RPN) for improving the region-proposal quality and detection performance by systematically addressing the limitation of the conventional RPN that heuristically defines the anchors and aligns the features to the anchors. First, instead of using multiple anchors with predefined scales and aspect ratios, Cascade RPN relies on a single anchor per location and performs multi-stage refinement. Each stage is progressively more stringent in defining positive samples by starting out with an anchor-free metric followed by anchor-based metrics in the ensuing stages. Second, to attain alignment between the features and the anchors throughout the stages, adaptive convolution is proposed that takes the anchors in addition to the image features as its input and learns the sampled features guided by the anchors. A simple implementation of a two-stage Cascade RPN achieves AR 13.4 points higher than that of the conventional RPN, surpassing any existing region proposal methods. When adopting to Fast R-CNN and Faster R-CNN, Cascade RPN can improve the detection mAP by 3.1 and 3.5 points, respectively. + +
    + +
    + +## Results and Models + +### Region proposal performance + +| Method | Backbone | Style | Mem (GB) | Train time (s/iter) | Inf time (fps) | AR 1000 | Config | Download | +| :----: | :------: | :---: | :------: | :-----------------: | :------------: | :-----: | :----------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------: | +| CRPN | R-50-FPN | caffe | - | - | - | 72.0 | [config](./cascade-rpn_r50-caffe_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rpn/crpn_r50_caffe_fpn_1x_coco/cascade_rpn_r50_caffe_fpn_1x_coco-7aa93cef.pth) | + +### Detection performance + +| Method | Proposal | Backbone | Style | Schedule | Mem (GB) | Train time (s/iter) | Inf time (fps) | box AP | Config | Download | +| :----------: | :---------: | :------: | :---: | :------: | :------: | :-----------------: | :------------: | :----: | :----------------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| Fast R-CNN | Cascade RPN | R-50-FPN | caffe | 1x | - | - | - | 39.9 | [config](./cascade-rpn_fast-rcnn_r50-caffe_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rpn/crpn_fast_rcnn_r50_caffe_fpn_1x_coco/crpn_fast_rcnn_r50_caffe_fpn_1x_coco-cb486e66.pth) | +| Faster R-CNN | Cascade RPN | R-50-FPN | caffe | 1x | - | - | - | 40.4 | [config](./cascade-rpn_faster-rcnn_r50-caffe_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cascade_rpn/crpn_faster_rcnn_r50_caffe_fpn_1x_coco/crpn_faster_rcnn_r50_caffe_fpn_1x_coco-c8283cca.pth) | + +## Citation + +We provide the code for reproducing experiment results of [Cascade RPN](https://arxiv.org/abs/1909.06720). + +```latex +@inproceedings{vu2019cascade, + title={Cascade RPN: Delving into High-Quality Region Proposal Network with Adaptive Convolution}, + author={Vu, Thang and Jang, Hyunjun and Pham, Trung X and Yoo, Chang D}, + booktitle={Conference on Neural Information Processing Systems (NeurIPS)}, + year={2019} +} +``` diff --git a/mmdetection/configs/cascade_rpn/cascade-rpn_fast-rcnn_r50-caffe_fpn_1x_coco.py b/mmdetection/configs/cascade_rpn/cascade-rpn_fast-rcnn_r50-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..ba23ce90 --- /dev/null +++ b/mmdetection/configs/cascade_rpn/cascade-rpn_fast-rcnn_r50-caffe_fpn_1x_coco.py @@ -0,0 +1,27 @@ +_base_ = '../fast_rcnn/fast-rcnn_r50-caffe_fpn_1x_coco.py' +model = dict( + roi_head=dict( + bbox_head=dict( + bbox_coder=dict(target_stds=[0.04, 0.04, 0.08, 0.08]), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.5), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0))), + # model training and testing settings + train_cfg=dict( + rcnn=dict( + assigner=dict( + pos_iou_thr=0.65, neg_iou_thr=0.65, min_pos_iou=0.65), + sampler=dict(num=256))), + test_cfg=dict(rcnn=dict(score_thr=1e-3))) + +# MMEngine support the following two ways, users can choose +# according to convenience +# train_dataloader = dict(dataset=dict(proposal_file='proposals/crpn_r50_caffe_fpn_1x_train2017.pkl')) # noqa +_base_.train_dataloader.dataset.proposal_file = 'proposals/crpn_r50_caffe_fpn_1x_train2017.pkl' # noqa + +# val_dataloader = dict(dataset=dict(proposal_file='proposals/crpn_r50_caffe_fpn_1x_val2017.pkl')) # noqa +# test_dataloader = val_dataloader +_base_.val_dataloader.dataset.proposal_file = 'proposals/crpn_r50_caffe_fpn_1x_val2017.pkl' # noqa +test_dataloader = _base_.val_dataloader + +optim_wrapper = dict(clip_grad=dict(max_norm=35, norm_type=2)) diff --git a/mmdetection/configs/cascade_rpn/cascade-rpn_faster-rcnn_r50-caffe_fpn_1x_coco.py b/mmdetection/configs/cascade_rpn/cascade-rpn_faster-rcnn_r50-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..2f7eced0 --- /dev/null +++ b/mmdetection/configs/cascade_rpn/cascade-rpn_faster-rcnn_r50-caffe_fpn_1x_coco.py @@ -0,0 +1,89 @@ +_base_ = '../faster_rcnn/faster-rcnn_r50-caffe_fpn_1x_coco.py' +rpn_weight = 0.7 +model = dict( + rpn_head=dict( + _delete_=True, + type='CascadeRPNHead', + num_stages=2, + stages=[ + dict( + type='StageCascadeRPNHead', + in_channels=256, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + scales=[8], + ratios=[1.0], + strides=[4, 8, 16, 32, 64]), + adapt_cfg=dict(type='dilation', dilation=3), + bridged_feature=True, + with_cls=False, + reg_decoded_bbox=True, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=(.0, .0, .0, .0), + target_stds=(0.1, 0.1, 0.5, 0.5)), + loss_bbox=dict( + type='IoULoss', linear=True, + loss_weight=10.0 * rpn_weight)), + dict( + type='StageCascadeRPNHead', + in_channels=256, + feat_channels=256, + adapt_cfg=dict(type='offset'), + bridged_feature=False, + with_cls=True, + reg_decoded_bbox=True, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=(.0, .0, .0, .0), + target_stds=(0.05, 0.05, 0.1, 0.1)), + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=True, + loss_weight=1.0 * rpn_weight), + loss_bbox=dict( + type='IoULoss', linear=True, + loss_weight=10.0 * rpn_weight)) + ]), + roi_head=dict( + bbox_head=dict( + bbox_coder=dict(target_stds=[0.04, 0.04, 0.08, 0.08]), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.5), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0))), + # model training and testing settings + train_cfg=dict( + rpn=[ + dict( + assigner=dict( + type='RegionAssigner', center_ratio=0.2, ignore_ratio=0.5), + allowed_border=-1, + pos_weight=-1, + debug=False), + dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.7, + min_pos_iou=0.3, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=-1, + pos_weight=-1, + debug=False) + ], + rpn_proposal=dict(max_per_img=300, nms=dict(iou_threshold=0.8)), + rcnn=dict( + assigner=dict( + pos_iou_thr=0.65, neg_iou_thr=0.65, min_pos_iou=0.65), + sampler=dict(type='RandomSampler', num=256))), + test_cfg=dict( + rpn=dict(max_per_img=300, nms=dict(iou_threshold=0.8)), + rcnn=dict(score_thr=1e-3))) +optim_wrapper = dict(clip_grad=dict(max_norm=35, norm_type=2)) diff --git a/mmdetection/configs/cascade_rpn/cascade-rpn_r50-caffe_fpn_1x_coco.py b/mmdetection/configs/cascade_rpn/cascade-rpn_r50-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..6eba24d1 --- /dev/null +++ b/mmdetection/configs/cascade_rpn/cascade-rpn_r50-caffe_fpn_1x_coco.py @@ -0,0 +1,76 @@ +_base_ = '../rpn/rpn_r50-caffe_fpn_1x_coco.py' +model = dict( + rpn_head=dict( + _delete_=True, + type='CascadeRPNHead', + num_stages=2, + stages=[ + dict( + type='StageCascadeRPNHead', + in_channels=256, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + scales=[8], + ratios=[1.0], + strides=[4, 8, 16, 32, 64]), + adapt_cfg=dict(type='dilation', dilation=3), + bridged_feature=True, + sampling=False, + with_cls=False, + reg_decoded_bbox=True, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=(.0, .0, .0, .0), + target_stds=(0.1, 0.1, 0.5, 0.5)), + loss_bbox=dict(type='IoULoss', linear=True, loss_weight=10.0)), + dict( + type='StageCascadeRPNHead', + in_channels=256, + feat_channels=256, + adapt_cfg=dict(type='offset'), + bridged_feature=False, + sampling=True, + with_cls=True, + reg_decoded_bbox=True, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=(.0, .0, .0, .0), + target_stds=(0.05, 0.05, 0.1, 0.1)), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, + loss_weight=1.0), + loss_bbox=dict(type='IoULoss', linear=True, loss_weight=10.0)) + ]), + train_cfg=dict(rpn=[ + dict( + assigner=dict( + type='RegionAssigner', center_ratio=0.2, ignore_ratio=0.5), + allowed_border=-1, + pos_weight=-1, + debug=False), + dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.7, + min_pos_iou=0.3, + ignore_iof_thr=-1, + iou_calculator=dict(type='BboxOverlaps2D')), + sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=-1, + pos_weight=-1, + debug=False) + ]), + test_cfg=dict( + rpn=dict( + nms_pre=2000, + max_per_img=2000, + nms=dict(type='nms', iou_threshold=0.8), + min_bbox_size=0))) +optim_wrapper = dict(clip_grad=dict(max_norm=35, norm_type=2)) diff --git a/mmdetection/configs/cascade_rpn/metafile.yml b/mmdetection/configs/cascade_rpn/metafile.yml new file mode 100644 index 00000000..62a88c5d --- /dev/null +++ b/mmdetection/configs/cascade_rpn/metafile.yml @@ -0,0 +1,44 @@ +Collections: + - Name: Cascade RPN + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - Cascade RPN + - FPN + - ResNet + Paper: + URL: https://arxiv.org/abs/1909.06720 + Title: 'Cascade RPN: Delving into High-Quality Region Proposal Network with Adaptive Convolution' + README: configs/cascade_rpn/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.8.0/mmdet/models/dense_heads/cascade_rpn_head.py#L538 + Version: v2.8.0 + +Models: + - Name: cascade-rpn_fast-rcnn_r50-caffe_fpn_1x_coco + In Collection: Cascade RPN + Config: configs/cascade_rpn/cascade-rpn_fast-rcnn_r50-caffe_fpn_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rpn/crpn_fast_rcnn_r50_caffe_fpn_1x_coco/crpn_fast_rcnn_r50_caffe_fpn_1x_coco-cb486e66.pth + + - Name: cascade-rpn_faster-rcnn_r50-caffe_fpn_1x_coco + In Collection: Cascade RPN + Config: configs/cascade_rpn/cascade-rpn_faster-rcnn_r50-caffe_fpn_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cascade_rpn/crpn_faster_rcnn_r50_caffe_fpn_1x_coco/crpn_faster_rcnn_r50_caffe_fpn_1x_coco-c8283cca.pth diff --git a/mmdetection/configs/centernet/README.md b/mmdetection/configs/centernet/README.md new file mode 100644 index 00000000..81e229c6 --- /dev/null +++ b/mmdetection/configs/centernet/README.md @@ -0,0 +1,58 @@ +# CenterNet + +> [Objects as Points](https://arxiv.org/abs/1904.07850) + + + +## Abstract + +Detection identifies objects as axis-aligned boxes in an image. Most successful object detectors enumerate a nearly exhaustive list of potential object locations and classify each. This is wasteful, inefficient, and requires additional post-processing. In this paper, we take a different approach. We model an object as a single point --- the center point of its bounding box. Our detector uses keypoint estimation to find center points and regresses to all other object properties, such as size, 3D location, orientation, and even pose. Our center point based approach, CenterNet, is end-to-end differentiable, simpler, faster, and more accurate than corresponding bounding box based detectors. CenterNet achieves the best speed-accuracy trade-off on the MS COCO dataset, with 28.1% AP at 142 FPS, 37.4% AP at 52 FPS, and 45.1% AP with multi-scale testing at 1.4 FPS. We use the same approach to estimate 3D bounding box in the KITTI benchmark and human pose on the COCO keypoint dataset. Our method performs competitively with sophisticated multi-stage methods and runs in real-time. + +
    + +
    + +## Results and Models + +| Backbone | DCN | Mem (GB) | Box AP | Flip box AP | Config | Download | +| :-------: | :-: | :------: | :----: | :---------: | :--------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| ResNet-18 | N | 3.45 | 25.9 | 27.3 | [config](./centernet_r18_8xb16-crop512-140e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/centernet/centernet_resnet18_140e_coco/centernet_resnet18_140e_coco_20210705_093630-bb5b3bf7.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/centernet/centernet_resnet18_140e_coco/centernet_resnet18_140e_coco_20210705_093630.log.json) | +| ResNet-18 | Y | 3.47 | 29.5 | 30.9 | [config](./centernet_r18-dcnv2_8xb16-crop512-140e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/centernet/centernet_resnet18_dcnv2_140e_coco/centernet_resnet18_dcnv2_140e_coco_20210702_155131-c8cd631f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/centernet/centernet_resnet18_dcnv2_140e_coco/centernet_resnet18_dcnv2_140e_coco_20210702_155131.log.json) | + +Note: + +- Flip box AP setting is single-scale and `flip=True`. +- Due to complex data enhancement, we find that the performance is unstable and may fluctuate by about 0.4 mAP. mAP 29.4 ~ 29.8 is acceptable in ResNet-18-DCNv2. +- Compared to the source code, we refer to [CenterNet-Better](https://github.com/FateScript/CenterNet-better), and make the following changes + - fix wrong image mean and variance in image normalization to be compatible with the pre-trained backbone. + - Use SGD rather than ADAM optimizer and add warmup and grad clip. + - Use DistributedDataParallel as other models in MMDetection rather than using DataParallel. + +## CenterNet Update + +| Backbone | Style | Lr schd | MS train | Mem (GB) | Box AP | Config | Download | +| :-------: | :---: | :-----: | :------: | :------: | :----: | :------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| ResNet-50 | caffe | 1x | True | 3.3 | 40.2 | [config](./centernet-update_r50-caffe_fpn_ms-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/centernet/centernet-update_r50-caffe_fpn_ms-1x_coco/centernet-update_r50-caffe_fpn_ms-1x_coco_20230512_203845-8306baf2.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/centernet/centernet-update_r50-caffe_fpn_ms-1x_coco/centernet-update_r50-caffe_fpn_ms-1x_coco_20230512_203845.log.json) | + +CenterNet Update from the paper of [Probabilistic two-stage detection](https://arxiv.org/abs/2103.07461). The author has updated CenterNet to greatly improve performance and convergence speed. +The [Details](https://github.com/xingyizhou/CenterNet2/blob/master/docs/MODEL_ZOO.md) are as follows: + +- Using top-left-right-bottom box encoding and GIoU Loss +- Adding regression loss to the center 3x3 region +- Adding more positive pixels for the heatmap loss whose regression loss is small and is within the center3x3 region +- Using RetinaNet-style optimizer (SGD), learning rate rule (0.01 for each batch size 16), and schedule (12 epochs) +- Added FPN neck layers, and assigns objects to FPN levels based on a fixed size range. +- Using standard NMS instead of max pooling + +Note: We found that the performance of the r50 model fluctuates greatly and sometimes it does not converge. If the model does not converge, you can try running it again or reduce the learning rate. + +## Citation + +```latex +@article{zhou2019objects, + title={Objects as Points}, + author={Zhou, Xingyi and Wang, Dequan and Kr{\"a}henb{\"u}hl, Philipp}, + booktitle={arXiv preprint arXiv:1904.07850}, + year={2019} +} +``` diff --git a/mmdetection/configs/centernet/centernet-update_r101_fpn_8xb8-amp-lsj-200e_coco.py b/mmdetection/configs/centernet/centernet-update_r101_fpn_8xb8-amp-lsj-200e_coco.py new file mode 100644 index 00000000..4fc65e0f --- /dev/null +++ b/mmdetection/configs/centernet/centernet-update_r101_fpn_8xb8-amp-lsj-200e_coco.py @@ -0,0 +1,7 @@ +_base_ = './centernet-update_r50_fpn_8xb8-amp-lsj-200e_coco.py' + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/centernet/centernet-update_r18_fpn_8xb8-amp-lsj-200e_coco.py b/mmdetection/configs/centernet/centernet-update_r18_fpn_8xb8-amp-lsj-200e_coco.py new file mode 100644 index 00000000..ab3ae32e --- /dev/null +++ b/mmdetection/configs/centernet/centernet-update_r18_fpn_8xb8-amp-lsj-200e_coco.py @@ -0,0 +1,7 @@ +_base_ = './centernet-update_r50_fpn_8xb8-amp-lsj-200e_coco.py' + +model = dict( + backbone=dict( + depth=18, + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet18')), + neck=dict(in_channels=[64, 128, 256, 512])) diff --git a/mmdetection/configs/centernet/centernet-update_r50-caffe_fpn_ms-1x_coco.py b/mmdetection/configs/centernet/centernet-update_r50-caffe_fpn_ms-1x_coco.py new file mode 100644 index 00000000..1f6e2b39 --- /dev/null +++ b/mmdetection/configs/centernet/centernet-update_r50-caffe_fpn_ms-1x_coco.py @@ -0,0 +1,105 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +model = dict( + type='CenterNet', + # use caffe img_norm + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=False), + norm_eval=True, + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_output', + num_outs=5, + # There is a chance to get 40.3 after switching init_cfg, + # otherwise it is about 39.9~40.1 + init_cfg=dict(type='Caffe2Xavier', layer='Conv2d'), + relu_before_extra_convs=True), + bbox_head=dict( + type='CenterNetUpdateHead', + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + strides=[8, 16, 32, 64, 128], + hm_min_radius=4, + hm_min_overlap=0.8, + more_pos_thresh=0.2, + more_pos_topk=9, + soft_weight_on_reg=False, + loss_cls=dict( + type='GaussianFocalLoss', + pos_weight=0.25, + neg_weight=0.75, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=2.0), + ), + train_cfg=None, + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) + +# single-scale training is about 39.3 +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736), + (1333, 768), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=0.00025, + by_epoch=False, + begin=0, + end=4000), + dict( + type='MultiStepLR', + begin=0, + end=12, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] + +optim_wrapper = dict( + optimizer=dict(lr=0.01), + # Experiments show that there is no need to turn on clip_grad. + paramwise_cfg=dict(norm_decay_mult=0.)) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=16) diff --git a/mmdetection/configs/centernet/centernet-update_r50_fpn_8xb8-amp-lsj-200e_coco.py b/mmdetection/configs/centernet/centernet-update_r50_fpn_8xb8-amp-lsj-200e_coco.py new file mode 100644 index 00000000..34e0c680 --- /dev/null +++ b/mmdetection/configs/centernet/centernet-update_r50_fpn_8xb8-amp-lsj-200e_coco.py @@ -0,0 +1,83 @@ +_base_ = '../common/lsj-200e_coco-detection.py' + +image_size = (1024, 1024) +batch_augments = [dict(type='BatchFixedSizePad', size=image_size)] + +model = dict( + type='CenterNet', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32, + batch_augments=batch_augments), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_output', + num_outs=5, + init_cfg=dict(type='Caffe2Xavier', layer='Conv2d'), + relu_before_extra_convs=True), + bbox_head=dict( + type='CenterNetUpdateHead', + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + strides=[8, 16, 32, 64, 128], + loss_cls=dict( + type='GaussianFocalLoss', + pos_weight=0.25, + neg_weight=0.75, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=2.0), + ), + train_cfg=None, + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) + +train_dataloader = dict(batch_size=8, num_workers=4) +# Enable automatic-mixed-precision training with AmpOptimWrapper. +optim_wrapper = dict( + type='AmpOptimWrapper', + optimizer=dict( + type='SGD', lr=0.01 * 4, momentum=0.9, weight_decay=0.00004), + paramwise_cfg=dict(norm_decay_mult=0.)) + +param_scheduler = [ + dict( + type='LinearLR', + start_factor=0.00025, + by_epoch=False, + begin=0, + end=4000), + dict( + type='MultiStepLR', + begin=0, + end=25, + by_epoch=True, + milestones=[22, 24], + gamma=0.1) +] + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (8 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/centernet/centernet_r18-dcnv2_8xb16-crop512-140e_coco.py b/mmdetection/configs/centernet/centernet_r18-dcnv2_8xb16-crop512-140e_coco.py new file mode 100644 index 00000000..732a55d5 --- /dev/null +++ b/mmdetection/configs/centernet/centernet_r18-dcnv2_8xb16-crop512-140e_coco.py @@ -0,0 +1,136 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py', + './centernet_tta.py' +] + +dataset_type = 'CocoDataset' +data_root = 'data/coco/' + +# model settings +model = dict( + type='CenterNet', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True), + backbone=dict( + type='ResNet', + depth=18, + norm_eval=False, + norm_cfg=dict(type='BN'), + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet18')), + neck=dict( + type='CTResNetNeck', + in_channels=512, + num_deconv_filters=(256, 128, 64), + num_deconv_kernels=(4, 4, 4), + use_dcn=True), + bbox_head=dict( + type='CenterNetHead', + num_classes=80, + in_channels=64, + feat_channels=64, + loss_center_heatmap=dict(type='GaussianFocalLoss', loss_weight=1.0), + loss_wh=dict(type='L1Loss', loss_weight=0.1), + loss_offset=dict(type='L1Loss', loss_weight=1.0)), + train_cfg=None, + test_cfg=dict(topk=100, local_maximum_kernel=3, max_per_img=100)) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict( + type='RandomCenterCropPad', + # The cropped images are padded into squares during training, + # but may be less than crop_size. + crop_size=(512, 512), + ratios=(0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3), + mean=[0, 0, 0], + std=[1, 1, 1], + to_rgb=True, + test_pad_mode=None), + # Make sure the output is always crop_size. + dict(type='Resize', scale=(512, 512), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict( + type='LoadImageFromFile', + backend_args={{_base_.backend_args}}, + to_float32=True), + # don't need Resize + dict( + type='RandomCenterCropPad', + ratios=None, + border=None, + mean=[0, 0, 0], + std=[1, 1, 1], + to_rgb=True, + test_mode=True, + test_pad_mode=['logical_or', 31], + test_pad_add_pix=1), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'border')) +] + +# Use RepeatDataset to speed up training +train_dataloader = dict( + batch_size=16, + num_workers=4, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + dataset=dict( + _delete_=True, + type='RepeatDataset', + times=5, + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args={{_base_.backend_args}}, + ))) + +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader + +# optimizer +# Based on the default settings of modern detectors, the SGD effect is better +# than the Adam in the source code, so we use SGD default settings and +# if you use adam+lr5e-4, the map is 29.1. +optim_wrapper = dict(clip_grad=dict(max_norm=35, norm_type=2)) + +max_epochs = 28 +# learning policy +# Based on the default settings of modern detectors, we added warmup settings. +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, + end=1000), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[18, 24], # the real step is [18*5, 24*5] + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs) # the real epoch is 28*5=140 + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (16 samples per GPU) +auto_scale_lr = dict(base_batch_size=128) diff --git a/mmdetection/configs/centernet/centernet_r18_8xb16-crop512-140e_coco.py b/mmdetection/configs/centernet/centernet_r18_8xb16-crop512-140e_coco.py new file mode 100644 index 00000000..6094b642 --- /dev/null +++ b/mmdetection/configs/centernet/centernet_r18_8xb16-crop512-140e_coco.py @@ -0,0 +1,3 @@ +_base_ = './centernet_r18-dcnv2_8xb16-crop512-140e_coco.py' + +model = dict(neck=dict(use_dcn=False)) diff --git a/mmdetection/configs/centernet/centernet_tta.py b/mmdetection/configs/centernet/centernet_tta.py new file mode 100644 index 00000000..edd7b03e --- /dev/null +++ b/mmdetection/configs/centernet/centernet_tta.py @@ -0,0 +1,39 @@ +# This is different from the TTA of official CenterNet. + +tta_model = dict( + type='DetTTAModel', + tta_cfg=dict(nms=dict(type='nms', iou_threshold=0.5), max_per_img=100)) + +tta_pipeline = [ + dict(type='LoadImageFromFile', to_float32=True, backend_args=None), + dict( + type='TestTimeAug', + transforms=[ + [ + # ``RandomFlip`` must be placed before ``RandomCenterCropPad``, + # otherwise bounding box coordinates after flipping cannot be + # recovered correctly. + dict(type='RandomFlip', prob=1.), + dict(type='RandomFlip', prob=0.) + ], + [ + dict( + type='RandomCenterCropPad', + ratios=None, + border=None, + mean=[0, 0, 0], + std=[1, 1, 1], + to_rgb=True, + test_mode=True, + test_pad_mode=['logical_or', 31], + test_pad_add_pix=1), + ], + [dict(type='LoadAnnotations', with_bbox=True)], + [ + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'flip', 'flip_direction', 'border')) + ] + ]) +] diff --git a/mmdetection/configs/centernet/metafile.yml b/mmdetection/configs/centernet/metafile.yml new file mode 100644 index 00000000..496b8ea2 --- /dev/null +++ b/mmdetection/configs/centernet/metafile.yml @@ -0,0 +1,60 @@ +Collections: + - Name: CenterNet + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x TITANXP GPUs + Architecture: + - ResNet + Paper: + URL: https://arxiv.org/abs/1904.07850 + Title: 'Objects as Points' + README: configs/centernet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.13.0/mmdet/models/detectors/centernet.py#L10 + Version: v2.13.0 + +Models: + - Name: centernet_r18-dcnv2_8xb16-crop512-140e_coco + In Collection: CenterNet + Config: configs/centernet/centernet_r18-dcnv2_8xb16-crop512-140e_coco.py + Metadata: + Batch Size: 128 + Training Memory (GB): 3.47 + Epochs: 140 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 29.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/centernet/centernet_resnet18_dcnv2_140e_coco/centernet_resnet18_dcnv2_140e_coco_20210702_155131-c8cd631f.pth + + - Name: centernet_r18_8xb16-crop512-140e_coco + In Collection: CenterNet + Config: configs/centernet/centernet_r18_8xb16-crop512-140e_coco.py + Metadata: + Batch Size: 128 + Training Memory (GB): 3.45 + Epochs: 140 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 25.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/centernet/centernet_resnet18_140e_coco/centernet_resnet18_140e_coco_20210705_093630-bb5b3bf7.pth + + - Name: centernet-update_r50-caffe_fpn_ms-1x_coco + In Collection: CenterNet + Config: configs/centernet/centernet-update_r50-caffe_fpn_ms-1x_coco.py + Metadata: + Batch Size: 16 + Training Memory (GB): 3.3 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.2 + Weights: https://download.openmmlab.com/mmdetection/v3.0/centernet/centernet-update_r50-caffe_fpn_ms-1x_coco/centernet-update_r50-caffe_fpn_ms-1x_coco_20230512_203845-8306baf2.pth diff --git a/mmdetection/configs/centripetalnet/README.md b/mmdetection/configs/centripetalnet/README.md new file mode 100644 index 00000000..21edbd26 --- /dev/null +++ b/mmdetection/configs/centripetalnet/README.md @@ -0,0 +1,36 @@ +# CentripetalNet + +> [CentripetalNet: Pursuing High-quality Keypoint Pairs for Object Detection](https://arxiv.org/abs/2003.09119) + + + +## Abstract + +Keypoint-based detectors have achieved pretty-well performance. However, incorrect keypoint matching is still widespread and greatly affects the performance of the detector. In this paper, we propose CentripetalNet which uses centripetal shift to pair corner keypoints from the same instance. CentripetalNet predicts the position and the centripetal shift of the corner points and matches corners whose shifted results are aligned. Combining position information, our approach matches corner points more accurately than the conventional embedding approaches do. Corner pooling extracts information inside the bounding boxes onto the border. To make this information more aware at the corners, we design a cross-star deformable convolution network to conduct feature adaption. Furthermore, we explore instance segmentation on anchor-free detectors by equipping our CentripetalNet with a mask prediction module. On MS-COCO test-dev, our CentripetalNet not only outperforms all existing anchor-free detectors with an AP of 48.0% but also achieves comparable performance to the state-of-the-art instance segmentation approaches with a 40.2% MaskAP. + +
    + +
    + +## Results and Models + +| Backbone | Batch Size | Step/Total Epochs | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :--------------: | :-----------------------------------------------------------------------: | :---------------: | :------: | :------------: | :----: | :-----------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| HourglassNet-104 | [16 x 6](./centripetalnet_hourglass104_16xb6-crop511-210e-mstest_coco.py) | 190/210 | 16.7 | 3.7 | 44.8 | [config](./centripetalnet_hourglass104_16xb6-crop511-210e-mstest_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/centripetalnet/centripetalnet_hourglass104_mstest_16x6_210e_coco/centripetalnet_hourglass104_mstest_16x6_210e_coco_20200915_204804-3ccc61e5.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/centripetalnet/centripetalnet_hourglass104_mstest_16x6_210e_coco/centripetalnet_hourglass104_mstest_16x6_210e_coco_20200915_204804.log.json) | + +Note: + +- TTA setting is single-scale and `flip=True`. If you want to reproduce the TTA performance, please add `--tta` in the test command. +- The model we released is the best checkpoint rather than the latest checkpoint (box AP 44.8 vs 44.6 in our experiment). + +## Citation + +```latex +@InProceedings{Dong_2020_CVPR, +author = {Dong, Zhiwei and Li, Guoxuan and Liao, Yue and Wang, Fei and Ren, Pengju and Qian, Chen}, +title = {CentripetalNet: Pursuing High-Quality Keypoint Pairs for Object Detection}, +booktitle = {Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)}, +month = {June}, +year = {2020} +} +``` diff --git a/mmdetection/configs/centripetalnet/centripetalnet_hourglass104_16xb6-crop511-210e-mstest_coco.py b/mmdetection/configs/centripetalnet/centripetalnet_hourglass104_16xb6-crop511-210e-mstest_coco.py new file mode 100644 index 00000000..b757ffd1 --- /dev/null +++ b/mmdetection/configs/centripetalnet/centripetalnet_hourglass104_16xb6-crop511-210e-mstest_coco.py @@ -0,0 +1,181 @@ +_base_ = [ + '../_base_/default_runtime.py', '../_base_/datasets/coco_detection.py' +] + +data_preprocessor = dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True) + +# model settings +model = dict( + type='CornerNet', + data_preprocessor=data_preprocessor, + backbone=dict( + type='HourglassNet', + downsample_times=5, + num_stacks=2, + stage_channels=[256, 256, 384, 384, 384, 512], + stage_blocks=[2, 2, 2, 2, 2, 4], + norm_cfg=dict(type='BN', requires_grad=True)), + neck=None, + bbox_head=dict( + type='CentripetalHead', + num_classes=80, + in_channels=256, + num_feat_levels=2, + corner_emb_channels=0, + loss_heatmap=dict( + type='GaussianFocalLoss', alpha=2.0, gamma=4.0, loss_weight=1), + loss_offset=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1), + loss_guiding_shift=dict( + type='SmoothL1Loss', beta=1.0, loss_weight=0.05), + loss_centripetal_shift=dict( + type='SmoothL1Loss', beta=1.0, loss_weight=1)), + # training and testing settings + train_cfg=None, + test_cfg=dict( + corner_topk=100, + local_maximum_kernel=3, + distance_threshold=0.5, + score_thr=0.05, + max_per_img=100, + nms=dict(type='soft_nms', iou_threshold=0.5, method='gaussian'))) + +# data settings +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict( + # The cropped images are padded into squares during training, + # but may be smaller than crop_size. + type='RandomCenterCropPad', + crop_size=(511, 511), + ratios=(0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3), + test_mode=False, + test_pad_mode=None, + mean=data_preprocessor['mean'], + std=data_preprocessor['std'], + # Image data is not converted to rgb. + to_rgb=data_preprocessor['bgr_to_rgb']), + dict(type='Resize', scale=(511, 511), keep_ratio=False), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs'), +] + +test_pipeline = [ + dict( + type='LoadImageFromFile', + to_float32=True, + backend_args=_base_.backend_args), + # don't need Resize + dict( + type='RandomCenterCropPad', + crop_size=None, + ratios=None, + border=None, + test_mode=True, + test_pad_mode=['logical_or', 127], + mean=data_preprocessor['mean'], + std=data_preprocessor['std'], + # Image data is not converted to rgb. + to_rgb=data_preprocessor['bgr_to_rgb']), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'border')) +] + +train_dataloader = dict( + batch_size=6, + num_workers=3, + batch_sampler=None, + dataset=dict(pipeline=train_pipeline)) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='Adam', lr=0.0005), + clip_grad=dict(max_norm=35, norm_type=2)) + +max_epochs = 210 + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0 / 3, + by_epoch=False, + begin=0, + end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[190], + gamma=0.1) +] + +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (16 GPUs) x (6 samples per GPU) +auto_scale_lr = dict(base_batch_size=96) + +tta_model = dict( + type='DetTTAModel', + tta_cfg=dict( + nms=dict(type='soft_nms', iou_threshold=0.5, method='gaussian'), + max_per_img=100)) + +tta_pipeline = [ + dict( + type='LoadImageFromFile', + to_float32=True, + backend_args=_base_.backend_args), + dict( + type='TestTimeAug', + transforms=[ + [ + # ``RandomFlip`` must be placed before ``RandomCenterCropPad``, + # otherwise bounding box coordinates after flipping cannot be + # recovered correctly. + dict(type='RandomFlip', prob=1.), + dict(type='RandomFlip', prob=0.) + ], + [ + dict( + type='RandomCenterCropPad', + crop_size=None, + ratios=None, + border=None, + test_mode=True, + test_pad_mode=['logical_or', 127], + mean=data_preprocessor['mean'], + std=data_preprocessor['std'], + # Image data is not converted to rgb. + to_rgb=data_preprocessor['bgr_to_rgb']) + ], + [dict(type='LoadAnnotations', with_bbox=True)], + [ + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'flip', 'flip_direction', 'border')) + ] + ]) +] diff --git a/mmdetection/configs/centripetalnet/metafile.yml b/mmdetection/configs/centripetalnet/metafile.yml new file mode 100644 index 00000000..526572df --- /dev/null +++ b/mmdetection/configs/centripetalnet/metafile.yml @@ -0,0 +1,39 @@ +Collections: + - Name: CentripetalNet + Metadata: + Training Data: COCO + Training Techniques: + - Adam + Training Resources: 16x V100 GPUs + Architecture: + - Corner Pooling + - Stacked Hourglass Network + Paper: + URL: https://arxiv.org/abs/2003.09119 + Title: 'CentripetalNet: Pursuing High-quality Keypoint Pairs for Object Detection' + README: configs/centripetalnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.5.0/mmdet/models/detectors/cornernet.py#L9 + Version: v2.5.0 + +Models: + - Name: centripetalnet_hourglass104_16xb6-crop511-210e-mstest_coco + In Collection: CentripetalNet + Config: configs/centripetalnet/centripetalnet_hourglass104_16xb6-crop511-210e-mstest_coco.py + Metadata: + Batch Size: 96 + Training Memory (GB): 16.7 + inference time (ms/im): + - value: 270.27 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 210 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/centripetalnet/centripetalnet_hourglass104_mstest_16x6_210e_coco/centripetalnet_hourglass104_mstest_16x6_210e_coco_20200915_204804-3ccc61e5.pth diff --git a/mmdetection/configs/cityscapes/README.md b/mmdetection/configs/cityscapes/README.md new file mode 100644 index 00000000..9e37b64e --- /dev/null +++ b/mmdetection/configs/cityscapes/README.md @@ -0,0 +1,46 @@ +# Cityscapes + +> [The Cityscapes Dataset for Semantic Urban Scene Understanding](https://arxiv.org/abs/1604.01685) + + + +## Abstract + +Visual understanding of complex urban street scenes is an enabling factor for a wide range of applications. Object detection has benefited enormously from large-scale datasets, especially in the context of deep learning. For semantic urban scene understanding, however, no current dataset adequately captures the complexity of real-world urban scenes. +To address this, we introduce Cityscapes, a benchmark suite and large-scale dataset to train and test approaches for pixel-level and instance-level semantic labeling. Cityscapes is comprised of a large, diverse set of stereo video sequences recorded in streets from 50 different cities. 5000 of these images have high quality pixel-level annotations; 20000 additional images have coarse annotations to enable methods that leverage large volumes of weakly-labeled data. Crucially, our effort exceeds previous attempts in terms of dataset size, annotation richness, scene variability, and complexity. Our accompanying empirical study provides an in-depth analysis of the dataset characteristics, as well as a performance evaluation of several state-of-the-art approaches based on our benchmark. + +
    + +
    + +## Common settings + +- All baselines were trained using 8 GPU with a batch size of 8 (1 images per GPU) using the [linear scaling rule](https://arxiv.org/abs/1706.02677) to scale the learning rate. +- All models were trained on `cityscapes_train`, and tested on `cityscapes_val`. +- 1x training schedule indicates 64 epochs which corresponds to slightly less than the 24k iterations reported in the original schedule from the [Mask R-CNN paper](https://arxiv.org/abs/1703.06870) +- COCO pre-trained weights are used to initialize. +- A conversion [script](../../tools/dataset_converters/cityscapes.py) is provided to convert Cityscapes into COCO format. Please refer to [install.md](../../docs/1_exist_data_model.md#prepare-datasets) for details. +- `CityscapesDataset` implemented three evaluation methods. `bbox` and `segm` are standard COCO bbox/mask AP. `cityscapes` is the cityscapes dataset official evaluation, which may be slightly higher than COCO. + +### Faster R-CNN + +| Backbone | Style | Lr schd | Scale | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :------: | :-----: | :-----: | :------: | :------: | :------------: | :----: | :----------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | pytorch | 1x | 800-1024 | 5.2 | - | 40.3 | [config](./faster-rcnn_r50_fpn_1x_cityscapes.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cityscapes/faster_rcnn_r50_fpn_1x_cityscapes_20200502-829424c0.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cityscapes/faster_rcnn_r50_fpn_1x_cityscapes_20200502_114915.log.json) | + +### Mask R-CNN + +| Backbone | Style | Lr schd | Scale | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :------: | :-----: | :-----: | :------: | :------: | :------------: | :----: | :-----: | :--------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | pytorch | 1x | 800-1024 | 5.3 | - | 40.9 | 36.4 | [config](./mask-rcnn_r50_fpn_1x_cityscapes.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cityscapes/mask_rcnn_r50_fpn_1x_cityscapes/mask_rcnn_r50_fpn_1x_cityscapes_20201211_133733-d2858245.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cityscapes/mask_rcnn_r50_fpn_1x_cityscapes/mask_rcnn_r50_fpn_1x_cityscapes_20201211_133733.log.json) | + +## Citation + +```latex +@inproceedings{Cordts2016Cityscapes, + title={The Cityscapes Dataset for Semantic Urban Scene Understanding}, + author={Cordts, Marius and Omran, Mohamed and Ramos, Sebastian and Rehfeld, Timo and Enzweiler, Markus and Benenson, Rodrigo and Franke, Uwe and Roth, Stefan and Schiele, Bernt}, + booktitle={Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR)}, + year={2016} +} +``` diff --git a/mmdetection/configs/cityscapes/faster-rcnn_r50_fpn_1x_cityscapes.py b/mmdetection/configs/cityscapes/faster-rcnn_r50_fpn_1x_cityscapes.py new file mode 100644 index 00000000..ccd0de2a --- /dev/null +++ b/mmdetection/configs/cityscapes/faster-rcnn_r50_fpn_1x_cityscapes.py @@ -0,0 +1,41 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../_base_/datasets/cityscapes_detection.py', + '../_base_/default_runtime.py', '../_base_/schedules/schedule_1x.py' +] +model = dict( + backbone=dict(init_cfg=None), + roi_head=dict( + bbox_head=dict( + num_classes=8, + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0)))) + +# optimizer +# lr is set for a batch size of 8 +optim_wrapper = dict(optimizer=dict(lr=0.01)) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=8, + by_epoch=True, + # [7] yields higher performance than [6] + milestones=[7], + gamma=0.1) +] + +# actual epoch = 8 * 8 = 64 +train_cfg = dict(max_epochs=8) + +# For better, more stable performance initialize from COCO +load_from = 'https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth' # noqa + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (1 samples per GPU) +# TODO: support auto scaling lr +# auto_scale_lr = dict(base_batch_size=8) diff --git a/mmdetection/configs/cityscapes/mask-rcnn_r50_fpn_1x_cityscapes.py b/mmdetection/configs/cityscapes/mask-rcnn_r50_fpn_1x_cityscapes.py new file mode 100644 index 00000000..772268b1 --- /dev/null +++ b/mmdetection/configs/cityscapes/mask-rcnn_r50_fpn_1x_cityscapes.py @@ -0,0 +1,43 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/cityscapes_instance.py', + '../_base_/default_runtime.py', '../_base_/schedules/schedule_1x.py' +] +model = dict( + backbone=dict(init_cfg=None), + roi_head=dict( + bbox_head=dict( + type='Shared2FCBBoxHead', + num_classes=8, + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0)), + mask_head=dict(num_classes=8))) + +# optimizer +# lr is set for a batch size of 8 +optim_wrapper = dict(optimizer=dict(lr=0.01)) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=8, + by_epoch=True, + # [7] yields higher performance than [6] + milestones=[7], + gamma=0.1) +] + +# actual epoch = 8 * 8 = 64 +train_cfg = dict(max_epochs=8) + +# For better, more stable performance initialize from COCO +load_from = 'https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_fpn_1x_coco/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth' # noqa + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (1 samples per GPU) +# TODO: support auto scaling lr +# auto_scale_lr = dict(base_batch_size=8) diff --git a/mmdetection/configs/common/lsj-100e_coco-detection.py b/mmdetection/configs/common/lsj-100e_coco-detection.py new file mode 100644 index 00000000..bb631e5d --- /dev/null +++ b/mmdetection/configs/common/lsj-100e_coco-detection.py @@ -0,0 +1,122 @@ +_base_ = '../_base_/default_runtime.py' +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/coco/' +image_size = (1024, 1024) + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/coco/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomResize', + scale=image_size, + ratio_range=(0.1, 2.0), + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=image_size, + recompute_bbox=True, + allow_negative_crop=True), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +# Use RepeatDataset to speed up training +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + dataset=dict( + type='RepeatDataset', + times=4, # simply change this from 2 to 16 for 50e - 400e training. + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args=backend_args))) +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'annotations/instances_val2017.json', + metric='bbox', + format_only=False, + backend_args=backend_args) +test_evaluator = val_evaluator + +max_epochs = 25 + +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=5) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# optimizer assumes bs=64 +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.1, momentum=0.9, weight_decay=0.00004)) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.067, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[22, 24], + gamma=0.1) +] + +# only keep latest 2 checkpoints +default_hooks = dict(checkpoint=dict(max_keep_ckpts=2)) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (32 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/common/lsj-100e_coco-instance.py b/mmdetection/configs/common/lsj-100e_coco-instance.py new file mode 100644 index 00000000..6e62729d --- /dev/null +++ b/mmdetection/configs/common/lsj-100e_coco-instance.py @@ -0,0 +1,122 @@ +_base_ = '../_base_/default_runtime.py' +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/coco/' +image_size = (1024, 1024) + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/coco/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='RandomResize', + scale=image_size, + ratio_range=(0.1, 2.0), + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=image_size, + recompute_bbox=True, + allow_negative_crop=True), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +# Use RepeatDataset to speed up training +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + dataset=dict( + type='RepeatDataset', + times=4, # simply change this from 2 to 16 for 50e - 400e training. + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args=backend_args))) +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'annotations/instances_val2017.json', + metric=['bbox', 'segm'], + format_only=False, + backend_args=backend_args) +test_evaluator = val_evaluator + +max_epochs = 25 + +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=5) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# optimizer assumes bs=64 +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.1, momentum=0.9, weight_decay=0.00004)) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.067, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[22, 24], + gamma=0.1) +] + +# only keep latest 2 checkpoints +default_hooks = dict(checkpoint=dict(max_keep_ckpts=2)) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (32 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/common/lsj-200e_coco-detection.py b/mmdetection/configs/common/lsj-200e_coco-detection.py new file mode 100644 index 00000000..83d12947 --- /dev/null +++ b/mmdetection/configs/common/lsj-200e_coco-detection.py @@ -0,0 +1,18 @@ +_base_ = './lsj-100e_coco-detection.py' + +# 8x25=200e +train_dataloader = dict(dataset=dict(times=8)) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.067, by_epoch=False, begin=0, + end=1000), + dict( + type='MultiStepLR', + begin=0, + end=25, + by_epoch=True, + milestones=[22, 24], + gamma=0.1) +] diff --git a/mmdetection/configs/common/lsj-200e_coco-instance.py b/mmdetection/configs/common/lsj-200e_coco-instance.py new file mode 100644 index 00000000..af3e4bf1 --- /dev/null +++ b/mmdetection/configs/common/lsj-200e_coco-instance.py @@ -0,0 +1,18 @@ +_base_ = './lsj-100e_coco-instance.py' + +# 8x25=200e +train_dataloader = dict(dataset=dict(times=8)) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.067, by_epoch=False, begin=0, + end=1000), + dict( + type='MultiStepLR', + begin=0, + end=25, + by_epoch=True, + milestones=[22, 24], + gamma=0.1) +] diff --git a/mmdetection/configs/common/ms-90k_coco.py b/mmdetection/configs/common/ms-90k_coco.py new file mode 100644 index 00000000..e2d6c3da --- /dev/null +++ b/mmdetection/configs/common/ms-90k_coco.py @@ -0,0 +1,122 @@ +_base_ = '../_base_/default_runtime.py' + +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/coco/' +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/coco/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +# Align with Detectron2 +backend = 'pillow' +train_pipeline = [ + dict( + type='LoadImageFromFile', + backend_args=backend_args, + imdecode_backend=backend), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736), + (1333, 768), (1333, 800)], + keep_ratio=True, + backend=backend), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict( + type='LoadImageFromFile', + backend_args=backend_args, + imdecode_backend=backend), + dict(type='Resize', scale=(1333, 800), keep_ratio=True, backend=backend), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + pin_memory=True, + sampler=dict(type='InfiniteSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args=backend_args)) +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + pin_memory=True, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'annotations/instances_val2017.json', + metric='bbox', + format_only=False, + backend_args=backend_args) +test_evaluator = val_evaluator + +# training schedule for 90k +max_iter = 90000 +train_cfg = dict( + type='IterBasedTrainLoop', max_iters=max_iter, val_interval=10000) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, + end=1000), + dict( + type='MultiStepLR', + begin=0, + end=max_iter, + by_epoch=False, + milestones=[60000, 80000], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)) +# Default setting for scaling LR automatically +# - `enable` means enable scaling LR automatically +# or not by default. +# - `base_batch_size` = (8 GPUs) x (2 samples per GPU). +auto_scale_lr = dict(enable=False, base_batch_size=16) + +default_hooks = dict(checkpoint=dict(by_epoch=False, interval=10000)) +log_processor = dict(by_epoch=False) diff --git a/mmdetection/configs/common/ms-poly-90k_coco-instance.py b/mmdetection/configs/common/ms-poly-90k_coco-instance.py new file mode 100644 index 00000000..d5566b3c --- /dev/null +++ b/mmdetection/configs/common/ms-poly-90k_coco-instance.py @@ -0,0 +1,130 @@ +_base_ = '../_base_/default_runtime.py' + +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/coco/' +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/coco/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +# Align with Detectron2 +backend = 'pillow' +train_pipeline = [ + dict( + type='LoadImageFromFile', + backend_args=backend_args, + imdecode_backend=backend), + dict( + type='LoadAnnotations', + with_bbox=True, + with_mask=True, + poly2mask=False), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736), + (1333, 768), (1333, 800)], + keep_ratio=True, + backend=backend), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict( + type='LoadImageFromFile', + backend_args=backend_args, + imdecode_backend=backend), + dict(type='Resize', scale=(1333, 800), keep_ratio=True, backend=backend), + dict( + type='LoadAnnotations', + with_bbox=True, + with_mask=True, + poly2mask=False), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + pin_memory=True, + sampler=dict(type='InfiniteSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args=backend_args)) +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + pin_memory=True, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'annotations/instances_val2017.json', + metric=['bbox', 'segm'], + format_only=False, + backend_args=backend_args) +test_evaluator = val_evaluator + +# training schedule for 90k +max_iter = 90000 +train_cfg = dict( + type='IterBasedTrainLoop', max_iters=max_iter, val_interval=10000) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, + end=1000), + dict( + type='MultiStepLR', + begin=0, + end=max_iter, + by_epoch=False, + milestones=[60000, 80000], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)) +# Default setting for scaling LR automatically +# - `enable` means enable scaling LR automatically +# or not by default. +# - `base_batch_size` = (8 GPUs) x (2 samples per GPU). +auto_scale_lr = dict(enable=False, base_batch_size=16) + +default_hooks = dict(checkpoint=dict(by_epoch=False, interval=10000)) +log_processor = dict(by_epoch=False) diff --git a/mmdetection/configs/common/ms-poly_3x_coco-instance.py b/mmdetection/configs/common/ms-poly_3x_coco-instance.py new file mode 100644 index 00000000..04072f9b --- /dev/null +++ b/mmdetection/configs/common/ms-poly_3x_coco-instance.py @@ -0,0 +1,118 @@ +_base_ = '../_base_/default_runtime.py' +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/coco/' + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/coco/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +# In mstrain 3x config, img_scale=[(1333, 640), (1333, 800)], +# multiscale_mode='range' +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict( + type='LoadAnnotations', + with_bbox=True, + with_mask=True, + poly2mask=False), + dict( + type='RandomResize', scale=[(1333, 640), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs'), +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict( + type='LoadAnnotations', + with_bbox=True, + with_mask=True, + poly2mask=False), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type='RepeatDataset', + times=3, + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args=backend_args))) +val_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'annotations/instances_val2017.json', + metric=['bbox', 'segm'], + backend_args=backend_args) +test_evaluator = val_evaluator + +# training schedule for 3x with `RepeatDataset` +train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=12, val_interval=1) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# learning rate +# Experiments show that using milestones=[9, 11] has higher performance +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=12, + by_epoch=True, + milestones=[9, 11], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)) + +# Default setting for scaling LR automatically +# - `enable` means enable scaling LR automatically +# or not by default. +# - `base_batch_size` = (8 GPUs) x (2 samples per GPU). +auto_scale_lr = dict(enable=False, base_batch_size=16) diff --git a/mmdetection/configs/common/ms_3x_coco-instance.py b/mmdetection/configs/common/ms_3x_coco-instance.py new file mode 100644 index 00000000..f80cf88e --- /dev/null +++ b/mmdetection/configs/common/ms_3x_coco-instance.py @@ -0,0 +1,108 @@ +_base_ = '../_base_/default_runtime.py' + +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/coco/' + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/coco/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='RandomResize', scale=[(1333, 640), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type='RepeatDataset', + times=3, + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args=backend_args))) +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'annotations/instances_val2017.json', + metric='bbox', + backend_args=backend_args) +test_evaluator = val_evaluator + +# training schedule for 3x with `RepeatDataset` +train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=12, val_interval=1) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# learning rate +# Experiments show that using milestones=[9, 11] has higher performance +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=12, + by_epoch=True, + milestones=[9, 11], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)) + +# Default setting for scaling LR automatically +# - `enable` means enable scaling LR automatically +# or not by default. +# - `base_batch_size` = (8 GPUs) x (2 samples per GPU). +auto_scale_lr = dict(enable=False, base_batch_size=16) diff --git a/mmdetection/configs/common/ms_3x_coco.py b/mmdetection/configs/common/ms_3x_coco.py new file mode 100644 index 00000000..facbb34c --- /dev/null +++ b/mmdetection/configs/common/ms_3x_coco.py @@ -0,0 +1,108 @@ +_base_ = '../_base_/default_runtime.py' + +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/coco/' + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/coco/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomResize', scale=[(1333, 640), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type='RepeatDataset', + times=3, + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args=backend_args))) +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'annotations/instances_val2017.json', + metric='bbox', + backend_args=backend_args) +test_evaluator = val_evaluator + +# training schedule for 3x with `RepeatDataset` +train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=12, val_interval=1) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# learning rate +# Experiments show that using milestones=[9, 11] has higher performance +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=12, + by_epoch=True, + milestones=[9, 11], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)) + +# Default setting for scaling LR automatically +# - `enable` means enable scaling LR automatically +# or not by default. +# - `base_batch_size` = (8 GPUs) x (2 samples per GPU). +auto_scale_lr = dict(enable=False, base_batch_size=16) diff --git a/mmdetection/configs/common/ssj_270k_coco-instance.py b/mmdetection/configs/common/ssj_270k_coco-instance.py new file mode 100644 index 00000000..7407644f --- /dev/null +++ b/mmdetection/configs/common/ssj_270k_coco-instance.py @@ -0,0 +1,125 @@ +_base_ = '../_base_/default_runtime.py' +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/coco/' + +image_size = (1024, 1024) + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/coco/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +# Standard Scale Jittering (SSJ) resizes and crops an image +# with a resize range of 0.8 to 1.25 of the original image size. +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='RandomResize', + scale=image_size, + ratio_range=(0.8, 1.25), + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=image_size, + recompute_bbox=True, + allow_negative_crop=True), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict( + batch_size=2, + num_workers=2, + persistent_workers=True, + sampler=dict(type='InfiniteSampler'), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args=backend_args)) +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'annotations/instances_val2017.json', + metric=['bbox', 'segm'], + format_only=False, + backend_args=backend_args) +test_evaluator = val_evaluator + +# The model is trained by 270k iterations with batch_size 64, +# which is roughly equivalent to 144 epochs. + +max_iters = 270000 +train_cfg = dict( + type='IterBasedTrainLoop', max_iters=max_iters, val_interval=10000) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# optimizer assumes bs=64 +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.1, momentum=0.9, weight_decay=0.00004)) + +# learning rate policy +# lr steps at [0.9, 0.95, 0.975] of the maximum iterations +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, + end=1000), + dict( + type='MultiStepLR', + begin=0, + end=270000, + by_epoch=False, + milestones=[243000, 256500, 263250], + gamma=0.1) +] + +default_hooks = dict(checkpoint=dict(by_epoch=False, interval=10000)) +log_processor = dict(by_epoch=False) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (32 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/common/ssj_scp_270k_coco-instance.py b/mmdetection/configs/common/ssj_scp_270k_coco-instance.py new file mode 100644 index 00000000..06159dd4 --- /dev/null +++ b/mmdetection/configs/common/ssj_scp_270k_coco-instance.py @@ -0,0 +1,60 @@ +_base_ = 'ssj_270k_coco-instance.py' +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/coco/' + +image_size = (1024, 1024) + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/coco/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +# Standard Scale Jittering (SSJ) resizes and crops an image +# with a resize range of 0.8 to 1.25 of the original image size. +load_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='RandomResize', + scale=image_size, + ratio_range=(0.8, 1.25), + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=image_size, + recompute_bbox=True, + allow_negative_crop=True), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict(type='RandomFlip', prob=0.5), + dict(type='Pad', size=image_size), +] +train_pipeline = [ + dict(type='CopyPaste', max_num_pasted=100), + dict(type='PackDetInputs') +] + +train_dataloader = dict( + dataset=dict( + _delete_=True, + type='MultiImageMixDataset', + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=load_pipeline, + backend_args=backend_args), + pipeline=train_pipeline)) diff --git a/mmdetection/configs/condinst/README.md b/mmdetection/configs/condinst/README.md new file mode 100644 index 00000000..01deb0ec --- /dev/null +++ b/mmdetection/configs/condinst/README.md @@ -0,0 +1,40 @@ +# CondInst + +> [CondInst: Conditional Convolutions for Instance +> Segmentation](https://arxiv.org/pdf/2003.05664.pdf) + + + +## Abstract + +We propose a simple yet effective instance segmentation framework, termed CondInst (conditional convolutions for instance segmentation). Top-performing instance segmentation methods such as Mask +R-CNN rely on ROI operations (typically ROIPool or ROIAlign) to +obtain the final instance masks. In contrast, we propose to solve instance segmentation from a new perspective. Instead of using instancewise ROIs as inputs to a network of fixed weights, we employ dynamic +instance-aware networks, conditioned on instances. CondInst enjoys two +advantages: 1) Instance segmentation is solved by a fully convolutional +network, eliminating the need for ROI cropping and feature alignment. +2\) Due to the much improved capacity of dynamically-generated conditional convolutions, the mask head can be very compact (e.g., 3 conv. +layers, each having only 8 channels), leading to significantly faster inference. We demonstrate a simpler instance segmentation method that can +achieve improved performance in both accuracy and inference speed. On +the COCO dataset, we outperform a few recent methods including welltuned Mask R-CNN baselines, without longer training schedules needed. + +
    + +
    + +## Results and Models + +| Backbone | Style | MS train | Lr schd | bbox AP | mask AP | Config | Download | +| :------: | :-----: | :------: | :-----: | :-----: | :-----: | :-------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | pytorch | Y | 1x | 39.8 | 36.0 | [config](./condinst_r50_fpn_ms-poly-90k_coco_instance.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/condinst/condinst_r50_fpn_ms-poly-90k_coco_instance/condinst_r50_fpn_ms-poly-90k_coco_instance_20221129_125223-4c186406.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/condinst/condinst_r50_fpn_ms-poly-90k_coco_instance/condinst_r50_fpn_ms-poly-90k_coco_instance_20221129_125223.json) | + +## Citation + +```latex +@inproceedings{tian2020conditional, + title = {Conditional Convolutions for Instance Segmentation}, + author = {Tian, Zhi and Shen, Chunhua and Chen, Hao}, + booktitle = {Proc. Eur. Conf. Computer Vision (ECCV)}, + year = {2020} +} +``` diff --git a/mmdetection/configs/condinst/condinst_r50_fpn_ms-poly-90k_coco_instance.py b/mmdetection/configs/condinst/condinst_r50_fpn_ms-poly-90k_coco_instance.py new file mode 100644 index 00000000..39639d87 --- /dev/null +++ b/mmdetection/configs/condinst/condinst_r50_fpn_ms-poly-90k_coco_instance.py @@ -0,0 +1,85 @@ +_base_ = '../common/ms-poly-90k_coco-instance.py' + +# model settings +model = dict( + type='CondInst', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_mask=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50'), + style='pytorch'), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_output', # use P5 + num_outs=5, + relu_before_extra_convs=True), + bbox_head=dict( + type='CondInstBboxHead', + num_params=169, + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + strides=[8, 16, 32, 64, 128], + norm_on_bbox=True, + centerness_on_reg=True, + dcn_on_last_conv=False, + center_sampling=True, + conv_bias=True, + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=1.0), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)), + mask_head=dict( + type='CondInstMaskHead', + num_layers=3, + feat_channels=8, + size_of_interest=8, + mask_out_stride=4, + max_masks_to_train=300, + mask_feature_head=dict( + in_channels=256, + feat_channels=128, + start_level=0, + end_level=2, + out_channels=8, + mask_stride=8, + num_stacked_convs=4, + norm_cfg=dict(type='BN', requires_grad=True)), + loss_mask=dict( + type='DiceLoss', + use_sigmoid=True, + activate=True, + eps=5e-6, + loss_weight=1.0)), + # model training and testing settings + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100, + mask_thr=0.5)) + +# optimizer +optim_wrapper = dict(optimizer=dict(lr=0.01)) diff --git a/mmdetection/configs/condinst/metafile.yml b/mmdetection/configs/condinst/metafile.yml new file mode 100644 index 00000000..1237b74d --- /dev/null +++ b/mmdetection/configs/condinst/metafile.yml @@ -0,0 +1,32 @@ +Collections: + - Name: CondInst + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x A100 GPUs + Architecture: + - FPN + - FCOS + - ResNet + Paper: https://arxiv.org/abs/2003.05664 + README: configs/condinst/README.md + +Models: + - Name: condinst_r50_fpn_ms-poly-90k_coco_instance + In Collection: CondInst + Config: configs/condinst/condinst_r50_fpn_ms-poly-90k_coco_instance.py + Metadata: + Training Memory (GB): 4.4 + Iterations: 90000 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.0 + Weights: https://download.openmmlab.com/mmdetection/v3.0/condinst/condinst_r50_fpn_ms-poly-90k_coco_instance/condinst_r50_fpn_ms-poly-90k_coco_instance_20221129_125223-4c186406.pth diff --git a/mmdetection/configs/conditional_detr/README.md b/mmdetection/configs/conditional_detr/README.md new file mode 100644 index 00000000..4043571c --- /dev/null +++ b/mmdetection/configs/conditional_detr/README.md @@ -0,0 +1,39 @@ +# Conditional DETR + +> [Conditional DETR for Fast Training Convergence](https://arxiv.org/abs/2108.06152) + + + +## Abstract + +The DETR approach applies the transformer encoder and decoder architecture to object detection and achieves promising performance. In this paper, we handle the critical issue, slow training convergence, and present a conditional cross-attention mechanism for fast DETR training. Our approach is motivated by that the cross-attention in DETR relies highly on the content embeddings and that the spatial embeddings make minor contributions, increasing the need for high-quality content embeddings and thus increasing the training difficulty. + +
    + +
    + +Our conditional DETR learns a conditional spatial query from the decoder embedding for decoder multi-head cross-attention. The benefit is that through the conditional spatial query, each cross-attention head is able to attend to a band containing a distinct region, e.g., one object extremity or a region inside the object box (Figure 1). This narrows down the spatial range for localizing the distinct regions for object classification and box regression, thus relaxing the dependence on the content embeddings and easing the training. Empirical results show that conditional DETR converges 6.7x faster for the backbones R50 and R101 and 10x faster for stronger backbones DC5-R50 and DC5-R101. + +
    + + +
    + +## Results and Models + +We provide the config files and models for Conditional DETR: [Conditional DETR for Fast Training Convergence](https://arxiv.org/abs/2108.06152). + +| Backbone | Model | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :------: | :--------------: | :-----: | :------: | :------------: | :----: | :-----------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | Conditional DETR | 50e | | | 41.1 | [config](./conditional-detr_r50_8xb2-50e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/conditional_detr/conditional-detr_r50_8xb2-50e_coco/conditional-detr_r50_8xb2-50e_coco_20221121_180202-c83a1dc0.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/conditional_detr/conditional-detr_r50_8xb2-50e_coco/conditional-detr_r50_8xb2-50e_coco_20221121_180202.log.json) | + +## Citation + +```latex +@inproceedings{meng2021-CondDETR, + title = {Conditional DETR for Fast Training Convergence}, + author = {Meng, Depu and Chen, Xiaokang and Fan, Zejia and Zeng, Gang and Li, Houqiang and Yuan, Yuhui and Sun, Lei and Wang, Jingdong}, + booktitle = {Proceedings of the IEEE International Conference on Computer Vision (ICCV)}, + year = {2021} +} +``` diff --git a/mmdetection/configs/conditional_detr/conditional-detr_r50_8xb2-50e_coco.py b/mmdetection/configs/conditional_detr/conditional-detr_r50_8xb2-50e_coco.py new file mode 100644 index 00000000..a2147644 --- /dev/null +++ b/mmdetection/configs/conditional_detr/conditional-detr_r50_8xb2-50e_coco.py @@ -0,0 +1,42 @@ +_base_ = ['../detr/detr_r50_8xb2-150e_coco.py'] +model = dict( + type='ConditionalDETR', + num_queries=300, + decoder=dict( + num_layers=6, + layer_cfg=dict( + self_attn_cfg=dict( + _delete_=True, + embed_dims=256, + num_heads=8, + attn_drop=0.1, + cross_attn=False), + cross_attn_cfg=dict( + _delete_=True, + embed_dims=256, + num_heads=8, + attn_drop=0.1, + cross_attn=True))), + bbox_head=dict( + type='ConditionalDETRHead', + loss_cls=dict( + _delete_=True, + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=2.0)), + # training and testing settings + train_cfg=dict( + assigner=dict( + type='HungarianAssigner', + match_costs=[ + dict(type='FocalLossCost', weight=2.0), + dict(type='BBoxL1Cost', weight=5.0, box_format='xywh'), + dict(type='IoUCost', iou_mode='giou', weight=2.0) + ]))) + +# learning policy +train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=50, val_interval=1) + +param_scheduler = [dict(type='MultiStepLR', end=50, milestones=[40])] diff --git a/mmdetection/configs/conditional_detr/metafile.yml b/mmdetection/configs/conditional_detr/metafile.yml new file mode 100644 index 00000000..83f5532c --- /dev/null +++ b/mmdetection/configs/conditional_detr/metafile.yml @@ -0,0 +1,32 @@ +Collections: + - Name: Conditional DETR + Metadata: + Training Data: COCO + Training Techniques: + - AdamW + - Multi Scale Train + - Gradient Clip + Training Resources: 8x A100 GPUs + Architecture: + - ResNet + - Transformer + Paper: + URL: https://arxiv.org/abs/2108.06152 + Title: 'Conditional DETR for Fast Training Convergence' + README: configs/conditional_detr/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/f4112c9e5611468ffbd57cfba548fd1289264b52/mmdet/models/detectors/conditional_detr.py#L14 + Version: v3.0.0rc6 + +Models: + - Name: conditional-detr_r50_8xb2-50e_coco + In Collection: Conditional DETR + Config: configs/conditional_detr/conditional-detr_r50_8xb2-50e_coco.py + Metadata: + Epochs: 50 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.9 + Weights: https://download.openmmlab.com/mmdetection/v3.0/conditional_detr/conditional-detr_r50_8xb2-50e_coco/conditional-detr_r50_8xb2-50e_coco_20221121_180202-c83a1dc0.pth diff --git a/mmdetection/configs/convnext/README.md b/mmdetection/configs/convnext/README.md new file mode 100644 index 00000000..33497bb5 --- /dev/null +++ b/mmdetection/configs/convnext/README.md @@ -0,0 +1,42 @@ +# ConvNeXt + +> [A ConvNet for the 2020s](https://arxiv.org/abs/2201.03545) + + + +## Abstract + +The "Roaring 20s" of visual recognition began with the introduction of Vision Transformers (ViTs), which quickly superseded ConvNets as the state-of-the-art image classification model. A vanilla ViT, on the other hand, faces difficulties when applied to general computer vision tasks such as object detection and semantic segmentation. It is the hierarchical Transformers (e.g., Swin Transformers) that reintroduced several ConvNet priors, making Transformers practically viable as a generic vision backbone and demonstrating remarkable performance on a wide variety of vision tasks. However, the effectiveness of such hybrid approaches is still largely credited to the intrinsic superiority of Transformers, rather than the inherent inductive biases of convolutions. In this work, we reexamine the design spaces and test the limits of what a pure ConvNet can achieve. We gradually "modernize" a standard ResNet toward the design of a vision Transformer, and discover several key components that contribute to the performance difference along the way. The outcome of this exploration is a family of pure ConvNet models dubbed ConvNeXt. Constructed entirely from standard ConvNet modules, ConvNeXts compete favorably with Transformers in terms of accuracy and scalability, achieving 87.8% ImageNet top-1 accuracy and outperforming Swin Transformers on COCO detection and ADE20K segmentation, while maintaining the simplicity and efficiency of standard ConvNets. + +
    + +
    + +## Results and models + +| Method | Backbone | Pretrain | Lr schd | Multi-scale crop | FP16 | Mem (GB) | box AP | mask AP | Config | Download | +| :----------------: | :--------: | :---------: | :-----: | :--------------: | :--: | :------: | :----: | :-----: | :-------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| Mask R-CNN | ConvNeXt-T | ImageNet-1K | 3x | yes | yes | 7.3 | 46.2 | 41.7 | [config](./mask-rcnn_convnext-t-p4-w7_fpn_amp-ms-crop-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/convnext/mask_rcnn_convnext-t_p4_w7_fpn_fp16_ms-crop_3x_coco/mask_rcnn_convnext-t_p4_w7_fpn_fp16_ms-crop_3x_coco_20220426_154953-050731f4.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/convnext/mask_rcnn_convnext-t_p4_w7_fpn_fp16_ms-crop_3x_coco/mask_rcnn_convnext-t_p4_w7_fpn_fp16_ms-crop_3x_coco_20220426_154953.log.json) | +| Cascade Mask R-CNN | ConvNeXt-T | ImageNet-1K | 3x | yes | yes | 9.0 | 50.3 | 43.6 | [config](./cascade-mask-rcnn_convnext-t-p4-w7_fpn_4conv1fc-giou_amp-ms-crop-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/convnext/cascade_mask_rcnn_convnext-t_p4_w7_fpn_giou_4conv1f_fp16_ms-crop_3x_coco/cascade_mask_rcnn_convnext-t_p4_w7_fpn_giou_4conv1f_fp16_ms-crop_3x_coco_20220509_204200-8f07c40b.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/convnext/cascade_mask_rcnn_convnext-t_p4_w7_fpn_giou_4conv1f_fp16_ms-crop_3x_coco/cascade_mask_rcnn_convnext-t_p4_w7_fpn_giou_4conv1f_fp16_ms-crop_3x_coco_20220509_204200.log.json) | +| Cascade Mask R-CNN | ConvNeXt-S | ImageNet-1K | 3x | yes | yes | 12.3 | 51.8 | 44.8 | [config](./cascade-mask-rcnn_convnext-s-p4-w7_fpn_4conv1fc-giou_amp-ms-crop-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/convnext/cascade_mask_rcnn_convnext-s_p4_w7_fpn_giou_4conv1f_fp16_ms-crop_3x_coco/cascade_mask_rcnn_convnext-s_p4_w7_fpn_giou_4conv1f_fp16_ms-crop_3x_coco_20220510_201004-3d24f5a4.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/convnext/cascade_mask_rcnn_convnext-s_p4_w7_fpn_giou_4conv1f_fp16_ms-crop_3x_coco/cascade_mask_rcnn_convnext-s_p4_w7_fpn_giou_4conv1f_fp16_ms-crop_3x_coco_20220510_201004.log.json) | + +**Note**: + +- ConvNeXt backbone needs to install [MMPreTrain](https://github.com/open-mmlab/mmpretrain) first, which has abundant backbones for downstream tasks. + +```shell +pip install mmpretrain +``` + +- The performance is unstable. `Cascade Mask R-CNN` may fluctuate about 0.2 mAP. + +## Citation + +```bibtex +@article{liu2022convnet, + title={A ConvNet for the 2020s}, + author={Liu, Zhuang and Mao, Hanzi and Wu, Chao-Yuan and Feichtenhofer, Christoph and Darrell, Trevor and Xie, Saining}, + journal={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)}, + year={2022} +} +``` diff --git a/mmdetection/configs/convnext/cascade-mask-rcnn_convnext-s-p4-w7_fpn_4conv1fc-giou_amp-ms-crop-3x_coco.py b/mmdetection/configs/convnext/cascade-mask-rcnn_convnext-s-p4-w7_fpn_4conv1fc-giou_amp-ms-crop-3x_coco.py new file mode 100644 index 00000000..9a5fbedc --- /dev/null +++ b/mmdetection/configs/convnext/cascade-mask-rcnn_convnext-s-p4-w7_fpn_4conv1fc-giou_amp-ms-crop-3x_coco.py @@ -0,0 +1,26 @@ +_base_ = './cascade-mask-rcnn_convnext-t-p4-w7_fpn_4conv1fc-giou_amp-ms-crop-3x_coco.py' # noqa + +# please install mmpretrain +# import mmpretrain.models to trigger register_module in mmpretrain +custom_imports = dict( + imports=['mmpretrain.models'], allow_failed_imports=False) +checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-small_3rdparty_32xb128-noema_in1k_20220301-303e75e3.pth' # noqa + +model = dict( + backbone=dict( + _delete_=True, + type='mmpretrain.ConvNeXt', + arch='small', + out_indices=[0, 1, 2, 3], + drop_path_rate=0.6, + layer_scale_init_value=1.0, + gap_before_final_norm=False, + init_cfg=dict( + type='Pretrained', checkpoint=checkpoint_file, + prefix='backbone.'))) + +optim_wrapper = dict(paramwise_cfg={ + 'decay_rate': 0.7, + 'decay_type': 'layer_wise', + 'num_layers': 12 +}) diff --git a/mmdetection/configs/convnext/cascade-mask-rcnn_convnext-t-p4-w7_fpn_4conv1fc-giou_amp-ms-crop-3x_coco.py b/mmdetection/configs/convnext/cascade-mask-rcnn_convnext-t-p4-w7_fpn_4conv1fc-giou_amp-ms-crop-3x_coco.py new file mode 100644 index 00000000..c92f8683 --- /dev/null +++ b/mmdetection/configs/convnext/cascade-mask-rcnn_convnext-t-p4-w7_fpn_4conv1fc-giou_amp-ms-crop-3x_coco.py @@ -0,0 +1,154 @@ +_base_ = [ + '../_base_/models/cascade-mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +# please install mmpretrain +# import mmpretrain.models to trigger register_module in mmpretrain +custom_imports = dict( + imports=['mmpretrain.models'], allow_failed_imports=False) +checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-tiny_3rdparty_32xb128-noema_in1k_20220301-795e9634.pth' # noqa + +model = dict( + backbone=dict( + _delete_=True, + type='mmpretrain.ConvNeXt', + arch='tiny', + out_indices=[0, 1, 2, 3], + drop_path_rate=0.4, + layer_scale_init_value=1.0, + gap_before_final_norm=False, + init_cfg=dict( + type='Pretrained', checkpoint=checkpoint_file, + prefix='backbone.')), + neck=dict(in_channels=[96, 192, 384, 768]), + roi_head=dict(bbox_head=[ + dict( + type='ConvFCBBoxHead', + num_shared_convs=4, + num_shared_fcs=1, + in_channels=256, + conv_out_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=False, + reg_decoded_bbox=True, + norm_cfg=dict(type='SyncBN', requires_grad=True), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=10.0)), + dict( + type='ConvFCBBoxHead', + num_shared_convs=4, + num_shared_fcs=1, + in_channels=256, + conv_out_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.05, 0.05, 0.1, 0.1]), + reg_class_agnostic=False, + reg_decoded_bbox=True, + norm_cfg=dict(type='SyncBN', requires_grad=True), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=10.0)), + dict( + type='ConvFCBBoxHead', + num_shared_convs=4, + num_shared_fcs=1, + in_channels=256, + conv_out_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.033, 0.033, 0.067, 0.067]), + reg_class_agnostic=False, + reg_decoded_bbox=True, + norm_cfg=dict(type='SyncBN', requires_grad=True), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=10.0)) + ])) + +# augmentation strategy originates from DETR / Sparse RCNN +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[[ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + scales=[(400, 1333), (500, 1333), (600, 1333)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), + (576, 1333), (608, 1333), (640, 1333), + (672, 1333), (704, 1333), (736, 1333), + (768, 1333), (800, 1333)], + keep_ratio=True) + ]]), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +max_epochs = 36 +train_cfg = dict(max_epochs=max_epochs) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, + end=1000), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[27, 33], + gamma=0.1) +] + +# Enable automatic-mixed-precision training with AmpOptimWrapper. +optim_wrapper = dict( + type='AmpOptimWrapper', + constructor='LearningRateDecayOptimizerConstructor', + paramwise_cfg={ + 'decay_rate': 0.7, + 'decay_type': 'layer_wise', + 'num_layers': 6 + }, + optimizer=dict( + _delete_=True, + type='AdamW', + lr=0.0002, + betas=(0.9, 0.999), + weight_decay=0.05)) diff --git a/mmdetection/configs/convnext/mask-rcnn_convnext-t-p4-w7_fpn_amp-ms-crop-3x_coco.py b/mmdetection/configs/convnext/mask-rcnn_convnext-t-p4-w7_fpn_amp-ms-crop-3x_coco.py new file mode 100644 index 00000000..5792b5b5 --- /dev/null +++ b/mmdetection/configs/convnext/mask-rcnn_convnext-t-p4-w7_fpn_amp-ms-crop-3x_coco.py @@ -0,0 +1,96 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +# please install mmpretrain +# import mmpretrain.models to trigger register_module in mmpretrain +custom_imports = dict( + imports=['mmpretrain.models'], allow_failed_imports=False) +checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/convnext/downstream/convnext-tiny_3rdparty_32xb128-noema_in1k_20220301-795e9634.pth' # noqa + +model = dict( + backbone=dict( + _delete_=True, + type='mmpretrain.ConvNeXt', + arch='tiny', + out_indices=[0, 1, 2, 3], + drop_path_rate=0.4, + layer_scale_init_value=1.0, + gap_before_final_norm=False, + init_cfg=dict( + type='Pretrained', checkpoint=checkpoint_file, + prefix='backbone.')), + neck=dict(in_channels=[96, 192, 384, 768])) + +# augmentation strategy originates from DETR / Sparse RCNN +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[[ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + scales=[(400, 1333), (500, 1333), (600, 1333)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), + (576, 1333), (608, 1333), (640, 1333), + (672, 1333), (704, 1333), (736, 1333), + (768, 1333), (800, 1333)], + keep_ratio=True) + ]]), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +max_epochs = 36 +train_cfg = dict(max_epochs=max_epochs) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, + end=1000), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[27, 33], + gamma=0.1) +] + +# Enable automatic-mixed-precision training with AmpOptimWrapper. +optim_wrapper = dict( + type='AmpOptimWrapper', + constructor='LearningRateDecayOptimizerConstructor', + paramwise_cfg={ + 'decay_rate': 0.95, + 'decay_type': 'layer_wise', + 'num_layers': 6 + }, + optimizer=dict( + _delete_=True, + type='AdamW', + lr=0.0001, + betas=(0.9, 0.999), + weight_decay=0.05, + )) diff --git a/mmdetection/configs/convnext/metafile.yml b/mmdetection/configs/convnext/metafile.yml new file mode 100644 index 00000000..b9fd7506 --- /dev/null +++ b/mmdetection/configs/convnext/metafile.yml @@ -0,0 +1,93 @@ +Models: + - Name: mask-rcnn_convnext-t-p4-w7_fpn_amp-ms-crop-3x_coco + In Collection: Mask R-CNN + Config: configs/convnext/mask-rcnn_convnext-t-p4-w7_fpn_amp-ms-crop-3x_coco.py + Metadata: + Training Memory (GB): 7.3 + Epochs: 36 + Training Data: COCO + Training Techniques: + - AdamW + - Mixed Precision Training + Training Resources: 8x A100 GPUs + Architecture: + - ConvNeXt + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.2 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 41.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/convnext/mask_rcnn_convnext-t_p4_w7_fpn_fp16_ms-crop_3x_coco/mask_rcnn_convnext-t_p4_w7_fpn_fp16_ms-crop_3x_coco_20220426_154953-050731f4.pth + Paper: + URL: https://arxiv.org/abs/2201.03545 + Title: 'A ConvNet for the 2020s' + README: configs/convnext/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.16.0/mmdet/models/backbones/swin.py#L465 + Version: v2.16.0 + + - Name: cascade-mask-rcnn_convnext-t-p4-w7_fpn_4conv1fc-giou_amp-ms-crop-3x_coco + In Collection: Cascade Mask R-CNN + Config: configs/convnext/cascade-mask-rcnn_convnext-t-p4-w7_fpn_4conv1fc-giou_amp-ms-crop-3x_coco.py + Metadata: + Training Memory (GB): 9.0 + Epochs: 36 + Training Data: COCO + Training Techniques: + - AdamW + - Mixed Precision Training + Training Resources: 8x A100 GPUs + Architecture: + - ConvNeXt + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 50.3 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 43.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/convnext/cascade_mask_rcnn_convnext-t_p4_w7_fpn_giou_4conv1f_fp16_ms-crop_3x_coco/cascade_mask_rcnn_convnext-t_p4_w7_fpn_giou_4conv1f_fp16_ms-crop_3x_coco_20220509_204200-8f07c40b.pth + Paper: + URL: https://arxiv.org/abs/2201.03545 + Title: 'A ConvNet for the 2020s' + README: configs/convnext/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.16.0/mmdet/models/backbones/swin.py#L465 + Version: v2.25.0 + + - Name: cascade-mask-rcnn_convnext-s-p4-w7_fpn_4conv1fc-giou_amp-ms-crop-3x_coco + In Collection: Cascade Mask R-CNN + Config: configs/convnext/cascade-mask-rcnn_convnext-s-p4-w7_fpn_4conv1fc-giou_amp-ms-crop-3x_coco.py + Metadata: + Training Memory (GB): 12.3 + Epochs: 36 + Training Data: COCO + Training Techniques: + - AdamW + - Mixed Precision Training + Training Resources: 8x A100 GPUs + Architecture: + - ConvNeXt + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 51.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 44.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/convnext/cascade_mask_rcnn_convnext-s_p4_w7_fpn_giou_4conv1f_fp16_ms-crop_3x_coco/cascade_mask_rcnn_convnext-s_p4_w7_fpn_giou_4conv1f_fp16_ms-crop_3x_coco_20220510_201004-3d24f5a4.pth + Paper: + URL: https://arxiv.org/abs/2201.03545 + Title: 'A ConvNet for the 2020s' + README: configs/convnext/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.16.0/mmdet/models/backbones/swin.py#L465 + Version: v2.25.0 diff --git a/mmdetection/configs/cornernet/README.md b/mmdetection/configs/cornernet/README.md new file mode 100644 index 00000000..e44964d8 --- /dev/null +++ b/mmdetection/configs/cornernet/README.md @@ -0,0 +1,43 @@ +# CornerNet + +> [Cornernet: Detecting objects as paired keypoints](https://arxiv.org/abs/1808.01244) + + + +## Abstract + +We propose CornerNet, a new approach to object detection where we detect an object bounding box as a pair of keypoints, the top-left corner and the bottom-right corner, using a single convolution neural network. By detecting objects as paired keypoints, we eliminate the need for designing a set of anchor boxes commonly used in prior single-stage detectors. In addition to our novel formulation, we introduce corner pooling, a new type of pooling layer that helps the network better localize corners. Experiments show that CornerNet achieves a 42.2% AP on MS COCO, outperforming all existing one-stage detectors. + +
    + +
    + +## Results and Models + +| Backbone | Batch Size | Step/Total Epochs | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :--------------: | :------------------------------------------------------------------: | :---------------: | :------: | :------------: | :----: | :------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| HourglassNet-104 | [10 x 5](./cornernet_hourglass104_10xb5-crop511-210e-mstest_coco.py) | 180/210 | 13.9 | 4.2 | 41.2 | [config](./cornernet_hourglass104_10xb5-crop511-210e-mstest_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cornernet/cornernet_hourglass104_mstest_10x5_210e_coco/cornernet_hourglass104_mstest_10x5_210e_coco_20200824_185720-5fefbf1c.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cornernet/cornernet_hourglass104_mstest_10x5_210e_coco/cornernet_hourglass104_mstest_10x5_210e_coco_20200824_185720.log.json) | +| HourglassNet-104 | [8 x 6](./cornernet_hourglass104_8xb6-210e-mstest_coco.py) | 180/210 | 15.9 | 4.2 | 41.2 | [config](./cornernet_hourglass104_8xb6-210e-mstest_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cornernet/cornernet_hourglass104_mstest_8x6_210e_coco/cornernet_hourglass104_mstest_8x6_210e_coco_20200825_150618-79b44c30.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cornernet/cornernet_hourglass104_mstest_8x6_210e_coco/cornernet_hourglass104_mstest_8x6_210e_coco_20200825_150618.log.json) | +| HourglassNet-104 | [32 x 3](./cornernet_hourglass104_32xb3-210e-mstest_coco.py) | 180/210 | 9.5 | 3.9 | 40.4 | [config](./cornernet_hourglass104_32xb3-210e-mstest_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/cornernet/cornernet_hourglass104_mstest_32x3_210e_coco/cornernet_hourglass104_mstest_32x3_210e_coco_20200819_203110-1efaea91.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/cornernet/cornernet_hourglass104_mstest_32x3_210e_coco/cornernet_hourglass104_mstest_32x3_210e_coco_20200819_203110.log.json) | + +Note: + +- TTA setting is single-scale and `flip=True`. If you want to reproduce the TTA performance, please add `--tta` in the test command. +- Experiments with `images_per_gpu=6` are conducted on Tesla V100-SXM2-32GB, `images_per_gpu=3` are conducted on GeForce GTX 1080 Ti. +- Here are the descriptions of each experiment setting: + - 10 x 5: 10 GPUs with 5 images per gpu. This is the same setting as that reported in the original paper. + - 8 x 6: 8 GPUs with 6 images per gpu. The total batchsize is similar to paper and only need 1 node to train. + - 32 x 3: 32 GPUs with 3 images per gpu. The default setting for 1080TI and need 4 nodes to train. + +## Citation + +```latex +@inproceedings{law2018cornernet, + title={Cornernet: Detecting objects as paired keypoints}, + author={Law, Hei and Deng, Jia}, + booktitle={15th European Conference on Computer Vision, ECCV 2018}, + pages={765--781}, + year={2018}, + organization={Springer Verlag} +} +``` diff --git a/mmdetection/configs/cornernet/cornernet_hourglass104_10xb5-crop511-210e-mstest_coco.py b/mmdetection/configs/cornernet/cornernet_hourglass104_10xb5-crop511-210e-mstest_coco.py new file mode 100644 index 00000000..76339163 --- /dev/null +++ b/mmdetection/configs/cornernet/cornernet_hourglass104_10xb5-crop511-210e-mstest_coco.py @@ -0,0 +1,8 @@ +_base_ = './cornernet_hourglass104_8xb6-210e-mstest_coco.py' + +train_dataloader = dict(batch_size=5) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (10 GPUs) x (5 samples per GPU) +auto_scale_lr = dict(base_batch_size=50) diff --git a/mmdetection/configs/cornernet/cornernet_hourglass104_32xb3-210e-mstest_coco.py b/mmdetection/configs/cornernet/cornernet_hourglass104_32xb3-210e-mstest_coco.py new file mode 100644 index 00000000..51a47403 --- /dev/null +++ b/mmdetection/configs/cornernet/cornernet_hourglass104_32xb3-210e-mstest_coco.py @@ -0,0 +1,8 @@ +_base_ = './cornernet_hourglass104_8xb6-210e-mstest_coco.py' + +train_dataloader = dict(batch_size=3) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (32 GPUs) x (3 samples per GPU) +auto_scale_lr = dict(base_batch_size=96) diff --git a/mmdetection/configs/cornernet/cornernet_hourglass104_8xb6-210e-mstest_coco.py b/mmdetection/configs/cornernet/cornernet_hourglass104_8xb6-210e-mstest_coco.py new file mode 100644 index 00000000..bdb46fff --- /dev/null +++ b/mmdetection/configs/cornernet/cornernet_hourglass104_8xb6-210e-mstest_coco.py @@ -0,0 +1,183 @@ +_base_ = [ + '../_base_/default_runtime.py', '../_base_/datasets/coco_detection.py' +] + +data_preprocessor = dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True) + +# model settings +model = dict( + type='CornerNet', + data_preprocessor=data_preprocessor, + backbone=dict( + type='HourglassNet', + downsample_times=5, + num_stacks=2, + stage_channels=[256, 256, 384, 384, 384, 512], + stage_blocks=[2, 2, 2, 2, 2, 4], + norm_cfg=dict(type='BN', requires_grad=True)), + neck=None, + bbox_head=dict( + type='CornerHead', + num_classes=80, + in_channels=256, + num_feat_levels=2, + corner_emb_channels=1, + loss_heatmap=dict( + type='GaussianFocalLoss', alpha=2.0, gamma=4.0, loss_weight=1), + loss_embedding=dict( + type='AssociativeEmbeddingLoss', + pull_weight=0.10, + push_weight=0.10), + loss_offset=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1)), + # training and testing settings + train_cfg=None, + test_cfg=dict( + corner_topk=100, + local_maximum_kernel=3, + distance_threshold=0.5, + score_thr=0.05, + max_per_img=100, + nms=dict(type='soft_nms', iou_threshold=0.5, method='gaussian'))) + +# data settings +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict( + # The cropped images are padded into squares during training, + # but may be smaller than crop_size. + type='RandomCenterCropPad', + crop_size=(511, 511), + ratios=(0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3), + test_mode=False, + test_pad_mode=None, + mean=data_preprocessor['mean'], + std=data_preprocessor['std'], + # Image data is not converted to rgb. + to_rgb=data_preprocessor['bgr_to_rgb']), + # Make sure the output is always crop_size. + dict(type='Resize', scale=(511, 511), keep_ratio=False), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs'), +] + +test_pipeline = [ + dict( + type='LoadImageFromFile', + to_float32=True, + backend_args=_base_.backend_args, + ), + # don't need Resize + dict( + type='RandomCenterCropPad', + crop_size=None, + ratios=None, + border=None, + test_mode=True, + test_pad_mode=['logical_or', 127], + mean=data_preprocessor['mean'], + std=data_preprocessor['std'], + # Image data is not converted to rgb. + to_rgb=data_preprocessor['bgr_to_rgb']), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'border')) +] + +train_dataloader = dict( + batch_size=6, + num_workers=3, + batch_sampler=None, + dataset=dict(pipeline=train_pipeline)) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='Adam', lr=0.0005), + clip_grad=dict(max_norm=35, norm_type=2)) + +max_epochs = 210 + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0 / 3, + by_epoch=False, + begin=0, + end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[180], + gamma=0.1) +] + +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (6 samples per GPU) +auto_scale_lr = dict(base_batch_size=48) + +tta_model = dict( + type='DetTTAModel', + tta_cfg=dict( + nms=dict(type='soft_nms', iou_threshold=0.5, method='gaussian'), + max_per_img=100)) + +tta_pipeline = [ + dict( + type='LoadImageFromFile', + to_float32=True, + backend_args=_base_.backend_args), + dict( + type='TestTimeAug', + transforms=[ + [ + # ``RandomFlip`` must be placed before ``RandomCenterCropPad``, + # otherwise bounding box coordinates after flipping cannot be + # recovered correctly. + dict(type='RandomFlip', prob=1.), + dict(type='RandomFlip', prob=0.) + ], + [ + dict( + type='RandomCenterCropPad', + crop_size=None, + ratios=None, + border=None, + test_mode=True, + test_pad_mode=['logical_or', 127], + mean=data_preprocessor['mean'], + std=data_preprocessor['std'], + # Image data is not converted to rgb. + to_rgb=data_preprocessor['bgr_to_rgb']) + ], + [dict(type='LoadAnnotations', with_bbox=True)], + [ + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'flip', 'flip_direction', 'border')) + ] + ]) +] diff --git a/mmdetection/configs/cornernet/metafile.yml b/mmdetection/configs/cornernet/metafile.yml new file mode 100644 index 00000000..f915cf37 --- /dev/null +++ b/mmdetection/configs/cornernet/metafile.yml @@ -0,0 +1,83 @@ +Collections: + - Name: CornerNet + Metadata: + Training Data: COCO + Training Techniques: + - Adam + Training Resources: 8x V100 GPUs + Architecture: + - Corner Pooling + - Stacked Hourglass Network + Paper: + URL: https://arxiv.org/abs/1808.01244 + Title: 'CornerNet: Detecting Objects as Paired Keypoints' + README: configs/cornernet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.3.0/mmdet/models/detectors/cornernet.py#L9 + Version: v2.3.0 + +Models: + - Name: cornernet_hourglass104_10xb5-crop511-210e-mstest_coco + In Collection: CornerNet + Config: configs/cornernet/cornernet_hourglass104_10xb5-crop511-210e-mstest_coco.py + Metadata: + Training Resources: 10x V100 GPUs + Batch Size: 50 + Training Memory (GB): 13.9 + inference time (ms/im): + - value: 238.1 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 210 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cornernet/cornernet_hourglass104_mstest_10x5_210e_coco/cornernet_hourglass104_mstest_10x5_210e_coco_20200824_185720-5fefbf1c.pth + + - Name: cornernet_hourglass104_8xb6-210e-mstest_coco + In Collection: CornerNet + Config: configs/cornernet/cornernet_hourglass104_8xb6-210e-mstest_coco.py + Metadata: + Batch Size: 48 + Training Memory (GB): 15.9 + inference time (ms/im): + - value: 238.1 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 210 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cornernet/cornernet_hourglass104_mstest_8x6_210e_coco/cornernet_hourglass104_mstest_8x6_210e_coco_20200825_150618-79b44c30.pth + + - Name: cornernet_hourglass104_32xb3-210e-mstest_coco + In Collection: CornerNet + Config: configs/cornernet/cornernet_hourglass104_32xb3-210e-mstest_coco.py + Metadata: + Training Resources: 32x V100 GPUs + Batch Size: 96 + Training Memory (GB): 9.5 + inference time (ms/im): + - value: 256.41 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 210 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/cornernet/cornernet_hourglass104_mstest_32x3_210e_coco/cornernet_hourglass104_mstest_32x3_210e_coco_20200819_203110-1efaea91.pth diff --git a/mmdetection/configs/crowddet/README.md b/mmdetection/configs/crowddet/README.md new file mode 100644 index 00000000..abc0f2d2 --- /dev/null +++ b/mmdetection/configs/crowddet/README.md @@ -0,0 +1,37 @@ +# CrowdDet + +> [Detection in Crowded Scenes: One Proposal, Multiple Predictions](https://arxiv.org/abs/2003.09163) + + + +## Abstract + +We propose a simple yet effective proposal-based object detector, aiming at detecting highly-overlapped instances in crowded scenes. The key of our approach is to let each proposal predict a set of correlated instances rather than a single one in previous proposal-based frameworks. Equipped with new techniques such as EMD Loss and Set NMS, our detector can effectively handle the difficulty of detecting highly overlapped objects. On a FPN-Res50 baseline, our detector can obtain 4.9% AP gains on challenging CrowdHuman dataset and 1.0% MR^−2 improvements on CityPersons dataset, without bells and whistles. Moreover, on less crowed datasets like COCO, our approach can still achieve moderate improvement, suggesting the proposed method is robust to crowdedness. Code and pre-trained models will be released at https://github.com/megvii-model/CrowdDetection. + +
    + +
    + +## Results and Models + +| Backbone | RM | Style | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :------: | :---: | :-----: | :------: | :------------: | :----: | :-------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | False | pytorch | 4.4 | - | 90.0 | [config](./crowddet-rcnn_r50_fpn_8xb2-30e_crowdhuman.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/crowddet/crowddet-rcnn_r50_fpn_8xb2-30e_crowdhuman/crowddet-rcnn_r50_fpn_8xb2-30e_crowdhuman_20221023_174954-dc319c2d.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/crowddet/crowddet-rcnn_r50_fpn_8xb2-30e_crowdhuman/crowddet-rcnn_r50_fpn_8xb2-30e_crowdhuman_20221023_174954.log.json) | +| R-50-FPN | True | pytorch | 4.8 | - | 90.32 | [config](./crowddet-rcnn_refine_r50_fpn_8xb2-30e_crowdhuman.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/crowddet/crowddet-rcnn_refine_r50_fpn_8xb2-30e_crowdhuman/crowddet-rcnn_refine_r50_fpn_8xb2-30e_crowdhuman_20221024_215917-45602806.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/crowddet/crowddet-rcnn_refine_r50_fpn_8xb2-30e_crowdhuman/crowddet-rcnn_refine_r50_fpn_8xb2-30e_crowdhuman_20221024_215917.log.json) | + +Note: + +- RM indicates whether to use the refine module. +- The dataset for training and testing this model is `CrowdHuman`, and the metric of `box AP` is calculated by `mmdet/evaluation/metrics/crowdhuman_metric.py`. + +## Citation + +```latex +@inproceedings{Chu_2020_CVPR, + title={Detection in Crowded Scenes: One Proposal, Multiple Predictions}, + author={Chu, Xuangeng and Zheng, Anlin and Zhang, Xiangyu and Sun, Jian}, + booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)}, + month = {June}, + year = {2020} +} +``` diff --git a/mmdetection/configs/crowddet/crowddet-rcnn_r50_fpn_8xb2-30e_crowdhuman.py b/mmdetection/configs/crowddet/crowddet-rcnn_r50_fpn_8xb2-30e_crowdhuman.py new file mode 100644 index 00000000..8815be77 --- /dev/null +++ b/mmdetection/configs/crowddet/crowddet-rcnn_r50_fpn_8xb2-30e_crowdhuman.py @@ -0,0 +1,227 @@ +_base_ = ['../_base_/default_runtime.py'] + +model = dict( + type='CrowdDet', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[103.53, 116.28, 123.675], + std=[57.375, 57.12, 58.395], + bgr_to_rgb=False, + pad_size_divisor=64, + # This option is set according to https://github.com/Purkialo/CrowdDet/ + # blob/master/lib/data/CrowdHuman.py The images in the entire batch are + # resize together. + batch_augments=[ + dict(type='BatchResize', scale=(1400, 800), pad_size_divisor=64) + ]), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + num_outs=5, + upsample_cfg=dict(mode='bilinear', align_corners=False)), + rpn_head=dict( + type='RPNHead', + in_channels=256, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + scales=[8], + ratios=[1.0, 2.0, 3.0], + strides=[4, 8, 16, 32, 64], + centers=[(8, 8), (8, 8), (8, 8), (8, 8), (8, 8)]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0.0, 0.0, 0.0, 0.0], + target_stds=[1.0, 1.0, 1.0, 1.0], + clip_border=False), + loss_cls=dict(type='CrossEntropyLoss', loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0)), + roi_head=dict( + type='MultiInstanceRoIHead', + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict( + type='RoIAlign', + output_size=7, + sampling_ratio=-1, + aligned=True, + use_torchvision=True), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + bbox_head=dict( + type='MultiInstanceBBoxHead', + with_refine=False, + num_shared_fcs=2, + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=1, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=False, + loss_cls=dict( + type='CrossEntropyLoss', + loss_weight=1.0, + use_sigmoid=False, + reduction='none'), + loss_bbox=dict( + type='SmoothL1Loss', loss_weight=1.0, reduction='none'))), + # model training and testing settings + train_cfg=dict( + rpn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=(0.3, 0.7), + min_pos_iou=0.3, + match_low_quality=True, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=-1, + pos_weight=-1, + debug=False), + rpn_proposal=dict( + nms_pre=2400, + max_per_img=2000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=2), + rcnn=dict( + assigner=dict( + type='MultiInstanceAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0.3, + match_low_quality=False, + ignore_iof_thr=-1), + sampler=dict( + type='MultiInsRandomSampler', + num=512, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + pos_weight=-1, + debug=False)), + test_cfg=dict( + rpn=dict( + nms_pre=1200, + max_per_img=1000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=2), + rcnn=dict( + nms=dict(type='nms', iou_threshold=0.5), + score_thr=0.01, + max_per_img=500))) + +dataset_type = 'CrowdHumanDataset' +data_root = 'data/CrowdHuman/' + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/tracking/CrowdHuman/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/tracking/', +# 'data/': 's3://openmmlab/datasets/tracking/' +# })) +backend_args = None + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip', + 'flip_direction')) +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1400, 800), keep_ratio=True), + # avoid bboxes being resized + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict( + batch_size=2, + num_workers=4, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=None, # The 'batch_sampler' may decrease the precision + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotation_train.odgt', + data_prefix=dict(img='Images/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args=backend_args)) +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotation_val.odgt', + data_prefix=dict(img='Images/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CrowdHumanMetric', + ann_file=data_root + 'annotation_val.odgt', + metric=['AP', 'MR', 'JI'], + backend_args=backend_args) +test_evaluator = val_evaluator + +train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=30, val_interval=1) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=800), + dict( + type='MultiStepLR', + begin=0, + end=30, + by_epoch=True, + milestones=[24, 27], + gamma=0.1) +] + +# optimizer +auto_scale_lr = dict(base_batch_size=16) +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.002, momentum=0.9, weight_decay=0.0001)) diff --git a/mmdetection/configs/crowddet/crowddet-rcnn_refine_r50_fpn_8xb2-30e_crowdhuman.py b/mmdetection/configs/crowddet/crowddet-rcnn_refine_r50_fpn_8xb2-30e_crowdhuman.py new file mode 100644 index 00000000..80277ce1 --- /dev/null +++ b/mmdetection/configs/crowddet/crowddet-rcnn_refine_r50_fpn_8xb2-30e_crowdhuman.py @@ -0,0 +1,3 @@ +_base_ = './crowddet-rcnn_r50_fpn_8xb2-30e_crowdhuman.py' + +model = dict(roi_head=dict(bbox_head=dict(with_refine=True))) diff --git a/mmdetection/configs/crowddet/metafile.yml b/mmdetection/configs/crowddet/metafile.yml new file mode 100644 index 00000000..4f191dea --- /dev/null +++ b/mmdetection/configs/crowddet/metafile.yml @@ -0,0 +1,47 @@ +Collections: + - Name: CrowdDet + Metadata: + Training Data: CrowdHuman + Training Techniques: + - SGD + - EMD Loss + Training Resources: 8x A100 GPUs + Architecture: + - FPN + - RPN + - ResNet + - RoIPool + Paper: + URL: https://arxiv.org/abs/2003.09163 + Title: 'Detection in Crowded Scenes: One Proposal, Multiple Predictions' + README: configs/crowddet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v3.0.0rc3/mmdet/models/detectors/crowddet.py + Version: v3.0.0rc3 + +Models: + - Name: crowddet-rcnn_refine_r50_fpn_8xb2-30e_crowdhuman + In Collection: CrowdDet + Config: configs/crowddet/crowddet-rcnn_refine_r50_fpn_8xb2-30e_crowdhuman.py + Metadata: + Training Memory (GB): 4.8 + Epochs: 30 + Results: + - Task: Object Detection + Dataset: CrowdHuman + Metrics: + box AP: 90.32 + Weights: https://download.openmmlab.com/mmdetection/v3.0/crowddet/crowddet-rcnn_refine_r50_fpn_8xb2-30e_crowdhuman/crowddet-rcnn_refine_r50_fpn_8xb2-30e_crowdhuman_20221024_215917-45602806.pth + + - Name: crowddet-rcnn_r50_fpn_8xb2-30e_crowdhuman + In Collection: CrowdDet + Config: configs/crowddet/crowddet-rcnn_r50_fpn_8xb2-30e_crowdhuman.py + Metadata: + Training Memory (GB): 4.4 + Epochs: 30 + Results: + - Task: Object Detection + Dataset: CrowdHuman + Metrics: + box AP: 90.0 + Weights: https://download.openmmlab.com/mmdetection/v3.0/crowddet/crowddet-rcnn_r50_fpn_8xb2-30e_crowdhuman/crowddet-rcnn_r50_fpn_8xb2-30e_crowdhuman_20221023_174954-dc319c2d.pth diff --git a/mmdetection/configs/dab_detr/README.md b/mmdetection/configs/dab_detr/README.md new file mode 100644 index 00000000..5661f27a --- /dev/null +++ b/mmdetection/configs/dab_detr/README.md @@ -0,0 +1,40 @@ +# DAB-DETR + +> [DAB-DETR: Dynamic Anchor Boxes are Better Queries for DETR](https://arxiv.org/abs/2201.12329) + + + +## Abstract + +We present in this paper a novel query formulation using dynamic anchor boxes for DETR (DEtection TRansformer) and offer a deeper understanding of the role of queries in DETR. This new formulation directly uses box coordinates as queries in Transformer decoders and dynamically updates them layer-by-layer. Using box coordinates not only helps using explicit positional priors to improve the query-to-feature similarity and eliminate the slow training convergence issue in DETR, but also allows us to modulate the positional attention map using the box width and height information. Such a design makes it clear that queries in DETR can be implemented as performing soft ROI pooling layer-by-layer in a cascade manner. As a result, it leads to the best performance on MS-COCO benchmark among the DETR-like detection models under the same setting, e.g., AP 45.7% using ResNet50-DC5 as backbone trained in 50 epochs. We also conducted extensive experiments to confirm our analysis and verify the effectiveness of our methods. + +
    + +
    +
    + +
    +
    + +
    + +## Results and Models + +We provide the config files and models for DAB-DETR: [DAB-DETR: Dynamic Anchor Boxes are Better Queries for DETR](https://arxiv.org/abs/2201.12329). + +| Backbone | Model | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :------: | :------: | :-----: | :------: | :------------: | :----: | :---------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | DAB-DETR | 50e | | | 42.3 | [config](./dab-detr_r50_8xb2-50e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/dab_detr/dab-detr_r50_8xb2-50e_coco/dab-detr_r50_8xb2-50e_coco_20221122_120837-c1035c8c.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/dab_detr/dab-detr_r50_8xb2-50e_coco/dab-detr_r50_8xb2-50e_coco_20221122_120837.log.json) | + +## Citation + +```latex +@inproceedings{ + liu2022dabdetr, + title={{DAB}-{DETR}: Dynamic Anchor Boxes are Better Queries for {DETR}}, + author={Shilong Liu and Feng Li and Hao Zhang and Xiao Yang and Xianbiao Qi and Hang Su and Jun Zhu and Lei Zhang}, + booktitle={International Conference on Learning Representations}, + year={2022}, + url={https://openreview.net/forum?id=oMI9PjOb9Jl} +} +``` diff --git a/mmdetection/configs/dab_detr/dab-detr_r50_8xb2-50e_coco.py b/mmdetection/configs/dab_detr/dab-detr_r50_8xb2-50e_coco.py new file mode 100644 index 00000000..314ed97e --- /dev/null +++ b/mmdetection/configs/dab_detr/dab-detr_r50_8xb2-50e_coco.py @@ -0,0 +1,159 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', '../_base_/default_runtime.py' +] +model = dict( + type='DABDETR', + num_queries=300, + with_random_refpoints=False, + num_patterns=0, + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=1), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(3, ), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=False), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='ChannelMapper', + in_channels=[2048], + kernel_size=1, + out_channels=256, + act_cfg=None, + norm_cfg=None, + num_outs=1), + encoder=dict( + num_layers=6, + layer_cfg=dict( + self_attn_cfg=dict( + embed_dims=256, num_heads=8, dropout=0., batch_first=True), + ffn_cfg=dict( + embed_dims=256, + feedforward_channels=2048, + num_fcs=2, + ffn_drop=0., + act_cfg=dict(type='PReLU')))), + decoder=dict( + num_layers=6, + query_dim=4, + query_scale_type='cond_elewise', + with_modulated_hw_attn=True, + layer_cfg=dict( + self_attn_cfg=dict( + embed_dims=256, + num_heads=8, + attn_drop=0., + proj_drop=0., + cross_attn=False), + cross_attn_cfg=dict( + embed_dims=256, + num_heads=8, + attn_drop=0., + proj_drop=0., + cross_attn=True), + ffn_cfg=dict( + embed_dims=256, + feedforward_channels=2048, + num_fcs=2, + ffn_drop=0., + act_cfg=dict(type='PReLU'))), + return_intermediate=True), + positional_encoding=dict(num_feats=128, temperature=20, normalize=True), + bbox_head=dict( + type='DABDETRHead', + num_classes=80, + embed_dims=256, + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=5.0), + loss_iou=dict(type='GIoULoss', loss_weight=2.0)), + # training and testing settings + train_cfg=dict( + assigner=dict( + type='HungarianAssigner', + match_costs=[ + dict(type='FocalLossCost', weight=2., eps=1e-8), + dict(type='BBoxL1Cost', weight=5.0, box_format='xywh'), + dict(type='IoUCost', iou_mode='giou', weight=2.0) + ])), + test_cfg=dict(max_per_img=300)) + +# train_pipeline, NOTE the img_scale and the Pad's size_divisor is different +# from the default setting in mmdet. +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[[ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + scales=[(400, 1333), (500, 1333), (600, 1333)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), + (576, 1333), (608, 1333), (640, 1333), + (672, 1333), (704, 1333), (736, 1333), + (768, 1333), (800, 1333)], + keep_ratio=True) + ]]), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0001), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict( + custom_keys={'backbone': dict(lr_mult=0.1, decay_mult=1.0)})) + +# learning policy +max_epochs = 50 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[40], + gamma=0.1) +] + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=16, enable=False) diff --git a/mmdetection/configs/dab_detr/metafile.yml b/mmdetection/configs/dab_detr/metafile.yml new file mode 100644 index 00000000..94383a04 --- /dev/null +++ b/mmdetection/configs/dab_detr/metafile.yml @@ -0,0 +1,32 @@ +Collections: + - Name: DAB-DETR + Metadata: + Training Data: COCO + Training Techniques: + - AdamW + - Multi Scale Train + - Gradient Clip + Training Resources: 8x A100 GPUs + Architecture: + - ResNet + - Transformer + Paper: + URL: https://arxiv.org/abs/2201.12329 + Title: 'DAB-DETR: Dynamic Anchor Boxes are Better Queries for DETR' + README: configs/dab_detr/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/f4112c9e5611468ffbd57cfba548fd1289264b52/mmdet/models/detectors/dab_detr.py#L15 + Version: v3.0.0rc6 + +Models: + - Name: dab-detr_r50_8xb2-50e_coco + In Collection: DAB-DETR + Config: configs/dab_detr/dab-detr_r50_8xb2-50e_coco.py + Metadata: + Epochs: 50 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.3 + Weights: https://download.openmmlab.com/mmdetection/v3.0/dab_detr/dab-detr_r50_8xb2-50e_coco/dab-detr_r50_8xb2-50e_coco_20221122_120837-c1035c8c.pth diff --git a/mmdetection/configs/dcn/README.md b/mmdetection/configs/dcn/README.md new file mode 100644 index 00000000..e287e1d5 --- /dev/null +++ b/mmdetection/configs/dcn/README.md @@ -0,0 +1,48 @@ +# DCN + +> [Deformable Convolutional Networks](https://arxiv.org/abs/1703.06211) + + + +## Abstract + +Convolutional neural networks (CNNs) are inherently limited to model geometric transformations due to the fixed geometric structures in its building modules. In this work, we introduce two new modules to enhance the transformation modeling capacity of CNNs, namely, deformable convolution and deformable RoI pooling. Both are based on the idea of augmenting the spatial sampling locations in the modules with additional offsets and learning the offsets from target tasks, without additional supervision. The new modules can readily replace their plain counterparts in existing CNNs and can be easily trained end-to-end by standard back-propagation, giving rise to deformable convolutional networks. Extensive experiments validate the effectiveness of our approach on sophisticated vision tasks of object detection and semantic segmentation. + +
    + +
    + +## Results and Models + +| Backbone | Model | Style | Conv | Pool | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :-------------: | :----------: | :-----: | :----------: | :---: | :-----: | :------: | :------------: | :----: | :-----: | :-----------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | Faster | pytorch | dconv(c3-c5) | - | 1x | 4.0 | 17.8 | 41.3 | | [config](./faster-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/dcn/faster_rcnn_r50_fpn_dconv_c3-c5_1x_coco/faster_rcnn_r50_fpn_dconv_c3-c5_1x_coco_20200130-d68aed1e.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/dcn/faster_rcnn_r50_fpn_dconv_c3-c5_1x_coco/faster_rcnn_r50_fpn_dconv_c3-c5_1x_coco_20200130_212941.log.json) | +| R-50-FPN | Faster | pytorch | - | dpool | 1x | 5.0 | 17.2 | 38.9 | | [config](./faster-rcnn_r50_fpn_dpool_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/dcn/faster_rcnn_r50_fpn_dpool_1x_coco/faster_rcnn_r50_fpn_dpool_1x_coco_20200307-90d3c01d.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/dcn/faster_rcnn_r50_fpn_dpool_1x_coco/faster_rcnn_r50_fpn_dpool_1x_coco_20200307_203250.log.json) | +| R-101-FPN | Faster | pytorch | dconv(c3-c5) | - | 1x | 6.0 | 12.5 | 42.7 | | [config](./faster-rcnn_r101-dconv-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/dcn/faster_rcnn_r101_fpn_dconv_c3-c5_1x_coco/faster_rcnn_r101_fpn_dconv_c3-c5_1x_coco_20200203-1377f13d.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/dcn/faster_rcnn_r101_fpn_dconv_c3-c5_1x_coco/faster_rcnn_r101_fpn_dconv_c3-c5_1x_coco_20200203_230019.log.json) | +| X-101-32x4d-FPN | Faster | pytorch | dconv(c3-c5) | - | 1x | 7.3 | 10.0 | 44.5 | | [config](./faster-rcnn_x101-32x4d-dconv-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/dcn/faster_rcnn_x101_32x4d_fpn_dconv_c3-c5_1x_coco/faster_rcnn_x101_32x4d_fpn_dconv_c3-c5_1x_coco_20200203-4f85c69c.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/dcn/faster_rcnn_x101_32x4d_fpn_dconv_c3-c5_1x_coco/faster_rcnn_x101_32x4d_fpn_dconv_c3-c5_1x_coco_20200203_001325.log.json) | +| R-50-FPN | Mask | pytorch | dconv(c3-c5) | - | 1x | 4.5 | 15.4 | 41.8 | 37.4 | [config](./mask-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/dcn/mask_rcnn_r50_fpn_dconv_c3-c5_1x_coco/mask_rcnn_r50_fpn_dconv_c3-c5_1x_coco_20200203-4d9ad43b.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/dcn/mask_rcnn_r50_fpn_dconv_c3-c5_1x_coco/mask_rcnn_r50_fpn_dconv_c3-c5_1x_coco_20200203_061339.log.json) | +| R-101-FPN | Mask | pytorch | dconv(c3-c5) | - | 1x | 6.5 | 11.7 | 43.5 | 38.9 | [config](./mask-rcnn_r101-dconv-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/dcn/mask_rcnn_r101_fpn_dconv_c3-c5_1x_coco/mask_rcnn_r101_fpn_dconv_c3-c5_1x_coco_20200216-a71f5bce.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/dcn/mask_rcnn_r101_fpn_dconv_c3-c5_1x_coco/mask_rcnn_r101_fpn_dconv_c3-c5_1x_coco_20200216_191601.log.json) | +| R-50-FPN | Cascade | pytorch | dconv(c3-c5) | - | 1x | 4.5 | 14.6 | 43.8 | | [config](./cascade-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/dcn/cascade_rcnn_r50_fpn_dconv_c3-c5_1x_coco/cascade_rcnn_r50_fpn_dconv_c3-c5_1x_coco_20200130-2f1fca44.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/dcn/cascade_rcnn_r50_fpn_dconv_c3-c5_1x_coco/cascade_rcnn_r50_fpn_dconv_c3-c5_1x_coco_20200130_220843.log.json) | +| R-101-FPN | Cascade | pytorch | dconv(c3-c5) | - | 1x | 6.4 | 11.0 | 45.0 | | [config](./cascade-rcnn_r101-dconv-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/dcn/cascade_rcnn_r101_fpn_dconv_c3-c5_1x_coco/cascade_rcnn_r101_fpn_dconv_c3-c5_1x_coco_20200203-3b2f0594.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/dcn/cascade_rcnn_r101_fpn_dconv_c3-c5_1x_coco/cascade_rcnn_r101_fpn_dconv_c3-c5_1x_coco_20200203_224829.log.json) | +| R-50-FPN | Cascade Mask | pytorch | dconv(c3-c5) | - | 1x | 6.0 | 10.0 | 44.4 | 38.6 | [config](./cascade-mask-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/dcn/cascade_mask_rcnn_r50_fpn_dconv_c3-c5_1x_coco/cascade_mask_rcnn_r50_fpn_dconv_c3-c5_1x_coco_20200202-42e767a2.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/dcn/cascade_mask_rcnn_r50_fpn_dconv_c3-c5_1x_coco/cascade_mask_rcnn_r50_fpn_dconv_c3-c5_1x_coco_20200202_010309.log.json) | +| R-101-FPN | Cascade Mask | pytorch | dconv(c3-c5) | - | 1x | 8.0 | 8.6 | 45.8 | 39.7 | [config](./cascade-mask-rcnn_r101-dconv-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/dcn/cascade_mask_rcnn_r101_fpn_dconv_c3-c5_1x_coco/cascade_mask_rcnn_r101_fpn_dconv_c3-c5_1x_coco_20200204-df0c5f10.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/dcn/cascade_mask_rcnn_r101_fpn_dconv_c3-c5_1x_coco/cascade_mask_rcnn_r101_fpn_dconv_c3-c5_1x_coco_20200204_134006.log.json) | +| X-101-32x4d-FPN | Cascade Mask | pytorch | dconv(c3-c5) | - | 1x | 9.2 | | 47.3 | 41.1 | [config](./cascade-mask-rcnn_x101-32x4d-dconv-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/dcn/cascade_mask_rcnn_x101_32x4d_fpn_dconv_c3-c5_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_dconv_c3-c5_1x_coco-e75f90c8.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/dcn/cascade_mask_rcnn_x101_32x4d_fpn_dconv_c3-c5_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_dconv_c3-c5_1x_coco-20200606_183737.log.json) | +| R-50-FPN (FP16) | Mask | pytorch | dconv(c3-c5) | - | 1x | 3.0 | | 41.9 | 37.5 | [config](./mask-rcnn_r50-dconv-c3-c5_fpn_amp-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/fp16/mask_rcnn_r50_fpn_fp16_dconv_c3-c5_1x_coco/mask_rcnn_r50_fpn_fp16_dconv_c3-c5_1x_coco_20210520_180247-c06429d2.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/fp16/mask_rcnn_r50_fpn_fp16_dconv_c3-c5_1x_coco/mask_rcnn_r50_fpn_fp16_dconv_c3-c5_1x_coco_20210520_180247.log.json) | + +**Notes:** + +- `dconv` denotes deformable convolution, `c3-c5` means adding dconv in resnet stage 3 to 5. `dpool` denotes deformable roi pooling. +- The dcn ops are modified from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch, which should be more memory efficient and slightly faster. +- (\*) For R-50-FPN (dg=4), dg is short for deformable_group. This model is trained and tested on Amazon EC2 p3dn.24xlarge instance. +- **Memory, Train/Inf time is outdated.** + +## Citation + +```latex +@inproceedings{dai2017deformable, + title={Deformable Convolutional Networks}, + author={Dai, Jifeng and Qi, Haozhi and Xiong, Yuwen and Li, Yi and Zhang, Guodong and Hu, Han and Wei, Yichen}, + booktitle={Proceedings of the IEEE international conference on computer vision}, + year={2017} +} +``` diff --git a/mmdetection/configs/dcn/cascade-mask-rcnn_r101-dconv-c3-c5_fpn_1x_coco.py b/mmdetection/configs/dcn/cascade-mask-rcnn_r101-dconv-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..8c0ff989 --- /dev/null +++ b/mmdetection/configs/dcn/cascade-mask-rcnn_r101-dconv-c3-c5_fpn_1x_coco.py @@ -0,0 +1,5 @@ +_base_ = '../cascade_rcnn/cascade-mask-rcnn_r101_fpn_1x_coco.py' +model = dict( + backbone=dict( + dcn=dict(type='DCN', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True))) diff --git a/mmdetection/configs/dcn/cascade-mask-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py b/mmdetection/configs/dcn/cascade-mask-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..cfcc5e73 --- /dev/null +++ b/mmdetection/configs/dcn/cascade-mask-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py @@ -0,0 +1,5 @@ +_base_ = '../cascade_rcnn/cascade-mask-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + dcn=dict(type='DCN', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True))) diff --git a/mmdetection/configs/dcn/cascade-mask-rcnn_x101-32x4d-dconv-c3-c5_fpn_1x_coco.py b/mmdetection/configs/dcn/cascade-mask-rcnn_x101-32x4d-dconv-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..48b25f62 --- /dev/null +++ b/mmdetection/configs/dcn/cascade-mask-rcnn_x101-32x4d-dconv-c3-c5_fpn_1x_coco.py @@ -0,0 +1,5 @@ +_base_ = '../cascade_rcnn/cascade-mask-rcnn_x101-32x4d_fpn_1x_coco.py' +model = dict( + backbone=dict( + dcn=dict(type='DCN', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True))) diff --git a/mmdetection/configs/dcn/cascade-rcnn_r101-dconv-c3-c5_fpn_1x_coco.py b/mmdetection/configs/dcn/cascade-rcnn_r101-dconv-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..8a942da7 --- /dev/null +++ b/mmdetection/configs/dcn/cascade-rcnn_r101-dconv-c3-c5_fpn_1x_coco.py @@ -0,0 +1,5 @@ +_base_ = '../cascade_rcnn/cascade-rcnn_r101_fpn_1x_coco.py' +model = dict( + backbone=dict( + dcn=dict(type='DCN', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True))) diff --git a/mmdetection/configs/dcn/cascade-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py b/mmdetection/configs/dcn/cascade-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..f6bf5b79 --- /dev/null +++ b/mmdetection/configs/dcn/cascade-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py @@ -0,0 +1,5 @@ +_base_ = '../cascade_rcnn/cascade-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + dcn=dict(type='DCN', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True))) diff --git a/mmdetection/configs/dcn/faster-rcnn_r101-dconv-c3-c5_fpn_1x_coco.py b/mmdetection/configs/dcn/faster-rcnn_r101-dconv-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..db44e7e8 --- /dev/null +++ b/mmdetection/configs/dcn/faster-rcnn_r101-dconv-c3-c5_fpn_1x_coco.py @@ -0,0 +1,5 @@ +_base_ = '../faster_rcnn/faster-rcnn_r101_fpn_1x_coco.py' +model = dict( + backbone=dict( + dcn=dict(type='DCN', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True))) diff --git a/mmdetection/configs/dcn/faster-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py b/mmdetection/configs/dcn/faster-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..95f20467 --- /dev/null +++ b/mmdetection/configs/dcn/faster-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py @@ -0,0 +1,5 @@ +_base_ = '../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + dcn=dict(type='DCN', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True))) diff --git a/mmdetection/configs/dcn/faster-rcnn_r50_fpn_dpool_1x_coco.py b/mmdetection/configs/dcn/faster-rcnn_r50_fpn_dpool_1x_coco.py new file mode 100644 index 00000000..c65ce5fd --- /dev/null +++ b/mmdetection/configs/dcn/faster-rcnn_r50_fpn_dpool_1x_coco.py @@ -0,0 +1,12 @@ +_base_ = '../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + roi_head=dict( + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict( + _delete_=True, + type='DeformRoIPoolPack', + output_size=7, + output_channels=256), + out_channels=256, + featmap_strides=[4, 8, 16, 32]))) diff --git a/mmdetection/configs/dcn/faster-rcnn_x101-32x4d-dconv-c3-c5_fpn_1x_coco.py b/mmdetection/configs/dcn/faster-rcnn_x101-32x4d-dconv-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..e4ed832f --- /dev/null +++ b/mmdetection/configs/dcn/faster-rcnn_x101-32x4d-dconv-c3-c5_fpn_1x_coco.py @@ -0,0 +1,16 @@ +_base_ = '../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + dcn=dict(type='DCN', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/dcn/mask-rcnn_r101-dconv-c3-c5_fpn_1x_coco.py b/mmdetection/configs/dcn/mask-rcnn_r101-dconv-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..3f36714a --- /dev/null +++ b/mmdetection/configs/dcn/mask-rcnn_r101-dconv-c3-c5_fpn_1x_coco.py @@ -0,0 +1,5 @@ +_base_ = '../mask_rcnn/mask-rcnn_r101_fpn_1x_coco.py' +model = dict( + backbone=dict( + dcn=dict(type='DCN', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True))) diff --git a/mmdetection/configs/dcn/mask-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py b/mmdetection/configs/dcn/mask-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..0b281d41 --- /dev/null +++ b/mmdetection/configs/dcn/mask-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py @@ -0,0 +1,5 @@ +_base_ = '../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + dcn=dict(type='DCN', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True))) diff --git a/mmdetection/configs/dcn/mask-rcnn_r50-dconv-c3-c5_fpn_amp-1x_coco.py b/mmdetection/configs/dcn/mask-rcnn_r50-dconv-c3-c5_fpn_amp-1x_coco.py new file mode 100644 index 00000000..9d015943 --- /dev/null +++ b/mmdetection/configs/dcn/mask-rcnn_r50-dconv-c3-c5_fpn_amp-1x_coco.py @@ -0,0 +1,10 @@ +_base_ = '../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + dcn=dict(type='DCN', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True))) + +# MMEngine support the following two ways, users can choose +# according to convenience +# optim_wrapper = dict(type='AmpOptimWrapper') +_base_.optim_wrapper.type = 'AmpOptimWrapper' diff --git a/mmdetection/configs/dcn/metafile.yml b/mmdetection/configs/dcn/metafile.yml new file mode 100644 index 00000000..4aa35b5d --- /dev/null +++ b/mmdetection/configs/dcn/metafile.yml @@ -0,0 +1,272 @@ +Collections: + - Name: Deformable Convolutional Networks + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - Deformable Convolution + Paper: + URL: https://arxiv.org/abs/1703.06211 + Title: "Deformable Convolutional Networks" + README: configs/dcn/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/ops/dcn/deform_conv.py#L15 + Version: v2.0.0 + +Models: + - Name: faster-rcnn_r50_fpn_dconv_c3-c5_1x_coco + In Collection: Deformable Convolutional Networks + Config: configs/dcn/faster-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.0 + inference time (ms/im): + - value: 56.18 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/dcn/faster_rcnn_r50_fpn_dconv_c3-c5_1x_coco/faster_rcnn_r50_fpn_dconv_c3-c5_1x_coco_20200130-d68aed1e.pth + + - Name: faster-rcnn_r50_fpn_dpool_1x_coco + In Collection: Deformable Convolutional Networks + Config: configs/dcn/faster-rcnn_r50_fpn_dpool_1x_coco.py + Metadata: + Training Memory (GB): 5.0 + inference time (ms/im): + - value: 58.14 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/dcn/faster_rcnn_r50_fpn_dpool_1x_coco/faster_rcnn_r50_fpn_dpool_1x_coco_20200307-90d3c01d.pth + + - Name: faster-rcnn_r101-dconv-c3-c5_fpn_1x_coco + In Collection: Deformable Convolutional Networks + Config: configs/dcn/faster-rcnn_r101-dconv-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 6.0 + inference time (ms/im): + - value: 80 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/dcn/faster_rcnn_r101_fpn_dconv_c3-c5_1x_coco/faster_rcnn_r101_fpn_dconv_c3-c5_1x_coco_20200203-1377f13d.pth + + - Name: faster-rcnn_x101-32x4d-dconv-c3-c5_fpn_1x_coco + In Collection: Deformable Convolutional Networks + Config: configs/dcn/faster-rcnn_x101-32x4d-dconv-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 7.3 + inference time (ms/im): + - value: 100 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/dcn/faster_rcnn_x101_32x4d_fpn_dconv_c3-c5_1x_coco/faster_rcnn_x101_32x4d_fpn_dconv_c3-c5_1x_coco_20200203-4f85c69c.pth + + - Name: mask-rcnn_r50_fpn_dconv_c3-c5_1x_coco + In Collection: Deformable Convolutional Networks + Config: configs/dcn/mask-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.5 + inference time (ms/im): + - value: 64.94 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/dcn/mask_rcnn_r50_fpn_dconv_c3-c5_1x_coco/mask_rcnn_r50_fpn_dconv_c3-c5_1x_coco_20200203-4d9ad43b.pth + + - Name: mask-rcnn_r50_fpn_fp16_dconv_c3-c5_1x_coco + In Collection: Deformable Convolutional Networks + Config: configs/dcn/mask-rcnn_r50-dconv-c3-c5_fpn_amp-1x_coco.py + Metadata: + Training Techniques: + - SGD with Momentum + - Weight Decay + - Mixed Precision Training + Training Memory (GB): 3.0 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.9 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/fp16/mask_rcnn_r50_fpn_fp16_dconv_c3-c5_1x_coco/mask_rcnn_r50_fpn_fp16_dconv_c3-c5_1x_coco_20210520_180247-c06429d2.pth + + - Name: mask-rcnn_r101-dconv-c3-c5_fpn_1x_coco + In Collection: Deformable Convolutional Networks + Config: configs/dcn/mask-rcnn_r101-dconv-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 6.5 + inference time (ms/im): + - value: 85.47 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.5 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/dcn/mask_rcnn_r101_fpn_dconv_c3-c5_1x_coco/mask_rcnn_r101_fpn_dconv_c3-c5_1x_coco_20200216-a71f5bce.pth + + - Name: cascade-rcnn_r50_fpn_dconv_c3-c5_1x_coco + In Collection: Deformable Convolutional Networks + Config: configs/dcn/cascade-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.5 + inference time (ms/im): + - value: 68.49 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/dcn/cascade_rcnn_r50_fpn_dconv_c3-c5_1x_coco/cascade_rcnn_r50_fpn_dconv_c3-c5_1x_coco_20200130-2f1fca44.pth + + - Name: cascade-rcnn_r101-dconv-c3-c5_fpn_1x_coco + In Collection: Deformable Convolutional Networks + Config: configs/dcn/cascade-rcnn_r101-dconv-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 6.4 + inference time (ms/im): + - value: 90.91 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/dcn/cascade_rcnn_r101_fpn_dconv_c3-c5_1x_coco/cascade_rcnn_r101_fpn_dconv_c3-c5_1x_coco_20200203-3b2f0594.pth + + - Name: cascade-mask-rcnn_r50_fpn_dconv_c3-c5_1x_coco + In Collection: Deformable Convolutional Networks + Config: configs/dcn/cascade-mask-rcnn_r50-dconv-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 6.0 + inference time (ms/im): + - value: 100 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.4 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/dcn/cascade_mask_rcnn_r50_fpn_dconv_c3-c5_1x_coco/cascade_mask_rcnn_r50_fpn_dconv_c3-c5_1x_coco_20200202-42e767a2.pth + + - Name: cascade-mask-rcnn_r101-dconv-c3-c5_fpn_1x_coco + In Collection: Deformable Convolutional Networks + Config: configs/dcn/cascade-mask-rcnn_r101-dconv-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 8.0 + inference time (ms/im): + - value: 116.28 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/dcn/cascade_mask_rcnn_r101_fpn_dconv_c3-c5_1x_coco/cascade_mask_rcnn_r101_fpn_dconv_c3-c5_1x_coco_20200204-df0c5f10.pth + + - Name: cascade-mask-rcnn_x101-32x4d-dconv-c3-c5_fpn_1x_coco + In Collection: Deformable Convolutional Networks + Config: configs/dcn/cascade-mask-rcnn_x101-32x4d-dconv-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 9.2 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 47.3 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 41.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/dcn/cascade_mask_rcnn_x101_32x4d_fpn_dconv_c3-c5_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_dconv_c3-c5_1x_coco-e75f90c8.pth diff --git a/mmdetection/configs/dcnv2/README.md b/mmdetection/configs/dcnv2/README.md new file mode 100644 index 00000000..7f42c934 --- /dev/null +++ b/mmdetection/configs/dcnv2/README.md @@ -0,0 +1,37 @@ +# DCNv2 + +> [Deformable ConvNets v2: More Deformable, Better Results](https://arxiv.org/abs/1811.11168) + + + +## Abstract + +The superior performance of Deformable Convolutional Networks arises from its ability to adapt to the geometric variations of objects. Through an examination of its adaptive behavior, we observe that while the spatial support for its neural features conforms more closely than regular ConvNets to object structure, this support may nevertheless extend well beyond the region of interest, causing features to be influenced by irrelevant image content. To address this problem, we present a reformulation of Deformable ConvNets that improves its ability to focus on pertinent image regions, through increased modeling power and stronger training. The modeling power is enhanced through a more comprehensive integration of deformable convolution within the network, and by introducing a modulation mechanism that expands the scope of deformation modeling. To effectively harness this enriched modeling capability, we guide network training via a proposed feature mimicking scheme that helps the network to learn features that reflect the object focus and classification power of RCNN features. With the proposed contributions, this new version of Deformable ConvNets yields significant performance gains over the original model and produces leading results on the COCO benchmark for object detection and instance segmentation. + +## Results and Models + +| Backbone | Model | Style | Conv | Pool | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :---------------: | :----: | :-----: | :-----------: | :----: | :-----: | :------: | :------------: | :----: | :-----: | :------------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | Faster | pytorch | mdconv(c3-c5) | - | 1x | 4.1 | 17.6 | 41.4 | | [config](./faster-rcnn_r50-mdconv-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/dcn/faster_rcnn_r50_fpn_mdconv_c3-c5_1x_coco/faster_rcnn_r50_fpn_mdconv_c3-c5_1x_coco_20200130-d099253b.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/dcn/faster_rcnn_r50_fpn_mdconv_c3-c5_1x_coco/faster_rcnn_r50_fpn_mdconv_c3-c5_1x_coco_20200130_222144.log.json) | +| \*R-50-FPN (dg=4) | Faster | pytorch | mdconv(c3-c5) | - | 1x | 4.2 | 17.4 | 41.5 | | [config](./faster-rcnn_r50-mdconv-group4-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/dcn/faster_rcnn_r50_fpn_mdconv_c3-c5_group4_1x_coco/faster_rcnn_r50_fpn_mdconv_c3-c5_group4_1x_coco_20200130-01262257.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/dcn/faster_rcnn_r50_fpn_mdconv_c3-c5_group4_1x_coco/faster_rcnn_r50_fpn_mdconv_c3-c5_group4_1x_coco_20200130_222058.log.json) | +| R-50-FPN | Faster | pytorch | - | mdpool | 1x | 5.8 | 16.6 | 38.7 | | [config](./faster-rcnn_r50_fpn_mdpool_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/dcn/faster_rcnn_r50_fpn_mdpool_1x_coco/faster_rcnn_r50_fpn_mdpool_1x_coco_20200307-c0df27ff.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/dcn/faster_rcnn_r50_fpn_mdpool_1x_coco/faster_rcnn_r50_fpn_mdpool_1x_coco_20200307_203304.log.json) | +| R-50-FPN | Mask | pytorch | mdconv(c3-c5) | - | 1x | 4.5 | 15.1 | 41.5 | 37.1 | [config](./mask-rcnn_r50-mdconv-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/dcn/mask_rcnn_r50_fpn_mdconv_c3-c5_1x_coco/mask_rcnn_r50_fpn_mdconv_c3-c5_1x_coco_20200203-ad97591f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/dcn/mask_rcnn_r50_fpn_mdconv_c3-c5_1x_coco/mask_rcnn_r50_fpn_mdconv_c3-c5_1x_coco_20200203_063443.log.json) | +| R-50-FPN (FP16) | Mask | pytorch | mdconv(c3-c5) | - | 1x | 3.1 | | 42.0 | 37.6 | [config](./mask-rcnn_r50-mdconv-c3-c5_fpn_amp-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/fp16/mask_rcnn_r50_fpn_fp16_mdconv_c3-c5_1x_coco/mask_rcnn_r50_fpn_fp16_mdconv_c3-c5_1x_coco_20210520_180434-cf8fefa5.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/fp16/mask_rcnn_r50_fpn_fp16_mdconv_c3-c5_1x_coco/mask_rcnn_r50_fpn_fp16_mdconv_c3-c5_1x_coco_20210520_180434.log.json) | + +**Notes:** + +- `mdconv` denotes modulated deformable convolution, `c3-c5` means adding dconv in resnet stage 3 to 5. `mdpool` denotes modulated deformable roi pooling. +- The dcn ops are modified from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch, which should be more memory efficient and slightly faster. +- (\*) For R-50-FPN (dg=4), dg is short for deformable_group. This model is trained and tested on Amazon EC2 p3dn.24xlarge instance. +- **Memory, Train/Inf time is outdated.** + +## Citation + +```latex +@article{zhu2018deformable, + title={Deformable ConvNets v2: More Deformable, Better Results}, + author={Zhu, Xizhou and Hu, Han and Lin, Stephen and Dai, Jifeng}, + journal={arXiv preprint arXiv:1811.11168}, + year={2018} +} +``` diff --git a/mmdetection/configs/dcnv2/faster-rcnn_r50-mdconv-c3-c5_fpn_1x_coco.py b/mmdetection/configs/dcnv2/faster-rcnn_r50-mdconv-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..a7f7e4ee --- /dev/null +++ b/mmdetection/configs/dcnv2/faster-rcnn_r50-mdconv-c3-c5_fpn_1x_coco.py @@ -0,0 +1,5 @@ +_base_ = '../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + dcn=dict(type='DCNv2', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True))) diff --git a/mmdetection/configs/dcnv2/faster-rcnn_r50-mdconv-group4-c3-c5_fpn_1x_coco.py b/mmdetection/configs/dcnv2/faster-rcnn_r50-mdconv-group4-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..5c58dbed --- /dev/null +++ b/mmdetection/configs/dcnv2/faster-rcnn_r50-mdconv-group4-c3-c5_fpn_1x_coco.py @@ -0,0 +1,5 @@ +_base_ = '../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + dcn=dict(type='DCNv2', deform_groups=4, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True))) diff --git a/mmdetection/configs/dcnv2/faster-rcnn_r50_fpn_mdpool_1x_coco.py b/mmdetection/configs/dcnv2/faster-rcnn_r50_fpn_mdpool_1x_coco.py new file mode 100644 index 00000000..6198d6d7 --- /dev/null +++ b/mmdetection/configs/dcnv2/faster-rcnn_r50_fpn_mdpool_1x_coco.py @@ -0,0 +1,12 @@ +_base_ = '../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + roi_head=dict( + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict( + _delete_=True, + type='ModulatedDeformRoIPoolPack', + output_size=7, + output_channels=256), + out_channels=256, + featmap_strides=[4, 8, 16, 32]))) diff --git a/mmdetection/configs/dcnv2/mask-rcnn_r50-mdconv-c3-c5_fpn_1x_coco.py b/mmdetection/configs/dcnv2/mask-rcnn_r50-mdconv-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..f7a90bbf --- /dev/null +++ b/mmdetection/configs/dcnv2/mask-rcnn_r50-mdconv-c3-c5_fpn_1x_coco.py @@ -0,0 +1,5 @@ +_base_ = '../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + dcn=dict(type='DCNv2', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True))) diff --git a/mmdetection/configs/dcnv2/mask-rcnn_r50-mdconv-c3-c5_fpn_amp-1x_coco.py b/mmdetection/configs/dcnv2/mask-rcnn_r50-mdconv-c3-c5_fpn_amp-1x_coco.py new file mode 100644 index 00000000..3b3894c2 --- /dev/null +++ b/mmdetection/configs/dcnv2/mask-rcnn_r50-mdconv-c3-c5_fpn_amp-1x_coco.py @@ -0,0 +1,10 @@ +_base_ = '../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + dcn=dict(type='DCNv2', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True))) + +# MMEngine support the following two ways, users can choose +# according to convenience +# optim_wrapper = dict(type='AmpOptimWrapper') +_base_.optim_wrapper.type = 'AmpOptimWrapper' diff --git a/mmdetection/configs/dcnv2/metafile.yml b/mmdetection/configs/dcnv2/metafile.yml new file mode 100644 index 00000000..dea7bfa1 --- /dev/null +++ b/mmdetection/configs/dcnv2/metafile.yml @@ -0,0 +1,123 @@ +Collections: + - Name: Deformable Convolutional Networks v2 + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - Deformable Convolution + Paper: + URL: https://arxiv.org/abs/1811.11168 + Title: "Deformable ConvNets v2: More Deformable, Better Results" + README: configs/dcnv2/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/ops/dcn/deform_conv.py#L15 + Version: v2.0.0 + +Models: + - Name: faster-rcnn_r50_fpn_mdconv_c3-c5_1x_coco + In Collection: Deformable Convolutional Networks v2 + Config: configs/dcnv2/faster-rcnn_r50-mdconv-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.1 + inference time (ms/im): + - value: 56.82 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/dcn/faster_rcnn_r50_fpn_mdconv_c3-c5_1x_coco/faster_rcnn_r50_fpn_mdconv_c3-c5_1x_coco_20200130-d099253b.pth + + - Name: faster-rcnn_r50_fpn_mdconv_c3-c5_group4_1x_coco + In Collection: Deformable Convolutional Networks v2 + Config: configs/dcnv2/faster-rcnn_r50-mdconv-group4-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.2 + inference time (ms/im): + - value: 57.47 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/dcn/faster_rcnn_r50_fpn_mdconv_c3-c5_group4_1x_coco/faster_rcnn_r50_fpn_mdconv_c3-c5_group4_1x_coco_20200130-01262257.pth + + - Name: faster-rcnn_r50_fpn_mdpool_1x_coco + In Collection: Deformable Convolutional Networks v2 + Config: configs/dcnv2/faster-rcnn_r50_fpn_mdpool_1x_coco.py + Metadata: + Training Memory (GB): 5.8 + inference time (ms/im): + - value: 60.24 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/dcn/faster_rcnn_r50_fpn_mdpool_1x_coco/faster_rcnn_r50_fpn_mdpool_1x_coco_20200307-c0df27ff.pth + + - Name: mask-rcnn_r50_fpn_mdconv_c3-c5_1x_coco + In Collection: Deformable Convolutional Networks v2 + Config: configs/dcnv2/mask-rcnn_r50-mdconv-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.5 + inference time (ms/im): + - value: 66.23 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.5 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/dcn/mask_rcnn_r50_fpn_mdconv_c3-c5_1x_coco/mask_rcnn_r50_fpn_mdconv_c3-c5_1x_coco_20200203-ad97591f.pth + + - Name: mask-rcnn_r50_fpn_fp16_mdconv_c3-c5_1x_coco + In Collection: Deformable Convolutional Networks v2 + Config: configs/dcnv2/mask-rcnn_r50-mdconv-c3-c5_fpn_amp-1x_coco.py + Metadata: + Training Memory (GB): 3.1 + Training Techniques: + - SGD with Momentum + - Weight Decay + - Mixed Precision Training + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.0 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/fp16/mask_rcnn_r50_fpn_fp16_mdconv_c3-c5_1x_coco/mask_rcnn_r50_fpn_fp16_mdconv_c3-c5_1x_coco_20210520_180434-cf8fefa5.pth diff --git a/mmdetection/configs/ddod/README.md b/mmdetection/configs/ddod/README.md new file mode 100644 index 00000000..d5ea9cd0 --- /dev/null +++ b/mmdetection/configs/ddod/README.md @@ -0,0 +1,31 @@ +# DDOD + +> [Disentangle Your Dense Object Detector](https://arxiv.org/pdf/2107.02963.pdf) + + + +## Abstract + +Deep learning-based dense object detectors have achieved great success in the past few years and have been applied to numerous multimedia applications such as video understanding. However, the current training pipeline for dense detectors is compromised to lots of conjunctions that may not hold. In this paper, we investigate three such important conjunctions: 1) only samples assigned as positive in classification head are used to train the regression head; 2) classification and regression share the same input feature and computational fields defined by the parallel head architecture; and 3) samples distributed in different feature pyramid layers are treated equally when computing the loss. We first carry out a series of pilot experiments to show disentangling such conjunctions can lead to persistent performance improvement. Then, based on these findings, we propose Disentangled Dense Object Detector(DDOD), in which simple and effective disentanglement mechanisms are designed and integrated into the current state-of-the-art dense object detectors. Extensive experiments on MS COCO benchmark show that our approach can lead to 2.0 mAP, 2.4 mAP and 2.2 mAP absolute improvements on RetinaNet, FCOS, and ATSS baselines with negligible extra overhead. Notably, our best model reaches 55.0 mAP on the COCO test-dev set and 93.5 AP on the hard subset of WIDER FACE, achieving new state-of-the-art performance on these two competitive benchmarks. Code is available at https://github.com/zehuichen123/DDOD. + +
    + +
    + +## Results and Models + +| Model | Backbone | Style | Lr schd | Mem (GB) | box AP | Config | Download | +| :-------: | :------: | :-----: | :-----: | :------: | :----: | :---------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| DDOD-ATSS | R-50 | pytorch | 1x | 3.4 | 41.7 | [config](./ddod_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/ddod/ddod_r50_fpn_1x_coco/ddod_r50_fpn_1x_coco_20220523_223737-29b2fc67.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/ddod/ddod_r50_fpn_1x_coco/ddod_r50_fpn_1x_coco_20220523_223737.log.json) | + +## Citation + +```latex +@inproceedings{chen2021disentangle, +title={Disentangle Your Dense Object Detector}, +author={Chen, Zehui and Yang, Chenhongyi and Li, Qiaofei and Zhao, Feng and Zha, Zheng-Jun and Wu, Feng}, +booktitle={Proceedings of the 29th ACM International Conference on Multimedia}, +pages={4939--4948}, +year={2021} +} +``` diff --git a/mmdetection/configs/ddod/ddod_r50_fpn_1x_coco.py b/mmdetection/configs/ddod/ddod_r50_fpn_1x_coco.py new file mode 100644 index 00000000..fed1116b --- /dev/null +++ b/mmdetection/configs/ddod/ddod_r50_fpn_1x_coco.py @@ -0,0 +1,72 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +model = dict( + type='DDOD', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_output', + num_outs=5), + bbox_head=dict( + type='DDODHead', + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + octave_base_scale=8, + scales_per_octave=1, + strides=[8, 16, 32, 64, 128]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=2.0), + loss_iou=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)), + train_cfg=dict( + # assigner is mean cls_assigner + assigner=dict(type='ATSSAssigner', topk=9, alpha=0.8), + reg_assigner=dict(type='ATSSAssigner', topk=9, alpha=0.5), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) + +# optimizer +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) diff --git a/mmdetection/configs/ddod/metafile.yml b/mmdetection/configs/ddod/metafile.yml new file mode 100644 index 00000000..c2239500 --- /dev/null +++ b/mmdetection/configs/ddod/metafile.yml @@ -0,0 +1,33 @@ +Collections: + - Name: DDOD + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - DDOD + - FPN + - ResNet + Paper: + URL: https://arxiv.org/pdf/2107.02963.pdf + Title: 'Disentangle Your Dense Object Detector' + README: configs/ddod/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.25.0/mmdet/models/detectors/ddod.py#L6 + Version: v2.25.0 + +Models: + - Name: ddod_r50_fpn_1x_coco + In Collection: DDOD + Config: configs/ddod/ddod_r50_fpn_1x_coco.py + Metadata: + Training Memory (GB): 3.4 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/ddod/ddod_r50_fpn_1x_coco/ddod_r50_fpn_1x_coco_20220523_223737-29b2fc67.pth diff --git a/mmdetection/configs/ddq/README.md b/mmdetection/configs/ddq/README.md new file mode 100644 index 00000000..3f6f459c --- /dev/null +++ b/mmdetection/configs/ddq/README.md @@ -0,0 +1,39 @@ +# DDQ + +> [Dense Distinct Query for End-to-End Object Detection](https://arxiv.org/abs/2303.12776) + + + +## Abstract + + + +One-to-one label assignment in object detection has successfully obviated the need for non-maximum suppression (NMS) as postprocessing and makes the pipeline end-to-end. However, it triggers a new dilemma as the widely used sparse queries cannot guarantee a high recall, while dense queries inevitably bring more similar queries and encounter optimization difficulties. As both sparse and dense queries are problematic, then what are the expected queries in end-to-end object detection? This paper shows that the solution should be Dense Distinct Queries (DDQ). Concretely, we first lay dense queries like traditional detectors and then select distinct ones for one-to-one assignments. DDQ blends the advantages of traditional and recent end-to-end detectors and significantly improves the performance of various detectors including FCN, R-CNN, and DETRs. Most impressively, DDQ-DETR achieves 52.1 AP on MS-COCO dataset within 12 epochs using a ResNet-50 backbone, outperforming all existing detectors in the same setting. DDQ also shares the benefit of end-to-end detectors in crowded scenes and achieves 93.8 AP on CrowdHuman. We hope DDQ can inspire researchers to consider the complementarity between traditional methods and end-to-end detectors. + +![ddq_arch](https://github.com/open-mmlab/mmdetection/assets/33146359/5ca9f11b-b6f3-454f-a2d1-3009ee337bbc) + +## Results and Models + +| Model | Backbone | Lr schd | Augmentation | box AP(val) | Config | Download | +| :---------------: | :------: | :-----: | :----------: | :---------: | :------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| DDQ DETR-4scale | R-50 | 12e | DETR | 51.4 | [config](./ddq-detr-4scale_r50_8xb2-12e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/ddq/ddq-detr-4scale_r50_8xb2-12e_coco/ddq-detr-4scale_r50_8xb2-12e_coco_20230809_170711-42528127.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/ddq/ddq-detr-4scale_r50_8xb2-12e_coco/ddq-detr-4scale_r50_8xb2-12e_coco_20230809_170711.log.json) | +| DDQ DETR-5scale\* | R-50 | 12e | DETR | 52.1 | [config](./ddq-detr-5scale_r50_8xb2-12e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/ddq/ddq_detr_5scale_coco_1x.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/ddq/ddq_detr_5scale_coco_1x_20230319_103307.log) | +| DDQ DETR-4scale\* | Swin-L | 30e | DETR | 58.7 | [config](./ddq-detr-4scale_swinl_8xb2-30e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/ddq/ddq_detr_swinl_30e.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/ddq/ddq_detr_swinl_30e_20230316_221721_20230318_143554.log) | + +**Note** + +- Models labeled * are not trained by us, but from [DDQ official website](https://github.com/jshilong/DDQ). +- We find that the performance is unstable and may fluctuate by about 0.2 mAP. + +## Citation + +```latex +@InProceedings{Zhang_2023_CVPR, + author = {Zhang, Shilong and Wang, Xinjiang and Wang, Jiaqi and Pang, Jiangmiao and Lyu, Chengqi and Zhang, Wenwei and Luo, Ping and Chen, Kai}, + title = {Dense Distinct Query for End-to-End Object Detection}, + booktitle = {Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)}, + month = {June}, + year = {2023}, + pages = {7329-7338} +} +``` diff --git a/mmdetection/configs/ddq/ddq-detr-4scale_r50_8xb2-12e_coco.py b/mmdetection/configs/ddq/ddq-detr-4scale_r50_8xb2-12e_coco.py new file mode 100644 index 00000000..5e64afc0 --- /dev/null +++ b/mmdetection/configs/ddq/ddq-detr-4scale_r50_8xb2-12e_coco.py @@ -0,0 +1,170 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', '../_base_/default_runtime.py' +] +model = dict( + type='DDQDETR', + num_queries=900, # num_matching_queries + # ratio of num_dense queries to num_queries + dense_topk_ratio=1.5, + with_box_refine=True, + as_two_stage=True, + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=1), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=False), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='ChannelMapper', + in_channels=[512, 1024, 2048], + kernel_size=1, + out_channels=256, + act_cfg=None, + norm_cfg=dict(type='GN', num_groups=32), + num_outs=4), + # encoder class name: DeformableDetrTransformerEncoder + encoder=dict( + num_layers=6, + layer_cfg=dict( + self_attn_cfg=dict(embed_dims=256, num_levels=4, + dropout=0.0), # 0.1 for DeformDETR + ffn_cfg=dict( + embed_dims=256, + feedforward_channels=2048, # 1024 for DeformDETR + ffn_drop=0.0))), # 0.1 for DeformDETR + # decoder class name: DDQTransformerDecoder + decoder=dict( + # `num_layers` >= 2, because attention masks of the last + # `num_layers` - 1 layers are used for distinct query selection + num_layers=6, + return_intermediate=True, + layer_cfg=dict( + self_attn_cfg=dict(embed_dims=256, num_heads=8, + dropout=0.0), # 0.1 for DeformDETR + cross_attn_cfg=dict(embed_dims=256, num_levels=4, + dropout=0.0), # 0.1 for DeformDETR + ffn_cfg=dict( + embed_dims=256, + feedforward_channels=2048, # 1024 for DeformDETR + ffn_drop=0.0)), # 0.1 for DeformDETR + post_norm_cfg=None), + positional_encoding=dict( + num_feats=128, + normalize=True, + offset=0.0, # -0.5 for DeformDETR + temperature=20), # 10000 for DeformDETR + bbox_head=dict( + type='DDQDETRHead', + num_classes=80, + sync_cls_avg_factor=True, + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=5.0), + loss_iou=dict(type='GIoULoss', loss_weight=2.0)), + dn_cfg=dict( + label_noise_scale=0.5, + box_noise_scale=1.0, + group_cfg=dict(dynamic=True, num_groups=None, num_dn_queries=100)), + dqs_cfg=dict(type='nms', iou_threshold=0.8), + # training and testing settings + train_cfg=dict( + assigner=dict( + type='HungarianAssigner', + match_costs=[ + dict(type='FocalLossCost', weight=2.0), + dict(type='BBoxL1Cost', weight=5.0, box_format='xywh'), + dict(type='IoUCost', iou_mode='giou', weight=2.0) + ])), + test_cfg=dict(max_per_img=300)) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='PackDetInputs') +] + +train_dataloader = dict( + dataset=dict( + filter_cfg=dict(filter_empty_gt=False), pipeline=train_pipeline)) + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.0002, weight_decay=0.05), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict(custom_keys={'backbone': dict(lr_mult=0.1)})) + +# learning policy +max_epochs = 12 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) + +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +param_scheduler = [ + dict( + type='LinearLR', + start_factor=0.0001, + by_epoch=False, + begin=0, + end=2000), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[11], + gamma=0.1) +] + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=16) diff --git a/mmdetection/configs/ddq/ddq-detr-4scale_swinl_8xb2-30e_coco.py b/mmdetection/configs/ddq/ddq-detr-4scale_swinl_8xb2-30e_coco.py new file mode 100644 index 00000000..d8636494 --- /dev/null +++ b/mmdetection/configs/ddq/ddq-detr-4scale_swinl_8xb2-30e_coco.py @@ -0,0 +1,177 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', '../_base_/default_runtime.py' +] +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_large_patch4_window12_384_22k.pth' # noqa: E501 +model = dict( + type='DDQDETR', + num_queries=900, # num_matching_queries + # ratio of num_dense queries to num_queries + dense_topk_ratio=1.5, + with_box_refine=True, + as_two_stage=True, + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=1), + backbone=dict( + type='SwinTransformer', + pretrain_img_size=384, + embed_dims=192, + depths=[2, 2, 18, 2], + num_heads=[6, 12, 24, 48], + window_size=12, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.2, + patch_norm=True, + out_indices=(1, 2, 3), + with_cp=False, + convert_weights=True, + init_cfg=dict(type='Pretrained', checkpoint=pretrained)), + neck=dict( + type='ChannelMapper', + in_channels=[384, 768, 1536], + kernel_size=1, + out_channels=256, + act_cfg=None, + norm_cfg=dict(type='GN', num_groups=32), + num_outs=4), + # encoder class name: DeformableDetrTransformerEncoder + encoder=dict( + num_layers=6, + layer_cfg=dict( + self_attn_cfg=dict(embed_dims=256, num_levels=4, + dropout=0.0), # 0.1 for DeformDETR + ffn_cfg=dict( + embed_dims=256, + feedforward_channels=2048, # 1024 for DeformDETR + ffn_drop=0.0))), # 0.1 for DeformDETR + # decoder class name: DDQTransformerDecoder + decoder=dict( + num_layers=6, + return_intermediate=True, + layer_cfg=dict( + self_attn_cfg=dict(embed_dims=256, num_heads=8, + dropout=0.0), # 0.1 for DeformDETR + cross_attn_cfg=dict(embed_dims=256, num_levels=4, + dropout=0.0), # 0.1 for DeformDETR + ffn_cfg=dict( + embed_dims=256, + feedforward_channels=2048, # 1024 for DeformDETR + ffn_drop=0.0)), # 0.1 for DeformDETR + post_norm_cfg=None), + positional_encoding=dict( + num_feats=128, + normalize=True, + offset=0.0, # -0.5 for DeformDETR + temperature=20), # 10000 for DeformDETR + bbox_head=dict( + type='DDQDETRHead', + num_classes=80, + sync_cls_avg_factor=True, + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=5.0), + loss_iou=dict(type='GIoULoss', loss_weight=2.0)), + dn_cfg=dict( + label_noise_scale=0.5, + box_noise_scale=1.0, + group_cfg=dict(dynamic=True, num_groups=None, num_dn_queries=100)), + dqs_cfg=dict(type='nms', iou_threshold=0.8), + # training and testing settings + train_cfg=dict( + assigner=dict( + type='HungarianAssigner', + match_costs=[ + dict(type='FocalLossCost', weight=2.0), + dict(type='BBoxL1Cost', weight=5.0, box_format='xywh'), + dict(type='IoUCost', iou_mode='giou', weight=2.0) + ])), + test_cfg=dict(max_per_img=300)) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='PackDetInputs') +] + +train_dataloader = dict( + dataset=dict( + filter_cfg=dict(filter_empty_gt=False), pipeline=train_pipeline)) + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.0002, weight_decay=0.05), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict(custom_keys={'backbone': dict(lr_mult=0.05)})) + +# learning policy +max_epochs = 30 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) + +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +param_scheduler = [ + dict( + type='LinearLR', + start_factor=0.0001, + by_epoch=False, + begin=0, + end=2000), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[20, 26], + gamma=0.1) +] + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=16) diff --git a/mmdetection/configs/ddq/ddq-detr-5scale_r50_8xb2-12e_coco.py b/mmdetection/configs/ddq/ddq-detr-5scale_r50_8xb2-12e_coco.py new file mode 100644 index 00000000..3c38f553 --- /dev/null +++ b/mmdetection/configs/ddq/ddq-detr-5scale_r50_8xb2-12e_coco.py @@ -0,0 +1,171 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', '../_base_/default_runtime.py' +] +model = dict( + type='DDQDETR', + num_queries=900, # num_matching_queries + # ratio of num_dense queries to num_queries + dense_topk_ratio=1.5, + with_box_refine=True, + as_two_stage=True, + num_feature_levels=5, + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=1), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=False), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='ChannelMapper', + in_channels=[256, 512, 1024, 2048], + kernel_size=1, + out_channels=256, + act_cfg=None, + norm_cfg=dict(type='GN', num_groups=32), + num_outs=5), + # encoder class name: DeformableDetrTransformerEncoder + encoder=dict( + num_layers=6, + layer_cfg=dict( + self_attn_cfg=dict(embed_dims=256, num_levels=5, + dropout=0.0), # 0.1 for DeformDETR + ffn_cfg=dict( + embed_dims=256, + feedforward_channels=2048, # 1024 for DeformDETR + ffn_drop=0.0))), # 0.1 for DeformDETR + # decoder class name: DDQTransformerDecoder + decoder=dict( + num_layers=6, + return_intermediate=True, + layer_cfg=dict( + self_attn_cfg=dict(embed_dims=256, num_heads=8, + dropout=0.0), # 0.1 for DeformDETR + cross_attn_cfg=dict(embed_dims=256, num_levels=5, + dropout=0.0), # 0.1 for DeformDETR + ffn_cfg=dict( + embed_dims=256, + feedforward_channels=2048, # 1024 for DeformDETR + ffn_drop=0.0)), # 0.1 for DeformDETR + post_norm_cfg=None), + positional_encoding=dict( + num_feats=128, + normalize=True, + offset=0.0, # -0.5 for DeformDETR + temperature=20), # 10000 for DeformDETR + bbox_head=dict( + type='DDQDETRHead', + num_classes=80, + sync_cls_avg_factor=True, + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=5.0), + loss_iou=dict(type='GIoULoss', loss_weight=2.0)), + dn_cfg=dict( + label_noise_scale=0.5, + box_noise_scale=1.0, + group_cfg=dict(dynamic=True, num_groups=None, num_dn_queries=100)), + dqs_cfg=dict(type='nms', iou_threshold=0.8), + # training and testing settings + train_cfg=dict( + assigner=dict( + type='HungarianAssigner', + match_costs=[ + dict(type='FocalLossCost', weight=2.0), + dict(type='BBoxL1Cost', weight=5.0, box_format='xywh'), + dict(type='IoUCost', iou_mode='giou', weight=2.0) + ])), + test_cfg=dict(max_per_img=300)) + +# train_pipeline, NOTE the img_scale and the Pad's size_divisor is different +# from the default setting in mmdet. +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='PackDetInputs') +] + +train_dataloader = dict( + dataset=dict( + filter_cfg=dict(filter_empty_gt=False), pipeline=train_pipeline)) + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.0002, weight_decay=0.05), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict(custom_keys={'backbone': dict(lr_mult=0.1)})) + +# learning policy +max_epochs = 12 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) + +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +param_scheduler = [ + dict( + type='LinearLR', + start_factor=0.0001, + by_epoch=False, + begin=0, + end=2000), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[11], + gamma=0.1) +] + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=16) diff --git a/mmdetection/configs/ddq/metafile.yml b/mmdetection/configs/ddq/metafile.yml new file mode 100644 index 00000000..bd33abe1 --- /dev/null +++ b/mmdetection/configs/ddq/metafile.yml @@ -0,0 +1,56 @@ +Collections: + - Name: DDQ + Metadata: + Training Data: COCO + Training Techniques: + - AdamW + - Multi Scale Train + - Gradient Clip + Training Resources: 8x A100 GPUs + Architecture: + - ResNet + - Transformer + Paper: + URL: https://arxiv.org/abs/2303.12776 + Title: 'Dense Distinct Query for End-to-End Object Detection' + README: configs/ddq/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/dev-3.x/mmdet/models/detectors/ddq_detr.py#L21 + Version: dev-3.x + +Models: + - Name: ddq-detr-4scale_r50_8xb2-12e_coco + In Collection: DDQ + Config: configs/ddq/ddq-detr-4scale_r50_8xb2-12e_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 51.4 + Weights: https://download.openmmlab.com/mmdetection/v3.0/ddq/ddq-detr-4scale_r50_8xb2-12e_coco/ddq-detr-4scale_r50_8xb2-12e_coco_20230809_170711-42528127.pth + + - Name: ddq-detr-5scale_r50_8xb2-12e_coco + In Collection: DDQ + Config: configs/dino/ddq-detr-5scale_r50_8xb2-12e_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 52.1 + Weights: https://download.openmmlab.com/mmdetection/v3.0/ddq/ddq_detr_5scale_coco_1x.pth + + - Name: ddq-detr-4scale_swinl_8xb2-30e_coco + In Collection: DDQ + Config: configs/dino/ddq-detr-4scale_swinl_8xb2-30e_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 58.7 + Weights: https://download.openmmlab.com/mmdetection/v3.0/ddq/ddq_detr_swinl_30e.pth diff --git a/mmdetection/configs/deepfashion/README.md b/mmdetection/configs/deepfashion/README.md new file mode 100644 index 00000000..844e29d6 --- /dev/null +++ b/mmdetection/configs/deepfashion/README.md @@ -0,0 +1,70 @@ +# DeepFashion + +> [DeepFashion: Powering Robust Clothes Recognition and Retrieval With Rich Annotations](https://openaccess.thecvf.com/content_cvpr_2016/html/Liu_DeepFashion_Powering_Robust_CVPR_2016_paper.html) + + + +## Abstract + +Recent advances in clothes recognition have been driven by the construction of clothes datasets. Existing datasets are limited in the amount of annotations and are difficult to cope with the various challenges in real-world applications. In this work, we introduce DeepFashion, a large-scale clothes dataset with comprehensive annotations. It contains over 800,000 images, which are richly annotated with massive attributes, clothing landmarks, and correspondence of images taken under different scenarios including store, street snapshot, and consumer. Such rich annotations enable the development of powerful algorithms in clothes recognition and facilitating future researches. To demonstrate the advantages of DeepFashion, we propose a new deep model, namely FashionNet, which learns clothing features by jointly predicting clothing attributes and landmarks. The estimated landmarks are then employed to pool or gate the learned features. It is optimized in an iterative manner. Extensive experiments demonstrate the effectiveness of FashionNet and the usefulness of DeepFashion. + +
    + +
    + +## Introduction + +[MMFashion](https://github.com/open-mmlab/mmfashion) develops "fashion parsing and segmentation" module +based on the dataset +[DeepFashion-Inshop](https://drive.google.com/drive/folders/0B7EVK8r0v71pVDZFQXRsMDZCX1E?usp=sharing). +Its annotation follows COCO style. +To use it, you need to first download the data. Note that we only use "img_highres" in this task. +The file tree should be like this: + +```sh +mmdetection +├── mmdet +├── tools +├── configs +├── data +│ ├── DeepFashion +│ │ ├── In-shop +| │ │ ├── Anno +| │ │ │   ├── segmentation +| │ │ │   | ├── DeepFashion_segmentation_train.json +| │ │ │   | ├── DeepFashion_segmentation_query.json +| │ │ │   | ├── DeepFashion_segmentation_gallery.json +| │ │ │   ├── list_bbox_inshop.txt +| │ │ │   ├── list_description_inshop.json +| │ │ │   ├── list_item_inshop.txt +| │ │ │   └── list_landmarks_inshop.txt +| │ │ ├── Eval +| │ │ │ └── list_eval_partition.txt +| │ │ ├── Img +| │ │ │ ├── img +| │ │ │ │ ├──XXX.jpg +| │ │ │ ├── img_highres +| │ │ │ └── ├──XXX.jpg + +``` + +After that you can train the Mask RCNN r50 on DeepFashion-In-shop dataset by launching training with the `mask_rcnn_r50_fpn_1x.py` config +or creating your own config file. + +## Results and Models + +| Backbone | Model type | Dataset | bbox detection Average Precision | segmentation Average Precision | Config | Download (Google) | +| :------: | :--------: | :-----------------: | :------------------------------: | :----------------------------: | :----------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| ResNet50 | Mask RCNN | DeepFashion-In-shop | 0.599 | 0.584 | [config](./mask-rcnn_r50_fpn_15e_deepfashion.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/deepfashion/mask_rcnn_r50_fpn_15e_deepfashion/mask_rcnn_r50_fpn_15e_deepfashion_20200329_192752.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/deepfashion/mask_rcnn_r50_fpn_15e_deepfashion/20200329_192752.log.json) | + +## Citation + +```latex +@inproceedings{liuLQWTcvpr16DeepFashion, + author = {Liu, Ziwei and Luo, Ping and Qiu, Shi and Wang, Xiaogang and Tang, Xiaoou}, + title = {DeepFashion: Powering Robust Clothes Recognition and Retrieval with Rich Annotations}, + booktitle = {Proceedings of IEEE Conference on Computer Vision and Pattern Recognition (CVPR)}, + month = {June}, + year = {2016} +} +``` diff --git a/mmdetection/configs/deepfashion/mask-rcnn_r50_fpn_15e_deepfashion.py b/mmdetection/configs/deepfashion/mask-rcnn_r50_fpn_15e_deepfashion.py new file mode 100644 index 00000000..403b18a4 --- /dev/null +++ b/mmdetection/configs/deepfashion/mask-rcnn_r50_fpn_15e_deepfashion.py @@ -0,0 +1,23 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/deepfashion.py', '../_base_/schedules/schedule_1x.py', + '../_base_/default_runtime.py' +] +model = dict( + roi_head=dict( + bbox_head=dict(num_classes=15), mask_head=dict(num_classes=15))) +# runtime settings +max_epochs = 15 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] diff --git a/mmdetection/configs/deepsort/README.md b/mmdetection/configs/deepsort/README.md new file mode 100644 index 00000000..e50ec17e --- /dev/null +++ b/mmdetection/configs/deepsort/README.md @@ -0,0 +1,109 @@ +# Simple online and realtime tracking with a deep association metric + +## Abstract + + + +Simple Online and Realtime Tracking (SORT) is a pragmatic approach to multiple object tracking with a focus on simple, effective algorithms. In this paper, we integrate appearance information to improve the performance of SORT. Due to this extension we are able to track objects through longer periods of occlusions, effectively reducing the number of identity switches. In spirit of the original framework we place much of the computational complexity into an offline pre-training stage where we learn a deep association metric on a largescale person re-identification dataset. During online application, we establish measurement-to-track associations using nearest neighbor queries in visual appearance space. Experimental evaluation shows that our extensions reduce the number of identity switches by 45%, achieving overall competitive performance at high frame rates. + + + +
    + +
    + +## Results and models on MOT17 + +Currently we do not support training ReID models for DeepSORT. +We directly use the ReID model from [Tracktor](https://github.com/phil-bergmann/tracking_wo_bnw). These missed features will be supported in the future. + +| Method | Detector | ReID | Train Set | Test Set | Public | Inf time (fps) | HOTA | MOTA | IDF1 | FP | FN | IDSw. | Config | Download | +| :------: | :----------------: | :--: | :--------: | :------: | :----: | :------------: | :--: | :--: | :--: | :---: | :---: | :---: | :--------------------------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| DeepSORT | R50-FasterRCNN-FPN | R50 | half-train | half-val | N | 13.8 | 57.0 | 63.7 | 69.5 | 15063 | 40323 | 3276 | [config](deepsort_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py) | [detector](https://download.openmmlab.com/mmtracking/mot/faster_rcnn/faster-rcnn_r50_fpn_4e_mot17-half-64ee2ed4.pth) [reid](https://download.openmmlab.com/mmtracking/mot/reid/tracktor_reid_r50_iter25245-a452f51f.pth) | + +## Get started + +### 1. Development Environment Setup + +Tracking Development Environment Setup can refer to this [document](../../docs/en/get_started.md). + +### 2. Dataset Prepare + +Tracking Dataset Prepare can refer to this [document](../../docs/en/user_guides/tracking_dataset_prepare.md). + +### 3. Training + +We implement DeepSORT with independent detector and ReID models. +Note that, due to the influence of parameters such as learning rate in default configuration file, +we recommend using 8 GPUs for training in order to reproduce accuracy. + +You can train the detector as follows. + +```shell script +# Training Faster R-CNN on mot17-half-train dataset with following command. +# The number after config file represents the number of GPUs used. Here we use 8 GPUs. +bash tools/dist_train.sh configs/sort/faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py 8 +``` + +If you want to know about more detailed usage of `train.py/dist_train.sh/slurm_train.sh`, +please refer to this [document](../../docs/en/user_guides/tracking_train_test.md). + +### 4. Testing and evaluation + +### 4.1 Example on MOTxx-halfval dataset + +**4.1.1 use separate trained detector and reid model to evaluating and testing** + +```shell +# Example 1: Test on motXX-half-val set. +# The number after config file represents the number of GPUs used. Here we use 8 GPUs. +bash tools/dist_test_tracking.sh configs/deepsort/deepsort_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py 8 --detector ${DETECTOR_CHECKPOINT_PATH} --reid ${REID_CHECKPOINT_PATH} +``` + +**4.1.2 use video_baesd to evaluating and testing** + +we also provide two_ways(img_based or video_based) to evaluating and testing. +if you want to use video_based to evaluating and testing, you can modify config as follows + +``` +val_dataloader = dict( + sampler=dict(type='DefaultSampler', shuffle=False, round_up=False)) +``` + +### 4.2 Example on MOTxx-test dataset + +If you want to get the results of the [MOT Challenge](https://motchallenge.net/) test set, +please use the following command to generate result files that can be used for submission. +It will be stored in `./mot_17_test_res`, you can modify the saved path in `test_evaluator` of the config. + +```shell script +# Example 2: Test on motxx-test set +# The number after config file represents the number of GPUs used +bash tools/dist_test_tracking.sh configs/deepsort/deepsort_faster-rcnn_r50_fpn_8xb2-4e_mot17train_test-mot17test 8 --detector ${DETECTOR_CHECKPOINT_PATH} --reid ${REID_CHECKPOINT_PATH} +``` + +If you want to know about more detailed usage of `test_tracking.py/dist_test_tracking.sh/slurm_test_tracking.sh`, +please refer to this [document](../../docs/en/user_guides/tracking_train_test.md). + +### 5.Inference + +Use a single GPU to predict a video and save it as a video. + +```shell +python demo/mot_demo.py demo/demo_mot.mp4 configs/deepsort/deepsort_faster-rcnn_r50_fpn_8xb2-4e_mot17train_test-mot17test --detector ${DETECTOR_CHECKPOINT_PATH} --reid ${REID_CHECKPOINT_PATH} --out mot.mp4 +``` + +## Citation + + + +```latex +@inproceedings{wojke2017simple, + title={Simple online and realtime tracking with a deep association metric}, + author={Wojke, Nicolai and Bewley, Alex and Paulus, Dietrich}, + booktitle={2017 IEEE international conference on image processing (ICIP)}, + pages={3645--3649}, + year={2017}, + organization={IEEE} +} +``` diff --git a/mmdetection/configs/deepsort/deepsort_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py b/mmdetection/configs/deepsort/deepsort_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py new file mode 100644 index 00000000..70d33938 --- /dev/null +++ b/mmdetection/configs/deepsort/deepsort_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py @@ -0,0 +1,85 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../_base_/datasets/mot_challenge.py', '../_base_/default_runtime.py' +] + +default_hooks = dict( + logger=dict(type='LoggerHook', interval=1), + visualization=dict(type='TrackVisualizationHook', draw=False)) + +vis_backends = [dict(type='LocalVisBackend')] +visualizer = dict( + type='TrackLocalVisualizer', vis_backends=vis_backends, name='visualizer') +# custom hooks +custom_hooks = [ + # Synchronize model buffers such as running_mean and running_var in BN + # at the end of each epoch + dict(type='SyncBuffersHook') +] + +detector = _base_.model +detector.pop('data_preprocessor') +detector.rpn_head.bbox_coder.update(dict(clip_border=False)) +detector.roi_head.bbox_head.update(dict(num_classes=1)) +detector.roi_head.bbox_head.bbox_coder.update(dict(clip_border=False)) +detector['init_cfg'] = dict( + type='Pretrained', + checkpoint= # noqa: E251 + 'https://download.openmmlab.com/mmtracking/mot/faster_rcnn/' + 'faster-rcnn_r50_fpn_4e_mot17-half-64ee2ed4.pth') +del _base_.model + +model = dict( + type='DeepSORT', + data_preprocessor=dict( + type='TrackDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32), + detector=detector, + reid=dict( + type='BaseReID', + data_preprocessor=dict(type='mmpretrain.ClsDataPreprocessor'), + backbone=dict( + type='mmpretrain.ResNet', + depth=50, + num_stages=4, + out_indices=(3, ), + style='pytorch'), + neck=dict(type='GlobalAveragePooling', kernel_size=(8, 4), stride=1), + head=dict( + type='LinearReIDHead', + num_fcs=1, + in_channels=2048, + fc_channels=1024, + out_channels=128, + num_classes=380, + loss_cls=dict(type='mmpretrain.CrossEntropyLoss', loss_weight=1.0), + loss_triplet=dict(type='TripletLoss', margin=0.3, loss_weight=1.0), + norm_cfg=dict(type='BN1d'), + act_cfg=dict(type='ReLU')), + init_cfg=dict( + type='Pretrained', + checkpoint= # noqa: E251 + 'https://download.openmmlab.com/mmtracking/mot/reid/tracktor_reid_r50_iter25245-a452f51f.pth' # noqa: E501 + )), + tracker=dict( + type='SORTTracker', + motion=dict(type='KalmanFilter', center_only=False), + obj_score_thr=0.5, + reid=dict( + num_samples=10, + img_scale=(256, 128), + img_norm_cfg=None, + match_score_thr=2.0), + match_iou_thr=0.5, + momentums=None, + num_tentatives=2, + num_frames_retain=100)) + +train_dataloader = None + +train_cfg = None +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') diff --git a/mmdetection/configs/deepsort/deepsort_faster-rcnn_r50_fpn_8xb2-4e_mot17train_test-mot17test.py b/mmdetection/configs/deepsort/deepsort_faster-rcnn_r50_fpn_8xb2-4e_mot17train_test-mot17test.py new file mode 100644 index 00000000..687ce7ad --- /dev/null +++ b/mmdetection/configs/deepsort/deepsort_faster-rcnn_r50_fpn_8xb2-4e_mot17train_test-mot17test.py @@ -0,0 +1,15 @@ +_base_ = [ + './deepsort_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain' + '_test-mot17halfval.py' +] + +# dataloader +val_dataloader = dict( + dataset=dict(ann_file='annotations/train_cocoformat.json')) +test_dataloader = dict( + dataset=dict( + ann_file='annotations/test_cocoformat.json', + data_prefix=dict(img_path='test'))) + +# evaluator +test_evaluator = dict(format_only=True, outfile_prefix='./mot_17_test_res') diff --git a/mmdetection/configs/deepsort/metafile.yml b/mmdetection/configs/deepsort/metafile.yml new file mode 100644 index 00000000..2feb358e --- /dev/null +++ b/mmdetection/configs/deepsort/metafile.yml @@ -0,0 +1,37 @@ +Collections: + - Name: DeepSORT + Metadata: + Training Techniques: + - SGD with Momentum + Training Resources: 8x V100 GPUs + Architecture: + - ResNet + - FPN + Paper: + URL: https://arxiv.org/abs/1703.07402 + Title: Simple Online and Realtime Tracking with a Deep Association Metric + README: configs/deepsort/README.md + +Models: + - Name: deepsort_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval + In Collection: DeepSORT + Config: configs/deepsort/deepsort_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py + Metadata: + Training Data: MOT17-half-train + inference time (ms/im): + - value: 72.5 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (640, 1088) + Results: + - Task: Multiple Object Tracking + Dataset: MOT17-half-val + Metrics: + MOTA: 63.7 + IDF1: 69.5 + HOTA: 57.0 + Weights: + - https://download.openmmlab.com/mmtracking/mot/faster_rcnn/faster-rcnn_r50_fpn_4e_mot17-half-64ee2ed4.pth + - https://download.openmmlab.com/mmtracking/mot/reid/tracktor_reid_r50_iter25245-a452f51f.pth diff --git a/mmdetection/configs/deformable_detr/README.md b/mmdetection/configs/deformable_detr/README.md new file mode 100644 index 00000000..ca897cdb --- /dev/null +++ b/mmdetection/configs/deformable_detr/README.md @@ -0,0 +1,41 @@ +# Deformable DETR + +> [Deformable DETR: Deformable Transformers for End-to-End Object Detection](https://arxiv.org/abs/2010.04159) + + + +## Abstract + +DETR has been recently proposed to eliminate the need for many hand-designed components in object detection while demonstrating good performance. However, it suffers from slow convergence and limited feature spatial resolution, due to the limitation of Transformer attention modules in processing image feature maps. To mitigate these issues, we proposed Deformable DETR, whose attention modules only attend to a small set of key sampling points around a reference. Deformable DETR can achieve better performance than DETR (especially on small objects) with 10 times less training epochs. Extensive experiments on the COCO benchmark demonstrate the effectiveness of our approach. + +
    + +
    + +## Results and Models + +| Backbone | Model | Lr schd | box AP | Config | Download | +| :------: | :---------------------------------: | :-----: | :----: | :---------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | Deformable DETR | 50e | 44.3 | [config](./deformable-detr_r50_16xb2-50e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/deformable_detr/deformable-detr_r50_16xb2-50e_coco/deformable-detr_r50_16xb2-50e_coco_20221029_210934-6bc7d21b.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/deformable_detr/deformable-detr_r50_16xb2-50e_coco/deformable-detr_r50_16xb2-50e_coco_20221029_210934.log.json) | +| R-50 | + iterative bounding box refinement | 50e | 46.2 | [config](./deformable-detr-refine_r50_16xb2-50e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/deformable_detr/deformable-detr-refine_r50_16xb2-50e_coco/deformable-detr-refine_r50_16xb2-50e_coco_20221022_225303-844e0f93.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/deformable_detr/deformable-detr-refine_r50_16xb2-50e_coco/deformable-detr-refine_r50_16xb2-50e_coco_20221022_225303.log.json) | +| R-50 | ++ two-stage Deformable DETR | 50e | 47.0 | [config](./deformable-detr-refine-twostage_r50_16xb2-50e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/deformable_detr/deformable-detr-refine-twostage_r50_16xb2-50e_coco/deformable-detr-refine-twostage_r50_16xb2-50e_coco_20221021_184714-acc8a5ff.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/deformable_detr/deformable-detr-refine-twostage_r50_16xb2-50e_coco/deformable-detr-refine-twostage_r50_16xb2-50e_coco_20221021_184714.log.json) | + +### NOTE + +1. All models are trained with batch size 32. +2. The performance is unstable. `Deformable DETR` and `iterative bounding box refinement` may fluctuate about 0.3 mAP. `two-stage Deformable DETR` may fluctuate about 0.2 mAP. + +## Citation + +We provide the config files for Deformable DETR: [Deformable DETR: Deformable Transformers for End-to-End Object Detection](https://arxiv.org/abs/2010.04159). + +```latex +@inproceedings{ +zhu2021deformable, +title={Deformable DETR: Deformable Transformers for End-to-End Object Detection}, +author={Xizhou Zhu and Weijie Su and Lewei Lu and Bin Li and Xiaogang Wang and Jifeng Dai}, +booktitle={International Conference on Learning Representations}, +year={2021}, +url={https://openreview.net/forum?id=gZ9hCDWe6ke} +} +``` diff --git a/mmdetection/configs/deformable_detr/deformable-detr-refine-twostage_r50_16xb2-50e_coco.py b/mmdetection/configs/deformable_detr/deformable-detr-refine-twostage_r50_16xb2-50e_coco.py new file mode 100644 index 00000000..eeb67fc9 --- /dev/null +++ b/mmdetection/configs/deformable_detr/deformable-detr-refine-twostage_r50_16xb2-50e_coco.py @@ -0,0 +1,2 @@ +_base_ = 'deformable-detr-refine_r50_16xb2-50e_coco.py' +model = dict(as_two_stage=True) diff --git a/mmdetection/configs/deformable_detr/deformable-detr-refine_r50_16xb2-50e_coco.py b/mmdetection/configs/deformable_detr/deformable-detr-refine_r50_16xb2-50e_coco.py new file mode 100644 index 00000000..b968674f --- /dev/null +++ b/mmdetection/configs/deformable_detr/deformable-detr-refine_r50_16xb2-50e_coco.py @@ -0,0 +1,2 @@ +_base_ = 'deformable-detr_r50_16xb2-50e_coco.py' +model = dict(with_box_refine=True) diff --git a/mmdetection/configs/deformable_detr/deformable-detr_r50_16xb2-50e_coco.py b/mmdetection/configs/deformable_detr/deformable-detr_r50_16xb2-50e_coco.py new file mode 100644 index 00000000..e0dee411 --- /dev/null +++ b/mmdetection/configs/deformable_detr/deformable-detr_r50_16xb2-50e_coco.py @@ -0,0 +1,156 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', '../_base_/default_runtime.py' +] +model = dict( + type='DeformableDETR', + num_queries=300, + num_feature_levels=4, + with_box_refine=False, + as_two_stage=False, + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=1), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=False), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='ChannelMapper', + in_channels=[512, 1024, 2048], + kernel_size=1, + out_channels=256, + act_cfg=None, + norm_cfg=dict(type='GN', num_groups=32), + num_outs=4), + encoder=dict( # DeformableDetrTransformerEncoder + num_layers=6, + layer_cfg=dict( # DeformableDetrTransformerEncoderLayer + self_attn_cfg=dict( # MultiScaleDeformableAttention + embed_dims=256, + batch_first=True), + ffn_cfg=dict( + embed_dims=256, feedforward_channels=1024, ffn_drop=0.1))), + decoder=dict( # DeformableDetrTransformerDecoder + num_layers=6, + return_intermediate=True, + layer_cfg=dict( # DeformableDetrTransformerDecoderLayer + self_attn_cfg=dict( # MultiheadAttention + embed_dims=256, + num_heads=8, + dropout=0.1, + batch_first=True), + cross_attn_cfg=dict( # MultiScaleDeformableAttention + embed_dims=256, + batch_first=True), + ffn_cfg=dict( + embed_dims=256, feedforward_channels=1024, ffn_drop=0.1)), + post_norm_cfg=None), + positional_encoding=dict(num_feats=128, normalize=True, offset=-0.5), + bbox_head=dict( + type='DeformableDETRHead', + num_classes=80, + sync_cls_avg_factor=True, + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=2.0), + loss_bbox=dict(type='L1Loss', loss_weight=5.0), + loss_iou=dict(type='GIoULoss', loss_weight=2.0)), + # training and testing settings + train_cfg=dict( + assigner=dict( + type='HungarianAssigner', + match_costs=[ + dict(type='FocalLossCost', weight=2.0), + dict(type='BBoxL1Cost', weight=5.0, box_format='xywh'), + dict(type='IoUCost', iou_mode='giou', weight=2.0) + ])), + test_cfg=dict(max_per_img=100)) + +# train_pipeline, NOTE the img_scale and the Pad's size_divisor is different +# from the default setting in mmdet. +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='PackDetInputs') +] +train_dataloader = dict( + dataset=dict( + filter_cfg=dict(filter_empty_gt=False), pipeline=train_pipeline)) + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.0002, weight_decay=0.0001), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict( + custom_keys={ + 'backbone': dict(lr_mult=0.1), + 'sampling_offsets': dict(lr_mult=0.1), + 'reference_points': dict(lr_mult=0.1) + })) + +# learning policy +max_epochs = 50 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[40], + gamma=0.1) +] + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (16 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=32) diff --git a/mmdetection/configs/deformable_detr/metafile.yml b/mmdetection/configs/deformable_detr/metafile.yml new file mode 100644 index 00000000..a30c9791 --- /dev/null +++ b/mmdetection/configs/deformable_detr/metafile.yml @@ -0,0 +1,56 @@ +Collections: + - Name: Deformable DETR + Metadata: + Training Data: COCO + Training Techniques: + - AdamW + - Multi Scale Train + - Gradient Clip + Training Resources: 8x V100 GPUs + Architecture: + - ResNet + - Transformer + Paper: + URL: https://openreview.net/forum?id=gZ9hCDWe6ke + Title: 'Deformable DETR: Deformable Transformers for End-to-End Object Detection' + README: configs/deformable_detr/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.12.0/mmdet/models/detectors/deformable_detr.py#L6 + Version: v2.12.0 + +Models: + - Name: deformable-detr_r50_16xb2-50e_coco + In Collection: Deformable DETR + Config: configs/deformable_detr/deformable-detr_r50_16xb2-50e_coco.py + Metadata: + Epochs: 50 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.3 + Weights: https://download.openmmlab.com/mmdetection/v3.0/deformable_detr/deformable-detr_r50_16xb2-50e_coco/deformable-detr_r50_16xb2-50e_coco_20221029_210934-6bc7d21b.pth + + - Name: deformable-detr-refine_r50_16xb2-50e_coco + In Collection: Deformable DETR + Config: configs/deformable_detr/deformable-detr-refine_r50_16xb2-50e_coco.py + Metadata: + Epochs: 50 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.2 + Weights: https://download.openmmlab.com/mmdetection/v3.0/deformable_detr/deformable-detr-refine_r50_16xb2-50e_coco/deformable-detr-refine_r50_16xb2-50e_coco_20221022_225303-844e0f93.pth + + - Name: deformable-detr-refine-twostage_r50_16xb2-50e_coco + In Collection: Deformable DETR + Config: configs/deformable_detr/deformable-detr-refine-twostage_r50_16xb2-50e_coco.py + Metadata: + Epochs: 50 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 47.0 + Weights: https://download.openmmlab.com/mmdetection/v3.0/deformable_detr/deformable-detr-refine-twostage_r50_16xb2-50e_coco/deformable-detr-refine-twostage_r50_16xb2-50e_coco_20221021_184714-acc8a5ff.pth diff --git a/mmdetection/configs/detectors/README.md b/mmdetection/configs/detectors/README.md new file mode 100644 index 00000000..2918d6e4 --- /dev/null +++ b/mmdetection/configs/detectors/README.md @@ -0,0 +1,69 @@ +# DetectoRS + +> [DetectoRS: Detecting Objects with Recursive Feature Pyramid and Switchable Atrous Convolution](https://arxiv.org/abs/2006.02334) + + + +## Abstract + +Many modern object detectors demonstrate outstanding performances by using the mechanism of looking and thinking twice. In this paper, we explore this mechanism in the backbone design for object detection. At the macro level, we propose Recursive Feature Pyramid, which incorporates extra feedback connections from Feature Pyramid Networks into the bottom-up backbone layers. At the micro level, we propose Switchable Atrous Convolution, which convolves the features with different atrous rates and gathers the results using switch functions. Combining them results in DetectoRS, which significantly improves the performances of object detection. On COCO test-dev, DetectoRS achieves state-of-the-art 55.7% box AP for object detection, 48.5% mask AP for instance segmentation, and 50.0% PQ for panoptic segmentation. + +
    + +
    + +## Introduction + +DetectoRS requires COCO and [COCO-stuff](http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/stuffthingmaps_trainval2017.zip) dataset for training. You need to download and extract it in the COCO dataset path. +The directory should be like this. + +```none +mmdetection +├── mmdet +├── tools +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ ├── train2017 +│ │ ├── val2017 +│ │ ├── test2017 +| | ├── stuffthingmaps +``` + +## Results and Models + +DetectoRS includes two major components: + +- Recursive Feature Pyramid (RFP). +- Switchable Atrous Convolution (SAC). + +They can be used independently. +Combining them together results in DetectoRS. +The results on COCO 2017 val are shown in the below table. + +| Method | Detector | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :-------: | :-----------------: | :-----: | :------: | :------------: | :----: | :-----: | :-----------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| RFP | Cascade + ResNet-50 | 1x | 7.5 | - | 44.8 | | [config](./cascade-rcnn_r50-rfp_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/detectors/cascade_rcnn_r50_rfp_1x_coco/cascade_rcnn_r50_rfp_1x_coco-8cf51bfd.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/detectors/cascade_rcnn_r50_rfp_1x_coco/cascade_rcnn_r50_rfp_1x_coco_20200624_104126.log.json) | +| SAC | Cascade + ResNet-50 | 1x | 5.6 | - | 45.0 | | [config](./cascade-rcnn_r50-sac_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/detectors/cascade_rcnn_r50_sac_1x_coco/cascade_rcnn_r50_sac_1x_coco-24bfda62.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/detectors/cascade_rcnn_r50_sac_1x_coco/cascade_rcnn_r50_sac_1x_coco_20200624_104402.log.json) | +| DetectoRS | Cascade + ResNet-50 | 1x | 9.9 | - | 47.4 | | [config](./detectors_cascade-rcnn_r50_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/detectors/detectors_cascade_rcnn_r50_1x_coco/detectors_cascade_rcnn_r50_1x_coco-32a10ba0.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/detectors/detectors_cascade_rcnn_r50_1x_coco/detectors_cascade_rcnn_r50_1x_coco_20200706_001203.log.json) | +| RFP | HTC + ResNet-50 | 1x | 11.2 | - | 46.6 | 40.9 | [config](./htc_r50-rfp_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/detectors/htc_r50_rfp_1x_coco/htc_r50_rfp_1x_coco-8ff87c51.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/detectors/htc_r50_rfp_1x_coco/htc_r50_rfp_1x_coco_20200624_103053.log.json) | +| SAC | HTC + ResNet-50 | 1x | 9.3 | - | 46.4 | 40.9 | [config](./htc_r50-sac_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/detectors/htc_r50_sac_1x_coco/htc_r50_sac_1x_coco-bfa60c54.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/detectors/htc_r50_sac_1x_coco/htc_r50_sac_1x_coco_20200624_103111.log.json) | +| DetectoRS | HTC + ResNet-50 | 1x | 13.6 | - | 49.1 | 42.6 | [config](./detectors_htc-r50_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/detectors/detectors_htc_r50_1x_coco/detectors_htc_r50_1x_coco-329b1453.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/detectors/detectors_htc_r50_1x_coco/detectors_htc_r50_1x_coco_20200624_103659.log.json) | +| DetectoRS | HTC + ResNet-101 | 20e | 19.6 | | 50.5 | 43.9 | [config](./detectors_htc-r101_20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/detectors/detectors_htc_r101_20e_coco/detectors_htc_r101_20e_coco_20210419_203638-348d533b.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/detectors/detectors_htc_r101_20e_coco/detectors_htc_r101_20e_coco_20210419_203638.log.json) | + +*Note*: This is a re-implementation based on MMDetection-V2. +The original implementation is based on MMDetection-V1. + +## Citation + +We provide the config files for [DetectoRS: Detecting Objects with Recursive Feature Pyramid and Switchable Atrous Convolution](https://arxiv.org/pdf/2006.02334.pdf). + +```latex +@article{qiao2020detectors, + title={DetectoRS: Detecting Objects with Recursive Feature Pyramid and Switchable Atrous Convolution}, + author={Qiao, Siyuan and Chen, Liang-Chieh and Yuille, Alan}, + journal={arXiv preprint arXiv:2006.02334}, + year={2020} +} +``` diff --git a/mmdetection/configs/detectors/cascade-rcnn_r50-rfp_1x_coco.py b/mmdetection/configs/detectors/cascade-rcnn_r50-rfp_1x_coco.py new file mode 100644 index 00000000..c30c84d7 --- /dev/null +++ b/mmdetection/configs/detectors/cascade-rcnn_r50-rfp_1x_coco.py @@ -0,0 +1,28 @@ +_base_ = [ + '../_base_/models/cascade-rcnn_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +model = dict( + backbone=dict( + type='DetectoRS_ResNet', + conv_cfg=dict(type='ConvAWS'), + output_img=True), + neck=dict( + type='RFP', + rfp_steps=2, + aspp_out_channels=64, + aspp_dilations=(1, 3, 6, 1), + rfp_backbone=dict( + rfp_inplanes=256, + type='DetectoRS_ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + conv_cfg=dict(type='ConvAWS'), + pretrained='torchvision://resnet50', + style='pytorch'))) diff --git a/mmdetection/configs/detectors/cascade-rcnn_r50-sac_1x_coco.py b/mmdetection/configs/detectors/cascade-rcnn_r50-sac_1x_coco.py new file mode 100644 index 00000000..24d6cd3a --- /dev/null +++ b/mmdetection/configs/detectors/cascade-rcnn_r50-sac_1x_coco.py @@ -0,0 +1,12 @@ +_base_ = [ + '../_base_/models/cascade-rcnn_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +model = dict( + backbone=dict( + type='DetectoRS_ResNet', + conv_cfg=dict(type='ConvAWS'), + sac=dict(type='SAC', use_deform=True), + stage_with_sac=(False, True, True, True))) diff --git a/mmdetection/configs/detectors/detectors_cascade-rcnn_r50_1x_coco.py b/mmdetection/configs/detectors/detectors_cascade-rcnn_r50_1x_coco.py new file mode 100644 index 00000000..19d13d9c --- /dev/null +++ b/mmdetection/configs/detectors/detectors_cascade-rcnn_r50_1x_coco.py @@ -0,0 +1,32 @@ +_base_ = [ + '../_base_/models/cascade-rcnn_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +model = dict( + backbone=dict( + type='DetectoRS_ResNet', + conv_cfg=dict(type='ConvAWS'), + sac=dict(type='SAC', use_deform=True), + stage_with_sac=(False, True, True, True), + output_img=True), + neck=dict( + type='RFP', + rfp_steps=2, + aspp_out_channels=64, + aspp_dilations=(1, 3, 6, 1), + rfp_backbone=dict( + rfp_inplanes=256, + type='DetectoRS_ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + conv_cfg=dict(type='ConvAWS'), + sac=dict(type='SAC', use_deform=True), + stage_with_sac=(False, True, True, True), + pretrained='torchvision://resnet50', + style='pytorch'))) diff --git a/mmdetection/configs/detectors/detectors_htc-r101_20e_coco.py b/mmdetection/configs/detectors/detectors_htc-r101_20e_coco.py new file mode 100644 index 00000000..93d7d2b1 --- /dev/null +++ b/mmdetection/configs/detectors/detectors_htc-r101_20e_coco.py @@ -0,0 +1,28 @@ +_base_ = '../htc/htc_r101_fpn_20e_coco.py' + +model = dict( + backbone=dict( + type='DetectoRS_ResNet', + conv_cfg=dict(type='ConvAWS'), + sac=dict(type='SAC', use_deform=True), + stage_with_sac=(False, True, True, True), + output_img=True), + neck=dict( + type='RFP', + rfp_steps=2, + aspp_out_channels=64, + aspp_dilations=(1, 3, 6, 1), + rfp_backbone=dict( + rfp_inplanes=256, + type='DetectoRS_ResNet', + depth=101, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + conv_cfg=dict(type='ConvAWS'), + sac=dict(type='SAC', use_deform=True), + stage_with_sac=(False, True, True, True), + pretrained='torchvision://resnet101', + style='pytorch'))) diff --git a/mmdetection/configs/detectors/detectors_htc-r50_1x_coco.py b/mmdetection/configs/detectors/detectors_htc-r50_1x_coco.py new file mode 100644 index 00000000..0d2fc4f7 --- /dev/null +++ b/mmdetection/configs/detectors/detectors_htc-r50_1x_coco.py @@ -0,0 +1,28 @@ +_base_ = '../htc/htc_r50_fpn_1x_coco.py' + +model = dict( + backbone=dict( + type='DetectoRS_ResNet', + conv_cfg=dict(type='ConvAWS'), + sac=dict(type='SAC', use_deform=True), + stage_with_sac=(False, True, True, True), + output_img=True), + neck=dict( + type='RFP', + rfp_steps=2, + aspp_out_channels=64, + aspp_dilations=(1, 3, 6, 1), + rfp_backbone=dict( + rfp_inplanes=256, + type='DetectoRS_ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + conv_cfg=dict(type='ConvAWS'), + sac=dict(type='SAC', use_deform=True), + stage_with_sac=(False, True, True, True), + pretrained='torchvision://resnet50', + style='pytorch'))) diff --git a/mmdetection/configs/detectors/htc_r50-rfp_1x_coco.py b/mmdetection/configs/detectors/htc_r50-rfp_1x_coco.py new file mode 100644 index 00000000..496104e1 --- /dev/null +++ b/mmdetection/configs/detectors/htc_r50-rfp_1x_coco.py @@ -0,0 +1,24 @@ +_base_ = '../htc/htc_r50_fpn_1x_coco.py' + +model = dict( + backbone=dict( + type='DetectoRS_ResNet', + conv_cfg=dict(type='ConvAWS'), + output_img=True), + neck=dict( + type='RFP', + rfp_steps=2, + aspp_out_channels=64, + aspp_dilations=(1, 3, 6, 1), + rfp_backbone=dict( + rfp_inplanes=256, + type='DetectoRS_ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + conv_cfg=dict(type='ConvAWS'), + pretrained='torchvision://resnet50', + style='pytorch'))) diff --git a/mmdetection/configs/detectors/htc_r50-sac_1x_coco.py b/mmdetection/configs/detectors/htc_r50-sac_1x_coco.py new file mode 100644 index 00000000..72d4db96 --- /dev/null +++ b/mmdetection/configs/detectors/htc_r50-sac_1x_coco.py @@ -0,0 +1,8 @@ +_base_ = '../htc/htc_r50_fpn_1x_coco.py' + +model = dict( + backbone=dict( + type='DetectoRS_ResNet', + conv_cfg=dict(type='ConvAWS'), + sac=dict(type='SAC', use_deform=True), + stage_with_sac=(False, True, True, True))) diff --git a/mmdetection/configs/detectors/metafile.yml b/mmdetection/configs/detectors/metafile.yml new file mode 100644 index 00000000..196a1cef --- /dev/null +++ b/mmdetection/configs/detectors/metafile.yml @@ -0,0 +1,114 @@ +Collections: + - Name: DetectoRS + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - ASPP + - FPN + - RFP + - RPN + - ResNet + - RoIAlign + - SAC + Paper: + URL: https://arxiv.org/abs/2006.02334 + Title: 'DetectoRS: Detecting Objects with Recursive Feature Pyramid and Switchable Atrous Convolution' + README: configs/detectors/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.2.0/mmdet/models/backbones/detectors_resnet.py#L205 + Version: v2.2.0 + +Models: + - Name: cascade-rcnn_r50-rfp_1x_coco + In Collection: DetectoRS + Config: configs/detectors/cascade-rcnn_r50-rfp_1x_coco.py + Metadata: + Training Memory (GB): 7.5 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/detectors/cascade_rcnn_r50_rfp_1x_coco/cascade_rcnn_r50_rfp_1x_coco-8cf51bfd.pth + + - Name: cascade-rcnn_r50-sac_1x_coco + In Collection: DetectoRS + Config: configs/detectors/cascade-rcnn_r50-sac_1x_coco.py + Metadata: + Training Memory (GB): 5.6 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/detectors/cascade_rcnn_r50_sac_1x_coco/cascade_rcnn_r50_sac_1x_coco-24bfda62.pth + + - Name: detectors_cascade-rcnn_r50_1x_coco + In Collection: DetectoRS + Config: configs/detectors/detectors_cascade-rcnn_r50_1x_coco.py + Metadata: + Training Memory (GB): 9.9 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 47.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/detectors/detectors_cascade_rcnn_r50_1x_coco/detectors_cascade_rcnn_r50_1x_coco-32a10ba0.pth + + - Name: htc_r50-rfp_1x_coco + In Collection: DetectoRS + Config: configs/detectors/htc_r50-rfp_1x_coco.py + Metadata: + Training Memory (GB): 11.2 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.6 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 40.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/detectors/htc_r50_rfp_1x_coco/htc_r50_rfp_1x_coco-8ff87c51.pth + + - Name: htc_r50-sac_1x_coco + In Collection: DetectoRS + Config: configs/detectors/htc_r50-sac_1x_coco.py + Metadata: + Training Memory (GB): 9.3 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.4 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 40.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/detectors/htc_r50_sac_1x_coco/htc_r50_sac_1x_coco-bfa60c54.pth + + - Name: detectors_htc-r50_1x_coco + In Collection: DetectoRS + Config: configs/detectors/detectors_htc-r50_1x_coco.py + Metadata: + Training Memory (GB): 13.6 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 49.1 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 42.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/detectors/detectors_htc_r50_1x_coco/detectors_htc_r50_1x_coco-329b1453.pth diff --git a/mmdetection/configs/detr/README.md b/mmdetection/configs/detr/README.md new file mode 100644 index 00000000..8e843f36 --- /dev/null +++ b/mmdetection/configs/detr/README.md @@ -0,0 +1,37 @@ +# DETR + +> [End-to-End Object Detection with Transformers](https://arxiv.org/abs/2005.12872) + + + +## Abstract + +We present a new method that views object detection as a direct set prediction problem. Our approach streamlines the detection pipeline, effectively removing the need for many hand-designed components like a non-maximum suppression procedure or anchor generation that explicitly encode our prior knowledge about the task. The main ingredients of the new framework, called DEtection TRansformer or DETR, are a set-based global loss that forces unique predictions via bipartite matching, and a transformer encoder-decoder architecture. Given a fixed small set of learned object queries, DETR reasons about the relations of the objects and the global image context to directly output the final set of predictions in parallel. The new model is conceptually simple and does not require a specialized library, unlike many other modern detectors. DETR demonstrates accuracy and run-time performance on par with the well-established and highly-optimized Faster RCNN baseline on the challenging COCO object detection dataset. Moreover, DETR can be easily generalized to produce panoptic segmentation in a unified manner. We show that it significantly outperforms competitive baselines. + +
    + +
    + +## Results and Models + +| Backbone | Model | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :------: | :---: | :-----: | :------: | :------------: | :----: | :------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | DETR | 150e | 7.9 | | 39.9 | [config](./detr_r50_8xb2-150e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/detr/detr_r50_8xb2-150e_coco/detr_r50_8xb2-150e_coco_20221023_153551-436d03e8.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/detr/detr_r50_8xb2-150e_coco/detr_r50_8xb2-150e_coco_20221023_153551.log.json) | + +## Citation + +We provide the config files for DETR: [End-to-End Object Detection with Transformers](https://arxiv.org/abs/2005.12872). + +```latex +@inproceedings{detr, + author = {Nicolas Carion and + Francisco Massa and + Gabriel Synnaeve and + Nicolas Usunier and + Alexander Kirillov and + Sergey Zagoruyko}, + title = {End-to-End Object Detection with Transformers}, + booktitle = {ECCV}, + year = {2020} +} +``` diff --git a/mmdetection/configs/detr/detr_r101_8xb2-500e_coco.py b/mmdetection/configs/detr/detr_r101_8xb2-500e_coco.py new file mode 100644 index 00000000..6661aacd --- /dev/null +++ b/mmdetection/configs/detr/detr_r101_8xb2-500e_coco.py @@ -0,0 +1,7 @@ +_base_ = './detr_r50_8xb2-500e_coco.py' + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/detr/detr_r18_8xb2-500e_coco.py b/mmdetection/configs/detr/detr_r18_8xb2-500e_coco.py new file mode 100644 index 00000000..305b9d6f --- /dev/null +++ b/mmdetection/configs/detr/detr_r18_8xb2-500e_coco.py @@ -0,0 +1,7 @@ +_base_ = './detr_r50_8xb2-500e_coco.py' + +model = dict( + backbone=dict( + depth=18, + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet18')), + neck=dict(in_channels=[512])) diff --git a/mmdetection/configs/detr/detr_r50_8xb2-150e_coco.py b/mmdetection/configs/detr/detr_r50_8xb2-150e_coco.py new file mode 100644 index 00000000..aaa15410 --- /dev/null +++ b/mmdetection/configs/detr/detr_r50_8xb2-150e_coco.py @@ -0,0 +1,155 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', '../_base_/default_runtime.py' +] +model = dict( + type='DETR', + num_queries=100, + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=1), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(3, ), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=False), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='ChannelMapper', + in_channels=[2048], + kernel_size=1, + out_channels=256, + act_cfg=None, + norm_cfg=None, + num_outs=1), + encoder=dict( # DetrTransformerEncoder + num_layers=6, + layer_cfg=dict( # DetrTransformerEncoderLayer + self_attn_cfg=dict( # MultiheadAttention + embed_dims=256, + num_heads=8, + dropout=0.1, + batch_first=True), + ffn_cfg=dict( + embed_dims=256, + feedforward_channels=2048, + num_fcs=2, + ffn_drop=0.1, + act_cfg=dict(type='ReLU', inplace=True)))), + decoder=dict( # DetrTransformerDecoder + num_layers=6, + layer_cfg=dict( # DetrTransformerDecoderLayer + self_attn_cfg=dict( # MultiheadAttention + embed_dims=256, + num_heads=8, + dropout=0.1, + batch_first=True), + cross_attn_cfg=dict( # MultiheadAttention + embed_dims=256, + num_heads=8, + dropout=0.1, + batch_first=True), + ffn_cfg=dict( + embed_dims=256, + feedforward_channels=2048, + num_fcs=2, + ffn_drop=0.1, + act_cfg=dict(type='ReLU', inplace=True))), + return_intermediate=True), + positional_encoding=dict(num_feats=128, normalize=True), + bbox_head=dict( + type='DETRHead', + num_classes=80, + embed_dims=256, + loss_cls=dict( + type='CrossEntropyLoss', + bg_cls_weight=0.1, + use_sigmoid=False, + loss_weight=1.0, + class_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=5.0), + loss_iou=dict(type='GIoULoss', loss_weight=2.0)), + # training and testing settings + train_cfg=dict( + assigner=dict( + type='HungarianAssigner', + match_costs=[ + dict(type='ClassificationCost', weight=1.), + dict(type='BBoxL1Cost', weight=5.0, box_format='xywh'), + dict(type='IoUCost', iou_mode='giou', weight=2.0) + ])), + test_cfg=dict(max_per_img=100)) + +# train_pipeline, NOTE the img_scale and the Pad's size_divisor is different +# from the default setting in mmdet. +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[[ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + scales=[(400, 1333), (500, 1333), (600, 1333)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), + (576, 1333), (608, 1333), (640, 1333), + (672, 1333), (704, 1333), (736, 1333), + (768, 1333), (800, 1333)], + keep_ratio=True) + ]]), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0001), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict( + custom_keys={'backbone': dict(lr_mult=0.1, decay_mult=1.0)})) + +# learning policy +max_epochs = 150 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[100], + gamma=0.1) +] + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=16) diff --git a/mmdetection/configs/detr/detr_r50_8xb2-500e_coco.py b/mmdetection/configs/detr/detr_r50_8xb2-500e_coco.py new file mode 100644 index 00000000..f07d5dce --- /dev/null +++ b/mmdetection/configs/detr/detr_r50_8xb2-500e_coco.py @@ -0,0 +1,24 @@ +_base_ = './detr_r50_8xb2-150e_coco.py' + +# learning policy +max_epochs = 500 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=10) + +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[334], + gamma=0.1) +] + +# only keep latest 2 checkpoints +default_hooks = dict(checkpoint=dict(max_keep_ckpts=2)) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=16) diff --git a/mmdetection/configs/detr/metafile.yml b/mmdetection/configs/detr/metafile.yml new file mode 100644 index 00000000..a9132dff --- /dev/null +++ b/mmdetection/configs/detr/metafile.yml @@ -0,0 +1,33 @@ +Collections: + - Name: DETR + Metadata: + Training Data: COCO + Training Techniques: + - AdamW + - Multi Scale Train + - Gradient Clip + Training Resources: 8x V100 GPUs + Architecture: + - ResNet + - Transformer + Paper: + URL: https://arxiv.org/abs/2005.12872 + Title: 'End-to-End Object Detection with Transformers' + README: configs/detr/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.7.0/mmdet/models/detectors/detr.py#L7 + Version: v2.7.0 + +Models: + - Name: detr_r50_8xb2-150e_coco + In Collection: DETR + Config: configs/detr/detr_r50_8xb2-150e_coco.py + Metadata: + Training Memory (GB): 7.9 + Epochs: 150 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.9 + Weights: https://download.openmmlab.com/mmdetection/v3.0/detr/detr_r50_8xb2-150e_coco/detr_r50_8xb2-150e_coco_20221023_153551-436d03e8.pth diff --git a/mmdetection/configs/dino/README.md b/mmdetection/configs/dino/README.md new file mode 100644 index 00000000..d8a01bde --- /dev/null +++ b/mmdetection/configs/dino/README.md @@ -0,0 +1,40 @@ +# DINO + +> [DINO: DETR with Improved DeNoising Anchor Boxes for End-to-End Object Detection](https://arxiv.org/abs/2203.03605) + + + +## Abstract + +We present DINO (DETR with Improved deNoising anchOr boxes), a state-of-the-art end-to-end object detector. DINO improves over previous DETR-like models in performance and efficiency by using a contrastive way for denoising training, a mixed query selection method for anchor initialization, and a look forward twice scheme for box prediction. DINO achieves 49.4AP in 12 epochs and 51.3AP in 24 epochs on COCO with a ResNet-50 backbone and multi-scale features, yielding a significant improvement of +6.0AP and +2.7AP, respectively, compared to DN-DETR, the previous best DETR-like model. DINO scales well in both model size and data size. Without bells and whistles, after pre-training on the Objects365 dataset with a SwinL backbone, DINO obtains the best results on both COCO val2017 (63.2AP) and test-dev (63.3AP). Compared to other models on the leaderboard, DINO significantly reduces its model size and pre-training data size while achieving better results. + +
    + +
    + +## Results and Models + +| Backbone | Model | Lr schd | Better-Hyper | box AP | Config | Download | +| :------: | :---------: | :-----: | :----------: | :----: | :---------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | DINO-4scale | 12e | False | 49.0 | [config](./dino-4scale_r50_8xb2-12e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/dino/dino-4scale_r50_8xb2-12e_coco/dino-4scale_r50_8xb2-12e_coco_20221202_182705-55b2bba2.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/dino/dino-4scale_r50_8xb2-12e_coco/dino-4scale_r50_8xb2-12e_coco_20221202_182705.log.json) | +| R-50 | DINO-4scale | 12e | True | 50.1 | [config](./dino-4scale_r50_improved_8xb2-12e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/dino/dino-4scale_r50_improved_8xb2-12e_coco/dino-4scale_r50_improved_8xb2-12e_coco_20230818_162607-6f47a913.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/dino/dino-4scale_r50_improved_8xb2-12e_coco/dino-4scale_r50_improved_8xb2-12e_coco_20230818_162607.log.json) | +| Swin-L | DINO-5scale | 12e | False | 57.2 | [config](./dino-5scale_swin-l_8xb2-12e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/dino/dino-5scale_swin-l_8xb2-12e_coco/dino-5scale_swin-l_8xb2-12e_coco_20230228_072924-a654145f.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/dino/dino-5scale_swin-l_8xb2-12e_coco/dino-5scale_swin-l_8xb2-12e_coco_20230228_072924.log) | +| Swin-L | DINO-5scale | 36e | False | 58.4 | [config](./dino-5scale_swin-l_8xb2-36e_coco.py) | [model](https://github.com/RistoranteRist/mmlab-weights/releases/download/dino-swinl/dino-5scale_swin-l_8xb2-36e_coco-5486e051.pth) \| [log](https://github.com/RistoranteRist/mmlab-weights/releases/download/dino-swinl/20230307_032359.log) | + +### NOTE + +The performance is unstable. `DINO-4scale` with `R-50` may fluctuate about 0.4 mAP. + +## Citation + +We provide the config files for DINO: [DINO: DETR with Improved DeNoising Anchor Boxes for End-to-End Object Detection](https://arxiv.org/abs/2203.03605). + +```latex +@misc{zhang2022dino, + title={DINO: DETR with Improved DeNoising Anchor Boxes for End-to-End Object Detection}, + author={Hao Zhang and Feng Li and Shilong Liu and Lei Zhang and Hang Su and Jun Zhu and Lionel M. Ni and Heung-Yeung Shum}, + year={2022}, + eprint={2203.03605}, + archivePrefix={arXiv}, + primaryClass={cs.CV}} +``` diff --git a/mmdetection/configs/dino/dino-4scale_r50_8xb2-12e_coco.py b/mmdetection/configs/dino/dino-4scale_r50_8xb2-12e_coco.py new file mode 100644 index 00000000..5831f898 --- /dev/null +++ b/mmdetection/configs/dino/dino-4scale_r50_8xb2-12e_coco.py @@ -0,0 +1,163 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', '../_base_/default_runtime.py' +] +model = dict( + type='DINO', + num_queries=900, # num_matching_queries + with_box_refine=True, + as_two_stage=True, + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=1), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=False), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='ChannelMapper', + in_channels=[512, 1024, 2048], + kernel_size=1, + out_channels=256, + act_cfg=None, + norm_cfg=dict(type='GN', num_groups=32), + num_outs=4), + encoder=dict( + num_layers=6, + layer_cfg=dict( + self_attn_cfg=dict(embed_dims=256, num_levels=4, + dropout=0.0), # 0.1 for DeformDETR + ffn_cfg=dict( + embed_dims=256, + feedforward_channels=2048, # 1024 for DeformDETR + ffn_drop=0.0))), # 0.1 for DeformDETR + decoder=dict( + num_layers=6, + return_intermediate=True, + layer_cfg=dict( + self_attn_cfg=dict(embed_dims=256, num_heads=8, + dropout=0.0), # 0.1 for DeformDETR + cross_attn_cfg=dict(embed_dims=256, num_levels=4, + dropout=0.0), # 0.1 for DeformDETR + ffn_cfg=dict( + embed_dims=256, + feedforward_channels=2048, # 1024 for DeformDETR + ffn_drop=0.0)), # 0.1 for DeformDETR + post_norm_cfg=None), + positional_encoding=dict( + num_feats=128, + normalize=True, + offset=0.0, # -0.5 for DeformDETR + temperature=20), # 10000 for DeformDETR + bbox_head=dict( + type='DINOHead', + num_classes=80, + sync_cls_avg_factor=True, + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), # 2.0 in DeformDETR + loss_bbox=dict(type='L1Loss', loss_weight=5.0), + loss_iou=dict(type='GIoULoss', loss_weight=2.0)), + dn_cfg=dict( # TODO: Move to model.train_cfg ? + label_noise_scale=0.5, + box_noise_scale=1.0, # 0.4 for DN-DETR + group_cfg=dict(dynamic=True, num_groups=None, + num_dn_queries=100)), # TODO: half num_dn_queries + # training and testing settings + train_cfg=dict( + assigner=dict( + type='HungarianAssigner', + match_costs=[ + dict(type='FocalLossCost', weight=2.0), + dict(type='BBoxL1Cost', weight=5.0, box_format='xywh'), + dict(type='IoUCost', iou_mode='giou', weight=2.0) + ])), + test_cfg=dict(max_per_img=300)) # 100 for DeformDETR + +# train_pipeline, NOTE the img_scale and the Pad's size_divisor is different +# from the default setting in mmdet. +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='PackDetInputs') +] +train_dataloader = dict( + dataset=dict( + filter_cfg=dict(filter_empty_gt=False), pipeline=train_pipeline)) + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict( + type='AdamW', + lr=0.0001, # 0.0002 for DeformDETR + weight_decay=0.0001), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict(custom_keys={'backbone': dict(lr_mult=0.1)}) +) # custom_keys contains sampling_offsets and reference_points in DeformDETR # noqa + +# learning policy +max_epochs = 12 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) + +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[11], + gamma=0.1) +] + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=16) diff --git a/mmdetection/configs/dino/dino-4scale_r50_8xb2-24e_coco.py b/mmdetection/configs/dino/dino-4scale_r50_8xb2-24e_coco.py new file mode 100644 index 00000000..8534ac6a --- /dev/null +++ b/mmdetection/configs/dino/dino-4scale_r50_8xb2-24e_coco.py @@ -0,0 +1,13 @@ +_base_ = './dino-4scale_r50_8xb2-12e_coco.py' +max_epochs = 24 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[20], + gamma=0.1) +] diff --git a/mmdetection/configs/dino/dino-4scale_r50_8xb2-36e_coco.py b/mmdetection/configs/dino/dino-4scale_r50_8xb2-36e_coco.py new file mode 100644 index 00000000..1c2cf460 --- /dev/null +++ b/mmdetection/configs/dino/dino-4scale_r50_8xb2-36e_coco.py @@ -0,0 +1,13 @@ +_base_ = './dino-4scale_r50_8xb2-12e_coco.py' +max_epochs = 36 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[30], + gamma=0.1) +] diff --git a/mmdetection/configs/dino/dino-4scale_r50_improved_8xb2-12e_coco.py b/mmdetection/configs/dino/dino-4scale_r50_improved_8xb2-12e_coco.py new file mode 100644 index 00000000..6a4a82ba --- /dev/null +++ b/mmdetection/configs/dino/dino-4scale_r50_improved_8xb2-12e_coco.py @@ -0,0 +1,18 @@ +_base_ = ['dino-4scale_r50_8xb2-12e_coco.py'] + +# from deformable detr hyper +model = dict( + backbone=dict(frozen_stages=-1), + bbox_head=dict(loss_cls=dict(loss_weight=2.0)), + positional_encoding=dict(offset=-0.5, temperature=10000), + dn_cfg=dict(group_cfg=dict(num_dn_queries=300))) + +# optimizer +optim_wrapper = dict( + optimizer=dict(lr=0.0002), + paramwise_cfg=dict( + custom_keys={ + 'backbone': dict(lr_mult=0.1), + 'sampling_offsets': dict(lr_mult=0.1), + 'reference_points': dict(lr_mult=0.1) + })) diff --git a/mmdetection/configs/dino/dino-5scale_swin-l_8xb2-12e_coco.py b/mmdetection/configs/dino/dino-5scale_swin-l_8xb2-12e_coco.py new file mode 100644 index 00000000..3d39f22f --- /dev/null +++ b/mmdetection/configs/dino/dino-5scale_swin-l_8xb2-12e_coco.py @@ -0,0 +1,30 @@ +_base_ = './dino-4scale_r50_8xb2-12e_coco.py' + +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_large_patch4_window12_384_22k.pth' # noqa +num_levels = 5 +model = dict( + num_feature_levels=num_levels, + backbone=dict( + _delete_=True, + type='SwinTransformer', + pretrain_img_size=384, + embed_dims=192, + depths=[2, 2, 18, 2], + num_heads=[6, 12, 24, 48], + window_size=12, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.2, + patch_norm=True, + out_indices=(0, 1, 2, 3), + # Please only add indices that would be used + # in FPN, otherwise some parameter will not be used + with_cp=True, + convert_weights=True, + init_cfg=dict(type='Pretrained', checkpoint=pretrained)), + neck=dict(in_channels=[192, 384, 768, 1536], num_outs=num_levels), + encoder=dict(layer_cfg=dict(self_attn_cfg=dict(num_levels=num_levels))), + decoder=dict(layer_cfg=dict(cross_attn_cfg=dict(num_levels=num_levels)))) diff --git a/mmdetection/configs/dino/dino-5scale_swin-l_8xb2-36e_coco.py b/mmdetection/configs/dino/dino-5scale_swin-l_8xb2-36e_coco.py new file mode 100644 index 00000000..d55a38e6 --- /dev/null +++ b/mmdetection/configs/dino/dino-5scale_swin-l_8xb2-36e_coco.py @@ -0,0 +1,13 @@ +_base_ = './dino-5scale_swin-l_8xb2-12e_coco.py' +max_epochs = 36 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[27, 33], + gamma=0.1) +] diff --git a/mmdetection/configs/dino/metafile.yml b/mmdetection/configs/dino/metafile.yml new file mode 100644 index 00000000..f276a04e --- /dev/null +++ b/mmdetection/configs/dino/metafile.yml @@ -0,0 +1,85 @@ +Collections: + - Name: DINO + Metadata: + Training Data: COCO + Training Techniques: + - AdamW + - Multi Scale Train + - Gradient Clip + Training Resources: 8x A100 GPUs + Architecture: + - ResNet + - Transformer + Paper: + URL: https://arxiv.org/abs/2203.03605 + Title: 'DINO: DETR with Improved DeNoising Anchor Boxes for End-to-End Object Detection' + README: configs/dino/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/f4112c9e5611468ffbd57cfba548fd1289264b52/mmdet/models/detectors/dino.py#L17 + Version: v3.0.0rc6 + +Models: + - Name: dino-4scale_r50_8xb2-12e_coco + In Collection: DINO + Config: configs/dino/dino-4scale_r50_8xb2-12e_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 49.0 + Weights: https://download.openmmlab.com/mmdetection/v3.0/dino/dino-4scale_r50_8xb2-12e_coco/dino-4scale_r50_8xb2-12e_coco_20221202_182705-55b2bba2.pth + + - Name: dino-4scale_r50_8xb2-24e_coco + In Collection: DINO + Config: configs/dino/dino-4scale_r50_8xb2-24e_coco.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + + - Name: dino-4scale_r50_8xb2-36e_coco + In Collection: DINO + Config: configs/dino/dino-4scale_r50_8xb2-36e_coco.py + Metadata: + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + + - Name: dino-5scale_swin-l_8xb2-12e_coco + In Collection: DINO + Config: configs/dino/dino-5scale_swin-l_8xb2-12e_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 57.2 + Weights: https://download.openmmlab.com/mmdetection/v3.0/dino/dino-5scale_swin-l_8xb2-12e_coco/dino-5scale_swin-l_8xb2-12e_coco_20230228_072924-a654145f.pth + + - Name: dino-5scale_swin-l_8xb2-36e_coco + In Collection: DINO + Config: configs/dino/dino-5scale_swin-l_8xb2-36e_coco.py + Metadata: + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 58.4 + Weights: https://github.com/RistoranteRist/mmlab-weights/releases/download/dino-swinl/dino-5scale_swin-l_8xb2-36e_coco-5486e051.pth + - Name: dino-4scale_r50_improved_8xb2-12e_coco + In Collection: DINO + Config: configs/dino/dino-4scale_r50_improved_8xb2-12e_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 50.1 + Weights: https://download.openmmlab.com/mmdetection/v3.0/dino/dino-4scale_r50_improved_8xb2-12e_coco/dino-4scale_r50_improved_8xb2-12e_coco_20230818_162607-6f47a913.pth diff --git a/mmdetection/configs/double_heads/README.md b/mmdetection/configs/double_heads/README.md new file mode 100644 index 00000000..1b97dbc1 --- /dev/null +++ b/mmdetection/configs/double_heads/README.md @@ -0,0 +1,32 @@ +# Double Heads + +> [Rethinking Classification and Localization for Object Detection](https://arxiv.org/abs/1904.06493) + + + +## Abstract + +Two head structures (i.e. fully connected head and convolution head) have been widely used in R-CNN based detectors for classification and localization tasks. However, there is a lack of understanding of how does these two head structures work for these two tasks. To address this issue, we perform a thorough analysis and find an interesting fact that the two head structures have opposite preferences towards the two tasks. Specifically, the fully connected head (fc-head) is more suitable for the classification task, while the convolution head (conv-head) is more suitable for the localization task. Furthermore, we examine the output feature maps of both heads and find that fc-head has more spatial sensitivity than conv-head. Thus, fc-head has more capability to distinguish a complete object from part of an object, but is not robust to regress the whole object. Based upon these findings, we propose a Double-Head method, which has a fully connected head focusing on classification and a convolution head for bounding box regression. Without bells and whistles, our method gains +3.5 and +2.8 AP on MS COCO dataset from Feature Pyramid Network (FPN) baselines with ResNet-50 and ResNet-101 backbones, respectively. + +
    + +
    + +## Results and Models + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :------: | :-----: | :-----: | :------: | :------------: | :----: | :-------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | pytorch | 1x | 6.8 | 9.5 | 40.0 | [config](./dh-faster-rcnn_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/double_heads/dh_faster_rcnn_r50_fpn_1x_coco/dh_faster_rcnn_r50_fpn_1x_coco_20200130-586b67df.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/double_heads/dh_faster_rcnn_r50_fpn_1x_coco/dh_faster_rcnn_r50_fpn_1x_coco_20200130_220238.log.json) | + +## Citation + +```latex +@article{wu2019rethinking, + title={Rethinking Classification and Localization for Object Detection}, + author={Yue Wu and Yinpeng Chen and Lu Yuan and Zicheng Liu and Lijuan Wang and Hongzhi Li and Yun Fu}, + year={2019}, + eprint={1904.06493}, + archivePrefix={arXiv}, + primaryClass={cs.CV} +} +``` diff --git a/mmdetection/configs/double_heads/dh-faster-rcnn_r50_fpn_1x_coco.py b/mmdetection/configs/double_heads/dh-faster-rcnn_r50_fpn_1x_coco.py new file mode 100644 index 00000000..6b9b6e69 --- /dev/null +++ b/mmdetection/configs/double_heads/dh-faster-rcnn_r50_fpn_1x_coco.py @@ -0,0 +1,23 @@ +_base_ = '../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + roi_head=dict( + type='DoubleHeadRoIHead', + reg_roi_scale_factor=1.3, + bbox_head=dict( + _delete_=True, + type='DoubleConvFCBBoxHead', + num_convs=4, + num_fcs=2, + in_channels=256, + conv_out_channels=1024, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=False, + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=2.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=2.0)))) diff --git a/mmdetection/configs/double_heads/metafile.yml b/mmdetection/configs/double_heads/metafile.yml new file mode 100644 index 00000000..bb14e796 --- /dev/null +++ b/mmdetection/configs/double_heads/metafile.yml @@ -0,0 +1,41 @@ +Collections: + - Name: Rethinking Classification and Localization for Object Detection + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - FPN + - RPN + - ResNet + - RoIAlign + Paper: + URL: https://arxiv.org/pdf/1904.06493 + Title: 'Rethinking Classification and Localization for Object Detection' + README: configs/double_heads/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/roi_heads/double_roi_head.py#L6 + Version: v2.0.0 + +Models: + - Name: dh-faster-rcnn_r50_fpn_1x_coco + In Collection: Rethinking Classification and Localization for Object Detection + Config: configs/double_heads/dh-faster-rcnn_r50_fpn_1x_coco.py + Metadata: + Training Memory (GB): 6.8 + inference time (ms/im): + - value: 105.26 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/double_heads/dh_faster_rcnn_r50_fpn_1x_coco/dh_faster_rcnn_r50_fpn_1x_coco_20200130-586b67df.pth diff --git a/mmdetection/configs/dsdl/README.md b/mmdetection/configs/dsdl/README.md new file mode 100644 index 00000000..f38c3b65 --- /dev/null +++ b/mmdetection/configs/dsdl/README.md @@ -0,0 +1,63 @@ +# DSDL: Standard Description Language for DataSet + + + +## 1. Abstract + +Data is the cornerstone of artificial intelligence. The efficiency of data acquisition, exchange, and application directly impacts the advances in technologies and applications. Over the long history of AI, a vast quantity of data sets have been developed and distributed. However, these datasets are defined in very different forms, which incurs significant overhead when it comes to exchange, integration, and utilization -- it is often the case that one needs to develop a new customized tool or script in order to incorporate a new dataset into a workflow. + +To overcome such difficulties, we develop **Data Set Description Language (DSDL)**. More details please visit our [official documents](https://opendatalab.github.io/dsdl-docs/getting_started/overview/), dsdl datasets can be downloaded from our platform [OpenDataLab](https://opendatalab.com/). + +## 2. Steps + +- install dsdl: + + install by pip: + + ``` + pip install dsdl + ``` + + install by source code: + + ``` + git clone https://github.com/opendatalab/dsdl-sdk.git -b schema-dsdl + cd dsdl-sdk + python setup.py install + ``` + +- install mmdet and pytorch: + please refer this [installation documents](https://mmdetection.readthedocs.io/en/latest/get_started.html). + +- train: + + - using single gpu: + + ``` + python tools/train.py {config_file} + ``` + + - using slurm: + + ``` + ./tools/slurm_train.sh {partition} {job_name} {config_file} {work_dir} {gpu_nums} + ``` + +## 3. Test Results + +- detection task: + + | Datasets | Model | box AP | Config | + | :--------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :----: | :-------------------------: | + | VOC07+12 | [model](https://download.openmmlab.com/mmdetection/v2.0/pascal_voc/faster_rcnn_r50_fpn_1x_voc0712/faster_rcnn_r50_fpn_1x_voc0712_20220320_192712-54bef0f3.pth) | 80.3\* | [config](./voc0712.py) | + | COCO | [model](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth) | 37.4 | [config](./coco.py) | + | Objects365 | [model](https://download.openmmlab.com/mmdetection/v2.0/objects365/faster_rcnn_r50_fpn_16x4_1x_obj365v2/faster_rcnn_r50_fpn_16x4_1x_obj365v2_20221220_175040-5910b015.pth) | 19.8 | [config](./objects365v2.py) | + | OpenImages | [model](https://download.openmmlab.com/mmdetection/v2.0/openimages/faster_rcnn_r50_fpn_32x2_cas_1x_openimages/faster_rcnn_r50_fpn_32x2_cas_1x_openimages_20220306_202424-98c630e5.pth) | 59.9\* | [config](./openimagesv6.py) | + + \*: box AP in voc metric and openimages metric, actually means AP_50. + +- instance segmentation task: + + | Datasets | Model | box AP | mask AP | Config | + | :------: | :------------------------------------------------------------------------------------------------------------------------------------------: | :----: | :-----: | :--------------------------: | + | COCO | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_fpn_1x_coco/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth) | 38.1 | 34.7 | [config](./coco_instance.py) | diff --git a/mmdetection/configs/dsdl/coco.py b/mmdetection/configs/dsdl/coco.py new file mode 100644 index 00000000..3c9e895e --- /dev/null +++ b/mmdetection/configs/dsdl/coco.py @@ -0,0 +1,33 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py', + '../_base_/datasets/dsdl.py' +] + +# dsdl dataset settings + +# please visit our platform [OpenDataLab](https://opendatalab.com/) +# to downloaded dsdl dataset. +data_root = 'data/COCO2017' +img_prefix = 'original' +train_ann = 'dsdl/set-train/train.yaml' +val_ann = 'dsdl/set-val/val.yaml' +specific_key_path = dict(ignore_flag='./annotations/*/iscrowd') + +train_dataloader = dict( + dataset=dict( + specific_key_path=specific_key_path, + data_root=data_root, + ann_file=train_ann, + data_prefix=dict(img_path=img_prefix), + filter_cfg=dict(filter_empty_gt=True, min_size=32, bbox_min_size=32), + )) + +val_dataloader = dict( + dataset=dict( + specific_key_path=specific_key_path, + data_root=data_root, + ann_file=val_ann, + data_prefix=dict(img_path=img_prefix), + )) +test_dataloader = val_dataloader diff --git a/mmdetection/configs/dsdl/coco_instance.py b/mmdetection/configs/dsdl/coco_instance.py new file mode 100644 index 00000000..e34f93c9 --- /dev/null +++ b/mmdetection/configs/dsdl/coco_instance.py @@ -0,0 +1,62 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py', + '../_base_/datasets/dsdl.py' +] + +# dsdl dataset settings. + +# please visit our platform [OpenDataLab](https://opendatalab.com/) +# to downloaded dsdl dataset. +data_root = 'data/COCO2017' +img_prefix = 'original' +train_ann = 'dsdl/set-train/train.yaml' +val_ann = 'dsdl/set-val/val.yaml' +specific_key_path = dict(ignore_flag='./annotations/*/iscrowd') + +backend_args = None + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'instances')) +] + +train_dataloader = dict( + dataset=dict( + with_polygon=True, + specific_key_path=specific_key_path, + data_root=data_root, + ann_file=train_ann, + data_prefix=dict(img_path=img_prefix), + filter_cfg=dict(filter_empty_gt=True, min_size=32, bbox_min_size=32), + pipeline=train_pipeline, + )) + +val_dataloader = dict( + dataset=dict( + with_polygon=True, + specific_key_path=specific_key_path, + data_root=data_root, + ann_file=val_ann, + data_prefix=dict(img_path=img_prefix), + pipeline=test_pipeline, + )) + +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', metric=['bbox', 'segm'], format_only=False) + +test_evaluator = val_evaluator diff --git a/mmdetection/configs/dsdl/objects365v2.py b/mmdetection/configs/dsdl/objects365v2.py new file mode 100644 index 00000000..d25a2323 --- /dev/null +++ b/mmdetection/configs/dsdl/objects365v2.py @@ -0,0 +1,54 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py', + '../_base_/datasets/dsdl.py' +] + +model = dict(roi_head=dict(bbox_head=dict(num_classes=365))) + +# dsdl dataset settings + +# please visit our platform [OpenDataLab](https://opendatalab.com/) +# to downloaded dsdl dataset. +data_root = 'data/Objects365' +img_prefix = 'original' +train_ann = 'dsdl/set-train/train.yaml' +val_ann = 'dsdl/set-val/val.yaml' +specific_key_path = dict(ignore_flag='./annotations/*/iscrowd') + +train_dataloader = dict( + dataset=dict( + specific_key_path=specific_key_path, + data_root=data_root, + ann_file=train_ann, + data_prefix=dict(img_path=img_prefix), + filter_cfg=dict(filter_empty_gt=True, min_size=32, bbox_min_size=32), + )) + +val_dataloader = dict( + dataset=dict( + specific_key_path=specific_key_path, + data_root=data_root, + ann_file=val_ann, + data_prefix=dict(img_path=img_prefix), + test_mode=True, + )) +test_dataloader = val_dataloader + +default_hooks = dict(logger=dict(type='LoggerHook', interval=1000), ) +train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=3, val_interval=1) +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=12, + by_epoch=True, + milestones=[1, 2], + gamma=0.1) +] +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) diff --git a/mmdetection/configs/dsdl/openimagesv6.py b/mmdetection/configs/dsdl/openimagesv6.py new file mode 100644 index 00000000..a65f942a --- /dev/null +++ b/mmdetection/configs/dsdl/openimagesv6.py @@ -0,0 +1,94 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../_base_/schedules/schedule_1x.py', + '../_base_/default_runtime.py', +] + +model = dict(roi_head=dict(bbox_head=dict(num_classes=601))) + +# dsdl dataset settings + +# please visit our platform [OpenDataLab](https://opendatalab.com/) +# to downloaded dsdl dataset. +dataset_type = 'DSDLDetDataset' +data_root = 'data/OpenImages' +train_ann = 'dsdl/set-train/train.yaml' +val_ann = 'dsdl/set-val/val.yaml' +specific_key_path = dict( + image_level_labels='./image_labels/*/label', + Label='./objects/*/label', + is_group_of='./objects/*/isgroupof', +) + +backend_args = dict( + backend='petrel', + path_mapping=dict({'data/': 's3://open_dataset_original/'})) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='Resize', scale=(1024, 800), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1024, 800), keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'instances', 'image_level_labels')) +] + +train_dataloader = dict( + sampler=dict(type='ClassAwareSampler', num_sample_class=1), + dataset=dict( + type=dataset_type, + with_imagelevel_label=True, + with_hierarchy=True, + specific_key_path=specific_key_path, + data_root=data_root, + ann_file=train_ann, + filter_cfg=dict(filter_empty_gt=True, min_size=32, bbox_min_size=32), + pipeline=train_pipeline)) + +val_dataloader = dict( + dataset=dict( + type=dataset_type, + with_imagelevel_label=True, + with_hierarchy=True, + specific_key_path=specific_key_path, + data_root=data_root, + ann_file=val_ann, + test_mode=True, + pipeline=test_pipeline)) + +test_dataloader = val_dataloader + +default_hooks = dict(logger=dict(type='LoggerHook', interval=1000), ) +train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=3, val_interval=1) +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=12, + by_epoch=True, + milestones=[1, 2], + gamma=0.1) +] +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) + +val_evaluator = dict( + type='OpenImagesMetric', + iou_thrs=0.5, + ioa_thrs=0.5, + use_group_of=True, + get_supercategory=True) + +test_evaluator = val_evaluator diff --git a/mmdetection/configs/dsdl/voc07.py b/mmdetection/configs/dsdl/voc07.py new file mode 100644 index 00000000..b7b86471 --- /dev/null +++ b/mmdetection/configs/dsdl/voc07.py @@ -0,0 +1,94 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', '../_base_/default_runtime.py' +] + +# model setting +model = dict(roi_head=dict(bbox_head=dict(num_classes=20))) + +# dsdl dataset settings + +# please visit our platform [OpenDataLab](https://opendatalab.com/) +# to downloaded dsdl dataset. +dataset_type = 'DSDLDetDataset' +data_root = 'data/VOC07-det' +img_prefix = 'original' +train_ann = 'dsdl/set-train/train.yaml' +val_ann = 'dsdl/set-test/test.yaml' + +specific_key_path = dict(ignore_flag='./objects/*/difficult') + +backend_args = None + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='Resize', scale=(1000, 600), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1000, 600), keep_ratio=True), + # avoid bboxes being resized + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'instances')) +] +train_dataloader = dict( + dataset=dict( + type=dataset_type, + specific_key_path=specific_key_path, + data_root=data_root, + ann_file=train_ann, + data_prefix=dict(img_path=img_prefix), + filter_cfg=dict(filter_empty_gt=True, min_size=32, bbox_min_size=32), + pipeline=train_pipeline)) + +val_dataloader = dict( + dataset=dict( + type=dataset_type, + specific_key_path=specific_key_path, + data_root=data_root, + ann_file=val_ann, + data_prefix=dict(img_path=img_prefix), + test_mode=True, + pipeline=test_pipeline)) +test_dataloader = val_dataloader + +# Pascal VOC2007 uses `11points` as default evaluate mode, while PASCAL +# VOC2012 defaults to use 'area'. +val_evaluator = dict(type='VOCMetric', metric='mAP', eval_mode='11points') +# val_evaluator = dict(type='CocoMetric', metric='bbox') +test_evaluator = val_evaluator + +# training schedule, voc dataset is repeated 3 times, in +# `_base_/datasets/voc0712.py`, so the actual epoch = 4 * 3 = 12 +max_epochs = 12 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=3) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# learning rate +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[9], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) + +# Default setting for scaling LR automatically +# - `enable` means enable scaling LR automatically +# or not by default. +# - `base_batch_size` = (8 GPUs) x (2 samples per GPU). +auto_scale_lr = dict(enable=False, base_batch_size=16) diff --git a/mmdetection/configs/dsdl/voc0712.py b/mmdetection/configs/dsdl/voc0712.py new file mode 100644 index 00000000..9ec1bb8f --- /dev/null +++ b/mmdetection/configs/dsdl/voc0712.py @@ -0,0 +1,132 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../_base_/schedules/schedule_1x.py', + '../_base_/default_runtime.py', + # '../_base_/datasets/dsdl.py' +] + +# model setting +model = dict(roi_head=dict(bbox_head=dict(num_classes=20))) + +# dsdl dataset settings + +# please visit our platform [OpenDataLab](https://opendatalab.com/) +# to downloaded dsdl dataset. +dataset_type = 'DSDLDetDataset' +data_root_07 = 'data/VOC07-det' +data_root_12 = 'data/VOC12-det' +img_prefix = 'original' + +train_ann = 'dsdl/set-train/train.yaml' +val_ann = 'dsdl/set-val/val.yaml' +test_ann = 'dsdl/set-test/test.yaml' + +backend_args = None +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='Resize', scale=(1000, 600), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(1000, 600), keep_ratio=True), + # If you don't have a gt annotation, delete the pipeline + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'instances')) +] + +specific_key_path = dict(ignore_flag='./objects/*/difficult', ) + +train_dataloader = dict( + dataset=dict( + type='RepeatDataset', + times=3, + dataset=dict( + type='ConcatDataset', + datasets=[ + dict( + type=dataset_type, + specific_key_path=specific_key_path, + data_root=data_root_07, + ann_file=train_ann, + data_prefix=dict(img_path=img_prefix), + filter_cfg=dict( + filter_empty_gt=True, min_size=32, bbox_min_size=32), + pipeline=train_pipeline), + dict( + type=dataset_type, + specific_key_path=specific_key_path, + data_root=data_root_07, + ann_file=val_ann, + data_prefix=dict(img_path=img_prefix), + filter_cfg=dict( + filter_empty_gt=True, min_size=32, bbox_min_size=32), + pipeline=train_pipeline), + dict( + type=dataset_type, + specific_key_path=specific_key_path, + data_root=data_root_12, + ann_file=train_ann, + data_prefix=dict(img_path=img_prefix), + filter_cfg=dict( + filter_empty_gt=True, min_size=32, bbox_min_size=32), + pipeline=train_pipeline), + dict( + type=dataset_type, + specific_key_path=specific_key_path, + data_root=data_root_12, + ann_file=val_ann, + data_prefix=dict(img_path=img_prefix), + filter_cfg=dict( + filter_empty_gt=True, min_size=32, bbox_min_size=32), + pipeline=train_pipeline), + ]))) + +val_dataloader = dict( + dataset=dict( + type=dataset_type, + specific_key_path=specific_key_path, + data_root=data_root_07, + ann_file=test_ann, + test_mode=True, + pipeline=test_pipeline)) +test_dataloader = val_dataloader + +val_evaluator = dict(type='CocoMetric', metric='bbox') +# val_evaluator = dict(type='VOCMetric', metric='mAP', eval_mode='11points') +test_evaluator = val_evaluator + +# training schedule, voc dataset is repeated 3 times, in +# `_base_/datasets/voc0712.py`, so the actual epoch = 4 * 3 = 12 +max_epochs = 4 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# learning rate +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[3], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) + +# Default setting for scaling LR automatically +# - `enable` means enable scaling LR automatically +# or not by default. +# - `base_batch_size` = (8 GPUs) x (2 samples per GPU). +auto_scale_lr = dict(enable=False, base_batch_size=16) diff --git a/mmdetection/configs/dyhead/README.md b/mmdetection/configs/dyhead/README.md new file mode 100644 index 00000000..decd4805 --- /dev/null +++ b/mmdetection/configs/dyhead/README.md @@ -0,0 +1,52 @@ +# DyHead + +> [Dynamic Head: Unifying Object Detection Heads with Attentions](https://arxiv.org/abs/2106.08322) + + + +## Abstract + +The complex nature of combining localization and classification in object detection has resulted in the flourished development of methods. Previous works tried to improve the performance in various object detection heads but failed to present a unified view. In this paper, we present a novel dynamic head framework to unify object detection heads with attentions. By coherently combining multiple self-attention mechanisms between feature levels for scale-awareness, among spatial locations for spatial-awareness, and within output channels for task-awareness, the proposed approach significantly improves the representation ability of object detection heads without any computational overhead. Further experiments demonstrate that the effectiveness and efficiency of the proposed dynamic head on the COCO benchmark. With a standard ResNeXt-101-DCN backbone, we largely improve the performance over popular object detectors and achieve a new state-of-the-art at 54.0 AP. Furthermore, with latest transformer backbone and extra data, we can push current best COCO result to a new record at 60.6 AP. + +
    + +
    + +## Results and Models + +| Method | Backbone | Style | Setting | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :----: | :------: | :-----: | :----------: | :-----: | :------: | :------------: | :----: | :----------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| ATSS | R-50 | caffe | reproduction | 1x | 5.4 | 13.2 | 42.5 | [config](./atss_r50-caffe_fpn_dyhead_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/dyhead/atss_r50_fpn_dyhead_for_reproduction_1x_coco/atss_r50_fpn_dyhead_for_reproduction_4x4_1x_coco_20220107_213939-162888e6.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/dyhead/atss_r50_fpn_dyhead_for_reproduction_1x_coco/atss_r50_fpn_dyhead_for_reproduction_4x4_1x_coco_20220107_213939.log.json) | +| ATSS | R-50 | pytorch | simple | 1x | 4.9 | 13.7 | 43.3 | [config](./atss_r50_fpn_dyhead_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/dyhead/atss_r50_fpn_dyhead_4x4_1x_coco/atss_r50_fpn_dyhead_4x4_1x_coco_20211219_023314-eaa620c6.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/dyhead/atss_r50_fpn_dyhead_4x4_1x_coco/atss_r50_fpn_dyhead_4x4_1x_coco_20211219_023314.log.json) | + +- We trained the above models with 4 GPUs and 4 `samples_per_gpu`. +- The `reproduction` setting aims to reproduce the official implementation based on Detectron2. +- The `simple` setting serves as a minimum example to use DyHead in MMDetection. Specifically, + - it adds `DyHead` to `neck` after `FPN` + - it sets `stacked_convs=0` to `bbox_head` +- The `simple` setting achieves higher AP than the original implementation. + We have not conduct ablation study between the two settings. + `dict(type='Pad', size_divisor=128)` may further improve AP by prefer spatial alignment across pyramid levels, although large padding reduces efficiency. + +We also trained the model with Swin-L backbone. Results are as below. + +| Method | Backbone | Style | Setting | Lr schd | mstrain | box AP | Config | Download | +| :----: | :------: | :---: | :----------: | :-----: | :------: | :----: | :-----------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| ATSS | Swin-L | caffe | reproduction | 2x | 480~1200 | 56.2 | [config](./atss_swin-l-p4-w12_fpn_dyhead_ms-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/dyhead/atss_swin-l-p4-w12_fpn_dyhead_mstrain_2x_coco/atss_swin-l-p4-w12_fpn_dyhead_mstrain_2x_coco_20220509_100315-bc5b6516.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/dyhead/atss_swin-l-p4-w12_fpn_dyhead_mstrain_2x_coco/atss_swin-l-p4-w12_fpn_dyhead_mstrain_2x_coco_20220509_100315.log.json) | + +## Relation to Other Methods + +- DyHead can be regarded as an improved [SEPC](https://arxiv.org/abs/2005.03101) with [DyReLU modules](https://arxiv.org/abs/2003.10027) and simplified [SE blocks](https://arxiv.org/abs/1709.01507). +- Xiyang Dai et al., the author team of DyHead, adopt it for [Dynamic DETR](https://openaccess.thecvf.com/content/ICCV2021/html/Dai_Dynamic_DETR_End-to-End_Object_Detection_With_Dynamic_Attention_ICCV_2021_paper.html). + The description of Dynamic Encoder in Sec. 3.2 will help you understand DyHead. + +## Citation + +```latex +@inproceedings{DyHead_CVPR2021, + author = {Dai, Xiyang and Chen, Yinpeng and Xiao, Bin and Chen, Dongdong and Liu, Mengchen and Yuan, Lu and Zhang, Lei}, + title = {Dynamic Head: Unifying Object Detection Heads With Attentions}, + booktitle = {Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)}, + year = {2021} +} +``` diff --git a/mmdetection/configs/dyhead/atss_r50-caffe_fpn_dyhead_1x_coco.py b/mmdetection/configs/dyhead/atss_r50-caffe_fpn_dyhead_1x_coco.py new file mode 100644 index 00000000..8716f122 --- /dev/null +++ b/mmdetection/configs/dyhead/atss_r50-caffe_fpn_dyhead_1x_coco.py @@ -0,0 +1,103 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +model = dict( + type='ATSS', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False, + pad_size_divisor=128), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=False), + norm_eval=True, + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe')), + neck=[ + dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_output', + num_outs=5), + dict( + type='DyHead', + in_channels=256, + out_channels=256, + num_blocks=6, + # disable zero_init_offset to follow official implementation + zero_init_offset=False) + ], + bbox_head=dict( + type='ATSSHead', + num_classes=80, + in_channels=256, + pred_kernel_size=1, # follow DyHead official implementation + stacked_convs=0, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + octave_base_scale=8, + scales_per_octave=1, + strides=[8, 16, 32, 64, 128], + center_offset=0.5), # follow DyHead official implementation + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=2.0), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)), + # training and testing settings + train_cfg=dict( + assigner=dict(type='ATSSAssigner', topk=9), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) + +# optimizer +optim_wrapper = dict(optimizer=dict(lr=0.01)) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='Resize', scale=(1333, 800), keep_ratio=True, backend='pillow'), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=(1333, 800), keep_ratio=True, backend='pillow'), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader diff --git a/mmdetection/configs/dyhead/atss_r50_fpn_dyhead_1x_coco.py b/mmdetection/configs/dyhead/atss_r50_fpn_dyhead_1x_coco.py new file mode 100644 index 00000000..89e89b98 --- /dev/null +++ b/mmdetection/configs/dyhead/atss_r50_fpn_dyhead_1x_coco.py @@ -0,0 +1,72 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +model = dict( + type='ATSS', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=[ + dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_output', + num_outs=5), + dict(type='DyHead', in_channels=256, out_channels=256, num_blocks=6) + ], + bbox_head=dict( + type='ATSSHead', + num_classes=80, + in_channels=256, + stacked_convs=0, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + octave_base_scale=8, + scales_per_octave=1, + strides=[8, 16, 32, 64, 128]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=2.0), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)), + # training and testing settings + train_cfg=dict( + assigner=dict(type='ATSSAssigner', topk=9), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) + +# optimizer +optim_wrapper = dict(optimizer=dict(lr=0.01)) diff --git a/mmdetection/configs/dyhead/atss_swin-l-p4-w12_fpn_dyhead_ms-2x_coco.py b/mmdetection/configs/dyhead/atss_swin-l-p4-w12_fpn_dyhead_ms-2x_coco.py new file mode 100644 index 00000000..f537b9dc --- /dev/null +++ b/mmdetection/configs/dyhead/atss_swin-l-p4-w12_fpn_dyhead_ms-2x_coco.py @@ -0,0 +1,140 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_large_patch4_window12_384_22k.pth' # noqa +model = dict( + type='ATSS', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=128), + backbone=dict( + type='SwinTransformer', + pretrain_img_size=384, + embed_dims=192, + depths=[2, 2, 18, 2], + num_heads=[6, 12, 24, 48], + window_size=12, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.2, + patch_norm=True, + out_indices=(1, 2, 3), + # Please only add indices that would be used + # in FPN, otherwise some parameter will not be used + with_cp=False, + convert_weights=True, + init_cfg=dict(type='Pretrained', checkpoint=pretrained)), + neck=[ + dict( + type='FPN', + in_channels=[384, 768, 1536], + out_channels=256, + start_level=0, + add_extra_convs='on_output', + num_outs=5), + dict( + type='DyHead', + in_channels=256, + out_channels=256, + num_blocks=6, + # disable zero_init_offset to follow official implementation + zero_init_offset=False) + ], + bbox_head=dict( + type='ATSSHead', + num_classes=80, + in_channels=256, + pred_kernel_size=1, # follow DyHead official implementation + stacked_convs=0, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + octave_base_scale=8, + scales_per_octave=1, + strides=[8, 16, 32, 64, 128], + center_offset=0.5), # follow DyHead official implementation + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=2.0), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)), + # training and testing settings + train_cfg=dict( + assigner=dict(type='ATSSAssigner', topk=9), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) + +# dataset settings +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomResize', + scale=[(2000, 480), (2000, 1200)], + keep_ratio=True, + backend='pillow'), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=(2000, 1200), keep_ratio=True, backend='pillow'), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict( + dataset=dict( + _delete_=True, + type='RepeatDataset', + times=2, + dataset=dict( + type={{_base_.dataset_type}}, + data_root={{_base_.data_root}}, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args={{_base_.backend_args}}))) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader + +# optimizer +optim_wrapper = dict( + _delete_=True, + type='OptimWrapper', + optimizer=dict( + type='AdamW', lr=0.00005, betas=(0.9, 0.999), weight_decay=0.05), + paramwise_cfg=dict( + custom_keys={ + 'absolute_pos_embed': dict(decay_mult=0.), + 'relative_position_bias_table': dict(decay_mult=0.), + 'norm': dict(decay_mult=0.) + }), + clip_grad=None) diff --git a/mmdetection/configs/dyhead/metafile.yml b/mmdetection/configs/dyhead/metafile.yml new file mode 100644 index 00000000..28b5a582 --- /dev/null +++ b/mmdetection/configs/dyhead/metafile.yml @@ -0,0 +1,76 @@ +Collections: + - Name: DyHead + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 4x T4 GPUs + Architecture: + - ATSS + - DyHead + - FPN + - ResNet + - Deformable Convolution + - Pyramid Convolution + Paper: + URL: https://arxiv.org/abs/2106.08322 + Title: 'Dynamic Head: Unifying Object Detection Heads with Attentions' + README: configs/dyhead/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.22.0/mmdet/models/necks/dyhead.py#L130 + Version: v2.22.0 + +Models: + - Name: atss_r50-caffe_fpn_dyhead_1x_coco + In Collection: DyHead + Config: configs/dyhead/atss_r50-caffe_fpn_dyhead_1x_coco.py + Metadata: + Training Memory (GB): 5.4 + inference time (ms/im): + - value: 75.7 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/dyhead/atss_r50_fpn_dyhead_for_reproduction_1x_coco/atss_r50_fpn_dyhead_for_reproduction_4x4_1x_coco_20220107_213939-162888e6.pth + + - Name: atss_r50_fpn_dyhead_1x_coco + In Collection: DyHead + Config: configs/dyhead/atss_r50_fpn_dyhead_1x_coco.py + Metadata: + Training Memory (GB): 4.9 + inference time (ms/im): + - value: 73.1 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/dyhead/atss_r50_fpn_dyhead_4x4_1x_coco/atss_r50_fpn_dyhead_4x4_1x_coco_20211219_023314-eaa620c6.pth + + - Name: atss_swin-l-p4-w12_fpn_dyhead_ms-2x_coco + In Collection: DyHead + Config: configs/dyhead/atss_swin-l-p4-w12_fpn_dyhead_ms-2x_coco.py + Metadata: + Training Memory (GB): 58.4 + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 56.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/dyhead/atss_swin-l-p4-w12_fpn_dyhead_mstrain_2x_coco/atss_swin-l-p4-w12_fpn_dyhead_mstrain_2x_coco_20220509_100315-bc5b6516.pth diff --git a/mmdetection/configs/dynamic_rcnn/README.md b/mmdetection/configs/dynamic_rcnn/README.md new file mode 100644 index 00000000..b5e803a2 --- /dev/null +++ b/mmdetection/configs/dynamic_rcnn/README.md @@ -0,0 +1,30 @@ +# Dynamic R-CNN + +> [Dynamic R-CNN: Towards High Quality Object Detection via Dynamic Training](https://arxiv.org/abs/2004.06002) + + + +## Abstract + +Although two-stage object detectors have continuously advanced the state-of-the-art performance in recent years, the training process itself is far from crystal. In this work, we first point out the inconsistency problem between the fixed network settings and the dynamic training procedure, which greatly affects the performance. For example, the fixed label assignment strategy and regression loss function cannot fit the distribution change of proposals and thus are harmful to training high quality detectors. Consequently, we propose Dynamic R-CNN to adjust the label assignment criteria (IoU threshold) and the shape of regression loss function (parameters of SmoothL1 Loss) automatically based on the statistics of proposals during training. This dynamic design makes better use of the training samples and pushes the detector to fit more high quality samples. Specifically, our method improves upon ResNet-50-FPN baseline with 1.9% AP and 5.5% AP90 on the MS COCO dataset with no extra overhead. + +
    + +
    + +## Results and Models + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :------: | :-----: | :-----: | :------: | :------------: | :----: | :-----------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | pytorch | 1x | 3.8 | | 38.9 | [config](./dynamic-rcnn_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/dynamic_rcnn/dynamic_rcnn_r50_fpn_1x/dynamic_rcnn_r50_fpn_1x-62a3f276.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/dynamic_rcnn/dynamic_rcnn_r50_fpn_1x/dynamic_rcnn_r50_fpn_1x_20200618_095048.log.json) | + +## Citation + +```latex +@article{DynamicRCNN, + author = {Hongkai Zhang and Hong Chang and Bingpeng Ma and Naiyan Wang and Xilin Chen}, + title = {Dynamic {R-CNN}: Towards High Quality Object Detection via Dynamic Training}, + journal = {arXiv preprint arXiv:2004.06002}, + year = {2020} +} +``` diff --git a/mmdetection/configs/dynamic_rcnn/dynamic-rcnn_r50_fpn_1x_coco.py b/mmdetection/configs/dynamic_rcnn/dynamic-rcnn_r50_fpn_1x_coco.py new file mode 100644 index 00000000..f64dfa0b --- /dev/null +++ b/mmdetection/configs/dynamic_rcnn/dynamic-rcnn_r50_fpn_1x_coco.py @@ -0,0 +1,28 @@ +_base_ = '../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + roi_head=dict( + type='DynamicRoIHead', + bbox_head=dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=False, + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0))), + train_cfg=dict( + rpn_proposal=dict(nms=dict(iou_threshold=0.85)), + rcnn=dict( + dynamic_rcnn=dict( + iou_topk=75, + beta_topk=10, + update_iter_interval=100, + initial_iou=0.4, + initial_beta=1.0))), + test_cfg=dict(rpn=dict(nms=dict(iou_threshold=0.85)))) diff --git a/mmdetection/configs/dynamic_rcnn/metafile.yml b/mmdetection/configs/dynamic_rcnn/metafile.yml new file mode 100644 index 00000000..64ab3b0c --- /dev/null +++ b/mmdetection/configs/dynamic_rcnn/metafile.yml @@ -0,0 +1,35 @@ +Collections: + - Name: Dynamic R-CNN + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - Dynamic R-CNN + - FPN + - RPN + - ResNet + - RoIAlign + Paper: + URL: https://arxiv.org/pdf/2004.06002 + Title: 'Dynamic R-CNN: Towards High Quality Object Detection via Dynamic Training' + README: configs/dynamic_rcnn/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.2.0/mmdet/models/roi_heads/dynamic_roi_head.py#L11 + Version: v2.2.0 + +Models: + - Name: dynamic-rcnn_r50_fpn_1x_coco + In Collection: Dynamic R-CNN + Config: configs/dynamic_rcnn/dynamic-rcnn_r50_fpn_1x_coco.py + Metadata: + Training Memory (GB): 3.8 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/dynamic_rcnn/dynamic_rcnn_r50_fpn_1x/dynamic_rcnn_r50_fpn_1x-62a3f276.pth diff --git a/mmdetection/configs/efficientnet/README.md b/mmdetection/configs/efficientnet/README.md new file mode 100644 index 00000000..941944db --- /dev/null +++ b/mmdetection/configs/efficientnet/README.md @@ -0,0 +1,30 @@ +# EfficientNet + +> [EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks](https://arxiv.org/abs/1905.11946v5) + + + +## Introduction + +Convolutional Neural Networks (ConvNets) are commonly developed at a fixed resource budget, and then scaled up for better accuracy if more resources are available. In this paper, we systematically study model scaling and identify that carefully balancing network depth, width, and resolution can lead to better performance. Based on this observation, we propose a new scaling method that uniformly scales all dimensions of depth/width/resolution using a simple yet highly effective compound coefficient. We demonstrate the effectiveness of this method on scaling up MobileNets and ResNet. + +To go even further, we use neural architecture search to design a new baseline network and scale it up to obtain a family of models, called EfficientNets, which achieve much better accuracy and efficiency than previous ConvNets. In particular, our EfficientNet-B7 achieves state-of-the-art 84.3% top-1 accuracy on ImageNet, while being 8.4x smaller and 6.1x faster on inference than the best existing ConvNet. Our EfficientNets also transfer well and achieve state-of-the-art accuracy on CIFAR-100 (91.7%), Flowers (98.8%), and 3 other transfer learning datasets, with an order of magnitude fewer parameters. + +## Results and Models + +### RetinaNet + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :-------------: | :-----: | :-----: | :------: | :------------: | :----: | :-----------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| Efficientnet-b3 | pytorch | 1x | - | - | 40.5 | [config](./retinanet_effb3_fpn_8xb4-crop896-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/efficientnet/retinanet_effb3_fpn_crop896_8x4_1x_coco/retinanet_effb3_fpn_crop896_8x4_1x_coco_20220322_234806-615a0dda.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/efficientnet/retinanet_effb3_fpn_crop896_8x4_1x_coco/retinanet_effb3_fpn_crop896_8x4_1x_coco_20220322_234806.log.json) | + +## Citation + +```latex +@article{tan2019efficientnet, + title={Efficientnet: Rethinking model scaling for convolutional neural networks}, + author={Tan, Mingxing and Le, Quoc V}, + journal={arXiv preprint arXiv:1905.11946}, + year={2019} +} +``` diff --git a/mmdetection/configs/efficientnet/metafile.yml b/mmdetection/configs/efficientnet/metafile.yml new file mode 100644 index 00000000..6e220c8a --- /dev/null +++ b/mmdetection/configs/efficientnet/metafile.yml @@ -0,0 +1,19 @@ +Models: + - Name: retinanet_effb3_fpn_8xb4-crop896-1x_coco + In Collection: RetinaNet + Config: configs/efficientnet/retinanet_effb3_fpn_8xb4-crop896-1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/efficientnet/retinanet_effb3_fpn_crop896_8x4_1x_coco/retinanet_effb3_fpn_crop896_8x4_1x_coco_20220322_234806-615a0dda.pth + Paper: + URL: https://arxiv.org/abs/1905.11946v5 + Title: 'EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks' + README: configs/efficientnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.23.0/mmdet/models/backbones/efficientnet.py#L159 + Version: v2.23.0 diff --git a/mmdetection/configs/efficientnet/retinanet_effb3_fpn_8xb4-crop896-1x_coco.py b/mmdetection/configs/efficientnet/retinanet_effb3_fpn_8xb4-crop896-1x_coco.py new file mode 100644 index 00000000..2d0d9cef --- /dev/null +++ b/mmdetection/configs/efficientnet/retinanet_effb3_fpn_8xb4-crop896-1x_coco.py @@ -0,0 +1,94 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/schedules/schedule_1x.py', + '../_base_/datasets/coco_detection.py', '../_base_/default_runtime.py' +] + +image_size = (896, 896) +batch_augments = [dict(type='BatchFixedSizePad', size=image_size)] +norm_cfg = dict(type='BN', requires_grad=True) +checkpoint = 'https://download.openmmlab.com/mmclassification/v0/efficientnet/efficientnet-b3_3rdparty_8xb32-aa_in1k_20220119-5b4887a0.pth' # noqa +model = dict( + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32, + batch_augments=batch_augments), + backbone=dict( + _delete_=True, + type='EfficientNet', + arch='b3', + drop_path_rate=0.2, + out_indices=(3, 4, 5), + frozen_stages=0, + norm_cfg=dict( + type='SyncBN', requires_grad=True, eps=1e-3, momentum=0.01), + norm_eval=False, + init_cfg=dict( + type='Pretrained', prefix='backbone', checkpoint=checkpoint)), + neck=dict( + in_channels=[48, 136, 384], + start_level=0, + out_channels=256, + relu_before_extra_convs=True, + no_norm_on_lateral=True, + norm_cfg=norm_cfg), + bbox_head=dict(type='RetinaSepBNHead', num_ins=5, norm_cfg=norm_cfg), + # training and testing settings + train_cfg=dict(assigner=dict(neg_iou_thr=0.5))) + +# dataset settings +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomResize', + scale=image_size, + ratio_range=(0.8, 1.2), + keep_ratio=True), + dict(type='RandomCrop', crop_size=image_size), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=image_size, keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict( + batch_size=4, num_workers=4, dataset=dict(pipeline=train_pipeline)) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader + +# optimizer +optim_wrapper = dict( + optimizer=dict(lr=0.04), + paramwise_cfg=dict(norm_decay_mult=0, bypass_duplicate=True)) + +# learning policy +max_epochs = 12 +param_scheduler = [ + dict(type='LinearLR', start_factor=0.1, by_epoch=False, begin=0, end=1000), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs) + +# cudnn_benchmark=True can accelerate fix-size training +env_cfg = dict(cudnn_benchmark=True) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (4 samples per GPU) +auto_scale_lr = dict(base_batch_size=32) diff --git a/mmdetection/configs/empirical_attention/README.md b/mmdetection/configs/empirical_attention/README.md new file mode 100644 index 00000000..c0b4a68b --- /dev/null +++ b/mmdetection/configs/empirical_attention/README.md @@ -0,0 +1,33 @@ +# Empirical Attention + +> [An Empirical Study of Spatial Attention Mechanisms in Deep Networks](https://arxiv.org/abs/1904.05873) + + + +## Abstract + +Attention mechanisms have become a popular component in deep neural networks, yet there has been little examination of how different influencing factors and methods for computing attention from these factors affect performance. Toward a better general understanding of attention mechanisms, we present an empirical study that ablates various spatial attention elements within a generalized attention formulation, encompassing the dominant Transformer attention as well as the prevalent deformable convolution and dynamic convolution modules. Conducted on a variety of applications, the study yields significant findings about spatial attention in deep networks, some of which run counter to conventional understanding. For example, we find that the query and key content comparison in Transformer attention is negligible for self-attention, but vital for encoder-decoder attention. A proper combination of deformable convolution with key content only saliency achieves the best accuracy-efficiency tradeoff in self-attention. Our results suggest that there exists much room for improvement in the design of attention mechanisms. + +
    + +
    + +## Results and Models + +| Backbone | Attention Component | DCN | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :------: | :-----------------: | :-: | :-----: | :------: | :------------: | :----: | :-----------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | 1111 | N | 1x | 8.0 | 13.8 | 40.0 | [config](./faster-rcnn_r50-attn1111_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/empirical_attention/faster_rcnn_r50_fpn_attention_1111_1x_coco/faster_rcnn_r50_fpn_attention_1111_1x_coco_20200130-403cccba.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/empirical_attention/faster_rcnn_r50_fpn_attention_1111_1x_coco/faster_rcnn_r50_fpn_attention_1111_1x_coco_20200130_210344.log.json) | +| R-50 | 0010 | N | 1x | 4.2 | 18.4 | 39.1 | [config](./faster-rcnn_r50-attn0010_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/empirical_attention/faster_rcnn_r50_fpn_attention_0010_1x_coco/faster_rcnn_r50_fpn_attention_0010_1x_coco_20200130-7cb0c14d.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/empirical_attention/faster_rcnn_r50_fpn_attention_0010_1x_coco/faster_rcnn_r50_fpn_attention_0010_1x_coco_20200130_210125.log.json) | +| R-50 | 1111 | Y | 1x | 8.0 | 12.7 | 42.1 | [config](./faster-rcnn_r50-attn1111-dcn_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/empirical_attention/faster_rcnn_r50_fpn_attention_1111_dcn_1x_coco/faster_rcnn_r50_fpn_attention_1111_dcn_1x_coco_20200130-8b2523a6.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/empirical_attention/faster_rcnn_r50_fpn_attention_1111_dcn_1x_coco/faster_rcnn_r50_fpn_attention_1111_dcn_1x_coco_20200130_204442.log.json) | +| R-50 | 0010 | Y | 1x | 4.2 | 17.1 | 42.0 | [config](./faster-rcnn_r50-attn0010-dcn_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/empirical_attention/faster_rcnn_r50_fpn_attention_0010_dcn_1x_coco/faster_rcnn_r50_fpn_attention_0010_dcn_1x_coco_20200130-1a2e831d.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/empirical_attention/faster_rcnn_r50_fpn_attention_0010_dcn_1x_coco/faster_rcnn_r50_fpn_attention_0010_dcn_1x_coco_20200130_210410.log.json) | + +## Citation + +```latex +@article{zhu2019empirical, + title={An Empirical Study of Spatial Attention Mechanisms in Deep Networks}, + author={Zhu, Xizhou and Cheng, Dazhi and Zhang, Zheng and Lin, Stephen and Dai, Jifeng}, + journal={arXiv preprint arXiv:1904.05873}, + year={2019} +} +``` diff --git a/mmdetection/configs/empirical_attention/faster-rcnn_r50-attn0010-dcn_fpn_1x_coco.py b/mmdetection/configs/empirical_attention/faster-rcnn_r50-attn0010-dcn_fpn_1x_coco.py new file mode 100644 index 00000000..e1ae17a7 --- /dev/null +++ b/mmdetection/configs/empirical_attention/faster-rcnn_r50-attn0010-dcn_fpn_1x_coco.py @@ -0,0 +1,16 @@ +_base_ = '../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + plugins=[ + dict( + cfg=dict( + type='GeneralizedAttention', + spatial_range=-1, + num_heads=8, + attention_type='0010', + kv_stride=2), + stages=(False, False, True, True), + position='after_conv2') + ], + dcn=dict(type='DCN', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True))) diff --git a/mmdetection/configs/empirical_attention/faster-rcnn_r50-attn0010_fpn_1x_coco.py b/mmdetection/configs/empirical_attention/faster-rcnn_r50-attn0010_fpn_1x_coco.py new file mode 100644 index 00000000..7336d292 --- /dev/null +++ b/mmdetection/configs/empirical_attention/faster-rcnn_r50-attn0010_fpn_1x_coco.py @@ -0,0 +1,13 @@ +_base_ = '../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict(plugins=[ + dict( + cfg=dict( + type='GeneralizedAttention', + spatial_range=-1, + num_heads=8, + attention_type='0010', + kv_stride=2), + stages=(False, False, True, True), + position='after_conv2') + ])) diff --git a/mmdetection/configs/empirical_attention/faster-rcnn_r50-attn1111-dcn_fpn_1x_coco.py b/mmdetection/configs/empirical_attention/faster-rcnn_r50-attn1111-dcn_fpn_1x_coco.py new file mode 100644 index 00000000..980e23d4 --- /dev/null +++ b/mmdetection/configs/empirical_attention/faster-rcnn_r50-attn1111-dcn_fpn_1x_coco.py @@ -0,0 +1,16 @@ +_base_ = '../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + plugins=[ + dict( + cfg=dict( + type='GeneralizedAttention', + spatial_range=-1, + num_heads=8, + attention_type='1111', + kv_stride=2), + stages=(False, False, True, True), + position='after_conv2') + ], + dcn=dict(type='DCN', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True))) diff --git a/mmdetection/configs/empirical_attention/faster-rcnn_r50-attn1111_fpn_1x_coco.py b/mmdetection/configs/empirical_attention/faster-rcnn_r50-attn1111_fpn_1x_coco.py new file mode 100644 index 00000000..426bc09f --- /dev/null +++ b/mmdetection/configs/empirical_attention/faster-rcnn_r50-attn1111_fpn_1x_coco.py @@ -0,0 +1,13 @@ +_base_ = '../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict(plugins=[ + dict( + cfg=dict( + type='GeneralizedAttention', + spatial_range=-1, + num_heads=8, + attention_type='1111', + kv_stride=2), + stages=(False, False, True, True), + position='after_conv2') + ])) diff --git a/mmdetection/configs/empirical_attention/metafile.yml b/mmdetection/configs/empirical_attention/metafile.yml new file mode 100644 index 00000000..b488da7d --- /dev/null +++ b/mmdetection/configs/empirical_attention/metafile.yml @@ -0,0 +1,103 @@ +Collections: + - Name: Empirical Attention + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - Deformable Convolution + - FPN + - RPN + - ResNet + - RoIAlign + - Spatial Attention + Paper: + URL: https://arxiv.org/pdf/1904.05873 + Title: 'An Empirical Study of Spatial Attention Mechanisms in Deep Networks' + README: configs/empirical_attention/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/ops/generalized_attention.py#L10 + Version: v2.0.0 + +Models: + - Name: faster-rcnn_r50_fpn_attention_1111_1x_coco + In Collection: Empirical Attention + Config: configs/empirical_attention/faster-rcnn_r50-attn1111_fpn_1x_coco.py + Metadata: + Training Memory (GB): 8.0 + inference time (ms/im): + - value: 72.46 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/empirical_attention/faster_rcnn_r50_fpn_attention_1111_1x_coco/faster_rcnn_r50_fpn_attention_1111_1x_coco_20200130-403cccba.pth + + - Name: faster-rcnn_r50_fpn_attention_0010_1x_coco + In Collection: Empirical Attention + Config: configs/empirical_attention/faster-rcnn_r50-attn0010_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.2 + inference time (ms/im): + - value: 54.35 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/empirical_attention/faster_rcnn_r50_fpn_attention_0010_1x_coco/faster_rcnn_r50_fpn_attention_0010_1x_coco_20200130-7cb0c14d.pth + + - Name: faster-rcnn_r50_fpn_attention_1111_dcn_1x_coco + In Collection: Empirical Attention + Config: configs/empirical_attention/faster-rcnn_r50-attn1111-dcn_fpn_1x_coco.py + Metadata: + Training Memory (GB): 8.0 + inference time (ms/im): + - value: 78.74 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/empirical_attention/faster_rcnn_r50_fpn_attention_1111_dcn_1x_coco/faster_rcnn_r50_fpn_attention_1111_dcn_1x_coco_20200130-8b2523a6.pth + + - Name: faster-rcnn_r50_fpn_attention_0010_dcn_1x_coco + In Collection: Empirical Attention + Config: configs/empirical_attention/faster-rcnn_r50-attn0010-dcn_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.2 + inference time (ms/im): + - value: 58.48 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/empirical_attention/faster_rcnn_r50_fpn_attention_0010_dcn_1x_coco/faster_rcnn_r50_fpn_attention_0010_dcn_1x_coco_20200130-1a2e831d.pth diff --git a/mmdetection/configs/fast_rcnn/README.md b/mmdetection/configs/fast_rcnn/README.md new file mode 100644 index 00000000..0bdc9359 --- /dev/null +++ b/mmdetection/configs/fast_rcnn/README.md @@ -0,0 +1,121 @@ +# Fast R-CNN + +> [Fast R-CNN](https://arxiv.org/abs/1504.08083) + + + +## Abstract + +This paper proposes a Fast Region-based Convolutional Network method (Fast R-CNN) for object detection. Fast R-CNN builds on previous work to efficiently classify object proposals using deep convolutional networks. Compared to previous work, Fast R-CNN employs several innovations to improve training and testing speed while also increasing detection accuracy. Fast R-CNN trains the very deep VGG16 network 9x faster than R-CNN, is 213x faster at test-time, and achieves a higher mAP on PASCAL VOC 2012. Compared to SPPnet, Fast R-CNN trains VGG16 3x faster, tests 10x faster, and is more accurate. + +
    + +
    + +## Introduction + +Before training the Fast R-CNN, users should first train an [RPN](../rpn/README.md), and use the RPN to extract the region proposals. +The region proposals can be obtained by setting `DumpProposals` pseudo metric. The dumped results is a `dict(file_name: pred_instance)`. +The `pred_instance` is an `InstanceData` containing the sorted boxes and scores predicted by RPN. We provide example of dumping proposals in [RPN config](../rpn/rpn_r50_fpn_1x_coco.py). + +- First, it should be obtained the region proposals in both training and validation (or testing) set. + change the type of `test_evaluator` to `DumpProposals` in the RPN config to get the region proposals as below: + + The config of get training image region proposals can be set as below: + + ```python + # For training set + val_dataloader = dict( + dataset=dict( + ann_file='data/coco/annotations/instances_train2017.json', + data_prefix=dict(img='val2017/'))) + val_dataloader = dict( + _delete_=True, + type='DumpProposals', + output_dir='data/coco/proposals/', + proposals_file='rpn_r50_fpn_1x_train2017.pkl') + test_dataloader = val_dataloader + test_evaluator = val_dataloader + ``` + + The config of get validation image region proposals can be set as below: + + ```python + # For validation set + val_dataloader = dict( + _delete_=True, + type='DumpProposals', + output_dir='data/coco/proposals/', + proposals_file='rpn_r50_fpn_1x_val2017.pkl') + test_evaluator = val_dataloader + ``` + + Extract the region proposals command can be set as below: + + ```bash + ./tools/dist_test.sh \ + configs/rpn_r50_fpn_1x_coco.py \ + checkpoints/rpn_r50_fpn_1x_coco_20200218-5525fa2e.pth \ + 8 + ``` + + Users can refer to [test tutorial](https://mmdetection.readthedocs.io/en/latest/user_guides/test.html) for more details. + +- Then, modify the path of `proposal_file` in the dataset and using `ProposalBroadcaster` to process both ground truth bounding boxes and region proposals in pipelines. + An example of Fast R-CNN important setting can be seen as below: + + ```python + train_pipeline = [ + dict( + type='LoadImageFromFile', + backend_args={{_base_.backend_args}}), + dict(type='LoadProposals', num_max_proposals=2000), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='ProposalBroadcaster', + transforms=[ + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + ]), + dict(type='PackDetInputs') + ] + test_pipeline = [ + dict( + type='LoadImageFromFile', + backend_args={{_base_.backend_args}}), + dict(type='LoadProposals', num_max_proposals=None), + dict( + type='ProposalBroadcaster', + transforms=[ + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + ]), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) + ] + train_dataloader = dict( + dataset=dict( + proposal_file='proposals/rpn_r50_fpn_1x_train2017.pkl', + pipeline=train_pipeline)) + val_dataloader = dict( + dataset=dict( + proposal_file='proposals/rpn_r50_fpn_1x_val2017.pkl', + pipeline=test_pipeline)) + test_dataloader = val_dataloader + ``` + +- Finally, users can start training the Fast R-CNN. + +## Results and Models + +## Citation + +```latex +@inproceedings{girshick2015fast, + title={Fast r-cnn}, + author={Girshick, Ross}, + booktitle={Proceedings of the IEEE international conference on computer vision}, + year={2015} +} +``` diff --git a/mmdetection/configs/fast_rcnn/fast-rcnn_r101-caffe_fpn_1x_coco.py b/mmdetection/configs/fast_rcnn/fast-rcnn_r101-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..02c70296 --- /dev/null +++ b/mmdetection/configs/fast_rcnn/fast-rcnn_r101-caffe_fpn_1x_coco.py @@ -0,0 +1,7 @@ +_base_ = './fast-rcnn_r50-caffe_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet101_caffe'))) diff --git a/mmdetection/configs/fast_rcnn/fast-rcnn_r101_fpn_1x_coco.py b/mmdetection/configs/fast_rcnn/fast-rcnn_r101_fpn_1x_coco.py new file mode 100644 index 00000000..5af6b223 --- /dev/null +++ b/mmdetection/configs/fast_rcnn/fast-rcnn_r101_fpn_1x_coco.py @@ -0,0 +1,6 @@ +_base_ = './fast-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/fast_rcnn/fast-rcnn_r101_fpn_2x_coco.py b/mmdetection/configs/fast_rcnn/fast-rcnn_r101_fpn_2x_coco.py new file mode 100644 index 00000000..73425cf1 --- /dev/null +++ b/mmdetection/configs/fast_rcnn/fast-rcnn_r101_fpn_2x_coco.py @@ -0,0 +1,6 @@ +_base_ = './fast-rcnn_r50_fpn_2x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/fast_rcnn/fast-rcnn_r50-caffe_fpn_1x_coco.py b/mmdetection/configs/fast_rcnn/fast-rcnn_r50-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..3110f9fd --- /dev/null +++ b/mmdetection/configs/fast_rcnn/fast-rcnn_r50-caffe_fpn_1x_coco.py @@ -0,0 +1,16 @@ +_base_ = './fast-rcnn_r50_fpn_1x_coco.py' + +model = dict( + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False, + pad_size_divisor=32), + backbone=dict( + norm_cfg=dict(type='BN', requires_grad=False), + style='caffe', + norm_eval=True, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe'))) diff --git a/mmdetection/configs/fast_rcnn/fast-rcnn_r50_fpn_1x_coco.py b/mmdetection/configs/fast_rcnn/fast-rcnn_r50_fpn_1x_coco.py new file mode 100644 index 00000000..daefe2d2 --- /dev/null +++ b/mmdetection/configs/fast_rcnn/fast-rcnn_r50_fpn_1x_coco.py @@ -0,0 +1,39 @@ +_base_ = [ + '../_base_/models/fast-rcnn_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadProposals', num_max_proposals=2000), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='ProposalBroadcaster', + transforms=[ + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + ]), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadProposals', num_max_proposals=None), + dict( + type='ProposalBroadcaster', + transforms=[ + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + ]), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict( + dataset=dict( + proposal_file='proposals/rpn_r50_fpn_1x_train2017.pkl', + pipeline=train_pipeline)) +val_dataloader = dict( + dataset=dict( + proposal_file='proposals/rpn_r50_fpn_1x_val2017.pkl', + pipeline=test_pipeline)) +test_dataloader = val_dataloader diff --git a/mmdetection/configs/fast_rcnn/fast-rcnn_r50_fpn_2x_coco.py b/mmdetection/configs/fast_rcnn/fast-rcnn_r50_fpn_2x_coco.py new file mode 100644 index 00000000..d609a7c0 --- /dev/null +++ b/mmdetection/configs/fast_rcnn/fast-rcnn_r50_fpn_2x_coco.py @@ -0,0 +1,14 @@ +_base_ = './fast-rcnn_r50_fpn_1x_coco.py' + +train_cfg = dict(max_epochs=24) +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=24, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/faster_rcnn/README.md b/mmdetection/configs/faster_rcnn/README.md new file mode 100644 index 00000000..8bcdcf6d --- /dev/null +++ b/mmdetection/configs/faster_rcnn/README.md @@ -0,0 +1,88 @@ +# Faster R-CNN + +> [Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks](https://arxiv.org/abs/1506.01497) + + + +## Abstract + +State-of-the-art object detection networks depend on region proposal algorithms to hypothesize object locations. Advances like SPPnet and Fast R-CNN have reduced the running time of these detection networks, exposing region proposal computation as a bottleneck. In this work, we introduce a Region Proposal Network (RPN) that shares full-image convolutional features with the detection network, thus enabling nearly cost-free region proposals. An RPN is a fully convolutional network that simultaneously predicts object bounds and objectness scores at each position. The RPN is trained end-to-end to generate high-quality region proposals, which are used by Fast R-CNN for detection. We further merge RPN and Fast R-CNN into a single network by sharing their convolutional features---using the recently popular terminology of neural networks with 'attention' mechanisms, the RPN component tells the unified network where to look. For the very deep VGG-16 model, our detection system has a frame rate of 5fps (including all steps) on a GPU, while achieving state-of-the-art object detection accuracy on PASCAL VOC 2007, 2012, and MS COCO datasets with only 300 proposals per image. In ILSVRC and COCO 2015 competitions, Faster R-CNN and RPN are the foundations of the 1st-place winning entries in several tracks. + +
    + +
    + +## Results and Models + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :-------------: | :-----: | :-----: | :------: | :------------: | :----: | :-----------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-C4 | caffe | 1x | - | - | 35.6 | [config](./faster-rcnn_r50-caffe_c4-1x_coco.py) | [model](https://download.openxlab.org.cn/models/mmdetection/FasterR-CNN/weight/faster-rcnn_r50-caffe-c4_1x_coco) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_caffe_c4_1x_coco/faster_rcnn_r50_caffe_c4_1x_coco_20220316_150152.log.json) | +| R-50-DC5 | caffe | 1x | - | - | 37.2 | [config](./faster-rcnn_r50-caffe-dc5_1x_coco.py) | [model](https://download.openxlab.org.cn/models/mmdetection/FasterR-CNN/weight/faster-rcnn_r50-caffe-dc5_1x_coco) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_caffe_dc5_1x_coco/faster_rcnn_r50_caffe_dc5_1x_coco_20201030_151909.log.json) | +| R-50-FPN | caffe | 1x | 3.8 | | 37.8 | [config](./faster-rcnn_r50-caffe_fpn_1x_coco.py) | [model](https://download.openxlab.org.cn/models/mmdetection/FasterR-CNN/weight/faster-rcnn_r50-caffe_fpn_1x_coco) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_caffe_fpn_1x_coco/faster_rcnn_r50_caffe_fpn_1x_coco_20200504_180032.log.json) | +| R-50-FPN | pytorch | 1x | 4.0 | 21.4 | 37.4 | [config](./faster-rcnn_r50_fpn_1x_coco.py) | [model](https://download.openxlab.org.cn/models/mmdetection/FasterR-CNN/weight/faster-rcnn_r50_fpn_1x_coco) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_1x_coco_20200130_204655.log.json) | +| R-50-FPN (FP16) | pytorch | 1x | 3.4 | 28.8 | 37.5 | [config](./faster-rcnn_r50_fpn_amp-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/fp16/faster_rcnn_r50_fpn_fp16_1x_coco/faster_rcnn_r50_fpn_fp16_1x_coco_20200204-d4dc1471.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/fp16/faster_rcnn_r50_fpn_fp16_1x_coco/faster_rcnn_r50_fpn_fp16_1x_coco_20200204_143530.log.json) | +| R-50-FPN | pytorch | 2x | - | - | 38.4 | [config](./faster-rcnn_r50_fpn_2x_coco.py) | [model](https://download.openxlab.org.cn/models/mmdetection/FasterR-CNN/weight/faster-rcnn_r50_fpn_2x_coco) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_2x_coco/faster_rcnn_r50_fpn_2x_coco_20200504_210434.log.json) | +| R-101-FPN | caffe | 1x | 5.7 | | 39.8 | [config](./faster-rcnn_r101-caffe_fpn_1x_coco.py) | [model](https://download.openxlab.org.cn/models/mmdetection/FasterR-CNN/weight/faster-rcnn_r101-caffe_fpn_1x_coco) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r101_caffe_fpn_1x_coco/faster_rcnn_r101_caffe_fpn_1x_coco_20200504_180057.log.json) | +| R-101-FPN | pytorch | 1x | 6.0 | 15.6 | 39.4 | [config](./faster-rcnn_r101_fpn_1x_coco.py) | [model](https://download.openxlab.org.cn/models/mmdetection/FasterR-CNN/weight/faster-rcnn_r101_fpn_1x_coco) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r101_fpn_1x_coco/faster_rcnn_r101_fpn_1x_coco_20200130_204655.log.json) | +| R-101-FPN | pytorch | 2x | - | - | 39.8 | [config](./faster-rcnn_r101_fpn_2x_coco.py) | [model](https://download.openxlab.org.cn/models/mmdetection/FasterR-CNN/weight/faster-rcnn_r101_fpn_2x_coco) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r101_fpn_2x_coco/faster_rcnn_r101_fpn_2x_coco_20200504_210455.log.json) | +| X-101-32x4d-FPN | pytorch | 1x | 7.2 | 13.8 | 41.2 | [config](./faster-rcnn_x101-32x4d_fpn_1x_coco.py) | [model](https://download.openxlab.org.cn/models/mmdetection/FasterR-CNN/weight/faster-rcnn_x101-32x4d_fpn_1x_coco) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_x101_32x4d_fpn_1x_coco/faster_rcnn_x101_32x4d_fpn_1x_coco_20200203_000520.log.json) | +| X-101-32x4d-FPN | pytorch | 2x | - | - | 41.2 | [config](./faster-rcnn_x101-32x4d_fpn_2x_coco.py) | [model](https://download.openxlab.org.cn/models/mmdetection/FasterR-CNN/weight/faster-rcnn_x101-32x4d_fpn_2x_coco) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_x101_32x4d_fpn_2x_coco/faster_rcnn_x101_32x4d_fpn_2x_coco_20200506_041400.log.json) | +| X-101-64x4d-FPN | pytorch | 1x | 10.3 | 9.4 | 42.1 | [config](./faster-rcnn_x101-64x4d_fpn_1x_coco.py) | [model](https://download.openxlab.org.cn/models/mmdetection/FasterR-CNN/weight/faster-rcnn_x101-64x4d_fpn_1x_coco) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_x101_64x4d_fpn_1x_coco/faster_rcnn_x101_64x4d_fpn_1x_coco_20200204_134340.log.json) | +| X-101-64x4d-FPN | pytorch | 2x | - | - | 41.6 | [config](./faster-rcnn_x101-64x4d_fpn_2x_coco.py) | [model](https://download.openxlab.org.cn/models/mmdetection/FasterR-CNN/weight/faster-rcnn_x101-64x4d_fpn_2x_coco) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_x101_64x4d_fpn_2x_coco/faster_rcnn_x101_64x4d_fpn_2x_coco_20200512_161033.log.json) | + +## Different regression loss + +We trained with R-50-FPN pytorch style backbone for 1x schedule. + +| Backbone | Loss type | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :------: | :------------: | :------: | :------------: | :----: | :----------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | L1Loss | 4.0 | 21.4 | 37.4 | [config](./faster-rcnn_r50_fpn_1x_coco.py) | [model](https://download.openxlab.org.cn/models/mmdetection/FasterR-CNN/weight/faster-rcnn_r50_fpn_1x_coco) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_1x_coco_20200130_204655.log.json) | +| R-50-FPN | IoULoss | | | 37.9 | [config](./faster-rcnn_r50_fpn_iou_1x_coco.py) | [model](https://download.openxlab.org.cn/models/mmdetection/FasterR-CNN/weight/faster-rcnn_r50_fpn_iou_1x_coco) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_iou_1x_coco/faster_rcnn_r50_fpn_iou_1x_coco_20200506_095954.log.json) | +| R-50-FPN | GIoULoss | | | 37.6 | [config](./faster-rcnn_r50_fpn_giou_1x_coco.py) | [model](https://download.openxlab.org.cn/models/mmdetection/FasterR-CNN/weight/faster-rcnn_r50_fpn_giou_1x_coco) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_giou_1x_coco_20200505_161120.log.json) | +| R-50-FPN | BoundedIoULoss | | | 37.4 | [config](./faster-rcnn_r50_fpn_bounded-iou_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_bounded_iou_1x_coco-98ad993b.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_bounded_iou_1x_coco_20200505_160738.log.json) | + +## Pre-trained Models + +We also train some models with longer schedules and multi-scale training. The users could finetune them for downstream tasks. + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :-----------------------------------------------------------: | :-----: | :-----: | :------: | :------------: | :----: | :--------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| [R-50-C4](./faster-rcnn_r50-caffe-c4_ms-1x_coco.py) | caffe | 1x | - | | 35.9 | [config](./faster-rcnn_r50-caffe-c4_ms-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_caffe_c4_mstrain_1x_coco/faster_rcnn_r50_caffe_c4_mstrain_1x_coco_20220316_150527-db276fed.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_caffe_c4_mstrain_1x_coco/faster_rcnn_r50_caffe_c4_mstrain_1x_coco_20220316_150527.log.json) | +| [R-50-DC5](./faster-rcnn_r50-caffe-dc5_ms-1x_coco.py) | caffe | 1x | - | | 37.4 | [config](./faster-rcnn_r50-caffe-dc5_ms-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_caffe_dc5_mstrain_1x_coco/faster_rcnn_r50_caffe_dc5_mstrain_1x_coco_20201028_233851-b33d21b9.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_caffe_dc5_mstrain_1x_coco/faster_rcnn_r50_caffe_dc5_mstrain_1x_coco_20201028_233851.log.json) | +| [R-50-DC5](./faster-rcnn_r50-caffe-dc5_ms-3x_coco.py) | caffe | 3x | - | | 38.7 | [config](./faster-rcnn_r50-caffe-dc5_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_caffe_dc5_mstrain_3x_coco/faster_rcnn_r50_caffe_dc5_mstrain_3x_coco_20201028_002107-34a53b2c.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_caffe_dc5_mstrain_3x_coco/faster_rcnn_r50_caffe_dc5_mstrain_3x_coco_20201028_002107.log.json) | +| [R-50-FPN](./faster-rcnn_r50-caffe_fpn_ms-2x_coco.py) | caffe | 2x | 3.7 | | 39.7 | [config](./faster-rcnn_r50-caffe_fpn_ms-2x_coco.py) | [model](https://download.openxlab.org.cn/models/mmdetection/FasterR-CNN/weight/faster-rcnn_r50-caffe_fpn_ms-2x_coco) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_caffe_fpn_mstrain_2x_coco/faster_rcnn_r50_caffe_fpn_mstrain_2x_coco_20200504_231813.log.json) | +| [R-50-FPN](./faster-rcnn_r50-caffe_fpn_ms-3x_coco.py) | caffe | 3x | 3.7 | | 39.9 | [config](./faster-rcnn_r50-caffe_fpn_ms-3x_coco.py) | [model](https://download.openxlab.org.cn/models/mmdetection/FasterR-CNN/weight/faster-rcnn_r50-caffe_fpn_ms-3x_coco) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_caffe_fpn_mstrain_3x_coco/faster_rcnn_r50_caffe_fpn_mstrain_3x_coco_20210526_095054.log.json) | +| [R-50-FPN](./faster-rcnn_r50_fpn_ms-3x_coco.py) | pytorch | 3x | 3.9 | | 40.3 | [config](./faster-rcnn_r50_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_mstrain_3x_coco/faster_rcnn_r50_fpn_mstrain_3x_coco_20210524_110822-e10bd31c.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_mstrain_3x_coco/faster_rcnn_r50_fpn_mstrain_3x_coco_20210524_110822.log.json) | +| [R-101-FPN](./faster-rcnn_r101-caffe_fpn_ms-3x_coco.py) | caffe | 3x | 5.6 | | 42.0 | [config](./faster-rcnn_r101-caffe_fpn_ms-3x_coco.py) | [model](https://download.openxlab.org.cn/models/mmdetection/FasterR-CNN/weight/faster-rcnn_r101-caffe_fpn_ms-3x_coco) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r101_caffe_fpn_mstrain_3x_coco/faster_rcnn_r101_caffe_fpn_mstrain_3x_coco_20210526_095742.log.json) | +| [R-101-FPN](./faster-rcnn_r101_fpn_ms-3x_coco.py) | pytorch | 3x | 5.8 | | 41.8 | [config](./faster-rcnn_r101_fpn_ms-3x_coco.py) | [model](https://download.openxlab.org.cn/models/mmdetection/FasterR-CNN/weight/faster-rcnn_r101_fpn_ms-3x_coco) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r101_fpn_mstrain_3x_coco/faster_rcnn_r101_fpn_mstrain_3x_coco_20210524_110822.log.json) | +| [X-101-32x4d-FPN](./faster-rcnn_x101-32x4d_fpn_ms-3x_coco.py) | pytorch | 3x | 7.0 | | 42.5 | [config](./faster-rcnn_x101-32x4d_fpn_ms-3x_coco.py) | [model](https://download.openxlab.org.cn/models/mmdetection/FasterR-CNN/weight/faster-rcnn_x101-32x4d_fpn_ms-3x_coco) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_x101_32x4d_fpn_mstrain_3x_coco/faster_rcnn_x101_32x4d_fpn_mstrain_3x_coco_20210524_124151.log.json) | +| [X-101-32x8d-FPN](./faster-rcnn_x101-32x8d_fpn_ms-3x_coco.py) | pytorch | 3x | 10.1 | | 42.4 | [config](./faster-rcnn_x101-32x8d_fpn_ms-3x_coco.py) | [model](https://download.openxlab.org.cn/models/mmdetection/FasterR-CNN/weight/faster-rcnn_x101-32x8d_fpn_ms-3x_coco) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_x101_32x8d_fpn_mstrain_3x_coco/faster_rcnn_x101_32x8d_fpn_mstrain_3x_coco_20210604_182954.log.json) | +| [X-101-64x4d-FPN](./faster-rcnn_x101-64x4d_fpn_ms-3x_coco.py) | pytorch | 3x | 10.0 | | 43.1 | [config](./faster-rcnn_x101-64x4d_fpn_ms-3x_coco.py) | [model](https://download.openxlab.org.cn/models/mmdetection/FasterR-CNN/weight/faster-rcnn_x101-64x4d_fpn_ms-3x_coco) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_x101_64x4d_fpn_mstrain_3x_coco/faster_rcnn_x101_64x4d_fpn_mstrain_3x_coco_20210524_124528.log.json) | + +We further finetune some pre-trained models on the COCO subsets, which only contain only a few of the 80 categories. + +| Backbone | Style | Class name | Pre-traind model | Mem (GB) | box AP | Config | Download | +| ------------------------------------------------------------------------ | ----- | ------------------ | -------------------------------------------------------------- | -------- | ------ | ---------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| [R-50-FPN](./faster-rcnn_r50-caffe_fpn_ms-1x_coco-person.py) | caffe | person | [R-50-FPN-Caffe-3x](./faster-rcnn_r50-caffe_fpn_ms-3x_coco.py) | 3.7 | 55.8 | [config](./faster-rcnn_r50-caffe_fpn_ms-1x_coco-person.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco-person/faster_rcnn_r50_fpn_1x_coco-person_20201216_175929-d022e227.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco-person/faster_rcnn_r50_fpn_1x_coco-person_20201216_175929.log.json) | +| [R-50-FPN](./faster-rcnn_r50-caffe_fpn_ms-1x_coco-person-bicycle-car.py) | caffe | person-bicycle-car | [R-50-FPN-Caffe-3x](./faster-rcnn_r50-caffe_fpn_ms-3x_coco.py) | 3.7 | 44.1 | [config](./faster-rcnn_r50-caffe_fpn_ms-1x_coco-person-bicycle-car.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco-person-bicycle-car/faster_rcnn_r50_fpn_1x_coco-person-bicycle-car_20201216_173117-6eda6d92.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco-person-bicycle-car/faster_rcnn_r50_fpn_1x_coco-person-bicycle-car_20201216_173117.log.json) | + +## Torchvision New Receipe (TNR) + +Torchvision released its high-precision ResNet models. The training details can be found on the [Pytorch website](https://pytorch.org/blog/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives/). Here, we have done grid searches on learning rate and weight decay and found the optimal hyper-parameter on the detection task. + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :--------------------------------------------------: | :-----: | :-----: | :------: | :------------: | :----: | :------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| [R-50-TNR](./faster-rcnn_r50-tnr-pre_fpn_1x_coco.py) | pytorch | 1x | - | | 40.2 | [config](./faster-rcnn_r50-tnr-pre_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_tnr-pretrain_1x_coco/faster_rcnn_r50_fpn_tnr-pretrain_1x_coco_20220320_085147-efedfda4.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_tnr-pretrain_1x_coco/faster_rcnn_r50_fpn_tnr-pretrain_1x_coco_20220320_085147.log.json) | + +## Citation + +```latex +@article{Ren_2017, + title={Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks}, + journal={IEEE Transactions on Pattern Analysis and Machine Intelligence}, + publisher={Institute of Electrical and Electronics Engineers (IEEE)}, + author={Ren, Shaoqing and He, Kaiming and Girshick, Ross and Sun, Jian}, + year={2017}, + month={Jun}, +} +``` diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r101-caffe_fpn_1x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r101-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..a18f1ada --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r101-caffe_fpn_1x_coco.py @@ -0,0 +1,7 @@ +_base_ = './faster-rcnn_r50-caffe_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet101_caffe'))) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r101-caffe_fpn_ms-3x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r101-caffe_fpn_ms-3x_coco.py new file mode 100644 index 00000000..1cdb4d49 --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r101-caffe_fpn_ms-3x_coco.py @@ -0,0 +1,11 @@ +_base_ = 'faster-rcnn_r50_fpn_ms-3x_coco.py' + +model = dict( + backbone=dict( + depth=101, + norm_cfg=dict(requires_grad=False), + norm_eval=True, + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet101_caffe'))) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r101_fpn_1x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r101_fpn_1x_coco.py new file mode 100644 index 00000000..d113ae62 --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r101_fpn_1x_coco.py @@ -0,0 +1,6 @@ +_base_ = './faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r101_fpn_2x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r101_fpn_2x_coco.py new file mode 100644 index 00000000..b471fb3c --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r101_fpn_2x_coco.py @@ -0,0 +1,6 @@ +_base_ = './faster-rcnn_r50_fpn_2x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r101_fpn_8xb8-amp-lsj-200e_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r101_fpn_8xb8-amp-lsj-200e_coco.py new file mode 100644 index 00000000..a71d4afd --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r101_fpn_8xb8-amp-lsj-200e_coco.py @@ -0,0 +1,7 @@ +_base_ = './faster-rcnn_r50_fpn_8xb8-amp-lsj-200e_coco.py' + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r101_fpn_ms-3x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r101_fpn_ms-3x_coco.py new file mode 100644 index 00000000..8ef6d1f8 --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r101_fpn_ms-3x_coco.py @@ -0,0 +1,7 @@ +_base_ = 'faster-rcnn_r50_fpn_ms-3x_coco.py' + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r18_fpn_8xb8-amp-lsj-200e_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r18_fpn_8xb8-amp-lsj-200e_coco.py new file mode 100644 index 00000000..65515c9a --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r18_fpn_8xb8-amp-lsj-200e_coco.py @@ -0,0 +1,7 @@ +_base_ = './faster-rcnn_r50_fpn_8xb8-amp-lsj-200e_coco.py' + +model = dict( + backbone=dict( + depth=18, + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet18')), + neck=dict(in_channels=[64, 128, 256, 512])) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe-c4_ms-1x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe-c4_ms-1x_coco.py new file mode 100644 index 00000000..7e231e86 --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe-c4_ms-1x_coco.py @@ -0,0 +1,14 @@ +_base_ = './faster-rcnn_r50-caffe_c4-1x_coco.py' + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736), + (1333, 768), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +_base_.train_dataloader.dataset.pipeline = train_pipeline diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe-dc5_1x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe-dc5_1x_coco.py new file mode 100644 index 00000000..8952a5c9 --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe-dc5_1x_coco.py @@ -0,0 +1,5 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50-caffe-dc5.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe-dc5_ms-1x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe-dc5_ms-1x_coco.py new file mode 100644 index 00000000..63a68859 --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe-dc5_ms-1x_coco.py @@ -0,0 +1,14 @@ +_base_ = 'faster-rcnn_r50-caffe-dc5_1x_coco.py' + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736), + (1333, 768), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +_base_.train_dataloader.dataset.pipeline = train_pipeline diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe-dc5_ms-3x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe-dc5_ms-3x_coco.py new file mode 100644 index 00000000..27063468 --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe-dc5_ms-3x_coco.py @@ -0,0 +1,18 @@ +_base_ = './faster-rcnn_r50-caffe-dc5_ms-1x_coco.py' + +# MMEngine support the following two ways, users can choose +# according to convenience +# param_scheduler = [ +# dict( +# type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), # noqa +# dict( +# type='MultiStepLR', +# begin=0, +# end=12, +# by_epoch=True, +# milestones=[28, 34], +# gamma=0.1) +# ] +_base_.param_scheduler[1].milestones = [28, 34] + +train_cfg = dict(max_epochs=36) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_c4-1x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_c4-1x_coco.py new file mode 100644 index 00000000..0888fc01 --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_c4-1x_coco.py @@ -0,0 +1,5 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50-caffe-c4.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_1x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..9129a958 --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_1x_coco.py @@ -0,0 +1,15 @@ +_base_ = './faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False, + pad_size_divisor=32), + backbone=dict( + norm_cfg=dict(requires_grad=False), + norm_eval=True, + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe'))) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_90k_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_90k_coco.py new file mode 100644 index 00000000..27f49355 --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_90k_coco.py @@ -0,0 +1,22 @@ +_base_ = 'faster-rcnn_r50-caffe_fpn_1x_coco.py' +max_iter = 90000 + +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_iter, + by_epoch=False, + milestones=[60000, 80000], + gamma=0.1) +] + +train_cfg = dict( + _delete_=True, + type='IterBasedTrainLoop', + max_iters=max_iter, + val_interval=10000) +default_hooks = dict(checkpoint=dict(by_epoch=False, interval=10000)) +log_processor = dict(by_epoch=False) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_ms-1x_coco-person-bicycle-car.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_ms-1x_coco-person-bicycle-car.py new file mode 100644 index 00000000..f36bb055 --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_ms-1x_coco-person-bicycle-car.py @@ -0,0 +1,16 @@ +_base_ = './faster-rcnn_r50-caffe_fpn_ms-1x_coco.py' +model = dict(roi_head=dict(bbox_head=dict(num_classes=3))) +metainfo = { + 'classes': ('person', 'bicycle', 'car'), + 'palette': [ + (220, 20, 60), + (119, 11, 32), + (0, 0, 142), + ] +} + +train_dataloader = dict(dataset=dict(metainfo=metainfo)) +val_dataloader = dict(dataset=dict(metainfo=metainfo)) +test_dataloader = dict(dataset=dict(metainfo=metainfo)) + +load_from = 'https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_caffe_fpn_mstrain_3x_coco/faster_rcnn_r50_caffe_fpn_mstrain_3x_coco_bbox_mAP-0.398_20200504_163323-30042637.pth' # noqa diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_ms-1x_coco-person.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_ms-1x_coco-person.py new file mode 100644 index 00000000..9528b63f --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_ms-1x_coco-person.py @@ -0,0 +1,14 @@ +_base_ = './faster-rcnn_r50-caffe_fpn_ms-1x_coco.py' +model = dict(roi_head=dict(bbox_head=dict(num_classes=1))) +metainfo = { + 'classes': ('person', ), + 'palette': [ + (220, 20, 60), + ] +} + +train_dataloader = dict(dataset=dict(metainfo=metainfo)) +val_dataloader = dict(dataset=dict(metainfo=metainfo)) +test_dataloader = dict(dataset=dict(metainfo=metainfo)) + +load_from = 'https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_caffe_fpn_mstrain_3x_coco/faster_rcnn_r50_caffe_fpn_mstrain_3x_coco_bbox_mAP-0.398_20200504_163323-30042637.pth' # noqa diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_ms-1x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_ms-1x_coco.py new file mode 100644 index 00000000..59f1633c --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_ms-1x_coco.py @@ -0,0 +1,31 @@ +_base_ = './faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False, + pad_size_divisor=32), + backbone=dict( + norm_cfg=dict(requires_grad=False), + norm_eval=True, + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe'))) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736), + (1333, 768), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +# MMEngine support the following two ways, users can choose +# according to convenience +# train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +_base_.train_dataloader.dataset.pipeline = train_pipeline diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_ms-2x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_ms-2x_coco.py new file mode 100644 index 00000000..44d320ea --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_ms-2x_coco.py @@ -0,0 +1,18 @@ +_base_ = './faster-rcnn_r50-caffe_fpn_ms-1x_coco.py' + +# MMEngine support the following two ways, users can choose +# according to convenience +# param_scheduler = [ +# dict( +# type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), # noqa +# dict( +# type='MultiStepLR', +# begin=0, +# end=12, +# by_epoch=True, +# milestones=[16, 23], +# gamma=0.1) +# ] +_base_.param_scheduler[1].milestones = [16, 23] + +train_cfg = dict(max_epochs=24) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_ms-3x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_ms-3x_coco.py new file mode 100644 index 00000000..365f6439 --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_ms-3x_coco.py @@ -0,0 +1,15 @@ +_base_ = 'faster-rcnn_r50_fpn_ms-3x_coco.py' +model = dict( + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False, + pad_size_divisor=32), + backbone=dict( + norm_cfg=dict(requires_grad=False), + norm_eval=True, + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe'))) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_ms-90k_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_ms-90k_coco.py new file mode 100644 index 00000000..6b9b3eb0 --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_ms-90k_coco.py @@ -0,0 +1,23 @@ +_base_ = 'faster-rcnn_r50-caffe_fpn_ms-1x_coco.py' + +max_iter = 90000 + +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_iter, + by_epoch=False, + milestones=[60000, 80000], + gamma=0.1) +] + +train_cfg = dict( + _delete_=True, + type='IterBasedTrainLoop', + max_iters=max_iter, + val_interval=10000) +default_hooks = dict(checkpoint=dict(by_epoch=False, interval=10000)) +log_processor = dict(by_epoch=False) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50-tnr-pre_fpn_1x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-tnr-pre_fpn_1x_coco.py new file mode 100644 index 00000000..7b3e5ded --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50-tnr-pre_fpn_1x_coco.py @@ -0,0 +1,14 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +checkpoint = 'https://download.pytorch.org/models/resnet50-11ad3fa6.pth' +model = dict( + backbone=dict(init_cfg=dict(type='Pretrained', checkpoint=checkpoint))) + +# `lr` and `weight_decay` have been searched to be optimal. +optim_wrapper = dict( + optimizer=dict(_delete_=True, type='AdamW', lr=0.0001, weight_decay=0.1), + paramwise_cfg=dict(norm_decay_mult=0., bypass_duplicate=True)) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py new file mode 100644 index 00000000..8a45417f --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py @@ -0,0 +1,5 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_2x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_2x_coco.py new file mode 100644 index 00000000..2981c6fb --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_2x_coco.py @@ -0,0 +1,5 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_2x.py', '../_base_/default_runtime.py' +] diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_8xb8-amp-lsj-200e_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_8xb8-amp-lsj-200e_coco.py new file mode 100644 index 00000000..3d366f3b --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_8xb8-amp-lsj-200e_coco.py @@ -0,0 +1,20 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../common/lsj-200e_coco-detection.py' +] +image_size = (1024, 1024) +batch_augments = [dict(type='BatchFixedSizePad', size=image_size)] + +model = dict(data_preprocessor=dict(batch_augments=batch_augments)) + +train_dataloader = dict(batch_size=8, num_workers=4) +# Enable automatic-mixed-precision training with AmpOptimWrapper. +optim_wrapper = dict( + type='AmpOptimWrapper', + optimizer=dict( + type='SGD', lr=0.02 * 4, momentum=0.9, weight_decay=0.00004)) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (8 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_amp-1x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_amp-1x_coco.py new file mode 100644 index 00000000..f765deae --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_amp-1x_coco.py @@ -0,0 +1,6 @@ +_base_ = './faster-rcnn_r50_fpn_1x_coco.py' + +# MMEngine support the following two ways, users can choose +# according to convenience +# optim_wrapper = dict(type='AmpOptimWrapper') +_base_.optim_wrapper.type = 'AmpOptimWrapper' diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_bounded-iou_1x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_bounded-iou_1x_coco.py new file mode 100644 index 00000000..7758ca80 --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_bounded-iou_1x_coco.py @@ -0,0 +1,6 @@ +_base_ = './faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + roi_head=dict( + bbox_head=dict( + reg_decoded_bbox=True, + loss_bbox=dict(type='BoundedIoULoss', loss_weight=10.0)))) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_ciou_1x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_ciou_1x_coco.py new file mode 100644 index 00000000..e8d8a304 --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_ciou_1x_coco.py @@ -0,0 +1,6 @@ +_base_ = './faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + roi_head=dict( + bbox_head=dict( + reg_decoded_bbox=True, + loss_bbox=dict(type='CIoULoss', loss_weight=12.0)))) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_fcos-rpn_1x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_fcos-rpn_1x_coco.py new file mode 100644 index 00000000..b5a34d9f --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_fcos-rpn_1x_coco.py @@ -0,0 +1,48 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +model = dict( + # copied from configs/fcos/fcos_r50-caffe_fpn_gn-head_1x_coco.py + neck=dict( + start_level=1, + add_extra_convs='on_output', # use P5 + relu_before_extra_convs=True), + rpn_head=dict( + _delete_=True, # ignore the unused old settings + type='FCOSHead', + # num_classes = 1 for rpn, + # if num_classes > 1, it will be set to 1 in + # TwoStageDetector automatically + num_classes=1, + in_channels=256, + stacked_convs=4, + feat_channels=256, + strides=[8, 16, 32, 64, 128], + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='IoULoss', loss_weight=1.0), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)), + roi_head=dict( # update featmap_strides + bbox_roi_extractor=dict(featmap_strides=[8, 16, 32, 64, 128]))) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, + end=1000), # Slowly increase lr, otherwise loss becomes NAN + dict( + type='MultiStepLR', + begin=0, + end=12, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_giou_1x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_giou_1x_coco.py new file mode 100644 index 00000000..82b71d77 --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_giou_1x_coco.py @@ -0,0 +1,6 @@ +_base_ = './faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + roi_head=dict( + bbox_head=dict( + reg_decoded_bbox=True, + loss_bbox=dict(type='GIoULoss', loss_weight=10.0)))) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_iou_1x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_iou_1x_coco.py new file mode 100644 index 00000000..e21c4364 --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_iou_1x_coco.py @@ -0,0 +1,6 @@ +_base_ = './faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + roi_head=dict( + bbox_head=dict( + reg_decoded_bbox=True, + loss_bbox=dict(type='IoULoss', loss_weight=10.0)))) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_ms-3x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_ms-3x_coco.py new file mode 100644 index 00000000..75dcfeb7 --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_ms-3x_coco.py @@ -0,0 +1 @@ +_base_ = ['../common/ms_3x_coco.py', '../_base_/models/faster-rcnn_r50_fpn.py'] diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_ohem_1x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_ohem_1x_coco.py new file mode 100644 index 00000000..4f804b9b --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_ohem_1x_coco.py @@ -0,0 +1,2 @@ +_base_ = './faster-rcnn_r50_fpn_1x_coco.py' +model = dict(train_cfg=dict(rcnn=dict(sampler=dict(type='OHEMSampler')))) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_soft-nms_1x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_soft-nms_1x_coco.py new file mode 100644 index 00000000..3775d8e4 --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_r50_fpn_soft-nms_1x_coco.py @@ -0,0 +1,12 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +model = dict( + test_cfg=dict( + rcnn=dict( + score_thr=0.05, + nms=dict(type='soft_nms', iou_threshold=0.5), + max_per_img=100))) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_x101-32x4d_fpn_1x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_x101-32x4d_fpn_1x_coco.py new file mode 100644 index 00000000..395c98cd --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_x101-32x4d_fpn_1x_coco.py @@ -0,0 +1,14 @@ +_base_ = './faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_x101-32x4d_fpn_2x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_x101-32x4d_fpn_2x_coco.py new file mode 100644 index 00000000..6232d0ed --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_x101-32x4d_fpn_2x_coco.py @@ -0,0 +1,14 @@ +_base_ = './faster-rcnn_r50_fpn_2x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_x101-32x4d_fpn_ms-3x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_x101-32x4d_fpn_ms-3x_coco.py new file mode 100644 index 00000000..88cb40fd --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_x101-32x4d_fpn_ms-3x_coco.py @@ -0,0 +1,14 @@ +_base_ = ['../common/ms_3x_coco.py', '../_base_/models/faster-rcnn_r50_fpn.py'] +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_x101-32x8d_fpn_ms-3x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_x101-32x8d_fpn_ms-3x_coco.py new file mode 100644 index 00000000..28d6290b --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_x101-32x8d_fpn_ms-3x_coco.py @@ -0,0 +1,23 @@ +_base_ = ['../common/ms_3x_coco.py', '../_base_/models/faster-rcnn_r50_fpn.py'] +model = dict( + # ResNeXt-101-32x8d model trained with Caffe2 at FB, + # so the mean and std need to be changed. + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[103.530, 116.280, 123.675], + std=[57.375, 57.120, 58.395], + bgr_to_rgb=False, + pad_size_divisor=32), + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=8, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=False), + style='pytorch', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnext101_32x8d'))) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_x101-64x4d_fpn_1x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_x101-64x4d_fpn_1x_coco.py new file mode 100644 index 00000000..f39d6322 --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_x101-64x4d_fpn_1x_coco.py @@ -0,0 +1,14 @@ +_base_ = './faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_x101-64x4d_fpn_2x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_x101-64x4d_fpn_2x_coco.py new file mode 100644 index 00000000..97a3c133 --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_x101-64x4d_fpn_2x_coco.py @@ -0,0 +1,14 @@ +_base_ = './faster-rcnn_r50_fpn_2x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/faster_rcnn/faster-rcnn_x101-64x4d_fpn_ms-3x_coco.py b/mmdetection/configs/faster_rcnn/faster-rcnn_x101-64x4d_fpn_ms-3x_coco.py new file mode 100644 index 00000000..eeaa218c --- /dev/null +++ b/mmdetection/configs/faster_rcnn/faster-rcnn_x101-64x4d_fpn_ms-3x_coco.py @@ -0,0 +1,14 @@ +_base_ = ['../common/ms_3x_coco.py', '../_base_/models/faster-rcnn_r50_fpn.py'] +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/faster_rcnn/metafile.yml b/mmdetection/configs/faster_rcnn/metafile.yml new file mode 100644 index 00000000..6a201e17 --- /dev/null +++ b/mmdetection/configs/faster_rcnn/metafile.yml @@ -0,0 +1,451 @@ +Collections: + - Name: Faster R-CNN + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - FPN + - RPN + - ResNet + - RoIPool + Paper: + URL: https://arxiv.org/abs/1506.01497 + Title: "Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks" + README: configs/faster_rcnn/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/detectors/faster_rcnn.py#L6 + Version: v2.0.0 + +Models: + - Name: faster-rcnn_r50-caffe-c4_1x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_r50-caffe_c4-1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 35.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_caffe_c4_1x_coco/faster_rcnn_r50_caffe_c4_1x_coco_20220316_150152-3f885b85.pth + + - Name: faster-rcnn_r50-caffe-c4_mstrain_1x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_r50-caffe-c4_ms-1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 35.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_caffe_c4_mstrain_1x_coco/faster_rcnn_r50_caffe_c4_mstrain_1x_coco_20220316_150527-db276fed.pth + + - Name: faster-rcnn_r50-caffe-dc5_1x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_r50-caffe-dc5_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_caffe_dc5_1x_coco/faster_rcnn_r50_caffe_dc5_1x_coco_20201030_151909-531f0f43.pth + + - Name: faster-rcnn_r50-caffe_fpn_1x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_1x_coco.py + Metadata: + Training Memory (GB): 3.8 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_caffe_fpn_1x_coco/faster_rcnn_r50_caffe_fpn_1x_coco_bbox_mAP-0.378_20200504_180032-c5925ee5.pth + + - Name: faster-rcnn_r50_fpn_1x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.0 + inference time (ms/im): + - value: 46.73 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth + + - Name: faster-rcnn_r50_fpn_fp16_1x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_r50_fpn_amp-1x_coco.py + Metadata: + Training Memory (GB): 3.4 + Training Techniques: + - SGD with Momentum + - Weight Decay + - Mixed Precision Training + inference time (ms/im): + - value: 34.72 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP16 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/fp16/faster_rcnn_r50_fpn_fp16_1x_coco/faster_rcnn_r50_fpn_fp16_1x_coco_20200204-d4dc1471.pth + + - Name: faster-rcnn_r50_fpn_2x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_r50_fpn_2x_coco.py + Metadata: + Training Memory (GB): 4.0 + inference time (ms/im): + - value: 46.73 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_2x_coco/faster_rcnn_r50_fpn_2x_coco_bbox_mAP-0.384_20200504_210434-a5d8aa15.pth + + - Name: faster-rcnn_r101-caffe_fpn_1x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_r101-caffe_fpn_1x_coco.py + Metadata: + Training Memory (GB): 5.7 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r101_caffe_fpn_1x_coco/faster_rcnn_r101_caffe_fpn_1x_coco_bbox_mAP-0.398_20200504_180057-b269e9dd.pth + + - Name: faster-rcnn_r101_fpn_1x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_r101_fpn_1x_coco.py + Metadata: + Training Memory (GB): 6.0 + inference time (ms/im): + - value: 64.1 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r101_fpn_1x_coco/faster_rcnn_r101_fpn_1x_coco_20200130-f513f705.pth + + - Name: faster-rcnn_r101_fpn_2x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_r101_fpn_2x_coco.py + Metadata: + Training Memory (GB): 6.0 + inference time (ms/im): + - value: 64.1 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r101_fpn_2x_coco/faster_rcnn_r101_fpn_2x_coco_bbox_mAP-0.398_20200504_210455-1d2dac9c.pth + + - Name: faster-rcnn_x101-32x4d_fpn_1x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_x101-32x4d_fpn_1x_coco.py + Metadata: + Training Memory (GB): 7.2 + inference time (ms/im): + - value: 72.46 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_x101_32x4d_fpn_1x_coco/faster_rcnn_x101_32x4d_fpn_1x_coco_20200203-cff10310.pth + + - Name: faster-rcnn_x101-32x4d_fpn_2x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_x101-32x4d_fpn_2x_coco.py + Metadata: + Training Memory (GB): 7.2 + inference time (ms/im): + - value: 72.46 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_x101_32x4d_fpn_2x_coco/faster_rcnn_x101_32x4d_fpn_2x_coco_bbox_mAP-0.412_20200506_041400-64a12c0b.pth + + - Name: faster-rcnn_x101-64x4d_fpn_1x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_x101-64x4d_fpn_1x_coco.py + Metadata: + Training Memory (GB): 10.3 + inference time (ms/im): + - value: 106.38 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_x101_64x4d_fpn_1x_coco/faster_rcnn_x101_64x4d_fpn_1x_coco_20200204-833ee192.pth + + - Name: faster-rcnn_x101-64x4d_fpn_2x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_x101-64x4d_fpn_2x_coco.py + Metadata: + Training Memory (GB): 10.3 + inference time (ms/im): + - value: 106.38 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_x101_64x4d_fpn_2x_coco/faster_rcnn_x101_64x4d_fpn_2x_coco_20200512_161033-5961fa95.pth + + - Name: faster-rcnn_r50_fpn_iou_1x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_r50_fpn_iou_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_iou_1x_coco/faster_rcnn_r50_fpn_iou_1x_coco_20200506_095954-938e81f0.pth + + - Name: faster-rcnn_r50_fpn_giou_1x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_r50_fpn_giou_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_giou_1x_coco-0eada910.pth + + - Name: faster-rcnn_r50_fpn_bounded_iou_1x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_r50_fpn_bounded-iou_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_bounded_iou_1x_coco-98ad993b.pth + + - Name: faster-rcnn_r50-caffe-dc5_mstrain_1x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_r50-caffe-dc5_ms-1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_caffe_dc5_mstrain_1x_coco/faster_rcnn_r50_caffe_dc5_mstrain_1x_coco_20201028_233851-b33d21b9.pth + + - Name: faster-rcnn_r50-caffe-dc5_mstrain_3x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_r50-caffe-dc5_ms-3x_coco.py + Metadata: + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_caffe_dc5_mstrain_3x_coco/faster_rcnn_r50_caffe_dc5_mstrain_3x_coco_20201028_002107-34a53b2c.pth + + - Name: faster-rcnn_r50-caffe_fpn_ms-2x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_ms-2x_coco.py + Metadata: + Training Memory (GB): 4.3 + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_caffe_fpn_mstrain_2x_coco/faster_rcnn_r50_caffe_fpn_mstrain_2x_coco_bbox_mAP-0.397_20200504_231813-10b2de58.pth + + - Name: faster-rcnn_r50-caffe_fpn_ms-3x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 3.7 + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_caffe_fpn_mstrain_3x_coco/faster_rcnn_r50_caffe_fpn_mstrain_3x_coco_20210526_095054-1f77628b.pth + + - Name: faster-rcnn_r50_fpn_mstrain_3x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_r50_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 3.9 + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_mstrain_3x_coco/faster_rcnn_r50_fpn_mstrain_3x_coco_20210524_110822-e10bd31c.pth + + - Name: faster-rcnn_r101-caffe_fpn_ms-3x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_r101-caffe_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 5.6 + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r101_caffe_fpn_mstrain_3x_coco/faster_rcnn_r101_caffe_fpn_mstrain_3x_coco_20210526_095742-a7ae426d.pth + + - Name: faster-rcnn_r101_fpn_ms-3x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_r101_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 5.8 + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r101_fpn_mstrain_3x_coco/faster_rcnn_r101_fpn_mstrain_3x_coco_20210524_110822-4d4d2ca8.pth + + - Name: faster-rcnn_x101-32x4d_fpn_ms-3x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_x101-32x4d_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 7.0 + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_x101_32x4d_fpn_mstrain_3x_coco/faster_rcnn_x101_32x4d_fpn_mstrain_3x_coco_20210524_124151-16b9b260.pth + + - Name: faster-rcnn_x101-32x8d_fpn_ms-3x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_x101-32x8d_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 10.1 + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_x101_32x8d_fpn_mstrain_3x_coco/faster_rcnn_x101_32x8d_fpn_mstrain_3x_coco_20210604_182954-002e082a.pth + + - Name: faster-rcnn_x101-64x4d_fpn_ms-3x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_x101-64x4d_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 10.0 + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_x101_64x4d_fpn_mstrain_3x_coco/faster_rcnn_x101_64x4d_fpn_mstrain_3x_coco_20210524_124528-26c63de6.pth + + - Name: faster-rcnn_r50_fpn_tnr-pretrain_1x_coco + In Collection: Faster R-CNN + Config: configs/faster_rcnn/faster-rcnn_r50-tnr-pre_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.0 + inference time (ms/im): + - value: 46.73 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_tnr-pretrain_1x_coco/faster_rcnn_r50_fpn_tnr-pretrain_1x_coco_20220320_085147-efedfda4.pth diff --git a/mmdetection/configs/fcos/README.md b/mmdetection/configs/fcos/README.md new file mode 100644 index 00000000..8d72237a --- /dev/null +++ b/mmdetection/configs/fcos/README.md @@ -0,0 +1,45 @@ +# FCOS + +> [FCOS: Fully Convolutional One-Stage Object Detection](https://arxiv.org/abs/1904.01355) + + + +## Abstract + +We propose a fully convolutional one-stage object detector (FCOS) to solve object detection in a per-pixel prediction fashion, analogue to semantic segmentation. Almost all state-of-the-art object detectors such as RetinaNet, SSD, YOLOv3, and Faster R-CNN rely on pre-defined anchor boxes. In contrast, our proposed detector FCOS is anchor box free, as well as proposal free. By eliminating the predefined set of anchor boxes, FCOS completely avoids the complicated computation related to anchor boxes such as calculating overlapping during training. More importantly, we also avoid all hyper-parameters related to anchor boxes, which are often very sensitive to the final detection performance. With the only post-processing non-maximum suppression (NMS), FCOS with ResNeXt-64x4d-101 achieves 44.7% in AP with single-model and single-scale testing, surpassing previous one-stage detectors with the advantage of being much simpler. For the first time, we demonstrate a much simpler and flexible detection framework achieving improved detection accuracy. We hope that the proposed FCOS framework can serve as a simple and strong alternative for many other instance-level tasks. + +
    + +
    + +## Results and Models + +| Backbone | Style | GN | MS train | Tricks | DCN | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :------: | :---: | :-: | :------: | :----: | :-: | :-----: | :------: | :------------: | :----: | :------------------------------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | caffe | Y | N | N | N | 1x | 3.6 | 22.7 | 36.6 | [config](./fcos_r50-caffe_fpn_gn-head_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_r50_caffe_fpn_gn-head_1x_coco/fcos_r50_caffe_fpn_gn-head_1x_coco-821213aa.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_r50_caffe_fpn_gn-head_1x_coco/20201227_180009.log.json) | +| R-50 | caffe | Y | N | Y | N | 1x | 3.7 | - | 38.7 | [config](./fcos_r50-caffe_fpn_gn-head-center-normbbox-centeronreg-giou_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_center-normbbox-centeronreg-giou_r50_caffe_fpn_gn-head_1x_coco/fcos_center-normbbox-centeronreg-giou_r50_caffe_fpn_gn-head_1x_coco-0a0d75a8.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_center-normbbox-centeronreg-giou_r50_caffe_fpn_gn-head_1x_coco/20210105_135818.log.json) | +| R-50 | caffe | Y | N | Y | Y | 1x | 3.8 | - | 42.3 | [config](./fcos_r50-dcn-caffe_fpn_gn-head-center-normbbox-centeronreg-giou_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_center-normbbox-centeronreg-giou_r50_caffe_fpn_gn-head_dcn_1x_coco/fcos_center-normbbox-centeronreg-giou_r50_caffe_fpn_gn-head_dcn_1x_coco-ae4d8b3d.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_center-normbbox-centeronreg-giou_r50_caffe_fpn_gn-head_dcn_1x_coco/20210105_224556.log.json) | +| R-101 | caffe | Y | N | N | N | 1x | 5.5 | 17.3 | 39.1 | [config](./fcos_r101-caffe_fpn_gn-head-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_r101_caffe_fpn_gn-head_1x_coco/fcos_r101_caffe_fpn_gn-head_1x_coco-0e37b982.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_r101_caffe_fpn_gn-head_1x_coco/20210103_155046.log.json) | + +| Backbone | Style | GN | MS train | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :------: | :-----: | :-: | :------: | :-----: | :------: | :------------: | :----: | :-----------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | caffe | Y | Y | 2x | 2.6 | 22.9 | 38.5 | [config](./fcos_r50-caffe_fpn_gn-head_ms-640-800-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_r50_caffe_fpn_gn-head_mstrain_640-800_2x_coco/fcos_r50_caffe_fpn_gn-head_mstrain_640-800_2x_coco-d92ceeea.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_r50_caffe_fpn_gn-head_mstrain_640-800_2x_coco/20201227_161900.log.json) | +| R-101 | caffe | Y | Y | 2x | 5.5 | 17.3 | 40.8 | [config](./fcos_r101-caffe_fpn_gn-head_ms-640-800-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_r101_caffe_fpn_gn-head_mstrain_640-800_2x_coco/fcos_r101_caffe_fpn_gn-head_mstrain_640-800_2x_coco-511424d6.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_r101_caffe_fpn_gn-head_mstrain_640-800_2x_coco/20210103_155046.log.json) | +| X-101 | pytorch | Y | Y | 2x | 10.0 | 9.7 | 42.6 | [config](./fcos_x101-64x4d_fpn_gn-head_ms-640-800-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_x101_64x4d_fpn_gn-head_mstrain_640-800_2x_coco/fcos_x101_64x4d_fpn_gn-head_mstrain_640-800_2x_coco-ede514a8.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_x101_64x4d_fpn_gn-head_mstrain_640-800_2x_coco/20210114_133041.log.json) | + +**Notes:** + +- The X-101 backbone is X-101-64x4d. +- Tricks means setting `norm_on_bbox`, `centerness_on_reg`, `center_sampling` as `True`. +- DCN means using `DCNv2` in both backbone and head. + +## Citation + +```latex +@article{tian2019fcos, + title={FCOS: Fully Convolutional One-Stage Object Detection}, + author={Tian, Zhi and Shen, Chunhua and Chen, Hao and He, Tong}, + journal={arXiv preprint arXiv:1904.01355}, + year={2019} +} +``` diff --git a/mmdetection/configs/fcos/fcos_r101-caffe_fpn_gn-head-1x_coco.py b/mmdetection/configs/fcos/fcos_r101-caffe_fpn_gn-head-1x_coco.py new file mode 100644 index 00000000..5380e874 --- /dev/null +++ b/mmdetection/configs/fcos/fcos_r101-caffe_fpn_gn-head-1x_coco.py @@ -0,0 +1,9 @@ +_base_ = './fcos_r50-caffe_fpn_gn-head_1x_coco.py' + +# model settings +model = dict( + backbone=dict( + depth=101, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron/resnet101_caffe'))) diff --git a/mmdetection/configs/fcos/fcos_r101-caffe_fpn_gn-head_ms-640-800-2x_coco.py b/mmdetection/configs/fcos/fcos_r101-caffe_fpn_gn-head_ms-640-800-2x_coco.py new file mode 100644 index 00000000..286a07a2 --- /dev/null +++ b/mmdetection/configs/fcos/fcos_r101-caffe_fpn_gn-head_ms-640-800-2x_coco.py @@ -0,0 +1,38 @@ +_base_ = './fcos_r50-caffe_fpn_gn-head_1x_coco.py' + +# model settings +model = dict( + backbone=dict( + depth=101, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron/resnet101_caffe'))) + +# dataset settings +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +# training schedule for 2x +max_epochs = 24 +train_cfg = dict(max_epochs=max_epochs) + +# learning rate +param_scheduler = [ + dict(type='ConstantLR', factor=1.0 / 3, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/fcos/fcos_r101_fpn_gn-head-center-normbbox-centeronreg-giou_8xb8-amp-lsj-200e_coco.py b/mmdetection/configs/fcos/fcos_r101_fpn_gn-head-center-normbbox-centeronreg-giou_8xb8-amp-lsj-200e_coco.py new file mode 100644 index 00000000..77250e69 --- /dev/null +++ b/mmdetection/configs/fcos/fcos_r101_fpn_gn-head-center-normbbox-centeronreg-giou_8xb8-amp-lsj-200e_coco.py @@ -0,0 +1,7 @@ +_base_ = './fcos_r50_fpn_gn-head-center-normbbox-centeronreg-giou_8xb8-amp-lsj-200e_coco.py' # noqa + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/fcos/fcos_r18_fpn_gn-head-center-normbbox-centeronreg-giou_8xb8-amp-lsj-200e_coco.py b/mmdetection/configs/fcos/fcos_r18_fpn_gn-head-center-normbbox-centeronreg-giou_8xb8-amp-lsj-200e_coco.py new file mode 100644 index 00000000..6f001024 --- /dev/null +++ b/mmdetection/configs/fcos/fcos_r18_fpn_gn-head-center-normbbox-centeronreg-giou_8xb8-amp-lsj-200e_coco.py @@ -0,0 +1,7 @@ +_base_ = './fcos_r50_fpn_gn-head-center-normbbox-centeronreg-giou_8xb8-amp-lsj-200e_coco.py' # noqa + +model = dict( + backbone=dict( + depth=18, + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet18')), + neck=dict(in_channels=[64, 128, 256, 512])) diff --git a/mmdetection/configs/fcos/fcos_r50-caffe_fpn_gn-head-center-normbbox-centeronreg-giou_1x_coco.py b/mmdetection/configs/fcos/fcos_r50-caffe_fpn_gn-head-center-normbbox-centeronreg-giou_1x_coco.py new file mode 100644 index 00000000..2a77641d --- /dev/null +++ b/mmdetection/configs/fcos/fcos_r50-caffe_fpn_gn-head-center-normbbox-centeronreg-giou_1x_coco.py @@ -0,0 +1,43 @@ +_base_ = 'fcos_r50-caffe_fpn_gn-head_1x_coco.py' + +# model setting +model = dict( + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False, + pad_size_divisor=32), + backbone=dict( + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe')), + bbox_head=dict( + norm_on_bbox=True, + centerness_on_reg=True, + dcn_on_last_conv=False, + center_sampling=True, + conv_bias=True, + loss_bbox=dict(type='GIoULoss', loss_weight=1.0)), + # training and testing settings + test_cfg=dict(nms=dict(type='nms', iou_threshold=0.6))) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0 / 3.0, + by_epoch=False, + begin=0, + end=500), + dict( + type='MultiStepLR', + begin=0, + end=12, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict(clip_grad=None) diff --git a/mmdetection/configs/fcos/fcos_r50-caffe_fpn_gn-head-center_1x_coco.py b/mmdetection/configs/fcos/fcos_r50-caffe_fpn_gn-head-center_1x_coco.py new file mode 100644 index 00000000..9e4eb1d5 --- /dev/null +++ b/mmdetection/configs/fcos/fcos_r50-caffe_fpn_gn-head-center_1x_coco.py @@ -0,0 +1,4 @@ +_base_ = './fcos_r50-caffe_fpn_gn-head_1x_coco.py' + +# model settings +model = dict(bbox_head=dict(center_sampling=True, center_sample_radius=1.5)) diff --git a/mmdetection/configs/fcos/fcos_r50-caffe_fpn_gn-head_1x_coco.py b/mmdetection/configs/fcos/fcos_r50-caffe_fpn_gn-head_1x_coco.py new file mode 100644 index 00000000..928a9b4c --- /dev/null +++ b/mmdetection/configs/fcos/fcos_r50-caffe_fpn_gn-head_1x_coco.py @@ -0,0 +1,75 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +# model settings +model = dict( + type='FCOS', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[102.9801, 115.9465, 122.7717], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=False), + norm_eval=True, + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron/resnet50_caffe')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_output', # use P5 + num_outs=5, + relu_before_extra_convs=True), + bbox_head=dict( + type='FCOSHead', + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + strides=[8, 16, 32, 64, 128], + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='IoULoss', loss_weight=1.0), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)), + # testing settings + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.5), + max_per_img=100)) + +# learning rate +param_scheduler = [ + dict(type='ConstantLR', factor=1.0 / 3, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=12, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + optimizer=dict(lr=0.01), + paramwise_cfg=dict(bias_lr_mult=2., bias_decay_mult=0.), + clip_grad=dict(max_norm=35, norm_type=2)) diff --git a/mmdetection/configs/fcos/fcos_r50-caffe_fpn_gn-head_4xb4-1x_coco.py b/mmdetection/configs/fcos/fcos_r50-caffe_fpn_gn-head_4xb4-1x_coco.py new file mode 100644 index 00000000..32358cd3 --- /dev/null +++ b/mmdetection/configs/fcos/fcos_r50-caffe_fpn_gn-head_4xb4-1x_coco.py @@ -0,0 +1,5 @@ +# TODO: Remove this config after benchmarking all related configs +_base_ = 'fcos_r50-caffe_fpn_gn-head_1x_coco.py' + +# dataset settings +train_dataloader = dict(batch_size=4, num_workers=4) diff --git a/mmdetection/configs/fcos/fcos_r50-caffe_fpn_gn-head_ms-640-800-2x_coco.py b/mmdetection/configs/fcos/fcos_r50-caffe_fpn_gn-head_ms-640-800-2x_coco.py new file mode 100644 index 00000000..4d50b4ec --- /dev/null +++ b/mmdetection/configs/fcos/fcos_r50-caffe_fpn_gn-head_ms-640-800-2x_coco.py @@ -0,0 +1,30 @@ +_base_ = './fcos_r50-caffe_fpn_gn-head_1x_coco.py' + +# dataset settings +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +# training schedule for 2x +max_epochs = 24 +train_cfg = dict(max_epochs=max_epochs) + +# learning rate +param_scheduler = [ + dict(type='ConstantLR', factor=1.0 / 3, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/fcos/fcos_r50-dcn-caffe_fpn_gn-head-center-normbbox-centeronreg-giou_1x_coco.py b/mmdetection/configs/fcos/fcos_r50-dcn-caffe_fpn_gn-head-center-normbbox-centeronreg-giou_1x_coco.py new file mode 100644 index 00000000..a6a6c44f --- /dev/null +++ b/mmdetection/configs/fcos/fcos_r50-dcn-caffe_fpn_gn-head-center-normbbox-centeronreg-giou_1x_coco.py @@ -0,0 +1,45 @@ +_base_ = 'fcos_r50-caffe_fpn_gn-head_1x_coco.py' + +# model settings +model = dict( + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False, + pad_size_divisor=32), + backbone=dict( + dcn=dict(type='DCNv2', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True), + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe')), + bbox_head=dict( + norm_on_bbox=True, + centerness_on_reg=True, + dcn_on_last_conv=True, + center_sampling=True, + conv_bias=True, + loss_bbox=dict(type='GIoULoss', loss_weight=1.0)), + # training and testing settings + test_cfg=dict(nms=dict(type='nms', iou_threshold=0.6))) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0 / 3.0, + by_epoch=False, + begin=0, + end=500), + dict( + type='MultiStepLR', + begin=0, + end=12, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict(clip_grad=None) diff --git a/mmdetection/configs/fcos/fcos_r50_fpn_gn-head-center-normbbox-centeronreg-giou_8xb8-amp-lsj-200e_coco.py b/mmdetection/configs/fcos/fcos_r50_fpn_gn-head-center-normbbox-centeronreg-giou_8xb8-amp-lsj-200e_coco.py new file mode 100644 index 00000000..b51556b8 --- /dev/null +++ b/mmdetection/configs/fcos/fcos_r50_fpn_gn-head-center-normbbox-centeronreg-giou_8xb8-amp-lsj-200e_coco.py @@ -0,0 +1,75 @@ +_base_ = '../common/lsj-200e_coco-detection.py' + +image_size = (1024, 1024) +batch_augments = [dict(type='BatchFixedSizePad', size=image_size)] + +# model settings +model = dict( + type='FCOS', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32, + batch_augments=batch_augments), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_output', # use P5 + num_outs=5, + relu_before_extra_convs=True), + bbox_head=dict( + type='FCOSHead', + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + strides=[8, 16, 32, 64, 128], + norm_on_bbox=True, + centerness_on_reg=True, + dcn_on_last_conv=False, + center_sampling=True, + conv_bias=True, + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=1.0), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)), + # testing settings + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) + +train_dataloader = dict(batch_size=8, num_workers=4) +# Enable automatic-mixed-precision training with AmpOptimWrapper. +optim_wrapper = dict( + type='AmpOptimWrapper', + optimizer=dict( + type='SGD', lr=0.01 * 4, momentum=0.9, weight_decay=0.00004), + paramwise_cfg=dict(bias_lr_mult=2., bias_decay_mult=0.), + clip_grad=dict(max_norm=35, norm_type=2)) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (8 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/fcos/fcos_x101-64x4d_fpn_gn-head_ms-640-800-2x_coco.py b/mmdetection/configs/fcos/fcos_x101-64x4d_fpn_gn-head_ms-640-800-2x_coco.py new file mode 100644 index 00000000..503c0e1c --- /dev/null +++ b/mmdetection/configs/fcos/fcos_x101-64x4d_fpn_gn-head_ms-640-800-2x_coco.py @@ -0,0 +1,52 @@ +_base_ = './fcos_r50-caffe_fpn_gn-head_1x_coco.py' + +# model settings +model = dict( + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32), + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) + +# dataset settings +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +# training schedule for 2x +max_epochs = 24 +train_cfg = dict(max_epochs=max_epochs) + +# learning rate +param_scheduler = [ + dict(type='ConstantLR', factor=1.0 / 3, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/fcos/metafile.yml b/mmdetection/configs/fcos/metafile.yml new file mode 100644 index 00000000..fb6527cf --- /dev/null +++ b/mmdetection/configs/fcos/metafile.yml @@ -0,0 +1,146 @@ +Collections: + - Name: FCOS + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - FPN + - Group Normalization + - ResNet + Paper: + URL: https://arxiv.org/abs/1904.01355 + Title: 'FCOS: Fully Convolutional One-Stage Object Detection' + README: configs/fcos/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/detectors/fcos.py#L6 + Version: v2.0.0 + +Models: + - Name: fcos_r50-caffe_fpn_gn-head_1x_coco + In Collection: FCOS + Config: configs/fcos/fcos_r50-caffe_fpn_gn-head_1x_coco.py + Metadata: + Training Memory (GB): 3.6 + inference time (ms/im): + - value: 44.05 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 36.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_r50_caffe_fpn_gn-head_1x_coco/fcos_r50_caffe_fpn_gn-head_1x_coco-821213aa.pth + + - Name: fcos_r50-caffe_fpn_gn-head-center-normbbox-centeronreg-giou_1x_coco + In Collection: FCOS + Config: configs/fcos/fcos_r50-caffe_fpn_gn-head-center-normbbox-centeronreg-giou_1x_coco.py + Metadata: + Training Memory (GB): 3.7 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_center-normbbox-centeronreg-giou_r50_caffe_fpn_gn-head_1x_coco/fcos_center-normbbox-centeronreg-giou_r50_caffe_fpn_gn-head_1x_coco-0a0d75a8.pth + + - Name: fcos_r50-dcn-caffe_fpn_gn-head-center-normbbox-centeronreg-giou_1x_coco + In Collection: FCOS + Config: configs/fcos/fcos_r50-dcn-caffe_fpn_gn-head-center-normbbox-centeronreg-giou_1x_coco.py + Metadata: + Training Memory (GB): 3.8 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_center-normbbox-centeronreg-giou_r50_caffe_fpn_gn-head_dcn_1x_coco/fcos_center-normbbox-centeronreg-giou_r50_caffe_fpn_gn-head_dcn_1x_coco-ae4d8b3d.pth + + - Name: fcos_r101-caffe_fpn_gn-head-1x_coco + In Collection: FCOS + Config: configs/fcos/fcos_r101-caffe_fpn_gn-head-1x_coco.py + Metadata: + Training Memory (GB): 5.5 + inference time (ms/im): + - value: 57.8 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_r101_caffe_fpn_gn-head_1x_coco/fcos_r101_caffe_fpn_gn-head_1x_coco-0e37b982.pth + + - Name: fcos_r50-caffe_fpn_gn-head_ms-640-800-2x_coco + In Collection: FCOS + Config: configs/fcos/fcos_r50-caffe_fpn_gn-head_ms-640-800-2x_coco.py + Metadata: + Training Memory (GB): 2.6 + inference time (ms/im): + - value: 43.67 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_r50_caffe_fpn_gn-head_mstrain_640-800_2x_coco/fcos_r50_caffe_fpn_gn-head_mstrain_640-800_2x_coco-d92ceeea.pth + + - Name: fcos_r101-caffe_fpn_gn-head_ms-640-800-2x_coco + In Collection: FCOS + Config: configs/fcos/fcos_r101-caffe_fpn_gn-head_ms-640-800-2x_coco.py + Metadata: + Training Memory (GB): 5.5 + inference time (ms/im): + - value: 57.8 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_r101_caffe_fpn_gn-head_mstrain_640-800_2x_coco/fcos_r101_caffe_fpn_gn-head_mstrain_640-800_2x_coco-511424d6.pth + + - Name: fcos_x101-64x4d_fpn_gn-head_ms-640-800-2x_coco + In Collection: FCOS + Config: configs/fcos/fcos_x101-64x4d_fpn_gn-head_ms-640-800-2x_coco.py + Metadata: + Training Memory (GB): 10.0 + inference time (ms/im): + - value: 103.09 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_x101_64x4d_fpn_gn-head_mstrain_640-800_2x_coco/fcos_x101_64x4d_fpn_gn-head_mstrain_640-800_2x_coco-ede514a8.pth diff --git a/mmdetection/configs/foveabox/README.md b/mmdetection/configs/foveabox/README.md new file mode 100644 index 00000000..96f1358b --- /dev/null +++ b/mmdetection/configs/foveabox/README.md @@ -0,0 +1,53 @@ +# FoveaBox + +> [FoveaBox: Beyond Anchor-based Object Detector](https://arxiv.org/abs/1904.03797) + + + +## Abstract + +We present FoveaBox, an accurate, flexible, and completely anchor-free framework for object detection. While almost all state-of-the-art object detectors utilize predefined anchors to enumerate possible locations, scales and aspect ratios for the search of the objects, their performance and generalization ability are also limited to the design of anchors. Instead, FoveaBox directly learns the object existing possibility and the bounding box coordinates without anchor reference. This is achieved by: (a) predicting category-sensitive semantic maps for the object existing possibility, and (b) producing category-agnostic bounding box for each position that potentially contains an object. The scales of target boxes are naturally associated with feature pyramid representations. In FoveaBox, an instance is assigned to adjacent feature levels to make the model more accurate.We demonstrate its effectiveness on standard benchmarks and report extensive experimental analysis. Without bells and whistles, FoveaBox achieves state-of-the-art single model performance on the standard COCO and Pascal VOC object detection benchmark. More importantly, FoveaBox avoids all computation and hyper-parameters related to anchor boxes, which are often sensitive to the final detection performance. We believe the simple and effective approach will serve as a solid baseline and help ease future research for object detection. + +
    + +
    + +## Introduction + +FoveaBox is an accurate, flexible and completely anchor-free object detection system for object detection framework, as presented in our paper [https://arxiv.org/abs/1904.03797](https://arxiv.org/abs/1904.03797): +Different from previous anchor-based methods, FoveaBox directly learns the object existing possibility and the bounding box coordinates without anchor reference. This is achieved by: (a) predicting category-sensitive semantic maps for the object existing possibility, and (b) producing category-agnostic bounding box for each position that potentially contains an object. + +## Results and Models + +### Results on R50/101-FPN + +| Backbone | Style | align | ms-train | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :------: | :-----: | :---: | :------: | :-----: | :------: | :------------: | :----: | :-----------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | pytorch | N | N | 1x | 5.6 | 24.1 | 36.5 | [config](./fovea_r50_fpn_4xb4-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_r50_fpn_4x4_1x_coco/fovea_r50_fpn_4x4_1x_coco_20200219-ee4d5303.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_r50_fpn_4x4_1x_coco/fovea_r50_fpn_4x4_1x_coco_20200219_223025.log.json) | +| R-50 | pytorch | N | N | 2x | 5.6 | - | 37.2 | [config](./fovea_r50_fpn_4xb4-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_r50_fpn_4x4_2x_coco/fovea_r50_fpn_4x4_2x_coco_20200203-2df792b1.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_r50_fpn_4x4_2x_coco/fovea_r50_fpn_4x4_2x_coco_20200203_112043.log.json) | +| R-50 | pytorch | Y | N | 2x | 8.1 | 19.4 | 37.9 | [config](./fovea_r50_fpn_gn-head-align_4xb4-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_align_r50_fpn_gn-head_4x4_2x_coco/fovea_align_r50_fpn_gn-head_4x4_2x_coco_20200203-8987880d.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_align_r50_fpn_gn-head_4x4_2x_coco/fovea_align_r50_fpn_gn-head_4x4_2x_coco_20200203_134252.log.json) | +| R-50 | pytorch | Y | Y | 2x | 8.1 | 18.3 | 40.4 | [config](./fovea_r50_fpn_gn-head-align_ms-640-800-4xb4-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_align_r50_fpn_gn-head_mstrain_640-800_4x4_2x_coco/fovea_align_r50_fpn_gn-head_mstrain_640-800_4x4_2x_coco_20200205-85ce26cb.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_align_r50_fpn_gn-head_mstrain_640-800_4x4_2x_coco/fovea_align_r50_fpn_gn-head_mstrain_640-800_4x4_2x_coco_20200205_112557.log.json) | +| R-101 | pytorch | N | N | 1x | 9.2 | 17.4 | 38.6 | [config](./fovea_r101_fpn_4xb4-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_r101_fpn_4x4_1x_coco/fovea_r101_fpn_4x4_1x_coco_20200219-05e38f1c.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_r101_fpn_4x4_1x_coco/fovea_r101_fpn_4x4_1x_coco_20200219_011740.log.json) | +| R-101 | pytorch | N | N | 2x | 11.7 | - | 40.0 | [config](./fovea_r101_fpn_4xb4-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_r101_fpn_4x4_2x_coco/fovea_r101_fpn_4x4_2x_coco_20200208-02320ea4.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_r101_fpn_4x4_2x_coco/fovea_r101_fpn_4x4_2x_coco_20200208_202059.log.json) | +| R-101 | pytorch | Y | N | 2x | 11.7 | 14.7 | 40.0 | [config](./fovea_r101_fpn_gn-head-align_4xb4-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_align_r101_fpn_gn-head_4x4_2x_coco/fovea_align_r101_fpn_gn-head_4x4_2x_coco_20200208-c39a027a.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_align_r101_fpn_gn-head_4x4_2x_coco/fovea_align_r101_fpn_gn-head_4x4_2x_coco_20200208_203337.log.json) | +| R-101 | pytorch | Y | Y | 2x | 11.7 | 14.7 | 42.0 | [config](./fovea_r101_fpn_gn-head-align_ms-640-800-4xb4-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_align_r101_fpn_gn-head_mstrain_640-800_4x4_2x_coco/fovea_align_r101_fpn_gn-head_mstrain_640-800_4x4_2x_coco_20200208-649c5eb6.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_align_r101_fpn_gn-head_mstrain_640-800_4x4_2x_coco/fovea_align_r101_fpn_gn-head_mstrain_640-800_4x4_2x_coco_20200208_202124.log.json) | + +\[1\] *1x and 2x mean the model is trained for 12 and 24 epochs, respectively.* \ +\[2\] *Align means utilizing deformable convolution to align the cls branch.* \ +\[3\] *All results are obtained with a single model and without any test time data augmentation.*\ +\[4\] *We use 4 GPUs for training.* + +Any pull requests or issues are welcome. + +## Citation + +Please consider citing our paper in your publications if the project helps your research. BibTeX reference is as follows. + +```latex +@article{kong2019foveabox, + title={FoveaBox: Beyond Anchor-based Object Detector}, + author={Kong, Tao and Sun, Fuchun and Liu, Huaping and Jiang, Yuning and Shi, Jianbo}, + journal={arXiv preprint arXiv:1904.03797}, + year={2019} +} +``` diff --git a/mmdetection/configs/foveabox/fovea_r101_fpn_4xb4-1x_coco.py b/mmdetection/configs/foveabox/fovea_r101_fpn_4xb4-1x_coco.py new file mode 100644 index 00000000..7e8ccf91 --- /dev/null +++ b/mmdetection/configs/foveabox/fovea_r101_fpn_4xb4-1x_coco.py @@ -0,0 +1,6 @@ +_base_ = './fovea_r50_fpn_4xb4-1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/foveabox/fovea_r101_fpn_4xb4-2x_coco.py b/mmdetection/configs/foveabox/fovea_r101_fpn_4xb4-2x_coco.py new file mode 100644 index 00000000..0dc98515 --- /dev/null +++ b/mmdetection/configs/foveabox/fovea_r101_fpn_4xb4-2x_coco.py @@ -0,0 +1,6 @@ +_base_ = './fovea_r50_fpn_4xb4-2x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/foveabox/fovea_r101_fpn_gn-head-align_4xb4-2x_coco.py b/mmdetection/configs/foveabox/fovea_r101_fpn_gn-head-align_4xb4-2x_coco.py new file mode 100644 index 00000000..222671d4 --- /dev/null +++ b/mmdetection/configs/foveabox/fovea_r101_fpn_gn-head-align_4xb4-2x_coco.py @@ -0,0 +1,23 @@ +_base_ = './fovea_r50_fpn_4xb4-1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101')), + bbox_head=dict( + with_deform=True, + norm_cfg=dict(type='GN', num_groups=32, requires_grad=True))) +# learning policy +max_epochs = 24 +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs) diff --git a/mmdetection/configs/foveabox/fovea_r101_fpn_gn-head-align_ms-640-800-4xb4-2x_coco.py b/mmdetection/configs/foveabox/fovea_r101_fpn_gn-head-align_ms-640-800-4xb4-2x_coco.py new file mode 100644 index 00000000..e1852d58 --- /dev/null +++ b/mmdetection/configs/foveabox/fovea_r101_fpn_gn-head-align_ms-640-800-4xb4-2x_coco.py @@ -0,0 +1,34 @@ +_base_ = './fovea_r50_fpn_4xb4-1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101')), + bbox_head=dict( + with_deform=True, + norm_cfg=dict(type='GN', num_groups=32, requires_grad=True))) +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +# learning policy +max_epochs = 24 +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs) diff --git a/mmdetection/configs/foveabox/fovea_r50_fpn_4xb4-1x_coco.py b/mmdetection/configs/foveabox/fovea_r50_fpn_4xb4-1x_coco.py new file mode 100644 index 00000000..13cf3ae9 --- /dev/null +++ b/mmdetection/configs/foveabox/fovea_r50_fpn_4xb4-1x_coco.py @@ -0,0 +1,59 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +# model settings +model = dict( + type='FOVEA', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + num_outs=5, + add_extra_convs='on_input'), + bbox_head=dict( + type='FoveaHead', + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + strides=[8, 16, 32, 64, 128], + base_edge_list=[16, 32, 64, 128, 256], + scale_ranges=((1, 64), (32, 128), (64, 256), (128, 512), (256, 2048)), + sigma=0.4, + with_deform=False, + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=1.50, + alpha=0.4, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=0.11, loss_weight=1.0)), + # training and testing settings + train_cfg=dict(), + test_cfg=dict( + nms_pre=1000, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.5), + max_per_img=100)) +train_dataloader = dict(batch_size=4, num_workers=4) +# optimizer +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) diff --git a/mmdetection/configs/foveabox/fovea_r50_fpn_4xb4-2x_coco.py b/mmdetection/configs/foveabox/fovea_r50_fpn_4xb4-2x_coco.py new file mode 100644 index 00000000..f9d06ef9 --- /dev/null +++ b/mmdetection/configs/foveabox/fovea_r50_fpn_4xb4-2x_coco.py @@ -0,0 +1,15 @@ +_base_ = './fovea_r50_fpn_4xb4-1x_coco.py' +# learning policy +max_epochs = 24 +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs) diff --git a/mmdetection/configs/foveabox/fovea_r50_fpn_gn-head-align_4xb4-2x_coco.py b/mmdetection/configs/foveabox/fovea_r50_fpn_gn-head-align_4xb4-2x_coco.py new file mode 100644 index 00000000..877bb4fa --- /dev/null +++ b/mmdetection/configs/foveabox/fovea_r50_fpn_gn-head-align_4xb4-2x_coco.py @@ -0,0 +1,20 @@ +_base_ = './fovea_r50_fpn_4xb4-1x_coco.py' +model = dict( + bbox_head=dict( + with_deform=True, + norm_cfg=dict(type='GN', num_groups=32, requires_grad=True))) +# learning policy +max_epochs = 24 +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs) +optim_wrapper = dict(clip_grad=dict(max_norm=35, norm_type=2)) diff --git a/mmdetection/configs/foveabox/fovea_r50_fpn_gn-head-align_ms-640-800-4xb4-2x_coco.py b/mmdetection/configs/foveabox/fovea_r50_fpn_gn-head-align_ms-640-800-4xb4-2x_coco.py new file mode 100644 index 00000000..5690bcae --- /dev/null +++ b/mmdetection/configs/foveabox/fovea_r50_fpn_gn-head-align_ms-640-800-4xb4-2x_coco.py @@ -0,0 +1,30 @@ +_base_ = './fovea_r50_fpn_4xb4-1x_coco.py' +model = dict( + bbox_head=dict( + with_deform=True, + norm_cfg=dict(type='GN', num_groups=32, requires_grad=True))) +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +# learning policy +max_epochs = 24 +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs) diff --git a/mmdetection/configs/foveabox/metafile.yml b/mmdetection/configs/foveabox/metafile.yml new file mode 100644 index 00000000..9ab2f542 --- /dev/null +++ b/mmdetection/configs/foveabox/metafile.yml @@ -0,0 +1,172 @@ +Collections: + - Name: FoveaBox + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 4x V100 GPUs + Architecture: + - FPN + - ResNet + Paper: + URL: https://arxiv.org/abs/1904.03797 + Title: 'FoveaBox: Beyond Anchor-based Object Detector' + README: configs/foveabox/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/detectors/fovea.py#L6 + Version: v2.0.0 + +Models: + - Name: fovea_r50_fpn_4xb4-1x_coco + In Collection: FoveaBox + Config: configs/foveabox/fovea_r50_fpn_4xb4-1x_coco.py + Metadata: + Training Memory (GB): 5.6 + inference time (ms/im): + - value: 41.49 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 36.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_r50_fpn_4x4_1x_coco/fovea_r50_fpn_4x4_1x_coco_20200219-ee4d5303.pth + + - Name: fovea_r50_fpn_4xb4-2x_coco + In Collection: FoveaBox + Config: configs/foveabox/fovea_r50_fpn_4xb4-2x_coco.py + Metadata: + Training Memory (GB): 5.6 + inference time (ms/im): + - value: 41.49 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_r50_fpn_4x4_2x_coco/fovea_r50_fpn_4x4_2x_coco_20200203-2df792b1.pth + + - Name: fovea_r50_fpn_gn-head-align_4xb4-2x_coco + In Collection: FoveaBox + Config: configs/foveabox/fovea_r50_fpn_gn-head-align_4xb4-2x_coco.py + Metadata: + Training Memory (GB): 8.1 + inference time (ms/im): + - value: 51.55 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_align_r50_fpn_gn-head_4x4_2x_coco/fovea_align_r50_fpn_gn-head_4x4_2x_coco_20200203-8987880d.pth + + - Name: fovea_r50_fpn_gn-head-align_ms-640-800-4xb4-2x_coco + In Collection: FoveaBox + Config: configs/foveabox/fovea_r50_fpn_gn-head-align_ms-640-800-4xb4-2x_coco.py + Metadata: + Training Memory (GB): 8.1 + inference time (ms/im): + - value: 54.64 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_align_r50_fpn_gn-head_mstrain_640-800_4x4_2x_coco/fovea_align_r50_fpn_gn-head_mstrain_640-800_4x4_2x_coco_20200205-85ce26cb.pth + + - Name: fovea_r101_fpn_4xb4-1x_coco + In Collection: FoveaBox + Config: configs/foveabox/fovea_r101_fpn_4xb4-1x_coco.py + Metadata: + Training Memory (GB): 9.2 + inference time (ms/im): + - value: 57.47 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_r101_fpn_4x4_1x_coco/fovea_r101_fpn_4x4_1x_coco_20200219-05e38f1c.pth + + - Name: fovea_r101_fpn_4xb4-2x_coco + In Collection: FoveaBox + Config: configs/foveabox/fovea_r101_fpn_4xb4-2x_coco.py + Metadata: + Training Memory (GB): 11.7 + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_r101_fpn_4x4_2x_coco/fovea_r101_fpn_4x4_2x_coco_20200208-02320ea4.pth + + - Name: fovea_r101_fpn_gn-head-align_4xb4-2x_coco + In Collection: FoveaBox + Config: configs/foveabox/fovea_r101_fpn_gn-head-align_4xb4-2x_coco.py + Metadata: + Training Memory (GB): 11.7 + inference time (ms/im): + - value: 68.03 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_align_r101_fpn_gn-head_4x4_2x_coco/fovea_align_r101_fpn_gn-head_4x4_2x_coco_20200208-c39a027a.pth + + - Name: fovea_r101_fpn_gn-head-align_ms-640-800-4xb4-2x_coco + In Collection: FoveaBox + Config: configs/foveabox/fovea_r101_fpn_gn-head-align_ms-640-800-4xb4-2x_coco.py + Metadata: + Training Memory (GB): 11.7 + inference time (ms/im): + - value: 68.03 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/foveabox/fovea_align_r101_fpn_gn-head_mstrain_640-800_4x4_2x_coco/fovea_align_r101_fpn_gn-head_mstrain_640-800_4x4_2x_coco_20200208-649c5eb6.pth diff --git a/mmdetection/configs/fpg/README.md b/mmdetection/configs/fpg/README.md new file mode 100644 index 00000000..1e2fd400 --- /dev/null +++ b/mmdetection/configs/fpg/README.md @@ -0,0 +1,43 @@ +# FPG + +> [Feature Pyramid Grids](https://arxiv.org/abs/2004.03580) + + + +## Abstract + +Feature pyramid networks have been widely adopted in the object detection literature to improve feature representations for better handling of variations in scale. In this paper, we present Feature Pyramid Grids (FPG), a deep multi-pathway feature pyramid, that represents the feature scale-space as a regular grid of parallel bottom-up pathways which are fused by multi-directional lateral connections. FPG can improve single-pathway feature pyramid networks by significantly increasing its performance at similar computation cost, highlighting importance of deep pyramid representations. In addition to its general and uniform structure, over complicated structures that have been found with neural architecture search, it also compares favorably against such approaches without relying on search. We hope that FPG with its uniform and effective nature can serve as a strong component for future work in object recognition. + +
    + +
    + +## Results and Models + +We benchmark the new training schedule (crop training, large batch, unfrozen BN, 50 epochs) introduced in NAS-FPN. +All backbones are Resnet-50 in pytorch style. + +| Method | Neck | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :----------: | :--------: | :-----: | :------: | :------------: | :----: | :-----: | :--------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| Faster R-CNN | FPG | 50e | 20.0 | - | 42.3 | - | [config](./faster-rcnn_r50_fpg_crop640-50e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/fpg/faster_rcnn_r50_fpg_crop640_50e_coco/faster_rcnn_r50_fpg_crop640_50e_coco_20220311_011856-74109f42.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/fpg/faster_rcnn_r50_fpg_crop640_50e_coco/faster_rcnn_r50_fpg_crop640_50e_coco_20220311_011856.log.json) | +| Faster R-CNN | FPG-chn128 | 50e | 11.9 | - | 41.2 | - | [config](./faster-rcnn_r50_fpg-chn128_crop640-50e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/fpg/faster_rcnn_r50_fpg-chn128_crop640_50e_coco/faster_rcnn_r50_fpg-chn128_crop640_50e_coco_20220311_011857-9376aa9d.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/fpg/faster_rcnn_r50_fpg-chn128_crop640_50e_coco/faster_rcnn_r50_fpg-chn128_crop640_50e_coco_20220311_011857.log.json) | +| Faster R-CNN | FPN | 50e | 20.0 | - | 38.9 | - | [config](./faster-rcnn_r50_fpn_crop640-50e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/fpg/faster_rcnn_r50_fpn_crop640_50e_coco/faster_rcnn_r50_fpn_crop640_50e_coco_20220311_011857-be7c9f42.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/fpg/faster_rcnn_r50_fpn_crop640_50e_coco/faster_rcnn_r50_fpn_crop640_50e_coco_20220311_011857.log.json) | +| Mask R-CNN | FPG | 50e | 23.2 | - | 43.0 | 38.1 | [config](./mask-rcnn_r50_fpg_crop640-50e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/fpg/mask_rcnn_r50_fpg_crop640_50e_coco/mask_rcnn_r50_fpg_crop640_50e_coco_20220311_011857-233b8334.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/fpg/mask_rcnn_r50_fpg_crop640_50e_coco/mask_rcnn_r50_fpg_crop640_50e_coco_20220311_011857.log.json) | +| Mask R-CNN | FPG-chn128 | 50e | 15.3 | - | 41.7 | 37.1 | [config](./mask-rcnn_r50_fpg-chn128_crop640-50e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/fpg/mask_rcnn_r50_fpg-chn128_crop640_50e_coco/mask_rcnn_r50_fpg-chn128_crop640_50e_coco_20220311_011859-043c9b4e.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/fpg/mask_rcnn_r50_fpg-chn128_crop640_50e_coco/mask_rcnn_r50_fpg-chn128_crop640_50e_coco_20220311_011859.log.json) | +| Mask R-CNN | FPN | 50e | 23.2 | - | 49.6 | 35.6 | [config](./mask-rcnn_r50_fpn_crop640-50e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/fpg/mask_rcnn_r50_fpn_crop640_50e_coco/mask_rcnn_r50_fpn_crop640_50e_coco_20220311_011855-a756664a.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/fpg/mask_rcnn_r50_fpn_crop640_50e_coco/mask_rcnn_r50_fpn_crop640_50e_coco_20220311_011855.log.json) | +| RetinaNet | FPG | 50e | 20.8 | - | 40.5 | - | [config](./retinanet_r50_fpg_crop640_50e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/fpg/retinanet_r50_fpg_crop640_50e_coco/retinanet_r50_fpg_crop640_50e_coco_20220311_110809-b0bcf5f4.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/fpg/retinanet_r50_fpg_crop640_50e_coco/retinanet_r50_fpg_crop640_50e_coco_20220311_110809.log.json) | +| RetinaNet | FPG-chn128 | 50e | 19.9 | - | 39.9 | - | [config](./retinanet_r50_fpg-chn128_crop640_50e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/fpg/retinanet_r50_fpg-chn128_crop640_50e_coco/retinanet_r50_fpg-chn128_crop640_50e_coco_20220313_104829-ee99a686.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/fpg/retinanet_r50_fpg-chn128_crop640_50e_coco/retinanet_r50_fpg-chn128_crop640_50e_coco_20220313_104829.log.json) | + +**Note**: Chn128 means to decrease the number of channels of features and convs from 256 (default) to 128 in +Neck and BBox Head, which can greatly decrease memory consumption without sacrificing much precision. + +## Citation + +```latex +@article{chen2020feature, + title={Feature pyramid grids}, + author={Chen, Kai and Cao, Yuhang and Loy, Chen Change and Lin, Dahua and Feichtenhofer, Christoph}, + journal={arXiv preprint arXiv:2004.03580}, + year={2020} +} +``` diff --git a/mmdetection/configs/fpg/faster-rcnn_r50_fpg-chn128_crop640-50e_coco.py b/mmdetection/configs/fpg/faster-rcnn_r50_fpg-chn128_crop640-50e_coco.py new file mode 100644 index 00000000..cb9160f5 --- /dev/null +++ b/mmdetection/configs/fpg/faster-rcnn_r50_fpg-chn128_crop640-50e_coco.py @@ -0,0 +1,9 @@ +_base_ = 'faster-rcnn_r50_fpg_crop640-50e_coco.py' + +norm_cfg = dict(type='BN', requires_grad=True) +model = dict( + neck=dict(out_channels=128, inter_channels=128), + rpn_head=dict(in_channels=128), + roi_head=dict( + bbox_roi_extractor=dict(out_channels=128), + bbox_head=dict(in_channels=128))) diff --git a/mmdetection/configs/fpg/faster-rcnn_r50_fpg_crop640-50e_coco.py b/mmdetection/configs/fpg/faster-rcnn_r50_fpg_crop640-50e_coco.py new file mode 100644 index 00000000..d0d366f1 --- /dev/null +++ b/mmdetection/configs/fpg/faster-rcnn_r50_fpg_crop640-50e_coco.py @@ -0,0 +1,48 @@ +_base_ = 'faster-rcnn_r50_fpn_crop640-50e_coco.py' + +norm_cfg = dict(type='BN', requires_grad=True) +model = dict( + neck=dict( + type='FPG', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + inter_channels=256, + num_outs=5, + stack_times=9, + paths=['bu'] * 9, + same_down_trans=None, + same_up_trans=dict( + type='conv', + kernel_size=3, + stride=2, + padding=1, + norm_cfg=norm_cfg, + inplace=False, + order=('act', 'conv', 'norm')), + across_lateral_trans=dict( + type='conv', + kernel_size=1, + norm_cfg=norm_cfg, + inplace=False, + order=('act', 'conv', 'norm')), + across_down_trans=dict( + type='interpolation_conv', + mode='nearest', + kernel_size=3, + norm_cfg=norm_cfg, + order=('act', 'conv', 'norm'), + inplace=False), + across_up_trans=None, + across_skip_trans=dict( + type='conv', + kernel_size=1, + norm_cfg=norm_cfg, + inplace=False, + order=('act', 'conv', 'norm')), + output_trans=dict( + type='last_conv', + kernel_size=3, + order=('act', 'conv', 'norm'), + inplace=False), + norm_cfg=norm_cfg, + skip_inds=[(0, 1, 2, 3), (0, 1, 2), (0, 1), (0, ), ()])) diff --git a/mmdetection/configs/fpg/faster-rcnn_r50_fpn_crop640-50e_coco.py b/mmdetection/configs/fpg/faster-rcnn_r50_fpn_crop640-50e_coco.py new file mode 100644 index 00000000..46211de0 --- /dev/null +++ b/mmdetection/configs/fpg/faster-rcnn_r50_fpn_crop640-50e_coco.py @@ -0,0 +1,73 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +norm_cfg = dict(type='BN', requires_grad=True) +image_size = (640, 640) +batch_augments = [dict(type='BatchFixedSizePad', size=image_size)] + +model = dict( + data_preprocessor=dict(pad_size_divisor=64, batch_augments=batch_augments), + backbone=dict(norm_cfg=norm_cfg, norm_eval=False), + neck=dict(norm_cfg=norm_cfg), + roi_head=dict(bbox_head=dict(norm_cfg=norm_cfg))) +dataset_type = 'CocoDataset' +data_root = 'data/coco/' + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomResize', + scale=image_size, + ratio_range=(0.8, 1.2), + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=image_size, + allow_negative_crop=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=image_size, keep_ratio=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict( + batch_size=8, num_workers=4, dataset=dict(pipeline=train_pipeline)) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader + +# learning policy +max_epochs = 50 +train_cfg = dict(max_epochs=max_epochs, val_interval=2) +param_scheduler = [ + dict(type='LinearLR', start_factor=0.1, by_epoch=False, begin=0, end=1000), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[30, 40], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.08, momentum=0.9, weight_decay=0.0001), + paramwise_cfg=dict(norm_decay_mult=0, bypass_duplicate=True), + clip_grad=None) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (8 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/fpg/mask-rcnn_r50_fpg-chn128_crop640-50e_coco.py b/mmdetection/configs/fpg/mask-rcnn_r50_fpg-chn128_crop640-50e_coco.py new file mode 100644 index 00000000..80439396 --- /dev/null +++ b/mmdetection/configs/fpg/mask-rcnn_r50_fpg-chn128_crop640-50e_coco.py @@ -0,0 +1,10 @@ +_base_ = 'mask-rcnn_r50_fpg_crop640-50e_coco.py' + +model = dict( + neck=dict(out_channels=128, inter_channels=128), + rpn_head=dict(in_channels=128), + roi_head=dict( + bbox_roi_extractor=dict(out_channels=128), + bbox_head=dict(in_channels=128), + mask_roi_extractor=dict(out_channels=128), + mask_head=dict(in_channels=128))) diff --git a/mmdetection/configs/fpg/mask-rcnn_r50_fpg_crop640-50e_coco.py b/mmdetection/configs/fpg/mask-rcnn_r50_fpg_crop640-50e_coco.py new file mode 100644 index 00000000..135bb60b --- /dev/null +++ b/mmdetection/configs/fpg/mask-rcnn_r50_fpg_crop640-50e_coco.py @@ -0,0 +1,48 @@ +_base_ = 'mask-rcnn_r50_fpn_crop640-50e_coco.py' + +norm_cfg = dict(type='BN', requires_grad=True) +model = dict( + neck=dict( + type='FPG', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + inter_channels=256, + num_outs=5, + stack_times=9, + paths=['bu'] * 9, + same_down_trans=None, + same_up_trans=dict( + type='conv', + kernel_size=3, + stride=2, + padding=1, + norm_cfg=norm_cfg, + inplace=False, + order=('act', 'conv', 'norm')), + across_lateral_trans=dict( + type='conv', + kernel_size=1, + norm_cfg=norm_cfg, + inplace=False, + order=('act', 'conv', 'norm')), + across_down_trans=dict( + type='interpolation_conv', + mode='nearest', + kernel_size=3, + norm_cfg=norm_cfg, + order=('act', 'conv', 'norm'), + inplace=False), + across_up_trans=None, + across_skip_trans=dict( + type='conv', + kernel_size=1, + norm_cfg=norm_cfg, + inplace=False, + order=('act', 'conv', 'norm')), + output_trans=dict( + type='last_conv', + kernel_size=3, + order=('act', 'conv', 'norm'), + inplace=False), + norm_cfg=norm_cfg, + skip_inds=[(0, 1, 2, 3), (0, 1, 2), (0, 1), (0, ), ()])) diff --git a/mmdetection/configs/fpg/mask-rcnn_r50_fpn_crop640-50e_coco.py b/mmdetection/configs/fpg/mask-rcnn_r50_fpn_crop640-50e_coco.py new file mode 100644 index 00000000..08ca5b6f --- /dev/null +++ b/mmdetection/configs/fpg/mask-rcnn_r50_fpn_crop640-50e_coco.py @@ -0,0 +1,79 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +norm_cfg = dict(type='BN', requires_grad=True) +image_size = (640, 640) +batch_augments = [dict(type='BatchFixedSizePad', size=image_size)] + +model = dict( + data_preprocessor=dict(pad_size_divisor=64, batch_augments=batch_augments), + backbone=dict(norm_cfg=norm_cfg, norm_eval=False), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + norm_cfg=norm_cfg, + num_outs=5), + roi_head=dict( + bbox_head=dict(norm_cfg=norm_cfg), mask_head=dict(norm_cfg=norm_cfg))) +dataset_type = 'CocoDataset' +data_root = 'data/coco/' + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='RandomResize', + scale=image_size, + ratio_range=(0.8, 1.2), + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=image_size, + allow_negative_crop=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=image_size, keep_ratio=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict( + batch_size=8, num_workers=4, dataset=dict(pipeline=train_pipeline)) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader + +# learning policy +max_epochs = 50 +train_cfg = dict(max_epochs=max_epochs, val_interval=2) +param_scheduler = [ + dict(type='LinearLR', start_factor=0.1, by_epoch=False, begin=0, end=1000), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[30, 40], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.08, momentum=0.9, weight_decay=0.0001), + paramwise_cfg=dict(norm_decay_mult=0, bypass_duplicate=True), + clip_grad=None) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (8 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/fpg/metafile.yml b/mmdetection/configs/fpg/metafile.yml new file mode 100644 index 00000000..7d7634ae --- /dev/null +++ b/mmdetection/configs/fpg/metafile.yml @@ -0,0 +1,104 @@ +Collections: + - Name: Feature Pyramid Grids + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - Feature Pyramid Grids + Paper: + URL: https://arxiv.org/abs/2004.03580 + Title: 'Feature Pyramid Grids' + README: configs/fpg/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.10.0/mmdet/models/necks/fpg.py#L101 + Version: v2.10.0 + +Models: + - Name: faster-rcnn_r50_fpg_crop640-50e_coco + In Collection: Feature Pyramid Grids + Config: configs/fpg/faster-rcnn_r50_fpg_crop640-50e_coco.py + Metadata: + Training Memory (GB): 20.0 + Epochs: 50 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/fpg/faster_rcnn_r50_fpg_crop640_50e_coco/faster_rcnn_r50_fpg_crop640_50e_coco_20220311_011856-74109f42.pth + + - Name: faster-rcnn_r50_fpg-chn128_crop640-50e_coco + In Collection: Feature Pyramid Grids + Config: configs/fpg/faster-rcnn_r50_fpg-chn128_crop640-50e_coco.py + Metadata: + Training Memory (GB): 11.9 + Epochs: 50 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/fpg/faster_rcnn_r50_fpg-chn128_crop640_50e_coco/faster_rcnn_r50_fpg-chn128_crop640_50e_coco_20220311_011857-9376aa9d.pth + + - Name: mask-rcnn_r50_fpg_crop640-50e_coco + In Collection: Feature Pyramid Grids + Config: configs/fpg/mask-rcnn_r50_fpg_crop640-50e_coco.py + Metadata: + Training Memory (GB): 23.2 + Epochs: 50 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.0 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/fpg/mask_rcnn_r50_fpg_crop640_50e_coco/mask_rcnn_r50_fpg_crop640_50e_coco_20220311_011857-233b8334.pth + + - Name: mask-rcnn_r50_fpg-chn128_crop640-50e_coco + In Collection: Feature Pyramid Grids + Config: configs/fpg/mask-rcnn_r50_fpg-chn128_crop640-50e_coco.py + Metadata: + Training Memory (GB): 15.3 + Epochs: 50 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.7 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/fpg/mask_rcnn_r50_fpg-chn128_crop640_50e_coco/mask_rcnn_r50_fpg-chn128_crop640_50e_coco_20220311_011859-043c9b4e.pth + + - Name: retinanet_r50_fpg_crop640_50e_coco + In Collection: Feature Pyramid Grids + Config: configs/fpg/retinanet_r50_fpg_crop640_50e_coco.py + Metadata: + Training Memory (GB): 20.8 + Epochs: 50 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/fpg/retinanet_r50_fpg_crop640_50e_coco/retinanet_r50_fpg_crop640_50e_coco_20220311_110809-b0bcf5f4.pth + + - Name: retinanet_r50_fpg-chn128_crop640_50e_coco + In Collection: Feature Pyramid Grids + Config: configs/fpg/retinanet_r50_fpg-chn128_crop640_50e_coco.py + Metadata: + Training Memory (GB): 19.9 + Epochs: 50 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/fpg/retinanet_r50_fpg-chn128_crop640_50e_coco/retinanet_r50_fpg-chn128_crop640_50e_coco_20220313_104829-ee99a686.pth diff --git a/mmdetection/configs/fpg/retinanet_r50_fpg-chn128_crop640_50e_coco.py b/mmdetection/configs/fpg/retinanet_r50_fpg-chn128_crop640_50e_coco.py new file mode 100644 index 00000000..9a6cf7e5 --- /dev/null +++ b/mmdetection/configs/fpg/retinanet_r50_fpg-chn128_crop640_50e_coco.py @@ -0,0 +1,5 @@ +_base_ = 'retinanet_r50_fpg_crop640_50e_coco.py' + +model = dict( + neck=dict(out_channels=128, inter_channels=128), + bbox_head=dict(in_channels=128)) diff --git a/mmdetection/configs/fpg/retinanet_r50_fpg_crop640_50e_coco.py b/mmdetection/configs/fpg/retinanet_r50_fpg_crop640_50e_coco.py new file mode 100644 index 00000000..e2aac283 --- /dev/null +++ b/mmdetection/configs/fpg/retinanet_r50_fpg_crop640_50e_coco.py @@ -0,0 +1,53 @@ +_base_ = '../nas_fpn/retinanet_r50_nasfpn_crop640-50e_coco.py' + +norm_cfg = dict(type='BN', requires_grad=True) +model = dict( + neck=dict( + _delete_=True, + type='FPG', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + inter_channels=256, + num_outs=5, + add_extra_convs=True, + start_level=1, + stack_times=9, + paths=['bu'] * 9, + same_down_trans=None, + same_up_trans=dict( + type='conv', + kernel_size=3, + stride=2, + padding=1, + norm_cfg=norm_cfg, + inplace=False, + order=('act', 'conv', 'norm')), + across_lateral_trans=dict( + type='conv', + kernel_size=1, + norm_cfg=norm_cfg, + inplace=False, + order=('act', 'conv', 'norm')), + across_down_trans=dict( + type='interpolation_conv', + mode='nearest', + kernel_size=3, + norm_cfg=norm_cfg, + order=('act', 'conv', 'norm'), + inplace=False), + across_up_trans=None, + across_skip_trans=dict( + type='conv', + kernel_size=1, + norm_cfg=norm_cfg, + inplace=False, + order=('act', 'conv', 'norm')), + output_trans=dict( + type='last_conv', + kernel_size=3, + order=('act', 'conv', 'norm'), + inplace=False), + norm_cfg=norm_cfg, + skip_inds=[(0, 1, 2, 3), (0, 1, 2), (0, 1), (0, ), ()])) + +train_cfg = dict(val_interval=2) diff --git a/mmdetection/configs/free_anchor/README.md b/mmdetection/configs/free_anchor/README.md new file mode 100644 index 00000000..03dc8283 --- /dev/null +++ b/mmdetection/configs/free_anchor/README.md @@ -0,0 +1,37 @@ +# FreeAnchor + +> [FreeAnchor: Learning to Match Anchors for Visual Object Detection](https://arxiv.org/abs/1909.02466) + + + +## Abstract + +Modern CNN-based object detectors assign anchors for ground-truth objects under the restriction of object-anchor Intersection-over-Unit (IoU). In this study, we propose a learning-to-match approach to break IoU restriction, allowing objects to match anchors in a flexible manner. Our approach, referred to as FreeAnchor, updates hand-crafted anchor assignment to "free" anchor matching by formulating detector training as a maximum likelihood estimation (MLE) procedure. FreeAnchor targets at learning features which best explain a class of objects in terms of both classification and localization. FreeAnchor is implemented by optimizing detection customized likelihood and can be fused with CNN-based detectors in a plug-and-play manner. Experiments on COCO demonstrate that FreeAnchor consistently outperforms their counterparts with significant margins. + +
    + +
    + +## Results and Models + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :---------: | :-----: | :-----: | :------: | :------------: | :----: | :----------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | pytorch | 1x | 4.9 | 18.4 | 38.7 | [config](./freeanchor_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/free_anchor/retinanet_free_anchor_r50_fpn_1x_coco/retinanet_free_anchor_r50_fpn_1x_coco_20200130-0f67375f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/free_anchor/retinanet_free_anchor_r50_fpn_1x_coco/retinanet_free_anchor_r50_fpn_1x_coco_20200130_095625.log.json) | +| R-101 | pytorch | 1x | 6.8 | 14.9 | 40.3 | [config](./freeanchor_r101_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/free_anchor/retinanet_free_anchor_r101_fpn_1x_coco/retinanet_free_anchor_r101_fpn_1x_coco_20200130-358324e6.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/free_anchor/retinanet_free_anchor_r101_fpn_1x_coco/retinanet_free_anchor_r101_fpn_1x_coco_20200130_100723.log.json) | +| X-101-32x4d | pytorch | 1x | 8.1 | 11.1 | 41.9 | [config](./freeanchor_x101-32x4d_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/free_anchor/retinanet_free_anchor_x101_32x4d_fpn_1x_coco/retinanet_free_anchor_x101_32x4d_fpn_1x_coco_20200130-d4846968.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/free_anchor/retinanet_free_anchor_x101_32x4d_fpn_1x_coco/retinanet_free_anchor_x101_32x4d_fpn_1x_coco_20200130_095627.log.json) | + +**Notes:** + +- We use 8 GPUs with 2 images/GPU. +- For more settings and models, please refer to the [official repo](https://github.com/zhangxiaosong18/FreeAnchor). + +## Citation + +```latex +@inproceedings{zhang2019freeanchor, + title = {{FreeAnchor}: Learning to Match Anchors for Visual Object Detection}, + author = {Zhang, Xiaosong and Wan, Fang and Liu, Chang and Ji, Rongrong and Ye, Qixiang}, + booktitle = {Neural Information Processing Systems}, + year = {2019} +} +``` diff --git a/mmdetection/configs/free_anchor/freeanchor_r101_fpn_1x_coco.py b/mmdetection/configs/free_anchor/freeanchor_r101_fpn_1x_coco.py new file mode 100644 index 00000000..dc323d94 --- /dev/null +++ b/mmdetection/configs/free_anchor/freeanchor_r101_fpn_1x_coco.py @@ -0,0 +1,6 @@ +_base_ = './freeanchor_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/free_anchor/freeanchor_r50_fpn_1x_coco.py b/mmdetection/configs/free_anchor/freeanchor_r50_fpn_1x_coco.py new file mode 100644 index 00000000..13f64d14 --- /dev/null +++ b/mmdetection/configs/free_anchor/freeanchor_r50_fpn_1x_coco.py @@ -0,0 +1,22 @@ +_base_ = '../retinanet/retinanet_r50_fpn_1x_coco.py' +model = dict( + bbox_head=dict( + _delete_=True, + type='FreeAnchorRetinaHead', + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + octave_base_scale=4, + scales_per_octave=3, + ratios=[0.5, 1.0, 2.0], + strides=[8, 16, 32, 64, 128]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + loss_bbox=dict(type='SmoothL1Loss', beta=0.11, loss_weight=0.75))) + +optim_wrapper = dict(clip_grad=dict(max_norm=35, norm_type=2)) diff --git a/mmdetection/configs/free_anchor/freeanchor_x101-32x4d_fpn_1x_coco.py b/mmdetection/configs/free_anchor/freeanchor_x101-32x4d_fpn_1x_coco.py new file mode 100644 index 00000000..8e448bc1 --- /dev/null +++ b/mmdetection/configs/free_anchor/freeanchor_x101-32x4d_fpn_1x_coco.py @@ -0,0 +1,13 @@ +_base_ = './freeanchor_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/free_anchor/metafile.yml b/mmdetection/configs/free_anchor/metafile.yml new file mode 100644 index 00000000..cff19db6 --- /dev/null +++ b/mmdetection/configs/free_anchor/metafile.yml @@ -0,0 +1,79 @@ +Collections: + - Name: FreeAnchor + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - FreeAnchor + - ResNet + Paper: + URL: https://arxiv.org/abs/1909.02466 + Title: 'FreeAnchor: Learning to Match Anchors for Visual Object Detection' + README: configs/free_anchor/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/dense_heads/free_anchor_retina_head.py#L10 + Version: v2.0.0 + +Models: + - Name: freeanchor_r50_fpn_1x_coco + In Collection: FreeAnchor + Config: configs/free_anchor/freeanchor_r50_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.9 + inference time (ms/im): + - value: 54.35 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/free_anchor/retinanet_free_anchor_r50_fpn_1x_coco/retinanet_free_anchor_r50_fpn_1x_coco_20200130-0f67375f.pth + + - Name: freeanchor_r101_fpn_1x_coco + In Collection: FreeAnchor + Config: configs/free_anchor/freeanchor_r101_fpn_1x_coco.py + Metadata: + Training Memory (GB): 6.8 + inference time (ms/im): + - value: 67.11 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/free_anchor/retinanet_free_anchor_r101_fpn_1x_coco/retinanet_free_anchor_r101_fpn_1x_coco_20200130-358324e6.pth + + - Name: freeanchor_x101-32x4d_fpn_1x_coco + In Collection: FreeAnchor + Config: configs/free_anchor/freeanchor_x101-32x4d_fpn_1x_coco.py + Metadata: + Training Memory (GB): 8.1 + inference time (ms/im): + - value: 90.09 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/free_anchor/retinanet_free_anchor_x101_32x4d_fpn_1x_coco/retinanet_free_anchor_x101_32x4d_fpn_1x_coco_20200130-d4846968.pth diff --git a/mmdetection/configs/fsaf/README.md b/mmdetection/configs/fsaf/README.md new file mode 100644 index 00000000..46f60577 --- /dev/null +++ b/mmdetection/configs/fsaf/README.md @@ -0,0 +1,57 @@ +# FSAF + +> [Feature Selective Anchor-Free Module for Single-Shot Object Detection](https://arxiv.org/abs/1903.00621) + + + +## Abstract + +We motivate and present feature selective anchor-free (FSAF) module, a simple and effective building block for single-shot object detectors. It can be plugged into single-shot detectors with feature pyramid structure. The FSAF module addresses two limitations brought up by the conventional anchor-based detection: 1) heuristic-guided feature selection; 2) overlap-based anchor sampling. The general concept of the FSAF module is online feature selection applied to the training of multi-level anchor-free branches. Specifically, an anchor-free branch is attached to each level of the feature pyramid, allowing box encoding and decoding in the anchor-free manner at an arbitrary level. During training, we dynamically assign each instance to the most suitable feature level. At the time of inference, the FSAF module can work jointly with anchor-based branches by outputting predictions in parallel. We instantiate this concept with simple implementations of anchor-free branches and online feature selection strategy. Experimental results on the COCO detection track show that our FSAF module performs better than anchor-based counterparts while being faster. When working jointly with anchor-based branches, the FSAF module robustly improves the baseline RetinaNet by a large margin under various settings, while introducing nearly free inference overhead. And the resulting best model can achieve a state-of-the-art 44.6% mAP, outperforming all existing single-shot detectors on COCO. + +
    + +
    + +## Introduction + +FSAF is an anchor-free method published in CVPR2019 ([https://arxiv.org/pdf/1903.00621.pdf](https://arxiv.org/pdf/1903.00621.pdf)). +Actually it is equivalent to the anchor-based method with only one anchor at each feature map position in each FPN level. +And this is how we implemented it. +Only the anchor-free branch is released for its better compatibility with the current framework and less computational budget. + +In the original paper, feature maps within the central 0.2-0.5 area of a gt box are tagged as ignored. However, +it is empirically found that a hard threshold (0.2-0.2) gives a further gain on the performance. (see the table below) + +## Results and Models + +### Results on R50/R101/X101-FPN + +| Backbone | ignore range | ms-train | Lr schd | Train Mem (GB) | Train time (s/iter) | Inf time (fps) | box AP | Config | Download | +| :------: | :----------: | :------: | :-----: | :------------: | :-----------------: | :------------: | :---------: | :----------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | 0.2-0.5 | N | 1x | 3.15 | 0.43 | 12.3 | 36.0 (35.9) | | [model](https://download.openmmlab.com/mmdetection/v2.0/fsaf/fsaf_pscale0.2_nscale0.5_r50_fpn_1x_coco/fsaf_pscale0.2_nscale0.5_r50_fpn_1x_coco_20200715-b555b0e0.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/fsaf/fsaf_pscale0.2_nscale0.5_r50_fpn_1x_coco/fsaf_pscale0.2_nscale0.5_r50_fpn_1x_coco_20200715_094657.log.json) | +| R-50 | 0.2-0.2 | N | 1x | 3.15 | 0.43 | 13.0 | 37.4 | [config](./fsaf_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/fsaf/fsaf_r50_fpn_1x_coco/fsaf_r50_fpn_1x_coco-94ccc51f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/fsaf/fsaf_r50_fpn_1x_coco/fsaf_r50_fpn_1x_coco_20200428_072327.log.json) | +| R-101 | 0.2-0.2 | N | 1x | 5.08 | 0.58 | 10.8 | 39.3 (37.9) | [config](./fsaf_r101_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/fsaf/fsaf_r101_fpn_1x_coco/fsaf_r101_fpn_1x_coco-9e71098f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/fsaf/fsaf_r101_fpn_1x_coco/fsaf_r101_fpn_1x_coco_20200428_160348.log.json) | +| X-101 | 0.2-0.2 | N | 1x | 9.38 | 1.23 | 5.6 | 42.4 (41.0) | [config](./fsaf_x101-64x4d_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/fsaf/fsaf_x101_64x4d_fpn_1x_coco/fsaf_x101_64x4d_fpn_1x_coco-e3f6e6fd.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/fsaf/fsaf_x101_64x4d_fpn_1x_coco/fsaf_x101_64x4d_fpn_1x_coco_20200428_160424.log.json) | + +**Notes:** + +- *1x means the model is trained for 12 epochs.* +- *AP values in the brackets represent those reported in the original paper.* +- *All results are obtained with a single model and single-scale test.* +- *X-101 backbone represents ResNext-101-64x4d.* +- *All pretrained backbones use pytorch style.* +- *All models are trained on 8 Titan-XP gpus and tested on a single gpu.* + +## Citation + +BibTeX reference is as follows. + +```latex +@inproceedings{zhu2019feature, + title={Feature Selective Anchor-Free Module for Single-Shot Object Detection}, + author={Zhu, Chenchen and He, Yihui and Savvides, Marios}, + booktitle={Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition}, + pages={840--849}, + year={2019} +} +``` diff --git a/mmdetection/configs/fsaf/fsaf_r101_fpn_1x_coco.py b/mmdetection/configs/fsaf/fsaf_r101_fpn_1x_coco.py new file mode 100644 index 00000000..12b49fed --- /dev/null +++ b/mmdetection/configs/fsaf/fsaf_r101_fpn_1x_coco.py @@ -0,0 +1,6 @@ +_base_ = './fsaf_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/fsaf/fsaf_r50_fpn_1x_coco.py b/mmdetection/configs/fsaf/fsaf_r50_fpn_1x_coco.py new file mode 100644 index 00000000..e7165cd6 --- /dev/null +++ b/mmdetection/configs/fsaf/fsaf_r50_fpn_1x_coco.py @@ -0,0 +1,47 @@ +_base_ = '../retinanet/retinanet_r50_fpn_1x_coco.py' +# model settings +model = dict( + type='FSAF', + bbox_head=dict( + type='FSAFHead', + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + reg_decoded_bbox=True, + # Only anchor-free branch is implemented. The anchor generator only + # generates 1 anchor at each feature point, as a substitute of the + # grid of features. + anchor_generator=dict( + type='AnchorGenerator', + octave_base_scale=1, + scales_per_octave=1, + ratios=[1.0], + strides=[8, 16, 32, 64, 128]), + bbox_coder=dict(_delete_=True, type='TBLRBBoxCoder', normalizer=4.0), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0, + reduction='none'), + loss_bbox=dict( + _delete_=True, + type='IoULoss', + eps=1e-6, + loss_weight=1.0, + reduction='none')), + # training and testing settings + train_cfg=dict( + assigner=dict( + _delete_=True, + type='CenterRegionAssigner', + pos_scale=0.2, + neg_scale=0.2, + min_pos_iof=0.01), + allowed_border=-1, + pos_weight=-1, + debug=False)) + +optim_wrapper = dict(clip_grad=dict(max_norm=10, norm_type=2)) diff --git a/mmdetection/configs/fsaf/fsaf_x101-64x4d_fpn_1x_coco.py b/mmdetection/configs/fsaf/fsaf_x101-64x4d_fpn_1x_coco.py new file mode 100644 index 00000000..89c0c634 --- /dev/null +++ b/mmdetection/configs/fsaf/fsaf_x101-64x4d_fpn_1x_coco.py @@ -0,0 +1,14 @@ +_base_ = './fsaf_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/fsaf/metafile.yml b/mmdetection/configs/fsaf/metafile.yml new file mode 100644 index 00000000..daaad0d3 --- /dev/null +++ b/mmdetection/configs/fsaf/metafile.yml @@ -0,0 +1,80 @@ +Collections: + - Name: FSAF + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x Titan-XP GPUs + Architecture: + - FPN + - FSAF + - ResNet + Paper: + URL: https://arxiv.org/abs/1903.00621 + Title: 'Feature Selective Anchor-Free Module for Single-Shot Object Detection' + README: configs/fsaf/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/detectors/fsaf.py#L6 + Version: v2.1.0 + +Models: + - Name: fsaf_r50_fpn_1x_coco + In Collection: FSAF + Config: configs/fsaf/fsaf_r50_fpn_1x_coco.py + Metadata: + Training Memory (GB): 3.15 + inference time (ms/im): + - value: 76.92 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/fsaf/fsaf_r50_fpn_1x_coco/fsaf_r50_fpn_1x_coco-94ccc51f.pth + + - Name: fsaf_r101_fpn_1x_coco + In Collection: FSAF + Config: configs/fsaf/fsaf_r101_fpn_1x_coco.py + Metadata: + Training Memory (GB): 5.08 + inference time (ms/im): + - value: 92.59 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/fsaf/fsaf_r101_fpn_1x_coco/fsaf_r101_fpn_1x_coco-9e71098f.pth + + - Name: fsaf_x101-64x4d_fpn_1x_coco + In Collection: FSAF + Config: configs/fsaf/fsaf_x101-64x4d_fpn_1x_coco.py + Metadata: + Training Memory (GB): 9.38 + inference time (ms/im): + - value: 178.57 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/fsaf/fsaf_x101_64x4d_fpn_1x_coco/fsaf_x101_64x4d_fpn_1x_coco-e3f6e6fd.pth diff --git a/mmdetection/configs/gcnet/README.md b/mmdetection/configs/gcnet/README.md new file mode 100644 index 00000000..1ba6f6f3 --- /dev/null +++ b/mmdetection/configs/gcnet/README.md @@ -0,0 +1,69 @@ +# GCNet + +> [GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond](https://arxiv.org/abs/1904.11492) + + + +## Abstract + +The Non-Local Network (NLNet) presents a pioneering approach for capturing long-range dependencies, via aggregating query-specific global context to each query position. However, through a rigorous empirical analysis, we have found that the global contexts modeled by non-local network are almost the same for different query positions within an image. In this paper, we take advantage of this finding to create a simplified network based on a query-independent formulation, which maintains the accuracy of NLNet but with significantly less computation. We further observe that this simplified design shares similar structure with Squeeze-Excitation Network (SENet). Hence we unify them into a three-step general framework for global context modeling. Within the general framework, we design a better instantiation, called the global context (GC) block, which is lightweight and can effectively model the global context. The lightweight property allows us to apply it for multiple layers in a backbone network to construct a global context network (GCNet), which generally outperforms both simplified NLNet and SENet on major benchmarks for various recognition tasks. + +
    + +
    + +## Introduction + +By [Yue Cao](http://yue-cao.me), [Jiarui Xu](http://jerryxu.net), [Stephen Lin](https://scholar.google.com/citations?user=c3PYmxUAAAAJ&hl=en), Fangyun Wei, [Han Hu](https://sites.google.com/site/hanhushomepage/). + +We provide config files to reproduce the results in the paper for +["GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond"](https://arxiv.org/abs/1904.11492) on COCO object detection. + +**GCNet** is initially described in [arxiv](https://arxiv.org/abs/1904.11492). Via absorbing advantages of Non-Local Networks (NLNet) and Squeeze-Excitation Networks (SENet), GCNet provides a simple, fast and effective approach for global context modeling, which generally outperforms both NLNet and SENet on major benchmarks for various recognition tasks. + +## Results and Models + +The results on COCO 2017val are shown in the below table. + +| Backbone | Model | Context | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :-------: | :---: | :------------: | :-----: | :------: | :------------: | :----: | :-----: | :-----------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | Mask | GC(c3-c5, r16) | 1x | 5.0 | | 39.7 | 35.9 | [config](./mask-rcnn_r50-gcb-r16-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r50_fpn_r16_gcb_c3-c5_1x_coco/mask_rcnn_r50_fpn_r16_gcb_c3-c5_1x_coco_20200515_211915-187da160.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r50_fpn_r16_gcb_c3-c5_1x_coco/mask_rcnn_r50_fpn_r16_gcb_c3-c5_1x_coco_20200515_211915.log.json) | +| R-50-FPN | Mask | GC(c3-c5, r4) | 1x | 5.1 | 15.0 | 39.9 | 36.0 | [config](./mask-rcnn_r50-gcb-r4-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r50_fpn_r4_gcb_c3-c5_1x_coco/mask_rcnn_r50_fpn_r4_gcb_c3-c5_1x_coco_20200204-17235656.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r50_fpn_r4_gcb_c3-c5_1x_coco/mask_rcnn_r50_fpn_r4_gcb_c3-c5_1x_coco_20200204_024626.log.json) | +| R-101-FPN | Mask | GC(c3-c5, r16) | 1x | 7.6 | 11.4 | 41.3 | 37.2 | [config](./mask-rcnn_r101-gcb-r16-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r101_fpn_r16_gcb_c3-c5_1x_coco/mask_rcnn_r101_fpn_r16_gcb_c3-c5_1x_coco_20200205-e58ae947.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r101_fpn_r16_gcb_c3-c5_1x_coco/mask_rcnn_r101_fpn_r16_gcb_c3-c5_1x_coco_20200205_192835.log.json) | +| R-101-FPN | Mask | GC(c3-c5, r4) | 1x | 7.8 | 11.6 | 42.2 | 37.8 | [config](./mask-rcnn_r101-gcb-r4-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r101_fpn_r4_gcb_c3-c5_1x_coco/mask_rcnn_r101_fpn_r4_gcb_c3-c5_1x_coco_20200206-af22dc9d.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r101_fpn_r4_gcb_c3-c5_1x_coco/mask_rcnn_r101_fpn_r4_gcb_c3-c5_1x_coco_20200206_112128.log.json) | + +| Backbone | Model | Context | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :-------: | :--------------: | :------------: | :-----: | :------: | :------------: | :----: | :-----: | :--------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | Mask | - | 1x | 4.4 | 16.6 | 38.4 | 34.6 | [config](./mask-rcnn_r50-syncbn_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r50_fpn_syncbn-backbone_1x_coco/mask_rcnn_r50_fpn_syncbn-backbone_1x_coco_20200202-bb3eb55c.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r50_fpn_syncbn-backbone_1x_coco/mask_rcnn_r50_fpn_syncbn-backbone_1x_coco_20200202_214122.log.json) | +| R-50-FPN | Mask | GC(c3-c5, r16) | 1x | 5.0 | 15.5 | 40.4 | 36.2 | [config](./mask-rcnn_r50-syncbn-gcb-r16-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r50_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco/mask_rcnn_r50_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco_20200202-587b99aa.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r50_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco/mask_rcnn_r50_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco_20200202_174907.log.json) | +| R-50-FPN | Mask | GC(c3-c5, r4) | 1x | 5.1 | 15.1 | 40.7 | 36.5 | [config](./mask-rcnn_r50-syncbn-gcb-r4-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r50_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco/mask_rcnn_r50_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco_20200202-50b90e5c.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r50_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco/mask_rcnn_r50_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco_20200202_085547.log.json) | +| R-101-FPN | Mask | - | 1x | 6.4 | 13.3 | 40.5 | 36.3 | [config](./mask-rcnn_r101-syncbn_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r101_fpn_syncbn-backbone_1x_coco/mask_rcnn_r101_fpn_syncbn-backbone_1x_coco_20200210-81658c8a.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r101_fpn_syncbn-backbone_1x_coco/mask_rcnn_r101_fpn_syncbn-backbone_1x_coco_20200210_220422.log.json) | +| R-101-FPN | Mask | GC(c3-c5, r16) | 1x | 7.6 | 12.0 | 42.2 | 37.8 | [config](./mask-rcnn_r101-syncbn-gcb-r16-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r101_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco/mask_rcnn_r101_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco_20200207-945e77ca.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r101_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco/mask_rcnn_r101_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco_20200207_015330.log.json) | +| R-101-FPN | Mask | GC(c3-c5, r4) | 1x | 7.8 | 11.8 | 42.2 | 37.8 | [config](./mask-rcnn_r101-syncbn-gcb-r4-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r101_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco/mask_rcnn_r101_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco_20200206-8407a3f0.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r101_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco/mask_rcnn_r101_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco_20200206_142508.log.json) | +| X-101-FPN | Mask | - | 1x | 7.6 | 11.3 | 42.4 | 37.7 | [config](./mask-rcnn_x101-32x4d-syncbn_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_x101_32x4d_fpn_syncbn-backbone_1x_coco/mask_rcnn_x101_32x4d_fpn_syncbn-backbone_1x_coco_20200211-7584841c.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_x101_32x4d_fpn_syncbn-backbone_1x_coco/mask_rcnn_x101_32x4d_fpn_syncbn-backbone_1x_coco_20200211_054326.log.json) | +| X-101-FPN | Mask | GC(c3-c5, r16) | 1x | 8.8 | 9.8 | 43.5 | 38.6 | [config](./mask-rcnn_x101-32x4d-syncbn-gcb-r16-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco/mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco_20200211-cbed3d2c.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco/mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco_20200211_164715.log.json) | +| X-101-FPN | Mask | GC(c3-c5, r4) | 1x | 9.0 | 9.7 | 43.9 | 39.0 | [config](./mask-rcnn_x101-32x4d-syncbn-gcb-r4-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco/mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco_20200212-68164964.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco/mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco_20200212_070942.log.json) | +| X-101-FPN | Cascade Mask | - | 1x | 9.2 | 8.4 | 44.7 | 38.6 | [config](./cascade-mask-rcnn_x101-32x4d-syncbn_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gcnet/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_1x_coco_20200310-d5ad2a5e.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gcnet/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_1x_coco_20200310_115217.log.json) | +| X-101-FPN | Cascade Mask | GC(c3-c5, r16) | 1x | 10.3 | 7.7 | 46.2 | 39.7 | [config](./cascade-mask-rcnn_x101-32x4d-syncbn-r16-gcb-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gcnet/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco_20200211-10bf2463.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gcnet/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco_20200211_184154.log.json) | +| X-101-FPN | Cascade Mask | GC(c3-c5, r4) | 1x | 10.6 | | 46.4 | 40.1 | [config](./cascade-mask-rcnn_x101-32x4d-syncbn-r4-gcb-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gcnet/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco_20200703_180653-ed035291.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gcnet/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco_20200703_180653.log.json) | +| X-101-FPN | DCN Cascade Mask | - | 1x | | | 47.5 | 40.9 | [config](./cascade-mask-rcnn_x101-32x4d-syncbn-dconv-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gcnet/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_dconv_c3-c5_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_dconv_c3-c5_1x_coco_20210615_211019-abbc39ea.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gcnet/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_dconv_c3-c5_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_dconv_c3-c5_1x_coco_20210615_211019.log.json) | +| X-101-FPN | DCN Cascade Mask | GC(c3-c5, r16) | 1x | | | 48.0 | 41.3 | [config](./cascade-mask-rcnn_x101-32x4d-syncbn-dconv-c3-c5-r16-gcb-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gcnet/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_dconv_c3-c5_r16_gcb_c3-c5_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_dconv_c3-c5_r16_gcb_c3-c5_1x_coco_20210615_215648-44aa598a.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gcnet/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_dconv_c3-c5_r16_gcb_c3-c5_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_dconv_c3-c5_r16_gcb_c3-c5_1x_coco_20210615_215648.log.json) | +| X-101-FPN | DCN Cascade Mask | GC(c3-c5, r4) | 1x | | | 47.9 | 41.1 | [config](./cascade-mask-rcnn_x101-32x4d-syncbn-dconv-c3-c5-r4-gcb-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gcnet/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_dconv_c3-c5_r4_gcb_c3-c5_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_dconv_c3-c5_r4_gcb_c3-c5_1x_coco_20210615_161851-720338ec.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gcnet/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_dconv_c3-c5_r4_gcb_c3-c5_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_dconv_c3-c5_r4_gcb_c3-c5_1x_coco_20210615_161851.log.json) | + +**Notes:** + +- The `SyncBN` is added in the backbone for all models in **Table 2**. +- `GC` denotes Global Context (GC) block is inserted after 1x1 conv of backbone. +- `DCN` denotes replace 3x3 conv with 3x3 Deformable Convolution in `c3-c5` stages of backbone. +- `r4` and `r16` denote ratio 4 and ratio 16 in GC block respectively. + +## Citation + +```latex +@article{cao2019GCNet, + title={GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond}, + author={Cao, Yue and Xu, Jiarui and Lin, Stephen and Wei, Fangyun and Hu, Han}, + journal={arXiv preprint arXiv:1904.11492}, + year={2019} +} +``` diff --git a/mmdetection/configs/gcnet/cascade-mask-rcnn_x101-32x4d-syncbn-dconv-c3-c5-r16-gcb-c3-c5_fpn_1x_coco.py b/mmdetection/configs/gcnet/cascade-mask-rcnn_x101-32x4d-syncbn-dconv-c3-c5-r16-gcb-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..6cf605b6 --- /dev/null +++ b/mmdetection/configs/gcnet/cascade-mask-rcnn_x101-32x4d-syncbn-dconv-c3-c5-r16-gcb-c3-c5_fpn_1x_coco.py @@ -0,0 +1,11 @@ +_base_ = '../dcn/cascade-mask-rcnn_x101-32x4d-dconv-c3-c5_fpn_1x_coco.py' +model = dict( + backbone=dict( + norm_cfg=dict(type='SyncBN', requires_grad=True), + norm_eval=False, + plugins=[ + dict( + cfg=dict(type='ContextBlock', ratio=1. / 16), + stages=(False, True, True, True), + position='after_conv3') + ])) diff --git a/mmdetection/configs/gcnet/cascade-mask-rcnn_x101-32x4d-syncbn-dconv-c3-c5-r4-gcb-c3-c5_fpn_1x_coco.py b/mmdetection/configs/gcnet/cascade-mask-rcnn_x101-32x4d-syncbn-dconv-c3-c5-r4-gcb-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..95fc687b --- /dev/null +++ b/mmdetection/configs/gcnet/cascade-mask-rcnn_x101-32x4d-syncbn-dconv-c3-c5-r4-gcb-c3-c5_fpn_1x_coco.py @@ -0,0 +1,11 @@ +_base_ = '../dcn/cascade-mask-rcnn_x101-32x4d-dconv-c3-c5_fpn_1x_coco.py' +model = dict( + backbone=dict( + norm_cfg=dict(type='SyncBN', requires_grad=True), + norm_eval=False, + plugins=[ + dict( + cfg=dict(type='ContextBlock', ratio=1. / 4), + stages=(False, True, True, True), + position='after_conv3') + ])) diff --git a/mmdetection/configs/gcnet/cascade-mask-rcnn_x101-32x4d-syncbn-dconv-c3-c5_fpn_1x_coco.py b/mmdetection/configs/gcnet/cascade-mask-rcnn_x101-32x4d-syncbn-dconv-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..9b77dc93 --- /dev/null +++ b/mmdetection/configs/gcnet/cascade-mask-rcnn_x101-32x4d-syncbn-dconv-c3-c5_fpn_1x_coco.py @@ -0,0 +1,4 @@ +_base_ = '../dcn/cascade-mask-rcnn_x101-32x4d-dconv-c3-c5_fpn_1x_coco.py' +model = dict( + backbone=dict( + norm_cfg=dict(type='SyncBN', requires_grad=True), norm_eval=False)) diff --git a/mmdetection/configs/gcnet/cascade-mask-rcnn_x101-32x4d-syncbn-r16-gcb-c3-c5_fpn_1x_coco.py b/mmdetection/configs/gcnet/cascade-mask-rcnn_x101-32x4d-syncbn-r16-gcb-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..8f97972a --- /dev/null +++ b/mmdetection/configs/gcnet/cascade-mask-rcnn_x101-32x4d-syncbn-r16-gcb-c3-c5_fpn_1x_coco.py @@ -0,0 +1,11 @@ +_base_ = '../cascade_rcnn/cascade-mask-rcnn_x101-32x4d_fpn_1x_coco.py' +model = dict( + backbone=dict( + norm_cfg=dict(type='SyncBN', requires_grad=True), + norm_eval=False, + plugins=[ + dict( + cfg=dict(type='ContextBlock', ratio=1. / 16), + stages=(False, True, True, True), + position='after_conv3') + ])) diff --git a/mmdetection/configs/gcnet/cascade-mask-rcnn_x101-32x4d-syncbn-r4-gcb-c3-c5_fpn_1x_coco.py b/mmdetection/configs/gcnet/cascade-mask-rcnn_x101-32x4d-syncbn-r4-gcb-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..8404cfda --- /dev/null +++ b/mmdetection/configs/gcnet/cascade-mask-rcnn_x101-32x4d-syncbn-r4-gcb-c3-c5_fpn_1x_coco.py @@ -0,0 +1,11 @@ +_base_ = '../cascade_rcnn/cascade-mask-rcnn_x101-32x4d_fpn_1x_coco.py' +model = dict( + backbone=dict( + norm_cfg=dict(type='SyncBN', requires_grad=True), + norm_eval=False, + plugins=[ + dict( + cfg=dict(type='ContextBlock', ratio=1. / 4), + stages=(False, True, True, True), + position='after_conv3') + ])) diff --git a/mmdetection/configs/gcnet/cascade-mask-rcnn_x101-32x4d-syncbn_fpn_1x_coco.py b/mmdetection/configs/gcnet/cascade-mask-rcnn_x101-32x4d-syncbn_fpn_1x_coco.py new file mode 100644 index 00000000..87667dee --- /dev/null +++ b/mmdetection/configs/gcnet/cascade-mask-rcnn_x101-32x4d-syncbn_fpn_1x_coco.py @@ -0,0 +1,4 @@ +_base_ = '../cascade_rcnn/cascade-mask-rcnn_x101-32x4d_fpn_1x_coco.py' +model = dict( + backbone=dict( + norm_cfg=dict(type='SyncBN', requires_grad=True), norm_eval=False)) diff --git a/mmdetection/configs/gcnet/mask-rcnn_r101-gcb-r16-c3-c5_fpn_1x_coco.py b/mmdetection/configs/gcnet/mask-rcnn_r101-gcb-r16-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..447e2c6d --- /dev/null +++ b/mmdetection/configs/gcnet/mask-rcnn_r101-gcb-r16-c3-c5_fpn_1x_coco.py @@ -0,0 +1,8 @@ +_base_ = '../mask_rcnn/mask-rcnn_r101_fpn_1x_coco.py' +model = dict( + backbone=dict(plugins=[ + dict( + cfg=dict(type='ContextBlock', ratio=1. / 16), + stages=(False, True, True, True), + position='after_conv3') + ])) diff --git a/mmdetection/configs/gcnet/mask-rcnn_r101-gcb-r4-c3-c5_fpn_1x_coco.py b/mmdetection/configs/gcnet/mask-rcnn_r101-gcb-r4-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..9c723a64 --- /dev/null +++ b/mmdetection/configs/gcnet/mask-rcnn_r101-gcb-r4-c3-c5_fpn_1x_coco.py @@ -0,0 +1,8 @@ +_base_ = '../mask_rcnn/mask-rcnn_r101_fpn_1x_coco.py' +model = dict( + backbone=dict(plugins=[ + dict( + cfg=dict(type='ContextBlock', ratio=1. / 4), + stages=(False, True, True, True), + position='after_conv3') + ])) diff --git a/mmdetection/configs/gcnet/mask-rcnn_r101-syncbn-gcb-r16-c3-c5_fpn_1x_coco.py b/mmdetection/configs/gcnet/mask-rcnn_r101-syncbn-gcb-r16-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..6f9d03d3 --- /dev/null +++ b/mmdetection/configs/gcnet/mask-rcnn_r101-syncbn-gcb-r16-c3-c5_fpn_1x_coco.py @@ -0,0 +1,11 @@ +_base_ = '../mask_rcnn/mask-rcnn_r101_fpn_1x_coco.py' +model = dict( + backbone=dict( + norm_cfg=dict(type='SyncBN', requires_grad=True), + norm_eval=False, + plugins=[ + dict( + cfg=dict(type='ContextBlock', ratio=1. / 16), + stages=(False, True, True, True), + position='after_conv3') + ])) diff --git a/mmdetection/configs/gcnet/mask-rcnn_r101-syncbn-gcb-r4-c3-c5_fpn_1x_coco.py b/mmdetection/configs/gcnet/mask-rcnn_r101-syncbn-gcb-r4-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..d07cb0d4 --- /dev/null +++ b/mmdetection/configs/gcnet/mask-rcnn_r101-syncbn-gcb-r4-c3-c5_fpn_1x_coco.py @@ -0,0 +1,11 @@ +_base_ = '../mask_rcnn/mask-rcnn_r101_fpn_1x_coco.py' +model = dict( + backbone=dict( + norm_cfg=dict(type='SyncBN', requires_grad=True), + norm_eval=False, + plugins=[ + dict( + cfg=dict(type='ContextBlock', ratio=1. / 4), + stages=(False, True, True, True), + position='after_conv3') + ])) diff --git a/mmdetection/configs/gcnet/mask-rcnn_r101-syncbn_fpn_1x_coco.py b/mmdetection/configs/gcnet/mask-rcnn_r101-syncbn_fpn_1x_coco.py new file mode 100644 index 00000000..957bdf55 --- /dev/null +++ b/mmdetection/configs/gcnet/mask-rcnn_r101-syncbn_fpn_1x_coco.py @@ -0,0 +1,4 @@ +_base_ = '../mask_rcnn/mask-rcnn_r101_fpn_1x_coco.py' +model = dict( + backbone=dict( + norm_cfg=dict(type='SyncBN', requires_grad=True), norm_eval=False)) diff --git a/mmdetection/configs/gcnet/mask-rcnn_r50-gcb-r16-c3-c5_fpn_1x_coco.py b/mmdetection/configs/gcnet/mask-rcnn_r50-gcb-r16-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..c9ec5ac3 --- /dev/null +++ b/mmdetection/configs/gcnet/mask-rcnn_r50-gcb-r16-c3-c5_fpn_1x_coco.py @@ -0,0 +1,8 @@ +_base_ = '../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict(plugins=[ + dict( + cfg=dict(type='ContextBlock', ratio=1. / 16), + stages=(False, True, True, True), + position='after_conv3') + ])) diff --git a/mmdetection/configs/gcnet/mask-rcnn_r50-gcb-r4-c3-c5_fpn_1x_coco.py b/mmdetection/configs/gcnet/mask-rcnn_r50-gcb-r4-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..42474d51 --- /dev/null +++ b/mmdetection/configs/gcnet/mask-rcnn_r50-gcb-r4-c3-c5_fpn_1x_coco.py @@ -0,0 +1,8 @@ +_base_ = '../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict(plugins=[ + dict( + cfg=dict(type='ContextBlock', ratio=1. / 4), + stages=(False, True, True, True), + position='after_conv3') + ])) diff --git a/mmdetection/configs/gcnet/mask-rcnn_r50-syncbn-gcb-r16-c3-c5_fpn_1x_coco.py b/mmdetection/configs/gcnet/mask-rcnn_r50-syncbn-gcb-r16-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..ac192808 --- /dev/null +++ b/mmdetection/configs/gcnet/mask-rcnn_r50-syncbn-gcb-r16-c3-c5_fpn_1x_coco.py @@ -0,0 +1,11 @@ +_base_ = '../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + norm_cfg=dict(type='SyncBN', requires_grad=True), + norm_eval=False, + plugins=[ + dict( + cfg=dict(type='ContextBlock', ratio=1. / 16), + stages=(False, True, True, True), + position='after_conv3') + ])) diff --git a/mmdetection/configs/gcnet/mask-rcnn_r50-syncbn-gcb-r4-c3-c5_fpn_1x_coco.py b/mmdetection/configs/gcnet/mask-rcnn_r50-syncbn-gcb-r4-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..ae29f0ce --- /dev/null +++ b/mmdetection/configs/gcnet/mask-rcnn_r50-syncbn-gcb-r4-c3-c5_fpn_1x_coco.py @@ -0,0 +1,11 @@ +_base_ = '../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + norm_cfg=dict(type='SyncBN', requires_grad=True), + norm_eval=False, + plugins=[ + dict( + cfg=dict(type='ContextBlock', ratio=1. / 4), + stages=(False, True, True, True), + position='after_conv3') + ])) diff --git a/mmdetection/configs/gcnet/mask-rcnn_r50-syncbn_fpn_1x_coco.py b/mmdetection/configs/gcnet/mask-rcnn_r50-syncbn_fpn_1x_coco.py new file mode 100644 index 00000000..f8ef27ba --- /dev/null +++ b/mmdetection/configs/gcnet/mask-rcnn_r50-syncbn_fpn_1x_coco.py @@ -0,0 +1,4 @@ +_base_ = '../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + norm_cfg=dict(type='SyncBN', requires_grad=True), norm_eval=False)) diff --git a/mmdetection/configs/gcnet/mask-rcnn_x101-32x4d-syncbn-gcb-r16-c3-c5_fpn_1x_coco.py b/mmdetection/configs/gcnet/mask-rcnn_x101-32x4d-syncbn-gcb-r16-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..1a2e2c9f --- /dev/null +++ b/mmdetection/configs/gcnet/mask-rcnn_x101-32x4d-syncbn-gcb-r16-c3-c5_fpn_1x_coco.py @@ -0,0 +1,11 @@ +_base_ = '../mask_rcnn/mask-rcnn_x101-32x4d_fpn_1x_coco.py' +model = dict( + backbone=dict( + norm_cfg=dict(type='SyncBN', requires_grad=True), + norm_eval=False, + plugins=[ + dict( + cfg=dict(type='ContextBlock', ratio=1. / 16), + stages=(False, True, True, True), + position='after_conv3') + ])) diff --git a/mmdetection/configs/gcnet/mask-rcnn_x101-32x4d-syncbn-gcb-r4-c3-c5_fpn_1x_coco.py b/mmdetection/configs/gcnet/mask-rcnn_x101-32x4d-syncbn-gcb-r4-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..65d3f9aa --- /dev/null +++ b/mmdetection/configs/gcnet/mask-rcnn_x101-32x4d-syncbn-gcb-r4-c3-c5_fpn_1x_coco.py @@ -0,0 +1,11 @@ +_base_ = '../mask_rcnn/mask-rcnn_x101-32x4d_fpn_1x_coco.py' +model = dict( + backbone=dict( + norm_cfg=dict(type='SyncBN', requires_grad=True), + norm_eval=False, + plugins=[ + dict( + cfg=dict(type='ContextBlock', ratio=1. / 4), + stages=(False, True, True, True), + position='after_conv3') + ])) diff --git a/mmdetection/configs/gcnet/mask-rcnn_x101-32x4d-syncbn_fpn_1x_coco.py b/mmdetection/configs/gcnet/mask-rcnn_x101-32x4d-syncbn_fpn_1x_coco.py new file mode 100644 index 00000000..b5343a6d --- /dev/null +++ b/mmdetection/configs/gcnet/mask-rcnn_x101-32x4d-syncbn_fpn_1x_coco.py @@ -0,0 +1,4 @@ +_base_ = '../mask_rcnn/mask-rcnn_x101-32x4d_fpn_1x_coco.py' +model = dict( + backbone=dict( + norm_cfg=dict(type='SyncBN', requires_grad=True), norm_eval=False)) diff --git a/mmdetection/configs/gcnet/metafile.yml b/mmdetection/configs/gcnet/metafile.yml new file mode 100644 index 00000000..075a94c8 --- /dev/null +++ b/mmdetection/configs/gcnet/metafile.yml @@ -0,0 +1,440 @@ +Collections: + - Name: GCNet + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - Global Context Block + - FPN + - RPN + - ResNet + - ResNeXt + Paper: + URL: https://arxiv.org/abs/1904.11492 + Title: 'GCNet: Non-local Networks Meet Squeeze-Excitation Networks and Beyond' + README: configs/gcnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/ops/context_block.py#L13 + Version: v2.0.0 + +Models: + - Name: mask-rcnn_r50_fpn_r16_gcb_c3-c5_1x_coco + In Collection: GCNet + Config: configs/gcnet/mask-rcnn_r50-gcb-r16-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 5.0 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.7 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 35.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r50_fpn_r16_gcb_c3-c5_1x_coco/mask_rcnn_r50_fpn_r16_gcb_c3-c5_1x_coco_20200515_211915-187da160.pth + + - Name: mask-rcnn_r50_fpn_r4_gcb_c3-c5_1x_coco + In Collection: GCNet + Config: configs/gcnet/mask-rcnn_r50-gcb-r4-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 5.1 + inference time (ms/im): + - value: 66.67 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.9 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r50_fpn_r4_gcb_c3-c5_1x_coco/mask_rcnn_r50_fpn_r4_gcb_c3-c5_1x_coco_20200204-17235656.pth + + - Name: mask-rcnn_r101-gcb-r16-c3-c5_fpn_1x_coco + In Collection: GCNet + Config: configs/gcnet/mask-rcnn_r101-gcb-r16-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 7.6 + inference time (ms/im): + - value: 87.72 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.3 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r101_fpn_r16_gcb_c3-c5_1x_coco/mask_rcnn_r101_fpn_r16_gcb_c3-c5_1x_coco_20200205-e58ae947.pth + + - Name: mask-rcnn_r101-gcb-r4-c3-c5_fpn_1x_coco + In Collection: GCNet + Config: configs/gcnet/mask-rcnn_r101-gcb-r4-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 7.8 + inference time (ms/im): + - value: 86.21 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.2 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r101_fpn_r4_gcb_c3-c5_1x_coco/mask_rcnn_r101_fpn_r4_gcb_c3-c5_1x_coco_20200206-af22dc9d.pth + + - Name: mask-rcnn_r50_fpn_syncbn-backbone_1x_coco + In Collection: GCNet + Config: configs/gcnet/mask-rcnn_r50-syncbn_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.4 + inference time (ms/im): + - value: 60.24 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.4 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 34.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r50_fpn_syncbn-backbone_1x_coco/mask_rcnn_r50_fpn_syncbn-backbone_1x_coco_20200202-bb3eb55c.pth + + - Name: mask-rcnn_r50_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco + In Collection: GCNet + Config: configs/gcnet/mask-rcnn_r50-syncbn-gcb-r16-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 5.0 + inference time (ms/im): + - value: 64.52 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.4 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r50_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco/mask_rcnn_r50_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco_20200202-587b99aa.pth + + - Name: mask-rcnn_r50_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco + In Collection: GCNet + Config: configs/gcnet/mask-rcnn_r50-syncbn-gcb-r4-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 5.1 + inference time (ms/im): + - value: 66.23 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.7 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r50_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco/mask_rcnn_r50_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco_20200202-50b90e5c.pth + + - Name: mask-rcnn_r101-syncbn_fpn_1x_coco + In Collection: GCNet + Config: configs/gcnet/mask-rcnn_r101-syncbn_fpn_1x_coco.py + Metadata: + Training Memory (GB): 6.4 + inference time (ms/im): + - value: 75.19 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.5 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r101_fpn_syncbn-backbone_1x_coco/mask_rcnn_r101_fpn_syncbn-backbone_1x_coco_20200210-81658c8a.pth + + - Name: mask-rcnn_r101-syncbn-gcb-r16-c3-c5_fpn_1x_coco + In Collection: GCNet + Config: configs/gcnet/mask-rcnn_r101-syncbn-gcb-r16-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 7.6 + inference time (ms/im): + - value: 83.33 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.2 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r101_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco/mask_rcnn_r101_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco_20200207-945e77ca.pth + + - Name: mask-rcnn_r101-syncbn-gcb-r4-c3-c5_fpn_1x_coco + In Collection: GCNet + Config: configs/gcnet/mask-rcnn_r101-syncbn-gcb-r4-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 7.8 + inference time (ms/im): + - value: 84.75 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.2 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r101_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco/mask_rcnn_r101_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco_20200206-8407a3f0.pth + + - Name: mask-rcnn_x101-32x4d-syncbn_fpn_1x_coco + In Collection: GCNet + Config: configs/gcnet/mask-rcnn_x101-32x4d-syncbn_fpn_1x_coco.py + Metadata: + Training Memory (GB): 7.6 + inference time (ms/im): + - value: 88.5 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.4 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_x101_32x4d_fpn_syncbn-backbone_1x_coco/mask_rcnn_x101_32x4d_fpn_syncbn-backbone_1x_coco_20200211-7584841c.pth + + - Name: mask-rcnn_x101-32x4d-syncbn-gcb-r16-c3-c5_fpn_1x_coco + In Collection: GCNet + Config: configs/gcnet/mask-rcnn_x101-32x4d-syncbn-gcb-r16-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 8.8 + inference time (ms/im): + - value: 102.04 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.5 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco/mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco_20200211-cbed3d2c.pth + + - Name: mask-rcnn_x101-32x4d-syncbn-gcb-r4-c3-c5_fpn_1x_coco + In Collection: GCNet + Config: configs/gcnet/mask-rcnn_x101-32x4d-syncbn-gcb-r4-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 9.0 + inference time (ms/im): + - value: 103.09 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.9 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco/mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco_20200212-68164964.pth + + - Name: cascade-mask-rcnn_x101-32x4d-syncbn_fpn_1x_coco + In Collection: GCNet + Config: configs/gcnet/cascade-mask-rcnn_x101-32x4d-syncbn_fpn_1x_coco.py + Metadata: + Training Memory (GB): 9.2 + inference time (ms/im): + - value: 119.05 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.7 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gcnet/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_1x_coco_20200310-d5ad2a5e.pth + + - Name: cascade-mask-rcnn_x101-32x4d-syncbn-r16-gcb-c3-c5_fpn_1x_coco + In Collection: GCNet + Config: configs/gcnet/cascade-mask-rcnn_x101-32x4d-syncbn-r16-gcb-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 10.3 + inference time (ms/im): + - value: 129.87 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.2 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gcnet/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco_20200211-10bf2463.pth + + - Name: cascade-mask-rcnn_x101-32x4d-syncbn-r4-gcb-c3-c5_fpn_1x_coco + In Collection: GCNet + Config: configs/gcnet/cascade-mask-rcnn_x101-32x4d-syncbn-r4-gcb-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 10.6 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.4 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 40.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gcnet/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco_20200703_180653-ed035291.pth + + - Name: cascade-mask-rcnn_x101-32x4d-syncbn-dconv-c3-c5_fpn_1x_coco + In Collection: GCNet + Config: configs/gcnet/cascade-mask-rcnn_x101-32x4d-syncbn-dconv-c3-c5_fpn_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 47.5 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 40.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gcnet/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_dconv_c3-c5_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_dconv_c3-c5_1x_coco_20210615_211019-abbc39ea.pth + + - Name: cascade-mask-rcnn_x101-32x4d-syncbn-dconv-c3-c5-r16-gcb-c3-c5_fpn_1x_coco + In Collection: GCNet + Config: configs/gcnet/cascade-mask-rcnn_x101-32x4d-syncbn-dconv-c3-c5-r16-gcb-c3-c5_fpn_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 48.0 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 41.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gcnet/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_dconv_c3-c5_r16_gcb_c3-c5_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_dconv_c3-c5_r16_gcb_c3-c5_1x_coco_20210615_215648-44aa598a.pth + + - Name: cascade-mask-rcnn_x101-32x4d-syncbn-dconv-c3-c5-r4-gcb-c3-c5_fpn_1x_coco + In Collection: GCNet + Config: configs/gcnet/cascade-mask-rcnn_x101-32x4d-syncbn-dconv-c3-c5-r4-gcb-c3-c5_fpn_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 47.9 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 41.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gcnet/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_dconv_c3-c5_r4_gcb_c3-c5_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_syncbn-backbone_dconv_c3-c5_r4_gcb_c3-c5_1x_coco_20210615_161851-720338ec.pth diff --git a/mmdetection/configs/gfl/README.md b/mmdetection/configs/gfl/README.md new file mode 100644 index 00000000..123f303a --- /dev/null +++ b/mmdetection/configs/gfl/README.md @@ -0,0 +1,42 @@ +# GFL + +> [Generalized Focal Loss: Learning Qualified and Distributed Bounding Boxes for Dense Object Detection](https://arxiv.org/abs/2006.04388) + + + +## Abstract + +One-stage detector basically formulates object detection as dense classification and localization. The classification is usually optimized by Focal Loss and the box location is commonly learned under Dirac delta distribution. A recent trend for one-stage detectors is to introduce an individual prediction branch to estimate the quality of localization, where the predicted quality facilitates the classification to improve detection performance. This paper delves into the representations of the above three fundamental elements: quality estimation, classification and localization. Two problems are discovered in existing practices, including (1) the inconsistent usage of the quality estimation and classification between training and inference and (2) the inflexible Dirac delta distribution for localization when there is ambiguity and uncertainty in complex scenes. To address the problems, we design new representations for these elements. Specifically, we merge the quality estimation into the class prediction vector to form a joint representation of localization quality and classification, and use a vector to represent arbitrary distribution of box locations. The improved representations eliminate the inconsistency risk and accurately depict the flexible distribution in real data, but contain continuous labels, which is beyond the scope of Focal Loss. We then propose Generalized Focal Loss (GFL) that generalizes Focal Loss from its discrete form to the continuous version for successful optimization. On COCO test-dev, GFL achieves 45.0% AP using ResNet-101 backbone, surpassing state-of-the-art SAPD (43.5%) and ATSS (43.6%) with higher or comparable inference speed, under the same backbone and training settings. Notably, our best model can achieve a single-model single-scale AP of 48.2%, at 10 FPS on a single 2080Ti GPU. + +
    + +
    + +## Results and Models + +| Backbone | Style | Lr schd | Multi-scale Training | Inf time (fps) | box AP | Config | Download | +| :---------------: | :-----: | :-----: | :------------------: | :------------: | :----: | :------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | pytorch | 1x | No | 19.5 | 40.2 | [config](./gfl_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gfl/gfl_r50_fpn_1x_coco/gfl_r50_fpn_1x_coco_20200629_121244-25944287.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gfl/gfl_r50_fpn_1x_coco/gfl_r50_fpn_1x_coco_20200629_121244.log.json) | +| R-50 | pytorch | 2x | Yes | 19.5 | 42.9 | [config](./gfl_r50_fpn_ms-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gfl/gfl_r50_fpn_mstrain_2x_coco/gfl_r50_fpn_mstrain_2x_coco_20200629_213802-37bb1edc.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gfl/gfl_r50_fpn_mstrain_2x_coco/gfl_r50_fpn_mstrain_2x_coco_20200629_213802.log.json) | +| R-101 | pytorch | 2x | Yes | 14.7 | 44.7 | [config](./gfl_r101_fpn_ms-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gfl/gfl_r101_fpn_mstrain_2x_coco/gfl_r101_fpn_mstrain_2x_coco_20200629_200126-dd12f847.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gfl/gfl_r101_fpn_mstrain_2x_coco/gfl_r101_fpn_mstrain_2x_coco_20200629_200126.log.json) | +| R-101-dcnv2 | pytorch | 2x | Yes | 12.9 | 47.1 | [config](./gfl_r101-dconv-c3-c5_fpn_ms-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gfl/gfl_r101_fpn_dconv_c3-c5_mstrain_2x_coco/gfl_r101_fpn_dconv_c3-c5_mstrain_2x_coco_20200630_102002-134b07df.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gfl/gfl_r101_fpn_dconv_c3-c5_mstrain_2x_coco/gfl_r101_fpn_dconv_c3-c5_mstrain_2x_coco_20200630_102002.log.json) | +| X-101-32x4d | pytorch | 2x | Yes | 12.1 | 45.9 | [config](./gfl_x101-32x4d_fpn_ms-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gfl/gfl_x101_32x4d_fpn_mstrain_2x_coco/gfl_x101_32x4d_fpn_mstrain_2x_coco_20200630_102002-50c1ffdb.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gfl/gfl_x101_32x4d_fpn_mstrain_2x_coco/gfl_x101_32x4d_fpn_mstrain_2x_coco_20200630_102002.log.json) | +| X-101-32x4d-dcnv2 | pytorch | 2x | Yes | 10.7 | 48.1 | [config](./gfl_x101-32x4d-dconv-c4-c5_fpn_ms-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gfl/gfl_x101_32x4d_fpn_dconv_c4-c5_mstrain_2x_coco/gfl_x101_32x4d_fpn_dconv_c4-c5_mstrain_2x_coco_20200630_102002-14a2bf25.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gfl/gfl_x101_32x4d_fpn_dconv_c4-c5_mstrain_2x_coco/gfl_x101_32x4d_fpn_dconv_c4-c5_mstrain_2x_coco_20200630_102002.log.json) | + +\[1\] *1x and 2x mean the model is trained for 90K and 180K iterations, respectively.* \ +\[2\] *All results are obtained with a single model and without any test time data augmentation such as multi-scale, flipping and etc..* \ +\[3\] *`dcnv2` denotes deformable convolutional networks v2.* \ +\[4\] *FPS is tested with a single GeForce RTX 2080Ti GPU, using a batch size of 1.* + +## Citation + +We provide config files to reproduce the object detection results in the paper [Generalized Focal Loss: Learning Qualified and Distributed Bounding Boxes for Dense Object Detection](https://arxiv.org/abs/2006.04388) + +```latex +@article{li2020generalized, + title={Generalized Focal Loss: Learning Qualified and Distributed Bounding Boxes for Dense Object Detection}, + author={Li, Xiang and Wang, Wenhai and Wu, Lijun and Chen, Shuo and Hu, Xiaolin and Li, Jun and Tang, Jinhui and Yang, Jian}, + journal={arXiv preprint arXiv:2006.04388}, + year={2020} +} +``` diff --git a/mmdetection/configs/gfl/gfl_r101-dconv-c3-c5_fpn_ms-2x_coco.py b/mmdetection/configs/gfl/gfl_r101-dconv-c3-c5_fpn_ms-2x_coco.py new file mode 100644 index 00000000..7f748935 --- /dev/null +++ b/mmdetection/configs/gfl/gfl_r101-dconv-c3-c5_fpn_ms-2x_coco.py @@ -0,0 +1,15 @@ +_base_ = './gfl_r50_fpn_ms-2x_coco.py' +model = dict( + backbone=dict( + type='ResNet', + depth=101, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + dcn=dict(type='DCN', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/gfl/gfl_r101_fpn_ms-2x_coco.py b/mmdetection/configs/gfl/gfl_r101_fpn_ms-2x_coco.py new file mode 100644 index 00000000..10135f16 --- /dev/null +++ b/mmdetection/configs/gfl/gfl_r101_fpn_ms-2x_coco.py @@ -0,0 +1,13 @@ +_base_ = './gfl_r50_fpn_ms-2x_coco.py' +model = dict( + backbone=dict( + type='ResNet', + depth=101, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/gfl/gfl_r50_fpn_1x_coco.py b/mmdetection/configs/gfl/gfl_r50_fpn_1x_coco.py new file mode 100644 index 00000000..90238255 --- /dev/null +++ b/mmdetection/configs/gfl/gfl_r50_fpn_1x_coco.py @@ -0,0 +1,66 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +model = dict( + type='GFL', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_output', + num_outs=5), + bbox_head=dict( + type='GFLHead', + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + octave_base_scale=8, + scales_per_octave=1, + strides=[8, 16, 32, 64, 128]), + loss_cls=dict( + type='QualityFocalLoss', + use_sigmoid=True, + beta=2.0, + loss_weight=1.0), + loss_dfl=dict(type='DistributionFocalLoss', loss_weight=0.25), + reg_max=16, + loss_bbox=dict(type='GIoULoss', loss_weight=2.0)), + # training and testing settings + train_cfg=dict( + assigner=dict(type='ATSSAssigner', topk=9), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) diff --git a/mmdetection/configs/gfl/gfl_r50_fpn_ms-2x_coco.py b/mmdetection/configs/gfl/gfl_r50_fpn_ms-2x_coco.py new file mode 100644 index 00000000..22770eb1 --- /dev/null +++ b/mmdetection/configs/gfl/gfl_r50_fpn_ms-2x_coco.py @@ -0,0 +1,28 @@ +_base_ = './gfl_r50_fpn_1x_coco.py' +max_epochs = 24 + +# learning policy +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs) + +# multi-scale training +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomResize', scale=[(1333, 480), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/mmdetection/configs/gfl/gfl_x101-32x4d-dconv-c4-c5_fpn_ms-2x_coco.py b/mmdetection/configs/gfl/gfl_x101-32x4d-dconv-c4-c5_fpn_ms-2x_coco.py new file mode 100644 index 00000000..6aa98eea --- /dev/null +++ b/mmdetection/configs/gfl/gfl_x101-32x4d-dconv-c4-c5_fpn_ms-2x_coco.py @@ -0,0 +1,18 @@ +_base_ = './gfl_r50_fpn_ms-2x_coco.py' +model = dict( + type='GFL', + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + dcn=dict(type='DCN', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, False, True, True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/gfl/gfl_x101-32x4d_fpn_ms-2x_coco.py b/mmdetection/configs/gfl/gfl_x101-32x4d_fpn_ms-2x_coco.py new file mode 100644 index 00000000..ec629b1f --- /dev/null +++ b/mmdetection/configs/gfl/gfl_x101-32x4d_fpn_ms-2x_coco.py @@ -0,0 +1,16 @@ +_base_ = './gfl_r50_fpn_ms-2x_coco.py' +model = dict( + type='GFL', + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/gfl/metafile.yml b/mmdetection/configs/gfl/metafile.yml new file mode 100644 index 00000000..183fc14b --- /dev/null +++ b/mmdetection/configs/gfl/metafile.yml @@ -0,0 +1,134 @@ +Collections: + - Name: Generalized Focal Loss + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - Generalized Focal Loss + - FPN + - ResNet + Paper: + URL: https://arxiv.org/abs/2006.04388 + Title: 'Generalized Focal Loss: Learning Qualified and Distributed Bounding Boxes for Dense Object Detection' + README: configs/gfl/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.2.0/mmdet/models/detectors/gfl.py#L6 + Version: v2.2.0 + +Models: + - Name: gfl_r50_fpn_1x_coco + In Collection: Generalized Focal Loss + Config: configs/gfl/gfl_r50_fpn_1x_coco.py + Metadata: + inference time (ms/im): + - value: 51.28 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gfl/gfl_r50_fpn_1x_coco/gfl_r50_fpn_1x_coco_20200629_121244-25944287.pth + + - Name: gfl_r50_fpn_ms-2x_coco + In Collection: Generalized Focal Loss + Config: configs/gfl/gfl_r50_fpn_ms-2x_coco.py + Metadata: + inference time (ms/im): + - value: 51.28 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gfl/gfl_r50_fpn_mstrain_2x_coco/gfl_r50_fpn_mstrain_2x_coco_20200629_213802-37bb1edc.pth + + - Name: gfl_r101_fpn_ms-2x_coco + In Collection: Generalized Focal Loss + Config: configs/gfl/gfl_r101_fpn_ms-2x_coco.py + Metadata: + inference time (ms/im): + - value: 68.03 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gfl/gfl_r101_fpn_mstrain_2x_coco/gfl_r101_fpn_mstrain_2x_coco_20200629_200126-dd12f847.pth + + - Name: gfl_r101-dconv-c3-c5_fpn_ms-2x_coco + In Collection: Generalized Focal Loss + Config: configs/gfl/gfl_r101-dconv-c3-c5_fpn_ms-2x_coco.py + Metadata: + inference time (ms/im): + - value: 77.52 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 47.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gfl/gfl_r101_fpn_dconv_c3-c5_mstrain_2x_coco/gfl_r101_fpn_dconv_c3-c5_mstrain_2x_coco_20200630_102002-134b07df.pth + + - Name: gfl_x101-32x4d_fpn_ms-2x_coco + In Collection: Generalized Focal Loss + Config: configs/gfl/gfl_x101-32x4d_fpn_ms-2x_coco.py + Metadata: + inference time (ms/im): + - value: 82.64 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gfl/gfl_x101_32x4d_fpn_mstrain_2x_coco/gfl_x101_32x4d_fpn_mstrain_2x_coco_20200630_102002-50c1ffdb.pth + + - Name: gfl_x101-32x4d-dconv-c4-c5_fpn_ms-2x_coco + In Collection: Generalized Focal Loss + Config: configs/gfl/gfl_x101-32x4d-dconv-c4-c5_fpn_ms-2x_coco.py + Metadata: + inference time (ms/im): + - value: 93.46 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 48.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gfl/gfl_x101_32x4d_fpn_dconv_c4-c5_mstrain_2x_coco/gfl_x101_32x4d_fpn_dconv_c4-c5_mstrain_2x_coco_20200630_102002-14a2bf25.pth diff --git a/mmdetection/configs/ghm/README.md b/mmdetection/configs/ghm/README.md new file mode 100644 index 00000000..c245cea5 --- /dev/null +++ b/mmdetection/configs/ghm/README.md @@ -0,0 +1,33 @@ +# GHM + +> [Gradient Harmonized Single-stage Detector](https://arxiv.org/abs/1811.05181) + + + +## Abstract + +Despite the great success of two-stage detectors, single-stage detector is still a more elegant and efficient way, yet suffers from the two well-known disharmonies during training, i.e. the huge difference in quantity between positive and negative examples as well as between easy and hard examples. In this work, we first point out that the essential effect of the two disharmonies can be summarized in term of the gradient. Further, we propose a novel gradient harmonizing mechanism (GHM) to be a hedging for the disharmonies. The philosophy behind GHM can be easily embedded into both classification loss function like cross-entropy (CE) and regression loss function like smooth-L1 (SL1) loss. To this end, two novel loss functions called GHM-C and GHM-R are designed to balancing the gradient flow for anchor classification and bounding box refinement, respectively. Ablation study on MS COCO demonstrates that without laborious hyper-parameter tuning, both GHM-C and GHM-R can bring substantial improvement for single-stage detector. Without any whistles and bells, our model achieves 41.6 mAP on COCO test-dev set which surpasses the state-of-the-art method, Focal Loss (FL) + SL1, by 0.8. + +
    + +
    + +## Results and Models + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :-------------: | :-----: | :-----: | :------: | :------------: | :----: | :-------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | pytorch | 1x | 4.0 | 3.3 | 37.0 | [config](./retinanet_r50_fpn_ghm-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/ghm/retinanet_ghm_r50_fpn_1x_coco/retinanet_ghm_r50_fpn_1x_coco_20200130-a437fda3.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/ghm/retinanet_ghm_r50_fpn_1x_coco/retinanet_ghm_r50_fpn_1x_coco_20200130_004213.log.json) | +| R-101-FPN | pytorch | 1x | 6.0 | 4.4 | 39.1 | [config](./retinanet_r101_fpn_ghm-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/ghm/retinanet_ghm_r101_fpn_1x_coco/retinanet_ghm_r101_fpn_1x_coco_20200130-c148ee8f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/ghm/retinanet_ghm_r101_fpn_1x_coco/retinanet_ghm_r101_fpn_1x_coco_20200130_145259.log.json) | +| X-101-32x4d-FPN | pytorch | 1x | 7.2 | 5.1 | 40.7 | [config](./retinanet_x101-32x4d_fpn_ghm-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/ghm/retinanet_ghm_x101_32x4d_fpn_1x_coco/retinanet_ghm_x101_32x4d_fpn_1x_coco_20200131-e4333bd0.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/ghm/retinanet_ghm_x101_32x4d_fpn_1x_coco/retinanet_ghm_x101_32x4d_fpn_1x_coco_20200131_113653.log.json) | +| X-101-64x4d-FPN | pytorch | 1x | 10.3 | 5.2 | 41.4 | [config](./retinanet_x101-64x4d_fpn_ghm-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/ghm/retinanet_ghm_x101_64x4d_fpn_1x_coco/retinanet_ghm_x101_64x4d_fpn_1x_coco_20200131-dd381cef.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/ghm/retinanet_ghm_x101_64x4d_fpn_1x_coco/retinanet_ghm_x101_64x4d_fpn_1x_coco_20200131_113723.log.json) | + +## Citation + +```latex +@inproceedings{li2019gradient, + title={Gradient Harmonized Single-stage Detector}, + author={Li, Buyu and Liu, Yu and Wang, Xiaogang}, + booktitle={AAAI Conference on Artificial Intelligence}, + year={2019} +} +``` diff --git a/mmdetection/configs/ghm/metafile.yml b/mmdetection/configs/ghm/metafile.yml new file mode 100644 index 00000000..63cb48ff --- /dev/null +++ b/mmdetection/configs/ghm/metafile.yml @@ -0,0 +1,101 @@ +Collections: + - Name: GHM + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - GHM-C + - GHM-R + - FPN + - ResNet + Paper: + URL: https://arxiv.org/abs/1811.05181 + Title: 'Gradient Harmonized Single-stage Detector' + README: configs/ghm/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/losses/ghm_loss.py#L21 + Version: v2.0.0 + +Models: + - Name: retinanet_r50_fpn_ghm-1x_coco + In Collection: GHM + Config: configs/ghm/retinanet_r50_fpn_ghm-1x_coco.py + Metadata: + Training Memory (GB): 4.0 + inference time (ms/im): + - value: 303.03 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/ghm/retinanet_ghm_r50_fpn_1x_coco/retinanet_ghm_r50_fpn_1x_coco_20200130-a437fda3.pth + + - Name: retinanet_r101_fpn_ghm-1x_coco + In Collection: GHM + Config: configs/ghm/retinanet_r101_fpn_ghm-1x_coco.py + Metadata: + Training Memory (GB): 6.0 + inference time (ms/im): + - value: 227.27 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/ghm/retinanet_ghm_r101_fpn_1x_coco/retinanet_ghm_r101_fpn_1x_coco_20200130-c148ee8f.pth + + - Name: retinanet_x101-32x4d_fpn_ghm-1x_coco + In Collection: GHM + Config: configs/ghm/retinanet_x101-32x4d_fpn_ghm-1x_coco.py + Metadata: + Training Memory (GB): 7.2 + inference time (ms/im): + - value: 196.08 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/ghm/retinanet_ghm_x101_32x4d_fpn_1x_coco/retinanet_ghm_x101_32x4d_fpn_1x_coco_20200131-e4333bd0.pth + + - Name: retinanet_x101-64x4d_fpn_ghm-1x_coco + In Collection: GHM + Config: configs/ghm/retinanet_x101-64x4d_fpn_ghm-1x_coco.py + Metadata: + Training Memory (GB): 10.3 + inference time (ms/im): + - value: 192.31 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/ghm/retinanet_ghm_x101_64x4d_fpn_1x_coco/retinanet_ghm_x101_64x4d_fpn_1x_coco_20200131-dd381cef.pth diff --git a/mmdetection/configs/ghm/retinanet_r101_fpn_ghm-1x_coco.py b/mmdetection/configs/ghm/retinanet_r101_fpn_ghm-1x_coco.py new file mode 100644 index 00000000..090221e6 --- /dev/null +++ b/mmdetection/configs/ghm/retinanet_r101_fpn_ghm-1x_coco.py @@ -0,0 +1,6 @@ +_base_ = './retinanet_r50_fpn_ghm-1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/ghm/retinanet_r50_fpn_ghm-1x_coco.py b/mmdetection/configs/ghm/retinanet_r50_fpn_ghm-1x_coco.py new file mode 100644 index 00000000..42b9aa6d --- /dev/null +++ b/mmdetection/configs/ghm/retinanet_r50_fpn_ghm-1x_coco.py @@ -0,0 +1,18 @@ +_base_ = '../retinanet/retinanet_r50_fpn_1x_coco.py' +model = dict( + bbox_head=dict( + loss_cls=dict( + _delete_=True, + type='GHMC', + bins=30, + momentum=0.75, + use_sigmoid=True, + loss_weight=1.0), + loss_bbox=dict( + _delete_=True, + type='GHMR', + mu=0.02, + bins=10, + momentum=0.7, + loss_weight=10.0))) +optim_wrapper = dict(clip_grad=dict(max_norm=35, norm_type=2)) diff --git a/mmdetection/configs/ghm/retinanet_x101-32x4d_fpn_ghm-1x_coco.py b/mmdetection/configs/ghm/retinanet_x101-32x4d_fpn_ghm-1x_coco.py new file mode 100644 index 00000000..1240545a --- /dev/null +++ b/mmdetection/configs/ghm/retinanet_x101-32x4d_fpn_ghm-1x_coco.py @@ -0,0 +1,14 @@ +_base_ = './retinanet_r50_fpn_ghm-1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/ghm/retinanet_x101-64x4d_fpn_ghm-1x_coco.py b/mmdetection/configs/ghm/retinanet_x101-64x4d_fpn_ghm-1x_coco.py new file mode 100644 index 00000000..689d2edc --- /dev/null +++ b/mmdetection/configs/ghm/retinanet_x101-64x4d_fpn_ghm-1x_coco.py @@ -0,0 +1,14 @@ +_base_ = './retinanet_r50_fpn_ghm-1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/glip/README.md b/mmdetection/configs/glip/README.md new file mode 100644 index 00000000..e74e98d1 --- /dev/null +++ b/mmdetection/configs/glip/README.md @@ -0,0 +1,173 @@ +# GLIP: Grounded Language-Image Pre-training + +> [GLIP: Grounded Language-Image Pre-training](https://arxiv.org/abs/2112.03857) + + + +## Abstract + +This paper presents a grounded language-image pre-training (GLIP) model for learning object-level, language-aware, and semantic-rich visual representations. GLIP unifies object detection and phrase grounding for pre-training. The unification brings two benefits: 1) it allows GLIP to learn from both detection and grounding data to improve both tasks and bootstrap a good grounding model; 2) GLIP can leverage massive image-text pairs by generating grounding boxes in a self-training fashion, making the learned representation semantic-rich. In our experiments, we pre-train GLIP on 27M grounding data, including 3M human-annotated and 24M web-crawled image-text pairs. The learned representations demonstrate strong zero-shot and few-shot transferability to various object-level recognition tasks. 1) When directly evaluated on COCO and LVIS (without seeing any images in COCO during pre-training), GLIP achieves 49.8 AP and 26.9 AP, respectively, surpassing many supervised baselines. 2) After fine-tuned on COCO, GLIP achieves 60.8 AP on val and 61.5 AP on test-dev, surpassing prior SoTA. 3) When transferred to 13 downstream object detection tasks, a 1-shot GLIP rivals with a fully-supervised Dynamic Head. + +
    + +
    + +## Installation + +```shell +cd $MMDETROOT + +# source installation +pip install -r requirements/multimodal.txt + +# or mim installation +mim install mmdet[multimodal] +``` + +```shell +cd $MMDETROOT + +wget https://download.openmmlab.com/mmdetection/v3.0/glip/glip_tiny_a_mmdet-b3654169.pth + +python demo/image_demo.py demo/demo.jpg \ +configs/glip/glip_atss_swin-t_a_fpn_dyhead_pretrain_obj365.py \ +--weights glip_tiny_a_mmdet-b3654169.pth \ +--texts 'bench. car' +``` + +
    + +
    + +## NOTE + +GLIP utilizes BERT as the language model, which requires access to https://huggingface.co/. If you encounter connection errors due to network access, you can download the required files on a computer with internet access and save them locally. Finally, modify the `lang_model_name` field in the config to the local path. Please refer to the following code: + +```python +from transformers import BertConfig, BertModel +from transformers import AutoTokenizer + +config = BertConfig.from_pretrained("bert-base-uncased") +model = BertModel.from_pretrained("bert-base-uncased", add_pooling_layer=False, config=config) +tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased") + +config.save_pretrained("your path/bert-base-uncased") +model.save_pretrained("your path/bert-base-uncased") +tokenizer.save_pretrained("your path/bert-base-uncased") +``` + +## COCO Results and Models + +| Model | Zero-shot or Finetune | COCO mAP | Official COCO mAP | Pre-Train Data | Config | Download | +| :--------: | :-------------------: | :------: | ----------------: | :------------------------: | :---------------------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| GLIP-T (A) | Zero-shot | 43.0 | 42.9 | O365 | [config](glip_atss_swin-t_a_fpn_dyhead_pretrain_obj365.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_tiny_a_mmdet-b3654169.pth) | +| GLIP-T (A) | Finetune | 53.3 | 52.9 | O365 | [config](glip_atss_swin-t_a_fpn_dyhead_16xb2_ms-2x_funtune_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_atss_swin-t_a_fpn_dyhead_16xb2_ms-2x_funtune_coco/glip_atss_swin-t_a_fpn_dyhead_16xb2_ms-2x_funtune_coco_20230914_180419-e6addd96.pth)\| [log](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_atss_swin-t_a_fpn_dyhead_16xb2_ms-2x_funtune_coco/glip_atss_swin-t_a_fpn_dyhead_16xb2_ms-2x_funtune_coco_20230914_180419.log.json) | +| GLIP-T (B) | Zero-shot | 44.9 | 44.9 | O365 | [config](glip_atss_swin-t_b_fpn_dyhead_pretrain_obj365.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_tiny_b_mmdet-6dfbd102.pth) | +| GLIP-T (B) | Finetune | 54.1 | 53.8 | O365 | [config](glip_atss_swin-t_b_fpn_dyhead_16xb2_ms-2x_funtune_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_atss_swin-t_b_fpn_dyhead_16xb2_ms-2x_funtune_coco/glip_atss_swin-t_b_fpn_dyhead_16xb2_ms-2x_funtune_coco_20230916_163538-650323ba.pth)\| [log](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_atss_swin-t_b_fpn_dyhead_16xb2_ms-2x_funtune_coco/glip_atss_swin-t_b_fpn_dyhead_16xb2_ms-2x_funtune_coco_20230916_163538.log.json) | +| GLIP-T (C) | Zero-shot | 46.7 | 46.7 | O365,GoldG | [config](glip_atss_swin-t_c_fpn_dyhead_pretrain_obj365-goldg.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_tiny_c_mmdet-2fc427dd.pth) | +| GLIP-T (C) | Finetune | 55.2 | 55.1 | O365,GoldG | [config](glip_atss_swin-t_c_fpn_dyhead_16xb2_ms-2x_funtune_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_atss_swin-t_c_fpn_dyhead_16xb2_ms-2x_funtune_coco/glip_atss_swin-t_c_fpn_dyhead_16xb2_ms-2x_funtune_coco_20230914_182935-4ba3fc3b.pth)\| [log](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_atss_swin-t_c_fpn_dyhead_16xb2_ms-2x_funtune_coco/glip_atss_swin-t_c_fpn_dyhead_16xb2_ms-2x_funtune_coco_20230914_182935.log.json) | +| GLIP-T | Zero-shot | 46.6 | 46.6 | O365,GoldG,CC3M,SBU | [config](glip_atss_swin-t_fpn_dyhead_pretrain_obj365-goldg-cc3m-sub.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_tiny_mmdet-c24ce662.pth) | +| GLIP-T | Finetune | 55.4 | 55.2 | O365,GoldG,CC3M,SBU | [config](glip_atss_swin-t_fpn_dyhead_16xb2_ms-2x_funtune_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_atss_swin-t_fpn_dyhead_16xb2_ms-2x_funtune_coco/glip_atss_swin-t_fpn_dyhead_16xb2_ms-2x_funtune_coco_20230914_224410-ba97be24.pth)\| [log](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_atss_swin-t_fpn_dyhead_16xb2_ms-2x_funtune_coco/glip_atss_swin-t_fpn_dyhead_16xb2_ms-2x_funtune_coco_20230914_224410.log.json) | +| GLIP-L | Zero-shot | 51.3 | 51.4 | FourODs,GoldG,CC3M+12M,SBU | [config](glip_atss_swin-l_fpn_dyhead_pretrain_mixeddata.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_l_mmdet-abfe026b.pth) | +| GLIP-L | Finetune | 59.4 | | FourODs,GoldG,CC3M+12M,SBU | [config](glip_atss_swin-l_fpn_dyhead_16xb2_ms-2x_funtune_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_atss_swin-l_fpn_dyhead_16xb2_ms-2x_funtune_coco/glip_atss_swin-l_fpn_dyhead_16xb2_ms-2x_funtune_coco_20230910_100800-e9be4274.pth)\| [log](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_atss_swin-l_fpn_dyhead_16xb2_ms-2x_funtune_coco/glip_atss_swin-l_fpn_dyhead_16xb2_ms-2x_funtune_coco_20230910_100800.log.json) | + +Note: + +1. The weights corresponding to the zero-shot model are adopted from the official weights and converted using the [script](../../tools/model_converters/glip_to_mmdet.py). We have not retrained the model for the time being. +2. Finetune refers to fine-tuning on the COCO 2017 dataset. The L model is trained using 16 A100 GPUs, while the remaining models are trained using 16 NVIDIA GeForce 3090 GPUs. +3. Taking the GLIP-T(A) model as an example, I trained it twice using the official code, and the fine-tuning mAP were 52.5 and 52.6. Therefore, the mAP we achieved in our reproduction is higher than the official results. The main reason is that we modified the `weight_decay` parameter. +4. Our experiments revealed that training for 24 epochs leads to overfitting. Therefore, we chose the best-performing model. If users want to train on a custom dataset, it is advisable to shorten the number of epochs and save the best-performing model. +5. Due to the official absence of fine-tuning hyperparameters for the GLIP-L model, we have not yet reproduced the official accuracy. I have found that overfitting can also occur, so it may be necessary to consider custom modifications to data augmentation and model enhancement. Given the high cost of training, we have not conducted any research on this matter at the moment. + +## LVIS Results + +| Model | Official | MiniVal APr | MiniVal APc | MiniVal APf | MiniVal AP | Val1.0 APr | Val1.0 APc | Val1.0 APf | Val1.0 AP | Pre-Train Data | Config | Download | +| :--------: | :------: | :---------: | :---------: | :---------: | :--------: | :--------: | :--------: | :--------: | :-------: | :------------------------: | :---------------------------------------------------------------------: | :------------------------------------------------------------------------------------------: | +| GLIP-T (A) | ✔ | | | | | | | | | O365 | [config](lvis/glip_atss_swin-t_a_fpn_dyhead_pretrain_zeroshot_lvis.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_tiny_a_mmdet-b3654169.pth) | +| GLIP-T (A) | | 12.1 | 15.5 | 25.8 | 20.2 | 6.2 | 10.9 | 22.8 | 14.7 | O365 | [config](lvis/glip_atss_swin-t_a_fpn_dyhead_pretrain_zeroshot_lvis.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_tiny_a_mmdet-b3654169.pth) | +| GLIP-T (B) | ✔ | | | | | | | | | O365 | [config](lvis/glip_atss_swin-t_bc_fpn_dyhead_pretrain_zeroshot_lvis.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_tiny_b_mmdet-6dfbd102.pth) | +| GLIP-T (B) | | 8.6 | 13.9 | 26.0 | 19.3 | 4.6 | 9.8 | 22.6 | 13.9 | O365 | [config](lvis/glip_atss_swin-t_bc_fpn_dyhead_pretrain_zeroshot_lvis.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_tiny_b_mmdet-6dfbd102.pth) | +| GLIP-T (C) | ✔ | 14.3 | 19.4 | 31.1 | 24.6 | | | | | O365,GoldG | [config](lvis/glip_atss_swin-t_bc_fpn_dyhead_pretrain_zeroshot_lvis.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_tiny_c_mmdet-2fc427dd.pth) | +| GLIP-T (C) | | 14.4 | 19.8 | 31.9 | 25.2 | 8.3 | 13.2 | 28.1 | 18.2 | O365,GoldG | [config](lvis/glip_atss_swin-t_bc_fpn_dyhead_pretrain_zeroshot_lvis.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_tiny_c_mmdet-2fc427dd.pth) | +| GLIP-T | ✔ | | | | | | | | | O365,GoldG,CC3M,SBU | [config](lvis/glip_atss_swin-t_bc_fpn_dyhead_pretrain_zeroshot_lvis.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_tiny_mmdet-c24ce662.pth) | +| GLIP-T | | 18.1 | 21.2 | 33.1 | 26.7 | 10.8 | 14.7 | 29.0 | 19.6 | O365,GoldG,CC3M,SBU | [config](lvis/glip_atss_swin-t_bc_fpn_dyhead_pretrain_zeroshot_lvis.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_tiny_mmdet-c24ce662.pth) | +| GLIP-L | ✔ | 29.2 | 34.9 | 42.1 | 37.9 | | | | | FourODs,GoldG,CC3M+12M,SBU | [config](lvis/glip_atss_swin-l_fpn_dyhead_pretrain_zeroshot_lvis.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_l_mmdet-abfe026b.pth) | +| GLIP-L | | 27.9 | 33.7 | 39.7 | 36.1 | 20.2 | 25.8 | 35.3 | 28.5 | FourODs,GoldG,CC3M+12M,SBU | [config](lvis/glip_atss_swin-l_fpn_dyhead_pretrain_zeroshot_lvis.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/glip/glip_l_mmdet-abfe026b.pth) | + +Note: + +1. The above are zero-shot evaluation results. +2. The evaluation metric we used is LVIS FixAP. For specific details, please refer to [Evaluating Large-Vocabulary Object Detectors: The Devil is in the Details](https://arxiv.org/pdf/2102.01066.pdf). +3. We found that the performance on small models is better than the official results, but it is lower on large models. This is mainly due to the incomplete alignment of the GLIP post-processing. + +## ODinW (Object Detection in the Wild) Results + +Learning visual representations from natural language supervision has recently shown great promise in a number of pioneering works. In general, these language-augmented visual models demonstrate strong transferability to a variety of datasets and tasks. However, it remains challenging to evaluate the transferablity of these models due to the lack of easy-to-use evaluation toolkits and public benchmarks. To tackle this, we build ELEVATER 1 , the first benchmark and toolkit for evaluating (pre-trained) language-augmented visual models. ELEVATER is composed of three components. (i) Datasets. As downstream evaluation suites, it consists of 20 image classification datasets and 35 object detection datasets, each of which is augmented with external knowledge. (ii) Toolkit. An automatic hyper-parameter tuning toolkit is developed to facilitate model evaluation on downstream tasks. (iii) Metrics. A variety of evaluation metrics are used to measure sample-efficiency (zero-shot and few-shot) and parameter-efficiency (linear probing and full model fine-tuning). ELEVATER is platform for Computer Vision in the Wild (CVinW), and is publicly released at https://computer-vision-in-the-wild.github.io/ELEVATER/ + +### Results and models of ODinW13 + +| Method | GLIP-T(A) | Official | GLIP-T(B) | Official | GLIP-T(C) | Official | GroundingDINO-T | GroundingDINO-B | +| --------------------- | --------- | --------- | --------- | --------- | --------- | --------- | --------------- | --------------- | +| AerialMaritimeDrone | 0.123 | 0.122 | 0.110 | 0.110 | 0.130 | 0.130 | 0.173 | 0.281 | +| Aquarium | 0.175 | 0.174 | 0.173 | 0.169 | 0.191 | 0.190 | 0.195 | 0.445 | +| CottontailRabbits | 0.686 | 0.686 | 0.688 | 0.688 | 0.744 | 0.744 | 0.799 | 0.808 | +| EgoHands | 0.013 | 0.013 | 0.003 | 0.004 | 0.314 | 0.315 | 0.608 | 0.764 | +| NorthAmericaMushrooms | 0.502 | 0.502 | 0.367 | 0.367 | 0.297 | 0.296 | 0.507 | 0.675 | +| Packages | 0.589 | 0.589 | 0.083 | 0.083 | 0.699 | 0.699 | 0.687 | 0.670 | +| PascalVOC | 0.512 | 0.512 | 0.541 | 0.540 | 0.565 | 0.565 | 0.563 | 0.711 | +| pistols | 0.339 | 0.339 | 0.502 | 0.501 | 0.503 | 0.504 | 0.726 | 0.771 | +| pothole | 0.007 | 0.007 | 0.030 | 0.030 | 0.058 | 0.058 | 0.215 | 0.478 | +| Raccoon | 0.075 | 0.074 | 0.285 | 0.288 | 0.241 | 0.244 | 0.549 | 0.541 | +| ShellfishOpenImages | 0.253 | 0.253 | 0.337 | 0.338 | 0.300 | 0.302 | 0.393 | 0.650 | +| thermalDogsAndPeople | 0.372 | 0.372 | 0.475 | 0.475 | 0.510 | 0.510 | 0.657 | 0.633 | +| VehiclesOpenImages | 0.574 | 0.566 | 0.562 | 0.547 | 0.549 | 0.534 | 0.613 | 0.647 | +| Average | **0.325** | **0.324** | **0.320** | **0.318** | **0.392** | **0.392** | **0.514** | **0.621** | + +### Results and models of ODinW35 + +| Method | GLIP-T(A) | Official | GLIP-T(B) | Official | GLIP-T(C) | Official | GroundingDINO-T | GroundingDINO-B | +| --------------------------- | --------- | --------- | --------- | --------- | --------- | --------- | --------------- | --------------- | +| AerialMaritimeDrone_large | 0.123 | 0.122 | 0.110 | 0.110 | 0.130 | 0.130 | 0.173 | 0.281 | +| AerialMaritimeDrone_tiled | 0.174 | 0.174 | 0.172 | 0.172 | 0.172 | 0.172 | 0.206 | 0.364 | +| AmericanSignLanguageLetters | 0.001 | 0.001 | 0.003 | 0.003 | 0.009 | 0.009 | 0.002 | 0.096 | +| Aquarium | 0.175 | 0.175 | 0.173 | 0.171 | 0.192 | 0.182 | 0.195 | 0.445 | +| BCCD | 0.016 | 0.016 | 0.001 | 0.001 | 0.000 | 0.000 | 0.161 | 0.584 | +| boggleBoards | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.134 | +| brackishUnderwater | 0.016 | 0..013 | 0.021 | 0.027 | 0.020 | 0.022 | 0.021 | 0.454 | +| ChessPieces | 0.001 | 0.001 | 0.000 | 0.000 | 0.001 | 0.001 | 0.000 | 0.000 | +| CottontailRabbits | 0.710 | 0.709 | 0.683 | 0.683 | 0.752 | 0.752 | 0.806 | 0.797 | +| dice | 0.005 | 0.005 | 0.004 | 0.004 | 0.004 | 0.004 | 0.004 | 0.082 | +| DroneControl | 0.016 | 0.017 | 0.006 | 0.008 | 0.005 | 0.007 | 0.042 | 0.638 | +| EgoHands_generic | 0.009 | 0.010 | 0.005 | 0.006 | 0.510 | 0.508 | 0.608 | 0.764 | +| EgoHands_specific | 0.001 | 0.001 | 0.004 | 0.006 | 0.003 | 0.004 | 0.002 | 0.687 | +| HardHatWorkers | 0.029 | 0.029 | 0.023 | 0.023 | 0.033 | 0.033 | 0.046 | 0.439 | +| MaskWearing | 0.007 | 0.007 | 0.003 | 0.002 | 0.005 | 0.005 | 0.004 | 0.406 | +| MountainDewCommercial | 0.218 | 0.227 | 0.199 | 0.197 | 0.478 | 0.463 | 0.430 | 0.580 | +| NorthAmericaMushrooms | 0.502 | 0.502 | 0.450 | 0.450 | 0.497 | 0.497 | 0.471 | 0.501 | +| openPoetryVision | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.051 | +| OxfordPets_by_breed | 0.001 | 0.002 | 0.002 | 0.004 | 0.001 | 0.002 | 0.003 | 0.799 | +| OxfordPets_by_species | 0.016 | 0.011 | 0.012 | 0.009 | 0.013 | 0.009 | 0.011 | 0.872 | +| PKLot | 0.002 | 0.002 | 0.000 | 0.000 | 0.000 | 0.000 | 0.001 | 0.774 | +| Packages | 0.569 | 0.569 | 0.279 | 0.279 | 0.712 | 0.712 | 0.695 | 0.728 | +| PascalVOC | 0.512 | 0.512 | 0.541 | 0.540 | 0.565 | 0.565 | 0.563 | 0.711 | +| pistols | 0.339 | 0.339 | 0.502 | 0.501 | 0.503 | 0.504 | 0.726 | 0.771 | +| plantdoc | 0.002 | 0.002 | 0.007 | 0.007 | 0.009 | 0.009 | 0.005 | 0.376 | +| pothole | 0.007 | 0.010 | 0.024 | 0.025 | 0.085 | 0.101 | 0.215 | 0.478 | +| Raccoons | 0.075 | 0.074 | 0.285 | 0.288 | 0.241 | 0.244 | 0.549 | 0.541 | +| selfdrivingCar | 0.071 | 0.072 | 0.074 | 0.074 | 0.081 | 0.080 | 0.089 | 0.318 | +| ShellfishOpenImages | 0.253 | 0.253 | 0.337 | 0.338 | 0.300 | 0.302 | 0.393 | 0.650 | +| ThermalCheetah | 0.028 | 0.028 | 0.000 | 0.000 | 0.028 | 0.028 | 0.087 | 0.290 | +| thermalDogsAndPeople | 0.372 | 0.372 | 0.475 | 0.475 | 0.510 | 0.510 | 0.657 | 0.633 | +| UnoCards | 0.000 | 0.000 | 0.000 | 0.001 | 0.002 | 0.003 | 0.006 | 0.754 | +| VehiclesOpenImages | 0.574 | 0.566 | 0.562 | 0.547 | 0.549 | 0.534 | 0.613 | 0.647 | +| WildfireSmoke | 0.000 | 0.000 | 0.000 | 0.000 | 0.017 | 0.017 | 0.134 | 0.410 | +| websiteScreenshots | 0.003 | 0.004 | 0.003 | 0.005 | 0.005 | 0.006 | 0.012 | 0.175 | +| Average | **0.134** | **0.134** | **0.138** | **0.138** | **0.179** | **0.178** | **0.227** | **0.492** | + +### Results on Flickr30k + +| Model | Official | Pre-Train Data | Val R@1 | Val R@5 | Val R@10 | Test R@1 | Test R@5 | Test R@10 | +| ------------- | -------- | ------------------- | ------- | ------- | -------- | -------- | -------- | --------- | +| **GLIP-T(C)** | ✔ | O365, GoldG | 84.8 | 94.9 | 96.3 | 85.5 | 95.4 | 96.6 | +| **GLIP-T(C)** | | O365, GoldG | 84.9 | 94.9 | 96.3 | 85.6 | 95.4 | 96.7 | +| **GLIP-T** | | O365,GoldG,CC3M,SBU | 85.3 | 95.5 | 96.9 | 86.0 | 95.9 | 97.2 | diff --git a/mmdetection/configs/glip/flickr30k/glip_atss_swin-t_c_fpn_dyhead_pretrain_obj365-goldg_zeroshot_flickr30k.py b/mmdetection/configs/glip/flickr30k/glip_atss_swin-t_c_fpn_dyhead_pretrain_obj365-goldg_zeroshot_flickr30k.py new file mode 100644 index 00000000..14d6e8aa --- /dev/null +++ b/mmdetection/configs/glip/flickr30k/glip_atss_swin-t_c_fpn_dyhead_pretrain_obj365-goldg_zeroshot_flickr30k.py @@ -0,0 +1,61 @@ +_base_ = '../glip_atss_swin-t_a_fpn_dyhead_pretrain_obj365.py' + +lang_model_name = 'bert-base-uncased' + +model = dict(bbox_head=dict(early_fuse=True)) + +dataset_type = 'Flickr30kDataset' +data_root = 'data/flickr30k_entities/' + +test_pipeline = [ + dict( + type='LoadImageFromFile', backend_args=None, + imdecode_backend='pillow'), + dict( + type='FixScaleResize', + scale=(800, 1333), + keep_ratio=True, + backend='pillow'), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'text', 'custom_entities', + 'tokens_positive', 'phrase_ids', 'phrases')) +] + +dataset_Flickr30k_val = dict( + type=dataset_type, + data_root=data_root, + ann_file='final_flickr_separateGT_val.json', + data_prefix=dict(img='flickr30k_images/'), + pipeline=test_pipeline, +) + +dataset_Flickr30k_test = dict( + type=dataset_type, + data_root=data_root, + ann_file='final_flickr_separateGT_test.json', + data_prefix=dict(img='flickr30k_images/'), + pipeline=test_pipeline, +) + +val_evaluator_Flickr30k = dict(type='Flickr30kMetric', ) + +test_evaluator_Flickr30k = dict(type='Flickr30kMetric', ) + +# ----------Config---------- # +dataset_prefixes = ['Flickr30kVal', 'Flickr30kTest'] +datasets = [dataset_Flickr30k_val, dataset_Flickr30k_test] +metrics = [val_evaluator_Flickr30k, test_evaluator_Flickr30k] + +val_dataloader = dict( + dataset=dict(_delete_=True, type='ConcatDataset', datasets=datasets)) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + type='MultiDatasetsEvaluator', + metrics=metrics, + dataset_prefixes=dataset_prefixes) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/glip/glip_atss_swin-l_fpn_dyhead_16xb2_ms-2x_funtune_coco.py b/mmdetection/configs/glip/glip_atss_swin-l_fpn_dyhead_16xb2_ms-2x_funtune_coco.py new file mode 100644 index 00000000..92a85a11 --- /dev/null +++ b/mmdetection/configs/glip/glip_atss_swin-l_fpn_dyhead_16xb2_ms-2x_funtune_coco.py @@ -0,0 +1,14 @@ +_base_ = './glip_atss_swin-t_b_fpn_dyhead_16xb2_ms-2x_funtune_coco.py' + +model = dict( + backbone=dict( + embed_dims=192, + depths=[2, 2, 18, 2], + num_heads=[6, 12, 24, 48], + window_size=12, + drop_path_rate=0.4, + ), + neck=dict(in_channels=[384, 768, 1536]), + bbox_head=dict(early_fuse=True, num_dyhead_blocks=8, use_checkpoint=True)) + +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/glip/glip_l_mmdet-abfe026b.pth' # noqa diff --git a/mmdetection/configs/glip/glip_atss_swin-l_fpn_dyhead_pretrain_mixeddata.py b/mmdetection/configs/glip/glip_atss_swin-l_fpn_dyhead_pretrain_mixeddata.py new file mode 100644 index 00000000..546ecfe1 --- /dev/null +++ b/mmdetection/configs/glip/glip_atss_swin-l_fpn_dyhead_pretrain_mixeddata.py @@ -0,0 +1,12 @@ +_base_ = './glip_atss_swin-t_a_fpn_dyhead_pretrain_obj365.py' + +model = dict( + backbone=dict( + embed_dims=192, + depths=[2, 2, 18, 2], + num_heads=[6, 12, 24, 48], + window_size=12, + drop_path_rate=0.4, + ), + neck=dict(in_channels=[384, 768, 1536]), + bbox_head=dict(early_fuse=True, num_dyhead_blocks=8)) diff --git a/mmdetection/configs/glip/glip_atss_swin-t_a_fpn_dyhead_16xb2_ms-2x_funtune_coco.py b/mmdetection/configs/glip/glip_atss_swin-t_a_fpn_dyhead_16xb2_ms-2x_funtune_coco.py new file mode 100644 index 00000000..4b280657 --- /dev/null +++ b/mmdetection/configs/glip/glip_atss_swin-t_a_fpn_dyhead_16xb2_ms-2x_funtune_coco.py @@ -0,0 +1,155 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/glip/glip_tiny_a_mmdet-b3654169.pth' # noqa +lang_model_name = 'bert-base-uncased' + +model = dict( + type='GLIP', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[103.53, 116.28, 123.675], + std=[57.375, 57.12, 58.395], + bgr_to_rgb=False, + pad_size_divisor=32), + backbone=dict( + type='SwinTransformer', + embed_dims=96, + depths=[2, 2, 6, 2], + num_heads=[3, 6, 12, 24], + window_size=7, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.2, + patch_norm=True, + out_indices=(1, 2, 3), + with_cp=False, + convert_weights=False), + neck=dict( + type='FPN_DropBlock', + in_channels=[192, 384, 768], + out_channels=256, + start_level=0, + relu_before_extra_convs=True, + add_extra_convs='on_output', + num_outs=5), + bbox_head=dict( + type='ATSSVLFusionHead', + lang_model_name=lang_model_name, + num_classes=80, + in_channels=256, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + octave_base_scale=8, + scales_per_octave=1, + strides=[8, 16, 32, 64, 128], + center_offset=0.5), + bbox_coder=dict( + type='DeltaXYWHBBoxCoderForGLIP', + target_means=[.0, .0, .0, .0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=2.0), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)), + language_model=dict(type='BertModel', name=lang_model_name), + train_cfg=dict( + assigner=dict( + type='ATSSAssigner', + topk=9, + iou_calculator=dict(type='BboxOverlaps2D_GLIP')), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) + +# dataset settings +train_pipeline = [ + dict( + type='LoadImageFromFile', + imdecode_backend='pillow', + backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='GTBoxSubOne_GLIP'), + dict( + type='RandomChoiceResize', + scales=[(1333, 480), (1333, 560), (1333, 640), (1333, 720), + (1333, 800)], + keep_ratio=True, + resize_type='FixScaleResize', + backend='pillow'), + dict(type='RandomFlip_GLIP', prob=0.5), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1, 1)), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities')) +] + +test_pipeline = [ + dict( + type='LoadImageFromFile', + backend_args=_base_.backend_args, + imdecode_backend='pillow'), + dict( + type='FixScaleResize', + scale=(800, 1333), + keep_ratio=True, + backend='pillow'), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'text', 'custom_entities')) +] + +train_dataloader = dict( + dataset=dict( + _delete_=True, + type='RepeatDataset', + times=2, + dataset=dict( + type=_base_.dataset_type, + data_root=_base_.data_root, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + return_classes=True, + backend_args=_base_.backend_args))) + +val_dataloader = dict( + dataset=dict(pipeline=test_pipeline, return_classes=True)) +test_dataloader = val_dataloader + +# We did not adopt the official 24e optimizer strategy +# because the results indicate that the current strategy is superior. +optim_wrapper = dict( + _delete_=True, + type='OptimWrapper', + optimizer=dict( + type='AdamW', lr=0.00002, betas=(0.9, 0.999), weight_decay=0.05), + paramwise_cfg=dict( + custom_keys={ + 'absolute_pos_embed': dict(decay_mult=0.), + 'relative_position_bias_table': dict(decay_mult=0.), + 'norm': dict(decay_mult=0.) + }), + clip_grad=None) diff --git a/mmdetection/configs/glip/glip_atss_swin-t_a_fpn_dyhead_pretrain_obj365.py b/mmdetection/configs/glip/glip_atss_swin-t_a_fpn_dyhead_pretrain_obj365.py new file mode 100644 index 00000000..34a818ca --- /dev/null +++ b/mmdetection/configs/glip/glip_atss_swin-t_a_fpn_dyhead_pretrain_obj365.py @@ -0,0 +1,90 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +lang_model_name = 'bert-base-uncased' + +model = dict( + type='GLIP', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[103.53, 116.28, 123.675], + std=[57.375, 57.12, 58.395], + bgr_to_rgb=False, + pad_size_divisor=32), + backbone=dict( + type='SwinTransformer', + embed_dims=96, + depths=[2, 2, 6, 2], + num_heads=[3, 6, 12, 24], + window_size=7, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.2, + patch_norm=True, + out_indices=(1, 2, 3), + with_cp=False, + convert_weights=False), + neck=dict( + type='FPN', + in_channels=[192, 384, 768], + out_channels=256, + start_level=0, + relu_before_extra_convs=True, + add_extra_convs='on_output', + num_outs=5), + bbox_head=dict( + type='ATSSVLFusionHead', + lang_model_name=lang_model_name, + num_classes=80, + in_channels=256, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + octave_base_scale=8, + scales_per_octave=1, + strides=[8, 16, 32, 64, 128], + center_offset=0.5), + bbox_coder=dict( + type='DeltaXYWHBBoxCoderForGLIP', + target_means=[.0, .0, .0, .0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + ), + language_model=dict(type='BertModel', name=lang_model_name), + train_cfg=dict( + assigner=dict(type='ATSSAssigner', topk=9), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) + +test_pipeline = [ + dict( + type='LoadImageFromFile', + backend_args=_base_.backend_args, + imdecode_backend='pillow'), + dict( + type='FixScaleResize', + scale=(800, 1333), + keep_ratio=True, + backend='pillow'), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'text', 'custom_entities')) +] + +val_dataloader = dict( + dataset=dict(pipeline=test_pipeline, return_classes=True)) +test_dataloader = val_dataloader diff --git a/mmdetection/configs/glip/glip_atss_swin-t_b_fpn_dyhead_16xb2_ms-2x_funtune_coco.py b/mmdetection/configs/glip/glip_atss_swin-t_b_fpn_dyhead_16xb2_ms-2x_funtune_coco.py new file mode 100644 index 00000000..3487de3f --- /dev/null +++ b/mmdetection/configs/glip/glip_atss_swin-t_b_fpn_dyhead_16xb2_ms-2x_funtune_coco.py @@ -0,0 +1,9 @@ +_base_ = './glip_atss_swin-t_a_fpn_dyhead_16xb2_ms-2x_funtune_coco.py' + +model = dict(bbox_head=dict(early_fuse=True, use_checkpoint=True)) + +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/glip/glip_tiny_b_mmdet-6dfbd102.pth' # noqa + +optim_wrapper = dict( + optimizer=dict(lr=0.00001), + clip_grad=dict(_delete_=True, max_norm=1, norm_type=2)) diff --git a/mmdetection/configs/glip/glip_atss_swin-t_b_fpn_dyhead_pretrain_obj365.py b/mmdetection/configs/glip/glip_atss_swin-t_b_fpn_dyhead_pretrain_obj365.py new file mode 100644 index 00000000..6334e5e3 --- /dev/null +++ b/mmdetection/configs/glip/glip_atss_swin-t_b_fpn_dyhead_pretrain_obj365.py @@ -0,0 +1,3 @@ +_base_ = './glip_atss_swin-t_a_fpn_dyhead_pretrain_obj365.py' + +model = dict(bbox_head=dict(early_fuse=True)) diff --git a/mmdetection/configs/glip/glip_atss_swin-t_c_fpn_dyhead_16xb2_ms-2x_funtune_coco.py b/mmdetection/configs/glip/glip_atss_swin-t_c_fpn_dyhead_16xb2_ms-2x_funtune_coco.py new file mode 100644 index 00000000..5c315e49 --- /dev/null +++ b/mmdetection/configs/glip/glip_atss_swin-t_c_fpn_dyhead_16xb2_ms-2x_funtune_coco.py @@ -0,0 +1,3 @@ +_base_ = './glip_atss_swin-t_b_fpn_dyhead_16xb2_ms-2x_funtune_coco.py' + +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/glip/glip_tiny_c_mmdet-2fc427dd.pth' # noqa diff --git a/mmdetection/configs/glip/glip_atss_swin-t_c_fpn_dyhead_pretrain_obj365-goldg.py b/mmdetection/configs/glip/glip_atss_swin-t_c_fpn_dyhead_pretrain_obj365-goldg.py new file mode 100644 index 00000000..24898f4d --- /dev/null +++ b/mmdetection/configs/glip/glip_atss_swin-t_c_fpn_dyhead_pretrain_obj365-goldg.py @@ -0,0 +1 @@ +_base_ = './glip_atss_swin-t_b_fpn_dyhead_pretrain_obj365.py' diff --git a/mmdetection/configs/glip/glip_atss_swin-t_fpn_dyhead_16xb2_ms-2x_funtune_coco.py b/mmdetection/configs/glip/glip_atss_swin-t_fpn_dyhead_16xb2_ms-2x_funtune_coco.py new file mode 100644 index 00000000..3391272e --- /dev/null +++ b/mmdetection/configs/glip/glip_atss_swin-t_fpn_dyhead_16xb2_ms-2x_funtune_coco.py @@ -0,0 +1,3 @@ +_base_ = './glip_atss_swin-t_b_fpn_dyhead_16xb2_ms-2x_funtune_coco.py' + +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/glip/glip_tiny_mmdet-c24ce662.pth' # noqa diff --git a/mmdetection/configs/glip/glip_atss_swin-t_fpn_dyhead_pretrain_obj365-goldg-cc3m-sub.py b/mmdetection/configs/glip/glip_atss_swin-t_fpn_dyhead_pretrain_obj365-goldg-cc3m-sub.py new file mode 100644 index 00000000..24898f4d --- /dev/null +++ b/mmdetection/configs/glip/glip_atss_swin-t_fpn_dyhead_pretrain_obj365-goldg-cc3m-sub.py @@ -0,0 +1 @@ +_base_ = './glip_atss_swin-t_b_fpn_dyhead_pretrain_obj365.py' diff --git a/mmdetection/configs/glip/lvis/glip_atss_swin-l_fpn_dyhead_pretrain_zeroshot_lvis.py b/mmdetection/configs/glip/lvis/glip_atss_swin-l_fpn_dyhead_pretrain_zeroshot_lvis.py new file mode 100644 index 00000000..1f79e447 --- /dev/null +++ b/mmdetection/configs/glip/lvis/glip_atss_swin-l_fpn_dyhead_pretrain_zeroshot_lvis.py @@ -0,0 +1,12 @@ +_base_ = './glip_atss_swin-t_a_fpn_dyhead_pretrain_zeroshot_lvis.py' + +model = dict( + backbone=dict( + embed_dims=192, + depths=[2, 2, 18, 2], + num_heads=[6, 12, 24, 48], + window_size=12, + drop_path_rate=0.4, + ), + neck=dict(in_channels=[384, 768, 1536]), + bbox_head=dict(early_fuse=True, num_dyhead_blocks=8)) diff --git a/mmdetection/configs/glip/lvis/glip_atss_swin-l_fpn_dyhead_pretrain_zeroshot_mini-lvis.py b/mmdetection/configs/glip/lvis/glip_atss_swin-l_fpn_dyhead_pretrain_zeroshot_mini-lvis.py new file mode 100644 index 00000000..13f1a690 --- /dev/null +++ b/mmdetection/configs/glip/lvis/glip_atss_swin-l_fpn_dyhead_pretrain_zeroshot_mini-lvis.py @@ -0,0 +1,12 @@ +_base_ = './glip_atss_swin-t_a_fpn_dyhead_pretrain_zeroshot_mini-lvis.py' + +model = dict( + backbone=dict( + embed_dims=192, + depths=[2, 2, 18, 2], + num_heads=[6, 12, 24, 48], + window_size=12, + drop_path_rate=0.4, + ), + neck=dict(in_channels=[384, 768, 1536]), + bbox_head=dict(early_fuse=True, num_dyhead_blocks=8)) diff --git a/mmdetection/configs/glip/lvis/glip_atss_swin-t_a_fpn_dyhead_pretrain_zeroshot_lvis.py b/mmdetection/configs/glip/lvis/glip_atss_swin-t_a_fpn_dyhead_pretrain_zeroshot_lvis.py new file mode 100644 index 00000000..4d526d59 --- /dev/null +++ b/mmdetection/configs/glip/lvis/glip_atss_swin-t_a_fpn_dyhead_pretrain_zeroshot_lvis.py @@ -0,0 +1,24 @@ +_base_ = '../glip_atss_swin-t_a_fpn_dyhead_pretrain_obj365.py' + +model = dict(test_cfg=dict( + max_per_img=300, + chunked_size=40, +)) + +dataset_type = 'LVISV1Dataset' +data_root = 'data/coco/' + +val_dataloader = dict( + dataset=dict( + data_root=data_root, + type=dataset_type, + ann_file='annotations/lvis_od_val.json', + data_prefix=dict(img=''))) +test_dataloader = val_dataloader + +# numpy < 1.24.0 +val_evaluator = dict( + _delete_=True, + type='LVISFixedAPMetric', + ann_file=data_root + 'annotations/lvis_od_val.json') +test_evaluator = val_evaluator diff --git a/mmdetection/configs/glip/lvis/glip_atss_swin-t_a_fpn_dyhead_pretrain_zeroshot_mini-lvis.py b/mmdetection/configs/glip/lvis/glip_atss_swin-t_a_fpn_dyhead_pretrain_zeroshot_mini-lvis.py new file mode 100644 index 00000000..70a57a3f --- /dev/null +++ b/mmdetection/configs/glip/lvis/glip_atss_swin-t_a_fpn_dyhead_pretrain_zeroshot_mini-lvis.py @@ -0,0 +1,25 @@ +_base_ = '../glip_atss_swin-t_a_fpn_dyhead_pretrain_obj365.py' + +model = dict(test_cfg=dict( + max_per_img=300, + chunked_size=40, +)) + +dataset_type = 'LVISV1Dataset' +data_root = 'data/coco/' + +val_dataloader = dict( + dataset=dict( + data_root=data_root, + type=dataset_type, + ann_file='annotations/lvis_v1_minival_inserted_image_name.json', + data_prefix=dict(img=''))) +test_dataloader = val_dataloader + +# numpy < 1.24.0 +val_evaluator = dict( + _delete_=True, + type='LVISFixedAPMetric', + ann_file=data_root + + 'annotations/lvis_v1_minival_inserted_image_name.json') +test_evaluator = val_evaluator diff --git a/mmdetection/configs/glip/lvis/glip_atss_swin-t_bc_fpn_dyhead_pretrain_zeroshot_lvis.py b/mmdetection/configs/glip/lvis/glip_atss_swin-t_bc_fpn_dyhead_pretrain_zeroshot_lvis.py new file mode 100644 index 00000000..6dc712b3 --- /dev/null +++ b/mmdetection/configs/glip/lvis/glip_atss_swin-t_bc_fpn_dyhead_pretrain_zeroshot_lvis.py @@ -0,0 +1,3 @@ +_base_ = './glip_atss_swin-t_a_fpn_dyhead_pretrain_zeroshot_lvis.py' + +model = dict(bbox_head=dict(early_fuse=True)) diff --git a/mmdetection/configs/glip/lvis/glip_atss_swin-t_bc_fpn_dyhead_pretrain_zeroshot_mini-lvis.py b/mmdetection/configs/glip/lvis/glip_atss_swin-t_bc_fpn_dyhead_pretrain_zeroshot_mini-lvis.py new file mode 100644 index 00000000..3babb911 --- /dev/null +++ b/mmdetection/configs/glip/lvis/glip_atss_swin-t_bc_fpn_dyhead_pretrain_zeroshot_mini-lvis.py @@ -0,0 +1,3 @@ +_base_ = './glip_atss_swin-t_a_fpn_dyhead_pretrain_zeroshot_mini-lvis.py' + +model = dict(bbox_head=dict(early_fuse=True)) diff --git a/mmdetection/configs/glip/metafile.yml b/mmdetection/configs/glip/metafile.yml new file mode 100644 index 00000000..fbbf718b --- /dev/null +++ b/mmdetection/configs/glip/metafile.yml @@ -0,0 +1,111 @@ +Collections: + - Name: GLIP + Metadata: + Training Data: Objects365, GoldG, CC3M, SBU and COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: A100 GPUs + Architecture: + - Swin Transformer + - DYHead + - BERT + Paper: + URL: https://arxiv.org/abs/2112.03857 + Title: 'GLIP: Grounded Language-Image Pre-training' + README: configs/glip/README.md + Code: + URL: + Version: v3.0.0 + +Models: + - Name: glip_atss_swin-t_a_fpn_dyhead_pretrain_obj365 + In Collection: GLIP + Config: configs/glip/glip_atss_swin-t_a_fpn_dyhead_pretrain_obj365.py + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.0 + Weights: https://download.openmmlab.com/mmdetection/v3.0/glip/glip_tiny_a_mmdet-b3654169.pth + - Name: glip_atss_swin-t_b_fpn_dyhead_pretrain_obj365 + In Collection: GLIP + Config: configs/glip/glip_atss_swin-t_b_fpn_dyhead_pretrain_obj365.py + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.9 + Weights: https://download.openmmlab.com/mmdetection/v3.0/glip/glip_tiny_b_mmdet-6dfbd102.pth + - Name: glip_atss_swin-t_c_fpn_dyhead_pretrain_obj365-goldg + In Collection: GLIP + Config: configs/glip/glip_atss_swin-t_c_fpn_dyhead_pretrain_obj365-goldg.py + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.7 + Weights: https://download.openmmlab.com/mmdetection/v3.0/glip/glip_tiny_c_mmdet-2fc427dd.pth + - Name: glip_atss_swin-t_fpn_dyhead_pretrain_obj365-goldg-cc3m-sub + In Collection: GLIP + Config: configs/glip/glip_atss_swin-t_fpn_dyhead_pretrain_obj365-goldg-cc3m-sub.py + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.4 + Weights: https://download.openmmlab.com/mmdetection/v3.0/glip/glip_tiny_mmdet-c24ce662.pth + - Name: glip_atss_swin-l_fpn_dyhead_pretrain_mixeddata + In Collection: GLIP + Config: configs/glip/glip_atss_swin-l_fpn_dyhead_pretrain_mixeddata.py + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 51.3 + Weights: https://download.openmmlab.com/mmdetection/v3.0/glip/glip_l_mmdet-abfe026b.pth + - Name: glip_atss_swin-t_a_fpn_dyhead_16xb2_ms-2x_funtune_coco + In Collection: GLIP + Config: configs/glip/glip_atss_swin-t_a_fpn_dyhead_16xb2_ms-2x_funtune_coco.py + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 53.3 + Weights: https://download.openmmlab.com/mmdetection/v3.0/glip/glip_atss_swin-t_a_fpn_dyhead_16xb2_ms-2x_funtune_coco/glip_atss_swin-t_a_fpn_dyhead_16xb2_ms-2x_funtune_coco_20230914_180419-e6addd96.pth + - Name: glip_atss_swin-t_b_fpn_dyhead_16xb2_ms-2x_funtune_coco + In Collection: GLIP + Config: configs/glip/glip_atss_swin-t_b_fpn_dyhead_16xb2_ms-2x_funtune_coco.py + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 54.1 + Weights: https://download.openmmlab.com/mmdetection/v3.0/glip/glip_atss_swin-t_b_fpn_dyhead_16xb2_ms-2x_funtune_coco/glip_atss_swin-t_b_fpn_dyhead_16xb2_ms-2x_funtune_coco_20230916_163538-650323ba.pth + - Name: glip_atss_swin-t_c_fpn_dyhead_16xb2_ms-2x_funtune_coco + In Collection: GLIP + Config: configs/glip/glip_atss_swin-t_c_fpn_dyhead_16xb2_ms-2x_funtune_coco.py + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 55.2 + Weights: https://download.openmmlab.com/mmdetection/v3.0/glip/glip_atss_swin-t_c_fpn_dyhead_16xb2_ms-2x_funtune_coco/glip_atss_swin-t_c_fpn_dyhead_16xb2_ms-2x_funtune_coco_20230914_182935-4ba3fc3b.pth + - Name: glip_atss_swin-t_fpn_dyhead_16xb2_ms-2x_funtune_coco + In Collection: GLIP + Config: configs/glip/glip_atss_swin-t_fpn_dyhead_16xb2_ms-2x_funtune_coco.py + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 55.4 + Weights: https://download.openmmlab.com/mmdetection/v3.0/glip/glip_atss_swin-t_fpn_dyhead_16xb2_ms-2x_funtune_coco/glip_atss_swin-t_fpn_dyhead_16xb2_ms-2x_funtune_coco_20230914_224410-ba97be24.pth + - Name: glip_atss_swin-l_fpn_dyhead_16xb2_ms-2x_funtune_coco + In Collection: GLIP + Config: configs/glip/glip_atss_swin-l_fpn_dyhead_16xb2_ms-2x_funtune_coco.py + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 59.4 + Weights: https://download.openmmlab.com/mmdetection/v3.0/glip/glip_atss_swin-l_fpn_dyhead_16xb2_ms-2x_funtune_coco/glip_atss_swin-l_fpn_dyhead_16xb2_ms-2x_funtune_coco_20230910_100800-e9be4274.pth diff --git a/mmdetection/configs/glip/odinw/glip_atss_swin-t_a_fpn_dyhead_pretrain_odinw13.py b/mmdetection/configs/glip/odinw/glip_atss_swin-t_a_fpn_dyhead_pretrain_odinw13.py new file mode 100644 index 00000000..d38effba --- /dev/null +++ b/mmdetection/configs/glip/odinw/glip_atss_swin-t_a_fpn_dyhead_pretrain_odinw13.py @@ -0,0 +1,338 @@ +_base_ = '../glip_atss_swin-t_a_fpn_dyhead_pretrain_obj365.py' + +dataset_type = 'CocoDataset' +data_root = 'data/odinw/' + +base_test_pipeline = _base_.test_pipeline +base_test_pipeline[-1]['meta_keys'] = ('img_id', 'img_path', 'ori_shape', + 'img_shape', 'scale_factor', 'text', + 'custom_entities', 'caption_prompt') + +# ---------------------1 AerialMaritimeDrone---------------------# +class_name = ('boat', 'car', 'dock', 'jetski', 'lift') +metainfo = dict(classes=class_name) +_data_root = data_root + 'AerialMaritimeDrone/large/' +dataset_AerialMaritimeDrone = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + test_mode=True, + pipeline=base_test_pipeline, + return_classes=True) +val_evaluator_AerialMaritimeDrone = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------2 Aquarium---------------------# +class_name = ('fish', 'jellyfish', 'penguin', 'puffin', 'shark', 'starfish', + 'stingray') +metainfo = dict(classes=class_name) +_data_root = data_root + 'Aquarium/Aquarium Combined.v2-raw-1024.coco/' + +caption_prompt = None +# caption_prompt = { +# 'penguin': { +# 'suffix': ', which is black and white' +# }, +# 'puffin': { +# 'suffix': ' with orange beaks' +# }, +# 'stingray': { +# 'suffix': ' which is flat and round' +# }, +# } +dataset_Aquarium = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_Aquarium = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------3 CottontailRabbits---------------------# +class_name = ('Cottontail-Rabbit', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'CottontailRabbits/' + +caption_prompt = None +# caption_prompt = {'Cottontail-Rabbit': {'name': 'rabbit'}} + +dataset_CottontailRabbits = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_CottontailRabbits = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------4 EgoHands---------------------# +class_name = ('hand', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'EgoHands/generic/' + +caption_prompt = None +# caption_prompt = {'hand': {'suffix': ' of a person'}} + +dataset_EgoHands = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_EgoHands = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------5 NorthAmericaMushrooms---------------------# +class_name = ('CoW', 'chanterelle') +metainfo = dict(classes=class_name) +_data_root = data_root + 'NorthAmericaMushrooms/North American Mushrooms.v1-416x416.coco/' # noqa + +caption_prompt = None +# caption_prompt = { +# 'CoW': { +# 'name': 'flat mushroom' +# }, +# 'chanterelle': { +# 'name': 'yellow mushroom' +# } +# } + +dataset_NorthAmericaMushrooms = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_NorthAmericaMushrooms = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------6 Packages---------------------# +class_name = ('package', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'Packages/Raw/' + +caption_prompt = None +# caption_prompt = { +# 'package': { +# 'prefix': 'there is a ', +# 'suffix': ' on the porch' +# } +# } + +dataset_Packages = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_Packages = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------7 PascalVOC---------------------# +class_name = ('aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', + 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', + 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', + 'tvmonitor') +metainfo = dict(classes=class_name) +_data_root = data_root + 'PascalVOC/' +dataset_PascalVOC = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_PascalVOC = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------8 pistols---------------------# +class_name = ('pistol', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'pistols/export/' +dataset_pistols = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='val_annotations_without_background.json', + data_prefix=dict(img=''), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_pistols = dict( + type='CocoMetric', + ann_file=_data_root + 'val_annotations_without_background.json', + metric='bbox') + +# ---------------------9 pothole---------------------# +class_name = ('pothole', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'pothole/' + +caption_prompt = None +# caption_prompt = { +# 'pothole': { +# 'prefix': 'there are some ', +# 'name': 'holes', +# 'suffix': ' on the road' +# } +# } + +dataset_pothole = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_pothole = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------10 Raccoon---------------------# +class_name = ('raccoon', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'Raccoon/Raccoon.v2-raw.coco/' +dataset_Raccoon = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_Raccoon = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------11 ShellfishOpenImages---------------------# +class_name = ('Crab', 'Lobster', 'Shrimp') +metainfo = dict(classes=class_name) +_data_root = data_root + 'ShellfishOpenImages/raw/' +dataset_ShellfishOpenImages = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_ShellfishOpenImages = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------12 thermalDogsAndPeople---------------------# +class_name = ('dog', 'person') +metainfo = dict(classes=class_name) +_data_root = data_root + 'thermalDogsAndPeople/' +dataset_thermalDogsAndPeople = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_thermalDogsAndPeople = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------13 VehiclesOpenImages---------------------# +class_name = ('Ambulance', 'Bus', 'Car', 'Motorcycle', 'Truck') +metainfo = dict(classes=class_name) +_data_root = data_root + 'VehiclesOpenImages/416x416/' +dataset_VehiclesOpenImages = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_VehiclesOpenImages = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# --------------------- Config---------------------# +dataset_prefixes = [ + 'AerialMaritimeDrone', 'Aquarium', 'CottontailRabbits', 'EgoHands', + 'NorthAmericaMushrooms', 'Packages', 'PascalVOC', 'pistols', 'pothole', + 'Raccoon', 'ShellfishOpenImages', 'thermalDogsAndPeople', + 'VehiclesOpenImages' +] +datasets = [ + dataset_AerialMaritimeDrone, dataset_Aquarium, dataset_CottontailRabbits, + dataset_EgoHands, dataset_NorthAmericaMushrooms, dataset_Packages, + dataset_PascalVOC, dataset_pistols, dataset_pothole, dataset_Raccoon, + dataset_ShellfishOpenImages, dataset_thermalDogsAndPeople, + dataset_VehiclesOpenImages +] +metrics = [ + val_evaluator_AerialMaritimeDrone, val_evaluator_Aquarium, + val_evaluator_CottontailRabbits, val_evaluator_EgoHands, + val_evaluator_NorthAmericaMushrooms, val_evaluator_Packages, + val_evaluator_PascalVOC, val_evaluator_pistols, val_evaluator_pothole, + val_evaluator_Raccoon, val_evaluator_ShellfishOpenImages, + val_evaluator_thermalDogsAndPeople, val_evaluator_VehiclesOpenImages +] + +# -------------------------------------------------# +val_dataloader = dict( + dataset=dict(_delete_=True, type='ConcatDataset', datasets=datasets)) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + type='MultiDatasetsEvaluator', + metrics=metrics, + dataset_prefixes=dataset_prefixes) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/glip/odinw/glip_atss_swin-t_a_fpn_dyhead_pretrain_odinw35.py b/mmdetection/configs/glip/odinw/glip_atss_swin-t_a_fpn_dyhead_pretrain_odinw35.py new file mode 100644 index 00000000..2eaf09ed --- /dev/null +++ b/mmdetection/configs/glip/odinw/glip_atss_swin-t_a_fpn_dyhead_pretrain_odinw35.py @@ -0,0 +1,794 @@ +_base_ = '../glip_atss_swin-t_a_fpn_dyhead_pretrain_obj365.py' + +dataset_type = 'CocoDataset' +data_root = 'data/odinw/' + +base_test_pipeline = _base_.test_pipeline +base_test_pipeline[-1]['meta_keys'] = ('img_id', 'img_path', 'ori_shape', + 'img_shape', 'scale_factor', 'text', + 'custom_entities', 'caption_prompt') + +# ---------------------1 AerialMaritimeDrone_large---------------------# +class_name = ('boat', 'car', 'dock', 'jetski', 'lift') +metainfo = dict(classes=class_name) +_data_root = data_root + 'AerialMaritimeDrone/large/' +dataset_AerialMaritimeDrone_large = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_AerialMaritimeDrone_large = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------2 AerialMaritimeDrone_tiled---------------------# +class_name = ('boat', 'car', 'dock', 'jetski', 'lift') +metainfo = dict(classes=class_name) +_data_root = data_root + 'AerialMaritimeDrone/tiled/' +dataset_AerialMaritimeDrone_tiled = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_AerialMaritimeDrone_tiled = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------3 AmericanSignLanguageLetters---------------------# +class_name = ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', + 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z') +metainfo = dict(classes=class_name) +_data_root = data_root + 'AmericanSignLanguageLetters/American Sign Language Letters.v1-v1.coco/' # noqa +dataset_AmericanSignLanguageLetters = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_AmericanSignLanguageLetters = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------4 Aquarium---------------------# +class_name = ('fish', 'jellyfish', 'penguin', 'puffin', 'shark', 'starfish', + 'stingray') +metainfo = dict(classes=class_name) +_data_root = data_root + 'Aquarium/Aquarium Combined.v2-raw-1024.coco/' +dataset_Aquarium = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_Aquarium = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------5 BCCD---------------------# +class_name = ('Platelets', 'RBC', 'WBC') +metainfo = dict(classes=class_name) +_data_root = data_root + 'BCCD/BCCD.v3-raw.coco/' +dataset_BCCD = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_BCCD = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------6 boggleBoards---------------------# +class_name = ('Q', 'a', 'an', 'b', 'c', 'd', 'e', 'er', 'f', 'g', 'h', 'he', + 'i', 'in', 'j', 'k', 'l', 'm', 'n', 'o', 'o ', 'p', 'q', 'qu', + 'r', 's', 't', 't\\', 'th', 'u', 'v', 'w', 'wild', 'x', 'y', 'z') +metainfo = dict(classes=class_name) +_data_root = data_root + 'boggleBoards/416x416AutoOrient/export/' +dataset_boggleBoards = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='val_annotations_without_background.json', + data_prefix=dict(img=''), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_boggleBoards = dict( + type='CocoMetric', + ann_file=_data_root + 'val_annotations_without_background.json', + metric='bbox') + +# ---------------------7 brackishUnderwater---------------------# +class_name = ('crab', 'fish', 'jellyfish', 'shrimp', 'small_fish', 'starfish') +metainfo = dict(classes=class_name) +_data_root = data_root + 'brackishUnderwater/960x540/' +dataset_brackishUnderwater = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_brackishUnderwater = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------8 ChessPieces---------------------# +class_name = (' ', 'black bishop', 'black king', 'black knight', 'black pawn', + 'black queen', 'black rook', 'white bishop', 'white king', + 'white knight', 'white pawn', 'white queen', 'white rook') +metainfo = dict(classes=class_name) +_data_root = data_root + 'ChessPieces/Chess Pieces.v23-raw.coco/' +dataset_ChessPieces = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/new_annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_ChessPieces = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/new_annotations_without_background.json', + metric='bbox') + +# ---------------------9 CottontailRabbits---------------------# +class_name = ('rabbit', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'CottontailRabbits/' +dataset_CottontailRabbits = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/new_annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_CottontailRabbits = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/new_annotations_without_background.json', + metric='bbox') + +# ---------------------10 dice---------------------# +class_name = ('1', '2', '3', '4', '5', '6') +metainfo = dict(classes=class_name) +_data_root = data_root + 'dice/mediumColor/export/' +dataset_dice = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='val_annotations_without_background.json', + data_prefix=dict(img=''), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_dice = dict( + type='CocoMetric', + ann_file=_data_root + 'val_annotations_without_background.json', + metric='bbox') + +# ---------------------11 DroneControl---------------------# +class_name = ('follow', 'follow_hand', 'land', 'land_hand', 'null', 'object', + 'takeoff', 'takeoff-hand') +metainfo = dict(classes=class_name) +_data_root = data_root + 'DroneControl/Drone Control.v3-raw.coco/' +dataset_DroneControl = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_DroneControl = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------12 EgoHands_generic---------------------# +class_name = ('hand', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'EgoHands/generic/' +caption_prompt = {'hand': {'suffix': ' of a person'}} +dataset_EgoHands_generic = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_EgoHands_generic = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------13 EgoHands_specific---------------------# +class_name = ('myleft', 'myright', 'yourleft', 'yourright') +metainfo = dict(classes=class_name) +_data_root = data_root + 'EgoHands/specific/' +dataset_EgoHands_specific = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_EgoHands_specific = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------14 HardHatWorkers---------------------# +class_name = ('head', 'helmet', 'person') +metainfo = dict(classes=class_name) +_data_root = data_root + 'HardHatWorkers/raw/' +dataset_HardHatWorkers = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_HardHatWorkers = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------15 MaskWearing---------------------# +class_name = ('mask', 'no-mask') +metainfo = dict(classes=class_name) +_data_root = data_root + 'MaskWearing/raw/' +dataset_MaskWearing = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_MaskWearing = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------16 MountainDewCommercial---------------------# +class_name = ('bottle', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'MountainDewCommercial/' +dataset_MountainDewCommercial = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_MountainDewCommercial = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------17 NorthAmericaMushrooms---------------------# +class_name = ('flat mushroom', 'yellow mushroom') +metainfo = dict(classes=class_name) +_data_root = data_root + 'NorthAmericaMushrooms/North American Mushrooms.v1-416x416.coco/' # noqa +dataset_NorthAmericaMushrooms = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/new_annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_NorthAmericaMushrooms = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/new_annotations_without_background.json', + metric='bbox') + +# ---------------------18 openPoetryVision---------------------# +class_name = ('American Typewriter', 'Andale Mono', 'Apple Chancery', 'Arial', + 'Avenir', 'Baskerville', 'Big Caslon', 'Bradley Hand', + 'Brush Script MT', 'Chalkboard', 'Comic Sans MS', 'Copperplate', + 'Courier', 'Didot', 'Futura', 'Geneva', 'Georgia', 'Gill Sans', + 'Helvetica', 'Herculanum', 'Impact', 'Kefa', 'Lucida Grande', + 'Luminari', 'Marker Felt', 'Menlo', 'Monaco', 'Noteworthy', + 'Optima', 'PT Sans', 'PT Serif', 'Palatino', 'Papyrus', + 'Phosphate', 'Rockwell', 'SF Pro', 'SignPainter', 'Skia', + 'Snell Roundhand', 'Tahoma', 'Times New Roman', 'Trebuchet MS', + 'Verdana') +metainfo = dict(classes=class_name) +_data_root = data_root + 'openPoetryVision/512x512/' +dataset_openPoetryVision = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_openPoetryVision = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------19 OxfordPets_by_breed---------------------# +class_name = ('cat-Abyssinian', 'cat-Bengal', 'cat-Birman', 'cat-Bombay', + 'cat-British_Shorthair', 'cat-Egyptian_Mau', 'cat-Maine_Coon', + 'cat-Persian', 'cat-Ragdoll', 'cat-Russian_Blue', 'cat-Siamese', + 'cat-Sphynx', 'dog-american_bulldog', + 'dog-american_pit_bull_terrier', 'dog-basset_hound', + 'dog-beagle', 'dog-boxer', 'dog-chihuahua', + 'dog-english_cocker_spaniel', 'dog-english_setter', + 'dog-german_shorthaired', 'dog-great_pyrenees', 'dog-havanese', + 'dog-japanese_chin', 'dog-keeshond', 'dog-leonberger', + 'dog-miniature_pinscher', 'dog-newfoundland', 'dog-pomeranian', + 'dog-pug', 'dog-saint_bernard', 'dog-samoyed', + 'dog-scottish_terrier', 'dog-shiba_inu', + 'dog-staffordshire_bull_terrier', 'dog-wheaten_terrier', + 'dog-yorkshire_terrier') +metainfo = dict(classes=class_name) +_data_root = data_root + 'OxfordPets/by-breed/' # noqa +dataset_OxfordPets_by_breed = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_OxfordPets_by_breed = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------20 OxfordPets_by_species---------------------# +class_name = ('cat', 'dog') +metainfo = dict(classes=class_name) +_data_root = data_root + 'OxfordPets/by-species/' # noqa +dataset_OxfordPets_by_species = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_OxfordPets_by_species = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------21 PKLot---------------------# +class_name = ('space-empty', 'space-occupied') +metainfo = dict(classes=class_name) +_data_root = data_root + 'PKLot/640/' # noqa +dataset_PKLot = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_PKLot = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------22 Packages---------------------# +class_name = ('package', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'Packages/Raw/' +caption_prompt = { + 'package': { + 'prefix': 'there is a ', + 'suffix': ' on the porch' + } +} +dataset_Packages = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_Packages = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------23 PascalVOC---------------------# +class_name = ('aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', + 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', + 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', + 'tvmonitor') +metainfo = dict(classes=class_name) +_data_root = data_root + 'PascalVOC/' +dataset_PascalVOC = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_PascalVOC = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------24 pistols---------------------# +class_name = ('pistol', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'pistols/export/' +dataset_pistols = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='val_annotations_without_background.json', + data_prefix=dict(img=''), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_pistols = dict( + type='CocoMetric', + ann_file=_data_root + 'val_annotations_without_background.json', + metric='bbox') + +# ---------------------25 plantdoc---------------------# +class_name = ('Apple Scab Leaf', 'Apple leaf', 'Apple rust leaf', + 'Bell_pepper leaf', 'Bell_pepper leaf spot', 'Blueberry leaf', + 'Cherry leaf', 'Corn Gray leaf spot', 'Corn leaf blight', + 'Corn rust leaf', 'Peach leaf', 'Potato leaf', + 'Potato leaf early blight', 'Potato leaf late blight', + 'Raspberry leaf', 'Soyabean leaf', 'Soybean leaf', + 'Squash Powdery mildew leaf', 'Strawberry leaf', + 'Tomato Early blight leaf', 'Tomato Septoria leaf spot', + 'Tomato leaf', 'Tomato leaf bacterial spot', + 'Tomato leaf late blight', 'Tomato leaf mosaic virus', + 'Tomato leaf yellow virus', 'Tomato mold leaf', + 'Tomato two spotted spider mites leaf', 'grape leaf', + 'grape leaf black rot') +metainfo = dict(classes=class_name) +_data_root = data_root + 'plantdoc/416x416/' +dataset_plantdoc = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_plantdoc = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------26 pothole---------------------# +class_name = ('pothole', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'pothole/' +caption_prompt = { + 'pothole': { + 'name': 'holes', + 'prefix': 'there are some ', + 'suffix': ' on the road' + } +} +dataset_pothole = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + caption_prompt=caption_prompt, + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_pothole = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------27 Raccoon---------------------# +class_name = ('raccoon', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'Raccoon/Raccoon.v2-raw.coco/' +dataset_Raccoon = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_Raccoon = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------28 selfdrivingCar---------------------# +class_name = ('biker', 'car', 'pedestrian', 'trafficLight', + 'trafficLight-Green', 'trafficLight-GreenLeft', + 'trafficLight-Red', 'trafficLight-RedLeft', + 'trafficLight-Yellow', 'trafficLight-YellowLeft', 'truck') +metainfo = dict(classes=class_name) +_data_root = data_root + 'selfdrivingCar/fixedLarge/export/' +dataset_selfdrivingCar = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='val_annotations_without_background.json', + data_prefix=dict(img=''), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_selfdrivingCar = dict( + type='CocoMetric', + ann_file=_data_root + 'val_annotations_without_background.json', + metric='bbox') + +# ---------------------29 ShellfishOpenImages---------------------# +class_name = ('Crab', 'Lobster', 'Shrimp') +metainfo = dict(classes=class_name) +_data_root = data_root + 'ShellfishOpenImages/raw/' +dataset_ShellfishOpenImages = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_ShellfishOpenImages = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------30 ThermalCheetah---------------------# +class_name = ('cheetah', 'human') +metainfo = dict(classes=class_name) +_data_root = data_root + 'ThermalCheetah/' +dataset_ThermalCheetah = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_ThermalCheetah = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------31 thermalDogsAndPeople---------------------# +class_name = ('dog', 'person') +metainfo = dict(classes=class_name) +_data_root = data_root + 'thermalDogsAndPeople/' +dataset_thermalDogsAndPeople = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_thermalDogsAndPeople = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------32 UnoCards---------------------# +class_name = ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', + '12', '13', '14') +metainfo = dict(classes=class_name) +_data_root = data_root + 'UnoCards/raw/' +dataset_UnoCards = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_UnoCards = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------33 VehiclesOpenImages---------------------# +class_name = ('Ambulance', 'Bus', 'Car', 'Motorcycle', 'Truck') +metainfo = dict(classes=class_name) +_data_root = data_root + 'VehiclesOpenImages/416x416/' +dataset_VehiclesOpenImages = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_VehiclesOpenImages = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------34 WildfireSmoke---------------------# +class_name = ('smoke', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'WildfireSmoke/' +dataset_WildfireSmoke = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_WildfireSmoke = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------35 websiteScreenshots---------------------# +class_name = ('button', 'field', 'heading', 'iframe', 'image', 'label', 'link', + 'text') +metainfo = dict(classes=class_name) +_data_root = data_root + 'websiteScreenshots/' +dataset_websiteScreenshots = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_websiteScreenshots = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# --------------------- Config---------------------# + +dataset_prefixes = [ + 'AerialMaritimeDrone_large', + 'AerialMaritimeDrone_tiled', + 'AmericanSignLanguageLetters', + 'Aquarium', + 'BCCD', + 'boggleBoards', + 'brackishUnderwater', + 'ChessPieces', + 'CottontailRabbits', + 'dice', + 'DroneControl', + 'EgoHands_generic', + 'EgoHands_specific', + 'HardHatWorkers', + 'MaskWearing', + 'MountainDewCommercial', + 'NorthAmericaMushrooms', + 'openPoetryVision', + 'OxfordPets_by_breed', + 'OxfordPets_by_species', + 'PKLot', + 'Packages', + 'PascalVOC', + 'pistols', + 'plantdoc', + 'pothole', + 'Raccoons', + 'selfdrivingCar', + 'ShellfishOpenImages', + 'ThermalCheetah', + 'thermalDogsAndPeople', + 'UnoCards', + 'VehiclesOpenImages', + 'WildfireSmoke', + 'websiteScreenshots', +] + +datasets = [ + dataset_AerialMaritimeDrone_large, dataset_AerialMaritimeDrone_tiled, + dataset_AmericanSignLanguageLetters, dataset_Aquarium, dataset_BCCD, + dataset_boggleBoards, dataset_brackishUnderwater, dataset_ChessPieces, + dataset_CottontailRabbits, dataset_dice, dataset_DroneControl, + dataset_EgoHands_generic, dataset_EgoHands_specific, + dataset_HardHatWorkers, dataset_MaskWearing, dataset_MountainDewCommercial, + dataset_NorthAmericaMushrooms, dataset_openPoetryVision, + dataset_OxfordPets_by_breed, dataset_OxfordPets_by_species, dataset_PKLot, + dataset_Packages, dataset_PascalVOC, dataset_pistols, dataset_plantdoc, + dataset_pothole, dataset_Raccoon, dataset_selfdrivingCar, + dataset_ShellfishOpenImages, dataset_ThermalCheetah, + dataset_thermalDogsAndPeople, dataset_UnoCards, dataset_VehiclesOpenImages, + dataset_WildfireSmoke, dataset_websiteScreenshots +] + +metrics = [ + val_evaluator_AerialMaritimeDrone_large, + val_evaluator_AerialMaritimeDrone_tiled, + val_evaluator_AmericanSignLanguageLetters, val_evaluator_Aquarium, + val_evaluator_BCCD, val_evaluator_boggleBoards, + val_evaluator_brackishUnderwater, val_evaluator_ChessPieces, + val_evaluator_CottontailRabbits, val_evaluator_dice, + val_evaluator_DroneControl, val_evaluator_EgoHands_generic, + val_evaluator_EgoHands_specific, val_evaluator_HardHatWorkers, + val_evaluator_MaskWearing, val_evaluator_MountainDewCommercial, + val_evaluator_NorthAmericaMushrooms, val_evaluator_openPoetryVision, + val_evaluator_OxfordPets_by_breed, val_evaluator_OxfordPets_by_species, + val_evaluator_PKLot, val_evaluator_Packages, val_evaluator_PascalVOC, + val_evaluator_pistols, val_evaluator_plantdoc, val_evaluator_pothole, + val_evaluator_Raccoon, val_evaluator_selfdrivingCar, + val_evaluator_ShellfishOpenImages, val_evaluator_ThermalCheetah, + val_evaluator_thermalDogsAndPeople, val_evaluator_UnoCards, + val_evaluator_VehiclesOpenImages, val_evaluator_WildfireSmoke, + val_evaluator_websiteScreenshots +] + +# -------------------------------------------------# +val_dataloader = dict( + dataset=dict(_delete_=True, type='ConcatDataset', datasets=datasets)) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + type='MultiDatasetsEvaluator', + metrics=metrics, + dataset_prefixes=dataset_prefixes) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/glip/odinw/glip_atss_swin-t_bc_fpn_dyhead_pretrain_odinw13.py b/mmdetection/configs/glip/odinw/glip_atss_swin-t_bc_fpn_dyhead_pretrain_odinw13.py new file mode 100644 index 00000000..c3479b62 --- /dev/null +++ b/mmdetection/configs/glip/odinw/glip_atss_swin-t_bc_fpn_dyhead_pretrain_odinw13.py @@ -0,0 +1,3 @@ +_base_ = './glip_atss_swin-t_a_fpn_dyhead_pretrain_odinw13.py' + +model = dict(bbox_head=dict(early_fuse=True)) diff --git a/mmdetection/configs/glip/odinw/glip_atss_swin-t_bc_fpn_dyhead_pretrain_odinw35.py b/mmdetection/configs/glip/odinw/glip_atss_swin-t_bc_fpn_dyhead_pretrain_odinw35.py new file mode 100644 index 00000000..182afc66 --- /dev/null +++ b/mmdetection/configs/glip/odinw/glip_atss_swin-t_bc_fpn_dyhead_pretrain_odinw35.py @@ -0,0 +1,3 @@ +_base_ = './glip_atss_swin-t_a_fpn_dyhead_pretrain_odinw35.py' + +model = dict(bbox_head=dict(early_fuse=True)) diff --git a/mmdetection/configs/glip/odinw/override_category.py b/mmdetection/configs/glip/odinw/override_category.py new file mode 100644 index 00000000..9ff05fc6 --- /dev/null +++ b/mmdetection/configs/glip/odinw/override_category.py @@ -0,0 +1,109 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import argparse + +import mmengine + + +def parse_args(): + parser = argparse.ArgumentParser(description='Override Category') + parser.add_argument('data_root') + return parser.parse_args() + + +def main(): + args = parse_args() + + ChessPieces = [{ + 'id': 1, + 'name': ' ', + 'supercategory': 'pieces' + }, { + 'id': 2, + 'name': 'black bishop', + 'supercategory': 'pieces' + }, { + 'id': 3, + 'name': 'black king', + 'supercategory': 'pieces' + }, { + 'id': 4, + 'name': 'black knight', + 'supercategory': 'pieces' + }, { + 'id': 5, + 'name': 'black pawn', + 'supercategory': 'pieces' + }, { + 'id': 6, + 'name': 'black queen', + 'supercategory': 'pieces' + }, { + 'id': 7, + 'name': 'black rook', + 'supercategory': 'pieces' + }, { + 'id': 8, + 'name': 'white bishop', + 'supercategory': 'pieces' + }, { + 'id': 9, + 'name': 'white king', + 'supercategory': 'pieces' + }, { + 'id': 10, + 'name': 'white knight', + 'supercategory': 'pieces' + }, { + 'id': 11, + 'name': 'white pawn', + 'supercategory': 'pieces' + }, { + 'id': 12, + 'name': 'white queen', + 'supercategory': 'pieces' + }, { + 'id': 13, + 'name': 'white rook', + 'supercategory': 'pieces' + }] + + _data_root = args.data_root + 'ChessPieces/Chess Pieces.v23-raw.coco/' + json_data = mmengine.load(_data_root + + 'valid/annotations_without_background.json') + json_data['categories'] = ChessPieces + mmengine.dump(json_data, + _data_root + 'valid/new_annotations_without_background.json') + + CottontailRabbits = [{ + 'id': 1, + 'name': 'rabbit', + 'supercategory': 'Cottontail-Rabbit' + }] + + _data_root = args.data_root + 'CottontailRabbits/' + json_data = mmengine.load(_data_root + + 'valid/annotations_without_background.json') + json_data['categories'] = CottontailRabbits + mmengine.dump(json_data, + _data_root + 'valid/new_annotations_without_background.json') + + NorthAmericaMushrooms = [{ + 'id': 1, + 'name': 'flat mushroom', + 'supercategory': 'mushroom' + }, { + 'id': 2, + 'name': 'yellow mushroom', + 'supercategory': 'mushroom' + }] + + _data_root = args.data_root + 'NorthAmericaMushrooms/North American Mushrooms.v1-416x416.coco/' # noqa + json_data = mmengine.load(_data_root + + 'valid/annotations_without_background.json') + json_data['categories'] = NorthAmericaMushrooms + mmengine.dump(json_data, + _data_root + 'valid/new_annotations_without_background.json') + + +if __name__ == '__main__': + main() diff --git a/mmdetection/configs/gn+ws/README.md b/mmdetection/configs/gn+ws/README.md new file mode 100644 index 00000000..ef8cfc81 --- /dev/null +++ b/mmdetection/configs/gn+ws/README.md @@ -0,0 +1,54 @@ +# GN + WS + +> [Weight Standardization](https://arxiv.org/abs/1903.10520) + + + +## Abstract + +Batch Normalization (BN) has become an out-of-box technique to improve deep network training. However, its effectiveness is limited for micro-batch training, i.e., each GPU typically has only 1-2 images for training, which is inevitable for many computer vision tasks, e.g., object detection and semantic segmentation, constrained by memory consumption. To address this issue, we propose Weight Standardization (WS) and Batch-Channel Normalization (BCN) to bring two success factors of BN into micro-batch training: 1) the smoothing effects on the loss landscape and 2) the ability to avoid harmful elimination singularities along the training trajectory. WS standardizes the weights in convolutional layers to smooth the loss landscape by reducing the Lipschitz constants of the loss and the gradients; BCN combines batch and channel normalizations and leverages estimated statistics of the activations in convolutional layers to keep networks away from elimination singularities. We validate WS and BCN on comprehensive computer vision tasks, including image classification, object detection, instance segmentation, video recognition and semantic segmentation. All experimental results consistently show that WS and BCN improve micro-batch training significantly. Moreover, using WS and BCN with micro-batch training is even able to match or outperform the performances of BN with large-batch training. + +
    + +
    + +## Results and Models + +Faster R-CNN + +| Backbone | Style | Normalization | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :-------------: | :-----: | :-----------: | :-----: | :------: | :------------: | :----: | :-----: | :---------------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | pytorch | GN+WS | 1x | 5.9 | 11.7 | 39.7 | - | [config](./faster-rcnn_r50_fpn_gn-ws-all_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/faster_rcnn_r50_fpn_gn_ws-all_1x_coco/faster_rcnn_r50_fpn_gn_ws-all_1x_coco_20200130-613d9fe2.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/faster_rcnn_r50_fpn_gn_ws-all_1x_coco/faster_rcnn_r50_fpn_gn_ws-all_1x_coco_20200130_210936.log.json) | +| R-101-FPN | pytorch | GN+WS | 1x | 8.9 | 9.0 | 41.7 | - | [config](./faster-rcnn_r101_fpn_gn-ws-all_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/faster_rcnn_r101_fpn_gn_ws-all_1x_coco/faster_rcnn_r101_fpn_gn_ws-all_1x_coco_20200205-a93b0d75.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/faster_rcnn_r101_fpn_gn_ws-all_1x_coco/faster_rcnn_r101_fpn_gn_ws-all_1x_coco_20200205_232146.log.json) | +| X-50-32x4d-FPN | pytorch | GN+WS | 1x | 7.0 | 10.3 | 40.7 | - | [config](./faster-rcnn_x50-32x4d_fpn_gn-ws-all_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/faster_rcnn_x50_32x4d_fpn_gn_ws-all_1x_coco/faster_rcnn_x50_32x4d_fpn_gn_ws-all_1x_coco_20200203-839c5d9d.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/faster_rcnn_x50_32x4d_fpn_gn_ws-all_1x_coco/faster_rcnn_x50_32x4d_fpn_gn_ws-all_1x_coco_20200203_220113.log.json) | +| X-101-32x4d-FPN | pytorch | GN+WS | 1x | 10.8 | 7.6 | 42.1 | - | [config](./faster-rcnn_x101-32x4d_fpn_gn-ws-all_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/faster_rcnn_x101_32x4d_fpn_gn_ws-all_1x_coco/faster_rcnn_x101_32x4d_fpn_gn_ws-all_1x_coco_20200212-27da1bc2.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/faster_rcnn_x101_32x4d_fpn_gn_ws-all_1x_coco/faster_rcnn_x101_32x4d_fpn_gn_ws-all_1x_coco_20200212_195302.log.json) | + +Mask R-CNN + +| Backbone | Style | Normalization | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :-------------: | :-----: | :-----------: | :-------: | :------: | :------------: | :----: | :-----: | :--------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | pytorch | GN+WS | 2x | 7.3 | 10.5 | 40.6 | 36.6 | [config](./mask-rcnn_r50_fpn_gn-ws-all_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/mask_rcnn_r50_fpn_gn_ws-all_2x_coco/mask_rcnn_r50_fpn_gn_ws-all_2x_coco_20200226-16acb762.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/mask_rcnn_r50_fpn_gn_ws-all_2x_coco/mask_rcnn_r50_fpn_gn_ws-all_2x_coco_20200226_062128.log.json) | +| R-101-FPN | pytorch | GN+WS | 2x | 10.3 | 8.6 | 42.0 | 37.7 | [config](./mask-rcnn_r101_fpn_gn-ws-all_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/mask_rcnn_r101_fpn_gn_ws-all_2x_coco/mask_rcnn_r101_fpn_gn_ws-all_2x_coco_20200212-ea357cd9.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/mask_rcnn_r101_fpn_gn_ws-all_2x_coco/mask_rcnn_r101_fpn_gn_ws-all_2x_coco_20200212_213627.log.json) | +| X-50-32x4d-FPN | pytorch | GN+WS | 2x | 8.4 | 9.3 | 41.1 | 37.0 | [config](./mask-rcnn_x50-32x4d_fpn_gn-ws-all_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/mask_rcnn_x50_32x4d_fpn_gn_ws-all_2x_coco/mask_rcnn_x50_32x4d_fpn_gn_ws-all_2x_coco_20200216-649fdb6f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/mask_rcnn_x50_32x4d_fpn_gn_ws-all_2x_coco/mask_rcnn_x50_32x4d_fpn_gn_ws-all_2x_coco_20200216_201500.log.json) | +| X-101-32x4d-FPN | pytorch | GN+WS | 2x | 12.2 | 7.1 | 42.1 | 37.9 | [config](./mask-rcnn_x101-32x4d_fpn_gn-ws-all_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/mask_rcnn_x101_32x4d_fpn_gn_ws-all_2x_coco/mask_rcnn_x101_32x4d_fpn_gn_ws-all_2x_coco_20200319-33fb95b5.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/mask_rcnn_x101_32x4d_fpn_gn_ws-all_2x_coco/mask_rcnn_x101_32x4d_fpn_gn_ws-all_2x_coco_20200319_104101.log.json) | +| R-50-FPN | pytorch | GN+WS | 20-23-24e | 7.3 | - | 41.1 | 37.1 | [config](./mask-rcnn_r50_fpn_gn-ws-all_20-23-24e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/mask_rcnn_r50_fpn_gn_ws-all_20_23_24e_coco/mask_rcnn_r50_fpn_gn_ws-all_20_23_24e_coco_20200213-487d1283.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/mask_rcnn_r50_fpn_gn_ws-all_20_23_24e_coco/mask_rcnn_r50_fpn_gn_ws-all_20_23_24e_coco_20200213_035123.log.json) | +| R-101-FPN | pytorch | GN+WS | 20-23-24e | 10.3 | - | 43.1 | 38.6 | [config](./mask-rcnn_r101_fpn_gn-ws-all_20-23-24e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/mask_rcnn_r101_fpn_gn_ws-all_20_23_24e_coco/mask_rcnn_r101_fpn_gn_ws-all_20_23_24e_coco_20200213-57b5a50f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/mask_rcnn_r101_fpn_gn_ws-all_20_23_24e_coco/mask_rcnn_r101_fpn_gn_ws-all_20_23_24e_coco_20200213_130142.log.json) | +| X-50-32x4d-FPN | pytorch | GN+WS | 20-23-24e | 8.4 | - | 42.1 | 38.0 | [config](./mask-rcnn_x50-32x4d_fpn_gn-ws-all_20-23-24e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/mask_rcnn_x50_32x4d_fpn_gn_ws-all_20_23_24e_coco/mask_rcnn_x50_32x4d_fpn_gn_ws-all_20_23_24e_coco_20200226-969bcb2c.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/mask_rcnn_x50_32x4d_fpn_gn_ws-all_20_23_24e_coco/mask_rcnn_x50_32x4d_fpn_gn_ws-all_20_23_24e_coco_20200226_093732.log.json) | +| X-101-32x4d-FPN | pytorch | GN+WS | 20-23-24e | 12.2 | - | 42.7 | 38.5 | [config](./mask-rcnn_x101-32x4d_fpn_gn-ws-all_20-23-24e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/mask_rcnn_x101_32x4d_fpn_gn_ws-all_20_23_24e_coco/mask_rcnn_x101_32x4d_fpn_gn_ws-all_20_23_24e_coco_20200316-e6cd35ef.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/mask_rcnn_x101_32x4d_fpn_gn_ws-all_20_23_24e_coco/mask_rcnn_x101_32x4d_fpn_gn_ws-all_20_23_24e_coco_20200316_013741.log.json) | + +Note: + +- GN+WS requires about 5% more memory than GN, and it is only 5% slower than GN. +- In the paper, a 20-23-24e lr schedule is used instead of 2x. +- The X-50-GN and X-101-GN pretrained models are also shared by the authors. + +## Citation + +```latex +@article{weightstandardization, + author = {Siyuan Qiao and Huiyu Wang and Chenxi Liu and Wei Shen and Alan Yuille}, + title = {Weight Standardization}, + journal = {arXiv preprint arXiv:1903.10520}, + year = {2019}, +} +``` diff --git a/mmdetection/configs/gn+ws/faster-rcnn_r101_fpn_gn-ws-all_1x_coco.py b/mmdetection/configs/gn+ws/faster-rcnn_r101_fpn_gn-ws-all_1x_coco.py new file mode 100644 index 00000000..a4cb8281 --- /dev/null +++ b/mmdetection/configs/gn+ws/faster-rcnn_r101_fpn_gn-ws-all_1x_coco.py @@ -0,0 +1,6 @@ +_base_ = './faster-rcnn_r50_fpn_gn-ws-all_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://jhu/resnet101_gn_ws'))) diff --git a/mmdetection/configs/gn+ws/faster-rcnn_r50_fpn_gn-ws-all_1x_coco.py b/mmdetection/configs/gn+ws/faster-rcnn_r50_fpn_gn-ws-all_1x_coco.py new file mode 100644 index 00000000..1a044c99 --- /dev/null +++ b/mmdetection/configs/gn+ws/faster-rcnn_r50_fpn_gn-ws-all_1x_coco.py @@ -0,0 +1,16 @@ +_base_ = '../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py' +conv_cfg = dict(type='ConvWS') +norm_cfg = dict(type='GN', num_groups=32, requires_grad=True) +model = dict( + backbone=dict( + conv_cfg=conv_cfg, + norm_cfg=norm_cfg, + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://jhu/resnet50_gn_ws')), + neck=dict(conv_cfg=conv_cfg, norm_cfg=norm_cfg), + roi_head=dict( + bbox_head=dict( + type='Shared4Conv1FCBBoxHead', + conv_out_channels=256, + conv_cfg=conv_cfg, + norm_cfg=norm_cfg))) diff --git a/mmdetection/configs/gn+ws/faster-rcnn_x101-32x4d_fpn_gn-ws-all_1x_coco.py b/mmdetection/configs/gn+ws/faster-rcnn_x101-32x4d_fpn_gn-ws-all_1x_coco.py new file mode 100644 index 00000000..b2a317d2 --- /dev/null +++ b/mmdetection/configs/gn+ws/faster-rcnn_x101-32x4d_fpn_gn-ws-all_1x_coco.py @@ -0,0 +1,18 @@ +_base_ = './faster-rcnn_r50_fpn_gn-ws-all_1x_coco.py' +conv_cfg = dict(type='ConvWS') +norm_cfg = dict(type='GN', num_groups=32, requires_grad=True) +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + style='pytorch', + conv_cfg=conv_cfg, + norm_cfg=norm_cfg, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://jhu/resnext101_32x4d_gn_ws'))) diff --git a/mmdetection/configs/gn+ws/faster-rcnn_x50-32x4d_fpn_gn-ws-all_1x_coco.py b/mmdetection/configs/gn+ws/faster-rcnn_x50-32x4d_fpn_gn-ws-all_1x_coco.py new file mode 100644 index 00000000..dd75a2c0 --- /dev/null +++ b/mmdetection/configs/gn+ws/faster-rcnn_x50-32x4d_fpn_gn-ws-all_1x_coco.py @@ -0,0 +1,18 @@ +_base_ = './faster-rcnn_r50_fpn_gn-ws-all_1x_coco.py' +conv_cfg = dict(type='ConvWS') +norm_cfg = dict(type='GN', num_groups=32, requires_grad=True) +model = dict( + backbone=dict( + type='ResNeXt', + depth=50, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + style='pytorch', + conv_cfg=conv_cfg, + norm_cfg=norm_cfg, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://jhu/resnext50_32x4d_gn_ws'))) diff --git a/mmdetection/configs/gn+ws/mask-rcnn_r101_fpn_gn-ws-all_20-23-24e_coco.py b/mmdetection/configs/gn+ws/mask-rcnn_r101_fpn_gn-ws-all_20-23-24e_coco.py new file mode 100644 index 00000000..1815e3f8 --- /dev/null +++ b/mmdetection/configs/gn+ws/mask-rcnn_r101_fpn_gn-ws-all_20-23-24e_coco.py @@ -0,0 +1,17 @@ +_base_ = './mask-rcnn_r101_fpn_gn-ws-all_2x_coco.py' +# learning policy +max_epochs = 24 +train_cfg = dict(max_epochs=max_epochs) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[20, 23], + gamma=0.1) +] diff --git a/mmdetection/configs/gn+ws/mask-rcnn_r101_fpn_gn-ws-all_2x_coco.py b/mmdetection/configs/gn+ws/mask-rcnn_r101_fpn_gn-ws-all_2x_coco.py new file mode 100644 index 00000000..5de37dee --- /dev/null +++ b/mmdetection/configs/gn+ws/mask-rcnn_r101_fpn_gn-ws-all_2x_coco.py @@ -0,0 +1,6 @@ +_base_ = './mask-rcnn_r50_fpn_gn-ws-all_2x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://jhu/resnet101_gn_ws'))) diff --git a/mmdetection/configs/gn+ws/mask-rcnn_r50_fpn_gn-ws-all_20-23-24e_coco.py b/mmdetection/configs/gn+ws/mask-rcnn_r50_fpn_gn-ws-all_20-23-24e_coco.py new file mode 100644 index 00000000..287c6520 --- /dev/null +++ b/mmdetection/configs/gn+ws/mask-rcnn_r50_fpn_gn-ws-all_20-23-24e_coco.py @@ -0,0 +1,17 @@ +_base_ = './mask-rcnn_r50_fpn_gn-ws-all_2x_coco.py' +# learning policy +max_epochs = 24 +train_cfg = dict(max_epochs=max_epochs) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[20, 23], + gamma=0.1) +] diff --git a/mmdetection/configs/gn+ws/mask-rcnn_r50_fpn_gn-ws-all_2x_coco.py b/mmdetection/configs/gn+ws/mask-rcnn_r50_fpn_gn-ws-all_2x_coco.py new file mode 100644 index 00000000..ed8b1b73 --- /dev/null +++ b/mmdetection/configs/gn+ws/mask-rcnn_r50_fpn_gn-ws-all_2x_coco.py @@ -0,0 +1,33 @@ +_base_ = '../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py' +conv_cfg = dict(type='ConvWS') +norm_cfg = dict(type='GN', num_groups=32, requires_grad=True) +model = dict( + backbone=dict( + conv_cfg=conv_cfg, + norm_cfg=norm_cfg, + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://jhu/resnet50_gn_ws')), + neck=dict(conv_cfg=conv_cfg, norm_cfg=norm_cfg), + roi_head=dict( + bbox_head=dict( + type='Shared4Conv1FCBBoxHead', + conv_out_channels=256, + conv_cfg=conv_cfg, + norm_cfg=norm_cfg), + mask_head=dict(conv_cfg=conv_cfg, norm_cfg=norm_cfg))) +# learning policy +max_epochs = 24 +train_cfg = dict(max_epochs=max_epochs) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/gn+ws/mask-rcnn_x101-32x4d_fpn_gn-ws-all_20-23-24e_coco.py b/mmdetection/configs/gn+ws/mask-rcnn_x101-32x4d_fpn_gn-ws-all_20-23-24e_coco.py new file mode 100644 index 00000000..8ce91935 --- /dev/null +++ b/mmdetection/configs/gn+ws/mask-rcnn_x101-32x4d_fpn_gn-ws-all_20-23-24e_coco.py @@ -0,0 +1,17 @@ +_base_ = './mask-rcnn_x101-32x4d_fpn_gn-ws-all_2x_coco.py' +# learning policy +max_epochs = 24 +train_cfg = dict(max_epochs=max_epochs) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[20, 23], + gamma=0.1) +] diff --git a/mmdetection/configs/gn+ws/mask-rcnn_x101-32x4d_fpn_gn-ws-all_2x_coco.py b/mmdetection/configs/gn+ws/mask-rcnn_x101-32x4d_fpn_gn-ws-all_2x_coco.py new file mode 100644 index 00000000..bcfc371e --- /dev/null +++ b/mmdetection/configs/gn+ws/mask-rcnn_x101-32x4d_fpn_gn-ws-all_2x_coco.py @@ -0,0 +1,19 @@ +_base_ = './mask-rcnn_r50_fpn_gn-ws-all_2x_coco.py' +# model settings +conv_cfg = dict(type='ConvWS') +norm_cfg = dict(type='GN', num_groups=32, requires_grad=True) +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + style='pytorch', + conv_cfg=conv_cfg, + norm_cfg=norm_cfg, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://jhu/resnext101_32x4d_gn_ws'))) diff --git a/mmdetection/configs/gn+ws/mask-rcnn_x50-32x4d_fpn_gn-ws-all_20-23-24e_coco.py b/mmdetection/configs/gn+ws/mask-rcnn_x50-32x4d_fpn_gn-ws-all_20-23-24e_coco.py new file mode 100644 index 00000000..af9ea5ab --- /dev/null +++ b/mmdetection/configs/gn+ws/mask-rcnn_x50-32x4d_fpn_gn-ws-all_20-23-24e_coco.py @@ -0,0 +1,17 @@ +_base_ = './mask-rcnn_x50-32x4d_fpn_gn-ws-all_2x_coco.py' +# learning policy +max_epochs = 24 +train_cfg = dict(max_epochs=max_epochs) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[20, 23], + gamma=0.1) +] diff --git a/mmdetection/configs/gn+ws/mask-rcnn_x50-32x4d_fpn_gn-ws-all_2x_coco.py b/mmdetection/configs/gn+ws/mask-rcnn_x50-32x4d_fpn_gn-ws-all_2x_coco.py new file mode 100644 index 00000000..ab2b1404 --- /dev/null +++ b/mmdetection/configs/gn+ws/mask-rcnn_x50-32x4d_fpn_gn-ws-all_2x_coco.py @@ -0,0 +1,19 @@ +_base_ = './mask-rcnn_r50_fpn_gn-ws-all_2x_coco.py' +# model settings +conv_cfg = dict(type='ConvWS') +norm_cfg = dict(type='GN', num_groups=32, requires_grad=True) +model = dict( + backbone=dict( + type='ResNeXt', + depth=50, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + style='pytorch', + conv_cfg=conv_cfg, + norm_cfg=norm_cfg, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://jhu/resnext50_32x4d_gn_ws'))) diff --git a/mmdetection/configs/gn+ws/metafile.yml b/mmdetection/configs/gn+ws/metafile.yml new file mode 100644 index 00000000..89b91072 --- /dev/null +++ b/mmdetection/configs/gn+ws/metafile.yml @@ -0,0 +1,263 @@ +Collections: + - Name: Weight Standardization + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - Group Normalization + - Weight Standardization + Paper: + URL: https://arxiv.org/abs/1903.10520 + Title: 'Weight Standardization' + README: configs/gn+ws/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/configs/gn%2Bws/mask-rcnn_r50_fpn_gn-ws-all_2x_coco.py + Version: v2.0.0 + +Models: + - Name: faster-rcnn_r50_fpn_gn_ws-all_1x_coco + In Collection: Weight Standardization + Config: configs/gn%2Bws/faster-rcnn_r50_fpn_gn-ws-all_1x_coco.py + Metadata: + Training Memory (GB): 5.9 + inference time (ms/im): + - value: 85.47 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/faster_rcnn_r50_fpn_gn_ws-all_1x_coco/faster_rcnn_r50_fpn_gn_ws-all_1x_coco_20200130-613d9fe2.pth + + - Name: faster-rcnn_r101_fpn_gn-ws-all_1x_coco + In Collection: Weight Standardization + Config: configs/gn%2Bws/faster-rcnn_r101_fpn_gn-ws-all_1x_coco.py + Metadata: + Training Memory (GB): 8.9 + inference time (ms/im): + - value: 111.11 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/faster_rcnn_r101_fpn_gn_ws-all_1x_coco/faster_rcnn_r101_fpn_gn_ws-all_1x_coco_20200205-a93b0d75.pth + + - Name: faster-rcnn_x50-32x4d_fpn_gn-ws-all_1x_coco + In Collection: Weight Standardization + Config: configs/gn%2Bws/faster-rcnn_x50-32x4d_fpn_gn-ws-all_1x_coco.py + Metadata: + Training Memory (GB): 7.0 + inference time (ms/im): + - value: 97.09 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/faster_rcnn_x50_32x4d_fpn_gn_ws-all_1x_coco/faster_rcnn_x50_32x4d_fpn_gn_ws-all_1x_coco_20200203-839c5d9d.pth + + - Name: faster-rcnn_x101-32x4d_fpn_gn-ws-all_1x_coco + In Collection: Weight Standardization + Config: configs/gn%2Bws/faster-rcnn_x101-32x4d_fpn_gn-ws-all_1x_coco.py + Metadata: + Training Memory (GB): 10.8 + inference time (ms/im): + - value: 131.58 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/faster_rcnn_x101_32x4d_fpn_gn_ws-all_1x_coco/faster_rcnn_x101_32x4d_fpn_gn_ws-all_1x_coco_20200212-27da1bc2.pth + + - Name: mask-rcnn_r50_fpn_gn_ws-all_2x_coco + In Collection: Weight Standardization + Config: configs/gn%2Bws/mask-rcnn_r50_fpn_gn-ws-all_2x_coco.py + Metadata: + Training Memory (GB): 7.3 + inference time (ms/im): + - value: 95.24 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.6 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/mask_rcnn_r50_fpn_gn_ws-all_2x_coco/mask_rcnn_r50_fpn_gn_ws-all_2x_coco_20200226-16acb762.pth + + - Name: mask-rcnn_r101_fpn_gn-ws-all_2x_coco + In Collection: Weight Standardization + Config: configs/gn%2Bws/mask-rcnn_r101_fpn_gn-ws-all_2x_coco.py + Metadata: + Training Memory (GB): 10.3 + inference time (ms/im): + - value: 116.28 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.0 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/mask_rcnn_r101_fpn_gn_ws-all_2x_coco/mask_rcnn_r101_fpn_gn_ws-all_2x_coco_20200212-ea357cd9.pth + + - Name: mask-rcnn_x50-32x4d_fpn_gn-ws-all_2x_coco + In Collection: Weight Standardization + Config: configs/gn%2Bws/mask-rcnn_x50-32x4d_fpn_gn-ws-all_2x_coco.py + Metadata: + Training Memory (GB): 8.4 + inference time (ms/im): + - value: 107.53 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.1 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/mask_rcnn_x50_32x4d_fpn_gn_ws-all_2x_coco/mask_rcnn_x50_32x4d_fpn_gn_ws-all_2x_coco_20200216-649fdb6f.pth + + - Name: mask-rcnn_x101-32x4d_fpn_gn-ws-all_2x_coco + In Collection: Weight Standardization + Config: configs/gn%2Bws/mask-rcnn_x101-32x4d_fpn_gn-ws-all_2x_coco.py + Metadata: + Training Memory (GB): 12.2 + inference time (ms/im): + - value: 140.85 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.1 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/mask_rcnn_x101_32x4d_fpn_gn_ws-all_2x_coco/mask_rcnn_x101_32x4d_fpn_gn_ws-all_2x_coco_20200319-33fb95b5.pth + + - Name: mask-rcnn_r50_fpn_gn_ws-all_20_23_24e_coco + In Collection: Weight Standardization + Config: configs/gn%2Bws/mask-rcnn_r50_fpn_gn-ws-all_20-23-24e_coco.py + Metadata: + Training Memory (GB): 7.3 + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.1 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/mask_rcnn_r50_fpn_gn_ws-all_20_23_24e_coco/mask_rcnn_r50_fpn_gn_ws-all_20_23_24e_coco_20200213-487d1283.pth + + - Name: mask-rcnn_r101_fpn_gn-ws-all_20-23-24e_coco + In Collection: Weight Standardization + Config: configs/gn%2Bws/mask-rcnn_r101_fpn_gn-ws-all_20-23-24e_coco.py + Metadata: + Training Memory (GB): 10.3 + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.1 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/mask_rcnn_r101_fpn_gn_ws-all_20_23_24e_coco/mask_rcnn_r101_fpn_gn_ws-all_20_23_24e_coco_20200213-57b5a50f.pth + + - Name: mask-rcnn_x50-32x4d_fpn_gn-ws-all_20-23-24e_coco + In Collection: Weight Standardization + Config: configs/gn%2Bws/mask-rcnn_x50-32x4d_fpn_gn-ws-all_20-23-24e_coco.py + Metadata: + Training Memory (GB): 8.4 + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.1 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/mask_rcnn_x50_32x4d_fpn_gn_ws-all_20_23_24e_coco/mask_rcnn_x50_32x4d_fpn_gn_ws-all_20_23_24e_coco_20200226-969bcb2c.pth + + - Name: mask-rcnn_x101-32x4d_fpn_gn-ws-all_20-23-24e_coco + In Collection: Weight Standardization + Config: configs/gn%2Bws/mask-rcnn_x101-32x4d_fpn_gn-ws-all_20-23-24e_coco.py + Metadata: + Training Memory (GB): 12.2 + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.7 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gn%2Bws/mask_rcnn_x101_32x4d_fpn_gn_ws-all_20_23_24e_coco/mask_rcnn_x101_32x4d_fpn_gn_ws-all_20_23_24e_coco_20200316-e6cd35ef.pth diff --git a/mmdetection/configs/gn/README.md b/mmdetection/configs/gn/README.md new file mode 100644 index 00000000..1bc8192f --- /dev/null +++ b/mmdetection/configs/gn/README.md @@ -0,0 +1,41 @@ +# GN + +> [Group Normalization](https://arxiv.org/abs/1803.08494) + + + +## Abstract + +Batch Normalization (BN) is a milestone technique in the development of deep learning, enabling various networks to train. However, normalizing along the batch dimension introduces problems --- BN's error increases rapidly when the batch size becomes smaller, caused by inaccurate batch statistics estimation. This limits BN's usage for training larger models and transferring features to computer vision tasks including detection, segmentation, and video, which require small batches constrained by memory consumption. In this paper, we present Group Normalization (GN) as a simple alternative to BN. GN divides the channels into groups and computes within each group the mean and variance for normalization. GN's computation is independent of batch sizes, and its accuracy is stable in a wide range of batch sizes. On ResNet-50 trained in ImageNet, GN has 10.6% lower error than its BN counterpart when using a batch size of 2; when using typical batch sizes, GN is comparably good with BN and outperforms other normalization variants. Moreover, GN can be naturally transferred from pre-training to fine-tuning. GN can outperform its BN-based counterparts for object detection and segmentation in COCO, and for video classification in Kinetics, showing that GN can effectively replace the powerful BN in a variety of tasks. GN can be easily implemented by a few lines of code in modern libraries. + +
    + +
    + +## Results and Models + +| Backbone | model | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :-----------: | :--------: | :-----: | :------: | :------------: | :----: | :-----: | :-----------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN (d) | Mask R-CNN | 2x | 7.1 | 11.0 | 40.2 | 36.4 | [config](./mask-rcnn_r50_fpn_gn-all_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r50_fpn_gn-all_2x_coco/mask_rcnn_r50_fpn_gn-all_2x_coco_20200206-8eee02a6.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r50_fpn_gn-all_2x_coco/mask_rcnn_r50_fpn_gn-all_2x_coco_20200206_050355.log.json) | +| R-50-FPN (d) | Mask R-CNN | 3x | 7.1 | - | 40.5 | 36.7 | [config](./mask-rcnn_r50_fpn_gn-all_3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r50_fpn_gn-all_3x_coco/mask_rcnn_r50_fpn_gn-all_3x_coco_20200214-8b23b1e5.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r50_fpn_gn-all_3x_coco/mask_rcnn_r50_fpn_gn-all_3x_coco_20200214_063512.log.json) | +| R-101-FPN (d) | Mask R-CNN | 2x | 9.9 | 9.0 | 41.9 | 37.6 | [config](./mask-rcnn_r101_fpn_gn-all_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r101_fpn_gn-all_2x_coco/mask_rcnn_r101_fpn_gn-all_2x_coco_20200205-d96b1b50.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r101_fpn_gn-all_2x_coco/mask_rcnn_r101_fpn_gn-all_2x_coco_20200205_234402.log.json) | +| R-101-FPN (d) | Mask R-CNN | 3x | 9.9 | | 42.1 | 38.0 | [config](./mask-rcnn_r101_fpn_gn-all_3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r101_fpn_gn-all_3x_coco/mask_rcnn_r101_fpn_gn-all_3x_coco_20200513_181609-0df864f4.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r101_fpn_gn-all_3x_coco/mask_rcnn_r101_fpn_gn-all_3x_coco_20200513_181609.log.json) | +| R-50-FPN (c) | Mask R-CNN | 2x | 7.1 | 10.9 | 40.0 | 36.1 | [config](./mask-rcnn_r50-contrib_fpn_gn-all_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r50_fpn_gn-all_contrib_2x_coco/mask_rcnn_r50_fpn_gn-all_contrib_2x_coco_20200207-20d3e849.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r50_fpn_gn-all_contrib_2x_coco/mask_rcnn_r50_fpn_gn-all_contrib_2x_coco_20200207_225832.log.json) | +| R-50-FPN (c) | Mask R-CNN | 3x | 7.1 | - | 40.1 | 36.2 | [config](./mask-rcnn_r50-contrib_fpn_gn-all_3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r50_fpn_gn-all_contrib_3x_coco/mask_rcnn_r50_fpn_gn-all_contrib_3x_coco_20200225-542aefbc.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r50_fpn_gn-all_contrib_3x_coco/mask_rcnn_r50_fpn_gn-all_contrib_3x_coco_20200225_235135.log.json) | + +**Notes:** + +- (d) means pretrained model converted from Detectron, and (c) means the contributed model pretrained by [@thangvubk](https://github.com/thangvubk). +- The `3x` schedule is epoch \[28, 34, 36\]. +- **Memory, Train/Inf time is outdated.** + +## Citation + +```latex +@inproceedings{wu2018group, + title={Group Normalization}, + author={Wu, Yuxin and He, Kaiming}, + booktitle={Proceedings of the European Conference on Computer Vision (ECCV)}, + year={2018} +} +``` diff --git a/mmdetection/configs/gn/mask-rcnn_r101_fpn_gn-all_2x_coco.py b/mmdetection/configs/gn/mask-rcnn_r101_fpn_gn-all_2x_coco.py new file mode 100644 index 00000000..54f57d8d --- /dev/null +++ b/mmdetection/configs/gn/mask-rcnn_r101_fpn_gn-all_2x_coco.py @@ -0,0 +1,7 @@ +_base_ = './mask-rcnn_r50_fpn_gn-all_2x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron/resnet101_gn'))) diff --git a/mmdetection/configs/gn/mask-rcnn_r101_fpn_gn-all_3x_coco.py b/mmdetection/configs/gn/mask-rcnn_r101_fpn_gn-all_3x_coco.py new file mode 100644 index 00000000..a94e063e --- /dev/null +++ b/mmdetection/configs/gn/mask-rcnn_r101_fpn_gn-all_3x_coco.py @@ -0,0 +1,18 @@ +_base_ = './mask-rcnn_r101_fpn_gn-all_2x_coco.py' + +# learning policy +max_epochs = 36 +train_cfg = dict(max_epochs=max_epochs) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[28, 34], + gamma=0.1) +] diff --git a/mmdetection/configs/gn/mask-rcnn_r50-contrib_fpn_gn-all_2x_coco.py b/mmdetection/configs/gn/mask-rcnn_r50-contrib_fpn_gn-all_2x_coco.py new file mode 100644 index 00000000..5515ec14 --- /dev/null +++ b/mmdetection/configs/gn/mask-rcnn_r50-contrib_fpn_gn-all_2x_coco.py @@ -0,0 +1,31 @@ +_base_ = '../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py' +norm_cfg = dict(type='GN', num_groups=32, requires_grad=True) +model = dict( + backbone=dict( + norm_cfg=norm_cfg, + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://contrib/resnet50_gn')), + neck=dict(norm_cfg=norm_cfg), + roi_head=dict( + bbox_head=dict( + type='Shared4Conv1FCBBoxHead', + conv_out_channels=256, + norm_cfg=norm_cfg), + mask_head=dict(norm_cfg=norm_cfg))) + +# learning policy +max_epochs = 24 +train_cfg = dict(max_epochs=max_epochs) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/gn/mask-rcnn_r50-contrib_fpn_gn-all_3x_coco.py b/mmdetection/configs/gn/mask-rcnn_r50-contrib_fpn_gn-all_3x_coco.py new file mode 100644 index 00000000..e6f7a97e --- /dev/null +++ b/mmdetection/configs/gn/mask-rcnn_r50-contrib_fpn_gn-all_3x_coco.py @@ -0,0 +1,18 @@ +_base_ = './mask-rcnn_r50-contrib_fpn_gn-all_2x_coco.py' + +# learning policy +max_epochs = 36 +train_cfg = dict(max_epochs=max_epochs) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[28, 34], + gamma=0.1) +] diff --git a/mmdetection/configs/gn/mask-rcnn_r50_fpn_gn-all_2x_coco.py b/mmdetection/configs/gn/mask-rcnn_r50_fpn_gn-all_2x_coco.py new file mode 100644 index 00000000..1313b22e --- /dev/null +++ b/mmdetection/configs/gn/mask-rcnn_r50_fpn_gn-all_2x_coco.py @@ -0,0 +1,36 @@ +_base_ = '../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py' +norm_cfg = dict(type='GN', num_groups=32, requires_grad=True) +model = dict( + data_preprocessor=dict( + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False), + backbone=dict( + norm_cfg=norm_cfg, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron/resnet50_gn')), + neck=dict(norm_cfg=norm_cfg), + roi_head=dict( + bbox_head=dict( + type='Shared4Conv1FCBBoxHead', + conv_out_channels=256, + norm_cfg=norm_cfg), + mask_head=dict(norm_cfg=norm_cfg))) + +# learning policy +max_epochs = 24 +train_cfg = dict(max_epochs=max_epochs) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/gn/mask-rcnn_r50_fpn_gn-all_3x_coco.py b/mmdetection/configs/gn/mask-rcnn_r50_fpn_gn-all_3x_coco.py new file mode 100644 index 00000000..e425de95 --- /dev/null +++ b/mmdetection/configs/gn/mask-rcnn_r50_fpn_gn-all_3x_coco.py @@ -0,0 +1,18 @@ +_base_ = './mask-rcnn_r50_fpn_gn-all_2x_coco.py' + +# learning policy +max_epochs = 36 +train_cfg = dict(max_epochs=max_epochs) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[28, 34], + gamma=0.1) +] diff --git a/mmdetection/configs/gn/metafile.yml b/mmdetection/configs/gn/metafile.yml new file mode 100644 index 00000000..9781dc93 --- /dev/null +++ b/mmdetection/configs/gn/metafile.yml @@ -0,0 +1,162 @@ +Collections: + - Name: Group Normalization + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - Group Normalization + Paper: + URL: https://arxiv.org/abs/1803.08494 + Title: 'Group Normalization' + README: configs/gn/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/configs/gn/mask-rcnn_r50_fpn_gn-all_2x_coco.py + Version: v2.0.0 + +Models: + - Name: mask-rcnn_r50_fpn_gn-all_2x_coco + In Collection: Group Normalization + Config: configs/gn/mask-rcnn_r50_fpn_gn-all_2x_coco.py + Metadata: + Training Memory (GB): 7.1 + inference time (ms/im): + - value: 90.91 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.2 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r50_fpn_gn-all_2x_coco/mask_rcnn_r50_fpn_gn-all_2x_coco_20200206-8eee02a6.pth + + - Name: mask-rcnn_r50_fpn_gn-all_3x_coco + In Collection: Group Normalization + Config: configs/gn/mask-rcnn_r50_fpn_gn-all_3x_coco.py + Metadata: + Training Memory (GB): 7.1 + inference time (ms/im): + - value: 90.91 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.5 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r50_fpn_gn-all_3x_coco/mask_rcnn_r50_fpn_gn-all_3x_coco_20200214-8b23b1e5.pth + + - Name: mask-rcnn_r101_fpn_gn-all_2x_coco + In Collection: Group Normalization + Config: configs/gn/mask-rcnn_r101_fpn_gn-all_2x_coco.py + Metadata: + Training Memory (GB): 9.9 + inference time (ms/im): + - value: 111.11 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.9 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r101_fpn_gn-all_2x_coco/mask_rcnn_r101_fpn_gn-all_2x_coco_20200205-d96b1b50.pth + + - Name: mask-rcnn_r101_fpn_gn-all_3x_coco + In Collection: Group Normalization + Config: configs/gn/mask-rcnn_r101_fpn_gn-all_3x_coco.py + Metadata: + Training Memory (GB): 9.9 + inference time (ms/im): + - value: 111.11 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.1 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r101_fpn_gn-all_3x_coco/mask_rcnn_r101_fpn_gn-all_3x_coco_20200513_181609-0df864f4.pth + + - Name: mask-rcnn_r50_fpn_gn-all_contrib_2x_coco + In Collection: Group Normalization + Config: configs/gn/mask-rcnn_r50-contrib_fpn_gn-all_2x_coco.py + Metadata: + Training Memory (GB): 7.1 + inference time (ms/im): + - value: 91.74 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.0 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r50_fpn_gn-all_contrib_2x_coco/mask_rcnn_r50_fpn_gn-all_contrib_2x_coco_20200207-20d3e849.pth + + - Name: mask-rcnn_r50_fpn_gn-all_contrib_3x_coco + In Collection: Group Normalization + Config: configs/gn/mask-rcnn_r50-contrib_fpn_gn-all_3x_coco.py + Metadata: + Training Memory (GB): 7.1 + inference time (ms/im): + - value: 91.74 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.1 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r50_fpn_gn-all_contrib_3x_coco/mask_rcnn_r50_fpn_gn-all_contrib_3x_coco_20200225-542aefbc.pth diff --git a/mmdetection/configs/grid_rcnn/README.md b/mmdetection/configs/grid_rcnn/README.md new file mode 100644 index 00000000..3de810af --- /dev/null +++ b/mmdetection/configs/grid_rcnn/README.md @@ -0,0 +1,47 @@ +# Grid R-CNN + +> [Grid R-CNN](https://arxiv.org/abs/1811.12030) + + + +## Abstract + +This paper proposes a novel object detection framework named Grid R-CNN, which adopts a grid guided localization mechanism for accurate object detection. Different from the traditional regression based methods, the Grid R-CNN captures the spatial information explicitly and enjoys the position sensitive property of fully convolutional architecture. Instead of using only two independent points, we design a multi-point supervision formulation to encode more clues in order to reduce the impact of inaccurate prediction of specific points. To take the full advantage of the correlation of points in a grid, we propose a two-stage information fusion strategy to fuse feature maps of neighbor grid points. The grid guided localization approach is easy to be extended to different state-of-the-art detection frameworks. Grid R-CNN leads to high quality object localization, and experiments demonstrate that it achieves a 4.1% AP gain at IoU=0.8 and a 10.0% AP gain at IoU=0.9 on COCO benchmark compared to Faster R-CNN with Res50 backbone and FPN architecture. + +Grid R-CNN is a well-performed objection detection framework. It transforms the traditional box offset regression problem into a grid point estimation problem. With the guidance of the grid points, it can obtain high-quality localization results. However, the speed of Grid R-CNN is not so satisfactory. In this technical report we present Grid R-CNN Plus, a better and faster version of Grid R-CNN. We have made several updates that significantly speed up the framework and simultaneously improve the accuracy. On COCO dataset, the Res50-FPN based Grid R-CNN Plus detector achieves an mAP of 40.4%, outperforming the baseline on the same model by 3.0 points with similar inference time. + +
    + +
    + +## Results and Models + +| Backbone | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :---------: | :-----: | :------: | :------------: | :----: | :-----------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | 2x | 5.1 | 15.0 | 40.4 | [config](./grid-rcnn_r50_fpn_gn-head_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/grid_rcnn/grid_rcnn_r50_fpn_gn-head_2x_coco/grid_rcnn_r50_fpn_gn-head_2x_coco_20200130-6cca8223.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/grid_rcnn/grid_rcnn_r50_fpn_gn-head_2x_coco/grid_rcnn_r50_fpn_gn-head_2x_coco_20200130_221140.log.json) | +| R-101 | 2x | 7.0 | 12.6 | 41.5 | [config](./grid-rcnn_r101_fpn_gn-head_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/grid_rcnn/grid_rcnn_r101_fpn_gn-head_2x_coco/grid_rcnn_r101_fpn_gn-head_2x_coco_20200309-d6eca030.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/grid_rcnn/grid_rcnn_r101_fpn_gn-head_2x_coco/grid_rcnn_r101_fpn_gn-head_2x_coco_20200309_164224.log.json) | +| X-101-32x4d | 2x | 8.3 | 10.8 | 42.9 | [config](./grid-rcnn_x101-32x4d_fpn_gn-head_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/grid_rcnn/grid_rcnn_x101_32x4d_fpn_gn-head_2x_coco/grid_rcnn_x101_32x4d_fpn_gn-head_2x_coco_20200130-d8f0e3ff.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/grid_rcnn/grid_rcnn_x101_32x4d_fpn_gn-head_2x_coco/grid_rcnn_x101_32x4d_fpn_gn-head_2x_coco_20200130_215413.log.json) | +| X-101-64x4d | 2x | 11.3 | 7.7 | 43.0 | [config](./grid-rcnn_x101-64x4d_fpn_gn-head_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/grid_rcnn/grid_rcnn_x101_64x4d_fpn_gn-head_2x_coco/grid_rcnn_x101_64x4d_fpn_gn-head_2x_coco_20200204-ec76a754.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/grid_rcnn/grid_rcnn_x101_64x4d_fpn_gn-head_2x_coco/grid_rcnn_x101_64x4d_fpn_gn-head_2x_coco_20200204_080641.log.json) | + +**Notes:** + +- All models are trained with 8 GPUs instead of 32 GPUs in the original paper. +- The warming up lasts for 1 epoch and `2x` here indicates 25 epochs. + +## Citation + +```latex +@inproceedings{lu2019grid, + title={Grid r-cnn}, + author={Lu, Xin and Li, Buyu and Yue, Yuxin and Li, Quanquan and Yan, Junjie}, + booktitle={Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition}, + year={2019} +} + +@article{lu2019grid, + title={Grid R-CNN Plus: Faster and Better}, + author={Lu, Xin and Li, Buyu and Yue, Yuxin and Li, Quanquan and Yan, Junjie}, + journal={arXiv preprint arXiv:1906.05688}, + year={2019} +} +``` diff --git a/mmdetection/configs/grid_rcnn/grid-rcnn_r101_fpn_gn-head_2x_coco.py b/mmdetection/configs/grid_rcnn/grid-rcnn_r101_fpn_gn-head_2x_coco.py new file mode 100644 index 00000000..46d41ed4 --- /dev/null +++ b/mmdetection/configs/grid_rcnn/grid-rcnn_r101_fpn_gn-head_2x_coco.py @@ -0,0 +1,7 @@ +_base_ = './grid-rcnn_r50_fpn_gn-head_2x_coco.py' + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/grid_rcnn/grid-rcnn_r50_fpn_gn-head_1x_coco.py b/mmdetection/configs/grid_rcnn/grid-rcnn_r50_fpn_gn-head_1x_coco.py new file mode 100644 index 00000000..35828063 --- /dev/null +++ b/mmdetection/configs/grid_rcnn/grid-rcnn_r50_fpn_gn-head_1x_coco.py @@ -0,0 +1,19 @@ +_base_ = './grid-rcnn_r50_fpn_gn-head_2x_coco.py' + +# training schedule +max_epochs = 12 +train_cfg = dict(max_epochs=max_epochs) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.0001, by_epoch=False, begin=0, + end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] diff --git a/mmdetection/configs/grid_rcnn/grid-rcnn_r50_fpn_gn-head_2x_coco.py b/mmdetection/configs/grid_rcnn/grid-rcnn_r50_fpn_gn-head_2x_coco.py new file mode 100644 index 00000000..228fca23 --- /dev/null +++ b/mmdetection/configs/grid_rcnn/grid-rcnn_r50_fpn_gn-head_2x_coco.py @@ -0,0 +1,160 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', '../_base_/default_runtime.py' +] +# model settings +model = dict( + type='GridRCNN', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + num_outs=5), + rpn_head=dict( + type='RPNHead', + in_channels=256, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + scales=[8], + ratios=[0.5, 1.0, 2.0], + strides=[4, 8, 16, 32, 64]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[1.0, 1.0, 1.0, 1.0]), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=1.0)), + roi_head=dict( + type='GridRoIHead', + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + bbox_head=dict( + type='Shared2FCBBoxHead', + with_reg=False, + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=False), + grid_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + grid_head=dict( + type='GridHead', + grid_points=9, + num_convs=8, + in_channels=256, + point_feat_channels=64, + norm_cfg=dict(type='GN', num_groups=36), + loss_grid=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=15))), + # model training and testing settings + train_cfg=dict( + rpn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.3, + min_pos_iou=0.3, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=0, + pos_weight=-1, + debug=False), + rpn_proposal=dict( + nms_pre=2000, + max_per_img=2000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0.5, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + pos_radius=1, + pos_weight=-1, + max_num_grid=192, + debug=False)), + test_cfg=dict( + rpn=dict( + nms_pre=1000, + max_per_img=1000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=dict( + score_thr=0.03, + nms=dict(type='nms', iou_threshold=0.3), + max_per_img=100))) +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)) + +# training schedule +max_epochs = 25 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0 / 80, + by_epoch=False, + begin=0, + end=3665), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[17, 23], + gamma=0.1) +] + +# Default setting for scaling LR automatically +# - `enable` means enable scaling LR automatically +# or not by default. +# - `base_batch_size` = (8 GPUs) x (2 samples per GPU). +auto_scale_lr = dict(enable=False, base_batch_size=16) diff --git a/mmdetection/configs/grid_rcnn/grid-rcnn_x101-32x4d_fpn_gn-head_2x_coco.py b/mmdetection/configs/grid_rcnn/grid-rcnn_x101-32x4d_fpn_gn-head_2x_coco.py new file mode 100644 index 00000000..dddf157b --- /dev/null +++ b/mmdetection/configs/grid_rcnn/grid-rcnn_x101-32x4d_fpn_gn-head_2x_coco.py @@ -0,0 +1,13 @@ +_base_ = './grid-rcnn_r50_fpn_gn-head_2x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/grid_rcnn/grid-rcnn_x101-64x4d_fpn_gn-head_2x_coco.py b/mmdetection/configs/grid_rcnn/grid-rcnn_x101-64x4d_fpn_gn-head_2x_coco.py new file mode 100644 index 00000000..e4ff50f5 --- /dev/null +++ b/mmdetection/configs/grid_rcnn/grid-rcnn_x101-64x4d_fpn_gn-head_2x_coco.py @@ -0,0 +1,13 @@ +_base_ = './grid-rcnn_x101-32x4d_fpn_gn-head_2x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/grid_rcnn/metafile.yml b/mmdetection/configs/grid_rcnn/metafile.yml new file mode 100644 index 00000000..cee91e3b --- /dev/null +++ b/mmdetection/configs/grid_rcnn/metafile.yml @@ -0,0 +1,101 @@ +Collections: + - Name: Grid R-CNN + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RPN + - Dilated Convolution + - ResNet + - RoIAlign + Paper: + URL: https://arxiv.org/abs/1906.05688 + Title: 'Grid R-CNN' + README: configs/grid_rcnn/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/detectors/grid_rcnn.py#L6 + Version: v2.0.0 + +Models: + - Name: grid-rcnn_r50_fpn_gn-head_2x_coco + In Collection: Grid R-CNN + Config: configs/grid_rcnn/grid-rcnn_r50_fpn_gn-head_2x_coco.py + Metadata: + Training Memory (GB): 5.1 + inference time (ms/im): + - value: 66.67 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/grid_rcnn/grid_rcnn_r50_fpn_gn-head_2x_coco/grid_rcnn_r50_fpn_gn-head_2x_coco_20200130-6cca8223.pth + + - Name: grid-rcnn_r101_fpn_gn-head_2x_coco + In Collection: Grid R-CNN + Config: configs/grid_rcnn/grid-rcnn_r101_fpn_gn-head_2x_coco.py + Metadata: + Training Memory (GB): 7.0 + inference time (ms/im): + - value: 79.37 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/grid_rcnn/grid_rcnn_r101_fpn_gn-head_2x_coco/grid_rcnn_r101_fpn_gn-head_2x_coco_20200309-d6eca030.pth + + - Name: grid-rcnn_x101-32x4d_fpn_gn-head_2x_coco + In Collection: Grid R-CNN + Config: configs/grid_rcnn/grid-rcnn_x101-32x4d_fpn_gn-head_2x_coco.py + Metadata: + Training Memory (GB): 8.3 + inference time (ms/im): + - value: 92.59 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/grid_rcnn/grid_rcnn_x101_32x4d_fpn_gn-head_2x_coco/grid_rcnn_x101_32x4d_fpn_gn-head_2x_coco_20200130-d8f0e3ff.pth + + - Name: grid-rcnn_x101-64x4d_fpn_gn-head_2x_coco + In Collection: Grid R-CNN + Config: configs/grid_rcnn/grid-rcnn_x101-64x4d_fpn_gn-head_2x_coco.py + Metadata: + Training Memory (GB): 11.3 + inference time (ms/im): + - value: 129.87 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/grid_rcnn/grid_rcnn_x101_64x4d_fpn_gn-head_2x_coco/grid_rcnn_x101_64x4d_fpn_gn-head_2x_coco_20200204-ec76a754.pth diff --git a/mmdetection/configs/groie/README.md b/mmdetection/configs/groie/README.md new file mode 100644 index 00000000..9792df93 --- /dev/null +++ b/mmdetection/configs/groie/README.md @@ -0,0 +1,72 @@ +# GRoIE + +> [A novel Region of Interest Extraction Layer for Instance Segmentation](https://arxiv.org/abs/2004.13665) + + + +## Abstract + +Given the wide diffusion of deep neural network architectures for computer vision tasks, several new applications are nowadays more and more feasible. Among them, a particular attention has been recently given to instance segmentation, by exploiting the results achievable by two-stage networks (such as Mask R-CNN or Faster R-CNN), derived from R-CNN. In these complex architectures, a crucial role is played by the Region of Interest (RoI) extraction layer, devoted to extracting a coherent subset of features from a single Feature Pyramid Network (FPN) layer attached on top of a backbone. +This paper is motivated by the need to overcome the limitations of existing RoI extractors which select only one (the best) layer from FPN. Our intuition is that all the layers of FPN retain useful information. Therefore, the proposed layer (called Generic RoI Extractor - GRoIE) introduces non-local building blocks and attention mechanisms to boost the performance. +A comprehensive ablation study at component level is conducted to find the best set of algorithms and parameters for the GRoIE layer. Moreover, GRoIE can be integrated seamlessly with every two-stage architecture for both object detection and instance segmentation tasks. Therefore, the improvements brought about by the use of GRoIE in different state-of-the-art architectures are also evaluated. The proposed layer leads up to gain a 1.1% AP improvement on bounding box detection and 1.7% AP improvement on instance segmentation. + +
    + +
    + +## Introduction + +By Leonardo Rossi, Akbar Karimi and Andrea Prati from +[IMPLab](http://implab.ce.unipr.it/). + +We provide configs to reproduce the results in the paper for +"*A novel Region of Interest Extraction Layer for Instance Segmentation*" +on COCO object detection. + +This paper is motivated by the need to overcome to the limitations of existing +RoI extractors which select only one (the best) layer from FPN. + +Our intuition is that all the layers of FPN retain useful information. + +Therefore, the proposed layer (called Generic RoI Extractor - **GRoIE**) +introduces non-local building blocks and attention mechanisms to boost the +performance. + +## Results and Models + +The results on COCO 2017 minival (5k images) are shown in the below table. + +### Application of GRoIE to different architectures + +| Backbone | Method | Lr schd | box AP | mask AP | Config | Download | +| :-------: | :-------------: | :-----: | :----: | :-----: | :------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | Faster Original | 1x | 37.4 | | [config](../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_1x_coco_20200130_204655.log.json) | +| R-50-FPN | + GRoIE | 1x | 38.3 | | [config](./faste-rcnn_r50_fpn_groie_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/groie/faster_rcnn_r50_fpn_groie_1x_coco/faster_rcnn_r50_fpn_groie_1x_coco_20200604_211715-66ee9516.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/groie/faster_rcnn_r50_fpn_groie_1x_coco/faster_rcnn_r50_fpn_groie_1x_coco_20200604_211715.log.json) | +| R-50-FPN | Grid R-CNN | 1x | 39.1 | | [config](./grid-rcnn_r50_fpn_gn-head-groie_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/groie/grid_rcnn_r50_fpn_gn-head_groie_1x_coco/grid_rcnn_r50_fpn_gn-head_groie_1x_coco_20200605_202059-4b75d86f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/groie/grid_rcnn_r50_fpn_gn-head_groie_1x_coco/grid_rcnn_r50_fpn_gn-head_groie_1x_coco_20200605_202059.log.json) | +| R-50-FPN | + GRoIE | 1x | | | [config](./grid-rcnn_r50_fpn_gn-head-groie_1x_coco.py) | | +| R-50-FPN | Mask R-CNN | 1x | 38.2 | 34.7 | [config](../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_fpn_1x_coco/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_fpn_1x_coco/mask_rcnn_r50_fpn_1x_coco_20200205_050542.log.json) | +| R-50-FPN | + GRoIE | 1x | 39.0 | 36.0 | [config](./mask-rcnn_r50_fpn_groie_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/groie/mask_rcnn_r50_fpn_groie_1x_coco/mask_rcnn_r50_fpn_groie_1x_coco_20200604_211715-50d90c74.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/groie/mask_rcnn_r50_fpn_groie_1x_coco/mask_rcnn_r50_fpn_groie_1x_coco_20200604_211715.log.json) | +| R-50-FPN | GC-Net | 1x | 40.7 | 36.5 | [config](../gcnet/mask-rcnn_r50-syncbn-gcb-r4-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r50_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco/mask_rcnn_r50_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco_20200202-50b90e5c.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r50_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco/mask_rcnn_r50_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco_20200202_085547.log.json) | +| R-50-FPN | + GRoIE | 1x | 41.0 | 37.8 | [config](./mask-rcnn_r50_fpn_syncbn-r4-gcb-c3-c5-groie_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/groie/mask_rcnn_r50_fpn_syncbn-backbone_r4_gcb_c3-c5_groie_1x_coco/mask_rcnn_r50_fpn_syncbn-backbone_r4_gcb_c3-c5_groie_1x_coco_20200604_211715-42eb79e1.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/groie/mask_rcnn_r50_fpn_syncbn-backbone_r4_gcb_c3-c5_groie_1x_coco/mask_rcnn_r50_fpn_syncbn-backbone_r4_gcb_c3-c5_groie_1x_coco_20200604_211715-42eb79e1.pth) | +| R-101-FPN | GC-Net | 1x | 42.2 | 37.8 | [config](../gcnet/mask-rcnn_r101-syncbn-gcb-r4-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r101_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco/mask_rcnn_r101_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco_20200206-8407a3f0.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/gcnet/mask_rcnn_r101_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco/mask_rcnn_r101_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco_20200206_142508.log.json) | +| R-101-FPN | + GRoIE | 1x | 42.6 | 38.7 | [config](./mask-rcnn_r101_fpn_syncbn-r4-gcb_c3-c5-groie_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/groie/mask_rcnn_r101_fpn_syncbn-backbone_r4_gcb_c3-c5_groie_1x_coco/mask_rcnn_r101_fpn_syncbn-backbone_r4_gcb_c3-c5_groie_1x_coco_20200607_224507-8daae01c.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/groie/mask_rcnn_r101_fpn_syncbn-backbone_r4_gcb_c3-c5_groie_1x_coco/mask_rcnn_r101_fpn_syncbn-backbone_r4_gcb_c3-c5_groie_1x_coco_20200607_224507.log.json) | + +## Citation + +If you use this work or benchmark in your research, please cite this project. + +```latex +@inproceedings{rossi2021novel, + title={A novel region of interest extraction layer for instance segmentation}, + author={Rossi, Leonardo and Karimi, Akbar and Prati, Andrea}, + booktitle={2020 25th International Conference on Pattern Recognition (ICPR)}, + pages={2203--2209}, + year={2021}, + organization={IEEE} +} +``` + +## Contact + +The implementation of GRoIE is currently maintained by +[Leonardo Rossi](https://github.com/hachreak/). diff --git a/mmdetection/configs/groie/faste-rcnn_r50_fpn_groie_1x_coco.py b/mmdetection/configs/groie/faste-rcnn_r50_fpn_groie_1x_coco.py new file mode 100644 index 00000000..0fbe8a32 --- /dev/null +++ b/mmdetection/configs/groie/faste-rcnn_r50_fpn_groie_1x_coco.py @@ -0,0 +1,25 @@ +_base_ = '../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py' +# model settings +model = dict( + roi_head=dict( + bbox_roi_extractor=dict( + type='GenericRoIExtractor', + aggregation='sum', + roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=2), + out_channels=256, + featmap_strides=[4, 8, 16, 32], + pre_cfg=dict( + type='ConvModule', + in_channels=256, + out_channels=256, + kernel_size=5, + padding=2, + inplace=False, + ), + post_cfg=dict( + type='GeneralizedAttention', + in_channels=256, + spatial_range=-1, + num_heads=6, + attention_type='0100', + kv_stride=2)))) diff --git a/mmdetection/configs/groie/grid-rcnn_r50_fpn_gn-head-groie_1x_coco.py b/mmdetection/configs/groie/grid-rcnn_r50_fpn_gn-head-groie_1x_coco.py new file mode 100644 index 00000000..dadccb79 --- /dev/null +++ b/mmdetection/configs/groie/grid-rcnn_r50_fpn_gn-head-groie_1x_coco.py @@ -0,0 +1,45 @@ +_base_ = '../grid_rcnn/grid-rcnn_r50_fpn_gn-head_1x_coco.py' +# model settings +model = dict( + roi_head=dict( + bbox_roi_extractor=dict( + type='GenericRoIExtractor', + aggregation='sum', + roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=2), + out_channels=256, + featmap_strides=[4, 8, 16, 32], + pre_cfg=dict( + type='ConvModule', + in_channels=256, + out_channels=256, + kernel_size=5, + padding=2, + inplace=False, + ), + post_cfg=dict( + type='GeneralizedAttention', + in_channels=256, + spatial_range=-1, + num_heads=6, + attention_type='0100', + kv_stride=2)), + grid_roi_extractor=dict( + type='GenericRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=2), + out_channels=256, + featmap_strides=[4, 8, 16, 32], + pre_cfg=dict( + type='ConvModule', + in_channels=256, + out_channels=256, + kernel_size=5, + padding=2, + inplace=False, + ), + post_cfg=dict( + type='GeneralizedAttention', + in_channels=256, + spatial_range=-1, + num_heads=6, + attention_type='0100', + kv_stride=2)))) diff --git a/mmdetection/configs/groie/mask-rcnn_r101_fpn_syncbn-r4-gcb_c3-c5-groie_1x_coco.py b/mmdetection/configs/groie/mask-rcnn_r101_fpn_syncbn-r4-gcb_c3-c5-groie_1x_coco.py new file mode 100644 index 00000000..5699b428 --- /dev/null +++ b/mmdetection/configs/groie/mask-rcnn_r101_fpn_syncbn-r4-gcb_c3-c5-groie_1x_coco.py @@ -0,0 +1,45 @@ +_base_ = '../gcnet/mask-rcnn_r101-syncbn-gcb-r4-c3-c5_fpn_1x_coco.py' +# model settings +model = dict( + roi_head=dict( + bbox_roi_extractor=dict( + type='GenericRoIExtractor', + aggregation='sum', + roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=2), + out_channels=256, + featmap_strides=[4, 8, 16, 32], + pre_cfg=dict( + type='ConvModule', + in_channels=256, + out_channels=256, + kernel_size=5, + padding=2, + inplace=False, + ), + post_cfg=dict( + type='GeneralizedAttention', + in_channels=256, + spatial_range=-1, + num_heads=6, + attention_type='0100', + kv_stride=2)), + mask_roi_extractor=dict( + type='GenericRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=2), + out_channels=256, + featmap_strides=[4, 8, 16, 32], + pre_cfg=dict( + type='ConvModule', + in_channels=256, + out_channels=256, + kernel_size=5, + padding=2, + inplace=False, + ), + post_cfg=dict( + type='GeneralizedAttention', + in_channels=256, + spatial_range=-1, + num_heads=6, + attention_type='0100', + kv_stride=2)))) diff --git a/mmdetection/configs/groie/mask-rcnn_r50_fpn_groie_1x_coco.py b/mmdetection/configs/groie/mask-rcnn_r50_fpn_groie_1x_coco.py new file mode 100644 index 00000000..4c9521e2 --- /dev/null +++ b/mmdetection/configs/groie/mask-rcnn_r50_fpn_groie_1x_coco.py @@ -0,0 +1,45 @@ +_base_ = '../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py' +# model settings +model = dict( + roi_head=dict( + bbox_roi_extractor=dict( + type='GenericRoIExtractor', + aggregation='sum', + roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=2), + out_channels=256, + featmap_strides=[4, 8, 16, 32], + pre_cfg=dict( + type='ConvModule', + in_channels=256, + out_channels=256, + kernel_size=5, + padding=2, + inplace=False, + ), + post_cfg=dict( + type='GeneralizedAttention', + in_channels=256, + spatial_range=-1, + num_heads=6, + attention_type='0100', + kv_stride=2)), + mask_roi_extractor=dict( + type='GenericRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=2), + out_channels=256, + featmap_strides=[4, 8, 16, 32], + pre_cfg=dict( + type='ConvModule', + in_channels=256, + out_channels=256, + kernel_size=5, + padding=2, + inplace=False, + ), + post_cfg=dict( + type='GeneralizedAttention', + in_channels=256, + spatial_range=-1, + num_heads=6, + attention_type='0100', + kv_stride=2)))) diff --git a/mmdetection/configs/groie/mask-rcnn_r50_fpn_syncbn-r4-gcb-c3-c5-groie_1x_coco.py b/mmdetection/configs/groie/mask-rcnn_r50_fpn_syncbn-r4-gcb-c3-c5-groie_1x_coco.py new file mode 100644 index 00000000..22e97b69 --- /dev/null +++ b/mmdetection/configs/groie/mask-rcnn_r50_fpn_syncbn-r4-gcb-c3-c5-groie_1x_coco.py @@ -0,0 +1,45 @@ +_base_ = '../gcnet/mask-rcnn_r50-syncbn-gcb-r4-c3-c5_fpn_1x_coco.py' +# model settings +model = dict( + roi_head=dict( + bbox_roi_extractor=dict( + type='GenericRoIExtractor', + aggregation='sum', + roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=2), + out_channels=256, + featmap_strides=[4, 8, 16, 32], + pre_cfg=dict( + type='ConvModule', + in_channels=256, + out_channels=256, + kernel_size=5, + padding=2, + inplace=False, + ), + post_cfg=dict( + type='GeneralizedAttention', + in_channels=256, + spatial_range=-1, + num_heads=6, + attention_type='0100', + kv_stride=2)), + mask_roi_extractor=dict( + type='GenericRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=2), + out_channels=256, + featmap_strides=[4, 8, 16, 32], + pre_cfg=dict( + type='ConvModule', + in_channels=256, + out_channels=256, + kernel_size=5, + padding=2, + inplace=False, + ), + post_cfg=dict( + type='GeneralizedAttention', + in_channels=256, + spatial_range=-1, + num_heads=6, + attention_type='0100', + kv_stride=2)))) diff --git a/mmdetection/configs/groie/metafile.yml b/mmdetection/configs/groie/metafile.yml new file mode 100644 index 00000000..ce957004 --- /dev/null +++ b/mmdetection/configs/groie/metafile.yml @@ -0,0 +1,94 @@ +Collections: + - Name: GRoIE + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - Generic RoI Extractor + - FPN + - RPN + - ResNet + - RoIAlign + Paper: + URL: https://arxiv.org/abs/2004.13665 + Title: 'A novel Region of Interest Extraction Layer for Instance Segmentation' + README: configs/groie/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/roi_heads/roi_extractors/groie.py#L15 + Version: v2.1.0 + +Models: + - Name: faster-rcnn_r50_fpn_groie_1x_coco + In Collection: GRoIE + Config: configs/groie/faste-rcnn_r50_fpn_groie_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/groie/faster_rcnn_r50_fpn_groie_1x_coco/faster_rcnn_r50_fpn_groie_1x_coco_20200604_211715-66ee9516.pth + + - Name: grid-rcnn_r50_fpn_gn-head-groie_1x_coco + In Collection: GRoIE + Config: configs/groie/grid-rcnn_r50_fpn_gn-head-groie_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/groie/grid_rcnn_r50_fpn_gn-head_groie_1x_coco/grid_rcnn_r50_fpn_gn-head_groie_1x_coco_20200605_202059-4b75d86f.pth + + - Name: mask-rcnn_r50_fpn_groie_1x_coco + In Collection: GRoIE + Config: configs/groie/mask-rcnn_r50_fpn_groie_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.0 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/groie/mask_rcnn_r50_fpn_groie_1x_coco/mask_rcnn_r50_fpn_groie_1x_coco_20200604_211715-50d90c74.pth + + - Name: mask-rcnn_r50_fpn_syncbn-backbone_r4_gcb_c3-c5_groie_1x_coco + In Collection: GRoIE + Config: configs/groie/mask-rcnn_r50_fpn_syncbn-r4-gcb-c3-c5-groie_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.0 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/groie/mask_rcnn_r50_fpn_syncbn-backbone_r4_gcb_c3-c5_groie_1x_coco/mask_rcnn_r50_fpn_syncbn-backbone_r4_gcb_c3-c5_groie_1x_coco_20200604_211715-42eb79e1.pth + + - Name: mask-rcnn_r101_fpn_syncbn-r4-gcb_c3-c5-groie_1x_coco + In Collection: GRoIE + Config: configs/groie/mask-rcnn_r101_fpn_syncbn-r4-gcb_c3-c5-groie_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.6 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/groie/mask_rcnn_r101_fpn_syncbn-backbone_r4_gcb_c3-c5_groie_1x_coco/mask_rcnn_r101_fpn_syncbn-backbone_r4_gcb_c3-c5_groie_1x_coco_20200607_224507-8daae01c.pth diff --git a/mmdetection/configs/grounding_dino/README.md b/mmdetection/configs/grounding_dino/README.md new file mode 100644 index 00000000..2a527828 --- /dev/null +++ b/mmdetection/configs/grounding_dino/README.md @@ -0,0 +1,317 @@ +# Grounding DINO: Marrying DINO with Grounded Pre-Training for Open-Set Object Detection + +[Grounding DINO: Marrying DINO with Grounded Pre-Training for Open-Set Object Detection](https://arxiv.org/abs/2303.05499) + + + +## Abstract + +In this paper, we present an open-set object detector, called Grounding DINO, by marrying Transformer-based detector DINO with grounded pre-training, which can detect arbitrary objects with human inputs such as category names or referring expressions. The key solution of open-set object detection is introducing language to a closed-set detector for open-set concept generalization. To effectively fuse language and vision modalities, we conceptually divide a closed-set detector into three phases and propose a tight fusion solution, which includes a feature enhancer, a language-guided query selection, and a cross-modality decoder for cross-modality fusion. While previous works mainly evaluate open-set object detection on novel categories, we propose to also perform evaluations on referring expression comprehension for objects specified with attributes. Grounding DINO performs remarkably well on all three settings, including benchmarks on COCO, LVIS, ODinW, and RefCOCO/+/g. Grounding DINO achieves a 52.5 AP on the COCO detection zero-shot transfer benchmark, i.e., without any training data from COCO. It sets a new record on the ODinW zero-shot benchmark with a mean 26.1 AP. + +
    + +
    + +## Installation + +```shell +cd $MMDETROOT + +# source installation +pip install -r requirements/multimodal.txt + +# or mim installation +mim install mmdet[multimodal] +``` + +## NOTE + +Grounding DINO utilizes BERT as the language model, which requires access to https://huggingface.co/. If you encounter connection errors due to network access, you can download the required files on a computer with internet access and save them locally. Finally, modify the `lang_model_name` field in the config to the local path. Please refer to the following code: + +```python +from transformers import BertConfig, BertModel +from transformers import AutoTokenizer + +config = BertConfig.from_pretrained("bert-base-uncased") +model = BertModel.from_pretrained("bert-base-uncased", add_pooling_layer=False, config=config) +tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased") + +config.save_pretrained("your path/bert-base-uncased") +model.save_pretrained("your path/bert-base-uncased") +tokenizer.save_pretrained("your path/bert-base-uncased") +``` + +## Inference + +``` +cd $MMDETROOT + +wget https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/groundingdino_swint_ogc_mmdet-822d7e9d.pth + +python demo/image_demo.py \ + demo/demo.jpg \ + configs/grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_cap4m.py \ + --weights groundingdino_swint_ogc_mmdet-822d7e9d.pth \ + --texts 'bench . car .' +``` + +
    + +
    + +## COCO Results and Models + +| Model | Backbone | Style | COCO mAP | Official COCO mAP | Pre-Train Data | Config | Download | +| :----------------: | :------: | :-------: | :--------: | :---------------: | :----------------------------------------------: | :------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| Grounding DINO-T | Swin-T | Zero-shot | 48.5 | 48.4 | O365,GoldG,Cap4M | [config](grounding_dino_swin-t_pretrain_obj365_goldg_cap4m.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/groundingdino_swint_ogc_mmdet-822d7e9d.pth) | +| Grounding DINO-T | Swin-T | Finetune | 58.1(+0.9) | 57.2 | O365,GoldG,Cap4M | [config](grounding_dino_swin-t_finetune_16xb2_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/grounding_dino_swin-t_finetune_16xb2_1x_coco/grounding_dino_swin-t_finetune_16xb2_1x_coco_20230921_152544-5f234b20.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/grounding_dino_swin-t_finetune_16xb2_1x_coco/grounding_dino_swin-t_finetune_16xb2_1x_coco_20230921_152544.log.json) | +| Grounding DINO-B | Swin-B | Zero-shot | 56.9 | 56.7 | COCO,O365,GoldG,Cap4M,OpenImage,ODinW-35,RefCOCO | [config](grounding_dino_swin-b_pretrain_mixeddata.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/groundingdino_swinb_cogcoor_mmdet-55949c9c.pth) | +| Grounding DINO-B | Swin-B | Finetune | 59.7 | | COCO,O365,GoldG,Cap4M,OpenImage,ODinW-35,RefCOCO | [config](grounding_dino_swin-b_finetune_16xb2_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/grounding_dino_swin-b_finetune_16xb2_1x_coco/grounding_dino_swin-b_finetune_16xb2_1x_coco_20230921_153201-f219e0c0.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/grounding_dino_swin-b_finetune_16xb2_1x_coco/grounding_dino_swin-b_finetune_16xb2_1x_coco_20230921_153201.log.json) | +| Grounding DINO-R50 | R50 | Scratch | 48.9(+0.8) | 48.1 | | [config](grounding_dino_r50_scratch_8xb2_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/grounding_dino_r50_scratch_8xb2_1x_coco/grounding_dino_r50_scratch_1x_coco-fe0002f2.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/grounding_dino_r50_scratch_8xb2_1x_coco/20230922_114218.json) | + +Note: + +1. The weights corresponding to the zero-shot model are adopted from the official weights and converted using the [script](../../tools/model_converters/groundingdino_to_mmdet.py). We have not retrained the model for the time being. +2. Finetune refers to fine-tuning on the COCO 2017 dataset. The R50 model is trained using 8 NVIDIA GeForce 3090 GPUs, while the remaining models are trained using 16 NVIDIA GeForce 3090 GPUs. The GPU memory usage is approximately 8.5GB. +3. Our performance is higher than the official model due to two reasons: we modified the initialization strategy and introduced a log scaler. + +## LVIS Results + +| Model | MiniVal APr | MiniVal APc | MiniVal APf | MiniVal AP | Val1.0 APr | Val1.0 APc | Val1.0 APf | Val1.0 AP | Pre-Train Data | Config | Download | +| :--------------: | :---------: | :---------: | :---------: | :--------: | :--------: | :--------: | :--------: | :-------: | :----------------------------------------------: | :-----------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------: | +| Grounding DINO-T | 18.8 | 24.2 | 34.7 | 28.8 | 10.1 | 15.3 | 29.9 | 20.1 | O365,GoldG,Cap4M | [config](lvis/grounding_dino_swin-t_pretrain_zeroshot_mini-lvis.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/groundingdino_swint_ogc_mmdet-822d7e9d.pth) | +| Grounding DINO-B | 27.9 | 33.4 | 37.2 | 34.7 | 19.0 | 24.1 | 32.9 | 26.7 | COCO,O365,GoldG,Cap4M,OpenImage,ODinW-35,RefCOCO | [config](lvis/grounding_dino_swin-b_pretrain_zeroshot_mini-lvis.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/groundingdino_swinb_cogcoor_mmdet-55949c9c.pth) | + +Note: + +1. The above are zero-shot evaluation results. +2. The evaluation metric we used is LVIS FixAP. For specific details, please refer to [Evaluating Large-Vocabulary Object Detectors: The Devil is in the Details](https://arxiv.org/pdf/2102.01066.pdf). + +## ODinW (Object Detection in the Wild) Results + +Learning visual representations from natural language supervision has recently shown great promise in a number of pioneering works. In general, these language-augmented visual models demonstrate strong transferability to a variety of datasets and tasks. However, it remains challenging to evaluate the transferablity of these models due to the lack of easy-to-use evaluation toolkits and public benchmarks. To tackle this, we build ELEVATER 1 , the first benchmark and toolkit for evaluating (pre-trained) language-augmented visual models. ELEVATER is composed of three components. (i) Datasets. As downstream evaluation suites, it consists of 20 image classification datasets and 35 object detection datasets, each of which is augmented with external knowledge. (ii) Toolkit. An automatic hyper-parameter tuning toolkit is developed to facilitate model evaluation on downstream tasks. (iii) Metrics. A variety of evaluation metrics are used to measure sample-efficiency (zero-shot and few-shot) and parameter-efficiency (linear probing and full model fine-tuning). ELEVATER is platform for Computer Vision in the Wild (CVinW), and is publicly released at https://computer-vision-in-the-wild.github.io/ELEVATER/ + +### Results and models of ODinW13 + +| Method | GLIP-T(A) | Official | GLIP-T(B) | Official | GLIP-T(C) | Official | GroundingDINO-T | GroundingDINO-B | +| --------------------- | --------- | --------- | --------- | --------- | --------- | --------- | --------------- | --------------- | +| AerialMaritimeDrone | 0.123 | 0.122 | 0.110 | 0.110 | 0.130 | 0.130 | 0.173 | 0.281 | +| Aquarium | 0.175 | 0.174 | 0.173 | 0.169 | 0.191 | 0.190 | 0.195 | 0.445 | +| CottontailRabbits | 0.686 | 0.686 | 0.688 | 0.688 | 0.744 | 0.744 | 0.799 | 0.808 | +| EgoHands | 0.013 | 0.013 | 0.003 | 0.004 | 0.314 | 0.315 | 0.608 | 0.764 | +| NorthAmericaMushrooms | 0.502 | 0.502 | 0.367 | 0.367 | 0.297 | 0.296 | 0.507 | 0.675 | +| Packages | 0.589 | 0.589 | 0.083 | 0.083 | 0.699 | 0.699 | 0.687 | 0.670 | +| PascalVOC | 0.512 | 0.512 | 0.541 | 0.540 | 0.565 | 0.565 | 0.563 | 0.711 | +| pistols | 0.339 | 0.339 | 0.502 | 0.501 | 0.503 | 0.504 | 0.726 | 0.771 | +| pothole | 0.007 | 0.007 | 0.030 | 0.030 | 0.058 | 0.058 | 0.215 | 0.478 | +| Raccoon | 0.075 | 0.074 | 0.285 | 0.288 | 0.241 | 0.244 | 0.549 | 0.541 | +| ShellfishOpenImages | 0.253 | 0.253 | 0.337 | 0.338 | 0.300 | 0.302 | 0.393 | 0.650 | +| thermalDogsAndPeople | 0.372 | 0.372 | 0.475 | 0.475 | 0.510 | 0.510 | 0.657 | 0.633 | +| VehiclesOpenImages | 0.574 | 0.566 | 0.562 | 0.547 | 0.549 | 0.534 | 0.613 | 0.647 | +| Average | **0.325** | **0.324** | **0.320** | **0.318** | **0.392** | **0.392** | **0.514** | **0.621** | + +### Results and models of ODinW35 + +| Method | GLIP-T(A) | Official | GLIP-T(B) | Official | GLIP-T(C) | Official | GroundingDINO-T | GroundingDINO-B | +| --------------------------- | --------- | --------- | --------- | --------- | --------- | --------- | --------------- | --------------- | +| AerialMaritimeDrone_large | 0.123 | 0.122 | 0.110 | 0.110 | 0.130 | 0.130 | 0.173 | 0.281 | +| AerialMaritimeDrone_tiled | 0.174 | 0.174 | 0.172 | 0.172 | 0.172 | 0.172 | 0.206 | 0.364 | +| AmericanSignLanguageLetters | 0.001 | 0.001 | 0.003 | 0.003 | 0.009 | 0.009 | 0.002 | 0.096 | +| Aquarium | 0.175 | 0.175 | 0.173 | 0.171 | 0.192 | 0.182 | 0.195 | 0.445 | +| BCCD | 0.016 | 0.016 | 0.001 | 0.001 | 0.000 | 0.000 | 0.161 | 0.584 | +| boggleBoards | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.134 | +| brackishUnderwater | 0.016 | 0..013 | 0.021 | 0.027 | 0.020 | 0.022 | 0.021 | 0.454 | +| ChessPieces | 0.001 | 0.001 | 0.000 | 0.000 | 0.001 | 0.001 | 0.000 | 0.000 | +| CottontailRabbits | 0.710 | 0.709 | 0.683 | 0.683 | 0.752 | 0.752 | 0.806 | 0.797 | +| dice | 0.005 | 0.005 | 0.004 | 0.004 | 0.004 | 0.004 | 0.004 | 0.082 | +| DroneControl | 0.016 | 0.017 | 0.006 | 0.008 | 0.005 | 0.007 | 0.042 | 0.638 | +| EgoHands_generic | 0.009 | 0.010 | 0.005 | 0.006 | 0.510 | 0.508 | 0.608 | 0.764 | +| EgoHands_specific | 0.001 | 0.001 | 0.004 | 0.006 | 0.003 | 0.004 | 0.002 | 0.687 | +| HardHatWorkers | 0.029 | 0.029 | 0.023 | 0.023 | 0.033 | 0.033 | 0.046 | 0.439 | +| MaskWearing | 0.007 | 0.007 | 0.003 | 0.002 | 0.005 | 0.005 | 0.004 | 0.406 | +| MountainDewCommercial | 0.218 | 0.227 | 0.199 | 0.197 | 0.478 | 0.463 | 0.430 | 0.580 | +| NorthAmericaMushrooms | 0.502 | 0.502 | 0.450 | 0.450 | 0.497 | 0.497 | 0.471 | 0.501 | +| openPoetryVision | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.051 | +| OxfordPets_by_breed | 0.001 | 0.002 | 0.002 | 0.004 | 0.001 | 0.002 | 0.003 | 0.799 | +| OxfordPets_by_species | 0.016 | 0.011 | 0.012 | 0.009 | 0.013 | 0.009 | 0.011 | 0.872 | +| PKLot | 0.002 | 0.002 | 0.000 | 0.000 | 0.000 | 0.000 | 0.001 | 0.774 | +| Packages | 0.569 | 0.569 | 0.279 | 0.279 | 0.712 | 0.712 | 0.695 | 0.728 | +| PascalVOC | 0.512 | 0.512 | 0.541 | 0.540 | 0.565 | 0.565 | 0.563 | 0.711 | +| pistols | 0.339 | 0.339 | 0.502 | 0.501 | 0.503 | 0.504 | 0.726 | 0.771 | +| plantdoc | 0.002 | 0.002 | 0.007 | 0.007 | 0.009 | 0.009 | 0.005 | 0.376 | +| pothole | 0.007 | 0.010 | 0.024 | 0.025 | 0.085 | 0.101 | 0.215 | 0.478 | +| Raccoons | 0.075 | 0.074 | 0.285 | 0.288 | 0.241 | 0.244 | 0.549 | 0.541 | +| selfdrivingCar | 0.071 | 0.072 | 0.074 | 0.074 | 0.081 | 0.080 | 0.089 | 0.318 | +| ShellfishOpenImages | 0.253 | 0.253 | 0.337 | 0.338 | 0.300 | 0.302 | 0.393 | 0.650 | +| ThermalCheetah | 0.028 | 0.028 | 0.000 | 0.000 | 0.028 | 0.028 | 0.087 | 0.290 | +| thermalDogsAndPeople | 0.372 | 0.372 | 0.475 | 0.475 | 0.510 | 0.510 | 0.657 | 0.633 | +| UnoCards | 0.000 | 0.000 | 0.000 | 0.001 | 0.002 | 0.003 | 0.006 | 0.754 | +| VehiclesOpenImages | 0.574 | 0.566 | 0.562 | 0.547 | 0.549 | 0.534 | 0.613 | 0.647 | +| WildfireSmoke | 0.000 | 0.000 | 0.000 | 0.000 | 0.017 | 0.017 | 0.134 | 0.410 | +| websiteScreenshots | 0.003 | 0.004 | 0.003 | 0.005 | 0.005 | 0.006 | 0.012 | 0.175 | +| Average | **0.134** | **0.134** | **0.138** | **0.138** | **0.179** | **0.178** | **0.227** | **0.492** | + +## Flickr30k Results + +| Model | Pre-Train Data | Val R@1 | Val R@5 | Val R@10 | Tesst R@1 | Test R@5 | Test R@10 | Config | Download | +| :--------------: | :--------------: | ------- | ------- | -------- | --------- | -------- | --------- | :-------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| Grounding DINO-T | O365,GoldG,Cap4M | 87.8 | 96.6 | 98.0 | 88.1 | 96.9 | 98.2 | [config](grounding_dino_swin-t_finetune_16xb2_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/grounding_dino_swin-t_finetune_16xb2_1x_coco/grounding_dino_swin-t_finetune_16xb2_1x_coco_20230921_152544-5f234b20.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/grounding_dino_swin-t_finetune_16xb2_1x_coco/grounding_dino_swin-t_finetune_16xb2_1x_coco_20230921_152544.log.json) | + +Note: + +1. `@1,5,10` refers to precision at the top 1, 5, and 10 positions in a predicted ranked list. +2. The pretraining data used by Grounding DINO-T is `O365,GoldG,Cap4M`, and the corresponding evaluation configuration is (grounding_dino_swin-t_pretrain_zeroshot_refcoco)\[refcoco/grounding_dino_swin-t_pretrain_zeroshot_refcoco.py\]. + +Test Command + +```shell +cd mmdetection +bash tools/dist_test.sh configs/grounding_dino/flickr30k/grounding_dino_swin-t-pretrain_zeroshot_flickr30k.py checkpoints/groundingdino_swint_ogc_mmdet-822d7e9d.pth 8 +``` + +## Referring Expression Comprehension Results + +| Method | Grounding DINO-T
    (O365,GoldG,Cap4M) | Grounding DINO-B
    (COCO,O365,GoldG,Cap4M,OpenImage,ODinW-35,RefCOCO) | +| --------------------------------------- | ----------------------------------------- | ------------------------------------------------------------------------- | +| RefCOCO val @1,5,10 | 50.77/89.45/94.86 | 84.61/97.88/99.10 | +| RefCOCO testA @1,5,10 | 57.45/91.29/95.62 | 88.65/98.89/99.63 | +| RefCOCO testB @1,5,10 | 44.97/86.54/92.88 | 80.51/96.64/98.51 | +| RefCOCO+ val @1,5,10 | 51.64/86.35/92.57 | 73.67/96.60/98.65 | +| RefCOCO+ testA @1,5,10 | 57.25/86.74/92.65 | 82.19/97.92/99.09 | +| RefCOCO+ testB @1,5,10 | 46.35/84.05/90.67 | 64.10/94.25/97.46 | +| RefCOCOg val @1,5,10 | 60.42/92.10/96.18 | 78.33/97.28/98.57 | +| RefCOCOg test @1,5,10 | 59.74/92.08/96.28 | 78.11/97.06/98.65 | +| gRefCOCO val Pr@(F1=1, IoU≥0.5),N-acc | 41.32/91.82 | 46.18/81.44 | +| gRefCOCO testA Pr@(F1=1, IoU≥0.5),N-acc | 27.23/90.24 | 38.60/76.06 | +| gRefCOCO testB Pr@(F1=1, IoU≥0.5),N-acc | 29.70/93.49 | 35.87/80.58 | + +Note: + +1. `@1,5,10` refers to precision at the top 1, 5, and 10 positions in a predicted ranked list. +2. `Pr@(F1=1, IoU≥0.5),N-acc` from the paper [GREC: Generalized Referring Expression Comprehension](https://arxiv.org/pdf/2308.16182.pdf) +3. The pretraining data used by Grounding DINO-T is `O365,GoldG,Cap4M`, and the corresponding evaluation configuration is (grounding_dino_swin-t_pretrain_zeroshot_refcoco)\[refcoco/grounding_dino_swin-t_pretrain_zeroshot_refcoco.py\]. +4. The pretraining data used by Grounding DINO-B is `COCO,O365,GoldG,Cap4M,OpenImage,ODinW-35,RefCOCO`, and the corresponding evaluation configuration is (grounding_dino_swin-t_pretrain_zeroshot_refcoco)\[refcoco/grounding_dino_swin-b_pretrain_zeroshot_refcoco.py\]. + +Test Command + +```shell +cd mmdetection +./tools/dist_test.sh configs/grounding_dino/refcoco/grounding_dino_swin-t_pretrain_zeroshot_refexp.py https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/groundingdino_swint_ogc_mmdet-822d7e9d.pth 8 +./tools/dist_test.sh configs/grounding_dino/refcoco/grounding_dino_swin-b_pretrain_zeroshot_refexp.py https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/groundingdino_swinb_cogcoor_mmdet-55949c9c.pth 8 +``` + +## Description Detection Dataset + +```shell +pip install ddd-dataset +``` + +| Method | mode | Grounding DINO-T
    (O365,GoldG,Cap4M) | Grounding DINO-B
    (COCO,O365,GoldG,Cap4M,OpenImage,ODinW-35,RefCOCO) | +| -------------------------------- | -------- | ----------------------------------------- | ------------------------------------------------------------------------- | +| FULL/short/middle/long/very long | concat | 17.2/18.0/18.7/14.8/16.3 | 20.2/20.4/21.1/18.8/19.8 | +| FULL/short/middle/long/very long | parallel | 22.3/28.2/24.8/19.1/13.9 | 25.0/26.4/27.2/23.5/19.7 | +| PRES/short/middle/long/very long | concat | 17.8/18.3/19.2/15.2/17.3 | 20.7/21.7/21.4/19.1/20.3 | +| PRES/short/middle/long/very long | parallel | 21.0/27.0/22.8/17.5/12.5 | 23.7/25.8/25.1/21.9/19.3 | +| ABS/short/middle/long/very long | concat | 15.4/17.1/16.4/13.6/14.9 | 18.6/16.1/19.7/18.1/19.1 | +| ABS/short/middle/long/very long | parallel | 26.0/32.0/33.0/23.6/15.5 | 28.8/28.1/35.8/28.2/20.2 | + +Note: + +1. Considering that the evaluation time for Inter-scenario is very long and the performance is low, it is temporarily not supported. The mentioned metrics are for Intra-scenario. +2. `concat` is the default inference mode for Grounding DINO, where it concatenates multiple sub-sentences with "." to form a single sentence for inference. On the other hand, "parallel" performs inference on each sub-sentence in a for-loop. + +## Custom Dataset + +To facilitate fine-tuning on custom datasets, we use a simple cat dataset as an example, as shown in the following steps. + +### 1. Dataset Preparation + +```shell +cd mmdetection +wget https://download.openmmlab.com/mmyolo/data/cat_dataset.zip +unzip cat_dataset.zip -d data/cat/ +``` + +cat dataset is a single-category dataset with 144 images, which has been converted to coco format. + +
    +cat dataset +
    + +### 2. Config Preparation + +Due to the simplicity and small number of cat datasets, we use 8 cards to train 20 epochs, scale the learning rate accordingly, and do not train the language model, only the visual model. + +The Details of the configuration can be found in [grounding_dino_swin-t_finetune_8xb2_20e_cat](grounding_dino_swin-t_finetune_8xb2_20e_cat.py) + +### 3. Visualization and Evaluation + +Due to the Grounding DINO is an open detection model, so it can be detected and evaluated even if it is not trained on the cat dataset. + +The single image visualization is as follows: + +```shell +cd mmdetection +python demo/image_demo.py data/cat/images/IMG_20211205_120756.jpg configs/grounding_dino/grounding_dino_swin-t_finetune_8xb2_20e_cat.py --weights https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/groundingdino_swint_ogc_mmdet-822d7e9d.pth --texts cat. +``` + +
    +cat dataset +
    + +The test dataset evaluation on single card is as follows: + +```shell +python tools/test.py configs/grounding_dino/grounding_dino_swin-t_finetune_8xb2_20e_cat.py https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/groundingdino_swint_ogc_mmdet-822d7e9d.pth +``` + +```text + Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.867 + Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 1.000 + Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.931 + Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.867 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.903 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.907 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.907 + Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000 + Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000 + Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.907 +``` + +### 4. Model Training and Visualization + +```shell +./tools/dist_train.sh configs/grounding_dino/grounding_dino_swin-t_finetune_8xb2_20e_cat.py 8 --work-dir cat_work_dir +``` + +The model will be saved based on the best performance on the test set. The performance of the best model (at epoch 16) is as follows: + +```text + Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.905 + Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 1.000 + Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.923 + Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.905 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.927 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.937 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.937 + Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000 + Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000 + Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.937 +``` + +We can find that after fine-tuning training, the training of the cat dataset is increased from 86.7 to 90.5. + +If we do single image inference visualization again, the result is as follows: + +```shell +cd mmdetection +python demo/image_demo.py data/cat/images/IMG_20211205_120756.jpg configs/grounding_dino/grounding_dino_swin-t_finetune_8xb2_20e_cat.py --weights cat_work_dir/best_coco_bbox_mAP_epoch_16.pth --texts cat. +``` + +
    +cat dataset +
    diff --git a/mmdetection/configs/grounding_dino/dod/grounding_dino_swin-b_pretrain_zeroshot_concat_dod.py b/mmdetection/configs/grounding_dino/dod/grounding_dino_swin-b_pretrain_zeroshot_concat_dod.py new file mode 100644 index 00000000..ac655b74 --- /dev/null +++ b/mmdetection/configs/grounding_dino/dod/grounding_dino_swin-b_pretrain_zeroshot_concat_dod.py @@ -0,0 +1,14 @@ +_base_ = 'grounding_dino_swin-t_pretrain_zeroshot_concat_dod.py' + +model = dict( + type='GroundingDINO', + backbone=dict( + pretrain_img_size=384, + embed_dims=128, + depths=[2, 2, 18, 2], + num_heads=[4, 8, 16, 32], + window_size=12, + drop_path_rate=0.3, + patch_norm=True), + neck=dict(in_channels=[256, 512, 1024]), +) diff --git a/mmdetection/configs/grounding_dino/dod/grounding_dino_swin-b_pretrain_zeroshot_parallel_dod.py b/mmdetection/configs/grounding_dino/dod/grounding_dino_swin-b_pretrain_zeroshot_parallel_dod.py new file mode 100644 index 00000000..9a1c8f2a --- /dev/null +++ b/mmdetection/configs/grounding_dino/dod/grounding_dino_swin-b_pretrain_zeroshot_parallel_dod.py @@ -0,0 +1,3 @@ +_base_ = 'grounding_dino_swin-b_pretrain_zeroshot_concat_dod.py' + +model = dict(test_cfg=dict(chunked_size=1)) diff --git a/mmdetection/configs/grounding_dino/dod/grounding_dino_swin-t_pretrain_zeroshot_concat_dod.py b/mmdetection/configs/grounding_dino/dod/grounding_dino_swin-t_pretrain_zeroshot_concat_dod.py new file mode 100644 index 00000000..bb418011 --- /dev/null +++ b/mmdetection/configs/grounding_dino/dod/grounding_dino_swin-t_pretrain_zeroshot_concat_dod.py @@ -0,0 +1,78 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365_goldg_cap4m.py' + +data_root = 'data/d3/' + +test_pipeline = [ + dict( + type='LoadImageFromFile', backend_args=None, + imdecode_backend='pillow'), + dict( + type='FixScaleResize', + scale=(800, 1333), + keep_ratio=True, + backend='pillow'), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'text', 'custom_entities', 'sent_ids')) +] + +# -------------------------------------------------# +val_dataset_full = dict( + type='DODDataset', + data_root=data_root, + ann_file='d3_json/d3_full_annotations.json', + data_prefix=dict(img='d3_images/', anno='d3_pkl'), + pipeline=test_pipeline, + test_mode=True, + backend_args=None, + return_classes=True) + +val_evaluator_full = dict( + type='DODCocoMetric', + ann_file=data_root + 'd3_json/d3_full_annotations.json') + +# -------------------------------------------------# +val_dataset_pres = dict( + type='DODDataset', + data_root=data_root, + ann_file='d3_json/d3_pres_annotations.json', + data_prefix=dict(img='d3_images/', anno='d3_pkl'), + pipeline=test_pipeline, + test_mode=True, + backend_args=None, + return_classes=True) +val_evaluator_pres = dict( + type='DODCocoMetric', + ann_file=data_root + 'd3_json/d3_pres_annotations.json') + +# -------------------------------------------------# +val_dataset_abs = dict( + type='DODDataset', + data_root=data_root, + ann_file='d3_json/d3_abs_annotations.json', + data_prefix=dict(img='d3_images/', anno='d3_pkl'), + pipeline=test_pipeline, + test_mode=True, + backend_args=None, + return_classes=True) +val_evaluator_abs = dict( + type='DODCocoMetric', + ann_file=data_root + 'd3_json/d3_abs_annotations.json') + +# -------------------------------------------------# +datasets = [val_dataset_full, val_dataset_pres, val_dataset_abs] +dataset_prefixes = ['FULL', 'PRES', 'ABS'] +metrics = [val_evaluator_full, val_evaluator_pres, val_evaluator_abs] + +val_dataloader = dict( + dataset=dict(_delete_=True, type='ConcatDataset', datasets=datasets)) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + type='MultiDatasetsEvaluator', + metrics=metrics, + dataset_prefixes=dataset_prefixes) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/grounding_dino/dod/grounding_dino_swin-t_pretrain_zeroshot_parallel_dod.py b/mmdetection/configs/grounding_dino/dod/grounding_dino_swin-t_pretrain_zeroshot_parallel_dod.py new file mode 100644 index 00000000..3d680091 --- /dev/null +++ b/mmdetection/configs/grounding_dino/dod/grounding_dino_swin-t_pretrain_zeroshot_parallel_dod.py @@ -0,0 +1,3 @@ +_base_ = 'grounding_dino_swin-t_pretrain_zeroshot_concat_dod.py' + +model = dict(test_cfg=dict(chunked_size=1)) diff --git a/mmdetection/configs/grounding_dino/flickr30k/grounding_dino_swin-t-pretrain_zeroshot_flickr30k.py b/mmdetection/configs/grounding_dino/flickr30k/grounding_dino_swin-t-pretrain_zeroshot_flickr30k.py new file mode 100644 index 00000000..c1996567 --- /dev/null +++ b/mmdetection/configs/grounding_dino/flickr30k/grounding_dino_swin-t-pretrain_zeroshot_flickr30k.py @@ -0,0 +1,57 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365_goldg_cap4m.py' + +dataset_type = 'Flickr30kDataset' +data_root = 'data/flickr30k_entities/' + +test_pipeline = [ + dict( + type='LoadImageFromFile', backend_args=None, + imdecode_backend='pillow'), + dict( + type='FixScaleResize', + scale=(800, 1333), + keep_ratio=True, + backend='pillow'), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'text', 'custom_entities', + 'tokens_positive', 'phrase_ids', 'phrases')) +] + +dataset_Flickr30k_val = dict( + type=dataset_type, + data_root=data_root, + ann_file='final_flickr_separateGT_val.json', + data_prefix=dict(img='flickr30k_images/'), + pipeline=test_pipeline, +) + +dataset_Flickr30k_test = dict( + type=dataset_type, + data_root=data_root, + ann_file='final_flickr_separateGT_test.json', + data_prefix=dict(img='flickr30k_images/'), + pipeline=test_pipeline, +) + +val_evaluator_Flickr30k = dict(type='Flickr30kMetric') + +test_evaluator_Flickr30k = dict(type='Flickr30kMetric') + +# ----------Config---------- # +dataset_prefixes = ['Flickr30kVal', 'Flickr30kTest'] +datasets = [dataset_Flickr30k_val, dataset_Flickr30k_test] +metrics = [val_evaluator_Flickr30k, test_evaluator_Flickr30k] + +val_dataloader = dict( + dataset=dict(_delete_=True, type='ConcatDataset', datasets=datasets)) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + type='MultiDatasetsEvaluator', + metrics=metrics, + dataset_prefixes=dataset_prefixes) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/grounding_dino/grounding_dino_r50_scratch_8xb2_1x_coco.py b/mmdetection/configs/grounding_dino/grounding_dino_r50_scratch_8xb2_1x_coco.py new file mode 100644 index 00000000..623a29b8 --- /dev/null +++ b/mmdetection/configs/grounding_dino/grounding_dino_r50_scratch_8xb2_1x_coco.py @@ -0,0 +1,208 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +lang_model_name = 'bert-base-uncased' + +model = dict( + type='GroundingDINO', + num_queries=900, + with_box_refine=True, + as_two_stage=True, + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_mask=False, + ), + language_model=dict( + type='BertModel', + name=lang_model_name, + pad_to_max=False, + use_sub_sentence_represent=True, + special_tokens_list=['[CLS]', '[SEP]', '.', '?'], + add_pooling_layer=False, + ), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=False), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='ChannelMapper', + in_channels=[512, 1024, 2048], + kernel_size=1, + out_channels=256, + act_cfg=None, + bias=True, + norm_cfg=dict(type='GN', num_groups=32), + num_outs=4), + encoder=dict( + num_layers=6, + num_cp=6, + # visual layer config + layer_cfg=dict( + self_attn_cfg=dict(embed_dims=256, num_levels=4, dropout=0.0), + ffn_cfg=dict( + embed_dims=256, feedforward_channels=2048, ffn_drop=0.0)), + # text layer config + text_layer_cfg=dict( + self_attn_cfg=dict(num_heads=4, embed_dims=256, dropout=0.0), + ffn_cfg=dict( + embed_dims=256, feedforward_channels=1024, ffn_drop=0.0)), + # fusion layer config + fusion_layer_cfg=dict( + v_dim=256, + l_dim=256, + embed_dim=1024, + num_heads=4, + init_values=1e-4), + ), + decoder=dict( + num_layers=6, + return_intermediate=True, + layer_cfg=dict( + # query self attention layer + self_attn_cfg=dict(embed_dims=256, num_heads=8, dropout=0.0), + # cross attention layer query to text + cross_attn_text_cfg=dict(embed_dims=256, num_heads=8, dropout=0.0), + # cross attention layer query to image + cross_attn_cfg=dict(embed_dims=256, num_heads=8, dropout=0.0), + ffn_cfg=dict( + embed_dims=256, feedforward_channels=2048, ffn_drop=0.0)), + post_norm_cfg=None), + positional_encoding=dict( + num_feats=128, normalize=True, offset=0.0, temperature=20), + bbox_head=dict( + type='GroundingDINOHead', + num_classes=80, + sync_cls_avg_factor=True, + contrastive_cfg=dict(max_text_len=256, log_scale='auto', bias=True), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), # 2.0 in DeformDETR + loss_bbox=dict(type='L1Loss', loss_weight=5.0), + loss_iou=dict(type='GIoULoss', loss_weight=2.0)), + dn_cfg=dict( # TODO: Move to model.train_cfg ? + label_noise_scale=0.5, + box_noise_scale=1.0, # 0.4 for DN-DETR + group_cfg=dict(dynamic=True, num_groups=None, + num_dn_queries=100)), # TODO: half num_dn_queries + # training and testing settings + train_cfg=dict( + assigner=dict( + type='HungarianAssigner', + match_costs=[ + dict(type='BinaryFocalLossCost', weight=2.0), + dict(type='BBoxL1Cost', weight=5.0, box_format='xywh'), + dict(type='IoUCost', iou_mode='giou', weight=2.0) + ])), + test_cfg=dict(max_per_img=300)) + +# dataset settings +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities')) +] + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='FixScaleResize', scale=(800, 1333), keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'text', 'custom_entities')) +] + +train_dataloader = dict( + dataset=dict( + filter_cfg=dict(filter_empty_gt=False), + pipeline=train_pipeline, + return_classes=True)) +val_dataloader = dict( + dataset=dict(pipeline=test_pipeline, return_classes=True)) +test_dataloader = val_dataloader + +# We did not adopt the official 24e optimizer strategy +# because the results indicate that the current strategy is superior. +optim_wrapper = dict( + _delete_=True, + type='OptimWrapper', + optimizer=dict( + type='AdamW', + lr=0.0001, # 0.0002 for DeformDETR + weight_decay=0.0001), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict(custom_keys={ + 'absolute_pos_embed': dict(decay_mult=0.), + 'backbone': dict(lr_mult=0.1) + })) +# learning policy +max_epochs = 12 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) + +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[11], + gamma=0.1) +] + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=16) diff --git a/mmdetection/configs/grounding_dino/grounding_dino_swin-b_finetune_16xb2_1x_coco.py b/mmdetection/configs/grounding_dino/grounding_dino_swin-b_finetune_16xb2_1x_coco.py new file mode 100644 index 00000000..3554ee24 --- /dev/null +++ b/mmdetection/configs/grounding_dino/grounding_dino_swin-b_finetune_16xb2_1x_coco.py @@ -0,0 +1,17 @@ +_base_ = [ + './grounding_dino_swin-t_finetune_16xb2_1x_coco.py', +] + +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/groundingdino_swinb_cogcoor_mmdet-55949c9c.pth' # noqa +model = dict( + type='GroundingDINO', + backbone=dict( + pretrain_img_size=384, + embed_dims=128, + depths=[2, 2, 18, 2], + num_heads=[4, 8, 16, 32], + window_size=12, + drop_path_rate=0.3, + patch_norm=True), + neck=dict(in_channels=[256, 512, 1024]), +) diff --git a/mmdetection/configs/grounding_dino/grounding_dino_swin-b_pretrain_mixeddata.py b/mmdetection/configs/grounding_dino/grounding_dino_swin-b_pretrain_mixeddata.py new file mode 100644 index 00000000..92f327fe --- /dev/null +++ b/mmdetection/configs/grounding_dino/grounding_dino_swin-b_pretrain_mixeddata.py @@ -0,0 +1,16 @@ +_base_ = [ + './grounding_dino_swin-t_pretrain_obj365_goldg_cap4m.py', +] + +model = dict( + type='GroundingDINO', + backbone=dict( + pretrain_img_size=384, + embed_dims=128, + depths=[2, 2, 18, 2], + num_heads=[4, 8, 16, 32], + window_size=12, + drop_path_rate=0.3, + patch_norm=True), + neck=dict(in_channels=[256, 512, 1024]), +) diff --git a/mmdetection/configs/grounding_dino/grounding_dino_swin-t_finetune_16xb2_1x_coco.py b/mmdetection/configs/grounding_dino/grounding_dino_swin-t_finetune_16xb2_1x_coco.py new file mode 100644 index 00000000..0c6403ee --- /dev/null +++ b/mmdetection/configs/grounding_dino/grounding_dino_swin-t_finetune_16xb2_1x_coco.py @@ -0,0 +1,204 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/groundingdino_swint_ogc_mmdet-822d7e9d.pth' # noqa +lang_model_name = 'bert-base-uncased' + +model = dict( + type='GroundingDINO', + num_queries=900, + with_box_refine=True, + as_two_stage=True, + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_mask=False, + ), + language_model=dict( + type='BertModel', + name=lang_model_name, + pad_to_max=False, + use_sub_sentence_represent=True, + special_tokens_list=['[CLS]', '[SEP]', '.', '?'], + add_pooling_layer=False, + ), + backbone=dict( + type='SwinTransformer', + embed_dims=96, + depths=[2, 2, 6, 2], + num_heads=[3, 6, 12, 24], + window_size=7, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.2, + patch_norm=True, + out_indices=(1, 2, 3), + with_cp=True, + convert_weights=False), + neck=dict( + type='ChannelMapper', + in_channels=[192, 384, 768], + kernel_size=1, + out_channels=256, + act_cfg=None, + bias=True, + norm_cfg=dict(type='GN', num_groups=32), + num_outs=4), + encoder=dict( + num_layers=6, + num_cp=6, + # visual layer config + layer_cfg=dict( + self_attn_cfg=dict(embed_dims=256, num_levels=4, dropout=0.0), + ffn_cfg=dict( + embed_dims=256, feedforward_channels=2048, ffn_drop=0.0)), + # text layer config + text_layer_cfg=dict( + self_attn_cfg=dict(num_heads=4, embed_dims=256, dropout=0.0), + ffn_cfg=dict( + embed_dims=256, feedforward_channels=1024, ffn_drop=0.0)), + # fusion layer config + fusion_layer_cfg=dict( + v_dim=256, + l_dim=256, + embed_dim=1024, + num_heads=4, + init_values=1e-4), + ), + decoder=dict( + num_layers=6, + return_intermediate=True, + layer_cfg=dict( + # query self attention layer + self_attn_cfg=dict(embed_dims=256, num_heads=8, dropout=0.0), + # cross attention layer query to text + cross_attn_text_cfg=dict(embed_dims=256, num_heads=8, dropout=0.0), + # cross attention layer query to image + cross_attn_cfg=dict(embed_dims=256, num_heads=8, dropout=0.0), + ffn_cfg=dict( + embed_dims=256, feedforward_channels=2048, ffn_drop=0.0)), + post_norm_cfg=None), + positional_encoding=dict( + num_feats=128, normalize=True, offset=0.0, temperature=20), + bbox_head=dict( + type='GroundingDINOHead', + num_classes=80, + sync_cls_avg_factor=True, + contrastive_cfg=dict(max_text_len=256, log_scale=0.0, bias=False), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), # 2.0 in DeformDETR + loss_bbox=dict(type='L1Loss', loss_weight=5.0), + loss_iou=dict(type='GIoULoss', loss_weight=2.0)), + dn_cfg=dict( # TODO: Move to model.train_cfg ? + label_noise_scale=0.5, + box_noise_scale=1.0, # 0.4 for DN-DETR + group_cfg=dict(dynamic=True, num_groups=None, + num_dn_queries=100)), # TODO: half num_dn_queries + # training and testing settings + train_cfg=dict( + assigner=dict( + type='HungarianAssigner', + match_costs=[ + dict(type='BinaryFocalLossCost', weight=2.0), + dict(type='BBoxL1Cost', weight=5.0, box_format='xywh'), + dict(type='IoUCost', iou_mode='giou', weight=2.0) + ])), + test_cfg=dict(max_per_img=300)) + +# dataset settings +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities')) +] + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='FixScaleResize', scale=(800, 1333), keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'text', 'custom_entities')) +] + +train_dataloader = dict( + dataset=dict( + filter_cfg=dict(filter_empty_gt=False), + pipeline=train_pipeline, + return_classes=True)) +val_dataloader = dict( + dataset=dict(pipeline=test_pipeline, return_classes=True)) +test_dataloader = val_dataloader + +optim_wrapper = dict( + _delete_=True, + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0001), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict(custom_keys={ + 'absolute_pos_embed': dict(decay_mult=0.), + 'backbone': dict(lr_mult=0.1) + })) +# learning policy +max_epochs = 12 +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[11], + gamma=0.1) +] + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (16 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=32) diff --git a/mmdetection/configs/grounding_dino/grounding_dino_swin-t_finetune_8xb2_20e_cat.py b/mmdetection/configs/grounding_dino/grounding_dino_swin-t_finetune_8xb2_20e_cat.py new file mode 100644 index 00000000..c2265e86 --- /dev/null +++ b/mmdetection/configs/grounding_dino/grounding_dino_swin-t_finetune_8xb2_20e_cat.py @@ -0,0 +1,56 @@ +_base_ = 'grounding_dino_swin-t_finetune_16xb2_1x_coco.py' + +data_root = 'data/cat/' +class_name = ('cat', ) +num_classes = len(class_name) +metainfo = dict(classes=class_name, palette=[(220, 20, 60)]) + +model = dict(bbox_head=dict(num_classes=num_classes)) + +train_dataloader = dict( + dataset=dict( + data_root=data_root, + metainfo=metainfo, + ann_file='annotations/trainval.json', + data_prefix=dict(img='images/'))) + +val_dataloader = dict( + dataset=dict( + metainfo=metainfo, + data_root=data_root, + ann_file='annotations/test.json', + data_prefix=dict(img='images/'))) + +test_dataloader = val_dataloader + +val_evaluator = dict(ann_file=data_root + 'annotations/test.json') +test_evaluator = val_evaluator + +max_epoch = 20 + +default_hooks = dict( + checkpoint=dict(interval=1, max_keep_ckpts=1, save_best='auto'), + logger=dict(type='LoggerHook', interval=5)) +train_cfg = dict(max_epochs=max_epoch, val_interval=1) + +param_scheduler = [ + dict(type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=30), + dict( + type='MultiStepLR', + begin=0, + end=max_epoch, + by_epoch=True, + milestones=[15], + gamma=0.1) +] + +optim_wrapper = dict( + optimizer=dict(lr=0.00005), + paramwise_cfg=dict( + custom_keys={ + 'absolute_pos_embed': dict(decay_mult=0.), + 'backbone': dict(lr_mult=0.1), + 'language_model': dict(lr_mult=0), + })) + +auto_scale_lr = dict(base_batch_size=16) diff --git a/mmdetection/configs/grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_cap4m.py b/mmdetection/configs/grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_cap4m.py new file mode 100644 index 00000000..7448764e --- /dev/null +++ b/mmdetection/configs/grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_cap4m.py @@ -0,0 +1,128 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +lang_model_name = 'bert-base-uncased' + +model = dict( + type='GroundingDINO', + num_queries=900, + with_box_refine=True, + as_two_stage=True, + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_mask=False, + ), + language_model=dict( + type='BertModel', + name=lang_model_name, + pad_to_max=False, + use_sub_sentence_represent=True, + special_tokens_list=['[CLS]', '[SEP]', '.', '?'], + add_pooling_layer=True, + ), + backbone=dict( + type='SwinTransformer', + embed_dims=96, + depths=[2, 2, 6, 2], + num_heads=[3, 6, 12, 24], + window_size=7, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.2, + patch_norm=True, + out_indices=(1, 2, 3), + with_cp=False, + convert_weights=False), + neck=dict( + type='ChannelMapper', + in_channels=[192, 384, 768], + kernel_size=1, + out_channels=256, + act_cfg=None, + bias=True, + norm_cfg=dict(type='GN', num_groups=32), + num_outs=4), + encoder=dict( + num_layers=6, + # visual layer config + layer_cfg=dict( + self_attn_cfg=dict(embed_dims=256, num_levels=4, dropout=0.0), + ffn_cfg=dict( + embed_dims=256, feedforward_channels=2048, ffn_drop=0.0)), + # text layer config + text_layer_cfg=dict( + self_attn_cfg=dict(num_heads=4, embed_dims=256, dropout=0.0), + ffn_cfg=dict( + embed_dims=256, feedforward_channels=1024, ffn_drop=0.0)), + # fusion layer config + fusion_layer_cfg=dict( + v_dim=256, + l_dim=256, + embed_dim=1024, + num_heads=4, + init_values=1e-4), + ), + decoder=dict( + num_layers=6, + return_intermediate=True, + layer_cfg=dict( + # query self attention layer + self_attn_cfg=dict(embed_dims=256, num_heads=8, dropout=0.0), + # cross attention layer query to text + cross_attn_text_cfg=dict(embed_dims=256, num_heads=8, dropout=0.0), + # cross attention layer query to image + cross_attn_cfg=dict(embed_dims=256, num_heads=8, dropout=0.0), + ffn_cfg=dict( + embed_dims=256, feedforward_channels=2048, ffn_drop=0.0)), + post_norm_cfg=None), + positional_encoding=dict( + num_feats=128, normalize=True, offset=0.0, temperature=20), + bbox_head=dict( + type='GroundingDINOHead', + num_classes=80, + sync_cls_avg_factor=True, + contrastive_cfg=dict(max_text_len=256), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), # 2.0 in DeformDETR + loss_bbox=dict(type='L1Loss', loss_weight=5.0)), + dn_cfg=dict( # TODO: Move to model.train_cfg ? + label_noise_scale=0.5, + box_noise_scale=1.0, # 0.4 for DN-DETR + group_cfg=dict(dynamic=True, num_groups=None, + num_dn_queries=100)), # TODO: half num_dn_queries + # training and testing settings + train_cfg=None, + test_cfg=dict(max_per_img=300)) + +test_pipeline = [ + dict( + type='LoadImageFromFile', backend_args=None, + imdecode_backend='pillow'), + dict( + type='FixScaleResize', + scale=(800, 1333), + keep_ratio=True, + backend='pillow'), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'text', 'custom_entities', + 'tokens_positive')) +] + +val_dataloader = dict( + dataset=dict(pipeline=test_pipeline, return_classes=True)) +test_dataloader = val_dataloader diff --git a/mmdetection/configs/grounding_dino/lvis/grounding_dino_swin-b_pretrain_zeroshot_lvis.py b/mmdetection/configs/grounding_dino/lvis/grounding_dino_swin-b_pretrain_zeroshot_lvis.py new file mode 100644 index 00000000..60841590 --- /dev/null +++ b/mmdetection/configs/grounding_dino/lvis/grounding_dino_swin-b_pretrain_zeroshot_lvis.py @@ -0,0 +1,14 @@ +_base_ = './grounding_dino_swin-t_pretrain_zeroshot_lvis.py' + +model = dict( + type='GroundingDINO', + backbone=dict( + pretrain_img_size=384, + embed_dims=128, + depths=[2, 2, 18, 2], + num_heads=[4, 8, 16, 32], + window_size=12, + drop_path_rate=0.3, + patch_norm=True), + neck=dict(in_channels=[256, 512, 1024]), +) diff --git a/mmdetection/configs/grounding_dino/lvis/grounding_dino_swin-b_pretrain_zeroshot_mini-lvis.py b/mmdetection/configs/grounding_dino/lvis/grounding_dino_swin-b_pretrain_zeroshot_mini-lvis.py new file mode 100644 index 00000000..68467a72 --- /dev/null +++ b/mmdetection/configs/grounding_dino/lvis/grounding_dino_swin-b_pretrain_zeroshot_mini-lvis.py @@ -0,0 +1,14 @@ +_base_ = './grounding_dino_swin-t_pretrain_zeroshot_mini-lvis.py' + +model = dict( + type='GroundingDINO', + backbone=dict( + pretrain_img_size=384, + embed_dims=128, + depths=[2, 2, 18, 2], + num_heads=[4, 8, 16, 32], + window_size=12, + drop_path_rate=0.3, + patch_norm=True), + neck=dict(in_channels=[256, 512, 1024]), +) diff --git a/mmdetection/configs/grounding_dino/lvis/grounding_dino_swin-t_pretrain_zeroshot_lvis.py b/mmdetection/configs/grounding_dino/lvis/grounding_dino_swin-t_pretrain_zeroshot_lvis.py new file mode 100644 index 00000000..3d05f0ce --- /dev/null +++ b/mmdetection/configs/grounding_dino/lvis/grounding_dino_swin-t_pretrain_zeroshot_lvis.py @@ -0,0 +1,24 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365_goldg_cap4m.py' + +model = dict(test_cfg=dict( + max_per_img=300, + chunked_size=40, +)) + +dataset_type = 'LVISV1Dataset' +data_root = 'data/coco/' + +val_dataloader = dict( + dataset=dict( + data_root=data_root, + type=dataset_type, + ann_file='annotations/lvis_od_val.json', + data_prefix=dict(img=''))) +test_dataloader = val_dataloader + +# numpy < 1.24.0 +val_evaluator = dict( + _delete_=True, + type='LVISFixedAPMetric', + ann_file=data_root + 'annotations/lvis_od_val.json') +test_evaluator = val_evaluator diff --git a/mmdetection/configs/grounding_dino/lvis/grounding_dino_swin-t_pretrain_zeroshot_mini-lvis.py b/mmdetection/configs/grounding_dino/lvis/grounding_dino_swin-t_pretrain_zeroshot_mini-lvis.py new file mode 100644 index 00000000..0aac6cf3 --- /dev/null +++ b/mmdetection/configs/grounding_dino/lvis/grounding_dino_swin-t_pretrain_zeroshot_mini-lvis.py @@ -0,0 +1,25 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365_goldg_cap4m.py' + +model = dict(test_cfg=dict( + max_per_img=300, + chunked_size=40, +)) + +dataset_type = 'LVISV1Dataset' +data_root = 'data/coco/' + +val_dataloader = dict( + dataset=dict( + data_root=data_root, + type=dataset_type, + ann_file='annotations/lvis_v1_minival_inserted_image_name.json', + data_prefix=dict(img=''))) +test_dataloader = val_dataloader + +# numpy < 1.24.0 +val_evaluator = dict( + _delete_=True, + type='LVISFixedAPMetric', + ann_file=data_root + + 'annotations/lvis_v1_minival_inserted_image_name.json') +test_evaluator = val_evaluator diff --git a/mmdetection/configs/grounding_dino/metafile.yml b/mmdetection/configs/grounding_dino/metafile.yml new file mode 100644 index 00000000..dcb5ebf8 --- /dev/null +++ b/mmdetection/configs/grounding_dino/metafile.yml @@ -0,0 +1,67 @@ +Collections: + - Name: Grounding DINO + Metadata: + Training Data: Objects365, GoldG, CC3M and COCO + Training Techniques: + - AdamW + - Multi Scale Train + - Gradient Clip + Training Resources: 3090 GPUs + Architecture: + - Swin Transformer + - BERT + Paper: + URL: https://arxiv.org/abs/2303.05499 + Title: 'Grounding DINO: Marrying DINO with Grounded Pre-Training for Open-Set Object Detection +' + README: configs/grounding_dino/README.md + Code: + URL: + Version: v3.0.0 + +Models: + - Name: grounding_dino_swin-t_pretrain_obj365_goldg_cap4m + In Collection: Grounding DINO + Config: configs/grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_cap4m.py + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 48.5 + Weights: https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/groundingdino_swint_ogc_mmdet-822d7e9d.pth + - Name: grounding_dino_swin-b_pretrain_mixeddata + In Collection: Grounding DINO + Config: configs/grounding_dino/grounding_dino_swin-b_pretrain_mixeddata.py + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 56.9 + Weights: https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/groundingdino_swinb_cogcoor_mmdet-55949c9c.pth + - Name: grounding_dino_swin-t_finetune_16xb2_1x_coco + In Collection: Grounding DINO + Config: configs/grounding_dino/grounding_dino_swin-t_finetune_16xb2_1x_coco.py + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 58.1 + Weights: https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/grounding_dino_swin-t_finetune_16xb2_1x_coco/grounding_dino_swin-t_finetune_16xb2_1x_coco_20230921_152544-5f234b20.pth + - Name: grounding_dino_swin-b_finetune_16xb2_1x_coco + In Collection: Grounding DINO + Config: configs/grounding_dino/grounding_dino_swin-b_finetune_16xb2_1x_coco.py + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 59.7 + Weights: https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/grounding_dino_swin-b_finetune_16xb2_1x_coco/grounding_dino_swin-b_finetune_16xb2_1x_coco_20230921_153201-f219e0c0.pth + - Name: grounding_dino_r50_scratch_8xb2_1x_coco + In Collection: Grounding DINO + Config: configs/grounding_dino/grounding_dino_r50_scratch_8xb2_1x_coco.py + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 48.9 + Weights: https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/grounding_dino_r50_scratch_8xb2_1x_coco/grounding_dino_r50_scratch_1x_coco-fe0002f2.pth diff --git a/mmdetection/configs/grounding_dino/odinw/grounding_dino_swin-b_pretrain_odinw13.py b/mmdetection/configs/grounding_dino/odinw/grounding_dino_swin-b_pretrain_odinw13.py new file mode 100644 index 00000000..65a6bc2a --- /dev/null +++ b/mmdetection/configs/grounding_dino/odinw/grounding_dino_swin-b_pretrain_odinw13.py @@ -0,0 +1,338 @@ +_base_ = '../grounding_dino_swin-b_pretrain_mixeddata.py' + +dataset_type = 'CocoDataset' +data_root = 'data/odinw/' + +base_test_pipeline = _base_.test_pipeline +base_test_pipeline[-1]['meta_keys'] = ('img_id', 'img_path', 'ori_shape', + 'img_shape', 'scale_factor', 'text', + 'custom_entities', 'caption_prompt') + +# ---------------------1 AerialMaritimeDrone---------------------# +class_name = ('boat', 'car', 'dock', 'jetski', 'lift') +metainfo = dict(classes=class_name) +_data_root = data_root + 'AerialMaritimeDrone/large/' +dataset_AerialMaritimeDrone = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + test_mode=True, + pipeline=base_test_pipeline, + return_classes=True) +val_evaluator_AerialMaritimeDrone = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------2 Aquarium---------------------# +class_name = ('fish', 'jellyfish', 'penguin', 'puffin', 'shark', 'starfish', + 'stingray') +metainfo = dict(classes=class_name) +_data_root = data_root + 'Aquarium/Aquarium Combined.v2-raw-1024.coco/' + +caption_prompt = None +# caption_prompt = { +# 'penguin': { +# 'suffix': ', which is black and white' +# }, +# 'puffin': { +# 'suffix': ' with orange beaks' +# }, +# 'stingray': { +# 'suffix': ' which is flat and round' +# }, +# } +dataset_Aquarium = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_Aquarium = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------3 CottontailRabbits---------------------# +class_name = ('Cottontail-Rabbit', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'CottontailRabbits/' + +caption_prompt = None +# caption_prompt = {'Cottontail-Rabbit': {'name': 'rabbit'}} + +dataset_CottontailRabbits = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_CottontailRabbits = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------4 EgoHands---------------------# +class_name = ('hand', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'EgoHands/generic/' + +caption_prompt = None +# caption_prompt = {'hand': {'suffix': ' of a person'}} + +dataset_EgoHands = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_EgoHands = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------5 NorthAmericaMushrooms---------------------# +class_name = ('CoW', 'chanterelle') +metainfo = dict(classes=class_name) +_data_root = data_root + 'NorthAmericaMushrooms/North American Mushrooms.v1-416x416.coco/' # noqa + +caption_prompt = None +# caption_prompt = { +# 'CoW': { +# 'name': 'flat mushroom' +# }, +# 'chanterelle': { +# 'name': 'yellow mushroom' +# } +# } + +dataset_NorthAmericaMushrooms = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_NorthAmericaMushrooms = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------6 Packages---------------------# +class_name = ('package', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'Packages/Raw/' + +caption_prompt = None +# caption_prompt = { +# 'package': { +# 'prefix': 'there is a ', +# 'suffix': ' on the porch' +# } +# } + +dataset_Packages = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_Packages = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------7 PascalVOC---------------------# +class_name = ('aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', + 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', + 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', + 'tvmonitor') +metainfo = dict(classes=class_name) +_data_root = data_root + 'PascalVOC/' +dataset_PascalVOC = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_PascalVOC = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------8 pistols---------------------# +class_name = ('pistol', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'pistols/export/' +dataset_pistols = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='val_annotations_without_background.json', + data_prefix=dict(img=''), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_pistols = dict( + type='CocoMetric', + ann_file=_data_root + 'val_annotations_without_background.json', + metric='bbox') + +# ---------------------9 pothole---------------------# +class_name = ('pothole', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'pothole/' + +caption_prompt = None +# caption_prompt = { +# 'pothole': { +# 'prefix': 'there are some ', +# 'name': 'holes', +# 'suffix': ' on the road' +# } +# } + +dataset_pothole = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_pothole = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------10 Raccoon---------------------# +class_name = ('raccoon', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'Raccoon/Raccoon.v2-raw.coco/' +dataset_Raccoon = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_Raccoon = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------11 ShellfishOpenImages---------------------# +class_name = ('Crab', 'Lobster', 'Shrimp') +metainfo = dict(classes=class_name) +_data_root = data_root + 'ShellfishOpenImages/raw/' +dataset_ShellfishOpenImages = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_ShellfishOpenImages = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------12 thermalDogsAndPeople---------------------# +class_name = ('dog', 'person') +metainfo = dict(classes=class_name) +_data_root = data_root + 'thermalDogsAndPeople/' +dataset_thermalDogsAndPeople = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_thermalDogsAndPeople = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------13 VehiclesOpenImages---------------------# +class_name = ('Ambulance', 'Bus', 'Car', 'Motorcycle', 'Truck') +metainfo = dict(classes=class_name) +_data_root = data_root + 'VehiclesOpenImages/416x416/' +dataset_VehiclesOpenImages = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_VehiclesOpenImages = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# --------------------- Config---------------------# +dataset_prefixes = [ + 'AerialMaritimeDrone', 'Aquarium', 'CottontailRabbits', 'EgoHands', + 'NorthAmericaMushrooms', 'Packages', 'PascalVOC', 'pistols', 'pothole', + 'Raccoon', 'ShellfishOpenImages', 'thermalDogsAndPeople', + 'VehiclesOpenImages' +] +datasets = [ + dataset_AerialMaritimeDrone, dataset_Aquarium, dataset_CottontailRabbits, + dataset_EgoHands, dataset_NorthAmericaMushrooms, dataset_Packages, + dataset_PascalVOC, dataset_pistols, dataset_pothole, dataset_Raccoon, + dataset_ShellfishOpenImages, dataset_thermalDogsAndPeople, + dataset_VehiclesOpenImages +] +metrics = [ + val_evaluator_AerialMaritimeDrone, val_evaluator_Aquarium, + val_evaluator_CottontailRabbits, val_evaluator_EgoHands, + val_evaluator_NorthAmericaMushrooms, val_evaluator_Packages, + val_evaluator_PascalVOC, val_evaluator_pistols, val_evaluator_pothole, + val_evaluator_Raccoon, val_evaluator_ShellfishOpenImages, + val_evaluator_thermalDogsAndPeople, val_evaluator_VehiclesOpenImages +] + +# -------------------------------------------------# +val_dataloader = dict( + dataset=dict(_delete_=True, type='ConcatDataset', datasets=datasets)) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + type='MultiDatasetsEvaluator', + metrics=metrics, + dataset_prefixes=dataset_prefixes) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/grounding_dino/odinw/grounding_dino_swin-b_pretrain_odinw35.py b/mmdetection/configs/grounding_dino/odinw/grounding_dino_swin-b_pretrain_odinw35.py new file mode 100644 index 00000000..e73cd8e6 --- /dev/null +++ b/mmdetection/configs/grounding_dino/odinw/grounding_dino_swin-b_pretrain_odinw35.py @@ -0,0 +1,796 @@ +_base_ = '../grounding_dino_swin-b_pretrain_mixeddata.py' + +dataset_type = 'CocoDataset' +data_root = 'data/odinw/' + +base_test_pipeline = _base_.test_pipeline +base_test_pipeline[-1]['meta_keys'] = ('img_id', 'img_path', 'ori_shape', + 'img_shape', 'scale_factor', 'text', + 'custom_entities', 'caption_prompt') + +# ---------------------1 AerialMaritimeDrone_large---------------------# +class_name = ('boat', 'car', 'dock', 'jetski', 'lift') +metainfo = dict(classes=class_name) +_data_root = data_root + 'AerialMaritimeDrone/large/' +dataset_AerialMaritimeDrone_large = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_AerialMaritimeDrone_large = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------2 AerialMaritimeDrone_tiled---------------------# +class_name = ('boat', 'car', 'dock', 'jetski', 'lift') +metainfo = dict(classes=class_name) +_data_root = data_root + 'AerialMaritimeDrone/tiled/' +dataset_AerialMaritimeDrone_tiled = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_AerialMaritimeDrone_tiled = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------3 AmericanSignLanguageLetters---------------------# +class_name = ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', + 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z') +metainfo = dict(classes=class_name) +_data_root = data_root + 'AmericanSignLanguageLetters/American Sign Language Letters.v1-v1.coco/' # noqa +dataset_AmericanSignLanguageLetters = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_AmericanSignLanguageLetters = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------4 Aquarium---------------------# +class_name = ('fish', 'jellyfish', 'penguin', 'puffin', 'shark', 'starfish', + 'stingray') +metainfo = dict(classes=class_name) +_data_root = data_root + 'Aquarium/Aquarium Combined.v2-raw-1024.coco/' +dataset_Aquarium = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_Aquarium = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------5 BCCD---------------------# +class_name = ('Platelets', 'RBC', 'WBC') +metainfo = dict(classes=class_name) +_data_root = data_root + 'BCCD/BCCD.v3-raw.coco/' +dataset_BCCD = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_BCCD = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------6 boggleBoards---------------------# +class_name = ('Q', 'a', 'an', 'b', 'c', 'd', 'e', 'er', 'f', 'g', 'h', 'he', + 'i', 'in', 'j', 'k', 'l', 'm', 'n', 'o', 'o ', 'p', 'q', 'qu', + 'r', 's', 't', 't\\', 'th', 'u', 'v', 'w', 'wild', 'x', 'y', 'z') +metainfo = dict(classes=class_name) +_data_root = data_root + 'boggleBoards/416x416AutoOrient/export/' +dataset_boggleBoards = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='val_annotations_without_background.json', + data_prefix=dict(img=''), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_boggleBoards = dict( + type='CocoMetric', + ann_file=_data_root + 'val_annotations_without_background.json', + metric='bbox') + +# ---------------------7 brackishUnderwater---------------------# +class_name = ('crab', 'fish', 'jellyfish', 'shrimp', 'small_fish', 'starfish') +metainfo = dict(classes=class_name) +_data_root = data_root + 'brackishUnderwater/960x540/' +dataset_brackishUnderwater = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_brackishUnderwater = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------8 ChessPieces---------------------# +class_name = (' ', 'black bishop', 'black king', 'black knight', 'black pawn', + 'black queen', 'black rook', 'white bishop', 'white king', + 'white knight', 'white pawn', 'white queen', 'white rook') +metainfo = dict(classes=class_name) +_data_root = data_root + 'ChessPieces/Chess Pieces.v23-raw.coco/' +dataset_ChessPieces = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/new_annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_ChessPieces = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/new_annotations_without_background.json', + metric='bbox') + +# ---------------------9 CottontailRabbits---------------------# +class_name = ('rabbit', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'CottontailRabbits/' +dataset_CottontailRabbits = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/new_annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_CottontailRabbits = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/new_annotations_without_background.json', + metric='bbox') + +# ---------------------10 dice---------------------# +class_name = ('1', '2', '3', '4', '5', '6') +metainfo = dict(classes=class_name) +_data_root = data_root + 'dice/mediumColor/export/' +dataset_dice = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='val_annotations_without_background.json', + data_prefix=dict(img=''), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_dice = dict( + type='CocoMetric', + ann_file=_data_root + 'val_annotations_without_background.json', + metric='bbox') + +# ---------------------11 DroneControl---------------------# +class_name = ('follow', 'follow_hand', 'land', 'land_hand', 'null', 'object', + 'takeoff', 'takeoff-hand') +metainfo = dict(classes=class_name) +_data_root = data_root + 'DroneControl/Drone Control.v3-raw.coco/' +dataset_DroneControl = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_DroneControl = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------12 EgoHands_generic---------------------# +class_name = ('hand', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'EgoHands/generic/' +caption_prompt = {'hand': {'suffix': ' of a person'}} +dataset_EgoHands_generic = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + # NOTE w. prompt 0.548; wo. prompt 0.764 + # caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_EgoHands_generic = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------13 EgoHands_specific---------------------# +class_name = ('myleft', 'myright', 'yourleft', 'yourright') +metainfo = dict(classes=class_name) +_data_root = data_root + 'EgoHands/specific/' +dataset_EgoHands_specific = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_EgoHands_specific = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------14 HardHatWorkers---------------------# +class_name = ('head', 'helmet', 'person') +metainfo = dict(classes=class_name) +_data_root = data_root + 'HardHatWorkers/raw/' +dataset_HardHatWorkers = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_HardHatWorkers = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------15 MaskWearing---------------------# +class_name = ('mask', 'no-mask') +metainfo = dict(classes=class_name) +_data_root = data_root + 'MaskWearing/raw/' +dataset_MaskWearing = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_MaskWearing = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------16 MountainDewCommercial---------------------# +class_name = ('bottle', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'MountainDewCommercial/' +dataset_MountainDewCommercial = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_MountainDewCommercial = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------17 NorthAmericaMushrooms---------------------# +class_name = ('flat mushroom', 'yellow mushroom') +metainfo = dict(classes=class_name) +_data_root = data_root + 'NorthAmericaMushrooms/North American Mushrooms.v1-416x416.coco/' # noqa +dataset_NorthAmericaMushrooms = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/new_annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_NorthAmericaMushrooms = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/new_annotations_without_background.json', + metric='bbox') + +# ---------------------18 openPoetryVision---------------------# +class_name = ('American Typewriter', 'Andale Mono', 'Apple Chancery', 'Arial', + 'Avenir', 'Baskerville', 'Big Caslon', 'Bradley Hand', + 'Brush Script MT', 'Chalkboard', 'Comic Sans MS', 'Copperplate', + 'Courier', 'Didot', 'Futura', 'Geneva', 'Georgia', 'Gill Sans', + 'Helvetica', 'Herculanum', 'Impact', 'Kefa', 'Lucida Grande', + 'Luminari', 'Marker Felt', 'Menlo', 'Monaco', 'Noteworthy', + 'Optima', 'PT Sans', 'PT Serif', 'Palatino', 'Papyrus', + 'Phosphate', 'Rockwell', 'SF Pro', 'SignPainter', 'Skia', + 'Snell Roundhand', 'Tahoma', 'Times New Roman', 'Trebuchet MS', + 'Verdana') +metainfo = dict(classes=class_name) +_data_root = data_root + 'openPoetryVision/512x512/' +dataset_openPoetryVision = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_openPoetryVision = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------19 OxfordPets_by_breed---------------------# +class_name = ('cat-Abyssinian', 'cat-Bengal', 'cat-Birman', 'cat-Bombay', + 'cat-British_Shorthair', 'cat-Egyptian_Mau', 'cat-Maine_Coon', + 'cat-Persian', 'cat-Ragdoll', 'cat-Russian_Blue', 'cat-Siamese', + 'cat-Sphynx', 'dog-american_bulldog', + 'dog-american_pit_bull_terrier', 'dog-basset_hound', + 'dog-beagle', 'dog-boxer', 'dog-chihuahua', + 'dog-english_cocker_spaniel', 'dog-english_setter', + 'dog-german_shorthaired', 'dog-great_pyrenees', 'dog-havanese', + 'dog-japanese_chin', 'dog-keeshond', 'dog-leonberger', + 'dog-miniature_pinscher', 'dog-newfoundland', 'dog-pomeranian', + 'dog-pug', 'dog-saint_bernard', 'dog-samoyed', + 'dog-scottish_terrier', 'dog-shiba_inu', + 'dog-staffordshire_bull_terrier', 'dog-wheaten_terrier', + 'dog-yorkshire_terrier') +metainfo = dict(classes=class_name) +_data_root = data_root + 'OxfordPets/by-breed/' # noqa +dataset_OxfordPets_by_breed = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_OxfordPets_by_breed = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------20 OxfordPets_by_species---------------------# +class_name = ('cat', 'dog') +metainfo = dict(classes=class_name) +_data_root = data_root + 'OxfordPets/by-species/' # noqa +dataset_OxfordPets_by_species = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_OxfordPets_by_species = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------21 PKLot---------------------# +class_name = ('space-empty', 'space-occupied') +metainfo = dict(classes=class_name) +_data_root = data_root + 'PKLot/640/' # noqa +dataset_PKLot = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_PKLot = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------22 Packages---------------------# +class_name = ('package', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'Packages/Raw/' +caption_prompt = { + 'package': { + 'prefix': 'there is a ', + 'suffix': ' on the porch' + } +} +dataset_Packages = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, # NOTE w. prompt 0.728; wo. prompt 0.670 + test_mode=True, + return_classes=True) +val_evaluator_Packages = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------23 PascalVOC---------------------# +class_name = ('aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', + 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', + 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', + 'tvmonitor') +metainfo = dict(classes=class_name) +_data_root = data_root + 'PascalVOC/' +dataset_PascalVOC = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_PascalVOC = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------24 pistols---------------------# +class_name = ('pistol', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'pistols/export/' +dataset_pistols = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='val_annotations_without_background.json', + data_prefix=dict(img=''), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_pistols = dict( + type='CocoMetric', + ann_file=_data_root + 'val_annotations_without_background.json', + metric='bbox') + +# ---------------------25 plantdoc---------------------# +class_name = ('Apple Scab Leaf', 'Apple leaf', 'Apple rust leaf', + 'Bell_pepper leaf', 'Bell_pepper leaf spot', 'Blueberry leaf', + 'Cherry leaf', 'Corn Gray leaf spot', 'Corn leaf blight', + 'Corn rust leaf', 'Peach leaf', 'Potato leaf', + 'Potato leaf early blight', 'Potato leaf late blight', + 'Raspberry leaf', 'Soyabean leaf', 'Soybean leaf', + 'Squash Powdery mildew leaf', 'Strawberry leaf', + 'Tomato Early blight leaf', 'Tomato Septoria leaf spot', + 'Tomato leaf', 'Tomato leaf bacterial spot', + 'Tomato leaf late blight', 'Tomato leaf mosaic virus', + 'Tomato leaf yellow virus', 'Tomato mold leaf', + 'Tomato two spotted spider mites leaf', 'grape leaf', + 'grape leaf black rot') +metainfo = dict(classes=class_name) +_data_root = data_root + 'plantdoc/416x416/' +dataset_plantdoc = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_plantdoc = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------26 pothole---------------------# +class_name = ('pothole', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'pothole/' +caption_prompt = { + 'pothole': { + 'name': 'holes', + 'prefix': 'there are some ', + 'suffix': ' on the road' + } +} +dataset_pothole = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + # NOTE w. prompt 0.221; wo. prompt 0.478 + # caption_prompt=caption_prompt, + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_pothole = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------27 Raccoon---------------------# +class_name = ('raccoon', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'Raccoon/Raccoon.v2-raw.coco/' +dataset_Raccoon = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_Raccoon = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------28 selfdrivingCar---------------------# +class_name = ('biker', 'car', 'pedestrian', 'trafficLight', + 'trafficLight-Green', 'trafficLight-GreenLeft', + 'trafficLight-Red', 'trafficLight-RedLeft', + 'trafficLight-Yellow', 'trafficLight-YellowLeft', 'truck') +metainfo = dict(classes=class_name) +_data_root = data_root + 'selfdrivingCar/fixedLarge/export/' +dataset_selfdrivingCar = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='val_annotations_without_background.json', + data_prefix=dict(img=''), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_selfdrivingCar = dict( + type='CocoMetric', + ann_file=_data_root + 'val_annotations_without_background.json', + metric='bbox') + +# ---------------------29 ShellfishOpenImages---------------------# +class_name = ('Crab', 'Lobster', 'Shrimp') +metainfo = dict(classes=class_name) +_data_root = data_root + 'ShellfishOpenImages/raw/' +dataset_ShellfishOpenImages = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_ShellfishOpenImages = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------30 ThermalCheetah---------------------# +class_name = ('cheetah', 'human') +metainfo = dict(classes=class_name) +_data_root = data_root + 'ThermalCheetah/' +dataset_ThermalCheetah = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_ThermalCheetah = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------31 thermalDogsAndPeople---------------------# +class_name = ('dog', 'person') +metainfo = dict(classes=class_name) +_data_root = data_root + 'thermalDogsAndPeople/' +dataset_thermalDogsAndPeople = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_thermalDogsAndPeople = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------32 UnoCards---------------------# +class_name = ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', + '12', '13', '14') +metainfo = dict(classes=class_name) +_data_root = data_root + 'UnoCards/raw/' +dataset_UnoCards = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_UnoCards = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------33 VehiclesOpenImages---------------------# +class_name = ('Ambulance', 'Bus', 'Car', 'Motorcycle', 'Truck') +metainfo = dict(classes=class_name) +_data_root = data_root + 'VehiclesOpenImages/416x416/' +dataset_VehiclesOpenImages = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_VehiclesOpenImages = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------34 WildfireSmoke---------------------# +class_name = ('smoke', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'WildfireSmoke/' +dataset_WildfireSmoke = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_WildfireSmoke = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------35 websiteScreenshots---------------------# +class_name = ('button', 'field', 'heading', 'iframe', 'image', 'label', 'link', + 'text') +metainfo = dict(classes=class_name) +_data_root = data_root + 'websiteScreenshots/' +dataset_websiteScreenshots = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_websiteScreenshots = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# --------------------- Config---------------------# + +dataset_prefixes = [ + 'AerialMaritimeDrone_large', + 'AerialMaritimeDrone_tiled', + 'AmericanSignLanguageLetters', + 'Aquarium', + 'BCCD', + 'boggleBoards', + 'brackishUnderwater', + 'ChessPieces', + 'CottontailRabbits', + 'dice', + 'DroneControl', + 'EgoHands_generic', + 'EgoHands_specific', + 'HardHatWorkers', + 'MaskWearing', + 'MountainDewCommercial', + 'NorthAmericaMushrooms', + 'openPoetryVision', + 'OxfordPets_by_breed', + 'OxfordPets_by_species', + 'PKLot', + 'Packages', + 'PascalVOC', + 'pistols', + 'plantdoc', + 'pothole', + 'Raccoons', + 'selfdrivingCar', + 'ShellfishOpenImages', + 'ThermalCheetah', + 'thermalDogsAndPeople', + 'UnoCards', + 'VehiclesOpenImages', + 'WildfireSmoke', + 'websiteScreenshots', +] + +datasets = [ + dataset_AerialMaritimeDrone_large, dataset_AerialMaritimeDrone_tiled, + dataset_AmericanSignLanguageLetters, dataset_Aquarium, dataset_BCCD, + dataset_boggleBoards, dataset_brackishUnderwater, dataset_ChessPieces, + dataset_CottontailRabbits, dataset_dice, dataset_DroneControl, + dataset_EgoHands_generic, dataset_EgoHands_specific, + dataset_HardHatWorkers, dataset_MaskWearing, dataset_MountainDewCommercial, + dataset_NorthAmericaMushrooms, dataset_openPoetryVision, + dataset_OxfordPets_by_breed, dataset_OxfordPets_by_species, dataset_PKLot, + dataset_Packages, dataset_PascalVOC, dataset_pistols, dataset_plantdoc, + dataset_pothole, dataset_Raccoon, dataset_selfdrivingCar, + dataset_ShellfishOpenImages, dataset_ThermalCheetah, + dataset_thermalDogsAndPeople, dataset_UnoCards, dataset_VehiclesOpenImages, + dataset_WildfireSmoke, dataset_websiteScreenshots +] + +metrics = [ + val_evaluator_AerialMaritimeDrone_large, + val_evaluator_AerialMaritimeDrone_tiled, + val_evaluator_AmericanSignLanguageLetters, val_evaluator_Aquarium, + val_evaluator_BCCD, val_evaluator_boggleBoards, + val_evaluator_brackishUnderwater, val_evaluator_ChessPieces, + val_evaluator_CottontailRabbits, val_evaluator_dice, + val_evaluator_DroneControl, val_evaluator_EgoHands_generic, + val_evaluator_EgoHands_specific, val_evaluator_HardHatWorkers, + val_evaluator_MaskWearing, val_evaluator_MountainDewCommercial, + val_evaluator_NorthAmericaMushrooms, val_evaluator_openPoetryVision, + val_evaluator_OxfordPets_by_breed, val_evaluator_OxfordPets_by_species, + val_evaluator_PKLot, val_evaluator_Packages, val_evaluator_PascalVOC, + val_evaluator_pistols, val_evaluator_plantdoc, val_evaluator_pothole, + val_evaluator_Raccoon, val_evaluator_selfdrivingCar, + val_evaluator_ShellfishOpenImages, val_evaluator_ThermalCheetah, + val_evaluator_thermalDogsAndPeople, val_evaluator_UnoCards, + val_evaluator_VehiclesOpenImages, val_evaluator_WildfireSmoke, + val_evaluator_websiteScreenshots +] + +# -------------------------------------------------# +val_dataloader = dict( + dataset=dict(_delete_=True, type='ConcatDataset', datasets=datasets)) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + type='MultiDatasetsEvaluator', + metrics=metrics, + dataset_prefixes=dataset_prefixes) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/grounding_dino/odinw/grounding_dino_swin-t_pretrain_odinw13.py b/mmdetection/configs/grounding_dino/odinw/grounding_dino_swin-t_pretrain_odinw13.py new file mode 100644 index 00000000..216b8059 --- /dev/null +++ b/mmdetection/configs/grounding_dino/odinw/grounding_dino_swin-t_pretrain_odinw13.py @@ -0,0 +1,338 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365_goldg_cap4m.py' # noqa + +dataset_type = 'CocoDataset' +data_root = 'data/odinw/' + +base_test_pipeline = _base_.test_pipeline +base_test_pipeline[-1]['meta_keys'] = ('img_id', 'img_path', 'ori_shape', + 'img_shape', 'scale_factor', 'text', + 'custom_entities', 'caption_prompt') + +# ---------------------1 AerialMaritimeDrone---------------------# +class_name = ('boat', 'car', 'dock', 'jetski', 'lift') +metainfo = dict(classes=class_name) +_data_root = data_root + 'AerialMaritimeDrone/large/' +dataset_AerialMaritimeDrone = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + test_mode=True, + pipeline=base_test_pipeline, + return_classes=True) +val_evaluator_AerialMaritimeDrone = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------2 Aquarium---------------------# +class_name = ('fish', 'jellyfish', 'penguin', 'puffin', 'shark', 'starfish', + 'stingray') +metainfo = dict(classes=class_name) +_data_root = data_root + 'Aquarium/Aquarium Combined.v2-raw-1024.coco/' + +caption_prompt = None +# caption_prompt = { +# 'penguin': { +# 'suffix': ', which is black and white' +# }, +# 'puffin': { +# 'suffix': ' with orange beaks' +# }, +# 'stingray': { +# 'suffix': ' which is flat and round' +# }, +# } +dataset_Aquarium = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_Aquarium = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------3 CottontailRabbits---------------------# +class_name = ('Cottontail-Rabbit', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'CottontailRabbits/' + +caption_prompt = None +# caption_prompt = {'Cottontail-Rabbit': {'name': 'rabbit'}} + +dataset_CottontailRabbits = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_CottontailRabbits = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------4 EgoHands---------------------# +class_name = ('hand', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'EgoHands/generic/' + +caption_prompt = None +# caption_prompt = {'hand': {'suffix': ' of a person'}} + +dataset_EgoHands = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_EgoHands = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------5 NorthAmericaMushrooms---------------------# +class_name = ('CoW', 'chanterelle') +metainfo = dict(classes=class_name) +_data_root = data_root + 'NorthAmericaMushrooms/North American Mushrooms.v1-416x416.coco/' # noqa + +caption_prompt = None +# caption_prompt = { +# 'CoW': { +# 'name': 'flat mushroom' +# }, +# 'chanterelle': { +# 'name': 'yellow mushroom' +# } +# } + +dataset_NorthAmericaMushrooms = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_NorthAmericaMushrooms = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------6 Packages---------------------# +class_name = ('package', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'Packages/Raw/' + +caption_prompt = None +# caption_prompt = { +# 'package': { +# 'prefix': 'there is a ', +# 'suffix': ' on the porch' +# } +# } + +dataset_Packages = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_Packages = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------7 PascalVOC---------------------# +class_name = ('aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', + 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', + 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', + 'tvmonitor') +metainfo = dict(classes=class_name) +_data_root = data_root + 'PascalVOC/' +dataset_PascalVOC = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_PascalVOC = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------8 pistols---------------------# +class_name = ('pistol', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'pistols/export/' +dataset_pistols = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='val_annotations_without_background.json', + data_prefix=dict(img=''), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_pistols = dict( + type='CocoMetric', + ann_file=_data_root + 'val_annotations_without_background.json', + metric='bbox') + +# ---------------------9 pothole---------------------# +class_name = ('pothole', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'pothole/' + +caption_prompt = None +# caption_prompt = { +# 'pothole': { +# 'prefix': 'there are some ', +# 'name': 'holes', +# 'suffix': ' on the road' +# } +# } + +dataset_pothole = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_pothole = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------10 Raccoon---------------------# +class_name = ('raccoon', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'Raccoon/Raccoon.v2-raw.coco/' +dataset_Raccoon = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_Raccoon = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------11 ShellfishOpenImages---------------------# +class_name = ('Crab', 'Lobster', 'Shrimp') +metainfo = dict(classes=class_name) +_data_root = data_root + 'ShellfishOpenImages/raw/' +dataset_ShellfishOpenImages = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_ShellfishOpenImages = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------12 thermalDogsAndPeople---------------------# +class_name = ('dog', 'person') +metainfo = dict(classes=class_name) +_data_root = data_root + 'thermalDogsAndPeople/' +dataset_thermalDogsAndPeople = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_thermalDogsAndPeople = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------13 VehiclesOpenImages---------------------# +class_name = ('Ambulance', 'Bus', 'Car', 'Motorcycle', 'Truck') +metainfo = dict(classes=class_name) +_data_root = data_root + 'VehiclesOpenImages/416x416/' +dataset_VehiclesOpenImages = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_VehiclesOpenImages = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# --------------------- Config---------------------# +dataset_prefixes = [ + 'AerialMaritimeDrone', 'Aquarium', 'CottontailRabbits', 'EgoHands', + 'NorthAmericaMushrooms', 'Packages', 'PascalVOC', 'pistols', 'pothole', + 'Raccoon', 'ShellfishOpenImages', 'thermalDogsAndPeople', + 'VehiclesOpenImages' +] +datasets = [ + dataset_AerialMaritimeDrone, dataset_Aquarium, dataset_CottontailRabbits, + dataset_EgoHands, dataset_NorthAmericaMushrooms, dataset_Packages, + dataset_PascalVOC, dataset_pistols, dataset_pothole, dataset_Raccoon, + dataset_ShellfishOpenImages, dataset_thermalDogsAndPeople, + dataset_VehiclesOpenImages +] +metrics = [ + val_evaluator_AerialMaritimeDrone, val_evaluator_Aquarium, + val_evaluator_CottontailRabbits, val_evaluator_EgoHands, + val_evaluator_NorthAmericaMushrooms, val_evaluator_Packages, + val_evaluator_PascalVOC, val_evaluator_pistols, val_evaluator_pothole, + val_evaluator_Raccoon, val_evaluator_ShellfishOpenImages, + val_evaluator_thermalDogsAndPeople, val_evaluator_VehiclesOpenImages +] + +# -------------------------------------------------# +val_dataloader = dict( + dataset=dict(_delete_=True, type='ConcatDataset', datasets=datasets)) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + type='MultiDatasetsEvaluator', + metrics=metrics, + dataset_prefixes=dataset_prefixes) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/grounding_dino/odinw/grounding_dino_swin-t_pretrain_odinw35.py b/mmdetection/configs/grounding_dino/odinw/grounding_dino_swin-t_pretrain_odinw35.py new file mode 100644 index 00000000..3df0394a --- /dev/null +++ b/mmdetection/configs/grounding_dino/odinw/grounding_dino_swin-t_pretrain_odinw35.py @@ -0,0 +1,796 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365_goldg_cap4m.py' # noqa + +dataset_type = 'CocoDataset' +data_root = 'data/odinw/' + +base_test_pipeline = _base_.test_pipeline +base_test_pipeline[-1]['meta_keys'] = ('img_id', 'img_path', 'ori_shape', + 'img_shape', 'scale_factor', 'text', + 'custom_entities', 'caption_prompt') + +# ---------------------1 AerialMaritimeDrone_large---------------------# +class_name = ('boat', 'car', 'dock', 'jetski', 'lift') +metainfo = dict(classes=class_name) +_data_root = data_root + 'AerialMaritimeDrone/large/' +dataset_AerialMaritimeDrone_large = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_AerialMaritimeDrone_large = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------2 AerialMaritimeDrone_tiled---------------------# +class_name = ('boat', 'car', 'dock', 'jetski', 'lift') +metainfo = dict(classes=class_name) +_data_root = data_root + 'AerialMaritimeDrone/tiled/' +dataset_AerialMaritimeDrone_tiled = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_AerialMaritimeDrone_tiled = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------3 AmericanSignLanguageLetters---------------------# +class_name = ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', + 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z') +metainfo = dict(classes=class_name) +_data_root = data_root + 'AmericanSignLanguageLetters/American Sign Language Letters.v1-v1.coco/' # noqa +dataset_AmericanSignLanguageLetters = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_AmericanSignLanguageLetters = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------4 Aquarium---------------------# +class_name = ('fish', 'jellyfish', 'penguin', 'puffin', 'shark', 'starfish', + 'stingray') +metainfo = dict(classes=class_name) +_data_root = data_root + 'Aquarium/Aquarium Combined.v2-raw-1024.coco/' +dataset_Aquarium = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_Aquarium = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------5 BCCD---------------------# +class_name = ('Platelets', 'RBC', 'WBC') +metainfo = dict(classes=class_name) +_data_root = data_root + 'BCCD/BCCD.v3-raw.coco/' +dataset_BCCD = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_BCCD = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------6 boggleBoards---------------------# +class_name = ('Q', 'a', 'an', 'b', 'c', 'd', 'e', 'er', 'f', 'g', 'h', 'he', + 'i', 'in', 'j', 'k', 'l', 'm', 'n', 'o', 'o ', 'p', 'q', 'qu', + 'r', 's', 't', 't\\', 'th', 'u', 'v', 'w', 'wild', 'x', 'y', 'z') +metainfo = dict(classes=class_name) +_data_root = data_root + 'boggleBoards/416x416AutoOrient/export/' +dataset_boggleBoards = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='val_annotations_without_background.json', + data_prefix=dict(img=''), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_boggleBoards = dict( + type='CocoMetric', + ann_file=_data_root + 'val_annotations_without_background.json', + metric='bbox') + +# ---------------------7 brackishUnderwater---------------------# +class_name = ('crab', 'fish', 'jellyfish', 'shrimp', 'small_fish', 'starfish') +metainfo = dict(classes=class_name) +_data_root = data_root + 'brackishUnderwater/960x540/' +dataset_brackishUnderwater = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_brackishUnderwater = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------8 ChessPieces---------------------# +class_name = (' ', 'black bishop', 'black king', 'black knight', 'black pawn', + 'black queen', 'black rook', 'white bishop', 'white king', + 'white knight', 'white pawn', 'white queen', 'white rook') +metainfo = dict(classes=class_name) +_data_root = data_root + 'ChessPieces/Chess Pieces.v23-raw.coco/' +dataset_ChessPieces = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/new_annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_ChessPieces = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/new_annotations_without_background.json', + metric='bbox') + +# ---------------------9 CottontailRabbits---------------------# +class_name = ('rabbit', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'CottontailRabbits/' +dataset_CottontailRabbits = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/new_annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_CottontailRabbits = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/new_annotations_without_background.json', + metric='bbox') + +# ---------------------10 dice---------------------# +class_name = ('1', '2', '3', '4', '5', '6') +metainfo = dict(classes=class_name) +_data_root = data_root + 'dice/mediumColor/export/' +dataset_dice = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='val_annotations_without_background.json', + data_prefix=dict(img=''), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_dice = dict( + type='CocoMetric', + ann_file=_data_root + 'val_annotations_without_background.json', + metric='bbox') + +# ---------------------11 DroneControl---------------------# +class_name = ('follow', 'follow_hand', 'land', 'land_hand', 'null', 'object', + 'takeoff', 'takeoff-hand') +metainfo = dict(classes=class_name) +_data_root = data_root + 'DroneControl/Drone Control.v3-raw.coco/' +dataset_DroneControl = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_DroneControl = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------12 EgoHands_generic---------------------# +class_name = ('hand', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'EgoHands/generic/' +caption_prompt = {'hand': {'suffix': ' of a person'}} +dataset_EgoHands_generic = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + # NOTE w. prompt 0.526, wo. prompt 0.608 + # caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_EgoHands_generic = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------13 EgoHands_specific---------------------# +class_name = ('myleft', 'myright', 'yourleft', 'yourright') +metainfo = dict(classes=class_name) +_data_root = data_root + 'EgoHands/specific/' +dataset_EgoHands_specific = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_EgoHands_specific = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------14 HardHatWorkers---------------------# +class_name = ('head', 'helmet', 'person') +metainfo = dict(classes=class_name) +_data_root = data_root + 'HardHatWorkers/raw/' +dataset_HardHatWorkers = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_HardHatWorkers = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------15 MaskWearing---------------------# +class_name = ('mask', 'no-mask') +metainfo = dict(classes=class_name) +_data_root = data_root + 'MaskWearing/raw/' +dataset_MaskWearing = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_MaskWearing = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------16 MountainDewCommercial---------------------# +class_name = ('bottle', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'MountainDewCommercial/' +dataset_MountainDewCommercial = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_MountainDewCommercial = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------17 NorthAmericaMushrooms---------------------# +class_name = ('flat mushroom', 'yellow mushroom') +metainfo = dict(classes=class_name) +_data_root = data_root + 'NorthAmericaMushrooms/North American Mushrooms.v1-416x416.coco/' # noqa +dataset_NorthAmericaMushrooms = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/new_annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_NorthAmericaMushrooms = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/new_annotations_without_background.json', + metric='bbox') + +# ---------------------18 openPoetryVision---------------------# +class_name = ('American Typewriter', 'Andale Mono', 'Apple Chancery', 'Arial', + 'Avenir', 'Baskerville', 'Big Caslon', 'Bradley Hand', + 'Brush Script MT', 'Chalkboard', 'Comic Sans MS', 'Copperplate', + 'Courier', 'Didot', 'Futura', 'Geneva', 'Georgia', 'Gill Sans', + 'Helvetica', 'Herculanum', 'Impact', 'Kefa', 'Lucida Grande', + 'Luminari', 'Marker Felt', 'Menlo', 'Monaco', 'Noteworthy', + 'Optima', 'PT Sans', 'PT Serif', 'Palatino', 'Papyrus', + 'Phosphate', 'Rockwell', 'SF Pro', 'SignPainter', 'Skia', + 'Snell Roundhand', 'Tahoma', 'Times New Roman', 'Trebuchet MS', + 'Verdana') +metainfo = dict(classes=class_name) +_data_root = data_root + 'openPoetryVision/512x512/' +dataset_openPoetryVision = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_openPoetryVision = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------19 OxfordPets_by_breed---------------------# +class_name = ('cat-Abyssinian', 'cat-Bengal', 'cat-Birman', 'cat-Bombay', + 'cat-British_Shorthair', 'cat-Egyptian_Mau', 'cat-Maine_Coon', + 'cat-Persian', 'cat-Ragdoll', 'cat-Russian_Blue', 'cat-Siamese', + 'cat-Sphynx', 'dog-american_bulldog', + 'dog-american_pit_bull_terrier', 'dog-basset_hound', + 'dog-beagle', 'dog-boxer', 'dog-chihuahua', + 'dog-english_cocker_spaniel', 'dog-english_setter', + 'dog-german_shorthaired', 'dog-great_pyrenees', 'dog-havanese', + 'dog-japanese_chin', 'dog-keeshond', 'dog-leonberger', + 'dog-miniature_pinscher', 'dog-newfoundland', 'dog-pomeranian', + 'dog-pug', 'dog-saint_bernard', 'dog-samoyed', + 'dog-scottish_terrier', 'dog-shiba_inu', + 'dog-staffordshire_bull_terrier', 'dog-wheaten_terrier', + 'dog-yorkshire_terrier') +metainfo = dict(classes=class_name) +_data_root = data_root + 'OxfordPets/by-breed/' # noqa +dataset_OxfordPets_by_breed = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_OxfordPets_by_breed = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------20 OxfordPets_by_species---------------------# +class_name = ('cat', 'dog') +metainfo = dict(classes=class_name) +_data_root = data_root + 'OxfordPets/by-species/' # noqa +dataset_OxfordPets_by_species = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_OxfordPets_by_species = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------21 PKLot---------------------# +class_name = ('space-empty', 'space-occupied') +metainfo = dict(classes=class_name) +_data_root = data_root + 'PKLot/640/' # noqa +dataset_PKLot = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_PKLot = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------22 Packages---------------------# +class_name = ('package', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'Packages/Raw/' +caption_prompt = { + 'package': { + 'prefix': 'there is a ', + 'suffix': ' on the porch' + } +} +dataset_Packages = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, # NOTE w. prompt 0.695; wo. prompt 0.687 + test_mode=True, + return_classes=True) +val_evaluator_Packages = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------23 PascalVOC---------------------# +class_name = ('aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', + 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', + 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', + 'tvmonitor') +metainfo = dict(classes=class_name) +_data_root = data_root + 'PascalVOC/' +dataset_PascalVOC = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_PascalVOC = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------24 pistols---------------------# +class_name = ('pistol', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'pistols/export/' +dataset_pistols = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='val_annotations_without_background.json', + data_prefix=dict(img=''), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_pistols = dict( + type='CocoMetric', + ann_file=_data_root + 'val_annotations_without_background.json', + metric='bbox') + +# ---------------------25 plantdoc---------------------# +class_name = ('Apple Scab Leaf', 'Apple leaf', 'Apple rust leaf', + 'Bell_pepper leaf', 'Bell_pepper leaf spot', 'Blueberry leaf', + 'Cherry leaf', 'Corn Gray leaf spot', 'Corn leaf blight', + 'Corn rust leaf', 'Peach leaf', 'Potato leaf', + 'Potato leaf early blight', 'Potato leaf late blight', + 'Raspberry leaf', 'Soyabean leaf', 'Soybean leaf', + 'Squash Powdery mildew leaf', 'Strawberry leaf', + 'Tomato Early blight leaf', 'Tomato Septoria leaf spot', + 'Tomato leaf', 'Tomato leaf bacterial spot', + 'Tomato leaf late blight', 'Tomato leaf mosaic virus', + 'Tomato leaf yellow virus', 'Tomato mold leaf', + 'Tomato two spotted spider mites leaf', 'grape leaf', + 'grape leaf black rot') +metainfo = dict(classes=class_name) +_data_root = data_root + 'plantdoc/416x416/' +dataset_plantdoc = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_plantdoc = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------26 pothole---------------------# +class_name = ('pothole', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'pothole/' +caption_prompt = { + 'pothole': { + 'name': 'holes', + 'prefix': 'there are some ', + 'suffix': ' on the road' + } +} +dataset_pothole = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + # NOTE w. prompt 0.137; wo. prompt 0.215 + # caption_prompt=caption_prompt, + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_pothole = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------27 Raccoon---------------------# +class_name = ('raccoon', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'Raccoon/Raccoon.v2-raw.coco/' +dataset_Raccoon = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_Raccoon = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------28 selfdrivingCar---------------------# +class_name = ('biker', 'car', 'pedestrian', 'trafficLight', + 'trafficLight-Green', 'trafficLight-GreenLeft', + 'trafficLight-Red', 'trafficLight-RedLeft', + 'trafficLight-Yellow', 'trafficLight-YellowLeft', 'truck') +metainfo = dict(classes=class_name) +_data_root = data_root + 'selfdrivingCar/fixedLarge/export/' +dataset_selfdrivingCar = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='val_annotations_without_background.json', + data_prefix=dict(img=''), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_selfdrivingCar = dict( + type='CocoMetric', + ann_file=_data_root + 'val_annotations_without_background.json', + metric='bbox') + +# ---------------------29 ShellfishOpenImages---------------------# +class_name = ('Crab', 'Lobster', 'Shrimp') +metainfo = dict(classes=class_name) +_data_root = data_root + 'ShellfishOpenImages/raw/' +dataset_ShellfishOpenImages = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_ShellfishOpenImages = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------30 ThermalCheetah---------------------# +class_name = ('cheetah', 'human') +metainfo = dict(classes=class_name) +_data_root = data_root + 'ThermalCheetah/' +dataset_ThermalCheetah = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_ThermalCheetah = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------31 thermalDogsAndPeople---------------------# +class_name = ('dog', 'person') +metainfo = dict(classes=class_name) +_data_root = data_root + 'thermalDogsAndPeople/' +dataset_thermalDogsAndPeople = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_thermalDogsAndPeople = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------32 UnoCards---------------------# +class_name = ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', + '12', '13', '14') +metainfo = dict(classes=class_name) +_data_root = data_root + 'UnoCards/raw/' +dataset_UnoCards = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_UnoCards = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------33 VehiclesOpenImages---------------------# +class_name = ('Ambulance', 'Bus', 'Car', 'Motorcycle', 'Truck') +metainfo = dict(classes=class_name) +_data_root = data_root + 'VehiclesOpenImages/416x416/' +dataset_VehiclesOpenImages = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_VehiclesOpenImages = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------34 WildfireSmoke---------------------# +class_name = ('smoke', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'WildfireSmoke/' +dataset_WildfireSmoke = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_WildfireSmoke = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------35 websiteScreenshots---------------------# +class_name = ('button', 'field', 'heading', 'iframe', 'image', 'label', 'link', + 'text') +metainfo = dict(classes=class_name) +_data_root = data_root + 'websiteScreenshots/' +dataset_websiteScreenshots = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_websiteScreenshots = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# --------------------- Config---------------------# + +dataset_prefixes = [ + 'AerialMaritimeDrone_large', + 'AerialMaritimeDrone_tiled', + 'AmericanSignLanguageLetters', + 'Aquarium', + 'BCCD', + 'boggleBoards', + 'brackishUnderwater', + 'ChessPieces', + 'CottontailRabbits', + 'dice', + 'DroneControl', + 'EgoHands_generic', + 'EgoHands_specific', + 'HardHatWorkers', + 'MaskWearing', + 'MountainDewCommercial', + 'NorthAmericaMushrooms', + 'openPoetryVision', + 'OxfordPets_by_breed', + 'OxfordPets_by_species', + 'PKLot', + 'Packages', + 'PascalVOC', + 'pistols', + 'plantdoc', + 'pothole', + 'Raccoons', + 'selfdrivingCar', + 'ShellfishOpenImages', + 'ThermalCheetah', + 'thermalDogsAndPeople', + 'UnoCards', + 'VehiclesOpenImages', + 'WildfireSmoke', + 'websiteScreenshots', +] + +datasets = [ + dataset_AerialMaritimeDrone_large, dataset_AerialMaritimeDrone_tiled, + dataset_AmericanSignLanguageLetters, dataset_Aquarium, dataset_BCCD, + dataset_boggleBoards, dataset_brackishUnderwater, dataset_ChessPieces, + dataset_CottontailRabbits, dataset_dice, dataset_DroneControl, + dataset_EgoHands_generic, dataset_EgoHands_specific, + dataset_HardHatWorkers, dataset_MaskWearing, dataset_MountainDewCommercial, + dataset_NorthAmericaMushrooms, dataset_openPoetryVision, + dataset_OxfordPets_by_breed, dataset_OxfordPets_by_species, dataset_PKLot, + dataset_Packages, dataset_PascalVOC, dataset_pistols, dataset_plantdoc, + dataset_pothole, dataset_Raccoon, dataset_selfdrivingCar, + dataset_ShellfishOpenImages, dataset_ThermalCheetah, + dataset_thermalDogsAndPeople, dataset_UnoCards, dataset_VehiclesOpenImages, + dataset_WildfireSmoke, dataset_websiteScreenshots +] + +metrics = [ + val_evaluator_AerialMaritimeDrone_large, + val_evaluator_AerialMaritimeDrone_tiled, + val_evaluator_AmericanSignLanguageLetters, val_evaluator_Aquarium, + val_evaluator_BCCD, val_evaluator_boggleBoards, + val_evaluator_brackishUnderwater, val_evaluator_ChessPieces, + val_evaluator_CottontailRabbits, val_evaluator_dice, + val_evaluator_DroneControl, val_evaluator_EgoHands_generic, + val_evaluator_EgoHands_specific, val_evaluator_HardHatWorkers, + val_evaluator_MaskWearing, val_evaluator_MountainDewCommercial, + val_evaluator_NorthAmericaMushrooms, val_evaluator_openPoetryVision, + val_evaluator_OxfordPets_by_breed, val_evaluator_OxfordPets_by_species, + val_evaluator_PKLot, val_evaluator_Packages, val_evaluator_PascalVOC, + val_evaluator_pistols, val_evaluator_plantdoc, val_evaluator_pothole, + val_evaluator_Raccoon, val_evaluator_selfdrivingCar, + val_evaluator_ShellfishOpenImages, val_evaluator_ThermalCheetah, + val_evaluator_thermalDogsAndPeople, val_evaluator_UnoCards, + val_evaluator_VehiclesOpenImages, val_evaluator_WildfireSmoke, + val_evaluator_websiteScreenshots +] + +# -------------------------------------------------# +val_dataloader = dict( + dataset=dict(_delete_=True, type='ConcatDataset', datasets=datasets)) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + type='MultiDatasetsEvaluator', + metrics=metrics, + dataset_prefixes=dataset_prefixes) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/grounding_dino/odinw/override_category.py b/mmdetection/configs/grounding_dino/odinw/override_category.py new file mode 100644 index 00000000..9ff05fc6 --- /dev/null +++ b/mmdetection/configs/grounding_dino/odinw/override_category.py @@ -0,0 +1,109 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import argparse + +import mmengine + + +def parse_args(): + parser = argparse.ArgumentParser(description='Override Category') + parser.add_argument('data_root') + return parser.parse_args() + + +def main(): + args = parse_args() + + ChessPieces = [{ + 'id': 1, + 'name': ' ', + 'supercategory': 'pieces' + }, { + 'id': 2, + 'name': 'black bishop', + 'supercategory': 'pieces' + }, { + 'id': 3, + 'name': 'black king', + 'supercategory': 'pieces' + }, { + 'id': 4, + 'name': 'black knight', + 'supercategory': 'pieces' + }, { + 'id': 5, + 'name': 'black pawn', + 'supercategory': 'pieces' + }, { + 'id': 6, + 'name': 'black queen', + 'supercategory': 'pieces' + }, { + 'id': 7, + 'name': 'black rook', + 'supercategory': 'pieces' + }, { + 'id': 8, + 'name': 'white bishop', + 'supercategory': 'pieces' + }, { + 'id': 9, + 'name': 'white king', + 'supercategory': 'pieces' + }, { + 'id': 10, + 'name': 'white knight', + 'supercategory': 'pieces' + }, { + 'id': 11, + 'name': 'white pawn', + 'supercategory': 'pieces' + }, { + 'id': 12, + 'name': 'white queen', + 'supercategory': 'pieces' + }, { + 'id': 13, + 'name': 'white rook', + 'supercategory': 'pieces' + }] + + _data_root = args.data_root + 'ChessPieces/Chess Pieces.v23-raw.coco/' + json_data = mmengine.load(_data_root + + 'valid/annotations_without_background.json') + json_data['categories'] = ChessPieces + mmengine.dump(json_data, + _data_root + 'valid/new_annotations_without_background.json') + + CottontailRabbits = [{ + 'id': 1, + 'name': 'rabbit', + 'supercategory': 'Cottontail-Rabbit' + }] + + _data_root = args.data_root + 'CottontailRabbits/' + json_data = mmengine.load(_data_root + + 'valid/annotations_without_background.json') + json_data['categories'] = CottontailRabbits + mmengine.dump(json_data, + _data_root + 'valid/new_annotations_without_background.json') + + NorthAmericaMushrooms = [{ + 'id': 1, + 'name': 'flat mushroom', + 'supercategory': 'mushroom' + }, { + 'id': 2, + 'name': 'yellow mushroom', + 'supercategory': 'mushroom' + }] + + _data_root = args.data_root + 'NorthAmericaMushrooms/North American Mushrooms.v1-416x416.coco/' # noqa + json_data = mmengine.load(_data_root + + 'valid/annotations_without_background.json') + json_data['categories'] = NorthAmericaMushrooms + mmengine.dump(json_data, + _data_root + 'valid/new_annotations_without_background.json') + + +if __name__ == '__main__': + main() diff --git a/mmdetection/configs/grounding_dino/refcoco/grounding_dino_swin-b_pretrain_zeroshot_refexp.py b/mmdetection/configs/grounding_dino/refcoco/grounding_dino_swin-b_pretrain_zeroshot_refexp.py new file mode 100644 index 00000000..dea0bad0 --- /dev/null +++ b/mmdetection/configs/grounding_dino/refcoco/grounding_dino_swin-b_pretrain_zeroshot_refexp.py @@ -0,0 +1,14 @@ +_base_ = './grounding_dino_swin-t_pretrain_zeroshot_refexp.py' + +model = dict( + type='GroundingDINO', + backbone=dict( + pretrain_img_size=384, + embed_dims=128, + depths=[2, 2, 18, 2], + num_heads=[4, 8, 16, 32], + window_size=12, + drop_path_rate=0.3, + patch_norm=True), + neck=dict(in_channels=[256, 512, 1024]), +) diff --git a/mmdetection/configs/grounding_dino/refcoco/grounding_dino_swin-t_pretrain_zeroshot_refexp.py b/mmdetection/configs/grounding_dino/refcoco/grounding_dino_swin-t_pretrain_zeroshot_refexp.py new file mode 100644 index 00000000..4b5c4657 --- /dev/null +++ b/mmdetection/configs/grounding_dino/refcoco/grounding_dino_swin-t_pretrain_zeroshot_refexp.py @@ -0,0 +1,228 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365_goldg_cap4m.py' + +# 30 is an empirical value, just set it to the maximum value +# without affecting the evaluation result +model = dict(test_cfg=dict(max_per_img=30)) + +data_root = 'data/coco/' + +test_pipeline = [ + dict( + type='LoadImageFromFile', backend_args=None, + imdecode_backend='pillow'), + dict( + type='FixScaleResize', + scale=(800, 1333), + keep_ratio=True, + backend='pillow'), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'text', 'custom_entities', + 'tokens_positive')) +] + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/final_refexp_val.json' +val_dataset_all_val = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=test_pipeline, + backend_args=None) +val_evaluator_all_val = dict( + type='RefExpMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + topk=(1, 5, 10)) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_refcoco_testA.json' +val_dataset_refcoco_testA = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=test_pipeline, + backend_args=None) + +val_evaluator_refcoco_testA = dict( + type='RefExpMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + topk=(1, 5, 10)) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_refcoco_testB.json' +val_dataset_refcoco_testB = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=test_pipeline, + backend_args=None) + +val_evaluator_refcoco_testB = dict( + type='RefExpMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + topk=(1, 5, 10)) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_refcoco+_testA.json' +val_dataset_refcoco_plus_testA = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=test_pipeline, + backend_args=None) + +val_evaluator_refcoco_plus_testA = dict( + type='RefExpMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + topk=(1, 5, 10)) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_refcoco+_testB.json' +val_dataset_refcoco_plus_testB = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=test_pipeline, + backend_args=None) + +val_evaluator_refcoco_plus_testB = dict( + type='RefExpMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + topk=(1, 5, 10)) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_refcocog_test.json' +val_dataset_refcocog_test = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=test_pipeline, + backend_args=None) + +val_evaluator_refcocog_test = dict( + type='RefExpMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + topk=(1, 5, 10)) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_grefcoco_val.json' +val_dataset_grefcoco_val = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=test_pipeline, + backend_args=None) + +val_evaluator_grefcoco_val = dict( + type='gRefCOCOMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + thresh_score=0.7, + thresh_f1=1.0) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_grefcoco_testA.json' +val_dataset_grefcoco_testA = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=test_pipeline, + backend_args=None) + +val_evaluator_grefcoco_testA = dict( + type='gRefCOCOMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + thresh_score=0.7, + thresh_f1=1.0) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_grefcoco_testB.json' +val_dataset_grefcoco_testB = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=test_pipeline, + backend_args=None) + +val_evaluator_grefcoco_testB = dict( + type='gRefCOCOMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + thresh_score=0.7, + thresh_f1=1.0) + +# -------------------------------------------------# +datasets = [ + val_dataset_all_val, val_dataset_refcoco_testA, val_dataset_refcoco_testB, + val_dataset_refcoco_plus_testA, val_dataset_refcoco_plus_testB, + val_dataset_refcocog_test, val_dataset_grefcoco_val, + val_dataset_grefcoco_testA, val_dataset_grefcoco_testB +] +dataset_prefixes = [ + 'val', 'refcoco_testA', 'refcoco_testB', 'refcoco+_testA', + 'refcoco+_testB', 'refcocog_test', 'grefcoco_val', 'grefcoco_testA', + 'grefcoco_testB' +] +metrics = [ + val_evaluator_all_val, val_evaluator_refcoco_testA, + val_evaluator_refcoco_testB, val_evaluator_refcoco_plus_testA, + val_evaluator_refcoco_plus_testB, val_evaluator_refcocog_test, + val_evaluator_grefcoco_val, val_evaluator_grefcoco_testA, + val_evaluator_grefcoco_testB +] + +val_dataloader = dict( + dataset=dict(_delete_=True, type='ConcatDataset', datasets=datasets)) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + type='MultiDatasetsEvaluator', + metrics=metrics, + dataset_prefixes=dataset_prefixes) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/guided_anchoring/README.md b/mmdetection/configs/guided_anchoring/README.md new file mode 100644 index 00000000..1a5e505d --- /dev/null +++ b/mmdetection/configs/guided_anchoring/README.md @@ -0,0 +1,59 @@ +# Guided Anchoring + +> [Region Proposal by Guided Anchoring](https://arxiv.org/abs/1901.03278) + + + +## Abstract + +Region anchors are the cornerstone of modern object detection techniques. State-of-the-art detectors mostly rely on a dense anchoring scheme, where anchors are sampled uniformly over the spatial domain with a predefined set of scales and aspect ratios. In this paper, we revisit this foundational stage. Our study shows that it can be done much more effectively and efficiently. Specifically, we present an alternative scheme, named Guided Anchoring, which leverages semantic features to guide the anchoring. The proposed method jointly predicts the locations where the center of objects of interest are likely to exist as well as the scales and aspect ratios at different locations. On top of predicted anchor shapes, we mitigate the feature inconsistency with a feature adaption module. We also study the use of high-quality proposals to improve detection performance. The anchoring scheme can be seamlessly integrated into proposal methods and detectors. With Guided Anchoring, we achieve 9.1% higher recall on MS COCO with 90% fewer anchors than the RPN baseline. We also adopt Guided Anchoring in Fast R-CNN, Faster R-CNN and RetinaNet, respectively improving the detection mAP by 2.2%, 2.7% and 1.2%. + +
    + +
    + +## Results and Models + +The results on COCO 2017 val is shown in the below table. (results on test-dev are usually slightly higher than val). + +| Method | Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | AR 1000 | Config | Download | +| :----: | :-------------: | :-----: | :-----: | :------: | :------------: | :-----: | :------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| GA-RPN | R-50-FPN | caffe | 1x | 5.3 | 15.8 | 68.4 | [config](./ga-rpn_r50-caffe_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_rpn_r50_caffe_fpn_1x_coco/ga_rpn_r50_caffe_fpn_1x_coco_20200531-899008a6.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_rpn_r50_caffe_fpn_1x_coco/ga_rpn_r50_caffe_fpn_1x_coco_20200531_011819.log.json) | +| GA-RPN | R-101-FPN | caffe | 1x | 7.3 | 13.0 | 69.5 | [config](./ga-rpn_r101-caffe_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_rpn_r101_caffe_fpn_1x_coco/ga_rpn_r101_caffe_fpn_1x_coco_20200531-ca9ba8fb.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_rpn_r101_caffe_fpn_1x_coco/ga_rpn_r101_caffe_fpn_1x_coco_20200531_011812.log.json) | +| GA-RPN | X-101-32x4d-FPN | pytorch | 1x | 8.5 | 10.0 | 70.6 | [config](./ga-rpn_x101-32x4d_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_rpn_x101_32x4d_fpn_1x_coco/ga_rpn_x101_32x4d_fpn_1x_coco_20200220-c28d1b18.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_rpn_x101_32x4d_fpn_1x_coco/ga_rpn_x101_32x4d_fpn_1x_coco_20200220_221326.log.json) | +| GA-RPN | X-101-64x4d-FPN | pytorch | 1x | 7.1 | 7.5 | 71.2 | [config](./ga-rpn_x101-64x4d_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_rpn_x101_64x4d_fpn_1x_coco/ga_rpn_x101_64x4d_fpn_1x_coco_20200225-3c6e1aa2.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_rpn_x101_64x4d_fpn_1x_coco/ga_rpn_x101_64x4d_fpn_1x_coco_20200225_152704.log.json) | + +| Method | Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :------------: | :-------------: | :-----: | :-----: | :------: | :------------: | :----: | :--------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| GA-Faster RCNN | R-50-FPN | caffe | 1x | 5.5 | | 39.6 | [config](./ga-faster-rcnn_r50-caffe_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_faster_r50_caffe_fpn_1x_coco/ga_faster_r50_caffe_fpn_1x_coco_20200702_000718-a11ccfe6.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_faster_r50_caffe_fpn_1x_coco/ga_faster_r50_caffe_fpn_1x_coco_20200702_000718.log.json) | +| GA-Faster RCNN | R-101-FPN | caffe | 1x | 7.5 | | 41.5 | [config](./ga-faster-rcnn_r101-caffe_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_faster_r101_caffe_fpn_1x_coco/ga_faster_r101_caffe_fpn_1x_coco_bbox_mAP-0.415_20200505_115528-fb82e499.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_faster_r101_caffe_fpn_1x_coco/ga_faster_r101_caffe_fpn_1x_coco_20200505_115528.log.json) | +| GA-Faster RCNN | X-101-32x4d-FPN | pytorch | 1x | 8.7 | 9.7 | 43.0 | [config](./ga-faster-rcnn_x101-32x4d_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_faster_x101_32x4d_fpn_1x_coco/ga_faster_x101_32x4d_fpn_1x_coco_20200215-1ded9da3.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_faster_x101_32x4d_fpn_1x_coco/ga_faster_x101_32x4d_fpn_1x_coco_20200215_184547.log.json) | +| GA-Faster RCNN | X-101-64x4d-FPN | pytorch | 1x | 11.8 | 7.3 | 43.9 | [config](./ga-faster-rcnn_x101-64x4d_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_faster_x101_64x4d_fpn_1x_coco/ga_faster_x101_64x4d_fpn_1x_coco_20200215-0fa7bde7.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_faster_x101_64x4d_fpn_1x_coco/ga_faster_x101_64x4d_fpn_1x_coco_20200215_104455.log.json) | +| GA-RetinaNet | R-50-FPN | caffe | 1x | 3.5 | 16.8 | 36.9 | [config](./ga-retinanet_r50-caffe_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_retinanet_r50_caffe_fpn_1x_coco/ga_retinanet_r50_caffe_fpn_1x_coco_20201020-39581c6f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_retinanet_r50_caffe_fpn_1x_coco/ga_retinanet_r50_caffe_fpn_1x_coco_20201020_225450.log.json) | +| GA-RetinaNet | R-101-FPN | caffe | 1x | 5.5 | 12.9 | 39.0 | [config](./ga-retinanet_r101-caffe_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_retinanet_r101_caffe_fpn_1x_coco/ga_retinanet_r101_caffe_fpn_1x_coco_20200531-6266453c.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_retinanet_r101_caffe_fpn_1x_coco/ga_retinanet_r101_caffe_fpn_1x_coco_20200531_012847.log.json) | +| GA-RetinaNet | X-101-32x4d-FPN | pytorch | 1x | 6.9 | 10.6 | 40.5 | [config](./ga-retinanet_x101-32x4d_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_retinanet_x101_32x4d_fpn_1x_coco/ga_retinanet_x101_32x4d_fpn_1x_coco_20200219-40c56caa.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_retinanet_x101_32x4d_fpn_1x_coco/ga_retinanet_x101_32x4d_fpn_1x_coco_20200219_223025.log.json) | +| GA-RetinaNet | X-101-64x4d-FPN | pytorch | 1x | 9.9 | 7.7 | 41.3 | [config](./ga-retinanet_x101-64x4d_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_retinanet_x101_64x4d_fpn_1x_coco/ga_retinanet_x101_64x4d_fpn_1x_coco_20200226-ef9f7f1f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_retinanet_x101_64x4d_fpn_1x_coco/ga_retinanet_x101_64x4d_fpn_1x_coco_20200226_221123.log.json) | + +- In the Guided Anchoring paper, `score_thr` is set to 0.001 in Fast/Faster RCNN and 0.05 in RetinaNet for both baselines and Guided Anchoring. + +- Performance on COCO test-dev benchmark are shown as follows. + +| Method | Backbone | Style | Lr schd | Aug Train | Score thr | AP | AP_50 | AP_75 | AP_small | AP_medium | AP_large | Download | +| :------------: | :-------: | :---: | :-----: | :-------: | :-------: | :-: | :---: | :---: | :------: | :-------: | :------: | :------: | +| GA-Faster RCNN | R-101-FPN | caffe | 1x | F | 0.05 | | | | | | | | +| GA-Faster RCNN | R-101-FPN | caffe | 1x | F | 0.001 | | | | | | | | +| GA-RetinaNet | R-101-FPN | caffe | 1x | F | 0.05 | | | | | | | | +| GA-RetinaNet | R-101-FPN | caffe | 2x | T | 0.05 | | | | | | | | + +## Citation + +We provide config files to reproduce the results in the CVPR 2019 paper for [Region Proposal by Guided Anchoring](https://arxiv.org/abs/1901.03278). + +```latex +@inproceedings{wang2019region, + title={Region Proposal by Guided Anchoring}, + author={Jiaqi Wang and Kai Chen and Shuo Yang and Chen Change Loy and Dahua Lin}, + booktitle={IEEE Conference on Computer Vision and Pattern Recognition}, + year={2019} +} +``` diff --git a/mmdetection/configs/guided_anchoring/ga-fast-rcnn_r50-caffe_fpn_1x_coco.py b/mmdetection/configs/guided_anchoring/ga-fast-rcnn_r50-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..2d0579c5 --- /dev/null +++ b/mmdetection/configs/guided_anchoring/ga-fast-rcnn_r50-caffe_fpn_1x_coco.py @@ -0,0 +1,66 @@ +_base_ = '../fast_rcnn/fast-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=False), + norm_eval=True, + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe')), + roi_head=dict( + bbox_head=dict(bbox_coder=dict(target_stds=[0.05, 0.05, 0.1, 0.1]))), + # model training and testing settings + train_cfg=dict( + rcnn=dict( + assigner=dict(pos_iou_thr=0.6, neg_iou_thr=0.6, min_pos_iou=0.6), + sampler=dict(num=256))), + test_cfg=dict(rcnn=dict(score_thr=1e-3))) +dataset_type = 'CocoDataset' +data_root = 'data/coco/' +img_norm_cfg = dict( + mean=[103.530, 116.280, 123.675], std=[1.0, 1.0, 1.0], to_rgb=False) +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadProposals', num_max_proposals=300), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='Resize', img_scale=(1333, 800), keep_ratio=True), + dict(type='RandomFlip', flip_ratio=0.5), + dict(type='Normalize', **img_norm_cfg), + dict(type='Pad', size_divisor=32), + dict(type='DefaultFormatBundle'), + dict(type='Collect', keys=['img', 'proposals', 'gt_bboxes', 'gt_labels']), +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadProposals', num_max_proposals=None), + dict( + type='MultiScaleFlipAug', + img_scale=(1333, 800), + flip=False, + transforms=[ + dict(type='Resize', keep_ratio=True), + dict(type='RandomFlip'), + dict(type='Normalize', **img_norm_cfg), + dict(type='Pad', size_divisor=32), + dict(type='ImageToTensor', keys=['img']), + dict(type='Collect', keys=['img', 'proposals']), + ]) +] +# TODO: support loading proposals +data = dict( + train=dict( + proposal_file=data_root + 'proposals/ga_rpn_r50_fpn_1x_train2017.pkl', + pipeline=train_pipeline), + val=dict( + proposal_file=data_root + 'proposals/ga_rpn_r50_fpn_1x_val2017.pkl', + pipeline=test_pipeline), + test=dict( + proposal_file=data_root + 'proposals/ga_rpn_r50_fpn_1x_val2017.pkl', + pipeline=test_pipeline)) +optimizer_config = dict( + _delete_=True, grad_clip=dict(max_norm=35, norm_type=2)) diff --git a/mmdetection/configs/guided_anchoring/ga-faster-rcnn_r101-caffe_fpn_1x_coco.py b/mmdetection/configs/guided_anchoring/ga-faster-rcnn_r101-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..f585dc35 --- /dev/null +++ b/mmdetection/configs/guided_anchoring/ga-faster-rcnn_r101-caffe_fpn_1x_coco.py @@ -0,0 +1,7 @@ +_base_ = './ga-faster-rcnn_r50-caffe_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet101_caffe'))) diff --git a/mmdetection/configs/guided_anchoring/ga-faster-rcnn_r50-caffe_fpn_1x_coco.py b/mmdetection/configs/guided_anchoring/ga-faster-rcnn_r50-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..6cd44de5 --- /dev/null +++ b/mmdetection/configs/guided_anchoring/ga-faster-rcnn_r50-caffe_fpn_1x_coco.py @@ -0,0 +1,64 @@ +_base_ = '../faster_rcnn/faster-rcnn_r50-caffe_fpn_1x_coco.py' +model = dict( + rpn_head=dict( + _delete_=True, + type='GARPNHead', + in_channels=256, + feat_channels=256, + approx_anchor_generator=dict( + type='AnchorGenerator', + octave_base_scale=8, + scales_per_octave=3, + ratios=[0.5, 1.0, 2.0], + strides=[4, 8, 16, 32, 64]), + square_anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + scales=[8], + strides=[4, 8, 16, 32, 64]), + anchor_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.07, 0.07, 0.14, 0.14]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.07, 0.07, 0.11, 0.11]), + loc_filter_thr=0.01, + loss_loc=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_shape=dict(type='BoundedIoULoss', beta=0.2, loss_weight=1.0), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0)), + roi_head=dict( + bbox_head=dict(bbox_coder=dict(target_stds=[0.05, 0.05, 0.1, 0.1]))), + # model training and testing settings + train_cfg=dict( + rpn=dict( + ga_assigner=dict( + type='ApproxMaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.3, + min_pos_iou=0.3, + ignore_iof_thr=-1), + ga_sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=-1, + center_ratio=0.2, + ignore_ratio=0.5), + rpn_proposal=dict(nms_post=1000, max_per_img=300), + rcnn=dict( + assigner=dict(pos_iou_thr=0.6, neg_iou_thr=0.6, min_pos_iou=0.6), + sampler=dict(type='RandomSampler', num=256))), + test_cfg=dict( + rpn=dict(nms_post=1000, max_per_img=300), rcnn=dict(score_thr=1e-3))) +optim_wrapper = dict(clip_grad=dict(max_norm=35, norm_type=2)) diff --git a/mmdetection/configs/guided_anchoring/ga-faster-rcnn_r50_fpn_1x_coco.py b/mmdetection/configs/guided_anchoring/ga-faster-rcnn_r50_fpn_1x_coco.py new file mode 100644 index 00000000..3007fbec --- /dev/null +++ b/mmdetection/configs/guided_anchoring/ga-faster-rcnn_r50_fpn_1x_coco.py @@ -0,0 +1,64 @@ +_base_ = '../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + rpn_head=dict( + _delete_=True, + type='GARPNHead', + in_channels=256, + feat_channels=256, + approx_anchor_generator=dict( + type='AnchorGenerator', + octave_base_scale=8, + scales_per_octave=3, + ratios=[0.5, 1.0, 2.0], + strides=[4, 8, 16, 32, 64]), + square_anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + scales=[8], + strides=[4, 8, 16, 32, 64]), + anchor_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.07, 0.07, 0.14, 0.14]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.07, 0.07, 0.11, 0.11]), + loc_filter_thr=0.01, + loss_loc=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_shape=dict(type='BoundedIoULoss', beta=0.2, loss_weight=1.0), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0)), + roi_head=dict( + bbox_head=dict(bbox_coder=dict(target_stds=[0.05, 0.05, 0.1, 0.1]))), + # model training and testing settings + train_cfg=dict( + rpn=dict( + ga_assigner=dict( + type='ApproxMaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.3, + min_pos_iou=0.3, + ignore_iof_thr=-1), + ga_sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=-1, + center_ratio=0.2, + ignore_ratio=0.5), + rpn_proposal=dict(nms_post=1000, max_per_img=300), + rcnn=dict( + assigner=dict(pos_iou_thr=0.6, neg_iou_thr=0.6, min_pos_iou=0.6), + sampler=dict(type='RandomSampler', num=256))), + test_cfg=dict( + rpn=dict(nms_post=1000, max_per_img=300), rcnn=dict(score_thr=1e-3))) +optim_wrapper = dict(clip_grad=dict(max_norm=35, norm_type=2)) diff --git a/mmdetection/configs/guided_anchoring/ga-faster-rcnn_x101-32x4d_fpn_1x_coco.py b/mmdetection/configs/guided_anchoring/ga-faster-rcnn_x101-32x4d_fpn_1x_coco.py new file mode 100644 index 00000000..8a22a1ec --- /dev/null +++ b/mmdetection/configs/guided_anchoring/ga-faster-rcnn_x101-32x4d_fpn_1x_coco.py @@ -0,0 +1,14 @@ +_base_ = './ga-faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/guided_anchoring/ga-faster-rcnn_x101-64x4d_fpn_1x_coco.py b/mmdetection/configs/guided_anchoring/ga-faster-rcnn_x101-64x4d_fpn_1x_coco.py new file mode 100644 index 00000000..3d6aaeaa --- /dev/null +++ b/mmdetection/configs/guided_anchoring/ga-faster-rcnn_x101-64x4d_fpn_1x_coco.py @@ -0,0 +1,14 @@ +_base_ = './ga-faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/guided_anchoring/ga-retinanet_r101-caffe_fpn_1x_coco.py b/mmdetection/configs/guided_anchoring/ga-retinanet_r101-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..9adbae55 --- /dev/null +++ b/mmdetection/configs/guided_anchoring/ga-retinanet_r101-caffe_fpn_1x_coco.py @@ -0,0 +1,7 @@ +_base_ = './ga-retinanet_r50-caffe_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet101_caffe'))) diff --git a/mmdetection/configs/guided_anchoring/ga-retinanet_r101-caffe_fpn_ms-2x.py b/mmdetection/configs/guided_anchoring/ga-retinanet_r101-caffe_fpn_ms-2x.py new file mode 100644 index 00000000..012e89b8 --- /dev/null +++ b/mmdetection/configs/guided_anchoring/ga-retinanet_r101-caffe_fpn_ms-2x.py @@ -0,0 +1,34 @@ +_base_ = './ga-retinanet_r101-caffe_fpn_1x_coco.py' + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomResize', scale=[(1333, 480), (1333, 960)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +# learning policy +max_epochs = 24 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0 / 3.0, + by_epoch=False, + begin=0, + end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/guided_anchoring/ga-retinanet_r50-caffe_fpn_1x_coco.py b/mmdetection/configs/guided_anchoring/ga-retinanet_r50-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..b62aba62 --- /dev/null +++ b/mmdetection/configs/guided_anchoring/ga-retinanet_r50-caffe_fpn_1x_coco.py @@ -0,0 +1,61 @@ +_base_ = '../retinanet/retinanet_r50-caffe_fpn_1x_coco.py' +model = dict( + bbox_head=dict( + _delete_=True, + type='GARetinaHead', + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + approx_anchor_generator=dict( + type='AnchorGenerator', + octave_base_scale=4, + scales_per_octave=3, + ratios=[0.5, 1.0, 2.0], + strides=[8, 16, 32, 64, 128]), + square_anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + scales=[4], + strides=[8, 16, 32, 64, 128]), + anchor_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[1.0, 1.0, 1.0, 1.0]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[1.0, 1.0, 1.0, 1.0]), + loc_filter_thr=0.01, + loss_loc=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_shape=dict(type='BoundedIoULoss', beta=0.2, loss_weight=1.0), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=0.04, loss_weight=1.0)), + # training and testing settings + train_cfg=dict( + ga_assigner=dict( + type='ApproxMaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.4, + min_pos_iou=0.4, + ignore_iof_thr=-1), + ga_sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + assigner=dict(neg_iou_thr=0.5, min_pos_iou=0.0), + center_ratio=0.2, + ignore_ratio=0.5)) +optim_wrapper = dict(clip_grad=dict(max_norm=35, norm_type=2)) diff --git a/mmdetection/configs/guided_anchoring/ga-retinanet_r50_fpn_1x_coco.py b/mmdetection/configs/guided_anchoring/ga-retinanet_r50_fpn_1x_coco.py new file mode 100644 index 00000000..da39c700 --- /dev/null +++ b/mmdetection/configs/guided_anchoring/ga-retinanet_r50_fpn_1x_coco.py @@ -0,0 +1,61 @@ +_base_ = '../retinanet/retinanet_r50_fpn_1x_coco.py' +model = dict( + bbox_head=dict( + _delete_=True, + type='GARetinaHead', + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + approx_anchor_generator=dict( + type='AnchorGenerator', + octave_base_scale=4, + scales_per_octave=3, + ratios=[0.5, 1.0, 2.0], + strides=[8, 16, 32, 64, 128]), + square_anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + scales=[4], + strides=[8, 16, 32, 64, 128]), + anchor_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[1.0, 1.0, 1.0, 1.0]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[1.0, 1.0, 1.0, 1.0]), + loc_filter_thr=0.01, + loss_loc=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_shape=dict(type='BoundedIoULoss', beta=0.2, loss_weight=1.0), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=0.04, loss_weight=1.0)), + # training and testing settings + train_cfg=dict( + ga_assigner=dict( + type='ApproxMaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.4, + min_pos_iou=0.4, + ignore_iof_thr=-1), + ga_sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + assigner=dict(neg_iou_thr=0.5, min_pos_iou=0.0), + center_ratio=0.2, + ignore_ratio=0.5)) +optim_wrapper = dict(clip_grad=dict(max_norm=35, norm_type=2)) diff --git a/mmdetection/configs/guided_anchoring/ga-retinanet_x101-32x4d_fpn_1x_coco.py b/mmdetection/configs/guided_anchoring/ga-retinanet_x101-32x4d_fpn_1x_coco.py new file mode 100644 index 00000000..478a8e5e --- /dev/null +++ b/mmdetection/configs/guided_anchoring/ga-retinanet_x101-32x4d_fpn_1x_coco.py @@ -0,0 +1,14 @@ +_base_ = './ga-retinanet_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/guided_anchoring/ga-retinanet_x101-64x4d_fpn_1x_coco.py b/mmdetection/configs/guided_anchoring/ga-retinanet_x101-64x4d_fpn_1x_coco.py new file mode 100644 index 00000000..cb7721d3 --- /dev/null +++ b/mmdetection/configs/guided_anchoring/ga-retinanet_x101-64x4d_fpn_1x_coco.py @@ -0,0 +1,14 @@ +_base_ = './ga-retinanet_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/guided_anchoring/ga-rpn_r101-caffe_fpn_1x_coco.py b/mmdetection/configs/guided_anchoring/ga-rpn_r101-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..b375c874 --- /dev/null +++ b/mmdetection/configs/guided_anchoring/ga-rpn_r101-caffe_fpn_1x_coco.py @@ -0,0 +1,8 @@ +_base_ = './ga-rpn_r50-caffe_fpn_1x_coco.py' +# model settings +model = dict( + backbone=dict( + depth=101, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet101_caffe'))) diff --git a/mmdetection/configs/guided_anchoring/ga-rpn_r50-caffe_fpn_1x_coco.py b/mmdetection/configs/guided_anchoring/ga-rpn_r50-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..aa58426e --- /dev/null +++ b/mmdetection/configs/guided_anchoring/ga-rpn_r50-caffe_fpn_1x_coco.py @@ -0,0 +1,57 @@ +_base_ = '../rpn/rpn_r50-caffe_fpn_1x_coco.py' +model = dict( + rpn_head=dict( + _delete_=True, + type='GARPNHead', + in_channels=256, + feat_channels=256, + approx_anchor_generator=dict( + type='AnchorGenerator', + octave_base_scale=8, + scales_per_octave=3, + ratios=[0.5, 1.0, 2.0], + strides=[4, 8, 16, 32, 64]), + square_anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + scales=[8], + strides=[4, 8, 16, 32, 64]), + anchor_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.07, 0.07, 0.14, 0.14]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.07, 0.07, 0.11, 0.11]), + loc_filter_thr=0.01, + loss_loc=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_shape=dict(type='BoundedIoULoss', beta=0.2, loss_weight=1.0), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0)), + # model training and testing settings + train_cfg=dict( + rpn=dict( + ga_assigner=dict( + type='ApproxMaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.3, + min_pos_iou=0.3, + ignore_iof_thr=-1), + ga_sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=-1, + center_ratio=0.2, + ignore_ratio=0.5)), + test_cfg=dict(rpn=dict(nms_post=1000))) +optim_wrapper = dict(clip_grad=dict(max_norm=35, norm_type=2)) diff --git a/mmdetection/configs/guided_anchoring/ga-rpn_r50_fpn_1x_coco.py b/mmdetection/configs/guided_anchoring/ga-rpn_r50_fpn_1x_coco.py new file mode 100644 index 00000000..2973f272 --- /dev/null +++ b/mmdetection/configs/guided_anchoring/ga-rpn_r50_fpn_1x_coco.py @@ -0,0 +1,57 @@ +_base_ = '../rpn/rpn_r50_fpn_1x_coco.py' +model = dict( + rpn_head=dict( + _delete_=True, + type='GARPNHead', + in_channels=256, + feat_channels=256, + approx_anchor_generator=dict( + type='AnchorGenerator', + octave_base_scale=8, + scales_per_octave=3, + ratios=[0.5, 1.0, 2.0], + strides=[4, 8, 16, 32, 64]), + square_anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + scales=[8], + strides=[4, 8, 16, 32, 64]), + anchor_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.07, 0.07, 0.14, 0.14]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.07, 0.07, 0.11, 0.11]), + loc_filter_thr=0.01, + loss_loc=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_shape=dict(type='BoundedIoULoss', beta=0.2, loss_weight=1.0), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0)), + # model training and testing settings + train_cfg=dict( + rpn=dict( + ga_assigner=dict( + type='ApproxMaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.3, + min_pos_iou=0.3, + ignore_iof_thr=-1), + ga_sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=-1, + center_ratio=0.2, + ignore_ratio=0.5)), + test_cfg=dict(rpn=dict(nms_post=1000))) +optim_wrapper = dict(clip_grad=dict(max_norm=35, norm_type=2)) diff --git a/mmdetection/configs/guided_anchoring/ga-rpn_x101-32x4d_fpn_1x_coco.py b/mmdetection/configs/guided_anchoring/ga-rpn_x101-32x4d_fpn_1x_coco.py new file mode 100644 index 00000000..276d45d8 --- /dev/null +++ b/mmdetection/configs/guided_anchoring/ga-rpn_x101-32x4d_fpn_1x_coco.py @@ -0,0 +1,14 @@ +_base_ = './ga-rpn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/guided_anchoring/ga-rpn_x101-64x4d_fpn_1x_coco.py b/mmdetection/configs/guided_anchoring/ga-rpn_x101-64x4d_fpn_1x_coco.py new file mode 100644 index 00000000..f29fe9aa --- /dev/null +++ b/mmdetection/configs/guided_anchoring/ga-rpn_x101-64x4d_fpn_1x_coco.py @@ -0,0 +1,14 @@ +_base_ = './ga-rpn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/guided_anchoring/metafile.yml b/mmdetection/configs/guided_anchoring/metafile.yml new file mode 100644 index 00000000..516b3e93 --- /dev/null +++ b/mmdetection/configs/guided_anchoring/metafile.yml @@ -0,0 +1,246 @@ +Collections: + - Name: Guided Anchoring + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - FPN + - Guided Anchoring + - ResNet + Paper: + URL: https://arxiv.org/abs/1901.03278 + Title: 'Region Proposal by Guided Anchoring' + README: configs/guided_anchoring/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/dense_heads/ga_retina_head.py#L10 + Version: v2.0.0 + +Models: + - Name: ga-rpn_r50-caffe_fpn_1x_coco + In Collection: Guided Anchoring + Config: configs/guided_anchoring/ga-rpn_r50-caffe_fpn_1x_coco.py + Metadata: + Training Memory (GB): 5.3 + inference time (ms/im): + - value: 63.29 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Region Proposal + Dataset: COCO + Metrics: + AR@1000: 68.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_rpn_r50_caffe_fpn_1x_coco/ga_rpn_r50_caffe_fpn_1x_coco_20200531-899008a6.pth + + - Name: ga-rpn_r101-caffe_fpn_1x_coco + In Collection: Guided Anchoring + Config: configs/guided_anchoring/ga-rpn_r101-caffe_fpn_1x_coco.py + Metadata: + Training Memory (GB): 7.3 + inference time (ms/im): + - value: 76.92 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Region Proposal + Dataset: COCO + Metrics: + AR@1000: 69.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_rpn_r101_caffe_fpn_1x_coco/ga_rpn_r101_caffe_fpn_1x_coco_20200531-ca9ba8fb.pth + + - Name: ga-rpn_x101-32x4d_fpn_1x_coco + In Collection: Guided Anchoring + Config: configs/guided_anchoring/ga-rpn_x101-32x4d_fpn_1x_coco.py + Metadata: + Training Memory (GB): 8.5 + inference time (ms/im): + - value: 100 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Region Proposal + Dataset: COCO + Metrics: + AR@1000: 70.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_rpn_x101_32x4d_fpn_1x_coco/ga_rpn_x101_32x4d_fpn_1x_coco_20200220-c28d1b18.pth + + - Name: ga-rpn_x101-64x4d_fpn_1x_coco + In Collection: Guided Anchoring + Config: configs/guided_anchoring/ga-rpn_x101-64x4d_fpn_1x_coco.py + Metadata: + Training Memory (GB): 7.1 + inference time (ms/im): + - value: 133.33 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Region Proposal + Dataset: COCO + Metrics: + AR@1000: 70.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_rpn_x101_64x4d_fpn_1x_coco/ga_rpn_x101_64x4d_fpn_1x_coco_20200225-3c6e1aa2.pth + + - Name: ga-faster-rcnn_r50-caffe_fpn_1x_coco + In Collection: Guided Anchoring + Config: configs/guided_anchoring/ga-faster-rcnn_r50-caffe_fpn_1x_coco.py + Metadata: + Training Memory (GB): 5.5 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_faster_r50_caffe_fpn_1x_coco/ga_faster_r50_caffe_fpn_1x_coco_20200702_000718-a11ccfe6.pth + + - Name: ga-faster-rcnn_r101-caffe_fpn_1x_coco + In Collection: Guided Anchoring + Config: configs/guided_anchoring/ga-faster-rcnn_r101-caffe_fpn_1x_coco.py + Metadata: + Training Memory (GB): 7.5 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_faster_r101_caffe_fpn_1x_coco/ga_faster_r101_caffe_fpn_1x_coco_bbox_mAP-0.415_20200505_115528-fb82e499.pth + + - Name: ga-faster-rcnn_x101-32x4d_fpn_1x_coco + In Collection: Guided Anchoring + Config: configs/guided_anchoring/ga-faster-rcnn_x101-32x4d_fpn_1x_coco.py + Metadata: + Training Memory (GB): 8.7 + inference time (ms/im): + - value: 103.09 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_faster_x101_32x4d_fpn_1x_coco/ga_faster_x101_32x4d_fpn_1x_coco_20200215-1ded9da3.pth + + - Name: ga-faster-rcnn_x101-64x4d_fpn_1x_coco + In Collection: Guided Anchoring + Config: configs/guided_anchoring/ga-faster-rcnn_x101-64x4d_fpn_1x_coco.py + Metadata: + Training Memory (GB): 11.8 + inference time (ms/im): + - value: 136.99 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_faster_x101_64x4d_fpn_1x_coco/ga_faster_x101_64x4d_fpn_1x_coco_20200215-0fa7bde7.pth + + - Name: ga-retinanet_r50-caffe_fpn_1x_coco + In Collection: Guided Anchoring + Config: configs/guided_anchoring/ga-retinanet_r50-caffe_fpn_1x_coco.py + Metadata: + Training Memory (GB): 3.5 + inference time (ms/im): + - value: 59.52 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 36.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_retinanet_r50_caffe_fpn_1x_coco/ga_retinanet_r50_caffe_fpn_1x_coco_20201020-39581c6f.pth + + - Name: ga-retinanet_r101-caffe_fpn_1x_coco + In Collection: Guided Anchoring + Config: configs/guided_anchoring/ga-retinanet_r101-caffe_fpn_1x_coco.py + Metadata: + Training Memory (GB): 5.5 + inference time (ms/im): + - value: 77.52 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_retinanet_r101_caffe_fpn_1x_coco/ga_retinanet_r101_caffe_fpn_1x_coco_20200531-6266453c.pth + + - Name: ga-retinanet_x101-32x4d_fpn_1x_coco + In Collection: Guided Anchoring + Config: configs/guided_anchoring/ga-retinanet_x101-32x4d_fpn_1x_coco.py + Metadata: + Training Memory (GB): 6.9 + inference time (ms/im): + - value: 94.34 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_retinanet_x101_32x4d_fpn_1x_coco/ga_retinanet_x101_32x4d_fpn_1x_coco_20200219-40c56caa.pth + + - Name: ga-retinanet_x101-64x4d_fpn_1x_coco + In Collection: Guided Anchoring + Config: configs/guided_anchoring/ga-retinanet_x101-64x4d_fpn_1x_coco.py + Metadata: + Training Memory (GB): 9.9 + inference time (ms/im): + - value: 129.87 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/guided_anchoring/ga_retinanet_x101_64x4d_fpn_1x_coco/ga_retinanet_x101_64x4d_fpn_1x_coco_20200226-ef9f7f1f.pth diff --git a/mmdetection/configs/hrnet/README.md b/mmdetection/configs/hrnet/README.md new file mode 100644 index 00000000..fc1ed0cc --- /dev/null +++ b/mmdetection/configs/hrnet/README.md @@ -0,0 +1,101 @@ +# HRNet + +> [Deep High-Resolution Representation Learning for Human Pose Estimation](https://arxiv.org/abs/1902.09212) + + + +## Abstract + +This is an official pytorch implementation of Deep High-Resolution Representation Learning for Human Pose Estimation. In this work, we are interested in the human pose estimation problem with a focus on learning reliable high-resolution representations. Most existing methods recover high-resolution representations from low-resolution representations produced by a high-to-low resolution network. Instead, our proposed network maintains high-resolution representations through the whole process. We start from a high-resolution subnetwork as the first stage, gradually add high-to-low resolution subnetworks one by one to form more stages, and connect the mutli-resolution subnetworks in parallel. We conduct repeated multi-scale fusions such that each of the high-to-low resolution representations receives information from other parallel representations over and over, leading to rich high-resolution representations. As a result, the predicted keypoint heatmap is potentially more accurate and spatially more precise. We empirically demonstrate the effectiveness of our network through the superior pose estimation results over two benchmark datasets: the COCO keypoint detection dataset and the MPII Human Pose dataset. + +High-resolution representation learning plays an essential role in many vision problems, e.g., pose estimation and semantic segmentation. The high-resolution network (HRNet), recently developed for human pose estimation, maintains high-resolution representations through the whole process by connecting high-to-low resolution convolutions in parallel and produces strong high-resolution representations by repeatedly conducting fusions across parallel convolutions. +In this paper, we conduct a further study on high-resolution representations by introducing a simple yet effective modification and apply it to a wide range of vision tasks. We augment the high-resolution representation by aggregating the (upsampled) representations from all the parallel convolutions rather than only the representation from the high-resolution convolution as done in HRNet. This simple modification leads to stronger representations, evidenced by superior results. We show top results in semantic segmentation on Cityscapes, LIP, and PASCAL Context, and facial landmark detection on AFLW, COFW, 300W, and WFLW. In addition, we build a multi-level representation from the high-resolution representation and apply it to the Faster R-CNN object detection framework and the extended frameworks. The proposed approach achieves superior results to existing single-model networks on COCO object detection. + +
    + +
    + +## Results and Models + +### Faster R-CNN + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :----------: | :-----: | :-----: | :------: | :------------: | :----: | :---------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| HRNetV2p-W18 | pytorch | 1x | 6.6 | 13.4 | 36.9 | [config](./faster-rcnn_hrnetv2p-w18-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/faster_rcnn_hrnetv2p_w18_1x_coco/faster_rcnn_hrnetv2p_w18_1x_coco_20200130-56651a6d.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/faster_rcnn_hrnetv2p_w18_1x_coco/faster_rcnn_hrnetv2p_w18_1x_coco_20200130_211246.log.json) | +| HRNetV2p-W18 | pytorch | 2x | 6.6 | - | 38.9 | [config](./faster-rcnn_hrnetv2p-w18-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/faster_rcnn_hrnetv2p_w18_2x_coco/faster_rcnn_hrnetv2p_w18_2x_coco_20200702_085731-a4ec0611.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/faster_rcnn_hrnetv2p_w18_2x_coco/faster_rcnn_hrnetv2p_w18_2x_coco_20200702_085731.log.json) | +| HRNetV2p-W32 | pytorch | 1x | 9.0 | 12.4 | 40.2 | [config](./faster-rcnn_hrnetv2p-w32-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/faster_rcnn_hrnetv2p_w32_1x_coco/faster_rcnn_hrnetv2p_w32_1x_coco_20200130-6e286425.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/faster_rcnn_hrnetv2p_w32_1x_coco/faster_rcnn_hrnetv2p_w32_1x_coco_20200130_204442.log.json) | +| HRNetV2p-W32 | pytorch | 2x | 9.0 | - | 41.4 | [config](./faster-rcnn_hrnetv2p-w32_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/faster_rcnn_hrnetv2p_w32_2x_coco/faster_rcnn_hrnetv2p_w32_2x_coco_20200529_015927-976a9c15.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/faster_rcnn_hrnetv2p_w32_2x_coco/faster_rcnn_hrnetv2p_w32_2x_coco_20200529_015927.log.json) | +| HRNetV2p-W40 | pytorch | 1x | 10.4 | 10.5 | 41.2 | [config](./faster-rcnn_hrnetv2p-w40-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/faster_rcnn_hrnetv2p_w40_1x_coco/faster_rcnn_hrnetv2p_w40_1x_coco_20200210-95c1f5ce.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/faster_rcnn_hrnetv2p_w40_1x_coco/faster_rcnn_hrnetv2p_w40_1x_coco_20200210_125315.log.json) | +| HRNetV2p-W40 | pytorch | 2x | 10.4 | - | 42.1 | [config](./faster-rcnn_hrnetv2p-w40_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/faster_rcnn_hrnetv2p_w40_2x_coco/faster_rcnn_hrnetv2p_w40_2x_coco_20200512_161033-0f236ef4.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/faster_rcnn_hrnetv2p_w40_2x_coco/faster_rcnn_hrnetv2p_w40_2x_coco_20200512_161033.log.json) | + +### Mask R-CNN + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :----------: | :-----: | :-----: | :------: | :------------: | :----: | :-----: | :-------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| HRNetV2p-W18 | pytorch | 1x | 7.0 | 11.7 | 37.7 | 34.2 | [config](./mask-rcnn_hrnetv2p-w18-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/mask_rcnn_hrnetv2p_w18_1x_coco/mask_rcnn_hrnetv2p_w18_1x_coco_20200205-1c3d78ed.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/mask_rcnn_hrnetv2p_w18_1x_coco/mask_rcnn_hrnetv2p_w18_1x_coco_20200205_232523.log.json) | +| HRNetV2p-W18 | pytorch | 2x | 7.0 | - | 39.8 | 36.0 | [config](./mask-rcnn_hrnetv2p-w18-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/mask_rcnn_hrnetv2p_w18_2x_coco/mask_rcnn_hrnetv2p_w18_2x_coco_20200212-b3c825b1.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/mask_rcnn_hrnetv2p_w18_2x_coco/mask_rcnn_hrnetv2p_w18_2x_coco_20200212_134222.log.json) | +| HRNetV2p-W32 | pytorch | 1x | 9.4 | 11.3 | 41.2 | 37.1 | [config](./mask-rcnn_hrnetv2p-w32-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/mask_rcnn_hrnetv2p_w32_1x_coco/mask_rcnn_hrnetv2p_w32_1x_coco_20200207-b29f616e.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/mask_rcnn_hrnetv2p_w32_1x_coco/mask_rcnn_hrnetv2p_w32_1x_coco_20200207_055017.log.json) | +| HRNetV2p-W32 | pytorch | 2x | 9.4 | - | 42.5 | 37.8 | [config](./mask-rcnn_hrnetv2p-w32-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/mask_rcnn_hrnetv2p_w32_2x_coco/mask_rcnn_hrnetv2p_w32_2x_coco_20200213-45b75b4d.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/mask_rcnn_hrnetv2p_w32_2x_coco/mask_rcnn_hrnetv2p_w32_2x_coco_20200213_150518.log.json) | +| HRNetV2p-W40 | pytorch | 1x | 10.9 | | 42.1 | 37.5 | [config](./mask-rcnn_hrnetv2p-w40_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/mask_rcnn_hrnetv2p_w40_1x_coco/mask_rcnn_hrnetv2p_w40_1x_coco_20200511_015646-66738b35.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/mask_rcnn_hrnetv2p_w40_1x_coco/mask_rcnn_hrnetv2p_w40_1x_coco_20200511_015646.log.json) | +| HRNetV2p-W40 | pytorch | 2x | 10.9 | | 42.8 | 38.2 | [config](./mask-rcnn_hrnetv2p-w40-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/mask_rcnn_hrnetv2p_w40_2x_coco/mask_rcnn_hrnetv2p_w40_2x_coco_20200512_163732-aed5e4ab.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/mask_rcnn_hrnetv2p_w40_2x_coco/mask_rcnn_hrnetv2p_w40_2x_coco_20200512_163732.log.json) | + +### Cascade R-CNN + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :----------: | :-----: | :-----: | :------: | :------------: | :----: | :-----------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| HRNetV2p-W18 | pytorch | 20e | 7.0 | 11.0 | 41.2 | [config](./cascade-rcnn_hrnetv2p-w18-20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/cascade_rcnn_hrnetv2p_w18_20e_coco/cascade_rcnn_hrnetv2p_w18_20e_coco_20200210-434be9d7.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/cascade_rcnn_hrnetv2p_w18_20e_coco/cascade_rcnn_hrnetv2p_w18_20e_coco_20200210_105632.log.json) | +| HRNetV2p-W32 | pytorch | 20e | 9.4 | 11.0 | 43.3 | [config](./cascade-rcnn_hrnetv2p-w32-20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/cascade_rcnn_hrnetv2p_w32_20e_coco/cascade_rcnn_hrnetv2p_w32_20e_coco_20200208-928455a4.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/cascade_rcnn_hrnetv2p_w32_20e_coco/cascade_rcnn_hrnetv2p_w32_20e_coco_20200208_160511.log.json) | +| HRNetV2p-W40 | pytorch | 20e | 10.8 | | 43.8 | [config](./cascade-rcnn_hrnetv2p-w40-20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/cascade_rcnn_hrnetv2p_w40_20e_coco/cascade_rcnn_hrnetv2p_w40_20e_coco_20200512_161112-75e47b04.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/cascade_rcnn_hrnetv2p_w40_20e_coco/cascade_rcnn_hrnetv2p_w40_20e_coco_20200512_161112.log.json) | + +### Cascade Mask R-CNN + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :----------: | :-----: | :-----: | :------: | :------------: | :----: | :-----: | :----------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| HRNetV2p-W18 | pytorch | 20e | 8.5 | 8.5 | 41.6 | 36.4 | [config](./cascade-mask-rcnn_hrnetv2p-w18_20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/cascade_mask_rcnn_hrnetv2p_w18_20e_coco/cascade_mask_rcnn_hrnetv2p_w18_20e_coco_20200210-b543cd2b.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/cascade_mask_rcnn_hrnetv2p_w18_20e_coco/cascade_mask_rcnn_hrnetv2p_w18_20e_coco_20200210_093149.log.json) | +| HRNetV2p-W32 | pytorch | 20e | | 8.3 | 44.3 | 38.6 | [config](./cascade-mask-rcnn_hrnetv2p-w32_20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/cascade_mask_rcnn_hrnetv2p_w32_20e_coco/cascade_mask_rcnn_hrnetv2p_w32_20e_coco_20200512_154043-39d9cf7b.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/cascade_mask_rcnn_hrnetv2p_w32_20e_coco/cascade_mask_rcnn_hrnetv2p_w32_20e_coco_20200512_154043.log.json) | +| HRNetV2p-W40 | pytorch | 20e | 12.5 | | 45.1 | 39.3 | [config](./cascade-mask-rcnn_hrnetv2p-w40-20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/cascade_mask_rcnn_hrnetv2p_w40_20e_coco/cascade_mask_rcnn_hrnetv2p_w40_20e_coco_20200527_204922-969c4610.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/cascade_mask_rcnn_hrnetv2p_w40_20e_coco/cascade_mask_rcnn_hrnetv2p_w40_20e_coco_20200527_204922.log.json) | + +### Hybrid Task Cascade (HTC) + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :----------: | :-----: | :-----: | :------: | :------------: | :----: | :-----: | :--------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| HRNetV2p-W18 | pytorch | 20e | 10.8 | 4.7 | 42.8 | 37.9 | [config](./htc_hrnetv2p-w18_20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/htc_hrnetv2p_w18_20e_coco/htc_hrnetv2p_w18_20e_coco_20200210-b266988c.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/htc_hrnetv2p_w18_20e_coco/htc_hrnetv2p_w18_20e_coco_20200210_182735.log.json) | +| HRNetV2p-W32 | pytorch | 20e | 13.1 | 4.9 | 45.4 | 39.9 | [config](./htc_hrnetv2p-w32_20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/htc_hrnetv2p_w32_20e_coco/htc_hrnetv2p_w32_20e_coco_20200207-7639fa12.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/htc_hrnetv2p_w32_20e_coco/htc_hrnetv2p_w32_20e_coco_20200207_193153.log.json) | +| HRNetV2p-W40 | pytorch | 20e | 14.6 | | 46.4 | 40.8 | [config](./htc_hrnetv2p-w40_20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/htc_hrnetv2p_w40_20e_coco/htc_hrnetv2p_w40_20e_coco_20200529_183411-417c4d5b.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/htc_hrnetv2p_w40_20e_coco/htc_hrnetv2p_w40_20e_coco_20200529_183411.log.json) | + +### FCOS + +| Backbone | Style | GN | MS train | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :----------: | :-----: | :-: | :------: | :-----: | :------: | :------------: | :----: | :--------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| HRNetV2p-W18 | pytorch | Y | N | 1x | 13.0 | 12.9 | 35.3 | [config](./fcos_hrnetv2p-w18-gn-head_4xb4-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/fcos_hrnetv2p_w18_gn-head_4x4_1x_coco/fcos_hrnetv2p_w18_gn-head_4x4_1x_coco_20201212_100710-4ad151de.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/fcos_hrnetv2p_w18_gn-head_4x4_1x_coco/fcos_hrnetv2p_w18_gn-head_4x4_1x_coco_20201212_100710.log.json) | +| HRNetV2p-W18 | pytorch | Y | N | 2x | 13.0 | - | 38.2 | [config](./fcos_hrnetv2p-w18-gn-head_4xb4-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/fcos_hrnetv2p_w18_gn-head_4x4_2x_coco/fcos_hrnetv2p_w18_gn-head_4x4_2x_coco_20201212_101110-5c575fa5.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/fcos_hrnetv2p_w18_gn-head_4x4_2x_coco/fcos_hrnetv2p_w18_gn-head_4x4_2x_coco_20201212_101110.log.json) | +| HRNetV2p-W32 | pytorch | Y | N | 1x | 17.5 | 12.9 | 39.5 | [config](./fcos_hrnetv2p-w32-gn-head_4xb4-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/fcos_hrnetv2p_w32_gn-head_4x4_1x_coco/fcos_hrnetv2p_w32_gn-head_4x4_1x_coco_20201211_134730-cb8055c0.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/fcos_hrnetv2p_w32_gn-head_4x4_1x_coco/fcos_hrnetv2p_w32_gn-head_4x4_1x_coco_20201211_134730.log.json) | +| HRNetV2p-W32 | pytorch | Y | N | 2x | 17.5 | - | 40.8 | [config](./fcos_hrnetv2p-w32-gn-head_4xb4-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/fcos_hrnetv2p_w32_gn-head_4x4_2x_coco/fcos_hrnetv2p_w32_gn-head_4x4_2x_coco_20201212_112133-77b6b9bb.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/fcos_hrnetv2p_w32_gn-head_4x4_2x_coco/fcos_hrnetv2p_w32_gn-head_4x4_2x_coco_20201212_112133.log.json) | +| HRNetV2p-W18 | pytorch | Y | Y | 2x | 13.0 | 12.9 | 38.3 | [config](./fcos_hrnetv2p-w18-gn-head_ms-640-800-4xb4-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/fcos_hrnetv2p_w18_gn-head_mstrain_640-800_4x4_2x_coco/fcos_hrnetv2p_w18_gn-head_mstrain_640-800_4x4_2x_coco_20201212_111651-441e9d9f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/fcos_hrnetv2p_w18_gn-head_mstrain_640-800_4x4_2x_coco/fcos_hrnetv2p_w18_gn-head_mstrain_640-800_4x4_2x_coco_20201212_111651.log.json) | +| HRNetV2p-W32 | pytorch | Y | Y | 2x | 17.5 | 12.4 | 41.9 | [config](./fcos_hrnetv2p-w32-gn-head_ms-640-800-4xb4-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/fcos_hrnetv2p_w32_gn-head_mstrain_640-800_4x4_2x_coco/fcos_hrnetv2p_w32_gn-head_mstrain_640-800_4x4_2x_coco_20201212_090846-b6f2b49f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/fcos_hrnetv2p_w32_gn-head_mstrain_640-800_4x4_2x_coco/fcos_hrnetv2p_w32_gn-head_mstrain_640-800_4x4_2x_coco_20201212_090846.log.json) | +| HRNetV2p-W48 | pytorch | Y | Y | 2x | 20.3 | 10.8 | 42.7 | [config](./fcos_hrnetv2p-w40-gn-head_ms-640-800-4xb4-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/hrnet/fcos_hrnetv2p_w40_gn-head_mstrain_640-800_4x4_2x_coco/fcos_hrnetv2p_w40_gn-head_mstrain_640-800_4x4_2x_coco_20201212_124752-f22d2ce5.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/hrnet/fcos_hrnetv2p_w40_gn-head_mstrain_640-800_4x4_2x_coco/fcos_hrnetv2p_w40_gn-head_mstrain_640-800_4x4_2x_coco_20201212_124752.log.json) | + +**Note:** + +- The `28e` schedule in HTC indicates decreasing the lr at 24 and 27 epochs, with a total of 28 epochs. +- HRNetV2 ImageNet pretrained models are in [HRNets for Image Classification](https://github.com/HRNet/HRNet-Image-Classification). + +## Citation + +```latex +@inproceedings{SunXLW19, + title={Deep High-Resolution Representation Learning for Human Pose Estimation}, + author={Ke Sun and Bin Xiao and Dong Liu and Jingdong Wang}, + booktitle={CVPR}, + year={2019} +} + +@article{SunZJCXLMWLW19, + title={High-Resolution Representations for Labeling Pixels and Regions}, + author={Ke Sun and Yang Zhao and Borui Jiang and Tianheng Cheng and Bin Xiao + and Dong Liu and Yadong Mu and Xinggang Wang and Wenyu Liu and Jingdong Wang}, + journal = {CoRR}, + volume = {abs/1904.04514}, + year={2019} +} +``` diff --git a/mmdetection/configs/hrnet/cascade-mask-rcnn_hrnetv2p-w18_20e_coco.py b/mmdetection/configs/hrnet/cascade-mask-rcnn_hrnetv2p-w18_20e_coco.py new file mode 100644 index 00000000..5ca0ebfe --- /dev/null +++ b/mmdetection/configs/hrnet/cascade-mask-rcnn_hrnetv2p-w18_20e_coco.py @@ -0,0 +1,11 @@ +_base_ = './cascade-mask-rcnn_hrnetv2p-w32_20e_coco.py' +# model settings +model = dict( + backbone=dict( + extra=dict( + stage2=dict(num_channels=(18, 36)), + stage3=dict(num_channels=(18, 36, 72)), + stage4=dict(num_channels=(18, 36, 72, 144))), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://msra/hrnetv2_w18')), + neck=dict(type='HRFPN', in_channels=[18, 36, 72, 144], out_channels=256)) diff --git a/mmdetection/configs/hrnet/cascade-mask-rcnn_hrnetv2p-w32_20e_coco.py b/mmdetection/configs/hrnet/cascade-mask-rcnn_hrnetv2p-w32_20e_coco.py new file mode 100644 index 00000000..1ffedc39 --- /dev/null +++ b/mmdetection/configs/hrnet/cascade-mask-rcnn_hrnetv2p-w32_20e_coco.py @@ -0,0 +1,51 @@ +_base_ = '../cascade_rcnn/cascade-mask-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + _delete_=True, + type='HRNet', + extra=dict( + stage1=dict( + num_modules=1, + num_branches=1, + block='BOTTLENECK', + num_blocks=(4, ), + num_channels=(64, )), + stage2=dict( + num_modules=1, + num_branches=2, + block='BASIC', + num_blocks=(4, 4), + num_channels=(32, 64)), + stage3=dict( + num_modules=4, + num_branches=3, + block='BASIC', + num_blocks=(4, 4, 4), + num_channels=(32, 64, 128)), + stage4=dict( + num_modules=3, + num_branches=4, + block='BASIC', + num_blocks=(4, 4, 4, 4), + num_channels=(32, 64, 128, 256))), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://msra/hrnetv2_w32')), + neck=dict( + _delete_=True, + type='HRFPN', + in_channels=[32, 64, 128, 256], + out_channels=256)) +# learning policy +max_epochs = 20 +train_cfg = dict(max_epochs=max_epochs) +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 19], + gamma=0.1) +] diff --git a/mmdetection/configs/hrnet/cascade-mask-rcnn_hrnetv2p-w40-20e_coco.py b/mmdetection/configs/hrnet/cascade-mask-rcnn_hrnetv2p-w40-20e_coco.py new file mode 100644 index 00000000..4a51a024 --- /dev/null +++ b/mmdetection/configs/hrnet/cascade-mask-rcnn_hrnetv2p-w40-20e_coco.py @@ -0,0 +1,12 @@ +_base_ = './cascade-mask-rcnn_hrnetv2p-w32_20e_coco.py' +# model settings +model = dict( + backbone=dict( + type='HRNet', + extra=dict( + stage2=dict(num_channels=(40, 80)), + stage3=dict(num_channels=(40, 80, 160)), + stage4=dict(num_channels=(40, 80, 160, 320))), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://msra/hrnetv2_w40')), + neck=dict(type='HRFPN', in_channels=[40, 80, 160, 320], out_channels=256)) diff --git a/mmdetection/configs/hrnet/cascade-rcnn_hrnetv2p-w18-20e_coco.py b/mmdetection/configs/hrnet/cascade-rcnn_hrnetv2p-w18-20e_coco.py new file mode 100644 index 00000000..8834c1d4 --- /dev/null +++ b/mmdetection/configs/hrnet/cascade-rcnn_hrnetv2p-w18-20e_coco.py @@ -0,0 +1,11 @@ +_base_ = './cascade-rcnn_hrnetv2p-w32-20e_coco.py' +# model settings +model = dict( + backbone=dict( + extra=dict( + stage2=dict(num_channels=(18, 36)), + stage3=dict(num_channels=(18, 36, 72)), + stage4=dict(num_channels=(18, 36, 72, 144))), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://msra/hrnetv2_w18')), + neck=dict(type='HRFPN', in_channels=[18, 36, 72, 144], out_channels=256)) diff --git a/mmdetection/configs/hrnet/cascade-rcnn_hrnetv2p-w32-20e_coco.py b/mmdetection/configs/hrnet/cascade-rcnn_hrnetv2p-w32-20e_coco.py new file mode 100644 index 00000000..afeb75db --- /dev/null +++ b/mmdetection/configs/hrnet/cascade-rcnn_hrnetv2p-w32-20e_coco.py @@ -0,0 +1,51 @@ +_base_ = '../cascade_rcnn/cascade-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + _delete_=True, + type='HRNet', + extra=dict( + stage1=dict( + num_modules=1, + num_branches=1, + block='BOTTLENECK', + num_blocks=(4, ), + num_channels=(64, )), + stage2=dict( + num_modules=1, + num_branches=2, + block='BASIC', + num_blocks=(4, 4), + num_channels=(32, 64)), + stage3=dict( + num_modules=4, + num_branches=3, + block='BASIC', + num_blocks=(4, 4, 4), + num_channels=(32, 64, 128)), + stage4=dict( + num_modules=3, + num_branches=4, + block='BASIC', + num_blocks=(4, 4, 4, 4), + num_channels=(32, 64, 128, 256))), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://msra/hrnetv2_w32')), + neck=dict( + _delete_=True, + type='HRFPN', + in_channels=[32, 64, 128, 256], + out_channels=256)) +# learning policy +max_epochs = 20 +train_cfg = dict(max_epochs=max_epochs) +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 19], + gamma=0.1) +] diff --git a/mmdetection/configs/hrnet/cascade-rcnn_hrnetv2p-w40-20e_coco.py b/mmdetection/configs/hrnet/cascade-rcnn_hrnetv2p-w40-20e_coco.py new file mode 100644 index 00000000..66f8882a --- /dev/null +++ b/mmdetection/configs/hrnet/cascade-rcnn_hrnetv2p-w40-20e_coco.py @@ -0,0 +1,12 @@ +_base_ = './cascade-rcnn_hrnetv2p-w32-20e_coco.py' +# model settings +model = dict( + backbone=dict( + type='HRNet', + extra=dict( + stage2=dict(num_channels=(40, 80)), + stage3=dict(num_channels=(40, 80, 160)), + stage4=dict(num_channels=(40, 80, 160, 320))), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://msra/hrnetv2_w40')), + neck=dict(type='HRFPN', in_channels=[40, 80, 160, 320], out_channels=256)) diff --git a/mmdetection/configs/hrnet/faster-rcnn_hrnetv2p-w18-1x_coco.py b/mmdetection/configs/hrnet/faster-rcnn_hrnetv2p-w18-1x_coco.py new file mode 100644 index 00000000..ee9a6986 --- /dev/null +++ b/mmdetection/configs/hrnet/faster-rcnn_hrnetv2p-w18-1x_coco.py @@ -0,0 +1,11 @@ +_base_ = './faster-rcnn_hrnetv2p-w32-1x_coco.py' +# model settings +model = dict( + backbone=dict( + extra=dict( + stage2=dict(num_channels=(18, 36)), + stage3=dict(num_channels=(18, 36, 72)), + stage4=dict(num_channels=(18, 36, 72, 144))), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://msra/hrnetv2_w18')), + neck=dict(type='HRFPN', in_channels=[18, 36, 72, 144], out_channels=256)) diff --git a/mmdetection/configs/hrnet/faster-rcnn_hrnetv2p-w18-2x_coco.py b/mmdetection/configs/hrnet/faster-rcnn_hrnetv2p-w18-2x_coco.py new file mode 100644 index 00000000..0b72c68f --- /dev/null +++ b/mmdetection/configs/hrnet/faster-rcnn_hrnetv2p-w18-2x_coco.py @@ -0,0 +1,16 @@ +_base_ = './faster-rcnn_hrnetv2p-w18-1x_coco.py' + +# learning policy +max_epochs = 24 +train_cfg = dict(max_epochs=max_epochs) +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/hrnet/faster-rcnn_hrnetv2p-w32-1x_coco.py b/mmdetection/configs/hrnet/faster-rcnn_hrnetv2p-w32-1x_coco.py new file mode 100644 index 00000000..a27ad06c --- /dev/null +++ b/mmdetection/configs/hrnet/faster-rcnn_hrnetv2p-w32-1x_coco.py @@ -0,0 +1,37 @@ +_base_ = '../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + _delete_=True, + type='HRNet', + extra=dict( + stage1=dict( + num_modules=1, + num_branches=1, + block='BOTTLENECK', + num_blocks=(4, ), + num_channels=(64, )), + stage2=dict( + num_modules=1, + num_branches=2, + block='BASIC', + num_blocks=(4, 4), + num_channels=(32, 64)), + stage3=dict( + num_modules=4, + num_branches=3, + block='BASIC', + num_blocks=(4, 4, 4), + num_channels=(32, 64, 128)), + stage4=dict( + num_modules=3, + num_branches=4, + block='BASIC', + num_blocks=(4, 4, 4, 4), + num_channels=(32, 64, 128, 256))), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://msra/hrnetv2_w32')), + neck=dict( + _delete_=True, + type='HRFPN', + in_channels=[32, 64, 128, 256], + out_channels=256)) diff --git a/mmdetection/configs/hrnet/faster-rcnn_hrnetv2p-w32_2x_coco.py b/mmdetection/configs/hrnet/faster-rcnn_hrnetv2p-w32_2x_coco.py new file mode 100644 index 00000000..c9568ce6 --- /dev/null +++ b/mmdetection/configs/hrnet/faster-rcnn_hrnetv2p-w32_2x_coco.py @@ -0,0 +1,16 @@ +_base_ = './faster-rcnn_hrnetv2p-w32-1x_coco.py' + +# learning policy +max_epochs = 24 +train_cfg = dict(max_epochs=max_epochs) +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/hrnet/faster-rcnn_hrnetv2p-w40-1x_coco.py b/mmdetection/configs/hrnet/faster-rcnn_hrnetv2p-w40-1x_coco.py new file mode 100644 index 00000000..b3620023 --- /dev/null +++ b/mmdetection/configs/hrnet/faster-rcnn_hrnetv2p-w40-1x_coco.py @@ -0,0 +1,11 @@ +_base_ = './faster-rcnn_hrnetv2p-w32-1x_coco.py' +model = dict( + backbone=dict( + type='HRNet', + extra=dict( + stage2=dict(num_channels=(40, 80)), + stage3=dict(num_channels=(40, 80, 160)), + stage4=dict(num_channels=(40, 80, 160, 320))), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://msra/hrnetv2_w40')), + neck=dict(type='HRFPN', in_channels=[40, 80, 160, 320], out_channels=256)) diff --git a/mmdetection/configs/hrnet/faster-rcnn_hrnetv2p-w40_2x_coco.py b/mmdetection/configs/hrnet/faster-rcnn_hrnetv2p-w40_2x_coco.py new file mode 100644 index 00000000..d1b45355 --- /dev/null +++ b/mmdetection/configs/hrnet/faster-rcnn_hrnetv2p-w40_2x_coco.py @@ -0,0 +1,16 @@ +_base_ = './faster-rcnn_hrnetv2p-w40-1x_coco.py' + +# learning policy +max_epochs = 24 +train_cfg = dict(max_epochs=max_epochs) +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/hrnet/fcos_hrnetv2p-w18-gn-head_4xb4-1x_coco.py b/mmdetection/configs/hrnet/fcos_hrnetv2p-w18-gn-head_4xb4-1x_coco.py new file mode 100644 index 00000000..c20ca776 --- /dev/null +++ b/mmdetection/configs/hrnet/fcos_hrnetv2p-w18-gn-head_4xb4-1x_coco.py @@ -0,0 +1,10 @@ +_base_ = './fcos_hrnetv2p-w32-gn-head_4xb4-1x_coco.py' +model = dict( + backbone=dict( + extra=dict( + stage2=dict(num_channels=(18, 36)), + stage3=dict(num_channels=(18, 36, 72)), + stage4=dict(num_channels=(18, 36, 72, 144))), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://msra/hrnetv2_w18')), + neck=dict(type='HRFPN', in_channels=[18, 36, 72, 144], out_channels=256)) diff --git a/mmdetection/configs/hrnet/fcos_hrnetv2p-w18-gn-head_4xb4-2x_coco.py b/mmdetection/configs/hrnet/fcos_hrnetv2p-w18-gn-head_4xb4-2x_coco.py new file mode 100644 index 00000000..f5b67f6a --- /dev/null +++ b/mmdetection/configs/hrnet/fcos_hrnetv2p-w18-gn-head_4xb4-2x_coco.py @@ -0,0 +1,16 @@ +_base_ = './fcos_hrnetv2p-w18-gn-head_4xb4-1x_coco.py' + +# learning policy +max_epochs = 24 +train_cfg = dict(max_epochs=max_epochs) +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/hrnet/fcos_hrnetv2p-w18-gn-head_ms-640-800-4xb4-2x_coco.py b/mmdetection/configs/hrnet/fcos_hrnetv2p-w18-gn-head_ms-640-800-4xb4-2x_coco.py new file mode 100644 index 00000000..c5332d65 --- /dev/null +++ b/mmdetection/configs/hrnet/fcos_hrnetv2p-w18-gn-head_ms-640-800-4xb4-2x_coco.py @@ -0,0 +1,10 @@ +_base_ = './fcos_hrnetv2p-w32-gn-head_ms-640-800-4xb4-2x_coco.py' +model = dict( + backbone=dict( + extra=dict( + stage2=dict(num_channels=(18, 36)), + stage3=dict(num_channels=(18, 36, 72)), + stage4=dict(num_channels=(18, 36, 72, 144))), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://msra/hrnetv2_w18')), + neck=dict(type='HRFPN', in_channels=[18, 36, 72, 144], out_channels=256)) diff --git a/mmdetection/configs/hrnet/fcos_hrnetv2p-w32-gn-head_4xb4-1x_coco.py b/mmdetection/configs/hrnet/fcos_hrnetv2p-w32-gn-head_4xb4-1x_coco.py new file mode 100644 index 00000000..159d96d7 --- /dev/null +++ b/mmdetection/configs/hrnet/fcos_hrnetv2p-w32-gn-head_4xb4-1x_coco.py @@ -0,0 +1,43 @@ +_base_ = '../fcos/fcos_r50-caffe_fpn_gn-head_4xb4-1x_coco.py' +model = dict( + data_preprocessor=dict( + mean=[103.53, 116.28, 123.675], + std=[57.375, 57.12, 58.395], + bgr_to_rgb=False), + backbone=dict( + _delete_=True, + type='HRNet', + extra=dict( + stage1=dict( + num_modules=1, + num_branches=1, + block='BOTTLENECK', + num_blocks=(4, ), + num_channels=(64, )), + stage2=dict( + num_modules=1, + num_branches=2, + block='BASIC', + num_blocks=(4, 4), + num_channels=(32, 64)), + stage3=dict( + num_modules=4, + num_branches=3, + block='BASIC', + num_blocks=(4, 4, 4), + num_channels=(32, 64, 128)), + stage4=dict( + num_modules=3, + num_branches=4, + block='BASIC', + num_blocks=(4, 4, 4, 4), + num_channels=(32, 64, 128, 256))), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://msra/hrnetv2_w32')), + neck=dict( + _delete_=True, + type='HRFPN', + in_channels=[32, 64, 128, 256], + out_channels=256, + stride=2, + num_outs=5)) diff --git a/mmdetection/configs/hrnet/fcos_hrnetv2p-w32-gn-head_4xb4-2x_coco.py b/mmdetection/configs/hrnet/fcos_hrnetv2p-w32-gn-head_4xb4-2x_coco.py new file mode 100644 index 00000000..73fd80e9 --- /dev/null +++ b/mmdetection/configs/hrnet/fcos_hrnetv2p-w32-gn-head_4xb4-2x_coco.py @@ -0,0 +1,16 @@ +_base_ = './fcos_hrnetv2p-w32-gn-head_4xb4-1x_coco.py' + +# learning policy +max_epochs = 24 +train_cfg = dict(max_epochs=max_epochs) +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/hrnet/fcos_hrnetv2p-w32-gn-head_ms-640-800-4xb4-2x_coco.py b/mmdetection/configs/hrnet/fcos_hrnetv2p-w32-gn-head_ms-640-800-4xb4-2x_coco.py new file mode 100644 index 00000000..4c977bf3 --- /dev/null +++ b/mmdetection/configs/hrnet/fcos_hrnetv2p-w32-gn-head_ms-640-800-4xb4-2x_coco.py @@ -0,0 +1,35 @@ +_base_ = './fcos_hrnetv2p-w32-gn-head_4xb4-1x_coco.py' + +model = dict( + data_preprocessor=dict( + mean=[103.53, 116.28, 123.675], + std=[57.375, 57.12, 58.395], + bgr_to_rgb=False)) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +# learning policy +max_epochs = 24 +train_cfg = dict(max_epochs=max_epochs) +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/hrnet/fcos_hrnetv2p-w40-gn-head_ms-640-800-4xb4-2x_coco.py b/mmdetection/configs/hrnet/fcos_hrnetv2p-w40-gn-head_ms-640-800-4xb4-2x_coco.py new file mode 100644 index 00000000..bb0ff6d6 --- /dev/null +++ b/mmdetection/configs/hrnet/fcos_hrnetv2p-w40-gn-head_ms-640-800-4xb4-2x_coco.py @@ -0,0 +1,11 @@ +_base_ = './fcos_hrnetv2p-w32-gn-head_ms-640-800-4xb4-2x_coco.py' +model = dict( + backbone=dict( + type='HRNet', + extra=dict( + stage2=dict(num_channels=(40, 80)), + stage3=dict(num_channels=(40, 80, 160)), + stage4=dict(num_channels=(40, 80, 160, 320))), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://msra/hrnetv2_w40')), + neck=dict(type='HRFPN', in_channels=[40, 80, 160, 320], out_channels=256)) diff --git a/mmdetection/configs/hrnet/htc_hrnetv2p-w18_20e_coco.py b/mmdetection/configs/hrnet/htc_hrnetv2p-w18_20e_coco.py new file mode 100644 index 00000000..55255d52 --- /dev/null +++ b/mmdetection/configs/hrnet/htc_hrnetv2p-w18_20e_coco.py @@ -0,0 +1,10 @@ +_base_ = './htc_hrnetv2p-w32_20e_coco.py' +model = dict( + backbone=dict( + extra=dict( + stage2=dict(num_channels=(18, 36)), + stage3=dict(num_channels=(18, 36, 72)), + stage4=dict(num_channels=(18, 36, 72, 144))), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://msra/hrnetv2_w18')), + neck=dict(type='HRFPN', in_channels=[18, 36, 72, 144], out_channels=256)) diff --git a/mmdetection/configs/hrnet/htc_hrnetv2p-w32_20e_coco.py b/mmdetection/configs/hrnet/htc_hrnetv2p-w32_20e_coco.py new file mode 100644 index 00000000..545cb83e --- /dev/null +++ b/mmdetection/configs/hrnet/htc_hrnetv2p-w32_20e_coco.py @@ -0,0 +1,37 @@ +_base_ = '../htc/htc_r50_fpn_20e_coco.py' +model = dict( + backbone=dict( + _delete_=True, + type='HRNet', + extra=dict( + stage1=dict( + num_modules=1, + num_branches=1, + block='BOTTLENECK', + num_blocks=(4, ), + num_channels=(64, )), + stage2=dict( + num_modules=1, + num_branches=2, + block='BASIC', + num_blocks=(4, 4), + num_channels=(32, 64)), + stage3=dict( + num_modules=4, + num_branches=3, + block='BASIC', + num_blocks=(4, 4, 4), + num_channels=(32, 64, 128)), + stage4=dict( + num_modules=3, + num_branches=4, + block='BASIC', + num_blocks=(4, 4, 4, 4), + num_channels=(32, 64, 128, 256))), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://msra/hrnetv2_w32')), + neck=dict( + _delete_=True, + type='HRFPN', + in_channels=[32, 64, 128, 256], + out_channels=256)) diff --git a/mmdetection/configs/hrnet/htc_hrnetv2p-w40_20e_coco.py b/mmdetection/configs/hrnet/htc_hrnetv2p-w40_20e_coco.py new file mode 100644 index 00000000..b09256a0 --- /dev/null +++ b/mmdetection/configs/hrnet/htc_hrnetv2p-w40_20e_coco.py @@ -0,0 +1,11 @@ +_base_ = './htc_hrnetv2p-w32_20e_coco.py' +model = dict( + backbone=dict( + type='HRNet', + extra=dict( + stage2=dict(num_channels=(40, 80)), + stage3=dict(num_channels=(40, 80, 160)), + stage4=dict(num_channels=(40, 80, 160, 320))), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://msra/hrnetv2_w40')), + neck=dict(type='HRFPN', in_channels=[40, 80, 160, 320], out_channels=256)) diff --git a/mmdetection/configs/hrnet/htc_hrnetv2p-w40_28e_coco.py b/mmdetection/configs/hrnet/htc_hrnetv2p-w40_28e_coco.py new file mode 100644 index 00000000..1c13b58a --- /dev/null +++ b/mmdetection/configs/hrnet/htc_hrnetv2p-w40_28e_coco.py @@ -0,0 +1,16 @@ +_base_ = './htc_hrnetv2p-w40_20e_coco.py' + +# learning policy +max_epochs = 28 +train_cfg = dict(max_epochs=max_epochs) +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[24, 27], + gamma=0.1) +] diff --git a/mmdetection/configs/hrnet/htc_x101-64x4d_fpn_16xb1-28e_coco.py b/mmdetection/configs/hrnet/htc_x101-64x4d_fpn_16xb1-28e_coco.py new file mode 100644 index 00000000..1f1304e5 --- /dev/null +++ b/mmdetection/configs/hrnet/htc_x101-64x4d_fpn_16xb1-28e_coco.py @@ -0,0 +1,16 @@ +_base_ = '../htc/htc_x101-64x4d_fpn_16xb1-20e_coco.py' + +# learning policy +max_epochs = 28 +train_cfg = dict(max_epochs=max_epochs) +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[24, 27], + gamma=0.1) +] diff --git a/mmdetection/configs/hrnet/mask-rcnn_hrnetv2p-w18-1x_coco.py b/mmdetection/configs/hrnet/mask-rcnn_hrnetv2p-w18-1x_coco.py new file mode 100644 index 00000000..5d5a463a --- /dev/null +++ b/mmdetection/configs/hrnet/mask-rcnn_hrnetv2p-w18-1x_coco.py @@ -0,0 +1,10 @@ +_base_ = './mask-rcnn_hrnetv2p-w32-1x_coco.py' +model = dict( + backbone=dict( + extra=dict( + stage2=dict(num_channels=(18, 36)), + stage3=dict(num_channels=(18, 36, 72)), + stage4=dict(num_channels=(18, 36, 72, 144))), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://msra/hrnetv2_w18')), + neck=dict(type='HRFPN', in_channels=[18, 36, 72, 144], out_channels=256)) diff --git a/mmdetection/configs/hrnet/mask-rcnn_hrnetv2p-w18-2x_coco.py b/mmdetection/configs/hrnet/mask-rcnn_hrnetv2p-w18-2x_coco.py new file mode 100644 index 00000000..8abc5592 --- /dev/null +++ b/mmdetection/configs/hrnet/mask-rcnn_hrnetv2p-w18-2x_coco.py @@ -0,0 +1,16 @@ +_base_ = './mask-rcnn_hrnetv2p-w18-1x_coco.py' + +# learning policy +max_epochs = 24 +train_cfg = dict(max_epochs=max_epochs) +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/hrnet/mask-rcnn_hrnetv2p-w32-1x_coco.py b/mmdetection/configs/hrnet/mask-rcnn_hrnetv2p-w32-1x_coco.py new file mode 100644 index 00000000..208b0378 --- /dev/null +++ b/mmdetection/configs/hrnet/mask-rcnn_hrnetv2p-w32-1x_coco.py @@ -0,0 +1,37 @@ +_base_ = '../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + _delete_=True, + type='HRNet', + extra=dict( + stage1=dict( + num_modules=1, + num_branches=1, + block='BOTTLENECK', + num_blocks=(4, ), + num_channels=(64, )), + stage2=dict( + num_modules=1, + num_branches=2, + block='BASIC', + num_blocks=(4, 4), + num_channels=(32, 64)), + stage3=dict( + num_modules=4, + num_branches=3, + block='BASIC', + num_blocks=(4, 4, 4), + num_channels=(32, 64, 128)), + stage4=dict( + num_modules=3, + num_branches=4, + block='BASIC', + num_blocks=(4, 4, 4, 4), + num_channels=(32, 64, 128, 256))), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://msra/hrnetv2_w32')), + neck=dict( + _delete_=True, + type='HRFPN', + in_channels=[32, 64, 128, 256], + out_channels=256)) diff --git a/mmdetection/configs/hrnet/mask-rcnn_hrnetv2p-w32-2x_coco.py b/mmdetection/configs/hrnet/mask-rcnn_hrnetv2p-w32-2x_coco.py new file mode 100644 index 00000000..d3741c82 --- /dev/null +++ b/mmdetection/configs/hrnet/mask-rcnn_hrnetv2p-w32-2x_coco.py @@ -0,0 +1,16 @@ +_base_ = './mask-rcnn_hrnetv2p-w32-1x_coco.py' + +# learning policy +max_epochs = 24 +train_cfg = dict(max_epochs=max_epochs) +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/hrnet/mask-rcnn_hrnetv2p-w40-2x_coco.py b/mmdetection/configs/hrnet/mask-rcnn_hrnetv2p-w40-2x_coco.py new file mode 100644 index 00000000..360420c5 --- /dev/null +++ b/mmdetection/configs/hrnet/mask-rcnn_hrnetv2p-w40-2x_coco.py @@ -0,0 +1,16 @@ +_base_ = './mask-rcnn_hrnetv2p-w40_1x_coco.py' + +# learning policy +max_epochs = 24 +train_cfg = dict(max_epochs=max_epochs) +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/hrnet/mask-rcnn_hrnetv2p-w40_1x_coco.py b/mmdetection/configs/hrnet/mask-rcnn_hrnetv2p-w40_1x_coco.py new file mode 100644 index 00000000..36e2305a --- /dev/null +++ b/mmdetection/configs/hrnet/mask-rcnn_hrnetv2p-w40_1x_coco.py @@ -0,0 +1,11 @@ +_base_ = './mask-rcnn_hrnetv2p-w18-1x_coco.py' +model = dict( + backbone=dict( + type='HRNet', + extra=dict( + stage2=dict(num_channels=(40, 80)), + stage3=dict(num_channels=(40, 80, 160)), + stage4=dict(num_channels=(40, 80, 160, 320))), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://msra/hrnetv2_w40')), + neck=dict(type='HRFPN', in_channels=[40, 80, 160, 320], out_channels=256)) diff --git a/mmdetection/configs/hrnet/metafile.yml b/mmdetection/configs/hrnet/metafile.yml new file mode 100644 index 00000000..54c62479 --- /dev/null +++ b/mmdetection/configs/hrnet/metafile.yml @@ -0,0 +1,971 @@ +Models: + - Name: faster-rcnn_hrnetv2p-w18-1x_coco + In Collection: Faster R-CNN + Config: configs/hrnet/faster-rcnn_hrnetv2p-w18-1x_coco.py + Metadata: + Training Memory (GB): 6.6 + inference time (ms/im): + - value: 74.63 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 36.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/faster_rcnn_hrnetv2p_w18_1x_coco/faster_rcnn_hrnetv2p_w18_1x_coco_20200130-56651a6d.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: faster-rcnn_hrnetv2p-w18-2x_coco + In Collection: Faster R-CNN + Config: configs/hrnet/faster-rcnn_hrnetv2p-w18-2x_coco.py + Metadata: + Training Memory (GB): 6.6 + inference time (ms/im): + - value: 74.63 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/faster_rcnn_hrnetv2p_w18_2x_coco/faster_rcnn_hrnetv2p_w18_2x_coco_20200702_085731-a4ec0611.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: faster-rcnn_hrnetv2p-w32-1x_coco + In Collection: Faster R-CNN + Config: configs/hrnet/faster-rcnn_hrnetv2p-w32-1x_coco.py + Metadata: + Training Memory (GB): 9.0 + inference time (ms/im): + - value: 80.65 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/faster_rcnn_hrnetv2p_w32_1x_coco/faster_rcnn_hrnetv2p_w32_1x_coco_20200130-6e286425.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: faster-rcnn_hrnetv2p-w32_2x_coco + In Collection: Faster R-CNN + Config: configs/hrnet/faster-rcnn_hrnetv2p-w32_2x_coco.py + Metadata: + Training Memory (GB): 9.0 + inference time (ms/im): + - value: 80.65 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/faster_rcnn_hrnetv2p_w32_2x_coco/faster_rcnn_hrnetv2p_w32_2x_coco_20200529_015927-976a9c15.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: faster-rcnn_hrnetv2p-w40-1x_coco + In Collection: Faster R-CNN + Config: configs/hrnet/faster-rcnn_hrnetv2p-w40-1x_coco.py + Metadata: + Training Memory (GB): 10.4 + inference time (ms/im): + - value: 95.24 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/faster_rcnn_hrnetv2p_w40_1x_coco/faster_rcnn_hrnetv2p_w40_1x_coco_20200210-95c1f5ce.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: faster-rcnn_hrnetv2p-w40_2x_coco + In Collection: Faster R-CNN + Config: configs/hrnet/faster-rcnn_hrnetv2p-w40_2x_coco.py + Metadata: + Training Memory (GB): 10.4 + inference time (ms/im): + - value: 95.24 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/faster_rcnn_hrnetv2p_w40_2x_coco/faster_rcnn_hrnetv2p_w40_2x_coco_20200512_161033-0f236ef4.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: mask-rcnn_hrnetv2p-w18-1x_coco + In Collection: Mask R-CNN + Config: configs/hrnet/mask-rcnn_hrnetv2p-w18-1x_coco.py + Metadata: + Training Memory (GB): 7.0 + inference time (ms/im): + - value: 85.47 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.7 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 34.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/mask_rcnn_hrnetv2p_w18_1x_coco/mask_rcnn_hrnetv2p_w18_1x_coco_20200205-1c3d78ed.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: mask-rcnn_hrnetv2p-w18-2x_coco + In Collection: Mask R-CNN + Config: configs/hrnet/mask-rcnn_hrnetv2p-w18-2x_coco.py + Metadata: + Training Memory (GB): 7.0 + inference time (ms/im): + - value: 85.47 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/mask_rcnn_hrnetv2p_w18_2x_coco/mask_rcnn_hrnetv2p_w18_2x_coco_20200212-b3c825b1.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: mask-rcnn_hrnetv2p-w32-1x_coco + In Collection: Mask R-CNN + Config: configs/hrnet/mask-rcnn_hrnetv2p-w32-1x_coco.py + Metadata: + Training Memory (GB): 9.4 + inference time (ms/im): + - value: 88.5 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.2 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/mask_rcnn_hrnetv2p_w32_1x_coco/mask_rcnn_hrnetv2p_w32_1x_coco_20200207-b29f616e.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: mask-rcnn_hrnetv2p-w32-2x_coco + In Collection: Mask R-CNN + Config: configs/hrnet/mask-rcnn_hrnetv2p-w32-2x_coco.py + Metadata: + Training Memory (GB): 9.4 + inference time (ms/im): + - value: 88.5 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.5 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/mask_rcnn_hrnetv2p_w32_2x_coco/mask_rcnn_hrnetv2p_w32_2x_coco_20200213-45b75b4d.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: mask-rcnn_hrnetv2p-w40_1x_coco + In Collection: Mask R-CNN + Config: configs/hrnet/mask-rcnn_hrnetv2p-w40_1x_coco.py + Metadata: + Training Memory (GB): 10.9 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.1 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/mask_rcnn_hrnetv2p_w40_1x_coco/mask_rcnn_hrnetv2p_w40_1x_coco_20200511_015646-66738b35.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: mask-rcnn_hrnetv2p-w40-2x_coco + In Collection: Mask R-CNN + Config: configs/hrnet/mask-rcnn_hrnetv2p-w40-2x_coco.py + Metadata: + Training Memory (GB): 10.9 + Epochs: 24 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/mask_rcnn_hrnetv2p_w40_2x_coco/mask_rcnn_hrnetv2p_w40_2x_coco_20200512_163732-aed5e4ab.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: cascade-rcnn_hrnetv2p-w18-20e_coco + In Collection: Cascade R-CNN + Config: configs/hrnet/cascade-rcnn_hrnetv2p-w18-20e_coco.py + Metadata: + Training Memory (GB): 7.0 + inference time (ms/im): + - value: 90.91 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 20 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/cascade_rcnn_hrnetv2p_w18_20e_coco/cascade_rcnn_hrnetv2p_w18_20e_coco_20200210-434be9d7.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: cascade-rcnn_hrnetv2p-w32-20e_coco + In Collection: Cascade R-CNN + Config: configs/hrnet/cascade-rcnn_hrnetv2p-w32-20e_coco.py + Metadata: + Training Memory (GB): 9.4 + inference time (ms/im): + - value: 90.91 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 20 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/cascade_rcnn_hrnetv2p_w32_20e_coco/cascade_rcnn_hrnetv2p_w32_20e_coco_20200208-928455a4.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: cascade-rcnn_hrnetv2p-w40-20e_coco + In Collection: Cascade R-CNN + Config: configs/hrnet/cascade-rcnn_hrnetv2p-w40-20e_coco.py + Metadata: + Training Memory (GB): 10.8 + Epochs: 20 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/cascade_rcnn_hrnetv2p_w40_20e_coco/cascade_rcnn_hrnetv2p_w40_20e_coco_20200512_161112-75e47b04.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: cascade-mask-rcnn_hrnetv2p-w18_20e_coco + In Collection: Cascade R-CNN + Config: configs/hrnet/cascade-mask-rcnn_hrnetv2p-w18_20e_coco.py + Metadata: + Training Memory (GB): 8.5 + inference time (ms/im): + - value: 117.65 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 20 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.6 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/cascade_mask_rcnn_hrnetv2p_w18_20e_coco/cascade_mask_rcnn_hrnetv2p_w18_20e_coco_20200210-b543cd2b.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: cascade-mask-rcnn_hrnetv2p-w32_20e_coco + In Collection: Cascade R-CNN + Config: configs/hrnet/cascade-mask-rcnn_hrnetv2p-w32_20e_coco.py + Metadata: + inference time (ms/im): + - value: 120.48 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 20 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.3 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/cascade_mask_rcnn_hrnetv2p_w32_20e_coco/cascade_mask_rcnn_hrnetv2p_w32_20e_coco_20200512_154043-39d9cf7b.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: cascade-mask-rcnn_hrnetv2p-w40-20e_coco + In Collection: Cascade R-CNN + Config: configs/hrnet/cascade-mask-rcnn_hrnetv2p-w40-20e_coco.py + Metadata: + Training Memory (GB): 12.5 + Epochs: 20 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.1 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/cascade_mask_rcnn_hrnetv2p_w40_20e_coco/cascade_mask_rcnn_hrnetv2p_w40_20e_coco_20200527_204922-969c4610.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: htc_hrnetv2p-w18_20e_coco + In Collection: HTC + Config: configs/hrnet/htc_hrnetv2p-w18_20e_coco.py + Metadata: + Training Memory (GB): 10.8 + inference time (ms/im): + - value: 212.77 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 20 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/htc_hrnetv2p_w18_20e_coco/htc_hrnetv2p_w18_20e_coco_20200210-b266988c.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: htc_hrnetv2p-w32_20e_coco + In Collection: HTC + Config: configs/hrnet/htc_hrnetv2p-w32_20e_coco.py + Metadata: + Training Memory (GB): 13.1 + inference time (ms/im): + - value: 204.08 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 20 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.4 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/htc_hrnetv2p_w32_20e_coco/htc_hrnetv2p_w32_20e_coco_20200207-7639fa12.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: htc_hrnetv2p-w40_20e_coco + In Collection: HTC + Config: configs/hrnet/htc_hrnetv2p-w40_20e_coco.py + Metadata: + Training Memory (GB): 14.6 + Epochs: 20 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.4 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 40.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/htc_hrnetv2p_w40_20e_coco/htc_hrnetv2p_w40_20e_coco_20200529_183411-417c4d5b.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: fcos_hrnetv2p-w18-gn-head_4xb4-1x_coco + In Collection: FCOS + Config: configs/hrnet/fcos_hrnetv2p-w18-gn-head_4xb4-1x_coco.py + Metadata: + Training Resources: 4x V100 GPUs + Batch Size: 16 + Training Memory (GB): 13.0 + inference time (ms/im): + - value: 77.52 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 35.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/fcos_hrnetv2p_w18_gn-head_4x4_1x_coco/fcos_hrnetv2p_w18_gn-head_4x4_1x_coco_20201212_100710-4ad151de.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: fcos_hrnetv2p-w18-gn-head_4xb4-2x_coco + In Collection: FCOS + Config: configs/hrnet/fcos_hrnetv2p-w18-gn-head_4xb4-2x_coco.py + Metadata: + Training Resources: 4x V100 GPUs + Batch Size: 16 + Training Memory (GB): 13.0 + inference time (ms/im): + - value: 77.52 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/fcos_hrnetv2p_w18_gn-head_4x4_2x_coco/fcos_hrnetv2p_w18_gn-head_4x4_2x_coco_20201212_101110-5c575fa5.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: fcos_hrnetv2p-w32-gn-head_4xb4-1x_coco + In Collection: FCOS + Config: configs/hrnet/fcos_hrnetv2p-w32-gn-head_4xb4-1x_coco.py + Metadata: + Training Resources: 4x V100 GPUs + Batch Size: 16 + Training Memory (GB): 17.5 + inference time (ms/im): + - value: 77.52 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/fcos_hrnetv2p_w32_gn-head_4x4_1x_coco/fcos_hrnetv2p_w32_gn-head_4x4_1x_coco_20201211_134730-cb8055c0.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: fcos_hrnetv2p-w32-gn-head_4xb4-2x_coco + In Collection: FCOS + Config: configs/hrnet/fcos_hrnetv2p-w32-gn-head_4xb4-2x_coco.py + Metadata: + Training Resources: 4x V100 GPUs + Batch Size: 16 + Training Memory (GB): 17.5 + inference time (ms/im): + - value: 77.52 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/fcos_hrnetv2p_w32_gn-head_4x4_2x_coco/fcos_hrnetv2p_w32_gn-head_4x4_2x_coco_20201212_112133-77b6b9bb.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: fcos_hrnetv2p-w18-gn-head_ms-640-800-4xb4-2x_coco + In Collection: FCOS + Config: configs/hrnet/fcos_hrnetv2p-w18-gn-head_ms-640-800-4xb4-2x_coco.py + Metadata: + Training Resources: 4x V100 GPUs + Batch Size: 16 + Training Memory (GB): 13.0 + inference time (ms/im): + - value: 77.52 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/fcos_hrnetv2p_w18_gn-head_mstrain_640-800_4x4_2x_coco/fcos_hrnetv2p_w18_gn-head_mstrain_640-800_4x4_2x_coco_20201212_111651-441e9d9f.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: fcos_hrnetv2p-w32-gn-head_ms-640-800-4xb4-2x_coco + In Collection: FCOS + Config: configs/hrnet/fcos_hrnetv2p-w32-gn-head_ms-640-800-4xb4-2x_coco.py + Metadata: + Training Resources: 4x V100 GPUs + Batch Size: 16 + Training Memory (GB): 17.5 + inference time (ms/im): + - value: 80.65 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/fcos_hrnetv2p_w32_gn-head_mstrain_640-800_4x4_2x_coco/fcos_hrnetv2p_w32_gn-head_mstrain_640-800_4x4_2x_coco_20201212_090846-b6f2b49f.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 + + - Name: fcos_hrnetv2p-w40-gn-head_ms-640-800-4xb4-2x_coco + In Collection: FCOS + Config: configs/hrnet/fcos_hrnetv2p-w40-gn-head_ms-640-800-4xb4-2x_coco.py + Metadata: + Training Resources: 4x V100 GPUs + Batch Size: 16 + Training Memory (GB): 20.3 + inference time (ms/im): + - value: 92.59 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Architecture: + - HRNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/hrnet/fcos_hrnetv2p_w40_gn-head_mstrain_640-800_4x4_2x_coco/fcos_hrnetv2p_w40_gn-head_mstrain_640-800_4x4_2x_coco_20201212_124752-f22d2ce5.pth + Paper: + URL: https://arxiv.org/abs/1904.04514 + Title: 'Deep High-Resolution Representation Learning for Visual Recognition' + README: configs/hrnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/backbones/hrnet.py#L195 + Version: v2.0.0 diff --git a/mmdetection/configs/htc/README.md b/mmdetection/configs/htc/README.md new file mode 100644 index 00000000..a6b77ce4 --- /dev/null +++ b/mmdetection/configs/htc/README.md @@ -0,0 +1,67 @@ +# HTC + +> [Hybrid Task Cascade for Instance Segmentation](https://arxiv.org/abs/1901.07518) + + + +## Abstract + +Cascade is a classic yet powerful architecture that has boosted performance on various tasks. However, how to introduce cascade to instance segmentation remains an open question. A simple combination of Cascade R-CNN and Mask R-CNN only brings limited gain. In exploring a more effective approach, we find that the key to a successful instance segmentation cascade is to fully leverage the reciprocal relationship between detection and segmentation. In this work, we propose a new framework, Hybrid Task Cascade (HTC), which differs in two important aspects: (1) instead of performing cascaded refinement on these two tasks separately, it interweaves them for a joint multi-stage processing; (2) it adopts a fully convolutional branch to provide spatial context, which can help distinguishing hard foreground from cluttered background. Overall, this framework can learn more discriminative features progressively while integrating complementary features together in each stage. Without bells and whistles, a single HTC obtains 38.4 and 1.5 improvement over a strong Cascade Mask R-CNN baseline on MSCOCO dataset. Moreover, our overall system achieves 48.6 mask AP on the test-challenge split, ranking 1st in the COCO 2018 Challenge Object Detection Task. + +
    + +
    + +## Introduction + +HTC requires COCO and [COCO-stuff](http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/stuffthingmaps_trainval2017.zip) dataset for training. You need to download and extract it in the COCO dataset path. +The directory should be like this. + +```none +mmdetection +├── mmdet +├── tools +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ ├── train2017 +│ │ ├── val2017 +│ │ ├── test2017 +| | ├── stuffthingmaps +``` + +## Results and Models + +The results on COCO 2017val are shown in the below table. (results on test-dev are usually slightly higher than val) + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :-------------: | :-----: | :-----: | :------: | :------------: | :----: | :-----: | :----------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | pytorch | 1x | 8.2 | 5.8 | 42.3 | 37.4 | [config](./htc_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/htc/htc_r50_fpn_1x_coco/htc_r50_fpn_1x_coco_20200317-7332cf16.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/htc/htc_r50_fpn_1x_coco/htc_r50_fpn_1x_coco_20200317_070435.log.json) | +| R-50-FPN | pytorch | 20e | 8.2 | - | 43.3 | 38.3 | [config](./htc_r50_fpn_20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/htc/htc_r50_fpn_20e_coco/htc_r50_fpn_20e_coco_20200319-fe28c577.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/htc/htc_r50_fpn_20e_coco/htc_r50_fpn_20e_coco_20200319_070313.log.json) | +| R-101-FPN | pytorch | 20e | 10.2 | 5.5 | 44.8 | 39.6 | [config](./htc_r101_fpn_20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/htc/htc_r101_fpn_20e_coco/htc_r101_fpn_20e_coco_20200317-9b41b48f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/htc/htc_r101_fpn_20e_coco/htc_r101_fpn_20e_coco_20200317_153107.log.json) | +| X-101-32x4d-FPN | pytorch | 20e | 11.4 | 5.0 | 46.1 | 40.5 | [config](./htc_x101-32x4d_fpn_16xb1-20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/htc/htc_x101_32x4d_fpn_16x1_20e_coco/htc_x101_32x4d_fpn_16x1_20e_coco_20200318-de97ae01.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/htc/htc_x101_32x4d_fpn_16x1_20e_coco/htc_x101_32x4d_fpn_16x1_20e_coco_20200318_034519.log.json) | +| X-101-64x4d-FPN | pytorch | 20e | 14.5 | 4.4 | 47.0 | 41.4 | [config](./htc_x101-64x4d_fpn_16xb1-20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/htc/htc_x101_64x4d_fpn_16x1_20e_coco/htc_x101_64x4d_fpn_16x1_20e_coco_20200318-b181fd7a.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/htc/htc_x101_64x4d_fpn_16x1_20e_coco/htc_x101_64x4d_fpn_16x1_20e_coco_20200318_081711.log.json) | + +- In the HTC paper and COCO 2018 Challenge, `score_thr` is set to 0.001 for both baselines and HTC. +- We use 8 GPUs with 2 images/GPU for R-50 and R-101 models, and 16 GPUs with 1 image/GPU for X-101 models. + If you would like to train X-101 HTC with 8 GPUs, you need to change the lr from 0.02 to 0.01. + +We also provide a powerful HTC with DCN and multi-scale training model. No testing augmentation is used. + +| Backbone | Style | DCN | training scales | Lr schd | box AP | mask AP | Config | Download | +| :-------------: | :-----: | :---: | :-------------: | :-----: | :----: | :-----: | :----------------------------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| X-101-64x4d-FPN | pytorch | c3-c5 | 400~1400 | 20e | 50.4 | 43.8 | [config](./htc_x101-64x4d-dconv-c3-c5_fpn_ms-400-1400-16xb1-20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/htc/htc_x101_64x4d_fpn_dconv_c3-c5_mstrain_400_1400_16x1_20e_coco/htc_x101_64x4d_fpn_dconv_c3-c5_mstrain_400_1400_16x1_20e_coco_20200312-946fd751.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/htc/htc_x101_64x4d_fpn_dconv_c3-c5_mstrain_400_1400_16x1_20e_coco/htc_x101_64x4d_fpn_dconv_c3-c5_mstrain_400_1400_16x1_20e_coco_20200312_203410.log.json) | + +## Citation + +We provide config files to reproduce the results in the CVPR 2019 paper for [Hybrid Task Cascade](https://arxiv.org/abs/1901.07518). + +```latex +@inproceedings{chen2019hybrid, + title={Hybrid task cascade for instance segmentation}, + author={Chen, Kai and Pang, Jiangmiao and Wang, Jiaqi and Xiong, Yu and Li, Xiaoxiao and Sun, Shuyang and Feng, Wansen and Liu, Ziwei and Shi, Jianping and Ouyang, Wanli and Chen Change Loy and Dahua Lin}, + booktitle={IEEE Conference on Computer Vision and Pattern Recognition}, + year={2019} +} +``` diff --git a/mmdetection/configs/htc/htc-without-semantic_r50_fpn_1x_coco.py b/mmdetection/configs/htc/htc-without-semantic_r50_fpn_1x_coco.py new file mode 100644 index 00000000..791f4eb2 --- /dev/null +++ b/mmdetection/configs/htc/htc-without-semantic_r50_fpn_1x_coco.py @@ -0,0 +1,223 @@ +_base_ = [ + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +# model settings +model = dict( + type='HybridTaskCascade', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + num_outs=5), + rpn_head=dict( + type='RPNHead', + in_channels=256, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + scales=[8], + ratios=[0.5, 1.0, 2.0], + strides=[4, 8, 16, 32, 64]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[1.0, 1.0, 1.0, 1.0]), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=1.0)), + roi_head=dict( + type='HybridTaskCascadeRoIHead', + interleaved=True, + mask_info_flow=True, + num_stages=3, + stage_loss_weights=[1, 0.5, 0.25], + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + bbox_head=[ + dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, + loss_weight=1.0)), + dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.05, 0.05, 0.1, 0.1]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, + loss_weight=1.0)), + dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.033, 0.033, 0.067, 0.067]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0)) + ], + mask_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + mask_head=[ + dict( + type='HTCMaskHead', + with_conv_res=False, + num_convs=4, + in_channels=256, + conv_out_channels=256, + num_classes=80, + loss_mask=dict( + type='CrossEntropyLoss', use_mask=True, loss_weight=1.0)), + dict( + type='HTCMaskHead', + num_convs=4, + in_channels=256, + conv_out_channels=256, + num_classes=80, + loss_mask=dict( + type='CrossEntropyLoss', use_mask=True, loss_weight=1.0)), + dict( + type='HTCMaskHead', + num_convs=4, + in_channels=256, + conv_out_channels=256, + num_classes=80, + loss_mask=dict( + type='CrossEntropyLoss', use_mask=True, loss_weight=1.0)) + ]), + # model training and testing settings + train_cfg=dict( + rpn=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.3, + min_pos_iou=0.3, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=-1, + add_gt_as_proposals=False), + allowed_border=0, + pos_weight=-1, + debug=False), + rpn_proposal=dict( + nms_pre=2000, + max_per_img=2000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=[ + dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0.5, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + mask_size=28, + pos_weight=-1, + debug=False), + dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.6, + neg_iou_thr=0.6, + min_pos_iou=0.6, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + mask_size=28, + pos_weight=-1, + debug=False), + dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.7, + min_pos_iou=0.7, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + mask_size=28, + pos_weight=-1, + debug=False) + ]), + test_cfg=dict( + rpn=dict( + nms_pre=1000, + max_per_img=1000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=dict( + score_thr=0.001, + nms=dict(type='nms', iou_threshold=0.5), + max_per_img=100, + mask_thr_binary=0.5))) diff --git a/mmdetection/configs/htc/htc_r101_fpn_20e_coco.py b/mmdetection/configs/htc/htc_r101_fpn_20e_coco.py new file mode 100644 index 00000000..28091aad --- /dev/null +++ b/mmdetection/configs/htc/htc_r101_fpn_20e_coco.py @@ -0,0 +1,6 @@ +_base_ = './htc_r50_fpn_20e_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/htc/htc_r50_fpn_1x_coco.py b/mmdetection/configs/htc/htc_r50_fpn_1x_coco.py new file mode 100644 index 00000000..3573f1f6 --- /dev/null +++ b/mmdetection/configs/htc/htc_r50_fpn_1x_coco.py @@ -0,0 +1,33 @@ +_base_ = './htc-without-semantic_r50_fpn_1x_coco.py' +model = dict( + data_preprocessor=dict(pad_seg=True), + roi_head=dict( + semantic_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0), + out_channels=256, + featmap_strides=[8]), + semantic_head=dict( + type='FusedSemanticHead', + num_ins=5, + fusion_level=1, + seg_scale_factor=1 / 8, + num_convs=4, + in_channels=256, + conv_out_channels=256, + num_classes=183, + loss_seg=dict( + type='CrossEntropyLoss', ignore_index=255, loss_weight=0.2)))) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict( + type='LoadAnnotations', with_bbox=True, with_mask=True, with_seg=True), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +train_dataloader = dict( + dataset=dict( + data_prefix=dict(img='train2017/', seg='stuffthingmaps/train2017/'), + pipeline=train_pipeline)) diff --git a/mmdetection/configs/htc/htc_r50_fpn_20e_coco.py b/mmdetection/configs/htc/htc_r50_fpn_20e_coco.py new file mode 100644 index 00000000..9f510fa6 --- /dev/null +++ b/mmdetection/configs/htc/htc_r50_fpn_20e_coco.py @@ -0,0 +1,16 @@ +_base_ = './htc_r50_fpn_1x_coco.py' + +# learning policy +max_epochs = 20 +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 19], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs) diff --git a/mmdetection/configs/htc/htc_x101-32x4d_fpn_16xb1-20e_coco.py b/mmdetection/configs/htc/htc_x101-32x4d_fpn_16xb1-20e_coco.py new file mode 100644 index 00000000..396d3a0e --- /dev/null +++ b/mmdetection/configs/htc/htc_x101-32x4d_fpn_16xb1-20e_coco.py @@ -0,0 +1,32 @@ +_base_ = './htc_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) + +train_dataloader = dict(batch_size=1, num_workers=1) + +# learning policy +max_epochs = 20 +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 19], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs) diff --git a/mmdetection/configs/htc/htc_x101-64x4d-dconv-c3-c5_fpn_ms-400-1400-16xb1-20e_coco.py b/mmdetection/configs/htc/htc_x101-64x4d-dconv-c3-c5_fpn_ms-400-1400-16xb1-20e_coco.py new file mode 100644 index 00000000..26d68e7e --- /dev/null +++ b/mmdetection/configs/htc/htc_x101-64x4d-dconv-c3-c5_fpn_ms-400-1400-16xb1-20e_coco.py @@ -0,0 +1,20 @@ +_base_ = './htc_x101-64x4d_fpn_16xb1-20e_coco.py' + +model = dict( + backbone=dict( + dcn=dict(type='DCN', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True))) + +# dataset settings +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='LoadAnnotations', with_bbox=True, with_mask=True, with_seg=True), + dict( + type='RandomResize', + scale=[(1600, 400), (1600, 1400)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/mmdetection/configs/htc/htc_x101-64x4d_fpn_16xb1-20e_coco.py b/mmdetection/configs/htc/htc_x101-64x4d_fpn_16xb1-20e_coco.py new file mode 100644 index 00000000..a600ddb0 --- /dev/null +++ b/mmdetection/configs/htc/htc_x101-64x4d_fpn_16xb1-20e_coco.py @@ -0,0 +1,7 @@ +_base_ = './htc_x101-32x4d_fpn_16xb1-20e_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + groups=64, + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/htc/metafile.yml b/mmdetection/configs/htc/metafile.yml new file mode 100644 index 00000000..2f0f74d2 --- /dev/null +++ b/mmdetection/configs/htc/metafile.yml @@ -0,0 +1,165 @@ +Collections: + - Name: HTC + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - FPN + - HTC + - RPN + - ResNet + - ResNeXt + - RoIAlign + Paper: + URL: https://arxiv.org/abs/1901.07518 + Title: 'Hybrid Task Cascade for Instance Segmentation' + README: configs/htc/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/detectors/htc.py#L6 + Version: v2.0.0 + +Models: + - Name: htc_r50_fpn_1x_coco + In Collection: HTC + Config: configs/htc/htc_r50_fpn_1x_coco.py + Metadata: + Training Memory (GB): 8.2 + inference time (ms/im): + - value: 172.41 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.3 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/htc/htc_r50_fpn_1x_coco/htc_r50_fpn_1x_coco_20200317-7332cf16.pth + + - Name: htc_r50_fpn_20e_coco + In Collection: HTC + Config: configs/htc/htc_r50_fpn_20e_coco.py + Metadata: + Training Memory (GB): 8.2 + inference time (ms/im): + - value: 172.41 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 20 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.3 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/htc/htc_r50_fpn_20e_coco/htc_r50_fpn_20e_coco_20200319-fe28c577.pth + + - Name: htc_r101_fpn_20e_coco + In Collection: HTC + Config: configs/htc/htc_r101_fpn_20e_coco.py + Metadata: + Training Memory (GB): 10.2 + inference time (ms/im): + - value: 181.82 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 20 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/htc/htc_r101_fpn_20e_coco/htc_r101_fpn_20e_coco_20200317-9b41b48f.pth + + - Name: htc_x101-32x4d_fpn_16xb1-20e_coco + In Collection: HTC + Config: configs/htc/htc_x101-32x4d_fpn_16xb1-20e_coco.py + Metadata: + Training Resources: 16x V100 GPUs + Batch Size: 16 + Training Memory (GB): 11.4 + inference time (ms/im): + - value: 200 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 20 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.1 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 40.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/htc/htc_x101_32x4d_fpn_16x1_20e_coco/htc_x101_32x4d_fpn_16x1_20e_coco_20200318-de97ae01.pth + + - Name: htc_x101-64x4d_fpn_16xb1-20e_coco + In Collection: HTC + Config: configs/htc/htc_x101-64x4d_fpn_16xb1-20e_coco.py + Metadata: + Training Resources: 16x V100 GPUs + Batch Size: 16 + Training Memory (GB): 14.5 + inference time (ms/im): + - value: 227.27 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 20 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 47.0 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 41.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/htc/htc_x101_64x4d_fpn_16x1_20e_coco/htc_x101_64x4d_fpn_16x1_20e_coco_20200318-b181fd7a.pth + + - Name: htc_x101-64x4d-dconv-c3-c5_fpn_ms-400-1400-16xb1-20e_coco + In Collection: HTC + Config: configs/htc/htc_x101-64x4d-dconv-c3-c5_fpn_ms-400-1400-16xb1-20e_coco.py + Metadata: + Training Resources: 16x V100 GPUs + Batch Size: 16 + Epochs: 20 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 50.4 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 43.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/htc/htc_x101_64x4d_fpn_dconv_c3-c5_mstrain_400_1400_16x1_20e_coco/htc_x101_64x4d_fpn_dconv_c3-c5_mstrain_400_1400_16x1_20e_coco_20200312-946fd751.pth diff --git a/mmdetection/configs/instaboost/README.md b/mmdetection/configs/instaboost/README.md new file mode 100644 index 00000000..34132341 --- /dev/null +++ b/mmdetection/configs/instaboost/README.md @@ -0,0 +1,58 @@ +# Instaboost + +> [Instaboost: Boosting instance segmentation via probability map guided copy-pasting](https://arxiv.org/abs/1908.07801) + + + +## Abstract + +Instance segmentation requires a large number of training samples to achieve satisfactory performance and benefits from proper data augmentation. To enlarge the training set and increase the diversity, previous methods have investigated using data annotation from other domain (e.g. bbox, point) in a weakly supervised mechanism. In this paper, we present a simple, efficient and effective method to augment the training set using the existing instance mask annotations. Exploiting the pixel redundancy of the background, we are able to improve the performance of Mask R-CNN for 1.7 mAP on COCO dataset and 3.3 mAP on Pascal VOC dataset by simply introducing random jittering to objects. Furthermore, we propose a location probability map based approach to explore the feasible locations that objects can be placed based on local appearance similarity. With the guidance of such map, we boost the performance of R101-Mask R-CNN on instance segmentation from 35.7 mAP to 37.9 mAP without modifying the backbone or network structure. Our method is simple to implement and does not increase the computational complexity. It can be integrated into the training pipeline of any instance segmentation model without affecting the training and inference efficiency. + +
    + +
    + +## Introduction + +Configs in this directory is the implementation for ICCV2019 paper "InstaBoost: Boosting Instance Segmentation Via Probability Map Guided Copy-Pasting" and provided by the authors of the paper. InstaBoost is a data augmentation method for object detection and instance segmentation. The paper has been released on [`arXiv`](https://arxiv.org/abs/1908.07801). + +## Usage + +### Requirements + +You need to install `instaboostfast` before using it. + +```shell +pip install instaboostfast +``` + +The code and more details can be found [here](https://github.com/GothicAi/Instaboost). + +### Integration with MMDetection + +InstaBoost have been already integrated in the data pipeline, thus all you need is to add or change **InstaBoost** configurations after **LoadImageFromFile**. We have provided examples like [this](mask_rcnn_r50_fpn_instaboost_4x#L121). You can refer to [`InstaBoostConfig`](https://github.com/GothicAi/InstaBoost-pypi#instaboostconfig) for more details. + +## Results and Models + +- All models were trained on `coco_2017_train` and tested on `coco_2017_val` for convenience of evaluation and comparison. In the paper, the results are obtained from `test-dev`. +- To balance accuracy and training time when using InstaBoost, models released in this page are all trained for 48 Epochs. Other training and testing configs strictly follow the original framework. +- For results and models in MMDetection V1.x, please refer to [Instaboost](https://github.com/GothicAi/Instaboost). + +| Network | Backbone | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :-----------: | :-------------: | :-----: | :------: | :------------: | :----: | :-----: | :---------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| Mask R-CNN | R-50-FPN | 4x | 4.4 | 17.5 | 40.6 | 36.6 | [config](./mask-rcnn_r50_fpn_instaboost-4x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/instaboost/mask_rcnn_r50_fpn_instaboost_4x_coco/mask_rcnn_r50_fpn_instaboost_4x_coco_20200307-d025f83a.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/instaboost/mask_rcnn_r50_fpn_instaboost_4x_coco/mask_rcnn_r50_fpn_instaboost_4x_coco_20200307_223635.log.json) | +| Mask R-CNN | R-101-FPN | 4x | 6.4 | | 42.5 | 38.0 | [config](./mask-rcnn_r101_fpn_instaboost-4x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/instaboost/mask_rcnn_r101_fpn_instaboost_4x_coco/mask_rcnn_r101_fpn_instaboost_4x_coco_20200703_235738-f23f3a5f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/instaboost/mask_rcnn_r101_fpn_instaboost_4x_coco/mask_rcnn_r101_fpn_instaboost_4x_coco_20200703_235738.log.json) | +| Mask R-CNN | X-101-64x4d-FPN | 4x | 10.7 | | 44.7 | 39.7 | [config](./mask-rcnn_x101-64x4d_fpn_instaboost-4x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/instaboost/mask_rcnn_x101_64x4d_fpn_instaboost_4x_coco/mask_rcnn_x101_64x4d_fpn_instaboost_4x_coco_20200515_080947-8ed58c1b.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/instaboost/mask_rcnn_x101_64x4d_fpn_instaboost_4x_coco/mask_rcnn_x101_64x4d_fpn_instaboost_4x_coco_20200515_080947.log.json) | +| Cascade R-CNN | R-101-FPN | 4x | 6.0 | 12.0 | 43.7 | 38.0 | [config](./cascade-mask-rcnn_r50_fpn_instaboost-4x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/instaboost/cascade_mask_rcnn_r50_fpn_instaboost_4x_coco/cascade_mask_rcnn_r50_fpn_instaboost_4x_coco_20200307-c19d98d9.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/instaboost/cascade_mask_rcnn_r50_fpn_instaboost_4x_coco/cascade_mask_rcnn_r50_fpn_instaboost_4x_coco_20200307_223646.log.json) | + +## Citation + +```latex +@inproceedings{fang2019instaboost, + title={Instaboost: Boosting instance segmentation via probability map guided copy-pasting}, + author={Fang, Hao-Shu and Sun, Jianhua and Wang, Runzhong and Gou, Minghao and Li, Yong-Lu and Lu, Cewu}, + booktitle={Proceedings of the IEEE International Conference on Computer Vision}, + pages={682--691}, + year={2019} +} +``` diff --git a/mmdetection/configs/instaboost/cascade-mask-rcnn_r101_fpn_instaboost-4x_coco.py b/mmdetection/configs/instaboost/cascade-mask-rcnn_r101_fpn_instaboost-4x_coco.py new file mode 100644 index 00000000..53e33b89 --- /dev/null +++ b/mmdetection/configs/instaboost/cascade-mask-rcnn_r101_fpn_instaboost-4x_coco.py @@ -0,0 +1,7 @@ +_base_ = './cascade-mask-rcnn_r50_fpn_instaboost-4x_coco.py' + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/instaboost/cascade-mask-rcnn_r50_fpn_instaboost-4x_coco.py b/mmdetection/configs/instaboost/cascade-mask-rcnn_r50_fpn_instaboost-4x_coco.py new file mode 100644 index 00000000..f7736cf5 --- /dev/null +++ b/mmdetection/configs/instaboost/cascade-mask-rcnn_r50_fpn_instaboost-4x_coco.py @@ -0,0 +1,40 @@ +_base_ = '../cascade_rcnn/cascade-mask-rcnn_r50_fpn_1x_coco.py' + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict( + type='InstaBoost', + action_candidate=('normal', 'horizontal', 'skip'), + action_prob=(1, 0, 0), + scale=(0.8, 1.2), + dx=15, + dy=15, + theta=(-1, 1), + color_prob=0.5, + hflag=False, + aug_ratio=0.5), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +max_epochs = 48 + +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[32, 44], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs) + +# only keep latest 3 checkpoints +default_hooks = dict(checkpoint=dict(max_keep_ckpts=3)) diff --git a/mmdetection/configs/instaboost/cascade-mask-rcnn_x101-64x4d_fpn_instaboost-4x_coco.py b/mmdetection/configs/instaboost/cascade-mask-rcnn_x101-64x4d_fpn_instaboost-4x_coco.py new file mode 100644 index 00000000..c7938d9e --- /dev/null +++ b/mmdetection/configs/instaboost/cascade-mask-rcnn_x101-64x4d_fpn_instaboost-4x_coco.py @@ -0,0 +1,14 @@ +_base_ = './cascade-mask-rcnn_r50_fpn_instaboost-4x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/instaboost/mask-rcnn_r101_fpn_instaboost-4x_coco.py b/mmdetection/configs/instaboost/mask-rcnn_r101_fpn_instaboost-4x_coco.py new file mode 100644 index 00000000..55bfa9fe --- /dev/null +++ b/mmdetection/configs/instaboost/mask-rcnn_r101_fpn_instaboost-4x_coco.py @@ -0,0 +1,6 @@ +_base_ = './mask-rcnn_r50_fpn_instaboost-4x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/instaboost/mask-rcnn_r50_fpn_instaboost-4x_coco.py b/mmdetection/configs/instaboost/mask-rcnn_r50_fpn_instaboost-4x_coco.py new file mode 100644 index 00000000..0a8c9be8 --- /dev/null +++ b/mmdetection/configs/instaboost/mask-rcnn_r50_fpn_instaboost-4x_coco.py @@ -0,0 +1,40 @@ +_base_ = '../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py' + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict( + type='InstaBoost', + action_candidate=('normal', 'horizontal', 'skip'), + action_prob=(1, 0, 0), + scale=(0.8, 1.2), + dx=15, + dy=15, + theta=(-1, 1), + color_prob=0.5, + hflag=False, + aug_ratio=0.5), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +max_epochs = 48 + +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[32, 44], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs) + +# only keep latest 3 checkpoints +default_hooks = dict(checkpoint=dict(max_keep_ckpts=3)) diff --git a/mmdetection/configs/instaboost/mask-rcnn_x101-64x4d_fpn_instaboost-4x_coco.py b/mmdetection/configs/instaboost/mask-rcnn_x101-64x4d_fpn_instaboost-4x_coco.py new file mode 100644 index 00000000..9ba2ada6 --- /dev/null +++ b/mmdetection/configs/instaboost/mask-rcnn_x101-64x4d_fpn_instaboost-4x_coco.py @@ -0,0 +1,14 @@ +_base_ = './mask-rcnn_r50_fpn_instaboost-4x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/instaboost/metafile.yml b/mmdetection/configs/instaboost/metafile.yml new file mode 100644 index 00000000..228f31b7 --- /dev/null +++ b/mmdetection/configs/instaboost/metafile.yml @@ -0,0 +1,99 @@ +Collections: + - Name: InstaBoost + Metadata: + Training Data: COCO + Training Techniques: + - InstaBoost + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Paper: + URL: https://arxiv.org/abs/1908.07801 + Title: 'Instaboost: Boosting instance segmentation via probability map guided copy-pasting' + README: configs/instaboost/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/datasets/pipelines/instaboost.py#L7 + Version: v2.0.0 + +Models: + - Name: mask-rcnn_r50_fpn_instaboost_4x_coco + In Collection: InstaBoost + Config: configs/instaboost/mask-rcnn_r50_fpn_instaboost-4x_coco.py + Metadata: + Training Memory (GB): 4.4 + inference time (ms/im): + - value: 57.14 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 48 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.6 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/instaboost/mask_rcnn_r50_fpn_instaboost_4x_coco/mask_rcnn_r50_fpn_instaboost_4x_coco_20200307-d025f83a.pth + + - Name: mask-rcnn_r101_fpn_instaboost-4x_coco + In Collection: InstaBoost + Config: configs/instaboost/mask-rcnn_r101_fpn_instaboost-4x_coco.py + Metadata: + Training Memory (GB): 6.4 + Epochs: 48 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.5 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/instaboost/mask_rcnn_r101_fpn_instaboost_4x_coco/mask_rcnn_r101_fpn_instaboost_4x_coco_20200703_235738-f23f3a5f.pth + + - Name: mask-rcnn_x101-64x4d_fpn_instaboost-4x_coco + In Collection: InstaBoost + Config: configs/instaboost/mask-rcnn_x101-64x4d_fpn_instaboost-4x_coco.py + Metadata: + Training Memory (GB): 10.7 + Epochs: 48 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.7 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/instaboost/mask_rcnn_x101_64x4d_fpn_instaboost_4x_coco/mask_rcnn_x101_64x4d_fpn_instaboost_4x_coco_20200515_080947-8ed58c1b.pth + + - Name: cascade-mask-rcnn_r50_fpn_instaboost_4x_coco + In Collection: InstaBoost + Config: configs/instaboost/cascade-mask-rcnn_r50_fpn_instaboost-4x_coco.py + Metadata: + Training Memory (GB): 6.0 + inference time (ms/im): + - value: 83.33 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 48 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.7 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/instaboost/cascade_mask_rcnn_r50_fpn_instaboost_4x_coco/cascade_mask_rcnn_r50_fpn_instaboost_4x_coco_20200307-c19d98d9.pth diff --git a/mmdetection/configs/lad/README.md b/mmdetection/configs/lad/README.md new file mode 100644 index 00000000..3c3b6b4b --- /dev/null +++ b/mmdetection/configs/lad/README.md @@ -0,0 +1,45 @@ +# LAD + +> [Improving Object Detection by Label Assignment Distillation](https://arxiv.org/abs/2108.10520) + + + +## Abstract + +Label assignment in object detection aims to assign targets, foreground or background, to sampled regions in an image. Unlike labeling for image classification, this problem is not well defined due to the object's bounding box. In this paper, we investigate the problem from a perspective of distillation, hence we call Label Assignment Distillation (LAD). Our initial motivation is very simple, we use a teacher network to generate labels for the student. This can be achieved in two ways: either using the teacher's prediction as the direct targets (soft label), or through the hard labels dynamically assigned by the teacher (LAD). Our experiments reveal that: (i) LAD is more effective than soft-label, but they are complementary. (ii) Using LAD, a smaller teacher can also improve a larger student significantly, while soft-label can't. We then introduce Co-learning LAD, in which two networks simultaneously learn from scratch and the role of teacher and student are dynamically interchanged. Using PAA-ResNet50 as a teacher, our LAD techniques can improve detectors PAA-ResNet101 and PAA-ResNeXt101 to 46AP and 47.5AP on the COCO test-dev set. With a stronger teacher PAA-SwinB, we improve the students PAA-ResNet50 to 43.7AP by only 1x schedule training and standard setting, and PAA-ResNet101 to 47.9AP, significantly surpassing the current methods. + +
    + +
    + +## Results and Models + +We provide config files to reproduce the object detection results in the +WACV 2022 paper for Improving Object Detection by Label Assignment +Distillation. + +### PAA with LAD + +| Teacher | Student | Training schedule | AP (val) | Config | Download | +| :-----: | :-----: | :---------------: | :------: | :----------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| -- | R-50 | 1x | 40.4 | [config](../paa/paa_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r50_fpn_1x_coco/paa_r50_fpn_1x_coco_20200821-936edec3.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r50_fpn_1x_coco/paa_r50_fpn_1x_coco_20200821-936edec3.log.json) | +| -- | R-101 | 1x | 42.6 | [config](../paa/paa_r101_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r101_fpn_1x_coco/paa_r101_fpn_1x_coco_20200821-0a1825a4.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r101_fpn_1x_coco/paa_r101_fpn_1x_coco_20200821-0a1825a4.log.json) | +| R-101 | R-50 | 1x | 41.4 | [config](./lad_r50-paa-r101_fpn_2xb8_coco_1x.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/lad/lad_r50_paa_r101_fpn_coco_1x/lad_r50_paa_r101_fpn_coco_1x_20220708_124246-74c76ff0.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/lad/lad_r50_paa_r101_fpn_coco_1x/lad_r50_paa_r101_fpn_coco_1x_20220708_124246.log.json) | +| R-50 | R-101 | 1x | 43.2 | [config](./lad_r101-paa-r50_fpn_2xb8_coco_1x.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/lad/lad_r101_paa_r50_fpn_coco_1x/lad_r101_paa_r50_fpn_coco_1x_20220708_124357-9407ac54.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/lad/lad_r101_paa_r50_fpn_coco_1x/lad_r101_paa_r50_fpn_coco_1x_20220708_124357.log.json) | + +## Note + +- Meaning of Config name: lad_r50(student model)\_paa(based on paa)\_r101(teacher model)\_fpn(neck)\_coco(dataset)\_1x(12 epoch).py +- Results may fluctuate by about 0.2 mAP. +- 2 GPUs are used, 8 samples per GPU. + +## Citation + +```latex +@inproceedings{nguyen2021improving, + title={Improving Object Detection by Label Assignment Distillation}, + author={Chuong H. Nguyen and Thuy C. Nguyen and Tuan N. Tang and Nam L. H. Phan}, + booktitle = {WACV}, + year={2022} +} +``` diff --git a/mmdetection/configs/lad/lad_r101-paa-r50_fpn_2xb8_coco_1x.py b/mmdetection/configs/lad/lad_r101-paa-r50_fpn_2xb8_coco_1x.py new file mode 100644 index 00000000..d61d0863 --- /dev/null +++ b/mmdetection/configs/lad/lad_r101-paa-r50_fpn_2xb8_coco_1x.py @@ -0,0 +1,127 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +teacher_ckpt = 'https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r50_fpn_1x_coco/paa_r50_fpn_1x_coco_20200821-936edec3.pth' # noqa + +model = dict( + type='LAD', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32), + # student + backbone=dict( + type='ResNet', + depth=101, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_output', + num_outs=5), + bbox_head=dict( + type='LADHead', + reg_decoded_bbox=True, + score_voting=True, + topk=9, + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + octave_base_scale=8, + scales_per_octave=1, + strides=[8, 16, 32, 64, 128]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=1.3), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.5)), + # teacher + teacher_ckpt=teacher_ckpt, + teacher_backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch'), + teacher_neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_output', + num_outs=5), + teacher_bbox_head=dict( + type='LADHead', + reg_decoded_bbox=True, + score_voting=True, + topk=9, + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + octave_base_scale=8, + scales_per_octave=1, + strides=[8, 16, 32, 64, 128]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=1.3), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.5)), + # training and testing settings + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.1, + neg_iou_thr=0.1, + min_pos_iou=0, + ignore_iof_thr=-1), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + score_voting=True, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) +train_dataloader = dict(batch_size=8, num_workers=4) +optim_wrapper = dict(type='AmpOptimWrapper', optimizer=dict(lr=0.01)) diff --git a/mmdetection/configs/lad/lad_r50-paa-r101_fpn_2xb8_coco_1x.py b/mmdetection/configs/lad/lad_r50-paa-r101_fpn_2xb8_coco_1x.py new file mode 100644 index 00000000..f7eaf2bf --- /dev/null +++ b/mmdetection/configs/lad/lad_r50-paa-r101_fpn_2xb8_coco_1x.py @@ -0,0 +1,126 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +teacher_ckpt = 'http://download.openmmlab.com/mmdetection/v2.0/paa/paa_r101_fpn_1x_coco/paa_r101_fpn_1x_coco_20200821-0a1825a4.pth' # noqa + +model = dict( + type='LAD', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32), + # student + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_output', + num_outs=5), + bbox_head=dict( + type='LADHead', + reg_decoded_bbox=True, + score_voting=True, + topk=9, + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + octave_base_scale=8, + scales_per_octave=1, + strides=[8, 16, 32, 64, 128]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=1.3), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.5)), + # teacher + teacher_ckpt=teacher_ckpt, + teacher_backbone=dict( + type='ResNet', + depth=101, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch'), + teacher_neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_output', + num_outs=5), + teacher_bbox_head=dict( + type='LADHead', + reg_decoded_bbox=True, + score_voting=True, + topk=9, + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + octave_base_scale=8, + scales_per_octave=1, + strides=[8, 16, 32, 64, 128]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=1.3), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.5)), + # training and testing settings + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.1, + neg_iou_thr=0.1, + min_pos_iou=0, + ignore_iof_thr=-1), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + score_voting=True, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) +train_dataloader = dict(batch_size=8, num_workers=4) +optim_wrapper = dict(type='AmpOptimWrapper', optimizer=dict(lr=0.01)) diff --git a/mmdetection/configs/lad/metafile.yml b/mmdetection/configs/lad/metafile.yml new file mode 100644 index 00000000..230132e6 --- /dev/null +++ b/mmdetection/configs/lad/metafile.yml @@ -0,0 +1,45 @@ +Collections: + - Name: Label Assignment Distillation + Metadata: + Training Data: COCO + Training Techniques: + - Label Assignment Distillation + - SGD with Momentum + - Weight Decay + Training Resources: 2x V100 GPUs + Architecture: + - FPN + - ResNet + Paper: + URL: https://arxiv.org/abs/2108.10520 + Title: 'Improving Object Detection by Label Assignment Distillation' + README: configs/lad/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.19.0/mmdet/models/detectors/lad.py#L10 + Version: v2.19.0 + +Models: + - Name: lad_r101-paa-r50_fpn_2xb8_coco_1x + In Collection: Label Assignment Distillation + Config: configs/lad/lad_r101-paa-r50_fpn_2xb8_coco_1x.py + Metadata: + Training Memory (GB): 12.4 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/lad/lad_r101_paa_r50_fpn_coco_1x/lad_r101_paa_r50_fpn_coco_1x_20220708_124357-9407ac54.pth + - Name: lad_r50-paa-r101_fpn_2xb8_coco_1x + In Collection: Label Assignment Distillation + Config: configs/lad/lad_r50-paa-r101_fpn_2xb8_coco_1x.py + Metadata: + Training Memory (GB): 8.9 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/lad/lad_r50_paa_r101_fpn_coco_1x/lad_r50_paa_r101_fpn_coco_1x_20220708_124246-74c76ff0.pth diff --git a/mmdetection/configs/ld/README.md b/mmdetection/configs/ld/README.md new file mode 100644 index 00000000..65e16c79 --- /dev/null +++ b/mmdetection/configs/ld/README.md @@ -0,0 +1,43 @@ +# LD + +> [Localization Distillation for Dense Object Detection](https://arxiv.org/abs/2102.12252) + + + +## Abstract + +Knowledge distillation (KD) has witnessed its powerful capability in learning compact models in object detection. Previous KD methods for object detection mostly focus on imitating deep features within the imitation regions instead of mimicking classification logits due to its inefficiency in distilling localization information. In this paper, by reformulating the knowledge distillation process on localization, we present a novel localization distillation (LD) method which can efficiently transfer the localization knowledge from the teacher to the student. Moreover, we also heuristically introduce the concept of valuable localization region that can aid to selectively distill the semantic and localization knowledge for a certain region. Combining these two new components, for the first time, we show that logit mimicking can outperform feature imitation and localization knowledge distillation is more important and efficient than semantic knowledge for distilling object detectors. Our distillation scheme is simple as well as effective and can be easily applied to different dense object detectors. Experiments show that our LD can boost the AP score of GFocal-ResNet-50 with a single-scale 1× training schedule from 40.1 to 42.1 on the COCO benchmark without any sacrifice on the inference speed. + +
    + +
    + +## Results and Models + +### GFocalV1 with LD + +| Teacher | Student | Training schedule | Mini-batch size | AP (val) | Config | Download | +| :-------: | :-----: | :---------------: | :-------------: | :------: | :-----------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| -- | R-18 | 1x | 6 | 35.8 | | | +| R-101 | R-18 | 1x | 6 | 36.5 | [config](./ld_r18-gflv1-r101_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/ld/ld_r18_gflv1_r101_fpn_coco_1x/ld_r18_gflv1_r101_fpn_coco_1x_20220702_062206-330e6332.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/ld/ld_r18_gflv1_r101_fpn_coco_1x/ld_r18_gflv1_r101_fpn_coco_1x_20220702_062206.log.json) | +| -- | R-34 | 1x | 6 | 38.9 | | | +| R-101 | R-34 | 1x | 6 | 39.9 | [config](./ld_r34-gflv1-r101_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/ld/ld_r34_gflv1_r101_fpn_coco_1x/ld_r34_gflv1_r101_fpn_coco_1x_20220630_134007-9bc69413.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/ld/ld_r34_gflv1_r101_fpn_coco_1x/ld_r34_gflv1_r101_fpn_coco_1x_20220630_134007.log.json) | +| -- | R-50 | 1x | 6 | 40.1 | | | +| R-101 | R-50 | 1x | 6 | 41.0 | [config](./ld_r50-gflv1-r101_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/ld/ld_r50_gflv1_r101_fpn_coco_1x/ld_r50_gflv1_r101_fpn_coco_1x_20220629_145355-8dc5bad8.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/ld/ld_r50_gflv1_r101_fpn_coco_1x/ld_r50_gflv1_r101_fpn_coco_1x_20220629_145355.log.json) | +| -- | R-101 | 2x | 6 | 44.6 | | | +| R-101-DCN | R-101 | 2x | 6 | 45.5 | [config](./ld_r101-gflv1-r101-dcn_fpn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/ld/ld_r101_gflv1_r101dcn_fpn_coco_2x/ld_r101_gflv1_r101dcn_fpn_coco_2x_20220629_185920-9e658426.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/ld/ld_r101_gflv1_r101dcn_fpn_coco_2x/ld_r101_gflv1_r101dcn_fpn_coco_2x_20220629_185920.log.json) | + +## Note + +- Meaning of Config name: ld_r18(student model)\_gflv1(based on gflv1)\_r101(teacher model)\_fpn(neck)\_coco(dataset)\_1x(12 epoch).py + +## Citation + +```latex +@Inproceedings{zheng2022LD, + title={Localization Distillation for Dense Object Detection}, + author= {Zheng, Zhaohui and Ye, Rongguang and Wang, Ping and Ren, Dongwei and Zuo, Wangmeng and Hou, Qibin and Cheng, Mingming}, + booktitle={CVPR}, + year={2022} +} +``` diff --git a/mmdetection/configs/ld/ld_r101-gflv1-r101-dcn_fpn_2x_coco.py b/mmdetection/configs/ld/ld_r101-gflv1-r101-dcn_fpn_2x_coco.py new file mode 100644 index 00000000..a7e928bd --- /dev/null +++ b/mmdetection/configs/ld/ld_r101-gflv1-r101-dcn_fpn_2x_coco.py @@ -0,0 +1,49 @@ +_base_ = ['./ld_r18-gflv1-r101_fpn_1x_coco.py'] +teacher_ckpt = 'https://download.openmmlab.com/mmdetection/v2.0/gfl/gfl_r101_fpn_dconv_c3-c5_mstrain_2x_coco/gfl_r101_fpn_dconv_c3-c5_mstrain_2x_coco_20200630_102002-134b07df.pth' # noqa +model = dict( + teacher_config='configs/gfl/gfl_r101-dconv-c3-c5_fpn_ms-2x_coco.py', + teacher_ckpt=teacher_ckpt, + backbone=dict( + type='ResNet', + depth=101, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_output', + num_outs=5)) + +max_epochs = 24 +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs) + +# multi-scale training +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomResize', scale=[(1333, 480), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/mmdetection/configs/ld/ld_r18-gflv1-r101_fpn_1x_coco.py b/mmdetection/configs/ld/ld_r18-gflv1-r101_fpn_1x_coco.py new file mode 100644 index 00000000..f18bb1d3 --- /dev/null +++ b/mmdetection/configs/ld/ld_r18-gflv1-r101_fpn_1x_coco.py @@ -0,0 +1,70 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +teacher_ckpt = 'https://download.openmmlab.com/mmdetection/v2.0/gfl/gfl_r101_fpn_mstrain_2x_coco/gfl_r101_fpn_mstrain_2x_coco_20200629_200126-dd12f847.pth' # noqa +model = dict( + type='KnowledgeDistillationSingleStageDetector', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32), + teacher_config='configs/gfl/gfl_r101_fpn_ms-2x_coco.py', + teacher_ckpt=teacher_ckpt, + backbone=dict( + type='ResNet', + depth=18, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet18')), + neck=dict( + type='FPN', + in_channels=[64, 128, 256, 512], + out_channels=256, + start_level=1, + add_extra_convs='on_output', + num_outs=5), + bbox_head=dict( + type='LDHead', + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + octave_base_scale=8, + scales_per_octave=1, + strides=[8, 16, 32, 64, 128]), + loss_cls=dict( + type='QualityFocalLoss', + use_sigmoid=True, + beta=2.0, + loss_weight=1.0), + loss_dfl=dict(type='DistributionFocalLoss', loss_weight=0.25), + loss_ld=dict( + type='KnowledgeDistillationKLDivLoss', loss_weight=0.25, T=10), + reg_max=16, + loss_bbox=dict(type='GIoULoss', loss_weight=2.0)), + # training and testing settings + train_cfg=dict( + assigner=dict(type='ATSSAssigner', topk=9), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) + +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) diff --git a/mmdetection/configs/ld/ld_r34-gflv1-r101_fpn_1x_coco.py b/mmdetection/configs/ld/ld_r34-gflv1-r101_fpn_1x_coco.py new file mode 100644 index 00000000..2198adc8 --- /dev/null +++ b/mmdetection/configs/ld/ld_r34-gflv1-r101_fpn_1x_coco.py @@ -0,0 +1,19 @@ +_base_ = ['./ld_r18-gflv1-r101_fpn_1x_coco.py'] +model = dict( + backbone=dict( + type='ResNet', + depth=34, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet34')), + neck=dict( + type='FPN', + in_channels=[64, 128, 256, 512], + out_channels=256, + start_level=1, + add_extra_convs='on_output', + num_outs=5)) diff --git a/mmdetection/configs/ld/ld_r50-gflv1-r101_fpn_1x_coco.py b/mmdetection/configs/ld/ld_r50-gflv1-r101_fpn_1x_coco.py new file mode 100644 index 00000000..89ab5796 --- /dev/null +++ b/mmdetection/configs/ld/ld_r50-gflv1-r101_fpn_1x_coco.py @@ -0,0 +1,19 @@ +_base_ = ['./ld_r18-gflv1-r101_fpn_1x_coco.py'] +model = dict( + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_output', + num_outs=5)) diff --git a/mmdetection/configs/ld/metafile.yml b/mmdetection/configs/ld/metafile.yml new file mode 100644 index 00000000..a807d1b8 --- /dev/null +++ b/mmdetection/configs/ld/metafile.yml @@ -0,0 +1,69 @@ +Collections: + - Name: Localization Distillation + Metadata: + Training Data: COCO + Training Techniques: + - Localization Distillation + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - FPN + - ResNet + Paper: + URL: https://arxiv.org/abs/2102.12252 + Title: 'Localization Distillation for Dense Object Detection' + README: configs/ld/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.11.0/mmdet/models/dense_heads/ld_head.py#L11 + Version: v2.11.0 + +Models: + - Name: ld_r18-gflv1-r101_fpn_1x_coco + In Collection: Localization Distillation + Config: configs/ld/ld_r18-gflv1-r101_fpn_1x_coco.py + Metadata: + Training Memory (GB): 1.8 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 36.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/ld/ld_r18_gflv1_r101_fpn_coco_1x/ld_r18_gflv1_r101_fpn_coco_1x_20220702_062206-330e6332.pth + - Name: ld_r34-gflv1-r101_fpn_1x_coco + In Collection: Localization Distillation + Config: configs/ld/ld_r34-gflv1-r101_fpn_1x_coco.py + Metadata: + Training Memory (GB): 2.2 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/ld/ld_r34_gflv1_r101_fpn_coco_1x/ld_r34_gflv1_r101_fpn_coco_1x_20220630_134007-9bc69413.pth + - Name: ld_r50-gflv1-r101_fpn_1x_coco + In Collection: Localization Distillation + Config: configs/ld/ld_r50-gflv1-r101_fpn_1x_coco.py + Metadata: + Training Memory (GB): 3.6 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/ld/ld_r50_gflv1_r101_fpn_coco_1x/ld_r50_gflv1_r101_fpn_coco_1x_20220629_145355-8dc5bad8.pth + - Name: ld_r101-gflv1-r101-dcn_fpn_2x_coco + In Collection: Localization Distillation + Config: configs/ld/ld_r101-gflv1-r101-dcn_fpn_2x_coco.py + Metadata: + Training Memory (GB): 5.5 + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/ld/ld_r101_gflv1_r101dcn_fpn_coco_2x/ld_r101_gflv1_r101dcn_fpn_coco_2x_20220629_185920-9e658426.pth diff --git a/mmdetection/configs/legacy_1.x/README.md b/mmdetection/configs/legacy_1.x/README.md new file mode 100644 index 00000000..443a0a71 --- /dev/null +++ b/mmdetection/configs/legacy_1.x/README.md @@ -0,0 +1,54 @@ +# Legacy Configs in MMDetection V1.x + + + +Configs in this directory implement the legacy configs used by MMDetection V1.x and its model zoos. + +To help users convert their models from V1.x to MMDetection V2.0, we provide v1.x configs to inference the converted v1.x models. +Due to the BC-breaking changes in MMDetection V2.0 from MMDetection V1.x, running inference with the same model weights in these two version will produce different results. The difference will cause within 1% AP absolute difference as can be found in the following table. + +## Usage + +To upgrade the model version, the users need to do the following steps. + +### 1. Convert model weights + +There are three main difference in the model weights between V1.x and V2.0 codebases. + +1. Since the class order in all the detector's classification branch is reordered, all the legacy model weights need to go through the conversion process. +2. The regression and segmentation head no longer contain the background channel. Weights in these background channels should be removed to fix in the current codebase. +3. For two-stage detectors, their wegihts need to be upgraded since MMDetection V2.0 refactors all the two-stage detectors with `RoIHead`. + +The users can do the same modification as mentioned above for the self-implemented +detectors. We provide a scripts `tools/model_converters/upgrade_model_version.py` to convert the model weights in the V1.x model zoo. + +```bash +python tools/model_converters/upgrade_model_version.py ${OLD_MODEL_PATH} ${NEW_MODEL_PATH} --num-classes ${NUM_CLASSES} + +``` + +- OLD_MODEL_PATH: the path to load the model weights in 1.x version. +- NEW_MODEL_PATH: the path to save the converted model weights in 2.0 version. +- NUM_CLASSES: number of classes of the original model weights. Usually it is 81 for COCO dataset, 21 for VOC dataset. + The number of classes in V2.0 models should be equal to that in V1.x models - 1. + +### 2. Use configs with legacy settings + +After converting the model weights, checkout to the v1.2 release to find the corresponding config file that uses the legacy settings. +The V1.x models usually need these three legacy modules: `LegacyAnchorGenerator`, `LegacyDeltaXYWHBBoxCoder`, and `RoIAlign(align=False)`. +For models using ResNet Caffe backbones, they also need to change the pretrain name and the corresponding `img_norm_cfg`. +An example is in [`retinanet_r50-caffe_fpn_1x_coco_v1.py`](retinanet_r50-caffe_fpn_1x_coco_v1.py) +Then use the config to test the model weights. For most models, the obtained results should be close to that in V1.x. +We provide configs of some common structures in this directory. + +## Performance + +The performance change after converting the models in this directory are listed as the following. + +| Method | Style | Lr schd | V1.x box AP | V1.x mask AP | V2.0 box AP | V2.0 mask AP | Config | Download | +| :-------------------------: | :-----: | :-----: | :---------: | :----------: | :---------: | :----------: | :-------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------: | +| Mask R-CNN R-50-FPN | pytorch | 1x | 37.3 | 34.2 | 36.8 | 33.9 | [config](./mask-rcnn_r50_fpn_1x_coco_v1.py) | [model](https://s3.ap-northeast-2.amazonaws.com/open-mmlab/mmdetection/models/mask_rcnn_r50_fpn_1x_20181010-069fa190.pth) | +| RetinaNet R-50-FPN | caffe | 1x | 35.8 | - | 35.4 | - | [config](./retinanet_r50-caffe_fpn_1x_coco_v1.py) | | +| RetinaNet R-50-FPN | pytorch | 1x | 35.6 | - | 35.2 | - | [config](./retinanet_r50_fpn_1x_coco_v1.py) | [model](https://s3.ap-northeast-2.amazonaws.com/open-mmlab/mmdetection/models/retinanet_r50_fpn_1x_20181125-7b0c2548.pth) | +| Cascade Mask R-CNN R-50-FPN | pytorch | 1x | 41.2 | 35.7 | 40.8 | 35.6 | [config](./cascade-mask-rcnn_r50_fpn_1x_coco_v1.py) | [model](https://s3.ap-northeast-2.amazonaws.com/open-mmlab/mmdetection/models/cascade_mask_rcnn_r50_fpn_1x_20181123-88b170c9.pth) | +| SSD300-VGG16 | caffe | 120e | 25.7 | - | 25.4 | - | [config](./ssd300_coco_v1.py) | [model](https://s3.ap-northeast-2.amazonaws.com/open-mmlab/mmdetection/models/ssd300_coco_vgg16_caffe_120e_20181221-84d7110b.pth) | diff --git a/mmdetection/configs/legacy_1.x/cascade-mask-rcnn_r50_fpn_1x_coco_v1.py b/mmdetection/configs/legacy_1.x/cascade-mask-rcnn_r50_fpn_1x_coco_v1.py new file mode 100644 index 00000000..f948a7a9 --- /dev/null +++ b/mmdetection/configs/legacy_1.x/cascade-mask-rcnn_r50_fpn_1x_coco_v1.py @@ -0,0 +1,78 @@ +_base_ = [ + '../_base_/models/cascade-mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +model = dict( + type='CascadeRCNN', + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + num_outs=5), + rpn_head=dict( + anchor_generator=dict(type='LegacyAnchorGenerator', center_offset=0.5), + bbox_coder=dict( + type='LegacyDeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[1.0, 1.0, 1.0, 1.0])), + roi_head=dict( + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict( + type='RoIAlign', + output_size=7, + sampling_ratio=2, + aligned=False)), + bbox_head=[ + dict( + type='Shared2FCBBoxHead', + reg_class_agnostic=True, + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='LegacyDeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2])), + dict( + type='Shared2FCBBoxHead', + reg_class_agnostic=True, + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='LegacyDeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.05, 0.05, 0.1, 0.1])), + dict( + type='Shared2FCBBoxHead', + reg_class_agnostic=True, + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='LegacyDeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.033, 0.033, 0.067, 0.067])), + ], + mask_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict( + type='RoIAlign', + output_size=14, + sampling_ratio=2, + aligned=False)))) diff --git a/mmdetection/configs/legacy_1.x/faster-rcnn_r50_fpn_1x_coco_v1.py b/mmdetection/configs/legacy_1.x/faster-rcnn_r50_fpn_1x_coco_v1.py new file mode 100644 index 00000000..66bf9713 --- /dev/null +++ b/mmdetection/configs/legacy_1.x/faster-rcnn_r50_fpn_1x_coco_v1.py @@ -0,0 +1,38 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +model = dict( + type='FasterRCNN', + backbone=dict( + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + rpn_head=dict( + type='RPNHead', + anchor_generator=dict( + type='LegacyAnchorGenerator', + center_offset=0.5, + scales=[8], + ratios=[0.5, 1.0, 2.0], + strides=[4, 8, 16, 32, 64]), + bbox_coder=dict(type='LegacyDeltaXYWHBBoxCoder'), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=1.0)), + roi_head=dict( + type='StandardRoIHead', + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict( + type='RoIAlign', + output_size=7, + sampling_ratio=2, + aligned=False), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + bbox_head=dict( + bbox_coder=dict(type='LegacyDeltaXYWHBBoxCoder'), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0))), + # model training and testing settings + train_cfg=dict( + rpn_proposal=dict(max_per_img=2000), + rcnn=dict(assigner=dict(match_low_quality=True)))) diff --git a/mmdetection/configs/legacy_1.x/mask-rcnn_r50_fpn_1x_coco_v1.py b/mmdetection/configs/legacy_1.x/mask-rcnn_r50_fpn_1x_coco_v1.py new file mode 100644 index 00000000..69080259 --- /dev/null +++ b/mmdetection/configs/legacy_1.x/mask-rcnn_r50_fpn_1x_coco_v1.py @@ -0,0 +1,34 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +model = dict( + rpn_head=dict( + anchor_generator=dict(type='LegacyAnchorGenerator', center_offset=0.5), + bbox_coder=dict(type='LegacyDeltaXYWHBBoxCoder'), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=1.0)), + roi_head=dict( + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict( + type='RoIAlign', + output_size=7, + sampling_ratio=2, + aligned=False)), + mask_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict( + type='RoIAlign', + output_size=14, + sampling_ratio=2, + aligned=False)), + bbox_head=dict( + bbox_coder=dict(type='LegacyDeltaXYWHBBoxCoder'), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0))), + + # model training and testing settings + train_cfg=dict( + rpn_proposal=dict(max_per_img=2000), + rcnn=dict(assigner=dict(match_low_quality=True)))) diff --git a/mmdetection/configs/legacy_1.x/retinanet_r50-caffe_fpn_1x_coco_v1.py b/mmdetection/configs/legacy_1.x/retinanet_r50-caffe_fpn_1x_coco_v1.py new file mode 100644 index 00000000..49abc31a --- /dev/null +++ b/mmdetection/configs/legacy_1.x/retinanet_r50-caffe_fpn_1x_coco_v1.py @@ -0,0 +1,16 @@ +_base_ = './retinanet_r50_fpn_1x_coco_v1.py' +model = dict( + data_preprocessor=dict( + type='DetDataPreprocessor', + # use caffe img_norm + mean=[102.9801, 115.9465, 122.7717], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False, + pad_size_divisor=32), + backbone=dict( + norm_cfg=dict(requires_grad=False), + norm_eval=True, + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron/resnet50_caffe'))) diff --git a/mmdetection/configs/legacy_1.x/retinanet_r50_fpn_1x_coco_v1.py b/mmdetection/configs/legacy_1.x/retinanet_r50_fpn_1x_coco_v1.py new file mode 100644 index 00000000..6198b971 --- /dev/null +++ b/mmdetection/configs/legacy_1.x/retinanet_r50_fpn_1x_coco_v1.py @@ -0,0 +1,17 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +model = dict( + bbox_head=dict( + type='RetinaHead', + anchor_generator=dict( + type='LegacyAnchorGenerator', + center_offset=0.5, + octave_base_scale=4, + scales_per_octave=3, + ratios=[0.5, 1.0, 2.0], + strides=[8, 16, 32, 64, 128]), + bbox_coder=dict(type='LegacyDeltaXYWHBBoxCoder'), + loss_bbox=dict(type='SmoothL1Loss', beta=0.11, loss_weight=1.0))) diff --git a/mmdetection/configs/legacy_1.x/ssd300_coco_v1.py b/mmdetection/configs/legacy_1.x/ssd300_coco_v1.py new file mode 100644 index 00000000..e5ffc633 --- /dev/null +++ b/mmdetection/configs/legacy_1.x/ssd300_coco_v1.py @@ -0,0 +1,20 @@ +_base_ = [ + '../_base_/models/ssd300.py', '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_2x.py', '../_base_/default_runtime.py' +] +# model settings +input_size = 300 +model = dict( + bbox_head=dict( + type='SSDHead', + anchor_generator=dict( + type='LegacySSDAnchorGenerator', + scale_major=False, + input_size=input_size, + basesize_ratio_range=(0.15, 0.9), + strides=[8, 16, 32, 64, 100, 300], + ratios=[[2], [2, 3], [2, 3], [2, 3], [2], [2]]), + bbox_coder=dict( + type='LegacyDeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.1, 0.1, 0.2, 0.2]))) diff --git a/mmdetection/configs/libra_rcnn/README.md b/mmdetection/configs/libra_rcnn/README.md new file mode 100644 index 00000000..ee8015ba --- /dev/null +++ b/mmdetection/configs/libra_rcnn/README.md @@ -0,0 +1,53 @@ +# Libra R-CNN + +> [Libra R-CNN: Towards Balanced Learning for Object Detection](https://arxiv.org/abs/1904.02701) + + + +## Abstract + +Compared with model architectures, the training process, which is also crucial to the success of detectors, has received relatively less attention in object detection. In this work, we carefully revisit the standard training practice of detectors, and find that the detection performance is often limited by the imbalance during the training process, which generally consists in three levels - sample level, feature level, and objective level. To mitigate the adverse effects caused thereby, we propose Libra R-CNN, a simple but effective framework towards balanced learning for object detection. It integrates three novel components: IoU-balanced sampling, balanced feature pyramid, and balanced L1 loss, respectively for reducing the imbalance at sample, feature, and objective level. Benefitted from the overall balanced design, Libra R-CNN significantly improves the detection performance. Without bells and whistles, it achieves 2.5 points and 2.0 points higher Average Precision (AP) than FPN Faster R-CNN and RetinaNet respectively on MSCOCO. + +Instance recognition is rapidly advanced along with the developments of various deep convolutional neural networks. Compared to the architectures of networks, the training process, which is also crucial to the success of detectors, has received relatively less attention. In this work, we carefully revisit the standard training practice of detectors, and find that the detection performance is often limited by the imbalance during the training process, which generally consists in three levels - sample level, feature level, and objective level. To mitigate the adverse effects caused thereby, we propose Libra R-CNN, a simple yet effective framework towards balanced learning for instance recognition. It integrates IoU-balanced sampling, balanced feature pyramid, and objective re-weighting, respectively for reducing the imbalance at sample, feature, and objective level. Extensive experiments conducted on MS COCO, LVIS and Pascal VOC datasets prove the effectiveness of the overall balanced design. + +
    + +
    + +## Results and Models + +The results on COCO 2017val are shown in the below table. (results on test-dev are usually slightly higher than val) + +| Architecture | Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :----------: | :-------------: | :-----: | :-----: | :------: | :------------: | :----: | :-----------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| Faster R-CNN | R-50-FPN | pytorch | 1x | 4.6 | 19.0 | 38.3 | [config](./libra-faster-rcnn_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/libra_rcnn/libra_faster_rcnn_r50_fpn_1x_coco/libra_faster_rcnn_r50_fpn_1x_coco_20200130-3afee3a9.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/libra_rcnn/libra_faster_rcnn_r50_fpn_1x_coco/libra_faster_rcnn_r50_fpn_1x_coco_20200130_204655.log.json) | +| Fast R-CNN | R-50-FPN | pytorch | 1x | | | | | | +| Faster R-CNN | R-101-FPN | pytorch | 1x | 6.5 | 14.4 | 40.1 | [config](./libra-faster-rcnn_r101_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/libra_rcnn/libra_faster_rcnn_r101_fpn_1x_coco/libra_faster_rcnn_r101_fpn_1x_coco_20200203-8dba6a5a.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/libra_rcnn/libra_faster_rcnn_r101_fpn_1x_coco/libra_faster_rcnn_r101_fpn_1x_coco_20200203_001405.log.json) | +| Faster R-CNN | X-101-64x4d-FPN | pytorch | 1x | 10.8 | 8.5 | 42.7 | [config](./libra-faster-rcnn_x101-64x4d_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/libra_rcnn/libra_faster_rcnn_x101_64x4d_fpn_1x_coco/libra_faster_rcnn_x101_64x4d_fpn_1x_coco_20200315-3a7d0488.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/libra_rcnn/libra_faster_rcnn_x101_64x4d_fpn_1x_coco/libra_faster_rcnn_x101_64x4d_fpn_1x_coco_20200315_231625.log.json) | +| RetinaNet | R-50-FPN | pytorch | 1x | 4.2 | 17.7 | 37.6 | [config](./libra-retinanet_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/libra_rcnn/libra_retinanet_r50_fpn_1x_coco/libra_retinanet_r50_fpn_1x_coco_20200205-804d94ce.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/libra_rcnn/libra_retinanet_r50_fpn_1x_coco/libra_retinanet_r50_fpn_1x_coco_20200205_112757.log.json) | + +## Citation + +We provide config files to reproduce the results in the CVPR 2019 paper [Libra R-CNN](https://arxiv.org/pdf/1904.02701.pdf). + +The extended version of [Libra R-CNN](https://arxiv.org/pdf/2108.10175.pdf) is accpeted by IJCV. + +```latex +@inproceedings{pang2019libra, + title={Libra R-CNN: Towards Balanced Learning for Object Detection}, + author={Pang, Jiangmiao and Chen, Kai and Shi, Jianping and Feng, Huajun and Ouyang, Wanli and Dahua Lin}, + booktitle={IEEE Conference on Computer Vision and Pattern Recognition}, + year={2019} +} + +@article{pang2021towards, + title={Towards Balanced Learning for Instance Recognition}, + author={Pang, Jiangmiao and Chen, Kai and Li, Qi and Xu, Zhihai and Feng, Huajun and Shi, Jianping and Ouyang, Wanli and Lin, Dahua}, + journal={International Journal of Computer Vision}, + volume={129}, + number={5}, + pages={1376--1393}, + year={2021}, + publisher={Springer} +} +``` diff --git a/mmdetection/configs/libra_rcnn/libra-fast-rcnn_r50_fpn_1x_coco.py b/mmdetection/configs/libra_rcnn/libra-fast-rcnn_r50_fpn_1x_coco.py new file mode 100644 index 00000000..2efe440c --- /dev/null +++ b/mmdetection/configs/libra_rcnn/libra-fast-rcnn_r50_fpn_1x_coco.py @@ -0,0 +1,52 @@ +_base_ = '../fast_rcnn/fast-rcnn_r50_fpn_1x_coco.py' +# model settings +model = dict( + neck=[ + dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + num_outs=5), + dict( + type='BFP', + in_channels=256, + num_levels=5, + refine_level=2, + refine_type='non_local') + ], + roi_head=dict( + bbox_head=dict( + loss_bbox=dict( + _delete_=True, + type='BalancedL1Loss', + alpha=0.5, + gamma=1.5, + beta=1.0, + loss_weight=1.0))), + # model training and testing settings + train_cfg=dict( + rcnn=dict( + sampler=dict( + _delete_=True, + type='CombinedSampler', + num=512, + pos_fraction=0.25, + add_gt_as_proposals=True, + pos_sampler=dict(type='InstanceBalancedPosSampler'), + neg_sampler=dict( + type='IoUBalancedNegSampler', + floor_thr=-1, + floor_fraction=0, + num_bins=3))))) + +# MMEngine support the following two ways, users can choose +# according to convenience +# _base_.train_dataloader.dataset.proposal_file = 'libra_proposals/rpn_r50_fpn_1x_train2017.pkl' # noqa +train_dataloader = dict( + dataset=dict(proposal_file='libra_proposals/rpn_r50_fpn_1x_train2017.pkl')) + +# _base_.val_dataloader.dataset.proposal_file = 'libra_proposals/rpn_r50_fpn_1x_val2017.pkl' # noqa +# test_dataloader = _base_.val_dataloader +val_dataloader = dict( + dataset=dict(proposal_file='libra_proposals/rpn_r50_fpn_1x_val2017.pkl')) +test_dataloader = val_dataloader diff --git a/mmdetection/configs/libra_rcnn/libra-faster-rcnn_r101_fpn_1x_coco.py b/mmdetection/configs/libra_rcnn/libra-faster-rcnn_r101_fpn_1x_coco.py new file mode 100644 index 00000000..985df64c --- /dev/null +++ b/mmdetection/configs/libra_rcnn/libra-faster-rcnn_r101_fpn_1x_coco.py @@ -0,0 +1,6 @@ +_base_ = './libra-faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/libra_rcnn/libra-faster-rcnn_r50_fpn_1x_coco.py b/mmdetection/configs/libra_rcnn/libra-faster-rcnn_r50_fpn_1x_coco.py new file mode 100644 index 00000000..f9ee507d --- /dev/null +++ b/mmdetection/configs/libra_rcnn/libra-faster-rcnn_r50_fpn_1x_coco.py @@ -0,0 +1,41 @@ +_base_ = '../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py' +# model settings +model = dict( + neck=[ + dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + num_outs=5), + dict( + type='BFP', + in_channels=256, + num_levels=5, + refine_level=2, + refine_type='non_local') + ], + roi_head=dict( + bbox_head=dict( + loss_bbox=dict( + _delete_=True, + type='BalancedL1Loss', + alpha=0.5, + gamma=1.5, + beta=1.0, + loss_weight=1.0))), + # model training and testing settings + train_cfg=dict( + rpn=dict(sampler=dict(neg_pos_ub=5), allowed_border=-1), + rcnn=dict( + sampler=dict( + _delete_=True, + type='CombinedSampler', + num=512, + pos_fraction=0.25, + add_gt_as_proposals=True, + pos_sampler=dict(type='InstanceBalancedPosSampler'), + neg_sampler=dict( + type='IoUBalancedNegSampler', + floor_thr=-1, + floor_fraction=0, + num_bins=3))))) diff --git a/mmdetection/configs/libra_rcnn/libra-faster-rcnn_x101-64x4d_fpn_1x_coco.py b/mmdetection/configs/libra_rcnn/libra-faster-rcnn_x101-64x4d_fpn_1x_coco.py new file mode 100644 index 00000000..158e238e --- /dev/null +++ b/mmdetection/configs/libra_rcnn/libra-faster-rcnn_x101-64x4d_fpn_1x_coco.py @@ -0,0 +1,14 @@ +_base_ = './libra-faster-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/libra_rcnn/libra-retinanet_r50_fpn_1x_coco.py b/mmdetection/configs/libra_rcnn/libra-retinanet_r50_fpn_1x_coco.py new file mode 100644 index 00000000..be274209 --- /dev/null +++ b/mmdetection/configs/libra_rcnn/libra-retinanet_r50_fpn_1x_coco.py @@ -0,0 +1,26 @@ +_base_ = '../retinanet/retinanet_r50_fpn_1x_coco.py' +# model settings +model = dict( + neck=[ + dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_input', + num_outs=5), + dict( + type='BFP', + in_channels=256, + num_levels=5, + refine_level=1, + refine_type='non_local') + ], + bbox_head=dict( + loss_bbox=dict( + _delete_=True, + type='BalancedL1Loss', + alpha=0.5, + gamma=1.5, + beta=0.11, + loss_weight=1.0))) diff --git a/mmdetection/configs/libra_rcnn/metafile.yml b/mmdetection/configs/libra_rcnn/metafile.yml new file mode 100644 index 00000000..f01bd02b --- /dev/null +++ b/mmdetection/configs/libra_rcnn/metafile.yml @@ -0,0 +1,99 @@ +Collections: + - Name: Libra R-CNN + Metadata: + Training Data: COCO + Training Techniques: + - IoU-Balanced Sampling + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - Balanced Feature Pyramid + Paper: + URL: https://arxiv.org/abs/1904.02701 + Title: 'Libra R-CNN: Towards Balanced Learning for Object Detection' + README: configs/libra_rcnn/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/necks/bfp.py#L10 + Version: v2.0.0 + +Models: + - Name: libra-faster-rcnn_r50_fpn_1x_coco + In Collection: Libra R-CNN + Config: configs/libra_rcnn/libra-faster-rcnn_r50_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.6 + inference time (ms/im): + - value: 52.63 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/libra_rcnn/libra_faster_rcnn_r50_fpn_1x_coco/libra_faster_rcnn_r50_fpn_1x_coco_20200130-3afee3a9.pth + + - Name: libra-faster-rcnn_r101_fpn_1x_coco + In Collection: Libra R-CNN + Config: configs/libra_rcnn/libra-faster-rcnn_r101_fpn_1x_coco.py + Metadata: + Training Memory (GB): 6.5 + inference time (ms/im): + - value: 69.44 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/libra_rcnn/libra_faster_rcnn_r101_fpn_1x_coco/libra_faster_rcnn_r101_fpn_1x_coco_20200203-8dba6a5a.pth + + - Name: libra-faster-rcnn_x101-64x4d_fpn_1x_coco + In Collection: Libra R-CNN + Config: configs/libra_rcnn/libra-faster-rcnn_x101-64x4d_fpn_1x_coco.py + Metadata: + Training Memory (GB): 10.8 + inference time (ms/im): + - value: 117.65 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/libra_rcnn/libra_faster_rcnn_x101_64x4d_fpn_1x_coco/libra_faster_rcnn_x101_64x4d_fpn_1x_coco_20200315-3a7d0488.pth + + - Name: libra-retinanet_r50_fpn_1x_coco + In Collection: Libra R-CNN + Config: configs/libra_rcnn/libra-retinanet_r50_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.2 + inference time (ms/im): + - value: 56.5 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/libra_rcnn/libra_retinanet_r50_fpn_1x_coco/libra_retinanet_r50_fpn_1x_coco_20200205-804d94ce.pth diff --git a/mmdetection/configs/lvis/README.md b/mmdetection/configs/lvis/README.md new file mode 100644 index 00000000..57aeda43 --- /dev/null +++ b/mmdetection/configs/lvis/README.md @@ -0,0 +1,56 @@ +# LVIS + +> [LVIS: A Dataset for Large Vocabulary Instance Segmentation](https://arxiv.org/abs/1908.03195) + + + +## Abstract + +Progress on object detection is enabled by datasets that focus the research community's attention on open challenges. This process led us from simple images to complex scenes and from bounding boxes to segmentation masks. In this work, we introduce LVIS (pronounced \`el-vis'): a new dataset for Large Vocabulary Instance Segmentation. We plan to collect ~2 million high-quality instance segmentation masks for over 1000 entry-level object categories in 164k images. Due to the Zipfian distribution of categories in natural images, LVIS naturally has a long tail of categories with few training samples. Given that state-of-the-art deep learning methods for object detection perform poorly in the low-sample regime, we believe that our dataset poses an important and exciting new scientific challenge. + +
    + +
    + +## Common Setting + +- Please follow [install guide](../../docs/get_started.md#install-mmdetection) to install open-mmlab forked cocoapi first. + +- Run following scripts to install our forked lvis-api. + + ```shell + pip install git+https://github.com/lvis-dataset/lvis-api.git + ``` + +- All experiments use oversample strategy [here](../../docs/tutorials/customize_dataset.md#class-balanced-dataset) with oversample threshold `1e-3`. + +- The size of LVIS v0.5 is half of COCO, so schedule `2x` in LVIS is roughly the same iterations as `1x` in COCO. + +## Results and models of LVIS v0.5 + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :-------------: | :-----: | :-----: | :------: | :------------: | :----: | :-----: | :----------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | pytorch | 2x | - | - | 26.1 | 25.9 | [config](./mask-rcnn_r50_fpn_sample1e-3_ms-2x_lvis-v0.5.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/lvis/mask_rcnn_r50_fpn_sample1e-3_mstrain_2x_lvis/mask_rcnn_r50_fpn_sample1e-3_mstrain_2x_lvis-dbd06831.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/lvis/mask_rcnn_r50_fpn_sample1e-3_mstrain_2x_lvis/mask_rcnn_r50_fpn_sample1e-3_mstrain_2x_lvis_20200531_160435.log.json) | +| R-101-FPN | pytorch | 2x | - | - | 27.1 | 27.0 | [config](./mask-rcnn_r101_fpn_sample1e-3_ms-2x_lvis-v0.5.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/lvis/mask_rcnn_r101_fpn_sample1e-3_mstrain_2x_lvis/mask_rcnn_r101_fpn_sample1e-3_mstrain_2x_lvis-54582ee2.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/lvis/mask_rcnn_r101_fpn_sample1e-3_mstrain_2x_lvis/mask_rcnn_r101_fpn_sample1e-3_mstrain_2x_lvis_20200601_134748.log.json) | +| X-101-32x4d-FPN | pytorch | 2x | - | - | 26.7 | 26.9 | [config](./mask-rcnn_x101-32x4d_fpn_sample1e-3_ms-2x_lvis-v0.5.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/lvis/mask_rcnn_x101_32x4d_fpn_sample1e-3_mstrain_2x_lvis/mask_rcnn_x101_32x4d_fpn_sample1e-3_mstrain_2x_lvis-3cf55ea2.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/lvis/mask_rcnn_x101_32x4d_fpn_sample1e-3_mstrain_2x_lvis/mask_rcnn_x101_32x4d_fpn_sample1e-3_mstrain_2x_lvis_20200531_221749.log.json) | +| X-101-64x4d-FPN | pytorch | 2x | - | - | 26.4 | 26.0 | [config](./mask-rcnn_x101-64x4d_fpn_sample1e-3_ms-2x_lvis-v0.5.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/lvis/mask_rcnn_x101_64x4d_fpn_sample1e-3_mstrain_2x_lvis/mask_rcnn_x101_64x4d_fpn_sample1e-3_mstrain_2x_lvis-1c99a5ad.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/lvis/mask_rcnn_x101_64x4d_fpn_sample1e-3_mstrain_2x_lvis/mask_rcnn_x101_64x4d_fpn_sample1e-3_mstrain_2x_lvis_20200601_194651.log.json) | + +## Results and models of LVIS v1 + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :-------------: | :-----: | :-----: | :------: | :------------: | :----: | :-----: | :--------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | pytorch | 1x | 9.1 | - | 22.5 | 21.7 | [config](./mask-rcnn_r50_fpn_sample1e-3_ms-1x_lvis-v1.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/lvis/mask_rcnn_r50_fpn_sample1e-3_mstrain_1x_lvis_v1/mask_rcnn_r50_fpn_sample1e-3_mstrain_1x_lvis_v1-aa78ac3d.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/lvis/mask_rcnn_r50_fpn_sample1e-3_mstrain_1x_lvis_v1/mask_rcnn_r50_fpn_sample1e-3_mstrain_1x_lvis_v1-20200829_061305.log.json) | +| R-101-FPN | pytorch | 1x | 10.8 | - | 24.6 | 23.6 | [config](./mask-rcnn_r101_fpn_sample1e-3_ms-1x_lvis-v1.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/lvis/mask_rcnn_r101_fpn_sample1e-3_mstrain_1x_lvis_v1/mask_rcnn_r101_fpn_sample1e-3_mstrain_1x_lvis_v1-ec55ce32.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/lvis/mask_rcnn_r101_fpn_sample1e-3_mstrain_1x_lvis_v1/mask_rcnn_r101_fpn_sample1e-3_mstrain_1x_lvis_v1-20200829_070959.log.json) | +| X-101-32x4d-FPN | pytorch | 1x | 11.8 | - | 26.7 | 25.5 | [config](./mask-rcnn_x101-32x4d_fpn_sample1e-3_ms-1x_lvis-v1.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/lvis/mask_rcnn_x101_32x4d_fpn_sample1e-3_mstrain_1x_lvis_v1/mask_rcnn_x101_32x4d_fpn_sample1e-3_mstrain_1x_lvis_v1-ebbc5c81.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/lvis/mask_rcnn_x101_32x4d_fpn_sample1e-3_mstrain_1x_lvis_v1/mask_rcnn_x101_32x4d_fpn_sample1e-3_mstrain_1x_lvis_v1-20200829_071317.log.json) | +| X-101-64x4d-FPN | pytorch | 1x | 14.6 | - | 27.2 | 25.8 | [config](./mask-rcnn_x101-64x4d_fpn_sample1e-3_ms-1x_lvis-v1.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/lvis/mask_rcnn_x101_64x4d_fpn_sample1e-3_mstrain_1x_lvis_v1/mask_rcnn_x101_64x4d_fpn_sample1e-3_mstrain_1x_lvis_v1-43d9edfe.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/lvis/mask_rcnn_x101_64x4d_fpn_sample1e-3_mstrain_1x_lvis_v1/mask_rcnn_x101_64x4d_fpn_sample1e-3_mstrain_1x_lvis_v1-20200830_060206.log.json) | + +## Citation + +```latex +@inproceedings{gupta2019lvis, + title={{LVIS}: A Dataset for Large Vocabulary Instance Segmentation}, + author={Gupta, Agrim and Dollar, Piotr and Girshick, Ross}, + booktitle={Proceedings of the {IEEE} Conference on Computer Vision and Pattern Recognition}, + year={2019} +} +``` diff --git a/mmdetection/configs/lvis/mask-rcnn_r101_fpn_sample1e-3_ms-1x_lvis-v1.py b/mmdetection/configs/lvis/mask-rcnn_r101_fpn_sample1e-3_ms-1x_lvis-v1.py new file mode 100644 index 00000000..3994d75a --- /dev/null +++ b/mmdetection/configs/lvis/mask-rcnn_r101_fpn_sample1e-3_ms-1x_lvis-v1.py @@ -0,0 +1,6 @@ +_base_ = './mask-rcnn_r50_fpn_sample1e-3_ms-1x_lvis-v1.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/lvis/mask-rcnn_r101_fpn_sample1e-3_ms-2x_lvis-v0.5.py b/mmdetection/configs/lvis/mask-rcnn_r101_fpn_sample1e-3_ms-2x_lvis-v0.5.py new file mode 100644 index 00000000..ed8b3639 --- /dev/null +++ b/mmdetection/configs/lvis/mask-rcnn_r101_fpn_sample1e-3_ms-2x_lvis-v0.5.py @@ -0,0 +1,6 @@ +_base_ = './mask-rcnn_r50_fpn_sample1e-3_ms-2x_lvis-v0.5.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/lvis/mask-rcnn_r50_fpn_sample1e-3_ms-1x_lvis-v1.py b/mmdetection/configs/lvis/mask-rcnn_r50_fpn_sample1e-3_ms-1x_lvis-v1.py new file mode 100644 index 00000000..cdd3683e --- /dev/null +++ b/mmdetection/configs/lvis/mask-rcnn_r50_fpn_sample1e-3_ms-1x_lvis-v1.py @@ -0,0 +1,13 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/lvis_v1_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +model = dict( + roi_head=dict( + bbox_head=dict(num_classes=1203), mask_head=dict(num_classes=1203)), + test_cfg=dict( + rcnn=dict( + score_thr=0.0001, + # LVIS allows up to 300 + max_per_img=300))) diff --git a/mmdetection/configs/lvis/mask-rcnn_r50_fpn_sample1e-3_ms-2x_lvis-v0.5.py b/mmdetection/configs/lvis/mask-rcnn_r50_fpn_sample1e-3_ms-2x_lvis-v0.5.py new file mode 100644 index 00000000..b36b6c17 --- /dev/null +++ b/mmdetection/configs/lvis/mask-rcnn_r50_fpn_sample1e-3_ms-2x_lvis-v0.5.py @@ -0,0 +1,13 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/lvis_v0.5_instance.py', + '../_base_/schedules/schedule_2x.py', '../_base_/default_runtime.py' +] +model = dict( + roi_head=dict( + bbox_head=dict(num_classes=1230), mask_head=dict(num_classes=1230)), + test_cfg=dict( + rcnn=dict( + score_thr=0.0001, + # LVIS allows up to 300 + max_per_img=300))) diff --git a/mmdetection/configs/lvis/mask-rcnn_x101-32x4d_fpn_sample1e-3_ms-1x_lvis-v1.py b/mmdetection/configs/lvis/mask-rcnn_x101-32x4d_fpn_sample1e-3_ms-1x_lvis-v1.py new file mode 100644 index 00000000..9da3ab6d --- /dev/null +++ b/mmdetection/configs/lvis/mask-rcnn_x101-32x4d_fpn_sample1e-3_ms-1x_lvis-v1.py @@ -0,0 +1,14 @@ +_base_ = './mask-rcnn_r50_fpn_sample1e-3_ms-1x_lvis-v1.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/lvis/mask-rcnn_x101-32x4d_fpn_sample1e-3_ms-2x_lvis-v0.5.py b/mmdetection/configs/lvis/mask-rcnn_x101-32x4d_fpn_sample1e-3_ms-2x_lvis-v0.5.py new file mode 100644 index 00000000..9a097c94 --- /dev/null +++ b/mmdetection/configs/lvis/mask-rcnn_x101-32x4d_fpn_sample1e-3_ms-2x_lvis-v0.5.py @@ -0,0 +1,14 @@ +_base_ = './mask-rcnn_r50_fpn_sample1e-3_ms-2x_lvis-v0.5.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/lvis/mask-rcnn_x101-64x4d_fpn_sample1e-3_ms-1x_lvis-v1.py b/mmdetection/configs/lvis/mask-rcnn_x101-64x4d_fpn_sample1e-3_ms-1x_lvis-v1.py new file mode 100644 index 00000000..b0819b3e --- /dev/null +++ b/mmdetection/configs/lvis/mask-rcnn_x101-64x4d_fpn_sample1e-3_ms-1x_lvis-v1.py @@ -0,0 +1,14 @@ +_base_ = './mask-rcnn_r50_fpn_sample1e-3_ms-1x_lvis-v1.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/lvis/mask-rcnn_x101-64x4d_fpn_sample1e-3_ms-2x_lvis-v0.5.py b/mmdetection/configs/lvis/mask-rcnn_x101-64x4d_fpn_sample1e-3_ms-2x_lvis-v0.5.py new file mode 100644 index 00000000..9d272008 --- /dev/null +++ b/mmdetection/configs/lvis/mask-rcnn_x101-64x4d_fpn_sample1e-3_ms-2x_lvis-v0.5.py @@ -0,0 +1,14 @@ +_base_ = './mask-rcnn_r50_fpn_sample1e-3_ms-2x_lvis-v0.5.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/lvis/metafile.yml b/mmdetection/configs/lvis/metafile.yml new file mode 100644 index 00000000..f8def96c --- /dev/null +++ b/mmdetection/configs/lvis/metafile.yml @@ -0,0 +1,128 @@ +Models: + - Name: mask-rcnn_r50_fpn_sample1e-3_ms-2x_lvis-v0.5 + In Collection: Mask R-CNN + Config: configs/lvis/mask-rcnn_r50_fpn_sample1e-3_ms-2x_lvis-v0.5.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: LVIS v0.5 + Metrics: + box AP: 26.1 + - Task: Instance Segmentation + Dataset: LVIS v0.5 + Metrics: + mask AP: 25.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/lvis/mask_rcnn_r50_fpn_sample1e-3_mstrain_2x_lvis/mask_rcnn_r50_fpn_sample1e-3_mstrain_2x_lvis-dbd06831.pth + + - Name: mask-rcnn_r101_fpn_sample1e-3_ms-2x_lvis-v0.5 + In Collection: Mask R-CNN + Config: configs/lvis/mask-rcnn_r101_fpn_sample1e-3_ms-2x_lvis-v0.5.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: LVIS v0.5 + Metrics: + box AP: 27.1 + - Task: Instance Segmentation + Dataset: LVIS v0.5 + Metrics: + mask AP: 27.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/lvis/mask_rcnn_r101_fpn_sample1e-3_mstrain_2x_lvis/mask_rcnn_r101_fpn_sample1e-3_mstrain_2x_lvis-54582ee2.pth + + - Name: mask-rcnn_x101-32x4d_fpn_sample1e-3_ms-2x_lvis-v0.5 + In Collection: Mask R-CNN + Config: configs/lvis/mask-rcnn_x101-32x4d_fpn_sample1e-3_ms-2x_lvis-v0.5.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: LVIS v0.5 + Metrics: + box AP: 26.7 + - Task: Instance Segmentation + Dataset: LVIS v0.5 + Metrics: + mask AP: 26.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/lvis/mask_rcnn_x101_32x4d_fpn_sample1e-3_mstrain_2x_lvis/mask_rcnn_x101_32x4d_fpn_sample1e-3_mstrain_2x_lvis-3cf55ea2.pth + + - Name: mask-rcnn_x101-64x4d_fpn_sample1e-3_ms-2x_lvis-v0.5 + In Collection: Mask R-CNN + Config: configs/lvis/mask-rcnn_x101-64x4d_fpn_sample1e-3_ms-2x_lvis-v0.5.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: LVIS v0.5 + Metrics: + box AP: 26.4 + - Task: Instance Segmentation + Dataset: LVIS v0.5 + Metrics: + mask AP: 26.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/lvis/mask_rcnn_x101_64x4d_fpn_sample1e-3_mstrain_2x_lvis/mask_rcnn_x101_64x4d_fpn_sample1e-3_mstrain_2x_lvis-1c99a5ad.pth + + - Name: mask-rcnn_r50_fpn_sample1e-3_ms-1x_lvis-v1 + In Collection: Mask R-CNN + Config: configs/lvis/mask-rcnn_r50_fpn_sample1e-3_ms-1x_lvis-v1.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: LVIS v1 + Metrics: + box AP: 22.5 + - Task: Instance Segmentation + Dataset: LVIS v1 + Metrics: + mask AP: 21.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/lvis/mask_rcnn_r50_fpn_sample1e-3_mstrain_1x_lvis_v1/mask_rcnn_r50_fpn_sample1e-3_mstrain_1x_lvis_v1-aa78ac3d.pth + + - Name: mask-rcnn_r101_fpn_sample1e-3_ms-1x_lvis-v1 + In Collection: Mask R-CNN + Config: configs/lvis/mask-rcnn_r101_fpn_sample1e-3_ms-1x_lvis-v1.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: LVIS v1 + Metrics: + box AP: 24.6 + - Task: Instance Segmentation + Dataset: LVIS v1 + Metrics: + mask AP: 23.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/lvis/mask_rcnn_r101_fpn_sample1e-3_mstrain_1x_lvis_v1/mask_rcnn_r101_fpn_sample1e-3_mstrain_1x_lvis_v1-ec55ce32.pth + + - Name: mask-rcnn_x101-32x4d_fpn_sample1e-3_ms-1x_lvis-v1 + In Collection: Mask R-CNN + Config: configs/lvis/mask-rcnn_x101-32x4d_fpn_sample1e-3_ms-1x_lvis-v1.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: LVIS v1 + Metrics: + box AP: 26.7 + - Task: Instance Segmentation + Dataset: LVIS v1 + Metrics: + mask AP: 25.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/lvis/mask_rcnn_x101_32x4d_fpn_sample1e-3_mstrain_1x_lvis_v1/mask_rcnn_x101_32x4d_fpn_sample1e-3_mstrain_1x_lvis_v1-ebbc5c81.pth + + - Name: mask-rcnn_x101-64x4d_fpn_sample1e-3_ms-1x_lvis-v1 + In Collection: Mask R-CNN + Config: configs/lvis/mask-rcnn_x101-64x4d_fpn_sample1e-3_ms-1x_lvis-v1.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: LVIS v1 + Metrics: + box AP: 27.2 + - Task: Instance Segmentation + Dataset: LVIS v1 + Metrics: + mask AP: 25.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/lvis/mask_rcnn_x101_64x4d_fpn_sample1e-3_mstrain_1x_lvis_v1/mask_rcnn_x101_64x4d_fpn_sample1e-3_mstrain_1x_lvis_v1-43d9edfe.pth diff --git a/mmdetection/configs/mask2former/README.md b/mmdetection/configs/mask2former/README.md new file mode 100644 index 00000000..94b0821e --- /dev/null +++ b/mmdetection/configs/mask2former/README.md @@ -0,0 +1,76 @@ +# Mask2Former + +> [Masked-attention Mask Transformer for Universal Image Segmentation](http://arxiv.org/abs/2112.01527) + + + +## Abstract + +Image segmentation is about grouping pixels with different semantics, e.g., category or instance membership, where each choice of semantics defines a task. While only the semantics of each task differ, current research focuses on designing specialized architectures for each task. We present Masked-attention Mask Transformer (Mask2Former), a new architecture capable of addressing any image segmentation task (panoptic, instance or semantic). Its key components include masked attention, which extracts localized features by constraining cross-attention within predicted mask regions. In addition to reducing the research effort by at least three times, it outperforms the best specialized architectures by a significant margin on four popular datasets. Most notably, Mask2Former sets a new state-of-the-art for panoptic segmentation (57.8 PQ on COCO), instance segmentation (50.1 AP on COCO) and semantic segmentation (57.7 mIoU on ADE20K). + +
    + +
    + +## Introduction + +Mask2Former requires COCO and [COCO-panoptic](http://images.cocodataset.org/annotations/panoptic_annotations_trainval2017.zip) dataset for training and evaluation. You need to download and extract it in the COCO dataset path. +The directory should be like this. + +```none +mmdetection +├── mmdet +├── tools +├── configs +├── data +│ ├── coco +│ │ ├── annotations +| | | ├── instances_train2017.json +| | | ├── instances_val2017.json +│ │ │ ├── panoptic_train2017.json +│ │ │ ├── panoptic_train2017 +│ │ │ ├── panoptic_val2017.json +│ │ │ ├── panoptic_val2017 +│ │ ├── train2017 +│ │ ├── val2017 +│ │ ├── test2017 +``` + +## Results and Models + +### Panoptic segmentation + +| Backbone | style | Pretrain | Lr schd | Mem (GB) | Inf time (fps) | PQ | box mAP | mask mAP | Config | Download | +| -------- | ------- | ------------ | ------- | -------- | -------------- | ---- | ------- | -------- | ------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | +| R-50 | pytorch | ImageNet-1K | 50e | 13.9 | - | 52.0 | 44.5 | 41.8 | [config](./mask2former_r50_8xb2-lsj-50e_coco-panoptic.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/mask2former/mask2former_r50_8xb2-lsj-50e_coco-panoptic/mask2former_r50_8xb2-lsj-50e_coco-panoptic_20230118_125535-54df384a.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/mask2former/mask2former_r50_8xb2-lsj-50e_coco-panoptic/mask2former_r50_8xb2-lsj-50e_coco-panoptic_20230118_125535.log.json) | +| R-101 | pytorch | ImageNet-1K | 50e | 16.1 | - | 52.4 | 45.3 | 42.4 | [config](./mask2former_r101_8xb2-lsj-50e_coco-panoptic.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/mask2former/mask2former_r101_8xb2-lsj-50e_coco-panoptic/mask2former_r101_8xb2-lsj-50e_coco-panoptic_20220329_225104-c74d4d71.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask2former/mask2former_r101_lsj_8x2_50e_coco-panoptic/mask2former_r101_lsj_8x2_50e_coco-panoptic_20220329_225104.log.json) | +| Swin-T | - | ImageNet-1K | 50e | 15.9 | - | 53.4 | 46.3 | 43.4 | [config](./mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco-panoptic.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/mask2former/mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco-panoptic/mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco-panoptic_20220326_224553-3ec9e0ae.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask2former/mask2former_swin-t-p4-w7-224_lsj_8x2_50e_coco-panoptic/mask2former_swin-t-p4-w7-224_lsj_8x2_50e_coco-panoptic_20220326_224553.log.json) | +| Swin-S | - | ImageNet-1K | 50e | 19.1 | - | 54.5 | 47.8 | 44.5 | [config](./mask2former_swin-s-p4-w7-224_8xb2-lsj-50e_coco-panoptic.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/mask2former/mask2former_swin-s-p4-w7-224_8xb2-lsj-50e_coco-panoptic/mask2former_swin-s-p4-w7-224_8xb2-lsj-50e_coco-panoptic_20220329_225200-4a16ded7.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask2former/mask2former_swin-s-p4-w7-224_lsj_8x2_50e_coco-panoptic/mask2former_swin-s-p4-w7-224_lsj_8x2_50e_coco-panoptic_20220329_225200.log.json) | +| Swin-B | - | ImageNet-1K | 50e | 26.0 | - | 55.1 | 48.2 | 44.9 | [config](./mask2former_swin-b-p4-w12-384_8xb2-lsj-50e_coco-panoptic.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/mask2former/mask2former_swin-b-p4-w12-384_8xb2-lsj-50e_coco-panoptic/mask2former_swin-b-p4-w12-384_8xb2-lsj-50e_coco-panoptic_20220331_002244-8a651d82.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask2former/mask2former_swin-b-p4-w12-384_lsj_8x2_50e_coco-panoptic/mask2former_swin-b-p4-w12-384_lsj_8x2_50e_coco-panoptic_20220331_002244.log.json) | +| Swin-B | - | ImageNet-21K | 50e | 25.8 | - | 56.3 | 50.0 | 46.3 | [config](./mask2former_swin-b-p4-w12-384-in21k_8xb2-lsj-50e_coco-panoptic.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/mask2former/mask2former_swin-b-p4-w12-384-in21k_8xb2-lsj-50e_coco-panoptic/mask2former_swin-b-p4-w12-384-in21k_8xb2-lsj-50e_coco-panoptic_20220329_230021-05ec7315.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask2former/mask2former_swin-b-p4-w12-384-in21k_lsj_8x2_50e_coco-panoptic/mask2former_swin-b-p4-w12-384-in21k_lsj_8x2_50e_coco-panoptic_20220329_230021.log.json) | +| Swin-L | - | ImageNet-21K | 100e | 21.1 | - | 57.6 | 52.2 | 48.5 | [config](./mask2former_swin-l-p4-w12-384-in21k_16xb1-lsj-100e_coco-panoptic.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/mask2former/mask2former_swin-l-p4-w12-384-in21k_16xb1-lsj-100e_coco-panoptic/mask2former_swin-l-p4-w12-384-in21k_16xb1-lsj-100e_coco-panoptic_20220407_104949-82f8d28d.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask2former/mask2former_swin-l-p4-w12-384-in21k_lsj_16x1_100e_coco-panoptic/mask2former_swin-l-p4-w12-384-in21k_lsj_16x1_100e_coco-panoptic_20220407_104949.log.json) | + +### Instance segmentation + +| Backbone | style | Pretrain | Lr schd | Mem (GB) | Inf time (fps) | box mAP | mask mAP | Config | Download | +| -------- | ------- | ----------- | ------- | -------- | -------------- | ------- | -------- | ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | +| R-50 | pytorch | ImageNet-1K | 50e | 13.7 | - | 45.7 | 42.9 | [config](./mask2former_r50_8xb2-lsj-50e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/mask2former/mask2former_r50_8xb2-lsj-50e_coco/mask2former_r50_8xb2-lsj-50e_coco_20220506_191028-41b088b6.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask2former/mask2former_r50_lsj_8x2_50e_coco/mask2former_r50_lsj_8x2_50e_coco_20220506_191028.log.json) | +| R-101 | pytorch | ImageNet-1K | 50e | 15.5 | - | 46.7 | 44.0 | [config](./mask2former_r101_8xb2-lsj-50e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/mask2former/mask2former_r101_8xb2-lsj-50e_coco/mask2former_r101_8xb2-lsj-50e_coco_20220426_100250-ecf181e2.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask2former/mask2former_r101_lsj_8x2_50e_coco/mask2former_r101_lsj_8x2_50e_coco_20220426_100250.log.json) | +| Swin-T | - | ImageNet-1K | 50e | 15.3 | - | 47.7 | 44.7 | [config](./mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/mask2former/mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco/mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco_20220508_091649-01b0f990.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask2former/mask2former_swin-t-p4-w7-224_lsj_8x2_50e_coco/mask2former_swin-t-p4-w7-224_lsj_8x2_50e_coco_20220508_091649.log.json) | +| Swin-S | - | ImageNet-1K | 50e | 18.8 | - | 49.3 | 46.1 | [config](./mask2former_swin-s-p4-w7-224_8xb2-lsj-50e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/mask2former/mask2former_swin-s-p4-w7-224_8xb2-lsj-50e_coco/mask2former_swin-s-p4-w7-224_8xb2-lsj-50e_coco_20220504_001756-c9d0c4f2.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask2former/mask2former_swin-s-p4-w7-224_lsj_8x2_50e_coco/mask2former_swin-s-p4-w7-224_lsj_8x2_50e_coco_20220504_001756.log.json) | + +### Note + +1. The performance is unstable. The `Mask2Former-R50-coco-panoptic` may fluctuate about 0.2 PQ. The models other than `Mask2Former-R50-coco-panoptic` were trained with mmdet 2.x and have been converted for mmdet 3.x. +2. We have trained the instance segmentation models many times (see more details in [PR 7571](https://github.com/open-mmlab/mmdetection/pull/7571)). The results of the trained models are relatively stable (+- 0.2), and have a certain gap (about 0.2 AP) in comparison with the results in the [paper](http://arxiv.org/abs/2112.01527). However, the performance of the model trained with the official code is unstable and may also be slightly lower than the reported results as mentioned in the [issue](https://github.com/facebookresearch/Mask2Former/issues/46). + +## Citation + +```latex +@article{cheng2021mask2former, + title={Masked-attention Mask Transformer for Universal Image Segmentation}, + author={Bowen Cheng and Ishan Misra and Alexander G. Schwing and Alexander Kirillov and Rohit Girdhar}, + journal={arXiv}, + year={2021} +} +``` diff --git a/mmdetection/configs/mask2former/mask2former_r101_8xb2-lsj-50e_coco-panoptic.py b/mmdetection/configs/mask2former/mask2former_r101_8xb2-lsj-50e_coco-panoptic.py new file mode 100644 index 00000000..66685a2f --- /dev/null +++ b/mmdetection/configs/mask2former/mask2former_r101_8xb2-lsj-50e_coco-panoptic.py @@ -0,0 +1,7 @@ +_base_ = './mask2former_r50_8xb2-lsj-50e_coco-panoptic.py' + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/mask2former/mask2former_r101_8xb2-lsj-50e_coco.py b/mmdetection/configs/mask2former/mask2former_r101_8xb2-lsj-50e_coco.py new file mode 100644 index 00000000..f4c29906 --- /dev/null +++ b/mmdetection/configs/mask2former/mask2former_r101_8xb2-lsj-50e_coco.py @@ -0,0 +1,7 @@ +_base_ = ['./mask2former_r50_8xb2-lsj-50e_coco.py'] + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/mask2former/mask2former_r50_8xb2-lsj-50e_coco-panoptic.py b/mmdetection/configs/mask2former/mask2former_r50_8xb2-lsj-50e_coco-panoptic.py new file mode 100644 index 00000000..c53e981b --- /dev/null +++ b/mmdetection/configs/mask2former/mask2former_r50_8xb2-lsj-50e_coco-panoptic.py @@ -0,0 +1,251 @@ +_base_ = [ + '../_base_/datasets/coco_panoptic.py', '../_base_/default_runtime.py' +] +image_size = (1024, 1024) +batch_augments = [ + dict( + type='BatchFixedSizePad', + size=image_size, + img_pad_value=0, + pad_mask=True, + mask_pad_value=0, + pad_seg=True, + seg_pad_value=255) +] +data_preprocessor = dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32, + pad_mask=True, + mask_pad_value=0, + pad_seg=True, + seg_pad_value=255, + batch_augments=batch_augments) + +num_things_classes = 80 +num_stuff_classes = 53 +num_classes = num_things_classes + num_stuff_classes +model = dict( + type='Mask2Former', + data_preprocessor=data_preprocessor, + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=-1, + norm_cfg=dict(type='BN', requires_grad=False), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + panoptic_head=dict( + type='Mask2FormerHead', + in_channels=[256, 512, 1024, 2048], # pass to pixel_decoder inside + strides=[4, 8, 16, 32], + feat_channels=256, + out_channels=256, + num_things_classes=num_things_classes, + num_stuff_classes=num_stuff_classes, + num_queries=100, + num_transformer_feat_level=3, + pixel_decoder=dict( + type='MSDeformAttnPixelDecoder', + num_outs=3, + norm_cfg=dict(type='GN', num_groups=32), + act_cfg=dict(type='ReLU'), + encoder=dict( # DeformableDetrTransformerEncoder + num_layers=6, + layer_cfg=dict( # DeformableDetrTransformerEncoderLayer + self_attn_cfg=dict( # MultiScaleDeformableAttention + embed_dims=256, + num_heads=8, + num_levels=3, + num_points=4, + dropout=0.0, + batch_first=True), + ffn_cfg=dict( + embed_dims=256, + feedforward_channels=1024, + num_fcs=2, + ffn_drop=0.0, + act_cfg=dict(type='ReLU', inplace=True)))), + positional_encoding=dict(num_feats=128, normalize=True)), + enforce_decoder_input_project=False, + positional_encoding=dict(num_feats=128, normalize=True), + transformer_decoder=dict( # Mask2FormerTransformerDecoder + return_intermediate=True, + num_layers=9, + layer_cfg=dict( # Mask2FormerTransformerDecoderLayer + self_attn_cfg=dict( # MultiheadAttention + embed_dims=256, + num_heads=8, + dropout=0.0, + batch_first=True), + cross_attn_cfg=dict( # MultiheadAttention + embed_dims=256, + num_heads=8, + dropout=0.0, + batch_first=True), + ffn_cfg=dict( + embed_dims=256, + feedforward_channels=2048, + num_fcs=2, + ffn_drop=0.0, + act_cfg=dict(type='ReLU', inplace=True))), + init_cfg=None), + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=2.0, + reduction='mean', + class_weight=[1.0] * num_classes + [0.1]), + loss_mask=dict( + type='CrossEntropyLoss', + use_sigmoid=True, + reduction='mean', + loss_weight=5.0), + loss_dice=dict( + type='DiceLoss', + use_sigmoid=True, + activate=True, + reduction='mean', + naive_dice=True, + eps=1.0, + loss_weight=5.0)), + panoptic_fusion_head=dict( + type='MaskFormerFusionHead', + num_things_classes=num_things_classes, + num_stuff_classes=num_stuff_classes, + loss_panoptic=None, + init_cfg=None), + train_cfg=dict( + num_points=12544, + oversample_ratio=3.0, + importance_sample_ratio=0.75, + assigner=dict( + type='HungarianAssigner', + match_costs=[ + dict(type='ClassificationCost', weight=2.0), + dict( + type='CrossEntropyLossCost', weight=5.0, use_sigmoid=True), + dict(type='DiceCost', weight=5.0, pred_act=True, eps=1.0) + ]), + sampler=dict(type='MaskPseudoSampler')), + test_cfg=dict( + panoptic_on=True, + # For now, the dataset does not support + # evaluating semantic segmentation metric. + semantic_on=False, + instance_on=True, + # max_per_image is for instance segmentation. + max_per_image=100, + iou_thr=0.8, + # In Mask2Former's panoptic postprocessing, + # it will filter mask area where score is less than 0.5 . + filter_low_score=True), + init_cfg=None) + +# dataset settings +data_root = 'data/coco/' +train_pipeline = [ + dict( + type='LoadImageFromFile', + to_float32=True, + backend_args={{_base_.backend_args}}), + dict( + type='LoadPanopticAnnotations', + with_bbox=True, + with_mask=True, + with_seg=True, + backend_args={{_base_.backend_args}}), + dict(type='RandomFlip', prob=0.5), + # large scale jittering + dict( + type='RandomResize', + scale=image_size, + ratio_range=(0.1, 2.0), + keep_ratio=True), + dict( + type='RandomCrop', + crop_size=image_size, + crop_type='absolute', + recompute_bbox=True, + allow_negative_crop=True), + dict(type='PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +val_evaluator = [ + dict( + type='CocoPanopticMetric', + ann_file=data_root + 'annotations/panoptic_val2017.json', + seg_prefix=data_root + 'annotations/panoptic_val2017/', + backend_args={{_base_.backend_args}}), + dict( + type='CocoMetric', + ann_file=data_root + 'annotations/instances_val2017.json', + metric=['bbox', 'segm'], + backend_args={{_base_.backend_args}}) +] +test_evaluator = val_evaluator + +# optimizer +embed_multi = dict(lr_mult=1.0, decay_mult=0.0) +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict( + type='AdamW', + lr=0.0001, + weight_decay=0.05, + eps=1e-8, + betas=(0.9, 0.999)), + paramwise_cfg=dict( + custom_keys={ + 'backbone': dict(lr_mult=0.1, decay_mult=1.0), + 'query_embed': embed_multi, + 'query_feat': embed_multi, + 'level_embed': embed_multi, + }, + norm_decay_mult=0.0), + clip_grad=dict(max_norm=0.01, norm_type=2)) + +# learning policy +max_iters = 368750 +param_scheduler = dict( + type='MultiStepLR', + begin=0, + end=max_iters, + by_epoch=False, + milestones=[327778, 355092], + gamma=0.1) + +# Before 365001th iteration, we do evaluation every 5000 iterations. +# After 365000th iteration, we do evaluation every 368750 iterations, +# which means that we do evaluation at the end of training. +interval = 5000 +dynamic_intervals = [(max_iters // interval * interval + 1, max_iters)] +train_cfg = dict( + type='IterBasedTrainLoop', + max_iters=max_iters, + val_interval=interval, + dynamic_intervals=dynamic_intervals) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +default_hooks = dict( + checkpoint=dict( + type='CheckpointHook', + by_epoch=False, + save_last=True, + max_keep_ckpts=3, + interval=interval)) +log_processor = dict(type='LogProcessor', window_size=50, by_epoch=False) + +# Default setting for scaling LR automatically +# - `enable` means enable scaling LR automatically +# or not by default. +# - `base_batch_size` = (8 GPUs) x (2 samples per GPU). +auto_scale_lr = dict(enable=False, base_batch_size=16) diff --git a/mmdetection/configs/mask2former/mask2former_r50_8xb2-lsj-50e_coco.py b/mmdetection/configs/mask2former/mask2former_r50_8xb2-lsj-50e_coco.py new file mode 100644 index 00000000..24a17f58 --- /dev/null +++ b/mmdetection/configs/mask2former/mask2former_r50_8xb2-lsj-50e_coco.py @@ -0,0 +1,100 @@ +_base_ = ['./mask2former_r50_8xb2-lsj-50e_coco-panoptic.py'] + +num_things_classes = 80 +num_stuff_classes = 0 +num_classes = num_things_classes + num_stuff_classes +image_size = (1024, 1024) +batch_augments = [ + dict( + type='BatchFixedSizePad', + size=image_size, + img_pad_value=0, + pad_mask=True, + mask_pad_value=0, + pad_seg=False) +] +data_preprocessor = dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32, + pad_mask=True, + mask_pad_value=0, + pad_seg=False, + batch_augments=batch_augments) +model = dict( + data_preprocessor=data_preprocessor, + panoptic_head=dict( + num_things_classes=num_things_classes, + num_stuff_classes=num_stuff_classes, + loss_cls=dict(class_weight=[1.0] * num_classes + [0.1])), + panoptic_fusion_head=dict( + num_things_classes=num_things_classes, + num_stuff_classes=num_stuff_classes), + test_cfg=dict(panoptic_on=False)) + +# dataset settings +train_pipeline = [ + dict( + type='LoadImageFromFile', + to_float32=True, + backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict(type='RandomFlip', prob=0.5), + # large scale jittering + dict( + type='RandomResize', + scale=image_size, + ratio_range=(0.1, 2.0), + resize_type='Resize', + keep_ratio=True), + dict( + type='RandomCrop', + crop_size=image_size, + crop_type='absolute', + recompute_bbox=True, + allow_negative_crop=True), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-5, 1e-5), by_mask=True), + dict(type='PackDetInputs') +] + +test_pipeline = [ + dict( + type='LoadImageFromFile', + to_float32=True, + backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + # If you don't have a gt annotation, delete the pipeline + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +dataset_type = 'CocoDataset' +data_root = 'data/coco/' + +train_dataloader = dict( + dataset=dict( + type=dataset_type, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + pipeline=train_pipeline)) +val_dataloader = dict( + dataset=dict( + type=dataset_type, + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + pipeline=test_pipeline)) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + type='CocoMetric', + ann_file=data_root + 'annotations/instances_val2017.json', + metric=['bbox', 'segm'], + format_only=False, + backend_args={{_base_.backend_args}}) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/mask2former/mask2former_swin-b-p4-w12-384-in21k_8xb2-lsj-50e_coco-panoptic.py b/mmdetection/configs/mask2former/mask2former_swin-b-p4-w12-384-in21k_8xb2-lsj-50e_coco-panoptic.py new file mode 100644 index 00000000..b275f231 --- /dev/null +++ b/mmdetection/configs/mask2former/mask2former_swin-b-p4-w12-384-in21k_8xb2-lsj-50e_coco-panoptic.py @@ -0,0 +1,5 @@ +_base_ = ['./mask2former_swin-b-p4-w12-384_8xb2-lsj-50e_coco-panoptic.py'] +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_base_patch4_window12_384_22k.pth' # noqa + +model = dict( + backbone=dict(init_cfg=dict(type='Pretrained', checkpoint=pretrained))) diff --git a/mmdetection/configs/mask2former/mask2former_swin-b-p4-w12-384_8xb2-lsj-50e_coco-panoptic.py b/mmdetection/configs/mask2former/mask2former_swin-b-p4-w12-384_8xb2-lsj-50e_coco-panoptic.py new file mode 100644 index 00000000..bd59400b --- /dev/null +++ b/mmdetection/configs/mask2former/mask2former_swin-b-p4-w12-384_8xb2-lsj-50e_coco-panoptic.py @@ -0,0 +1,42 @@ +_base_ = ['./mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco-panoptic.py'] +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_base_patch4_window12_384.pth' # noqa + +depths = [2, 2, 18, 2] +model = dict( + backbone=dict( + pretrain_img_size=384, + embed_dims=128, + depths=depths, + num_heads=[4, 8, 16, 32], + window_size=12, + init_cfg=dict(type='Pretrained', checkpoint=pretrained)), + panoptic_head=dict(in_channels=[128, 256, 512, 1024])) + +# set all layers in backbone to lr_mult=0.1 +# set all norm layers, position_embeding, +# query_embeding, level_embeding to decay_multi=0.0 +backbone_norm_multi = dict(lr_mult=0.1, decay_mult=0.0) +backbone_embed_multi = dict(lr_mult=0.1, decay_mult=0.0) +embed_multi = dict(lr_mult=1.0, decay_mult=0.0) +custom_keys = { + 'backbone': dict(lr_mult=0.1, decay_mult=1.0), + 'backbone.patch_embed.norm': backbone_norm_multi, + 'backbone.norm': backbone_norm_multi, + 'absolute_pos_embed': backbone_embed_multi, + 'relative_position_bias_table': backbone_embed_multi, + 'query_embed': embed_multi, + 'query_feat': embed_multi, + 'level_embed': embed_multi +} +custom_keys.update({ + f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi + for stage_id, num_blocks in enumerate(depths) + for block_id in range(num_blocks) +}) +custom_keys.update({ + f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi + for stage_id in range(len(depths) - 1) +}) +# optimizer +optim_wrapper = dict( + paramwise_cfg=dict(custom_keys=custom_keys, norm_decay_mult=0.0)) diff --git a/mmdetection/configs/mask2former/mask2former_swin-l-p4-w12-384-in21k_16xb1-lsj-100e_coco-panoptic.py b/mmdetection/configs/mask2former/mask2former_swin-l-p4-w12-384-in21k_16xb1-lsj-100e_coco-panoptic.py new file mode 100644 index 00000000..e203ffc9 --- /dev/null +++ b/mmdetection/configs/mask2former/mask2former_swin-l-p4-w12-384-in21k_16xb1-lsj-100e_coco-panoptic.py @@ -0,0 +1,25 @@ +_base_ = ['./mask2former_swin-b-p4-w12-384_8xb2-lsj-50e_coco-panoptic.py'] +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_large_patch4_window12_384_22k.pth' # noqa + +model = dict( + backbone=dict( + embed_dims=192, + num_heads=[6, 12, 24, 48], + init_cfg=dict(type='Pretrained', checkpoint=pretrained)), + panoptic_head=dict(num_queries=200, in_channels=[192, 384, 768, 1536])) + +train_dataloader = dict(batch_size=1, num_workers=1) + +# learning policy +max_iters = 737500 +param_scheduler = dict(end=max_iters, milestones=[655556, 710184]) + +# Before 735001th iteration, we do evaluation every 5000 iterations. +# After 735000th iteration, we do evaluation every 737500 iterations, +# which means that we do evaluation at the end of training.' +interval = 5000 +dynamic_intervals = [(max_iters // interval * interval + 1, max_iters)] +train_cfg = dict( + max_iters=max_iters, + val_interval=interval, + dynamic_intervals=dynamic_intervals) diff --git a/mmdetection/configs/mask2former/mask2former_swin-s-p4-w7-224_8xb2-lsj-50e_coco-panoptic.py b/mmdetection/configs/mask2former/mask2former_swin-s-p4-w7-224_8xb2-lsj-50e_coco-panoptic.py new file mode 100644 index 00000000..f9d081db --- /dev/null +++ b/mmdetection/configs/mask2former/mask2former_swin-s-p4-w7-224_8xb2-lsj-50e_coco-panoptic.py @@ -0,0 +1,37 @@ +_base_ = ['./mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco-panoptic.py'] +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_small_patch4_window7_224.pth' # noqa + +depths = [2, 2, 18, 2] +model = dict( + backbone=dict( + depths=depths, init_cfg=dict(type='Pretrained', + checkpoint=pretrained))) + +# set all layers in backbone to lr_mult=0.1 +# set all norm layers, position_embeding, +# query_embeding, level_embeding to decay_multi=0.0 +backbone_norm_multi = dict(lr_mult=0.1, decay_mult=0.0) +backbone_embed_multi = dict(lr_mult=0.1, decay_mult=0.0) +embed_multi = dict(lr_mult=1.0, decay_mult=0.0) +custom_keys = { + 'backbone': dict(lr_mult=0.1, decay_mult=1.0), + 'backbone.patch_embed.norm': backbone_norm_multi, + 'backbone.norm': backbone_norm_multi, + 'absolute_pos_embed': backbone_embed_multi, + 'relative_position_bias_table': backbone_embed_multi, + 'query_embed': embed_multi, + 'query_feat': embed_multi, + 'level_embed': embed_multi +} +custom_keys.update({ + f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi + for stage_id, num_blocks in enumerate(depths) + for block_id in range(num_blocks) +}) +custom_keys.update({ + f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi + for stage_id in range(len(depths) - 1) +}) +# optimizer +optim_wrapper = dict( + paramwise_cfg=dict(custom_keys=custom_keys, norm_decay_mult=0.0)) diff --git a/mmdetection/configs/mask2former/mask2former_swin-s-p4-w7-224_8xb2-lsj-50e_coco.py b/mmdetection/configs/mask2former/mask2former_swin-s-p4-w7-224_8xb2-lsj-50e_coco.py new file mode 100644 index 00000000..69d5e8c6 --- /dev/null +++ b/mmdetection/configs/mask2former/mask2former_swin-s-p4-w7-224_8xb2-lsj-50e_coco.py @@ -0,0 +1,37 @@ +_base_ = ['./mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco.py'] +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_small_patch4_window7_224.pth' # noqa + +depths = [2, 2, 18, 2] +model = dict( + backbone=dict( + depths=depths, init_cfg=dict(type='Pretrained', + checkpoint=pretrained))) + +# set all layers in backbone to lr_mult=0.1 +# set all norm layers, position_embeding, +# query_embeding, level_embeding to decay_multi=0.0 +backbone_norm_multi = dict(lr_mult=0.1, decay_mult=0.0) +backbone_embed_multi = dict(lr_mult=0.1, decay_mult=0.0) +embed_multi = dict(lr_mult=1.0, decay_mult=0.0) +custom_keys = { + 'backbone': dict(lr_mult=0.1, decay_mult=1.0), + 'backbone.patch_embed.norm': backbone_norm_multi, + 'backbone.norm': backbone_norm_multi, + 'absolute_pos_embed': backbone_embed_multi, + 'relative_position_bias_table': backbone_embed_multi, + 'query_embed': embed_multi, + 'query_feat': embed_multi, + 'level_embed': embed_multi +} +custom_keys.update({ + f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi + for stage_id, num_blocks in enumerate(depths) + for block_id in range(num_blocks) +}) +custom_keys.update({ + f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi + for stage_id in range(len(depths) - 1) +}) +# optimizer +optim_wrapper = dict( + paramwise_cfg=dict(custom_keys=custom_keys, norm_decay_mult=0.0)) diff --git a/mmdetection/configs/mask2former/mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco-panoptic.py b/mmdetection/configs/mask2former/mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco-panoptic.py new file mode 100644 index 00000000..1c00d7a6 --- /dev/null +++ b/mmdetection/configs/mask2former/mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco-panoptic.py @@ -0,0 +1,58 @@ +_base_ = ['./mask2former_r50_8xb2-lsj-50e_coco-panoptic.py'] +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_tiny_patch4_window7_224.pth' # noqa + +depths = [2, 2, 6, 2] +model = dict( + type='Mask2Former', + backbone=dict( + _delete_=True, + type='SwinTransformer', + embed_dims=96, + depths=depths, + num_heads=[3, 6, 12, 24], + window_size=7, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.3, + patch_norm=True, + out_indices=(0, 1, 2, 3), + with_cp=False, + convert_weights=True, + frozen_stages=-1, + init_cfg=dict(type='Pretrained', checkpoint=pretrained)), + panoptic_head=dict( + type='Mask2FormerHead', in_channels=[96, 192, 384, 768]), + init_cfg=None) + +# set all layers in backbone to lr_mult=0.1 +# set all norm layers, position_embeding, +# query_embeding, level_embeding to decay_multi=0.0 +backbone_norm_multi = dict(lr_mult=0.1, decay_mult=0.0) +backbone_embed_multi = dict(lr_mult=0.1, decay_mult=0.0) +embed_multi = dict(lr_mult=1.0, decay_mult=0.0) +custom_keys = { + 'backbone': dict(lr_mult=0.1, decay_mult=1.0), + 'backbone.patch_embed.norm': backbone_norm_multi, + 'backbone.norm': backbone_norm_multi, + 'absolute_pos_embed': backbone_embed_multi, + 'relative_position_bias_table': backbone_embed_multi, + 'query_embed': embed_multi, + 'query_feat': embed_multi, + 'level_embed': embed_multi +} +custom_keys.update({ + f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi + for stage_id, num_blocks in enumerate(depths) + for block_id in range(num_blocks) +}) +custom_keys.update({ + f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi + for stage_id in range(len(depths) - 1) +}) + +# optimizer +optim_wrapper = dict( + paramwise_cfg=dict(custom_keys=custom_keys, norm_decay_mult=0.0)) diff --git a/mmdetection/configs/mask2former/mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco.py b/mmdetection/configs/mask2former/mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco.py new file mode 100644 index 00000000..5bb9c218 --- /dev/null +++ b/mmdetection/configs/mask2former/mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco.py @@ -0,0 +1,56 @@ +_base_ = ['./mask2former_r50_8xb2-lsj-50e_coco.py'] +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_tiny_patch4_window7_224.pth' # noqa +depths = [2, 2, 6, 2] +model = dict( + type='Mask2Former', + backbone=dict( + _delete_=True, + type='SwinTransformer', + embed_dims=96, + depths=depths, + num_heads=[3, 6, 12, 24], + window_size=7, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.3, + patch_norm=True, + out_indices=(0, 1, 2, 3), + with_cp=False, + convert_weights=True, + frozen_stages=-1, + init_cfg=dict(type='Pretrained', checkpoint=pretrained)), + panoptic_head=dict( + type='Mask2FormerHead', in_channels=[96, 192, 384, 768]), + init_cfg=None) + +# set all layers in backbone to lr_mult=0.1 +# set all norm layers, position_embeding, +# query_embeding, level_embeding to decay_multi=0.0 +backbone_norm_multi = dict(lr_mult=0.1, decay_mult=0.0) +backbone_embed_multi = dict(lr_mult=0.1, decay_mult=0.0) +embed_multi = dict(lr_mult=1.0, decay_mult=0.0) +custom_keys = { + 'backbone': dict(lr_mult=0.1, decay_mult=1.0), + 'backbone.patch_embed.norm': backbone_norm_multi, + 'backbone.norm': backbone_norm_multi, + 'absolute_pos_embed': backbone_embed_multi, + 'relative_position_bias_table': backbone_embed_multi, + 'query_embed': embed_multi, + 'query_feat': embed_multi, + 'level_embed': embed_multi +} +custom_keys.update({ + f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi + for stage_id, num_blocks in enumerate(depths) + for block_id in range(num_blocks) +}) +custom_keys.update({ + f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi + for stage_id in range(len(depths) - 1) +}) +# optimizer +optim_wrapper = dict( + paramwise_cfg=dict(custom_keys=custom_keys, norm_decay_mult=0.0)) diff --git a/mmdetection/configs/mask2former/metafile.yml b/mmdetection/configs/mask2former/metafile.yml new file mode 100644 index 00000000..33212392 --- /dev/null +++ b/mmdetection/configs/mask2former/metafile.yml @@ -0,0 +1,223 @@ +Collections: + - Name: Mask2Former + Metadata: + Training Data: COCO + Training Techniques: + - AdamW + - Weight Decay + Training Resources: 8x A100 GPUs + Architecture: + - Mask2Former + Paper: + URL: https://arxiv.org/pdf/2112.01527 + Title: 'Masked-attention Mask Transformer for Universal Image Segmentation' + README: configs/mask2former/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.23.0/mmdet/models/detectors/mask2former.py#L7 + Version: v2.23.0 + +Models: +- Name: mask2former_swin-s-p4-w7-224_8xb2-lsj-50e_coco-panoptic + In Collection: Mask2Former + Config: configs/mask2former/mask2former_swin-s-p4-w7-224_8xb2-lsj-50e_coco-panoptic.py + Metadata: + Training Memory (GB): 19.1 + Iterations: 368750 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 47.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 44.5 + - Task: Panoptic Segmentation + Dataset: COCO + Metrics: + PQ: 54.5 + Weights: https://download.openmmlab.com/mmdetection/v3.0/mask2former/mask2former_swin-s-p4-w7-224_8xb2-lsj-50e_coco-panoptic/mask2former_swin-s-p4-w7-224_8xb2-lsj-50e_coco-panoptic_20220329_225200-4a16ded7.pth +- Name: mask2former_r101_8xb2-lsj-50e_coco + In Collection: Mask2Former + Config: configs/mask2former/mask2former_r101_8xb2-lsj-50e_coco.py + Metadata: + Training Memory (GB): 15.5 + Iterations: 368750 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.7 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 44.0 + Weights: https://download.openmmlab.com/mmdetection/v3.0/mask2former/mask2former_r101_8xb2-lsj-50e_coco/mask2former_r101_8xb2-lsj-50e_coco_20220426_100250-ecf181e2.pth +- Name: mask2former_r101_8xb2-lsj-50e_coco-panoptic + In Collection: Mask2Former + Config: configs/mask2former/mask2former_r101_8xb2-lsj-50e_coco-panoptic.py + Metadata: + Training Memory (GB): 16.1 + Iterations: 368750 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.3 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 42.4 + - Task: Panoptic Segmentation + Dataset: COCO + Metrics: + PQ: 52.4 + Weights: https://download.openmmlab.com/mmdetection/v3.0/mask2former/mask2former_r101_8xb2-lsj-50e_coco-panoptic/mask2former_r101_8xb2-lsj-50e_coco-panoptic_20220329_225104-c74d4d71.pth +- Name: mask2former_r50_8xb2-lsj-50e_coco-panoptic + In Collection: Mask2Former + Config: configs/mask2former/mask2former_r50_8xb2-lsj-50e_coco-panoptic.py + Metadata: + Training Memory (GB): 13.9 + Iterations: 368750 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.5 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 41.8 + - Task: Panoptic Segmentation + Dataset: COCO + Metrics: + PQ: 52.0 + Weights: https://download.openmmlab.com/mmdetection/v3.0/mask2former/mask2former_r50_8xb2-lsj-50e_coco-panoptic/mask2former_r50_8xb2-lsj-50e_coco-panoptic_20230118_125535-54df384a.pth +- Name: mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco-panoptic + In Collection: Mask2Former + Config: configs/mask2former/mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco-panoptic.py + Metadata: + Training Memory (GB): 15.9 + Iterations: 368750 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.3 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 43.4 + - Task: Panoptic Segmentation + Dataset: COCO + Metrics: + PQ: 53.4 + Weights: https://download.openmmlab.com/mmdetection/v3.0/mask2former/mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco-panoptic/mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco-panoptic_20220326_224553-3ec9e0ae.pth +- Name: mask2former_r50_8xb2-lsj-50e_coco + In Collection: Mask2Former + Config: configs/mask2former/mask2former_r50_8xb2-lsj-50e_coco.py + Metadata: + Training Memory (GB): 13.7 + Iterations: 368750 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.7 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 42.9 + Weights: https://download.openmmlab.com/mmdetection/v3.0/mask2former/mask2former_r50_8xb2-lsj-50e_coco/mask2former_r50_8xb2-lsj-50e_coco_20220506_191028-41b088b6.pth +- Name: mask2former_swin-l-p4-w12-384-in21k_16xb1-lsj-100e_coco-panoptic + In Collection: Mask2Former + Config: configs/mask2former/mask2former_swin-l-p4-w12-384-in21k_16xb1-lsj-100e_coco-panoptic.py + Metadata: + Training Memory (GB): 21.1 + Iterations: 737500 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 52.2 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 48.5 + - Task: Panoptic Segmentation + Dataset: COCO + Metrics: + PQ: 57.6 + Weights: https://download.openmmlab.com/mmdetection/v3.0/mask2former/mask2former_swin-l-p4-w12-384-in21k_16xb1-lsj-100e_coco-panoptic/mask2former_swin-l-p4-w12-384-in21k_16xb1-lsj-100e_coco-panoptic_20220407_104949-82f8d28d.pth +- Name: mask2former_swin-b-p4-w12-384-in21k_8xb2-lsj-50e_coco-panoptic + In Collection: Mask2Former + Config: configs/mask2former/mask2former_swin-b-p4-w12-384-in21k_8xb2-lsj-50e_coco-panoptic.py + Metadata: + Training Memory (GB): 25.8 + Iterations: 368750 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 50.0 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 46.3 + - Task: Panoptic Segmentation + Dataset: COCO + Metrics: + PQ: 56.3 + Weights: https://download.openmmlab.com/mmdetection/v3.0/mask2former/mask2former_swin-b-p4-w12-384-in21k_8xb2-lsj-50e_coco-panoptic/mask2former_swin-b-p4-w12-384-in21k_8xb2-lsj-50e_coco-panoptic_20220329_230021-05ec7315.pth +- Name: mask2former_swin-b-p4-w12-384_8xb2-lsj-50e_coco-panoptic + In Collection: Mask2Former + Config: configs/mask2former/mask2former_swin-b-p4-w12-384_8xb2-lsj-50e_coco-panoptic.py + Metadata: + Training Memory (GB): 26.0 + Iterations: 368750 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 48.2 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 44.9 + - Task: Panoptic Segmentation + Dataset: COCO + Metrics: + PQ: 55.1 + Weights: https://download.openmmlab.com/mmdetection/v3.0/mask2former/mask2former_swin-b-p4-w12-384_8xb2-lsj-50e_coco-panoptic/mask2former_swin-b-p4-w12-384_8xb2-lsj-50e_coco-panoptic_20220331_002244-8a651d82.pth +- Name: mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco + In Collection: Mask2Former + Config: configs/mask2former/mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco.py + Metadata: + Training Memory (GB): 15.3 + Iterations: 368750 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 47.7 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 44.7 + Weights: https://download.openmmlab.com/mmdetection/v3.0/mask2former/mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco/mask2former_swin-t-p4-w7-224_8xb2-lsj-50e_coco_20220508_091649-01b0f990.pth +- Name: mask2former_swin-s-p4-w7-224_8xb2-lsj-50e_coco + In Collection: Mask2Former + Config: configs/mask2former/mask2former_swin-s-p4-w7-224_8xb2-lsj-50e_coco.py + Metadata: + Training Memory (GB): 18.8 + Iterations: 368750 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 49.3 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 46.1 + Weights: https://download.openmmlab.com/mmdetection/v3.0/mask2former/mask2former_swin-s-p4-w7-224_8xb2-lsj-50e_coco/mask2former_swin-s-p4-w7-224_8xb2-lsj-50e_coco_20220504_001756-c9d0c4f2.pth diff --git a/mmdetection/configs/mask2former_vis/README.md b/mmdetection/configs/mask2former_vis/README.md new file mode 100644 index 00000000..69965729 --- /dev/null +++ b/mmdetection/configs/mask2former_vis/README.md @@ -0,0 +1,81 @@ +# Mask2Former for Video Instance Segmentation + +## Abstract + + + +We find Mask2Former also achieves state-of-the-art performance on video instance segmentation without modifying the architecture, the loss or even the training pipeline. In this report, we show universal image segmentation architectures trivially generalize to video segmentation by directly predicting 3D segmentation volumes. Specifically, Mask2Former sets a new state-of-the-art of 60.4 AP on YouTubeVIS-2019 and 52.6 AP on YouTubeVIS-2021. We believe Mask2Former is also capable of handling video semantic and panoptic segmentation, given its versatility in image segmentation. We hope this will make state-of-theart video segmentation research more accessible and bring more attention to designing universal image and video segmentation architectures. + + + +
    + +
    + +## Citation + + + +```latex +@inproceedings{cheng2021mask2former, + title={Masked-attention Mask Transformer for Universal Image Segmentation}, + author={Bowen Cheng and Ishan Misra and Alexander G. Schwing and Alexander Kirillov and Rohit Girdhar}, + journal={CVPR}, + year={2022} +} +``` + +## Results and models of Mask2Former on YouTube-VIS 2021 validation dataset + +Note: Codalab has closed the evaluation portal of `YouTube-VIS 2019`, so we do not provide the results of `YouTube-VIS 2019` at present. If you want to evaluate the results of `YouTube-VIS 2021`, at present, you can submit the result to the evaluation portal of `YouTube-VIS 2022`. The value of `AP_S` is the result of `YouTube-VIS 2021`. + +| Method | Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | AP | Config | Download | +| :----------------------: | :------: | :-----: | :-----: | :------: | :------------: | :--: | :---------------------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| Mask2Former | R-50 | pytorch | 8e | 6.0 | - | 41.3 | [config](mask2former_r50_8xb2-8e_youtubevis2021.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/mask2former_vis/mask2former_r50_8xb2-8e_youtubevis2021/mask2former_r50_8xb2-8e_youtubevis2021_20230426_131833-5d215283.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/mask2former_vis/mask2former_r50_8xb2-8e_youtubevis2021/mask2former_r50_8xb2-8e_youtubevis2021_20230426_131833.json) | +| Mask2Former | R-101 | pytorch | 8e | 7.5 | - | 42.3 | [config](mask2former_r101_8xb2-8e_youtubevis2021.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/mask2former_vis/mask2former_r101_8xb2-8e_youtubevis2021/mask2former_r101_8xb2-8e_youtubevis2021_20220823_092747-8077d115.pth) \| [log](https://download.openmmlab.com/mmtracking/vis/mask2former/mask2former_r101_8xb2-8e_youtubevis2021_20220823_092747.json) | +| Mask2Former(200 queries) | Swin-L | pytorch | 8e | 18.5 | - | 52.3 | [config](mask2former_swin-l-p4-w12-384-in21k_8xb2-8e_youtubevis2021.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/mask2former_vis/mask2former_swin-l-p4-w12-384-in21k_8xb2-8e_youtubevis2021/mask2former_swin-l-p4-w12-384-in21k_8xb2-8e_youtubevis2021_20220907_124752-48252603.pth) \| [log](https://download.openmmlab.com/mmtracking/vis/mask2former/mask2former_swin-l-p4-w12-384-in21k_8xb2-8e_youtubevis2021_20220907_124752.json) | + +## Get started + +### 1. Development Environment Setup + +Tracking Development Environment Setup can refer to this [document](../../docs/en/get_started.md). + +### 2. Dataset Prepare + +Tracking Dataset Prepare can refer to this [document](../../docs/en/user_guides/tracking_dataset_prepare.md). + +### 3. Training + +Due to the influence of parameters such as learning rate in default configuration file, we recommend using 8 GPUs for training in order to reproduce accuracy. You can use the following command to start the training. + +```shell +# Training Mask2Former on YouTube-VIS-2021 dataset with following command. +# The number after config file represents the number of GPUs used. Here we use 8 GPUs. +bash tools/dist_train.sh configs/mask2former_vis/mask2former_r50_8xb2-8e_youtubevis2021.py 8 +``` + +If you want to know about more detailed usage of `train.py/dist_train.sh/slurm_train.sh`, +please refer to this [document](../../docs/en/user_guides/tracking_train_test.md). + +### 4. Testing and evaluation + +If you want to get the results of the [YouTube-VOS](https://youtube-vos.org/dataset/vis/) val/test set, please use the following command to generate result files that can be used for submission. It will be stored in `./youtube_vis_results.submission_file.zip`, you can modify the saved path in `test_evaluator` of the config. + +```shell +# The number after config file represents the number of GPUs used. +bash tools/dist_test_tracking.sh configs/mask2former_vis/mask2former_r50_8xb2-8e_youtubevis2021.py --checkpoint ${CHECKPOINT_PATH} +``` + +If you want to know about more detailed usage of `test_tracking.py/dist_test_tracking.sh/slurm_test_tracking.sh`, +please refer to this [document](../../docs/en/user_guides/tracking_train_test.md). + +### 5.Inference + +Use a single GPU to predict a video and save it as a video. + +```shell +python demo/mot_demo.py demo/demo_mot.mp4 configs/mask2former_vis/mask2former_r50_8xb2-8e_youtubevis2021.py --checkpoint {CHECKPOINT_PATH} --out vis.mp4 +``` + +If you want to know about more detailed usage of `mot_demo.py`, please refer to this [document](../../docs/en/user_guides/tracking_inference.md). diff --git a/mmdetection/configs/mask2former_vis/mask2former_r101_8xb2-8e_youtubevis2019.py b/mmdetection/configs/mask2former_vis/mask2former_r101_8xb2-8e_youtubevis2019.py new file mode 100644 index 00000000..3ba4aea8 --- /dev/null +++ b/mmdetection/configs/mask2former_vis/mask2former_r101_8xb2-8e_youtubevis2019.py @@ -0,0 +1,12 @@ +_base_ = './mask2former_r50_8xb2-8e_youtubevis2019.py' + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101')), + init_cfg=dict( + type='Pretrained', + checkpoint='https://download.openmmlab.com/mmdetection/v3.0/' + 'mask2former/mask2former_r101_8xb2-lsj-50e_coco/' + 'mask2former_r101_8xb2-lsj-50e_coco_20220426_100250-ecf181e2.pth')) diff --git a/mmdetection/configs/mask2former_vis/mask2former_r101_8xb2-8e_youtubevis2021.py b/mmdetection/configs/mask2former_vis/mask2former_r101_8xb2-8e_youtubevis2021.py new file mode 100644 index 00000000..95f9ceeb --- /dev/null +++ b/mmdetection/configs/mask2former_vis/mask2former_r101_8xb2-8e_youtubevis2021.py @@ -0,0 +1,12 @@ +_base_ = './mask2former_r50_8xb2-8e_youtubevis2021.py' + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101')), + init_cfg=dict( + type='Pretrained', + checkpoint='https://download.openmmlab.com/mmdetection/v3.0/' + 'mask2former/mask2former_r101_8xb2-lsj-50e_coco/' + 'mask2former_r101_8xb2-lsj-50e_coco_20220426_100250-ecf181e2.pth')) diff --git a/mmdetection/configs/mask2former_vis/mask2former_r50_8xb2-8e_youtubevis2019.py b/mmdetection/configs/mask2former_vis/mask2former_r50_8xb2-8e_youtubevis2019.py new file mode 100644 index 00000000..8dc03bf9 --- /dev/null +++ b/mmdetection/configs/mask2former_vis/mask2former_r50_8xb2-8e_youtubevis2019.py @@ -0,0 +1,174 @@ +_base_ = ['../_base_/datasets/youtube_vis.py', '../_base_/default_runtime.py'] + +num_classes = 40 +num_frames = 2 +model = dict( + type='Mask2FormerVideo', + data_preprocessor=dict( + type='TrackDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_mask=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=-1, + norm_cfg=dict(type='BN', requires_grad=False), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + track_head=dict( + type='Mask2FormerTrackHead', + in_channels=[256, 512, 1024, 2048], # pass to pixel_decoder inside + strides=[4, 8, 16, 32], + feat_channels=256, + out_channels=256, + num_classes=num_classes, + num_queries=100, + num_frames=num_frames, + num_transformer_feat_level=3, + pixel_decoder=dict( + type='MSDeformAttnPixelDecoder', + num_outs=3, + norm_cfg=dict(type='GN', num_groups=32), + act_cfg=dict(type='ReLU'), + encoder=dict( # DeformableDetrTransformerEncoder + num_layers=6, + layer_cfg=dict( # DeformableDetrTransformerEncoderLayer + self_attn_cfg=dict( # MultiScaleDeformableAttention + embed_dims=256, + num_heads=8, + num_levels=3, + num_points=4, + im2col_step=128, + dropout=0.0, + batch_first=True), + ffn_cfg=dict( + embed_dims=256, + feedforward_channels=1024, + num_fcs=2, + ffn_drop=0.0, + act_cfg=dict(type='ReLU', inplace=True)))), + positional_encoding=dict(num_feats=128, normalize=True)), + enforce_decoder_input_project=False, + positional_encoding=dict( + type='SinePositionalEncoding3D', num_feats=128, normalize=True), + transformer_decoder=dict( # Mask2FormerTransformerDecoder + return_intermediate=True, + num_layers=9, + layer_cfg=dict( # Mask2FormerTransformerDecoderLayer + self_attn_cfg=dict( # MultiheadAttention + embed_dims=256, + num_heads=8, + dropout=0.0, + batch_first=True), + cross_attn_cfg=dict( # MultiheadAttention + embed_dims=256, + num_heads=8, + dropout=0.0, + batch_first=True), + ffn_cfg=dict( + embed_dims=256, + feedforward_channels=2048, + num_fcs=2, + ffn_drop=0.0, + act_cfg=dict(type='ReLU', inplace=True))), + init_cfg=None), + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=2.0, + reduction='mean', + class_weight=[1.0] * num_classes + [0.1]), + loss_mask=dict( + type='CrossEntropyLoss', + use_sigmoid=True, + reduction='mean', + loss_weight=5.0), + loss_dice=dict( + type='DiceLoss', + use_sigmoid=True, + activate=True, + reduction='mean', + naive_dice=True, + eps=1.0, + loss_weight=5.0), + train_cfg=dict( + num_points=12544, + oversample_ratio=3.0, + importance_sample_ratio=0.75, + assigner=dict( + type='HungarianAssigner', + match_costs=[ + dict(type='ClassificationCost', weight=2.0), + dict( + type='CrossEntropyLossCost', + weight=5.0, + use_sigmoid=True), + dict(type='DiceCost', weight=5.0, pred_act=True, eps=1.0) + ]), + sampler=dict(type='MaskPseudoSampler'))), + init_cfg=dict( + type='Pretrained', + checkpoint='https://download.openmmlab.com/mmdetection/v3.0/' + 'mask2former/mask2former_r50_8xb2-lsj-50e_coco/' + 'mask2former_r50_8xb2-lsj-50e_coco_20220506_191028-41b088b6.pth')) + +# optimizer +embed_multi = dict(lr_mult=1.0, decay_mult=0.0) +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict( + type='AdamW', + lr=0.0001, + weight_decay=0.05, + eps=1e-8, + betas=(0.9, 0.999)), + paramwise_cfg=dict( + custom_keys={ + 'backbone': dict(lr_mult=0.1, decay_mult=1.0), + 'query_embed': embed_multi, + 'query_feat': embed_multi, + 'level_embed': embed_multi, + }, + norm_decay_mult=0.0), + clip_grad=dict(max_norm=0.01, norm_type=2)) + +# learning policy +max_iters = 6000 +param_scheduler = dict( + type='MultiStepLR', + begin=0, + end=max_iters, + by_epoch=False, + milestones=[ + 4000, + ], + gamma=0.1) +# runtime settings +train_cfg = dict( + type='IterBasedTrainLoop', max_iters=max_iters, val_interval=6001) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +vis_backends = [dict(type='LocalVisBackend')] +visualizer = dict( + type='TrackLocalVisualizer', vis_backends=vis_backends, name='visualizer') + +default_hooks = dict( + checkpoint=dict( + type='CheckpointHook', by_epoch=False, save_last=True, interval=2000), + visualization=dict(type='TrackVisualizationHook', draw=False)) +log_processor = dict(type='LogProcessor', window_size=50, by_epoch=False) + +# evaluator +val_evaluator = dict( + type='YouTubeVISMetric', + metric='youtube_vis_ap', + outfile_prefix='./youtube_vis_results', + format_only=True) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/mask2former_vis/mask2former_r50_8xb2-8e_youtubevis2021.py b/mmdetection/configs/mask2former_vis/mask2former_r50_8xb2-8e_youtubevis2021.py new file mode 100644 index 00000000..158fe52d --- /dev/null +++ b/mmdetection/configs/mask2former_vis/mask2former_r50_8xb2-8e_youtubevis2021.py @@ -0,0 +1,37 @@ +_base_ = './mask2former_r50_8xb2-8e_youtubevis2019.py' + +dataset_type = 'YouTubeVISDataset' +data_root = 'data/youtube_vis_2021/' +dataset_version = data_root[-5:-1] # 2019 or 2021 + +train_dataloader = dict( + dataset=dict( + data_root=data_root, + dataset_version=dataset_version, + ann_file='annotations/youtube_vis_2021_train.json')) + +val_dataloader = dict( + dataset=dict( + data_root=data_root, + dataset_version=dataset_version, + ann_file='annotations/youtube_vis_2021_valid.json')) +test_dataloader = val_dataloader + +# learning policy +max_iters = 8000 +param_scheduler = dict( + type='MultiStepLR', + begin=0, + end=max_iters, + by_epoch=False, + milestones=[ + 5500, + ], + gamma=0.1) +# runtime settings +train_cfg = dict( + type='IterBasedTrainLoop', max_iters=max_iters, val_interval=8001) + +default_hooks = dict( + checkpoint=dict( + type='CheckpointHook', by_epoch=False, save_last=True, interval=500)) diff --git a/mmdetection/configs/mask2former_vis/mask2former_swin-l-p4-w12-384-in21k_8xb2-8e_youtubevis2021.py b/mmdetection/configs/mask2former_vis/mask2former_swin-l-p4-w12-384-in21k_8xb2-8e_youtubevis2021.py new file mode 100644 index 00000000..94dcccf4 --- /dev/null +++ b/mmdetection/configs/mask2former_vis/mask2former_swin-l-p4-w12-384-in21k_8xb2-8e_youtubevis2021.py @@ -0,0 +1,64 @@ +_base_ = ['./mask2former_r50_8xb2-8e_youtubevis2021.py'] +depths = [2, 2, 18, 2] +model = dict( + type='Mask2FormerVideo', + backbone=dict( + _delete_=True, + type='SwinTransformer', + pretrain_img_size=384, + embed_dims=192, + depths=depths, + num_heads=[6, 12, 24, 48], + window_size=12, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.3, + patch_norm=True, + out_indices=(0, 1, 2, 3), + with_cp=False, + convert_weights=True, + frozen_stages=-1, + init_cfg=None), + track_head=dict( + type='Mask2FormerTrackHead', + in_channels=[192, 384, 768, 1536], + num_queries=200), + init_cfg=dict( + type='Pretrained', + checkpoint= # noqa: E251 + 'https://download.openmmlab.com/mmdetection/v3.0/mask2former/' + 'mask2former_swin-l-p4-w12-384-in21k_16xb1-lsj-100e_coco-panoptic/' + 'mask2former_swin-l-p4-w12-384-in21k_16xb1-lsj-100e_coco-panoptic_' + '20220407_104949-82f8d28d.pth')) + +# set all layers in backbone to lr_mult=0.1 +# set all norm layers, position_embeding, +# query_embeding, level_embeding to decay_multi=0.0 +backbone_norm_multi = dict(lr_mult=0.1, decay_mult=0.0) +backbone_embed_multi = dict(lr_mult=0.1, decay_mult=0.0) +embed_multi = dict(lr_mult=1.0, decay_mult=0.0) +custom_keys = { + 'backbone': dict(lr_mult=0.1, decay_mult=1.0), + 'backbone.patch_embed.norm': backbone_norm_multi, + 'backbone.norm': backbone_norm_multi, + 'absolute_pos_embed': backbone_embed_multi, + 'relative_position_bias_table': backbone_embed_multi, + 'query_embed': embed_multi, + 'query_feat': embed_multi, + 'level_embed': embed_multi +} +custom_keys.update({ + f'backbone.stages.{stage_id}.blocks.{block_id}.norm': backbone_norm_multi + for stage_id, num_blocks in enumerate(depths) + for block_id in range(num_blocks) +}) +custom_keys.update({ + f'backbone.stages.{stage_id}.downsample.norm': backbone_norm_multi + for stage_id in range(len(depths) - 1) +}) +# optimizer +optim_wrapper = dict( + paramwise_cfg=dict(custom_keys=custom_keys, norm_decay_mult=0.0)) diff --git a/mmdetection/configs/mask2former_vis/metafile.yml b/mmdetection/configs/mask2former_vis/metafile.yml new file mode 100644 index 00000000..f5f4bd7c --- /dev/null +++ b/mmdetection/configs/mask2former_vis/metafile.yml @@ -0,0 +1,53 @@ +Collections: + - Name: Mask2Former + Metadata: + Training Techniques: + - AdamW + - Weight Decay + Training Resources: 8x A100 GPUs + Architecture: + - Mask2Former + Paper: + URL: https://arxiv.org/pdf/2112.10764.pdf + Title: Mask2Former for Video Instance Segmentation + README: configs/mask2former/README.md + +Models: + - Name: mask2former_r50_8xb2-8e_youtubevis2021 + In Collection: Mask2Former + Config: configs/mask2former_vis/mask2former_r50_8xb2-8e_youtubevis2021.py + Metadata: + Training Data: YouTube-VIS 2021 + Training Memory (GB): 6.0 + Results: + - Task: Video Instance Segmentation + Dataset: YouTube-VIS 2021 + Metrics: + AP: 41.3 + Weights: https://download.openmmlab.com/mmdetection/v3.0/mask2former_vis/mask2former_r50_8xb2-8e_youtubevis2021/mask2former_r50_8xb2-8e_youtubevis2021_20230426_131833-5d215283.pth + + - Name: mask2former_r101_8xb2-8e_youtubevis2021 + In Collection: Mask2Former + Config: configs/mask2former_vis/mask2former_r101_8xb2-8e_youtubevis2021.py + Metadata: + Training Data: YouTube-VIS 2021 + Training Memory (GB): 7.5 + Results: + - Task: Video Instance Segmentation + Dataset: YouTube-VIS 2021 + Metrics: + AP: 42.3 + Weights: https://download.openmmlab.com/mmdetection/v3.0/mask2former_vis/mask2former_r101_8xb2-8e_youtubevis2021/mask2former_r101_8xb2-8e_youtubevis2021_20220823_092747-8077d115.pth + + - Name: mask2former_swin-l-p4-w12-384-in21k_8xb2-8e_youtubevis2021.py + In Collection: Mask2Former + Config: configs/mask2former_vis/mask2former_swin-l-p4-w12-384-in21k_8xb2-8e_youtubevis2021.py + Metadata: + Training Data: YouTube-VIS 2021 + Training Memory (GB): 18.5 + Results: + - Task: Video Instance Segmentation + Dataset: YouTube-VIS 2021 + Metrics: + AP: 52.3 + Weights: https://download.openmmlab.com/mmdetection/v3.0/mask2former_vis/mask2former_swin-l-p4-w12-384-in21k_8xb2-8e_youtubevis2021/mask2former_swin-l-p4-w12-384-in21k_8xb2-8e_youtubevis2021_20220907_124752-48252603.pth diff --git a/mmdetection/configs/mask_rcnn/README.md b/mmdetection/configs/mask_rcnn/README.md new file mode 100644 index 00000000..afc5c3c9 --- /dev/null +++ b/mmdetection/configs/mask_rcnn/README.md @@ -0,0 +1,59 @@ +# Mask R-CNN + +> [Mask R-CNN](https://arxiv.org/abs/1703.06870) + + + +## Abstract + +We present a conceptually simple, flexible, and general framework for object instance segmentation. Our approach efficiently detects objects in an image while simultaneously generating a high-quality segmentation mask for each instance. The method, called Mask R-CNN, extends Faster R-CNN by adding a branch for predicting an object mask in parallel with the existing branch for bounding box recognition. Mask R-CNN is simple to train and adds only a small overhead to Faster R-CNN, running at 5 fps. Moreover, Mask R-CNN is easy to generalize to other tasks, e.g., allowing us to estimate human poses in the same framework. We show top results in all three tracks of the COCO suite of challenges, including instance segmentation, bounding-box object detection, and person keypoint detection. Without bells and whistles, Mask R-CNN outperforms all existing, single-model entries on every task, including the COCO 2016 challenge winners. We hope our simple and effective approach will serve as a solid baseline and help ease future research in instance-level recognition. + +
    + +
    + +## Results and Models + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :-------------: | :-----: | :-----: | :------: | :------------: | :----: | :-----: | :---------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | caffe | 1x | 4.3 | | 38.0 | 34.4 | [config](./mask-rcnn_r50-caffe_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_caffe_fpn_1x_coco/mask_rcnn_r50_caffe_fpn_1x_coco_bbox_mAP-0.38__segm_mAP-0.344_20200504_231812-0ebd1859.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_caffe_fpn_1x_coco/mask_rcnn_r50_caffe_fpn_1x_coco_20200504_231812.log.json) | +| R-50-FPN | pytorch | 1x | 4.4 | 16.1 | 38.2 | 34.7 | [config](./mask-rcnn_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_fpn_1x_coco/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_fpn_1x_coco/mask_rcnn_r50_fpn_1x_coco_20200205_050542.log.json) | +| R-50-FPN (FP16) | pytorch | 1x | 3.6 | 24.1 | 38.1 | 34.7 | [config](./mask-rcnn_r50_fpn_amp-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/fp16/mask_rcnn_r50_fpn_fp16_1x_coco/mask_rcnn_r50_fpn_fp16_1x_coco_20200205-59faf7e4.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/fp16/mask_rcnn_r50_fpn_fp16_1x_coco/mask_rcnn_r50_fpn_fp16_1x_coco_20200205_130539.log.json) | +| R-50-FPN | pytorch | 2x | - | - | 39.2 | 35.4 | [config](./mask-rcnn_r50_fpn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_fpn_2x_coco/mask_rcnn_r50_fpn_2x_coco_bbox_mAP-0.392__segm_mAP-0.354_20200505_003907-3e542a40.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_fpn_2x_coco/mask_rcnn_r50_fpn_2x_coco_20200505_003907.log.json) | +| R-101-FPN | caffe | 1x | | | 40.4 | 36.4 | [config](./mask-rcnn_r101-caffe_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r101_caffe_fpn_1x_coco/mask_rcnn_r101_caffe_fpn_1x_coco_20200601_095758-805e06c1.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r101_caffe_fpn_1x_coco/mask_rcnn_r101_caffe_fpn_1x_coco_20200601_095758.log.json) | +| R-101-FPN | pytorch | 1x | 6.4 | 13.5 | 40.0 | 36.1 | [config](./mask-rcnn_r101_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r101_fpn_1x_coco/mask_rcnn_r101_fpn_1x_coco_20200204-1efe0ed5.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r101_fpn_1x_coco/mask_rcnn_r101_fpn_1x_coco_20200204_144809.log.json) | +| R-101-FPN | pytorch | 2x | - | - | 40.8 | 36.6 | [config](./mask-rcnn_r101_fpn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r101_fpn_2x_coco/mask_rcnn_r101_fpn_2x_coco_bbox_mAP-0.408__segm_mAP-0.366_20200505_071027-14b391c7.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r101_fpn_2x_coco/mask_rcnn_r101_fpn_2x_coco_20200505_071027.log.json) | +| X-101-32x4d-FPN | pytorch | 1x | 7.6 | 11.3 | 41.9 | 37.5 | [config](./mask-rcnn_x101-32x4d_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_32x4d_fpn_1x_coco/mask_rcnn_x101_32x4d_fpn_1x_coco_20200205-478d0b67.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_32x4d_fpn_1x_coco/mask_rcnn_x101_32x4d_fpn_1x_coco_20200205_034906.log.json) | +| X-101-32x4d-FPN | pytorch | 2x | - | - | 42.2 | 37.8 | [config](./mask-rcnn_x101-32x4d_fpn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_32x4d_fpn_2x_coco/mask_rcnn_x101_32x4d_fpn_2x_coco_bbox_mAP-0.422__segm_mAP-0.378_20200506_004702-faef898c.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_32x4d_fpn_2x_coco/mask_rcnn_x101_32x4d_fpn_2x_coco_20200506_004702.log.json) | +| X-101-64x4d-FPN | pytorch | 1x | 10.7 | 8.0 | 42.8 | 38.4 | [config](./mask-rcnn_x101-64x4d_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_64x4d_fpn_1x_coco/mask_rcnn_x101_64x4d_fpn_1x_coco_20200201-9352eb0d.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_64x4d_fpn_1x_coco/mask_rcnn_x101_64x4d_fpn_1x_coco_20200201_124310.log.json) | +| X-101-64x4d-FPN | pytorch | 2x | - | - | 42.7 | 38.1 | [config](./mask-rcnn_x101-64x4d_fpn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_64x4d_fpn_2x_coco/mask_rcnn_x101_64x4d_fpn_2x_coco_20200509_224208-39d6f70c.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_64x4d_fpn_2x_coco/mask_rcnn_x101_64x4d_fpn_2x_coco_20200509_224208.log.json) | +| X-101-32x8d-FPN | pytorch | 1x | 10.6 | - | 42.8 | 38.3 | [config](./mask-rcnn_x101-32x8d_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_32x8d_fpn_1x_coco/mask_rcnn_x101_32x8d_fpn_1x_coco_20220630_173841-0aaf329e.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_32x8d_fpn_1x_coco/mask_rcnn_x101_32x8d_fpn_1x_coco_20220630_173841.log.json) | + +## Pre-trained Models + +We also train some models with longer schedules and multi-scale training. The users could finetune them for downstream tasks. + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :--------------------------------------------------------------: | :-----: | :-----: | :------: | :------------: | :----: | :-----: | :-----------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| [R-50-FPN](./mask-rcnn_r50-caffe_fpn_ms-poly-2x_coco.py) | caffe | 2x | 4.3 | | 40.3 | 36.5 | [config](./mask-rcnn_r50-caffe_fpn_ms-poly-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_caffe_fpn_mstrain-poly_2x_coco/mask_rcnn_r50_caffe_fpn_mstrain-poly_2x_coco_bbox_mAP-0.403__segm_mAP-0.365_20200504_231822-a75c98ce.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_caffe_fpn_mstrain-poly_2x_coco/mask_rcnn_r50_caffe_fpn_mstrain-poly_2x_coco_20200504_231822.log.json) | +| [R-50-FPN](./mask-rcnn_r50-caffe_fpn_ms-poly-3x_coco.py) | caffe | 3x | 4.3 | | 40.8 | 37.0 | [config](./mask-rcnn_r50-caffe_fpn_ms-poly-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_20200504_163245.log.json) | +| [R-50-FPN](./mask-rcnn_r50_fpn_ms-poly-3x_coco.py) | pytorch | 3x | 4.1 | | 40.9 | 37.1 | [config](./mask-rcnn_r50_fpn_ms-poly-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_fpn_mstrain-poly_3x_coco/mask_rcnn_r50_fpn_mstrain-poly_3x_coco_20210524_201154-21b550bb.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_fpn_mstrain-poly_3x_coco/mask_rcnn_r50_fpn_mstrain-poly_3x_coco_20210524_201154.log.json) | +| [R-101-FPN](./mask-rcnn_r101-caffe_fpn_ms-poly-3x_coco.py) | caffe | 3x | 5.9 | | 42.9 | 38.5 | [config](./mask-rcnn_r101-caffe_fpn_ms-poly-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r101_caffe_fpn_mstrain-poly_3x_coco/mask_rcnn_r101_caffe_fpn_mstrain-poly_3x_coco_20210526_132339-3c33ce02.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn_r101_caffe_fpn_mstrain-poly_3x_coco/mask_rcnn_r101_caffe_fpn_mstrain-poly_3x_coco_20210526_132339.log.json) | +| [R-101-FPN](./mask-rcnn_r101_fpn_ms-poly-3x_coco.py) | pytorch | 3x | 6.1 | | 42.7 | 38.5 | [config](./mask-rcnn_r101_fpn_ms-poly-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r101_fpn_mstrain-poly_3x_coco/mask_rcnn_r101_fpn_mstrain-poly_3x_coco_20210524_200244-5675c317.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r101_fpn_mstrain-poly_3x_coco/mask_rcnn_r101_fpn_mstrain-poly_3x_coco_20210524_200244.log.json) | +| [x101-32x4d-FPN](./mask-rcnn_x101-32x4d_fpn_ms-poly-3x_coco.py) | pytorch | 3x | 7.3 | | 43.6 | 39.0 | [config](./mask-rcnn_x101-32x4d_fpn_ms-poly-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_32x4d_fpn_mstrain-poly_3x_coco/mask_rcnn_x101_32x4d_fpn_mstrain-poly_3x_coco_20210524_201410-abcd7859.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_32x4d_fpn_mstrain-poly_3x_coco/mask_rcnn_x101_32x4d_fpn_mstrain-poly_3x_coco_20210524_201410.log.json) | +| [X-101-32x8d-FPN](./mask-rcnn_x101-32x8d_fpn_ms-poly-3x_coco.py) | pytorch | 1x | 10.4 | | 43.4 | 39.0 | [config](./mask-rcnn_x101-32x8d_fpn_ms-poly-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_32x8d_fpn_mstrain-poly_1x_coco/mask_rcnn_x101_32x8d_fpn_mstrain-poly_1x_coco_20220630_170346-b4637974.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_32x8d_fpn_mstrain-poly_1x_coco/mask_rcnn_x101_32x8d_fpn_mstrain-poly_1x_coco_20220630_170346.log.json) | +| [X-101-32x8d-FPN](./mask-rcnn_x101-32x8d_fpn_ms-poly-3x_coco.py) | pytorch | 3x | 10.3 | | 44.3 | 39.5 | [config](./mask-rcnn_x101-32x8d_fpn_ms-poly-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_32x8d_fpn_mstrain-poly_3x_coco/mask_rcnn_x101_32x8d_fpn_mstrain-poly_3x_coco_20210607_161042-8bd2c639.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_32x8d_fpn_mstrain-poly_3x_coco/mask_rcnn_x101_32x8d_fpn_mstrain-poly_3x_coco_20210607_161042.log.json) | +| [X-101-64x4d-FPN](./mask-rcnn_x101-64x4d_fpn_ms-poly_3x_coco.py) | pytorch | 3x | 10.4 | | 44.5 | 39.7 | [config](./mask-rcnn_x101-64x4d_fpn_ms-poly_3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_64x4d_fpn_mstrain-poly_3x_coco/mask_rcnn_x101_64x4d_fpn_mstrain-poly_3x_coco_20210526_120447-c376f129.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_64x4d_fpn_mstrain-poly_3x_coco/mask_rcnn_x101_64x4d_fpn_mstrain-poly_3x_coco_20210526_120447.log.json) | + +## Citation + +```latex +@article{He_2017, + title={Mask R-CNN}, + journal={2017 IEEE International Conference on Computer Vision (ICCV)}, + publisher={IEEE}, + author={He, Kaiming and Gkioxari, Georgia and Dollar, Piotr and Girshick, Ross}, + year={2017}, + month={Oct} +} +``` diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_r101-caffe_fpn_1x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_r101-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..09808e4b --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_r101-caffe_fpn_1x_coco.py @@ -0,0 +1,7 @@ +_base_ = './mask-rcnn_r50-caffe_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet101_caffe'))) diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_r101-caffe_fpn_ms-poly-3x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_r101-caffe_fpn_ms-poly-3x_coco.py new file mode 100644 index 00000000..e723aea8 --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_r101-caffe_fpn_ms-poly-3x_coco.py @@ -0,0 +1,19 @@ +_base_ = [ + '../common/ms-poly_3x_coco-instance.py', + '../_base_/models/mask-rcnn_r50_fpn.py' +] + +model = dict( + # use caffe img_norm + data_preprocessor=dict( + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False), + backbone=dict( + depth=101, + norm_cfg=dict(requires_grad=False), + norm_eval=True, + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet101_caffe'))) diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_r101_fpn_1x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_r101_fpn_1x_coco.py new file mode 100644 index 00000000..af91ff0b --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_r101_fpn_1x_coco.py @@ -0,0 +1,6 @@ +_base_ = './mask-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_r101_fpn_2x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_r101_fpn_2x_coco.py new file mode 100644 index 00000000..a5599e7c --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_r101_fpn_2x_coco.py @@ -0,0 +1,6 @@ +_base_ = './mask-rcnn_r50_fpn_2x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_r101_fpn_8xb8-amp-lsj-200e_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_r101_fpn_8xb8-amp-lsj-200e_coco.py new file mode 100644 index 00000000..45235105 --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_r101_fpn_8xb8-amp-lsj-200e_coco.py @@ -0,0 +1,7 @@ +_base_ = './mask-rcnn_r50_fpn_8xb8-amp-lsj-200e_coco.py' + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_r101_fpn_ms-poly-3x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_r101_fpn_ms-poly-3x_coco.py new file mode 100644 index 00000000..384f6dcd --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_r101_fpn_ms-poly-3x_coco.py @@ -0,0 +1,10 @@ +_base_ = [ + '../common/ms-poly_3x_coco-instance.py', + '../_base_/models/mask-rcnn_r50_fpn.py' +] + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_r18_fpn_8xb8-amp-lsj-200e_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_r18_fpn_8xb8-amp-lsj-200e_coco.py new file mode 100644 index 00000000..5b9219c9 --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_r18_fpn_8xb8-amp-lsj-200e_coco.py @@ -0,0 +1,7 @@ +_base_ = './mask-rcnn_r50_fpn_8xb8-amp-lsj-200e_coco.py' + +model = dict( + backbone=dict( + depth=18, + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet18')), + neck=dict(in_channels=[64, 128, 256, 512])) diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_r50-caffe-c4_1x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_r50-caffe-c4_1x_coco.py new file mode 100644 index 00000000..9919f11c --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_r50-caffe-c4_1x_coco.py @@ -0,0 +1,5 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50-caffe-c4.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_1x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..4124f138 --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_1x_coco.py @@ -0,0 +1,13 @@ +_base_ = './mask-rcnn_r50_fpn_1x_coco.py' +model = dict( + # use caffe img_norm + data_preprocessor=dict( + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False), + backbone=dict( + norm_cfg=dict(requires_grad=False), + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe'))) diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-1x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-1x_coco.py new file mode 100644 index 00000000..7702ae14 --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-1x_coco.py @@ -0,0 +1,28 @@ +_base_ = './mask-rcnn_r50_fpn_1x_coco.py' + +model = dict( + # use caffe img_norm + data_preprocessor=dict( + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False), + backbone=dict( + norm_cfg=dict(requires_grad=False), + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe'))) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736), + (1333, 768), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs'), +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco.py new file mode 100644 index 00000000..94d94dd3 --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco.py @@ -0,0 +1,31 @@ +_base_ = './mask-rcnn_r50_fpn_1x_coco.py' + +model = dict( + # use caffe img_norm + data_preprocessor=dict( + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False), + backbone=dict( + norm_cfg=dict(requires_grad=False), + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe'))) +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict( + type='LoadAnnotations', + with_bbox=True, + with_mask=True, + poly2mask=False), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736), + (1333, 768), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-poly-2x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-poly-2x_coco.py new file mode 100644 index 00000000..dbf87bb8 --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-poly-2x_coco.py @@ -0,0 +1,15 @@ +_base_ = './mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco.py' + +train_cfg = dict(max_epochs=24) +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=24, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-poly-3x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-poly-3x_coco.py new file mode 100644 index 00000000..45260e2e --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-poly-3x_coco.py @@ -0,0 +1,15 @@ +_base_ = './mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco.py' + +train_cfg = dict(max_epochs=36) +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=24, + by_epoch=True, + milestones=[28, 34], + gamma=0.1) +] diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_poly-1x_coco_v1.py b/mmdetection/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_poly-1x_coco_v1.py new file mode 100644 index 00000000..3baf0014 --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_poly-1x_coco_v1.py @@ -0,0 +1,31 @@ +_base_ = './mask-rcnn_r50_fpn_1x_coco.py' + +model = dict( + # use caffe img_norm + data_preprocessor=dict( + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False), + backbone=dict( + norm_cfg=dict(requires_grad=False), + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe')), + rpn_head=dict( + loss_bbox=dict(type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=1.0)), + roi_head=dict( + bbox_roi_extractor=dict( + roi_layer=dict( + type='RoIAlign', + output_size=7, + sampling_ratio=2, + aligned=False)), + bbox_head=dict( + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0)), + mask_roi_extractor=dict( + roi_layer=dict( + type='RoIAlign', + output_size=14, + sampling_ratio=2, + aligned=False)))) diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_r50_fpn_1x-wandb_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_r50_fpn_1x-wandb_coco.py new file mode 100644 index 00000000..28b125cc --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_r50_fpn_1x-wandb_coco.py @@ -0,0 +1,16 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +vis_backends = [dict(type='LocalVisBackend'), dict(type='WandbVisBackend')] +visualizer = dict(vis_backends=vis_backends) + +# MMEngine support the following two ways, users can choose +# according to convenience +# default_hooks = dict(checkpoint=dict(interval=4)) +_base_.default_hooks.checkpoint.interval = 4 + +# train_cfg = dict(val_interval=2) +_base_.train_cfg.val_interval = 2 diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py new file mode 100644 index 00000000..0fc6b91a --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py @@ -0,0 +1,5 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_r50_fpn_2x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_r50_fpn_2x_coco.py new file mode 100644 index 00000000..87cb8b4b --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_r50_fpn_2x_coco.py @@ -0,0 +1,5 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_2x.py', '../_base_/default_runtime.py' +] diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_r50_fpn_8xb8-amp-lsj-200e_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_r50_fpn_8xb8-amp-lsj-200e_coco.py new file mode 100644 index 00000000..7371b364 --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_r50_fpn_8xb8-amp-lsj-200e_coco.py @@ -0,0 +1,22 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../common/lsj-100e_coco-instance.py' +] +image_size = (1024, 1024) +batch_augments = [ + dict(type='BatchFixedSizePad', size=image_size, pad_mask=True) +] + +model = dict(data_preprocessor=dict(batch_augments=batch_augments)) + +train_dataloader = dict(batch_size=8, num_workers=4) +# Enable automatic-mixed-precision training with AmpOptimWrapper. +optim_wrapper = dict( + type='AmpOptimWrapper', + optimizer=dict( + type='SGD', lr=0.02 * 4, momentum=0.9, weight_decay=0.00004)) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (8 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_r50_fpn_amp-1x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_r50_fpn_amp-1x_coco.py new file mode 100644 index 00000000..a139c48b --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_r50_fpn_amp-1x_coco.py @@ -0,0 +1,4 @@ +_base_ = './mask-rcnn_r50_fpn_1x_coco.py' + +# Enable automatic-mixed-precision training with AmpOptimWrapper. +optim_wrapper = dict(type='AmpOptimWrapper') diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_r50_fpn_ms-poly-3x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_r50_fpn_ms-poly-3x_coco.py new file mode 100644 index 00000000..417adc3c --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_r50_fpn_ms-poly-3x_coco.py @@ -0,0 +1,4 @@ +_base_ = [ + '../common/ms-poly_3x_coco-instance.py', + '../_base_/models/mask-rcnn_r50_fpn.py' +] diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_r50_fpn_poly-1x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_r50_fpn_poly-1x_coco.py new file mode 100644 index 00000000..826180ce --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_r50_fpn_poly-1x_coco.py @@ -0,0 +1,18 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict( + type='LoadAnnotations', + with_bbox=True, + with_mask=True, + poly2mask=False), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs'), +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_x101-32x4d_fpn_1x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_x101-32x4d_fpn_1x_coco.py new file mode 100644 index 00000000..921ade81 --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_x101-32x4d_fpn_1x_coco.py @@ -0,0 +1,14 @@ +_base_ = './mask-rcnn_r101_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_x101-32x4d_fpn_2x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_x101-32x4d_fpn_2x_coco.py new file mode 100644 index 00000000..db8157f8 --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_x101-32x4d_fpn_2x_coco.py @@ -0,0 +1,14 @@ +_base_ = './mask-rcnn_r101_fpn_2x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_x101-32x4d_fpn_ms-poly-3x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_x101-32x4d_fpn_ms-poly-3x_coco.py new file mode 100644 index 00000000..83e5451f --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_x101-32x4d_fpn_ms-poly-3x_coco.py @@ -0,0 +1,18 @@ +_base_ = [ + '../common/ms-poly_3x_coco-instance.py', + '../_base_/models/mask-rcnn_r50_fpn.py' +] + +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_x101-32x8d_fpn_1x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_x101-32x8d_fpn_1x_coco.py new file mode 100644 index 00000000..3e9b1b6f --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_x101-32x8d_fpn_1x_coco.py @@ -0,0 +1,22 @@ +_base_ = './mask-rcnn_r101_fpn_1x_coco.py' + +model = dict( + # ResNeXt-101-32x8d model trained with Caffe2 at FB, + # so the mean and std need to be changed. + data_preprocessor=dict( + mean=[103.530, 116.280, 123.675], + std=[57.375, 57.120, 58.395], + bgr_to_rgb=False), + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=8, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=False), + style='pytorch', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnext101_32x8d'))) diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_x101-32x8d_fpn_ms-poly-1x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_x101-32x8d_fpn_ms-poly-1x_coco.py new file mode 100644 index 00000000..6ee204d9 --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_x101-32x8d_fpn_ms-poly-1x_coco.py @@ -0,0 +1,40 @@ +_base_ = './mask-rcnn_r101_fpn_1x_coco.py' + +model = dict( + # ResNeXt-101-32x8d model trained with Caffe2 at FB, + # so the mean and std need to be changed. + data_preprocessor=dict( + mean=[103.530, 116.280, 123.675], + std=[57.375, 57.120, 58.395], + bgr_to_rgb=False), + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=8, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=False), + style='pytorch', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnext101_32x8d'))) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict( + type='LoadAnnotations', + with_bbox=True, + with_mask=True, + poly2mask=False), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736), + (1333, 768), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs'), +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_x101-32x8d_fpn_ms-poly-3x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_x101-32x8d_fpn_ms-poly-3x_coco.py new file mode 100644 index 00000000..999a30c3 --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_x101-32x8d_fpn_ms-poly-3x_coco.py @@ -0,0 +1,25 @@ +_base_ = [ + '../common/ms-poly_3x_coco-instance.py', + '../_base_/models/mask-rcnn_r50_fpn.py' +] + +model = dict( + # ResNeXt-101-32x8d model trained with Caffe2 at FB, + # so the mean and std need to be changed. + data_preprocessor=dict( + mean=[103.530, 116.280, 123.675], + std=[57.375, 57.120, 58.395], + bgr_to_rgb=False), + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=8, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=False), + style='pytorch', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnext101_32x8d'))) diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_x101-64x4d_fpn_1x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_x101-64x4d_fpn_1x_coco.py new file mode 100644 index 00000000..2cbb658c --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_x101-64x4d_fpn_1x_coco.py @@ -0,0 +1,14 @@ +_base_ = './mask-rcnn_x101-32x4d_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_x101-64x4d_fpn_2x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_x101-64x4d_fpn_2x_coco.py new file mode 100644 index 00000000..f21a55b0 --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_x101-64x4d_fpn_2x_coco.py @@ -0,0 +1,14 @@ +_base_ = './mask-rcnn_x101-32x4d_fpn_2x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/mask_rcnn/mask-rcnn_x101-64x4d_fpn_ms-poly_3x_coco.py b/mmdetection/configs/mask_rcnn/mask-rcnn_x101-64x4d_fpn_ms-poly_3x_coco.py new file mode 100644 index 00000000..09b49d47 --- /dev/null +++ b/mmdetection/configs/mask_rcnn/mask-rcnn_x101-64x4d_fpn_ms-poly_3x_coco.py @@ -0,0 +1,18 @@ +_base_ = [ + '../common/ms-poly_3x_coco-instance.py', + '../_base_/models/mask-rcnn_r50_fpn.py' +] + +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/mask_rcnn/metafile.yml b/mmdetection/configs/mask_rcnn/metafile.yml new file mode 100644 index 00000000..ddf85c87 --- /dev/null +++ b/mmdetection/configs/mask_rcnn/metafile.yml @@ -0,0 +1,443 @@ +Collections: + - Name: Mask R-CNN + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - Softmax + - RPN + - Convolution + - Dense Connections + - FPN + - ResNet + - RoIAlign + Paper: + URL: https://arxiv.org/abs/1703.06870v3 + Title: "Mask R-CNN" + README: configs/mask_rcnn/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/detectors/mask_rcnn.py#L6 + Version: v2.0.0 + +Models: + - Name: mask-rcnn_r50-caffe_fpn_1x_coco + In Collection: Mask R-CNN + Config: configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.3 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.0 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 34.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_caffe_fpn_1x_coco/mask_rcnn_r50_caffe_fpn_1x_coco_bbox_mAP-0.38__segm_mAP-0.344_20200504_231812-0ebd1859.pth + + - Name: mask-rcnn_r50_fpn_1x_coco + In Collection: Mask R-CNN + Config: configs/mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.4 + inference time (ms/im): + - value: 62.11 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.2 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 34.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_fpn_1x_coco/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth + + - Name: mask-rcnn_r50_fpn_fp16_1x_coco + In Collection: Mask R-CNN + Config: configs/mask_rcnn/mask-rcnn_r50_fpn_amp-1x_coco.py + Metadata: + Training Memory (GB): 3.6 + Training Techniques: + - SGD with Momentum + - Weight Decay + - Mixed Precision Training + inference time (ms/im): + - value: 41.49 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP16 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.1 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 34.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/fp16/mask_rcnn_r50_fpn_fp16_1x_coco/mask_rcnn_r50_fpn_fp16_1x_coco_20200205-59faf7e4.pth + + - Name: mask-rcnn_r50_fpn_2x_coco + In Collection: Mask R-CNN + Config: configs/mask_rcnn/mask-rcnn_r50_fpn_2x_coco.py + Metadata: + Training Memory (GB): 4.4 + inference time (ms/im): + - value: 62.11 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.2 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 35.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_fpn_2x_coco/mask_rcnn_r50_fpn_2x_coco_bbox_mAP-0.392__segm_mAP-0.354_20200505_003907-3e542a40.pth + + - Name: mask-rcnn_r101-caffe_fpn_1x_coco + In Collection: Mask R-CNN + Config: configs/mask_rcnn/mask-rcnn_r101-caffe_fpn_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.4 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r101_caffe_fpn_1x_coco/mask_rcnn_r101_caffe_fpn_1x_coco_20200601_095758-805e06c1.pth + + - Name: mask-rcnn_r101_fpn_1x_coco + In Collection: Mask R-CNN + Config: configs/mask_rcnn/mask-rcnn_r101_fpn_1x_coco.py + Metadata: + Training Memory (GB): 6.4 + inference time (ms/im): + - value: 74.07 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.0 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r101_fpn_1x_coco/mask_rcnn_r101_fpn_1x_coco_20200204-1efe0ed5.pth + + - Name: mask-rcnn_r101_fpn_2x_coco + In Collection: Mask R-CNN + Config: configs/mask_rcnn/mask-rcnn_r101_fpn_2x_coco.py + Metadata: + Training Memory (GB): 6.4 + inference time (ms/im): + - value: 74.07 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r101_fpn_2x_coco/mask_rcnn_r101_fpn_2x_coco_bbox_mAP-0.408__segm_mAP-0.366_20200505_071027-14b391c7.pth + + - Name: mask-rcnn_x101-32x4d_fpn_1x_coco + In Collection: Mask R-CNN + Config: configs/mask_rcnn/mask-rcnn_x101-32x4d_fpn_1x_coco.py + Metadata: + Training Memory (GB): 7.6 + inference time (ms/im): + - value: 88.5 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.9 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_32x4d_fpn_1x_coco/mask_rcnn_x101_32x4d_fpn_1x_coco_20200205-478d0b67.pth + + - Name: mask-rcnn_x101-32x4d_fpn_2x_coco + In Collection: Mask R-CNN + Config: configs/mask_rcnn/mask-rcnn_x101-32x4d_fpn_2x_coco.py + Metadata: + Training Memory (GB): 7.6 + inference time (ms/im): + - value: 88.5 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.2 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_32x4d_fpn_2x_coco/mask_rcnn_x101_32x4d_fpn_2x_coco_bbox_mAP-0.422__segm_mAP-0.378_20200506_004702-faef898c.pth + + - Name: mask-rcnn_x101-64x4d_fpn_1x_coco + In Collection: Mask R-CNN + Config: configs/mask_rcnn/mask-rcnn_x101-64x4d_fpn_1x_coco.py + Metadata: + Training Memory (GB): 10.7 + inference time (ms/im): + - value: 125 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_64x4d_fpn_1x_coco/mask_rcnn_x101_64x4d_fpn_1x_coco_20200201-9352eb0d.pth + + - Name: mask-rcnn_x101-64x4d_fpn_2x_coco + In Collection: Mask R-CNN + Config: configs/mask_rcnn/mask-rcnn_x101-64x4d_fpn_2x_coco.py + Metadata: + Training Memory (GB): 10.7 + inference time (ms/im): + - value: 125 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.7 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_64x4d_fpn_2x_coco/mask_rcnn_x101_64x4d_fpn_2x_coco_20200509_224208-39d6f70c.pth + + - Name: mask-rcnn_x101-32x8d_fpn_1x_coco + In Collection: Mask R-CNN + Config: configs/mask_rcnn/mask-rcnn_x101-32x8d_fpn_1x_coco.py + Metadata: + Training Memory (GB): 10.6 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_32x8d_fpn_1x_coco/mask_rcnn_x101_32x8d_fpn_1x_coco_20220630_173841-0aaf329e.pth + + - Name: mask-rcnn_r50-caffe_fpn_ms-poly-2x_coco + In Collection: Mask R-CNN + Config: configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-poly-2x_coco.py + Metadata: + Training Memory (GB): 4.3 + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.3 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_caffe_fpn_mstrain-poly_2x_coco/mask_rcnn_r50_caffe_fpn_mstrain-poly_2x_coco_bbox_mAP-0.403__segm_mAP-0.365_20200504_231822-a75c98ce.pth + + - Name: mask-rcnn_r50-caffe_fpn_ms-poly-3x_coco + In Collection: Mask R-CNN + Config: configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-poly-3x_coco.py + Metadata: + Training Memory (GB): 4.3 + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth + + - Name: mask-rcnn_r50_fpn_mstrain-poly_3x_coco + In Collection: Mask R-CNN + Config: configs/mask_rcnn/mask-rcnn_r50_fpn_ms-poly-3x_coco.py + Metadata: + Training Memory (GB): 4.1 + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.9 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_fpn_mstrain-poly_3x_coco/mask_rcnn_r50_fpn_mstrain-poly_3x_coco_20210524_201154-21b550bb.pth + + - Name: mask-rcnn_r101_fpn_ms-poly-3x_coco + In Collection: Mask R-CNN + Config: configs/mask_rcnn/mask-rcnn_r101_fpn_ms-poly-3x_coco.py + Metadata: + Training Memory (GB): 6.1 + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.7 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r101_fpn_mstrain-poly_3x_coco/mask_rcnn_r101_fpn_mstrain-poly_3x_coco_20210524_200244-5675c317.pth + + - Name: mask-rcnn_r101-caffe_fpn_ms-poly-3x_coco + In Collection: Mask R-CNN + Config: configs/mask_rcnn/mask-rcnn_r101-caffe_fpn_ms-poly-3x_coco.py + Metadata: + Training Memory (GB): 5.9 + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.9 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r101_caffe_fpn_mstrain-poly_3x_coco/mask_rcnn_r101_caffe_fpn_mstrain-poly_3x_coco_20210526_132339-3c33ce02.pth + + - Name: mask-rcnn_x101-32x4d_fpn_ms-poly-3x_coco + In Collection: Mask R-CNN + Config: configs/mask_rcnn/mask-rcnn_x101-32x4d_fpn_ms-poly-3x_coco.py + Metadata: + Training Memory (GB): 7.3 + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.6 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_32x4d_fpn_mstrain-poly_3x_coco/mask_rcnn_x101_32x4d_fpn_mstrain-poly_3x_coco_20210524_201410-abcd7859.pth + + - Name: mask-rcnn_x101-32x8d_fpn_ms-poly-1x_coco + In Collection: Mask R-CNN + Config: configs/mask_rcnn/mask-rcnn_x101-32x8d_fpn_ms-poly-1x_coco.py + Metadata: + Training Memory (GB): 10.4 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.4 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_32x8d_fpn_mstrain-poly_1x_coco/mask_rcnn_x101_32x8d_fpn_mstrain-poly_1x_coco_20220630_170346-b4637974.pth + + - Name: mask-rcnn_x101-32x8d_fpn_ms-poly-3x_coco + In Collection: Mask R-CNN + Config: configs/mask_rcnn/mask-rcnn_x101-32x8d_fpn_ms-poly-3x_coco.py + Metadata: + Training Memory (GB): 10.3 + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_32x8d_fpn_mstrain-poly_3x_coco/mask_rcnn_x101_32x8d_fpn_mstrain-poly_3x_coco_20210607_161042-8bd2c639.pth + + - Name: mask-rcnn_x101-64x4d_fpn_ms-poly_3x_coco + In Collection: Mask R-CNN + Config: configs/mask_rcnn/mask-rcnn_x101-64x4d_fpn_ms-poly_3x_coco.py + Metadata: + Epochs: 36 + Training Memory (GB): 10.4 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.5 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_64x4d_fpn_mstrain-poly_3x_coco/mask_rcnn_x101_64x4d_fpn_mstrain-poly_3x_coco_20210526_120447-c376f129.pth diff --git a/mmdetection/configs/maskformer/README.md b/mmdetection/configs/maskformer/README.md new file mode 100644 index 00000000..ca5ce320 --- /dev/null +++ b/mmdetection/configs/maskformer/README.md @@ -0,0 +1,58 @@ +# MaskFormer + +> [Per-Pixel Classification is Not All You Need for Semantic Segmentation](https://arxiv.org/abs/2107.06278) + + + +## Abstract + +Modern approaches typically formulate semantic segmentation as a per-pixel classification task, while instance-level segmentation is handled with an alternative mask classification. Our key insight: mask classification is sufficiently general to solve both semantic- and instance-level segmentation tasks in a unified manner using the exact same model, loss, and training procedure. Following this observation, we propose MaskFormer, a simple mask classification model which predicts a set of binary masks, each associated with a single global class label prediction. Overall, the proposed mask classification-based method simplifies the landscape of effective approaches to semantic and panoptic segmentation tasks and shows excellent empirical results. In particular, we observe that MaskFormer outperforms per-pixel classification baselines when the number of classes is large. Our mask classification-based method outperforms both current state-of-the-art semantic (55.6 mIoU on ADE20K) and panoptic segmentation (52.7 PQ on COCO) models. + +
    + +
    + +## Introduction + +MaskFormer requires COCO and [COCO-panoptic](http://images.cocodataset.org/annotations/panoptic_annotations_trainval2017.zip) dataset for training and evaluation. You need to download and extract it in the COCO dataset path. +The directory should be like this. + +```none +mmdetection +├── mmdet +├── tools +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── panoptic_train2017.json +│ │ │ ├── panoptic_train2017 +│ │ │ ├── panoptic_val2017.json +│ │ │ ├── panoptic_val2017 +│ │ ├── train2017 +│ │ ├── val2017 +│ │ ├── test2017 +``` + +## Results and Models + +| Backbone | style | Lr schd | Mem (GB) | Inf time (fps) | PQ | SQ | RQ | PQ_th | SQ_th | RQ_th | PQ_st | SQ_st | RQ_st | Config | Download | +| :------: | :-----: | :-----: | :------: | :------------: | :----: | :----: | :----: | :----: | :----: | :----: | :----: | :----: | :----: | :--------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | pytorch | 75e | 16.2 | - | 46.757 | 80.297 | 57.176 | 50.829 | 81.125 | 61.798 | 40.610 | 79.048 | 50.199 | [config](./maskformer_r50_ms-16xb1-75e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/maskformer/maskformer_r50_ms-16xb1-75e_coco/maskformer_r50_ms-16xb1-75e_coco_20230116_095226-baacd858.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/maskformer/maskformer_r50_ms-16xb1-75e_coco/maskformer_r50_ms-16xb1-75e_coco_20230116_095226.log.json) | +| Swin-L | pytorch | 300e | 27.2 | - | 53.249 | 81.704 | 64.231 | 58.798 | 82.923 | 70.282 | 44.874 | 79.863 | 55.097 | [config](./maskformer_swin-l-p4-w12_64xb1-ms-300e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/maskformer/maskformer_swin-l-p4-w12_64xb1-ms-300e_coco/maskformer_swin-l-p4-w12_64xb1-ms-300e_coco_20220326_221612-c63ab967.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/maskformer/maskformer_swin-l-p4-w12_mstrain_64x1_300e_coco/maskformer_swin-l-p4-w12_mstrain_64x1_300e_coco_20220326_221612.log.json) | + +### Note + +1. The `R-50` version was mentioned in Table XI, in paper [Masked-attention Mask Transformer for Universal Image Segmentation](https://arxiv.org/abs/2112.01527). +2. The models were trained with mmdet 2.x and have been converted for mmdet 3.x. + +## Citation + +```latex +@inproceedings{cheng2021maskformer, + title={Per-Pixel Classification is Not All You Need for Semantic Segmentation}, + author={Bowen Cheng and Alexander G. Schwing and Alexander Kirillov}, + journal={NeurIPS}, + year={2021} +} +``` diff --git a/mmdetection/configs/maskformer/maskformer_r50_ms-16xb1-75e_coco.py b/mmdetection/configs/maskformer/maskformer_r50_ms-16xb1-75e_coco.py new file mode 100644 index 00000000..784ee776 --- /dev/null +++ b/mmdetection/configs/maskformer/maskformer_r50_ms-16xb1-75e_coco.py @@ -0,0 +1,216 @@ +_base_ = [ + '../_base_/datasets/coco_panoptic.py', '../_base_/default_runtime.py' +] + +data_preprocessor = dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=1, + pad_mask=True, + mask_pad_value=0, + pad_seg=True, + seg_pad_value=255) + +num_things_classes = 80 +num_stuff_classes = 53 +num_classes = num_things_classes + num_stuff_classes +model = dict( + type='MaskFormer', + data_preprocessor=data_preprocessor, + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=-1, + norm_cfg=dict(type='BN', requires_grad=False), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + panoptic_head=dict( + type='MaskFormerHead', + in_channels=[256, 512, 1024, 2048], # pass to pixel_decoder inside + feat_channels=256, + out_channels=256, + num_things_classes=num_things_classes, + num_stuff_classes=num_stuff_classes, + num_queries=100, + pixel_decoder=dict( + type='TransformerEncoderPixelDecoder', + norm_cfg=dict(type='GN', num_groups=32), + act_cfg=dict(type='ReLU'), + encoder=dict( # DetrTransformerEncoder + num_layers=6, + layer_cfg=dict( # DetrTransformerEncoderLayer + self_attn_cfg=dict( # MultiheadAttention + embed_dims=256, + num_heads=8, + dropout=0.1, + batch_first=True), + ffn_cfg=dict( + embed_dims=256, + feedforward_channels=2048, + num_fcs=2, + ffn_drop=0.1, + act_cfg=dict(type='ReLU', inplace=True)))), + positional_encoding=dict(num_feats=128, normalize=True)), + enforce_decoder_input_project=False, + positional_encoding=dict(num_feats=128, normalize=True), + transformer_decoder=dict( # DetrTransformerDecoder + num_layers=6, + layer_cfg=dict( # DetrTransformerDecoderLayer + self_attn_cfg=dict( # MultiheadAttention + embed_dims=256, + num_heads=8, + dropout=0.1, + batch_first=True), + cross_attn_cfg=dict( # MultiheadAttention + embed_dims=256, + num_heads=8, + dropout=0.1, + batch_first=True), + ffn_cfg=dict( + embed_dims=256, + feedforward_channels=2048, + num_fcs=2, + ffn_drop=0.1, + act_cfg=dict(type='ReLU', inplace=True))), + return_intermediate=True), + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0, + reduction='mean', + class_weight=[1.0] * num_classes + [0.1]), + loss_mask=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + reduction='mean', + loss_weight=20.0), + loss_dice=dict( + type='DiceLoss', + use_sigmoid=True, + activate=True, + reduction='mean', + naive_dice=True, + eps=1.0, + loss_weight=1.0)), + panoptic_fusion_head=dict( + type='MaskFormerFusionHead', + num_things_classes=num_things_classes, + num_stuff_classes=num_stuff_classes, + loss_panoptic=None, + init_cfg=None), + train_cfg=dict( + assigner=dict( + type='HungarianAssigner', + match_costs=[ + dict(type='ClassificationCost', weight=1.0), + dict(type='FocalLossCost', weight=20.0, binary_input=True), + dict(type='DiceCost', weight=1.0, pred_act=True, eps=1.0) + ]), + sampler=dict(type='MaskPseudoSampler')), + test_cfg=dict( + panoptic_on=True, + # For now, the dataset does not support + # evaluating semantic segmentation metric. + semantic_on=False, + instance_on=False, + # max_per_image is for instance segmentation. + max_per_image=100, + object_mask_thr=0.8, + iou_thr=0.8, + # In MaskFormer's panoptic postprocessing, + # it will not filter masks whose score is smaller than 0.5 . + filter_low_score=False), + init_cfg=None) + +# dataset settings +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='LoadPanopticAnnotations', + with_bbox=True, + with_mask=True, + with_seg=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[[ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + scales=[(400, 1333), (500, 1333), (600, 1333)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), + (576, 1333), (608, 1333), (640, 1333), + (672, 1333), (704, 1333), (736, 1333), + (768, 1333), (800, 1333)], + keep_ratio=True) + ]]), + dict(type='PackDetInputs') +] + +train_dataloader = dict( + batch_size=1, num_workers=1, dataset=dict(pipeline=train_pipeline)) + +val_dataloader = dict(batch_size=1, num_workers=1) + +test_dataloader = val_dataloader + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict( + type='AdamW', + lr=0.0001, + weight_decay=0.0001, + eps=1e-8, + betas=(0.9, 0.999)), + paramwise_cfg=dict( + custom_keys={ + 'backbone': dict(lr_mult=0.1, decay_mult=1.0), + 'query_embed': dict(lr_mult=1.0, decay_mult=0.0) + }, + norm_decay_mult=0.0), + clip_grad=dict(max_norm=0.01, norm_type=2)) + +max_epochs = 75 + +# learning rate +param_scheduler = dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[50], + gamma=0.1) + +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# Default setting for scaling LR automatically +# - `enable` means enable scaling LR automatically +# or not by default. +# - `base_batch_size` = (16 GPUs) x (1 samples per GPU). +auto_scale_lr = dict(enable=False, base_batch_size=16) diff --git a/mmdetection/configs/maskformer/maskformer_swin-l-p4-w12_64xb1-ms-300e_coco.py b/mmdetection/configs/maskformer/maskformer_swin-l-p4-w12_64xb1-ms-300e_coco.py new file mode 100644 index 00000000..9e4897f2 --- /dev/null +++ b/mmdetection/configs/maskformer/maskformer_swin-l-p4-w12_64xb1-ms-300e_coco.py @@ -0,0 +1,73 @@ +_base_ = './maskformer_r50_ms-16xb1-75e_coco.py' + +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_large_patch4_window12_384_22k.pth' # noqa +depths = [2, 2, 18, 2] +model = dict( + backbone=dict( + _delete_=True, + type='SwinTransformer', + pretrain_img_size=384, + embed_dims=192, + patch_size=4, + window_size=12, + mlp_ratio=4, + depths=depths, + num_heads=[6, 12, 24, 48], + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.3, + patch_norm=True, + out_indices=(0, 1, 2, 3), + with_cp=False, + convert_weights=True, + init_cfg=dict(type='Pretrained', checkpoint=pretrained)), + panoptic_head=dict( + in_channels=[192, 384, 768, 1536], # pass to pixel_decoder inside + pixel_decoder=dict( + _delete_=True, + type='PixelDecoder', + norm_cfg=dict(type='GN', num_groups=32), + act_cfg=dict(type='ReLU')), + enforce_decoder_input_project=True)) + +# optimizer + +# weight_decay = 0.01 +# norm_weight_decay = 0.0 +# embed_weight_decay = 0.0 +embed_multi = dict(lr_mult=1.0, decay_mult=0.0) +norm_multi = dict(lr_mult=1.0, decay_mult=0.0) +custom_keys = { + 'norm': norm_multi, + 'absolute_pos_embed': embed_multi, + 'relative_position_bias_table': embed_multi, + 'query_embed': embed_multi +} + +optim_wrapper = dict( + optimizer=dict(lr=6e-5, weight_decay=0.01), + paramwise_cfg=dict(custom_keys=custom_keys, norm_decay_mult=0.0)) + +max_epochs = 300 + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=1e-6, by_epoch=False, begin=0, end=1500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[250], + gamma=0.1) +] + +train_cfg = dict(max_epochs=max_epochs) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (64 GPUs) x (1 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/maskformer/metafile.yml b/mmdetection/configs/maskformer/metafile.yml new file mode 100644 index 00000000..fa58269d --- /dev/null +++ b/mmdetection/configs/maskformer/metafile.yml @@ -0,0 +1,43 @@ +Collections: + - Name: MaskFormer + Metadata: + Training Data: COCO + Training Techniques: + - AdamW + - Weight Decay + Training Resources: 16x V100 GPUs + Architecture: + - MaskFormer + Paper: + URL: https://arxiv.org/pdf/2107.06278 + Title: 'Per-Pixel Classification is Not All You Need for Semantic Segmentation' + README: configs/maskformer/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.22.0/mmdet/models/detectors/maskformer.py#L7 + Version: v2.22.0 + +Models: + - Name: maskformer_r50_ms-16xb1-75e_coco + In Collection: MaskFormer + Config: configs/maskformer/maskformer_r50_ms-16xb1-75e_coco.py + Metadata: + Training Memory (GB): 16.2 + Epochs: 75 + Results: + - Task: Panoptic Segmentation + Dataset: COCO + Metrics: + PQ: 46.9 + Weights: https://download.openmmlab.com/mmdetection/v3.0/maskformer/maskformer_r50_ms-16xb1-75e_coco/maskformer_r50_ms-16xb1-75e_coco_20230116_095226-baacd858.pth + - Name: maskformer_swin-l-p4-w12_64xb1-ms-300e_coco + In Collection: MaskFormer + Config: configs/maskformer/maskformer_swin-l-p4-w12_64xb1-ms-300e_coco.py + Metadata: + Training Memory (GB): 27.2 + Epochs: 300 + Results: + - Task: Panoptic Segmentation + Dataset: COCO + Metrics: + PQ: 53.2 + Weights: https://download.openmmlab.com/mmdetection/v3.0/maskformer/maskformer_swin-l-p4-w12_64xb1-ms-300e_coco/maskformer_swin-l-p4-w12_64xb1-ms-300e_coco_20220326_221612-c63ab967.pth diff --git a/mmdetection/configs/masktrack_rcnn/README.md b/mmdetection/configs/masktrack_rcnn/README.md new file mode 100644 index 00000000..5cef692a --- /dev/null +++ b/mmdetection/configs/masktrack_rcnn/README.md @@ -0,0 +1,93 @@ +# Video Instance Segmentation + +## Abstract + + + +In this paper we present a new computer vision task, named video instance segmentation. The goal of this new task is simultaneous detection, segmentation and tracking of instances in videos. In words, it is the first time that the image instance segmentation problem is extended to the video domain. To facilitate research on this new task, we propose a large-scale benchmark called YouTube-VIS, which consists of 2883 high-resolution YouTube videos, a 40-category label set and 131k high-quality instance masks. In addition, we propose a novel algorithm called MaskTrack R-CNN for this task. Our new method introduces a new tracking branch to Mask R-CNN to jointly perform the detection, segmentation and tracking tasks simultaneously. Finally, we evaluate the proposed method and several strong baselines on our new dataset. Experimental results clearly demonstrate the advantages of the proposed algorithm and reveal insight for future improvement. We believe the video instance segmentation task will motivate the community along the line of research for video understanding. + + + +
    + +
    + +## Citation + + + +```latex +@inproceedings{yang2019video, + title={Video instance segmentation}, + author={Yang, Linjie and Fan, Yuchen and Xu, Ning}, + booktitle={Proceedings of the IEEE/CVF International Conference on Computer Vision}, + pages={5188--5197}, + year={2019} +} +``` + +## Results and models of MaskTrack R-CNN on YouTube-VIS 2019 validation dataset + +As mentioned in [Issues #6](https://github.com/youtubevos/MaskTrackRCNN/issues/6#issuecomment-502503505) in MaskTrack R-CNN, the result is kind of unstable for different trials, which ranges from 28 AP to 31 AP when using R-50-FPN as backbone. +The checkpoint provided below is the best one from two experiments. + +| Method | Base detector | Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | AP | Config | Download | +| :-------------: | :-----------: | :-------: | :-----: | :-----: | :------: | :------------: | :--: | :--------------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| MaskTrack R-CNN | Mask R-CNN | R-50-FPN | pytorch | 12e | 1.61 | - | 30.2 | [config](masktrack-rcnn_mask-rcnn_r50_fpn_8xb1-12e_youtubevis2019.py) | [model](https://download.openmmlab.com/mmtracking/vis/masktrack_rcnn/masktrack_rcnn_r50_fpn_12e_youtubevis2019/masktrack_rcnn_r50_fpn_12e_youtubevis2019_20211022_194830-6ca6b91e.pth) \| [log](https://download.openmmlab.com/mmtracking/vis/masktrack_rcnn/masktrack_rcnn_r50_fpn_12e_youtubevis2019/masktrack_rcnn_r50_fpn_12e_youtubevis2019_20211022_194830.log.json) | +| MaskTrack R-CNN | Mask R-CNN | R-101-FPN | pytorch | 12e | 2.27 | - | 32.2 | [config](masktrack-rcnn_mask-rcnn_r101_fpn_8xb1-12e_youtubevis2019.py) | [model](https://download.openmmlab.com/mmtracking/vis/masktrack_rcnn/masktrack_rcnn_r101_fpn_12e_youtubevis2019/masktrack_rcnn_r101_fpn_12e_youtubevis2019_20211023_150038-454dc48b.pth) \| [log](https://download.openmmlab.com/mmtracking/vis/masktrack_rcnn/masktrack_rcnn_r101_fpn_12e_youtubevis2019/masktrack_rcnn_r101_fpn_12e_youtubevis2019_20211023_150038.log.json) | +| MaskTrack R-CNN | Mask R-CNN | X-101-FPN | pytorch | 12e | 3.69 | - | 34.7 | [config](masktrack-rcnn_mask-rcnn_x101_fpn_8xb1-12e_youtubevis2019.py) | [model](https://download.openmmlab.com/mmtracking/vis/masktrack_rcnn/masktrack_rcnn_x101_fpn_12e_youtubevis2019/masktrack_rcnn_x101_fpn_12e_youtubevis2019_20211023_153205-fff7a102.pth) \| [log](https://download.openmmlab.com/mmtracking/vis/masktrack_rcnn/masktrack_rcnn_x101_fpn_12e_youtubevis2019/masktrack_rcnn_x101_fpn_12e_youtubevis2019_20211023_153205.log.json) | + +## Results and models of MaskTrack R-CNN on YouTube-VIS 2021 validation dataset + +The checkpoint provided below is the best one from two experiments. + +| Method | Base detector | Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | AP | Config | Download | +| :-------------: | :-----------: | :-------: | :-----: | :-----: | :------: | :------------: | :--: | :--------------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| MaskTrack R-CNN | Mask R-CNN | R-50-FPN | pytorch | 12e | 1.61 | - | 28.7 | [config](masktrack-rcnn_mask-rcnn_r50_fpn_8xb1-12e_youtubevis2021.py) | [model](https://download.openmmlab.com/mmtracking/vis/masktrack_rcnn/masktrack_rcnn_r50_fpn_12e_youtubevis2021/masktrack_rcnn_r50_fpn_12e_youtubevis2021_20211026_044948-10da90d9.pth) \| [log](https://download.openmmlab.com/mmtracking/vis/masktrack_rcnn/masktrack_rcnn_r50_fpn_12e_youtubevis2021/masktrack_rcnn_r50_fpn_12e_youtubevis2021_20211026_044948.log.json) | +| MaskTrack R-CNN | Mask R-CNN | R-101-FPN | pytorch | 12e | 2.27 | - | 31.3 | [config](masktrack-rcnn_mask-rcnn_r101_fpn_8xb1-12e_youtubevis2021.py) | [model](https://download.openmmlab.com/mmtracking/vis/masktrack_rcnn/masktrack_rcnn_r101_fpn_12e_youtubevis2021/masktrack_rcnn_r101_fpn_12e_youtubevis2021_20211026_045509-3c49e4f3.pth) \| [log](https://download.openmmlab.com/mmtracking/vis/masktrack_rcnn/masktrack_rcnn_r101_fpn_12e_youtubevis2021/masktrack_rcnn_r101_fpn_12e_youtubevis2021_20211026_045509.log.json) | +| MaskTrack R-CNN | Mask R-CNN | X-101-FPN | pytorch | 12e | 3.69 | - | 33.5 | [config](masktrack-rcnn_mask-rcnn_x101_fpn_8xb1-12e_youtubevis2021.py) | [model](https://download.openmmlab.com/mmtracking/vis/masktrack_rcnn/masktrack_rcnn_x101_fpn_12e_youtubevis2021/masktrack_rcnn_x101_fpn_12e_youtubevis2021_20211026_095943-90831df4.pth) \| [log](https://download.openmmlab.com/mmtracking/vis/masktrack_rcnn/masktrack_rcnn_x101_fpn_12e_youtubevis2021/masktrack_rcnn_x101_fpn_12e_youtubevis2021_20211026_095943.log.json) | + +## Get started + +### 1. Development Environment Setup + +Tracking Development Environment Setup can refer to this [document](../../docs/en/get_started.md). + +### 2. Dataset Prepare + +Tracking Dataset Prepare can refer to this [document](../../docs/en/user_guides/tracking_dataset_prepare.md). + +### 3. Training + +Due to the influence of parameters such as learning rate in default configuration file, we recommend using 8 GPUs for training in order to reproduce accuracy. You can use the following command to start the training. + +```shell +# Training MaskTrack R-CNN on YouTube-VIS-2021 dataset with following command. +# The number after config file represents the number of GPUs used. Here we use 8 GPUs. +bash tools/dist_train.sh configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_r50_fpn_8xb1-12e_youtubevis2021.py 8 +``` + +If you want to know about more detailed usage of `train.py/dist_train.sh/slurm_train.sh`, +please refer to this [document](../../docs/en/user_guides/tracking_train_test.md). + +### 4. Testing and evaluation + +If you want to get the results of the [YouTube-VOS](https://youtube-vos.org/dataset/vis/) val/test set, please use the following command to generate result files that can be used for submission. It will be stored in `./youtube_vis_results.submission_file.zip`, you can modify the saved path in `test_evaluator` of the config. + +```shell +# The number after config file represents the number of GPUs used. +bash tools/dist_test_tracking.sh configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_r50_fpn_8xb1-12e_youtubevis2021.py 8 --checkpoint ${CHECKPOINT_PATH} +``` + +If you want to know about more detailed usage of `train.py/dist_train.sh/slurm_train.sh`, +please refer to this [document](../../docs/en/user_guides/tracking_train_test.md). + +### 5.Inference + +Use a single GPU to predict a video and save it as a video. + +```shell +python demo/mot_demo.py demo/demo_mot.mp4 configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_r50_fpn_8xb1-12e_youtubevis2021.py --checkpoint {CHECKPOINT_PATH} --out vis.mp4 +``` + +If you want to know about more detailed usage of `mot_demo.py`, please refer to this [document](../../docs/en/user_guides/tracking_inference.md). diff --git a/mmdetection/configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_r101_fpn_8xb1-12e_youtubevis2019.py b/mmdetection/configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_r101_fpn_8xb1-12e_youtubevis2019.py new file mode 100644 index 00000000..4be492d5 --- /dev/null +++ b/mmdetection/configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_r101_fpn_8xb1-12e_youtubevis2019.py @@ -0,0 +1,12 @@ +_base_ = ['./masktrack-rcnn_mask-rcnn_r50_fpn_8xb1-12e_youtubevis2019.py'] +model = dict( + detector=dict( + backbone=dict( + depth=101, + init_cfg=dict( + type='Pretrained', checkpoint='torchvision://resnet101')), + init_cfg=dict( + type='Pretrained', + checkpoint= # noqa: E251 + 'https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r101_fpn_1x_coco/mask_rcnn_r101_fpn_1x_coco_20200204-1efe0ed5.pth' # noqa: E501 + ))) diff --git a/mmdetection/configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_r101_fpn_8xb1-12e_youtubevis2021.py b/mmdetection/configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_r101_fpn_8xb1-12e_youtubevis2021.py new file mode 100644 index 00000000..81bae4af --- /dev/null +++ b/mmdetection/configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_r101_fpn_8xb1-12e_youtubevis2021.py @@ -0,0 +1,28 @@ +_base_ = ['./masktrack-rcnn_mask-rcnn_r50_fpn_8xb1-12e_youtubevis2019.py'] +model = dict( + detector=dict( + backbone=dict( + depth=101, + init_cfg=dict( + type='Pretrained', checkpoint='torchvision://resnet101')), + init_cfg=dict( + type='Pretrained', + checkpoint= # noqa: E251 + 'https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r101_fpn_1x_coco/mask_rcnn_r101_fpn_1x_coco_20200204-1efe0ed5.pth' # noqa: E501 + ))) + +data_root = 'data/youtube_vis_2021/' +dataset_version = data_root[-5:-1] + +# dataloader +train_dataloader = dict( + dataset=dict( + data_root=data_root, + dataset_version=dataset_version, + ann_file='annotations/youtube_vis_2021_train.json')) +val_dataloader = dict( + dataset=dict( + data_root=data_root, + dataset_version=dataset_version, + ann_file='annotations/youtube_vis_2021_valid.json')) +test_dataloader = val_dataloader diff --git a/mmdetection/configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_r50_fpn_8xb1-12e_youtubevis2019.py b/mmdetection/configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_r50_fpn_8xb1-12e_youtubevis2019.py new file mode 100644 index 00000000..db1be7b0 --- /dev/null +++ b/mmdetection/configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_r50_fpn_8xb1-12e_youtubevis2019.py @@ -0,0 +1,130 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/youtube_vis.py', '../_base_/default_runtime.py' +] + +detector = _base_.model +detector.pop('data_preprocessor') +detector.roi_head.bbox_head.update(dict(num_classes=40)) +detector.roi_head.mask_head.update(dict(num_classes=40)) +detector.train_cfg.rpn.sampler.update(dict(num=64)) +detector.train_cfg.rpn_proposal.update(dict(nms_pre=200, max_per_img=200)) +detector.train_cfg.rcnn.sampler.update(dict(num=128)) +detector.test_cfg.rpn.update(dict(nms_pre=200, max_per_img=200)) +detector.test_cfg.rcnn.update(dict(score_thr=0.01)) +detector['init_cfg'] = dict( + type='Pretrained', + checkpoint= # noqa: E251 + 'https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_fpn_1x_coco/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth' # noqa: E501 +) +del _base_.model + +model = dict( + type='MaskTrackRCNN', + data_preprocessor=dict( + type='TrackDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_mask=True, + pad_size_divisor=32), + detector=detector, + track_head=dict( + type='RoITrackHead', + roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + embed_head=dict( + type='RoIEmbedHead', + num_fcs=2, + roi_feat_size=7, + in_channels=256, + fc_out_channels=1024), + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0.5, + match_low_quality=True, + ignore_iof_thr=-1), + sampler=dict( + type='RandomSampler', + num=128, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + pos_weight=-1, + debug=False)), + tracker=dict( + type='MaskTrackRCNNTracker', + match_weights=dict(det_score=1.0, iou=2.0, det_label=10.0), + num_frames_retain=20)) + +dataset_type = 'YouTubeVISDataset' +data_root = 'data/youtube_vis_2019/' +dataset_version = data_root[-5:-1] # 2019 or 2021 + +# train_dataloader +train_dataloader = dict( + _delete_=True, + batch_size=1, + num_workers=2, + persistent_workers=True, + sampler=dict(type='TrackImgSampler'), # image-based sampling + batch_sampler=dict(type='TrackAspectRatioBatchSampler'), + dataset=dict( + type=dataset_type, + data_root=data_root, + dataset_version=dataset_version, + ann_file='annotations/youtube_vis_2019_train.json', + data_prefix=dict(img_path='train/JPEGImages'), + pipeline=_base_.train_pipeline)) + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.00125, momentum=0.9, weight_decay=0.0001), + clip_grad=dict(max_norm=35, norm_type=2)) + +# learning policy +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0 / 3.0, + by_epoch=False, + begin=0, + end=500), + dict( + type='MultiStepLR', + begin=0, + end=12, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] + +# visualizer +default_hooks = dict( + visualization=dict(type='TrackVisualizationHook', draw=False)) + +vis_backends = [dict(type='LocalVisBackend')] +visualizer = dict( + type='TrackLocalVisualizer', vis_backends=vis_backends, name='visualizer') + +# runtime settings +train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=12, val_begin=13) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# evaluator +val_evaluator = dict( + type='YouTubeVISMetric', + metric='youtube_vis_ap', + outfile_prefix='./youtube_vis_results', + format_only=True) +test_evaluator = val_evaluator + +del detector diff --git a/mmdetection/configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_r50_fpn_8xb1-12e_youtubevis2021.py b/mmdetection/configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_r50_fpn_8xb1-12e_youtubevis2021.py new file mode 100644 index 00000000..47263d50 --- /dev/null +++ b/mmdetection/configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_r50_fpn_8xb1-12e_youtubevis2021.py @@ -0,0 +1,17 @@ +_base_ = ['./masktrack-rcnn_mask-rcnn_r50_fpn_8xb1-12e_youtubevis2019.py'] + +data_root = 'data/youtube_vis_2021/' +dataset_version = data_root[-5:-1] + +# dataloader +train_dataloader = dict( + dataset=dict( + data_root=data_root, + dataset_version=dataset_version, + ann_file='annotations/youtube_vis_2021_train.json')) +val_dataloader = dict( + dataset=dict( + data_root=data_root, + dataset_version=dataset_version, + ann_file='annotations/youtube_vis_2021_valid.json')) +test_dataloader = val_dataloader diff --git a/mmdetection/configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_x101_fpn_8xb1-12e_youtubevis2019.py b/mmdetection/configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_x101_fpn_8xb1-12e_youtubevis2019.py new file mode 100644 index 00000000..e7e3f11e --- /dev/null +++ b/mmdetection/configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_x101_fpn_8xb1-12e_youtubevis2019.py @@ -0,0 +1,16 @@ +_base_ = ['./masktrack-rcnn_mask-rcnn_r50_fpn_8xb1-12e_youtubevis2019.py'] +model = dict( + detector=dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://resnext101_64x4d')), + init_cfg=dict( + type='Pretrained', + checkpoint= # noqa: E251 + 'https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_64x4d_fpn_1x_coco/mask_rcnn_x101_64x4d_fpn_1x_coco_20200201-9352eb0d.pth' # noqa: E501 + ))) diff --git a/mmdetection/configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_x101_fpn_8xb1-12e_youtubevis2021.py b/mmdetection/configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_x101_fpn_8xb1-12e_youtubevis2021.py new file mode 100644 index 00000000..ea4c8b92 --- /dev/null +++ b/mmdetection/configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_x101_fpn_8xb1-12e_youtubevis2021.py @@ -0,0 +1,32 @@ +_base_ = ['./masktrack-rcnn_mask-rcnn_r50_fpn_8xb1-12e_youtubevis2019.py'] +model = dict( + detector=dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://resnext101_64x4d')), + init_cfg=dict( + type='Pretrained', + checkpoint= # noqa: E251 + 'https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_64x4d_fpn_1x_coco/mask_rcnn_x101_64x4d_fpn_1x_coco_20200201-9352eb0d.pth' # noqa: E501 + ))) + +data_root = 'data/youtube_vis_2021/' +dataset_version = data_root[-5:-1] + +# dataloader +train_dataloader = dict( + dataset=dict( + data_root=data_root, + dataset_version=dataset_version, + ann_file='annotations/youtube_vis_2021_train.json')) +val_dataloader = dict( + dataset=dict( + data_root=data_root, + dataset_version=dataset_version, + ann_file='annotations/youtube_vis_2021_valid.json')) +test_dataloader = val_dataloader diff --git a/mmdetection/configs/masktrack_rcnn/metafile.yml b/mmdetection/configs/masktrack_rcnn/metafile.yml new file mode 100644 index 00000000..7a1d71d5 --- /dev/null +++ b/mmdetection/configs/masktrack_rcnn/metafile.yml @@ -0,0 +1,91 @@ +Collections: + - Name: MaskTrack R-CNN + Metadata: + Training Techniques: + - SGD with Momentum + Training Resources: 8x TiTanXP GPUs + Architecture: + - ResNet + Paper: + URL: https://arxiv.org/pdf/1905.04804.pdf + Title: Video Instance Segmentation + README: configs/masktrack_rcnn/README.md + +Models: + - Name: masktrack-rcnn_mask-rcnn_r50_fpn_8xb1-12e_youtubevis2019 + In Collection: MaskTrack R-CNN + Config: configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_r50_fpn_8xb1-12e_youtubevis2019.py + Metadata: + Training Data: YouTube-VIS 2019 + Training Memory (GB): 1.16 + Results: + - Task: Video Instance Segmentation + Dataset: YouTube-VIS 2019 + Metrics: + AP: 30.2 + Weights: https://download.openmmlab.com/mmtracking/vis/masktrack_rcnn/masktrack_rcnn_r50_fpn_12e_youtubevis2019/masktrack_rcnn_r50_fpn_12e_youtubevis2019_20211022_194830-6ca6b91e.pth + + - Name: masktrack-rcnn_mask-rcnn_r101_fpn_8xb1-12e_youtubevis2019 + In Collection: MaskTrack R-CNN + Config: configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_r101_fpn_8xb1-12e_youtubevis2019.py + Metadata: + Training Data: YouTube-VIS 2019 + Training Memory (GB): 2.27 + Results: + - Task: Video Instance Segmentation + Dataset: YouTube-VIS 2019 + Metrics: + AP: 32.2 + Weights: https://download.openmmlab.com/mmtracking/vis/masktrack_rcnn/masktrack_rcnn_r101_fpn_12e_youtubevis2019/masktrack_rcnn_r101_fpn_12e_youtubevis2019_20211023_150038-454dc48b.pth + + - Name: masktrack-rcnn_mask-rcnn_x101_fpn_8xb1-12e_youtubevis2019 + In Collection: MaskTrack R-CNN + Config: configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_x101_fpn_8xb1-12e_youtubevis2019.py + Metadata: + Training Data: YouTube-VIS 2019 + Training Memory (GB): 3.69 + Results: + - Task: Video Instance Segmentation + Dataset: YouTube-VIS 2019 + Metrics: + AP: 34.7 + Weights: https://download.openmmlab.com/mmtracking/vis/masktrack_rcnn/masktrack_rcnn_x101_fpn_12e_youtubevis2019/masktrack_rcnn_x101_fpn_12e_youtubevis2019_20211023_153205-fff7a102.pth + + - Name: masktrack-rcnn_mask-rcnn_r50_fpn_8xb1-12e_youtubevis2021 + In Collection: MaskTrack R-CNN + Config: configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_r50_fpn_8xb1-12e_youtubevis2021.py + Metadata: + Training Data: YouTube-VIS 2021 + Training Memory (GB): 1.16 + Results: + - Task: Video Instance Segmentation + Dataset: YouTube-VIS 2021 + Metrics: + AP: 28.7 + Weights: https://download.openmmlab.com/mmtracking/vis/masktrack_rcnn/masktrack_rcnn_r50_fpn_12e_youtubevis2021/masktrack_rcnn_r50_fpn_12e_youtubevis2021_20211026_044948-10da90d9.pth + + - Name: masktrack-rcnn_mask-rcnn_r101_fpn_8xb1-12e_youtubevis2021 + In Collection: MaskTrack R-CNN + Config: configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_r101_fpn_8xb1-12e_youtubevis2021.py + Metadata: + Training Data: YouTube-VIS 2021 + Training Memory (GB): 2.27 + Results: + - Task: Video Instance Segmentation + Dataset: YouTube-VIS 2021 + Metrics: + AP: 31.3 + Weights: https://download.openmmlab.com/mmtracking/vis/masktrack_rcnn/masktrack_rcnn_r101_fpn_12e_youtubevis2021/masktrack_rcnn_r101_fpn_12e_youtubevis2021_20211026_045509-3c49e4f3.pth + + - Name: masktrack-rcnn_mask-rcnn_x101_fpn_8xb1-12e_youtubevis2021 + In Collection: MaskTrack R-CNN + Config: configs/masktrack_rcnn/masktrack-rcnn_mask-rcnn_x101_fpn_8xb1-12e_youtubevis2021.py + Metadata: + Training Data: YouTube-VIS 2021 + Training Memory (GB): 3.69 + Results: + - Task: Video Instance Segmentation + Dataset: YouTube-VIS 2021 + Metrics: + AP: 33.5 + Weights: https://download.openmmlab.com/mmtracking/vis/masktrack_rcnn/masktrack_rcnn_x101_fpn_12e_youtubevis2021/masktrack_rcnn_x101_fpn_12e_youtubevis2021_20211026_095943-90831df4.pth diff --git a/mmdetection/configs/misc/d2_faster-rcnn_r50-caffe_fpn_ms-90k_coco.py b/mmdetection/configs/misc/d2_faster-rcnn_r50-caffe_fpn_ms-90k_coco.py new file mode 100644 index 00000000..d93e1562 --- /dev/null +++ b/mmdetection/configs/misc/d2_faster-rcnn_r50-caffe_fpn_ms-90k_coco.py @@ -0,0 +1,75 @@ +_base_ = '../common/ms-90k_coco.py' + +# model settings +model = dict( + type='Detectron2Wrapper', + bgr_to_rgb=False, + detector=dict( + # The settings in `d2_detector` will merged into default settings + # in detectron2. More details please refer to + # https://github.com/facebookresearch/detectron2/blob/main/detectron2/config/defaults.py # noqa + meta_architecture='GeneralizedRCNN', + # If you want to finetune the detector, you can use the + # checkpoint released by detectron2, for example: + # weights='detectron2://COCO-Detection/faster_rcnn_R_50_FPN_1x/137257794/model_final_b275ba.pkl' # noqa + weights='detectron2://ImageNetPretrained/MSRA/R-50.pkl', + mask_on=False, + pixel_mean=[103.530, 116.280, 123.675], + pixel_std=[1.0, 1.0, 1.0], + backbone=dict(name='build_resnet_fpn_backbone', freeze_at=2), + resnets=dict( + depth=50, + out_features=['res2', 'res3', 'res4', 'res5'], + num_groups=1, + norm='FrozenBN'), + fpn=dict( + in_features=['res2', 'res3', 'res4', 'res5'], out_channels=256), + anchor_generator=dict( + name='DefaultAnchorGenerator', + sizes=[[32], [64], [128], [256], [512]], + aspect_ratios=[[0.5, 1.0, 2.0]], + angles=[[-90, 0, 90]]), + proposal_generator=dict(name='RPN'), + rpn=dict( + head_name='StandardRPNHead', + in_features=['p2', 'p3', 'p4', 'p5', 'p6'], + iou_thresholds=[0.3, 0.7], + iou_labels=[0, -1, 1], + batch_size_per_image=256, + positive_fraction=0.5, + bbox_reg_loss_type='smooth_l1', + bbox_reg_loss_weight=1.0, + bbox_reg_weights=(1.0, 1.0, 1.0, 1.0), + smooth_l1_beta=0.0, + loss_weight=1.0, + boundary_thresh=-1, + pre_nms_topk_train=2000, + post_nms_topk_train=1000, + pre_nms_topk_test=1000, + post_nms_topk_test=1000, + nms_thresh=0.7, + conv_dims=[-1]), + roi_heads=dict( + name='StandardROIHeads', + num_classes=80, + in_features=['p2', 'p3', 'p4', 'p5'], + iou_thresholds=[0.5], + iou_labels=[0, 1], + batch_size_per_image=512, + positive_fraction=0.25, + score_thresh_test=0.05, + nms_thresh_test=0.5, + proposal_append_gt=True), + roi_box_head=dict( + name='FastRCNNConvFCHead', + num_fc=2, + fc_dim=1024, + conv_dim=256, + pooler_type='ROIAlignV2', + pooler_resolution=7, + pooler_sampling_ratio=0, + bbox_reg_loss_type='smooth_l1', + bbox_reg_loss_weight=1.0, + bbox_reg_weights=(10.0, 10.0, 5.0, 5.0), + smooth_l1_beta=0.0, + cls_agnostic_bbox_reg=False))) diff --git a/mmdetection/configs/misc/d2_mask-rcnn_r50-caffe_fpn_ms-90k_coco.py b/mmdetection/configs/misc/d2_mask-rcnn_r50-caffe_fpn_ms-90k_coco.py new file mode 100644 index 00000000..c0919c45 --- /dev/null +++ b/mmdetection/configs/misc/d2_mask-rcnn_r50-caffe_fpn_ms-90k_coco.py @@ -0,0 +1,83 @@ +_base_ = '../common/ms-poly-90k_coco-instance.py' + +# model settings +model = dict( + type='Detectron2Wrapper', + bgr_to_rgb=False, + detector=dict( + # The settings in `d2_detector` will merged into default settings + # in detectron2. More details please refer to + # https://github.com/facebookresearch/detectron2/blob/main/detectron2/config/defaults.py # noqa + meta_architecture='GeneralizedRCNN', + # If you want to finetune the detector, you can use the + # checkpoint released by detectron2, for example: + # weights='detectron2://COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_1x/137260431/model_final_a54504.pkl' # noqa + weights='detectron2://ImageNetPretrained/MSRA/R-50.pkl', + mask_on=True, + pixel_mean=[103.530, 116.280, 123.675], + pixel_std=[1.0, 1.0, 1.0], + backbone=dict(name='build_resnet_fpn_backbone', freeze_at=2), + resnets=dict( + depth=50, + out_features=['res2', 'res3', 'res4', 'res5'], + num_groups=1, + norm='FrozenBN'), + fpn=dict( + in_features=['res2', 'res3', 'res4', 'res5'], out_channels=256), + anchor_generator=dict( + name='DefaultAnchorGenerator', + sizes=[[32], [64], [128], [256], [512]], + aspect_ratios=[[0.5, 1.0, 2.0]], + angles=[[-90, 0, 90]]), + proposal_generator=dict(name='RPN'), + rpn=dict( + head_name='StandardRPNHead', + in_features=['p2', 'p3', 'p4', 'p5', 'p6'], + iou_thresholds=[0.3, 0.7], + iou_labels=[0, -1, 1], + batch_size_per_image=256, + positive_fraction=0.5, + bbox_reg_loss_type='smooth_l1', + bbox_reg_loss_weight=1.0, + bbox_reg_weights=(1.0, 1.0, 1.0, 1.0), + smooth_l1_beta=0.0, + loss_weight=1.0, + boundary_thresh=-1, + pre_nms_topk_train=2000, + post_nms_topk_train=1000, + pre_nms_topk_test=1000, + post_nms_topk_test=1000, + nms_thresh=0.7, + conv_dims=[-1]), + roi_heads=dict( + name='StandardROIHeads', + num_classes=80, + in_features=['p2', 'p3', 'p4', 'p5'], + iou_thresholds=[0.5], + iou_labels=[0, 1], + batch_size_per_image=512, + positive_fraction=0.25, + score_thresh_test=0.05, + nms_thresh_test=0.5, + proposal_append_gt=True), + roi_box_head=dict( + name='FastRCNNConvFCHead', + num_fc=2, + fc_dim=1024, + conv_dim=256, + pooler_type='ROIAlignV2', + pooler_resolution=7, + pooler_sampling_ratio=0, + bbox_reg_loss_type='smooth_l1', + bbox_reg_loss_weight=1.0, + bbox_reg_weights=(10.0, 10.0, 5.0, 5.0), + smooth_l1_beta=0.0, + cls_agnostic_bbox_reg=False), + roi_mask_head=dict( + name='MaskRCNNConvUpsampleHead', + conv_dim=256, + num_conv=4, + pooler_type='ROIAlignV2', + pooler_resolution=14, + pooler_sampling_ratio=0, + cls_agnostic_mask=False))) diff --git a/mmdetection/configs/misc/d2_retinanet_r50-caffe_fpn_ms-90k_coco.py b/mmdetection/configs/misc/d2_retinanet_r50-caffe_fpn_ms-90k_coco.py new file mode 100644 index 00000000..d3f75876 --- /dev/null +++ b/mmdetection/configs/misc/d2_retinanet_r50-caffe_fpn_ms-90k_coco.py @@ -0,0 +1,48 @@ +_base_ = '../common/ms-90k_coco.py' + +# model settings +model = dict( + type='Detectron2Wrapper', + bgr_to_rgb=False, + detector=dict( + # The settings in `d2_detector` will merged into default settings + # in detectron2. More details please refer to + # https://github.com/facebookresearch/detectron2/blob/main/detectron2/config/defaults.py # noqa + meta_architecture='RetinaNet', + # If you want to finetune the detector, you can use the + # checkpoint released by detectron2, for example: + # weights='detectron2://COCO-Detection/retinanet_R_50_FPN_1x/190397773/model_final_bfca0b.pkl' # noqa + weights='detectron2://ImageNetPretrained/MSRA/R-50.pkl', + mask_on=False, + pixel_mean=[103.530, 116.280, 123.675], + pixel_std=[1.0, 1.0, 1.0], + backbone=dict(name='build_retinanet_resnet_fpn_backbone', freeze_at=2), + resnets=dict( + depth=50, + out_features=['res3', 'res4', 'res5'], + num_groups=1, + norm='FrozenBN'), + fpn=dict(in_features=['res3', 'res4', 'res5'], out_channels=256), + anchor_generator=dict( + name='DefaultAnchorGenerator', + sizes=[[x, x * 2**(1.0 / 3), x * 2**(2.0 / 3)] + for x in [32, 64, 128, 256, 512]], + aspect_ratios=[[0.5, 1.0, 2.0]], + angles=[[-90, 0, 90]]), + retinanet=dict( + num_classes=80, + in_features=['p3', 'p4', 'p5', 'p6', 'p7'], + num_convs=4, + iou_thresholds=[0.4, 0.5], + iou_labels=[0, -1, 1], + bbox_reg_weights=(1.0, 1.0, 1.0, 1.0), + bbox_reg_loss_type='smooth_l1', + smooth_l1_loss_beta=0.0, + focal_loss_gamma=2.0, + focal_loss_alpha=0.25, + prior_prob=0.01, + score_thresh_test=0.05, + topk_candidates_test=1000, + nms_thresh_test=0.5))) + +optim_wrapper = dict(optimizer=dict(lr=0.01)) diff --git a/mmdetection/configs/mm_grounding_dino/README.md b/mmdetection/configs/mm_grounding_dino/README.md new file mode 100644 index 00000000..c88cb1c9 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/README.md @@ -0,0 +1,387 @@ +# MM Grounding DINO + +> [An Open and Comprehensive Pipeline for Unified Object Grounding and Detection](https://arxiv.org/abs/2401.02361) + + + +## Abstract + +Grounding-DINO is a state-of-the-art open-set detection model that tackles multiple vision tasks including Open-Vocabulary Detection (OVD), Phrase Grounding (PG), and Referring Expression Comprehension (REC). Its effectiveness has led to its widespread adoption as a mainstream architecture for various downstream applications. However, despite its significance, the original Grounding-DINO model lacks comprehensive public technical details due to the unavailability of its training code. To bridge this gap, we present MM-Grounding-DINO, an open-source, comprehensive, and user-friendly baseline, which is built with the MMDetection toolbox. It adopts abundant vision datasets for pre-training and various detection and grounding datasets for fine-tuning. We give a comprehensive analysis of each reported result and detailed settings for reproduction. The extensive experiments on the benchmarks mentioned demonstrate that our MM-Grounding-DINO-Tiny outperforms the Grounding-DINO-Tiny baseline. We release all our models to the research community. + +
    + +
    + +
    + +
    + +## Dataset Preparation + +Please refer to [dataset_prepare.md](dataset_prepare.md) or [中文版数据准备](dataset_prepare_zh-CN.md) + +## ✨ What's New + +💎 **We have released the pre-trained weights for Swin-B and Swin-L, welcome to try and give feedback.** + +## Usage + +Please refer to [usage.md](usage.md) or [中文版用法说明](usage_zh-CN.md) + +## Zero-Shot COCO Results and Models + +| Model | Backbone | Style | COCO mAP | Pre-Train Data | Config | Download | +| :----------: | :------: | :-------: | :--------: | :----------------------: | :------------------------------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| GDINO-T | Swin-T | Zero-shot | 46.7 | O365 | | | +| GDINO-T | Swin-T | Zero-shot | 48.1 | O365,GoldG | | | +| GDINO-T | Swin-T | Zero-shot | 48.4 | O365,GoldG,Cap4M | [config](../grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_cap4m.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/grounding_dino/groundingdino_swint_ogc_mmdet-822d7e9d.pth) | +| MM-GDINO-T | Swin-T | Zero-shot | 48.5(+1.8) | O365 | [config](grounding_dino_swin-t_pretrain_obj365.py) | | +| MM-GDINO-T | Swin-T | Zero-shot | 50.4(+2.3) | O365,GoldG | [config](grounding_dino_swin-t_pretrain_obj365_goldg.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg/grounding_dino_swin-t_pretrain_obj365_goldg_20231122_132602-4ea751ce.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg/grounding_dino_swin-t_pretrain_obj365_goldg_20231122_132602.log.json) | +| MM-GDINO-T | Swin-T | Zero-shot | 50.5(+2.1) | O365,GoldG,GRIT | [config](grounding_dino_swin-t_pretrain_obj365_goldg_grit9m.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_20231128_200818-169cc352.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_20231128_200818.log.json) | +| MM-GDINO-T | Swin-T | Zero-shot | 50.6(+2.2) | O365,GoldG,V3Det | [config](grounding_dino_swin-t_pretrain_obj365_goldg_v3det.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_v3det/grounding_dino_swin-t_pretrain_obj365_goldg_v3det_20231218_095741-e316e297.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_v3det/grounding_dino_swin-t_pretrain_obj365_goldg_v3det_20231218_095741.log.json) | +| MM-GDINO-T | Swin-T | Zero-shot | 50.4(+2.0) | O365,GoldG,GRIT,V3Det | [config](grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047.log.json) | +| MM-GDINO-B | Swin-B | Zero-shot | 52.5 | O365,GoldG,V3Det | [config](grounding_dino_swin-b_pretrain_obj365_goldg_v3det.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-b_pretrain_obj365_goldg_v3det/grounding_dino_swin-b_pretrain_obj365_goldg_v3de-f83eef00.pth) \| [log](<>) | +| MM-GDINO-B\* | Swin-B | - | 59.5 | O365,ALL | [config](grounding_dino_swin-b_pretrain_all.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-b_pretrain_all/grounding_dino_swin-b_pretrain_all-f9818a7c.pth) \| [log](<>) | +| MM-GDINO-L | Swin-L | Zero-shot | 53.0 | O365V2,OpenImageV6,GoldG | [config](grounding_dino_swin-l_pretrain_obj365_goldg.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-l_pretrain_obj365_goldg/grounding_dino_swin-l_pretrain_obj365_goldg-34dcdc53.pth) \| [log](<>) | +| MM-GDINO-L\* | Swin-L | - | 60.3 | O365V2,OpenImageV6,ALL | [config](grounding_dino_swin-l_pretrain_all.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-l_pretrain_all/grounding_dino_swin-l_pretrain_all-56d69e78.pth) \| [log](<>) | + +- This * indicates that the model has not been fully trained yet. We will release the final weights in the future. +- ALL: GoldG,V3det,COCO2017,LVISV1,COCO2014,GRIT,RefCOCO,RefCOCO+,RefCOCOg,gRefCOCO. + +## Zero-Shot LVIS Results + +| Model | MiniVal APr | MiniVal APc | MiniVal APf | MiniVal AP | Val1.0 APr | Val1.0 APc | Val1.0 APf | Val1.0 AP | Pre-Train Data | +| :--------: | :---------: | :---------: | :---------: | :---------: | :--------: | :--------: | :--------: | :---------: | :-------------------: | +| GDINO-T | 18.8 | 24.2 | 34.7 | 28.8 | 10.1 | 15.3 | 29.9 | 20.1 | O365,GoldG,Cap4M | +| MM-GDINO-T | 28.1 | 30.2 | 42.0 | 35.7(+6.9) | 17.1 | 22.4 | 36.5 | 27.0(+6.9) | O365,GoldG | +| MM-GDINO-T | 26.6 | 32.4 | 41.8 | 36.5(+7.7) | 17.3 | 22.6 | 36.4 | 27.1(+7.0) | O365,GoldG,GRIT | +| MM-GDINO-T | 33.0 | 36.0 | 45.9 | 40.5(+11.7) | 21.5 | 25.5 | 40.2 | 30.6(+10.5) | O365,GoldG,V3Det | +| MM-GDINO-T | 34.2 | 37.4 | 46.2 | 41.4(+12.6) | 23.6 | 27.6 | 40.5 | 31.9(+11.8) | O365,GoldG,GRIT,V3Det | + +- The MM-GDINO-T config file is [mini-lvis](lvis/grounding_dino_swin-t_pretrain_zeroshot_mini-lvis.py) and [lvis 1.0](lvis/grounding_dino_swin-t_pretrain_zeroshot_lvis.py) + +## Zero-Shot ODinW (Object Detection in the Wild) Results + +### Results and models of ODinW13 + +| Method | GDINO-T
    (O365,GoldG,Cap4M) | MM-GDINO-T
    (O365,GoldG) | MM-GDINO-T
    (O365,GoldG,GRIT) | MM-GDINO-T
    (O365,GoldG,V3Det) | MM-GDINO-T
    (O365,GoldG,GRIT,V3Det) | +| --------------------- | -------------------------------- | ----------------------------- | ---------------------------------- | ----------------------------------- | ---------------------------------------- | +| AerialMaritimeDrone | 0.173 | 0.133 | 0.155 | 0.177 | 0.151 | +| Aquarium | 0.195 | 0.252 | 0.261 | 0.266 | 0.283 | +| CottontailRabbits | 0.799 | 0.771 | 0.810 | 0.778 | 0.786 | +| EgoHands | 0.608 | 0.499 | 0.537 | 0.506 | 0.519 | +| NorthAmericaMushrooms | 0.507 | 0.331 | 0.462 | 0.669 | 0.767 | +| Packages | 0.687 | 0.707 | 0.687 | 0.710 | 0.706 | +| PascalVOC | 0.563 | 0.565 | 0.580 | 0.556 | 0.566 | +| pistols | 0.726 | 0.585 | 0.709 | 0.671 | 0.729 | +| pothole | 0.215 | 0.136 | 0.285 | 0.199 | 0.243 | +| Raccoon | 0.549 | 0.469 | 0.511 | 0.553 | 0.535 | +| ShellfishOpenImages | 0.393 | 0.321 | 0.437 | 0.519 | 0.488 | +| thermalDogsAndPeople | 0.657 | 0.556 | 0.603 | 0.493 | 0.542 | +| VehiclesOpenImages | 0.613 | 0.566 | 0.603 | 0.614 | 0.615 | +| Average | **0.514** | **0.453** | **0.511** | **0.516** | **0.533** | + +- The MM-GDINO-T config file is [odinw13](odinw/grounding_dino_swin-t_pretrain_odinw13.py) + +### Results and models of ODinW35 + +| Method | GDINO-T
    (O365,GoldG,Cap4M) | MM-GDINO-T
    (O365,GoldG) | MM-GDINO-T
    (O365,GoldG,GRIT) | MM-GDINO-T
    (O365,GoldG,V3Det) | MM-GDINO-T
    (O365,GoldG,GRIT,V3Det) | +| --------------------------- | -------------------------------- | ----------------------------- | ---------------------------------- | ----------------------------------- | ---------------------------------------- | +| AerialMaritimeDrone_large | 0.173 | 0.133 | 0.155 | 0.177 | 0.151 | +| AerialMaritimeDrone_tiled | 0.206 | 0.170 | 0.225 | 0.184 | 0.206 | +| AmericanSignLanguageLetters | 0.002 | 0.016 | 0.020 | 0.011 | 0.007 | +| Aquarium | 0.195 | 0.252 | 0.261 | 0.266 | 0.283 | +| BCCD | 0.161 | 0.069 | 0.118 | 0.083 | 0.077 | +| boggleBoards | 0.000 | 0.002 | 0.001 | 0.001 | 0.002 | +| brackishUnderwater | 0.021 | 0.033 | 0.021 | 0.025 | 0.025 | +| ChessPieces | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | +| CottontailRabbits | 0.806 | 0.771 | 0.810 | 0.778 | 0.786 | +| dice | 0.004 | 0.002 | 0.005 | 0.001 | 0.001 | +| DroneControl | 0.042 | 0.047 | 0.097 | 0.088 | 0.074 | +| EgoHands_generic | 0.608 | 0.527 | 0.537 | 0.506 | 0.519 | +| EgoHands_specific | 0.002 | 0.001 | 0.005 | 0.007 | 0.003 | +| HardHatWorkers | 0.046 | 0.048 | 0.070 | 0.070 | 0.108 | +| MaskWearing | 0.004 | 0.009 | 0.004 | 0.011 | 0.009 | +| MountainDewCommercial | 0.430 | 0.453 | 0.465 | 0.194 | 0.430 | +| NorthAmericaMushrooms | 0.471 | 0.331 | 0.462 | 0.669 | 0.767 | +| openPoetryVision | 0.000 | 0.001 | 0.000 | 0.000 | 0.000 | +| OxfordPets_by_breed | 0.003 | 0.002 | 0.004 | 0.006 | 0.004 | +| OxfordPets_by_species | 0.011 | 0.019 | 0.016 | 0.020 | 0.015 | +| PKLot | 0.001 | 0.004 | 0.002 | 0.008 | 0.007 | +| Packages | 0.695 | 0.707 | 0.687 | 0.710 | 0.706 | +| PascalVOC | 0.563 | 0.565 | 0.580 | 0.566 | 0.566 | +| pistols | 0.726 | 0.585 | 0.709 | 0.671 | 0.729 | +| plantdoc | 0.005 | 0.005 | 0.007 | 0.008 | 0.011 | +| pothole | 0.215 | 0.136 | 0.219 | 0.077 | 0.168 | +| Raccoons | 0.549 | 0.469 | 0.511 | 0.553 | 0.535 | +| selfdrivingCar | 0.089 | 0.091 | 0.076 | 0.094 | 0.083 | +| ShellfishOpenImages | 0.393 | 0.321 | 0.437 | 0.519 | 0.488 | +| ThermalCheetah | 0.087 | 0.063 | 0.081 | 0.030 | 0.045 | +| thermalDogsAndPeople | 0.657 | 0.556 | 0.603 | 0.493 | 0.543 | +| UnoCards | 0.006 | 0.012 | 0.010 | 0.009 | 0.005 | +| VehiclesOpenImages | 0.613 | 0.566 | 0.603 | 0.614 | 0.615 | +| WildfireSmoke | 0.134 | 0.106 | 0.154 | 0.042 | 0.127 | +| websiteScreenshots | 0.012 | 0.02 | 0.016 | 0.016 | 0.016 | +| Average | **0.227** | **0.202** | **0.228** | **0.214** | **0.284** | + +- The MM-GDINO-T config file is [odinw35](odinw/grounding_dino_swin-t_pretrain_odinw35.py) + +## Zero-Shot Referring Expression Comprehension Results + +| Method | GDINO-T
    (O365,GoldG,Cap4M) | MM-GDINO-T
    (O365,GoldG) | MM-GDINO-T
    (O365,GoldG,GRIT) | MM-GDINO-T
    (O365,GoldG,V3Det) | MM-GDINO-T
    (O365,GoldG,GRIT,V3Det) | +| ---------------------- | -------------------------------- | ----------------------------- | ---------------------------------- | ----------------------------------- | ---------------------------------------- | +| RefCOCO val @1,5,10 | 50.8/89.5/94.9 | 53.1/89.9/94.7 | 53.4/90.3/95.5 | 52.1/89.8/95.0 | 53.1/89.7/95.1 | +| RefCOCO testA @1,5,10 | 57.4/91.3/95.6 | 59.7/91.5/95.9 | 58.8/91.70/96.2 | 58.4/86.8/95.6 | 59.1/91.0/95.5 | +| RefCOCO testB @1,5,10 | 45.0/86.5/92.9 | 46.4/86.9/92.2 | 46.8/87.7/93.3 | 45.4/86.2/92.6 | 46.8/87.8/93.6 | +| RefCOCO+ val @1,5,10 | 51.6/86.4/92.6 | 53.1/87.0/92.8 | 53.5/88.0/93.7 | 52.5/86.8/93.2 | 52.7/87.7/93.5 | +| RefCOCO+ testA @1,5,10 | 57.3/86.7/92.7 | 58.9/87.3/92.9 | 59.0/88.1/93.7 | 58.1/86.7/93.5 | 58.7/87.2/93.1 | +| RefCOCO+ testB @1,5,10 | 46.4/84.1/90.7 | 47.9/84.3/91.0 | 47.9/85.5/92.7 | 46.9/83.7/91.5 | 48.4/85.8/92.1 | +| RefCOCOg val @1,5,10 | 60.4/92.1/96.2 | 61.2/92.6/96.1 | 62.7/93.3/97.0 | 61.7/92.9/96.6 | 62.9/93.3/97.2 | +| RefCOCOg test @1,5,10 | 59.7/92.1/96.3 | 61.1/93.3/96.7 | 62.6/94.9/97.1 | 61.0/93.1/96.8 | 62.9/93.9/97.4 | + +| Method | thresh_score | GDINO-T
    (O365,GoldG,Cap4M) | MM-GDINO-T
    (O365,GoldG) | MM-GDINO-T
    (O365,GoldG,GRIT) | MM-GDINO-T
    (O365,GoldG,V3Det) | MM-GDINO-T
    (O365,GoldG,GRIT,V3Det) | +| --------------------------------------- | ------------ | -------------------------------- | ----------------------------- | ---------------------------------- | ----------------------------------- | ---------------------------------------- | +| gRefCOCO val Pr@(F1=1, IoU≥0.5),N-acc | 0.5 | 39.3/70.4 | | | | 39.4/67.5 | +| gRefCOCO val Pr@(F1=1, IoU≥0.5),N-acc | 0.6 | 40.5/83.8 | | | | 40.6/83.1 | +| gRefCOCO val Pr@(F1=1, IoU≥0.5),N-acc | 0.7 | 41.3/91.8 | 39.8/84.7 | 40.7/89.7 | 40.3/88.8 | 41.0/91.3 | +| gRefCOCO val Pr@(F1=1, IoU≥0.5),N-acc | 0.8 | 41.5/96.8 | | | | 41.1/96.4 | +| gRefCOCO testA Pr@(F1=1, IoU≥0.5),N-acc | 0.5 | 31.9/70.4 | | | | 33.1/69.5 | +| gRefCOCO testA Pr@(F1=1, IoU≥0.5),N-acc | 0.6 | 29.3/82.9 | | | | 29.2/84.3 | +| gRefCOCO testA Pr@(F1=1, IoU≥0.5),N-acc | 0.7 | 27.2/90.2 | 26.3/89.0 | 26.0/91.9 | 25.4/91.8 | 26.1/93.0 | +| gRefCOCO testA Pr@(F1=1, IoU≥0.5),N-acc | 0.8 | 25.1/96.3 | | | | 23.8/97.2 | +| gRefCOCO testB Pr@(F1=1, IoU≥0.5),N-acc | 0.5 | 30.9/72.5 | | | | 33.0/69.6 | +| gRefCOCO testB Pr@(F1=1, IoU≥0.5),N-acc | 0.6 | 30.0/86.1 | | | | 31.6/96.7 | +| gRefCOCO testB Pr@(F1=1, IoU≥0.5),N-acc | 0.7 | 29.7/93.5 | 31.3/84.8 | 30.6/90.2 | 30.7/89.9 | 30.4/92.3 | +| gRefCOCO testB Pr@(F1=1, IoU≥0.5),N-acc | 0.8 | 29.1/97.4 | | | | 29.5/84.2 | + +- The MM-GDINO-T config file is [here](refcoco/grounding_dino_swin-t_pretrain_zeroshot_refexp.py) + +## Zero-Shot Description Detection Dataset(DOD) + +```shell +pip install ddd-dataset +``` + +| Method | mode | GDINO-T
    (O365,GoldG,Cap4M) | MM-GDINO-T
    (O365,GoldG) | MM-GDINO-T
    (O365,GoldG,GRIT) | MM-GDINO-T
    (O365,GoldG,V3Det) | MM-GDINO-T
    (O365,GoldG,GRIT,V3Det) | +| -------------------------------- | -------- | -------------------------------- | ----------------------------- | ---------------------------------- | ----------------------------------- | ---------------------------------------- | +| FULL/short/middle/long/very long | concat | 17.2/18.0/18.7/14.8/16.3 | 15.6/17.3/16.7/14.3/13.1 | 17.0/17.7/18.0/15.7/15.7 | 16.2/17.4/16.8/14.9/15.4 | 17.5/23.4/18.3/14.7/13.8 | +| FULL/short/middle/long/very long | parallel | 22.3/28.2/24.8/19.1/13.9 | 21.7/24.7/24.0/20.2/13.7 | 22.5/25.6/25.1/20.5/14.9 | 22.3/25.6/24.5/20.6/14.7 | 22.9/28.1/25.4/20.4/14.4 | +| PRES/short/middle/long/very long | concat | 17.8/18.3/19.2/15.2/17.3 | 16.4/18.4/17.3/14.5/14.2 | 17.9/19.0/18.3/16.5/17.5 | 16.6/18.8/17.1/15.1/15.0 | 18.0/23.7/18.6/15.4/13.3 | +| PRES/short/middle/long/very long | parallel | 21.0/27.0/22.8/17.5/12.5 | 21.3/25.5/22.8/19.2/12.9 | 21.5/25.2/23.0/19.0/15.0 | 21.6/25.7/23.0/19.5/14.8 | 21.9/27.4/23.2/19.1/14.2 | +| ABS/short/middle/long/very long | concat | 15.4/17.1/16.4/13.6/14.9 | 13.4/13.4/14.5/13.5/11.9 | 14.5/13.1/16.7/13.6/13.3 | 14.8/12.5/15.6/14.3/15.8 | 15.9/22.2/17.1/12.5/14.4 | +| ABS/short/middle/long/very long | parallel | 26.0/32.0/33.0/23.6/15.5 | 22.8/22.2/28.7/22.9/14.7 | 25.6/26.8/33.9/24.5/14.7 | 24.1/24.9/30.7/23.8/14.7 | 26.0/30.3/34.1/23.9/14.6 | + +Note: + +1. Considering that the evaluation time for Inter-scenario is very long and the performance is low, it is temporarily not supported. The mentioned metrics are for Intra-scenario. +2. `concat` is the default inference mode for Grounding DINO, where it concatenates multiple sub-sentences with "." to form a single sentence for inference. On the other hand, "parallel" performs inference on each sub-sentence in a for-loop. +3. The MM-GDINO-T config file is [concat_dod](dod/grounding_dino_swin-t_pretrain_zeroshot_concat_dod.py) and [parallel_dod](dod/grounding_dino_swin-t_pretrain_zeroshot_parallel_dod.py) + +## Pretrain Flickr30k Results + +| Model | Pre-Train Data | Val R@1 | Val R@5 | Val R@10 | Test R@1 | Test R@5 | Test R@10 | +| :--------: | :-------------------: | ------- | ------- | -------- | -------- | -------- | --------- | +| GLIP-T | O365,GoldG | 84.9 | 94.9 | 96.3 | 85.6 | 95.4 | 96.7 | +| GLIP-T | O365,GoldG,CC3M,SBU | 85.3 | 95.5 | 96.9 | 86.0 | 95.9 | 97.2 | +| GDINO-T | O365,GoldG,Cap4M | 87.8 | 96.6 | 98.0 | 88.1 | 96.9 | 98.2 | +| MM-GDINO-T | O365,GoldG | 85.5 | 95.6 | 97.2 | 86.2 | 95.7 | 97.4 | +| MM-GDINO-T | O365,GoldG,GRIT | 86.7 | 95.8 | 97.6 | 87.0 | 96.2 | 97.7 | +| MM-GDINO-T | O365,GoldG,V3Det | 85.9 | 95.7 | 97.4 | 86.3 | 95.7 | 97.4 | +| MM-GDINO-T | O365,GoldG,GRIT,V3Det | 86.7 | 96.0 | 97.6 | 87.2 | 96.2 | 97.7 | + +Note: + +1. `@1,5,10` refers to precision at the top 1, 5, and 10 positions in a predicted ranked list. +2. The MM-GDINO-T config file is [here](flickr30k/grounding_dino_swin-t-pretrain_flickr30k.py) + +## Validating the generalization of a pre-trained model through fine-tuning + +### RTTS + +| Architecture | Backbone | Lr schd | box AP | +| :-----------------: | :------: | ------- | -------- | +| Faster R-CNN | R-50 | 1x | 48.1 | +| Cascade R-CNN | R-50 | 1x | 50.8 | +| ATSS | R-50 | 1x | 48.2 | +| TOOD | R-50 | 1X | 50.8 | +| MM-GDINO(zero-shot) | Swin-T | | 49.8 | +| MM-GDINO | Swin-T | 1x | **69.1** | + +- The reference metrics come from https://github.com/BIGWangYuDong/lqit/tree/main/configs/detection/rtts_dataset +- The MM-GDINO-T config file is [here](rtts/grounding_dino_swin-t_finetune_8xb4_1x_rtts.py) + +### RUOD + +| Architecture | Backbone | Lr schd | box AP | +| :-----------------: | :------: | ------- | -------- | +| Faster R-CNN | R-50 | 1x | 52.4 | +| Cascade R-CNN | R-50 | 1x | 55.3 | +| ATSS | R-50 | 1x | 55.7 | +| TOOD | R-50 | 1X | 57.4 | +| MM-GDINO(zero-shot) | Swin-T | | 29.8 | +| MM-GDINO | Swin-T | 1x | **65.5** | + +- The reference metrics come from https://github.com/BIGWangYuDong/lqit/tree/main/configs/detection/ruod_dataset +- The MM-GDINO-T config file is [here](ruod/grounding_dino_swin-t_finetune_8xb4_1x_ruod.py) + +### Brain Tumor + +| Architecture | Backbone | Lr schd | box AP | +| :-----------: | :------: | ------- | ------ | +| Faster R-CNN | R-50 | 50e | 43.5 | +| Cascade R-CNN | R-50 | 50e | 46.2 | +| DINO | R-50 | 50e | 46.4 | +| Cascade-DINO | R-50 | 50e | 48.6 | +| MM-GDINO | Swin-T | 50e | 47.5 | + +- The reference metrics come from https://arxiv.org/abs/2307.11035 +- The MM-GDINO-T config file is [here](brain_tumor/grounding_dino_swin-t_finetune_8xb4_50e_brain_tumor.py) + +### Cityscapes + +| Architecture | Backbone | Lr schd | box AP | +| :-----------------: | :------: | ------- | -------- | +| Faster R-CNN | R-50 | 50e | 30.1 | +| Cascade R-CNN | R-50 | 50e | 31.8 | +| DINO | R-50 | 50e | 34.5 | +| Cascade-DINO | R-50 | 50e | 34.8 | +| MM-GDINO(zero-shot) | Swin-T | | 34.2 | +| MM-GDINO | Swin-T | 50e | **51.5** | + +- The reference metrics come from https://arxiv.org/abs/2307.11035 +- The MM-GDINO-T config file is [here](cityscapes/grounding_dino_swin-t_finetune_8xb4_50e_cityscapes.py) + +### People in Painting + +| Architecture | Backbone | Lr schd | box AP | +| :-----------------: | :------: | ------- | -------- | +| Faster R-CNN | R-50 | 50e | 17.0 | +| Cascade R-CNN | R-50 | 50e | 18.0 | +| DINO | R-50 | 50e | 12.0 | +| Cascade-DINO | R-50 | 50e | 13.4 | +| MM-GDINO(zero-shot) | Swin-T | | 23.1 | +| MM-GDINO | Swin-T | 50e | **38.9** | + +- The reference metrics come from https://arxiv.org/abs/2307.11035 +- The MM-GDINO-T config file is [here](people_in_painting/grounding_dino_swin-t_finetune_8xb4_50e_people_in_painting.py) + +### COCO + +**(1) Closed-set performance** + +| Architecture | Backbone | Lr schd | box AP | +| :-----------------: | :------: | ------- | ------ | +| Faster R-CNN | R-50 | 1x | 37.4 | +| Cascade R-CNN | R-50 | 1x | 40.3 | +| ATSS | R-50 | 1x | 39.4 | +| TOOD | R-50 | 1X | 42.4 | +| DINO | R-50 | 1X | 50.1 | +| GLIP(zero-shot) | Swin-T | | 46.6 | +| GDINO(zero-shot) | Swin-T | | 48.5 | +| MM-GDINO(zero-shot) | Swin-T | | 50.4 | +| GLIP | Swin-T | 1x | 55.4 | +| GDINO | Swin-T | 1x | 58.1 | +| MM-GDINO | Swin-T | 1x | 58.2 | + +- The MM-GDINO-T config file is [here](coco/grounding_dino_swin-t_finetune_16xb4_1x_coco.py) + +**(2) Open-set continuing pretraining performance** + +| Architecture | Backbone | Lr schd | box AP | +| :-----------------: | :------: | :-----: | :----: | +| GLIP(zero-shot) | Swin-T | | 46.7 | +| GDINO(zero-shot) | Swin-T | | 48.5 | +| MM-GDINO(zero-shot) | Swin-T | | 50.4 | +| MM-GDINO | Swin-T | 1x | 54.7 | + +- The MM-GDINO-T config file is [here](coco/grounding_dino_swin-t_finetune_16xb4_1x_sft_coco.py) +- Due to the small size of the COCO dataset, continuing pretraining solely on COCO can easily lead to overfitting. The results shown above are from the third epoch. I do not recommend you train using this approach. + +**(3) Open vocabulary performance** + +| Architecture | Backbone | Lr schd | box AP | Base box AP | Novel box AP | box AP@50 | Base box AP@50 | Novel box AP@50 | +| :-----------------: | :------: | :-----: | :----: | :---------: | :----------: | :-------: | :------------: | :-------------: | +| MM-GDINO(zero-shot) | Swin-T | | 51.1 | 48.4 | 58.9 | 66.7 | 64.0 | 74.2 | +| MM-GDINO | Swin-T | 1x | 57.2 | 56.1 | 60.4 | 73.6 | 73.0 | 75.3 | + +- The MM-GDINO-T config file is [here](coco/grounding_dino_swin-t_finetune_16xb4_1x_coco_48_17.py) + +### LVIS 1.0 + +**(1) Open-set continuing pretraining performance** + +| Architecture | Backbone | Lr schd | MiniVal APr | MiniVal APc | MiniVal APf | MiniVal AP | Val1.0 APr | Val1.0 APc | Val1.0 APf | Val1.0 AP | +| :-----------------: | :------: | :-----: | :---------: | :---------: | :---------: | :--------: | :--------: | :--------: | :--------: | :-------: | +| GLIP(zero-shot) | Swin-T | | 18.1 | 21.2 | 33.1 | 26.7 | 10.8 | 14.7 | 29.0 | 19.6 | +| GDINO(zero-shot) | Swin-T | | 18.8 | 24.2 | 34.7 | 28.8 | 10.1 | 15.3 | 29.9 | 20.1 | +| MM-GDINO(zero-shot) | Swin-T | | 34.2 | 37.4 | 46.2 | 41.4 | 23.6 | 27.6 | 40.5 | 31.9 | +| MM-GDINO | Swin-T | 1x | 50.7 | 58.8 | 60.1 | 58.7 | 45.2 | 50.2 | 56.1 | 51.7 | + +- The MM-GDINO-T config file is [here](lvis/grounding_dino_swin-t_finetune_16xb4_1x_lvis.py) + +**(2) Open vocabulary performance** + +| Architecture | Backbone | Lr schd | MiniVal APr | MiniVal APc | MiniVal APf | MiniVal AP | +| :-----------------: | :------: | :-----: | :---------: | :---------: | :---------: | :--------: | +| MM-GDINO(zero-shot) | Swin-T | | 34.2 | 37.4 | 46.2 | 41.4 | +| MM-GDINO | Swin-T | 1x | 43.2 | 57.4 | 59.3 | 57.1 | + +- The MM-GDINO-T config file is [here](lvis/grounding_dino_swin-t_finetune_16xb4_1x_lvis_866_337.py) + +### RefEXP + +#### RefCOCO + +| Architecture | Backbone | Lr schd | val @1 | val @5 | val @10 | testA @1 | testA @5 | testA @10 | testB @1 | testB @5 | testB @10 | +| :-----------------: | :------: | :-----: | :----: | :----: | :-----: | :------: | :------: | :-------: | :------: | :------: | :-------: | +| GDINO(zero-shot) | Swin-T | | 50.8 | 89.5 | 94.9 | 57.5 | 91.3 | 95.6 | 45.0 | 86.5 | 92.9 | +| MM-GDINO(zero-shot) | Swin-T | | 53.1 | 89.7 | 95.1 | 59.1 | 91.0 | 95.5 | 46.8 | 87.8 | 93.6 | +| GDINO | Swin-T | UNK | 89.2 | | | 91.9 | | | 86.0 | | | +| MM-GDINO | Swin-T | 5e | 89.5 | 98.6 | 99.4 | 91.4 | 99.2 | 99.8 | 86.6 | 97.9 | 99.1 | + +- The MM-GDINO-T config file is [here](refcoco/grounding_dino_swin-t_finetune_8xb4_5e_refcoco.py) + +#### RefCOCO+ + +| Architecture | Backbone | Lr schd | val @1 | val @5 | val @10 | testA @1 | testA @5 | testA @10 | testB @1 | testB @5 | testB @10 | +| :-----------------: | :------: | :-----: | :----: | :----: | :-----: | :------: | :------: | :-------: | :------: | :------: | :-------: | +| GDINO(zero-shot) | Swin-T | | 51.6 | 86.4 | 92.6 | 57.3 | 86.7 | 92.7 | 46.4 | 84.1 | 90.7 | +| MM-GDINO(zero-shot) | Swin-T | | 52.7 | 87.7 | 93.5 | 58.7 | 87.2 | 93.1 | 48.4 | 85.8 | 92.1 | +| GDINO | Swin-T | UNK | 81.1 | | | 87.4 | | | 74.7 | | | +| MM-GDINO | Swin-T | 5e | 82.1 | 97.8 | 99.2 | 87.5 | 99.2 | 99.7 | 74.0 | 96.3 | 96.4 | + +- The MM-GDINO-T config file is [here](refcoco/grounding_dino_swin-t_finetune_8xb4_5e_refcoco_plus.py) + +#### RefCOCOg + +| Architecture | Backbone | Lr schd | val @1 | val @5 | val @10 | test @1 | test @5 | test @10 | +| :-----------------: | :------: | :-----: | :----: | :----: | :-----: | :-----: | :-----: | :------: | +| GDINO(zero-shot) | Swin-T | | 60.4 | 92.1 | 96.2 | 59.7 | 92.1 | 96.3 | +| MM-GDINO(zero-shot) | Swin-T | | 62.9 | 93.3 | 97.2 | 62.9 | 93.9 | 97.4 | +| GDINO | Swin-T | UNK | 84.2 | | | 84.9 | | | +| MM-GDINO | Swin-T | 5e | 85.5 | 98.4 | 99.4 | 85.8 | 98.6 | 99.4 | + +- The MM-GDINO-T config file is [here](refcoco/grounding_dino_swin-t_finetune_8xb4_5e_refcocog.py) + +#### gRefCOCO + +| Architecture | Backbone | Lr schd | val Pr@(F1=1, IoU≥0.5) | val N-acc | testA Pr@(F1=1, IoU≥0.5) | testA N-acc | testB Pr@(F1=1, IoU≥0.5) | testB N-acc | +| :-----------------: | :------: | :-----: | :--------------------: | :-------: | :----------------------: | :---------: | :----------------------: | :---------: | +| GDINO(zero-shot) | Swin-T | | 41.3 | 91.8 | 27.2 | 90.2 | 29.7 | 93.5 | +| MM-GDINO(zero-shot) | Swin-T | | 41.0 | 91.3 | 26.1 | 93.0 | 30.4 | 92.3 | +| MM-GDINO | Swin-T | 5e | 45.1 | 64.7 | 42.5 | 65.5 | 40.3 | 63.2 | + +- The MM-GDINO-T config file is [here](refcoco/grounding_dino_swin-t_finetune_8xb4_5e_grefcoco.py) + +## Citation + +If you find this project useful in your research, please consider citing: + +```latex +@article{zhao2024open, + title={An Open and Comprehensive Pipeline for Unified Object Grounding and Detection}, + author={Zhao, Xiangyu and Chen, Yicheng and Xu, Shilin and Li, Xiangtai and Wang, Xinjiang and Li, Yining and Huang, Haian}, + journal={arXiv preprint arXiv:2401.02361}, + year={2024} +} +``` diff --git a/mmdetection/configs/mm_grounding_dino/brain_tumor/grounding_dino_swin-t_finetune_8xb4_50e_brain_tumor.py b/mmdetection/configs/mm_grounding_dino/brain_tumor/grounding_dino_swin-t_finetune_8xb4_50e_brain_tumor.py new file mode 100644 index 00000000..1172da5b --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/brain_tumor/grounding_dino_swin-t_finetune_8xb4_50e_brain_tumor.py @@ -0,0 +1,112 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365.py' + +# https://universe.roboflow.com/roboflow-100/brain-tumor-m2pbp/dataset/2 +data_root = 'data/brain_tumor_v2/' +class_name = ('label0', 'label1', 'label2') +label_name = '_annotations.coco.json' + +palette = [(220, 20, 60), (255, 0, 0), (0, 0, 142)] + +metainfo = dict(classes=class_name, palette=palette) + +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities')) +] + +train_dataloader = dict( + sampler=dict(_delete_=True, type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + _delete_=True, + type='RepeatDataset', + times=10, + dataset=dict( + type='CocoDataset', + data_root=data_root, + metainfo=metainfo, + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline, + return_classes=True, + data_prefix=dict(img='train/'), + ann_file='train/' + label_name))) + +val_dataloader = dict( + dataset=dict( + metainfo=metainfo, + data_root=data_root, + return_classes=True, + ann_file='valid/' + label_name, + data_prefix=dict(img='valid/'))) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'valid/' + label_name, + metric='bbox', + format_only=False) +test_evaluator = val_evaluator + +optim_wrapper = dict( + _delete_=True, + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0001), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict(custom_keys={ + 'absolute_pos_embed': dict(decay_mult=0.), + 'backbone': dict(lr_mult=0.1) + })) + +# learning policy +max_epochs = 5 +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[4], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs, val_interval=1) + +default_hooks = dict(checkpoint=dict(max_keep_ckpts=1, save_best='auto')) + +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth' # noqa diff --git a/mmdetection/configs/mm_grounding_dino/cityscapes/grounding_dino_swin-t_finetune_8xb4_50e_cityscapes.py b/mmdetection/configs/mm_grounding_dino/cityscapes/grounding_dino_swin-t_finetune_8xb4_50e_cityscapes.py new file mode 100644 index 00000000..c4283413 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/cityscapes/grounding_dino_swin-t_finetune_8xb4_50e_cityscapes.py @@ -0,0 +1,110 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365.py' + +data_root = 'data/cityscapes/' +class_name = ('person', 'rider', 'car', 'truck', 'bus', 'train', 'motorcycle', + 'bicycle') +palette = [(220, 20, 60), (255, 0, 0), (0, 0, 142), (0, 0, 70), (0, 60, 100), + (0, 80, 100), (0, 0, 230), (119, 11, 32)] + +metainfo = dict(classes=class_name, palette=palette) + +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities')) +] + +train_dataloader = dict( + sampler=dict(_delete_=True, type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + _delete_=True, + type='RepeatDataset', + times=10, + dataset=dict( + type='CocoDataset', + data_root=data_root, + metainfo=metainfo, + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline, + return_classes=True, + data_prefix=dict(img='leftImg8bit/train/'), + ann_file='annotations/instancesonly_filtered_gtFine_train.json'))) + +val_dataloader = dict( + dataset=dict( + metainfo=metainfo, + data_root=data_root, + return_classes=True, + ann_file='annotations/instancesonly_filtered_gtFine_val.json', + data_prefix=dict(img='leftImg8bit/val/'))) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'annotations/instancesonly_filtered_gtFine_val.json', + metric='bbox', + format_only=False) +test_evaluator = val_evaluator + +optim_wrapper = dict( + _delete_=True, + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0001), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict(custom_keys={ + 'absolute_pos_embed': dict(decay_mult=0.), + 'backbone': dict(lr_mult=0.1) + })) + +# learning policy +max_epochs = 5 +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[4], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs, val_interval=1) +default_hooks = dict(checkpoint=dict(max_keep_ckpts=1, save_best='auto')) + +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth' # noqa diff --git a/mmdetection/configs/mm_grounding_dino/coco/grounding_dino_swin-t_finetune_16xb4_1x_coco.py b/mmdetection/configs/mm_grounding_dino/coco/grounding_dino_swin-t_finetune_16xb4_1x_coco.py new file mode 100644 index 00000000..792297ac --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/coco/grounding_dino_swin-t_finetune_16xb4_1x_coco.py @@ -0,0 +1,85 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365.py' + +data_root = 'data/coco/' + +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities')) +] + +train_dataloader = dict( + dataset=dict( + _delete_=True, + type='CocoDataset', + data_root=data_root, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + return_classes=True, + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline)) + +optim_wrapper = dict( + _delete_=True, + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.0002, weight_decay=0.0001), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict( + custom_keys={ + 'absolute_pos_embed': dict(decay_mult=0.), + 'backbone': dict(lr_mult=0.1), + 'language_model': dict(lr_mult=0.1), + })) + +# learning policy +max_epochs = 12 +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs, val_interval=1) + +default_hooks = dict(checkpoint=dict(max_keep_ckpts=1, save_best='auto')) + +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth' # noqa diff --git a/mmdetection/configs/mm_grounding_dino/coco/grounding_dino_swin-t_finetune_16xb4_1x_coco_48_17.py b/mmdetection/configs/mm_grounding_dino/coco/grounding_dino_swin-t_finetune_16xb4_1x_coco_48_17.py new file mode 100644 index 00000000..e68afbb4 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/coco/grounding_dino_swin-t_finetune_16xb4_1x_coco_48_17.py @@ -0,0 +1,157 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365.py' + +data_root = 'data/coco/' +base_classes = ('person', 'bicycle', 'car', 'motorcycle', 'train', 'truck', + 'boat', 'bench', 'bird', 'horse', 'sheep', 'bear', 'zebra', + 'giraffe', 'backpack', 'handbag', 'suitcase', 'frisbee', + 'skis', 'kite', 'surfboard', 'bottle', 'fork', 'spoon', 'bowl', + 'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot', + 'pizza', 'donut', 'chair', 'bed', 'toilet', 'tv', 'laptop', + 'mouse', 'remote', 'microwave', 'oven', 'toaster', + 'refrigerator', 'book', 'clock', 'vase', 'toothbrush') # 48 +novel_classes = ('airplane', 'bus', 'cat', 'dog', 'cow', 'elephant', + 'umbrella', 'tie', 'snowboard', 'skateboard', 'cup', 'knife', + 'cake', 'couch', 'keyboard', 'sink', 'scissors') # 17 +all_classes = ( + 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', + 'truck', 'boat', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow', + 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella', 'handbag', + 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard', 'kite', 'skateboard', + 'surfboard', 'bottle', 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', + 'apple', 'sandwich', 'orange', 'broccoli', 'carrot', 'pizza', 'donut', + 'cake', 'chair', 'couch', 'bed', 'toilet', 'tv', 'laptop', 'mouse', + 'remote', 'keyboard', 'microwave', 'oven', 'toaster', 'sink', + 'refrigerator', 'book', 'clock', 'vase', 'scissors', 'toothbrush') # 65 + +train_metainfo = dict(classes=base_classes) +test_metainfo = dict( + classes=all_classes, + base_classes=base_classes, + novel_classes=novel_classes) + +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities')) +] + +test_pipeline = [ + dict( + type='LoadImageFromFile', backend_args=None, + imdecode_backend='pillow'), + dict( + type='FixScaleResize', + scale=(800, 1333), + keep_ratio=True, + backend='pillow'), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'text', 'custom_entities', + 'tokens_positive')) +] + +train_dataloader = dict( + dataset=dict( + _delete_=True, + type='CocoDataset', + metainfo=train_metainfo, + data_root=data_root, + ann_file='annotations/instances_train2017_seen_2.json', + data_prefix=dict(img='train2017/'), + return_classes=True, + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline)) + +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type='CocoDataset', + metainfo=test_metainfo, + data_root=data_root, + ann_file='annotations/instances_val2017_all_2.json', + data_prefix=dict(img='val2017/'), + test_mode=True, + pipeline=test_pipeline, + return_classes=True, + )) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='OVCocoMetric', + ann_file=data_root + 'annotations/instances_val2017_all_2.json', + metric='bbox', + format_only=False) +test_evaluator = val_evaluator + +optim_wrapper = dict( + _delete_=True, + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.00005, weight_decay=0.0001), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict( + custom_keys={ + 'absolute_pos_embed': dict(decay_mult=0.), + 'backbone': dict(lr_mult=0.1), + # 'language_model': dict(lr_mult=0), + })) + +# learning policy +max_epochs = 12 +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs, val_interval=1) + +default_hooks = dict( + checkpoint=dict( + max_keep_ckpts=1, save_best='coco/novel_ap50', rule='greater')) + +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth' # noqa diff --git a/mmdetection/configs/mm_grounding_dino/coco/grounding_dino_swin-t_finetune_16xb4_1x_sft_coco.py b/mmdetection/configs/mm_grounding_dino/coco/grounding_dino_swin-t_finetune_16xb4_1x_sft_coco.py new file mode 100644 index 00000000..5505df58 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/coco/grounding_dino_swin-t_finetune_16xb4_1x_sft_coco.py @@ -0,0 +1,93 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365.py' + +data_root = 'data/coco/' + +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict( + type='RandomSamplingNegPos', + tokenizer_name=_base_.lang_model_name, + num_sample_negative=20, # ======= important ===== + label_map_file='data/coco/annotations/coco2017_label_map.json', + max_tokens=256), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities', 'tokens_positive', 'dataset_mode')) +] + +train_dataloader = dict( + dataset=dict( + _delete_=True, + type='ODVGDataset', + need_text=False, + data_root=data_root, + ann_file='annotations/instances_train2017_od.json', + label_map_file='annotations/coco2017_label_map.json', + data_prefix=dict(img='train2017/'), + return_classes=True, + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline)) + +optim_wrapper = dict( + _delete_=True, + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.00005, weight_decay=0.0001), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict( + custom_keys={ + 'absolute_pos_embed': dict(decay_mult=0.), + 'backbone': dict(lr_mult=0.1), + 'language_model': dict(lr_mult=0.0), + })) + +# learning policy +max_epochs = 12 +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs, val_interval=1) + +default_hooks = dict(checkpoint=dict(max_keep_ckpts=1, save_best='auto')) + +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth' # noqa diff --git a/mmdetection/configs/mm_grounding_dino/dataset_prepare.md b/mmdetection/configs/mm_grounding_dino/dataset_prepare.md new file mode 100644 index 00000000..af60a8bf --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/dataset_prepare.md @@ -0,0 +1,1193 @@ +# Data Prepare and Process + +## MM-GDINO-T Pre-train Dataset + +For the MM-GDINO-T model, we provide a total of 5 different data combination pre-training configurations. The data is trained in a progressive accumulation manner, so users can prepare it according to their actual needs. + +### 1 Objects365v1 + +The corresponding training config is [grounding_dino_swin-t_pretrain_obj365](./grounding_dino_swin-t_pretrain_obj365.py) + +Objects365v1 can be downloaded from [opendatalab](https://opendatalab.com/OpenDataLab/Objects365_v1). It offers two methods of download: CLI and SDK. + +After downloading and unzipping, place the dataset or create a symbolic link to the `data/objects365v1` directory. The directory structure is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── objects365v1 +│ │ ├── objects365_train.json +│ │ ├── objects365_val.json +│ │ ├── train +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +│ │ ├── test +``` + +Then, use [coco2odvg.py](../../tools/dataset_converters/coco2odvg.py) to convert it into the ODVG format required for training. + +```shell +python tools/dataset_converters/coco2odvg.py data/objects365v1/objects365_train.json -d o365v1 +``` + +After the program runs successfully, it will create two new files, `o365v1_train_od.json` and `o365v1_label_map.json`, in the `data/objects365v1` directory. The complete structure is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── objects365v1 +│ │ ├── objects365_train.json +│ │ ├── objects365_val.json +│ │ ├── o365v1_train_od.json +│ │ ├── o365v1_label_map.json +│ │ ├── train +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +│ │ ├── test +``` + +### 2 COCO 2017 + +The above configuration will evaluate the performance on the COCO 2017 dataset during the training process. Therefore, it is necessary to prepare the COCO 2017 dataset. You can download it from the [COCO](https://cocodataset.org/) official website or from [opendatalab](https://opendatalab.com/OpenDataLab/COCO_2017). + +After downloading and unzipping, place the dataset or create a symbolic link to the `data/coco` directory. The directory structure is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +``` + +### 3 GoldG + +After downloading the dataset, you can start training with the [grounding_dino_swin-t_pretrain_obj365_goldg](./grounding_dino_swin-t_pretrain_obj365_goldg.py) configuration. + +The GoldG dataset includes the `GQA` and `Flickr30k` datasets, which are part of the MixedGrounding dataset mentioned in the GLIP paper, excluding the COCO dataset. The download links are [mdetr_annotations](https://huggingface.co/GLIPModel/GLIP/tree/main/mdetr_annotations), and the specific files currently needed are `mdetr_annotations/final_mixed_train_no_coco.json` and `mdetr_annotations/final_flickr_separateGT_train.json`. + +Then download the [GQA images](https://nlp.stanford.edu/data/gqa/images.zip). After downloading and unzipping, place the dataset or create a symbolic link to them in the `data/gqa` directory, with the following directory structure: + +```text +mmdetection +├── configs +├── data +│ ├── gqa +| | ├── final_mixed_train_no_coco.json +│ │ ├── images +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +Then download the [Flickr30k images](http://shannon.cs.illinois.edu/DenotationGraph/). You need to apply for access to this dataset and then download it using the provided link. After downloading and unzipping, place the dataset or create a symbolic link to them in the `data/flickr30k_entities` directory, with the following directory structure: + +```text +mmdetection +├── configs +├── data +│ ├── flickr30k_entities +│ │ ├── final_flickr_separateGT_train.json +│ │ ├── flickr30k_images +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +For the GQA dataset, you need to use [goldg2odvg.py](../../tools/dataset_converters/goldg2odvg.py) to convert it into the ODVG format required for training: + +```shell +python tools/dataset_converters/goldg2odvg.py data/gqa/final_mixed_train_no_coco.json +``` + +After the program has run, a new file `final_mixed_train_no_coco_vg.json` will be created in the `data/gqa` directory, with the complete structure as follows: + +```text +mmdetection +├── configs +├── data +│ ├── gqa +| | ├── final_mixed_train_no_coco.json +| | ├── final_mixed_train_no_coco_vg.json +│ │ ├── images +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +For the Flickr30k dataset, you need to use [goldg2odvg.py](../../tools/dataset_converters/goldg2odvg.py) to convert it into the ODVG format required for training: + +```shell +python tools/dataset_converters/goldg2odvg.py data/flickr30k_entities/final_flickr_separateGT_train.json +``` + +After the program has run, a new file `final_flickr_separateGT_train_vg.json` will be created in the `data/flickr30k_entities` directory, with the complete structure as follows: + +```text +mmdetection +├── configs +├── data +│ ├── flickr30k_entities +│ │ ├── final_flickr_separateGT_train.json +│ │ ├── final_flickr_separateGT_train_vg.json +│ │ ├── flickr30k_images +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +### 4 GRIT-20M + +The corresponding training configuration is [grounding_dino_swin-t_pretrain_obj365_goldg_grit9m](./grounding_dino_swin-t_pretrain_obj365_goldg_grit9m.py). + +The GRIT dataset can be downloaded using the img2dataset package from [GRIT](https://huggingface.co/datasets/zzliang/GRIT#download-image). By default, the dataset size is 1.1T, and downloading and processing it may require at least 2T of disk space, depending on your available storage capacity. After downloading, the dataset is in its original format, which includes: + +```text +mmdetection +├── configs +├── data +│ ├── grit_raw +│ │ ├── 00000_stats.json +│ │ ├── 00000.parquet +│ │ ├── 00000.tar +│ │ ├── 00001_stats.json +│ │ ├── 00001.parquet +│ │ ├── 00001.tar +│ │ ├── ... +``` + +After downloading, further format processing is required: + +```shell +python tools/dataset_converters/grit_processing.py data/grit_raw data/grit_processed +``` + +The processed format is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── grit_processed +│ │ ├── annotations +│ │ │ ├── 00000.json +│ │ │ ├── 00001.json +│ │ │ ├── ... +│ │ ├── images +│ │ │ ├── 00000 +│ │ │ │ ├── 000000000.jpg +│ │ │ │ ├── 000000003.jpg +│ │ │ │ ├── 000000004.jpg +│ │ │ │ ├── ... +│ │ │ ├── 00001 +│ │ │ ├── ... +``` + +As for the GRIT dataset, you need to use [grit2odvg.py](../../tools/dataset_converters/grit2odvg.py) to convert it to the format of ODVG: + +```shell +python tools/dataset_converters/grit2odvg.py data/grit_processed/ +``` + +After the program has run, a new file `grit20m_vg.json` will be created in the `data/grit_processed` directory, which has about 9M data, with the complete structure as follows: + +```text +mmdetection +├── configs +├── data +│ ├── grit_processed +| | ├── grit20m_vg.json +│ │ ├── annotations +│ │ │ ├── 00000.json +│ │ │ ├── 00001.json +│ │ │ ├── ... +│ │ ├── images +│ │ │ ├── 00000 +│ │ │ │ ├── 000000000.jpg +│ │ │ │ ├── 000000003.jpg +│ │ │ │ ├── 000000004.jpg +│ │ │ │ ├── ... +│ │ │ ├── 00001 +│ │ │ ├── ... +``` + +### 5 V3Det + +The corresponding training configurations are: + +- [grounding_dino_swin-t_pretrain_obj365_goldg_v3det](./grounding_dino_swin-t_pretrain_obj365_goldg_v3det.py) +- [grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det](./grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det.py) + +The V3Det dataset can be downloaded from [opendatalab](https://opendatalab.com/V3Det/V3Det). After downloading and unzipping, place the dataset or create a symbolic link to it in the `data/v3det` directory, with the following directory structure: + +```text +mmdetection +├── configs +├── data +│ ├── v3det +│ │ ├── annotations +│ │ | ├── v3det_2023_v1_train.json +│ │ ├── images +│ │ │ ├── a00000066 +│ │ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +Then use [coco2odvg.py](../../tools/dataset_converters/coco2odvg.py) to convert it into the ODVG format required for training: + +```shell +python tools/dataset_converters/coco2odvg.py data/v3det/annotations/v3det_2023_v1_train.json -d v3det +``` + +After the program has run, two new files `v3det_2023_v1_train_od.json` and `v3det_2023_v1_label_map.json` will be created in the `data/v3det/annotations` directory, with the complete structure as follows: + +```text +mmdetection +├── configs +├── data +│ ├── v3det +│ │ ├── annotations +│ │ | ├── v3det_2023_v1_train.json +│ │ | ├── v3det_2023_v1_train_od.json +│ │ | ├── v3det_2023_v1_label_map.json +│ │ ├── images +│ │ │ ├── a00000066 +│ │ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +### 6 Data Splitting and Visualization + +Considering that users need to prepare many datasets, which is inconvenient for confirming images and annotations before training, we provide a data splitting and visualization tool. This tool can split the dataset into a tiny version and then use a visualization script to check the correctness of the images and labels. + +1. Splitting the Dataset + +The script is located [here](../../tools/misc/split_odvg.py). Taking `Object365 v1` as an example, the command to split the dataset is as follows: + +```shell +python tools/misc/split_odvg.py data/object365_v1/ o365v1_train_od.json train your_output_dir --label-map-file o365v1_label_map.json -n 200 +``` + +After running the above script, it will create a folder structure in the `your_output_dir` directory identical to `data/object365_v1/`, but it will only save 200 training images and their corresponding json files for convenient user review. + +2. Visualizing the Original Dataset + +The script is located [here](../../tools/analysis_tools/browse_grounding_raw.py). Taking `Object365 v1` as an example, the command to visualize the dataset is as follows: + +```shell +python tools/analysis_tools/browse_grounding_raw.py data/object365_v1/ o365v1_train_od.json train --label-map-file o365v1_label_map.json -o your_output_dir --not-show +``` + +After running the above script, it will generate images in the `your_output_dir` directory that include both the pictures and their labels, making it convenient for users to review. + +3. Visualizing the Output Dataset + +The script is located [here](../../tools/analysis_tools/browse_grounding_dataset.py). Users can use this script to view the results of the dataset output, including the results of data augmentation. Taking `Object365 v1` as an example, the command to visualize the dataset is as follows: + +```shell +python tools/analysis_tools/browse_grounding_dataset.py configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365.py -o your_output_dir --not-show +``` + +After running the above script, it will generate images in the `your_output_dir` directory that include both the pictures and their labels, making it convenient for users to review. + +## MM-GDINO-L Pre-training Data Preparation and Processing + +### 1 Object365 v2 + +Objects365_v2 can be downloaded from [opendatalab](https://opendatalab.com/OpenDataLab/Objects365). It offers two download methods: CLI and SDK. + +After downloading and unzipping, place the dataset or create a symbolic link to it in the `data/objects365v2` directory, with the following directory structure: + +```text +mmdetection +├── configs +├── data +│ ├── objects365v2 +│ │ ├── annotations +│ │ │ ├── zhiyuan_objv2_train.json +│ │ ├── train +│ │ │ ├── patch0 +│ │ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +Since some category names in Objects365v2 are incorrect, it is necessary to correct them first. + +```shell +python tools/dataset_converters/fix_o365_names.py +``` + +A new annotation file `zhiyuan_objv2_train_fixname.json` will be generated in the `data/objects365v2/annotations` directory. + +Then use [coco2odvg.py](../../tools/dataset_converters/coco2odvg.py) to convert it into the ODVG format required for training: + +```shell +python tools/dataset_converters/coco2odvg.py data/objects365v2/annotations/zhiyuan_objv2_train_fixname.json -d o365v2 +``` + +After the program has run, two new files `zhiyuan_objv2_train_fixname_od.json` and `o365v2_label_map.json` will be created in the `data/objects365v2` directory, with the complete structure as follows: + +```text +mmdetection +├── configs +├── data +│ ├── objects365v2 +│ │ ├── annotations +│ │ │ ├── zhiyuan_objv2_train.json +│ │ │ ├── zhiyuan_objv2_train_fixname.json +│ │ │ ├── zhiyuan_objv2_train_fixname_od.json +│ │ │ ├── o365v2_label_map.json +│ │ ├── train +│ │ │ ├── patch0 +│ │ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +### 2 OpenImages v6 + +OpenImages v6 can be downloaded from the [official website](https://storage.googleapis.com/openimages/web/download_v6.html). Due to the large size of the dataset, it may take some time to download. After completion, the file structure is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── OpenImages +│ │ ├── annotations +| │ │ ├── oidv6-train-annotations-bbox.csv +| │ │ ├── class-descriptions-boxable.csv +│ │ ├── OpenImages +│ │ │ ├── train +│ │ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +Then use [openimages2odvg.py](../../tools/dataset_converters/openimages2odvg.py) to convert it into the ODVG format required for training: + +```shell +python tools/dataset_converters/openimages2odvg.py data/OpenImages/annotations +``` + +After the program has run, two new files `oidv6-train-annotation_od.json` and `openimages_label_map.json` will be created in the `data/OpenImages/annotations` directory, with the complete structure as follows: + +```text +mmdetection +├── configs +├── data +│ ├── OpenImages +│ │ ├── annotations +| │ │ ├── oidv6-train-annotations-bbox.csv +| │ │ ├── class-descriptions-boxable.csv +| │ │ ├── oidv6-train-annotations_od.json +| │ │ ├── openimages_label_map.json +│ │ ├── OpenImages +│ │ │ ├── train +│ │ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +### 3 V3Det + +Referring to the data preparation section of the previously mentioned MM-GDINO-T pre-training data preparation and processing, the complete dataset structure is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── v3det +│ │ ├── annotations +│ │ | ├── v3det_2023_v1_train.json +│ │ | ├── v3det_2023_v1_train_od.json +│ │ | ├── v3det_2023_v1_label_map.json +│ │ ├── images +│ │ │ ├── a00000066 +│ │ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +### 4 LVIS 1.0 + +Please refer to the `2 LVIS 1.0` section of the later `Fine-tuning Dataset Preparation`. The complete dataset structure is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── lvis_v1_train.json +│ │ │ ├── lvis_v1_val.json +│ │ │ ├── lvis_v1_train_od.json +│ │ │ ├── lvis_v1_label_map.json +│ │ │ ├── instances_val2017.json +│ │ │ ├── lvis_v1_minival_inserted_image_name.json +│ │ │ ├── lvis_od_val.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +``` + +### 5 COCO2017 OD + +You can refer to the earlier section `MM-GDINO-T Pre-training Data Preparation and Processing` for data preparation. For convenience in subsequent processing, please create a symbolic link or move the downloaded [mdetr_annotations](https://huggingface.co/GLIPModel/GLIP/tree/main/mdetr_annotations) folder to the `data/coco` path. The complete dataset structure is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ ├── mdetr_annotations +│ │ │ ├── final_refexp_val.json +│ │ │ ├── finetune_refcoco_testA.json +│ │ │ ├── ... +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +``` + +Due to some overlap between COCO2017 train and RefCOCO/RefCOCO+/RefCOCOg/gRefCOCO val, if not removed in advance, there will be data leakage when evaluating RefExp. + +```shell +python tools/dataset_converters/remove_cocotrain2017_from_refcoco.py data/coco/mdetr_annotations data/coco/annotations/instances_train2017.json +``` + +A new file `instances_train2017_norefval.json` will be created in the `data/coco/annotations` directory. Finally, use [coco2odvg.py](../../tools/dataset_converters/coco2odvg.py) to convert it into the ODVG format required for training: + +```shell +python tools/dataset_converters/coco2odvg.py data/coco/annotations/instances_train2017_norefval.json -d coco +``` + +Two new files `instances_train2017_norefval_od.json` and `coco_label_map.json` will be created in the `data/coco/annotations` directory, with the complete structure as follows: + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ │ ├── instances_train2017_norefval_od.json +│ │ │ ├── coco_label_map.json +│ │ ├── mdetr_annotations +│ │ │ ├── final_refexp_val.json +│ │ │ ├── finetune_refcoco_testA.json +│ │ │ ├── ... +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +``` + +Note: There are 15,000 images that overlap between the COCO2017 train and LVIS 1.0 val datasets. Therefore, if the COCO2017 train dataset is used in training, the evaluation results of LVIS 1.0 val will have a data leakage issue. However, LVIS 1.0 minival does not have this problem. + +### 6 GoldG + +Please refer to the section on `MM-GDINO-T Pre-training Data Preparation and Processing`. + +```text +mmdetection +├── configs +├── data +│ ├── flickr30k_entities +│ │ ├── final_flickr_separateGT_train.json +│ │ ├── final_flickr_separateGT_train_vg.json +│ │ ├── flickr30k_images +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ ├── gqa +| | ├── final_mixed_train_no_coco.json +| | ├── final_mixed_train_no_coco_vg.json +│ │ ├── images +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +### 7 COCO2014 VG + +MDetr provides a Phrase Grounding version of the COCO2014 train annotations. The original annotation file is named `final_mixed_train.json`, and similar to the previous structure, the file structure is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ ├── mdetr_annotations +│ │ │ ├── final_mixed_train.json +│ │ │ ├── ... +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── train2014 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +We can extract the COCO portion of the data from `final_mixed_train.json`. + +```shell +python tools/dataset_converters/extract_coco_from_mixed.py data/coco/mdetr_annotations/final_mixed_train.json +``` + +A new file named `final_mixed_train_only_coco.json` will be created in the `data/coco/mdetr_annotations` directory. Finally, use [goldg2odvg.py](../../tools/dataset_converters/goldg2odvg.py) to convert it into the ODVG format required for training: + +```shell +python tools/dataset_converters/goldg2odvg.py data/coco/mdetr_annotations/final_mixed_train_only_coco.json +``` + +A new file named `final_mixed_train_only_coco_vg.json` will be created in the `data/coco/mdetr_annotations` directory, with the complete structure as follows: + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ ├── mdetr_annotations +│ │ │ ├── final_mixed_train.json +│ │ │ ├── final_mixed_train_only_coco.json +│ │ │ ├── final_mixed_train_only_coco_vg.json +│ │ │ ├── ... +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── train2014 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +Note: COCO2014 train and COCO2017 val do not have duplicate images, so there is no need to worry about data leakage issues in COCO evaluation. + +### 8 Referring Expression Comprehension + +There are a total of 4 datasets included. For data preparation, please refer to the `Fine-tuning Dataset Preparation` section. + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ │ ├── instances_train2014.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +│ │ ├── train2014 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── mdetr_annotations +│ │ │ ├── final_refexp_val.json +│ │ │ ├── finetune_refcoco_testA.json +│ │ │ ├── finetune_refcoco_testB.json +│ │ │ ├── finetune_refcoco+_testA.json +│ │ │ ├── finetune_refcoco+_testB.json +│ │ │ ├── finetune_refcocog_test.json +│ │ │ ├── finetune_refcoco_train_vg.json +│ │ │ ├── finetune_refcoco+_train_vg.json +│ │ │ ├── finetune_refcocog_train_vg.json +│ │ │ ├── finetune_grefcoco_train_vg.json +``` + +### 9 GRIT-20M + +Please refer to the `MM-GDINO-T Pre-training Data Preparation and Processing` section. + +## Preparation of Evaluation Dataset + +### 1 COCO 2017 + +The data preparation process is consistent with the previous descriptions, and the final structure is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +``` + +### 2 LVIS 1.0 + +The LVIS 1.0 val dataset includes both mini and full versions. The significance of the mini version is: + +1. The full LVIS val evaluation dataset is quite large, and conducting an evaluation with it can take a significant amount of time. +2. In the full LVIS val dataset, there are 15,000 images from the COCO2017 train dataset. If a user has used the COCO2017 data for training, there can be a data leakage issue when evaluating on the full LVIS val dataset + +The LVIS 1.0 dataset contains images that are exactly the same as the COCO2017 dataset, with the addition of new annotations. You can download the minival annotation file from [here](https://huggingface.co/GLIPModel/GLIP/blob/main/lvis_v1_minival_inserted_image_name.json), and the val 1.0 annotation file from [here](https://huggingface.co/GLIPModel/GLIP/blob/main/lvis_od_val.json). The final structure is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ │ ├── lvis_v1_minival_inserted_image_name.json +│ │ │ ├── lvis_od_val.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +``` + +### 3 ODinW + +ODinW, which stands for Object Detection in the Wild, is a dataset used to evaluate the generalization capability of grounding pre-trained models in different real-world scenarios. It consists of two subsets, ODinW13 and ODinW35, representing datasets composed of 13 and 35 different datasets, respectively. You can download it from [here](https://huggingface.co/GLIPModel/GLIP/tree/main/odinw_35), and then unzip each file. The final structure is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── odinw +│ │ ├── AerialMaritimeDrone +│ │ | |── large +│ │ | | ├── test +│ │ | | ├── train +│ │ | | ├── valid +│ │ | |── tiled +│ │ ├── AmericanSignLanguageLetters +│ │ ├── Aquarium +│ │ ├── BCCD +│ │ ├── ... +``` + +When evaluating ODinW35, custom prompts are required. Therefore, it's necessary to preprocess the annotated JSON files in advance. You can use the [override_category.py](./odinw/override_category.py) script for this purpose. After processing, it will generate new annotation files without overwriting the original ones. + +```shell +python configs/mm_grounding_dino/odinw/override_category.py data/odinw/ +``` + +### 4 DOD + +DOD stands for Described Object Detection, and it is introduced in the paper titled [Described Object Detection: Liberating Object Detection with Flexible Expressions](https://arxiv.org/abs/2307.12813). You can download the dataset from [here](https://github.com/shikras/d-cube?tab=readme-ov-file). The final structure of the dataset is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── d3 +│ │ ├── d3_images +│ │ ├── d3_json +│ │ ├── d3_pkl +``` + +### 5 Flickr30k Entities + +In the previous GoldG data preparation section, we downloaded the necessary files for training with Flickr30k. For evaluation, you will need 2 JSON files, which you can download from [here](https://huggingface.co/GLIPModel/GLIP/blob/main/mdetr_annotations/final_flickr_separateGT_val.json) and [here](https://huggingface.co/GLIPModel/GLIP/blob/main/mdetr_annotations/final_flickr_separateGT_test.json). The final structure of the dataset is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── flickr30k_entities +│ │ ├── final_flickr_separateGT_train.json +│ │ ├── final_flickr_separateGT_val.json +│ │ ├── final_flickr_separateGT_test.json +│ │ ├── final_flickr_separateGT_train_vg.json +│ │ ├── flickr30k_images +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +### 6 Referring Expression Comprehension + +Referential Expression Comprehension includes 4 datasets: RefCOCO, RefCOCO+, RefCOCOg, and gRefCOCO. The images used in these 4 datasets are from COCO2014 train, similar to COCO2017. You can download the images from the official COCO website or opendatalab. The annotations can be directly downloaded from [here](https://huggingface.co/GLIPModel/GLIP/tree/main/mdetr_annotations). The mdetr_annotations folder contains a large number of annotations, so you can choose to download only the JSON files you need. The final structure of the dataset is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ │ ├── instances_train2014.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +│ │ ├── train2014 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── mdetr_annotations +│ │ │ ├── final_refexp_val.json +│ │ │ ├── finetune_refcoco_testA.json +│ │ │ ├── finetune_refcoco_testB.json +│ │ │ ├── finetune_refcoco+_testA.json +│ │ │ ├── finetune_refcoco+_testB.json +│ │ │ ├── finetune_refcocog_test.json +│ │ │ ├── finetune_refcocog_test.json +``` + +Please note that gRefCOCO is introduced in [GREC: Generalized Referring Expression Comprehension](https://arxiv.org/abs/2308.16182) and is not available in the `mdetr_annotations` folder. You will need to handle it separately. Here are the specific steps: + +1. Download [gRefCOCO](https://github.com/henghuiding/gRefCOCO?tab=readme-ov-file) and unzip it into the `data/coco/` folder. + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ │ ├── instances_train2014.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +│ │ ├── train2014 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── mdetr_annotations +│ │ ├── grefs +│ │ │ ├── grefs(unc).json +│ │ │ ├── instances.json +``` + +2. Convert to COCO format + +You can use the official [conversion script](https://github.com/henghuiding/gRefCOCO/blob/b4b1e55b4d3a41df26d6b7d843ea011d581127d4/mdetr/scripts/fine-tuning/grefexp_coco_format.py) provided by gRefCOCO. Please note that you need to uncomment line 161 and comment out line 160 in the script to obtain the full JSON file. + +```shell +# you need to clone the official repo +git clone https://github.com/henghuiding/gRefCOCO.git +cd gRefCOCO/mdetr +python scripts/fine-tuning/grefexp_coco_format.py --data_path ../../data/coco/grefs --out_path ../../data/coco/mdetr_annotations/ --coco_path ../../data/coco +``` + +Four JSON files will be generated in the `data/coco/mdetr_annotations/` folder. The complete dataset structure is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ │ ├── instances_train2014.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +│ │ ├── train2014 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── mdetr_annotations +│ │ │ ├── final_refexp_val.json +│ │ │ ├── finetune_refcoco_testA.json +│ │ │ ├── finetune_refcoco_testB.json +│ │ │ ├── finetune_grefcoco_train.json +│ │ │ ├── finetune_grefcoco_val.json +│ │ │ ├── finetune_grefcoco_testA.json +│ │ │ ├── finetune_grefcoco_testB.json +``` + +## Fine-Tuning Dataset Preparation + +### 1 COCO 2017 + +COCO is the most commonly used dataset in the field of object detection, and we aim to explore its fine-tuning modes more comprehensively. From current developments, there are a total of three fine-tuning modes: + +1. Closed-set fine-tuning, where the description on the text side cannot be modified after fine-tuning, transforms into a closed-set algorithm. This approach maximizes performance on COCO but loses generality. +2. Open-set continued pretraining fine-tuning involves using pretraining methods consistent with the COCO dataset. There are two approaches to this: the first is to reduce the learning rate and fix certain modules, fine-tuning only on the COCO dataset; the second is to mix COCO data with some of the pre-trained data. The goal of both approaches is to improve performance on the COCO dataset as much as possible without compromising generalization. +3. Open-vocabulary fine-tuning involves adopting a common practice in the OVD (Open-Vocabulary Detection) domain. It divides COCO categories into base classes and novel classes. During training, fine-tuning is performed only on the base classes, while evaluation is conducted on both base and novel classes. This approach allows for the assessment of COCO OVD capabilities, with the goal of improving COCO dataset performance without compromising generalization as much as possible. + +\*\*(1) Closed-set Fine-tuning \*\* + +This section does not require data preparation; you can directly use the data you have prepared previously. + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +``` + +**(2) Open-set Continued Pretraining Fine-tuning** +To use this approach, you need to convert the COCO training data into ODVG format. You can use the following command for conversion: + +```shell +python tools/dataset_converters/coco2odvg.py data/coco/annotations/instances_train2017.json -d coco +``` + +This will generate new files, `instances_train2017_od.json` and `coco2017_label_map.json`, in the `data/coco/annotations/` directory. The complete dataset structure is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_train2017_od.json +│ │ │ ├── coco2017_label_map.json +│ │ │ ├── instances_val2017.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +``` + +Once you have obtained the data, you can choose whether to perform individual pretraining or mixed pretraining. + +**(3) Open-vocabulary Fine-tuning** +For this approach, you need to convert the COCO training data into OVD (Open-Vocabulary Detection) format. You can use the following command for conversion: + +```shell +python tools/dataset_converters/coco2ovd.py data/coco/ +``` + +This will generate new files, `instances_val2017_all_2.json` and `instances_val2017_seen_2.json`, in the `data/coco/annotations/` directory. The complete dataset structure is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_train2017_od.json +│ │ │ ├── instances_val2017_all_2.json +│ │ │ ├── instances_val2017_seen_2.json +│ │ │ ├── coco2017_label_map.json +│ │ │ ├── instances_val2017.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +``` + +You can then proceed to train and test directly using the [configuration](coco/grounding_dino_swin-t_finetune_16xb4_1x_coco_48_17.py). + +### 2 LVIS 1.0 + +LVIS is a dataset that includes 1,203 classes, making it a valuable dataset for fine-tuning. Due to its large number of classes, it's not feasible to perform closed-set fine-tuning. Therefore, we can only use open-set continued pretraining fine-tuning and open-vocabulary fine-tuning on LVIS. + +You need to prepare the LVIS training JSON files first, which you can download from [here](https://www.lvisdataset.org/dataset). We only need `lvis_v1_train.json` and `lvis_v1_val.json`. After downloading them, place them in the `data/coco/annotations/` directory, and then run the following command: + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── lvis_v1_train.json +│ │ │ ├── lvis_v1_val.json +│ │ │ ├── instances_val2017.json +│ │ │ ├── lvis_v1_minival_inserted_image_name.json +│ │ │ ├── lvis_od_val.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +``` + +(1) Open-set continued pretraining fine-tuning + +Convert to ODVG format using the following command: + +```shell +python tools/dataset_converters/lvis2odvg.py data/coco/annotations/lvis_v1_train.json +``` + +It will generate new files, `lvis_v1_train_od.json` and `lvis_v1_label_map.json`, in the `data/coco/annotations/` directory, and the complete dataset structure will look like this: + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── lvis_v1_train.json +│ │ │ ├── lvis_v1_val.json +│ │ │ ├── lvis_v1_train_od.json +│ │ │ ├── lvis_v1_label_map.json +│ │ │ ├── instances_val2017.json +│ │ │ ├── lvis_v1_minival_inserted_image_name.json +│ │ │ ├── lvis_od_val.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +``` + +You can directly use the provided [configuration](lvis/grounding_dino_swin-t_finetune_16xb4_1x_lvis.py) for training and testing, or you can modify the configuration to mix it with some of the pretraining datasets as needed. + +**(2) Open Vocabulary Fine-tuning** + +Convert to OVD format using the following command: + +```shell +python tools/dataset_converters/lvis2ovd.py data/coco/ +``` + +New `lvis_v1_train_od_norare.json` and `lvis_v1_label_map_norare.json` will be generated under `data/coco/annotations/`, and the complete dataset structure is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── lvis_v1_train.json +│ │ │ ├── lvis_v1_val.json +│ │ │ ├── lvis_v1_train_od.json +│ │ │ ├── lvis_v1_label_map.json +│ │ │ ├── instances_val2017.json +│ │ │ ├── lvis_v1_minival_inserted_image_name.json +│ │ │ ├── lvis_od_val.json +│ │ │ ├── lvis_v1_train_od_norare.json +│ │ │ ├── lvis_v1_label_map_norare.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +``` + +然Then you can directly use the [configuration](lvis/grounding_dino_swin-t_finetune_16xb4_1x_lvis_866_337.py) for training and testing. + +### 3 RTTS + +RTTS is a foggy weather dataset, which contains 4,322 foggy images, including five classes: bicycle, bus, car, motorbike, and person. It can be downloaded from [here](https://drive.google.com/file/d/15Ei1cHGVqR1mXFep43BO7nkHq1IEGh1e/view), and then extracted to the `data/RTTS/` folder. The complete dataset structure is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── RTTS +│ │ ├── annotations_json +│ │ ├── annotations_xml +│ │ ├── ImageSets +│ │ ├── JPEGImages +``` + +### 4 RUOD + +RUOD is an underwater object detection dataset. You can download it from [here](https://drive.google.com/file/d/1hxtbdgfVveUm_DJk5QXkNLokSCTa_E5o/view), and then extract it to the `data/RUOD/` folder. The complete dataset structure is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── RUOD +│ │ ├── Environment_pic +│ │ ├── Environmet_ANN +│ │ ├── RUOD_ANN +│ │ ├── RUOD_pic +``` + +### 5 Brain Tumor + +Brain Tumor is a 2D detection dataset in the medical field. You can download it from [here](https://universe.roboflow.com/roboflow-100/brain-tumor-m2pbp/dataset/2), please make sure to choose the `COCO JSON` format. Then extract it to the `data/brain_tumor_v2/` folder. The complete dataset structure is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── brain_tumor_v2 +│ │ ├── test +│ │ ├── train +│ │ ├── valid +``` + +### 6 Cityscapes + +Cityscapes is an urban street scene dataset. You can download it from [here](https://www.cityscapes-dataset.com/) or from opendatalab, and then extract it to the `data/cityscapes/` folder. The complete dataset structure is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── cityscapes +│ │ ├── annotations +│ │ ├── leftImg8bit +│ │ │ ├── train +│ │ │ ├── val +│ │ ├── gtFine +│ │ │ ├── train +│ │ │ ├── val +``` + +After downloading, you can use the [cityscapes.py](../../tools/dataset_converters/cityscapes.py) script to generate the required JSON format. + +```shell +python tools/dataset_converters/cityscapes.py data/cityscapes/ +``` + +Three new JSON files will be generated in the annotations directory. The complete dataset structure is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── cityscapes +│ │ ├── annotations +│ │ │ ├── instancesonly_filtered_gtFine_train.json +│ │ │ ├── instancesonly_filtered_gtFine_val.json +│ │ │ ├── instancesonly_filtered_gtFine_test.json +│ │ ├── leftImg8bit +│ │ │ ├── train +│ │ │ ├── val +│ │ ├── gtFine +│ │ │ ├── train +│ │ │ ├── val +``` + +### 7 People in Painting + +People in Painting is an oil painting dataset that you can download from [here](https://universe.roboflow.com/roboflow-100/people-in-paintings/dataset/2). Please make sure to choose the `COCO JSON` format. After downloading, unzip the dataset to the `data/people_in_painting_v2/` folder. The complete dataset structure is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── people_in_painting_v2 +│ │ ├── test +│ │ ├── train +│ │ ├── valid +``` + +### 8 Referring Expression Comprehension + +Fine-tuning for Referential Expression Comprehension is similar to what was described earlier and includes four datasets. The dataset preparation for evaluation has already been organized. The complete dataset structure is as follows: + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ │ ├── instances_train2014.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +│ │ ├── train2014 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── mdetr_annotations +│ │ │ ├── final_refexp_val.json +│ │ │ ├── finetune_refcoco_testA.json +│ │ │ ├── finetune_refcoco_testB.json +│ │ │ ├── finetune_refcoco+_testA.json +│ │ │ ├── finetune_refcoco+_testB.json +│ │ │ ├── finetune_refcocog_test.json +│ │ │ ├── finetune_refcocog_test.json +``` + +Then we need to convert it to the required ODVG format. Please use the [refcoco2odvg.py](../../tools/dataset_converters/refcoco2odvg.py) script to perform the conversion. + +```shell +python tools/dataset_converters/refcoco2odvg.py data/coco/mdetr_annotations +``` + +The converted dataset structure will include 4 new JSON files in the `data/coco/mdetr_annotations` directory. Here is the structure of the converted dataset: + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ │ ├── instances_train2014.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +│ │ ├── train2014 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── mdetr_annotations +│ │ │ ├── final_refexp_val.json +│ │ │ ├── finetune_refcoco_testA.json +│ │ │ ├── finetune_refcoco_testB.json +│ │ │ ├── finetune_refcoco+_testA.json +│ │ │ ├── finetune_refcoco+_testB.json +│ │ │ ├── finetune_refcocog_test.json +│ │ │ ├── finetune_refcoco_train_vg.json +│ │ │ ├── finetune_refcoco+_train_vg.json +│ │ │ ├── finetune_refcocog_train_vg.json +│ │ │ ├── finetune_grefcoco_train_vg.json +``` diff --git a/mmdetection/configs/mm_grounding_dino/dataset_prepare_zh-CN.md b/mmdetection/configs/mm_grounding_dino/dataset_prepare_zh-CN.md new file mode 100644 index 00000000..10520b02 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/dataset_prepare_zh-CN.md @@ -0,0 +1,1194 @@ +# 数据准备和处理 + +## MM-GDINO-T 预训练数据准备和处理 + +MM-GDINO-T 模型中我们一共提供了 5 种不同数据组合的预训练配置，数据采用逐步累加的方式进行训练，因此用户可以根据自己的实际需求准备数据。 + +### 1 Objects365 v1 + +对应的训练配置为 [grounding_dino_swin-t_pretrain_obj365](./grounding_dino_swin-t_pretrain_obj365.py) + +Objects365_v1 可以从 [opendatalab](https://opendatalab.com/OpenDataLab/Objects365_v1) 下载，其提供了 CLI 和 SDK 两者下载方式。 + +下载并解压后，将其放置或者软链接到 `data/objects365v1` 目录下，目录结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── objects365v1 +│ │ ├── objects365_train.json +│ │ ├── objects365_val.json +│ │ ├── train +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +│ │ ├── test +``` + +然后使用 [coco2odvg.py](../../tools/dataset_converters/coco2odvg.py) 转换为训练所需的 ODVG 格式： + +```shell +python tools/dataset_converters/coco2odvg.py data/objects365v1/objects365_train.json -d o365v1 +``` + +程序运行完成后会在 `data/objects365v1` 目录下创建 `o365v1_train_od.json` 和 `o365v1_label_map.json` 两个新文件，完整结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── objects365v1 +│ │ ├── objects365_train.json +│ │ ├── objects365_val.json +│ │ ├── o365v1_train_od.json +│ │ ├── o365v1_label_map.json +│ │ ├── train +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +│ │ ├── test +``` + +### 2 COCO 2017 + +上述配置在训练过程中会评估 COCO 2017 数据集的性能，因此需要准备 COCO 2017 数据集。你可以从 [COCO](https://cocodataset.org/) 官网下载或者从 [opendatalab](https://opendatalab.com/OpenDataLab/COCO_2017) 下载 + +下载并解压后，将其放置或者软链接到 `data/coco` 目录下，目录结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +``` + +### 3 GoldG + +下载该数据集后就可以训练 [grounding_dino_swin-t_pretrain_obj365_goldg](./grounding_dino_swin-t_pretrain_obj365_goldg.py) 配置了。 + +GoldG 数据集包括 `GQA` 和 `Flickr30k` 两个数据集，来自 GLIP 论文中提到的 MixedGrounding 数据集，其排除了 COCO 数据集。下载链接为 [mdetr_annotations](https://huggingface.co/GLIPModel/GLIP/tree/main/mdetr_annotations)，我们目前需要的是 `mdetr_annotations/final_mixed_train_no_coco.json` 和 `mdetr_annotations/final_flickr_separateGT_train.json` 文件。 + +然后下载 [GQA images](https://nlp.stanford.edu/data/gqa/images.zip) 图片。下载并解压后，将其放置或者软链接到 `data/gqa` 目录下，目录结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── gqa +| | ├── final_mixed_train_no_coco.json +│ │ ├── images +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +然后下载 [Flickr30k images](http://shannon.cs.illinois.edu/DenotationGraph/) 图片。这个数据下载需要先申请，再获得下载链接后才可以下载。下载并解压后，将其放置或者软链接到 `data/flickr30k_entities` 目录下，目录结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── flickr30k_entities +│ │ ├── final_flickr_separateGT_train.json +│ │ ├── flickr30k_images +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +对于 GQA 数据集，你需要使用 [goldg2odvg.py](../../tools/dataset_converters/goldg2odvg.py) 转换为训练所需的 ODVG 格式： + +```shell +python tools/dataset_converters/goldg2odvg.py data/gqa/final_mixed_train_no_coco.json +``` + +程序运行完成后会在 `data/gqa` 目录下创建 `final_mixed_train_no_coco_vg.json` 新文件，完整结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── gqa +| | ├── final_mixed_train_no_coco.json +| | ├── final_mixed_train_no_coco_vg.json +│ │ ├── images +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +对于 Flickr30k 数据集，你需要使用 [goldg2odvg.py](../../tools/dataset_converters/goldg2odvg.py) 转换为训练所需的 ODVG 格式： + +```shell +python tools/dataset_converters/goldg2odvg.py data/flickr30k_entities/final_flickr_separateGT_train.json +``` + +程序运行完成后会在 `data/flickr30k_entities` 目录下创建 `final_flickr_separateGT_train_vg.json` 新文件，完整结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── flickr30k_entities +│ │ ├── final_flickr_separateGT_train.json +│ │ ├── final_flickr_separateGT_train_vg.json +│ │ ├── flickr30k_images +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +### 4 GRIT-20M + +对应的训练配置为 [grounding_dino_swin-t_pretrain_obj365_goldg_grit9m](./grounding_dino_swin-t_pretrain_obj365_goldg_grit9m.py) + +GRIT数据集可以从 [GRIT](https://huggingface.co/datasets/zzliang/GRIT#download-image) 中使用 img2dataset 包下载，默认指令下载后数据集大小为 1.1T，下载和处理预估需要至少 2T 硬盘空间，可根据硬盘容量酌情下载。下载后原始格式为： + +```text +mmdetection +├── configs +├── data +│ ├── grit_raw +│ │ ├── 00000_stats.json +│ │ ├── 00000.parquet +│ │ ├── 00000.tar +│ │ ├── 00001_stats.json +│ │ ├── 00001.parquet +│ │ ├── 00001.tar +│ │ ├── ... +``` + +下载后需要对格式进行进一步处理: + +```shell +python tools/dataset_converters/grit_processing.py data/grit_raw data/grit_processed +``` + +处理后的格式为： + +```text +mmdetection +├── configs +├── data +│ ├── grit_processed +│ │ ├── annotations +│ │ │ ├── 00000.json +│ │ │ ├── 00001.json +│ │ │ ├── ... +│ │ ├── images +│ │ │ ├── 00000 +│ │ │ │ ├── 000000000.jpg +│ │ │ │ ├── 000000003.jpg +│ │ │ │ ├── 000000004.jpg +│ │ │ │ ├── ... +│ │ │ ├── 00001 +│ │ │ ├── ... +``` + +对于 GRIT 数据集，你需要使用 [grit2odvg.py](../../tools/dataset_converters/grit2odvg.py) 转化成需要的 ODVG 格式： + +```shell +python tools/dataset_converters/grit2odvg.py data/grit_processed/ +``` + +程序运行完成后会在 `data/grit_processed` 目录下创建 `grit20m_vg.json` 新文件，大概包含 9M 条数据，完整结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── grit_processed +| | ├── grit20m_vg.json +│ │ ├── annotations +│ │ │ ├── 00000.json +│ │ │ ├── 00001.json +│ │ │ ├── ... +│ │ ├── images +│ │ │ ├── 00000 +│ │ │ │ ├── 000000000.jpg +│ │ │ │ ├── 000000003.jpg +│ │ │ │ ├── 000000004.jpg +│ │ │ │ ├── ... +│ │ │ ├── 00001 +│ │ │ ├── ... +``` + +### 5 V3Det + +对应的训练配置为 + +- [grounding_dino_swin-t_pretrain_obj365_goldg_v3det](./grounding_dino_swin-t_pretrain_obj365_goldg_v3det.py) +- [grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det](./grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det.py) + +V3Det 数据集下载可以从 [opendatalab](https://opendatalab.com/V3Det/V3Det) 下载，下载并解压后，将其放置或者软链接到 `data/v3det` 目录下，目录结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── v3det +│ │ ├── annotations +│ │ | ├── v3det_2023_v1_train.json +│ │ ├── images +│ │ │ ├── a00000066 +│ │ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +然后使用 [coco2odvg.py](../../tools/dataset_converters/coco2odvg.py) 转换为训练所需的 ODVG 格式： + +```shell +python tools/dataset_converters/coco2odvg.py data/v3det/annotations/v3det_2023_v1_train.json -d v3det +``` + +程序运行完成后会在 `data/v3det/annotations` 目录下创建目录下创建 `v3det_2023_v1_train_od.json` 和 `v3det_2023_v1_label_map.json` 两个新文件，完整结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── v3det +│ │ ├── annotations +│ │ | ├── v3det_2023_v1_train.json +│ │ | ├── v3det_2023_v1_train_od.json +│ │ | ├── v3det_2023_v1_label_map.json +│ │ ├── images +│ │ │ ├── a00000066 +│ │ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +### 6 数据切分和可视化 + +考虑到用户需要准备的数据集过多，不方便对图片和标注进行训练前确认，因此我们提供了一个数据切分和可视化的工具，可以将数据集切分为 tiny 版本，然后使用可视化脚本查看图片和标签正确性。 + +1. 切分数据集 + +脚本位于 [这里](../../tools/misc/split_odvg.py), 以 `Object365 v1` 为例，切分数据集的命令如下： + +```shell +python tools/misc/split_odvg.py data/object365_v1/ o365v1_train_od.json train your_output_dir --label-map-file o365v1_label_map.json -n 200 +``` + +上述脚本运行后会在 `your_output_dir` 目录下创建和 `data/object365_v1/` 一样的文件夹结构，但是只会保存 200 张训练图片和对应的 json，方便用户查看。 + +2. 可视化原始数据集 + +脚本位于 [这里](../../tools/analysis_tools/browse_grounding_raw.py), 以 `Object365 v1` 为例，可视化数据集的命令如下： + +```shell +python tools/analysis_tools/browse_grounding_raw.py data/object365_v1/ o365v1_train_od.json train --label-map-file o365v1_label_map.json -o your_output_dir --not-show +``` + +上述脚本运行后会在 `your_output_dir` 目录下生成同时包括图片和标签的图片，方便用户查看。 + +3. 可视化 dataset 输出的数据集 + +脚本位于 [这里](../../tools/analysis_tools/browse_grounding_dataset.py), 用户可以通过该脚本查看 dataset 输出的结果即包括了数据增强的结果。 以 `Object365 v1` 为例，可视化数据集的命令如下： + +```shell +python tools/analysis_tools/browse_grounding_dataset.py configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365.py -o your_output_dir --not-show +``` + +上述脚本运行后会在 `your_output_dir` 目录下生成同时包括图片和标签的图片，方便用户查看。 + +## MM-GDINO-L 预训练数据准备和处理 + +### 1 Object365 v2 + +Objects365_v2 可以从 [opendatalab](https://opendatalab.com/OpenDataLab/Objects365) 下载，其提供了 CLI 和 SDK 两者下载方式。 + +下载并解压后，将其放置或者软链接到 `data/objects365v2` 目录下，目录结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── objects365v2 +│ │ ├── annotations +│ │ │ ├── zhiyuan_objv2_train.json +│ │ ├── train +│ │ │ ├── patch0 +│ │ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +由于 objects365v2 类别中有部分类名是错误的，因此需要先进行修正。 + +```shell +python tools/dataset_converters/fix_o365_names.py +``` + +会在 `data/objects365v2/annotations` 下生成新的标注文件 `zhiyuan_objv2_train_fixname.json`。 + +然后使用 [coco2odvg.py](../../tools/dataset_converters/coco2odvg.py) 转换为训练所需的 ODVG 格式： + +```shell +python tools/dataset_converters/coco2odvg.py data/objects365v2/annotations/zhiyuan_objv2_train_fixname.json -d o365v2 +``` + +程序运行完成后会在 `data/objects365v2` 目录下创建 `zhiyuan_objv2_train_fixname_od.json` 和 `o365v2_label_map.json` 两个新文件，完整结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── objects365v2 +│ │ ├── annotations +│ │ │ ├── zhiyuan_objv2_train.json +│ │ │ ├── zhiyuan_objv2_train_fixname.json +│ │ │ ├── zhiyuan_objv2_train_fixname_od.json +│ │ │ ├── o365v2_label_map.json +│ │ ├── train +│ │ │ ├── patch0 +│ │ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +### 2 OpenImages v6 + +OpenImages v6 可以从 [官网](https://storage.googleapis.com/openimages/web/download_v6.html) 下载，由于数据集比较大，需要花费一定的时间，下载完成后文件结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── OpenImages +│ │ ├── annotations +| │ │ ├── oidv6-train-annotations-bbox.csv +| │ │ ├── class-descriptions-boxable.csv +│ │ ├── OpenImages +│ │ │ ├── train +│ │ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +然后使用 [openimages2odvg.py](../../tools/dataset_converters/openimages2odvg.py) 转换为训练所需的 ODVG 格式： + +```shell +python tools/dataset_converters/openimages2odvg.py data/OpenImages/annotations +``` + +程序运行完成后会在 `data/OpenImages/annotations` 目录下创建 `oidv6-train-annotation_od.json` 和 `openimages_label_map.json` 两个新文件，完整结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── OpenImages +│ │ ├── annotations +| │ │ ├── oidv6-train-annotations-bbox.csv +| │ │ ├── class-descriptions-boxable.csv +| │ │ ├── oidv6-train-annotations_od.json +| │ │ ├── openimages_label_map.json +│ │ ├── OpenImages +│ │ │ ├── train +│ │ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +### 3 V3Det + +参见前面的 MM-GDINO-T 预训练数据准备和处理 数据准备部分，完整数据集结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── v3det +│ │ ├── annotations +│ │ | ├── v3det_2023_v1_train.json +│ │ | ├── v3det_2023_v1_train_od.json +│ │ | ├── v3det_2023_v1_label_map.json +│ │ ├── images +│ │ │ ├── a00000066 +│ │ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +### 4 LVIS 1.0 + +参见后面的 `微调数据集准备` 的 `2 LVIS 1.0` 部分。完整数据集结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── lvis_v1_train.json +│ │ │ ├── lvis_v1_val.json +│ │ │ ├── lvis_v1_train_od.json +│ │ │ ├── lvis_v1_label_map.json +│ │ │ ├── instances_val2017.json +│ │ │ ├── lvis_v1_minival_inserted_image_name.json +│ │ │ ├── lvis_od_val.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +``` + +### 5 COCO2017 OD + +数据准备可以参考前面的 `MM-GDINO-T 预训练数据准备和处理` 部分。为了方便后续处理，请将下载的 [mdetr_annotations](https://huggingface.co/GLIPModel/GLIP/tree/main/mdetr_annotations) 文件夹软链接或者移动到 `data/coco` 路径下 +完整数据集结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ ├── mdetr_annotations +│ │ │ ├── final_refexp_val.json +│ │ │ ├── finetune_refcoco_testA.json +│ │ │ ├── ... +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +``` + +由于 COCO2017 train 和 RefCOCO/RefCOCO+/RefCOCOg/gRefCOCO val 中存在部分重叠，如果不提前移除，在评测 RefExp 时候会存在数据泄露。 + +```shell +python tools/dataset_converters/remove_cocotrain2017_from_refcoco.py data/coco/mdetr_annotations data/coco/annotations/instances_train2017.json +``` + +会在 `data/coco/annotations` 目录下创建 `instances_train2017_norefval.json` 新文件。最后使用 [coco2odvg.py](../../tools/dataset_converters/coco2odvg.py) 转换为训练所需的 ODVG 格式： + +```shell +python tools/dataset_converters/coco2odvg.py data/coco/annotations/instances_train2017_norefval.json -d coco +``` + +会在 `data/coco/annotations` 目录下创建 `instances_train2017_norefval_od.json` 和 `coco_label_map.json` 两个新文件，完整结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ │ ├── instances_train2017_norefval_od.json +│ │ │ ├── coco_label_map.json +│ │ ├── mdetr_annotations +│ │ │ ├── final_refexp_val.json +│ │ │ ├── finetune_refcoco_testA.json +│ │ │ ├── ... +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +``` + +注意： COCO2017 train 和 LVIS 1.0 val 数据集有 15000 张图片重复，因此一旦在训练中使用了 COCO2017 train，那么 LVIS 1.0 val 的评测结果就存在数据泄露问题，LVIS 1.0 minival 没有这个问题。 + +### 6 GoldG + +参见 MM-GDINO-T 预训练数据准备和处理 部分 + +```text +mmdetection +├── configs +├── data +│ ├── flickr30k_entities +│ │ ├── final_flickr_separateGT_train.json +│ │ ├── final_flickr_separateGT_train_vg.json +│ │ ├── flickr30k_images +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ ├── gqa +| | ├── final_mixed_train_no_coco.json +| | ├── final_mixed_train_no_coco_vg.json +│ │ ├── images +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +### 7 COCO2014 VG + +MDetr 中提供了 COCO2014 train 的 Phrase Grounding 版本标注， 最原始标注文件为 `final_mixed_train.json`，和之前类似，文件结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ ├── mdetr_annotations +│ │ │ ├── final_mixed_train.json +│ │ │ ├── ... +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── train2014 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +我们可以从 `final_mixed_train.json` 中提取出 COCO 部分数据 + +```shell +python tools/dataset_converters/extract_coco_from_mixed.py data/coco/mdetr_annotations/final_mixed_train.json +``` + +会在 `data/coco/mdetr_annotations` 目录下创建 `final_mixed_train_only_coco.json` 新文件，最后使用 [goldg2odvg.py](../../tools/dataset_converters/goldg2odvg.py) 转换为训练所需的 ODVG 格式： + +```shell +python tools/dataset_converters/goldg2odvg.py data/coco/mdetr_annotations/final_mixed_train_only_coco.json +``` + +会在 `data/coco/mdetr_annotations` 目录下创建 `final_mixed_train_only_coco_vg.json` 新文件，完整结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ ├── mdetr_annotations +│ │ │ ├── final_mixed_train.json +│ │ │ ├── final_mixed_train_only_coco.json +│ │ │ ├── final_mixed_train_only_coco_vg.json +│ │ │ ├── ... +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── train2014 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +注意： COCO2014 train 和 COCO2017 val 没有重复图片，因此不用担心 COCO 评测的数据泄露问题。 + +### 8 Referring Expression Comprehension + +其一共包括 4 个数据集。数据准备部分请参见 微调数据集准备 部分。 + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ │ ├── instances_train2014.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +│ │ ├── train2014 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── mdetr_annotations +│ │ │ ├── final_refexp_val.json +│ │ │ ├── finetune_refcoco_testA.json +│ │ │ ├── finetune_refcoco_testB.json +│ │ │ ├── finetune_refcoco+_testA.json +│ │ │ ├── finetune_refcoco+_testB.json +│ │ │ ├── finetune_refcocog_test.json +│ │ │ ├── finetune_refcoco_train_vg.json +│ │ │ ├── finetune_refcoco+_train_vg.json +│ │ │ ├── finetune_refcocog_train_vg.json +│ │ │ ├── finetune_grefcoco_train_vg.json +``` + +### 9 GRIT-20M + +参见 MM-GDINO-T 预训练数据准备和处理 部分 + +## 评测数据集准备 + +### 1 COCO 2017 + +数据准备流程和前面描述一致，最终结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +``` + +### 2 LVIS 1.0 + +LVIS 1.0 val 数据集包括 mini 和全量两个版本，mini 版本存在的意义是： + +1. LVIS val 全量评测数据集比较大，评测一次需要比较久的时间 +2. LVIS val 全量数据集中包括了 15000 张 COCO2017 train, 如果用户使用了 COCO2017 数据进行训练，那么将存在数据泄露问题 + +LVIS 1.0 图片和 COCO2017 数据集图片完全一样，只是提供了新的标注而已，minival 标注文件可以从 [这里](https://huggingface.co/GLIPModel/GLIP/blob/main/lvis_v1_minival_inserted_image_name.json)下载， val 1.0 标注文件可以从 [这里](https://huggingface.co/GLIPModel/GLIP/blob/main/lvis_od_val.json) 下载。 最终结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ │ ├── lvis_v1_minival_inserted_image_name.json +│ │ │ ├── lvis_od_val.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +``` + +### 3 ODinW + +ODinw 全称为 Object Detection in the Wild，是用于验证 grounding 预训练模型在不同实际场景中的泛化能力的数据集，其包括两个子集，分别是 ODinW13 和 ODinW35，代表是由 13 和 35 个数据集组成的。你可以从 [这里](https://huggingface.co/GLIPModel/GLIP/tree/main/odinw_35)下载，然后对每个文件进行解压，最终结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── odinw +│ │ ├── AerialMaritimeDrone +│ │ | |── large +│ │ | | ├── test +│ │ | | ├── train +│ │ | | ├── valid +│ │ | |── tiled +│ │ ├── AmericanSignLanguageLetters +│ │ ├── Aquarium +│ │ ├── BCCD +│ │ ├── ... +``` + +在评测 ODinW3535 时候由于需要自定义 prompt，因此需要提前对标注的 json 文件进行处理，你可以使用 [override_category.py](./odinw/override_category.py) 脚本进行处理，处理后会生成新的标注文件，不会覆盖原先的标注文件。 + +```shell +python configs/mm_grounding_dino/odinw/override_category.py data/odinw/ +``` + +### 4 DOD + +DOD 来自 [Described Object Detection: Liberating Object Detection with Flexible Expressions](https://arxiv.org/abs/2307.12813)。其数据集可以从 [这里](https://github.com/shikras/d-cube?tab=readme-ov-file#download)下载，最终的数据集结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── d3 +│ │ ├── d3_images +│ │ ├── d3_json +│ │ ├── d3_pkl +``` + +### 5 Flickr30k Entities + +在前面 GoldG 数据准备章节中我们已经下载了 Flickr30k 训练所需文件，评估所需的文件是 2 个 json 文件，你可以从 [这里](https://huggingface.co/GLIPModel/GLIP/blob/main/mdetr_annotations/final_flickr_separateGT_val.json) 和 [这里](https://huggingface.co/GLIPModel/GLIP/blob/main/mdetr_annotations/final_flickr_separateGT_test.json)下载，最终的数据集结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── flickr30k_entities +│ │ ├── final_flickr_separateGT_train.json +│ │ ├── final_flickr_separateGT_val.json +│ │ ├── final_flickr_separateGT_test.json +│ │ ├── final_flickr_separateGT_train_vg.json +│ │ ├── flickr30k_images +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +``` + +### 6 Referring Expression Comprehension + +指代性表达式理解包括 4 个数据集： RefCOCO, RefCOCO+, RefCOCOg, gRefCOCO。这 4 个数据集所采用的图片都来自于 COCO2014 train，和 COCO2017 类似，你可以从 COCO 官方或者 opendatalab 中下载，而标注可以直接从 [这里](https://huggingface.co/GLIPModel/GLIP/tree/main/mdetr_annotations) 下载，mdetr_annotations 文件夹里面包括了其他大量的标注，你如果觉得数量过多，可以只下载所需要的几个 json 文件即可。最终的数据集结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ │ ├── instances_train2014.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +│ │ ├── train2014 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── mdetr_annotations +│ │ │ ├── final_refexp_val.json +│ │ │ ├── finetune_refcoco_testA.json +│ │ │ ├── finetune_refcoco_testB.json +│ │ │ ├── finetune_refcoco+_testA.json +│ │ │ ├── finetune_refcoco+_testB.json +│ │ │ ├── finetune_refcocog_test.json +│ │ │ ├── finetune_refcocog_test.json +``` + +注意 gRefCOCO 是在 [GREC: Generalized Referring Expression Comprehension](https://arxiv.org/abs/2308.16182) 被提出，并不在 `mdetr_annotations` 文件夹中，需要自行处理。具体步骤为： + +1. 下载 [gRefCOCO](https://github.com/henghuiding/gRefCOCO?tab=readme-ov-file#grefcoco-dataset-download)，并解压到 data/coco/ 文件夹中 + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ │ ├── instances_train2014.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +│ │ ├── train2014 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── mdetr_annotations +│ │ ├── grefs +│ │ │ ├── grefs(unc).json +│ │ │ ├── instances.json +``` + +2. 转换为 coco 格式 + +你可以使用 gRefCOCO 官方提供的[转换脚本](https://github.com/henghuiding/gRefCOCO/blob/b4b1e55b4d3a41df26d6b7d843ea011d581127d4/mdetr/scripts/fine-tuning/grefexp_coco_format.py)。注意需要将被注释的 161 行打开，并注释 160 行才可以得到全量的 json 文件。 + +```shell +# 需要克隆官方 repo +git clone https://github.com/henghuiding/gRefCOCO.git +cd gRefCOCO/mdetr +python scripts/fine-tuning/grefexp_coco_format.py --data_path ../../data/coco/grefs --out_path ../../data/coco/mdetr_annotations/ --coco_path ../../data/coco +``` + +会在 `data/coco/mdetr_annotations/` 文件夹中生成 4 个 json 文件，完整的数据集结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ │ ├── instances_train2014.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +│ │ ├── train2014 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── mdetr_annotations +│ │ │ ├── final_refexp_val.json +│ │ │ ├── finetune_refcoco_testA.json +│ │ │ ├── finetune_refcoco_testB.json +│ │ │ ├── finetune_grefcoco_train.json +│ │ │ ├── finetune_grefcoco_val.json +│ │ │ ├── finetune_grefcoco_testA.json +│ │ │ ├── finetune_grefcoco_testB.json +``` + +## 微调数据集准备 + +### 1 COCO 2017 + +COCO 是检测领域最常用的数据集，我们希望能够更充分探索其微调模式。从目前发展来看，一共有 3 种微调方式： + +1. 闭集微调，即微调后文本端将无法修改描述，转变为闭集算法，在 COCO 上性能能够最大化，但是失去了通用性。 +2. 开集继续预训练微调，即对 COCO 数据集采用和预训练一致的预训练手段。此时有两种做法，第一种是降低学习率并固定某些模块，仅仅在 COCO 数据上预训练，第二种是将 COCO 数据和部分预训练数据混合一起训练，两种方式的目的都是在尽可能不降低泛化性时提高 COCO 数据集性能 +3. 开放词汇微调，即采用 OVD 领域常用做法，将 COCO 类别分成 base 类和 novel 类，训练时候仅仅在 base 类上进行，评测在 base 和 novel 类上进行。这种方式可以验证 COCO OVD 能力，目的也是在尽可能不降低泛化性时提高 COCO 数据集性能 + +**(1) 闭集微调** + +这个部分无需准备数据，直接用之前的数据即可。 + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +``` + +**(2) 开集继续预训练微调** +这种方式需要将 COCO 训练数据转换为 ODVG 格式，你可以使用如下命令转换： + +```shell +python tools/dataset_converters/coco2odvg.py data/coco/annotations/instances_train2017.json -d coco +``` + +会在 `data/coco/annotations/` 下生成新的 `instances_train2017_od.json` 和 `coco2017_label_map.json`，完整的数据集结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_train2017_od.json +│ │ │ ├── coco2017_label_map.json +│ │ │ ├── instances_val2017.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +``` + +在得到数据后，你可以自行选择单独预习还是混合预训练方式。 + +**(3) 开放词汇微调** +这种方式需要将 COCO 训练数据转换为 OVD 格式，你可以使用如下命令转换： + +```shell +python tools/dataset_converters/coco2ovd.py data/coco/ +``` + +会在 `data/coco/annotations/` 下生成新的 `instances_val2017_all_2.json` 和 `instances_val2017_seen_2.json`，完整的数据集结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_train2017_od.json +│ │ │ ├── instances_val2017_all_2.json +│ │ │ ├── instances_val2017_seen_2.json +│ │ │ ├── coco2017_label_map.json +│ │ │ ├── instances_val2017.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +``` + +然后可以直接使用 [配置](coco/grounding_dino_swin-t_finetune_16xb4_1x_coco_48_17.py) 进行训练和测试。 + +### 2 LVIS 1.0 + +LVIS 是一个包括 1203 类的数据集，同时也是一个长尾联邦数据集，对其进行微调很有意义。 由于其类别过多，我们无法对其进行闭集微调，因此只能采用开集继续预训练微调和开放词汇微调。 + +你需要先准备好 LVIS 训练 JSON 文件，你可以从 [这里](https://www.lvisdataset.org/dataset) 下载，我们只需要 `lvis_v1_train.json` 和 `lvis_v1_val.json`，然后将其放到 `data/coco/annotations/` 下，然后运行如下命令： + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── lvis_v1_train.json +│ │ │ ├── lvis_v1_val.json +│ │ │ ├── instances_val2017.json +│ │ │ ├── lvis_v1_minival_inserted_image_name.json +│ │ │ ├── lvis_od_val.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +``` + +(1) 开集继续预训练微调 + +使用如下命令转换为 ODVG 格式： + +```shell +python tools/dataset_converters/lvis2odvg.py data/coco/annotations/lvis_v1_train.json +``` + +会在 `data/coco/annotations/` 下生成新的 `lvis_v1_train_od.json` 和 `lvis_v1_label_map.json`，完整的数据集结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── lvis_v1_train.json +│ │ │ ├── lvis_v1_val.json +│ │ │ ├── lvis_v1_train_od.json +│ │ │ ├── lvis_v1_label_map.json +│ │ │ ├── instances_val2017.json +│ │ │ ├── lvis_v1_minival_inserted_image_name.json +│ │ │ ├── lvis_od_val.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +``` + +然后可以直接使用 [配置](lvis/grounding_dino_swin-t_finetune_16xb4_1x_lvis.py) 进行训练测试，或者你修改配置将其和部分预训练数据集混合使用。 + +**(2) 开放词汇微调** + +使用如下命令转换为 OVD 格式： + +```shell +python tools/dataset_converters/lvis2ovd.py data/coco/ +``` + +会在 `data/coco/annotations/` 下生成新的 `lvis_v1_train_od_norare.json` 和 `lvis_v1_label_map_norare.json`，完整的数据集结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── lvis_v1_train.json +│ │ │ ├── lvis_v1_val.json +│ │ │ ├── lvis_v1_train_od.json +│ │ │ ├── lvis_v1_label_map.json +│ │ │ ├── instances_val2017.json +│ │ │ ├── lvis_v1_minival_inserted_image_name.json +│ │ │ ├── lvis_od_val.json +│ │ │ ├── lvis_v1_train_od_norare.json +│ │ │ ├── lvis_v1_label_map_norare.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +``` + +然后可以直接使用 [配置](lvis/grounding_dino_swin-t_finetune_16xb4_1x_lvis_866_337.py) 进行训练测试 + +### 3 RTTS + +RTTS 是一个浓雾天气数据集，该数据集包含 4,322 张雾天图像，包含五个类：自行车 (bicycle)、公共汽车 (bus)、汽车 (car)、摩托车 (motorbike) 和人 (person)。可以从 [这里](https://drive.google.com/file/d/15Ei1cHGVqR1mXFep43BO7nkHq1IEGh1e/view)下载, 然后解压到 `data/RTTS/` 文件夹中。完整的数据集结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── RTTS +│ │ ├── annotations_json +│ │ ├── annotations_xml +│ │ ├── ImageSets +│ │ ├── JPEGImages +``` + +### 4 RUOD + +RUOD 是一个水下目标检测数据集，你可以从 [这里](https://drive.google.com/file/d/1hxtbdgfVveUm_DJk5QXkNLokSCTa_E5o/view)下载, 然后解压到 `data/RUOD/` 文件夹中。完整的数据集结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── RUOD +│ │ ├── Environment_pic +│ │ ├── Environmet_ANN +│ │ ├── RUOD_ANN +│ │ ├── RUOD_pic +``` + +### 5 Brain Tumor + +Brain Tumor 是一个医学领域的 2d 检测数据集，你可以从 [这里](https://universe.roboflow.com/roboflow-100/brain-tumor-m2pbp/dataset/2)下载, 请注意选择 `COCO JSON` 格式。然后解压到 `data/brain_tumor_v2/` 文件夹中。完整的数据集结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── brain_tumor_v2 +│ │ ├── test +│ │ ├── train +│ │ ├── valid +``` + +### 6 Cityscapes + +Cityscapes 是一个城市街景数据集，你可以从 [这里](https://www.cityscapes-dataset.com/) 或者 opendatalab 中下载, 然后解压到 `data/cityscapes/` 文件夹中。完整的数据集结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── cityscapes +│ │ ├── annotations +│ │ ├── leftImg8bit +│ │ │ ├── train +│ │ │ ├── val +│ │ ├── gtFine +│ │ │ ├── train +│ │ │ ├── val +``` + +在下载后，然后使用 [cityscapes.py](../../tools/dataset_converters/cityscapes.py) 脚本生成我们所需要的 json 格式 + +```shell +python tools/dataset_converters/cityscapes.py data/cityscapes/ +``` + +会在 annotations 中生成 3 个新的 json 文件。完整的数据集结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── cityscapes +│ │ ├── annotations +│ │ │ ├── instancesonly_filtered_gtFine_train.json +│ │ │ ├── instancesonly_filtered_gtFine_val.json +│ │ │ ├── instancesonly_filtered_gtFine_test.json +│ │ ├── leftImg8bit +│ │ │ ├── train +│ │ │ ├── val +│ │ ├── gtFine +│ │ │ ├── train +│ │ │ ├── val +``` + +### 7 People in Painting + +People in Painting 是一个油画数据集，你可以从 [这里](https://universe.roboflow.com/roboflow-100/people-in-paintings/dataset/2), 请注意选择 `COCO JSON` 格式。然后解压到 `data/people_in_painting_v2/` 文件夹中。完整的数据集结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── people_in_painting_v2 +│ │ ├── test +│ │ ├── train +│ │ ├── valid +``` + +### 8 Referring Expression Comprehension + +指代性表达式理解的微调和前面一样，也是包括 4 个数据集，在评测数据准备阶段已经全部整理好了，完整的数据集结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ │ ├── instances_train2014.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +│ │ ├── train2014 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── mdetr_annotations +│ │ │ ├── final_refexp_val.json +│ │ │ ├── finetune_refcoco_testA.json +│ │ │ ├── finetune_refcoco_testB.json +│ │ │ ├── finetune_refcoco+_testA.json +│ │ │ ├── finetune_refcoco+_testB.json +│ │ │ ├── finetune_refcocog_test.json +│ │ │ ├── finetune_refcocog_test.json +``` + +然后我们需要将其转换为所需的 ODVG 格式，请使用 [refcoco2odvg.py](../../tools/dataset_converters/refcoco2odvg.py) 脚本转换， + +```shell +python tools/dataset_converters/refcoco2odvg.py data/coco/mdetr_annotations +``` + +会在 `data/coco/mdetr_annotations` 中生成新的 4 个 json 文件。 转换后的数据集结构如下： + +```text +mmdetection +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── instances_train2017.json +│ │ │ ├── instances_val2017.json +│ │ │ ├── instances_train2014.json +│ │ ├── train2017 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── val2017 +│ │ │ ├── xxxx.jpg +│ │ │ ├── ... +│ │ ├── train2014 +│ │ │ ├── xxx.jpg +│ │ │ ├── ... +│ │ ├── mdetr_annotations +│ │ │ ├── final_refexp_val.json +│ │ │ ├── finetune_refcoco_testA.json +│ │ │ ├── finetune_refcoco_testB.json +│ │ │ ├── finetune_refcoco+_testA.json +│ │ │ ├── finetune_refcoco+_testB.json +│ │ │ ├── finetune_refcocog_test.json +│ │ │ ├── finetune_refcoco_train_vg.json +│ │ │ ├── finetune_refcoco+_train_vg.json +│ │ │ ├── finetune_refcocog_train_vg.json +│ │ │ ├── finetune_grefcoco_train_vg.json +``` diff --git a/mmdetection/configs/mm_grounding_dino/dod/grounding_dino_swin-t_pretrain_zeroshot_concat_dod.py b/mmdetection/configs/mm_grounding_dino/dod/grounding_dino_swin-t_pretrain_zeroshot_concat_dod.py new file mode 100644 index 00000000..e59a0a52 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/dod/grounding_dino_swin-t_pretrain_zeroshot_concat_dod.py @@ -0,0 +1,78 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365.py' + +data_root = 'data/d3/' + +test_pipeline = [ + dict( + type='LoadImageFromFile', backend_args=None, + imdecode_backend='pillow'), + dict( + type='FixScaleResize', + scale=(800, 1333), + keep_ratio=True, + backend='pillow'), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'text', 'custom_entities', 'sent_ids')) +] + +# -------------------------------------------------# +val_dataset_full = dict( + type='DODDataset', + data_root=data_root, + ann_file='d3_json/d3_full_annotations.json', + data_prefix=dict(img='d3_images/', anno='d3_pkl'), + pipeline=test_pipeline, + test_mode=True, + backend_args=None, + return_classes=True) + +val_evaluator_full = dict( + type='DODCocoMetric', + ann_file=data_root + 'd3_json/d3_full_annotations.json') + +# -------------------------------------------------# +val_dataset_pres = dict( + type='DODDataset', + data_root=data_root, + ann_file='d3_json/d3_pres_annotations.json', + data_prefix=dict(img='d3_images/', anno='d3_pkl'), + pipeline=test_pipeline, + test_mode=True, + backend_args=None, + return_classes=True) +val_evaluator_pres = dict( + type='DODCocoMetric', + ann_file=data_root + 'd3_json/d3_pres_annotations.json') + +# -------------------------------------------------# +val_dataset_abs = dict( + type='DODDataset', + data_root=data_root, + ann_file='d3_json/d3_abs_annotations.json', + data_prefix=dict(img='d3_images/', anno='d3_pkl'), + pipeline=test_pipeline, + test_mode=True, + backend_args=None, + return_classes=True) +val_evaluator_abs = dict( + type='DODCocoMetric', + ann_file=data_root + 'd3_json/d3_abs_annotations.json') + +# -------------------------------------------------# +datasets = [val_dataset_full, val_dataset_pres, val_dataset_abs] +dataset_prefixes = ['FULL', 'PRES', 'ABS'] +metrics = [val_evaluator_full, val_evaluator_pres, val_evaluator_abs] + +val_dataloader = dict( + dataset=dict(_delete_=True, type='ConcatDataset', datasets=datasets)) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + type='MultiDatasetsEvaluator', + metrics=metrics, + dataset_prefixes=dataset_prefixes) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/mm_grounding_dino/dod/grounding_dino_swin-t_pretrain_zeroshot_parallel_dod.py b/mmdetection/configs/mm_grounding_dino/dod/grounding_dino_swin-t_pretrain_zeroshot_parallel_dod.py new file mode 100644 index 00000000..3d680091 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/dod/grounding_dino_swin-t_pretrain_zeroshot_parallel_dod.py @@ -0,0 +1,3 @@ +_base_ = 'grounding_dino_swin-t_pretrain_zeroshot_concat_dod.py' + +model = dict(test_cfg=dict(chunked_size=1)) diff --git a/mmdetection/configs/mm_grounding_dino/flickr30k/grounding_dino_swin-t-pretrain_flickr30k.py b/mmdetection/configs/mm_grounding_dino/flickr30k/grounding_dino_swin-t-pretrain_flickr30k.py new file mode 100644 index 00000000..e9eb783d --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/flickr30k/grounding_dino_swin-t-pretrain_flickr30k.py @@ -0,0 +1,57 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365.py' + +dataset_type = 'Flickr30kDataset' +data_root = 'data/flickr30k_entities/' + +test_pipeline = [ + dict( + type='LoadImageFromFile', backend_args=None, + imdecode_backend='pillow'), + dict( + type='FixScaleResize', + scale=(800, 1333), + keep_ratio=True, + backend='pillow'), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'text', 'custom_entities', + 'tokens_positive', 'phrase_ids', 'phrases')) +] + +dataset_Flickr30k_val = dict( + type=dataset_type, + data_root=data_root, + ann_file='final_flickr_separateGT_val.json', + data_prefix=dict(img='flickr30k_images/'), + pipeline=test_pipeline, +) + +dataset_Flickr30k_test = dict( + type=dataset_type, + data_root=data_root, + ann_file='final_flickr_separateGT_test.json', + data_prefix=dict(img='flickr30k_images/'), + pipeline=test_pipeline, +) + +val_evaluator_Flickr30k = dict(type='Flickr30kMetric') + +test_evaluator_Flickr30k = dict(type='Flickr30kMetric') + +# ----------Config---------- # +dataset_prefixes = ['Flickr30kVal', 'Flickr30kTest'] +datasets = [dataset_Flickr30k_val, dataset_Flickr30k_test] +metrics = [val_evaluator_Flickr30k, test_evaluator_Flickr30k] + +val_dataloader = dict( + dataset=dict(_delete_=True, type='ConcatDataset', datasets=datasets)) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + type='MultiDatasetsEvaluator', + metrics=metrics, + dataset_prefixes=dataset_prefixes) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-b_pretrain_all.py b/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-b_pretrain_all.py new file mode 100644 index 00000000..eff58bba --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-b_pretrain_all.py @@ -0,0 +1,335 @@ +_base_ = 'grounding_dino_swin-t_pretrain_obj365.py' + +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-b_pretrain_obj365_goldg_v3det/grounding_dino_swin-b_pretrain_obj365_goldg_v3de-f83eef00.pth' # noqa + +model = dict( + use_autocast=True, + backbone=dict( + _delete_=True, + type='SwinTransformer', + pretrain_img_size=384, + embed_dims=128, + depths=[2, 2, 18, 2], + num_heads=[4, 8, 16, 32], + window_size=12, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.3, + patch_norm=True, + out_indices=(1, 2, 3), + with_cp=True, + convert_weights=True, + frozen_stages=-1, + init_cfg=None), + neck=dict(in_channels=[256, 512, 1024]), +) + +o365v1_od_dataset = dict( + type='ODVGDataset', + data_root='data/objects365v1/', + ann_file='o365v1_train_odvg.json', + label_map_file='o365v1_label_map.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None, +) + +flickr30k_dataset = dict( + type='ODVGDataset', + data_root='data/flickr30k_entities/', + ann_file='final_flickr_separateGT_train_vg.json', + label_map_file=None, + data_prefix=dict(img='flickr30k_images/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None) + +gqa_dataset = dict( + type='ODVGDataset', + data_root='data/gqa/', + ann_file='final_mixed_train_no_coco_vg.json', + label_map_file=None, + data_prefix=dict(img='images/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None) + +v3d_train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict( + type='RandomSamplingNegPos', + tokenizer_name=_base_.lang_model_name, + num_sample_negative=85, + # change this + label_map_file='data/V3Det/annotations/v3det_2023_v1_label_map.json', + max_tokens=256), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities', 'tokens_positive', 'dataset_mode')) +] +v3det_dataset = dict( + type='ODVGDataset', + data_root='data/V3Det/', + ann_file='annotations/v3det_2023_v1_train_od.json', + label_map_file='annotations/v3det_2023_v1_label_map.json', + data_prefix=dict(img=''), + filter_cfg=dict(filter_empty_gt=False), + need_text=False, # change this + pipeline=v3d_train_pipeline, + return_classes=True, + backend_args=None) + +grit_dataset = dict( + type='ODVGDataset', + data_root='grit_processed/', + ann_file='grit20m_vg.json', + label_map_file=None, + data_prefix=dict(img=''), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None) + +# --------------------------- lvis od dataset--------------------------- +lvis_train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict( + type='RandomSamplingNegPos', + tokenizer_name=_base_.lang_model_name, + num_sample_negative=85, + # change this + label_map_file='data/coco/annotations/lvis_v1_label_map.json', + max_tokens=256), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities', 'tokens_positive', 'dataset_mode')) +] +lvis_dataset = dict( + type='ClassBalancedDataset', + oversample_thr=1e-3, + dataset=dict( + type='ODVGDataset', + data_root='data/coco/', + ann_file='annotations/lvis_v1_train_od.json', + label_map_file='annotations/lvis_v1_label_map.json', + data_prefix=dict(img=''), + filter_cfg=dict(filter_empty_gt=False), + need_text=False, # change this + pipeline=lvis_train_pipeline, + return_classes=True, + backend_args=None)) + +# --------------------------- coco2017 od dataset--------------------------- +coco2017_train_dataset = dict( + type='RepeatDataset', + times=2, + dataset=dict( + type='ODVGDataset', + data_root='data/coco/', + ann_file='annotations/instance_train2017_norefval_od.json', + label_map_file='annotations/coco2017_label_map.json', + data_prefix=dict(img='train2017'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None)) + +# --------------------------- coco2014 vg dataset--------------------------- +coco2014_vg_dataset = dict( + type='ODVGDataset', + data_root='data/coco/', + ann_file='mdetr_annotations/final_mixed_train_only_coco_vg.json', + label_map_file=None, + data_prefix=dict(img='train2014/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None) + +# --------------------------- refcoco vg dataset--------------------------- +refcoco_dataset = dict( + type='RepeatDataset', + times=2, + dataset=dict( + type='ODVGDataset', + data_root='data/coco/', + ann_file='mdetr_annotations/finetune_refcoco_train_vg.json', + label_map_file=None, + data_prefix=dict(img='train2014'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None)) + +# --------------------------- refcoco+ vg dataset--------------------------- +refcoco_plus_dataset = dict( + type='RepeatDataset', + times=2, + dataset=dict( + type='ODVGDataset', + data_root='data/coco/', + ann_file='mdetr_annotations/finetune_refcoco+_train_vg.json', + label_map_file=None, + data_prefix=dict(img='train2014'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None)) + +# --------------------------- refcocog vg dataset--------------------------- +refcocog_dataset = dict( + type='RepeatDataset', + times=3, + dataset=dict( + type='ODVGDataset', + data_root='data/coco/', + ann_file='mdetr_annotations/finetune_refcocog_train_vg.json', + label_map_file=None, + data_prefix=dict(img='train2014'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None)) + +# --------------------------- grefcoco vg dataset--------------------------- +grefcoco_dataset = dict( + type='RepeatDataset', + times=2, + dataset=dict( + type='ODVGDataset', + data_root='data/coco/', + ann_file='mdetr_annotations/finetune_grefcoco_train_vg.json', + label_map_file=None, + data_prefix=dict(img='train2014'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None)) + +# --------------------------- dataloader--------------------------- +train_dataloader = dict( + batch_size=4, + num_workers=4, + sampler=dict( + _delete_=True, + type='CustomSampleSizeSampler', + ratio_mode=True, + dataset_size=[-1, -1, 0.07, -1, -1, -1, -1, -1, -1, -1, -1, -1]), + dataset=dict(datasets=[ + o365v1_od_dataset, # 1.74M + v3det_dataset, # + grit_dataset, + lvis_dataset, + coco2017_train_dataset, # 0.12M + flickr30k_dataset, # 0.15M + gqa_dataset, # 0.62M + coco2014_vg_dataset, # 0.49M + refcoco_dataset, # 0.12M + refcoco_plus_dataset, # 0.12M + refcocog_dataset, # 0.08M + grefcoco_dataset, # 0.19M + ])) + +optim_wrapper = dict(optimizer=dict(lr=0.0001)) + +# learning policy +max_iter = 304680 +train_cfg = dict( + _delete_=True, + type='IterBasedTrainLoop', + max_iters=max_iter, + val_interval=10000) + +param_scheduler = [ + dict(type='LinearLR', start_factor=0.1, by_epoch=False, begin=0, end=1000), + dict( + type='MultiStepLR', + begin=0, + end=max_iter, + by_epoch=False, + milestones=[228510], + gamma=0.1) +] + +default_hooks = dict( + checkpoint=dict(by_epoch=False, interval=10000, max_keep_ckpts=20)) +log_processor = dict(by_epoch=False) diff --git a/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-b_pretrain_obj365_goldg_v3det.py b/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-b_pretrain_obj365_goldg_v3det.py new file mode 100644 index 00000000..743d02cf --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-b_pretrain_obj365_goldg_v3det.py @@ -0,0 +1,143 @@ +_base_ = 'grounding_dino_swin-t_pretrain_obj365.py' + +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_base_patch4_window12_384_22k.pth' # noqa +model = dict( + use_autocast=True, + backbone=dict( + _delete_=True, + type='SwinTransformer', + pretrain_img_size=384, + embed_dims=128, + depths=[2, 2, 18, 2], + num_heads=[4, 8, 16, 32], + window_size=12, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.3, + patch_norm=True, + out_indices=(1, 2, 3), + with_cp=True, + convert_weights=True, + frozen_stages=-1, + init_cfg=dict(type='Pretrained', checkpoint=pretrained)), + neck=dict(in_channels=[256, 512, 1024]), +) + +o365v1_od_dataset = dict( + type='ODVGDataset', + data_root='data/objects365v1/', + ann_file='o365v1_train_odvg.json', + label_map_file='o365v1_label_map.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None, +) + +flickr30k_dataset = dict( + type='ODVGDataset', + data_root='data/flickr30k_entities/', + ann_file='final_flickr_separateGT_train_vg.json', + label_map_file=None, + data_prefix=dict(img='flickr30k_images/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None) + +gqa_dataset = dict( + type='ODVGDataset', + data_root='data/gqa/', + ann_file='final_mixed_train_no_coco_vg.json', + label_map_file=None, + data_prefix=dict(img='images/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None) + +v3d_train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict( + type='RandomSamplingNegPos', + tokenizer_name=_base_.lang_model_name, + num_sample_negative=85, + # change this + label_map_file='data/V3Det/annotations/v3det_2023_v1_label_map.json', + max_tokens=256), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities', 'tokens_positive', 'dataset_mode')) +] +v3det_dataset = dict( + type='ODVGDataset', + data_root='data/V3Det/', + ann_file='annotations/v3det_2023_v1_train_od.json', + label_map_file='annotations/v3det_2023_v1_label_map.json', + data_prefix=dict(img=''), + filter_cfg=dict(filter_empty_gt=False), + need_text=False, # change this + pipeline=v3d_train_pipeline, + return_classes=True, + backend_args=None) + +train_dataloader = dict( + dataset=dict(datasets=[ + o365v1_od_dataset, flickr30k_dataset, gqa_dataset, v3det_dataset + ])) + +# learning policy +max_epochs = 18 +param_scheduler = [ + dict(type='LinearLR', start_factor=0.1, by_epoch=False, begin=0, end=1000), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[13, 16], + gamma=0.1) +] + +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) diff --git a/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-l_pretrain_all.py b/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-l_pretrain_all.py new file mode 100644 index 00000000..a17f2344 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-l_pretrain_all.py @@ -0,0 +1,540 @@ +_base_ = 'grounding_dino_swin-t_pretrain_obj365.py' + +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-l_pretrain_obj365_goldg/grounding_dino_swin-l_pretrain_obj365_goldg-34dcdc53.pth' # noqa + +num_levels = 5 +model = dict( + use_autocast=True, + num_feature_levels=num_levels, + backbone=dict( + _delete_=True, + type='SwinTransformer', + pretrain_img_size=384, + embed_dims=192, + depths=[2, 2, 18, 2], + num_heads=[6, 12, 24, 48], + window_size=12, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.2, + patch_norm=True, + out_indices=(0, 1, 2, 3), + # Please only add indices that would be used + # in FPN, otherwise some parameter will not be used + with_cp=True, + convert_weights=True, + frozen_stages=-1, + init_cfg=None), + neck=dict(in_channels=[192, 384, 768, 1536], num_outs=num_levels), + encoder=dict(layer_cfg=dict(self_attn_cfg=dict(num_levels=num_levels))), + decoder=dict(layer_cfg=dict(cross_attn_cfg=dict(num_levels=num_levels)))) + +# --------------------------- object365v2 od dataset--------------------------- +# objv2_backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/objects365v2/': 'yudong:s3://wangyudong/obj365_v2/', +# 'data/objects365v2/': 'yudong:s3://wangyudong/obj365_v2/' +# })) +objv2_backend_args = None + +objv2_train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=objv2_backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict( + type='RandomSamplingNegPos', + tokenizer_name=_base_.lang_model_name, + num_sample_negative=85, + # change this + label_map_file='data/objects365v2/annotations/o365v2_label_map.json', + max_tokens=256), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities', 'tokens_positive', 'dataset_mode')) +] + +o365v2_dataset = dict( + type='ODVGDataset', + data_root='data/objects365v2/', + ann_file='annotations/zhiyuan_objv2_train_od.json', + label_map_file='annotations/o365v2_label_map.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=objv2_train_pipeline, + return_classes=True, + need_text=False, + backend_args=None, +) + +# --------------------------- openimagev6 od dataset--------------------------- +# oi_backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +oi_backend_args = None + +oi_train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=oi_backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict( + type='RandomSamplingNegPos', + tokenizer_name=_base_.lang_model_name, + num_sample_negative=85, + # change this + label_map_file='data/OpenImages/annotations/openimages_label_map.json', + max_tokens=256), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities', 'tokens_positive', 'dataset_mode')) +] + +oiv6_dataset = dict( + type='ODVGDataset', + data_root='data/OpenImages/', + ann_file='annotations/oidv6-train-annotations_od.json', + label_map_file='annotations/openimages_label_map.json', + data_prefix=dict(img='OpenImages/train/'), + filter_cfg=dict(filter_empty_gt=False), + need_text=False, + pipeline=oi_train_pipeline, + return_classes=True, + backend_args=None) + +# --------------------------- v3det od dataset--------------------------- +v3d_train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict( + type='RandomSamplingNegPos', + tokenizer_name=_base_.lang_model_name, + num_sample_negative=85, + # change this + label_map_file='data/V3Det/annotations/v3det_2023_v1_label_map.json', + max_tokens=256), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities', 'tokens_positive', 'dataset_mode')) +] +v3det_dataset = dict( + type='RepeatDataset', + times=2, + dataset=dict( + type='ODVGDataset', + data_root='data/V3Det/', + ann_file='annotations/v3det_2023_v1_train_od.json', + label_map_file='annotations/v3det_2023_v1_label_map.json', + data_prefix=dict(img=''), + filter_cfg=dict(filter_empty_gt=False), + need_text=False, + pipeline=v3d_train_pipeline, + return_classes=True, + backend_args=None)) + +# --------------------------- lvis od dataset--------------------------- +lvis_train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict( + type='RandomSamplingNegPos', + tokenizer_name=_base_.lang_model_name, + num_sample_negative=85, + # change this + label_map_file='data/coco/annotations/lvis_v1_label_map.json', + max_tokens=256), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities', 'tokens_positive', 'dataset_mode')) +] +lvis_dataset = dict( + type='ClassBalancedDataset', + oversample_thr=1e-3, + dataset=dict( + type='ODVGDataset', + data_root='data/coco/', + ann_file='annotations/lvis_v1_train_od.json', + label_map_file='annotations/lvis_v1_label_map.json', + data_prefix=dict(img=''), + filter_cfg=dict(filter_empty_gt=False), + need_text=False, # change this + pipeline=lvis_train_pipeline, + return_classes=True, + backend_args=None)) + +# --------------------------- coco2017 od dataset--------------------------- +coco2017_train_dataset = dict( + type='RepeatDataset', + times=2, + dataset=dict( + type='ODVGDataset', + data_root='data/coco/', + ann_file='annotations/instance_train2017_norefval_od.json', + label_map_file='annotations/coco2017_label_map.json', + data_prefix=dict(img='train2017'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None)) + +# --------------------------- flickr30k vg dataset--------------------------- +flickr30k_dataset = dict( + type='RepeatDataset', + times=2, + dataset=dict( + type='ODVGDataset', + data_root='data/flickr30k_entities/', + ann_file='final_flickr_separateGT_train_vg.json', + label_map_file=None, + data_prefix=dict(img='flickr30k_images/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None)) + +# --------------------------- gqa vg dataset--------------------------- +gqa_dataset = dict( + type='ODVGDataset', + data_root='data/gqa/', + ann_file='final_mixed_train_no_coco_vg.json', + label_map_file=None, + data_prefix=dict(img='images/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None) + +# --------------------------- coco2014 vg dataset--------------------------- +coco2014_vg_dataset = dict( + type='ODVGDataset', + data_root='data/coco/', + ann_file='mdetr_annotations/final_mixed_train_only_coco_vg.json', + label_map_file=None, + data_prefix=dict(img='train2014/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None) + +# --------------------------- refcoco vg dataset--------------------------- +refcoco_dataset = dict( + type='RepeatDataset', + times=2, + dataset=dict( + type='ODVGDataset', + data_root='data/coco/', + ann_file='mdetr_annotations/finetune_refcoco_train_vg.json', + label_map_file=None, + data_prefix=dict(img='train2014'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None)) + +# --------------------------- refcoco+ vg dataset--------------------------- +refcoco_plus_dataset = dict( + type='RepeatDataset', + times=2, + dataset=dict( + type='ODVGDataset', + data_root='data/coco/', + ann_file='mdetr_annotations/finetune_refcoco+_train_vg.json', + label_map_file=None, + data_prefix=dict(img='train2014'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None)) + +# --------------------------- refcocog vg dataset--------------------------- +refcocog_dataset = dict( + type='RepeatDataset', + times=3, + dataset=dict( + type='ODVGDataset', + data_root='data/coco/', + ann_file='mdetr_annotations/finetune_refcocog_train_vg.json', + label_map_file=None, + data_prefix=dict(img='train2014'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None)) + +# --------------------------- grefcoco vg dataset--------------------------- +grefcoco_dataset = dict( + type='RepeatDataset', + times=2, + dataset=dict( + type='ODVGDataset', + data_root='data/coco/', + ann_file='mdetr_annotations/finetune_grefcoco_train_vg.json', + label_map_file=None, + data_prefix=dict(img='train2014'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None)) + +# --------------------------- grit vg dataset--------------------------- +# grit_backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/grit/': 'yichen:s3://chenyicheng/grit/', +# 'data/grit/': 'yichen:s3://chenyicheng/grit/' +# })) +grit_backend_args = None + +grit_train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=grit_backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict( + type='RandomSamplingNegPos', + tokenizer_name=_base_.lang_model_name, + num_sample_negative=85, + max_tokens=256), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities', 'tokens_positive', 'dataset_mode')) +] + +grit_dataset = dict( + type='ODVGDataset', + data_root='data/grit/', + ann_file='grit20m_vg.json', + label_map_file=None, + data_prefix=dict(img=''), + filter_cfg=dict(filter_empty_gt=False), + pipeline=grit_train_pipeline, + return_classes=True, + backend_args=None) + +# --------------------------- dataloader--------------------------- +train_dataloader = dict( + batch_size=4, + num_workers=4, + sampler=dict( + _delete_=True, + type='CustomSampleSizeSampler', + ratio_mode=True, + # OD ~ 1.74+1.67*0.5+0.18*2+0.12*2+0.1=3.2 + # vg ~ 0.15*2+0.62*1+0.49*1+0.12*2+0.12*2+0.08*3+0.19*2+9*0.09=3.3 + dataset_size=[-1, 0.5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0.09]), + dataset=dict(datasets=[ + o365v2_dataset, # 1.74M + oiv6_dataset, # 1.67M + v3det_dataset, # 0.18M + coco2017_train_dataset, # 0.12M + lvis_dataset, # 0.1M + flickr30k_dataset, # 0.15M + gqa_dataset, # 0.62M + coco2014_vg_dataset, # 0.49M + refcoco_dataset, # 0.12M + refcoco_plus_dataset, # 0.12M + refcocog_dataset, # 0.08M + grefcoco_dataset, # 0.19M + grit_dataset # 9M + ])) + +# 4NODES * 8GPU +optim_wrapper = dict(optimizer=dict(lr=0.0001)) + +max_iter = 250000 +train_cfg = dict( + _delete_=True, + type='IterBasedTrainLoop', + max_iters=max_iter, + val_interval=13000) + +param_scheduler = [ + dict(type='LinearLR', start_factor=0.1, by_epoch=False, begin=0, end=1000), + dict( + type='MultiStepLR', + begin=0, + end=max_iter, + by_epoch=False, + milestones=[210000], + gamma=0.1) +] + +default_hooks = dict( + checkpoint=dict(by_epoch=False, interval=13000, max_keep_ckpts=30)) +log_processor = dict(by_epoch=False) diff --git a/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-l_pretrain_obj365_goldg.py b/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-l_pretrain_obj365_goldg.py new file mode 100644 index 00000000..85d43f96 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-l_pretrain_obj365_goldg.py @@ -0,0 +1,227 @@ +_base_ = 'grounding_dino_swin-t_pretrain_obj365.py' + +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_large_patch4_window12_384_22k.pth' # noqa +num_levels = 5 +model = dict( + use_autocast=True, + num_feature_levels=num_levels, + backbone=dict( + _delete_=True, + type='SwinTransformer', + pretrain_img_size=384, + embed_dims=192, + depths=[2, 2, 18, 2], + num_heads=[6, 12, 24, 48], + window_size=12, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.2, + patch_norm=True, + out_indices=(0, 1, 2, 3), + # Please only add indices that would be used + # in FPN, otherwise some parameter will not be used + with_cp=True, + convert_weights=True, + frozen_stages=-1, + init_cfg=dict(type='Pretrained', checkpoint=pretrained)), + neck=dict(in_channels=[192, 384, 768, 1536], num_outs=num_levels), + encoder=dict(layer_cfg=dict(self_attn_cfg=dict(num_levels=num_levels))), + decoder=dict(layer_cfg=dict(cross_attn_cfg=dict(num_levels=num_levels)))) + +# --------------------------- object365v2 od dataset--------------------------- +# objv2_backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/objects365v2/': 'yudong:s3://wangyudong/obj365_v2/', +# 'data/objects365v2/': 'yudong:s3://wangyudong/obj365_v2/' +# })) +objv2_backend_args = None + +objv2_train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=objv2_backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict( + type='RandomSamplingNegPos', + tokenizer_name=_base_.lang_model_name, + num_sample_negative=85, + # change this + label_map_file='data/objects365v2/annotations/o365v2_label_map.json', + max_tokens=256), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities', 'tokens_positive', 'dataset_mode')) +] + +o365v2_dataset = dict( + type='ODVGDataset', + data_root='data/objects365v2/', + ann_file='annotations/zhiyuan_objv2_train_od.json', + label_map_file='annotations/o365v2_label_map.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=objv2_train_pipeline, + return_classes=True, + need_text=False, + backend_args=None, +) + +# --------------------------- openimagev6 od dataset--------------------------- +# oi_backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +oi_backend_args = None + +oi_train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=oi_backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict( + type='RandomSamplingNegPos', + tokenizer_name=_base_.lang_model_name, + num_sample_negative=85, + # change this + label_map_file='data/OpenImages/annotations/openimages_label_map.json', + max_tokens=256), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities', 'tokens_positive', 'dataset_mode')) +] + +oiv6_dataset = dict( + type='ODVGDataset', + data_root='data/OpenImages/', + ann_file='annotations/oidv6-train-annotations_od.json', + label_map_file='annotations/openimages_label_map.json', + data_prefix=dict(img='OpenImages/train/'), + filter_cfg=dict(filter_empty_gt=False), + need_text=False, + pipeline=oi_train_pipeline, + return_classes=True, + backend_args=None) + +flickr30k_dataset = dict( + type='ODVGDataset', + data_root='data/flickr30k_entities/', + ann_file='final_flickr_separateGT_train_vg.json', + label_map_file=None, + data_prefix=dict(img='flickr30k_images/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None) + +gqa_dataset = dict( + type='ODVGDataset', + data_root='data/gqa/', + ann_file='final_mixed_train_no_coco_vg.json', + label_map_file=None, + data_prefix=dict(img='images/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None) + +train_dataloader = dict( + dataset=dict(datasets=[ + o365v2_dataset, oiv6_dataset, flickr30k_dataset, gqa_dataset + ])) + +# 4Nodex8GPU +optim_wrapper = dict(optimizer=dict(lr=0.0002)) + +max_iter = 200000 +train_cfg = dict( + _delete_=True, + type='IterBasedTrainLoop', + max_iters=max_iter, + val_interval=13000) + +param_scheduler = [ + dict(type='LinearLR', start_factor=0.1, by_epoch=False, begin=0, end=1000), + dict( + type='MultiStepLR', + begin=0, + end=max_iter, + by_epoch=False, + milestones=[156100], + gamma=0.5) +] + +default_hooks = dict( + checkpoint=dict(by_epoch=False, interval=13000, max_keep_ckpts=30)) +log_processor = dict(by_epoch=False) diff --git a/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_finetune_8xb4_20e_cat.py b/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_finetune_8xb4_20e_cat.py new file mode 100644 index 00000000..bf3b3589 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_finetune_8xb4_20e_cat.py @@ -0,0 +1,102 @@ +_base_ = 'grounding_dino_swin-t_pretrain_obj365.py' + +data_root = 'data/cat/' +class_name = ('cat', ) +num_classes = len(class_name) +metainfo = dict(classes=class_name, palette=[(220, 20, 60)]) + +model = dict(bbox_head=dict(num_classes=num_classes)) + +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities')) +] + +train_dataloader = dict( + dataset=dict( + _delete_=True, + type='CocoDataset', + data_root=data_root, + metainfo=metainfo, + return_classes=True, + pipeline=train_pipeline, + filter_cfg=dict(filter_empty_gt=False, min_size=32), + ann_file='annotations/trainval.json', + data_prefix=dict(img='images/'))) + +val_dataloader = dict( + dataset=dict( + metainfo=metainfo, + data_root=data_root, + ann_file='annotations/test.json', + data_prefix=dict(img='images/'))) + +test_dataloader = val_dataloader + +val_evaluator = dict(ann_file=data_root + 'annotations/test.json') +test_evaluator = val_evaluator + +max_epoch = 20 + +default_hooks = dict( + checkpoint=dict(interval=1, max_keep_ckpts=1, save_best='auto'), + logger=dict(type='LoggerHook', interval=5)) +train_cfg = dict(max_epochs=max_epoch, val_interval=1) + +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epoch, + by_epoch=True, + milestones=[15], + gamma=0.1) +] + +optim_wrapper = dict( + optimizer=dict(lr=0.0001), + paramwise_cfg=dict( + custom_keys={ + 'absolute_pos_embed': dict(decay_mult=0.), + 'backbone': dict(lr_mult=0.0), + 'language_model': dict(lr_mult=0.0) + })) + +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth' # noqa diff --git a/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365.py b/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365.py new file mode 100644 index 00000000..66060f45 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365.py @@ -0,0 +1,247 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_tiny_patch4_window7_224.pth' # noqa +lang_model_name = 'bert-base-uncased' + +model = dict( + type='GroundingDINO', + num_queries=900, + with_box_refine=True, + as_two_stage=True, + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_mask=False, + ), + language_model=dict( + type='BertModel', + name=lang_model_name, + max_tokens=256, + pad_to_max=False, + use_sub_sentence_represent=True, + special_tokens_list=['[CLS]', '[SEP]', '.', '?'], + add_pooling_layer=False, + ), + backbone=dict( + type='SwinTransformer', + embed_dims=96, + depths=[2, 2, 6, 2], + num_heads=[3, 6, 12, 24], + window_size=7, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.2, + patch_norm=True, + out_indices=(1, 2, 3), + with_cp=True, + convert_weights=True, + frozen_stages=-1, + init_cfg=dict(type='Pretrained', checkpoint=pretrained)), + neck=dict( + type='ChannelMapper', + in_channels=[192, 384, 768], + kernel_size=1, + out_channels=256, + act_cfg=None, + bias=True, + norm_cfg=dict(type='GN', num_groups=32), + num_outs=4), + encoder=dict( + num_layers=6, + num_cp=6, + # visual layer config + layer_cfg=dict( + self_attn_cfg=dict(embed_dims=256, num_levels=4, dropout=0.0), + ffn_cfg=dict( + embed_dims=256, feedforward_channels=2048, ffn_drop=0.0)), + # text layer config + text_layer_cfg=dict( + self_attn_cfg=dict(num_heads=4, embed_dims=256, dropout=0.0), + ffn_cfg=dict( + embed_dims=256, feedforward_channels=1024, ffn_drop=0.0)), + # fusion layer config + fusion_layer_cfg=dict( + v_dim=256, + l_dim=256, + embed_dim=1024, + num_heads=4, + init_values=1e-4), + ), + decoder=dict( + num_layers=6, + return_intermediate=True, + layer_cfg=dict( + # query self attention layer + self_attn_cfg=dict(embed_dims=256, num_heads=8, dropout=0.0), + # cross attention layer query to text + cross_attn_text_cfg=dict(embed_dims=256, num_heads=8, dropout=0.0), + # cross attention layer query to image + cross_attn_cfg=dict(embed_dims=256, num_heads=8, dropout=0.0), + ffn_cfg=dict( + embed_dims=256, feedforward_channels=2048, ffn_drop=0.0)), + post_norm_cfg=None), + positional_encoding=dict( + num_feats=128, normalize=True, offset=0.0, temperature=20), + bbox_head=dict( + type='GroundingDINOHead', + num_classes=256, + sync_cls_avg_factor=True, + contrastive_cfg=dict(max_text_len=256, log_scale='auto', bias=True), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), # 2.0 in DeformDETR + loss_bbox=dict(type='L1Loss', loss_weight=5.0)), + dn_cfg=dict( # TODO: Move to model.train_cfg ? + label_noise_scale=0.5, + box_noise_scale=1.0, # 0.4 for DN-DETR + group_cfg=dict(dynamic=True, num_groups=None, + num_dn_queries=100)), # TODO: half num_dn_queries + # training and testing settings + train_cfg=dict( + assigner=dict( + type='HungarianAssigner', + match_costs=[ + dict(type='BinaryFocalLossCost', weight=2.0), + dict(type='BBoxL1Cost', weight=5.0, box_format='xywh'), + dict(type='IoUCost', iou_mode='giou', weight=2.0) + ])), + test_cfg=dict(max_per_img=300)) + +# dataset settings +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict( + type='RandomSamplingNegPos', + tokenizer_name=lang_model_name, + num_sample_negative=85, + max_tokens=256), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities', 'tokens_positive', 'dataset_mode')) +] + +test_pipeline = [ + dict( + type='LoadImageFromFile', backend_args=None, + imdecode_backend='pillow'), + dict( + type='FixScaleResize', + scale=(800, 1333), + keep_ratio=True, + backend='pillow'), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'text', 'custom_entities', + 'tokens_positive')) +] + +dataset_type = 'ODVGDataset' +data_root = 'data/objects365v1/' + +coco_od_dataset = dict( + type=dataset_type, + data_root=data_root, + ann_file='o365v1_train_odvg.json', + label_map_file='o365v1_label_map.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=train_pipeline, + return_classes=True, + backend_args=None) + +train_dataloader = dict( + _delete_=True, + batch_size=4, + num_workers=4, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict(type='ConcatDataset', datasets=[coco_od_dataset])) + +val_dataloader = dict( + dataset=dict(pipeline=test_pipeline, return_classes=True)) +test_dataloader = val_dataloader + +optim_wrapper = dict( + _delete_=True, + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.0004, + weight_decay=0.0001), # bs=16 0.0001 + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict( + custom_keys={ + 'absolute_pos_embed': dict(decay_mult=0.), + 'backbone': dict(lr_mult=0.1), + 'language_model': dict(lr_mult=0.1), + })) + +# learning policy +max_epochs = 30 +param_scheduler = [ + dict(type='LinearLR', start_factor=0.1, by_epoch=False, begin=0, end=1000), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[19, 26], + gamma=0.1) +] + +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (16 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) + +default_hooks = dict(visualization=dict(type='GroundingVisualizationHook')) diff --git a/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg.py b/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg.py new file mode 100644 index 00000000..b7f388bd --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg.py @@ -0,0 +1,38 @@ +_base_ = 'grounding_dino_swin-t_pretrain_obj365.py' + +o365v1_od_dataset = dict( + type='ODVGDataset', + data_root='data/objects365v1/', + ann_file='o365v1_train_odvg.json', + label_map_file='o365v1_label_map.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None, +) + +flickr30k_dataset = dict( + type='ODVGDataset', + data_root='data/flickr30k_entities/', + ann_file='final_flickr_separateGT_train_vg.json', + label_map_file=None, + data_prefix=dict(img='flickr30k_images/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None) + +gqa_dataset = dict( + type='ODVGDataset', + data_root='data/gqa/', + ann_file='final_mixed_train_no_coco_vg.json', + label_map_file=None, + data_prefix=dict(img='images/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None) + +train_dataloader = dict( + dataset=dict(datasets=[o365v1_od_dataset, flickr30k_dataset, gqa_dataset])) diff --git a/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m.py b/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m.py new file mode 100644 index 00000000..8e9f5ca4 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m.py @@ -0,0 +1,55 @@ +_base_ = 'grounding_dino_swin-t_pretrain_obj365.py' + +o365v1_od_dataset = dict( + type='ODVGDataset', + data_root='data/objects365v1/', + ann_file='o365v1_train_odvg.json', + label_map_file='o365v1_label_map.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None, +) + +flickr30k_dataset = dict( + type='ODVGDataset', + data_root='data/flickr30k_entities/', + ann_file='final_flickr_separateGT_train_vg.json', + label_map_file=None, + data_prefix=dict(img='flickr30k_images/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None) + +gqa_dataset = dict( + type='ODVGDataset', + data_root='data/gqa/', + ann_file='final_mixed_train_no_coco_vg.json', + label_map_file=None, + data_prefix=dict(img='images/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None) + +grit_dataset = dict( + type='ODVGDataset', + data_root='grit_processed/', + ann_file='grit20m_vg.json', + label_map_file=None, + data_prefix=dict(img=''), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None) + +train_dataloader = dict( + sampler=dict( + _delete_=True, + type='CustomSampleSizeSampler', + dataset_size=[-1, -1, -1, 500000]), + dataset=dict(datasets=[ + o365v1_od_dataset, flickr30k_dataset, gqa_dataset, grit_dataset + ])) diff --git a/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det.py b/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det.py new file mode 100644 index 00000000..56e500c8 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det.py @@ -0,0 +1,117 @@ +_base_ = 'grounding_dino_swin-t_pretrain_obj365.py' + +o365v1_od_dataset = dict( + type='ODVGDataset', + data_root='data/objects365v1/', + ann_file='o365v1_train_odvg.json', + label_map_file='o365v1_label_map.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None, +) + +flickr30k_dataset = dict( + type='ODVGDataset', + data_root='data/flickr30k_entities/', + ann_file='final_flickr_separateGT_train_vg.json', + label_map_file=None, + data_prefix=dict(img='flickr30k_images/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None) + +gqa_dataset = dict( + type='ODVGDataset', + data_root='data/gqa/', + ann_file='final_mixed_train_no_coco_vg.json', + label_map_file=None, + data_prefix=dict(img='images/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None) + +v3d_train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict( + type='RandomSamplingNegPos', + tokenizer_name=_base_.lang_model_name, + num_sample_negative=85, + # change this + label_map_file='data/V3Det/annotations/v3det_2023_v1_label_map.json', + max_tokens=256), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities', 'tokens_positive', 'dataset_mode')) +] +v3det_dataset = dict( + type='ODVGDataset', + data_root='data/V3Det/', + ann_file='annotations/v3det_2023_v1_train_od.json', + label_map_file='annotations/v3det_2023_v1_label_map.json', + data_prefix=dict(img=''), + filter_cfg=dict(filter_empty_gt=False), + need_text=False, # change this + pipeline=v3d_train_pipeline, + return_classes=True, + backend_args=None) + +grit_dataset = dict( + type='ODVGDataset', + data_root='grit_processed/', + ann_file='grit20m_vg.json', + label_map_file=None, + data_prefix=dict(img=''), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None) + +train_dataloader = dict( + sampler=dict( + _delete_=True, + type='CustomSampleSizeSampler', + dataset_size=[-1, -1, -1, -1, 500000]), + dataset=dict(datasets=[ + o365v1_od_dataset, flickr30k_dataset, gqa_dataset, v3det_dataset, + grit_dataset + ])) diff --git a/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_v3det.py b/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_v3det.py new file mode 100644 index 00000000..c89014fb --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_v3det.py @@ -0,0 +1,101 @@ +_base_ = 'grounding_dino_swin-t_pretrain_obj365.py' + +o365v1_od_dataset = dict( + type='ODVGDataset', + data_root='data/objects365v1/', + ann_file='o365v1_train_odvg.json', + label_map_file='o365v1_label_map.json', + data_prefix=dict(img='train/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None, +) + +flickr30k_dataset = dict( + type='ODVGDataset', + data_root='data/flickr30k_entities/', + ann_file='final_flickr_separateGT_train_vg.json', + label_map_file=None, + data_prefix=dict(img='flickr30k_images/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None) + +gqa_dataset = dict( + type='ODVGDataset', + data_root='data/gqa/', + ann_file='final_mixed_train_no_coco_vg.json', + label_map_file=None, + data_prefix=dict(img='images/'), + filter_cfg=dict(filter_empty_gt=False), + pipeline=_base_.train_pipeline, + return_classes=True, + backend_args=None) + +v3d_train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict( + type='RandomSamplingNegPos', + tokenizer_name=_base_.lang_model_name, + num_sample_negative=85, + # change this + label_map_file='data/V3Det/annotations/v3det_2023_v1_label_map.json', + max_tokens=256), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities', 'tokens_positive', 'dataset_mode')) +] +v3det_dataset = dict( + type='ODVGDataset', + data_root='data/V3Det/', + ann_file='annotations/v3det_2023_v1_train_od.json', + label_map_file='annotations/v3det_2023_v1_label_map.json', + data_prefix=dict(img=''), + filter_cfg=dict(filter_empty_gt=False), + need_text=False, # change this + pipeline=v3d_train_pipeline, + return_classes=True, + backend_args=None) + +train_dataloader = dict( + dataset=dict(datasets=[ + o365v1_od_dataset, flickr30k_dataset, gqa_dataset, v3det_dataset + ])) diff --git a/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_pseudo-labeling_cat.py b/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_pseudo-labeling_cat.py new file mode 100644 index 00000000..6dc8dcd8 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_pseudo-labeling_cat.py @@ -0,0 +1,43 @@ +_base_ = 'grounding_dino_swin-t_pretrain_obj365.py' + +test_pipeline = [ + dict( + type='LoadImageFromFile', backend_args=None, + imdecode_backend='pillow'), + dict( + type='FixScaleResize', + scale=(800, 1333), + keep_ratio=True, + backend='pillow'), + dict(type='LoadTextAnnotations'), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'text', 'custom_entities', + 'tokens_positive')) +] + +data_root = 'data/cat/' + +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=False, + dataset=dict( + type='ODVGDataset', + data_root=data_root, + label_map_file='cat_label_map.json', + ann_file='cat_train_od.json', + data_prefix=dict(img='images/'), + pipeline=test_pipeline, + return_classes=True)) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + outfile_path=data_root + 'cat_train_od_v1.json', + img_prefix=data_root + 'images/', + score_thr=0.7, + nms_thr=0.5, + type='DumpODVGResults') +test_evaluator = val_evaluator diff --git a/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_pseudo-labeling_flickr30k.py b/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_pseudo-labeling_flickr30k.py new file mode 100644 index 00000000..78bf1c34 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_pseudo-labeling_flickr30k.py @@ -0,0 +1,42 @@ +_base_ = 'grounding_dino_swin-t_pretrain_obj365.py' + +test_pipeline = [ + dict( + type='LoadImageFromFile', backend_args=None, + imdecode_backend='pillow'), + dict( + type='FixScaleResize', + scale=(800, 1333), + keep_ratio=True, + backend='pillow'), + dict(type='LoadTextAnnotations'), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'text', 'custom_entities', + 'tokens_positive')) +] + +data_root = 'data/flickr30k_entities/' + +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=False, + dataset=dict( + type='ODVGDataset', + data_root=data_root, + ann_file='flickr_simple_train_vg.json', + data_prefix=dict(img='flickr30k_images/'), + pipeline=test_pipeline, + return_classes=True)) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + outfile_path=data_root + 'flickr_simple_train_vg_v1.json', + img_prefix=data_root + 'flickr30k_images/', + score_thr=0.4, + nms_thr=0.5, + type='DumpODVGResults') +test_evaluator = val_evaluator diff --git a/mmdetection/configs/mm_grounding_dino/lvis/grounding_dino_swin-t_finetune_16xb4_1x_lvis.py b/mmdetection/configs/mm_grounding_dino/lvis/grounding_dino_swin-t_finetune_16xb4_1x_lvis.py new file mode 100644 index 00000000..3ba12c90 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/lvis/grounding_dino_swin-t_finetune_16xb4_1x_lvis.py @@ -0,0 +1,120 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365.py' + +data_root = 'data/coco/' + +model = dict(test_cfg=dict( + max_per_img=300, + chunked_size=40, +)) + +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict( + type='RandomSamplingNegPos', + tokenizer_name=_base_.lang_model_name, + num_sample_negative=85, + # change this + label_map_file='data/coco/annotations/lvis_v1_label_map.json', + max_tokens=256), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities', 'tokens_positive', 'dataset_mode')) +] + +train_dataloader = dict( + dataset=dict( + _delete_=True, + type='ClassBalancedDataset', + oversample_thr=1e-3, + dataset=dict( + type='ODVGDataset', + data_root=data_root, + need_text=False, + label_map_file='annotations/lvis_v1_label_map.json', + ann_file='annotations/lvis_v1_train_od.json', + data_prefix=dict(img=''), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + return_classes=True, + pipeline=train_pipeline))) + +val_dataloader = dict( + dataset=dict( + data_root=data_root, + type='LVISV1Dataset', + ann_file='annotations/lvis_v1_minival_inserted_image_name.json', + data_prefix=dict(img=''))) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + type='LVISFixedAPMetric', + ann_file=data_root + + 'annotations/lvis_v1_minival_inserted_image_name.json') +test_evaluator = val_evaluator + +optim_wrapper = dict( + _delete_=True, + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.0002, weight_decay=0.0001), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict( + custom_keys={ + 'absolute_pos_embed': dict(decay_mult=0.), + 'backbone': dict(lr_mult=0.1), + # 'language_model': dict(lr_mult=0), + })) + +# learning policy +max_epochs = 12 +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[11], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs, val_interval=3) + +default_hooks = dict( + checkpoint=dict( + max_keep_ckpts=1, save_best='lvis_fixed_ap/AP', rule='greater')) + +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth' # noqa diff --git a/mmdetection/configs/mm_grounding_dino/lvis/grounding_dino_swin-t_finetune_16xb4_1x_lvis_866_337.py b/mmdetection/configs/mm_grounding_dino/lvis/grounding_dino_swin-t_finetune_16xb4_1x_lvis_866_337.py new file mode 100644 index 00000000..28d0141d --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/lvis/grounding_dino_swin-t_finetune_16xb4_1x_lvis_866_337.py @@ -0,0 +1,120 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365.py' + +data_root = 'data/coco/' + +model = dict(test_cfg=dict( + max_per_img=300, + chunked_size=40, +)) + +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict( + type='RandomSamplingNegPos', + tokenizer_name=_base_.lang_model_name, + num_sample_negative=85, + # change this + label_map_file='data/coco/annotations/lvis_v1_label_map_norare.json', + max_tokens=256), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities', 'tokens_positive', 'dataset_mode')) +] + +train_dataloader = dict( + dataset=dict( + _delete_=True, + type='ClassBalancedDataset', + oversample_thr=1e-3, + dataset=dict( + type='ODVGDataset', + data_root=data_root, + need_text=False, + label_map_file='annotations/lvis_v1_label_map_norare.json', + ann_file='annotations/lvis_v1_train_od_norare.json', + data_prefix=dict(img=''), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + return_classes=True, + pipeline=train_pipeline))) + +val_dataloader = dict( + dataset=dict( + data_root=data_root, + type='LVISV1Dataset', + ann_file='annotations/lvis_v1_minival_inserted_image_name.json', + data_prefix=dict(img=''))) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + type='LVISFixedAPMetric', + ann_file=data_root + + 'annotations/lvis_v1_minival_inserted_image_name.json') +test_evaluator = val_evaluator + +optim_wrapper = dict( + _delete_=True, + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.00005, weight_decay=0.0001), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict( + custom_keys={ + 'absolute_pos_embed': dict(decay_mult=0.), + 'backbone': dict(lr_mult=0.1), + # 'language_model': dict(lr_mult=0), + })) + +# learning policy +max_epochs = 12 +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs, val_interval=3) + +default_hooks = dict( + checkpoint=dict( + max_keep_ckpts=3, save_best='lvis_fixed_ap/AP', rule='greater')) + +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth' # noqa diff --git a/mmdetection/configs/mm_grounding_dino/lvis/grounding_dino_swin-t_pretrain_zeroshot_lvis.py b/mmdetection/configs/mm_grounding_dino/lvis/grounding_dino_swin-t_pretrain_zeroshot_lvis.py new file mode 100644 index 00000000..fb4ed438 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/lvis/grounding_dino_swin-t_pretrain_zeroshot_lvis.py @@ -0,0 +1,24 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365.py' + +model = dict(test_cfg=dict( + max_per_img=300, + chunked_size=40, +)) + +dataset_type = 'LVISV1Dataset' +data_root = 'data/coco/' + +val_dataloader = dict( + dataset=dict( + data_root=data_root, + type=dataset_type, + ann_file='annotations/lvis_od_val.json', + data_prefix=dict(img=''))) +test_dataloader = val_dataloader + +# numpy < 1.24.0 +val_evaluator = dict( + _delete_=True, + type='LVISFixedAPMetric', + ann_file=data_root + 'annotations/lvis_od_val.json') +test_evaluator = val_evaluator diff --git a/mmdetection/configs/mm_grounding_dino/lvis/grounding_dino_swin-t_pretrain_zeroshot_mini-lvis.py b/mmdetection/configs/mm_grounding_dino/lvis/grounding_dino_swin-t_pretrain_zeroshot_mini-lvis.py new file mode 100644 index 00000000..406a39a4 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/lvis/grounding_dino_swin-t_pretrain_zeroshot_mini-lvis.py @@ -0,0 +1,25 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365.py' + +model = dict(test_cfg=dict( + max_per_img=300, + chunked_size=40, +)) + +dataset_type = 'LVISV1Dataset' +data_root = 'data/coco/' + +val_dataloader = dict( + dataset=dict( + data_root=data_root, + type=dataset_type, + ann_file='annotations/lvis_v1_minival_inserted_image_name.json', + data_prefix=dict(img=''))) +test_dataloader = val_dataloader + +# numpy < 1.24.0 +val_evaluator = dict( + _delete_=True, + type='LVISFixedAPMetric', + ann_file=data_root + + 'annotations/lvis_v1_minival_inserted_image_name.json') +test_evaluator = val_evaluator diff --git a/mmdetection/configs/mm_grounding_dino/metafile.yml b/mmdetection/configs/mm_grounding_dino/metafile.yml new file mode 100644 index 00000000..c104ac05 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/metafile.yml @@ -0,0 +1,90 @@ +Collections: + - Name: MM Grounding DINO + Metadata: + Training Data: Objects365, GoldG, GRIT and V3Det + Training Techniques: + - AdamW + - Multi Scale Train + - Gradient Clip + Training Resources: 3090 GPUs + Architecture: + - Swin Transformer + - BERT + README: configs/mm_grounding_dino/README.md + Code: + URL: + Version: v3.0.0 + +Models: + - Name: grounding_dino_swin-t_pretrain_obj365_goldg + In Collection: MM Grounding DINO + Config: configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg.py + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 50.4 + Weights: https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg/grounding_dino_swin-t_pretrain_obj365_goldg_20231122_132602-4ea751ce.pth + - Name: grounding_dino_swin-t_pretrain_obj365_goldg_grit9m + In Collection: MM Grounding DINO + Config: configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m.py + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 50.5 + Weights: https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_20231128_200818-169cc352.pth + - Name: grounding_dino_swin-t_pretrain_obj365_goldg_v3det + In Collection: MM Grounding DINO + Config: configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_v3det.py + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 50.6 + Weights: https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_v3det/grounding_dino_swin-t_pretrain_obj365_goldg_v3det_20231218_095741-e316e297.pth + - Name: grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det + In Collection: MM Grounding DINO + Config: configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det.py + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 50.4 + Weights: https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth + - Name: grounding_dino_swin-b_pretrain_obj365_goldg_v3det + In Collection: MM Grounding DINO + Config: configs/mm_grounding_dino/grounding_dino_swin-b_pretrain_obj365_goldg_v3det.py + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 52.5 + Weights: https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-b_pretrain_obj365_goldg_v3det/grounding_dino_swin-b_pretrain_obj365_goldg_v3de-f83eef00.pth + - Name: grounding_dino_swin-b_pretrain_all + In Collection: MM Grounding DINO + Config: configs/mm_grounding_dino/grounding_dino_swin-b_pretrain_all.py + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 59.5 + Weights: https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-b_pretrain_all/grounding_dino_swin-b_pretrain_all-f9818a7c.pth + - Name: grounding_dino_swin-l_pretrain_obj365_goldg + In Collection: MM Grounding DINO + Config: configs/mm_grounding_dino/grounding_dino_swin-l_pretrain_obj365_goldg.py + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 53.0 + Weights: https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-l_pretrain_obj365_goldg/grounding_dino_swin-l_pretrain_obj365_goldg-34dcdc53.pth + - Name: grounding_dino_swin-l_pretrain_all + In Collection: MM Grounding DINO + Config: configs/mm_grounding_dino/grounding_dino_swin-l_pretrain_all.py + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 60.3 + Weights: https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-l_pretrain_all/grounding_dino_swin-l_pretrain_all-56d69e78.pth diff --git a/mmdetection/configs/mm_grounding_dino/odinw/grounding_dino_swin-t_pretrain_odinw13.py b/mmdetection/configs/mm_grounding_dino/odinw/grounding_dino_swin-t_pretrain_odinw13.py new file mode 100644 index 00000000..d87ca7ca --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/odinw/grounding_dino_swin-t_pretrain_odinw13.py @@ -0,0 +1,338 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365.py' # noqa + +dataset_type = 'CocoDataset' +data_root = 'data/odinw/' + +base_test_pipeline = _base_.test_pipeline +base_test_pipeline[-1]['meta_keys'] = ('img_id', 'img_path', 'ori_shape', + 'img_shape', 'scale_factor', 'text', + 'custom_entities', 'caption_prompt') + +# ---------------------1 AerialMaritimeDrone---------------------# +class_name = ('boat', 'car', 'dock', 'jetski', 'lift') +metainfo = dict(classes=class_name) +_data_root = data_root + 'AerialMaritimeDrone/large/' +dataset_AerialMaritimeDrone = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + test_mode=True, + pipeline=base_test_pipeline, + return_classes=True) +val_evaluator_AerialMaritimeDrone = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------2 Aquarium---------------------# +class_name = ('fish', 'jellyfish', 'penguin', 'puffin', 'shark', 'starfish', + 'stingray') +metainfo = dict(classes=class_name) +_data_root = data_root + 'Aquarium/Aquarium Combined.v2-raw-1024.coco/' + +caption_prompt = None +# caption_prompt = { +# 'penguin': { +# 'suffix': ', which is black and white' +# }, +# 'puffin': { +# 'suffix': ' with orange beaks' +# }, +# 'stingray': { +# 'suffix': ' which is flat and round' +# }, +# } +dataset_Aquarium = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_Aquarium = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------3 CottontailRabbits---------------------# +class_name = ('Cottontail-Rabbit', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'CottontailRabbits/' + +# caption_prompt = None +caption_prompt = {'Cottontail-Rabbit': {'name': 'rabbit'}} + +dataset_CottontailRabbits = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_CottontailRabbits = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------4 EgoHands---------------------# +class_name = ('hand', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'EgoHands/generic/' + +# caption_prompt = None +caption_prompt = {'hand': {'suffix': ' of a person'}} + +dataset_EgoHands = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_EgoHands = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------5 NorthAmericaMushrooms---------------------# +class_name = ('CoW', 'chanterelle') +metainfo = dict(classes=class_name) +_data_root = data_root + 'NorthAmericaMushrooms/North American Mushrooms.v1-416x416.coco/' # noqa + +# caption_prompt = None +caption_prompt = { + 'CoW': { + 'name': 'flat mushroom' + }, + 'chanterelle': { + 'name': 'yellow mushroom' + } +} + +dataset_NorthAmericaMushrooms = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_NorthAmericaMushrooms = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------6 Packages---------------------# +class_name = ('package', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'Packages/Raw/' + +# caption_prompt = None +caption_prompt = { + 'package': { + 'prefix': 'there is a ', + 'suffix': ' on the porch' + } +} + +dataset_Packages = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_Packages = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------7 PascalVOC---------------------# +class_name = ('aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', + 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', + 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', + 'tvmonitor') +metainfo = dict(classes=class_name) +_data_root = data_root + 'PascalVOC/' +dataset_PascalVOC = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_PascalVOC = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------8 pistols---------------------# +class_name = ('pistol', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'pistols/export/' +dataset_pistols = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='val_annotations_without_background.json', + data_prefix=dict(img=''), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_pistols = dict( + type='CocoMetric', + ann_file=_data_root + 'val_annotations_without_background.json', + metric='bbox') + +# ---------------------9 pothole---------------------# +class_name = ('pothole', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'pothole/' + +# caption_prompt = None +caption_prompt = { + 'pothole': { + 'prefix': 'there are some ', + 'name': 'holes', + 'suffix': ' on the road' + } +} + +dataset_pothole = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_pothole = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------10 Raccoon---------------------# +class_name = ('raccoon', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'Raccoon/Raccoon.v2-raw.coco/' +dataset_Raccoon = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_Raccoon = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------11 ShellfishOpenImages---------------------# +class_name = ('Crab', 'Lobster', 'Shrimp') +metainfo = dict(classes=class_name) +_data_root = data_root + 'ShellfishOpenImages/raw/' +dataset_ShellfishOpenImages = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_ShellfishOpenImages = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------12 thermalDogsAndPeople---------------------# +class_name = ('dog', 'person') +metainfo = dict(classes=class_name) +_data_root = data_root + 'thermalDogsAndPeople/' +dataset_thermalDogsAndPeople = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_thermalDogsAndPeople = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------13 VehiclesOpenImages---------------------# +class_name = ('Ambulance', 'Bus', 'Car', 'Motorcycle', 'Truck') +metainfo = dict(classes=class_name) +_data_root = data_root + 'VehiclesOpenImages/416x416/' +dataset_VehiclesOpenImages = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_VehiclesOpenImages = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# --------------------- Config---------------------# +dataset_prefixes = [ + 'AerialMaritimeDrone', 'Aquarium', 'CottontailRabbits', 'EgoHands', + 'NorthAmericaMushrooms', 'Packages', 'PascalVOC', 'pistols', 'pothole', + 'Raccoon', 'ShellfishOpenImages', 'thermalDogsAndPeople', + 'VehiclesOpenImages' +] +datasets = [ + dataset_AerialMaritimeDrone, dataset_Aquarium, dataset_CottontailRabbits, + dataset_EgoHands, dataset_NorthAmericaMushrooms, dataset_Packages, + dataset_PascalVOC, dataset_pistols, dataset_pothole, dataset_Raccoon, + dataset_ShellfishOpenImages, dataset_thermalDogsAndPeople, + dataset_VehiclesOpenImages +] +metrics = [ + val_evaluator_AerialMaritimeDrone, val_evaluator_Aquarium, + val_evaluator_CottontailRabbits, val_evaluator_EgoHands, + val_evaluator_NorthAmericaMushrooms, val_evaluator_Packages, + val_evaluator_PascalVOC, val_evaluator_pistols, val_evaluator_pothole, + val_evaluator_Raccoon, val_evaluator_ShellfishOpenImages, + val_evaluator_thermalDogsAndPeople, val_evaluator_VehiclesOpenImages +] + +# -------------------------------------------------# +val_dataloader = dict( + dataset=dict(_delete_=True, type='ConcatDataset', datasets=datasets)) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + type='MultiDatasetsEvaluator', + metrics=metrics, + dataset_prefixes=dataset_prefixes) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/mm_grounding_dino/odinw/grounding_dino_swin-t_pretrain_odinw35.py b/mmdetection/configs/mm_grounding_dino/odinw/grounding_dino_swin-t_pretrain_odinw35.py new file mode 100644 index 00000000..a6b8566a --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/odinw/grounding_dino_swin-t_pretrain_odinw35.py @@ -0,0 +1,794 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365.py' # noqa + +dataset_type = 'CocoDataset' +data_root = 'data/odinw/' + +base_test_pipeline = _base_.test_pipeline +base_test_pipeline[-1]['meta_keys'] = ('img_id', 'img_path', 'ori_shape', + 'img_shape', 'scale_factor', 'text', + 'custom_entities', 'caption_prompt') + +# ---------------------1 AerialMaritimeDrone_large---------------------# +class_name = ('boat', 'car', 'dock', 'jetski', 'lift') +metainfo = dict(classes=class_name) +_data_root = data_root + 'AerialMaritimeDrone/large/' +dataset_AerialMaritimeDrone_large = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_AerialMaritimeDrone_large = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------2 AerialMaritimeDrone_tiled---------------------# +class_name = ('boat', 'car', 'dock', 'jetski', 'lift') +metainfo = dict(classes=class_name) +_data_root = data_root + 'AerialMaritimeDrone/tiled/' +dataset_AerialMaritimeDrone_tiled = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_AerialMaritimeDrone_tiled = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------3 AmericanSignLanguageLetters---------------------# +class_name = ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', + 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z') +metainfo = dict(classes=class_name) +_data_root = data_root + 'AmericanSignLanguageLetters/American Sign Language Letters.v1-v1.coco/' # noqa +dataset_AmericanSignLanguageLetters = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_AmericanSignLanguageLetters = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------4 Aquarium---------------------# +class_name = ('fish', 'jellyfish', 'penguin', 'puffin', 'shark', 'starfish', + 'stingray') +metainfo = dict(classes=class_name) +_data_root = data_root + 'Aquarium/Aquarium Combined.v2-raw-1024.coco/' +dataset_Aquarium = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_Aquarium = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------5 BCCD---------------------# +class_name = ('Platelets', 'RBC', 'WBC') +metainfo = dict(classes=class_name) +_data_root = data_root + 'BCCD/BCCD.v3-raw.coco/' +dataset_BCCD = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_BCCD = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------6 boggleBoards---------------------# +class_name = ('Q', 'a', 'an', 'b', 'c', 'd', 'e', 'er', 'f', 'g', 'h', 'he', + 'i', 'in', 'j', 'k', 'l', 'm', 'n', 'o', 'o ', 'p', 'q', 'qu', + 'r', 's', 't', 't\\', 'th', 'u', 'v', 'w', 'wild', 'x', 'y', 'z') +metainfo = dict(classes=class_name) +_data_root = data_root + 'boggleBoards/416x416AutoOrient/export/' +dataset_boggleBoards = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='val_annotations_without_background.json', + data_prefix=dict(img=''), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_boggleBoards = dict( + type='CocoMetric', + ann_file=_data_root + 'val_annotations_without_background.json', + metric='bbox') + +# ---------------------7 brackishUnderwater---------------------# +class_name = ('crab', 'fish', 'jellyfish', 'shrimp', 'small_fish', 'starfish') +metainfo = dict(classes=class_name) +_data_root = data_root + 'brackishUnderwater/960x540/' +dataset_brackishUnderwater = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_brackishUnderwater = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------8 ChessPieces---------------------# +class_name = (' ', 'black bishop', 'black king', 'black knight', 'black pawn', + 'black queen', 'black rook', 'white bishop', 'white king', + 'white knight', 'white pawn', 'white queen', 'white rook') +metainfo = dict(classes=class_name) +_data_root = data_root + 'ChessPieces/Chess Pieces.v23-raw.coco/' +dataset_ChessPieces = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/new_annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_ChessPieces = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/new_annotations_without_background.json', + metric='bbox') + +# ---------------------9 CottontailRabbits---------------------# +class_name = ('rabbit', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'CottontailRabbits/' +dataset_CottontailRabbits = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/new_annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_CottontailRabbits = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/new_annotations_without_background.json', + metric='bbox') + +# ---------------------10 dice---------------------# +class_name = ('1', '2', '3', '4', '5', '6') +metainfo = dict(classes=class_name) +_data_root = data_root + 'dice/mediumColor/export/' +dataset_dice = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='val_annotations_without_background.json', + data_prefix=dict(img=''), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_dice = dict( + type='CocoMetric', + ann_file=_data_root + 'val_annotations_without_background.json', + metric='bbox') + +# ---------------------11 DroneControl---------------------# +class_name = ('follow', 'follow_hand', 'land', 'land_hand', 'null', 'object', + 'takeoff', 'takeoff-hand') +metainfo = dict(classes=class_name) +_data_root = data_root + 'DroneControl/Drone Control.v3-raw.coco/' +dataset_DroneControl = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_DroneControl = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------12 EgoHands_generic---------------------# +class_name = ('hand', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'EgoHands/generic/' +caption_prompt = {'hand': {'suffix': ' of a person'}} +dataset_EgoHands_generic = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_EgoHands_generic = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------13 EgoHands_specific---------------------# +class_name = ('myleft', 'myright', 'yourleft', 'yourright') +metainfo = dict(classes=class_name) +_data_root = data_root + 'EgoHands/specific/' +dataset_EgoHands_specific = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_EgoHands_specific = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------14 HardHatWorkers---------------------# +class_name = ('head', 'helmet', 'person') +metainfo = dict(classes=class_name) +_data_root = data_root + 'HardHatWorkers/raw/' +dataset_HardHatWorkers = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_HardHatWorkers = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------15 MaskWearing---------------------# +class_name = ('mask', 'no-mask') +metainfo = dict(classes=class_name) +_data_root = data_root + 'MaskWearing/raw/' +dataset_MaskWearing = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_MaskWearing = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------16 MountainDewCommercial---------------------# +class_name = ('bottle', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'MountainDewCommercial/' +dataset_MountainDewCommercial = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_MountainDewCommercial = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------17 NorthAmericaMushrooms---------------------# +class_name = ('flat mushroom', 'yellow mushroom') +metainfo = dict(classes=class_name) +_data_root = data_root + 'NorthAmericaMushrooms/North American Mushrooms.v1-416x416.coco/' # noqa +dataset_NorthAmericaMushrooms = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/new_annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_NorthAmericaMushrooms = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/new_annotations_without_background.json', + metric='bbox') + +# ---------------------18 openPoetryVision---------------------# +class_name = ('American Typewriter', 'Andale Mono', 'Apple Chancery', 'Arial', + 'Avenir', 'Baskerville', 'Big Caslon', 'Bradley Hand', + 'Brush Script MT', 'Chalkboard', 'Comic Sans MS', 'Copperplate', + 'Courier', 'Didot', 'Futura', 'Geneva', 'Georgia', 'Gill Sans', + 'Helvetica', 'Herculanum', 'Impact', 'Kefa', 'Lucida Grande', + 'Luminari', 'Marker Felt', 'Menlo', 'Monaco', 'Noteworthy', + 'Optima', 'PT Sans', 'PT Serif', 'Palatino', 'Papyrus', + 'Phosphate', 'Rockwell', 'SF Pro', 'SignPainter', 'Skia', + 'Snell Roundhand', 'Tahoma', 'Times New Roman', 'Trebuchet MS', + 'Verdana') +metainfo = dict(classes=class_name) +_data_root = data_root + 'openPoetryVision/512x512/' +dataset_openPoetryVision = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_openPoetryVision = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------19 OxfordPets_by_breed---------------------# +class_name = ('cat-Abyssinian', 'cat-Bengal', 'cat-Birman', 'cat-Bombay', + 'cat-British_Shorthair', 'cat-Egyptian_Mau', 'cat-Maine_Coon', + 'cat-Persian', 'cat-Ragdoll', 'cat-Russian_Blue', 'cat-Siamese', + 'cat-Sphynx', 'dog-american_bulldog', + 'dog-american_pit_bull_terrier', 'dog-basset_hound', + 'dog-beagle', 'dog-boxer', 'dog-chihuahua', + 'dog-english_cocker_spaniel', 'dog-english_setter', + 'dog-german_shorthaired', 'dog-great_pyrenees', 'dog-havanese', + 'dog-japanese_chin', 'dog-keeshond', 'dog-leonberger', + 'dog-miniature_pinscher', 'dog-newfoundland', 'dog-pomeranian', + 'dog-pug', 'dog-saint_bernard', 'dog-samoyed', + 'dog-scottish_terrier', 'dog-shiba_inu', + 'dog-staffordshire_bull_terrier', 'dog-wheaten_terrier', + 'dog-yorkshire_terrier') +metainfo = dict(classes=class_name) +_data_root = data_root + 'OxfordPets/by-breed/' # noqa +dataset_OxfordPets_by_breed = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_OxfordPets_by_breed = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------20 OxfordPets_by_species---------------------# +class_name = ('cat', 'dog') +metainfo = dict(classes=class_name) +_data_root = data_root + 'OxfordPets/by-species/' # noqa +dataset_OxfordPets_by_species = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_OxfordPets_by_species = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------21 PKLot---------------------# +class_name = ('space-empty', 'space-occupied') +metainfo = dict(classes=class_name) +_data_root = data_root + 'PKLot/640/' # noqa +dataset_PKLot = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_PKLot = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------22 Packages---------------------# +class_name = ('package', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'Packages/Raw/' +caption_prompt = { + 'package': { + 'prefix': 'there is a ', + 'suffix': ' on the porch' + } +} +dataset_Packages = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=base_test_pipeline, + caption_prompt=caption_prompt, + test_mode=True, + return_classes=True) +val_evaluator_Packages = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------23 PascalVOC---------------------# +class_name = ('aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', + 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', + 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', + 'tvmonitor') +metainfo = dict(classes=class_name) +_data_root = data_root + 'PascalVOC/' +dataset_PascalVOC = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_PascalVOC = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------24 pistols---------------------# +class_name = ('pistol', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'pistols/export/' +dataset_pistols = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='val_annotations_without_background.json', + data_prefix=dict(img=''), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_pistols = dict( + type='CocoMetric', + ann_file=_data_root + 'val_annotations_without_background.json', + metric='bbox') + +# ---------------------25 plantdoc---------------------# +class_name = ('Apple Scab Leaf', 'Apple leaf', 'Apple rust leaf', + 'Bell_pepper leaf', 'Bell_pepper leaf spot', 'Blueberry leaf', + 'Cherry leaf', 'Corn Gray leaf spot', 'Corn leaf blight', + 'Corn rust leaf', 'Peach leaf', 'Potato leaf', + 'Potato leaf early blight', 'Potato leaf late blight', + 'Raspberry leaf', 'Soyabean leaf', 'Soybean leaf', + 'Squash Powdery mildew leaf', 'Strawberry leaf', + 'Tomato Early blight leaf', 'Tomato Septoria leaf spot', + 'Tomato leaf', 'Tomato leaf bacterial spot', + 'Tomato leaf late blight', 'Tomato leaf mosaic virus', + 'Tomato leaf yellow virus', 'Tomato mold leaf', + 'Tomato two spotted spider mites leaf', 'grape leaf', + 'grape leaf black rot') +metainfo = dict(classes=class_name) +_data_root = data_root + 'plantdoc/416x416/' +dataset_plantdoc = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_plantdoc = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------26 pothole---------------------# +class_name = ('pothole', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'pothole/' +caption_prompt = { + 'pothole': { + 'name': 'holes', + 'prefix': 'there are some ', + 'suffix': ' on the road' + } +} +dataset_pothole = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + caption_prompt=caption_prompt, + pipeline=base_test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_pothole = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------27 Raccoon---------------------# +class_name = ('raccoon', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'Raccoon/Raccoon.v2-raw.coco/' +dataset_Raccoon = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_Raccoon = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------28 selfdrivingCar---------------------# +class_name = ('biker', 'car', 'pedestrian', 'trafficLight', + 'trafficLight-Green', 'trafficLight-GreenLeft', + 'trafficLight-Red', 'trafficLight-RedLeft', + 'trafficLight-Yellow', 'trafficLight-YellowLeft', 'truck') +metainfo = dict(classes=class_name) +_data_root = data_root + 'selfdrivingCar/fixedLarge/export/' +dataset_selfdrivingCar = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='val_annotations_without_background.json', + data_prefix=dict(img=''), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_selfdrivingCar = dict( + type='CocoMetric', + ann_file=_data_root + 'val_annotations_without_background.json', + metric='bbox') + +# ---------------------29 ShellfishOpenImages---------------------# +class_name = ('Crab', 'Lobster', 'Shrimp') +metainfo = dict(classes=class_name) +_data_root = data_root + 'ShellfishOpenImages/raw/' +dataset_ShellfishOpenImages = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_ShellfishOpenImages = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------30 ThermalCheetah---------------------# +class_name = ('cheetah', 'human') +metainfo = dict(classes=class_name) +_data_root = data_root + 'ThermalCheetah/' +dataset_ThermalCheetah = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_ThermalCheetah = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------31 thermalDogsAndPeople---------------------# +class_name = ('dog', 'person') +metainfo = dict(classes=class_name) +_data_root = data_root + 'thermalDogsAndPeople/' +dataset_thermalDogsAndPeople = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_thermalDogsAndPeople = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------32 UnoCards---------------------# +class_name = ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', + '12', '13', '14') +metainfo = dict(classes=class_name) +_data_root = data_root + 'UnoCards/raw/' +dataset_UnoCards = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_UnoCards = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------33 VehiclesOpenImages---------------------# +class_name = ('Ambulance', 'Bus', 'Car', 'Motorcycle', 'Truck') +metainfo = dict(classes=class_name) +_data_root = data_root + 'VehiclesOpenImages/416x416/' +dataset_VehiclesOpenImages = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_VehiclesOpenImages = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------34 WildfireSmoke---------------------# +class_name = ('smoke', ) +metainfo = dict(classes=class_name) +_data_root = data_root + 'WildfireSmoke/' +dataset_WildfireSmoke = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_WildfireSmoke = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# ---------------------35 websiteScreenshots---------------------# +class_name = ('button', 'field', 'heading', 'iframe', 'image', 'label', 'link', + 'text') +metainfo = dict(classes=class_name) +_data_root = data_root + 'websiteScreenshots/' +dataset_websiteScreenshots = dict( + type=dataset_type, + metainfo=metainfo, + data_root=_data_root, + ann_file='valid/annotations_without_background.json', + data_prefix=dict(img='valid/'), + pipeline=_base_.test_pipeline, + test_mode=True, + return_classes=True) +val_evaluator_websiteScreenshots = dict( + type='CocoMetric', + ann_file=_data_root + 'valid/annotations_without_background.json', + metric='bbox') + +# --------------------- Config---------------------# + +dataset_prefixes = [ + 'AerialMaritimeDrone_large', + 'AerialMaritimeDrone_tiled', + 'AmericanSignLanguageLetters', + 'Aquarium', + 'BCCD', + 'boggleBoards', + 'brackishUnderwater', + 'ChessPieces', + 'CottontailRabbits', + 'dice', + 'DroneControl', + 'EgoHands_generic', + 'EgoHands_specific', + 'HardHatWorkers', + 'MaskWearing', + 'MountainDewCommercial', + 'NorthAmericaMushrooms', + 'openPoetryVision', + 'OxfordPets_by_breed', + 'OxfordPets_by_species', + 'PKLot', + 'Packages', + 'PascalVOC', + 'pistols', + 'plantdoc', + 'pothole', + 'Raccoons', + 'selfdrivingCar', + 'ShellfishOpenImages', + 'ThermalCheetah', + 'thermalDogsAndPeople', + 'UnoCards', + 'VehiclesOpenImages', + 'WildfireSmoke', + 'websiteScreenshots', +] + +datasets = [ + dataset_AerialMaritimeDrone_large, dataset_AerialMaritimeDrone_tiled, + dataset_AmericanSignLanguageLetters, dataset_Aquarium, dataset_BCCD, + dataset_boggleBoards, dataset_brackishUnderwater, dataset_ChessPieces, + dataset_CottontailRabbits, dataset_dice, dataset_DroneControl, + dataset_EgoHands_generic, dataset_EgoHands_specific, + dataset_HardHatWorkers, dataset_MaskWearing, dataset_MountainDewCommercial, + dataset_NorthAmericaMushrooms, dataset_openPoetryVision, + dataset_OxfordPets_by_breed, dataset_OxfordPets_by_species, dataset_PKLot, + dataset_Packages, dataset_PascalVOC, dataset_pistols, dataset_plantdoc, + dataset_pothole, dataset_Raccoon, dataset_selfdrivingCar, + dataset_ShellfishOpenImages, dataset_ThermalCheetah, + dataset_thermalDogsAndPeople, dataset_UnoCards, dataset_VehiclesOpenImages, + dataset_WildfireSmoke, dataset_websiteScreenshots +] + +metrics = [ + val_evaluator_AerialMaritimeDrone_large, + val_evaluator_AerialMaritimeDrone_tiled, + val_evaluator_AmericanSignLanguageLetters, val_evaluator_Aquarium, + val_evaluator_BCCD, val_evaluator_boggleBoards, + val_evaluator_brackishUnderwater, val_evaluator_ChessPieces, + val_evaluator_CottontailRabbits, val_evaluator_dice, + val_evaluator_DroneControl, val_evaluator_EgoHands_generic, + val_evaluator_EgoHands_specific, val_evaluator_HardHatWorkers, + val_evaluator_MaskWearing, val_evaluator_MountainDewCommercial, + val_evaluator_NorthAmericaMushrooms, val_evaluator_openPoetryVision, + val_evaluator_OxfordPets_by_breed, val_evaluator_OxfordPets_by_species, + val_evaluator_PKLot, val_evaluator_Packages, val_evaluator_PascalVOC, + val_evaluator_pistols, val_evaluator_plantdoc, val_evaluator_pothole, + val_evaluator_Raccoon, val_evaluator_selfdrivingCar, + val_evaluator_ShellfishOpenImages, val_evaluator_ThermalCheetah, + val_evaluator_thermalDogsAndPeople, val_evaluator_UnoCards, + val_evaluator_VehiclesOpenImages, val_evaluator_WildfireSmoke, + val_evaluator_websiteScreenshots +] + +# -------------------------------------------------# +val_dataloader = dict( + dataset=dict(_delete_=True, type='ConcatDataset', datasets=datasets)) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + type='MultiDatasetsEvaluator', + metrics=metrics, + dataset_prefixes=dataset_prefixes) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/mm_grounding_dino/odinw/override_category.py b/mmdetection/configs/mm_grounding_dino/odinw/override_category.py new file mode 100644 index 00000000..9ff05fc6 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/odinw/override_category.py @@ -0,0 +1,109 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import argparse + +import mmengine + + +def parse_args(): + parser = argparse.ArgumentParser(description='Override Category') + parser.add_argument('data_root') + return parser.parse_args() + + +def main(): + args = parse_args() + + ChessPieces = [{ + 'id': 1, + 'name': ' ', + 'supercategory': 'pieces' + }, { + 'id': 2, + 'name': 'black bishop', + 'supercategory': 'pieces' + }, { + 'id': 3, + 'name': 'black king', + 'supercategory': 'pieces' + }, { + 'id': 4, + 'name': 'black knight', + 'supercategory': 'pieces' + }, { + 'id': 5, + 'name': 'black pawn', + 'supercategory': 'pieces' + }, { + 'id': 6, + 'name': 'black queen', + 'supercategory': 'pieces' + }, { + 'id': 7, + 'name': 'black rook', + 'supercategory': 'pieces' + }, { + 'id': 8, + 'name': 'white bishop', + 'supercategory': 'pieces' + }, { + 'id': 9, + 'name': 'white king', + 'supercategory': 'pieces' + }, { + 'id': 10, + 'name': 'white knight', + 'supercategory': 'pieces' + }, { + 'id': 11, + 'name': 'white pawn', + 'supercategory': 'pieces' + }, { + 'id': 12, + 'name': 'white queen', + 'supercategory': 'pieces' + }, { + 'id': 13, + 'name': 'white rook', + 'supercategory': 'pieces' + }] + + _data_root = args.data_root + 'ChessPieces/Chess Pieces.v23-raw.coco/' + json_data = mmengine.load(_data_root + + 'valid/annotations_without_background.json') + json_data['categories'] = ChessPieces + mmengine.dump(json_data, + _data_root + 'valid/new_annotations_without_background.json') + + CottontailRabbits = [{ + 'id': 1, + 'name': 'rabbit', + 'supercategory': 'Cottontail-Rabbit' + }] + + _data_root = args.data_root + 'CottontailRabbits/' + json_data = mmengine.load(_data_root + + 'valid/annotations_without_background.json') + json_data['categories'] = CottontailRabbits + mmengine.dump(json_data, + _data_root + 'valid/new_annotations_without_background.json') + + NorthAmericaMushrooms = [{ + 'id': 1, + 'name': 'flat mushroom', + 'supercategory': 'mushroom' + }, { + 'id': 2, + 'name': 'yellow mushroom', + 'supercategory': 'mushroom' + }] + + _data_root = args.data_root + 'NorthAmericaMushrooms/North American Mushrooms.v1-416x416.coco/' # noqa + json_data = mmengine.load(_data_root + + 'valid/annotations_without_background.json') + json_data['categories'] = NorthAmericaMushrooms + mmengine.dump(json_data, + _data_root + 'valid/new_annotations_without_background.json') + + +if __name__ == '__main__': + main() diff --git a/mmdetection/configs/mm_grounding_dino/people_in_painting/grounding_dino_swin-t_finetune_8xb4_50e_people_in_painting.py b/mmdetection/configs/mm_grounding_dino/people_in_painting/grounding_dino_swin-t_finetune_8xb4_50e_people_in_painting.py new file mode 100644 index 00000000..449d8682 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/people_in_painting/grounding_dino_swin-t_finetune_8xb4_50e_people_in_painting.py @@ -0,0 +1,109 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365.py' + +# https://universe.roboflow.com/roboflow-100/people-in-paintings/dataset/2 +data_root = 'data/people_in_painting_v2/' +class_name = ('Human', ) +palette = [(220, 20, 60)] + +metainfo = dict(classes=class_name, palette=palette) + +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities')) +] + +train_dataloader = dict( + sampler=dict(_delete_=True, type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + _delete_=True, + type='RepeatDataset', + times=10, + dataset=dict( + type='CocoDataset', + data_root=data_root, + metainfo=metainfo, + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline, + return_classes=True, + data_prefix=dict(img='train/'), + ann_file='train/_annotations.coco.json'))) + +val_dataloader = dict( + dataset=dict( + metainfo=metainfo, + data_root=data_root, + return_classes=True, + ann_file='valid/_annotations.coco.json', + data_prefix=dict(img='valid/'))) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'valid/_annotations.coco.json', + metric='bbox', + format_only=False) +test_evaluator = val_evaluator + +optim_wrapper = dict( + _delete_=True, + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0001), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict(custom_keys={ + 'absolute_pos_embed': dict(decay_mult=0.), + 'backbone': dict(lr_mult=0.1) + })) + +# learning policy +max_epochs = 5 +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[4], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs, val_interval=1) +default_hooks = dict(checkpoint=dict(max_keep_ckpts=1, save_best='auto')) + +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth' # noqa diff --git a/mmdetection/configs/mm_grounding_dino/refcoco/grounding_dino_swin-t_finetune_8xb4_5e_grefcoco.py b/mmdetection/configs/mm_grounding_dino/refcoco/grounding_dino_swin-t_finetune_8xb4_5e_grefcoco.py new file mode 100644 index 00000000..983ffe5c --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/refcoco/grounding_dino_swin-t_finetune_8xb4_5e_grefcoco.py @@ -0,0 +1,170 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365.py' + +data_root = 'data/coco/' + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + # change this + dict(type='RandomFlip', prob=0.0), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict( + type='RandomSamplingNegPos', + tokenizer_name=_base_.lang_model_name, + num_sample_negative=85, + max_tokens=256), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities', 'tokens_positive', 'dataset_mode')) +] + +train_dataloader = dict( + dataset=dict( + _delete_=True, + type='ODVGDataset', + data_root=data_root, + ann_file='mdetr_annotations/finetune_grefcoco_train_vg.json', + data_prefix=dict(img='train2014/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + return_classes=True, + pipeline=train_pipeline)) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_grefcoco_val.json' +val_dataset_all_val = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=_base_.test_pipeline, + backend_args=None) +val_evaluator_all_val = dict( + type='gRefCOCOMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + thresh_score=0.7, + thresh_f1=1.0) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_grefcoco_testA.json' +val_dataset_refcoco_testA = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=_base_.test_pipeline, + backend_args=None) + +val_evaluator_refcoco_testA = dict( + type='gRefCOCOMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + thresh_score=0.7, + thresh_f1=1.0) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_grefcoco_testB.json' +val_dataset_refcoco_testB = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=_base_.test_pipeline, + backend_args=None) + +val_evaluator_refcoco_testB = dict( + type='gRefCOCOMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + thresh_score=0.7, + thresh_f1=1.0) + +# -------------------------------------------------# +datasets = [ + val_dataset_all_val, val_dataset_refcoco_testA, val_dataset_refcoco_testB +] +dataset_prefixes = ['grefcoco_val', 'grefcoco_testA', 'grefcoco_testB'] +metrics = [ + val_evaluator_all_val, val_evaluator_refcoco_testA, + val_evaluator_refcoco_testB +] + +val_dataloader = dict( + dataset=dict(_delete_=True, type='ConcatDataset', datasets=datasets)) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + type='MultiDatasetsEvaluator', + metrics=metrics, + dataset_prefixes=dataset_prefixes) +test_evaluator = val_evaluator + +optim_wrapper = dict( + _delete_=True, + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.0002, weight_decay=0.0001), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict( + custom_keys={ + 'absolute_pos_embed': dict(decay_mult=0.), + 'backbone': dict(lr_mult=0.1), + # 'language_model': dict(lr_mult=0), + })) + +# learning policy +max_epochs = 5 +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[3], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs, val_interval=1) + +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth' # noqa diff --git a/mmdetection/configs/mm_grounding_dino/refcoco/grounding_dino_swin-t_finetune_8xb4_5e_refcoco.py b/mmdetection/configs/mm_grounding_dino/refcoco/grounding_dino_swin-t_finetune_8xb4_5e_refcoco.py new file mode 100644 index 00000000..d91af473 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/refcoco/grounding_dino_swin-t_finetune_8xb4_5e_refcoco.py @@ -0,0 +1,167 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365.py' + +data_root = 'data/coco/' + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + # change this + dict(type='RandomFlip', prob=0.0), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict( + type='RandomSamplingNegPos', + tokenizer_name=_base_.lang_model_name, + num_sample_negative=85, + max_tokens=256), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities', 'tokens_positive', 'dataset_mode')) +] + +train_dataloader = dict( + dataset=dict( + _delete_=True, + type='ODVGDataset', + data_root=data_root, + ann_file='mdetr_annotations/finetune_refcoco_train_vg.json', + data_prefix=dict(img='train2014/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + return_classes=True, + pipeline=train_pipeline)) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_refcoco_val.json' +val_dataset_all_val = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=_base_.test_pipeline, + backend_args=None) +val_evaluator_all_val = dict( + type='RefExpMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + topk=(1, 5, 10)) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_refcoco_testA.json' +val_dataset_refcoco_testA = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=_base_.test_pipeline, + backend_args=None) + +val_evaluator_refcoco_testA = dict( + type='RefExpMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + topk=(1, 5, 10)) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_refcoco_testB.json' +val_dataset_refcoco_testB = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=_base_.test_pipeline, + backend_args=None) + +val_evaluator_refcoco_testB = dict( + type='RefExpMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + topk=(1, 5, 10)) + +# -------------------------------------------------# +datasets = [ + val_dataset_all_val, val_dataset_refcoco_testA, val_dataset_refcoco_testB +] +dataset_prefixes = ['refcoco_val', 'refcoco_testA', 'refcoco_testB'] +metrics = [ + val_evaluator_all_val, val_evaluator_refcoco_testA, + val_evaluator_refcoco_testB +] + +val_dataloader = dict( + dataset=dict(_delete_=True, type='ConcatDataset', datasets=datasets)) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + type='MultiDatasetsEvaluator', + metrics=metrics, + dataset_prefixes=dataset_prefixes) +test_evaluator = val_evaluator + +optim_wrapper = dict( + _delete_=True, + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.0002, weight_decay=0.0001), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict( + custom_keys={ + 'absolute_pos_embed': dict(decay_mult=0.), + 'backbone': dict(lr_mult=0.1), + # 'language_model': dict(lr_mult=0), + })) + +# learning policy +max_epochs = 5 +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[3], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs, val_interval=1) + +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth' # noqa diff --git a/mmdetection/configs/mm_grounding_dino/refcoco/grounding_dino_swin-t_finetune_8xb4_5e_refcoco_plus.py b/mmdetection/configs/mm_grounding_dino/refcoco/grounding_dino_swin-t_finetune_8xb4_5e_refcoco_plus.py new file mode 100644 index 00000000..871adc8e --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/refcoco/grounding_dino_swin-t_finetune_8xb4_5e_refcoco_plus.py @@ -0,0 +1,167 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365.py' + +data_root = 'data/coco/' + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + # change this + dict(type='RandomFlip', prob=0.0), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict( + type='RandomSamplingNegPos', + tokenizer_name=_base_.lang_model_name, + num_sample_negative=85, + max_tokens=256), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities', 'tokens_positive', 'dataset_mode')) +] + +train_dataloader = dict( + dataset=dict( + _delete_=True, + type='ODVGDataset', + data_root=data_root, + ann_file='mdetr_annotations/finetune_refcoco+_train_vg.json', + data_prefix=dict(img='train2014/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + return_classes=True, + pipeline=train_pipeline)) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_refcoco+_val.json' +val_dataset_all_val = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=_base_.test_pipeline, + backend_args=None) +val_evaluator_all_val = dict( + type='RefExpMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + topk=(1, 5, 10)) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_refcoco+_testA.json' +val_dataset_refcoco_testA = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=_base_.test_pipeline, + backend_args=None) + +val_evaluator_refcoco_testA = dict( + type='RefExpMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + topk=(1, 5, 10)) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_refcoco+_testB.json' +val_dataset_refcoco_testB = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=_base_.test_pipeline, + backend_args=None) + +val_evaluator_refcoco_testB = dict( + type='RefExpMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + topk=(1, 5, 10)) + +# -------------------------------------------------# +datasets = [ + val_dataset_all_val, val_dataset_refcoco_testA, val_dataset_refcoco_testB +] +dataset_prefixes = ['refcoco+_val', 'refcoco+_testA', 'refcoco+_testB'] +metrics = [ + val_evaluator_all_val, val_evaluator_refcoco_testA, + val_evaluator_refcoco_testB +] + +val_dataloader = dict( + dataset=dict(_delete_=True, type='ConcatDataset', datasets=datasets)) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + type='MultiDatasetsEvaluator', + metrics=metrics, + dataset_prefixes=dataset_prefixes) +test_evaluator = val_evaluator + +optim_wrapper = dict( + _delete_=True, + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.0002, weight_decay=0.0001), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict( + custom_keys={ + 'absolute_pos_embed': dict(decay_mult=0.), + 'backbone': dict(lr_mult=0.1), + # 'language_model': dict(lr_mult=0), + })) + +# learning policy +max_epochs = 5 +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[3], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs, val_interval=1) + +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth' # noqa diff --git a/mmdetection/configs/mm_grounding_dino/refcoco/grounding_dino_swin-t_finetune_8xb4_5e_refcocog.py b/mmdetection/configs/mm_grounding_dino/refcoco/grounding_dino_swin-t_finetune_8xb4_5e_refcocog.py new file mode 100644 index 00000000..a351d6f9 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/refcoco/grounding_dino_swin-t_finetune_8xb4_5e_refcocog.py @@ -0,0 +1,145 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365.py' + +data_root = 'data/coco/' + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + # change this + dict(type='RandomFlip', prob=0.0), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict( + type='RandomSamplingNegPos', + tokenizer_name=_base_.lang_model_name, + num_sample_negative=85, + max_tokens=256), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities', 'tokens_positive', 'dataset_mode')) +] + +train_dataloader = dict( + dataset=dict( + _delete_=True, + type='ODVGDataset', + data_root=data_root, + ann_file='mdetr_annotations/finetune_refcocog_train_vg.json', + data_prefix=dict(img='train2014/'), + filter_cfg=dict(filter_empty_gt=False, min_size=32), + return_classes=True, + pipeline=train_pipeline)) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_refcocog_val.json' +val_dataset_all_val = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=_base_.test_pipeline, + backend_args=None) +val_evaluator_all_val = dict( + type='RefExpMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + topk=(1, 5, 10)) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_refcocog_test.json' +val_dataset_refcoco_test = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=_base_.test_pipeline, + backend_args=None) + +val_evaluator_refcoco_test = dict( + type='RefExpMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + topk=(1, 5, 10)) + +# -------------------------------------------------# +datasets = [val_dataset_all_val, val_dataset_refcoco_test] +dataset_prefixes = ['refcocog_val', 'refcocog_test'] +metrics = [val_evaluator_all_val, val_evaluator_refcoco_test] + +val_dataloader = dict( + dataset=dict(_delete_=True, type='ConcatDataset', datasets=datasets)) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + type='MultiDatasetsEvaluator', + metrics=metrics, + dataset_prefixes=dataset_prefixes) +test_evaluator = val_evaluator + +optim_wrapper = dict( + _delete_=True, + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.0002, weight_decay=0.0001), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict( + custom_keys={ + 'absolute_pos_embed': dict(decay_mult=0.), + 'backbone': dict(lr_mult=0.1), + # 'language_model': dict(lr_mult=0), + })) + +# learning policy +max_epochs = 5 +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[3], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs, val_interval=1) + +default_hooks = dict(checkpoint=dict(max_keep_ckpts=1, save_best='auto')) + +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth' # noqa diff --git a/mmdetection/configs/mm_grounding_dino/refcoco/grounding_dino_swin-t_pretrain_zeroshot_refexp.py b/mmdetection/configs/mm_grounding_dino/refcoco/grounding_dino_swin-t_pretrain_zeroshot_refexp.py new file mode 100644 index 00000000..437d71c6 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/refcoco/grounding_dino_swin-t_pretrain_zeroshot_refexp.py @@ -0,0 +1,228 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365.py' + +# 30 is an empirical value, just set it to the maximum value +# without affecting the evaluation result +model = dict(test_cfg=dict(max_per_img=30)) + +data_root = 'data/coco/' + +test_pipeline = [ + dict( + type='LoadImageFromFile', backend_args=None, + imdecode_backend='pillow'), + dict( + type='FixScaleResize', + scale=(800, 1333), + keep_ratio=True, + backend='pillow'), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'text', 'custom_entities', + 'tokens_positive')) +] + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/final_refexp_val.json' +val_dataset_all_val = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=test_pipeline, + backend_args=None) +val_evaluator_all_val = dict( + type='RefExpMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + topk=(1, 5, 10)) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_refcoco_testA.json' +val_dataset_refcoco_testA = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=test_pipeline, + backend_args=None) + +val_evaluator_refcoco_testA = dict( + type='RefExpMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + topk=(1, 5, 10)) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_refcoco_testB.json' +val_dataset_refcoco_testB = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=test_pipeline, + backend_args=None) + +val_evaluator_refcoco_testB = dict( + type='RefExpMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + topk=(1, 5, 10)) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_refcoco+_testA.json' +val_dataset_refcoco_plus_testA = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=test_pipeline, + backend_args=None) + +val_evaluator_refcoco_plus_testA = dict( + type='RefExpMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + topk=(1, 5, 10)) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_refcoco+_testB.json' +val_dataset_refcoco_plus_testB = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=test_pipeline, + backend_args=None) + +val_evaluator_refcoco_plus_testB = dict( + type='RefExpMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + topk=(1, 5, 10)) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_refcocog_test.json' +val_dataset_refcocog_test = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=test_pipeline, + backend_args=None) + +val_evaluator_refcocog_test = dict( + type='RefExpMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + topk=(1, 5, 10)) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_grefcoco_val.json' +val_dataset_grefcoco_val = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=test_pipeline, + backend_args=None) + +val_evaluator_grefcoco_val = dict( + type='gRefCOCOMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + thresh_score=0.7, + thresh_f1=1.0) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_grefcoco_testA.json' +val_dataset_grefcoco_testA = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=test_pipeline, + backend_args=None) + +val_evaluator_grefcoco_testA = dict( + type='gRefCOCOMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + thresh_score=0.7, + thresh_f1=1.0) + +# -------------------------------------------------# +ann_file = 'mdetr_annotations/finetune_grefcoco_testB.json' +val_dataset_grefcoco_testB = dict( + type='MDETRStyleRefCocoDataset', + data_root=data_root, + ann_file=ann_file, + data_prefix=dict(img='train2014/'), + test_mode=True, + return_classes=True, + pipeline=test_pipeline, + backend_args=None) + +val_evaluator_grefcoco_testB = dict( + type='gRefCOCOMetric', + ann_file=data_root + ann_file, + metric='bbox', + iou_thrs=0.5, + thresh_score=0.7, + thresh_f1=1.0) + +# -------------------------------------------------# +datasets = [ + val_dataset_all_val, val_dataset_refcoco_testA, val_dataset_refcoco_testB, + val_dataset_refcoco_plus_testA, val_dataset_refcoco_plus_testB, + val_dataset_refcocog_test, val_dataset_grefcoco_val, + val_dataset_grefcoco_testA, val_dataset_grefcoco_testB +] +dataset_prefixes = [ + 'val', 'refcoco_testA', 'refcoco_testB', 'refcoco+_testA', + 'refcoco+_testB', 'refcocog_test', 'grefcoco_val', 'grefcoco_testA', + 'grefcoco_testB' +] +metrics = [ + val_evaluator_all_val, val_evaluator_refcoco_testA, + val_evaluator_refcoco_testB, val_evaluator_refcoco_plus_testA, + val_evaluator_refcoco_plus_testB, val_evaluator_refcocog_test, + val_evaluator_grefcoco_val, val_evaluator_grefcoco_testA, + val_evaluator_grefcoco_testB +] + +val_dataloader = dict( + dataset=dict(_delete_=True, type='ConcatDataset', datasets=datasets)) +test_dataloader = val_dataloader + +val_evaluator = dict( + _delete_=True, + type='MultiDatasetsEvaluator', + metrics=metrics, + dataset_prefixes=dataset_prefixes) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/mm_grounding_dino/rtts/grounding_dino_swin-t_finetune_8xb4_1x_rtts.py b/mmdetection/configs/mm_grounding_dino/rtts/grounding_dino_swin-t_finetune_8xb4_1x_rtts.py new file mode 100644 index 00000000..95c2be05 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/rtts/grounding_dino_swin-t_finetune_8xb4_1x_rtts.py @@ -0,0 +1,106 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365.py' + +data_root = 'data/RTTS/' +class_name = ('bicycle', 'bus', 'car', 'motorbike', 'person') +palette = [(255, 97, 0), (0, 201, 87), (176, 23, 31), (138, 43, 226), + (30, 144, 255)] + +metainfo = dict(classes=class_name, palette=palette) + +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities')) +] + +train_dataloader = dict( + sampler=dict(_delete_=True, type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + _delete_=True, + type='CocoDataset', + data_root=data_root, + metainfo=metainfo, + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline, + return_classes=True, + ann_file='annotations_json/rtts_train.json', + data_prefix=dict(img=''))) + +val_dataloader = dict( + dataset=dict( + metainfo=metainfo, + data_root=data_root, + return_classes=True, + ann_file='annotations_json/rtts_val.json', + data_prefix=dict(img=''))) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'annotations_json/rtts_val.json', + metric='bbox', + format_only=False) +test_evaluator = val_evaluator + +optim_wrapper = dict( + _delete_=True, + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0001), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict(custom_keys={ + 'absolute_pos_embed': dict(decay_mult=0.), + 'backbone': dict(lr_mult=0.1) + })) + +# learning policy +max_epochs = 12 +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[11], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs, val_interval=1) +default_hooks = dict(checkpoint=dict(max_keep_ckpts=1, save_best='auto')) + +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth' # noqa diff --git a/mmdetection/configs/mm_grounding_dino/ruod/grounding_dino_swin-t_finetune_8xb4_1x_ruod.py b/mmdetection/configs/mm_grounding_dino/ruod/grounding_dino_swin-t_finetune_8xb4_1x_ruod.py new file mode 100644 index 00000000..f57682b2 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/ruod/grounding_dino_swin-t_finetune_8xb4_1x_ruod.py @@ -0,0 +1,108 @@ +_base_ = '../grounding_dino_swin-t_pretrain_obj365.py' + +data_root = 'data/RUOD/' +class_name = ('holothurian', 'echinus', 'scallop', 'starfish', 'fish', + 'corals', 'diver', 'cuttlefish', 'turtle', 'jellyfish') +palette = [(235, 211, 70), (106, 90, 205), (160, 32, 240), (176, 23, 31), + (142, 0, 0), (230, 0, 0), (106, 0, 228), (60, 100, 0), (80, 100, 0), + (70, 0, 0)] + +metainfo = dict(classes=class_name, palette=palette) + +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction', 'text', + 'custom_entities')) +] + +train_dataloader = dict( + sampler=dict(_delete_=True, type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + _delete_=True, + type='CocoDataset', + data_root=data_root, + metainfo=metainfo, + filter_cfg=dict(filter_empty_gt=False, min_size=32), + pipeline=train_pipeline, + return_classes=True, + ann_file='RUOD_ANN/instances_train.json', + data_prefix=dict(img='RUOD_pic/train/'))) + +val_dataloader = dict( + dataset=dict( + metainfo=metainfo, + data_root=data_root, + return_classes=True, + ann_file='RUOD_ANN/instances_test.json', + data_prefix=dict(img='RUOD_pic/test/'))) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'RUOD_ANN/instances_test.json', + metric='bbox', + format_only=False) +test_evaluator = val_evaluator + +optim_wrapper = dict( + _delete_=True, + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0001), + clip_grad=dict(max_norm=0.1, norm_type=2), + paramwise_cfg=dict(custom_keys={ + 'absolute_pos_embed': dict(decay_mult=0.), + 'backbone': dict(lr_mult=0.1) + })) + +# learning policy +max_epochs = 12 +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[11], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs, val_interval=1) +default_hooks = dict(checkpoint=dict(max_keep_ckpts=1, save_best='auto')) + +load_from = 'https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth' # noqa diff --git a/mmdetection/configs/mm_grounding_dino/usage.md b/mmdetection/configs/mm_grounding_dino/usage.md new file mode 100644 index 00000000..123c6638 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/usage.md @@ -0,0 +1,491 @@ +# Usage + +## Install + +After installing MMDet according to the instructions in the [get_started](../../docs/zh_cn/get_started.md) section, you need to install additional dependency packages: + +```shell +cd $MMDETROOT + +pip install -r requirements/multimodal.txt +pip install emoji ddd-dataset +pip install git+https://github.com/lvis-dataset/lvis-api.git" +``` + +Please note that since the LVIS third-party library does not currently support numpy 1.24, ensure that your numpy version meets the requirements. It is recommended to install numpy version 1.23. + +## Instructions + +### Download BERT Weight + +MM Grounding DINO uses BERT as its language model and requires access to https://huggingface.co/. If you encounter connection errors due to network access issues, you can download the necessary files on a computer with network access and save them locally. Finally, modify the `lang_model_name` field in the configuration file to the local path. For specific instructions, please refer to the following code: + +```python +from transformers import BertConfig, BertModel +from transformers import AutoTokenizer + +config = BertConfig.from_pretrained("bert-base-uncased") +model = BertModel.from_pretrained("bert-base-uncased", add_pooling_layer=False, config=config) +tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased") + +config.save_pretrained("your path/bert-base-uncased") +model.save_pretrained("your path/bert-base-uncased") +tokenizer.save_pretrained("your path/bert-base-uncased") +``` + +### Download NLTK Weight + +When MM Grounding DINO performs Phrase Grounding inference, it may extract noun phrases. Although it downloads specific models at runtime, considering that some users' running environments cannot connect to the internet, it is possible to download them in advance to the `~/nltk_data` path. + +```python +import nltk +nltk.download('punkt', download_dir='~/nltk_data') +nltk.download('averaged_perceptron_tagger', download_dir='~/nltk_data') +``` + +### Download MM Grounding DINO-T Weight + +For convenience in demonstration, you can download the MM Grounding DINO-T model weights in advance to the current path. + +```shell +wget load_from = 'https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth' # noqa +``` + +## Inference + +Before inference, for a better experience of the inference effects on different images, it is recommended that you first download [these images](https://github.com/microsoft/X-Decoder/tree/main/inference_demo/images) to the current path. + +MM Grounding DINO supports four types of inference methods: Closed-Set Object Detection, Open Vocabulary Object Detection, Phrase Grounding, and Referential Expression Comprehension. The details are explained below. + +**(1) Closed-Set Object Detection** + +Since MM Grounding DINO is a pretrained model, it can theoretically be applied to any closed-set detection dataset. Currently, we support commonly used datasets such as coco/voc/cityscapes/objects365v1/lvis, etc. Below, we will use coco as an example. + +```shell +python demo/image_demo.py images/animals.png \ + configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365.py \ + --weights grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth \ + --texts '$: coco' +``` + +The predictions for `outputs/vis/animals.png` will be generated in the current directory, as shown in the following image. + +
    + +
    + +Since ostrich is not one of the 80 classes in COCO, it will not be detected. + +It's important to note that Objects365v1 and LVIS have a large number of categories. If you try to input all category names directly into the network, it may exceed 256 tokens, leading to poor model predictions. In such cases, you can use the `--chunked-size` parameter to perform chunked predictions. However, please be aware that chunked predictions may take longer to complete due to the large number of categories. + +```shell +python demo/image_demo.py images/animals.png \ + configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365.py \ + --weights grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth \ + --texts '$: lvis' --chunked-size 70 \ + --palette random +``` + +
    + +
    + +Different `--chunked-size` values can lead to different prediction results. You can experiment with different chunked sizes to find the one that works best for your specific task and dataset. + +**(2) Open Vocabulary Object Detection** + +Open vocabulary object detection refers to the ability to input arbitrary class names during inference. + +```shell +python demo/image_demo.py images/animals.png \ + configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365.py \ + --weights grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth \ + --texts 'zebra. giraffe' -c +``` + +
    + +
    + +**(3) Phrase Grounding** + +Phrase Grounding refers to the process where a user inputs a natural language description, and the model automatically detects the corresponding bounding boxes for the mentioned noun phrases. It can be used in two ways: + +1. Automatically extracting noun phrases using the NLTK library and then performing detection. + +```shell +python demo/image_demo.py images/apples.jpg \ + configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365.py \ + --weights grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth \ + --texts 'There are many apples here.' +``` + +
    + +
    + +The program will automatically split `many apples` as a noun phrase and then detect the corresponding objects. Different input descriptions can have a significant impact on the prediction results. + +2. Users can manually specify which parts of the sentence are noun phrases to avoid errors in NLTK extraction. + +```shell +python demo/image_demo.py images/fruit.jpg \ + configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365.py \ + --weights grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth \ + --texts 'The picture contains watermelon, flower, and a white bottle.' \ + --tokens-positive "[[[21,31]], [[45,59]]]" --pred-score-thr 0.12 +``` + +The noun phrase corresponding to positions 21-31 is `watermelon`, and the noun phrase corresponding to positions 45-59 is `a white bottle`. + +
    + +
    + +**(4) Referential Expression Comprehension** + +Referential expression understanding refers to the model automatically comprehending the referential expressions involved in a user's language description without the need for noun phrase extraction. + +```shell +python demo/image_demo.py images/apples.jpg \ + configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365.py \ + --weights grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth \ + --texts 'red apple.' \ + --tokens-positive -1 +``` + +
    + +
    + +## Evaluation + +Our provided evaluation scripts are unified, and you only need to prepare the data in advance and then run the relevant configuration. + +(1) Zero-Shot COCO2017 val + +```shell +# single GPU +python tools/test.py configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365.py \ + grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth + +# 8 GPUs +./tools/dist_test.sh configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365.py \ + grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth 8 +``` + +(2) Zero-Shot ODinW13 + +```shell +# single GPU +python tools/test.py configs/mm_grounding_dino/odinw/grounding_dino_swin-t_pretrain_odinw13.py \ + grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth + +# 8 GPUs +./tools/dist_test.sh configs/mm_grounding_dino/odinw/grounding_dino_swin-t_pretrain_odinw13.py \ + grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth 8 +``` + +## Visualization of Evaluation Results + +For the convenience of visualizing and analyzing model prediction results, we provide support for visualizing evaluation dataset prediction results. Taking referential expression understanding as an example, the usage is as follows: + +```shell +python tools/test.py configs/mm_grounding_dino/refcoco/grounding_dino_swin-t_pretrain_zeroshot_refexp \ + grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth --work-dir refcoco_result --show-dir save_path +``` + +During the inference process, it will save the visualization results to the `refcoco_result/{current_timestamp}/save_path` directory. For other evaluation dataset visualizations, you only need to replace the configuration file. + +Here are some visualization results for various datasets. The left image represents the Ground Truth (GT). The right image represents the Predicted Result. + +1. COCO2017 val Results： + +
    + +
    + +2. Flickr30k Entities Results： + +
    + +
    + +3. DOD Results： + +
    + +
    + +4. RefCOCO val Results： + +
    + +
    + +5. RefCOCO testA Results： + +
    + +
    + +6. gRefCOCO val Results： + +
    + +
    + +## Training + +If you want to reproduce our results, you can train the model by using the following command after preparing the dataset: + +```shell +# Training on a single machine with 8 GPUs for obj365v1 dataset +./tools/dist_train.sh configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365.py 8 +# Training on a single machine with 8 GPUs for datasets like obj365v1, goldg, grit, v3det, and other datasets is similar. +./tools/dist_train.sh configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det.py 8 +``` + +For multi-machine training, please refer to [train.md](../../docs/zh_cn/user_guides/train.md). The MM-Grounding-DINO T model is designed to work with 32 GPUs (specifically, 3090Ti GPUs). If your total batch size is not 32x4=128, you will need to manually adjust the learning rate accordingly. + +### Pretraining Custom Format Explanation + +In order to standardize the pretraining formats for different datasets, we refer to the format design proposed by [Open-GroundingDino](https://github.com/longzw1997/Open-GroundingDino). Specifically, it is divided into two formats. + +**(1) Object Detection Format (OD)** + +```text +{"filename": "obj365_train_000000734304.jpg", + "height": 512, + "width": 769, + "detection": { + "instances": [ + {"bbox": [109.4768676992, 346.0190429696, 135.1918335098, 365.3641967616], "label": 2, "category": "chair"}, + {"bbox": [58.612365705900004, 323.2281494016, 242.6005859067, 451.4166870016], "label": 8, "category": "car"} + ] + } +} +``` + +The numerical values corresponding to labels in the label dictionary should match the respective label_map. Each item in the instances list corresponds to a bounding box (in the format x1y1x2y2). + +**(2) Phrase Grounding Format (VG)** + +```text +{"filename": "2405116.jpg", + "height": 375, + "width": 500, + "grounding": + {"caption": "Two surfers walking down the shore. sand on the beach.", + "regions": [ + {"bbox": [206, 156, 282, 248], "phrase": "Two surfers", "tokens_positive": [[0, 3], [4, 11]]}, + {"bbox": [303, 338, 443, 343], "phrase": "sand", "tokens_positive": [[36, 40]]}, + {"bbox": [[327, 223, 421, 282], [300, 200, 400, 210]], "phrase": "beach", "tokens_positive": [[48, 53]]} + ] + } +``` + +The `tokens_positive` field indicates the character positions of the current phrase within the caption. + +## Example of Fine-tuning Custom Dataset + +In order to facilitate downstream fine-tuning on custom datasets, we have provided a fine-tuning example using the simple "cat" dataset as an illustration. + +### 1 Data Preparation + +```shell +cd mmdetection +wget https://download.openmmlab.com/mmyolo/data/cat_dataset.zip +unzip cat_dataset.zip -d data/cat/ +``` + +The "cat" dataset is a single-category dataset consisting of 144 images, already converted to the COCO format. + +
    +cat dataset +
    + +### 2 Configuration Preparation + +Due to the simplicity and small size of the "cat" dataset, we trained it for 20 epochs using 8 GPUs, with corresponding learning rate scaling. We did not train the language model, only the visual model. + +Detailed configuration information can be found in [grounding_dino_swin-t_finetune_8xb4_20e_cat](grounding_dino_swin-t_finetune_8xb4_20e_cat.py). + +### 3 Visualization and Evaluation of Zero-Shot Results + +Due to MM Grounding DINO being an open-set detection model, you can perform detection and evaluation even if it was not trained on the cat dataset. + +Visualization of a single image: + +```shell +cd mmdetection +python demo/image_demo.py data/cat/images/IMG_20211205_120756.jpg configs/mm_grounding_dino/grounding_dino_swin-t_finetune_8xb4_20e_cat.py --weights grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth --texts cat. +``` + +Evaluation results of Zero-shot on test dataset： + +```shell +python tools/test.py configs/mm_grounding_dino/grounding_dino_swin-t_finetune_8xb4_20e_cat.py grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth +``` + +```text + Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.881 + Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 1.000 + Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.929 + Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.881 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.913 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.913 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.913 + Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000 + Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000 + Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.913 +``` + +### 4 Fine-tuning + +```shell +./tools/dist_train.sh configs/mm_grounding_dino/grounding_dino_swin-t_finetune_8xb4_20e_cat.py 8 --work-dir cat_work_dir +``` + +The model will save the best-performing checkpoint. It achieved its best performance at the 16th epoch, with the following results: + +```text + Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.901 + Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 1.000 + Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.930 + Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.901 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.967 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.967 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.967 + Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000 + Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000 + Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.967 +``` + +We can observe that after fine-tuning, the training performance on the cat dataset improved from 88.1 to 90.1. However, due to the small dataset size, the evaluation metrics show some fluctuations. + +## Iterative Generation and Optimization Pipeline of Model Self-training Pseduo Label + +To facilitate users in creating their own datasets from scratch or those who want to leverage the model's inference capabilities for iterative pseudo-label generation and optimization, continuously modifying pseudo-labels to improve model performance, we have provided relevant pipelines. + +Since we have defined two data formats, we will provide separate explanations for demonstration purposes. + +### 1 Object Detection Format + +Here, we continue to use the aforementioned cat dataset as an example. Let's assume that we currently have a series of images and predefined categories but no annotations. + +1. Generate initial `odvg` format file + +```python +import os +import cv2 +import json +import jsonlines + +data_root = 'data/cat' +images_path = os.path.join(data_root, 'images') +out_path = os.path.join(data_root, 'cat_train_od.json') +metas = [] +for files in os.listdir(images_path): + img = cv2.imread(os.path.join(images_path, files)) + height, width, _ = img.shape + metas.append({"filename": files, "height": height, "width": width}) + +with jsonlines.open(out_path, mode='w') as writer: + writer.write_all(metas) + +# 生成 label_map.json，由于只有一个类别，所以只需要写一个 cat 即可 +label_map_path = os.path.join(data_root, 'cat_label_map.json') +with open(label_map_path, 'w') as f: + json.dump({'0': 'cat'}, f) +``` + +Two files, `cat_train_od.json` and `cat_label_map.json`, will be generated in the `data/cat` directory. + +2. Inference with pre-trained model and save the results + +We provide a readily usable [configuration](grounding_dino_swin-t_pretrain_pseudo-labeling_cat.py). If you are using a different dataset, you can refer to this configuration for modifications. + +```shell +python tools/test.py configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_pseudo-labeling_cat.py \ + grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth +``` + +A new file `cat_train_od_v1.json` will be generated in the `data/cat` directory. You can manually open it to confirm or use the provided [script](../../tools/analysis_tools/browse_grounding_raw.py) to visualize the results. + +```shell +python tools/analysis_tools/browse_grounding_raw.py data/cat/ cat_train_od_v1.json images --label-map-file cat_label_map.json -o your_output_dir --not-show +``` + +The visualization results will be generated in the `your_output_dir` directory. + +3. Continue training to boost performance + +After obtaining pseudo-labels, you can mix them with some pre-training data for further pre-training to improve the model's performance on the current dataset. Then, you can repeat step 2 to obtain more accurate pseudo-labels, and continue this iterative process. + +### 2 Phrase Grounding Format + +1. Generate initial `odvg` format file + +The bootstrapping process of Phrase Grounding requires providing captions corresponding to each image and pre-segmented phrase information initially. Taking flickr30k entities images as an example, the generated typical file should look like this: + +```text +[ +{"filename": "3028766968.jpg", + "height": 375, + "width": 500, + "grounding": + {"caption": "Man with a black shirt on sit behind a desk sorting threw a giant stack of people work with a smirk on his face .", + "regions": [ + {"bbox": [0, 0, 1, 1], "phrase": "a giant stack of people", "tokens_positive": [[58, 81]]}, + {"bbox": [0, 0, 1, 1], "phrase": "a black shirt", "tokens_positive": [[9, 22]]}, + {"bbox": [0, 0, 1, 1], "phrase": "a desk", "tokens_positive": [[37, 43]]}, + {"bbox": [0, 0, 1, 1], "phrase": "his face", "tokens_positive": [[103, 111]]}, + {"bbox": [0, 0, 1, 1], "phrase": "Man", "tokens_positive": [[0, 3]]}]}} +{"filename": "6944134083.jpg", + "height": 319, + "width": 500, + "grounding": + {"caption": "Two men are competing in a horse race .", + "regions": [ + {"bbox": [0, 0, 1, 1], "phrase": "Two men", "tokens_positive": [[0, 7]]}]}} +] +``` + +Bbox needs to be set to `[0, 0, 1, 1]` for initialization to make sure the programme could run, but this value would not be utilized. + +```text +{"filename": "3028766968.jpg", "height": 375, "width": 500, "grounding": {"caption": "Man with a black shirt on sit behind a desk sorting threw a giant stack of people work with a smirk on his face .", "regions": [{"bbox": [0, 0, 1, 1], "phrase": "a giant stack of people", "tokens_positive": [[58, 81]]}, {"bbox": [0, 0, 1, 1], "phrase": "a black shirt", "tokens_positive": [[9, 22]]}, {"bbox": [0, 0, 1, 1], "phrase": "a desk", "tokens_positive": [[37, 43]]}, {"bbox": [0, 0, 1, 1], "phrase": "his face", "tokens_positive": [[103, 111]]}, {"bbox": [0, 0, 1, 1], "phrase": "Man", "tokens_positive": [[0, 3]]}]}} +{"filename": "6944134083.jpg", "height": 319, "width": 500, "grounding": {"caption": "Two men are competing in a horse race .", "regions": [{"bbox": [0, 0, 1, 1], "phrase": "Two men", "tokens_positive": [[0, 7]]}]}} +``` + +You can directly copy the text above, and assume that the text content is pasted into a file named `flickr_simple_train_vg.json`, which is placed in the pre-prepared `data/flickr30k_entities` dataset directory, as detailed in the data preparation document. + +2. Inference with pre-trained model and save the results + +We provide a directly usable [configuration](https://chat.openai.com/c/grounding_dino_swin-t_pretrain_pseudo-labeling_flickr30k.py). If you are using a different dataset, you can refer to this configuration for modifications. + +```shell +python tools/test.py configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_pseudo-labeling_flickr30k.py \ + grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth +``` + +The translation of your text from Chinese to English is: "A new file `flickr_simple_train_vg_v1.json` will be generated in the `data/flickr30k_entities` directory. You can manually open it to confirm or use the [script](../../tools/analysis_tools/browse_grounding_raw.py) to visualize the effects + +```shell +python tools/analysis_tools/browse_grounding_raw.py data/flickr30k_entities/ flickr_simple_train_vg_v1.json flickr30k_images -o your_output_dir --not-show +``` + +The visualization results will be generated in the `your_output_dir` directory, as shown in the following image: + +
    + +
    + +3. Continue training to boost performance + +After obtaining the pseudo-labels, you can mix some pre-training data to continue pre-training jointly, which enhances the model's performance on the current dataset. Then, rerun step 2 to obtain more accurate pseudo-labels, and repeat this cycle iteratively. diff --git a/mmdetection/configs/mm_grounding_dino/usage_zh-CN.md b/mmdetection/configs/mm_grounding_dino/usage_zh-CN.md new file mode 100644 index 00000000..5f625ea6 --- /dev/null +++ b/mmdetection/configs/mm_grounding_dino/usage_zh-CN.md @@ -0,0 +1,491 @@ +# 用法说明 + +## 安装 + +在按照 [get_started](../../docs/zh_cn/get_started.md) 一节的说明安装好 MMDet 之后，需要安装额外的依赖包： + +```shell +cd $MMDETROOT + +pip install -r requirements/multimodal.txt +pip install emoji ddd-dataset +pip install git+https://github.com/lvis-dataset/lvis-api.git" +``` + +请注意由于 LVIS 第三方库暂时不支持 numpy 1.24，因此请确保您的 numpy 版本符合要求。建议安装 numpy 1.23 版本。 + +## 说明 + +### BERT 权重下载 + +MM Grounding DINO 采用了 BERT 作为语言模型，需要访问 https://huggingface.co/, 如果您因为网络访问问题遇到连接错误，可以在有网络访问权限的电脑上下载所需文件并保存在本地。最后，修改配置文件中的 `lang_model_name` 字段为本地路径即可。具体请参考以下代码： + +```python +from transformers import BertConfig, BertModel +from transformers import AutoTokenizer + +config = BertConfig.from_pretrained("bert-base-uncased") +model = BertModel.from_pretrained("bert-base-uncased", add_pooling_layer=False, config=config) +tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased") + +config.save_pretrained("your path/bert-base-uncased") +model.save_pretrained("your path/bert-base-uncased") +tokenizer.save_pretrained("your path/bert-base-uncased") +``` + +### NLTK 权重下载 + +MM Grounding DINO 在进行 Phrase Grounding 推理时候可能会进行名词短语提取，虽然会在运行时候下载特定的模型，但是考虑到有些用户运行环境无法联网，因此可以提前下载到 `~/nltk_data` 路径下 + +```python +import nltk +nltk.download('punkt', download_dir='~/nltk_data') +nltk.download('averaged_perceptron_tagger', download_dir='~/nltk_data') +``` + +### MM Grounding DINO-T 模型权重下载 + +为了方便演示，您可以提前下载 MM Grounding DINO-T 模型权重到当前路径下 + +```shell +wget load_from = 'https://download.openmmlab.com/mmdetection/v3.0/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth' # noqa +``` + +## 推理 + +在推理前，为了更好的体验不同图片的推理效果，建议您先下载 [这些图片](https://github.com/microsoft/X-Decoder/tree/main/inference_demo/images) 到当前路径下 + +MM Grounding DINO 支持了闭集目标检测，开放词汇目标检测，Phrase Grounding 和指代性表达式理解 4 种推理方式，下面详细说明。 + +**(1) 闭集目标检测** + +由于 MM Grounding DINO 是预训练模型，理论上可以应用于任何闭集检测数据集，目前我们支持了常用的 coco/voc/cityscapes/objects365v1/lvis 等，下面以 coco 为例 + +```shell +python demo/image_demo.py images/animals.png \ + configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365.py \ + --weights grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth \ + --texts '$: coco' +``` + +会在当前路径下生成 `outputs/vis/animals.png` 的预测结果，如下图所示 + +
    + +
    + +由于鸵鸟并不在 COCO 80 类中, 因此不会检测出来。 + +需要注意，由于 objects365v1 和 lvis 类别很多，如果直接将类别名全部输入到网络中，会超过 256 个 token 导致模型预测效果极差，此时我们需要通过 `--chunked-size` 参数进行截断预测, 同时预测时间会比较长。 + +```shell +python demo/image_demo.py images/animals.png \ + configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365.py \ + --weights grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth \ + --texts '$: lvis' --chunked-size 70 \ + --palette random +``` + +
    + +
    + +不同的 `--chunked-size` 会导致不同的预测效果，您可以自行尝试。 + +**(2) 开放词汇目标检测** + +开放词汇目标检测是指在推理时候，可以输入任意的类别名 + +```shell +python demo/image_demo.py images/animals.png \ + configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365.py \ + --weights grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth \ + --texts 'zebra. giraffe' -c +``` + +
    + +
    + +**(3) Phrase Grounding** + +Phrase Grounding 是指的用户输入一句语言描述，模型自动对其涉及到的名词短语想对应的 bbox 进行检测，有两种用法 + +1. 通过 NLTK 库自动提取名词短语，然后进行检测 + +```shell +python demo/image_demo.py images/apples.jpg \ + configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365.py \ + --weights grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth \ + --texts 'There are many apples here.' +``` + +
    + +
    + +程序内部会自动切分出 `many apples` 作为名词短语，然后检测出对应物体。不同的输入描述对预测结果影响很大。 + +2. 用户自己指定句子中哪些为名词短语，避免 NLTK 提取错误的情况 + +```shell +python demo/image_demo.py images/fruit.jpg \ + configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365.py \ + --weights grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth \ + --texts 'The picture contains watermelon, flower, and a white bottle.' \ + --tokens-positive "[[[21,31]], [[45,59]]]" --pred-score-thr 0.12 +``` + +21,31 对应的名词短语为 `watermelon`，45,59 对应的名词短语为 `a white bottle`。 + +
    + +
    + +**(4) 指代性表达式理解** + +指代性表达式理解是指的用户输入一句语言描述，模型自动对其涉及到的指代性表达式进行理解, 不需要进行名词短语提取。 + +```shell +python demo/image_demo.py images/apples.jpg \ + configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365.py \ + --weights grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth \ + --texts 'red apple.' \ + --tokens-positive -1 +``` + +
    + +
    + +## 评测 + +我们所提供的评测脚本都是统一的，你只需要提前准备好数据，然后运行相关配置就可以了 + +(1) Zero-Shot COCO2017 val + +```shell +# 单卡 +python tools/test.py configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365.py \ + grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth + +# 8 卡 +./tools/dist_test.sh configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365.py \ + grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth 8 +``` + +(2) Zero-Shot ODinW13 + +```shell +# 单卡 +python tools/test.py configs/mm_grounding_dino/odinw/grounding_dino_swin-t_pretrain_odinw13.py \ + grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth + +# 8 卡 +./tools/dist_test.sh configs/mm_grounding_dino/odinw/grounding_dino_swin-t_pretrain_odinw13.py \ + grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth 8 +``` + +## 评测数据集结果可视化 + +为了方便大家对模型预测结果进行可视化和分析，我们支持了评测数据集预测结果可视化，以指代性表达式理解为例用法如下： + +```shell +python tools/test.py configs/mm_grounding_dino/refcoco/grounding_dino_swin-t_pretrain_zeroshot_refexp \ + grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth --work-dir refcoco_result --show-dir save_path +``` + +模型在推理过程中会将可视化结果保存到 `refcoco_result/{当前时间戳}/save_path` 路径下。其余评测数据集可视化只需要替换配置文件即可。 + +下面展示一些数据集的可视化结果： 左图为 GT，右图为预测结果 + +1. COCO2017 val 结果： + +
    + +
    + +2. Flickr30k Entities 结果： + +
    + +
    + +3. DOD 结果： + +
    + +
    + +4. RefCOCO val 结果： + +
    + +
    + +5. RefCOCO testA 结果： + +
    + +
    + +6. gRefCOCO val 结果： + +
    + +
    + +## 模型训练 + +如果想复现我们的结果，你可以在准备好数据集后，直接通过如下命令进行训练 + +```shell +# 单机 8 卡训练仅包括 obj365v1 数据集 +./tools/dist_train.sh configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365.py 8 +# 单机 8 卡训练包括 obj365v1/goldg/grit/v3det 数据集，其余数据集类似 +./tools/dist_train.sh configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det.py 8 +``` + +多机训练的用法请参考 [train.md](../../docs/zh_cn/user_guides/train.md)。MM-Grounding-DINO T 模型默认采用的是 32 张 3090Ti，如果你的总 bs 数不是 32x4=128，那么你需要手动的线性调整学习率。 + +### 预训练自定义格式说明 + +为了统一不同数据集的预训练格式，我们参考 [Open-GroundingDino](https://github.com/longzw1997/Open-GroundingDino) 所设计的格式。具体来说分成 2 种格式 + +**(1) 目标检测数据格式 OD** + +```text +{"filename": "obj365_train_000000734304.jpg", + "height": 512, + "width": 769, + "detection": { + "instances": [ + {"bbox": [109.4768676992, 346.0190429696, 135.1918335098, 365.3641967616], "label": 2, "category": "chair"}, + {"bbox": [58.612365705900004, 323.2281494016, 242.6005859067, 451.4166870016], "label": 8, "category": "car"} + ] + } +} +``` + +label字典中所对应的数值需要和相应的 label_map 一致。 instances 列表中的每一项都对应一个 bbox (x1y1x2y2 格式)。 + +**(2) phrase grounding 数据格式 VG** + +```text +{"filename": "2405116.jpg", + "height": 375, + "width": 500, + "grounding": + {"caption": "Two surfers walking down the shore. sand on the beach.", + "regions": [ + {"bbox": [206, 156, 282, 248], "phrase": "Two surfers", "tokens_positive": [[0, 3], [4, 11]]}, + {"bbox": [303, 338, 443, 343], "phrase": "sand", "tokens_positive": [[36, 40]]}, + {"bbox": [[327, 223, 421, 282], [300, 200, 400, 210]], "phrase": "beach", "tokens_positive": [[48, 53]]} + ] + } +``` + +tokens_positive 表示当前 phrase 在 caption 中的字符位置。 + +## 自定义数据集微调训练案例 + +为了方便用户针对自定义数据集进行下游微调，我们特意提供了以简单的 cat 数据集为例的微调训练案例。 + +### 1 数据准备 + +```shell +cd mmdetection +wget https://download.openmmlab.com/mmyolo/data/cat_dataset.zip +unzip cat_dataset.zip -d data/cat/ +``` + +cat 数据集是一个单类别数据集，包含 144 张图片，已经转换为 coco 格式。 + +
    +cat dataset +
    + +### 2 配置准备 + +由于 cat 数据集的简单性和数量较少，我们使用 8 卡训练 20 个 epoch，相应的缩放学习率，不训练语言模型，只训练视觉模型。 + +详细的配置信息可以在 [grounding_dino_swin-t_finetune_8xb4_20e_cat](grounding_dino_swin-t_finetune_8xb4_20e_cat.py) 中找到。 + +### 3 可视化和 Zero-Shot 评估 + +由于 MM Grounding DINO 是一个开放的检测模型，所以即使没有在 cat 数据集上训练，也可以进行检测和评估。 + +单张图片的可视化结果如下： + +```shell +cd mmdetection +python demo/image_demo.py data/cat/images/IMG_20211205_120756.jpg configs/mm_grounding_dino/grounding_dino_swin-t_finetune_8xb4_20e_cat.py --weights grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth --texts cat. +``` + +测试集上的 Zero-Shot 评估结果如下： + +```shell +python tools/test.py configs/mm_grounding_dino/grounding_dino_swin-t_finetune_8xb4_20e_cat.py grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth +``` + +```text + Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.881 + Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 1.000 + Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.929 + Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.881 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.913 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.913 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.913 + Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000 + Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000 + Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.913 +``` + +### 4 模型训练 + +```shell +./tools/dist_train.sh configs/mm_grounding_dino/grounding_dino_swin-t_finetune_8xb4_20e_cat.py 8 --work-dir cat_work_dir +``` + +模型将会保存性能最佳的模型。在第 16 epoch 时候达到最佳，性能如下所示： + +```text + Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.901 + Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 1.000 + Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.930 + Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000 + Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.901 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.967 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.967 + Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.967 + Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000 + Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000 + Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.967 +``` + +我们可以发现，经过微调训练后，cat 数据集的训练性能从 88.1 提升到了 90.1。同时由于数据集比较小，评估指标波动比较大。 + +## 模型自训练伪标签迭代生成和优化 pipeline + +为了方便用户从头构建自己的数据集或者希望利用模型推理能力进行自举式伪标签迭代生成和优化，不断修改伪标签来提升模型性能，我们特意提供了相关的 pipeline。 + +由于我们定义了两种数据格式，为了演示我们也将分别进行说明。 + +### 1 目标检测格式 + +此处我们依然采用上述的 cat 数据集为例，假设我们目前只有一系列图片和预定义的类别，并不存在标注。 + +1. 生成初始 odvg 格式文件 + +```python +import os +import cv2 +import json +import jsonlines + +data_root = 'data/cat' +images_path = os.path.join(data_root, 'images') +out_path = os.path.join(data_root, 'cat_train_od.json') +metas = [] +for files in os.listdir(images_path): + img = cv2.imread(os.path.join(images_path, files)) + height, width, _ = img.shape + metas.append({"filename": files, "height": height, "width": width}) + +with jsonlines.open(out_path, mode='w') as writer: + writer.write_all(metas) + +# 生成 label_map.json，由于只有一个类别，所以只需要写一个 cat 即可 +label_map_path = os.path.join(data_root, 'cat_label_map.json') +with open(label_map_path, 'w') as f: + json.dump({'0': 'cat'}, f) +``` + +会在 `data/cat` 目录下生成 `cat_train_od.json` 和 `cat_label_map.json` 两个文件。 + +2. 使用预训练模型进行推理，并保存结果 + +我们提供了直接可用的 [配置](grounding_dino_swin-t_pretrain_pseudo-labeling_cat.py), 如果你是其他数据集可以参考这个配置进行修改。 + +```shell +python tools/test.py configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_pseudo-labeling_cat.py \ + grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth +``` + +会在 `data/cat` 目录下新生成 `cat_train_od_v1.json` 文件，你可以手动打开确认或者使用 [脚本](../../tools/analysis_tools/browse_grounding_raw.py) 可视化效果 + +```shell +python tools/analysis_tools/browse_grounding_raw.py data/cat/ cat_train_od_v1.json images --label-map-file cat_label_map.json -o your_output_dir --not-show +``` + +会在 your_output_dir 目录下生成可视化结果 + +3. 继续训练提高性能 + +在得到伪标签后，你可以混合一些预训练数据联合进行继续预训练，提升模型在当前数据集上的性能，然后重新运行 2 步骤，得到更准确的伪标签，如此循环迭代即可。 + +### 2 Phrase Grounding 格式 + +1. 生成初始 odvg 格式文件 + +Phrase Grounding 的自举流程要求初始时候提供每张图片对应的 caption 和提前切割好的 phrase 信息。以 flickr30k entities 图片为例，生成的典型的文件应该如下所示： + +```text +[ +{"filename": "3028766968.jpg", + "height": 375, + "width": 500, + "grounding": + {"caption": "Man with a black shirt on sit behind a desk sorting threw a giant stack of people work with a smirk on his face .", + "regions": [ + {"bbox": [0, 0, 1, 1], "phrase": "a giant stack of people", "tokens_positive": [[58, 81]]}, + {"bbox": [0, 0, 1, 1], "phrase": "a black shirt", "tokens_positive": [[9, 22]]}, + {"bbox": [0, 0, 1, 1], "phrase": "a desk", "tokens_positive": [[37, 43]]}, + {"bbox": [0, 0, 1, 1], "phrase": "his face", "tokens_positive": [[103, 111]]}, + {"bbox": [0, 0, 1, 1], "phrase": "Man", "tokens_positive": [[0, 3]]}]}} +{"filename": "6944134083.jpg", + "height": 319, + "width": 500, + "grounding": + {"caption": "Two men are competing in a horse race .", + "regions": [ + {"bbox": [0, 0, 1, 1], "phrase": "Two men", "tokens_positive": [[0, 7]]}]}} +] +``` + +初始时候 bbox 必须要设置为 `[0, 0, 1, 1]`，因为这能确保程序正常运行，但是 bbox 的值并不会被使用。 + +```text +{"filename": "3028766968.jpg", "height": 375, "width": 500, "grounding": {"caption": "Man with a black shirt on sit behind a desk sorting threw a giant stack of people work with a smirk on his face .", "regions": [{"bbox": [0, 0, 1, 1], "phrase": "a giant stack of people", "tokens_positive": [[58, 81]]}, {"bbox": [0, 0, 1, 1], "phrase": "a black shirt", "tokens_positive": [[9, 22]]}, {"bbox": [0, 0, 1, 1], "phrase": "a desk", "tokens_positive": [[37, 43]]}, {"bbox": [0, 0, 1, 1], "phrase": "his face", "tokens_positive": [[103, 111]]}, {"bbox": [0, 0, 1, 1], "phrase": "Man", "tokens_positive": [[0, 3]]}]}} +{"filename": "6944134083.jpg", "height": 319, "width": 500, "grounding": {"caption": "Two men are competing in a horse race .", "regions": [{"bbox": [0, 0, 1, 1], "phrase": "Two men", "tokens_positive": [[0, 7]]}]}} +``` + +你可直接复制上面的文本，并假设将文本内容粘贴到命名为 `flickr_simple_train_vg.json` 文件中，并放置于提前准备好的 `data/flickr30k_entities` 数据集目录下，具体见数据准备文档。 + +2. 使用预训练模型进行推理，并保存结果 + +我们提供了直接可用的 [配置](grounding_dino_swin-t_pretrain_pseudo-labeling_flickr30k.py), 如果你是其他数据集可以参考这个配置进行修改。 + +```shell +python tools/test.py configs/mm_grounding_dino/grounding_dino_swin-t_pretrain_pseudo-labeling_flickr30k.py \ + grounding_dino_swin-t_pretrain_obj365_goldg_grit9m_v3det_20231204_095047-b448804b.pth +``` + +会在 `data/flickr30k_entities` 目录下新生成 `flickr_simple_train_vg_v1.json` 文件，你可以手动打开确认或者使用 [脚本](../../tools/analysis_tools/browse_grounding_raw.py) 可视化效果 + +```shell +python tools/analysis_tools/browse_grounding_raw.py data/flickr30k_entities/ flickr_simple_train_vg_v1.json flickr30k_images -o your_output_dir --not-show +``` + +会在 `your_output_dir` 目录下生成可视化结果，如下图所示： + +
    + +
    + +3. 继续训练提高性能 + +在得到伪标签后，你可以混合一些预训练数据联合进行继续预训练，提升模型在当前数据集上的性能，然后重新运行 2 步骤，得到更准确的伪标签，如此循环迭代即可。 diff --git a/mmdetection/configs/ms_rcnn/README.md b/mmdetection/configs/ms_rcnn/README.md new file mode 100644 index 00000000..abbec9b6 --- /dev/null +++ b/mmdetection/configs/ms_rcnn/README.md @@ -0,0 +1,36 @@ +# MS R-CNN + +> [Mask Scoring R-CNN](https://arxiv.org/abs/1903.00241) + + + +## Abstract + +Letting a deep network be aware of the quality of its own predictions is an interesting yet important problem. In the task of instance segmentation, the confidence of instance classification is used as mask quality score in most instance segmentation frameworks. However, the mask quality, quantified as the IoU between the instance mask and its ground truth, is usually not well correlated with classification score. In this paper, we study this problem and propose Mask Scoring R-CNN which contains a network block to learn the quality of the predicted instance masks. The proposed network block takes the instance feature and the corresponding predicted mask together to regress the mask IoU. The mask scoring strategy calibrates the misalignment between mask quality and mask score, and improves instance segmentation performance by prioritizing more accurate mask predictions during COCO AP evaluation. By extensive evaluations on the COCO dataset, Mask Scoring R-CNN brings consistent and noticeable gain with different models, and outperforms the state-of-the-art Mask R-CNN. We hope our simple and effective approach will provide a new direction for improving instance segmentation. + +
    + +
    + +## Results and Models + +| Backbone | style | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :----------: | :-----: | :-----: | :------: | :------------: | :----: | :-----: | :-------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | caffe | 1x | 4.5 | | 38.2 | 36.0 | [config](./ms-rcnn_r50-caffe_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/ms_rcnn/ms_rcnn_r50_caffe_fpn_1x_coco/ms_rcnn_r50_caffe_fpn_1x_coco_20200702_180848-61c9355e.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/ms_rcnn/ms_rcnn_r50_caffe_fpn_1x_coco/ms_rcnn_r50_caffe_fpn_1x_coco_20200702_180848.log.json) | +| R-50-FPN | caffe | 2x | - | - | 38.8 | 36.3 | [config](./ms-rcnn_r50-caffe_fpn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/ms_rcnn/ms_rcnn_r50_caffe_fpn_2x_coco/ms_rcnn_r50_caffe_fpn_2x_coco_bbox_mAP-0.388__segm_mAP-0.363_20200506_004738-ee87b137.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/ms_rcnn/ms_rcnn_r50_caffe_fpn_2x_coco/ms_rcnn_r50_caffe_fpn_2x_coco_20200506_004738.log.json) | +| R-101-FPN | caffe | 1x | 6.5 | | 40.4 | 37.6 | [config](./ms-rcnn_r101-caffe_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/ms_rcnn/ms_rcnn_r101_caffe_fpn_1x_coco/ms_rcnn_r101_caffe_fpn_1x_coco_bbox_mAP-0.404__segm_mAP-0.376_20200506_004755-b9b12a37.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/ms_rcnn/ms_rcnn_r101_caffe_fpn_1x_coco/ms_rcnn_r101_caffe_fpn_1x_coco_20200506_004755.log.json) | +| R-101-FPN | caffe | 2x | - | - | 41.1 | 38.1 | [config](./ms-rcnn_r101-caffe_fpn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/ms_rcnn/ms_rcnn_r101_caffe_fpn_2x_coco/ms_rcnn_r101_caffe_fpn_2x_coco_bbox_mAP-0.411__segm_mAP-0.381_20200506_011134-5f3cc74f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/ms_rcnn/ms_rcnn_r101_caffe_fpn_2x_coco/ms_rcnn_r101_caffe_fpn_2x_coco_20200506_011134.log.json) | +| R-X101-32x4d | pytorch | 2x | 7.9 | 11.0 | 41.8 | 38.7 | [config](./ms-rcnn_x101-32x4d_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/ms_rcnn/ms_rcnn_x101_32x4d_fpn_1x_coco/ms_rcnn_x101_32x4d_fpn_1x_coco_20200206-81fd1740.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/ms_rcnn/ms_rcnn_x101_32x4d_fpn_1x_coco/ms_rcnn_x101_32x4d_fpn_1x_coco_20200206_100113.log.json) | +| R-X101-64x4d | pytorch | 1x | 11.0 | 8.0 | 43.0 | 39.5 | [config](./ms-rcnn_x101-64x4d_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/ms_rcnn/ms_rcnn_x101_64x4d_fpn_1x_coco/ms_rcnn_x101_64x4d_fpn_1x_coco_20200206-86ba88d2.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/ms_rcnn/ms_rcnn_x101_64x4d_fpn_1x_coco/ms_rcnn_x101_64x4d_fpn_1x_coco_20200206_091744.log.json) | +| R-X101-64x4d | pytorch | 2x | 11.0 | 8.0 | 42.6 | 39.5 | [config](./ms-rcnn_x101-64x4d_fpn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/ms_rcnn/ms_rcnn_x101_64x4d_fpn_2x_coco/ms_rcnn_x101_64x4d_fpn_2x_coco_20200308-02a445e2.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/ms_rcnn/ms_rcnn_x101_64x4d_fpn_2x_coco/ms_rcnn_x101_64x4d_fpn_2x_coco_20200308_012247.log.json) | + +## Citation + +```latex +@inproceedings{huang2019msrcnn, + title={Mask Scoring R-CNN}, + author={Zhaojin Huang and Lichao Huang and Yongchao Gong and Chang Huang and Xinggang Wang}, + booktitle={IEEE Conference on Computer Vision and Pattern Recognition}, + year={2019}, +} +``` diff --git a/mmdetection/configs/ms_rcnn/metafile.yml b/mmdetection/configs/ms_rcnn/metafile.yml new file mode 100644 index 00000000..290f0543 --- /dev/null +++ b/mmdetection/configs/ms_rcnn/metafile.yml @@ -0,0 +1,159 @@ +Collections: + - Name: Mask Scoring R-CNN + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RPN + - FPN + - ResNet + - RoIAlign + Paper: + URL: https://arxiv.org/abs/1903.00241 + Title: 'Mask Scoring R-CNN' + README: configs/ms_rcnn/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/detectors/mask_scoring_rcnn.py#L6 + Version: v2.0.0 + +Models: + - Name: ms-rcnn_r50-caffe_fpn_1x_coco + In Collection: Mask Scoring R-CNN + Config: configs/ms_rcnn/ms-rcnn_r50-caffe_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.5 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.2 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/ms_rcnn/ms_rcnn_r50_caffe_fpn_1x_coco/ms_rcnn_r50_caffe_fpn_1x_coco_20200702_180848-61c9355e.pth + + - Name: ms-rcnn_r50-caffe_fpn_2x_coco + In Collection: Mask Scoring R-CNN + Config: configs/ms_rcnn/ms-rcnn_r50-caffe_fpn_2x_coco.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/ms_rcnn/ms_rcnn_r50_caffe_fpn_2x_coco/ms_rcnn_r50_caffe_fpn_2x_coco_bbox_mAP-0.388__segm_mAP-0.363_20200506_004738-ee87b137.pth + + - Name: ms-rcnn_r101-caffe_fpn_1x_coco + In Collection: Mask Scoring R-CNN + Config: configs/ms_rcnn/ms-rcnn_r101-caffe_fpn_1x_coco.py + Metadata: + Training Memory (GB): 6.5 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.4 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/ms_rcnn/ms_rcnn_r101_caffe_fpn_1x_coco/ms_rcnn_r101_caffe_fpn_1x_coco_bbox_mAP-0.404__segm_mAP-0.376_20200506_004755-b9b12a37.pth + + - Name: ms-rcnn_r101-caffe_fpn_2x_coco + In Collection: Mask Scoring R-CNN + Config: configs/ms_rcnn/ms-rcnn_r101-caffe_fpn_2x_coco.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.1 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/ms_rcnn/ms_rcnn_r101_caffe_fpn_2x_coco/ms_rcnn_r101_caffe_fpn_2x_coco_bbox_mAP-0.411__segm_mAP-0.381_20200506_011134-5f3cc74f.pth + + - Name: ms-rcnn_x101-32x4d_fpn_1x_coco + In Collection: Mask Scoring R-CNN + Config: configs/ms_rcnn/ms-rcnn_x101-32x4d_fpn_1x_coco.py + Metadata: + Training Memory (GB): 7.9 + inference time (ms/im): + - value: 90.91 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/ms_rcnn/ms_rcnn_x101_32x4d_fpn_1x_coco/ms_rcnn_x101_32x4d_fpn_1x_coco_20200206-81fd1740.pth + + - Name: ms-rcnn_x101-64x4d_fpn_1x_coco + In Collection: Mask Scoring R-CNN + Config: configs/ms_rcnn/ms-rcnn_x101-64x4d_fpn_1x_coco.py + Metadata: + Training Memory (GB): 11.0 + inference time (ms/im): + - value: 125 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.0 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/ms_rcnn/ms_rcnn_x101_64x4d_fpn_1x_coco/ms_rcnn_x101_64x4d_fpn_1x_coco_20200206-86ba88d2.pth + + - Name: ms-rcnn_x101-64x4d_fpn_2x_coco + In Collection: Mask Scoring R-CNN + Config: configs/ms_rcnn/ms-rcnn_x101-64x4d_fpn_2x_coco.py + Metadata: + Training Memory (GB): 11.0 + inference time (ms/im): + - value: 125 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.6 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/ms_rcnn/ms_rcnn_x101_64x4d_fpn_2x_coco/ms_rcnn_x101_64x4d_fpn_2x_coco_20200308-02a445e2.pth diff --git a/mmdetection/configs/ms_rcnn/ms-rcnn_r101-caffe_fpn_1x_coco.py b/mmdetection/configs/ms_rcnn/ms-rcnn_r101-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..2ff4f2d6 --- /dev/null +++ b/mmdetection/configs/ms_rcnn/ms-rcnn_r101-caffe_fpn_1x_coco.py @@ -0,0 +1,7 @@ +_base_ = './ms-rcnn_r50-caffe_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet101_caffe'))) diff --git a/mmdetection/configs/ms_rcnn/ms-rcnn_r101-caffe_fpn_2x_coco.py b/mmdetection/configs/ms_rcnn/ms-rcnn_r101-caffe_fpn_2x_coco.py new file mode 100644 index 00000000..54b29e4f --- /dev/null +++ b/mmdetection/configs/ms_rcnn/ms-rcnn_r101-caffe_fpn_2x_coco.py @@ -0,0 +1,17 @@ +_base_ = './ms-rcnn_r101-caffe_fpn_1x_coco.py' +# learning policy +max_epochs = 24 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) + +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/ms_rcnn/ms-rcnn_r50-caffe_fpn_1x_coco.py b/mmdetection/configs/ms_rcnn/ms-rcnn_r50-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..e7fbc51f --- /dev/null +++ b/mmdetection/configs/ms_rcnn/ms-rcnn_r50-caffe_fpn_1x_coco.py @@ -0,0 +1,16 @@ +_base_ = '../mask_rcnn/mask-rcnn_r50-caffe_fpn_1x_coco.py' +model = dict( + type='MaskScoringRCNN', + roi_head=dict( + type='MaskScoringRoIHead', + mask_iou_head=dict( + type='MaskIoUHead', + num_convs=4, + num_fcs=2, + roi_feat_size=14, + in_channels=256, + conv_out_channels=256, + fc_out_channels=1024, + num_classes=80)), + # model training and testing settings + train_cfg=dict(rcnn=dict(mask_thr_binary=0.5))) diff --git a/mmdetection/configs/ms_rcnn/ms-rcnn_r50-caffe_fpn_2x_coco.py b/mmdetection/configs/ms_rcnn/ms-rcnn_r50-caffe_fpn_2x_coco.py new file mode 100644 index 00000000..03348822 --- /dev/null +++ b/mmdetection/configs/ms_rcnn/ms-rcnn_r50-caffe_fpn_2x_coco.py @@ -0,0 +1,17 @@ +_base_ = './ms-rcnn_r50-caffe_fpn_1x_coco.py' +# learning policy +max_epochs = 24 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) + +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/ms_rcnn/ms-rcnn_r50_fpn_1x_coco.py b/mmdetection/configs/ms_rcnn/ms-rcnn_r50_fpn_1x_coco.py new file mode 100644 index 00000000..0ae47d1c --- /dev/null +++ b/mmdetection/configs/ms_rcnn/ms-rcnn_r50_fpn_1x_coco.py @@ -0,0 +1,16 @@ +_base_ = '../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py' +model = dict( + type='MaskScoringRCNN', + roi_head=dict( + type='MaskScoringRoIHead', + mask_iou_head=dict( + type='MaskIoUHead', + num_convs=4, + num_fcs=2, + roi_feat_size=14, + in_channels=256, + conv_out_channels=256, + fc_out_channels=1024, + num_classes=80)), + # model training and testing settings + train_cfg=dict(rcnn=dict(mask_thr_binary=0.5))) diff --git a/mmdetection/configs/ms_rcnn/ms-rcnn_x101-32x4d_fpn_1x_coco.py b/mmdetection/configs/ms_rcnn/ms-rcnn_x101-32x4d_fpn_1x_coco.py new file mode 100644 index 00000000..1a5d0d0f --- /dev/null +++ b/mmdetection/configs/ms_rcnn/ms-rcnn_x101-32x4d_fpn_1x_coco.py @@ -0,0 +1,14 @@ +_base_ = './ms-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/ms_rcnn/ms-rcnn_x101-64x4d_fpn_1x_coco.py b/mmdetection/configs/ms_rcnn/ms-rcnn_x101-64x4d_fpn_1x_coco.py new file mode 100644 index 00000000..16290076 --- /dev/null +++ b/mmdetection/configs/ms_rcnn/ms-rcnn_x101-64x4d_fpn_1x_coco.py @@ -0,0 +1,14 @@ +_base_ = './ms-rcnn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/ms_rcnn/ms-rcnn_x101-64x4d_fpn_2x_coco.py b/mmdetection/configs/ms_rcnn/ms-rcnn_x101-64x4d_fpn_2x_coco.py new file mode 100644 index 00000000..7aec1874 --- /dev/null +++ b/mmdetection/configs/ms_rcnn/ms-rcnn_x101-64x4d_fpn_2x_coco.py @@ -0,0 +1,17 @@ +_base_ = './ms-rcnn_x101-64x4d_fpn_1x_coco.py' +# learning policy +max_epochs = 24 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) + +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/nas_fcos/README.md b/mmdetection/configs/nas_fcos/README.md new file mode 100644 index 00000000..a0ec77c8 --- /dev/null +++ b/mmdetection/configs/nas_fcos/README.md @@ -0,0 +1,35 @@ +# NAS-FCOS + +> [NAS-FCOS: Fast Neural Architecture Search for Object Detection](https://arxiv.org/abs/1906.04423) + + + +## Abstract + +The success of deep neural networks relies on significant architecture engineering. Recently neural architecture search (NAS) has emerged as a promise to greatly reduce manual effort in network design by automatically searching for optimal architectures, although typically such algorithms need an excessive amount of computational resources, e.g., a few thousand GPU-days. To date, on challenging vision tasks such as object detection, NAS, especially fast versions of NAS, is less studied. Here we propose to search for the decoder structure of object detectors with search efficiency being taken into consideration. To be more specific, we aim to efficiently search for the feature pyramid network (FPN) as well as the prediction head of a simple anchor-free object detector, namely FCOS, using a tailored reinforcement learning paradigm. With carefully designed search space, search algorithms and strategies for evaluating network quality, we are able to efficiently search a top-performing detection architecture within 4 days using 8 V100 GPUs. The discovered architecture surpasses state-of-the-art object detection models (such as Faster R-CNN, RetinaNet and FCOS) by 1.5 to 3.5 points in AP on the COCO dataset, with comparable computation complexity and memory footprint, demonstrating the efficacy of the proposed NAS for object detection. + +
    + +
    + +## Results and Models + +| Head | Backbone | Style | GN-head | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :----------: | :------: | :---: | :-----: | :-----: | :------: | :------------: | :----: | :-----------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| NAS-FCOSHead | R-50 | caffe | Y | 1x | | | 39.4 | [config](./nas-fcos_r50-caffe_fpn_nashead-gn-head_4xb4-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/nas_fcos/nas_fcos_nashead_r50_caffe_fpn_gn-head_4x4_1x_coco/nas_fcos_nashead_r50_caffe_fpn_gn-head_4x4_1x_coco_20200520-1bdba3ce.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/nas_fcos/nas_fcos_nashead_r50_caffe_fpn_gn-head_4x4_1x_coco/nas_fcos_nashead_r50_caffe_fpn_gn-head_4x4_1x_coco_20200520.log.json) | +| FCOSHead | R-50 | caffe | Y | 1x | | | 38.5 | [config](./nas-fcos_r50-caffe_fpn_fcoshead-gn-head_4xb4-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/nas_fcos/nas_fcos_fcoshead_r50_caffe_fpn_gn-head_4x4_1x_coco/nas_fcos_fcoshead_r50_caffe_fpn_gn-head_4x4_1x_coco_20200521-7fdcbce0.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/nas_fcos/nas_fcos_fcoshead_r50_caffe_fpn_gn-head_4x4_1x_coco/nas_fcos_fcoshead_r50_caffe_fpn_gn-head_4x4_1x_coco_20200521.log.json) | + +**Notes:** + +- To be consistent with the author's implementation, we use 4 GPUs with 4 images/GPU. + +## Citation + +```latex +@article{wang2019fcos, + title={Nas-fcos: Fast neural architecture search for object detection}, + author={Wang, Ning and Gao, Yang and Chen, Hao and Wang, Peng and Tian, Zhi and Shen, Chunhua}, + journal={arXiv preprint arXiv:1906.04423}, + year={2019} +} +``` diff --git a/mmdetection/configs/nas_fcos/metafile.yml b/mmdetection/configs/nas_fcos/metafile.yml new file mode 100644 index 00000000..02292a41 --- /dev/null +++ b/mmdetection/configs/nas_fcos/metafile.yml @@ -0,0 +1,44 @@ +Collections: + - Name: NAS-FCOS + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 4x V100 GPUs + Architecture: + - FPN + - NAS-FCOS + - ResNet + Paper: + URL: https://arxiv.org/abs/1906.04423 + Title: 'NAS-FCOS: Fast Neural Architecture Search for Object Detection' + README: configs/nas_fcos/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/detectors/nasfcos.py#L6 + Version: v2.1.0 + +Models: + - Name: nas-fcos_r50-caffe_fpn_nashead-gn-head_4xb4-1x_coco + In Collection: NAS-FCOS + Config: configs/nas_fcos/nas-fcos_r50-caffe_fpn_nashead-gn-head_4xb4-1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/nas_fcos/nas_fcos_nashead_r50_caffe_fpn_gn-head_4x4_1x_coco/nas_fcos_nashead_r50_caffe_fpn_gn-head_4x4_1x_coco_20200520-1bdba3ce.pth + + - Name: nas-fcos_r50-caffe_fpn_fcoshead-gn-head_4xb4-1x_coco + In Collection: NAS-FCOS + Config: configs/nas_fcos/nas-fcos_r50-caffe_fpn_fcoshead-gn-head_4xb4-1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/nas_fcos/nas_fcos_fcoshead_r50_caffe_fpn_gn-head_4x4_1x_coco/nas_fcos_fcoshead_r50_caffe_fpn_gn-head_4x4_1x_coco_20200521-7fdcbce0.pth diff --git a/mmdetection/configs/nas_fcos/nas-fcos_r50-caffe_fpn_fcoshead-gn-head_4xb4-1x_coco.py b/mmdetection/configs/nas_fcos/nas-fcos_r50-caffe_fpn_fcoshead-gn-head_4xb4-1x_coco.py new file mode 100644 index 00000000..ba207c9f --- /dev/null +++ b/mmdetection/configs/nas_fcos/nas-fcos_r50-caffe_fpn_fcoshead-gn-head_4xb4-1x_coco.py @@ -0,0 +1,75 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +# model settings +model = dict( + type='NASFCOS', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=False, eps=0), + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe')), + neck=dict( + type='NASFCOS_FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs=True, + num_outs=5, + norm_cfg=dict(type='BN'), + conv_cfg=dict(type='DCNv2', deform_groups=2)), + bbox_head=dict( + type='FCOSHead', + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + strides=[8, 16, 32, 64, 128], + norm_cfg=dict(type='GN', num_groups=32), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='IoULoss', loss_weight=1.0), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)), + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.4, + min_pos_iou=0, + ignore_iof_thr=-1), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) + +# dataset settings +train_dataloader = dict(batch_size=4, num_workers=2) + +# optimizer +optim_wrapper = dict( + optimizer=dict(lr=0.01), + paramwise_cfg=dict(bias_lr_mult=2., bias_decay_mult=0.)) diff --git a/mmdetection/configs/nas_fcos/nas-fcos_r50-caffe_fpn_nashead-gn-head_4xb4-1x_coco.py b/mmdetection/configs/nas_fcos/nas-fcos_r50-caffe_fpn_nashead-gn-head_4xb4-1x_coco.py new file mode 100644 index 00000000..329f34c4 --- /dev/null +++ b/mmdetection/configs/nas_fcos/nas-fcos_r50-caffe_fpn_nashead-gn-head_4xb4-1x_coco.py @@ -0,0 +1,74 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +# model settings +model = dict( + type='NASFCOS', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=False, eps=0), + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe')), + neck=dict( + type='NASFCOS_FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs=True, + num_outs=5, + norm_cfg=dict(type='BN'), + conv_cfg=dict(type='DCNv2', deform_groups=2)), + bbox_head=dict( + type='NASFCOSHead', + num_classes=80, + in_channels=256, + feat_channels=256, + strides=[8, 16, 32, 64, 128], + norm_cfg=dict(type='GN', num_groups=32), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='IoULoss', loss_weight=1.0), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)), + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.4, + min_pos_iou=0, + ignore_iof_thr=-1), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) + +# dataset settings +train_dataloader = dict(batch_size=4, num_workers=2) + +# optimizer +optim_wrapper = dict( + optimizer=dict(lr=0.01), + paramwise_cfg=dict(bias_lr_mult=2., bias_decay_mult=0.)) diff --git a/mmdetection/configs/nas_fpn/README.md b/mmdetection/configs/nas_fpn/README.md new file mode 100644 index 00000000..260ec470 --- /dev/null +++ b/mmdetection/configs/nas_fpn/README.md @@ -0,0 +1,36 @@ +# NAS-FPN + +> [NAS-FPN: Learning Scalable Feature Pyramid Architecture for Object Detection](https://arxiv.org/abs/1904.07392) + + + +## Abstract + +Current state-of-the-art convolutional architectures for object detection are manually designed. Here we aim to learn a better architecture of feature pyramid network for object detection. We adopt Neural Architecture Search and discover a new feature pyramid architecture in a novel scalable search space covering all cross-scale connections. The discovered architecture, named NAS-FPN, consists of a combination of top-down and bottom-up connections to fuse features across scales. NAS-FPN, combined with various backbone models in the RetinaNet framework, achieves better accuracy and latency tradeoff compared to state-of-the-art object detection models. NAS-FPN improves mobile detection accuracy by 2 AP compared to state-of-the-art SSDLite with MobileNetV2 model in \[32\] and achieves 48.3 AP which surpasses Mask R-CNN \[10\] detection accuracy with less computation time. + +
    + +
    + +## Results and Models + +We benchmark the new training schedule (crop training, large batch, unfrozen BN, 50 epochs) introduced in NAS-FPN. RetinaNet is used in the paper. + +| Backbone | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :---------: | :-----: | :------: | :------------: | :----: | :--------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | 50e | 12.9 | 22.9 | 37.9 | [config](./retinanet_r50_fpn_crop640-50e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/nas_fpn/retinanet_r50_fpn_crop640_50e_coco/retinanet_r50_fpn_crop640_50e_coco-9b953d76.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/nas_fpn/retinanet_r50_fpn_crop640_50e_coco/retinanet_r50_fpn_crop640_50e_coco_20200529_095329.log.json) | +| R-50-NASFPN | 50e | 13.2 | 23.0 | 40.5 | [config](./retinanet_r50_nasfpn_crop640-50e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/nas_fpn/retinanet_r50_nasfpn_crop640_50e_coco/retinanet_r50_nasfpn_crop640_50e_coco-0ad1f644.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/nas_fpn/retinanet_r50_nasfpn_crop640_50e_coco/retinanet_r50_nasfpn_crop640_50e_coco_20200528_230008.log.json) | + +**Note**: We find that it is unstable to train NAS-FPN and there is a small chance that results can be 3% mAP lower. + +## Citation + +```latex +@inproceedings{ghiasi2019fpn, + title={Nas-fpn: Learning scalable feature pyramid architecture for object detection}, + author={Ghiasi, Golnaz and Lin, Tsung-Yi and Le, Quoc V}, + booktitle={Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition}, + pages={7036--7045}, + year={2019} +} +``` diff --git a/mmdetection/configs/nas_fpn/metafile.yml b/mmdetection/configs/nas_fpn/metafile.yml new file mode 100644 index 00000000..aef0df6d --- /dev/null +++ b/mmdetection/configs/nas_fpn/metafile.yml @@ -0,0 +1,59 @@ +Collections: + - Name: NAS-FPN + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - NAS-FPN + - ResNet + Paper: + URL: https://arxiv.org/abs/1904.07392 + Title: 'NAS-FPN: Learning Scalable Feature Pyramid Architecture for Object Detection' + README: configs/nas_fpn/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/necks/nas_fpn.py#L67 + Version: v2.0.0 + +Models: + - Name: retinanet_r50_fpn_crop640-50e_coco + In Collection: NAS-FPN + Config: configs/nas_fpn/retinanet_r50_fpn_crop640-50e_coco.py + Metadata: + Training Memory (GB): 12.9 + inference time (ms/im): + - value: 43.67 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 50 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/nas_fpn/retinanet_r50_fpn_crop640_50e_coco/retinanet_r50_fpn_crop640_50e_coco-9b953d76.pth + + - Name: retinanet_r50_nasfpn_crop640-50e_coco + In Collection: NAS-FPN + Config: configs/nas_fpn/retinanet_r50_nasfpn_crop640-50e_coco.py + Metadata: + Training Memory (GB): 13.2 + inference time (ms/im): + - value: 43.48 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 50 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/nas_fpn/retinanet_r50_nasfpn_crop640_50e_coco/retinanet_r50_nasfpn_crop640_50e_coco-0ad1f644.pth diff --git a/mmdetection/configs/nas_fpn/retinanet_r50_fpn_crop640-50e_coco.py b/mmdetection/configs/nas_fpn/retinanet_r50_fpn_crop640-50e_coco.py new file mode 100644 index 00000000..11c34f67 --- /dev/null +++ b/mmdetection/configs/nas_fpn/retinanet_r50_fpn_crop640-50e_coco.py @@ -0,0 +1,78 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +norm_cfg = dict(type='BN', requires_grad=True) +model = dict( + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=64, + batch_augments=[dict(type='BatchFixedSizePad', size=(640, 640))]), + backbone=dict(norm_eval=False), + neck=dict( + relu_before_extra_convs=True, + no_norm_on_lateral=True, + norm_cfg=norm_cfg), + bbox_head=dict(type='RetinaSepBNHead', num_ins=5, norm_cfg=norm_cfg), + # training and testing settings + train_cfg=dict(assigner=dict(neg_iou_thr=0.5))) + +# dataset settings +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomResize', + scale=(640, 640), + ratio_range=(0.8, 1.2), + keep_ratio=True), + dict(type='RandomCrop', crop_size=(640, 640)), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=(640, 640), keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict( + batch_size=8, num_workers=4, dataset=dict(pipeline=train_pipeline)) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader + +# training schedule for 50e +max_epochs = 50 +train_cfg = dict(max_epochs=max_epochs) + +# learning rate +param_scheduler = [ + dict(type='LinearLR', start_factor=0.1, by_epoch=False, begin=0, end=1000), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[30, 40], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.08, momentum=0.9, weight_decay=0.0001), + paramwise_cfg=dict(norm_decay_mult=0, bypass_duplicate=True)) + +env_cfg = dict(cudnn_benchmark=True) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (8 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/nas_fpn/retinanet_r50_nasfpn_crop640-50e_coco.py b/mmdetection/configs/nas_fpn/retinanet_r50_nasfpn_crop640-50e_coco.py new file mode 100644 index 00000000..a851b745 --- /dev/null +++ b/mmdetection/configs/nas_fpn/retinanet_r50_nasfpn_crop640-50e_coco.py @@ -0,0 +1,16 @@ +_base_ = './retinanet_r50_fpn_crop640-50e_coco.py' + +# model settings +model = dict( + # `pad_size_divisor=128` ensures the feature maps sizes + # in `NAS_FPN` won't mismatch. + data_preprocessor=dict(pad_size_divisor=128), + neck=dict( + _delete_=True, + type='NASFPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + num_outs=5, + stack_times=7, + start_level=1, + norm_cfg=dict(type='BN', requires_grad=True))) diff --git a/mmdetection/configs/objects365/README.md b/mmdetection/configs/objects365/README.md new file mode 100644 index 00000000..fca0dbfc --- /dev/null +++ b/mmdetection/configs/objects365/README.md @@ -0,0 +1,102 @@ +# Objects365 Dataset + +> [Objects365 Dataset](https://openaccess.thecvf.com/content_ICCV_2019/papers/Shao_Objects365_A_Large-Scale_High-Quality_Dataset_for_Object_Detection_ICCV_2019_paper.pdf) + + + +## Abstract + + + +#### Objects365 Dataset V1 + +[Objects365 Dataset V1](http://www.objects365.org/overview.html) is a brand new dataset, +designed to spur object detection research with a focus on diverse objects in the Wild. +It has 365 object categories over 600K training images. More than 10 million, high-quality bounding boxes are manually labeled through a three-step, carefully designed annotation pipeline. It is the largest object detection dataset (with full annotation) so far and establishes a more challenging benchmark for the community. Objects365 can serve as a better feature learning dataset for localization-sensitive tasks like object detection +and semantic segmentation. + + + +
    + +
    + +#### Objects365 Dataset V2 + +[Objects365 Dataset V2](http://www.objects365.org/overview.html) is based on the V1 release of the Objects365 dataset. +Objects 365 annotated 365 object classes on more than 1800k images, with more than 29 million bounding boxes in the training set, surpassing PASCAL VOC, ImageNet, and COCO datasets. +Objects 365 includes 11 categories of people, clothing, living room, bathroom, kitchen, office/medical, electrical appliances, transportation, food, animals, sports/musical instruments, and each category has dozens of subcategories. + +## Citation + +``` +@inproceedings{shao2019objects365, + title={Objects365: A large-scale, high-quality dataset for object detection}, + author={Shao, Shuai and Li, Zeming and Zhang, Tianyuan and Peng, Chao and Yu, Gang and Zhang, Xiangyu and Li, Jing and Sun, Jian}, + booktitle={Proceedings of the IEEE/CVF international conference on computer vision}, + pages={8430--8439}, + year={2019} +} +``` + +## Prepare Dataset + +1. You need to download and extract Objects365 dataset. Users can download Objects365 V2 by using `tools/misc/download_dataset.py`. + + **Usage** + + ```shell + python tools/misc/download_dataset.py --dataset-name objects365v2 \ + --save-dir ${SAVING PATH} \ + --unzip \ + --delete # Optional, delete the download zip file + ``` + + **Note:** There is no download link for Objects365 V1 right now. If you would like to download Objects365-V1, please visit [official website](http://www.objects365.org/) to concat the author. + +2. The directory should be like this: + + ```none + mmdetection + ├── mmdet + ├── tools + ├── configs + ├── data + │ ├── Objects365 + │ │ ├── Obj365_v1 + │ │ │ ├── annotations + │ │ │ │ ├── objects365_train.json + │ │ │ │ ├── objects365_val.json + │ │ │ ├── train # training images + │ │ │ ├── val # validation images + │ │ ├── Obj365_v2 + │ │ │ ├── annotations + │ │ │ │ ├── zhiyuan_objv2_train.json + │ │ │ │ ├── zhiyuan_objv2_val.json + │ │ │ ├── train # training images + │ │ │ │ ├── patch0 + │ │ │ │ ├── patch1 + │ │ │ │ ├── ... + │ │ │ ├── val # validation images + │ │ │ │ ├── patch0 + │ │ │ │ ├── patch1 + │ │ │ │ ├── ... + ``` + +## Results and Models + +### Objects365 V1 + +| Architecture | Backbone | Style | Lr schd | Mem (GB) | box AP | Config | Download | +| :----------: | :------: | :-----: | :-----: | :------: | :----: | :-------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| Faster R-CNN | R-50 | pytorch | 1x | - | 19.6 | [config](https://github.com/open-mmlab/mmdetection/tree/main/configs/objects365/faster-rcnn_r50_fpn_16xb4-1x_objects365v1.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/objects365/faster_rcnn_r50_fpn_16x4_1x_obj365v1/faster_rcnn_r50_fpn_16x4_1x_obj365v1_20221219_181226-9ff10f95.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/objects365/faster_rcnn_r50_fpn_16x4_1x_obj365v1/faster_rcnn_r50_fpn_16x4_1x_obj365v1_20221219_181226.log.json) | +| Faster R-CNN | R-50 | pytorch | 1350K | - | 22.3 | [config](https://github.com/open-mmlab/mmdetection/tree/main/configs/objects365/faster-rcnn_r50-syncbn_fpn_1350k_objects365v1.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/objects365/faster_rcnn_r50_fpn_syncbn_1350k_obj365v1/faster_rcnn_r50_fpn_syncbn_1350k_obj365v1_20220510_142457-337d8965.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/objects365/faster_rcnn_r50_fpn_syncbn_1350k_obj365v1/faster_rcnn_r50_fpn_syncbn_1350k_obj365v1_20220510_142457.log.json) | +| Retinanet | R-50 | pytorch | 1x | - | 14.8 | [config](https://github.com/open-mmlab/mmdetection/tree/main/configs/objects365/retinanet_r50_fpn_1x_objects365v1.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/objects365/retinanet_r50_fpn_1x_obj365v1/retinanet_r50_fpn_1x_obj365v1_20221219_181859-ba3e3dd5.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/objects365/retinanet_r50_fpn_1x_obj365v1/retinanet_r50_fpn_1x_obj365v1_20221219_181859.log.json) | +| Retinanet | R-50 | pytorch | 1350K | - | 18.0 | [config](https://github.com/open-mmlab/mmdetection/tree/main/configs/objects365/retinanet_r50-syncbn_fpn_1350k_objects365v1.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/objects365/retinanet_r50_fpn_syncbn_1350k_obj365v1/retinanet_r50_fpn_syncbn_1350k_obj365v1_20220513_111237-7517c576.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/objects365/retinanet_r50_fpn_syncbn_1350k_obj365v1/retinanet_r50_fpn_syncbn_1350k_obj365v1_20220513_111237.log.json) | + +### Objects365 V2 + +| Architecture | Backbone | Style | Lr schd | Mem (GB) | box AP | Config | Download | +| :----------: | :------: | :-----: | :-----: | :------: | :----: | :---------------------------------------------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| Faster R-CNN | R-50 | pytorch | 1x | - | 19.8 | [config](https://github.com/open-mmlab/mmdetection/tree/main/configs/objects365/faster-rcnn_r50_fpn_16xb4-1x_objects365v2.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/objects365/faster_rcnn_r50_fpn_16x4_1x_obj365v2/faster_rcnn_r50_fpn_16x4_1x_obj365v2_20221220_175040-5910b015.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/objects365/faster_rcnn_r50_fpn_16x4_1x_obj365v2/faster_rcnn_r50_fpn_16x4_1x_obj365v2_20221220_175040.log.json) | +| Retinanet | R-50 | pytorch | 1x | - | 16.7 | [config](https://github.com/open-mmlab/mmdetection/tree/main/configs/objects365/retinanet_r50_fpn_1x_objects365v2.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/objects365/retinanet_r50_fpn_1x_obj365v2/retinanet_r50_fpn_1x_obj365v2_20221223_122105-d9b191f1.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/objects365/retinanet_r50_fpn_1x_obj365v2/retinanet_r50_fpn_1x_obj365v2_20221223_122105.log.json) | diff --git a/mmdetection/configs/objects365/faster-rcnn_r50-syncbn_fpn_1350k_objects365v1.py b/mmdetection/configs/objects365/faster-rcnn_r50-syncbn_fpn_1350k_objects365v1.py new file mode 100644 index 00000000..ff7d0a36 --- /dev/null +++ b/mmdetection/configs/objects365/faster-rcnn_r50-syncbn_fpn_1350k_objects365v1.py @@ -0,0 +1,49 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../_base_/datasets/objects365v2_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +model = dict( + backbone=dict(norm_cfg=dict(type='SyncBN', requires_grad=True)), + roi_head=dict(bbox_head=dict(num_classes=365))) + +# training schedule for 1350K +train_cfg = dict( + _delete_=True, + type='IterBasedTrainLoop', + max_iters=1350000, # 36 epochs + val_interval=150000) + +# Using 8 GPUS while training +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001), + clip_grad=dict(max_norm=35, norm_type=2)) + +# learning rate policy +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0 / 1000, + by_epoch=False, + begin=0, + end=1000), + dict( + type='MultiStepLR', + begin=0, + end=1350000, + by_epoch=False, + milestones=[900000, 1200000], + gamma=0.1) +] + +train_dataloader = dict(sampler=dict(type='InfiniteSampler')) +default_hooks = dict(checkpoint=dict(by_epoch=False, interval=150000)) + +log_processor = dict(by_epoch=False) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=16) diff --git a/mmdetection/configs/objects365/faster-rcnn_r50_fpn_16xb4-1x_objects365v1.py b/mmdetection/configs/objects365/faster-rcnn_r50_fpn_16xb4-1x_objects365v1.py new file mode 100644 index 00000000..bc0d96fa --- /dev/null +++ b/mmdetection/configs/objects365/faster-rcnn_r50_fpn_16xb4-1x_objects365v1.py @@ -0,0 +1,39 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../_base_/datasets/objects365v1_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +model = dict(roi_head=dict(bbox_head=dict(num_classes=365))) + +train_dataloader = dict( + batch_size=4, # using 16 GPUS while training. total batch size is 16 x 4) +) + +# Using 32 GPUS while training +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.08, momentum=0.9, weight_decay=0.0001), + clip_grad=dict(max_norm=35, norm_type=2)) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0 / 1000, + by_epoch=False, + begin=0, + end=1000), + dict( + type='MultiStepLR', + begin=0, + end=12, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (32 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/objects365/faster-rcnn_r50_fpn_16xb4-1x_objects365v2.py b/mmdetection/configs/objects365/faster-rcnn_r50_fpn_16xb4-1x_objects365v2.py new file mode 100644 index 00000000..1090678f --- /dev/null +++ b/mmdetection/configs/objects365/faster-rcnn_r50_fpn_16xb4-1x_objects365v2.py @@ -0,0 +1,39 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../_base_/datasets/objects365v2_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +model = dict(roi_head=dict(bbox_head=dict(num_classes=365))) + +train_dataloader = dict( + batch_size=4, # using 16 GPUS while training. total batch size is 16 x 4) +) + +# Using 32 GPUS while training +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.08, momentum=0.9, weight_decay=0.0001), + clip_grad=dict(max_norm=35, norm_type=2)) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0 / 1000, + by_epoch=False, + begin=0, + end=1000), + dict( + type='MultiStepLR', + begin=0, + end=12, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (32 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/objects365/metafile.yml b/mmdetection/configs/objects365/metafile.yml new file mode 100644 index 00000000..d43e8bde --- /dev/null +++ b/mmdetection/configs/objects365/metafile.yml @@ -0,0 +1,101 @@ +- Name: retinanet_r50_fpn_1x_objects365v1 + In Collection: RetinaNet + Config: configs/objects365/retinanet_r50_fpn_1x_objects365v1.py + Metadata: + Training Memory (GB): 7.4 + Epochs: 12 + Training Data: Objects365 v1 + Training Techniques: + - SGD with Momentum + - Weight Decay + Results: + - Task: Object Detection + Dataset: Objects365 v1 + Metrics: + box AP: 14.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/objects365/retinanet_r50_fpn_1x_obj365v1/retinanet_r50_fpn_1x_obj365v1_20221219_181859-ba3e3dd5.pth + +- Name: retinanet_r50-syncbn_fpn_1350k_objects365v1 + In Collection: RetinaNet + Config: configs/objects365/retinanet_r50-syncbn_fpn_1350k_objects365v1.py + Metadata: + Training Memory (GB): 7.6 + Iterations: 1350000 + Training Data: Objects365 v1 + Training Techniques: + - SGD with Momentum + - Weight Decay + Results: + - Task: Object Detection + Dataset: Objects365 v1 + Metrics: + box AP: 18.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/objects365/retinanet_r50_fpn_syncbn_1350k_obj365v1/retinanet_r50_fpn_syncbn_1350k_obj365v1_20220513_111237-7517c576.pth + +- Name: retinanet_r50_fpn_1x_objects365v2 + In Collection: RetinaNet + Config: configs/objects365/retinanet_r50_fpn_1x_objects365v2.py + Metadata: + Training Memory (GB): 7.2 + Epochs: 12 + Training Data: Objects365 v2 + Training Techniques: + - SGD with Momentum + - Weight Decay + Results: + - Task: Object Detection + Dataset: Objects365 v2 + Metrics: + box AP: 16.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/objects365/retinanet_r50_fpn_1x_obj365v2/retinanet_r50_fpn_1x_obj365v2_20221223_122105-d9b191f1.pth + +- Name: faster-rcnn_r50_fpn_16xb4-1x_objects365v1 + In Collection: Faster R-CNN + Config: configs/objects365/faster-rcnn_r50_fpn_16xb4-1x_objects365v1.py + Metadata: + Training Memory (GB): 11.4 + Epochs: 12 + Training Data: Objects365 v1 + Training Techniques: + - SGD with Momentum + - Weight Decay + Results: + - Task: Object Detection + Dataset: Objects365 v1 + Metrics: + box AP: 19.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/objects365/faster_rcnn_r50_fpn_16x4_1x_obj365v1/faster_rcnn_r50_fpn_16x4_1x_obj365v1_20221219_181226-9ff10f95.pth + +- Name: faster-rcnn_r50-syncbn_fpn_1350k_objects365v1 + In Collection: Faster R-CNN + Config: configs/objects365/faster-rcnn_r50-syncbn_fpn_1350k_objects365v1.py + Metadata: + Training Memory (GB): 8.6 + Iterations: 1350000 + Training Data: Objects365 v1 + Training Techniques: + - SGD with Momentum + - Weight Decay + Results: + - Task: Object Detection + Dataset: Objects365 v1 + Metrics: + box AP: 22.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/objects365/faster_rcnn_r50_fpn_syncbn_1350k_obj365v1/faster_rcnn_r50_fpn_syncbn_1350k_obj365v1_20220510_142457-337d8965.pth + +- Name: faster-rcnn_r50_fpn_16xb4-1x_objects365v2 + In Collection: Faster R-CNN + Config: configs/objects365/faster-rcnn_r50_fpn_16xb4-1x_objects365v2.py + Metadata: + Training Memory (GB): 10.8 + Epochs: 12 + Training Data: Objects365 v1 + Training Techniques: + - SGD with Momentum + - Weight Decay + Results: + - Task: Object Detection + Dataset: Objects365 v2 + Metrics: + box AP: 19.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/objects365/faster_rcnn_r50_fpn_16x4_1x_obj365v2/faster_rcnn_r50_fpn_16x4_1x_obj365v2_20221220_175040-5910b015.pth diff --git a/mmdetection/configs/objects365/retinanet_r50-syncbn_fpn_1350k_objects365v1.py b/mmdetection/configs/objects365/retinanet_r50-syncbn_fpn_1350k_objects365v1.py new file mode 100644 index 00000000..c41dfce8 --- /dev/null +++ b/mmdetection/configs/objects365/retinanet_r50-syncbn_fpn_1350k_objects365v1.py @@ -0,0 +1,49 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/datasets/objects365v2_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +model = dict( + backbone=dict(norm_cfg=dict(type='SyncBN', requires_grad=True)), + bbox_head=dict(num_classes=365)) + +# training schedule for 1350K +train_cfg = dict( + _delete_=True, + type='IterBasedTrainLoop', + max_iters=1350000, # 36 epochs + val_interval=150000) + +# Using 8 GPUS while training +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001), + clip_grad=dict(max_norm=35, norm_type=2)) + +# learning rate policy +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0 / 1000, + by_epoch=False, + begin=0, + end=10000), + dict( + type='MultiStepLR', + begin=0, + end=1350000, + by_epoch=False, + milestones=[900000, 1200000], + gamma=0.1) +] + +train_dataloader = dict(sampler=dict(type='InfiniteSampler')) +default_hooks = dict(checkpoint=dict(by_epoch=False, interval=150000)) + +log_processor = dict(by_epoch=False) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=16) diff --git a/mmdetection/configs/objects365/retinanet_r50_fpn_1x_objects365v1.py b/mmdetection/configs/objects365/retinanet_r50_fpn_1x_objects365v1.py new file mode 100644 index 00000000..72144192 --- /dev/null +++ b/mmdetection/configs/objects365/retinanet_r50_fpn_1x_objects365v1.py @@ -0,0 +1,35 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/datasets/objects365v1_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +model = dict(bbox_head=dict(num_classes=365)) + +# Using 8 GPUS while training +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001), + clip_grad=dict(max_norm=35, norm_type=2)) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0 / 1000, + by_epoch=False, + begin=0, + end=10000), + dict( + type='MultiStepLR', + begin=0, + end=12, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=16) diff --git a/mmdetection/configs/objects365/retinanet_r50_fpn_1x_objects365v2.py b/mmdetection/configs/objects365/retinanet_r50_fpn_1x_objects365v2.py new file mode 100644 index 00000000..21954412 --- /dev/null +++ b/mmdetection/configs/objects365/retinanet_r50_fpn_1x_objects365v2.py @@ -0,0 +1,35 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/datasets/objects365v2_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +model = dict(bbox_head=dict(num_classes=365)) + +# Using 8 GPUS while training +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001), + clip_grad=dict(max_norm=35, norm_type=2)) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0 / 1000, + by_epoch=False, + begin=0, + end=10000), + dict( + type='MultiStepLR', + begin=0, + end=12, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=16) diff --git a/mmdetection/configs/ocsort/README.md b/mmdetection/configs/ocsort/README.md new file mode 100644 index 00000000..e9b86c6c --- /dev/null +++ b/mmdetection/configs/ocsort/README.md @@ -0,0 +1,56 @@ +# Observation-Centric SORT: Rethinking SORT for Robust Multi-Object Tracking + +## Abstract + + + +Multi-Object Tracking (MOT) has rapidly progressed with the development of object detection and re-identification. However, motion modeling, which facilitates object association by forecasting short-term trajec- tories with past observations, has been relatively under-explored in recent years. Current motion models in MOT typically assume that the object motion is linear in a small time window and needs continuous observations, so these methods are sensitive to occlusions and non-linear motion and require high frame-rate videos. In this work, we show that a simple motion model can obtain state-of-the-art tracking performance without other cues like appearance. We emphasize the role of “observation” when recovering tracks from being lost and reducing the error accumulated by linear motion models during the lost period. We thus name the proposed method as Observation-Centric SORT, OC-SORT for short. It remains simple, online, and real-time but improves robustness over occlusion and non-linear motion. It achieves 63.2 and 62.1 HOTA on MOT17 and MOT20, respectively, surpassing all published methods. It also sets new states of the art on KITTI Pedestrian Tracking and DanceTrack where the object motion is highly non-linear + + + +
    + +
    + +## Citation + + + +```latex +@article{cao2022observation, + title={Observation-Centric SORT: Rethinking SORT for Robust Multi-Object Tracking}, + author={Cao, Jinkun and Weng, Xinshuo and Khirodkar, Rawal and Pang, Jiangmiao and Kitani, Kris}, + journal={arXiv preprint arXiv:2203.14360}, + year={2022} +} +``` + +## Results and models on MOT17 + +The performance on `MOT17-half-val` is comparable with the performance from [the OC-SORT official implementation](https://github.com/noahcao/OC_SORT). We use the same YOLO-X detector weights as in [ByteTrack](https://github.com/open-mmlab/mmtracking/tree/master/configs/mot/bytetrack). + +| Method | Detector | Train Set | Test Set | Public | Inf time (fps) | HOTA | MOTA | IDF1 | FP | FN | IDSw. | Config | Download | +| :-----: | :------: | :---------------------: | :------: | :----: | :------------: | :--: | :--: | :--: | :---: | :---: | :---: | :-------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| OC-SORT | YOLOX-X | CrowdHuman + half-train | half-val | N | - | 67.5 | 77.5 | 78.2 | 15987 | 19590 | 855 | [config](ocsort_yolox_x_crowdhuman_mot17-private-half.py) | [model](https://download.openmmlab.com/mmtracking/mot/ocsort/mot_dataset/ocsort_yolox_x_crowdhuman_mot17-private-half_20220813_101618-fe150582.pth) \| [log](https://download.openmmlab.com/mmtracking/mot/ocsort/mot_dataset/ocsort_yolox_x_crowdhuman_mot17-private-half_20220813_101618.log.json) | + +## Get started + +### 1. Development Environment Setup + +Tracking Development Environment Setup can refer to this [document](../../docs/en/get_started.md). + +### 2. Dataset Prepare + +Tracking Dataset Prepare can refer to this [document](../../docs/en/user_guides/tracking_dataset_prepare.md). + +### 3. Training + +OCSORT training is same as Bytetrack, please refer to [document](../../configs/bytetrack/README.md). + +### 4. Testing and evaluation + +OCSORT evaluation and test are same as Bytetrack, please refer to [document](../../configs/bytetrack/README.md). + +### 5.Inference + +OCSORT inference is same as Bytetrack, please refer to [document](../../configs/bytetrack/README.md). diff --git a/mmdetection/configs/ocsort/metafile.yml b/mmdetection/configs/ocsort/metafile.yml new file mode 100644 index 00000000..0a31ef10 --- /dev/null +++ b/mmdetection/configs/ocsort/metafile.yml @@ -0,0 +1,27 @@ +Collections: + - Name: OCSORT + Metadata: + Training Techniques: + - SGD with Momentum + Training Resources: 8x V100 GPUs + Architecture: + - YOLOX + Paper: + URL: https://arxiv.org/abs/2203.14360 + Title: Observation-Centric SORT Rethinking SORT for Robust Multi-Object Tracking + README: configs/ocsort/README.md + +Models: + - Name: ocsort_yolox_x_crowdhuman_mot17-private-half + In Collection: OCSORT + Config: configs/ocsort/ocsort_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval.py + Metadata: + Training Data: CrowdHuman + MOT17-half-train + Results: + - Task: Multiple Object Tracking + Dataset: MOT17-half-val + Metrics: + HOTA: 67.5 + MOTA: 77.5 + IDF1: 78.2 + Weights: https://download.openmmlab.com/mmtracking/mot/ocsort/mot_dataset/ocsort_yolox_x_crowdhuman_mot17-private-half_20220813_101618-fe150582.pth diff --git a/mmdetection/configs/ocsort/ocsort_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval.py b/mmdetection/configs/ocsort/ocsort_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval.py new file mode 100644 index 00000000..ea04923d --- /dev/null +++ b/mmdetection/configs/ocsort/ocsort_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval.py @@ -0,0 +1,18 @@ +_base_ = [ + '../bytetrack/bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval.py', # noqa: E501 +] + +model = dict( + type='OCSORT', + tracker=dict( + _delete_=True, + type='OCSORTTracker', + motion=dict(type='KalmanFilter'), + obj_score_thr=0.3, + init_track_thr=0.7, + weight_iou_with_det_scores=True, + match_iou_thr=0.3, + num_tentatives=3, + vel_consist_weight=0.2, + vel_delta_t=3, + num_frames_retain=30)) diff --git a/mmdetection/configs/ocsort/ocsort_yolox_x_8xb4-amp-80e_crowdhuman-mot20train_test-mot20test.py b/mmdetection/configs/ocsort/ocsort_yolox_x_8xb4-amp-80e_crowdhuman-mot20train_test-mot20test.py new file mode 100644 index 00000000..ea04923d --- /dev/null +++ b/mmdetection/configs/ocsort/ocsort_yolox_x_8xb4-amp-80e_crowdhuman-mot20train_test-mot20test.py @@ -0,0 +1,18 @@ +_base_ = [ + '../bytetrack/bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval.py', # noqa: E501 +] + +model = dict( + type='OCSORT', + tracker=dict( + _delete_=True, + type='OCSORTTracker', + motion=dict(type='KalmanFilter'), + obj_score_thr=0.3, + init_track_thr=0.7, + weight_iou_with_det_scores=True, + match_iou_thr=0.3, + num_tentatives=3, + vel_consist_weight=0.2, + vel_delta_t=3, + num_frames_retain=30)) diff --git a/mmdetection/configs/openimages/README.md b/mmdetection/configs/openimages/README.md new file mode 100644 index 00000000..ccfc721d --- /dev/null +++ b/mmdetection/configs/openimages/README.md @@ -0,0 +1,149 @@ +# Open Images Dataset + +> [Open Images Dataset](https://arxiv.org/abs/1811.00982) + + + +## Abstract + + + +#### Open Images v6 + +[Open Images](https://storage.googleapis.com/openimages/web/index.html) is a dataset of ~9M images annotated with image-level labels, +object bounding boxes, object segmentation masks, visual relationships, +and localized narratives: + +- It contains a total of 16M bounding boxes for 600 object classes on + 1.9M images, making it the largest existing dataset with object location + annotations. The boxes have been largely manually drawn by professional + annotators to ensure accuracy and consistency. The images are very diverse + and often contain complex scenes with several objects (8.3 per image on + average). + +- Open Images also offers visual relationship annotations, indicating pairs + of objects in particular relations (e.g. "woman playing guitar", "beer on + table"), object properties (e.g. "table is wooden"), and human actions (e.g. + "woman is jumping"). In total it has 3.3M annotations from 1,466 distinct + relationship triplets. + +- In V5 we added segmentation masks for 2.8M object instances in 350 classes. + Segmentation masks mark the outline of objects, which characterizes their + spatial extent to a much higher level of detail. + +- In V6 we added 675k localized narratives: multimodal descriptions of images + consisting of synchronized voice, text, and mouse traces over the objects being + described. (Note we originally launched localized narratives only on train in V6, + but since July 2020 we also have validation and test covered.) + +- Finally, the dataset is annotated with 59.9M image-level labels spanning 19,957 + classes. + +We believe that having a single dataset with unified annotations for image +classification, object detection, visual relationship detection, instance +segmentation, and multimodal image descriptions will enable to study these +tasks jointly and stimulate progress towards genuine scene understanding. + + + +
    + +
    + +#### Open Images Challenge 2019 + +[Open Images Challenges 2019](https://storage.googleapis.com/openimages/web/challenge2019.html) is based on the V5 release of the Open +Images dataset. The images of the dataset are very varied and +often contain complex scenes with several objects (explore the dataset). + +## Citation + +``` +@article{OpenImages, + author = {Alina Kuznetsova and Hassan Rom and Neil Alldrin and Jasper Uijlings and Ivan Krasin and Jordi Pont-Tuset and Shahab Kamali and Stefan Popov and Matteo Malloci and Alexander Kolesnikov and Tom Duerig and Vittorio Ferrari}, + title = {The Open Images Dataset V4: Unified image classification, object detection, and visual relationship detection at scale}, + year = {2020}, + journal = {IJCV} +} +``` + +## Prepare Dataset + +1. You need to download and extract Open Images dataset. + +2. The Open Images dataset does not have image metas (width and height of the image), + which will be used during training and testing (evaluation). We suggest to get test image metas before + training/testing by using `tools/misc/get_image_metas.py`. + + **Usage** + + ```shell + python tools/misc/get_image_metas.py ${CONFIG} \ + --dataset ${DATASET TYPE} \ # train or val or test + --out ${OUTPUT FILE NAME} + ``` + +3. The directory should be like this: + + ```none + mmdetection + ├── mmdet + ├── tools + ├── configs + ├── data + │ ├── OpenImages + │ │ ├── annotations + │ │ │ ├── bbox_labels_600_hierarchy.json + │ │ │ ├── class-descriptions-boxable.csv + │ │ │ ├── oidv6-train-annotations-bbox.scv + │ │ │ ├── validation-annotations-bbox.csv + │ │ │ ├── validation-annotations-human-imagelabels-boxable.csv + │ │ │ ├── validation-image-metas.pkl # get from script + │ │ ├── challenge2019 + │ │ │ ├── challenge-2019-train-detection-bbox.txt + │ │ │ ├── challenge-2019-validation-detection-bbox.txt + │ │ │ ├── class_label_tree.np + │ │ │ ├── class_sample_train.pkl + │ │ │ ├── challenge-2019-validation-detection-human-imagelabels.csv # download from official website + │ │ │ ├── challenge-2019-validation-metas.pkl # get from script + │ │ ├── OpenImages + │ │ │ ├── train # training images + │ │ │ ├── test # testing images + │ │ │ ├── validation # validation images + ``` + +**Note**: + +1. The training and validation images of Open Images Challenge dataset are based on + Open Images v6, but the test images are different. +2. The Open Images Challenges annotations are obtained from [TSD](https://github.com/Sense-X/TSD). + You can also download the annotations from [official website](https://storage.googleapis.com/openimages/web/challenge2019_downloads.html), + and set data.train.type=OpenImagesDataset, data.val.type=OpenImagesDataset, and data.test.type=OpenImagesDataset in the config +3. If users do not want to use `validation-annotations-human-imagelabels-boxable.csv` and `challenge-2019-validation-detection-human-imagelabels.csv` + users can set `test_dataloader.dataset.image_level_ann_file=None` and `test_dataloader.dataset.image_level_ann_file=None` in the config. + Please note that loading image-levels label is the default of Open Images evaluation metric. + More details please refer to the [official website](https://storage.googleapis.com/openimages/web/evaluation.html) + +## Results and Models + +| Architecture | Backbone | Style | Lr schd | Sampler | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :---------------------------: | :------: | :-----: | :-----: | :-----------------: | :------: | :------------: | :----: | :------------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| Faster R-CNN | R-50 | pytorch | 1x | Group Sampler | 7.7 | - | 51.6 | [config](./faster-rcnn_r50_fpn_32xb2-1x_openimages.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/openimages/faster_rcnn_r50_fpn_32x2_1x_openimages/faster_rcnn_r50_fpn_32x2_1x_openimages_20211130_231159-e87ab7ce.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/openimages/faster_rcnn_r50_fpn_32x2_1x_openimages/faster_rcnn_r50_fpn_32x2_1x_openimages_20211130_231159.log.json) | +| Faster R-CNN | R-50 | pytorch | 1x | Class Aware Sampler | 7.7 | - | 60.0 | [config](./faster-rcnn_r50_fpn_32xb2-cas-1x_openimages.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/openimages/faster_rcnn_r50_fpn_32x2_cas_1x_openimages/faster_rcnn_r50_fpn_32x2_cas_1x_openimages_20220306_202424-98c630e5.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/openimages/faster_rcnn_r50_fpn_32x2_cas_1x_openimages/faster_rcnn_r50_fpn_32x2_cas_1x_openimages_20220306_202424.log.json) | +| Faster R-CNN (Challenge 2019) | R-50 | pytorch | 1x | Group Sampler | 7.7 | - | 54.9 | [config](./faster-rcnn_r50_fpn_32xb2-1x_openimages-challenge.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/openimages/faster_rcnn_r50_fpn_32x2_1x_openimages_challenge/faster_rcnn_r50_fpn_32x2_1x_openimages_challenge_20220114_045100-0e79e5df.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/openimages/faster_rcnn_r50_fpn_32x2_1x_openimages_challenge/faster_rcnn_r50_fpn_32x2_1x_openimages_challenge_20220114_045100.log.json) | +| Faster R-CNN (Challenge 2019) | R-50 | pytorch | 1x | Class Aware Sampler | 7.1 | - | 65.0 | [config](./faster-rcnn_r50_fpn_32xb2-cas-1x_openimages-challenge.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/openimages/faster_rcnn_r50_fpn_32x2_cas_1x_openimages_challenge/faster_rcnn_r50_fpn_32x2_cas_1x_openimages_challenge_20220221_192021-34c402d9.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/openimages/faster_rcnn_r50_fpn_32x2_cas_1x_openimages_challenge/faster_rcnn_r50_fpn_32x2_cas_1x_openimages_challenge_20220221_192021.log.json) | +| Retinanet | R-50 | pytorch | 1x | Group Sampler | 6.6 | - | 61.5 | [config](./retinanet_r50_fpn_32xb2-1x_openimages.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/openimages/retinanet_r50_fpn_32x2_1x_openimages/retinanet_r50_fpn_32x2_1x_openimages_20211223_071954-d2ae5462.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/openimages/retinanet_r50_fpn_32x2_1x_openimages/retinanet_r50_fpn_32x2_1x_openimages_20211223_071954.log.json) | +| SSD | VGG16 | pytorch | 36e | Group Sampler | 10.8 | - | 35.4 | [config](./ssd300_32xb8-36e_openimages.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/openimages/ssd300_32x8_36e_openimages/ssd300_32x8_36e_openimages_20211224_000232-dce93846.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/openimages/ssd300_32x8_36e_openimages/ssd300_32x8_36e_openimages_20211224_000232.log.json) | + +**Notes:** + +- 'cas' is short for 'Class Aware Sampler' + +### Results of consider image level labels + +| Architecture | Sampler | Consider Image Level Labels | box AP | +| :-------------------------------: | :-----------------: | :-------------------------: | :----: | +| Faster R-CNN r50 (Challenge 2019) | Group Sampler | w/o | 62.19 | +| Faster R-CNN r50 (Challenge 2019) | Group Sampler | w/ | 54.87 | +| Faster R-CNN r50 (Challenge 2019) | Class Aware Sampler | w/o | 71.77 | +| Faster R-CNN r50 (Challenge 2019) | Class Aware Sampler | w/ | 64.98 | diff --git a/mmdetection/configs/openimages/faster-rcnn_r50_fpn_32xb2-1x_openimages-challenge.py b/mmdetection/configs/openimages/faster-rcnn_r50_fpn_32xb2-1x_openimages-challenge.py new file mode 100644 index 00000000..e79a92cc --- /dev/null +++ b/mmdetection/configs/openimages/faster-rcnn_r50_fpn_32xb2-1x_openimages-challenge.py @@ -0,0 +1,39 @@ +_base_ = ['faster-rcnn_r50_fpn_32xb2-1x_openimages.py'] + +model = dict( + roi_head=dict(bbox_head=dict(num_classes=500)), + test_cfg=dict(rcnn=dict(score_thr=0.01))) + +# dataset settings +dataset_type = 'OpenImagesChallengeDataset' +train_dataloader = dict( + dataset=dict( + type=dataset_type, + ann_file='challenge2019/challenge-2019-train-detection-bbox.txt', + label_file='challenge2019/cls-label-description.csv', + hierarchy_file='challenge2019/class_label_tree.np', + meta_file='challenge2019/challenge-2019-train-metas.pkl')) +val_dataloader = dict( + dataset=dict( + type=dataset_type, + ann_file='challenge2019/challenge-2019-validation-detection-bbox.txt', + data_prefix=dict(img='OpenImages/'), + label_file='challenge2019/cls-label-description.csv', + hierarchy_file='challenge2019/class_label_tree.np', + meta_file='challenge2019/challenge-2019-validation-metas.pkl', + image_level_ann_file='challenge2019/challenge-2019-validation-' + 'detection-human-imagelabels.csv')) +test_dataloader = dict( + dataset=dict( + type=dataset_type, + ann_file='challenge2019/challenge-2019-validation-detection-bbox.txt', + label_file='challenge2019/cls-label-description.csv', + hierarchy_file='challenge2019/class_label_tree.np', + meta_file='challenge2019/challenge-2019-validation-metas.pkl', + image_level_ann_file='challenge2019/challenge-2019-validation-' + 'detection-human-imagelabels.csv')) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (32 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/openimages/faster-rcnn_r50_fpn_32xb2-1x_openimages.py b/mmdetection/configs/openimages/faster-rcnn_r50_fpn_32xb2-1x_openimages.py new file mode 100644 index 00000000..f3f0aa0a --- /dev/null +++ b/mmdetection/configs/openimages/faster-rcnn_r50_fpn_32xb2-1x_openimages.py @@ -0,0 +1,35 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../_base_/datasets/openimages_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +model = dict(roi_head=dict(bbox_head=dict(num_classes=601))) + +# Using 32 GPUS while training +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.08, momentum=0.9, weight_decay=0.0001), + clip_grad=dict(max_norm=35, norm_type=2)) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0 / 64, + by_epoch=False, + begin=0, + end=26000), + dict( + type='MultiStepLR', + begin=0, + end=12, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (32 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/openimages/faster-rcnn_r50_fpn_32xb2-cas-1x_openimages-challenge.py b/mmdetection/configs/openimages/faster-rcnn_r50_fpn_32xb2-cas-1x_openimages-challenge.py new file mode 100644 index 00000000..9e428725 --- /dev/null +++ b/mmdetection/configs/openimages/faster-rcnn_r50_fpn_32xb2-cas-1x_openimages-challenge.py @@ -0,0 +1,5 @@ +_base_ = ['faster-rcnn_r50_fpn_32xb2-1x_openimages-challenge.py'] + +# Use ClassAwareSampler +train_dataloader = dict( + sampler=dict(_delete_=True, type='ClassAwareSampler', num_sample_class=1)) diff --git a/mmdetection/configs/openimages/faster-rcnn_r50_fpn_32xb2-cas-1x_openimages.py b/mmdetection/configs/openimages/faster-rcnn_r50_fpn_32xb2-cas-1x_openimages.py new file mode 100644 index 00000000..803190ab --- /dev/null +++ b/mmdetection/configs/openimages/faster-rcnn_r50_fpn_32xb2-cas-1x_openimages.py @@ -0,0 +1,5 @@ +_base_ = ['faster-rcnn_r50_fpn_32xb2-1x_openimages.py'] + +# Use ClassAwareSampler +train_dataloader = dict( + sampler=dict(_delete_=True, type='ClassAwareSampler', num_sample_class=1)) diff --git a/mmdetection/configs/openimages/metafile.yml b/mmdetection/configs/openimages/metafile.yml new file mode 100644 index 00000000..76c12094 --- /dev/null +++ b/mmdetection/configs/openimages/metafile.yml @@ -0,0 +1,102 @@ +Models: + - Name: faster-rcnn_r50_fpn_32x2_1x_openimages + In Collection: Faster R-CNN + Config: configs/openimages/faster-rcnn_r50_fpn_32xb2-1x_openimages.py + Metadata: + Training Memory (GB): 7.7 + Epochs: 12 + Training Data: Open Images v6 + Training Techniques: + - SGD with Momentum + - Weight Decay + Results: + - Task: Object Detection + Dataset: Open Images v6 + Metrics: + box AP: 51.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/openimages/faster_rcnn_r50_fpn_32x2_1x_openimages/faster_rcnn_r50_fpn_32x2_1x_openimages_20211130_231159-e87ab7ce.pth + + - Name: retinanet_r50_fpn_32xb2-1x_openimages + In Collection: RetinaNet + Config: configs/openimages/retinanet_r50_fpn_32xb2-1x_openimages.py + Metadata: + Training Memory (GB): 6.6 + Epochs: 12 + Training Data: Open Images v6 + Training Techniques: + - SGD with Momentum + - Weight Decay + Results: + - Task: Object Detection + Dataset: Open Images v6 + Metrics: + box AP: 61.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/openimages/retinanet_r50_fpn_32x2_1x_openimages/retinanet_r50_fpn_32x2_1x_openimages_20211223_071954-d2ae5462.pth + + - Name: ssd300_32xb8-36e_openimages + In Collection: SSD + Config: configs/openimages/ssd300_32xb8-36e_openimages.py + Metadata: + Training Memory (GB): 10.8 + Epochs: 36 + Training Data: Open Images v6 + Training Techniques: + - SGD with Momentum + - Weight Decay + Results: + - Task: Object Detection + Dataset: Open Images v6 + Metrics: + box AP: 35.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/openimages/ssd300_32x8_36e_openimages/ssd300_32x8_36e_openimages_20211224_000232-dce93846.pth + + - Name: faster-rcnn_r50_fpn_32x2_1x_openimages_challenge + In Collection: Faster R-CNN + Config: configs/openimages/faster-rcnn_r50_fpn_32xb2-1x_openimages-challenge.py + Metadata: + Training Memory (GB): 7.7 + Epochs: 12 + Training Data: Open Images Challenge 2019 + Training Techniques: + - SGD with Momentum + - Weight Decay + Results: + - Task: Object Detection + Dataset: Open Images Challenge 2019 + Metrics: + box AP: 54.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/openimages/faster_rcnn_r50_fpn_32x2_1x_openimages_challenge/faster_rcnn_r50_fpn_32x2_1x_openimages_challenge_20220114_045100-0e79e5df.pth + + - Name: faster-rcnn_r50_fpn_32x2_cas_1x_openimages + In Collection: Faster R-CNN + Config: configs/openimages/faster-rcnn_r50_fpn_32xb2-cas-1x_openimages.py + Metadata: + Training Memory (GB): 7.7 + Epochs: 12 + Training Data: Open Images Challenge 2019 + Training Techniques: + - SGD with Momentum + - Weight Decay + Results: + - Task: Object Detection + Dataset: Open Images Challenge 2019 + Metrics: + box AP: 60.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/openimages/faster_rcnn_r50_fpn_32x2_cas_1x_openimages/faster_rcnn_r50_fpn_32x2_cas_1x_openimages_20220306_202424-98c630e5.pth + + - Name: faster-rcnn_r50_fpn_32x2_cas_1x_openimages_challenge + In Collection: Faster R-CNN + Config: configs/openimages/faster-rcnn_r50_fpn_32xb2-cas-1x_openimages-challenge.py + Metadata: + Training Memory (GB): 7.1 + Epochs: 12 + Training Data: Open Images Challenge 2019 + Training Techniques: + - SGD with Momentum + - Weight Decay + Results: + - Task: Object Detection + Dataset: Open Images Challenge 2019 + Metrics: + box AP: 65.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/openimages/faster_rcnn_r50_fpn_32x2_cas_1x_openimages_challenge/faster_rcnn_r50_fpn_32x2_cas_1x_openimages_challenge_20220221_192021-34c402d9.pth diff --git a/mmdetection/configs/openimages/retinanet_r50_fpn_32xb2-1x_openimages.py b/mmdetection/configs/openimages/retinanet_r50_fpn_32xb2-1x_openimages.py new file mode 100644 index 00000000..97a0eb07 --- /dev/null +++ b/mmdetection/configs/openimages/retinanet_r50_fpn_32xb2-1x_openimages.py @@ -0,0 +1,35 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/datasets/openimages_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +model = dict(bbox_head=dict(num_classes=601)) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0 / 64, + by_epoch=False, + begin=0, + end=26000), + dict( + type='MultiStepLR', + begin=0, + end=12, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.08, momentum=0.9, weight_decay=0.0001), + clip_grad=dict(max_norm=35, norm_type=2)) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (32 GPUs) x (2 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/openimages/ssd300_32xb8-36e_openimages.py b/mmdetection/configs/openimages/ssd300_32xb8-36e_openimages.py new file mode 100644 index 00000000..9cb51cae --- /dev/null +++ b/mmdetection/configs/openimages/ssd300_32xb8-36e_openimages.py @@ -0,0 +1,88 @@ +_base_ = [ + '../_base_/models/ssd300.py', '../_base_/datasets/openimages_detection.py', + '../_base_/default_runtime.py', '../_base_/schedules/schedule_1x.py' +] +model = dict( + bbox_head=dict( + num_classes=601, + anchor_generator=dict(basesize_ratio_range=(0.2, 0.9)))) +# dataset settings +dataset_type = 'OpenImagesDataset' +data_root = 'data/OpenImages/' +input_size = 300 +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict( + type='Expand', + mean={{_base_.model.data_preprocessor.mean}}, + to_rgb={{_base_.model.data_preprocessor.bgr_to_rgb}}, + ratio_range=(1, 4)), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.3), + dict(type='Resize', scale=(input_size, input_size), keep_ratio=False), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=(input_size, input_size), keep_ratio=False), + # avoid bboxes being resized + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'instances')) +] + +train_dataloader = dict( + batch_size=8, # using 32 GPUS while training. total batch size is 32 x 8 + batch_sampler=None, + dataset=dict( + _delete_=True, + type='RepeatDataset', + times=3, # repeat 3 times, total epochs are 12 x 3 + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/oidv6-train-annotations-bbox.csv', + data_prefix=dict(img='OpenImages/train/'), + label_file='annotations/class-descriptions-boxable.csv', + hierarchy_file='annotations/bbox_labels_600_hierarchy.json', + meta_file='annotations/train-image-metas.pkl', + pipeline=train_pipeline))) +val_dataloader = dict(batch_size=8, dataset=dict(pipeline=test_pipeline)) +test_dataloader = dict(batch_size=8, dataset=dict(pipeline=test_pipeline)) + +# optimizer +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.04, momentum=0.9, weight_decay=5e-4)) +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=0.001, + by_epoch=False, + begin=0, + end=20000), + dict( + type='MultiStepLR', + begin=0, + end=12, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (32 GPUs) x (8 samples per GPU) +auto_scale_lr = dict(base_batch_size=256) diff --git a/mmdetection/configs/paa/README.md b/mmdetection/configs/paa/README.md new file mode 100644 index 00000000..625aacf2 --- /dev/null +++ b/mmdetection/configs/paa/README.md @@ -0,0 +1,47 @@ +# PAA + +> [Probabilistic Anchor Assignment with IoU Prediction for Object Detection](https://arxiv.org/abs/2007.08103) + + + +## Abstract + +In object detection, determining which anchors to assign as positive or negative samples, known as anchor assignment, has been revealed as a core procedure that can significantly affect a model's performance. In this paper we propose a novel anchor assignment strategy that adaptively separates anchors into positive and negative samples for a ground truth bounding box according to the model's learning status such that it is able to reason about the separation in a probabilistic manner. To do so we first calculate the scores of anchors conditioned on the model and fit a probability distribution to these scores. The model is then trained with anchors separated into positive and negative samples according to their probabilities. Moreover, we investigate the gap between the training and testing objectives and propose to predict the Intersection-over-Unions of detected boxes as a measure of localization quality to reduce the discrepancy. The combined score of classification and localization qualities serving as a box selection metric in non-maximum suppression well aligns with the proposed anchor assignment strategy and leads significant performance improvements. The proposed methods only add a single convolutional layer to RetinaNet baseline and does not require multiple anchors per location, so are efficient. Experimental results verify the effectiveness of the proposed methods. Especially, our models set new records for single-stage detectors on MS COCO test-dev dataset with various backbones. + +
    + +
    + +## Results and Models + +We provide config files to reproduce the object detection results in the +ECCV 2020 paper for Probabilistic Anchor Assignment with IoU +Prediction for Object Detection. + +| Backbone | Lr schd | Mem (GB) | Score voting | box AP | Config | Download | +| :-------: | :-----: | :------: | :----------: | :----: | :------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | 12e | 3.7 | True | 40.4 | [config](./paa_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r50_fpn_1x_coco/paa_r50_fpn_1x_coco_20200821-936edec3.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r50_fpn_1x_coco/paa_r50_fpn_1x_coco_20200821-936edec3.log.json) | +| R-50-FPN | 12e | 3.7 | False | 40.2 | - | | +| R-50-FPN | 18e | 3.7 | True | 41.4 | [config](./paa_r50_fpn_1.5x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r50_fpn_1.5x_coco/paa_r50_fpn_1.5x_coco_20200823-805d6078.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r50_fpn_1.5x_coco/paa_r50_fpn_1.5x_coco_20200823-805d6078.log.json) | +| R-50-FPN | 18e | 3.7 | False | 41.2 | - | | +| R-50-FPN | 24e | 3.7 | True | 41.6 | [config](./paa_r50_fpn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r50_fpn_2x_coco/paa_r50_fpn_2x_coco_20200821-c98bfc4e.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r50_fpn_2x_coco/paa_r50_fpn_2x_coco_20200821-c98bfc4e.log.json) | +| R-50-FPN | 36e | 3.7 | True | 43.3 | [config](./paa_r50_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r50_fpn_mstrain_3x_coco/paa_r50_fpn_mstrain_3x_coco_20210121_145722-06a6880b.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r50_fpn_mstrain_3x_coco/paa_r50_fpn_mstrain_3x_coco_20210121_145722.log.json) | +| R-101-FPN | 12e | 6.2 | True | 42.6 | [config](./paa_r101_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r101_fpn_1x_coco/paa_r101_fpn_1x_coco_20200821-0a1825a4.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r101_fpn_1x_coco/paa_r101_fpn_1x_coco_20200821-0a1825a4.log.json) | +| R-101-FPN | 12e | 6.2 | False | 42.4 | - | | +| R-101-FPN | 24e | 6.2 | True | 43.5 | [config](./paa_r101_fpn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r101_fpn_2x_coco/paa_r101_fpn_2x_coco_20200821-6829f96b.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r101_fpn_2x_coco/paa_r101_fpn_2x_coco_20200821-6829f96b.log.json) | +| R-101-FPN | 36e | 6.2 | True | 45.1 | [config](./paa_r101_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r101_fpn_mstrain_3x_coco/paa_r101_fpn_mstrain_3x_coco_20210122_084202-83250d22.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r101_fpn_mstrain_3x_coco/paa_r101_fpn_mstrain_3x_coco_20210122_084202.log.json) | + +**Note**: + +1. We find that the performance is unstable with 1x setting and may fluctuate by about 0.2 mAP. We report the best results. + +## Citation + +```latex +@inproceedings{paa-eccv2020, + title={Probabilistic Anchor Assignment with IoU Prediction for Object Detection}, + author={Kim, Kang and Lee, Hee Seok}, + booktitle = {ECCV}, + year={2020} +} +``` diff --git a/mmdetection/configs/paa/metafile.yml b/mmdetection/configs/paa/metafile.yml new file mode 100644 index 00000000..078b9749 --- /dev/null +++ b/mmdetection/configs/paa/metafile.yml @@ -0,0 +1,111 @@ +Collections: + - Name: PAA + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - FPN + - Probabilistic Anchor Assignment + - ResNet + Paper: + URL: https://arxiv.org/abs/2007.08103 + Title: 'Probabilistic Anchor Assignment with IoU Prediction for Object Detection' + README: configs/paa/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.4.0/mmdet/models/detectors/paa.py#L6 + Version: v2.4.0 + +Models: + - Name: paa_r50_fpn_1x_coco + In Collection: PAA + Config: configs/paa/paa_r50_fpn_1x_coco.py + Metadata: + Training Memory (GB): 3.7 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r50_fpn_1x_coco/paa_r50_fpn_1x_coco_20200821-936edec3.pth + + - Name: paa_r50_fpn_1.5x_coco + In Collection: PAA + Config: configs/paa/paa_r50_fpn_1.5x_coco.py + Metadata: + Training Memory (GB): 3.7 + Epochs: 18 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r50_fpn_1.5x_coco/paa_r50_fpn_1.5x_coco_20200823-805d6078.pth + + - Name: paa_r50_fpn_2x_coco + In Collection: PAA + Config: configs/paa/paa_r50_fpn_2x_coco.py + Metadata: + Training Memory (GB): 3.7 + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r50_fpn_2x_coco/paa_r50_fpn_2x_coco_20200821-c98bfc4e.pth + + - Name: paa_r50_fpn_mstrain_3x_coco + In Collection: PAA + Config: configs/paa/paa_r50_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 3.7 + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r50_fpn_mstrain_3x_coco/paa_r50_fpn_mstrain_3x_coco_20210121_145722-06a6880b.pth + + - Name: paa_r101_fpn_1x_coco + In Collection: PAA + Config: configs/paa/paa_r101_fpn_1x_coco.py + Metadata: + Training Memory (GB): 6.2 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r101_fpn_1x_coco/paa_r101_fpn_1x_coco_20200821-0a1825a4.pth + + - Name: paa_r101_fpn_2x_coco + In Collection: PAA + Config: configs/paa/paa_r101_fpn_2x_coco.py + Metadata: + Training Memory (GB): 6.2 + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r101_fpn_2x_coco/paa_r101_fpn_2x_coco_20200821-6829f96b.pth + + - Name: paa_r101_fpn_mstrain_3x_coco + In Collection: PAA + Config: configs/paa/paa_r101_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 6.2 + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/paa/paa_r101_fpn_mstrain_3x_coco/paa_r101_fpn_mstrain_3x_coco_20210122_084202-83250d22.pth diff --git a/mmdetection/configs/paa/paa_r101_fpn_1x_coco.py b/mmdetection/configs/paa/paa_r101_fpn_1x_coco.py new file mode 100644 index 00000000..94f1c278 --- /dev/null +++ b/mmdetection/configs/paa/paa_r101_fpn_1x_coco.py @@ -0,0 +1,6 @@ +_base_ = './paa_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/paa/paa_r101_fpn_2x_coco.py b/mmdetection/configs/paa/paa_r101_fpn_2x_coco.py new file mode 100644 index 00000000..c6136f3b --- /dev/null +++ b/mmdetection/configs/paa/paa_r101_fpn_2x_coco.py @@ -0,0 +1,18 @@ +_base_ = './paa_r101_fpn_1x_coco.py' +max_epochs = 24 + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] + +# training schedule for 2x +train_cfg = dict(max_epochs=max_epochs) diff --git a/mmdetection/configs/paa/paa_r101_fpn_ms-3x_coco.py b/mmdetection/configs/paa/paa_r101_fpn_ms-3x_coco.py new file mode 100644 index 00000000..8529dcdb --- /dev/null +++ b/mmdetection/configs/paa/paa_r101_fpn_ms-3x_coco.py @@ -0,0 +1,6 @@ +_base_ = './paa_r50_fpn_ms-3x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/paa/paa_r50_fpn_1.5x_coco.py b/mmdetection/configs/paa/paa_r50_fpn_1.5x_coco.py new file mode 100644 index 00000000..ae993b5c --- /dev/null +++ b/mmdetection/configs/paa/paa_r50_fpn_1.5x_coco.py @@ -0,0 +1,18 @@ +_base_ = './paa_r50_fpn_1x_coco.py' +max_epochs = 18 + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[12, 16], + gamma=0.1) +] + +# training schedule for 1.5x +train_cfg = dict(max_epochs=max_epochs) diff --git a/mmdetection/configs/paa/paa_r50_fpn_1x_coco.py b/mmdetection/configs/paa/paa_r50_fpn_1x_coco.py new file mode 100644 index 00000000..f806a3ea --- /dev/null +++ b/mmdetection/configs/paa/paa_r50_fpn_1x_coco.py @@ -0,0 +1,80 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +# model settings +model = dict( + type='PAA', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_output', + num_outs=5), + bbox_head=dict( + type='PAAHead', + reg_decoded_bbox=True, + score_voting=True, + topk=9, + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + octave_base_scale=8, + scales_per_octave=1, + strides=[8, 16, 32, 64, 128]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=1.3), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.5)), + # training and testing settings + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.1, + neg_iou_thr=0.1, + min_pos_iou=0, + ignore_iof_thr=-1), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) diff --git a/mmdetection/configs/paa/paa_r50_fpn_2x_coco.py b/mmdetection/configs/paa/paa_r50_fpn_2x_coco.py new file mode 100644 index 00000000..6908e4eb --- /dev/null +++ b/mmdetection/configs/paa/paa_r50_fpn_2x_coco.py @@ -0,0 +1,18 @@ +_base_ = './paa_r50_fpn_1x_coco.py' +max_epochs = 24 + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] + +# training schedule for 2x +train_cfg = dict(max_epochs=max_epochs) diff --git a/mmdetection/configs/paa/paa_r50_fpn_ms-3x_coco.py b/mmdetection/configs/paa/paa_r50_fpn_ms-3x_coco.py new file mode 100644 index 00000000..fed8b90a --- /dev/null +++ b/mmdetection/configs/paa/paa_r50_fpn_ms-3x_coco.py @@ -0,0 +1,29 @@ +_base_ = './paa_r50_fpn_1x_coco.py' +max_epochs = 36 + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[28, 34], + gamma=0.1) +] + +# training schedule for 3x +train_cfg = dict(max_epochs=max_epochs) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomResize', scale=[(1333, 640), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/mmdetection/configs/pafpn/README.md b/mmdetection/configs/pafpn/README.md new file mode 100644 index 00000000..36cd6e9f --- /dev/null +++ b/mmdetection/configs/pafpn/README.md @@ -0,0 +1,34 @@ +# PAFPN + +> [Path Aggregation Network for Instance Segmentation](https://arxiv.org/abs/1803.01534) + + + +## Abstract + +The way that information propagates in neural networks is of great importance. In this paper, we propose Path Aggregation Network (PANet) aiming at boosting information flow in proposal-based instance segmentation framework. Specifically, we enhance the entire feature hierarchy with accurate localization signals in lower layers by bottom-up path augmentation, which shortens the information path between lower layers and topmost feature. We present adaptive feature pooling, which links feature grid and all feature levels to make useful information in each feature level propagate directly to following proposal subnetworks. A complementary branch capturing different views for each proposal is created to further improve mask prediction. These improvements are simple to implement, with subtle extra computational overhead. Our PANet reaches the 1st place in the COCO 2017 Challenge Instance Segmentation task and the 2nd place in Object Detection task without large-batch training. It is also state-of-the-art on MVD and Cityscapes. + +
    + +
    + +## Results and Models + +| Backbone | style | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :------: | :-----: | :-----: | :------: | :------------: | :----: | :-----: | :------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | pytorch | 1x | 4.0 | 17.2 | 37.5 | | [config](./faster-rcnn_r50_pafpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/pafpn/faster_rcnn_r50_pafpn_1x_coco/faster_rcnn_r50_pafpn_1x_coco_bbox_mAP-0.375_20200503_105836-b7b4b9bd.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/pafpn/faster_rcnn_r50_pafpn_1x_coco/faster_rcnn_r50_pafpn_1x_coco_20200503_105836.log.json) | + +## Citation + +```latex +@inproceedings{liu2018path, + author = {Shu Liu and + Lu Qi and + Haifang Qin and + Jianping Shi and + Jiaya Jia}, + title = {Path Aggregation Network for Instance Segmentation}, + booktitle = {Proceedings of IEEE Conference on Computer Vision and Pattern Recognition (CVPR)}, + year = {2018} +} +``` diff --git a/mmdetection/configs/pafpn/faster-rcnn_r50_pafpn_1x_coco.py b/mmdetection/configs/pafpn/faster-rcnn_r50_pafpn_1x_coco.py new file mode 100644 index 00000000..1452baec --- /dev/null +++ b/mmdetection/configs/pafpn/faster-rcnn_r50_pafpn_1x_coco.py @@ -0,0 +1,8 @@ +_base_ = '../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py' + +model = dict( + neck=dict( + type='PAFPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + num_outs=5)) diff --git a/mmdetection/configs/pafpn/metafile.yml b/mmdetection/configs/pafpn/metafile.yml new file mode 100644 index 00000000..7772d276 --- /dev/null +++ b/mmdetection/configs/pafpn/metafile.yml @@ -0,0 +1,38 @@ +Collections: + - Name: PAFPN + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - PAFPN + Paper: + URL: https://arxiv.org/abs/1803.01534 + Title: 'Path Aggregation Network for Instance Segmentation' + README: configs/pafpn/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/necks/pafpn.py#L11 + Version: v2.0.0 + +Models: + - Name: faster-rcnn_r50_pafpn_1x_coco + In Collection: PAFPN + Config: configs/pafpn/faster-rcnn_r50_pafpn_1x_coco.py + Metadata: + Training Memory (GB): 4.0 + inference time (ms/im): + - value: 58.14 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/pafpn/faster_rcnn_r50_pafpn_1x_coco/faster_rcnn_r50_pafpn_1x_coco_bbox_mAP-0.375_20200503_105836-b7b4b9bd.pth diff --git a/mmdetection/configs/panoptic_fpn/README.md b/mmdetection/configs/panoptic_fpn/README.md new file mode 100644 index 00000000..0321fb7c --- /dev/null +++ b/mmdetection/configs/panoptic_fpn/README.md @@ -0,0 +1,62 @@ +# Panoptic FPN + +> [Panoptic feature pyramid networks](https://arxiv.org/abs/1901.02446) + + + +## Abstract + +The recently introduced panoptic segmentation task has renewed our community's interest in unifying the tasks of instance segmentation (for thing classes) and semantic segmentation (for stuff classes). However, current state-of-the-art methods for this joint task use separate and dissimilar networks for instance and semantic segmentation, without performing any shared computation. In this work, we aim to unify these methods at the architectural level, designing a single network for both tasks. Our approach is to endow Mask R-CNN, a popular instance segmentation method, with a semantic segmentation branch using a shared Feature Pyramid Network (FPN) backbone. Surprisingly, this simple baseline not only remains effective for instance segmentation, but also yields a lightweight, top-performing method for semantic segmentation. In this work, we perform a detailed study of this minimally extended version of Mask R-CNN with FPN, which we refer to as Panoptic FPN, and show it is a robust and accurate baseline for both tasks. Given its effectiveness and conceptual simplicity, we hope our method can serve as a strong baseline and aid future research in panoptic segmentation. + +
    + +
    + +## Dataset + +PanopticFPN requires COCO and [COCO-panoptic](http://images.cocodataset.org/annotations/panoptic_annotations_trainval2017.zip) dataset for training and evaluation. You need to download and extract it in the COCO dataset path. +The directory should be like this. + +```none +mmdetection +├── mmdet +├── tools +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ │ ├── panoptic_train2017.json +│ │ │ ├── panoptic_train2017 +│ │ │ ├── panoptic_val2017.json +│ │ │ ├── panoptic_val2017 +│ │ ├── train2017 +│ │ ├── val2017 +│ │ ├── test2017 +``` + +## Results and Models + +| Backbone | style | Lr schd | Mem (GB) | Inf time (fps) | PQ | SQ | RQ | PQ_th | SQ_th | RQ_th | PQ_st | SQ_st | RQ_st | Config | Download | +| :-------: | :-----: | :-----: | :------: | :------------: | :--: | :--: | :--: | :---: | :---: | :---: | :---: | :---: | :---: | :---------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | pytorch | 1x | 4.7 | | 40.2 | 77.8 | 49.3 | 47.8 | 80.9 | 57.5 | 28.9 | 73.1 | 37.0 | [config](./panoptic-fpn_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/panoptic_fpn/panoptic_fpn_r50_fpn_1x_coco/panoptic_fpn_r50_fpn_1x_coco_20210821_101153-9668fd13.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/panoptic_fpn/panoptic_fpn_r50_fpn_1x_coco/panoptic_fpn_r50_fpn_1x_coco_20210821_101153.log.json) | +| R-50-FPN | pytorch | 3x | - | - | 42.5 | 78.1 | 51.7 | 50.3 | 81.5 | 60.3 | 30.7 | 73.0 | 38.8 | [config](./panoptic-fpn_r50_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/panoptic_fpn/panoptic_fpn_r50_fpn_mstrain_3x_coco/panoptic_fpn_r50_fpn_mstrain_3x_coco_20210824_171155-5650f98b.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/panoptic_fpn/panoptic_fpn_r50_fpn_mstrain_3x_coco/panoptic_fpn_r50_fpn_mstrain_3x_coco_20210824_171155.log.json) | +| R-101-FPN | pytorch | 1x | 6.7 | | 42.2 | 78.3 | 51.4 | 50.1 | 81.4 | 59.9 | 30.3 | 73.6 | 38.5 | [config](./panoptic-fpn_r101_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/panoptic_fpn/panoptic_fpn_r101_fpn_1x_coco/panoptic_fpn_r101_fpn_1x_coco_20210820_193950-ab9157a2.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/panoptic_fpn/panoptic_fpn_r101_fpn_1x_coco/panoptic_fpn_r101_fpn_1x_coco_20210820_193950.log.json) | +| R-101-FPN | pytorch | 3x | - | - | 44.1 | 78.9 | 53.6 | 52.1 | 81.7 | 62.3 | 32.0 | 74.6 | 40.3 | [config](./panoptic-fpn_r101_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/panoptic_fpn/panoptic_fpn_r101_fpn_mstrain_3x_coco/panoptic_fpn_r101_fpn_mstrain_3x_coco_20210823_114712-9c99acc4.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/panoptic_fpn/panoptic_fpn_r101_fpn_mstrain_3x_coco/panoptic_fpn_r101_fpn_mstrain_3x_coco_20210823_114712.log.json) | + +## Citation + +The base method for panoptic segmentation task. + +```latex +@inproceedings{kirillov2018panopticfpn, + author = { + Alexander Kirillov, + Ross Girshick, + Kaiming He, + Piotr Dollar, + }, + title = {Panoptic Feature Pyramid Networks}, + booktitle = {Proceedings of IEEE Conference on Computer Vision and Pattern Recognition (CVPR)}, + year = {2019} +} +``` diff --git a/mmdetection/configs/panoptic_fpn/metafile.yml b/mmdetection/configs/panoptic_fpn/metafile.yml new file mode 100644 index 00000000..c99275ec --- /dev/null +++ b/mmdetection/configs/panoptic_fpn/metafile.yml @@ -0,0 +1,70 @@ +Collections: + - Name: PanopticFPN + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - PanopticFPN + Paper: + URL: https://arxiv.org/pdf/1901.02446 + Title: 'Panoptic feature pyramid networks' + README: configs/panoptic_fpn/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.16.0/mmdet/models/detectors/panoptic_fpn.py#L7 + Version: v2.16.0 + +Models: + - Name: panoptic_fpn_r50_fpn_1x_coco + In Collection: PanopticFPN + Config: configs/panoptic_fpn/panoptic-fpn_r50_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.6 + Epochs: 12 + Results: + - Task: Panoptic Segmentation + Dataset: COCO + Metrics: + PQ: 40.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/panoptic_fpn/panoptic_fpn_r50_fpn_1x_coco/panoptic_fpn_r50_fpn_1x_coco_20210821_101153-9668fd13.pth + + - Name: panoptic_fpn_r50_fpn_mstrain_3x_coco + In Collection: PanopticFPN + Config: configs/panoptic_fpn/panoptic-fpn_r50_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 4.6 + Epochs: 36 + Results: + - Task: Panoptic Segmentation + Dataset: COCO + Metrics: + PQ: 42.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/panoptic_fpn/panoptic_fpn_r50_fpn_mstrain_3x_coco/panoptic_fpn_r50_fpn_mstrain_3x_coco_20210824_171155-5650f98b.pth + + - Name: panoptic_fpn_r101_fpn_1x_coco + In Collection: PanopticFPN + Config: configs/panoptic_fpn/panoptic-fpn_r101_fpn_1x_coco.py + Metadata: + Training Memory (GB): 6.5 + Epochs: 12 + Results: + - Task: Panoptic Segmentation + Dataset: COCO + Metrics: + PQ: 42.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/panoptic_fpn/panoptic_fpn_r101_fpn_1x_coco/panoptic_fpn_r101_fpn_1x_coco_20210820_193950-ab9157a2.pth + + - Name: panoptic_fpn_r101_fpn_mstrain_3x_coco + In Collection: PanopticFPN + Config: configs/panoptic_fpn/panoptic-fpn_r101_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 6.5 + Epochs: 36 + Results: + - Task: Panoptic Segmentation + Dataset: COCO + Metrics: + PQ: 44.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/panoptic_fpn/panoptic_fpn_r101_fpn_mstrain_3x_coco/panoptic_fpn_r101_fpn_mstrain_3x_coco_20210823_114712-9c99acc4.pth diff --git a/mmdetection/configs/panoptic_fpn/panoptic-fpn_r101_fpn_1x_coco.py b/mmdetection/configs/panoptic_fpn/panoptic-fpn_r101_fpn_1x_coco.py new file mode 100644 index 00000000..b960254e --- /dev/null +++ b/mmdetection/configs/panoptic_fpn/panoptic-fpn_r101_fpn_1x_coco.py @@ -0,0 +1,6 @@ +_base_ = './panoptic-fpn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/panoptic_fpn/panoptic-fpn_r101_fpn_ms-3x_coco.py b/mmdetection/configs/panoptic_fpn/panoptic-fpn_r101_fpn_ms-3x_coco.py new file mode 100644 index 00000000..268782ee --- /dev/null +++ b/mmdetection/configs/panoptic_fpn/panoptic-fpn_r101_fpn_ms-3x_coco.py @@ -0,0 +1,6 @@ +_base_ = './panoptic-fpn_r50_fpn_ms-3x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/panoptic_fpn/panoptic-fpn_r50_fpn_1x_coco.py b/mmdetection/configs/panoptic_fpn/panoptic-fpn_r50_fpn_1x_coco.py new file mode 100644 index 00000000..c2c89ef5 --- /dev/null +++ b/mmdetection/configs/panoptic_fpn/panoptic-fpn_r50_fpn_1x_coco.py @@ -0,0 +1,45 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_panoptic.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +model = dict( + type='PanopticFPN', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32, + pad_mask=True, + mask_pad_value=0, + pad_seg=True, + seg_pad_value=255), + semantic_head=dict( + type='PanopticFPNHead', + num_things_classes=80, + num_stuff_classes=53, + in_channels=256, + inner_channels=128, + start_level=0, + end_level=4, + norm_cfg=dict(type='GN', num_groups=32, requires_grad=True), + conv_cfg=None, + loss_seg=dict( + type='CrossEntropyLoss', ignore_index=255, loss_weight=0.5)), + panoptic_fusion_head=dict( + type='HeuristicFusionHead', + num_things_classes=80, + num_stuff_classes=53), + test_cfg=dict( + rcnn=dict( + score_thr=0.6, + nms=dict(type='nms', iou_threshold=0.5, class_agnostic=True), + max_per_img=100, + mask_thr_binary=0.5), + # used in HeuristicFusionHead + panoptic=dict(mask_overlap=0.5, stuff_area_limit=4096))) + +# Forced to remove NumClassCheckHook +custom_hooks = [] diff --git a/mmdetection/configs/panoptic_fpn/panoptic-fpn_r50_fpn_ms-3x_coco.py b/mmdetection/configs/panoptic_fpn/panoptic-fpn_r50_fpn_ms-3x_coco.py new file mode 100644 index 00000000..b18a8f8d --- /dev/null +++ b/mmdetection/configs/panoptic_fpn/panoptic-fpn_r50_fpn_ms-3x_coco.py @@ -0,0 +1,35 @@ +_base_ = './panoptic-fpn_r50_fpn_1x_coco.py' + +# In mstrain 3x config, img_scale=[(1333, 640), (1333, 800)], +# multiscale_mode='range' +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict( + type='LoadPanopticAnnotations', + with_bbox=True, + with_mask=True, + with_seg=True), + dict( + type='RandomResize', scale=[(1333, 640), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +# TODO: Use RepeatDataset to speed up training +# training schedule for 3x +train_cfg = dict(max_epochs=36, val_interval=3) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=36, + by_epoch=True, + milestones=[24, 33], + gamma=0.1) +] diff --git a/mmdetection/configs/pascal_voc/README.md b/mmdetection/configs/pascal_voc/README.md new file mode 100644 index 00000000..2ead3add --- /dev/null +++ b/mmdetection/configs/pascal_voc/README.md @@ -0,0 +1,40 @@ +# Pascal VOC + +> [The Pascal Visual Object Classes (VOC) Challenge](https://link.springer.com/article/10.1007/s11263-009-0275-4) + + + +## Abstract + +The Pascal Visual Object Classes (VOC) challenge is a benchmark in visual object category recognition and detection, providing the vision and machine learning communities with a standard dataset of images and annotation, and standard evaluation procedures. Organised annually from 2005 to present, the challenge and its associated dataset has become accepted as the benchmark for object detection. + +This paper describes the dataset and evaluation procedure. We review the state-of-the-art in evaluated methods for both classification and detection, analyse whether the methods are statistically different, what they are learning from the images (e.g. the object or its context), and what the methods find easy or confuse. The paper concludes with lessons learnt in the three year history of the challenge, and proposes directions for future improvement and extension. + +
    + +
    + +## Results and Models + +| Architecture | Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :-------------: | :------: | :-----: | :-----: | :------: | :------------: | :----: | :----------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| Faster R-CNN C4 | R-50 | caffe | 18k | | - | 80.9 | [config](./faster-rcnn_r50-caffe-c4_ms-18k_voc0712.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/pascal_voc/faster_rcnn_r50_caffe_c4_mstrain_18k_voc0712//home/dong/code_sensetime/2022Q1/mmdetection/work_dirs/prepare_voc/gather/pascal_voc/faster_rcnn_r50_caffe_c4_mstrain_18k_voc0712/faster_rcnn_r50_caffe_c4_mstrain_18k_voc0712_20220314_234327-847a14d2.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/pascal_voc/faster_rcnn_r50_caffe_c4_mstrain_18k_voc0712/faster_rcnn_r50_caffe_c4_mstrain_18k_voc0712_20220314_234327.log.json) | +| Faster R-CNN | R-50 | pytorch | 1x | 2.6 | - | 80.4 | [config](./faster-rcnn_r50_fpn_1x_voc0712.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/pascal_voc/faster_rcnn_r50_fpn_1x_voc0712/faster_rcnn_r50_fpn_1x_voc0712_20220320_192712-54bef0f3.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/pascal_voc/faster_rcnn_r50_fpn_1x_voc0712/faster_rcnn_r50_fpn_1x_voc0712_20220320_192712.log.json) | +| Retinanet | R-50 | pytorch | 1x | 2.1 | - | 77.3 | [config](./retinanet_r50_fpn_1x_voc0712.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/pascal_voc/retinanet_r50_fpn_1x_voc0712/retinanet_r50_fpn_1x_voc0712_20200617-47cbdd0e.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/pascal_voc/retinanet_r50_fpn_1x_voc0712/retinanet_r50_fpn_1x_voc0712_20200616_014642.log.json) | +| SSD300 | VGG16 | - | 120e | - | - | 76.5 | [config](./ssd300_voc0712.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/pascal_voc/ssd300_voc0712/ssd300_voc0712_20220320_194658-17edda1b.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/pascal_voc/ssd300_voc0712/ssd300_voc0712_20220320_194658.log.json) | +| SSD512 | VGG16 | - | 120e | - | - | 79.5 | [config](./ssd512_voc0712.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/pascal_voc/ssd512_voc0712/ssd512_voc0712_20220320_194717-03cefefe.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/pascal_voc/ssd512_voc0712/ssd512_voc0712_20220320_194717.log.json) | + +## Citation + +```latex +@Article{Everingham10, + author = "Everingham, M. and Van~Gool, L. and Williams, C. K. I. and Winn, J. and Zisserman, A.", + title = "The Pascal Visual Object Classes (VOC) Challenge", + journal = "International Journal of Computer Vision", + volume = "88", + year = "2010", + number = "2", + month = jun, + pages = "303--338", +} +``` diff --git a/mmdetection/configs/pascal_voc/faster-rcnn_r50-caffe-c4_ms-18k_voc0712.py b/mmdetection/configs/pascal_voc/faster-rcnn_r50-caffe-c4_ms-18k_voc0712.py new file mode 100644 index 00000000..dddc0bbd --- /dev/null +++ b/mmdetection/configs/pascal_voc/faster-rcnn_r50-caffe-c4_ms-18k_voc0712.py @@ -0,0 +1,86 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50-caffe-c4.py', + '../_base_/schedules/schedule_1x.py', '../_base_/datasets/voc0712.py', + '../_base_/default_runtime.py' +] +model = dict(roi_head=dict(bbox_head=dict(num_classes=20))) + +# dataset settings +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomChoiceResize', + scales=[(1333, 480), (1333, 512), (1333, 544), (1333, 576), + (1333, 608), (1333, 640), (1333, 672), (1333, 704), + (1333, 736), (1333, 768), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + # avoid bboxes being resized + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict( + sampler=dict(type='InfiniteSampler', shuffle=True), + dataset=dict( + _delete_=True, + type='ConcatDataset', + datasets=[ + dict( + type='VOCDataset', + data_root={{_base_.data_root}}, + ann_file='VOC2007/ImageSets/Main/trainval.txt', + data_prefix=dict(sub_data_root='VOC2007/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args={{_base_.backend_args}}), + dict( + type='VOCDataset', + data_root={{_base_.data_root}}, + ann_file='VOC2012/ImageSets/Main/trainval.txt', + data_prefix=dict(sub_data_root='VOC2012/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args={{_base_.backend_args}}) + ])) + +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader + +# training schedule for 18k +max_iter = 18000 +train_cfg = dict( + _delete_=True, + type='IterBasedTrainLoop', + max_iters=max_iter, + val_interval=3000) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=100), + dict( + type='MultiStepLR', + begin=0, + end=max_iter, + by_epoch=False, + milestones=[12000, 16000], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)) + +default_hooks = dict(checkpoint=dict(by_epoch=False, interval=3000)) +log_processor = dict(by_epoch=False) diff --git a/mmdetection/configs/pascal_voc/faster-rcnn_r50_fpn_1x_voc0712-cocofmt.py b/mmdetection/configs/pascal_voc/faster-rcnn_r50_fpn_1x_voc0712-cocofmt.py new file mode 100644 index 00000000..0b0aa41d --- /dev/null +++ b/mmdetection/configs/pascal_voc/faster-rcnn_r50_fpn_1x_voc0712-cocofmt.py @@ -0,0 +1,100 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', '../_base_/datasets/voc0712.py', + '../_base_/default_runtime.py' +] +model = dict(roi_head=dict(bbox_head=dict(num_classes=20))) + +METAINFO = { + 'classes': + ('aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', + 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person', + 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor'), + # palette is a list of color tuples, which is used for visualization. + 'palette': [(106, 0, 228), (119, 11, 32), (165, 42, 42), (0, 0, 192), + (197, 226, 255), (0, 60, 100), (0, 0, 142), (255, 77, 255), + (153, 69, 1), (120, 166, 157), (0, 182, 199), (0, 226, 252), + (182, 182, 255), (0, 0, 230), (220, 20, 60), (163, 255, 0), + (0, 82, 0), (3, 95, 161), (0, 80, 100), (183, 130, 88)] +} + +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/VOCdevkit/' + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='Resize', scale=(1000, 600), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=(1000, 600), keep_ratio=True), + # avoid bboxes being resized + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict( + dataset=dict( + type='RepeatDataset', + times=3, + dataset=dict( + _delete_=True, + type=dataset_type, + data_root=data_root, + ann_file='annotations/voc0712_trainval.json', + data_prefix=dict(img=''), + metainfo=METAINFO, + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args={{_base_.backend_args}}))) +val_dataloader = dict( + dataset=dict( + type=dataset_type, + ann_file='annotations/voc07_test.json', + data_prefix=dict(img=''), + metainfo=METAINFO, + pipeline=test_pipeline)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'annotations/voc07_test.json', + metric='bbox', + format_only=False, + backend_args={{_base_.backend_args}}) +test_evaluator = val_evaluator + +# training schedule, the dataset is repeated 3 times, so the +# actual epoch = 4 * 3 = 12 +max_epochs = 4 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# learning rate +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[3], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) + +# Default setting for scaling LR automatically +# - `enable` means enable scaling LR automatically +# or not by default. +# - `base_batch_size` = (8 GPUs) x (2 samples per GPU). +auto_scale_lr = dict(enable=False, base_batch_size=16) diff --git a/mmdetection/configs/pascal_voc/faster-rcnn_r50_fpn_1x_voc0712.py b/mmdetection/configs/pascal_voc/faster-rcnn_r50_fpn_1x_voc0712.py new file mode 100644 index 00000000..07391667 --- /dev/null +++ b/mmdetection/configs/pascal_voc/faster-rcnn_r50_fpn_1x_voc0712.py @@ -0,0 +1,35 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', '../_base_/datasets/voc0712.py', + '../_base_/default_runtime.py' +] +model = dict(roi_head=dict(bbox_head=dict(num_classes=20))) + +# training schedule, voc dataset is repeated 3 times, in +# `_base_/datasets/voc0712.py`, so the actual epoch = 4 * 3 = 12 +max_epochs = 4 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# learning rate +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[3], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) + +# Default setting for scaling LR automatically +# - `enable` means enable scaling LR automatically +# or not by default. +# - `base_batch_size` = (8 GPUs) x (2 samples per GPU). +auto_scale_lr = dict(enable=False, base_batch_size=16) diff --git a/mmdetection/configs/pascal_voc/retinanet_r50_fpn_1x_voc0712.py b/mmdetection/configs/pascal_voc/retinanet_r50_fpn_1x_voc0712.py new file mode 100644 index 00000000..c86a6f19 --- /dev/null +++ b/mmdetection/configs/pascal_voc/retinanet_r50_fpn_1x_voc0712.py @@ -0,0 +1,34 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', '../_base_/datasets/voc0712.py', + '../_base_/default_runtime.py' +] +model = dict(bbox_head=dict(num_classes=20)) + +# training schedule, voc dataset is repeated 3 times, in +# `_base_/datasets/voc0712.py`, so the actual epoch = 4 * 3 = 12 +max_epochs = 4 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# learning rate +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[3], + gamma=0.1) +] +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) + +# Default setting for scaling LR automatically +# - `enable` means enable scaling LR automatically +# or not by default. +# - `base_batch_size` = (8 GPUs) x (2 samples per GPU). +auto_scale_lr = dict(enable=False, base_batch_size=16) diff --git a/mmdetection/configs/pascal_voc/ssd300_voc0712.py b/mmdetection/configs/pascal_voc/ssd300_voc0712.py new file mode 100644 index 00000000..ff7a1368 --- /dev/null +++ b/mmdetection/configs/pascal_voc/ssd300_voc0712.py @@ -0,0 +1,102 @@ +_base_ = [ + '../_base_/models/ssd300.py', '../_base_/datasets/voc0712.py', + '../_base_/schedules/schedule_2x.py', '../_base_/default_runtime.py' +] +model = dict( + bbox_head=dict( + num_classes=20, anchor_generator=dict(basesize_ratio_range=(0.2, + 0.9)))) +# dataset settings +dataset_type = 'VOCDataset' +data_root = 'data/VOCdevkit/' +input_size = 300 +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='Expand', + mean={{_base_.model.data_preprocessor.mean}}, + to_rgb={{_base_.model.data_preprocessor.bgr_to_rgb}}, + ratio_range=(1, 4)), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.3), + dict(type='Resize', scale=(input_size, input_size), keep_ratio=False), + dict(type='RandomFlip', prob=0.5), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='Resize', scale=(input_size, input_size), keep_ratio=False), + # avoid bboxes being resized + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict( + batch_size=8, + num_workers=3, + dataset=dict( # RepeatDataset + # the dataset is repeated 10 times, and the training schedule is 2x, + # so the actual epoch = 12 * 10 = 120. + times=10, + dataset=dict( # ConcatDataset + # VOCDataset will add different `dataset_type` in dataset.metainfo, + # which will get error if using ConcatDataset. Adding + # `ignore_keys` can avoid this error. + ignore_keys=['dataset_type'], + datasets=[ + dict( + type=dataset_type, + data_root=data_root, + ann_file='VOC2007/ImageSets/Main/trainval.txt', + data_prefix=dict(sub_data_root='VOC2007/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline), + dict( + type=dataset_type, + data_root=data_root, + ann_file='VOC2012/ImageSets/Main/trainval.txt', + data_prefix=dict(sub_data_root='VOC2012/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline) + ]))) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader + +custom_hooks = [ + dict(type='NumClassCheckHook'), + dict(type='CheckInvalidLossHook', interval=50, priority='VERY_LOW') +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=1e-3, momentum=0.9, weight_decay=5e-4)) + +# learning policy +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=24, + by_epoch=True, + milestones=[16, 20], + gamma=0.1) +] + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (8 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/pascal_voc/ssd512_voc0712.py b/mmdetection/configs/pascal_voc/ssd512_voc0712.py new file mode 100644 index 00000000..6c4dc8a3 --- /dev/null +++ b/mmdetection/configs/pascal_voc/ssd512_voc0712.py @@ -0,0 +1,82 @@ +_base_ = 'ssd300_voc0712.py' + +input_size = 512 +model = dict( + neck=dict( + out_channels=(512, 1024, 512, 256, 256, 256, 256), + level_strides=(2, 2, 2, 2, 1), + level_paddings=(1, 1, 1, 1, 1), + last_kernel_size=4), + bbox_head=dict( + in_channels=(512, 1024, 512, 256, 256, 256, 256), + anchor_generator=dict( + input_size=input_size, + strides=[8, 16, 32, 64, 128, 256, 512], + basesize_ratio_range=(0.15, 0.9), + ratios=([2], [2, 3], [2, 3], [2, 3], [2, 3], [2], [2])))) + +# dataset settings +dataset_type = 'VOCDataset' +data_root = 'data/VOCdevkit/' +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='Expand', + mean={{_base_.model.data_preprocessor.mean}}, + to_rgb={{_base_.model.data_preprocessor.bgr_to_rgb}}, + ratio_range=(1, 4)), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.3), + dict(type='Resize', scale=(input_size, input_size), keep_ratio=False), + dict(type='RandomFlip', prob=0.5), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='Resize', scale=(input_size, input_size), keep_ratio=False), + # avoid bboxes being resized + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict( + batch_size=8, + num_workers=3, + dataset=dict( # RepeatDataset + # the dataset is repeated 10 times, and the training schedule is 2x, + # so the actual epoch = 12 * 10 = 120. + times=10, + dataset=dict( # ConcatDataset + # VOCDataset will add different `dataset_type` in dataset.metainfo, + # which will get error if using ConcatDataset. Adding + # `ignore_keys` can avoid this error. + ignore_keys=['dataset_type'], + datasets=[ + dict( + type=dataset_type, + data_root=data_root, + ann_file='VOC2007/ImageSets/Main/trainval.txt', + data_prefix=dict(sub_data_root='VOC2007/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline), + dict( + type=dataset_type, + data_root=data_root, + ann_file='VOC2012/ImageSets/Main/trainval.txt', + data_prefix=dict(sub_data_root='VOC2012/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline) + ]))) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader diff --git a/mmdetection/configs/pisa/README.md b/mmdetection/configs/pisa/README.md new file mode 100644 index 00000000..39f79ecd --- /dev/null +++ b/mmdetection/configs/pisa/README.md @@ -0,0 +1,50 @@ +# PISA + +> [Prime Sample Attention in Object Detection](https://arxiv.org/abs/1904.04821) + + + +## Abstract + +It is a common paradigm in object detection frameworks to treat all samples equally and target at maximizing the performance on average. In this work, we revisit this paradigm through a careful study on how different samples contribute to the overall performance measured in terms of mAP. Our study suggests that the samples in each mini-batch are neither independent nor equally important, and therefore a better classifier on average does not necessarily mean higher mAP. Motivated by this study, we propose the notion of Prime Samples, those that play a key role in driving the detection performance. We further develop a simple yet effective sampling and learning strategy called PrIme Sample Attention (PISA) that directs the focus of the training process towards such samples. Our experiments demonstrate that it is often more effective to focus on prime samples than hard samples when training a detector. Particularly, On the MSCOCO dataset, PISA outperforms the random sampling baseline and hard mining schemes, e.g., OHEM and Focal Loss, consistently by around 2% on both single-stage and two-stage detectors, even with a strong backbone ResNeXt-101. + +
    + +
    + +## Results and Models + +| PISA | Network | Backbone | Lr schd | box AP | mask AP | Config | Download | +| :--: | :----------: | :------------: | :-----: | :----: | :-----: | :----------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| × | Faster R-CNN | R-50-FPN | 1x | 36.4 | | - | | +| √ | Faster R-CNN | R-50-FPN | 1x | 38.4 | | [config](./faster-rcnn_r50_fpn_pisa_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/pisa/pisa_faster_rcnn_r50_fpn_1x_coco/pisa_faster_rcnn_r50_fpn_1x_coco-dea93523.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/pisa/pisa_faster_rcnn_r50_fpn_1x_coco/pisa_faster_rcnn_r50_fpn_1x_coco_20200506_185619.log.json) | +| × | Faster R-CNN | X101-32x4d-FPN | 1x | 40.1 | | - | | +| √ | Faster R-CNN | X101-32x4d-FPN | 1x | 41.9 | | [config](./faster-rcnn_x101-32x4d_fpn_pisa_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/pisa/pisa_faster_rcnn_x101_32x4d_fpn_1x_coco/pisa_faster_rcnn_x101_32x4d_fpn_1x_coco-e4accec4.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/pisa/pisa_faster_rcnn_x101_32x4d_fpn_1x_coco/pisa_faster_rcnn_x101_32x4d_fpn_1x_coco_20200505_181503.log.json) | +| × | Mask R-CNN | R-50-FPN | 1x | 37.3 | 34.2 | - | | +| √ | Mask R-CNN | R-50-FPN | 1x | 39.1 | 35.2 | [config](./mask-rcnn_r50_fpn_pisa_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/pisa/pisa_mask_rcnn_r50_fpn_1x_coco/pisa_mask_rcnn_r50_fpn_1x_coco-dfcedba6.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/pisa/pisa_mask_rcnn_r50_fpn_1x_coco/pisa_mask_rcnn_r50_fpn_1x_coco_20200508_150500.log.json) | +| × | Mask R-CNN | X101-32x4d-FPN | 1x | 41.1 | 37.1 | - | | +| √ | Mask R-CNN | X101-32x4d-FPN | 1x | | | | | +| × | RetinaNet | R-50-FPN | 1x | 35.6 | | - | | +| √ | RetinaNet | R-50-FPN | 1x | 36.9 | | [config](./retinanet-r50_fpn_pisa_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/pisa/pisa_retinanet_r50_fpn_1x_coco/pisa_retinanet_r50_fpn_1x_coco-76409952.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/pisa/pisa_retinanet_r50_fpn_1x_coco/pisa_retinanet_r50_fpn_1x_coco_20200504_014311.log.json) | +| × | RetinaNet | X101-32x4d-FPN | 1x | 39.0 | | - | | +| √ | RetinaNet | X101-32x4d-FPN | 1x | 40.7 | | [config](./retinanet_x101-32x4d_fpn_pisa_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/pisa/pisa_retinanet_x101_32x4d_fpn_1x_coco/pisa_retinanet_x101_32x4d_fpn_1x_coco-a0c13c73.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/pisa/pisa_retinanet_x101_32x4d_fpn_1x_coco/pisa_retinanet_x101_32x4d_fpn_1x_coco_20200505_001404.log.json) | +| × | SSD300 | VGG16 | 1x | 25.6 | | - | | +| √ | SSD300 | VGG16 | 1x | 27.6 | | [config](./ssd300_pisa_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/pisa/pisa_ssd300_coco/pisa_ssd300_coco-710e3ac9.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/pisa/pisa_ssd300_coco/pisa_ssd300_coco_20200504_144325.log.json) | +| × | SSD512 | VGG16 | 1x | 29.3 | | - | | +| √ | SSD512 | VGG16 | 1x | 31.8 | | [config](./ssd512_pisa_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/pisa/pisa_ssd512_coco/pisa_ssd512_coco-247addee.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/pisa/pisa_ssd512_coco/pisa_ssd512_coco_20200508_131030.log.json) | + +**Notes:** + +- In the original paper, all models are trained and tested on mmdet v1.x, thus results may not be exactly the same with this release on v2.0. +- It is noted PISA only modifies the training pipeline so the inference time remains the same with the baseline. + +## Citation + +```latex +@inproceedings{cao2019prime, + title={Prime sample attention in object detection}, + author={Cao, Yuhang and Chen, Kai and Loy, Chen Change and Lin, Dahua}, + booktitle={IEEE Conference on Computer Vision and Pattern Recognition}, + year={2020} +} +``` diff --git a/mmdetection/configs/pisa/faster-rcnn_r50_fpn_pisa_1x_coco.py b/mmdetection/configs/pisa/faster-rcnn_r50_fpn_pisa_1x_coco.py new file mode 100644 index 00000000..237a3b13 --- /dev/null +++ b/mmdetection/configs/pisa/faster-rcnn_r50_fpn_pisa_1x_coco.py @@ -0,0 +1,30 @@ +_base_ = '../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py' + +model = dict( + roi_head=dict( + type='PISARoIHead', + bbox_head=dict( + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0))), + train_cfg=dict( + rpn_proposal=dict( + nms_pre=2000, + max_per_img=2000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=dict( + sampler=dict( + type='ScoreHLRSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True, + k=0.5, + bias=0.), + isr=dict(k=2, bias=0), + carl=dict(k=1, bias=0.2))), + test_cfg=dict( + rpn=dict( + nms_pre=2000, + max_per_img=2000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0))) diff --git a/mmdetection/configs/pisa/faster-rcnn_x101-32x4d_fpn_pisa_1x_coco.py b/mmdetection/configs/pisa/faster-rcnn_x101-32x4d_fpn_pisa_1x_coco.py new file mode 100644 index 00000000..4b2c8d9a --- /dev/null +++ b/mmdetection/configs/pisa/faster-rcnn_x101-32x4d_fpn_pisa_1x_coco.py @@ -0,0 +1,30 @@ +_base_ = '../faster_rcnn/faster-rcnn_x101-32x4d_fpn_1x_coco.py' + +model = dict( + roi_head=dict( + type='PISARoIHead', + bbox_head=dict( + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0))), + train_cfg=dict( + rpn_proposal=dict( + nms_pre=2000, + max_per_img=2000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=dict( + sampler=dict( + type='ScoreHLRSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True, + k=0.5, + bias=0.), + isr=dict(k=2, bias=0), + carl=dict(k=1, bias=0.2))), + test_cfg=dict( + rpn=dict( + nms_pre=2000, + max_per_img=2000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0))) diff --git a/mmdetection/configs/pisa/mask-rcnn_r50_fpn_pisa_1x_coco.py b/mmdetection/configs/pisa/mask-rcnn_r50_fpn_pisa_1x_coco.py new file mode 100644 index 00000000..d6a68235 --- /dev/null +++ b/mmdetection/configs/pisa/mask-rcnn_r50_fpn_pisa_1x_coco.py @@ -0,0 +1,30 @@ +_base_ = '../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py' + +model = dict( + roi_head=dict( + type='PISARoIHead', + bbox_head=dict( + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0))), + train_cfg=dict( + rpn_proposal=dict( + nms_pre=2000, + max_per_img=2000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=dict( + sampler=dict( + type='ScoreHLRSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True, + k=0.5, + bias=0.), + isr=dict(k=2, bias=0), + carl=dict(k=1, bias=0.2))), + test_cfg=dict( + rpn=dict( + nms_pre=2000, + max_per_img=2000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0))) diff --git a/mmdetection/configs/pisa/mask-rcnn_x101-32x4d_fpn_pisa_1x_coco.py b/mmdetection/configs/pisa/mask-rcnn_x101-32x4d_fpn_pisa_1x_coco.py new file mode 100644 index 00000000..f2ac19fe --- /dev/null +++ b/mmdetection/configs/pisa/mask-rcnn_x101-32x4d_fpn_pisa_1x_coco.py @@ -0,0 +1,30 @@ +_base_ = '../mask_rcnn/mask-rcnn_x101-32x4d_fpn_1x_coco.py' + +model = dict( + roi_head=dict( + type='PISARoIHead', + bbox_head=dict( + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0))), + train_cfg=dict( + rpn_proposal=dict( + nms_pre=2000, + max_per_img=2000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0), + rcnn=dict( + sampler=dict( + type='ScoreHLRSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True, + k=0.5, + bias=0.), + isr=dict(k=2, bias=0), + carl=dict(k=1, bias=0.2))), + test_cfg=dict( + rpn=dict( + nms_pre=2000, + max_per_img=2000, + nms=dict(type='nms', iou_threshold=0.7), + min_bbox_size=0))) diff --git a/mmdetection/configs/pisa/metafile.yml b/mmdetection/configs/pisa/metafile.yml new file mode 100644 index 00000000..3be5c3ba --- /dev/null +++ b/mmdetection/configs/pisa/metafile.yml @@ -0,0 +1,110 @@ +Collections: + - Name: PISA + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - FPN + - PISA + - RPN + - ResNet + - RoIPool + Paper: + URL: https://arxiv.org/abs/1904.04821 + Title: 'Prime Sample Attention in Object Detection' + README: configs/pisa/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/roi_heads/pisa_roi_head.py#L8 + Version: v2.1.0 + +Models: + - Name: pisa_faster_rcnn_r50_fpn_1x_coco + In Collection: PISA + Config: configs/pisa/faster-rcnn_r50_fpn_pisa_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/pisa/pisa_faster_rcnn_r50_fpn_1x_coco/pisa_faster_rcnn_r50_fpn_1x_coco-dea93523.pth + + - Name: pisa_faster_rcnn_x101_32x4d_fpn_1x_coco + In Collection: PISA + Config: configs/pisa/faster-rcnn_x101-32x4d_fpn_pisa_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/pisa/pisa_faster_rcnn_x101_32x4d_fpn_1x_coco/pisa_faster_rcnn_x101_32x4d_fpn_1x_coco-e4accec4.pth + + - Name: pisa_mask_rcnn_r50_fpn_1x_coco + In Collection: PISA + Config: configs/pisa/mask-rcnn_r50_fpn_pisa_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.1 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 35.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/pisa/pisa_mask_rcnn_r50_fpn_1x_coco/pisa_mask_rcnn_r50_fpn_1x_coco-dfcedba6.pth + + - Name: pisa_retinanet_r50_fpn_1x_coco + In Collection: PISA + Config: configs/pisa/retinanet-r50_fpn_pisa_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 36.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/pisa/pisa_retinanet_r50_fpn_1x_coco/pisa_retinanet_r50_fpn_1x_coco-76409952.pth + + - Name: pisa_retinanet_x101_32x4d_fpn_1x_coco + In Collection: PISA + Config: configs/pisa/retinanet_x101-32x4d_fpn_pisa_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/pisa/pisa_retinanet_x101_32x4d_fpn_1x_coco/pisa_retinanet_x101_32x4d_fpn_1x_coco-a0c13c73.pth + + - Name: pisa_ssd300_coco + In Collection: PISA + Config: configs/pisa/ssd300_pisa_coco.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 27.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/pisa/pisa_ssd300_coco/pisa_ssd300_coco-710e3ac9.pth + + - Name: pisa_ssd512_coco + In Collection: PISA + Config: configs/pisa/ssd512_pisa_coco.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 31.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/pisa/pisa_ssd512_coco/pisa_ssd512_coco-247addee.pth diff --git a/mmdetection/configs/pisa/retinanet-r50_fpn_pisa_1x_coco.py b/mmdetection/configs/pisa/retinanet-r50_fpn_pisa_1x_coco.py new file mode 100644 index 00000000..70f89e22 --- /dev/null +++ b/mmdetection/configs/pisa/retinanet-r50_fpn_pisa_1x_coco.py @@ -0,0 +1,7 @@ +_base_ = '../retinanet/retinanet_r50_fpn_1x_coco.py' + +model = dict( + bbox_head=dict( + type='PISARetinaHead', + loss_bbox=dict(type='SmoothL1Loss', beta=0.11, loss_weight=1.0)), + train_cfg=dict(isr=dict(k=2., bias=0.), carl=dict(k=1., bias=0.2))) diff --git a/mmdetection/configs/pisa/retinanet_x101-32x4d_fpn_pisa_1x_coco.py b/mmdetection/configs/pisa/retinanet_x101-32x4d_fpn_pisa_1x_coco.py new file mode 100644 index 00000000..9caad45d --- /dev/null +++ b/mmdetection/configs/pisa/retinanet_x101-32x4d_fpn_pisa_1x_coco.py @@ -0,0 +1,7 @@ +_base_ = '../retinanet/retinanet_x101-32x4d_fpn_1x_coco.py' + +model = dict( + bbox_head=dict( + type='PISARetinaHead', + loss_bbox=dict(type='SmoothL1Loss', beta=0.11, loss_weight=1.0)), + train_cfg=dict(isr=dict(k=2., bias=0.), carl=dict(k=1., bias=0.2))) diff --git a/mmdetection/configs/pisa/ssd300_pisa_coco.py b/mmdetection/configs/pisa/ssd300_pisa_coco.py new file mode 100644 index 00000000..b10236ba --- /dev/null +++ b/mmdetection/configs/pisa/ssd300_pisa_coco.py @@ -0,0 +1,7 @@ +_base_ = '../ssd/ssd300_coco.py' + +model = dict( + bbox_head=dict(type='PISASSDHead'), + train_cfg=dict(isr=dict(k=2., bias=0.), carl=dict(k=1., bias=0.2))) + +optim_wrapper = dict(clip_grad=dict(max_norm=35, norm_type=2)) diff --git a/mmdetection/configs/pisa/ssd512_pisa_coco.py b/mmdetection/configs/pisa/ssd512_pisa_coco.py new file mode 100644 index 00000000..939c7f45 --- /dev/null +++ b/mmdetection/configs/pisa/ssd512_pisa_coco.py @@ -0,0 +1,7 @@ +_base_ = '../ssd/ssd512_coco.py' + +model = dict( + bbox_head=dict(type='PISASSDHead'), + train_cfg=dict(isr=dict(k=2., bias=0.), carl=dict(k=1., bias=0.2))) + +optim_wrapper = dict(clip_grad=dict(max_norm=35, norm_type=2)) diff --git a/mmdetection/configs/point_rend/README.md b/mmdetection/configs/point_rend/README.md new file mode 100644 index 00000000..efa1dcac --- /dev/null +++ b/mmdetection/configs/point_rend/README.md @@ -0,0 +1,33 @@ +# PointRend + +> [PointRend: Image Segmentation as Rendering](https://arxiv.org/abs/1912.08193) + + + +## Abstract + +We present a new method for efficient high-quality image segmentation of objects and scenes. By analogizing classical computer graphics methods for efficient rendering with over- and undersampling challenges faced in pixel labeling tasks, we develop a unique perspective of image segmentation as a rendering problem. From this vantage, we present the PointRend (Point-based Rendering) neural network module: a module that performs point-based segmentation predictions at adaptively selected locations based on an iterative subdivision algorithm. PointRend can be flexibly applied to both instance and semantic segmentation tasks by building on top of existing state-of-the-art models. While many concrete implementations of the general idea are possible, we show that a simple design already achieves excellent results. Qualitatively, PointRend outputs crisp object boundaries in regions that are over-smoothed by previous methods. Quantitatively, PointRend yields significant gains on COCO and Cityscapes, for both instance and semantic segmentation. PointRend's efficiency enables output resolutions that are otherwise impractical in terms of memory or computation compared to existing approaches. + +
    + +
    + +## Results and Models + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :------: | :---: | :-----: | :------: | :------------: | :----: | :-----: | :------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | caffe | 1x | 4.6 | | 38.4 | 36.3 | [config](./point-rend_r50-caffe_fpn_ms-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/point_rend/point_rend_r50_caffe_fpn_mstrain_1x_coco/point_rend_r50_caffe_fpn_mstrain_1x_coco-1bcb5fb4.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/point_rend/point_rend_r50_caffe_fpn_mstrain_1x_coco/point_rend_r50_caffe_fpn_mstrain_1x_coco_20200612_161407.log.json) | +| R-50-FPN | caffe | 3x | 4.6 | | 41.0 | 38.0 | [config](./point-rend_r50-caffe_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/point_rend/point_rend_r50_caffe_fpn_mstrain_3x_coco/point_rend_r50_caffe_fpn_mstrain_3x_coco-e0ebb6b7.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/point_rend/point_rend_r50_caffe_fpn_mstrain_3x_coco/point_rend_r50_caffe_fpn_mstrain_3x_coco_20200614_002632.log.json) | + +Note: All models are trained with multi-scale, the input image shorter side is randomly scaled to one of (640, 672, 704, 736, 768, 800). + +## Citation + +```latex +@InProceedings{kirillov2019pointrend, + title={{PointRend}: Image Segmentation as Rendering}, + author={Alexander Kirillov and Yuxin Wu and Kaiming He and Ross Girshick}, + journal={ArXiv:1912.08193}, + year={2019} +} +``` diff --git a/mmdetection/configs/point_rend/metafile.yml b/mmdetection/configs/point_rend/metafile.yml new file mode 100644 index 00000000..f54f8a86 --- /dev/null +++ b/mmdetection/configs/point_rend/metafile.yml @@ -0,0 +1,54 @@ +Collections: + - Name: PointRend + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - PointRend + - FPN + - ResNet + Paper: + URL: https://arxiv.org/abs/1912.08193 + Title: 'PointRend: Image Segmentation as Rendering' + README: configs/point_rend/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.2.0/mmdet/models/detectors/point_rend.py#L6 + Version: v2.2.0 + +Models: + - Name: point_rend_r50_caffe_fpn_mstrain_1x_coco + In Collection: PointRend + Config: configs/point_rend/point-rend_r50-caffe_fpn_ms-1x_coco.py + Metadata: + Training Memory (GB): 4.6 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.4 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/point_rend/point_rend_r50_caffe_fpn_mstrain_1x_coco/point_rend_r50_caffe_fpn_mstrain_1x_coco-1bcb5fb4.pth + + - Name: point_rend_r50_caffe_fpn_mstrain_3x_coco + In Collection: PointRend + Config: configs/point_rend/point-rend_r50-caffe_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 4.6 + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.0 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/point_rend/point_rend_r50_caffe_fpn_mstrain_3x_coco/point_rend_r50_caffe_fpn_mstrain_3x_coco-e0ebb6b7.pth diff --git a/mmdetection/configs/point_rend/point-rend_r50-caffe_fpn_ms-1x_coco.py b/mmdetection/configs/point_rend/point-rend_r50-caffe_fpn_ms-1x_coco.py new file mode 100644 index 00000000..8b17f5a3 --- /dev/null +++ b/mmdetection/configs/point_rend/point-rend_r50-caffe_fpn_ms-1x_coco.py @@ -0,0 +1,44 @@ +_base_ = '../mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-1x_coco.py' +# model settings +model = dict( + type='PointRend', + roi_head=dict( + type='PointRendRoIHead', + mask_roi_extractor=dict( + type='GenericRoIExtractor', + aggregation='concat', + roi_layer=dict( + _delete_=True, type='SimpleRoIAlign', output_size=14), + out_channels=256, + featmap_strides=[4]), + mask_head=dict( + _delete_=True, + type='CoarseMaskHead', + num_fcs=2, + in_channels=256, + conv_out_channels=256, + fc_out_channels=1024, + num_classes=80, + loss_mask=dict( + type='CrossEntropyLoss', use_mask=True, loss_weight=1.0)), + point_head=dict( + type='MaskPointHead', + num_fcs=3, + in_channels=256, + fc_channels=256, + num_classes=80, + coarse_pred_each_layer=True, + loss_point=dict( + type='CrossEntropyLoss', use_mask=True, loss_weight=1.0))), + # model training and testing settings + train_cfg=dict( + rcnn=dict( + mask_size=7, + num_points=14 * 14, + oversample_ratio=3, + importance_sample_ratio=0.75)), + test_cfg=dict( + rcnn=dict( + subdivision_steps=5, + subdivision_num_points=28 * 28, + scale_factor=2))) diff --git a/mmdetection/configs/point_rend/point-rend_r50-caffe_fpn_ms-3x_coco.py b/mmdetection/configs/point_rend/point-rend_r50-caffe_fpn_ms-3x_coco.py new file mode 100644 index 00000000..b11faaa9 --- /dev/null +++ b/mmdetection/configs/point_rend/point-rend_r50-caffe_fpn_ms-3x_coco.py @@ -0,0 +1,18 @@ +_base_ = './point-rend_r50-caffe_fpn_ms-1x_coco.py' + +max_epochs = 36 + +# learning policy +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[28, 34], + gamma=0.1) +] + +train_cfg = dict(max_epochs=max_epochs) diff --git a/mmdetection/configs/pvt/README.md b/mmdetection/configs/pvt/README.md new file mode 100644 index 00000000..fccad4f6 --- /dev/null +++ b/mmdetection/configs/pvt/README.md @@ -0,0 +1,57 @@ +# PVT + +> [Pyramid vision transformer: A versatile backbone for dense prediction without convolutions](https://arxiv.org/abs/2102.12122) + + + +## Abstract + +Although using convolutional neural networks (CNNs) as backbones achieves great successes in computer vision, this work investigates a simple backbone network useful for many dense prediction tasks without convolutions. Unlike the recently-proposed Transformer model (e.g., ViT) that is specially designed for image classification, we propose Pyramid Vision Transformer~(PVT), which overcomes the difficulties of porting Transformer to various dense prediction tasks. PVT has several merits compared to prior arts. (1) Different from ViT that typically has low-resolution outputs and high computational and memory cost, PVT can be not only trained on dense partitions of the image to achieve high output resolution, which is important for dense predictions but also using a progressive shrinking pyramid to reduce computations of large feature maps. (2) PVT inherits the advantages from both CNN and Transformer, making it a unified backbone in various vision tasks without convolutions by simply replacing CNN backbones. (3) We validate PVT by conducting extensive experiments, showing that it boosts the performance of many downstream tasks, e.g., object detection, semantic, and instance segmentation. For example, with a comparable number of parameters, RetinaNet+PVT achieves 40.4 AP on the COCO dataset, surpassing RetinNet+ResNet50 (36.3 AP) by 4.1 absolute AP. We hope PVT could serve as an alternative and useful backbone for pixel-level predictions and facilitate future researches. + +Transformer recently has shown encouraging progresses in computer vision. In this work, we present new baselines by improving the original Pyramid Vision Transformer (abbreviated as PVTv1) by adding three designs, including (1) overlapping patch embedding, (2) convolutional feed-forward networks, and (3) linear complexity attention layers. +With these modifications, our PVTv2 significantly improves PVTv1 on three tasks e.g., classification, detection, and segmentation. Moreover, PVTv2 achieves comparable or better performances than recent works such as Swin Transformer. We hope this work will facilitate state-of-the-art Transformer researches in computer vision. + +
    + +
    + +## Results and Models + +### RetinaNet (PVTv1) + +| Backbone | Lr schd | Mem (GB) | box AP | Config | Download | +| :--------: | :-----: | :------: | :----: | :----------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| PVT-Tiny | 12e | 8.5 | 36.6 | [config](./retinanet_pvt-t_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvt-t_fpn_1x_coco/retinanet_pvt-t_fpn_1x_coco_20210831_103110-17b566bd.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvt-t_fpn_1x_coco/retinanet_pvt-t_fpn_1x_coco_20210831_103110.log.json) | +| PVT-Small | 12e | 14.5 | 40.4 | [config](./retinanet_pvt-s_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvt-s_fpn_1x_coco/retinanet_pvt-s_fpn_1x_coco_20210906_142921-b6c94a5b.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvt-s_fpn_1x_coco/retinanet_pvt-s_fpn_1x_coco_20210906_142921.log.json) | +| PVT-Medium | 12e | 20.9 | 41.7 | [config](./retinanet_pvt-m_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvt-m_fpn_1x_coco/retinanet_pvt-m_fpn_1x_coco_20210831_103243-55effa1b.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvt-m_fpn_1x_coco/retinanet_pvt-m_fpn_1x_coco_20210831_103243.log.json) | + +### RetinaNet (PVTv2) + +| Backbone | Lr schd | Mem (GB) | box AP | Config | Download | +| :------: | :-----: | :------: | :----: | :-------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| PVTv2-B0 | 12e | 7.4 | 37.1 | [config](./retinanet_pvtv2-b0_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvtv2-b0_fpn_1x_coco/retinanet_pvtv2-b0_fpn_1x_coco_20210831_103157-13e9aabe.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvtv2-b0_fpn_1x_coco/retinanet_pvtv2-b0_fpn_1x_coco_20210831_103157.log.json) | +| PVTv2-B1 | 12e | 9.5 | 41.2 | [config](./retinanet_pvtv2-b1_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvtv2-b1_fpn_1x_coco/retinanet_pvtv2-b1_fpn_1x_coco_20210831_103318-7e169a7d.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvtv2-b1_fpn_1x_coco/retinanet_pvtv2-b1_fpn_1x_coco_20210831_103318.log.json) | +| PVTv2-B2 | 12e | 16.2 | 44.6 | [config](./retinanet_pvtv2-b2_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvtv2-b2_fpn_1x_coco/retinanet_pvtv2-b2_fpn_1x_coco_20210901_174843-529f0b9a.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvtv2-b2_fpn_1x_coco/retinanet_pvtv2-b2_fpn_1x_coco_20210901_174843.log.json) | +| PVTv2-B3 | 12e | 23.0 | 46.0 | [config](./retinanet_pvtv2-b3_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvtv2-b3_fpn_1x_coco/retinanet_pvtv2-b3_fpn_1x_coco_20210903_151512-8357deff.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvtv2-b3_fpn_1x_coco/retinanet_pvtv2-b3_fpn_1x_coco_20210903_151512.log.json) | +| PVTv2-B4 | 12e | 17.0 | 46.3 | [config](./retinanet_pvtv2-b4_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvtv2-b4_fpn_1x_coco/retinanet_pvtv2-b4_fpn_1x_coco_20210901_170151-83795c86.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvtv2-b4_fpn_1x_coco/retinanet_pvtv2-b4_fpn_1x_coco_20210901_170151.log.json) | +| PVTv2-B5 | 12e | 18.7 | 46.1 | [config](./retinanet_pvtv2-b5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvtv2-b5_fpn_1x_coco/retinanet_pvtv2-b5_fpn_1x_coco_20210902_201800-3420eb57.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvtv2-b5_fpn_1x_coco/retinanet_pvtv2-b5_fpn_1x_coco_20210902_201800.log.json) | + +## Citation + +```latex +@article{wang2021pyramid, + title={Pyramid vision transformer: A versatile backbone for dense prediction without convolutions}, + author={Wang, Wenhai and Xie, Enze and Li, Xiang and Fan, Deng-Ping and Song, Kaitao and Liang, Ding and Lu, Tong and Luo, Ping and Shao, Ling}, + journal={arXiv preprint arXiv:2102.12122}, + year={2021} +} +``` + +```latex +@article{wang2021pvtv2, + title={PVTv2: Improved Baselines with Pyramid Vision Transformer}, + author={Wang, Wenhai and Xie, Enze and Li, Xiang and Fan, Deng-Ping and Song, Kaitao and Liang, Ding and Lu, Tong and Luo, Ping and Shao, Ling}, + journal={arXiv preprint arXiv:2106.13797}, + year={2021} +} +``` diff --git a/mmdetection/configs/pvt/metafile.yml b/mmdetection/configs/pvt/metafile.yml new file mode 100644 index 00000000..58843784 --- /dev/null +++ b/mmdetection/configs/pvt/metafile.yml @@ -0,0 +1,243 @@ +Models: + - Name: retinanet_pvt-t_fpn_1x_coco + In Collection: RetinaNet + Config: configs/pvt/retinanet_pvt-t_fpn_1x_coco.py + Metadata: + Training Memory (GB): 8.5 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x NVIDIA V100 GPUs + Architecture: + - PyramidVisionTransformer + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 36.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvt-t_fpn_1x_coco/retinanet_pvt-t_fpn_1x_coco_20210831_103110-17b566bd.pth + Paper: + URL: https://arxiv.org/abs/2102.12122 + Title: "Pyramid Vision Transformer: A Versatile Backbone for Dense Prediction without Convolutions" + README: configs/pvt/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.17.0/mmdet/models/backbones/pvt.py#L315 + Version: 2.17.0 + + - Name: retinanet_pvt-s_fpn_1x_coco + In Collection: RetinaNet + Config: configs/pvt/retinanet_pvt-s_fpn_1x_coco.py + Metadata: + Training Memory (GB): 14.5 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x NVIDIA V100 GPUs + Architecture: + - PyramidVisionTransformer + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvt-s_fpn_1x_coco/retinanet_pvt-s_fpn_1x_coco_20210906_142921-b6c94a5b.pth + Paper: + URL: https://arxiv.org/abs/2102.12122 + Title: "Pyramid Vision Transformer: A Versatile Backbone for Dense Prediction without Convolutions" + README: configs/pvt/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.17.0/mmdet/models/backbones/pvt.py#L315 + Version: 2.17.0 + + - Name: retinanet_pvt-m_fpn_1x_coco + In Collection: RetinaNet + Config: configs/pvt/retinanet_pvt-m_fpn_1x_coco.py + Metadata: + Training Memory (GB): 20.9 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x NVIDIA V100 GPUs + Architecture: + - PyramidVisionTransformer + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvt-m_fpn_1x_coco/retinanet_pvt-m_fpn_1x_coco_20210831_103243-55effa1b.pth + Paper: + URL: https://arxiv.org/abs/2102.12122 + Title: "Pyramid Vision Transformer: A Versatile Backbone for Dense Prediction without Convolutions" + README: configs/pvt/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.17.0/mmdet/models/backbones/pvt.py#L315 + Version: 2.17.0 + + - Name: retinanet_pvtv2-b0_fpn_1x_coco + In Collection: RetinaNet + Config: configs/pvt/retinanet_pvtv2-b0_fpn_1x_coco.py + Metadata: + Training Memory (GB): 7.4 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x NVIDIA V100 GPUs + Architecture: + - PyramidVisionTransformerV2 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvtv2-b0_fpn_1x_coco/retinanet_pvtv2-b0_fpn_1x_coco_20210831_103157-13e9aabe.pth + Paper: + URL: https://arxiv.org/abs/2106.13797 + Title: "PVTv2: Improved Baselines with Pyramid Vision Transformer" + README: configs/pvt/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.17.0/mmdet/models/backbones/pvt.py#L543 + Version: 2.17.0 + + - Name: retinanet_pvtv2-b1_fpn_1x_coco + In Collection: RetinaNet + Config: configs/pvt/retinanet_pvtv2-b1_fpn_1x_coco.py + Metadata: + Training Memory (GB): 9.5 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x NVIDIA V100 GPUs + Architecture: + - PyramidVisionTransformerV2 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvtv2-b1_fpn_1x_coco/retinanet_pvtv2-b1_fpn_1x_coco_20210831_103318-7e169a7d.pth + Paper: + URL: https://arxiv.org/abs/2106.13797 + Title: "PVTv2: Improved Baselines with Pyramid Vision Transformer" + README: configs/pvt/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.17.0/mmdet/models/backbones/pvt.py#L543 + Version: 2.17.0 + + - Name: retinanet_pvtv2-b2_fpn_1x_coco + In Collection: RetinaNet + Config: configs/pvt/retinanet_pvtv2-b2_fpn_1x_coco.py + Metadata: + Training Memory (GB): 16.2 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x NVIDIA V100 GPUs + Architecture: + - PyramidVisionTransformerV2 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvtv2-b2_fpn_1x_coco/retinanet_pvtv2-b2_fpn_1x_coco_20210901_174843-529f0b9a.pth + Paper: + URL: https://arxiv.org/abs/2106.13797 + Title: "PVTv2: Improved Baselines with Pyramid Vision Transformer" + README: configs/pvt/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.17.0/mmdet/models/backbones/pvt.py#L543 + Version: 2.17.0 + + - Name: retinanet_pvtv2-b3_fpn_1x_coco + In Collection: RetinaNet + Config: configs/pvt/retinanet_pvtv2-b3_fpn_1x_coco.py + Metadata: + Training Memory (GB): 23.0 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x NVIDIA V100 GPUs + Architecture: + - PyramidVisionTransformerV2 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvtv2-b3_fpn_1x_coco/retinanet_pvtv2-b3_fpn_1x_coco_20210903_151512-8357deff.pth + Paper: + URL: https://arxiv.org/abs/2106.13797 + Title: "PVTv2: Improved Baselines with Pyramid Vision Transformer" + README: configs/pvt/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.17.0/mmdet/models/backbones/pvt.py#L543 + Version: 2.17.0 + + - Name: retinanet_pvtv2-b4_fpn_1x_coco + In Collection: RetinaNet + Config: configs/pvt/retinanet_pvtv2-b4_fpn_1x_coco.py + Metadata: + Training Memory (GB): 17.0 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x NVIDIA V100 GPUs + Architecture: + - PyramidVisionTransformerV2 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvtv2-b4_fpn_1x_coco/retinanet_pvtv2-b4_fpn_1x_coco_20210901_170151-83795c86.pth + Paper: + URL: https://arxiv.org/abs/2106.13797 + Title: "PVTv2: Improved Baselines with Pyramid Vision Transformer" + README: configs/pvt/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.17.0/mmdet/models/backbones/pvt.py#L543 + Version: 2.17.0 + + - Name: retinanet_pvtv2-b5_fpn_1x_coco + In Collection: RetinaNet + Config: configs/pvt/retinanet_pvtv2-b5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 18.7 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x NVIDIA V100 GPUs + Architecture: + - PyramidVisionTransformerV2 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/pvt/retinanet_pvtv2-b5_fpn_1x_coco/retinanet_pvtv2-b5_fpn_1x_coco_20210902_201800-3420eb57.pth + Paper: + URL: https://arxiv.org/abs/2106.13797 + Title: "PVTv2: Improved Baselines with Pyramid Vision Transformer" + README: configs/pvt/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.17.0/mmdet/models/backbones/pvt.py#L543 + Version: 2.17.0 diff --git a/mmdetection/configs/pvt/retinanet_pvt-l_fpn_1x_coco.py b/mmdetection/configs/pvt/retinanet_pvt-l_fpn_1x_coco.py new file mode 100644 index 00000000..1a6f604b --- /dev/null +++ b/mmdetection/configs/pvt/retinanet_pvt-l_fpn_1x_coco.py @@ -0,0 +1,8 @@ +_base_ = 'retinanet_pvt-t_fpn_1x_coco.py' +model = dict( + backbone=dict( + num_layers=[3, 8, 27, 3], + init_cfg=dict(checkpoint='https://github.com/whai362/PVT/' + 'releases/download/v2/pvt_large.pth'))) +# Enable automatic-mixed-precision training with AmpOptimWrapper. +optim_wrapper = dict(type='AmpOptimWrapper') diff --git a/mmdetection/configs/pvt/retinanet_pvt-m_fpn_1x_coco.py b/mmdetection/configs/pvt/retinanet_pvt-m_fpn_1x_coco.py new file mode 100644 index 00000000..b888f788 --- /dev/null +++ b/mmdetection/configs/pvt/retinanet_pvt-m_fpn_1x_coco.py @@ -0,0 +1,6 @@ +_base_ = 'retinanet_pvt-t_fpn_1x_coco.py' +model = dict( + backbone=dict( + num_layers=[3, 4, 18, 3], + init_cfg=dict(checkpoint='https://github.com/whai362/PVT/' + 'releases/download/v2/pvt_medium.pth'))) diff --git a/mmdetection/configs/pvt/retinanet_pvt-s_fpn_1x_coco.py b/mmdetection/configs/pvt/retinanet_pvt-s_fpn_1x_coco.py new file mode 100644 index 00000000..46603488 --- /dev/null +++ b/mmdetection/configs/pvt/retinanet_pvt-s_fpn_1x_coco.py @@ -0,0 +1,6 @@ +_base_ = 'retinanet_pvt-t_fpn_1x_coco.py' +model = dict( + backbone=dict( + num_layers=[3, 4, 6, 3], + init_cfg=dict(checkpoint='https://github.com/whai362/PVT/' + 'releases/download/v2/pvt_small.pth'))) diff --git a/mmdetection/configs/pvt/retinanet_pvt-t_fpn_1x_coco.py b/mmdetection/configs/pvt/retinanet_pvt-t_fpn_1x_coco.py new file mode 100644 index 00000000..5f67c444 --- /dev/null +++ b/mmdetection/configs/pvt/retinanet_pvt-t_fpn_1x_coco.py @@ -0,0 +1,18 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +model = dict( + type='RetinaNet', + backbone=dict( + _delete_=True, + type='PyramidVisionTransformer', + num_layers=[2, 2, 2, 2], + init_cfg=dict(checkpoint='https://github.com/whai362/PVT/' + 'releases/download/v2/pvt_tiny.pth')), + neck=dict(in_channels=[64, 128, 320, 512])) +# optimizer +optim_wrapper = dict( + optimizer=dict( + _delete_=True, type='AdamW', lr=0.0001, weight_decay=0.0001)) diff --git a/mmdetection/configs/pvt/retinanet_pvtv2-b0_fpn_1x_coco.py b/mmdetection/configs/pvt/retinanet_pvtv2-b0_fpn_1x_coco.py new file mode 100644 index 00000000..cbebf90f --- /dev/null +++ b/mmdetection/configs/pvt/retinanet_pvtv2-b0_fpn_1x_coco.py @@ -0,0 +1,19 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +model = dict( + type='RetinaNet', + backbone=dict( + _delete_=True, + type='PyramidVisionTransformerV2', + embed_dims=32, + num_layers=[2, 2, 2, 2], + init_cfg=dict(checkpoint='https://github.com/whai362/PVT/' + 'releases/download/v2/pvt_v2_b0.pth')), + neck=dict(in_channels=[32, 64, 160, 256])) +# optimizer +optim_wrapper = dict( + optimizer=dict( + _delete_=True, type='AdamW', lr=0.0001, weight_decay=0.0001)) diff --git a/mmdetection/configs/pvt/retinanet_pvtv2-b1_fpn_1x_coco.py b/mmdetection/configs/pvt/retinanet_pvtv2-b1_fpn_1x_coco.py new file mode 100644 index 00000000..5374c509 --- /dev/null +++ b/mmdetection/configs/pvt/retinanet_pvtv2-b1_fpn_1x_coco.py @@ -0,0 +1,7 @@ +_base_ = 'retinanet_pvtv2-b0_fpn_1x_coco.py' +model = dict( + backbone=dict( + embed_dims=64, + init_cfg=dict(checkpoint='https://github.com/whai362/PVT/' + 'releases/download/v2/pvt_v2_b1.pth')), + neck=dict(in_channels=[64, 128, 320, 512])) diff --git a/mmdetection/configs/pvt/retinanet_pvtv2-b2_fpn_1x_coco.py b/mmdetection/configs/pvt/retinanet_pvtv2-b2_fpn_1x_coco.py new file mode 100644 index 00000000..cf9a18de --- /dev/null +++ b/mmdetection/configs/pvt/retinanet_pvtv2-b2_fpn_1x_coco.py @@ -0,0 +1,8 @@ +_base_ = 'retinanet_pvtv2-b0_fpn_1x_coco.py' +model = dict( + backbone=dict( + embed_dims=64, + num_layers=[3, 4, 6, 3], + init_cfg=dict(checkpoint='https://github.com/whai362/PVT/' + 'releases/download/v2/pvt_v2_b2.pth')), + neck=dict(in_channels=[64, 128, 320, 512])) diff --git a/mmdetection/configs/pvt/retinanet_pvtv2-b3_fpn_1x_coco.py b/mmdetection/configs/pvt/retinanet_pvtv2-b3_fpn_1x_coco.py new file mode 100644 index 00000000..7a47f820 --- /dev/null +++ b/mmdetection/configs/pvt/retinanet_pvtv2-b3_fpn_1x_coco.py @@ -0,0 +1,8 @@ +_base_ = 'retinanet_pvtv2-b0_fpn_1x_coco.py' +model = dict( + backbone=dict( + embed_dims=64, + num_layers=[3, 4, 18, 3], + init_cfg=dict(checkpoint='https://github.com/whai362/PVT/' + 'releases/download/v2/pvt_v2_b3.pth')), + neck=dict(in_channels=[64, 128, 320, 512])) diff --git a/mmdetection/configs/pvt/retinanet_pvtv2-b4_fpn_1x_coco.py b/mmdetection/configs/pvt/retinanet_pvtv2-b4_fpn_1x_coco.py new file mode 100644 index 00000000..5faf4c50 --- /dev/null +++ b/mmdetection/configs/pvt/retinanet_pvtv2-b4_fpn_1x_coco.py @@ -0,0 +1,20 @@ +_base_ = 'retinanet_pvtv2-b0_fpn_1x_coco.py' +model = dict( + backbone=dict( + embed_dims=64, + num_layers=[3, 8, 27, 3], + init_cfg=dict(checkpoint='https://github.com/whai362/PVT/' + 'releases/download/v2/pvt_v2_b4.pth')), + neck=dict(in_channels=[64, 128, 320, 512])) +# optimizer +optim_wrapper = dict( + optimizer=dict( + _delete_=True, type='AdamW', lr=0.0001 / 1.4, weight_decay=0.0001)) + +# dataset settings +train_dataloader = dict(batch_size=1, num_workers=1) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (1 samples per GPU) +auto_scale_lr = dict(base_batch_size=8) diff --git a/mmdetection/configs/pvt/retinanet_pvtv2-b5_fpn_1x_coco.py b/mmdetection/configs/pvt/retinanet_pvtv2-b5_fpn_1x_coco.py new file mode 100644 index 00000000..afff8719 --- /dev/null +++ b/mmdetection/configs/pvt/retinanet_pvtv2-b5_fpn_1x_coco.py @@ -0,0 +1,21 @@ +_base_ = 'retinanet_pvtv2-b0_fpn_1x_coco.py' +model = dict( + backbone=dict( + embed_dims=64, + num_layers=[3, 6, 40, 3], + mlp_ratios=(4, 4, 4, 4), + init_cfg=dict(checkpoint='https://github.com/whai362/PVT/' + 'releases/download/v2/pvt_v2_b5.pth')), + neck=dict(in_channels=[64, 128, 320, 512])) +# optimizer +optim_wrapper = dict( + optimizer=dict( + _delete_=True, type='AdamW', lr=0.0001 / 1.4, weight_decay=0.0001)) + +# dataset settings +train_dataloader = dict(batch_size=1, num_workers=1) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (1 samples per GPU) +auto_scale_lr = dict(base_batch_size=8) diff --git a/mmdetection/configs/qdtrack/README.md b/mmdetection/configs/qdtrack/README.md new file mode 100644 index 00000000..5a6efe7d --- /dev/null +++ b/mmdetection/configs/qdtrack/README.md @@ -0,0 +1,89 @@ +# Quasi-Dense Similarity Learning for Multiple Object Tracking + +## Abstract + + + +Similarity learning has been recognized as a crucial step for object tracking. However, existing multiple object tracking methods only use sparse ground truth matching as the training objective, while ignoring the majority of the informative regions on the images. In this paper, we present Quasi-Dense Similarity Learning, which densely samples hundreds of region proposals on a pair of images for contrastive learning. We can directly combine this similarity learning with existing detection methods to build Quasi-Dense Tracking (QDTrack) without turning to displacementregression or motion priors. We also find that the resulting distinctive feature space admits a simple nearest neighbor search at the inference time. Despite its simplicity, QD-Track outperforms all existing methods on MOT, BDD100K, Waymo, and TAO tracking benchmarks. It achieves 68.7 MOTA at 20.3 FPS on MOT17 without using external training data. Compared to methods with similar detectors, it boosts almost 10 points of MOTA and significantly decreases the number of ID switches on BDD100K and Waymo datasets. + + + +
    + + +
    + +## Results and models on MOT17 + +| Method | Detector | Train Set | Test Set | Public | Inf time (fps) | HOTA | MOTA | IDF1 | FP | FN | IDSw. | Config | Download | +| :-----: | :----------: | :--------: | :------: | :----: | :------------: | :--: | :--: | :--: | :--: | :---: | :---: | :-------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| QDTrack | Faster R-CNN | half-train | half-val | N | - | 57.1 | 68.1 | 68.6 | 7707 | 42732 | 1083 | [config](qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py) | [model](https://download.openmmlab.com/mmtracking/mot/qdtrack/mot_dataset/qdtrack_faster-rcnn_r50_fpn_4e_mot17_20220315_145635-76f295ef.pth) \| [log](https://download.openmmlab.com/mmtracking/mot/qdtrack/mot_dataset/qdtrack_faster-rcnn_r50_fpn_4e_mot17_20220315_145635.log.json) | + +## Get started + +### 1. Development Environment Setup + +Tracking Development Environment Setup can refer to this [document](../../docs/en/get_started.md). + +### 2. Dataset Prepare + +Tracking Dataset Prepare can refer to this [document](../../docs/en/user_guides/tracking_dataset_prepare.md). + +### 3. Training + +Due to the influence of parameters such as learning rate in default configuration file, we recommend using 8 GPUs for training in order to reproduce accuracy. You can use the following command to start the training. + +```shell +# Training QDTrack on mot17-half-train dataset with following command. +# The number after config file represents the number of GPUs used. Here we use 8 GPUs. +bash tools/dist_train.sh configs/qdtrack/qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py 8 +``` + +If you want to know about more detailed usage of `train.py/dist_train.sh/slurm_train.sh`, +please refer to this [document](../../docs/en/user_guides/tracking_train_test.md). + +### 4. Testing and evaluation + +**4.1 Example on MOTxx-halfval dataset** + +```shell +# Example 1: Test on motXX-half-val set +# The number after config file represents the number of GPUs used. Here we use 8 GPUs. +bash tools/dist_test_tracking.sh configs/qdtrack/qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py 8 --checkpoint ${CHECKPOINT_PATH} +``` + +**4.2 use video_baesd to evaluating and testing** +we also provide two_ways(img_based or video_based) to evaluating and testing. +if you want to use video_based to evaluating and testing, you can modify config as follows + +``` +val_dataloader = dict( + sampler=dict(type='DefaultSampler', shuffle=False, round_up=False)) +``` + +If you want to know about more detailed usage of `test_tracking.py/dist_test_tracking.sh/slurm_test_tracking.sh`, +please refer to this [document](../../docs/en/user_guides/tracking_train_test.md). + +### 5.Inference + +Use a single GPU to predict a video and save it as a video. + +```shell +python demo/mot_demo.py demo/demo_mot.mp4 configs/qdtrack/qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py --checkpoint ${CHECKPOINT_PATH} --out mot.mp4 +``` + +If you want to know about more detailed usage of `mot_demo.py`, please refer to this [document](../../docs/en/user_guides/tracking_inference.md). + +## Citation + + + +```latex +@inproceedings{pang2021quasi, + title={Quasi-dense similarity learning for multiple object tracking}, + author={Pang, Jiangmiao and Qiu, Linlu and Li, Xia and Chen, Haofeng and Li, Qi and Darrell, Trevor and Yu, Fisher}, + booktitle={Proceedings of the IEEE/CVF conference on computer vision and pattern recognition}, + pages={164--173}, + year={2021} +} +``` diff --git a/mmdetection/configs/qdtrack/metafile.yml b/mmdetection/configs/qdtrack/metafile.yml new file mode 100644 index 00000000..e5c5504d --- /dev/null +++ b/mmdetection/configs/qdtrack/metafile.yml @@ -0,0 +1,30 @@ +Collections: + - Name: QDTrack + Metadata: + Training Data: MOT17, crowdhuman + Training Techniques: + - SGD + Training Resources: 8x V100 GPUs + Architecture: + - ResNet + Paper: + URL: https://arxiv.org/pdf/2006.06664.pdf + Title: Quasi-Dense Similarity Learning for Multiple Object Tracking + README: configs/qdtrack/README.md + +Models: + - Name: qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval + In Collection: QDTrack + Config: configs/qdtrack/qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py + Metadata: + Training Data: MOT17 + Training Memory (GB): 5.83 + Epochs: 4 + Results: + - Task: Multi-object Tracking + Dataset: MOT17 + Metrics: + HOTA: 57.1 + MOTA: 68.1 + IDF1: 68.6 + Weights: https://download.openmmlab.com/mmtracking/mot/qdtrack/mot_dataset/qdtrack_faster-rcnn_r50_fpn_4e_mot17_20220315_145635-76f295ef.pth diff --git a/mmdetection/configs/qdtrack/qdtrack_faster-rcnn_r50_fpn_4e_base.py b/mmdetection/configs/qdtrack/qdtrack_faster-rcnn_r50_fpn_4e_base.py new file mode 100644 index 00000000..e3c17c3e --- /dev/null +++ b/mmdetection/configs/qdtrack/qdtrack_faster-rcnn_r50_fpn_4e_base.py @@ -0,0 +1,118 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', '../_base_/default_runtime.py' +] + +detector = _base_.model +detector.pop('data_preprocessor') + +detector['backbone'].update( + dict( + norm_cfg=dict(type='BN', requires_grad=False), + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe'))) +detector.rpn_head.loss_bbox.update( + dict(type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=1.0)) +detector.rpn_head.bbox_coder.update(dict(clip_border=False)) +detector.roi_head.bbox_head.update(dict(num_classes=1)) +detector.roi_head.bbox_head.bbox_coder.update(dict(clip_border=False)) +detector['init_cfg'] = dict( + type='Pretrained', + checkpoint= # noqa: E251 + 'https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/' + 'faster_rcnn_r50_fpn_1x_coco-person/' + 'faster_rcnn_r50_fpn_1x_coco-person_20201216_175929-d022e227.pth' + # noqa: E501 +) +del _base_.model + +model = dict( + type='QDTrack', + data_preprocessor=dict( + type='TrackDataPreprocessor', + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False, + pad_size_divisor=32), + detector=detector, + track_head=dict( + type='QuasiDenseTrackHead', + roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + embed_head=dict( + type='QuasiDenseEmbedHead', + num_convs=4, + num_fcs=1, + embed_channels=256, + norm_cfg=dict(type='GN', num_groups=32), + loss_track=dict(type='MultiPosCrossEntropyLoss', loss_weight=0.25), + loss_track_aux=dict( + type='MarginL2Loss', + neg_pos_ub=3, + pos_margin=0, + neg_margin=0.1, + hard_mining=True, + loss_weight=1.0)), + loss_bbox=dict(type='L1Loss', loss_weight=1.0), + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.5, + min_pos_iou=0.5, + match_low_quality=False, + ignore_iof_thr=-1), + sampler=dict( + type='CombinedSampler', + num=256, + pos_fraction=0.5, + neg_pos_ub=3, + add_gt_as_proposals=True, + pos_sampler=dict(type='InstanceBalancedPosSampler'), + neg_sampler=dict(type='RandomSampler')))), + tracker=dict( + type='QuasiDenseTracker', + init_score_thr=0.9, + obj_score_thr=0.5, + match_score_thr=0.5, + memo_tracklet_frames=30, + memo_backdrop_frames=1, + memo_momentum=0.8, + nms_conf_thr=0.5, + nms_backdrop_iou_thr=0.3, + nms_class_iou_thr=0.7, + with_cats=True, + match_metric='bisoftmax')) +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001), + clip_grad=dict(max_norm=35, norm_type=2)) +# learning policy +param_scheduler = [ + dict(type='MultiStepLR', begin=0, end=4, by_epoch=True, milestones=[3]) +] + +# runtime settings +train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=4, val_interval=4) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +default_hooks = dict( + logger=dict(type='LoggerHook', interval=50), + visualization=dict(type='TrackVisualizationHook', draw=False)) + +vis_backends = [dict(type='LocalVisBackend')] +visualizer = dict( + type='TrackLocalVisualizer', vis_backends=vis_backends, name='visualizer') + +# custom hooks +custom_hooks = [ + # Synchronize model buffers such as running_mean and running_var in BN + # at the end of each epoch + dict(type='SyncBuffersHook') +] diff --git a/mmdetection/configs/qdtrack/qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py b/mmdetection/configs/qdtrack/qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py new file mode 100644 index 00000000..d87604da --- /dev/null +++ b/mmdetection/configs/qdtrack/qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py @@ -0,0 +1,14 @@ +_base_ = [ + './qdtrack_faster-rcnn_r50_fpn_4e_base.py', + '../_base_/datasets/mot_challenge.py', +] + +# evaluator +val_evaluator = [ + dict(type='CocoVideoMetric', metric=['bbox'], classwise=True), + dict(type='MOTChallengeMetric', metric=['HOTA', 'CLEAR', 'Identity']) +] + +test_evaluator = val_evaluator +# The fluctuation of HOTA is about +-1. +randomness = dict(seed=6) diff --git a/mmdetection/configs/queryinst/README.md b/mmdetection/configs/queryinst/README.md new file mode 100644 index 00000000..ee62ccbf --- /dev/null +++ b/mmdetection/configs/queryinst/README.md @@ -0,0 +1,36 @@ +# QueryInst + +> [Instances as Queries](https://openaccess.thecvf.com/content/ICCV2021/html/Fang_Instances_As_Queries_ICCV_2021_paper.html) + + + +## Abstract + +We present QueryInst, a new perspective for instance segmentation. QueryInst is a multi-stage end-to-end system that treats instances of interest as learnable queries, enabling query based object detectors, e.g., Sparse R-CNN, to have strong instance segmentation performance. The attributes of instances such as categories, bounding boxes, instance masks, and instance association embeddings are represented by queries in a unified manner. In QueryInst, a query is shared by both detection and segmentation via dynamic convolutions and driven by parallelly-supervised multi-stage learning. We conduct extensive experiments on three challenging benchmarks, i.e., COCO, CityScapes, and YouTube-VIS to evaluate the effectiveness of QueryInst in object detection, instance segmentation, and video instance segmentation tasks. For the first time, we demonstrate that a simple end-to-end query based framework can achieve the state-of-the-art performance in various instance-level recognition tasks. + +
    + +
    + +## Results and Models + +| Model | Backbone | Style | Lr schd | Number of Proposals | Multi-Scale | RandomCrop | box AP | mask AP | Config | Download | +| :-------: | :-------: | :-----: | :-----: | :-----------------: | :---------: | :--------: | :----: | :-----: | :---------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| QueryInst | R-50-FPN | pytorch | 1x | 100 | False | False | 42.0 | 37.5 | [config](./queryinst_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/queryinst/queryinst_r50_fpn_1x_coco/queryinst_r50_fpn_1x_coco_20210907_084916-5a8f1998.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/queryinst/queryinst_r50_fpn_1x_coco/queryinst_r50_fpn_1x_coco_20210907_084916.log.json) | +| QueryInst | R-50-FPN | pytorch | 3x | 100 | True | False | 44.8 | 39.8 | [config](./queryinst_r50_fpn_ms-480-800-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/queryinst/queryinst_r50_fpn_mstrain_480-800_3x_coco/queryinst_r50_fpn_mstrain_480-800_3x_coco_20210901_103643-7837af86.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/queryinst/queryinst_r50_fpn_mstrain_480-800_3x_coco/queryinst_r50_fpn_mstrain_480-800_3x_coco_20210901_103643.log.json) | +| QueryInst | R-50-FPN | pytorch | 3x | 300 | True | True | 47.5 | 41.7 | [config](./queryinst_r50_fpn_300-proposals_crop-ms-480-800-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/queryinst/queryinst_r50_fpn_300_proposals_crop_mstrain_480-800_3x_coco/queryinst_r50_fpn_300_proposals_crop_mstrain_480-800_3x_coco_20210904_101802-85cffbd8.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/queryinst/queryinst_r50_fpn_300_proposals_crop_mstrain_480-800_3x_coco/queryinst_r50_fpn_300_proposals_crop_mstrain_480-800_3x_coco_20210904_101802.log.json) | +| QueryInst | R-101-FPN | pytorch | 3x | 100 | True | False | 46.4 | 41.0 | [config](./queryinst_r101_fpn_ms-480-800-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/queryinst/queryinst_r101_fpn_mstrain_480-800_3x_coco/queryinst_r101_fpn_mstrain_480-800_3x_coco_20210904_104048-91f9995b.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/queryinst/queryinst_r101_fpn_mstrain_480-800_3x_coco/queryinst_r101_fpn_mstrain_480-800_3x_coco_20210904_104048.log.json) | +| QueryInst | R-101-FPN | pytorch | 3x | 300 | True | True | 49.0 | 42.9 | [config](./queryinst_r101_fpn_300-proposals_crop-ms-480-800-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/queryinst/queryinst_r101_fpn_300_proposals_crop_mstrain_480-800_3x_coco/queryinst_r101_fpn_300_proposals_crop_mstrain_480-800_3x_coco_20210904_153621-76cce59f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/queryinst/queryinst_r101_fpn_300_proposals_crop_mstrain_480-800_3x_coco/queryinst_r101_fpn_300_proposals_crop_mstrain_480-800_3x_coco_20210904_153621.log.json) | + +## Citation + +```latex +@InProceedings{Fang_2021_ICCV, + author = {Fang, Yuxin and Yang, Shusheng and Wang, Xinggang and Li, Yu and Fang, Chen and Shan, Ying and Feng, Bin and Liu, Wenyu}, + title = {Instances As Queries}, + booktitle = {Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV)}, + month = {October}, + year = {2021}, + pages = {6910-6919} +} +``` diff --git a/mmdetection/configs/queryinst/metafile.yml b/mmdetection/configs/queryinst/metafile.yml new file mode 100644 index 00000000..3ea3b00a --- /dev/null +++ b/mmdetection/configs/queryinst/metafile.yml @@ -0,0 +1,100 @@ +Collections: + - Name: QueryInst + Metadata: + Training Data: COCO + Training Techniques: + - AdamW + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - FPN + - ResNet + - QueryInst + Paper: + URL: https://openaccess.thecvf.com/content/ICCV2021/papers/Fang_Instances_As_Queries_ICCV_2021_paper.pdf + Title: 'Instances as Queries' + README: configs/queryinst/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/detectors/queryinst.py + Version: v2.18.0 + +Models: + - Name: queryinst_r50_fpn_1x_coco + In Collection: QueryInst + Config: configs/queryinst/queryinst_r50_fpn_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.0 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/queryinst/queryinst_r50_fpn_1x_coco/queryinst_r50_fpn_1x_coco_20210907_084916-5a8f1998.pth + + - Name: queryinst_r50_fpn_ms-480-800-3x_coco + In Collection: QueryInst + Config: configs/queryinst/queryinst_r50_fpn_ms-480-800-3x_coco.py + Metadata: + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/queryinst/queryinst_r50_fpn_mstrain_480-800_3x_coco/queryinst_r50_fpn_mstrain_480-800_3x_coco_20210901_103643-7837af86.pth + + - Name: queryinst_r50_fpn_300-proposals_crop-ms-480-800-3x_coco + In Collection: QueryInst + Config: configs/queryinst/queryinst_r50_fpn_300-proposals_crop-ms-480-800-3x_coco.py + Metadata: + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 47.5 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 41.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/queryinst/queryinst_r50_fpn_300_proposals_crop_mstrain_480-800_3x_coco/queryinst_r50_fpn_300_proposals_crop_mstrain_480-800_3x_coco_20210904_101802-85cffbd8.pth + + - Name: queryinst_r101_fpn_ms-480-800-3x_coco + In Collection: QueryInst + Config: configs/queryinst/queryinst_r101_fpn_ms-480-800-3x_coco.py + Metadata: + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.4 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 41.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/queryinst/queryinst_r101_fpn_mstrain_480-800_3x_coco/queryinst_r101_fpn_mstrain_480-800_3x_coco_20210904_104048-91f9995b.pth + + - Name: queryinst_r101_fpn_300-proposals_crop-ms-480-800-3x_coco + In Collection: QueryInst + Config: configs/queryinst/queryinst_r101_fpn_300-proposals_crop-ms-480-800-3x_coco.py + Metadata: + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 49.0 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 42.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/queryinst/queryinst_r101_fpn_300_proposals_crop_mstrain_480-800_3x_coco/queryinst_r101_fpn_300_proposals_crop_mstrain_480-800_3x_coco_20210904_153621-76cce59f.pth diff --git a/mmdetection/configs/queryinst/queryinst_r101_fpn_300-proposals_crop-ms-480-800-3x_coco.py b/mmdetection/configs/queryinst/queryinst_r101_fpn_300-proposals_crop-ms-480-800-3x_coco.py new file mode 100644 index 00000000..1692c134 --- /dev/null +++ b/mmdetection/configs/queryinst/queryinst_r101_fpn_300-proposals_crop-ms-480-800-3x_coco.py @@ -0,0 +1,7 @@ +_base_ = './queryinst_r50_fpn_300-proposals_crop-ms-480-800-3x_coco.py' + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/queryinst/queryinst_r101_fpn_ms-480-800-3x_coco.py b/mmdetection/configs/queryinst/queryinst_r101_fpn_ms-480-800-3x_coco.py new file mode 100644 index 00000000..dd5b7f45 --- /dev/null +++ b/mmdetection/configs/queryinst/queryinst_r101_fpn_ms-480-800-3x_coco.py @@ -0,0 +1,7 @@ +_base_ = './queryinst_r50_fpn_ms-480-800-3x_coco.py' + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/queryinst/queryinst_r50_fpn_1x_coco.py b/mmdetection/configs/queryinst/queryinst_r50_fpn_1x_coco.py new file mode 100644 index 00000000..63d61d78 --- /dev/null +++ b/mmdetection/configs/queryinst/queryinst_r50_fpn_1x_coco.py @@ -0,0 +1,155 @@ +_base_ = [ + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +num_stages = 6 +num_proposals = 100 +model = dict( + type='QueryInst', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_mask=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=0, + add_extra_convs='on_input', + num_outs=4), + rpn_head=dict( + type='EmbeddingRPNHead', + num_proposals=num_proposals, + proposal_feature_channel=256), + roi_head=dict( + type='SparseRoIHead', + num_stages=num_stages, + stage_loss_weights=[1] * num_stages, + proposal_feature_channel=256, + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=2), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + mask_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=2), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + bbox_head=[ + dict( + type='DIIHead', + num_classes=80, + num_ffn_fcs=2, + num_heads=8, + num_cls_fcs=1, + num_reg_fcs=3, + feedforward_channels=2048, + in_channels=256, + dropout=0.0, + ffn_act_cfg=dict(type='ReLU', inplace=True), + dynamic_conv_cfg=dict( + type='DynamicConv', + in_channels=256, + feat_channels=64, + out_channels=256, + input_feat_shape=7, + act_cfg=dict(type='ReLU', inplace=True), + norm_cfg=dict(type='LN')), + loss_bbox=dict(type='L1Loss', loss_weight=5.0), + loss_iou=dict(type='GIoULoss', loss_weight=2.0), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=2.0), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + clip_border=False, + target_means=[0., 0., 0., 0.], + target_stds=[0.5, 0.5, 1., 1.])) for _ in range(num_stages) + ], + mask_head=[ + dict( + type='DynamicMaskHead', + dynamic_conv_cfg=dict( + type='DynamicConv', + in_channels=256, + feat_channels=64, + out_channels=256, + input_feat_shape=14, + with_proj=False, + act_cfg=dict(type='ReLU', inplace=True), + norm_cfg=dict(type='LN')), + num_convs=4, + num_classes=80, + roi_feat_size=14, + in_channels=256, + conv_kernel_size=3, + conv_out_channels=256, + class_agnostic=False, + norm_cfg=dict(type='BN'), + upsample_cfg=dict(type='deconv', scale_factor=2), + loss_mask=dict( + type='DiceLoss', + loss_weight=8.0, + use_sigmoid=True, + activate=False, + eps=1e-5)) for _ in range(num_stages) + ]), + # training and testing settings + train_cfg=dict( + rpn=None, + rcnn=[ + dict( + assigner=dict( + type='HungarianAssigner', + match_costs=[ + dict(type='FocalLossCost', weight=2.0), + dict(type='BBoxL1Cost', weight=5.0, box_format='xyxy'), + dict(type='IoUCost', iou_mode='giou', weight=2.0) + ]), + sampler=dict(type='PseudoSampler'), + pos_weight=1, + mask_size=28, + ) for _ in range(num_stages) + ]), + test_cfg=dict( + rpn=None, rcnn=dict(max_per_img=num_proposals, mask_thr_binary=0.5))) + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict( + _delete_=True, type='AdamW', lr=0.0001, weight_decay=0.0001), + paramwise_cfg=dict( + custom_keys={'backbone': dict(lr_mult=0.1, decay_mult=1.0)}), + clip_grad=dict(max_norm=0.1, norm_type=2)) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, + end=1000), + dict( + type='MultiStepLR', + begin=0, + end=12, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] diff --git a/mmdetection/configs/queryinst/queryinst_r50_fpn_300-proposals_crop-ms-480-800-3x_coco.py b/mmdetection/configs/queryinst/queryinst_r50_fpn_300-proposals_crop-ms-480-800-3x_coco.py new file mode 100644 index 00000000..33ab0612 --- /dev/null +++ b/mmdetection/configs/queryinst/queryinst_r50_fpn_300-proposals_crop-ms-480-800-3x_coco.py @@ -0,0 +1,45 @@ +_base_ = './queryinst_r50_fpn_ms-480-800-3x_coco.py' +num_proposals = 300 +model = dict( + rpn_head=dict(num_proposals=num_proposals), + test_cfg=dict( + _delete_=True, + rpn=None, + rcnn=dict(max_per_img=num_proposals, mask_thr_binary=0.5))) + +# augmentation strategy originates from DETR. +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[[ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + scales=[(400, 1333), (500, 1333), (600, 1333)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), + (576, 1333), (608, 1333), (640, 1333), + (672, 1333), (704, 1333), (736, 1333), + (768, 1333), (800, 1333)], + keep_ratio=True) + ]]), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/mmdetection/configs/queryinst/queryinst_r50_fpn_ms-480-800-3x_coco.py b/mmdetection/configs/queryinst/queryinst_r50_fpn_ms-480-800-3x_coco.py new file mode 100644 index 00000000..6b99374e --- /dev/null +++ b/mmdetection/configs/queryinst/queryinst_r50_fpn_ms-480-800-3x_coco.py @@ -0,0 +1,32 @@ +_base_ = './queryinst_r50_fpn_1x_coco.py' + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +# learning policy +max_epochs = 36 +train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=max_epochs) + +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[27, 33], + gamma=0.1) +] diff --git a/mmdetection/configs/regnet/README.md b/mmdetection/configs/regnet/README.md new file mode 100644 index 00000000..0bfcec18 --- /dev/null +++ b/mmdetection/configs/regnet/README.md @@ -0,0 +1,121 @@ +# RegNet + +> [Designing Network Design Spaces](https://arxiv.org/abs/2003.13678) + + + +## Abstract + +In this work, we present a new network design paradigm. Our goal is to help advance the understanding of network design and discover design principles that generalize across settings. Instead of focusing on designing individual network instances, we design network design spaces that parametrize populations of networks. The overall process is analogous to classic manual design of networks, but elevated to the design space level. Using our methodology we explore the structure aspect of network design and arrive at a low-dimensional design space consisting of simple, regular networks that we call RegNet. The core insight of the RegNet parametrization is surprisingly simple: widths and depths of good networks can be explained by a quantized linear function. We analyze the RegNet design space and arrive at interesting findings that do not match the current practice of network design. The RegNet design space provides simple and fast networks that work well across a wide range of flop regimes. Under comparable training settings and flops, the RegNet models outperform the popular EfficientNet models while being up to 5x faster on GPUs. + +
    + +
    + +## Introduction + +We implement RegNetX and RegNetY models in detection systems and provide their first results on Mask R-CNN, Faster R-CNN and RetinaNet. + +The pre-trained models are converted from [model zoo of pycls](https://github.com/facebookresearch/pycls/blob/master/MODEL_ZOO.md). + +## Usage + +To use a regnet model, there are two steps to do: + +1. Convert the model to ResNet-style supported by MMDetection +2. Modify backbone and neck in config accordingly + +### Convert model + +We already prepare models of FLOPs from 400M to 12G in our model zoo. + +For more general usage, we also provide script `regnet2mmdet.py` in the tools directory to convert the key of models pretrained by [pycls](https://github.com/facebookresearch/pycls/) to +ResNet-style checkpoints used in MMDetection. + +```bash +python -u tools/model_converters/regnet2mmdet.py ${PRETRAIN_PATH} ${STORE_PATH} +``` + +This script convert model from `PRETRAIN_PATH` and store the converted model in `STORE_PATH`. + +### Modify config + +The users can modify the config's `depth` of backbone and corresponding keys in `arch` according to the configs in the [pycls model zoo](https://github.com/facebookresearch/pycls/blob/master/MODEL_ZOO.md). +The parameter `in_channels` in FPN can be found in the Figure 15 & 16 of the paper (`wi` in the legend). +This directory already provides some configs with their performance, using RegNetX from 800MF to 12GF level. +For other pre-trained models or self-implemented regnet models, the users are responsible to check these parameters by themselves. + +**Note**: Although Fig. 15 & 16 also provide `w0`, `wa`, `wm`, `group_w`, and `bot_mul` for `arch`, they are quantized thus inaccurate, using them sometimes produces different backbone that does not match the key in the pre-trained model. + +## Results and Models + +### Mask R-CNN + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :----------------------------------------------------------------------------------: | :-----: | :-----: | :------: | :------------: | :----: | :-----: | :-------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| [R-50-FPN](../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py) | pytorch | 1x | 4.4 | 12.0 | 38.2 | 34.7 | [config](../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_fpn_1x_coco/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_fpn_1x_coco/mask_rcnn_r50_fpn_1x_coco_20200205_050542.log.json) | +| [RegNetX-3.2GF-FPN](./mask-rcnn_regnetx-3.2GF_fpn_1x_coco.py) | pytorch | 1x | 5.0 | | 40.3 | 36.6 | [config](./mask-rcnn_regnetx-3.2GF_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-3.2GF_fpn_1x_coco/mask_rcnn_regnetx-3.2GF_fpn_1x_coco_20200520_163141-2a9d1814.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-3.2GF_fpn_1x_coco/mask_rcnn_regnetx-3.2GF_fpn_1x_coco_20200520_163141.log.json) | +| [RegNetX-4.0GF-FPN](./mask-rcnn_regnetx-4GF_fpn_1x_coco.py) | pytorch | 1x | 5.5 | | 41.5 | 37.4 | [config](./mask-rcnn_regnetx-4GF_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-4GF_fpn_1x_coco/mask_rcnn_regnetx-4GF_fpn_1x_coco_20200517_180217-32e9c92d.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-4GF_fpn_1x_coco/mask_rcnn_regnetx-4GF_fpn_1x_coco_20200517_180217.log.json) | +| [R-101-FPN](../mask_rcnn/mask-rcnn_r101_fpn_1x_coco.py) | pytorch | 1x | 6.4 | 10.3 | 40.0 | 36.1 | [config](../mask_rcnn/mask-rcnn_r101_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r101_fpn_1x_coco/mask_rcnn_r101_fpn_1x_coco_20200204-1efe0ed5.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r101_fpn_1x_coco/mask_rcnn_r101_fpn_1x_coco_20200204_144809.log.json) | +| [RegNetX-6.4GF-FPN](./mask-rcnn_regnetx-6.4GF_fpn_1x_coco.py) | pytorch | 1x | 6.1 | | 41.0 | 37.1 | [config](./mask-rcnn_regnetx-6.4GF_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-6.4GF_fpn_1x_coco/mask_rcnn_regnetx-6.4GF_fpn_1x_coco_20200517_180439-3a7aae83.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-6.4GF_fpn_1x_coco/mask_rcnn_regnetx-6.4GF_fpn_1x_coco_20200517_180439.log.json) | +| [X-101-32x4d-FPN](../mask_rcnn/mask-rcnn_x101-32x4d_fpn_1x_coco.py) | pytorch | 1x | 7.6 | 9.4 | 41.9 | 37.5 | [config](../mask_rcnn/mask-rcnn_x101-32x4d_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_32x4d_fpn_1x_coco/mask_rcnn_x101_32x4d_fpn_1x_coco_20200205-478d0b67.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_x101_32x4d_fpn_1x_coco/mask_rcnn_x101_32x4d_fpn_1x_coco_20200205_034906.log.json) | +| [RegNetX-8.0GF-FPN](./mask-rcnn_regnetx-8GF_fpn_1x_coco.py) | pytorch | 1x | 6.4 | | 41.7 | 37.5 | [config](./mask-rcnn_regnetx-8GF_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-8GF_fpn_1x_coco/mask_rcnn_regnetx-8GF_fpn_1x_coco_20200517_180515-09daa87e.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-8GF_fpn_1x_coco/mask_rcnn_regnetx-8GF_fpn_1x_coco_20200517_180515.log.json) | +| [RegNetX-12GF-FPN](./mask-rcnn_regnetx-12GF_fpn_1x_coco.py) | pytorch | 1x | 7.4 | | 42.2 | 38 | [config](./mask-rcnn_regnetx-12GF_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-12GF_fpn_1x_coco/mask_rcnn_regnetx-12GF_fpn_1x_coco_20200517_180552-b538bd8b.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-12GF_fpn_1x_coco/mask_rcnn_regnetx-12GF_fpn_1x_coco_20200517_180552.log.json) | +| [RegNetX-3.2GF-FPN-DCN-C3-C5](./mask-rcnn_regnetx-3.2GF-mdconv-c3-c5_fpn_1x_coco.py) | pytorch | 1x | 5.0 | | 40.3 | 36.6 | [config](./mask-rcnn_regnetx-3.2GF-mdconv-c3-c5_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-3.2GF_fpn_mdconv_c3-c5_1x_coco/mask_rcnn_regnetx-3.2GF_fpn_mdconv_c3-c5_1x_coco_20200520_172726-75f40794.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-3.2GF_fpn_mdconv_c3-c5_1x_coco/mask_rcnn_regnetx-3.2GF_fpn_mdconv_c3-c5_1x_coco_20200520_172726.log.json) | + +### Faster R-CNN + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :-------------------------------------------------------------: | :-----: | :-----: | :------: | :------------: | :----: | :-----------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| [R-50-FPN](../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py) | pytorch | 1x | 4.0 | 18.2 | 37.4 | [config](../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_1x_coco_20200130_204655.log.json) | +| [RegNetX-3.2GF-FPN](./faster-rcnn_regnetx-3.2GF_fpn_1x_coco.py) | pytorch | 1x | 4.5 | | 39.9 | [config](./faster-rcnn_regnetx-3.2GF_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/faster_rcnn_regnetx-3.2GF_fpn_1x_coco/faster_rcnn_regnetx-3.2GF_fpn_1x_coco_20200517_175927-126fd9bf.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/faster_rcnn_regnetx-3.2GF_fpn_1x_coco/faster_rcnn_regnetx-3.2GF_fpn_1x_coco_20200517_175927.log.json) | +| [RegNetX-3.2GF-FPN](./faster-rcnn_regnetx-3.2GF_fpn_2x_coco.py) | pytorch | 2x | 4.5 | | 41.1 | [config](./faster-rcnn_regnetx-3.2GF_fpn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/faster_rcnn_regnetx-3.2GF_fpn_2x_coco/faster_rcnn_regnetx-3.2GF_fpn_2x_coco_20200520_223955-e2081918.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/faster_rcnn_regnetx-3.2GF_fpn_2x_coco/faster_rcnn_regnetx-3.2GF_fpn_2x_coco_20200520_223955.log.json) | + +### RetinaNet + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :-----------------------------------------------------------: | :-----: | :-----: | :------: | :------------: | :----: | :-------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| [R-50-FPN](../retinanet/retinanet_r50_fpn_1x_coco.py) | pytorch | 1x | 3.8 | 16.6 | 36.5 | [config](../retinanet/retinanet_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r50_fpn_1x_coco/retinanet_r50_fpn_1x_coco_20200130-c2398f9e.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r50_fpn_1x_coco/retinanet_r50_fpn_1x_coco_20200130_002941.log.json) | +| [RegNetX-800MF-FPN](./retinanet_regnetx-800MF_fpn_1x_coco.py) | pytorch | 1x | 2.5 | | 35.6 | [config](./retinanet_regnetx-800MF_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/retinanet_regnetx-800MF_fpn_1x_coco/retinanet_regnetx-800MF_fpn_1x_coco_20200517_191403-f6f91d10.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/retinanet_regnetx-800MF_fpn_1x_coco/retinanet_regnetx-800MF_fpn_1x_coco_20200517_191403.log.json) | +| [RegNetX-1.6GF-FPN](./retinanet_regnetx-1.6GF_fpn_1x_coco.py) | pytorch | 1x | 3.3 | | 37.3 | [config](./retinanet_regnetx-1.6GF_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/retinanet_regnetx-1.6GF_fpn_1x_coco/retinanet_regnetx-1.6GF_fpn_1x_coco_20200517_191403-37009a9d.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/retinanet_regnetx-1.6GF_fpn_1x_coco/retinanet_regnetx-1.6GF_fpn_1x_coco_20200517_191403.log.json) | +| [RegNetX-3.2GF-FPN](./retinanet_regnetx-3.2GF_fpn_1x_coco.py) | pytorch | 1x | 4.2 | | 39.1 | [config](./retinanet_regnetx-3.2GF_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/retinanet_regnetx-3.2GF_fpn_1x_coco/retinanet_regnetx-3.2GF_fpn_1x_coco_20200520_163141-cb1509e8.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/retinanet_regnetx-3.2GF_fpn_1x_coco/retinanet_regnetx-3.2GF_fpn_1x_coco_20200520_163141.log.json) | + +### Pre-trained models + +We also train some models with longer schedules and multi-scale training. The users could finetune them for downstream tasks. + +| Method | Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :---------------: | :----------------------------------------------------------------------: | :-----: | :-----: | :------: | :------------: | :----: | :-----: | :-----------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| Faster RCNN | [RegNetX-400MF-FPN](./faster-rcnn_regnetx-400MF_fpn_ms-3x_coco.py) | pytorch | 3x | 2.3 | | 37.1 | - | [config](./faster-rcnn_regnetx-400MF_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/faster_rcnn_regnetx-400MF_fpn_mstrain_3x_coco/faster_rcnn_regnetx-400MF_fpn_mstrain_3x_coco_20210526_095112-e1967c37.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/faster_rcnn_regnetx-400MF_fpn_mstrain_3x_coco/faster_rcnn_regnetx-400MF_fpn_mstrain_3x_coco_20210526_095112.log.json) | +| Faster RCNN | [RegNetX-800MF-FPN](./faster-rcnn_regnetx-800MF_fpn_ms-3x_coco.py) | pytorch | 3x | 2.8 | | 38.8 | - | [config](./faster-rcnn_regnetx-800MF_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/faster_rcnn_regnetx-800MF_fpn_mstrain_3x_coco/faster_rcnn_regnetx-800MF_fpn_mstrain_3x_coco_20210526_095118-a2c70b20.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/faster_rcnn_regnetx-800MF_fpn_mstrain_3x_coco/faster_rcnn_regnetx-800MF_fpn_mstrain_3x_coco_20210526_095118.log.json) | +| Faster RCNN | [RegNetX-1.6GF-FPN](./faster-rcnn_regnetx-1.6GF_fpn_ms-3x_coco.py) | pytorch | 3x | 3.4 | | 40.5 | - | [config](./faster-rcnn_regnetx-1.6GF_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/faster_rcnn_regnetx-1.6GF_fpn_mstrain_3x_coco/faster_rcnn_regnetx-1_20210526_095325-94aa46cc.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/faster_rcnn_regnetx-1.6GF_fpn_mstrain_3x_coco/faster_rcnn_regnetx-1_20210526_095325.log.json) | +| Faster RCNN | [RegNetX-3.2GF-FPN](./faster-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py) | pytorch | 3x | 4.4 | | 42.3 | - | [config](./faster-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/faster_rcnn_regnetx-3.2GF_fpn_mstrain_3x_coco/faster_rcnn_regnetx-3_20210526_095152-e16a5227.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/faster_rcnn_regnetx-3.2GF_fpn_mstrain_3x_coco/faster_rcnn_regnetx-3_20210526_095152.log.json) | +| Faster RCNN | [RegNetX-4GF-FPN](./faster-rcnn_regnetx-4GF_fpn_ms-3x_coco.py) | pytorch | 3x | 4.9 | | 42.8 | - | [config](./faster-rcnn_regnetx-4GF_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/faster_rcnn_regnetx-4GF_fpn_mstrain_3x_coco/faster_rcnn_regnetx-4GF_fpn_mstrain_3x_coco_20210526_095201-65eaf841.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/faster_rcnn_regnetx-4GF_fpn_mstrain_3x_coco/faster_rcnn_regnetx-4GF_fpn_mstrain_3x_coco_20210526_095201.log.json) | +| Mask RCNN | [RegNetX-400MF-FPN](./mask-rcnn_regnetx-400MF_fpn_ms-poly-3x_coco.py) | pytorch | 3x | 2.5 | | 37.6 | 34.4 | [config](./mask-rcnn_regnetx-400MF_fpn_ms-poly-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-400MF_fpn_mstrain-poly_3x_coco/mask_rcnn_regnetx-400MF_fpn_mstrain-poly_3x_coco_20210601_235443-8aac57a4.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-400MF_fpn_mstrain-poly_3x_coco/mask_rcnn_regnetx-400MF_fpn_mstrain-poly_3x_coco_20210601_235443.log.json) | +| Mask RCNN | [RegNetX-800MF-FPN](./mask-rcnn_regnetx-800MF_fpn_ms-poly-3x_coco.py) | pytorch | 3x | 2.9 | | 39.5 | 36.1 | [config](./mask-rcnn_regnetx-800MF_fpn_ms-poly-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-800MF_fpn_mstrain-poly_3x_coco/mask_rcnn_regnetx-800MF_fpn_mstrain-poly_3x_coco_20210602_210641-715d51f5.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-800MF_fpn_mstrain-poly_3x_coco/mask_rcnn_regnetx-800MF_fpn_mstrain-poly_3x_coco_20210602_210641.log.json) | +| Mask RCNN | [RegNetX-1.6GF-FPN](./mask-rcnn_regnetx-1.6GF_fpn_ms-poly-3x_coco.py) | pytorch | 3x | 3.6 | | 40.9 | 37.5 | [config](./mask-rcnn_regnetx-1.6GF_fpn_ms-poly-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-1.6GF_fpn_mstrain-poly_3x_coco/mask_rcnn_regnetx-1_20210602_210641-6764cff5.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-1.6GF_fpn_mstrain-poly_3x_coco/mask_rcnn_regnetx-1_20210602_210641.log.json) | +| Mask RCNN | [RegNetX-3.2GF-FPN](./mask-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py) | pytorch | 3x | 5.0 | | 43.1 | 38.7 | [config](./mask-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-3.2GF_fpn_mstrain_3x_coco/mask_rcnn_regnetx-3.2GF_fpn_mstrain_3x_coco_20200521_202221-99879813.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-3.2GF_fpn_mstrain_3x_coco/mask_rcnn_regnetx-3.2GF_fpn_mstrain_3x_coco_20200521_202221.log.json) | +| Mask RCNN | [RegNetX-4GF-FPN](./mask-rcnn_regnetx-4GF_fpn_ms-poly-3x_coco.py) | pytorch | 3x | 5.1 | | 43.4 | 39.2 | [config](./mask-rcnn_regnetx-4GF_fpn_ms-poly-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-4GF_fpn_mstrain-poly_3x_coco/mask_rcnn_regnetx-4GF_fpn_mstrain-poly_3x_coco_20210602_032621-00f0331c.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-4GF_fpn_mstrain-poly_3x_coco/mask_rcnn_regnetx-4GF_fpn_mstrain-poly_3x_coco_20210602_032621.log.json) | +| Cascade Mask RCNN | [RegNetX-400MF-FPN](./cascade-mask-rcnn_regnetx-400MF_fpn_ms-3x_coco.py) | pytorch | 3x | 4.3 | | 41.6 | 36.4 | [config](./cascade-mask-rcnn_regnetx-400MF_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/cascade_mask_rcnn_regnetx-400MF_fpn_mstrain_3x_coco/cascade_mask_rcnn_regnetx-400MF_fpn_mstrain_3x_coco_20210715_211619-5142f449.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/cascade_mask_rcnn_regnetx-400MF_fpn_mstrain_3x_coco/cascade_mask_rcnn_regnetx-400MF_fpn_mstrain_3x_coco_20210715_211619.log.json) | +| Cascade Mask RCNN | [RegNetX-800MF-FPN](./cascade-mask-rcnn_regnetx-800MF_fpn_ms-3x_coco.py) | pytorch | 3x | 4.8 | | 42.8 | 37.6 | [config](./cascade-mask-rcnn_regnetx-800MF_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/cascade_mask_rcnn_regnetx-800MF_fpn_mstrain_3x_coco/cascade_mask_rcnn_regnetx-800MF_fpn_mstrain_3x_coco_20210715_211616-dcbd13f4.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/cascade_mask_rcnn_regnetx-800MF_fpn_mstrain_3x_coco/cascade_mask_rcnn_regnetx-800MF_fpn_mstrain_3x_coco_20210715_211616.log.json) | +| Cascade Mask RCNN | [RegNetX-1.6GF-FPN](./cascade-mask-rcnn_regnetx-1.6GF_fpn_ms-3x_coco.py) | pytorch | 3x | 5.4 | | 44.5 | 39.0 | [config](./cascade-mask-rcnn_regnetx-1.6GF_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/cascade_mask_rcnn_regnetx-1.6GF_fpn_mstrain_3x_coco/cascade_mask_rcnn_regnetx-1_20210715_211616-75f29a61.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/cascade_mask_rcnn_regnetx-1.6GF_fpn_mstrain_3x_coco/cascade_mask_rcnn_regnetx-1_20210715_211616.log.json) | +| Cascade Mask RCNN | [RegNetX-3.2GF-FPN](./cascade-mask-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py) | pytorch | 3x | 6.4 | | 45.8 | 40.0 | [config](./cascade-mask-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/cascade_mask_rcnn_regnetx-3.2GF_fpn_mstrain_3x_coco/cascade_mask_rcnn_regnetx-3_20210715_211616-b9c2c58b.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/cascade_mask_rcnn_regnetx-3.2GF_fpn_mstrain_3x_coco/cascade_mask_rcnn_regnetx-3_20210715_211616.log.json) | +| Cascade Mask RCNN | [RegNetX-4GF-FPN](./cascade-mask-rcnn_regnetx-4GF_fpn_ms-3x_coco.py) | pytorch | 3x | 6.9 | | 45.8 | 40.0 | [config](./cascade-mask-rcnn_regnetx-4GF_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/regnet/cascade_mask_rcnn_regnetx-4GF_fpn_mstrain_3x_coco/cascade_mask_rcnn_regnetx-4GF_fpn_mstrain_3x_coco_20210715_212034-cbb1be4c.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/regnet/cascade_mask_rcnn_regnetx-4GF_fpn_mstrain_3x_coco/cascade_mask_rcnn_regnetx-4GF_fpn_mstrain_3x_coco_20210715_212034.log.json) | + +### Notice + +1. The models are trained using a different weight decay, i.e., `weight_decay=5e-5` according to the setting in ImageNet training. This brings improvement of at least 0.7 AP absolute but does not improve the model using ResNet-50. +2. RetinaNets using RegNets are trained with learning rate 0.02 with gradient clip. We find that using learning rate 0.02 could improve the results by at least 0.7 AP absolute and gradient clip is necessary to stabilize the training. However, this does not improve the performance of ResNet-50-FPN RetinaNet. + +## Citation + +```latex +@article{radosavovic2020designing, + title={Designing Network Design Spaces}, + author={Ilija Radosavovic and Raj Prateek Kosaraju and Ross Girshick and Kaiming He and Piotr Dollár}, + year={2020}, + eprint={2003.13678}, + archivePrefix={arXiv}, + primaryClass={cs.CV} +} +``` diff --git a/mmdetection/configs/regnet/cascade-mask-rcnn_regnetx-1.6GF_fpn_ms-3x_coco.py b/mmdetection/configs/regnet/cascade-mask-rcnn_regnetx-1.6GF_fpn_ms-3x_coco.py new file mode 100644 index 00000000..74e6adab --- /dev/null +++ b/mmdetection/configs/regnet/cascade-mask-rcnn_regnetx-1.6GF_fpn_ms-3x_coco.py @@ -0,0 +1,17 @@ +_base_ = 'cascade-mask-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py' +model = dict( + backbone=dict( + type='RegNet', + arch='regnetx_1.6gf', + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_1.6gf')), + neck=dict( + type='FPN', + in_channels=[72, 168, 408, 912], + out_channels=256, + num_outs=5)) diff --git a/mmdetection/configs/regnet/cascade-mask-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py b/mmdetection/configs/regnet/cascade-mask-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py new file mode 100644 index 00000000..ea219021 --- /dev/null +++ b/mmdetection/configs/regnet/cascade-mask-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py @@ -0,0 +1,28 @@ +_base_ = [ + '../common/ms_3x_coco-instance.py', + '../_base_/models/cascade-mask-rcnn_r50_fpn.py' +] +model = dict( + data_preprocessor=dict( + # The mean and std are used in PyCls when training RegNets + mean=[103.53, 116.28, 123.675], + std=[57.375, 57.12, 58.395], + bgr_to_rgb=False), + backbone=dict( + _delete_=True, + type='RegNet', + arch='regnetx_3.2gf', + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_3.2gf')), + neck=dict( + type='FPN', + in_channels=[96, 192, 432, 1008], + out_channels=256, + num_outs=5)) + +optim_wrapper = dict(optimizer=dict(weight_decay=0.00005)) diff --git a/mmdetection/configs/regnet/cascade-mask-rcnn_regnetx-400MF_fpn_ms-3x_coco.py b/mmdetection/configs/regnet/cascade-mask-rcnn_regnetx-400MF_fpn_ms-3x_coco.py new file mode 100644 index 00000000..3fe47f83 --- /dev/null +++ b/mmdetection/configs/regnet/cascade-mask-rcnn_regnetx-400MF_fpn_ms-3x_coco.py @@ -0,0 +1,17 @@ +_base_ = 'cascade-mask-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py' +model = dict( + backbone=dict( + type='RegNet', + arch='regnetx_400mf', + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_400mf')), + neck=dict( + type='FPN', + in_channels=[32, 64, 160, 384], + out_channels=256, + num_outs=5)) diff --git a/mmdetection/configs/regnet/cascade-mask-rcnn_regnetx-4GF_fpn_ms-3x_coco.py b/mmdetection/configs/regnet/cascade-mask-rcnn_regnetx-4GF_fpn_ms-3x_coco.py new file mode 100644 index 00000000..e22886a8 --- /dev/null +++ b/mmdetection/configs/regnet/cascade-mask-rcnn_regnetx-4GF_fpn_ms-3x_coco.py @@ -0,0 +1,17 @@ +_base_ = 'cascade-mask-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py' +model = dict( + backbone=dict( + type='RegNet', + arch='regnetx_4.0gf', + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_4.0gf')), + neck=dict( + type='FPN', + in_channels=[80, 240, 560, 1360], + out_channels=256, + num_outs=5)) diff --git a/mmdetection/configs/regnet/cascade-mask-rcnn_regnetx-800MF_fpn_ms-3x_coco.py b/mmdetection/configs/regnet/cascade-mask-rcnn_regnetx-800MF_fpn_ms-3x_coco.py new file mode 100644 index 00000000..655bdc60 --- /dev/null +++ b/mmdetection/configs/regnet/cascade-mask-rcnn_regnetx-800MF_fpn_ms-3x_coco.py @@ -0,0 +1,17 @@ +_base_ = 'cascade-mask-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py' +model = dict( + backbone=dict( + type='RegNet', + arch='regnetx_800mf', + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_800mf')), + neck=dict( + type='FPN', + in_channels=[64, 128, 288, 672], + out_channels=256, + num_outs=5)) diff --git a/mmdetection/configs/regnet/faster-rcnn_regnetx-1.6GF_fpn_ms-3x_coco.py b/mmdetection/configs/regnet/faster-rcnn_regnetx-1.6GF_fpn_ms-3x_coco.py new file mode 100644 index 00000000..e9e8302b --- /dev/null +++ b/mmdetection/configs/regnet/faster-rcnn_regnetx-1.6GF_fpn_ms-3x_coco.py @@ -0,0 +1,17 @@ +_base_ = 'faster-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py' +model = dict( + backbone=dict( + type='RegNet', + arch='regnetx_1.6gf', + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_1.6gf')), + neck=dict( + type='FPN', + in_channels=[72, 168, 408, 912], + out_channels=256, + num_outs=5)) diff --git a/mmdetection/configs/regnet/faster-rcnn_regnetx-3.2GF_fpn_1x_coco.py b/mmdetection/configs/regnet/faster-rcnn_regnetx-3.2GF_fpn_1x_coco.py new file mode 100644 index 00000000..db49092e --- /dev/null +++ b/mmdetection/configs/regnet/faster-rcnn_regnetx-3.2GF_fpn_1x_coco.py @@ -0,0 +1,30 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +model = dict( + data_preprocessor=dict( + # The mean and std are used in PyCls when training RegNets + mean=[103.53, 116.28, 123.675], + std=[57.375, 57.12, 58.395], + bgr_to_rgb=False), + backbone=dict( + _delete_=True, + type='RegNet', + arch='regnetx_3.2gf', + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_3.2gf')), + neck=dict( + type='FPN', + in_channels=[96, 192, 432, 1008], + out_channels=256, + num_outs=5)) + +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.00005)) diff --git a/mmdetection/configs/regnet/faster-rcnn_regnetx-3.2GF_fpn_2x_coco.py b/mmdetection/configs/regnet/faster-rcnn_regnetx-3.2GF_fpn_2x_coco.py new file mode 100644 index 00000000..be533603 --- /dev/null +++ b/mmdetection/configs/regnet/faster-rcnn_regnetx-3.2GF_fpn_2x_coco.py @@ -0,0 +1,16 @@ +_base_ = './faster-rcnn_regnetx-3.2GF_fpn_1x_coco.py' + +# learning policy +max_epochs = 24 +train_cfg = dict(max_epochs=max_epochs) +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/regnet/faster-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py b/mmdetection/configs/regnet/faster-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py new file mode 100644 index 00000000..d3d5d5d6 --- /dev/null +++ b/mmdetection/configs/regnet/faster-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py @@ -0,0 +1,25 @@ +_base_ = ['../common/ms_3x_coco.py', '../_base_/models/faster-rcnn_r50_fpn.py'] +model = dict( + data_preprocessor=dict( + # The mean and std are used in PyCls when training RegNets + mean=[103.53, 116.28, 123.675], + std=[57.375, 57.12, 58.395], + bgr_to_rgb=False), + backbone=dict( + _delete_=True, + type='RegNet', + arch='regnetx_3.2gf', + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_3.2gf')), + neck=dict( + type='FPN', + in_channels=[96, 192, 432, 1008], + out_channels=256, + num_outs=5)) + +optim_wrapper = dict(optimizer=dict(weight_decay=0.00005)) diff --git a/mmdetection/configs/regnet/faster-rcnn_regnetx-400MF_fpn_ms-3x_coco.py b/mmdetection/configs/regnet/faster-rcnn_regnetx-400MF_fpn_ms-3x_coco.py new file mode 100644 index 00000000..2edeff9c --- /dev/null +++ b/mmdetection/configs/regnet/faster-rcnn_regnetx-400MF_fpn_ms-3x_coco.py @@ -0,0 +1,17 @@ +_base_ = 'faster-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py' +model = dict( + backbone=dict( + type='RegNet', + arch='regnetx_400mf', + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_400mf')), + neck=dict( + type='FPN', + in_channels=[32, 64, 160, 384], + out_channels=256, + num_outs=5)) diff --git a/mmdetection/configs/regnet/faster-rcnn_regnetx-4GF_fpn_ms-3x_coco.py b/mmdetection/configs/regnet/faster-rcnn_regnetx-4GF_fpn_ms-3x_coco.py new file mode 100644 index 00000000..afcbb5d5 --- /dev/null +++ b/mmdetection/configs/regnet/faster-rcnn_regnetx-4GF_fpn_ms-3x_coco.py @@ -0,0 +1,17 @@ +_base_ = 'faster-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py' +model = dict( + backbone=dict( + type='RegNet', + arch='regnetx_4.0gf', + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_4.0gf')), + neck=dict( + type='FPN', + in_channels=[80, 240, 560, 1360], + out_channels=256, + num_outs=5)) diff --git a/mmdetection/configs/regnet/faster-rcnn_regnetx-800MF_fpn_ms-3x_coco.py b/mmdetection/configs/regnet/faster-rcnn_regnetx-800MF_fpn_ms-3x_coco.py new file mode 100644 index 00000000..f659ec96 --- /dev/null +++ b/mmdetection/configs/regnet/faster-rcnn_regnetx-800MF_fpn_ms-3x_coco.py @@ -0,0 +1,17 @@ +_base_ = 'faster-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py' +model = dict( + backbone=dict( + type='RegNet', + arch='regnetx_800mf', + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_800mf')), + neck=dict( + type='FPN', + in_channels=[64, 128, 288, 672], + out_channels=256, + num_outs=5)) diff --git a/mmdetection/configs/regnet/mask-rcnn_regnetx-1.6GF_fpn_ms-poly-3x_coco.py b/mmdetection/configs/regnet/mask-rcnn_regnetx-1.6GF_fpn_ms-poly-3x_coco.py new file mode 100644 index 00000000..60874c66 --- /dev/null +++ b/mmdetection/configs/regnet/mask-rcnn_regnetx-1.6GF_fpn_ms-poly-3x_coco.py @@ -0,0 +1,26 @@ +_base_ = [ + '../common/ms-poly_3x_coco-instance.py', + '../_base_/models/mask-rcnn_r50_fpn.py' +] + +model = dict( + backbone=dict( + _delete_=True, + type='RegNet', + arch='regnetx_1.6gf', + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_1.6gf')), + neck=dict( + type='FPN', + in_channels=[72, 168, 408, 912], + out_channels=256, + num_outs=5)) + +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.00005), + clip_grad=dict(max_norm=35, norm_type=2)) diff --git a/mmdetection/configs/regnet/mask-rcnn_regnetx-12GF_fpn_1x_coco.py b/mmdetection/configs/regnet/mask-rcnn_regnetx-12GF_fpn_1x_coco.py new file mode 100644 index 00000000..e82cecea --- /dev/null +++ b/mmdetection/configs/regnet/mask-rcnn_regnetx-12GF_fpn_1x_coco.py @@ -0,0 +1,17 @@ +_base_ = './mask-rcnn_regnetx-3.2GF_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='RegNet', + arch='regnetx_12gf', + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_12gf')), + neck=dict( + type='FPN', + in_channels=[224, 448, 896, 2240], + out_channels=256, + num_outs=5)) diff --git a/mmdetection/configs/regnet/mask-rcnn_regnetx-3.2GF-mdconv-c3-c5_fpn_1x_coco.py b/mmdetection/configs/regnet/mask-rcnn_regnetx-3.2GF-mdconv-c3-c5_fpn_1x_coco.py new file mode 100644 index 00000000..c7c1d1ac --- /dev/null +++ b/mmdetection/configs/regnet/mask-rcnn_regnetx-3.2GF-mdconv-c3-c5_fpn_1x_coco.py @@ -0,0 +1,7 @@ +_base_ = 'mask-rcnn_regnetx-3.2GF_fpn_1x_coco.py' +model = dict( + backbone=dict( + dcn=dict(type='DCNv2', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_3.2gf'))) diff --git a/mmdetection/configs/regnet/mask-rcnn_regnetx-3.2GF_fpn_1x_coco.py b/mmdetection/configs/regnet/mask-rcnn_regnetx-3.2GF_fpn_1x_coco.py new file mode 100644 index 00000000..c52bf13f --- /dev/null +++ b/mmdetection/configs/regnet/mask-rcnn_regnetx-3.2GF_fpn_1x_coco.py @@ -0,0 +1,30 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +model = dict( + data_preprocessor=dict( + # The mean and std are used in PyCls when training RegNets + mean=[103.53, 116.28, 123.675], + std=[57.375, 57.12, 58.395], + bgr_to_rgb=False), + backbone=dict( + _delete_=True, + type='RegNet', + arch='regnetx_3.2gf', + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_3.2gf')), + neck=dict( + type='FPN', + in_channels=[96, 192, 432, 1008], + out_channels=256, + num_outs=5)) + +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.00005)) diff --git a/mmdetection/configs/regnet/mask-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py b/mmdetection/configs/regnet/mask-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py new file mode 100644 index 00000000..36482c93 --- /dev/null +++ b/mmdetection/configs/regnet/mask-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py @@ -0,0 +1,60 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +model = dict( + data_preprocessor=dict( + # The mean and std are used in PyCls when training RegNets + mean=[103.53, 116.28, 123.675], + std=[57.375, 57.12, 58.395], + bgr_to_rgb=False), + backbone=dict( + _delete_=True, + type='RegNet', + arch='regnetx_3.2gf', + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_3.2gf')), + neck=dict( + type='FPN', + in_channels=[96, 192, 432, 1008], + out_channels=256, + num_outs=5)) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736), + (1333, 768), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.00005), + clip_grad=dict(max_norm=35, norm_type=2)) + +# learning policy +max_epochs = 36 +train_cfg = dict(max_epochs=max_epochs) +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[28, 34], + gamma=0.1) +] diff --git a/mmdetection/configs/regnet/mask-rcnn_regnetx-400MF_fpn_ms-poly-3x_coco.py b/mmdetection/configs/regnet/mask-rcnn_regnetx-400MF_fpn_ms-poly-3x_coco.py new file mode 100644 index 00000000..b96e1921 --- /dev/null +++ b/mmdetection/configs/regnet/mask-rcnn_regnetx-400MF_fpn_ms-poly-3x_coco.py @@ -0,0 +1,26 @@ +_base_ = [ + '../common/ms-poly_3x_coco-instance.py', + '../_base_/models/mask-rcnn_r50_fpn.py' +] + +model = dict( + backbone=dict( + _delete_=True, + type='RegNet', + arch='regnetx_400mf', + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_400mf')), + neck=dict( + type='FPN', + in_channels=[32, 64, 160, 384], + out_channels=256, + num_outs=5)) + +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.00005), + clip_grad=dict(max_norm=35, norm_type=2)) diff --git a/mmdetection/configs/regnet/mask-rcnn_regnetx-4GF_fpn_1x_coco.py b/mmdetection/configs/regnet/mask-rcnn_regnetx-4GF_fpn_1x_coco.py new file mode 100644 index 00000000..ce9f8ef4 --- /dev/null +++ b/mmdetection/configs/regnet/mask-rcnn_regnetx-4GF_fpn_1x_coco.py @@ -0,0 +1,17 @@ +_base_ = './mask-rcnn_regnetx-3.2GF_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='RegNet', + arch='regnetx_4.0gf', + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_4.0gf')), + neck=dict( + type='FPN', + in_channels=[80, 240, 560, 1360], + out_channels=256, + num_outs=5)) diff --git a/mmdetection/configs/regnet/mask-rcnn_regnetx-4GF_fpn_ms-poly-3x_coco.py b/mmdetection/configs/regnet/mask-rcnn_regnetx-4GF_fpn_ms-poly-3x_coco.py new file mode 100644 index 00000000..f160ccf6 --- /dev/null +++ b/mmdetection/configs/regnet/mask-rcnn_regnetx-4GF_fpn_ms-poly-3x_coco.py @@ -0,0 +1,26 @@ +_base_ = [ + '../common/ms-poly_3x_coco-instance.py', + '../_base_/models/mask-rcnn_r50_fpn.py' +] + +model = dict( + backbone=dict( + _delete_=True, + type='RegNet', + arch='regnetx_4.0gf', + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_4.0gf')), + neck=dict( + type='FPN', + in_channels=[80, 240, 560, 1360], + out_channels=256, + num_outs=5)) + +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.00005), + clip_grad=dict(max_norm=35, norm_type=2)) diff --git a/mmdetection/configs/regnet/mask-rcnn_regnetx-6.4GF_fpn_1x_coco.py b/mmdetection/configs/regnet/mask-rcnn_regnetx-6.4GF_fpn_1x_coco.py new file mode 100644 index 00000000..e17a3d76 --- /dev/null +++ b/mmdetection/configs/regnet/mask-rcnn_regnetx-6.4GF_fpn_1x_coco.py @@ -0,0 +1,17 @@ +_base_ = './mask-rcnn_regnetx-3.2GF_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='RegNet', + arch='regnetx_6.4gf', + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_6.4gf')), + neck=dict( + type='FPN', + in_channels=[168, 392, 784, 1624], + out_channels=256, + num_outs=5)) diff --git a/mmdetection/configs/regnet/mask-rcnn_regnetx-800MF_fpn_ms-poly-3x_coco.py b/mmdetection/configs/regnet/mask-rcnn_regnetx-800MF_fpn_ms-poly-3x_coco.py new file mode 100644 index 00000000..93851fdb --- /dev/null +++ b/mmdetection/configs/regnet/mask-rcnn_regnetx-800MF_fpn_ms-poly-3x_coco.py @@ -0,0 +1,26 @@ +_base_ = [ + '../common/ms-poly_3x_coco-instance.py', + '../_base_/models/mask-rcnn_r50_fpn.py' +] + +model = dict( + backbone=dict( + _delete_=True, + type='RegNet', + arch='regnetx_800mf', + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_800mf')), + neck=dict( + type='FPN', + in_channels=[64, 128, 288, 672], + out_channels=256, + num_outs=5)) + +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.00005), + clip_grad=dict(max_norm=35, norm_type=2)) diff --git a/mmdetection/configs/regnet/mask-rcnn_regnetx-8GF_fpn_1x_coco.py b/mmdetection/configs/regnet/mask-rcnn_regnetx-8GF_fpn_1x_coco.py new file mode 100644 index 00000000..62a4c931 --- /dev/null +++ b/mmdetection/configs/regnet/mask-rcnn_regnetx-8GF_fpn_1x_coco.py @@ -0,0 +1,17 @@ +_base_ = './mask-rcnn_regnetx-3.2GF_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='RegNet', + arch='regnetx_8.0gf', + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_8.0gf')), + neck=dict( + type='FPN', + in_channels=[80, 240, 720, 1920], + out_channels=256, + num_outs=5)) diff --git a/mmdetection/configs/regnet/metafile.yml b/mmdetection/configs/regnet/metafile.yml new file mode 100644 index 00000000..19fbba80 --- /dev/null +++ b/mmdetection/configs/regnet/metafile.yml @@ -0,0 +1,797 @@ +Models: + - Name: mask-rcnn_regnetx-3.2GF_fpn_1x_coco + In Collection: Mask R-CNN + Config: configs/regnet/mask-rcnn_regnetx-3.2GF_fpn_1x_coco.py + Metadata: + Training Memory (GB): 5.0 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.3 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-3.2GF_fpn_1x_coco/mask_rcnn_regnetx-3.2GF_fpn_1x_coco_20200520_163141-2a9d1814.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: mask-rcnn_regnetx-4GF_fpn_1x_coco + In Collection: Mask R-CNN + Config: configs/regnet/mask-rcnn_regnetx-4GF_fpn_1x_coco.py + Metadata: + Training Memory (GB): 5.5 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.5 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-4GF_fpn_1x_coco/mask_rcnn_regnetx-4GF_fpn_1x_coco_20200517_180217-32e9c92d.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: mask-rcnn_regnetx-6.4GF_fpn_1x_coco + In Collection: Mask R-CNN + Config: configs/regnet/mask-rcnn_regnetx-6.4GF_fpn_1x_coco.py + Metadata: + Training Memory (GB): 6.1 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.0 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-6.4GF_fpn_1x_coco/mask_rcnn_regnetx-6.4GF_fpn_1x_coco_20200517_180439-3a7aae83.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: mask-rcnn_regnetx-8GF_fpn_1x_coco + In Collection: Mask R-CNN + Config: configs/regnet/mask-rcnn_regnetx-8GF_fpn_1x_coco.py + Metadata: + Training Memory (GB): 6.4 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.7 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-8GF_fpn_1x_coco/mask_rcnn_regnetx-8GF_fpn_1x_coco_20200517_180515-09daa87e.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: mask-rcnn_regnetx-12GF_fpn_1x_coco + In Collection: Mask R-CNN + Config: configs/regnet/mask-rcnn_regnetx-12GF_fpn_1x_coco.py + Metadata: + Training Memory (GB): 7.4 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.2 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-12GF_fpn_1x_coco/mask_rcnn_regnetx-12GF_fpn_1x_coco_20200517_180552-b538bd8b.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: mask-rcnn_regnetx-3.2GF-mdconv-c3-c5_fpn_1x_coco + In Collection: Mask R-CNN + Config: configs/regnet/mask-rcnn_regnetx-3.2GF-mdconv-c3-c5_fpn_1x_coco.py + Metadata: + Training Memory (GB): 5.0 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.3 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-3.2GF_fpn_mdconv_c3-c5_1x_coco/mask_rcnn_regnetx-3.2GF_fpn_mdconv_c3-c5_1x_coco_20200520_172726-75f40794.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: faster-rcnn_regnetx-3.2GF_fpn_1x_coco + In Collection: Faster R-CNN + Config: configs/regnet/faster-rcnn_regnetx-3.2GF_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.5 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/faster_rcnn_regnetx-3.2GF_fpn_1x_coco/faster_rcnn_regnetx-3.2GF_fpn_1x_coco_20200517_175927-126fd9bf.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: faster-rcnn_regnetx-3.2GF_fpn_2x_coco + In Collection: Faster R-CNN + Config: configs/regnet/faster-rcnn_regnetx-3.2GF_fpn_2x_coco.py + Metadata: + Training Memory (GB): 4.5 + Epochs: 24 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/faster_rcnn_regnetx-3.2GF_fpn_2x_coco/faster_rcnn_regnetx-3.2GF_fpn_2x_coco_20200520_223955-e2081918.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: retinanet_regnetx-800MF_fpn_1x_coco + In Collection: RetinaNet + Config: configs/regnet/retinanet_regnetx-800MF_fpn_1x_coco.py + Metadata: + Training Memory (GB): 2.5 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 35.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/retinanet_regnetx-800MF_fpn_1x_coco/retinanet_regnetx-800MF_fpn_1x_coco_20200517_191403-f6f91d10.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: retinanet_regnetx-1.6GF_fpn_1x_coco + In Collection: RetinaNet + Config: configs/regnet/retinanet_regnetx-1.6GF_fpn_1x_coco.py + Metadata: + Training Memory (GB): 3.3 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/retinanet_regnetx-1.6GF_fpn_1x_coco/retinanet_regnetx-1.6GF_fpn_1x_coco_20200517_191403-37009a9d.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: retinanet_regnetx-3.2GF_fpn_1x_coco + In Collection: RetinaNet + Config: configs/regnet/retinanet_regnetx-3.2GF_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.2 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/retinanet_regnetx-3.2GF_fpn_1x_coco/retinanet_regnetx-3.2GF_fpn_1x_coco_20200520_163141-cb1509e8.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: faster-rcnn_regnetx-400MF_fpn_ms-3x_coco + In Collection: Faster R-CNN + Config: configs/regnet/faster-rcnn_regnetx-400MF_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 2.3 + Epochs: 36 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/faster_rcnn_regnetx-400MF_fpn_mstrain_3x_coco/faster_rcnn_regnetx-400MF_fpn_mstrain_3x_coco_20210526_095112-e1967c37.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: faster-rcnn_regnetx-800MF_fpn_ms-3x_coco + In Collection: Faster R-CNN + Config: configs/regnet/faster-rcnn_regnetx-800MF_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 2.8 + Epochs: 36 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/faster_rcnn_regnetx-800MF_fpn_mstrain_3x_coco/faster_rcnn_regnetx-800MF_fpn_mstrain_3x_coco_20210526_095118-a2c70b20.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: faster-rcnn_regnetx-1.6GF_fpn_ms-3x_coco + In Collection: Faster R-CNN + Config: configs/regnet/faster-rcnn_regnetx-1.6GF_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 3.4 + Epochs: 36 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/faster_rcnn_regnetx-1.6GF_fpn_mstrain_3x_coco/faster_rcnn_regnetx-1_20210526_095325-94aa46cc.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: faster-rcnn_regnetx-3.2GF_fpn_ms-3x_coco + In Collection: Faster R-CNN + Config: configs/regnet/faster-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 4.4 + Epochs: 36 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/faster_rcnn_regnetx-3.2GF_fpn_mstrain_3x_coco/faster_rcnn_regnetx-3_20210526_095152-e16a5227.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: faster-rcnn_regnetx-4GF_fpn_ms-3x_coco + In Collection: Faster R-CNN + Config: configs/regnet/faster-rcnn_regnetx-4GF_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 4.9 + Epochs: 36 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/faster_rcnn_regnetx-4GF_fpn_mstrain_3x_coco/faster_rcnn_regnetx-4GF_fpn_mstrain_3x_coco_20210526_095201-65eaf841.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: mask-rcnn_regnetx-3.2GF_fpn_ms-3x_coco + In Collection: Mask R-CNN + Config: configs/regnet/mask-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 5.0 + Epochs: 36 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.1 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-3.2GF_fpn_mstrain_3x_coco/mask_rcnn_regnetx-3.2GF_fpn_mstrain_3x_coco_20200521_202221-99879813.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: mask-rcnn_regnetx-400MF_fpn_ms-poly-3x_coco + In Collection: Mask R-CNN + Config: configs/regnet/mask-rcnn_regnetx-400MF_fpn_ms-poly-3x_coco.py + Metadata: + Training Memory (GB): 2.5 + Epochs: 36 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.6 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 34.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-400MF_fpn_mstrain-poly_3x_coco/mask_rcnn_regnetx-400MF_fpn_mstrain-poly_3x_coco_20210601_235443-8aac57a4.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: mask-rcnn_regnetx-800MF_fpn_ms-poly-3x_coco + In Collection: Mask R-CNN + Config: configs/regnet/mask-rcnn_regnetx-800MF_fpn_ms-poly-3x_coco.py + Metadata: + Training Memory (GB): 2.9 + Epochs: 36 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.5 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-800MF_fpn_mstrain-poly_3x_coco/mask_rcnn_regnetx-800MF_fpn_mstrain-poly_3x_coco_20210602_210641-715d51f5.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: mask-rcnn_regnetx-1.6GF_fpn_ms-poly-3x_coco + In Collection: Mask R-CNN + Config: configs/regnet/mask-rcnn_regnetx-1.6GF_fpn_ms-poly-3x_coco.py + Metadata: + Training Memory (GB): 3.6 + Epochs: 36 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.9 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-1.6GF_fpn_mstrain-poly_3x_coco/mask_rcnn_regnetx-1_20210602_210641-6764cff5.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: mask-rcnn_regnetx-3.2GF_fpn_ms-3x_coco + In Collection: Mask R-CNN + Config: configs/regnet/mask-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 5.0 + Epochs: 36 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.1 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-3.2GF_fpn_mstrain_3x_coco/mask_rcnn_regnetx-3.2GF_fpn_mstrain_3x_coco_20200521_202221-99879813.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: mask-rcnn_regnetx-4GF_fpn_ms-poly-3x_coco + In Collection: Mask R-CNN + Config: configs/regnet/mask-rcnn_regnetx-4GF_fpn_ms-poly-3x_coco.py + Metadata: + Training Memory (GB): 5.1 + Epochs: 36 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.4 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/mask_rcnn_regnetx-4GF_fpn_mstrain-poly_3x_coco/mask_rcnn_regnetx-4GF_fpn_mstrain-poly_3x_coco_20210602_032621-00f0331c.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: cascade-mask-rcnn_regnetx-400MF_fpn_ms-3x_coco + In Collection: Cascade R-CNN + Config: configs/regnet/cascade-mask-rcnn_regnetx-400MF_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 4.3 + Epochs: 36 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.6 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/cascade_mask_rcnn_regnetx-400MF_fpn_mstrain_3x_coco/cascade_mask_rcnn_regnetx-400MF_fpn_mstrain_3x_coco_20210715_211619-5142f449.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: cascade-mask-rcnn_regnetx-800MF_fpn_ms-3x_coco + In Collection: Cascade R-CNN + Config: configs/regnet/cascade-mask-rcnn_regnetx-800MF_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 4.8 + Epochs: 36 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/cascade_mask_rcnn_regnetx-800MF_fpn_mstrain_3x_coco/cascade_mask_rcnn_regnetx-800MF_fpn_mstrain_3x_coco_20210715_211616-dcbd13f4.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: cascade-mask-rcnn_regnetx-1.6GF_fpn_ms-3x_coco + In Collection: Cascade R-CNN + Config: configs/regnet/cascade-mask-rcnn_regnetx-1.6GF_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 5.4 + Epochs: 36 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.5 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/cascade_mask_rcnn_regnetx-1.6GF_fpn_mstrain_3x_coco/cascade_mask_rcnn_regnetx-1_20210715_211616-75f29a61.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: cascade-mask-rcnn_regnetx-3.2GF_fpn_ms-3x_coco + In Collection: Cascade R-CNN + Config: configs/regnet/cascade-mask-rcnn_regnetx-3.2GF_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 6.4 + Epochs: 36 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 40.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/cascade_mask_rcnn_regnetx-3.2GF_fpn_mstrain_3x_coco/cascade_mask_rcnn_regnetx-3_20210715_211616-b9c2c58b.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 + + - Name: cascade-mask-rcnn_regnetx-4GF_fpn_ms-3x_coco + In Collection: Cascade R-CNN + Config: configs/regnet/cascade-mask-rcnn_regnetx-4GF_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 6.9 + Epochs: 36 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - RegNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 40.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/regnet/cascade_mask_rcnn_regnetx-4GF_fpn_mstrain_3x_coco/cascade_mask_rcnn_regnetx-4GF_fpn_mstrain_3x_coco_20210715_212034-cbb1be4c.pth + Paper: + URL: https://arxiv.org/abs/2003.13678 + Title: 'Designing Network Design Spaces' + README: configs/regnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/regnet.py#L11 + Version: v2.1.0 diff --git a/mmdetection/configs/regnet/retinanet_regnetx-1.6GF_fpn_1x_coco.py b/mmdetection/configs/regnet/retinanet_regnetx-1.6GF_fpn_1x_coco.py new file mode 100644 index 00000000..7395c1bf --- /dev/null +++ b/mmdetection/configs/regnet/retinanet_regnetx-1.6GF_fpn_1x_coco.py @@ -0,0 +1,17 @@ +_base_ = './retinanet_regnetx-3.2GF_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='RegNet', + arch='regnetx_1.6gf', + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_1.6gf')), + neck=dict( + type='FPN', + in_channels=[72, 168, 408, 912], + out_channels=256, + num_outs=5)) diff --git a/mmdetection/configs/regnet/retinanet_regnetx-3.2GF_fpn_1x_coco.py b/mmdetection/configs/regnet/retinanet_regnetx-3.2GF_fpn_1x_coco.py new file mode 100644 index 00000000..8b8a32ce --- /dev/null +++ b/mmdetection/configs/regnet/retinanet_regnetx-3.2GF_fpn_1x_coco.py @@ -0,0 +1,31 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +model = dict( + data_preprocessor=dict( + # The mean and std are used in PyCls when training RegNets + mean=[103.53, 116.28, 123.675], + std=[57.375, 57.12, 58.395], + bgr_to_rgb=False), + backbone=dict( + _delete_=True, + type='RegNet', + arch='regnetx_3.2gf', + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_3.2gf')), + neck=dict( + type='FPN', + in_channels=[96, 192, 432, 1008], + out_channels=256, + num_outs=5)) + +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.00005), + clip_grad=dict(max_norm=35, norm_type=2)) diff --git a/mmdetection/configs/regnet/retinanet_regnetx-800MF_fpn_1x_coco.py b/mmdetection/configs/regnet/retinanet_regnetx-800MF_fpn_1x_coco.py new file mode 100644 index 00000000..f6f89893 --- /dev/null +++ b/mmdetection/configs/regnet/retinanet_regnetx-800MF_fpn_1x_coco.py @@ -0,0 +1,17 @@ +_base_ = './retinanet_regnetx-3.2GF_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='RegNet', + arch='regnetx_800mf', + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://regnetx_800mf')), + neck=dict( + type='FPN', + in_channels=[64, 128, 288, 672], + out_channels=256, + num_outs=5)) diff --git a/mmdetection/configs/reid/README.md b/mmdetection/configs/reid/README.md new file mode 100644 index 00000000..a5bfe5ec --- /dev/null +++ b/mmdetection/configs/reid/README.md @@ -0,0 +1,135 @@ +# Training a ReID Model + +You may want to train a ReID model for multiple object tracking or other applications. We support ReID model training in MMDetection, which is built upon [MMPretrain](https://github.com/open-mmlab/mmpretrain). + +### 1. Development Environment Setup + +Tracking Development Environment Setup can refer to this [document](../../docs/en/get_started.md). + +### 2. Dataset Preparation + +This section will show how to train a ReID model on standard datasets i.e. MOT17. + +We need to download datasets following docs. We use [ReIDDataset](mmdet/datasets/reid_dataset.py) to maintain standard datasets. In this case, you need to convert the official dataset to this style. We provide scripts and the usages as follow: + +```python +python tools/dataset_converters/mot2reid.py -i ./data/MOT17/ -o ./data/MOT17/reid --val-split 0.2 --vis-threshold 0.3 +``` + +Arguments: + +- `--val-split`: Proportion of the validation dataset to the whole ReID dataset. +- `--vis-threshold`: Threshold of visibility for each person. + +The directory of the converted datasets is as follows: + +``` +MOT17 +├── train +├── test +├── reid +│ ├── imgs +│ │ ├── MOT17-02-FRCNN_000002 +│ │ │ ├── 000000.jpg +│ │ │ ├── 000001.jpg +│ │ │ ├── ... +│ │ ├── MOT17-02-FRCNN_000003 +│ │ │ ├── 000000.jpg +│ │ │ ├── 000001.jpg +│ │ │ ├── ... +│ ├── meta +│ │ ├── train_80.txt +│ │ ├── val_20.txt +``` + +Note: `80` in `train_80.txt` means the proportion of the training dataset to the whole ReID dataset is eighty percent. While the proportion of the validation dataset is twenty percent. + +For training, we provide a annotation list `train_80.txt`. Each line of the list constraints a filename and its corresponding ground-truth labels. The format is as follows: + +``` +MOT17-05-FRCNN_000110/000018.jpg 0 +MOT17-13-FRCNN_000146/000014.jpg 1 +MOT17-05-FRCNN_000088/000004.jpg 2 +MOT17-02-FRCNN_000009/000081.jpg 3 +``` + +For validation, The annotation list `val_20.txt` remains the same as format above. + +Note: Images in `MOT17/reid/imgs` are cropped from raw images in `MOT17/train` by the corresponding `gt.txt`. The value of ground-truth labels should fall in range `[0, num_classes - 1]`. + +### 3. Training + +#### Training on a single GPU + +```shell +python tools/train.py configs/reid/reid_r50_8xb32-6e_mot17train80_test-mot17val20.py +``` + +#### Training on multiple GPUs + +We provide `tools/dist_train.sh` to launch training on multiple GPUs. +The basic usage is as follows. + +```shell +bash tools/dist_train.sh configs/reid/reid_r50_8xb32-6e_mot17train80_test-mot17val20.py 8 +``` + +### 4. Customize Dataset + +This section will show how to train a ReID model on customize datasets. + +### 4.1 Dataset Preparation + +You need to convert your customize datasets to existing dataset format. + +#### An example of customized dataset + +Assume we are going to implement a `Filelist` dataset, which takes filelists for both training and testing. The directory of the dataset is as follows: + +``` +Filelist +├── imgs +│ ├── person1 +│ │ ├── 000000.jpg +│ │ ├── 000001.jpg +│ │ ├── ... +│ ├── person2 +│ │ ├── 000000.jpg +│ │ ├── 000001.jpg +│ │ ├── ... +├── meta +│ ├── train.txt +│ ├── val.txt +``` + +The format of annotation list is as follows: + +``` +person1/000000.jpg 0 +person1/000001.jpg 0 +person2/000000.jpg 1 +person2/000001.jpg 1 +``` + +You can directly use [ReIDDataset](mmdet/datasets/reid_dataset.py). In this case, you only need to modify the config as follows: + +```python +# modify the path of annotation files and the image path prefix +data = dict( + train=dict( + data_prefix='data/Filelist/imgs', + ann_file='data/Filelist/meta/train.txt'), + val=dict( + data_prefix='data/Filelist/imgs', + ann_file='data/Filelist/meta/val.txt'), + test=dict( + data_prefix='data/Filelist/imgs', + ann_file='data/Filelist/meta/val.txt'), +) +# modify the number of classes, assume your training set has 100 classes +model = dict(reid=dict(head=dict(num_classes=100))) +``` + +### 4.2 Training + +The training stage is the same as `Standard Dataset`. diff --git a/mmdetection/configs/reid/reid_r50_8xb32-6e_mot15train80_test-mot15val20.py b/mmdetection/configs/reid/reid_r50_8xb32-6e_mot15train80_test-mot15val20.py new file mode 100644 index 00000000..4e30b229 --- /dev/null +++ b/mmdetection/configs/reid/reid_r50_8xb32-6e_mot15train80_test-mot15val20.py @@ -0,0 +1,7 @@ +_base_ = ['./reid_r50_8xb32-6e_mot17train80_test-mot17val20.py'] +model = dict(head=dict(num_classes=368)) +# data +data_root = 'data/MOT15/' +train_dataloader = dict(dataset=dict(data_root=data_root)) +val_dataloader = dict(dataset=dict(data_root=data_root)) +test_dataloader = val_dataloader diff --git a/mmdetection/configs/reid/reid_r50_8xb32-6e_mot16train80_test-mot16val20.py b/mmdetection/configs/reid/reid_r50_8xb32-6e_mot16train80_test-mot16val20.py new file mode 100644 index 00000000..468b9bfb --- /dev/null +++ b/mmdetection/configs/reid/reid_r50_8xb32-6e_mot16train80_test-mot16val20.py @@ -0,0 +1,7 @@ +_base_ = ['./reid_r50_8xb32-6e_mot17train80_test-mot17val20.py'] +model = dict(head=dict(num_classes=371)) +# data +data_root = 'data/MOT16/' +train_dataloader = dict(dataset=dict(data_root=data_root)) +val_dataloader = dict(dataset=dict(data_root=data_root)) +test_dataloader = val_dataloader diff --git a/mmdetection/configs/reid/reid_r50_8xb32-6e_mot17train80_test-mot17val20.py b/mmdetection/configs/reid/reid_r50_8xb32-6e_mot17train80_test-mot17val20.py new file mode 100644 index 00000000..83669de7 --- /dev/null +++ b/mmdetection/configs/reid/reid_r50_8xb32-6e_mot17train80_test-mot17val20.py @@ -0,0 +1,61 @@ +_base_ = [ + '../_base_/datasets/mot_challenge_reid.py', '../_base_/default_runtime.py' +] +model = dict( + type='BaseReID', + data_preprocessor=dict( + type='ReIDDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + to_rgb=True), + backbone=dict( + type='mmpretrain.ResNet', + depth=50, + num_stages=4, + out_indices=(3, ), + style='pytorch'), + neck=dict(type='GlobalAveragePooling', kernel_size=(8, 4), stride=1), + head=dict( + type='LinearReIDHead', + num_fcs=1, + in_channels=2048, + fc_channels=1024, + out_channels=128, + num_classes=380, + loss_cls=dict(type='mmpretrain.CrossEntropyLoss', loss_weight=1.0), + loss_triplet=dict(type='TripletLoss', margin=0.3, loss_weight=1.0), + norm_cfg=dict(type='BN1d'), + act_cfg=dict(type='ReLU')), + init_cfg=dict( + type='Pretrained', + checkpoint= # noqa: E251 + 'https://download.openmmlab.com/mmclassification/v0/resnet/resnet50_batch256_imagenet_20200708-cfb998bf.pth' # noqa: E501 + )) + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + clip_grad=None, + optimizer=dict(type='SGD', lr=0.1, momentum=0.9, weight_decay=0.0001)) + +# learning policy +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0 / 1000, + by_epoch=False, + begin=0, + end=1000), + dict( + type='MultiStepLR', + begin=0, + end=6, + by_epoch=True, + milestones=[5], + gamma=0.1) +] + +# train, val, test setting +train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=6, val_interval=1) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') diff --git a/mmdetection/configs/reid/reid_r50_8xb32-6e_mot20train80_test-mot20val20.py b/mmdetection/configs/reid/reid_r50_8xb32-6e_mot20train80_test-mot20val20.py new file mode 100644 index 00000000..8a807996 --- /dev/null +++ b/mmdetection/configs/reid/reid_r50_8xb32-6e_mot20train80_test-mot20val20.py @@ -0,0 +1,10 @@ +_base_ = ['./reid_r50_8xb32-6e_mot17train80_test-mot17val20.py'] +model = dict(head=dict(num_classes=1701)) +# data +data_root = 'data/MOT20/' +train_dataloader = dict(dataset=dict(data_root=data_root)) +val_dataloader = dict(dataset=dict(data_root=data_root)) +test_dataloader = val_dataloader + +# train, val, test setting +train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=6, val_interval=7) diff --git a/mmdetection/configs/reppoints/README.md b/mmdetection/configs/reppoints/README.md new file mode 100644 index 00000000..03cb86be --- /dev/null +++ b/mmdetection/configs/reppoints/README.md @@ -0,0 +1,59 @@ +# RepPoints + +> [RepPoints: Point Set Representation for Object Detection](https://arxiv.org/abs/1904.11490) + + + +## Abstract + +Modern object detectors rely heavily on rectangular bounding boxes, such as anchors, proposals and the final predictions, to represent objects at various recognition stages. The bounding box is convenient to use but provides only a coarse localization of objects and leads to a correspondingly coarse extraction of object features. In this paper, we present RepPoints(representative points), a new finer representation of objects as a set of sample points useful for both localization and recognition. Given ground truth localization and recognition targets for training, RepPoints learn to automatically arrange themselves in a manner that bounds the spatial extent of an object and indicates semantically significant local areas. They furthermore do not require the use of anchors to sample a space of bounding boxes. We show that an anchor-free object detector based on RepPoints can be as effective as the state-of-the-art anchor-based detection methods, with 46.5 AP and 67.4 AP50 on the COCO test-dev detection benchmark, using ResNet-101 model. + +
    + +
    + +## Introdution + +By [Ze Yang](https://yangze.tech/), [Shaohui Liu](http://b1ueber2y.me/), and [Han Hu](https://ancientmooner.github.io/). + +We provide code support and configuration files to reproduce the results in the paper for +["RepPoints: Point Set Representation for Object Detection"](https://arxiv.org/abs/1904.11490) on COCO object detection. + +**RepPoints**, initially described in [arXiv](https://arxiv.org/abs/1904.11490), is a new representation method for visual objects, on which visual understanding tasks are typically centered. Visual object representation, aiming at both geometric description and appearance feature extraction, is conventionally achieved by `bounding box + RoIPool (RoIAlign)`. The bounding box representation is convenient to use; however, it provides only a rectangular localization of objects that lacks geometric precision and may consequently degrade feature quality. Our new representation, RepPoints, models objects by a `point set` instead of a `bounding box`, which learns to adaptively position themselves over an object in a manner that circumscribes the object’s `spatial extent` and enables `semantically aligned feature extraction`. This richer and more flexible representation maintains the convenience of bounding boxes while facilitating various visual understanding applications. This repo demonstrated the effectiveness of RepPoints for COCO object detection. + +Another feature of this repo is the demonstration of an `anchor-free detector`, which can be as effective as state-of-the-art anchor-based detection methods. The anchor-free detector can utilize either `bounding box` or `RepPoints` as the basic object representation. + +## Results and Models + +The results on COCO 2017val are shown in the table below. + +| Method | Backbone | GN | Anchor | convert func | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :-------: | :-----------: | :-: | :----: | :----------: | :-----: | :------: | :------------: | :----: | :---------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| BBox | R-50-FPN | Y | single | - | 1x | 3.9 | 15.9 | 36.4 | [config](./reppoints-bbox_r50_fpn-gn_head-gn-grid_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/reppoints/bbox_r50_grid_fpn_gn-neck%2Bhead_1x_coco/bbox_r50_grid_fpn_gn-neck%2Bhead_1x_coco_20200329_145916-0eedf8d1.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/reppoints/bbox_r50_grid_fpn_gn-neck%2Bhead_1x_coco/bbox_r50_grid_fpn_gn-neck%2Bhead_1x_coco_20200329_145916.log.json) | +| BBox | R-50-FPN | Y | none | - | 1x | 3.9 | 15.4 | 37.4 | [config](./reppoints-bbox_r50-center_fpn-gn_head-gn-grid_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/reppoints/bbox_r50_grid_fpn_gn-neck%2Bhead_1x_coco/bbox_r50_grid_fpn_gn-neck%2Bhead_1x_coco_20200329_145916-0eedf8d1.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/reppoints/bbox_r50_grid_fpn_gn-neck%2Bhead_1x_coco/bbox_r50_grid_fpn_gn-neck%2Bhead_1x_coco_20200329_145916.log.json) | +| RepPoints | R-50-FPN | N | none | moment | 1x | 3.3 | 18.5 | 37.0 | [config](./reppoints-moment_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r50_fpn_1x_coco/reppoints_moment_r50_fpn_1x_coco_20200330-b73db8d1.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r50_fpn_1x_coco/reppoints_moment_r50_fpn_1x_coco_20200330_233609.log.json) | +| RepPoints | R-50-FPN | Y | none | moment | 1x | 3.9 | 17.5 | 38.1 | [config](./reppoints-moment_r50_fpn-gn_head-gn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r50_fpn_gn-neck%2Bhead_1x_coco/reppoints_moment_r50_fpn_gn-neck%2Bhead_1x_coco_20200329_145952-3e51b550.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r50_fpn_gn-neck%2Bhead_1x_coco/reppoints_moment_r50_fpn_gn-neck%2Bhead_1x_coco_20200329_145952.log.json) | +| RepPoints | R-50-FPN | Y | none | moment | 2x | 3.9 | - | 38.6 | [config](./reppoints-moment_r50_fpn-gn_head-gn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r50_fpn_gn-neck%2Bhead_2x_coco/reppoints_moment_r50_fpn_gn-neck%2Bhead_2x_coco_20200329-91babaa2.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r50_fpn_gn-neck%2Bhead_2x_coco/reppoints_moment_r50_fpn_gn-neck%2Bhead_2x_coco_20200329_150020.log.json) | +| RepPoints | R-101-FPN | Y | none | moment | 2x | 5.8 | 13.7 | 40.5 | [config](./reppoints-moment_r101_fpn-gn_head-gn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r101_fpn_gn-neck%2Bhead_2x_coco/reppoints_moment_r101_fpn_gn-neck%2Bhead_2x_coco_20200329-4fbc7310.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r101_fpn_gn-neck%2Bhead_2x_coco/reppoints_moment_r101_fpn_gn-neck%2Bhead_2x_coco_20200329_132205.log.json) | +| RepPoints | R-101-FPN-DCN | Y | none | moment | 2x | 5.9 | 12.1 | 42.9 | [config](./reppoints-moment_r101-dconv-c3-c5_fpn-gn_head-gn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r101_fpn_dconv_c3-c5_gn-neck%2Bhead_2x_coco/reppoints_moment_r101_fpn_dconv_c3-c5_gn-neck%2Bhead_2x_coco_20200329-3309fbf2.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r101_fpn_dconv_c3-c5_gn-neck%2Bhead_2x_coco/reppoints_moment_r101_fpn_dconv_c3-c5_gn-neck%2Bhead_2x_coco_20200329_132134.log.json) | +| RepPoints | X-101-FPN-DCN | Y | none | moment | 2x | 7.1 | 9.3 | 44.2 | [config](./reppoints-moment_x101-dconv-c3-c5_fpn-gn_head-gn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_x101_fpn_dconv_c3-c5_gn-neck%2Bhead_2x_coco/reppoints_moment_x101_fpn_dconv_c3-c5_gn-neck%2Bhead_2x_coco_20200329-f87da1ea.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_x101_fpn_dconv_c3-c5_gn-neck%2Bhead_2x_coco/reppoints_moment_x101_fpn_dconv_c3-c5_gn-neck%2Bhead_2x_coco_20200329_132201.log.json) | + +**Notes:** + +- `R-xx`, `X-xx` denote the ResNet and ResNeXt architectures, respectively. +- `DCN` denotes replacing 3x3 conv with the 3x3 deformable convolution in `c3-c5` stages of backbone. +- `none` in the `anchor` column means 2-d `center point` (x,y) is used to represent the initial object hypothesis. `single` denotes one 4-d anchor box (x,y,w,h) with IoU based label assign criterion is adopted. +- `moment`, `partial MinMax`, `MinMax` in the `convert func` column are three functions to convert a point set to a pseudo box. +- Note the results here are slightly different from those reported in the paper, due to framework change. While the original paper uses an [MXNet](https://mxnet.apache.org/) implementation, we re-implement the method in [PyTorch](https://pytorch.org/) based on mmdetection. + +## Citation + +```latex +@inproceedings{yang2019reppoints, + title={RepPoints: Point Set Representation for Object Detection}, + author={Yang, Ze and Liu, Shaohui and Hu, Han and Wang, Liwei and Lin, Stephen}, + booktitle={The IEEE International Conference on Computer Vision (ICCV)}, + month={Oct}, + year={2019} +} +``` diff --git a/mmdetection/configs/reppoints/metafile.yml b/mmdetection/configs/reppoints/metafile.yml new file mode 100644 index 00000000..732d541f --- /dev/null +++ b/mmdetection/configs/reppoints/metafile.yml @@ -0,0 +1,181 @@ +Collections: + - Name: RepPoints + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - Group Normalization + - FPN + - RepPoints + - ResNet + Paper: + URL: https://arxiv.org/abs/1904.11490 + Title: 'RepPoints: Point Set Representation for Object Detection' + README: configs/reppoints/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/detectors/reppoints_detector.py#L9 + Version: v2.0.0 + +Models: + - Name: reppoints-bbox_r50_fpn-gn_head-gn-grid_1x_coco + In Collection: RepPoints + Config: configs/reppoints/reppoints-bbox_r50_fpn-gn_head-gn-grid_1x_coco.py + Metadata: + Training Memory (GB): 3.9 + inference time (ms/im): + - value: 62.89 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 36.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/reppoints/bbox_r50_grid_fpn_gn-neck%2Bhead_1x_coco/bbox_r50_grid_fpn_gn-neck%2Bhead_1x_coco_20200329_145916-0eedf8d1.pth + + - Name: reppoints-bbox_r50-center_fpn-gn_head-gn-grid_1x_coco + In Collection: RepPoints + Config: configs/reppoints/reppoints-bbox_r50-center_fpn-gn_head-gn-grid_1x_coco.py + Metadata: + Training Memory (GB): 3.9 + inference time (ms/im): + - value: 64.94 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/reppoints/bbox_r50_grid_fpn_gn-neck%2Bhead_1x_coco/bbox_r50_grid_fpn_gn-neck%2Bhead_1x_coco_20200329_145916-0eedf8d1.pth + + - Name: reppoints-moment_r50_fpn_1x_coco + In Collection: RepPoints + Config: configs/reppoints/reppoints-moment_r50_fpn_1x_coco.py + Metadata: + Training Memory (GB): 3.3 + inference time (ms/im): + - value: 54.05 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r50_fpn_1x_coco/reppoints_moment_r50_fpn_1x_coco_20200330-b73db8d1.pth + + - Name: reppoints-moment_r50_fpn-gn_head-gn_1x_coco + In Collection: RepPoints + Config: configs/reppoints/reppoints-moment_r50_fpn-gn_head-gn_1x_coco.py + Metadata: + Training Memory (GB): 3.9 + inference time (ms/im): + - value: 57.14 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r50_fpn_gn-neck%2Bhead_1x_coco/reppoints_moment_r50_fpn_gn-neck%2Bhead_1x_coco_20200329_145952-3e51b550.pth + + - Name: reppoints-moment_r50_fpn-gn_head-gn_2x_coco + In Collection: RepPoints + Config: configs/reppoints/reppoints-moment_r50_fpn-gn_head-gn_2x_coco.py + Metadata: + Training Memory (GB): 3.9 + inference time (ms/im): + - value: 57.14 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r50_fpn_gn-neck%2Bhead_2x_coco/reppoints_moment_r50_fpn_gn-neck%2Bhead_2x_coco_20200329-91babaa2.pth + + - Name: reppoints-moment_r101_fpn-gn_head-gn_2x_coco + In Collection: RepPoints + Config: configs/reppoints/reppoints-moment_r101_fpn-gn_head-gn_2x_coco.py + Metadata: + Training Memory (GB): 5.8 + inference time (ms/im): + - value: 72.99 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r101_fpn_gn-neck%2Bhead_2x_coco/reppoints_moment_r101_fpn_gn-neck%2Bhead_2x_coco_20200329-4fbc7310.pth + + - Name: reppoints-moment_r101-dconv-c3-c5_fpn-gn_head-gn_2x_coco + In Collection: RepPoints + Config: configs/reppoints/reppoints-moment_r101-dconv-c3-c5_fpn-gn_head-gn_2x_coco.py + Metadata: + Training Memory (GB): 5.9 + inference time (ms/im): + - value: 82.64 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_r101_fpn_dconv_c3-c5_gn-neck%2Bhead_2x_coco/reppoints_moment_r101_fpn_dconv_c3-c5_gn-neck%2Bhead_2x_coco_20200329-3309fbf2.pth + + - Name: reppoints-moment_x101-dconv-c3-c5_fpn-gn_head-gn_2x_coco + In Collection: RepPoints + Config: configs/reppoints/reppoints-moment_x101-dconv-c3-c5_fpn-gn_head-gn_2x_coco.py + Metadata: + Training Memory (GB): 7.1 + inference time (ms/im): + - value: 107.53 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/reppoints/reppoints_moment_x101_fpn_dconv_c3-c5_gn-neck%2Bhead_2x_coco/reppoints_moment_x101_fpn_dconv_c3-c5_gn-neck%2Bhead_2x_coco_20200329-f87da1ea.pth diff --git a/mmdetection/configs/reppoints/reppoints-bbox_r50-center_fpn-gn_head-gn-grid_1x_coco.py b/mmdetection/configs/reppoints/reppoints-bbox_r50-center_fpn-gn_head-gn-grid_1x_coco.py new file mode 100644 index 00000000..f116e53f --- /dev/null +++ b/mmdetection/configs/reppoints/reppoints-bbox_r50-center_fpn-gn_head-gn-grid_1x_coco.py @@ -0,0 +1,2 @@ +_base_ = './reppoints-moment_r50_fpn-gn_head-gn_1x_coco.py' +model = dict(bbox_head=dict(transform_method='minmax', use_grid_points=True)) diff --git a/mmdetection/configs/reppoints/reppoints-bbox_r50_fpn-gn_head-gn-grid_1x_coco.py b/mmdetection/configs/reppoints/reppoints-bbox_r50_fpn-gn_head-gn-grid_1x_coco.py new file mode 100644 index 00000000..76be39b8 --- /dev/null +++ b/mmdetection/configs/reppoints/reppoints-bbox_r50_fpn-gn_head-gn-grid_1x_coco.py @@ -0,0 +1,13 @@ +_base_ = './reppoints-moment_r50_fpn-gn_head-gn_1x_coco.py' +model = dict( + bbox_head=dict(transform_method='minmax', use_grid_points=True), + # training and testing settings + train_cfg=dict( + init=dict( + assigner=dict( + _delete_=True, + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.4, + min_pos_iou=0, + ignore_iof_thr=-1)))) diff --git a/mmdetection/configs/reppoints/reppoints-minmax_r50_fpn-gn_head-gn_1x_coco.py b/mmdetection/configs/reppoints/reppoints-minmax_r50_fpn-gn_head-gn_1x_coco.py new file mode 100644 index 00000000..0e7dffe7 --- /dev/null +++ b/mmdetection/configs/reppoints/reppoints-minmax_r50_fpn-gn_head-gn_1x_coco.py @@ -0,0 +1,2 @@ +_base_ = './reppoints-moment_r50_fpn-gn_head-gn_1x_coco.py' +model = dict(bbox_head=dict(transform_method='minmax')) diff --git a/mmdetection/configs/reppoints/reppoints-moment_r101-dconv-c3-c5_fpn-gn_head-gn_2x_coco.py b/mmdetection/configs/reppoints/reppoints-moment_r101-dconv-c3-c5_fpn-gn_head-gn_2x_coco.py new file mode 100644 index 00000000..5c2bfab4 --- /dev/null +++ b/mmdetection/configs/reppoints/reppoints-moment_r101-dconv-c3-c5_fpn-gn_head-gn_2x_coco.py @@ -0,0 +1,8 @@ +_base_ = './reppoints-moment_r50_fpn-gn_head-gn_2x_coco.py' +model = dict( + backbone=dict( + depth=101, + dcn=dict(type='DCN', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True), + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/reppoints/reppoints-moment_r101_fpn-gn_head-gn_2x_coco.py b/mmdetection/configs/reppoints/reppoints-moment_r101_fpn-gn_head-gn_2x_coco.py new file mode 100644 index 00000000..02c447ad --- /dev/null +++ b/mmdetection/configs/reppoints/reppoints-moment_r101_fpn-gn_head-gn_2x_coco.py @@ -0,0 +1,6 @@ +_base_ = './reppoints-moment_r50_fpn-gn_head-gn_2x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/reppoints/reppoints-moment_r50_fpn-gn_head-gn_1x_coco.py b/mmdetection/configs/reppoints/reppoints-moment_r50_fpn-gn_head-gn_1x_coco.py new file mode 100644 index 00000000..cedf2226 --- /dev/null +++ b/mmdetection/configs/reppoints/reppoints-moment_r50_fpn-gn_head-gn_1x_coco.py @@ -0,0 +1,3 @@ +_base_ = './reppoints-moment_r50_fpn_1x_coco.py' +norm_cfg = dict(type='GN', num_groups=32, requires_grad=True) +model = dict(neck=dict(norm_cfg=norm_cfg), bbox_head=dict(norm_cfg=norm_cfg)) diff --git a/mmdetection/configs/reppoints/reppoints-moment_r50_fpn-gn_head-gn_2x_coco.py b/mmdetection/configs/reppoints/reppoints-moment_r50_fpn-gn_head-gn_2x_coco.py new file mode 100644 index 00000000..4490d449 --- /dev/null +++ b/mmdetection/configs/reppoints/reppoints-moment_r50_fpn-gn_head-gn_2x_coco.py @@ -0,0 +1,17 @@ +_base_ = './reppoints-moment_r50_fpn-gn_head-gn_1x_coco.py' + +max_epochs = 24 + +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/reppoints/reppoints-moment_r50_fpn_1x_coco.py b/mmdetection/configs/reppoints/reppoints-moment_r50_fpn_1x_coco.py new file mode 100644 index 00000000..df7e72a8 --- /dev/null +++ b/mmdetection/configs/reppoints/reppoints-moment_r50_fpn_1x_coco.py @@ -0,0 +1,74 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +model = dict( + type='RepPointsDetector', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_input', + num_outs=5), + bbox_head=dict( + type='RepPointsHead', + num_classes=80, + in_channels=256, + feat_channels=256, + point_feat_channels=256, + stacked_convs=3, + num_points=9, + gradient_mul=0.1, + point_strides=[8, 16, 32, 64, 128], + point_base_scale=4, + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox_init=dict(type='SmoothL1Loss', beta=0.11, loss_weight=0.5), + loss_bbox_refine=dict(type='SmoothL1Loss', beta=0.11, loss_weight=1.0), + transform_method='moment'), + # training and testing settings + train_cfg=dict( + init=dict( + assigner=dict(type='PointAssigner', scale=4, pos_num=1), + allowed_border=-1, + pos_weight=-1, + debug=False), + refine=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.4, + min_pos_iou=0, + ignore_iof_thr=-1), + allowed_border=-1, + pos_weight=-1, + debug=False)), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.5), + max_per_img=100)) + +optim_wrapper = dict(optimizer=dict(lr=0.01)) diff --git a/mmdetection/configs/reppoints/reppoints-moment_x101-dconv-c3-c5_fpn-gn_head-gn_2x_coco.py b/mmdetection/configs/reppoints/reppoints-moment_x101-dconv-c3-c5_fpn-gn_head-gn_2x_coco.py new file mode 100644 index 00000000..a9909efe --- /dev/null +++ b/mmdetection/configs/reppoints/reppoints-moment_x101-dconv-c3-c5_fpn-gn_head-gn_2x_coco.py @@ -0,0 +1,16 @@ +_base_ = './reppoints-moment_r50_fpn-gn_head-gn_2x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + dcn=dict(type='DCN', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/reppoints/reppoints-partial-minmax_r50_fpn-gn_head-gn_1x_coco.py b/mmdetection/configs/reppoints/reppoints-partial-minmax_r50_fpn-gn_head-gn_1x_coco.py new file mode 100644 index 00000000..30f7844b --- /dev/null +++ b/mmdetection/configs/reppoints/reppoints-partial-minmax_r50_fpn-gn_head-gn_1x_coco.py @@ -0,0 +1,2 @@ +_base_ = './reppoints-moment_r50_fpn-gn_head-gn_1x_coco.py' +model = dict(bbox_head=dict(transform_method='partial_minmax')) diff --git a/mmdetection/configs/reppoints/reppoints.png b/mmdetection/configs/reppoints/reppoints.png new file mode 100644 index 00000000..a9306d9b Binary files /dev/null and b/mmdetection/configs/reppoints/reppoints.png differ diff --git a/mmdetection/configs/res2net/README.md b/mmdetection/configs/res2net/README.md new file mode 100644 index 00000000..cd6732b6 --- /dev/null +++ b/mmdetection/configs/res2net/README.md @@ -0,0 +1,77 @@ +# Res2Net + +> [Res2Net: A New Multi-scale Backbone Architecture](https://arxiv.org/abs/1904.01169) + + + +## Abstract + +Representing features at multiple scales is of great importance for numerous vision tasks. Recent advances in backbone convolutional neural networks (CNNs) continually demonstrate stronger multi-scale representation ability, leading to consistent performance gains on a wide range of applications. However, most existing methods represent the multi-scale features in a layer-wise manner. In this paper, we propose a novel building block for CNNs, namely Res2Net, by constructing hierarchical residual-like connections within one single residual block. The Res2Net represents multi-scale features at a granular level and increases the range of receptive fields for each network layer. The proposed Res2Net block can be plugged into the state-of-the-art backbone CNN models, e.g., ResNet, ResNeXt, and DLA. We evaluate the Res2Net block on all these models and demonstrate consistent performance gains over baseline models on widely-used datasets, e.g., CIFAR-100 and ImageNet. Further ablation studies and experimental results on representative computer vision tasks, i.e., object detection, class activation mapping, and salient object detection, further verify the superiority of the Res2Net over the state-of-the-art baseline methods. + +
    + +
    + +## Introduction + +We propose a novel building block for CNNs, namely Res2Net, by constructing hierarchical residual-like connections within one single residual block. The Res2Net represents multi-scale features at a granular level and increases the range of receptive fields for each network layer. + +| Backbone | Params. | GFLOPs | top-1 err. | top-5 err. | +| :---------------: | :-----: | :----: | :--------: | :--------: | +| ResNet-101 | 44.6 M | 7.8 | 22.63 | 6.44 | +| ResNeXt-101-64x4d | 83.5M | 15.5 | 20.40 | - | +| HRNetV2p-W48 | 77.5M | 16.1 | 20.70 | 5.50 | +| Res2Net-101 | 45.2M | 8.3 | 18.77 | 4.64 | + +Compared with other backbone networks, Res2Net requires fewer parameters and FLOPs. + +**Note:** + +- GFLOPs for classification are calculated with image size (224x224). + +## Results and Models + +### Faster R-CNN + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :--------: | :-----: | :-----: | :------: | :------------: | :----: | :------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R2-101-FPN | pytorch | 2x | 7.4 | - | 43.0 | [config](./faster-rcnn_res2net-101_fpn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/res2net/faster_rcnn_r2_101_fpn_2x_coco/faster_rcnn_r2_101_fpn_2x_coco-175f1da6.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/res2net/faster_rcnn_r2_101_fpn_2x_coco/faster_rcnn_r2_101_fpn_2x_coco_20200514_231734.log.json) | + +### Mask R-CNN + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :--------: | :-----: | :-----: | :------: | :------------: | :----: | :-----: | :----------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R2-101-FPN | pytorch | 2x | 7.9 | - | 43.6 | 38.7 | [config](./mask-rcnn_res2net-101_fpn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/res2net/mask_rcnn_r2_101_fpn_2x_coco/mask_rcnn_r2_101_fpn_2x_coco-17f061e8.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/res2net/mask_rcnn_r2_101_fpn_2x_coco/mask_rcnn_r2_101_fpn_2x_coco_20200515_002413.log.json) | + +### Cascade R-CNN + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :--------: | :-----: | :-----: | :------: | :------------: | :----: | :--------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R2-101-FPN | pytorch | 20e | 7.8 | - | 45.7 | [config](./cascade-rcnn_res2net-101_fpn_20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/res2net/cascade_rcnn_r2_101_fpn_20e_coco/cascade_rcnn_r2_101_fpn_20e_coco-f4b7b7db.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/res2net/cascade_rcnn_r2_101_fpn_20e_coco/cascade_rcnn_r2_101_fpn_20e_coco_20200515_091644.log.json) | + +### Cascade Mask R-CNN + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :--------: | :-----: | :-----: | :------: | :------------: | :----: | :-----: | :-------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R2-101-FPN | pytorch | 20e | 9.5 | - | 46.4 | 40.0 | [config](./cascade-mask-rcnn_res2net-101_fpn_20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/res2net/cascade_mask_rcnn_r2_101_fpn_20e_coco/cascade_mask_rcnn_r2_101_fpn_20e_coco-8a7b41e1.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/res2net/cascade_mask_rcnn_r2_101_fpn_20e_coco/cascade_mask_rcnn_r2_101_fpn_20e_coco_20200515_091645.log.json) | + +### Hybrid Task Cascade (HTC) + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :--------: | :-----: | :-----: | :------: | :------------: | :----: | :-----: | :-----------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R2-101-FPN | pytorch | 20e | - | - | 47.5 | 41.6 | [config](./htc_res2net-101_fpn_20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/res2net/htc_r2_101_fpn_20e_coco/htc_r2_101_fpn_20e_coco-3a8d2112.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/res2net/htc_r2_101_fpn_20e_coco/htc_r2_101_fpn_20e_coco_20200515_150029.log.json) | + +- Res2Net ImageNet pretrained models are in [Res2Net-PretrainedModels](https://github.com/Res2Net/Res2Net-PretrainedModels). +- More applications of Res2Net are in [Res2Net-Github](https://github.com/Res2Net/). + +## Citation + +```latex +@article{gao2019res2net, + title={Res2Net: A New Multi-scale Backbone Architecture}, + author={Gao, Shang-Hua and Cheng, Ming-Ming and Zhao, Kai and Zhang, Xin-Yu and Yang, Ming-Hsuan and Torr, Philip}, + journal={IEEE TPAMI}, + year={2020}, + doi={10.1109/TPAMI.2019.2938758}, +} +``` diff --git a/mmdetection/configs/res2net/cascade-mask-rcnn_res2net-101_fpn_20e_coco.py b/mmdetection/configs/res2net/cascade-mask-rcnn_res2net-101_fpn_20e_coco.py new file mode 100644 index 00000000..21b6d2ea --- /dev/null +++ b/mmdetection/configs/res2net/cascade-mask-rcnn_res2net-101_fpn_20e_coco.py @@ -0,0 +1,10 @@ +_base_ = '../cascade_rcnn/cascade-mask-rcnn_r50_fpn_20e_coco.py' +model = dict( + backbone=dict( + type='Res2Net', + depth=101, + scales=4, + base_width=26, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://res2net101_v1d_26w_4s'))) diff --git a/mmdetection/configs/res2net/cascade-rcnn_res2net-101_fpn_20e_coco.py b/mmdetection/configs/res2net/cascade-rcnn_res2net-101_fpn_20e_coco.py new file mode 100644 index 00000000..670a7745 --- /dev/null +++ b/mmdetection/configs/res2net/cascade-rcnn_res2net-101_fpn_20e_coco.py @@ -0,0 +1,10 @@ +_base_ = '../cascade_rcnn/cascade-rcnn_r50_fpn_20e_coco.py' +model = dict( + backbone=dict( + type='Res2Net', + depth=101, + scales=4, + base_width=26, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://res2net101_v1d_26w_4s'))) diff --git a/mmdetection/configs/res2net/faster-rcnn_res2net-101_fpn_2x_coco.py b/mmdetection/configs/res2net/faster-rcnn_res2net-101_fpn_2x_coco.py new file mode 100644 index 00000000..033cf574 --- /dev/null +++ b/mmdetection/configs/res2net/faster-rcnn_res2net-101_fpn_2x_coco.py @@ -0,0 +1,10 @@ +_base_ = '../faster_rcnn/faster-rcnn_r50_fpn_2x_coco.py' +model = dict( + backbone=dict( + type='Res2Net', + depth=101, + scales=4, + base_width=26, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://res2net101_v1d_26w_4s'))) diff --git a/mmdetection/configs/res2net/htc_res2net-101_fpn_20e_coco.py b/mmdetection/configs/res2net/htc_res2net-101_fpn_20e_coco.py new file mode 100644 index 00000000..d5542fda --- /dev/null +++ b/mmdetection/configs/res2net/htc_res2net-101_fpn_20e_coco.py @@ -0,0 +1,10 @@ +_base_ = '../htc/htc_r50_fpn_20e_coco.py' +model = dict( + backbone=dict( + type='Res2Net', + depth=101, + scales=4, + base_width=26, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://res2net101_v1d_26w_4s'))) diff --git a/mmdetection/configs/res2net/mask-rcnn_res2net-101_fpn_2x_coco.py b/mmdetection/configs/res2net/mask-rcnn_res2net-101_fpn_2x_coco.py new file mode 100644 index 00000000..3a2d5730 --- /dev/null +++ b/mmdetection/configs/res2net/mask-rcnn_res2net-101_fpn_2x_coco.py @@ -0,0 +1,10 @@ +_base_ = '../mask_rcnn/mask-rcnn_r50_fpn_2x_coco.py' +model = dict( + backbone=dict( + type='Res2Net', + depth=101, + scales=4, + base_width=26, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://res2net101_v1d_26w_4s'))) diff --git a/mmdetection/configs/res2net/metafile.yml b/mmdetection/configs/res2net/metafile.yml new file mode 100644 index 00000000..1d9f9ea0 --- /dev/null +++ b/mmdetection/configs/res2net/metafile.yml @@ -0,0 +1,146 @@ +Models: + - Name: faster-rcnn_res2net-101_fpn_2x_coco + In Collection: Faster R-CNN + Config: configs/res2net/faster-rcnn_res2net-101_fpn_2x_coco.py + Metadata: + Training Memory (GB): 7.4 + Epochs: 24 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - Res2Net + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/res2net/faster_rcnn_r2_101_fpn_2x_coco/faster_rcnn_r2_101_fpn_2x_coco-175f1da6.pth + Paper: + URL: https://arxiv.org/abs/1904.01169 + Title: 'Res2Net for object detection and instance segmentation' + README: configs/res2net/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/res2net.py#L239 + Version: v2.1.0 + + - Name: mask-rcnn_res2net-101_fpn_2x_coco + In Collection: Mask R-CNN + Config: configs/res2net/mask-rcnn_res2net-101_fpn_2x_coco.py + Metadata: + Training Memory (GB): 7.9 + Epochs: 24 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - Res2Net + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.6 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/res2net/mask_rcnn_r2_101_fpn_2x_coco/mask_rcnn_r2_101_fpn_2x_coco-17f061e8.pth + Paper: + URL: https://arxiv.org/abs/1904.01169 + Title: 'Res2Net for object detection and instance segmentation' + README: configs/res2net/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/res2net.py#L239 + Version: v2.1.0 + + - Name: cascade-rcnn_res2net-101_fpn_20e_coco + In Collection: Cascade R-CNN + Config: configs/res2net/cascade-rcnn_res2net-101_fpn_20e_coco.py + Metadata: + Training Memory (GB): 7.8 + Epochs: 20 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - Res2Net + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/res2net/cascade_rcnn_r2_101_fpn_20e_coco/cascade_rcnn_r2_101_fpn_20e_coco-f4b7b7db.pth + Paper: + URL: https://arxiv.org/abs/1904.01169 + Title: 'Res2Net for object detection and instance segmentation' + README: configs/res2net/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/res2net.py#L239 + Version: v2.1.0 + + - Name: cascade-mask-rcnn_res2net-101_fpn_20e_coco + In Collection: Cascade R-CNN + Config: configs/res2net/cascade-mask-rcnn_res2net-101_fpn_20e_coco.py + Metadata: + Training Memory (GB): 9.5 + Epochs: 20 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - Res2Net + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.4 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 40.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/res2net/cascade_mask_rcnn_r2_101_fpn_20e_coco/cascade_mask_rcnn_r2_101_fpn_20e_coco-8a7b41e1.pth + Paper: + URL: https://arxiv.org/abs/1904.01169 + Title: 'Res2Net for object detection and instance segmentation' + README: configs/res2net/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/res2net.py#L239 + Version: v2.1.0 + + - Name: htc_res2net-101_fpn_20e_coco + In Collection: HTC + Config: configs/res2net/htc_res2net-101_fpn_20e_coco.py + Metadata: + Epochs: 20 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - Res2Net + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 47.5 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 41.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/res2net/htc_r2_101_fpn_20e_coco/htc_r2_101_fpn_20e_coco-3a8d2112.pth + Paper: + URL: https://arxiv.org/abs/1904.01169 + Title: 'Res2Net for object detection and instance segmentation' + README: configs/res2net/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.1.0/mmdet/models/backbones/res2net.py#L239 + Version: v2.1.0 diff --git a/mmdetection/configs/resnest/README.md b/mmdetection/configs/resnest/README.md new file mode 100644 index 00000000..a72f8423 --- /dev/null +++ b/mmdetection/configs/resnest/README.md @@ -0,0 +1,54 @@ +# ResNeSt + +> [ResNeSt: Split-Attention Networks](https://arxiv.org/abs/2004.08955) + + + +## Abstract + +It is well known that featuremap attention and multi-path representation are important for visual recognition. In this paper, we present a modularized architecture, which applies the channel-wise attention on different network branches to leverage their success in capturing cross-feature interactions and learning diverse representations. Our design results in a simple and unified computation block, which can be parameterized using only a few variables. Our model, named ResNeSt, outperforms EfficientNet in accuracy and latency trade-off on image classification. In addition, ResNeSt has achieved superior transfer learning results on several public benchmarks serving as the backbone, and has been adopted by the winning entries of COCO-LVIS challenge. + +
    + +
    + +## Results and Models + +### Faster R-CNN + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :-------: | :-----: | :-----: | :------: | :------------: | :----: | :-----------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| S-50-FPN | pytorch | 1x | 4.8 | - | 42.0 | [config](./faster-rcnn_s50_fpn_syncbn-backbone+head_ms-range-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/resnest/faster_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco/faster_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco_20200926_125502-20289c16.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/resnest/faster_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco/faster_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco-20200926_125502.log.json) | +| S-101-FPN | pytorch | 1x | 7.1 | - | 44.5 | [config](./faster-rcnn_s101_fpn_syncbn-backbone+head_ms-range-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/resnest/faster_rcnn_s101_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco/faster_rcnn_s101_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco_20201006_021058-421517f1.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/resnest/faster_rcnn_s101_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco/faster_rcnn_s101_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco-20201006_021058.log.json) | + +### Mask R-CNN + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :-------: | :-----: | :-----: | :------: | :------------: | :----: | :-----: | :---------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| S-50-FPN | pytorch | 1x | 5.5 | - | 42.6 | 38.1 | [config](./mask-rcnn_s50_fpn_syncbn-backbone+head_ms-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/resnest/mask_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain_1x_coco/mask_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain_1x_coco_20200926_125503-8a2c3d47.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/resnest/mask_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain_1x_coco/mask_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain_1x_coco-20200926_125503.log.json) | +| S-101-FPN | pytorch | 1x | 7.8 | - | 45.2 | 40.2 | [config](./mask-rcnn_s101_fpn_syncbn-backbone+head_ms-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/resnest/mask_rcnn_s101_fpn_syncbn-backbone%2Bhead_mstrain_1x_coco/mask_rcnn_s101_fpn_syncbn-backbone%2Bhead_mstrain_1x_coco_20201005_215831-af60cdf9.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/resnest/mask_rcnn_s101_fpn_syncbn-backbone%2Bhead_mstrain_1x_coco/mask_rcnn_s101_fpn_syncbn-backbone%2Bhead_mstrain_1x_coco-20201005_215831.log.json) | + +### Cascade R-CNN + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :-------: | :-----: | :-----: | :------: | :------------: | :----: | :------------------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| S-50-FPN | pytorch | 1x | - | - | 44.5 | [config](./cascade-rcnn_s50_fpn_syncbn-backbone+head_ms-range-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/resnest/cascade_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco/cascade_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco_20201122_213640-763cc7b5.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/resnest/cascade_rcnn_s101_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco/cascade_rcnn_s101_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco-20201005_113242.log.json) | +| S-101-FPN | pytorch | 1x | 8.4 | - | 46.8 | [config](./cascade-rcnn_s101_fpn_syncbn-backbone+head_ms-range-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/resnest/cascade_rcnn_s101_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco/cascade_rcnn_s101_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco_20201005_113242-b9459f8f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/resnest/cascade_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco/cascade_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco-20201122_213640.log.json) | + +### Cascade Mask R-CNN + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :-------: | :-----: | :-----: | :------: | :------------: | :----: | :-----: | :-----------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| S-50-FPN | pytorch | 1x | - | - | 45.4 | 39.5 | [config](./cascade-mask-rcnn_s50_fpn_syncbn-backbone+head_ms-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/resnest/cascade_mask_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain_1x_coco/cascade_mask_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain_1x_coco_20201122_104428-99eca4c7.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/resnest/cascade_mask_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain_1x_coco/cascade_mask_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain_1x_coco-20201122_104428.log.json) | +| S-101-FPN | pytorch | 1x | 10.5 | - | 47.7 | 41.4 | [config](./cascade-mask-rcnn_s101_fpn_syncbn-backbone+head_ms-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/resnest/cascade_mask_rcnn_s101_fpn_syncbn-backbone%2Bhead_mstrain_1x_coco/cascade_mask_rcnn_s101_fpn_syncbn-backbone%2Bhead_mstrain_1x_coco_20201005_113243-42607475.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/resnest/cascade_mask_rcnn_s101_fpn_syncbn-backbone%2Bhead_mstrain_1x_coco/cascade_mask_rcnn_s101_fpn_syncbn-backbone%2Bhead_mstrain_1x_coco-20201005_113243.log.json) | + +## Citation + +```latex +@article{zhang2020resnest, +title={ResNeSt: Split-Attention Networks}, +author={Zhang, Hang and Wu, Chongruo and Zhang, Zhongyue and Zhu, Yi and Zhang, Zhi and Lin, Haibin and Sun, Yue and He, Tong and Muller, Jonas and Manmatha, R. and Li, Mu and Smola, Alexander}, +journal={arXiv preprint arXiv:2004.08955}, +year={2020} +} +``` diff --git a/mmdetection/configs/resnest/cascade-mask-rcnn_s101_fpn_syncbn-backbone+head_ms-1x_coco.py b/mmdetection/configs/resnest/cascade-mask-rcnn_s101_fpn_syncbn-backbone+head_ms-1x_coco.py new file mode 100644 index 00000000..f4f19925 --- /dev/null +++ b/mmdetection/configs/resnest/cascade-mask-rcnn_s101_fpn_syncbn-backbone+head_ms-1x_coco.py @@ -0,0 +1,7 @@ +_base_ = './cascade-mask-rcnn_s50_fpn_syncbn-backbone+head_ms-1x_coco.py' +model = dict( + backbone=dict( + stem_channels=128, + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='open-mmlab://resnest101'))) diff --git a/mmdetection/configs/resnest/cascade-mask-rcnn_s50_fpn_syncbn-backbone+head_ms-1x_coco.py b/mmdetection/configs/resnest/cascade-mask-rcnn_s50_fpn_syncbn-backbone+head_ms-1x_coco.py new file mode 100644 index 00000000..c6ef41c0 --- /dev/null +++ b/mmdetection/configs/resnest/cascade-mask-rcnn_s50_fpn_syncbn-backbone+head_ms-1x_coco.py @@ -0,0 +1,101 @@ +_base_ = '../cascade_rcnn/cascade-mask-rcnn_r50_fpn_1x_coco.py' +norm_cfg = dict(type='SyncBN', requires_grad=True) + +model = dict( + # use ResNeSt img_norm + data_preprocessor=dict( + mean=[123.68, 116.779, 103.939], + std=[58.393, 57.12, 57.375], + bgr_to_rgb=True), + backbone=dict( + type='ResNeSt', + stem_channels=64, + depth=50, + radix=2, + reduction_factor=4, + avg_down_stride=True, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=norm_cfg, + norm_eval=False, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='open-mmlab://resnest50')), + roi_head=dict( + bbox_head=[ + dict( + type='Shared4Conv1FCBBoxHead', + in_channels=256, + conv_out_channels=256, + fc_out_channels=1024, + norm_cfg=norm_cfg, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, + loss_weight=1.0)), + dict( + type='Shared4Conv1FCBBoxHead', + in_channels=256, + conv_out_channels=256, + fc_out_channels=1024, + norm_cfg=norm_cfg, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.05, 0.05, 0.1, 0.1]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, + loss_weight=1.0)), + dict( + type='Shared4Conv1FCBBoxHead', + in_channels=256, + conv_out_channels=256, + fc_out_channels=1024, + norm_cfg=norm_cfg, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.033, 0.033, 0.067, 0.067]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0)) + ], + mask_head=dict(norm_cfg=norm_cfg))) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict( + type='LoadAnnotations', + with_bbox=True, + with_mask=True, + poly2mask=False), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736), + (1333, 768), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/mmdetection/configs/resnest/cascade-rcnn_s101_fpn_syncbn-backbone+head_ms-range-1x_coco.py b/mmdetection/configs/resnest/cascade-rcnn_s101_fpn_syncbn-backbone+head_ms-range-1x_coco.py new file mode 100644 index 00000000..9dbf3fae --- /dev/null +++ b/mmdetection/configs/resnest/cascade-rcnn_s101_fpn_syncbn-backbone+head_ms-range-1x_coco.py @@ -0,0 +1,7 @@ +_base_ = './cascade-rcnn_s50_fpn_syncbn-backbone+head_ms-range-1x_coco.py' +model = dict( + backbone=dict( + stem_channels=128, + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='open-mmlab://resnest101'))) diff --git a/mmdetection/configs/resnest/cascade-rcnn_s50_fpn_syncbn-backbone+head_ms-range-1x_coco.py b/mmdetection/configs/resnest/cascade-rcnn_s50_fpn_syncbn-backbone+head_ms-range-1x_coco.py new file mode 100644 index 00000000..7ce7b563 --- /dev/null +++ b/mmdetection/configs/resnest/cascade-rcnn_s50_fpn_syncbn-backbone+head_ms-range-1x_coco.py @@ -0,0 +1,93 @@ +_base_ = '../cascade_rcnn/cascade-rcnn_r50_fpn_1x_coco.py' +norm_cfg = dict(type='SyncBN', requires_grad=True) +model = dict( + # use ResNeSt img_norm + data_preprocessor=dict( + mean=[123.68, 116.779, 103.939], + std=[58.393, 57.12, 57.375], + bgr_to_rgb=True), + backbone=dict( + type='ResNeSt', + stem_channels=64, + depth=50, + radix=2, + reduction_factor=4, + avg_down_stride=True, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=norm_cfg, + norm_eval=False, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='open-mmlab://resnest50')), + roi_head=dict( + bbox_head=[ + dict( + type='Shared4Conv1FCBBoxHead', + in_channels=256, + conv_out_channels=256, + fc_out_channels=1024, + norm_cfg=norm_cfg, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, + loss_weight=1.0)), + dict( + type='Shared4Conv1FCBBoxHead', + in_channels=256, + conv_out_channels=256, + fc_out_channels=1024, + norm_cfg=norm_cfg, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.05, 0.05, 0.1, 0.1]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, + loss_weight=1.0)), + dict( + type='Shared4Conv1FCBBoxHead', + in_channels=256, + conv_out_channels=256, + fc_out_channels=1024, + norm_cfg=norm_cfg, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.033, 0.033, 0.067, 0.067]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0)) + ], )) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomResize', scale=[(1333, 640), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/mmdetection/configs/resnest/faster-rcnn_s101_fpn_syncbn-backbone+head_ms-range-1x_coco.py b/mmdetection/configs/resnest/faster-rcnn_s101_fpn_syncbn-backbone+head_ms-range-1x_coco.py new file mode 100644 index 00000000..f1e16321 --- /dev/null +++ b/mmdetection/configs/resnest/faster-rcnn_s101_fpn_syncbn-backbone+head_ms-range-1x_coco.py @@ -0,0 +1,7 @@ +_base_ = './faster-rcnn_s50_fpn_syncbn-backbone+head_ms-range-1x_coco.py' +model = dict( + backbone=dict( + stem_channels=128, + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='open-mmlab://resnest101'))) diff --git a/mmdetection/configs/resnest/faster-rcnn_s50_fpn_syncbn-backbone+head_ms-range-1x_coco.py b/mmdetection/configs/resnest/faster-rcnn_s50_fpn_syncbn-backbone+head_ms-range-1x_coco.py new file mode 100644 index 00000000..8f0ec6e0 --- /dev/null +++ b/mmdetection/configs/resnest/faster-rcnn_s50_fpn_syncbn-backbone+head_ms-range-1x_coco.py @@ -0,0 +1,39 @@ +_base_ = '../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py' +norm_cfg = dict(type='SyncBN', requires_grad=True) +model = dict( + # use ResNeSt img_norm + data_preprocessor=dict( + mean=[123.68, 116.779, 103.939], + std=[58.393, 57.12, 57.375], + bgr_to_rgb=True), + backbone=dict( + type='ResNeSt', + stem_channels=64, + depth=50, + radix=2, + reduction_factor=4, + avg_down_stride=True, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=norm_cfg, + norm_eval=False, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='open-mmlab://resnest50')), + roi_head=dict( + bbox_head=dict( + type='Shared4Conv1FCBBoxHead', + conv_out_channels=256, + norm_cfg=norm_cfg))) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomResize', scale=[(1333, 640), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/mmdetection/configs/resnest/mask-rcnn_s101_fpn_syncbn-backbone+head_ms-1x_coco.py b/mmdetection/configs/resnest/mask-rcnn_s101_fpn_syncbn-backbone+head_ms-1x_coco.py new file mode 100644 index 00000000..3edf49f0 --- /dev/null +++ b/mmdetection/configs/resnest/mask-rcnn_s101_fpn_syncbn-backbone+head_ms-1x_coco.py @@ -0,0 +1,7 @@ +_base_ = './mask-rcnn_s50_fpn_syncbn-backbone+head_ms-1x_coco.py' +model = dict( + backbone=dict( + stem_channels=128, + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='open-mmlab://resnest101'))) diff --git a/mmdetection/configs/resnest/mask-rcnn_s50_fpn_syncbn-backbone+head_ms-1x_coco.py b/mmdetection/configs/resnest/mask-rcnn_s50_fpn_syncbn-backbone+head_ms-1x_coco.py new file mode 100644 index 00000000..c6f27000 --- /dev/null +++ b/mmdetection/configs/resnest/mask-rcnn_s50_fpn_syncbn-backbone+head_ms-1x_coco.py @@ -0,0 +1,46 @@ +_base_ = '../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py' +norm_cfg = dict(type='SyncBN', requires_grad=True) +model = dict( + # use ResNeSt img_norm + data_preprocessor=dict( + mean=[123.68, 116.779, 103.939], + std=[58.393, 57.12, 57.375], + bgr_to_rgb=True), + backbone=dict( + type='ResNeSt', + stem_channels=64, + depth=50, + radix=2, + reduction_factor=4, + avg_down_stride=True, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=norm_cfg, + norm_eval=False, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='open-mmlab://resnest50')), + roi_head=dict( + bbox_head=dict( + type='Shared4Conv1FCBBoxHead', + conv_out_channels=256, + norm_cfg=norm_cfg), + mask_head=dict(norm_cfg=norm_cfg))) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict( + type='LoadAnnotations', + with_bbox=True, + with_mask=True, + poly2mask=False), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736), + (1333, 768), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/mmdetection/configs/resnest/metafile.yml b/mmdetection/configs/resnest/metafile.yml new file mode 100644 index 00000000..265c9409 --- /dev/null +++ b/mmdetection/configs/resnest/metafile.yml @@ -0,0 +1,230 @@ +Models: + - Name: faster-rcnn_s50_fpn_syncbn-backbone+head_ms-range-1x_coco + In Collection: Faster R-CNN + Config: configs/resnest/faster-rcnn_s50_fpn_syncbn-backbone+head_ms-range-1x_coco.py + Metadata: + Training Memory (GB): 4.8 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - ResNeSt + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/resnest/faster_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco/faster_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco_20200926_125502-20289c16.pth + Paper: + URL: https://arxiv.org/abs/2004.08955 + Title: 'ResNeSt: Split-Attention Networks' + README: configs/resnest/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.7.0/mmdet/models/backbones/resnest.py#L273 + Version: v2.7.0 + + - Name: faster-rcnn_s101_fpn_syncbn-backbone+head_ms-range-1x_coco + In Collection: Faster R-CNN + Config: configs/resnest/faster-rcnn_s101_fpn_syncbn-backbone+head_ms-range-1x_coco.py + Metadata: + Training Memory (GB): 7.1 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - ResNeSt + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/resnest/faster_rcnn_s101_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco/faster_rcnn_s101_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco_20201006_021058-421517f1.pth + Paper: + URL: https://arxiv.org/abs/2004.08955 + Title: 'ResNeSt: Split-Attention Networks' + README: configs/resnest/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.7.0/mmdet/models/backbones/resnest.py#L273 + Version: v2.7.0 + + - Name: mask-rcnn_s50_fpn_syncbn-backbone+head_ms-1x_coco + In Collection: Mask R-CNN + Config: configs/resnest/mask-rcnn_s50_fpn_syncbn-backbone+head_ms-1x_coco.py + Metadata: + Training Memory (GB): 5.5 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - ResNeSt + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.6 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/resnest/mask_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain_1x_coco/mask_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain_1x_coco_20200926_125503-8a2c3d47.pth + Paper: + URL: https://arxiv.org/abs/2004.08955 + Title: 'ResNeSt: Split-Attention Networks' + README: configs/resnest/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.7.0/mmdet/models/backbones/resnest.py#L273 + Version: v2.7.0 + + - Name: mask-rcnn_s101_fpn_syncbn-backbone+head_ms-1x_coco + In Collection: Mask R-CNN + Config: configs/resnest/mask-rcnn_s101_fpn_syncbn-backbone+head_ms-1x_coco.py + Metadata: + Training Memory (GB): 7.8 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - ResNeSt + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.2 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 40.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/resnest/mask_rcnn_s101_fpn_syncbn-backbone%2Bhead_mstrain_1x_coco/mask_rcnn_s101_fpn_syncbn-backbone%2Bhead_mstrain_1x_coco_20201005_215831-af60cdf9.pth + Paper: + URL: https://arxiv.org/abs/2004.08955 + Title: 'ResNeSt: Split-Attention Networks' + README: configs/resnest/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.7.0/mmdet/models/backbones/resnest.py#L273 + Version: v2.7.0 + + - Name: cascade-rcnn_s50_fpn_syncbn-backbone+head_ms-range-1x_coco + In Collection: Cascade R-CNN + Config: configs/resnest/cascade-rcnn_s50_fpn_syncbn-backbone+head_ms-range-1x_coco.py + Metadata: + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - ResNeSt + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/resnest/cascade_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco/cascade_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco_20201122_213640-763cc7b5.pth + Paper: + URL: https://arxiv.org/abs/2004.08955 + Title: 'ResNeSt: Split-Attention Networks' + README: configs/resnest/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.7.0/mmdet/models/backbones/resnest.py#L273 + Version: v2.7.0 + + - Name: cascade-rcnn_s101_fpn_syncbn-backbone+head_ms-range-1x_coco + In Collection: Cascade R-CNN + Config: configs/resnest/cascade-rcnn_s101_fpn_syncbn-backbone+head_ms-range-1x_coco.py + Metadata: + Training Memory (GB): 8.4 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - ResNeSt + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/resnest/cascade_rcnn_s101_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco/cascade_rcnn_s101_fpn_syncbn-backbone%2Bhead_mstrain-range_1x_coco_20201005_113242-b9459f8f.pth + Paper: + URL: https://arxiv.org/abs/2004.08955 + Title: 'ResNeSt: Split-Attention Networks' + README: configs/resnest/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.7.0/mmdet/models/backbones/resnest.py#L273 + Version: v2.7.0 + + - Name: cascade-mask-rcnn_s50_fpn_syncbn-backbone+head_ms-1x_coco + In Collection: Cascade R-CNN + Config: configs/resnest/cascade-mask-rcnn_s50_fpn_syncbn-backbone+head_ms-1x_coco.py + Metadata: + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - ResNeSt + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.4 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/resnest/cascade_mask_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain_1x_coco/cascade_mask_rcnn_s50_fpn_syncbn-backbone%2Bhead_mstrain_1x_coco_20201122_104428-99eca4c7.pth + Paper: + URL: https://arxiv.org/abs/2004.08955 + Title: 'ResNeSt: Split-Attention Networks' + README: configs/resnest/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.7.0/mmdet/models/backbones/resnest.py#L273 + Version: v2.7.0 + + - Name: cascade-mask-rcnn_s101_fpn_syncbn-backbone+head_ms-1x_coco + In Collection: Cascade R-CNN + Config: configs/resnest/cascade-mask-rcnn_s101_fpn_syncbn-backbone+head_ms-1x_coco.py + Metadata: + Training Memory (GB): 10.5 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - ResNeSt + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 47.7 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 41.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/resnest/cascade_mask_rcnn_s101_fpn_syncbn-backbone%2Bhead_mstrain_1x_coco/cascade_mask_rcnn_s101_fpn_syncbn-backbone%2Bhead_mstrain_1x_coco_20201005_113243-42607475.pth + Paper: + URL: https://arxiv.org/abs/2004.08955 + Title: 'ResNeSt: Split-Attention Networks' + README: configs/resnest/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.7.0/mmdet/models/backbones/resnest.py#L273 + Version: v2.7.0 diff --git a/mmdetection/configs/resnet_strikes_back/README.md b/mmdetection/configs/resnet_strikes_back/README.md new file mode 100644 index 00000000..f015729a --- /dev/null +++ b/mmdetection/configs/resnet_strikes_back/README.md @@ -0,0 +1,40 @@ +# ResNet strikes back + +> [ResNet strikes back: An improved training procedure in timm](https://arxiv.org/abs/2110.00476) + + + +## Abstract + +The influential Residual Networks designed by He et al. remain the gold-standard architecture in numerous scientific publications. They typically serve as the default architecture in studies, or as baselines when new architectures are proposed. Yet there has been significant progress on best practices for training neural networks since the inception of the ResNet architecture in 2015. Novel optimization & dataaugmentation have increased the effectiveness of the training recipes. + +In this paper, we re-evaluate the performance of the vanilla ResNet-50 when trained with a procedure that integrates such advances. We share competitive training settings and pre-trained models in the timm open-source library, with the hope that they will serve as better baselines for future work. For instance, with our more demanding training setting, a vanilla ResNet-50 reaches 80.4% top-1 accuracy at resolution 224×224 on ImageNet-val without extra data or distillation. We also report the performance achieved with popular models with our training procedure. + +
    + +
    + +## Results and Models + +| Method | Backbone | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :----------------: | :------: | :-----: | :------: | :------------: | :---------: | :---------: | :------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| Faster R-CNN | R-50 rsb | 1x | 3.9 | - | 40.8 (+3.4) | - | [Config](./faster-rcnn_r50-rsb-pre_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/resnet_strikes_back/faster_rcnn_r50_fpn_rsb-pretrain_1x_coco/faster_rcnn_r50_fpn_rsb-pretrain_1x_coco_20220113_162229-32ae82a9.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/resnet_strikes_back/faster_rcnn_r50_fpn_rsb-pretrain_1x_coco/faster_rcnn_r50_fpn_rsb-pretrain_1x_coco_20220113_162229.log.json) | +| Mask R-CNN | R-50 rsb | 1x | 4.5 | - | 41.2 (+3.0) | 38.2 (+3.0) | [Config](./mask-rcnn_r50-rsb-pre_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/resnet_strikes_back/mask_rcnn_r50_fpn_rsb-pretrain_1x_coco/mask_rcnn_r50_fpn_rsb-pretrain_1x_coco_20220113_174054-06ce8ba0.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/resnet_strikes_back/mask_rcnn_r50_fpn_rsb-pretrain_1x_coco/mask_rcnn_r50_fpn_rsb-pretrain_1x_coco_20220113_174054.log.json) | +| Cascade Mask R-CNN | R-50 rsb | 1x | 6.2 | - | 44.8 (+3.6) | 39.9 (+3.6) | [Config](./cascade-mask-rcnn_r50-rsb-pre_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/resnet_strikes_back/cascade_mask_rcnn_r50_fpn_rsb-pretrain_1x_coco/cascade_mask_rcnn_r50_fpn_rsb-pretrain_1x_coco_20220113_193636-8b9ad50f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/resnet_strikes_back/cascade_mask_rcnn_r50_fpn_rsb-pretrain_1x_coco/cascade_mask_rcnn_r50_fpn_rsb-pretrain_1x_coco_20220113_193636.log.json) | +| RetinaNet | R-50 rsb | 1x | 3.8 | - | 39.0 (+2.5) | - | [Config](./retinanet_r50-rsb-pre_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/resnet_strikes_back/retinanet_r50_fpn_rsb-pretrain_1x_coco/retinanet_r50_fpn_rsb-pretrain_1x_coco_20220113_175432-bd24aae9.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/resnet_strikes_back/retinanet_r50_fpn_rsb-pretrain_1x_coco/retinanet_r50_fpn_rsb-pretrain_1x_coco_20220113_175432.log.json) | + +**Notes:** + +- 'rsb' is short for 'resnet strikes back' +- We have done some grid searches on learning rate and weight decay and get these optimal hyper-parameters. + +## Citation + +```latex +@article{wightman2021resnet, +title={Resnet strikes back: An improved training procedure in timm}, +author={Ross Wightman, Hugo Touvron, Hervé Jégou}, +journal={arXiv preprint arXiv:2110.00476}, +year={2021} +} +``` diff --git a/mmdetection/configs/resnet_strikes_back/cascade-mask-rcnn_r50-rsb-pre_fpn_1x_coco.py b/mmdetection/configs/resnet_strikes_back/cascade-mask-rcnn_r50-rsb-pre_fpn_1x_coco.py new file mode 100644 index 00000000..de7b95b0 --- /dev/null +++ b/mmdetection/configs/resnet_strikes_back/cascade-mask-rcnn_r50-rsb-pre_fpn_1x_coco.py @@ -0,0 +1,15 @@ +_base_ = [ + '../_base_/models/cascade-mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +checkpoint = 'https://download.openmmlab.com/mmclassification/v0/resnet/resnet50_8xb256-rsb-a1-600e_in1k_20211228-20e21305.pth' # noqa +model = dict( + backbone=dict( + init_cfg=dict( + type='Pretrained', prefix='backbone.', checkpoint=checkpoint))) + +optim_wrapper = dict( + optimizer=dict(_delete_=True, type='AdamW', lr=0.0002, weight_decay=0.05), + paramwise_cfg=dict(norm_decay_mult=0., bypass_duplicate=True)) diff --git a/mmdetection/configs/resnet_strikes_back/faster-rcnn_r50-rsb-pre_fpn_1x_coco.py b/mmdetection/configs/resnet_strikes_back/faster-rcnn_r50-rsb-pre_fpn_1x_coco.py new file mode 100644 index 00000000..8c60f66a --- /dev/null +++ b/mmdetection/configs/resnet_strikes_back/faster-rcnn_r50-rsb-pre_fpn_1x_coco.py @@ -0,0 +1,15 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +checkpoint = 'https://download.openmmlab.com/mmclassification/v0/resnet/resnet50_8xb256-rsb-a1-600e_in1k_20211228-20e21305.pth' # noqa +model = dict( + backbone=dict( + init_cfg=dict( + type='Pretrained', prefix='backbone.', checkpoint=checkpoint))) + +optim_wrapper = dict( + optimizer=dict(_delete_=True, type='AdamW', lr=0.0002, weight_decay=0.05), + paramwise_cfg=dict(norm_decay_mult=0., bypass_duplicate=True)) diff --git a/mmdetection/configs/resnet_strikes_back/mask-rcnn_r50-rsb-pre_fpn_1x_coco.py b/mmdetection/configs/resnet_strikes_back/mask-rcnn_r50-rsb-pre_fpn_1x_coco.py new file mode 100644 index 00000000..85e25d39 --- /dev/null +++ b/mmdetection/configs/resnet_strikes_back/mask-rcnn_r50-rsb-pre_fpn_1x_coco.py @@ -0,0 +1,15 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +checkpoint = 'https://download.openmmlab.com/mmclassification/v0/resnet/resnet50_8xb256-rsb-a1-600e_in1k_20211228-20e21305.pth' # noqa +model = dict( + backbone=dict( + init_cfg=dict( + type='Pretrained', prefix='backbone.', checkpoint=checkpoint))) + +optim_wrapper = dict( + optimizer=dict(_delete_=True, type='AdamW', lr=0.0002, weight_decay=0.05), + paramwise_cfg=dict(norm_decay_mult=0., bypass_duplicate=True)) diff --git a/mmdetection/configs/resnet_strikes_back/metafile.yml b/mmdetection/configs/resnet_strikes_back/metafile.yml new file mode 100644 index 00000000..74b15210 --- /dev/null +++ b/mmdetection/configs/resnet_strikes_back/metafile.yml @@ -0,0 +1,116 @@ +Models: + - Name: faster-rcnn_r50_fpn_rsb-pretrain_1x_coco + In Collection: Faster R-CNN + Config: configs/resnet_strikes_back/faster-rcnn_r50-rsb-pre_fpn_1x_coco.py + Metadata: + Training Memory (GB): 3.9 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - ResNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/resnet_strikes_back/faster_rcnn_r50_fpn_rsb-pretrain_1x_coco/faster_rcnn_r50_fpn_rsb-pretrain_1x_coco_20220113_162229-32ae82a9.pth + Paper: + URL: https://arxiv.org/abs/2110.00476 + Title: 'ResNet strikes back: An improved training procedure in timm' + README: configs/resnet_strikes_back/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.22.0/configs/resnet_strikes_back/README.md + Version: v2.22.0 + + - Name: cascade-mask-rcnn_r50_fpn_rsb-pretrain_1x_coco + In Collection: Cascade R-CNN + Config: configs/resnet_strikes_back/cascade-mask-rcnn_r50-rsb-pre_fpn_1x_coco.py + Metadata: + Training Memory (GB): 6.2 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - ResNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/resnet_strikes_back/cascade_mask_rcnn_r50_fpn_rsb-pretrain_1x_coco/cascade_mask_rcnn_r50_fpn_rsb-pretrain_1x_coco_20220113_193636-8b9ad50f.pth + Paper: + URL: https://arxiv.org/abs/2110.00476 + Title: 'ResNet strikes back: An improved training procedure in timm' + README: configs/resnet_strikes_back/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.22.0/configs/resnet_strikes_back/README.md + Version: v2.22.0 + + - Name: retinanet_r50-rsb-pre_fpn_1x_coco + In Collection: RetinaNet + Config: configs/resnet_strikes_back/retinanet_r50-rsb-pre_fpn_1x_coco.py + Metadata: + Training Memory (GB): 3.8 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - ResNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/resnet_strikes_back/retinanet_r50_fpn_rsb-pretrain_1x_coco/retinanet_r50_fpn_rsb-pretrain_1x_coco_20220113_175432-bd24aae9.pth + Paper: + URL: https://arxiv.org/abs/2110.00476 + Title: 'ResNet strikes back: An improved training procedure in timm' + README: configs/resnet_strikes_back/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.22.0/configs/resnet_strikes_back/README.md + Version: v2.22.0 + + - Name: mask-rcnn_r50_fpn_rsb-pretrain_1x_coco + In Collection: Mask R-CNN + Config: configs/resnet_strikes_back/mask-rcnn_r50-rsb-pre_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.5 + Epochs: 12 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - ResNet + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.2 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/resnet_strikes_back/mask_rcnn_r50_fpn_rsb-pretrain_1x_coco/mask_rcnn_r50_fpn_rsb-pretrain_1x_coco_20220113_174054-06ce8ba0.pth + Paper: + URL: https://arxiv.org/abs/2110.00476 + Title: 'ResNet strikes back: An improved training procedure in timm' + README: configs/resnet_strikes_back/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.22.0/configs/resnet_strikes_back/README.md + Version: v2.22.0 diff --git a/mmdetection/configs/resnet_strikes_back/retinanet_r50-rsb-pre_fpn_1x_coco.py b/mmdetection/configs/resnet_strikes_back/retinanet_r50-rsb-pre_fpn_1x_coco.py new file mode 100644 index 00000000..7ce7bfd8 --- /dev/null +++ b/mmdetection/configs/resnet_strikes_back/retinanet_r50-rsb-pre_fpn_1x_coco.py @@ -0,0 +1,15 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +checkpoint = 'https://download.openmmlab.com/mmclassification/v0/resnet/resnet50_8xb256-rsb-a1-600e_in1k_20211228-20e21305.pth' # noqa +model = dict( + backbone=dict( + init_cfg=dict( + type='Pretrained', prefix='backbone.', checkpoint=checkpoint))) + +optim_wrapper = dict( + optimizer=dict(_delete_=True, type='AdamW', lr=0.0001, weight_decay=0.05), + paramwise_cfg=dict(norm_decay_mult=0., bypass_duplicate=True)) diff --git a/mmdetection/configs/retinanet/README.md b/mmdetection/configs/retinanet/README.md new file mode 100644 index 00000000..b38335a3 --- /dev/null +++ b/mmdetection/configs/retinanet/README.md @@ -0,0 +1,53 @@ +# RetinaNet + +> [Focal Loss for Dense Object Detection](https://arxiv.org/abs/1708.02002) + + + +## Abstract + +The highest accuracy object detectors to date are based on a two-stage approach popularized by R-CNN, where a classifier is applied to a sparse set of candidate object locations. In contrast, one-stage detectors that are applied over a regular, dense sampling of possible object locations have the potential to be faster and simpler, but have trailed the accuracy of two-stage detectors thus far. In this paper, we investigate why this is the case. We discover that the extreme foreground-background class imbalance encountered during training of dense detectors is the central cause. We propose to address this class imbalance by reshaping the standard cross entropy loss such that it down-weights the loss assigned to well-classified examples. Our novel Focal Loss focuses training on a sparse set of hard examples and prevents the vast number of easy negatives from overwhelming the detector during training. To evaluate the effectiveness of our loss, we design and train a simple dense detector we call RetinaNet. Our results show that when trained with the focal loss, RetinaNet is able to match the speed of previous one-stage detectors while surpassing the accuracy of all existing state-of-the-art two-stage detectors. + +
    + +
    + +## Results and Models + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :-------------: | :-----: | :----------: | :------: | :------------: | :----: | :---------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-18-FPN | pytorch | 1x | 1.7 | | 31.7 | [config](./retinanet_r18_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r18_fpn_1x_coco/retinanet_r18_fpn_1x_coco_20220407_171055-614fd399.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r18_fpn_1x_coco/retinanet_r18_fpn_1x_coco_20220407_171055.log.json) | +| R-18-FPN | pytorch | 1x(1 x 8 BS) | 5.0 | | 31.7 | [config](./retinanet_r18_fpn_1xb8-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r18_fpn_1x8_1x_coco/retinanet_r18_fpn_1x8_1x_coco_20220407_171255-4ea310d7.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r18_fpn_1x8_1x_coco/retinanet_r18_fpn_1x8_1x_coco_20220407_171255.log.json) | +| R-50-FPN | caffe | 1x | 3.5 | 18.6 | 36.3 | [config](./retinanet_r50-caffe_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r50_caffe_fpn_1x_coco/retinanet_r50_caffe_fpn_1x_coco_20200531-f11027c5.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r50_caffe_fpn_1x_coco/retinanet_r50_caffe_fpn_1x_coco_20200531_012518.log.json) | +| R-50-FPN | pytorch | 1x | 3.8 | 19.0 | 36.5 | [config](./retinanet_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r50_fpn_1x_coco/retinanet_r50_fpn_1x_coco_20200130-c2398f9e.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r50_fpn_1x_coco/retinanet_r50_fpn_1x_coco_20200130_002941.log.json) | +| R-50-FPN (FP16) | pytorch | 1x | 2.8 | 31.6 | 36.4 | [config](./retinanet_r50_fpn_amp-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/fp16/retinanet_r50_fpn_fp16_1x_coco/retinanet_r50_fpn_fp16_1x_coco_20200702-0dbfb212.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/fp16/retinanet_r50_fpn_fp16_1x_coco/retinanet_r50_fpn_fp16_1x_coco_20200702_020127.log.json) | +| R-50-FPN | pytorch | 2x | - | - | 37.4 | [config](./retinanet_r50_fpn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r50_fpn_2x_coco/retinanet_r50_fpn_2x_coco_20200131-fdb43119.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r50_fpn_2x_coco/retinanet_r50_fpn_2x_coco_20200131_114738.log.json) | +| R-101-FPN | caffe | 1x | 5.5 | 14.7 | 38.5 | [config](./retinanet_r101-caffe_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r101_caffe_fpn_1x_coco/retinanet_r101_caffe_fpn_1x_coco_20200531-b428fa0f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r101_caffe_fpn_1x_coco/retinanet_r101_caffe_fpn_1x_coco_20200531_012536.log.json) | +| R-101-FPN | pytorch | 1x | 5.7 | 15.0 | 38.5 | [config](./retinanet_r101_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r101_fpn_1x_coco/retinanet_r101_fpn_1x_coco_20200130-7a93545f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r101_fpn_1x_coco/retinanet_r101_fpn_1x_coco_20200130_003055.log.json) | +| R-101-FPN | pytorch | 2x | - | - | 38.9 | [config](./retinanet_r101_fpn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r101_fpn_2x_coco/retinanet_r101_fpn_2x_coco_20200131-5560aee8.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r101_fpn_2x_coco/retinanet_r101_fpn_2x_coco_20200131_114859.log.json) | +| X-101-32x4d-FPN | pytorch | 1x | 7.0 | 12.1 | 39.9 | [config](./retinanet_x101-32x4d_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_x101_32x4d_fpn_1x_coco/retinanet_x101_32x4d_fpn_1x_coco_20200130-5c8b7ec4.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_x101_32x4d_fpn_1x_coco/retinanet_x101_32x4d_fpn_1x_coco_20200130_003004.log.json) | +| X-101-32x4d-FPN | pytorch | 2x | - | - | 40.1 | [config](./retinanet_x101-32x4d_fpn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_x101_32x4d_fpn_2x_coco/retinanet_x101_32x4d_fpn_2x_coco_20200131-237fc5e1.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_x101_32x4d_fpn_2x_coco/retinanet_x101_32x4d_fpn_2x_coco_20200131_114812.log.json) | +| X-101-64x4d-FPN | pytorch | 1x | 10.0 | 8.7 | 41.0 | [config](./retinanet_x101-64x4d_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_x101_64x4d_fpn_1x_coco/retinanet_x101_64x4d_fpn_1x_coco_20200130-366f5af1.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_x101_64x4d_fpn_1x_coco/retinanet_x101_64x4d_fpn_1x_coco_20200130_003008.log.json) | +| X-101-64x4d-FPN | pytorch | 2x | - | - | 40.8 | [config](./retinanet_x101-64x4d_fpn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_x101_64x4d_fpn_2x_coco/retinanet_x101_64x4d_fpn_2x_coco_20200131-bca068ab.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_x101_64x4d_fpn_2x_coco/retinanet_x101_64x4d_fpn_2x_coco_20200131_114833.log.json) | + +## Pre-trained Models + +We also train some models with longer schedules and multi-scale training. The users could finetune them for downstream tasks. + +| Backbone | Style | Lr schd | Mem (GB) | box AP | Config | Download | +| :-------------: | :-----: | :-----: | :------: | :----: | :--------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | pytorch | 3x | 3.5 | 39.5 | [config](./retinanet_r50_fpn_ms-640-800-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r50_fpn_mstrain_3x_coco/retinanet_r50_fpn_mstrain_3x_coco_20210718_220633-88476508.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r50_fpn_mstrain_3x_coco/retinanet_r50_fpn_mstrain_3x_coco_20210718_220633-88476508.log.json) | +| R-101-FPN | caffe | 3x | 5.4 | 40.7 | [config](./retinanet_r101-caffe_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r101_caffe_fpn_mstrain_3x_coco/retinanet_r101_caffe_fpn_mstrain_3x_coco_20210721_063439-88a8a944.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r101_caffe_fpn_mstrain_3x_coco/retinanet_r101_caffe_fpn_mstrain_3x_coco_20210721_063439-88a8a944.log.json) | +| R-101-FPN | pytorch | 3x | 5.4 | 41 | [config](./retinanet_r101_fpn_ms-640-800-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r101_fpn_mstrain_3x_coco/retinanet_r101_fpn_mstrain_3x_coco_20210720_214650-7ee888e0.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r101_fpn_mstrain_3x_coco/retinanet_r101_fpn_mstrain_3x_coco_20210720_214650-7ee888e0.log.json) | +| X-101-64x4d-FPN | pytorch | 3x | 9.8 | 41.6 | [config](./retinanet_x101-64x4d_fpn_ms-640-800-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_x101_64x4d_fpn_mstrain_3x_coco/retinanet_x101_64x4d_fpn_mstrain_3x_coco_20210719_051838-022c2187.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_x101_64x4d_fpn_mstrain_3x_coco/retinanet_x101_64x4d_fpn_mstrain_3x_coco_20210719_051838-022c2187.log.json) | + +## Citation + +```latex +@inproceedings{lin2017focal, + title={Focal loss for dense object detection}, + author={Lin, Tsung-Yi and Goyal, Priya and Girshick, Ross and He, Kaiming and Doll{\'a}r, Piotr}, + booktitle={Proceedings of the IEEE international conference on computer vision}, + year={2017} +} +``` diff --git a/mmdetection/configs/retinanet/metafile.yml b/mmdetection/configs/retinanet/metafile.yml new file mode 100644 index 00000000..0551541c --- /dev/null +++ b/mmdetection/configs/retinanet/metafile.yml @@ -0,0 +1,312 @@ +Collections: + - Name: RetinaNet + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - Focal Loss + - FPN + - ResNet + Paper: + URL: https://arxiv.org/abs/1708.02002 + Title: "Focal Loss for Dense Object Detection" + README: configs/retinanet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/detectors/retinanet.py#L6 + Version: v2.0.0 + +Models: + - Name: retinanet_r18_fpn_1x_coco + In Collection: RetinaNet + Config: configs/retinanet/retinanet_r18_fpn_1x_coco.py + Metadata: + Training Memory (GB): 1.7 + Training Resources: 8x V100 GPUs + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 31.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r18_fpn_1x_coco/retinanet_r18_fpn_1x_coco_20220407_171055-614fd399.pth + + - Name: retinanet_r18_fpn_1xb8-1x_coco + In Collection: RetinaNet + Config: configs/retinanet/retinanet_r18_fpn_1xb8-1x_coco.py + Metadata: + Training Memory (GB): 5.0 + Training Resources: 1x V100 GPUs + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 31.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r18_fpn_1x8_1x_coco/retinanet_r18_fpn_1x8_1x_coco_20220407_171255-4ea310d7.pth + + - Name: retinanet_r50-caffe_fpn_1x_coco + In Collection: RetinaNet + Config: configs/retinanet/retinanet_r50-caffe_fpn_1x_coco.py + Metadata: + Training Memory (GB): 3.5 + inference time (ms/im): + - value: 53.76 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 36.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r50_caffe_fpn_1x_coco/retinanet_r50_caffe_fpn_1x_coco_20200531-f11027c5.pth + + - Name: retinanet_r50_fpn_1x_coco + In Collection: RetinaNet + Config: configs/retinanet/retinanet_r50_fpn_1x_coco.py + Metadata: + Training Memory (GB): 3.8 + inference time (ms/im): + - value: 52.63 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 36.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r50_fpn_1x_coco/retinanet_r50_fpn_1x_coco_20200130-c2398f9e.pth + + - Name: retinanet_r50_fpn_amp-1x_coco + In Collection: RetinaNet + Config: configs/retinanet/retinanet_r50_fpn_amp-1x_coco.py + Metadata: + Training Memory (GB): 2.8 + Training Techniques: + - SGD with Momentum + - Weight Decay + - Mixed Precision Training + inference time (ms/im): + - value: 31.65 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP16 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 36.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/fp16/retinanet_r50_fpn_fp16_1x_coco/retinanet_r50_fpn_fp16_1x_coco_20200702-0dbfb212.pth + + - Name: retinanet_r50_fpn_2x_coco + In Collection: RetinaNet + Config: configs/retinanet/retinanet_r50_fpn_2x_coco.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r50_fpn_2x_coco/retinanet_r50_fpn_2x_coco_20200131-fdb43119.pth + + - Name: retinanet_r50_fpn_ms-640-800-3x_coco + In Collection: RetinaNet + Config: configs/retinanet/retinanet_r50_fpn_ms-640-800-3x_coco.py + Metadata: + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r50_fpn_mstrain_3x_coco/retinanet_r50_fpn_mstrain_3x_coco_20210718_220633-88476508.pth + + - Name: retinanet_r101-caffe_fpn_1x_coco + In Collection: RetinaNet + Config: configs/retinanet/retinanet_r101-caffe_fpn_1x_coco.py + Metadata: + Training Memory (GB): 5.5 + inference time (ms/im): + - value: 68.03 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r101_caffe_fpn_1x_coco/retinanet_r101_caffe_fpn_1x_coco_20200531-b428fa0f.pth + + - Name: retinanet_r101-caffe_fpn_ms-3x_coco + In Collection: RetinaNet + Config: configs/retinanet/retinanet_r101-caffe_fpn_ms-3x_coco.py + Metadata: + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r101_caffe_fpn_mstrain_3x_coco/retinanet_r101_caffe_fpn_mstrain_3x_coco_20210721_063439-88a8a944.pth + + - Name: retinanet_r101_fpn_1x_coco + In Collection: RetinaNet + Config: configs/retinanet/retinanet_r101_fpn_1x_coco.py + Metadata: + Training Memory (GB): 5.7 + inference time (ms/im): + - value: 66.67 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r101_fpn_1x_coco/retinanet_r101_fpn_1x_coco_20200130-7a93545f.pth + + - Name: retinanet_r101_fpn_2x_coco + In Collection: RetinaNet + Config: configs/retinanet/retinanet_r101_fpn_2x_coco.py + Metadata: + Training Memory (GB): 5.7 + inference time (ms/im): + - value: 66.67 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r101_fpn_2x_coco/retinanet_r101_fpn_2x_coco_20200131-5560aee8.pth + + - Name: retinanet_r101_fpn_ms-640-800-3x_coco + In Collection: RetinaNet + Config: configs/retinanet/retinanet_r101_fpn_ms-640-800-3x_coco.py + Metadata: + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41 + Weights: https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r101_fpn_mstrain_3x_coco/retinanet_r101_fpn_mstrain_3x_coco_20210720_214650-7ee888e0.pth + + - Name: retinanet_x101-32x4d_fpn_1x_coco + In Collection: RetinaNet + Config: configs/retinanet/retinanet_x101-32x4d_fpn_1x_coco.py + Metadata: + Training Memory (GB): 7.0 + inference time (ms/im): + - value: 82.64 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_x101_32x4d_fpn_1x_coco/retinanet_x101_32x4d_fpn_1x_coco_20200130-5c8b7ec4.pth + + - Name: retinanet_x101-32x4d_fpn_2x_coco + In Collection: RetinaNet + Config: configs/retinanet/retinanet_x101-32x4d_fpn_2x_coco.py + Metadata: + Training Memory (GB): 7.0 + inference time (ms/im): + - value: 82.64 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_x101_32x4d_fpn_2x_coco/retinanet_x101_32x4d_fpn_2x_coco_20200131-237fc5e1.pth + + - Name: retinanet_x101-64x4d_fpn_1x_coco + In Collection: RetinaNet + Config: configs/retinanet/retinanet_x101-64x4d_fpn_1x_coco.py + Metadata: + Training Memory (GB): 10.0 + inference time (ms/im): + - value: 114.94 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_x101_64x4d_fpn_1x_coco/retinanet_x101_64x4d_fpn_1x_coco_20200130-366f5af1.pth + + - Name: retinanet_x101-64x4d_fpn_2x_coco + In Collection: RetinaNet + Config: configs/retinanet/retinanet_x101-64x4d_fpn_2x_coco.py + Metadata: + Training Memory (GB): 10.0 + inference time (ms/im): + - value: 114.94 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_x101_64x4d_fpn_2x_coco/retinanet_x101_64x4d_fpn_2x_coco_20200131-bca068ab.pth + + - Name: retinanet_x101-64x4d_fpn_ms-640-800-3x_coco + In Collection: RetinaNet + Config: configs/retinanet/retinanet_x101-64x4d_fpn_ms-640-800-3x_coco.py + Metadata: + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_x101_64x4d_fpn_mstrain_3x_coco/retinanet_x101_64x4d_fpn_mstrain_3x_coco_20210719_051838-022c2187.pth diff --git a/mmdetection/configs/retinanet/retinanet_r101-caffe_fpn_1x_coco.py b/mmdetection/configs/retinanet/retinanet_r101-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..1f3a4487 --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_r101-caffe_fpn_1x_coco.py @@ -0,0 +1,7 @@ +_base_ = './retinanet_r50-caffe_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet101_caffe'))) diff --git a/mmdetection/configs/retinanet/retinanet_r101-caffe_fpn_ms-3x_coco.py b/mmdetection/configs/retinanet/retinanet_r101-caffe_fpn_ms-3x_coco.py new file mode 100644 index 00000000..cfe77345 --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_r101-caffe_fpn_ms-3x_coco.py @@ -0,0 +1,8 @@ +_base_ = './retinanet_r50-caffe_fpn_ms-3x_coco.py' +# learning policy +model = dict( + backbone=dict( + depth=101, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet101_caffe'))) diff --git a/mmdetection/configs/retinanet/retinanet_r101_fpn_1x_coco.py b/mmdetection/configs/retinanet/retinanet_r101_fpn_1x_coco.py new file mode 100644 index 00000000..a7f06002 --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_r101_fpn_1x_coco.py @@ -0,0 +1,6 @@ +_base_ = './retinanet_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/retinanet/retinanet_r101_fpn_2x_coco.py b/mmdetection/configs/retinanet/retinanet_r101_fpn_2x_coco.py new file mode 100644 index 00000000..721112a2 --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_r101_fpn_2x_coco.py @@ -0,0 +1,6 @@ +_base_ = './retinanet_r50_fpn_2x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/retinanet/retinanet_r101_fpn_8xb8-amp-lsj-200e_coco.py b/mmdetection/configs/retinanet/retinanet_r101_fpn_8xb8-amp-lsj-200e_coco.py new file mode 100644 index 00000000..be018eaa --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_r101_fpn_8xb8-amp-lsj-200e_coco.py @@ -0,0 +1,7 @@ +_base_ = './retinanet_r50_fpn_8xb8-amp-lsj-200e_coco.py' + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/retinanet/retinanet_r101_fpn_ms-640-800-3x_coco.py b/mmdetection/configs/retinanet/retinanet_r101_fpn_ms-640-800-3x_coco.py new file mode 100644 index 00000000..56639722 --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_r101_fpn_ms-640-800-3x_coco.py @@ -0,0 +1,9 @@ +_base_ = ['../_base_/models/retinanet_r50_fpn.py', '../common/ms_3x_coco.py'] +# optimizer +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) diff --git a/mmdetection/configs/retinanet/retinanet_r18_fpn_1x_coco.py b/mmdetection/configs/retinanet/retinanet_r18_fpn_1x_coco.py new file mode 100644 index 00000000..96021180 --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_r18_fpn_1x_coco.py @@ -0,0 +1,20 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +# model +model = dict( + backbone=dict( + depth=18, + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet18')), + neck=dict(in_channels=[64, 128, 256, 512])) +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) + +# TODO: support auto scaling lr +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (2 samples per GPU) +# auto_scale_lr = dict(base_batch_size=16) diff --git a/mmdetection/configs/retinanet/retinanet_r18_fpn_1xb8-1x_coco.py b/mmdetection/configs/retinanet/retinanet_r18_fpn_1xb8-1x_coco.py new file mode 100644 index 00000000..d2e88d68 --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_r18_fpn_1xb8-1x_coco.py @@ -0,0 +1,24 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +# data +train_dataloader = dict(batch_size=8) + +# model +model = dict( + backbone=dict( + depth=18, + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet18')), + neck=dict(in_channels=[64, 128, 256, 512])) + +# Note: If the learning rate is set to 0.0025, the mAP will be 32.4. +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.005, momentum=0.9, weight_decay=0.0001)) +# TODO: support auto scaling lr +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (1 GPUs) x (8 samples per GPU) +# auto_scale_lr = dict(base_batch_size=8) diff --git a/mmdetection/configs/retinanet/retinanet_r18_fpn_8xb8-amp-lsj-200e_coco.py b/mmdetection/configs/retinanet/retinanet_r18_fpn_8xb8-amp-lsj-200e_coco.py new file mode 100644 index 00000000..d6833f3f --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_r18_fpn_8xb8-amp-lsj-200e_coco.py @@ -0,0 +1,7 @@ +_base_ = './retinanet_r50_fpn_8xb8-amp-lsj-200e_coco.py' + +model = dict( + backbone=dict( + depth=18, + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet18')), + neck=dict(in_channels=[64, 128, 256, 512])) diff --git a/mmdetection/configs/retinanet/retinanet_r50-caffe_fpn_1x_coco.py b/mmdetection/configs/retinanet/retinanet_r50-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..6ba1cddd --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_r50-caffe_fpn_1x_coco.py @@ -0,0 +1,16 @@ +_base_ = './retinanet_r50_fpn_1x_coco.py' +model = dict( + data_preprocessor=dict( + type='DetDataPreprocessor', + # use caffe img_norm + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False, + pad_size_divisor=32), + backbone=dict( + norm_cfg=dict(requires_grad=False), + norm_eval=True, + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe'))) diff --git a/mmdetection/configs/retinanet/retinanet_r50-caffe_fpn_ms-1x_coco.py b/mmdetection/configs/retinanet/retinanet_r50-caffe_fpn_ms-1x_coco.py new file mode 100644 index 00000000..93687d8c --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_r50-caffe_fpn_ms-1x_coco.py @@ -0,0 +1,15 @@ +_base_ = './retinanet_r50-caffe_fpn_1x_coco.py' + +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736), + (1333, 768), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/mmdetection/configs/retinanet/retinanet_r50-caffe_fpn_ms-2x_coco.py b/mmdetection/configs/retinanet/retinanet_r50-caffe_fpn_ms-2x_coco.py new file mode 100644 index 00000000..6d1604fb --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_r50-caffe_fpn_ms-2x_coco.py @@ -0,0 +1,16 @@ +_base_ = './retinanet_r50-caffe_fpn_ms-1x_coco.py' +# training schedule for 2x +train_cfg = dict(max_epochs=24) + +# learning rate policy +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=24, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/retinanet/retinanet_r50-caffe_fpn_ms-3x_coco.py b/mmdetection/configs/retinanet/retinanet_r50-caffe_fpn_ms-3x_coco.py new file mode 100644 index 00000000..5a6d42a1 --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_r50-caffe_fpn_ms-3x_coco.py @@ -0,0 +1,17 @@ +_base_ = './retinanet_r50-caffe_fpn_ms-1x_coco.py' + +# training schedule for 2x +train_cfg = dict(max_epochs=36) + +# learning rate policy +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=36, + by_epoch=True, + milestones=[28, 34], + gamma=0.1) +] diff --git a/mmdetection/configs/retinanet/retinanet_r50_fpn_1x_coco.py b/mmdetection/configs/retinanet/retinanet_r50_fpn_1x_coco.py new file mode 100644 index 00000000..00d2567b --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_r50_fpn_1x_coco.py @@ -0,0 +1,10 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py', + './retinanet_tta.py' +] + +# optimizer +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) diff --git a/mmdetection/configs/retinanet/retinanet_r50_fpn_2x_coco.py b/mmdetection/configs/retinanet/retinanet_r50_fpn_2x_coco.py new file mode 100644 index 00000000..47511b78 --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_r50_fpn_2x_coco.py @@ -0,0 +1,25 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +# training schedule for 2x +train_cfg = dict(max_epochs=24) + +# learning rate policy +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=24, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) diff --git a/mmdetection/configs/retinanet/retinanet_r50_fpn_8xb8-amp-lsj-200e_coco.py b/mmdetection/configs/retinanet/retinanet_r50_fpn_8xb8-amp-lsj-200e_coco.py new file mode 100644 index 00000000..2f10db2f --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_r50_fpn_8xb8-amp-lsj-200e_coco.py @@ -0,0 +1,21 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../common/lsj-200e_coco-detection.py' +] + +image_size = (1024, 1024) +batch_augments = [dict(type='BatchFixedSizePad', size=image_size)] + +model = dict(data_preprocessor=dict(batch_augments=batch_augments)) + +train_dataloader = dict(batch_size=8, num_workers=4) +# Enable automatic-mixed-precision training with AmpOptimWrapper. +optim_wrapper = dict( + type='AmpOptimWrapper', + optimizer=dict( + type='SGD', lr=0.01 * 4, momentum=0.9, weight_decay=0.00004)) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (8 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/retinanet/retinanet_r50_fpn_90k_coco.py b/mmdetection/configs/retinanet/retinanet_r50_fpn_90k_coco.py new file mode 100644 index 00000000..1e1b2fd9 --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_r50_fpn_90k_coco.py @@ -0,0 +1,24 @@ +_base_ = 'retinanet_r50_fpn_1x_coco.py' + +# training schedule for 90k +train_cfg = dict( + _delete_=True, + type='IterBasedTrainLoop', + max_iters=90000, + val_interval=10000) +# learning rate policy +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=90000, + by_epoch=False, + milestones=[60000, 80000], + gamma=0.1) +] +train_dataloader = dict(sampler=dict(type='InfiniteSampler')) +default_hooks = dict(checkpoint=dict(by_epoch=False, interval=10000)) + +log_processor = dict(by_epoch=False) diff --git a/mmdetection/configs/retinanet/retinanet_r50_fpn_amp-1x_coco.py b/mmdetection/configs/retinanet/retinanet_r50_fpn_amp-1x_coco.py new file mode 100644 index 00000000..acf52663 --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_r50_fpn_amp-1x_coco.py @@ -0,0 +1,6 @@ +_base_ = './retinanet_r50_fpn_1x_coco.py' + +# MMEngine support the following two ways, users can choose +# according to convenience +# optim_wrapper = dict(type='AmpOptimWrapper') +_base_.optim_wrapper.type = 'AmpOptimWrapper' diff --git a/mmdetection/configs/retinanet/retinanet_r50_fpn_ms-640-800-3x_coco.py b/mmdetection/configs/retinanet/retinanet_r50_fpn_ms-640-800-3x_coco.py new file mode 100644 index 00000000..d91cf8ce --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_r50_fpn_ms-640-800-3x_coco.py @@ -0,0 +1,4 @@ +_base_ = ['../_base_/models/retinanet_r50_fpn.py', '../common/ms_3x_coco.py'] +# optimizer +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) diff --git a/mmdetection/configs/retinanet/retinanet_tta.py b/mmdetection/configs/retinanet/retinanet_tta.py new file mode 100644 index 00000000..d0f37e0a --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_tta.py @@ -0,0 +1,23 @@ +tta_model = dict( + type='DetTTAModel', + tta_cfg=dict(nms=dict(type='nms', iou_threshold=0.5), max_per_img=100)) + +img_scales = [(1333, 800), (666, 400), (2000, 1200)] +tta_pipeline = [ + dict(type='LoadImageFromFile', backend_args=None), + dict( + type='TestTimeAug', + transforms=[[ + dict(type='Resize', scale=s, keep_ratio=True) for s in img_scales + ], [ + dict(type='RandomFlip', prob=1.), + dict(type='RandomFlip', prob=0.) + ], [dict(type='LoadAnnotations', with_bbox=True)], + [ + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', + 'img_shape', 'scale_factor', 'flip', + 'flip_direction')) + ]]) +] diff --git a/mmdetection/configs/retinanet/retinanet_x101-32x4d_fpn_1x_coco.py b/mmdetection/configs/retinanet/retinanet_x101-32x4d_fpn_1x_coco.py new file mode 100644 index 00000000..765a4c2c --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_x101-32x4d_fpn_1x_coco.py @@ -0,0 +1,14 @@ +_base_ = './retinanet_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/retinanet/retinanet_x101-32x4d_fpn_2x_coco.py b/mmdetection/configs/retinanet/retinanet_x101-32x4d_fpn_2x_coco.py new file mode 100644 index 00000000..14de96fa --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_x101-32x4d_fpn_2x_coco.py @@ -0,0 +1,14 @@ +_base_ = './retinanet_r50_fpn_2x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/retinanet/retinanet_x101-64x4d_fpn_1x_coco.py b/mmdetection/configs/retinanet/retinanet_x101-64x4d_fpn_1x_coco.py new file mode 100644 index 00000000..948cd18e --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_x101-64x4d_fpn_1x_coco.py @@ -0,0 +1,14 @@ +_base_ = './retinanet_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/retinanet/retinanet_x101-64x4d_fpn_2x_coco.py b/mmdetection/configs/retinanet/retinanet_x101-64x4d_fpn_2x_coco.py new file mode 100644 index 00000000..ad04b6ee --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_x101-64x4d_fpn_2x_coco.py @@ -0,0 +1,14 @@ +_base_ = './retinanet_r50_fpn_2x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/retinanet/retinanet_x101-64x4d_fpn_ms-640-800-3x_coco.py b/mmdetection/configs/retinanet/retinanet_x101-64x4d_fpn_ms-640-800-3x_coco.py new file mode 100644 index 00000000..85313416 --- /dev/null +++ b/mmdetection/configs/retinanet/retinanet_x101-64x4d_fpn_ms-640-800-3x_coco.py @@ -0,0 +1,11 @@ +_base_ = ['../_base_/models/retinanet_r50_fpn.py', '../common/ms_3x_coco.py'] +# optimizer +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) +optim_wrapper = dict(optimizer=dict(type='SGD', lr=0.01)) diff --git a/mmdetection/configs/rpn/README.md b/mmdetection/configs/rpn/README.md new file mode 100644 index 00000000..bd328b47 --- /dev/null +++ b/mmdetection/configs/rpn/README.md @@ -0,0 +1,39 @@ +# RPN + +> [Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks](https://arxiv.org/abs/1506.01497) + + + +## Abstract + +State-of-the-art object detection networks depend on region proposal algorithms to hypothesize object locations. Advances like SPPnet and Fast R-CNN have reduced the running time of these detection networks, exposing region proposal computation as a bottleneck. In this work, we introduce a Region Proposal Network (RPN) that shares full-image convolutional features with the detection network, thus enabling nearly cost-free region proposals. An RPN is a fully convolutional network that simultaneously predicts object bounds and objectness scores at each position. The RPN is trained end-to-end to generate high-quality region proposals, which are used by Fast R-CNN for detection. We further merge RPN and Fast R-CNN into a single network by sharing their convolutional features---using the recently popular terminology of neural networks with 'attention' mechanisms, the RPN component tells the unified network where to look. For the very deep VGG-16 model, our detection system has a frame rate of 5fps (including all steps) on a GPU, while achieving state-of-the-art object detection accuracy on PASCAL VOC 2007, 2012, and MS COCO datasets with only 300 proposals per image. In ILSVRC and COCO 2015 competitions, Faster R-CNN and RPN are the foundations of the 1st-place winning entries in several tracks. + +
    + +
    + +## Results and Models + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | AR1000 | Config | Download | +| :-------------: | :-----: | :-----: | :------: | :------------: | :----: | :---------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | caffe | 1x | 3.5 | 22.6 | 58.7 | [config](./rpn_r50-caffe_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_r50_caffe_fpn_1x_coco/rpn_r50_caffe_fpn_1x_coco_20200531-5b903a37.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_r50_caffe_fpn_1x_coco/rpn_r50_caffe_fpn_1x_coco_20200531_012334.log.json) | +| R-50-FPN | pytorch | 1x | 3.8 | 22.3 | 58.2 | [config](./rpn_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_r50_fpn_1x_coco/rpn_r50_fpn_1x_coco_20200218-5525fa2e.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_r50_fpn_1x_coco/rpn_r50_fpn_1x_coco_20200218_151240.log.json) | +| R-50-FPN | pytorch | 2x | - | - | 58.6 | [config](./rpn_r50_fpn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_r50_fpn_2x_coco/rpn_r50_fpn_2x_coco_20200131-0728c9b3.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_r50_fpn_2x_coco/rpn_r50_fpn_2x_coco_20200131_190631.log.json) | +| R-101-FPN | caffe | 1x | 5.4 | 17.3 | 60.0 | [config](./rpn_r101-caffe_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_r101_caffe_fpn_1x_coco/rpn_r101_caffe_fpn_1x_coco_20200531-0629a2e2.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_r101_caffe_fpn_1x_coco/rpn_r101_caffe_fpn_1x_coco_20200531_012345.log.json) | +| R-101-FPN | pytorch | 1x | 5.8 | 16.5 | 59.7 | [config](./rpn_r101_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_r101_fpn_1x_coco/rpn_r101_fpn_1x_coco_20200131-2ace2249.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_r101_fpn_1x_coco/rpn_r101_fpn_1x_coco_20200131_191000.log.json) | +| R-101-FPN | pytorch | 2x | - | - | 60.2 | [config](./rpn_r101_fpn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_r101_fpn_2x_coco/rpn_r101_fpn_2x_coco_20200131-24e3db1a.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_r101_fpn_2x_coco/rpn_r101_fpn_2x_coco_20200131_191106.log.json) | +| X-101-32x4d-FPN | pytorch | 1x | 7.0 | 13.0 | 60.6 | [config](./rpn_x101-32x4d_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_x101_32x4d_fpn_1x_coco/rpn_x101_32x4d_fpn_1x_coco_20200219-b02646c6.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_x101_32x4d_fpn_1x_coco/rpn_x101_32x4d_fpn_1x_coco_20200219_012037.log.json) | +| X-101-32x4d-FPN | pytorch | 2x | - | - | 61.1 | [config](./rpn_x101-32x4d_fpn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_x101_32x4d_fpn_2x_coco/rpn_x101_32x4d_fpn_2x_coco_20200208-d22bd0bb.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_x101_32x4d_fpn_2x_coco/rpn_x101_32x4d_fpn_2x_coco_20200208_200752.log.json) | +| X-101-64x4d-FPN | pytorch | 1x | 10.1 | 9.1 | 61.0 | [config](./rpn_x101-64x4d_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_x101_64x4d_fpn_1x_coco/rpn_x101_64x4d_fpn_1x_coco_20200208-cde6f7dd.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_x101_64x4d_fpn_1x_coco/rpn_x101_64x4d_fpn_1x_coco_20200208_200752.log.json) | +| X-101-64x4d-FPN | pytorch | 2x | - | - | 61.5 | [config](./rpn_x101-64x4d_fpn_2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_x101_64x4d_fpn_2x_coco/rpn_x101_64x4d_fpn_2x_coco_20200208-c65f524f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_x101_64x4d_fpn_2x_coco/rpn_x101_64x4d_fpn_2x_coco_20200208_200752.log.json) | + +## Citation + +```latex +@inproceedings{ren2015faster, + title={Faster r-cnn: Towards real-time object detection with region proposal networks}, + author={Ren, Shaoqing and He, Kaiming and Girshick, Ross and Sun, Jian}, + booktitle={Advances in neural information processing systems}, + year={2015} +} +``` diff --git a/mmdetection/configs/rpn/metafile.yml b/mmdetection/configs/rpn/metafile.yml new file mode 100644 index 00000000..9796ead6 --- /dev/null +++ b/mmdetection/configs/rpn/metafile.yml @@ -0,0 +1,127 @@ +Collections: + - Name: RPN + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - FPN + - ResNet + Paper: + URL: https://arxiv.org/abs/1506.01497 + Title: "Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks" + README: configs/rpn/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/mmdet/models/detectors/rpn.py#L6 + Version: v2.0.0 + +Models: + - Name: rpn_r50-caffe_fpn_1x_coco + In Collection: RPN + Config: configs/rpn/rpn_r50-caffe_fpn_1x_coco.py + Metadata: + Training Memory (GB): 3.5 + Training Resources: 8x V100 GPUs + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + AR@1000: 58.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_r50_caffe_fpn_1x_coco/rpn_r50_caffe_fpn_1x_coco_20200531-5b903a37.pth + + - Name: rpn_r50_fpn_1x_coco + In Collection: RPN + Config: configs/rpn/rpn_r50_fpn_1x_coco.py + Metadata: + Training Memory (GB): 3.8 + Training Resources: 8x V100 GPUs + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + AR@1000: 58.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_r50_fpn_1x_coco/rpn_r50_fpn_1x_coco_20200218-5525fa2e.pth + + - Name: rpn_r50_fpn_2x_coco + In Collection: RPN + Config: rpn_r50_fpn_2x_coco.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + AR@1000: 58.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_r50_fpn_2x_coco/rpn_r50_fpn_2x_coco_20200131-0728c9b3.pth + + - Name: rpn_r101-caffe_fpn_1x_coco + In Collection: RPN + Config: configs/rpn/rpn_r101-caffe_fpn_1x_coco.py + Metadata: + Training Memory (GB): 5.4 + Training Resources: 8x V100 GPUs + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + AR@1000: 60.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_r101_caffe_fpn_1x_coco/rpn_r101_caffe_fpn_1x_coco_20200531-0629a2e2.pth + + - Name: rpn_x101-32x4d_fpn_1x_coco + In Collection: RPN + Config: configs/rpn/rpn_x101-32x4d_fpn_1x_coco.py + Metadata: + Training Memory (GB): 7.0 + Training Resources: 8x V100 GPUs + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + AR@1000: 60.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_x101_32x4d_fpn_1x_coco/rpn_x101_32x4d_fpn_1x_coco_20200219-b02646c6.pth + + - Name: rpn_x101-32x4d_fpn_2x_coco + In Collection: RPN + Config: configs/rpn/rpn_x101-32x4d_fpn_2x_coco.py + Metadata: + Training Resources: 8x V100 GPUs + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + AR@1000: 61.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_x101_32x4d_fpn_2x_coco/rpn_x101_32x4d_fpn_2x_coco_20200208-d22bd0bb.pth + + - Name: rpn_x101-64x4d_fpn_1x_coco + In Collection: RPN + Config: configs/rpn/rpn_x101-64x4d_fpn_1x_coco.py + Metadata: + Training Memory (GB): 10.1 + Training Resources: 8x V100 GPUs + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + AR@1000: 61.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_x101_64x4d_fpn_1x_coco/rpn_x101_64x4d_fpn_1x_coco_20200208-cde6f7dd.pth + + - Name: rpn_x101-64x4d_fpn_2x_coco + In Collection: RPN + Config: configs/rpn/rpn_x101-64x4d_fpn_2x_coco.py + Metadata: + Training Resources: 8x V100 GPUs + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + AR@1000: 61.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/rpn/rpn_x101_64x4d_fpn_2x_coco/rpn_x101_64x4d_fpn_2x_coco_20200208-c65f524f.pth diff --git a/mmdetection/configs/rpn/rpn_r101-caffe_fpn_1x_coco.py b/mmdetection/configs/rpn/rpn_r101-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..22977af8 --- /dev/null +++ b/mmdetection/configs/rpn/rpn_r101-caffe_fpn_1x_coco.py @@ -0,0 +1,7 @@ +_base_ = './rpn_r50-caffe_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet101_caffe'))) diff --git a/mmdetection/configs/rpn/rpn_r101_fpn_1x_coco.py b/mmdetection/configs/rpn/rpn_r101_fpn_1x_coco.py new file mode 100644 index 00000000..962728ff --- /dev/null +++ b/mmdetection/configs/rpn/rpn_r101_fpn_1x_coco.py @@ -0,0 +1,6 @@ +_base_ = './rpn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/rpn/rpn_r101_fpn_2x_coco.py b/mmdetection/configs/rpn/rpn_r101_fpn_2x_coco.py new file mode 100644 index 00000000..ac7671c1 --- /dev/null +++ b/mmdetection/configs/rpn/rpn_r101_fpn_2x_coco.py @@ -0,0 +1,6 @@ +_base_ = './rpn_r50_fpn_2x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/rpn/rpn_r50-caffe-c4_1x_coco.py b/mmdetection/configs/rpn/rpn_r50-caffe-c4_1x_coco.py new file mode 100644 index 00000000..76b878c8 --- /dev/null +++ b/mmdetection/configs/rpn/rpn_r50-caffe-c4_1x_coco.py @@ -0,0 +1,8 @@ +_base_ = [ + '../_base_/models/rpn_r50-caffe-c4.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +val_evaluator = dict(metric='proposal_fast') +test_evaluator = val_evaluator diff --git a/mmdetection/configs/rpn/rpn_r50-caffe_fpn_1x_coco.py b/mmdetection/configs/rpn/rpn_r50-caffe_fpn_1x_coco.py new file mode 100644 index 00000000..530f3652 --- /dev/null +++ b/mmdetection/configs/rpn/rpn_r50-caffe_fpn_1x_coco.py @@ -0,0 +1,16 @@ +_base_ = './rpn_r50_fpn_1x_coco.py' +# use caffe img_norm +model = dict( + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False, + pad_size_divisor=32), + backbone=dict( + norm_cfg=dict(requires_grad=False), + norm_eval=True, + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe'))) diff --git a/mmdetection/configs/rpn/rpn_r50_fpn_1x_coco.py b/mmdetection/configs/rpn/rpn_r50_fpn_1x_coco.py new file mode 100644 index 00000000..7fe88d39 --- /dev/null +++ b/mmdetection/configs/rpn/rpn_r50_fpn_1x_coco.py @@ -0,0 +1,36 @@ +_base_ = [ + '../_base_/models/rpn_r50_fpn.py', '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +val_evaluator = dict(metric='proposal_fast') +test_evaluator = val_evaluator + +# inference on val dataset and dump the proposals with evaluate metric +# data_root = 'data/coco/' +# test_evaluator = [ +# dict( +# type='DumpProposals', +# output_dir=data_root + 'proposals/', +# proposals_file='rpn_r50_fpn_1x_val2017.pkl'), +# dict( +# type='CocoMetric', +# ann_file=data_root + 'annotations/instances_val2017.json', +# metric='proposal_fast', +# backend_args={{_base_.backend_args}}, +# format_only=False) +# ] + +# inference on training dataset and dump the proposals without evaluate metric +# data_root = 'data/coco/' +# test_dataloader = dict( +# dataset=dict( +# ann_file='annotations/instances_train2017.json', +# data_prefix=dict(img='train2017/'))) +# +# test_evaluator = [ +# dict( +# type='DumpProposals', +# output_dir=data_root + 'proposals/', +# proposals_file='rpn_r50_fpn_1x_train2017.pkl'), +# ] diff --git a/mmdetection/configs/rpn/rpn_r50_fpn_2x_coco.py b/mmdetection/configs/rpn/rpn_r50_fpn_2x_coco.py new file mode 100644 index 00000000..0ebccbcf --- /dev/null +++ b/mmdetection/configs/rpn/rpn_r50_fpn_2x_coco.py @@ -0,0 +1,17 @@ +_base_ = './rpn_r50_fpn_1x_coco.py' + +# learning policy +max_epochs = 24 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] diff --git a/mmdetection/configs/rpn/rpn_x101-32x4d_fpn_1x_coco.py b/mmdetection/configs/rpn/rpn_x101-32x4d_fpn_1x_coco.py new file mode 100644 index 00000000..d0c73948 --- /dev/null +++ b/mmdetection/configs/rpn/rpn_x101-32x4d_fpn_1x_coco.py @@ -0,0 +1,14 @@ +_base_ = './rpn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/rpn/rpn_x101-32x4d_fpn_2x_coco.py b/mmdetection/configs/rpn/rpn_x101-32x4d_fpn_2x_coco.py new file mode 100644 index 00000000..c6880b76 --- /dev/null +++ b/mmdetection/configs/rpn/rpn_x101-32x4d_fpn_2x_coco.py @@ -0,0 +1,14 @@ +_base_ = './rpn_r50_fpn_2x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/rpn/rpn_x101-64x4d_fpn_1x_coco.py b/mmdetection/configs/rpn/rpn_x101-64x4d_fpn_1x_coco.py new file mode 100644 index 00000000..96e691a9 --- /dev/null +++ b/mmdetection/configs/rpn/rpn_x101-64x4d_fpn_1x_coco.py @@ -0,0 +1,14 @@ +_base_ = './rpn_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/rpn/rpn_x101-64x4d_fpn_2x_coco.py b/mmdetection/configs/rpn/rpn_x101-64x4d_fpn_2x_coco.py new file mode 100644 index 00000000..4182a396 --- /dev/null +++ b/mmdetection/configs/rpn/rpn_x101-64x4d_fpn_2x_coco.py @@ -0,0 +1,14 @@ +_base_ = './rpn_r50_fpn_2x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/rtmdet/README.md b/mmdetection/configs/rtmdet/README.md new file mode 100644 index 00000000..1677184a --- /dev/null +++ b/mmdetection/configs/rtmdet/README.md @@ -0,0 +1,457 @@ +# RTMDet: An Empirical Study of Designing Real-Time Object Detectors + +> [RTMDet: An Empirical Study of Designing Real-Time Object Detectors](https://arxiv.org/abs/2212.07784) + +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/rtmdet-an-empirical-study-of-designing-real/real-time-instance-segmentation-on-mscoco)](https://paperswithcode.com/sota/real-time-instance-segmentation-on-mscoco?p=rtmdet-an-empirical-study-of-designing-real) +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/rtmdet-an-empirical-study-of-designing-real/object-detection-in-aerial-images-on-dota-1)](https://paperswithcode.com/sota/object-detection-in-aerial-images-on-dota-1?p=rtmdet-an-empirical-study-of-designing-real) +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/rtmdet-an-empirical-study-of-designing-real/object-detection-in-aerial-images-on-hrsc2016)](https://paperswithcode.com/sota/object-detection-in-aerial-images-on-hrsc2016?p=rtmdet-an-empirical-study-of-designing-real) + + + +## Abstract + +In this paper, we aim to design an efficient real-time object detector that exceeds the YOLO series and is easily extensible for many object recognition tasks such as instance segmentation and rotated object detection. To obtain a more efficient model architecture, we explore an architecture that has compatible capacities in the backbone and neck, constructed by a basic building block that consists of large-kernel depth-wise convolutions. We further introduce soft labels when calculating matching costs in the dynamic label assignment to improve accuracy. Together with better training techniques, the resulting object detector, named RTMDet, achieves 52.8% AP on COCO with 300+ FPS on an NVIDIA 3090 GPU, outperforming the current mainstream industrial detectors. RTMDet achieves the best parameter-accuracy trade-off with tiny/small/medium/large/extra-large model sizes for various application scenarios, and obtains new state-of-the-art performance on real-time instance segmentation and rotated object detection. We hope the experimental results can provide new insights into designing versatile real-time object detectors for many object recognition tasks. + +
    + +
    + +## Results and Models + +### Object Detection + +| Model | size | box AP | Params(M) | FLOPS(G) | TRT-FP16-Latency(ms)
    RTX3090 | TRT-FP16-Latency(ms)
    T4 | Config | Download | +| :-----------------: | :--: | :----: | :-------: | :------: | :-----------------------------: | :------------------------: | :------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| RTMDet-tiny | 640 | 41.1 | 4.8 | 8.1 | 0.98 | 2.34 | [config](./rtmdet_tiny_8xb32-300e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_tiny_8xb32-300e_coco/rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_tiny_8xb32-300e_coco/rtmdet_tiny_8xb32-300e_coco_20220902_112414.log.json) | +| RTMDet-s | 640 | 44.6 | 8.89 | 14.8 | 1.22 | 2.96 | [config](./rtmdet_s_8xb32-300e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_s_8xb32-300e_coco/rtmdet_s_8xb32-300e_coco_20220905_161602-387a891e.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_s_8xb32-300e_coco/rtmdet_s_8xb32-300e_coco_20220905_161602.log.json) | +| RTMDet-m | 640 | 49.4 | 24.71 | 39.27 | 1.62 | 6.41 | [config](./rtmdet_m_8xb32-300e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_m_8xb32-300e_coco/rtmdet_m_8xb32-300e_coco_20220719_112220-229f527c.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_m_8xb32-300e_coco/rtmdet_m_8xb32-300e_coco_20220719_112220.log.json) | +| RTMDet-l | 640 | 51.5 | 52.3 | 80.23 | 2.44 | 10.32 | [config](./rtmdet_l_8xb32-300e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_l_8xb32-300e_coco/rtmdet_l_8xb32-300e_coco_20220719_112030-5a0be7c4.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_l_8xb32-300e_coco/rtmdet_l_8xb32-300e_coco_20220719_112030.log.json) | +| RTMDet-x | 640 | 52.8 | 94.86 | 141.67 | 3.10 | 18.80 | [config](./rtmdet_x_8xb32-300e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_x_8xb32-300e_coco/rtmdet_x_8xb32-300e_coco_20220715_230555-cc79b9ae.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_x_8xb32-300e_coco/rtmdet_x_8xb32-300e_coco_20220715_230555.log.json) | +| RTMDet-x-P6 | 1280 | 54.9 | | | | | [config](./rtmdet_x_p6_4xb8-300e_coco.py) | [model](https://github.com/orange0-jp/orange-weights/releases/download/v0.1.0rtmdet-p6/rtmdet_x_p6_4xb8-300e_coco-bf32be58.pth) | +| RTMDet-l-ConvNeXt-B | 640 | 53.1 | | | | | [config](./rtmdet_l_convnext_b_4xb32-100e_coco.py) | [model](https://github.com/orange0-jp/orange-weights/releases/download/v0.1.0rtmdet-swin-convnext/rtmdet_l_convnext_b_4xb32-100e_coco-d4731b3d.pth) | +| RTMDet-l-Swin-B | 640 | 52.4 | | | | | [config](./rtmdet_l_swin_b_4xb32-100e_coco.py) | [model](https://github.com/orange0-jp/orange-weights/releases/download/v0.1.0rtmdet-swin-convnext/rtmdet_l_swin_b_4xb32-100e_coco-0828ce5d.pth) | +| RTMDet-l-Swin-B-P6 | 1280 | 56.4 | | | | | [config](./rtmdet_l_swin_b_p6_4xb16-100e_coco.py) | [model](https://github.com/orange0-jp/orange-weights/releases/download/v0.1.0rtmdet-swin-convnext/rtmdet_l_swin_b_p6_4xb16-100e_coco-a1486b6f.pth) | + +**Note**: + +1. We implement a fast training version of RTMDet in [MMYOLO](https://github.com/open-mmlab/mmyolo). Its training speed is **2.6 times faster** and memory requirement is lower! Try it [here](https://github.com/open-mmlab/mmyolo/tree/main/configs/rtmdet)! +2. The inference speed of RTMDet is measured with TensorRT 8.4.3, cuDNN 8.2.0, FP16, batch size=1, and without NMS. +3. For a fair comparison, the config of bbox postprocessing is changed to be consistent with YOLOv5/6/7 after [PR#9494](https://github.com/open-mmlab/mmdetection/pull/9494), bringing about 0.1~0.3% AP improvement. + +### Instance Segmentation + +RTMDet-Ins is the state-of-the-art real-time instance segmentation on coco dataset: + +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/rtmdet-an-empirical-study-of-designing-real/real-time-instance-segmentation-on-mscoco)](https://paperswithcode.com/sota/real-time-instance-segmentation-on-mscoco?p=rtmdet-an-empirical-study-of-designing-real) + +| Model | size | box AP | mask AP | Params(M) | FLOPS(G) | TRT-FP16-Latency(ms) | Config | Download | +| :-------------: | :--: | :----: | :-----: | :-------: | :------: | :------------------: | :--------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| RTMDet-Ins-tiny | 640 | 40.5 | 35.4 | 5.6 | 11.8 | 1.70 | [config](./rtmdet-ins_tiny_8xb32-300e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet-ins_tiny_8xb32-300e_coco/rtmdet-ins_tiny_8xb32-300e_coco_20221130_151727-ec670f7e.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet-ins_tiny_8xb32-300e_coco/rtmdet-ins_tiny_8xb32-300e_coco_20221130_151727.log.json) | +| RTMDet-Ins-s | 640 | 44.0 | 38.7 | 10.18 | 21.5 | 1.93 | [config](./rtmdet-ins_s_8xb32-300e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet-ins_s_8xb32-300e_coco/rtmdet-ins_s_8xb32-300e_coco_20221121_212604-fdc5d7ec.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet-ins_s_8xb32-300e_coco/rtmdet-ins_s_8xb32-300e_coco_20221121_212604.log.json) | +| RTMDet-Ins-m | 640 | 48.8 | 42.1 | 27.58 | 54.13 | 2.69 | [config](./rtmdet-ins_m_8xb32-300e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet-ins_m_8xb32-300e_coco/rtmdet-ins_m_8xb32-300e_coco_20221123_001039-6eba602e.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet-ins_m_8xb32-300e_coco/rtmdet-ins_m_8xb32-300e_coco_20221123_001039.log.json) | +| RTMDet-Ins-l | 640 | 51.2 | 43.7 | 57.37 | 106.56 | 3.68 | [config](./rtmdet-ins_l_8xb32-300e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet-ins_l_8xb32-300e_coco/rtmdet-ins_l_8xb32-300e_coco_20221124_103237-78d1d652.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet-ins_l_8xb32-300e_coco/rtmdet-ins_l_8xb32-300e_coco_20221124_103237.log.json) | +| RTMDet-Ins-x | 640 | 52.4 | 44.6 | 102.7 | 182.7 | 5.31 | [config](./rtmdet-ins_x_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet-ins_x_8xb16-300e_coco/rtmdet-ins_x_8xb16-300e_coco_20221124_111313-33d4595b.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet-ins_x_8xb16-300e_coco/rtmdet-ins_x_8xb16-300e_coco_20221124_111313.log.json) | + +**Note**: + +1. The inference speed of RTMDet-Ins is measured on an NVIDIA 3090 GPU with TensorRT 8.4.3, cuDNN 8.2.0, FP16, batch size=1. Top 100 masks are kept and the post process latency is included. + +### Rotated Object Detection + +RTMDet-R achieves state-of-the-art on various remote sensing datasets. + +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/rtmdet-an-empirical-study-of-designing-real/object-detection-in-aerial-images-on-dota-1)](https://paperswithcode.com/sota/object-detection-in-aerial-images-on-dota-1?p=rtmdet-an-empirical-study-of-designing-real) + +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/rtmdet-an-empirical-study-of-designing-real/one-stage-anchor-free-oriented-object-1)](https://paperswithcode.com/sota/one-stage-anchor-free-oriented-object-1?p=rtmdet-an-empirical-study-of-designing-real) + +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/rtmdet-an-empirical-study-of-designing-real/object-detection-in-aerial-images-on-hrsc2016)](https://paperswithcode.com/sota/object-detection-in-aerial-images-on-hrsc2016?p=rtmdet-an-empirical-study-of-designing-real) + +[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/rtmdet-an-empirical-study-of-designing-real/one-stage-anchor-free-oriented-object-3)](https://paperswithcode.com/sota/one-stage-anchor-free-oriented-object-3?p=rtmdet-an-empirical-study-of-designing-real) + +Models and configs of RTMDet-R are available in [MMRotate](https://github.com/open-mmlab/mmrotate/tree/1.x/configs/rotated_rtmdet). + +| Backbone | pretrain | Aug | mmAP | mAP50 | mAP75 | Params(M) | FLOPS(G) | TRT-FP16-Latency(ms) | Config | Download | +| :---------: | :------: | :---: | :---: | :---: | :---: | :-------: | :------: | :------------------: | :---------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| RTMDet-tiny | IN | RR | 47.37 | 75.36 | 50.64 | 4.88 | 20.45 | 4.40 | [config](https://github.com/open-mmlab/mmrotate/edit/1.x/configs/rotated_rtmdet/rotated_rtmdet_tiny-3x-dota.py) | [model](https://download.openmmlab.com/mmrotate/v1.0/rotated_rtmdet/rotated_rtmdet_tiny-3x-dota/rotated_rtmdet_tiny-3x-dota-9d821076.pth) \| [log](https://download.openmmlab.com/mmrotate/v1.0/rotated_rtmdet/rotated_rtmdet_tiny-3x-dota/rotated_rtmdet_tiny-3x-dota_20221201_120814.json) | +| RTMDet-tiny | IN | MS+RR | 53.59 | 79.82 | 58.87 | 4.88 | 20.45 | 4.40 | [config](https://github.com/open-mmlab/mmrotate/edit/1.x/configs/rotated_rtmdet/rotated_rtmdet_tiny-3x-dota_ms.py) | [model](https://download.openmmlab.com/mmrotate/v1.0/rotated_rtmdet/rotated_rtmdet_tiny-3x-dota_ms/rotated_rtmdet_tiny-3x-dota_ms-f12286ff.pth) \| [log](https://download.openmmlab.com/mmrotate/v1.0/rotated_rtmdet/rotated_rtmdet_tiny-3x-dota_ms/rotated_rtmdet_tiny-3x-dota_ms_20221113_201235.log) | +| RTMDet-s | IN | RR | 48.16 | 76.93 | 50.59 | 8.86 | 37.62 | 4.86 | [config](https://github.com/open-mmlab/mmrotate/edit/1.x/configs/rotated_rtmdet/rotated_rtmdet_s-3x-dota.py) | [model](https://download.openmmlab.com/mmrotate/v1.0/rotated_rtmdet/rotated_rtmdet_s-3x-dota/rotated_rtmdet_s-3x-dota-11f6ccf5.pth) \| [log](https://download.openmmlab.com/mmrotate/v1.0/rotated_rtmdet/rotated_rtmdet_s-3x-dota/rotated_rtmdet_s-3x-dota_20221124_081442.json) | +| RTMDet-s | IN | MS+RR | 54.43 | 79.98 | 60.07 | 8.86 | 37.62 | 4.86 | [config](https://github.com/open-mmlab/mmrotate/edit/1.x/configs/rotated_rtmdet/rotated_rtmdet_s-3x-dota_ms.py) | [model](https://download.openmmlab.com/mmrotate/v1.0/rotated_rtmdet/rotated_rtmdet_s-3x-dota_ms/rotated_rtmdet_s-3x-dota_ms-20ead048.pth) \| [log](https://download.openmmlab.com/mmrotate/v1.0/rotated_rtmdet/rotated_rtmdet_s-3x-dota_ms/rotated_rtmdet_s-3x-dota_ms_20221113_201055.json) | +| RTMDet-m | IN | RR | 50.56 | 78.24 | 54.47 | 24.67 | 99.76 | 7.82 | [config](https://github.com/open-mmlab/mmrotate/edit/1.x/configs/rotated_rtmdet/rotated_rtmdet_m-3x-dota.py) | [model](https://download.openmmlab.com/mmrotate/v1.0/rotated_rtmdet/rotated_rtmdet_m-3x-dota/rotated_rtmdet_m-3x-dota-beeadda6.pth) \| [log](https://download.openmmlab.com/mmrotate/v1.0/rotated_rtmdet/rotated_rtmdet_m-3x-dota/rotated_rtmdet_m-3x-dota_20221122_011234.json) | +| RTMDet-m | IN | MS+RR | 55.00 | 80.26 | 61.26 | 24.67 | 99.76 | 7.82 | [config](https://github.com/open-mmlab/mmrotate/edit/1.x/configs/rotated_rtmdet/rotated_rtmdet_m-3x-dota_ms.py) | [model](https://download.openmmlab.com/mmrotate/v1.0/rotated_rtmdet/rotated_rtmdet_m-3x-dota_ms/rotated_rtmdet_m-3x-dota_ms-c71eb375.pth) \| [log](https://download.openmmlab.com/mmrotate/v1.0/rotated_rtmdet/rotated_rtmdet_m-3x-dota_ms/rotated_rtmdet_m-3x-dota_ms_20221122_011234.json) | +| RTMDet-l | IN | RR | 51.01 | 78.85 | 55.21 | 52.27 | 204.21 | 10.82 | [config](https://github.com/open-mmlab/mmrotate/edit/1.x/configs/rotated_rtmdet/rotated_rtmdet_l-3x-dota.py) | [model](https://download.openmmlab.com/mmrotate/v1.0/rotated_rtmdet/rotated_rtmdet_l-3x-dota/rotated_rtmdet_l-3x-dota-23992372.pth) \| [log](https://download.openmmlab.com/mmrotate/v1.0/rotated_rtmdet/rotated_rtmdet_l-3x-dota/rotated_rtmdet_l-3x-dota_20221122_011241.json) | +| RTMDet-l | IN | MS+RR | 55.52 | 80.54 | 61.47 | 52.27 | 204.21 | 10.82 | [config](https://github.com/open-mmlab/mmrotate/edit/1.x/configs/rotated_rtmdet/rotated_rtmdet_l-3x-dota_ms.py) | [model](https://download.openmmlab.com/mmrotate/v1.0/rotated_rtmdet/rotated_rtmdet_l-3x-dota_ms/rotated_rtmdet_l-3x-dota_ms-2738da34.pth) \| [log](https://download.openmmlab.com/mmrotate/v1.0/rotated_rtmdet/rotated_rtmdet_l-3x-dota_ms/rotated_rtmdet_l-3x-dota_ms_20221122_011241.json) | +| RTMDet-l | COCO | MS+RR | 56.74 | 81.33 | 63.45 | 52.27 | 204.21 | 10.82 | [config](https://github.com/open-mmlab/mmrotate/edit/1.x/configs/rotated_rtmdet/rotated_rtmdet_l-coco_pretrain-3x-dota_ms.py) | [model](https://download.openmmlab.com/mmrotate/v1.0/rotated_rtmdet/rotated_rtmdet_l-coco_pretrain-3x-dota_ms/rotated_rtmdet_l-coco_pretrain-3x-dota_ms-06d248a2.pth) \| [log](https://download.openmmlab.com/mmrotate/v1.0/rotated_rtmdet/rotated_rtmdet_l-coco_pretrain-3x-dota_ms/rotated_rtmdet_l-coco_pretrain-3x-dota_ms_20221113_202010.json) | + +### Classification + +We also provide the imagenet classification configs of the RTMDet backbone. Find more details in the [classification folder](./classification). + +| Model | resolution | Params(M) | Flops(G) | Top-1 (%) | Top-5 (%) | Download | +| :----------: | :--------: | :-------: | :------: | :-------: | :-------: | :---------------------------------------------------------------------------------------------------------------------------------: | +| CSPNeXt-tiny | 224x224 | 2.73 | 0.34 | 69.44 | 89.45 | [model](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-tiny_imagenet_600e-3a2dd350.pth) | +| CSPNeXt-s | 224x224 | 4.89 | 0.66 | 74.41 | 92.23 | [model](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-s_imagenet_600e-ea671761.pth) | +| CSPNeXt-m | 224x224 | 13.05 | 1.93 | 79.27 | 94.79 | [model](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-m_8xb256-rsb-a1-600e_in1k-ecb3bbd9.pth) | +| CSPNeXt-l | 224x224 | 27.16 | 4.19 | 81.30 | 95.62 | [model](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-l_8xb256-rsb-a1-600e_in1k-6a760974.pth) | +| CSPNeXt-x | 224x224 | 48.85 | 7.76 | 82.10 | 95.69 | [model](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-x_8xb256-rsb-a1-600e_in1k-b3f78edd.pth) | + +## Citation + +```latex +@misc{lyu2022rtmdet, + title={RTMDet: An Empirical Study of Designing Real-Time Object Detectors}, + author={Chengqi Lyu and Wenwei Zhang and Haian Huang and Yue Zhou and Yudong Wang and Yanyi Liu and Shilong Zhang and Kai Chen}, + year={2022}, + eprint={2212.07784}, + archivePrefix={arXiv}, + primaryClass={cs.CV} +} +``` + +## Visualization + +
    + +
    + +## Deployment Tutorial + +Here is a basic example of deploy RTMDet with [MMDeploy-1.x](https://github.com/open-mmlab/mmdeploy/tree/1.x). + +### Step1. Install MMDeploy + +Before starting the deployment, please make sure you install MMDetection and MMDeploy-1.x correctly. + +- Install MMDetection, please refer to the [MMDetection installation guide](https://mmdetection.readthedocs.io/en/latest/get_started.html). +- Install MMDeploy-1.x, please refer to the [MMDeploy-1.x installation guide](https://mmdeploy.readthedocs.io/en/1.x/get_started.html#installation). + +If you want to deploy RTMDet with ONNXRuntime, TensorRT, or other inference engine, +please make sure you have installed the corresponding dependencies and MMDeploy precompiled packages. + +### Step2. Convert Model + +After the installation, you can enjoy the model deployment journey starting from converting PyTorch model to backend model by running MMDeploy's `tools/deploy.py`. + +The detailed model conversion tutorial please refer to the [MMDeploy document](https://mmdeploy.readthedocs.io/en/1.x/02-how-to-run/convert_model.html). +Here we only give the example of converting RTMDet. + +MMDeploy supports converting dynamic and static models. Dynamic models support different input shape, but the inference speed is slower than static models. +To achieve the best performance, we suggest converting RTMDet with static setting. + +- If you only want to use ONNX, please use [`configs/mmdet/detection/detection_onnxruntime_static.py`](https://github.com/open-mmlab/mmdeploy/blob/1.x/configs/mmdet/detection/detection_onnxruntime_static.py) as the deployment config. +- If you want to use TensorRT, please use [`configs/mmdet/detection/detection_tensorrt_static-640x640.py`](https://github.com/open-mmlab/mmdeploy/blob/1.x/configs/mmdet/detection/detection_tensorrt_static-640x640.py). + +If you want to customize the settings in the deployment config for your requirements, please refer to [MMDeploy config tutorial](https://mmdeploy.readthedocs.io/en/1.x/02-how-to-run/write_config.html). + +After preparing the deployment config, you can run the `tools/deploy.py` script to convert your model. +Here we take converting RTMDet-s to TensorRT as an example: + +```shell +# go to the mmdeploy folder +cd ${PATH_TO_MMDEPLOY} + +# download RTMDet-s checkpoint +wget -P checkpoint https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_s_8xb32-300e_coco/rtmdet_s_8xb32-300e_coco_20220905_161602-387a891e.pth + +# run the command to start model conversion +python tools/deploy.py \ + configs/mmdet/detection/detection_tensorrt_static-640x640.py \ + ${PATH_TO_MMDET}/configs/rtmdet/rtmdet_s_8xb32-300e_coco.py \ + checkpoint/rtmdet_s_8xb32-300e_coco_20220905_161602-387a891e.pth \ + demo/resources/det.jpg \ + --work-dir ./work_dirs/rtmdet \ + --device cuda:0 \ + --show +``` + +If the script runs successfully, you will see the following files: + +``` +|----work_dirs + |----rtmdet + |----end2end.onnx # ONNX model + |----end2end.engine # TensorRT engine file +``` + +After this, you can check the inference results with MMDeploy Model Converter API: + +```python +from mmdeploy.apis import inference_model + +result = inference_model( + model_cfg='${PATH_TO_MMDET}/configs/rtmdet/rtmdet_s_8xb32-300e_coco.py', + deploy_cfg='${PATH_TO_MMDEPLOY}/configs/mmdet/detection/detection_tensorrt_static-640x640.py', + backend_files=['work_dirs/rtmdet/end2end.engine'], + img='demo/resources/det.jpg', + device='cuda:0') +``` + +#### Advanced Setting + +To convert the model with TRT-FP16, you can enable the fp16 mode in your deploy config: + +```python +# in MMDeploy config +backend_config = dict( + type='tensorrt', + common_config=dict( + fp16_mode=True # enable fp16 + )) +``` + +To reduce the end to end inference speed with the inference engine, we suggest you to adjust the post-processing setting of the model. +We set a very low score threshold during training and testing to achieve better COCO mAP. +However, in actual usage scenarios, a relatively high score threshold (e.g. 0.3) is usually used. + +You can adjust the score threshold and the number of detection boxes in your model config according to the actual usage to reduce the time-consuming of post-processing. + +```python +# in MMDetection config +model = dict( + test_cfg=dict( + nms_pre=1000, # keep top-k score bboxes before nms + min_bbox_size=0, + score_thr=0.3, # score threshold to filter bboxes + nms=dict(type='nms', iou_threshold=0.65), + max_per_img=100) # only keep top-100 as the final results. +) +``` + +### Step3. Inference with SDK + +We provide both Python and C++ inference API with MMDeploy SDK. + +To use SDK, you need to dump the required info during converting the model. Just add `--dump-info` to the model conversion command: + +```shell +python tools/deploy.py \ + configs/mmdet/detection/detection_tensorrt_static-640x640.py \ + ${PATH_TO_MMDET}/configs/rtmdet/rtmdet_s_8xb32-300e_coco.py \ + checkpoint/rtmdet_s_8xb32-300e_coco_20220905_161602-387a891e.pth \ + demo/resources/det.jpg \ + --work-dir ./work_dirs/rtmdet-sdk \ + --device cuda:0 \ + --show \ + --dump-info # dump sdk info +``` + +After running the command, it will dump 3 json files additionally for the SDK: + +``` +|----work_dirs + |----rtmdet-sdk + |----end2end.onnx # ONNX model + |----end2end.engine # TensorRT engine file + # json files for the SDK + |----pipeline.json + |----deploy.json + |----detail.json +``` + +#### Python API + +Here is a basic example of SDK Python API: + +```python +from mmdeploy_python import Detector +import cv2 + +img = cv2.imread('demo/resources/det.jpg') + +# create a detector +detector = Detector(model_path='work_dirs/rtmdet-sdk', device_name='cuda', device_id=0) +# run the inference +bboxes, labels, _ = detector(img) +# Filter the result according to threshold +indices = [i for i in range(len(bboxes))] +for index, bbox, label_id in zip(indices, bboxes, labels): + [left, top, right, bottom], score = bbox[0:4].astype(int), bbox[4] + if score < 0.3: + continue + # draw bbox + cv2.rectangle(img, (left, top), (right, bottom), (0, 255, 0)) + +cv2.imwrite('output_detection.png', img) +``` + +#### C++ API + +Here is a basic example of SDK C++ API: + +```C++ +#include +#include +#include "mmdeploy/detector.hpp" + +int main() { + const char* device_name = "cuda"; + int device_id = 0; + std::string model_path = "work_dirs/rtmdet-sdk"; + std::string image_path = "demo/resources/det.jpg"; + + // 1. load model + mmdeploy::Model model(model_path); + // 2. create predictor + mmdeploy::Detector detector(model, mmdeploy::Device{device_name, device_id}); + // 3. read image + cv::Mat img = cv::imread(image_path); + // 4. inference + auto dets = detector.Apply(img); + // 5. deal with the result. Here we choose to visualize it + for (int i = 0; i < dets.size(); ++i) { + const auto& box = dets[i].bbox; + fprintf(stdout, "box %d, left=%.2f, top=%.2f, right=%.2f, bottom=%.2f, label=%d, score=%.4f\n", + i, box.left, box.top, box.right, box.bottom, dets[i].label_id, dets[i].score); + if (bboxes[i].score < 0.3) { + continue; + } + cv::rectangle(img, cv::Point{(int)box.left, (int)box.top}, + cv::Point{(int)box.right, (int)box.bottom}, cv::Scalar{0, 255, 0}); + } + cv::imwrite("output_detection.png", img); + return 0; +} +``` + +To build C++ example, please add MMDeploy package in your CMake project as following: + +```cmake +find_package(MMDeploy REQUIRED) +target_link_libraries(${name} PRIVATE mmdeploy ${OpenCV_LIBS}) +``` + +#### Other languages + +- [C# API Examples](https://github.com/open-mmlab/mmdeploy/tree/1.x/demo/csharp) +- [JAVA API Examples](https://github.com/open-mmlab/mmdeploy/tree/1.x/demo/java) + +### Deploy RTMDet Instance Segmentation Model + +We support RTMDet-Ins ONNXRuntime and TensorRT deployment after [MMDeploy v1.0.0rc2](https://github.com/open-mmlab/mmdeploy/tree/v1.0.0rc2). And its deployment process is almost consistent with the detection model. + +#### Step1. Install MMDeploy >= v1.0.0rc2 + +Please refer to the [MMDeploy-1.x installation guide](https://mmdeploy.readthedocs.io/en/1.x/get_started.html#installation) to install the latest version. +Please remember to replace the pre-built package with the latest version. +The v1.0.0rc2 package can be downloaded from [v1.0.0rc2 release page](https://github.com/open-mmlab/mmdeploy/releases/tag/v1.0.0rc2). + +Step2. Convert Model + +This step has no difference with the previous tutorial. The only thing you need to change is switching to the RTMDet-Ins deploy config: + +- If you want to use ONNXRuntime, please use [`configs/mmdet/instance-seg/instance-seg_rtmdet-ins_onnxruntime_static-640x640.py`](https://github.com/open-mmlab/mmdeploy/blob/dev-1.x/configs/mmdet/instance-seg/instance-seg_rtmdet-ins_onnxruntime_static-640x640.py) as the deployment config. +- If you want to use TensorRT, please use [`configs/mmdet/instance-seg/instance-seg_rtmdet-ins_tensorrt_static-640x640.py`](https://github.com/open-mmlab/mmdeploy/blob/dev-1.x/configs/mmdet/instance-seg/instance-seg_rtmdet-ins_tensorrt_static-640x640.py). + +Here we take converting RTMDet-Ins-s to TensorRT as an example: + +```shell +# go to the mmdeploy folder +cd ${PATH_TO_MMDEPLOY} + +# download RTMDet-s checkpoint +wget -P checkpoint https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet-ins_s_8xb32-300e_coco/rtmdet-ins_s_8xb32-300e_coco_20221121_212604-fdc5d7ec.pth + +# run the command to start model conversion +python tools/deploy.py \ + configs/mmdet/instance-seg/instance-seg_rtmdet-ins_tensorrt_static-640x640.py \ + ${PATH_TO_MMDET}/configs/rtmdet/rtmdet-ins_s_8xb32-300e_coco.py \ + checkpoint/rtmdet-ins_s_8xb32-300e_coco_20221121_212604-fdc5d7ec.pth \ + demo/resources/det.jpg \ + --work-dir ./work_dirs/rtmdet-ins \ + --device cuda:0 \ + --show +``` + +If the script runs successfully, you will see the following files: + +``` +|----work_dirs + |----rtmdet-ins + |----end2end.onnx # ONNX model + |----end2end.engine # TensorRT engine file +``` + +After this, you can check the inference results with MMDeploy Model Converter API: + +```python +from mmdeploy.apis import inference_model + +result = inference_model( + model_cfg='${PATH_TO_MMDET}/configs/rtmdet/rtmdet-ins_s_8xb32-300e_coco.py', + deploy_cfg='${PATH_TO_MMDEPLOY}/configs/mmdet/instance-seg/instance-seg_rtmdet-ins_tensorrt_static-640x640.py', + backend_files=['work_dirs/rtmdet-ins/end2end.engine'], + img='demo/resources/det.jpg', + device='cuda:0') +``` + +### Model Config + +In MMDetection's config, we use `model` to set up detection algorithm components. In addition to neural network components such as `backbone`, `neck`, etc, it also requires `data_preprocessor`, `train_cfg`, and `test_cfg`. `data_preprocessor` is responsible for processing a batch of data output by dataloader. `train_cfg`, and `test_cfg` in the model config are for training and testing hyperparameters of the components.Taking RTMDet as an example, we will introduce each field in the config according to different function modules: + +```python +model = dict( + type='RTMDet', # The name of detector + data_preprocessor=dict( # The config of data preprocessor, usually includes image normalization and padding + type='DetDataPreprocessor', # The type of the data preprocessor. Refer to https://mmdetection.readthedocs.io/en/latest/api.html#mmdet.models.data_preprocessors.DetDataPreprocessor + mean=[103.53, 116.28, 123.675], # Mean values used to pre-training the pre-trained backbone models, ordered in R, G, B + std=[57.375, 57.12, 58.395], # Standard variance used to pre-training the pre-trained backbone models, ordered in R, G, B + bgr_to_rgb=False, # whether to convert image from BGR to RGB + batch_augments=None), # Batch-level augmentations + backbone=dict( # The config of backbone + type='CSPNeXt', # The type of backbone network. Refer to https://mmdetection.readthedocs.io/en/latest/api.html#mmdet.models.backbones.CSPNeXt + arch='P5', # Architecture of CSPNeXt, from {P5, P6}. Defaults to P5 + expand_ratio=0.5, # Ratio to adjust the number of channels of the hidden layer. Defaults to 0.5 + deepen_factor=1, # Depth multiplier, multiply number of blocks in CSP layer by this amount. Defaults to 1.0 + widen_factor=1, # Width multiplier, multiply number of channels in each layer by this amount. Defaults to 1.0 + channel_attention=True, # Whether to add channel attention in each stage. Defaults to True + norm_cfg=dict(type='SyncBN'), # Dictionary to construct and config norm layer. Defaults to dict(type=’BN’, requires_grad=True) + act_cfg=dict(type='SiLU', inplace=True)), # Config dict for activation layer. Defaults to dict(type=’SiLU’) + neck=dict( + type='CSPNeXtPAFPN', # The type of neck is CSPNeXtPAFPN. Refer to https://mmdetection.readthedocs.io/en/latest/api.html#mmdet.models.necks.CSPNeXtPAFPN + in_channels=[256, 512, 1024], # Number of input channels per scale + out_channels=256, # Number of output channels (used at each scale) + num_csp_blocks=3, # Number of bottlenecks in CSPLayer. Defaults to 3 + expand_ratio=0.5, # Ratio to adjust the number of channels of the hidden layer. Default: 0.5 + norm_cfg=dict(type='SyncBN'), # Config dict for normalization layer. Default: dict(type=’BN’) + act_cfg=dict(type='SiLU', inplace=True)), # Config dict for activation layer. Default: dict(type=’Swish’) + bbox_head=dict( + type='RTMDetSepBNHead', # The type of bbox_head is RTMDetSepBNHead. RTMDetHead with separated BN layers and shared conv layers. Refer to https://mmdetection.readthedocs.io/en/latest/api.html#mmdet.models.dense_heads.RTMDetSepBNHead + num_classes=80, # Number of categories excluding the background category + in_channels=256, # Number of channels in the input feature map + stacked_convs=2, # Whether to share conv layers between stages. Defaults to True + feat_channels=256, # Feature channels of convolutional layers in the head + anchor_generator=dict( # The config of anchor generator + type='MlvlPointGenerator', # The methods use MlvlPointGenerator. Refer to https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/task_modules/prior_generators/point_generator.py#L92 + offset=0, # The offset of points, the value is normalized with corresponding stride. Defaults to 0.5 + strides=[8, 16, 32]), # Strides of anchors in multiple feature levels in order (w, h) + bbox_coder=dict(type='DistancePointBBoxCoder'), # Distance Point BBox coder.This coder encodes gt bboxes (x1, y1, x2, y2) into (top, bottom, left,right) and decode it back to the original. Refer to https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/task_modules/coders/distance_point_bbox_coder.py#L9 + loss_cls=dict( # Config of loss function for the classification branch + type='QualityFocalLoss', # Type of loss for classification branch. Refer to https://mmdetection.readthedocs.io/en/latest/api.html#mmdet.models.losses.QualityFocalLoss + use_sigmoid=True, # Whether sigmoid operation is conducted in QFL. Defaults to True + beta=2.0, # The beta parameter for calculating the modulating factor. Defaults to 2.0 + loss_weight=1.0), # Loss weight of current loss + loss_bbox=dict( # Config of loss function for the regression branch + type='GIoULoss', # Type of loss. Refer to https://mmdetection.readthedocs.io/en/latest/api.html#mmdet.models.losses.GIoULoss + loss_weight=2.0), # Loss weight of the regression branch + with_objectness=False, # Whether to add an objectness branch. Defaults to True + exp_on_reg=True, # Whether to use .exp() in regression + share_conv=True, # Whether to share conv layers between stages. Defaults to True + pred_kernel_size=1, # Kernel size of prediction layer. Defaults to 1 + norm_cfg=dict(type='SyncBN'), # Config dict for normalization layer. Defaults to dict(type='BN', momentum=0.03, eps=0.001) + act_cfg=dict(type='SiLU', inplace=True)), # Config dict for activation layer. Defaults to dict(type='SiLU') + train_cfg=dict( # Config of training hyperparameters for ATSS + assigner=dict( # Config of assigner + type='DynamicSoftLabelAssigner', # Type of assigner. DynamicSoftLabelAssigner computes matching between predictions and ground truth with dynamic soft label assignment. Refer to https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/task_modules/assigners/dynamic_soft_label_assigner.py#L40 + topk=13), # Select top-k predictions to calculate dynamic k best matches for each gt. Defaults to 13 + allowed_border=-1, # The border allowed after padding for valid anchors + pos_weight=-1, # The weight of positive samples during training + debug=False), # Whether to set the debug mode + test_cfg=dict( # Config for testing hyperparameters for ATSS + nms_pre=30000, # The number of boxes before NMS + min_bbox_size=0, # The allowed minimal box size + score_thr=0.001, # Threshold to filter out boxes + nms=dict( # Config of NMS in the second stage + type='nms', # Type of NMS + iou_threshold=0.65), # NMS threshold + max_per_img=300), # Max number of detections of each image +) +``` diff --git a/mmdetection/configs/rtmdet/classification/README.md b/mmdetection/configs/rtmdet/classification/README.md new file mode 100644 index 00000000..acc127db --- /dev/null +++ b/mmdetection/configs/rtmdet/classification/README.md @@ -0,0 +1,56 @@ +# CSPNeXt ImageNet Pre-training + +In this folder, we provide the imagenet pre-training config of RTMDet's backbone CSPNeXt. + +## Requirements + +To train with these configs, please install [MMPreTrain](https://github.com/open-mmlab/mmpretrain) first. + +Install by MIM: + +```shell +mim install mmpretrain +``` + +or install by pip: + +```shell +pip install mmpretrain +``` + +## Prepare Dataset + +To pre-train on ImageNet, you need to prepare the dataset first. Please refer to the [guide](https://mmpretrain.readthedocs.io/en/latest/user_guides/dataset_prepare.html#imagenet). + +## How to Train + +You can use the classification config in the same way as the detection config. + +For single-GPU training, run: + +```shell +python tools/train.py \ + ${CONFIG_FILE} \ + [optional arguments] +``` + +For multi-GPU training, run: + +```shell +bash ./tools/dist_train.sh \ + ${CONFIG_FILE} \ + ${GPU_NUM} \ + [optional arguments] +``` + +More details can be found in [user guides](https://mmdetection.readthedocs.io/en/latest/user_guides/train.html). + +## Results and Models + +| Model | resolution | Params(M) | Flops(G) | Top-1 (%) | Top-5 (%) | Download | +| :----------: | :--------: | :-------: | :------: | :-------: | :-------: | :---------------------------------------------------------------------------------------------------------------------------------: | +| CSPNeXt-tiny | 224x224 | 2.73 | 0.34 | 69.44 | 89.45 | [model](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-tiny_imagenet_600e-3a2dd350.pth) | +| CSPNeXt-s | 224x224 | 4.89 | 0.66 | 74.41 | 92.23 | [model](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-s_imagenet_600e-ea671761.pth) | +| CSPNeXt-m | 224x224 | 13.05 | 1.93 | 79.27 | 94.79 | [model](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-m_8xb256-rsb-a1-600e_in1k-ecb3bbd9.pth) | +| CSPNeXt-l | 224x224 | 27.16 | 4.19 | 81.30 | 95.62 | [model](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-l_8xb256-rsb-a1-600e_in1k-6a760974.pth) | +| CSPNeXt-x | 224x224 | 48.85 | 7.76 | 82.10 | 95.69 | [model](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-x_8xb256-rsb-a1-600e_in1k-b3f78edd.pth) | diff --git a/mmdetection/configs/rtmdet/classification/cspnext-l_8xb256-rsb-a1-600e_in1k.py b/mmdetection/configs/rtmdet/classification/cspnext-l_8xb256-rsb-a1-600e_in1k.py new file mode 100644 index 00000000..d2e70539 --- /dev/null +++ b/mmdetection/configs/rtmdet/classification/cspnext-l_8xb256-rsb-a1-600e_in1k.py @@ -0,0 +1,5 @@ +_base_ = './cspnext-s_8xb256-rsb-a1-600e_in1k.py' + +model = dict( + backbone=dict(deepen_factor=1, widen_factor=1), + head=dict(in_channels=1024)) diff --git a/mmdetection/configs/rtmdet/classification/cspnext-m_8xb256-rsb-a1-600e_in1k.py b/mmdetection/configs/rtmdet/classification/cspnext-m_8xb256-rsb-a1-600e_in1k.py new file mode 100644 index 00000000..e1b1352d --- /dev/null +++ b/mmdetection/configs/rtmdet/classification/cspnext-m_8xb256-rsb-a1-600e_in1k.py @@ -0,0 +1,5 @@ +_base_ = './cspnext-s_8xb256-rsb-a1-600e_in1k.py' + +model = dict( + backbone=dict(deepen_factor=0.67, widen_factor=0.75), + head=dict(in_channels=768)) diff --git a/mmdetection/configs/rtmdet/classification/cspnext-s_8xb256-rsb-a1-600e_in1k.py b/mmdetection/configs/rtmdet/classification/cspnext-s_8xb256-rsb-a1-600e_in1k.py new file mode 100644 index 00000000..dcfd2ea4 --- /dev/null +++ b/mmdetection/configs/rtmdet/classification/cspnext-s_8xb256-rsb-a1-600e_in1k.py @@ -0,0 +1,64 @@ +_base_ = [ + 'mmpretrain::_base_/datasets/imagenet_bs256_rsb_a12.py', + 'mmpretrain::_base_/schedules/imagenet_bs2048_rsb.py', + 'mmpretrain::_base_/default_runtime.py' +] + +model = dict( + type='ImageClassifier', + backbone=dict( + type='mmdet.CSPNeXt', + arch='P5', + out_indices=(4, ), + expand_ratio=0.5, + deepen_factor=0.33, + widen_factor=0.5, + channel_attention=True, + norm_cfg=dict(type='BN'), + act_cfg=dict(type='mmdet.SiLU')), + neck=dict(type='GlobalAveragePooling'), + head=dict( + type='LinearClsHead', + num_classes=1000, + in_channels=512, + loss=dict( + type='LabelSmoothLoss', + label_smooth_val=0.1, + mode='original', + loss_weight=1.0), + topk=(1, 5)), + train_cfg=dict(augments=[ + dict(type='Mixup', alpha=0.2), + dict(type='CutMix', alpha=1.0) + ])) + +# dataset settings +train_dataloader = dict(sampler=dict(type='RepeatAugSampler', shuffle=True)) + +# schedule settings +optim_wrapper = dict( + optimizer=dict(weight_decay=0.01), + paramwise_cfg=dict(bias_decay_mult=0., norm_decay_mult=0.), +) + +param_scheduler = [ + # warm up learning rate scheduler + dict( + type='LinearLR', + start_factor=0.0001, + by_epoch=True, + begin=0, + end=5, + # update by iter + convert_to_iter_based=True), + # main learning rate scheduler + dict( + type='CosineAnnealingLR', + T_max=595, + eta_min=1.0e-6, + by_epoch=True, + begin=5, + end=600) +] + +train_cfg = dict(by_epoch=True, max_epochs=600) diff --git a/mmdetection/configs/rtmdet/classification/cspnext-tiny_8xb256-rsb-a1-600e_in1k.py b/mmdetection/configs/rtmdet/classification/cspnext-tiny_8xb256-rsb-a1-600e_in1k.py new file mode 100644 index 00000000..af3170bd --- /dev/null +++ b/mmdetection/configs/rtmdet/classification/cspnext-tiny_8xb256-rsb-a1-600e_in1k.py @@ -0,0 +1,5 @@ +_base_ = './cspnext-s_8xb256-rsb-a1-600e_in1k.py' + +model = dict( + backbone=dict(deepen_factor=0.167, widen_factor=0.375), + head=dict(in_channels=384)) diff --git a/mmdetection/configs/rtmdet/classification/cspnext-x_8xb256-rsb-a1-600e_in1k.py b/mmdetection/configs/rtmdet/classification/cspnext-x_8xb256-rsb-a1-600e_in1k.py new file mode 100644 index 00000000..edec48d7 --- /dev/null +++ b/mmdetection/configs/rtmdet/classification/cspnext-x_8xb256-rsb-a1-600e_in1k.py @@ -0,0 +1,5 @@ +_base_ = './cspnext-s_8xb256-rsb-a1-600e_in1k.py' + +model = dict( + backbone=dict(deepen_factor=1.33, widen_factor=1.25), + head=dict(in_channels=1280)) diff --git a/mmdetection/configs/rtmdet/metafile.yml b/mmdetection/configs/rtmdet/metafile.yml new file mode 100644 index 00000000..a62abcb2 --- /dev/null +++ b/mmdetection/configs/rtmdet/metafile.yml @@ -0,0 +1,242 @@ +Collections: + - Name: RTMDet + Metadata: + Training Data: COCO + Training Techniques: + - AdamW + - Flat Cosine Annealing + Training Resources: 8x A100 GPUs + Architecture: + - CSPNeXt + - CSPNeXtPAFPN + README: configs/rtmdet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v3.0.0rc1/mmdet/models/detectors/rtmdet.py#L6 + Version: v3.0.0rc1 + +Models: + - Name: rtmdet_tiny_8xb32-300e_coco + Alias: + - rtmdet-t + In Collection: RTMDet + Config: configs/rtmdet/rtmdet_tiny_8xb32-300e_coco.py + Metadata: + Training Memory (GB): 11.7 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.9 + Weights: https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_tiny_8xb32-300e_coco/rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth + + - Name: rtmdet_s_8xb32-300e_coco + Alias: + - rtmdet-s + In Collection: RTMDet + Config: configs/rtmdet/rtmdet_s_8xb32-300e_coco.py + Metadata: + Training Memory (GB): 15.9 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.5 + Weights: https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_s_8xb32-300e_coco/rtmdet_s_8xb32-300e_coco_20220905_161602-387a891e.pth + + - Name: rtmdet_m_8xb32-300e_coco + Alias: + - rtmdet-m + In Collection: RTMDet + Config: configs/rtmdet/rtmdet_m_8xb32-300e_coco.py + Metadata: + Training Memory (GB): 27.8 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 49.1 + Weights: https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_m_8xb32-300e_coco/rtmdet_m_8xb32-300e_coco_20220719_112220-229f527c.pth + + - Name: rtmdet_l_8xb32-300e_coco + Alias: + - rtmdet-l + In Collection: RTMDet + Config: configs/rtmdet/rtmdet_l_8xb32-300e_coco.py + Metadata: + Training Memory (GB): 43.2 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 51.3 + Weights: https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_l_8xb32-300e_coco/rtmdet_l_8xb32-300e_coco_20220719_112030-5a0be7c4.pth + + - Name: rtmdet_x_8xb32-300e_coco + Alias: + - rtmdet-x + In Collection: RTMDet + Config: configs/rtmdet/rtmdet_x_8xb32-300e_coco.py + Metadata: + Training Memory (GB): 61.1 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 52.6 + Weights: https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_x_8xb32-300e_coco/rtmdet_x_8xb32-300e_coco_20220715_230555-cc79b9ae.pth + + - Name: rtmdet_x_p6_4xb8-300e_coco + Alias: + - rtmdet-x_p6 + In Collection: RTMDet + Config: configs/rtmdet/rtmdet_x_p6_4xb8-300e_coco.py + Metadata: + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 54.9 + Weights: https://github.com/orange0-jp/orange-weights/releases/download/v0.1.0rtmdet-p6/rtmdet_x_p6_4xb8-300e_coco-bf32be58.pth + + - Name: rtmdet_l_convnext_b_4xb32-100e_coco + Alias: + - rtmdet-l_convnext_b + In Collection: RTMDet + Config: configs/rtmdet/rtmdet_l_convnext_b_4xb32-100e_coco.py + Metadata: + Epochs: 100 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 53.1 + Weights: https://github.com/orange0-jp/orange-weights/releases/download/v0.1.0rtmdet-swin-convnext/rtmdet_l_convnext_b_4xb32-100e_coco-d4731b3d.pth + + - Name: rtmdet_l_swin_b_4xb32-100e_coco + Alias: + - rtmdet-l_swin_b + In Collection: RTMDet + Config: configs/rtmdet/rtmdet_l_swin_b_4xb32-100e_coco.py + Metadata: + Epochs: 100 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 52.4 + Weights: https://github.com/orange0-jp/orange-weights/releases/download/v0.1.0rtmdet-swin-convnext/rtmdet_l_swin_b_4xb32-100e_coco-0828ce5d.pth + + - Name: rtmdet_l_swin_b_p6_4xb16-100e_coco + Alias: + - rtmdet-l_swin_b_p6 + In Collection: RTMDet + Config: configs/rtmdet/rtmdet_l_swin_b_p6_4xb16-100e_coco.py + Metadata: + Epochs: 100 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 56.4 + Weights: https://github.com/orange0-jp/orange-weights/releases/download/v0.1.0rtmdet-swin-convnext/rtmdet_l_swin_b_p6_4xb16-100e_coco-a1486b6f.pth + + - Name: rtmdet-ins_tiny_8xb32-300e_coco + Alias: + - rtmdet-ins-t + In Collection: RTMDet + Config: configs/rtmdet/rtmdet-ins_tiny_8xb32-300e_coco.py + Metadata: + Training Memory (GB): 18.4 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.5 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 35.4 + Weights: https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet-ins_tiny_8xb32-300e_coco/rtmdet-ins_tiny_8xb32-300e_coco_20221130_151727-ec670f7e.pth + + - Name: rtmdet-ins_s_8xb32-300e_coco + Alias: + - rtmdet-ins-s + In Collection: RTMDet + Config: configs/rtmdet/rtmdet-ins_s_8xb32-300e_coco.py + Metadata: + Training Memory (GB): 27.6 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.0 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 38.7 + Weights: https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet-ins_s_8xb32-300e_coco/rtmdet-ins_s_8xb32-300e_coco_20221121_212604-fdc5d7ec.pth + + - Name: rtmdet-ins_m_8xb32-300e_coco + Alias: + - rtmdet-ins-m + In Collection: RTMDet + Config: configs/rtmdet/rtmdet-ins_m_8xb32-300e_coco.py + Metadata: + Training Memory (GB): 42.5 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 48.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 42.1 + Weights: https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet-ins_m_8xb32-300e_coco/rtmdet-ins_m_8xb32-300e_coco_20221123_001039-6eba602e.pth + + - Name: rtmdet-ins_l_8xb32-300e_coco + Alias: + - rtmdet-ins-l + In Collection: RTMDet + Config: configs/rtmdet/rtmdet-ins_l_8xb32-300e_coco.py + Metadata: + Training Memory (GB): 59.8 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 51.2 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 43.7 + Weights: https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet-ins_l_8xb32-300e_coco/rtmdet-ins_l_8xb32-300e_coco_20221124_103237-78d1d652.pth + + - Name: rtmdet-ins_x_8xb16-300e_coco + Alias: + - rtmdet-ins-x + In Collection: RTMDet + Config: configs/rtmdet/rtmdet-ins_x_8xb16-300e_coco.py + Metadata: + Training Memory (GB): 33.7 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 52.4 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 44.6 + Weights: https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet-ins_x_8xb16-300e_coco/rtmdet-ins_x_8xb16-300e_coco_20221124_111313-33d4595b.pth diff --git a/mmdetection/configs/rtmdet/rtmdet-ins_l_8xb32-300e_coco.py b/mmdetection/configs/rtmdet/rtmdet-ins_l_8xb32-300e_coco.py new file mode 100644 index 00000000..6b4b9240 --- /dev/null +++ b/mmdetection/configs/rtmdet/rtmdet-ins_l_8xb32-300e_coco.py @@ -0,0 +1,104 @@ +_base_ = './rtmdet_l_8xb32-300e_coco.py' +model = dict( + bbox_head=dict( + _delete_=True, + type='RTMDetInsSepBNHead', + num_classes=80, + in_channels=256, + stacked_convs=2, + share_conv=True, + pred_kernel_size=1, + feat_channels=256, + act_cfg=dict(type='SiLU', inplace=True), + norm_cfg=dict(type='SyncBN', requires_grad=True), + anchor_generator=dict( + type='MlvlPointGenerator', offset=0, strides=[8, 16, 32]), + bbox_coder=dict(type='DistancePointBBoxCoder'), + loss_cls=dict( + type='QualityFocalLoss', + use_sigmoid=True, + beta=2.0, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=2.0), + loss_mask=dict( + type='DiceLoss', loss_weight=2.0, eps=5e-6, reduction='mean')), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100, + mask_thr_binary=0.5), +) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict( + type='LoadAnnotations', + with_bbox=True, + with_mask=True, + poly2mask=False), + dict(type='CachedMosaic', img_scale=(640, 640), pad_val=114.0), + dict( + type='RandomResize', + scale=(1280, 1280), + ratio_range=(0.1, 2.0), + keep_ratio=True), + dict( + type='RandomCrop', + crop_size=(640, 640), + recompute_bbox=True, + allow_negative_crop=True), + dict(type='YOLOXHSVRandomAug'), + dict(type='RandomFlip', prob=0.5), + dict(type='Pad', size=(640, 640), pad_val=dict(img=(114, 114, 114))), + dict( + type='CachedMixUp', + img_scale=(640, 640), + ratio_range=(1.0, 1.0), + max_cached_images=20, + pad_val=(114, 114, 114)), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1, 1)), + dict(type='PackDetInputs') +] + +train_dataloader = dict(pin_memory=True, dataset=dict(pipeline=train_pipeline)) + +train_pipeline_stage2 = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict( + type='LoadAnnotations', + with_bbox=True, + with_mask=True, + poly2mask=False), + dict( + type='RandomResize', + scale=(640, 640), + ratio_range=(0.1, 2.0), + keep_ratio=True), + dict( + type='RandomCrop', + crop_size=(640, 640), + recompute_bbox=True, + allow_negative_crop=True), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1, 1)), + dict(type='YOLOXHSVRandomAug'), + dict(type='RandomFlip', prob=0.5), + dict(type='Pad', size=(640, 640), pad_val=dict(img=(114, 114, 114))), + dict(type='PackDetInputs') +] +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0002, + update_buffers=True, + priority=49), + dict( + type='PipelineSwitchHook', + switch_epoch=280, + switch_pipeline=train_pipeline_stage2) +] + +val_evaluator = dict(metric=['bbox', 'segm']) +test_evaluator = val_evaluator diff --git a/mmdetection/configs/rtmdet/rtmdet-ins_m_8xb32-300e_coco.py b/mmdetection/configs/rtmdet/rtmdet-ins_m_8xb32-300e_coco.py new file mode 100644 index 00000000..66da9148 --- /dev/null +++ b/mmdetection/configs/rtmdet/rtmdet-ins_m_8xb32-300e_coco.py @@ -0,0 +1,6 @@ +_base_ = './rtmdet-ins_l_8xb32-300e_coco.py' + +model = dict( + backbone=dict(deepen_factor=0.67, widen_factor=0.75), + neck=dict(in_channels=[192, 384, 768], out_channels=192, num_csp_blocks=2), + bbox_head=dict(in_channels=192, feat_channels=192)) diff --git a/mmdetection/configs/rtmdet/rtmdet-ins_s_8xb32-300e_coco.py b/mmdetection/configs/rtmdet/rtmdet-ins_s_8xb32-300e_coco.py new file mode 100644 index 00000000..28bc21cc --- /dev/null +++ b/mmdetection/configs/rtmdet/rtmdet-ins_s_8xb32-300e_coco.py @@ -0,0 +1,80 @@ +_base_ = './rtmdet-ins_l_8xb32-300e_coco.py' +checkpoint = 'https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-s_imagenet_600e.pth' # noqa +model = dict( + backbone=dict( + deepen_factor=0.33, + widen_factor=0.5, + init_cfg=dict( + type='Pretrained', prefix='backbone.', checkpoint=checkpoint)), + neck=dict(in_channels=[128, 256, 512], out_channels=128, num_csp_blocks=1), + bbox_head=dict(in_channels=128, feat_channels=128)) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict( + type='LoadAnnotations', + with_bbox=True, + with_mask=True, + poly2mask=False), + dict(type='CachedMosaic', img_scale=(640, 640), pad_val=114.0), + dict( + type='RandomResize', + scale=(1280, 1280), + ratio_range=(0.5, 2.0), + keep_ratio=True), + dict( + type='RandomCrop', + crop_size=(640, 640), + recompute_bbox=True, + allow_negative_crop=True), + dict(type='YOLOXHSVRandomAug'), + dict(type='RandomFlip', prob=0.5), + dict(type='Pad', size=(640, 640), pad_val=dict(img=(114, 114, 114))), + dict( + type='CachedMixUp', + img_scale=(640, 640), + ratio_range=(1.0, 1.0), + max_cached_images=20, + pad_val=(114, 114, 114)), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1, 1)), + dict(type='PackDetInputs') +] + +train_pipeline_stage2 = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict( + type='LoadAnnotations', + with_bbox=True, + with_mask=True, + poly2mask=False), + dict( + type='RandomResize', + scale=(640, 640), + ratio_range=(0.5, 2.0), + keep_ratio=True), + dict( + type='RandomCrop', + crop_size=(640, 640), + recompute_bbox=True, + allow_negative_crop=True), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1, 1)), + dict(type='YOLOXHSVRandomAug'), + dict(type='RandomFlip', prob=0.5), + dict(type='Pad', size=(640, 640), pad_val=dict(img=(114, 114, 114))), + dict(type='PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0002, + update_buffers=True, + priority=49), + dict( + type='PipelineSwitchHook', + switch_epoch=280, + switch_pipeline=train_pipeline_stage2) +] diff --git a/mmdetection/configs/rtmdet/rtmdet-ins_tiny_8xb32-300e_coco.py b/mmdetection/configs/rtmdet/rtmdet-ins_tiny_8xb32-300e_coco.py new file mode 100644 index 00000000..954f9116 --- /dev/null +++ b/mmdetection/configs/rtmdet/rtmdet-ins_tiny_8xb32-300e_coco.py @@ -0,0 +1,48 @@ +_base_ = './rtmdet-ins_s_8xb32-300e_coco.py' + +checkpoint = 'https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-tiny_imagenet_600e.pth' # noqa + +model = dict( + backbone=dict( + deepen_factor=0.167, + widen_factor=0.375, + init_cfg=dict( + type='Pretrained', prefix='backbone.', checkpoint=checkpoint)), + neck=dict(in_channels=[96, 192, 384], out_channels=96, num_csp_blocks=1), + bbox_head=dict(in_channels=96, feat_channels=96)) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict( + type='LoadAnnotations', + with_bbox=True, + with_mask=True, + poly2mask=False), + dict( + type='CachedMosaic', + img_scale=(640, 640), + pad_val=114.0, + max_cached_images=20, + random_pop=False), + dict( + type='RandomResize', + scale=(1280, 1280), + ratio_range=(0.5, 2.0), + keep_ratio=True), + dict(type='RandomCrop', crop_size=(640, 640)), + dict(type='YOLOXHSVRandomAug'), + dict(type='RandomFlip', prob=0.5), + dict(type='Pad', size=(640, 640), pad_val=dict(img=(114, 114, 114))), + dict( + type='CachedMixUp', + img_scale=(640, 640), + ratio_range=(1.0, 1.0), + max_cached_images=10, + random_pop=False, + pad_val=(114, 114, 114), + prob=0.5), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1, 1)), + dict(type='PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/mmdetection/configs/rtmdet/rtmdet-ins_x_8xb16-300e_coco.py b/mmdetection/configs/rtmdet/rtmdet-ins_x_8xb16-300e_coco.py new file mode 100644 index 00000000..daaa640e --- /dev/null +++ b/mmdetection/configs/rtmdet/rtmdet-ins_x_8xb16-300e_coco.py @@ -0,0 +1,31 @@ +_base_ = './rtmdet-ins_l_8xb32-300e_coco.py' + +model = dict( + backbone=dict(deepen_factor=1.33, widen_factor=1.25), + neck=dict( + in_channels=[320, 640, 1280], out_channels=320, num_csp_blocks=4), + bbox_head=dict(in_channels=320, feat_channels=320)) + +base_lr = 0.002 + +# optimizer +optim_wrapper = dict(optimizer=dict(lr=base_lr)) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0e-5, + by_epoch=False, + begin=0, + end=1000), + dict( + # use cosine lr from 150 to 300 epoch + type='CosineAnnealingLR', + eta_min=base_lr * 0.05, + begin=_base_.max_epochs // 2, + end=_base_.max_epochs, + T_max=_base_.max_epochs // 2, + by_epoch=True, + convert_to_iter_based=True), +] diff --git a/mmdetection/configs/rtmdet/rtmdet_l_8xb32-300e_coco.py b/mmdetection/configs/rtmdet/rtmdet_l_8xb32-300e_coco.py new file mode 100644 index 00000000..1cce4d89 --- /dev/null +++ b/mmdetection/configs/rtmdet/rtmdet_l_8xb32-300e_coco.py @@ -0,0 +1,179 @@ +_base_ = [ + '../_base_/default_runtime.py', '../_base_/schedules/schedule_1x.py', + '../_base_/datasets/coco_detection.py', './rtmdet_tta.py' +] +model = dict( + type='RTMDet', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[103.53, 116.28, 123.675], + std=[57.375, 57.12, 58.395], + bgr_to_rgb=False, + batch_augments=None), + backbone=dict( + type='CSPNeXt', + arch='P5', + expand_ratio=0.5, + deepen_factor=1, + widen_factor=1, + channel_attention=True, + norm_cfg=dict(type='SyncBN'), + act_cfg=dict(type='SiLU', inplace=True)), + neck=dict( + type='CSPNeXtPAFPN', + in_channels=[256, 512, 1024], + out_channels=256, + num_csp_blocks=3, + expand_ratio=0.5, + norm_cfg=dict(type='SyncBN'), + act_cfg=dict(type='SiLU', inplace=True)), + bbox_head=dict( + type='RTMDetSepBNHead', + num_classes=80, + in_channels=256, + stacked_convs=2, + feat_channels=256, + anchor_generator=dict( + type='MlvlPointGenerator', offset=0, strides=[8, 16, 32]), + bbox_coder=dict(type='DistancePointBBoxCoder'), + loss_cls=dict( + type='QualityFocalLoss', + use_sigmoid=True, + beta=2.0, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=2.0), + with_objectness=False, + exp_on_reg=True, + share_conv=True, + pred_kernel_size=1, + norm_cfg=dict(type='SyncBN'), + act_cfg=dict(type='SiLU', inplace=True)), + train_cfg=dict( + assigner=dict(type='DynamicSoftLabelAssigner', topk=13), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=30000, + min_bbox_size=0, + score_thr=0.001, + nms=dict(type='nms', iou_threshold=0.65), + max_per_img=300), +) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='CachedMosaic', img_scale=(640, 640), pad_val=114.0), + dict( + type='RandomResize', + scale=(1280, 1280), + ratio_range=(0.1, 2.0), + keep_ratio=True), + dict(type='RandomCrop', crop_size=(640, 640)), + dict(type='YOLOXHSVRandomAug'), + dict(type='RandomFlip', prob=0.5), + dict(type='Pad', size=(640, 640), pad_val=dict(img=(114, 114, 114))), + dict( + type='CachedMixUp', + img_scale=(640, 640), + ratio_range=(1.0, 1.0), + max_cached_images=20, + pad_val=(114, 114, 114)), + dict(type='PackDetInputs') +] + +train_pipeline_stage2 = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomResize', + scale=(640, 640), + ratio_range=(0.1, 2.0), + keep_ratio=True), + dict(type='RandomCrop', crop_size=(640, 640)), + dict(type='YOLOXHSVRandomAug'), + dict(type='RandomFlip', prob=0.5), + dict(type='Pad', size=(640, 640), pad_val=dict(img=(114, 114, 114))), + dict(type='PackDetInputs') +] + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=(640, 640), keep_ratio=True), + dict(type='Pad', size=(640, 640), pad_val=dict(img=(114, 114, 114))), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict( + batch_size=32, + num_workers=10, + batch_sampler=None, + pin_memory=True, + dataset=dict(pipeline=train_pipeline)) +val_dataloader = dict( + batch_size=5, num_workers=10, dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader + +max_epochs = 300 +stage2_num_epochs = 20 +base_lr = 0.004 +interval = 10 + +train_cfg = dict( + max_epochs=max_epochs, + val_interval=interval, + dynamic_intervals=[(max_epochs - stage2_num_epochs, 1)]) + +val_evaluator = dict(proposal_nums=(100, 1, 10)) +test_evaluator = val_evaluator + +# optimizer +optim_wrapper = dict( + _delete_=True, + type='OptimWrapper', + optimizer=dict(type='AdamW', lr=base_lr, weight_decay=0.05), + paramwise_cfg=dict( + norm_decay_mult=0, bias_decay_mult=0, bypass_duplicate=True)) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0e-5, + by_epoch=False, + begin=0, + end=1000), + dict( + # use cosine lr from 150 to 300 epoch + type='CosineAnnealingLR', + eta_min=base_lr * 0.05, + begin=max_epochs // 2, + end=max_epochs, + T_max=max_epochs // 2, + by_epoch=True, + convert_to_iter_based=True), +] + +# hooks +default_hooks = dict( + checkpoint=dict( + interval=interval, + max_keep_ckpts=3 # only keep latest 3 checkpoints + )) +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0002, + update_buffers=True, + priority=49), + dict( + type='PipelineSwitchHook', + switch_epoch=max_epochs - stage2_num_epochs, + switch_pipeline=train_pipeline_stage2) +] diff --git a/mmdetection/configs/rtmdet/rtmdet_l_convnext_b_4xb32-100e_coco.py b/mmdetection/configs/rtmdet/rtmdet_l_convnext_b_4xb32-100e_coco.py new file mode 100644 index 00000000..85af292b --- /dev/null +++ b/mmdetection/configs/rtmdet/rtmdet_l_convnext_b_4xb32-100e_coco.py @@ -0,0 +1,81 @@ +_base_ = './rtmdet_l_8xb32-300e_coco.py' + +custom_imports = dict( + imports=['mmpretrain.models'], allow_failed_imports=False) + +norm_cfg = dict(type='GN', num_groups=32) +checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/convnext/convnext-base_in21k-pre-3rdparty_in1k-384px_20221219-4570f792.pth' # noqa +model = dict( + type='RTMDet', + data_preprocessor=dict( + _delete_=True, + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + batch_augments=None), + backbone=dict( + _delete_=True, + type='mmpretrain.ConvNeXt', + arch='base', + out_indices=[1, 2, 3], + drop_path_rate=0.7, + layer_scale_init_value=1.0, + gap_before_final_norm=False, + with_cp=True, + init_cfg=dict( + type='Pretrained', checkpoint=checkpoint_file, + prefix='backbone.')), + neck=dict(in_channels=[256, 512, 1024], norm_cfg=norm_cfg), + bbox_head=dict(norm_cfg=norm_cfg)) + +max_epochs = 100 +stage2_num_epochs = 10 +interval = 10 +base_lr = 0.001 + +train_cfg = dict( + max_epochs=max_epochs, + val_interval=interval, + dynamic_intervals=[(max_epochs - stage2_num_epochs, 1)]) + +optim_wrapper = dict( + constructor='LearningRateDecayOptimizerConstructor', + paramwise_cfg={ + 'decay_rate': 0.8, + 'decay_type': 'layer_wise', + 'num_layers': 12 + }, + optimizer=dict(lr=base_lr)) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0e-5, + by_epoch=False, + begin=0, + end=1000), + dict( + # use cosine lr from 50 to 100 epoch + type='CosineAnnealingLR', + eta_min=base_lr * 0.05, + begin=max_epochs // 2, + end=max_epochs, + T_max=max_epochs // 2, + by_epoch=True, + convert_to_iter_based=True), +] + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0002, + update_buffers=True, + priority=49), + dict( + type='PipelineSwitchHook', + switch_epoch=max_epochs - stage2_num_epochs, + switch_pipeline={{_base_.train_pipeline_stage2}}) +] diff --git a/mmdetection/configs/rtmdet/rtmdet_l_swin_b_4xb32-100e_coco.py b/mmdetection/configs/rtmdet/rtmdet_l_swin_b_4xb32-100e_coco.py new file mode 100644 index 00000000..84b0e0fa --- /dev/null +++ b/mmdetection/configs/rtmdet/rtmdet_l_swin_b_4xb32-100e_coco.py @@ -0,0 +1,78 @@ +_base_ = './rtmdet_l_8xb32-300e_coco.py' + +norm_cfg = dict(type='GN', num_groups=32) +checkpoint = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_base_patch4_window12_384_22k.pth' # noqa +model = dict( + type='RTMDet', + data_preprocessor=dict( + _delete_=True, + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + batch_augments=None), + backbone=dict( + _delete_=True, + type='SwinTransformer', + pretrain_img_size=384, + embed_dims=128, + depths=[2, 2, 18, 2], + num_heads=[4, 8, 16, 32], + window_size=12, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.3, + patch_norm=True, + out_indices=(1, 2, 3), + with_cp=True, + convert_weights=True, + init_cfg=dict(type='Pretrained', checkpoint=checkpoint)), + neck=dict(in_channels=[256, 512, 1024], norm_cfg=norm_cfg), + bbox_head=dict(norm_cfg=norm_cfg)) + +max_epochs = 100 +stage2_num_epochs = 10 +interval = 10 +base_lr = 0.001 + +train_cfg = dict( + max_epochs=max_epochs, + val_interval=interval, + dynamic_intervals=[(max_epochs - stage2_num_epochs, 1)]) + +optim_wrapper = dict(optimizer=dict(lr=base_lr)) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0e-5, + by_epoch=False, + begin=0, + end=1000), + dict( + # use cosine lr from 50 to 100 epoch + type='CosineAnnealingLR', + eta_min=base_lr * 0.05, + begin=max_epochs // 2, + end=max_epochs, + T_max=max_epochs // 2, + by_epoch=True, + convert_to_iter_based=True), +] + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0002, + update_buffers=True, + priority=49), + dict( + type='PipelineSwitchHook', + switch_epoch=max_epochs - stage2_num_epochs, + switch_pipeline={{_base_.train_pipeline_stage2}}) +] diff --git a/mmdetection/configs/rtmdet/rtmdet_l_swin_b_p6_4xb16-100e_coco.py b/mmdetection/configs/rtmdet/rtmdet_l_swin_b_p6_4xb16-100e_coco.py new file mode 100644 index 00000000..37d4215c --- /dev/null +++ b/mmdetection/configs/rtmdet/rtmdet_l_swin_b_p6_4xb16-100e_coco.py @@ -0,0 +1,114 @@ +_base_ = './rtmdet_l_swin_b_4xb32-100e_coco.py' + +model = dict( + backbone=dict( + depths=[2, 2, 18, 2, 1], + num_heads=[4, 8, 16, 32, 64], + strides=(4, 2, 2, 2, 2), + out_indices=(1, 2, 3, 4)), + neck=dict(in_channels=[256, 512, 1024, 2048]), + bbox_head=dict( + anchor_generator=dict( + type='MlvlPointGenerator', offset=0, strides=[8, 16, 32, 64]))) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='CachedMosaic', img_scale=(1280, 1280), pad_val=114.0), + dict( + type='RandomResize', + scale=(2560, 2560), + ratio_range=(0.1, 2.0), + keep_ratio=True), + dict(type='RandomCrop', crop_size=(1280, 1280)), + dict(type='YOLOXHSVRandomAug'), + dict(type='RandomFlip', prob=0.5), + dict(type='Pad', size=(1280, 1280), pad_val=dict(img=(114, 114, 114))), + dict( + type='CachedMixUp', + img_scale=(1280, 1280), + ratio_range=(1.0, 1.0), + max_cached_images=20, + pad_val=(114, 114, 114)), + dict(type='PackDetInputs') +] + +train_pipeline_stage2 = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomResize', + scale=(1280, 1280), + ratio_range=(0.1, 2.0), + keep_ratio=True), + dict(type='RandomCrop', crop_size=(1280, 1280)), + dict(type='YOLOXHSVRandomAug'), + dict(type='RandomFlip', prob=0.5), + dict(type='Pad', size=(1280, 1280), pad_val=dict(img=(114, 114, 114))), + dict(type='PackDetInputs') +] + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=(1280, 1280), keep_ratio=True), + dict(type='Pad', size=(1280, 1280), pad_val=dict(img=(114, 114, 114))), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict( + batch_size=16, num_workers=20, dataset=dict(pipeline=train_pipeline)) +val_dataloader = dict(num_workers=20, dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader + +max_epochs = 100 +stage2_num_epochs = 10 + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0002, + update_buffers=True, + priority=49), + dict( + type='PipelineSwitchHook', + switch_epoch=max_epochs - stage2_num_epochs, + switch_pipeline=train_pipeline_stage2) +] + +img_scales = [(1280, 1280), (640, 640), (1920, 1920)] +tta_pipeline = [ + dict(type='LoadImageFromFile', backend_args=None), + dict( + type='TestTimeAug', + transforms=[ + [ + dict(type='Resize', scale=s, keep_ratio=True) + for s in img_scales + ], + [ + # ``RandomFlip`` must be placed before ``Pad``, otherwise + # bounding box coordinates after flipping cannot be + # recovered correctly. + dict(type='RandomFlip', prob=1.), + dict(type='RandomFlip', prob=0.) + ], + [ + dict( + type='Pad', + size=(1920, 1920), + pad_val=dict(img=(114, 114, 114))), + ], + [dict(type='LoadAnnotations', with_bbox=True)], + [ + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction')) + ] + ]) +] diff --git a/mmdetection/configs/rtmdet/rtmdet_m_8xb32-300e_coco.py b/mmdetection/configs/rtmdet/rtmdet_m_8xb32-300e_coco.py new file mode 100644 index 00000000..c83f5a60 --- /dev/null +++ b/mmdetection/configs/rtmdet/rtmdet_m_8xb32-300e_coco.py @@ -0,0 +1,6 @@ +_base_ = './rtmdet_l_8xb32-300e_coco.py' + +model = dict( + backbone=dict(deepen_factor=0.67, widen_factor=0.75), + neck=dict(in_channels=[192, 384, 768], out_channels=192, num_csp_blocks=2), + bbox_head=dict(in_channels=192, feat_channels=192)) diff --git a/mmdetection/configs/rtmdet/rtmdet_s_8xb32-300e_coco.py b/mmdetection/configs/rtmdet/rtmdet_s_8xb32-300e_coco.py new file mode 100644 index 00000000..cbf76247 --- /dev/null +++ b/mmdetection/configs/rtmdet/rtmdet_s_8xb32-300e_coco.py @@ -0,0 +1,62 @@ +_base_ = './rtmdet_l_8xb32-300e_coco.py' +checkpoint = 'https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-s_imagenet_600e.pth' # noqa +model = dict( + backbone=dict( + deepen_factor=0.33, + widen_factor=0.5, + init_cfg=dict( + type='Pretrained', prefix='backbone.', checkpoint=checkpoint)), + neck=dict(in_channels=[128, 256, 512], out_channels=128, num_csp_blocks=1), + bbox_head=dict(in_channels=128, feat_channels=128, exp_on_reg=False)) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='CachedMosaic', img_scale=(640, 640), pad_val=114.0), + dict( + type='RandomResize', + scale=(1280, 1280), + ratio_range=(0.5, 2.0), + keep_ratio=True), + dict(type='RandomCrop', crop_size=(640, 640)), + dict(type='YOLOXHSVRandomAug'), + dict(type='RandomFlip', prob=0.5), + dict(type='Pad', size=(640, 640), pad_val=dict(img=(114, 114, 114))), + dict( + type='CachedMixUp', + img_scale=(640, 640), + ratio_range=(1.0, 1.0), + max_cached_images=20, + pad_val=(114, 114, 114)), + dict(type='PackDetInputs') +] + +train_pipeline_stage2 = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomResize', + scale=(640, 640), + ratio_range=(0.5, 2.0), + keep_ratio=True), + dict(type='RandomCrop', crop_size=(640, 640)), + dict(type='YOLOXHSVRandomAug'), + dict(type='RandomFlip', prob=0.5), + dict(type='Pad', size=(640, 640), pad_val=dict(img=(114, 114, 114))), + dict(type='PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0002, + update_buffers=True, + priority=49), + dict( + type='PipelineSwitchHook', + switch_epoch=280, + switch_pipeline=train_pipeline_stage2) +] diff --git a/mmdetection/configs/rtmdet/rtmdet_tiny_8xb32-300e_coco.py b/mmdetection/configs/rtmdet/rtmdet_tiny_8xb32-300e_coco.py new file mode 100644 index 00000000..a686f4a7 --- /dev/null +++ b/mmdetection/configs/rtmdet/rtmdet_tiny_8xb32-300e_coco.py @@ -0,0 +1,43 @@ +_base_ = './rtmdet_s_8xb32-300e_coco.py' + +checkpoint = 'https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-tiny_imagenet_600e.pth' # noqa + +model = dict( + backbone=dict( + deepen_factor=0.167, + widen_factor=0.375, + init_cfg=dict( + type='Pretrained', prefix='backbone.', checkpoint=checkpoint)), + neck=dict(in_channels=[96, 192, 384], out_channels=96, num_csp_blocks=1), + bbox_head=dict(in_channels=96, feat_channels=96, exp_on_reg=False)) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='CachedMosaic', + img_scale=(640, 640), + pad_val=114.0, + max_cached_images=20, + random_pop=False), + dict( + type='RandomResize', + scale=(1280, 1280), + ratio_range=(0.5, 2.0), + keep_ratio=True), + dict(type='RandomCrop', crop_size=(640, 640)), + dict(type='YOLOXHSVRandomAug'), + dict(type='RandomFlip', prob=0.5), + dict(type='Pad', size=(640, 640), pad_val=dict(img=(114, 114, 114))), + dict( + type='CachedMixUp', + img_scale=(640, 640), + ratio_range=(1.0, 1.0), + max_cached_images=10, + random_pop=False, + pad_val=(114, 114, 114), + prob=0.5), + dict(type='PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/mmdetection/configs/rtmdet/rtmdet_tta.py b/mmdetection/configs/rtmdet/rtmdet_tta.py new file mode 100644 index 00000000..6dde36de --- /dev/null +++ b/mmdetection/configs/rtmdet/rtmdet_tta.py @@ -0,0 +1,36 @@ +tta_model = dict( + type='DetTTAModel', + tta_cfg=dict(nms=dict(type='nms', iou_threshold=0.6), max_per_img=100)) + +img_scales = [(640, 640), (320, 320), (960, 960)] +tta_pipeline = [ + dict(type='LoadImageFromFile', backend_args=None), + dict( + type='TestTimeAug', + transforms=[ + [ + dict(type='Resize', scale=s, keep_ratio=True) + for s in img_scales + ], + [ + # ``RandomFlip`` must be placed before ``Pad``, otherwise + # bounding box coordinates after flipping cannot be + # recovered correctly. + dict(type='RandomFlip', prob=1.), + dict(type='RandomFlip', prob=0.) + ], + [ + dict( + type='Pad', + size=(960, 960), + pad_val=dict(img=(114, 114, 114))), + ], + [dict(type='LoadAnnotations', with_bbox=True)], + [ + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction')) + ] + ]) +] diff --git a/mmdetection/configs/rtmdet/rtmdet_x_8xb32-300e_coco.py b/mmdetection/configs/rtmdet/rtmdet_x_8xb32-300e_coco.py new file mode 100644 index 00000000..16a33632 --- /dev/null +++ b/mmdetection/configs/rtmdet/rtmdet_x_8xb32-300e_coco.py @@ -0,0 +1,7 @@ +_base_ = './rtmdet_l_8xb32-300e_coco.py' + +model = dict( + backbone=dict(deepen_factor=1.33, widen_factor=1.25), + neck=dict( + in_channels=[320, 640, 1280], out_channels=320, num_csp_blocks=4), + bbox_head=dict(in_channels=320, feat_channels=320)) diff --git a/mmdetection/configs/rtmdet/rtmdet_x_p6_4xb8-300e_coco.py b/mmdetection/configs/rtmdet/rtmdet_x_p6_4xb8-300e_coco.py new file mode 100644 index 00000000..d1bb7fa6 --- /dev/null +++ b/mmdetection/configs/rtmdet/rtmdet_x_p6_4xb8-300e_coco.py @@ -0,0 +1,132 @@ +_base_ = './rtmdet_x_8xb32-300e_coco.py' + +model = dict( + backbone=dict(arch='P6', out_indices=(2, 3, 4, 5)), + neck=dict(in_channels=[320, 640, 960, 1280]), + bbox_head=dict( + anchor_generator=dict( + type='MlvlPointGenerator', offset=0, strides=[8, 16, 32, 64]))) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='CachedMosaic', img_scale=(1280, 1280), pad_val=114.0), + dict( + type='RandomResize', + scale=(2560, 2560), + ratio_range=(0.1, 2.0), + keep_ratio=True), + dict(type='RandomCrop', crop_size=(1280, 1280)), + dict(type='YOLOXHSVRandomAug'), + dict(type='RandomFlip', prob=0.5), + dict(type='Pad', size=(1280, 1280), pad_val=dict(img=(114, 114, 114))), + dict( + type='CachedMixUp', + img_scale=(1280, 1280), + ratio_range=(1.0, 1.0), + max_cached_images=20, + pad_val=(114, 114, 114)), + dict(type='PackDetInputs') +] + +train_pipeline_stage2 = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomResize', + scale=(1280, 1280), + ratio_range=(0.1, 2.0), + keep_ratio=True), + dict(type='RandomCrop', crop_size=(1280, 1280)), + dict(type='YOLOXHSVRandomAug'), + dict(type='RandomFlip', prob=0.5), + dict(type='Pad', size=(1280, 1280), pad_val=dict(img=(114, 114, 114))), + dict(type='PackDetInputs') +] + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=(1280, 1280), keep_ratio=True), + dict(type='Pad', size=(1280, 1280), pad_val=dict(img=(114, 114, 114))), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict( + batch_size=8, num_workers=20, dataset=dict(pipeline=train_pipeline)) +val_dataloader = dict( + batch_size=5, num_workers=20, dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader + +max_epochs = 300 +stage2_num_epochs = 20 + +base_lr = 0.004 * 32 / 256 +optim_wrapper = dict(optimizer=dict(lr=base_lr)) + +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0e-5, + by_epoch=False, + begin=0, + end=1000), + dict( + # use cosine lr from 150 to 300 epoch + type='CosineAnnealingLR', + eta_min=base_lr * 0.05, + begin=max_epochs // 2, + end=max_epochs, + T_max=max_epochs // 2, + by_epoch=True, + convert_to_iter_based=True), +] + +custom_hooks = [ + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0002, + update_buffers=True, + priority=49), + dict( + type='PipelineSwitchHook', + switch_epoch=max_epochs - stage2_num_epochs, + switch_pipeline=train_pipeline_stage2) +] + +img_scales = [(1280, 1280), (640, 640), (1920, 1920)] +tta_pipeline = [ + dict(type='LoadImageFromFile', backend_args=None), + dict( + type='TestTimeAug', + transforms=[ + [ + dict(type='Resize', scale=s, keep_ratio=True) + for s in img_scales + ], + [ + # ``RandomFlip`` must be placed before ``Pad``, otherwise + # bounding box coordinates after flipping cannot be + # recovered correctly. + dict(type='RandomFlip', prob=1.), + dict(type='RandomFlip', prob=0.) + ], + [ + dict( + type='Pad', + size=(1920, 1920), + pad_val=dict(img=(114, 114, 114))), + ], + [dict(type='LoadAnnotations', with_bbox=True)], + [ + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction')) + ] + ]) +] diff --git a/mmdetection/configs/sabl/README.md b/mmdetection/configs/sabl/README.md new file mode 100644 index 00000000..c730729c --- /dev/null +++ b/mmdetection/configs/sabl/README.md @@ -0,0 +1,47 @@ +# SABL + +> [Side-Aware Boundary Localization for More Precise Object Detection](https://arxiv.org/abs/1912.04260) + + + +## Abstract + +Current object detection frameworks mainly rely on bounding box regression to localize objects. Despite the remarkable progress in recent years, the precision of bounding box regression remains unsatisfactory, hence limiting performance in object detection. We observe that precise localization requires careful placement of each side of the bounding box. However, the mainstream approach, which focuses on predicting centers and sizes, is not the most effective way to accomplish this task, especially when there exists displacements with large variance between the anchors and the targets. In this paper, we propose an alternative approach, named as Side-Aware Boundary Localization (SABL), where each side of the bounding box is respectively localized with a dedicated network branch. To tackle the difficulty of precise localization in the presence of displacements with large variance, we further propose a two-step localization scheme, which first predicts a range of movement through bucket prediction and then pinpoints the precise position within the predicted bucket. We test the proposed method on both two-stage and single-stage detection frameworks. Replacing the standard bounding box regression branch with the proposed design leads to significant improvements on Faster R-CNN, RetinaNet, and Cascade R-CNN, by 3.0%, 1.7%, and 0.9%, respectively. + +
    + +
    + +## Results and Models + +The results on COCO 2017 val is shown in the below table. (results on test-dev are usually slightly higher than val). +Single-scale testing (1333x800) is adopted in all results. + +| Method | Backbone | Lr schd | ms-train | box AP | Config | Download | +| :----------------: | :-------: | :-----: | :------: | :----: | :-----------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| SABL Faster R-CNN | R-50-FPN | 1x | N | 39.9 | [config](./sabl-faster-rcnn_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_faster_rcnn_r50_fpn_1x_coco/sabl_faster_rcnn_r50_fpn_1x_coco-e867595b.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_faster_rcnn_r50_fpn_1x_coco/20200830_130324.log.json) | +| SABL Faster R-CNN | R-101-FPN | 1x | N | 41.7 | [config](./sabl-faster-rcnn_r101_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_faster_rcnn_r101_fpn_1x_coco/sabl_faster_rcnn_r101_fpn_1x_coco-f804c6c1.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_faster_rcnn_r101_fpn_1x_coco/20200830_183949.log.json) | +| SABL Cascade R-CNN | R-50-FPN | 1x | N | 41.6 | [config](./sabl-cascade-rcnn_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_cascade_rcnn_r50_fpn_1x_coco/sabl_cascade_rcnn_r50_fpn_1x_coco-e1748e5e.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_cascade_rcnn_r50_fpn_1x_coco/20200831_033726.log.json) | +| SABL Cascade R-CNN | R-101-FPN | 1x | N | 43.0 | [config](./sabl-cascade-rcnn_r101_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_cascade_rcnn_r101_fpn_1x_coco/sabl_cascade_rcnn_r101_fpn_1x_coco-2b83e87c.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_cascade_rcnn_r101_fpn_1x_coco/20200831_141745.log.json) | + +| Method | Backbone | GN | Lr schd | ms-train | box AP | Config | Download | +| :------------: | :-------: | :-: | :-----: | :---------: | :----: | :----------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| SABL RetinaNet | R-50-FPN | N | 1x | N | 37.7 | [config](./sabl-retinanet_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_retinanet_r50_fpn_1x_coco/sabl_retinanet_r50_fpn_1x_coco-6c54fd4f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_retinanet_r50_fpn_1x_coco/20200830_053451.log.json) | +| SABL RetinaNet | R-50-FPN | Y | 1x | N | 38.8 | [config](./sabl-retinanet_r50-gn_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_retinanet_r50_fpn_gn_1x_coco/sabl_retinanet_r50_fpn_gn_1x_coco-e16dfcf1.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_retinanet_r50_fpn_gn_1x_coco/20200831_141955.log.json) | +| SABL RetinaNet | R-101-FPN | N | 1x | N | 39.7 | [config](./sabl-retinanet_r101_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_retinanet_r101_fpn_1x_coco/sabl_retinanet_r101_fpn_1x_coco-42026904.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_retinanet_r101_fpn_1x_coco/20200831_034256.log.json) | +| SABL RetinaNet | R-101-FPN | Y | 1x | N | 40.5 | [config](./sabl-retinanet_r101-gn_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_retinanet_r101_fpn_gn_1x_coco/sabl_retinanet_r101_fpn_gn_1x_coco-40a893e8.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_retinanet_r101_fpn_gn_1x_coco/20200830_201422.log.json) | +| SABL RetinaNet | R-101-FPN | Y | 2x | Y (640~800) | 42.9 | [config](./sabl-retinanet_r101-gn_fpn_ms-640-800-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_retinanet_r101_fpn_gn_2x_ms_640_800_coco/sabl_retinanet_r101_fpn_gn_2x_ms_640_800_coco-1e63382c.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_retinanet_r101_fpn_gn_2x_ms_640_800_coco/20200830_144807.log.json) | +| SABL RetinaNet | R-101-FPN | Y | 2x | Y (480~960) | 43.6 | [config](./sabl-retinanet_r101-gn_fpn_ms-480-960-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_retinanet_r101_fpn_gn_2x_ms_480_960_coco/sabl_retinanet_r101_fpn_gn_2x_ms_480_960_coco-5342f857.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_retinanet_r101_fpn_gn_2x_ms_480_960_coco/20200830_164537.log.json) | + +## Citation + +We provide config files to reproduce the object detection results in the ECCV 2020 Spotlight paper for [Side-Aware Boundary Localization for More Precise Object Detection](https://arxiv.org/abs/1912.04260). + +```latex +@inproceedings{Wang_2020_ECCV, + title = {Side-Aware Boundary Localization for More Precise Object Detection}, + author = {Jiaqi Wang and Wenwei Zhang and Yuhang Cao and Kai Chen and Jiangmiao Pang and Tao Gong and Jianping Shi and Chen Change Loy and Dahua Lin}, + booktitle = {ECCV}, + year = {2020} +} +``` diff --git a/mmdetection/configs/sabl/metafile.yml b/mmdetection/configs/sabl/metafile.yml new file mode 100644 index 00000000..632b869c --- /dev/null +++ b/mmdetection/configs/sabl/metafile.yml @@ -0,0 +1,140 @@ +Collections: + - Name: SABL + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - FPN + - ResNet + - SABL + Paper: + URL: https://arxiv.org/abs/1912.04260 + Title: 'Side-Aware Boundary Localization for More Precise Object Detection' + README: configs/sabl/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.4.0/mmdet/models/roi_heads/bbox_heads/sabl_head.py#L14 + Version: v2.4.0 + +Models: + - Name: sabl-faster-rcnn_r50_fpn_1x_coco + In Collection: SABL + Config: configs/sabl/sabl-faster-rcnn_r50_fpn_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_faster_rcnn_r50_fpn_1x_coco/sabl_faster_rcnn_r50_fpn_1x_coco-e867595b.pth + + - Name: sabl-faster-rcnn_r101_fpn_1x_coco + In Collection: SABL + Config: configs/sabl/sabl-faster-rcnn_r101_fpn_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_faster_rcnn_r101_fpn_1x_coco/sabl_faster_rcnn_r101_fpn_1x_coco-f804c6c1.pth + + - Name: sabl-cascade-rcnn_r50_fpn_1x_coco + In Collection: SABL + Config: configs/sabl/sabl-cascade-rcnn_r50_fpn_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_cascade_rcnn_r50_fpn_1x_coco/sabl_cascade_rcnn_r50_fpn_1x_coco-e1748e5e.pth + + - Name: sabl-cascade-rcnn_r101_fpn_1x_coco + In Collection: SABL + Config: configs/sabl/sabl-cascade-rcnn_r101_fpn_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_cascade_rcnn_r101_fpn_1x_coco/sabl_cascade_rcnn_r101_fpn_1x_coco-2b83e87c.pth + + - Name: sabl-retinanet_r50_fpn_1x_coco + In Collection: SABL + Config: configs/sabl/sabl-retinanet_r50_fpn_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_retinanet_r50_fpn_1x_coco/sabl_retinanet_r50_fpn_1x_coco-6c54fd4f.pth + + - Name: sabl-retinanet_r50-gn_fpn_1x_coco + In Collection: SABL + Config: configs/sabl/sabl-retinanet_r50-gn_fpn_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 38.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_retinanet_r50_fpn_gn_1x_coco/sabl_retinanet_r50_fpn_gn_1x_coco-e16dfcf1.pth + + - Name: sabl-retinanet_r101_fpn_1x_coco + In Collection: SABL + Config: configs/sabl/sabl-retinanet_r101_fpn_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 39.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_retinanet_r101_fpn_1x_coco/sabl_retinanet_r101_fpn_1x_coco-42026904.pth + + - Name: sabl-retinanet_r101-gn_fpn_1x_coco + In Collection: SABL + Config: configs/sabl/sabl-retinanet_r101-gn_fpn_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_retinanet_r101_fpn_gn_1x_coco/sabl_retinanet_r101_fpn_gn_1x_coco-40a893e8.pth + + - Name: sabl-retinanet_r101-gn_fpn_ms-640-800-2x_coco + In Collection: SABL + Config: configs/sabl/sabl-retinanet_r101-gn_fpn_ms-640-800-2x_coco.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_retinanet_r101_fpn_gn_2x_ms_640_800_coco/sabl_retinanet_r101_fpn_gn_2x_ms_640_800_coco-1e63382c.pth + + - Name: sabl-retinanet_r101-gn_fpn_ms-480-960-2x_coco + In Collection: SABL + Config: configs/sabl/sabl-retinanet_r101-gn_fpn_ms-480-960-2x_coco.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/sabl/sabl_retinanet_r101_fpn_gn_2x_ms_480_960_coco/sabl_retinanet_r101_fpn_gn_2x_ms_480_960_coco-5342f857.pth diff --git a/mmdetection/configs/sabl/sabl-cascade-rcnn_r101_fpn_1x_coco.py b/mmdetection/configs/sabl/sabl-cascade-rcnn_r101_fpn_1x_coco.py new file mode 100644 index 00000000..404e7fcb --- /dev/null +++ b/mmdetection/configs/sabl/sabl-cascade-rcnn_r101_fpn_1x_coco.py @@ -0,0 +1,90 @@ +_base_ = [ + '../_base_/models/cascade-rcnn_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +# model settings +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101')), + roi_head=dict(bbox_head=[ + dict( + type='SABLHead', + num_classes=80, + cls_in_channels=256, + reg_in_channels=256, + roi_feat_size=7, + reg_feat_up_ratio=2, + reg_pre_kernel=3, + reg_post_kernel=3, + reg_pre_num=2, + reg_post_num=1, + cls_out_channels=1024, + reg_offset_out_channels=256, + reg_cls_out_channels=256, + num_cls_fcs=1, + num_reg_fcs=0, + reg_class_agnostic=True, + norm_cfg=None, + bbox_coder=dict( + type='BucketingBBoxCoder', num_buckets=14, scale_factor=1.7), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0), + loss_bbox_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox_reg=dict(type='SmoothL1Loss', beta=0.1, + loss_weight=1.0)), + dict( + type='SABLHead', + num_classes=80, + cls_in_channels=256, + reg_in_channels=256, + roi_feat_size=7, + reg_feat_up_ratio=2, + reg_pre_kernel=3, + reg_post_kernel=3, + reg_pre_num=2, + reg_post_num=1, + cls_out_channels=1024, + reg_offset_out_channels=256, + reg_cls_out_channels=256, + num_cls_fcs=1, + num_reg_fcs=0, + reg_class_agnostic=True, + norm_cfg=None, + bbox_coder=dict( + type='BucketingBBoxCoder', num_buckets=14, scale_factor=1.5), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0), + loss_bbox_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox_reg=dict(type='SmoothL1Loss', beta=0.1, + loss_weight=1.0)), + dict( + type='SABLHead', + num_classes=80, + cls_in_channels=256, + reg_in_channels=256, + roi_feat_size=7, + reg_feat_up_ratio=2, + reg_pre_kernel=3, + reg_post_kernel=3, + reg_pre_num=2, + reg_post_num=1, + cls_out_channels=1024, + reg_offset_out_channels=256, + reg_cls_out_channels=256, + num_cls_fcs=1, + num_reg_fcs=0, + reg_class_agnostic=True, + norm_cfg=None, + bbox_coder=dict( + type='BucketingBBoxCoder', num_buckets=14, scale_factor=1.3), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0), + loss_bbox_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox_reg=dict(type='SmoothL1Loss', beta=0.1, loss_weight=1.0)) + ])) diff --git a/mmdetection/configs/sabl/sabl-cascade-rcnn_r50_fpn_1x_coco.py b/mmdetection/configs/sabl/sabl-cascade-rcnn_r50_fpn_1x_coco.py new file mode 100644 index 00000000..69c59ca2 --- /dev/null +++ b/mmdetection/configs/sabl/sabl-cascade-rcnn_r50_fpn_1x_coco.py @@ -0,0 +1,86 @@ +_base_ = [ + '../_base_/models/cascade-rcnn_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +# model settings +model = dict( + roi_head=dict(bbox_head=[ + dict( + type='SABLHead', + num_classes=80, + cls_in_channels=256, + reg_in_channels=256, + roi_feat_size=7, + reg_feat_up_ratio=2, + reg_pre_kernel=3, + reg_post_kernel=3, + reg_pre_num=2, + reg_post_num=1, + cls_out_channels=1024, + reg_offset_out_channels=256, + reg_cls_out_channels=256, + num_cls_fcs=1, + num_reg_fcs=0, + reg_class_agnostic=True, + norm_cfg=None, + bbox_coder=dict( + type='BucketingBBoxCoder', num_buckets=14, scale_factor=1.7), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0), + loss_bbox_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox_reg=dict(type='SmoothL1Loss', beta=0.1, + loss_weight=1.0)), + dict( + type='SABLHead', + num_classes=80, + cls_in_channels=256, + reg_in_channels=256, + roi_feat_size=7, + reg_feat_up_ratio=2, + reg_pre_kernel=3, + reg_post_kernel=3, + reg_pre_num=2, + reg_post_num=1, + cls_out_channels=1024, + reg_offset_out_channels=256, + reg_cls_out_channels=256, + num_cls_fcs=1, + num_reg_fcs=0, + reg_class_agnostic=True, + norm_cfg=None, + bbox_coder=dict( + type='BucketingBBoxCoder', num_buckets=14, scale_factor=1.5), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0), + loss_bbox_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox_reg=dict(type='SmoothL1Loss', beta=0.1, + loss_weight=1.0)), + dict( + type='SABLHead', + num_classes=80, + cls_in_channels=256, + reg_in_channels=256, + roi_feat_size=7, + reg_feat_up_ratio=2, + reg_pre_kernel=3, + reg_post_kernel=3, + reg_pre_num=2, + reg_post_num=1, + cls_out_channels=1024, + reg_offset_out_channels=256, + reg_cls_out_channels=256, + num_cls_fcs=1, + num_reg_fcs=0, + reg_class_agnostic=True, + norm_cfg=None, + bbox_coder=dict( + type='BucketingBBoxCoder', num_buckets=14, scale_factor=1.3), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0), + loss_bbox_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox_reg=dict(type='SmoothL1Loss', beta=0.1, loss_weight=1.0)) + ])) diff --git a/mmdetection/configs/sabl/sabl-faster-rcnn_r101_fpn_1x_coco.py b/mmdetection/configs/sabl/sabl-faster-rcnn_r101_fpn_1x_coco.py new file mode 100644 index 00000000..d1bf8b9c --- /dev/null +++ b/mmdetection/configs/sabl/sabl-faster-rcnn_r101_fpn_1x_coco.py @@ -0,0 +1,38 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101')), + roi_head=dict( + bbox_head=dict( + _delete_=True, + type='SABLHead', + num_classes=80, + cls_in_channels=256, + reg_in_channels=256, + roi_feat_size=7, + reg_feat_up_ratio=2, + reg_pre_kernel=3, + reg_post_kernel=3, + reg_pre_num=2, + reg_post_num=1, + cls_out_channels=1024, + reg_offset_out_channels=256, + reg_cls_out_channels=256, + num_cls_fcs=1, + num_reg_fcs=0, + reg_class_agnostic=True, + norm_cfg=None, + bbox_coder=dict( + type='BucketingBBoxCoder', num_buckets=14, scale_factor=1.7), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0), + loss_bbox_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox_reg=dict(type='SmoothL1Loss', beta=0.1, + loss_weight=1.0)))) diff --git a/mmdetection/configs/sabl/sabl-faster-rcnn_r50_fpn_1x_coco.py b/mmdetection/configs/sabl/sabl-faster-rcnn_r50_fpn_1x_coco.py new file mode 100644 index 00000000..a727bd6d --- /dev/null +++ b/mmdetection/configs/sabl/sabl-faster-rcnn_r50_fpn_1x_coco.py @@ -0,0 +1,34 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +model = dict( + roi_head=dict( + bbox_head=dict( + _delete_=True, + type='SABLHead', + num_classes=80, + cls_in_channels=256, + reg_in_channels=256, + roi_feat_size=7, + reg_feat_up_ratio=2, + reg_pre_kernel=3, + reg_post_kernel=3, + reg_pre_num=2, + reg_post_num=1, + cls_out_channels=1024, + reg_offset_out_channels=256, + reg_cls_out_channels=256, + num_cls_fcs=1, + num_reg_fcs=0, + reg_class_agnostic=True, + norm_cfg=None, + bbox_coder=dict( + type='BucketingBBoxCoder', num_buckets=14, scale_factor=1.7), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0), + loss_bbox_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox_reg=dict(type='SmoothL1Loss', beta=0.1, + loss_weight=1.0)))) diff --git a/mmdetection/configs/sabl/sabl-retinanet_r101-gn_fpn_1x_coco.py b/mmdetection/configs/sabl/sabl-retinanet_r101-gn_fpn_1x_coco.py new file mode 100644 index 00000000..f181ad68 --- /dev/null +++ b/mmdetection/configs/sabl/sabl-retinanet_r101-gn_fpn_1x_coco.py @@ -0,0 +1,57 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +# model settings +norm_cfg = dict(type='GN', num_groups=32, requires_grad=True) +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101')), + bbox_head=dict( + _delete_=True, + type='SABLRetinaHead', + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + approx_anchor_generator=dict( + type='AnchorGenerator', + octave_base_scale=4, + scales_per_octave=3, + ratios=[0.5, 1.0, 2.0], + strides=[8, 16, 32, 64, 128]), + square_anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + scales=[4], + strides=[8, 16, 32, 64, 128]), + norm_cfg=norm_cfg, + bbox_coder=dict( + type='BucketingBBoxCoder', num_buckets=14, scale_factor=3.0), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.5), + loss_bbox_reg=dict( + type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=1.5)), + # training and testing settings + train_cfg=dict( + assigner=dict( + type='ApproxMaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.4, + min_pos_iou=0.0, + ignore_iof_thr=-1), + allowed_border=-1, + pos_weight=-1, + debug=False)) +# optimizer +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) diff --git a/mmdetection/configs/sabl/sabl-retinanet_r101-gn_fpn_ms-480-960-2x_coco.py b/mmdetection/configs/sabl/sabl-retinanet_r101-gn_fpn_ms-480-960-2x_coco.py new file mode 100644 index 00000000..dc7209ae --- /dev/null +++ b/mmdetection/configs/sabl/sabl-retinanet_r101-gn_fpn_ms-480-960-2x_coco.py @@ -0,0 +1,68 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_2x.py', '../_base_/default_runtime.py' +] +# model settings +norm_cfg = dict(type='GN', num_groups=32, requires_grad=True) +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101')), + bbox_head=dict( + _delete_=True, + type='SABLRetinaHead', + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + approx_anchor_generator=dict( + type='AnchorGenerator', + octave_base_scale=4, + scales_per_octave=3, + ratios=[0.5, 1.0, 2.0], + strides=[8, 16, 32, 64, 128]), + square_anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + scales=[4], + strides=[8, 16, 32, 64, 128]), + norm_cfg=norm_cfg, + bbox_coder=dict( + type='BucketingBBoxCoder', num_buckets=14, scale_factor=3.0), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.5), + loss_bbox_reg=dict( + type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=1.5)), + # training and testing settings + train_cfg=dict( + assigner=dict( + type='ApproxMaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.4, + min_pos_iou=0.0, + ignore_iof_thr=-1), + allowed_border=-1, + pos_weight=-1, + debug=False)) +# dataset settings +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomResize', scale=[(1333, 480), (1333, 960)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +# optimizer +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) diff --git a/mmdetection/configs/sabl/sabl-retinanet_r101-gn_fpn_ms-640-800-2x_coco.py b/mmdetection/configs/sabl/sabl-retinanet_r101-gn_fpn_ms-640-800-2x_coco.py new file mode 100644 index 00000000..ac5f6d98 --- /dev/null +++ b/mmdetection/configs/sabl/sabl-retinanet_r101-gn_fpn_ms-640-800-2x_coco.py @@ -0,0 +1,68 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_2x.py', '../_base_/default_runtime.py' +] +# model settings +norm_cfg = dict(type='GN', num_groups=32, requires_grad=True) +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101')), + bbox_head=dict( + _delete_=True, + type='SABLRetinaHead', + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + approx_anchor_generator=dict( + type='AnchorGenerator', + octave_base_scale=4, + scales_per_octave=3, + ratios=[0.5, 1.0, 2.0], + strides=[8, 16, 32, 64, 128]), + square_anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + scales=[4], + strides=[8, 16, 32, 64, 128]), + norm_cfg=norm_cfg, + bbox_coder=dict( + type='BucketingBBoxCoder', num_buckets=14, scale_factor=3.0), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.5), + loss_bbox_reg=dict( + type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=1.5)), + # training and testing settings + train_cfg=dict( + assigner=dict( + type='ApproxMaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.4, + min_pos_iou=0.0, + ignore_iof_thr=-1), + allowed_border=-1, + pos_weight=-1, + debug=False)) +# dataset settings +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomResize', scale=[(1333, 480), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +# optimizer +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) diff --git a/mmdetection/configs/sabl/sabl-retinanet_r101_fpn_1x_coco.py b/mmdetection/configs/sabl/sabl-retinanet_r101_fpn_1x_coco.py new file mode 100644 index 00000000..409695b5 --- /dev/null +++ b/mmdetection/configs/sabl/sabl-retinanet_r101_fpn_1x_coco.py @@ -0,0 +1,55 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +# model settings +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101')), + bbox_head=dict( + _delete_=True, + type='SABLRetinaHead', + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + approx_anchor_generator=dict( + type='AnchorGenerator', + octave_base_scale=4, + scales_per_octave=3, + ratios=[0.5, 1.0, 2.0], + strides=[8, 16, 32, 64, 128]), + square_anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + scales=[4], + strides=[8, 16, 32, 64, 128]), + bbox_coder=dict( + type='BucketingBBoxCoder', num_buckets=14, scale_factor=3.0), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.5), + loss_bbox_reg=dict( + type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=1.5)), + # training and testing settings + train_cfg=dict( + assigner=dict( + type='ApproxMaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.4, + min_pos_iou=0.0, + ignore_iof_thr=-1), + allowed_border=-1, + pos_weight=-1, + debug=False)) +# optimizer +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) diff --git a/mmdetection/configs/sabl/sabl-retinanet_r50-gn_fpn_1x_coco.py b/mmdetection/configs/sabl/sabl-retinanet_r50-gn_fpn_1x_coco.py new file mode 100644 index 00000000..4facdb6a --- /dev/null +++ b/mmdetection/configs/sabl/sabl-retinanet_r50-gn_fpn_1x_coco.py @@ -0,0 +1,53 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +# model settings +norm_cfg = dict(type='GN', num_groups=32, requires_grad=True) +model = dict( + bbox_head=dict( + _delete_=True, + type='SABLRetinaHead', + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + approx_anchor_generator=dict( + type='AnchorGenerator', + octave_base_scale=4, + scales_per_octave=3, + ratios=[0.5, 1.0, 2.0], + strides=[8, 16, 32, 64, 128]), + square_anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + scales=[4], + strides=[8, 16, 32, 64, 128]), + norm_cfg=norm_cfg, + bbox_coder=dict( + type='BucketingBBoxCoder', num_buckets=14, scale_factor=3.0), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.5), + loss_bbox_reg=dict( + type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=1.5)), + # training and testing settings + train_cfg=dict( + assigner=dict( + type='ApproxMaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.4, + min_pos_iou=0.0, + ignore_iof_thr=-1), + allowed_border=-1, + pos_weight=-1, + debug=False)) +# optimizer +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) diff --git a/mmdetection/configs/sabl/sabl-retinanet_r50_fpn_1x_coco.py b/mmdetection/configs/sabl/sabl-retinanet_r50_fpn_1x_coco.py new file mode 100644 index 00000000..9073d6f0 --- /dev/null +++ b/mmdetection/configs/sabl/sabl-retinanet_r50_fpn_1x_coco.py @@ -0,0 +1,51 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +# model settings +model = dict( + bbox_head=dict( + _delete_=True, + type='SABLRetinaHead', + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + approx_anchor_generator=dict( + type='AnchorGenerator', + octave_base_scale=4, + scales_per_octave=3, + ratios=[0.5, 1.0, 2.0], + strides=[8, 16, 32, 64, 128]), + square_anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + scales=[4], + strides=[8, 16, 32, 64, 128]), + bbox_coder=dict( + type='BucketingBBoxCoder', num_buckets=14, scale_factor=3.0), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.5), + loss_bbox_reg=dict( + type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=1.5)), + # training and testing settings + train_cfg=dict( + assigner=dict( + type='ApproxMaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.4, + min_pos_iou=0.0, + ignore_iof_thr=-1), + allowed_border=-1, + pos_weight=-1, + debug=False)) +# optimizer +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) diff --git a/mmdetection/configs/scnet/README.md b/mmdetection/configs/scnet/README.md new file mode 100644 index 00000000..08dbfa87 --- /dev/null +++ b/mmdetection/configs/scnet/README.md @@ -0,0 +1,63 @@ +# SCNet + +> [SCNet: Training Inference Sample Consistency for Instance Segmentation](https://arxiv.org/abs/2012.10150) + + + +## Abstract + + + +Cascaded architectures have brought significant performance improvement in object detection and instance segmentation. However, there are lingering issues regarding the disparity in the Intersection-over-Union (IoU) distribution of the samples between training and inference. This disparity can potentially exacerbate detection accuracy. This paper proposes an architecture referred to as Sample Consistency Network (SCNet) to ensure that the IoU distribution of the samples at training time is close to that at inference time. Furthermore, SCNet incorporates feature relay and utilizes global contextual information to further reinforce the reciprocal relationships among classifying, detecting, and segmenting sub-tasks. Extensive experiments on the standard COCO dataset reveal the effectiveness of the proposed method over multiple evaluation metrics, including box AP, mask AP, and inference speed. In particular, while running 38% faster, the proposed SCNet improves the AP of the box and mask predictions by respectively 1.3 and 2.3 points compared to the strong Cascade Mask R-CNN baseline. + +
    + +
    + +## Dataset + +SCNet requires COCO and [COCO-stuff](http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/stuffthingmaps_trainval2017.zip) dataset for training. You need to download and extract it in the COCO dataset path. +The directory should be like this. + +```none +mmdetection +├── mmdet +├── tools +├── configs +├── data +│ ├── coco +│ │ ├── annotations +│ │ ├── train2017 +│ │ ├── val2017 +│ │ ├── test2017 +| | ├── stuffthingmaps +``` + +## Results and Models + +The results on COCO 2017val are shown in the below table. (results on test-dev are usually slightly higher than val) + +| Backbone | Style | Lr schd | Mem (GB) | Inf speed (fps) | box AP | mask AP | TTA box AP | TTA mask AP | Config | Download | +| :-------------: | :-----: | :-----: | :------: | :-------------: | :----: | :-----: | :--------: | :---------: | :------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-FPN | pytorch | 1x | 7.0 | 6.2 | 43.5 | 39.2 | 44.8 | 40.9 | [config](./scnet_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/scnet/scnet_r50_fpn_1x_coco/scnet_r50_fpn_1x_coco-c3f09857.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/scnet/scnet_r50_fpn_1x_coco/scnet_r50_fpn_1x_coco_20210117_192725.log.json) | +| R-50-FPN | pytorch | 20e | 7.0 | 6.2 | 44.5 | 40.0 | 45.8 | 41.5 | [config](./scnet_r50_fpn_20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/scnet/scnet_r50_fpn_20e_coco/scnet_r50_fpn_20e_coco-a569f645.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/scnet/scnet_r50_fpn_20e_coco/scnet_r50_fpn_20e_coco_20210116_060148.log.json) | +| R-101-FPN | pytorch | 20e | 8.9 | 5.8 | 45.8 | 40.9 | 47.3 | 42.7 | [config](./scnet_r101_fpn_20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/scnet/scnet_r101_fpn_20e_coco/scnet_r101_fpn_20e_coco-294e312c.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/scnet/scnet_r101_fpn_20e_coco/scnet_r101_fpn_20e_coco_20210118_175824.log.json) | +| X-101-64x4d-FPN | pytorch | 20e | 13.2 | 4.9 | 47.5 | 42.3 | 48.9 | 44.0 | [config](./scnet_x101-64x4d_fpn_20e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/scnet/scnet_x101_64x4d_fpn_20e_coco/scnet_x101_64x4d_fpn_20e_coco-fb09dec9.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/scnet/scnet_x101_64x4d_fpn_20e_coco/scnet_x101_64x4d_fpn_20e_coco_20210120_045959.log.json) | + +### Notes + +- Training hyper-parameters are identical to those of [HTC](https://github.com/open-mmlab/mmdetection/tree/main/configs/htc). +- TTA means Test Time Augmentation, which applies horizontal flip and multi-scale testing. Refer to [config](./scnet_r50_fpn_1x_coco.py). + +## Citation + +We provide the code for reproducing experiment results of [SCNet](https://arxiv.org/abs/2012.10150). + +```latex +@inproceedings{vu2019cascade, + title={SCNet: Training Inference Sample Consistency for Instance Segmentation}, + author={Vu, Thang and Haeyong, Kang and Yoo, Chang D}, + booktitle={AAAI}, + year={2021} +} +``` diff --git a/mmdetection/configs/scnet/metafile.yml b/mmdetection/configs/scnet/metafile.yml new file mode 100644 index 00000000..936d3896 --- /dev/null +++ b/mmdetection/configs/scnet/metafile.yml @@ -0,0 +1,116 @@ +Collections: + - Name: SCNet + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - FPN + - ResNet + - SCNet + Paper: + URL: https://arxiv.org/abs/2012.10150 + Title: 'SCNet: Training Inference Sample Consistency for Instance Segmentation' + README: configs/scnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.9.0/mmdet/models/detectors/scnet.py#L6 + Version: v2.9.0 + +Models: + - Name: scnet_r50_fpn_1x_coco + In Collection: SCNet + Config: configs/scnet/scnet_r50_fpn_1x_coco.py + Metadata: + Training Memory (GB): 7.0 + inference time (ms/im): + - value: 161.29 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.5 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/scnet/scnet_r50_fpn_1x_coco/scnet_r50_fpn_1x_coco-c3f09857.pth + + - Name: scnet_r50_fpn_20e_coco + In Collection: SCNet + Config: configs/scnet/scnet_r50_fpn_20e_coco.py + Metadata: + Training Memory (GB): 7.0 + inference time (ms/im): + - value: 161.29 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 20 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.5 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 40.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/scnet/scnet_r50_fpn_20e_coco/scnet_r50_fpn_20e_coco-a569f645.pth + + - Name: scnet_r101_fpn_20e_coco + In Collection: SCNet + Config: configs/scnet/scnet_r101_fpn_20e_coco.py + Metadata: + Training Memory (GB): 8.9 + inference time (ms/im): + - value: 172.41 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 20 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 40.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/scnet/scnet_r101_fpn_20e_coco/scnet_r101_fpn_20e_coco-294e312c.pth + + - Name: scnet_x101-64x4d_fpn_20e_coco + In Collection: SCNet + Config: configs/scnet/scnet_x101-64x4d_fpn_20e_coco.py + Metadata: + Training Memory (GB): 13.2 + inference time (ms/im): + - value: 204.08 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (800, 1333) + Epochs: 20 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 47.5 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 42.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/scnet/scnet_x101_64x4d_fpn_20e_coco/scnet_x101_64x4d_fpn_20e_coco-fb09dec9.pth diff --git a/mmdetection/configs/scnet/scnet_r101_fpn_20e_coco.py b/mmdetection/configs/scnet/scnet_r101_fpn_20e_coco.py new file mode 100644 index 00000000..ebba5297 --- /dev/null +++ b/mmdetection/configs/scnet/scnet_r101_fpn_20e_coco.py @@ -0,0 +1,6 @@ +_base_ = './scnet_r50_fpn_20e_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/scnet/scnet_r50_fpn_1x_coco.py b/mmdetection/configs/scnet/scnet_r50_fpn_1x_coco.py new file mode 100644 index 00000000..a0210fdb --- /dev/null +++ b/mmdetection/configs/scnet/scnet_r50_fpn_1x_coco.py @@ -0,0 +1,138 @@ +_base_ = '../htc/htc_r50_fpn_1x_coco.py' +# model settings +model = dict( + type='SCNet', + roi_head=dict( + _delete_=True, + type='SCNetRoIHead', + num_stages=3, + stage_loss_weights=[1, 0.5, 0.25], + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + bbox_head=[ + dict( + type='SCNetBBoxHead', + num_shared_fcs=2, + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, + loss_weight=1.0)), + dict( + type='SCNetBBoxHead', + num_shared_fcs=2, + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.05, 0.05, 0.1, 0.1]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, + loss_weight=1.0)), + dict( + type='SCNetBBoxHead', + num_shared_fcs=2, + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=80, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.033, 0.033, 0.067, 0.067]), + reg_class_agnostic=True, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0)) + ], + mask_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + mask_head=dict( + type='SCNetMaskHead', + num_convs=12, + in_channels=256, + conv_out_channels=256, + num_classes=80, + conv_to_res=True, + loss_mask=dict( + type='CrossEntropyLoss', use_mask=True, loss_weight=1.0)), + semantic_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0), + out_channels=256, + featmap_strides=[8]), + semantic_head=dict( + type='SCNetSemanticHead', + num_ins=5, + fusion_level=1, + seg_scale_factor=1 / 8, + num_convs=4, + in_channels=256, + conv_out_channels=256, + num_classes=183, + loss_seg=dict( + type='CrossEntropyLoss', ignore_index=255, loss_weight=0.2), + conv_to_res=True), + glbctx_head=dict( + type='GlobalContextHead', + num_convs=4, + in_channels=256, + conv_out_channels=256, + num_classes=80, + loss_weight=3.0, + conv_to_res=True), + feat_relay_head=dict( + type='FeatureRelayHead', + in_channels=1024, + out_conv_channels=256, + roi_feat_size=7, + scale_factor=2))) + +# TODO +# uncomment below code to enable test time augmentations +# img_norm_cfg = dict( +# mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True) +# test_pipeline = [ +# dict(type='LoadImageFromFile'), +# dict( +# type='MultiScaleFlipAug', +# img_scale=[(600, 900), (800, 1200), (1000, 1500), (1200, 1800), +# (1400, 2100)], +# flip=True, +# transforms=[ +# dict(type='Resize', keep_ratio=True), +# dict(type='RandomFlip', flip_ratio=0.5), +# dict(type='Normalize', **img_norm_cfg), +# dict(type='Pad', size_divisor=32), +# dict(type='ImageToTensor', keys=['img']), +# dict(type='Collect', keys=['img']), +# ]) +# ] +# data = dict( +# val=dict(pipeline=test_pipeline), +# test=dict(pipeline=test_pipeline)) diff --git a/mmdetection/configs/scnet/scnet_r50_fpn_20e_coco.py b/mmdetection/configs/scnet/scnet_r50_fpn_20e_coco.py new file mode 100644 index 00000000..533e1b5f --- /dev/null +++ b/mmdetection/configs/scnet/scnet_r50_fpn_20e_coco.py @@ -0,0 +1,15 @@ +_base_ = './scnet_r50_fpn_1x_coco.py' +# learning policy +max_epochs = 20 +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 19], + gamma=0.1) +] +train_cfg = dict(max_epochs=max_epochs) diff --git a/mmdetection/configs/scnet/scnet_x101-64x4d_fpn_20e_coco.py b/mmdetection/configs/scnet/scnet_x101-64x4d_fpn_20e_coco.py new file mode 100644 index 00000000..1e54b030 --- /dev/null +++ b/mmdetection/configs/scnet/scnet_x101-64x4d_fpn_20e_coco.py @@ -0,0 +1,15 @@ +_base_ = './scnet_r50_fpn_20e_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/scnet/scnet_x101-64x4d_fpn_8xb1-20e_coco.py b/mmdetection/configs/scnet/scnet_x101-64x4d_fpn_8xb1-20e_coco.py new file mode 100644 index 00000000..3cdce7d5 --- /dev/null +++ b/mmdetection/configs/scnet/scnet_x101-64x4d_fpn_8xb1-20e_coco.py @@ -0,0 +1,8 @@ +_base_ = './scnet_x101-64x4d_fpn_20e_coco.py' +train_dataloader = dict(batch_size=1, num_workers=1) + +optim_wrapper = dict(optimizer=dict(lr=0.01)) +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (1 samples per GPU) +auto_scale_lr = dict(base_batch_size=8) diff --git a/mmdetection/configs/scratch/README.md b/mmdetection/configs/scratch/README.md new file mode 100644 index 00000000..7bdd8ff9 --- /dev/null +++ b/mmdetection/configs/scratch/README.md @@ -0,0 +1,35 @@ +# Scratch + +> [Rethinking ImageNet Pre-training](https://arxiv.org/abs/1811.08883) + + + +## Abstract + +We report competitive results on object detection and instance segmentation on the COCO dataset using standard models trained from random initialization. The results are no worse than their ImageNet pre-training counterparts even when using the hyper-parameters of the baseline system (Mask R-CNN) that were optimized for fine-tuning pre-trained models, with the sole exception of increasing the number of training iterations so the randomly initialized models may converge. Training from random initialization is surprisingly robust; our results hold even when: (i) using only 10% of the training data, (ii) for deeper and wider models, and (iii) for multiple tasks and metrics. Experiments show that ImageNet pre-training speeds up convergence early in training, but does not necessarily provide regularization or improve final target task accuracy. To push the envelope we demonstrate 50.9 AP on COCO object detection without using any external data---a result on par with the top COCO 2017 competition results that used ImageNet pre-training. These observations challenge the conventional wisdom of ImageNet pre-training for dependent tasks and we expect these discoveries will encourage people to rethink the current de facto paradigm of \`pre-training and fine-tuning' in computer vision. + +
    + +
    + +## Results and Models + +| Model | Backbone | Style | Lr schd | box AP | mask AP | Config | Download | +| :----------: | :------: | :-----: | :-----: | :----: | :-----: | :-------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| Faster R-CNN | R-50-FPN | pytorch | 6x | 40.7 | | [config](./faster-rcnn_r50-scratch_fpn_gn-all_6x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/scratch/faster_rcnn_r50_fpn_gn-all_scratch_6x_coco/scratch_faster_rcnn_r50_fpn_gn_6x_bbox_mAP-0.407_20200201_193013-90813d01.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/scratch/faster_rcnn_r50_fpn_gn-all_scratch_6x_coco/scratch_faster_rcnn_r50_fpn_gn_6x_20200201_193013.log.json) | +| Mask R-CNN | R-50-FPN | pytorch | 6x | 41.2 | 37.4 | [config](./mask-rcnn_r50-scratch_fpn_gn-all_6x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/scratch/mask_rcnn_r50_fpn_gn-all_scratch_6x_coco/scratch_mask_rcnn_r50_fpn_gn_6x_bbox_mAP-0.412__segm_mAP-0.374_20200201_193051-1e190a40.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/scratch/mask_rcnn_r50_fpn_gn-all_scratch_6x_coco/scratch_mask_rcnn_r50_fpn_gn_6x_20200201_193051.log.json) | + +Note: + +- The above models are trained with 16 GPUs. + +## Citation + +```latex +@article{he2018rethinking, + title={Rethinking imagenet pre-training}, + author={He, Kaiming and Girshick, Ross and Doll{\'a}r, Piotr}, + journal={arXiv preprint arXiv:1811.08883}, + year={2018} +} +``` diff --git a/mmdetection/configs/scratch/faster-rcnn_r50-scratch_fpn_gn-all_6x_coco.py b/mmdetection/configs/scratch/faster-rcnn_r50-scratch_fpn_gn-all_6x_coco.py new file mode 100644 index 00000000..6e632b9a --- /dev/null +++ b/mmdetection/configs/scratch/faster-rcnn_r50-scratch_fpn_gn-all_6x_coco.py @@ -0,0 +1,39 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +norm_cfg = dict(type='GN', num_groups=32, requires_grad=True) +model = dict( + backbone=dict( + frozen_stages=-1, + zero_init_residual=False, + norm_cfg=norm_cfg, + init_cfg=None), + neck=dict(norm_cfg=norm_cfg), + roi_head=dict( + bbox_head=dict( + type='Shared4Conv1FCBBoxHead', + conv_out_channels=256, + norm_cfg=norm_cfg))) + +optim_wrapper = dict(paramwise_cfg=dict(norm_decay_mult=0.)) + +max_epochs = 73 + +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[65, 71], + gamma=0.1) +] + +train_cfg = dict(max_epochs=max_epochs) + +# only keep latest 3 checkpoints +default_hooks = dict(checkpoint=dict(max_keep_ckpts=3)) diff --git a/mmdetection/configs/scratch/mask-rcnn_r50-scratch_fpn_gn-all_6x_coco.py b/mmdetection/configs/scratch/mask-rcnn_r50-scratch_fpn_gn-all_6x_coco.py new file mode 100644 index 00000000..9796f504 --- /dev/null +++ b/mmdetection/configs/scratch/mask-rcnn_r50-scratch_fpn_gn-all_6x_coco.py @@ -0,0 +1,40 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +norm_cfg = dict(type='GN', num_groups=32, requires_grad=True) +model = dict( + backbone=dict( + frozen_stages=-1, + zero_init_residual=False, + norm_cfg=norm_cfg, + init_cfg=None), + neck=dict(norm_cfg=norm_cfg), + roi_head=dict( + bbox_head=dict( + type='Shared4Conv1FCBBoxHead', + conv_out_channels=256, + norm_cfg=norm_cfg), + mask_head=dict(norm_cfg=norm_cfg))) + +optim_wrapper = dict(paramwise_cfg=dict(norm_decay_mult=0.)) + +max_epochs = 73 + +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[65, 71], + gamma=0.1) +] + +train_cfg = dict(max_epochs=max_epochs) + +# only keep latest 3 checkpoints +default_hooks = dict(checkpoint=dict(max_keep_ckpts=3)) diff --git a/mmdetection/configs/scratch/metafile.yml b/mmdetection/configs/scratch/metafile.yml new file mode 100644 index 00000000..977b8e5b --- /dev/null +++ b/mmdetection/configs/scratch/metafile.yml @@ -0,0 +1,48 @@ +Collections: + - Name: Rethinking ImageNet Pre-training + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - FPN + - RPN + - ResNet + Paper: + URL: https://arxiv.org/abs/1811.08883 + Title: 'Rethinking ImageNet Pre-training' + README: configs/scratch/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.0.0/configs/scratch/faster-rcnn_r50-scratch_fpn_gn-all_6x_coco.py + Version: v2.0.0 + +Models: + - Name: faster-rcnn_r50_fpn_gn-all_scratch_6x_coco + In Collection: Rethinking ImageNet Pre-training + Config: configs/scratch/faster-rcnn_r50-scratch_fpn_gn-all_6x_coco.py + Metadata: + Epochs: 72 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/scratch/faster_rcnn_r50_fpn_gn-all_scratch_6x_coco/scratch_faster_rcnn_r50_fpn_gn_6x_bbox_mAP-0.407_20200201_193013-90813d01.pth + + - Name: mask-rcnn_r50_fpn_gn-all_scratch_6x_coco + In Collection: Rethinking ImageNet Pre-training + Config: configs/scratch/mask-rcnn_r50-scratch_fpn_gn-all_6x_coco.py + Metadata: + Epochs: 72 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.2 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/scratch/mask_rcnn_r50_fpn_gn-all_scratch_6x_coco/scratch_mask_rcnn_r50_fpn_gn_6x_bbox_mAP-0.412__segm_mAP-0.374_20200201_193051-1e190a40.pth diff --git a/mmdetection/configs/seesaw_loss/README.md b/mmdetection/configs/seesaw_loss/README.md new file mode 100644 index 00000000..7077d753 --- /dev/null +++ b/mmdetection/configs/seesaw_loss/README.md @@ -0,0 +1,47 @@ +# Seesaw Loss + +> [Seesaw Loss for Long-Tailed Instance Segmentation](https://arxiv.org/abs/2008.10032) + + + +## Abstract + +Instance segmentation has witnessed a remarkable progress on class-balanced benchmarks. However, they fail to perform as accurately in real-world scenarios, where the category distribution of objects naturally comes with a long tail. Instances of head classes dominate a long-tailed dataset and they serve as negative samples of tail categories. The overwhelming gradients of negative samples on tail classes lead to a biased learning process for classifiers. Consequently, objects of tail categories are more likely to be misclassified as backgrounds or head categories. To tackle this problem, we propose Seesaw Loss to dynamically re-balance gradients of positive and negative samples for each category, with two complementary factors, i.e., mitigation factor and compensation factor. The mitigation factor reduces punishments to tail categories w.r.t. the ratio of cumulative training instances between different categories. Meanwhile, the compensation factor increases the penalty of misclassified instances to avoid false positives of tail categories. We conduct extensive experiments on Seesaw Loss with mainstream frameworks and different data sampling strategies. With a simple end-to-end training pipeline, Seesaw Loss obtains significant gains over Cross-Entropy Loss, and achieves state-of-the-art performance on LVIS dataset without bells and whistles. + +
    + +
    + +- Please setup [LVIS dataset](../lvis/README.md) for MMDetection. + +- RFS indicates to use oversample strategy [here](../../docs/tutorials/customipredataset.md#class-balanced-dataset) with oversample threshold `1e-3`. + +## Results and models of Seasaw Loss on LVIS v1 dataset + +| Method | Backbone | Style | Lr schd | Data Sampler | Norm Mask | box AP | mask AP | Config | Download | +| :----------------: | :-------: | :-----: | :-----: | :----------: | :-------: | :----: | :-----: | :----------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| Mask R-CNN | R-50-FPN | pytorch | 2x | random | N | 25.6 | 25.0 | [config](./mask-rcnn_r50_fpn_seesaw-loss_random-ms-2x_lvis-v1.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/mask_rcnn_r50_fpn_random_seesaw_loss_mstrain_2x_lvis_v1-a698dd3d.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/mask_rcnn_r50_fpn_random_seesaw_loss_mstrain_2x_lvis_v1.log.json) | +| Mask R-CNN | R-50-FPN | pytorch | 2x | random | Y | 25.6 | 25.4 | [config](./mask-rcnn_r50_fpn_seesaw-loss-normed-mask_random-ms-2x_lvis-v1.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/mask_rcnn_r50_fpn_random_seesaw_loss_normed_mask_mstrain_2x_lvis_v1-a1c11314.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/mask_rcnn_r50_fpn_random_seesaw_loss_normed_mask_mstrain_2x_lvis_v1.log.json) | +| Mask R-CNN | R-101-FPN | pytorch | 2x | random | N | 27.4 | 26.7 | [config](./mask-rcnn_r101_fpn_seesaw-loss_random-ms-2x_lvis-v1.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/mask_rcnn_r101_fpn_random_seesaw_loss_mstrain_2x_lvis_v1-8e6e6dd5.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/mask_rcnn_r101_fpn_random_seesaw_loss_mstrain_2x_lvis_v1.log.json) | +| Mask R-CNN | R-101-FPN | pytorch | 2x | random | Y | 27.2 | 27.3 | [config](./mask-rcnn_r101_fpn_seesaw-loss-normed-mask_random-ms-2x_lvis-v1.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/mask_rcnn_r101_fpn_random_seesaw_loss_normed_mask_mstrain_2x_lvis_v1-a0b59c42.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/mask_rcnn_r101_fpn_random_seesaw_loss_normed_mask_mstrain_2x_lvis_v1.log.json) | +| Mask R-CNN | R-50-FPN | pytorch | 2x | RFS | N | 27.6 | 26.4 | [config](./mask-rcnn_r50_fpn_seesaw-loss_sample1e-3-ms-2x_lvis-v1.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/mask_rcnn_r50_fpn_sample1e-3_seesaw_loss_mstrain_2x_lvis_v1-392a804b.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/mask_rcnn_r50_fpn_sample1e-3_seesaw_loss_mstrain_2x_lvis_v1.log.json) | +| Mask R-CNN | R-50-FPN | pytorch | 2x | RFS | Y | 27.6 | 26.8 | [config](./mask-rcnn_r50_fpn_seesaw-loss-normed-mask_sample1e-3-ms-2x_lvis-v1.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/mask_rcnn_r50_fpn_sample1e-3_seesaw_loss_normed_mask_mstrain_2x_lvis_v1-cd0f6a12.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/mask_rcnn_r50_fpn_sample1e-3_seesaw_loss_normed_mask_mstrain_2x_lvis_v1.log.json) | +| Mask R-CNN | R-101-FPN | pytorch | 2x | RFS | N | 28.9 | 27.6 | [config](./mask-rcnn_r101_fpn_seesaw-loss_sample1e-3-ms-2x_lvis-v1.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/mask_rcnn_r101_fpn_sample1e-3_seesaw_loss_mstrain_2x_lvis_v1-e68eb464.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/mask_rcnn_r101_fpn_sample1e-3_seesaw_loss_mstrain_2x_lvis_v1.log.json) | +| Mask R-CNN | R-101-FPN | pytorch | 2x | RFS | Y | 28.9 | 28.2 | [config](./mask-rcnn_r101_fpn_seesaw-loss-normed-mask_sample1e-3-ms-2x_lvis-v1.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/mask_rcnn_r101_fpn_sample1e-3_seesaw_loss_normed_mask_mstrain_2x_lvis_v1-1d817139.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/mask_rcnn_r101_fpn_sample1e-3_seesaw_loss_normed_mask_mstrain_2x_lvis_v1.log.json) | +| Cascade Mask R-CNN | R-101-FPN | pytorch | 2x | random | N | 33.1 | 29.2 | [config](./cascade-mask-rcnn_r101_fpn_seesaw-loss_random-ms-2x_lvis-v1.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/cascade_mask_rcnn_r101_fpn_random_seesaw_loss_mstrain_2x_lvis_v1-71e2215e.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/cascade_mask_rcnn_r101_fpn_random_seesaw_loss_mstrain_2x_lvis_v1.log.json) | +| Cascade Mask R-CNN | R-101-FPN | pytorch | 2x | random | Y | 33.0 | 30.0 | [config](./cascade-mask-rcnn_r101_fpn_seesaw-loss-normed-mask_random-ms-2x_lvis-v1.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/cascade_mask_rcnn_r101_fpn_random_seesaw_loss_normed_mask_mstrain_2x_lvis_v1-8b5a6745.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/cascade_mask_rcnn_r101_fpn_random_seesaw_loss_normed_mask_mstrain_2x_lvis_v1.log.json) | +| Cascade Mask R-CNN | R-101-FPN | pytorch | 2x | RFS | N | 30.0 | 29.3 | [config](./cascade-mask-rcnn_r101_fpn_seesaw-loss_sample1e-3-ms-2x_lvis-v1.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/cascade_mask_rcnn_r101_fpn_sample1e-3_seesaw_loss_mstrain_2x_lvis_v1-5d8ca2a4.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/cascade_mask_rcnn_r101_fpn_sample1e-3_seesaw_loss_mstrain_2x_lvis_v1.log.json) | +| Cascade Mask R-CNN | R-101-FPN | pytorch | 2x | RFS | Y | 32.8 | 30.1 | [config](./cascade-mask-rcnn_r101_fpn_seesaw-loss-normed-mask_sample1e-3-ms-2x_lvis-v1.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/cascade_mask_rcnn_r101_fpn_sample1e-3_seesaw_loss_normed_mask_mstrain_2x_lvis_v1-c8551505.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/cascade_mask_rcnn_r101_fpn_sample1e-3_seesaw_loss_normed_mask_mstrain_2x_lvis_v1.log.json) | + +## Citation + +We provide config files to reproduce the instance segmentation performance in the CVPR 2021 paper for [Seesaw Loss for Long-Tailed Instance Segmentation](https://arxiv.org/abs/2008.10032). + +```latex +@inproceedings{wang2021seesaw, + title={Seesaw Loss for Long-Tailed Instance Segmentation}, + author={Jiaqi Wang and Wenwei Zhang and Yuhang Zang and Yuhang Cao and Jiangmiao Pang and Tao Gong and Kai Chen and Ziwei Liu and Chen Change Loy and Dahua Lin}, + booktitle={Proceedings of the {IEEE} Conference on Computer Vision and Pattern Recognition}, + year={2021} +} +``` diff --git a/mmdetection/configs/seesaw_loss/cascade-mask-rcnn_r101_fpn_seesaw-loss-normed-mask_random-ms-2x_lvis-v1.py b/mmdetection/configs/seesaw_loss/cascade-mask-rcnn_r101_fpn_seesaw-loss-normed-mask_random-ms-2x_lvis-v1.py new file mode 100644 index 00000000..2de87dcc --- /dev/null +++ b/mmdetection/configs/seesaw_loss/cascade-mask-rcnn_r101_fpn_seesaw-loss-normed-mask_random-ms-2x_lvis-v1.py @@ -0,0 +1,5 @@ +_base_ = './cascade-mask-rcnn_r101_fpn_seesaw-loss_random-ms-2x_lvis-v1.py' # noqa: E501 +model = dict( + roi_head=dict( + mask_head=dict( + predictor_cfg=dict(type='NormedConv2d', tempearture=20)))) diff --git a/mmdetection/configs/seesaw_loss/cascade-mask-rcnn_r101_fpn_seesaw-loss-normed-mask_sample1e-3-ms-2x_lvis-v1.py b/mmdetection/configs/seesaw_loss/cascade-mask-rcnn_r101_fpn_seesaw-loss-normed-mask_sample1e-3-ms-2x_lvis-v1.py new file mode 100644 index 00000000..4d67ad7d --- /dev/null +++ b/mmdetection/configs/seesaw_loss/cascade-mask-rcnn_r101_fpn_seesaw-loss-normed-mask_sample1e-3-ms-2x_lvis-v1.py @@ -0,0 +1,5 @@ +_base_ = './cascade-mask-rcnn_r101_fpn_seesaw-loss_sample1e-3-ms-2x_lvis-v1.py' # noqa: E501 +model = dict( + roi_head=dict( + mask_head=dict( + predictor_cfg=dict(type='NormedConv2d', tempearture=20)))) diff --git a/mmdetection/configs/seesaw_loss/cascade-mask-rcnn_r101_fpn_seesaw-loss_random-ms-2x_lvis-v1.py b/mmdetection/configs/seesaw_loss/cascade-mask-rcnn_r101_fpn_seesaw-loss_random-ms-2x_lvis-v1.py new file mode 100644 index 00000000..2a1a87d4 --- /dev/null +++ b/mmdetection/configs/seesaw_loss/cascade-mask-rcnn_r101_fpn_seesaw-loss_random-ms-2x_lvis-v1.py @@ -0,0 +1,116 @@ +_base_ = [ + '../_base_/models/cascade-mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_2x.py', '../_base_/default_runtime.py' +] + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101')), + roi_head=dict( + bbox_head=[ + dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=1203, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=True, + cls_predictor_cfg=dict(type='NormedLinear', tempearture=20), + loss_cls=dict( + type='SeesawLoss', + p=0.8, + q=2.0, + num_classes=1203, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, + loss_weight=1.0)), + dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=1203, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.05, 0.05, 0.1, 0.1]), + reg_class_agnostic=True, + cls_predictor_cfg=dict(type='NormedLinear', tempearture=20), + loss_cls=dict( + type='SeesawLoss', + p=0.8, + q=2.0, + num_classes=1203, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, + loss_weight=1.0)), + dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=1203, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.033, 0.033, 0.067, 0.067]), + reg_class_agnostic=True, + cls_predictor_cfg=dict(type='NormedLinear', tempearture=20), + loss_cls=dict( + type='SeesawLoss', + p=0.8, + q=2.0, + num_classes=1203, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0)) + ], + mask_head=dict(num_classes=1203)), + test_cfg=dict( + rcnn=dict( + score_thr=0.0001, + # LVIS allows up to 300 + max_per_img=300))) + +# dataset settings +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736), + (1333, 768), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +dataset_type = 'LVISV1Dataset' +data_root = 'data/lvis_v1/' +train_dataloader = dict( + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/lvis_v1_train.json', + data_prefix=dict(img=''), + pipeline=train_pipeline)) +val_dataloader = dict( + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/lvis_v1_val.json', + data_prefix=dict(img=''))) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='LVISMetric', + ann_file=data_root + 'annotations/lvis_v1_val.json', + metric=['bbox', 'segm']) +test_evaluator = val_evaluator + +train_cfg = dict(val_interval=24) diff --git a/mmdetection/configs/seesaw_loss/cascade-mask-rcnn_r101_fpn_seesaw-loss_sample1e-3-ms-2x_lvis-v1.py b/mmdetection/configs/seesaw_loss/cascade-mask-rcnn_r101_fpn_seesaw-loss_sample1e-3-ms-2x_lvis-v1.py new file mode 100644 index 00000000..0e7b4df9 --- /dev/null +++ b/mmdetection/configs/seesaw_loss/cascade-mask-rcnn_r101_fpn_seesaw-loss_sample1e-3-ms-2x_lvis-v1.py @@ -0,0 +1,95 @@ +_base_ = [ + '../_base_/models/cascade-mask-rcnn_r50_fpn.py', + '../_base_/datasets/lvis_v1_instance.py', + '../_base_/schedules/schedule_2x.py', '../_base_/default_runtime.py' +] + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101')), + roi_head=dict( + bbox_head=[ + dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=1203, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=True, + cls_predictor_cfg=dict(type='NormedLinear', tempearture=20), + loss_cls=dict( + type='SeesawLoss', + p=0.8, + q=2.0, + num_classes=1203, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, + loss_weight=1.0)), + dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=1203, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.05, 0.05, 0.1, 0.1]), + reg_class_agnostic=True, + cls_predictor_cfg=dict(type='NormedLinear', tempearture=20), + loss_cls=dict( + type='SeesawLoss', + p=0.8, + q=2.0, + num_classes=1203, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, + loss_weight=1.0)), + dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=1203, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.033, 0.033, 0.067, 0.067]), + reg_class_agnostic=True, + cls_predictor_cfg=dict(type='NormedLinear', tempearture=20), + loss_cls=dict( + type='SeesawLoss', + p=0.8, + q=2.0, + num_classes=1203, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0)) + ], + mask_head=dict(num_classes=1203)), + test_cfg=dict( + rcnn=dict( + score_thr=0.0001, + # LVIS allows up to 300 + max_per_img=300))) + +# dataset settings +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736), + (1333, 768), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(dataset=dict(pipeline=train_pipeline))) + +train_cfg = dict(val_interval=24) diff --git a/mmdetection/configs/seesaw_loss/mask-rcnn_r101_fpn_seesaw-loss-normed-mask_random-ms-2x_lvis-v1.py b/mmdetection/configs/seesaw_loss/mask-rcnn_r101_fpn_seesaw-loss-normed-mask_random-ms-2x_lvis-v1.py new file mode 100644 index 00000000..b518c213 --- /dev/null +++ b/mmdetection/configs/seesaw_loss/mask-rcnn_r101_fpn_seesaw-loss-normed-mask_random-ms-2x_lvis-v1.py @@ -0,0 +1,6 @@ +_base_ = './mask-rcnn_r50_fpn_seesaw-loss-normed-mask_random-ms-2x_lvis-v1.py' # noqa: E501 +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/seesaw_loss/mask-rcnn_r101_fpn_seesaw-loss-normed-mask_sample1e-3-ms-2x_lvis-v1.py b/mmdetection/configs/seesaw_loss/mask-rcnn_r101_fpn_seesaw-loss-normed-mask_sample1e-3-ms-2x_lvis-v1.py new file mode 100644 index 00000000..008bbcae --- /dev/null +++ b/mmdetection/configs/seesaw_loss/mask-rcnn_r101_fpn_seesaw-loss-normed-mask_sample1e-3-ms-2x_lvis-v1.py @@ -0,0 +1,6 @@ +_base_ = './mask-rcnn_r50_fpn_seesaw-loss-normed-mask_sample1e-3-ms-2x_lvis-v1.py' # noqa: E501 +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/seesaw_loss/mask-rcnn_r101_fpn_seesaw-loss_random-ms-2x_lvis-v1.py b/mmdetection/configs/seesaw_loss/mask-rcnn_r101_fpn_seesaw-loss_random-ms-2x_lvis-v1.py new file mode 100644 index 00000000..8a0b6755 --- /dev/null +++ b/mmdetection/configs/seesaw_loss/mask-rcnn_r101_fpn_seesaw-loss_random-ms-2x_lvis-v1.py @@ -0,0 +1,6 @@ +_base_ = './mask-rcnn_r50_fpn_seesaw-loss_random-ms-2x_lvis-v1.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/seesaw_loss/mask-rcnn_r101_fpn_seesaw-loss_sample1e-3-ms-2x_lvis-v1.py b/mmdetection/configs/seesaw_loss/mask-rcnn_r101_fpn_seesaw-loss_sample1e-3-ms-2x_lvis-v1.py new file mode 100644 index 00000000..61432319 --- /dev/null +++ b/mmdetection/configs/seesaw_loss/mask-rcnn_r101_fpn_seesaw-loss_sample1e-3-ms-2x_lvis-v1.py @@ -0,0 +1,6 @@ +_base_ = './mask-rcnn_r50_fpn_seesaw-loss_sample1e-3-ms-2x_lvis-v1.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/seesaw_loss/mask-rcnn_r50_fpn_seesaw-loss-normed-mask_random-ms-2x_lvis-v1.py b/mmdetection/configs/seesaw_loss/mask-rcnn_r50_fpn_seesaw-loss-normed-mask_random-ms-2x_lvis-v1.py new file mode 100644 index 00000000..06d2438c --- /dev/null +++ b/mmdetection/configs/seesaw_loss/mask-rcnn_r50_fpn_seesaw-loss-normed-mask_random-ms-2x_lvis-v1.py @@ -0,0 +1,5 @@ +_base_ = './mask-rcnn_r50_fpn_seesaw-loss_random-ms-2x_lvis-v1.py' +model = dict( + roi_head=dict( + mask_head=dict( + predictor_cfg=dict(type='NormedConv2d', tempearture=20)))) diff --git a/mmdetection/configs/seesaw_loss/mask-rcnn_r50_fpn_seesaw-loss-normed-mask_sample1e-3-ms-2x_lvis-v1.py b/mmdetection/configs/seesaw_loss/mask-rcnn_r50_fpn_seesaw-loss-normed-mask_sample1e-3-ms-2x_lvis-v1.py new file mode 100644 index 00000000..5fc68d3d --- /dev/null +++ b/mmdetection/configs/seesaw_loss/mask-rcnn_r50_fpn_seesaw-loss-normed-mask_sample1e-3-ms-2x_lvis-v1.py @@ -0,0 +1,5 @@ +_base_ = './mask-rcnn_r50_fpn_seesaw-loss_sample1e-3-ms-2x_lvis-v1.py' +model = dict( + roi_head=dict( + mask_head=dict( + predictor_cfg=dict(type='NormedConv2d', tempearture=20)))) diff --git a/mmdetection/configs/seesaw_loss/mask-rcnn_r50_fpn_seesaw-loss_random-ms-2x_lvis-v1.py b/mmdetection/configs/seesaw_loss/mask-rcnn_r50_fpn_seesaw-loss_random-ms-2x_lvis-v1.py new file mode 100644 index 00000000..25c646c9 --- /dev/null +++ b/mmdetection/configs/seesaw_loss/mask-rcnn_r50_fpn_seesaw-loss_random-ms-2x_lvis-v1.py @@ -0,0 +1,59 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_2x.py', '../_base_/default_runtime.py' +] +model = dict( + roi_head=dict( + bbox_head=dict( + num_classes=1203, + cls_predictor_cfg=dict(type='NormedLinear', tempearture=20), + loss_cls=dict( + type='SeesawLoss', + p=0.8, + q=2.0, + num_classes=1203, + loss_weight=1.0)), + mask_head=dict(num_classes=1203)), + test_cfg=dict( + rcnn=dict( + score_thr=0.0001, + # LVIS allows up to 300 + max_per_img=300))) + +# dataset settings +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736), + (1333, 768), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +dataset_type = 'LVISV1Dataset' +data_root = 'data/lvis_v1/' +train_dataloader = dict( + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/lvis_v1_train.json', + data_prefix=dict(img=''), + pipeline=train_pipeline)) +val_dataloader = dict( + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/lvis_v1_val.json', + data_prefix=dict(img=''))) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='LVISMetric', + ann_file=data_root + 'annotations/lvis_v1_val.json', + metric=['bbox', 'segm']) +test_evaluator = val_evaluator + +train_cfg = dict(val_interval=24) diff --git a/mmdetection/configs/seesaw_loss/mask-rcnn_r50_fpn_seesaw-loss_sample1e-3-ms-2x_lvis-v1.py b/mmdetection/configs/seesaw_loss/mask-rcnn_r50_fpn_seesaw-loss_sample1e-3-ms-2x_lvis-v1.py new file mode 100644 index 00000000..d60320e0 --- /dev/null +++ b/mmdetection/configs/seesaw_loss/mask-rcnn_r50_fpn_seesaw-loss_sample1e-3-ms-2x_lvis-v1.py @@ -0,0 +1,38 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/lvis_v1_instance.py', + '../_base_/schedules/schedule_2x.py', '../_base_/default_runtime.py' +] +model = dict( + roi_head=dict( + bbox_head=dict( + num_classes=1203, + cls_predictor_cfg=dict(type='NormedLinear', tempearture=20), + loss_cls=dict( + type='SeesawLoss', + p=0.8, + q=2.0, + num_classes=1203, + loss_weight=1.0)), + mask_head=dict(num_classes=1203)), + test_cfg=dict( + rcnn=dict( + score_thr=0.0001, + # LVIS allows up to 300 + max_per_img=300))) + +# dataset settings +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736), + (1333, 768), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(dataset=dict(pipeline=train_pipeline))) + +train_cfg = dict(val_interval=24) diff --git a/mmdetection/configs/seesaw_loss/metafile.yml b/mmdetection/configs/seesaw_loss/metafile.yml new file mode 100644 index 00000000..374b9cde --- /dev/null +++ b/mmdetection/configs/seesaw_loss/metafile.yml @@ -0,0 +1,203 @@ +Collections: + - Name: Seesaw Loss + Metadata: + Training Data: LVIS + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - Softmax + - RPN + - Convolution + - Dense Connections + - FPN + - ResNet + - RoIAlign + - Seesaw Loss + Paper: + URL: https://arxiv.org/abs/2008.10032 + Title: 'Seesaw Loss for Long-Tailed Instance Segmentation' + README: configs/seesaw_loss/README.md + +Models: + - Name: mask-rcnn_r50_fpn_random_seesaw_loss_mstrain_2x_lvis_v1 + In Collection: Seesaw Loss + Config: configs/seesaw_loss/mask-rcnn_r50_fpn_seesaw-loss_random-ms-2x_lvis-v1.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: LVIS v1 + Metrics: + box AP: 25.6 + - Task: Instance Segmentation + Dataset: LVIS v1 + Metrics: + mask AP: 25.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/mask_rcnn_r50_fpn_random_seesaw_loss_mstrain_2x_lvis_v1-a698dd3d.pth + - Name: mask-rcnn_r50_fpn_random_seesaw_loss_normed_mask_mstrain_2x_lvis_v1 + In Collection: Seesaw Loss + Config: configs/seesaw_loss/mask-rcnn_r50_fpn_seesaw-loss-normed-mask_random-ms-2x_lvis-v1.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: LVIS v1 + Metrics: + box AP: 25.6 + - Task: Instance Segmentation + Dataset: LVIS v1 + Metrics: + mask AP: 25.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/mask_rcnn_r50_fpn_random_seesaw_loss_normed_mask_mstrain_2x_lvis_v1-a1c11314.pth + - Name: mask-rcnn_r101_fpn_seesaw-loss_random-ms-2x_lvis-v1 + In Collection: Seesaw Loss + Config: configs/seesaw_loss/mask-rcnn_r101_fpn_seesaw-loss_random-ms-2x_lvis-v1.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: LVIS v1 + Metrics: + box AP: 27.4 + - Task: Instance Segmentation + Dataset: LVIS v1 + Metrics: + mask AP: 26.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/mask_rcnn_r101_fpn_random_seesaw_loss_mstrain_2x_lvis_v1-8e6e6dd5.pth + - Name: mask-rcnn_r101_fpn_seesaw-loss-normed-mask_random-ms-2x_lvis-v1 + In Collection: Seesaw Loss + Config: configs/seesaw_loss/mask-rcnn_r101_fpn_seesaw-loss-normed-mask_random-ms-2x_lvis-v1.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: LVIS v1 + Metrics: + box AP: 27.2 + - Task: Instance Segmentation + Dataset: LVIS v1 + Metrics: + mask AP: 27.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/mask_rcnn_r101_fpn_random_seesaw_loss_normed_mask_mstrain_2x_lvis_v1-a0b59c42.pth + - Name: mask-rcnn_r50_fpn_sample1e-3_seesaw_loss_mstrain_2x_lvis_v1 + In Collection: Seesaw Loss + Config: configs/seesaw_loss/mask-rcnn_r50_fpn_seesaw-loss_sample1e-3-ms-2x_lvis-v1.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: LVIS v1 + Metrics: + box AP: 27.6 + - Task: Instance Segmentation + Dataset: LVIS v1 + Metrics: + mask AP: 26.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/mask_rcnn_r50_fpn_sample1e-3_seesaw_loss_mstrain_2x_lvis_v1-392a804b.pth + - Name: mask-rcnn_r50_fpn_sample1e-3_seesaw_loss_normed_mask_mstrain_2x_lvis_v1 + In Collection: Seesaw Loss + Config: configs/seesaw_loss/mask-rcnn_r50_fpn_seesaw-loss-normed-mask_sample1e-3-ms-2x_lvis-v1.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: LVIS v1 + Metrics: + box AP: 27.6 + - Task: Instance Segmentation + Dataset: LVIS v1 + Metrics: + mask AP: 26.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/mask_rcnn_r50_fpn_sample1e-3_seesaw_loss_normed_mask_mstrain_2x_lvis_v1-cd0f6a12.pth + - Name: mask-rcnn_r101_fpn_seesaw-loss_sample1e-3-ms-2x_lvis-v1 + In Collection: Seesaw Loss + Config: configs/seesaw_loss/mask-rcnn_r101_fpn_seesaw-loss_sample1e-3-ms-2x_lvis-v1.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: LVIS v1 + Metrics: + box AP: 28.9 + - Task: Instance Segmentation + Dataset: LVIS v1 + Metrics: + mask AP: 27.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/mask_rcnn_r101_fpn_sample1e-3_seesaw_loss_mstrain_2x_lvis_v1-e68eb464.pth + - Name: mask-rcnn_r101_fpn_seesaw-loss-normed-mask_sample1e-3-ms-2x_lvis-v1 + In Collection: Seesaw Loss + Config: configs/seesaw_loss/mask-rcnn_r101_fpn_seesaw-loss-normed-mask_sample1e-3-ms-2x_lvis-v1.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: LVIS v1 + Metrics: + box AP: 28.9 + - Task: Instance Segmentation + Dataset: LVIS v1 + Metrics: + mask AP: 28.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/mask_rcnn_r101_fpn_sample1e-3_seesaw_loss_normed_mask_mstrain_2x_lvis_v1-1d817139.pth + - Name: cascade-mask-rcnn_r101_fpn_seesaw-loss_random-ms-2x_lvis-v1 + In Collection: Seesaw Loss + Config: configs/seesaw_loss/cascade-mask-rcnn_r101_fpn_seesaw-loss_random-ms-2x_lvis-v1.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: LVIS v1 + Metrics: + box AP: 33.1 + - Task: Instance Segmentation + Dataset: LVIS v1 + Metrics: + mask AP: 29.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/cascade_mask_rcnn_r101_fpn_random_seesaw_loss_mstrain_2x_lvis_v1-71e2215e.pth + - Name: cascade-mask-rcnn_r101_fpn_seesaw-loss-normed-mask_random-ms-2x_lvis-v1 + In Collection: Seesaw Loss + Config: configs/seesaw_loss/cascade-mask-rcnn_r101_fpn_seesaw-loss-normed-mask_random-ms-2x_lvis-v1.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: LVIS v1 + Metrics: + box AP: 33.0 + - Task: Instance Segmentation + Dataset: LVIS v1 + Metrics: + mask AP: 30.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/cascade_mask_rcnn_r101_fpn_random_seesaw_loss_normed_mask_mstrain_2x_lvis_v1-8b5a6745.pth + - Name: cascade-mask-rcnn_r101_fpn_seesaw-loss_sample1e-3-ms-2x_lvis-v1 + In Collection: Seesaw Loss + Config: configs/seesaw_loss/cascade-mask-rcnn_r101_fpn_seesaw-loss_sample1e-3-ms-2x_lvis-v1.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: LVIS v1 + Metrics: + box AP: 30.0 + - Task: Instance Segmentation + Dataset: LVIS v1 + Metrics: + mask AP: 29.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/cascade_mask_rcnn_r101_fpn_sample1e-3_seesaw_loss_mstrain_2x_lvis_v1-5d8ca2a4.pth + - Name: cascade-mask-rcnn_r101_fpn_seesaw-loss-normed-mask_sample1e-3-ms-2x_lvis-v1 + In Collection: Seesaw Loss + Config: configs/seesaw_loss/cascade-mask-rcnn_r101_fpn_seesaw-loss-normed-mask_sample1e-3-ms-2x_lvis-v1.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: LVIS v1 + Metrics: + box AP: 32.8 + - Task: Instance Segmentation + Dataset: LVIS v1 + Metrics: + mask AP: 30.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/seesaw_loss/cascade_mask_rcnn_r101_fpn_sample1e-3_seesaw_loss_normed_mask_mstrain_2x_lvis_v1-c8551505.pth diff --git a/mmdetection/configs/selfsup_pretrain/README.md b/mmdetection/configs/selfsup_pretrain/README.md new file mode 100644 index 00000000..57537ddd --- /dev/null +++ b/mmdetection/configs/selfsup_pretrain/README.md @@ -0,0 +1,109 @@ +# Backbones Trained by Self-Supervise Algorithms + + + +## Abstract + +Unsupervised image representations have significantly reduced the gap with supervised pretraining, notably with the recent achievements of contrastive learning methods. These contrastive methods typically work online and rely on a large number of explicit pairwise feature comparisons, which is computationally challenging. In this paper, we propose an online algorithm, SwAV, that takes advantage of contrastive methods without requiring to compute pairwise comparisons. Specifically, our method simultaneously clusters the data while enforcing consistency between cluster assignments produced for different augmentations (or views) of the same image, instead of comparing features directly as in contrastive learning. Simply put, we use a swapped prediction mechanism where we predict the cluster assignment of a view from the representation of another view. Our method can be trained with large and small batches and can scale to unlimited amounts of data. Compared to previous contrastive methods, our method is more memory efficient since it does not require a large memory bank or a special momentum network. In addition, we also propose a new data augmentation strategy, multi-crop, that uses a mix of views with different resolutions in place of two full-resolution views, without increasing the memory or compute requirements much. We validate our findings by achieving 75.3% top-1 accuracy on ImageNet with ResNet-50, as well as surpassing supervised pretraining on all the considered transfer tasks. + +
    + +
    + +We present Momentum Contrast (MoCo) for unsupervised visual representation learning. From a perspective on contrastive learning as dictionary look-up, we build a dynamic dictionary with a queue and a moving-averaged encoder. This enables building a large and consistent dictionary on-the-fly that facilitates contrastive unsupervised learning. MoCo provides competitive results under the common linear protocol on ImageNet classification. More importantly, the representations learned by MoCo transfer well to downstream tasks. MoCo can outperform its supervised pre-training counterpart in 7 detection/segmentation tasks on PASCAL VOC, COCO, and other datasets, sometimes surpassing it by large margins. This suggests that the gap between unsupervised and supervised representation learning has been largely closed in many vision tasks. + +
    + +
    + +## Usage + +To use a self-supervisely pretrained backbone, there are two steps to do: + +1. Download and convert the model to PyTorch-style supported by MMDetection +2. Modify the config and change the training setting accordingly + +### Convert model + +For more general usage, we also provide script `selfsup2mmdet.py` in the tools directory to convert the key of models pretrained by different self-supervised methods to PyTorch-style checkpoints used in MMDetection. + +```bash +python -u tools/model_converters/selfsup2mmdet.py ${PRETRAIN_PATH} ${STORE_PATH} --selfsup ${method} +``` + +This script convert model from `PRETRAIN_PATH` and store the converted model in `STORE_PATH`. + +For example, to use a ResNet-50 backbone released by MoCo, you can download it from [here](https://dl.fbaipublicfiles.com/moco/moco_checkpoints/moco_v2_800ep/moco_v2_800ep_pretrain.pth.tar) and use the following command + +```bash +python -u tools/model_converters/selfsup2mmdet.py ./moco_v2_800ep_pretrain.pth.tar mocov2_r50_800ep_pretrain.pth --selfsup moco +``` + +To use the ResNet-50 backbone released by SwAV, you can download it from [here](https://dl.fbaipublicfiles.com/deepcluster/swav_800ep_pretrain.pth.tar) + +### Modify config + +The backbone requires SyncBN and the `frozen_stages` need to be changed. A config that use the moco backbone is as below + +```python +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +model = dict( + pretrained='./mocov2_r50_800ep_pretrain.pth', + backbone=dict( + frozen_stages=0, + norm_cfg=dict(type='SyncBN', requires_grad=True), + norm_eval=False)) + +``` + +## Results and Models + +| Method | Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :-------: | :------------------------------------------------------------: | :-----: | :------------: | :------: | :------------: | :----: | :-----: | :----------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| Mask RCNN | [R50 by MoCo v2](./mask-rcnn_r50-mocov2-pre_fpn_1x_coco.py) | pytorch | 1x | | | 38.0 | 34.3 | [config](./mask-rcnn_r50-mocov2-pre_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/selfsup_pretrain/mask_rcnn_r50_fpn_mocov2-pretrain_1x_coco/mask_rcnn_r50_fpn_mocov2-pretrain_1x_coco_20210604_114614-a8b63483.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/selfsup_pretrain/mask_rcnn_r50_fpn_mocov2-pretrain_1x_coco/mask_rcnn_r50_fpn_mocov2-pretrain_1x_coco_20210604_114614.log.json) | +| Mask RCNN | [R50 by MoCo v2](./mask-rcnn_r50-mocov2-pre_fpn_ms-2x_coco.py) | pytorch | multi-scale 2x | | | 40.8 | 36.8 | [config](./mask-rcnn_r50-mocov2-pre_fpn_ms-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/selfsup_pretrain/mask_rcnn_r50_fpn_mocov2-pretrain_ms-2x_coco/mask_rcnn_r50_fpn_mocov2-pretrain_ms-2x_coco_20210605_163717-d95df20a.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/selfsup_pretrain/mask_rcnn_r50_fpn_mocov2-pretrain_ms-2x_coco/mask_rcnn_r50_fpn_mocov2-pretrain_ms-2x_coco_20210605_163717.log.json) | +| Mask RCNN | [R50 by SwAV](./mask-rcnn_r50-swav-pre_fpn_1x_coco.py) | pytorch | 1x | | | 39.1 | 35.7 | [config](./mask-rcnn_r50-swav-pre_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/selfsup_pretrain/mask_rcnn_r50_fpn_swav-pretrain_1x_coco/mask_rcnn_r50_fpn_swav-pretrain_1x_coco_20210604_114640-7b9baf28.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/selfsup_pretrain/mask_rcnn_r50_fpn_swav-pretrain_1x_coco/mask_rcnn_r50_fpn_swav-pretrain_1x_coco_20210604_114640.log.json) | +| Mask RCNN | [R50 by SwAV](./mask-rcnn_r50-swav-pre_fpn_ms-2x_coco.py) | pytorch | multi-scale 2x | | | 41.3 | 37.3 | [config](./mask-rcnn_r50-swav-pre_fpn_ms-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/selfsup_pretrain/mask_rcnn_r50_fpn_swav-pretrain_ms-2x_coco/mask_rcnn_r50_fpn_swav-pretrain_ms-2x_coco_20210605_163717-08e26fca.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/selfsup_pretrain/mask_rcnn_r50_fpn_swav-pretrain_ms-2x_coco/mask_rcnn_r50_fpn_swav-pretrain_ms-2x_coco_20210605_163717.log.json) | + +### Notice + +1. We only provide single-scale 1x and multi-scale 2x configs as examples to show how to use backbones trained by self-supervised algorithms. We will try to reproduce the results in their corresponding paper using the released backbone in the future. Please stay tuned. + +## Citation + +We support to apply the backbone models pre-trained by different self-supervised methods in detection systems and provide their results on Mask R-CNN. + +The pre-trained models are converted from [MoCo](https://github.com/facebookresearch/moco) and downloaded from [SwAV](https://github.com/facebookresearch/swav). + +For SwAV, please cite + +```latex +@article{caron2020unsupervised, + title={Unsupervised Learning of Visual Features by Contrasting Cluster Assignments}, + author={Caron, Mathilde and Misra, Ishan and Mairal, Julien and Goyal, Priya and Bojanowski, Piotr and Joulin, Armand}, + booktitle={Proceedings of Advances in Neural Information Processing Systems (NeurIPS)}, + year={2020} +} +``` + +For MoCo, please cite + +```latex +@Article{he2019moco, + author = {Kaiming He and Haoqi Fan and Yuxin Wu and Saining Xie and Ross Girshick}, + title = {Momentum Contrast for Unsupervised Visual Representation Learning}, + journal = {arXiv preprint arXiv:1911.05722}, + year = {2019}, +} +@Article{chen2020mocov2, + author = {Xinlei Chen and Haoqi Fan and Ross Girshick and Kaiming He}, + title = {Improved Baselines with Momentum Contrastive Learning}, + journal = {arXiv preprint arXiv:2003.04297}, + year = {2020}, +} +``` diff --git a/mmdetection/configs/selfsup_pretrain/mask-rcnn_r50-mocov2-pre_fpn_1x_coco.py b/mmdetection/configs/selfsup_pretrain/mask-rcnn_r50-mocov2-pre_fpn_1x_coco.py new file mode 100644 index 00000000..91d45add --- /dev/null +++ b/mmdetection/configs/selfsup_pretrain/mask-rcnn_r50-mocov2-pre_fpn_1x_coco.py @@ -0,0 +1,13 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +model = dict( + backbone=dict( + frozen_stages=0, + norm_cfg=dict(type='SyncBN', requires_grad=True), + norm_eval=False, + init_cfg=dict( + type='Pretrained', checkpoint='./mocov2_r50_800ep_pretrain.pth'))) diff --git a/mmdetection/configs/selfsup_pretrain/mask-rcnn_r50-mocov2-pre_fpn_ms-2x_coco.py b/mmdetection/configs/selfsup_pretrain/mask-rcnn_r50-mocov2-pre_fpn_ms-2x_coco.py new file mode 100644 index 00000000..ddaebf55 --- /dev/null +++ b/mmdetection/configs/selfsup_pretrain/mask-rcnn_r50-mocov2-pre_fpn_ms-2x_coco.py @@ -0,0 +1,25 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_2x.py', '../_base_/default_runtime.py' +] + +model = dict( + backbone=dict( + frozen_stages=0, + norm_cfg=dict(type='SyncBN', requires_grad=True), + norm_eval=False, + init_cfg=dict( + type='Pretrained', checkpoint='./mocov2_r50_800ep_pretrain.pth'))) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='RandomResize', scale=[(1333, 640), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/mmdetection/configs/selfsup_pretrain/mask-rcnn_r50-swav-pre_fpn_1x_coco.py b/mmdetection/configs/selfsup_pretrain/mask-rcnn_r50-swav-pre_fpn_1x_coco.py new file mode 100644 index 00000000..785c80ec --- /dev/null +++ b/mmdetection/configs/selfsup_pretrain/mask-rcnn_r50-swav-pre_fpn_1x_coco.py @@ -0,0 +1,13 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +model = dict( + backbone=dict( + frozen_stages=0, + norm_cfg=dict(type='SyncBN', requires_grad=True), + norm_eval=False, + init_cfg=dict( + type='Pretrained', checkpoint='./swav_800ep_pretrain.pth.tar'))) diff --git a/mmdetection/configs/selfsup_pretrain/mask-rcnn_r50-swav-pre_fpn_ms-2x_coco.py b/mmdetection/configs/selfsup_pretrain/mask-rcnn_r50-swav-pre_fpn_ms-2x_coco.py new file mode 100644 index 00000000..c393e0b3 --- /dev/null +++ b/mmdetection/configs/selfsup_pretrain/mask-rcnn_r50-swav-pre_fpn_ms-2x_coco.py @@ -0,0 +1,25 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_2x.py', '../_base_/default_runtime.py' +] + +model = dict( + backbone=dict( + frozen_stages=0, + norm_cfg=dict(type='SyncBN', requires_grad=True), + norm_eval=False, + init_cfg=dict( + type='Pretrained', checkpoint='./swav_800ep_pretrain.pth.tar'))) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='RandomResize', scale=[(1333, 640), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/mmdetection/configs/simple_copy_paste/README.md b/mmdetection/configs/simple_copy_paste/README.md new file mode 100644 index 00000000..23b09ce5 --- /dev/null +++ b/mmdetection/configs/simple_copy_paste/README.md @@ -0,0 +1,38 @@ +# SimpleCopyPaste + +> [Simple Copy-Paste is a Strong Data Augmentation Method for Instance Segmentation](https://arxiv.org/abs/2012.07177) + + + +## Abstract + +Building instance segmentation models that are data-efficient and can handle rare object categories is an important challenge in computer vision. Leveraging data augmentations is a promising direction towards addressing this challenge. Here, we perform a systematic study of the Copy-Paste augmentation (\[13, 12\]) for instance segmentation where we randomly paste objects onto an image. Prior studies on Copy-Paste relied on modeling the surrounding visual context for pasting the objects. However, we find that the simple mechanism of pasting objects randomly is good enough and can provide solid gains on top of strong baselines. Furthermore, we show Copy-Paste is additive with semi-supervised methods that leverage extra data through pseudo labeling (e.g. self-training). On COCO instance segmentation, we achieve 49.1 mask AP and 57.3 box AP, an improvement of +0.6 mask AP and +1.5 box AP over the previous state-of-the-art. We further demonstrate that Copy-Paste can lead to significant improvements on the LVIS benchmark. Our baseline model outperforms the LVIS 2020 Challenge winning entry by +3.6 mask AP on rare categories. + +
    + +
    + +## Results and Models + +### Mask R-CNN with Standard Scale Jittering (SSJ) and Simple Copy-Paste(SCP) + +Standard Scale Jittering(SSJ) resizes and crops an image with a resize range of 0.8 to 1.25 of the original image size, and Simple Copy-Paste(SCP) selects a random subset of objects from one of the images and pastes them onto the other image. + +| Backbone | Training schedule | Augmentation | batch size | box AP | mask AP | Config | Download | +| :------: | :---------------: | :----------: | :--------: | :----: | :-----: | :------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | 90k | SSJ | 64 | 43.3 | 39.0 | [config](./mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_32xb2-ssj-90k_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/simple_copy_paste/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_32x2_90k_coco/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_32x2_90k_coco_20220316_181409-f79c84c5.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/simple_copy_paste/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_32x2_90k_coco/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_32x2_90k_coco_20220316_181409.log.json) | +| R-50 | 90k | SSJ+SCP | 64 | 43.8 | 39.2 | [config](./mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_32xb2-ssj-scp-90k_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/simple_copy_paste/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_scp_32x2_90k_coco/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_scp_32x2_90k_coco_20220316_181307-6bc5726f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/simple_copy_paste/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_scp_32x2_90k_coco/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_scp_32x2_90k_coco_20220316_181307.log.json) | +| R-50 | 270k | SSJ | 64 | 43.5 | 39.1 | [config](./mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_32xb2-ssj-270k_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/simple_copy_paste/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_32x2_270k_coco/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_32x2_270k_coco_20220324_182940-33a100c5.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/simple_copy_paste/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_32x2_270k_coco/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_32x2_270k_coco_20220324_182940.log.json) | +| R-50 | 270k | SSJ+SCP | 64 | 45.1 | 40.3 | [config](./mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_32xb2-ssj-scp-270k_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/simple_copy_paste/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_scp_32x2_270k_coco/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_scp_32x2_270k_coco_20220324_201229-80ee90b7.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/simple_copy_paste/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_scp_32x2_270k_coco/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_scp_32x2_270k_coco_20220324_201229.log.json) | + +## Citation + +```latex +@inproceedings{ghiasi2021simple, + title={Simple copy-paste is a strong data augmentation method for instance segmentation}, + author={Ghiasi, Golnaz and Cui, Yin and Srinivas, Aravind and Qian, Rui and Lin, Tsung-Yi and Cubuk, Ekin D and Le, Quoc V and Zoph, Barret}, + booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition}, + pages={2918--2928}, + year={2021} +} +``` diff --git a/mmdetection/configs/simple_copy_paste/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_32xb2-ssj-270k_coco.py b/mmdetection/configs/simple_copy_paste/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_32xb2-ssj-270k_coco.py new file mode 100644 index 00000000..0c6e081e --- /dev/null +++ b/mmdetection/configs/simple_copy_paste/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_32xb2-ssj-270k_coco.py @@ -0,0 +1,31 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + # 270k iterations with batch_size 64 is roughly equivalent to 144 epochs + '../common/ssj_270k_coco-instance.py', +] + +image_size = (1024, 1024) +batch_augments = [ + dict(type='BatchFixedSizePad', size=image_size, pad_mask=True) +] +norm_cfg = dict(type='SyncBN', requires_grad=True) +# Use MMSyncBN that handles empty tensor in head. It can be changed to +# SyncBN after https://github.com/pytorch/pytorch/issues/36530 is fixed +head_norm_cfg = dict(type='MMSyncBN', requires_grad=True) +model = dict( + # the model is trained from scratch, so init_cfg is None + data_preprocessor=dict( + # pad_size_divisor=32 is unnecessary in training but necessary + # in testing. + pad_size_divisor=32, + batch_augments=batch_augments), + backbone=dict( + frozen_stages=-1, norm_eval=False, norm_cfg=norm_cfg, init_cfg=None), + neck=dict(norm_cfg=norm_cfg), + rpn_head=dict(num_convs=2), # leads to 0.1+ mAP + roi_head=dict( + bbox_head=dict( + type='Shared4Conv1FCBBoxHead', + conv_out_channels=256, + norm_cfg=head_norm_cfg), + mask_head=dict(norm_cfg=head_norm_cfg))) diff --git a/mmdetection/configs/simple_copy_paste/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_32xb2-ssj-90k_coco.py b/mmdetection/configs/simple_copy_paste/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_32xb2-ssj-90k_coco.py new file mode 100644 index 00000000..abe8962a --- /dev/null +++ b/mmdetection/configs/simple_copy_paste/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_32xb2-ssj-90k_coco.py @@ -0,0 +1,18 @@ +_base_ = 'mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_32xb2-ssj-270k_coco.py' # noqa + +# training schedule for 90k +max_iters = 90000 + +# learning rate policy +# lr steps at [0.9, 0.95, 0.975] of the maximum iterations +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.067, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=90000, + by_epoch=False, + milestones=[81000, 85500, 87750], + gamma=0.1) +] diff --git a/mmdetection/configs/simple_copy_paste/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_32xb2-ssj-scp-270k_coco.py b/mmdetection/configs/simple_copy_paste/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_32xb2-ssj-scp-270k_coco.py new file mode 100644 index 00000000..f0ea57d1 --- /dev/null +++ b/mmdetection/configs/simple_copy_paste/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_32xb2-ssj-scp-270k_coco.py @@ -0,0 +1,31 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + # 270k iterations with batch_size 64 is roughly equivalent to 144 epochs + '../common/ssj_scp_270k_coco-instance.py' +] + +image_size = (1024, 1024) +batch_augments = [ + dict(type='BatchFixedSizePad', size=image_size, pad_mask=True) +] +norm_cfg = dict(type='SyncBN', requires_grad=True) +# Use MMSyncBN that handles empty tensor in head. It can be changed to +# SyncBN after https://github.com/pytorch/pytorch/issues/36530 is fixed +head_norm_cfg = dict(type='MMSyncBN', requires_grad=True) +model = dict( + # the model is trained from scratch, so init_cfg is None + data_preprocessor=dict( + # pad_size_divisor=32 is unnecessary in training but necessary + # in testing. + pad_size_divisor=32, + batch_augments=batch_augments), + backbone=dict( + frozen_stages=-1, norm_eval=False, norm_cfg=norm_cfg, init_cfg=None), + neck=dict(norm_cfg=norm_cfg), + rpn_head=dict(num_convs=2), # leads to 0.1+ mAP + roi_head=dict( + bbox_head=dict( + type='Shared4Conv1FCBBoxHead', + conv_out_channels=256, + norm_cfg=head_norm_cfg), + mask_head=dict(norm_cfg=head_norm_cfg))) diff --git a/mmdetection/configs/simple_copy_paste/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_32xb2-ssj-scp-90k_coco.py b/mmdetection/configs/simple_copy_paste/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_32xb2-ssj-scp-90k_coco.py new file mode 100644 index 00000000..e158b5c0 --- /dev/null +++ b/mmdetection/configs/simple_copy_paste/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_32xb2-ssj-scp-90k_coco.py @@ -0,0 +1,18 @@ +_base_ = 'mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_32xb2-ssj-scp-270k_coco.py' # noqa + +# training schedule for 90k +max_iters = 90000 + +# learning rate policy +# lr steps at [0.9, 0.95, 0.975] of the maximum iterations +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.067, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=90000, + by_epoch=False, + milestones=[81000, 85500, 87750], + gamma=0.1) +] diff --git a/mmdetection/configs/simple_copy_paste/metafile.yml b/mmdetection/configs/simple_copy_paste/metafile.yml new file mode 100644 index 00000000..8a40b658 --- /dev/null +++ b/mmdetection/configs/simple_copy_paste/metafile.yml @@ -0,0 +1,92 @@ +Collections: + - Name: SimpleCopyPaste + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 32x A100 GPUs + Architecture: + - Softmax + - RPN + - Convolution + - Dense Connections + - FPN + - ResNet + - RoIAlign + Paper: + URL: https://arxiv.org/abs/2012.07177 + Title: "Simple Copy-Paste is a Strong Data Augmentation Method for Instance Segmentation" + README: configs/simple_copy_paste/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.25.0/mmdet/datasets/pipelines/transforms.py#L2762 + Version: v2.25.0 + +Models: + - Name: mask-rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_32x2_270k_coco + In Collection: SimpleCopyPaste + Config: configs/simple_copy_paste/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_32xb2-ssj-270k_coco.py + Metadata: + Training Memory (GB): 7.2 + Iterations: 270000 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.5 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/simple_copy_paste/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_32x2_270k_coco/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_32x2_270k_coco_20220324_182940-33a100c5.pth + + - Name: mask-rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_32x2_90k_coco + In Collection: SimpleCopyPaste + Config: configs/simple_copy_paste/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_32xb2-ssj-90k_coco.py + Metadata: + Training Memory (GB): 7.2 + Iterations: 90000 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.3 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/simple_copy_paste/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_32x2_90k_coco/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_32x2_90k_coco_20220316_181409-f79c84c5.pth + + - Name: mask-rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_scp_32x2_270k_coco + In Collection: SimpleCopyPaste + Config: configs/simple_copy_paste/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_32xb2-ssj-scp-270k_coco.py + Metadata: + Training Memory (GB): 7.2 + Iterations: 270000 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.1 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 40.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/simple_copy_paste/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_scp_32x2_270k_coco/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_scp_32x2_270k_coco_20220324_201229-80ee90b7.pth + + - Name: mask-rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_scp_32x2_90k_coco + In Collection: SimpleCopyPaste + Config: configs/simple_copy_paste/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_32xb2-ssj-scp-90k_coco.py + Metadata: + Training Memory (GB): 7.2 + Iterations: 90000 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.8 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/simple_copy_paste/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_scp_32x2_90k_coco/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_scp_32x2_90k_coco_20220316_181307-6bc5726f.pth diff --git a/mmdetection/configs/soft_teacher/README.md b/mmdetection/configs/soft_teacher/README.md new file mode 100644 index 00000000..1fd3d84d --- /dev/null +++ b/mmdetection/configs/soft_teacher/README.md @@ -0,0 +1,33 @@ +# SoftTeacher + +> [End-to-End Semi-Supervised Object Detection with Soft Teacher](https://arxiv.org/abs/2106.09018) + + + +## Abstract + +This paper presents an end-to-end semi-supervised object detection approach, in contrast to previous more complex multi-stage methods. The end-to-end training gradually improves pseudo label qualities during the curriculum, and the more and more accurate pseudo labels in turn benefit object detection training. We also propose two simple yet effective techniques within this framework: a soft teacher mechanism where the classification loss of each unlabeled bounding box is weighed by the classification score produced by the teacher network; a box jittering approach to select reliable pseudo boxes for the learning of box regression. On the COCO benchmark, the proposed approach outperforms previous methods by a large margin under various labeling ratios, i.e. 1%, 5% and 10%. Moreover, our approach proves to perform also well when the amount of labeled data is relatively large. For example, it can improve a 40.9 mAP baseline detector trained using the full COCO training set by +3.6 mAP, reaching 44.5 mAP, by leveraging the 123K unlabeled images of COCO. On the state-of-the-art Swin Transformer based object detector (58.9 mAP on test-dev), it can still significantly improve the detection accuracy by +1.5 mAP, reaching 60.4 mAP, and improve the instance segmentation accuracy by +1.2 mAP, reaching 52.4 mAP. Further incorporating with the Object365 pre-trained model, the detection accuracy reaches 61.3 mAP and the instance segmentation accuracy reaches 53.0 mAP, pushing the new state-of-the-art. + +
    + +
    + +## Results and Models + +| Model | Detector | Labeled Dataset | Iteration | box AP | Config | Download | +| :---------: | :----------: | :-------------: | :-------: | :----: | :-----------------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| SoftTeacher | Faster R-CNN | COCO-1% | 180k | 19.9 | [config](./soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.01-coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.01-coco/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0_20230330_233412-3c8f6d4a.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.01-coco/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0_20230330_233412.log.json) | +| SoftTeacher | Faster R-CNN | COCO-2% | 180k | 24.9 | [config](./soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.02-coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.02-coco/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0_20230331_020244-c0d2c3aa.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.02-coco/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0_20230331_020244.log.json) | +| SoftTeacher | Faster R-CNN | COCO-5% | 180k | 30.4 | [config](./soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.05-coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.05-coco/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0_20230331_070656-308798ad.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.05-coco/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0_20230331_070656.log.json) | +| SoftTeacher | Faster R-CNN | COCO-10% | 180k | 33.8 | [config](./soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.1-coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.1-coco/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0_20230330_232113-b46f78d0.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.1-coco/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0_20230330_232113.log.json) | + +## Citation + +```latex +@article{xu2021end, + title={End-to-End Semi-Supervised Object Detection with Soft Teacher}, + author={Xu, Mengde and Zhang, Zheng and Hu, Han and Wang, Jianfeng and Wang, Lijuan and Wei, Fangyun and Bai, Xiang and Liu, Zicheng}, + journal={Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV)}, + year={2021} +} +``` diff --git a/mmdetection/configs/soft_teacher/metafile.yml b/mmdetection/configs/soft_teacher/metafile.yml new file mode 100644 index 00000000..9622acec --- /dev/null +++ b/mmdetection/configs/soft_teacher/metafile.yml @@ -0,0 +1,67 @@ +Collections: + - Name: SoftTeacher + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x A100 GPUs + Architecture: + - FPN + - ResNet + Paper: + URL: https://arxiv.org/abs/2106.09018 + Title: "End-to-End Semi-Supervised Object Detection with Soft Teacher" + README: configs/soft_teacher/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v3.0.0rc1/mmdet/models/detectors/soft_teacher.py#L20 + Version: v3.0.0rc1 + +Models: + - Name: soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.01-coco.py + In Collection: SoftTeacher + Config: configs/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.01-coco.py + Metadata: + Iterations: 180000 + Results: + - Task: Semi-Supervised Object Detection + Dataset: COCO + Metrics: + box AP: 19.9 + Weights: https://download.openmmlab.com/mmdetection/v3.0/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.01-coco/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0_20230330_233412-3c8f6d4a.pth + + - Name: soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.02-coco.py + In Collection: SoftTeacher + Config: configs/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.02-coco.py + Metadata: + Iterations: 180000 + Results: + - Task: Semi-Supervised Object Detection + Dataset: COCO + Metrics: + box AP: 24.9 + Weights: https://download.openmmlab.com/mmdetection/v3.0/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.02-coco/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0_20230331_020244-c0d2c3aa.pth + + - Name: soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.05-coco.py + In Collection: SoftTeacher + Config: configs/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.05-coco.py + Metadata: + Iterations: 180000 + Results: + - Task: Semi-Supervised Object Detection + Dataset: COCO + Metrics: + box AP: 30.4 + Weights: https://download.openmmlab.com/mmdetection/v3.0/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.05-coco/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0_20230331_070656-308798ad.pth + + - Name: soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.1-coco.py + In Collection: SoftTeacher + Config: configs/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.1-coco.py + Metadata: + Iterations: 180000 + Results: + - Task: Semi-Supervised Object Detection + Dataset: COCO + Metrics: + box AP: 33.8 + Weights: https://download.openmmlab.com/mmdetection/v3.0/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.1-coco/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0_20230330_232113-b46f78d0.pth diff --git a/mmdetection/configs/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.01-coco.py b/mmdetection/configs/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.01-coco.py new file mode 100644 index 00000000..2bd09645 --- /dev/null +++ b/mmdetection/configs/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.01-coco.py @@ -0,0 +1,9 @@ +_base_ = ['soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.1-coco.py'] + +# 1% coco train2017 is set as labeled dataset +labeled_dataset = _base_.labeled_dataset +unlabeled_dataset = _base_.unlabeled_dataset +labeled_dataset.ann_file = 'semi_anns/instances_train2017.1@1.json' +unlabeled_dataset.ann_file = 'semi_anns/instances_train2017.1@1-unlabeled.json' +train_dataloader = dict( + dataset=dict(datasets=[labeled_dataset, unlabeled_dataset])) diff --git a/mmdetection/configs/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.02-coco.py b/mmdetection/configs/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.02-coco.py new file mode 100644 index 00000000..8ca38c93 --- /dev/null +++ b/mmdetection/configs/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.02-coco.py @@ -0,0 +1,9 @@ +_base_ = ['soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.1-coco.py'] + +# 2% coco train2017 is set as labeled dataset +labeled_dataset = _base_.labeled_dataset +unlabeled_dataset = _base_.unlabeled_dataset +labeled_dataset.ann_file = 'semi_anns/instances_train2017.1@2.json' +unlabeled_dataset.ann_file = 'semi_anns/instances_train2017.1@2-unlabeled.json' +train_dataloader = dict( + dataset=dict(datasets=[labeled_dataset, unlabeled_dataset])) diff --git a/mmdetection/configs/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.05-coco.py b/mmdetection/configs/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.05-coco.py new file mode 100644 index 00000000..750b7ed6 --- /dev/null +++ b/mmdetection/configs/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.05-coco.py @@ -0,0 +1,9 @@ +_base_ = ['soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.1-coco.py'] + +# 5% coco train2017 is set as labeled dataset +labeled_dataset = _base_.labeled_dataset +unlabeled_dataset = _base_.unlabeled_dataset +labeled_dataset.ann_file = 'semi_anns/instances_train2017.1@5.json' +unlabeled_dataset.ann_file = 'semi_anns/instances_train2017.1@5-unlabeled.json' +train_dataloader = dict( + dataset=dict(datasets=[labeled_dataset, unlabeled_dataset])) diff --git a/mmdetection/configs/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.1-coco.py b/mmdetection/configs/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.1-coco.py new file mode 100644 index 00000000..3713aef4 --- /dev/null +++ b/mmdetection/configs/soft_teacher/soft-teacher_faster-rcnn_r50-caffe_fpn_180k_semi-0.1-coco.py @@ -0,0 +1,84 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', '../_base_/default_runtime.py', + '../_base_/datasets/semi_coco_detection.py' +] + +detector = _base_.model +detector.data_preprocessor = dict( + type='DetDataPreprocessor', + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False, + pad_size_divisor=32) +detector.backbone = dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=False), + norm_eval=True, + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe')) + +model = dict( + _delete_=True, + type='SoftTeacher', + detector=detector, + data_preprocessor=dict( + type='MultiBranchDataPreprocessor', + data_preprocessor=detector.data_preprocessor), + semi_train_cfg=dict( + freeze_teacher=True, + sup_weight=1.0, + unsup_weight=4.0, + pseudo_label_initial_score_thr=0.5, + rpn_pseudo_thr=0.9, + cls_pseudo_thr=0.9, + reg_pseudo_thr=0.02, + jitter_times=10, + jitter_scale=0.06, + min_pseudo_bbox_wh=(1e-2, 1e-2)), + semi_test_cfg=dict(predict_on='teacher')) + +# 10% coco train2017 is set as labeled dataset +labeled_dataset = _base_.labeled_dataset +unlabeled_dataset = _base_.unlabeled_dataset +labeled_dataset.ann_file = 'semi_anns/instances_train2017.1@10.json' +unlabeled_dataset.ann_file = 'semi_anns/' \ + 'instances_train2017.1@10-unlabeled.json' +unlabeled_dataset.data_prefix = dict(img='train2017/') +train_dataloader = dict( + dataset=dict(datasets=[labeled_dataset, unlabeled_dataset])) + +# training schedule for 180k +train_cfg = dict( + type='IterBasedTrainLoop', max_iters=180000, val_interval=5000) +val_cfg = dict(type='TeacherStudentValLoop') +test_cfg = dict(type='TestLoop') + +# learning rate policy +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=180000, + by_epoch=False, + milestones=[120000, 160000], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) + +default_hooks = dict( + checkpoint=dict(by_epoch=False, interval=10000, max_keep_ckpts=2)) +log_processor = dict(by_epoch=False) + +custom_hooks = [dict(type='MeanTeacherHook')] diff --git a/mmdetection/configs/solo/README.md b/mmdetection/configs/solo/README.md new file mode 100644 index 00000000..4a36676b --- /dev/null +++ b/mmdetection/configs/solo/README.md @@ -0,0 +1,54 @@ +# SOLO + +> [SOLO: Segmenting Objects by Locations](https://arxiv.org/abs/1912.04488) + + + +## Abstract + +We present a new, embarrassingly simple approach to instance segmentation in images. Compared to many other dense prediction tasks, e.g., semantic segmentation, it is the arbitrary number of instances that have made instance segmentation much more challenging. In order to predict a mask for each instance, mainstream approaches either follow the 'detect-thensegment' strategy as used by Mask R-CNN, or predict category masks first then use clustering techniques to group pixels into individual instances. We view the task of instance segmentation from a completely new perspective by introducing the notion of "instance categories", which assigns categories to each pixel within an instance according to the instance's location and size, thus nicely converting instance mask segmentation into a classification-solvable problem. Now instance segmentation is decomposed into two classification tasks. We demonstrate a much simpler and flexible instance segmentation framework with strong performance, achieving on par accuracy with Mask R-CNN and outperforming recent singleshot instance segmenters in accuracy. We hope that this very simple and strong framework can serve as a baseline for many instance-level recognition tasks besides instance segmentation. + +
    + +
    + +## Results and Models + +### SOLO + +| Backbone | Style | MS train | Lr schd | Mem (GB) | Inf time (fps) | mask AP | Download | +| :------: | :-----: | :------: | :-----: | :------: | :------------: | :-----: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | pytorch | N | 1x | 8.0 | 14.0 | 33.1 | [model](https://download.openmmlab.com/mmdetection/v2.0/solo/solo_r50_fpn_1x_coco/solo_r50_fpn_1x_coco_20210821_035055-2290a6b8.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/solo/solo_r50_fpn_1x_coco/solo_r50_fpn_1x_coco_20210821_035055.log.json) | +| R-50 | pytorch | Y | 3x | 7.4 | 14.0 | 35.9 | [model](https://download.openmmlab.com/mmdetection/v2.0/solo/solo_r50_fpn_3x_coco/solo_r50_fpn_3x_coco_20210901_012353-11d224d7.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/solo/solo_r50_fpn_3x_coco/solo_r50_fpn_3x_coco_20210901_012353.log.json) | + +### Decoupled SOLO + +| Backbone | Style | MS train | Lr schd | Mem (GB) | Inf time (fps) | mask AP | Download | +| :------: | :-----: | :------: | :-----: | :------: | :------------: | :-----: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | pytorch | N | 1x | 7.8 | 12.5 | 33.9 | [model](https://download.openmmlab.com/mmdetection/v2.0/solo/decoupled_solo_r50_fpn_1x_coco/decoupled_solo_r50_fpn_1x_coco_20210820_233348-6337c589.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/solo/decoupled_solo_r50_fpn_1x_coco/decoupled_solo_r50_fpn_1x_coco_20210820_233348.log.json) | +| R-50 | pytorch | Y | 3x | 7.9 | 12.5 | 36.7 | [model](https://download.openmmlab.com/mmdetection/v2.0/solo/decoupled_solo_r50_fpn_3x_coco/decoupled_solo_r50_fpn_3x_coco_20210821_042504-7b3301ec.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/solo/decoupled_solo_r50_fpn_3x_coco/decoupled_solo_r50_fpn_3x_coco_20210821_042504.log.json) | + +- Decoupled SOLO has a decoupled head which is different from SOLO head. + Decoupled SOLO serves as an efficient and equivalent variant in accuracy + of SOLO. Please refer to the corresponding config files for details. + +### Decoupled Light SOLO + +| Backbone | Style | MS train | Lr schd | Mem (GB) | Inf time (fps) | mask AP | Download | +| :------: | :-----: | :------: | :-----: | :------: | :------------: | :-----: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | pytorch | Y | 3x | 2.2 | 31.2 | 32.9 | [model](https://download.openmmlab.com/mmdetection/v2.0/solo/decoupled_solo_light_r50_fpn_3x_coco/decoupled_solo_light_r50_fpn_3x_coco_20210906_142703-e70e226f.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/solo/decoupled_solo_light_r50_fpn_3x_coco/decoupled_solo_light_r50_fpn_3x_coco_20210906_142703.log.json) | + +- Decoupled Light SOLO using decoupled structure similar to Decoupled + SOLO head, with light-weight head and smaller input size, Please refer + to the corresponding config files for details. + +## Citation + +```latex +@inproceedings{wang2020solo, + title = {{SOLO}: Segmenting Objects by Locations}, + author = {Wang, Xinlong and Kong, Tao and Shen, Chunhua and Jiang, Yuning and Li, Lei}, + booktitle = {Proc. Eur. Conf. Computer Vision (ECCV)}, + year = {2020} +} +``` diff --git a/mmdetection/configs/solo/decoupled-solo-light_r50_fpn_3x_coco.py b/mmdetection/configs/solo/decoupled-solo-light_r50_fpn_3x_coco.py new file mode 100644 index 00000000..fc35df3c --- /dev/null +++ b/mmdetection/configs/solo/decoupled-solo-light_r50_fpn_3x_coco.py @@ -0,0 +1,50 @@ +_base_ = './decoupled-solo_r50_fpn_3x_coco.py' + +# model settings +model = dict( + mask_head=dict( + type='DecoupledSOLOLightHead', + num_classes=80, + in_channels=256, + stacked_convs=4, + feat_channels=256, + strides=[8, 8, 16, 32, 32], + scale_ranges=((1, 64), (32, 128), (64, 256), (128, 512), (256, 2048)), + pos_scale=0.2, + num_grids=[40, 36, 24, 16, 12], + cls_down_index=0, + loss_mask=dict( + type='DiceLoss', use_sigmoid=True, activate=False, + loss_weight=3.0), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + norm_cfg=dict(type='GN', num_groups=32, requires_grad=True))) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='RandomChoiceResize', + scales=[(852, 512), (852, 480), (852, 448), (852, 416), (852, 384), + (852, 352)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=(852, 512), keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader diff --git a/mmdetection/configs/solo/decoupled-solo_r50_fpn_1x_coco.py b/mmdetection/configs/solo/decoupled-solo_r50_fpn_1x_coco.py new file mode 100644 index 00000000..6d7f4b90 --- /dev/null +++ b/mmdetection/configs/solo/decoupled-solo_r50_fpn_1x_coco.py @@ -0,0 +1,24 @@ +_base_ = './solo_r50_fpn_1x_coco.py' +# model settings +model = dict( + mask_head=dict( + type='DecoupledSOLOHead', + num_classes=80, + in_channels=256, + stacked_convs=7, + feat_channels=256, + strides=[8, 8, 16, 32, 32], + scale_ranges=((1, 96), (48, 192), (96, 384), (192, 768), (384, 2048)), + pos_scale=0.2, + num_grids=[40, 36, 24, 16, 12], + cls_down_index=0, + loss_mask=dict( + type='DiceLoss', use_sigmoid=True, activate=False, + loss_weight=3.0), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + norm_cfg=dict(type='GN', num_groups=32, requires_grad=True))) diff --git a/mmdetection/configs/solo/decoupled-solo_r50_fpn_3x_coco.py b/mmdetection/configs/solo/decoupled-solo_r50_fpn_3x_coco.py new file mode 100644 index 00000000..4a8c19de --- /dev/null +++ b/mmdetection/configs/solo/decoupled-solo_r50_fpn_3x_coco.py @@ -0,0 +1,25 @@ +_base_ = './solo_r50_fpn_3x_coco.py' + +# model settings +model = dict( + mask_head=dict( + type='DecoupledSOLOHead', + num_classes=80, + in_channels=256, + stacked_convs=7, + feat_channels=256, + strides=[8, 8, 16, 32, 32], + scale_ranges=((1, 96), (48, 192), (96, 384), (192, 768), (384, 2048)), + pos_scale=0.2, + num_grids=[40, 36, 24, 16, 12], + cls_down_index=0, + loss_mask=dict( + type='DiceLoss', use_sigmoid=True, activate=False, + loss_weight=3.0), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + norm_cfg=dict(type='GN', num_groups=32, requires_grad=True))) diff --git a/mmdetection/configs/solo/metafile.yml b/mmdetection/configs/solo/metafile.yml new file mode 100644 index 00000000..aa38b8c0 --- /dev/null +++ b/mmdetection/configs/solo/metafile.yml @@ -0,0 +1,115 @@ +Collections: + - Name: SOLO + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - FPN + - Convolution + - ResNet + Paper: https://arxiv.org/abs/1912.04488 + README: configs/solo/README.md + +Models: + - Name: decoupled-solo_r50_fpn_1x_coco + In Collection: SOLO + Config: configs/solo/decoupled-solo_r50_fpn_1x_coco.py + Metadata: + Training Memory (GB): 7.8 + Epochs: 12 + inference time (ms/im): + - value: 116.4 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (1333, 800) + Results: + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 33.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/solo/decoupled_solo_r50_fpn_1x_coco/decoupled_solo_r50_fpn_1x_coco_20210820_233348-6337c589.pth + + - Name: decoupled-solo_r50_fpn_3x_coco + In Collection: SOLO + Config: configs/solo/decoupled-solo_r50_fpn_3x_coco.py + Metadata: + Training Memory (GB): 7.9 + Epochs: 36 + inference time (ms/im): + - value: 117.2 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (1333, 800) + Results: + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 36.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/solo/decoupled_solo_r50_fpn_3x_coco/decoupled_solo_r50_fpn_3x_coco_20210821_042504-7b3301ec.pth + + - Name: decoupled-solo-light_r50_fpn_3x_coco + In Collection: SOLO + Config: configs/solo/decoupled-solo-light_r50_fpn_3x_coco.py + Metadata: + Training Memory (GB): 2.2 + Epochs: 36 + inference time (ms/im): + - value: 35.0 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (852, 512) + Results: + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 32.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/solo/decoupled_solo_light_r50_fpn_3x_coco/decoupled_solo_light_r50_fpn_3x_coco_20210906_142703-e70e226f.pth + + - Name: solo_r50_fpn_3x_coco + In Collection: SOLO + Config: configs/solo/solo_r50_fpn_3x_coco.py + Metadata: + Training Memory (GB): 7.4 + Epochs: 36 + inference time (ms/im): + - value: 94.2 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (1333, 800) + Results: + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 35.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/solo/solo_r50_fpn_3x_coco/solo_r50_fpn_3x_coco_20210901_012353-11d224d7.pth + + - Name: solo_r50_fpn_1x_coco + In Collection: SOLO + Config: configs/solo/solo_r50_fpn_1x_coco.py + Metadata: + Training Memory (GB): 8.0 + Epochs: 12 + inference time (ms/im): + - value: 95.1 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (1333, 800) + Results: + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 33.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/solo/solo_r50_fpn_1x_coco/solo_r50_fpn_1x_coco_20210821_035055-2290a6b8.pth diff --git a/mmdetection/configs/solo/solo_r101_fpn_8xb8-lsj-200e_coco.py b/mmdetection/configs/solo/solo_r101_fpn_8xb8-lsj-200e_coco.py new file mode 100644 index 00000000..0f49c5c1 --- /dev/null +++ b/mmdetection/configs/solo/solo_r101_fpn_8xb8-lsj-200e_coco.py @@ -0,0 +1,7 @@ +_base_ = './solo_r50_fpn_8xb8-lsj-200e_coco.py' + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/solo/solo_r18_fpn_8xb8-lsj-200e_coco.py b/mmdetection/configs/solo/solo_r18_fpn_8xb8-lsj-200e_coco.py new file mode 100644 index 00000000..977ae54d --- /dev/null +++ b/mmdetection/configs/solo/solo_r18_fpn_8xb8-lsj-200e_coco.py @@ -0,0 +1,7 @@ +_base_ = './solo_r50_fpn_8xb8-lsj-200e_coco.py' + +model = dict( + backbone=dict( + depth=18, + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet18')), + neck=dict(in_channels=[64, 128, 256, 512])) diff --git a/mmdetection/configs/solo/solo_r50_fpn_1x_coco.py b/mmdetection/configs/solo/solo_r50_fpn_1x_coco.py new file mode 100644 index 00000000..595e9ffe --- /dev/null +++ b/mmdetection/configs/solo/solo_r50_fpn_1x_coco.py @@ -0,0 +1,62 @@ +_base_ = [ + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +# model settings +model = dict( + type='SOLO', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_mask=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50'), + style='pytorch'), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=0, + num_outs=5), + mask_head=dict( + type='SOLOHead', + num_classes=80, + in_channels=256, + stacked_convs=7, + feat_channels=256, + strides=[8, 8, 16, 32, 32], + scale_ranges=((1, 96), (48, 192), (96, 384), (192, 768), (384, 2048)), + pos_scale=0.2, + num_grids=[40, 36, 24, 16, 12], + cls_down_index=0, + loss_mask=dict(type='DiceLoss', use_sigmoid=True, loss_weight=3.0), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + norm_cfg=dict(type='GN', num_groups=32, requires_grad=True)), + # model training and testing settings + test_cfg=dict( + nms_pre=500, + score_thr=0.1, + mask_thr=0.5, + filter_thr=0.05, + kernel='gaussian', # gaussian/linear + sigma=2.0, + max_per_img=100)) + +# optimizer +optim_wrapper = dict(optimizer=dict(lr=0.01)) + +val_evaluator = dict(metric='segm') +test_evaluator = val_evaluator diff --git a/mmdetection/configs/solo/solo_r50_fpn_3x_coco.py b/mmdetection/configs/solo/solo_r50_fpn_3x_coco.py new file mode 100644 index 00000000..0d5abbd2 --- /dev/null +++ b/mmdetection/configs/solo/solo_r50_fpn_3x_coco.py @@ -0,0 +1,35 @@ +_base_ = './solo_r50_fpn_1x_coco.py' + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='RandomChoiceResize', + scales=[(1333, 800), (1333, 768), (1333, 736), (1333, 704), + (1333, 672), (1333, 640)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +# training schedule for 3x +max_epochs = 36 +train_cfg = dict(max_epochs=max_epochs) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0 / 3, + by_epoch=False, + begin=0, + end=500), + dict( + type='MultiStepLR', + begin=0, + end=36, + by_epoch=True, + milestones=[27, 33], + gamma=0.1) +] diff --git a/mmdetection/configs/solo/solo_r50_fpn_8xb8-lsj-200e_coco.py b/mmdetection/configs/solo/solo_r50_fpn_8xb8-lsj-200e_coco.py new file mode 100644 index 00000000..d46bf391 --- /dev/null +++ b/mmdetection/configs/solo/solo_r50_fpn_8xb8-lsj-200e_coco.py @@ -0,0 +1,71 @@ +_base_ = '../common/lsj-200e_coco-instance.py' + +image_size = (1024, 1024) +batch_augments = [dict(type='BatchFixedSizePad', size=image_size)] + +# model settings +model = dict( + type='SOLO', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32, + batch_augments=batch_augments), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50'), + style='pytorch'), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=0, + num_outs=5), + mask_head=dict( + type='SOLOHead', + num_classes=80, + in_channels=256, + stacked_convs=7, + feat_channels=256, + strides=[8, 8, 16, 32, 32], + scale_ranges=((1, 96), (48, 192), (96, 384), (192, 768), (384, 2048)), + pos_scale=0.2, + num_grids=[40, 36, 24, 16, 12], + cls_down_index=0, + loss_mask=dict(type='DiceLoss', use_sigmoid=True, loss_weight=3.0), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + norm_cfg=dict(type='GN', num_groups=32, requires_grad=True)), + # model training and testing settings + test_cfg=dict( + nms_pre=500, + score_thr=0.1, + mask_thr=0.5, + filter_thr=0.05, + kernel='gaussian', # gaussian/linear + sigma=2.0, + max_per_img=100)) + +train_dataloader = dict(batch_size=8, num_workers=4) + +# Enable automatic-mixed-precision training with AmpOptimWrapper. +optim_wrapper = dict( + type='AmpOptimWrapper', + optimizer=dict( + type='SGD', lr=0.01 * 4, momentum=0.9, weight_decay=0.00004), + clip_grad=dict(max_norm=35, norm_type=2)) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (8 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/solov2/README.md b/mmdetection/configs/solov2/README.md new file mode 100644 index 00000000..b2169131 --- /dev/null +++ b/mmdetection/configs/solov2/README.md @@ -0,0 +1,59 @@ +# SOLOv2 + +> [SOLOv2: Dynamic and Fast Instance Segmentation](https://arxiv.org/abs/2003.10152) + + + +## Abstract + +In this work, we aim at building a simple, direct, and fast instance segmentation +framework with strong performance. We follow the principle of the SOLO method of +Wang et al. "SOLO: segmenting objects by locations". Importantly, we take one +step further by dynamically learning the mask head of the object segmenter such +that the mask head is conditioned on the location. Specifically, the mask branch +is decoupled into a mask kernel branch and mask feature branch, which are +responsible for learning the convolution kernel and the convolved features +respectively. Moreover, we propose Matrix NMS (non maximum suppression) to +significantly reduce the inference time overhead due to NMS of masks. Our +Matrix NMS performs NMS with parallel matrix operations in one shot, and +yields better results. We demonstrate a simple direct instance segmentation +system, outperforming a few state-of-the-art methods in both speed and accuracy. +A light-weight version of SOLOv2 executes at 31.3 FPS and yields 37.1% AP. +Moreover, our state-of-the-art results in object detection (from our mask byproduct) +and panoptic segmentation show the potential to serve as a new strong baseline +for many instance-level recognition tasks besides instance segmentation. + +
    + +
    + +## Results and Models + +### SOLOv2 + +| Backbone | Style | MS train | Lr schd | Mem (GB) | mask AP | Config | Download | +| :--------: | :-----: | :------: | :-----: | :------: | :-----: | :-------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | pytorch | N | 1x | 5.1 | 34.8 | [config](./solov2_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/solov2/solov2_r50_fpn_1x_coco/solov2_r50_fpn_1x_coco_20220512_125858-a357fa23.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/solov2/solov2_r50_fpn_1x_coco/solov2_r50_fpn_1x_coco_20220512_125858.log.json) | +| R-50 | pytorch | Y | 3x | 5.1 | 37.5 | [config](./solov2_r50_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/solov2/solov2_r50_fpn_3x_coco/solov2_r50_fpn_3x_coco_20220512_125856-fed092d4.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/solov2/solov2_r50_fpn_3x_coco/solov2_r50_fpn_3x_coco_20220512_125856.log.json) | +| R-101 | pytorch | Y | 3x | 6.9 | 39.1 | [config](./solov2_r101_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/solov2/solov2_r101_fpn_3x_coco/solov2_r101_fpn_3x_coco_20220511_095119-c559a076.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/solov2/solov2_r101_fpn_3x_coco/solov2_r101_fpn_3x_coco_20220511_095119.log.json) | +| R-101(DCN) | pytorch | Y | 3x | 7.1 | 41.2 | [config](./solov2_r101-dcn_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/solov2/solov2_r101_dcn_fpn_3x_coco/solov2_r101_dcn_fpn_3x_coco_20220513_214734-16c966cb.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/solov2/solov2_r101_dcn_fpn_3x_coco/solov2_r101_dcn_fpn_3x_coco_20220513_214734.log.json) | +| X-101(DCN) | pytorch | Y | 3x | 11.3 | 42.4 | [config](./solov2_x101-dcn_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/solov2/solov2_x101_dcn_fpn_3x_coco/solov2_x101_dcn_fpn_3x_coco_20220513_214337-aef41095.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/solov2/solov2_x101_dcn_fpn_3x_coco/solov2_x101_dcn_fpn_3x_coco_20220513_214337.log.json) | + +### Light SOLOv2 + +| Backbone | Style | MS train | Lr schd | Mem (GB) | mask AP | Config | Download | +| :------: | :-----: | :------: | :-----: | :------: | :-----: | :--------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-18 | pytorch | Y | 3x | 9.1 | 29.7 | [config](./solov2-light_r18_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/solov2/solov2_light_r18_fpn_3x_coco/solov2_light_r18_fpn_3x_coco_20220511_083717-75fa355b.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/solov2/solov2_light_r18_fpn_3x_coco/solov2_light_r18_fpn_3x_coco_20220511_083717.log.json) | +| R-34 | pytorch | Y | 3x | 9.3 | 31.9 | [config](./solov2-light_r34_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/solov2/solov2_light_r34_fpn_3x_coco/solov2_light_r34_fpn_3x_coco_20220511_091839-e51659d3.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/solov2/solov2_light_r34_fpn_3x_coco/solov2_light_r34_fpn_3x_coco_20220511_091839.log.json) | +| R-50 | pytorch | Y | 3x | 9.9 | 33.7 | [config](./solov2-light_r50_fpn_ms-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/solov2/solov2_light_r50_fpn_3x_coco/solov2_light_r50_fpn_3x_coco_20220512_165256-c93a6074.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/solov2/solov2_light_r50_fpn_3x_coco/solov2_light_r50_fpn_3x_coco_20220512_165256.log.json) | + +## Citation + +```latex +@article{wang2020solov2, + title={SOLOv2: Dynamic and Fast Instance Segmentation}, + author={Wang, Xinlong and Zhang, Rufeng and Kong, Tao and Li, Lei and Shen, Chunhua}, + journal={Proc. Advances in Neural Information Processing Systems (NeurIPS)}, + year={2020} +} +``` diff --git a/mmdetection/configs/solov2/metafile.yml b/mmdetection/configs/solov2/metafile.yml new file mode 100644 index 00000000..d0156b2b --- /dev/null +++ b/mmdetection/configs/solov2/metafile.yml @@ -0,0 +1,93 @@ +Collections: + - Name: SOLOv2 + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x A100 GPUs + Architecture: + - FPN + - Convolution + - ResNet + Paper: https://arxiv.org/abs/2003.10152 + README: configs/solov2/README.md + +Models: + - Name: solov2_r50_fpn_1x_coco + In Collection: SOLOv2 + Config: configs/solov2/solov2_r50_fpn_1x_coco.py + Metadata: + Training Memory (GB): 5.1 + Epochs: 12 + Results: + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 34.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/solov2/solov2_r50_fpn_1x_coco/solov2_r50_fpn_1x_coco_20220512_125858-a357fa23.pth + + - Name: solov2_r50_fpn_ms-3x_coco + In Collection: SOLOv2 + Config: configs/solov2/solov2_r50_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 5.1 + Epochs: 36 + Results: + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 37.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/solov2/solov2_r50_fpn_3x_coco/solov2_r50_fpn_3x_coco_20220512_125856-fed092d4.pth + + - Name: solov2_r101-dcn_fpn_ms-3x_coco + In Collection: SOLOv2 + Config: configs/solov2/solov2_r101-dcn_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 7.1 + Epochs: 36 + Results: + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 41.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/solov2/solov2_r101_dcn_fpn_3x_coco/solov2_r101_dcn_fpn_3x_coco_20220513_214734-16c966cb.pth + + - Name: solov2_x101-dcn_fpn_ms-3x_coco + In Collection: SOLOv2 + Config: configs/solov2/solov2_x101-dcn_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 11.3 + Epochs: 36 + Results: + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 42.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/solov2/solov2_x101_dcn_fpn_3x_coco/solov2_x101_dcn_fpn_3x_coco_20220513_214337-aef41095.pth + + - Name: solov2-light_r18_fpn_ms-3x_coco + In Collection: SOLOv2 + Config: configs/solov2/solov2-light_r18_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 9.1 + Epochs: 36 + Results: + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 29.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/solov2/solov2_light_r18_fpn_3x_coco/solov2_light_r18_fpn_3x_coco_20220511_083717-75fa355b.pth + + - Name: solov2-light_r50_fpn_ms-3x_coco + In Collection: SOLOv2 + Config: configs/solov2/solov2-light_r50_fpn_ms-3x_coco.py + Metadata: + Training Memory (GB): 9.9 + Epochs: 36 + Results: + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 33.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/solov2/solov2_light_r50_fpn_3x_coco/solov2_light_r50_fpn_3x_coco_20220512_165256-c93a6074.pth diff --git a/mmdetection/configs/solov2/solov2-light_r18_fpn_ms-3x_coco.py b/mmdetection/configs/solov2/solov2-light_r18_fpn_ms-3x_coco.py new file mode 100644 index 00000000..f8fc53e0 --- /dev/null +++ b/mmdetection/configs/solov2/solov2-light_r18_fpn_ms-3x_coco.py @@ -0,0 +1,7 @@ +_base_ = './solov2-light_r50_fpn_ms-3x_coco.py' + +# model settings +model = dict( + backbone=dict( + depth=18, init_cfg=dict(checkpoint='torchvision://resnet18')), + neck=dict(in_channels=[64, 128, 256, 512])) diff --git a/mmdetection/configs/solov2/solov2-light_r34_fpn_ms-3x_coco.py b/mmdetection/configs/solov2/solov2-light_r34_fpn_ms-3x_coco.py new file mode 100644 index 00000000..149b3366 --- /dev/null +++ b/mmdetection/configs/solov2/solov2-light_r34_fpn_ms-3x_coco.py @@ -0,0 +1,7 @@ +_base_ = './solov2-light_r50_fpn_ms-3x_coco.py' + +# model settings +model = dict( + backbone=dict( + depth=34, init_cfg=dict(checkpoint='torchvision://resnet34')), + neck=dict(in_channels=[64, 128, 256, 512])) diff --git a/mmdetection/configs/solov2/solov2-light_r50-dcn_fpn_ms-3x_coco.py b/mmdetection/configs/solov2/solov2-light_r50-dcn_fpn_ms-3x_coco.py new file mode 100644 index 00000000..05391944 --- /dev/null +++ b/mmdetection/configs/solov2/solov2-light_r50-dcn_fpn_ms-3x_coco.py @@ -0,0 +1,14 @@ +_base_ = './solov2-light_r50_fpn_ms-3x_coco.py' + +# model settings +model = dict( + backbone=dict( + dcn=dict(type='DCNv2', deformable_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True)), + mask_head=dict( + feat_channels=256, + stacked_convs=3, + scale_ranges=((1, 64), (32, 128), (64, 256), (128, 512), (256, 2048)), + mask_feature_head=dict(out_channels=128), + dcn_cfg=dict(type='DCNv2'), + dcn_apply_to_all_conv=False)) # light solov2 head diff --git a/mmdetection/configs/solov2/solov2-light_r50_fpn_ms-3x_coco.py b/mmdetection/configs/solov2/solov2-light_r50_fpn_ms-3x_coco.py new file mode 100644 index 00000000..cf0a7f77 --- /dev/null +++ b/mmdetection/configs/solov2/solov2-light_r50_fpn_ms-3x_coco.py @@ -0,0 +1,56 @@ +_base_ = './solov2_r50_fpn_1x_coco.py' + +# model settings +model = dict( + mask_head=dict( + stacked_convs=2, + feat_channels=256, + scale_ranges=((1, 56), (28, 112), (56, 224), (112, 448), (224, 896)), + mask_feature_head=dict(out_channels=128))) + +# dataset settings +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='RandomChoiceResize', + scales=[(768, 512), (768, 480), (768, 448), (768, 416), (768, 384), + (768, 352)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=(448, 768), keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader + +# training schedule for 3x +max_epochs = 36 +train_cfg = dict(by_epoch=True, max_epochs=max_epochs) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0 / 3, + by_epoch=False, + begin=0, + end=500), + dict( + type='MultiStepLR', + begin=0, + end=36, + by_epoch=True, + milestones=[27, 33], + gamma=0.1) +] diff --git a/mmdetection/configs/solov2/solov2_r101-dcn_fpn_ms-3x_coco.py b/mmdetection/configs/solov2/solov2_r101-dcn_fpn_ms-3x_coco.py new file mode 100644 index 00000000..370a4eb7 --- /dev/null +++ b/mmdetection/configs/solov2/solov2_r101-dcn_fpn_ms-3x_coco.py @@ -0,0 +1,13 @@ +_base_ = './solov2_r50_fpn_ms-3x_coco.py' + +# model settings +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(checkpoint='torchvision://resnet101'), + dcn=dict(type='DCNv2', deformable_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True)), + mask_head=dict( + mask_feature_head=dict(conv_cfg=dict(type='DCNv2')), + dcn_cfg=dict(type='DCNv2'), + dcn_apply_to_all_conv=True)) diff --git a/mmdetection/configs/solov2/solov2_r101_fpn_ms-3x_coco.py b/mmdetection/configs/solov2/solov2_r101_fpn_ms-3x_coco.py new file mode 100644 index 00000000..96aaac0a --- /dev/null +++ b/mmdetection/configs/solov2/solov2_r101_fpn_ms-3x_coco.py @@ -0,0 +1,6 @@ +_base_ = './solov2_r50_fpn_ms-3x_coco.py' + +# model settings +model = dict( + backbone=dict( + depth=101, init_cfg=dict(checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/solov2/solov2_r50_fpn_1x_coco.py b/mmdetection/configs/solov2/solov2_r50_fpn_1x_coco.py new file mode 100644 index 00000000..138ca010 --- /dev/null +++ b/mmdetection/configs/solov2/solov2_r50_fpn_1x_coco.py @@ -0,0 +1,70 @@ +_base_ = [ + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +# model settings +model = dict( + type='SOLOv2', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_mask=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50'), + style='pytorch'), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=0, + num_outs=5), + mask_head=dict( + type='SOLOV2Head', + num_classes=80, + in_channels=256, + feat_channels=512, + stacked_convs=4, + strides=[8, 8, 16, 32, 32], + scale_ranges=((1, 96), (48, 192), (96, 384), (192, 768), (384, 2048)), + pos_scale=0.2, + num_grids=[40, 36, 24, 16, 12], + cls_down_index=0, + mask_feature_head=dict( + feat_channels=128, + start_level=0, + end_level=3, + out_channels=256, + mask_stride=4, + norm_cfg=dict(type='GN', num_groups=32, requires_grad=True)), + loss_mask=dict(type='DiceLoss', use_sigmoid=True, loss_weight=3.0), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0)), + # model training and testing settings + test_cfg=dict( + nms_pre=500, + score_thr=0.1, + mask_thr=0.5, + filter_thr=0.05, + kernel='gaussian', # gaussian/linear + sigma=2.0, + max_per_img=100)) + +# optimizer +optim_wrapper = dict( + optimizer=dict(lr=0.01), clip_grad=dict(max_norm=35, norm_type=2)) + +val_evaluator = dict(metric='segm') +test_evaluator = val_evaluator diff --git a/mmdetection/configs/solov2/solov2_r50_fpn_ms-3x_coco.py b/mmdetection/configs/solov2/solov2_r50_fpn_ms-3x_coco.py new file mode 100644 index 00000000..d6f09827 --- /dev/null +++ b/mmdetection/configs/solov2/solov2_r50_fpn_ms-3x_coco.py @@ -0,0 +1,35 @@ +_base_ = './solov2_r50_fpn_1x_coco.py' + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='RandomChoiceResize', + scales=[(1333, 800), (1333, 768), (1333, 736), (1333, 704), + (1333, 672), (1333, 640)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +# training schedule for 3x +max_epochs = 36 +train_cfg = dict(max_epochs=max_epochs) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0 / 3, + by_epoch=False, + begin=0, + end=500), + dict( + type='MultiStepLR', + begin=0, + end=36, + by_epoch=True, + milestones=[27, 33], + gamma=0.1) +] diff --git a/mmdetection/configs/solov2/solov2_x101-dcn_fpn_ms-3x_coco.py b/mmdetection/configs/solov2/solov2_x101-dcn_fpn_ms-3x_coco.py new file mode 100644 index 00000000..612c45eb --- /dev/null +++ b/mmdetection/configs/solov2/solov2_x101-dcn_fpn_ms-3x_coco.py @@ -0,0 +1,17 @@ +_base_ = './solov2_r50_fpn_ms-3x_coco.py' + +# model settings +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + dcn=dict(type='DCNv2', deformable_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d')), + mask_head=dict( + mask_feature_head=dict(conv_cfg=dict(type='DCNv2')), + dcn_cfg=dict(type='DCNv2'), + dcn_apply_to_all_conv=True)) diff --git a/mmdetection/configs/sort/README.md b/mmdetection/configs/sort/README.md new file mode 100644 index 00000000..8f035fde --- /dev/null +++ b/mmdetection/configs/sort/README.md @@ -0,0 +1,108 @@ +# Simple online and realtime tracking + +## Abstract + + + +This paper explores a pragmatic approach to multiple object tracking where the main focus is to associate objects efficiently for online and realtime applications. To this end, detection quality is identified as a key factor influencing tracking performance, where changing the detector can improve tracking by up to 18.9%. Despite only using a rudimentary combination of familiar techniques such as the Kalman Filter and Hungarian algorithm for the tracking components, this approach achieves an accuracy comparable to state-of-the-art online trackers. Furthermore, due to the simplicity of our tracking method, the tracker updates at a rate of 260 Hz which is over 20x faster than other state-of-the-art trackers. + + + +
    + +
    + +## Citation + + + +```latex +@inproceedings{bewley2016simple, + title={Simple online and realtime tracking}, + author={Bewley, Alex and Ge, Zongyuan and Ott, Lionel and Ramos, Fabio and Upcroft, Ben}, + booktitle={2016 IEEE International Conference on Image Processing (ICIP)}, + pages={3464--3468}, + year={2016}, + organization={IEEE} +} +``` + +## Results and models on MOT17 + +| Method | Detector | ReID | Train Set | Test Set | Public | Inf time (fps) | HOTA | MOTA | IDF1 | FP | FN | IDSw. | Config | Download | +| :----: | :----------------: | :--: | :--------: | :------: | :----: | :------------: | :--: | :--: | :--: | :---: | :---: | :---: | :----------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------: | +| SORT | R50-FasterRCNN-FPN | - | half-train | half-val | N | 18.6 | 52.0 | 62.0 | 57.8 | 15150 | 40410 | 5847 | [config](sort_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py) | [detector](https://download.openmmlab.com/mmtracking/mot/faster_rcnn/faster-rcnn_r50_fpn_4e_mot17-half-64ee2ed4.pth) | + +## Get started + +### 1. Development Environment Setup + +Tracking Development Environment Setup can refer to this [document](../../docs/en/get_started.md). + +### 2. Dataset Prepare + +Tracking Dataset Prepare can refer to this [document](../../docs/en/user_guides/tracking_dataset_prepare.md). + +### 3. Training + +We implement SORT with independent detector models. +Note that, due to the influence of parameters such as learning rate in default configuration file, +we recommend using 8 GPUs for training in order to reproduce accuracy. + +You can train the detector as follows. + +```shell script +# Training Faster R-CNN on mot17-half-train dataset with following command. +# The number after config file represents the number of GPUs used. Here we use 8 GPUs. +bash tools/dist_train.sh configs/sort/faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py 8 +``` + +If you want to know about more detailed usage of `train.py/dist_train.sh/slurm_train.sh`, +please refer to this [document](../../docs/en/user_guides/tracking_train_test.md). + +### 4. Testing and evaluation + +### 4.1 Example on MOTxx-halfval dataset + +**4.1.1 use separate trained detector model to evaluating and testing**\* + +```shell script +# Example 1: Test on motXX-half-val set. +# The number after config file represents the number of GPUs used. Here we use 8 GPUs. +bash tools/dist_test_tracking.sh configs/sort/sort_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py 8 --detector ${DETECTOR_CHECKPOINT_PATH} +``` + +**4.1.2 use video_baesd to evaluating and testing** + +we also provide two_ways(img_based or video_based) to evaluating and testing. +if you want to use video_based to evaluating and testing, you can modify config as follows + +``` +val_dataloader = dict( + sampler=dict(type='DefaultSampler', shuffle=False, round_up=False)) +``` + +### 4.2 Example on MOTxx-test dataset + +If you want to get the results of the [MOT Challenge](https://motchallenge.net/) test set, +please use the following command to generate result files that can be used for submission. +It will be stored in `./mot_17_test_res`, you can modify the saved path in `test_evaluator` of the config. + +```shell script +# Example 2: Test on motxx-test set +# The number after config file represents the number of GPUs used +bash tools/dist_test_tracking.sh configs/sort/sort_faster-rcnn_r50_fpn_8xb2-4e_mot17train_test-mot17test.py 8 --detector ${DETECTOR_CHECKPOINT_PATH} +``` + +If you want to know about more detailed usage of `test_tracking.py/dist_test_tracking.sh/slurm_test_tracking.sh`, +please refer to this [document](../../docs/en/user_guides/tracking_train_test.md). + +### 5.Inference + +Use a single GPU to predict a video and save it as a video. + +```shell +python demo/mot_demo.py demo/demo_mot.mp4 configs/sort/sort_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py --detector ${DETECTOR_CHECKPOINT_PATH} --out mot.mp4 +``` + +If you want to know about more detailed usage of `mot_demo.py`, please refer to this [document](../../docs/en/user_guides/tracking_inference.md). diff --git a/mmdetection/configs/sort/faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py b/mmdetection/configs/sort/faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py new file mode 100644 index 00000000..f1d5b72c --- /dev/null +++ b/mmdetection/configs/sort/faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py @@ -0,0 +1,41 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../_base_/datasets/mot_challenge_det.py', '../_base_/default_runtime.py' +] + +model = dict( + rpn_head=dict( + bbox_coder=dict(clip_border=False), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=1.0)), + roi_head=dict( + bbox_head=dict( + num_classes=1, + bbox_coder=dict(clip_border=False), + loss_bbox=dict(type='SmoothL1Loss', loss_weight=1.0))), + init_cfg=dict( + type='Pretrained', + checkpoint= # noqa: E251 + 'http://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_2x_coco/faster_rcnn_r50_fpn_2x_coco_bbox_mAP-0.384_20200504_210434-a5d8aa15.pth' # noqa: E501 + )) + +# training schedule for 4e +train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=4, val_interval=1) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# learning rate +param_scheduler = [ + dict(type='LinearLR', start_factor=0.01, by_epoch=False, begin=0, end=100), + dict( + type='MultiStepLR', + begin=0, + end=4, + by_epoch=True, + milestones=[3], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)) diff --git a/mmdetection/configs/sort/faster-rcnn_r50_fpn_8xb2-4e_mot17train_test-mot17train.py b/mmdetection/configs/sort/faster-rcnn_r50_fpn_8xb2-4e_mot17train_test-mot17train.py new file mode 100644 index 00000000..83647061 --- /dev/null +++ b/mmdetection/configs/sort/faster-rcnn_r50_fpn_8xb2-4e_mot17train_test-mot17train.py @@ -0,0 +1,11 @@ +_base_ = ['./faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval'] +# data +data_root = 'data/MOT17/' +train_dataloader = dict( + dataset=dict(ann_file='annotations/train_cocoformat.json')) +val_dataloader = dict( + dataset=dict(ann_file='annotations/train_cocoformat.json')) +test_dataloader = val_dataloader + +val_evaluator = dict(ann_file=data_root + 'annotations/train_cocoformat.json') +test_evaluator = val_evaluator diff --git a/mmdetection/configs/sort/faster-rcnn_r50_fpn_8xb2-8e_mot20halftrain_test-mot20halfval.py b/mmdetection/configs/sort/faster-rcnn_r50_fpn_8xb2-8e_mot20halftrain_test-mot20halfval.py new file mode 100644 index 00000000..a6d14ad8 --- /dev/null +++ b/mmdetection/configs/sort/faster-rcnn_r50_fpn_8xb2-8e_mot20halftrain_test-mot20halfval.py @@ -0,0 +1,29 @@ +_base_ = ['./faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval'] +model = dict( + rpn_head=dict(bbox_coder=dict(clip_border=True)), + roi_head=dict( + bbox_head=dict(bbox_coder=dict(clip_border=True), num_classes=1))) +# data +data_root = 'data/MOT20/' +train_dataloader = dict(dataset=dict(data_root=data_root)) +val_dataloader = dict(dataset=dict(data_root=data_root)) +test_dataloader = val_dataloader + +val_evaluator = dict(ann_file=data_root + + 'annotations/half-val_cocoformat.json') +test_evaluator = val_evaluator + +# training schedule for 8e +train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=8, val_interval=1) + +# learning rate +param_scheduler = [ + dict(type='LinearLR', start_factor=0.01, by_epoch=False, begin=0, end=100), + dict( + type='MultiStepLR', + begin=0, + end=8, + by_epoch=True, + milestones=[6], + gamma=0.1) +] diff --git a/mmdetection/configs/sort/faster-rcnn_r50_fpn_8xb2-8e_mot20train_test-mot20train.py b/mmdetection/configs/sort/faster-rcnn_r50_fpn_8xb2-8e_mot20train_test-mot20train.py new file mode 100644 index 00000000..85c85973 --- /dev/null +++ b/mmdetection/configs/sort/faster-rcnn_r50_fpn_8xb2-8e_mot20train_test-mot20train.py @@ -0,0 +1,32 @@ +_base_ = ['./faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval'] +model = dict( + rpn_head=dict(bbox_coder=dict(clip_border=True)), + roi_head=dict( + bbox_head=dict(bbox_coder=dict(clip_border=True), num_classes=1))) +# data +data_root = 'data/MOT20/' +train_dataloader = dict( + dataset=dict( + data_root=data_root, ann_file='annotations/train_cocoformat.json')) +val_dataloader = dict( + dataset=dict( + data_root=data_root, ann_file='annotations/train_cocoformat.json')) +test_dataloader = val_dataloader + +val_evaluator = dict(ann_file=data_root + 'annotations/train_cocoformat.json') +test_evaluator = val_evaluator + +# training schedule for 8e +train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=8, val_interval=1) + +# learning rate +param_scheduler = [ + dict(type='LinearLR', start_factor=0.01, by_epoch=False, begin=0, end=100), + dict( + type='MultiStepLR', + begin=0, + end=8, + by_epoch=True, + milestones=[6], + gamma=0.1) +] diff --git a/mmdetection/configs/sort/metafile.yml b/mmdetection/configs/sort/metafile.yml new file mode 100644 index 00000000..c582ce35 --- /dev/null +++ b/mmdetection/configs/sort/metafile.yml @@ -0,0 +1,35 @@ +Collections: + - Name: SORT + Metadata: + Training Techniques: + - SGD with Momentum + Training Resources: 8x V100 GPUs + Architecture: + - ResNet + - FPN + Paper: + URL: https://arxiv.org/abs/1602.00763 + Title: Simple Online and Realtime Tracking + README: configs/sort/README.md + +Models: + - Name: sort_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval + In Collection: SORT + Config: configs/mot/sort/sort_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py + Metadata: + Training Data: MOT17-half-train + inference time (ms/im): + - value: 53.8 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (640, 1088) + Results: + - Task: Multiple Object Tracking + Dataset: MOT17-half-val + Metrics: + MOTA: 62.0 + IDF1: 57.8 + HOTA: 52.0 + Weights: https://download.openmmlab.com/mmtracking/mot/faster_rcnn/faster-rcnn_r50_fpn_4e_mot17-half-64ee2ed4.pth diff --git a/mmdetection/configs/sort/sort_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py b/mmdetection/configs/sort/sort_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py new file mode 100644 index 00000000..78acb774 --- /dev/null +++ b/mmdetection/configs/sort/sort_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py @@ -0,0 +1,54 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', + '../_base_/datasets/mot_challenge.py', '../_base_/default_runtime.py' +] + +default_hooks = dict( + logger=dict(type='LoggerHook', interval=1), + visualization=dict(type='TrackVisualizationHook', draw=False)) + +vis_backends = [dict(type='LocalVisBackend')] +visualizer = dict( + type='TrackLocalVisualizer', vis_backends=vis_backends, name='visualizer') + +# custom hooks +custom_hooks = [ + # Synchronize model buffers such as running_mean and running_var in BN + # at the end of each epoch + dict(type='SyncBuffersHook') +] + +detector = _base_.model +detector.pop('data_preprocessor') +detector.rpn_head.bbox_coder.update(dict(clip_border=False)) +detector.roi_head.bbox_head.update(dict(num_classes=1)) +detector.roi_head.bbox_head.bbox_coder.update(dict(clip_border=False)) +detector['init_cfg'] = dict( + type='Pretrained', + checkpoint= # noqa: E251 + 'https://download.openmmlab.com/mmtracking/mot/' + 'faster_rcnn/faster-rcnn_r50_fpn_4e_mot17-half-64ee2ed4.pth') # noqa: E501 +del _base_.model + +model = dict( + type='DeepSORT', + data_preprocessor=dict( + type='TrackDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + rgb_to_bgr=False, + pad_size_divisor=32), + detector=detector, + tracker=dict( + type='SORTTracker', + motion=dict(type='KalmanFilter', center_only=False), + obj_score_thr=0.5, + match_iou_thr=0.5, + reid=None)) + +train_dataloader = None + +train_cfg = None +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') diff --git a/mmdetection/configs/sort/sort_faster-rcnn_r50_fpn_8xb2-4e_mot17train_test-mot17test.py b/mmdetection/configs/sort/sort_faster-rcnn_r50_fpn_8xb2-4e_mot17train_test-mot17test.py new file mode 100644 index 00000000..921652c4 --- /dev/null +++ b/mmdetection/configs/sort/sort_faster-rcnn_r50_fpn_8xb2-4e_mot17train_test-mot17test.py @@ -0,0 +1,15 @@ +_base_ = [ + './sort_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain' + '_test-mot17halfval.py' +] + +# dataloader +val_dataloader = dict( + dataset=dict(ann_file='annotations/train_cocoformat.json')) +test_dataloader = dict( + dataset=dict( + ann_file='annotations/test_cocoformat.json', + data_prefix=dict(img_path='test'))) + +# evaluator +test_evaluator = dict(format_only=True, outfile_prefix='./mot_17_test_res') diff --git a/mmdetection/configs/sparse_rcnn/README.md b/mmdetection/configs/sparse_rcnn/README.md new file mode 100644 index 00000000..2e8e365b --- /dev/null +++ b/mmdetection/configs/sparse_rcnn/README.md @@ -0,0 +1,38 @@ +# Sparse R-CNN + +> [Sparse R-CNN: End-to-End Object Detection with Learnable Proposals](https://arxiv.org/abs/2011.12450) + + + +## Abstract + +We present Sparse R-CNN, a purely sparse method for object detection in images. Existing works on object detection heavily rely on dense object candidates, such as k anchor boxes pre-defined on all grids of image feature map of size H×W. In our method, however, a fixed sparse set of learned object proposals, total length of N, are provided to object recognition head to perform classification and location. By eliminating HWk (up to hundreds of thousands) hand-designed object candidates to N (e.g. 100) learnable proposals, Sparse R-CNN completely avoids all efforts related to object candidates design and many-to-one label assignment. More importantly, final predictions are directly output without non-maximum suppression post-procedure. Sparse R-CNN demonstrates accuracy, run-time and training convergence performance on par with the well-established detector baselines on the challenging COCO dataset, e.g., achieving 45.0 AP in standard 3× training schedule and running at 22 fps using ResNet-50 FPN model. We hope our work could inspire re-thinking the convention of dense prior in object detectors. + +
    + +
    + +## Results and Models + +| Model | Backbone | Style | Lr schd | Number of Proposals | Multi-Scale | RandomCrop | box AP | Config | Download | +| :----------: | :-------: | :-----: | :-----: | :-----------------: | :---------: | :--------: | :----: | :-----------------------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| Sparse R-CNN | R-50-FPN | pytorch | 1x | 100 | False | False | 37.9 | [config](./sparse-rcnn_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/sparse_rcnn/sparse_rcnn_r50_fpn_1x_coco/sparse_rcnn_r50_fpn_1x_coco_20201222_214453-dc79b137.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/sparse_rcnn/sparse_rcnn_r50_fpn_1x_coco/sparse_rcnn_r50_fpn_1x_coco_20201222_214453-dc79b137.log.json) | +| Sparse R-CNN | R-50-FPN | pytorch | 3x | 100 | True | False | 42.8 | [config](./sparse-rcnn_r50_fpn_ms-480-800-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/sparse_rcnn/sparse_rcnn_r50_fpn_mstrain_480-800_3x_coco/sparse_rcnn_r50_fpn_mstrain_480-800_3x_coco_20201218_154234-7bc5c054.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/sparse_rcnn/sparse_rcnn_r50_fpn_mstrain_480-800_3x_coco/sparse_rcnn_r50_fpn_mstrain_480-800_3x_coco_20201218_154234-7bc5c054.log.json) | +| Sparse R-CNN | R-50-FPN | pytorch | 3x | 300 | True | True | 45.0 | [config](./sparse-rcnn_r50_fpn_300-proposals_crop-ms-480-800-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/sparse_rcnn/sparse_rcnn_r50_fpn_300_proposals_crop_mstrain_480-800_3x_coco/sparse_rcnn_r50_fpn_300_proposals_crop_mstrain_480-800_3x_coco_20201223_024605-9fe92701.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/sparse_rcnn/sparse_rcnn_r50_fpn_300_proposals_crop_mstrain_480-800_3x_coco/sparse_rcnn_r50_fpn_300_proposals_crop_mstrain_480-800_3x_coco_20201223_024605-9fe92701.log.json) | +| Sparse R-CNN | R-101-FPN | pytorch | 3x | 100 | True | False | 44.2 | [config](./sparse-rcnn_r101_fpn_ms-480-800-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/sparse_rcnn/sparse_rcnn_r101_fpn_mstrain_480-800_3x_coco/sparse_rcnn_r101_fpn_mstrain_480-800_3x_coco_20201223_121552-6c46c9d6.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/sparse_rcnn/sparse_rcnn_r101_fpn_mstrain_480-800_3x_coco/sparse_rcnn_r101_fpn_mstrain_480-800_3x_coco_20201223_121552-6c46c9d6.log.json) | +| Sparse R-CNN | R-101-FPN | pytorch | 3x | 300 | True | True | 46.2 | [config](./sparse-rcnn_r101_fpn_300-proposals_crop-ms-480-800-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/sparse_rcnn/sparse_rcnn_r101_fpn_300_proposals_crop_mstrain_480-800_3x_coco/sparse_rcnn_r101_fpn_300_proposals_crop_mstrain_480-800_3x_coco_20201223_023452-c23c3564.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/sparse_rcnn/sparse_rcnn_r101_fpn_300_proposals_crop_mstrain_480-800_3x_coco/sparse_rcnn_r101_fpn_300_proposals_crop_mstrain_480-800_3x_coco_20201223_023452-c23c3564.log.json) | + +### Notes + +We observe about 0.3 AP noise especially when using ResNet-101 as the backbone. + +## Citation + +```latex +@article{peize2020sparse, + title = {{SparseR-CNN}: End-to-End Object Detection with Learnable Proposals}, + author = {Peize Sun and Rufeng Zhang and Yi Jiang and Tao Kong and Chenfeng Xu and Wei Zhan and Masayoshi Tomizuka and Lei Li and Zehuan Yuan and Changhu Wang and Ping Luo}, + journal = {arXiv preprint arXiv:2011.12450}, + year = {2020} +} +``` diff --git a/mmdetection/configs/sparse_rcnn/metafile.yml b/mmdetection/configs/sparse_rcnn/metafile.yml new file mode 100644 index 00000000..8fe25318 --- /dev/null +++ b/mmdetection/configs/sparse_rcnn/metafile.yml @@ -0,0 +1,80 @@ +Collections: + - Name: Sparse R-CNN + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - FPN + - ResNet + - Sparse R-CNN + Paper: + URL: https://arxiv.org/abs/2011.12450 + Title: 'Sparse R-CNN: End-to-End Object Detection with Learnable Proposals' + README: configs/sparse_rcnn/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.9.0/mmdet/models/detectors/sparse_rcnn.py#L6 + Version: v2.9.0 + +Models: + - Name: sparse-rcnn_r50_fpn_1x_coco + In Collection: Sparse R-CNN + Config: configs/sparse_rcnn/sparse-rcnn_r50_fpn_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/sparse_rcnn/sparse_rcnn_r50_fpn_1x_coco/sparse_rcnn_r50_fpn_1x_coco_20201222_214453-dc79b137.pth + + - Name: sparse-rcnn_r50_fpn_ms-480-800-3x_coco + In Collection: Sparse R-CNN + Config: configs/sparse_rcnn/sparse-rcnn_r50_fpn_ms-480-800-3x_coco.py + Metadata: + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/sparse_rcnn/sparse_rcnn_r50_fpn_mstrain_480-800_3x_coco/sparse_rcnn_r50_fpn_mstrain_480-800_3x_coco_20201218_154234-7bc5c054.pth + + - Name: sparse-rcnn_r50_fpn_300-proposals_crop-ms-480-800-3x_coco + In Collection: Sparse R-CNN + Config: configs/sparse_rcnn/sparse-rcnn_r50_fpn_300-proposals_crop-ms-480-800-3x_coco.py + Metadata: + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 45.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/sparse_rcnn/sparse_rcnn_r50_fpn_300_proposals_crop_mstrain_480-800_3x_coco/sparse_rcnn_r50_fpn_300_proposals_crop_mstrain_480-800_3x_coco_20201223_024605-9fe92701.pth + + - Name: sparse-rcnn_r101_fpn_ms-480-800-3x_coco + In Collection: Sparse R-CNN + Config: configs/sparse_rcnn/sparse-rcnn_r101_fpn_ms-480-800-3x_coco.py + Metadata: + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/sparse_rcnn/sparse_rcnn_r101_fpn_mstrain_480-800_3x_coco/sparse_rcnn_r101_fpn_mstrain_480-800_3x_coco_20201223_121552-6c46c9d6.pth + + - Name: sparse-rcnn_r101_fpn_300-proposals_crop-ms-480-800-3x_coco + In Collection: Sparse R-CNN + Config: configs/sparse_rcnn/sparse-rcnn_r101_fpn_300-proposals_crop-ms-480-800-3x_coco.py + Metadata: + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/sparse_rcnn/sparse_rcnn_r101_fpn_300_proposals_crop_mstrain_480-800_3x_coco/sparse_rcnn_r101_fpn_300_proposals_crop_mstrain_480-800_3x_coco_20201223_023452-c23c3564.pth diff --git a/mmdetection/configs/sparse_rcnn/sparse-rcnn_r101_fpn_300-proposals_crop-ms-480-800-3x_coco.py b/mmdetection/configs/sparse_rcnn/sparse-rcnn_r101_fpn_300-proposals_crop-ms-480-800-3x_coco.py new file mode 100644 index 00000000..09c11c65 --- /dev/null +++ b/mmdetection/configs/sparse_rcnn/sparse-rcnn_r101_fpn_300-proposals_crop-ms-480-800-3x_coco.py @@ -0,0 +1,7 @@ +_base_ = './sparse-rcnn_r50_fpn_300-proposals_crop-ms-480-800-3x_coco.py' + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/sparse_rcnn/sparse-rcnn_r101_fpn_ms-480-800-3x_coco.py b/mmdetection/configs/sparse_rcnn/sparse-rcnn_r101_fpn_ms-480-800-3x_coco.py new file mode 100644 index 00000000..a51f11ce --- /dev/null +++ b/mmdetection/configs/sparse_rcnn/sparse-rcnn_r101_fpn_ms-480-800-3x_coco.py @@ -0,0 +1,7 @@ +_base_ = './sparse-rcnn_r50_fpn_ms-480-800-3x_coco.py' + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/sparse_rcnn/sparse-rcnn_r50_fpn_1x_coco.py b/mmdetection/configs/sparse_rcnn/sparse-rcnn_r50_fpn_1x_coco.py new file mode 100644 index 00000000..88354427 --- /dev/null +++ b/mmdetection/configs/sparse_rcnn/sparse-rcnn_r50_fpn_1x_coco.py @@ -0,0 +1,101 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +num_stages = 6 +num_proposals = 100 +model = dict( + type='SparseRCNN', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=0, + add_extra_convs='on_input', + num_outs=4), + rpn_head=dict( + type='EmbeddingRPNHead', + num_proposals=num_proposals, + proposal_feature_channel=256), + roi_head=dict( + type='SparseRoIHead', + num_stages=num_stages, + stage_loss_weights=[1] * num_stages, + proposal_feature_channel=256, + bbox_roi_extractor=dict( + type='SingleRoIExtractor', + roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=2), + out_channels=256, + featmap_strides=[4, 8, 16, 32]), + bbox_head=[ + dict( + type='DIIHead', + num_classes=80, + num_ffn_fcs=2, + num_heads=8, + num_cls_fcs=1, + num_reg_fcs=3, + feedforward_channels=2048, + in_channels=256, + dropout=0.0, + ffn_act_cfg=dict(type='ReLU', inplace=True), + dynamic_conv_cfg=dict( + type='DynamicConv', + in_channels=256, + feat_channels=64, + out_channels=256, + input_feat_shape=7, + act_cfg=dict(type='ReLU', inplace=True), + norm_cfg=dict(type='LN')), + loss_bbox=dict(type='L1Loss', loss_weight=5.0), + loss_iou=dict(type='GIoULoss', loss_weight=2.0), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=2.0), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + clip_border=False, + target_means=[0., 0., 0., 0.], + target_stds=[0.5, 0.5, 1., 1.])) for _ in range(num_stages) + ]), + # training and testing settings + train_cfg=dict( + rpn=None, + rcnn=[ + dict( + assigner=dict( + type='HungarianAssigner', + match_costs=[ + dict(type='FocalLossCost', weight=2.0), + dict(type='BBoxL1Cost', weight=5.0, box_format='xyxy'), + dict(type='IoUCost', iou_mode='giou', weight=2.0) + ]), + sampler=dict(type='PseudoSampler'), + pos_weight=1) for _ in range(num_stages) + ]), + test_cfg=dict(rpn=None, rcnn=dict(max_per_img=num_proposals))) + +# optimizer +optim_wrapper = dict( + optimizer=dict( + _delete_=True, type='AdamW', lr=0.000025, weight_decay=0.0001), + clip_grad=dict(max_norm=1, norm_type=2)) diff --git a/mmdetection/configs/sparse_rcnn/sparse-rcnn_r50_fpn_300-proposals_crop-ms-480-800-3x_coco.py b/mmdetection/configs/sparse_rcnn/sparse-rcnn_r50_fpn_300-proposals_crop-ms-480-800-3x_coco.py new file mode 100644 index 00000000..93edc031 --- /dev/null +++ b/mmdetection/configs/sparse_rcnn/sparse-rcnn_r50_fpn_300-proposals_crop-ms-480-800-3x_coco.py @@ -0,0 +1,43 @@ +_base_ = './sparse-rcnn_r50_fpn_ms-480-800-3x_coco.py' +num_proposals = 300 +model = dict( + rpn_head=dict(num_proposals=num_proposals), + test_cfg=dict( + _delete_=True, rpn=None, rcnn=dict(max_per_img=num_proposals))) + +# augmentation strategy originates from DETR. +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[[ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + scales=[(400, 1333), (500, 1333), (600, 1333)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), + (576, 1333), (608, 1333), (640, 1333), + (672, 1333), (704, 1333), (736, 1333), + (768, 1333), (800, 1333)], + keep_ratio=True) + ]]), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/mmdetection/configs/sparse_rcnn/sparse-rcnn_r50_fpn_ms-480-800-3x_coco.py b/mmdetection/configs/sparse_rcnn/sparse-rcnn_r50_fpn_ms-480-800-3x_coco.py new file mode 100644 index 00000000..156028d7 --- /dev/null +++ b/mmdetection/configs/sparse_rcnn/sparse-rcnn_r50_fpn_ms-480-800-3x_coco.py @@ -0,0 +1,32 @@ +_base_ = './sparse-rcnn_r50_fpn_1x_coco.py' + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +# learning policy +max_epochs = 36 +train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=max_epochs) + +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[27, 33], + gamma=0.1) +] diff --git a/mmdetection/configs/ssd/README.md b/mmdetection/configs/ssd/README.md new file mode 100644 index 00000000..8b3ca912 --- /dev/null +++ b/mmdetection/configs/ssd/README.md @@ -0,0 +1,62 @@ +# SSD + +> [SSD: Single Shot MultiBox Detector](https://arxiv.org/abs/1512.02325) + + + +## Abstract + +We present a method for detecting objects in images using a single deep neural network. Our approach, named SSD, discretizes the output space of bounding boxes into a set of default boxes over different aspect ratios and scales per feature map location. At prediction time, the network generates scores for the presence of each object category in each default box and produces adjustments to the box to better match the object shape. Additionally, the network combines predictions from multiple feature maps with different resolutions to naturally handle objects of various sizes. Our SSD model is simple relative to methods that require object proposals because it completely eliminates proposal generation and subsequent pixel or feature resampling stage and encapsulates all computation in a single network. This makes SSD easy to train and straightforward to integrate into systems that require a detection component. Experimental results on the PASCAL VOC, MS COCO, and ILSVRC datasets confirm that SSD has comparable accuracy to methods that utilize an additional object proposal step and is much faster, while providing a unified framework for both training and inference. Compared to other single stage methods, SSD has much better accuracy, even with a smaller input image size. For 300×300 input, SSD achieves 72.1% mAP on VOC2007 test at 58 FPS on a Nvidia Titan X and for 500×500 input, SSD achieves 75.1% mAP, outperforming a comparable state of the art Faster R-CNN model. + +
    + +
    + +## Results and models of SSD + +| Backbone | Size | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :------: | :--: | :---: | :-----: | :------: | :------------: | :----: | :------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| VGG16 | 300 | caffe | 120e | 9.9 | 43.7 | 25.5 | [config](./ssd300_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/ssd/ssd300_coco/ssd300_coco_20210803_015428-d231a06e.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/ssd/ssd300_coco/ssd300_coco_20210803_015428.log.json) | +| VGG16 | 512 | caffe | 120e | 19.4 | 30.7 | 29.5 | [config](./ssd512_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/ssd/ssd512_coco/ssd512_coco_20210803_022849-0a47a1ca.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/ssd/ssd512_coco/ssd512_coco_20210803_022849.log.json) | + +## Results and models of SSD-Lite + +| Backbone | Size | Training from scratch | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :---------: | :--: | :-------------------: | :-----: | :------: | :------------: | :----: | :--------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| MobileNetV2 | 320 | yes | 600e | 4.0 | 69.9 | 21.3 | [config](./ssdlite_mobilenetv2-scratch_8xb24-600e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/ssd/ssdlite_mobilenetv2_scratch_600e_coco/ssdlite_mobilenetv2_scratch_600e_coco_20210629_110627-974d9307.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/ssd/ssdlite_mobilenetv2_scratch_600e_coco/ssdlite_mobilenetv2_scratch_600e_coco_20210629_110627.log.json) | + +## Notice + +### Compatibility + +In v2.14.0, [PR5291](https://github.com/open-mmlab/mmdetection/pull/5291) refactored SSD neck and head for more +flexible usage. If users want to use the SSD checkpoint trained in the older versions, we provide a scripts +`tools/model_converters/upgrade_ssd_version.py` to convert the model weights. + +```bash +python tools/model_converters/upgrade_ssd_version.py ${OLD_MODEL_PATH} ${NEW_MODEL_PATH} + +``` + +- OLD_MODEL_PATH: the path to load the old version SSD model. +- NEW_MODEL_PATH: the path to save the converted model weights. + +### SSD-Lite training settings + +There are some differences between our implementation of MobileNetV2 SSD-Lite and the one in [TensorFlow 1.x detection model zoo](https://github.com/tensorflow/models/blob/master/research/object_detection/g3doc/tf1_detection_zoo.md) . + +1. Use 320x320 as input size instead of 300x300. +2. The anchor sizes are different. +3. The C4 feature map is taken from the last layer of stage 4 instead of the middle of the block. +4. The model in TensorFlow1.x is trained on coco 2014 and validated on coco minival2014, but we trained and validated the model on coco 2017. The mAP on val2017 is usually a little lower than minival2014 (refer to the results in TensorFlow Object Detection API, e.g., MobileNetV2 SSD gets 22 mAP on minival2014 but 20.2 mAP on val2017). + +## Citation + +```latex +@article{Liu_2016, + title={SSD: Single Shot MultiBox Detector}, + journal={ECCV}, + author={Liu, Wei and Anguelov, Dragomir and Erhan, Dumitru and Szegedy, Christian and Reed, Scott and Fu, Cheng-Yang and Berg, Alexander C.}, + year={2016}, +} +``` diff --git a/mmdetection/configs/ssd/metafile.yml b/mmdetection/configs/ssd/metafile.yml new file mode 100644 index 00000000..190a207c --- /dev/null +++ b/mmdetection/configs/ssd/metafile.yml @@ -0,0 +1,78 @@ +Collections: + - Name: SSD + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - VGG + Paper: + URL: https://arxiv.org/abs/1512.02325 + Title: 'SSD: Single Shot MultiBox Detector' + README: configs/ssd/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.14.0/mmdet/models/dense_heads/ssd_head.py#L16 + Version: v2.14.0 + +Models: + - Name: ssd300_coco + In Collection: SSD + Config: configs/ssd/ssd300_coco.py + Metadata: + Training Memory (GB): 9.9 + inference time (ms/im): + - value: 22.88 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (300, 300) + Epochs: 120 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 25.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/ssd/ssd300_coco/ssd300_coco_20210803_015428-d231a06e.pth + + - Name: ssd512_coco + In Collection: SSD + Config: configs/ssd/ssd512_coco.py + Metadata: + Training Memory (GB): 19.4 + inference time (ms/im): + - value: 32.57 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (512, 512) + Epochs: 120 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 29.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/ssd/ssd512_coco/ssd512_coco_20210803_022849-0a47a1ca.pth + + - Name: ssdlite_mobilenetv2-scratch_8xb24-600e_coco + In Collection: SSD + Config: configs/ssd/ssdlite_mobilenetv2-scratch_8xb24-600e_coco.py + Metadata: + Training Memory (GB): 4.0 + inference time (ms/im): + - value: 14.3 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (320, 320) + Epochs: 600 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 21.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/ssd/ssdlite_mobilenetv2_scratch_600e_coco/ssdlite_mobilenetv2_scratch_600e_coco_20210629_110627-974d9307.pth diff --git a/mmdetection/configs/ssd/ssd300_coco.py b/mmdetection/configs/ssd/ssd300_coco.py new file mode 100644 index 00000000..796d25c9 --- /dev/null +++ b/mmdetection/configs/ssd/ssd300_coco.py @@ -0,0 +1,71 @@ +_base_ = [ + '../_base_/models/ssd300.py', '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_2x.py', '../_base_/default_runtime.py' +] + +# dataset settings +input_size = 300 +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='Expand', + mean={{_base_.model.data_preprocessor.mean}}, + to_rgb={{_base_.model.data_preprocessor.bgr_to_rgb}}, + ratio_range=(1, 4)), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.3), + dict(type='Resize', scale=(input_size, input_size), keep_ratio=False), + dict(type='RandomFlip', prob=0.5), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=(input_size, input_size), keep_ratio=False), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict( + batch_size=8, + num_workers=2, + batch_sampler=None, + dataset=dict( + _delete_=True, + type='RepeatDataset', + times=5, + dataset=dict( + type={{_base_.dataset_type}}, + data_root={{_base_.data_root}}, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args={{_base_.backend_args}}))) +val_dataloader = dict(batch_size=8, dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=2e-3, momentum=0.9, weight_decay=5e-4)) + +custom_hooks = [ + dict(type='NumClassCheckHook'), + dict(type='CheckInvalidLossHook', interval=50, priority='VERY_LOW') +] + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (8 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/ssd/ssd512_coco.py b/mmdetection/configs/ssd/ssd512_coco.py new file mode 100644 index 00000000..7acd6144 --- /dev/null +++ b/mmdetection/configs/ssd/ssd512_coco.py @@ -0,0 +1,60 @@ +_base_ = 'ssd300_coco.py' + +# model settings +input_size = 512 +model = dict( + neck=dict( + out_channels=(512, 1024, 512, 256, 256, 256, 256), + level_strides=(2, 2, 2, 2, 1), + level_paddings=(1, 1, 1, 1, 1), + last_kernel_size=4), + bbox_head=dict( + in_channels=(512, 1024, 512, 256, 256, 256, 256), + anchor_generator=dict( + type='SSDAnchorGenerator', + scale_major=False, + input_size=input_size, + basesize_ratio_range=(0.1, 0.9), + strides=[8, 16, 32, 64, 128, 256, 512], + ratios=[[2], [2, 3], [2, 3], [2, 3], [2, 3], [2], [2]]))) + +# dataset settings +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='Expand', + mean={{_base_.model.data_preprocessor.mean}}, + to_rgb={{_base_.model.data_preprocessor.bgr_to_rgb}}, + ratio_range=(1, 4)), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.3), + dict(type='Resize', scale=(input_size, input_size), keep_ratio=False), + dict(type='RandomFlip', prob=0.5), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=(input_size, input_size), keep_ratio=False), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict(dataset=dict(dataset=dict(pipeline=train_pipeline))) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (8 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/ssd/ssdlite_mobilenetv2-scratch_8xb24-600e_coco.py b/mmdetection/configs/ssd/ssdlite_mobilenetv2-scratch_8xb24-600e_coco.py new file mode 100644 index 00000000..4e508f20 --- /dev/null +++ b/mmdetection/configs/ssd/ssdlite_mobilenetv2-scratch_8xb24-600e_coco.py @@ -0,0 +1,158 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +# model settings +data_preprocessor = dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=1) +model = dict( + type='SingleStageDetector', + data_preprocessor=data_preprocessor, + backbone=dict( + type='MobileNetV2', + out_indices=(4, 7), + norm_cfg=dict(type='BN', eps=0.001, momentum=0.03), + init_cfg=dict(type='TruncNormal', layer='Conv2d', std=0.03)), + neck=dict( + type='SSDNeck', + in_channels=(96, 1280), + out_channels=(96, 1280, 512, 256, 256, 128), + level_strides=(2, 2, 2, 2), + level_paddings=(1, 1, 1, 1), + l2_norm_scale=None, + use_depthwise=True, + norm_cfg=dict(type='BN', eps=0.001, momentum=0.03), + act_cfg=dict(type='ReLU6'), + init_cfg=dict(type='TruncNormal', layer='Conv2d', std=0.03)), + bbox_head=dict( + type='SSDHead', + in_channels=(96, 1280, 512, 256, 256, 128), + num_classes=80, + use_depthwise=True, + norm_cfg=dict(type='BN', eps=0.001, momentum=0.03), + act_cfg=dict(type='ReLU6'), + init_cfg=dict(type='Normal', layer='Conv2d', std=0.001), + + # set anchor size manually instead of using the predefined + # SSD300 setting. + anchor_generator=dict( + type='SSDAnchorGenerator', + scale_major=False, + strides=[16, 32, 64, 107, 160, 320], + ratios=[[2, 3], [2, 3], [2, 3], [2, 3], [2, 3], [2, 3]], + min_sizes=[48, 100, 150, 202, 253, 304], + max_sizes=[100, 150, 202, 253, 304, 320]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.1, 0.1, 0.2, 0.2])), + # model training and testing settings + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0., + ignore_iof_thr=-1, + gt_max_assign_all=False), + sampler=dict(type='PseudoSampler'), + smoothl1_beta=1., + allowed_border=-1, + pos_weight=-1, + neg_pos_ratio=3, + debug=False), + test_cfg=dict( + nms_pre=1000, + nms=dict(type='nms', iou_threshold=0.45), + min_bbox_size=0, + score_thr=0.02, + max_per_img=200)) +env_cfg = dict(cudnn_benchmark=True) + +# dataset settings +input_size = 320 +train_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='Expand', + mean=data_preprocessor['mean'], + to_rgb=data_preprocessor['bgr_to_rgb'], + ratio_range=(1, 4)), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.3), + dict(type='Resize', scale=(input_size, input_size), keep_ratio=False), + dict(type='RandomFlip', prob=0.5), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile'), + dict(type='Resize', scale=(input_size, input_size), keep_ratio=False), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict( + batch_size=24, + num_workers=4, + batch_sampler=None, + dataset=dict( + _delete_=True, + type='RepeatDataset', + times=5, + dataset=dict( + type={{_base_.dataset_type}}, + data_root={{_base_.data_root}}, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline))) +val_dataloader = dict(batch_size=8, dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader + +# training schedule +max_epochs = 120 +train_cfg = dict(max_epochs=max_epochs, val_interval=5) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='CosineAnnealingLR', + begin=0, + T_max=max_epochs, + end=max_epochs, + by_epoch=True, + eta_min=0) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.015, momentum=0.9, weight_decay=4.0e-5)) + +custom_hooks = [ + dict(type='NumClassCheckHook'), + dict(type='CheckInvalidLossHook', interval=50, priority='VERY_LOW') +] + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (24 samples per GPU) +auto_scale_lr = dict(base_batch_size=192) diff --git a/mmdetection/configs/strong_baselines/README.md b/mmdetection/configs/strong_baselines/README.md new file mode 100644 index 00000000..e5db3e08 --- /dev/null +++ b/mmdetection/configs/strong_baselines/README.md @@ -0,0 +1,20 @@ +# Strong Baselines + + + +We train Mask R-CNN with large-scale jitter and longer schedule as strong baselines. +The modifications follow those in [Detectron2](https://github.com/facebookresearch/detectron2/tree/master/configs/new_baselines). + +## Results and Models + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :------: | :-----: | :-----: | :------: | :------------: | :----: | :-----: | :--------------------------------------------------------------------------------: | :----------------------: | +| R-50-FPN | pytorch | 50e | | | | | [config](./mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_lsj-50e_coco.py) | [model](<>) \| [log](<>) | +| R-50-FPN | pytorch | 100e | | | | | [config](./mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_lsj-100e_coco.py) | [model](<>) \| [log](<>) | +| R-50-FPN | caffe | 100e | | | 44.7 | 40.4 | [config](./mask-rcnn_r50-caffe_fpn_rpn-2conv_4conv1fc_syncbn-all_lsj-100e_coco.py) | [model](<>) \| [log](<>) | +| R-50-FPN | caffe | 400e | | | | | [config](./mask-rcnn_r50-caffe_fpn_rpn-2conv_4conv1fc_syncbn-all_lsj-400e_coco.py) | [model](<>) \| [log](<>) | + +## Notice + +When using large-scale jittering, there are sometimes empty proposals in the box and mask heads during training. +This requires MMSyncBN that allows empty tensors. Therefore, please use mmcv-full>=1.3.14 to train models supported in this directory. diff --git a/mmdetection/configs/strong_baselines/mask-rcnn_r50-caffe_fpn_rpn-2conv_4conv1fc_syncbn-all_amp-lsj-100e_coco.py b/mmdetection/configs/strong_baselines/mask-rcnn_r50-caffe_fpn_rpn-2conv_4conv1fc_syncbn-all_amp-lsj-100e_coco.py new file mode 100644 index 00000000..b004d740 --- /dev/null +++ b/mmdetection/configs/strong_baselines/mask-rcnn_r50-caffe_fpn_rpn-2conv_4conv1fc_syncbn-all_amp-lsj-100e_coco.py @@ -0,0 +1,4 @@ +_base_ = 'mask-rcnn_r50-caffe_fpn_rpn-2conv_4conv1fc_syncbn-all_lsj-100e_coco.py' # noqa + +# Enable automatic-mixed-precision training with AmpOptimWrapper. +optim_wrapper = dict(type='AmpOptimWrapper') diff --git a/mmdetection/configs/strong_baselines/mask-rcnn_r50-caffe_fpn_rpn-2conv_4conv1fc_syncbn-all_lsj-100e_coco.py b/mmdetection/configs/strong_baselines/mask-rcnn_r50-caffe_fpn_rpn-2conv_4conv1fc_syncbn-all_lsj-100e_coco.py new file mode 100644 index 00000000..70e92a82 --- /dev/null +++ b/mmdetection/configs/strong_baselines/mask-rcnn_r50-caffe_fpn_rpn-2conv_4conv1fc_syncbn-all_lsj-100e_coco.py @@ -0,0 +1,68 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../common/lsj-100e_coco-instance.py' +] +image_size = (1024, 1024) +batch_augments = [ + dict(type='BatchFixedSizePad', size=image_size, pad_mask=True) +] +norm_cfg = dict(type='SyncBN', requires_grad=True) +# Use MMSyncBN that handles empty tensor in head. It can be changed to +# SyncBN after https://github.com/pytorch/pytorch/issues/36530 is fixed +head_norm_cfg = dict(type='MMSyncBN', requires_grad=True) +model = dict( + # use caffe norm + data_preprocessor=dict( + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False, + + # pad_size_divisor=32 is unnecessary in training but necessary + # in testing. + pad_size_divisor=32, + batch_augments=batch_augments), + backbone=dict( + frozen_stages=-1, + norm_eval=False, + norm_cfg=norm_cfg, + init_cfg=None, + style='caffe'), + neck=dict(norm_cfg=norm_cfg), + rpn_head=dict(num_convs=2), + roi_head=dict( + bbox_head=dict( + type='Shared4Conv1FCBBoxHead', + conv_out_channels=256, + norm_cfg=head_norm_cfg), + mask_head=dict(norm_cfg=head_norm_cfg))) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='RandomResize', + scale=image_size, + ratio_range=(0.1, 2.0), + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=image_size, + recompute_bbox=True, + allow_negative_crop=True), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +# Use RepeatDataset to speed up training +train_dataloader = dict(dataset=dict(dataset=dict(pipeline=train_pipeline))) diff --git a/mmdetection/configs/strong_baselines/mask-rcnn_r50-caffe_fpn_rpn-2conv_4conv1fc_syncbn-all_lsj-400e_coco.py b/mmdetection/configs/strong_baselines/mask-rcnn_r50-caffe_fpn_rpn-2conv_4conv1fc_syncbn-all_lsj-400e_coco.py new file mode 100644 index 00000000..cb64c9b6 --- /dev/null +++ b/mmdetection/configs/strong_baselines/mask-rcnn_r50-caffe_fpn_rpn-2conv_4conv1fc_syncbn-all_lsj-400e_coco.py @@ -0,0 +1,20 @@ +_base_ = './mask-rcnn_r50-caffe_fpn_rpn-2conv_4conv1fc_syncbn-all_lsj-100e_coco.py' # noqa + +# Use RepeatDataset to speed up training +# change repeat time from 4 (for 100 epochs) to 16 (for 400 epochs) +train_dataloader = dict(dataset=dict(times=4 * 4)) +param_scheduler = [ + dict( + type='LinearLR', + start_factor=0.067, + by_epoch=False, + begin=0, + end=500 * 4), + dict( + type='MultiStepLR', + begin=0, + end=12, + by_epoch=True, + milestones=[22, 24], + gamma=0.1) +] diff --git a/mmdetection/configs/strong_baselines/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_amp-lsj-100e_coco.py b/mmdetection/configs/strong_baselines/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_amp-lsj-100e_coco.py new file mode 100644 index 00000000..7fab2c72 --- /dev/null +++ b/mmdetection/configs/strong_baselines/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_amp-lsj-100e_coco.py @@ -0,0 +1,4 @@ +_base_ = 'mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_lsj-100e_coco.py' + +# Enable automatic-mixed-precision training with AmpOptimWrapper. +optim_wrapper = dict(type='AmpOptimWrapper') diff --git a/mmdetection/configs/strong_baselines/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_lsj-100e_coco.py b/mmdetection/configs/strong_baselines/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_lsj-100e_coco.py new file mode 100644 index 00000000..8e06587f --- /dev/null +++ b/mmdetection/configs/strong_baselines/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_lsj-100e_coco.py @@ -0,0 +1,30 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../common/lsj-100e_coco-instance.py' +] + +image_size = (1024, 1024) +batch_augments = [ + dict(type='BatchFixedSizePad', size=image_size, pad_mask=True) +] +norm_cfg = dict(type='SyncBN', requires_grad=True) +# Use MMSyncBN that handles empty tensor in head. It can be changed to +# SyncBN after https://github.com/pytorch/pytorch/issues/36530 is fixed +head_norm_cfg = dict(type='MMSyncBN', requires_grad=True) +model = dict( + # the model is trained from scratch, so init_cfg is None + data_preprocessor=dict( + # pad_size_divisor=32 is unnecessary in training but necessary + # in testing. + pad_size_divisor=32, + batch_augments=batch_augments), + backbone=dict( + frozen_stages=-1, norm_eval=False, norm_cfg=norm_cfg, init_cfg=None), + neck=dict(norm_cfg=norm_cfg), + rpn_head=dict(num_convs=2), # leads to 0.1+ mAP + roi_head=dict( + bbox_head=dict( + type='Shared4Conv1FCBBoxHead', + conv_out_channels=256, + norm_cfg=head_norm_cfg), + mask_head=dict(norm_cfg=head_norm_cfg))) diff --git a/mmdetection/configs/strong_baselines/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_lsj-50e_coco.py b/mmdetection/configs/strong_baselines/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_lsj-50e_coco.py new file mode 100644 index 00000000..6621d28c --- /dev/null +++ b/mmdetection/configs/strong_baselines/mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_lsj-50e_coco.py @@ -0,0 +1,5 @@ +_base_ = 'mask-rcnn_r50_fpn_rpn-2conv_4conv1fc_syncbn-all_lsj-100e_coco.py' + +# Use RepeatDataset to speed up training +# change repeat time from 4 (for 100 epochs) to 2 (for 50 epochs) +train_dataloader = dict(dataset=dict(times=2)) diff --git a/mmdetection/configs/strong_baselines/metafile.yml b/mmdetection/configs/strong_baselines/metafile.yml new file mode 100644 index 00000000..f72c07e6 --- /dev/null +++ b/mmdetection/configs/strong_baselines/metafile.yml @@ -0,0 +1,24 @@ +Models: + - Name: mask-rcnn_r50-caffe_fpn_rpn-2conv_4conv1fc_syncbn-all_lsj-100e_coco + In Collection: Mask R-CNN + Config: configs/strong_baselines/mask-rcnn_r50-caffe_fpn_rpn-2conv_4conv1fc_syncbn-all_lsj-100e_coco.py + Metadata: + Epochs: 100 + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + - LSJ + Training Resources: 8x V100 GPUs + Architecture: + - ResNet + - FPN + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.7 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + box AP: 40.4 diff --git a/mmdetection/configs/strongsort/README.md b/mmdetection/configs/strongsort/README.md new file mode 100644 index 00000000..8e08413c --- /dev/null +++ b/mmdetection/configs/strongsort/README.md @@ -0,0 +1,108 @@ +# StrongSORT: Make DeepSORT Great Again + +## Abstract + + + +Existing Multi-Object Tracking (MOT) methods can be roughly classified as tracking-by-detection and joint-detection-association paradigms. Although the latter has elicited more attention and demonstrates comparable performance relative to the former, we claim that the tracking-by-detection paradigm is still the optimal solution in terms of tracking accuracy. In this paper, we revisit the classic tracker DeepSORT and upgrade it from various aspects, i.e., detection, embedding and association. The resulting tracker, called StrongSORT, sets new HOTA and IDF1 records on MOT17 and MOT20. We also present two lightweight and plug-and-play algorithms to further refine the tracking results. Firstly, an appearance-free link model (AFLink) is proposed to associate short tracklets into complete trajectories. To the best of our knowledge, this is the first global link model without appearance information. Secondly, we propose Gaussian-smoothed interpolation (GSI) to compensate for missing detections. Instead of ignoring motion information like linear interpolation, GSI is based on the Gaussian process regression algorithm and can achieve more accurate localizations. Moreover, AFLink and GSI can be plugged into various trackers with a negligible extra computational cost (591.9 and 140.9 Hz, respectively, on MOT17). By integrating StrongSORT with the two algorithms, the final tracker StrongSORT++ ranks first on MOT17 and MOT20 in terms of HOTA and IDF1 metrics and surpasses the second-place one by 1.3 - 2.2. Code will be released soon. + + + +
    + +
    + +## Citation + + + +```latex +@article{du2022strongsort, + title={Strongsort: Make deepsort great again}, + author={Du, Yunhao and Song, Yang and Yang, Bo and Zhao, Yanyun}, + journal={arXiv preprint arXiv:2202.13514}, + year={2022} +} +``` + +## Results and models on MOT17 + +| Method | Detector | ReID | Train Set | Test Set | Public | Inf time (fps) | HOTA | MOTA | IDF1 | FP | FN | IDSw. | Config | Download | +| :----------: | :------: | :--: | :---------------------------: | :------------: | :----: | :------------: | :--: | :--: | :--: | :---: | :---: | :---: | :----------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| StrongSORT++ | YOLOX-X | R50 | CrowdHuman + MOT17-half-train | MOT17-half-val | N | - | 70.9 | 78.4 | 83.3 | 15237 | 19035 | 582 | [config](strongsort_yolox_x_8xb4-80e_crowdhuman-mot17halftrain_test-mot17halfval.py) | [detector](https://download.openmmlab.com/mmtracking/mot/strongsort/mot_dataset/yolox_x_crowdhuman_mot17-private-half_20220812_192036-b6c9ce9a.pth) [reid](https://download.openmmlab.com/mmtracking/mot/reid/reid_r50_6e_mot17-4bf6b63d.pth) [AFLink](https://download.openmmlab.com/mmtracking/mot/strongsort/mot_dataset/aflink_motchallenge_20220812_190310-a7578ad3.pth) | + +## Results and models on MOT20 + +| Method | Detector | ReID | Train Set | Test Set | Public | Inf time (fps) | HOTA | MOTA | IDF1 | FP | FN | IDSw. | Config | Download | +| :----------: | :------: | :--: | :----------------------: | :--------: | :----: | :------------: | :--: | :--: | :--: | :---: | :---: | :---: | :---------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| StrongSORT++ | YOLOX-X | R50 | CrowdHuman + MOT20-train | MOT20-test | N | - | 62.9 | 75.5 | 77.3 | 29043 | 96155 | 1640 | [config](strongsort_yolox_x_8xb4-80e_crowdhuman-mot20train_test-mot20test.py) | [detector](https://download.openmmlab.com/mmtracking/mot/strongsort/mot_dataset/yolox_x_crowdhuman_mot20-private_20220812_192123-77c014de.pth) [reid](https://download.openmmlab.com/mmtracking/mot/reid/reid_r50_6e_mot20_20210803_212426-c83b1c01.pth) [AFLink](https://download.openmmlab.com/mmtracking/mot/strongsort/mot_dataset/aflink_motchallenge_20220812_190310-a7578ad3.pth) | + +## Get started + +### 1. Development Environment Setup + +Tracking Development Environment Setup can refer to this [document](../../docs/en/get_started.md). + +### 2. Dataset Prepare + +Tracking Dataset Prepare can refer to this [document](../../docs/en/user_guides/tracking_dataset_prepare.md). + +### 3. Training + +We implement StrongSORT with independent detector and ReID models. +Note that, due to the influence of parameters such as learning rate in default configuration file, +we recommend using 8 GPUs for training in order to reproduce accuracy. + +You can train the detector as follows. + +```shell script +# Training YOLOX-X on crowdhuman and mot17-half-train dataset with following command. +# The number after config file represents the number of GPUs used. Here we use 8 GPUs. +bash tools/dist_train.sh configs/det/yolox_x_8xb4-80e_crowdhuman-mot17halftrain_test-mot17halfval.py 8 +``` + +And you can train the ReID model as follows. + +```shell script +# Training ReID model on mot17-train80 dataset with following command. +# The number after config file represents the number of GPUs used. Here we use 8 GPUs. +bash tools/dist_train.sh configs/reid/reid_r50_8xb32-6e_mot17train80_test-mot17val20.py 8 +``` + +If you want to know about more detailed usage of `train.py/dist_train.sh/slurm_train.sh`, +please refer to this [document](../../docs/en/user_guides/tracking_train_test.md). + +### 4. Testing and evaluation + +**2.1 Example on MOTxx-halfval dataset** + +```shell script +# Example 1: Test on motXX-half-val set. +# The number after config file represents the number of GPUs used. Here we use 8 GPUs. +bash tools/dist_test_tracking.sh configs/strongsort/strongsort_yolox_x_8xb4-80e_crowdhuman-mot17halftrain_test-mot17halfval.py 8 --detector ${CHECKPOINT_PATH} --reid ${CHECKPOINT_PATH} +``` + +**2.2 Example on MOTxx-test dataset** + +If you want to get the results of the [MOT Challenge](https://motchallenge.net/) test set, +please use the following command to generate result files that can be used for submission. +It will be stored in `./mot_20_test_res`, you can modify the saved path in `test_evaluator` of the config. + +```shell script +# Example 2: Test on motxx-test set +# The number after config file represents the number of GPUs used +bash tools/dist_test_tracking.sh configs/strongsort/strongsort_yolox_x_8xb4-80e_crowdhuman-mot20train_test-mot20test.py 8 --detector ${CHECKPOINT_PATH} --reid ${CHECKPOINT_PATH} +``` + +If you want to know about more detailed usage of `test_tracking.py/dist_test_tracking.sh/slurm_test_tracking.sh`, +please refer to this [document](../../docs/en/user_guides/tracking_train_test.md). + +### 3.Inference + +Use a single GPU to predict a video and save it as a video. + +```shell +python demo/mot_demo.py demo/demo_mot.mp4 configs/strongsort/strongsort_yolox_x_8xb4-80e_crowdhuman-mot17halftrain_test-mot17halfval.py --detector ${CHECKPOINT_FILE} --reid ${CHECKPOINT_PATH} --out mot.mp4 +``` + +If you want to know about more detailed usage of `mot_demo.py`, please refer to this [document](../../docs/en/user_guides/tracking_inference.md). diff --git a/mmdetection/configs/strongsort/metafile.yml b/mmdetection/configs/strongsort/metafile.yml new file mode 100644 index 00000000..08a564b7 --- /dev/null +++ b/mmdetection/configs/strongsort/metafile.yml @@ -0,0 +1,48 @@ +Collections: + - Name: StrongSORT++ + Metadata: + Training Techniques: + - SGD with Momentum + Training Resources: 8x V100 GPUs + Architecture: + - ResNet + - YOLOX + Paper: + URL: https://arxiv.org/abs/2202.13514 + Title: "StrongSORT: Make DeepSORT Great Again" + README: configs/strongsort/README.md + +Models: + - Name: strongsort_yolox_x_8xb4-80e_crowdhuman-mot17halftrain_test-mot17halfval + In Collection: StrongSORT++ + Config: configs/strongsort/strongsort_yolox_x_8xb4-80e_crowdhuman-mot17halftrain_test-mot17halfval.py + Metadata: + Training Data: CrowdHuman + MOT17-half-train + Results: + - Task: Multiple Object Tracking + Dataset: MOT17-half-val + Metrics: + MOTA: 78.3 + IDF1: 83.2 + HOTA: 70.9 + Weights: + - https://download.openmmlab.com/mmtracking/mot/strongsort/mot_dataset/yolox_x_crowdhuman_mot17-private-half_20220812_192036-b6c9ce9a.pth + - https://download.openmmlab.com/mmtracking/mot/reid/reid_r50_6e_mot17-4bf6b63d.pth + - https://download.openmmlab.com/mmtracking/mot/strongsort/mot_dataset/aflink_motchallenge_20220812_190310-a7578ad3.pth + + - Name: strongsort_yolox_x_8xb4-80e_crowdhuman-mot20train_test-mot20test + In Collection: StrongSORT++ + Config: configs/strongsort/strongsort_yolox_x_8xb4-80e_crowdhuman-mot20train_test-mot20test.py + Metadata: + Training Data: CrowdHuman + MOT20-train + Results: + - Task: Multiple Object Tracking + Dataset: MOT20-test + Metrics: + MOTA: 75.5 + IDF1: 77.3 + HOTA: 62.9 + Weights: + - https://download.openmmlab.com/mmtracking/mot/strongsort/mot_dataset/yolox_x_crowdhuman_mot20-private_20220812_192123-77c014de.pth + - https://download.openmmlab.com/mmtracking/mot/reid/reid_r50_6e_mot20_20210803_212426-c83b1c01.pth + - https://download.openmmlab.com/mmtracking/mot/strongsort/mot_dataset/aflink_motchallenge_20220812_190310-a7578ad3.pth diff --git a/mmdetection/configs/strongsort/strongsort_yolox_x_8xb4-80e_crowdhuman-mot17halftrain_test-mot17halfval.py b/mmdetection/configs/strongsort/strongsort_yolox_x_8xb4-80e_crowdhuman-mot17halftrain_test-mot17halfval.py new file mode 100644 index 00000000..532e2aee --- /dev/null +++ b/mmdetection/configs/strongsort/strongsort_yolox_x_8xb4-80e_crowdhuman-mot17halftrain_test-mot17halfval.py @@ -0,0 +1,130 @@ +_base_ = [ + './yolox_x_8xb4-80e_crowdhuman-mot17halftrain_test-mot17halfval.py', # noqa: E501 +] + +dataset_type = 'MOTChallengeDataset' +detector = _base_.model +detector.pop('data_preprocessor') +del _base_.model + +model = dict( + type='StrongSORT', + data_preprocessor=dict( + type='TrackDataPreprocessor', + pad_size_divisor=32, + batch_augments=[ + dict( + type='BatchSyncRandomResize', + random_size_range=(576, 1024), + size_divisor=32, + interval=10) + ]), + detector=detector, + reid=dict( + type='BaseReID', + data_preprocessor=dict(type='mmpretrain.ClsDataPreprocessor'), + backbone=dict( + type='mmpretrain.ResNet', + depth=50, + num_stages=4, + out_indices=(3, ), + style='pytorch'), + neck=dict(type='GlobalAveragePooling', kernel_size=(8, 4), stride=1), + head=dict( + type='LinearReIDHead', + num_fcs=1, + in_channels=2048, + fc_channels=1024, + out_channels=128, + num_classes=380, + loss_cls=dict(type='mmpretrain.CrossEntropyLoss', loss_weight=1.0), + loss_triplet=dict(type='TripletLoss', margin=0.3, loss_weight=1.0), + norm_cfg=dict(type='BN1d'), + act_cfg=dict(type='ReLU'))), + cmc=dict( + type='CameraMotionCompensation', + warp_mode='cv2.MOTION_EUCLIDEAN', + num_iters=100, + stop_eps=0.00001), + tracker=dict( + type='StrongSORTTracker', + motion=dict(type='KalmanFilter', center_only=False, use_nsa=True), + obj_score_thr=0.6, + reid=dict( + num_samples=None, + img_scale=(256, 128), + img_norm_cfg=dict( + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + to_rgb=True), + match_score_thr=0.3, + motion_weight=0.02, + ), + match_iou_thr=0.7, + momentums=dict(embeds=0.1, ), + num_tentatives=2, + num_frames_retain=100), + postprocess_model=dict( + type='AppearanceFreeLink', + checkpoint= # noqa: E251 + 'https://download.openmmlab.com/mmtracking/mot/strongsort/mot_dataset/aflink_motchallenge_20220812_190310-a7578ad3.pth', # noqa: E501 + temporal_threshold=(0, 30), + spatial_threshold=50, + confidence_threshold=0.95, + )) + +train_pipeline = None +test_pipeline = [ + dict( + type='TransformBroadcaster', + transforms=[ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='Resize', scale=_base_.img_scale, keep_ratio=True), + dict( + type='Pad', + size_divisor=32, + pad_val=dict(img=(114.0, 114.0, 114.0))), + dict(type='LoadTrackAnnotations'), + ]), + dict(type='PackTrackInputs') +] + +train_dataloader = None +val_dataloader = dict( + # Now StrongSORT only support video_based sampling + sampler=dict(type='DefaultSampler', shuffle=False, round_up=False), + dataset=dict( + _delete_=True, + type=dataset_type, + data_root=_base_.data_root, + ann_file='annotations/half-val_cocoformat.json', + data_prefix=dict(img_path='train'), + # when you evaluate track performance, you need to remove metainfo + test_mode=True, + pipeline=test_pipeline)) +test_dataloader = val_dataloader + +train_cfg = None +optim_wrapper = None + +# evaluator +val_evaluator = dict( + _delete_=True, + type='MOTChallengeMetric', + metric=['HOTA', 'CLEAR', 'Identity'], + # use_postprocess to support AppearanceFreeLink in val_evaluator + use_postprocess=True, + postprocess_tracklet_cfg=[ + dict( + type='InterpolateTracklets', + min_num_frames=5, + max_num_frames=20, + use_gsi=True, + smooth_tau=10) + ]) +test_evaluator = val_evaluator + +default_hooks = dict(logger=dict(type='LoggerHook', interval=1)) + +del _base_.param_scheduler +del _base_.custom_hooks diff --git a/mmdetection/configs/strongsort/strongsort_yolox_x_8xb4-80e_crowdhuman-mot20train_test-mot20test.py b/mmdetection/configs/strongsort/strongsort_yolox_x_8xb4-80e_crowdhuman-mot20train_test-mot20test.py new file mode 100644 index 00000000..eab97063 --- /dev/null +++ b/mmdetection/configs/strongsort/strongsort_yolox_x_8xb4-80e_crowdhuman-mot20train_test-mot20test.py @@ -0,0 +1,44 @@ +_base_ = [ + './strongsort_yolox_x_8xb4-80e_crowdhuman-mot17halftrain' + '_test-mot17halfval.py' +] + +img_scale = (1600, 896) # width, height + +model = dict( + data_preprocessor=dict( + type='TrackDataPreprocessor', + pad_size_divisor=32, + batch_augments=[ + dict(type='BatchSyncRandomResize', random_size_range=(640, 1152)) + ])) + +test_pipeline = [ + dict( + type='TransformBroadcaster', + transforms=[ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='Resize', scale=img_scale, keep_ratio=True), + dict( + type='Pad', + size_divisor=32, + pad_val=dict(img=(114.0, 114.0, 114.0))), + dict(type='LoadTrackAnnotations'), + ]), + dict(type='PackTrackInputs') +] + +val_dataloader = dict( + dataset=dict( + data_root='data/MOT17', + ann_file='annotations/train_cocoformat.json', + data_prefix=dict(img_path='train'), + pipeline=test_pipeline)) +test_dataloader = dict( + dataset=dict( + data_root='data/MOT20', + ann_file='annotations/test_cocoformat.json', + data_prefix=dict(img_path='test'), + pipeline=test_pipeline)) + +test_evaluator = dict(format_only=True, outfile_prefix='./mot_20_test_res') diff --git a/mmdetection/configs/strongsort/yolox_x_8xb4-80e_crowdhuman-mot17halftrain_test-mot17halfval.py b/mmdetection/configs/strongsort/yolox_x_8xb4-80e_crowdhuman-mot17halftrain_test-mot17halfval.py new file mode 100644 index 00000000..59a52e43 --- /dev/null +++ b/mmdetection/configs/strongsort/yolox_x_8xb4-80e_crowdhuman-mot17halftrain_test-mot17halfval.py @@ -0,0 +1,188 @@ +_base_ = ['../yolox/yolox_x_8xb8-300e_coco.py'] + +data_root = 'data/MOT17/' + +img_scale = (1440, 800) # width, height +batch_size = 4 + +# model settings +model = dict( + bbox_head=dict(num_classes=1), + test_cfg=dict(nms=dict(iou_threshold=0.7)), + init_cfg=dict( + type='Pretrained', + checkpoint= # noqa: E251 + 'https://download.openmmlab.com/mmdetection/v2.0/yolox/yolox_x_8x8_300e_coco/yolox_x_8x8_300e_coco_20211126_140254-1ef88d67.pth' # noqa: E501 + )) + +train_pipeline = [ + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + bbox_clip_border=False), + dict( + type='RandomAffine', + scaling_ratio_range=(0.1, 2), + border=(-img_scale[0] // 2, -img_scale[1] // 2), + bbox_clip_border=False), + dict( + type='MixUp', + img_scale=img_scale, + ratio_range=(0.8, 1.6), + pad_val=114.0, + bbox_clip_border=False), + dict(type='YOLOXHSVRandomAug'), + dict(type='RandomFlip', prob=0.5), + dict( + type='Resize', + scale=img_scale, + keep_ratio=True, + clip_object_border=False), + dict(type='Pad', size_divisor=32, pad_val=dict(img=(114.0, 114.0, 114.0))), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1, 1), keep_empty=False), + dict(type='PackDetInputs') +] + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='Resize', scale=img_scale, keep_ratio=True), + dict(type='Pad', size_divisor=32, pad_val=dict(img=(114.0, 114.0, 114.0))), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict( + _delete_=True, + batch_size=batch_size, + num_workers=4, + persistent_workers=True, + pin_memory=True, + sampler=dict(type='DefaultSampler', shuffle=True), + dataset=dict( + type='MultiImageMixDataset', + dataset=dict( + type='ConcatDataset', + datasets=[ + dict( + type='CocoDataset', + data_root=data_root, + ann_file='annotations/half-train_cocoformat.json', + data_prefix=dict(img='train'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + metainfo=dict(classes=('pedestrian', )), + pipeline=[ + dict( + type='LoadImageFromFile', + backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + ]), + dict( + type='CocoDataset', + data_root='data/crowdhuman', + ann_file='annotations/crowdhuman_train.json', + data_prefix=dict(img='train'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + metainfo=dict(classes=('pedestrian', )), + pipeline=[ + dict( + type='LoadImageFromFile', + backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + ]), + dict( + type='CocoDataset', + data_root='data/crowdhuman', + ann_file='annotations/crowdhuman_val.json', + data_prefix=dict(img='val'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + metainfo=dict(classes=('pedestrian', )), + pipeline=[ + dict( + type='LoadImageFromFile', + backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + ]), + ]), + pipeline=train_pipeline)) + +val_dataloader = dict( + batch_size=1, + num_workers=2, + dataset=dict( + data_root=data_root, + ann_file='annotations/half-val_cocoformat.json', + data_prefix=dict(img='train'), + metainfo=dict(classes=('pedestrian', )), + pipeline=test_pipeline)) +test_dataloader = val_dataloader + +# training settings +max_epochs = 80 +num_last_epochs = 10 +interval = 5 + +train_cfg = dict(max_epochs=max_epochs, val_begin=75, val_interval=1) + +# optimizer +# default 8 gpu +base_lr = 0.001 / 8 * batch_size +optim_wrapper = dict(optimizer=dict(lr=base_lr)) + +# learning rate +param_scheduler = [ + dict( + type='QuadraticWarmupLR', + by_epoch=True, + begin=0, + end=1, + convert_to_iter_based=True), + dict( + type='CosineAnnealingLR', + eta_min=base_lr * 0.05, + begin=1, + T_max=max_epochs - num_last_epochs, + end=max_epochs - num_last_epochs, + by_epoch=True, + convert_to_iter_based=True), + dict( + type='ConstantLR', + by_epoch=True, + factor=1, + begin=max_epochs - num_last_epochs, + end=max_epochs, + ) +] + +default_hooks = dict( + checkpoint=dict( + interval=1, + max_keep_ckpts=5 # only keep latest 5 checkpoints + )) + +custom_hooks = [ + dict( + type='YOLOXModeSwitchHook', + num_last_epochs=num_last_epochs, + priority=48), + dict(type='SyncNormHook', priority=48), + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + priority=49) +] + +# evaluator +val_evaluator = dict( + ann_file=data_root + 'annotations/half-val_cocoformat.json', + format_only=False) +test_evaluator = val_evaluator + +del _base_.tta_model +del _base_.tta_pipeline +del _base_.train_dataset diff --git a/mmdetection/configs/strongsort/yolox_x_8xb4-80e_crowdhuman-mot20train_test-mot20test.py b/mmdetection/configs/strongsort/yolox_x_8xb4-80e_crowdhuman-mot20train_test-mot20test.py new file mode 100644 index 00000000..d4eb3cb2 --- /dev/null +++ b/mmdetection/configs/strongsort/yolox_x_8xb4-80e_crowdhuman-mot20train_test-mot20test.py @@ -0,0 +1,108 @@ +_base_ = ['./yolox_x_8xb4-80e_crowdhuman-mot17halftrain_test-mot17halfval.py'] + +data_root = 'data/MOT20/' + +img_scale = (1600, 896) # width, height + +# model settings +model = dict( + data_preprocessor=dict(batch_augments=[ + dict(type='BatchSyncRandomResize', random_size_range=(640, 1152)) + ])) + +train_pipeline = [ + dict( + type='Mosaic', + img_scale=img_scale, + pad_val=114.0, + bbox_clip_border=True), + dict( + type='RandomAffine', + scaling_ratio_range=(0.1, 2), + border=(-img_scale[0] // 2, -img_scale[1] // 2), + bbox_clip_border=True), + dict( + type='MixUp', + img_scale=img_scale, + ratio_range=(0.8, 1.6), + pad_val=114.0, + bbox_clip_border=True), + dict(type='YOLOXHSVRandomAug'), + dict(type='RandomFlip', prob=0.5), + dict( + type='Resize', + scale=img_scale, + keep_ratio=True, + clip_object_border=True), + dict(type='Pad', size_divisor=32, pad_val=dict(img=(114.0, 114.0, 114.0))), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1, 1), keep_empty=False), + dict(type='PackDetInputs') +] + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='Resize', scale=img_scale, keep_ratio=True), + dict(type='Pad', size_divisor=32, pad_val=dict(img=(114.0, 114.0, 114.0))), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict( + dataset=dict( + type='MultiImageMixDataset', + dataset=dict( + type='ConcatDataset', + datasets=[ + dict( + type='CocoDataset', + data_root=data_root, + ann_file='annotations/train_cocoformat.json', + data_prefix=dict(img='train'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + metainfo=dict(classes=('pedestrian', )), + pipeline=[ + dict( + type='LoadImageFromFile', + backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + ]), + dict( + type='CocoDataset', + data_root='data/crowdhuman', + ann_file='annotations/crowdhuman_train.json', + data_prefix=dict(img='train'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + metainfo=dict(classes=('pedestrian', )), + pipeline=[ + dict( + type='LoadImageFromFile', + backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + ]), + dict( + type='CocoDataset', + data_root='data/crowdhuman', + ann_file='annotations/crowdhuman_val.json', + data_prefix=dict(img='val'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + metainfo=dict(classes=('pedestrian', )), + pipeline=[ + dict( + type='LoadImageFromFile', + backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + ]), + ]), + pipeline=train_pipeline)) + +val_dataloader = dict( + dataset=dict( + data_root='data/MOT17', ann_file='annotations/train_cocoformat.json')) +test_dataloader = val_dataloader + +# evaluator +val_evaluator = dict(ann_file='data/MOT17/annotations/train_cocoformat.json') +test_evaluator = val_evaluator diff --git a/mmdetection/configs/swin/README.md b/mmdetection/configs/swin/README.md new file mode 100644 index 00000000..99bcf6ed --- /dev/null +++ b/mmdetection/configs/swin/README.md @@ -0,0 +1,41 @@ +# Swin + +> [Swin Transformer: Hierarchical Vision Transformer using Shifted Windows](https://arxiv.org/abs/2103.14030) + + + +## Abstract + +This paper presents a new vision Transformer, called Swin Transformer, that capably serves as a general-purpose backbone for computer vision. Challenges in adapting Transformer from language to vision arise from differences between the two domains, such as large variations in the scale of visual entities and the high resolution of pixels in images compared to words in text. To address these differences, we propose a hierarchical Transformer whose representation is computed with Shifted windows. The shifted windowing scheme brings greater efficiency by limiting self-attention computation to non-overlapping local windows while also allowing for cross-window connection. This hierarchical architecture has the flexibility to model at various scales and has linear computational complexity with respect to image size. These qualities of Swin Transformer make it compatible with a broad range of vision tasks, including image classification (87.3 top-1 accuracy on ImageNet-1K) and dense prediction tasks such as object detection (58.7 box AP and 51.1 mask AP on COCO test-dev) and semantic segmentation (53.5 mIoU on ADE20K val). Its performance surpasses the previous state-of-the-art by a large margin of +2.7 box AP and +2.6 mask AP on COCO, and +3.2 mIoU on ADE20K, demonstrating the potential of Transformer-based models as vision backbones. The hierarchical design and the shifted window approach also prove beneficial for all-MLP architectures. + +
    + +
    + +## Results and Models + +### Mask R-CNN + +| Backbone | Pretrain | Lr schd | Multi-scale crop | FP16 | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | +| :------: | :---------: | :-----: | :--------------: | :--: | :------: | :------------: | :----: | :-----: | :-----------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| Swin-T | ImageNet-1K | 1x | no | no | 7.6 | | 42.7 | 39.3 | [config](./mask-rcnn_swin-t-p4-w7_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/swin/mask_rcnn_swin-t-p4-w7_fpn_1x_coco/mask_rcnn_swin-t-p4-w7_fpn_1x_coco_20210902_120937-9d6b7cfa.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/swin/mask_rcnn_swin-t-p4-w7_fpn_1x_coco/mask_rcnn_swin-t-p4-w7_fpn_1x_coco_20210902_120937.log.json) | +| Swin-T | ImageNet-1K | 3x | yes | no | 10.2 | | 46.0 | 41.6 | [config](./mask-rcnn_swin-t-p4-w7_fpn_ms-crop-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/swin/mask_rcnn_swin-t-p4-w7_fpn_ms-crop-3x_coco/mask_rcnn_swin-t-p4-w7_fpn_ms-crop-3x_coco_20210906_131725-bacf6f7b.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/swin/mask_rcnn_swin-t-p4-w7_fpn_ms-crop-3x_coco/mask_rcnn_swin-t-p4-w7_fpn_ms-crop-3x_coco_20210906_131725.log.json) | +| Swin-T | ImageNet-1K | 3x | yes | yes | 7.8 | | 46.0 | 41.7 | [config](./mask-rcnn_swin-t-p4-w7_fpn_amp-ms-crop-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/swin/mask_rcnn_swin-t-p4-w7_fpn_fp16_ms-crop-3x_coco/mask_rcnn_swin-t-p4-w7_fpn_fp16_ms-crop-3x_coco_20210908_165006-90a4008c.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/swin/mask_rcnn_swin-t-p4-w7_fpn_fp16_ms-crop-3x_coco/mask_rcnn_swin-t-p4-w7_fpn_fp16_ms-crop-3x_coco_20210908_165006.log.json) | +| Swin-S | ImageNet-1K | 3x | yes | yes | 11.9 | | 48.2 | 43.2 | [config](./mask-rcnn_swin-s-p4-w7_fpn_amp-ms-crop-3x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/swin/mask_rcnn_swin-s-p4-w7_fpn_fp16_ms-crop-3x_coco/mask_rcnn_swin-s-p4-w7_fpn_fp16_ms-crop-3x_coco_20210903_104808-b92c91f1.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/swin/mask_rcnn_swin-s-p4-w7_fpn_fp16_ms-crop-3x_coco/mask_rcnn_swin-s-p4-w7_fpn_fp16_ms-crop-3x_coco_20210903_104808.log.json) | + +### Notice + +Please follow the example +of `retinanet_swin-t-p4-w7_fpn_1x_coco.py` when you want to combine Swin Transformer with +the one-stage detector. Because there is a layer norm at the outs of Swin Transformer, you must set `start_level` as 0 in FPN, so we have to set the `out_indices` of backbone as `[1,2,3]`. + +## Citation + +```latex +@article{liu2021Swin, + title={Swin Transformer: Hierarchical Vision Transformer using Shifted Windows}, + author={Liu, Ze and Lin, Yutong and Cao, Yue and Hu, Han and Wei, Yixuan and Zhang, Zheng and Lin, Stephen and Guo, Baining}, + journal={arXiv preprint arXiv:2103.14030}, + year={2021} +} +``` diff --git a/mmdetection/configs/swin/mask-rcnn_swin-s-p4-w7_fpn_amp-ms-crop-3x_coco.py b/mmdetection/configs/swin/mask-rcnn_swin-s-p4-w7_fpn_amp-ms-crop-3x_coco.py new file mode 100644 index 00000000..4a3e8ad9 --- /dev/null +++ b/mmdetection/configs/swin/mask-rcnn_swin-s-p4-w7_fpn_amp-ms-crop-3x_coco.py @@ -0,0 +1,6 @@ +_base_ = './mask-rcnn_swin-t-p4-w7_fpn_amp-ms-crop-3x_coco.py' +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_small_patch4_window7_224.pth' # noqa +model = dict( + backbone=dict( + depths=[2, 2, 18, 2], + init_cfg=dict(type='Pretrained', checkpoint=pretrained))) diff --git a/mmdetection/configs/swin/mask-rcnn_swin-t-p4-w7_fpn_1x_coco.py b/mmdetection/configs/swin/mask-rcnn_swin-t-p4-w7_fpn_1x_coco.py new file mode 100644 index 00000000..5471caa1 --- /dev/null +++ b/mmdetection/configs/swin/mask-rcnn_swin-t-p4-w7_fpn_1x_coco.py @@ -0,0 +1,60 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_tiny_patch4_window7_224.pth' # noqa +model = dict( + type='MaskRCNN', + backbone=dict( + _delete_=True, + type='SwinTransformer', + embed_dims=96, + depths=[2, 2, 6, 2], + num_heads=[3, 6, 12, 24], + window_size=7, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.2, + patch_norm=True, + out_indices=(0, 1, 2, 3), + with_cp=False, + convert_weights=True, + init_cfg=dict(type='Pretrained', checkpoint=pretrained)), + neck=dict(in_channels=[96, 192, 384, 768])) + +max_epochs = 12 +train_cfg = dict(max_epochs=max_epochs) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, + end=1000), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + paramwise_cfg=dict( + custom_keys={ + 'absolute_pos_embed': dict(decay_mult=0.), + 'relative_position_bias_table': dict(decay_mult=0.), + 'norm': dict(decay_mult=0.) + }), + optimizer=dict( + _delete_=True, + type='AdamW', + lr=0.0001, + betas=(0.9, 0.999), + weight_decay=0.05)) diff --git a/mmdetection/configs/swin/mask-rcnn_swin-t-p4-w7_fpn_amp-ms-crop-3x_coco.py b/mmdetection/configs/swin/mask-rcnn_swin-t-p4-w7_fpn_amp-ms-crop-3x_coco.py new file mode 100644 index 00000000..622087ba --- /dev/null +++ b/mmdetection/configs/swin/mask-rcnn_swin-t-p4-w7_fpn_amp-ms-crop-3x_coco.py @@ -0,0 +1,3 @@ +_base_ = './mask-rcnn_swin-t-p4-w7_fpn_ms-crop-3x_coco.py' +# Enable automatic-mixed-precision training with AmpOptimWrapper. +optim_wrapper = dict(type='AmpOptimWrapper') diff --git a/mmdetection/configs/swin/mask-rcnn_swin-t-p4-w7_fpn_ms-crop-3x_coco.py b/mmdetection/configs/swin/mask-rcnn_swin-t-p4-w7_fpn_ms-crop-3x_coco.py new file mode 100644 index 00000000..7024b732 --- /dev/null +++ b/mmdetection/configs/swin/mask-rcnn_swin-t-p4-w7_fpn_ms-crop-3x_coco.py @@ -0,0 +1,99 @@ +_base_ = [ + '../_base_/models/mask-rcnn_r50_fpn.py', + '../_base_/datasets/coco_instance.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_tiny_patch4_window7_224.pth' # noqa + +model = dict( + type='MaskRCNN', + backbone=dict( + _delete_=True, + type='SwinTransformer', + embed_dims=96, + depths=[2, 2, 6, 2], + num_heads=[3, 6, 12, 24], + window_size=7, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.2, + patch_norm=True, + out_indices=(0, 1, 2, 3), + with_cp=False, + convert_weights=True, + init_cfg=dict(type='Pretrained', checkpoint=pretrained)), + neck=dict(in_channels=[96, 192, 384, 768])) + +# augmentation strategy originates from DETR / Sparse RCNN +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[[ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + scales=[(400, 1333), (500, 1333), (600, 1333)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), + (576, 1333), (608, 1333), (640, 1333), + (672, 1333), (704, 1333), (736, 1333), + (768, 1333), (800, 1333)], + keep_ratio=True) + ]]), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) + +max_epochs = 36 +train_cfg = dict(max_epochs=max_epochs) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, + end=1000), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[27, 33], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + paramwise_cfg=dict( + custom_keys={ + 'absolute_pos_embed': dict(decay_mult=0.), + 'relative_position_bias_table': dict(decay_mult=0.), + 'norm': dict(decay_mult=0.) + }), + optimizer=dict( + _delete_=True, + type='AdamW', + lr=0.0001, + betas=(0.9, 0.999), + weight_decay=0.05)) diff --git a/mmdetection/configs/swin/metafile.yml b/mmdetection/configs/swin/metafile.yml new file mode 100644 index 00000000..763f9300 --- /dev/null +++ b/mmdetection/configs/swin/metafile.yml @@ -0,0 +1,120 @@ +Models: + - Name: mask-rcnn_swin-s-p4-w7_fpn_amp-ms-crop-3x_coco + In Collection: Mask R-CNN + Config: configs/swin/mask-rcnn_swin-s-p4-w7_fpn_amp-ms-crop-3x_coco.py + Metadata: + Training Memory (GB): 11.9 + Epochs: 36 + Training Data: COCO + Training Techniques: + - AdamW + Training Resources: 8x V100 GPUs + Architecture: + - Swin Transformer + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 48.2 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 43.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/swin/mask_rcnn_swin-s-p4-w7_fpn_fp16_ms-crop-3x_coco/mask_rcnn_swin-s-p4-w7_fpn_fp16_ms-crop-3x_coco_20210903_104808-b92c91f1.pth + Paper: + URL: https://arxiv.org/abs/2107.08430 + Title: 'Swin Transformer: Hierarchical Vision Transformer using Shifted Windows' + README: configs/swin/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.16.0/mmdet/models/backbones/swin.py#L465 + Version: v2.16.0 + + - Name: mask-rcnn_swin-t-p4-w7_fpn_ms-crop-3x_coco + In Collection: Mask R-CNN + Config: configs/swin/mask-rcnn_swin-t-p4-w7_fpn_ms-crop-3x_coco.py + Metadata: + Training Memory (GB): 10.2 + Epochs: 36 + Training Data: COCO + Training Techniques: + - AdamW + Training Resources: 8x V100 GPUs + Architecture: + - Swin Transformer + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.0 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 41.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/swin/mask_rcnn_swin-t-p4-w7_fpn_ms-crop-3x_coco/mask_rcnn_swin-t-p4-w7_fpn_ms-crop-3x_coco_20210906_131725-bacf6f7b.pth + Paper: + URL: https://arxiv.org/abs/2107.08430 + Title: 'Swin Transformer: Hierarchical Vision Transformer using Shifted Windows' + README: configs/swin/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.16.0/mmdet/models/backbones/swin.py#L465 + Version: v2.16.0 + + - Name: mask-rcnn_swin-t-p4-w7_fpn_1x_coco + In Collection: Mask R-CNN + Config: configs/swin/mask-rcnn_swin-t-p4-w7_fpn_1x_coco.py + Metadata: + Training Memory (GB): 7.6 + Epochs: 12 + Training Data: COCO + Training Techniques: + - AdamW + Training Resources: 8x V100 GPUs + Architecture: + - Swin Transformer + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.7 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 39.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/swin/mask_rcnn_swin-t-p4-w7_fpn_1x_coco/mask_rcnn_swin-t-p4-w7_fpn_1x_coco_20210902_120937-9d6b7cfa.pth + Paper: + URL: https://arxiv.org/abs/2107.08430 + Title: 'Swin Transformer: Hierarchical Vision Transformer using Shifted Windows' + README: configs/swin/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.16.0/mmdet/models/backbones/swin.py#L465 + Version: v2.16.0 + + - Name: mask-rcnn_swin-t-p4-w7_fpn_amp-ms-crop-3x_coco + In Collection: Mask R-CNN + Config: configs/swin/mask-rcnn_swin-t-p4-w7_fpn_amp-ms-crop-3x_coco.py + Metadata: + Training Memory (GB): 7.8 + Epochs: 36 + Training Data: COCO + Training Techniques: + - AdamW + Training Resources: 8x V100 GPUs + Architecture: + - Swin Transformer + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.0 + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 41.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/swin/mask_rcnn_swin-t-p4-w7_fpn_fp16_ms-crop-3x_coco/mask_rcnn_swin-t-p4-w7_fpn_fp16_ms-crop-3x_coco_20210908_165006-90a4008c.pth + Paper: + URL: https://arxiv.org/abs/2107.08430 + Title: 'Swin Transformer: Hierarchical Vision Transformer using Shifted Windows' + README: configs/swin/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.16.0/mmdet/models/backbones/swin.py#L465 + Version: v2.16.0 diff --git a/mmdetection/configs/swin/retinanet_swin-t-p4-w7_fpn_1x_coco.py b/mmdetection/configs/swin/retinanet_swin-t-p4-w7_fpn_1x_coco.py new file mode 100644 index 00000000..2f40a87e --- /dev/null +++ b/mmdetection/configs/swin/retinanet_swin-t-p4-w7_fpn_1x_coco.py @@ -0,0 +1,31 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_tiny_patch4_window7_224.pth' # noqa +model = dict( + backbone=dict( + _delete_=True, + type='SwinTransformer', + embed_dims=96, + depths=[2, 2, 6, 2], + num_heads=[3, 6, 12, 24], + window_size=7, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.2, + patch_norm=True, + out_indices=(1, 2, 3), + # Please only add indices that would be used + # in FPN, otherwise some parameter will not be used + with_cp=False, + convert_weights=True, + init_cfg=dict(type='Pretrained', checkpoint=pretrained)), + neck=dict(in_channels=[192, 384, 768], start_level=0, num_outs=5)) + +# optimizer +optim_wrapper = dict(optimizer=dict(lr=0.01)) diff --git a/mmdetection/configs/timm_example/README.md b/mmdetection/configs/timm_example/README.md new file mode 100644 index 00000000..848f8d3c --- /dev/null +++ b/mmdetection/configs/timm_example/README.md @@ -0,0 +1,62 @@ +# Timm Example + +> [PyTorch Image Models](https://github.com/rwightman/pytorch-image-models) + + + +## Abstract + +Py**T**orch **Im**age **M**odels (`timm`) is a collection of image models, layers, utilities, optimizers, schedulers, data-loaders / augmentations, and reference training / validation scripts that aim to pull together a wide variety of SOTA models with ability to reproduce ImageNet training results. + + + +## Results and Models + +### RetinaNet + +| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :-------------: | :-----: | :-----: | :------: | :------------: | :----: | :-------------------------------------------------------: | :------: | +| R-50 | pytorch | 1x | | | | [config](./retinanet_timm-tv-resnet50_fpn_1x_coco.py) | | +| EfficientNet-B1 | - | 1x | | | | [config](./retinanet_timm-efficientnet-b1_fpn_1x_coco.py) | | + +## Usage + +### Install additional requirements + +MMDetection supports timm backbones via `TIMMBackbone`, a wrapper class in MMPretrain. +Thus, you need to install `mmpretrain` in addition to timm. +If you have already installed requirements for mmdet, run + +```shell +pip install 'dataclasses; python_version<"3.7"' +pip install timm +pip install mmpretrain +``` + +See [this document](https://mmpretrain.readthedocs.io/en/latest/get_started.html#installation) for the details of MMPretrain installation. + +### Edit config + +- See example configs for basic usage. +- See the documents of [timm feature extraction](https://rwightman.github.io/pytorch-image-models/feature_extraction/#multi-scale-feature-maps-feature-pyramid) and [TIMMBackbone](https://mmpretrain.readthedocs.io/en/latest/api/generated/mmpretrain.models.backbones.TIMMBackbone.html#mmpretrain.models.backbones.TIMMBackbone) for details. +- Which feature map is output depends on the backbone. + Please check `backbone out_channels` and `backbone out_strides` in your log, and modify `model.neck.in_channels` and `model.backbone.out_indices` if necessary. +- If you use Vision Transformer models that do not support `features_only=True`, add `custom_hooks = []` to your config to disable `NumClassCheckHook`. + +## Citation + +```latex +@misc{rw2019timm, + author = {Ross Wightman}, + title = {PyTorch Image Models}, + year = {2019}, + publisher = {GitHub}, + journal = {GitHub repository}, + doi = {10.5281/zenodo.4414861}, + howpublished = {\url{https://github.com/rwightman/pytorch-image-models}} +} +``` diff --git a/mmdetection/configs/timm_example/retinanet_timm-efficientnet-b1_fpn_1x_coco.py b/mmdetection/configs/timm_example/retinanet_timm-efficientnet-b1_fpn_1x_coco.py new file mode 100644 index 00000000..b87dddf5 --- /dev/null +++ b/mmdetection/configs/timm_example/retinanet_timm-efficientnet-b1_fpn_1x_coco.py @@ -0,0 +1,23 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +# please install mmpretrain +# import mmpretrain.models to trigger register_module in mmpretrain +custom_imports = dict( + imports=['mmpretrain.models'], allow_failed_imports=False) + +model = dict( + backbone=dict( + _delete_=True, + type='mmpretrain.TIMMBackbone', + model_name='efficientnet_b1', + features_only=True, + pretrained=True, + out_indices=(1, 2, 3, 4)), + neck=dict(in_channels=[24, 40, 112, 320])) + +# optimizer +optim_wrapper = dict(optimizer=dict(lr=0.01)) diff --git a/mmdetection/configs/timm_example/retinanet_timm-tv-resnet50_fpn_1x_coco.py b/mmdetection/configs/timm_example/retinanet_timm-tv-resnet50_fpn_1x_coco.py new file mode 100644 index 00000000..74e43506 --- /dev/null +++ b/mmdetection/configs/timm_example/retinanet_timm-tv-resnet50_fpn_1x_coco.py @@ -0,0 +1,22 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +# please install mmpretrain +# import mmpretrain.models to trigger register_module in mmpretrain +custom_imports = dict( + imports=['mmpretrain.models'], allow_failed_imports=False) + +model = dict( + backbone=dict( + _delete_=True, + type='mmpretrain.TIMMBackbone', + model_name='tv_resnet50', # ResNet-50 with torchvision weights + features_only=True, + pretrained=True, + out_indices=(1, 2, 3, 4))) + +# optimizer +optim_wrapper = dict(optimizer=dict(lr=0.01)) diff --git a/mmdetection/configs/tood/README.md b/mmdetection/configs/tood/README.md new file mode 100644 index 00000000..9371d9d7 --- /dev/null +++ b/mmdetection/configs/tood/README.md @@ -0,0 +1,40 @@ +# TOOD + +> [TOOD: Task-aligned One-stage Object Detection](https://arxiv.org/abs/2108.07755) + + + +## Abstract + +One-stage object detection is commonly implemented by optimizing two sub-tasks: object classification and localization, using heads with two parallel branches, which might lead to a certain level of spatial misalignment in predictions between the two tasks. In this work, we propose a Task-aligned One-stage Object Detection (TOOD) that explicitly aligns the two tasks in a learning-based manner. First, we design a novel Task-aligned Head (T-Head) which offers a better balance between learning task-interactive and task-specific features, as well as a greater flexibility to learn the alignment via a task-aligned predictor. Second, we propose Task Alignment Learning (TAL) to explicitly pull closer (or even unify) the optimal anchors for the two tasks during training via a designed sample assignment scheme and a task-aligned loss. Extensive experiments are conducted on MS-COCO, where TOOD achieves a 51.1 AP at single-model single-scale testing. This surpasses the recent one-stage detectors by a large margin, such as ATSS (47.7 AP), GFL (48.2 AP), and PAA (49.0 AP), with fewer parameters and FLOPs. Qualitative results also demonstrate the effectiveness of TOOD for better aligning the tasks of object classification and localization. + +
    + +
    + +## Results and Models + +| Backbone | Style | Anchor Type | Lr schd | Multi-scale Training | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :---------------: | :-----: | :----------: | :-----: | :------------------: | :------: | :------------: | :----: | :-------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | pytorch | Anchor-free | 1x | N | 4.1 | | 42.4 | [config](./tood_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/tood/tood_r50_fpn_1x_coco/tood_r50_fpn_1x_coco_20211210_103425-20e20746.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/tood/tood_r50_fpn_1x_coco/tood_r50_fpn_1x_coco_20211210_103425.log) | +| R-50 | pytorch | Anchor-based | 1x | N | 4.1 | | 42.4 | [config](./tood_r50_fpn_anchor-based_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/tood/tood_r50_fpn_anchor_based_1x_coco/tood_r50_fpn_anchor_based_1x_coco_20211214_100105-b776c134.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/tood/tood_r50_fpn_anchor_based_1x_coco/tood_r50_fpn_anchor_based_1x_coco_20211214_100105.log) | +| R-50 | pytorch | Anchor-free | 2x | Y | 4.1 | | 44.5 | [config](./tood_r50_fpn_ms-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/tood/tood_r50_fpn_mstrain_2x_coco/tood_r50_fpn_mstrain_2x_coco_20211210_144231-3b23174c.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/tood/tood_r50_fpn_mstrain_2x_coco/tood_r50_fpn_mstrain_2x_coco_20211210_144231.log) | +| R-101 | pytorch | Anchor-free | 2x | Y | 6.0 | | 46.1 | [config](./tood_r101_fpn_ms-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/tood/tood_r101_fpn_mstrain_2x_coco/tood_r101_fpn_mstrain_2x_coco_20211210_144232-a18f53c8.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/tood/tood_r101_fpn_mstrain_2x_coco/tood_r101_fpn_mstrain_2x_coco_20211210_144232.log) | +| R-101-dcnv2 | pytorch | Anchor-free | 2x | Y | 6.2 | | 49.3 | [config](./tood_r101-dconv-c3-c5_fpn_ms-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/tood/tood_r101_fpn_dconv_c3-c5_mstrain_2x_coco/tood_r101_fpn_dconv_c3-c5_mstrain_2x_coco_20211210_213728-4a824142.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/tood/tood_r101_fpn_dconv_c3-c5_mstrain_2x_coco/tood_r101_fpn_dconv_c3-c5_mstrain_2x_coco_20211210_213728.log) | +| X-101-64x4d | pytorch | Anchor-free | 2x | Y | 10.2 | | 47.6 | [config](./tood_x101-64x4d_fpn_ms-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/tood/tood_x101_64x4d_fpn_mstrain_2x_coco/tood_x101_64x4d_fpn_mstrain_2x_coco_20211211_003519-a4f36113.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/tood/tood_x101_64x4d_fpn_mstrain_2x_coco/tood_x101_64x4d_fpn_mstrain_2x_coco_20211211_003519.log) | +| X-101-64x4d-dcnv2 | pytorch | Anchor-free | 2x | Y | | | | [config](./tood_x101-64x4d-dconv-c4-c5_fpn_ms-2x_coco.py) | [model](<>) \| [log](<>) | + +\[1\] *1x and 2x mean the model is trained for 90K and 180K iterations, respectively.* \ +\[2\] *All results are obtained with a single model and without any test time data augmentation such as multi-scale, flipping and etc..* \ +\[3\] *`dcnv2` denotes deformable convolutional networks v2.* \\ + +## Citation + +```latex +@inproceedings{feng2021tood, + title={TOOD: Task-aligned One-stage Object Detection}, + author={Feng, Chengjian and Zhong, Yujie and Gao, Yu and Scott, Matthew R and Huang, Weilin}, + booktitle={ICCV}, + year={2021} +} +``` diff --git a/mmdetection/configs/tood/metafile.yml b/mmdetection/configs/tood/metafile.yml new file mode 100644 index 00000000..d2bc0807 --- /dev/null +++ b/mmdetection/configs/tood/metafile.yml @@ -0,0 +1,95 @@ +Collections: + - Name: TOOD + Metadata: + Training Data: COCO + Training Techniques: + - SGD + Training Resources: 8x V100 GPUs + Architecture: + - TOOD + Paper: + URL: https://arxiv.org/abs/2108.07755 + Title: 'TOOD: Task-aligned One-stage Object Detection' + README: configs/tood/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.20.0/mmdet/models/detectors/tood.py#L7 + Version: v2.20.0 + +Models: + - Name: tood_r101_fpn_ms-2x_coco + In Collection: TOOD + Config: configs/tood/tood_r101_fpn_ms-2x_coco.py + Metadata: + Training Memory (GB): 6.0 + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.1 + Weights: https://download.openmmlab.com/mmdetection/v2.0/tood/tood_r101_fpn_mstrain_2x_coco/tood_r101_fpn_mstrain_2x_coco_20211210_144232-a18f53c8.pth + + - Name: tood_x101-64x4d_fpn_ms-2x_coco + In Collection: TOOD + Config: configs/tood/tood_x101-64x4d_fpn_ms-2x_coco.py + Metadata: + Training Memory (GB): 10.2 + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 47.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/tood/tood_x101_64x4d_fpn_mstrain_2x_coco/tood_x101_64x4d_fpn_mstrain_2x_coco_20211211_003519-a4f36113.pth + + - Name: tood_r101-dconv-c3-c5_fpn_ms-2x_coco + In Collection: TOOD + Config: configs/tood/tood_r101-dconv-c3-c5_fpn_ms-2x_coco.py + Metadata: + Training Memory (GB): 6.2 + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 49.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/tood/tood_r101_fpn_dconv_c3-c5_mstrain_2x_coco/tood_r101_fpn_dconv_c3-c5_mstrain_2x_coco_20211210_213728-4a824142.pth + + - Name: tood_r50_fpn_anchor-based_1x_coco + In Collection: TOOD + Config: configs/tood/tood_r50_fpn_anchor-based_1x_coco.py + Metadata: + Training Memory (GB): 4.1 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/tood/tood_r50_fpn_anchor_based_1x_coco/tood_r50_fpn_anchor_based_1x_coco_20211214_100105-b776c134.pth + + - Name: tood_r50_fpn_1x_coco + In Collection: TOOD + Config: configs/tood/tood_r50_fpn_1x_coco.py + Metadata: + Training Memory (GB): 4.1 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 42.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/tood/tood_r50_fpn_1x_coco/tood_r50_fpn_1x_coco_20211210_103425-20e20746.pth + + - Name: tood_r50_fpn_ms-2x_coco + In Collection: TOOD + Config: configs/tood/tood_r50_fpn_ms-2x_coco.py + Metadata: + Training Memory (GB): 4.1 + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/tood/tood_r50_fpn_mstrain_2x_coco/tood_r50_fpn_mstrain_2x_coco_20211210_144231-3b23174c.pth diff --git a/mmdetection/configs/tood/tood_r101-dconv-c3-c5_fpn_ms-2x_coco.py b/mmdetection/configs/tood/tood_r101-dconv-c3-c5_fpn_ms-2x_coco.py new file mode 100644 index 00000000..45030a68 --- /dev/null +++ b/mmdetection/configs/tood/tood_r101-dconv-c3-c5_fpn_ms-2x_coco.py @@ -0,0 +1,7 @@ +_base_ = './tood_r101_fpn_ms-2x_coco.py' + +model = dict( + backbone=dict( + dcn=dict(type='DCNv2', deformable_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True)), + bbox_head=dict(num_dcn=2)) diff --git a/mmdetection/configs/tood/tood_r101_fpn_ms-2x_coco.py b/mmdetection/configs/tood/tood_r101_fpn_ms-2x_coco.py new file mode 100644 index 00000000..fc6ae5d9 --- /dev/null +++ b/mmdetection/configs/tood/tood_r101_fpn_ms-2x_coco.py @@ -0,0 +1,7 @@ +_base_ = './tood_r50_fpn_ms-2x_coco.py' + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/tood/tood_r50_fpn_1x_coco.py b/mmdetection/configs/tood/tood_r50_fpn_1x_coco.py new file mode 100644 index 00000000..e4839d9d --- /dev/null +++ b/mmdetection/configs/tood/tood_r50_fpn_1x_coco.py @@ -0,0 +1,80 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +# model settings +model = dict( + type='TOOD', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_output', + num_outs=5), + bbox_head=dict( + type='TOODHead', + num_classes=80, + in_channels=256, + stacked_convs=6, + feat_channels=256, + anchor_type='anchor_free', + anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + octave_base_scale=8, + scales_per_octave=1, + strides=[8, 16, 32, 64, 128]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + initial_loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + activated=True, # use probability instead of logit as input + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_cls=dict( + type='QualityFocalLoss', + use_sigmoid=True, + activated=True, # use probability instead of logit as input + beta=2.0, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=2.0)), + train_cfg=dict( + initial_epoch=4, + initial_assigner=dict(type='ATSSAssigner', topk=9), + assigner=dict(type='TaskAlignedAssigner', topk=13), + alpha=1, + beta=6, + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) +# optimizer +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) diff --git a/mmdetection/configs/tood/tood_r50_fpn_anchor-based_1x_coco.py b/mmdetection/configs/tood/tood_r50_fpn_anchor-based_1x_coco.py new file mode 100644 index 00000000..c7fbf6af --- /dev/null +++ b/mmdetection/configs/tood/tood_r50_fpn_anchor-based_1x_coco.py @@ -0,0 +1,2 @@ +_base_ = './tood_r50_fpn_1x_coco.py' +model = dict(bbox_head=dict(anchor_type='anchor_based')) diff --git a/mmdetection/configs/tood/tood_r50_fpn_ms-2x_coco.py b/mmdetection/configs/tood/tood_r50_fpn_ms-2x_coco.py new file mode 100644 index 00000000..ffb296dc --- /dev/null +++ b/mmdetection/configs/tood/tood_r50_fpn_ms-2x_coco.py @@ -0,0 +1,30 @@ +_base_ = './tood_r50_fpn_1x_coco.py' +max_epochs = 24 + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] + +# training schedule for 2x +train_cfg = dict(max_epochs=max_epochs) + +# multi-scale training +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomResize', scale=[(1333, 480), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/mmdetection/configs/tood/tood_x101-64x4d-dconv-c4-c5_fpn_ms-2x_coco.py b/mmdetection/configs/tood/tood_x101-64x4d-dconv-c4-c5_fpn_ms-2x_coco.py new file mode 100644 index 00000000..43405196 --- /dev/null +++ b/mmdetection/configs/tood/tood_x101-64x4d-dconv-c4-c5_fpn_ms-2x_coco.py @@ -0,0 +1,7 @@ +_base_ = './tood_x101-64x4d_fpn_ms-2x_coco.py' +model = dict( + backbone=dict( + dcn=dict(type='DCNv2', deformable_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, False, True, True), + ), + bbox_head=dict(num_dcn=2)) diff --git a/mmdetection/configs/tood/tood_x101-64x4d_fpn_ms-2x_coco.py b/mmdetection/configs/tood/tood_x101-64x4d_fpn_ms-2x_coco.py new file mode 100644 index 00000000..1651542c --- /dev/null +++ b/mmdetection/configs/tood/tood_x101-64x4d_fpn_ms-2x_coco.py @@ -0,0 +1,16 @@ +_base_ = './tood_r50_fpn_ms-2x_coco.py' + +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/tridentnet/README.md b/mmdetection/configs/tridentnet/README.md new file mode 100644 index 00000000..b972b3a3 --- /dev/null +++ b/mmdetection/configs/tridentnet/README.md @@ -0,0 +1,38 @@ +# TridentNet + +> [Scale-Aware Trident Networks for Object Detection](https://arxiv.org/abs/1901.01892) + + + +## Abstract + +Scale variation is one of the key challenges in object detection. In this work, we first present a controlled experiment to investigate the effect of receptive fields for scale variation in object detection. Based on the findings from the exploration experiments, we propose a novel Trident Network (TridentNet) aiming to generate scale-specific feature maps with a uniform representational power. We construct a parallel multi-branch architecture in which each branch shares the same transformation parameters but with different receptive fields. Then, we adopt a scale-aware training scheme to specialize each branch by sampling object instances of proper scales for training. As a bonus, a fast approximation version of TridentNet could achieve significant improvements without any additional parameters and computational cost compared with the vanilla detector. On the COCO dataset, our TridentNet with ResNet-101 backbone achieves state-of-the-art single-model results of 48.4 mAP. + +
    + +
    + +## Results and Models + +We reports the test results using only one branch for inference. + +| Backbone | Style | mstrain | Lr schd | Mem (GB) | Inf time (fps) | box AP | Download | +| :------: | :---: | :-----: | :-----: | :------: | :------------: | :----: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | caffe | N | 1x | | | 37.7 | [model](https://download.openmmlab.com/mmdetection/v2.0/tridentnet/tridentnet_r50_caffe_1x_coco/tridentnet_r50_caffe_1x_coco_20201230_141838-2ec0b530.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/tridentnet/tridentnet_r50_caffe_1x_coco/tridentnet_r50_caffe_1x_coco_20201230_141838.log.json) | +| R-50 | caffe | Y | 1x | | | 37.6 | [model](https://download.openmmlab.com/mmdetection/v2.0/tridentnet/tridentnet_r50_caffe_mstrain_1x_coco/tridentnet_r50_caffe_mstrain_1x_coco_20201230_141839-6ce55ccb.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/tridentnet/tridentnet_r50_caffe_mstrain_1x_coco/tridentnet_r50_caffe_mstrain_1x_coco_20201230_141839.log.json) | +| R-50 | caffe | Y | 3x | | | 40.3 | [model](https://download.openmmlab.com/mmdetection/v2.0/tridentnet/tridentnet_r50_caffe_mstrain_3x_coco/tridentnet_r50_caffe_mstrain_3x_coco_20201130_100539-46d227ba.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/tridentnet/tridentnet_r50_caffe_mstrain_3x_coco/tridentnet_r50_caffe_mstrain_3x_coco_20201130_100539.log.json) | + +**Note** + +Similar to [Detectron2](https://github.com/facebookresearch/detectron2/tree/master/projects/TridentNet), we haven't implemented the Scale-aware Training Scheme in section 4.2 of the paper. + +## Citation + +```latex +@InProceedings{li2019scale, + title={Scale-Aware Trident Networks for Object Detection}, + author={Li, Yanghao and Chen, Yuntao and Wang, Naiyan and Zhang, Zhaoxiang}, + journal={The International Conference on Computer Vision (ICCV)}, + year={2019} +} +``` diff --git a/mmdetection/configs/tridentnet/metafile.yml b/mmdetection/configs/tridentnet/metafile.yml new file mode 100644 index 00000000..c0081c5b --- /dev/null +++ b/mmdetection/configs/tridentnet/metafile.yml @@ -0,0 +1,55 @@ +Collections: + - Name: TridentNet + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - ResNet + - TridentNet Block + Paper: + URL: https://arxiv.org/abs/1901.01892 + Title: 'Scale-Aware Trident Networks for Object Detection' + README: configs/tridentnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.8.0/mmdet/models/detectors/trident_faster_rcnn.py#L6 + Version: v2.8.0 + +Models: + - Name: tridentnet_r50-caffe_1x_coco + In Collection: TridentNet + Config: configs/tridentnet/tridentnet_r50-caffe_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/tridentnet/tridentnet_r50_caffe_1x_coco/tridentnet_r50_caffe_1x_coco_20201230_141838-2ec0b530.pth + + - Name: tridentnet_r50-caffe_ms-1x_coco + In Collection: TridentNet + Config: configs/tridentnet/tridentnet_r50-caffe_ms-1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/tridentnet/tridentnet_r50_caffe_mstrain_1x_coco/tridentnet_r50_caffe_mstrain_1x_coco_20201230_141839-6ce55ccb.pth + + - Name: tridentnet_r50-caffe_ms-3x_coco + In Collection: TridentNet + Config: configs/tridentnet/tridentnet_r50-caffe_ms-3x_coco.py + Metadata: + Epochs: 36 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.3 + Weights: https://download.openmmlab.com/mmdetection/v2.0/tridentnet/tridentnet_r50_caffe_mstrain_3x_coco/tridentnet_r50_caffe_mstrain_3x_coco_20201130_100539-46d227ba.pth diff --git a/mmdetection/configs/tridentnet/tridentnet_r50-caffe_1x_coco.py b/mmdetection/configs/tridentnet/tridentnet_r50-caffe_1x_coco.py new file mode 100644 index 00000000..26a4c123 --- /dev/null +++ b/mmdetection/configs/tridentnet/tridentnet_r50-caffe_1x_coco.py @@ -0,0 +1,22 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50-caffe-c4.py', + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] + +model = dict( + type='TridentFasterRCNN', + backbone=dict( + type='TridentResNet', + trident_dilations=(1, 2, 3), + num_branch=3, + test_branch_idx=1, + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron2/resnet50_caffe')), + roi_head=dict(type='TridentRoIHead', num_branch=3, test_branch_idx=1), + train_cfg=dict( + rpn_proposal=dict(max_per_img=500), + rcnn=dict( + sampler=dict(num=128, pos_fraction=0.5, + add_gt_as_proposals=False)))) diff --git a/mmdetection/configs/tridentnet/tridentnet_r50-caffe_ms-1x_coco.py b/mmdetection/configs/tridentnet/tridentnet_r50-caffe_ms-1x_coco.py new file mode 100644 index 00000000..806d20b9 --- /dev/null +++ b/mmdetection/configs/tridentnet/tridentnet_r50-caffe_ms-1x_coco.py @@ -0,0 +1,15 @@ +_base_ = 'tridentnet_r50-caffe_1x_coco.py' + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomChoiceResize', + scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736), + (1333, 768), (1333, 800)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) diff --git a/mmdetection/configs/tridentnet/tridentnet_r50-caffe_ms-3x_coco.py b/mmdetection/configs/tridentnet/tridentnet_r50-caffe_ms-3x_coco.py new file mode 100644 index 00000000..4de249c6 --- /dev/null +++ b/mmdetection/configs/tridentnet/tridentnet_r50-caffe_ms-3x_coco.py @@ -0,0 +1,18 @@ +_base_ = 'tridentnet_r50-caffe_ms-1x_coco.py' + +# learning rate +max_epochs = 36 +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) + +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[28, 34], + gamma=0.1) +] diff --git a/mmdetection/configs/v3det/README.md b/mmdetection/configs/v3det/README.md new file mode 100644 index 00000000..36879316 --- /dev/null +++ b/mmdetection/configs/v3det/README.md @@ -0,0 +1,86 @@ +

    +

    + +# V3Det: Vast Vocabulary Visual Detection Dataset + +
    + Jiaqi Wang*, + Pan Zhang*, + Tao Chu*, + Yuhang Cao*,
    + Yujie Zhou, + Tong Wu, + Bin Wang, + Conghui He, + Dahua Lin
    + (* equal contribution)
    + Accepted to ICCV 2023 (Oral) +
    +

    +

    +

    + + Paper, + Dataset
    +     +
    +
    +

    + +
    + +
    + + + +## Abstract + +Recent advances in detecting arbitrary objects in the real world are trained and evaluated on object detection datasets with a relatively restricted vocabulary. To facilitate the development of more general visual object detection, we propose V3Det, a vast vocabulary visual detection dataset with precisely annotated bounding boxes on massive images. V3Det has several appealing properties: 1) Vast Vocabulary: It contains bounding boxes of objects from 13,204 categories on real-world images, which is 10 times larger than the existing large vocabulary object detection dataset, e.g., LVIS. 2) Hierarchical Category Organization: The vast vocabulary of V3Det is organized by a hierarchical category tree which annotates the inclusion relationship among categories, encouraging the exploration of category relationships in vast and open vocabulary object detection. 3) Rich Annotations: V3Det comprises precisely annotated objects in 243k images and professional descriptions of each category written by human experts and a powerful chatbot. By offering a vast exploration space, V3Det enables extensive benchmarks on both vast and open vocabulary object detection, leading to new observations, practices, and insights for future research. It has the potential to serve as a cornerstone dataset for developing more general visual perception systems. V3Det is available at https://v3det.openxlab.org.cn/. + +## Prepare Dataset + +Please download and prepare V3Det Dataset at [V3Det Homepage](https://v3det.openxlab.org.cn/) and [V3Det Github](https://github.com/V3Det/V3Det). + +The data includes a training set, a validation set, comprising 13,204 categories. The training set consists of 183,354 images, while the validation set has 29,821 images. The data organization is: + +``` +data/ + V3Det/ + images/ + / + |────.png + ... + ... + annotations/ + |────v3det_2023_v1_category_tree.json # Category tree + |────category_name_13204_v3det_2023_v1.txt # Category name + |────v3det_2023_v1_train.json # Train set + |────v3det_2023_v1_val.json # Validation set +``` + +## Results and Models + +| Backbone | Model | Lr schd | box AP | Config | Download | +| :------: | :-------------: | :-----: | :----: | :----------------------------------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------: | +| R-50 | Faster R-CNN | 2x | 25.4 | [config](./faster_rcnn_r50_fpn_8x4_sample1e-3_mstrain_v3det_2x.py) | [model](https://download.openxlab.org.cn/models/V3Det/V3Det/weight//faster_rcnn_r50_fpn_8x4_sample1e-3_mstrain_v3det_2x) | +| R-50 | Cascade R-CNN | 2x | 31.6 | [config](./cascade_rcnn_r50_fpn_8x4_sample1e-3_mstrain_v3det_2x.py) | [model](https://download.openxlab.org.cn/models/V3Det/V3Det/weight//cascade_rcnn_r50_fpn_8x4_sample1e-3_mstrain_v3det_2x) | +| R-50 | FCOS | 2x | 9.4 | [config](./fcos_r50_fpn_8x4_sample1e-3_mstrain_v3det_2x.py) | [model](https://download.openxlab.org.cn/models/V3Det/V3Det/weight//fcos_r50_fpn_8x4_sample1e-3_mstrain_v3det_2x) | +| R-50 | Deformable-DETR | 50e | 34.4 | [config](./deformable-detr-refine-twostage_r50_8xb4_sample1e-3_v3det_50e.py) | [model](https://download.openxlab.org.cn/models/V3Det/V3Det/weight/Deformable_DETR_V3Det_R50) | +| R-50 | DINO | 36e | 33.5 | [config](./dino-4scale_r50_8xb2_sample1e-3_v3det_36e.py) | [model](https://download.openxlab.org.cn/models/V3Det/V3Det/weight/DINO_V3Det_R50) | +| Swin-B | Faster R-CNN | 2x | 37.6 | [config](./faster_rcnn_swinb_fpn_8x4_sample1e-3_mstrain_v3det_2x.py) | [model](https://download.openxlab.org.cn/models/V3Det/V3Det/weight//faster_rcnn_swinb_fpn_8x4_sample1e-3_mstrain_v3det_2x) | +| Swin-B | Cascade R-CNN | 2x | 42.5 | [config](./cascade_rcnn_swinb_fpn_8x4_sample1e-3_mstrain_v3det_2x.py) | [model](https://download.openxlab.org.cn/models/V3Det/V3Det/weight//cascade_rcnn_swinb_fpn_8x4_sample1e-3_mstrain_v3det_2x) | +| Swin-B | FCOS | 2x | 21.0 | [config](./fcos_swinb_fpn_8x4_sample1e-3_mstrain_v3det_2x.py) | [model](https://download.openxlab.org.cn/models/V3Det/V3Det/weight//fcos_swinb_fpn_8x4_sample1e-3_mstrain_v3det_2x) | +| Swin-B | Deformable-DETR | 50e | 42.5 | [config](./deformable-detr-refine-twostage_swin_16xb2_sample1e-3_v3det_50e.py) | [model](https://download.openxlab.org.cn/models/V3Det/V3Det/weight/Deformable_DETR_V3Det_SwinB) | +| Swin-B | DINO | 36e | 42.0 | [config](./dino-4scale_swin_16xb1_sample1e-3_v3det_36e.py) | [model](https://download.openxlab.org.cn/models/V3Det/V3Det/weight/DINO_V3Det_SwinB) | + +## Citation + +```latex +@inproceedings{wang2023v3det, + title = {V3Det: Vast Vocabulary Visual Detection Dataset}, + author = {Wang, Jiaqi and Zhang, Pan and Chu, Tao and Cao, Yuhang and Zhou, Yujie and Wu, Tong and Wang, Bin and He, Conghui and Lin, Dahua}, + booktitle = {The IEEE International Conference on Computer Vision (ICCV)}, + month = {October}, + year = {2023} +} +``` diff --git a/mmdetection/configs/v3det/cascade_rcnn_r50_fpn_8x4_sample1e-3_mstrain_v3det_2x.py b/mmdetection/configs/v3det/cascade_rcnn_r50_fpn_8x4_sample1e-3_mstrain_v3det_2x.py new file mode 100644 index 00000000..567c31bd --- /dev/null +++ b/mmdetection/configs/v3det/cascade_rcnn_r50_fpn_8x4_sample1e-3_mstrain_v3det_2x.py @@ -0,0 +1,171 @@ +_base_ = [ + '../_base_/models/cascade-rcnn_r50_fpn.py', '../_base_/datasets/v3det.py', + '../_base_/schedules/schedule_2x.py', '../_base_/default_runtime.py' +] +# model settings +model = dict( + rpn_head=dict( + loss_bbox=dict(_delete_=True, type='L1Loss', loss_weight=1.0)), + roi_head=dict(bbox_head=[ + dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=13204, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2]), + reg_class_agnostic=True, + cls_predictor_cfg=dict( + type='NormedLinear', tempearture=50, bias=True), + loss_cls=dict( + type='CrossEntropyCustomLoss', + num_classes=13204, + use_sigmoid=True, + loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0)), + dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=13204, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.05, 0.05, 0.1, 0.1]), + reg_class_agnostic=True, + cls_predictor_cfg=dict( + type='NormedLinear', tempearture=50, bias=True), + loss_cls=dict( + type='CrossEntropyCustomLoss', + num_classes=13204, + use_sigmoid=True, + loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0)), + dict( + type='Shared2FCBBoxHead', + in_channels=256, + fc_out_channels=1024, + roi_feat_size=7, + num_classes=13204, + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[0., 0., 0., 0.], + target_stds=[0.033, 0.033, 0.067, 0.067]), + reg_class_agnostic=True, + cls_predictor_cfg=dict( + type='NormedLinear', tempearture=50, bias=True), + loss_cls=dict( + type='CrossEntropyCustomLoss', + num_classes=13204, + use_sigmoid=True, + loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0)) + ]), + # model training and testing settings + train_cfg=dict( + rpn_proposal=dict(nms_pre=4000, max_per_img=2000), + rcnn=[ + dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0.5, + match_low_quality=False, + ignore_iof_thr=-1, + perm_repeat_gt_cfg=dict(iou_thr=0.7, perm_range=0.01)), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + pos_weight=-1, + debug=False), + dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.6, + neg_iou_thr=0.6, + min_pos_iou=0.6, + match_low_quality=False, + ignore_iof_thr=-1, + perm_repeat_gt_cfg=dict(iou_thr=0.7, perm_range=0.01)), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + pos_weight=-1, + debug=False), + dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.7, + neg_iou_thr=0.7, + min_pos_iou=0.7, + match_low_quality=False, + ignore_iof_thr=-1, + perm_repeat_gt_cfg=dict(iou_thr=0.7, perm_range=0.01)), + sampler=dict( + type='RandomSampler', + num=512, + pos_fraction=0.25, + neg_pos_ub=-1, + add_gt_as_proposals=True), + pos_weight=-1, + debug=False) + ]), + test_cfg=dict( + rcnn=dict( + score_thr=0.0001, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=300))) +# dataset settings +train_dataloader = dict(batch_size=4, num_workers=8) + +# training schedule for 1x +max_iter = 68760 * 2 +train_cfg = dict( + _delete_=True, + type='IterBasedTrainLoop', + max_iters=max_iter, + val_interval=max_iter) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0 / 2048, + by_epoch=False, + begin=0, + end=5000), + dict( + type='MultiStepLR', + begin=0, + end=max_iter, + by_epoch=False, + milestones=[45840 * 2, 63030 * 2], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(_delete_=True, type='AdamW', lr=1e-4 * 1, weight_decay=0.1), + clip_grad=dict(max_norm=35, norm_type=2)) + +# Default setting for scaling LR automatically +# - `enable` means enable scaling LR automatically +# or not by default. +# - `base_batch_size` = (8 GPUs) x (2 samples per GPU). +auto_scale_lr = dict(enable=False, base_batch_size=32) + +default_hooks = dict( + checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=5730 * 2)) +log_processor = dict(type='LogProcessor', window_size=50, by_epoch=False) diff --git a/mmdetection/configs/v3det/cascade_rcnn_swinb_fpn_8x4_sample1e-3_mstrain_v3det_2x.py b/mmdetection/configs/v3det/cascade_rcnn_swinb_fpn_8x4_sample1e-3_mstrain_v3det_2x.py new file mode 100644 index 00000000..f6493323 --- /dev/null +++ b/mmdetection/configs/v3det/cascade_rcnn_swinb_fpn_8x4_sample1e-3_mstrain_v3det_2x.py @@ -0,0 +1,27 @@ +_base_ = [ + './cascade_rcnn_r50_fpn_8x4_sample1e-3_mstrain_v3det_2x.py', +] + +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_base_patch4_window7_224.pth' # noqa + +# model settings +model = dict( + backbone=dict( + _delete_=True, + type='SwinTransformer', + embed_dims=128, + depths=[2, 2, 18, 2], + num_heads=[4, 8, 16, 32], + window_size=7, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.3, + patch_norm=True, + out_indices=(0, 1, 2, 3), + with_cp=False, + convert_weights=True, + init_cfg=dict(type='Pretrained', checkpoint=pretrained)), + neck=dict(in_channels=[128, 256, 512, 1024])) diff --git a/mmdetection/configs/v3det/deformable-detr-refine-twostage_r50_8xb4_sample1e-3_v3det_50e.py b/mmdetection/configs/v3det/deformable-detr-refine-twostage_r50_8xb4_sample1e-3_v3det_50e.py new file mode 100644 index 00000000..97544a27 --- /dev/null +++ b/mmdetection/configs/v3det/deformable-detr-refine-twostage_r50_8xb4_sample1e-3_v3det_50e.py @@ -0,0 +1,108 @@ +_base_ = '../deformable_detr/deformable-detr-refine-twostage_r50_16xb2-50e_coco.py' # noqa + +model = dict( + bbox_head=dict(num_classes=13204), + test_cfg=dict(max_per_img=300), +) + +data_root = 'data/V3Det/' +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='PackDetInputs') +] + +train_dataloader = dict( + _delete_=True, + batch_size=4, + num_workers=4, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type='ClassBalancedDataset', + oversample_thr=1e-3, + dataset=dict( + type='V3DetDataset', + data_root=data_root, + ann_file='annotations/v3det_2023_v1_train.json', + data_prefix=dict(img=''), + filter_cfg=dict(filter_empty_gt=False), + pipeline=train_pipeline, + backend_args=None))) +val_dataloader = dict( + dataset=dict( + type='V3DetDataset', + data_root=data_root, + ann_file='annotations/v3det_2023_v1_val.json', + data_prefix=dict(img=''))) +test_dataloader = val_dataloader + +val_evaluator = dict( + ann_file=data_root + 'annotations/v3det_2023_v1_val.json', + use_mp_eval=True, + proposal_nums=[300]) +test_evaluator = val_evaluator + +# training schedule for 50e +# when using RFS, bs32, each epoch ~ 5730 iter +max_iter = 286500 +train_cfg = dict( + _delete_=True, + type='IterBasedTrainLoop', + max_iters=max_iter, + val_interval=max_iter / 5) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# learning rate +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_iter, + by_epoch=False, + milestones=[229200], # 40e + gamma=0.1) +] + +default_hooks = dict( + timer=dict(type='IterTimerHook'), + param_scheduler=dict(type='ParamSchedulerHook'), + checkpoint=dict( + type='CheckpointHook', by_epoch=False, interval=5730, + max_keep_ckpts=3)) + +log_processor = dict(type='LogProcessor', window_size=50, by_epoch=False) diff --git a/mmdetection/configs/v3det/deformable-detr-refine-twostage_swin_16xb2_sample1e-3_v3det_50e.py b/mmdetection/configs/v3det/deformable-detr-refine-twostage_swin_16xb2_sample1e-3_v3det_50e.py new file mode 100644 index 00000000..e640cd60 --- /dev/null +++ b/mmdetection/configs/v3det/deformable-detr-refine-twostage_swin_16xb2_sample1e-3_v3det_50e.py @@ -0,0 +1,27 @@ +_base_ = 'deformable-detr-refine-twostage_r50_8xb4_sample1e-3_v3det_50e.py' + +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_base_patch4_window7_224.pth' # noqa + +model = dict( + backbone=dict( + _delete_=True, + type='SwinTransformer', + embed_dims=128, + depths=[2, 2, 18, 2], + num_heads=[4, 8, 16, 32], + window_size=7, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.3, + patch_norm=True, + out_indices=(1, 2, 3), + with_cp=False, + convert_weights=True, + init_cfg=dict(type='Pretrained', checkpoint=pretrained)), + neck=dict(in_channels=[256, 512, 1024]), +) + +train_dataloader = dict(batch_size=2, num_workers=2) diff --git a/mmdetection/configs/v3det/dino-4scale_r50_8xb2_sample1e-3_v3det_36e.py b/mmdetection/configs/v3det/dino-4scale_r50_8xb2_sample1e-3_v3det_36e.py new file mode 100644 index 00000000..d9e6e6be --- /dev/null +++ b/mmdetection/configs/v3det/dino-4scale_r50_8xb2_sample1e-3_v3det_36e.py @@ -0,0 +1,109 @@ +_base_ = '../dino/dino-4scale_r50_8xb2-36e_coco.py' + +model = dict( + bbox_head=dict(num_classes=13204), + test_cfg=dict(max_per_img=300), +) + +data_root = 'data/V3Det/' +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='RandomFlip', prob=0.5), + dict( + type='RandomChoice', + transforms=[ + [ + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ], + [ + dict( + type='RandomChoiceResize', + # The radio of all image in train dataset < 7 + # follow the original implement + scales=[(400, 4200), (500, 4200), (600, 4200)], + keep_ratio=True), + dict( + type='RandomCrop', + crop_type='absolute_range', + crop_size=(384, 600), + allow_negative_crop=True), + dict( + type='RandomChoiceResize', + scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333), + (608, 1333), (640, 1333), (672, 1333), (704, 1333), + (736, 1333), (768, 1333), (800, 1333)], + keep_ratio=True) + ] + ]), + dict(type='PackDetInputs') +] +train_dataloader = dict( + _delete_=True, + batch_size=2, + num_workers=2, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type='ClassBalancedDataset', + oversample_thr=1e-3, + dataset=dict( + type='V3DetDataset', + data_root=data_root, + ann_file='annotations/v3det_2023_v1_train.json', + data_prefix=dict(img=''), + filter_cfg=dict(filter_empty_gt=False), + pipeline=train_pipeline, + backend_args=None))) +val_dataloader = dict( + dataset=dict( + type='V3DetDataset', + data_root=data_root, + ann_file='annotations/v3det_2023_v1_val.json', + data_prefix=dict(img=''))) +test_dataloader = val_dataloader + +val_evaluator = dict( + ann_file=data_root + 'annotations/v3det_2023_v1_val.json', + use_mp_eval=True, + proposal_nums=[300]) +test_evaluator = val_evaluator + +# training schedule for 36e +# when using RFS, bs16, each epoch ~ 11460 iter +max_iter = 412560 +train_cfg = dict( + _delete_=True, + type='IterBasedTrainLoop', + max_iters=max_iter, + val_interval=max_iter / 5) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# learning rate +param_scheduler = [ + dict( + type='MultiStepLR', + begin=0, + end=max_iter, + by_epoch=False, + milestones=[343800], # 30e + gamma=0.1) +] + +default_hooks = dict( + timer=dict(type='IterTimerHook'), + param_scheduler=dict(type='ParamSchedulerHook'), + checkpoint=dict( + type='CheckpointHook', + by_epoch=False, + interval=11460, + max_keep_ckpts=3)) + +log_processor = dict(type='LogProcessor', window_size=50, by_epoch=False) diff --git a/mmdetection/configs/v3det/dino-4scale_swin_16xb1_sample1e-3_v3det_36e.py b/mmdetection/configs/v3det/dino-4scale_swin_16xb1_sample1e-3_v3det_36e.py new file mode 100644 index 00000000..100c4ba4 --- /dev/null +++ b/mmdetection/configs/v3det/dino-4scale_swin_16xb1_sample1e-3_v3det_36e.py @@ -0,0 +1,27 @@ +_base_ = 'dino-4scale_r50_8xb2_sample1e-3_v3det_36e.py' + +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_base_patch4_window7_224.pth' # noqa + +model = dict( + backbone=dict( + _delete_=True, + type='SwinTransformer', + embed_dims=128, + depths=[2, 2, 18, 2], + num_heads=[4, 8, 16, 32], + window_size=7, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.3, + patch_norm=True, + out_indices=(1, 2, 3), + with_cp=False, + convert_weights=True, + init_cfg=dict(type='Pretrained', checkpoint=pretrained)), + neck=dict(in_channels=[256, 512, 1024]), +) + +train_dataloader = dict(batch_size=1) diff --git a/mmdetection/configs/v3det/faster_rcnn_r50_fpn_8x4_sample1e-3_mstrain_v3det_2x.py b/mmdetection/configs/v3det/faster_rcnn_r50_fpn_8x4_sample1e-3_mstrain_v3det_2x.py new file mode 100644 index 00000000..3d306fb0 --- /dev/null +++ b/mmdetection/configs/v3det/faster_rcnn_r50_fpn_8x4_sample1e-3_mstrain_v3det_2x.py @@ -0,0 +1,72 @@ +_base_ = [ + '../_base_/models/faster-rcnn_r50_fpn.py', '../_base_/datasets/v3det.py', + '../_base_/schedules/schedule_2x.py', '../_base_/default_runtime.py' +] +# model settings +model = dict( + roi_head=dict( + bbox_head=dict( + num_classes=13204, + reg_class_agnostic=True, + cls_predictor_cfg=dict( + type='NormedLinear', tempearture=50, bias=True), + loss_cls=dict( + type='CrossEntropyCustomLoss', + num_classes=13204, + use_sigmoid=True, + loss_weight=1.0), + loss_bbox=dict(type='L1Loss', loss_weight=1.0))), + # model training and testing settings + train_cfg=dict( + rpn_proposal=dict(nms_pre=4000, max_per_img=2000), + rcnn=dict( + assigner=dict( + perm_repeat_gt_cfg=dict(iou_thr=0.7, perm_range=0.01)))), + test_cfg=dict( + rcnn=dict( + score_thr=0.0001, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=300))) +# dataset settings +train_dataloader = dict(batch_size=4, num_workers=8) + +# training schedule for 2x +max_iter = 68760 * 2 +train_cfg = dict( + _delete_=True, + type='IterBasedTrainLoop', + max_iters=max_iter, + val_interval=max_iter) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0 / 2048, + by_epoch=False, + begin=0, + end=5000), + dict( + type='MultiStepLR', + begin=0, + end=max_iter, + by_epoch=False, + milestones=[45840 * 2, 63030 * 2], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(_delete_=True, type='AdamW', lr=1e-4 * 1, weight_decay=0.1), + clip_grad=dict(max_norm=35, norm_type=2)) + +# Default setting for scaling LR automatically +# - `enable` means enable scaling LR automatically +# or not by default. +# - `base_batch_size` = (8 GPUs) x (2 samples per GPU). +auto_scale_lr = dict(enable=False, base_batch_size=32) + +default_hooks = dict( + checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=5730 * 2)) +log_processor = dict(type='LogProcessor', window_size=50, by_epoch=False) diff --git a/mmdetection/configs/v3det/faster_rcnn_swinb_fpn_8x4_sample1e-3_mstrain_v3det_2x.py b/mmdetection/configs/v3det/faster_rcnn_swinb_fpn_8x4_sample1e-3_mstrain_v3det_2x.py new file mode 100644 index 00000000..b0b11108 --- /dev/null +++ b/mmdetection/configs/v3det/faster_rcnn_swinb_fpn_8x4_sample1e-3_mstrain_v3det_2x.py @@ -0,0 +1,27 @@ +_base_ = [ + './faster_rcnn_r50_fpn_8x4_sample1e-3_mstrain_v3det_2x.py', +] + +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_base_patch4_window7_224.pth' # noqa + +# model settings +model = dict( + backbone=dict( + _delete_=True, + type='SwinTransformer', + embed_dims=128, + depths=[2, 2, 18, 2], + num_heads=[4, 8, 16, 32], + window_size=7, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0., + attn_drop_rate=0., + drop_path_rate=0.3, + patch_norm=True, + out_indices=(0, 1, 2, 3), + with_cp=False, + convert_weights=True, + init_cfg=dict(type='Pretrained', checkpoint=pretrained)), + neck=dict(in_channels=[128, 256, 512, 1024])) diff --git a/mmdetection/configs/v3det/fcos_r50_fpn_8x4_sample1e-3_mstrain_v3det_2x.py b/mmdetection/configs/v3det/fcos_r50_fpn_8x4_sample1e-3_mstrain_v3det_2x.py new file mode 100644 index 00000000..b78e38c9 --- /dev/null +++ b/mmdetection/configs/v3det/fcos_r50_fpn_8x4_sample1e-3_mstrain_v3det_2x.py @@ -0,0 +1,116 @@ +_base_ = [ + '../_base_/datasets/v3det.py', '../_base_/schedules/schedule_2x.py', + '../_base_/default_runtime.py' +] +# model settings +model = dict( + type='FCOS', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_output', # use P5 + num_outs=5, + relu_before_extra_convs=True), + bbox_head=dict( + type='FCOSHead', + num_classes=13204, + in_channels=256, + stacked_convs=4, + feat_channels=256, + strides=[8, 16, 32, 64, 128], + cls_predictor_cfg=dict(type='NormedLinear', tempearture=50, bias=True), + loss_cls=dict( + type='FocalCustomLoss', + use_sigmoid=True, + num_classes=13204, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='IoULoss', loss_weight=1.0), + loss_centerness=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)), + # model training and testing settings + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.4, + min_pos_iou=0, + ignore_iof_thr=-1, + perm_repeat_gt_cfg=dict(iou_thr=0.7, perm_range=0.01)), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.0001, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=300)) +# dataset settings + +backend_args = None + +train_dataloader = dict(batch_size=2, num_workers=8) + +# training schedule for 2x +max_iter = 68760 * 2 * 2 +train_cfg = dict( + _delete_=True, + type='IterBasedTrainLoop', + max_iters=max_iter, + val_interval=max_iter) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=1.0 / 2048, + by_epoch=False, + begin=0, + end=5000 * 2), + dict( + type='MultiStepLR', + begin=0, + end=max_iter, + by_epoch=False, + milestones=[45840 * 2 * 2, 63030 * 2 * 2], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict( + _delete_=True, type='AdamW', lr=1e-4 * 0.25, weight_decay=0.1), + clip_grad=dict(max_norm=35, norm_type=2)) + +# Default setting for scaling LR automatically +# - `enable` means enable scaling LR automatically +# or not by default. +# - `base_batch_size` = (8 GPUs) x (2 samples per GPU). +auto_scale_lr = dict(enable=False, base_batch_size=32) + +default_hooks = dict( + checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=5730 * 2)) +log_processor = dict(type='LogProcessor', window_size=50, by_epoch=False) + +find_unused_parameters = True diff --git a/mmdetection/configs/v3det/fcos_swinb_fpn_8x4_sample1e-3_mstrain_v3det_2x.py b/mmdetection/configs/v3det/fcos_swinb_fpn_8x4_sample1e-3_mstrain_v3det_2x.py new file mode 100644 index 00000000..6ca952a2 --- /dev/null +++ b/mmdetection/configs/v3det/fcos_swinb_fpn_8x4_sample1e-3_mstrain_v3det_2x.py @@ -0,0 +1,27 @@ +_base_ = [ + './fcos_r50_fpn_8x4_sample1e-3_mstrain_v3det_2x.py', +] + +pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_base_patch4_window7_224.pth' # noqa + +# model settings +model = dict( + backbone=dict( + _delete_=True, + type='SwinTransformer', + embed_dims=128, + depths=[2, 2, 18, 2], + num_heads=[4, 8, 16, 32], + window_size=7, + mlp_ratio=4, + qkv_bias=True, + qk_scale=None, + drop_rate=0.0, + attn_drop_rate=0.0, + drop_path_rate=0.3, + patch_norm=True, + out_indices=(0, 1, 2, 3), + with_cp=False, + convert_weights=True, + init_cfg=dict(type='Pretrained', checkpoint=pretrained)), + neck=dict(in_channels=[128, 256, 512, 1024], force_grad_on_level=True)) diff --git a/mmdetection/configs/v3det/v3det_icon.jpg b/mmdetection/configs/v3det/v3det_icon.jpg new file mode 100644 index 00000000..b25be6fd Binary files /dev/null and b/mmdetection/configs/v3det/v3det_icon.jpg differ diff --git a/mmdetection/configs/vfnet/README.md b/mmdetection/configs/vfnet/README.md new file mode 100644 index 00000000..73b5c07b --- /dev/null +++ b/mmdetection/configs/vfnet/README.md @@ -0,0 +1,48 @@ +# VarifocalNet + +> [VarifocalNet: An IoU-aware Dense Object Detector](https://arxiv.org/abs/2008.13367) + + + +## Abstract + +Accurately ranking the vast number of candidate detections is crucial for dense object detectors to achieve high performance. Prior work uses the classification score or a combination of classification and predicted localization scores to rank candidates. However, neither option results in a reliable ranking, thus degrading detection performance. In this paper, we propose to learn an Iou-aware Classification Score (IACS) as a joint representation of object presence confidence and localization accuracy. We show that dense object detectors can achieve a more accurate ranking of candidate detections based on the IACS. We design a new loss function, named Varifocal Loss, to train a dense object detector to predict the IACS, and propose a new star-shaped bounding box feature representation for IACS prediction and bounding box refinement. Combining these two new components and a bounding box refinement branch, we build an IoU-aware dense object detector based on the FCOS+ATSS architecture, that we call VarifocalNet or VFNet for short. Extensive experiments on MS COCO show that our VFNet consistently surpasses the strong baseline by ∼2.0 AP with different backbones. Our best model VFNet-X-1200 with Res2Net-101-DCN achieves a single-model single-scale AP of 55.1 on COCO test-dev, which is state-of-the-art among various object detectors. + +
    + +
    + +## Introduction + +**VarifocalNet (VFNet)** learns to predict the IoU-aware classification score which mixes the object presence confidence and localization accuracy together as the detection score for a bounding box. The learning is supervised by the proposed Varifocal Loss (VFL), based on a new star-shaped bounding box feature representation (the features at nine yellow sampling points). Given the new representation, the object localization accuracy is further improved by refining the initially regressed bounding box. The full paper is available at: [https://arxiv.org/abs/2008.13367](https://arxiv.org/abs/2008.13367). + +## Results and Models + +| Backbone | Style | DCN | MS train | Lr schd | Inf time (fps) | box AP (val) | box AP (test-dev) | Config | Download | +| :---------: | :-----: | :-: | :------: | :-----: | :------------: | :----------: | :---------------: | :---------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50 | pytorch | N | N | 1x | - | 41.6 | 41.6 | [config](./vfnet_r50_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_r50_fpn_1x_coco/vfnet_r50_fpn_1x_coco_20201027-38db6f58.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_r50_fpn_1x_coco/vfnet_r50_fpn_1x_coco.json) | +| R-50 | pytorch | N | Y | 2x | - | 44.5 | 44.8 | [config](./vfnet_r50_fpn_ms-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_r50_fpn_mstrain_2x_coco/vfnet_r50_fpn_mstrain_2x_coco_20201027-7cc75bd2.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_r50_fpn_mstrain_2x_coco/vfnet_r50_fpn_mstrain_2x_coco.json) | +| R-50 | pytorch | Y | Y | 2x | - | 47.8 | 48.0 | [config](./vfnet_r50-mdconv-c3-c5_fpn_ms-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_r50_fpn_mdconv_c3-c5_mstrain_2x_coco/vfnet_r50_fpn_mdconv_c3-c5_mstrain_2x_coco_20201027pth-6879c318.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_r50_fpn_mdconv_c3-c5_mstrain_2x_coco/vfnet_r50_fpn_mdconv_c3-c5_mstrain_2x_coco.json) | +| R-101 | pytorch | N | N | 1x | - | 43.0 | 43.6 | [config](./vfnet_r101_fpn_1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_r101_fpn_1x_coco/vfnet_r101_fpn_1x_coco_20201027pth-c831ece7.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_r101_fpn_1x_coco/vfnet_r101_fpn_1x_coco.json) | +| R-101 | pytorch | N | Y | 2x | - | 46.2 | 46.7 | [config](./vfnet_r101_fpn_ms-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_r101_fpn_mstrain_2x_coco/vfnet_r101_fpn_mstrain_2x_coco_20201027pth-4a5d53f1.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_r101_fpn_mstrain_2x_coco/vfnet_r101_fpn_mstrain_2x_coco.json) | +| R-101 | pytorch | Y | Y | 2x | - | 49.0 | 49.2 | [config](./vfnet_r101-mdconv-c3-c5_fpn_ms-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_r101_fpn_mdconv_c3-c5_mstrain_2x_coco/vfnet_r101_fpn_mdconv_c3-c5_mstrain_2x_coco_20201027pth-7729adb5.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_r101_fpn_mdconv_c3-c5_mstrain_2x_coco/vfnet_r101_fpn_mdconv_c3-c5_mstrain_2x_coco.json) | +| X-101-32x4d | pytorch | Y | Y | 2x | - | 49.7 | 50.0 | [config](./vfnet_x101-32x4d-mdconv-c3-c5_fpn_ms-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_x101_32x4d_fpn_mdconv_c3-c5_mstrain_2x_coco/vfnet_x101_32x4d_fpn_mdconv_c3-c5_mstrain_2x_coco_20201027pth-d300a6fc.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_x101_32x4d_fpn_mdconv_c3-c5_mstrain_2x_coco/vfnet_x101_32x4d_fpn_mdconv_c3-c5_mstrain_2x_coco.json) | +| X-101-64x4d | pytorch | Y | Y | 2x | - | 50.4 | 50.8 | [config](./vfnet_x101-64x4d-mdconv-c3-c5_fpn_ms-2x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_x101_64x4d_fpn_mdconv_c3-c5_mstrain_2x_coco/vfnet_x101_64x4d_fpn_mdconv_c3-c5_mstrain_2x_coco_20201027pth-b5f6da5e.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_x101_64x4d_fpn_mdconv_c3-c5_mstrain_2x_coco/vfnet_x101_64x4d_fpn_mdconv_c3-c5_mstrain_2x_coco.json) | + +**Notes:** + +- The MS-train scale range is 1333x\[480:960\] (`range` mode) and the inference scale keeps 1333x800. +- DCN means using `DCNv2` in both backbone and head. +- Inference time will be updated soon. +- More results and pre-trained models can be found in [VarifocalNet-Github](https://github.com/hyz-xmaster/VarifocalNet) + +## Citation + +```latex +@article{zhang2020varifocalnet, + title={VarifocalNet: An IoU-aware Dense Object Detector}, + author={Zhang, Haoyang and Wang, Ying and Dayoub, Feras and S{\"u}nderhauf, Niko}, + journal={arXiv preprint arXiv:2008.13367}, + year={2020} +} +``` diff --git a/mmdetection/configs/vfnet/metafile.yml b/mmdetection/configs/vfnet/metafile.yml new file mode 100644 index 00000000..1b791d01 --- /dev/null +++ b/mmdetection/configs/vfnet/metafile.yml @@ -0,0 +1,116 @@ +Collections: + - Name: VFNet + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - FPN + - ResNet + - Varifocal Loss + Paper: + URL: https://arxiv.org/abs/2008.13367 + Title: 'VarifocalNet: An IoU-aware Dense Object Detector' + README: configs/vfnet/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.6.0/mmdet/models/detectors/vfnet.py#L6 + Version: v2.6.0 + +Models: + - Name: vfnet_r50_fpn_1x_coco + In Collection: VFNet + Config: configs/vfnet/vfnet_r50_fpn_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 41.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_r50_fpn_1x_coco/vfnet_r50_fpn_1x_coco_20201027-38db6f58.pth + + - Name: vfnet_r50_fpn_ms-2x_coco + In Collection: VFNet + Config: configs/vfnet/vfnet_r50_fpn_ms-2x_coco.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 44.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_r50_fpn_mstrain_2x_coco/vfnet_r50_fpn_mstrain_2x_coco_20201027-7cc75bd2.pth + + - Name: vfnet_r50-mdconv-c3-c5_fpn_ms-2x_coco + In Collection: VFNet + Config: configs/vfnet/vfnet_r50-mdconv-c3-c5_fpn_ms-2x_coco.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 48.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_r50_fpn_mdconv_c3-c5_mstrain_2x_coco/vfnet_r50_fpn_mdconv_c3-c5_mstrain_2x_coco_20201027pth-6879c318.pth + + - Name: vfnet_r101_fpn_1x_coco + In Collection: VFNet + Config: configs/vfnet/vfnet_r101_fpn_1x_coco.py + Metadata: + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 43.6 + Weights: https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_r101_fpn_1x_coco/vfnet_r101_fpn_1x_coco_20201027pth-c831ece7.pth + + - Name: vfnet_r101_fpn_ms-2x_coco + In Collection: VFNet + Config: configs/vfnet/vfnet_r101_fpn_ms-2x_coco.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 46.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_r101_fpn_mstrain_2x_coco/vfnet_r101_fpn_mstrain_2x_coco_20201027pth-4a5d53f1.pth + + - Name: vfnet_r101-mdconv-c3-c5_fpn_ms-2x_coco + In Collection: VFNet + Config: configs/vfnet/vfnet_r101-mdconv-c3-c5_fpn_ms-2x_coco.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 49.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_r101_fpn_mdconv_c3-c5_mstrain_2x_coco/vfnet_r101_fpn_mdconv_c3-c5_mstrain_2x_coco_20201027pth-7729adb5.pth + + - Name: vfnet_x101-32x4d-mdconv-c3-c5_fpn_ms-2x_coco + In Collection: VFNet + Config: configs/vfnet/vfnet_x101-32x4d-mdconv-c3-c5_fpn_ms-2x_coco.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 50.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_x101_32x4d_fpn_mdconv_c3-c5_mstrain_2x_coco/vfnet_x101_32x4d_fpn_mdconv_c3-c5_mstrain_2x_coco_20201027pth-d300a6fc.pth + + - Name: vfnet_x101-64x4d-mdconv-c3-c5_fpn_ms-2x_coco + In Collection: VFNet + Config: configs/vfnet/vfnet_x101-64x4d-mdconv-c3-c5_fpn_ms-2x_coco.py + Metadata: + Epochs: 24 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 50.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/vfnet/vfnet_x101_64x4d_fpn_mdconv_c3-c5_mstrain_2x_coco/vfnet_x101_64x4d_fpn_mdconv_c3-c5_mstrain_2x_coco_20201027pth-b5f6da5e.pth diff --git a/mmdetection/configs/vfnet/vfnet_r101-mdconv-c3-c5_fpn_ms-2x_coco.py b/mmdetection/configs/vfnet/vfnet_r101-mdconv-c3-c5_fpn_ms-2x_coco.py new file mode 100644 index 00000000..2dd67a3b --- /dev/null +++ b/mmdetection/configs/vfnet/vfnet_r101-mdconv-c3-c5_fpn_ms-2x_coco.py @@ -0,0 +1,15 @@ +_base_ = './vfnet_r50-mdconv-c3-c5_fpn_ms-2x_coco.py' +model = dict( + backbone=dict( + type='ResNet', + depth=101, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + dcn=dict(type='DCNv2', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True), + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/vfnet/vfnet_r101_fpn_1x_coco.py b/mmdetection/configs/vfnet/vfnet_r101_fpn_1x_coco.py new file mode 100644 index 00000000..b296a079 --- /dev/null +++ b/mmdetection/configs/vfnet/vfnet_r101_fpn_1x_coco.py @@ -0,0 +1,6 @@ +_base_ = './vfnet_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/vfnet/vfnet_r101_fpn_2x_coco.py b/mmdetection/configs/vfnet/vfnet_r101_fpn_2x_coco.py new file mode 100644 index 00000000..37a7bacb --- /dev/null +++ b/mmdetection/configs/vfnet/vfnet_r101_fpn_2x_coco.py @@ -0,0 +1,20 @@ +_base_ = './vfnet_r50_fpn_1x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) +# learning policy +max_epochs = 24 +param_scheduler = [ + dict(type='LinearLR', start_factor=0.1, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] + +train_cfg = dict(max_epochs=max_epochs) diff --git a/mmdetection/configs/vfnet/vfnet_r101_fpn_ms-2x_coco.py b/mmdetection/configs/vfnet/vfnet_r101_fpn_ms-2x_coco.py new file mode 100644 index 00000000..62f064b7 --- /dev/null +++ b/mmdetection/configs/vfnet/vfnet_r101_fpn_ms-2x_coco.py @@ -0,0 +1,6 @@ +_base_ = './vfnet_r50_fpn_ms-2x_coco.py' +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/vfnet/vfnet_r50-mdconv-c3-c5_fpn_ms-2x_coco.py b/mmdetection/configs/vfnet/vfnet_r50-mdconv-c3-c5_fpn_ms-2x_coco.py new file mode 100644 index 00000000..08adf927 --- /dev/null +++ b/mmdetection/configs/vfnet/vfnet_r50-mdconv-c3-c5_fpn_ms-2x_coco.py @@ -0,0 +1,6 @@ +_base_ = './vfnet_r50_fpn_ms-2x_coco.py' +model = dict( + backbone=dict( + dcn=dict(type='DCNv2', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True)), + bbox_head=dict(dcn_on_last_conv=True)) diff --git a/mmdetection/configs/vfnet/vfnet_r50_fpn_1x_coco.py b/mmdetection/configs/vfnet/vfnet_r50_fpn_1x_coco.py new file mode 100644 index 00000000..99bc3b5f --- /dev/null +++ b/mmdetection/configs/vfnet/vfnet_r50_fpn_1x_coco.py @@ -0,0 +1,104 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +# model settings +model = dict( + type='VFNet', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_output', # use P5 + num_outs=5, + relu_before_extra_convs=True), + bbox_head=dict( + type='VFNetHead', + num_classes=80, + in_channels=256, + stacked_convs=3, + feat_channels=256, + strides=[8, 16, 32, 64, 128], + center_sampling=False, + dcn_on_last_conv=False, + use_atss=True, + use_vfl=True, + loss_cls=dict( + type='VarifocalLoss', + use_sigmoid=True, + alpha=0.75, + gamma=2.0, + iou_weighted=True, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=1.5), + loss_bbox_refine=dict(type='GIoULoss', loss_weight=2.0)), + # training and testing settings + train_cfg=dict( + assigner=dict(type='ATSSAssigner', topk=9), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) + +# data setting +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader + +# optimizer +optim_wrapper = dict( + optimizer=dict(lr=0.01), + paramwise_cfg=dict(bias_lr_mult=2., bias_decay_mult=0.), + clip_grad=None) +# learning rate +max_epochs = 12 +param_scheduler = [ + dict(type='LinearLR', start_factor=0.1, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] + +train_cfg = dict(max_epochs=max_epochs) diff --git a/mmdetection/configs/vfnet/vfnet_r50_fpn_ms-2x_coco.py b/mmdetection/configs/vfnet/vfnet_r50_fpn_ms-2x_coco.py new file mode 100644 index 00000000..0f8eed29 --- /dev/null +++ b/mmdetection/configs/vfnet/vfnet_r50_fpn_ms-2x_coco.py @@ -0,0 +1,36 @@ +_base_ = './vfnet_r50_fpn_1x_coco.py' +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='RandomResize', scale=[(1333, 480), (1333, 960)], + keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader +# learning policy +max_epochs = 24 +param_scheduler = [ + dict(type='LinearLR', start_factor=0.1, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[16, 22], + gamma=0.1) +] + +train_cfg = dict(max_epochs=max_epochs) diff --git a/mmdetection/configs/vfnet/vfnet_res2net-101_fpn_ms-2x_coco.py b/mmdetection/configs/vfnet/vfnet_res2net-101_fpn_ms-2x_coco.py new file mode 100644 index 00000000..94288e8e --- /dev/null +++ b/mmdetection/configs/vfnet/vfnet_res2net-101_fpn_ms-2x_coco.py @@ -0,0 +1,16 @@ +_base_ = './vfnet_r50_fpn_ms-2x_coco.py' +model = dict( + backbone=dict( + type='Res2Net', + depth=101, + scales=4, + base_width=26, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://res2net101_v1d_26w_4s'))) diff --git a/mmdetection/configs/vfnet/vfnet_res2net101-mdconv-c3-c5_fpn_ms-2x_coco.py b/mmdetection/configs/vfnet/vfnet_res2net101-mdconv-c3-c5_fpn_ms-2x_coco.py new file mode 100644 index 00000000..269330d3 --- /dev/null +++ b/mmdetection/configs/vfnet/vfnet_res2net101-mdconv-c3-c5_fpn_ms-2x_coco.py @@ -0,0 +1,18 @@ +_base_ = './vfnet_r50-mdconv-c3-c5_fpn_ms-2x_coco.py' +model = dict( + backbone=dict( + type='Res2Net', + depth=101, + scales=4, + base_width=26, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + dcn=dict(type='DCNv2', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True), + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://res2net101_v1d_26w_4s'))) diff --git a/mmdetection/configs/vfnet/vfnet_x101-32x4d-mdconv-c3-c5_fpn_ms-2x_coco.py b/mmdetection/configs/vfnet/vfnet_x101-32x4d-mdconv-c3-c5_fpn_ms-2x_coco.py new file mode 100644 index 00000000..465da0cb --- /dev/null +++ b/mmdetection/configs/vfnet/vfnet_x101-32x4d-mdconv-c3-c5_fpn_ms-2x_coco.py @@ -0,0 +1,17 @@ +_base_ = './vfnet_r50-mdconv-c3-c5_fpn_ms-2x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + dcn=dict(type='DCNv2', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/vfnet/vfnet_x101-32x4d_fpn_ms-2x_coco.py b/mmdetection/configs/vfnet/vfnet_x101-32x4d_fpn_ms-2x_coco.py new file mode 100644 index 00000000..486bcfe5 --- /dev/null +++ b/mmdetection/configs/vfnet/vfnet_x101-32x4d_fpn_ms-2x_coco.py @@ -0,0 +1,15 @@ +_base_ = './vfnet_r50_fpn_ms-2x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=32, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_32x4d'))) diff --git a/mmdetection/configs/vfnet/vfnet_x101-64x4d-mdconv-c3-c5_fpn_ms-2x_coco.py b/mmdetection/configs/vfnet/vfnet_x101-64x4d-mdconv-c3-c5_fpn_ms-2x_coco.py new file mode 100644 index 00000000..14a070e7 --- /dev/null +++ b/mmdetection/configs/vfnet/vfnet_x101-64x4d-mdconv-c3-c5_fpn_ms-2x_coco.py @@ -0,0 +1,17 @@ +_base_ = './vfnet_r50-mdconv-c3-c5_fpn_ms-2x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + dcn=dict(type='DCNv2', deform_groups=1, fallback_on_stride=False), + stage_with_dcn=(False, True, True, True), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/vfnet/vfnet_x101-64x4d_fpn_ms-2x_coco.py b/mmdetection/configs/vfnet/vfnet_x101-64x4d_fpn_ms-2x_coco.py new file mode 100644 index 00000000..92e3f71d --- /dev/null +++ b/mmdetection/configs/vfnet/vfnet_x101-64x4d_fpn_ms-2x_coco.py @@ -0,0 +1,15 @@ +_base_ = './vfnet_r50_fpn_ms-2x_coco.py' +model = dict( + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + style='pytorch', + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://resnext101_64x4d'))) diff --git a/mmdetection/configs/wider_face/README.md b/mmdetection/configs/wider_face/README.md new file mode 100644 index 00000000..1904506c --- /dev/null +++ b/mmdetection/configs/wider_face/README.md @@ -0,0 +1,57 @@ +# WIDER FACE + +> [WIDER FACE: A Face Detection Benchmark](https://arxiv.org/abs/1511.06523) + + + +## Abstract + +Face detection is one of the most studied topics in the computer vision community. Much of the progresses have been made by the availability of face detection benchmark datasets. We show that there is a gap between current face detection performance and the real world requirements. To facilitate future face detection research, we introduce the WIDER FACE dataset, which is 10 times larger than existing datasets. The dataset contains rich annotations, including occlusions, poses, event categories, and face bounding boxes. Faces in the proposed dataset are extremely challenging due to large variations in scale, pose and occlusion, as shown in Fig. 1. Furthermore, we show that WIDER FACE dataset is an effective training source for face detection. We benchmark several representative detection systems, providing an overview of state-of-the-art performance and propose a solution to deal with large scale variation. Finally, we discuss common failure cases that worth to be further investigated. + +
    + +
    + +## Introduction + +To use the WIDER Face dataset you need to download it +and extract to the `data/WIDERFace` folder. Annotation in the VOC format +can be found in this [repo](https://github.com/sovrasov/wider-face-pascal-voc-annotations.git). +You should move the annotation files from `WIDER_train_annotations` and `WIDER_val_annotations` folders +to the `Annotation` folders inside the corresponding directories `WIDER_train` and `WIDER_val`. +Also annotation lists `val.txt` and `train.txt` should be copied to `data/WIDERFace` from `WIDER_train_annotations` and `WIDER_val_annotations`. +The directory should be like this: + +``` +mmdetection +├── mmdet +├── tools +├── configs +├── data +│ ├── WIDERFace +│ │ ├── WIDER_train +│ | │ ├──0--Parade +│ | │ ├── ... +│ | │ ├── Annotations +│ │ ├── WIDER_val +│ | │ ├──0--Parade +│ | │ ├── ... +│ | │ ├── Annotations +│ │ ├── val.txt +│ │ ├── train.txt + +``` + +After that you can train the SSD300 on WIDER by launching training with the `ssd300_wider_face.py` config or +create your own config based on the presented one. + +## Citation + +```latex +@inproceedings{yang2016wider, + Author = {Yang, Shuo and Luo, Ping and Loy, Chen Change and Tang, Xiaoou}, + Booktitle = {IEEE Conference on Computer Vision and Pattern Recognition (CVPR)}, + Title = {WIDER FACE: A Face Detection Benchmark}, + Year = {2016} +} +``` diff --git a/mmdetection/configs/wider_face/retinanet_r50_fpn_1x_widerface.py b/mmdetection/configs/wider_face/retinanet_r50_fpn_1x_widerface.py new file mode 100644 index 00000000..78067255 --- /dev/null +++ b/mmdetection/configs/wider_face/retinanet_r50_fpn_1x_widerface.py @@ -0,0 +1,10 @@ +_base_ = [ + '../_base_/models/retinanet_r50_fpn.py', + '../_base_/datasets/wider_face.py', '../_base_/schedules/schedule_1x.py', + '../_base_/default_runtime.py' +] +# model settings +model = dict(bbox_head=dict(num_classes=1)) +# optimizer +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)) diff --git a/mmdetection/configs/wider_face/ssd300_8xb32-24e_widerface.py b/mmdetection/configs/wider_face/ssd300_8xb32-24e_widerface.py new file mode 100644 index 00000000..02c3c927 --- /dev/null +++ b/mmdetection/configs/wider_face/ssd300_8xb32-24e_widerface.py @@ -0,0 +1,64 @@ +_base_ = [ + '../_base_/models/ssd300.py', '../_base_/datasets/wider_face.py', + '../_base_/default_runtime.py', '../_base_/schedules/schedule_2x.py' +] +model = dict(bbox_head=dict(num_classes=1)) + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict( + type='Expand', + mean={{_base_.model.data_preprocessor.mean}}, + to_rgb={{_base_.model.data_preprocessor.bgr_to_rgb}}, + ratio_range=(1, 4)), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.3), + dict(type='Resize', scale=(300, 300), keep_ratio=False), + dict(type='RandomFlip', prob=0.5), + dict(type='PackDetInputs') +] + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=_base_.backend_args), + dict(type='Resize', scale=(300, 300), keep_ratio=False), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +dataset_type = 'WIDERFaceDataset' +data_root = 'data/WIDERFace/' +train_dataloader = dict( + batch_size=32, num_workers=8, dataset=dict(pipeline=train_pipeline)) + +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, + end=1000), + dict(type='MultiStepLR', by_epoch=True, milestones=[16, 20], gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + optimizer=dict(lr=0.012, momentum=0.9, weight_decay=5e-4), + clip_grad=dict(max_norm=35, norm_type=2)) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (32 samples per GPU) +auto_scale_lr = dict(base_batch_size=256) diff --git a/mmdetection/configs/yolact/README.md b/mmdetection/configs/yolact/README.md new file mode 100644 index 00000000..e884ad65 --- /dev/null +++ b/mmdetection/configs/yolact/README.md @@ -0,0 +1,75 @@ +# YOLACT + +> [YOLACT: Real-time Instance Segmentation](https://arxiv.org/abs/1904.02689) + + + +## Abstract + +We present a simple, fully-convolutional model for real-time instance segmentation that achieves 29.8 mAP on MS COCO at 33.5 fps evaluated on a single Titan Xp, which is significantly faster than any previous competitive approach. Moreover, we obtain this result after training on only one GPU. We accomplish this by breaking instance segmentation into two parallel subtasks: (1) generating a set of prototype masks and (2) predicting per-instance mask coefficients. Then we produce instance masks by linearly combining the prototypes with the mask coefficients. We find that because this process doesn't depend on repooling, this approach produces very high-quality masks and exhibits temporal stability for free. Furthermore, we analyze the emergent behavior of our prototypes and show they learn to localize instances on their own in a translation variant manner, despite being fully-convolutional. Finally, we also propose Fast NMS, a drop-in 12 ms faster replacement for standard NMS that only has a marginal performance penalty. + +
    + +
    + +## Introduction + +A simple, fully convolutional model for real-time instance segmentation. This is the code for our paper: + +- [YOLACT: Real-time Instance Segmentation](https://arxiv.org/abs/1904.02689) + + + +For a real-time demo, check out our ICCV video: +[![IMAGE ALT TEXT HERE](https://img.youtube.com/vi/0pMfmo8qfpQ/0.jpg)](https://www.youtube.com/watch?v=0pMfmo8qfpQ) + +## Evaluation + +Here are our YOLACT models along with their FPS on a Titan Xp and mAP on COCO's `val`: + +| Image Size | GPU x BS | Backbone | \*FPS | mAP | Weights | Configs | Download | +| :--------: | :------: | :-----------: | :---: | :--: | :-----: | :--------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------: | +| 550 | 1x8 | Resnet50-FPN | 42.5 | 29.0 | | [config](./yolact_r50_1xb8-55e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/yolact/yolact_r50_1x8_coco/yolact_r50_1x8_coco_20200908-f38d58df.pth) | +| 550 | 8x8 | Resnet50-FPN | 42.5 | 28.4 | | [config](./yolact_r50_8xb8-55e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/yolact/yolact_r50_8x8_coco/yolact_r50_8x8_coco_20200908-ca34f5db.pth) | +| 550 | 1x8 | Resnet101-FPN | 33.5 | 30.4 | | [config](./yolact_r101_1xb8-55e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/yolact/yolact_r101_1x8_coco/yolact_r101_1x8_coco_20200908-4cbe9101.pth) | + +\*Note: The FPS is evaluated by the [original implementation](https://github.com/dbolya/yolact). When calculating FPS, only the model inference time is taken into account. Data loading and post-processing operations such as converting masks to RLE code, generating COCO JSON results, image rendering are not included. + +## Training + +All the aforementioned models are trained with a single GPU. It typically takes ~12GB VRAM when using resnet-101 as the backbone. If you want to try multiple GPUs training, you may have to modify the configuration files accordingly, such as adjusting the training schedule and freezing batch norm. + +```Shell +# Trains using the resnet-101 backbone with a batch size of 8 on a single GPU. +./tools/dist_train.sh configs/yolact/yolact_r101.py 1 +``` + +## Testing + +Please refer to [mmdetection/docs/getting_started.md](https://mmdetection.readthedocs.io/en/latest/1_exist_data_model.html#test-existing-models). + +## Citation + +If you use YOLACT or this code base in your work, please cite + +```latex +@inproceedings{yolact-iccv2019, + author = {Daniel Bolya and Chong Zhou and Fanyi Xiao and Yong Jae Lee}, + title = {YOLACT: {Real-time} Instance Segmentation}, + booktitle = {ICCV}, + year = {2019}, +} +``` + + diff --git a/mmdetection/configs/yolact/metafile.yml b/mmdetection/configs/yolact/metafile.yml new file mode 100644 index 00000000..9ca76b3d --- /dev/null +++ b/mmdetection/configs/yolact/metafile.yml @@ -0,0 +1,81 @@ +Collections: + - Name: YOLACT + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - FPN + - ResNet + Paper: + URL: https://arxiv.org/abs/1904.02689 + Title: 'YOLACT: Real-time Instance Segmentation' + README: configs/yolact/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.5.0/mmdet/models/detectors/yolact.py#L9 + Version: v2.5.0 + +Models: + - Name: yolact_r50_1x8_coco + In Collection: YOLACT + Config: configs/yolact/yolact_r50_1xb8-55e_coco.py + Metadata: + Training Resources: 1x V100 GPU + Batch Size: 8 + Epochs: 55 + inference time (ms/im): + - value: 23.53 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (550, 550) + Results: + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 29.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/yolact/yolact_r50_1x8_coco/yolact_r50_1x8_coco_20200908-f38d58df.pth + + - Name: yolact_r50_8x8_coco + In Collection: YOLACT + Config: configs/yolact/yolact_r50_8xb8-55e_coco.py + Metadata: + Batch Size: 64 + Epochs: 55 + inference time (ms/im): + - value: 23.53 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (550, 550) + Results: + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 28.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/yolact/yolact_r50_8x8_coco/yolact_r50_8x8_coco_20200908-ca34f5db.pth + + - Name: yolact_r101_1x8_coco + In Collection: YOLACT + Config: configs/yolact/yolact_r101_1xb8-55e_coco.py + Metadata: + Training Resources: 1x V100 GPU + Batch Size: 8 + Epochs: 55 + inference time (ms/im): + - value: 29.85 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (550, 550) + Results: + - Task: Instance Segmentation + Dataset: COCO + Metrics: + mask AP: 30.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/yolact/yolact_r101_1x8_coco/yolact_r101_1x8_coco_20200908-4cbe9101.pth diff --git a/mmdetection/configs/yolact/yolact_r101_1xb8-55e_coco.py b/mmdetection/configs/yolact/yolact_r101_1xb8-55e_coco.py new file mode 100644 index 00000000..e6ffe296 --- /dev/null +++ b/mmdetection/configs/yolact/yolact_r101_1xb8-55e_coco.py @@ -0,0 +1,7 @@ +_base_ = './yolact_r50_1xb8-55e_coco.py' + +model = dict( + backbone=dict( + depth=101, + init_cfg=dict(type='Pretrained', + checkpoint='torchvision://resnet101'))) diff --git a/mmdetection/configs/yolact/yolact_r50_1xb8-55e_coco.py b/mmdetection/configs/yolact/yolact_r50_1xb8-55e_coco.py new file mode 100644 index 00000000..b7dabf15 --- /dev/null +++ b/mmdetection/configs/yolact/yolact_r50_1xb8-55e_coco.py @@ -0,0 +1,170 @@ +_base_ = [ + '../_base_/datasets/coco_instance.py', '../_base_/default_runtime.py' +] +img_norm_cfg = dict( + mean=[123.68, 116.78, 103.94], std=[58.40, 57.12, 57.38], to_rgb=True) +# model settings +input_size = 550 +model = dict( + type='YOLACT', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=img_norm_cfg['mean'], + std=img_norm_cfg['std'], + bgr_to_rgb=img_norm_cfg['to_rgb'], + pad_mask=True), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), + frozen_stages=-1, # do not freeze stem + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=False, # update the statistics of bn + zero_init_residual=False, + style='pytorch', + init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + add_extra_convs='on_input', + num_outs=5, + upsample_cfg=dict(mode='bilinear')), + bbox_head=dict( + type='YOLACTHead', + num_classes=80, + in_channels=256, + feat_channels=256, + anchor_generator=dict( + type='AnchorGenerator', + octave_base_scale=3, + scales_per_octave=1, + base_sizes=[8, 16, 32, 64, 128], + ratios=[0.5, 1.0, 2.0], + strides=[550.0 / x for x in [69, 35, 18, 9, 5]], + centers=[(550 * 0.5 / x, 550 * 0.5 / x) + for x in [69, 35, 18, 9, 5]]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[0.1, 0.1, 0.2, 0.2]), + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + reduction='none', + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.5), + num_head_convs=1, + num_protos=32, + use_ohem=True), + mask_head=dict( + type='YOLACTProtonet', + in_channels=256, + num_protos=32, + num_classes=80, + max_masks_to_train=100, + loss_mask_weight=6.125, + with_seg_branch=True, + loss_segm=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)), + # training and testing settings + train_cfg=dict( + assigner=dict( + type='MaxIoUAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.4, + min_pos_iou=0., + ignore_iof_thr=-1, + gt_max_assign_all=False), + sampler=dict(type='PseudoSampler'), # YOLACT should use PseudoSampler + # smoothl1_beta=1., + allowed_border=-1, + pos_weight=-1, + neg_pos_ratio=3, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + mask_thr=0.5, + iou_thr=0.5, + top_k=200, + max_per_img=100, + mask_thr_binary=0.5)) +# dataset settings +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict(type='FilterAnnotations', min_gt_bbox_wh=(4.0, 4.0)), + dict( + type='Expand', + mean=img_norm_cfg['mean'], + to_rgb=img_norm_cfg['to_rgb'], + ratio_range=(1, 4)), + dict( + type='MinIoURandomCrop', + min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), + min_crop_size=0.3), + dict(type='Resize', scale=(input_size, input_size), keep_ratio=False), + dict(type='RandomFlip', prob=0.5), + dict( + type='PhotoMetricDistortion', + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=(input_size, input_size), keep_ratio=False), + dict(type='LoadAnnotations', with_bbox=True, with_mask=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict( + batch_size=8, + num_workers=4, + batch_sampler=None, + dataset=dict(pipeline=train_pipeline)) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader + +max_epochs = 55 +# training schedule for 55e +train_cfg = dict( + type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1) +val_cfg = dict(type='ValLoop') +test_cfg = dict(type='TestLoop') + +# learning rate +param_scheduler = [ + dict(type='LinearLR', start_factor=0.1, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[20, 42, 49, 52], + gamma=0.1) +] + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=1e-3, momentum=0.9, weight_decay=5e-4)) + +custom_hooks = [ + dict(type='CheckInvalidLossHook', interval=50, priority='VERY_LOW') +] + +env_cfg = dict(cudnn_benchmark=True) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (1 GPUs) x (8 samples per GPU) +auto_scale_lr = dict(base_batch_size=8) diff --git a/mmdetection/configs/yolact/yolact_r50_8xb8-55e_coco.py b/mmdetection/configs/yolact/yolact_r50_8xb8-55e_coco.py new file mode 100644 index 00000000..e39c285d --- /dev/null +++ b/mmdetection/configs/yolact/yolact_r50_8xb8-55e_coco.py @@ -0,0 +1,23 @@ +_base_ = 'yolact_r50_1xb8-55e_coco.py' + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(lr=8e-3), + clip_grad=dict(max_norm=35, norm_type=2)) +# learning rate +max_epochs = 55 +param_scheduler = [ + dict(type='LinearLR', start_factor=0.1, by_epoch=False, begin=0, end=1000), + dict( + type='MultiStepLR', + begin=0, + end=max_epochs, + by_epoch=True, + milestones=[20, 42, 49, 52], + gamma=0.1) +] +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (8 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/yolo/README.md b/mmdetection/configs/yolo/README.md new file mode 100644 index 00000000..9cb47bcc --- /dev/null +++ b/mmdetection/configs/yolo/README.md @@ -0,0 +1,55 @@ +# YOLOv3 + +> [YOLOv3: An Incremental Improvement](https://arxiv.org/abs/1804.02767) + + + +## Abstract + +We present some updates to YOLO! We made a bunch of little design changes to make it better. We also trained this new network that's pretty swell. It's a little bigger than last time but more accurate. It's still fast though, don't worry. At 320x320 YOLOv3 runs in 22 ms at 28.2 mAP, as accurate as SSD but three times faster. When we look at the old .5 IOU mAP detection metric YOLOv3 is quite good. It achieves 57.9 mAP@50 in 51 ms on a Titan X, compared to 57.5 mAP@50 in 198 ms by RetinaNet, similar performance but 3.8x faster. + +
    + +
    + +## Results and Models + +| Backbone | Scale | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :--------: | :---: | :-----: | :------: | :------------: | :----: | :---------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| DarkNet-53 | 320 | 273e | 2.7 | 63.9 | 27.9 | [config](./yolov3_d53_8xb8-320-273e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/yolo/yolov3_d53_320_273e_coco/yolov3_d53_320_273e_coco-421362b6.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/yolo/yolov3_d53_320_273e_coco/yolov3_d53_320_273e_coco-20200819_172101.log.json) | +| DarkNet-53 | 416 | 273e | 3.8 | 61.2 | 30.9 | [config](./yolov3_d53_8xb8-ms-416-273e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/yolo/yolov3_d53_mstrain-416_273e_coco/yolov3_d53_mstrain-416_273e_coco-2b60fcd9.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/yolo/yolov3_d53_mstrain-416_273e_coco/yolov3_d53_mstrain-416_273e_coco-20200819_173424.log.json) | +| DarkNet-53 | 608 | 273e | 7.4 | 48.1 | 33.7 | [config](./yolov3_d53_8xb8-ms-608-273e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/yolo/yolov3_d53_mstrain-608_273e_coco/yolov3_d53_mstrain-608_273e_coco_20210518_115020-a2c3acb8.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/yolo/yolov3_d53_mstrain-608_273e_coco/yolov3_d53_mstrain-608_273e_coco_20210518_115020.log.json) | + +## Mixed Precision Training + +We also train YOLOv3 with mixed precision training. + +| Backbone | Scale | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :--------: | :---: | :-----: | :------: | :------------: | :----: | :-------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| DarkNet-53 | 608 | 273e | 4.7 | 48.1 | 33.8 | [config](./yolov3_d53_8xb8-amp-ms-608-273e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/yolo/yolov3_d53_fp16_mstrain-608_273e_coco/yolov3_d53_fp16_mstrain-608_273e_coco_20210517_213542-4bc34944.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/yolo/yolov3_d53_fp16_mstrain-608_273e_coco/yolov3_d53_fp16_mstrain-608_273e_coco_20210517_213542.log.json) | + +## Lightweight models + +| Backbone | Scale | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | +| :---------: | :---: | :-----: | :------: | :------------: | :----: | :------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| MobileNetV2 | 416 | 300e | 5.3 | | 23.9 | [config](./yolov3_mobilenetv2_8xb24-ms-416-300e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/yolo/yolov3_mobilenetv2_mstrain-416_300e_coco/yolov3_mobilenetv2_mstrain-416_300e_coco_20210718_010823-f68a07b3.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/yolo/yolov3_mobilenetv2_mstrain-416_300e_coco/yolov3_mobilenetv2_mstrain-416_300e_coco_20210718_010823.log.json) | +| MobileNetV2 | 320 | 300e | 3.2 | | 22.2 | [config](./yolov3_mobilenetv2_8xb24-320-300e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/yolo/yolov3_mobilenetv2_320_300e_coco/yolov3_mobilenetv2_320_300e_coco_20210719_215349-d18dff72.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/yolo/yolov3_mobilenetv2_320_300e_coco/yolov3_mobilenetv2_320_300e_coco_20210719_215349.log.json) | + +Notice: We reduce the number of channels to 96 in both head and neck. It can reduce the flops and parameters, which makes these models more suitable for edge devices. + +## Credit + +This implementation originates from the project of Haoyu Wu(@wuhy08) at Western Digital. + +## Citation + +```latex +@misc{redmon2018yolov3, + title={YOLOv3: An Incremental Improvement}, + author={Joseph Redmon and Ali Farhadi}, + year={2018}, + eprint={1804.02767}, + archivePrefix={arXiv}, + primaryClass={cs.CV} +} +``` diff --git a/mmdetection/configs/yolo/metafile.yml b/mmdetection/configs/yolo/metafile.yml new file mode 100644 index 00000000..627e70c4 --- /dev/null +++ b/mmdetection/configs/yolo/metafile.yml @@ -0,0 +1,124 @@ +Collections: + - Name: YOLOv3 + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - DarkNet + Paper: + URL: https://arxiv.org/abs/1804.02767 + Title: 'YOLOv3: An Incremental Improvement' + README: configs/yolo/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.4.0/mmdet/models/detectors/yolo.py#L8 + Version: v2.4.0 + +Models: + - Name: yolov3_d53_320_273e_coco + In Collection: YOLOv3 + Config: configs/yolo/yolov3_d53_8xb8-320-273e_coco.py + Metadata: + Training Memory (GB): 2.7 + inference time (ms/im): + - value: 15.65 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (320, 320) + Epochs: 273 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 27.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/yolo/yolov3_d53_320_273e_coco/yolov3_d53_320_273e_coco-421362b6.pth + + - Name: yolov3_d53_mstrain-416_273e_coco + In Collection: YOLOv3 + Config: configs/yolo/yolov3_d53_8xb8-ms-416-273e_coco.py + Metadata: + Training Memory (GB): 3.8 + inference time (ms/im): + - value: 16.34 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (416, 416) + Epochs: 273 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 30.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/yolo/yolov3_d53_mstrain-416_273e_coco/yolov3_d53_mstrain-416_273e_coco-2b60fcd9.pth + + - Name: yolov3_d53_mstrain-608_273e_coco + In Collection: YOLOv3 + Config: configs/yolo/yolov3_d53_8xb8-ms-608-273e_coco.py + Metadata: + Training Memory (GB): 7.4 + inference time (ms/im): + - value: 20.79 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP32 + resolution: (608, 608) + Epochs: 273 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 33.7 + Weights: https://download.openmmlab.com/mmdetection/v2.0/yolo/yolov3_d53_mstrain-608_273e_coco/yolov3_d53_mstrain-608_273e_coco_20210518_115020-a2c3acb8.pth + + - Name: yolov3_d53_fp16_mstrain-608_273e_coco + In Collection: YOLOv3 + Config: configs/yolo/yolov3_d53_8xb8-amp-ms-608-273e_coco.py + Metadata: + Training Memory (GB): 4.7 + inference time (ms/im): + - value: 20.79 + hardware: V100 + backend: PyTorch + batch size: 1 + mode: FP16 + resolution: (608, 608) + Epochs: 273 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 33.8 + Weights: https://download.openmmlab.com/mmdetection/v2.0/yolo/yolov3_d53_fp16_mstrain-608_273e_coco/yolov3_d53_fp16_mstrain-608_273e_coco_20210517_213542-4bc34944.pth + + - Name: yolov3_mobilenetv2_8xb24-320-300e_coco + In Collection: YOLOv3 + Config: configs/yolo/yolov3_mobilenetv2_8xb24-320-300e_coco.py + Metadata: + Training Memory (GB): 3.2 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 22.2 + Weights: https://download.openmmlab.com/mmdetection/v2.0/yolo/yolov3_mobilenetv2_320_300e_coco/yolov3_mobilenetv2_320_300e_coco_20210719_215349-d18dff72.pth + + - Name: yolov3_mobilenetv2_8xb24-ms-416-300e_coco + In Collection: YOLOv3 + Config: configs/yolo/yolov3_mobilenetv2_8xb24-ms-416-300e_coco.py + Metadata: + Training Memory (GB): 5.3 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 23.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/yolo/yolov3_mobilenetv2_mstrain-416_300e_coco/yolov3_mobilenetv2_mstrain-416_300e_coco_20210718_010823-f68a07b3.pth diff --git a/mmdetection/configs/yolo/yolov3_d53_8xb8-320-273e_coco.py b/mmdetection/configs/yolo/yolov3_d53_8xb8-320-273e_coco.py new file mode 100644 index 00000000..a3d08dd7 --- /dev/null +++ b/mmdetection/configs/yolo/yolov3_d53_8xb8-320-273e_coco.py @@ -0,0 +1,29 @@ +_base_ = './yolov3_d53_8xb8-ms-608-273e_coco.py' + +input_size = (320, 320) +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + # `mean` and `to_rgb` should be the same with the `preprocess_cfg` + dict(type='Expand', mean=[0, 0, 0], to_rgb=True, ratio_range=(1, 2)), + dict( + type='MinIoURandomCrop', + min_ious=(0.4, 0.5, 0.6, 0.7, 0.8, 0.9), + min_crop_size=0.3), + dict(type='Resize', scale=input_size, keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PhotoMetricDistortion'), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=input_size, keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader diff --git a/mmdetection/configs/yolo/yolov3_d53_8xb8-amp-ms-608-273e_coco.py b/mmdetection/configs/yolo/yolov3_d53_8xb8-amp-ms-608-273e_coco.py new file mode 100644 index 00000000..173d8ee2 --- /dev/null +++ b/mmdetection/configs/yolo/yolov3_d53_8xb8-amp-ms-608-273e_coco.py @@ -0,0 +1,3 @@ +_base_ = './yolov3_d53_8xb8-ms-608-273e_coco.py' +# fp16 settings +optim_wrapper = dict(type='AmpOptimWrapper', loss_scale='dynamic') diff --git a/mmdetection/configs/yolo/yolov3_d53_8xb8-ms-416-273e_coco.py b/mmdetection/configs/yolo/yolov3_d53_8xb8-ms-416-273e_coco.py new file mode 100644 index 00000000..ca0127e8 --- /dev/null +++ b/mmdetection/configs/yolo/yolov3_d53_8xb8-ms-416-273e_coco.py @@ -0,0 +1,28 @@ +_base_ = './yolov3_d53_8xb8-ms-608-273e_coco.py' + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + # `mean` and `to_rgb` should be the same with the `preprocess_cfg` + dict(type='Expand', mean=[0, 0, 0], to_rgb=True, ratio_range=(1, 2)), + dict( + type='MinIoURandomCrop', + min_ious=(0.4, 0.5, 0.6, 0.7, 0.8, 0.9), + min_crop_size=0.3), + dict(type='RandomResize', scale=[(320, 320), (416, 416)], keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PhotoMetricDistortion'), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=(416, 416), keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader diff --git a/mmdetection/configs/yolo/yolov3_d53_8xb8-ms-608-273e_coco.py b/mmdetection/configs/yolo/yolov3_d53_8xb8-ms-608-273e_coco.py new file mode 100644 index 00000000..d4a36dfd --- /dev/null +++ b/mmdetection/configs/yolo/yolov3_d53_8xb8-ms-608-273e_coco.py @@ -0,0 +1,167 @@ +_base_ = ['../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'] +# model settings +data_preprocessor = dict( + type='DetDataPreprocessor', + mean=[0, 0, 0], + std=[255., 255., 255.], + bgr_to_rgb=True, + pad_size_divisor=32) +model = dict( + type='YOLOV3', + data_preprocessor=data_preprocessor, + backbone=dict( + type='Darknet', + depth=53, + out_indices=(3, 4, 5), + init_cfg=dict(type='Pretrained', checkpoint='open-mmlab://darknet53')), + neck=dict( + type='YOLOV3Neck', + num_scales=3, + in_channels=[1024, 512, 256], + out_channels=[512, 256, 128]), + bbox_head=dict( + type='YOLOV3Head', + num_classes=80, + in_channels=[512, 256, 128], + out_channels=[1024, 512, 256], + anchor_generator=dict( + type='YOLOAnchorGenerator', + base_sizes=[[(116, 90), (156, 198), (373, 326)], + [(30, 61), (62, 45), (59, 119)], + [(10, 13), (16, 30), (33, 23)]], + strides=[32, 16, 8]), + bbox_coder=dict(type='YOLOBBoxCoder'), + featmap_strides=[32, 16, 8], + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=True, + loss_weight=1.0, + reduction='sum'), + loss_conf=dict( + type='CrossEntropyLoss', + use_sigmoid=True, + loss_weight=1.0, + reduction='sum'), + loss_xy=dict( + type='CrossEntropyLoss', + use_sigmoid=True, + loss_weight=2.0, + reduction='sum'), + loss_wh=dict(type='MSELoss', loss_weight=2.0, reduction='sum')), + # training and testing settings + train_cfg=dict( + assigner=dict( + type='GridAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0)), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + conf_thr=0.005, + nms=dict(type='nms', iou_threshold=0.45), + max_per_img=100)) +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/coco/' + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/coco/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='Expand', + mean=data_preprocessor['mean'], + to_rgb=data_preprocessor['bgr_to_rgb'], + ratio_range=(1, 2)), + dict( + type='MinIoURandomCrop', + min_ious=(0.4, 0.5, 0.6, 0.7, 0.8, 0.9), + min_crop_size=0.3), + dict(type='RandomResize', scale=[(320, 320), (608, 608)], keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PhotoMetricDistortion'), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(608, 608), keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict( + batch_size=8, + num_workers=4, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args=backend_args)) +val_dataloader = dict( + batch_size=1, + num_workers=2, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'annotations/instances_val2017.json', + metric='bbox', + backend_args=backend_args) +test_evaluator = val_evaluator + +train_cfg = dict(max_epochs=273, val_interval=7) + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.001, momentum=0.9, weight_decay=0.0005), + clip_grad=dict(max_norm=35, norm_type=2)) + +# learning policy +param_scheduler = [ + dict(type='LinearLR', start_factor=0.1, by_epoch=False, begin=0, end=2000), + dict(type='MultiStepLR', by_epoch=True, milestones=[218, 246], gamma=0.1) +] + +default_hooks = dict(checkpoint=dict(type='CheckpointHook', interval=7)) + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (8 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/yolo/yolov3_mobilenetv2_8xb24-320-300e_coco.py b/mmdetection/configs/yolo/yolov3_mobilenetv2_8xb24-320-300e_coco.py new file mode 100644 index 00000000..07b39373 --- /dev/null +++ b/mmdetection/configs/yolo/yolov3_mobilenetv2_8xb24-320-300e_coco.py @@ -0,0 +1,42 @@ +_base_ = ['./yolov3_mobilenetv2_8xb24-ms-416-300e_coco.py'] + +# yapf:disable +model = dict( + bbox_head=dict( + anchor_generator=dict( + base_sizes=[[(220, 125), (128, 222), (264, 266)], + [(35, 87), (102, 96), (60, 170)], + [(10, 15), (24, 36), (72, 42)]]))) +# yapf:enable + +input_size = (320, 320) +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + # `mean` and `to_rgb` should be the same with the `preprocess_cfg` + dict( + type='Expand', + mean=[123.675, 116.28, 103.53], + to_rgb=True, + ratio_range=(1, 2)), + dict( + type='MinIoURandomCrop', + min_ious=(0.4, 0.5, 0.6, 0.7, 0.8, 0.9), + min_crop_size=0.3), + dict(type='Resize', scale=input_size, keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PhotoMetricDistortion'), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=input_size, keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict(dataset=dict(dataset=dict(pipeline=train_pipeline))) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader diff --git a/mmdetection/configs/yolo/yolov3_mobilenetv2_8xb24-ms-416-300e_coco.py b/mmdetection/configs/yolo/yolov3_mobilenetv2_8xb24-ms-416-300e_coco.py new file mode 100644 index 00000000..9a161b66 --- /dev/null +++ b/mmdetection/configs/yolo/yolov3_mobilenetv2_8xb24-ms-416-300e_coco.py @@ -0,0 +1,176 @@ +_base_ = ['../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'] +# model settings +data_preprocessor = dict( + type='DetDataPreprocessor', + mean=[123.675, 116.28, 103.53], + std=[58.395, 57.12, 57.375], + bgr_to_rgb=True, + pad_size_divisor=32) +model = dict( + type='YOLOV3', + data_preprocessor=data_preprocessor, + backbone=dict( + type='MobileNetV2', + out_indices=(2, 4, 6), + act_cfg=dict(type='LeakyReLU', negative_slope=0.1), + init_cfg=dict( + type='Pretrained', checkpoint='open-mmlab://mmdet/mobilenet_v2')), + neck=dict( + type='YOLOV3Neck', + num_scales=3, + in_channels=[320, 96, 32], + out_channels=[96, 96, 96]), + bbox_head=dict( + type='YOLOV3Head', + num_classes=80, + in_channels=[96, 96, 96], + out_channels=[96, 96, 96], + anchor_generator=dict( + type='YOLOAnchorGenerator', + base_sizes=[[(116, 90), (156, 198), (373, 326)], + [(30, 61), (62, 45), (59, 119)], + [(10, 13), (16, 30), (33, 23)]], + strides=[32, 16, 8]), + bbox_coder=dict(type='YOLOBBoxCoder'), + featmap_strides=[32, 16, 8], + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=True, + loss_weight=1.0, + reduction='sum'), + loss_conf=dict( + type='CrossEntropyLoss', + use_sigmoid=True, + loss_weight=1.0, + reduction='sum'), + loss_xy=dict( + type='CrossEntropyLoss', + use_sigmoid=True, + loss_weight=2.0, + reduction='sum'), + loss_wh=dict(type='MSELoss', loss_weight=2.0, reduction='sum')), + # training and testing settings + train_cfg=dict( + assigner=dict( + type='GridAssigner', + pos_iou_thr=0.5, + neg_iou_thr=0.5, + min_pos_iou=0)), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + conf_thr=0.005, + nms=dict(type='nms', iou_threshold=0.45), + max_per_img=100)) +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/coco/' + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/coco/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='Expand', + mean=data_preprocessor['mean'], + to_rgb=data_preprocessor['bgr_to_rgb'], + ratio_range=(1, 2)), + dict( + type='MinIoURandomCrop', + min_ious=(0.4, 0.5, 0.6, 0.7, 0.8, 0.9), + min_crop_size=0.3), + dict(type='RandomResize', scale=[(320, 320), (416, 416)], keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='PhotoMetricDistortion'), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=(416, 416), keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict( + batch_size=24, + num_workers=4, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + batch_sampler=dict(type='AspectRatioBatchSampler'), + dataset=dict( + type='RepeatDataset', # use RepeatDataset to speed up training + times=10, + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + filter_cfg=dict(filter_empty_gt=True, min_size=32), + pipeline=train_pipeline, + backend_args=backend_args))) +val_dataloader = dict( + batch_size=24, + num_workers=4, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'annotations/instances_val2017.json', + metric='bbox', + backend_args=backend_args) +test_evaluator = val_evaluator + +train_cfg = dict(max_epochs=30) + +# optimizer +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict(type='SGD', lr=0.003, momentum=0.9, weight_decay=0.0005), + clip_grad=dict(max_norm=35, norm_type=2)) + +# learning policy +param_scheduler = [ + dict( + type='LinearLR', + start_factor=0.0001, + by_epoch=False, + begin=0, + end=4000), + dict(type='MultiStepLR', by_epoch=True, milestones=[24, 28], gamma=0.1) +] + +find_unused_parameters = True + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (24 samples per GPU) +auto_scale_lr = dict(base_batch_size=192) diff --git a/mmdetection/configs/yolof/README.md b/mmdetection/configs/yolof/README.md new file mode 100644 index 00000000..b9167f6e --- /dev/null +++ b/mmdetection/configs/yolof/README.md @@ -0,0 +1,35 @@ +# YOLOF + +> [You Only Look One-level Feature](https://arxiv.org/abs/2103.09460) + + + +## Abstract + +This paper revisits feature pyramids networks (FPN) for one-stage detectors and points out that the success of FPN is due to its divide-and-conquer solution to the optimization problem in object detection rather than multi-scale feature fusion. From the perspective of optimization, we introduce an alternative way to address the problem instead of adopting the complex feature pyramids - {\\em utilizing only one-level feature for detection}. Based on the simple and efficient solution, we present You Only Look One-level Feature (YOLOF). In our method, two key components, Dilated Encoder and Uniform Matching, are proposed and bring considerable improvements. Extensive experiments on the COCO benchmark prove the effectiveness of the proposed model. Our YOLOF achieves comparable results with its feature pyramids counterpart RetinaNet while being 2.5× faster. Without transformer layers, YOLOF can match the performance of DETR in a single-level feature manner with 7× less training epochs. With an image size of 608×608, YOLOF achieves 44.3 mAP running at 60 fps on 2080Ti, which is 13% faster than YOLOv4. + +
    + +
    + +## Results and Models + +| Backbone | Style | Epoch | Lr schd | Mem (GB) | box AP | Config | Download | +| :------: | :---: | :---: | :-----: | :------: | :----: | :--------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| R-50-C5 | caffe | Y | 1x | 8.3 | 37.5 | [config](./yolof_r50-c5_8xb8-1x_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/yolof/yolof_r50_c5_8x8_1x_coco/yolof_r50_c5_8x8_1x_coco_20210425_024427-8e864411.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/yolof/yolof_r50_c5_8x8_1x_coco/yolof_r50_c5_8x8_1x_coco_20210425_024427.log.json) | + +**Note**: + +1. We find that the performance is unstable and may fluctuate by about 0.3 mAP. mAP 37.4 ~ 37.7 is acceptable in YOLOF_R_50_C5_1x. Such fluctuation can also be found in the [original implementation](https://github.com/chensnathan/YOLOF). +2. In addition to instability issues, sometimes there are large loss fluctuations and NAN, so there may still be problems with this project, which will be improved subsequently. + +## Citation + +```latex +@inproceedings{chen2021you, + title={You Only Look One-level Feature}, + author={Chen, Qiang and Wang, Yingming and Yang, Tong and Zhang, Xiangyu and Cheng, Jian and Sun, Jian}, + booktitle={IEEE Conference on Computer Vision and Pattern Recognition}, + year={2021} +} +``` diff --git a/mmdetection/configs/yolof/metafile.yml b/mmdetection/configs/yolof/metafile.yml new file mode 100644 index 00000000..b3b7b7f8 --- /dev/null +++ b/mmdetection/configs/yolof/metafile.yml @@ -0,0 +1,32 @@ +Collections: + - Name: YOLOF + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Momentum + - Weight Decay + Training Resources: 8x V100 GPUs + Architecture: + - Dilated Encoder + - ResNet + Paper: + URL: https://arxiv.org/abs/2103.09460 + Title: 'You Only Look One-level Feature' + README: configs/yolof/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.12.0/mmdet/models/detectors/yolof.py#L6 + Version: v2.12.0 + +Models: + - Name: yolof_r50_c5_8x8_1x_coco + In Collection: YOLOF + Config: configs/yolof/yolof_r50-c5_8xb8-1x_coco.py + Metadata: + Training Memory (GB): 8.3 + Epochs: 12 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 37.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/yolof/yolof_r50_c5_8x8_1x_coco/yolof_r50_c5_8x8_1x_coco_20210425_024427-8e864411.pth diff --git a/mmdetection/configs/yolof/yolof_r50-c5_8xb8-1x_coco.py b/mmdetection/configs/yolof/yolof_r50-c5_8xb8-1x_coco.py new file mode 100644 index 00000000..5ea228e3 --- /dev/null +++ b/mmdetection/configs/yolof/yolof_r50-c5_8xb8-1x_coco.py @@ -0,0 +1,116 @@ +_base_ = [ + '../_base_/datasets/coco_detection.py', + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' +] +model = dict( + type='YOLOF', + data_preprocessor=dict( + type='DetDataPreprocessor', + mean=[103.530, 116.280, 123.675], + std=[1.0, 1.0, 1.0], + bgr_to_rgb=False, + pad_size_divisor=32), + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(3, ), + frozen_stages=1, + norm_cfg=dict(type='BN', requires_grad=False), + norm_eval=True, + style='caffe', + init_cfg=dict( + type='Pretrained', + checkpoint='open-mmlab://detectron/resnet50_caffe')), + neck=dict( + type='DilatedEncoder', + in_channels=2048, + out_channels=512, + block_mid_channels=128, + num_residual_blocks=4, + block_dilations=[2, 4, 6, 8]), + bbox_head=dict( + type='YOLOFHead', + num_classes=80, + in_channels=512, + reg_decoded_bbox=True, + anchor_generator=dict( + type='AnchorGenerator', + ratios=[1.0], + scales=[1, 2, 4, 8, 16], + strides=[32]), + bbox_coder=dict( + type='DeltaXYWHBBoxCoder', + target_means=[.0, .0, .0, .0], + target_stds=[1., 1., 1., 1.], + add_ctr_clamp=True, + ctr_clamp=32), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='GIoULoss', loss_weight=1.0)), + # training and testing settings + train_cfg=dict( + assigner=dict( + type='UniformAssigner', pos_ignore_thr=0.15, neg_ignore_thr=0.7), + allowed_border=-1, + pos_weight=-1, + debug=False), + test_cfg=dict( + nms_pre=1000, + min_bbox_size=0, + score_thr=0.05, + nms=dict(type='nms', iou_threshold=0.6), + max_per_img=100)) +# optimizer +optim_wrapper = dict( + optimizer=dict(type='SGD', lr=0.12, momentum=0.9, weight_decay=0.0001), + paramwise_cfg=dict( + norm_decay_mult=0., custom_keys={'backbone': dict(lr_mult=1. / 3)})) + +# learning rate +param_scheduler = [ + dict( + type='LinearLR', + start_factor=0.00066667, + by_epoch=False, + begin=0, + end=1500), + dict( + type='MultiStepLR', + begin=0, + end=12, + by_epoch=True, + milestones=[8, 11], + gamma=0.1) +] + +train_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='LoadAnnotations', with_bbox=True), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='RandomFlip', prob=0.5), + dict(type='RandomShift', prob=0.5, max_shift_px=32), + dict(type='PackDetInputs') +] +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=(1333, 800), keep_ratio=True), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] +train_dataloader = dict( + batch_size=8, num_workers=8, dataset=dict(pipeline=train_pipeline)) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (8 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/yolof/yolof_r50-c5_8xb8-iter-1x_coco.py b/mmdetection/configs/yolof/yolof_r50-c5_8xb8-iter-1x_coco.py new file mode 100644 index 00000000..466a8200 --- /dev/null +++ b/mmdetection/configs/yolof/yolof_r50-c5_8xb8-iter-1x_coco.py @@ -0,0 +1,32 @@ +_base_ = './yolof_r50-c5_8xb8-1x_coco.py' + +# We implemented the iter-based config according to the source code. +# COCO dataset has 117266 images after filtering. We use 8 gpu and +# 8 batch size training, so 22500 is equivalent to +# 22500/(117266/(8x8))=12.3 epoch, 15000 is equivalent to 8.2 epoch, +# 20000 is equivalent to 10.9 epoch. Due to lr(0.12) is large, +# the iter-based and epoch-based setting have about 0.2 difference on +# the mAP evaluation value. + +train_cfg = dict( + _delete_=True, + type='IterBasedTrainLoop', + max_iters=22500, + val_interval=4500) + +# learning rate policy +param_scheduler = [ + dict( + type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500), + dict( + type='MultiStepLR', + begin=0, + end=22500, + by_epoch=False, + milestones=[15000, 20000], + gamma=0.1) +] +train_dataloader = dict(sampler=dict(type='InfiniteSampler')) +default_hooks = dict(checkpoint=dict(by_epoch=False, interval=2500)) + +log_processor = dict(by_epoch=False) diff --git a/mmdetection/configs/yolox/README.md b/mmdetection/configs/yolox/README.md new file mode 100644 index 00000000..0cde1926 --- /dev/null +++ b/mmdetection/configs/yolox/README.md @@ -0,0 +1,39 @@ +# YOLOX + +> [YOLOX: Exceeding YOLO Series in 2021](https://arxiv.org/abs/2107.08430) + + + +## Abstract + +In this report, we present some experienced improvements to YOLO series, forming a new high-performance detector -- YOLOX. We switch the YOLO detector to an anchor-free manner and conduct other advanced detection techniques, i.e., a decoupled head and the leading label assignment strategy SimOTA to achieve state-of-the-art results across a large scale range of models: For YOLO-Nano with only 0.91M parameters and 1.08G FLOPs, we get 25.3% AP on COCO, surpassing NanoDet by 1.8% AP; for YOLOv3, one of the most widely used detectors in industry, we boost it to 47.3% AP on COCO, outperforming the current best practice by 3.0% AP; for YOLOX-L with roughly the same amount of parameters as YOLOv4-CSP, YOLOv5-L, we achieve 50.0% AP on COCO at a speed of 68.9 FPS on Tesla V100, exceeding YOLOv5-L by 1.8% AP. Further, we won the 1st Place on Streaming Perception Challenge (Workshop on Autonomous Driving at CVPR 2021) using a single YOLOX-L model. We hope this report can provide useful experience for developers and researchers in practical scenes, and we also provide deploy versions with ONNX, TensorRT, NCNN, and Openvino supported. + +
    + +
    + +## Results and Models + +| Backbone | size | Mem (GB) | box AP | Config | Download | +| :--------: | :--: | :------: | :----: | :--------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| YOLOX-tiny | 416 | 3.5 | 32.0 | [config](./yolox_tiny_8xb8-300e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/yolox/yolox_tiny_8x8_300e_coco/yolox_tiny_8x8_300e_coco_20211124_171234-b4047906.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/yolox/yolox_tiny_8x8_300e_coco/yolox_tiny_8x8_300e_coco_20211124_171234.log.json) | +| YOLOX-s | 640 | 7.6 | 40.5 | [config](./yolox_s_8xb8-300e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/yolox/yolox_s_8x8_300e_coco/yolox_s_8x8_300e_coco_20211121_095711-4592a793.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/yolox/yolox_s_8x8_300e_coco/yolox_s_8x8_300e_coco_20211121_095711.log.json) | +| YOLOX-l | 640 | 19.9 | 49.4 | [config](./yolox_l_8xb8-300e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/yolox/yolox_l_8x8_300e_coco/yolox_l_8x8_300e_coco_20211126_140236-d3bd2b23.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/yolox/yolox_l_8x8_300e_coco/yolox_l_8x8_300e_coco_20211126_140236.log.json) | +| YOLOX-x | 640 | 28.1 | 50.9 | [config](./yolox_x_8xb8-300e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v2.0/yolox/yolox_x_8x8_300e_coco/yolox_x_8x8_300e_coco_20211126_140254-1ef88d67.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/yolox/yolox_x_8x8_300e_coco/yolox_x_8x8_300e_coco_20211126_140254.log.json) | + +**Note**: + +1. The test score threshold is 0.001, and the box AP indicates the best AP. +2. Due to the need for pre-training weights, we cannot reproduce the performance of the `yolox-nano` model. Please refer to https://github.com/Megvii-BaseDetection/YOLOX/issues/674 for more information. +3. We also trained the model by the official release of YOLOX based on [Megvii-BaseDetection/YOLOX#735](https://github.com/Megvii-BaseDetection/YOLOX/issues/735) with commit ID [38c633](https://github.com/Megvii-BaseDetection/YOLOX/tree/38c633bf176462ee42b110c70e4ffe17b5753208). We found that the best AP of `YOLOX-tiny`, `YOLOX-s`, `YOLOX-l`, and `YOLOX-x` is 31.8, 40.3, 49.2, and 50.9, respectively. The performance is consistent with that of our re-implementation (see Table above) but still has a gap (0.3~0.8 AP) in comparison with the reported performance in their [README](https://github.com/Megvii-BaseDetection/YOLOX/blob/38c633bf176462ee42b110c70e4ffe17b5753208/README.md#benchmark). + +## Citation + +```latex +@article{yolox2021, + title={{YOLOX}: Exceeding YOLO Series in 2021}, + author={Ge, Zheng and Liu, Songtao and Wang, Feng and Li, Zeming and Sun, Jian}, + journal={arXiv preprint arXiv:2107.08430}, + year={2021} +} +``` diff --git a/mmdetection/configs/yolox/metafile.yml b/mmdetection/configs/yolox/metafile.yml new file mode 100644 index 00000000..2f64450e --- /dev/null +++ b/mmdetection/configs/yolox/metafile.yml @@ -0,0 +1,70 @@ +Collections: + - Name: YOLOX + Metadata: + Training Data: COCO + Training Techniques: + - SGD with Nesterov + - Weight Decay + - Cosine Annealing Lr Updater + Training Resources: 8x TITANXp GPUs + Architecture: + - CSPDarkNet + - PAFPN + Paper: + URL: https://arxiv.org/abs/2107.08430 + Title: 'YOLOX: Exceeding YOLO Series in 2021' + README: configs/yolox/README.md + Code: + URL: https://github.com/open-mmlab/mmdetection/blob/v2.15.1/mmdet/models/detectors/yolox.py#L6 + Version: v2.15.1 + + +Models: + - Name: yolox_s_8x8_300e_coco + In Collection: YOLOX + Config: configs/yolox/yolox_s_8xb8-300e_coco.py + Metadata: + Training Memory (GB): 7.6 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 40.5 + Weights: https://download.openmmlab.com/mmdetection/v2.0/yolox/yolox_s_8x8_300e_coco/yolox_s_8x8_300e_coco_20211121_095711-4592a793.pth + - Name: yolox_l_8x8_300e_coco + In Collection: YOLOX + Config: configs/yolox/yolox_l_8xb8-300e_coco.py + Metadata: + Training Memory (GB): 19.9 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 49.4 + Weights: https://download.openmmlab.com/mmdetection/v2.0/yolox/yolox_l_8x8_300e_coco/yolox_l_8x8_300e_coco_20211126_140236-d3bd2b23.pth + - Name: yolox_x_8x8_300e_coco + In Collection: YOLOX + Config: configs/yolox/yolox_x_8xb8-300e_coco.py + Metadata: + Training Memory (GB): 28.1 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 50.9 + Weights: https://download.openmmlab.com/mmdetection/v2.0/yolox/yolox_x_8x8_300e_coco/yolox_x_8x8_300e_coco_20211126_140254-1ef88d67.pth + - Name: yolox_tiny_8x8_300e_coco + In Collection: YOLOX + Config: configs/yolox/yolox_tiny_8xb8-300e_coco.py + Metadata: + Training Memory (GB): 3.5 + Epochs: 300 + Results: + - Task: Object Detection + Dataset: COCO + Metrics: + box AP: 32.0 + Weights: https://download.openmmlab.com/mmdetection/v2.0/yolox/yolox_tiny_8x8_300e_coco/yolox_tiny_8x8_300e_coco_20211124_171234-b4047906.pth diff --git a/mmdetection/configs/yolox/yolox_l_8xb8-300e_coco.py b/mmdetection/configs/yolox/yolox_l_8xb8-300e_coco.py new file mode 100644 index 00000000..2a4b287b --- /dev/null +++ b/mmdetection/configs/yolox/yolox_l_8xb8-300e_coco.py @@ -0,0 +1,8 @@ +_base_ = './yolox_s_8xb8-300e_coco.py' + +# model settings +model = dict( + backbone=dict(deepen_factor=1.0, widen_factor=1.0), + neck=dict( + in_channels=[256, 512, 1024], out_channels=256, num_csp_blocks=3), + bbox_head=dict(in_channels=256, feat_channels=256)) diff --git a/mmdetection/configs/yolox/yolox_m_8xb8-300e_coco.py b/mmdetection/configs/yolox/yolox_m_8xb8-300e_coco.py new file mode 100644 index 00000000..d82f9e98 --- /dev/null +++ b/mmdetection/configs/yolox/yolox_m_8xb8-300e_coco.py @@ -0,0 +1,8 @@ +_base_ = './yolox_s_8xb8-300e_coco.py' + +# model settings +model = dict( + backbone=dict(deepen_factor=0.67, widen_factor=0.75), + neck=dict(in_channels=[192, 384, 768], out_channels=192, num_csp_blocks=2), + bbox_head=dict(in_channels=192, feat_channels=192), +) diff --git a/mmdetection/configs/yolox/yolox_nano_8xb8-300e_coco.py b/mmdetection/configs/yolox/yolox_nano_8xb8-300e_coco.py new file mode 100644 index 00000000..3f7a1c5a --- /dev/null +++ b/mmdetection/configs/yolox/yolox_nano_8xb8-300e_coco.py @@ -0,0 +1,11 @@ +_base_ = './yolox_tiny_8xb8-300e_coco.py' + +# model settings +model = dict( + backbone=dict(deepen_factor=0.33, widen_factor=0.25, use_depthwise=True), + neck=dict( + in_channels=[64, 128, 256], + out_channels=64, + num_csp_blocks=1, + use_depthwise=True), + bbox_head=dict(in_channels=64, feat_channels=64, use_depthwise=True)) diff --git a/mmdetection/configs/yolox/yolox_s_8xb8-300e_coco.py b/mmdetection/configs/yolox/yolox_s_8xb8-300e_coco.py new file mode 100644 index 00000000..3e324eb5 --- /dev/null +++ b/mmdetection/configs/yolox/yolox_s_8xb8-300e_coco.py @@ -0,0 +1,250 @@ +_base_ = [ + '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py', + './yolox_tta.py' +] + +img_scale = (640, 640) # width, height + +# model settings +model = dict( + type='YOLOX', + data_preprocessor=dict( + type='DetDataPreprocessor', + pad_size_divisor=32, + batch_augments=[ + dict( + type='BatchSyncRandomResize', + random_size_range=(480, 800), + size_divisor=32, + interval=10) + ]), + backbone=dict( + type='CSPDarknet', + deepen_factor=0.33, + widen_factor=0.5, + out_indices=(2, 3, 4), + use_depthwise=False, + spp_kernal_sizes=(5, 9, 13), + norm_cfg=dict(type='BN', momentum=0.03, eps=0.001), + act_cfg=dict(type='Swish'), + ), + neck=dict( + type='YOLOXPAFPN', + in_channels=[128, 256, 512], + out_channels=128, + num_csp_blocks=1, + use_depthwise=False, + upsample_cfg=dict(scale_factor=2, mode='nearest'), + norm_cfg=dict(type='BN', momentum=0.03, eps=0.001), + act_cfg=dict(type='Swish')), + bbox_head=dict( + type='YOLOXHead', + num_classes=80, + in_channels=128, + feat_channels=128, + stacked_convs=2, + strides=(8, 16, 32), + use_depthwise=False, + norm_cfg=dict(type='BN', momentum=0.03, eps=0.001), + act_cfg=dict(type='Swish'), + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=True, + reduction='sum', + loss_weight=1.0), + loss_bbox=dict( + type='IoULoss', + mode='square', + eps=1e-16, + reduction='sum', + loss_weight=5.0), + loss_obj=dict( + type='CrossEntropyLoss', + use_sigmoid=True, + reduction='sum', + loss_weight=1.0), + loss_l1=dict(type='L1Loss', reduction='sum', loss_weight=1.0)), + train_cfg=dict(assigner=dict(type='SimOTAAssigner', center_radius=2.5)), + # In order to align the source code, the threshold of the val phase is + # 0.01, and the threshold of the test phase is 0.001. + test_cfg=dict(score_thr=0.01, nms=dict(type='nms', iou_threshold=0.65))) + +# dataset settings +data_root = 'data/coco/' +dataset_type = 'CocoDataset' + +# Example to use different file client +# Method 1: simply set the data root and let the file I/O module +# automatically infer from prefix (not support LMDB and Memcache yet) + +# data_root = 's3://openmmlab/datasets/detection/coco/' + +# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6 +# backend_args = dict( +# backend='petrel', +# path_mapping=dict({ +# './data/': 's3://openmmlab/datasets/detection/', +# 'data/': 's3://openmmlab/datasets/detection/' +# })) +backend_args = None + +train_pipeline = [ + dict(type='Mosaic', img_scale=img_scale, pad_val=114.0), + dict( + type='RandomAffine', + scaling_ratio_range=(0.1, 2), + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2)), + dict( + type='MixUp', + img_scale=img_scale, + ratio_range=(0.8, 1.6), + pad_val=114.0), + dict(type='YOLOXHSVRandomAug'), + dict(type='RandomFlip', prob=0.5), + # According to the official implementation, multi-scale + # training is not considered here but in the + # 'mmdet/models/detectors/yolox.py'. + # Resize and Pad are for the last 15 epochs when Mosaic, + # RandomAffine, and MixUp are closed by YOLOXModeSwitchHook. + dict(type='Resize', scale=img_scale, keep_ratio=True), + dict( + type='Pad', + pad_to_square=True, + # If the image is three-channel, the pad value needs + # to be set separately for each channel. + pad_val=dict(img=(114.0, 114.0, 114.0))), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1, 1), keep_empty=False), + dict(type='PackDetInputs') +] + +train_dataset = dict( + # use MultiImageMixDataset wrapper to support mosaic and mixup + type='MultiImageMixDataset', + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_train2017.json', + data_prefix=dict(img='train2017/'), + pipeline=[ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='LoadAnnotations', with_bbox=True) + ], + filter_cfg=dict(filter_empty_gt=False, min_size=32), + backend_args=backend_args), + pipeline=train_pipeline) + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args=backend_args), + dict(type='Resize', scale=img_scale, keep_ratio=True), + dict( + type='Pad', + pad_to_square=True, + pad_val=dict(img=(114.0, 114.0, 114.0))), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict( + batch_size=8, + num_workers=4, + persistent_workers=True, + sampler=dict(type='DefaultSampler', shuffle=True), + dataset=train_dataset) +val_dataloader = dict( + batch_size=8, + num_workers=4, + persistent_workers=True, + drop_last=False, + sampler=dict(type='DefaultSampler', shuffle=False), + dataset=dict( + type=dataset_type, + data_root=data_root, + ann_file='annotations/instances_val2017.json', + data_prefix=dict(img='val2017/'), + test_mode=True, + pipeline=test_pipeline, + backend_args=backend_args)) +test_dataloader = val_dataloader + +val_evaluator = dict( + type='CocoMetric', + ann_file=data_root + 'annotations/instances_val2017.json', + metric='bbox', + backend_args=backend_args) +test_evaluator = val_evaluator + +# training settings +max_epochs = 300 +num_last_epochs = 15 +interval = 10 + +train_cfg = dict(max_epochs=max_epochs, val_interval=interval) + +# optimizer +# default 8 gpu +base_lr = 0.01 +optim_wrapper = dict( + type='OptimWrapper', + optimizer=dict( + type='SGD', lr=base_lr, momentum=0.9, weight_decay=5e-4, + nesterov=True), + paramwise_cfg=dict(norm_decay_mult=0., bias_decay_mult=0.)) + +# learning rate +param_scheduler = [ + dict( + # use quadratic formula to warm up 5 epochs + # and lr is updated by iteration + # TODO: fix default scope in get function + type='mmdet.QuadraticWarmupLR', + by_epoch=True, + begin=0, + end=5, + convert_to_iter_based=True), + dict( + # use cosine lr from 5 to 285 epoch + type='CosineAnnealingLR', + eta_min=base_lr * 0.05, + begin=5, + T_max=max_epochs - num_last_epochs, + end=max_epochs - num_last_epochs, + by_epoch=True, + convert_to_iter_based=True), + dict( + # use fixed lr during last 15 epochs + type='ConstantLR', + by_epoch=True, + factor=1, + begin=max_epochs - num_last_epochs, + end=max_epochs, + ) +] + +default_hooks = dict( + checkpoint=dict( + interval=interval, + max_keep_ckpts=3 # only keep latest 3 checkpoints + )) + +custom_hooks = [ + dict( + type='YOLOXModeSwitchHook', + num_last_epochs=num_last_epochs, + priority=48), + dict(type='SyncNormHook', priority=48), + dict( + type='EMAHook', + ema_type='ExpMomentumEMA', + momentum=0.0001, + update_buffers=True, + priority=49) +] + +# NOTE: `auto_scale_lr` is for automatically scaling LR, +# USER SHOULD NOT CHANGE ITS VALUES. +# base_batch_size = (8 GPUs) x (8 samples per GPU) +auto_scale_lr = dict(base_batch_size=64) diff --git a/mmdetection/configs/yolox/yolox_tiny_8xb8-300e_coco.py b/mmdetection/configs/yolox/yolox_tiny_8xb8-300e_coco.py new file mode 100644 index 00000000..86f7e9a6 --- /dev/null +++ b/mmdetection/configs/yolox/yolox_tiny_8xb8-300e_coco.py @@ -0,0 +1,54 @@ +_base_ = './yolox_s_8xb8-300e_coco.py' + +# model settings +model = dict( + data_preprocessor=dict(batch_augments=[ + dict( + type='BatchSyncRandomResize', + random_size_range=(320, 640), + size_divisor=32, + interval=10) + ]), + backbone=dict(deepen_factor=0.33, widen_factor=0.375), + neck=dict(in_channels=[96, 192, 384], out_channels=96), + bbox_head=dict(in_channels=96, feat_channels=96)) + +img_scale = (640, 640) # width, height + +train_pipeline = [ + dict(type='Mosaic', img_scale=img_scale, pad_val=114.0), + dict( + type='RandomAffine', + scaling_ratio_range=(0.5, 1.5), + # img_scale is (width, height) + border=(-img_scale[0] // 2, -img_scale[1] // 2)), + dict(type='YOLOXHSVRandomAug'), + dict(type='RandomFlip', prob=0.5), + # Resize and Pad are for the last 15 epochs when Mosaic and + # RandomAffine are closed by YOLOXModeSwitchHook. + dict(type='Resize', scale=img_scale, keep_ratio=True), + dict( + type='Pad', + pad_to_square=True, + pad_val=dict(img=(114.0, 114.0, 114.0))), + dict(type='FilterAnnotations', min_gt_bbox_wh=(1, 1), keep_empty=False), + dict(type='PackDetInputs') +] + +test_pipeline = [ + dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}), + dict(type='Resize', scale=(416, 416), keep_ratio=True), + dict( + type='Pad', + pad_to_square=True, + pad_val=dict(img=(114.0, 114.0, 114.0))), + dict(type='LoadAnnotations', with_bbox=True), + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor')) +] + +train_dataloader = dict(dataset=dict(pipeline=train_pipeline)) +val_dataloader = dict(dataset=dict(pipeline=test_pipeline)) +test_dataloader = val_dataloader diff --git a/mmdetection/configs/yolox/yolox_tta.py b/mmdetection/configs/yolox/yolox_tta.py new file mode 100644 index 00000000..e65244be --- /dev/null +++ b/mmdetection/configs/yolox/yolox_tta.py @@ -0,0 +1,36 @@ +tta_model = dict( + type='DetTTAModel', + tta_cfg=dict(nms=dict(type='nms', iou_threshold=0.65), max_per_img=100)) + +img_scales = [(640, 640), (320, 320), (960, 960)] +tta_pipeline = [ + dict(type='LoadImageFromFile', backend_args=None), + dict( + type='TestTimeAug', + transforms=[ + [ + dict(type='Resize', scale=s, keep_ratio=True) + for s in img_scales + ], + [ + # ``RandomFlip`` must be placed before ``Pad``, otherwise + # bounding box coordinates after flipping cannot be + # recovered correctly. + dict(type='RandomFlip', prob=1.), + dict(type='RandomFlip', prob=0.) + ], + [ + dict( + type='Pad', + pad_to_square=True, + pad_val=dict(img=(114.0, 114.0, 114.0))), + ], + [dict(type='LoadAnnotations', with_bbox=True)], + [ + dict( + type='PackDetInputs', + meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', + 'scale_factor', 'flip', 'flip_direction')) + ] + ]) +] diff --git a/mmdetection/configs/yolox/yolox_x_8xb8-300e_coco.py b/mmdetection/configs/yolox/yolox_x_8xb8-300e_coco.py new file mode 100644 index 00000000..34828e03 --- /dev/null +++ b/mmdetection/configs/yolox/yolox_x_8xb8-300e_coco.py @@ -0,0 +1,8 @@ +_base_ = './yolox_s_8xb8-300e_coco.py' + +# model settings +model = dict( + backbone=dict(deepen_factor=1.33, widen_factor=1.25), + neck=dict( + in_channels=[320, 640, 1280], out_channels=320, num_csp_blocks=4), + bbox_head=dict(in_channels=320, feat_channels=320)) diff --git a/mmdetection/dataset-index.yml b/mmdetection/dataset-index.yml new file mode 100644 index 00000000..116412e1 --- /dev/null +++ b/mmdetection/dataset-index.yml @@ -0,0 +1,18 @@ +openxlab: true +voc2007: + dataset: OpenDataLab/PASCAL_VOC2007 + download_root: data + data_root: data + script: tools/dataset_converters/scripts/preprocess_voc2007.sh + +voc2012: + dataset: OpenDataLab/PASCAL_VOC2012 + download_root: data + data_root: data + script: tools/dataset_converters/scripts/preprocess_voc2012.sh + +coco2017: + dataset: OpenDataLab/COCO_2017 + download_root: data + data_root: data/coco + script: tools/dataset_converters/scripts/preprocess_coco2017.sh diff --git a/mmdetection/demo/MMDet_InstanceSeg_Tutorial.ipynb b/mmdetection/demo/MMDet_InstanceSeg_Tutorial.ipynb new file mode 100644 index 00000000..4b63ba34 --- /dev/null +++ b/mmdetection/demo/MMDet_InstanceSeg_Tutorial.ipynb @@ -0,0 +1,2167 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "aGYwt_UjIrqp" + }, + "source": [ + "# Instance Segmentation\n", + "\n", + "In this tutorial, you will learn:\n", + "- the basic structure of Mask R-CNN.\n", + "- to perform inference with a MMDetection detector.\n", + "- to train a new instance segmentation model with a new dataset.\n", + "\n", + "Let's start!\n", + "\n", + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cCk6uTQrdUUn" + }, + "source": [ + "If you are running the tutorial files on the colab platform or a new virtual environment, please run the following code first to configure the runtime environment.\n", + "```python\n", + "!pip install -U openmim\n", + "!mim install \"mmengine>=0.7.0\"\n", + "!mim install \"mmcv>=2.0.0rc4\"\n", + "\n", + "# Install mmdetection\n", + "!rm -rf mmdetection\n", + "!git clone https://github.com/open-mmlab/mmdetection.git\n", + "%cd mmdetection\n", + "\n", + "!pip install -e .\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6hD0mmMixT0p", + "outputId": "221dad3c-5ef8-4094-e07e-289f333f7bb9" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch version: 2.0.1+cu118 cuda: True\n", + "mmdetection: 3.1.0\n", + "mmcv: 2.0.1\n", + "mmengine: 0.8.4\n" + ] + } + ], + "source": [ + "# Check Pytorch installation\n", + "import torch, torchvision\n", + "print(\"torch version:\",torch.__version__, \"cuda:\",torch.cuda.is_available())\n", + "\n", + "# Check MMDetection installation\n", + "import mmdet\n", + "print(\"mmdetection:\",mmdet.__version__)\n", + "\n", + "# Check mmcv installation\n", + "import mmcv\n", + "print(\"mmcv:\",mmcv.__version__)\n", + "\n", + "# Check mmengine installation\n", + "import mmengine\n", + "print(\"mmengine:\",mmengine.__version__)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gi9zw03oM4CH" + }, + "source": [ + "## Perform Inference with An MMDetection Detector" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3pFYLerc0we1" + }, + "source": [ + "### A two-stage detector\n", + "\n", + "In this tutorial, we use Mask R-CNN, a simple two-stage detector as an example.\n", + "\n", + "The high-level architecture of Mask R-CNN is shown in the following picture. More details can be found in the [paper](https://arxiv.org/abs/1703.06870).\n", + "\n", + "\"mask\n", + "\n", + "Mask R-CNN adds a mask branch based on the original Faster R-CNN. It also uses RoIAlign, a more precise version of RoIPooling for RoI feature extraction to improve the performance.\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "sWI-nX5yRYYQ", + "outputId": "fd91e337-27cb-492c-a948-98adcbcfca27" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "processing mask-rcnn_r50-caffe_fpn_ms-poly-3x_coco...\n", + "\u001b[2Kdownloading \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m169.6/169.6 MiB\u001b[0m \u001b[31m9.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h\u001b[32mSuccessfully downloaded mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth to /content/mmdetection/checkpoints\u001b[0m\n", + "\u001b[32mSuccessfully dumped mask-rcnn_r50-caffe_fpn_ms-poly-3x_coco.py to /content/mmdetection/checkpoints\u001b[0m\n" + ] + } + ], + "source": [ + "!mim download mmdet --config mask-rcnn_r50-caffe_fpn_ms-poly-3x_coco --dest ./checkpoints" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "8M5KUnX7Np3h", + "outputId": "71de79c0-9f7e-4cae-f810-5c0a20fe9be8" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loads checkpoint by local backend from path: checkpoints/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth\n" + ] + } + ], + "source": [ + "import mmcv\n", + "import mmengine\n", + "from mmdet.apis import init_detector, inference_detector\n", + "from mmdet.utils import register_all_modules\n", + "# Choose to use a config and initialize the detector\n", + "config_file = 'configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-poly-3x_coco.py'\n", + "# Setup a checkpoint file to load\n", + "checkpoint_file = 'checkpoints/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth'\n", + "\n", + "# register all modules in mmdet into the registries\n", + "register_all_modules()\n", + "\n", + "# build the model from a config file and a checkpoint file\n", + "model = init_detector(config_file, checkpoint_file, device='cuda:0') # or device='cuda:0'\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pVqDQAOiKkJK" + }, + "source": [ + "From the printed model, we will find that the model does consist of the components that we described earlier. It uses ResNet as its CNN backbone, and has a RPN head and RoI Head.\n", + "The RoI Head includes box head and mask head. In addition, the model has a neural network module, named neck, directly after the CNN backbone. It is a [feature pyramid network (FPN)](https://arxiv.org/abs/1612.03144) for enhancing the multi-scale features.\n", + "\n", + "\n", + "### Inference with the detector\n", + "\n", + "The model is successfully created and loaded, let's see how good it is. We use the high-level API `inference_detector` implemented in the MMDetection. This API is created to ease the inference process. The details of the codes can be found [here](https://github.com/open-mmlab/mmdetection/blob/master/mmdet/apis/inference.py#L15)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Wi6DRpsQPEmV", + "outputId": "42a9dd39-edcb-49f1-e318-a3cd77f89eee" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " ignored_instances: \n", + " pred_instances: \n", + ") at 0x79a3c999fc10>\n" + ] + } + ], + "source": [ + "# Use the detector to do inference\n", + "image = mmcv.imread('demo/demo.jpg',channel_order='rgb')\n", + "result = inference_detector(model, image)\n", + "print(result)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4pFVhKeQRYYS" + }, + "source": [ + "### Let's plot the result" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "YinmJV1dRYYT", + "outputId": "e6c9059f-55b3-481b-edef-b21befcbcf2e" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/mmengine/visualization/visualizer.py:196: UserWarning: Failed to add , please provide the `save_dir` argument.\n", + " warnings.warn(f'Failed to add {vis_backend.__class__}, '\n" + ] + } + ], + "source": [ + "from mmdet.registry import VISUALIZERS\n", + "# init visualizer(run the block only once in jupyter notebook)\n", + "visualizer = VISUALIZERS.build(model.cfg.visualizer)\n", + "# the dataset_meta is loaded from the checkpoint and\n", + "# then pass to the model in init_detector\n", + "visualizer.dataset_meta = model.dataset_meta" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 464 + }, + "id": "z6qT6pG1RYYT", + "outputId": "089b652b-061f-480d-f9de-ffa06b7d385a" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
    " + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# show the results\n", + "visualizer.add_datasample(\n", + " 'result',\n", + " image,\n", + " data_sample=result,\n", + " draw_gt = None,\n", + " wait_time=0,\n", + ")\n", + "visualizer.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7GrWIJywLV-V" + }, + "source": [ + "## Train a Detector on A Customized Dataset\n", + "\n", + "To train a new detector, there are usually three things to do:\n", + "1. Support a new dataset\n", + "2. Modify the config\n", + "3. Train a new detector\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "E73y5Lru-wBx" + }, + "source": [ + "### Support a new dataset\n", + "\n", + "There are three ways to support a new dataset in MMDetection:\n", + " 1. Reorganize the dataset into a COCO format\n", + " 2. Reorganize the dataset into a middle format\n", + " 3. Implement a new dataset\n", + "\n", + "We recommend the first two methods, as they are usually easier than the third.\n", + "\n", + "In this tutorial, we give an example that converts the data into COCO format because MMDetection **only support evaluating mask AP of dataset in COCO format for now**. Other methods and more advanced usages can be found in the [doc](https://mmdetection.readthedocs.io/en/latest/advanced_guides/customize_dataset.html).\n", + "\n", + "First, let's download the [the balloon dataset](https://github.com/matterport/Mask_RCNN/tree/master/samples/balloon)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "rHnw5Q_nARXq" + }, + "outputs": [], + "source": [ + "# download and unzip the data\n", + "!wget -c https://github.com/matterport/Mask_RCNN/releases/download/v2.1/balloon_dataset.zip" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ucSfn1U_RYYW" + }, + "outputs": [], + "source": [ + "!unzip balloon_dataset.zip -d ./ballondatasets/" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Ro6JhfBVRYYX" + }, + "source": [ + "# Check the directory structure of the tiny data\n", + "\n", + "# Install tree first in your terminal(linux)\n", + "sudo apt-get -q install tree\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Wuwxw1oZRtVZ", + "outputId": "2e472cfa-2e2f-41ea-ddec-5a9d49fe71cf" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/bin/bash: line 1: tree: command not found\n" + ] + } + ], + "source": [ + "!tree ballondatasets" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 836 + }, + "id": "YnQQqzOWzE91", + "outputId": "ff7d3804-638c-461f-aef6-8c496a4b69c8" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
    " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Let's take a look at the dataset image\n", + "import mmcv\n", + "import matplotlib.pyplot as plt\n", + "\n", + "img = mmcv.imread('ballondatasets/balloon/train/10464445726_6f1e3bbe6a_k.jpg')\n", + "plt.figure(figsize=(15, 10))\n", + "plt.imshow(mmcv.bgr2rgb(img))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PMZvtSIl71qi" + }, + "source": [ + "After downloading the data, we need to implement a function to convert the annotation format into the COCO format. Then we can use implemented `COCODataset` to load the data and perform training and evaluation.\n", + "Let's take a look at the annotation json file.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "id": "n7rwalnPd6e1" + }, + "outputs": [], + "source": [ + "# Check the label of a single image\n", + "import mmengine\n", + "\n", + "annotation = mmengine.load('./ballondatasets/balloon/train/via_region_data.json')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "keLW7uqJM54Y", + "outputId": "8bdf087e-5ec0-4f8a-ee1d-5692986ac87d" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'fileref': '',\n", + " 'size': 1115004,\n", + " 'filename': '34020010494_e5cb88e1c4_k.jpg',\n", + " 'base64_img_data': '',\n", + " 'file_attributes': {},\n", + " 'regions': {'0': {'shape_attributes': {'name': 'polygon',\n", + " 'all_points_x': [1020,\n", + " 1000,\n", + " 994,\n", + " 1003,\n", + " 1023,\n", + " 1050,\n", + " 1089,\n", + " 1134,\n", + " 1190,\n", + " 1265,\n", + " 1321,\n", + " 1361,\n", + " 1403,\n", + " 1428,\n", + " 1442,\n", + " 1445,\n", + " 1441,\n", + " 1427,\n", + " 1400,\n", + " 1361,\n", + " 1316,\n", + " 1269,\n", + " 1228,\n", + " 1198,\n", + " 1207,\n", + " 1210,\n", + " 1190,\n", + " 1177,\n", + " 1172,\n", + " 1174,\n", + " 1170,\n", + " 1153,\n", + " 1127,\n", + " 1104,\n", + " 1061,\n", + " 1032,\n", + " 1020],\n", + " 'all_points_y': [963,\n", + " 899,\n", + " 841,\n", + " 787,\n", + " 738,\n", + " 700,\n", + " 663,\n", + " 638,\n", + " 621,\n", + " 619,\n", + " 643,\n", + " 672,\n", + " 720,\n", + " 765,\n", + " 800,\n", + " 860,\n", + " 896,\n", + " 942,\n", + " 990,\n", + " 1035,\n", + " 1079,\n", + " 1112,\n", + " 1129,\n", + " 1134,\n", + " 1144,\n", + " 1153,\n", + " 1166,\n", + " 1166,\n", + " 1150,\n", + " 1136,\n", + " 1129,\n", + " 1122,\n", + " 1112,\n", + " 1084,\n", + " 1037,\n", + " 989,\n", + " 963]},\n", + " 'region_attributes': {}}}}" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# The annotation is a dict, and its values looks like the following\n", + "annotation['34020010494_e5cb88e1c4_k.jpg1115004']" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QA1pFg-FeO3l" + }, + "source": [ + "According to the above observation, each single image has a corresponding annotation containing keys `filename` and `regions` that are necessary for training.\n", + "We need to read annotations of each image and convert them into COCO format as below:\n", + "\n", + "```python\n", + "{\n", + " \"images\": [image],\n", + " \"annotations\": [annotation],\n", + " \"categories\": [category]\n", + "}\n", + "\n", + "\n", + "image = {\n", + " \"id\": int,\n", + " \"width\": int,\n", + " \"height\": int,\n", + " \"file_name\": str,\n", + "}\n", + "\n", + "annotation = {\n", + " \"id\": int,\n", + " \"image_id\": int,\n", + " \"category_id\": int,\n", + " \"segmentation\": RLE or [polygon],\n", + " \"area\": float,\n", + " \"bbox\": [x,y,width,height],\n", + " \"iscrowd\": 0 or 1,\n", + "}\n", + "\n", + "categories = [{\n", + " \"id\": int,\n", + " \"name\": str,\n", + " \"supercategory\": str,\n", + "}]\n", + "```\n", + "**Note**: We only list the necessary keys for training, as shown above. For a full COCO format, please see [here](https://cocodataset.org/#format-data)." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "id": "GdSaB2ad0EdX" + }, + "outputs": [], + "source": [ + "import os.path as osp\n", + "\n", + "def convert_balloon_to_coco(ann_file, out_file, image_prefix):\n", + " data_infos = mmengine.load(ann_file)\n", + "\n", + " annotations = []\n", + " images = []\n", + " obj_count = 0\n", + " for idx, v in enumerate(mmengine.track_iter_progress(list(data_infos.values()))):\n", + " filename = v['filename']\n", + " img_path = osp.join(image_prefix, filename)\n", + " height, width = mmcv.imread(img_path).shape[:2]\n", + "\n", + " images.append(dict(\n", + " id=idx,\n", + " file_name=filename,\n", + " height=height,\n", + " width=width))\n", + "\n", + " bboxes = []\n", + " labels = []\n", + " masks = []\n", + " for _, obj in v['regions'].items():\n", + " assert not obj['region_attributes']\n", + " obj = obj['shape_attributes']\n", + " px = obj['all_points_x']\n", + " py = obj['all_points_y']\n", + " poly = [(x + 0.5, y + 0.5) for x, y in zip(px, py)]\n", + " poly = [p for x in poly for p in x]\n", + "\n", + " x_min, y_min, x_max, y_max = (\n", + " min(px), min(py), max(px), max(py))\n", + "\n", + "\n", + " data_anno = dict(\n", + " image_id=idx,\n", + " id=obj_count,\n", + " category_id=0,\n", + " bbox=[x_min, y_min, x_max - x_min, y_max - y_min],\n", + " area=(x_max - x_min) * (y_max - y_min),\n", + " segmentation=[poly],\n", + " iscrowd=0)\n", + " annotations.append(data_anno)\n", + " obj_count += 1\n", + "\n", + " coco_format_json = dict(\n", + " images=images,\n", + " annotations=annotations,\n", + " categories=[{'id':0, 'name': 'balloon'}])\n", + " mmengine.dump(coco_format_json, out_file)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "G3xV5ktqlpFu", + "outputId": "2d97137b-34e6-42e5-c8d6-0a4fe7d2c7cf" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 61/61, 19.7 task/s, elapsed: 3s, ETA: 0s\n", + "[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 13/13, 20.1 task/s, elapsed: 1s, ETA: 0s\n" + ] + } + ], + "source": [ + "convert_balloon_to_coco(\n", + " './ballondatasets/balloon/train/via_region_data.json',\n", + " './ballondatasets/balloon/train/annotation_coco.json',\n", + " './ballondatasets/balloon/train/')\n", + "convert_balloon_to_coco(\n", + " './ballondatasets/balloon/val/via_region_data.json',\n", + " './ballondatasets/balloon/val/annotation_coco.json',\n", + " './ballondatasets/balloon/val/')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "h85AtunjRvx4" + }, + "source": [ + "Checking the label corresponding to the instance split ID after the data format conversion is complete" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "zaYkWbxORwZq", + "outputId": "02ad1ff6-f138-49af-b733-1d23c51557f5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loading annotations into memory...\n", + "Done (t=0.01s)\n", + "creating index...\n", + "index created!\n", + "Category ID: 0, Category Name: balloon\n" + ] + } + ], + "source": [ + "from pycocotools.coco import COCO\n", + "\n", + "# Path to load the COCO annotation file\n", + "annotation_file = './ballondatasets/balloon/train/annotation_coco.json'\n", + "\n", + "# Initialise the COCO object\n", + "coco = COCO(annotation_file)\n", + "\n", + "# Get all category tags and corresponding category IDs\n", + "categories = coco.loadCats(coco.getCatIds())\n", + "category_id_to_name = {cat['id']: cat['name'] for cat in categories}\n", + "\n", + "# Print all category IDs and corresponding category names\n", + "for category_id, category_name in category_id_to_name.items():\n", + " print(f\"Category ID: {category_id}, Category Name: {category_name}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PwqJOpBe-bMj" + }, + "source": [ + "### Modify the config\n", + "\n", + "In the next step, we need to modify the config for the training.\n", + "To accelerate the process, we finetune a detector using a pre-trained detector." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "id": "hamZrlnH-YDD" + }, + "outputs": [], + "source": [ + "from mmengine import Config\n", + "cfg = Config.fromfile('./configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco.py')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HntziLGq-92Z" + }, + "source": [ + "Given a config that trains a Mask R-CNN on COCO dataset, we need to modify some values to use it for training on the balloon dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "id": "pUbwD8uV0PR8" + }, + "outputs": [], + "source": [ + "from mmengine.runner import set_random_seed\n", + "\n", + "# Modify dataset classes and color\n", + "cfg.metainfo = {\n", + " 'classes': ('balloon', ),\n", + " 'palette': [\n", + " (220, 20, 60),\n", + " ]\n", + "}\n", + "\n", + "# Modify dataset type and path\n", + "cfg.data_root = './ballondatasets/balloon'\n", + "\n", + "cfg.train_dataloader.dataset.ann_file = 'train/annotation_coco.json'\n", + "cfg.train_dataloader.dataset.data_root = cfg.data_root\n", + "cfg.train_dataloader.dataset.data_prefix.img = 'train/'\n", + "cfg.train_dataloader.dataset.metainfo = cfg.metainfo\n", + "\n", + "cfg.val_dataloader.dataset.ann_file = 'val/annotation_coco.json'\n", + "cfg.val_dataloader.dataset.data_root = cfg.data_root\n", + "cfg.val_dataloader.dataset.data_prefix.img = 'val/'\n", + "cfg.val_dataloader.dataset.metainfo = cfg.metainfo\n", + "\n", + "cfg.test_dataloader = cfg.val_dataloader\n", + "\n", + "# Modify metric config\n", + "cfg.val_evaluator.ann_file = cfg.data_root+'/'+'val/annotation_coco.json'\n", + "cfg.test_evaluator = cfg.val_evaluator\n", + "\n", + "# Modify num classes of the model in box head and mask head\n", + "cfg.model.roi_head.bbox_head.num_classes = 1\n", + "cfg.model.roi_head.mask_head.num_classes = 1\n", + "\n", + "# We can still the pre-trained Mask RCNN model to obtain a higher performance\n", + "cfg.load_from = 'checkpoints/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth'\n", + "\n", + "# Set up working dir to save files and logs.\n", + "cfg.work_dir = './tutorial_exps'\n", + "\n", + "\n", + "# We can set the evaluation interval to reduce the evaluation times\n", + "cfg.train_cfg.val_interval = 3\n", + "# We can set the checkpoint saving interval to reduce the storage cost\n", + "cfg.default_hooks.checkpoint.interval = 3\n", + "\n", + "# The original learning rate (LR) is set for 8-GPU training.\n", + "# We divide it by 8 since we only use one GPU.\n", + "cfg.optim_wrapper.optimizer.lr = 0.02 / 8\n", + "cfg.default_hooks.logger.interval = 10\n", + "\n", + "\n", + "# Set seed thus the results are more reproducible\n", + "# cfg.seed = 0\n", + "set_random_seed(0, deterministic=False)\n", + "\n", + "# We can also use tensorboard to log the training process\n", + "cfg.visualizer.vis_backends.append({\"type\":'TensorboardVisBackend'})\n", + "\n", + "#------------------------------------------------------\n", + "config=f'./configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-poly-3x_balloon.py'\n", + "with open(config, 'w') as f:\n", + " f.write(cfg.pretty_text)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "111W_oZV_3wa" + }, + "source": [ + "### Train a new detector\n", + "\n", + "Finally, lets initialize the dataset and detector, then train a new detector!" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "JiqDnPdAMGyg", + "outputId": "0de25679-3541-488e-eceb-5b5400f92745" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "08/15 04:31:57 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - \n", + "------------------------------------------------------------\n", + "System environment:\n", + " sys.platform: linux\n", + " Python: 3.10.12 (main, Jun 11 2023, 05:26:28) [GCC 11.4.0]\n", + " CUDA available: True\n", + " numpy_random_seed: 1186080067\n", + " GPU 0: Tesla T4\n", + " CUDA_HOME: /usr/local/cuda\n", + " NVCC: Cuda compilation tools, release 11.8, V11.8.89\n", + " GCC: x86_64-linux-gnu-gcc (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0\n", + " PyTorch: 2.0.1+cu118\n", + " PyTorch compiling details: PyTorch built with:\n", + " - GCC 9.3\n", + " - C++ Version: 201703\n", + " - Intel(R) oneAPI Math Kernel Library Version 2022.2-Product Build 20220804 for Intel(R) 64 architecture applications\n", + " - Intel(R) MKL-DNN v2.7.3 (Git Hash 6dbeffbae1f23cbbeae17adb7b5b13f1f37c080e)\n", + " - OpenMP 201511 (a.k.a. OpenMP 4.5)\n", + " - LAPACK is enabled (usually provided by MKL)\n", + " - NNPACK is enabled\n", + " - CPU capability usage: AVX2\n", + " - CUDA Runtime 11.8\n", + " - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90\n", + " - CuDNN 8.7\n", + " - Magma 2.6.1\n", + " - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, CUDA_VERSION=11.8, CUDNN_VERSION=8.7.0, CXX_COMPILER=/opt/rh/devtoolset-9/root/usr/bin/c++, CXX_FLAGS= -D_GLIBCXX_USE_CXX11_ABI=0 -fabi-version=11 -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wunused-local-typedefs -Wno-unused-parameter -Wno-unused-function -Wno-unused-result -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Werror=cast-function-type -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, TORCH_DISABLE_GPU_ASSERTS=ON, TORCH_VERSION=2.0.1, USE_CUDA=ON, USE_CUDNN=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, \n", + "\n", + " TorchVision: 0.15.2+cu118\n", + " OpenCV: 4.8.0\n", + " MMEngine: 0.8.4\n", + "\n", + "Runtime environment:\n", + " cudnn_benchmark: False\n", + " dist_cfg: {'backend': 'nccl'}\n", + " mp_cfg: {'mp_start_method': 'fork', 'opencv_num_threads': 0}\n", + " seed: 1186080067\n", + " Distributed launcher: none\n", + " Distributed training: False\n", + " GPU number: 1\n", + "------------------------------------------------------------\n", + "\n", + "08/15 04:31:57 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Config:\n", + "auto_scale_lr = dict(base_batch_size=16, enable=False)\n", + "backend_args = None\n", + "data_root = './ballondatasets/balloon'\n", + "dataset_type = 'CocoDataset'\n", + "default_hooks = dict(\n", + " checkpoint=dict(interval=3, type='CheckpointHook'),\n", + " logger=dict(interval=10, type='LoggerHook'),\n", + " param_scheduler=dict(type='ParamSchedulerHook'),\n", + " sampler_seed=dict(type='DistSamplerSeedHook'),\n", + " timer=dict(type='IterTimerHook'),\n", + " visualization=dict(type='DetVisualizationHook'))\n", + "default_scope = 'mmdet'\n", + "env_cfg = dict(\n", + " cudnn_benchmark=False,\n", + " dist_cfg=dict(backend='nccl'),\n", + " mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0))\n", + "launcher = 'none'\n", + "load_from = 'checkpoints/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth'\n", + "log_level = 'INFO'\n", + "log_processor = dict(by_epoch=True, type='LogProcessor', window_size=50)\n", + "metainfo = dict(\n", + " classes=('balloon', ), palette=[\n", + " (\n", + " 220,\n", + " 20,\n", + " 60,\n", + " ),\n", + " ])\n", + "model = dict(\n", + " backbone=dict(\n", + " depth=50,\n", + " frozen_stages=1,\n", + " init_cfg=dict(\n", + " checkpoint='open-mmlab://detectron2/resnet50_caffe',\n", + " type='Pretrained'),\n", + " norm_cfg=dict(requires_grad=False, type='BN'),\n", + " norm_eval=True,\n", + " num_stages=4,\n", + " out_indices=(\n", + " 0,\n", + " 1,\n", + " 2,\n", + " 3,\n", + " ),\n", + " style='caffe',\n", + " type='ResNet'),\n", + " data_preprocessor=dict(\n", + " bgr_to_rgb=False,\n", + " mean=[\n", + " 103.53,\n", + " 116.28,\n", + " 123.675,\n", + " ],\n", + " pad_mask=True,\n", + " pad_size_divisor=32,\n", + " std=[\n", + " 1.0,\n", + " 1.0,\n", + " 1.0,\n", + " ],\n", + " type='DetDataPreprocessor'),\n", + " neck=dict(\n", + " in_channels=[\n", + " 256,\n", + " 512,\n", + " 1024,\n", + " 2048,\n", + " ],\n", + " num_outs=5,\n", + " out_channels=256,\n", + " type='FPN'),\n", + " roi_head=dict(\n", + " bbox_head=dict(\n", + " bbox_coder=dict(\n", + " target_means=[\n", + " 0.0,\n", + " 0.0,\n", + " 0.0,\n", + " 0.0,\n", + " ],\n", + " target_stds=[\n", + " 0.1,\n", + " 0.1,\n", + " 0.2,\n", + " 0.2,\n", + " ],\n", + " type='DeltaXYWHBBoxCoder'),\n", + " fc_out_channels=1024,\n", + " in_channels=256,\n", + " loss_bbox=dict(loss_weight=1.0, type='L1Loss'),\n", + " loss_cls=dict(\n", + " loss_weight=1.0, type='CrossEntropyLoss', use_sigmoid=False),\n", + " num_classes=1,\n", + " reg_class_agnostic=False,\n", + " roi_feat_size=7,\n", + " type='Shared2FCBBoxHead'),\n", + " bbox_roi_extractor=dict(\n", + " featmap_strides=[\n", + " 4,\n", + " 8,\n", + " 16,\n", + " 32,\n", + " ],\n", + " out_channels=256,\n", + " roi_layer=dict(output_size=7, sampling_ratio=0, type='RoIAlign'),\n", + " type='SingleRoIExtractor'),\n", + " mask_head=dict(\n", + " conv_out_channels=256,\n", + " in_channels=256,\n", + " loss_mask=dict(\n", + " loss_weight=1.0, type='CrossEntropyLoss', use_mask=True),\n", + " num_classes=1,\n", + " num_convs=4,\n", + " type='FCNMaskHead'),\n", + " mask_roi_extractor=dict(\n", + " featmap_strides=[\n", + " 4,\n", + " 8,\n", + " 16,\n", + " 32,\n", + " ],\n", + " out_channels=256,\n", + " roi_layer=dict(output_size=14, sampling_ratio=0, type='RoIAlign'),\n", + " type='SingleRoIExtractor'),\n", + " type='StandardRoIHead'),\n", + " rpn_head=dict(\n", + " anchor_generator=dict(\n", + " ratios=[\n", + " 0.5,\n", + " 1.0,\n", + " 2.0,\n", + " ],\n", + " scales=[\n", + " 8,\n", + " ],\n", + " strides=[\n", + " 4,\n", + " 8,\n", + " 16,\n", + " 32,\n", + " 64,\n", + " ],\n", + " type='AnchorGenerator'),\n", + " bbox_coder=dict(\n", + " target_means=[\n", + " 0.0,\n", + " 0.0,\n", + " 0.0,\n", + " 0.0,\n", + " ],\n", + " target_stds=[\n", + " 1.0,\n", + " 1.0,\n", + " 1.0,\n", + " 1.0,\n", + " ],\n", + " type='DeltaXYWHBBoxCoder'),\n", + " feat_channels=256,\n", + " in_channels=256,\n", + " loss_bbox=dict(loss_weight=1.0, type='L1Loss'),\n", + " loss_cls=dict(\n", + " loss_weight=1.0, type='CrossEntropyLoss', use_sigmoid=True),\n", + " type='RPNHead'),\n", + " test_cfg=dict(\n", + " rcnn=dict(\n", + " mask_thr_binary=0.5,\n", + " max_per_img=100,\n", + " nms=dict(iou_threshold=0.5, type='nms'),\n", + " score_thr=0.05),\n", + " rpn=dict(\n", + " max_per_img=1000,\n", + " min_bbox_size=0,\n", + " nms=dict(iou_threshold=0.7, type='nms'),\n", + " nms_pre=1000)),\n", + " train_cfg=dict(\n", + " rcnn=dict(\n", + " assigner=dict(\n", + " ignore_iof_thr=-1,\n", + " match_low_quality=True,\n", + " min_pos_iou=0.5,\n", + " neg_iou_thr=0.5,\n", + " pos_iou_thr=0.5,\n", + " type='MaxIoUAssigner'),\n", + " debug=False,\n", + " mask_size=28,\n", + " pos_weight=-1,\n", + " sampler=dict(\n", + " add_gt_as_proposals=True,\n", + " neg_pos_ub=-1,\n", + " num=512,\n", + " pos_fraction=0.25,\n", + " type='RandomSampler')),\n", + " rpn=dict(\n", + " allowed_border=-1,\n", + " assigner=dict(\n", + " ignore_iof_thr=-1,\n", + " match_low_quality=True,\n", + " min_pos_iou=0.3,\n", + " neg_iou_thr=0.3,\n", + " pos_iou_thr=0.7,\n", + " type='MaxIoUAssigner'),\n", + " debug=False,\n", + " pos_weight=-1,\n", + " sampler=dict(\n", + " add_gt_as_proposals=False,\n", + " neg_pos_ub=-1,\n", + " num=256,\n", + " pos_fraction=0.5,\n", + " type='RandomSampler')),\n", + " rpn_proposal=dict(\n", + " max_per_img=1000,\n", + " min_bbox_size=0,\n", + " nms=dict(iou_threshold=0.7, type='nms'),\n", + " nms_pre=2000)),\n", + " type='MaskRCNN')\n", + "optim_wrapper = dict(\n", + " optimizer=dict(lr=0.0025, momentum=0.9, type='SGD', weight_decay=0.0001),\n", + " type='OptimWrapper')\n", + "param_scheduler = [\n", + " dict(\n", + " begin=0, by_epoch=False, end=500, start_factor=0.001, type='LinearLR'),\n", + " dict(\n", + " begin=0,\n", + " by_epoch=True,\n", + " end=12,\n", + " gamma=0.1,\n", + " milestones=[\n", + " 8,\n", + " 11,\n", + " ],\n", + " type='MultiStepLR'),\n", + "]\n", + "resume = False\n", + "test_cfg = dict(type='TestLoop')\n", + "test_dataloader = dict(\n", + " batch_size=1,\n", + " dataset=dict(\n", + " ann_file='val/annotation_coco.json',\n", + " backend_args=None,\n", + " data_prefix=dict(img='val/'),\n", + " data_root='./ballondatasets/balloon',\n", + " metainfo=dict(classes=('balloon', ), palette=[\n", + " (\n", + " 220,\n", + " 20,\n", + " 60,\n", + " ),\n", + " ]),\n", + " pipeline=[\n", + " dict(backend_args=None, type='LoadImageFromFile'),\n", + " dict(keep_ratio=True, scale=(\n", + " 1333,\n", + " 800,\n", + " ), type='Resize'),\n", + " dict(type='LoadAnnotations', with_bbox=True, with_mask=True),\n", + " dict(\n", + " meta_keys=(\n", + " 'img_id',\n", + " 'img_path',\n", + " 'ori_shape',\n", + " 'img_shape',\n", + " 'scale_factor',\n", + " ),\n", + " type='PackDetInputs'),\n", + " ],\n", + " test_mode=True,\n", + " type='CocoDataset'),\n", + " drop_last=False,\n", + " num_workers=2,\n", + " persistent_workers=True,\n", + " sampler=dict(shuffle=False, type='DefaultSampler'))\n", + "test_evaluator = dict(\n", + " ann_file='./ballondatasets/balloon/val/annotation_coco.json',\n", + " backend_args=None,\n", + " format_only=False,\n", + " metric=[\n", + " 'bbox',\n", + " 'segm',\n", + " ],\n", + " type='CocoMetric')\n", + "test_pipeline = [\n", + " dict(backend_args=None, type='LoadImageFromFile'),\n", + " dict(keep_ratio=True, scale=(\n", + " 1333,\n", + " 800,\n", + " ), type='Resize'),\n", + " dict(type='LoadAnnotations', with_bbox=True, with_mask=True),\n", + " dict(\n", + " meta_keys=(\n", + " 'img_id',\n", + " 'img_path',\n", + " 'ori_shape',\n", + " 'img_shape',\n", + " 'scale_factor',\n", + " ),\n", + " type='PackDetInputs'),\n", + "]\n", + "train_cfg = dict(max_epochs=12, type='EpochBasedTrainLoop', val_interval=3)\n", + "train_dataloader = dict(\n", + " batch_sampler=dict(type='AspectRatioBatchSampler'),\n", + " batch_size=2,\n", + " dataset=dict(\n", + " ann_file='train/annotation_coco.json',\n", + " backend_args=None,\n", + " data_prefix=dict(img='train/'),\n", + " data_root='./ballondatasets/balloon',\n", + " filter_cfg=dict(filter_empty_gt=True, min_size=32),\n", + " metainfo=dict(classes=('balloon', ), palette=[\n", + " (\n", + " 220,\n", + " 20,\n", + " 60,\n", + " ),\n", + " ]),\n", + " pipeline=[\n", + " dict(backend_args=None, type='LoadImageFromFile'),\n", + " dict(\n", + " poly2mask=False,\n", + " type='LoadAnnotations',\n", + " with_bbox=True,\n", + " with_mask=True),\n", + " dict(\n", + " keep_ratio=True,\n", + " scales=[\n", + " (\n", + " 1333,\n", + " 640,\n", + " ),\n", + " (\n", + " 1333,\n", + " 672,\n", + " ),\n", + " (\n", + " 1333,\n", + " 704,\n", + " ),\n", + " (\n", + " 1333,\n", + " 736,\n", + " ),\n", + " (\n", + " 1333,\n", + " 768,\n", + " ),\n", + " (\n", + " 1333,\n", + " 800,\n", + " ),\n", + " ],\n", + " type='RandomChoiceResize'),\n", + " dict(prob=0.5, type='RandomFlip'),\n", + " dict(type='PackDetInputs'),\n", + " ],\n", + " type='CocoDataset'),\n", + " num_workers=2,\n", + " persistent_workers=True,\n", + " sampler=dict(shuffle=True, type='DefaultSampler'))\n", + "train_pipeline = [\n", + " dict(backend_args=None, type='LoadImageFromFile'),\n", + " dict(\n", + " poly2mask=False,\n", + " type='LoadAnnotations',\n", + " with_bbox=True,\n", + " with_mask=True),\n", + " dict(\n", + " keep_ratio=True,\n", + " scales=[\n", + " (\n", + " 1333,\n", + " 640,\n", + " ),\n", + " (\n", + " 1333,\n", + " 672,\n", + " ),\n", + " (\n", + " 1333,\n", + " 704,\n", + " ),\n", + " (\n", + " 1333,\n", + " 736,\n", + " ),\n", + " (\n", + " 1333,\n", + " 768,\n", + " ),\n", + " (\n", + " 1333,\n", + " 800,\n", + " ),\n", + " ],\n", + " type='RandomChoiceResize'),\n", + " dict(prob=0.5, type='RandomFlip'),\n", + " dict(type='PackDetInputs'),\n", + "]\n", + "val_cfg = dict(type='ValLoop')\n", + "val_dataloader = dict(\n", + " batch_size=1,\n", + " dataset=dict(\n", + " ann_file='val/annotation_coco.json',\n", + " backend_args=None,\n", + " data_prefix=dict(img='val/'),\n", + " data_root='./ballondatasets/balloon',\n", + " metainfo=dict(classes=('balloon', ), palette=[\n", + " (\n", + " 220,\n", + " 20,\n", + " 60,\n", + " ),\n", + " ]),\n", + " pipeline=[\n", + " dict(backend_args=None, type='LoadImageFromFile'),\n", + " dict(keep_ratio=True, scale=(\n", + " 1333,\n", + " 800,\n", + " ), type='Resize'),\n", + " dict(type='LoadAnnotations', with_bbox=True, with_mask=True),\n", + " dict(\n", + " meta_keys=(\n", + " 'img_id',\n", + " 'img_path',\n", + " 'ori_shape',\n", + " 'img_shape',\n", + " 'scale_factor',\n", + " ),\n", + " type='PackDetInputs'),\n", + " ],\n", + " test_mode=True,\n", + " type='CocoDataset'),\n", + " drop_last=False,\n", + " num_workers=2,\n", + " persistent_workers=True,\n", + " sampler=dict(shuffle=False, type='DefaultSampler'))\n", + "val_evaluator = dict(\n", + " ann_file='./ballondatasets/balloon/val/annotation_coco.json',\n", + " backend_args=None,\n", + " format_only=False,\n", + " metric=[\n", + " 'bbox',\n", + " 'segm',\n", + " ],\n", + " type='CocoMetric')\n", + "vis_backends = [\n", + " dict(type='LocalVisBackend'),\n", + "]\n", + "visualizer = dict(\n", + " name='visualizer',\n", + " type='DetLocalVisualizer',\n", + " vis_backends=[\n", + " dict(type='LocalVisBackend'),\n", + " dict(type='TensorboardVisBackend'),\n", + " ])\n", + "work_dir = './tutorial_exps'\n", + "\n", + "2023-08-15 04:31:59.033157: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-08-15 04:32:00.371943: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", + "08/15 04:32:04 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Distributed training is not used, all SyncBatchNorm (SyncBN) layers in the model will be automatically reverted to BatchNormXd layers if they are used.\n", + "08/15 04:32:04 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Hooks will be executed in the following order:\n", + "before_run:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(BELOW_NORMAL) LoggerHook \n", + " -------------------- \n", + "before_train:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(NORMAL ) IterTimerHook \n", + "(VERY_LOW ) CheckpointHook \n", + " -------------------- \n", + "before_train_epoch:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(NORMAL ) IterTimerHook \n", + "(NORMAL ) DistSamplerSeedHook \n", + " -------------------- \n", + "before_train_iter:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(NORMAL ) IterTimerHook \n", + " -------------------- \n", + "after_train_iter:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(NORMAL ) IterTimerHook \n", + "(BELOW_NORMAL) LoggerHook \n", + "(LOW ) ParamSchedulerHook \n", + "(VERY_LOW ) CheckpointHook \n", + " -------------------- \n", + "after_train_epoch:\n", + "(NORMAL ) IterTimerHook \n", + "(LOW ) ParamSchedulerHook \n", + "(VERY_LOW ) CheckpointHook \n", + " -------------------- \n", + "before_val:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + " -------------------- \n", + "before_val_epoch:\n", + "(NORMAL ) IterTimerHook \n", + " -------------------- \n", + "before_val_iter:\n", + "(NORMAL ) IterTimerHook \n", + " -------------------- \n", + "after_val_iter:\n", + "(NORMAL ) IterTimerHook \n", + "(NORMAL ) DetVisualizationHook \n", + "(BELOW_NORMAL) LoggerHook \n", + " -------------------- \n", + "after_val_epoch:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(NORMAL ) IterTimerHook \n", + "(BELOW_NORMAL) LoggerHook \n", + "(LOW ) ParamSchedulerHook \n", + "(VERY_LOW ) CheckpointHook \n", + " -------------------- \n", + "after_val:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + " -------------------- \n", + "after_train:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(VERY_LOW ) CheckpointHook \n", + " -------------------- \n", + "before_test:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + " -------------------- \n", + "before_test_epoch:\n", + "(NORMAL ) IterTimerHook \n", + " -------------------- \n", + "before_test_iter:\n", + "(NORMAL ) IterTimerHook \n", + " -------------------- \n", + "after_test_iter:\n", + "(NORMAL ) IterTimerHook \n", + "(NORMAL ) DetVisualizationHook \n", + "(BELOW_NORMAL) LoggerHook \n", + " -------------------- \n", + "after_test_epoch:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(NORMAL ) IterTimerHook \n", + "(BELOW_NORMAL) LoggerHook \n", + " -------------------- \n", + "after_test:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + " -------------------- \n", + "after_run:\n", + "(BELOW_NORMAL) LoggerHook \n", + " -------------------- \n", + "loading annotations into memory...\n", + "Done (t=0.01s)\n", + "creating index...\n", + "index created!\n", + "loading annotations into memory...\n", + "Done (t=0.00s)\n", + "creating index...\n", + "index created!\n", + "loading annotations into memory...\n", + "Done (t=0.00s)\n", + "creating index...\n", + "index created!\n", + "08/15 04:32:05 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - load model from: open-mmlab://detectron2/resnet50_caffe\n", + "08/15 04:32:05 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Loads checkpoint by openmmlab backend from path: open-mmlab://detectron2/resnet50_caffe\n", + "Downloading: \"https://download.openmmlab.com/pretrain/third_party/resnet50_msra-5891d200.pth\" to /root/.cache/torch/hub/checkpoints/resnet50_msra-5891d200.pth\n", + "100% 89.9M/89.9M [00:12<00:00, 7.43MB/s]\n", + "08/15 04:32:19 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - The model and loaded state dict do not match exactly\n", + "\n", + "unexpected key in source state_dict: conv1.bias\n", + "\n", + "Loads checkpoint by local backend from path: checkpoints/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth\n", + "The model and loaded state dict do not match exactly\n", + "\n", + "size mismatch for roi_head.bbox_head.fc_cls.weight: copying a param with shape torch.Size([81, 1024]) from checkpoint, the shape in current model is torch.Size([2, 1024]).\n", + "size mismatch for roi_head.bbox_head.fc_cls.bias: copying a param with shape torch.Size([81]) from checkpoint, the shape in current model is torch.Size([2]).\n", + "size mismatch for roi_head.bbox_head.fc_reg.weight: copying a param with shape torch.Size([320, 1024]) from checkpoint, the shape in current model is torch.Size([4, 1024]).\n", + "size mismatch for roi_head.bbox_head.fc_reg.bias: copying a param with shape torch.Size([320]) from checkpoint, the shape in current model is torch.Size([4]).\n", + "size mismatch for roi_head.mask_head.conv_logits.weight: copying a param with shape torch.Size([80, 256, 1, 1]) from checkpoint, the shape in current model is torch.Size([1, 256, 1, 1]).\n", + "size mismatch for roi_head.mask_head.conv_logits.bias: copying a param with shape torch.Size([80]) from checkpoint, the shape in current model is torch.Size([1]).\n", + "08/15 04:32:19 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Load checkpoint from checkpoints/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth\n", + "08/15 04:32:19 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - \"FileClient\" will be deprecated in future. Please use io functions in https://mmengine.readthedocs.io/en/latest/api/fileio.html#file-io\n", + "08/15 04:32:19 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - \"HardDiskBackend\" is the alias of \"LocalBackend\" and the former will be deprecated in future.\n", + "08/15 04:32:19 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Checkpoints will be saved to /content/mmdetection/tutorial_exps.\n", + "08/15 04:32:25 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [1][10/31] lr: 4.7545e-05 eta: 0:03:33 time: 0.5898 data_time: 0.0359 memory: 3283 loss: 16.7169 loss_rpn_cls: 0.1373 loss_rpn_bbox: 0.0201 loss_cls: 0.6155 acc: 83.3984 loss_bbox: 0.3727 loss_mask: 15.5713\n", + "08/15 04:32:30 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [1][20/31] lr: 9.7595e-05 eta: 0:03:05 time: 0.5271 data_time: 0.0214 memory: 3283 loss: 10.8499 loss_rpn_cls: 0.0836 loss_rpn_bbox: 0.0148 loss_cls: 0.5401 acc: 84.6680 loss_bbox: 0.2949 loss_mask: 9.9164\n", + "08/15 04:32:35 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [1][30/31] lr: 1.4765e-04 eta: 0:03:02 time: 0.5348 data_time: 0.0180 memory: 3283 loss: 7.7485 loss_rpn_cls: 0.0823 loss_rpn_bbox: 0.0183 loss_cls: 0.4752 acc: 95.7031 loss_bbox: 0.2886 loss_mask: 6.8839\n", + "08/15 04:32:35 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-3x_balloon_20230815_043154\n", + "08/15 04:32:41 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [2][10/31] lr: 2.0270e-04 eta: 0:02:53 time: 0.5254 data_time: 0.0198 memory: 3449 loss: 5.9555 loss_rpn_cls: 0.0705 loss_rpn_bbox: 0.0176 loss_cls: 0.4270 acc: 93.2617 loss_bbox: 0.3093 loss_mask: 5.1312\n", + "08/15 04:32:46 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [2][20/31] lr: 2.5275e-04 eta: 0:02:49 time: 0.5077 data_time: 0.0126 memory: 3282 loss: 4.6321 loss_rpn_cls: 0.0661 loss_rpn_bbox: 0.0176 loss_cls: 0.3947 acc: 84.6680 loss_bbox: 0.3221 loss_mask: 3.8315\n", + "08/15 04:32:52 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [2][30/31] lr: 3.0280e-04 eta: 0:02:45 time: 0.5237 data_time: 0.0137 memory: 3283 loss: 1.8118 loss_rpn_cls: 0.0470 loss_rpn_bbox: 0.0193 loss_cls: 0.3295 acc: 85.7422 loss_bbox: 0.3360 loss_mask: 1.0801\n", + "08/15 04:32:52 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-3x_balloon_20230815_043154\n", + "08/15 04:32:57 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [3][10/31] lr: 3.5786e-04 eta: 0:02:37 time: 0.5224 data_time: 0.0146 memory: 3282 loss: 1.1179 loss_rpn_cls: 0.0411 loss_rpn_bbox: 0.0203 loss_cls: 0.2903 acc: 96.0938 loss_bbox: 0.3861 loss_mask: 0.3801\n", + "08/15 04:33:02 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [3][20/31] lr: 4.0791e-04 eta: 0:02:31 time: 0.5148 data_time: 0.0105 memory: 3283 loss: 0.9559 loss_rpn_cls: 0.0353 loss_rpn_bbox: 0.0189 loss_cls: 0.2542 acc: 95.4102 loss_bbox: 0.3753 loss_mask: 0.2723\n", + "08/15 04:33:08 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [3][30/31] lr: 4.5796e-04 eta: 0:02:27 time: 0.5319 data_time: 0.0118 memory: 3283 loss: 0.9498 loss_rpn_cls: 0.0316 loss_rpn_bbox: 0.0194 loss_cls: 0.2459 acc: 86.4258 loss_bbox: 0.4030 loss_mask: 0.2500\n", + "08/15 04:33:08 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-3x_balloon_20230815_043154\n", + "08/15 04:33:08 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Saving checkpoint at 3 epochs\n", + "08/15 04:33:20 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [3][10/13] eta: 0:00:03 time: 1.0153 data_time: 0.0759 memory: 2785 \n", + "08/15 04:33:21 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating bbox...\n", + "Loading and preparing results...\n", + "DONE (t=0.00s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *bbox*\n", + "DONE (t=0.16s).\n", + "Accumulating evaluation results...\n", + "DONE (t=0.06s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.515\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.736\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.597\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.266\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.621\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.644\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.644\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.644\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.525\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.719\n", + "08/15 04:33:21 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - bbox_mAP_copypaste: 0.515 0.736 0.597 0.000 0.266 0.621\n", + "08/15 04:33:21 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating segm...\n", + "Loading and preparing results...\n", + "DONE (t=0.04s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *segm*\n", + "DONE (t=0.21s).\n", + "Accumulating evaluation results...\n", + "DONE (t=0.06s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.622\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.733\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.729\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = 0.001\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.331\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.734\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.764\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.764\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.764\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = 0.150\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.750\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.803\n", + "08/15 04:33:22 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - segm_mAP_copypaste: 0.622 0.733 0.729 0.001 0.331 0.734\n", + "08/15 04:33:22 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [3][13/13] coco/bbox_mAP: 0.5150 coco/bbox_mAP_50: 0.7360 coco/bbox_mAP_75: 0.5970 coco/bbox_mAP_s: 0.0000 coco/bbox_mAP_m: 0.2660 coco/bbox_mAP_l: 0.6210 coco/segm_mAP: 0.6220 coco/segm_mAP_50: 0.7330 coco/segm_mAP_75: 0.7290 coco/segm_mAP_s: 0.0010 coco/segm_mAP_m: 0.3310 coco/segm_mAP_l: 0.7340 data_time: 0.0597 time: 0.8604\n", + "08/15 04:33:27 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [4][10/31] lr: 5.1301e-04 eta: 0:02:22 time: 0.5251 data_time: 0.0119 memory: 3283 loss: 0.8807 loss_rpn_cls: 0.0273 loss_rpn_bbox: 0.0187 loss_cls: 0.2192 acc: 95.1172 loss_bbox: 0.4036 loss_mask: 0.2119\n", + "08/15 04:33:32 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [4][20/31] lr: 5.6306e-04 eta: 0:02:16 time: 0.5211 data_time: 0.0099 memory: 3004 loss: 0.8362 loss_rpn_cls: 0.0217 loss_rpn_bbox: 0.0173 loss_cls: 0.2001 acc: 97.4609 loss_bbox: 0.4115 loss_mask: 0.1856\n", + "08/15 04:33:38 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [4][30/31] lr: 6.1311e-04 eta: 0:02:11 time: 0.5334 data_time: 0.0108 memory: 3284 loss: 0.7356 loss_rpn_cls: 0.0198 loss_rpn_bbox: 0.0148 loss_cls: 0.1705 acc: 99.1211 loss_bbox: 0.3685 loss_mask: 0.1621\n", + "08/15 04:33:38 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-3x_balloon_20230815_043154\n", + "08/15 04:33:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [5][10/31] lr: 6.6817e-04 eta: 0:02:05 time: 0.5305 data_time: 0.0137 memory: 3283 loss: 0.6874 loss_rpn_cls: 0.0174 loss_rpn_bbox: 0.0127 loss_cls: 0.1545 acc: 95.1172 loss_bbox: 0.3607 loss_mask: 0.1421\n", + "08/15 04:33:49 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [5][20/31] lr: 7.1822e-04 eta: 0:01:59 time: 0.5216 data_time: 0.0115 memory: 3283 loss: 0.6122 loss_rpn_cls: 0.0162 loss_rpn_bbox: 0.0123 loss_cls: 0.1331 acc: 93.5547 loss_bbox: 0.3217 loss_mask: 0.1289\n", + "08/15 04:33:54 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [5][30/31] lr: 7.6827e-04 eta: 0:01:55 time: 0.5289 data_time: 0.0125 memory: 3283 loss: 0.5432 loss_rpn_cls: 0.0145 loss_rpn_bbox: 0.0122 loss_cls: 0.1175 acc: 93.7500 loss_bbox: 0.2771 loss_mask: 0.1219\n", + "08/15 04:33:55 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-3x_balloon_20230815_043154\n", + "08/15 04:34:00 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [6][10/31] lr: 8.2332e-04 eta: 0:01:49 time: 0.5335 data_time: 0.0137 memory: 3284 loss: 0.4541 loss_rpn_cls: 0.0139 loss_rpn_bbox: 0.0115 loss_cls: 0.0988 acc: 94.2383 loss_bbox: 0.2158 loss_mask: 0.1141\n", + "08/15 04:34:06 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [6][20/31] lr: 8.7337e-04 eta: 0:01:44 time: 0.5318 data_time: 0.0095 memory: 3283 loss: 0.4245 loss_rpn_cls: 0.0130 loss_rpn_bbox: 0.0122 loss_cls: 0.0944 acc: 99.4141 loss_bbox: 0.1922 loss_mask: 0.1127\n", + "08/15 04:34:11 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [6][30/31] lr: 9.2342e-04 eta: 0:01:39 time: 0.5465 data_time: 0.0102 memory: 3497 loss: 0.3810 loss_rpn_cls: 0.0133 loss_rpn_bbox: 0.0126 loss_cls: 0.0883 acc: 98.1445 loss_bbox: 0.1617 loss_mask: 0.1052\n", + "08/15 04:34:12 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-3x_balloon_20230815_043154\n", + "08/15 04:34:12 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Saving checkpoint at 6 epochs\n", + "08/15 04:34:17 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [6][10/13] eta: 0:00:01 time: 0.6382 data_time: 0.0735 memory: 1810 \n", + "08/15 04:34:18 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating bbox...\n", + "Loading and preparing results...\n", + "DONE (t=0.00s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *bbox*\n", + "DONE (t=0.03s).\n", + "Accumulating evaluation results...\n", + "DONE (t=0.02s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.709\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.854\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.799\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.474\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.795\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.776\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.776\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.776\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.733\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.833\n", + "08/15 04:34:18 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - bbox_mAP_copypaste: 0.709 0.854 0.799 0.000 0.474 0.795\n", + "08/15 04:34:18 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating segm...\n", + "Loading and preparing results...\n", + "DONE (t=0.00s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *segm*\n", + "DONE (t=0.03s).\n", + "Accumulating evaluation results...\n", + "DONE (t=0.01s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.762\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.834\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.834\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.453\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.860\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.822\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.822\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.822\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.758\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.889\n", + "08/15 04:34:18 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - segm_mAP_copypaste: 0.762 0.834 0.834 0.000 0.453 0.860\n", + "08/15 04:34:18 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [6][13/13] coco/bbox_mAP: 0.7090 coco/bbox_mAP_50: 0.8540 coco/bbox_mAP_75: 0.7990 coco/bbox_mAP_s: 0.0000 coco/bbox_mAP_m: 0.4740 coco/bbox_mAP_l: 0.7950 coco/segm_mAP: 0.7620 coco/segm_mAP_50: 0.8340 coco/segm_mAP_75: 0.8340 coco/segm_mAP_s: 0.0000 coco/segm_mAP_m: 0.4530 coco/segm_mAP_l: 0.8600 data_time: 0.0661 time: 0.3035\n", + "08/15 04:34:23 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [7][10/31] lr: 9.7848e-04 eta: 0:01:33 time: 0.5453 data_time: 0.0117 memory: 3283 loss: 0.3427 loss_rpn_cls: 0.0123 loss_rpn_bbox: 0.0119 loss_cls: 0.0819 acc: 98.7305 loss_bbox: 0.1376 loss_mask: 0.0989\n", + "08/15 04:34:29 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [7][20/31] lr: 1.0285e-03 eta: 0:01:28 time: 0.5473 data_time: 0.0103 memory: 3282 loss: 0.2958 loss_rpn_cls: 0.0098 loss_rpn_bbox: 0.0095 loss_cls: 0.0710 acc: 97.1680 loss_bbox: 0.1132 loss_mask: 0.0922\n", + "08/15 04:34:35 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [7][30/31] lr: 1.0786e-03 eta: 0:01:23 time: 0.5543 data_time: 0.0105 memory: 3448 loss: 0.2984 loss_rpn_cls: 0.0092 loss_rpn_bbox: 0.0104 loss_cls: 0.0723 acc: 91.1133 loss_bbox: 0.1114 loss_mask: 0.0952\n", + "08/15 04:34:35 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-3x_balloon_20230815_043154\n", + "08/15 04:34:41 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [8][10/31] lr: 1.1336e-03 eta: 0:01:17 time: 0.5499 data_time: 0.0125 memory: 3283 loss: 0.2648 loss_rpn_cls: 0.0083 loss_rpn_bbox: 0.0094 loss_cls: 0.0634 acc: 97.7539 loss_bbox: 0.0944 loss_mask: 0.0894\n", + "08/15 04:34:47 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [8][20/31] lr: 1.1837e-03 eta: 0:01:12 time: 0.5652 data_time: 0.0119 memory: 3283 loss: 0.2537 loss_rpn_cls: 0.0073 loss_rpn_bbox: 0.0086 loss_cls: 0.0605 acc: 99.2188 loss_bbox: 0.0873 loss_mask: 0.0900\n", + "08/15 04:34:52 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [8][30/31] lr: 1.2337e-03 eta: 0:01:07 time: 0.5620 data_time: 0.0117 memory: 3283 loss: 0.2575 loss_rpn_cls: 0.0073 loss_rpn_bbox: 0.0099 loss_cls: 0.0642 acc: 95.4102 loss_bbox: 0.0891 loss_mask: 0.0870\n", + "08/15 04:34:52 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-3x_balloon_20230815_043154\n", + "08/15 04:34:58 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [9][10/31] lr: 1.2888e-04 eta: 0:01:01 time: 0.5621 data_time: 0.0160 memory: 3283 loss: 0.2680 loss_rpn_cls: 0.0079 loss_rpn_bbox: 0.0108 loss_cls: 0.0709 acc: 95.8008 loss_bbox: 0.0934 loss_mask: 0.0851\n", + "08/15 04:35:04 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [9][20/31] lr: 1.3388e-04 eta: 0:00:56 time: 0.5631 data_time: 0.0150 memory: 3283 loss: 0.2295 loss_rpn_cls: 0.0063 loss_rpn_bbox: 0.0082 loss_cls: 0.0603 acc: 99.1211 loss_bbox: 0.0787 loss_mask: 0.0760\n", + "08/15 04:35:09 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [9][30/31] lr: 1.3889e-04 eta: 0:00:50 time: 0.5553 data_time: 0.0133 memory: 3091 loss: 0.2444 loss_rpn_cls: 0.0064 loss_rpn_bbox: 0.0094 loss_cls: 0.0650 acc: 96.5820 loss_bbox: 0.0847 loss_mask: 0.0789\n", + "08/15 04:35:09 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-3x_balloon_20230815_043154\n", + "08/15 04:35:09 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Saving checkpoint at 9 epochs\n", + "08/15 04:35:16 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [9][10/13] eta: 0:00:01 time: 0.5437 data_time: 0.0917 memory: 1693 \n", + "08/15 04:35:16 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating bbox...\n", + "Loading and preparing results...\n", + "DONE (t=0.00s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *bbox*\n", + "DONE (t=0.04s).\n", + "Accumulating evaluation results...\n", + "DONE (t=0.02s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.741\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.869\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.807\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.473\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.833\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.794\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.794\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.794\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.717\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.864\n", + "08/15 04:35:16 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - bbox_mAP_copypaste: 0.741 0.869 0.807 0.000 0.473 0.833\n", + "08/15 04:35:16 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating segm...\n", + "Loading and preparing results...\n", + "DONE (t=0.00s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *segm*\n", + "DONE (t=0.04s).\n", + "Accumulating evaluation results...\n", + "DONE (t=0.02s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.779\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.847\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.847\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.476\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.877\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.830\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.830\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.830\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.767\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.897\n", + "08/15 04:35:16 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - segm_mAP_copypaste: 0.779 0.847 0.847 0.000 0.476 0.877\n", + "08/15 04:35:16 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [9][13/13] coco/bbox_mAP: 0.7410 coco/bbox_mAP_50: 0.8690 coco/bbox_mAP_75: 0.8070 coco/bbox_mAP_s: 0.0000 coco/bbox_mAP_m: 0.4730 coco/bbox_mAP_l: 0.8330 coco/segm_mAP: 0.7790 coco/segm_mAP_50: 0.8470 coco/segm_mAP_75: 0.8470 coco/segm_mAP_s: 0.0000 coco/segm_mAP_m: 0.4760 coco/segm_mAP_l: 0.8770 data_time: 0.1157 time: 0.3601\n", + "08/15 04:35:22 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [10][10/31] lr: 1.4439e-04 eta: 0:00:44 time: 0.5374 data_time: 0.0169 memory: 3284 loss: 0.2415 loss_rpn_cls: 0.0063 loss_rpn_bbox: 0.0093 loss_cls: 0.0644 acc: 98.3398 loss_bbox: 0.0832 loss_mask: 0.0784\n", + "08/15 04:35:27 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [10][20/31] lr: 1.4940e-04 eta: 0:00:39 time: 0.5342 data_time: 0.0130 memory: 3283 loss: 0.2161 loss_rpn_cls: 0.0048 loss_rpn_bbox: 0.0080 loss_cls: 0.0573 acc: 99.4141 loss_bbox: 0.0721 loss_mask: 0.0738\n", + "08/15 04:35:33 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [10][30/31] lr: 1.5440e-04 eta: 0:00:33 time: 0.5374 data_time: 0.0129 memory: 3428 loss: 0.2210 loss_rpn_cls: 0.0054 loss_rpn_bbox: 0.0086 loss_cls: 0.0584 acc: 99.8047 loss_bbox: 0.0737 loss_mask: 0.0749\n", + "08/15 04:35:33 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-3x_balloon_20230815_043154\n", + "08/15 04:35:38 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [11][10/31] lr: 1.5991e-04 eta: 0:00:27 time: 0.5344 data_time: 0.0149 memory: 3067 loss: 0.2405 loss_rpn_cls: 0.0052 loss_rpn_bbox: 0.0099 loss_cls: 0.0639 acc: 98.8281 loss_bbox: 0.0807 loss_mask: 0.0808\n", + "08/15 04:35:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [11][20/31] lr: 1.6491e-04 eta: 0:00:22 time: 0.5326 data_time: 0.0105 memory: 3283 loss: 0.2297 loss_rpn_cls: 0.0047 loss_rpn_bbox: 0.0094 loss_cls: 0.0606 acc: 96.7773 loss_bbox: 0.0768 loss_mask: 0.0781\n", + "08/15 04:35:49 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [11][30/31] lr: 1.6992e-04 eta: 0:00:17 time: 0.5409 data_time: 0.0115 memory: 3283 loss: 0.2221 loss_rpn_cls: 0.0048 loss_rpn_bbox: 0.0092 loss_cls: 0.0595 acc: 95.3125 loss_bbox: 0.0753 loss_mask: 0.0733\n", + "08/15 04:35:50 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-3x_balloon_20230815_043154\n", + "08/15 04:35:55 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [12][10/31] lr: 1.7543e-05 eta: 0:00:11 time: 0.5311 data_time: 0.0129 memory: 3200 loss: 0.2094 loss_rpn_cls: 0.0054 loss_rpn_bbox: 0.0084 loss_cls: 0.0555 acc: 96.9727 loss_bbox: 0.0689 loss_mask: 0.0711\n", + "08/15 04:36:00 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [12][20/31] lr: 1.8043e-05 eta: 0:00:05 time: 0.5275 data_time: 0.0098 memory: 3448 loss: 0.2108 loss_rpn_cls: 0.0047 loss_rpn_bbox: 0.0089 loss_cls: 0.0560 acc: 99.5117 loss_bbox: 0.0698 loss_mask: 0.0713\n", + "08/15 04:36:06 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [12][30/31] lr: 1.8544e-05 eta: 0:00:00 time: 0.5425 data_time: 0.0111 memory: 3282 loss: 0.2048 loss_rpn_cls: 0.0043 loss_rpn_bbox: 0.0080 loss_cls: 0.0540 acc: 98.2422 loss_bbox: 0.0695 loss_mask: 0.0690\n", + "08/15 04:36:06 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-3x_balloon_20230815_043154\n", + "08/15 04:36:06 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Saving checkpoint at 12 epochs\n", + "08/15 04:36:12 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [12][10/13] eta: 0:00:01 time: 0.4801 data_time: 0.0931 memory: 1589 \n", + "08/15 04:36:12 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating bbox...\n", + "Loading and preparing results...\n", + "DONE (t=0.00s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *bbox*\n", + "DONE (t=0.02s).\n", + "Accumulating evaluation results...\n", + "DONE (t=0.01s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.740\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.868\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.804\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.506\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.828\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.798\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.798\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.798\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.742\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.861\n", + "08/15 04:36:12 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - bbox_mAP_copypaste: 0.740 0.868 0.804 0.000 0.506 0.828\n", + "08/15 04:36:12 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating segm...\n", + "Loading and preparing results...\n", + "DONE (t=0.00s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *segm*\n", + "DONE (t=0.02s).\n", + "Accumulating evaluation results...\n", + "DONE (t=0.01s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.776\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.845\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.845\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.481\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.868\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.832\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.832\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.832\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.775\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.897\n", + "08/15 04:36:12 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - segm_mAP_copypaste: 0.776 0.845 0.845 0.000 0.481 0.868\n", + "08/15 04:36:12 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [12][13/13] coco/bbox_mAP: 0.7400 coco/bbox_mAP_50: 0.8680 coco/bbox_mAP_75: 0.8040 coco/bbox_mAP_s: 0.0000 coco/bbox_mAP_m: 0.5060 coco/bbox_mAP_l: 0.8280 coco/segm_mAP: 0.7760 coco/segm_mAP_50: 0.8450 coco/segm_mAP_75: 0.8450 coco/segm_mAP_s: 0.0000 coco/segm_mAP_m: 0.4810 coco/segm_mAP_l: 0.8680 data_time: 0.0903 time: 0.2892\n" + ] + } + ], + "source": [ + "!python tools/train.py {config}" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_vYQF5K2NqqI" + }, + "source": [ + "### Understand the log\n", + "From the log, we can have a basic understanding on the training process and know how well the detector is trained.\n", + "\n", + "First, since the dataset we are using is small, we loaded a Mask R-CNN model and finetune it for detection. Because the original Mask R-CNN is trained on COCO dataset that contains 80 classes but KITTI Tiny dataset only have 3 classes. Therefore, the last FC layers of the pre-trained Mask R-CNN for classification and regression have different weight shape and are not used. The pre-trained weights of mask prediction layer `mask_head.conv_logits` also does not matches the current model and is not used due to similar reason.\n", + "\n", + "Third, after training, the detector is evaluated by the default COCO-style evaluation. The results show that the detector achieves 79.6 bbox AP and 81.5 mask AP on the val dataset, not bad!\n", + "\n", + " We can also check the tensorboard to see the curves." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "gbLNlJR-RYYd" + }, + "outputs": [], + "source": [ + "%pip install tensorboard -i https://mirrors.ustc.edu.cn/pypi/web/simple" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "id": "PW2NAam_7irv" + }, + "outputs": [], + "source": [ + "# load tensorboard in jupyter notebook\n", + "%load_ext tensorboard" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "4G9MCbL2RYYd" + }, + "outputs": [], + "source": [ + "# see curves in tensorboard\n", + "# if you see please run it again\n", + "%tensorboard --logdir tutorial_exps/" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MfQ-yspZLuuI" + }, + "source": [ + "## Test the Trained Detector\n", + "\n", + "After finetuning the detector, let's visualize the prediction results!" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "_MuZurfGLq0p", + "outputId": "4b25759c-8e22-405e-a061-3abc44e38043" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loads checkpoint by local backend from path: tutorial_exps/epoch_12.pth\n", + "\n", + " ignored_instances: \n", + " pred_instances: \n", + ") at 0x79a3a96e3130>\n" + ] + } + ], + "source": [ + "import mmcv\n", + "from mmdet.apis import init_detector, inference_detector\n", + "img = mmcv.imread('./ballondatasets/balloon/train/7178882742_f090f3ce56_k.jpg',channel_order='rgb')\n", + "checkpoint_file = 'tutorial_exps/epoch_12.pth'\n", + "model = init_detector(cfg, checkpoint_file, device='cpu')\n", + "new_result = inference_detector(model, img)\n", + "print(new_result)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 461 + }, + "id": "7SSTauCURYYe", + "outputId": "3becb5ea-cb4e-44f6-d93d-c10194a2263b" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
    " + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from mmengine.visualization import Visualizer\n", + "# get built visualizer\n", + "visualizer_now = Visualizer.get_current_instance()\n", + "# the dataset_meta is loaded from the checkpoint and\n", + "# then pass to the model in init_detector\n", + "visualizer_now.dataset_meta = model.dataset_meta\n", + "# show the results\n", + "visualizer_now.add_datasample(\n", + " 'new_result',\n", + " img,\n", + " data_sample=new_result,\n", + " draw_gt=False,\n", + " wait_time=0,\n", + " out_file=None,\n", + " pred_score_thr=0.5\n", + ")\n", + "visualizer_now.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6rzruCwFgPXm" + }, + "source": [ + "## What to Do Next?\n", + "\n", + "So far, we have learnt how to test and train Mask R-CNN. To further explore the segmentation task, you could do several other things as shown below:\n", + "\n", + "- Try cascade methods, e.g., [Cascade Mask R-CNN](https://github.com/open-mmlab/mmdetection/tree/master/configs/cascade_rcnn) and [HTC](https://github.com/open-mmlab/mmdetection/tree/master/configs/htc) in [MMDetection model zoo](https://github.com/open-mmlab/mmdetection/blob/master/docs/en/model_zoo.md). They are powerful detectors that are ranked high in many benchmarks, e.g., COCO dataset.\n", + "- Try single-stage methods, e.g., [K-Net](https://github.com/ZwwWayne/K-Net) and [Dense-RepPoints](https://github.com/justimyhxu/Dense-RepPoints). These two algorithms are based on MMDetection. Box-free instance segmentation is a new trend in the instance segmentation community.\n", + "- Try semantic segmentation. Semantic segmentation is also a popular task with wide applications. You can explore [MMSegmentation](https://github.com/open-mmlab/mmsegmentation/); we also provide a [colab tutorial](https://github.com/open-mmlab/mmsegmentation/blob/master/demo/MMSegmentation_Tutorial.ipynb) for semantic segmentation using MMSegmentation.\n" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.15" + }, + "vscode": { + "interpreter": { + "hash": "8868640c17582ff5a3e06365ba2fb344ce697cf42d4745ae8b85a9738303c037" + } + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/mmdetection/demo/MMDet_Tutorial.ipynb b/mmdetection/demo/MMDet_Tutorial.ipynb new file mode 100644 index 00000000..47785506 --- /dev/null +++ b/mmdetection/demo/MMDet_Tutorial.ipynb @@ -0,0 +1,3013 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "gCMycQ_2U8SA" + }, + "source": [ + "
    \n", + " \n", + "
     
    \n", + "
    \n", + " OpenMMLab website\n", + " \n", + " \n", + " HOT\n", + " \n", + " \n", + "     \n", + " OpenMMLab platform\n", + " \n", + " \n", + " TRY IT OUT\n", + " \n", + " \n", + "
    \n", + "
     
    \n", + "\n", + "\"Open\n", + "\n", + "[![PyPI](https://img.shields.io/pypi/v/mmdet)](https://pypi.org/project/mmdet)\n", + "[![docs](https://img.shields.io/badge/docs-latest-blue)](https://mmdetection.readthedocs.io/en/latest/)\n", + "[![badge](https://github.com/open-mmlab/mmdetection/workflows/build/badge.svg)](https://github.com/open-mmlab/mmdetection/actions)\n", + "[![codecov](https://codecov.io/gh/open-mmlab/mmdetection/branch/master/graph/badge.svg)](https://codecov.io/gh/open-mmlab/mmdetection)\n", + "[![license](https://img.shields.io/github/license/open-mmlab/mmdetection.svg)](https://github.com/open-mmlab/mmdetection/blob/master/LICENSE)\n", + "[![open issues](https://isitmaintained.com/badge/open/open-mmlab/mmdetection.svg)](https://github.com/open-mmlab/mmdetection/issues)\n", + "[![issue resolution](https://isitmaintained.com/badge/resolution/open-mmlab/mmdetection.svg)](https://github.com/open-mmlab/mmdetection/issues)\n", + "\n", + "[📘Documentation](https://mmdetection.readthedocs.io/en/3.x/) |\n", + "[🛠️Installation](https://mmdetection.readthedocs.io/en/3.x/get_started.html) |\n", + "[👀Model Zoo](https://mmdetection.readthedocs.io/en/3.x/model_zoo.html) |\n", + "[🆕Update News](https://mmdetection.readthedocs.io/en/3.x/notes/changelog.html) |\n", + "[🚀Ongoing Projects](https://github.com/open-mmlab/mmdetection/projects) |\n", + "[🤔Reporting Issues](https://github.com/open-mmlab/mmdetection/issues/new/choose)\n", + "\n", + "
    \n", + "\n", + "
    \n", + " \n", + " \"\"\n", + " \"\"\n", + " \n", + " \"\"\n", + " \"\"\n", + " \n", + " \"\"\n", + " \"\"\n", + " \n", + " \"\"\n", + " \"\"\n", + " \n", + " \"\"\n", + " \"\"\n", + " \n", + " \"\"\n", + "
    " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aGYwt_UjIrqp" + }, + "source": [ + "# Object Detection\n", + "\n", + "In this tutorial, you will learn:\n", + "- the basic structure of RTMDet.\n", + "- to perform inference with a MMDetection detector.\n", + "- to train a new detector with a new dataset.\n", + "\n", + "Let's start!\n", + "\n", + "```{note}\n", + "The commands in this tutorial are mainly for Colab.\n", + "You can click the button above, `Open in Colab`, to run this notebook in Colab.\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tJxJHruNLb7Y" + }, + "source": [ + "## Install MMDetection" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Wi4LPmsR66sy", + "outputId": "13704ca1-3e1f-4bfc-8638-86458b1effb1" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "nvcc: NVIDIA (R) Cuda compiler driver\n", + "Copyright (c) 2005-2022 NVIDIA Corporation\n", + "Built on Wed_Sep_21_10:33:58_PDT_2022\n", + "Cuda compilation tools, release 11.8, V11.8.89\n", + "Build cuda_11.8.r11.8/compiler.31833905_0\n", + "gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0\n", + "Copyright (C) 2019 Free Software Foundation, Inc.\n", + "This is free software; see the source for copying conditions. There is NO\n", + "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n", + "\n" + ] + } + ], + "source": [ + "# Check nvcc version\n", + "!nvcc -V\n", + "# Check GCC version\n", + "!gcc --version" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "gkGnB9WyHSXB", + "outputId": "781c6870-be3d-4162-cae1-017ebf0c6043" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting openmim\n", + " Downloading openmim-0.3.7-py2.py3-none-any.whl (51 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m51.3/51.3 kB\u001b[0m \u001b[31m536.0 kB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: requests in /usr/local/lib/python3.9/dist-packages (from openmim) (2.27.1)\n", + "Collecting model-index\n", + " Downloading model_index-0.1.11-py3-none-any.whl (34 kB)\n", + "Requirement already satisfied: rich in /usr/local/lib/python3.9/dist-packages (from openmim) (13.3.3)\n", + "Requirement already satisfied: tabulate in /usr/local/lib/python3.9/dist-packages (from openmim) (0.8.10)\n", + "Requirement already satisfied: pandas in /usr/local/lib/python3.9/dist-packages (from openmim) (1.5.3)\n", + "Requirement already satisfied: Click in /usr/local/lib/python3.9/dist-packages (from openmim) (8.1.3)\n", + "Collecting colorama\n", + " Downloading colorama-0.4.6-py2.py3-none-any.whl (25 kB)\n", + "Requirement already satisfied: pip>=19.3 in /usr/local/lib/python3.9/dist-packages (from openmim) (23.0.1)\n", + "Collecting ordered-set\n", + " Downloading ordered_set-4.1.0-py3-none-any.whl (7.6 kB)\n", + "Requirement already satisfied: markdown in /usr/local/lib/python3.9/dist-packages (from model-index->openmim) (3.4.3)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.9/dist-packages (from model-index->openmim) (6.0)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.9/dist-packages (from pandas->openmim) (2022.7.1)\n", + "Requirement already satisfied: numpy>=1.20.3 in /usr/local/lib/python3.9/dist-packages (from pandas->openmim) (1.22.4)\n", + "Requirement already satisfied: python-dateutil>=2.8.1 in /usr/local/lib/python3.9/dist-packages (from pandas->openmim) (2.8.2)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/dist-packages (from requests->openmim) (2022.12.7)\n", + "Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.9/dist-packages (from requests->openmim) (2.0.12)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.9/dist-packages (from requests->openmim) (1.26.15)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/dist-packages (from requests->openmim) (3.4)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.9/dist-packages (from rich->openmim) (2.14.0)\n", + "Requirement already satisfied: markdown-it-py<3.0.0,>=2.2.0 in /usr/local/lib/python3.9/dist-packages (from rich->openmim) (2.2.0)\n", + "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.9/dist-packages (from markdown-it-py<3.0.0,>=2.2.0->rich->openmim) (0.1.2)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.9/dist-packages (from python-dateutil>=2.8.1->pandas->openmim) (1.16.0)\n", + "Requirement already satisfied: importlib-metadata>=4.4 in /usr/local/lib/python3.9/dist-packages (from markdown->model-index->openmim) (6.3.0)\n", + "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.9/dist-packages (from importlib-metadata>=4.4->markdown->model-index->openmim) (3.15.0)\n", + "Installing collected packages: ordered-set, colorama, model-index, openmim\n", + "Successfully installed colorama-0.4.6 model-index-0.1.11 openmim-0.3.7 ordered-set-4.1.0\n", + "/usr/local/lib/python3.9/dist-packages/setuptools/command/install.py:34: SetuptoolsDeprecationWarning: setup.py install is deprecated. Use build and pip and other standards-based tools.\n", + " warnings.warn(\n", + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Looking in links: https://download.openmmlab.com/mmcv/dist/cu118/torch2.0.0/index.html\n", + "Collecting mmengine>=0.7.0\n", + " Downloading mmengine-0.7.2-py3-none-any.whl (366 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m366.9/366.9 kB\u001b[0m \u001b[31m26.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: pyyaml in /usr/local/lib/python3.9/dist-packages (from mmengine>=0.7.0) (6.0)\n", + "Requirement already satisfied: rich in /usr/local/lib/python3.9/dist-packages (from mmengine>=0.7.0) (13.3.3)\n", + "Requirement already satisfied: opencv-python>=3 in /usr/local/lib/python3.9/dist-packages (from mmengine>=0.7.0) (4.7.0.72)\n", + "Collecting addict\n", + " Downloading addict-2.4.0-py3-none-any.whl (3.8 kB)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.9/dist-packages (from mmengine>=0.7.0) (3.7.1)\n", + "Collecting yapf\n", + " Downloading yapf-0.32.0-py2.py3-none-any.whl (190 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m190.2/190.2 kB\u001b[0m \u001b[31m25.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: numpy in /usr/local/lib/python3.9/dist-packages (from mmengine>=0.7.0) (1.22.4)\n", + "Requirement already satisfied: termcolor in /usr/local/lib/python3.9/dist-packages (from mmengine>=0.7.0) (2.2.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmengine>=0.7.0) (3.0.9)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmengine>=0.7.0) (4.39.3)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmengine>=0.7.0) (1.0.7)\n", + "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmengine>=0.7.0) (8.4.0)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmengine>=0.7.0) (0.11.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmengine>=0.7.0) (1.4.4)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmengine>=0.7.0) (23.0)\n", + "Requirement already satisfied: importlib-resources>=3.2.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmengine>=0.7.0) (5.12.0)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmengine>=0.7.0) (2.8.2)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.9/dist-packages (from rich->mmengine>=0.7.0) (2.14.0)\n", + "Requirement already satisfied: markdown-it-py<3.0.0,>=2.2.0 in /usr/local/lib/python3.9/dist-packages (from rich->mmengine>=0.7.0) (2.2.0)\n", + "Requirement already satisfied: zipp>=3.1.0 in /usr/local/lib/python3.9/dist-packages (from importlib-resources>=3.2.0->matplotlib->mmengine>=0.7.0) (3.15.0)\n", + "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.9/dist-packages (from markdown-it-py<3.0.0,>=2.2.0->rich->mmengine>=0.7.0) (0.1.2)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.9/dist-packages (from python-dateutil>=2.7->matplotlib->mmengine>=0.7.0) (1.16.0)\n", + "Installing collected packages: yapf, addict, mmengine\n", + "/usr/local/lib/python3.9/dist-packages/setuptools/command/install.py:34: SetuptoolsDeprecationWarning: setup.py install is deprecated. Use build and pip and other standards-based tools.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.9/dist-packages/setuptools/command/install.py:34: SetuptoolsDeprecationWarning: setup.py install is deprecated. Use build and pip and other standards-based tools.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.9/dist-packages/setuptools/command/install.py:34: SetuptoolsDeprecationWarning: setup.py install is deprecated. Use build and pip and other standards-based tools.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.9/dist-packages/setuptools/command/install.py:34: SetuptoolsDeprecationWarning: setup.py install is deprecated. Use build and pip and other standards-based tools.\n", + " warnings.warn(\n", + "Successfully installed addict-2.4.0 mmengine-0.7.2 yapf-0.32.0\n", + "/usr/local/lib/python3.9/dist-packages/setuptools/command/install.py:34: SetuptoolsDeprecationWarning: setup.py install is deprecated. Use build and pip and other standards-based tools.\n", + " warnings.warn(\n", + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Looking in links: https://download.openmmlab.com/mmcv/dist/cu118/torch2.0.0/index.html\n", + "Collecting mmcv>=2.0.0rc4\n", + " Downloading https://download.openmmlab.com/mmcv/dist/cu118/torch2.0.0/mmcv-2.0.0-cp39-cp39-manylinux1_x86_64.whl (74.4 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m74.4/74.4 MB\u001b[0m \u001b[31m12.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: mmengine>=0.2.0 in /usr/local/lib/python3.9/dist-packages (from mmcv>=2.0.0rc4) (0.7.2)\n", + "Requirement already satisfied: Pillow in /usr/local/lib/python3.9/dist-packages (from mmcv>=2.0.0rc4) (8.4.0)\n", + "Requirement already satisfied: addict in /usr/local/lib/python3.9/dist-packages (from mmcv>=2.0.0rc4) (2.4.0)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.9/dist-packages (from mmcv>=2.0.0rc4) (6.0)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.9/dist-packages (from mmcv>=2.0.0rc4) (1.22.4)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.9/dist-packages (from mmcv>=2.0.0rc4) (23.0)\n", + "Requirement already satisfied: yapf in /usr/local/lib/python3.9/dist-packages (from mmcv>=2.0.0rc4) (0.32.0)\n", + "Requirement already satisfied: opencv-python>=3 in /usr/local/lib/python3.9/dist-packages (from mmcv>=2.0.0rc4) (4.7.0.72)\n", + "Requirement already satisfied: termcolor in /usr/local/lib/python3.9/dist-packages (from mmengine>=0.2.0->mmcv>=2.0.0rc4) (2.2.0)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.9/dist-packages (from mmengine>=0.2.0->mmcv>=2.0.0rc4) (3.7.1)\n", + "Requirement already satisfied: rich in /usr/local/lib/python3.9/dist-packages (from mmengine>=0.2.0->mmcv>=2.0.0rc4) (13.3.3)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmengine>=0.2.0->mmcv>=2.0.0rc4) (3.0.9)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmengine>=0.2.0->mmcv>=2.0.0rc4) (1.0.7)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmengine>=0.2.0->mmcv>=2.0.0rc4) (4.39.3)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmengine>=0.2.0->mmcv>=2.0.0rc4) (0.11.0)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmengine>=0.2.0->mmcv>=2.0.0rc4) (2.8.2)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmengine>=0.2.0->mmcv>=2.0.0rc4) (1.4.4)\n", + "Requirement already satisfied: importlib-resources>=3.2.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmengine>=0.2.0->mmcv>=2.0.0rc4) (5.12.0)\n", + "Requirement already satisfied: markdown-it-py<3.0.0,>=2.2.0 in /usr/local/lib/python3.9/dist-packages (from rich->mmengine>=0.2.0->mmcv>=2.0.0rc4) (2.2.0)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.9/dist-packages (from rich->mmengine>=0.2.0->mmcv>=2.0.0rc4) (2.14.0)\n", + "Requirement already satisfied: zipp>=3.1.0 in /usr/local/lib/python3.9/dist-packages (from importlib-resources>=3.2.0->matplotlib->mmengine>=0.2.0->mmcv>=2.0.0rc4) (3.15.0)\n", + "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.9/dist-packages (from markdown-it-py<3.0.0,>=2.2.0->rich->mmengine>=0.2.0->mmcv>=2.0.0rc4) (0.1.2)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.9/dist-packages (from python-dateutil>=2.7->matplotlib->mmengine>=0.2.0->mmcv>=2.0.0rc4) (1.16.0)\n", + "Installing collected packages: mmcv\n", + "/usr/local/lib/python3.9/dist-packages/setuptools/command/install.py:34: SetuptoolsDeprecationWarning: setup.py install is deprecated. Use build and pip and other standards-based tools.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.9/dist-packages/setuptools/command/install.py:34: SetuptoolsDeprecationWarning: setup.py install is deprecated. Use build and pip and other standards-based tools.\n", + " warnings.warn(\n", + "Successfully installed mmcv-2.0.0\n", + "Cloning into 'mmdetection'...\n", + "remote: Enumerating objects: 35338, done.\u001b[K\n", + "remote: Counting objects: 100% (31/31), done.\u001b[K\n", + "remote: Compressing objects: 100% (31/31), done.\u001b[K\n", + "remote: Total 35338 (delta 2), reused 8 (delta 0), pack-reused 35307\u001b[K\n", + "Receiving objects: 100% (35338/35338), 47.30 MiB | 16.88 MiB/s, done.\n", + "Resolving deltas: 100% (24919/24919), done.\n", + "/content/mmdetection\n", + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Obtaining file:///content/mmdetection\n", + " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.9/dist-packages (from mmdet==3.0.0) (3.7.1)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.9/dist-packages (from mmdet==3.0.0) (1.22.4)\n", + "Requirement already satisfied: pycocotools in /usr/local/lib/python3.9/dist-packages (from mmdet==3.0.0) (2.0.6)\n", + "Requirement already satisfied: scipy in /usr/local/lib/python3.9/dist-packages (from mmdet==3.0.0) (1.10.1)\n", + "Requirement already satisfied: shapely in /usr/local/lib/python3.9/dist-packages (from mmdet==3.0.0) (2.0.1)\n", + "Requirement already satisfied: six in /usr/local/lib/python3.9/dist-packages (from mmdet==3.0.0) (1.16.0)\n", + "Collecting terminaltables\n", + " Downloading terminaltables-3.1.10-py2.py3-none-any.whl (15 kB)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmdet==3.0.0) (1.4.4)\n", + "Requirement already satisfied: importlib-resources>=3.2.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmdet==3.0.0) (5.12.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmdet==3.0.0) (3.0.9)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmdet==3.0.0) (1.0.7)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmdet==3.0.0) (0.11.0)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmdet==3.0.0) (2.8.2)\n", + "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmdet==3.0.0) (8.4.0)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmdet==3.0.0) (23.0)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib->mmdet==3.0.0) (4.39.3)\n", + "Requirement already satisfied: zipp>=3.1.0 in /usr/local/lib/python3.9/dist-packages (from importlib-resources>=3.2.0->matplotlib->mmdet==3.0.0) (3.15.0)\n", + "Installing collected packages: terminaltables, mmdet\n", + " Running setup.py develop for mmdet\n", + "Successfully installed mmdet-3.0.0 terminaltables-3.1.10\n" + ] + } + ], + "source": [ + "# install dependencies: (use cu111 because colab has CUDA 11.1)\n", + "%pip install -U openmim\n", + "!mim install \"mmengine>=0.7.0\"\n", + "!mim install \"mmcv>=2.0.0rc4\"\n", + "\n", + "# Install mmdetection\n", + "!rm -rf mmdetection\n", + "!git clone https://github.com/open-mmlab/mmdetection.git\n", + "%cd mmdetection\n", + "\n", + "%pip install -e ." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "_YeUiqAoCaoV", + "outputId": "98b02135-08f8-4142-9b59-80056f29192d" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "sys.platform: linux\n", + "Python: 3.9.16 (main, Dec 7 2022, 01:11:51) [GCC 9.4.0]\n", + "CUDA available: True\n", + "numpy_random_seed: 2147483648\n", + "GPU 0: Tesla T4\n", + "CUDA_HOME: /usr/local/cuda\n", + "NVCC: Cuda compilation tools, release 11.8, V11.8.89\n", + "GCC: x86_64-linux-gnu-gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0\n", + "PyTorch: 2.0.0+cu118\n", + "PyTorch compiling details: PyTorch built with:\n", + " - GCC 9.3\n", + " - C++ Version: 201703\n", + " - Intel(R) oneAPI Math Kernel Library Version 2022.2-Product Build 20220804 for Intel(R) 64 architecture applications\n", + " - Intel(R) MKL-DNN v2.7.3 (Git Hash 6dbeffbae1f23cbbeae17adb7b5b13f1f37c080e)\n", + " - OpenMP 201511 (a.k.a. OpenMP 4.5)\n", + " - LAPACK is enabled (usually provided by MKL)\n", + " - NNPACK is enabled\n", + " - CPU capability usage: AVX2\n", + " - CUDA Runtime 11.8\n", + " - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90\n", + " - CuDNN 8.7\n", + " - Magma 2.6.1\n", + " - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, CUDA_VERSION=11.8, CUDNN_VERSION=8.7.0, CXX_COMPILER=/opt/rh/devtoolset-9/root/usr/bin/c++, CXX_FLAGS= -D_GLIBCXX_USE_CXX11_ABI=0 -fabi-version=11 -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wunused-local-typedefs -Wno-unused-parameter -Wno-unused-function -Wno-unused-result -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Werror=cast-function-type -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, TORCH_DISABLE_GPU_ASSERTS=ON, TORCH_VERSION=2.0.0, USE_CUDA=ON, USE_CUDNN=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, \n", + "\n", + "TorchVision: 0.15.1+cu118\n", + "OpenCV: 4.7.0\n", + "MMEngine: 0.7.2\n", + "MMDetection: 3.0.0+ecac3a7\n" + ] + } + ], + "source": [ + "from mmengine.utils import get_git_hash\n", + "from mmengine.utils.dl_utils import collect_env as collect_base_env\n", + "\n", + "import mmdet\n", + "\n", + "\n", + "def collect_env():\n", + " \"\"\"Collect the information of the running environments.\"\"\"\n", + " env_info = collect_base_env()\n", + " env_info['MMDetection'] = f'{mmdet.__version__}+{get_git_hash()[:7]}'\n", + " return env_info\n", + "\n", + "\n", + "if __name__ == '__main__':\n", + " for name, val in collect_env().items():\n", + " print(f'{name}: {val}')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gi9zw03oM4CH" + }, + "source": [ + "## Perform Inference with An MMDet detector\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "s99mDGBG1S1z" + }, + "source": [ + "### An efficient Real-Time one-stage detector\n", + "\n", + "In this tutorial, we use RTMDet, an efficient Real-Time one-stage detector as an example.\n", + "\n", + "The high-level architecture of RTMDet is shown in the following picture. More details can be found in the [paper](https://arxiv.org/abs/2212.07784).\n", + "\n", + "![RTMDet](https://user-images.githubusercontent.com/27466624/225922103-404064c1-3cb0-4ab5-9388-79f9517dcdb0.jpg)\n", + "\n", + "To obtain a more efficient model architecture, MMDetection explore an architecture that has compatible capacities in the backbone and neck, constructed by a basic building block that consists of large-kernel depth-wise convolutions. MMDetection further introduce soft labels when calculating matching costs in the dynamic label assignment to improve accuracy. Together with better training techniques, the resulting object detector, named RTMDet, achieves 52.8% AP on COCO with 300+ FPS on an NVIDIA 3090 GPU, outperforming the current mainstream industrial detectors. RTMDet achieves the best parameter-accuracy trade-off with tiny/small/medium/large/extra-large model sizes for various application scenarios, and obtains new state-of-the-art performance on real-time instance segmentation and rotated object detection. We hope the experimental results can provide new insights into designing versatile real-time object detectors for many object recognition tasks.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "j4doHX4exvS1", + "outputId": "9eb9d460-7e3f-4bbc-f9e6-5823773375d3" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "processing rtmdet_tiny_8xb32-300e_coco...\n", + "\u001b[2Kdownloading \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m54.9/54.9 MiB\u001b[0m \u001b[31m54.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h\u001b[32mSuccessfully downloaded rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth to /content/mmdetection/checkpoints\u001b[0m\n", + "\u001b[32mSuccessfully dumped rtmdet_tiny_8xb32-300e_coco.py to /content/mmdetection/checkpoints\u001b[0m\n" + ] + } + ], + "source": [ + "# We download the pre-trained checkpoints for inference and finetuning.\n", + "!mkdir ./checkpoints\n", + "!mim download mmdet --config rtmdet_tiny_8xb32-300e_coco --dest ./checkpoints" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fLgFRMtP91ue" + }, + "source": [ + "### Inference the detector\n", + "\n", + "Since the model is successfully created and loaded, let's see how good it is. We use the high-level API `DetInferencer` implemented in the MMDetection. This API is created to ease the inference process. The details of the codes can be found [here](https://github.com/open-mmlab/mmdetection/blob/dev-3.x/mmdet/apis/det_inferencer.py)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 244, + "referenced_widgets": [ + "b1188048a1f04c2fa77c0d3829da39bd", + "534561e3c4804bae96a30d44493d701d" + ] + }, + "id": "Wi6DRpsQPEmV", + "outputId": "0b0a14bc-fd10-4ec4-a585-e1ddefc33973" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Loads checkpoint by local backend from path: ./checkpoints/rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth\n", + "The model and loaded state dict do not match exactly\n", + "\n", + "unexpected key in source state_dict: data_preprocessor.mean, data_preprocessor.std\n", + "\n", + "04/17 10:28:19 - mmengine - WARNING - Failed to search registry with scope \"mmdet\" in the \"function\" registry tree. As a workaround, the current \"function\" registry in \"mmengine\" is used to build instance. This may cause unexpected failure when running the built modules. Please check whether \"mmdet\" is a correct scope, or whether the registry is initialized.\n", + "04/17 10:28:19 - mmengine - WARNING - `Visualizer` backend is not initialized because save_dir is None.\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Output()" + ], + "application/vnd.jupyter.widget-view+json": { + "version_major": 2, + "version_minor": 0, + "model_id": "b1188048a1f04c2fa77c0d3829da39bd" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "/usr/local/lib/python3.9/dist-packages/torch/functional.py:504: UserWarning: torch.meshgrid: in an upcoming \n", + "release, it will be required to pass the indexing argument. (Triggered internally at \n", + "../aten/src/ATen/native/TensorShape.cpp:3483.)\n", + " return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]\n" + ], + "text/html": [ + "
    /usr/local/lib/python3.9/dist-packages/torch/functional.py:504: UserWarning: torch.meshgrid: in an upcoming \n",
+              "release, it will be required to pass the indexing argument. (Triggered internally at \n",
+              "../aten/src/ATen/native/TensorShape.cpp:3483.)\n",
+              "  return _VF.meshgrid(tensors, **kwargs)  # type: ignore[attr-defined]\n",
+              "
    \n" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [], + "text/html": [ + "
    \n"
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "\n"
+            ],
+            "text/html": [
+              "
    \n",
+              "
    \n"
+            ]
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "from mmdet.apis import DetInferencer\n",
+        "\n",
+        "# Choose to use a config\n",
+        "model_name = 'rtmdet_tiny_8xb32-300e_coco'\n",
+        "# Setup a checkpoint file to load\n",
+        "checkpoint = './checkpoints/rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth'\n",
+        "\n",
+        "# Set the device to be used for evaluation\n",
+        "device = 'cuda:0'\n",
+        "\n",
+        "# Initialize the DetInferencer\n",
+        "inferencer = DetInferencer(model_name, checkpoint, device)\n",
+        "\n",
+        "# Use the detector to do inference\n",
+        "img = './demo/demo.jpg'\n",
+        "result = inferencer(img, out_dir='./output')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "m6a8T4goU8Sq",
+        "outputId": "68005045-d741-4f53-b59b-16881337bebf"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "\u001b[1m{\u001b[0m\n",
+              "\u001b[2;32m│   \u001b[0m\u001b[32m'predictions'\u001b[0m: \u001b[1m[\u001b[0m\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m{\u001b[0m\n",
+              "\u001b[2;32m│   │   │   \u001b[0m\u001b[32m'bboxes'\u001b[0m: \u001b[1m[\u001b[0m\n",
+              "\u001b[2;32m│   │   │   │   \u001b[0m\u001b[1m[\u001b[0m\u001b[1;36m221.37188720703125\u001b[0m, \u001b[1;36m176.12808227539062\u001b[0m, \u001b[1;36m456.25811767578125\u001b[0m, \u001b[1;36m383.2401428222656\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   │   │   \u001b[0m\u001b[1m[\u001b[0m\u001b[1;36m295.3505859375\u001b[0m, \u001b[1;36m117.18350219726562\u001b[0m, \u001b[1;36m378.571533203125\u001b[0m, \u001b[1;36m150.27117919921875\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   │   │   \u001b[0m\u001b[1m[\u001b[0m\u001b[1;36m190.57350158691406\u001b[0m, \u001b[1;36m109.70985412597656\u001b[0m, \u001b[1;36m299.52215576171875\u001b[0m, \u001b[1;36m155.0396270751953\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   │   │   \u001b[0m\u001b[1m[\u001b[0m\u001b[1;36m431.36944580078125\u001b[0m, \u001b[1;36m104.98468780517578\u001b[0m, \u001b[1;36m484.879150390625\u001b[0m, \u001b[1;36m131.94033813476562\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   │   │   \u001b[0m\u001b[33m...\u001b[0m +\u001b[1;36m296\u001b[0m\n",
+              "\u001b[2;32m│   │   │   \u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   │   \u001b[0m\u001b[32m'labels'\u001b[0m: \u001b[1m[\u001b[0m\u001b[1;36m13\u001b[0m, \u001b[1;36m2\u001b[0m, \u001b[1;36m2\u001b[0m, \u001b[1;36m2\u001b[0m, \u001b[33m...\u001b[0m +\u001b[1;36m296\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   │   \u001b[0m\u001b[32m'scores'\u001b[0m: \u001b[1m[\u001b[0m\u001b[1;36m0.8703235387802124\u001b[0m, \u001b[1;36m0.7677358984947205\u001b[0m, \u001b[1;36m0.7427828311920166\u001b[0m, \u001b[1;36m0.6994596123695374\u001b[0m, \u001b[33m...\u001b[0m +\u001b[1;36m296\u001b[0m\u001b[1m]\u001b[0m\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m}\u001b[0m\n",
+              "\u001b[2;32m│   \u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   \u001b[0m\u001b[32m'visualization'\u001b[0m: \u001b[1m[\u001b[0m\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1;35marray\u001b[0m\u001b[1m(\u001b[0m\u001b[1m[\u001b[0m\u001b[1m[\u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m28\u001b[0m,  \u001b[1;36m48\u001b[0m,  \u001b[1;36m13\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m37\u001b[0m,  \u001b[1;36m63\u001b[0m,  \u001b[1;36m28\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m30\u001b[0m,  \u001b[1;36m64\u001b[0m,  \u001b[1;36m27\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[33m...\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m23\u001b[0m,  \u001b[1;36m47\u001b[0m,  \u001b[1;36m31\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m31\u001b[0m,  \u001b[1;36m67\u001b[0m,  \u001b[1;36m31\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m54\u001b[0m,  \u001b[1;36m92\u001b[0m,  \u001b[1;36m17\u001b[0m\u001b[1m]\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│      \u001b[0m\n",
+              "\u001b[2;32m│      \u001b[0m\u001b[1m[\u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m23\u001b[0m,  \u001b[1;36m42\u001b[0m,   \u001b[1;36m0\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m25\u001b[0m,  \u001b[1;36m50\u001b[0m,   \u001b[1;36m8\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m30\u001b[0m,  \u001b[1;36m62\u001b[0m,  \u001b[1;36m21\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[33m...\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m92\u001b[0m, \u001b[1;36m114\u001b[0m, \u001b[1;36m102\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m16\u001b[0m,  \u001b[1;36m53\u001b[0m,  \u001b[1;36m12\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m44\u001b[0m,  \u001b[1;36m75\u001b[0m,  \u001b[1;36m16\u001b[0m\u001b[1m]\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│      \u001b[0m\n",
+              "\u001b[2;32m│      \u001b[0m\u001b[1m[\u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m20\u001b[0m,  \u001b[1;36m50\u001b[0m,   \u001b[1;36m0\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m25\u001b[0m,  \u001b[1;36m59\u001b[0m,   \u001b[1;36m8\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m29\u001b[0m,  \u001b[1;36m66\u001b[0m,  \u001b[1;36m23\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[33m...\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m47\u001b[0m,  \u001b[1;36m70\u001b[0m,  \u001b[1;36m44\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m29\u001b[0m,  \u001b[1;36m60\u001b[0m,  \u001b[1;36m18\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m54\u001b[0m,  \u001b[1;36m77\u001b[0m,  \u001b[1;36m31\u001b[0m\u001b[1m]\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│      \u001b[0m\n",
+              "\u001b[2;32m│      \u001b[0m\u001b[33m...\u001b[0m,\n",
+              "\u001b[2;32m│      \u001b[0m\n",
+              "\u001b[2;32m│      \u001b[0m\u001b[1m[\u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m63\u001b[0m,  \u001b[1;36m68\u001b[0m,  \u001b[1;36m45\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m58\u001b[0m,  \u001b[1;36m66\u001b[0m,  \u001b[1;36m27\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m74\u001b[0m,  \u001b[1;36m84\u001b[0m,  \u001b[1;36m49\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[33m...\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m32\u001b[0m,  \u001b[1;36m46\u001b[0m,  \u001b[1;36m23\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m56\u001b[0m,  \u001b[1;36m76\u001b[0m,  \u001b[1;36m39\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m31\u001b[0m,  \u001b[1;36m47\u001b[0m,  \u001b[1;36m18\u001b[0m\u001b[1m]\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│      \u001b[0m\n",
+              "\u001b[2;32m│      \u001b[0m\u001b[1m[\u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m60\u001b[0m,  \u001b[1;36m66\u001b[0m,  \u001b[1;36m40\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m45\u001b[0m,  \u001b[1;36m55\u001b[0m,  \u001b[1;36m18\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m83\u001b[0m,  \u001b[1;36m92\u001b[0m,  \u001b[1;36m61\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[33m...\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m63\u001b[0m,  \u001b[1;36m77\u001b[0m,  \u001b[1;36m54\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m47\u001b[0m,  \u001b[1;36m67\u001b[0m,  \u001b[1;36m30\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m35\u001b[0m,  \u001b[1;36m52\u001b[0m,  \u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│      \u001b[0m\n",
+              "\u001b[2;32m│      \u001b[0m\u001b[1m[\u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m64\u001b[0m,  \u001b[1;36m70\u001b[0m,  \u001b[1;36m42\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m85\u001b[0m,  \u001b[1;36m95\u001b[0m,  \u001b[1;36m60\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m66\u001b[0m,  \u001b[1;36m75\u001b[0m,  \u001b[1;36m48\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[33m...\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m37\u001b[0m,  \u001b[1;36m51\u001b[0m,  \u001b[1;36m28\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m59\u001b[0m,  \u001b[1;36m79\u001b[0m,  \u001b[1;36m42\u001b[0m\u001b[1m]\u001b[0m,\n",
+              "\u001b[2;32m│   │   \u001b[0m\u001b[1m[\u001b[0m \u001b[1;36m44\u001b[0m,  \u001b[1;36m61\u001b[0m,  \u001b[1;36m29\u001b[0m\u001b[1m]\u001b[0m\u001b[1m]\u001b[0m\u001b[1m]\u001b[0m, \u001b[33mdtype\u001b[0m=\u001b[35muint8\u001b[0m\u001b[1m)\u001b[0m\n",
+              "\u001b[2;32m│   \u001b[0m\u001b[1m]\u001b[0m\n",
+              "\u001b[1m}\u001b[0m\n"
+            ],
+            "text/html": [
+              "
    {\n",
+              "│   'predictions': [\n",
+              "│   │   {\n",
+              "│   │   │   'bboxes': [\n",
+              "│   │   │   │   [221.37188720703125, 176.12808227539062, 456.25811767578125, 383.2401428222656],\n",
+              "│   │   │   │   [295.3505859375, 117.18350219726562, 378.571533203125, 150.27117919921875],\n",
+              "│   │   │   │   [190.57350158691406, 109.70985412597656, 299.52215576171875, 155.0396270751953],\n",
+              "│   │   │   │   [431.36944580078125, 104.98468780517578, 484.879150390625, 131.94033813476562],\n",
+              "│   │   │   │   ... +296\n",
+              "│   │   │   ],\n",
+              "│   │   │   'labels': [13, 2, 2, 2, ... +296],\n",
+              "│   │   │   'scores': [0.8703235387802124, 0.7677358984947205, 0.7427828311920166, 0.6994596123695374, ... +296]\n",
+              "│   │   }\n",
+              "│   ],\n",
+              "│   'visualization': [\n",
+              "│   │   array([[[ 28,  48,  13],\n",
+              "│   │   [ 37,  63,  28],\n",
+              "│   │   [ 30,  64,  27],\n",
+              "│   │   ...,\n",
+              "│   │   [ 23,  47,  31],\n",
+              "│   │   [ 31,  67,  31],\n",
+              "│   │   [ 54,  92,  17]],\n",
+              "│      \n",
+              "│      [[ 23,  42,   0],\n",
+              "│   │   [ 25,  50,   8],\n",
+              "│   │   [ 30,  62,  21],\n",
+              "│   │   ...,\n",
+              "│   │   [ 92, 114, 102],\n",
+              "│   │   [ 16,  53,  12],\n",
+              "│   │   [ 44,  75,  16]],\n",
+              "│      \n",
+              "│      [[ 20,  50,   0],\n",
+              "│   │   [ 25,  59,   8],\n",
+              "│   │   [ 29,  66,  23],\n",
+              "│   │   ...,\n",
+              "│   │   [ 47,  70,  44],\n",
+              "│   │   [ 29,  60,  18],\n",
+              "│   │   [ 54,  77,  31]],\n",
+              "│      \n",
+              "│      ...,\n",
+              "│      \n",
+              "│      [[ 63,  68,  45],\n",
+              "│   │   [ 58,  66,  27],\n",
+              "│   │   [ 74,  84,  49],\n",
+              "│   │   ...,\n",
+              "│   │   [ 32,  46,  23],\n",
+              "│   │   [ 56,  76,  39],\n",
+              "│   │   [ 31,  47,  18]],\n",
+              "│      \n",
+              "│      [[ 60,  66,  40],\n",
+              "│   │   [ 45,  55,  18],\n",
+              "│   │   [ 83,  92,  61],\n",
+              "│   │   ...,\n",
+              "│   │   [ 63,  77,  54],\n",
+              "│   │   [ 47,  67,  30],\n",
+              "│   │   [ 35,  52,  20]],\n",
+              "│      \n",
+              "│      [[ 64,  70,  42],\n",
+              "│   │   [ 85,  95,  60],\n",
+              "│   │   [ 66,  75,  48],\n",
+              "│   │   ...,\n",
+              "│   │   [ 37,  51,  28],\n",
+              "│   │   [ 59,  79,  42],\n",
+              "│   │   [ 44,  61,  29]]], dtype=uint8)\n",
+              "│   ]\n",
+              "}\n",
+              "
    \n"
+            ]
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "# Show the structure of result dict\n",
+        "from rich.pretty import pprint\n",
+        "pprint(result, max_length=4)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 444
+        },
+        "id": "UsJU5D-QPX8L",
+        "outputId": "766f3211-301b-4a89-ae9d-898a92181c67"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              ""
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {},
+          "execution_count": 7
+        }
+      ],
+      "source": [
+        "# Show the output image\n",
+        "from PIL import Image\n",
+        "Image.open('./output/vis/demo.jpg')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "7GrWIJywLV-V"
+      },
+      "source": [
+        "## Train with customized datasets\n",
+        "\n",
+        "In this part, you will know how to train predefined models with customized datasets and then test it. We use the [balloon dataset](https://github.com/matterport/Mask_RCNN/tree/master/samples/balloon) as an example to describe the whole process.\n",
+        "\n",
+        "The basic steps are as below:\n",
+        "\n",
+        "1. Prepare the customized dataset\n",
+        "2. Prepare a config\n",
+        "3. Train, test, and infer models on the customized dataset.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "E73y5Lru-wBx"
+      },
+      "source": [
+        "### Prepare the customized dataset\n",
+        "\n",
+        "There are three ways to support a new dataset in MMDetection:\n",
+        "\n",
+        "1. Reorganize the dataset into COCO format.\n",
+        "2. Reorganize the dataset into a middle format.\n",
+        "3. Implement a new dataset.\n",
+        "\n",
+        "Usually, we recommend using the first two methods which are usually easier than the third.\n",
+        "\n",
+        "In this tutorial, we use the ballon dataset an example of converting the data into COCO format.\n",
+        "\n",
+        "**Note**: Datasets and metrics have been decoupled except CityScapes since MMDetection 3.0. Therefore, users can use any kind of evaluation metrics for any format of datasets during validation. For example: evaluate on COCO dataset with VOC metric, or evaluate on OpenImages dataset with both VOC and COCO metrics."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "sbJhEsckU8UX",
+        "outputId": "b9fdd1b1-5591-41b9-b27c-cadccac9aafa"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Downloading https://download.openmmlab.com/mmyolo/data/balloon_dataset.zip to data/balloon_dataset.zip\n",
+            "100% 36.9M/36.9M [00:01<00:00, 25.0MB/s]\n",
+            "Unzipping balloon_dataset.zip\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Download the data and unzip it\n",
+        "!python tools/misc/download_dataset.py --dataset-name balloon --save-dir data --unzip"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "gmMpkzs2U8UY"
+      },
+      "source": [
+        "#### COCO annotation format\n",
+        "The necessary keys of COCO format for instance segmentation are as below, for the complete details, please refer [here](https://cocodataset.org/#format-data).\n",
+        "\n",
+        "```json\n",
+        "{\n",
+        "    \"images\": [image],\n",
+        "    \"annotations\": [annotation],\n",
+        "    \"categories\": [category]\n",
+        "}\n",
+        "image = {\n",
+        "    \"id\": int,\n",
+        "    \"width\": int,\n",
+        "    \"height\": int,\n",
+        "    \"file_name\": str,\n",
+        "}\n",
+        "annotation = {\n",
+        "    \"id\": int,\n",
+        "    \"image_id\": int,\n",
+        "    \"category_id\": int,\n",
+        "    \"segmentation\": RLE or [polygon],\n",
+        "    \"area\": float,\n",
+        "    \"bbox\": [x,y,width,height], # (x, y) are the coordinates of the upper left corner of the bbox\n",
+        "    \"iscrowd\": 0 or 1,\n",
+        "}\n",
+        "categories = [{\n",
+        "    \"id\": int,\n",
+        "    \"name\": str,\n",
+        "    \"supercategory\": str,\n",
+        "}]\n",
+        "```\n",
+        "\n",
+        "Assume we use the balloon dataset.\n",
+        "After downloading the data, we need to implement a function to convert the annotation format into the COCO format. Then we can use implemented `CocoDataset` to load the data and perform training and evaluation.\n",
+        "\n",
+        "If you take a look at the dataset, you will find the dataset format is as below:\n",
+        "\n",
+        "```json\n",
+        "{'base64_img_data': '',\n",
+        " 'file_attributes': {},\n",
+        " 'filename': '34020010494_e5cb88e1c4_k.jpg',\n",
+        " 'fileref': '',\n",
+        " 'regions': {'0': {'region_attributes': {},\n",
+        "   'shape_attributes': {'all_points_x': [1020,\n",
+        "     1000,\n",
+        "     994,\n",
+        "     1003,\n",
+        "     1023,\n",
+        "     1050,\n",
+        "     1089,\n",
+        "     1134,\n",
+        "     1190,\n",
+        "     1265,\n",
+        "     1321,\n",
+        "     1361,\n",
+        "     1403,\n",
+        "     1428,\n",
+        "     1442,\n",
+        "     1445,\n",
+        "     1441,\n",
+        "     1427,\n",
+        "     1400,\n",
+        "     1361,\n",
+        "     1316,\n",
+        "     1269,\n",
+        "     1228,\n",
+        "     1198,\n",
+        "     1207,\n",
+        "     1210,\n",
+        "     1190,\n",
+        "     1177,\n",
+        "     1172,\n",
+        "     1174,\n",
+        "     1170,\n",
+        "     1153,\n",
+        "     1127,\n",
+        "     1104,\n",
+        "     1061,\n",
+        "     1032,\n",
+        "     1020],\n",
+        "    'all_points_y': [963,\n",
+        "     899,\n",
+        "     841,\n",
+        "     787,\n",
+        "     738,\n",
+        "     700,\n",
+        "     663,\n",
+        "     638,\n",
+        "     621,\n",
+        "     619,\n",
+        "     643,\n",
+        "     672,\n",
+        "     720,\n",
+        "     765,\n",
+        "     800,\n",
+        "     860,\n",
+        "     896,\n",
+        "     942,\n",
+        "     990,\n",
+        "     1035,\n",
+        "     1079,\n",
+        "     1112,\n",
+        "     1129,\n",
+        "     1134,\n",
+        "     1144,\n",
+        "     1153,\n",
+        "     1166,\n",
+        "     1166,\n",
+        "     1150,\n",
+        "     1136,\n",
+        "     1129,\n",
+        "     1122,\n",
+        "     1112,\n",
+        "     1084,\n",
+        "     1037,\n",
+        "     989,\n",
+        "     963],\n",
+        "    'name': 'polygon'}}},\n",
+        " 'size': 1115004}\n",
+        "```\n",
+        "\n",
+        "The annotation is a JSON file where each key indicates an image's all annotations.\n",
+        "The code to convert the balloon dataset into coco format is as below.\n",
+        "\n",
+        "Using the function below, users can successfully convert the annotation file into json format, then we can use `CocoDataset` to train and evaluate the model with `CocoMetric`."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "rHnw5Q_nARXq",
+        "outputId": "4b1efb44-f81d-486f-80e6-461a57fe84bc"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 61/61, 34.8 task/s, elapsed: 2s, ETA:     0s\n",
+            "[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 13/13, 22.2 task/s, elapsed: 1s, ETA:     0s\n"
+          ]
+        }
+      ],
+      "source": [
+        "import os.path as osp\n",
+        "import mmcv\n",
+        "from mmengine.fileio import dump, load\n",
+        "from mmengine.utils import track_iter_progress\n",
+        "\n",
+        "def convert_balloon_to_coco(ann_file, out_file, image_prefix):\n",
+        "    data_infos = load(ann_file)\n",
+        "\n",
+        "    annotations = []\n",
+        "    images = []\n",
+        "    obj_count = 0\n",
+        "    for idx, v in enumerate(track_iter_progress(data_infos.values())):\n",
+        "        filename = v['filename']\n",
+        "        img_path = osp.join(image_prefix, filename)\n",
+        "        height, width = mmcv.imread(img_path).shape[:2]\n",
+        "\n",
+        "        images.append(\n",
+        "            dict(id=idx, file_name=filename, height=height, width=width))\n",
+        "        \n",
+        "        for _, obj in v['regions'].items():\n",
+        "            assert not obj['region_attributes']\n",
+        "            obj = obj['shape_attributes']\n",
+        "            px = obj['all_points_x']\n",
+        "            py = obj['all_points_y']\n",
+        "            poly = [(x + 0.5, y + 0.5) for x, y in zip(px, py)]\n",
+        "            poly = [p for x in poly for p in x]\n",
+        "\n",
+        "            x_min, y_min, x_max, y_max = (min(px), min(py), max(px), max(py))\n",
+        "\n",
+        "            data_anno = dict(\n",
+        "                image_id=idx,\n",
+        "                id=obj_count,\n",
+        "                category_id=0,\n",
+        "                bbox=[x_min, y_min, x_max - x_min, y_max - y_min],\n",
+        "                area=(x_max - x_min) * (y_max - y_min),\n",
+        "                segmentation=[poly],\n",
+        "                iscrowd=0)\n",
+        "            annotations.append(data_anno)\n",
+        "            obj_count += 1\n",
+        "\n",
+        "    coco_format_json = dict(\n",
+        "        images=images,\n",
+        "        annotations=annotations,\n",
+        "        categories=[{\n",
+        "            'id': 0,\n",
+        "            'name': 'balloon'\n",
+        "        }])\n",
+        "    dump(coco_format_json, out_file)\n",
+        "\n",
+        "if __name__ == '__main__':\n",
+        "    convert_balloon_to_coco(ann_file='data/balloon/train/via_region_data.json',\n",
+        "                            out_file='data/balloon/train.json',\n",
+        "                            image_prefix='data/balloon/train')\n",
+        "    convert_balloon_to_coco(ann_file='data/balloon/val/via_region_data.json',\n",
+        "                            out_file='data/balloon/val.json',\n",
+        "                            image_prefix='data/balloon/val')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "yc9UDp1vU8UZ"
+      },
+      "source": [
+        "## Prepare a config\n",
+        "\n",
+        "The second step is to prepare a config thus the dataset could be successfully loaded. Assume that we want to use RTMDet-tiny, the config to train the detector on balloon dataset is as below. Assume the config is under directory `configs/rtmdet/` and named as `rtmdet_tiny_1xb4-20e_balloon.py`, the config is as below.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 10,
+      "metadata": {
+        "id": "XjTW6XydU8Ua"
+      },
+      "outputs": [],
+      "source": [
+        "config_balloon = \"\"\"\n",
+        "# Inherit and overwrite part of the config based on this config\n",
+        "_base_ = './rtmdet_tiny_8xb32-300e_coco.py'\n",
+        "\n",
+        "data_root = 'data/balloon/' # dataset root\n",
+        "\n",
+        "train_batch_size_per_gpu = 4\n",
+        "train_num_workers = 2\n",
+        "\n",
+        "max_epochs = 20\n",
+        "stage2_num_epochs = 1\n",
+        "base_lr = 0.00008\n",
+        "\n",
+        "\n",
+        "metainfo = {\n",
+        "    'classes': ('balloon', ),\n",
+        "    'palette': [\n",
+        "        (220, 20, 60),\n",
+        "    ]\n",
+        "}\n",
+        "\n",
+        "train_dataloader = dict(\n",
+        "    batch_size=train_batch_size_per_gpu,\n",
+        "    num_workers=train_num_workers,\n",
+        "    dataset=dict(\n",
+        "        data_root=data_root,\n",
+        "        metainfo=metainfo,\n",
+        "        data_prefix=dict(img='train/'),\n",
+        "        ann_file='train.json'))\n",
+        "\n",
+        "val_dataloader = dict(\n",
+        "    dataset=dict(\n",
+        "        data_root=data_root,\n",
+        "        metainfo=metainfo,\n",
+        "        data_prefix=dict(img='val/'),\n",
+        "        ann_file='val.json'))\n",
+        "\n",
+        "test_dataloader = val_dataloader\n",
+        "\n",
+        "val_evaluator = dict(ann_file=data_root + 'val.json')\n",
+        "\n",
+        "test_evaluator = val_evaluator\n",
+        "\n",
+        "model = dict(bbox_head=dict(num_classes=1))\n",
+        "\n",
+        "# learning rate\n",
+        "param_scheduler = [\n",
+        "    dict(\n",
+        "        type='LinearLR',\n",
+        "        start_factor=1.0e-5,\n",
+        "        by_epoch=False,\n",
+        "        begin=0,\n",
+        "        end=10),\n",
+        "    dict(\n",
+        "        # use cosine lr from 10 to 20 epoch\n",
+        "        type='CosineAnnealingLR',\n",
+        "        eta_min=base_lr * 0.05,\n",
+        "        begin=max_epochs // 2,\n",
+        "        end=max_epochs,\n",
+        "        T_max=max_epochs // 2,\n",
+        "        by_epoch=True,\n",
+        "        convert_to_iter_based=True),\n",
+        "]\n",
+        "\n",
+        "train_pipeline_stage2 = [\n",
+        "    dict(type='LoadImageFromFile', backend_args=None),\n",
+        "    dict(type='LoadAnnotations', with_bbox=True),\n",
+        "    dict(\n",
+        "        type='RandomResize',\n",
+        "        scale=(640, 640),\n",
+        "        ratio_range=(0.1, 2.0),\n",
+        "        keep_ratio=True),\n",
+        "    dict(type='RandomCrop', crop_size=(640, 640)),\n",
+        "    dict(type='YOLOXHSVRandomAug'),\n",
+        "    dict(type='RandomFlip', prob=0.5),\n",
+        "    dict(type='Pad', size=(640, 640), pad_val=dict(img=(114, 114, 114))),\n",
+        "    dict(type='PackDetInputs')\n",
+        "]\n",
+        "\n",
+        "# optimizer\n",
+        "optim_wrapper = dict(\n",
+        "    _delete_=True,\n",
+        "    type='OptimWrapper',\n",
+        "    optimizer=dict(type='AdamW', lr=base_lr, weight_decay=0.05),\n",
+        "    paramwise_cfg=dict(\n",
+        "        norm_decay_mult=0, bias_decay_mult=0, bypass_duplicate=True))\n",
+        "\n",
+        "default_hooks = dict(\n",
+        "    checkpoint=dict(\n",
+        "        interval=5,\n",
+        "        max_keep_ckpts=2,  # only keep latest 2 checkpoints\n",
+        "        save_best='auto'\n",
+        "    ),\n",
+        "    logger=dict(type='LoggerHook', interval=5))\n",
+        "\n",
+        "custom_hooks = [\n",
+        "    dict(\n",
+        "        type='PipelineSwitchHook',\n",
+        "        switch_epoch=max_epochs - stage2_num_epochs,\n",
+        "        switch_pipeline=train_pipeline_stage2)\n",
+        "]\n",
+        "\n",
+        "# load COCO pre-trained weight\n",
+        "load_from = './checkpoints/rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth'\n",
+        "\n",
+        "train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1)\n",
+        "visualizer = dict(vis_backends=[dict(type='LocalVisBackend'),dict(type='TensorboardVisBackend')])\n",
+        "\"\"\"\n",
+        "\n",
+        "with open('./configs/rtmdet/rtmdet_tiny_1xb4-20e_balloon.py', 'w') as f:\n",
+        "    f.write(config_balloon)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 11,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "5LNm7LxwZG2w",
+        "outputId": "aac457c5-f915-433d-e98a-85ddd9005543"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "04/17 10:28:35 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - \n",
+            "------------------------------------------------------------\n",
+            "System environment:\n",
+            "    sys.platform: linux\n",
+            "    Python: 3.9.16 (main, Dec  7 2022, 01:11:51) [GCC 9.4.0]\n",
+            "    CUDA available: True\n",
+            "    numpy_random_seed: 904036445\n",
+            "    GPU 0: Tesla T4\n",
+            "    CUDA_HOME: /usr/local/cuda\n",
+            "    NVCC: Cuda compilation tools, release 11.8, V11.8.89\n",
+            "    GCC: x86_64-linux-gnu-gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0\n",
+            "    PyTorch: 2.0.0+cu118\n",
+            "    PyTorch compiling details: PyTorch built with:\n",
+            "  - GCC 9.3\n",
+            "  - C++ Version: 201703\n",
+            "  - Intel(R) oneAPI Math Kernel Library Version 2022.2-Product Build 20220804 for Intel(R) 64 architecture applications\n",
+            "  - Intel(R) MKL-DNN v2.7.3 (Git Hash 6dbeffbae1f23cbbeae17adb7b5b13f1f37c080e)\n",
+            "  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n",
+            "  - LAPACK is enabled (usually provided by MKL)\n",
+            "  - NNPACK is enabled\n",
+            "  - CPU capability usage: AVX2\n",
+            "  - CUDA Runtime 11.8\n",
+            "  - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90\n",
+            "  - CuDNN 8.7\n",
+            "  - Magma 2.6.1\n",
+            "  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, CUDA_VERSION=11.8, CUDNN_VERSION=8.7.0, CXX_COMPILER=/opt/rh/devtoolset-9/root/usr/bin/c++, CXX_FLAGS= -D_GLIBCXX_USE_CXX11_ABI=0 -fabi-version=11 -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wunused-local-typedefs -Wno-unused-parameter -Wno-unused-function -Wno-unused-result -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Werror=cast-function-type -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, TORCH_DISABLE_GPU_ASSERTS=ON, TORCH_VERSION=2.0.0, USE_CUDA=ON, USE_CUDNN=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, \n",
+            "\n",
+            "    TorchVision: 0.15.1+cu118\n",
+            "    OpenCV: 4.7.0\n",
+            "    MMEngine: 0.7.2\n",
+            "\n",
+            "Runtime environment:\n",
+            "    cudnn_benchmark: False\n",
+            "    mp_cfg: {'mp_start_method': 'fork', 'opencv_num_threads': 0}\n",
+            "    dist_cfg: {'backend': 'nccl'}\n",
+            "    seed: None\n",
+            "    Distributed launcher: none\n",
+            "    Distributed training: False\n",
+            "    GPU number: 1\n",
+            "------------------------------------------------------------\n",
+            "\n",
+            "04/17 10:28:37 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Config:\n",
+            "default_scope = 'mmdet'\n",
+            "default_hooks = dict(\n",
+            "    timer=dict(type='IterTimerHook'),\n",
+            "    logger=dict(type='LoggerHook', interval=5),\n",
+            "    param_scheduler=dict(type='ParamSchedulerHook'),\n",
+            "    checkpoint=dict(\n",
+            "        type='CheckpointHook', interval=5, max_keep_ckpts=2, save_best='auto'),\n",
+            "    sampler_seed=dict(type='DistSamplerSeedHook'),\n",
+            "    visualization=dict(type='DetVisualizationHook'))\n",
+            "env_cfg = dict(\n",
+            "    cudnn_benchmark=False,\n",
+            "    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),\n",
+            "    dist_cfg=dict(backend='nccl'))\n",
+            "vis_backends = [dict(type='LocalVisBackend')]\n",
+            "visualizer = dict(\n",
+            "    type='DetLocalVisualizer',\n",
+            "    vis_backends=[\n",
+            "        dict(type='LocalVisBackend'),\n",
+            "        dict(type='TensorboardVisBackend')\n",
+            "    ],\n",
+            "    name='visualizer')\n",
+            "log_processor = dict(type='LogProcessor', window_size=50, by_epoch=True)\n",
+            "log_level = 'INFO'\n",
+            "load_from = './checkpoints/rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth'\n",
+            "resume = False\n",
+            "train_cfg = dict(\n",
+            "    type='EpochBasedTrainLoop',\n",
+            "    max_epochs=20,\n",
+            "    val_interval=1,\n",
+            "    dynamic_intervals=[(280, 1)])\n",
+            "val_cfg = dict(type='ValLoop')\n",
+            "test_cfg = dict(type='TestLoop')\n",
+            "param_scheduler = [\n",
+            "    dict(type='LinearLR', start_factor=1e-05, by_epoch=False, begin=0, end=10),\n",
+            "    dict(\n",
+            "        type='CosineAnnealingLR',\n",
+            "        eta_min=4.000000000000001e-06,\n",
+            "        begin=10,\n",
+            "        end=20,\n",
+            "        T_max=10,\n",
+            "        by_epoch=True,\n",
+            "        convert_to_iter_based=True)\n",
+            "]\n",
+            "optim_wrapper = dict(\n",
+            "    type='OptimWrapper',\n",
+            "    optimizer=dict(type='AdamW', lr=8e-05, weight_decay=0.05),\n",
+            "    paramwise_cfg=dict(\n",
+            "        norm_decay_mult=0, bias_decay_mult=0, bypass_duplicate=True))\n",
+            "auto_scale_lr = dict(enable=False, base_batch_size=16)\n",
+            "dataset_type = 'CocoDataset'\n",
+            "data_root = 'data/balloon/'\n",
+            "backend_args = None\n",
+            "train_pipeline = [\n",
+            "    dict(type='LoadImageFromFile', backend_args=None),\n",
+            "    dict(type='LoadAnnotations', with_bbox=True),\n",
+            "    dict(\n",
+            "        type='CachedMosaic',\n",
+            "        img_scale=(640, 640),\n",
+            "        pad_val=114.0,\n",
+            "        max_cached_images=20,\n",
+            "        random_pop=False),\n",
+            "    dict(\n",
+            "        type='RandomResize',\n",
+            "        scale=(1280, 1280),\n",
+            "        ratio_range=(0.5, 2.0),\n",
+            "        keep_ratio=True),\n",
+            "    dict(type='RandomCrop', crop_size=(640, 640)),\n",
+            "    dict(type='YOLOXHSVRandomAug'),\n",
+            "    dict(type='RandomFlip', prob=0.5),\n",
+            "    dict(type='Pad', size=(640, 640), pad_val=dict(img=(114, 114, 114))),\n",
+            "    dict(\n",
+            "        type='CachedMixUp',\n",
+            "        img_scale=(640, 640),\n",
+            "        ratio_range=(1.0, 1.0),\n",
+            "        max_cached_images=10,\n",
+            "        random_pop=False,\n",
+            "        pad_val=(114, 114, 114),\n",
+            "        prob=0.5),\n",
+            "    dict(type='PackDetInputs')\n",
+            "]\n",
+            "test_pipeline = [\n",
+            "    dict(type='LoadImageFromFile', backend_args=None),\n",
+            "    dict(type='Resize', scale=(640, 640), keep_ratio=True),\n",
+            "    dict(type='Pad', size=(640, 640), pad_val=dict(img=(114, 114, 114))),\n",
+            "    dict(\n",
+            "        type='PackDetInputs',\n",
+            "        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',\n",
+            "                   'scale_factor'))\n",
+            "]\n",
+            "train_dataloader = dict(\n",
+            "    batch_size=4,\n",
+            "    num_workers=2,\n",
+            "    persistent_workers=True,\n",
+            "    sampler=dict(type='DefaultSampler', shuffle=True),\n",
+            "    batch_sampler=None,\n",
+            "    dataset=dict(\n",
+            "        type='CocoDataset',\n",
+            "        data_root='data/balloon/',\n",
+            "        ann_file='train.json',\n",
+            "        data_prefix=dict(img='train/'),\n",
+            "        filter_cfg=dict(filter_empty_gt=True, min_size=32),\n",
+            "        pipeline=[\n",
+            "            dict(type='LoadImageFromFile', backend_args=None),\n",
+            "            dict(type='LoadAnnotations', with_bbox=True),\n",
+            "            dict(\n",
+            "                type='CachedMosaic',\n",
+            "                img_scale=(640, 640),\n",
+            "                pad_val=114.0,\n",
+            "                max_cached_images=20,\n",
+            "                random_pop=False),\n",
+            "            dict(\n",
+            "                type='RandomResize',\n",
+            "                scale=(1280, 1280),\n",
+            "                ratio_range=(0.5, 2.0),\n",
+            "                keep_ratio=True),\n",
+            "            dict(type='RandomCrop', crop_size=(640, 640)),\n",
+            "            dict(type='YOLOXHSVRandomAug'),\n",
+            "            dict(type='RandomFlip', prob=0.5),\n",
+            "            dict(\n",
+            "                type='Pad', size=(640, 640),\n",
+            "                pad_val=dict(img=(114, 114, 114))),\n",
+            "            dict(\n",
+            "                type='CachedMixUp',\n",
+            "                img_scale=(640, 640),\n",
+            "                ratio_range=(1.0, 1.0),\n",
+            "                max_cached_images=10,\n",
+            "                random_pop=False,\n",
+            "                pad_val=(114, 114, 114),\n",
+            "                prob=0.5),\n",
+            "            dict(type='PackDetInputs')\n",
+            "        ],\n",
+            "        backend_args=None,\n",
+            "        metainfo=dict(classes=('balloon', ), palette=[(220, 20, 60)])),\n",
+            "    pin_memory=True)\n",
+            "val_dataloader = dict(\n",
+            "    batch_size=5,\n",
+            "    num_workers=10,\n",
+            "    persistent_workers=True,\n",
+            "    drop_last=False,\n",
+            "    sampler=dict(type='DefaultSampler', shuffle=False),\n",
+            "    dataset=dict(\n",
+            "        type='CocoDataset',\n",
+            "        data_root='data/balloon/',\n",
+            "        ann_file='val.json',\n",
+            "        data_prefix=dict(img='val/'),\n",
+            "        test_mode=True,\n",
+            "        pipeline=[\n",
+            "            dict(type='LoadImageFromFile', backend_args=None),\n",
+            "            dict(type='Resize', scale=(640, 640), keep_ratio=True),\n",
+            "            dict(\n",
+            "                type='Pad', size=(640, 640),\n",
+            "                pad_val=dict(img=(114, 114, 114))),\n",
+            "            dict(\n",
+            "                type='PackDetInputs',\n",
+            "                meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',\n",
+            "                           'scale_factor'))\n",
+            "        ],\n",
+            "        backend_args=None,\n",
+            "        metainfo=dict(classes=('balloon', ), palette=[(220, 20, 60)])))\n",
+            "test_dataloader = dict(\n",
+            "    batch_size=5,\n",
+            "    num_workers=10,\n",
+            "    persistent_workers=True,\n",
+            "    drop_last=False,\n",
+            "    sampler=dict(type='DefaultSampler', shuffle=False),\n",
+            "    dataset=dict(\n",
+            "        type='CocoDataset',\n",
+            "        data_root='data/balloon/',\n",
+            "        ann_file='val.json',\n",
+            "        data_prefix=dict(img='val/'),\n",
+            "        test_mode=True,\n",
+            "        pipeline=[\n",
+            "            dict(type='LoadImageFromFile', backend_args=None),\n",
+            "            dict(type='Resize', scale=(640, 640), keep_ratio=True),\n",
+            "            dict(\n",
+            "                type='Pad', size=(640, 640),\n",
+            "                pad_val=dict(img=(114, 114, 114))),\n",
+            "            dict(\n",
+            "                type='PackDetInputs',\n",
+            "                meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',\n",
+            "                           'scale_factor'))\n",
+            "        ],\n",
+            "        backend_args=None,\n",
+            "        metainfo=dict(classes=('balloon', ), palette=[(220, 20, 60)])))\n",
+            "val_evaluator = dict(\n",
+            "    type='CocoMetric',\n",
+            "    ann_file='data/balloon/val.json',\n",
+            "    metric='bbox',\n",
+            "    format_only=False,\n",
+            "    backend_args=None,\n",
+            "    proposal_nums=(100, 1, 10))\n",
+            "test_evaluator = dict(\n",
+            "    type='CocoMetric',\n",
+            "    ann_file='data/balloon/val.json',\n",
+            "    metric='bbox',\n",
+            "    format_only=False,\n",
+            "    backend_args=None,\n",
+            "    proposal_nums=(100, 1, 10))\n",
+            "tta_model = dict(\n",
+            "    type='DetTTAModel',\n",
+            "    tta_cfg=dict(nms=dict(type='nms', iou_threshold=0.6), max_per_img=100))\n",
+            "img_scales = [(640, 640), (320, 320), (960, 960)]\n",
+            "tta_pipeline = [\n",
+            "    dict(type='LoadImageFromFile', backend_args=None),\n",
+            "    dict(\n",
+            "        type='TestTimeAug',\n",
+            "        transforms=[[{\n",
+            "            'type': 'Resize',\n",
+            "            'scale': (640, 640),\n",
+            "            'keep_ratio': True\n",
+            "        }, {\n",
+            "            'type': 'Resize',\n",
+            "            'scale': (320, 320),\n",
+            "            'keep_ratio': True\n",
+            "        }, {\n",
+            "            'type': 'Resize',\n",
+            "            'scale': (960, 960),\n",
+            "            'keep_ratio': True\n",
+            "        }],\n",
+            "                    [{\n",
+            "                        'type': 'RandomFlip',\n",
+            "                        'prob': 1.0\n",
+            "                    }, {\n",
+            "                        'type': 'RandomFlip',\n",
+            "                        'prob': 0.0\n",
+            "                    }],\n",
+            "                    [{\n",
+            "                        'type': 'Pad',\n",
+            "                        'size': (960, 960),\n",
+            "                        'pad_val': {\n",
+            "                            'img': (114, 114, 114)\n",
+            "                        }\n",
+            "                    }],\n",
+            "                    [{\n",
+            "                        'type':\n",
+            "                        'PackDetInputs',\n",
+            "                        'meta_keys':\n",
+            "                        ('img_id', 'img_path', 'ori_shape', 'img_shape',\n",
+            "                         'scale_factor', 'flip', 'flip_direction')\n",
+            "                    }]])\n",
+            "]\n",
+            "model = dict(\n",
+            "    type='RTMDet',\n",
+            "    data_preprocessor=dict(\n",
+            "        type='DetDataPreprocessor',\n",
+            "        mean=[103.53, 116.28, 123.675],\n",
+            "        std=[57.375, 57.12, 58.395],\n",
+            "        bgr_to_rgb=False,\n",
+            "        batch_augments=None),\n",
+            "    backbone=dict(\n",
+            "        type='CSPNeXt',\n",
+            "        arch='P5',\n",
+            "        expand_ratio=0.5,\n",
+            "        deepen_factor=0.167,\n",
+            "        widen_factor=0.375,\n",
+            "        channel_attention=True,\n",
+            "        norm_cfg=dict(type='SyncBN'),\n",
+            "        act_cfg=dict(type='SiLU', inplace=True),\n",
+            "        init_cfg=dict(\n",
+            "            type='Pretrained',\n",
+            "            prefix='backbone.',\n",
+            "            checkpoint=\n",
+            "            'https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-tiny_imagenet_600e.pth'\n",
+            "        )),\n",
+            "    neck=dict(\n",
+            "        type='CSPNeXtPAFPN',\n",
+            "        in_channels=[96, 192, 384],\n",
+            "        out_channels=96,\n",
+            "        num_csp_blocks=1,\n",
+            "        expand_ratio=0.5,\n",
+            "        norm_cfg=dict(type='SyncBN'),\n",
+            "        act_cfg=dict(type='SiLU', inplace=True)),\n",
+            "    bbox_head=dict(\n",
+            "        type='RTMDetSepBNHead',\n",
+            "        num_classes=1,\n",
+            "        in_channels=96,\n",
+            "        stacked_convs=2,\n",
+            "        feat_channels=96,\n",
+            "        anchor_generator=dict(\n",
+            "            type='MlvlPointGenerator', offset=0, strides=[8, 16, 32]),\n",
+            "        bbox_coder=dict(type='DistancePointBBoxCoder'),\n",
+            "        loss_cls=dict(\n",
+            "            type='QualityFocalLoss',\n",
+            "            use_sigmoid=True,\n",
+            "            beta=2.0,\n",
+            "            loss_weight=1.0),\n",
+            "        loss_bbox=dict(type='GIoULoss', loss_weight=2.0),\n",
+            "        with_objectness=False,\n",
+            "        exp_on_reg=False,\n",
+            "        share_conv=True,\n",
+            "        pred_kernel_size=1,\n",
+            "        norm_cfg=dict(type='SyncBN'),\n",
+            "        act_cfg=dict(type='SiLU', inplace=True)),\n",
+            "    train_cfg=dict(\n",
+            "        assigner=dict(type='DynamicSoftLabelAssigner', topk=13),\n",
+            "        allowed_border=-1,\n",
+            "        pos_weight=-1,\n",
+            "        debug=False),\n",
+            "    test_cfg=dict(\n",
+            "        nms_pre=30000,\n",
+            "        min_bbox_size=0,\n",
+            "        score_thr=0.001,\n",
+            "        nms=dict(type='nms', iou_threshold=0.65),\n",
+            "        max_per_img=300))\n",
+            "train_pipeline_stage2 = [\n",
+            "    dict(type='LoadImageFromFile', backend_args=None),\n",
+            "    dict(type='LoadAnnotations', with_bbox=True),\n",
+            "    dict(\n",
+            "        type='RandomResize',\n",
+            "        scale=(640, 640),\n",
+            "        ratio_range=(0.1, 2.0),\n",
+            "        keep_ratio=True),\n",
+            "    dict(type='RandomCrop', crop_size=(640, 640)),\n",
+            "    dict(type='YOLOXHSVRandomAug'),\n",
+            "    dict(type='RandomFlip', prob=0.5),\n",
+            "    dict(type='Pad', size=(640, 640), pad_val=dict(img=(114, 114, 114))),\n",
+            "    dict(type='PackDetInputs')\n",
+            "]\n",
+            "max_epochs = 20\n",
+            "stage2_num_epochs = 1\n",
+            "base_lr = 8e-05\n",
+            "interval = 10\n",
+            "custom_hooks = [\n",
+            "    dict(\n",
+            "        type='PipelineSwitchHook',\n",
+            "        switch_epoch=19,\n",
+            "        switch_pipeline=[\n",
+            "            dict(type='LoadImageFromFile', backend_args=None),\n",
+            "            dict(type='LoadAnnotations', with_bbox=True),\n",
+            "            dict(\n",
+            "                type='RandomResize',\n",
+            "                scale=(640, 640),\n",
+            "                ratio_range=(0.1, 2.0),\n",
+            "                keep_ratio=True),\n",
+            "            dict(type='RandomCrop', crop_size=(640, 640)),\n",
+            "            dict(type='YOLOXHSVRandomAug'),\n",
+            "            dict(type='RandomFlip', prob=0.5),\n",
+            "            dict(\n",
+            "                type='Pad', size=(640, 640),\n",
+            "                pad_val=dict(img=(114, 114, 114))),\n",
+            "            dict(type='PackDetInputs')\n",
+            "        ])\n",
+            "]\n",
+            "checkpoint = 'https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-tiny_imagenet_600e.pth'\n",
+            "train_batch_size_per_gpu = 4\n",
+            "train_num_workers = 2\n",
+            "metainfo = dict(classes=('balloon', ), palette=[(220, 20, 60)])\n",
+            "launcher = 'none'\n",
+            "work_dir = './work_dirs/rtmdet_tiny_1xb4-20e_balloon'\n",
+            "\n",
+            "2023-04-17 10:28:39.429834: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
+            "To enable the following instructions: AVX2 AVX512F FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
+            "2023-04-17 10:28:40.271799: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
+            "04/17 10:28:43 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Distributed training is not used, all SyncBatchNorm (SyncBN) layers in the model will be automatically reverted to BatchNormXd layers if they are used.\n",
+            "04/17 10:28:43 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Hooks will be executed in the following order:\n",
+            "before_run:\n",
+            "(VERY_HIGH   ) RuntimeInfoHook                    \n",
+            "(BELOW_NORMAL) LoggerHook                         \n",
+            " -------------------- \n",
+            "before_train:\n",
+            "(VERY_HIGH   ) RuntimeInfoHook                    \n",
+            "(NORMAL      ) IterTimerHook                      \n",
+            "(VERY_LOW    ) CheckpointHook                     \n",
+            " -------------------- \n",
+            "before_train_epoch:\n",
+            "(VERY_HIGH   ) RuntimeInfoHook                    \n",
+            "(NORMAL      ) IterTimerHook                      \n",
+            "(NORMAL      ) DistSamplerSeedHook                \n",
+            "(NORMAL      ) PipelineSwitchHook                 \n",
+            " -------------------- \n",
+            "before_train_iter:\n",
+            "(VERY_HIGH   ) RuntimeInfoHook                    \n",
+            "(NORMAL      ) IterTimerHook                      \n",
+            " -------------------- \n",
+            "after_train_iter:\n",
+            "(VERY_HIGH   ) RuntimeInfoHook                    \n",
+            "(NORMAL      ) IterTimerHook                      \n",
+            "(BELOW_NORMAL) LoggerHook                         \n",
+            "(LOW         ) ParamSchedulerHook                 \n",
+            "(VERY_LOW    ) CheckpointHook                     \n",
+            " -------------------- \n",
+            "after_train_epoch:\n",
+            "(NORMAL      ) IterTimerHook                      \n",
+            "(LOW         ) ParamSchedulerHook                 \n",
+            "(VERY_LOW    ) CheckpointHook                     \n",
+            " -------------------- \n",
+            "before_val_epoch:\n",
+            "(NORMAL      ) IterTimerHook                      \n",
+            " -------------------- \n",
+            "before_val_iter:\n",
+            "(NORMAL      ) IterTimerHook                      \n",
+            " -------------------- \n",
+            "after_val_iter:\n",
+            "(NORMAL      ) IterTimerHook                      \n",
+            "(NORMAL      ) DetVisualizationHook               \n",
+            "(BELOW_NORMAL) LoggerHook                         \n",
+            " -------------------- \n",
+            "after_val_epoch:\n",
+            "(VERY_HIGH   ) RuntimeInfoHook                    \n",
+            "(NORMAL      ) IterTimerHook                      \n",
+            "(BELOW_NORMAL) LoggerHook                         \n",
+            "(LOW         ) ParamSchedulerHook                 \n",
+            "(VERY_LOW    ) CheckpointHook                     \n",
+            " -------------------- \n",
+            "after_train:\n",
+            "(VERY_LOW    ) CheckpointHook                     \n",
+            " -------------------- \n",
+            "before_test_epoch:\n",
+            "(NORMAL      ) IterTimerHook                      \n",
+            " -------------------- \n",
+            "before_test_iter:\n",
+            "(NORMAL      ) IterTimerHook                      \n",
+            " -------------------- \n",
+            "after_test_iter:\n",
+            "(NORMAL      ) IterTimerHook                      \n",
+            "(NORMAL      ) DetVisualizationHook               \n",
+            "(BELOW_NORMAL) LoggerHook                         \n",
+            " -------------------- \n",
+            "after_test_epoch:\n",
+            "(VERY_HIGH   ) RuntimeInfoHook                    \n",
+            "(NORMAL      ) IterTimerHook                      \n",
+            "(BELOW_NORMAL) LoggerHook                         \n",
+            " -------------------- \n",
+            "after_run:\n",
+            "(BELOW_NORMAL) LoggerHook                         \n",
+            " -------------------- \n",
+            "loading annotations into memory...\n",
+            "Done (t=0.00s)\n",
+            "creating index...\n",
+            "index created!\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stem.0.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stem.0.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stem.1.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stem.1.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stem.2.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stem.2.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage1.0.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage1.0.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage1.1.main_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage1.1.main_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage1.1.short_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage1.1.short_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage1.1.final_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage1.1.final_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage1.1.blocks.0.conv1.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage1.1.blocks.0.conv1.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage1.1.blocks.0.conv2.depthwise_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage1.1.blocks.0.conv2.depthwise_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage1.1.blocks.0.conv2.pointwise_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage1.1.blocks.0.conv2.pointwise_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage1.1.attention.fc.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage2.0.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage2.0.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage2.1.main_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage2.1.main_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage2.1.short_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage2.1.short_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage2.1.final_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage2.1.final_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage2.1.blocks.0.conv1.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage2.1.blocks.0.conv1.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage2.1.blocks.0.conv2.depthwise_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage2.1.blocks.0.conv2.depthwise_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage2.1.blocks.0.conv2.pointwise_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage2.1.blocks.0.conv2.pointwise_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage2.1.attention.fc.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage3.0.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage3.0.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage3.1.main_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage3.1.main_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage3.1.short_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage3.1.short_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage3.1.final_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage3.1.final_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage3.1.blocks.0.conv1.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage3.1.blocks.0.conv1.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage3.1.blocks.0.conv2.depthwise_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage3.1.blocks.0.conv2.depthwise_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage3.1.blocks.0.conv2.pointwise_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage3.1.blocks.0.conv2.pointwise_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage3.1.attention.fc.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage4.0.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage4.0.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage4.1.conv1.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage4.1.conv1.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage4.1.conv2.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage4.1.conv2.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage4.2.main_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage4.2.main_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage4.2.short_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage4.2.short_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage4.2.final_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage4.2.final_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage4.2.blocks.0.conv1.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage4.2.blocks.0.conv1.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage4.2.blocks.0.conv2.depthwise_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage4.2.blocks.0.conv2.depthwise_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage4.2.blocks.0.conv2.pointwise_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage4.2.blocks.0.conv2.pointwise_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- backbone.stage4.2.attention.fc.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.reduce_layers.0.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.reduce_layers.0.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.reduce_layers.1.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.reduce_layers.1.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.top_down_blocks.0.main_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.top_down_blocks.0.main_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.top_down_blocks.0.short_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.top_down_blocks.0.short_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.top_down_blocks.0.final_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.top_down_blocks.0.final_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.top_down_blocks.0.blocks.0.conv1.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.top_down_blocks.0.blocks.0.conv1.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.top_down_blocks.0.blocks.0.conv2.depthwise_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.top_down_blocks.0.blocks.0.conv2.depthwise_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.top_down_blocks.0.blocks.0.conv2.pointwise_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.top_down_blocks.0.blocks.0.conv2.pointwise_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.top_down_blocks.1.main_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.top_down_blocks.1.main_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.top_down_blocks.1.short_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.top_down_blocks.1.short_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.top_down_blocks.1.final_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.top_down_blocks.1.final_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.top_down_blocks.1.blocks.0.conv1.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.top_down_blocks.1.blocks.0.conv1.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.top_down_blocks.1.blocks.0.conv2.depthwise_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.top_down_blocks.1.blocks.0.conv2.depthwise_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.top_down_blocks.1.blocks.0.conv2.pointwise_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.top_down_blocks.1.blocks.0.conv2.pointwise_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.downsamples.0.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.downsamples.0.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.downsamples.1.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.downsamples.1.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.bottom_up_blocks.0.main_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.bottom_up_blocks.0.main_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.bottom_up_blocks.0.short_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.bottom_up_blocks.0.short_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.bottom_up_blocks.0.final_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.bottom_up_blocks.0.final_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.bottom_up_blocks.0.blocks.0.conv1.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.bottom_up_blocks.0.blocks.0.conv1.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.bottom_up_blocks.0.blocks.0.conv2.depthwise_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.bottom_up_blocks.0.blocks.0.conv2.depthwise_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.bottom_up_blocks.0.blocks.0.conv2.pointwise_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.bottom_up_blocks.0.blocks.0.conv2.pointwise_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.bottom_up_blocks.1.main_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.bottom_up_blocks.1.main_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.bottom_up_blocks.1.short_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.bottom_up_blocks.1.short_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.bottom_up_blocks.1.final_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.bottom_up_blocks.1.final_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.bottom_up_blocks.1.blocks.0.conv1.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.bottom_up_blocks.1.blocks.0.conv1.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.bottom_up_blocks.1.blocks.0.conv2.depthwise_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.bottom_up_blocks.1.blocks.0.conv2.depthwise_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.bottom_up_blocks.1.blocks.0.conv2.pointwise_conv.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.bottom_up_blocks.1.blocks.0.conv2.pointwise_conv.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.out_convs.0.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.out_convs.0.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.out_convs.1.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.out_convs.1.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.out_convs.2.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- neck.out_convs.2.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.cls_convs.0.0.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.cls_convs.0.0.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.cls_convs.0.1.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.cls_convs.0.1.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - bbox_head.cls_convs.1.0.conv is duplicate. It is skipped since bypass_duplicate=True\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.cls_convs.1.0.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.cls_convs.1.0.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - bbox_head.cls_convs.1.1.conv is duplicate. It is skipped since bypass_duplicate=True\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.cls_convs.1.1.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.cls_convs.1.1.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - bbox_head.cls_convs.2.0.conv is duplicate. It is skipped since bypass_duplicate=True\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.cls_convs.2.0.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.cls_convs.2.0.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - bbox_head.cls_convs.2.1.conv is duplicate. It is skipped since bypass_duplicate=True\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.cls_convs.2.1.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.cls_convs.2.1.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.reg_convs.0.0.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.reg_convs.0.0.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.reg_convs.0.1.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.reg_convs.0.1.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - bbox_head.reg_convs.1.0.conv is duplicate. It is skipped since bypass_duplicate=True\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.reg_convs.1.0.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.reg_convs.1.0.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - bbox_head.reg_convs.1.1.conv is duplicate. It is skipped since bypass_duplicate=True\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.reg_convs.1.1.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.reg_convs.1.1.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - bbox_head.reg_convs.2.0.conv is duplicate. It is skipped since bypass_duplicate=True\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.reg_convs.2.0.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.reg_convs.2.0.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - bbox_head.reg_convs.2.1.conv is duplicate. It is skipped since bypass_duplicate=True\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.reg_convs.2.1.bn.weight:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.reg_convs.2.1.bn.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.rtm_cls.0.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.rtm_cls.1.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.rtm_cls.2.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.rtm_reg.0.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.rtm_reg.1.bias:weight_decay=0.0\n",
+            "04/17 10:28:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - paramwise_options -- bbox_head.rtm_reg.2.bias:weight_decay=0.0\n",
+            "loading annotations into memory...\n",
+            "Done (t=0.00s)\n",
+            "creating index...\n",
+            "index created!\n",
+            "/usr/local/lib/python3.9/dist-packages/torch/utils/data/dataloader.py:561: UserWarning: This DataLoader will create 10 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n",
+            "  warnings.warn(_create_warning_msg(\n",
+            "loading annotations into memory...\n",
+            "Done (t=0.00s)\n",
+            "creating index...\n",
+            "index created!\n",
+            "04/17 10:28:46 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - load backbone. in model from: https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-tiny_imagenet_600e.pth\n",
+            "Loads checkpoint by http backend from path: https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-tiny_imagenet_600e.pth\n",
+            "Downloading: \"https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-tiny_imagenet_600e.pth\" to /root/.cache/torch/hub/checkpoints/cspnext-tiny_imagenet_600e.pth\n",
+            "100% 31.5M/31.5M [00:01<00:00, 27.2MB/s]\n",
+            "Loads checkpoint by local backend from path: ./checkpoints/rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth\n",
+            "The model and loaded state dict do not match exactly\n",
+            "\n",
+            "size mismatch for bbox_head.rtm_cls.0.weight: copying a param with shape torch.Size([80, 96, 1, 1]) from checkpoint, the shape in current model is torch.Size([1, 96, 1, 1]).\n",
+            "size mismatch for bbox_head.rtm_cls.0.bias: copying a param with shape torch.Size([80]) from checkpoint, the shape in current model is torch.Size([1]).\n",
+            "size mismatch for bbox_head.rtm_cls.1.weight: copying a param with shape torch.Size([80, 96, 1, 1]) from checkpoint, the shape in current model is torch.Size([1, 96, 1, 1]).\n",
+            "size mismatch for bbox_head.rtm_cls.1.bias: copying a param with shape torch.Size([80]) from checkpoint, the shape in current model is torch.Size([1]).\n",
+            "size mismatch for bbox_head.rtm_cls.2.weight: copying a param with shape torch.Size([80, 96, 1, 1]) from checkpoint, the shape in current model is torch.Size([1, 96, 1, 1]).\n",
+            "size mismatch for bbox_head.rtm_cls.2.bias: copying a param with shape torch.Size([80]) from checkpoint, the shape in current model is torch.Size([1]).\n",
+            "unexpected key in source state_dict: data_preprocessor.mean, data_preprocessor.std\n",
+            "\n",
+            "04/17 10:28:48 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Load checkpoint from ./checkpoints/rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth\n",
+            "04/17 10:28:48 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - \"FileClient\" will be deprecated in future. Please use io functions in https://mmengine.readthedocs.io/en/latest/api/fileio.html#file-io\n",
+            "04/17 10:28:48 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - \"HardDiskBackend\" is the alias of \"LocalBackend\" and the former will be deprecated in future.\n",
+            "04/17 10:28:48 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Checkpoints will be saved to /content/mmdetection/work_dirs/rtmdet_tiny_1xb4-20e_balloon.\n",
+            "/usr/local/lib/python3.9/dist-packages/torch/functional.py:504: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at ../aten/src/ATen/native/TensorShape.cpp:3483.)\n",
+            "  return _VF.meshgrid(tensors, **kwargs)  # type: ignore[attr-defined]\n",
+            "04/17 10:28:51 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [1][ 5/16]  lr: 3.5556e-05  eta: 0:03:33  time: 0.6778  data_time: 0.2107  memory: 1422  loss: 2.7197  loss_cls: 2.0437  loss_bbox: 0.6761\n",
+            "04/17 10:28:52 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [1][10/16]  lr: 8.0000e-05  eta: 0:02:31  time: 0.4890  data_time: 0.1117  memory: 1422  loss: 2.7312  loss_cls: 2.0638  loss_bbox: 0.6673\n",
+            "04/17 10:28:54 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [1][15/16]  lr: 8.0000e-05  eta: 0:02:05  time: 0.4111  data_time: 0.0774  memory: 1422  loss: 2.7183  loss_cls: 2.0497  loss_bbox: 0.6687\n",
+            "04/17 10:28:54 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: rtmdet_tiny_1xb4-20e_balloon_20230417_102835\n",
+            "/usr/local/lib/python3.9/dist-packages/torch/utils/data/dataloader.py:561: UserWarning: This DataLoader will create 10 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n",
+            "  warnings.warn(_create_warning_msg(\n",
+            "04/17 10:28:55 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating bbox...\n",
+            "Loading and preparing results...\n",
+            "DONE (t=0.01s)\n",
+            "creating index...\n",
+            "index created!\n",
+            "Running per image evaluation...\n",
+            "Evaluate annotation type *bbox*\n",
+            "DONE (t=0.13s).\n",
+            "Accumulating evaluation results...\n",
+            "DONE (t=0.02s).\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.044\n",
+            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.059\n",
+            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.051\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.076\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.054\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.000\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.190\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.488\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.208\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.608\n",
+            "04/17 10:28:55 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - bbox_mAP_copypaste: 0.044 0.059 0.051 0.000 0.076 0.054\n",
+            "04/17 10:28:55 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [1][3/3]    coco/bbox_mAP: 0.0440  coco/bbox_mAP_50: 0.0590  coco/bbox_mAP_75: 0.0510  coco/bbox_mAP_s: 0.0000  coco/bbox_mAP_m: 0.0760  coco/bbox_mAP_l: 0.0540  data_time: 0.1730  time: 0.2618\n",
+            "04/17 10:28:56 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The best checkpoint with 0.0440 coco/bbox_mAP at 1 epoch is saved to best_coco_bbox_mAP_epoch_1.pth.\n",
+            "04/17 10:28:59 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [2][ 5/16]  lr: 8.0000e-05  eta: 0:02:09  time: 0.4335  data_time: 0.0945  memory: 1422  loss: 2.7141  loss_cls: 2.0473  loss_bbox: 0.6668\n",
+            "04/17 10:29:02 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [2][10/16]  lr: 8.0000e-05  eta: 0:02:20  time: 0.4791  data_time: 0.1165  memory: 1422  loss: 2.7160  loss_cls: 2.0560  loss_bbox: 0.6600\n",
+            "04/17 10:29:04 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [2][15/16]  lr: 8.0000e-05  eta: 0:02:13  time: 0.4614  data_time: 0.0997  memory: 1422  loss: 2.7240  loss_cls: 2.0732  loss_bbox: 0.6507\n",
+            "04/17 10:29:04 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: rtmdet_tiny_1xb4-20e_balloon_20230417_102835\n",
+            "04/17 10:29:05 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating bbox...\n",
+            "Loading and preparing results...\n",
+            "DONE (t=0.00s)\n",
+            "creating index...\n",
+            "index created!\n",
+            "Running per image evaluation...\n",
+            "Evaluate annotation type *bbox*\n",
+            "DONE (t=0.12s).\n",
+            "Accumulating evaluation results...\n",
+            "DONE (t=0.02s).\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.128\n",
+            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.165\n",
+            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.147\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.081\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.164\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.056\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.320\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.570\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.325\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.683\n",
+            "04/17 10:29:05 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - bbox_mAP_copypaste: 0.128 0.165 0.147 0.000 0.081 0.164\n",
+            "04/17 10:29:05 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [2][3/3]    coco/bbox_mAP: 0.1280  coco/bbox_mAP_50: 0.1650  coco/bbox_mAP_75: 0.1470  coco/bbox_mAP_s: 0.0000  coco/bbox_mAP_m: 0.0810  coco/bbox_mAP_l: 0.1640  data_time: 0.1576  time: 0.2254\n",
+            "04/17 10:29:05 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The previous best checkpoint /content/mmdetection/work_dirs/rtmdet_tiny_1xb4-20e_balloon/best_coco_bbox_mAP_epoch_1.pth is removed\n",
+            "04/17 10:29:06 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The best checkpoint with 0.1280 coco/bbox_mAP at 2 epoch is saved to best_coco_bbox_mAP_epoch_2.pth.\n",
+            "04/17 10:29:08 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [3][ 5/16]  lr: 8.0000e-05  eta: 0:02:06  time: 0.4462  data_time: 0.1025  memory: 1422  loss: 2.7154  loss_cls: 2.0725  loss_bbox: 0.6429\n",
+            "04/17 10:29:10 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [3][10/16]  lr: 8.0000e-05  eta: 0:02:01  time: 0.4378  data_time: 0.1003  memory: 1422  loss: 2.7268  loss_cls: 2.0980  loss_bbox: 0.6288\n",
+            "04/17 10:29:12 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [3][15/16]  lr: 8.0000e-05  eta: 0:01:54  time: 0.4192  data_time: 0.0922  memory: 1422  loss: 2.7336  loss_cls: 2.1177  loss_bbox: 0.6159\n",
+            "04/17 10:29:12 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: rtmdet_tiny_1xb4-20e_balloon_20230417_102835\n",
+            "04/17 10:29:12 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating bbox...\n",
+            "Loading and preparing results...\n",
+            "DONE (t=0.00s)\n",
+            "creating index...\n",
+            "index created!\n",
+            "Running per image evaluation...\n",
+            "Evaluate annotation type *bbox*\n",
+            "DONE (t=0.13s).\n",
+            "Accumulating evaluation results...\n",
+            "DONE (t=0.02s).\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.308\n",
+            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.381\n",
+            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.356\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.098\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.409\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.146\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.370\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.646\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.292\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.800\n",
+            "04/17 10:29:12 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - bbox_mAP_copypaste: 0.308 0.381 0.356 0.000 0.098 0.409\n",
+            "04/17 10:29:12 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [3][3/3]    coco/bbox_mAP: 0.3080  coco/bbox_mAP_50: 0.3810  coco/bbox_mAP_75: 0.3560  coco/bbox_mAP_s: 0.0000  coco/bbox_mAP_m: 0.0980  coco/bbox_mAP_l: 0.4090  data_time: 0.1456  time: 0.2063\n",
+            "04/17 10:29:12 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The previous best checkpoint /content/mmdetection/work_dirs/rtmdet_tiny_1xb4-20e_balloon/best_coco_bbox_mAP_epoch_2.pth is removed\n",
+            "04/17 10:29:14 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The best checkpoint with 0.3080 coco/bbox_mAP at 3 epoch is saved to best_coco_bbox_mAP_epoch_3.pth.\n",
+            "04/17 10:29:17 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [4][ 5/16]  lr: 8.0000e-05  eta: 0:01:54  time: 0.3957  data_time: 0.0830  memory: 1422  loss: 2.7228  loss_cls: 2.1246  loss_bbox: 0.5982\n",
+            "04/17 10:29:19 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [4][10/16]  lr: 8.0000e-05  eta: 0:01:54  time: 0.4205  data_time: 0.0934  memory: 1422  loss: 2.7104  loss_cls: 2.1374  loss_bbox: 0.5730\n",
+            "04/17 10:29:21 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [4][15/16]  lr: 8.0000e-05  eta: 0:01:51  time: 0.4289  data_time: 0.1029  memory: 1422  loss: 2.6786  loss_cls: 2.1263  loss_bbox: 0.5524\n",
+            "04/17 10:29:21 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: rtmdet_tiny_1xb4-20e_balloon_20230417_102835\n",
+            "04/17 10:29:22 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating bbox...\n",
+            "Loading and preparing results...\n",
+            "DONE (t=0.00s)\n",
+            "creating index...\n",
+            "index created!\n",
+            "Running per image evaluation...\n",
+            "Evaluate annotation type *bbox*\n",
+            "DONE (t=0.12s).\n",
+            "Accumulating evaluation results...\n",
+            "DONE (t=0.02s).\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.406\n",
+            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.531\n",
+            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.449\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.116\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.525\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.166\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.496\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.694\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.533\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.786\n",
+            "04/17 10:29:22 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - bbox_mAP_copypaste: 0.406 0.531 0.449 0.000 0.116 0.525\n",
+            "04/17 10:29:22 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [4][3/3]    coco/bbox_mAP: 0.4060  coco/bbox_mAP_50: 0.5310  coco/bbox_mAP_75: 0.4490  coco/bbox_mAP_s: 0.0000  coco/bbox_mAP_m: 0.1160  coco/bbox_mAP_l: 0.5250  data_time: 0.1390  time: 0.1964\n",
+            "04/17 10:29:22 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The previous best checkpoint /content/mmdetection/work_dirs/rtmdet_tiny_1xb4-20e_balloon/best_coco_bbox_mAP_epoch_3.pth is removed\n",
+            "04/17 10:29:23 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The best checkpoint with 0.4060 coco/bbox_mAP at 4 epoch is saved to best_coco_bbox_mAP_epoch_4.pth.\n",
+            "04/17 10:29:26 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [5][ 5/16]  lr: 8.0000e-05  eta: 0:01:46  time: 0.4261  data_time: 0.1005  memory: 1422  loss: 2.6337  loss_cls: 2.1077  loss_bbox: 0.5260\n",
+            "04/17 10:29:27 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [5][10/16]  lr: 8.0000e-05  eta: 0:01:43  time: 0.4038  data_time: 0.0969  memory: 1422  loss: 2.5711  loss_cls: 2.0661  loss_bbox: 0.5050\n",
+            "04/17 10:29:29 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [5][15/16]  lr: 8.0000e-05  eta: 0:01:39  time: 0.3730  data_time: 0.0887  memory: 1422  loss: 2.4938  loss_cls: 2.0094  loss_bbox: 0.4844\n",
+            "04/17 10:29:29 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: rtmdet_tiny_1xb4-20e_balloon_20230417_102835\n",
+            "04/17 10:29:29 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Saving checkpoint at 5 epochs\n",
+            "04/17 10:29:31 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating bbox...\n",
+            "Loading and preparing results...\n",
+            "DONE (t=0.01s)\n",
+            "creating index...\n",
+            "index created!\n",
+            "Running per image evaluation...\n",
+            "Evaluate annotation type *bbox*\n",
+            "DONE (t=0.25s).\n",
+            "Accumulating evaluation results...\n",
+            "DONE (t=0.03s).\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.426\n",
+            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.547\n",
+            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.476\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.110\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.556\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.170\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.508\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.678\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.417\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.803\n",
+            "04/17 10:29:31 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - bbox_mAP_copypaste: 0.426 0.547 0.476 0.000 0.110 0.556\n",
+            "04/17 10:29:31 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [5][3/3]    coco/bbox_mAP: 0.4260  coco/bbox_mAP_50: 0.5470  coco/bbox_mAP_75: 0.4760  coco/bbox_mAP_s: 0.0000  coco/bbox_mAP_m: 0.1100  coco/bbox_mAP_l: 0.5560  data_time: 0.1361  time: 0.1959\n",
+            "04/17 10:29:31 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The previous best checkpoint /content/mmdetection/work_dirs/rtmdet_tiny_1xb4-20e_balloon/best_coco_bbox_mAP_epoch_4.pth is removed\n",
+            "04/17 10:29:33 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The best checkpoint with 0.4260 coco/bbox_mAP at 5 epoch is saved to best_coco_bbox_mAP_epoch_5.pth.\n",
+            "04/17 10:29:37 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [6][ 5/16]  lr: 8.0000e-05  eta: 0:01:40  time: 0.4070  data_time: 0.1114  memory: 1422  loss: 2.4067  loss_cls: 1.9395  loss_bbox: 0.4673\n",
+            "04/17 10:29:39 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [6][10/16]  lr: 8.0000e-05  eta: 0:01:37  time: 0.4020  data_time: 0.1043  memory: 1422  loss: 2.3103  loss_cls: 1.8537  loss_bbox: 0.4566\n",
+            "04/17 10:29:40 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [6][15/16]  lr: 8.0000e-05  eta: 0:01:33  time: 0.4037  data_time: 0.1089  memory: 1422  loss: 2.2055  loss_cls: 1.7604  loss_bbox: 0.4451\n",
+            "04/17 10:29:40 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: rtmdet_tiny_1xb4-20e_balloon_20230417_102835\n",
+            "04/17 10:29:41 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating bbox...\n",
+            "Loading and preparing results...\n",
+            "DONE (t=0.00s)\n",
+            "creating index...\n",
+            "index created!\n",
+            "Running per image evaluation...\n",
+            "Evaluate annotation type *bbox*\n",
+            "DONE (t=0.12s).\n",
+            "Accumulating evaluation results...\n",
+            "DONE (t=0.02s).\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.455\n",
+            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.579\n",
+            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.492\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.173\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.584\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.160\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.582\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.702\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.517\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.803\n",
+            "04/17 10:29:41 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - bbox_mAP_copypaste: 0.455 0.579 0.492 0.000 0.173 0.584\n",
+            "04/17 10:29:41 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [6][3/3]    coco/bbox_mAP: 0.4550  coco/bbox_mAP_50: 0.5790  coco/bbox_mAP_75: 0.4920  coco/bbox_mAP_s: 0.0000  coco/bbox_mAP_m: 0.1730  coco/bbox_mAP_l: 0.5840  data_time: 0.1338  time: 0.1915\n",
+            "04/17 10:29:41 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The previous best checkpoint /content/mmdetection/work_dirs/rtmdet_tiny_1xb4-20e_balloon/best_coco_bbox_mAP_epoch_5.pth is removed\n",
+            "04/17 10:29:42 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The best checkpoint with 0.4550 coco/bbox_mAP at 6 epoch is saved to best_coco_bbox_mAP_epoch_6.pth.\n",
+            "04/17 10:29:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [7][ 5/16]  lr: 8.0000e-05  eta: 0:01:30  time: 0.4004  data_time: 0.1114  memory: 1422  loss: 2.0828  loss_cls: 1.6540  loss_bbox: 0.4288\n",
+            "04/17 10:29:46 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [7][10/16]  lr: 8.0000e-05  eta: 0:01:27  time: 0.3826  data_time: 0.1077  memory: 1422  loss: 1.9577  loss_cls: 1.5354  loss_bbox: 0.4222\n",
+            "04/17 10:29:48 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [7][15/16]  lr: 8.0000e-05  eta: 0:01:24  time: 0.3629  data_time: 0.0973  memory: 1422  loss: 1.8775  loss_cls: 1.4601  loss_bbox: 0.4174\n",
+            "04/17 10:29:48 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: rtmdet_tiny_1xb4-20e_balloon_20230417_102835\n",
+            "04/17 10:29:49 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating bbox...\n",
+            "Loading and preparing results...\n",
+            "DONE (t=0.01s)\n",
+            "creating index...\n",
+            "index created!\n",
+            "Running per image evaluation...\n",
+            "Evaluate annotation type *bbox*\n",
+            "DONE (t=0.25s).\n",
+            "Accumulating evaluation results...\n",
+            "DONE (t=0.03s).\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.494\n",
+            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.658\n",
+            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.558\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.186\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.613\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.174\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.578\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.726\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.575\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.817\n",
+            "04/17 10:29:49 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - bbox_mAP_copypaste: 0.494 0.658 0.558 0.000 0.186 0.613\n",
+            "04/17 10:29:49 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [7][3/3]    coco/bbox_mAP: 0.4940  coco/bbox_mAP_50: 0.6580  coco/bbox_mAP_75: 0.5580  coco/bbox_mAP_s: 0.0000  coco/bbox_mAP_m: 0.1860  coco/bbox_mAP_l: 0.6130  data_time: 0.1454  time: 0.2026\n",
+            "04/17 10:29:49 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The previous best checkpoint /content/mmdetection/work_dirs/rtmdet_tiny_1xb4-20e_balloon/best_coco_bbox_mAP_epoch_6.pth is removed\n",
+            "04/17 10:29:51 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The best checkpoint with 0.4940 coco/bbox_mAP at 7 epoch is saved to best_coco_bbox_mAP_epoch_7.pth.\n",
+            "04/17 10:29:54 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [8][ 5/16]  lr: 8.0000e-05  eta: 0:01:22  time: 0.3740  data_time: 0.1034  memory: 1422  loss: 1.7607  loss_cls: 1.3465  loss_bbox: 0.4142\n",
+            "04/17 10:29:55 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [8][10/16]  lr: 8.0000e-05  eta: 0:01:19  time: 0.3734  data_time: 0.1042  memory: 1422  loss: 1.6590  loss_cls: 1.2527  loss_bbox: 0.4064\n",
+            "04/17 10:29:56 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [8][15/16]  lr: 8.0000e-05  eta: 0:01:16  time: 0.3658  data_time: 0.0988  memory: 1422  loss: 1.5863  loss_cls: 1.1838  loss_bbox: 0.4025\n",
+            "04/17 10:29:56 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: rtmdet_tiny_1xb4-20e_balloon_20230417_102835\n",
+            "04/17 10:29:57 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating bbox...\n",
+            "Loading and preparing results...\n",
+            "DONE (t=0.00s)\n",
+            "creating index...\n",
+            "index created!\n",
+            "Running per image evaluation...\n",
+            "Evaluate annotation type *bbox*\n",
+            "DONE (t=0.11s).\n",
+            "Accumulating evaluation results...\n",
+            "DONE (t=0.02s).\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.542\n",
+            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.693\n",
+            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.620\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.231\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.666\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.190\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.618\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.740\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.625\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.819\n",
+            "04/17 10:29:57 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - bbox_mAP_copypaste: 0.542 0.693 0.620 0.000 0.231 0.666\n",
+            "04/17 10:29:57 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [8][3/3]    coco/bbox_mAP: 0.5420  coco/bbox_mAP_50: 0.6930  coco/bbox_mAP_75: 0.6200  coco/bbox_mAP_s: 0.0000  coco/bbox_mAP_m: 0.2310  coco/bbox_mAP_l: 0.6660  data_time: 0.1422  time: 0.1982\n",
+            "04/17 10:29:57 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The previous best checkpoint /content/mmdetection/work_dirs/rtmdet_tiny_1xb4-20e_balloon/best_coco_bbox_mAP_epoch_7.pth is removed\n",
+            "04/17 10:29:59 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The best checkpoint with 0.5420 coco/bbox_mAP at 8 epoch is saved to best_coco_bbox_mAP_epoch_8.pth.\n",
+            "04/17 10:30:01 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [9][ 5/16]  lr: 8.0000e-05  eta: 0:01:14  time: 0.3413  data_time: 0.0825  memory: 1422  loss: 1.4943  loss_cls: 1.1003  loss_bbox: 0.3940\n",
+            "04/17 10:30:03 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [9][10/16]  lr: 8.0000e-05  eta: 0:01:12  time: 0.3545  data_time: 0.0888  memory: 1422  loss: 1.4314  loss_cls: 1.0468  loss_bbox: 0.3846\n",
+            "04/17 10:30:05 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train)  [9][15/16]  lr: 8.0000e-05  eta: 0:01:10  time: 0.3613  data_time: 0.0938  memory: 1422  loss: 1.3590  loss_cls: 0.9855  loss_bbox: 0.3735\n",
+            "04/17 10:30:05 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: rtmdet_tiny_1xb4-20e_balloon_20230417_102835\n",
+            "04/17 10:30:06 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating bbox...\n",
+            "Loading and preparing results...\n",
+            "DONE (t=0.01s)\n",
+            "creating index...\n",
+            "index created!\n",
+            "Running per image evaluation...\n",
+            "Evaluate annotation type *bbox*\n",
+            "DONE (t=0.24s).\n",
+            "Accumulating evaluation results...\n",
+            "DONE (t=0.03s).\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.611\n",
+            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.725\n",
+            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.689\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.227\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.751\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.214\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.696\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.774\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.633\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.864\n",
+            "04/17 10:30:07 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - bbox_mAP_copypaste: 0.611 0.725 0.689 0.000 0.227 0.751\n",
+            "04/17 10:30:07 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [9][3/3]    coco/bbox_mAP: 0.6110  coco/bbox_mAP_50: 0.7250  coco/bbox_mAP_75: 0.6890  coco/bbox_mAP_s: 0.0000  coco/bbox_mAP_m: 0.2270  coco/bbox_mAP_l: 0.7510  data_time: 0.1471  time: 0.2029\n",
+            "04/17 10:30:07 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The previous best checkpoint /content/mmdetection/work_dirs/rtmdet_tiny_1xb4-20e_balloon/best_coco_bbox_mAP_epoch_8.pth is removed\n",
+            "04/17 10:30:08 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The best checkpoint with 0.6110 coco/bbox_mAP at 9 epoch is saved to best_coco_bbox_mAP_epoch_9.pth.\n",
+            "04/17 10:30:10 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [10][ 5/16]  lr: 8.0000e-05  eta: 0:01:08  time: 0.3742  data_time: 0.0985  memory: 1422  loss: 1.2606  loss_cls: 0.8955  loss_bbox: 0.3651\n",
+            "04/17 10:30:12 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [10][10/16]  lr: 8.0000e-05  eta: 0:01:05  time: 0.3687  data_time: 0.0901  memory: 1422  loss: 1.2161  loss_cls: 0.8550  loss_bbox: 0.3611\n",
+            "04/17 10:30:13 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [10][15/16]  lr: 8.0000e-05  eta: 0:01:03  time: 0.3582  data_time: 0.0862  memory: 1422  loss: 1.1586  loss_cls: 0.8081  loss_bbox: 0.3505\n",
+            "04/17 10:30:13 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: rtmdet_tiny_1xb4-20e_balloon_20230417_102835\n",
+            "04/17 10:30:13 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Saving checkpoint at 10 epochs\n",
+            "04/17 10:30:15 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating bbox...\n",
+            "Loading and preparing results...\n",
+            "DONE (t=0.00s)\n",
+            "creating index...\n",
+            "index created!\n",
+            "Running per image evaluation...\n",
+            "Evaluate annotation type *bbox*\n",
+            "DONE (t=0.12s).\n",
+            "Accumulating evaluation results...\n",
+            "DONE (t=0.02s).\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.623\n",
+            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.741\n",
+            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.698\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.273\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.761\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.226\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.670\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.768\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.642\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.853\n",
+            "04/17 10:30:16 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - bbox_mAP_copypaste: 0.623 0.741 0.698 0.000 0.273 0.761\n",
+            "04/17 10:30:16 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [10][3/3]    coco/bbox_mAP: 0.6230  coco/bbox_mAP_50: 0.7410  coco/bbox_mAP_75: 0.6980  coco/bbox_mAP_s: 0.0000  coco/bbox_mAP_m: 0.2730  coco/bbox_mAP_l: 0.7610  data_time: 0.1447  time: 0.2024\n",
+            "04/17 10:30:16 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The previous best checkpoint /content/mmdetection/work_dirs/rtmdet_tiny_1xb4-20e_balloon/best_coco_bbox_mAP_epoch_9.pth is removed\n",
+            "04/17 10:30:17 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The best checkpoint with 0.6230 coco/bbox_mAP at 10 epoch is saved to best_coco_bbox_mAP_epoch_10.pth.\n",
+            "04/17 10:30:20 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [11][ 5/16]  lr: 7.9883e-05  eta: 0:01:01  time: 0.3772  data_time: 0.0894  memory: 1422  loss: 1.0756  loss_cls: 0.7460  loss_bbox: 0.3297\n",
+            "04/17 10:30:22 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [11][10/16]  lr: 7.9408e-05  eta: 0:01:00  time: 0.3923  data_time: 0.0905  memory: 1422  loss: 1.0549  loss_cls: 0.7295  loss_bbox: 0.3254\n",
+            "04/17 10:30:24 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [11][15/16]  lr: 7.8573e-05  eta: 0:00:58  time: 0.4015  data_time: 0.1017  memory: 1422  loss: 1.0355  loss_cls: 0.7114  loss_bbox: 0.3241\n",
+            "04/17 10:30:24 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: rtmdet_tiny_1xb4-20e_balloon_20230417_102835\n",
+            "04/17 10:30:25 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating bbox...\n",
+            "Loading and preparing results...\n",
+            "DONE (t=0.00s)\n",
+            "creating index...\n",
+            "index created!\n",
+            "Running per image evaluation...\n",
+            "Evaluate annotation type *bbox*\n",
+            "DONE (t=0.11s).\n",
+            "Accumulating evaluation results...\n",
+            "DONE (t=0.02s).\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.645\n",
+            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.772\n",
+            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.709\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.231\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.778\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.226\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.686\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.782\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.692\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.856\n",
+            "04/17 10:30:25 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - bbox_mAP_copypaste: 0.645 0.772 0.709 0.000 0.231 0.778\n",
+            "04/17 10:30:25 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [11][3/3]    coco/bbox_mAP: 0.6450  coco/bbox_mAP_50: 0.7720  coco/bbox_mAP_75: 0.7090  coco/bbox_mAP_s: 0.0000  coco/bbox_mAP_m: 0.2310  coco/bbox_mAP_l: 0.7780  data_time: 0.1423  time: 0.1990\n",
+            "04/17 10:30:25 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The previous best checkpoint /content/mmdetection/work_dirs/rtmdet_tiny_1xb4-20e_balloon/best_coco_bbox_mAP_epoch_10.pth is removed\n",
+            "04/17 10:30:26 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The best checkpoint with 0.6450 coco/bbox_mAP at 11 epoch is saved to best_coco_bbox_mAP_epoch_11.pth.\n",
+            "04/17 10:30:29 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [12][ 5/16]  lr: 7.7107e-05  eta: 0:00:55  time: 0.4071  data_time: 0.1000  memory: 1422  loss: 0.9773  loss_cls: 0.6681  loss_bbox: 0.3092\n",
+            "04/17 10:30:30 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [12][10/16]  lr: 7.5513e-05  eta: 0:00:53  time: 0.4009  data_time: 0.0986  memory: 1422  loss: 0.9503  loss_cls: 0.6470  loss_bbox: 0.3033\n",
+            "04/17 10:30:32 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [12][15/16]  lr: 7.3596e-05  eta: 0:00:50  time: 0.3808  data_time: 0.0966  memory: 1422  loss: 0.9250  loss_cls: 0.6268  loss_bbox: 0.2982\n",
+            "04/17 10:30:32 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: rtmdet_tiny_1xb4-20e_balloon_20230417_102835\n",
+            "04/17 10:30:32 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating bbox...\n",
+            "Loading and preparing results...\n",
+            "DONE (t=0.00s)\n",
+            "creating index...\n",
+            "index created!\n",
+            "Running per image evaluation...\n",
+            "Evaluate annotation type *bbox*\n",
+            "DONE (t=0.12s).\n",
+            "Accumulating evaluation results...\n",
+            "DONE (t=0.02s).\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.617\n",
+            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.751\n",
+            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.696\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.218\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.750\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.210\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.662\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.760\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.633\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.844\n",
+            "04/17 10:30:33 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - bbox_mAP_copypaste: 0.617 0.751 0.696 0.000 0.218 0.750\n",
+            "04/17 10:30:33 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [12][3/3]    coco/bbox_mAP: 0.6170  coco/bbox_mAP_50: 0.7510  coco/bbox_mAP_75: 0.6960  coco/bbox_mAP_s: 0.0000  coco/bbox_mAP_m: 0.2180  coco/bbox_mAP_l: 0.7500  data_time: 0.1405  time: 0.1964\n",
+            "04/17 10:30:36 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [13][ 5/16]  lr: 7.0895e-05  eta: 0:00:49  time: 0.4001  data_time: 0.1021  memory: 1422  loss: 0.9386  loss_cls: 0.6415  loss_bbox: 0.2971\n",
+            "04/17 10:30:39 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [13][10/16]  lr: 6.8337e-05  eta: 0:00:47  time: 0.4275  data_time: 0.1168  memory: 1422  loss: 0.9174  loss_cls: 0.6254  loss_bbox: 0.2920\n",
+            "04/17 10:30:41 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [13][15/16]  lr: 6.5526e-05  eta: 0:00:45  time: 0.4284  data_time: 0.1216  memory: 1422  loss: 0.9057  loss_cls: 0.6122  loss_bbox: 0.2935\n",
+            "04/17 10:30:41 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: rtmdet_tiny_1xb4-20e_balloon_20230417_102835\n",
+            "04/17 10:30:41 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating bbox...\n",
+            "Loading and preparing results...\n",
+            "DONE (t=0.00s)\n",
+            "creating index...\n",
+            "index created!\n",
+            "Running per image evaluation...\n",
+            "Evaluate annotation type *bbox*\n",
+            "DONE (t=0.11s).\n",
+            "Accumulating evaluation results...\n",
+            "DONE (t=0.02s).\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.635\n",
+            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.755\n",
+            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.718\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.242\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.771\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.210\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.680\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.774\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.642\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.861\n",
+            "04/17 10:30:42 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - bbox_mAP_copypaste: 0.635 0.755 0.718 0.000 0.242 0.771\n",
+            "04/17 10:30:42 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [13][3/3]    coco/bbox_mAP: 0.6350  coco/bbox_mAP_50: 0.7550  coco/bbox_mAP_75: 0.7180  coco/bbox_mAP_s: 0.0000  coco/bbox_mAP_m: 0.2420  coco/bbox_mAP_l: 0.7710  data_time: 0.1386  time: 0.1939\n",
+            "04/17 10:30:44 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [14][ 5/16]  lr: 6.1855e-05  eta: 0:00:43  time: 0.4110  data_time: 0.1137  memory: 1422  loss: 0.9190  loss_cls: 0.6193  loss_bbox: 0.2997\n",
+            "04/17 10:30:45 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [14][10/16]  lr: 5.8584e-05  eta: 0:00:40  time: 0.4015  data_time: 0.1135  memory: 1422  loss: 0.9312  loss_cls: 0.6258  loss_bbox: 0.3054\n",
+            "04/17 10:30:47 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [14][15/16]  lr: 5.5152e-05  eta: 0:00:38  time: 0.3801  data_time: 0.1030  memory: 1422  loss: 0.9122  loss_cls: 0.6111  loss_bbox: 0.3011\n",
+            "04/17 10:30:47 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: rtmdet_tiny_1xb4-20e_balloon_20230417_102835\n",
+            "04/17 10:30:47 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating bbox...\n",
+            "Loading and preparing results...\n",
+            "DONE (t=0.00s)\n",
+            "creating index...\n",
+            "index created!\n",
+            "Running per image evaluation...\n",
+            "Evaluate annotation type *bbox*\n",
+            "DONE (t=0.11s).\n",
+            "Accumulating evaluation results...\n",
+            "DONE (t=0.02s).\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.636\n",
+            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.739\n",
+            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.708\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.220\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.782\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.222\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.690\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.788\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.683\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.867\n",
+            "04/17 10:30:47 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - bbox_mAP_copypaste: 0.636 0.739 0.708 0.000 0.220 0.782\n",
+            "04/17 10:30:47 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [14][3/3]    coco/bbox_mAP: 0.6360  coco/bbox_mAP_50: 0.7390  coco/bbox_mAP_75: 0.7080  coco/bbox_mAP_s: 0.0000  coco/bbox_mAP_m: 0.2200  coco/bbox_mAP_l: 0.7820  data_time: 0.1371  time: 0.1918\n",
+            "04/17 10:30:50 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [15][ 5/16]  lr: 5.0871e-05  eta: 0:00:36  time: 0.3939  data_time: 0.1054  memory: 1422  loss: 0.8896  loss_cls: 0.5903  loss_bbox: 0.2993\n",
+            "04/17 10:30:53 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [15][10/16]  lr: 4.7206e-05  eta: 0:00:34  time: 0.4165  data_time: 0.1144  memory: 1422  loss: 0.8796  loss_cls: 0.5829  loss_bbox: 0.2967\n",
+            "04/17 10:30:55 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [15][15/16]  lr: 4.3492e-05  eta: 0:00:32  time: 0.4306  data_time: 0.1161  memory: 1422  loss: 0.8680  loss_cls: 0.5699  loss_bbox: 0.2981\n",
+            "04/17 10:30:55 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: rtmdet_tiny_1xb4-20e_balloon_20230417_102835\n",
+            "04/17 10:30:55 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Saving checkpoint at 15 epochs\n",
+            "04/17 10:30:57 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating bbox...\n",
+            "Loading and preparing results...\n",
+            "DONE (t=0.00s)\n",
+            "creating index...\n",
+            "index created!\n",
+            "Running per image evaluation...\n",
+            "Evaluate annotation type *bbox*\n",
+            "DONE (t=0.11s).\n",
+            "Accumulating evaluation results...\n",
+            "DONE (t=0.01s).\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.644\n",
+            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.750\n",
+            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.701\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.232\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.788\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.224\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.686\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.790\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.692\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.867\n",
+            "04/17 10:30:57 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - bbox_mAP_copypaste: 0.644 0.750 0.701 0.000 0.232 0.788\n",
+            "04/17 10:30:57 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [15][3/3]    coco/bbox_mAP: 0.6440  coco/bbox_mAP_50: 0.7500  coco/bbox_mAP_75: 0.7010  coco/bbox_mAP_s: 0.0000  coco/bbox_mAP_m: 0.2320  coco/bbox_mAP_l: 0.7880  data_time: 0.1364  time: 0.1922\n",
+            "04/17 10:30:59 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [16][ 5/16]  lr: 3.9019e-05  eta: 0:00:30  time: 0.4257  data_time: 0.1152  memory: 1422  loss: 0.8383  loss_cls: 0.5478  loss_bbox: 0.2904\n",
+            "04/17 10:31:01 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [16][10/16]  lr: 3.5320e-05  eta: 0:00:28  time: 0.3921  data_time: 0.0945  memory: 1422  loss: 0.8302  loss_cls: 0.5349  loss_bbox: 0.2953\n",
+            "04/17 10:31:03 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [16][15/16]  lr: 3.1685e-05  eta: 0:00:25  time: 0.3721  data_time: 0.0851  memory: 1422  loss: 0.8413  loss_cls: 0.5464  loss_bbox: 0.2949\n",
+            "04/17 10:31:03 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: rtmdet_tiny_1xb4-20e_balloon_20230417_102835\n",
+            "04/17 10:31:03 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating bbox...\n",
+            "Loading and preparing results...\n",
+            "DONE (t=0.00s)\n",
+            "creating index...\n",
+            "index created!\n",
+            "Running per image evaluation...\n",
+            "Evaluate annotation type *bbox*\n",
+            "DONE (t=0.12s).\n",
+            "Accumulating evaluation results...\n",
+            "DONE (t=0.01s).\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.667\n",
+            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.769\n",
+            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.741\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.264\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.800\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.218\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.714\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.802\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.708\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.878\n",
+            "04/17 10:31:03 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - bbox_mAP_copypaste: 0.667 0.769 0.741 0.000 0.264 0.800\n",
+            "04/17 10:31:03 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [16][3/3]    coco/bbox_mAP: 0.6670  coco/bbox_mAP_50: 0.7690  coco/bbox_mAP_75: 0.7410  coco/bbox_mAP_s: 0.0000  coco/bbox_mAP_m: 0.2640  coco/bbox_mAP_l: 0.8000  data_time: 0.1355  time: 0.1909\n",
+            "04/17 10:31:03 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The previous best checkpoint /content/mmdetection/work_dirs/rtmdet_tiny_1xb4-20e_balloon/best_coco_bbox_mAP_epoch_11.pth is removed\n",
+            "04/17 10:31:05 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The best checkpoint with 0.6670 coco/bbox_mAP at 16 epoch is saved to best_coco_bbox_mAP_epoch_16.pth.\n",
+            "04/17 10:31:08 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [17][ 5/16]  lr: 2.7458e-05  eta: 0:00:23  time: 0.3927  data_time: 0.0868  memory: 1422  loss: 0.8335  loss_cls: 0.5406  loss_bbox: 0.2929\n",
+            "04/17 10:31:10 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [17][10/16]  lr: 2.4087e-05  eta: 0:00:21  time: 0.4168  data_time: 0.0975  memory: 1422  loss: 0.8255  loss_cls: 0.5369  loss_bbox: 0.2886\n",
+            "04/17 10:31:12 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [17][15/16]  lr: 2.0888e-05  eta: 0:00:19  time: 0.4215  data_time: 0.0995  memory: 1422  loss: 0.7952  loss_cls: 0.5153  loss_bbox: 0.2799\n",
+            "04/17 10:31:12 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: rtmdet_tiny_1xb4-20e_balloon_20230417_102835\n",
+            "04/17 10:31:13 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating bbox...\n",
+            "Loading and preparing results...\n",
+            "DONE (t=0.00s)\n",
+            "creating index...\n",
+            "index created!\n",
+            "Running per image evaluation...\n",
+            "Evaluate annotation type *bbox*\n",
+            "DONE (t=0.11s).\n",
+            "Accumulating evaluation results...\n",
+            "DONE (t=0.02s).\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.670\n",
+            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.769\n",
+            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.736\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.262\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.811\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.220\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.702\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.796\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.667\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.883\n",
+            "04/17 10:31:13 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - bbox_mAP_copypaste: 0.670 0.769 0.736 0.000 0.262 0.811\n",
+            "04/17 10:31:13 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [17][3/3]    coco/bbox_mAP: 0.6700  coco/bbox_mAP_50: 0.7690  coco/bbox_mAP_75: 0.7360  coco/bbox_mAP_s: 0.0000  coco/bbox_mAP_m: 0.2620  coco/bbox_mAP_l: 0.8110  data_time: 0.1274  time: 0.1807\n",
+            "04/17 10:31:13 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The previous best checkpoint /content/mmdetection/work_dirs/rtmdet_tiny_1xb4-20e_balloon/best_coco_bbox_mAP_epoch_16.pth is removed\n",
+            "04/17 10:31:14 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - The best checkpoint with 0.6700 coco/bbox_mAP at 17 epoch is saved to best_coco_bbox_mAP_epoch_17.pth.\n",
+            "04/17 10:31:17 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [18][ 5/16]  lr: 1.7321e-05  eta: 0:00:17  time: 0.4258  data_time: 0.0986  memory: 1422  loss: 0.8050  loss_cls: 0.5228  loss_bbox: 0.2821\n",
+            "04/17 10:31:18 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [18][10/16]  lr: 1.4608e-05  eta: 0:00:15  time: 0.3996  data_time: 0.0886  memory: 1422  loss: 0.8288  loss_cls: 0.5427  loss_bbox: 0.2861\n",
+            "04/17 10:31:19 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [18][15/16]  lr: 1.2158e-05  eta: 0:00:13  time: 0.3710  data_time: 0.0774  memory: 1422  loss: 0.8460  loss_cls: 0.5555  loss_bbox: 0.2906\n",
+            "04/17 10:31:19 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: rtmdet_tiny_1xb4-20e_balloon_20230417_102835\n",
+            "04/17 10:31:20 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating bbox...\n",
+            "Loading and preparing results...\n",
+            "DONE (t=0.00s)\n",
+            "creating index...\n",
+            "index created!\n",
+            "Running per image evaluation...\n",
+            "Evaluate annotation type *bbox*\n",
+            "DONE (t=0.11s).\n",
+            "Accumulating evaluation results...\n",
+            "DONE (t=0.02s).\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.657\n",
+            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.755\n",
+            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.720\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.243\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.802\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.222\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.696\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.788\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.658\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.875\n",
+            "04/17 10:31:20 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - bbox_mAP_copypaste: 0.657 0.755 0.720 0.000 0.243 0.802\n",
+            "04/17 10:31:20 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [18][3/3]    coco/bbox_mAP: 0.6570  coco/bbox_mAP_50: 0.7550  coco/bbox_mAP_75: 0.7200  coco/bbox_mAP_s: 0.0000  coco/bbox_mAP_m: 0.2430  coco/bbox_mAP_l: 0.8020  data_time: 0.1262  time: 0.1788\n",
+            "04/17 10:31:23 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [19][ 5/16]  lr: 9.5997e-06  eta: 0:00:10  time: 0.3893  data_time: 0.0942  memory: 1422  loss: 0.8529  loss_cls: 0.5586  loss_bbox: 0.2943\n",
+            "04/17 10:31:25 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [19][10/16]  lr: 7.8096e-06  eta: 0:00:08  time: 0.3976  data_time: 0.0917  memory: 1422  loss: 0.8404  loss_cls: 0.5487  loss_bbox: 0.2917\n",
+            "04/17 10:31:28 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [19][15/16]  lr: 6.3487e-06  eta: 0:00:06  time: 0.4112  data_time: 0.0973  memory: 1422  loss: 0.8332  loss_cls: 0.5454  loss_bbox: 0.2878\n",
+            "04/17 10:31:28 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: rtmdet_tiny_1xb4-20e_balloon_20230417_102835\n",
+            "04/17 10:31:28 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating bbox...\n",
+            "Loading and preparing results...\n",
+            "DONE (t=0.00s)\n",
+            "creating index...\n",
+            "index created!\n",
+            "Running per image evaluation...\n",
+            "Evaluate annotation type *bbox*\n",
+            "DONE (t=0.11s).\n",
+            "Accumulating evaluation results...\n",
+            "DONE (t=0.02s).\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.648\n",
+            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.758\n",
+            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.714\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.278\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.786\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.220\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.682\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.788\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.692\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.864\n",
+            "04/17 10:31:28 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - bbox_mAP_copypaste: 0.648 0.758 0.714 0.000 0.278 0.786\n",
+            "04/17 10:31:28 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [19][3/3]    coco/bbox_mAP: 0.6480  coco/bbox_mAP_50: 0.7580  coco/bbox_mAP_75: 0.7140  coco/bbox_mAP_s: 0.0000  coco/bbox_mAP_m: 0.2780  coco/bbox_mAP_l: 0.7860  data_time: 0.1265  time: 0.1790\n",
+            "04/17 10:31:28 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Switch pipeline now!\n",
+            "04/17 10:31:30 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [20][ 5/16]  lr: 5.0499e-06  eta: 0:00:04  time: 0.3946  data_time: 0.0911  memory: 1422  loss: 0.8398  loss_cls: 0.5569  loss_bbox: 0.2829\n",
+            "04/17 10:31:31 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [20][10/16]  lr: 4.3584e-06  eta: 0:00:02  time: 0.3541  data_time: 0.0729  memory: 1422  loss: 0.8475  loss_cls: 0.5686  loss_bbox: 0.2789\n",
+            "04/17 10:31:32 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(train) [20][15/16]  lr: 4.0293e-06  eta: 0:00:00  time: 0.3273  data_time: 0.0671  memory: 1422  loss: 0.8943  loss_cls: 0.6161  loss_bbox: 0.2783\n",
+            "04/17 10:31:32 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Exp name: rtmdet_tiny_1xb4-20e_balloon_20230417_102835\n",
+            "04/17 10:31:32 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Saving checkpoint at 20 epochs\n",
+            "04/17 10:31:34 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Evaluating bbox...\n",
+            "Loading and preparing results...\n",
+            "DONE (t=0.00s)\n",
+            "creating index...\n",
+            "index created!\n",
+            "Running per image evaluation...\n",
+            "Evaluate annotation type *bbox*\n",
+            "DONE (t=0.11s).\n",
+            "Accumulating evaluation results...\n",
+            "DONE (t=0.01s).\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.652\n",
+            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.794\n",
+            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.750\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.241\n",
+            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.785\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.222\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.706\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.782\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.675\n",
+            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.861\n",
+            "04/17 10:31:34 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - bbox_mAP_copypaste: 0.652 0.794 0.750 0.000 0.241 0.785\n",
+            "04/17 10:31:34 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Epoch(val) [20][3/3]    coco/bbox_mAP: 0.6520  coco/bbox_mAP_50: 0.7940  coco/bbox_mAP_75: 0.7500  coco/bbox_mAP_s: 0.0000  coco/bbox_mAP_m: 0.2410  coco/bbox_mAP_l: 0.7850  data_time: 0.1265  time: 0.1808\n"
+          ]
+        }
+      ],
+      "source": [
+        "!python tools/train.py configs/rtmdet/rtmdet_tiny_1xb4-20e_balloon.py"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "_vYQF5K2NqqI"
+      },
+      "source": [
+        "### Understand the log\n",
+        "From the log, we can have a basic understanding on the training process and know how well the detector is trained.\n",
+        "\n",
+        "First, since the dataset we are using is small, we loaded a pre-trained Faster R-CNN model and fine-tune it for detection. \n",
+        "The original Faster R-CNN is trained on COCO dataset that contains 80 classes but KITTI Tiny dataset only have 3 classes. Therefore, the last FC layers of the pre-trained Faster R-CNN for classification and regression have different weight shape and are not used.\n",
+        "\n",
+        "Second, after training, the detector is evaluated by the default VOC-style evaluation. The results show that the detector achieves 58.1 mAP on the val dataset, not bad!\n",
+        "\n",
+        "We can also check the tensorboard to see the curves."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 12,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 821,
+          "resources": {
+            "https://localhost:6006/?tensorboardColab=true": {
+              "data": "<!doctype html><meta name="tb-relative-root" content="./"><!doctype html><!--
@license
Copyright 2019 The TensorFlow Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
--><html><head><meta charset="utf-8">
<title>TensorBoard</title>
<script type="text/javascript" nonce="afdfeef6475a41f0acc820ac7b4" src="//injections.adguard.org?ts=1681724588597&amp;type=content-script&amp;dmn=colab.research.google.com&amp;pth=%2Ftun%2Fm%2Fgpu-t4-s-39sy895222pxy%2F_proxy%2F6006%2F%3FtensorboardColab%3Dtrue%26authuser%3D0&amp;app=chrome.exe&amp;css=3&amp;js=1&amp;rel=1&amp;rji=1&amp;sbe=1&amp;stealth=1&amp;uag="></script>
<script type="text/javascript" nonce="afdfeef6475a41f0acc820ac7b4" src="//injections.adguard.org?ts=1681724588597&amp;name=AdGuard%20Assistant&amp;name=AdGuard%20Extra&amp;type=user-script"></script><link rel="shortcut icon" href="data:image/png;base64,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">
<link rel="apple-touch-icon" href="data:image/png;base64,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">

<style>
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/uYECMKoHcO9x1wdmbyHIm3-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/sTdaA6j0Psb920Vjv-mrzH-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/_VYFx-s824kXq_Ul2BHqYH-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/tnj4SB6DNbdaQnsM8CFqBX-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/oMMgfZMQthOryQo9n22dcuvvDin1pK8aKteLpeZ5c0A.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/Ks_cVxiCiwUWVsFWFA3Bjn-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/NJ4vxlgWwWbEsv18dAhqnn-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/isZ-wbCXNKAbnjo6_TwHToX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/77FXFjRbGzN4aCrSFhlh3oX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/jSN2CGVDbcVyCnfJfjSdfIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/UX6i4JxQDm3fVTc1CPuwqoX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/d-6IYplOFocCacKzxwXSOJBw1xU1rKptJj_0jans920.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/97uahxiqZRoncBaCEI3aW4X0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/PwZc-YbIL414wB9rB1IAPYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC14sYYdJg5dU2qzJEVSuta0.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC_ZraR2Tg8w2lzm7kLNL0-w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcCwt_Rm691LTebKfY2ZkKSmI.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC1BW26QxpSj-_ZKm_xT4hWw.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC4gp9Q8gbYrhqGlRav_IXfk.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC6E8kM4xWR1_1bYURRojRGc.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC9DiNsR5a-9Oe_Ivpu8XWlY.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/OpXUqTo0UgQQhGj_SFdLWBkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/WxrXJa0C3KdtC7lMafG4dRkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/cDKhRaXnQTOVbaoxwdOr9xkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/1hZf02POANh32k2VkgEoUBkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/vPcynSL0qHq_6dX7lKVByXYhjbSpvc47ee6xR_80Hnw.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/vSzulfKSK0LLjjfeaxcREhkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/K23cxWVTrIFD6DJsEVi07RkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/Fl4y0QdOxyyTHEGMXX8kcYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/0eC6fl06luXEYWpBSJvXCIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/I3S1wsgSg9YCurV6PUkTOYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/-L14Jk06m6pUHB-5mXQQnYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/Hgo13k-tfSpn0qi1SFdUfZBw1xU1rKptJj_0jans920.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/Pru33qjShpZSmG3z6VYwnYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/NYDWBdD4gIq26G5XYbHsFIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at14sYYdJg5dU2qzJEVSuta0.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at_ZraR2Tg8w2lzm7kLNL0-w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0atwt_Rm691LTebKfY2ZkKSmI.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at1BW26QxpSj-_ZKm_xT4hWw.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at4gp9Q8gbYrhqGlRav_IXfk.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at6E8kM4xWR1_1bYURRojRGc.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at9DiNsR5a-9Oe_Ivpu8XWlY.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/oHi30kwQWvpCWqAhzHcCSIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/ZLqKeelYbATG60EpZBSDy4X0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/mx9Uck6uB63VIKFYnEMXrYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/rGvHdJnr2l75qb0YND9NyIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/RxZJdnzeo3R5zSexge8UUZBw1xU1rKptJj_0jans920.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/oOeFwZNlrTefzLYmlVV1UIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/mbmhprMH69Zi6eEPBYVFhYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0V4sYYdJg5dU2qzJEVSuta0.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0fZraR2Tg8w2lzm7kLNL0-w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0Qt_Rm691LTebKfY2ZkKSmI.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0VBW26QxpSj-_ZKm_xT4hWw.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0Ygp9Q8gbYrhqGlRav_IXfk.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0aE8kM4xWR1_1bYURRojRGc.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0dDiNsR5a-9Oe_Ivpu8XWlY.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY14sYYdJg5dU2qzJEVSuta0.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY_ZraR2Tg8w2lzm7kLNL0-w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpYwt_Rm691LTebKfY2ZkKSmI.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY1BW26QxpSj-_ZKm_xT4hWw.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY4gp9Q8gbYrhqGlRav_IXfk.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY6E8kM4xWR1_1bYURRojRGc.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY9DiNsR5a-9Oe_Ivpu8XWlY.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz1x-M1I1w5OMiqnVF8xBLhU.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59FzwXaAXup5mZlfK6xRLrhsco.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fzwn6Wqxo-xwxilDXPU8chVU.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz1T7aJLK6nKpn36IMwTcMMc.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz_79_ZuUxCigM2DespTnFaw.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz4gd9OEPUCN3AdYW0e8tat4.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz8bIQSYZnWLaWC9QNCpTK_U.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
</style>



<style>.mat-badge-content{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small .mat-badge-content{font-size:9px}.mat-badge-large .mat-badge-content{font-size:24px}.mat-h1,.mat-headline,.mat-typography .mat-h1,.mat-typography .mat-headline,.mat-typography h1{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2,.mat-title,.mat-typography .mat-h2,.mat-typography .mat-title,.mat-typography h2{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3,.mat-subheading-2,.mat-typography .mat-h3,.mat-typography .mat-subheading-2,.mat-typography h3{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4,.mat-subheading-1,.mat-typography .mat-h4,.mat-typography .mat-subheading-1,.mat-typography h4{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5,.mat-typography .mat-h5,.mat-typography h5{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6,.mat-typography .mat-h6,.mat-typography h6{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong,.mat-body-2,.mat-typography .mat-body-strong,.mat-typography .mat-body-2{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body,.mat-body-1,.mat-typography .mat-body,.mat-typography .mat-body-1,.mat-typography{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body p,.mat-body-1 p,.mat-typography .mat-body p,.mat-typography .mat-body-1 p,.mat-typography p{margin:0 0 12px}.mat-small,.mat-caption,.mat-typography .mat-small,.mat-typography .mat-caption{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4,.mat-typography .mat-display-4{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3,.mat-typography .mat-display-3{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2,.mat-typography .mat-display-2{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1,.mat-typography .mat-display-1{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button,.mat-raised-button,.mat-icon-button,.mat-stroked-button,.mat-flat-button,.mat-fab,.mat-mini-fab{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title{font-size:24px;font-weight:500}.mat-card-header .mat-card-title{font-size:20px}.mat-card-subtitle,.mat-card-content{font-size:14px}.mat-checkbox{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout .mat-checkbox-label{line-height:24px}.mat-chip{font-size:14px;font-weight:500}.mat-chip .mat-chip-trailing-icon.mat-icon,.mat-chip .mat-chip-remove.mat-icon{font-size:18px}.mat-table{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell{font-size:12px;font-weight:500}.mat-cell,.mat-footer-cell{font-size:14px}.mat-calendar{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body{font-size:13px}.mat-calendar-body-label,.mat-calendar-period-button{font-size:14px;font-weight:500}.mat-calendar-table-header th{font-size:11px;font-weight:400}.mat-dialog-title{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper{padding-bottom:1.34375em}.mat-form-field-prefix .mat-icon,.mat-form-field-suffix .mat-icon{font-size:150%;line-height:1.125}.mat-form-field-prefix .mat-icon-button,.mat-form-field-suffix .mat-icon-button{height:1.5em;width:1.5em}.mat-form-field-prefix .mat-icon-button .mat-icon,.mat-form-field-suffix .mat-icon-button .mat-icon{height:1.125em;line-height:1.125}.mat-form-field-infix{padding:.5em 0;border-top:.84375em solid rgba(0,0,0,0)}.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float .mat-input-server[label]:not(:label-shown)+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper{top:-0.84375em;padding-top:.84375em}.mat-form-field-label{top:1.34375em}.mat-form-field-underline{bottom:1.34375em}.mat-form-field-subscript-wrapper{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy .mat-form-field-wrapper{padding-bottom:1.25em}.mat-form-field-appearance-legacy .mat-form-field-infix{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-form-field-autofill-control:-webkit-autofill+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server[label]:not(:label-shown)+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);width:133.3333533333%}.mat-form-field-appearance-legacy .mat-form-field-label{top:1.28125em}.mat-form-field-appearance-legacy .mat-form-field-underline{bottom:1.25em}.mat-form-field-appearance-legacy .mat-form-field-subscript-wrapper{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-form-field-autofill-control:-webkit-autofill+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server[label]:not(:label-shown)+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill .mat-form-field-infix{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill .mat-form-field-label{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-fill.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float .mat-input-server[label]:not(:label-shown)+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline .mat-form-field-infix{padding:1em 0 1em 0}.mat-form-field-appearance-outline .mat-form-field-label{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-outline.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float .mat-input-server[label]:not(:label-shown)+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header,.mat-grid-tile-footer{font-size:14px}.mat-grid-tile-header .mat-line,.mat-grid-tile-footer .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header .mat-line:nth-child(n+2),.mat-grid-tile-footer .mat-line:nth-child(n+2){font-size:12px}input.mat-input-element{margin-top:-0.0625em}.mat-menu-item{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator,.mat-paginator-page-size .mat-select-trigger{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger{height:1.125em}.mat-slide-toggle-content{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical,.mat-stepper-horizontal{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label{font-size:14px;font-weight:400}.mat-step-sub-label-error{font-weight:normal}.mat-step-label-error{font-size:14px}.mat-step-label-selected{font-size:14px;font-weight:500}.mat-tab-group{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label,.mat-tab-link{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar,.mat-toolbar h1,.mat-toolbar h2,.mat-toolbar h3,.mat-toolbar h4,.mat-toolbar h5,.mat-toolbar h6{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base .mat-list-item{font-size:16px}.mat-list-base .mat-list-item .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base .mat-list-item .mat-line:nth-child(n+2){font-size:14px}.mat-list-base .mat-list-option{font-size:16px}.mat-list-base .mat-list-option .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base .mat-list-option .mat-line:nth-child(n+2){font-size:14px}.mat-list-base .mat-subheader{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense] .mat-list-item{font-size:12px}.mat-list-base[dense] .mat-list-item .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense] .mat-list-item .mat-line:nth-child(n+2){font-size:12px}.mat-list-base[dense] .mat-list-option{font-size:12px}.mat-list-base[dense] .mat-list-option .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense] .mat-list-option .mat-line:nth-child(n+2){font-size:12px}.mat-list-base[dense] .mat-subheader{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node,.mat-nested-tree-node{font-weight:400;font-size:14px}.mat-ripple{overflow:hidden;position:relative}.mat-ripple:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded{overflow:visible}.mat-ripple-element{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale3d(0, 0, 0)}.cdk-high-contrast-active .mat-ripple-element{display:none}.cdk-visually-hidden{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;white-space:nowrap;outline:0;-webkit-appearance:none;-moz-appearance:none;left:0}[dir=rtl] .cdk-visually-hidden{left:auto;right:0}.cdk-overlay-container,.cdk-global-overlay-wrapper{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container{position:fixed;z-index:1000}.cdk-overlay-container:empty{display:none}.cdk-global-overlay-wrapper{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:rgba(0,0,0,0);transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing{opacity:1}.cdk-high-contrast-active .cdk-overlay-backdrop.cdk-overlay-backdrop-showing{opacity:.6}.cdk-overlay-dark-backdrop{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop{transition:visibility 1ms linear,opacity 1ms linear;visibility:hidden;opacity:1}.cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing{opacity:0;visibility:visible}.cdk-overlay-backdrop-noop-animation{transition:none}.cdk-overlay-connected-position-bounding-box{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock{position:fixed;width:100%;overflow-y:scroll}textarea.cdk-textarea-autosize{resize:none}textarea.cdk-textarea-autosize-measuring{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}@keyframes cdk-text-field-autofill-start{/*!*/}@keyframes cdk-text-field-autofill-end{/*!*/}.cdk-text-field-autofill-monitored:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}.mat-focus-indicator{position:relative}.mat-focus-indicator::before{top:0;left:0;right:0;bottom:0;position:absolute;box-sizing:border-box;pointer-events:none;display:var(--mat-focus-indicator-display, none);border:var(--mat-focus-indicator-border-width, 3px) var(--mat-focus-indicator-border-style, solid) var(--mat-focus-indicator-border-color, transparent);border-radius:var(--mat-focus-indicator-border-radius, 4px)}.mat-focus-indicator:focus::before{content:""}.cdk-high-contrast-active{--mat-focus-indicator-display: block}.mat-mdc-focus-indicator{position:relative}.mat-mdc-focus-indicator::before{top:0;left:0;right:0;bottom:0;position:absolute;box-sizing:border-box;pointer-events:none;display:var(--mat-mdc-focus-indicator-display, none);border:var(--mat-mdc-focus-indicator-border-width, 3px) var(--mat-mdc-focus-indicator-border-style, solid) var(--mat-mdc-focus-indicator-border-color, transparent);border-radius:var(--mat-mdc-focus-indicator-border-radius, 4px)}.mat-mdc-focus-indicator:focus::before{content:""}.cdk-high-contrast-active{--mat-mdc-focus-indicator-display: block}.mat-badge-content{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small .mat-badge-content{font-size:9px}.mat-badge-large .mat-badge-content{font-size:24px}.mat-h1,.mat-headline,.mat-typography .mat-h1,.mat-typography .mat-headline,.mat-typography h1{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2,.mat-title,.mat-typography .mat-h2,.mat-typography .mat-title,.mat-typography h2{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3,.mat-subheading-2,.mat-typography .mat-h3,.mat-typography .mat-subheading-2,.mat-typography h3{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4,.mat-subheading-1,.mat-typography .mat-h4,.mat-typography .mat-subheading-1,.mat-typography h4{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5,.mat-typography .mat-h5,.mat-typography h5{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6,.mat-typography .mat-h6,.mat-typography h6{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong,.mat-body-2,.mat-typography .mat-body-strong,.mat-typography .mat-body-2{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body,.mat-body-1,.mat-typography .mat-body,.mat-typography .mat-body-1,.mat-typography{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body p,.mat-body-1 p,.mat-typography .mat-body p,.mat-typography .mat-body-1 p,.mat-typography p{margin:0 0 12px}.mat-small,.mat-caption,.mat-typography .mat-small,.mat-typography .mat-caption{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4,.mat-typography .mat-display-4{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3,.mat-typography .mat-display-3{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2,.mat-typography .mat-display-2{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1,.mat-typography .mat-display-1{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button,.mat-raised-button,.mat-icon-button,.mat-stroked-button,.mat-flat-button,.mat-fab,.mat-mini-fab{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title{font-size:24px;font-weight:500}.mat-card-header .mat-card-title{font-size:20px}.mat-card-subtitle,.mat-card-content{font-size:14px}.mat-checkbox{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout .mat-checkbox-label{line-height:24px}.mat-chip{font-size:14px;font-weight:500}.mat-chip .mat-chip-trailing-icon.mat-icon,.mat-chip .mat-chip-remove.mat-icon{font-size:18px}.mat-table{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell{font-size:12px;font-weight:500}.mat-cell,.mat-footer-cell{font-size:14px}.mat-calendar{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body{font-size:13px}.mat-calendar-body-label,.mat-calendar-period-button{font-size:14px;font-weight:500}.mat-calendar-table-header th{font-size:11px;font-weight:400}.mat-dialog-title{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper{padding-bottom:1.34375em}.mat-form-field-prefix .mat-icon,.mat-form-field-suffix .mat-icon{font-size:150%;line-height:1.125}.mat-form-field-prefix .mat-icon-button,.mat-form-field-suffix .mat-icon-button{height:1.5em;width:1.5em}.mat-form-field-prefix .mat-icon-button .mat-icon,.mat-form-field-suffix .mat-icon-button .mat-icon{height:1.125em;line-height:1.125}.mat-form-field-infix{padding:.5em 0;border-top:.84375em solid rgba(0,0,0,0)}.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.34373em) scale(0.75);width:133.3333533333%}.mat-form-field-can-float .mat-input-server[label]:not(:label-shown)+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.34372em) scale(0.75);width:133.3333633333%}.mat-form-field-label-wrapper{top:-0.84375em;padding-top:.84375em}.mat-form-field-label{top:1.34375em}.mat-form-field-underline{bottom:1.34375em}.mat-form-field-subscript-wrapper{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy .mat-form-field-wrapper{padding-bottom:1.25em}.mat-form-field-appearance-legacy .mat-form-field-infix{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00106px);width:133.3333933333%}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-form-field-autofill-control:-webkit-autofill+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00107px);width:133.3334033333%}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server[label]:not(:label-shown)+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00108px);width:133.3334133333%}.mat-form-field-appearance-legacy .mat-form-field-label{top:1.28125em}.mat-form-field-appearance-legacy .mat-form-field-underline{bottom:1.25em}.mat-form-field-appearance-legacy .mat-form-field-subscript-wrapper{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28116em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-form-field-autofill-control:-webkit-autofill+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28115em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server[label]:not(:label-shown)+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28114em) scale(0.75)}}.mat-form-field-appearance-fill .mat-form-field-infix{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill .mat-form-field-label{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-fill.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-0.59373em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-fill.mat-form-field-can-float .mat-input-server[label]:not(:label-shown)+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-0.59372em) scale(0.75);width:133.3333633333%}.mat-form-field-appearance-outline .mat-form-field-infix{padding:1em 0 1em 0}.mat-form-field-appearance-outline .mat-form-field-label{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-outline.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.59373em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-outline.mat-form-field-can-float .mat-input-server[label]:not(:label-shown)+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.59372em) scale(0.75);width:133.3333633333%}.mat-grid-tile-header,.mat-grid-tile-footer{font-size:14px}.mat-grid-tile-header .mat-line,.mat-grid-tile-footer .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header .mat-line:nth-child(n+2),.mat-grid-tile-footer .mat-line:nth-child(n+2){font-size:12px}input.mat-input-element{margin-top:-0.0625em}.mat-menu-item{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator,.mat-paginator-page-size .mat-select-trigger{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger{height:1.125em}.mat-slide-toggle-content{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical,.mat-stepper-horizontal{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label{font-size:14px;font-weight:400}.mat-step-sub-label-error{font-weight:normal}.mat-step-label-error{font-size:14px}.mat-step-label-selected{font-size:14px;font-weight:500}.mat-tab-group{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label,.mat-tab-link{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar,.mat-toolbar h1,.mat-toolbar h2,.mat-toolbar h3,.mat-toolbar h4,.mat-toolbar h5,.mat-toolbar h6{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base .mat-list-item{font-size:16px}.mat-list-base .mat-list-item .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base .mat-list-item .mat-line:nth-child(n+2){font-size:14px}.mat-list-base .mat-list-option{font-size:16px}.mat-list-base .mat-list-option .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base .mat-list-option .mat-line:nth-child(n+2){font-size:14px}.mat-list-base .mat-subheader{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense] .mat-list-item{font-size:12px}.mat-list-base[dense] .mat-list-item .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense] .mat-list-item .mat-line:nth-child(n+2){font-size:12px}.mat-list-base[dense] .mat-list-option{font-size:12px}.mat-list-base[dense] .mat-list-option .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense] .mat-list-option .mat-line:nth-child(n+2){font-size:12px}.mat-list-base[dense] .mat-subheader{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node,.mat-nested-tree-node{font-weight:400;font-size:14px}.mat-ripple-element{background-color:rgba(0,0,0,.1)}.mat-option{color:#212121}.mat-option:hover:not(.mat-option-disabled),.mat-option:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled{color:rgba(0,0,0,.38)}.mat-primary .mat-option.mat-selected:not(.mat-option-disabled){color:#f57c00}.mat-accent .mat-option.mat-selected:not(.mat-option-disabled){color:#ff9800}.mat-warn .mat-option.mat-selected:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label{color:#616161}.mat-optgroup-disabled .mat-optgroup-label{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox{color:#616161}.mat-pseudo-checkbox::after{color:#fff}.mat-pseudo-checkbox-disabled{color:#b0b0b0}.mat-primary .mat-pseudo-checkbox-checked,.mat-primary .mat-pseudo-checkbox-indeterminate{background:#f57c00}.mat-pseudo-checkbox-checked,.mat-pseudo-checkbox-indeterminate,.mat-accent .mat-pseudo-checkbox-checked,.mat-accent .mat-pseudo-checkbox-indeterminate{background:#ff9800}.mat-warn .mat-pseudo-checkbox-checked,.mat-warn .mat-pseudo-checkbox-indeterminate{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled,.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled{background:#b0b0b0}.mat-app-background{background-color:#fff;color:#212121}.mat-elevation-z0{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker{display:none}.mat-autocomplete-panel{background:#fff;color:#212121}.mat-autocomplete-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel .mat-option.mat-selected:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel .mat-option.mat-selected:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge{position:relative}.mat-badge.mat-badge{overflow:visible}.mat-badge-hidden .mat-badge-content{display:none}.mat-badge-content{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled .mat-badge-content,.mat-badge-content._mat-animation-noopable{transition:none}.mat-badge-content.mat-badge-active{transform:none}.mat-badge-small .mat-badge-content{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above .mat-badge-content{top:-8px}.mat-badge-small.mat-badge-below .mat-badge-content{bottom:-8px}.mat-badge-small.mat-badge-before .mat-badge-content{left:-16px}[dir=rtl] .mat-badge-small.mat-badge-before .mat-badge-content{left:auto;right:-16px}.mat-badge-small.mat-badge-after .mat-badge-content{right:-16px}[dir=rtl] .mat-badge-small.mat-badge-after .mat-badge-content{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before .mat-badge-content{left:-8px}[dir=rtl] .mat-badge-small.mat-badge-overlap.mat-badge-before .mat-badge-content{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after .mat-badge-content{right:-8px}[dir=rtl] .mat-badge-small.mat-badge-overlap.mat-badge-after .mat-badge-content{right:auto;left:-8px}.mat-badge-medium .mat-badge-content{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above .mat-badge-content{top:-11px}.mat-badge-medium.mat-badge-below .mat-badge-content{bottom:-11px}.mat-badge-medium.mat-badge-before .mat-badge-content{left:-22px}[dir=rtl] .mat-badge-medium.mat-badge-before .mat-badge-content{left:auto;right:-22px}.mat-badge-medium.mat-badge-after .mat-badge-content{right:-22px}[dir=rtl] .mat-badge-medium.mat-badge-after .mat-badge-content{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before .mat-badge-content{left:-11px}[dir=rtl] .mat-badge-medium.mat-badge-overlap.mat-badge-before .mat-badge-content{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after .mat-badge-content{right:-11px}[dir=rtl] .mat-badge-medium.mat-badge-overlap.mat-badge-after .mat-badge-content{right:auto;left:-11px}.mat-badge-large .mat-badge-content{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above .mat-badge-content{top:-14px}.mat-badge-large.mat-badge-below .mat-badge-content{bottom:-14px}.mat-badge-large.mat-badge-before .mat-badge-content{left:-28px}[dir=rtl] .mat-badge-large.mat-badge-before .mat-badge-content{left:auto;right:-28px}.mat-badge-large.mat-badge-after .mat-badge-content{right:-28px}[dir=rtl] .mat-badge-large.mat-badge-after .mat-badge-content{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before .mat-badge-content{left:-14px}[dir=rtl] .mat-badge-large.mat-badge-overlap.mat-badge-before .mat-badge-content{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after .mat-badge-content{right:-14px}[dir=rtl] .mat-badge-large.mat-badge-overlap.mat-badge-after .mat-badge-content{right:auto;left:-14px}.mat-badge-content{color:#fff;background:#f57c00}.cdk-high-contrast-active .mat-badge-content{outline:solid 1px;border-radius:0}.mat-badge-accent .mat-badge-content{background:#ff9800;color:#fff}.mat-badge-warn .mat-badge-content{color:#fff;background:#f44336}.mat-badge-disabled .mat-badge-content{background:#bdbdbd;color:#757575}.mat-bottom-sheet-container{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button,.mat-icon-button,.mat-stroked-button{color:inherit;background:rgba(0,0,0,0)}.mat-button.mat-primary,.mat-icon-button.mat-primary,.mat-stroked-button.mat-primary{color:#f57c00}.mat-button.mat-accent,.mat-icon-button.mat-accent,.mat-stroked-button.mat-accent{color:#ff9800}.mat-button.mat-warn,.mat-icon-button.mat-warn,.mat-stroked-button.mat-warn{color:#f44336}.mat-button.mat-primary.mat-button-disabled,.mat-button.mat-accent.mat-button-disabled,.mat-button.mat-warn.mat-button-disabled,.mat-button.mat-button-disabled.mat-button-disabled,.mat-icon-button.mat-primary.mat-button-disabled,.mat-icon-button.mat-accent.mat-button-disabled,.mat-icon-button.mat-warn.mat-button-disabled,.mat-icon-button.mat-button-disabled.mat-button-disabled,.mat-stroked-button.mat-primary.mat-button-disabled,.mat-stroked-button.mat-accent.mat-button-disabled,.mat-stroked-button.mat-warn.mat-button-disabled,.mat-stroked-button.mat-button-disabled.mat-button-disabled{color:rgba(0,0,0,.26)}.mat-button.mat-primary .mat-button-focus-overlay,.mat-icon-button.mat-primary .mat-button-focus-overlay,.mat-stroked-button.mat-primary .mat-button-focus-overlay{background-color:#f57c00}.mat-button.mat-accent .mat-button-focus-overlay,.mat-icon-button.mat-accent .mat-button-focus-overlay,.mat-stroked-button.mat-accent .mat-button-focus-overlay{background-color:#ff9800}.mat-button.mat-warn .mat-button-focus-overlay,.mat-icon-button.mat-warn .mat-button-focus-overlay,.mat-stroked-button.mat-warn .mat-button-focus-overlay{background-color:#f44336}.mat-button.mat-button-disabled .mat-button-focus-overlay,.mat-icon-button.mat-button-disabled .mat-button-focus-overlay,.mat-stroked-button.mat-button-disabled .mat-button-focus-overlay{background-color:rgba(0,0,0,0)}.mat-button .mat-ripple-element,.mat-icon-button .mat-ripple-element,.mat-stroked-button .mat-ripple-element{opacity:.1;background-color:currentColor}.mat-button-focus-overlay{background:#000}.mat-stroked-button:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button,.mat-raised-button,.mat-fab,.mat-mini-fab{color:#212121;background-color:#fff}.mat-flat-button.mat-primary,.mat-raised-button.mat-primary,.mat-fab.mat-primary,.mat-mini-fab.mat-primary{color:#fff}.mat-flat-button.mat-accent,.mat-raised-button.mat-accent,.mat-fab.mat-accent,.mat-mini-fab.mat-accent{color:#fff}.mat-flat-button.mat-warn,.mat-raised-button.mat-warn,.mat-fab.mat-warn,.mat-mini-fab.mat-warn{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled,.mat-flat-button.mat-accent.mat-button-disabled,.mat-flat-button.mat-warn.mat-button-disabled,.mat-flat-button.mat-button-disabled.mat-button-disabled,.mat-raised-button.mat-primary.mat-button-disabled,.mat-raised-button.mat-accent.mat-button-disabled,.mat-raised-button.mat-warn.mat-button-disabled,.mat-raised-button.mat-button-disabled.mat-button-disabled,.mat-fab.mat-primary.mat-button-disabled,.mat-fab.mat-accent.mat-button-disabled,.mat-fab.mat-warn.mat-button-disabled,.mat-fab.mat-button-disabled.mat-button-disabled,.mat-mini-fab.mat-primary.mat-button-disabled,.mat-mini-fab.mat-accent.mat-button-disabled,.mat-mini-fab.mat-warn.mat-button-disabled,.mat-mini-fab.mat-button-disabled.mat-button-disabled{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary,.mat-raised-button.mat-primary,.mat-fab.mat-primary,.mat-mini-fab.mat-primary{background-color:#f57c00}.mat-flat-button.mat-accent,.mat-raised-button.mat-accent,.mat-fab.mat-accent,.mat-mini-fab.mat-accent{background-color:#ff9800}.mat-flat-button.mat-warn,.mat-raised-button.mat-warn,.mat-fab.mat-warn,.mat-mini-fab.mat-warn{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled,.mat-flat-button.mat-accent.mat-button-disabled,.mat-flat-button.mat-warn.mat-button-disabled,.mat-flat-button.mat-button-disabled.mat-button-disabled,.mat-raised-button.mat-primary.mat-button-disabled,.mat-raised-button.mat-accent.mat-button-disabled,.mat-raised-button.mat-warn.mat-button-disabled,.mat-raised-button.mat-button-disabled.mat-button-disabled,.mat-fab.mat-primary.mat-button-disabled,.mat-fab.mat-accent.mat-button-disabled,.mat-fab.mat-warn.mat-button-disabled,.mat-fab.mat-button-disabled.mat-button-disabled,.mat-mini-fab.mat-primary.mat-button-disabled,.mat-mini-fab.mat-accent.mat-button-disabled,.mat-mini-fab.mat-warn.mat-button-disabled,.mat-mini-fab.mat-button-disabled.mat-button-disabled{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary .mat-ripple-element,.mat-raised-button.mat-primary .mat-ripple-element,.mat-fab.mat-primary .mat-ripple-element,.mat-mini-fab.mat-primary .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent .mat-ripple-element,.mat-raised-button.mat-accent .mat-ripple-element,.mat-fab.mat-accent .mat-ripple-element,.mat-mini-fab.mat-accent .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn .mat-ripple-element,.mat-raised-button.mat-warn .mat-ripple-element,.mat-fab.mat-warn .mat-ripple-element,.mat-mini-fab.mat-warn .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-stroked-button:not([class*=mat-elevation-z]),.mat-flat-button:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab:not([class*=mat-elevation-z]),.mat-mini-fab:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab:not(.mat-button-disabled):active:not([class*=mat-elevation-z]),.mat-mini-fab:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled:not([class*=mat-elevation-z]),.mat-mini-fab.mat-button-disabled:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone:not([class*=mat-elevation-z]),.mat-button-toggle-group:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard:not([class*=mat-elevation-z]),.mat-button-toggle-group-appearance-standard:not([class*=mat-elevation-z]){box-shadow:none}.mat-button-toggle{color:rgba(0,0,0,.38)}.mat-button-toggle .mat-button-toggle-focus-overlay{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard{color:#212121;background:#fff}.mat-button-toggle-appearance-standard .mat-button-toggle-focus-overlay{background-color:#000}.mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:solid 1px #e0e0e0}[dir=rtl] .mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:solid 1px #e0e0e0}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:none;border-top:solid 1px #e0e0e0}.mat-button-toggle-checked{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard{color:#212121}.mat-button-toggle-disabled{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.mat-button-toggle-group-appearance-standard{border:solid 1px #e0e0e0}.mat-button-toggle-appearance-standard .mat-button-toggle-label-content{line-height:48px}.mat-card{background:#fff;color:#212121}.mat-card:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle{color:#616161}.mat-checkbox-frame{border-color:#616161}.mat-checkbox-checkmark{fill:#fff}.mat-checkbox-checkmark-path{stroke:#fff !important}.mat-checkbox-mixedmark{background-color:#fff}.mat-checkbox-indeterminate.mat-primary .mat-checkbox-background,.mat-checkbox-checked.mat-primary .mat-checkbox-background{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent .mat-checkbox-background,.mat-checkbox-checked.mat-accent .mat-checkbox-background{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn .mat-checkbox-background,.mat-checkbox-checked.mat-warn .mat-checkbox-background{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked .mat-checkbox-background,.mat-checkbox-disabled.mat-checkbox-indeterminate .mat-checkbox-background{background-color:#b0b0b0}.mat-checkbox-disabled:not(.mat-checkbox-checked) .mat-checkbox-frame{border-color:#b0b0b0}.mat-checkbox-disabled .mat-checkbox-label{color:rgba(0,0,0,.38)}.mat-checkbox .mat-ripple-element{background-color:#000}.mat-checkbox-checked:not(.mat-checkbox-disabled).mat-primary .mat-ripple-element,.mat-checkbox:active:not(.mat-checkbox-disabled).mat-primary .mat-ripple-element{background:#f57c00}.mat-checkbox-checked:not(.mat-checkbox-disabled).mat-accent .mat-ripple-element,.mat-checkbox:active:not(.mat-checkbox-disabled).mat-accent .mat-ripple-element{background:#ff9800}.mat-checkbox-checked:not(.mat-checkbox-disabled).mat-warn .mat-ripple-element,.mat-checkbox:active:not(.mat-checkbox-disabled).mat-warn .mat-ripple-element{background:#f44336}.mat-chip.mat-standard-chip{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip .mat-chip-remove{color:#212121;opacity:.4}.mat-chip.mat-standard-chip:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip:not(.mat-chip-disabled) .mat-chip-remove:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled{opacity:.4}.mat-chip.mat-standard-chip::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary .mat-chip-remove{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn .mat-chip-remove{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent .mat-chip-remove{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-table{background:#fff}.mat-table thead,.mat-table tbody,.mat-table tfoot,mat-header-row,mat-row,mat-footer-row,[mat-header-row],[mat-row],[mat-footer-row],.mat-table-sticky{background:inherit}mat-row,mat-header-row,mat-footer-row,th.mat-header-cell,td.mat-cell,td.mat-footer-cell{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell{color:#616161}.mat-cell,.mat-footer-cell{color:#212121}.mat-calendar-arrow{fill:rgba(0,0,0,.54)}.mat-datepicker-toggle,.mat-datepicker-content .mat-calendar-next-button,.mat-datepicker-content .mat-calendar-previous-button{color:rgba(0,0,0,.54)}.mat-calendar-table-header-divider::after{background:rgba(0,0,0,.12)}.mat-calendar-table-header,.mat-calendar-body-label{color:#616161}.mat-calendar-body-cell-content,.mat-date-range-input-separator{color:#212121;border-color:rgba(0,0,0,0)}.mat-calendar-body-disabled>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled .mat-date-range-input-separator{color:#757575}.mat-calendar-body-in-preview{color:rgba(0,0,0,.24)}.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled>.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical,.mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start::before,[dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end::before,[dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-calendar-body-selected{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(245,124,0,.3)}@media(hover: hover){.mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(245,124,0,.3)}}.mat-datepicker-content{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent .mat-calendar-body-in-range::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-start::before,.mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-end::before,.mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-datepicker-content.mat-accent .mat-calendar-body-selected{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-accent .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.mat-datepicker-content.mat-accent .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(255,152,0,.3)}@media(hover: hover){.mat-datepicker-content.mat-accent .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(255,152,0,.3)}}.mat-datepicker-content.mat-warn .mat-calendar-body-in-range::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-start::before,.mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-end::before,.mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-datepicker-content.mat-warn .mat-calendar-body-selected{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.mat-datepicker-content.mat-warn .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}@media(hover: hover){.mat-datepicker-content.mat-warn .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}}.mat-datepicker-content-touch{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active{color:#f57c00}.mat-datepicker-toggle-active.mat-accent{color:#ff9800}.mat-datepicker-toggle-active.mat-warn{color:#f44336}.mat-date-range-input-inner[disabled]{color:#757575}.mat-dialog-container{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel{background:#fff;color:#212121}.mat-expansion-panel:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel .mat-expansion-panel-header.cdk-keyboard-focused:not([aria-disabled=true]),.mat-expansion-panel .mat-expansion-panel-header.cdk-program-focused:not([aria-disabled=true]),.mat-expansion-panel:not(.mat-expanded) .mat-expansion-panel-header:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel:not(.mat-expanded):not([aria-disabled=true]) .mat-expansion-panel-header:hover{background:#fff}}.mat-expansion-panel-header-title{color:#212121}.mat-expansion-panel-header-description,.mat-expansion-indicator::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-title,.mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-description{color:inherit}.mat-expansion-panel-header{height:48px}.mat-expansion-panel-header.mat-expanded{height:64px}.mat-form-field-label{color:rgba(97,97,97,.6)}.mat-hint{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused .mat-form-field-label{color:#f57c00}.mat-form-field.mat-focused .mat-form-field-label.mat-accent{color:#ff9800}.mat-form-field.mat-focused .mat-form-field-label.mat-warn{color:#f44336}.mat-focused .mat-form-field-required-marker{color:#ff9800}.mat-form-field-ripple{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused .mat-form-field-ripple{background-color:#f57c00}.mat-form-field.mat-focused .mat-form-field-ripple.mat-accent{background-color:#ff9800}.mat-form-field.mat-focused .mat-form-field-ripple.mat-warn{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid) .mat-form-field-infix::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid).mat-accent .mat-form-field-infix::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid).mat-warn .mat-form-field-infix::after{color:#f44336}.mat-form-field.mat-form-field-invalid .mat-form-field-label{color:#f44336}.mat-form-field.mat-form-field-invalid .mat-form-field-label.mat-accent,.mat-form-field.mat-form-field-invalid .mat-form-field-label .mat-form-field-required-marker{color:#f44336}.mat-form-field.mat-form-field-invalid .mat-form-field-ripple,.mat-form-field.mat-form-field-invalid .mat-form-field-ripple.mat-accent{background-color:#f44336}.mat-error{color:#f44336}.mat-form-field-appearance-legacy .mat-form-field-label{color:#616161}.mat-form-field-appearance-legacy .mat-hint{color:#616161}.mat-form-field-appearance-legacy .mat-form-field-underline{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled .mat-form-field-underline{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard .mat-form-field-underline{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled .mat-form-field-underline{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill .mat-form-field-flex{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-flex{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill .mat-form-field-underline::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-label{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-underline::before{background-color:rgba(0,0,0,0)}.mat-form-field-appearance-outline .mat-form-field-outline{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline .mat-form-field-outline-thick{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused .mat-form-field-outline-thick{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent .mat-form-field-outline-thick{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn .mat-form-field-outline-thick{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid .mat-form-field-outline-thick{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled .mat-form-field-label{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled .mat-form-field-outline{color:rgba(0,0,0,.06)}.mat-icon.mat-primary{color:#f57c00}.mat-icon.mat-accent{color:#ff9800}.mat-icon.mat-warn{color:#f44336}.mat-form-field-type-mat-native-select .mat-form-field-infix::after{color:#616161}.mat-input-element:disabled,.mat-form-field-type-mat-native-select.mat-form-field-disabled .mat-form-field-infix::after{color:#757575}.mat-input-element{caret-color:#f57c00}.mat-input-element::placeholder{color:rgba(97,97,97,.42)}.mat-input-element::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent .mat-input-element{caret-color:#ff9800}.mat-form-field.mat-warn .mat-input-element,.mat-form-field-invalid .mat-input-element{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid .mat-form-field-infix::after{color:#f44336}.mat-list-base .mat-list-item{color:#212121}.mat-list-base .mat-list-option{color:#212121}.mat-list-base .mat-subheader{color:#616161}.mat-list-base .mat-list-item-disabled{background-color:#eee;color:#757575}.mat-list-option:hover,.mat-list-option:focus,.mat-nav-list .mat-list-item:hover,.mat-nav-list .mat-list-item:focus,.mat-action-list .mat-list-item:hover,.mat-action-list .mat-list-item:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option,.mat-list-single-selected-option:hover,.mat-list-single-selected-option:focus{background:rgba(0,0,0,.12)}.mat-menu-panel{background:#fff}.mat-menu-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item{background:rgba(0,0,0,0);color:#212121}.mat-menu-item[disabled],.mat-menu-item[disabled] .mat-menu-submenu-icon,.mat-menu-item[disabled] .mat-icon-no-color{color:rgba(0,0,0,.38)}.mat-menu-item .mat-icon-no-color,.mat-menu-submenu-icon{color:rgba(0,0,0,.54)}.mat-menu-item:hover:not([disabled]),.mat-menu-item.cdk-program-focused:not([disabled]),.mat-menu-item.cdk-keyboard-focused:not([disabled]),.mat-menu-item-highlighted:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator{background:#fff}.mat-paginator,.mat-paginator-page-size .mat-select-trigger{color:#616161}.mat-paginator-decrement,.mat-paginator-increment{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first,.mat-paginator-last{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled] .mat-paginator-decrement,.mat-icon-button[disabled] .mat-paginator-increment,.mat-icon-button[disabled] .mat-paginator-first,.mat-icon-button[disabled] .mat-paginator-last{border-color:rgba(0,0,0,.38)}.mat-paginator-container{min-height:56px}.mat-progress-bar-background{fill:#fddebf}.mat-progress-bar-buffer{background-color:#fddebf}.mat-progress-bar-fill::after{background-color:#f57c00}.mat-progress-bar.mat-accent .mat-progress-bar-background{fill:#ffe5bf}.mat-progress-bar.mat-accent .mat-progress-bar-buffer{background-color:#ffe5bf}.mat-progress-bar.mat-accent .mat-progress-bar-fill::after{background-color:#ff9800}.mat-progress-bar.mat-warn .mat-progress-bar-background{fill:#fcd0cd}.mat-progress-bar.mat-warn .mat-progress-bar-buffer{background-color:#fcd0cd}.mat-progress-bar.mat-warn .mat-progress-bar-fill::after{background-color:#f44336}.mat-progress-spinner circle,.mat-spinner circle{stroke:#f57c00}.mat-progress-spinner.mat-accent circle,.mat-spinner.mat-accent circle{stroke:#ff9800}.mat-progress-spinner.mat-warn circle,.mat-spinner.mat-warn circle{stroke:#f44336}.mat-radio-outer-circle{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked .mat-radio-outer-circle{border-color:#f57c00}.mat-radio-button.mat-primary .mat-radio-inner-circle,.mat-radio-button.mat-primary .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),.mat-radio-button.mat-primary.mat-radio-checked .mat-radio-persistent-ripple,.mat-radio-button.mat-primary:active .mat-radio-persistent-ripple{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked .mat-radio-outer-circle{border-color:#ff9800}.mat-radio-button.mat-accent .mat-radio-inner-circle,.mat-radio-button.mat-accent .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),.mat-radio-button.mat-accent.mat-radio-checked .mat-radio-persistent-ripple,.mat-radio-button.mat-accent:active .mat-radio-persistent-ripple{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked .mat-radio-outer-circle{border-color:#f44336}.mat-radio-button.mat-warn .mat-radio-inner-circle,.mat-radio-button.mat-warn .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),.mat-radio-button.mat-warn.mat-radio-checked .mat-radio-persistent-ripple,.mat-radio-button.mat-warn:active .mat-radio-persistent-ripple{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked .mat-radio-outer-circle,.mat-radio-button.mat-radio-disabled .mat-radio-outer-circle{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled .mat-radio-ripple .mat-ripple-element,.mat-radio-button.mat-radio-disabled .mat-radio-inner-circle{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled .mat-radio-label-content{color:rgba(0,0,0,.38)}.mat-radio-button .mat-ripple-element{background-color:#000}.mat-select-value{color:#212121}.mat-select-placeholder{color:rgba(97,97,97,.42)}.mat-select-disabled .mat-select-value{color:#757575}.mat-select-arrow{color:#616161}.mat-select-panel{background:#fff}.mat-select-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel .mat-option.mat-selected:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary .mat-select-arrow{color:#f57c00}.mat-form-field.mat-focused.mat-accent .mat-select-arrow{color:#ff9800}.mat-form-field.mat-focused.mat-warn .mat-select-arrow{color:#f44336}.mat-form-field .mat-select.mat-select-invalid .mat-select-arrow{color:#f44336}.mat-form-field .mat-select.mat-select-disabled .mat-select-arrow{color:#757575}.mat-drawer-container{background-color:#fff;color:#212121}.mat-drawer{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push{background-color:#fff}.mat-drawer:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl] .mat-drawer-side{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl] .mat-drawer-side.mat-drawer-end{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked .mat-slide-toggle-thumb{background-color:#ff9800}.mat-slide-toggle.mat-checked .mat-slide-toggle-bar{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked .mat-ripple-element{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked .mat-slide-toggle-thumb{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked .mat-slide-toggle-bar{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked .mat-ripple-element{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked .mat-slide-toggle-thumb{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked .mat-slide-toggle-bar{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked .mat-ripple-element{background-color:#f44336}.mat-slide-toggle:not(.mat-checked) .mat-ripple-element{background-color:#000}.mat-slide-toggle-thumb{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar{background-color:rgba(0,0,0,.38)}.mat-slider-track-background{background-color:rgba(0,0,0,.26)}.mat-slider.mat-primary .mat-slider-track-fill,.mat-slider.mat-primary .mat-slider-thumb,.mat-slider.mat-primary .mat-slider-thumb-label{background-color:#f57c00}.mat-slider.mat-primary .mat-slider-thumb-label-text{color:#fff}.mat-slider.mat-primary .mat-slider-focus-ring{background-color:rgba(245,124,0,.2)}.mat-slider.mat-accent .mat-slider-track-fill,.mat-slider.mat-accent .mat-slider-thumb,.mat-slider.mat-accent .mat-slider-thumb-label{background-color:#ff9800}.mat-slider.mat-accent .mat-slider-thumb-label-text{color:#fff}.mat-slider.mat-accent .mat-slider-focus-ring{background-color:rgba(255,152,0,.2)}.mat-slider.mat-warn .mat-slider-track-fill,.mat-slider.mat-warn .mat-slider-thumb,.mat-slider.mat-warn .mat-slider-thumb-label{background-color:#f44336}.mat-slider.mat-warn .mat-slider-thumb-label-text{color:#fff}.mat-slider.mat-warn .mat-slider-focus-ring{background-color:rgba(244,67,54,.2)}.mat-slider:hover .mat-slider-track-background,.mat-slider.cdk-focused .mat-slider-track-background{background-color:rgba(0,0,0,.38)}.mat-slider.mat-slider-disabled .mat-slider-track-background,.mat-slider.mat-slider-disabled .mat-slider-track-fill,.mat-slider.mat-slider-disabled .mat-slider-thumb{background-color:rgba(0,0,0,.26)}.mat-slider.mat-slider-disabled:hover .mat-slider-track-background{background-color:rgba(0,0,0,.26)}.mat-slider.mat-slider-min-value .mat-slider-focus-ring{background-color:rgba(0,0,0,.12)}.mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing .mat-slider-thumb,.mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing .mat-slider-thumb-label{background-color:rgba(0,0,0,.87)}.mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused .mat-slider-thumb,.mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused .mat-slider-thumb-label{background-color:rgba(0,0,0,.26)}.mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing) .mat-slider-thumb{border-color:rgba(0,0,0,.26);background-color:rgba(0,0,0,0)}.mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing):hover .mat-slider-thumb,.mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing).cdk-focused .mat-slider-thumb{border-color:rgba(0,0,0,.38)}.mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled .mat-slider-thumb,.mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled .mat-slider-thumb{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks .mat-slider-wrapper::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal .mat-slider-ticks{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical .mat-slider-ticks{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused,.mat-step-header.cdk-program-focused,.mat-step-header:hover:not([aria-disabled]),.mat-step-header:hover[aria-disabled=false]{background-color:rgba(0,0,0,.04)}.mat-step-header:hover[aria-disabled=true]{cursor:default}@media(hover: none){.mat-step-header:hover{background:none}}.mat-step-header .mat-step-label,.mat-step-header .mat-step-optional{color:#616161}.mat-step-header .mat-step-icon{background-color:#616161;color:#fff}.mat-step-header .mat-step-icon-selected,.mat-step-header .mat-step-icon-state-done,.mat-step-header .mat-step-icon-state-edit{background-color:#f57c00;color:#fff}.mat-step-header.mat-accent .mat-step-icon{color:#fff}.mat-step-header.mat-accent .mat-step-icon-selected,.mat-step-header.mat-accent .mat-step-icon-state-done,.mat-step-header.mat-accent .mat-step-icon-state-edit{background-color:#ff9800;color:#fff}.mat-step-header.mat-warn .mat-step-icon{color:#fff}.mat-step-header.mat-warn .mat-step-icon-selected,.mat-step-header.mat-warn .mat-step-icon-state-done,.mat-step-header.mat-warn .mat-step-icon-state-edit{background-color:#f44336;color:#fff}.mat-step-header .mat-step-icon-state-error{background-color:rgba(0,0,0,0);color:#f44336}.mat-step-header .mat-step-label.mat-step-label-active{color:#212121}.mat-step-header .mat-step-label.mat-step-label-error{color:#f44336}.mat-stepper-horizontal,.mat-stepper-vertical{background-color:#fff}.mat-stepper-vertical-line::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header::before,.mat-horizontal-stepper-header::after,.mat-stepper-horizontal-line{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header{height:72px}.mat-stepper-label-position-bottom .mat-horizontal-stepper-header,.mat-vertical-stepper-header{padding:24px 24px}.mat-stepper-vertical-line::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom .mat-horizontal-stepper-header::after,.mat-stepper-label-position-bottom .mat-horizontal-stepper-header::before{top:36px}.mat-stepper-label-position-bottom .mat-stepper-horizontal-line{top:36px}.mat-sort-header-arrow{color:#616161}.mat-tab-nav-bar,.mat-tab-header{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header .mat-tab-nav-bar,.mat-tab-group-inverted-header .mat-tab-header{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label,.mat-tab-link{color:#212121}.mat-tab-label.mat-tab-disabled,.mat-tab-link.mat-tab-disabled{color:#757575}.mat-tab-header-pagination-chevron{border-color:#212121}.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#757575}.mat-tab-group[class*=mat-background-]>.mat-tab-header,.mat-tab-nav-bar[class*=mat-background-]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-primary .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-group.mat-primary .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-primary .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled){background-color:rgba(255,167,38,.3)}.mat-tab-group.mat-primary .mat-ink-bar,.mat-tab-nav-bar.mat-primary .mat-ink-bar{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary>.mat-tab-header .mat-ink-bar,.mat-tab-group.mat-primary.mat-background-primary>.mat-tab-link-container .mat-ink-bar,.mat-tab-nav-bar.mat-primary.mat-background-primary>.mat-tab-header .mat-ink-bar,.mat-tab-nav-bar.mat-primary.mat-background-primary>.mat-tab-link-container .mat-ink-bar{background-color:#fff}.mat-tab-group.mat-accent .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-accent .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-group.mat-accent .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-accent .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled){background-color:rgba(255,224,178,.3)}.mat-tab-group.mat-accent .mat-ink-bar,.mat-tab-nav-bar.mat-accent .mat-ink-bar{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent>.mat-tab-header .mat-ink-bar,.mat-tab-group.mat-accent.mat-background-accent>.mat-tab-link-container .mat-ink-bar,.mat-tab-nav-bar.mat-accent.mat-background-accent>.mat-tab-header .mat-ink-bar,.mat-tab-nav-bar.mat-accent.mat-background-accent>.mat-tab-link-container .mat-ink-bar{background-color:#fff}.mat-tab-group.mat-warn .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-warn .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-group.mat-warn .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-warn .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn .mat-ink-bar,.mat-tab-nav-bar.mat-warn .mat-ink-bar{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn>.mat-tab-header .mat-ink-bar,.mat-tab-group.mat-warn.mat-background-warn>.mat-tab-link-container .mat-ink-bar,.mat-tab-nav-bar.mat-warn.mat-background-warn>.mat-tab-header .mat-ink-bar,.mat-tab-nav-bar.mat-warn.mat-background-warn>.mat-tab-link-container .mat-ink-bar{background-color:#fff}.mat-tab-group.mat-background-primary .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-primary .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-primary .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-primary .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled){background-color:rgba(255,167,38,.3)}.mat-tab-group.mat-background-primary>.mat-tab-header,.mat-tab-group.mat-background-primary>.mat-tab-link-container,.mat-tab-group.mat-background-primary>.mat-tab-header-pagination,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header,.mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination{background-color:#f57c00}.mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-label,.mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-tab-link,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-label,.mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-tab-link{color:#fff}.mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-label.mat-tab-disabled,.mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-tab-link.mat-tab-disabled,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-label.mat-tab-disabled,.mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-primary>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-focus-indicator::before,.mat-tab-group.mat-background-primary>.mat-tab-header .mat-focus-indicator::before,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-focus-indicator::before,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-focus-indicator::before{border-color:#fff}.mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-primary>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#fff;opacity:.4}.mat-tab-group.mat-background-primary>.mat-tab-header .mat-ripple-element,.mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-ripple-element,.mat-tab-group.mat-background-primary>.mat-tab-header-pagination .mat-ripple-element,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-ripple-element,.mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-ripple-element,.mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination .mat-ripple-element{background-color:#fff;opacity:.12}.mat-tab-group.mat-background-accent .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-accent .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-accent .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-accent .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled){background-color:rgba(255,224,178,.3)}.mat-tab-group.mat-background-accent>.mat-tab-header,.mat-tab-group.mat-background-accent>.mat-tab-link-container,.mat-tab-group.mat-background-accent>.mat-tab-header-pagination,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header,.mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination{background-color:#ff9800}.mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-label,.mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-tab-link,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-label,.mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-tab-link{color:#fff}.mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-label.mat-tab-disabled,.mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-tab-link.mat-tab-disabled,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-label.mat-tab-disabled,.mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-accent>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-focus-indicator::before,.mat-tab-group.mat-background-accent>.mat-tab-header .mat-focus-indicator::before,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-focus-indicator::before,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-focus-indicator::before{border-color:#fff}.mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-accent>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#fff;opacity:.4}.mat-tab-group.mat-background-accent>.mat-tab-header .mat-ripple-element,.mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-ripple-element,.mat-tab-group.mat-background-accent>.mat-tab-header-pagination .mat-ripple-element,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-ripple-element,.mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-ripple-element,.mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination .mat-ripple-element{background-color:#fff;opacity:.12}.mat-tab-group.mat-background-warn .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-warn .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-warn .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-warn .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn>.mat-tab-header,.mat-tab-group.mat-background-warn>.mat-tab-link-container,.mat-tab-group.mat-background-warn>.mat-tab-header-pagination,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header,.mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination{background-color:#f44336}.mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-label,.mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-tab-link,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-label,.mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-tab-link{color:#fff}.mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-label.mat-tab-disabled,.mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-tab-link.mat-tab-disabled,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-label.mat-tab-disabled,.mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-warn>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-focus-indicator::before,.mat-tab-group.mat-background-warn>.mat-tab-header .mat-focus-indicator::before,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-focus-indicator::before,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-focus-indicator::before{border-color:#fff}.mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-group.mat-background-warn>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#fff;opacity:.4}.mat-tab-group.mat-background-warn>.mat-tab-header .mat-ripple-element,.mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-ripple-element,.mat-tab-group.mat-background-warn>.mat-tab-header-pagination .mat-ripple-element,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-ripple-element,.mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-ripple-element,.mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination .mat-ripple-element{background-color:#fff;opacity:.12}.mat-toolbar{background:#f57c00;color:#212121}.mat-toolbar.mat-primary{background:#f57c00;color:#fff}.mat-toolbar.mat-accent{background:#ff9800;color:#fff}.mat-toolbar.mat-warn{background:#f44336;color:#fff}.mat-toolbar .mat-form-field-underline,.mat-toolbar .mat-form-field-ripple,.mat-toolbar .mat-focused .mat-form-field-ripple{background-color:currentColor}.mat-toolbar .mat-form-field-label,.mat-toolbar .mat-focused .mat-form-field-label,.mat-toolbar .mat-select-value,.mat-toolbar .mat-select-arrow,.mat-toolbar .mat-form-field.mat-focused .mat-select-arrow{color:inherit}.mat-toolbar .mat-input-element{caret-color:currentColor}.mat-toolbar-multiple-rows{min-height:64px}.mat-toolbar-row,.mat-toolbar-single-row{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows{min-height:56px}.mat-toolbar-row,.mat-toolbar-single-row{height:56px}}.mat-tooltip{background:rgba(97,97,97,.9)}.mat-tree{background:#fff}.mat-tree-node,.mat-nested-tree-node{color:#212121}.mat-tree-node{min-height:48px}.mat-snack-bar-container{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action{color:#ff9800}body{overflow:hidden}.cdk-overlay-container{contain:strict}a:not(.mat-button,.mat-icon-button){color:#1976d2}a:not(.mat-button,.mat-icon-button):visited{color:#7b1fa2}body.dark-mode{background-color:#303030}body.dark-mode a:not(.mat-button,.mat-icon-button){color:#42a5f5}body.dark-mode a:not(.mat-button,.mat-icon-button):visited{color:#ba68c8}body.dark-mode .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-option{color:#fff}body.dark-mode .mat-option:hover:not(.mat-option-disabled),body.dark-mode .mat-option:focus:not(.mat-option-disabled){background:rgba(255,255,255,.04)}body.dark-mode .mat-option.mat-selected:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(255,255,255,.04)}body.dark-mode .mat-option.mat-active{background:rgba(255,255,255,.04);color:#fff}body.dark-mode .mat-option.mat-option-disabled{color:rgba(255,255,255,.5)}body.dark-mode .mat-primary .mat-option.mat-selected:not(.mat-option-disabled){color:#ef6c00}body.dark-mode .mat-accent .mat-option.mat-selected:not(.mat-option-disabled){color:#ef6c00}body.dark-mode .mat-warn .mat-option.mat-selected:not(.mat-option-disabled){color:#f44336}body.dark-mode .mat-optgroup-label{color:rgba(255,255,255,.7)}body.dark-mode .mat-optgroup-disabled .mat-optgroup-label{color:rgba(255,255,255,.5)}body.dark-mode .mat-pseudo-checkbox{color:rgba(255,255,255,.7)}body.dark-mode .mat-pseudo-checkbox::after{color:#303030}body.dark-mode .mat-pseudo-checkbox-disabled{color:#686868}body.dark-mode .mat-primary .mat-pseudo-checkbox-checked,body.dark-mode .mat-primary .mat-pseudo-checkbox-indeterminate{background:#ef6c00}body.dark-mode .mat-pseudo-checkbox-checked,body.dark-mode .mat-pseudo-checkbox-indeterminate,body.dark-mode .mat-accent .mat-pseudo-checkbox-checked,body.dark-mode .mat-accent .mat-pseudo-checkbox-indeterminate{background:#ef6c00}body.dark-mode .mat-warn .mat-pseudo-checkbox-checked,body.dark-mode .mat-warn .mat-pseudo-checkbox-indeterminate{background:#f44336}body.dark-mode .mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled,body.dark-mode .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled{background:#686868}body.dark-mode .mat-app-background,body.dark-mode.mat-app-background{background-color:#303030;color:#fff}body.dark-mode .mat-elevation-z0{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z1{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z2{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z3{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z4{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z5{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z6{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z7{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z8{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z9{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z10{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z11{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z12{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z13{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z14{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z15{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z16{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z17{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z18{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z19{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z20{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z21{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z22{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z23{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-elevation-z24{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker{display:none}body.dark-mode .mat-autocomplete-panel{background:#424242;color:#fff}body.dark-mode .mat-autocomplete-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-autocomplete-panel .mat-option.mat-selected:not(.mat-active):not(:hover){background:#424242}body.dark-mode .mat-autocomplete-panel .mat-option.mat-selected:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#fff}body.dark-mode .mat-badge-content{color:#fff;background:#ef6c00}.cdk-high-contrast-active body.dark-mode .mat-badge-content{outline:solid 1px;border-radius:0}body.dark-mode .mat-badge-accent .mat-badge-content{background:#ef6c00;color:#fff}body.dark-mode .mat-badge-warn .mat-badge-content{color:#fff;background:#f44336}body.dark-mode .mat-badge-disabled .mat-badge-content{background:#6e6e6e;color:#616161}body.dark-mode .mat-bottom-sheet-container{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#424242;color:#fff}body.dark-mode .mat-button,body.dark-mode .mat-icon-button,body.dark-mode .mat-stroked-button{color:inherit;background:rgba(0,0,0,0)}body.dark-mode .mat-button.mat-primary,body.dark-mode .mat-icon-button.mat-primary,body.dark-mode .mat-stroked-button.mat-primary{color:#ef6c00}body.dark-mode .mat-button.mat-accent,body.dark-mode .mat-icon-button.mat-accent,body.dark-mode .mat-stroked-button.mat-accent{color:#ef6c00}body.dark-mode .mat-button.mat-warn,body.dark-mode .mat-icon-button.mat-warn,body.dark-mode .mat-stroked-button.mat-warn{color:#f44336}body.dark-mode .mat-button.mat-primary.mat-button-disabled,body.dark-mode .mat-button.mat-accent.mat-button-disabled,body.dark-mode .mat-button.mat-warn.mat-button-disabled,body.dark-mode .mat-button.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-icon-button.mat-primary.mat-button-disabled,body.dark-mode .mat-icon-button.mat-accent.mat-button-disabled,body.dark-mode .mat-icon-button.mat-warn.mat-button-disabled,body.dark-mode .mat-icon-button.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-stroked-button.mat-primary.mat-button-disabled,body.dark-mode .mat-stroked-button.mat-accent.mat-button-disabled,body.dark-mode .mat-stroked-button.mat-warn.mat-button-disabled,body.dark-mode .mat-stroked-button.mat-button-disabled.mat-button-disabled{color:rgba(255,255,255,.3)}body.dark-mode .mat-button.mat-primary .mat-button-focus-overlay,body.dark-mode .mat-icon-button.mat-primary .mat-button-focus-overlay,body.dark-mode .mat-stroked-button.mat-primary .mat-button-focus-overlay{background-color:#ef6c00}body.dark-mode .mat-button.mat-accent .mat-button-focus-overlay,body.dark-mode .mat-icon-button.mat-accent .mat-button-focus-overlay,body.dark-mode .mat-stroked-button.mat-accent .mat-button-focus-overlay{background-color:#ef6c00}body.dark-mode .mat-button.mat-warn .mat-button-focus-overlay,body.dark-mode .mat-icon-button.mat-warn .mat-button-focus-overlay,body.dark-mode .mat-stroked-button.mat-warn .mat-button-focus-overlay{background-color:#f44336}body.dark-mode .mat-button.mat-button-disabled .mat-button-focus-overlay,body.dark-mode .mat-icon-button.mat-button-disabled .mat-button-focus-overlay,body.dark-mode .mat-stroked-button.mat-button-disabled .mat-button-focus-overlay{background-color:rgba(0,0,0,0)}body.dark-mode .mat-button .mat-ripple-element,body.dark-mode .mat-icon-button .mat-ripple-element,body.dark-mode .mat-stroked-button .mat-ripple-element{opacity:.1;background-color:currentColor}body.dark-mode .mat-button-focus-overlay{background:#fff}body.dark-mode .mat-stroked-button:not(.mat-button-disabled){border-color:rgba(255,255,255,.12)}body.dark-mode .mat-flat-button,body.dark-mode .mat-raised-button,body.dark-mode .mat-fab,body.dark-mode .mat-mini-fab{color:#fff;background-color:#424242}body.dark-mode .mat-flat-button.mat-primary,body.dark-mode .mat-raised-button.mat-primary,body.dark-mode .mat-fab.mat-primary,body.dark-mode .mat-mini-fab.mat-primary{color:#fff}body.dark-mode .mat-flat-button.mat-accent,body.dark-mode .mat-raised-button.mat-accent,body.dark-mode .mat-fab.mat-accent,body.dark-mode .mat-mini-fab.mat-accent{color:#fff}body.dark-mode .mat-flat-button.mat-warn,body.dark-mode .mat-raised-button.mat-warn,body.dark-mode .mat-fab.mat-warn,body.dark-mode .mat-mini-fab.mat-warn{color:#fff}body.dark-mode .mat-flat-button.mat-primary.mat-button-disabled,body.dark-mode .mat-flat-button.mat-accent.mat-button-disabled,body.dark-mode .mat-flat-button.mat-warn.mat-button-disabled,body.dark-mode .mat-flat-button.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-raised-button.mat-primary.mat-button-disabled,body.dark-mode .mat-raised-button.mat-accent.mat-button-disabled,body.dark-mode .mat-raised-button.mat-warn.mat-button-disabled,body.dark-mode .mat-raised-button.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-fab.mat-primary.mat-button-disabled,body.dark-mode .mat-fab.mat-accent.mat-button-disabled,body.dark-mode .mat-fab.mat-warn.mat-button-disabled,body.dark-mode .mat-fab.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-primary.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-accent.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-warn.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-button-disabled.mat-button-disabled{color:rgba(255,255,255,.3)}body.dark-mode .mat-flat-button.mat-primary,body.dark-mode .mat-raised-button.mat-primary,body.dark-mode .mat-fab.mat-primary,body.dark-mode .mat-mini-fab.mat-primary{background-color:#ef6c00}body.dark-mode .mat-flat-button.mat-accent,body.dark-mode .mat-raised-button.mat-accent,body.dark-mode .mat-fab.mat-accent,body.dark-mode .mat-mini-fab.mat-accent{background-color:#ef6c00}body.dark-mode .mat-flat-button.mat-warn,body.dark-mode .mat-raised-button.mat-warn,body.dark-mode .mat-fab.mat-warn,body.dark-mode .mat-mini-fab.mat-warn{background-color:#f44336}body.dark-mode .mat-flat-button.mat-primary.mat-button-disabled,body.dark-mode .mat-flat-button.mat-accent.mat-button-disabled,body.dark-mode .mat-flat-button.mat-warn.mat-button-disabled,body.dark-mode .mat-flat-button.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-raised-button.mat-primary.mat-button-disabled,body.dark-mode .mat-raised-button.mat-accent.mat-button-disabled,body.dark-mode .mat-raised-button.mat-warn.mat-button-disabled,body.dark-mode .mat-raised-button.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-fab.mat-primary.mat-button-disabled,body.dark-mode .mat-fab.mat-accent.mat-button-disabled,body.dark-mode .mat-fab.mat-warn.mat-button-disabled,body.dark-mode .mat-fab.mat-button-disabled.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-primary.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-accent.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-warn.mat-button-disabled,body.dark-mode .mat-mini-fab.mat-button-disabled.mat-button-disabled{background-color:rgba(255,255,255,.12)}body.dark-mode .mat-flat-button.mat-primary .mat-ripple-element,body.dark-mode .mat-raised-button.mat-primary .mat-ripple-element,body.dark-mode .mat-fab.mat-primary .mat-ripple-element,body.dark-mode .mat-mini-fab.mat-primary .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-flat-button.mat-accent .mat-ripple-element,body.dark-mode .mat-raised-button.mat-accent .mat-ripple-element,body.dark-mode .mat-fab.mat-accent .mat-ripple-element,body.dark-mode .mat-mini-fab.mat-accent .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-flat-button.mat-warn .mat-ripple-element,body.dark-mode .mat-raised-button.mat-warn .mat-ripple-element,body.dark-mode .mat-fab.mat-warn .mat-ripple-element,body.dark-mode .mat-mini-fab.mat-warn .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-stroked-button:not([class*=mat-elevation-z]),body.dark-mode .mat-flat-button:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-raised-button:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-raised-button:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-raised-button.mat-button-disabled:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-fab:not([class*=mat-elevation-z]),body.dark-mode .mat-mini-fab:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-fab:not(.mat-button-disabled):active:not([class*=mat-elevation-z]),body.dark-mode .mat-mini-fab:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-fab.mat-button-disabled:not([class*=mat-elevation-z]),body.dark-mode .mat-mini-fab.mat-button-disabled:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-button-toggle-standalone:not([class*=mat-elevation-z]),body.dark-mode .mat-button-toggle-group:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-button-toggle-standalone.mat-button-toggle-appearance-standard:not([class*=mat-elevation-z]),body.dark-mode .mat-button-toggle-group-appearance-standard:not([class*=mat-elevation-z]){box-shadow:none}body.dark-mode .mat-button-toggle{color:rgba(255,255,255,.5)}body.dark-mode .mat-button-toggle .mat-button-toggle-focus-overlay{background-color:rgba(255,255,255,.12)}body.dark-mode .mat-button-toggle-appearance-standard{color:#fff;background:#424242}body.dark-mode .mat-button-toggle-appearance-standard .mat-button-toggle-focus-overlay{background-color:#fff}body.dark-mode .mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:solid 1px #595959}body.dark-mode [dir=rtl] .mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:solid 1px #595959}body.dark-mode .mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:none;border-top:solid 1px #595959}body.dark-mode .mat-button-toggle-checked{background-color:#212121;color:rgba(255,255,255,.7)}body.dark-mode .mat-button-toggle-checked.mat-button-toggle-appearance-standard{color:#fff}body.dark-mode .mat-button-toggle-disabled{color:rgba(255,255,255,.3);background-color:#000}body.dark-mode .mat-button-toggle-disabled.mat-button-toggle-appearance-standard{background:#424242}body.dark-mode .mat-button-toggle-disabled.mat-button-toggle-checked{background-color:#424242}body.dark-mode .mat-button-toggle-standalone.mat-button-toggle-appearance-standard,body.dark-mode .mat-button-toggle-group-appearance-standard{border:solid 1px #595959}body.dark-mode .mat-button-toggle-appearance-standard .mat-button-toggle-label-content{line-height:48px}body.dark-mode .mat-card{background:#424242;color:#fff}body.dark-mode .mat-card:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-card.mat-card-flat:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-card-subtitle{color:rgba(255,255,255,.7)}body.dark-mode .mat-checkbox-frame{border-color:rgba(255,255,255,.7)}body.dark-mode .mat-checkbox-checkmark{fill:#303030}body.dark-mode .mat-checkbox-checkmark-path{stroke:#303030 !important}body.dark-mode .mat-checkbox-mixedmark{background-color:#303030}body.dark-mode .mat-checkbox-indeterminate.mat-primary .mat-checkbox-background,body.dark-mode .mat-checkbox-checked.mat-primary .mat-checkbox-background{background-color:#ef6c00}body.dark-mode .mat-checkbox-indeterminate.mat-accent .mat-checkbox-background,body.dark-mode .mat-checkbox-checked.mat-accent .mat-checkbox-background{background-color:#ef6c00}body.dark-mode .mat-checkbox-indeterminate.mat-warn .mat-checkbox-background,body.dark-mode .mat-checkbox-checked.mat-warn .mat-checkbox-background{background-color:#f44336}body.dark-mode .mat-checkbox-disabled.mat-checkbox-checked .mat-checkbox-background,body.dark-mode .mat-checkbox-disabled.mat-checkbox-indeterminate .mat-checkbox-background{background-color:#686868}body.dark-mode .mat-checkbox-disabled:not(.mat-checkbox-checked) .mat-checkbox-frame{border-color:#686868}body.dark-mode .mat-checkbox-disabled .mat-checkbox-label{color:rgba(255,255,255,.5)}body.dark-mode .mat-checkbox .mat-ripple-element{background-color:#fff}body.dark-mode .mat-checkbox-checked:not(.mat-checkbox-disabled).mat-primary .mat-ripple-element,body.dark-mode .mat-checkbox:active:not(.mat-checkbox-disabled).mat-primary .mat-ripple-element{background:#ef6c00}body.dark-mode .mat-checkbox-checked:not(.mat-checkbox-disabled).mat-accent .mat-ripple-element,body.dark-mode .mat-checkbox:active:not(.mat-checkbox-disabled).mat-accent .mat-ripple-element{background:#ef6c00}body.dark-mode .mat-checkbox-checked:not(.mat-checkbox-disabled).mat-warn .mat-ripple-element,body.dark-mode .mat-checkbox:active:not(.mat-checkbox-disabled).mat-warn .mat-ripple-element{background:#f44336}body.dark-mode .mat-chip.mat-standard-chip{background-color:#616161;color:#fff}body.dark-mode .mat-chip.mat-standard-chip .mat-chip-remove{color:#fff;opacity:.4}body.dark-mode .mat-chip.mat-standard-chip:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-chip.mat-standard-chip:not(.mat-chip-disabled) .mat-chip-remove:hover{opacity:.54}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-disabled{opacity:.4}body.dark-mode .mat-chip.mat-standard-chip::after{background:#fff}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-primary{background-color:#ef6c00;color:#fff}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-primary .mat-chip-remove{color:#fff;opacity:.4}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-primary .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-warn{background-color:#f44336;color:#fff}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-warn .mat-chip-remove{color:#fff;opacity:.4}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-warn .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-accent{background-color:#ef6c00;color:#fff}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-accent .mat-chip-remove{color:#fff;opacity:.4}body.dark-mode .mat-chip.mat-standard-chip.mat-chip-selected.mat-accent .mat-ripple-element{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-table{background:#424242}body.dark-mode .mat-table thead,body.dark-mode .mat-table tbody,body.dark-mode .mat-table tfoot,body.dark-mode mat-header-row,body.dark-mode mat-row,body.dark-mode mat-footer-row,body.dark-mode [mat-header-row],body.dark-mode [mat-row],body.dark-mode [mat-footer-row],body.dark-mode .mat-table-sticky{background:inherit}body.dark-mode mat-row,body.dark-mode mat-header-row,body.dark-mode mat-footer-row,body.dark-mode th.mat-header-cell,body.dark-mode td.mat-cell,body.dark-mode td.mat-footer-cell{border-bottom-color:rgba(255,255,255,.12)}body.dark-mode .mat-header-cell{color:rgba(255,255,255,.7)}body.dark-mode .mat-cell,body.dark-mode .mat-footer-cell{color:#fff}body.dark-mode .mat-calendar-arrow{fill:#fff}body.dark-mode .mat-datepicker-toggle,body.dark-mode .mat-datepicker-content .mat-calendar-next-button,body.dark-mode .mat-datepicker-content .mat-calendar-previous-button{color:#fff}body.dark-mode .mat-calendar-table-header-divider::after{background:rgba(255,255,255,.12)}body.dark-mode .mat-calendar-table-header,body.dark-mode .mat-calendar-body-label{color:rgba(255,255,255,.7)}body.dark-mode .mat-calendar-body-cell-content,body.dark-mode .mat-date-range-input-separator{color:#fff;border-color:rgba(0,0,0,0)}body.dark-mode .mat-calendar-body-disabled>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#616161}body.dark-mode .mat-form-field-disabled .mat-date-range-input-separator{color:#616161}body.dark-mode .mat-calendar-body-in-preview{color:rgba(255,255,255,.24)}body.dark-mode .mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(255,255,255,.5)}body.dark-mode .mat-calendar-body-disabled>.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(255,255,255,.3)}body.dark-mode .mat-calendar-body-in-range::before{background:rgba(239,108,0,.2)}body.dark-mode .mat-calendar-body-comparison-identical,body.dark-mode .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}body.dark-mode .mat-calendar-body-comparison-bridge-start::before,body.dark-mode [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(239, 108, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-calendar-body-comparison-bridge-end::before,body.dark-mode [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(239, 108, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,body.dark-mode .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}body.dark-mode .mat-calendar-body-comparison-identical.mat-calendar-body-selected,body.dark-mode .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}body.dark-mode .mat-calendar-body-selected{background-color:#ef6c00;color:#fff}body.dark-mode .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(239,108,0,.4)}body.dark-mode .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}body.dark-mode .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),body.dark-mode .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(239,108,0,.3)}@media(hover: hover){body.dark-mode .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(239,108,0,.3)}}body.dark-mode .mat-datepicker-content{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#424242;color:#fff}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-range::before{background:rgba(239,108,0,.2)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical,body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-start::before,body.dark-mode .mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(239, 108, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-end::before,body.dark-mode .mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(239, 108, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical.mat-calendar-body-selected,body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-selected{background-color:#ef6c00;color:#fff}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(239,108,0,.4)}body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}body.dark-mode .mat-datepicker-content.mat-accent .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),body.dark-mode .mat-datepicker-content.mat-accent .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(239,108,0,.3)}@media(hover: hover){body.dark-mode .mat-datepicker-content.mat-accent .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(239,108,0,.3)}}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-range::before{background:rgba(244,67,54,.2)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical,body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-start::before,body.dark-mode .mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-end::before,body.dark-mode .mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical.mat-calendar-body-selected,body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-selected{background-color:#f44336;color:#fff}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(244,67,54,.4)}body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}body.dark-mode .mat-datepicker-content.mat-warn .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),body.dark-mode .mat-datepicker-content.mat-warn .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}@media(hover: hover){body.dark-mode .mat-datepicker-content.mat-warn .mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(244,67,54,.3)}}body.dark-mode .mat-datepicker-content-touch{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-datepicker-toggle-active{color:#ef6c00}body.dark-mode .mat-datepicker-toggle-active.mat-accent{color:#ef6c00}body.dark-mode .mat-datepicker-toggle-active.mat-warn{color:#f44336}body.dark-mode .mat-date-range-input-inner[disabled]{color:#616161}body.dark-mode .mat-dialog-container{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#424242;color:#fff}body.dark-mode .mat-divider{border-top-color:rgba(255,255,255,.12)}body.dark-mode .mat-divider-vertical{border-right-color:rgba(255,255,255,.12)}body.dark-mode .mat-expansion-panel{background:#424242;color:#fff}body.dark-mode .mat-expansion-panel:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-action-row{border-top-color:rgba(255,255,255,.12)}body.dark-mode .mat-expansion-panel .mat-expansion-panel-header.cdk-keyboard-focused:not([aria-disabled=true]),body.dark-mode .mat-expansion-panel .mat-expansion-panel-header.cdk-program-focused:not([aria-disabled=true]),body.dark-mode .mat-expansion-panel:not(.mat-expanded) .mat-expansion-panel-header:hover:not([aria-disabled=true]){background:rgba(255,255,255,.04)}@media(hover: none){body.dark-mode .mat-expansion-panel:not(.mat-expanded):not([aria-disabled=true]) .mat-expansion-panel-header:hover{background:#424242}}body.dark-mode .mat-expansion-panel-header-title{color:#fff}body.dark-mode .mat-expansion-panel-header-description,body.dark-mode .mat-expansion-indicator::after{color:rgba(255,255,255,.7)}body.dark-mode .mat-expansion-panel-header[aria-disabled=true]{color:rgba(255,255,255,.3)}body.dark-mode .mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-title,body.dark-mode .mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-description{color:inherit}body.dark-mode .mat-expansion-panel-header{height:48px}body.dark-mode .mat-expansion-panel-header.mat-expanded{height:64px}body.dark-mode .mat-form-field-label{color:rgba(255,255,255,.7)}body.dark-mode .mat-hint{color:rgba(255,255,255,.7)}body.dark-mode .mat-form-field.mat-focused .mat-form-field-label{color:#ef6c00}body.dark-mode .mat-form-field.mat-focused .mat-form-field-label.mat-accent{color:#ef6c00}body.dark-mode .mat-form-field.mat-focused .mat-form-field-label.mat-warn{color:#f44336}body.dark-mode .mat-focused .mat-form-field-required-marker{color:#ef6c00}body.dark-mode .mat-form-field-ripple{background-color:#fff}body.dark-mode .mat-form-field.mat-focused .mat-form-field-ripple{background-color:#ef6c00}body.dark-mode .mat-form-field.mat-focused .mat-form-field-ripple.mat-accent{background-color:#ef6c00}body.dark-mode .mat-form-field.mat-focused .mat-form-field-ripple.mat-warn{background-color:#f44336}body.dark-mode .mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid) .mat-form-field-infix::after{color:#ef6c00}body.dark-mode .mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid).mat-accent .mat-form-field-infix::after{color:#ef6c00}body.dark-mode .mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid).mat-warn .mat-form-field-infix::after{color:#f44336}body.dark-mode .mat-form-field.mat-form-field-invalid .mat-form-field-label{color:#f44336}body.dark-mode .mat-form-field.mat-form-field-invalid .mat-form-field-label.mat-accent,body.dark-mode .mat-form-field.mat-form-field-invalid .mat-form-field-label .mat-form-field-required-marker{color:#f44336}body.dark-mode .mat-form-field.mat-form-field-invalid .mat-form-field-ripple,body.dark-mode .mat-form-field.mat-form-field-invalid .mat-form-field-ripple.mat-accent{background-color:#f44336}body.dark-mode .mat-error{color:#f44336}body.dark-mode .mat-form-field-appearance-legacy .mat-form-field-label{color:rgba(255,255,255,.7)}body.dark-mode .mat-form-field-appearance-legacy .mat-hint{color:rgba(255,255,255,.7)}body.dark-mode .mat-form-field-appearance-legacy .mat-form-field-underline{background-color:rgba(255,255,255,.7)}body.dark-mode .mat-form-field-appearance-legacy.mat-form-field-disabled .mat-form-field-underline{background-image:linear-gradient(to right, rgba(255, 255, 255, 0.7) 0%, rgba(255, 255, 255, 0.7) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}body.dark-mode .mat-form-field-appearance-standard .mat-form-field-underline{background-color:rgba(255,255,255,.7)}body.dark-mode .mat-form-field-appearance-standard.mat-form-field-disabled .mat-form-field-underline{background-image:linear-gradient(to right, rgba(255, 255, 255, 0.7) 0%, rgba(255, 255, 255, 0.7) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}body.dark-mode .mat-form-field-appearance-fill .mat-form-field-flex{background-color:rgba(255,255,255,.1)}body.dark-mode .mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-flex{background-color:rgba(255,255,255,.05)}body.dark-mode .mat-form-field-appearance-fill .mat-form-field-underline::before{background-color:rgba(255,255,255,.5)}body.dark-mode .mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-label{color:#616161}body.dark-mode .mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-underline::before{background-color:rgba(0,0,0,0)}body.dark-mode .mat-form-field-appearance-outline .mat-form-field-outline{color:rgba(255,255,255,.3)}body.dark-mode .mat-form-field-appearance-outline .mat-form-field-outline-thick{color:#fff}body.dark-mode .mat-form-field-appearance-outline.mat-focused .mat-form-field-outline-thick{color:#ef6c00}body.dark-mode .mat-form-field-appearance-outline.mat-focused.mat-accent .mat-form-field-outline-thick{color:#ef6c00}body.dark-mode .mat-form-field-appearance-outline.mat-focused.mat-warn .mat-form-field-outline-thick{color:#f44336}body.dark-mode .mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid .mat-form-field-outline-thick{color:#f44336}body.dark-mode .mat-form-field-appearance-outline.mat-form-field-disabled .mat-form-field-label{color:#616161}body.dark-mode .mat-form-field-appearance-outline.mat-form-field-disabled .mat-form-field-outline{color:rgba(255,255,255,.15)}body.dark-mode .mat-icon.mat-primary{color:#ef6c00}body.dark-mode .mat-icon.mat-accent{color:#ef6c00}body.dark-mode .mat-icon.mat-warn{color:#f44336}body.dark-mode .mat-form-field-type-mat-native-select .mat-form-field-infix::after{color:rgba(255,255,255,.7)}body.dark-mode .mat-input-element:disabled,body.dark-mode .mat-form-field-type-mat-native-select.mat-form-field-disabled .mat-form-field-infix::after{color:#616161}body.dark-mode .mat-input-element{caret-color:#ef6c00}body.dark-mode .mat-input-element::placeholder{color:rgba(255,255,255,.5)}body.dark-mode .mat-input-element::-moz-placeholder{color:rgba(255,255,255,.5)}body.dark-mode .mat-input-element::-webkit-input-placeholder{color:rgba(255,255,255,.5)}body.dark-mode .mat-input-element:-ms-input-placeholder{color:rgba(255,255,255,.5)}body.dark-mode .mat-input-element:not(.mat-native-select-inline) option{color:rgba(0,0,0,.87)}body.dark-mode .mat-input-element:not(.mat-native-select-inline) option:disabled{color:rgba(0,0,0,.38)}body.dark-mode .mat-form-field.mat-accent .mat-input-element{caret-color:#ef6c00}body.dark-mode .mat-form-field.mat-warn .mat-input-element,body.dark-mode .mat-form-field-invalid .mat-input-element{caret-color:#f44336}body.dark-mode .mat-form-field-type-mat-native-select.mat-form-field-invalid .mat-form-field-infix::after{color:#f44336}body.dark-mode .mat-list-base .mat-list-item{color:#fff}body.dark-mode .mat-list-base .mat-list-option{color:#fff}body.dark-mode .mat-list-base .mat-subheader{color:rgba(255,255,255,.7)}body.dark-mode .mat-list-base .mat-list-item-disabled{background-color:rgba(255,255,255,.12);color:#616161}body.dark-mode .mat-list-option:hover,body.dark-mode .mat-list-option:focus,body.dark-mode .mat-nav-list .mat-list-item:hover,body.dark-mode .mat-nav-list .mat-list-item:focus,body.dark-mode .mat-action-list .mat-list-item:hover,body.dark-mode .mat-action-list .mat-list-item:focus{background:rgba(255,255,255,.04)}body.dark-mode .mat-list-single-selected-option,body.dark-mode .mat-list-single-selected-option:hover,body.dark-mode .mat-list-single-selected-option:focus{background:rgba(255,255,255,.12)}body.dark-mode .mat-menu-panel{background:#424242}body.dark-mode .mat-menu-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-menu-item{background:rgba(0,0,0,0);color:#fff}body.dark-mode .mat-menu-item[disabled],body.dark-mode .mat-menu-item[disabled] .mat-menu-submenu-icon,body.dark-mode .mat-menu-item[disabled] .mat-icon-no-color{color:rgba(255,255,255,.5)}body.dark-mode .mat-menu-item .mat-icon-no-color,body.dark-mode .mat-menu-submenu-icon{color:#fff}body.dark-mode .mat-menu-item:hover:not([disabled]),body.dark-mode .mat-menu-item.cdk-program-focused:not([disabled]),body.dark-mode .mat-menu-item.cdk-keyboard-focused:not([disabled]),body.dark-mode .mat-menu-item-highlighted:not([disabled]){background:rgba(255,255,255,.04)}body.dark-mode .mat-paginator{background:#424242}body.dark-mode .mat-paginator,body.dark-mode .mat-paginator-page-size .mat-select-trigger{color:rgba(255,255,255,.7)}body.dark-mode .mat-paginator-decrement,body.dark-mode .mat-paginator-increment{border-top:2px solid #fff;border-right:2px solid #fff}body.dark-mode .mat-paginator-first,body.dark-mode .mat-paginator-last{border-top:2px solid #fff}body.dark-mode .mat-icon-button[disabled] .mat-paginator-decrement,body.dark-mode .mat-icon-button[disabled] .mat-paginator-increment,body.dark-mode .mat-icon-button[disabled] .mat-paginator-first,body.dark-mode .mat-icon-button[disabled] .mat-paginator-last{border-color:rgba(255,255,255,.5)}body.dark-mode .mat-paginator-container{min-height:56px}body.dark-mode .mat-progress-bar-background{fill:#603f24}body.dark-mode .mat-progress-bar-buffer{background-color:#603f24}body.dark-mode .mat-progress-bar-fill::after{background-color:#ef6c00}body.dark-mode .mat-progress-bar.mat-accent .mat-progress-bar-background{fill:#603f24}body.dark-mode .mat-progress-bar.mat-accent .mat-progress-bar-buffer{background-color:#603f24}body.dark-mode .mat-progress-bar.mat-accent .mat-progress-bar-fill::after{background-color:#ef6c00}body.dark-mode .mat-progress-bar.mat-warn .mat-progress-bar-background{fill:#613532}body.dark-mode .mat-progress-bar.mat-warn .mat-progress-bar-buffer{background-color:#613532}body.dark-mode .mat-progress-bar.mat-warn .mat-progress-bar-fill::after{background-color:#f44336}body.dark-mode .mat-progress-spinner circle,body.dark-mode .mat-spinner circle{stroke:#ef6c00}body.dark-mode .mat-progress-spinner.mat-accent circle,body.dark-mode .mat-spinner.mat-accent circle{stroke:#ef6c00}body.dark-mode .mat-progress-spinner.mat-warn circle,body.dark-mode .mat-spinner.mat-warn circle{stroke:#f44336}body.dark-mode .mat-radio-outer-circle{border-color:rgba(255,255,255,.7)}body.dark-mode .mat-radio-button.mat-primary.mat-radio-checked .mat-radio-outer-circle{border-color:#ef6c00}body.dark-mode .mat-radio-button.mat-primary .mat-radio-inner-circle,body.dark-mode .mat-radio-button.mat-primary .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),body.dark-mode .mat-radio-button.mat-primary.mat-radio-checked .mat-radio-persistent-ripple,body.dark-mode .mat-radio-button.mat-primary:active .mat-radio-persistent-ripple{background-color:#ef6c00}body.dark-mode .mat-radio-button.mat-accent.mat-radio-checked .mat-radio-outer-circle{border-color:#ef6c00}body.dark-mode .mat-radio-button.mat-accent .mat-radio-inner-circle,body.dark-mode .mat-radio-button.mat-accent .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),body.dark-mode .mat-radio-button.mat-accent.mat-radio-checked .mat-radio-persistent-ripple,body.dark-mode .mat-radio-button.mat-accent:active .mat-radio-persistent-ripple{background-color:#ef6c00}body.dark-mode .mat-radio-button.mat-warn.mat-radio-checked .mat-radio-outer-circle{border-color:#f44336}body.dark-mode .mat-radio-button.mat-warn .mat-radio-inner-circle,body.dark-mode .mat-radio-button.mat-warn .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),body.dark-mode .mat-radio-button.mat-warn.mat-radio-checked .mat-radio-persistent-ripple,body.dark-mode .mat-radio-button.mat-warn:active .mat-radio-persistent-ripple{background-color:#f44336}body.dark-mode .mat-radio-button.mat-radio-disabled.mat-radio-checked .mat-radio-outer-circle,body.dark-mode .mat-radio-button.mat-radio-disabled .mat-radio-outer-circle{border-color:rgba(255,255,255,.5)}body.dark-mode .mat-radio-button.mat-radio-disabled .mat-radio-ripple .mat-ripple-element,body.dark-mode .mat-radio-button.mat-radio-disabled .mat-radio-inner-circle{background-color:rgba(255,255,255,.5)}body.dark-mode .mat-radio-button.mat-radio-disabled .mat-radio-label-content{color:rgba(255,255,255,.5)}body.dark-mode .mat-radio-button .mat-ripple-element{background-color:#fff}body.dark-mode .mat-select-value{color:#fff}body.dark-mode .mat-select-placeholder{color:rgba(255,255,255,.5)}body.dark-mode .mat-select-disabled .mat-select-value{color:#616161}body.dark-mode .mat-select-arrow{color:rgba(255,255,255,.7)}body.dark-mode .mat-select-panel{background:#424242}body.dark-mode .mat-select-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-select-panel .mat-option.mat-selected:not(.mat-option-multiple){background:rgba(255,255,255,.12)}body.dark-mode .mat-form-field.mat-focused.mat-primary .mat-select-arrow{color:#ef6c00}body.dark-mode .mat-form-field.mat-focused.mat-accent .mat-select-arrow{color:#ef6c00}body.dark-mode .mat-form-field.mat-focused.mat-warn .mat-select-arrow{color:#f44336}body.dark-mode .mat-form-field .mat-select.mat-select-invalid .mat-select-arrow{color:#f44336}body.dark-mode .mat-form-field .mat-select.mat-select-disabled .mat-select-arrow{color:#616161}body.dark-mode .mat-drawer-container{background-color:#303030;color:#fff}body.dark-mode .mat-drawer{background-color:#424242;color:#fff}body.dark-mode .mat-drawer.mat-drawer-push{background-color:#424242}body.dark-mode .mat-drawer:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-drawer-side{border-right:solid 1px rgba(255,255,255,.12)}body.dark-mode .mat-drawer-side.mat-drawer-end{border-left:solid 1px rgba(255,255,255,.12);border-right:none}body.dark-mode [dir=rtl] .mat-drawer-side{border-left:solid 1px rgba(255,255,255,.12);border-right:none}body.dark-mode [dir=rtl] .mat-drawer-side.mat-drawer-end{border-left:none;border-right:solid 1px rgba(255,255,255,.12)}body.dark-mode .mat-drawer-backdrop.mat-drawer-shown{background-color:rgba(189,189,189,.6)}body.dark-mode .mat-slide-toggle.mat-checked .mat-slide-toggle-thumb{background-color:#ef6c00}body.dark-mode .mat-slide-toggle.mat-checked .mat-slide-toggle-bar{background-color:rgba(239,108,0,.54)}body.dark-mode .mat-slide-toggle.mat-checked .mat-ripple-element{background-color:#ef6c00}body.dark-mode .mat-slide-toggle.mat-primary.mat-checked .mat-slide-toggle-thumb{background-color:#ef6c00}body.dark-mode .mat-slide-toggle.mat-primary.mat-checked .mat-slide-toggle-bar{background-color:rgba(239,108,0,.54)}body.dark-mode .mat-slide-toggle.mat-primary.mat-checked .mat-ripple-element{background-color:#ef6c00}body.dark-mode .mat-slide-toggle.mat-warn.mat-checked .mat-slide-toggle-thumb{background-color:#f44336}body.dark-mode .mat-slide-toggle.mat-warn.mat-checked .mat-slide-toggle-bar{background-color:rgba(244,67,54,.54)}body.dark-mode .mat-slide-toggle.mat-warn.mat-checked .mat-ripple-element{background-color:#f44336}body.dark-mode .mat-slide-toggle:not(.mat-checked) .mat-ripple-element{background-color:#fff}body.dark-mode .mat-slide-toggle-thumb{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#bdbdbd}body.dark-mode .mat-slide-toggle-bar{background-color:rgba(255,255,255,.5)}body.dark-mode .mat-slider-track-background{background-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider.mat-primary .mat-slider-track-fill,body.dark-mode .mat-slider.mat-primary .mat-slider-thumb,body.dark-mode .mat-slider.mat-primary .mat-slider-thumb-label{background-color:#ef6c00}body.dark-mode .mat-slider.mat-primary .mat-slider-thumb-label-text{color:#fff}body.dark-mode .mat-slider.mat-primary .mat-slider-focus-ring{background-color:rgba(239,108,0,.2)}body.dark-mode .mat-slider.mat-accent .mat-slider-track-fill,body.dark-mode .mat-slider.mat-accent .mat-slider-thumb,body.dark-mode .mat-slider.mat-accent .mat-slider-thumb-label{background-color:#ef6c00}body.dark-mode .mat-slider.mat-accent .mat-slider-thumb-label-text{color:#fff}body.dark-mode .mat-slider.mat-accent .mat-slider-focus-ring{background-color:rgba(239,108,0,.2)}body.dark-mode .mat-slider.mat-warn .mat-slider-track-fill,body.dark-mode .mat-slider.mat-warn .mat-slider-thumb,body.dark-mode .mat-slider.mat-warn .mat-slider-thumb-label{background-color:#f44336}body.dark-mode .mat-slider.mat-warn .mat-slider-thumb-label-text{color:#fff}body.dark-mode .mat-slider.mat-warn .mat-slider-focus-ring{background-color:rgba(244,67,54,.2)}body.dark-mode .mat-slider:hover .mat-slider-track-background,body.dark-mode .mat-slider.cdk-focused .mat-slider-track-background{background-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider.mat-slider-disabled .mat-slider-track-background,body.dark-mode .mat-slider.mat-slider-disabled .mat-slider-track-fill,body.dark-mode .mat-slider.mat-slider-disabled .mat-slider-thumb{background-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider.mat-slider-disabled:hover .mat-slider-track-background{background-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider.mat-slider-min-value .mat-slider-focus-ring{background-color:rgba(255,255,255,.12)}body.dark-mode .mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing .mat-slider-thumb,body.dark-mode .mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing .mat-slider-thumb-label{background-color:#fff}body.dark-mode .mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused .mat-slider-thumb,body.dark-mode .mat-slider.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused .mat-slider-thumb-label{background-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing) .mat-slider-thumb{border-color:rgba(255,255,255,.3);background-color:rgba(0,0,0,0)}body.dark-mode .mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing):hover .mat-slider-thumb,body.dark-mode .mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing).cdk-focused .mat-slider-thumb{border-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled .mat-slider-thumb,body.dark-mode .mat-slider.mat-slider-min-value:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled .mat-slider-thumb{border-color:rgba(255,255,255,.3)}body.dark-mode .mat-slider-has-ticks .mat-slider-wrapper::after{border-color:rgba(255,255,255,.7)}body.dark-mode .mat-slider-horizontal .mat-slider-ticks{background-image:repeating-linear-gradient(to right, rgba(255, 255, 255, 0.7), rgba(255, 255, 255, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(255, 255, 255, 0.7), rgba(255, 255, 255, 0.7) 2px, transparent 0, transparent)}body.dark-mode .mat-slider-vertical .mat-slider-ticks{background-image:repeating-linear-gradient(to bottom, rgba(255, 255, 255, 0.7), rgba(255, 255, 255, 0.7) 2px, transparent 0, transparent)}body.dark-mode .mat-step-header.cdk-keyboard-focused,body.dark-mode .mat-step-header.cdk-program-focused,body.dark-mode .mat-step-header:hover:not([aria-disabled]),body.dark-mode .mat-step-header:hover[aria-disabled=false]{background-color:rgba(255,255,255,.04)}body.dark-mode .mat-step-header:hover[aria-disabled=true]{cursor:default}@media(hover: none){body.dark-mode .mat-step-header:hover{background:none}}body.dark-mode .mat-step-header .mat-step-label,body.dark-mode .mat-step-header .mat-step-optional{color:rgba(255,255,255,.7)}body.dark-mode .mat-step-header .mat-step-icon{background-color:rgba(255,255,255,.7);color:#fff}body.dark-mode .mat-step-header .mat-step-icon-selected,body.dark-mode .mat-step-header .mat-step-icon-state-done,body.dark-mode .mat-step-header .mat-step-icon-state-edit{background-color:#ef6c00;color:#fff}body.dark-mode .mat-step-header.mat-accent .mat-step-icon{color:#fff}body.dark-mode .mat-step-header.mat-accent .mat-step-icon-selected,body.dark-mode .mat-step-header.mat-accent .mat-step-icon-state-done,body.dark-mode .mat-step-header.mat-accent .mat-step-icon-state-edit{background-color:#ef6c00;color:#fff}body.dark-mode .mat-step-header.mat-warn .mat-step-icon{color:#fff}body.dark-mode .mat-step-header.mat-warn .mat-step-icon-selected,body.dark-mode .mat-step-header.mat-warn .mat-step-icon-state-done,body.dark-mode .mat-step-header.mat-warn .mat-step-icon-state-edit{background-color:#f44336;color:#fff}body.dark-mode .mat-step-header .mat-step-icon-state-error{background-color:rgba(0,0,0,0);color:#f44336}body.dark-mode .mat-step-header .mat-step-label.mat-step-label-active{color:#fff}body.dark-mode .mat-step-header .mat-step-label.mat-step-label-error{color:#f44336}body.dark-mode .mat-stepper-horizontal,body.dark-mode .mat-stepper-vertical{background-color:#424242}body.dark-mode .mat-stepper-vertical-line::before{border-left-color:rgba(255,255,255,.12)}body.dark-mode .mat-horizontal-stepper-header::before,body.dark-mode .mat-horizontal-stepper-header::after,body.dark-mode .mat-stepper-horizontal-line{border-top-color:rgba(255,255,255,.12)}body.dark-mode .mat-horizontal-stepper-header{height:72px}body.dark-mode .mat-stepper-label-position-bottom .mat-horizontal-stepper-header,body.dark-mode .mat-vertical-stepper-header{padding:24px 24px}body.dark-mode .mat-stepper-vertical-line::before{top:-16px;bottom:-16px}body.dark-mode .mat-stepper-label-position-bottom .mat-horizontal-stepper-header::after,body.dark-mode .mat-stepper-label-position-bottom .mat-horizontal-stepper-header::before{top:36px}body.dark-mode .mat-stepper-label-position-bottom .mat-stepper-horizontal-line{top:36px}body.dark-mode .mat-sort-header-arrow{color:#c6c6c6}body.dark-mode .mat-tab-nav-bar,body.dark-mode .mat-tab-header{border-bottom:1px solid rgba(255,255,255,.12)}body.dark-mode .mat-tab-group-inverted-header .mat-tab-nav-bar,body.dark-mode .mat-tab-group-inverted-header .mat-tab-header{border-top:1px solid rgba(255,255,255,.12);border-bottom:none}body.dark-mode .mat-tab-label,body.dark-mode .mat-tab-link{color:#fff}body.dark-mode .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-link.mat-tab-disabled{color:#616161}body.dark-mode .mat-tab-header-pagination-chevron{border-color:#fff}body.dark-mode .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#616161}body.dark-mode .mat-tab-group[class*=mat-background-]>.mat-tab-header,body.dark-mode .mat-tab-nav-bar[class*=mat-background-]{border-bottom:none;border-top:none}body.dark-mode .mat-tab-group.mat-primary .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-group.mat-primary .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-group.mat-primary .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-group.mat-primary .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled){background-color:rgba(251,140,0,.3)}body.dark-mode .mat-tab-group.mat-primary .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-primary .mat-ink-bar{background-color:#ef6c00}body.dark-mode .mat-tab-group.mat-primary.mat-background-primary>.mat-tab-header .mat-ink-bar,body.dark-mode .mat-tab-group.mat-primary.mat-background-primary>.mat-tab-link-container .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-primary.mat-background-primary>.mat-tab-header .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-primary.mat-background-primary>.mat-tab-link-container .mat-ink-bar{background-color:#fff}body.dark-mode .mat-tab-group.mat-accent .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-group.mat-accent .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-group.mat-accent .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-group.mat-accent .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled){background-color:rgba(251,140,0,.3)}body.dark-mode .mat-tab-group.mat-accent .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-accent .mat-ink-bar{background-color:#ef6c00}body.dark-mode .mat-tab-group.mat-accent.mat-background-accent>.mat-tab-header .mat-ink-bar,body.dark-mode .mat-tab-group.mat-accent.mat-background-accent>.mat-tab-link-container .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-accent.mat-background-accent>.mat-tab-header .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-accent.mat-background-accent>.mat-tab-link-container .mat-ink-bar{background-color:#fff}body.dark-mode .mat-tab-group.mat-warn .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-group.mat-warn .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-group.mat-warn .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-group.mat-warn .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}body.dark-mode .mat-tab-group.mat-warn .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-warn .mat-ink-bar{background-color:#f44336}body.dark-mode .mat-tab-group.mat-warn.mat-background-warn>.mat-tab-header .mat-ink-bar,body.dark-mode .mat-tab-group.mat-warn.mat-background-warn>.mat-tab-link-container .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-warn.mat-background-warn>.mat-tab-header .mat-ink-bar,body.dark-mode .mat-tab-nav-bar.mat-warn.mat-background-warn>.mat-tab-link-container .mat-ink-bar{background-color:#fff}body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-group.mat-background-primary .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled){background-color:rgba(251,140,0,.3)}body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-link-container,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header-pagination,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination{background-color:#ef6c00}body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-label,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-tab-link,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-label,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-tab-link{color:#fff}body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-tab-link.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-focus-indicator::before,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header .mat-focus-indicator::before,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-focus-indicator::before,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-focus-indicator::before{border-color:#fff}body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#fff;opacity:.4}body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header .mat-ripple-element,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-link-container .mat-ripple-element,body.dark-mode .mat-tab-group.mat-background-primary>.mat-tab-header-pagination .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-link-container .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-primary>.mat-tab-header-pagination .mat-ripple-element{background-color:#fff;opacity:.12}body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-group.mat-background-accent .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled){background-color:rgba(251,140,0,.3)}body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-link-container,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header-pagination,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination{background-color:#ef6c00}body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-label,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-tab-link,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-label,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-tab-link{color:#fff}body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-tab-link.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-focus-indicator::before,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header .mat-focus-indicator::before,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-focus-indicator::before,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-focus-indicator::before{border-color:#fff}body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#fff;opacity:.4}body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header .mat-ripple-element,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-link-container .mat-ripple-element,body.dark-mode .mat-tab-group.mat-background-accent>.mat-tab-header-pagination .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-link-container .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-accent>.mat-tab-header-pagination .mat-ripple-element{background-color:#fff;opacity:.12}body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-group.mat-background-warn .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),body.dark-mode .mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-link-container,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header-pagination,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination{background-color:#f44336}body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-label,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-tab-link,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-label,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-tab-link{color:#fff}body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-tab-link.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-label.mat-tab-disabled,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-focus-indicator::before,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header .mat-focus-indicator::before,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-focus-indicator::before,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-focus-indicator::before{border-color:#fff}body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#fff;opacity:.4}body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header .mat-ripple-element,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-link-container .mat-ripple-element,body.dark-mode .mat-tab-group.mat-background-warn>.mat-tab-header-pagination .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-link-container .mat-ripple-element,body.dark-mode .mat-tab-nav-bar.mat-background-warn>.mat-tab-header-pagination .mat-ripple-element{background-color:#fff;opacity:.12}body.dark-mode .mat-toolbar{background:#ef6c00;color:#fff}body.dark-mode .mat-toolbar.mat-primary{background:#ef6c00;color:#fff}body.dark-mode .mat-toolbar.mat-accent{background:#ef6c00;color:#fff}body.dark-mode .mat-toolbar.mat-warn{background:#f44336;color:#fff}body.dark-mode .mat-toolbar .mat-form-field-underline,body.dark-mode .mat-toolbar .mat-form-field-ripple,body.dark-mode .mat-toolbar .mat-focused .mat-form-field-ripple{background-color:currentColor}body.dark-mode .mat-toolbar .mat-form-field-label,body.dark-mode .mat-toolbar .mat-focused .mat-form-field-label,body.dark-mode .mat-toolbar .mat-select-value,body.dark-mode .mat-toolbar .mat-select-arrow,body.dark-mode .mat-toolbar .mat-form-field.mat-focused .mat-select-arrow{color:inherit}body.dark-mode .mat-toolbar .mat-input-element{caret-color:currentColor}body.dark-mode .mat-toolbar-multiple-rows{min-height:64px}body.dark-mode .mat-toolbar-row,body.dark-mode .mat-toolbar-single-row{height:64px}@media(max-width: 599px){body.dark-mode .mat-toolbar-multiple-rows{min-height:56px}body.dark-mode .mat-toolbar-row,body.dark-mode .mat-toolbar-single-row{height:56px}}body.dark-mode .mat-tooltip{background:rgba(97,97,97,.9)}body.dark-mode .mat-tree{background:#424242}body.dark-mode .mat-tree-node,body.dark-mode .mat-nested-tree-node{color:#fff}body.dark-mode .mat-tree-node{min-height:48px}body.dark-mode .mat-snack-bar-container{color:rgba(0,0,0,.87);background:#fafafa;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}body.dark-mode .mat-simple-snackbar-action{color:inherit}
</style>

<style>
  html,
  body {
    margin: 0;
    padding: 0;
    height: 100%;
    font-family: Roboto, sans-serif;
    color: var(--primary-text-color);

    /* Legacy mechanism to avoid issues with subpixel anti-aliasing on macOS.
     *
     * In the past [1], macOS subpixel AA caused excessive bolding for light-on-dark text; this rule
     * avoids that by requesting non-subpixel AA always, rather than the default behavior, which is
     * to use subpixel AA when available. The original issue was "fixed" by removing subpixel AA in
     * macOS 14 (Mojave), but for legacy reasons they preserved the bolding effect as an option.
     * Chrome then in turn updated its font rendering to apply that bolding effect [2], which means
     * that even though the `-webkit-font-smoothing` docs [3] suggest that setting `antialiased`
     * would have no effect for recent versions of macOS, it still is needed to avoid the bolding.
     *
     * [1]: http://www.lighterra.com/articles/macosxtextaabug/
     * [2]: https://bugs.chromium.org/p/chromium/issues/detail?id=858861
     * [3]: https://developer.mozilla.org/en-US/docs/Web/CSS/font-smooth
     *
     */

    -webkit-font-smoothing: antialiased;
  }
  noscript {
    display: block;
    margin: 0 auto;
    max-width: 600px;
    padding: 10px;
  }
</style>

</head><body><noscript>
    <h1>TensorBoard requires JavaScript</h1>
    <p>Please enable JavaScript and reload this page.</p>
  </noscript><tb-webapp></tb-webapp><script src="index.js?_file_hash=486f34d2"></script></body></html>",
+              "headers": [
+                [
+                  "content-type",
+                  "text/html; charset=utf-8"
+                ]
+              ],
+              "ok": true,
+              "status": 200,
+              "status_text": ""
+            },
+            "https://localhost:6006/chart_worker.js?_file_hash=c4417681": {
+              "data": "(()=>{var H0=Object.defineProperty,V0=Object.defineProperties;var G0=Object.getOwnPropertyDescriptors;var af=Object.getOwnPropertySymbols;var W0=Object.prototype.hasOwnProperty,q0=Object.prototype.propertyIsEnumerable;var cf=Math.pow,lf=(n,t,e)=>t in n?H0(n,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):n[t]=e,No=(n,t)=>{for(var e in t||(t={}))W0.call(t,e)&&lf(n,e,t[e]);if(af)for(var e of af(t))q0.call(t,e)&&lf(n,e,t[e]);return n},uf=(n,t)=>V0(n,G0(t));var hf=(n,t,e)=>new Promise((i,r)=>{var s=l=>{try{a(e.next(l))}catch(c){r(c)}},o=l=>{try{a(e.throw(l))}catch(c){r(c)}},a=l=>l.done?i(l.value):Promise.resolve(l.value).then(s,o);a((e=e.apply(n,t)).next())});var on;(function(n){n[n.LINEAR=0]="LINEAR",n[n.LOG10=1]="LOG10",n[n.TIME=2]="TIME"})(on||(on={}));function an(n,t){return n<t?-1:n>t?1:n>=t?0:NaN}function is(n){return n.length===1&&(n=X0(n)),{left:function(t,e,i,r){for(i==null&&(i=0),r==null&&(r=t.length);i<r;){var s=i+r>>>1;n(t[s],e)<0?i=s+1:r=s}return i},right:function(t,e,i,r){for(i==null&&(i=0),r==null&&(r=t.length);i<r;){var s=i+r>>>1;n(t[s],e)>0?r=s:i=s+1}return i}}}function X0(n){return function(t,e){return an(n(t),e)}}var ff=is(an),df=ff.right,Y0=ff.left,Bn=df;var pf=Array.prototype,J0=pf.slice,$0=pf.map;var kl=Math.sqrt(50),Hl=Math.sqrt(10),Vl=Math.sqrt(2);function rs(n,t,e){var i,r=-1,s,o,a;if(t=+t,n=+n,e=+e,n===t&&e>0)return[n];if((i=t<n)&&(s=n,n=t,t=s),(a=Ji(n,t,e))===0||!isFinite(a))return[];if(a>0)for(n=Math.ceil(n/a),t=Math.floor(t/a),o=new Array(s=Math.ceil(t-n+1));++r<s;)o[r]=(n+r)*a;else for(n=Math.floor(n*a),t=Math.ceil(t*a),o=new Array(s=Math.ceil(n-t+1));++r<s;)o[r]=(n-r)/a;return i&&o.reverse(),o}function Ji(n,t,e){var i=(t-n)/Math.max(0,e),r=Math.floor(Math.log(i)/Math.LN10),s=i/Math.pow(10,r);return r>=0?(s>=kl?10:s>=Hl?5:s>=Vl?2:1)*Math.pow(10,r):-Math.pow(10,-r)/(s>=kl?10:s>=Hl?5:s>=Vl?2:1)}function _n(n,t,e){var i=Math.abs(t-n)/Math.max(0,e),r=Math.pow(10,Math.floor(Math.log(i)/Math.LN10)),s=i/r;return s>=kl?r*=10:s>=Hl?r*=5:s>=Vl&&(r*=2),t<n?-r:r}var ex=Array.prototype.slice;var nx={value:function(){}};function yf(){for(var n=0,t=arguments.length,e={},i;n<t;++n){if(!(i=arguments[n]+"")||i in e||/[\s.]/.test(i))throw new Error("illegal type: "+i);e[i]=[]}return new zo(e)}function zo(n){this._=n}function ix(n,t){return n.trim().split(/^|\s+/).map(function(e){var i="",r=e.indexOf(".");if(r>=0&&(i=e.slice(r+1),e=e.slice(0,r)),e&&!t.hasOwnProperty(e))throw new Error("unknown type: "+e);return{type:e,name:i}})}zo.prototype=yf.prototype={constructor:zo,on:function(n,t){var e=this._,i=ix(n+"",e),r,s=-1,o=i.length;if(arguments.length<2){for(;++s<o;)if((r=(n=i[s]).type)&&(r=rx(e[r],n.name)))return r;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++s<o;)if(r=(n=i[s]).type)e[r]=xf(e[r],n.name,t);else if(t==null)for(r in e)e[r]=xf(e[r],n.name,null);return this},copy:function(){var n={},t=this._;for(var e in t)n[e]=t[e].slice();return new zo(n)},call:function(n,t){if((r=arguments.length-2)>0)for(var e=new Array(r),i=0,r,s;i<r;++i)e[i]=arguments[i+2];if(!this._.hasOwnProperty(n))throw new Error("unknown type: "+n);for(s=this._[n],i=0,r=s.length;i<r;++i)s[i].value.apply(t,e)},apply:function(n,t,e){if(!this._.hasOwnProperty(n))throw new Error("unknown type: "+n);for(var i=this._[n],r=0,s=i.length;r<s;++r)i[r].value.apply(t,e)}};function rx(n,t){for(var e=0,i=n.length,r;e<i;++e)if((r=n[e]).name===t)return r.value}function xf(n,t,e){for(var i=0,r=n.length;i<r;++i)if(n[i].name===t){n[i]=nx,n=n.slice(0,i).concat(n.slice(i+1));break}return e!=null&&n.push({name:t,value:e}),n}var Wl=yf;var Uo="http://www.w3.org/1999/xhtml",ql={svg:"http://www.w3.org/2000/svg",xhtml:Uo,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};function wn(n){var t=n+="",e=t.indexOf(":");return e>=0&&(t=n.slice(0,e))!=="xmlns"&&(n=n.slice(e+1)),ql.hasOwnProperty(t)?{space:ql[t],local:n}:n}function sx(n){return function(){var t=this.ownerDocument,e=this.namespaceURI;return e===Uo&&t.documentElement.namespaceURI===Uo?t.createElement(n):t.createElementNS(e,n)}}function ox(n){return function(){return this.ownerDocument.createElementNS(n.space,n.local)}}function Bo(n){var t=wn(n);return(t.local?ox:sx)(t)}function ax(){}function di(n){return n==null?ax:function(){return this.querySelector(n)}}function vf(n){typeof n!="function"&&(n=di(n));for(var t=this._groups,e=t.length,i=new Array(e),r=0;r<e;++r)for(var s=t[r],o=s.length,a=i[r]=new Array(o),l,c,u=0;u<o;++u)(l=s[u])&&(c=n.call(l,l.__data__,u,s))&&("__data__"in l&&(c.__data__=l.__data__),a[u]=c);return new ce(i,this._parents)}function lx(){return[]}function os(n){return n==null?lx:function(){return this.querySelectorAll(n)}}function _f(n){typeof n!="function"&&(n=os(n));for(var t=this._groups,e=t.length,i=[],r=[],s=0;s<e;++s)for(var o=t[s],a=o.length,l,c=0;c<a;++c)(l=o[c])&&(i.push(n.call(l,l.__data__,c,o)),r.push(l));return new ce(i,r)}function as(n){return function(){return this.matches(n)}}function wf(n){typeof n!="function"&&(n=as(n));for(var t=this._groups,e=t.length,i=new Array(e),r=0;r<e;++r)for(var s=t[r],o=s.length,a=i[r]=[],l,c=0;c<o;++c)(l=s[c])&&n.call(l,l.__data__,c,s)&&a.push(l);return new ce(i,this._parents)}function Oo(n){return new Array(n.length)}function Mf(){return new ce(this._enter||this._groups.map(Oo),this._parents)}function ls(n,t){this.ownerDocument=n.ownerDocument,this.namespaceURI=n.namespaceURI,this._next=null,this._parent=n,this.__data__=t}ls.prototype={constructor:ls,appendChild:function(n){return this._parent.insertBefore(n,this._next)},insertBefore:function(n,t){return this._parent.insertBefore(n,t)},querySelector:function(n){return this._parent.querySelector(n)},querySelectorAll:function(n){return this._parent.querySelectorAll(n)}};function bf(n){return function(){return n}}var Sf="$";function cx(n,t,e,i,r,s){for(var o=0,a,l=t.length,c=s.length;o<c;++o)(a=t[o])?(a.__data__=s[o],i[o]=a):e[o]=new ls(n,s[o]);for(;o<l;++o)(a=t[o])&&(r[o]=a)}function ux(n,t,e,i,r,s,o){var a,l,c={},u=t.length,h=s.length,f=new Array(u),d;for(a=0;a<u;++a)(l=t[a])&&(f[a]=d=Sf+o.call(l,l.__data__,a,t),d in c?r[a]=l:c[d]=l);for(a=0;a<h;++a)d=Sf+o.call(n,s[a],a,s),(l=c[d])?(i[a]=l,l.__data__=s[a],c[d]=null):e[a]=new ls(n,s[a]);for(a=0;a<u;++a)(l=t[a])&&c[f[a]]===l&&(r[a]=l)}function Ef(n,t){if(!n)return d=new Array(this.size()),c=-1,this.each(function(L){d[++c]=L}),d;var e=t?ux:cx,i=this._parents,r=this._groups;typeof n!="function"&&(n=bf(n));for(var s=r.length,o=new Array(s),a=new Array(s),l=new Array(s),c=0;c<s;++c){var u=i[c],h=r[c],f=h.length,d=n.call(u,u&&u.__data__,c,i),g=d.length,x=a[c]=new Array(g),v=o[c]=new Array(g),m=l[c]=new Array(f);e(u,h,x,v,m,d,t);for(var p=0,b=0,_,S;p<g;++p)if(_=x[p]){for(p>=b&&(b=p+1);!(S=v[b])&&++b<g;);_._next=S||null}}return o=new ce(o,i),o._enter=a,o._exit=l,o}function Tf(){return new ce(this._exit||this._groups.map(Oo),this._parents)}function Af(n,t,e){var i=this.enter(),r=this,s=this.exit();return i=typeof n=="function"?n(i):i.append(n+""),t!=null&&(r=t(r)),e==null?s.remove():e(s),i&&r?i.merge(r).order():r}function Cf(n){for(var t=this._groups,e=n._groups,i=t.length,r=e.length,s=Math.min(i,r),o=new Array(i),a=0;a<s;++a)for(var l=t[a],c=e[a],u=l.length,h=o[a]=new Array(u),f,d=0;d<u;++d)(f=l[d]||c[d])&&(h[d]=f);for(;a<i;++a)o[a]=t[a];return new ce(o,this._parents)}function Rf(){for(var n=this._groups,t=-1,e=n.length;++t<e;)for(var i=n[t],r=i.length-1,s=i[r],o;--r>=0;)(o=i[r])&&(s&&o.compareDocumentPosition(s)^4&&s.parentNode.insertBefore(o,s),s=o);return this}function Lf(n){n||(n=hx);function t(h,f){return h&&f?n(h.__data__,f.__data__):!h-!f}for(var e=this._groups,i=e.length,r=new Array(i),s=0;s<i;++s){for(var o=e[s],a=o.length,l=r[s]=new Array(a),c,u=0;u<a;++u)(c=o[u])&&(l[u]=c);l.sort(t)}return new ce(r,this._parents).order()}function hx(n,t){return n<t?-1:n>t?1:n>=t?0:NaN}function Pf(){var n=arguments[0];return arguments[0]=this,n.apply(null,arguments),this}function Df(){var n=new Array(this.size()),t=-1;return this.each(function(){n[++t]=this}),n}function If(){for(var n=this._groups,t=0,e=n.length;t<e;++t)for(var i=n[t],r=0,s=i.length;r<s;++r){var o=i[r];if(o)return o}return null}function Nf(){var n=0;return this.each(function(){++n}),n}function Ff(){return!this.node()}function zf(n){for(var t=this._groups,e=0,i=t.length;e<i;++e)for(var r=t[e],s=0,o=r.length,a;s<o;++s)(a=r[s])&&n.call(a,a.__data__,s,r);return this}function fx(n){return function(){this.removeAttribute(n)}}function dx(n){return function(){this.removeAttributeNS(n.space,n.local)}}function px(n,t){return function(){this.setAttribute(n,t)}}function mx(n,t){return function(){this.setAttributeNS(n.space,n.local,t)}}function gx(n,t){return function(){var e=t.apply(this,arguments);e==null?this.removeAttribute(n):this.setAttribute(n,e)}}function xx(n,t){return function(){var e=t.apply(this,arguments);e==null?this.removeAttributeNS(n.space,n.local):this.setAttributeNS(n.space,n.local,e)}}function Uf(n,t){var e=wn(n);if(arguments.length<2){var i=this.node();return e.local?i.getAttributeNS(e.space,e.local):i.getAttribute(e)}return this.each((t==null?e.local?dx:fx:typeof t=="function"?e.local?xx:gx:e.local?mx:px)(e,t))}function ko(n){return n.ownerDocument&&n.ownerDocument.defaultView||n.document&&n||n.defaultView}function yx(n){return function(){this.style.removeProperty(n)}}function vx(n,t,e){return function(){this.style.setProperty(n,t,e)}}function _x(n,t,e){return function(){var i=t.apply(this,arguments);i==null?this.style.removeProperty(n):this.style.setProperty(n,i,e)}}function Bf(n,t,e){return arguments.length>1?this.each((t==null?yx:typeof t=="function"?_x:vx)(n,t,e==null?"":e)):On(this.node(),n)}function On(n,t){return n.style.getPropertyValue(t)||ko(n).getComputedStyle(n,null).getPropertyValue(t)}function wx(n){return function(){delete this[n]}}function Mx(n,t){return function(){this[n]=t}}function bx(n,t){return function(){var e=t.apply(this,arguments);e==null?delete this[n]:this[n]=e}}function Of(n,t){return arguments.length>1?this.each((t==null?wx:typeof t=="function"?bx:Mx)(n,t)):this.node()[n]}function kf(n){return n.trim().split(/^|\s+/)}function Xl(n){return n.classList||new Hf(n)}function Hf(n){this._node=n,this._names=kf(n.getAttribute("class")||"")}Hf.prototype={add:function(n){var t=this._names.indexOf(n);t<0&&(this._names.push(n),this._node.setAttribute("class",this._names.join(" ")))},remove:function(n){var t=this._names.indexOf(n);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(n){return this._names.indexOf(n)>=0}};function Vf(n,t){for(var e=Xl(n),i=-1,r=t.length;++i<r;)e.add(t[i])}function Gf(n,t){for(var e=Xl(n),i=-1,r=t.length;++i<r;)e.remove(t[i])}function Sx(n){return function(){Vf(this,n)}}function Ex(n){return function(){Gf(this,n)}}function Tx(n,t){return function(){(t.apply(this,arguments)?Vf:Gf)(this,n)}}function Wf(n,t){var e=kf(n+"");if(arguments.length<2){for(var i=Xl(this.node()),r=-1,s=e.length;++r<s;)if(!i.contains(e[r]))return!1;return!0}return this.each((typeof t=="function"?Tx:t?Sx:Ex)(e,t))}function Ax(){this.textContent=""}function Cx(n){return function(){this.textContent=n}}function Rx(n){return function(){var t=n.apply(this,arguments);this.textContent=t==null?"":t}}function qf(n){return arguments.length?this.each(n==null?Ax:(typeof n=="function"?Rx:Cx)(n)):this.node().textContent}function Lx(){this.innerHTML=""}function Px(n){return function(){this.innerHTML=n}}function Dx(n){return function(){var t=n.apply(this,arguments);this.innerHTML=t==null?"":t}}function Xf(n){return arguments.length?this.each(n==null?Lx:(typeof n=="function"?Dx:Px)(n)):this.node().innerHTML}function Ix(){this.nextSibling&&this.parentNode.appendChild(this)}function Yf(){return this.each(Ix)}function Nx(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function Zf(){return this.each(Nx)}function Jf(n){var t=typeof n=="function"?n:Bo(n);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}function Fx(){return null}function $f(n,t){var e=typeof n=="function"?n:Bo(n),i=t==null?Fx:typeof t=="function"?t:di(t);return this.select(function(){return this.insertBefore(e.apply(this,arguments),i.apply(this,arguments)||null)})}function zx(){var n=this.parentNode;n&&n.removeChild(this)}function Kf(){return this.each(zx)}function Ux(){var n=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(n,this.nextSibling):n}function Bx(){var n=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(n,this.nextSibling):n}function Qf(n){return this.select(n?Bx:Ux)}function jf(n){return arguments.length?this.property("__data__",n):this.node().__data__}var ed={},Yl=null;typeof document!="undefined"&&(td=document.documentElement,"onmouseenter"in td||(ed={mouseenter:"mouseover",mouseleave:"mouseout"}));var td;function Ox(n,t,e){return n=nd(n,t,e),function(i){var r=i.relatedTarget;(!r||r!==this&&!(r.compareDocumentPosition(this)&8))&&n.call(this,i)}}function nd(n,t,e){return function(i){var r=Yl;Yl=i;try{n.call(this,this.__data__,t,e)}finally{Yl=r}}}function kx(n){return n.trim().split(/^|\s+/).map(function(t){var e="",i=t.indexOf(".");return i>=0&&(e=t.slice(i+1),t=t.slice(0,i)),{type:t,name:e}})}function Hx(n){return function(){var t=this.__on;if(!!t){for(var e=0,i=-1,r=t.length,s;e<r;++e)s=t[e],(!n.type||s.type===n.type)&&s.name===n.name?this.removeEventListener(s.type,s.listener,s.capture):t[++i]=s;++i?t.length=i:delete this.__on}}}function Vx(n,t,e){var i=ed.hasOwnProperty(n.type)?Ox:nd;return function(r,s,o){var a=this.__on,l,c=i(t,s,o);if(a){for(var u=0,h=a.length;u<h;++u)if((l=a[u]).type===n.type&&l.name===n.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=e),l.value=t;return}}this.addEventListener(n.type,c,e),l={type:n.type,name:n.name,value:t,listener:c,capture:e},a?a.push(l):this.__on=[l]}}function id(n,t,e){var i=kx(n+""),r,s=i.length,o;if(arguments.length<2){var a=this.node().__on;if(a){for(var l=0,c=a.length,u;l<c;++l)for(r=0,u=a[l];r<s;++r)if((o=i[r]).type===u.type&&o.name===u.name)return u.value}return}for(a=t?Vx:Hx,e==null&&(e=!1),r=0;r<s;++r)this.each(a(i[r],t,e));return this}function rd(n,t,e){var i=ko(n),r=i.CustomEvent;typeof r=="function"?r=new r(t,e):(r=i.document.createEvent("Event"),e?(r.initEvent(t,e.bubbles,e.cancelable),r.detail=e.detail):r.initEvent(t,!1,!1)),n.dispatchEvent(r)}function Gx(n,t){return function(){return rd(this,n,t)}}function Wx(n,t){return function(){return rd(this,n,t.apply(this,arguments))}}function sd(n,t){return this.each((typeof t=="function"?Wx:Gx)(n,t))}var qx=[null];function ce(n,t){this._groups=n,this._parents=t}function od(){return new ce([[document.documentElement]],qx)}ce.prototype=od.prototype={constructor:ce,select:vf,selectAll:_f,filter:wf,data:Ef,enter:Mf,exit:Tf,join:Af,merge:Cf,order:Rf,sort:Lf,call:Pf,nodes:Df,node:If,size:Nf,empty:Ff,each:zf,attr:Uf,style:Bf,property:Of,classed:Wf,text:qf,html:Xf,raise:Yf,lower:Zf,append:Jf,insert:$f,remove:Kf,clone:Qf,datum:jf,on:id,dispatch:sd};var Mn=od;function Ho(n,t,e){n.prototype=t.prototype=e,e.constructor=n}function Zl(n,t){var e=Object.create(n.prototype);for(var i in t)e[i]=t[i];return e}function hs(){}var cs=.7,Go=1/cs,$i="\\s*([+-]?\\d+)\\s*",us="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",cn="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",Xx=/^#([0-9a-f]{3,8})$/,Yx=new RegExp("^rgb\\("+[$i,$i,$i]+"\\)$"),Zx=new RegExp("^rgb\\("+[cn,cn,cn]+"\\)$"),Jx=new RegExp("^rgba\\("+[$i,$i,$i,us]+"\\)$"),$x=new RegExp("^rgba\\("+[cn,cn,cn,us]+"\\)$"),Kx=new RegExp("^hsl\\("+[us,cn,cn]+"\\)$"),Qx=new RegExp("^hsla\\("+[us,cn,cn,us]+"\\)$"),ad={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};Ho(hs,Je,{copy:function(n){return Object.assign(new this.constructor,this,n)},displayable:function(){return this.rgb().displayable()},hex:ld,formatHex:ld,formatHsl:jx,formatRgb:cd,toString:cd});function ld(){return this.rgb().formatHex()}function jx(){return pd(this).formatHsl()}function cd(){return this.rgb().formatRgb()}function Je(n){var t,e;return n=(n+"").trim().toLowerCase(),(t=Xx.exec(n))?(e=t[1].length,t=parseInt(t[1],16),e===6?ud(t):e===3?new Ue(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):e===8?Vo(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):e===4?Vo(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=Yx.exec(n))?new Ue(t[1],t[2],t[3],1):(t=Zx.exec(n))?new Ue(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=Jx.exec(n))?Vo(t[1],t[2],t[3],t[4]):(t=$x.exec(n))?Vo(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=Kx.exec(n))?dd(t[1],t[2]/100,t[3]/100,1):(t=Qx.exec(n))?dd(t[1],t[2]/100,t[3]/100,t[4]):ad.hasOwnProperty(n)?ud(ad[n]):n==="transparent"?new Ue(NaN,NaN,NaN,0):null}function ud(n){return new Ue(n>>16&255,n>>8&255,n&255,1)}function Vo(n,t,e,i){return i<=0&&(n=t=e=NaN),new Ue(n,t,e,i)}function ty(n){return n instanceof hs||(n=Je(n)),n?(n=n.rgb(),new Ue(n.r,n.g,n.b,n.opacity)):new Ue}function Ki(n,t,e,i){return arguments.length===1?ty(n):new Ue(n,t,e,i==null?1:i)}function Ue(n,t,e,i){this.r=+n,this.g=+t,this.b=+e,this.opacity=+i}Ho(Ue,Ki,Zl(hs,{brighter:function(n){return n=n==null?Go:Math.pow(Go,n),new Ue(this.r*n,this.g*n,this.b*n,this.opacity)},darker:function(n){return n=n==null?cs:Math.pow(cs,n),new Ue(this.r*n,this.g*n,this.b*n,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:hd,formatHex:hd,formatRgb:fd,toString:fd}));function hd(){return"#"+Jl(this.r)+Jl(this.g)+Jl(this.b)}function fd(){var n=this.opacity;return n=isNaN(n)?1:Math.max(0,Math.min(1,n)),(n===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(n===1?")":", "+n+")")}function Jl(n){return n=Math.max(0,Math.min(255,Math.round(n)||0)),(n<16?"0":"")+n.toString(16)}function dd(n,t,e,i){return i<=0?n=t=e=NaN:e<=0||e>=1?n=t=NaN:t<=0&&(n=NaN),new ln(n,t,e,i)}function pd(n){if(n instanceof ln)return new ln(n.h,n.s,n.l,n.opacity);if(n instanceof hs||(n=Je(n)),!n)return new ln;if(n instanceof ln)return n;n=n.rgb();var t=n.r/255,e=n.g/255,i=n.b/255,r=Math.min(t,e,i),s=Math.max(t,e,i),o=NaN,a=s-r,l=(s+r)/2;return a?(t===s?o=(e-i)/a+(e<i)*6:e===s?o=(i-t)/a+2:o=(t-e)/a+4,a/=l<.5?s+r:2-s-r,o*=60):a=l>0&&l<1?0:o,new ln(o,a,l,n.opacity)}function pi(n,t,e,i){return arguments.length===1?pd(n):new ln(n,t,e,i==null?1:i)}function ln(n,t,e,i){this.h=+n,this.s=+t,this.l=+e,this.opacity=+i}Ho(ln,pi,Zl(hs,{brighter:function(n){return n=n==null?Go:Math.pow(Go,n),new ln(this.h,this.s,this.l*n,this.opacity)},darker:function(n){return n=n==null?cs:Math.pow(cs,n),new ln(this.h,this.s,this.l*n,this.opacity)},rgb:function(){var n=this.h%360+(this.h<0)*360,t=isNaN(n)||isNaN(this.s)?0:this.s,e=this.l,i=e+(e<.5?e:1-e)*t,r=2*e-i;return new Ue($l(n>=240?n-240:n+120,r,i),$l(n,r,i),$l(n<120?n+240:n-120,r,i),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var n=this.opacity;return n=isNaN(n)?1:Math.max(0,Math.min(1,n)),(n===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(n===1?")":", "+n+")")}}));function $l(n,t,e){return(n<60?t+(e-t)*n/60:n<180?e:n<240?t+(e-t)*(240-n)/60:t)*255}function Kl(n,t,e,i,r){var s=n*n,o=s*n;return((1-3*n+3*s-o)*t+(4-6*s+3*o)*e+(1+3*n+3*s-3*o)*i+o*r)/6}function md(n){var t=n.length-1;return function(e){var i=e<=0?e=0:e>=1?(e=1,t-1):Math.floor(e*t),r=n[i],s=n[i+1],o=i>0?n[i-1]:2*r-s,a=i<t-1?n[i+2]:2*s-r;return Kl((e-i/t)*t,o,r,s,a)}}function gd(n){var t=n.length;return function(e){var i=Math.floor(((e%=1)<0?++e:e)*t),r=n[(i+t-1)%t],s=n[i%t],o=n[(i+1)%t],a=n[(i+2)%t];return Kl((e-i/t)*t,r,s,o,a)}}function Qi(n){return function(){return n}}function xd(n,t){return function(e){return n+e*t}}function ey(n,t,e){return n=Math.pow(n,e),t=Math.pow(t,e)-n,e=1/e,function(i){return Math.pow(n+i*t,e)}}function yd(n,t){var e=t-n;return e?xd(n,e>180||e<-180?e-360*Math.round(e/360):e):Qi(isNaN(n)?t:n)}function vd(n){return(n=+n)==1?bn:function(t,e){return e-t?ey(t,e,n):Qi(isNaN(t)?e:t)}}function bn(n,t){var e=t-n;return e?xd(n,e):Qi(isNaN(n)?t:n)}var mi=function n(t){var e=vd(t);function i(r,s){var o=e((r=Ki(r)).r,(s=Ki(s)).r),a=e(r.g,s.g),l=e(r.b,s.b),c=bn(r.opacity,s.opacity);return function(u){return r.r=o(u),r.g=a(u),r.b=l(u),r.opacity=c(u),r+""}}return i.gamma=n,i}(1);function _d(n){return function(t){var e=t.length,i=new Array(e),r=new Array(e),s=new Array(e),o,a;for(o=0;o<e;++o)a=Ki(t[o]),i[o]=a.r||0,r[o]=a.g||0,s[o]=a.b||0;return i=n(i),r=n(r),s=n(s),a.opacity=1,function(l){return a.r=i(l),a.g=r(l),a.b=s(l),a+""}}}var ny=_d(md),iy=_d(gd);function wd(n,t){t||(t=[]);var e=n?Math.min(t.length,n.length):0,i=t.slice(),r;return function(s){for(r=0;r<e;++r)i[r]=n[r]*(1-s)+t[r]*s;return i}}function Md(n){return ArrayBuffer.isView(n)&&!(n instanceof DataView)}function bd(n,t){var e=t?t.length:0,i=n?Math.min(e,n.length):0,r=new Array(i),s=new Array(e),o;for(o=0;o<i;++o)r[o]=gi(n[o],t[o]);for(;o<e;++o)s[o]=t[o];return function(a){for(o=0;o<i;++o)s[o]=r[o](a);return s}}function Sd(n,t){var e=new Date;return n=+n,t=+t,function(i){return e.setTime(n*(1-i)+t*i),e}}function ye(n,t){return n=+n,t=+t,function(e){return n*(1-e)+t*e}}function Ed(n,t){var e={},i={},r;(n===null||typeof n!="object")&&(n={}),(t===null||typeof t!="object")&&(t={});for(r in t)r in n?e[r]=gi(n[r],t[r]):i[r]=t[r];return function(s){for(r in e)i[r]=e[r](s);return i}}var jl=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,Ql=new RegExp(jl.source,"g");function ry(n){return function(){return n}}function sy(n){return function(t){return n(t)+""}}function fs(n,t){var e=jl.lastIndex=Ql.lastIndex=0,i,r,s,o=-1,a=[],l=[];for(n=n+"",t=t+"";(i=jl.exec(n))&&(r=Ql.exec(t));)(s=r.index)>e&&(s=t.slice(e,s),a[o]?a[o]+=s:a[++o]=s),(i=i[0])===(r=r[0])?a[o]?a[o]+=r:a[++o]=r:(a[++o]=null,l.push({i:o,x:ye(i,r)})),e=Ql.lastIndex;return e<t.length&&(s=t.slice(e),a[o]?a[o]+=s:a[++o]=s),a.length<2?l[0]?sy(l[0].x):ry(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)a[(h=l[u]).i]=h.x(c);return a.join("")})}function gi(n,t){var e=typeof t,i;return t==null||e==="boolean"?Qi(t):(e==="number"?ye:e==="string"?(i=Je(t))?(t=i,mi):fs:t instanceof Je?mi:t instanceof Date?Sd:Md(t)?wd:Array.isArray(t)?bd:typeof t.valueOf!="function"&&typeof t.toString!="function"||isNaN(t)?Ed:ye)(n,t)}function tc(n,t){return n=+n,t=+t,function(e){return Math.round(n*(1-e)+t*e)}}var Td=180/Math.PI,Wo={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1};function ec(n,t,e,i,r,s){var o,a,l;return(o=Math.sqrt(n*n+t*t))&&(n/=o,t/=o),(l=n*e+t*i)&&(e-=n*l,i-=t*l),(a=Math.sqrt(e*e+i*i))&&(e/=a,i/=a,l/=a),n*i<t*e&&(n=-n,t=-t,l=-l,o=-o),{translateX:r,translateY:s,rotate:Math.atan2(t,n)*Td,skewX:Math.atan(l)*Td,scaleX:o,scaleY:a}}var ds,nc,Ad,qo;function Cd(n){return n==="none"?Wo:(ds||(ds=document.createElement("DIV"),nc=document.documentElement,Ad=document.defaultView),ds.style.transform=n,n=Ad.getComputedStyle(nc.appendChild(ds),null).getPropertyValue("transform"),nc.removeChild(ds),n=n.slice(7,-1).split(","),ec(+n[0],+n[1],+n[2],+n[3],+n[4],+n[5]))}function Rd(n){return n==null?Wo:(qo||(qo=document.createElementNS("http://www.w3.org/2000/svg","g")),qo.setAttribute("transform",n),(n=qo.transform.baseVal.consolidate())?(n=n.matrix,ec(n.a,n.b,n.c,n.d,n.e,n.f)):Wo)}function Ld(n,t,e,i){function r(c){return c.length?c.pop()+" ":""}function s(c,u,h,f,d,g){if(c!==h||u!==f){var x=d.push("translate(",null,t,null,e);g.push({i:x-4,x:ye(c,h)},{i:x-2,x:ye(u,f)})}else(h||f)&&d.push("translate("+h+t+f+e)}function o(c,u,h,f){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),f.push({i:h.push(r(h)+"rotate(",null,i)-2,x:ye(c,u)})):u&&h.push(r(h)+"rotate("+u+i)}function a(c,u,h,f){c!==u?f.push({i:h.push(r(h)+"skewX(",null,i)-2,x:ye(c,u)}):u&&h.push(r(h)+"skewX("+u+i)}function l(c,u,h,f,d,g){if(c!==h||u!==f){var x=d.push(r(d)+"scale(",null,",",null,")");g.push({i:x-4,x:ye(c,h)},{i:x-2,x:ye(u,f)})}else(h!==1||f!==1)&&d.push(r(d)+"scale("+h+","+f+")")}return function(c,u){var h=[],f=[];return c=n(c),u=n(u),s(c.translateX,c.translateY,u.translateX,u.translateY,h,f),o(c.rotate,u.rotate,h,f),a(c.skewX,u.skewX,h,f),l(c.scaleX,c.scaleY,u.scaleX,u.scaleY,h,f),c=u=null,function(d){for(var g=-1,x=f.length,v;++g<x;)h[(v=f[g]).i]=v.x(d);return h.join("")}}}var ic=Ld(Cd,"px, ","px)","deg)"),rc=Ld(Rd,", ",")",")");function Pd(n){return function(t,e){var i=n((t=pi(t)).h,(e=pi(e)).h),r=bn(t.s,e.s),s=bn(t.l,e.l),o=bn(t.opacity,e.opacity);return function(a){return t.h=i(a),t.s=r(a),t.l=s(a),t.opacity=o(a),t+""}}}var sc=Pd(yd),oy=Pd(bn);var ji=0,ms=0,ps=0,Id=1e3,Xo,gs,Yo=0,xi=0,Zo=0,xs=typeof performance=="object"&&performance.now?performance:Date,Nd=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(n){setTimeout(n,17)};function tr(){return xi||(Nd(ay),xi=xs.now()+Zo)}function ay(){xi=0}function ys(){this._call=this._time=this._next=null}ys.prototype=Jo.prototype={constructor:ys,restart:function(n,t,e){if(typeof n!="function")throw new TypeError("callback is not a function");e=(e==null?tr():+e)+(t==null?0:+t),!this._next&&gs!==this&&(gs?gs._next=this:Xo=this,gs=this),this._call=n,this._time=e,oc()},stop:function(){this._call&&(this._call=null,this._time=1/0,oc())}};function Jo(n,t,e){var i=new ys;return i.restart(n,t,e),i}function Fd(){tr(),++ji;for(var n=Xo,t;n;)(t=xi-n._time)>=0&&n._call.call(null,t),n=n._next;--ji}function Dd(){xi=(Yo=xs.now())+Zo,ji=ms=0;try{Fd()}finally{ji=0,cy(),xi=0}}function ly(){var n=xs.now(),t=n-Yo;t>Id&&(Zo-=t,Yo=n)}function cy(){for(var n,t=Xo,e,i=1/0;t;)t._call?(i>t._time&&(i=t._time),n=t,t=t._next):(e=t._next,t._next=null,t=n?n._next=e:Xo=e);gs=n,oc(i)}function oc(n){if(!ji){ms&&(ms=clearTimeout(ms));var t=n-xi;t>24?(n<1/0&&(ms=setTimeout(Dd,n-xs.now()-Zo)),ps&&(ps=clearInterval(ps))):(ps||(Yo=xs.now(),ps=setInterval(ly,Id)),ji=1,Nd(Dd))}}function $o(n,t,e){var i=new ys;return t=t==null?0:+t,i.restart(function(r){i.stop(),n(r+t)},t,e),i}var uy=Wl("start","end","cancel","interrupt"),hy=[],Ud=0,ac=1,Qo=2,Ko=3,zd=4,jo=5,vs=6;function kn(n,t,e,i,r,s){var o=n.__transition;if(!o)n.__transition={};else if(e in o)return;fy(n,e,{name:t,index:i,group:r,on:uy,tween:hy,time:s.time,delay:s.delay,duration:s.duration,ease:s.ease,timer:null,state:Ud})}function _s(n,t){var e=ue(n,t);if(e.state>Ud)throw new Error("too late; already scheduled");return e}function Ae(n,t){var e=ue(n,t);if(e.state>Ko)throw new Error("too late; already running");return e}function ue(n,t){var e=n.__transition;if(!e||!(e=e[t]))throw new Error("transition not found");return e}function fy(n,t,e){var i=n.__transition,r;i[t]=e,e.timer=Jo(s,0,e.time);function s(c){e.state=ac,e.timer.restart(o,e.delay,e.time),e.delay<=c&&o(c-e.delay)}function o(c){var u,h,f,d;if(e.state!==ac)return l();for(u in i)if(d=i[u],d.name===e.name){if(d.state===Ko)return $o(o);d.state===zd?(d.state=vs,d.timer.stop(),d.on.call("interrupt",n,n.__data__,d.index,d.group),delete i[u]):+u<t&&(d.state=vs,d.timer.stop(),d.on.call("cancel",n,n.__data__,d.index,d.group),delete i[u])}if($o(function(){e.state===Ko&&(e.state=zd,e.timer.restart(a,e.delay,e.time),a(c))}),e.state=Qo,e.on.call("start",n,n.__data__,e.index,e.group),e.state===Qo){for(e.state=Ko,r=new Array(f=e.tween.length),u=0,h=-1;u<f;++u)(d=e.tween[u].value.call(n,n.__data__,e.index,e.group))&&(r[++h]=d);r.length=h+1}}function a(c){for(var u=c<e.duration?e.ease.call(null,c/e.duration):(e.timer.restart(l),e.state=jo,1),h=-1,f=r.length;++h<f;)r[h].call(n,u);e.state===jo&&(e.on.call("end",n,n.__data__,e.index,e.group),l())}function l(){e.state=vs,e.timer.stop(),delete i[t];for(var c in i)return;delete n.__transition}}function ws(n,t){var e=n.__transition,i,r,s=!0,o;if(!!e){t=t==null?null:t+"";for(o in e){if((i=e[o]).name!==t){s=!1;continue}r=i.state>Qo&&i.state<jo,i.state=vs,i.timer.stop(),i.on.call(r?"interrupt":"cancel",n,n.__data__,i.index,i.group),delete e[o]}s&&delete n.__transition}}function Bd(n){return this.each(function(){ws(this,n)})}function dy(n,t){var e,i;return function(){var r=Ae(this,n),s=r.tween;if(s!==e){i=e=s;for(var o=0,a=i.length;o<a;++o)if(i[o].name===t){i=i.slice(),i.splice(o,1);break}}r.tween=i}}function py(n,t,e){var i,r;if(typeof e!="function")throw new Error;return function(){var s=Ae(this,n),o=s.tween;if(o!==i){r=(i=o).slice();for(var a={name:t,value:e},l=0,c=r.length;l<c;++l)if(r[l].name===t){r[l]=a;break}l===c&&r.push(a)}s.tween=r}}function Od(n,t){var e=this._id;if(n+="",arguments.length<2){for(var i=ue(this.node(),e).tween,r=0,s=i.length,o;r<s;++r)if((o=i[r]).name===n)return o.value;return null}return this.each((t==null?dy:py)(e,n,t))}function er(n,t,e){var i=n._id;return n.each(function(){var r=Ae(this,i);(r.value||(r.value={}))[t]=e.apply(this,arguments)}),function(r){return ue(r,i).value[t]}}function ta(n,t){var e;return(typeof t=="number"?ye:t instanceof Je?mi:(e=Je(t))?(t=e,mi):fs)(n,t)}function my(n){return function(){this.removeAttribute(n)}}function gy(n){return function(){this.removeAttributeNS(n.space,n.local)}}function xy(n,t,e){var i,r=e+"",s;return function(){var o=this.getAttribute(n);return o===r?null:o===i?s:s=t(i=o,e)}}function yy(n,t,e){var i,r=e+"",s;return function(){var o=this.getAttributeNS(n.space,n.local);return o===r?null:o===i?s:s=t(i=o,e)}}function vy(n,t,e){var i,r,s;return function(){var o,a=e(this),l;return a==null?void this.removeAttribute(n):(o=this.getAttribute(n),l=a+"",o===l?null:o===i&&l===r?s:(r=l,s=t(i=o,a)))}}function _y(n,t,e){var i,r,s;return function(){var o,a=e(this),l;return a==null?void this.removeAttributeNS(n.space,n.local):(o=this.getAttributeNS(n.space,n.local),l=a+"",o===l?null:o===i&&l===r?s:(r=l,s=t(i=o,a)))}}function kd(n,t){var e=wn(n),i=e==="transform"?rc:ta;return this.attrTween(n,typeof t=="function"?(e.local?_y:vy)(e,i,er(this,"attr."+n,t)):t==null?(e.local?gy:my)(e):(e.local?yy:xy)(e,i,t))}function wy(n,t){return function(e){this.setAttribute(n,t.call(this,e))}}function My(n,t){return function(e){this.setAttributeNS(n.space,n.local,t.call(this,e))}}function by(n,t){var e,i;function r(){var s=t.apply(this,arguments);return s!==i&&(e=(i=s)&&My(n,s)),e}return r._value=t,r}function Sy(n,t){var e,i;function r(){var s=t.apply(this,arguments);return s!==i&&(e=(i=s)&&wy(n,s)),e}return r._value=t,r}function Hd(n,t){var e="attr."+n;if(arguments.length<2)return(e=this.tween(e))&&e._value;if(t==null)return this.tween(e,null);if(typeof t!="function")throw new Error;var i=wn(n);return this.tween(e,(i.local?by:Sy)(i,t))}function Ey(n,t){return function(){_s(this,n).delay=+t.apply(this,arguments)}}function Ty(n,t){return t=+t,function(){_s(this,n).delay=t}}function Vd(n){var t=this._id;return arguments.length?this.each((typeof n=="function"?Ey:Ty)(t,n)):ue(this.node(),t).delay}function Ay(n,t){return function(){Ae(this,n).duration=+t.apply(this,arguments)}}function Cy(n,t){return t=+t,function(){Ae(this,n).duration=t}}function Gd(n){var t=this._id;return arguments.length?this.each((typeof n=="function"?Ay:Cy)(t,n)):ue(this.node(),t).duration}function Ry(n,t){if(typeof t!="function")throw new Error;return function(){Ae(this,n).ease=t}}function Wd(n){var t=this._id;return arguments.length?this.each(Ry(t,n)):ue(this.node(),t).ease}function qd(n){typeof n!="function"&&(n=as(n));for(var t=this._groups,e=t.length,i=new Array(e),r=0;r<e;++r)for(var s=t[r],o=s.length,a=i[r]=[],l,c=0;c<o;++c)(l=s[c])&&n.call(l,l.__data__,c,s)&&a.push(l);return new we(i,this._parents,this._name,this._id)}function Xd(n){if(n._id!==this._id)throw new Error;for(var t=this._groups,e=n._groups,i=t.length,r=e.length,s=Math.min(i,r),o=new Array(i),a=0;a<s;++a)for(var l=t[a],c=e[a],u=l.length,h=o[a]=new Array(u),f,d=0;d<u;++d)(f=l[d]||c[d])&&(h[d]=f);for(;a<i;++a)o[a]=t[a];return new we(o,this._parents,this._name,this._id)}function Ly(n){return(n+"").trim().split(/^|\s+/).every(function(t){var e=t.indexOf(".");return e>=0&&(t=t.slice(0,e)),!t||t==="start"})}function Py(n,t,e){var i,r,s=Ly(t)?_s:Ae;return function(){var o=s(this,n),a=o.on;a!==i&&(r=(i=a).copy()).on(t,e),o.on=r}}function Yd(n,t){var e=this._id;return arguments.length<2?ue(this.node(),e).on.on(n):this.each(Py(e,n,t))}function Dy(n){return function(){var t=this.parentNode;for(var e in this.__transition)if(+e!==n)return;t&&t.removeChild(this)}}function Zd(){return this.on("end.remove",Dy(this._id))}function Jd(n){var t=this._name,e=this._id;typeof n!="function"&&(n=di(n));for(var i=this._groups,r=i.length,s=new Array(r),o=0;o<r;++o)for(var a=i[o],l=a.length,c=s[o]=new Array(l),u,h,f=0;f<l;++f)(u=a[f])&&(h=n.call(u,u.__data__,f,a))&&("__data__"in u&&(h.__data__=u.__data__),c[f]=h,kn(c[f],t,e,f,c,ue(u,e)));return new we(s,this._parents,t,e)}function $d(n){var t=this._name,e=this._id;typeof n!="function"&&(n=os(n));for(var i=this._groups,r=i.length,s=[],o=[],a=0;a<r;++a)for(var l=i[a],c=l.length,u,h=0;h<c;++h)if(u=l[h]){for(var f=n.call(u,u.__data__,h,l),d,g=ue(u,e),x=0,v=f.length;x<v;++x)(d=f[x])&&kn(d,t,e,x,f,g);s.push(f),o.push(u)}return new we(s,o,t,e)}var Iy=Mn.prototype.constructor;function Kd(){return new Iy(this._groups,this._parents)}function Ny(n,t){var e,i,r;return function(){var s=On(this,n),o=(this.style.removeProperty(n),On(this,n));return s===o?null:s===e&&o===i?r:r=t(e=s,i=o)}}function Qd(n){return function(){this.style.removeProperty(n)}}function Fy(n,t,e){var i,r=e+"",s;return function(){var o=On(this,n);return o===r?null:o===i?s:s=t(i=o,e)}}function zy(n,t,e){var i,r,s;return function(){var o=On(this,n),a=e(this),l=a+"";return a==null&&(l=a=(this.style.removeProperty(n),On(this,n))),o===l?null:o===i&&l===r?s:(r=l,s=t(i=o,a))}}function Uy(n,t){var e,i,r,s="style."+t,o="end."+s,a;return function(){var l=Ae(this,n),c=l.on,u=l.value[s]==null?a||(a=Qd(t)):void 0;(c!==e||r!==u)&&(i=(e=c).copy()).on(o,r=u),l.on=i}}function jd(n,t,e){var i=(n+="")=="transform"?ic:ta;return t==null?this.styleTween(n,Ny(n,i)).on("end.style."+n,Qd(n)):typeof t=="function"?this.styleTween(n,zy(n,i,er(this,"style."+n,t))).each(Uy(this._id,n)):this.styleTween(n,Fy(n,i,t),e).on("end.style."+n,null)}function By(n,t,e){return function(i){this.style.setProperty(n,t.call(this,i),e)}}function Oy(n,t,e){var i,r;function s(){var o=t.apply(this,arguments);return o!==r&&(i=(r=o)&&By(n,o,e)),i}return s._value=t,s}function tp(n,t,e){var i="style."+(n+="");if(arguments.length<2)return(i=this.tween(i))&&i._value;if(t==null)return this.tween(i,null);if(typeof t!="function")throw new Error;return this.tween(i,Oy(n,t,e==null?"":e))}function ky(n){return function(){this.textContent=n}}function Hy(n){return function(){var t=n(this);this.textContent=t==null?"":t}}function ep(n){return this.tween("text",typeof n=="function"?Hy(er(this,"text",n)):ky(n==null?"":n+""))}function Vy(n){return function(t){this.textContent=n.call(this,t)}}function Gy(n){var t,e;function i(){var r=n.apply(this,arguments);return r!==e&&(t=(e=r)&&Vy(r)),t}return i._value=n,i}function np(n){var t="text";if(arguments.length<1)return(t=this.tween(t))&&t._value;if(n==null)return this.tween(t,null);if(typeof n!="function")throw new Error;return this.tween(t,Gy(n))}function ip(){for(var n=this._name,t=this._id,e=ea(),i=this._groups,r=i.length,s=0;s<r;++s)for(var o=i[s],a=o.length,l,c=0;c<a;++c)if(l=o[c]){var u=ue(l,t);kn(l,n,e,c,o,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new we(i,this._parents,n,e)}function rp(){var n,t,e=this,i=e._id,r=e.size();return new Promise(function(s,o){var a={value:o},l={value:function(){--r===0&&s()}};e.each(function(){var c=Ae(this,i),u=c.on;u!==n&&(t=(n=u).copy(),t._.cancel.push(a),t._.interrupt.push(a),t._.end.push(l)),c.on=t})})}var Wy=0;function we(n,t,e,i){this._groups=n,this._parents=t,this._name=e,this._id=i}function lc(n){return Mn().transition(n)}function ea(){return++Wy}var nr=Mn.prototype;we.prototype=lc.prototype={constructor:we,select:Jd,selectAll:$d,filter:qd,merge:Xd,selection:Kd,transition:ip,call:nr.call,nodes:nr.nodes,node:nr.node,size:nr.size,empty:nr.empty,each:nr.each,on:Yd,attr:kd,attrTween:Hd,style:jd,styleTween:tp,text:ep,textTween:np,remove:Zd,tween:Od,delay:Vd,duration:Gd,ease:Wd,end:rp};function na(n){return((n*=2)<=1?n*n*n:(n-=2)*n*n+2)/2}var cc={time:null,delay:0,duration:250,ease:na};function qy(n,t){for(var e;!(e=n.__transition)||!(e=e[t]);)if(!(n=n.parentNode))return cc.time=tr(),cc;return e}function sp(n){var t,e;n instanceof we?(t=n._id,n=n._name):(t=ea(),(e=cc).time=tr(),n=n==null?null:n+"");for(var i=this._groups,r=i.length,s=0;s<r;++s)for(var o=i[s],a=o.length,l,c=0;c<a;++c)(l=o[c])&&kn(l,n,t,c,o,e||qy(l,t));return new we(i,this._parents,n,t)}Mn.prototype.interrupt=Bd;Mn.prototype.transition=sp;function op(n){return[+n[0],+n[1]]}function Xy(n){return[op(n[0]),op(n[1])]}var GP={name:"x",handles:["w","e"].map(uc),input:function(n,t){return n==null?null:[[+n[0],t[0][1]],[+n[1],t[1][1]]]},output:function(n){return n&&[n[0][0],n[1][0]]}},WP={name:"y",handles:["n","s"].map(uc),input:function(n,t){return n==null?null:[[t[0][0],+n[0]],[t[1][0],+n[1]]]},output:function(n){return n&&[n[0][1],n[1][1]]}},qP={name:"xy",handles:["n","w","e","s","nw","ne","sw","se"].map(uc),input:function(n){return n==null?null:Xy(n)},output:function(n){return n}};function uc(n){return{type:n}}var ap=Math.PI,Yy=ap/2,Zy=ap*2;var Jy=Array.prototype.slice;var Be="$";function ia(){}ia.prototype=lp.prototype={constructor:ia,has:function(n){return Be+n in this},get:function(n){return this[Be+n]},set:function(n,t){return this[Be+n]=t,this},remove:function(n){var t=Be+n;return t in this&&delete this[t]},clear:function(){for(var n in this)n[0]===Be&&delete this[n]},keys:function(){var n=[];for(var t in this)t[0]===Be&&n.push(t.slice(1));return n},values:function(){var n=[];for(var t in this)t[0]===Be&&n.push(this[t]);return n},entries:function(){var n=[];for(var t in this)t[0]===Be&&n.push({key:t.slice(1),value:this[t]});return n},size:function(){var n=0;for(var t in this)t[0]===Be&&++n;return n},empty:function(){for(var n in this)if(n[0]===Be)return!1;return!0},each:function(n){for(var t in this)t[0]===Be&&n(this[t],t.slice(1),this)}};function lp(n,t){var e=new ia;if(n instanceof ia)n.each(function(a,l){e.set(l,a)});else if(Array.isArray(n)){var i=-1,r=n.length,s;if(t==null)for(;++i<r;)e.set(i,n[i]);else for(;++i<r;)e.set(t(s=n[i],i,n),s)}else if(n)for(var o in n)e.set(o,n[o]);return e}var yi=lp;function ra(){}var vi=yi.prototype;ra.prototype=$y.prototype={constructor:ra,has:vi.has,add:function(n){return n+="",this[Be+n]=n,this},remove:vi.remove,clear:vi.clear,values:vi.keys,size:vi.size,empty:vi.empty,each:vi.each};function $y(n,t){var e=new ra;if(n instanceof ra)n.each(function(s){e.add(s)});else if(n){var i=-1,r=n.length;if(t==null)for(;++i<r;)e.add(n[i]);else for(;++i<r;)e.add(t(n[i],i,n))}return e}var Ky=Array.prototype,cp=Ky.slice;var TI=Math.PI*(3-Math.sqrt(5));function hp(n){return Math.abs(n=Math.round(n))>=1e21?n.toLocaleString("en").replace(/,/g,""):n.toString(10)}function _i(n,t){if((e=(n=t?n.toExponential(t-1):n.toExponential()).indexOf("e"))<0)return null;var e,i=n.slice(0,e);return[i.length>1?i[0]+i.slice(2):i,+n.slice(e+1)]}function un(n){return n=_i(Math.abs(n)),n?n[1]:NaN}function fp(n,t){return function(e,i){for(var r=e.length,s=[],o=0,a=n[0],l=0;r>0&&a>0&&(l+a+1>i&&(a=Math.max(1,i-l)),s.push(e.substring(r-=a,r+a)),!((l+=a+1)>i));)a=n[o=(o+1)%n.length];return s.reverse().join(t)}}function dp(n){return function(t){return t.replace(/[0-9]/g,function(e){return n[+e]})}}var tv=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function Hn(n){if(!(t=tv.exec(n)))throw new Error("invalid format: "+n);var t;return new sa({fill:t[1],align:t[2],sign:t[3],symbol:t[4],zero:t[5],width:t[6],comma:t[7],precision:t[8]&&t[8].slice(1),trim:t[9],type:t[10]})}Hn.prototype=sa.prototype;function sa(n){this.fill=n.fill===void 0?" ":n.fill+"",this.align=n.align===void 0?">":n.align+"",this.sign=n.sign===void 0?"-":n.sign+"",this.symbol=n.symbol===void 0?"":n.symbol+"",this.zero=!!n.zero,this.width=n.width===void 0?void 0:+n.width,this.comma=!!n.comma,this.precision=n.precision===void 0?void 0:+n.precision,this.trim=!!n.trim,this.type=n.type===void 0?"":n.type+""}sa.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(this.width===void 0?"":Math.max(1,this.width|0))+(this.comma?",":"")+(this.precision===void 0?"":"."+Math.max(0,this.precision|0))+(this.trim?"~":"")+this.type};function pp(n){t:for(var t=n.length,e=1,i=-1,r;e<t;++e)switch(n[e]){case".":i=r=e;break;case"0":i===0&&(i=e),r=e;break;default:if(!+n[e])break t;i>0&&(i=0);break}return i>0?n.slice(0,i)+n.slice(r+1):n}var hc;function mp(n,t){var e=_i(n,t);if(!e)return n+"";var i=e[0],r=e[1],s=r-(hc=Math.max(-8,Math.min(8,Math.floor(r/3)))*3)+1,o=i.length;return s===o?i:s>o?i+new Array(s-o+1).join("0"):s>0?i.slice(0,s)+"."+i.slice(s):"0."+new Array(1-s).join("0")+_i(n,Math.max(0,t+s-1))[0]}function fc(n,t){var e=_i(n,t);if(!e)return n+"";var i=e[0],r=e[1];return r<0?"0."+new Array(-r).join("0")+i:i.length>r+1?i.slice(0,r+1)+"."+i.slice(r+1):i+new Array(r-i.length+2).join("0")}var dc={"%":function(n,t){return(n*100).toFixed(t)},b:function(n){return Math.round(n).toString(2)},c:function(n){return n+""},d:hp,e:function(n,t){return n.toExponential(t)},f:function(n,t){return n.toFixed(t)},g:function(n,t){return n.toPrecision(t)},o:function(n){return Math.round(n).toString(8)},p:function(n,t){return fc(n*100,t)},r:fc,s:mp,X:function(n){return Math.round(n).toString(16).toUpperCase()},x:function(n){return Math.round(n).toString(16)}};function pc(n){return n}var gp=Array.prototype.map,xp=["y","z","a","f","p","n","\xB5","m","","k","M","G","T","P","E","Z","Y"];function yp(n){var t=n.grouping===void 0||n.thousands===void 0?pc:fp(gp.call(n.grouping,Number),n.thousands+""),e=n.currency===void 0?"":n.currency[0]+"",i=n.currency===void 0?"":n.currency[1]+"",r=n.decimal===void 0?".":n.decimal+"",s=n.numerals===void 0?pc:dp(gp.call(n.numerals,String)),o=n.percent===void 0?"%":n.percent+"",a=n.minus===void 0?"-":n.minus+"",l=n.nan===void 0?"NaN":n.nan+"";function c(h){h=Hn(h);var f=h.fill,d=h.align,g=h.sign,x=h.symbol,v=h.zero,m=h.width,p=h.comma,b=h.precision,_=h.trim,S=h.type;S==="n"?(p=!0,S="g"):dc[S]||(b===void 0&&(b=12),_=!0,S="g"),(v||f==="0"&&d==="=")&&(v=!0,f="0",d="=");var L=x==="$"?e:x==="#"&&/[boxX]/.test(S)?"0"+S.toLowerCase():"",A=x==="$"?i:/[%p]/.test(S)?o:"",H=dc[S],tt=/[defgprs%]/.test(S);b=b===void 0?6:/[gprs]/.test(S)?Math.max(1,Math.min(21,b)):Math.max(0,Math.min(20,b));function X(y){var R=L,D=A,F,z,N;if(S==="c")D=H(y)+D,y="";else{y=+y;var V=y<0||1/y<0;if(y=isNaN(y)?l:H(Math.abs(y),b),_&&(y=pp(y)),V&&+y==0&&g!=="+"&&(V=!1),R=(V?g==="("?g:a:g==="-"||g==="("?"":g)+R,D=(S==="s"?xp[8+hc/3]:"")+D+(V&&g==="("?")":""),tt){for(F=-1,z=y.length;++F<z;)if(N=y.charCodeAt(F),48>N||N>57){D=(N===46?r+y.slice(F+1):y.slice(F))+D,y=y.slice(0,F);break}}}p&&!v&&(y=t(y,1/0));var Q=R.length+y.length+D.length,at=Q<m?new Array(m-Q+1).join(f):"";switch(p&&v&&(y=t(at+y,at.length?m-D.length:1/0),at=""),d){case"<":y=R+y+D+at;break;case"=":y=R+at+y+D;break;case"^":y=at.slice(0,Q=at.length>>1)+R+y+D+at.slice(Q);break;default:y=at+R+y+D;break}return s(y)}return X.toString=function(){return h+""},X}function u(h,f){var d=c((h=Hn(h),h.type="f",h)),g=Math.max(-8,Math.min(8,Math.floor(un(f)/3)))*3,x=Math.pow(10,-g),v=xp[8+g/3];return function(m){return d(x*m)+v}}return{format:c,formatPrefix:u}}var oa,Oe,aa;mc({decimal:".",thousands:",",grouping:[3],currency:["$",""],minus:"-"});function mc(n){return oa=yp(n),Oe=oa.format,aa=oa.formatPrefix,oa}function gc(n){return Math.max(0,-un(Math.abs(n)))}function xc(n,t){return Math.max(0,Math.max(-8,Math.min(8,Math.floor(un(t)/3)))*3-un(Math.abs(n)))}function yc(n,t){return n=Math.abs(n),t=Math.abs(t)-n,Math.max(0,un(t)-un(n))+1}function We(){return Math.random()}var ev=function n(t){function e(i,r){return i=i==null?0:+i,r=r==null?1:+r,arguments.length===1?(r=i,i=0):r-=i,function(){return t()*r+i}}return e.source=n,e}(We);var vc=function n(t){function e(i,r){var s,o;return i=i==null?0:+i,r=r==null?1:+r,function(){var a;if(s!=null)a=s,s=null;else do s=t()*2-1,a=t()*2-1,o=s*s+a*a;while(!o||o>1);return i+r*a*Math.sqrt(-2*Math.log(o)/o)}}return e.source=n,e}(We);var nv=function n(t){function e(){var i=vc.source(t).apply(this,arguments);return function(){return Math.exp(i())}}return e.source=n,e}(We);var _c=function n(t){function e(i){return function(){for(var r=0,s=0;s<i;++s)r+=t();return r}}return e.source=n,e}(We);var iv=function n(t){function e(i){var r=_c.source(t)(i);return function(){return r()/i}}return e.source=n,e}(We);var rv=function n(t){function e(i){return function(){return-Math.log(1-t())/i}}return e.source=n,e}(We);function Pe(n,t){switch(arguments.length){case 0:break;case 1:this.range(n);break;default:this.range(t).domain(n);break}return this}var vp=Array.prototype,bs=vp.map,wi=vp.slice;function _p(n){return function(){return n}}function wc(n){return+n}var wp=[0,1];function De(n){return n}function Mc(n,t){return(t-=n=+n)?function(e){return(e-n)/t}:_p(isNaN(t)?NaN:.5)}function Mp(n){var t=n[0],e=n[n.length-1],i;return t>e&&(i=t,t=e,e=i),function(r){return Math.max(t,Math.min(e,r))}}function ov(n,t,e){var i=n[0],r=n[1],s=t[0],o=t[1];return r<i?(i=Mc(r,i),s=e(o,s)):(i=Mc(i,r),s=e(s,o)),function(a){return s(i(a))}}function av(n,t,e){var i=Math.min(n.length,t.length)-1,r=new Array(i),s=new Array(i),o=-1;for(n[i]<n[0]&&(n=n.slice().reverse(),t=t.slice().reverse());++o<i;)r[o]=Mc(n[o],n[o+1]),s[o]=e(t[o],t[o+1]);return function(a){var l=Bn(n,a,1,i)-1;return s[l](r[l](a))}}function Vn(n,t){return t.domain(n.domain()).range(n.range()).interpolate(n.interpolate()).clamp(n.clamp()).unknown(n.unknown())}function Ss(){var n=wp,t=wp,e=gi,i,r,s,o=De,a,l,c;function u(){return a=Math.min(n.length,t.length)>2?av:ov,l=c=null,h}function h(f){return isNaN(f=+f)?s:(l||(l=a(n.map(i),t,e)))(i(o(f)))}return h.invert=function(f){return o(r((c||(c=a(t,n.map(i),ye)))(f)))},h.domain=function(f){return arguments.length?(n=bs.call(f,wc),o===De||(o=Mp(n)),u()):n.slice()},h.range=function(f){return arguments.length?(t=wi.call(f),u()):t.slice()},h.rangeRound=function(f){return t=wi.call(f),e=tc,u()},h.clamp=function(f){return arguments.length?(o=f?Mp(n):De,h):o!==De},h.interpolate=function(f){return arguments.length?(e=f,u()):e},h.unknown=function(f){return arguments.length?(s=f,h):s},function(f,d){return i=f,r=d,u()}}function Es(n,t){return Ss()(n,t)}function bc(n,t,e,i){var r=_n(n,t,e),s;switch(i=Hn(i==null?",f":i),i.type){case"s":{var o=Math.max(Math.abs(n),Math.abs(t));return i.precision==null&&!isNaN(s=xc(r,o))&&(i.precision=s),aa(i,o)}case"":case"e":case"g":case"p":case"r":{i.precision==null&&!isNaN(s=yc(r,Math.max(Math.abs(n),Math.abs(t))))&&(i.precision=s-(i.type==="e"));break}case"f":case"%":{i.precision==null&&!isNaN(s=gc(r))&&(i.precision=s-(i.type==="%")*2);break}}return Oe(i)}function Mi(n){var t=n.domain;return n.ticks=function(e){var i=t();return rs(i[0],i[i.length-1],e==null?10:e)},n.tickFormat=function(e,i){var r=t();return bc(r[0],r[r.length-1],e==null?10:e,i)},n.nice=function(e){e==null&&(e=10);var i=t(),r=0,s=i.length-1,o=i[r],a=i[s],l;return a<o&&(l=o,o=a,a=l,l=r,r=s,s=l),l=Ji(o,a,e),l>0?(o=Math.floor(o/l)*l,a=Math.ceil(a/l)*l,l=Ji(o,a,e)):l<0&&(o=Math.ceil(o*l)/l,a=Math.floor(a*l)/l,l=Ji(o,a,e)),l>0?(i[r]=Math.floor(o/l)*l,i[s]=Math.ceil(a/l)*l,t(i)):l<0&&(i[r]=Math.ceil(o*l)/l,i[s]=Math.floor(a*l)/l,t(i)),n},n}function ir(){var n=Es(De,De);return n.copy=function(){return Vn(n,ir())},Pe.apply(n,arguments),Mi(n)}function la(n,t){n=n.slice();var e=0,i=n.length-1,r=n[e],s=n[i],o;return s<r&&(o=e,e=i,i=o,o=r,r=s,s=o),n[e]=t.floor(r),n[i]=t.ceil(s),n}function bp(n){return Math.log(n)}function Sp(n){return Math.exp(n)}function lv(n){return-Math.log(-n)}function cv(n){return-Math.exp(-n)}function uv(n){return isFinite(n)?+("1e"+n):n<0?0:n}function hv(n){return n===10?uv:n===Math.E?Math.exp:function(t){return Math.pow(n,t)}}function fv(n){return n===Math.E?Math.log:n===10&&Math.log10||n===2&&Math.log2||(n=Math.log(n),function(t){return Math.log(t)/n})}function Ep(n){return function(t){return-n(-t)}}function Sc(n){var t=n(bp,Sp),e=t.domain,i=10,r,s;function o(){return r=fv(i),s=hv(i),e()[0]<0?(r=Ep(r),s=Ep(s),n(lv,cv)):n(bp,Sp),t}return t.base=function(a){return arguments.length?(i=+a,o()):i},t.domain=function(a){return arguments.length?(e(a),o()):e()},t.ticks=function(a){var l=e(),c=l[0],u=l[l.length-1],h;(h=u<c)&&(f=c,c=u,u=f);var f=r(c),d=r(u),g,x,v,m=a==null?10:+a,p=[];if(!(i%1)&&d-f<m){if(f=Math.round(f)-1,d=Math.round(d)+1,c>0){for(;f<d;++f)for(x=1,g=s(f);x<i;++x)if(v=g*x,!(v<c)){if(v>u)break;p.push(v)}}else for(;f<d;++f)for(x=i-1,g=s(f);x>=1;--x)if(v=g*x,!(v<c)){if(v>u)break;p.push(v)}}else p=rs(f,d,Math.min(d-f,m)).map(s);return h?p.reverse():p},t.tickFormat=function(a,l){if(l==null&&(l=i===10?".0e":","),typeof l!="function"&&(l=Oe(l)),a===1/0)return l;a==null&&(a=10);var c=Math.max(1,i*a/t.ticks().length);return function(u){var h=u/s(Math.round(r(u)));return h*i<i-.5&&(h*=i),h<=c?l(u):""}},t.nice=function(){return e(la(e(),{floor:function(a){return s(Math.floor(r(a)))},ceil:function(a){return s(Math.ceil(r(a)))}}))},t}function Ts(){var n=Sc(Ss()).domain([1,10]);return n.copy=function(){return Vn(n,Ts()).base(n.base())},Pe.apply(n,arguments),n}var Ec=new Date,Tc=new Date;function Yt(n,t,e,i){function r(s){return n(s=arguments.length===0?new Date:new Date(+s)),s}return r.floor=function(s){return n(s=new Date(+s)),s},r.ceil=function(s){return n(s=new Date(s-1)),t(s,1),n(s),s},r.round=function(s){var o=r(s),a=r.ceil(s);return s-o<a-s?o:a},r.offset=function(s,o){return t(s=new Date(+s),o==null?1:Math.floor(o)),s},r.range=function(s,o,a){var l=[],c;if(s=r.ceil(s),a=a==null?1:Math.floor(a),!(s<o)||!(a>0))return l;do l.push(c=new Date(+s)),t(s,a),n(s);while(c<s&&s<o);return l},r.filter=function(s){return Yt(function(o){if(o>=o)for(;n(o),!s(o);)o.setTime(o-1)},function(o,a){if(o>=o)if(a<0)for(;++a<=0;)for(;t(o,-1),!s(o););else for(;--a>=0;)for(;t(o,1),!s(o););})},e&&(r.count=function(s,o){return Ec.setTime(+s),Tc.setTime(+o),n(Ec),n(Tc),Math.floor(e(Ec,Tc))},r.every=function(s){return s=Math.floor(s),!isFinite(s)||!(s>0)?null:s>1?r.filter(i?function(o){return i(o)%s===0}:function(o){return r.count(0,o)%s===0}):r}),r}var ca=Yt(function(){},function(n,t){n.setTime(+n+t)},function(n,t){return t-n});ca.every=function(n){return n=Math.floor(n),!isFinite(n)||!(n>0)?null:n>1?Yt(function(t){t.setTime(Math.floor(t/n)*n)},function(t,e){t.setTime(+t+e*n)},function(t,e){return(e-t)/n}):ca};var ua=ca,Tp=ca.range;var bi=1e3,Sn=6e4,Ac=36e5,ha=864e5,fa=6048e5;var Ap=Yt(function(n){n.setTime(n-n.getMilliseconds())},function(n,t){n.setTime(+n+t*bi)},function(n,t){return(t-n)/bi},function(n){return n.getUTCSeconds()}),da=Ap,Cp=Ap.range;var Rp=Yt(function(n){n.setTime(n-n.getMilliseconds()-n.getSeconds()*bi)},function(n,t){n.setTime(+n+t*Sn)},function(n,t){return(t-n)/Sn},function(n){return n.getMinutes()}),Cc=Rp,dv=Rp.range;var Lp=Yt(function(n){n.setTime(n-n.getMilliseconds()-n.getSeconds()*bi-n.getMinutes()*Sn)},function(n,t){n.setTime(+n+t*Ac)},function(n,t){return(t-n)/Ac},function(n){return n.getHours()}),Rc=Lp,pv=Lp.range;var Pp=Yt(function(n){n.setHours(0,0,0,0)},function(n,t){n.setDate(n.getDate()+t)},function(n,t){return(t-n-(t.getTimezoneOffset()-n.getTimezoneOffset())*Sn)/ha},function(n){return n.getDate()-1}),rr=Pp,mv=Pp.range;function Si(n){return Yt(function(t){t.setDate(t.getDate()-(t.getDay()+7-n)%7),t.setHours(0,0,0,0)},function(t,e){t.setDate(t.getDate()+e*7)},function(t,e){return(e-t-(e.getTimezoneOffset()-t.getTimezoneOffset())*Sn)/fa})}var Ei=Si(0),sr=Si(1),Dp=Si(2),Ip=Si(3),Gn=Si(4),Np=Si(5),Fp=Si(6),zp=Ei.range,gv=sr.range,xv=Dp.range,yv=Ip.range,vv=Gn.range,_v=Np.range,wv=Fp.range;var Up=Yt(function(n){n.setDate(1),n.setHours(0,0,0,0)},function(n,t){n.setMonth(n.getMonth()+t)},function(n,t){return t.getMonth()-n.getMonth()+(t.getFullYear()-n.getFullYear())*12},function(n){return n.getMonth()}),Lc=Up,Mv=Up.range;var Pc=Yt(function(n){n.setMonth(0,1),n.setHours(0,0,0,0)},function(n,t){n.setFullYear(n.getFullYear()+t)},function(n,t){return t.getFullYear()-n.getFullYear()},function(n){return n.getFullYear()});Pc.every=function(n){return!isFinite(n=Math.floor(n))||!(n>0)?null:Yt(function(t){t.setFullYear(Math.floor(t.getFullYear()/n)*n),t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,e){t.setFullYear(t.getFullYear()+e*n)})};var En=Pc,bv=Pc.range;var Bp=Yt(function(n){n.setUTCHours(0,0,0,0)},function(n,t){n.setUTCDate(n.getUTCDate()+t)},function(n,t){return(t-n)/ha},function(n){return n.getUTCDate()-1}),pa=Bp,Sv=Bp.range;function Ti(n){return Yt(function(t){t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-n)%7),t.setUTCHours(0,0,0,0)},function(t,e){t.setUTCDate(t.getUTCDate()+e*7)},function(t,e){return(e-t)/fa})}var As=Ti(0),or=Ti(1),Op=Ti(2),kp=Ti(3),Wn=Ti(4),Hp=Ti(5),Vp=Ti(6),Gp=As.range,Ev=or.range,Tv=Op.range,Av=kp.range,Cv=Wn.range,Rv=Hp.range,Lv=Vp.range;var Dc=Yt(function(n){n.setUTCMonth(0,1),n.setUTCHours(0,0,0,0)},function(n,t){n.setUTCFullYear(n.getUTCFullYear()+t)},function(n,t){return t.getUTCFullYear()-n.getUTCFullYear()},function(n){return n.getUTCFullYear()});Dc.every=function(n){return!isFinite(n=Math.floor(n))||!(n>0)?null:Yt(function(t){t.setUTCFullYear(Math.floor(t.getUTCFullYear()/n)*n),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,e){t.setUTCFullYear(t.getUTCFullYear()+e*n)})};var Ai=Dc,Pv=Dc.range;function Ic(n){if(0<=n.y&&n.y<100){var t=new Date(-1,n.m,n.d,n.H,n.M,n.S,n.L);return t.setFullYear(n.y),t}return new Date(n.y,n.m,n.d,n.H,n.M,n.S,n.L)}function Nc(n){if(0<=n.y&&n.y<100){var t=new Date(Date.UTC(-1,n.m,n.d,n.H,n.M,n.S,n.L));return t.setUTCFullYear(n.y),t}return new Date(Date.UTC(n.y,n.m,n.d,n.H,n.M,n.S,n.L))}function Cs(n,t,e){return{y:n,m:t,d:e,H:0,M:0,S:0,L:0}}function Fc(n){var t=n.dateTime,e=n.date,i=n.time,r=n.periods,s=n.days,o=n.shortDays,a=n.months,l=n.shortMonths,c=Rs(r),u=Ls(r),h=Rs(s),f=Ls(s),d=Rs(o),g=Ls(o),x=Rs(a),v=Ls(a),m=Rs(l),p=Ls(l),b={a:V,A:Q,b:at,B:G,c:null,d:Jp,e:Jp,f:t_,g:u_,G:f_,H:Kv,I:Qv,j:jv,L:tm,m:e_,M:n_,p:$,q:lt,Q:Qp,s:jp,S:i_,u:r_,U:s_,V:o_,w:a_,W:l_,x:null,X:null,y:c_,Y:h_,Z:d_,"%":Kp},_={a:dt,A:xt,b:k,B:Ft,c:null,d:$p,e:$p,f:x_,g:A_,G:R_,H:p_,I:m_,j:g_,L:nm,m:y_,M:v_,p:mt,q:St,Q:Qp,s:jp,S:__,u:w_,U:M_,V:b_,w:S_,W:E_,x:null,X:null,y:T_,Y:C_,Z:L_,"%":Kp},S={a:X,A:y,b:R,B:D,c:F,d:Yp,e:Yp,f:Yv,g:Xp,G:qp,H:Zp,I:Zp,j:Gv,L:Xv,m:Vv,M:Wv,p:tt,q:Hv,Q:Jv,s:$v,S:qv,u:zv,U:Uv,V:Bv,w:Fv,W:Ov,x:z,X:N,y:Xp,Y:qp,Z:kv,"%":Zv};b.x=L(e,b),b.X=L(i,b),b.c=L(t,b),_.x=L(e,_),_.X=L(i,_),_.c=L(t,_);function L(B,st){return function(nt){var C=[],j=-1,J=0,it=B.length,et,vt,bt;for(nt instanceof Date||(nt=new Date(+nt));++j<it;)B.charCodeAt(j)===37&&(C.push(B.slice(J,j)),(vt=Wp[et=B.charAt(++j)])!=null?et=B.charAt(++j):vt=et==="e"?" ":"0",(bt=st[et])&&(et=bt(nt,vt)),C.push(et),J=j+1);return C.push(B.slice(J,j)),C.join("")}}function A(B,st){return function(nt){var C=Cs(1900,void 0,1),j=H(C,B,nt+="",0),J,it;if(j!=nt.length)return null;if("Q"in C)return new Date(C.Q);if("s"in C)return new Date(C.s*1e3+("L"in C?C.L:0));if(st&&!("Z"in C)&&(C.Z=0),"p"in C&&(C.H=C.H%12+C.p*12),C.m===void 0&&(C.m="q"in C?C.q:0),"V"in C){if(C.V<1||C.V>53)return null;"w"in C||(C.w=1),"Z"in C?(J=Nc(Cs(C.y,0,1)),it=J.getUTCDay(),J=it>4||it===0?or.ceil(J):or(J),J=pa.offset(J,(C.V-1)*7),C.y=J.getUTCFullYear(),C.m=J.getUTCMonth(),C.d=J.getUTCDate()+(C.w+6)%7):(J=Ic(Cs(C.y,0,1)),it=J.getDay(),J=it>4||it===0?sr.ceil(J):sr(J),J=rr.offset(J,(C.V-1)*7),C.y=J.getFullYear(),C.m=J.getMonth(),C.d=J.getDate()+(C.w+6)%7)}else("W"in C||"U"in C)&&("w"in C||(C.w="u"in C?C.u%7:"W"in C?1:0),it="Z"in C?Nc(Cs(C.y,0,1)).getUTCDay():Ic(Cs(C.y,0,1)).getDay(),C.m=0,C.d="W"in C?(C.w+6)%7+C.W*7-(it+5)%7:C.w+C.U*7-(it+6)%7);return"Z"in C?(C.H+=C.Z/100|0,C.M+=C.Z%100,Nc(C)):Ic(C)}}function H(B,st,nt,C){for(var j=0,J=st.length,it=nt.length,et,vt;j<J;){if(C>=it)return-1;if(et=st.charCodeAt(j++),et===37){if(et=st.charAt(j++),vt=S[et in Wp?st.charAt(j++):et],!vt||(C=vt(B,nt,C))<0)return-1}else if(et!=nt.charCodeAt(C++))return-1}return C}function tt(B,st,nt){var C=c.exec(st.slice(nt));return C?(B.p=u[C[0].toLowerCase()],nt+C[0].length):-1}function X(B,st,nt){var C=d.exec(st.slice(nt));return C?(B.w=g[C[0].toLowerCase()],nt+C[0].length):-1}function y(B,st,nt){var C=h.exec(st.slice(nt));return C?(B.w=f[C[0].toLowerCase()],nt+C[0].length):-1}function R(B,st,nt){var C=m.exec(st.slice(nt));return C?(B.m=p[C[0].toLowerCase()],nt+C[0].length):-1}function D(B,st,nt){var C=x.exec(st.slice(nt));return C?(B.m=v[C[0].toLowerCase()],nt+C[0].length):-1}function F(B,st,nt){return H(B,t,st,nt)}function z(B,st,nt){return H(B,e,st,nt)}function N(B,st,nt){return H(B,i,st,nt)}function V(B){return o[B.getDay()]}function Q(B){return s[B.getDay()]}function at(B){return l[B.getMonth()]}function G(B){return a[B.getMonth()]}function $(B){return r[+(B.getHours()>=12)]}function lt(B){return 1+~~(B.getMonth()/3)}function dt(B){return o[B.getUTCDay()]}function xt(B){return s[B.getUTCDay()]}function k(B){return l[B.getUTCMonth()]}function Ft(B){return a[B.getUTCMonth()]}function mt(B){return r[+(B.getUTCHours()>=12)]}function St(B){return 1+~~(B.getUTCMonth()/3)}return{format:function(B){var st=L(B+="",b);return st.toString=function(){return B},st},parse:function(B){var st=A(B+="",!1);return st.toString=function(){return B},st},utcFormat:function(B){var st=L(B+="",_);return st.toString=function(){return B},st},utcParse:function(B){var st=A(B+="",!0);return st.toString=function(){return B},st}}}var Wp={"-":"",_:" ",0:"0"},pe=/^\s*\d+/,Dv=/^%/,Iv=/[\\^$*+?|[\]().{}]/g;function Bt(n,t,e){var i=n<0?"-":"",r=(i?-n:n)+"",s=r.length;return i+(s<e?new Array(e-s+1).join(t)+r:r)}function Nv(n){return n.replace(Iv,"\\$&")}function Rs(n){return new RegExp("^(?:"+n.map(Nv).join("|")+")","i")}function Ls(n){for(var t={},e=-1,i=n.length;++e<i;)t[n[e].toLowerCase()]=e;return t}function Fv(n,t,e){var i=pe.exec(t.slice(e,e+1));return i?(n.w=+i[0],e+i[0].length):-1}function zv(n,t,e){var i=pe.exec(t.slice(e,e+1));return i?(n.u=+i[0],e+i[0].length):-1}function Uv(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.U=+i[0],e+i[0].length):-1}function Bv(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.V=+i[0],e+i[0].length):-1}function Ov(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.W=+i[0],e+i[0].length):-1}function qp(n,t,e){var i=pe.exec(t.slice(e,e+4));return i?(n.y=+i[0],e+i[0].length):-1}function Xp(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.y=+i[0]+(+i[0]>68?1900:2e3),e+i[0].length):-1}function kv(n,t,e){var i=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(t.slice(e,e+6));return i?(n.Z=i[1]?0:-(i[2]+(i[3]||"00")),e+i[0].length):-1}function Hv(n,t,e){var i=pe.exec(t.slice(e,e+1));return i?(n.q=i[0]*3-3,e+i[0].length):-1}function Vv(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.m=i[0]-1,e+i[0].length):-1}function Yp(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.d=+i[0],e+i[0].length):-1}function Gv(n,t,e){var i=pe.exec(t.slice(e,e+3));return i?(n.m=0,n.d=+i[0],e+i[0].length):-1}function Zp(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.H=+i[0],e+i[0].length):-1}function Wv(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.M=+i[0],e+i[0].length):-1}function qv(n,t,e){var i=pe.exec(t.slice(e,e+2));return i?(n.S=+i[0],e+i[0].length):-1}function Xv(n,t,e){var i=pe.exec(t.slice(e,e+3));return i?(n.L=+i[0],e+i[0].length):-1}function Yv(n,t,e){var i=pe.exec(t.slice(e,e+6));return i?(n.L=Math.floor(i[0]/1e3),e+i[0].length):-1}function Zv(n,t,e){var i=Dv.exec(t.slice(e,e+1));return i?e+i[0].length:-1}function Jv(n,t,e){var i=pe.exec(t.slice(e));return i?(n.Q=+i[0],e+i[0].length):-1}function $v(n,t,e){var i=pe.exec(t.slice(e));return i?(n.s=+i[0],e+i[0].length):-1}function Jp(n,t){return Bt(n.getDate(),t,2)}function Kv(n,t){return Bt(n.getHours(),t,2)}function Qv(n,t){return Bt(n.getHours()%12||12,t,2)}function jv(n,t){return Bt(1+rr.count(En(n),n),t,3)}function tm(n,t){return Bt(n.getMilliseconds(),t,3)}function t_(n,t){return tm(n,t)+"000"}function e_(n,t){return Bt(n.getMonth()+1,t,2)}function n_(n,t){return Bt(n.getMinutes(),t,2)}function i_(n,t){return Bt(n.getSeconds(),t,2)}function r_(n){var t=n.getDay();return t===0?7:t}function s_(n,t){return Bt(Ei.count(En(n)-1,n),t,2)}function em(n){var t=n.getDay();return t>=4||t===0?Gn(n):Gn.ceil(n)}function o_(n,t){return n=em(n),Bt(Gn.count(En(n),n)+(En(n).getDay()===4),t,2)}function a_(n){return n.getDay()}function l_(n,t){return Bt(sr.count(En(n)-1,n),t,2)}function c_(n,t){return Bt(n.getFullYear()%100,t,2)}function u_(n,t){return n=em(n),Bt(n.getFullYear()%100,t,2)}function h_(n,t){return Bt(n.getFullYear()%1e4,t,4)}function f_(n,t){var e=n.getDay();return n=e>=4||e===0?Gn(n):Gn.ceil(n),Bt(n.getFullYear()%1e4,t,4)}function d_(n){var t=n.getTimezoneOffset();return(t>0?"-":(t*=-1,"+"))+Bt(t/60|0,"0",2)+Bt(t%60,"0",2)}function $p(n,t){return Bt(n.getUTCDate(),t,2)}function p_(n,t){return Bt(n.getUTCHours(),t,2)}function m_(n,t){return Bt(n.getUTCHours()%12||12,t,2)}function g_(n,t){return Bt(1+pa.count(Ai(n),n),t,3)}function nm(n,t){return Bt(n.getUTCMilliseconds(),t,3)}function x_(n,t){return nm(n,t)+"000"}function y_(n,t){return Bt(n.getUTCMonth()+1,t,2)}function v_(n,t){return Bt(n.getUTCMinutes(),t,2)}function __(n,t){return Bt(n.getUTCSeconds(),t,2)}function w_(n){var t=n.getUTCDay();return t===0?7:t}function M_(n,t){return Bt(As.count(Ai(n)-1,n),t,2)}function im(n){var t=n.getUTCDay();return t>=4||t===0?Wn(n):Wn.ceil(n)}function b_(n,t){return n=im(n),Bt(Wn.count(Ai(n),n)+(Ai(n).getUTCDay()===4),t,2)}function S_(n){return n.getUTCDay()}function E_(n,t){return Bt(or.count(Ai(n)-1,n),t,2)}function T_(n,t){return Bt(n.getUTCFullYear()%100,t,2)}function A_(n,t){return n=im(n),Bt(n.getUTCFullYear()%100,t,2)}function C_(n,t){return Bt(n.getUTCFullYear()%1e4,t,4)}function R_(n,t){var e=n.getUTCDay();return n=e>=4||e===0?Wn(n):Wn.ceil(n),Bt(n.getUTCFullYear()%1e4,t,4)}function L_(){return"+0000"}function Kp(){return"%"}function Qp(n){return+n}function jp(n){return Math.floor(+n/1e3)}var ar,ma,rm,sm,om;zc({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]});function zc(n){return ar=Fc(n),ma=ar.format,rm=ar.parse,sm=ar.utcFormat,om=ar.utcParse,ar}var Ps=1e3,Ds=Ps*60,Is=Ds*60,Ns=Is*24,P_=Ns*7,am=Ns*30,Uc=Ns*365;function D_(n){return new Date(n)}function I_(n){return n instanceof Date?+n:+new Date(+n)}function Bc(n,t,e,i,r,s,o,a,l){var c=Es(De,De),u=c.invert,h=c.domain,f=l(".%L"),d=l(":%S"),g=l("%I:%M"),x=l("%I %p"),v=l("%a %d"),m=l("%b %d"),p=l("%B"),b=l("%Y"),_=[[o,1,Ps],[o,5,5*Ps],[o,15,15*Ps],[o,30,30*Ps],[s,1,Ds],[s,5,5*Ds],[s,15,15*Ds],[s,30,30*Ds],[r,1,Is],[r,3,3*Is],[r,6,6*Is],[r,12,12*Is],[i,1,Ns],[i,2,2*Ns],[e,1,P_],[t,1,am],[t,3,3*am],[n,1,Uc]];function S(A){return(o(A)<A?f:s(A)<A?d:r(A)<A?g:i(A)<A?x:t(A)<A?e(A)<A?v:m:n(A)<A?p:b)(A)}function L(A,H,tt,X){if(A==null&&(A=10),typeof A=="number"){var y=Math.abs(tt-H)/A,R=is(function(D){return D[2]}).right(_,y);R===_.length?(X=_n(H/Uc,tt/Uc,A),A=n):R?(R=_[y/_[R-1][2]<_[R][2]/y?R-1:R],X=R[1],A=R[0]):(X=Math.max(_n(H,tt,A),1),A=a)}return X==null?A:A.every(X)}return c.invert=function(A){return new Date(u(A))},c.domain=function(A){return arguments.length?h(bs.call(A,I_)):h().map(D_)},c.ticks=function(A,H){var tt=h(),X=tt[0],y=tt[tt.length-1],R=y<X,D;return R&&(D=X,X=y,y=D),D=L(A,X,y,H),D=D?D.range(X,y+1):[],R?D.reverse():D},c.tickFormat=function(A,H){return H==null?S:l(H)},c.nice=function(A,H){var tt=h();return(A=L(A,tt[0],tt[tt.length-1],H))?h(la(tt,A)):c},c.copy=function(){return Vn(c,Bc(n,t,e,i,r,s,o,a,l))},c}function Fs(){return Pe.apply(Bc(En,Lc,Ei,rr,Rc,Cc,da,ua,ma).domain([new Date(2e3,0,1),new Date(2e3,0,2)]),arguments)}function Oc(){this._=null}function lr(n){n.U=n.C=n.L=n.R=n.P=n.N=null}Oc.prototype={constructor:Oc,insert:function(n,t){var e,i,r;if(n){if(t.P=n,t.N=n.N,n.N&&(n.N.P=t),n.N=t,n.R){for(n=n.R;n.L;)n=n.L;n.L=t}else n.R=t;e=n}else this._?(n=cm(this._),t.P=null,t.N=n,n.P=n.L=t,e=n):(t.P=t.N=null,this._=t,e=null);for(t.L=t.R=null,t.U=e,t.C=!0,n=t;e&&e.C;)i=e.U,e===i.L?(r=i.R,r&&r.C?(e.C=r.C=!1,i.C=!0,n=i):(n===e.R&&(zs(this,e),n=e,e=n.U),e.C=!1,i.C=!0,Us(this,i))):(r=i.L,r&&r.C?(e.C=r.C=!1,i.C=!0,n=i):(n===e.L&&(Us(this,e),n=e,e=n.U),e.C=!1,i.C=!0,zs(this,i))),e=n.U;this._.C=!1},remove:function(n){n.N&&(n.N.P=n.P),n.P&&(n.P.N=n.N),n.N=n.P=null;var t=n.U,e,i=n.L,r=n.R,s,o;if(i?r?s=cm(r):s=i:s=r,t?t.L===n?t.L=s:t.R=s:this._=s,i&&r?(o=s.C,s.C=n.C,s.L=i,i.U=s,s!==r?(t=s.U,s.U=n.U,n=s.R,t.L=n,s.R=r,r.U=s):(s.U=t,t=s,n=s.R)):(o=n.C,n=s),n&&(n.U=t),!o){if(n&&n.C){n.C=!1;return}do{if(n===this._)break;if(n===t.L){if(e=t.R,e.C&&(e.C=!1,t.C=!0,zs(this,t),e=t.R),e.L&&e.L.C||e.R&&e.R.C){(!e.R||!e.R.C)&&(e.L.C=!1,e.C=!0,Us(this,e),e=t.R),e.C=t.C,t.C=e.R.C=!1,zs(this,t),n=this._;break}}else if(e=t.L,e.C&&(e.C=!1,t.C=!0,Us(this,t),e=t.L),e.L&&e.L.C||e.R&&e.R.C){(!e.L||!e.L.C)&&(e.R.C=!1,e.C=!0,zs(this,e),e=t.L),e.C=t.C,t.C=e.L.C=!1,Us(this,t),n=this._;break}e.C=!0,n=t,t=t.U}while(!n.C);n&&(n.C=!1)}}};function zs(n,t){var e=t,i=t.R,r=e.U;r?r.L===e?r.L=i:r.R=i:n._=i,i.U=r,e.U=i,e.R=i.L,e.R&&(e.R.U=e),i.L=e}function Us(n,t){var e=t,i=t.L,r=e.U;r?r.L===e?r.L=i:r.R=i:n._=i,i.U=r,e.U=i,e.L=i.R,e.L&&(e.L.U=e),i.R=e}function cm(n){for(;n.L;)n=n.L;return n}var kc=Oc;function cr(n,t,e,i){var r=[null,null],s=me.push(r)-1;return r.left=n,r.right=t,e&&Bs(r,n,t,e),i&&Bs(r,t,n,i),Ce[n.index].halfedges.push(s),Ce[t.index].halfedges.push(s),r}function ur(n,t,e){var i=[t,e];return i.left=n,i}function Bs(n,t,e,i){!n[0]&&!n[1]?(n[0]=i,n.left=t,n.right=e):n.left===e?n[1]=i:n[0]=i}function z_(n,t,e,i,r){var s=n[0],o=n[1],a=s[0],l=s[1],c=o[0],u=o[1],h=0,f=1,d=c-a,g=u-l,x;if(x=t-a,!(!d&&x>0)){if(x/=d,d<0){if(x<h)return;x<f&&(f=x)}else if(d>0){if(x>f)return;x>h&&(h=x)}if(x=i-a,!(!d&&x<0)){if(x/=d,d<0){if(x>f)return;x>h&&(h=x)}else if(d>0){if(x<h)return;x<f&&(f=x)}if(x=e-l,!(!g&&x>0)){if(x/=g,g<0){if(x<h)return;x<f&&(f=x)}else if(g>0){if(x>f)return;x>h&&(h=x)}if(x=r-l,!(!g&&x<0)){if(x/=g,g<0){if(x>f)return;x>h&&(h=x)}else if(g>0){if(x<h)return;x<f&&(f=x)}return!(h>0)&&!(f<1)||(h>0&&(n[0]=[a+h*d,l+h*g]),f<1&&(n[1]=[a+f*d,l+f*g])),!0}}}}}function U_(n,t,e,i,r){var s=n[1];if(s)return!0;var o=n[0],a=n.left,l=n.right,c=a[0],u=a[1],h=l[0],f=l[1],d=(c+h)/2,g=(u+f)/2,x,v;if(f===u){if(d<t||d>=i)return;if(c>h){if(!o)o=[d,e];else if(o[1]>=r)return;s=[d,r]}else{if(!o)o=[d,r];else if(o[1]<e)return;s=[d,e]}}else if(x=(c-h)/(f-u),v=g-x*d,x<-1||x>1)if(c>h){if(!o)o=[(e-v)/x,e];else if(o[1]>=r)return;s=[(r-v)/x,r]}else{if(!o)o=[(r-v)/x,r];else if(o[1]<e)return;s=[(e-v)/x,e]}else if(u<f){if(!o)o=[t,x*t+v];else if(o[0]>=i)return;s=[i,x*i+v]}else{if(!o)o=[i,x*i+v];else if(o[0]<t)return;s=[t,x*t+v]}return n[0]=o,n[1]=s,!0}function um(n,t,e,i){for(var r=me.length,s;r--;)(!U_(s=me[r],n,t,e,i)||!z_(s,n,t,e,i)||!(Math.abs(s[0][0]-s[1][0])>Xt||Math.abs(s[0][1]-s[1][1])>Xt))&&delete me[r]}function hm(n){return Ce[n.index]={site:n,halfedges:[]}}function B_(n,t){var e=n.site,i=t.left,r=t.right;return e===r&&(r=i,i=e),r?Math.atan2(r[1]-i[1],r[0]-i[0]):(e===i?(i=t[1],r=t[0]):(i=t[0],r=t[1]),Math.atan2(i[0]-r[0],r[1]-i[1]))}function Hc(n,t){return t[+(t.left!==n.site)]}function O_(n,t){return t[+(t.left===n.site)]}function fm(){for(var n=0,t=Ce.length,e,i,r,s;n<t;++n)if((e=Ce[n])&&(s=(i=e.halfedges).length)){var o=new Array(s),a=new Array(s);for(r=0;r<s;++r)o[r]=r,a[r]=B_(e,me[i[r]]);for(o.sort(function(l,c){return a[c]-a[l]}),r=0;r<s;++r)a[r]=i[o[r]];for(r=0;r<s;++r)i[r]=a[r]}}function dm(n,t,e,i){var r=Ce.length,s,o,a,l,c,u,h,f,d,g,x,v,m=!0;for(s=0;s<r;++s)if(o=Ce[s]){for(a=o.site,c=o.halfedges,l=c.length;l--;)me[c[l]]||c.splice(l,1);for(l=0,u=c.length;l<u;)g=O_(o,me[c[l]]),x=g[0],v=g[1],h=Hc(o,me[c[++l%u]]),f=h[0],d=h[1],(Math.abs(x-f)>Xt||Math.abs(v-d)>Xt)&&(c.splice(l,0,me.push(ur(a,g,Math.abs(x-n)<Xt&&i-v>Xt?[n,Math.abs(f-n)<Xt?d:i]:Math.abs(v-i)<Xt&&e-x>Xt?[Math.abs(d-i)<Xt?f:e,i]:Math.abs(x-e)<Xt&&v-t>Xt?[e,Math.abs(f-e)<Xt?d:t]:Math.abs(v-t)<Xt&&x-n>Xt?[Math.abs(d-t)<Xt?f:n,t]:null))-1),++u);u&&(m=!1)}if(m){var p,b,_,S=1/0;for(s=0,m=null;s<r;++s)(o=Ce[s])&&(a=o.site,p=a[0]-n,b=a[1]-t,_=p*p+b*b,_<S&&(S=_,m=o));if(m){var L=[n,t],A=[n,i],H=[e,i],tt=[e,t];m.halfedges.push(me.push(ur(a=m.site,L,A))-1,me.push(ur(a,A,H))-1,me.push(ur(a,H,tt))-1,me.push(ur(a,tt,L))-1)}}for(s=0;s<r;++s)(o=Ce[s])&&(o.halfedges.length||delete Ce[s])}var pm=[],ga;function k_(){lr(this),this.x=this.y=this.arc=this.site=this.cy=null}function Ci(n){var t=n.P,e=n.N;if(!(!t||!e)){var i=t.site,r=n.site,s=e.site;if(i!==s){var o=r[0],a=r[1],l=i[0]-o,c=i[1]-a,u=s[0]-o,h=s[1]-a,f=2*(l*h-c*u);if(!(f>=-mm)){var d=l*l+c*c,g=u*u+h*h,x=(h*d-c*g)/f,v=(l*g-u*d)/f,m=pm.pop()||new k_;m.arc=n,m.site=r,m.x=x+o,m.y=(m.cy=v+a)+Math.sqrt(x*x+v*v),n.circle=m;for(var p=null,b=hr._;b;)if(m.y<b.y||m.y===b.y&&m.x<=b.x)if(b.L)b=b.L;else{p=b.P;break}else if(b.R)b=b.R;else{p=b;break}hr.insert(p,m),p||(ga=m)}}}}function Ri(n){var t=n.circle;t&&(t.P||(ga=t.N),hr.remove(t),pm.push(t),lr(t),n.circle=null)}var xm=[];function H_(){lr(this),this.edge=this.site=this.circle=null}function gm(n){var t=xm.pop()||new H_;return t.site=n,t}function Vc(n){Ri(n),Li.remove(n),xm.push(n),lr(n)}function ym(n){var t=n.circle,e=t.x,i=t.cy,r=[e,i],s=n.P,o=n.N,a=[n];Vc(n);for(var l=s;l.circle&&Math.abs(e-l.circle.x)<Xt&&Math.abs(i-l.circle.cy)<Xt;)s=l.P,a.unshift(l),Vc(l),l=s;a.unshift(l),Ri(l);for(var c=o;c.circle&&Math.abs(e-c.circle.x)<Xt&&Math.abs(i-c.circle.cy)<Xt;)o=c.N,a.push(c),Vc(c),c=o;a.push(c),Ri(c);var u=a.length,h;for(h=1;h<u;++h)c=a[h],l=a[h-1],Bs(c.edge,l.site,c.site,r);l=a[0],c=a[u-1],c.edge=cr(l.site,c.site,null,r),Ci(l),Ci(c)}function vm(n){for(var t=n[0],e=n[1],i,r,s,o,a=Li._;a;)if(s=_m(a,e)-t,s>Xt)a=a.L;else if(o=t-V_(a,e),o>Xt){if(!a.R){i=a;break}a=a.R}else{s>-Xt?(i=a.P,r=a):o>-Xt?(i=a,r=a.N):i=r=a;break}hm(n);var l=gm(n);if(Li.insert(i,l),!(!i&&!r)){if(i===r){Ri(i),r=gm(i.site),Li.insert(l,r),l.edge=r.edge=cr(i.site,l.site),Ci(i),Ci(r);return}if(!r){l.edge=cr(i.site,l.site);return}Ri(i),Ri(r);var c=i.site,u=c[0],h=c[1],f=n[0]-u,d=n[1]-h,g=r.site,x=g[0]-u,v=g[1]-h,m=2*(f*v-d*x),p=f*f+d*d,b=x*x+v*v,_=[(v*p-d*b)/m+u,(f*b-x*p)/m+h];Bs(r.edge,c,g,_),l.edge=cr(c,n,null,_),r.edge=cr(n,g,null,_),Ci(i),Ci(r)}}function _m(n,t){var e=n.site,i=e[0],r=e[1],s=r-t;if(!s)return i;var o=n.P;if(!o)return-1/0;e=o.site;var a=e[0],l=e[1],c=l-t;if(!c)return a;var u=a-i,h=1/s-1/c,f=u/c;return h?(-f+Math.sqrt(f*f-2*h*(u*u/(-2*c)-l+c/2+r-s/2)))/h+i:(i+a)/2}function V_(n,t){var e=n.N;if(e)return _m(e,t);var i=n.site;return i[1]===t?i[0]:1/0}var Xt=1e-6,mm=1e-12,Li,Ce,hr,me;function G_(n,t,e){return(n[0]-e[0])*(t[1]-n[1])-(n[0]-t[0])*(e[1]-n[1])}function W_(n,t){return t[1]-n[1]||t[0]-n[0]}function xa(n,t){var e=n.sort(W_).pop(),i,r,s;for(me=[],Ce=new Array(n.length),Li=new kc,hr=new kc;;)if(s=ga,e&&(!s||e[1]<s.y||e[1]===s.y&&e[0]<s.x))(e[0]!==i||e[1]!==r)&&(vm(e),i=e[0],r=e[1]),e=n.pop();else if(s)ym(s.arc);else break;if(fm(),t){var o=+t[0][0],a=+t[0][1],l=+t[1][0],c=+t[1][1];um(o,a,l,c),dm(o,a,l,c)}this.edges=me,this.cells=Ce,Li=hr=me=Ce=null}xa.prototype={constructor:xa,polygons:function(){var n=this.edges;return this.cells.map(function(t){var e=t.halfedges.map(function(i){return Hc(t,n[i])});return e.data=t.site.data,e})},triangles:function(){var n=[],t=this.edges;return this.cells.forEach(function(e,i){if(!!(a=(s=e.halfedges).length))for(var r=e.site,s,o=-1,a,l,c=t[s[a-1]],u=c.left===r?c.right:c.left;++o<a;)l=u,c=t[s[o]],u=c.left===r?c.right:c.left,l&&u&&i<l.index&&i<u.index&&G_(r,l,u)<0&&n.push([r.data,l.data,u.data])}),n},links:function(){return this.edges.filter(function(n){return n.right}).map(function(n){return{source:n.left.data,target:n.right.data}})},find:function(n,t,e){for(var i=this,r,s=i._found||0,o=i.cells.length,a;!(a=i.cells[s]);)if(++s>=o)return null;var l=n-a.site[0],c=t-a.site[1],u=l*l+c*c;do a=i.cells[r=s],s=null,a.halfedges.forEach(function(h){var f=i.edges[h],d=f.left;if(!((d===a.site||!d)&&!(d=f.right))){var g=n-d[0],x=t-d[1],v=g*g+x*x;v<u&&(u=v,s=d.index)}});while(s!==null);return i._found=r,e==null||u<=e*e?a.site:null}};function Pi(n,t,e){this.k=n,this.x=t,this.y=e}Pi.prototype={constructor:Pi,scale:function(n){return n===1?this:new Pi(this.k*n,this.x,this.y)},translate:function(n,t){return n===0&t===0?this:new Pi(this.k,this.x+this.k*n,this.y+this.k*t)},apply:function(n){return[n[0]*this.k+this.x,n[1]*this.k+this.y]},applyX:function(n){return n*this.k+this.x},applyY:function(n){return n*this.k+this.y},invert:function(n){return[(n[0]-this.x)/this.k,(n[1]-this.y)/this.k]},invertX:function(n){return(n-this.x)/this.k},invertY:function(n){return(n-this.y)/this.k},rescaleX:function(n){return n.copy().domain(n.range().map(this.invertX,this).map(n.invert,n))},rescaleY:function(n){return n.copy().domain(n.range().map(this.invertY,this).map(n.invert,n))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};var Gc=new Pi(1,0,0);Wc.prototype=Pi.prototype;function Wc(n){for(;!n.__zoom;)if(!(n=n.parentNode))return Gc;return n.__zoom}var bm=1e4,Sm=.001,Em=Oe(".2~e"),q_=Oe(".4~r"),wm=Oe(",~");function Mm(n){if(n===0)return"0";let t=Math.abs(n);return t>=bm||t<Sm?Em(n):q_(n)}var Xc={formatTick:Mm,formatShort:Mm,formatReadable(n){let t=Math.abs(n);return t>=bm||t<Sm?Em(n):wm(n)},formatLong:wm},sk=new Intl.NumberFormat(void 0,{maximumFractionDigits:3});var ok=Oe("0.3~s"),ak=Oe(",.3~f");var X_=1e3,Y_=60*X_,Z_=60*Y_,J_=24*Z_,lk=365*J_,ck=Oe(".4~");var $_=Fs().tickFormat(),qc,Tm={formatTick(n){return $_(new Date(n))},formatShort(n){return new Date(n).toLocaleString(qc,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric"})},formatReadable(n){return new Date(n).toLocaleString(qc,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short"})},formatLong(n){return new Date(n).toLocaleString(qc,{year:"numeric",month:"long",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short",fractionalSecondDigits:3})}};function fr(n){switch(n){case on.LINEAR:return new Yc;case on.LOG10:return new Zc;case on.TIME:return new Jc;default:let t=n;throw new RangeError(`ScaleType ${t} not supported.`)}}var K_=.05,Yc=class{constructor(){this.defaultFormatter=Xc}transform(t,e,i){let[r,s]=t,o=s-r,[a,l]=e,c=l-a;return o===0?a:c/o*(i-r)+a}forward(t,e,i){return this.transform(t,e,i)}reverse(t,e,i){return this.transform(e,t,i)}niceDomain(t){let[e,i]=t;if(i<e)throw new Error("Unexpected input: min is larger than max");if(i===e)return e===0?[-1,1]:e<0?[2*e,0]:[0,2*e];let r=ir(),s=(i-e+Number.EPSILON)*K_,[o,a]=r.domain([e-s,i+s]).nice().domain();return[o,a]}ticks(t,e){return ir().domain(t).ticks(e)}isSafeNumber(t){return Number.isFinite(t)}},Zc=class{constructor(){this.defaultFormatter=Xc}transform(t){return Math.log10(t>0?t:Number.MIN_VALUE)}untransform(t){return Math.exp(t/Math.LOG10E)}forward(t,e,i){if(i<=0)return e[0];let[r,s]=t,[o,a]=e,l=this.transform(r),u=this.transform(s)-l,h=a-o;return i=this.transform(i),h/(u+Number.EPSILON)*(i-l)+o}reverse(t,e,i){let[r,s]=t,[o,a]=e,l=this.transform(r),u=this.transform(s)-l,h=a-o,f=u/(h+Number.EPSILON)*(i-o)+l;return this.untransform(f)}niceDomain(t){let[e,i]=t;if(e>i)throw new Error("Unexpected input: min is larger than max");let r=Math.max(e,Number.MIN_VALUE),s=Math.max(i,Number.MIN_VALUE);return i<=0?[Number.MIN_VALUE,1]:[Math.max(Number.MIN_VALUE,r*.5),s*2]}ticks(t,e){let i=t[0]<=0?Number.MIN_VALUE:t[0],r=t[1]<=0?Number.MIN_VALUE:t[1],s=Ts().domain([i,r]).ticks(e);return s.length?s:t}isSafeNumber(t){return Number.isFinite(t)&&t>0}},Jc=class{constructor(){this.scale=Fs(),this.defaultFormatter=Tm}forward(t,e,i){return this.scale.domain(t).range(e)(i)}reverse(t,e,i){return this.scale.domain(t).range(e).invert(i).getTime()}niceDomain(t){let[e,i]=this.scale.domain(t).nice().domain();return[e.getTime(),i.getTime()]}ticks(t,e){return this.scale.domain(t).ticks(e).map(i=>i.getTime())}isSafeNumber(t){return Number.isFinite(t)}};function Q_(n){return{x:[n.x,n.x+n.width],y:[n.y,n.y+n.height]}}var $c=!1;if(self.hasOwnProperty("WebGL2RenderingContext")&&self.hasOwnProperty("document")){let n=document.createElement("canvas");n.addEventListener("webglcontextcreationerror",()=>{$c=!1});let t=n.getContext("webgl2");$c=Boolean(t)}function j_(){return $c}function tw(){return self.hasOwnProperty("OffscreenCanvas")}function ew(n,t){if(n.length!==t.length)return!1;for(let e=0;e<n.length;e++)if(n[e]!==t[e])return!1;return!0}function nw(n,t){return n.x[0]===t.x[0]&&n.x[1]===t.x[1]&&n.y[0]===t.y[0]&&n.y[1]===t.y[1]}var Di={convertRectToExtent:Q_,isWebGl2Supported:j_,isOffscreenCanvasSupported:tw,arePolylinesEqual:ew,areExtentsEqual:nw};var dr=class{constructor(){this.xScale=fr(on.LINEAR),this.yScale=fr(on.LINEAR),this.domContainerRect={x:0,width:1,y:0,height:1},this.lastUpdated=0,this.currentViewBoxRect={x:0,width:1,y:0,height:1}}getUpdateIdentifier(){return this.lastUpdated}updateIdentifier(){this.lastUpdated++}isYAxisPointedDown(){return!0}setXScale(t){this.xScale=t,this.updateIdentifier()}setYScale(t){this.yScale=t,this.updateIdentifier()}getCurrentViewBoxRect(){return this.currentViewBoxRect}setViewBoxRect(t){this.currentViewBoxRect=t,this.updateIdentifier()}setDomContainerRect(t){this.domContainerRect=t,this.updateIdentifier()}transformDataToUiCoord(t,e){let i=t,r=Di.convertRectToExtent(this.currentViewBoxRect);return[this.xScale.forward(r.x,[i.x,i.x+i.width],e[0]),this.yScale.forward(r.y,this.isYAxisPointedDown()?[i.y+i.height,i.y]:[i.y,i.y+i.height],e[1])]}};var Tn;(function(n){n[n.SVG=0]="SVG",n[n.WEBGL=1]="WEBGL"})(Tn||(Tn={}));function ya(n,t,e,i){let{color:r,visible:s,opacity:o}=i,a=n;return!a&&!s?null:(a=a!=null?a:t(),a=e(a),a.style.display=s?"":"none",a.style.stroke=r,a.style.opacity=String(o!=null?o:1),a)}var Os=class{constructor(t){this.svg=t}flush(){}onResize(t){}destroyObject(t){this.svg.removeChild(t.dom)}setUseDarkMode(t){}createPathDString(t){if(!t.length)return"";let e=new Array(t.length/2);e[0]=`M${t[0]},${t[1]}`;for(let i=1;i<t.length/2;i++)e[i]=`L${t[i*2]},${t[i*2+1]}`;return e.join("")}createOrUpdateLineObject(t,e,i){let r=ya(t==null?void 0:t.dom,()=>{let s=document.createElementNS("http://www.w3.org/2000/svg","path");s.style.fill="none";let o=this.createPathDString(e);return s.setAttribute("d",o),this.svg.appendChild(s),s},s=>{if(!(t!=null&&t.data)||!Di.arePolylinesEqual(e,t==null?void 0:t.data)){let o=this.createPathDString(e);s.setAttribute("d",o)}return s},i);return r===null?null:(r.style.strokeWidth=String(i.width),{dom:r,data:e})}createOrUpdateTriangleObject(t,e,i){let{size:r,color:s}=i,o=r*Math.sqrt(3)/2,a=new Float32Array([e.x-r/2,e.y+o/3,e.x+r/2,e.y+o/3,e.x,e.y-o*2/3]),l=ya(t==null?void 0:t.dom,()=>{let c=document.createElementNS("http://www.w3.org/2000/svg","path");c.classList.add("triangle"),c.style.fill="none";let u=this.createPathDString(a);return c.setAttribute("d",u+"Z"),this.svg.appendChild(c),c},c=>{let u=this.createPathDString(a);return c.setAttribute("d",u+"Z"),c},i);return l===null?null:(l.style.fill=s,{dom:l,data:a})}createOrUpdateCircleObject(t,e,i){let{color:r,radius:s}=i,o=ya(t==null?void 0:t.dom,()=>{let a=document.createElementNS("http://www.w3.org/2000/svg","circle");return a.style.fill=r,a.setAttribute("cx",String(e.x)),a.setAttribute("cy",String(e.y)),a.setAttribute("r",String(s)),this.svg.appendChild(a),a},a=>(a.style.fill=r,a.setAttribute("cx",String(e.x)),a.setAttribute("cy",String(e.y)),a.setAttribute("r",String(s)),a),i);return o===null?null:{dom:o,data:e}}createOrUpdateTrapezoidObject(t,e,i,r){if(e.y!==i.y)throw new RangeError("Input error: start.y != end.y.");let{altitude:s,color:o}=r,a=2/Math.sqrt(3)*s,l=new Float32Array([e.x-a/2,e.y+s/2,e.x,e.y-s/2,i.x,i.y-s/2,i.x+a/2,i.y+s/2]),c=ya(t==null?void 0:t.dom,()=>{let u=document.createElementNS("http://www.w3.org/2000/svg","path");u.classList.add("trapezoid"),u.style.fill="none";let h=this.createPathDString(l);return u.setAttribute("d",h+"Z"),this.svg.appendChild(u),u},u=>{let h=this.createPathDString(l);return u.setAttribute("d",h+"Z"),u},r);return c===null?null:(c.style.fill=o,{dom:c,data:l})}dispose(){}};var $h="137";var iw=0,Am=1,rw=2;var l0=1,sw=2,Js=3,eo=0,he=1,Hr=2,c0=1;var jn=0,Ks=1,Cm=2,Rm=3,Lm=4,ow=5,Ir=100,aw=101,lw=102,Pm=103,Dm=104,cw=200,uw=201,hw=202,fw=203,u0=204,h0=205,dw=206,pw=207,mw=208,gw=209,xw=210,yw=0,vw=1,_w=2,zu=3,ww=4,Mw=5,bw=6,Sw=7,Cl=0,Ew=1,Tw=2,ti=0,Aw=1,Cw=2,Rw=3,Lw=4,Pw=5,f0=300,Ao=301,Co=302,Uu=303,Bu=304,Rl=306,Kh=307,Ou=1e3,Ve=1001,ku=1002,fe=1003,Im=1004;var Nm=1005;var be=1006,Dw=1007;var Ll=1008;var ei=1009,Iw=1010,Nw=1011,no=1012,Fw=1013,Qa=1014,Ui=1015,Ur=1016,zw=1017,Uw=1018,Br=1020,Bw=1021,Re=1023,Ow=1024,kw=1025,Oi=1026,Vr=1027,Hw=1028,Vw=1029,Gw=1030,Ww=1031,qw=1033,Kc=33776,Qc=33777,jc=33778,tu=33779,Fm=35840,zm=35841,Um=35842,Bm=35843,Xw=36196,Om=37492,km=37496,Hm=37808,Vm=37809,Gm=37810,Wm=37811,qm=37812,Xm=37813,Ym=37814,Zm=37815,Jm=37816,$m=37817,Km=37818,Qm=37819,jm=37820,tg=37821,eg=36492,Yw=2200,Zw=2201,Jw=2202,ja=2300,tl=2301,eu=2302,Nr=2400,Fr=2401,el=2402,Qh=2500,d0=2501,$w=0;var ri=3e3,$t=3001,Kw=3200,Qw=3201,ts=0,jw=1;var nu=7680;var tM=519,io=35044,nl=35048;var ng="300 es",Hu=1035,In=class{addEventListener(t,e){this._listeners===void 0&&(this._listeners={});let i=this._listeners;i[t]===void 0&&(i[t]=[]),i[t].indexOf(e)===-1&&i[t].push(e)}hasEventListener(t,e){if(this._listeners===void 0)return!1;let i=this._listeners;return i[t]!==void 0&&i[t].indexOf(e)!==-1}removeEventListener(t,e){if(this._listeners===void 0)return;let r=this._listeners[t];if(r!==void 0){let s=r.indexOf(e);s!==-1&&r.splice(s,1)}}dispatchEvent(t){if(this._listeners===void 0)return;let i=this._listeners[t.type];if(i!==void 0){t.target=this;let r=i.slice(0);for(let s=0,o=r.length;s<o;s++)r[s].call(this,t);t.target=null}}},ve=[];for(let n=0;n<256;n++)ve[n]=(n<16?"0":"")+n.toString(16);var iu=Math.PI/180,Vu=180/Math.PI;function tn(){let n=Math.random()*4294967295|0,t=Math.random()*4294967295|0,e=Math.random()*4294967295|0,i=Math.random()*4294967295|0;return(ve[n&255]+ve[n>>8&255]+ve[n>>16&255]+ve[n>>24&255]+"-"+ve[t&255]+ve[t>>8&255]+"-"+ve[t>>16&15|64]+ve[t>>24&255]+"-"+ve[e&63|128]+ve[e>>8&255]+"-"+ve[e>>16&255]+ve[e>>24&255]+ve[i&255]+ve[i>>8&255]+ve[i>>16&255]+ve[i>>24&255]).toUpperCase()}function Ie(n,t,e){return Math.max(t,Math.min(e,n))}function eM(n,t){return(n%t+t)%t}function ru(n,t,e){return(1-e)*n+e*t}function ig(n){return(n&n-1)===0&&n!==0}function nM(n){return Math.pow(2,Math.floor(Math.log(n)/Math.LN2))}var K=class{constructor(t=0,e=0){this.x=t,this.y=e}get width(){return this.x}set width(t){this.x=t}get height(){return this.y}set height(t){this.y=t}set(t,e){return this.x=t,this.y=e,this}setScalar(t){return this.x=t,this.y=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y)}copy(t){return this.x=t.x,this.y=t.y,this}add(t,e){return e!==void 0?(console.warn("THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this)}addScalar(t){return this.x+=t,this.y+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this}sub(t,e){return e!==void 0?(console.warn("THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this)}subScalar(t){return this.x-=t,this.y-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this}multiply(t){return this.x*=t.x,this.y*=t.y,this}multiplyScalar(t){return this.x*=t,this.y*=t,this}divide(t){return this.x/=t.x,this.y/=t.y,this}divideScalar(t){return this.multiplyScalar(1/t)}applyMatrix3(t){let e=this.x,i=this.y,r=t.elements;return this.x=r[0]*e+r[3]*i+r[6],this.y=r[1]*e+r[4]*i+r[7],this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this}clampLength(t,e){let i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(t,Math.min(e,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this}negate(){return this.x=-this.x,this.y=-this.y,this}dot(t){return this.x*t.x+this.y*t.y}cross(t){return this.x*t.y-this.y*t.x}lengthSq(){return this.x*this.x+this.y*this.y}length(){return Math.sqrt(this.x*this.x+this.y*this.y)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)}normalize(){return this.divideScalar(this.length()||1)}angle(){return Math.atan2(-this.y,-this.x)+Math.PI}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){let e=this.x-t.x,i=this.y-t.y;return e*e+i*i}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this}equals(t){return t.x===this.x&&t.y===this.y}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t}fromBufferAttribute(t,e,i){return i!==void 0&&console.warn("THREE.Vector2: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this}rotateAround(t,e){let i=Math.cos(e),r=Math.sin(e),s=this.x-t.x,o=this.y-t.y;return this.x=s*i-o*r+t.x,this.y=s*r+o*i+t.y,this}random(){return this.x=Math.random(),this.y=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y}};K.prototype.isVector2=!0;var de=class{constructor(){this.elements=[1,0,0,0,1,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.")}set(t,e,i,r,s,o,a,l,c){let u=this.elements;return u[0]=t,u[1]=r,u[2]=a,u[3]=e,u[4]=s,u[5]=l,u[6]=i,u[7]=o,u[8]=c,this}identity(){return this.set(1,0,0,0,1,0,0,0,1),this}copy(t){let e=this.elements,i=t.elements;return e[0]=i[0],e[1]=i[1],e[2]=i[2],e[3]=i[3],e[4]=i[4],e[5]=i[5],e[6]=i[6],e[7]=i[7],e[8]=i[8],this}extractBasis(t,e,i){return t.setFromMatrix3Column(this,0),e.setFromMatrix3Column(this,1),i.setFromMatrix3Column(this,2),this}setFromMatrix4(t){let e=t.elements;return this.set(e[0],e[4],e[8],e[1],e[5],e[9],e[2],e[6],e[10]),this}multiply(t){return this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,e){let i=t.elements,r=e.elements,s=this.elements,o=i[0],a=i[3],l=i[6],c=i[1],u=i[4],h=i[7],f=i[2],d=i[5],g=i[8],x=r[0],v=r[3],m=r[6],p=r[1],b=r[4],_=r[7],S=r[2],L=r[5],A=r[8];return s[0]=o*x+a*p+l*S,s[3]=o*v+a*b+l*L,s[6]=o*m+a*_+l*A,s[1]=c*x+u*p+h*S,s[4]=c*v+u*b+h*L,s[7]=c*m+u*_+h*A,s[2]=f*x+d*p+g*S,s[5]=f*v+d*b+g*L,s[8]=f*m+d*_+g*A,this}multiplyScalar(t){let e=this.elements;return e[0]*=t,e[3]*=t,e[6]*=t,e[1]*=t,e[4]*=t,e[7]*=t,e[2]*=t,e[5]*=t,e[8]*=t,this}determinant(){let t=this.elements,e=t[0],i=t[1],r=t[2],s=t[3],o=t[4],a=t[5],l=t[6],c=t[7],u=t[8];return e*o*u-e*a*c-i*s*u+i*a*l+r*s*c-r*o*l}invert(){let t=this.elements,e=t[0],i=t[1],r=t[2],s=t[3],o=t[4],a=t[5],l=t[6],c=t[7],u=t[8],h=u*o-a*c,f=a*l-u*s,d=c*s-o*l,g=e*h+i*f+r*d;if(g===0)return this.set(0,0,0,0,0,0,0,0,0);let x=1/g;return t[0]=h*x,t[1]=(r*c-u*i)*x,t[2]=(a*i-r*o)*x,t[3]=f*x,t[4]=(u*e-r*l)*x,t[5]=(r*s-a*e)*x,t[6]=d*x,t[7]=(i*l-c*e)*x,t[8]=(o*e-i*s)*x,this}transpose(){let t,e=this.elements;return t=e[1],e[1]=e[3],e[3]=t,t=e[2],e[2]=e[6],e[6]=t,t=e[5],e[5]=e[7],e[7]=t,this}getNormalMatrix(t){return this.setFromMatrix4(t).invert().transpose()}transposeIntoArray(t){let e=this.elements;return t[0]=e[0],t[1]=e[3],t[2]=e[6],t[3]=e[1],t[4]=e[4],t[5]=e[7],t[6]=e[2],t[7]=e[5],t[8]=e[8],this}setUvTransform(t,e,i,r,s,o,a){let l=Math.cos(s),c=Math.sin(s);return this.set(i*l,i*c,-i*(l*o+c*a)+o+t,-r*c,r*l,-r*(-c*o+l*a)+a+e,0,0,1),this}scale(t,e){let i=this.elements;return i[0]*=t,i[3]*=t,i[6]*=t,i[1]*=e,i[4]*=e,i[7]*=e,this}rotate(t){let e=Math.cos(t),i=Math.sin(t),r=this.elements,s=r[0],o=r[3],a=r[6],l=r[1],c=r[4],u=r[7];return r[0]=e*s+i*l,r[3]=e*o+i*c,r[6]=e*a+i*u,r[1]=-i*s+e*l,r[4]=-i*o+e*c,r[7]=-i*a+e*u,this}translate(t,e){let i=this.elements;return i[0]+=t*i[2],i[3]+=t*i[5],i[6]+=t*i[8],i[1]+=e*i[2],i[4]+=e*i[5],i[7]+=e*i[8],this}equals(t){let e=this.elements,i=t.elements;for(let r=0;r<9;r++)if(e[r]!==i[r])return!1;return!0}fromArray(t,e=0){for(let i=0;i<9;i++)this.elements[i]=t[i+e];return this}toArray(t=[],e=0){let i=this.elements;return t[e]=i[0],t[e+1]=i[1],t[e+2]=i[2],t[e+3]=i[3],t[e+4]=i[4],t[e+5]=i[5],t[e+6]=i[6],t[e+7]=i[7],t[e+8]=i[8],t}clone(){return new this.constructor().fromArray(this.elements)}};de.prototype.isMatrix3=!0;function p0(n){for(let t=n.length-1;t>=0;--t)if(n[t]>65535)return!0;return!1}function ro(n){return document.createElementNS("http://www.w3.org/1999/xhtml",n)}var m0={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074},$e={h:0,s:0,l:0},va={h:0,s:0,l:0};function su(n,t,e){return e<0&&(e+=1),e>1&&(e-=1),e<1/6?n+(t-n)*6*e:e<1/2?t:e<2/3?n+(t-n)*6*(2/3-e):n}function Or(n){return n<.04045?n*.0773993808:Math.pow(n*.9478672986+.0521327014,2.4)}function ou(n){return n<.0031308?n*12.92:1.055*Math.pow(n,.41666)-.055}var ft=class{constructor(t,e,i){return e===void 0&&i===void 0?this.set(t):this.setRGB(t,e,i)}set(t){return t&&t.isColor?this.copy(t):typeof t=="number"?this.setHex(t):typeof t=="string"&&this.setStyle(t),this}setScalar(t){return this.r=t,this.g=t,this.b=t,this}setHex(t){return t=Math.floor(t),this.r=(t>>16&255)/255,this.g=(t>>8&255)/255,this.b=(t&255)/255,this}setRGB(t,e,i){return this.r=t,this.g=e,this.b=i,this}setHSL(t,e,i){if(t=eM(t,1),e=Ie(e,0,1),i=Ie(i,0,1),e===0)this.r=this.g=this.b=i;else{let r=i<=.5?i*(1+e):i+e-i*e,s=2*i-r;this.r=su(s,r,t+1/3),this.g=su(s,r,t),this.b=su(s,r,t-1/3)}return this}setStyle(t){function e(r){r!==void 0&&parseFloat(r)<1&&console.warn("THREE.Color: Alpha component of "+t+" will be ignored.")}let i;if(i=/^((?:rgb|hsl)a?)\(([^\)]*)\)/.exec(t)){let r,s=i[1],o=i[2];switch(s){case"rgb":case"rgba":if(r=/^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(o))return this.r=Math.min(255,parseInt(r[1],10))/255,this.g=Math.min(255,parseInt(r[2],10))/255,this.b=Math.min(255,parseInt(r[3],10))/255,e(r[4]),this;if(r=/^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(o))return this.r=Math.min(100,parseInt(r[1],10))/100,this.g=Math.min(100,parseInt(r[2],10))/100,this.b=Math.min(100,parseInt(r[3],10))/100,e(r[4]),this;break;case"hsl":case"hsla":if(r=/^\s*(\d*\.?\d+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(o)){let a=parseFloat(r[1])/360,l=parseInt(r[2],10)/100,c=parseInt(r[3],10)/100;return e(r[4]),this.setHSL(a,l,c)}break}}else if(i=/^\#([A-Fa-f\d]+)$/.exec(t)){let r=i[1],s=r.length;if(s===3)return this.r=parseInt(r.charAt(0)+r.charAt(0),16)/255,this.g=parseInt(r.charAt(1)+r.charAt(1),16)/255,this.b=parseInt(r.charAt(2)+r.charAt(2),16)/255,this;if(s===6)return this.r=parseInt(r.charAt(0)+r.charAt(1),16)/255,this.g=parseInt(r.charAt(2)+r.charAt(3),16)/255,this.b=parseInt(r.charAt(4)+r.charAt(5),16)/255,this}return t&&t.length>0?this.setColorName(t):this}setColorName(t){let e=m0[t.toLowerCase()];return e!==void 0?this.setHex(e):console.warn("THREE.Color: Unknown color "+t),this}clone(){return new this.constructor(this.r,this.g,this.b)}copy(t){return this.r=t.r,this.g=t.g,this.b=t.b,this}copySRGBToLinear(t){return this.r=Or(t.r),this.g=Or(t.g),this.b=Or(t.b),this}copyLinearToSRGB(t){return this.r=ou(t.r),this.g=ou(t.g),this.b=ou(t.b),this}convertSRGBToLinear(){return this.copySRGBToLinear(this),this}convertLinearToSRGB(){return this.copyLinearToSRGB(this),this}getHex(){return this.r*255<<16^this.g*255<<8^this.b*255<<0}getHexString(){return("000000"+this.getHex().toString(16)).slice(-6)}getHSL(t){let e=this.r,i=this.g,r=this.b,s=Math.max(e,i,r),o=Math.min(e,i,r),a,l,c=(o+s)/2;if(o===s)a=0,l=0;else{let u=s-o;switch(l=c<=.5?u/(s+o):u/(2-s-o),s){case e:a=(i-r)/u+(i<r?6:0);break;case i:a=(r-e)/u+2;break;case r:a=(e-i)/u+4;break}a/=6}return t.h=a,t.s=l,t.l=c,t}getStyle(){return"rgb("+(this.r*255|0)+","+(this.g*255|0)+","+(this.b*255|0)+")"}offsetHSL(t,e,i){return this.getHSL($e),$e.h+=t,$e.s+=e,$e.l+=i,this.setHSL($e.h,$e.s,$e.l),this}add(t){return this.r+=t.r,this.g+=t.g,this.b+=t.b,this}addColors(t,e){return this.r=t.r+e.r,this.g=t.g+e.g,this.b=t.b+e.b,this}addScalar(t){return this.r+=t,this.g+=t,this.b+=t,this}sub(t){return this.r=Math.max(0,this.r-t.r),this.g=Math.max(0,this.g-t.g),this.b=Math.max(0,this.b-t.b),this}multiply(t){return this.r*=t.r,this.g*=t.g,this.b*=t.b,this}multiplyScalar(t){return this.r*=t,this.g*=t,this.b*=t,this}lerp(t,e){return this.r+=(t.r-this.r)*e,this.g+=(t.g-this.g)*e,this.b+=(t.b-this.b)*e,this}lerpColors(t,e,i){return this.r=t.r+(e.r-t.r)*i,this.g=t.g+(e.g-t.g)*i,this.b=t.b+(e.b-t.b)*i,this}lerpHSL(t,e){this.getHSL($e),t.getHSL(va);let i=ru($e.h,va.h,e),r=ru($e.s,va.s,e),s=ru($e.l,va.l,e);return this.setHSL(i,r,s),this}equals(t){return t.r===this.r&&t.g===this.g&&t.b===this.b}fromArray(t,e=0){return this.r=t[e],this.g=t[e+1],this.b=t[e+2],this}toArray(t=[],e=0){return t[e]=this.r,t[e+1]=this.g,t[e+2]=this.b,t}fromBufferAttribute(t,e){return this.r=t.getX(e),this.g=t.getY(e),this.b=t.getZ(e),t.normalized===!0&&(this.r/=255,this.g/=255,this.b/=255),this}toJSON(){return this.getHex()}};ft.NAMES=m0;ft.prototype.isColor=!0;ft.prototype.r=1;ft.prototype.g=1;ft.prototype.b=1;var pr,Nn=class{static getDataURL(t){if(/^data:/i.test(t.src)||typeof HTMLCanvasElement=="undefined")return t.src;let e;if(t instanceof HTMLCanvasElement)e=t;else{pr===void 0&&(pr=ro("canvas")),pr.width=t.width,pr.height=t.height;let i=pr.getContext("2d");t instanceof ImageData?i.putImageData(t,0,0):i.drawImage(t,0,0,t.width,t.height),e=pr}return e.width>2048||e.height>2048?(console.warn("THREE.ImageUtils.getDataURL: Image converted to jpg for performance reasons",t),e.toDataURL("image/jpeg",.6)):e.toDataURL("image/png")}static sRGBToLinear(t){if(typeof HTMLImageElement!="undefined"&&t instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&t instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&t instanceof ImageBitmap){let e=ro("canvas");e.width=t.width,e.height=t.height;let i=e.getContext("2d");i.drawImage(t,0,0,t.width,t.height);let r=i.getImageData(0,0,t.width,t.height),s=r.data;for(let o=0;o<s.length;o++)s[o]=Or(s[o]/255)*255;return i.putImageData(r,0,0),e}else if(t.data){let e=t.data.slice(0);for(let i=0;i<e.length;i++)e instanceof Uint8Array||e instanceof Uint8ClampedArray?e[i]=Math.floor(Or(e[i]/255)*255):e[i]=Or(e[i]);return{data:e,width:t.width,height:t.height}}else return console.warn("THREE.ImageUtils.sRGBToLinear(): Unsupported image type. No color space conversion applied."),t}},iM=0,ae=class extends In{constructor(t=ae.DEFAULT_IMAGE,e=ae.DEFAULT_MAPPING,i=Ve,r=Ve,s=be,o=Ll,a=Re,l=ei,c=1,u=ri){super(),Object.defineProperty(this,"id",{value:iM++}),this.uuid=tn(),this.name="",this.image=t,this.mipmaps=[],this.mapping=e,this.wrapS=i,this.wrapT=r,this.magFilter=s,this.minFilter=o,this.anisotropy=c,this.format=a,this.internalFormat=null,this.type=l,this.offset=new K(0,0),this.repeat=new K(1,1),this.center=new K(0,0),this.rotation=0,this.matrixAutoUpdate=!0,this.matrix=new de,this.generateMipmaps=!0,this.premultiplyAlpha=!1,this.flipY=!0,this.unpackAlignment=4,this.encoding=u,this.userData={},this.version=0,this.onUpdate=null,this.isRenderTargetTexture=!1,this.needsPMREMUpdate=!1}updateMatrix(){this.matrix.setUvTransform(this.offset.x,this.offset.y,this.repeat.x,this.repeat.y,this.rotation,this.center.x,this.center.y)}clone(){return new this.constructor().copy(this)}copy(t){return this.name=t.name,this.image=t.image,this.mipmaps=t.mipmaps.slice(0),this.mapping=t.mapping,this.wrapS=t.wrapS,this.wrapT=t.wrapT,this.magFilter=t.magFilter,this.minFilter=t.minFilter,this.anisotropy=t.anisotropy,this.format=t.format,this.internalFormat=t.internalFormat,this.type=t.type,this.offset.copy(t.offset),this.repeat.copy(t.repeat),this.center.copy(t.center),this.rotation=t.rotation,this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrix.copy(t.matrix),this.generateMipmaps=t.generateMipmaps,this.premultiplyAlpha=t.premultiplyAlpha,this.flipY=t.flipY,this.unpackAlignment=t.unpackAlignment,this.encoding=t.encoding,this.userData=JSON.parse(JSON.stringify(t.userData)),this}toJSON(t){let e=t===void 0||typeof t=="string";if(!e&&t.textures[this.uuid]!==void 0)return t.textures[this.uuid];let i={metadata:{version:4.5,type:"Texture",generator:"Texture.toJSON"},uuid:this.uuid,name:this.name,mapping:this.mapping,repeat:[this.repeat.x,this.repeat.y],offset:[this.offset.x,this.offset.y],center:[this.center.x,this.center.y],rotation:this.rotation,wrap:[this.wrapS,this.wrapT],format:this.format,type:this.type,encoding:this.encoding,minFilter:this.minFilter,magFilter:this.magFilter,anisotropy:this.anisotropy,flipY:this.flipY,premultiplyAlpha:this.premultiplyAlpha,unpackAlignment:this.unpackAlignment};if(this.image!==void 0){let r=this.image;if(r.uuid===void 0&&(r.uuid=tn()),!e&&t.images[r.uuid]===void 0){let s;if(Array.isArray(r)){s=[];for(let o=0,a=r.length;o<a;o++)r[o].isDataTexture?s.push(au(r[o].image)):s.push(au(r[o]))}else s=au(r);t.images[r.uuid]={uuid:r.uuid,url:s}}i.image=r.uuid}return JSON.stringify(this.userData)!=="{}"&&(i.userData=this.userData),e||(t.textures[this.uuid]=i),i}dispose(){this.dispatchEvent({type:"dispose"})}transformUv(t){if(this.mapping!==f0)return t;if(t.applyMatrix3(this.matrix),t.x<0||t.x>1)switch(this.wrapS){case Ou:t.x=t.x-Math.floor(t.x);break;case Ve:t.x=t.x<0?0:1;break;case ku:Math.abs(Math.floor(t.x)%2)===1?t.x=Math.ceil(t.x)-t.x:t.x=t.x-Math.floor(t.x);break}if(t.y<0||t.y>1)switch(this.wrapT){case Ou:t.y=t.y-Math.floor(t.y);break;case Ve:t.y=t.y<0?0:1;break;case ku:Math.abs(Math.floor(t.y)%2)===1?t.y=Math.ceil(t.y)-t.y:t.y=t.y-Math.floor(t.y);break}return this.flipY&&(t.y=1-t.y),t}set needsUpdate(t){t===!0&&this.version++}};ae.DEFAULT_IMAGE=void 0;ae.DEFAULT_MAPPING=f0;ae.prototype.isTexture=!0;function au(n){return typeof HTMLImageElement!="undefined"&&n instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&n instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&n instanceof ImageBitmap?Nn.getDataURL(n):n.data?{data:Array.prototype.slice.call(n.data),width:n.width,height:n.height,type:n.data.constructor.name}:(console.warn("THREE.Texture: Unable to serialize Texture."),{})}var Wt=class{constructor(t=0,e=0,i=0,r=1){this.x=t,this.y=e,this.z=i,this.w=r}get width(){return this.z}set width(t){this.z=t}get height(){return this.w}set height(t){this.w=t}set(t,e,i,r){return this.x=t,this.y=e,this.z=i,this.w=r,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this.w=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setW(t){return this.w=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;case 3:this.w=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;case 3:return this.w;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z,this.w)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this.w=t.w!==void 0?t.w:1,this}add(t,e){return e!==void 0?(console.warn("THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this.w+=t.w,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this.w+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this.z=t.z+e.z,this.w=t.w+e.w,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this.z+=t.z*e,this.w+=t.w*e,this}sub(t,e){return e!==void 0?(console.warn("THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this.w-=t.w,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this.w-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this.z=t.z-e.z,this.w=t.w-e.w,this}multiply(t){return this.x*=t.x,this.y*=t.y,this.z*=t.z,this.w*=t.w,this}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this.w*=t,this}applyMatrix4(t){let e=this.x,i=this.y,r=this.z,s=this.w,o=t.elements;return this.x=o[0]*e+o[4]*i+o[8]*r+o[12]*s,this.y=o[1]*e+o[5]*i+o[9]*r+o[13]*s,this.z=o[2]*e+o[6]*i+o[10]*r+o[14]*s,this.w=o[3]*e+o[7]*i+o[11]*r+o[15]*s,this}divideScalar(t){return this.multiplyScalar(1/t)}setAxisAngleFromQuaternion(t){this.w=2*Math.acos(t.w);let e=Math.sqrt(1-t.w*t.w);return e<1e-4?(this.x=1,this.y=0,this.z=0):(this.x=t.x/e,this.y=t.y/e,this.z=t.z/e),this}setAxisAngleFromRotationMatrix(t){let e,i,r,s,l=t.elements,c=l[0],u=l[4],h=l[8],f=l[1],d=l[5],g=l[9],x=l[2],v=l[6],m=l[10];if(Math.abs(u-f)<.01&&Math.abs(h-x)<.01&&Math.abs(g-v)<.01){if(Math.abs(u+f)<.1&&Math.abs(h+x)<.1&&Math.abs(g+v)<.1&&Math.abs(c+d+m-3)<.1)return this.set(1,0,0,0),this;e=Math.PI;let b=(c+1)/2,_=(d+1)/2,S=(m+1)/2,L=(u+f)/4,A=(h+x)/4,H=(g+v)/4;return b>_&&b>S?b<.01?(i=0,r=.707106781,s=.707106781):(i=Math.sqrt(b),r=L/i,s=A/i):_>S?_<.01?(i=.707106781,r=0,s=.707106781):(r=Math.sqrt(_),i=L/r,s=H/r):S<.01?(i=.707106781,r=.707106781,s=0):(s=Math.sqrt(S),i=A/s,r=H/s),this.set(i,r,s,e),this}let p=Math.sqrt((v-g)*(v-g)+(h-x)*(h-x)+(f-u)*(f-u));return Math.abs(p)<.001&&(p=1),this.x=(v-g)/p,this.y=(h-x)/p,this.z=(f-u)/p,this.w=Math.acos((c+d+m-1)/2),this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this.w=Math.min(this.w,t.w),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this.w=Math.max(this.w,t.w),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this.z=Math.max(t.z,Math.min(e.z,this.z)),this.w=Math.max(t.w,Math.min(e.w,this.w)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this.z=Math.max(t,Math.min(e,this.z)),this.w=Math.max(t,Math.min(e,this.w)),this}clampLength(t,e){let i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(t,Math.min(e,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this.w=Math.floor(this.w),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this.w=Math.ceil(this.w),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this.w=Math.round(this.w),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this.w=this.w<0?Math.ceil(this.w):Math.floor(this.w),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this.w=-this.w,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z+this.w*t.w}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)+Math.abs(this.w)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this.z+=(t.z-this.z)*e,this.w+=(t.w-this.w)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this.z=t.z+(e.z-t.z)*i,this.w=t.w+(e.w-t.w)*i,this}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z&&t.w===this.w}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this.z=t[e+2],this.w=t[e+3],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t[e+2]=this.z,t[e+3]=this.w,t}fromBufferAttribute(t,e,i){return i!==void 0&&console.warn("THREE.Vector4: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this.z=t.getZ(e),this.w=t.getW(e),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this.w=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z,yield this.w}};Wt.prototype.isVector4=!0;var Ne=class extends In{constructor(t,e,i={}){super(),this.width=t,this.height=e,this.depth=1,this.scissor=new Wt(0,0,t,e),this.scissorTest=!1,this.viewport=new Wt(0,0,t,e),this.texture=new ae(void 0,i.mapping,i.wrapS,i.wrapT,i.magFilter,i.minFilter,i.format,i.type,i.anisotropy,i.encoding),this.texture.isRenderTargetTexture=!0,this.texture.image={width:t,height:e,depth:1},this.texture.generateMipmaps=i.generateMipmaps!==void 0?i.generateMipmaps:!1,this.texture.internalFormat=i.internalFormat!==void 0?i.internalFormat:null,this.texture.minFilter=i.minFilter!==void 0?i.minFilter:be,this.depthBuffer=i.depthBuffer!==void 0?i.depthBuffer:!0,this.stencilBuffer=i.stencilBuffer!==void 0?i.stencilBuffer:!1,this.depthTexture=i.depthTexture!==void 0?i.depthTexture:null}setTexture(t){t.image={width:this.width,height:this.height,depth:this.depth},this.texture=t}setSize(t,e,i=1){(this.width!==t||this.height!==e||this.depth!==i)&&(this.width=t,this.height=e,this.depth=i,this.texture.image.width=t,this.texture.image.height=e,this.texture.image.depth=i,this.dispose()),this.viewport.set(0,0,t,e),this.scissor.set(0,0,t,e)}clone(){return new this.constructor().copy(this)}copy(t){return this.width=t.width,this.height=t.height,this.depth=t.depth,this.viewport.copy(t.viewport),this.texture=t.texture.clone(),this.texture.image=Object.assign({},t.texture.image),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this}dispose(){this.dispatchEvent({type:"dispose"})}};Ne.prototype.isWebGLRenderTarget=!0;var Gu=class extends Ne{constructor(t,e,i){super(t,e);let r=this.texture;this.texture=[];for(let s=0;s<i;s++)this.texture[s]=r.clone()}setSize(t,e,i=1){if(this.width!==t||this.height!==e||this.depth!==i){this.width=t,this.height=e,this.depth=i;for(let r=0,s=this.texture.length;r<s;r++)this.texture[r].image.width=t,this.texture[r].image.height=e,this.texture[r].image.depth=i;this.dispose()}return this.viewport.set(0,0,t,e),this.scissor.set(0,0,t,e),this}copy(t){this.dispose(),this.width=t.width,this.height=t.height,this.depth=t.depth,this.viewport.set(0,0,this.width,this.height),this.scissor.set(0,0,this.width,this.height),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this.texture.length=0;for(let e=0,i=t.texture.length;e<i;e++)this.texture[e]=t.texture[e].clone();return this}};Gu.prototype.isWebGLMultipleRenderTargets=!0;var so=class extends Ne{constructor(t,e,i={}){super(t,e,i),this.samples=4,this.ignoreDepthForMultisampleCopy=i.ignoreDepth!==void 0?i.ignoreDepth:!0,this.useRenderToTexture=i.useRenderToTexture!==void 0?i.useRenderToTexture:!1,this.useRenderbuffer=this.useRenderToTexture===!1}copy(t){return super.copy.call(this,t),this.samples=t.samples,this.useRenderToTexture=t.useRenderToTexture,this.useRenderbuffer=t.useRenderbuffer,this}};so.prototype.isWebGLMultisampleRenderTarget=!0;var Ee=class{constructor(t=0,e=0,i=0,r=1){this._x=t,this._y=e,this._z=i,this._w=r}static slerp(t,e,i,r){return console.warn("THREE.Quaternion: Static .slerp() has been deprecated. Use qm.slerpQuaternions( qa, qb, t ) instead."),i.slerpQuaternions(t,e,r)}static slerpFlat(t,e,i,r,s,o,a){let l=i[r+0],c=i[r+1],u=i[r+2],h=i[r+3],f=s[o+0],d=s[o+1],g=s[o+2],x=s[o+3];if(a===0){t[e+0]=l,t[e+1]=c,t[e+2]=u,t[e+3]=h;return}if(a===1){t[e+0]=f,t[e+1]=d,t[e+2]=g,t[e+3]=x;return}if(h!==x||l!==f||c!==d||u!==g){let v=1-a,m=l*f+c*d+u*g+h*x,p=m>=0?1:-1,b=1-m*m;if(b>Number.EPSILON){let S=Math.sqrt(b),L=Math.atan2(S,m*p);v=Math.sin(v*L)/S,a=Math.sin(a*L)/S}let _=a*p;if(l=l*v+f*_,c=c*v+d*_,u=u*v+g*_,h=h*v+x*_,v===1-a){let S=1/Math.sqrt(l*l+c*c+u*u+h*h);l*=S,c*=S,u*=S,h*=S}}t[e]=l,t[e+1]=c,t[e+2]=u,t[e+3]=h}static multiplyQuaternionsFlat(t,e,i,r,s,o){let a=i[r],l=i[r+1],c=i[r+2],u=i[r+3],h=s[o],f=s[o+1],d=s[o+2],g=s[o+3];return t[e]=a*g+u*h+l*d-c*f,t[e+1]=l*g+u*f+c*h-a*d,t[e+2]=c*g+u*d+a*f-l*h,t[e+3]=u*g-a*h-l*f-c*d,t}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get w(){return this._w}set w(t){this._w=t,this._onChangeCallback()}set(t,e,i,r){return this._x=t,this._y=e,this._z=i,this._w=r,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._w)}copy(t){return this._x=t.x,this._y=t.y,this._z=t.z,this._w=t.w,this._onChangeCallback(),this}setFromEuler(t,e){if(!(t&&t.isEuler))throw new Error("THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.");let i=t._x,r=t._y,s=t._z,o=t._order,a=Math.cos,l=Math.sin,c=a(i/2),u=a(r/2),h=a(s/2),f=l(i/2),d=l(r/2),g=l(s/2);switch(o){case"XYZ":this._x=f*u*h+c*d*g,this._y=c*d*h-f*u*g,this._z=c*u*g+f*d*h,this._w=c*u*h-f*d*g;break;case"YXZ":this._x=f*u*h+c*d*g,this._y=c*d*h-f*u*g,this._z=c*u*g-f*d*h,this._w=c*u*h+f*d*g;break;case"ZXY":this._x=f*u*h-c*d*g,this._y=c*d*h+f*u*g,this._z=c*u*g+f*d*h,this._w=c*u*h-f*d*g;break;case"ZYX":this._x=f*u*h-c*d*g,this._y=c*d*h+f*u*g,this._z=c*u*g-f*d*h,this._w=c*u*h+f*d*g;break;case"YZX":this._x=f*u*h+c*d*g,this._y=c*d*h+f*u*g,this._z=c*u*g-f*d*h,this._w=c*u*h-f*d*g;break;case"XZY":this._x=f*u*h-c*d*g,this._y=c*d*h-f*u*g,this._z=c*u*g+f*d*h,this._w=c*u*h+f*d*g;break;default:console.warn("THREE.Quaternion: .setFromEuler() encountered an unknown order: "+o)}return e!==!1&&this._onChangeCallback(),this}setFromAxisAngle(t,e){let i=e/2,r=Math.sin(i);return this._x=t.x*r,this._y=t.y*r,this._z=t.z*r,this._w=Math.cos(i),this._onChangeCallback(),this}setFromRotationMatrix(t){let e=t.elements,i=e[0],r=e[4],s=e[8],o=e[1],a=e[5],l=e[9],c=e[2],u=e[6],h=e[10],f=i+a+h;if(f>0){let d=.5/Math.sqrt(f+1);this._w=.25/d,this._x=(u-l)*d,this._y=(s-c)*d,this._z=(o-r)*d}else if(i>a&&i>h){let d=2*Math.sqrt(1+i-a-h);this._w=(u-l)/d,this._x=.25*d,this._y=(r+o)/d,this._z=(s+c)/d}else if(a>h){let d=2*Math.sqrt(1+a-i-h);this._w=(s-c)/d,this._x=(r+o)/d,this._y=.25*d,this._z=(l+u)/d}else{let d=2*Math.sqrt(1+h-i-a);this._w=(o-r)/d,this._x=(s+c)/d,this._y=(l+u)/d,this._z=.25*d}return this._onChangeCallback(),this}setFromUnitVectors(t,e){let i=t.dot(e)+1;return i<Number.EPSILON?(i=0,Math.abs(t.x)>Math.abs(t.z)?(this._x=-t.y,this._y=t.x,this._z=0,this._w=i):(this._x=0,this._y=-t.z,this._z=t.y,this._w=i)):(this._x=t.y*e.z-t.z*e.y,this._y=t.z*e.x-t.x*e.z,this._z=t.x*e.y-t.y*e.x,this._w=i),this.normalize()}angleTo(t){return 2*Math.acos(Math.abs(Ie(this.dot(t),-1,1)))}rotateTowards(t,e){let i=this.angleTo(t);if(i===0)return this;let r=Math.min(1,e/i);return this.slerp(t,r),this}identity(){return this.set(0,0,0,1)}invert(){return this.conjugate()}conjugate(){return this._x*=-1,this._y*=-1,this._z*=-1,this._onChangeCallback(),this}dot(t){return this._x*t._x+this._y*t._y+this._z*t._z+this._w*t._w}lengthSq(){return this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w}length(){return Math.sqrt(this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w)}normalize(){let t=this.length();return t===0?(this._x=0,this._y=0,this._z=0,this._w=1):(t=1/t,this._x=this._x*t,this._y=this._y*t,this._z=this._z*t,this._w=this._w*t),this._onChangeCallback(),this}multiply(t,e){return e!==void 0?(console.warn("THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead."),this.multiplyQuaternions(t,e)):this.multiplyQuaternions(this,t)}premultiply(t){return this.multiplyQuaternions(t,this)}multiplyQuaternions(t,e){let i=t._x,r=t._y,s=t._z,o=t._w,a=e._x,l=e._y,c=e._z,u=e._w;return this._x=i*u+o*a+r*c-s*l,this._y=r*u+o*l+s*a-i*c,this._z=s*u+o*c+i*l-r*a,this._w=o*u-i*a-r*l-s*c,this._onChangeCallback(),this}slerp(t,e){if(e===0)return this;if(e===1)return this.copy(t);let i=this._x,r=this._y,s=this._z,o=this._w,a=o*t._w+i*t._x+r*t._y+s*t._z;if(a<0?(this._w=-t._w,this._x=-t._x,this._y=-t._y,this._z=-t._z,a=-a):this.copy(t),a>=1)return this._w=o,this._x=i,this._y=r,this._z=s,this;let l=1-a*a;if(l<=Number.EPSILON){let d=1-e;return this._w=d*o+e*this._w,this._x=d*i+e*this._x,this._y=d*r+e*this._y,this._z=d*s+e*this._z,this.normalize(),this._onChangeCallback(),this}let c=Math.sqrt(l),u=Math.atan2(c,a),h=Math.sin((1-e)*u)/c,f=Math.sin(e*u)/c;return this._w=o*h+this._w*f,this._x=i*h+this._x*f,this._y=r*h+this._y*f,this._z=s*h+this._z*f,this._onChangeCallback(),this}slerpQuaternions(t,e,i){return this.copy(t).slerp(e,i)}random(){let t=Math.random(),e=Math.sqrt(1-t),i=Math.sqrt(t),r=2*Math.PI*Math.random(),s=2*Math.PI*Math.random();return this.set(e*Math.cos(r),i*Math.sin(s),i*Math.cos(s),e*Math.sin(r))}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._w===this._w}fromArray(t,e=0){return this._x=t[e],this._y=t[e+1],this._z=t[e+2],this._w=t[e+3],this._onChangeCallback(),this}toArray(t=[],e=0){return t[e]=this._x,t[e+1]=this._y,t[e+2]=this._z,t[e+3]=this._w,t}fromBufferAttribute(t,e){return this._x=t.getX(e),this._y=t.getY(e),this._z=t.getZ(e),this._w=t.getW(e),this}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}};Ee.prototype.isQuaternion=!0;var T=class{constructor(t=0,e=0,i=0){this.x=t,this.y=e,this.z=i}set(t,e,i){return i===void 0&&(i=this.z),this.x=t,this.y=e,this.z=i,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this}add(t,e){return e!==void 0?(console.warn("THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this.z=t.z+e.z,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this.z+=t.z*e,this}sub(t,e){return e!==void 0?(console.warn("THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this.z=t.z-e.z,this}multiply(t,e){return e!==void 0?(console.warn("THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead."),this.multiplyVectors(t,e)):(this.x*=t.x,this.y*=t.y,this.z*=t.z,this)}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this}multiplyVectors(t,e){return this.x=t.x*e.x,this.y=t.y*e.y,this.z=t.z*e.z,this}applyEuler(t){return t&&t.isEuler||console.error("THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order."),this.applyQuaternion(rg.setFromEuler(t))}applyAxisAngle(t,e){return this.applyQuaternion(rg.setFromAxisAngle(t,e))}applyMatrix3(t){let e=this.x,i=this.y,r=this.z,s=t.elements;return this.x=s[0]*e+s[3]*i+s[6]*r,this.y=s[1]*e+s[4]*i+s[7]*r,this.z=s[2]*e+s[5]*i+s[8]*r,this}applyNormalMatrix(t){return this.applyMatrix3(t).normalize()}applyMatrix4(t){let e=this.x,i=this.y,r=this.z,s=t.elements,o=1/(s[3]*e+s[7]*i+s[11]*r+s[15]);return this.x=(s[0]*e+s[4]*i+s[8]*r+s[12])*o,this.y=(s[1]*e+s[5]*i+s[9]*r+s[13])*o,this.z=(s[2]*e+s[6]*i+s[10]*r+s[14])*o,this}applyQuaternion(t){let e=this.x,i=this.y,r=this.z,s=t.x,o=t.y,a=t.z,l=t.w,c=l*e+o*r-a*i,u=l*i+a*e-s*r,h=l*r+s*i-o*e,f=-s*e-o*i-a*r;return this.x=c*l+f*-s+u*-a-h*-o,this.y=u*l+f*-o+h*-s-c*-a,this.z=h*l+f*-a+c*-o-u*-s,this}project(t){return this.applyMatrix4(t.matrixWorldInverse).applyMatrix4(t.projectionMatrix)}unproject(t){return this.applyMatrix4(t.projectionMatrixInverse).applyMatrix4(t.matrixWorld)}transformDirection(t){let e=this.x,i=this.y,r=this.z,s=t.elements;return this.x=s[0]*e+s[4]*i+s[8]*r,this.y=s[1]*e+s[5]*i+s[9]*r,this.z=s[2]*e+s[6]*i+s[10]*r,this.normalize()}divide(t){return this.x/=t.x,this.y/=t.y,this.z/=t.z,this}divideScalar(t){return this.multiplyScalar(1/t)}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this.z=Math.max(t.z,Math.min(e.z,this.z)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this.z=Math.max(t,Math.min(e,this.z)),this}clampLength(t,e){let i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(t,Math.min(e,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this.z+=(t.z-this.z)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this.z=t.z+(e.z-t.z)*i,this}cross(t,e){return e!==void 0?(console.warn("THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead."),this.crossVectors(t,e)):this.crossVectors(this,t)}crossVectors(t,e){let i=t.x,r=t.y,s=t.z,o=e.x,a=e.y,l=e.z;return this.x=r*l-s*a,this.y=s*o-i*l,this.z=i*a-r*o,this}projectOnVector(t){let e=t.lengthSq();if(e===0)return this.set(0,0,0);let i=t.dot(this)/e;return this.copy(t).multiplyScalar(i)}projectOnPlane(t){return lu.copy(this).projectOnVector(t),this.sub(lu)}reflect(t){return this.sub(lu.copy(t).multiplyScalar(2*this.dot(t)))}angleTo(t){let e=Math.sqrt(this.lengthSq()*t.lengthSq());if(e===0)return Math.PI/2;let i=this.dot(t)/e;return Math.acos(Ie(i,-1,1))}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){let e=this.x-t.x,i=this.y-t.y,r=this.z-t.z;return e*e+i*i+r*r}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)+Math.abs(this.z-t.z)}setFromSpherical(t){return this.setFromSphericalCoords(t.radius,t.phi,t.theta)}setFromSphericalCoords(t,e,i){let r=Math.sin(e)*t;return this.x=r*Math.sin(i),this.y=Math.cos(e)*t,this.z=r*Math.cos(i),this}setFromCylindrical(t){return this.setFromCylindricalCoords(t.radius,t.theta,t.y)}setFromCylindricalCoords(t,e,i){return this.x=t*Math.sin(e),this.y=i,this.z=t*Math.cos(e),this}setFromMatrixPosition(t){let e=t.elements;return this.x=e[12],this.y=e[13],this.z=e[14],this}setFromMatrixScale(t){let e=this.setFromMatrixColumn(t,0).length(),i=this.setFromMatrixColumn(t,1).length(),r=this.setFromMatrixColumn(t,2).length();return this.x=e,this.y=i,this.z=r,this}setFromMatrixColumn(t,e){return this.fromArray(t.elements,e*4)}setFromMatrix3Column(t,e){return this.fromArray(t.elements,e*3)}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this.z=t[e+2],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t[e+2]=this.z,t}fromBufferAttribute(t,e,i){return i!==void 0&&console.warn("THREE.Vector3: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this.z=t.getZ(e),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this}randomDirection(){let t=(Math.random()-.5)*2,e=Math.random()*Math.PI*2,i=Math.sqrt(1-cf(t,2));return this.x=i*Math.cos(e),this.y=i*Math.sin(e),this.z=t,this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z}};T.prototype.isVector3=!0;var lu=new T,rg=new Ee,Ge=class{constructor(t=new T(1/0,1/0,1/0),e=new T(-1/0,-1/0,-1/0)){this.min=t,this.max=e}set(t,e){return this.min.copy(t),this.max.copy(e),this}setFromArray(t){let e=1/0,i=1/0,r=1/0,s=-1/0,o=-1/0,a=-1/0;for(let l=0,c=t.length;l<c;l+=3){let u=t[l],h=t[l+1],f=t[l+2];u<e&&(e=u),h<i&&(i=h),f<r&&(r=f),u>s&&(s=u),h>o&&(o=h),f>a&&(a=f)}return this.min.set(e,i,r),this.max.set(s,o,a),this}setFromBufferAttribute(t){let e=1/0,i=1/0,r=1/0,s=-1/0,o=-1/0,a=-1/0;for(let l=0,c=t.count;l<c;l++){let u=t.getX(l),h=t.getY(l),f=t.getZ(l);u<e&&(e=u),h<i&&(i=h),f<r&&(r=f),u>s&&(s=u),h>o&&(o=h),f>a&&(a=f)}return this.min.set(e,i,r),this.max.set(s,o,a),this}setFromPoints(t){this.makeEmpty();for(let e=0,i=t.length;e<i;e++)this.expandByPoint(t[e]);return this}setFromCenterAndSize(t,e){let i=Ii.copy(e).multiplyScalar(.5);return this.min.copy(t).sub(i),this.max.copy(t).add(i),this}setFromObject(t,e=!1){return this.makeEmpty(),this.expandByObject(t,e)}clone(){return new this.constructor().copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=this.min.z=1/0,this.max.x=this.max.y=this.max.z=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y||this.max.z<this.min.z}getCenter(t){return this.isEmpty()?t.set(0,0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return this.isEmpty()?t.set(0,0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}expandByObject(t,e=!1){t.updateWorldMatrix(!1,!1);let i=t.geometry;if(i!==void 0)if(e&&i.attributes!=null&&i.attributes.position!==void 0){let s=i.attributes.position;for(let o=0,a=s.count;o<a;o++)Ii.fromBufferAttribute(s,o).applyMatrix4(t.matrixWorld),this.expandByPoint(Ii)}else i.boundingBox===null&&i.computeBoundingBox(),cu.copy(i.boundingBox),cu.applyMatrix4(t.matrixWorld),this.union(cu);let r=t.children;for(let s=0,o=r.length;s<o;s++)this.expandByObject(r[s],e);return this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y||t.z<this.min.z||t.z>this.max.z)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y&&this.min.z<=t.min.z&&t.max.z<=this.max.z}getParameter(t,e){return e.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y),(t.z-this.min.z)/(this.max.z-this.min.z))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y||t.max.z<this.min.z||t.min.z>this.max.z)}intersectsSphere(t){return this.clampPoint(t.center,Ii),Ii.distanceToSquared(t.center)<=t.radius*t.radius}intersectsPlane(t){let e,i;return t.normal.x>0?(e=t.normal.x*this.min.x,i=t.normal.x*this.max.x):(e=t.normal.x*this.max.x,i=t.normal.x*this.min.x),t.normal.y>0?(e+=t.normal.y*this.min.y,i+=t.normal.y*this.max.y):(e+=t.normal.y*this.max.y,i+=t.normal.y*this.min.y),t.normal.z>0?(e+=t.normal.z*this.min.z,i+=t.normal.z*this.max.z):(e+=t.normal.z*this.max.z,i+=t.normal.z*this.min.z),e<=-t.constant&&i>=-t.constant}intersectsTriangle(t){if(this.isEmpty())return!1;this.getCenter(ks),_a.subVectors(this.max,ks),mr.subVectors(t.a,ks),gr.subVectors(t.b,ks),xr.subVectors(t.c,ks),qn.subVectors(gr,mr),Xn.subVectors(xr,gr),Ni.subVectors(mr,xr);let e=[0,-qn.z,qn.y,0,-Xn.z,Xn.y,0,-Ni.z,Ni.y,qn.z,0,-qn.x,Xn.z,0,-Xn.x,Ni.z,0,-Ni.x,-qn.y,qn.x,0,-Xn.y,Xn.x,0,-Ni.y,Ni.x,0];return!uu(e,mr,gr,xr,_a)||(e=[1,0,0,0,1,0,0,0,1],!uu(e,mr,gr,xr,_a))?!1:(wa.crossVectors(qn,Xn),e=[wa.x,wa.y,wa.z],uu(e,mr,gr,xr,_a))}clampPoint(t,e){return e.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return Ii.copy(t).clamp(this.min,this.max).sub(t).length()}getBoundingSphere(t){return this.getCenter(t.center),t.radius=this.getSize(Ii).length()*.5,t}intersect(t){return this.min.max(t.min),this.max.min(t.max),this.isEmpty()&&this.makeEmpty(),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}applyMatrix4(t){return this.isEmpty()?this:(An[0].set(this.min.x,this.min.y,this.min.z).applyMatrix4(t),An[1].set(this.min.x,this.min.y,this.max.z).applyMatrix4(t),An[2].set(this.min.x,this.max.y,this.min.z).applyMatrix4(t),An[3].set(this.min.x,this.max.y,this.max.z).applyMatrix4(t),An[4].set(this.max.x,this.min.y,this.min.z).applyMatrix4(t),An[5].set(this.max.x,this.min.y,this.max.z).applyMatrix4(t),An[6].set(this.max.x,this.max.y,this.min.z).applyMatrix4(t),An[7].set(this.max.x,this.max.y,this.max.z).applyMatrix4(t),this.setFromPoints(An),this)}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}};Ge.prototype.isBox3=!0;var An=[new T,new T,new T,new T,new T,new T,new T,new T],Ii=new T,cu=new Ge,mr=new T,gr=new T,xr=new T,qn=new T,Xn=new T,Ni=new T,ks=new T,_a=new T,wa=new T,Fi=new T;function uu(n,t,e,i,r){for(let s=0,o=n.length-3;s<=o;s+=3){Fi.fromArray(n,s);let a=r.x*Math.abs(Fi.x)+r.y*Math.abs(Fi.y)+r.z*Math.abs(Fi.z),l=t.dot(Fi),c=e.dot(Fi),u=i.dot(Fi);if(Math.max(-Math.max(l,c,u),Math.min(l,c,u))>a)return!1}return!0}var rM=new Ge,sg=new T,Ma=new T,hu=new T,si=class{constructor(t=new T,e=-1){this.center=t,this.radius=e}set(t,e){return this.center.copy(t),this.radius=e,this}setFromPoints(t,e){let i=this.center;e!==void 0?i.copy(e):rM.setFromPoints(t).getCenter(i);let r=0;for(let s=0,o=t.length;s<o;s++)r=Math.max(r,i.distanceToSquared(t[s]));return this.radius=Math.sqrt(r),this}copy(t){return this.center.copy(t.center),this.radius=t.radius,this}isEmpty(){return this.radius<0}makeEmpty(){return this.center.set(0,0,0),this.radius=-1,this}containsPoint(t){return t.distanceToSquared(this.center)<=this.radius*this.radius}distanceToPoint(t){return t.distanceTo(this.center)-this.radius}intersectsSphere(t){let e=this.radius+t.radius;return t.center.distanceToSquared(this.center)<=e*e}intersectsBox(t){return t.intersectsSphere(this)}intersectsPlane(t){return Math.abs(t.distanceToPoint(this.center))<=this.radius}clampPoint(t,e){let i=this.center.distanceToSquared(t);return e.copy(t),i>this.radius*this.radius&&(e.sub(this.center).normalize(),e.multiplyScalar(this.radius).add(this.center)),e}getBoundingBox(t){return this.isEmpty()?(t.makeEmpty(),t):(t.set(this.center,this.center),t.expandByScalar(this.radius),t)}applyMatrix4(t){return this.center.applyMatrix4(t),this.radius=this.radius*t.getMaxScaleOnAxis(),this}translate(t){return this.center.add(t),this}expandByPoint(t){hu.subVectors(t,this.center);let e=hu.lengthSq();if(e>this.radius*this.radius){let i=Math.sqrt(e),r=(i-this.radius)*.5;this.center.add(hu.multiplyScalar(r/i)),this.radius+=r}return this}union(t){return this.center.equals(t.center)===!0?Ma.set(0,0,1).multiplyScalar(t.radius):Ma.subVectors(t.center,this.center).normalize().multiplyScalar(t.radius),this.expandByPoint(sg.copy(t.center).add(Ma)),this.expandByPoint(sg.copy(t.center).sub(Ma)),this}equals(t){return t.center.equals(this.center)&&t.radius===this.radius}clone(){return new this.constructor().copy(this)}},Cn=new T,fu=new T,ba=new T,Yn=new T,du=new T,Sa=new T,pu=new T,oi=class{constructor(t=new T,e=new T(0,0,-1)){this.origin=t,this.direction=e}set(t,e){return this.origin.copy(t),this.direction.copy(e),this}copy(t){return this.origin.copy(t.origin),this.direction.copy(t.direction),this}at(t,e){return e.copy(this.direction).multiplyScalar(t).add(this.origin)}lookAt(t){return this.direction.copy(t).sub(this.origin).normalize(),this}recast(t){return this.origin.copy(this.at(t,Cn)),this}closestPointToPoint(t,e){e.subVectors(t,this.origin);let i=e.dot(this.direction);return i<0?e.copy(this.origin):e.copy(this.direction).multiplyScalar(i).add(this.origin)}distanceToPoint(t){return Math.sqrt(this.distanceSqToPoint(t))}distanceSqToPoint(t){let e=Cn.subVectors(t,this.origin).dot(this.direction);return e<0?this.origin.distanceToSquared(t):(Cn.copy(this.direction).multiplyScalar(e).add(this.origin),Cn.distanceToSquared(t))}distanceSqToSegment(t,e,i,r){fu.copy(t).add(e).multiplyScalar(.5),ba.copy(e).sub(t).normalize(),Yn.copy(this.origin).sub(fu);let s=t.distanceTo(e)*.5,o=-this.direction.dot(ba),a=Yn.dot(this.direction),l=-Yn.dot(ba),c=Yn.lengthSq(),u=Math.abs(1-o*o),h,f,d,g;if(u>0)if(h=o*l-a,f=o*a-l,g=s*u,h>=0)if(f>=-g)if(f<=g){let x=1/u;h*=x,f*=x,d=h*(h+o*f+2*a)+f*(o*h+f+2*l)+c}else f=s,h=Math.max(0,-(o*f+a)),d=-h*h+f*(f+2*l)+c;else f=-s,h=Math.max(0,-(o*f+a)),d=-h*h+f*(f+2*l)+c;else f<=-g?(h=Math.max(0,-(-o*s+a)),f=h>0?-s:Math.min(Math.max(-s,-l),s),d=-h*h+f*(f+2*l)+c):f<=g?(h=0,f=Math.min(Math.max(-s,-l),s),d=f*(f+2*l)+c):(h=Math.max(0,-(o*s+a)),f=h>0?s:Math.min(Math.max(-s,-l),s),d=-h*h+f*(f+2*l)+c);else f=o>0?-s:s,h=Math.max(0,-(o*f+a)),d=-h*h+f*(f+2*l)+c;return i&&i.copy(this.direction).multiplyScalar(h).add(this.origin),r&&r.copy(ba).multiplyScalar(f).add(fu),d}intersectSphere(t,e){Cn.subVectors(t.center,this.origin);let i=Cn.dot(this.direction),r=Cn.dot(Cn)-i*i,s=t.radius*t.radius;if(r>s)return null;let o=Math.sqrt(s-r),a=i-o,l=i+o;return a<0&&l<0?null:a<0?this.at(l,e):this.at(a,e)}intersectsSphere(t){return this.distanceSqToPoint(t.center)<=t.radius*t.radius}distanceToPlane(t){let e=t.normal.dot(this.direction);if(e===0)return t.distanceToPoint(this.origin)===0?0:null;let i=-(this.origin.dot(t.normal)+t.constant)/e;return i>=0?i:null}intersectPlane(t,e){let i=this.distanceToPlane(t);return i===null?null:this.at(i,e)}intersectsPlane(t){let e=t.distanceToPoint(this.origin);return e===0||t.normal.dot(this.direction)*e<0}intersectBox(t,e){let i,r,s,o,a,l,c=1/this.direction.x,u=1/this.direction.y,h=1/this.direction.z,f=this.origin;return c>=0?(i=(t.min.x-f.x)*c,r=(t.max.x-f.x)*c):(i=(t.max.x-f.x)*c,r=(t.min.x-f.x)*c),u>=0?(s=(t.min.y-f.y)*u,o=(t.max.y-f.y)*u):(s=(t.max.y-f.y)*u,o=(t.min.y-f.y)*u),i>o||s>r||((s>i||i!==i)&&(i=s),(o<r||r!==r)&&(r=o),h>=0?(a=(t.min.z-f.z)*h,l=(t.max.z-f.z)*h):(a=(t.max.z-f.z)*h,l=(t.min.z-f.z)*h),i>l||a>r)||((a>i||i!==i)&&(i=a),(l<r||r!==r)&&(r=l),r<0)?null:this.at(i>=0?i:r,e)}intersectsBox(t){return this.intersectBox(t,Cn)!==null}intersectTriangle(t,e,i,r,s){du.subVectors(e,t),Sa.subVectors(i,t),pu.crossVectors(du,Sa);let o=this.direction.dot(pu),a;if(o>0){if(r)return null;a=1}else if(o<0)a=-1,o=-o;else return null;Yn.subVectors(this.origin,t);let l=a*this.direction.dot(Sa.crossVectors(Yn,Sa));if(l<0)return null;let c=a*this.direction.dot(du.cross(Yn));if(c<0||l+c>o)return null;let u=-a*Yn.dot(pu);return u<0?null:this.at(u/o,s)}applyMatrix4(t){return this.origin.applyMatrix4(t),this.direction.transformDirection(t),this}equals(t){return t.origin.equals(this.origin)&&t.direction.equals(this.direction)}clone(){return new this.constructor().copy(this)}},wt=class{constructor(){this.elements=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.")}set(t,e,i,r,s,o,a,l,c,u,h,f,d,g,x,v){let m=this.elements;return m[0]=t,m[4]=e,m[8]=i,m[12]=r,m[1]=s,m[5]=o,m[9]=a,m[13]=l,m[2]=c,m[6]=u,m[10]=h,m[14]=f,m[3]=d,m[7]=g,m[11]=x,m[15]=v,this}identity(){return this.set(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1),this}clone(){return new wt().fromArray(this.elements)}copy(t){let e=this.elements,i=t.elements;return e[0]=i[0],e[1]=i[1],e[2]=i[2],e[3]=i[3],e[4]=i[4],e[5]=i[5],e[6]=i[6],e[7]=i[7],e[8]=i[8],e[9]=i[9],e[10]=i[10],e[11]=i[11],e[12]=i[12],e[13]=i[13],e[14]=i[14],e[15]=i[15],this}copyPosition(t){let e=this.elements,i=t.elements;return e[12]=i[12],e[13]=i[13],e[14]=i[14],this}setFromMatrix3(t){let e=t.elements;return this.set(e[0],e[3],e[6],0,e[1],e[4],e[7],0,e[2],e[5],e[8],0,0,0,0,1),this}extractBasis(t,e,i){return t.setFromMatrixColumn(this,0),e.setFromMatrixColumn(this,1),i.setFromMatrixColumn(this,2),this}makeBasis(t,e,i){return this.set(t.x,e.x,i.x,0,t.y,e.y,i.y,0,t.z,e.z,i.z,0,0,0,0,1),this}extractRotation(t){let e=this.elements,i=t.elements,r=1/yr.setFromMatrixColumn(t,0).length(),s=1/yr.setFromMatrixColumn(t,1).length(),o=1/yr.setFromMatrixColumn(t,2).length();return e[0]=i[0]*r,e[1]=i[1]*r,e[2]=i[2]*r,e[3]=0,e[4]=i[4]*s,e[5]=i[5]*s,e[6]=i[6]*s,e[7]=0,e[8]=i[8]*o,e[9]=i[9]*o,e[10]=i[10]*o,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,this}makeRotationFromEuler(t){t&&t.isEuler||console.error("THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.");let e=this.elements,i=t.x,r=t.y,s=t.z,o=Math.cos(i),a=Math.sin(i),l=Math.cos(r),c=Math.sin(r),u=Math.cos(s),h=Math.sin(s);if(t.order==="XYZ"){let f=o*u,d=o*h,g=a*u,x=a*h;e[0]=l*u,e[4]=-l*h,e[8]=c,e[1]=d+g*c,e[5]=f-x*c,e[9]=-a*l,e[2]=x-f*c,e[6]=g+d*c,e[10]=o*l}else if(t.order==="YXZ"){let f=l*u,d=l*h,g=c*u,x=c*h;e[0]=f+x*a,e[4]=g*a-d,e[8]=o*c,e[1]=o*h,e[5]=o*u,e[9]=-a,e[2]=d*a-g,e[6]=x+f*a,e[10]=o*l}else if(t.order==="ZXY"){let f=l*u,d=l*h,g=c*u,x=c*h;e[0]=f-x*a,e[4]=-o*h,e[8]=g+d*a,e[1]=d+g*a,e[5]=o*u,e[9]=x-f*a,e[2]=-o*c,e[6]=a,e[10]=o*l}else if(t.order==="ZYX"){let f=o*u,d=o*h,g=a*u,x=a*h;e[0]=l*u,e[4]=g*c-d,e[8]=f*c+x,e[1]=l*h,e[5]=x*c+f,e[9]=d*c-g,e[2]=-c,e[6]=a*l,e[10]=o*l}else if(t.order==="YZX"){let f=o*l,d=o*c,g=a*l,x=a*c;e[0]=l*u,e[4]=x-f*h,e[8]=g*h+d,e[1]=h,e[5]=o*u,e[9]=-a*u,e[2]=-c*u,e[6]=d*h+g,e[10]=f-x*h}else if(t.order==="XZY"){let f=o*l,d=o*c,g=a*l,x=a*c;e[0]=l*u,e[4]=-h,e[8]=c*u,e[1]=f*h+x,e[5]=o*u,e[9]=d*h-g,e[2]=g*h-d,e[6]=a*u,e[10]=x*h+f}return e[3]=0,e[7]=0,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,this}makeRotationFromQuaternion(t){return this.compose(sM,t,oM)}lookAt(t,e,i){let r=this.elements;return ke.subVectors(t,e),ke.lengthSq()===0&&(ke.z=1),ke.normalize(),Zn.crossVectors(i,ke),Zn.lengthSq()===0&&(Math.abs(i.z)===1?ke.x+=1e-4:ke.z+=1e-4,ke.normalize(),Zn.crossVectors(i,ke)),Zn.normalize(),Ea.crossVectors(ke,Zn),r[0]=Zn.x,r[4]=Ea.x,r[8]=ke.x,r[1]=Zn.y,r[5]=Ea.y,r[9]=ke.y,r[2]=Zn.z,r[6]=Ea.z,r[10]=ke.z,this}multiply(t,e){return e!==void 0?(console.warn("THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead."),this.multiplyMatrices(t,e)):this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,e){let i=t.elements,r=e.elements,s=this.elements,o=i[0],a=i[4],l=i[8],c=i[12],u=i[1],h=i[5],f=i[9],d=i[13],g=i[2],x=i[6],v=i[10],m=i[14],p=i[3],b=i[7],_=i[11],S=i[15],L=r[0],A=r[4],H=r[8],tt=r[12],X=r[1],y=r[5],R=r[9],D=r[13],F=r[2],z=r[6],N=r[10],V=r[14],Q=r[3],at=r[7],G=r[11],$=r[15];return s[0]=o*L+a*X+l*F+c*Q,s[4]=o*A+a*y+l*z+c*at,s[8]=o*H+a*R+l*N+c*G,s[12]=o*tt+a*D+l*V+c*$,s[1]=u*L+h*X+f*F+d*Q,s[5]=u*A+h*y+f*z+d*at,s[9]=u*H+h*R+f*N+d*G,s[13]=u*tt+h*D+f*V+d*$,s[2]=g*L+x*X+v*F+m*Q,s[6]=g*A+x*y+v*z+m*at,s[10]=g*H+x*R+v*N+m*G,s[14]=g*tt+x*D+v*V+m*$,s[3]=p*L+b*X+_*F+S*Q,s[7]=p*A+b*y+_*z+S*at,s[11]=p*H+b*R+_*N+S*G,s[15]=p*tt+b*D+_*V+S*$,this}multiplyScalar(t){let e=this.elements;return e[0]*=t,e[4]*=t,e[8]*=t,e[12]*=t,e[1]*=t,e[5]*=t,e[9]*=t,e[13]*=t,e[2]*=t,e[6]*=t,e[10]*=t,e[14]*=t,e[3]*=t,e[7]*=t,e[11]*=t,e[15]*=t,this}determinant(){let t=this.elements,e=t[0],i=t[4],r=t[8],s=t[12],o=t[1],a=t[5],l=t[9],c=t[13],u=t[2],h=t[6],f=t[10],d=t[14],g=t[3],x=t[7],v=t[11],m=t[15];return g*(+s*l*h-r*c*h-s*a*f+i*c*f+r*a*d-i*l*d)+x*(+e*l*d-e*c*f+s*o*f-r*o*d+r*c*u-s*l*u)+v*(+e*c*h-e*a*d-s*o*h+i*o*d+s*a*u-i*c*u)+m*(-r*a*u-e*l*h+e*a*f+r*o*h-i*o*f+i*l*u)}transpose(){let t=this.elements,e;return e=t[1],t[1]=t[4],t[4]=e,e=t[2],t[2]=t[8],t[8]=e,e=t[6],t[6]=t[9],t[9]=e,e=t[3],t[3]=t[12],t[12]=e,e=t[7],t[7]=t[13],t[13]=e,e=t[11],t[11]=t[14],t[14]=e,this}setPosition(t,e,i){let r=this.elements;return t.isVector3?(r[12]=t.x,r[13]=t.y,r[14]=t.z):(r[12]=t,r[13]=e,r[14]=i),this}invert(){let t=this.elements,e=t[0],i=t[1],r=t[2],s=t[3],o=t[4],a=t[5],l=t[6],c=t[7],u=t[8],h=t[9],f=t[10],d=t[11],g=t[12],x=t[13],v=t[14],m=t[15],p=h*v*c-x*f*c+x*l*d-a*v*d-h*l*m+a*f*m,b=g*f*c-u*v*c-g*l*d+o*v*d+u*l*m-o*f*m,_=u*x*c-g*h*c+g*a*d-o*x*d-u*a*m+o*h*m,S=g*h*l-u*x*l-g*a*f+o*x*f+u*a*v-o*h*v,L=e*p+i*b+r*_+s*S;if(L===0)return this.set(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);let A=1/L;return t[0]=p*A,t[1]=(x*f*s-h*v*s-x*r*d+i*v*d+h*r*m-i*f*m)*A,t[2]=(a*v*s-x*l*s+x*r*c-i*v*c-a*r*m+i*l*m)*A,t[3]=(h*l*s-a*f*s-h*r*c+i*f*c+a*r*d-i*l*d)*A,t[4]=b*A,t[5]=(u*v*s-g*f*s+g*r*d-e*v*d-u*r*m+e*f*m)*A,t[6]=(g*l*s-o*v*s-g*r*c+e*v*c+o*r*m-e*l*m)*A,t[7]=(o*f*s-u*l*s+u*r*c-e*f*c-o*r*d+e*l*d)*A,t[8]=_*A,t[9]=(g*h*s-u*x*s-g*i*d+e*x*d+u*i*m-e*h*m)*A,t[10]=(o*x*s-g*a*s+g*i*c-e*x*c-o*i*m+e*a*m)*A,t[11]=(u*a*s-o*h*s-u*i*c+e*h*c+o*i*d-e*a*d)*A,t[12]=S*A,t[13]=(u*x*r-g*h*r+g*i*f-e*x*f-u*i*v+e*h*v)*A,t[14]=(g*a*r-o*x*r-g*i*l+e*x*l+o*i*v-e*a*v)*A,t[15]=(o*h*r-u*a*r+u*i*l-e*h*l-o*i*f+e*a*f)*A,this}scale(t){let e=this.elements,i=t.x,r=t.y,s=t.z;return e[0]*=i,e[4]*=r,e[8]*=s,e[1]*=i,e[5]*=r,e[9]*=s,e[2]*=i,e[6]*=r,e[10]*=s,e[3]*=i,e[7]*=r,e[11]*=s,this}getMaxScaleOnAxis(){let t=this.elements,e=t[0]*t[0]+t[1]*t[1]+t[2]*t[2],i=t[4]*t[4]+t[5]*t[5]+t[6]*t[6],r=t[8]*t[8]+t[9]*t[9]+t[10]*t[10];return Math.sqrt(Math.max(e,i,r))}makeTranslation(t,e,i){return this.set(1,0,0,t,0,1,0,e,0,0,1,i,0,0,0,1),this}makeRotationX(t){let e=Math.cos(t),i=Math.sin(t);return this.set(1,0,0,0,0,e,-i,0,0,i,e,0,0,0,0,1),this}makeRotationY(t){let e=Math.cos(t),i=Math.sin(t);return this.set(e,0,i,0,0,1,0,0,-i,0,e,0,0,0,0,1),this}makeRotationZ(t){let e=Math.cos(t),i=Math.sin(t);return this.set(e,-i,0,0,i,e,0,0,0,0,1,0,0,0,0,1),this}makeRotationAxis(t,e){let i=Math.cos(e),r=Math.sin(e),s=1-i,o=t.x,a=t.y,l=t.z,c=s*o,u=s*a;return this.set(c*o+i,c*a-r*l,c*l+r*a,0,c*a+r*l,u*a+i,u*l-r*o,0,c*l-r*a,u*l+r*o,s*l*l+i,0,0,0,0,1),this}makeScale(t,e,i){return this.set(t,0,0,0,0,e,0,0,0,0,i,0,0,0,0,1),this}makeShear(t,e,i,r,s,o){return this.set(1,i,s,0,t,1,o,0,e,r,1,0,0,0,0,1),this}compose(t,e,i){let r=this.elements,s=e._x,o=e._y,a=e._z,l=e._w,c=s+s,u=o+o,h=a+a,f=s*c,d=s*u,g=s*h,x=o*u,v=o*h,m=a*h,p=l*c,b=l*u,_=l*h,S=i.x,L=i.y,A=i.z;return r[0]=(1-(x+m))*S,r[1]=(d+_)*S,r[2]=(g-b)*S,r[3]=0,r[4]=(d-_)*L,r[5]=(1-(f+m))*L,r[6]=(v+p)*L,r[7]=0,r[8]=(g+b)*A,r[9]=(v-p)*A,r[10]=(1-(f+x))*A,r[11]=0,r[12]=t.x,r[13]=t.y,r[14]=t.z,r[15]=1,this}decompose(t,e,i){let r=this.elements,s=yr.set(r[0],r[1],r[2]).length(),o=yr.set(r[4],r[5],r[6]).length(),a=yr.set(r[8],r[9],r[10]).length();this.determinant()<0&&(s=-s),t.x=r[12],t.y=r[13],t.z=r[14],Ke.copy(this);let c=1/s,u=1/o,h=1/a;return Ke.elements[0]*=c,Ke.elements[1]*=c,Ke.elements[2]*=c,Ke.elements[4]*=u,Ke.elements[5]*=u,Ke.elements[6]*=u,Ke.elements[8]*=h,Ke.elements[9]*=h,Ke.elements[10]*=h,e.setFromRotationMatrix(Ke),i.x=s,i.y=o,i.z=a,this}makePerspective(t,e,i,r,s,o){o===void 0&&console.warn("THREE.Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.");let a=this.elements,l=2*s/(e-t),c=2*s/(i-r),u=(e+t)/(e-t),h=(i+r)/(i-r),f=-(o+s)/(o-s),d=-2*o*s/(o-s);return a[0]=l,a[4]=0,a[8]=u,a[12]=0,a[1]=0,a[5]=c,a[9]=h,a[13]=0,a[2]=0,a[6]=0,a[10]=f,a[14]=d,a[3]=0,a[7]=0,a[11]=-1,a[15]=0,this}makeOrthographic(t,e,i,r,s,o){let a=this.elements,l=1/(e-t),c=1/(i-r),u=1/(o-s),h=(e+t)*l,f=(i+r)*c,d=(o+s)*u;return a[0]=2*l,a[4]=0,a[8]=0,a[12]=-h,a[1]=0,a[5]=2*c,a[9]=0,a[13]=-f,a[2]=0,a[6]=0,a[10]=-2*u,a[14]=-d,a[3]=0,a[7]=0,a[11]=0,a[15]=1,this}equals(t){let e=this.elements,i=t.elements;for(let r=0;r<16;r++)if(e[r]!==i[r])return!1;return!0}fromArray(t,e=0){for(let i=0;i<16;i++)this.elements[i]=t[i+e];return this}toArray(t=[],e=0){let i=this.elements;return t[e]=i[0],t[e+1]=i[1],t[e+2]=i[2],t[e+3]=i[3],t[e+4]=i[4],t[e+5]=i[5],t[e+6]=i[6],t[e+7]=i[7],t[e+8]=i[8],t[e+9]=i[9],t[e+10]=i[10],t[e+11]=i[11],t[e+12]=i[12],t[e+13]=i[13],t[e+14]=i[14],t[e+15]=i[15],t}};wt.prototype.isMatrix4=!0;var yr=new T,Ke=new wt,sM=new T(0,0,0),oM=new T(1,1,1),Zn=new T,Ea=new T,ke=new T,og=new wt,ag=new Ee,ai=class{constructor(t=0,e=0,i=0,r=ai.DefaultOrder){this._x=t,this._y=e,this._z=i,this._order=r}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get order(){return this._order}set order(t){this._order=t,this._onChangeCallback()}set(t,e,i,r=this._order){return this._x=t,this._y=e,this._z=i,this._order=r,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._order)}copy(t){return this._x=t._x,this._y=t._y,this._z=t._z,this._order=t._order,this._onChangeCallback(),this}setFromRotationMatrix(t,e=this._order,i=!0){let r=t.elements,s=r[0],o=r[4],a=r[8],l=r[1],c=r[5],u=r[9],h=r[2],f=r[6],d=r[10];switch(e){case"XYZ":this._y=Math.asin(Ie(a,-1,1)),Math.abs(a)<.9999999?(this._x=Math.atan2(-u,d),this._z=Math.atan2(-o,s)):(this._x=Math.atan2(f,c),this._z=0);break;case"YXZ":this._x=Math.asin(-Ie(u,-1,1)),Math.abs(u)<.9999999?(this._y=Math.atan2(a,d),this._z=Math.atan2(l,c)):(this._y=Math.atan2(-h,s),this._z=0);break;case"ZXY":this._x=Math.asin(Ie(f,-1,1)),Math.abs(f)<.9999999?(this._y=Math.atan2(-h,d),this._z=Math.atan2(-o,c)):(this._y=0,this._z=Math.atan2(l,s));break;case"ZYX":this._y=Math.asin(-Ie(h,-1,1)),Math.abs(h)<.9999999?(this._x=Math.atan2(f,d),this._z=Math.atan2(l,s)):(this._x=0,this._z=Math.atan2(-o,c));break;case"YZX":this._z=Math.asin(Ie(l,-1,1)),Math.abs(l)<.9999999?(this._x=Math.atan2(-u,c),this._y=Math.atan2(-h,s)):(this._x=0,this._y=Math.atan2(a,d));break;case"XZY":this._z=Math.asin(-Ie(o,-1,1)),Math.abs(o)<.9999999?(this._x=Math.atan2(f,c),this._y=Math.atan2(a,s)):(this._x=Math.atan2(-u,d),this._y=0);break;default:console.warn("THREE.Euler: .setFromRotationMatrix() encountered an unknown order: "+e)}return this._order=e,i===!0&&this._onChangeCallback(),this}setFromQuaternion(t,e,i){return og.makeRotationFromQuaternion(t),this.setFromRotationMatrix(og,e,i)}setFromVector3(t,e=this._order){return this.set(t.x,t.y,t.z,e)}reorder(t){return ag.setFromEuler(this),this.setFromQuaternion(ag,t)}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._order===this._order}fromArray(t){return this._x=t[0],this._y=t[1],this._z=t[2],t[3]!==void 0&&(this._order=t[3]),this._onChangeCallback(),this}toArray(t=[],e=0){return t[e]=this._x,t[e+1]=this._y,t[e+2]=this._z,t[e+3]=this._order,t}toVector3(t){return t?t.set(this._x,this._y,this._z):new T(this._x,this._y,this._z)}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}};ai.prototype.isEuler=!0;ai.DefaultOrder="XYZ";ai.RotationOrders=["XYZ","YZX","ZXY","XZY","YXZ","ZYX"];var il=class{constructor(){this.mask=1}set(t){this.mask=(1<<t|0)>>>0}enable(t){this.mask|=1<<t|0}enableAll(){this.mask=-1}toggle(t){this.mask^=1<<t|0}disable(t){this.mask&=~(1<<t|0)}disableAll(){this.mask=0}test(t){return(this.mask&t.mask)!==0}isEnabled(t){return(this.mask&(1<<t|0))!==0}},aM=0,lg=new T,vr=new Ee,Rn=new wt,Ta=new T,Hs=new T,lM=new T,cM=new Ee,cg=new T(1,0,0),ug=new T(0,1,0),hg=new T(0,0,1),uM={type:"added"},fg={type:"removed"},kt=class extends In{constructor(){super(),Object.defineProperty(this,"id",{value:aM++}),this.uuid=tn(),this.name="",this.type="Object3D",this.parent=null,this.children=[],this.up=kt.DefaultUp.clone();let t=new T,e=new ai,i=new Ee,r=new T(1,1,1);function s(){i.setFromEuler(e,!1)}function o(){e.setFromQuaternion(i,void 0,!1)}e._onChange(s),i._onChange(o),Object.defineProperties(this,{position:{configurable:!0,enumerable:!0,value:t},rotation:{configurable:!0,enumerable:!0,value:e},quaternion:{configurable:!0,enumerable:!0,value:i},scale:{configurable:!0,enumerable:!0,value:r},modelViewMatrix:{value:new wt},normalMatrix:{value:new de}}),this.matrix=new wt,this.matrixWorld=new wt,this.matrixAutoUpdate=kt.DefaultMatrixAutoUpdate,this.matrixWorldNeedsUpdate=!1,this.layers=new il,this.visible=!0,this.castShadow=!1,this.receiveShadow=!1,this.frustumCulled=!0,this.renderOrder=0,this.animations=[],this.userData={}}onBeforeRender(){}onAfterRender(){}applyMatrix4(t){this.matrixAutoUpdate&&this.updateMatrix(),this.matrix.premultiply(t),this.matrix.decompose(this.position,this.quaternion,this.scale)}applyQuaternion(t){return this.quaternion.premultiply(t),this}setRotationFromAxisAngle(t,e){this.quaternion.setFromAxisAngle(t,e)}setRotationFromEuler(t){this.quaternion.setFromEuler(t,!0)}setRotationFromMatrix(t){this.quaternion.setFromRotationMatrix(t)}setRotationFromQuaternion(t){this.quaternion.copy(t)}rotateOnAxis(t,e){return vr.setFromAxisAngle(t,e),this.quaternion.multiply(vr),this}rotateOnWorldAxis(t,e){return vr.setFromAxisAngle(t,e),this.quaternion.premultiply(vr),this}rotateX(t){return this.rotateOnAxis(cg,t)}rotateY(t){return this.rotateOnAxis(ug,t)}rotateZ(t){return this.rotateOnAxis(hg,t)}translateOnAxis(t,e){return lg.copy(t).applyQuaternion(this.quaternion),this.position.add(lg.multiplyScalar(e)),this}translateX(t){return this.translateOnAxis(cg,t)}translateY(t){return this.translateOnAxis(ug,t)}translateZ(t){return this.translateOnAxis(hg,t)}localToWorld(t){return t.applyMatrix4(this.matrixWorld)}worldToLocal(t){return t.applyMatrix4(Rn.copy(this.matrixWorld).invert())}lookAt(t,e,i){t.isVector3?Ta.copy(t):Ta.set(t,e,i);let r=this.parent;this.updateWorldMatrix(!0,!1),Hs.setFromMatrixPosition(this.matrixWorld),this.isCamera||this.isLight?Rn.lookAt(Hs,Ta,this.up):Rn.lookAt(Ta,Hs,this.up),this.quaternion.setFromRotationMatrix(Rn),r&&(Rn.extractRotation(r.matrixWorld),vr.setFromRotationMatrix(Rn),this.quaternion.premultiply(vr.invert()))}add(t){if(arguments.length>1){for(let e=0;e<arguments.length;e++)this.add(arguments[e]);return this}return t===this?(console.error("THREE.Object3D.add: object can't be added as a child of itself.",t),this):(t&&t.isObject3D?(t.parent!==null&&t.parent.remove(t),t.parent=this,this.children.push(t),t.dispatchEvent(uM)):console.error("THREE.Object3D.add: object not an instance of THREE.Object3D.",t),this)}remove(t){if(arguments.length>1){for(let i=0;i<arguments.length;i++)this.remove(arguments[i]);return this}let e=this.children.indexOf(t);return e!==-1&&(t.parent=null,this.children.splice(e,1),t.dispatchEvent(fg)),this}removeFromParent(){let t=this.parent;return t!==null&&t.remove(this),this}clear(){for(let t=0;t<this.children.length;t++){let e=this.children[t];e.parent=null,e.dispatchEvent(fg)}return this.children.length=0,this}attach(t){return this.updateWorldMatrix(!0,!1),Rn.copy(this.matrixWorld).invert(),t.parent!==null&&(t.parent.updateWorldMatrix(!0,!1),Rn.multiply(t.parent.matrixWorld)),t.applyMatrix4(Rn),this.add(t),t.updateWorldMatrix(!1,!0),this}getObjectById(t){return this.getObjectByProperty("id",t)}getObjectByName(t){return this.getObjectByProperty("name",t)}getObjectByProperty(t,e){if(this[t]===e)return this;for(let i=0,r=this.children.length;i<r;i++){let o=this.children[i].getObjectByProperty(t,e);if(o!==void 0)return o}}getWorldPosition(t){return this.updateWorldMatrix(!0,!1),t.setFromMatrixPosition(this.matrixWorld)}getWorldQuaternion(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(Hs,t,lM),t}getWorldScale(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(Hs,cM,t),t}getWorldDirection(t){this.updateWorldMatrix(!0,!1);let e=this.matrixWorld.elements;return t.set(e[8],e[9],e[10]).normalize()}raycast(){}traverse(t){t(this);let e=this.children;for(let i=0,r=e.length;i<r;i++)e[i].traverse(t)}traverseVisible(t){if(this.visible===!1)return;t(this);let e=this.children;for(let i=0,r=e.length;i<r;i++)e[i].traverseVisible(t)}traverseAncestors(t){let e=this.parent;e!==null&&(t(e),e.traverseAncestors(t))}updateMatrix(){this.matrix.compose(this.position,this.quaternion,this.scale),this.matrixWorldNeedsUpdate=!0}updateMatrixWorld(t){this.matrixAutoUpdate&&this.updateMatrix(),(this.matrixWorldNeedsUpdate||t)&&(this.parent===null?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),this.matrixWorldNeedsUpdate=!1,t=!0);let e=this.children;for(let i=0,r=e.length;i<r;i++)e[i].updateMatrixWorld(t)}updateWorldMatrix(t,e){let i=this.parent;if(t===!0&&i!==null&&i.updateWorldMatrix(!0,!1),this.matrixAutoUpdate&&this.updateMatrix(),this.parent===null?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),e===!0){let r=this.children;for(let s=0,o=r.length;s<o;s++)r[s].updateWorldMatrix(!1,!0)}}toJSON(t){let e=t===void 0||typeof t=="string",i={};e&&(t={geometries:{},materials:{},textures:{},images:{},shapes:{},skeletons:{},animations:{}},i.metadata={version:4.5,type:"Object",generator:"Object3D.toJSON"});let r={};r.uuid=this.uuid,r.type=this.type,this.name!==""&&(r.name=this.name),this.castShadow===!0&&(r.castShadow=!0),this.receiveShadow===!0&&(r.receiveShadow=!0),this.visible===!1&&(r.visible=!1),this.frustumCulled===!1&&(r.frustumCulled=!1),this.renderOrder!==0&&(r.renderOrder=this.renderOrder),JSON.stringify(this.userData)!=="{}"&&(r.userData=this.userData),r.layers=this.layers.mask,r.matrix=this.matrix.toArray(),this.matrixAutoUpdate===!1&&(r.matrixAutoUpdate=!1),this.isInstancedMesh&&(r.type="InstancedMesh",r.count=this.count,r.instanceMatrix=this.instanceMatrix.toJSON(),this.instanceColor!==null&&(r.instanceColor=this.instanceColor.toJSON()));function s(a,l){return a[l.uuid]===void 0&&(a[l.uuid]=l.toJSON(t)),l.uuid}if(this.isScene)this.background&&(this.background.isColor?r.background=this.background.toJSON():this.background.isTexture&&(r.background=this.background.toJSON(t).uuid)),this.environment&&this.environment.isTexture&&(r.environment=this.environment.toJSON(t).uuid);else if(this.isMesh||this.isLine||this.isPoints){r.geometry=s(t.geometries,this.geometry);let a=this.geometry.parameters;if(a!==void 0&&a.shapes!==void 0){let l=a.shapes;if(Array.isArray(l))for(let c=0,u=l.length;c<u;c++){let h=l[c];s(t.shapes,h)}else s(t.shapes,l)}}if(this.isSkinnedMesh&&(r.bindMode=this.bindMode,r.bindMatrix=this.bindMatrix.toArray(),this.skeleton!==void 0&&(s(t.skeletons,this.skeleton),r.skeleton=this.skeleton.uuid)),this.material!==void 0)if(Array.isArray(this.material)){let a=[];for(let l=0,c=this.material.length;l<c;l++)a.push(s(t.materials,this.material[l]));r.material=a}else r.material=s(t.materials,this.material);if(this.children.length>0){r.children=[];for(let a=0;a<this.children.length;a++)r.children.push(this.children[a].toJSON(t).object)}if(this.animations.length>0){r.animations=[];for(let a=0;a<this.animations.length;a++){let l=this.animations[a];r.animations.push(s(t.animations,l))}}if(e){let a=o(t.geometries),l=o(t.materials),c=o(t.textures),u=o(t.images),h=o(t.shapes),f=o(t.skeletons),d=o(t.animations);a.length>0&&(i.geometries=a),l.length>0&&(i.materials=l),c.length>0&&(i.textures=c),u.length>0&&(i.images=u),h.length>0&&(i.shapes=h),f.length>0&&(i.skeletons=f),d.length>0&&(i.animations=d)}return i.object=r,i;function o(a){let l=[];for(let c in a){let u=a[c];delete u.metadata,l.push(u)}return l}}clone(t){return new this.constructor().copy(this,t)}copy(t,e=!0){if(this.name=t.name,this.up.copy(t.up),this.position.copy(t.position),this.rotation.order=t.rotation.order,this.quaternion.copy(t.quaternion),this.scale.copy(t.scale),this.matrix.copy(t.matrix),this.matrixWorld.copy(t.matrixWorld),this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrixWorldNeedsUpdate=t.matrixWorldNeedsUpdate,this.layers.mask=t.layers.mask,this.visible=t.visible,this.castShadow=t.castShadow,this.receiveShadow=t.receiveShadow,this.frustumCulled=t.frustumCulled,this.renderOrder=t.renderOrder,this.userData=JSON.parse(JSON.stringify(t.userData)),e===!0)for(let i=0;i<t.children.length;i++){let r=t.children[i];this.add(r.clone())}return this}};kt.DefaultUp=new T(0,1,0);kt.DefaultMatrixAutoUpdate=!0;kt.prototype.isObject3D=!0;var Qe=new T,Ln=new T,mu=new T,Pn=new T,_r=new T,wr=new T,dg=new T,gu=new T,xu=new T,yu=new T,re=class{constructor(t=new T,e=new T,i=new T){this.a=t,this.b=e,this.c=i}static getNormal(t,e,i,r){r.subVectors(i,e),Qe.subVectors(t,e),r.cross(Qe);let s=r.lengthSq();return s>0?r.multiplyScalar(1/Math.sqrt(s)):r.set(0,0,0)}static getBarycoord(t,e,i,r,s){Qe.subVectors(r,e),Ln.subVectors(i,e),mu.subVectors(t,e);let o=Qe.dot(Qe),a=Qe.dot(Ln),l=Qe.dot(mu),c=Ln.dot(Ln),u=Ln.dot(mu),h=o*c-a*a;if(h===0)return s.set(-2,-1,-1);let f=1/h,d=(c*l-a*u)*f,g=(o*u-a*l)*f;return s.set(1-d-g,g,d)}static containsPoint(t,e,i,r){return this.getBarycoord(t,e,i,r,Pn),Pn.x>=0&&Pn.y>=0&&Pn.x+Pn.y<=1}static getUV(t,e,i,r,s,o,a,l){return this.getBarycoord(t,e,i,r,Pn),l.set(0,0),l.addScaledVector(s,Pn.x),l.addScaledVector(o,Pn.y),l.addScaledVector(a,Pn.z),l}static isFrontFacing(t,e,i,r){return Qe.subVectors(i,e),Ln.subVectors(t,e),Qe.cross(Ln).dot(r)<0}set(t,e,i){return this.a.copy(t),this.b.copy(e),this.c.copy(i),this}setFromPointsAndIndices(t,e,i,r){return this.a.copy(t[e]),this.b.copy(t[i]),this.c.copy(t[r]),this}setFromAttributeAndIndices(t,e,i,r){return this.a.fromBufferAttribute(t,e),this.b.fromBufferAttribute(t,i),this.c.fromBufferAttribute(t,r),this}clone(){return new this.constructor().copy(this)}copy(t){return this.a.copy(t.a),this.b.copy(t.b),this.c.copy(t.c),this}getArea(){return Qe.subVectors(this.c,this.b),Ln.subVectors(this.a,this.b),Qe.cross(Ln).length()*.5}getMidpoint(t){return t.addVectors(this.a,this.b).add(this.c).multiplyScalar(1/3)}getNormal(t){return re.getNormal(this.a,this.b,this.c,t)}getPlane(t){return t.setFromCoplanarPoints(this.a,this.b,this.c)}getBarycoord(t,e){return re.getBarycoord(t,this.a,this.b,this.c,e)}getUV(t,e,i,r,s){return re.getUV(t,this.a,this.b,this.c,e,i,r,s)}containsPoint(t){return re.containsPoint(t,this.a,this.b,this.c)}isFrontFacing(t){return re.isFrontFacing(this.a,this.b,this.c,t)}intersectsBox(t){return t.intersectsTriangle(this)}closestPointToPoint(t,e){let i=this.a,r=this.b,s=this.c,o,a;_r.subVectors(r,i),wr.subVectors(s,i),gu.subVectors(t,i);let l=_r.dot(gu),c=wr.dot(gu);if(l<=0&&c<=0)return e.copy(i);xu.subVectors(t,r);let u=_r.dot(xu),h=wr.dot(xu);if(u>=0&&h<=u)return e.copy(r);let f=l*h-u*c;if(f<=0&&l>=0&&u<=0)return o=l/(l-u),e.copy(i).addScaledVector(_r,o);yu.subVectors(t,s);let d=_r.dot(yu),g=wr.dot(yu);if(g>=0&&d<=g)return e.copy(s);let x=d*c-l*g;if(x<=0&&c>=0&&g<=0)return a=c/(c-g),e.copy(i).addScaledVector(wr,a);let v=u*g-d*h;if(v<=0&&h-u>=0&&d-g>=0)return dg.subVectors(s,r),a=(h-u)/(h-u+(d-g)),e.copy(r).addScaledVector(dg,a);let m=1/(v+x+f);return o=x*m,a=f*m,e.copy(i).addScaledVector(_r,o).addScaledVector(wr,a)}equals(t){return t.a.equals(this.a)&&t.b.equals(this.b)&&t.c.equals(this.c)}},hM=0,xe=class extends In{constructor(){super(),Object.defineProperty(this,"id",{value:hM++}),this.uuid=tn(),this.name="",this.type="Material",this.fog=!0,this.blending=Ks,this.side=eo,this.vertexColors=!1,this.opacity=1,this.transparent=!1,this.blendSrc=u0,this.blendDst=h0,this.blendEquation=Ir,this.blendSrcAlpha=null,this.blendDstAlpha=null,this.blendEquationAlpha=null,this.depthFunc=zu,this.depthTest=!0,this.depthWrite=!0,this.stencilWriteMask=255,this.stencilFunc=tM,this.stencilRef=0,this.stencilFuncMask=255,this.stencilFail=nu,this.stencilZFail=nu,this.stencilZPass=nu,this.stencilWrite=!1,this.clippingPlanes=null,this.clipIntersection=!1,this.clipShadows=!1,this.shadowSide=null,this.colorWrite=!0,this.alphaWrite=!0,this.precision=null,this.polygonOffset=!1,this.polygonOffsetFactor=0,this.polygonOffsetUnits=0,this.dithering=!1,this.alphaToCoverage=!1,this.premultipliedAlpha=!1,this.visible=!0,this.toneMapped=!0,this.userData={},this.version=0,this._alphaTest=0}get alphaTest(){return this._alphaTest}set alphaTest(t){this._alphaTest>0!=t>0&&this.version++,this._alphaTest=t}onBuild(){}onBeforeRender(){}onBeforeCompile(){}customProgramCacheKey(){return this.onBeforeCompile.toString()}setValues(t){if(t!==void 0)for(let e in t){let i=t[e];if(i===void 0){console.warn("THREE.Material: '"+e+"' parameter is undefined.");continue}if(e==="shading"){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=i===c0;continue}let r=this[e];if(r===void 0){console.warn("THREE."+this.type+": '"+e+"' is not a property of this material.");continue}r&&r.isColor?r.set(i):r&&r.isVector3&&i&&i.isVector3?r.copy(i):this[e]=i}}toJSON(t){let e=t===void 0||typeof t=="string";e&&(t={textures:{},images:{}});let i={metadata:{version:4.5,type:"Material",generator:"Material.toJSON"}};i.uuid=this.uuid,i.type=this.type,this.name!==""&&(i.name=this.name),this.color&&this.color.isColor&&(i.color=this.color.getHex()),this.roughness!==void 0&&(i.roughness=this.roughness),this.metalness!==void 0&&(i.metalness=this.metalness),this.sheen!==void 0&&(i.sheen=this.sheen),this.sheenColor&&this.sheenColor.isColor&&(i.sheenColor=this.sheenColor.getHex()),this.sheenRoughness!==void 0&&(i.sheenRoughness=this.sheenRoughness),this.emissive&&this.emissive.isColor&&(i.emissive=this.emissive.getHex()),this.emissiveIntensity&&this.emissiveIntensity!==1&&(i.emissiveIntensity=this.emissiveIntensity),this.specular&&this.specular.isColor&&(i.specular=this.specular.getHex()),this.specularIntensity!==void 0&&(i.specularIntensity=this.specularIntensity),this.specularColor&&this.specularColor.isColor&&(i.specularColor=this.specularColor.getHex()),this.shininess!==void 0&&(i.shininess=this.shininess),this.clearcoat!==void 0&&(i.clearcoat=this.clearcoat),this.clearcoatRoughness!==void 0&&(i.clearcoatRoughness=this.clearcoatRoughness),this.clearcoatMap&&this.clearcoatMap.isTexture&&(i.clearcoatMap=this.clearcoatMap.toJSON(t).uuid),this.clearcoatRoughnessMap&&this.clearcoatRoughnessMap.isTexture&&(i.clearcoatRoughnessMap=this.clearcoatRoughnessMap.toJSON(t).uuid),this.clearcoatNormalMap&&this.clearcoatNormalMap.isTexture&&(i.clearcoatNormalMap=this.clearcoatNormalMap.toJSON(t).uuid,i.clearcoatNormalScale=this.clearcoatNormalScale.toArray()),this.map&&this.map.isTexture&&(i.map=this.map.toJSON(t).uuid),this.matcap&&this.matcap.isTexture&&(i.matcap=this.matcap.toJSON(t).uuid),this.alphaMap&&this.alphaMap.isTexture&&(i.alphaMap=this.alphaMap.toJSON(t).uuid),this.lightMap&&this.lightMap.isTexture&&(i.lightMap=this.lightMap.toJSON(t).uuid,i.lightMapIntensity=this.lightMapIntensity),this.aoMap&&this.aoMap.isTexture&&(i.aoMap=this.aoMap.toJSON(t).uuid,i.aoMapIntensity=this.aoMapIntensity),this.bumpMap&&this.bumpMap.isTexture&&(i.bumpMap=this.bumpMap.toJSON(t).uuid,i.bumpScale=this.bumpScale),this.normalMap&&this.normalMap.isTexture&&(i.normalMap=this.normalMap.toJSON(t).uuid,i.normalMapType=this.normalMapType,i.normalScale=this.normalScale.toArray()),this.displacementMap&&this.displacementMap.isTexture&&(i.displacementMap=this.displacementMap.toJSON(t).uuid,i.displacementScale=this.displacementScale,i.displacementBias=this.displacementBias),this.roughnessMap&&this.roughnessMap.isTexture&&(i.roughnessMap=this.roughnessMap.toJSON(t).uuid),this.metalnessMap&&this.metalnessMap.isTexture&&(i.metalnessMap=this.metalnessMap.toJSON(t).uuid),this.emissiveMap&&this.emissiveMap.isTexture&&(i.emissiveMap=this.emissiveMap.toJSON(t).uuid),this.specularMap&&this.specularMap.isTexture&&(i.specularMap=this.specularMap.toJSON(t).uuid),this.specularIntensityMap&&this.specularIntensityMap.isTexture&&(i.specularIntensityMap=this.specularIntensityMap.toJSON(t).uuid),this.specularColorMap&&this.specularColorMap.isTexture&&(i.specularColorMap=this.specularColorMap.toJSON(t).uuid),this.envMap&&this.envMap.isTexture&&(i.envMap=this.envMap.toJSON(t).uuid,this.combine!==void 0&&(i.combine=this.combine)),this.envMapIntensity!==void 0&&(i.envMapIntensity=this.envMapIntensity),this.reflectivity!==void 0&&(i.reflectivity=this.reflectivity),this.refractionRatio!==void 0&&(i.refractionRatio=this.refractionRatio),this.gradientMap&&this.gradientMap.isTexture&&(i.gradientMap=this.gradientMap.toJSON(t).uuid),this.transmission!==void 0&&(i.transmission=this.transmission),this.transmissionMap&&this.transmissionMap.isTexture&&(i.transmissionMap=this.transmissionMap.toJSON(t).uuid),this.thickness!==void 0&&(i.thickness=this.thickness),this.thicknessMap&&this.thicknessMap.isTexture&&(i.thicknessMap=this.thicknessMap.toJSON(t).uuid),this.attenuationDistance!==void 0&&(i.attenuationDistance=this.attenuationDistance),this.attenuationColor!==void 0&&(i.attenuationColor=this.attenuationColor.getHex()),this.size!==void 0&&(i.size=this.size),this.shadowSide!==null&&(i.shadowSide=this.shadowSide),this.sizeAttenuation!==void 0&&(i.sizeAttenuation=this.sizeAttenuation),this.blending!==Ks&&(i.blending=this.blending),this.side!==eo&&(i.side=this.side),this.vertexColors&&(i.vertexColors=!0),this.opacity<1&&(i.opacity=this.opacity),this.transparent===!0&&(i.transparent=this.transparent),i.depthFunc=this.depthFunc,i.depthTest=this.depthTest,i.depthWrite=this.depthWrite,i.colorWrite=this.colorWrite,i.alphaWrite=this.alphaWrite,i.stencilWrite=this.stencilWrite,i.stencilWriteMask=this.stencilWriteMask,i.stencilFunc=this.stencilFunc,i.stencilRef=this.stencilRef,i.stencilFuncMask=this.stencilFuncMask,i.stencilFail=this.stencilFail,i.stencilZFail=this.stencilZFail,i.stencilZPass=this.stencilZPass,this.rotation&&this.rotation!==0&&(i.rotation=this.rotation),this.polygonOffset===!0&&(i.polygonOffset=!0),this.polygonOffsetFactor!==0&&(i.polygonOffsetFactor=this.polygonOffsetFactor),this.polygonOffsetUnits!==0&&(i.polygonOffsetUnits=this.polygonOffsetUnits),this.linewidth&&this.linewidth!==1&&(i.linewidth=this.linewidth),this.dashSize!==void 0&&(i.dashSize=this.dashSize),this.gapSize!==void 0&&(i.gapSize=this.gapSize),this.scale!==void 0&&(i.scale=this.scale),this.dithering===!0&&(i.dithering=!0),this.alphaTest>0&&(i.alphaTest=this.alphaTest),this.alphaToCoverage===!0&&(i.alphaToCoverage=this.alphaToCoverage),this.premultipliedAlpha===!0&&(i.premultipliedAlpha=this.premultipliedAlpha),this.wireframe===!0&&(i.wireframe=this.wireframe),this.wireframeLinewidth>1&&(i.wireframeLinewidth=this.wireframeLinewidth),this.wireframeLinecap!=="round"&&(i.wireframeLinecap=this.wireframeLinecap),this.wireframeLinejoin!=="round"&&(i.wireframeLinejoin=this.wireframeLinejoin),this.flatShading===!0&&(i.flatShading=this.flatShading),this.visible===!1&&(i.visible=!1),this.toneMapped===!1&&(i.toneMapped=!1),JSON.stringify(this.userData)!=="{}"&&(i.userData=this.userData);function r(s){let o=[];for(let a in s){let l=s[a];delete l.metadata,o.push(l)}return o}if(e){let s=r(t.textures),o=r(t.images);s.length>0&&(i.textures=s),o.length>0&&(i.images=o)}return i}clone(){return new this.constructor().copy(this)}copy(t){this.name=t.name,this.fog=t.fog,this.blending=t.blending,this.side=t.side,this.vertexColors=t.vertexColors,this.opacity=t.opacity,this.transparent=t.transparent,this.blendSrc=t.blendSrc,this.blendDst=t.blendDst,this.blendEquation=t.blendEquation,this.blendSrcAlpha=t.blendSrcAlpha,this.blendDstAlpha=t.blendDstAlpha,this.blendEquationAlpha=t.blendEquationAlpha,this.depthFunc=t.depthFunc,this.depthTest=t.depthTest,this.depthWrite=t.depthWrite,this.stencilWriteMask=t.stencilWriteMask,this.stencilFunc=t.stencilFunc,this.stencilRef=t.stencilRef,this.stencilFuncMask=t.stencilFuncMask,this.stencilFail=t.stencilFail,this.stencilZFail=t.stencilZFail,this.stencilZPass=t.stencilZPass,this.stencilWrite=t.stencilWrite;let e=t.clippingPlanes,i=null;if(e!==null){let r=e.length;i=new Array(r);for(let s=0;s!==r;++s)i[s]=e[s].clone()}return this.clippingPlanes=i,this.clipIntersection=t.clipIntersection,this.clipShadows=t.clipShadows,this.shadowSide=t.shadowSide,this.colorWrite=t.colorWrite,this.alphaWrite=t.alphaWrite,this.precision=t.precision,this.polygonOffset=t.polygonOffset,this.polygonOffsetFactor=t.polygonOffsetFactor,this.polygonOffsetUnits=t.polygonOffsetUnits,this.dithering=t.dithering,this.alphaTest=t.alphaTest,this.alphaToCoverage=t.alphaToCoverage,this.premultipliedAlpha=t.premultipliedAlpha,this.visible=t.visible,this.toneMapped=t.toneMapped,this.userData=JSON.parse(JSON.stringify(t.userData)),this}dispose(){this.dispatchEvent({type:"dispose"})}set needsUpdate(t){t===!0&&this.version++}};xe.prototype.isMaterial=!0;var ki=class extends xe{constructor(t){super(),this.type="MeshBasicMaterial",this.color=new ft(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=Cl,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};ki.prototype.isMeshBasicMaterial=!0;var Jt=new T,Aa=new K,Qt=class{constructor(t,e,i){if(Array.isArray(t))throw new TypeError("THREE.BufferAttribute: array should be a Typed Array.");this.name="",this.array=t,this.itemSize=e,this.count=t!==void 0?t.length/e:0,this.normalized=i===!0,this.usage=io,this.updateRange={offset:0,count:-1},this.version=0}onUploadCallback(){}set needsUpdate(t){t===!0&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.name=t.name,this.array=new t.array.constructor(t.array),this.itemSize=t.itemSize,this.count=t.count,this.normalized=t.normalized,this.usage=t.usage,this}copyAt(t,e,i){t*=this.itemSize,i*=e.itemSize;for(let r=0,s=this.itemSize;r<s;r++)this.array[t+r]=e.array[i+r];return this}copyArray(t){return this.array.set(t),this}copyColorsArray(t){let e=this.array,i=0;for(let r=0,s=t.length;r<s;r++){let o=t[r];o===void 0&&(console.warn("THREE.BufferAttribute.copyColorsArray(): color is undefined",r),o=new ft),e[i++]=o.r,e[i++]=o.g,e[i++]=o.b}return this}copyVector2sArray(t){let e=this.array,i=0;for(let r=0,s=t.length;r<s;r++){let o=t[r];o===void 0&&(console.warn("THREE.BufferAttribute.copyVector2sArray(): vector is undefined",r),o=new K),e[i++]=o.x,e[i++]=o.y}return this}copyVector3sArray(t){let e=this.array,i=0;for(let r=0,s=t.length;r<s;r++){let o=t[r];o===void 0&&(console.warn("THREE.BufferAttribute.copyVector3sArray(): vector is undefined",r),o=new T),e[i++]=o.x,e[i++]=o.y,e[i++]=o.z}return this}copyVector4sArray(t){let e=this.array,i=0;for(let r=0,s=t.length;r<s;r++){let o=t[r];o===void 0&&(console.warn("THREE.BufferAttribute.copyVector4sArray(): vector is undefined",r),o=new Wt),e[i++]=o.x,e[i++]=o.y,e[i++]=o.z,e[i++]=o.w}return this}applyMatrix3(t){if(this.itemSize===2)for(let e=0,i=this.count;e<i;e++)Aa.fromBufferAttribute(this,e),Aa.applyMatrix3(t),this.setXY(e,Aa.x,Aa.y);else if(this.itemSize===3)for(let e=0,i=this.count;e<i;e++)Jt.fromBufferAttribute(this,e),Jt.applyMatrix3(t),this.setXYZ(e,Jt.x,Jt.y,Jt.z);return this}applyMatrix4(t){for(let e=0,i=this.count;e<i;e++)Jt.x=this.getX(e),Jt.y=this.getY(e),Jt.z=this.getZ(e),Jt.applyMatrix4(t),this.setXYZ(e,Jt.x,Jt.y,Jt.z);return this}applyNormalMatrix(t){for(let e=0,i=this.count;e<i;e++)Jt.x=this.getX(e),Jt.y=this.getY(e),Jt.z=this.getZ(e),Jt.applyNormalMatrix(t),this.setXYZ(e,Jt.x,Jt.y,Jt.z);return this}transformDirection(t){for(let e=0,i=this.count;e<i;e++)Jt.x=this.getX(e),Jt.y=this.getY(e),Jt.z=this.getZ(e),Jt.transformDirection(t),this.setXYZ(e,Jt.x,Jt.y,Jt.z);return this}set(t,e=0){return this.array.set(t,e),this}getX(t){return this.array[t*this.itemSize]}setX(t,e){return this.array[t*this.itemSize]=e,this}getY(t){return this.array[t*this.itemSize+1]}setY(t,e){return this.array[t*this.itemSize+1]=e,this}getZ(t){return this.array[t*this.itemSize+2]}setZ(t,e){return this.array[t*this.itemSize+2]=e,this}getW(t){return this.array[t*this.itemSize+3]}setW(t,e){return this.array[t*this.itemSize+3]=e,this}setXY(t,e,i){return t*=this.itemSize,this.array[t+0]=e,this.array[t+1]=i,this}setXYZ(t,e,i,r){return t*=this.itemSize,this.array[t+0]=e,this.array[t+1]=i,this.array[t+2]=r,this}setXYZW(t,e,i,r,s){return t*=this.itemSize,this.array[t+0]=e,this.array[t+1]=i,this.array[t+2]=r,this.array[t+3]=s,this}onUpload(t){return this.onUploadCallback=t,this}clone(){return new this.constructor(this.array,this.itemSize).copy(this)}toJSON(){let t={itemSize:this.itemSize,type:this.array.constructor.name,array:Array.prototype.slice.call(this.array),normalized:this.normalized};return this.name!==""&&(t.name=this.name),this.usage!==io&&(t.usage=this.usage),(this.updateRange.offset!==0||this.updateRange.count!==-1)&&(t.updateRange=this.updateRange),t}};Qt.prototype.isBufferAttribute=!0;var rl=class extends Qt{constructor(t,e,i){super(new Uint16Array(t),e,i)}};var sl=class extends Qt{constructor(t,e,i){super(new Uint32Array(t),e,i)}},Wu=class extends Qt{constructor(t,e,i){super(new Uint16Array(t),e,i)}};Wu.prototype.isFloat16BufferAttribute=!0;var ee=class extends Qt{constructor(t,e,i){super(new Float32Array(t),e,i)}};var fM=0,qe=new wt,vu=new kt,Mr=new T,He=new Ge,Vs=new Ge,ge=new T,Ht=class extends In{constructor(){super(),Object.defineProperty(this,"id",{value:fM++}),this.uuid=tn(),this.name="",this.type="BufferGeometry",this.index=null,this.attributes={},this.morphAttributes={},this.morphTargetsRelative=!1,this.groups=[],this.boundingBox=null,this.boundingSphere=null,this.drawRange={start:0,count:1/0},this.userData={}}getIndex(){return this.index}setIndex(t){return Array.isArray(t)?this.index=new(p0(t)?sl:rl)(t,1):this.index=t,this}getAttribute(t){return this.attributes[t]}setAttribute(t,e){return this.attributes[t]=e,this}deleteAttribute(t){return delete this.attributes[t],this}hasAttribute(t){return this.attributes[t]!==void 0}addGroup(t,e,i=0){this.groups.push({start:t,count:e,materialIndex:i})}clearGroups(){this.groups=[]}setDrawRange(t,e){this.drawRange.start=t,this.drawRange.count=e}applyMatrix4(t){let e=this.attributes.position;e!==void 0&&(e.applyMatrix4(t),e.needsUpdate=!0);let i=this.attributes.normal;if(i!==void 0){let s=new de().getNormalMatrix(t);i.applyNormalMatrix(s),i.needsUpdate=!0}let r=this.attributes.tangent;return r!==void 0&&(r.transformDirection(t),r.needsUpdate=!0),this.boundingBox!==null&&this.computeBoundingBox(),this.boundingSphere!==null&&this.computeBoundingSphere(),this}applyQuaternion(t){return qe.makeRotationFromQuaternion(t),this.applyMatrix4(qe),this}rotateX(t){return qe.makeRotationX(t),this.applyMatrix4(qe),this}rotateY(t){return qe.makeRotationY(t),this.applyMatrix4(qe),this}rotateZ(t){return qe.makeRotationZ(t),this.applyMatrix4(qe),this}translate(t,e,i){return qe.makeTranslation(t,e,i),this.applyMatrix4(qe),this}scale(t,e,i){return qe.makeScale(t,e,i),this.applyMatrix4(qe),this}lookAt(t){return vu.lookAt(t),vu.updateMatrix(),this.applyMatrix4(vu.matrix),this}center(){return this.computeBoundingBox(),this.boundingBox.getCenter(Mr).negate(),this.translate(Mr.x,Mr.y,Mr.z),this}setFromPoints(t){let e=[];for(let i=0,r=t.length;i<r;i++){let s=t[i];e.push(s.x,s.y,s.z||0)}return this.setAttribute("position",new ee(e,3)),this}computeBoundingBox(){this.boundingBox===null&&(this.boundingBox=new Ge);let t=this.attributes.position,e=this.morphAttributes.position;if(t&&t.isGLBufferAttribute){console.error('THREE.BufferGeometry.computeBoundingBox(): GLBufferAttribute requires a manual bounding box. Alternatively set "mesh.frustumCulled" to "false".',this),this.boundingBox.set(new T(-1/0,-1/0,-1/0),new T(1/0,1/0,1/0));return}if(t!==void 0){if(this.boundingBox.setFromBufferAttribute(t),e)for(let i=0,r=e.length;i<r;i++){let s=e[i];He.setFromBufferAttribute(s),this.morphTargetsRelative?(ge.addVectors(this.boundingBox.min,He.min),this.boundingBox.expandByPoint(ge),ge.addVectors(this.boundingBox.max,He.max),this.boundingBox.expandByPoint(ge)):(this.boundingBox.expandByPoint(He.min),this.boundingBox.expandByPoint(He.max))}}else this.boundingBox.makeEmpty();(isNaN(this.boundingBox.min.x)||isNaN(this.boundingBox.min.y)||isNaN(this.boundingBox.min.z))&&console.error('THREE.BufferGeometry.computeBoundingBox(): Computed min/max have NaN values. The "position" attribute is likely to have NaN values.',this)}computeBoundingSphere(){this.boundingSphere===null&&(this.boundingSphere=new si);let t=this.attributes.position,e=this.morphAttributes.position;if(t&&t.isGLBufferAttribute){console.error('THREE.BufferGeometry.computeBoundingSphere(): GLBufferAttribute requires a manual bounding sphere. Alternatively set "mesh.frustumCulled" to "false".',this),this.boundingSphere.set(new T,1/0);return}if(t){let i=this.boundingSphere.center;if(He.setFromBufferAttribute(t),e)for(let s=0,o=e.length;s<o;s++){let a=e[s];Vs.setFromBufferAttribute(a),this.morphTargetsRelative?(ge.addVectors(He.min,Vs.min),He.expandByPoint(ge),ge.addVectors(He.max,Vs.max),He.expandByPoint(ge)):(He.expandByPoint(Vs.min),He.expandByPoint(Vs.max))}He.getCenter(i);let r=0;for(let s=0,o=t.count;s<o;s++)ge.fromBufferAttribute(t,s),r=Math.max(r,i.distanceToSquared(ge));if(e)for(let s=0,o=e.length;s<o;s++){let a=e[s],l=this.morphTargetsRelative;for(let c=0,u=a.count;c<u;c++)ge.fromBufferAttribute(a,c),l&&(Mr.fromBufferAttribute(t,c),ge.add(Mr)),r=Math.max(r,i.distanceToSquared(ge))}this.boundingSphere.radius=Math.sqrt(r),isNaN(this.boundingSphere.radius)&&console.error('THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.',this)}}computeTangents(){let t=this.index,e=this.attributes;if(t===null||e.position===void 0||e.normal===void 0||e.uv===void 0){console.error("THREE.BufferGeometry: .computeTangents() failed. Missing required attributes (index, position, normal or uv)");return}let i=t.array,r=e.position.array,s=e.normal.array,o=e.uv.array,a=r.length/3;e.tangent===void 0&&this.setAttribute("tangent",new Qt(new Float32Array(4*a),4));let l=e.tangent.array,c=[],u=[];for(let X=0;X<a;X++)c[X]=new T,u[X]=new T;let h=new T,f=new T,d=new T,g=new K,x=new K,v=new K,m=new T,p=new T;function b(X,y,R){h.fromArray(r,X*3),f.fromArray(r,y*3),d.fromArray(r,R*3),g.fromArray(o,X*2),x.fromArray(o,y*2),v.fromArray(o,R*2),f.sub(h),d.sub(h),x.sub(g),v.sub(g);let D=1/(x.x*v.y-v.x*x.y);!isFinite(D)||(m.copy(f).multiplyScalar(v.y).addScaledVector(d,-x.y).multiplyScalar(D),p.copy(d).multiplyScalar(x.x).addScaledVector(f,-v.x).multiplyScalar(D),c[X].add(m),c[y].add(m),c[R].add(m),u[X].add(p),u[y].add(p),u[R].add(p))}let _=this.groups;_.length===0&&(_=[{start:0,count:i.length}]);for(let X=0,y=_.length;X<y;++X){let R=_[X],D=R.start,F=R.count;for(let z=D,N=D+F;z<N;z+=3)b(i[z+0],i[z+1],i[z+2])}let S=new T,L=new T,A=new T,H=new T;function tt(X){A.fromArray(s,X*3),H.copy(A);let y=c[X];S.copy(y),S.sub(A.multiplyScalar(A.dot(y))).normalize(),L.crossVectors(H,y);let D=L.dot(u[X])<0?-1:1;l[X*4]=S.x,l[X*4+1]=S.y,l[X*4+2]=S.z,l[X*4+3]=D}for(let X=0,y=_.length;X<y;++X){let R=_[X],D=R.start,F=R.count;for(let z=D,N=D+F;z<N;z+=3)tt(i[z+0]),tt(i[z+1]),tt(i[z+2])}}computeVertexNormals(){let t=this.index,e=this.getAttribute("position");if(e!==void 0){let i=this.getAttribute("normal");if(i===void 0)i=new Qt(new Float32Array(e.count*3),3),this.setAttribute("normal",i);else for(let f=0,d=i.count;f<d;f++)i.setXYZ(f,0,0,0);let r=new T,s=new T,o=new T,a=new T,l=new T,c=new T,u=new T,h=new T;if(t)for(let f=0,d=t.count;f<d;f+=3){let g=t.getX(f+0),x=t.getX(f+1),v=t.getX(f+2);r.fromBufferAttribute(e,g),s.fromBufferAttribute(e,x),o.fromBufferAttribute(e,v),u.subVectors(o,s),h.subVectors(r,s),u.cross(h),a.fromBufferAttribute(i,g),l.fromBufferAttribute(i,x),c.fromBufferAttribute(i,v),a.add(u),l.add(u),c.add(u),i.setXYZ(g,a.x,a.y,a.z),i.setXYZ(x,l.x,l.y,l.z),i.setXYZ(v,c.x,c.y,c.z)}else for(let f=0,d=e.count;f<d;f+=3)r.fromBufferAttribute(e,f+0),s.fromBufferAttribute(e,f+1),o.fromBufferAttribute(e,f+2),u.subVectors(o,s),h.subVectors(r,s),u.cross(h),i.setXYZ(f+0,u.x,u.y,u.z),i.setXYZ(f+1,u.x,u.y,u.z),i.setXYZ(f+2,u.x,u.y,u.z);this.normalizeNormals(),i.needsUpdate=!0}}merge(t,e){if(!(t&&t.isBufferGeometry)){console.error("THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.",t);return}e===void 0&&(e=0,console.warn("THREE.BufferGeometry.merge(): Overwriting original geometry, starting at offset=0. Use BufferGeometryUtils.mergeBufferGeometries() for lossless merge."));let i=this.attributes;for(let r in i){if(t.attributes[r]===void 0)continue;let o=i[r].array,a=t.attributes[r],l=a.array,c=a.itemSize*e,u=Math.min(l.length,o.length-c);for(let h=0,f=c;h<u;h++,f++)o[f]=l[h]}return this}normalizeNormals(){let t=this.attributes.normal;for(let e=0,i=t.count;e<i;e++)ge.fromBufferAttribute(t,e),ge.normalize(),t.setXYZ(e,ge.x,ge.y,ge.z)}toNonIndexed(){function t(a,l){let c=a.array,u=a.itemSize,h=a.normalized,f=new c.constructor(l.length*u),d=0,g=0;for(let x=0,v=l.length;x<v;x++){a.isInterleavedBufferAttribute?d=l[x]*a.data.stride+a.offset:d=l[x]*u;for(let m=0;m<u;m++)f[g++]=c[d++]}return new Qt(f,u,h)}if(this.index===null)return console.warn("THREE.BufferGeometry.toNonIndexed(): BufferGeometry is already non-indexed."),this;let e=new Ht,i=this.index.array,r=this.attributes;for(let a in r){let l=r[a],c=t(l,i);e.setAttribute(a,c)}let s=this.morphAttributes;for(let a in s){let l=[],c=s[a];for(let u=0,h=c.length;u<h;u++){let f=c[u],d=t(f,i);l.push(d)}e.morphAttributes[a]=l}e.morphTargetsRelative=this.morphTargetsRelative;let o=this.groups;for(let a=0,l=o.length;a<l;a++){let c=o[a];e.addGroup(c.start,c.count,c.materialIndex)}return e}toJSON(){let t={metadata:{version:4.5,type:"BufferGeometry",generator:"BufferGeometry.toJSON"}};if(t.uuid=this.uuid,t.type=this.type,this.name!==""&&(t.name=this.name),Object.keys(this.userData).length>0&&(t.userData=this.userData),this.parameters!==void 0){let l=this.parameters;for(let c in l)l[c]!==void 0&&(t[c]=l[c]);return t}t.data={attributes:{}};let e=this.index;e!==null&&(t.data.index={type:e.array.constructor.name,array:Array.prototype.slice.call(e.array)});let i=this.attributes;for(let l in i){let c=i[l];t.data.attributes[l]=c.toJSON(t.data)}let r={},s=!1;for(let l in this.morphAttributes){let c=this.morphAttributes[l],u=[];for(let h=0,f=c.length;h<f;h++){let d=c[h];u.push(d.toJSON(t.data))}u.length>0&&(r[l]=u,s=!0)}s&&(t.data.morphAttributes=r,t.data.morphTargetsRelative=this.morphTargetsRelative);let o=this.groups;o.length>0&&(t.data.groups=JSON.parse(JSON.stringify(o)));let a=this.boundingSphere;return a!==null&&(t.data.boundingSphere={center:a.center.toArray(),radius:a.radius}),t}clone(){return new this.constructor().copy(this)}copy(t){this.index=null,this.attributes={},this.morphAttributes={},this.groups=[],this.boundingBox=null,this.boundingSphere=null;let e={};this.name=t.name;let i=t.index;i!==null&&this.setIndex(i.clone(e));let r=t.attributes;for(let c in r){let u=r[c];this.setAttribute(c,u.clone(e))}let s=t.morphAttributes;for(let c in s){let u=[],h=s[c];for(let f=0,d=h.length;f<d;f++)u.push(h[f].clone(e));this.morphAttributes[c]=u}this.morphTargetsRelative=t.morphTargetsRelative;let o=t.groups;for(let c=0,u=o.length;c<u;c++){let h=o[c];this.addGroup(h.start,h.count,h.materialIndex)}let a=t.boundingBox;a!==null&&(this.boundingBox=a.clone());let l=t.boundingSphere;return l!==null&&(this.boundingSphere=l.clone()),this.drawRange.start=t.drawRange.start,this.drawRange.count=t.drawRange.count,this.userData=t.userData,t.parameters!==void 0&&(this.parameters=Object.assign({},t.parameters)),this}dispose(){this.dispatchEvent({type:"dispose"})}};Ht.prototype.isBufferGeometry=!0;var pg=new wt,br=new oi,_u=new si,Jn=new T,$n=new T,Kn=new T,wu=new T,Mu=new T,bu=new T,Ca=new T,Ra=new T,La=new T,Pa=new K,Da=new K,Ia=new K,Su=new T,Na=new T,oe=class extends kt{constructor(t=new Ht,e=new ki){super(),this.type="Mesh",this.geometry=t,this.material=e,this.updateMorphTargets()}copy(t){return super.copy(t),t.morphTargetInfluences!==void 0&&(this.morphTargetInfluences=t.morphTargetInfluences.slice()),t.morphTargetDictionary!==void 0&&(this.morphTargetDictionary=Object.assign({},t.morphTargetDictionary)),this.material=t.material,this.geometry=t.geometry,this}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let e=t.morphAttributes,i=Object.keys(e);if(i.length>0){let r=e[i[0]];if(r!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let s=0,o=r.length;s<o;s++){let a=r[s].name||String(s);this.morphTargetInfluences.push(0),this.morphTargetDictionary[a]=s}}}}else{let e=t.morphTargets;e!==void 0&&e.length>0&&console.error("THREE.Mesh.updateMorphTargets() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}}raycast(t,e){let i=this.geometry,r=this.material,s=this.matrixWorld;if(r===void 0||(i.boundingSphere===null&&i.computeBoundingSphere(),_u.copy(i.boundingSphere),_u.applyMatrix4(s),t.ray.intersectsSphere(_u)===!1)||(pg.copy(s).invert(),br.copy(t.ray).applyMatrix4(pg),i.boundingBox!==null&&br.intersectsBox(i.boundingBox)===!1))return;let o;if(i.isBufferGeometry){let a=i.index,l=i.attributes.position,c=i.morphAttributes.position,u=i.morphTargetsRelative,h=i.attributes.uv,f=i.attributes.uv2,d=i.groups,g=i.drawRange;if(a!==null)if(Array.isArray(r))for(let x=0,v=d.length;x<v;x++){let m=d[x],p=r[m.materialIndex],b=Math.max(m.start,g.start),_=Math.min(a.count,Math.min(m.start+m.count,g.start+g.count));for(let S=b,L=_;S<L;S+=3){let A=a.getX(S),H=a.getX(S+1),tt=a.getX(S+2);o=Fa(this,p,t,br,l,c,u,h,f,A,H,tt),o&&(o.faceIndex=Math.floor(S/3),o.face.materialIndex=m.materialIndex,e.push(o))}}else{let x=Math.max(0,g.start),v=Math.min(a.count,g.start+g.count);for(let m=x,p=v;m<p;m+=3){let b=a.getX(m),_=a.getX(m+1),S=a.getX(m+2);o=Fa(this,r,t,br,l,c,u,h,f,b,_,S),o&&(o.faceIndex=Math.floor(m/3),e.push(o))}}else if(l!==void 0)if(Array.isArray(r))for(let x=0,v=d.length;x<v;x++){let m=d[x],p=r[m.materialIndex],b=Math.max(m.start,g.start),_=Math.min(l.count,Math.min(m.start+m.count,g.start+g.count));for(let S=b,L=_;S<L;S+=3){let A=S,H=S+1,tt=S+2;o=Fa(this,p,t,br,l,c,u,h,f,A,H,tt),o&&(o.faceIndex=Math.floor(S/3),o.face.materialIndex=m.materialIndex,e.push(o))}}else{let x=Math.max(0,g.start),v=Math.min(l.count,g.start+g.count);for(let m=x,p=v;m<p;m+=3){let b=m,_=m+1,S=m+2;o=Fa(this,r,t,br,l,c,u,h,f,b,_,S),o&&(o.faceIndex=Math.floor(m/3),e.push(o))}}}else i.isGeometry&&console.error("THREE.Mesh.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}};oe.prototype.isMesh=!0;function dM(n,t,e,i,r,s,o,a){let l;if(t.side===he?l=i.intersectTriangle(o,s,r,!0,a):l=i.intersectTriangle(r,s,o,t.side!==Hr,a),l===null)return null;Na.copy(a),Na.applyMatrix4(n.matrixWorld);let c=e.ray.origin.distanceTo(Na);return c<e.near||c>e.far?null:{distance:c,point:Na.clone(),object:n}}function Fa(n,t,e,i,r,s,o,a,l,c,u,h){Jn.fromBufferAttribute(r,c),$n.fromBufferAttribute(r,u),Kn.fromBufferAttribute(r,h);let f=n.morphTargetInfluences;if(s&&f){Ca.set(0,0,0),Ra.set(0,0,0),La.set(0,0,0);for(let g=0,x=s.length;g<x;g++){let v=f[g],m=s[g];v!==0&&(wu.fromBufferAttribute(m,c),Mu.fromBufferAttribute(m,u),bu.fromBufferAttribute(m,h),o?(Ca.addScaledVector(wu,v),Ra.addScaledVector(Mu,v),La.addScaledVector(bu,v)):(Ca.addScaledVector(wu.sub(Jn),v),Ra.addScaledVector(Mu.sub($n),v),La.addScaledVector(bu.sub(Kn),v)))}Jn.add(Ca),$n.add(Ra),Kn.add(La)}n.isSkinnedMesh&&(n.boneTransform(c,Jn),n.boneTransform(u,$n),n.boneTransform(h,Kn));let d=dM(n,t,e,i,Jn,$n,Kn,Su);if(d){a&&(Pa.fromBufferAttribute(a,c),Da.fromBufferAttribute(a,u),Ia.fromBufferAttribute(a,h),d.uv=re.getUV(Su,Jn,$n,Kn,Pa,Da,Ia,new K)),l&&(Pa.fromBufferAttribute(l,c),Da.fromBufferAttribute(l,u),Ia.fromBufferAttribute(l,h),d.uv2=re.getUV(Su,Jn,$n,Kn,Pa,Da,Ia,new K));let g={a:c,b:u,c:h,normal:new T,materialIndex:0};re.getNormal(Jn,$n,Kn,g.normal),d.face=g}return d}var Hi=class extends Ht{constructor(t=1,e=1,i=1,r=1,s=1,o=1){super(),this.type="BoxGeometry",this.parameters={width:t,height:e,depth:i,widthSegments:r,heightSegments:s,depthSegments:o};let a=this;r=Math.floor(r),s=Math.floor(s),o=Math.floor(o);let l=[],c=[],u=[],h=[],f=0,d=0;g("z","y","x",-1,-1,i,e,t,o,s,0),g("z","y","x",1,-1,i,e,-t,o,s,1),g("x","z","y",1,1,t,i,e,r,o,2),g("x","z","y",1,-1,t,i,-e,r,o,3),g("x","y","z",1,-1,t,e,i,r,s,4),g("x","y","z",-1,-1,t,e,-i,r,s,5),this.setIndex(l),this.setAttribute("position",new ee(c,3)),this.setAttribute("normal",new ee(u,3)),this.setAttribute("uv",new ee(h,2));function g(x,v,m,p,b,_,S,L,A,H,tt){let X=_/A,y=S/H,R=_/2,D=S/2,F=L/2,z=A+1,N=H+1,V=0,Q=0,at=new T;for(let G=0;G<N;G++){let $=G*y-D;for(let lt=0;lt<z;lt++){let dt=lt*X-R;at[x]=dt*p,at[v]=$*b,at[m]=F,c.push(at.x,at.y,at.z),at[x]=0,at[v]=0,at[m]=L>0?1:-1,u.push(at.x,at.y,at.z),h.push(lt/A),h.push(1-G/H),V+=1}}for(let G=0;G<H;G++)for(let $=0;$<A;$++){let lt=f+$+z*G,dt=f+$+z*(G+1),xt=f+($+1)+z*(G+1),k=f+($+1)+z*G;l.push(lt,dt,k),l.push(dt,xt,k),Q+=6}a.addGroup(d,Q,tt),d+=Q,f+=V}}static fromJSON(t){return new Hi(t.width,t.height,t.depth,t.widthSegments,t.heightSegments,t.depthSegments)}};function Gr(n){let t={};for(let e in n){t[e]={};for(let i in n[e]){let r=n[e][i];r&&(r.isColor||r.isMatrix3||r.isMatrix4||r.isVector2||r.isVector3||r.isVector4||r.isTexture||r.isQuaternion)?t[e][i]=r.clone():Array.isArray(r)?t[e][i]=r.slice():t[e][i]=r}}return t}function Me(n){let t={};for(let e=0;e<n.length;e++){let i=Gr(n[e]);for(let r in i)t[r]=i[r]}return t}var pM={clone:Gr,merge:Me},mM=`void main() {
	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
}`,gM=`void main() {
	gl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );
}`,Fn=class extends xe{constructor(t){super(),this.type="ShaderMaterial",this.defines={},this.uniforms={},this.vertexShader=mM,this.fragmentShader=gM,this.linewidth=1,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.lights=!1,this.clipping=!1,this.extensions={derivatives:!1,fragDepth:!1,drawBuffers:!1,shaderTextureLOD:!1},this.defaultAttributeValues={color:[1,1,1],uv:[0,0],uv2:[0,0]},this.index0AttributeName=void 0,this.uniformsNeedUpdate=!1,this.glslVersion=null,t!==void 0&&(t.attributes!==void 0&&console.error("THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead."),this.setValues(t))}copy(t){return super.copy(t),this.fragmentShader=t.fragmentShader,this.vertexShader=t.vertexShader,this.uniforms=Gr(t.uniforms),this.defines=Object.assign({},t.defines),this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.lights=t.lights,this.clipping=t.clipping,this.extensions=Object.assign({},t.extensions),this.glslVersion=t.glslVersion,this}toJSON(t){let e=super.toJSON(t);e.glslVersion=this.glslVersion,e.uniforms={};for(let r in this.uniforms){let o=this.uniforms[r].value;o&&o.isTexture?e.uniforms[r]={type:"t",value:o.toJSON(t).uuid}:o&&o.isColor?e.uniforms[r]={type:"c",value:o.getHex()}:o&&o.isVector2?e.uniforms[r]={type:"v2",value:o.toArray()}:o&&o.isVector3?e.uniforms[r]={type:"v3",value:o.toArray()}:o&&o.isVector4?e.uniforms[r]={type:"v4",value:o.toArray()}:o&&o.isMatrix3?e.uniforms[r]={type:"m3",value:o.toArray()}:o&&o.isMatrix4?e.uniforms[r]={type:"m4",value:o.toArray()}:e.uniforms[r]={value:o}}Object.keys(this.defines).length>0&&(e.defines=this.defines),e.vertexShader=this.vertexShader,e.fragmentShader=this.fragmentShader;let i={};for(let r in this.extensions)this.extensions[r]===!0&&(i[r]=!0);return Object.keys(i).length>0&&(e.extensions=i),e}};Fn.prototype.isShaderMaterial=!0;var oo=class extends kt{constructor(){super(),this.type="Camera",this.matrixWorldInverse=new wt,this.projectionMatrix=new wt,this.projectionMatrixInverse=new wt}copy(t,e){return super.copy(t,e),this.matrixWorldInverse.copy(t.matrixWorldInverse),this.projectionMatrix.copy(t.projectionMatrix),this.projectionMatrixInverse.copy(t.projectionMatrixInverse),this}getWorldDirection(t){this.updateWorldMatrix(!0,!1);let e=this.matrixWorld.elements;return t.set(-e[8],-e[9],-e[10]).normalize()}updateMatrixWorld(t){super.updateMatrixWorld(t),this.matrixWorldInverse.copy(this.matrixWorld).invert()}updateWorldMatrix(t,e){super.updateWorldMatrix(t,e),this.matrixWorldInverse.copy(this.matrixWorld).invert()}clone(){return new this.constructor().copy(this)}};oo.prototype.isCamera=!0;var Se=class extends oo{constructor(t=50,e=1,i=.1,r=2e3){super(),this.type="PerspectiveCamera",this.fov=t,this.zoom=1,this.near=i,this.far=r,this.focus=10,this.aspect=e,this.view=null,this.filmGauge=35,this.filmOffset=0,this.updateProjectionMatrix()}copy(t,e){return super.copy(t,e),this.fov=t.fov,this.zoom=t.zoom,this.near=t.near,this.far=t.far,this.focus=t.focus,this.aspect=t.aspect,this.view=t.view===null?null:Object.assign({},t.view),this.filmGauge=t.filmGauge,this.filmOffset=t.filmOffset,this}setFocalLength(t){let e=.5*this.getFilmHeight()/t;this.fov=Vu*2*Math.atan(e),this.updateProjectionMatrix()}getFocalLength(){let t=Math.tan(iu*.5*this.fov);return .5*this.getFilmHeight()/t}getEffectiveFOV(){return Vu*2*Math.atan(Math.tan(iu*.5*this.fov)/this.zoom)}getFilmWidth(){return this.filmGauge*Math.min(this.aspect,1)}getFilmHeight(){return this.filmGauge/Math.max(this.aspect,1)}setViewOffset(t,e,i,r,s,o){this.aspect=t/e,this.view===null&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=e,this.view.offsetX=i,this.view.offsetY=r,this.view.width=s,this.view.height=o,this.updateProjectionMatrix()}clearViewOffset(){this.view!==null&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let t=this.near,e=t*Math.tan(iu*.5*this.fov)/this.zoom,i=2*e,r=this.aspect*i,s=-.5*r,o=this.view;if(this.view!==null&&this.view.enabled){let l=o.fullWidth,c=o.fullHeight;s+=o.offsetX*r/l,e-=o.offsetY*i/c,r*=o.width/l,i*=o.height/c}let a=this.filmOffset;a!==0&&(s+=t*a/this.getFilmWidth()),this.projectionMatrix.makePerspective(s,s+r,e,e-i,t,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){let e=super.toJSON(t);return e.object.fov=this.fov,e.object.zoom=this.zoom,e.object.near=this.near,e.object.far=this.far,e.object.focus=this.focus,e.object.aspect=this.aspect,this.view!==null&&(e.object.view=Object.assign({},this.view)),e.object.filmGauge=this.filmGauge,e.object.filmOffset=this.filmOffset,e}};Se.prototype.isPerspectiveCamera=!0;var Sr=90,Er=1,ao=class extends kt{constructor(t,e,i){if(super(),this.type="CubeCamera",i.isWebGLCubeRenderTarget!==!0){console.error("THREE.CubeCamera: The constructor now expects an instance of WebGLCubeRenderTarget as third parameter.");return}this.renderTarget=i;let r=new Se(Sr,Er,t,e);r.layers=this.layers,r.up.set(0,-1,0),r.lookAt(new T(1,0,0)),this.add(r);let s=new Se(Sr,Er,t,e);s.layers=this.layers,s.up.set(0,-1,0),s.lookAt(new T(-1,0,0)),this.add(s);let o=new Se(Sr,Er,t,e);o.layers=this.layers,o.up.set(0,0,1),o.lookAt(new T(0,1,0)),this.add(o);let a=new Se(Sr,Er,t,e);a.layers=this.layers,a.up.set(0,0,-1),a.lookAt(new T(0,-1,0)),this.add(a);let l=new Se(Sr,Er,t,e);l.layers=this.layers,l.up.set(0,-1,0),l.lookAt(new T(0,0,1)),this.add(l);let c=new Se(Sr,Er,t,e);c.layers=this.layers,c.up.set(0,-1,0),c.lookAt(new T(0,0,-1)),this.add(c)}update(t,e){this.parent===null&&this.updateMatrixWorld();let i=this.renderTarget,[r,s,o,a,l,c]=this.children,u=t.xr.enabled,h=t.getRenderTarget();t.xr.enabled=!1;let f=i.texture.generateMipmaps;i.texture.generateMipmaps=!1,t.setRenderTarget(i,0),t.render(e,r),t.setRenderTarget(i,1),t.render(e,s),t.setRenderTarget(i,2),t.render(e,o),t.setRenderTarget(i,3),t.render(e,a),t.setRenderTarget(i,4),t.render(e,l),i.texture.generateMipmaps=f,t.setRenderTarget(i,5),t.render(e,c),t.setRenderTarget(h),t.xr.enabled=u,i.texture.needsPMREMUpdate=!0}},Wr=class extends ae{constructor(t,e,i,r,s,o,a,l,c,u){t=t!==void 0?t:[],e=e!==void 0?e:Ao,super(t,e,i,r,s,o,a,l,c,u),this.flipY=!1}get images(){return this.image}set images(t){this.image=t}};Wr.prototype.isCubeTexture=!0;var ol=class extends Ne{constructor(t,e,i){Number.isInteger(e)&&(console.warn("THREE.WebGLCubeRenderTarget: constructor signature is now WebGLCubeRenderTarget( size, options )"),e=i),super(t,t,e),e=e||{},this.texture=new Wr(void 0,e.mapping,e.wrapS,e.wrapT,e.magFilter,e.minFilter,e.format,e.type,e.anisotropy,e.encoding),this.texture.isRenderTargetTexture=!0,this.texture.generateMipmaps=e.generateMipmaps!==void 0?e.generateMipmaps:!1,this.texture.minFilter=e.minFilter!==void 0?e.minFilter:be}fromEquirectangularTexture(t,e){this.texture.type=e.type,this.texture.format=Re,this.texture.encoding=e.encoding,this.texture.generateMipmaps=e.generateMipmaps,this.texture.minFilter=e.minFilter,this.texture.magFilter=e.magFilter;let i={uniforms:{tEquirect:{value:null}},vertexShader:`

				varying vec3 vWorldDirection;

				vec3 transformDirection( in vec3 dir, in mat4 matrix ) {

					return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );

				}

				void main() {

					vWorldDirection = transformDirection( position, modelMatrix );

					#include <begin_vertex>
					#include <project_vertex>

				}
			`,fragmentShader:`

				uniform sampler2D tEquirect;

				varying vec3 vWorldDirection;

				#include <common>

				void main() {

					vec3 direction = normalize( vWorldDirection );

					vec2 sampleUV = equirectUv( direction );

					gl_FragColor = texture2D( tEquirect, sampleUV );

				}
			`},r=new Hi(5,5,5),s=new Fn({name:"CubemapFromEquirect",uniforms:Gr(i.uniforms),vertexShader:i.vertexShader,fragmentShader:i.fragmentShader,side:he,blending:jn});s.uniforms.tEquirect.value=e;let o=new oe(r,s),a=e.minFilter;return e.minFilter===Ll&&(e.minFilter=be),new ao(1,10,this).update(t,o),e.minFilter=a,o.geometry.dispose(),o.material.dispose(),this}clear(t,e,i,r){let s=t.getRenderTarget();for(let o=0;o<6;o++)t.setRenderTarget(this,o),t.clear(e,i,r);t.setRenderTarget(s)}};ol.prototype.isWebGLCubeRenderTarget=!0;var Eu=new T,xM=new T,yM=new de,je=class{constructor(t=new T(1,0,0),e=0){this.normal=t,this.constant=e}set(t,e){return this.normal.copy(t),this.constant=e,this}setComponents(t,e,i,r){return this.normal.set(t,e,i),this.constant=r,this}setFromNormalAndCoplanarPoint(t,e){return this.normal.copy(t),this.constant=-e.dot(this.normal),this}setFromCoplanarPoints(t,e,i){let r=Eu.subVectors(i,e).cross(xM.subVectors(t,e)).normalize();return this.setFromNormalAndCoplanarPoint(r,t),this}copy(t){return this.normal.copy(t.normal),this.constant=t.constant,this}normalize(){let t=1/this.normal.length();return this.normal.multiplyScalar(t),this.constant*=t,this}negate(){return this.constant*=-1,this.normal.negate(),this}distanceToPoint(t){return this.normal.dot(t)+this.constant}distanceToSphere(t){return this.distanceToPoint(t.center)-t.radius}projectPoint(t,e){return e.copy(this.normal).multiplyScalar(-this.distanceToPoint(t)).add(t)}intersectLine(t,e){let i=t.delta(Eu),r=this.normal.dot(i);if(r===0)return this.distanceToPoint(t.start)===0?e.copy(t.start):null;let s=-(t.start.dot(this.normal)+this.constant)/r;return s<0||s>1?null:e.copy(i).multiplyScalar(s).add(t.start)}intersectsLine(t){let e=this.distanceToPoint(t.start),i=this.distanceToPoint(t.end);return e<0&&i>0||i<0&&e>0}intersectsBox(t){return t.intersectsPlane(this)}intersectsSphere(t){return t.intersectsPlane(this)}coplanarPoint(t){return t.copy(this.normal).multiplyScalar(-this.constant)}applyMatrix4(t,e){let i=e||yM.getNormalMatrix(t),r=this.coplanarPoint(Eu).applyMatrix4(t),s=this.normal.applyMatrix3(i).normalize();return this.constant=-r.dot(s),this}translate(t){return this.constant-=t.dot(this.normal),this}equals(t){return t.normal.equals(this.normal)&&t.constant===this.constant}clone(){return new this.constructor().copy(this)}};je.prototype.isPlane=!0;var Tr=new si,za=new T,qr=class{constructor(t=new je,e=new je,i=new je,r=new je,s=new je,o=new je){this.planes=[t,e,i,r,s,o]}set(t,e,i,r,s,o){let a=this.planes;return a[0].copy(t),a[1].copy(e),a[2].copy(i),a[3].copy(r),a[4].copy(s),a[5].copy(o),this}copy(t){let e=this.planes;for(let i=0;i<6;i++)e[i].copy(t.planes[i]);return this}setFromProjectionMatrix(t){let e=this.planes,i=t.elements,r=i[0],s=i[1],o=i[2],a=i[3],l=i[4],c=i[5],u=i[6],h=i[7],f=i[8],d=i[9],g=i[10],x=i[11],v=i[12],m=i[13],p=i[14],b=i[15];return e[0].setComponents(a-r,h-l,x-f,b-v).normalize(),e[1].setComponents(a+r,h+l,x+f,b+v).normalize(),e[2].setComponents(a+s,h+c,x+d,b+m).normalize(),e[3].setComponents(a-s,h-c,x-d,b-m).normalize(),e[4].setComponents(a-o,h-u,x-g,b-p).normalize(),e[5].setComponents(a+o,h+u,x+g,b+p).normalize(),this}intersectsObject(t){let e=t.geometry;return e.boundingSphere===null&&e.computeBoundingSphere(),Tr.copy(e.boundingSphere).applyMatrix4(t.matrixWorld),this.intersectsSphere(Tr)}intersectsSprite(t){return Tr.center.set(0,0,0),Tr.radius=.7071067811865476,Tr.applyMatrix4(t.matrixWorld),this.intersectsSphere(Tr)}intersectsSphere(t){let e=this.planes,i=t.center,r=-t.radius;for(let s=0;s<6;s++)if(e[s].distanceToPoint(i)<r)return!1;return!0}intersectsBox(t){let e=this.planes;for(let i=0;i<6;i++){let r=e[i];if(za.x=r.normal.x>0?t.max.x:t.min.x,za.y=r.normal.y>0?t.max.y:t.min.y,za.z=r.normal.z>0?t.max.z:t.min.z,r.distanceToPoint(za)<0)return!1}return!0}containsPoint(t){let e=this.planes;for(let i=0;i<6;i++)if(e[i].distanceToPoint(t)<0)return!1;return!0}clone(){return new this.constructor().copy(this)}};function g0(){let n=null,t=!1,e=null,i=null;function r(s,o){e(s,o),i=n.requestAnimationFrame(r)}return{start:function(){t!==!0&&e!==null&&(i=n.requestAnimationFrame(r),t=!0)},stop:function(){n.cancelAnimationFrame(i),t=!1},setAnimationLoop:function(s){e=s},setContext:function(s){n=s}}}function vM(n,t){let e=t.isWebGL2,i=new WeakMap;function r(c,u){let h=c.array,f=c.usage,d=n.createBuffer();n.bindBuffer(u,d),n.bufferData(u,h,f),c.onUploadCallback();let g=5126;return h instanceof Float32Array?g=5126:h instanceof Float64Array?console.warn("THREE.WebGLAttributes: Unsupported data buffer format: Float64Array."):h instanceof Uint16Array?c.isFloat16BufferAttribute?e?g=5131:console.warn("THREE.WebGLAttributes: Usage of Float16BufferAttribute requires WebGL2."):g=5123:h instanceof Int16Array?g=5122:h instanceof Uint32Array?g=5125:h instanceof Int32Array?g=5124:h instanceof Int8Array?g=5120:(h instanceof Uint8Array||h instanceof Uint8ClampedArray)&&(g=5121),{buffer:d,type:g,bytesPerElement:h.BYTES_PER_ELEMENT,version:c.version}}function s(c,u,h){let f=u.array,d=u.updateRange;n.bindBuffer(h,c),d.count===-1?n.bufferSubData(h,0,f):(e?n.bufferSubData(h,d.offset*f.BYTES_PER_ELEMENT,f,d.offset,d.count):n.bufferSubData(h,d.offset*f.BYTES_PER_ELEMENT,f.subarray(d.offset,d.offset+d.count)),d.count=-1)}function o(c){return c.isInterleavedBufferAttribute&&(c=c.data),i.get(c)}function a(c){c.isInterleavedBufferAttribute&&(c=c.data);let u=i.get(c);u&&(n.deleteBuffer(u.buffer),i.delete(c))}function l(c,u){if(c.isGLBufferAttribute){let f=i.get(c);(!f||f.version<c.version)&&i.set(c,{buffer:c.buffer,type:c.type,bytesPerElement:c.elementSize,version:c.version});return}c.isInterleavedBufferAttribute&&(c=c.data);let h=i.get(c);h===void 0?i.set(c,r(c,u)):h.version<c.version&&(s(h.buffer,c,u),h.version=c.version)}return{get:o,remove:a,update:l}}var lo=class extends Ht{constructor(t=1,e=1,i=1,r=1){super(),this.type="PlaneGeometry",this.parameters={width:t,height:e,widthSegments:i,heightSegments:r};let s=t/2,o=e/2,a=Math.floor(i),l=Math.floor(r),c=a+1,u=l+1,h=t/a,f=e/l,d=[],g=[],x=[],v=[];for(let m=0;m<u;m++){let p=m*f-o;for(let b=0;b<c;b++){let _=b*h-s;g.push(_,-p,0),x.push(0,0,1),v.push(b/a),v.push(1-m/l)}}for(let m=0;m<l;m++)for(let p=0;p<a;p++){let b=p+c*m,_=p+c*(m+1),S=p+1+c*(m+1),L=p+1+c*m;d.push(b,_,L),d.push(_,S,L)}this.setIndex(d),this.setAttribute("position",new ee(g,3)),this.setAttribute("normal",new ee(x,3)),this.setAttribute("uv",new ee(v,2))}static fromJSON(t){return new lo(t.width,t.height,t.widthSegments,t.heightSegments)}},_M=`#ifdef USE_ALPHAMAP
	diffuseColor.a *= texture2D( alphaMap, vUv ).g;
#endif`,wM=`#ifdef USE_ALPHAMAP
	uniform sampler2D alphaMap;
#endif`,MM=`#ifdef USE_ALPHATEST
	if ( diffuseColor.a < alphaTest ) discard;
#endif`,bM=`#ifdef USE_ALPHATEST
	uniform float alphaTest;
#endif`,SM=`#ifdef USE_AOMAP
	float ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;
	reflectedLight.indirectDiffuse *= ambientOcclusion;
	#if defined( USE_ENVMAP ) && defined( STANDARD )
		float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );
		reflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.roughness );
	#endif
#endif`,EM=`#ifdef USE_AOMAP
	uniform sampler2D aoMap;
	uniform float aoMapIntensity;
#endif`,TM="vec3 transformed = vec3( position );",AM=`vec3 objectNormal = vec3( normal );
#ifdef USE_TANGENT
	vec3 objectTangent = vec3( tangent.xyz );
#endif`,CM=`vec3 BRDF_Lambert( const in vec3 diffuseColor ) {
	return RECIPROCAL_PI * diffuseColor;
}
vec3 F_Schlick( const in vec3 f0, const in float f90, const in float dotVH ) {
	float fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );
	return f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );
}
float V_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {
	float a2 = pow2( alpha );
	float gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );
	float gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );
	return 0.5 / max( gv + gl, EPSILON );
}
float D_GGX( const in float alpha, const in float dotNH ) {
	float a2 = pow2( alpha );
	float denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;
	return RECIPROCAL_PI * a2 / pow2( denom );
}
vec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 f0, const in float f90, const in float roughness ) {
	float alpha = pow2( roughness );
	vec3 halfDir = normalize( lightDir + viewDir );
	float dotNL = saturate( dot( normal, lightDir ) );
	float dotNV = saturate( dot( normal, viewDir ) );
	float dotNH = saturate( dot( normal, halfDir ) );
	float dotVH = saturate( dot( viewDir, halfDir ) );
	vec3 F = F_Schlick( f0, f90, dotVH );
	float V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );
	float D = D_GGX( alpha, dotNH );
	return F * ( V * D );
}
vec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {
	const float LUT_SIZE = 64.0;
	const float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;
	const float LUT_BIAS = 0.5 / LUT_SIZE;
	float dotNV = saturate( dot( N, V ) );
	vec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );
	uv = uv * LUT_SCALE + LUT_BIAS;
	return uv;
}
float LTC_ClippedSphereFormFactor( const in vec3 f ) {
	float l = length( f );
	return max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );
}
vec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {
	float x = dot( v1, v2 );
	float y = abs( x );
	float a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;
	float b = 3.4175940 + ( 4.1616724 + y ) * y;
	float v = a / b;
	float theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;
	return cross( v1, v2 ) * theta_sintheta;
}
vec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {
	vec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];
	vec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];
	vec3 lightNormal = cross( v1, v2 );
	if( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );
	vec3 T1, T2;
	T1 = normalize( V - N * dot( V, N ) );
	T2 = - cross( N, T1 );
	mat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );
	vec3 coords[ 4 ];
	coords[ 0 ] = mat * ( rectCoords[ 0 ] - P );
	coords[ 1 ] = mat * ( rectCoords[ 1 ] - P );
	coords[ 2 ] = mat * ( rectCoords[ 2 ] - P );
	coords[ 3 ] = mat * ( rectCoords[ 3 ] - P );
	coords[ 0 ] = normalize( coords[ 0 ] );
	coords[ 1 ] = normalize( coords[ 1 ] );
	coords[ 2 ] = normalize( coords[ 2 ] );
	coords[ 3 ] = normalize( coords[ 3 ] );
	vec3 vectorFormFactor = vec3( 0.0 );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );
	float result = LTC_ClippedSphereFormFactor( vectorFormFactor );
	return vec3( result );
}
float G_BlinnPhong_Implicit( ) {
	return 0.25;
}
float D_BlinnPhong( const in float shininess, const in float dotNH ) {
	return RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );
}
vec3 BRDF_BlinnPhong( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float shininess ) {
	vec3 halfDir = normalize( lightDir + viewDir );
	float dotNH = saturate( dot( normal, halfDir ) );
	float dotVH = saturate( dot( viewDir, halfDir ) );
	vec3 F = F_Schlick( specularColor, 1.0, dotVH );
	float G = G_BlinnPhong_Implicit( );
	float D = D_BlinnPhong( shininess, dotNH );
	return F * ( G * D );
}
#if defined( USE_SHEEN )
float D_Charlie( float roughness, float dotNH ) {
	float alpha = pow2( roughness );
	float invAlpha = 1.0 / alpha;
	float cos2h = dotNH * dotNH;
	float sin2h = max( 1.0 - cos2h, 0.0078125 );
	return ( 2.0 + invAlpha ) * pow( sin2h, invAlpha * 0.5 ) / ( 2.0 * PI );
}
float V_Neubelt( float dotNV, float dotNL ) {
	return saturate( 1.0 / ( 4.0 * ( dotNL + dotNV - dotNL * dotNV ) ) );
}
vec3 BRDF_Sheen( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, vec3 sheenColor, const in float sheenRoughness ) {
	vec3 halfDir = normalize( lightDir + viewDir );
	float dotNL = saturate( dot( normal, lightDir ) );
	float dotNV = saturate( dot( normal, viewDir ) );
	float dotNH = saturate( dot( normal, halfDir ) );
	float D = D_Charlie( sheenRoughness, dotNH );
	float V = V_Neubelt( dotNV, dotNL );
	return sheenColor * ( D * V );
}
#endif`,RM=`#ifdef USE_BUMPMAP
	uniform sampler2D bumpMap;
	uniform float bumpScale;
	vec2 dHdxy_fwd() {
		vec2 dSTdx = dFdx( vUv );
		vec2 dSTdy = dFdy( vUv );
		float Hll = bumpScale * texture2D( bumpMap, vUv ).x;
		float dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;
		float dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;
		return vec2( dBx, dBy );
	}
	vec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy, float faceDirection ) {
		vec3 vSigmaX = vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );
		vec3 vSigmaY = vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );
		vec3 vN = surf_norm;
		vec3 R1 = cross( vSigmaY, vN );
		vec3 R2 = cross( vN, vSigmaX );
		float fDet = dot( vSigmaX, R1 ) * faceDirection;
		vec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );
		return normalize( abs( fDet ) * surf_norm - vGrad );
	}
#endif`,LM=`#if NUM_CLIPPING_PLANES > 0
	vec4 plane;
	#pragma unroll_loop_start
	for ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {
		plane = clippingPlanes[ i ];
		if ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;
	}
	#pragma unroll_loop_end
	#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES
		bool clipped = true;
		#pragma unroll_loop_start
		for ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {
			plane = clippingPlanes[ i ];
			clipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;
		}
		#pragma unroll_loop_end
		if ( clipped ) discard;
	#endif
#endif`,PM=`#if NUM_CLIPPING_PLANES > 0
	varying vec3 vClipPosition;
	uniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];
#endif`,DM=`#if NUM_CLIPPING_PLANES > 0
	varying vec3 vClipPosition;
#endif`,IM=`#if NUM_CLIPPING_PLANES > 0
	vClipPosition = - mvPosition.xyz;
#endif`,NM=`#if defined( USE_COLOR_ALPHA )
	diffuseColor *= vColor;
#elif defined( USE_COLOR )
	diffuseColor.rgb *= vColor;
#endif`,FM=`#if defined( USE_COLOR_ALPHA )
	varying vec4 vColor;
#elif defined( USE_COLOR )
	varying vec3 vColor;
#endif`,zM=`#if defined( USE_COLOR_ALPHA )
	varying vec4 vColor;
#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
	varying vec3 vColor;
#endif`,UM=`#if defined( USE_COLOR_ALPHA )
	vColor = vec4( 1.0 );
#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
	vColor = vec3( 1.0 );
#endif
#ifdef USE_COLOR
	vColor *= color;
#endif
#ifdef USE_INSTANCING_COLOR
	vColor.xyz *= instanceColor.xyz;
#endif`,BM=`#define PI 3.141592653589793
#define PI2 6.283185307179586
#define PI_HALF 1.5707963267948966
#define RECIPROCAL_PI 0.3183098861837907
#define RECIPROCAL_PI2 0.15915494309189535
#define EPSILON 1e-6
#ifndef saturate
#define saturate( a ) clamp( a, 0.0, 1.0 )
#endif
#define whiteComplement( a ) ( 1.0 - saturate( a ) )
float pow2( const in float x ) { return x*x; }
float pow3( const in float x ) { return x*x*x; }
float pow4( const in float x ) { float x2 = x*x; return x2*x2; }
float max3( const in vec3 v ) { return max( max( v.x, v.y ), v.z ); }
float average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }
highp float rand( const in vec2 uv ) {
	const highp float a = 12.9898, b = 78.233, c = 43758.5453;
	highp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );
	return fract( sin( sn ) * c );
}
#ifdef HIGH_PRECISION
	float precisionSafeLength( vec3 v ) { return length( v ); }
#else
	float precisionSafeLength( vec3 v ) {
		float maxComponent = max3( abs( v ) );
		return length( v / maxComponent ) * maxComponent;
	}
#endif
struct IncidentLight {
	vec3 color;
	vec3 direction;
	bool visible;
};
struct ReflectedLight {
	vec3 directDiffuse;
	vec3 directSpecular;
	vec3 indirectDiffuse;
	vec3 indirectSpecular;
};
struct GeometricContext {
	vec3 position;
	vec3 normal;
	vec3 viewDir;
#ifdef USE_CLEARCOAT
	vec3 clearcoatNormal;
#endif
};
vec3 transformDirection( in vec3 dir, in mat4 matrix ) {
	return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );
}
vec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {
	return normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );
}
mat3 transposeMat3( const in mat3 m ) {
	mat3 tmp;
	tmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );
	tmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );
	tmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );
	return tmp;
}
float linearToRelativeLuminance( const in vec3 color ) {
	vec3 weights = vec3( 0.2126, 0.7152, 0.0722 );
	return dot( weights, color.rgb );
}
bool isPerspectiveMatrix( mat4 m ) {
	return m[ 2 ][ 3 ] == - 1.0;
}
vec2 equirectUv( in vec3 dir ) {
	float u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;
	float v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;
	return vec2( u, v );
}`,OM=`#ifdef ENVMAP_TYPE_CUBE_UV
	#define cubeUV_maxMipLevel 8.0
	#define cubeUV_minMipLevel 4.0
	#define cubeUV_maxTileSize 256.0
	#define cubeUV_minTileSize 16.0
	float getFace( vec3 direction ) {
		vec3 absDirection = abs( direction );
		float face = - 1.0;
		if ( absDirection.x > absDirection.z ) {
			if ( absDirection.x > absDirection.y )
				face = direction.x > 0.0 ? 0.0 : 3.0;
			else
				face = direction.y > 0.0 ? 1.0 : 4.0;
		} else {
			if ( absDirection.z > absDirection.y )
				face = direction.z > 0.0 ? 2.0 : 5.0;
			else
				face = direction.y > 0.0 ? 1.0 : 4.0;
		}
		return face;
	}
	vec2 getUV( vec3 direction, float face ) {
		vec2 uv;
		if ( face == 0.0 ) {
			uv = vec2( direction.z, direction.y ) / abs( direction.x );
		} else if ( face == 1.0 ) {
			uv = vec2( - direction.x, - direction.z ) / abs( direction.y );
		} else if ( face == 2.0 ) {
			uv = vec2( - direction.x, direction.y ) / abs( direction.z );
		} else if ( face == 3.0 ) {
			uv = vec2( - direction.z, direction.y ) / abs( direction.x );
		} else if ( face == 4.0 ) {
			uv = vec2( - direction.x, direction.z ) / abs( direction.y );
		} else {
			uv = vec2( direction.x, direction.y ) / abs( direction.z );
		}
		return 0.5 * ( uv + 1.0 );
	}
	vec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {
		float face = getFace( direction );
		float filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );
		mipInt = max( mipInt, cubeUV_minMipLevel );
		float faceSize = exp2( mipInt );
		float texelSize = 1.0 / ( 3.0 * cubeUV_maxTileSize );
		vec2 uv = getUV( direction, face ) * ( faceSize - 1.0 ) + 0.5;
		if ( face > 2.0 ) {
			uv.y += faceSize;
			face -= 3.0;
		}
		uv.x += face * faceSize;
		if ( mipInt < cubeUV_maxMipLevel ) {
			uv.y += 2.0 * cubeUV_maxTileSize;
		}
		uv.y += filterInt * 2.0 * cubeUV_minTileSize;
		uv.x += 3.0 * max( 0.0, cubeUV_maxTileSize - 2.0 * faceSize );
		uv *= texelSize;
		return texture2D( envMap, uv ).rgb;
	}
	#define r0 1.0
	#define v0 0.339
	#define m0 - 2.0
	#define r1 0.8
	#define v1 0.276
	#define m1 - 1.0
	#define r4 0.4
	#define v4 0.046
	#define m4 2.0
	#define r5 0.305
	#define v5 0.016
	#define m5 3.0
	#define r6 0.21
	#define v6 0.0038
	#define m6 4.0
	float roughnessToMip( float roughness ) {
		float mip = 0.0;
		if ( roughness >= r1 ) {
			mip = ( r0 - roughness ) * ( m1 - m0 ) / ( r0 - r1 ) + m0;
		} else if ( roughness >= r4 ) {
			mip = ( r1 - roughness ) * ( m4 - m1 ) / ( r1 - r4 ) + m1;
		} else if ( roughness >= r5 ) {
			mip = ( r4 - roughness ) * ( m5 - m4 ) / ( r4 - r5 ) + m4;
		} else if ( roughness >= r6 ) {
			mip = ( r5 - roughness ) * ( m6 - m5 ) / ( r5 - r6 ) + m5;
		} else {
			mip = - 2.0 * log2( 1.16 * roughness );		}
		return mip;
	}
	vec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {
		float mip = clamp( roughnessToMip( roughness ), m0, cubeUV_maxMipLevel );
		float mipF = fract( mip );
		float mipInt = floor( mip );
		vec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );
		if ( mipF == 0.0 ) {
			return vec4( color0, 1.0 );
		} else {
			vec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );
			return vec4( mix( color0, color1, mipF ), 1.0 );
		}
	}
#endif`,kM=`vec3 transformedNormal = objectNormal;
#ifdef USE_INSTANCING
	mat3 m = mat3( instanceMatrix );
	transformedNormal /= vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) );
	transformedNormal = m * transformedNormal;
#endif
transformedNormal = normalMatrix * transformedNormal;
#ifdef FLIP_SIDED
	transformedNormal = - transformedNormal;
#endif
#ifdef USE_TANGENT
	vec3 transformedTangent = ( modelViewMatrix * vec4( objectTangent, 0.0 ) ).xyz;
	#ifdef FLIP_SIDED
		transformedTangent = - transformedTangent;
	#endif
#endif`,HM=`#ifdef USE_DISPLACEMENTMAP
	uniform sampler2D displacementMap;
	uniform float displacementScale;
	uniform float displacementBias;
#endif`,VM=`#ifdef USE_DISPLACEMENTMAP
	transformed += normalize( objectNormal ) * ( texture2D( displacementMap, vUv ).x * displacementScale + displacementBias );
#endif`,GM=`#ifdef USE_EMISSIVEMAP
	vec4 emissiveColor = texture2D( emissiveMap, vUv );
	totalEmissiveRadiance *= emissiveColor.rgb;
#endif`,WM=`#ifdef USE_EMISSIVEMAP
	uniform sampler2D emissiveMap;
#endif`,qM="gl_FragColor = linearToOutputTexel( gl_FragColor );",XM=`vec4 LinearToLinear( in vec4 value ) {
	return value;
}
vec4 LinearTosRGB( in vec4 value ) {
	return vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );
}`,YM=`#ifdef USE_ENVMAP
	#ifdef ENV_WORLDPOS
		vec3 cameraToFrag;
		if ( isOrthographic ) {
			cameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );
		} else {
			cameraToFrag = normalize( vWorldPosition - cameraPosition );
		}
		vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
		#ifdef ENVMAP_MODE_REFLECTION
			vec3 reflectVec = reflect( cameraToFrag, worldNormal );
		#else
			vec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );
		#endif
	#else
		vec3 reflectVec = vReflect;
	#endif
	#ifdef ENVMAP_TYPE_CUBE
		vec4 envColor = textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );
	#elif defined( ENVMAP_TYPE_CUBE_UV )
		vec4 envColor = textureCubeUV( envMap, reflectVec, 0.0 );
	#else
		vec4 envColor = vec4( 0.0 );
	#endif
	#ifdef ENVMAP_BLENDING_MULTIPLY
		outgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );
	#elif defined( ENVMAP_BLENDING_MIX )
		outgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );
	#elif defined( ENVMAP_BLENDING_ADD )
		outgoingLight += envColor.xyz * specularStrength * reflectivity;
	#endif
#endif`,ZM=`#ifdef USE_ENVMAP
	uniform float envMapIntensity;
	uniform float flipEnvMap;
	#ifdef ENVMAP_TYPE_CUBE
		uniform samplerCube envMap;
	#else
		uniform sampler2D envMap;
	#endif
	
#endif`,JM=`#ifdef USE_ENVMAP
	uniform float reflectivity;
	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )
		#define ENV_WORLDPOS
	#endif
	#ifdef ENV_WORLDPOS
		varying vec3 vWorldPosition;
		uniform float refractionRatio;
	#else
		varying vec3 vReflect;
	#endif
#endif`,$M=`#ifdef USE_ENVMAP
	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) ||defined( PHONG )
		#define ENV_WORLDPOS
	#endif
	#ifdef ENV_WORLDPOS
		
		varying vec3 vWorldPosition;
	#else
		varying vec3 vReflect;
		uniform float refractionRatio;
	#endif
#endif`,KM=`#ifdef USE_ENVMAP
	#ifdef ENV_WORLDPOS
		vWorldPosition = worldPosition.xyz;
	#else
		vec3 cameraToVertex;
		if ( isOrthographic ) {
			cameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );
		} else {
			cameraToVertex = normalize( worldPosition.xyz - cameraPosition );
		}
		vec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
		#ifdef ENVMAP_MODE_REFLECTION
			vReflect = reflect( cameraToVertex, worldNormal );
		#else
			vReflect = refract( cameraToVertex, worldNormal, refractionRatio );
		#endif
	#endif
#endif`,QM=`#ifdef USE_FOG
	vFogDepth = - mvPosition.z;
#endif`,jM=`#ifdef USE_FOG
	varying float vFogDepth;
#endif`,tb=`#ifdef USE_FOG
	#ifdef FOG_EXP2
		float fogFactor = 1.0 - exp( - fogDensity * fogDensity * vFogDepth * vFogDepth );
	#else
		float fogFactor = smoothstep( fogNear, fogFar, vFogDepth );
	#endif
	gl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );
#endif`,eb=`#ifdef USE_FOG
	uniform vec3 fogColor;
	varying float vFogDepth;
	#ifdef FOG_EXP2
		uniform float fogDensity;
	#else
		uniform float fogNear;
		uniform float fogFar;
	#endif
#endif`,nb=`#ifdef USE_GRADIENTMAP
	uniform sampler2D gradientMap;
#endif
vec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {
	float dotNL = dot( normal, lightDirection );
	vec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );
	#ifdef USE_GRADIENTMAP
		return vec3( texture2D( gradientMap, coord ).r );
	#else
		return ( coord.x < 0.7 ) ? vec3( 0.7 ) : vec3( 1.0 );
	#endif
}`,ib=`#ifdef USE_LIGHTMAP
	vec4 lightMapTexel = texture2D( lightMap, vUv2 );
	vec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;
	#ifndef PHYSICALLY_CORRECT_LIGHTS
		lightMapIrradiance *= PI;
	#endif
	reflectedLight.indirectDiffuse += lightMapIrradiance;
#endif`,rb=`#ifdef USE_LIGHTMAP
	uniform sampler2D lightMap;
	uniform float lightMapIntensity;
#endif`,sb=`vec3 diffuse = vec3( 1.0 );
GeometricContext geometry;
geometry.position = mvPosition.xyz;
geometry.normal = normalize( transformedNormal );
geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -mvPosition.xyz );
GeometricContext backGeometry;
backGeometry.position = geometry.position;
backGeometry.normal = -geometry.normal;
backGeometry.viewDir = geometry.viewDir;
vLightFront = vec3( 0.0 );
vIndirectFront = vec3( 0.0 );
#ifdef DOUBLE_SIDED
	vLightBack = vec3( 0.0 );
	vIndirectBack = vec3( 0.0 );
#endif
IncidentLight directLight;
float dotNL;
vec3 directLightColor_Diffuse;
vIndirectFront += getAmbientLightIrradiance( ambientLightColor );
vIndirectFront += getLightProbeIrradiance( lightProbe, geometry.normal );
#ifdef DOUBLE_SIDED
	vIndirectBack += getAmbientLightIrradiance( ambientLightColor );
	vIndirectBack += getLightProbeIrradiance( lightProbe, backGeometry.normal );
#endif
#if NUM_POINT_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {
		getPointLightInfo( pointLights[ i ], geometry, directLight );
		dotNL = dot( geometry.normal, directLight.direction );
		directLightColor_Diffuse = directLight.color;
		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
		#ifdef DOUBLE_SIDED
			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
		#endif
	}
	#pragma unroll_loop_end
#endif
#if NUM_SPOT_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {
		getSpotLightInfo( spotLights[ i ], geometry, directLight );
		dotNL = dot( geometry.normal, directLight.direction );
		directLightColor_Diffuse = directLight.color;
		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
		#ifdef DOUBLE_SIDED
			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
		#endif
	}
	#pragma unroll_loop_end
#endif
#if NUM_DIR_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
		getDirectionalLightInfo( directionalLights[ i ], geometry, directLight );
		dotNL = dot( geometry.normal, directLight.direction );
		directLightColor_Diffuse = directLight.color;
		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
		#ifdef DOUBLE_SIDED
			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
		#endif
	}
	#pragma unroll_loop_end
#endif
#if NUM_HEMI_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
		vIndirectFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );
		#ifdef DOUBLE_SIDED
			vIndirectBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry.normal );
		#endif
	}
	#pragma unroll_loop_end
#endif`,ob=`uniform bool receiveShadow;
uniform vec3 ambientLightColor;
uniform vec3 lightProbe[ 9 ];
vec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {
	float x = normal.x, y = normal.y, z = normal.z;
	vec3 result = shCoefficients[ 0 ] * 0.886227;
	result += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;
	result += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;
	result += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;
	result += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;
	result += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;
	result += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );
	result += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;
	result += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );
	return result;
}
vec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in vec3 normal ) {
	vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
	vec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );
	return irradiance;
}
vec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {
	vec3 irradiance = ambientLightColor;
	return irradiance;
}
float getDistanceAttenuation( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {
	#if defined ( PHYSICALLY_CORRECT_LIGHTS )
		float distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );
		if ( cutoffDistance > 0.0 ) {
			distanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );
		}
		return distanceFalloff;
	#else
		if ( cutoffDistance > 0.0 && decayExponent > 0.0 ) {
			return pow( saturate( - lightDistance / cutoffDistance + 1.0 ), decayExponent );
		}
		return 1.0;
	#endif
}
float getSpotAttenuation( const in float coneCosine, const in float penumbraCosine, const in float angleCosine ) {
	return smoothstep( coneCosine, penumbraCosine, angleCosine );
}
#if NUM_DIR_LIGHTS > 0
	struct DirectionalLight {
		vec3 direction;
		vec3 color;
	};
	uniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];
	void getDirectionalLightInfo( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight light ) {
		light.color = directionalLight.color;
		light.direction = directionalLight.direction;
		light.visible = true;
	}
#endif
#if NUM_POINT_LIGHTS > 0
	struct PointLight {
		vec3 position;
		vec3 color;
		float distance;
		float decay;
	};
	uniform PointLight pointLights[ NUM_POINT_LIGHTS ];
	void getPointLightInfo( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight light ) {
		vec3 lVector = pointLight.position - geometry.position;
		light.direction = normalize( lVector );
		float lightDistance = length( lVector );
		light.color = pointLight.color;
		light.color *= getDistanceAttenuation( lightDistance, pointLight.distance, pointLight.decay );
		light.visible = ( light.color != vec3( 0.0 ) );
	}
#endif
#if NUM_SPOT_LIGHTS > 0
	struct SpotLight {
		vec3 position;
		vec3 direction;
		vec3 color;
		float distance;
		float decay;
		float coneCos;
		float penumbraCos;
	};
	uniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];
	void getSpotLightInfo( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight light ) {
		vec3 lVector = spotLight.position - geometry.position;
		light.direction = normalize( lVector );
		float angleCos = dot( light.direction, spotLight.direction );
		float spotAttenuation = getSpotAttenuation( spotLight.coneCos, spotLight.penumbraCos, angleCos );
		if ( spotAttenuation > 0.0 ) {
			float lightDistance = length( lVector );
			light.color = spotLight.color * spotAttenuation;
			light.color *= getDistanceAttenuation( lightDistance, spotLight.distance, spotLight.decay );
			light.visible = ( light.color != vec3( 0.0 ) );
		} else {
			light.color = vec3( 0.0 );
			light.visible = false;
		}
	}
#endif
#if NUM_RECT_AREA_LIGHTS > 0
	struct RectAreaLight {
		vec3 color;
		vec3 position;
		vec3 halfWidth;
		vec3 halfHeight;
	};
	uniform sampler2D ltc_1;	uniform sampler2D ltc_2;
	uniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];
#endif
#if NUM_HEMI_LIGHTS > 0
	struct HemisphereLight {
		vec3 direction;
		vec3 skyColor;
		vec3 groundColor;
	};
	uniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];
	vec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in vec3 normal ) {
		float dotNL = dot( normal, hemiLight.direction );
		float hemiDiffuseWeight = 0.5 * dotNL + 0.5;
		vec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );
		return irradiance;
	}
#endif`,ab=`#if defined( USE_ENVMAP )
	#ifdef ENVMAP_MODE_REFRACTION
		uniform float refractionRatio;
	#endif
	vec3 getIBLIrradiance( const in vec3 normal ) {
		#if defined( ENVMAP_TYPE_CUBE_UV )
			vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
			vec4 envMapColor = textureCubeUV( envMap, worldNormal, 1.0 );
			return PI * envMapColor.rgb * envMapIntensity;
		#else
			return vec3( 0.0 );
		#endif
	}
	vec3 getIBLRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {
		#if defined( ENVMAP_TYPE_CUBE_UV )
			vec3 reflectVec;
			#ifdef ENVMAP_MODE_REFLECTION
				reflectVec = reflect( - viewDir, normal );
				reflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );
			#else
				reflectVec = refract( - viewDir, normal, refractionRatio );
			#endif
			reflectVec = inverseTransformDirection( reflectVec, viewMatrix );
			vec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness );
			return envMapColor.rgb * envMapIntensity;
		#else
			return vec3( 0.0 );
		#endif
	}
#endif`,lb=`ToonMaterial material;
material.diffuseColor = diffuseColor.rgb;`,cb=`varying vec3 vViewPosition;
struct ToonMaterial {
	vec3 diffuseColor;
};
void RE_Direct_Toon( const in IncidentLight directLight, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {
	vec3 irradiance = getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;
	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
void RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {
	reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
#define RE_Direct				RE_Direct_Toon
#define RE_IndirectDiffuse		RE_IndirectDiffuse_Toon
#define Material_LightProbeLOD( material )	(0)`,ub=`BlinnPhongMaterial material;
material.diffuseColor = diffuseColor.rgb;
material.specularColor = specular;
material.specularShininess = shininess;
material.specularStrength = specularStrength;`,hb=`varying vec3 vViewPosition;
struct BlinnPhongMaterial {
	vec3 diffuseColor;
	vec3 specularColor;
	float specularShininess;
	float specularStrength;
};
void RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {
	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
	vec3 irradiance = dotNL * directLight.color;
	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
	reflectedLight.directSpecular += irradiance * BRDF_BlinnPhong( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularShininess ) * material.specularStrength;
}
void RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {
	reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
#define RE_Direct				RE_Direct_BlinnPhong
#define RE_IndirectDiffuse		RE_IndirectDiffuse_BlinnPhong
#define Material_LightProbeLOD( material )	(0)`,fb=`PhysicalMaterial material;
material.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );
vec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );
float geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );
material.roughness = max( roughnessFactor, 0.0525 );material.roughness += geometryRoughness;
material.roughness = min( material.roughness, 1.0 );
#ifdef IOR
	#ifdef SPECULAR
		float specularIntensityFactor = specularIntensity;
		vec3 specularColorFactor = specularColor;
		#ifdef USE_SPECULARINTENSITYMAP
			specularIntensityFactor *= texture2D( specularIntensityMap, vUv ).a;
		#endif
		#ifdef USE_SPECULARCOLORMAP
			specularColorFactor *= texture2D( specularColorMap, vUv ).rgb;
		#endif
		material.specularF90 = mix( specularIntensityFactor, 1.0, metalnessFactor );
	#else
		float specularIntensityFactor = 1.0;
		vec3 specularColorFactor = vec3( 1.0 );
		material.specularF90 = 1.0;
	#endif
	material.specularColor = mix( min( pow2( ( ior - 1.0 ) / ( ior + 1.0 ) ) * specularColorFactor, vec3( 1.0 ) ) * specularIntensityFactor, diffuseColor.rgb, metalnessFactor );
#else
	material.specularColor = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessFactor );
	material.specularF90 = 1.0;
#endif
#ifdef USE_CLEARCOAT
	material.clearcoat = clearcoat;
	material.clearcoatRoughness = clearcoatRoughness;
	material.clearcoatF0 = vec3( 0.04 );
	material.clearcoatF90 = 1.0;
	#ifdef USE_CLEARCOATMAP
		material.clearcoat *= texture2D( clearcoatMap, vUv ).x;
	#endif
	#ifdef USE_CLEARCOAT_ROUGHNESSMAP
		material.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vUv ).y;
	#endif
	material.clearcoat = saturate( material.clearcoat );	material.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );
	material.clearcoatRoughness += geometryRoughness;
	material.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );
#endif
#ifdef USE_SHEEN
	material.sheenColor = sheenColor;
	#ifdef USE_SHEENCOLORMAP
		material.sheenColor *= texture2D( sheenColorMap, vUv ).rgb;
	#endif
	material.sheenRoughness = clamp( sheenRoughness, 0.07, 1.0 );
	#ifdef USE_SHEENROUGHNESSMAP
		material.sheenRoughness *= texture2D( sheenRoughnessMap, vUv ).a;
	#endif
#endif`,db=`struct PhysicalMaterial {
	vec3 diffuseColor;
	float roughness;
	vec3 specularColor;
	float specularF90;
	#ifdef USE_CLEARCOAT
		float clearcoat;
		float clearcoatRoughness;
		vec3 clearcoatF0;
		float clearcoatF90;
	#endif
	#ifdef USE_SHEEN
		vec3 sheenColor;
		float sheenRoughness;
	#endif
};
vec3 clearcoatSpecular = vec3( 0.0 );
vec3 sheenSpecular = vec3( 0.0 );
float IBLSheenBRDF( const in vec3 normal, const in vec3 viewDir, const in float roughness) {
	float dotNV = saturate( dot( normal, viewDir ) );
	float r2 = roughness * roughness;
	float a = roughness < 0.25 ? -339.2 * r2 + 161.4 * roughness - 25.9 : -8.48 * r2 + 14.3 * roughness - 9.95;
	float b = roughness < 0.25 ? 44.0 * r2 - 23.7 * roughness + 3.26 : 1.97 * r2 - 3.27 * roughness + 0.72;
	float DG = exp( a * dotNV + b ) + ( roughness < 0.25 ? 0.0 : 0.1 * ( roughness - 0.25 ) );
	return saturate( DG * RECIPROCAL_PI );
}
vec2 DFGApprox( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {
	float dotNV = saturate( dot( normal, viewDir ) );
	const vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );
	const vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );
	vec4 r = roughness * c0 + c1;
	float a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;
	vec2 fab = vec2( - 1.04, 1.04 ) * a004 + r.zw;
	return fab;
}
vec3 EnvironmentBRDF( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness ) {
	vec2 fab = DFGApprox( normal, viewDir, roughness );
	return specularColor * fab.x + specularF90 * fab.y;
}
void computeMultiscattering( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {
	vec2 fab = DFGApprox( normal, viewDir, roughness );
	vec3 FssEss = specularColor * fab.x + specularF90 * fab.y;
	float Ess = fab.x + fab.y;
	float Ems = 1.0 - Ess;
	vec3 Favg = specularColor + ( 1.0 - specularColor ) * 0.047619;	vec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );
	singleScatter += FssEss;
	multiScatter += Fms * Ems;
}
#if NUM_RECT_AREA_LIGHTS > 0
	void RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
		vec3 normal = geometry.normal;
		vec3 viewDir = geometry.viewDir;
		vec3 position = geometry.position;
		vec3 lightPos = rectAreaLight.position;
		vec3 halfWidth = rectAreaLight.halfWidth;
		vec3 halfHeight = rectAreaLight.halfHeight;
		vec3 lightColor = rectAreaLight.color;
		float roughness = material.roughness;
		vec3 rectCoords[ 4 ];
		rectCoords[ 0 ] = lightPos + halfWidth - halfHeight;		rectCoords[ 1 ] = lightPos - halfWidth - halfHeight;
		rectCoords[ 2 ] = lightPos - halfWidth + halfHeight;
		rectCoords[ 3 ] = lightPos + halfWidth + halfHeight;
		vec2 uv = LTC_Uv( normal, viewDir, roughness );
		vec4 t1 = texture2D( ltc_1, uv );
		vec4 t2 = texture2D( ltc_2, uv );
		mat3 mInv = mat3(
			vec3( t1.x, 0, t1.y ),
			vec3(    0, 1,    0 ),
			vec3( t1.z, 0, t1.w )
		);
		vec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );
		reflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );
		reflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );
	}
#endif
void RE_Direct_Physical( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
	vec3 irradiance = dotNL * directLight.color;
	#ifdef USE_CLEARCOAT
		float dotNLcc = saturate( dot( geometry.clearcoatNormal, directLight.direction ) );
		vec3 ccIrradiance = dotNLcc * directLight.color;
		clearcoatSpecular += ccIrradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.clearcoatNormal, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );
	#endif
	#ifdef USE_SHEEN
		sheenSpecular += irradiance * BRDF_Sheen( directLight.direction, geometry.viewDir, geometry.normal, material.sheenColor, material.sheenRoughness );
	#endif
	reflectedLight.directSpecular += irradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularF90, material.roughness );
	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
void RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
	reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
void RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {
	#ifdef USE_CLEARCOAT
		clearcoatSpecular += clearcoatRadiance * EnvironmentBRDF( geometry.clearcoatNormal, geometry.viewDir, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );
	#endif
	#ifdef USE_SHEEN
		sheenSpecular += irradiance * material.sheenColor * IBLSheenBRDF( geometry.normal, geometry.viewDir, material.sheenRoughness );
	#endif
	vec3 singleScattering = vec3( 0.0 );
	vec3 multiScattering = vec3( 0.0 );
	vec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;
	computeMultiscattering( geometry.normal, geometry.viewDir, material.specularColor, material.specularF90, material.roughness, singleScattering, multiScattering );
	vec3 diffuse = material.diffuseColor * ( 1.0 - ( singleScattering + multiScattering ) );
	reflectedLight.indirectSpecular += radiance * singleScattering;
	reflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;
	reflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;
}
#define RE_Direct				RE_Direct_Physical
#define RE_Direct_RectArea		RE_Direct_RectArea_Physical
#define RE_IndirectDiffuse		RE_IndirectDiffuse_Physical
#define RE_IndirectSpecular		RE_IndirectSpecular_Physical
float computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {
	return saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );
}`,pb=`
GeometricContext geometry;
geometry.position = - vViewPosition;
geometry.normal = normal;
geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );
#ifdef USE_CLEARCOAT
	geometry.clearcoatNormal = clearcoatNormal;
#endif
IncidentLight directLight;
#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )
	PointLight pointLight;
	#if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0
	PointLightShadow pointLightShadow;
	#endif
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {
		pointLight = pointLights[ i ];
		getPointLightInfo( pointLight, geometry, directLight );
		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )
		pointLightShadow = pointLightShadows[ i ];
		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;
		#endif
		RE_Direct( directLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )
	SpotLight spotLight;
	#if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0
	SpotLightShadow spotLightShadow;
	#endif
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {
		spotLight = spotLights[ i ];
		getSpotLightInfo( spotLight, geometry, directLight );
		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )
		spotLightShadow = spotLightShadows[ i ];
		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;
		#endif
		RE_Direct( directLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )
	DirectionalLight directionalLight;
	#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0
	DirectionalLightShadow directionalLightShadow;
	#endif
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
		directionalLight = directionalLights[ i ];
		getDirectionalLightInfo( directionalLight, geometry, directLight );
		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )
		directionalLightShadow = directionalLightShadows[ i ];
		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
		#endif
		RE_Direct( directLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )
	RectAreaLight rectAreaLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {
		rectAreaLight = rectAreaLights[ i ];
		RE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if defined( RE_IndirectDiffuse )
	vec3 iblIrradiance = vec3( 0.0 );
	vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );
	irradiance += getLightProbeIrradiance( lightProbe, geometry.normal );
	#if ( NUM_HEMI_LIGHTS > 0 )
		#pragma unroll_loop_start
		for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
			irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );
		}
		#pragma unroll_loop_end
	#endif
#endif
#if defined( RE_IndirectSpecular )
	vec3 radiance = vec3( 0.0 );
	vec3 clearcoatRadiance = vec3( 0.0 );
#endif`,mb=`#if defined( RE_IndirectDiffuse )
	#ifdef USE_LIGHTMAP
		vec4 lightMapTexel = texture2D( lightMap, vUv2 );
		vec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;
		#ifndef PHYSICALLY_CORRECT_LIGHTS
			lightMapIrradiance *= PI;
		#endif
		irradiance += lightMapIrradiance;
	#endif
	#if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )
		iblIrradiance += getIBLIrradiance( geometry.normal );
	#endif
#endif
#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )
	radiance += getIBLRadiance( geometry.viewDir, geometry.normal, material.roughness );
	#ifdef USE_CLEARCOAT
		clearcoatRadiance += getIBLRadiance( geometry.viewDir, geometry.clearcoatNormal, material.clearcoatRoughness );
	#endif
#endif`,gb=`#if defined( RE_IndirectDiffuse )
	RE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );
#endif
#if defined( RE_IndirectSpecular )
	RE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometry, material, reflectedLight );
#endif`,xb=`#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )
	gl_FragDepthEXT = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;
#endif`,yb=`#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )
	uniform float logDepthBufFC;
	varying float vFragDepth;
	varying float vIsPerspective;
#endif`,vb=`#ifdef USE_LOGDEPTHBUF
	#ifdef USE_LOGDEPTHBUF_EXT
		varying float vFragDepth;
		varying float vIsPerspective;
	#else
		uniform float logDepthBufFC;
	#endif
#endif`,_b=`#ifdef USE_LOGDEPTHBUF
	#ifdef USE_LOGDEPTHBUF_EXT
		vFragDepth = 1.0 + gl_Position.w;
		vIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );
	#else
		if ( isPerspectiveMatrix( projectionMatrix ) ) {
			gl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;
			gl_Position.z *= gl_Position.w;
		}
	#endif
#endif`,wb=`#ifdef USE_MAP
	vec4 sampledDiffuseColor = texture2D( map, vUv );
	#ifdef DECODE_VIDEO_TEXTURE
		sampledDiffuseColor = vec4( mix( pow( sampledDiffuseColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), sampledDiffuseColor.rgb * 0.0773993808, vec3( lessThanEqual( sampledDiffuseColor.rgb, vec3( 0.04045 ) ) ) ), sampledDiffuseColor.w );
	#endif
	diffuseColor *= sampledDiffuseColor;
#endif`,Mb=`#ifdef USE_MAP
	uniform sampler2D map;
#endif`,bb=`#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
	vec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;
#endif
#ifdef USE_MAP
	diffuseColor *= texture2D( map, uv );
#endif
#ifdef USE_ALPHAMAP
	diffuseColor.a *= texture2D( alphaMap, uv ).g;
#endif`,Sb=`#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
	uniform mat3 uvTransform;
#endif
#ifdef USE_MAP
	uniform sampler2D map;
#endif
#ifdef USE_ALPHAMAP
	uniform sampler2D alphaMap;
#endif`,Eb=`float metalnessFactor = metalness;
#ifdef USE_METALNESSMAP
	vec4 texelMetalness = texture2D( metalnessMap, vUv );
	metalnessFactor *= texelMetalness.b;
#endif`,Tb=`#ifdef USE_METALNESSMAP
	uniform sampler2D metalnessMap;
#endif`,Ab=`#ifdef USE_MORPHNORMALS
	objectNormal *= morphTargetBaseInfluence;
	#ifdef MORPHTARGETS_TEXTURE
		for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
			if ( morphTargetInfluences[ i ] != 0.0 ) objectNormal += getMorph( gl_VertexID, i, 1, 2 ) * morphTargetInfluences[ i ];
		}
	#else
		objectNormal += morphNormal0 * morphTargetInfluences[ 0 ];
		objectNormal += morphNormal1 * morphTargetInfluences[ 1 ];
		objectNormal += morphNormal2 * morphTargetInfluences[ 2 ];
		objectNormal += morphNormal3 * morphTargetInfluences[ 3 ];
	#endif
#endif`,Cb=`#ifdef USE_MORPHTARGETS
	uniform float morphTargetBaseInfluence;
	#ifdef MORPHTARGETS_TEXTURE
		uniform float morphTargetInfluences[ MORPHTARGETS_COUNT ];
		uniform sampler2DArray morphTargetsTexture;
		uniform vec2 morphTargetsTextureSize;
		vec3 getMorph( const in int vertexIndex, const in int morphTargetIndex, const in int offset, const in int stride ) {
			float texelIndex = float( vertexIndex * stride + offset );
			float y = floor( texelIndex / morphTargetsTextureSize.x );
			float x = texelIndex - y * morphTargetsTextureSize.x;
			vec3 morphUV = vec3( ( x + 0.5 ) / morphTargetsTextureSize.x, y / morphTargetsTextureSize.y, morphTargetIndex );
			return texture( morphTargetsTexture, morphUV ).xyz;
		}
	#else
		#ifndef USE_MORPHNORMALS
			uniform float morphTargetInfluences[ 8 ];
		#else
			uniform float morphTargetInfluences[ 4 ];
		#endif
	#endif
#endif`,Rb=`#ifdef USE_MORPHTARGETS
	transformed *= morphTargetBaseInfluence;
	#ifdef MORPHTARGETS_TEXTURE
		for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
			#ifndef USE_MORPHNORMALS
				if ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0, 1 ) * morphTargetInfluences[ i ];
			#else
				if ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0, 2 ) * morphTargetInfluences[ i ];
			#endif
		}
	#else
		transformed += morphTarget0 * morphTargetInfluences[ 0 ];
		transformed += morphTarget1 * morphTargetInfluences[ 1 ];
		transformed += morphTarget2 * morphTargetInfluences[ 2 ];
		transformed += morphTarget3 * morphTargetInfluences[ 3 ];
		#ifndef USE_MORPHNORMALS
			transformed += morphTarget4 * morphTargetInfluences[ 4 ];
			transformed += morphTarget5 * morphTargetInfluences[ 5 ];
			transformed += morphTarget6 * morphTargetInfluences[ 6 ];
			transformed += morphTarget7 * morphTargetInfluences[ 7 ];
		#endif
	#endif
#endif`,Lb=`float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;
#ifdef FLAT_SHADED
	vec3 fdx = vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );
	vec3 fdy = vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );
	vec3 normal = normalize( cross( fdx, fdy ) );
#else
	vec3 normal = normalize( vNormal );
	#ifdef DOUBLE_SIDED
		normal = normal * faceDirection;
	#endif
	#ifdef USE_TANGENT
		vec3 tangent = normalize( vTangent );
		vec3 bitangent = normalize( vBitangent );
		#ifdef DOUBLE_SIDED
			tangent = tangent * faceDirection;
			bitangent = bitangent * faceDirection;
		#endif
		#if defined( TANGENTSPACE_NORMALMAP ) || defined( USE_CLEARCOAT_NORMALMAP )
			mat3 vTBN = mat3( tangent, bitangent, normal );
		#endif
	#endif
#endif
vec3 geometryNormal = normal;`,Pb=`#ifdef OBJECTSPACE_NORMALMAP
	normal = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;
	#ifdef FLIP_SIDED
		normal = - normal;
	#endif
	#ifdef DOUBLE_SIDED
		normal = normal * faceDirection;
	#endif
	normal = normalize( normalMatrix * normal );
#elif defined( TANGENTSPACE_NORMALMAP )
	vec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;
	mapN.xy *= normalScale;
	#ifdef USE_TANGENT
		normal = normalize( vTBN * mapN );
	#else
		normal = perturbNormal2Arb( - vViewPosition, normal, mapN, faceDirection );
	#endif
#elif defined( USE_BUMPMAP )
	normal = perturbNormalArb( - vViewPosition, normal, dHdxy_fwd(), faceDirection );
#endif`,Db=`#ifndef FLAT_SHADED
	varying vec3 vNormal;
	#ifdef USE_TANGENT
		varying vec3 vTangent;
		varying vec3 vBitangent;
	#endif
#endif`,Ib=`#ifndef FLAT_SHADED
	varying vec3 vNormal;
	#ifdef USE_TANGENT
		varying vec3 vTangent;
		varying vec3 vBitangent;
	#endif
#endif`,Nb=`#ifndef FLAT_SHADED
	vNormal = normalize( transformedNormal );
	#ifdef USE_TANGENT
		vTangent = normalize( transformedTangent );
		vBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );
	#endif
#endif`,Fb=`#ifdef USE_NORMALMAP
	uniform sampler2D normalMap;
	uniform vec2 normalScale;
#endif
#ifdef OBJECTSPACE_NORMALMAP
	uniform mat3 normalMatrix;
#endif
#if ! defined ( USE_TANGENT ) && ( defined ( TANGENTSPACE_NORMALMAP ) || defined ( USE_CLEARCOAT_NORMALMAP ) )
	vec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm, vec3 mapN, float faceDirection ) {
		vec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );
		vec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );
		vec2 st0 = dFdx( vUv.st );
		vec2 st1 = dFdy( vUv.st );
		vec3 N = surf_norm;
		vec3 q1perp = cross( q1, N );
		vec3 q0perp = cross( N, q0 );
		vec3 T = q1perp * st0.x + q0perp * st1.x;
		vec3 B = q1perp * st0.y + q0perp * st1.y;
		float det = max( dot( T, T ), dot( B, B ) );
		float scale = ( det == 0.0 ) ? 0.0 : faceDirection * inversesqrt( det );
		return normalize( T * ( mapN.x * scale ) + B * ( mapN.y * scale ) + N * mapN.z );
	}
#endif`,zb=`#ifdef USE_CLEARCOAT
	vec3 clearcoatNormal = geometryNormal;
#endif`,Ub=`#ifdef USE_CLEARCOAT_NORMALMAP
	vec3 clearcoatMapN = texture2D( clearcoatNormalMap, vUv ).xyz * 2.0 - 1.0;
	clearcoatMapN.xy *= clearcoatNormalScale;
	#ifdef USE_TANGENT
		clearcoatNormal = normalize( vTBN * clearcoatMapN );
	#else
		clearcoatNormal = perturbNormal2Arb( - vViewPosition, clearcoatNormal, clearcoatMapN, faceDirection );
	#endif
#endif`,Bb=`#ifdef USE_CLEARCOATMAP
	uniform sampler2D clearcoatMap;
#endif
#ifdef USE_CLEARCOAT_ROUGHNESSMAP
	uniform sampler2D clearcoatRoughnessMap;
#endif
#ifdef USE_CLEARCOAT_NORMALMAP
	uniform sampler2D clearcoatNormalMap;
	uniform vec2 clearcoatNormalScale;
#endif`,Ob=`#ifdef OPAQUE
diffuseColor.a = 1.0;
#endif
#ifdef USE_TRANSMISSION
diffuseColor.a *= transmissionAlpha + 0.1;
#endif
gl_FragColor = vec4( outgoingLight, diffuseColor.a );`,kb=`vec3 packNormalToRGB( const in vec3 normal ) {
	return normalize( normal ) * 0.5 + 0.5;
}
vec3 unpackRGBToNormal( const in vec3 rgb ) {
	return 2.0 * rgb.xyz - 1.0;
}
const float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;
const vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );
const vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );
const float ShiftRight8 = 1. / 256.;
vec4 packDepthToRGBA( const in float v ) {
	vec4 r = vec4( fract( v * PackFactors ), v );
	r.yzw -= r.xyz * ShiftRight8;	return r * PackUpscale;
}
float unpackRGBAToDepth( const in vec4 v ) {
	return dot( v, UnpackFactors );
}
vec4 pack2HalfToRGBA( vec2 v ) {
	vec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ) );
	return vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w );
}
vec2 unpackRGBATo2Half( vec4 v ) {
	return vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );
}
float viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {
	return ( viewZ + near ) / ( near - far );
}
float orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {
	return linearClipZ * ( near - far ) - near;
}
float viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {
	return ( ( near + viewZ ) * far ) / ( ( far - near ) * viewZ );
}
float perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {
	return ( near * far ) / ( ( far - near ) * invClipZ - far );
}`,Hb=`#ifdef PREMULTIPLIED_ALPHA
	gl_FragColor.rgb *= gl_FragColor.a;
#endif`,Vb=`vec4 mvPosition = vec4( transformed, 1.0 );
#ifdef USE_INSTANCING
	mvPosition = instanceMatrix * mvPosition;
#endif
mvPosition = modelViewMatrix * mvPosition;
gl_Position = projectionMatrix * mvPosition;`,Gb=`#ifdef DITHERING
	gl_FragColor.rgb = dithering( gl_FragColor.rgb );
#endif`,Wb=`#ifdef DITHERING
	vec3 dithering( vec3 color ) {
		float grid_position = rand( gl_FragCoord.xy );
		vec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );
		dither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );
		return color + dither_shift_RGB;
	}
#endif`,qb=`float roughnessFactor = roughness;
#ifdef USE_ROUGHNESSMAP
	vec4 texelRoughness = texture2D( roughnessMap, vUv );
	roughnessFactor *= texelRoughness.g;
#endif`,Xb=`#ifdef USE_ROUGHNESSMAP
	uniform sampler2D roughnessMap;
#endif`,Yb=`#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0
		uniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];
		varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];
		struct DirectionalLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
		uniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];
		varying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];
		struct SpotLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
		uniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];
		varying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];
		struct PointLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
			float shadowCameraNear;
			float shadowCameraFar;
		};
		uniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];
	#endif
	float texture2DCompare( sampler2D depths, vec2 uv, float compare ) {
		return step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );
	}
	vec2 texture2DDistribution( sampler2D shadow, vec2 uv ) {
		return unpackRGBATo2Half( texture2D( shadow, uv ) );
	}
	float VSMShadow (sampler2D shadow, vec2 uv, float compare ){
		float occlusion = 1.0;
		vec2 distribution = texture2DDistribution( shadow, uv );
		float hard_shadow = step( compare , distribution.x );
		if (hard_shadow != 1.0 ) {
			float distance = compare - distribution.x ;
			float variance = max( 0.00000, distribution.y * distribution.y );
			float softness_probability = variance / (variance + distance * distance );			softness_probability = clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 );			occlusion = clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );
		}
		return occlusion;
	}
	float getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {
		float shadow = 1.0;
		shadowCoord.xyz /= shadowCoord.w;
		shadowCoord.z += shadowBias;
		bvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );
		bool inFrustum = all( inFrustumVec );
		bvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );
		bool frustumTest = all( frustumTestVec );
		if ( frustumTest ) {
		#if defined( SHADOWMAP_TYPE_PCF )
			vec2 texelSize = vec2( 1.0 ) / shadowMapSize;
			float dx0 = - texelSize.x * shadowRadius;
			float dy0 = - texelSize.y * shadowRadius;
			float dx1 = + texelSize.x * shadowRadius;
			float dy1 = + texelSize.y * shadowRadius;
			float dx2 = dx0 / 2.0;
			float dy2 = dy0 / 2.0;
			float dx3 = dx1 / 2.0;
			float dy3 = dy1 / 2.0;
			shadow = (
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )
			) * ( 1.0 / 17.0 );
		#elif defined( SHADOWMAP_TYPE_PCF_SOFT )
			vec2 texelSize = vec2( 1.0 ) / shadowMapSize;
			float dx = texelSize.x;
			float dy = texelSize.y;
			vec2 uv = shadowCoord.xy;
			vec2 f = fract( uv * shadowMapSize + 0.5 );
			uv -= f * texelSize;
			shadow = (
				texture2DCompare( shadowMap, uv, shadowCoord.z ) +
				texture2DCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +
				texture2DCompare( shadowMap, uv + texelSize, shadowCoord.z ) +
				mix( texture2DCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),
					 f.x ) +
				mix( texture2DCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),
					 f.x ) +
				mix( texture2DCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),
					 f.y ) +
				mix( texture2DCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),
					 f.y ) +
				mix( mix( texture2DCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ), 
						  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),
						  f.x ),
					 mix( texture2DCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ), 
						  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),
						  f.x ),
					 f.y )
			) * ( 1.0 / 9.0 );
		#elif defined( SHADOWMAP_TYPE_VSM )
			shadow = VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );
		#else
			shadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );
		#endif
		}
		return shadow;
	}
	vec2 cubeToUV( vec3 v, float texelSizeY ) {
		vec3 absV = abs( v );
		float scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );
		absV *= scaleToCube;
		v *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );
		vec2 planar = v.xy;
		float almostATexel = 1.5 * texelSizeY;
		float almostOne = 1.0 - almostATexel;
		if ( absV.z >= almostOne ) {
			if ( v.z > 0.0 )
				planar.x = 4.0 - v.x;
		} else if ( absV.x >= almostOne ) {
			float signX = sign( v.x );
			planar.x = v.z * signX + 2.0 * signX;
		} else if ( absV.y >= almostOne ) {
			float signY = sign( v.y );
			planar.x = v.x + 2.0 * signY + 2.0;
			planar.y = v.z * signY - 2.0;
		}
		return vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );
	}
	float getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {
		vec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );
		vec3 lightToPosition = shadowCoord.xyz;
		float dp = ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );		dp += shadowBias;
		vec3 bd3D = normalize( lightToPosition );
		#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )
			vec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;
			return (
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )
			) * ( 1.0 / 9.0 );
		#else
			return texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );
		#endif
	}
#endif`,Zb=`#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0
		uniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];
		varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];
		struct DirectionalLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
		uniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHT_SHADOWS ];
		varying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];
		struct SpotLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
		uniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];
		varying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];
		struct PointLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
			float shadowCameraNear;
			float shadowCameraFar;
		};
		uniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];
	#endif
#endif`,Jb=`#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0 || NUM_SPOT_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0
		vec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
		vec4 shadowWorldPosition;
	#endif
	#if NUM_DIR_LIGHT_SHADOWS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {
		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );
		vDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {
		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias, 0 );
		vSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * shadowWorldPosition;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {
		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );
		vPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;
	}
	#pragma unroll_loop_end
	#endif
#endif`,$b=`float getShadowMask() {
	float shadow = 1.0;
	#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0
	DirectionalLightShadow directionalLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {
		directionalLight = directionalLightShadows[ i ];
		shadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
	SpotLightShadow spotLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {
		spotLight = spotLightShadows[ i ];
		shadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
	PointLightShadow pointLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {
		pointLight = pointLightShadows[ i ];
		shadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;
	}
	#pragma unroll_loop_end
	#endif
	#endif
	return shadow;
}`,Kb=`#ifdef USE_SKINNING
	mat4 boneMatX = getBoneMatrix( skinIndex.x );
	mat4 boneMatY = getBoneMatrix( skinIndex.y );
	mat4 boneMatZ = getBoneMatrix( skinIndex.z );
	mat4 boneMatW = getBoneMatrix( skinIndex.w );
#endif`,Qb=`#ifdef USE_SKINNING
	uniform mat4 bindMatrix;
	uniform mat4 bindMatrixInverse;
	#ifdef BONE_TEXTURE
		uniform highp sampler2D boneTexture;
		uniform int boneTextureSize;
		mat4 getBoneMatrix( const in float i ) {
			float j = i * 4.0;
			float x = mod( j, float( boneTextureSize ) );
			float y = floor( j / float( boneTextureSize ) );
			float dx = 1.0 / float( boneTextureSize );
			float dy = 1.0 / float( boneTextureSize );
			y = dy * ( y + 0.5 );
			vec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );
			vec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );
			vec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );
			vec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );
			mat4 bone = mat4( v1, v2, v3, v4 );
			return bone;
		}
	#else
		uniform mat4 boneMatrices[ MAX_BONES ];
		mat4 getBoneMatrix( const in float i ) {
			mat4 bone = boneMatrices[ int(i) ];
			return bone;
		}
	#endif
#endif`,jb=`#ifdef USE_SKINNING
	vec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );
	vec4 skinned = vec4( 0.0 );
	skinned += boneMatX * skinVertex * skinWeight.x;
	skinned += boneMatY * skinVertex * skinWeight.y;
	skinned += boneMatZ * skinVertex * skinWeight.z;
	skinned += boneMatW * skinVertex * skinWeight.w;
	transformed = ( bindMatrixInverse * skinned ).xyz;
#endif`,t1=`#ifdef USE_SKINNING
	mat4 skinMatrix = mat4( 0.0 );
	skinMatrix += skinWeight.x * boneMatX;
	skinMatrix += skinWeight.y * boneMatY;
	skinMatrix += skinWeight.z * boneMatZ;
	skinMatrix += skinWeight.w * boneMatW;
	skinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;
	objectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;
	#ifdef USE_TANGENT
		objectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;
	#endif
#endif`,e1=`float specularStrength;
#ifdef USE_SPECULARMAP
	vec4 texelSpecular = texture2D( specularMap, vUv );
	specularStrength = texelSpecular.r;
#else
	specularStrength = 1.0;
#endif`,n1=`#ifdef USE_SPECULARMAP
	uniform sampler2D specularMap;
#endif`,i1=`#if defined( TONE_MAPPING )
	gl_FragColor.rgb = toneMapping( gl_FragColor.rgb );
#endif`,r1=`#ifndef saturate
#define saturate( a ) clamp( a, 0.0, 1.0 )
#endif
uniform float toneMappingExposure;
vec3 LinearToneMapping( vec3 color ) {
	return toneMappingExposure * color;
}
vec3 ReinhardToneMapping( vec3 color ) {
	color *= toneMappingExposure;
	return saturate( color / ( vec3( 1.0 ) + color ) );
}
vec3 OptimizedCineonToneMapping( vec3 color ) {
	color *= toneMappingExposure;
	color = max( vec3( 0.0 ), color - 0.004 );
	return pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );
}
vec3 RRTAndODTFit( vec3 v ) {
	vec3 a = v * ( v + 0.0245786 ) - 0.000090537;
	vec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;
	return a / b;
}
vec3 ACESFilmicToneMapping( vec3 color ) {
	const mat3 ACESInputMat = mat3(
		vec3( 0.59719, 0.07600, 0.02840 ),		vec3( 0.35458, 0.90834, 0.13383 ),
		vec3( 0.04823, 0.01566, 0.83777 )
	);
	const mat3 ACESOutputMat = mat3(
		vec3(  1.60475, -0.10208, -0.00327 ),		vec3( -0.53108,  1.10813, -0.07276 ),
		vec3( -0.07367, -0.00605,  1.07602 )
	);
	color *= toneMappingExposure / 0.6;
	color = ACESInputMat * color;
	color = RRTAndODTFit( color );
	color = ACESOutputMat * color;
	return saturate( color );
}
vec3 CustomToneMapping( vec3 color ) { return color; }`,s1=`#ifdef USE_TRANSMISSION
	float transmissionAlpha = 1.0;
	float transmissionFactor = transmission;
	float thicknessFactor = thickness;
	#ifdef USE_TRANSMISSIONMAP
		transmissionFactor *= texture2D( transmissionMap, vUv ).r;
	#endif
	#ifdef USE_THICKNESSMAP
		thicknessFactor *= texture2D( thicknessMap, vUv ).g;
	#endif
	vec3 pos = vWorldPosition;
	vec3 v = normalize( cameraPosition - pos );
	vec3 n = inverseTransformDirection( normal, viewMatrix );
	vec4 transmission = getIBLVolumeRefraction(
		n, v, roughnessFactor, material.diffuseColor, material.specularColor, material.specularF90,
		pos, modelMatrix, viewMatrix, projectionMatrix, ior, thicknessFactor,
		attenuationColor, attenuationDistance );
	totalDiffuse = mix( totalDiffuse, transmission.rgb, transmissionFactor );
	transmissionAlpha = mix( transmissionAlpha, transmission.a, transmissionFactor );
#endif`,o1=`#ifdef USE_TRANSMISSION
	uniform float transmission;
	uniform float thickness;
	uniform float attenuationDistance;
	uniform vec3 attenuationColor;
	#ifdef USE_TRANSMISSIONMAP
		uniform sampler2D transmissionMap;
	#endif
	#ifdef USE_THICKNESSMAP
		uniform sampler2D thicknessMap;
	#endif
	uniform vec2 transmissionSamplerSize;
	uniform sampler2D transmissionSamplerMap;
	uniform mat4 modelMatrix;
	uniform mat4 projectionMatrix;
	varying vec3 vWorldPosition;
	vec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {
		vec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );
		vec3 modelScale;
		modelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );
		modelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );
		modelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );
		return normalize( refractionVector ) * thickness * modelScale;
	}
	float applyIorToRoughness( const in float roughness, const in float ior ) {
		return roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );
	}
	vec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {
		float framebufferLod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );
		#ifdef TEXTURE_LOD_EXT
			return texture2DLodEXT( transmissionSamplerMap, fragCoord.xy, framebufferLod );
		#else
			return texture2D( transmissionSamplerMap, fragCoord.xy, framebufferLod );
		#endif
	}
	vec3 applyVolumeAttenuation( const in vec3 radiance, const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {
		if ( attenuationDistance == 0.0 ) {
			return radiance;
		} else {
			vec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;
			vec3 transmittance = exp( - attenuationCoefficient * transmissionDistance );			return transmittance * radiance;
		}
	}
	vec4 getIBLVolumeRefraction( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor,
		const in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix,
		const in mat4 viewMatrix, const in mat4 projMatrix, const in float ior, const in float thickness,
		const in vec3 attenuationColor, const in float attenuationDistance ) {
		vec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );
		vec3 refractedRayExit = position + transmissionRay;
		vec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );
		vec2 refractionCoords = ndcPos.xy / ndcPos.w;
		refractionCoords += 1.0;
		refractionCoords /= 2.0;
		vec4 transmittedLight = getTransmissionSample( refractionCoords, roughness, ior );
		vec3 attenuatedColor = applyVolumeAttenuation( transmittedLight.rgb, length( transmissionRay ), attenuationColor, attenuationDistance );
		vec3 F = EnvironmentBRDF( n, v, specularColor, specularF90, roughness );
		return vec4( ( 1.0 - F ) * attenuatedColor * diffuseColor, transmittedLight.a );
	}
#endif`,a1=`#if ( defined( USE_UV ) && ! defined( UVS_VERTEX_ONLY ) )
	varying vec2 vUv;
#endif`,l1=`#ifdef USE_UV
	#ifdef UVS_VERTEX_ONLY
		vec2 vUv;
	#else
		varying vec2 vUv;
	#endif
	uniform mat3 uvTransform;
#endif`,c1=`#ifdef USE_UV
	vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
#endif`,u1=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
	varying vec2 vUv2;
#endif`,h1=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
	attribute vec2 uv2;
	varying vec2 vUv2;
	uniform mat3 uv2Transform;
#endif`,f1=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
	vUv2 = ( uv2Transform * vec3( uv2, 1 ) ).xy;
#endif`,d1=`#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP ) || defined ( USE_TRANSMISSION )
	vec4 worldPosition = vec4( transformed, 1.0 );
	#ifdef USE_INSTANCING
		worldPosition = instanceMatrix * worldPosition;
	#endif
	worldPosition = modelMatrix * worldPosition;
#endif`,p1=`varying vec2 vUv;
uniform mat3 uvTransform;
void main() {
	vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
	gl_Position = vec4( position.xy, 1.0, 1.0 );
}`,m1=`uniform sampler2D t2D;
varying vec2 vUv;
void main() {
	gl_FragColor = texture2D( t2D, vUv );
	#include <tonemapping_fragment>
	#include <encodings_fragment>
}`,g1=`varying vec3 vWorldDirection;
#include <common>
void main() {
	vWorldDirection = transformDirection( position, modelMatrix );
	#include <begin_vertex>
	#include <project_vertex>
	gl_Position.z = gl_Position.w;
}`,x1=`#include <envmap_common_pars_fragment>
uniform float opacity;
varying vec3 vWorldDirection;
#include <cube_uv_reflection_fragment>
void main() {
	vec3 vReflect = vWorldDirection;
	#include <envmap_fragment>
	gl_FragColor = envColor;
	gl_FragColor.a *= opacity;
	#include <tonemapping_fragment>
	#include <encodings_fragment>
}`,y1=`#include <common>
#include <uv_pars_vertex>
#include <displacementmap_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
varying vec2 vHighPrecisionZW;
void main() {
	#include <uv_vertex>
	#include <skinbase_vertex>
	#ifdef USE_DISPLACEMENTMAP
		#include <beginnormal_vertex>
		#include <morphnormal_vertex>
		#include <skinnormal_vertex>
	#endif
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vHighPrecisionZW = gl_Position.zw;
}`,v1=`#if DEPTH_PACKING == 3200
	uniform float opacity;
#endif
#include <common>
#include <packing>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
varying vec2 vHighPrecisionZW;
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( 1.0 );
	#if DEPTH_PACKING == 3200
		diffuseColor.a = opacity;
	#endif
	#include <map_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <logdepthbuf_fragment>
	float fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;
	#if DEPTH_PACKING == 3200
		gl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );
	#elif DEPTH_PACKING == 3201
		gl_FragColor = packDepthToRGBA( fragCoordZ );
	#endif
}`,_1=`#define DISTANCE
varying vec3 vWorldPosition;
#include <common>
#include <uv_pars_vertex>
#include <displacementmap_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <skinbase_vertex>
	#ifdef USE_DISPLACEMENTMAP
		#include <beginnormal_vertex>
		#include <morphnormal_vertex>
		#include <skinnormal_vertex>
	#endif
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <worldpos_vertex>
	#include <clipping_planes_vertex>
	vWorldPosition = worldPosition.xyz;
}`,w1=`#define DISTANCE
uniform vec3 referencePosition;
uniform float nearDistance;
uniform float farDistance;
varying vec3 vWorldPosition;
#include <common>
#include <packing>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <clipping_planes_pars_fragment>
void main () {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( 1.0 );
	#include <map_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	float dist = length( vWorldPosition - referencePosition );
	dist = ( dist - nearDistance ) / ( farDistance - nearDistance );
	dist = saturate( dist );
	gl_FragColor = packDepthToRGBA( dist );
}`,M1=`varying vec3 vWorldDirection;
#include <common>
void main() {
	vWorldDirection = transformDirection( position, modelMatrix );
	#include <begin_vertex>
	#include <project_vertex>
}`,b1=`uniform sampler2D tEquirect;
varying vec3 vWorldDirection;
#include <common>
void main() {
	vec3 direction = normalize( vWorldDirection );
	vec2 sampleUV = equirectUv( direction );
	gl_FragColor = texture2D( tEquirect, sampleUV );
	#include <tonemapping_fragment>
	#include <encodings_fragment>
}`,S1=`uniform float scale;
attribute float lineDistance;
varying float vLineDistance;
#include <common>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	vLineDistance = scale * lineDistance;
	#include <color_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <fog_vertex>
}`,E1=`uniform vec3 diffuse;
uniform float opacity;
uniform float dashSize;
uniform float totalSize;
varying float vLineDistance;
#include <common>
#include <color_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	if ( mod( vLineDistance, totalSize ) > dashSize ) {
		discard;
	}
	vec3 outgoingLight = vec3( 0.0 );
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <color_fragment>
	outgoingLight = diffuseColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
}`,T1=`#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <envmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )
		#include <beginnormal_vertex>
		#include <morphnormal_vertex>
		#include <skinbase_vertex>
		#include <skinnormal_vertex>
		#include <defaultnormal_vertex>
	#endif
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <worldpos_vertex>
	#include <envmap_vertex>
	#include <fog_vertex>
}`,A1=`uniform vec3 diffuse;
uniform float opacity;
#ifndef FLAT_SHADED
	varying vec3 vNormal;
#endif
#include <common>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_pars_fragment>
#include <cube_uv_reflection_fragment>
#include <fog_pars_fragment>
#include <specularmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <specularmap_fragment>
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	#ifdef USE_LIGHTMAP
		vec4 lightMapTexel= texture2D( lightMap, vUv2 );
		reflectedLight.indirectDiffuse += lightMapTexel.rgb * lightMapIntensity;
	#else
		reflectedLight.indirectDiffuse += vec3( 1.0 );
	#endif
	#include <aomap_fragment>
	reflectedLight.indirectDiffuse *= diffuseColor.rgb;
	vec3 outgoingLight = reflectedLight.indirectDiffuse;
	#include <envmap_fragment>
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,C1=`#define LAMBERT
varying vec3 vLightFront;
varying vec3 vIndirectFront;
#ifdef DOUBLE_SIDED
	varying vec3 vLightBack;
	varying vec3 vIndirectBack;
#endif
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <envmap_pars_vertex>
#include <bsdfs>
#include <lights_pars_begin>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <worldpos_vertex>
	#include <envmap_vertex>
	#include <lights_lambert_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,R1=`uniform vec3 diffuse;
uniform vec3 emissive;
uniform float opacity;
varying vec3 vLightFront;
varying vec3 vIndirectFront;
#ifdef DOUBLE_SIDED
	varying vec3 vLightBack;
	varying vec3 vIndirectBack;
#endif
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_pars_fragment>
#include <cube_uv_reflection_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <fog_pars_fragment>
#include <shadowmap_pars_fragment>
#include <shadowmask_pars_fragment>
#include <specularmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <specularmap_fragment>
	#include <emissivemap_fragment>
	#ifdef DOUBLE_SIDED
		reflectedLight.indirectDiffuse += ( gl_FrontFacing ) ? vIndirectFront : vIndirectBack;
	#else
		reflectedLight.indirectDiffuse += vIndirectFront;
	#endif
	#include <lightmap_fragment>
	reflectedLight.indirectDiffuse *= BRDF_Lambert( diffuseColor.rgb );
	#ifdef DOUBLE_SIDED
		reflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;
	#else
		reflectedLight.directDiffuse = vLightFront;
	#endif
	reflectedLight.directDiffuse *= BRDF_Lambert( diffuseColor.rgb ) * getShadowMask();
	#include <aomap_fragment>
	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
	#include <envmap_fragment>
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,L1=`#define MATCAP
varying vec3 vViewPosition;
#include <common>
#include <uv_pars_vertex>
#include <color_pars_vertex>
#include <displacementmap_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <fog_vertex>
	vViewPosition = - mvPosition.xyz;
}`,P1=`#define MATCAP
uniform vec3 diffuse;
uniform float opacity;
uniform sampler2D matcap;
varying vec3 vViewPosition;
#include <common>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <fog_pars_fragment>
#include <normal_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	vec3 viewDir = normalize( vViewPosition );
	vec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );
	vec3 y = cross( viewDir, x );
	vec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;
	#ifdef USE_MATCAP
		vec4 matcapColor = texture2D( matcap, uv );
	#else
		vec4 matcapColor = vec4( vec3( mix( 0.2, 0.8, uv.y ) ), 1.0 );
	#endif
	vec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,D1=`#define NORMAL
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
	varying vec3 vViewPosition;
#endif
#include <common>
#include <uv_pars_vertex>
#include <displacementmap_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
	vViewPosition = - mvPosition.xyz;
#endif
}`,I1=`#define NORMAL
uniform float opacity;
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
	varying vec3 vViewPosition;
#endif
#include <packing>
#include <uv_pars_fragment>
#include <normal_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	#include <logdepthbuf_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	gl_FragColor = vec4( packNormalToRGB( normal ), opacity );
}`,N1=`#define PHONG
varying vec3 vViewPosition;
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <displacementmap_pars_vertex>
#include <envmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vViewPosition = - mvPosition.xyz;
	#include <worldpos_vertex>
	#include <envmap_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,F1=`#define PHONG
uniform vec3 diffuse;
uniform vec3 emissive;
uniform vec3 specular;
uniform float shininess;
uniform float opacity;
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_pars_fragment>
#include <cube_uv_reflection_fragment>
#include <fog_pars_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <normal_pars_fragment>
#include <lights_phong_pars_fragment>
#include <shadowmap_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <specularmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <specularmap_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	#include <emissivemap_fragment>
	#include <lights_phong_fragment>
	#include <lights_fragment_begin>
	#include <lights_fragment_maps>
	#include <lights_fragment_end>
	#include <aomap_fragment>
	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;
	#include <envmap_fragment>
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,z1=`#define STANDARD
varying vec3 vViewPosition;
#ifdef USE_TRANSMISSION
	varying vec3 vWorldPosition;
#endif
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <displacementmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vViewPosition = - mvPosition.xyz;
	#include <worldpos_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
#ifdef USE_TRANSMISSION
	vWorldPosition = worldPosition.xyz;
#endif
}`,U1=`#define STANDARD
#ifdef PHYSICAL
	#define IOR
	#define SPECULAR
#endif
uniform vec3 diffuse;
uniform vec3 emissive;
uniform float roughness;
uniform float metalness;
uniform float opacity;
#ifdef IOR
	uniform float ior;
#endif
#ifdef SPECULAR
	uniform float specularIntensity;
	uniform vec3 specularColor;
	#ifdef USE_SPECULARINTENSITYMAP
		uniform sampler2D specularIntensityMap;
	#endif
	#ifdef USE_SPECULARCOLORMAP
		uniform sampler2D specularColorMap;
	#endif
#endif
#ifdef USE_CLEARCOAT
	uniform float clearcoat;
	uniform float clearcoatRoughness;
#endif
#ifdef USE_SHEEN
	uniform vec3 sheenColor;
	uniform float sheenRoughness;
	#ifdef USE_SHEENCOLORMAP
		uniform sampler2D sheenColorMap;
	#endif
	#ifdef USE_SHEENROUGHNESSMAP
		uniform sampler2D sheenRoughnessMap;
	#endif
#endif
varying vec3 vViewPosition;
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <bsdfs>
#include <cube_uv_reflection_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_physical_pars_fragment>
#include <fog_pars_fragment>
#include <lights_pars_begin>
#include <normal_pars_fragment>
#include <lights_physical_pars_fragment>
#include <transmission_pars_fragment>
#include <shadowmap_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <clearcoat_pars_fragment>
#include <roughnessmap_pars_fragment>
#include <metalnessmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <roughnessmap_fragment>
	#include <metalnessmap_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	#include <clearcoat_normal_fragment_begin>
	#include <clearcoat_normal_fragment_maps>
	#include <emissivemap_fragment>
	#include <lights_physical_fragment>
	#include <lights_fragment_begin>
	#include <lights_fragment_maps>
	#include <lights_fragment_end>
	#include <aomap_fragment>
	vec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;
	vec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;
	#include <transmission_fragment>
	vec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;
	#ifdef USE_SHEEN
		float sheenEnergyComp = 1.0 - 0.157 * max3( material.sheenColor );
		outgoingLight = outgoingLight * sheenEnergyComp + sheenSpecular;
	#endif
	#ifdef USE_CLEARCOAT
		float dotNVcc = saturate( dot( geometry.clearcoatNormal, geometry.viewDir ) );
		vec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );
		outgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + clearcoatSpecular * material.clearcoat;
	#endif
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,B1=`#define TOON
varying vec3 vViewPosition;
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <displacementmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vViewPosition = - mvPosition.xyz;
	#include <worldpos_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,O1=`#define TOON
uniform vec3 diffuse;
uniform vec3 emissive;
uniform float opacity;
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <gradientmap_pars_fragment>
#include <fog_pars_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <normal_pars_fragment>
#include <lights_toon_pars_fragment>
#include <shadowmap_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	#include <emissivemap_fragment>
	#include <lights_toon_fragment>
	#include <lights_fragment_begin>
	#include <lights_fragment_maps>
	#include <lights_fragment_end>
	#include <aomap_fragment>
	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,k1=`uniform float size;
uniform float scale;
#include <common>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <color_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <project_vertex>
	gl_PointSize = size;
	#ifdef USE_SIZEATTENUATION
		bool isPerspective = isPerspectiveMatrix( projectionMatrix );
		if ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );
	#endif
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <worldpos_vertex>
	#include <fog_vertex>
}`,H1=`uniform vec3 diffuse;
uniform float opacity;
#include <common>
#include <color_pars_fragment>
#include <map_particle_pars_fragment>
#include <alphatest_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec3 outgoingLight = vec3( 0.0 );
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_particle_fragment>
	#include <color_fragment>
	#include <alphatest_fragment>
	outgoingLight = diffuseColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
}`,V1=`#include <common>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
void main() {
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <project_vertex>
	#include <worldpos_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,G1=`uniform vec3 color;
uniform float opacity;
#include <common>
#include <packing>
#include <fog_pars_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <shadowmap_pars_fragment>
#include <shadowmask_pars_fragment>
void main() {
	gl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
}`,W1=`uniform float rotation;
uniform vec2 center;
#include <common>
#include <uv_pars_vertex>
#include <fog_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	vec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );
	vec2 scale;
	scale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );
	scale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );
	#ifndef USE_SIZEATTENUATION
		bool isPerspective = isPerspectiveMatrix( projectionMatrix );
		if ( isPerspective ) scale *= - mvPosition.z;
	#endif
	vec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;
	vec2 rotatedPosition;
	rotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;
	rotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;
	mvPosition.xy += rotatedPosition;
	gl_Position = projectionMatrix * mvPosition;
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <fog_vertex>
}`,q1=`uniform vec3 diffuse;
uniform float opacity;
#include <common>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec3 outgoingLight = vec3( 0.0 );
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	outgoingLight = diffuseColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
}`,Pt={alphamap_fragment:_M,alphamap_pars_fragment:wM,alphatest_fragment:MM,alphatest_pars_fragment:bM,aomap_fragment:SM,aomap_pars_fragment:EM,begin_vertex:TM,beginnormal_vertex:AM,bsdfs:CM,bumpmap_pars_fragment:RM,clipping_planes_fragment:LM,clipping_planes_pars_fragment:PM,clipping_planes_pars_vertex:DM,clipping_planes_vertex:IM,color_fragment:NM,color_pars_fragment:FM,color_pars_vertex:zM,color_vertex:UM,common:BM,cube_uv_reflection_fragment:OM,defaultnormal_vertex:kM,displacementmap_pars_vertex:HM,displacementmap_vertex:VM,emissivemap_fragment:GM,emissivemap_pars_fragment:WM,encodings_fragment:qM,encodings_pars_fragment:XM,envmap_fragment:YM,envmap_common_pars_fragment:ZM,envmap_pars_fragment:JM,envmap_pars_vertex:$M,envmap_physical_pars_fragment:ab,envmap_vertex:KM,fog_vertex:QM,fog_pars_vertex:jM,fog_fragment:tb,fog_pars_fragment:eb,gradientmap_pars_fragment:nb,lightmap_fragment:ib,lightmap_pars_fragment:rb,lights_lambert_vertex:sb,lights_pars_begin:ob,lights_toon_fragment:lb,lights_toon_pars_fragment:cb,lights_phong_fragment:ub,lights_phong_pars_fragment:hb,lights_physical_fragment:fb,lights_physical_pars_fragment:db,lights_fragment_begin:pb,lights_fragment_maps:mb,lights_fragment_end:gb,logdepthbuf_fragment:xb,logdepthbuf_pars_fragment:yb,logdepthbuf_pars_vertex:vb,logdepthbuf_vertex:_b,map_fragment:wb,map_pars_fragment:Mb,map_particle_fragment:bb,map_particle_pars_fragment:Sb,metalnessmap_fragment:Eb,metalnessmap_pars_fragment:Tb,morphnormal_vertex:Ab,morphtarget_pars_vertex:Cb,morphtarget_vertex:Rb,normal_fragment_begin:Lb,normal_fragment_maps:Pb,normal_pars_fragment:Db,normal_pars_vertex:Ib,normal_vertex:Nb,normalmap_pars_fragment:Fb,clearcoat_normal_fragment_begin:zb,clearcoat_normal_fragment_maps:Ub,clearcoat_pars_fragment:Bb,output_fragment:Ob,packing:kb,premultiplied_alpha_fragment:Hb,project_vertex:Vb,dithering_fragment:Gb,dithering_pars_fragment:Wb,roughnessmap_fragment:qb,roughnessmap_pars_fragment:Xb,shadowmap_pars_fragment:Yb,shadowmap_pars_vertex:Zb,shadowmap_vertex:Jb,shadowmask_pars_fragment:$b,skinbase_vertex:Kb,skinning_pars_vertex:Qb,skinning_vertex:jb,skinnormal_vertex:t1,specularmap_fragment:e1,specularmap_pars_fragment:n1,tonemapping_fragment:i1,tonemapping_pars_fragment:r1,transmission_fragment:s1,transmission_pars_fragment:o1,uv_pars_fragment:a1,uv_pars_vertex:l1,uv_vertex:c1,uv2_pars_fragment:u1,uv2_pars_vertex:h1,uv2_vertex:f1,worldpos_vertex:d1,background_vert:p1,background_frag:m1,cube_vert:g1,cube_frag:x1,depth_vert:y1,depth_frag:v1,distanceRGBA_vert:_1,distanceRGBA_frag:w1,equirect_vert:M1,equirect_frag:b1,linedashed_vert:S1,linedashed_frag:E1,meshbasic_vert:T1,meshbasic_frag:A1,meshlambert_vert:C1,meshlambert_frag:R1,meshmatcap_vert:L1,meshmatcap_frag:P1,meshnormal_vert:D1,meshnormal_frag:I1,meshphong_vert:N1,meshphong_frag:F1,meshphysical_vert:z1,meshphysical_frag:U1,meshtoon_vert:B1,meshtoon_frag:O1,points_vert:k1,points_frag:H1,shadow_vert:V1,shadow_frag:G1,sprite_vert:W1,sprite_frag:q1},ot={common:{diffuse:{value:new ft(16777215)},opacity:{value:1},map:{value:null},uvTransform:{value:new de},uv2Transform:{value:new de},alphaMap:{value:null},alphaTest:{value:0}},specularmap:{specularMap:{value:null}},envmap:{envMap:{value:null},flipEnvMap:{value:-1},reflectivity:{value:1},ior:{value:1.5},refractionRatio:{value:.98}},aomap:{aoMap:{value:null},aoMapIntensity:{value:1}},lightmap:{lightMap:{value:null},lightMapIntensity:{value:1}},emissivemap:{emissiveMap:{value:null}},bumpmap:{bumpMap:{value:null},bumpScale:{value:1}},normalmap:{normalMap:{value:null},normalScale:{value:new K(1,1)}},displacementmap:{displacementMap:{value:null},displacementScale:{value:1},displacementBias:{value:0}},roughnessmap:{roughnessMap:{value:null}},metalnessmap:{metalnessMap:{value:null}},gradientmap:{gradientMap:{value:null}},fog:{fogDensity:{value:25e-5},fogNear:{value:1},fogFar:{value:2e3},fogColor:{value:new ft(16777215)}},lights:{ambientLightColor:{value:[]},lightProbe:{value:[]},directionalLights:{value:[],properties:{direction:{},color:{}}},directionalLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},directionalShadowMap:{value:[]},directionalShadowMatrix:{value:[]},spotLights:{value:[],properties:{color:{},position:{},direction:{},distance:{},coneCos:{},penumbraCos:{},decay:{}}},spotLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},spotShadowMap:{value:[]},spotShadowMatrix:{value:[]},pointLights:{value:[],properties:{color:{},position:{},decay:{},distance:{}}},pointLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{},shadowCameraNear:{},shadowCameraFar:{}}},pointShadowMap:{value:[]},pointShadowMatrix:{value:[]},hemisphereLights:{value:[],properties:{direction:{},skyColor:{},groundColor:{}}},rectAreaLights:{value:[],properties:{color:{},position:{},width:{},height:{}}},ltc_1:{value:null},ltc_2:{value:null}},points:{diffuse:{value:new ft(16777215)},opacity:{value:1},size:{value:1},scale:{value:1},map:{value:null},alphaMap:{value:null},alphaTest:{value:0},uvTransform:{value:new de}},sprite:{diffuse:{value:new ft(16777215)},opacity:{value:1},center:{value:new K(.5,.5)},rotation:{value:0},map:{value:null},alphaMap:{value:null},alphaTest:{value:0},uvTransform:{value:new de}}},fn={basic:{uniforms:Me([ot.common,ot.specularmap,ot.envmap,ot.aomap,ot.lightmap,ot.fog]),vertexShader:Pt.meshbasic_vert,fragmentShader:Pt.meshbasic_frag},lambert:{uniforms:Me([ot.common,ot.specularmap,ot.envmap,ot.aomap,ot.lightmap,ot.emissivemap,ot.fog,ot.lights,{emissive:{value:new ft(0)}}]),vertexShader:Pt.meshlambert_vert,fragmentShader:Pt.meshlambert_frag},phong:{uniforms:Me([ot.common,ot.specularmap,ot.envmap,ot.aomap,ot.lightmap,ot.emissivemap,ot.bumpmap,ot.normalmap,ot.displacementmap,ot.fog,ot.lights,{emissive:{value:new ft(0)},specular:{value:new ft(1118481)},shininess:{value:30}}]),vertexShader:Pt.meshphong_vert,fragmentShader:Pt.meshphong_frag},standard:{uniforms:Me([ot.common,ot.envmap,ot.aomap,ot.lightmap,ot.emissivemap,ot.bumpmap,ot.normalmap,ot.displacementmap,ot.roughnessmap,ot.metalnessmap,ot.fog,ot.lights,{emissive:{value:new ft(0)},roughness:{value:1},metalness:{value:0},envMapIntensity:{value:1}}]),vertexShader:Pt.meshphysical_vert,fragmentShader:Pt.meshphysical_frag},toon:{uniforms:Me([ot.common,ot.aomap,ot.lightmap,ot.emissivemap,ot.bumpmap,ot.normalmap,ot.displacementmap,ot.gradientmap,ot.fog,ot.lights,{emissive:{value:new ft(0)}}]),vertexShader:Pt.meshtoon_vert,fragmentShader:Pt.meshtoon_frag},matcap:{uniforms:Me([ot.common,ot.bumpmap,ot.normalmap,ot.displacementmap,ot.fog,{matcap:{value:null}}]),vertexShader:Pt.meshmatcap_vert,fragmentShader:Pt.meshmatcap_frag},points:{uniforms:Me([ot.points,ot.fog]),vertexShader:Pt.points_vert,fragmentShader:Pt.points_frag},dashed:{uniforms:Me([ot.common,ot.fog,{scale:{value:1},dashSize:{value:1},totalSize:{value:2}}]),vertexShader:Pt.linedashed_vert,fragmentShader:Pt.linedashed_frag},depth:{uniforms:Me([ot.common,ot.displacementmap]),vertexShader:Pt.depth_vert,fragmentShader:Pt.depth_frag},normal:{uniforms:Me([ot.common,ot.bumpmap,ot.normalmap,ot.displacementmap,{opacity:{value:1}}]),vertexShader:Pt.meshnormal_vert,fragmentShader:Pt.meshnormal_frag},sprite:{uniforms:Me([ot.sprite,ot.fog]),vertexShader:Pt.sprite_vert,fragmentShader:Pt.sprite_frag},background:{uniforms:{uvTransform:{value:new de},t2D:{value:null}},vertexShader:Pt.background_vert,fragmentShader:Pt.background_frag},cube:{uniforms:Me([ot.envmap,{opacity:{value:1}}]),vertexShader:Pt.cube_vert,fragmentShader:Pt.cube_frag},equirect:{uniforms:{tEquirect:{value:null}},vertexShader:Pt.equirect_vert,fragmentShader:Pt.equirect_frag},distanceRGBA:{uniforms:Me([ot.common,ot.displacementmap,{referencePosition:{value:new T},nearDistance:{value:1},farDistance:{value:1e3}}]),vertexShader:Pt.distanceRGBA_vert,fragmentShader:Pt.distanceRGBA_frag},shadow:{uniforms:Me([ot.lights,ot.fog,{color:{value:new ft(0)},opacity:{value:1}}]),vertexShader:Pt.shadow_vert,fragmentShader:Pt.shadow_frag}};fn.physical={uniforms:Me([fn.standard.uniforms,{clearcoat:{value:0},clearcoatMap:{value:null},clearcoatRoughness:{value:0},clearcoatRoughnessMap:{value:null},clearcoatNormalScale:{value:new K(1,1)},clearcoatNormalMap:{value:null},sheen:{value:0},sheenColor:{value:new ft(0)},sheenColorMap:{value:null},sheenRoughness:{value:1},sheenRoughnessMap:{value:null},transmission:{value:0},transmissionMap:{value:null},transmissionSamplerSize:{value:new K},transmissionSamplerMap:{value:null},thickness:{value:0},thicknessMap:{value:null},attenuationDistance:{value:0},attenuationColor:{value:new ft(0)},specularIntensity:{value:1},specularIntensityMap:{value:null},specularColor:{value:new ft(1,1,1)},specularColorMap:{value:null}}]),vertexShader:Pt.meshphysical_vert,fragmentShader:Pt.meshphysical_frag};function X1(n,t,e,i,r,s){let o=new ft(0),a=r===!0?0:1,l,c,u=null,h=0,f=null;function d(x,v){let m=!1,p=v.isScene===!0?v.background:null;p&&p.isTexture&&(p=t.get(p));let b=n.xr,_=b.getSession&&b.getSession();_&&_.environmentBlendMode==="additive"&&(p=null),p===null?g(o,a):p&&p.isColor&&(g(p,1),m=!0),(n.autoClear||m)&&n.clear(n.autoClearColor,n.autoClearDepth,n.autoClearStencil),p&&(p.isCubeTexture||p.mapping===Rl)?(c===void 0&&(c=new oe(new Hi(1,1,1),new Fn({name:"BackgroundCubeMaterial",uniforms:Gr(fn.cube.uniforms),vertexShader:fn.cube.vertexShader,fragmentShader:fn.cube.fragmentShader,side:he,depthTest:!1,depthWrite:!1,fog:!1})),c.geometry.deleteAttribute("normal"),c.geometry.deleteAttribute("uv"),c.onBeforeRender=function(S,L,A){this.matrixWorld.copyPosition(A.matrixWorld)},Object.defineProperty(c.material,"envMap",{get:function(){return this.uniforms.envMap.value}}),i.update(c)),c.material.uniforms.envMap.value=p,c.material.uniforms.flipEnvMap.value=p.isCubeTexture&&p.isRenderTargetTexture===!1?-1:1,(u!==p||h!==p.version||f!==n.toneMapping)&&(c.material.needsUpdate=!0,u=p,h=p.version,f=n.toneMapping),x.unshift(c,c.geometry,c.material,0,0,null)):p&&p.isTexture&&(l===void 0&&(l=new oe(new lo(2,2),new Fn({name:"BackgroundMaterial",uniforms:Gr(fn.background.uniforms),vertexShader:fn.background.vertexShader,fragmentShader:fn.background.fragmentShader,side:eo,depthTest:!1,depthWrite:!1,fog:!1})),l.geometry.deleteAttribute("normal"),Object.defineProperty(l.material,"map",{get:function(){return this.uniforms.t2D.value}}),i.update(l)),l.material.uniforms.t2D.value=p,p.matrixAutoUpdate===!0&&p.updateMatrix(),l.material.uniforms.uvTransform.value.copy(p.matrix),(u!==p||h!==p.version||f!==n.toneMapping)&&(l.material.needsUpdate=!0,u=p,h=p.version,f=n.toneMapping),x.unshift(l,l.geometry,l.material,0,0,null))}function g(x,v){e.buffers.color.setClear(x.r,x.g,x.b,v,s)}return{getClearColor:function(){return o},setClearColor:function(x,v=1){o.set(x),a=v,g(o,a)},getClearAlpha:function(){return a},setClearAlpha:function(x){a=x,g(o,a)},render:d}}function Y1(n,t,e,i){let r=n.getParameter(34921),s=i.isWebGL2?null:t.get("OES_vertex_array_object"),o=i.isWebGL2||s!==null,a={},l=x(null),c=l;function u(D,F,z,N,V){let Q=!1;if(o){let at=g(N,z,F);c!==at&&(c=at,f(c.object)),Q=v(N,V),Q&&m(N,V)}else{let at=F.wireframe===!0;(c.geometry!==N.id||c.program!==z.id||c.wireframe!==at)&&(c.geometry=N.id,c.program=z.id,c.wireframe=at,Q=!0)}D.isInstancedMesh===!0&&(Q=!0),V!==null&&e.update(V,34963),Q&&(A(D,F,z,N),V!==null&&n.bindBuffer(34963,e.get(V).buffer))}function h(){return i.isWebGL2?n.createVertexArray():s.createVertexArrayOES()}function f(D){return i.isWebGL2?n.bindVertexArray(D):s.bindVertexArrayOES(D)}function d(D){return i.isWebGL2?n.deleteVertexArray(D):s.deleteVertexArrayOES(D)}function g(D,F,z){let N=z.wireframe===!0,V=a[D.id];V===void 0&&(V={},a[D.id]=V);let Q=V[F.id];Q===void 0&&(Q={},V[F.id]=Q);let at=Q[N];return at===void 0&&(at=x(h()),Q[N]=at),at}function x(D){let F=[],z=[],N=[];for(let V=0;V<r;V++)F[V]=0,z[V]=0,N[V]=0;return{geometry:null,program:null,wireframe:!1,newAttributes:F,enabledAttributes:z,attributeDivisors:N,object:D,attributes:{},index:null}}function v(D,F){let z=c.attributes,N=D.attributes,V=0;for(let Q in N){let at=z[Q],G=N[Q];if(at===void 0||at.attribute!==G||at.data!==G.data)return!0;V++}return c.attributesNum!==V||c.index!==F}function m(D,F){let z={},N=D.attributes,V=0;for(let Q in N){let at=N[Q],G={};G.attribute=at,at.data&&(G.data=at.data),z[Q]=G,V++}c.attributes=z,c.attributesNum=V,c.index=F}function p(){let D=c.newAttributes;for(let F=0,z=D.length;F<z;F++)D[F]=0}function b(D){_(D,0)}function _(D,F){let z=c.newAttributes,N=c.enabledAttributes,V=c.attributeDivisors;z[D]=1,N[D]===0&&(n.enableVertexAttribArray(D),N[D]=1),V[D]!==F&&((i.isWebGL2?n:t.get("ANGLE_instanced_arrays"))[i.isWebGL2?"vertexAttribDivisor":"vertexAttribDivisorANGLE"](D,F),V[D]=F)}function S(){let D=c.newAttributes,F=c.enabledAttributes;for(let z=0,N=F.length;z<N;z++)F[z]!==D[z]&&(n.disableVertexAttribArray(z),F[z]=0)}function L(D,F,z,N,V,Q){i.isWebGL2===!0&&(z===5124||z===5125)?n.vertexAttribIPointer(D,F,z,V,Q):n.vertexAttribPointer(D,F,z,N,V,Q)}function A(D,F,z,N){if(i.isWebGL2===!1&&(D.isInstancedMesh||N.isInstancedBufferGeometry)&&t.get("ANGLE_instanced_arrays")===null)return;p();let V=N.attributes,Q=z.getAttributes(),at=F.defaultAttributeValues;for(let G in Q){let $=Q[G];if($.location>=0){let lt=V[G];if(lt===void 0&&(G==="instanceMatrix"&&D.instanceMatrix&&(lt=D.instanceMatrix),G==="instanceColor"&&D.instanceColor&&(lt=D.instanceColor)),lt!==void 0){let dt=lt.normalized,xt=lt.itemSize,k=e.get(lt);if(k===void 0)continue;let Ft=k.buffer,mt=k.type,St=k.bytesPerElement;if(lt.isInterleavedBufferAttribute){let B=lt.data,st=B.stride,nt=lt.offset;if(B&&B.isInstancedInterleavedBuffer){for(let C=0;C<$.locationSize;C++)_($.location+C,B.meshPerAttribute);D.isInstancedMesh!==!0&&N._maxInstanceCount===void 0&&(N._maxInstanceCount=B.meshPerAttribute*B.count)}else for(let C=0;C<$.locationSize;C++)b($.location+C);n.bindBuffer(34962,Ft);for(let C=0;C<$.locationSize;C++)L($.location+C,xt/$.locationSize,mt,dt,st*St,(nt+xt/$.locationSize*C)*St)}else{if(lt.isInstancedBufferAttribute){for(let B=0;B<$.locationSize;B++)_($.location+B,lt.meshPerAttribute);D.isInstancedMesh!==!0&&N._maxInstanceCount===void 0&&(N._maxInstanceCount=lt.meshPerAttribute*lt.count)}else for(let B=0;B<$.locationSize;B++)b($.location+B);n.bindBuffer(34962,Ft);for(let B=0;B<$.locationSize;B++)L($.location+B,xt/$.locationSize,mt,dt,xt*St,xt/$.locationSize*B*St)}}else if(at!==void 0){let dt=at[G];if(dt!==void 0)switch(dt.length){case 2:n.vertexAttrib2fv($.location,dt);break;case 3:n.vertexAttrib3fv($.location,dt);break;case 4:n.vertexAttrib4fv($.location,dt);break;default:n.vertexAttrib1fv($.location,dt)}}}}S()}function H(){y();for(let D in a){let F=a[D];for(let z in F){let N=F[z];for(let V in N)d(N[V].object),delete N[V];delete F[z]}delete a[D]}}function tt(D){if(a[D.id]===void 0)return;let F=a[D.id];for(let z in F){let N=F[z];for(let V in N)d(N[V].object),delete N[V];delete F[z]}delete a[D.id]}function X(D){for(let F in a){let z=a[F];if(z[D.id]===void 0)continue;let N=z[D.id];for(let V in N)d(N[V].object),delete N[V];delete z[D.id]}}function y(){R(),c!==l&&(c=l,f(c.object))}function R(){l.geometry=null,l.program=null,l.wireframe=!1}return{setup:u,reset:y,resetDefaultState:R,dispose:H,releaseStatesOfGeometry:tt,releaseStatesOfProgram:X,initAttributes:p,enableAttribute:b,disableUnusedAttributes:S}}function Z1(n,t,e,i){let r=i.isWebGL2,s;function o(c){s=c}function a(c,u){n.drawArrays(s,c,u),e.update(u,s,1)}function l(c,u,h){if(h===0)return;let f,d;if(r)f=n,d="drawArraysInstanced";else if(f=t.get("ANGLE_instanced_arrays"),d="drawArraysInstancedANGLE",f===null){console.error("THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");return}f[d](s,c,u,h),e.update(u,s,h)}this.setMode=o,this.render=a,this.renderInstances=l}function J1(n,t,e){let i;function r(){if(i!==void 0)return i;if(t.has("EXT_texture_filter_anisotropic")===!0){let A=t.get("EXT_texture_filter_anisotropic");i=n.getParameter(A.MAX_TEXTURE_MAX_ANISOTROPY_EXT)}else i=0;return i}function s(A){if(A==="highp"){if(n.getShaderPrecisionFormat(35633,36338).precision>0&&n.getShaderPrecisionFormat(35632,36338).precision>0)return"highp";A="mediump"}return A==="mediump"&&n.getShaderPrecisionFormat(35633,36337).precision>0&&n.getShaderPrecisionFormat(35632,36337).precision>0?"mediump":"lowp"}let o=typeof WebGL2RenderingContext!="undefined"&&n instanceof WebGL2RenderingContext||typeof WebGL2ComputeRenderingContext!="undefined"&&n instanceof WebGL2ComputeRenderingContext,a=e.precision!==void 0?e.precision:"highp",l=s(a);l!==a&&(console.warn("THREE.WebGLRenderer:",a,"not supported, using",l,"instead."),a=l);let c=o||t.has("WEBGL_draw_buffers"),u=e.logarithmicDepthBuffer===!0,h=n.getParameter(34930),f=n.getParameter(35660),d=n.getParameter(3379),g=n.getParameter(34076),x=n.getParameter(34921),v=n.getParameter(36347),m=n.getParameter(36348),p=n.getParameter(36349),b=f>0,_=o||t.has("OES_texture_float"),S=b&&_,L=o?n.getParameter(36183):0;return{isWebGL2:o,drawBuffers:c,getMaxAnisotropy:r,getMaxPrecision:s,precision:a,logarithmicDepthBuffer:u,maxTextures:h,maxVertexTextures:f,maxTextureSize:d,maxCubemapSize:g,maxAttributes:x,maxVertexUniforms:v,maxVaryings:m,maxFragmentUniforms:p,vertexTextures:b,floatFragmentTextures:_,floatVertexTextures:S,maxSamples:L}}function $1(n){let t=this,e=null,i=0,r=!1,s=!1,o=new je,a=new de,l={value:null,needsUpdate:!1};this.uniform=l,this.numPlanes=0,this.numIntersection=0,this.init=function(h,f,d){let g=h.length!==0||f||i!==0||r;return r=f,e=u(h,d,0),i=h.length,g},this.beginShadows=function(){s=!0,u(null)},this.endShadows=function(){s=!1,c()},this.setState=function(h,f,d){let g=h.clippingPlanes,x=h.clipIntersection,v=h.clipShadows,m=n.get(h);if(!r||g===null||g.length===0||s&&!v)s?u(null):c();else{let p=s?0:i,b=p*4,_=m.clippingState||null;l.value=_,_=u(g,f,b,d);for(let S=0;S!==b;++S)_[S]=e[S];m.clippingState=_,this.numIntersection=x?this.numPlanes:0,this.numPlanes+=p}};function c(){l.value!==e&&(l.value=e,l.needsUpdate=i>0),t.numPlanes=i,t.numIntersection=0}function u(h,f,d,g){let x=h!==null?h.length:0,v=null;if(x!==0){if(v=l.value,g!==!0||v===null){let m=d+x*4,p=f.matrixWorldInverse;a.getNormalMatrix(p),(v===null||v.length<m)&&(v=new Float32Array(m));for(let b=0,_=d;b!==x;++b,_+=4)o.copy(h[b]).applyMatrix4(p,a),o.normal.toArray(v,_),v[_+3]=o.constant}l.value=v,l.needsUpdate=!0}return t.numPlanes=x,t.numIntersection=0,v}}function K1(n){let t=new WeakMap;function e(o,a){return a===Uu?o.mapping=Ao:a===Bu&&(o.mapping=Co),o}function i(o){if(o&&o.isTexture&&o.isRenderTargetTexture===!1){let a=o.mapping;if(a===Uu||a===Bu)if(t.has(o)){let l=t.get(o).texture;return e(l,o.mapping)}else{let l=o.image;if(l&&l.height>0){let c=new ol(l.height/2);return c.fromEquirectangularTexture(n,o),t.set(o,c),o.addEventListener("dispose",r),e(c.texture,o.mapping)}else return null}}return o}function r(o){let a=o.target;a.removeEventListener("dispose",r);let l=t.get(a);l!==void 0&&(t.delete(a),l.dispose())}function s(){t=new WeakMap}return{get:i,dispose:s}}var Vi=class extends oo{constructor(t=-1,e=1,i=1,r=-1,s=.1,o=2e3){super(),this.type="OrthographicCamera",this.zoom=1,this.view=null,this.left=t,this.right=e,this.top=i,this.bottom=r,this.near=s,this.far=o,this.updateProjectionMatrix()}copy(t,e){return super.copy(t,e),this.left=t.left,this.right=t.right,this.top=t.top,this.bottom=t.bottom,this.near=t.near,this.far=t.far,this.zoom=t.zoom,this.view=t.view===null?null:Object.assign({},t.view),this}setViewOffset(t,e,i,r,s,o){this.view===null&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=e,this.view.offsetX=i,this.view.offsetY=r,this.view.width=s,this.view.height=o,this.updateProjectionMatrix()}clearViewOffset(){this.view!==null&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let t=(this.right-this.left)/(2*this.zoom),e=(this.top-this.bottom)/(2*this.zoom),i=(this.right+this.left)/2,r=(this.top+this.bottom)/2,s=i-t,o=i+t,a=r+e,l=r-e;if(this.view!==null&&this.view.enabled){let c=(this.right-this.left)/this.view.fullWidth/this.zoom,u=(this.top-this.bottom)/this.view.fullHeight/this.zoom;s+=c*this.view.offsetX,o=s+c*this.view.width,a-=u*this.view.offsetY,l=a-u*this.view.height}this.projectionMatrix.makeOrthographic(s,o,a,l,this.near,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){let e=super.toJSON(t);return e.object.zoom=this.zoom,e.object.left=this.left,e.object.right=this.right,e.object.top=this.top,e.object.bottom=this.bottom,e.object.near=this.near,e.object.far=this.far,this.view!==null&&(e.object.view=Object.assign({},this.view)),e}};Vi.prototype.isOrthographicCamera=!0;var Xr=class extends Fn{constructor(t){super(t),this.type="RawShaderMaterial"}};Xr.prototype.isRawShaderMaterial=!0;var kr=4,ni=8,hn=Math.pow(2,ni),x0=[.125,.215,.35,.446,.526,.582],y0=ni-kr+1+x0.length,Ar=20,Tu=new Vi,{_lodPlanes:Gs,_sizeLods:mg,_sigmas:Ua}=Q1(),gg=new ft,Au=null,zi=(1+Math.sqrt(5))/2,Cr=1/zi,xg=[new T(1,1,1),new T(-1,1,1),new T(1,1,-1),new T(-1,1,-1),new T(0,zi,Cr),new T(0,zi,-Cr),new T(Cr,0,zi),new T(-Cr,0,zi),new T(zi,Cr,0),new T(-zi,Cr,0)],al=class{constructor(t){this._renderer=t,this._pingPongRenderTarget=null,this._blurMaterial=j1(Ar),this._equirectShader=null,this._cubemapShader=null,this._compileMaterial(this._blurMaterial)}fromScene(t,e=0,i=.1,r=100){Au=this._renderer.getRenderTarget();let s=this._allocateTargets();return this._sceneToCubeUV(t,i,r,s),e>0&&this._blur(s,0,0,e),this._applyPMREM(s),this._cleanup(s),s}fromEquirectangular(t,e=null){return this._fromTexture(t,e)}fromCubemap(t,e=null){return this._fromTexture(t,e)}compileCubemapShader(){this._cubemapShader===null&&(this._cubemapShader=_g(),this._compileMaterial(this._cubemapShader))}compileEquirectangularShader(){this._equirectShader===null&&(this._equirectShader=vg(),this._compileMaterial(this._equirectShader))}dispose(){this._blurMaterial.dispose(),this._pingPongRenderTarget!==null&&this._pingPongRenderTarget.dispose(),this._cubemapShader!==null&&this._cubemapShader.dispose(),this._equirectShader!==null&&this._equirectShader.dispose();for(let t=0;t<Gs.length;t++)Gs[t].dispose()}_cleanup(t){this._renderer.setRenderTarget(Au),t.scissorTest=!1,Ba(t,0,0,t.width,t.height)}_fromTexture(t,e){Au=this._renderer.getRenderTarget();let i=e||this._allocateTargets(t);return this._textureToCubeUV(t,i),this._applyPMREM(i),this._cleanup(i),i}_allocateTargets(t){let e={magFilter:be,minFilter:be,generateMipmaps:!1,type:Ur,format:Re,encoding:ri,depthBuffer:!1},i=yg(e);return i.depthBuffer=!t,this._pingPongRenderTarget===null&&(this._pingPongRenderTarget=yg(e)),i}_compileMaterial(t){let e=new oe(Gs[0],t);this._renderer.compile(e,Tu)}_sceneToCubeUV(t,e,i,r){let a=new Se(90,1,e,i),l=[1,-1,1,1,1,1],c=[1,1,1,-1,-1,-1],u=this._renderer,h=u.autoClear,f=u.toneMapping;u.getClearColor(gg),u.toneMapping=ti,u.autoClear=!1;let d=new ki({name:"PMREM.Background",side:he,depthWrite:!1,depthTest:!1}),g=new oe(new Hi,d),x=!1,v=t.background;v?v.isColor&&(d.color.copy(v),t.background=null,x=!0):(d.color.copy(gg),x=!0);for(let m=0;m<6;m++){let p=m%3;p===0?(a.up.set(0,l[m],0),a.lookAt(c[m],0,0)):p===1?(a.up.set(0,0,l[m]),a.lookAt(0,c[m],0)):(a.up.set(0,l[m],0),a.lookAt(0,0,c[m])),Ba(r,p*hn,m>2?hn:0,hn,hn),u.setRenderTarget(r),x&&u.render(g,a),u.render(t,a)}g.geometry.dispose(),g.material.dispose(),u.toneMapping=f,u.autoClear=h,t.background=v}_textureToCubeUV(t,e){let i=this._renderer,r=t.mapping===Ao||t.mapping===Co;r?(this._cubemapShader===null&&(this._cubemapShader=_g()),this._cubemapShader.uniforms.flipEnvMap.value=t.isRenderTargetTexture===!1?-1:1):this._equirectShader===null&&(this._equirectShader=vg());let s=r?this._cubemapShader:this._equirectShader,o=new oe(Gs[0],s),a=s.uniforms;a.envMap.value=t,r||a.texelSize.value.set(1/t.image.width,1/t.image.height),Ba(e,0,0,3*hn,2*hn),i.setRenderTarget(e),i.render(o,Tu)}_applyPMREM(t){let e=this._renderer,i=e.autoClear;e.autoClear=!1;for(let r=1;r<y0;r++){let s=Math.sqrt(Ua[r]*Ua[r]-Ua[r-1]*Ua[r-1]),o=xg[(r-1)%xg.length];this._blur(t,r-1,r,s,o)}e.autoClear=i}_blur(t,e,i,r,s){let o=this._pingPongRenderTarget;this._halfBlur(t,o,e,i,r,"latitudinal",s),this._halfBlur(o,t,i,i,r,"longitudinal",s)}_halfBlur(t,e,i,r,s,o,a){let l=this._renderer,c=this._blurMaterial;o!=="latitudinal"&&o!=="longitudinal"&&console.error("blur direction must be either latitudinal or longitudinal!");let u=3,h=new oe(Gs[r],c),f=c.uniforms,d=mg[i]-1,g=isFinite(s)?Math.PI/(2*d):2*Math.PI/(2*Ar-1),x=s/g,v=isFinite(s)?1+Math.floor(u*x):Ar;v>Ar&&console.warn(`sigmaRadians, ${s}, is too large and will clip, as it requested ${v} samples when the maximum is set to ${Ar}`);let m=[],p=0;for(let L=0;L<Ar;++L){let A=L/x,H=Math.exp(-A*A/2);m.push(H),L===0?p+=H:L<v&&(p+=2*H)}for(let L=0;L<m.length;L++)m[L]=m[L]/p;f.envMap.value=t.texture,f.samples.value=v,f.weights.value=m,f.latitudinal.value=o==="latitudinal",a&&(f.poleAxis.value=a),f.dTheta.value=g,f.mipInt.value=ni-i;let b=mg[r],_=3*Math.max(0,hn-2*b),S=(r===0?0:2*hn)+2*b*(r>ni-kr?r-ni+kr:0);Ba(e,_,S,3*b,2*b),l.setRenderTarget(e),l.render(h,Tu)}};function Q1(){let n=[],t=[],e=[],i=ni;for(let r=0;r<y0;r++){let s=Math.pow(2,i);t.push(s);let o=1/s;r>ni-kr?o=x0[r-ni+kr-1]:r===0&&(o=0),e.push(o);let a=1/(s-1),l=-a/2,c=1+a/2,u=[l,l,c,l,c,c,l,l,c,c,l,c],h=6,f=6,d=3,g=2,x=1,v=new Float32Array(d*f*h),m=new Float32Array(g*f*h),p=new Float32Array(x*f*h);for(let _=0;_<h;_++){let S=_%3*2/3-1,L=_>2?0:-1,A=[S,L,0,S+2/3,L,0,S+2/3,L+1,0,S,L,0,S+2/3,L+1,0,S,L+1,0];v.set(A,d*f*_),m.set(u,g*f*_);let H=[_,_,_,_,_,_];p.set(H,x*f*_)}let b=new Ht;b.setAttribute("position",new Qt(v,d)),b.setAttribute("uv",new Qt(m,g)),b.setAttribute("faceIndex",new Qt(p,x)),n.push(b),i>kr&&i--}return{_lodPlanes:n,_sizeLods:t,_sigmas:e}}function yg(n){let t=new Ne(3*hn,3*hn,n);return t.texture.mapping=Rl,t.texture.name="PMREM.cubeUv",t.scissorTest=!0,t}function Ba(n,t,e,i,r){n.viewport.set(t,e,i,r),n.scissor.set(t,e,i,r)}function j1(n){let t=new Float32Array(n),e=new T(0,1,0);return new Xr({name:"SphericalGaussianBlur",defines:{n},uniforms:{envMap:{value:null},samples:{value:1},weights:{value:t},latitudinal:{value:!1},dTheta:{value:0},mipInt:{value:0},poleAxis:{value:e}},vertexShader:jh(),fragmentShader:`

			precision mediump float;
			precision mediump int;

			varying vec3 vOutputDirection;

			uniform sampler2D envMap;
			uniform int samples;
			uniform float weights[ n ];
			uniform bool latitudinal;
			uniform float dTheta;
			uniform float mipInt;
			uniform vec3 poleAxis;

			#define ENVMAP_TYPE_CUBE_UV
			#include <cube_uv_reflection_fragment>

			vec3 getSample( float theta, vec3 axis ) {

				float cosTheta = cos( theta );
				// Rodrigues' axis-angle rotation
				vec3 sampleDirection = vOutputDirection * cosTheta
					+ cross( axis, vOutputDirection ) * sin( theta )
					+ axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );

				return bilinearCubeUV( envMap, sampleDirection, mipInt );

			}

			void main() {

				vec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );

				if ( all( equal( axis, vec3( 0.0 ) ) ) ) {

					axis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );

				}

				axis = normalize( axis );

				gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );
				gl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );

				for ( int i = 1; i < n; i++ ) {

					if ( i >= samples ) {

						break;

					}

					float theta = dTheta * float( i );
					gl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );
					gl_FragColor.rgb += weights[ i ] * getSample( theta, axis );

				}

			}
		`,blending:jn,depthTest:!1,depthWrite:!1})}function vg(){let n=new K(1,1);return new Xr({name:"EquirectangularToCubeUV",uniforms:{envMap:{value:null},texelSize:{value:n}},vertexShader:jh(),fragmentShader:`

			precision mediump float;
			precision mediump int;

			varying vec3 vOutputDirection;

			uniform sampler2D envMap;
			uniform vec2 texelSize;

			#include <common>

			void main() {

				gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );

				vec3 outputDirection = normalize( vOutputDirection );
				vec2 uv = equirectUv( outputDirection );

				vec2 f = fract( uv / texelSize - 0.5 );
				uv -= f * texelSize;
				vec3 tl = texture2D ( envMap, uv ).rgb;
				uv.x += texelSize.x;
				vec3 tr = texture2D ( envMap, uv ).rgb;
				uv.y += texelSize.y;
				vec3 br = texture2D ( envMap, uv ).rgb;
				uv.x -= texelSize.x;
				vec3 bl = texture2D ( envMap, uv ).rgb;

				vec3 tm = mix( tl, tr, f.x );
				vec3 bm = mix( bl, br, f.x );
				gl_FragColor.rgb = mix( tm, bm, f.y );

			}
		`,blending:jn,depthTest:!1,depthWrite:!1})}function _g(){return new Xr({name:"CubemapToCubeUV",uniforms:{envMap:{value:null},flipEnvMap:{value:-1}},vertexShader:jh(),fragmentShader:`

			precision mediump float;
			precision mediump int;

			uniform float flipEnvMap;

			varying vec3 vOutputDirection;

			uniform samplerCube envMap;

			void main() {

				gl_FragColor = textureCube( envMap, vec3( flipEnvMap * vOutputDirection.x, vOutputDirection.yz ) );

			}
		`,blending:jn,depthTest:!1,depthWrite:!1})}function jh(){return`

		precision mediump float;
		precision mediump int;

		attribute vec3 position;
		attribute vec2 uv;
		attribute float faceIndex;

		varying vec3 vOutputDirection;

		// RH coordinate system; PMREM face-indexing convention
		vec3 getDirection( vec2 uv, float face ) {

			uv = 2.0 * uv - 1.0;

			vec3 direction = vec3( uv, 1.0 );

			if ( face == 0.0 ) {

				direction = direction.zyx; // ( 1, v, u ) pos x

			} else if ( face == 1.0 ) {

				direction = direction.xzy;
				direction.xz *= -1.0; // ( -u, 1, -v ) pos y

			} else if ( face == 2.0 ) {

				direction.x *= -1.0; // ( -u, v, 1 ) pos z

			} else if ( face == 3.0 ) {

				direction = direction.zyx;
				direction.xz *= -1.0; // ( -1, v, -u ) neg x

			} else if ( face == 4.0 ) {

				direction = direction.xzy;
				direction.xy *= -1.0; // ( -u, -1, v ) neg y

			} else if ( face == 5.0 ) {

				direction.z *= -1.0; // ( u, v, -1 ) neg z

			}

			return direction;

		}

		void main() {

			vOutputDirection = getDirection( uv, faceIndex );
			gl_Position = vec4( position, 1.0 );

		}
	`}function tS(n){let t=new WeakMap,e=null;function i(a){if(a&&a.isTexture){let l=a.mapping,c=l===Uu||l===Bu,u=l===Ao||l===Co;if(c||u)if(a.isRenderTargetTexture&&a.needsPMREMUpdate===!0){a.needsPMREMUpdate=!1;let h=t.get(a);return e===null&&(e=new al(n)),h=c?e.fromEquirectangular(a,h):e.fromCubemap(a,h),t.set(a,h),h.texture}else{if(t.has(a))return t.get(a).texture;{let h=a.image;if(c&&h&&h.height>0||u&&h&&r(h)){e===null&&(e=new al(n));let f=c?e.fromEquirectangular(a):e.fromCubemap(a);return t.set(a,f),a.addEventListener("dispose",s),f.texture}else return null}}}return a}function r(a){let l=0,c=6;for(let u=0;u<c;u++)a[u]!==void 0&&l++;return l===c}function s(a){let l=a.target;l.removeEventListener("dispose",s);let c=t.get(l);c!==void 0&&(t.delete(l),c.dispose())}function o(){t=new WeakMap,e!==null&&(e.dispose(),e=null)}return{get:i,dispose:o}}function eS(n){let t={};function e(i){if(t[i]!==void 0)return t[i];let r;switch(i){case"WEBGL_depth_texture":r=n.getExtension("WEBGL_depth_texture")||n.getExtension("MOZ_WEBGL_depth_texture")||n.getExtension("WEBKIT_WEBGL_depth_texture");break;case"EXT_texture_filter_anisotropic":r=n.getExtension("EXT_texture_filter_anisotropic")||n.getExtension("MOZ_EXT_texture_filter_anisotropic")||n.getExtension("WEBKIT_EXT_texture_filter_anisotropic");break;case"WEBGL_compressed_texture_s3tc":r=n.getExtension("WEBGL_compressed_texture_s3tc")||n.getExtension("MOZ_WEBGL_compressed_texture_s3tc")||n.getExtension("WEBKIT_WEBGL_compressed_texture_s3tc");break;case"WEBGL_compressed_texture_pvrtc":r=n.getExtension("WEBGL_compressed_texture_pvrtc")||n.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc");break;default:r=n.getExtension(i)}return t[i]=r,r}return{has:function(i){return e(i)!==null},init:function(i){i.isWebGL2?e("EXT_color_buffer_float"):(e("WEBGL_depth_texture"),e("OES_texture_float"),e("OES_texture_half_float"),e("OES_texture_half_float_linear"),e("OES_standard_derivatives"),e("OES_element_index_uint"),e("OES_vertex_array_object"),e("ANGLE_instanced_arrays")),e("OES_texture_float_linear"),e("EXT_color_buffer_half_float"),e("WEBGL_multisampled_render_to_texture")},get:function(i){let r=e(i);return r===null&&console.warn("THREE.WebGLRenderer: "+i+" extension not supported."),r}}}function nS(n,t,e,i){let r={},s=new WeakMap;function o(h){let f=h.target;f.index!==null&&t.remove(f.index);for(let g in f.attributes)t.remove(f.attributes[g]);f.removeEventListener("dispose",o),delete r[f.id];let d=s.get(f);d&&(t.remove(d),s.delete(f)),i.releaseStatesOfGeometry(f),f.isInstancedBufferGeometry===!0&&delete f._maxInstanceCount,e.memory.geometries--}function a(h,f){return r[f.id]===!0||(f.addEventListener("dispose",o),r[f.id]=!0,e.memory.geometries++),f}function l(h){let f=h.attributes;for(let g in f)t.update(f[g],34962);let d=h.morphAttributes;for(let g in d){let x=d[g];for(let v=0,m=x.length;v<m;v++)t.update(x[v],34962)}}function c(h){let f=[],d=h.index,g=h.attributes.position,x=0;if(d!==null){let p=d.array;x=d.version;for(let b=0,_=p.length;b<_;b+=3){let S=p[b+0],L=p[b+1],A=p[b+2];f.push(S,L,L,A,A,S)}}else{let p=g.array;x=g.version;for(let b=0,_=p.length/3-1;b<_;b+=3){let S=b+0,L=b+1,A=b+2;f.push(S,L,L,A,A,S)}}let v=new(p0(f)?sl:rl)(f,1);v.version=x;let m=s.get(h);m&&t.remove(m),s.set(h,v)}function u(h){let f=s.get(h);if(f){let d=h.index;d!==null&&f.version<d.version&&c(h)}else c(h);return s.get(h)}return{get:a,update:l,getWireframeAttribute:u}}function iS(n,t,e,i){let r=i.isWebGL2,s;function o(f){s=f}let a,l;function c(f){a=f.type,l=f.bytesPerElement}function u(f,d){n.drawElements(s,d,a,f*l),e.update(d,s,1)}function h(f,d,g){if(g===0)return;let x,v;if(r)x=n,v="drawElementsInstanced";else if(x=t.get("ANGLE_instanced_arrays"),v="drawElementsInstancedANGLE",x===null){console.error("THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");return}x[v](s,d,a,f*l,g),e.update(d,s,g)}this.setMode=o,this.setIndex=c,this.render=u,this.renderInstances=h}function rS(n){let t={geometries:0,textures:0},e={frame:0,calls:0,triangles:0,points:0,lines:0};function i(s,o,a){switch(e.calls++,o){case 4:e.triangles+=a*(s/3);break;case 1:e.lines+=a*(s/2);break;case 3:e.lines+=a*(s-1);break;case 2:e.lines+=a*s;break;case 0:e.points+=a*s;break;default:console.error("THREE.WebGLInfo: Unknown draw mode:",o);break}}function r(){e.frame++,e.calls=0,e.triangles=0,e.points=0,e.lines=0}return{memory:t,render:e,programs:null,autoReset:!0,reset:r,update:i}}var co=class extends ae{constructor(t=null,e=1,i=1,r=1){super(null),this.image={data:t,width:e,height:i,depth:r},this.magFilter=fe,this.minFilter=fe,this.wrapR=Ve,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};co.prototype.isDataTexture2DArray=!0;function sS(n,t){return n[0]-t[0]}function oS(n,t){return Math.abs(t[1])-Math.abs(n[1])}function wg(n,t){let e=1,i=t.isInterleavedBufferAttribute?t.data.array:t.array;i instanceof Int8Array?e=127:i instanceof Int16Array?e=32767:i instanceof Int32Array?e=2147483647:console.error("THREE.WebGLMorphtargets: Unsupported morph attribute data type: ",i),n.divideScalar(e)}function aS(n,t,e){let i={},r=new Float32Array(8),s=new WeakMap,o=new T,a=[];for(let c=0;c<8;c++)a[c]=[c,0];function l(c,u,h,f){let d=c.morphTargetInfluences;if(t.isWebGL2===!0){let g=u.morphAttributes.position.length,x=s.get(u);if(x===void 0||x.count!==g){let R=function(){X.dispose(),s.delete(u),u.removeEventListener("dispose",R)};x!==void 0&&x.texture.dispose();let p=u.morphAttributes.normal!==void 0,b=u.morphAttributes.position,_=u.morphAttributes.normal||[],S=u.attributes.position.count,L=p===!0?2:1,A=S*L,H=1;A>t.maxTextureSize&&(H=Math.ceil(A/t.maxTextureSize),A=t.maxTextureSize);let tt=new Float32Array(A*H*4*g),X=new co(tt,A,H,g);X.format=Re,X.type=Ui,X.needsUpdate=!0;let y=L*4;for(let D=0;D<g;D++){let F=b[D],z=_[D],N=A*H*4*D;for(let V=0;V<F.count;V++){o.fromBufferAttribute(F,V),F.normalized===!0&&wg(o,F);let Q=V*y;tt[N+Q+0]=o.x,tt[N+Q+1]=o.y,tt[N+Q+2]=o.z,tt[N+Q+3]=0,p===!0&&(o.fromBufferAttribute(z,V),z.normalized===!0&&wg(o,z),tt[N+Q+4]=o.x,tt[N+Q+5]=o.y,tt[N+Q+6]=o.z,tt[N+Q+7]=0)}}x={count:g,texture:X,size:new K(A,H)},s.set(u,x),u.addEventListener("dispose",R)}let v=0;for(let p=0;p<d.length;p++)v+=d[p];let m=u.morphTargetsRelative?1:1-v;f.getUniforms().setValue(n,"morphTargetBaseInfluence",m),f.getUniforms().setValue(n,"morphTargetInfluences",d),f.getUniforms().setValue(n,"morphTargetsTexture",x.texture,e),f.getUniforms().setValue(n,"morphTargetsTextureSize",x.size)}else{let g=d===void 0?0:d.length,x=i[u.id];if(x===void 0||x.length!==g){x=[];for(let _=0;_<g;_++)x[_]=[_,0];i[u.id]=x}for(let _=0;_<g;_++){let S=x[_];S[0]=_,S[1]=d[_]}x.sort(oS);for(let _=0;_<8;_++)_<g&&x[_][1]?(a[_][0]=x[_][0],a[_][1]=x[_][1]):(a[_][0]=Number.MAX_SAFE_INTEGER,a[_][1]=0);a.sort(sS);let v=u.morphAttributes.position,m=u.morphAttributes.normal,p=0;for(let _=0;_<8;_++){let S=a[_],L=S[0],A=S[1];L!==Number.MAX_SAFE_INTEGER&&A?(v&&u.getAttribute("morphTarget"+_)!==v[L]&&u.setAttribute("morphTarget"+_,v[L]),m&&u.getAttribute("morphNormal"+_)!==m[L]&&u.setAttribute("morphNormal"+_,m[L]),r[_]=A,p+=A):(v&&u.hasAttribute("morphTarget"+_)===!0&&u.deleteAttribute("morphTarget"+_),m&&u.hasAttribute("morphNormal"+_)===!0&&u.deleteAttribute("morphNormal"+_),r[_]=0)}let b=u.morphTargetsRelative?1:1-p;f.getUniforms().setValue(n,"morphTargetBaseInfluence",b),f.getUniforms().setValue(n,"morphTargetInfluences",r)}}return{update:l}}function lS(n,t,e,i){let r=new WeakMap;function s(l){let c=i.render.frame,u=l.geometry,h=t.get(l,u);return r.get(h)!==c&&(t.update(h),r.set(h,c)),l.isInstancedMesh&&(l.hasEventListener("dispose",a)===!1&&l.addEventListener("dispose",a),e.update(l.instanceMatrix,34962),l.instanceColor!==null&&e.update(l.instanceColor,34962)),h}function o(){r=new WeakMap}function a(l){let c=l.target;c.removeEventListener("dispose",a),e.remove(c.instanceMatrix),c.instanceColor!==null&&e.remove(c.instanceColor)}return{update:s,dispose:o}}var ll=class extends ae{constructor(t=null,e=1,i=1,r=1){super(null),this.image={data:t,width:e,height:i,depth:r},this.magFilter=fe,this.minFilter=fe,this.wrapR=Ve,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};ll.prototype.isDataTexture3D=!0;var v0=new ae,_0=new co,w0=new ll,M0=new Wr,Mg=[],bg=[],Sg=new Float32Array(16),Eg=new Float32Array(9),Tg=new Float32Array(4);function es(n,t,e){let i=n[0];if(i<=0||i>0)return n;let r=t*e,s=Mg[r];if(s===void 0&&(s=new Float32Array(r),Mg[r]=s),t!==0){i.toArray(s,0);for(let o=1,a=0;o!==t;++o)a+=e,n[o].toArray(s,a)}return s}function Le(n,t){if(n.length!==t.length)return!1;for(let e=0,i=n.length;e<i;e++)if(n[e]!==t[e])return!1;return!0}function Te(n,t){for(let e=0,i=t.length;e<i;e++)n[e]=t[e]}function Pl(n,t){let e=bg[t];e===void 0&&(e=new Int32Array(t),bg[t]=e);for(let i=0;i!==t;++i)e[i]=n.allocateTextureUnit();return e}function cS(n,t){let e=this.cache;e[0]!==t&&(n.uniform1f(this.addr,t),e[0]=t)}function uS(n,t){let e=this.cache;if(t.x!==void 0)(e[0]!==t.x||e[1]!==t.y)&&(n.uniform2f(this.addr,t.x,t.y),e[0]=t.x,e[1]=t.y);else{if(Le(e,t))return;n.uniform2fv(this.addr,t),Te(e,t)}}function hS(n,t){let e=this.cache;if(t.x!==void 0)(e[0]!==t.x||e[1]!==t.y||e[2]!==t.z)&&(n.uniform3f(this.addr,t.x,t.y,t.z),e[0]=t.x,e[1]=t.y,e[2]=t.z);else if(t.r!==void 0)(e[0]!==t.r||e[1]!==t.g||e[2]!==t.b)&&(n.uniform3f(this.addr,t.r,t.g,t.b),e[0]=t.r,e[1]=t.g,e[2]=t.b);else{if(Le(e,t))return;n.uniform3fv(this.addr,t),Te(e,t)}}function fS(n,t){let e=this.cache;if(t.x!==void 0)(e[0]!==t.x||e[1]!==t.y||e[2]!==t.z||e[3]!==t.w)&&(n.uniform4f(this.addr,t.x,t.y,t.z,t.w),e[0]=t.x,e[1]=t.y,e[2]=t.z,e[3]=t.w);else{if(Le(e,t))return;n.uniform4fv(this.addr,t),Te(e,t)}}function dS(n,t){let e=this.cache,i=t.elements;if(i===void 0){if(Le(e,t))return;n.uniformMatrix2fv(this.addr,!1,t),Te(e,t)}else{if(Le(e,i))return;Tg.set(i),n.uniformMatrix2fv(this.addr,!1,Tg),Te(e,i)}}function pS(n,t){let e=this.cache,i=t.elements;if(i===void 0){if(Le(e,t))return;n.uniformMatrix3fv(this.addr,!1,t),Te(e,t)}else{if(Le(e,i))return;Eg.set(i),n.uniformMatrix3fv(this.addr,!1,Eg),Te(e,i)}}function mS(n,t){let e=this.cache,i=t.elements;if(i===void 0){if(Le(e,t))return;n.uniformMatrix4fv(this.addr,!1,t),Te(e,t)}else{if(Le(e,i))return;Sg.set(i),n.uniformMatrix4fv(this.addr,!1,Sg),Te(e,i)}}function gS(n,t){let e=this.cache;e[0]!==t&&(n.uniform1i(this.addr,t),e[0]=t)}function xS(n,t){let e=this.cache;Le(e,t)||(n.uniform2iv(this.addr,t),Te(e,t))}function yS(n,t){let e=this.cache;Le(e,t)||(n.uniform3iv(this.addr,t),Te(e,t))}function vS(n,t){let e=this.cache;Le(e,t)||(n.uniform4iv(this.addr,t),Te(e,t))}function _S(n,t){let e=this.cache;e[0]!==t&&(n.uniform1ui(this.addr,t),e[0]=t)}function wS(n,t){let e=this.cache;Le(e,t)||(n.uniform2uiv(this.addr,t),Te(e,t))}function MS(n,t){let e=this.cache;Le(e,t)||(n.uniform3uiv(this.addr,t),Te(e,t))}function bS(n,t){let e=this.cache;Le(e,t)||(n.uniform4uiv(this.addr,t),Te(e,t))}function SS(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.safeSetTexture2D(t||v0,r)}function ES(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.setTexture3D(t||w0,r)}function TS(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.safeSetTextureCube(t||M0,r)}function AS(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.setTexture2DArray(t||_0,r)}function CS(n){switch(n){case 5126:return cS;case 35664:return uS;case 35665:return hS;case 35666:return fS;case 35674:return dS;case 35675:return pS;case 35676:return mS;case 5124:case 35670:return gS;case 35667:case 35671:return xS;case 35668:case 35672:return yS;case 35669:case 35673:return vS;case 5125:return _S;case 36294:return wS;case 36295:return MS;case 36296:return bS;case 35678:case 36198:case 36298:case 36306:case 35682:return SS;case 35679:case 36299:case 36307:return ES;case 35680:case 36300:case 36308:case 36293:return TS;case 36289:case 36303:case 36311:case 36292:return AS}}function RS(n,t){n.uniform1fv(this.addr,t)}function LS(n,t){let e=es(t,this.size,2);n.uniform2fv(this.addr,e)}function PS(n,t){let e=es(t,this.size,3);n.uniform3fv(this.addr,e)}function DS(n,t){let e=es(t,this.size,4);n.uniform4fv(this.addr,e)}function IS(n,t){let e=es(t,this.size,4);n.uniformMatrix2fv(this.addr,!1,e)}function NS(n,t){let e=es(t,this.size,9);n.uniformMatrix3fv(this.addr,!1,e)}function FS(n,t){let e=es(t,this.size,16);n.uniformMatrix4fv(this.addr,!1,e)}function zS(n,t){n.uniform1iv(this.addr,t)}function US(n,t){n.uniform2iv(this.addr,t)}function BS(n,t){n.uniform3iv(this.addr,t)}function OS(n,t){n.uniform4iv(this.addr,t)}function kS(n,t){n.uniform1uiv(this.addr,t)}function HS(n,t){n.uniform2uiv(this.addr,t)}function VS(n,t){n.uniform3uiv(this.addr,t)}function GS(n,t){n.uniform4uiv(this.addr,t)}function WS(n,t,e){let i=t.length,r=Pl(e,i);n.uniform1iv(this.addr,r);for(let s=0;s!==i;++s)e.safeSetTexture2D(t[s]||v0,r[s])}function qS(n,t,e){let i=t.length,r=Pl(e,i);n.uniform1iv(this.addr,r);for(let s=0;s!==i;++s)e.setTexture3D(t[s]||w0,r[s])}function XS(n,t,e){let i=t.length,r=Pl(e,i);n.uniform1iv(this.addr,r);for(let s=0;s!==i;++s)e.safeSetTextureCube(t[s]||M0,r[s])}function YS(n,t,e){let i=t.length,r=Pl(e,i);n.uniform1iv(this.addr,r);for(let s=0;s!==i;++s)e.setTexture2DArray(t[s]||_0,r[s])}function ZS(n){switch(n){case 5126:return RS;case 35664:return LS;case 35665:return PS;case 35666:return DS;case 35674:return IS;case 35675:return NS;case 35676:return FS;case 5124:case 35670:return zS;case 35667:case 35671:return US;case 35668:case 35672:return BS;case 35669:case 35673:return OS;case 5125:return kS;case 36294:return HS;case 36295:return VS;case 36296:return GS;case 35678:case 36198:case 36298:case 36306:case 35682:return WS;case 35679:case 36299:case 36307:return qS;case 35680:case 36300:case 36308:case 36293:return XS;case 36289:case 36303:case 36311:case 36292:return YS}}function JS(n,t,e){this.id=n,this.addr=e,this.cache=[],this.setValue=CS(t.type)}function b0(n,t,e){this.id=n,this.addr=e,this.cache=[],this.size=t.size,this.setValue=ZS(t.type)}b0.prototype.updateCache=function(n){let t=this.cache;n instanceof Float32Array&&t.length!==n.length&&(this.cache=new Float32Array(n.length)),Te(t,n)};function S0(n){this.id=n,this.seq=[],this.map={}}S0.prototype.setValue=function(n,t,e){let i=this.seq;for(let r=0,s=i.length;r!==s;++r){let o=i[r];o.setValue(n,t[o.id],e)}};var Cu=/(\w+)(\])?(\[|\.)?/g;function Ag(n,t){n.seq.push(t),n.map[t.id]=t}function $S(n,t,e){let i=n.name,r=i.length;for(Cu.lastIndex=0;;){let s=Cu.exec(i),o=Cu.lastIndex,a=s[1],l=s[2]==="]",c=s[3];if(l&&(a=a|0),c===void 0||c==="["&&o+2===r){Ag(e,c===void 0?new JS(a,n,t):new b0(a,n,t));break}else{let h=e.map[a];h===void 0&&(h=new S0(a),Ag(e,h)),e=h}}}function ii(n,t){this.seq=[],this.map={};let e=n.getProgramParameter(t,35718);for(let i=0;i<e;++i){let r=n.getActiveUniform(t,i),s=n.getUniformLocation(t,r.name);$S(r,s,this)}}ii.prototype.setValue=function(n,t,e,i){let r=this.map[t];r!==void 0&&r.setValue(n,e,i)};ii.prototype.setOptional=function(n,t,e){let i=t[e];i!==void 0&&this.setValue(n,e,i)};ii.upload=function(n,t,e,i){for(let r=0,s=t.length;r!==s;++r){let o=t[r],a=e[o.id];a.needsUpdate!==!1&&o.setValue(n,a.value,i)}};ii.seqWithValue=function(n,t){let e=[];for(let i=0,r=n.length;i!==r;++i){let s=n[i];s.id in t&&e.push(s)}return e};function Cg(n,t,e){let i=n.createShader(t);return n.shaderSource(i,e),n.compileShader(i),i}var KS=0;function QS(n){let t=n.split(`
`);for(let e=0;e<t.length;e++)t[e]=e+1+": "+t[e];return t.join(`
`)}function jS(n){switch(n){case ri:return["Linear","( value )"];case $t:return["sRGB","( value )"];default:return console.warn("THREE.WebGLProgram: Unsupported encoding:",n),["Linear","( value )"]}}function Rg(n,t,e){let i=n.getShaderParameter(t,35713),r=n.getShaderInfoLog(t).trim();return i&&r===""?"":e.toUpperCase()+`

`+r+`

`+QS(n.getShaderSource(t))}function tE(n,t){let e=jS(t);return"vec4 "+n+"( vec4 value ) { return LinearTo"+e[0]+e[1]+"; }"}function eE(n,t){let e;switch(t){case Aw:e="Linear";break;case Cw:e="Reinhard";break;case Rw:e="OptimizedCineon";break;case Lw:e="ACESFilmic";break;case Pw:e="Custom";break;default:console.warn("THREE.WebGLProgram: Unsupported toneMapping:",t),e="Linear"}return"vec3 "+n+"( vec3 color ) { return "+e+"ToneMapping( color ); }"}function nE(n){return[n.extensionDerivatives||n.envMapCubeUV||n.bumpMap||n.tangentSpaceNormalMap||n.clearcoatNormalMap||n.flatShading||n.shaderID==="physical"?"#extension GL_OES_standard_derivatives : enable":"",(n.extensionFragDepth||n.logarithmicDepthBuffer)&&n.rendererExtensionFragDepth?"#extension GL_EXT_frag_depth : enable":"",n.extensionDrawBuffers&&n.rendererExtensionDrawBuffers?"#extension GL_EXT_draw_buffers : require":"",(n.extensionShaderTextureLOD||n.envMap||n.transmission)&&n.rendererExtensionShaderTextureLod?"#extension GL_EXT_shader_texture_lod : enable":""].filter($s).join(`
`)}function iE(n){let t=[];for(let e in n){let i=n[e];i!==!1&&t.push("#define "+e+" "+i)}return t.join(`
`)}function rE(n,t){let e={},i=n.getProgramParameter(t,35721);for(let r=0;r<i;r++){let s=n.getActiveAttrib(t,r),o=s.name,a=1;s.type===35674&&(a=2),s.type===35675&&(a=3),s.type===35676&&(a=4),e[o]={type:s.type,location:n.getAttribLocation(t,o),locationSize:a}}return e}function $s(n){return n!==""}function Lg(n,t){return n.replace(/NUM_DIR_LIGHTS/g,t.numDirLights).replace(/NUM_SPOT_LIGHTS/g,t.numSpotLights).replace(/NUM_RECT_AREA_LIGHTS/g,t.numRectAreaLights).replace(/NUM_POINT_LIGHTS/g,t.numPointLights).replace(/NUM_HEMI_LIGHTS/g,t.numHemiLights).replace(/NUM_DIR_LIGHT_SHADOWS/g,t.numDirLightShadows).replace(/NUM_SPOT_LIGHT_SHADOWS/g,t.numSpotLightShadows).replace(/NUM_POINT_LIGHT_SHADOWS/g,t.numPointLightShadows)}function Pg(n,t){return n.replace(/NUM_CLIPPING_PLANES/g,t.numClippingPlanes).replace(/UNION_CLIPPING_PLANES/g,t.numClippingPlanes-t.numClipIntersection)}var sE=/^[ \t]*#include +<([\w\d./]+)>/gm;function qu(n){return n.replace(sE,oE)}function oE(n,t){let e=Pt[t];if(e===void 0)throw new Error("Can not resolve #include <"+t+">");return qu(e)}var aE=/#pragma unroll_loop[\s]+?for \( int i \= (\d+)\; i < (\d+)\; i \+\+ \) \{([\s\S]+?)(?=\})\}/g,lE=/#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*i\s*\+\+\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;function Dg(n){return n.replace(lE,E0).replace(aE,cE)}function cE(n,t,e,i){return console.warn("WebGLProgram: #pragma unroll_loop shader syntax is deprecated. Please use #pragma unroll_loop_start syntax instead."),E0(n,t,e,i)}function E0(n,t,e,i){let r="";for(let s=parseInt(t);s<parseInt(e);s++)r+=i.replace(/\[\s*i\s*\]/g,"[ "+s+" ]").replace(/UNROLLED_LOOP_INDEX/g,s);return r}function Ig(n){let t="precision "+n.precision+` float;
precision `+n.precision+" int;";return n.precision==="highp"?t+=`
#define HIGH_PRECISION`:n.precision==="mediump"?t+=`
#define MEDIUM_PRECISION`:n.precision==="lowp"&&(t+=`
#define LOW_PRECISION`),t}function uE(n){let t="SHADOWMAP_TYPE_BASIC";return n.shadowMapType===l0?t="SHADOWMAP_TYPE_PCF":n.shadowMapType===sw?t="SHADOWMAP_TYPE_PCF_SOFT":n.shadowMapType===Js&&(t="SHADOWMAP_TYPE_VSM"),t}function hE(n){let t="ENVMAP_TYPE_CUBE";if(n.envMap)switch(n.envMapMode){case Ao:case Co:t="ENVMAP_TYPE_CUBE";break;case Rl:case Kh:t="ENVMAP_TYPE_CUBE_UV";break}return t}function fE(n){let t="ENVMAP_MODE_REFLECTION";if(n.envMap)switch(n.envMapMode){case Co:case Kh:t="ENVMAP_MODE_REFRACTION";break}return t}function dE(n){let t="ENVMAP_BLENDING_NONE";if(n.envMap)switch(n.combine){case Cl:t="ENVMAP_BLENDING_MULTIPLY";break;case Ew:t="ENVMAP_BLENDING_MIX";break;case Tw:t="ENVMAP_BLENDING_ADD";break}return t}function pE(n,t,e,i){let r=n.getContext(),s=e.defines,o=e.vertexShader,a=e.fragmentShader,l=uE(e),c=hE(e),u=fE(e),h=dE(e),f=e.isWebGL2?"":nE(e),d=iE(s),g=r.createProgram(),x,v,m=e.glslVersion?"#version "+e.glslVersion+`
`:"";e.isRawShaderMaterial?(x=[d].filter($s).join(`
`),x.length>0&&(x+=`
`),v=[f,d].filter($s).join(`
`),v.length>0&&(v+=`
`)):(x=[Ig(e),"#define SHADER_NAME "+e.shaderName,d,e.instancing?"#define USE_INSTANCING":"",e.instancingColor?"#define USE_INSTANCING_COLOR":"",e.supportsVertexTextures?"#define VERTEX_TEXTURES":"","#define MAX_BONES "+e.maxBones,e.useFog&&e.fog?"#define USE_FOG":"",e.useFog&&e.fogExp2?"#define FOG_EXP2":"",e.map?"#define USE_MAP":"",e.envMap?"#define USE_ENVMAP":"",e.envMap?"#define "+u:"",e.lightMap?"#define USE_LIGHTMAP":"",e.aoMap?"#define USE_AOMAP":"",e.emissiveMap?"#define USE_EMISSIVEMAP":"",e.bumpMap?"#define USE_BUMPMAP":"",e.normalMap?"#define USE_NORMALMAP":"",e.normalMap&&e.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",e.normalMap&&e.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",e.clearcoatMap?"#define USE_CLEARCOATMAP":"",e.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",e.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",e.displacementMap&&e.supportsVertexTextures?"#define USE_DISPLACEMENTMAP":"",e.specularMap?"#define USE_SPECULARMAP":"",e.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",e.specularColorMap?"#define USE_SPECULARCOLORMAP":"",e.roughnessMap?"#define USE_ROUGHNESSMAP":"",e.metalnessMap?"#define USE_METALNESSMAP":"",e.alphaMap?"#define USE_ALPHAMAP":"",e.transmission?"#define USE_TRANSMISSION":"",e.transmissionMap?"#define USE_TRANSMISSIONMAP":"",e.thicknessMap?"#define USE_THICKNESSMAP":"",e.sheenColorMap?"#define USE_SHEENCOLORMAP":"",e.sheenRoughnessMap?"#define USE_SHEENROUGHNESSMAP":"",e.vertexTangents?"#define USE_TANGENT":"",e.vertexColors?"#define USE_COLOR":"",e.vertexAlphas?"#define USE_COLOR_ALPHA":"",e.vertexUvs?"#define USE_UV":"",e.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",e.flatShading?"#define FLAT_SHADED":"",e.skinning?"#define USE_SKINNING":"",e.useVertexTexture?"#define BONE_TEXTURE":"",e.morphTargets?"#define USE_MORPHTARGETS":"",e.morphNormals&&e.flatShading===!1?"#define USE_MORPHNORMALS":"",e.morphTargets&&e.isWebGL2?"#define MORPHTARGETS_TEXTURE":"",e.morphTargets&&e.isWebGL2?"#define MORPHTARGETS_COUNT "+e.morphTargetsCount:"",e.doubleSided?"#define DOUBLE_SIDED":"",e.flipSided?"#define FLIP_SIDED":"",e.shadowMapEnabled?"#define USE_SHADOWMAP":"",e.shadowMapEnabled?"#define "+l:"",e.sizeAttenuation?"#define USE_SIZEATTENUATION":"",e.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",e.logarithmicDepthBuffer&&e.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"","uniform mat4 modelMatrix;","uniform mat4 modelViewMatrix;","uniform mat4 projectionMatrix;","uniform mat4 viewMatrix;","uniform mat3 normalMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;","#ifdef USE_INSTANCING","	attribute mat4 instanceMatrix;","#endif","#ifdef USE_INSTANCING_COLOR","	attribute vec3 instanceColor;","#endif","attribute vec3 position;","attribute vec3 normal;","attribute vec2 uv;","#ifdef USE_TANGENT","	attribute vec4 tangent;","#endif","#if defined( USE_COLOR_ALPHA )","	attribute vec4 color;","#elif defined( USE_COLOR )","	attribute vec3 color;","#endif","#if ( defined( USE_MORPHTARGETS ) && ! defined( MORPHTARGETS_TEXTURE ) )","	attribute vec3 morphTarget0;","	attribute vec3 morphTarget1;","	attribute vec3 morphTarget2;","	attribute vec3 morphTarget3;","	#ifdef USE_MORPHNORMALS","		attribute vec3 morphNormal0;","		attribute vec3 morphNormal1;","		attribute vec3 morphNormal2;","		attribute vec3 morphNormal3;","	#else","		attribute vec3 morphTarget4;","		attribute vec3 morphTarget5;","		attribute vec3 morphTarget6;","		attribute vec3 morphTarget7;","	#endif","#endif","#ifdef USE_SKINNING","	attribute vec4 skinIndex;","	attribute vec4 skinWeight;","#endif",`
`].filter($s).join(`
`),v=[f,Ig(e),"#define SHADER_NAME "+e.shaderName,d,e.useFog&&e.fog?"#define USE_FOG":"",e.useFog&&e.fogExp2?"#define FOG_EXP2":"",e.map?"#define USE_MAP":"",e.matcap?"#define USE_MATCAP":"",e.envMap?"#define USE_ENVMAP":"",e.envMap?"#define "+c:"",e.envMap?"#define "+u:"",e.envMap?"#define "+h:"",e.lightMap?"#define USE_LIGHTMAP":"",e.aoMap?"#define USE_AOMAP":"",e.emissiveMap?"#define USE_EMISSIVEMAP":"",e.bumpMap?"#define USE_BUMPMAP":"",e.normalMap?"#define USE_NORMALMAP":"",e.normalMap&&e.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",e.normalMap&&e.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",e.clearcoat?"#define USE_CLEARCOAT":"",e.clearcoatMap?"#define USE_CLEARCOATMAP":"",e.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",e.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",e.specularMap?"#define USE_SPECULARMAP":"",e.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",e.specularColorMap?"#define USE_SPECULARCOLORMAP":"",e.roughnessMap?"#define USE_ROUGHNESSMAP":"",e.metalnessMap?"#define USE_METALNESSMAP":"",e.alphaMap?"#define USE_ALPHAMAP":"",e.alphaTest?"#define USE_ALPHATEST":"",e.sheen?"#define USE_SHEEN":"",e.sheenColorMap?"#define USE_SHEENCOLORMAP":"",e.sheenRoughnessMap?"#define USE_SHEENROUGHNESSMAP":"",e.transmission?"#define USE_TRANSMISSION":"",e.transmissionMap?"#define USE_TRANSMISSIONMAP":"",e.thicknessMap?"#define USE_THICKNESSMAP":"",e.decodeVideoTexture?"#define DECODE_VIDEO_TEXTURE":"",e.vertexTangents?"#define USE_TANGENT":"",e.vertexColors||e.instancingColor?"#define USE_COLOR":"",e.vertexAlphas?"#define USE_COLOR_ALPHA":"",e.vertexUvs?"#define USE_UV":"",e.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",e.gradientMap?"#define USE_GRADIENTMAP":"",e.flatShading?"#define FLAT_SHADED":"",e.doubleSided?"#define DOUBLE_SIDED":"",e.flipSided?"#define FLIP_SIDED":"",e.shadowMapEnabled?"#define USE_SHADOWMAP":"",e.shadowMapEnabled?"#define "+l:"",e.premultipliedAlpha?"#define PREMULTIPLIED_ALPHA":"",e.physicallyCorrectLights?"#define PHYSICALLY_CORRECT_LIGHTS":"",e.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",e.logarithmicDepthBuffer&&e.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"",(e.extensionShaderTextureLOD||e.envMap)&&e.rendererExtensionShaderTextureLod?"#define TEXTURE_LOD_EXT":"","uniform mat4 viewMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;",e.toneMapping!==ti?"#define TONE_MAPPING":"",e.toneMapping!==ti?Pt.tonemapping_pars_fragment:"",e.toneMapping!==ti?eE("toneMapping",e.toneMapping):"",e.dithering?"#define DITHERING":"",e.alphaWrite?"":"#define OPAQUE",Pt.encodings_pars_fragment,tE("linearToOutputTexel",e.outputEncoding),e.depthPacking?"#define DEPTH_PACKING "+e.depthPacking:"",`
`].filter($s).join(`
`)),o=qu(o),o=Lg(o,e),o=Pg(o,e),a=qu(a),a=Lg(a,e),a=Pg(a,e),o=Dg(o),a=Dg(a),e.isWebGL2&&e.isRawShaderMaterial!==!0&&(m=`#version 300 es
`,x=["precision mediump sampler2DArray;","#define attribute in","#define varying out","#define texture2D texture"].join(`
`)+`
`+x,v=["#define varying in",e.glslVersion===ng?"":"layout(location = 0) out highp vec4 pc_fragColor;",e.glslVersion===ng?"":"#define gl_FragColor pc_fragColor","#define gl_FragDepthEXT gl_FragDepth","#define texture2D texture","#define textureCube texture","#define texture2DProj textureProj","#define texture2DLodEXT textureLod","#define texture2DProjLodEXT textureProjLod","#define textureCubeLodEXT textureLod","#define texture2DGradEXT textureGrad","#define texture2DProjGradEXT textureProjGrad","#define textureCubeGradEXT textureGrad"].join(`
`)+`
`+v);let p=m+x+o,b=m+v+a,_=Cg(r,35633,p),S=Cg(r,35632,b);if(r.attachShader(g,_),r.attachShader(g,S),e.index0AttributeName!==void 0?r.bindAttribLocation(g,0,e.index0AttributeName):e.morphTargets===!0&&r.bindAttribLocation(g,0,"position"),r.linkProgram(g),n.debug.checkShaderErrors){let H=r.getProgramInfoLog(g).trim(),tt=r.getShaderInfoLog(_).trim(),X=r.getShaderInfoLog(S).trim(),y=!0,R=!0;if(r.getProgramParameter(g,35714)===!1){y=!1;let D=Rg(r,_,"vertex"),F=Rg(r,S,"fragment");console.error("THREE.WebGLProgram: Shader Error "+r.getError()+" - VALIDATE_STATUS "+r.getProgramParameter(g,35715)+`

Program Info Log: `+H+`
`+D+`
`+F)}else H!==""?console.warn("THREE.WebGLProgram: Program Info Log:",H):(tt===""||X==="")&&(R=!1);R&&(this.diagnostics={runnable:y,programLog:H,vertexShader:{log:tt,prefix:x},fragmentShader:{log:X,prefix:v}})}r.deleteShader(_),r.deleteShader(S);let L;this.getUniforms=function(){return L===void 0&&(L=new ii(r,g)),L};let A;return this.getAttributes=function(){return A===void 0&&(A=rE(r,g)),A},this.destroy=function(){i.releaseStatesOfProgram(this),r.deleteProgram(g),this.program=void 0},this.name=e.shaderName,this.id=KS++,this.cacheKey=t,this.usedTimes=1,this.program=g,this.vertexShader=_,this.fragmentShader=S,this}var mE=0,Xu=class{constructor(){this.shaderCache=new Map,this.materialCache=new Map}update(t){let e=t.vertexShader,i=t.fragmentShader,r=this._getShaderStage(e),s=this._getShaderStage(i),o=this._getShaderCacheForMaterial(t);return o.has(r)===!1&&(o.add(r),r.usedTimes++),o.has(s)===!1&&(o.add(s),s.usedTimes++),this}remove(t){let e=this.materialCache.get(t);for(let i of e)i.usedTimes--,i.usedTimes===0&&this.shaderCache.delete(i);return this.materialCache.delete(t),this}getVertexShaderID(t){return this._getShaderStage(t.vertexShader).id}getFragmentShaderID(t){return this._getShaderStage(t.fragmentShader).id}dispose(){this.shaderCache.clear(),this.materialCache.clear()}_getShaderCacheForMaterial(t){let e=this.materialCache;return e.has(t)===!1&&e.set(t,new Set),e.get(t)}_getShaderStage(t){let e=this.shaderCache;if(e.has(t)===!1){let i=new Yu;e.set(t,i)}return e.get(t)}},Yu=class{constructor(){this.id=mE++,this.usedTimes=0}};function gE(n,t,e,i,r,s,o){let a=new il,l=new Xu,c=[],u=r.isWebGL2,h=r.logarithmicDepthBuffer,f=r.floatVertexTextures,d=r.maxVertexUniforms,g=r.vertexTextures,x=r.precision,v={MeshDepthMaterial:"depth",MeshDistanceMaterial:"distanceRGBA",MeshNormalMaterial:"normal",MeshBasicMaterial:"basic",MeshLambertMaterial:"lambert",MeshPhongMaterial:"phong",MeshToonMaterial:"toon",MeshStandardMaterial:"physical",MeshPhysicalMaterial:"physical",MeshMatcapMaterial:"matcap",LineBasicMaterial:"basic",LineDashedMaterial:"dashed",PointsMaterial:"points",ShadowMaterial:"shadow",SpriteMaterial:"sprite"};function m(y){let D=y.skeleton.bones;if(f)return 1024;{let z=Math.floor((d-20)/4),N=Math.min(z,D.length);return N<D.length?(console.warn("THREE.WebGLRenderer: Skeleton has "+D.length+" bones. This GPU supports "+N+"."),0):N}}function p(y,R,D,F,z){let N=F.fog,V=y.isMeshStandardMaterial?F.environment:null,Q=(y.isMeshStandardMaterial?e:t).get(y.envMap||V),at=v[y.type],G=z.isSkinnedMesh?m(z):0;y.precision!==null&&(x=r.getMaxPrecision(y.precision),x!==y.precision&&console.warn("THREE.WebGLProgram.getParameters:",y.precision,"not supported, using",x,"instead."));let $,lt,dt,xt;if(at){let B=fn[at];$=B.vertexShader,lt=B.fragmentShader}else $=y.vertexShader,lt=y.fragmentShader,l.update(y),dt=l.getVertexShaderID(y),xt=l.getFragmentShaderID(y);let k=n.getRenderTarget(),Ft=y.alphaTest>0,mt=y.clearcoat>0;return{isWebGL2:u,shaderID:at,shaderName:y.type,vertexShader:$,fragmentShader:lt,defines:y.defines,customVertexShaderID:dt,customFragmentShaderID:xt,isRawShaderMaterial:y.isRawShaderMaterial===!0,glslVersion:y.glslVersion,precision:x,instancing:z.isInstancedMesh===!0,instancingColor:z.isInstancedMesh===!0&&z.instanceColor!==null,supportsVertexTextures:g,outputEncoding:k===null?n.outputEncoding:k.isXRRenderTarget===!0?k.texture.encoding:ri,map:!!y.map,matcap:!!y.matcap,envMap:!!Q,envMapMode:Q&&Q.mapping,envMapCubeUV:!!Q&&(Q.mapping===Rl||Q.mapping===Kh),lightMap:!!y.lightMap,aoMap:!!y.aoMap,emissiveMap:!!y.emissiveMap,bumpMap:!!y.bumpMap,normalMap:!!y.normalMap,objectSpaceNormalMap:y.normalMapType===jw,tangentSpaceNormalMap:y.normalMapType===ts,decodeVideoTexture:!!y.map&&y.map.isVideoTexture===!0&&y.map.encoding===$t,clearcoat:mt,clearcoatMap:mt&&!!y.clearcoatMap,clearcoatRoughnessMap:mt&&!!y.clearcoatRoughnessMap,clearcoatNormalMap:mt&&!!y.clearcoatNormalMap,displacementMap:!!y.displacementMap,roughnessMap:!!y.roughnessMap,metalnessMap:!!y.metalnessMap,specularMap:!!y.specularMap,specularIntensityMap:!!y.specularIntensityMap,specularColorMap:!!y.specularColorMap,alphaMap:!!y.alphaMap,alphaTest:Ft,alphaWrite:y.alphaWrite||y.transparent,gradientMap:!!y.gradientMap,sheen:y.sheen>0,sheenColorMap:!!y.sheenColorMap,sheenRoughnessMap:!!y.sheenRoughnessMap,transmission:y.transmission>0,transmissionMap:!!y.transmissionMap,thicknessMap:!!y.thicknessMap,combine:y.combine,vertexTangents:!!y.normalMap&&!!z.geometry&&!!z.geometry.attributes.tangent,vertexColors:y.vertexColors,vertexAlphas:y.vertexColors===!0&&!!z.geometry&&!!z.geometry.attributes.color&&z.geometry.attributes.color.itemSize===4,vertexUvs:!!y.map||!!y.bumpMap||!!y.normalMap||!!y.specularMap||!!y.alphaMap||!!y.emissiveMap||!!y.roughnessMap||!!y.metalnessMap||!!y.clearcoatMap||!!y.clearcoatRoughnessMap||!!y.clearcoatNormalMap||!!y.displacementMap||!!y.transmissionMap||!!y.thicknessMap||!!y.specularIntensityMap||!!y.specularColorMap||!!y.sheenColorMap||!!y.sheenRoughnessMap,uvsVertexOnly:!(!!y.map||!!y.bumpMap||!!y.normalMap||!!y.specularMap||!!y.alphaMap||!!y.emissiveMap||!!y.roughnessMap||!!y.metalnessMap||!!y.clearcoatNormalMap||y.transmission>0||!!y.transmissionMap||!!y.thicknessMap||!!y.specularIntensityMap||!!y.specularColorMap||y.sheen>0||!!y.sheenColorMap||!!y.sheenRoughnessMap)&&!!y.displacementMap,fog:!!N,useFog:y.fog,fogExp2:N&&N.isFogExp2,flatShading:!!y.flatShading,sizeAttenuation:y.sizeAttenuation,logarithmicDepthBuffer:h,skinning:z.isSkinnedMesh===!0&&G>0,maxBones:G,useVertexTexture:f,morphTargets:!!z.geometry&&!!z.geometry.morphAttributes.position,morphNormals:!!z.geometry&&!!z.geometry.morphAttributes.normal,morphTargetsCount:!!z.geometry&&!!z.geometry.morphAttributes.position?z.geometry.morphAttributes.position.length:0,numDirLights:R.directional.length,numPointLights:R.point.length,numSpotLights:R.spot.length,numRectAreaLights:R.rectArea.length,numHemiLights:R.hemi.length,numDirLightShadows:R.directionalShadowMap.length,numPointLightShadows:R.pointShadowMap.length,numSpotLightShadows:R.spotShadowMap.length,numClippingPlanes:o.numPlanes,numClipIntersection:o.numIntersection,dithering:y.dithering,shadowMapEnabled:n.shadowMap.enabled&&D.length>0,shadowMapType:n.shadowMap.type,toneMapping:y.toneMapped?n.toneMapping:ti,physicallyCorrectLights:n.physicallyCorrectLights,premultipliedAlpha:y.premultipliedAlpha,doubleSided:y.side===Hr,flipSided:y.side===he,depthPacking:y.depthPacking!==void 0?y.depthPacking:!1,index0AttributeName:y.index0AttributeName,extensionDerivatives:y.extensions&&y.extensions.derivatives,extensionFragDepth:y.extensions&&y.extensions.fragDepth,extensionDrawBuffers:y.extensions&&y.extensions.drawBuffers,extensionShaderTextureLOD:y.extensions&&y.extensions.shaderTextureLOD,rendererExtensionFragDepth:u||i.has("EXT_frag_depth"),rendererExtensionDrawBuffers:u||i.has("WEBGL_draw_buffers"),rendererExtensionShaderTextureLod:u||i.has("EXT_shader_texture_lod"),customProgramCacheKey:y.customProgramCacheKey()}}function b(y){let R=[];if(y.shaderID?R.push(y.shaderID):(R.push(y.customVertexShaderID),R.push(y.customFragmentShaderID)),y.defines!==void 0)for(let D in y.defines)R.push(D),R.push(y.defines[D]);return y.isRawShaderMaterial===!1&&(_(R,y),S(R,y),R.push(n.outputEncoding)),R.push(y.customProgramCacheKey),R.join()}function _(y,R){y.push(R.precision),y.push(R.outputEncoding),y.push(R.envMapMode),y.push(R.combine),y.push(R.vertexUvs),y.push(R.fogExp2),y.push(R.sizeAttenuation),y.push(R.maxBones),y.push(R.morphTargetsCount),y.push(R.numDirLights),y.push(R.numPointLights),y.push(R.numSpotLights),y.push(R.numHemiLights),y.push(R.numRectAreaLights),y.push(R.numDirLightShadows),y.push(R.numPointLightShadows),y.push(R.numSpotLightShadows),y.push(R.shadowMapType),y.push(R.toneMapping),y.push(R.numClippingPlanes),y.push(R.numClipIntersection),y.push(R.alphaWrite)}function S(y,R){a.disableAll(),R.isWebGL2&&a.enable(0),R.supportsVertexTextures&&a.enable(1),R.instancing&&a.enable(2),R.instancingColor&&a.enable(3),R.map&&a.enable(4),R.matcap&&a.enable(5),R.envMap&&a.enable(6),R.envMapCubeUV&&a.enable(7),R.lightMap&&a.enable(8),R.aoMap&&a.enable(9),R.emissiveMap&&a.enable(10),R.bumpMap&&a.enable(11),R.normalMap&&a.enable(12),R.objectSpaceNormalMap&&a.enable(13),R.tangentSpaceNormalMap&&a.enable(14),R.clearcoat&&a.enable(15),R.clearcoatMap&&a.enable(16),R.clearcoatRoughnessMap&&a.enable(17),R.clearcoatNormalMap&&a.enable(18),R.displacementMap&&a.enable(19),R.specularMap&&a.enable(20),R.roughnessMap&&a.enable(21),R.metalnessMap&&a.enable(22),R.gradientMap&&a.enable(23),R.alphaMap&&a.enable(24),R.alphaTest&&a.enable(25),R.vertexColors&&a.enable(26),R.vertexAlphas&&a.enable(27),R.vertexUvs&&a.enable(28),R.vertexTangents&&a.enable(29),R.uvsVertexOnly&&a.enable(30),R.fog&&a.enable(31),y.push(a.mask),a.disableAll(),R.useFog&&a.enable(0),R.flatShading&&a.enable(1),R.logarithmicDepthBuffer&&a.enable(2),R.skinning&&a.enable(3),R.useVertexTexture&&a.enable(4),R.morphTargets&&a.enable(5),R.morphNormals&&a.enable(6),R.premultipliedAlpha&&a.enable(7),R.shadowMapEnabled&&a.enable(8),R.physicallyCorrectLights&&a.enable(9),R.doubleSided&&a.enable(10),R.flipSided&&a.enable(11),R.depthPacking&&a.enable(12),R.dithering&&a.enable(13),R.specularIntensityMap&&a.enable(14),R.specularColorMap&&a.enable(15),R.transmission&&a.enable(16),R.transmissionMap&&a.enable(17),R.thicknessMap&&a.enable(18),R.sheen&&a.enable(19),R.sheenColorMap&&a.enable(20),R.sheenRoughnessMap&&a.enable(21),R.decodeVideoTexture&&a.enable(22),y.push(a.mask)}function L(y){let R=v[y.type],D;if(R){let F=fn[R];D=pM.clone(F.uniforms)}else D=y.uniforms;return D}function A(y,R){let D;for(let F=0,z=c.length;F<z;F++){let N=c[F];if(N.cacheKey===R){D=N,++D.usedTimes;break}}return D===void 0&&(D=new pE(n,R,y,s),c.push(D)),D}function H(y){if(--y.usedTimes===0){let R=c.indexOf(y);c[R]=c[c.length-1],c.pop(),y.destroy()}}function tt(y){l.remove(y)}function X(){l.dispose()}return{getParameters:p,getProgramCacheKey:b,getUniforms:L,acquireProgram:A,releaseProgram:H,releaseShaderCache:tt,programs:c,dispose:X}}function xE(){let n=new WeakMap;function t(s){let o=n.get(s);return o===void 0&&(o={},n.set(s,o)),o}function e(s){n.delete(s)}function i(s,o,a){n.get(s)[o]=a}function r(){n=new WeakMap}return{get:t,remove:e,update:i,dispose:r}}function yE(n,t){return n.groupOrder!==t.groupOrder?n.groupOrder-t.groupOrder:n.renderOrder!==t.renderOrder?n.renderOrder-t.renderOrder:n.material.id!==t.material.id?n.material.id-t.material.id:n.z!==t.z?n.z-t.z:n.id-t.id}function Ng(n,t){return n.groupOrder!==t.groupOrder?n.groupOrder-t.groupOrder:n.renderOrder!==t.renderOrder?n.renderOrder-t.renderOrder:n.z!==t.z?t.z-n.z:n.id-t.id}function Fg(){let n=[],t=0,e=[],i=[],r=[];function s(){t=0,e.length=0,i.length=0,r.length=0}function o(h,f,d,g,x,v){let m=n[t];return m===void 0?(m={id:h.id,object:h,geometry:f,material:d,groupOrder:g,renderOrder:h.renderOrder,z:x,group:v},n[t]=m):(m.id=h.id,m.object=h,m.geometry=f,m.material=d,m.groupOrder=g,m.renderOrder=h.renderOrder,m.z=x,m.group=v),t++,m}function a(h,f,d,g,x,v){let m=o(h,f,d,g,x,v);d.transmission>0?i.push(m):d.transparent===!0?r.push(m):e.push(m)}function l(h,f,d,g,x,v){let m=o(h,f,d,g,x,v);d.transmission>0?i.unshift(m):d.transparent===!0?r.unshift(m):e.unshift(m)}function c(h,f){e.length>1&&e.sort(h||yE),i.length>1&&i.sort(f||Ng),r.length>1&&r.sort(f||Ng)}function u(){for(let h=t,f=n.length;h<f;h++){let d=n[h];if(d.id===null)break;d.id=null,d.object=null,d.geometry=null,d.material=null,d.group=null}}return{opaque:e,transmissive:i,transparent:r,init:s,push:a,unshift:l,finish:u,sort:c}}function vE(){let n=new WeakMap;function t(i,r){let s;return n.has(i)===!1?(s=new Fg,n.set(i,[s])):r>=n.get(i).length?(s=new Fg,n.get(i).push(s)):s=n.get(i)[r],s}function e(){n=new WeakMap}return{get:t,dispose:e}}function _E(){let n={};return{get:function(t){if(n[t.id]!==void 0)return n[t.id];let e;switch(t.type){case"DirectionalLight":e={direction:new T,color:new ft};break;case"SpotLight":e={position:new T,direction:new T,color:new ft,distance:0,coneCos:0,penumbraCos:0,decay:0};break;case"PointLight":e={position:new T,color:new ft,distance:0,decay:0};break;case"HemisphereLight":e={direction:new T,skyColor:new ft,groundColor:new ft};break;case"RectAreaLight":e={color:new ft,position:new T,halfWidth:new T,halfHeight:new T};break}return n[t.id]=e,e}}}function wE(){let n={};return{get:function(t){if(n[t.id]!==void 0)return n[t.id];let e;switch(t.type){case"DirectionalLight":e={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new K};break;case"SpotLight":e={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new K};break;case"PointLight":e={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new K,shadowCameraNear:1,shadowCameraFar:1e3};break}return n[t.id]=e,e}}}var ME=0;function bE(n,t){return(t.castShadow?1:0)-(n.castShadow?1:0)}function SE(n,t){let e=new _E,i=wE(),r={version:0,hash:{directionalLength:-1,pointLength:-1,spotLength:-1,rectAreaLength:-1,hemiLength:-1,numDirectionalShadows:-1,numPointShadows:-1,numSpotShadows:-1},ambient:[0,0,0],probe:[],directional:[],directionalShadow:[],directionalShadowMap:[],directionalShadowMatrix:[],spot:[],spotShadow:[],spotShadowMap:[],spotShadowMatrix:[],rectArea:[],rectAreaLTC1:null,rectAreaLTC2:null,point:[],pointShadow:[],pointShadowMap:[],pointShadowMatrix:[],hemi:[]};for(let u=0;u<9;u++)r.probe.push(new T);let s=new T,o=new wt,a=new wt;function l(u,h){let f=0,d=0,g=0;for(let tt=0;tt<9;tt++)r.probe[tt].set(0,0,0);let x=0,v=0,m=0,p=0,b=0,_=0,S=0,L=0;u.sort(bE);let A=h!==!0?Math.PI:1;for(let tt=0,X=u.length;tt<X;tt++){let y=u[tt],R=y.color,D=y.intensity,F=y.distance,z=y.shadow&&y.shadow.map?y.shadow.map.texture:null;if(y.isAmbientLight)f+=R.r*D*A,d+=R.g*D*A,g+=R.b*D*A;else if(y.isLightProbe)for(let N=0;N<9;N++)r.probe[N].addScaledVector(y.sh.coefficients[N],D);else if(y.isDirectionalLight){let N=e.get(y);if(N.color.copy(y.color).multiplyScalar(y.intensity*A),y.castShadow){let V=y.shadow,Q=i.get(y);Q.shadowBias=V.bias,Q.shadowNormalBias=V.normalBias,Q.shadowRadius=V.radius,Q.shadowMapSize=V.mapSize,r.directionalShadow[x]=Q,r.directionalShadowMap[x]=z,r.directionalShadowMatrix[x]=y.shadow.matrix,_++}r.directional[x]=N,x++}else if(y.isSpotLight){let N=e.get(y);if(N.position.setFromMatrixPosition(y.matrixWorld),N.color.copy(R).multiplyScalar(D*A),N.distance=F,N.coneCos=Math.cos(y.angle),N.penumbraCos=Math.cos(y.angle*(1-y.penumbra)),N.decay=y.decay,y.castShadow){let V=y.shadow,Q=i.get(y);Q.shadowBias=V.bias,Q.shadowNormalBias=V.normalBias,Q.shadowRadius=V.radius,Q.shadowMapSize=V.mapSize,r.spotShadow[m]=Q,r.spotShadowMap[m]=z,r.spotShadowMatrix[m]=y.shadow.matrix,L++}r.spot[m]=N,m++}else if(y.isRectAreaLight){let N=e.get(y);N.color.copy(R).multiplyScalar(D),N.halfWidth.set(y.width*.5,0,0),N.halfHeight.set(0,y.height*.5,0),r.rectArea[p]=N,p++}else if(y.isPointLight){let N=e.get(y);if(N.color.copy(y.color).multiplyScalar(y.intensity*A),N.distance=y.distance,N.decay=y.decay,y.castShadow){let V=y.shadow,Q=i.get(y);Q.shadowBias=V.bias,Q.shadowNormalBias=V.normalBias,Q.shadowRadius=V.radius,Q.shadowMapSize=V.mapSize,Q.shadowCameraNear=V.camera.near,Q.shadowCameraFar=V.camera.far,r.pointShadow[v]=Q,r.pointShadowMap[v]=z,r.pointShadowMatrix[v]=y.shadow.matrix,S++}r.point[v]=N,v++}else if(y.isHemisphereLight){let N=e.get(y);N.skyColor.copy(y.color).multiplyScalar(D*A),N.groundColor.copy(y.groundColor).multiplyScalar(D*A),r.hemi[b]=N,b++}}p>0&&(t.isWebGL2||n.has("OES_texture_float_linear")===!0?(r.rectAreaLTC1=ot.LTC_FLOAT_1,r.rectAreaLTC2=ot.LTC_FLOAT_2):n.has("OES_texture_half_float_linear")===!0?(r.rectAreaLTC1=ot.LTC_HALF_1,r.rectAreaLTC2=ot.LTC_HALF_2):console.error("THREE.WebGLRenderer: Unable to use RectAreaLight. Missing WebGL extensions.")),r.ambient[0]=f,r.ambient[1]=d,r.ambient[2]=g;let H=r.hash;(H.directionalLength!==x||H.pointLength!==v||H.spotLength!==m||H.rectAreaLength!==p||H.hemiLength!==b||H.numDirectionalShadows!==_||H.numPointShadows!==S||H.numSpotShadows!==L)&&(r.directional.length=x,r.spot.length=m,r.rectArea.length=p,r.point.length=v,r.hemi.length=b,r.directionalShadow.length=_,r.directionalShadowMap.length=_,r.pointShadow.length=S,r.pointShadowMap.length=S,r.spotShadow.length=L,r.spotShadowMap.length=L,r.directionalShadowMatrix.length=_,r.pointShadowMatrix.length=S,r.spotShadowMatrix.length=L,H.directionalLength=x,H.pointLength=v,H.spotLength=m,H.rectAreaLength=p,H.hemiLength=b,H.numDirectionalShadows=_,H.numPointShadows=S,H.numSpotShadows=L,r.version=ME++)}function c(u,h){let f=0,d=0,g=0,x=0,v=0,m=h.matrixWorldInverse;for(let p=0,b=u.length;p<b;p++){let _=u[p];if(_.isDirectionalLight){let S=r.directional[f];S.direction.setFromMatrixPosition(_.matrixWorld),s.setFromMatrixPosition(_.target.matrixWorld),S.direction.sub(s),S.direction.transformDirection(m),f++}else if(_.isSpotLight){let S=r.spot[g];S.position.setFromMatrixPosition(_.matrixWorld),S.position.applyMatrix4(m),S.direction.setFromMatrixPosition(_.matrixWorld),s.setFromMatrixPosition(_.target.matrixWorld),S.direction.sub(s),S.direction.transformDirection(m),g++}else if(_.isRectAreaLight){let S=r.rectArea[x];S.position.setFromMatrixPosition(_.matrixWorld),S.position.applyMatrix4(m),a.identity(),o.copy(_.matrixWorld),o.premultiply(m),a.extractRotation(o),S.halfWidth.set(_.width*.5,0,0),S.halfHeight.set(0,_.height*.5,0),S.halfWidth.applyMatrix4(a),S.halfHeight.applyMatrix4(a),x++}else if(_.isPointLight){let S=r.point[d];S.position.setFromMatrixPosition(_.matrixWorld),S.position.applyMatrix4(m),d++}else if(_.isHemisphereLight){let S=r.hemi[v];S.direction.setFromMatrixPosition(_.matrixWorld),S.direction.transformDirection(m),S.direction.normalize(),v++}}}return{setup:l,setupView:c,state:r}}function zg(n,t){let e=new SE(n,t),i=[],r=[];function s(){i.length=0,r.length=0}function o(h){i.push(h)}function a(h){r.push(h)}function l(h){e.setup(i,h)}function c(h){e.setupView(i,h)}return{init:s,state:{lightsArray:i,shadowsArray:r,lights:e},setupLights:l,setupLightsView:c,pushLight:o,pushShadow:a}}function EE(n,t){let e=new WeakMap;function i(s,o=0){let a;return e.has(s)===!1?(a=new zg(n,t),e.set(s,[a])):o>=e.get(s).length?(a=new zg(n,t),e.get(s).push(a)):a=e.get(s)[o],a}function r(){e=new WeakMap}return{get:i,dispose:r}}var cl=class extends xe{constructor(t){super(),this.type="MeshDepthMaterial",this.depthPacking=Kw,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.setValues(t)}copy(t){return super.copy(t),this.depthPacking=t.depthPacking,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this}};cl.prototype.isMeshDepthMaterial=!0;var ul=class extends xe{constructor(t){super(),this.type="MeshDistanceMaterial",this.referencePosition=new T,this.nearDistance=1,this.farDistance=1e3,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.fog=!1,this.setValues(t)}copy(t){return super.copy(t),this.referencePosition.copy(t.referencePosition),this.nearDistance=t.nearDistance,this.farDistance=t.farDistance,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this}};ul.prototype.isMeshDistanceMaterial=!0;var TE=`void main() {
	gl_Position = vec4( position, 1.0 );
}`,AE=`uniform sampler2D shadow_pass;
uniform vec2 resolution;
uniform float radius;
#include <packing>
void main() {
	const float samples = float( VSM_SAMPLES );
	float mean = 0.0;
	float squared_mean = 0.0;
	float uvStride = samples <= 1.0 ? 0.0 : 2.0 / ( samples - 1.0 );
	float uvStart = samples <= 1.0 ? 0.0 : - 1.0;
	for ( float i = 0.0; i < samples; i ++ ) {
		float uvOffset = uvStart + i * uvStride;
		#ifdef HORIZONTAL_PASS
			vec2 distribution = unpackRGBATo2Half( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( uvOffset, 0.0 ) * radius ) / resolution ) );
			mean += distribution.x;
			squared_mean += distribution.y * distribution.y + distribution.x * distribution.x;
		#else
			float depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0, uvOffset ) * radius ) / resolution ) );
			mean += depth;
			squared_mean += depth * depth;
		#endif
	}
	mean = mean / samples;
	squared_mean = squared_mean / samples;
	float std_dev = sqrt( squared_mean - mean * mean );
	gl_FragColor = pack2HalfToRGBA( vec2( mean, std_dev ) );
}`;function T0(n,t,e){let i=new qr,r=new K,s=new K,o=new Wt,a=new cl({depthPacking:Qw}),l=new ul,c={},u=e.maxTextureSize,h={0:he,1:eo,2:Hr},f=new Fn({defines:{VSM_SAMPLES:8},uniforms:{shadow_pass:{value:null},resolution:{value:new K},radius:{value:4}},vertexShader:TE,fragmentShader:AE}),d=f.clone();d.defines.HORIZONTAL_PASS=1;let g=new Ht;g.setAttribute("position",new Qt(new Float32Array([-1,-1,.5,3,-1,.5,-1,3,.5]),3));let x=new oe(g,f),v=this;this.enabled=!1,this.autoUpdate=!0,this.needsUpdate=!1,this.type=l0,this.render=function(_,S,L){if(v.enabled===!1||v.autoUpdate===!1&&v.needsUpdate===!1||_.length===0)return;let A=n.getRenderTarget(),H=n.getActiveCubeFace(),tt=n.getActiveMipmapLevel(),X=n.state;X.setBlending(jn),X.buffers.color.setClear(1,1,1,1),X.buffers.depth.setTest(!0),X.setScissorTest(!1);for(let y=0,R=_.length;y<R;y++){let D=_[y],F=D.shadow;if(F===void 0){console.warn("THREE.WebGLShadowMap:",D,"has no shadow.");continue}if(F.autoUpdate===!1&&F.needsUpdate===!1)continue;r.copy(F.mapSize);let z=F.getFrameExtents();if(r.multiply(z),s.copy(F.mapSize),(r.x>u||r.y>u)&&(r.x>u&&(s.x=Math.floor(u/z.x),r.x=s.x*z.x,F.mapSize.x=s.x),r.y>u&&(s.y=Math.floor(u/z.y),r.y=s.y*z.y,F.mapSize.y=s.y)),F.map===null&&!F.isPointLightShadow&&this.type===Js){let V={minFilter:be,magFilter:be,format:Re};F.map=new Ne(r.x,r.y,V),F.map.texture.name=D.name+".shadowMap",F.mapPass=new Ne(r.x,r.y,V),F.camera.updateProjectionMatrix()}if(F.map===null){let V={minFilter:fe,magFilter:fe,format:Re};F.map=new Ne(r.x,r.y,V),F.map.texture.name=D.name+".shadowMap",F.camera.updateProjectionMatrix()}n.setRenderTarget(F.map),n.clear();let N=F.getViewportCount();for(let V=0;V<N;V++){let Q=F.getViewport(V);o.set(s.x*Q.x,s.y*Q.y,s.x*Q.z,s.y*Q.w),X.viewport(o),F.updateMatrices(D,V),i=F.getFrustum(),b(S,L,F.camera,D,this.type)}!F.isPointLightShadow&&this.type===Js&&m(F,L),F.needsUpdate=!1}v.needsUpdate=!1,n.setRenderTarget(A,H,tt)};function m(_,S){let L=t.update(x);f.defines.VSM_SAMPLES!==_.blurSamples&&(f.defines.VSM_SAMPLES=_.blurSamples,d.defines.VSM_SAMPLES=_.blurSamples,f.needsUpdate=!0,d.needsUpdate=!0),f.uniforms.shadow_pass.value=_.map.texture,f.uniforms.resolution.value=_.mapSize,f.uniforms.radius.value=_.radius,n.setRenderTarget(_.mapPass),n.clear(),n.renderBufferDirect(S,null,L,f,x,null),d.uniforms.shadow_pass.value=_.mapPass.texture,d.uniforms.resolution.value=_.mapSize,d.uniforms.radius.value=_.radius,n.setRenderTarget(_.map),n.clear(),n.renderBufferDirect(S,null,L,d,x,null)}function p(_,S,L,A,H,tt,X){let y=null,R=A.isPointLight===!0?_.customDistanceMaterial:_.customDepthMaterial;if(R!==void 0?y=R:y=A.isPointLight===!0?l:a,n.localClippingEnabled&&L.clipShadows===!0&&L.clippingPlanes.length!==0||L.displacementMap&&L.displacementScale!==0||L.alphaMap&&L.alphaTest>0){let D=y.uuid,F=L.uuid,z=c[D];z===void 0&&(z={},c[D]=z);let N=z[F];N===void 0&&(N=y.clone(),z[F]=N),y=N}return y.visible=L.visible,y.wireframe=L.wireframe,X===Js?y.side=L.shadowSide!==null?L.shadowSide:L.side:y.side=L.shadowSide!==null?L.shadowSide:h[L.side],y.alphaMap=L.alphaMap,y.alphaTest=L.alphaTest,y.clipShadows=L.clipShadows,y.clippingPlanes=L.clippingPlanes,y.clipIntersection=L.clipIntersection,y.displacementMap=L.displacementMap,y.displacementScale=L.displacementScale,y.displacementBias=L.displacementBias,y.wireframeLinewidth=L.wireframeLinewidth,y.linewidth=L.linewidth,A.isPointLight===!0&&y.isMeshDistanceMaterial===!0&&(y.referencePosition.setFromMatrixPosition(A.matrixWorld),y.nearDistance=H,y.farDistance=tt),y}function b(_,S,L,A,H){if(_.visible===!1)return;if(_.layers.test(S.layers)&&(_.isMesh||_.isLine||_.isPoints)&&(_.castShadow||_.receiveShadow&&H===Js)&&(!_.frustumCulled||i.intersectsObject(_))){_.modelViewMatrix.multiplyMatrices(L.matrixWorldInverse,_.matrixWorld);let y=t.update(_),R=_.material;if(Array.isArray(R)){let D=y.groups;for(let F=0,z=D.length;F<z;F++){let N=D[F],V=R[N.materialIndex];if(V&&V.visible){let Q=p(_,y,V,A,L.near,L.far,H);n.renderBufferDirect(L,null,y,Q,_,N)}}}else if(R.visible){let D=p(_,y,R,A,L.near,L.far,H);n.renderBufferDirect(L,null,y,D,_,null)}}let X=_.children;for(let y=0,R=X.length;y<R;y++)b(X[y],S,L,A,H)}}function CE(n,t,e){let i=e.isWebGL2;function r(){let P=!1,pt=new Wt,ht=null,Et=new Wt(0,0,0,0);return{setMask:function(Y){ht!==Y&&!P&&(n.colorMask(Y,Y,Y,Y),ht=Y)},setLocked:function(Y){P=Y},setClear:function(Y,Mt,Dt,jt,ze){ze===!0&&(Y*=jt,Mt*=jt,Dt*=jt),pt.set(Y,Mt,Dt,jt),Et.equals(pt)===!1&&(n.clearColor(Y,Mt,Dt,jt),Et.copy(pt))},reset:function(){P=!1,ht=null,Et.set(-1,0,0,0)}}}function s(){let P=!1,pt=null,ht=null,Et=null;return{setTest:function(Y){Y?k(2929):Ft(2929)},setMask:function(Y){pt!==Y&&!P&&(n.depthMask(Y),pt=Y)},setFunc:function(Y){if(ht!==Y){if(Y)switch(Y){case yw:n.depthFunc(512);break;case vw:n.depthFunc(519);break;case _w:n.depthFunc(513);break;case zu:n.depthFunc(515);break;case ww:n.depthFunc(514);break;case Mw:n.depthFunc(518);break;case bw:n.depthFunc(516);break;case Sw:n.depthFunc(517);break;default:n.depthFunc(515)}else n.depthFunc(515);ht=Y}},setLocked:function(Y){P=Y},setClear:function(Y){Et!==Y&&(n.clearDepth(Y),Et=Y)},reset:function(){P=!1,pt=null,ht=null,Et=null}}}function o(){let P=!1,pt=null,ht=null,Et=null,Y=null,Mt=null,Dt=null,jt=null,ze=null;return{setTest:function(ne){P||(ne?k(2960):Ft(2960))},setMask:function(ne){pt!==ne&&!P&&(n.stencilMask(ne),pt=ne)},setFunc:function(ne,en,yn){(ht!==ne||Et!==en||Y!==yn)&&(n.stencilFunc(ne,en,yn),ht=ne,Et=en,Y=yn)},setOp:function(ne,en,yn){(Mt!==ne||Dt!==en||jt!==yn)&&(n.stencilOp(ne,en,yn),Mt=ne,Dt=en,jt=yn)},setLocked:function(ne){P=ne},setClear:function(ne){ze!==ne&&(n.clearStencil(ne),ze=ne)},reset:function(){P=!1,pt=null,ht=null,Et=null,Y=null,Mt=null,Dt=null,jt=null,ze=null}}}let a=new r,l=new s,c=new o,u={},h={},f=new WeakMap,d=[],g=null,x=!1,v=null,m=null,p=null,b=null,_=null,S=null,L=null,A=!1,H=null,tt=null,X=null,y=null,R=null,D=n.getParameter(35661),F=!1,z=0,N=n.getParameter(7938);N.indexOf("WebGL")!==-1?(z=parseFloat(/^WebGL (\d)/.exec(N)[1]),F=z>=1):N.indexOf("OpenGL ES")!==-1&&(z=parseFloat(/^OpenGL ES (\d)/.exec(N)[1]),F=z>=2);let V=null,Q={},at=n.getParameter(3088),G=n.getParameter(2978),$=new Wt().fromArray(at),lt=new Wt().fromArray(G);function dt(P,pt,ht){let Et=new Uint8Array(4),Y=n.createTexture();n.bindTexture(P,Y),n.texParameteri(P,10241,9728),n.texParameteri(P,10240,9728);for(let Mt=0;Mt<ht;Mt++)n.texImage2D(pt+Mt,0,6408,1,1,0,6408,5121,Et);return Y}let xt={};xt[3553]=dt(3553,3553,1),xt[34067]=dt(34067,34069,6),a.setClear(0,0,0,1),l.setClear(1),c.setClear(0),k(2929),l.setFunc(zu),J(!1),it(Am),k(2884),C(jn);function k(P){u[P]!==!0&&(n.enable(P),u[P]=!0)}function Ft(P){u[P]!==!1&&(n.disable(P),u[P]=!1)}function mt(P,pt){return h[P]!==pt?(n.bindFramebuffer(P,pt),h[P]=pt,i&&(P===36009&&(h[36160]=pt),P===36160&&(h[36009]=pt)),!0):!1}function St(P,pt){let ht=d,Et=!1;if(P)if(ht=f.get(pt),ht===void 0&&(ht=[],f.set(pt,ht)),P.isWebGLMultipleRenderTargets){let Y=P.texture;if(ht.length!==Y.length||ht[0]!==36064){for(let Mt=0,Dt=Y.length;Mt<Dt;Mt++)ht[Mt]=36064+Mt;ht.length=Y.length,Et=!0}}else ht[0]!==36064&&(ht[0]=36064,Et=!0);else ht[0]!==1029&&(ht[0]=1029,Et=!0);Et&&(e.isWebGL2?n.drawBuffers(ht):t.get("WEBGL_draw_buffers").drawBuffersWEBGL(ht))}function B(P){return g!==P?(n.useProgram(P),g=P,!0):!1}let st={[Ir]:32774,[aw]:32778,[lw]:32779};if(i)st[Pm]=32775,st[Dm]=32776;else{let P=t.get("EXT_blend_minmax");P!==null&&(st[Pm]=P.MIN_EXT,st[Dm]=P.MAX_EXT)}let nt={[cw]:0,[uw]:1,[hw]:768,[u0]:770,[xw]:776,[mw]:774,[dw]:772,[fw]:769,[h0]:771,[gw]:775,[pw]:773};function C(P,pt,ht,Et,Y,Mt,Dt,jt){if(P===jn){x===!0&&(Ft(3042),x=!1);return}if(x===!1&&(k(3042),x=!0),P!==ow){if(P!==v||jt!==A){if((m!==Ir||_!==Ir)&&(n.blendEquation(32774),m=Ir,_=Ir),jt)switch(P){case Ks:n.blendFuncSeparate(1,771,1,771);break;case Cm:n.blendFunc(1,1);break;case Rm:n.blendFuncSeparate(0,769,0,1);break;case Lm:n.blendFuncSeparate(0,768,0,770);break;default:console.error("THREE.WebGLState: Invalid blending: ",P);break}else switch(P){case Ks:n.blendFuncSeparate(770,771,1,771);break;case Cm:n.blendFunc(770,1);break;case Rm:n.blendFuncSeparate(0,769,0,1);break;case Lm:n.blendFunc(0,768);break;default:console.error("THREE.WebGLState: Invalid blending: ",P);break}p=null,b=null,S=null,L=null,v=P,A=jt}return}Y=Y||pt,Mt=Mt||ht,Dt=Dt||Et,(pt!==m||Y!==_)&&(n.blendEquationSeparate(st[pt],st[Y]),m=pt,_=Y),(ht!==p||Et!==b||Mt!==S||Dt!==L)&&(n.blendFuncSeparate(nt[ht],nt[Et],nt[Mt],nt[Dt]),p=ht,b=Et,S=Mt,L=Dt),v=P,A=null}function j(P,pt){P.side===Hr?Ft(2884):k(2884);let ht=P.side===he;pt&&(ht=!ht),J(ht),P.blending===Ks&&P.transparent===!1?C(jn):C(P.blending,P.blendEquation,P.blendSrc,P.blendDst,P.blendEquationAlpha,P.blendSrcAlpha,P.blendDstAlpha,P.premultipliedAlpha),l.setFunc(P.depthFunc),l.setTest(P.depthTest),l.setMask(P.depthWrite),a.setMask(P.colorWrite);let Et=P.stencilWrite;c.setTest(Et),Et&&(c.setMask(P.stencilWriteMask),c.setFunc(P.stencilFunc,P.stencilRef,P.stencilFuncMask),c.setOp(P.stencilFail,P.stencilZFail,P.stencilZPass)),vt(P.polygonOffset,P.polygonOffsetFactor,P.polygonOffsetUnits),P.alphaToCoverage===!0?k(32926):Ft(32926)}function J(P){H!==P&&(P?n.frontFace(2304):n.frontFace(2305),H=P)}function it(P){P!==iw?(k(2884),P!==tt&&(P===Am?n.cullFace(1029):P===rw?n.cullFace(1028):n.cullFace(1032))):Ft(2884),tt=P}function et(P){P!==X&&(F&&n.lineWidth(P),X=P)}function vt(P,pt,ht){P?(k(32823),(y!==pt||R!==ht)&&(n.polygonOffset(pt,ht),y=pt,R=ht)):Ft(32823)}function bt(P){P?k(3089):Ft(3089)}function It(P){P===void 0&&(P=33984+D-1),V!==P&&(n.activeTexture(P),V=P)}function Zt(P,pt){V===null&&It();let ht=Q[V];ht===void 0&&(ht={type:void 0,texture:void 0},Q[V]=ht),(ht.type!==P||ht.texture!==pt)&&(n.bindTexture(P,pt||xt[P]),ht.type=P,ht.texture=pt)}function qt(){let P=Q[V];P!==void 0&&P.type!==void 0&&(n.bindTexture(P.type,null),P.type=void 0,P.texture=void 0)}function E(){try{n.compressedTexImage2D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function w(){try{n.texSubImage2D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function q(){try{n.texSubImage3D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function rt(){try{n.compressedTexSubImage2D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function gt(){try{n.texStorage2D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function W(){try{n.texStorage3D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function _t(){try{n.texImage2D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function yt(){try{n.texImage3D.apply(n,arguments)}catch(P){console.error("THREE.WebGLState:",P)}}function ut(P){$.equals(P)===!1&&(n.scissor(P.x,P.y,P.z,P.w),$.copy(P))}function ct(P){lt.equals(P)===!1&&(n.viewport(P.x,P.y,P.z,P.w),lt.copy(P))}function At(){n.disable(3042),n.disable(2884),n.disable(2929),n.disable(32823),n.disable(3089),n.disable(2960),n.disable(32926),n.blendEquation(32774),n.blendFunc(1,0),n.blendFuncSeparate(1,0,1,0),n.colorMask(!0,!0,!0,!0),n.clearColor(0,0,0,0),n.depthMask(!0),n.depthFunc(513),n.clearDepth(1),n.stencilMask(4294967295),n.stencilFunc(519,0,4294967295),n.stencilOp(7680,7680,7680),n.clearStencil(0),n.cullFace(1029),n.frontFace(2305),n.polygonOffset(0,0),n.activeTexture(33984),n.bindFramebuffer(36160,null),i===!0&&(n.bindFramebuffer(36009,null),n.bindFramebuffer(36008,null)),n.useProgram(null),n.lineWidth(1),n.scissor(0,0,n.canvas.width,n.canvas.height),n.viewport(0,0,n.canvas.width,n.canvas.height),u={},V=null,Q={},h={},f=new WeakMap,d=[],g=null,x=!1,v=null,m=null,p=null,b=null,_=null,S=null,L=null,A=!1,H=null,tt=null,X=null,y=null,R=null,$.set(0,0,n.canvas.width,n.canvas.height),lt.set(0,0,n.canvas.width,n.canvas.height),a.reset(),l.reset(),c.reset()}return{buffers:{color:a,depth:l,stencil:c},enable:k,disable:Ft,bindFramebuffer:mt,drawBuffers:St,useProgram:B,setBlending:C,setMaterial:j,setFlipSided:J,setCullFace:it,setLineWidth:et,setPolygonOffset:vt,setScissorTest:bt,activeTexture:It,bindTexture:Zt,unbindTexture:qt,compressedTexImage2D:E,texImage2D:_t,texImage3D:yt,texStorage2D:gt,texStorage3D:W,texSubImage2D:w,texSubImage3D:q,compressedTexSubImage2D:rt,scissor:ut,viewport:ct,reset:At}}function RE(n,t,e,i,r,s,o){let a=r.isWebGL2,l=r.maxTextures,c=r.maxCubemapSize,u=r.maxTextureSize,h=r.maxSamples,d=t.has("WEBGL_multisampled_render_to_texture")?t.get("WEBGL_multisampled_render_to_texture"):void 0,g=new WeakMap,x,v=!1;try{v=typeof OffscreenCanvas!="undefined"&&new OffscreenCanvas(1,1).getContext("2d")!==null}catch(E){}function m(E,w){return v?new OffscreenCanvas(E,w):ro("canvas")}function p(E,w,q,rt){let gt=1;if((E.width>rt||E.height>rt)&&(gt=rt/Math.max(E.width,E.height)),gt<1||w===!0)if(typeof HTMLImageElement!="undefined"&&E instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&E instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&E instanceof ImageBitmap){let W=w?nM:Math.floor,_t=W(gt*E.width),yt=W(gt*E.height);x===void 0&&(x=m(_t,yt));let ut=q?m(_t,yt):x;return ut.width=_t,ut.height=yt,ut.getContext("2d").drawImage(E,0,0,_t,yt),console.warn("THREE.WebGLRenderer: Texture has been resized from ("+E.width+"x"+E.height+") to ("+_t+"x"+yt+")."),ut}else return"data"in E&&console.warn("THREE.WebGLRenderer: Image in DataTexture is too big ("+E.width+"x"+E.height+")."),E;return E}function b(E){return ig(E.width)&&ig(E.height)}function _(E){return a?!1:E.wrapS!==Ve||E.wrapT!==Ve||E.minFilter!==fe&&E.minFilter!==be}function S(E,w){return E.generateMipmaps&&w&&E.minFilter!==fe&&E.minFilter!==be}function L(E){n.generateMipmap(E)}function A(E,w,q,rt,gt=!1){if(a===!1)return w;if(E!==null){if(n[E]!==void 0)return n[E];console.warn("THREE.WebGLRenderer: Attempt to use non-existing WebGL internal format '"+E+"'")}let W=w;return w===6403&&(q===5126&&(W=33326),q===5131&&(W=33325),q===5121&&(W=33321)),w===33319&&(q===5126&&(W=33328),q===5131&&(W=33327),q===5121&&(W=33323)),w===6408&&(q===5126&&(W=34836),q===5131&&(W=34842),q===5121&&(W=rt===$t&&gt===!1?35907:32856),q===32819&&(W=32854),q===32820&&(W=32855)),(W===33325||W===33326||W===33327||W===33328||W===34842||W===34836)&&t.get("EXT_color_buffer_float"),W}function H(E,w,q){return S(E,q)===!0||E.isFramebufferTexture&&E.minFilter!==fe&&E.minFilter!==be?Math.log2(Math.max(w.width,w.height))+1:E.mipmaps!==void 0&&E.mipmaps.length>0?E.mipmaps.length:E.isCompressedTexture&&Array.isArray(E.image)?w.mipmaps.length:1}function tt(E){return E===fe||E===Im||E===Nm?9728:9729}function X(E){let w=E.target;w.removeEventListener("dispose",X),R(w),w.isVideoTexture&&g.delete(w),o.memory.textures--}function y(E){let w=E.target;w.removeEventListener("dispose",y),D(w)}function R(E){let w=i.get(E);w.__webglInit!==void 0&&(n.deleteTexture(w.__webglTexture),i.remove(E))}function D(E){let w=E.texture,q=i.get(E),rt=i.get(w);if(!!E){if(rt.__webglTexture!==void 0&&(n.deleteTexture(rt.__webglTexture),o.memory.textures--),E.depthTexture&&E.depthTexture.dispose(),E.isWebGLCubeRenderTarget)for(let gt=0;gt<6;gt++)n.deleteFramebuffer(q.__webglFramebuffer[gt]),q.__webglDepthbuffer&&n.deleteRenderbuffer(q.__webglDepthbuffer[gt]);else n.deleteFramebuffer(q.__webglFramebuffer),q.__webglDepthbuffer&&n.deleteRenderbuffer(q.__webglDepthbuffer),q.__webglMultisampledFramebuffer&&n.deleteFramebuffer(q.__webglMultisampledFramebuffer),q.__webglColorRenderbuffer&&n.deleteRenderbuffer(q.__webglColorRenderbuffer),q.__webglDepthRenderbuffer&&n.deleteRenderbuffer(q.__webglDepthRenderbuffer);if(E.isWebGLMultipleRenderTargets)for(let gt=0,W=w.length;gt<W;gt++){let _t=i.get(w[gt]);_t.__webglTexture&&(n.deleteTexture(_t.__webglTexture),o.memory.textures--),i.remove(w[gt])}i.remove(w),i.remove(E)}}let F=0;function z(){F=0}function N(){let E=F;return E>=l&&console.warn("THREE.WebGLTextures: Trying to use "+E+" texture units while this GPU supports only "+l),F+=1,E}function V(E,w){let q=i.get(E);if(E.isVideoTexture&&et(E),E.version>0&&q.__version!==E.version){let rt=E.image;if(rt===void 0)console.warn("THREE.WebGLRenderer: Texture marked for update but image is undefined");else if(rt.complete===!1)console.warn("THREE.WebGLRenderer: Texture marked for update but image is incomplete");else{k(q,E,w);return}}e.activeTexture(33984+w),e.bindTexture(3553,q.__webglTexture)}function Q(E,w){let q=i.get(E);if(E.version>0&&q.__version!==E.version){k(q,E,w);return}e.activeTexture(33984+w),e.bindTexture(35866,q.__webglTexture)}function at(E,w){let q=i.get(E);if(E.version>0&&q.__version!==E.version){k(q,E,w);return}e.activeTexture(33984+w),e.bindTexture(32879,q.__webglTexture)}function G(E,w){let q=i.get(E);if(E.version>0&&q.__version!==E.version){Ft(q,E,w);return}e.activeTexture(33984+w),e.bindTexture(34067,q.__webglTexture)}let $={[Ou]:10497,[Ve]:33071,[ku]:33648},lt={[fe]:9728,[Im]:9984,[Nm]:9986,[be]:9729,[Dw]:9985,[Ll]:9987};function dt(E,w,q){if(q?(n.texParameteri(E,10242,$[w.wrapS]),n.texParameteri(E,10243,$[w.wrapT]),(E===32879||E===35866)&&n.texParameteri(E,32882,$[w.wrapR]),n.texParameteri(E,10240,lt[w.magFilter]),n.texParameteri(E,10241,lt[w.minFilter])):(n.texParameteri(E,10242,33071),n.texParameteri(E,10243,33071),(E===32879||E===35866)&&n.texParameteri(E,32882,33071),(w.wrapS!==Ve||w.wrapT!==Ve)&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping."),n.texParameteri(E,10240,tt(w.magFilter)),n.texParameteri(E,10241,tt(w.minFilter)),w.minFilter!==fe&&w.minFilter!==be&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter.")),t.has("EXT_texture_filter_anisotropic")===!0){let rt=t.get("EXT_texture_filter_anisotropic");if(w.type===Ui&&t.has("OES_texture_float_linear")===!1||a===!1&&w.type===Ur&&t.has("OES_texture_half_float_linear")===!1)return;(w.anisotropy>1||i.get(w).__currentAnisotropy)&&(n.texParameterf(E,rt.TEXTURE_MAX_ANISOTROPY_EXT,Math.min(w.anisotropy,r.getMaxAnisotropy())),i.get(w).__currentAnisotropy=w.anisotropy)}}function xt(E,w){E.__webglInit===void 0&&(E.__webglInit=!0,w.addEventListener("dispose",X),E.__webglTexture=n.createTexture(),o.memory.textures++)}function k(E,w,q){let rt=3553;w.isDataTexture2DArray&&(rt=35866),w.isDataTexture3D&&(rt=32879),xt(E,w),e.activeTexture(33984+q),e.bindTexture(rt,E.__webglTexture),n.pixelStorei(37440,w.flipY),n.pixelStorei(37441,w.premultiplyAlpha),n.pixelStorei(3317,w.unpackAlignment),n.pixelStorei(37443,0);let gt=_(w)&&b(w.image)===!1,W=p(w.image,gt,!1,u);W=vt(w,W);let _t=b(W)||a,yt=s.convert(w.format,w.encoding),ut=s.convert(w.type),ct=A(w.internalFormat,yt,ut,w.encoding,w.isVideoTexture);dt(rt,w,_t);let At,P=w.mipmaps,pt=a&&w.isVideoTexture!==!0,ht=E.__version===void 0,Et=H(w,W,_t);if(w.isDepthTexture)ct=6402,a?w.type===Ui?ct=36012:w.type===Qa?ct=33190:w.type===Br?ct=35056:ct=33189:w.type===Ui&&console.error("WebGLRenderer: Floating point depth texture requires WebGL2."),w.format===Oi&&ct===6402&&w.type!==no&&w.type!==Qa&&(console.warn("THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture."),w.type=no,ut=s.convert(w.type)),w.format===Vr&&ct===6402&&(ct=34041,w.type!==Br&&(console.warn("THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture."),w.type=Br,ut=s.convert(w.type))),pt&&ht?e.texStorage2D(3553,1,ct,W.width,W.height):e.texImage2D(3553,0,ct,W.width,W.height,0,yt,ut,null);else if(w.isDataTexture)if(P.length>0&&_t){pt&&ht&&e.texStorage2D(3553,Et,ct,P[0].width,P[0].height);for(let Y=0,Mt=P.length;Y<Mt;Y++)At=P[Y],pt?e.texSubImage2D(3553,0,0,0,At.width,At.height,yt,ut,At.data):e.texImage2D(3553,Y,ct,At.width,At.height,0,yt,ut,At.data);w.generateMipmaps=!1}else pt?(ht&&e.texStorage2D(3553,Et,ct,W.width,W.height),e.texSubImage2D(3553,0,0,0,W.width,W.height,yt,ut,W.data)):e.texImage2D(3553,0,ct,W.width,W.height,0,yt,ut,W.data);else if(w.isCompressedTexture){pt&&ht&&e.texStorage2D(3553,Et,ct,P[0].width,P[0].height);for(let Y=0,Mt=P.length;Y<Mt;Y++)At=P[Y],w.format!==Re?yt!==null?pt?e.compressedTexSubImage2D(3553,Y,0,0,At.width,At.height,yt,At.data):e.compressedTexImage2D(3553,Y,ct,At.width,At.height,0,At.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()"):pt?e.texSubImage2D(3553,Y,0,0,At.width,At.height,yt,ut,At.data):e.texImage2D(3553,Y,ct,At.width,At.height,0,yt,ut,At.data)}else if(w.isDataTexture2DArray)pt?(ht&&e.texStorage3D(35866,Et,ct,W.width,W.height,W.depth),e.texSubImage3D(35866,0,0,0,0,W.width,W.height,W.depth,yt,ut,W.data)):e.texImage3D(35866,0,ct,W.width,W.height,W.depth,0,yt,ut,W.data);else if(w.isDataTexture3D)pt?(ht&&e.texStorage3D(32879,Et,ct,W.width,W.height,W.depth),e.texSubImage3D(32879,0,0,0,0,W.width,W.height,W.depth,yt,ut,W.data)):e.texImage3D(32879,0,ct,W.width,W.height,W.depth,0,yt,ut,W.data);else if(w.isFramebufferTexture)pt&&ht?e.texStorage2D(3553,Et,ct,W.width,W.height):e.texImage2D(3553,0,ct,W.width,W.height,0,yt,ut,null);else if(P.length>0&&_t){pt&&ht&&e.texStorage2D(3553,Et,ct,P[0].width,P[0].height);for(let Y=0,Mt=P.length;Y<Mt;Y++)At=P[Y],pt?e.texSubImage2D(3553,Y,0,0,yt,ut,At):e.texImage2D(3553,Y,ct,yt,ut,At);w.generateMipmaps=!1}else pt?(ht&&e.texStorage2D(3553,Et,ct,W.width,W.height),e.texSubImage2D(3553,0,0,0,yt,ut,W)):e.texImage2D(3553,0,ct,yt,ut,W);S(w,_t)&&L(rt),E.__version=w.version,w.onUpdate&&w.onUpdate(w)}function Ft(E,w,q){if(w.image.length!==6)return;xt(E,w),e.activeTexture(33984+q),e.bindTexture(34067,E.__webglTexture),n.pixelStorei(37440,w.flipY),n.pixelStorei(37441,w.premultiplyAlpha),n.pixelStorei(3317,w.unpackAlignment),n.pixelStorei(37443,0);let rt=w&&(w.isCompressedTexture||w.image[0].isCompressedTexture),gt=w.image[0]&&w.image[0].isDataTexture,W=[];for(let Y=0;Y<6;Y++)!rt&&!gt?W[Y]=p(w.image[Y],!1,!0,c):W[Y]=gt?w.image[Y].image:w.image[Y],W[Y]=vt(w,W[Y]);let _t=W[0],yt=b(_t)||a,ut=s.convert(w.format,w.encoding),ct=s.convert(w.type),At=A(w.internalFormat,ut,ct,w.encoding),P=a&&w.isVideoTexture!==!0,pt=E.__version===void 0,ht=H(w,_t,yt);dt(34067,w,yt);let Et;if(rt){P&&pt&&e.texStorage2D(34067,ht,At,_t.width,_t.height);for(let Y=0;Y<6;Y++){Et=W[Y].mipmaps;for(let Mt=0;Mt<Et.length;Mt++){let Dt=Et[Mt];w.format!==Re?ut!==null?P?e.compressedTexSubImage2D(34069+Y,Mt,0,0,Dt.width,Dt.height,ut,Dt.data):e.compressedTexImage2D(34069+Y,Mt,At,Dt.width,Dt.height,0,Dt.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()"):P?e.texSubImage2D(34069+Y,Mt,0,0,Dt.width,Dt.height,ut,ct,Dt.data):e.texImage2D(34069+Y,Mt,At,Dt.width,Dt.height,0,ut,ct,Dt.data)}}}else{Et=w.mipmaps,P&&pt&&(Et.length>0&&ht++,e.texStorage2D(34067,ht,At,W[0].width,W[0].height));for(let Y=0;Y<6;Y++)if(gt){P?e.texSubImage2D(34069+Y,0,0,0,W[Y].width,W[Y].height,ut,ct,W[Y].data):e.texImage2D(34069+Y,0,At,W[Y].width,W[Y].height,0,ut,ct,W[Y].data);for(let Mt=0;Mt<Et.length;Mt++){let jt=Et[Mt].image[Y].image;P?e.texSubImage2D(34069+Y,Mt+1,0,0,jt.width,jt.height,ut,ct,jt.data):e.texImage2D(34069+Y,Mt+1,At,jt.width,jt.height,0,ut,ct,jt.data)}}else{P?e.texSubImage2D(34069+Y,0,0,0,ut,ct,W[Y]):e.texImage2D(34069+Y,0,At,ut,ct,W[Y]);for(let Mt=0;Mt<Et.length;Mt++){let Dt=Et[Mt];P?e.texSubImage2D(34069+Y,Mt+1,0,0,ut,ct,Dt.image[Y]):e.texImage2D(34069+Y,Mt+1,At,ut,ct,Dt.image[Y])}}}S(w,yt)&&L(34067),E.__version=w.version,w.onUpdate&&w.onUpdate(w)}function mt(E,w,q,rt,gt){let W=s.convert(q.format,q.encoding),_t=s.convert(q.type),yt=A(q.internalFormat,W,_t,q.encoding);i.get(w).__hasExternalTextures||(gt===32879||gt===35866?e.texImage3D(gt,0,yt,w.width,w.height,w.depth,0,W,_t,null):e.texImage2D(gt,0,yt,w.width,w.height,0,W,_t,null)),e.bindFramebuffer(36160,E),w.useRenderToTexture?d.framebufferTexture2DMultisampleEXT(36160,rt,gt,i.get(q).__webglTexture,0,it(w)):n.framebufferTexture2D(36160,rt,gt,i.get(q).__webglTexture,0),e.bindFramebuffer(36160,null)}function St(E,w,q){if(n.bindRenderbuffer(36161,E),w.depthBuffer&&!w.stencilBuffer){let rt=33189;if(q||w.useRenderToTexture){let gt=w.depthTexture;gt&&gt.isDepthTexture&&(gt.type===Ui?rt=36012:gt.type===Qa&&(rt=33190));let W=it(w);w.useRenderToTexture?d.renderbufferStorageMultisampleEXT(36161,W,rt,w.width,w.height):n.renderbufferStorageMultisample(36161,W,rt,w.width,w.height)}else n.renderbufferStorage(36161,rt,w.width,w.height);n.framebufferRenderbuffer(36160,36096,36161,E)}else if(w.depthBuffer&&w.stencilBuffer){let rt=it(w);q&&w.useRenderbuffer?n.renderbufferStorageMultisample(36161,rt,35056,w.width,w.height):w.useRenderToTexture?d.renderbufferStorageMultisampleEXT(36161,rt,35056,w.width,w.height):n.renderbufferStorage(36161,34041,w.width,w.height),n.framebufferRenderbuffer(36160,33306,36161,E)}else{let rt=w.isWebGLMultipleRenderTargets===!0?w.texture[0]:w.texture,gt=s.convert(rt.format,rt.encoding),W=s.convert(rt.type),_t=A(rt.internalFormat,gt,W,rt.encoding),yt=it(w);q&&w.useRenderbuffer?n.renderbufferStorageMultisample(36161,yt,_t,w.width,w.height):w.useRenderToTexture?d.renderbufferStorageMultisampleEXT(36161,yt,_t,w.width,w.height):n.renderbufferStorage(36161,_t,w.width,w.height)}n.bindRenderbuffer(36161,null)}function B(E,w){if(w&&w.isWebGLCubeRenderTarget)throw new Error("Depth Texture with cube render targets is not supported");if(e.bindFramebuffer(36160,E),!(w.depthTexture&&w.depthTexture.isDepthTexture))throw new Error("renderTarget.depthTexture must be an instance of THREE.DepthTexture");(!i.get(w.depthTexture).__webglTexture||w.depthTexture.image.width!==w.width||w.depthTexture.image.height!==w.height)&&(w.depthTexture.image.width=w.width,w.depthTexture.image.height=w.height,w.depthTexture.needsUpdate=!0),V(w.depthTexture,0);let rt=i.get(w.depthTexture).__webglTexture,gt=it(w);if(w.depthTexture.format===Oi)w.useRenderToTexture?d.framebufferTexture2DMultisampleEXT(36160,36096,3553,rt,0,gt):n.framebufferTexture2D(36160,36096,3553,rt,0);else if(w.depthTexture.format===Vr)w.useRenderToTexture?d.framebufferTexture2DMultisampleEXT(36160,33306,3553,rt,0,gt):n.framebufferTexture2D(36160,33306,3553,rt,0);else throw new Error("Unknown depthTexture format")}function st(E){let w=i.get(E),q=E.isWebGLCubeRenderTarget===!0;if(E.depthTexture&&!w.__autoAllocateDepthBuffer){if(q)throw new Error("target.depthTexture not supported in Cube render targets");B(w.__webglFramebuffer,E)}else if(q){w.__webglDepthbuffer=[];for(let rt=0;rt<6;rt++)e.bindFramebuffer(36160,w.__webglFramebuffer[rt]),w.__webglDepthbuffer[rt]=n.createRenderbuffer(),St(w.__webglDepthbuffer[rt],E,!1)}else e.bindFramebuffer(36160,w.__webglFramebuffer),w.__webglDepthbuffer=n.createRenderbuffer(),St(w.__webglDepthbuffer,E,!1);e.bindFramebuffer(36160,null)}function nt(E,w,q){let rt=i.get(E);w!==void 0&&mt(rt.__webglFramebuffer,E,E.texture,36064,3553),q!==void 0&&st(E)}function C(E){let w=E.texture,q=i.get(E),rt=i.get(w);E.addEventListener("dispose",y),E.isWebGLMultipleRenderTargets!==!0&&(rt.__webglTexture===void 0&&(rt.__webglTexture=n.createTexture()),rt.__version=w.version,o.memory.textures++);let gt=E.isWebGLCubeRenderTarget===!0,W=E.isWebGLMultipleRenderTargets===!0,_t=w.isDataTexture3D||w.isDataTexture2DArray,yt=b(E)||a;if(gt){q.__webglFramebuffer=[];for(let ut=0;ut<6;ut++)q.__webglFramebuffer[ut]=n.createFramebuffer()}else if(q.__webglFramebuffer=n.createFramebuffer(),W)if(r.drawBuffers){let ut=E.texture;for(let ct=0,At=ut.length;ct<At;ct++){let P=i.get(ut[ct]);P.__webglTexture===void 0&&(P.__webglTexture=n.createTexture(),o.memory.textures++)}}else console.warn("THREE.WebGLRenderer: WebGLMultipleRenderTargets can only be used with WebGL2 or WEBGL_draw_buffers extension.");else if(E.useRenderbuffer)if(a){q.__webglMultisampledFramebuffer=n.createFramebuffer(),q.__webglColorRenderbuffer=n.createRenderbuffer(),n.bindRenderbuffer(36161,q.__webglColorRenderbuffer);let ut=s.convert(w.format,w.encoding),ct=s.convert(w.type),At=A(w.internalFormat,ut,ct,w.encoding),P=it(E);n.renderbufferStorageMultisample(36161,P,At,E.width,E.height),e.bindFramebuffer(36160,q.__webglMultisampledFramebuffer),n.framebufferRenderbuffer(36160,36064,36161,q.__webglColorRenderbuffer),n.bindRenderbuffer(36161,null),E.depthBuffer&&(q.__webglDepthRenderbuffer=n.createRenderbuffer(),St(q.__webglDepthRenderbuffer,E,!0)),e.bindFramebuffer(36160,null)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.");if(gt){e.bindTexture(34067,rt.__webglTexture),dt(34067,w,yt);for(let ut=0;ut<6;ut++)mt(q.__webglFramebuffer[ut],E,w,36064,34069+ut);S(w,yt)&&L(34067),e.unbindTexture()}else if(W){let ut=E.texture;for(let ct=0,At=ut.length;ct<At;ct++){let P=ut[ct],pt=i.get(P);e.bindTexture(3553,pt.__webglTexture),dt(3553,P,yt),mt(q.__webglFramebuffer,E,P,36064+ct,3553),S(P,yt)&&L(3553)}e.unbindTexture()}else{let ut=3553;_t&&(a?ut=w.isDataTexture3D?32879:35866:console.warn("THREE.DataTexture3D and THREE.DataTexture2DArray only supported with WebGL2.")),e.bindTexture(ut,rt.__webglTexture),dt(ut,w,yt),mt(q.__webglFramebuffer,E,w,36064,ut),S(w,yt)&&L(ut),e.unbindTexture()}E.depthBuffer&&st(E)}function j(E){let w=b(E)||a,q=E.isWebGLMultipleRenderTargets===!0?E.texture:[E.texture];for(let rt=0,gt=q.length;rt<gt;rt++){let W=q[rt];if(S(W,w)){let _t=E.isWebGLCubeRenderTarget?34067:3553,yt=i.get(W).__webglTexture;e.bindTexture(_t,yt),L(_t),e.unbindTexture()}}}function J(E){if(E.useRenderbuffer)if(a){let w=E.width,q=E.height,rt=16384,gt=[36064],W=E.stencilBuffer?33306:36096;E.depthBuffer&&gt.push(W),E.ignoreDepthForMultisampleCopy||(E.depthBuffer&&(rt|=256),E.stencilBuffer&&(rt|=1024));let _t=i.get(E);e.bindFramebuffer(36008,_t.__webglMultisampledFramebuffer),e.bindFramebuffer(36009,_t.__webglFramebuffer),E.ignoreDepthForMultisampleCopy&&(n.invalidateFramebuffer(36008,[W]),n.invalidateFramebuffer(36009,[W])),n.blitFramebuffer(0,0,w,q,0,0,w,q,rt,9728),n.invalidateFramebuffer(36008,gt),e.bindFramebuffer(36008,null),e.bindFramebuffer(36009,_t.__webglMultisampledFramebuffer)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.")}function it(E){return a&&(E.useRenderbuffer||E.useRenderToTexture)?Math.min(h,E.samples):0}function et(E){let w=o.render.frame;g.get(E)!==w&&(g.set(E,w),E.update())}function vt(E,w){let q=E.encoding,rt=E.format,gt=E.type;return E.isCompressedTexture===!0||E.isVideoTexture===!0||E.format===Hu||q!==ri&&(q===$t?a===!1?t.has("EXT_sRGB")===!0&&rt===Re?(E.format=Hu,E.minFilter=be,E.generateMipmaps=!1):w=Nn.sRGBToLinear(w):(rt!==Re||gt!==ei)&&console.warn("THREE.WebGLTextures: sRGB encoded textures have to use RGBAFormat and UnsignedByteType."):console.error("THREE.WebGLTextures: Unsupported texture encoding:",q)),w}let bt=!1,It=!1;function Zt(E,w){E&&E.isWebGLRenderTarget&&(bt===!1&&(console.warn("THREE.WebGLTextures.safeSetTexture2D: don't use render targets as textures. Use their .texture property instead."),bt=!0),E=E.texture),V(E,w)}function qt(E,w){E&&E.isWebGLCubeRenderTarget&&(It===!1&&(console.warn("THREE.WebGLTextures.safeSetTextureCube: don't use cube render targets as textures. Use their .texture property instead."),It=!0),E=E.texture),G(E,w)}this.allocateTextureUnit=N,this.resetTextureUnits=z,this.setTexture2D=V,this.setTexture2DArray=Q,this.setTexture3D=at,this.setTextureCube=G,this.rebindTextures=nt,this.setupRenderTarget=C,this.updateRenderTargetMipmap=j,this.updateMultisampleRenderTarget=J,this.setupDepthRenderbuffer=st,this.setupFrameBufferTexture=mt,this.safeSetTexture2D=Zt,this.safeSetTextureCube=qt}function LE(n,t,e){let i=e.isWebGL2;function r(s,o=null){let a;if(s===ei)return 5121;if(s===zw)return 32819;if(s===Uw)return 32820;if(s===Iw)return 5120;if(s===Nw)return 5122;if(s===no)return 5123;if(s===Fw)return 5124;if(s===Qa)return 5125;if(s===Ui)return 5126;if(s===Ur)return i?5131:(a=t.get("OES_texture_half_float"),a!==null?a.HALF_FLOAT_OES:null);if(s===Bw)return 6406;if(s===Re)return 6408;if(s===Ow)return 6409;if(s===kw)return 6410;if(s===Oi)return 6402;if(s===Vr)return 34041;if(s===Hw)return 6403;if(s===Hu)return a=t.get("EXT_sRGB"),a!==null?a.SRGB_ALPHA_EXT:null;if(s===Vw)return 36244;if(s===Gw)return 33319;if(s===Ww)return 33320;if(s===qw)return 36249;if(s===Kc||s===Qc||s===jc||s===tu)if(o===$t)if(a=t.get("WEBGL_compressed_texture_s3tc_srgb"),a!==null){if(s===Kc)return a.COMPRESSED_SRGB_S3TC_DXT1_EXT;if(s===Qc)return a.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;if(s===jc)return a.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;if(s===tu)return a.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT}else return null;else if(a=t.get("WEBGL_compressed_texture_s3tc"),a!==null){if(s===Kc)return a.COMPRESSED_RGB_S3TC_DXT1_EXT;if(s===Qc)return a.COMPRESSED_RGBA_S3TC_DXT1_EXT;if(s===jc)return a.COMPRESSED_RGBA_S3TC_DXT3_EXT;if(s===tu)return a.COMPRESSED_RGBA_S3TC_DXT5_EXT}else return null;if(s===Fm||s===zm||s===Um||s===Bm)if(a=t.get("WEBGL_compressed_texture_pvrtc"),a!==null){if(s===Fm)return a.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;if(s===zm)return a.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;if(s===Um)return a.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;if(s===Bm)return a.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG}else return null;if(s===Xw)return a=t.get("WEBGL_compressed_texture_etc1"),a!==null?a.COMPRESSED_RGB_ETC1_WEBGL:null;if(s===Om||s===km)if(a=t.get("WEBGL_compressed_texture_etc"),a!==null){if(s===Om)return o===$t?a.COMPRESSED_SRGB8_ETC2:a.COMPRESSED_RGB8_ETC2;if(s===km)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:a.COMPRESSED_RGBA8_ETC2_EAC}else return null;if(s===Hm||s===Vm||s===Gm||s===Wm||s===qm||s===Xm||s===Ym||s===Zm||s===Jm||s===$m||s===Km||s===Qm||s===jm||s===tg)if(a=t.get("WEBGL_compressed_texture_astc"),a!==null){if(s===Hm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:a.COMPRESSED_RGBA_ASTC_4x4_KHR;if(s===Vm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:a.COMPRESSED_RGBA_ASTC_5x4_KHR;if(s===Gm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:a.COMPRESSED_RGBA_ASTC_5x5_KHR;if(s===Wm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:a.COMPRESSED_RGBA_ASTC_6x5_KHR;if(s===qm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:a.COMPRESSED_RGBA_ASTC_6x6_KHR;if(s===Xm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:a.COMPRESSED_RGBA_ASTC_8x5_KHR;if(s===Ym)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:a.COMPRESSED_RGBA_ASTC_8x6_KHR;if(s===Zm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:a.COMPRESSED_RGBA_ASTC_8x8_KHR;if(s===Jm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:a.COMPRESSED_RGBA_ASTC_10x5_KHR;if(s===$m)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:a.COMPRESSED_RGBA_ASTC_10x6_KHR;if(s===Km)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:a.COMPRESSED_RGBA_ASTC_10x8_KHR;if(s===Qm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:a.COMPRESSED_RGBA_ASTC_10x10_KHR;if(s===jm)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:a.COMPRESSED_RGBA_ASTC_12x10_KHR;if(s===tg)return o===$t?a.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:a.COMPRESSED_RGBA_ASTC_12x12_KHR}else return null;if(s===eg)if(a=t.get("EXT_texture_compression_bptc"),a!==null){if(s===eg)return o===$t?a.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT:a.COMPRESSED_RGBA_BPTC_UNORM_EXT}else return null;if(s===Br)return i?34042:(a=t.get("WEBGL_depth_texture"),a!==null?a.UNSIGNED_INT_24_8_WEBGL:null)}return{convert:r}}var hl=class extends Se{constructor(t=[]){super(),this.cameras=t}};hl.prototype.isArrayCamera=!0;var Bi=class extends kt{constructor(){super(),this.type="Group"}};Bi.prototype.isGroup=!0;var PE={type:"move"},Qs=class{constructor(){this._targetRay=null,this._grip=null,this._hand=null}getHandSpace(){return this._hand===null&&(this._hand=new Bi,this._hand.matrixAutoUpdate=!1,this._hand.visible=!1,this._hand.joints={},this._hand.inputState={pinching:!1}),this._hand}getTargetRaySpace(){return this._targetRay===null&&(this._targetRay=new Bi,this._targetRay.matrixAutoUpdate=!1,this._targetRay.visible=!1,this._targetRay.hasLinearVelocity=!1,this._targetRay.linearVelocity=new T,this._targetRay.hasAngularVelocity=!1,this._targetRay.angularVelocity=new T),this._targetRay}getGripSpace(){return this._grip===null&&(this._grip=new Bi,this._grip.matrixAutoUpdate=!1,this._grip.visible=!1,this._grip.hasLinearVelocity=!1,this._grip.linearVelocity=new T,this._grip.hasAngularVelocity=!1,this._grip.angularVelocity=new T),this._grip}dispatchEvent(t){return this._targetRay!==null&&this._targetRay.dispatchEvent(t),this._grip!==null&&this._grip.dispatchEvent(t),this._hand!==null&&this._hand.dispatchEvent(t),this}disconnect(t){return this.dispatchEvent({type:"disconnected",data:t}),this._targetRay!==null&&(this._targetRay.visible=!1),this._grip!==null&&(this._grip.visible=!1),this._hand!==null&&(this._hand.visible=!1),this}update(t,e,i){let r=null,s=null,o=null,a=this._targetRay,l=this._grip,c=this._hand;if(t&&e.session.visibilityState!=="visible-blurred")if(a!==null&&(r=e.getPose(t.targetRaySpace,i),r!==null&&(a.matrix.fromArray(r.transform.matrix),a.matrix.decompose(a.position,a.rotation,a.scale),r.linearVelocity?(a.hasLinearVelocity=!0,a.linearVelocity.copy(r.linearVelocity)):a.hasLinearVelocity=!1,r.angularVelocity?(a.hasAngularVelocity=!0,a.angularVelocity.copy(r.angularVelocity)):a.hasAngularVelocity=!1,this.dispatchEvent(PE))),c&&t.hand){o=!0;for(let x of t.hand.values()){let v=e.getJointPose(x,i);if(c.joints[x.jointName]===void 0){let p=new Bi;p.matrixAutoUpdate=!1,p.visible=!1,c.joints[x.jointName]=p,c.add(p)}let m=c.joints[x.jointName];v!==null&&(m.matrix.fromArray(v.transform.matrix),m.matrix.decompose(m.position,m.rotation,m.scale),m.jointRadius=v.radius),m.visible=v!==null}let u=c.joints["index-finger-tip"],h=c.joints["thumb-tip"],f=u.position.distanceTo(h.position),d=.02,g=.005;c.inputState.pinching&&f>d+g?(c.inputState.pinching=!1,this.dispatchEvent({type:"pinchend",handedness:t.handedness,target:this})):!c.inputState.pinching&&f<=d-g&&(c.inputState.pinching=!0,this.dispatchEvent({type:"pinchstart",handedness:t.handedness,target:this}))}else l!==null&&t.gripSpace&&(s=e.getPose(t.gripSpace,i),s!==null&&(l.matrix.fromArray(s.transform.matrix),l.matrix.decompose(l.position,l.rotation,l.scale),s.linearVelocity?(l.hasLinearVelocity=!0,l.linearVelocity.copy(s.linearVelocity)):l.hasLinearVelocity=!1,s.angularVelocity?(l.hasAngularVelocity=!0,l.angularVelocity.copy(s.angularVelocity)):l.hasAngularVelocity=!1));return a!==null&&(a.visible=r!==null),l!==null&&(l.visible=s!==null),c!==null&&(c.visible=o!==null),this}},uo=class extends ae{constructor(t,e,i,r,s,o,a,l,c,u){if(u=u!==void 0?u:Oi,u!==Oi&&u!==Vr)throw new Error("DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat");i===void 0&&u===Oi&&(i=no),i===void 0&&u===Vr&&(i=Br),super(null,r,s,o,a,l,u,i,c),this.image={width:t,height:e},this.magFilter=a!==void 0?a:fe,this.minFilter=l!==void 0?l:fe,this.flipY=!1,this.generateMipmaps=!1}};uo.prototype.isDepthTexture=!0;var Zu=class extends In{constructor(t,e){super();let i=this,r=null,s=1,o=null,a="local-floor",l=t.extensions.has("WEBGL_multisampled_render_to_texture"),c=null,u=null,h=null,f=null,d=!1,g=null,x=e.getContextAttributes(),v=null,m=null,p=[],b=new Map,_=new Se;_.layers.enable(1),_.viewport=new Wt;let S=new Se;S.layers.enable(2),S.viewport=new Wt;let L=[_,S],A=new hl;A.layers.enable(1),A.layers.enable(2);let H=null,tt=null;this.cameraAutoUpdate=!0,this.enabled=!1,this.isPresenting=!1,this.getController=function(G){let $=p[G];return $===void 0&&($=new Qs,p[G]=$),$.getTargetRaySpace()},this.getControllerGrip=function(G){let $=p[G];return $===void 0&&($=new Qs,p[G]=$),$.getGripSpace()},this.getHand=function(G){let $=p[G];return $===void 0&&($=new Qs,p[G]=$),$.getHandSpace()};function X(G){let $=b.get(G.inputSource);$&&$.dispatchEvent({type:G.type,data:G.inputSource})}function y(){b.forEach(function(G,$){G.disconnect($)}),b.clear(),H=null,tt=null,t.setRenderTarget(v),f=null,h=null,u=null,r=null,m=null,at.stop(),i.isPresenting=!1,i.dispatchEvent({type:"sessionend"})}this.setFramebufferScaleFactor=function(G){s=G,i.isPresenting===!0&&console.warn("THREE.WebXRManager: Cannot change framebuffer scale while presenting.")},this.setReferenceSpaceType=function(G){a=G,i.isPresenting===!0&&console.warn("THREE.WebXRManager: Cannot change reference space type while presenting.")},this.getReferenceSpace=function(){return o},this.getBaseLayer=function(){return h!==null?h:f},this.getBinding=function(){return u},this.getFrame=function(){return g},this.getSession=function(){return r},this.setSession=function(G){return hf(this,null,function*(){if(r=G,r!==null){if(v=t.getRenderTarget(),r.addEventListener("select",X),r.addEventListener("selectstart",X),r.addEventListener("selectend",X),r.addEventListener("squeeze",X),r.addEventListener("squeezestart",X),r.addEventListener("squeezeend",X),r.addEventListener("end",y),r.addEventListener("inputsourceschange",R),x.xrCompatible!==!0&&(yield e.makeXRCompatible()),r.renderState.layers===void 0||t.capabilities.isWebGL2===!1){let $={antialias:r.renderState.layers===void 0?x.antialias:!0,alpha:x.alpha,depth:x.depth,stencil:x.stencil,framebufferScaleFactor:s};f=new XRWebGLLayer(r,e,$),r.updateRenderState({baseLayer:f}),m=new Ne(f.framebufferWidth,f.framebufferHeight,{format:Re,type:ei,encoding:t.outputEncoding})}else{d=x.antialias;let $=null,lt=null,dt=null;x.depth&&(dt=x.stencil?35056:33190,$=x.stencil?Vr:Oi,lt=x.stencil?Br:no);let xt={colorFormat:t.outputEncoding===$t?35907:32856,depthFormat:dt,scaleFactor:s};u=new XRWebGLBinding(r,e),h=u.createProjectionLayer(xt),r.updateRenderState({layers:[h]}),d?m=new so(h.textureWidth,h.textureHeight,{format:Re,type:ei,depthTexture:new uo(h.textureWidth,h.textureHeight,lt,void 0,void 0,void 0,void 0,void 0,void 0,$),stencilBuffer:x.stencil,ignoreDepth:h.ignoreDepthValues,useRenderToTexture:l,encoding:t.outputEncoding}):m=new Ne(h.textureWidth,h.textureHeight,{format:Re,type:ei,depthTexture:new uo(h.textureWidth,h.textureHeight,lt,void 0,void 0,void 0,void 0,void 0,void 0,$),stencilBuffer:x.stencil,ignoreDepth:h.ignoreDepthValues,encoding:t.outputEncoding})}m.isXRRenderTarget=!0,this.setFoveation(1),o=yield r.requestReferenceSpace(a),at.setContext(r),at.start(),i.isPresenting=!0,i.dispatchEvent({type:"sessionstart"})}})};function R(G){let $=r.inputSources;for(let lt=0;lt<p.length;lt++)b.set($[lt],p[lt]);for(let lt=0;lt<G.removed.length;lt++){let dt=G.removed[lt],xt=b.get(dt);xt&&(xt.dispatchEvent({type:"disconnected",data:dt}),b.delete(dt))}for(let lt=0;lt<G.added.length;lt++){let dt=G.added[lt],xt=b.get(dt);xt&&xt.dispatchEvent({type:"connected",data:dt})}}let D=new T,F=new T;function z(G,$,lt){D.setFromMatrixPosition($.matrixWorld),F.setFromMatrixPosition(lt.matrixWorld);let dt=D.distanceTo(F),xt=$.projectionMatrix.elements,k=lt.projectionMatrix.elements,Ft=xt[14]/(xt[10]-1),mt=xt[14]/(xt[10]+1),St=(xt[9]+1)/xt[5],B=(xt[9]-1)/xt[5],st=(xt[8]-1)/xt[0],nt=(k[8]+1)/k[0],C=Ft*st,j=Ft*nt,J=dt/(-st+nt),it=J*-st;$.matrixWorld.decompose(G.position,G.quaternion,G.scale),G.translateX(it),G.translateZ(J),G.matrixWorld.compose(G.position,G.quaternion,G.scale),G.matrixWorldInverse.copy(G.matrixWorld).invert();let et=Ft+J,vt=mt+J,bt=C-it,It=j+(dt-it),Zt=St*mt/vt*et,qt=B*mt/vt*et;G.projectionMatrix.makePerspective(bt,It,Zt,qt,et,vt)}function N(G,$){$===null?G.matrixWorld.copy(G.matrix):G.matrixWorld.multiplyMatrices($.matrixWorld,G.matrix),G.matrixWorldInverse.copy(G.matrixWorld).invert()}this.updateCamera=function(G){if(r===null)return;A.near=S.near=_.near=G.near,A.far=S.far=_.far=G.far,(H!==A.near||tt!==A.far)&&(r.updateRenderState({depthNear:A.near,depthFar:A.far}),H=A.near,tt=A.far);let $=G.parent,lt=A.cameras;N(A,$);for(let xt=0;xt<lt.length;xt++)N(lt[xt],$);A.matrixWorld.decompose(A.position,A.quaternion,A.scale),G.position.copy(A.position),G.quaternion.copy(A.quaternion),G.scale.copy(A.scale),G.matrix.copy(A.matrix),G.matrixWorld.copy(A.matrixWorld);let dt=G.children;for(let xt=0,k=dt.length;xt<k;xt++)dt[xt].updateMatrixWorld(!0);lt.length===2?z(A,_,S):A.projectionMatrix.copy(_.projectionMatrix)},this.getCamera=function(){return A},this.getFoveation=function(){if(h!==null)return h.fixedFoveation;if(f!==null)return f.fixedFoveation},this.setFoveation=function(G){h!==null&&(h.fixedFoveation=G),f!==null&&f.fixedFoveation!==void 0&&(f.fixedFoveation=G)};let V=null;function Q(G,$){if(c=$.getViewerPose(o),g=$,c!==null){let dt=c.views;f!==null&&(t.setRenderTargetFramebuffer(m,f.framebuffer),t.setRenderTarget(m));let xt=!1;dt.length!==A.cameras.length&&(A.cameras.length=0,xt=!0);for(let k=0;k<dt.length;k++){let Ft=dt[k],mt=null;if(f!==null)mt=f.getViewport(Ft);else{let B=u.getViewSubImage(h,Ft);mt=B.viewport,k===0&&(t.setRenderTargetTextures(m,B.colorTexture,h.ignoreDepthValues?void 0:B.depthStencilTexture),t.setRenderTarget(m))}let St=L[k];St.matrix.fromArray(Ft.transform.matrix),St.projectionMatrix.fromArray(Ft.projectionMatrix),St.viewport.set(mt.x,mt.y,mt.width,mt.height),k===0&&A.matrix.copy(St.matrix),xt===!0&&A.cameras.push(St)}}let lt=r.inputSources;for(let dt=0;dt<p.length;dt++){let xt=p[dt],k=lt[dt];xt.update(k,$,o)}V&&V(G,$),g=null}let at=new g0;at.setAnimationLoop(Q),this.setAnimationLoop=function(G){V=G},this.dispose=function(){}}};function DE(n){function t(m,p){m.fogColor.value.copy(p.color),p.isFog?(m.fogNear.value=p.near,m.fogFar.value=p.far):p.isFogExp2&&(m.fogDensity.value=p.density)}function e(m,p,b,_,S){p.isMeshBasicMaterial?i(m,p):p.isMeshLambertMaterial?(i(m,p),l(m,p)):p.isMeshToonMaterial?(i(m,p),u(m,p)):p.isMeshPhongMaterial?(i(m,p),c(m,p)):p.isMeshStandardMaterial?(i(m,p),p.isMeshPhysicalMaterial?f(m,p,S):h(m,p)):p.isMeshMatcapMaterial?(i(m,p),d(m,p)):p.isMeshDepthMaterial?(i(m,p),g(m,p)):p.isMeshDistanceMaterial?(i(m,p),x(m,p)):p.isMeshNormalMaterial?(i(m,p),v(m,p)):p.isLineBasicMaterial?(r(m,p),p.isLineDashedMaterial&&s(m,p)):p.isPointsMaterial?o(m,p,b,_):p.isSpriteMaterial?a(m,p):p.isShadowMaterial?(m.color.value.copy(p.color),m.opacity.value=p.opacity):p.isShaderMaterial&&(p.uniformsNeedUpdate=!1)}function i(m,p){m.opacity.value=p.opacity,p.color&&m.diffuse.value.copy(p.color),p.emissive&&m.emissive.value.copy(p.emissive).multiplyScalar(p.emissiveIntensity),p.map&&(m.map.value=p.map),p.alphaMap&&(m.alphaMap.value=p.alphaMap),p.specularMap&&(m.specularMap.value=p.specularMap),p.alphaTest>0&&(m.alphaTest.value=p.alphaTest);let b=n.get(p).envMap;b&&(m.envMap.value=b,m.flipEnvMap.value=b.isCubeTexture&&b.isRenderTargetTexture===!1?-1:1,m.reflectivity.value=p.reflectivity,m.ior.value=p.ior,m.refractionRatio.value=p.refractionRatio),p.lightMap&&(m.lightMap.value=p.lightMap,m.lightMapIntensity.value=p.lightMapIntensity),p.aoMap&&(m.aoMap.value=p.aoMap,m.aoMapIntensity.value=p.aoMapIntensity);let _;p.map?_=p.map:p.specularMap?_=p.specularMap:p.displacementMap?_=p.displacementMap:p.normalMap?_=p.normalMap:p.bumpMap?_=p.bumpMap:p.roughnessMap?_=p.roughnessMap:p.metalnessMap?_=p.metalnessMap:p.alphaMap?_=p.alphaMap:p.emissiveMap?_=p.emissiveMap:p.clearcoatMap?_=p.clearcoatMap:p.clearcoatNormalMap?_=p.clearcoatNormalMap:p.clearcoatRoughnessMap?_=p.clearcoatRoughnessMap:p.specularIntensityMap?_=p.specularIntensityMap:p.specularColorMap?_=p.specularColorMap:p.transmissionMap?_=p.transmissionMap:p.thicknessMap?_=p.thicknessMap:p.sheenColorMap?_=p.sheenColorMap:p.sheenRoughnessMap&&(_=p.sheenRoughnessMap),_!==void 0&&(_.isWebGLRenderTarget&&(_=_.texture),_.matrixAutoUpdate===!0&&_.updateMatrix(),m.uvTransform.value.copy(_.matrix));let S;p.aoMap?S=p.aoMap:p.lightMap&&(S=p.lightMap),S!==void 0&&(S.isWebGLRenderTarget&&(S=S.texture),S.matrixAutoUpdate===!0&&S.updateMatrix(),m.uv2Transform.value.copy(S.matrix))}function r(m,p){m.diffuse.value.copy(p.color),m.opacity.value=p.opacity}function s(m,p){m.dashSize.value=p.dashSize,m.totalSize.value=p.dashSize+p.gapSize,m.scale.value=p.scale}function o(m,p,b,_){m.diffuse.value.copy(p.color),m.opacity.value=p.opacity,m.size.value=p.size*b,m.scale.value=_*.5,p.map&&(m.map.value=p.map),p.alphaMap&&(m.alphaMap.value=p.alphaMap),p.alphaTest>0&&(m.alphaTest.value=p.alphaTest);let S;p.map?S=p.map:p.alphaMap&&(S=p.alphaMap),S!==void 0&&(S.matrixAutoUpdate===!0&&S.updateMatrix(),m.uvTransform.value.copy(S.matrix))}function a(m,p){m.diffuse.value.copy(p.color),m.opacity.value=p.opacity,m.rotation.value=p.rotation,p.map&&(m.map.value=p.map),p.alphaMap&&(m.alphaMap.value=p.alphaMap),p.alphaTest>0&&(m.alphaTest.value=p.alphaTest);let b;p.map?b=p.map:p.alphaMap&&(b=p.alphaMap),b!==void 0&&(b.matrixAutoUpdate===!0&&b.updateMatrix(),m.uvTransform.value.copy(b.matrix))}function l(m,p){p.emissiveMap&&(m.emissiveMap.value=p.emissiveMap)}function c(m,p){m.specular.value.copy(p.specular),m.shininess.value=Math.max(p.shininess,1e-4),p.emissiveMap&&(m.emissiveMap.value=p.emissiveMap),p.bumpMap&&(m.bumpMap.value=p.bumpMap,m.bumpScale.value=p.bumpScale,p.side===he&&(m.bumpScale.value*=-1)),p.normalMap&&(m.normalMap.value=p.normalMap,m.normalScale.value.copy(p.normalScale),p.side===he&&m.normalScale.value.negate()),p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias)}function u(m,p){p.gradientMap&&(m.gradientMap.value=p.gradientMap),p.emissiveMap&&(m.emissiveMap.value=p.emissiveMap),p.bumpMap&&(m.bumpMap.value=p.bumpMap,m.bumpScale.value=p.bumpScale,p.side===he&&(m.bumpScale.value*=-1)),p.normalMap&&(m.normalMap.value=p.normalMap,m.normalScale.value.copy(p.normalScale),p.side===he&&m.normalScale.value.negate()),p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias)}function h(m,p){m.roughness.value=p.roughness,m.metalness.value=p.metalness,p.roughnessMap&&(m.roughnessMap.value=p.roughnessMap),p.metalnessMap&&(m.metalnessMap.value=p.metalnessMap),p.emissiveMap&&(m.emissiveMap.value=p.emissiveMap),p.bumpMap&&(m.bumpMap.value=p.bumpMap,m.bumpScale.value=p.bumpScale,p.side===he&&(m.bumpScale.value*=-1)),p.normalMap&&(m.normalMap.value=p.normalMap,m.normalScale.value.copy(p.normalScale),p.side===he&&m.normalScale.value.negate()),p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias),n.get(p).envMap&&(m.envMapIntensity.value=p.envMapIntensity)}function f(m,p,b){h(m,p),m.ior.value=p.ior,p.sheen>0&&(m.sheenColor.value.copy(p.sheenColor).multiplyScalar(p.sheen),m.sheenRoughness.value=p.sheenRoughness,p.sheenColorMap&&(m.sheenColorMap.value=p.sheenColorMap),p.sheenRoughnessMap&&(m.sheenRoughnessMap.value=p.sheenRoughnessMap)),p.clearcoat>0&&(m.clearcoat.value=p.clearcoat,m.clearcoatRoughness.value=p.clearcoatRoughness,p.clearcoatMap&&(m.clearcoatMap.value=p.clearcoatMap),p.clearcoatRoughnessMap&&(m.clearcoatRoughnessMap.value=p.clearcoatRoughnessMap),p.clearcoatNormalMap&&(m.clearcoatNormalScale.value.copy(p.clearcoatNormalScale),m.clearcoatNormalMap.value=p.clearcoatNormalMap,p.side===he&&m.clearcoatNormalScale.value.negate())),p.transmission>0&&(m.transmission.value=p.transmission,m.transmissionSamplerMap.value=b.texture,m.transmissionSamplerSize.value.set(b.width,b.height),p.transmissionMap&&(m.transmissionMap.value=p.transmissionMap),m.thickness.value=p.thickness,p.thicknessMap&&(m.thicknessMap.value=p.thicknessMap),m.attenuationDistance.value=p.attenuationDistance,m.attenuationColor.value.copy(p.attenuationColor)),m.specularIntensity.value=p.specularIntensity,m.specularColor.value.copy(p.specularColor),p.specularIntensityMap&&(m.specularIntensityMap.value=p.specularIntensityMap),p.specularColorMap&&(m.specularColorMap.value=p.specularColorMap)}function d(m,p){p.matcap&&(m.matcap.value=p.matcap),p.bumpMap&&(m.bumpMap.value=p.bumpMap,m.bumpScale.value=p.bumpScale,p.side===he&&(m.bumpScale.value*=-1)),p.normalMap&&(m.normalMap.value=p.normalMap,m.normalScale.value.copy(p.normalScale),p.side===he&&m.normalScale.value.negate()),p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias)}function g(m,p){p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias)}function x(m,p){p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias),m.referencePosition.value.copy(p.referencePosition),m.nearDistance.value=p.nearDistance,m.farDistance.value=p.farDistance}function v(m,p){p.bumpMap&&(m.bumpMap.value=p.bumpMap,m.bumpScale.value=p.bumpScale,p.side===he&&(m.bumpScale.value*=-1)),p.normalMap&&(m.normalMap.value=p.normalMap,m.normalScale.value.copy(p.normalScale),p.side===he&&m.normalScale.value.negate()),p.displacementMap&&(m.displacementMap.value=p.displacementMap,m.displacementScale.value=p.displacementScale,m.displacementBias.value=p.displacementBias)}return{refreshFogUniforms:t,refreshMaterialUniforms:e}}function IE(){let n=ro("canvas");return n.style.display="block",n}function Vt(n={}){let t=n.canvas!==void 0?n.canvas:IE(),e=n.context!==void 0?n.context:null,i=n.alpha!==void 0?n.alpha:!1,r=n.depth!==void 0?n.depth:!0,s=n.stencil!==void 0?n.stencil:!0,o=n.antialias!==void 0?n.antialias:!1,a=n.premultipliedAlpha!==void 0?n.premultipliedAlpha:!0,l=n.preserveDrawingBuffer!==void 0?n.preserveDrawingBuffer:!1,c=n.powerPreference!==void 0?n.powerPreference:"default",u=n.failIfMajorPerformanceCaveat!==void 0?n.failIfMajorPerformanceCaveat:!1,h=null,f=null,d=[],g=[];this.domElement=t,this.debug={checkShaderErrors:!0},this.autoClear=!0,this.autoClearColor=!0,this.autoClearDepth=!0,this.autoClearStencil=!0,this.sortObjects=!0,this.clippingPlanes=[],this.localClippingEnabled=!1,this.outputEncoding=ri,this.physicallyCorrectLights=!1,this.toneMapping=ti,this.toneMappingExposure=1;let x=this,v=!1,m=0,p=0,b=null,_=-1,S=null,L=new Wt,A=new Wt,H=null,tt=t.width,X=t.height,y=1,R=null,D=null,F=new Wt(0,0,tt,X),z=new Wt(0,0,tt,X),N=!1,V=new qr,Q=!1,at=!1,G=null,$=new wt,lt=new T,dt={background:null,fog:null,environment:null,overrideMaterial:null,isScene:!0};function xt(){return b===null?y:1}let k=e;function Ft(M,I){for(let O=0;O<M.length;O++){let U=M[O],Z=t.getContext(U,I);if(Z!==null)return Z}return null}try{let M={alpha:!0,depth:r,stencil:s,antialias:o,premultipliedAlpha:a,preserveDrawingBuffer:l,powerPreference:c,failIfMajorPerformanceCaveat:u};if("setAttribute"in t&&t.setAttribute("data-engine",`three.js r${$h}`),t.addEventListener("webglcontextlost",At,!1),t.addEventListener("webglcontextrestored",P,!1),k===null){let I=["webgl2","webgl","experimental-webgl"];if(x.isWebGL1Renderer===!0&&I.shift(),k=Ft(I,M),k===null)throw Ft(I)?new Error("Error creating WebGL context with your selected attributes."):new Error("Error creating WebGL context.")}k.getShaderPrecisionFormat===void 0&&(k.getShaderPrecisionFormat=function(){return{rangeMin:1,rangeMax:1,precision:1}})}catch(M){throw console.error("THREE.WebGLRenderer: "+M.message),M}let mt,St,B,st,nt,C,j,J,it,et,vt,bt,It,Zt,qt,E,w,q,rt,gt,W,_t,yt;function ut(){mt=new eS(k),St=new J1(k,mt,n),mt.init(St),_t=new LE(k,mt,St),B=new CE(k,mt,St),st=new rS(k),nt=new xE,C=new RE(k,mt,B,nt,St,_t,st),j=new K1(x),J=new tS(x),it=new vM(k,St),yt=new Y1(k,mt,it,St),et=new nS(k,it,st,yt),vt=new lS(k,et,it,st),rt=new aS(k,St,C),E=new $1(nt),bt=new gE(x,j,J,mt,St,yt,E),It=new DE(nt),Zt=new vE,qt=new EE(mt,St),q=new X1(x,j,B,vt,i,a),w=new T0(x,vt,St),gt=new Z1(k,mt,st,St),W=new iS(k,mt,st,St),st.programs=bt.programs,x.capabilities=St,x.extensions=mt,x.properties=nt,x.renderLists=Zt,x.shadowMap=w,x.state=B,x.info=st}ut();let ct=new Zu(x,k);this.xr=ct,this.getContext=function(){return k},this.getContextAttributes=function(){return k.getContextAttributes()},this.forceContextLoss=function(){let M=mt.get("WEBGL_lose_context");M&&M.loseContext()},this.forceContextRestore=function(){let M=mt.get("WEBGL_lose_context");M&&M.restoreContext()},this.getPixelRatio=function(){return y},this.setPixelRatio=function(M){M!==void 0&&(y=M,this.setSize(tt,X,!1))},this.getSize=function(M){return M.set(tt,X)},this.setSize=function(M,I,O){if(ct.isPresenting){console.warn("THREE.WebGLRenderer: Can't change size while VR device is presenting.");return}tt=M,X=I,t.width=Math.floor(M*y),t.height=Math.floor(I*y),O!==!1&&(t.style.width=M+"px",t.style.height=I+"px"),this.setViewport(0,0,M,I)},this.getDrawingBufferSize=function(M){return M.set(tt*y,X*y).floor()},this.setDrawingBufferSize=function(M,I,O){tt=M,X=I,y=O,t.width=Math.floor(M*O),t.height=Math.floor(I*O),this.setViewport(0,0,M,I)},this.getCurrentViewport=function(M){return M.copy(L)},this.getViewport=function(M){return M.copy(F)},this.setViewport=function(M,I,O,U){M.isVector4?F.set(M.x,M.y,M.z,M.w):F.set(M,I,O,U),B.viewport(L.copy(F).multiplyScalar(y).floor())},this.getScissor=function(M){return M.copy(z)},this.setScissor=function(M,I,O,U){M.isVector4?z.set(M.x,M.y,M.z,M.w):z.set(M,I,O,U),B.scissor(A.copy(z).multiplyScalar(y).floor())},this.getScissorTest=function(){return N},this.setScissorTest=function(M){B.setScissorTest(N=M)},this.setOpaqueSort=function(M){R=M},this.setTransparentSort=function(M){D=M},this.getClearColor=function(M){return M.copy(q.getClearColor())},this.setClearColor=function(){q.setClearColor.apply(q,arguments)},this.getClearAlpha=function(){return q.getClearAlpha()},this.setClearAlpha=function(){q.setClearAlpha.apply(q,arguments)},this.clear=function(M,I,O){let U=0;(M===void 0||M)&&(U|=16384),(I===void 0||I)&&(U|=256),(O===void 0||O)&&(U|=1024),k.clear(U)},this.clearColor=function(){this.clear(!0,!1,!1)},this.clearDepth=function(){this.clear(!1,!0,!1)},this.clearStencil=function(){this.clear(!1,!1,!0)},this.dispose=function(){t.removeEventListener("webglcontextlost",At,!1),t.removeEventListener("webglcontextrestored",P,!1),Zt.dispose(),qt.dispose(),nt.dispose(),j.dispose(),J.dispose(),vt.dispose(),yt.dispose(),bt.dispose(),ct.dispose(),ct.removeEventListener("sessionstart",Dt),ct.removeEventListener("sessionend",jt),G&&(G.dispose(),G=null),ze.stop()};function At(M){M.preventDefault(),console.log("THREE.WebGLRenderer: Context Lost."),v=!0}function P(){console.log("THREE.WebGLRenderer: Context Restored."),v=!1;let M=st.autoReset,I=w.enabled,O=w.autoUpdate,U=w.needsUpdate,Z=w.type;ut(),st.autoReset=M,w.enabled=I,w.autoUpdate=O,w.needsUpdate=U,w.type=Z}function pt(M){let I=M.target;I.removeEventListener("dispose",pt),ht(I)}function ht(M){Et(M),nt.remove(M)}function Et(M){let I=nt.get(M).programs;I!==void 0&&(I.forEach(function(O){bt.releaseProgram(O)}),M.isShaderMaterial&&bt.releaseShaderCache(M))}this.renderBufferDirect=function(M,I,O,U,Z,Tt){I===null&&(I=dt);let Ct=Z.isMesh&&Z.matrixWorld.determinant()<0,Lt=B0(M,I,O,U,Z);B.setMaterial(U,Ct);let Rt=O.index,Gt=O.attributes.position;if(Rt===null){if(Gt===void 0||Gt.count===0)return}else if(Rt.count===0)return;let zt=1;U.wireframe===!0&&(Rt=et.getWireframeAttribute(O),zt=2),yt.setup(Z,U,Lt,O,Rt);let Ut,ie=gt;Rt!==null&&(Ut=it.get(Rt),ie=W,ie.setIndex(Ut));let fi=Rt!==null?Rt.count:Gt.count,Zi=O.drawRange.start*zt,Ot=O.drawRange.count*zt,nn=Tt!==null?Tt.start*zt:0,le=Tt!==null?Tt.count*zt:1/0,rn=Math.max(Zi,nn),Io=Math.min(fi,Zi+Ot,nn+le)-1,sn=Math.max(0,Io-rn+1);if(sn!==0){if(Z.isMesh)U.wireframe===!0?(B.setLineWidth(U.wireframeLinewidth*xt()),ie.setMode(1)):ie.setMode(4);else if(Z.isLine){let vn=U.linewidth;vn===void 0&&(vn=1),B.setLineWidth(vn*xt()),Z.isLineSegments?ie.setMode(1):Z.isLineLoop?ie.setMode(2):ie.setMode(3)}else Z.isPoints?ie.setMode(0):Z.isSprite&&ie.setMode(4);if(Z.isInstancedMesh)ie.renderInstances(rn,sn,Z.count);else if(O.isInstancedBufferGeometry){let vn=Math.min(O.instanceCount,O._maxInstanceCount);ie.renderInstances(rn,sn,vn)}else ie.render(rn,sn)}},this.compile=function(M,I){f=qt.get(M),f.init(),g.push(f),M.traverseVisible(function(O){O.isLight&&O.layers.test(I.layers)&&(f.pushLight(O),O.castShadow&&f.pushShadow(O))}),f.setupLights(x.physicallyCorrectLights),M.traverse(function(O){let U=O.material;if(U)if(Array.isArray(U))for(let Z=0;Z<U.length;Z++){let Tt=U[Z];Ol(Tt,M,O)}else Ol(U,M,O)}),g.pop(),f=null};let Y=null;function Mt(M){Y&&Y(M)}function Dt(){ze.stop()}function jt(){ze.start()}let ze=new g0;ze.setAnimationLoop(Mt),typeof window!="undefined"&&ze.setContext(window),this.setAnimationLoop=function(M){Y=M,ct.setAnimationLoop(M),M===null?ze.stop():ze.start()},ct.addEventListener("sessionstart",Dt),ct.addEventListener("sessionend",jt),this.render=function(M,I){if(I!==void 0&&I.isCamera!==!0){console.error("THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.");return}if(v===!0)return;M.autoUpdate===!0&&M.updateMatrixWorld(),I.parent===null&&I.updateMatrixWorld(),ct.enabled===!0&&ct.isPresenting===!0&&(ct.cameraAutoUpdate===!0&&ct.updateCamera(I),I=ct.getCamera()),M.isScene===!0&&M.onBeforeRender(x,M,I,b),f=qt.get(M,g.length),f.init(),g.push(f),$.multiplyMatrices(I.projectionMatrix,I.matrixWorldInverse),V.setFromProjectionMatrix($),at=this.localClippingEnabled,Q=E.init(this.clippingPlanes,at,I),h=Zt.get(M,d.length),h.init(),d.push(h),ne(M,I,0,x.sortObjects),h.finish(),x.sortObjects===!0&&h.sort(R,D),Q===!0&&E.beginShadows();let O=f.state.shadowsArray;if(w.render(O,M,I),Q===!0&&E.endShadows(),this.info.autoReset===!0&&this.info.reset(),q.render(h,M),f.setupLights(x.physicallyCorrectLights),I.isArrayCamera){let U=I.cameras;for(let Z=0,Tt=U.length;Z<Tt;Z++){let Ct=U[Z];en(h,M,Ct,Ct.viewport)}}else en(h,M,I);b!==null&&(C.updateMultisampleRenderTarget(b),C.updateRenderTargetMipmap(b)),M.isScene===!0&&M.onAfterRender(x,M,I),B.buffers.depth.setTest(!0),B.buffers.depth.setMask(!0),B.buffers.color.setMask(!0),B.setPolygonOffset(!1),yt.resetDefaultState(),_=-1,S=null,g.pop(),g.length>0?f=g[g.length-1]:f=null,d.pop(),d.length>0?h=d[d.length-1]:h=null};function ne(M,I,O,U){if(M.visible===!1)return;if(M.layers.test(I.layers)){if(M.isGroup)O=M.renderOrder;else if(M.isLOD)M.autoUpdate===!0&&M.update(I);else if(M.isLight)f.pushLight(M),M.castShadow&&f.pushShadow(M);else if(M.isSprite){if(!M.frustumCulled||V.intersectsSprite(M)){U&&lt.setFromMatrixPosition(M.matrixWorld).applyMatrix4($);let Ct=vt.update(M),Lt=M.material;Lt.visible&&h.push(M,Ct,Lt,O,lt.z,null)}}else if((M.isMesh||M.isLine||M.isPoints)&&(M.isSkinnedMesh&&M.skeleton.frame!==st.render.frame&&(M.skeleton.update(),M.skeleton.frame=st.render.frame),!M.frustumCulled||V.intersectsObject(M))){U&&lt.setFromMatrixPosition(M.matrixWorld).applyMatrix4($);let Ct=vt.update(M),Lt=M.material;if(Array.isArray(Lt)){let Rt=Ct.groups;for(let Gt=0,zt=Rt.length;Gt<zt;Gt++){let Ut=Rt[Gt],ie=Lt[Ut.materialIndex];ie&&ie.visible&&h.push(M,Ct,ie,O,lt.z,Ut)}}else Lt.visible&&h.push(M,Ct,Lt,O,lt.z,null)}}let Tt=M.children;for(let Ct=0,Lt=Tt.length;Ct<Lt;Ct++)ne(Tt[Ct],I,O,U)}function en(M,I,O,U){let Z=M.opaque,Tt=M.transmissive,Ct=M.transparent;f.setupLightsView(O),Tt.length>0&&yn(Z,I,O),U&&B.viewport(L.copy(U)),Z.length>0&&Do(Z,I,O),Tt.length>0&&Do(Tt,I,O),Ct.length>0&&Do(Ct,I,O)}function yn(M,I,O){if(G===null){let Ct=o===!0&&St.isWebGL2===!0?so:Ne;G=new Ct(1024,1024,{generateMipmaps:!0,type:_t.convert(Ur)!==null?Ur:ei,minFilter:Ll,magFilter:fe,wrapS:Ve,wrapT:Ve,useRenderToTexture:mt.has("WEBGL_multisampled_render_to_texture")})}let U=x.getRenderTarget();x.setRenderTarget(G),x.clear();let Z=x.toneMapping;x.toneMapping=ti,Do(M,I,O),x.toneMapping=Z,C.updateMultisampleRenderTarget(G),C.updateRenderTargetMipmap(G),x.setRenderTarget(U)}function Do(M,I,O){let U=I.isScene===!0?I.overrideMaterial:null;for(let Z=0,Tt=M.length;Z<Tt;Z++){let Ct=M[Z],Lt=Ct.object,Rt=Ct.geometry,Gt=U===null?Ct.material:U,zt=Ct.group;Lt.layers.test(O.layers)&&U0(Lt,I,O,Rt,Gt,zt)}}function U0(M,I,O,U,Z,Tt){M.onBeforeRender(x,I,O,U,Z,Tt),M.modelViewMatrix.multiplyMatrices(O.matrixWorldInverse,M.matrixWorld),M.normalMatrix.getNormalMatrix(M.modelViewMatrix),Z.onBeforeRender(x,I,O,U,M,Tt),Z.transparent===!0&&Z.side===Hr?(Z.side=he,Z.needsUpdate=!0,x.renderBufferDirect(O,I,U,Z,M,Tt),Z.side=eo,Z.needsUpdate=!0,x.renderBufferDirect(O,I,U,Z,M,Tt),Z.side=Hr):x.renderBufferDirect(O,I,U,Z,M,Tt),M.onAfterRender(x,I,O,U,Z,Tt)}function Ol(M,I,O){I.isScene!==!0&&(I=dt);let U=nt.get(M),Z=f.state.lights,Tt=f.state.shadowsArray,Ct=Z.state.version,Lt=bt.getParameters(M,Z.state,Tt,I,O),Rt=bt.getProgramCacheKey(Lt),Gt=U.programs;U.environment=M.isMeshStandardMaterial?I.environment:null,U.fog=I.fog,U.envMap=(M.isMeshStandardMaterial?J:j).get(M.envMap||U.environment),Gt===void 0&&(M.addEventListener("dispose",pt),Gt=new Map,U.programs=Gt);let zt=Gt.get(Rt);if(zt!==void 0){if(U.currentProgram===zt&&U.lightsStateVersion===Ct)return of(M,Lt),zt}else Lt.uniforms=bt.getUniforms(M),M.onBuild(O,Lt,x),M.onBeforeCompile(Lt,x),zt=bt.acquireProgram(Lt,Rt),Gt.set(Rt,zt),U.uniforms=Lt.uniforms;let Ut=U.uniforms;(!M.isShaderMaterial&&!M.isRawShaderMaterial||M.clipping===!0)&&(Ut.clippingPlanes=E.uniform),of(M,Lt),U.needsLights=k0(M),U.lightsStateVersion=Ct,U.needsLights&&(Ut.ambientLightColor.value=Z.state.ambient,Ut.lightProbe.value=Z.state.probe,Ut.directionalLights.value=Z.state.directional,Ut.directionalLightShadows.value=Z.state.directionalShadow,Ut.spotLights.value=Z.state.spot,Ut.spotLightShadows.value=Z.state.spotShadow,Ut.rectAreaLights.value=Z.state.rectArea,Ut.ltc_1.value=Z.state.rectAreaLTC1,Ut.ltc_2.value=Z.state.rectAreaLTC2,Ut.pointLights.value=Z.state.point,Ut.pointLightShadows.value=Z.state.pointShadow,Ut.hemisphereLights.value=Z.state.hemi,Ut.directionalShadowMap.value=Z.state.directionalShadowMap,Ut.directionalShadowMatrix.value=Z.state.directionalShadowMatrix,Ut.spotShadowMap.value=Z.state.spotShadowMap,Ut.spotShadowMatrix.value=Z.state.spotShadowMatrix,Ut.pointShadowMap.value=Z.state.pointShadowMap,Ut.pointShadowMatrix.value=Z.state.pointShadowMatrix);let ie=zt.getUniforms(),fi=ii.seqWithValue(ie.seq,Ut);return U.currentProgram=zt,U.uniformsList=fi,zt}function of(M,I){let O=nt.get(M);O.outputEncoding=I.outputEncoding,O.instancing=I.instancing,O.skinning=I.skinning,O.morphTargets=I.morphTargets,O.morphNormals=I.morphNormals,O.morphTargetsCount=I.morphTargetsCount,O.numClippingPlanes=I.numClippingPlanes,O.numIntersection=I.numClipIntersection,O.vertexAlphas=I.vertexAlphas,O.vertexTangents=I.vertexTangents,O.toneMapping=I.toneMapping}function B0(M,I,O,U,Z){I.isScene!==!0&&(I=dt),C.resetTextureUnits();let Tt=I.fog,Ct=U.isMeshStandardMaterial?I.environment:null,Lt=b===null?x.outputEncoding:b.isXRRenderTarget===!0?b.texture.encoding:ri,Rt=(U.isMeshStandardMaterial?J:j).get(U.envMap||Ct),Gt=U.vertexColors===!0&&!!O.attributes.color&&O.attributes.color.itemSize===4,zt=!!U.normalMap&&!!O.attributes.tangent,Ut=!!O.morphAttributes.position,ie=!!O.morphAttributes.normal,fi=O.morphAttributes.position?O.morphAttributes.position.length:0,Zi=U.toneMapped?x.toneMapping:ti,Ot=nt.get(U),nn=f.state.lights;if(Q===!0&&(at===!0||M!==S)){let Ze=M===S&&U.id===_;E.setState(U,M,Ze)}let le=!1;U.version===Ot.__version?(Ot.needsLights&&Ot.lightsStateVersion!==nn.state.version||Ot.outputEncoding!==Lt||Z.isInstancedMesh&&Ot.instancing===!1||!Z.isInstancedMesh&&Ot.instancing===!0||Z.isSkinnedMesh&&Ot.skinning===!1||!Z.isSkinnedMesh&&Ot.skinning===!0||Ot.envMap!==Rt||U.fog&&Ot.fog!==Tt||Ot.numClippingPlanes!==void 0&&(Ot.numClippingPlanes!==E.numPlanes||Ot.numIntersection!==E.numIntersection)||Ot.vertexAlphas!==Gt||Ot.vertexTangents!==zt||Ot.morphTargets!==Ut||Ot.morphNormals!==ie||Ot.toneMapping!==Zi||St.isWebGL2===!0&&Ot.morphTargetsCount!==fi)&&(le=!0):(le=!0,Ot.__version=U.version);let rn=Ot.currentProgram;le===!0&&(rn=Ol(U,I,Z));let Io=!1,sn=!1,vn=!1,_e=rn.getUniforms(),ns=Ot.uniforms;if(B.useProgram(rn.program)&&(Io=!0,sn=!0,vn=!0),U.id!==_&&(_=U.id,sn=!0),Io||S!==M){if(_e.setValue(k,"projectionMatrix",M.projectionMatrix),St.logarithmicDepthBuffer&&_e.setValue(k,"logDepthBufFC",2/(Math.log(M.far+1)/Math.LN2)),S!==M&&(S=M,sn=!0,vn=!0),U.isShaderMaterial||U.isMeshPhongMaterial||U.isMeshToonMaterial||U.isMeshStandardMaterial||U.envMap){let Ze=_e.map.cameraPosition;Ze!==void 0&&Ze.setValue(k,lt.setFromMatrixPosition(M.matrixWorld))}(U.isMeshPhongMaterial||U.isMeshToonMaterial||U.isMeshLambertMaterial||U.isMeshBasicMaterial||U.isMeshStandardMaterial||U.isShaderMaterial)&&_e.setValue(k,"isOrthographic",M.isOrthographicCamera===!0),(U.isMeshPhongMaterial||U.isMeshToonMaterial||U.isMeshLambertMaterial||U.isMeshBasicMaterial||U.isMeshStandardMaterial||U.isShaderMaterial||U.isShadowMaterial||Z.isSkinnedMesh)&&_e.setValue(k,"viewMatrix",M.matrixWorldInverse)}if(Z.isSkinnedMesh){_e.setOptional(k,Z,"bindMatrix"),_e.setOptional(k,Z,"bindMatrixInverse");let Ze=Z.skeleton;Ze&&(St.floatVertexTextures?(Ze.boneTexture===null&&Ze.computeBoneTexture(),_e.setValue(k,"boneTexture",Ze.boneTexture,C),_e.setValue(k,"boneTextureSize",Ze.boneTextureSize)):_e.setOptional(k,Ze,"boneMatrices"))}return!!O&&(O.morphAttributes.position!==void 0||O.morphAttributes.normal!==void 0)&&rt.update(Z,O,U,rn),(sn||Ot.receiveShadow!==Z.receiveShadow)&&(Ot.receiveShadow=Z.receiveShadow,_e.setValue(k,"receiveShadow",Z.receiveShadow)),sn&&(_e.setValue(k,"toneMappingExposure",x.toneMappingExposure),Ot.needsLights&&O0(ns,vn),Tt&&U.fog&&It.refreshFogUniforms(ns,Tt),It.refreshMaterialUniforms(ns,U,y,X,G),ii.upload(k,Ot.uniformsList,ns,C)),U.isShaderMaterial&&U.uniformsNeedUpdate===!0&&(ii.upload(k,Ot.uniformsList,ns,C),U.uniformsNeedUpdate=!1),U.isSpriteMaterial&&_e.setValue(k,"center",Z.center),_e.setValue(k,"modelViewMatrix",Z.modelViewMatrix),_e.setValue(k,"normalMatrix",Z.normalMatrix),_e.setValue(k,"modelMatrix",Z.matrixWorld),rn}function O0(M,I){M.ambientLightColor.needsUpdate=I,M.lightProbe.needsUpdate=I,M.directionalLights.needsUpdate=I,M.directionalLightShadows.needsUpdate=I,M.pointLights.needsUpdate=I,M.pointLightShadows.needsUpdate=I,M.spotLights.needsUpdate=I,M.spotLightShadows.needsUpdate=I,M.rectAreaLights.needsUpdate=I,M.hemisphereLights.needsUpdate=I}function k0(M){return M.isMeshLambertMaterial||M.isMeshToonMaterial||M.isMeshPhongMaterial||M.isMeshStandardMaterial||M.isShadowMaterial||M.isShaderMaterial&&M.lights===!0}this.getActiveCubeFace=function(){return m},this.getActiveMipmapLevel=function(){return p},this.getRenderTarget=function(){return b},this.setRenderTargetTextures=function(M,I,O){nt.get(M.texture).__webglTexture=I,nt.get(M.depthTexture).__webglTexture=O;let U=nt.get(M);U.__hasExternalTextures=!0,U.__hasExternalTextures&&(U.__autoAllocateDepthBuffer=O===void 0,U.__autoAllocateDepthBuffer||M.useRenderToTexture&&(console.warn("render-to-texture extension was disabled because an external texture was provided"),M.useRenderToTexture=!1,M.useRenderbuffer=!0))},this.setRenderTargetFramebuffer=function(M,I){let O=nt.get(M);O.__webglFramebuffer=I,O.__useDefaultFramebuffer=I===void 0},this.setRenderTarget=function(M,I=0,O=0){b=M,m=I,p=O;let U=!0;if(M){let Rt=nt.get(M);Rt.__useDefaultFramebuffer!==void 0?(B.bindFramebuffer(36160,null),U=!1):Rt.__webglFramebuffer===void 0?C.setupRenderTarget(M):Rt.__hasExternalTextures&&C.rebindTextures(M,nt.get(M.texture).__webglTexture,nt.get(M.depthTexture).__webglTexture)}let Z=null,Tt=!1,Ct=!1;if(M){let Rt=M.texture;(Rt.isDataTexture3D||Rt.isDataTexture2DArray)&&(Ct=!0);let Gt=nt.get(M).__webglFramebuffer;M.isWebGLCubeRenderTarget?(Z=Gt[I],Tt=!0):M.useRenderbuffer?Z=nt.get(M).__webglMultisampledFramebuffer:Z=Gt,L.copy(M.viewport),A.copy(M.scissor),H=M.scissorTest}else L.copy(F).multiplyScalar(y).floor(),A.copy(z).multiplyScalar(y).floor(),H=N;if(B.bindFramebuffer(36160,Z)&&St.drawBuffers&&U&&B.drawBuffers(M,Z),B.viewport(L),B.scissor(A),B.setScissorTest(H),Tt){let Rt=nt.get(M.texture);k.framebufferTexture2D(36160,36064,34069+I,Rt.__webglTexture,O)}else if(Ct){let Rt=nt.get(M.texture),Gt=I||0;k.framebufferTextureLayer(36160,36064,Rt.__webglTexture,O||0,Gt)}_=-1},this.readRenderTargetPixels=function(M,I,O,U,Z,Tt,Ct){if(!(M&&M.isWebGLRenderTarget)){console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.");return}let Lt=nt.get(M).__webglFramebuffer;if(M.isWebGLCubeRenderTarget&&Ct!==void 0&&(Lt=Lt[Ct]),Lt){B.bindFramebuffer(36160,Lt);try{let Rt=M.texture,Gt=Rt.format,zt=Rt.type;if(Gt!==Re&&_t.convert(Gt)!==k.getParameter(35739)){console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.");return}let Ut=zt===Ur&&(mt.has("EXT_color_buffer_half_float")||St.isWebGL2&&mt.has("EXT_color_buffer_float"));if(zt!==ei&&_t.convert(zt)!==k.getParameter(35738)&&!(zt===Ui&&(St.isWebGL2||mt.has("OES_texture_float")||mt.has("WEBGL_color_buffer_float")))&&!Ut){console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.");return}k.checkFramebufferStatus(36160)===36053?I>=0&&I<=M.width-U&&O>=0&&O<=M.height-Z&&k.readPixels(I,O,U,Z,_t.convert(Gt),_t.convert(zt),Tt):console.error("THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete.")}finally{let Rt=b!==null?nt.get(b).__webglFramebuffer:null;B.bindFramebuffer(36160,Rt)}}},this.copyFramebufferToTexture=function(M,I,O=0){if(I.isFramebufferTexture!==!0){console.error("THREE.WebGLRenderer: copyFramebufferToTexture() can only be used with FramebufferTexture.");return}let U=Math.pow(2,-O),Z=Math.floor(I.image.width*U),Tt=Math.floor(I.image.height*U);C.setTexture2D(I,0),k.copyTexSubImage2D(3553,O,0,0,M.x,M.y,Z,Tt),B.unbindTexture()},this.copyTextureToTexture=function(M,I,O,U=0){let Z=I.image.width,Tt=I.image.height,Ct=_t.convert(O.format),Lt=_t.convert(O.type);C.setTexture2D(O,0),k.pixelStorei(37440,O.flipY),k.pixelStorei(37441,O.premultiplyAlpha),k.pixelStorei(3317,O.unpackAlignment),I.isDataTexture?k.texSubImage2D(3553,U,M.x,M.y,Z,Tt,Ct,Lt,I.image.data):I.isCompressedTexture?k.compressedTexSubImage2D(3553,U,M.x,M.y,I.mipmaps[0].width,I.mipmaps[0].height,Ct,I.mipmaps[0].data):k.texSubImage2D(3553,U,M.x,M.y,Ct,Lt,I.image),U===0&&O.generateMipmaps&&k.generateMipmap(3553),B.unbindTexture()},this.copyTextureToTexture3D=function(M,I,O,U,Z=0){if(x.isWebGL1Renderer){console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: can only be used with WebGL2.");return}let Tt=M.max.x-M.min.x+1,Ct=M.max.y-M.min.y+1,Lt=M.max.z-M.min.z+1,Rt=_t.convert(U.format),Gt=_t.convert(U.type),zt;if(U.isDataTexture3D)C.setTexture3D(U,0),zt=32879;else if(U.isDataTexture2DArray)C.setTexture2DArray(U,0),zt=35866;else{console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: only supports THREE.DataTexture3D and THREE.DataTexture2DArray.");return}k.pixelStorei(37440,U.flipY),k.pixelStorei(37441,U.premultiplyAlpha),k.pixelStorei(3317,U.unpackAlignment);let Ut=k.getParameter(3314),ie=k.getParameter(32878),fi=k.getParameter(3316),Zi=k.getParameter(3315),Ot=k.getParameter(32877),nn=O.isCompressedTexture?O.mipmaps[0]:O.image;k.pixelStorei(3314,nn.width),k.pixelStorei(32878,nn.height),k.pixelStorei(3316,M.min.x),k.pixelStorei(3315,M.min.y),k.pixelStorei(32877,M.min.z),O.isDataTexture||O.isDataTexture3D?k.texSubImage3D(zt,Z,I.x,I.y,I.z,Tt,Ct,Lt,Rt,Gt,nn.data):O.isCompressedTexture?(console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: untested support for compressed srcTexture."),k.compressedTexSubImage3D(zt,Z,I.x,I.y,I.z,Tt,Ct,Lt,Rt,nn.data)):k.texSubImage3D(zt,Z,I.x,I.y,I.z,Tt,Ct,Lt,Rt,Gt,nn),k.pixelStorei(3314,Ut),k.pixelStorei(32878,ie),k.pixelStorei(3316,fi),k.pixelStorei(3315,Zi),k.pixelStorei(32877,Ot),Z===0&&U.generateMipmaps&&k.generateMipmap(zt),B.unbindTexture()},this.initTexture=function(M){C.setTexture2D(M,0),B.unbindTexture()},this.resetState=function(){m=0,p=0,b=null,B.reset(),yt.reset()},typeof __THREE_DEVTOOLS__!="undefined"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}Vt.prototype.isWebGLRenderer=!0;var Ju=class extends Vt{};Ju.prototype.isWebGL1Renderer=!0;var ho=class{constructor(t,e=25e-5){this.name="",this.color=new ft(t),this.density=e}clone(){return new ho(this.color,this.density)}toJSON(){return{type:"FogExp2",color:this.color.getHex(),density:this.density}}};ho.prototype.isFogExp2=!0;var fo=class{constructor(t,e=1,i=1e3){this.name="",this.color=new ft(t),this.near=e,this.far=i}clone(){return new fo(this.color,this.near,this.far)}toJSON(){return{type:"Fog",color:this.color.getHex(),near:this.near,far:this.far}}};fo.prototype.isFog=!0;var Yr=class extends kt{constructor(){super(),this.type="Scene",this.background=null,this.environment=null,this.fog=null,this.overrideMaterial=null,this.autoUpdate=!0,typeof __THREE_DEVTOOLS__!="undefined"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}copy(t,e){return super.copy(t,e),t.background!==null&&(this.background=t.background.clone()),t.environment!==null&&(this.environment=t.environment.clone()),t.fog!==null&&(this.fog=t.fog.clone()),t.overrideMaterial!==null&&(this.overrideMaterial=t.overrideMaterial.clone()),this.autoUpdate=t.autoUpdate,this.matrixAutoUpdate=t.matrixAutoUpdate,this}toJSON(t){let e=super.toJSON(t);return this.fog!==null&&(e.object.fog=this.fog.toJSON()),e}};Yr.prototype.isScene=!0;var Gi=class{constructor(t,e){this.array=t,this.stride=e,this.count=t!==void 0?t.length/e:0,this.usage=io,this.updateRange={offset:0,count:-1},this.version=0,this.uuid=tn()}onUploadCallback(){}set needsUpdate(t){t===!0&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.array=new t.array.constructor(t.array),this.count=t.count,this.stride=t.stride,this.usage=t.usage,this}copyAt(t,e,i){t*=this.stride,i*=e.stride;for(let r=0,s=this.stride;r<s;r++)this.array[t+r]=e.array[i+r];return this}set(t,e=0){return this.array.set(t,e),this}clone(t){t.arrayBuffers===void 0&&(t.arrayBuffers={}),this.array.buffer._uuid===void 0&&(this.array.buffer._uuid=tn()),t.arrayBuffers[this.array.buffer._uuid]===void 0&&(t.arrayBuffers[this.array.buffer._uuid]=this.array.slice(0).buffer);let e=new this.array.constructor(t.arrayBuffers[this.array.buffer._uuid]),i=new this.constructor(e,this.stride);return i.setUsage(this.usage),i}onUpload(t){return this.onUploadCallback=t,this}toJSON(t){return t.arrayBuffers===void 0&&(t.arrayBuffers={}),this.array.buffer._uuid===void 0&&(this.array.buffer._uuid=tn()),t.arrayBuffers[this.array.buffer._uuid]===void 0&&(t.arrayBuffers[this.array.buffer._uuid]=Array.prototype.slice.call(new Uint32Array(this.array.buffer))),{uuid:this.uuid,buffer:this.array.buffer._uuid,type:this.array.constructor.name,stride:this.stride}}};Gi.prototype.isInterleavedBuffer=!0;var se=new T,Wi=class{constructor(t,e,i,r=!1){this.name="",this.data=t,this.itemSize=e,this.offset=i,this.normalized=r===!0}get count(){return this.data.count}get array(){return this.data.array}set needsUpdate(t){this.data.needsUpdate=t}applyMatrix4(t){for(let e=0,i=this.data.count;e<i;e++)se.x=this.getX(e),se.y=this.getY(e),se.z=this.getZ(e),se.applyMatrix4(t),this.setXYZ(e,se.x,se.y,se.z);return this}applyNormalMatrix(t){for(let e=0,i=this.count;e<i;e++)se.x=this.getX(e),se.y=this.getY(e),se.z=this.getZ(e),se.applyNormalMatrix(t),this.setXYZ(e,se.x,se.y,se.z);return this}transformDirection(t){for(let e=0,i=this.count;e<i;e++)se.x=this.getX(e),se.y=this.getY(e),se.z=this.getZ(e),se.transformDirection(t),this.setXYZ(e,se.x,se.y,se.z);return this}setX(t,e){return this.data.array[t*this.data.stride+this.offset]=e,this}setY(t,e){return this.data.array[t*this.data.stride+this.offset+1]=e,this}setZ(t,e){return this.data.array[t*this.data.stride+this.offset+2]=e,this}setW(t,e){return this.data.array[t*this.data.stride+this.offset+3]=e,this}getX(t){return this.data.array[t*this.data.stride+this.offset]}getY(t){return this.data.array[t*this.data.stride+this.offset+1]}getZ(t){return this.data.array[t*this.data.stride+this.offset+2]}getW(t){return this.data.array[t*this.data.stride+this.offset+3]}setXY(t,e,i){return t=t*this.data.stride+this.offset,this.data.array[t+0]=e,this.data.array[t+1]=i,this}setXYZ(t,e,i,r){return t=t*this.data.stride+this.offset,this.data.array[t+0]=e,this.data.array[t+1]=i,this.data.array[t+2]=r,this}setXYZW(t,e,i,r,s){return t=t*this.data.stride+this.offset,this.data.array[t+0]=e,this.data.array[t+1]=i,this.data.array[t+2]=r,this.data.array[t+3]=s,this}clone(t){if(t===void 0){console.log("THREE.InterleavedBufferAttribute.clone(): Cloning an interlaved buffer attribute will deinterleave buffer data.");let e=[];for(let i=0;i<this.count;i++){let r=i*this.data.stride+this.offset;for(let s=0;s<this.itemSize;s++)e.push(this.data.array[r+s])}return new Qt(new this.array.constructor(e),this.itemSize,this.normalized)}else return t.interleavedBuffers===void 0&&(t.interleavedBuffers={}),t.interleavedBuffers[this.data.uuid]===void 0&&(t.interleavedBuffers[this.data.uuid]=this.data.clone(t)),new Wi(t.interleavedBuffers[this.data.uuid],this.itemSize,this.offset,this.normalized)}toJSON(t){if(t===void 0){console.log("THREE.InterleavedBufferAttribute.toJSON(): Serializing an interlaved buffer attribute will deinterleave buffer data.");let e=[];for(let i=0;i<this.count;i++){let r=i*this.data.stride+this.offset;for(let s=0;s<this.itemSize;s++)e.push(this.data.array[r+s])}return{itemSize:this.itemSize,type:this.array.constructor.name,array:e,normalized:this.normalized}}else return t.interleavedBuffers===void 0&&(t.interleavedBuffers={}),t.interleavedBuffers[this.data.uuid]===void 0&&(t.interleavedBuffers[this.data.uuid]=this.data.toJSON(t)),{isInterleavedBufferAttribute:!0,itemSize:this.itemSize,data:this.data.uuid,offset:this.offset,normalized:this.normalized}}};Wi.prototype.isInterleavedBufferAttribute=!0;var fl=class extends xe{constructor(t){super(),this.type="SpriteMaterial",this.color=new ft(16777215),this.map=null,this.alphaMap=null,this.rotation=0,this.sizeAttenuation=!0,this.transparent=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.rotation=t.rotation,this.sizeAttenuation=t.sizeAttenuation,this}};fl.prototype.isSpriteMaterial=!0;var Rr,Ws=new T,Lr=new T,Pr=new T,Dr=new K,qs=new K,A0=new wt,Oa=new T,Xs=new T,ka=new T,Ug=new K,Ru=new K,Bg=new K,$u=class extends kt{constructor(t){if(super(),this.type="Sprite",Rr===void 0){Rr=new Ht;let e=new Float32Array([-.5,-.5,0,0,0,.5,-.5,0,1,0,.5,.5,0,1,1,-.5,.5,0,0,1]),i=new Gi(e,5);Rr.setIndex([0,1,2,0,2,3]),Rr.setAttribute("position",new Wi(i,3,0,!1)),Rr.setAttribute("uv",new Wi(i,2,3,!1))}this.geometry=Rr,this.material=t!==void 0?t:new fl,this.center=new K(.5,.5)}raycast(t,e){t.camera===null&&console.error('THREE.Sprite: "Raycaster.camera" needs to be set in order to raycast against sprites.'),Lr.setFromMatrixScale(this.matrixWorld),A0.copy(t.camera.matrixWorld),this.modelViewMatrix.multiplyMatrices(t.camera.matrixWorldInverse,this.matrixWorld),Pr.setFromMatrixPosition(this.modelViewMatrix),t.camera.isPerspectiveCamera&&this.material.sizeAttenuation===!1&&Lr.multiplyScalar(-Pr.z);let i=this.material.rotation,r,s;i!==0&&(s=Math.cos(i),r=Math.sin(i));let o=this.center;Ha(Oa.set(-.5,-.5,0),Pr,o,Lr,r,s),Ha(Xs.set(.5,-.5,0),Pr,o,Lr,r,s),Ha(ka.set(.5,.5,0),Pr,o,Lr,r,s),Ug.set(0,0),Ru.set(1,0),Bg.set(1,1);let a=t.ray.intersectTriangle(Oa,Xs,ka,!1,Ws);if(a===null&&(Ha(Xs.set(-.5,.5,0),Pr,o,Lr,r,s),Ru.set(0,1),a=t.ray.intersectTriangle(Oa,ka,Xs,!1,Ws),a===null))return;let l=t.ray.origin.distanceTo(Ws);l<t.near||l>t.far||e.push({distance:l,point:Ws.clone(),uv:re.getUV(Ws,Oa,Xs,ka,Ug,Ru,Bg,new K),face:null,object:this})}copy(t){return super.copy(t),t.center!==void 0&&this.center.copy(t.center),this.material=t.material,this}};$u.prototype.isSprite=!0;function Ha(n,t,e,i,r,s){Dr.subVectors(n,e).addScalar(.5).multiply(i),r!==void 0?(qs.x=s*Dr.x-r*Dr.y,qs.y=r*Dr.x+s*Dr.y):qs.copy(Dr),n.copy(t),n.x+=qs.x,n.y+=qs.y,n.applyMatrix4(A0)}var Og=new T,kg=new Wt,Hg=new Wt,NE=new T,Vg=new wt,dl=class extends oe{constructor(t,e){super(t,e),this.type="SkinnedMesh",this.bindMode="attached",this.bindMatrix=new wt,this.bindMatrixInverse=new wt}copy(t){return super.copy(t),this.bindMode=t.bindMode,this.bindMatrix.copy(t.bindMatrix),this.bindMatrixInverse.copy(t.bindMatrixInverse),this.skeleton=t.skeleton,this}bind(t,e){this.skeleton=t,e===void 0&&(this.updateMatrixWorld(!0),this.skeleton.calculateInverses(),e=this.matrixWorld),this.bindMatrix.copy(e),this.bindMatrixInverse.copy(e).invert()}pose(){this.skeleton.pose()}normalizeSkinWeights(){let t=new Wt,e=this.geometry.attributes.skinWeight;for(let i=0,r=e.count;i<r;i++){t.x=e.getX(i),t.y=e.getY(i),t.z=e.getZ(i),t.w=e.getW(i);let s=1/t.manhattanLength();s!==1/0?t.multiplyScalar(s):t.set(1,0,0,0),e.setXYZW(i,t.x,t.y,t.z,t.w)}}updateMatrixWorld(t){super.updateMatrixWorld(t),this.bindMode==="attached"?this.bindMatrixInverse.copy(this.matrixWorld).invert():this.bindMode==="detached"?this.bindMatrixInverse.copy(this.bindMatrix).invert():console.warn("THREE.SkinnedMesh: Unrecognized bindMode: "+this.bindMode)}boneTransform(t,e){let i=this.skeleton,r=this.geometry;kg.fromBufferAttribute(r.attributes.skinIndex,t),Hg.fromBufferAttribute(r.attributes.skinWeight,t),Og.copy(e).applyMatrix4(this.bindMatrix),e.set(0,0,0);for(let s=0;s<4;s++){let o=Hg.getComponent(s);if(o!==0){let a=kg.getComponent(s);Vg.multiplyMatrices(i.bones[a].matrixWorld,i.boneInverses[a]),e.addScaledVector(NE.copy(Og).applyMatrix4(Vg),o)}}return e.applyMatrix4(this.bindMatrixInverse)}};dl.prototype.isSkinnedMesh=!0;var Ku=class extends kt{constructor(){super(),this.type="Bone"}};Ku.prototype.isBone=!0;var Qu=class extends ae{constructor(t=null,e=1,i=1,r,s,o,a,l,c=fe,u=fe,h,f){super(null,o,a,l,c,u,r,s,h,f),this.image={data:t,width:e,height:i},this.magFilter=c,this.minFilter=u,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};Qu.prototype.isDataTexture=!0;var po=class extends Qt{constructor(t,e,i,r=1){typeof i=="number"&&(r=i,i=!1,console.error("THREE.InstancedBufferAttribute: The constructor now expects normalized as the third argument.")),super(t,e,i),this.meshPerAttribute=r}copy(t){return super.copy(t),this.meshPerAttribute=t.meshPerAttribute,this}toJSON(){let t=super.toJSON();return t.meshPerAttribute=this.meshPerAttribute,t.isInstancedBufferAttribute=!0,t}};po.prototype.isInstancedBufferAttribute=!0;var Gg=new wt,Wg=new wt,Va=[],Ys=new oe,ju=class extends oe{constructor(t,e,i){super(t,e),this.instanceMatrix=new po(new Float32Array(i*16),16),this.instanceColor=null,this.count=i,this.frustumCulled=!1}copy(t){return super.copy(t),this.instanceMatrix.copy(t.instanceMatrix),t.instanceColor!==null&&(this.instanceColor=t.instanceColor.clone()),this.count=t.count,this}getColorAt(t,e){e.fromArray(this.instanceColor.array,t*3)}getMatrixAt(t,e){e.fromArray(this.instanceMatrix.array,t*16)}raycast(t,e){let i=this.matrixWorld,r=this.count;if(Ys.geometry=this.geometry,Ys.material=this.material,Ys.material!==void 0)for(let s=0;s<r;s++){this.getMatrixAt(s,Gg),Wg.multiplyMatrices(i,Gg),Ys.matrixWorld=Wg,Ys.raycast(t,Va);for(let o=0,a=Va.length;o<a;o++){let l=Va[o];l.instanceId=s,l.object=this,e.push(l)}Va.length=0}}setColorAt(t,e){this.instanceColor===null&&(this.instanceColor=new po(new Float32Array(this.instanceMatrix.count*3),3)),e.toArray(this.instanceColor.array,t*3)}setMatrixAt(t,e){e.toArray(this.instanceMatrix.array,t*16)}updateMorphTargets(){}dispose(){this.dispatchEvent({type:"dispose"})}};ju.prototype.isInstancedMesh=!0;var zn=class extends xe{constructor(t){super(),this.type="LineBasicMaterial",this.color=new ft(16777215),this.linewidth=1,this.linecap="round",this.linejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.linewidth=t.linewidth,this.linecap=t.linecap,this.linejoin=t.linejoin,this}};zn.prototype.isLineBasicMaterial=!0;var qg=new T,Xg=new T,Yg=new wt,Lu=new oi,Ga=new si,mo=class extends kt{constructor(t=new Ht,e=new zn){super(),this.type="Line",this.geometry=t,this.material=e,this.updateMorphTargets()}copy(t){return super.copy(t),this.material=t.material,this.geometry=t.geometry,this}computeLineDistances(){let t=this.geometry;if(t.isBufferGeometry)if(t.index===null){let e=t.attributes.position,i=[0];for(let r=1,s=e.count;r<s;r++)qg.fromBufferAttribute(e,r-1),Xg.fromBufferAttribute(e,r),i[r]=i[r-1],i[r]+=qg.distanceTo(Xg);t.setAttribute("lineDistance",new ee(i,1))}else console.warn("THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.Line.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}raycast(t,e){let i=this.geometry,r=this.matrixWorld,s=t.params.Line.threshold,o=i.drawRange;if(i.boundingSphere===null&&i.computeBoundingSphere(),Ga.copy(i.boundingSphere),Ga.applyMatrix4(r),Ga.radius+=s,t.ray.intersectsSphere(Ga)===!1)return;Yg.copy(r).invert(),Lu.copy(t.ray).applyMatrix4(Yg);let a=s/((this.scale.x+this.scale.y+this.scale.z)/3),l=a*a,c=new T,u=new T,h=new T,f=new T,d=this.isLineSegments?2:1;if(i.isBufferGeometry){let g=i.index,v=i.attributes.position;if(g!==null){let m=Math.max(0,o.start),p=Math.min(g.count,o.start+o.count);for(let b=m,_=p-1;b<_;b+=d){let S=g.getX(b),L=g.getX(b+1);if(c.fromBufferAttribute(v,S),u.fromBufferAttribute(v,L),Lu.distanceSqToSegment(c,u,f,h)>l)continue;f.applyMatrix4(this.matrixWorld);let H=t.ray.origin.distanceTo(f);H<t.near||H>t.far||e.push({distance:H,point:h.clone().applyMatrix4(this.matrixWorld),index:b,face:null,faceIndex:null,object:this})}}else{let m=Math.max(0,o.start),p=Math.min(v.count,o.start+o.count);for(let b=m,_=p-1;b<_;b+=d){if(c.fromBufferAttribute(v,b),u.fromBufferAttribute(v,b+1),Lu.distanceSqToSegment(c,u,f,h)>l)continue;f.applyMatrix4(this.matrixWorld);let L=t.ray.origin.distanceTo(f);L<t.near||L>t.far||e.push({distance:L,point:h.clone().applyMatrix4(this.matrixWorld),index:b,face:null,faceIndex:null,object:this})}}}else i.isGeometry&&console.error("THREE.Line.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let e=t.morphAttributes,i=Object.keys(e);if(i.length>0){let r=e[i[0]];if(r!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let s=0,o=r.length;s<o;s++){let a=r[s].name||String(s);this.morphTargetInfluences.push(0),this.morphTargetDictionary[a]=s}}}}else{let e=t.morphTargets;e!==void 0&&e.length>0&&console.error("THREE.Line.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}};mo.prototype.isLine=!0;var Zg=new T,Jg=new T,go=class extends mo{constructor(t,e){super(t,e),this.type="LineSegments"}computeLineDistances(){let t=this.geometry;if(t.isBufferGeometry)if(t.index===null){let e=t.attributes.position,i=[];for(let r=0,s=e.count;r<s;r+=2)Zg.fromBufferAttribute(e,r),Jg.fromBufferAttribute(e,r+1),i[r]=r===0?0:i[r-1],i[r+1]=i[r]+Zg.distanceTo(Jg);t.setAttribute("lineDistance",new ee(i,1))}else console.warn("THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.LineSegments.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}};go.prototype.isLineSegments=!0;var th=class extends mo{constructor(t,e){super(t,e),this.type="LineLoop"}};th.prototype.isLineLoop=!0;var pl=class extends xe{constructor(t){super(),this.type="PointsMaterial",this.color=new ft(16777215),this.map=null,this.alphaMap=null,this.size=1,this.sizeAttenuation=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.size=t.size,this.sizeAttenuation=t.sizeAttenuation,this}};pl.prototype.isPointsMaterial=!0;var $g=new wt,eh=new oi,Wa=new si,qa=new T,nh=class extends kt{constructor(t=new Ht,e=new pl){super(),this.type="Points",this.geometry=t,this.material=e,this.updateMorphTargets()}copy(t){return super.copy(t),this.material=t.material,this.geometry=t.geometry,this}raycast(t,e){let i=this.geometry,r=this.matrixWorld,s=t.params.Points.threshold,o=i.drawRange;if(i.boundingSphere===null&&i.computeBoundingSphere(),Wa.copy(i.boundingSphere),Wa.applyMatrix4(r),Wa.radius+=s,t.ray.intersectsSphere(Wa)===!1)return;$g.copy(r).invert(),eh.copy(t.ray).applyMatrix4($g);let a=s/((this.scale.x+this.scale.y+this.scale.z)/3),l=a*a;if(i.isBufferGeometry){let c=i.index,h=i.attributes.position;if(c!==null){let f=Math.max(0,o.start),d=Math.min(c.count,o.start+o.count);for(let g=f,x=d;g<x;g++){let v=c.getX(g);qa.fromBufferAttribute(h,v),Kg(qa,v,l,r,t,e,this)}}else{let f=Math.max(0,o.start),d=Math.min(h.count,o.start+o.count);for(let g=f,x=d;g<x;g++)qa.fromBufferAttribute(h,g),Kg(qa,g,l,r,t,e,this)}}else console.error("THREE.Points.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let e=t.morphAttributes,i=Object.keys(e);if(i.length>0){let r=e[i[0]];if(r!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let s=0,o=r.length;s<o;s++){let a=r[s].name||String(s);this.morphTargetInfluences.push(0),this.morphTargetDictionary[a]=s}}}}else{let e=t.morphTargets;e!==void 0&&e.length>0&&console.error("THREE.Points.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}};nh.prototype.isPoints=!0;function Kg(n,t,e,i,r,s,o){let a=eh.distanceSqToPoint(n);if(a<e){let l=new T;eh.closestPointToPoint(n,l),l.applyMatrix4(i);let c=r.ray.origin.distanceTo(l);if(c<r.near||c>r.far)return;s.push({distance:c,distanceToRay:Math.sqrt(a),point:l,index:t,face:null,object:o})}}var ih=class extends ae{constructor(t,e,i,r,s,o,a,l,c){super(t,e,i,r,s,o,a,l,c),this.minFilter=o!==void 0?o:be,this.magFilter=s!==void 0?s:be,this.generateMipmaps=!1;let u=this;function h(){u.needsUpdate=!0,t.requestVideoFrameCallback(h)}"requestVideoFrameCallback"in t&&t.requestVideoFrameCallback(h)}clone(){return new this.constructor(this.image).copy(this)}update(){let t=this.image;"requestVideoFrameCallback"in t===!1&&t.readyState>=t.HAVE_CURRENT_DATA&&(this.needsUpdate=!0)}};ih.prototype.isVideoTexture=!0;var rh=class extends ae{constructor(t,e,i){super({width:t,height:e}),this.format=i,this.magFilter=fe,this.minFilter=fe,this.generateMipmaps=!1,this.needsUpdate=!0}};rh.prototype.isFramebufferTexture=!0;var sh=class extends ae{constructor(t,e,i,r,s,o,a,l,c,u,h,f){super(null,o,a,l,c,u,r,s,h,f),this.image={width:e,height:i},this.mipmaps=t,this.flipY=!1,this.generateMipmaps=!1}};sh.prototype.isCompressedTexture=!0;var oh=class extends ae{constructor(t,e,i,r,s,o,a,l,c){super(t,e,i,r,s,o,a,l,c),this.needsUpdate=!0}};oh.prototype.isCanvasTexture=!0;var Zr=class extends Ht{constructor(t=1,e=8,i=0,r=Math.PI*2){super(),this.type="CircleGeometry",this.parameters={radius:t,segments:e,thetaStart:i,thetaLength:r},e=Math.max(3,e);let s=[],o=[],a=[],l=[],c=new T,u=new K;o.push(0,0,0),a.push(0,0,1),l.push(.5,.5);for(let h=0,f=3;h<=e;h++,f+=3){let d=i+h/e*r;c.x=t*Math.cos(d),c.y=t*Math.sin(d),o.push(c.x,c.y,c.z),a.push(0,0,1),u.x=(o[f]/t+1)/2,u.y=(o[f+1]/t+1)/2,l.push(u.x,u.y)}for(let h=1;h<=e;h++)s.push(h,h+1,0);this.setIndex(s),this.setAttribute("position",new ee(o,3)),this.setAttribute("normal",new ee(a,3)),this.setAttribute("uv",new ee(l,2))}static fromJSON(t){return new Zr(t.radius,t.segments,t.thetaStart,t.thetaLength)}};var Sk=new T,Ek=new T,Tk=new T,Ak=new re;var Fe=class{constructor(){this.type="Curve",this.arcLengthDivisions=200}getPoint(){return console.warn("THREE.Curve: .getPoint() not implemented."),null}getPointAt(t,e){let i=this.getUtoTmapping(t);return this.getPoint(i,e)}getPoints(t=5){let e=[];for(let i=0;i<=t;i++)e.push(this.getPoint(i/t));return e}getSpacedPoints(t=5){let e=[];for(let i=0;i<=t;i++)e.push(this.getPointAt(i/t));return e}getLength(){let t=this.getLengths();return t[t.length-1]}getLengths(t=this.arcLengthDivisions){if(this.cacheArcLengths&&this.cacheArcLengths.length===t+1&&!this.needsUpdate)return this.cacheArcLengths;this.needsUpdate=!1;let e=[],i,r=this.getPoint(0),s=0;e.push(0);for(let o=1;o<=t;o++)i=this.getPoint(o/t),s+=i.distanceTo(r),e.push(s),r=i;return this.cacheArcLengths=e,e}updateArcLengths(){this.needsUpdate=!0,this.getLengths()}getUtoTmapping(t,e){let i=this.getLengths(),r=0,s=i.length,o;e?o=e:o=t*i[s-1];let a=0,l=s-1,c;for(;a<=l;)if(r=Math.floor(a+(l-a)/2),c=i[r]-o,c<0)a=r+1;else if(c>0)l=r-1;else{l=r;break}if(r=l,i[r]===o)return r/(s-1);let u=i[r],f=i[r+1]-u,d=(o-u)/f;return(r+d)/(s-1)}getTangent(t,e){let r=t-1e-4,s=t+1e-4;r<0&&(r=0),s>1&&(s=1);let o=this.getPoint(r),a=this.getPoint(s),l=e||(o.isVector2?new K:new T);return l.copy(a).sub(o).normalize(),l}getTangentAt(t,e){let i=this.getUtoTmapping(t);return this.getTangent(i,e)}computeFrenetFrames(t,e){let i=new T,r=[],s=[],o=[],a=new T,l=new wt;for(let d=0;d<=t;d++){let g=d/t;r[d]=this.getTangentAt(g,new T)}s[0]=new T,o[0]=new T;let c=Number.MAX_VALUE,u=Math.abs(r[0].x),h=Math.abs(r[0].y),f=Math.abs(r[0].z);u<=c&&(c=u,i.set(1,0,0)),h<=c&&(c=h,i.set(0,1,0)),f<=c&&i.set(0,0,1),a.crossVectors(r[0],i).normalize(),s[0].crossVectors(r[0],a),o[0].crossVectors(r[0],s[0]);for(let d=1;d<=t;d++){if(s[d]=s[d-1].clone(),o[d]=o[d-1].clone(),a.crossVectors(r[d-1],r[d]),a.length()>Number.EPSILON){a.normalize();let g=Math.acos(Ie(r[d-1].dot(r[d]),-1,1));s[d].applyMatrix4(l.makeRotationAxis(a,g))}o[d].crossVectors(r[d],s[d])}if(e===!0){let d=Math.acos(Ie(s[0].dot(s[t]),-1,1));d/=t,r[0].dot(a.crossVectors(s[0],s[t]))>0&&(d=-d);for(let g=1;g<=t;g++)s[g].applyMatrix4(l.makeRotationAxis(r[g],d*g)),o[g].crossVectors(r[g],s[g])}return{tangents:r,normals:s,binormals:o}}clone(){return new this.constructor().copy(this)}copy(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}toJSON(){let t={metadata:{version:4.5,type:"Curve",generator:"Curve.toJSON"}};return t.arcLengthDivisions=this.arcLengthDivisions,t.type=this.type,t}fromJSON(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}},Jr=class extends Fe{constructor(t=0,e=0,i=1,r=1,s=0,o=Math.PI*2,a=!1,l=0){super(),this.type="EllipseCurve",this.aX=t,this.aY=e,this.xRadius=i,this.yRadius=r,this.aStartAngle=s,this.aEndAngle=o,this.aClockwise=a,this.aRotation=l}getPoint(t,e){let i=e||new K,r=Math.PI*2,s=this.aEndAngle-this.aStartAngle,o=Math.abs(s)<Number.EPSILON;for(;s<0;)s+=r;for(;s>r;)s-=r;s<Number.EPSILON&&(o?s=0:s=r),this.aClockwise===!0&&!o&&(s===r?s=-r:s=s-r);let a=this.aStartAngle+t*s,l=this.aX+this.xRadius*Math.cos(a),c=this.aY+this.yRadius*Math.sin(a);if(this.aRotation!==0){let u=Math.cos(this.aRotation),h=Math.sin(this.aRotation),f=l-this.aX,d=c-this.aY;l=f*u-d*h+this.aX,c=f*h+d*u+this.aY}return i.set(l,c)}copy(t){return super.copy(t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this}toJSON(){let t=super.toJSON();return t.aX=this.aX,t.aY=this.aY,t.xRadius=this.xRadius,t.yRadius=this.yRadius,t.aStartAngle=this.aStartAngle,t.aEndAngle=this.aEndAngle,t.aClockwise=this.aClockwise,t.aRotation=this.aRotation,t}fromJSON(t){return super.fromJSON(t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this}};Jr.prototype.isEllipseCurve=!0;var ml=class extends Jr{constructor(t,e,i,r,s,o){super(t,e,i,i,r,s,o),this.type="ArcCurve"}};ml.prototype.isArcCurve=!0;function tf(){let n=0,t=0,e=0,i=0;function r(s,o,a,l){n=s,t=a,e=-3*s+3*o-2*a-l,i=2*s-2*o+a+l}return{initCatmullRom:function(s,o,a,l,c){r(o,a,c*(a-s),c*(l-o))},initNonuniformCatmullRom:function(s,o,a,l,c,u,h){let f=(o-s)/c-(a-s)/(c+u)+(a-o)/u,d=(a-o)/u-(l-o)/(u+h)+(l-a)/h;f*=u,d*=u,r(o,a,f,d)},calc:function(s){let o=s*s,a=o*s;return n+t*s+e*o+i*a}}}var Xa=new T,Pu=new tf,Du=new tf,Iu=new tf,gl=class extends Fe{constructor(t=[],e=!1,i="centripetal",r=.5){super(),this.type="CatmullRomCurve3",this.points=t,this.closed=e,this.curveType=i,this.tension=r}getPoint(t,e=new T){let i=e,r=this.points,s=r.length,o=(s-(this.closed?0:1))*t,a=Math.floor(o),l=o-a;this.closed?a+=a>0?0:(Math.floor(Math.abs(a)/s)+1)*s:l===0&&a===s-1&&(a=s-2,l=1);let c,u;this.closed||a>0?c=r[(a-1)%s]:(Xa.subVectors(r[0],r[1]).add(r[0]),c=Xa);let h=r[a%s],f=r[(a+1)%s];if(this.closed||a+2<s?u=r[(a+2)%s]:(Xa.subVectors(r[s-1],r[s-2]).add(r[s-1]),u=Xa),this.curveType==="centripetal"||this.curveType==="chordal"){let d=this.curveType==="chordal"?.5:.25,g=Math.pow(c.distanceToSquared(h),d),x=Math.pow(h.distanceToSquared(f),d),v=Math.pow(f.distanceToSquared(u),d);x<1e-4&&(x=1),g<1e-4&&(g=x),v<1e-4&&(v=x),Pu.initNonuniformCatmullRom(c.x,h.x,f.x,u.x,g,x,v),Du.initNonuniformCatmullRom(c.y,h.y,f.y,u.y,g,x,v),Iu.initNonuniformCatmullRom(c.z,h.z,f.z,u.z,g,x,v)}else this.curveType==="catmullrom"&&(Pu.initCatmullRom(c.x,h.x,f.x,u.x,this.tension),Du.initCatmullRom(c.y,h.y,f.y,u.y,this.tension),Iu.initCatmullRom(c.z,h.z,f.z,u.z,this.tension));return i.set(Pu.calc(l),Du.calc(l),Iu.calc(l)),i}copy(t){super.copy(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++){let r=t.points[e];this.points.push(r.clone())}return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this}toJSON(){let t=super.toJSON();t.points=[];for(let e=0,i=this.points.length;e<i;e++){let r=this.points[e];t.points.push(r.toArray())}return t.closed=this.closed,t.curveType=this.curveType,t.tension=this.tension,t}fromJSON(t){super.fromJSON(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++){let r=t.points[e];this.points.push(new T().fromArray(r))}return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this}};gl.prototype.isCatmullRomCurve3=!0;function Qg(n,t,e,i,r){let s=(i-t)*.5,o=(r-e)*.5,a=n*n,l=n*a;return(2*e-2*i+s+o)*l+(-3*e+3*i-2*s-o)*a+s*n+e}function FE(n,t){let e=1-n;return e*e*t}function zE(n,t){return 2*(1-n)*n*t}function UE(n,t){return n*n*t}function js(n,t,e,i){return FE(n,t)+zE(n,e)+UE(n,i)}function BE(n,t){let e=1-n;return e*e*e*t}function OE(n,t){let e=1-n;return 3*e*e*n*t}function kE(n,t){return 3*(1-n)*n*n*t}function HE(n,t){return n*n*n*t}function to(n,t,e,i,r){return BE(n,t)+OE(n,e)+kE(n,i)+HE(n,r)}var xo=class extends Fe{constructor(t=new K,e=new K,i=new K,r=new K){super(),this.type="CubicBezierCurve",this.v0=t,this.v1=e,this.v2=i,this.v3=r}getPoint(t,e=new K){let i=e,r=this.v0,s=this.v1,o=this.v2,a=this.v3;return i.set(to(t,r.x,s.x,o.x,a.x),to(t,r.y,s.y,o.y,a.y)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this}};xo.prototype.isCubicBezierCurve=!0;var xl=class extends Fe{constructor(t=new T,e=new T,i=new T,r=new T){super(),this.type="CubicBezierCurve3",this.v0=t,this.v1=e,this.v2=i,this.v3=r}getPoint(t,e=new T){let i=e,r=this.v0,s=this.v1,o=this.v2,a=this.v3;return i.set(to(t,r.x,s.x,o.x,a.x),to(t,r.y,s.y,o.y,a.y),to(t,r.z,s.z,o.z,a.z)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this}};xl.prototype.isCubicBezierCurve3=!0;var $r=class extends Fe{constructor(t=new K,e=new K){super(),this.type="LineCurve",this.v1=t,this.v2=e}getPoint(t,e=new K){let i=e;return t===1?i.copy(this.v2):(i.copy(this.v2).sub(this.v1),i.multiplyScalar(t).add(this.v1)),i}getPointAt(t,e){return this.getPoint(t,e)}getTangent(t,e){let i=e||new K;return i.copy(this.v2).sub(this.v1).normalize(),i}copy(t){return super.copy(t),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};$r.prototype.isLineCurve=!0;var ah=class extends Fe{constructor(t=new T,e=new T){super(),this.type="LineCurve3",this.isLineCurve3=!0,this.v1=t,this.v2=e}getPoint(t,e=new T){let i=e;return t===1?i.copy(this.v2):(i.copy(this.v2).sub(this.v1),i.multiplyScalar(t).add(this.v1)),i}getPointAt(t,e){return this.getPoint(t,e)}copy(t){return super.copy(t),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}},yo=class extends Fe{constructor(t=new K,e=new K,i=new K){super(),this.type="QuadraticBezierCurve",this.v0=t,this.v1=e,this.v2=i}getPoint(t,e=new K){let i=e,r=this.v0,s=this.v1,o=this.v2;return i.set(js(t,r.x,s.x,o.x),js(t,r.y,s.y,o.y)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};yo.prototype.isQuadraticBezierCurve=!0;var yl=class extends Fe{constructor(t=new T,e=new T,i=new T){super(),this.type="QuadraticBezierCurve3",this.v0=t,this.v1=e,this.v2=i}getPoint(t,e=new T){let i=e,r=this.v0,s=this.v1,o=this.v2;return i.set(js(t,r.x,s.x,o.x),js(t,r.y,s.y,o.y),js(t,r.z,s.z,o.z)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};yl.prototype.isQuadraticBezierCurve3=!0;var vo=class extends Fe{constructor(t=[]){super(),this.type="SplineCurve",this.points=t}getPoint(t,e=new K){let i=e,r=this.points,s=(r.length-1)*t,o=Math.floor(s),a=s-o,l=r[o===0?o:o-1],c=r[o],u=r[o>r.length-2?r.length-1:o+1],h=r[o>r.length-3?r.length-1:o+2];return i.set(Qg(a,l.x,c.x,u.x,h.x),Qg(a,l.y,c.y,u.y,h.y)),i}copy(t){super.copy(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++){let r=t.points[e];this.points.push(r.clone())}return this}toJSON(){let t=super.toJSON();t.points=[];for(let e=0,i=this.points.length;e<i;e++){let r=this.points[e];t.points.push(r.toArray())}return t}fromJSON(t){super.fromJSON(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++){let r=t.points[e];this.points.push(new K().fromArray(r))}return this}};vo.prototype.isSplineCurve=!0;var C0=Object.freeze({__proto__:null,ArcCurve:ml,CatmullRomCurve3:gl,CubicBezierCurve:xo,CubicBezierCurve3:xl,EllipseCurve:Jr,LineCurve:$r,LineCurve3:ah,QuadraticBezierCurve:yo,QuadraticBezierCurve3:yl,SplineCurve:vo}),lh=class extends Fe{constructor(){super(),this.type="CurvePath",this.curves=[],this.autoClose=!1}add(t){this.curves.push(t)}closePath(){let t=this.curves[0].getPoint(0),e=this.curves[this.curves.length-1].getPoint(1);t.equals(e)||this.curves.push(new $r(e,t))}getPoint(t,e){let i=t*this.getLength(),r=this.getCurveLengths(),s=0;for(;s<r.length;){if(r[s]>=i){let o=r[s]-i,a=this.curves[s],l=a.getLength(),c=l===0?0:1-o/l;return a.getPointAt(c,e)}s++}return null}getLength(){let t=this.getCurveLengths();return t[t.length-1]}updateArcLengths(){this.needsUpdate=!0,this.cacheLengths=null,this.getCurveLengths()}getCurveLengths(){if(this.cacheLengths&&this.cacheLengths.length===this.curves.length)return this.cacheLengths;let t=[],e=0;for(let i=0,r=this.curves.length;i<r;i++)e+=this.curves[i].getLength(),t.push(e);return this.cacheLengths=t,t}getSpacedPoints(t=40){let e=[];for(let i=0;i<=t;i++)e.push(this.getPoint(i/t));return this.autoClose&&e.push(e[0]),e}getPoints(t=12){let e=[],i;for(let r=0,s=this.curves;r<s.length;r++){let o=s[r],a=o&&o.isEllipseCurve?t*2:o&&(o.isLineCurve||o.isLineCurve3)?1:o&&o.isSplineCurve?t*o.points.length:t,l=o.getPoints(a);for(let c=0;c<l.length;c++){let u=l[c];i&&i.equals(u)||(e.push(u),i=u)}}return this.autoClose&&e.length>1&&!e[e.length-1].equals(e[0])&&e.push(e[0]),e}copy(t){super.copy(t),this.curves=[];for(let e=0,i=t.curves.length;e<i;e++){let r=t.curves[e];this.curves.push(r.clone())}return this.autoClose=t.autoClose,this}toJSON(){let t=super.toJSON();t.autoClose=this.autoClose,t.curves=[];for(let e=0,i=this.curves.length;e<i;e++){let r=this.curves[e];t.curves.push(r.toJSON())}return t}fromJSON(t){super.fromJSON(t),this.autoClose=t.autoClose,this.curves=[];for(let e=0,i=t.curves.length;e<i;e++){let r=t.curves[e];this.curves.push(new C0[r.type]().fromJSON(r))}return this}},_o=class extends lh{constructor(t){super(),this.type="Path",this.currentPoint=new K,t&&this.setFromPoints(t)}setFromPoints(t){this.moveTo(t[0].x,t[0].y);for(let e=1,i=t.length;e<i;e++)this.lineTo(t[e].x,t[e].y);return this}moveTo(t,e){return this.currentPoint.set(t,e),this}lineTo(t,e){let i=new $r(this.currentPoint.clone(),new K(t,e));return this.curves.push(i),this.currentPoint.set(t,e),this}quadraticCurveTo(t,e,i,r){let s=new yo(this.currentPoint.clone(),new K(t,e),new K(i,r));return this.curves.push(s),this.currentPoint.set(i,r),this}bezierCurveTo(t,e,i,r,s,o){let a=new xo(this.currentPoint.clone(),new K(t,e),new K(i,r),new K(s,o));return this.curves.push(a),this.currentPoint.set(s,o),this}splineThru(t){let e=[this.currentPoint.clone()].concat(t),i=new vo(e);return this.curves.push(i),this.currentPoint.copy(t[t.length-1]),this}arc(t,e,i,r,s,o){let a=this.currentPoint.x,l=this.currentPoint.y;return this.absarc(t+a,e+l,i,r,s,o),this}absarc(t,e,i,r,s,o){return this.absellipse(t,e,i,i,r,s,o),this}ellipse(t,e,i,r,s,o,a,l){let c=this.currentPoint.x,u=this.currentPoint.y;return this.absellipse(t+c,e+u,i,r,s,o,a,l),this}absellipse(t,e,i,r,s,o,a,l){let c=new Jr(t,e,i,r,s,o,a,l);if(this.curves.length>0){let h=c.getPoint(0);h.equals(this.currentPoint)||this.lineTo(h.x,h.y)}this.curves.push(c);let u=c.getPoint(1);return this.currentPoint.copy(u),this}copy(t){return super.copy(t),this.currentPoint.copy(t.currentPoint),this}toJSON(){let t=super.toJSON();return t.currentPoint=this.currentPoint.toArray(),t}fromJSON(t){return super.fromJSON(t),this.currentPoint.fromArray(t.currentPoint),this}},Un=class extends _o{constructor(t){super(t),this.uuid=tn(),this.type="Shape",this.holes=[]}getPointsHoles(t){let e=[];for(let i=0,r=this.holes.length;i<r;i++)e[i]=this.holes[i].getPoints(t);return e}extractPoints(t){return{shape:this.getPoints(t),holes:this.getPointsHoles(t)}}copy(t){super.copy(t),this.holes=[];for(let e=0,i=t.holes.length;e<i;e++){let r=t.holes[e];this.holes.push(r.clone())}return this}toJSON(){let t=super.toJSON();t.uuid=this.uuid,t.holes=[];for(let e=0,i=this.holes.length;e<i;e++){let r=this.holes[e];t.holes.push(r.toJSON())}return t}fromJSON(t){super.fromJSON(t),this.uuid=t.uuid,this.holes=[];for(let e=0,i=t.holes.length;e<i;e++){let r=t.holes[e];this.holes.push(new _o().fromJSON(r))}return this}},VE={triangulate:function(n,t,e=2){let i=t&&t.length,r=i?t[0]*e:n.length,s=R0(n,0,r,e,!0),o=[];if(!s||s.next===s.prev)return o;let a,l,c,u,h,f,d;if(i&&(s=YE(n,t,s,e)),n.length>80*e){a=c=n[0],l=u=n[1];for(let g=e;g<r;g+=e)h=n[g],f=n[g+1],h<a&&(a=h),f<l&&(l=f),h>c&&(c=h),f>u&&(u=f);d=Math.max(c-a,u-l),d=d!==0?1/d:0}return wo(s,o,e,a,l,d),o}};function R0(n,t,e,i,r){let s,o;if(r===rT(n,t,e,i)>0)for(s=t;s<e;s+=i)o=jg(s,n[s],n[s+1],o);else for(s=e-i;s>=t;s-=i)o=jg(s,n[s],n[s+1],o);return o&&Dl(o,o.next)&&(bo(o),o=o.next),o}function li(n,t){if(!n)return n;t||(t=n);let e=n,i;do if(i=!1,!e.steiner&&(Dl(e,e.next)||te(e.prev,e,e.next)===0)){if(bo(e),e=t=e.prev,e===e.next)break;i=!0}else e=e.next;while(i||e!==t);return t}function wo(n,t,e,i,r,s,o){if(!n)return;!o&&s&&QE(n,i,r,s);let a=n,l,c;for(;n.prev!==n.next;){if(l=n.prev,c=n.next,s?WE(n,i,r,s):GE(n)){t.push(l.i/e),t.push(n.i/e),t.push(c.i/e),bo(n),n=c.next,a=c.next;continue}if(n=c,n===a){o?o===1?(n=qE(li(n),t,e),wo(n,t,e,i,r,s,2)):o===2&&XE(n,t,e,i,r,s):wo(li(n),t,e,i,r,s,1);break}}}function GE(n){let t=n.prev,e=n,i=n.next;if(te(t,e,i)>=0)return!1;let r=n.next.next;for(;r!==n.prev;){if(zr(t.x,t.y,e.x,e.y,i.x,i.y,r.x,r.y)&&te(r.prev,r,r.next)>=0)return!1;r=r.next}return!0}function WE(n,t,e,i){let r=n.prev,s=n,o=n.next;if(te(r,s,o)>=0)return!1;let a=r.x<s.x?r.x<o.x?r.x:o.x:s.x<o.x?s.x:o.x,l=r.y<s.y?r.y<o.y?r.y:o.y:s.y<o.y?s.y:o.y,c=r.x>s.x?r.x>o.x?r.x:o.x:s.x>o.x?s.x:o.x,u=r.y>s.y?r.y>o.y?r.y:o.y:s.y>o.y?s.y:o.y,h=ch(a,l,t,e,i),f=ch(c,u,t,e,i),d=n.prevZ,g=n.nextZ;for(;d&&d.z>=h&&g&&g.z<=f;){if(d!==n.prev&&d!==n.next&&zr(r.x,r.y,s.x,s.y,o.x,o.y,d.x,d.y)&&te(d.prev,d,d.next)>=0||(d=d.prevZ,g!==n.prev&&g!==n.next&&zr(r.x,r.y,s.x,s.y,o.x,o.y,g.x,g.y)&&te(g.prev,g,g.next)>=0))return!1;g=g.nextZ}for(;d&&d.z>=h;){if(d!==n.prev&&d!==n.next&&zr(r.x,r.y,s.x,s.y,o.x,o.y,d.x,d.y)&&te(d.prev,d,d.next)>=0)return!1;d=d.prevZ}for(;g&&g.z<=f;){if(g!==n.prev&&g!==n.next&&zr(r.x,r.y,s.x,s.y,o.x,o.y,g.x,g.y)&&te(g.prev,g,g.next)>=0)return!1;g=g.nextZ}return!0}function qE(n,t,e){let i=n;do{let r=i.prev,s=i.next.next;!Dl(r,s)&&L0(r,i,i.next,s)&&Mo(r,s)&&Mo(s,r)&&(t.push(r.i/e),t.push(i.i/e),t.push(s.i/e),bo(i),bo(i.next),i=n=s),i=i.next}while(i!==n);return li(i)}function XE(n,t,e,i,r,s){let o=n;do{let a=o.next.next;for(;a!==o.prev;){if(o.i!==a.i&&eT(o,a)){let l=P0(o,a);o=li(o,o.next),l=li(l,l.next),wo(o,t,e,i,r,s),wo(l,t,e,i,r,s);return}a=a.next}o=o.next}while(o!==n)}function YE(n,t,e,i){let r=[],s,o,a,l,c;for(s=0,o=t.length;s<o;s++)a=t[s]*i,l=s<o-1?t[s+1]*i:n.length,c=R0(n,a,l,i,!1),c===c.next&&(c.steiner=!0),r.push(tT(c));for(r.sort(ZE),s=0;s<r.length;s++)JE(r[s],e),e=li(e,e.next);return e}function ZE(n,t){return n.x-t.x}function JE(n,t){if(t=$E(n,t),t){let e=P0(t,n);li(t,t.next),li(e,e.next)}}function $E(n,t){let e=t,i=n.x,r=n.y,s=-1/0,o;do{if(r<=e.y&&r>=e.next.y&&e.next.y!==e.y){let f=e.x+(r-e.y)*(e.next.x-e.x)/(e.next.y-e.y);if(f<=i&&f>s){if(s=f,f===i){if(r===e.y)return e;if(r===e.next.y)return e.next}o=e.x<e.next.x?e:e.next}}e=e.next}while(e!==t);if(!o)return null;if(i===s)return o;let a=o,l=o.x,c=o.y,u=1/0,h;e=o;do i>=e.x&&e.x>=l&&i!==e.x&&zr(r<c?i:s,r,l,c,r<c?s:i,r,e.x,e.y)&&(h=Math.abs(r-e.y)/(i-e.x),Mo(e,n)&&(h<u||h===u&&(e.x>o.x||e.x===o.x&&KE(o,e)))&&(o=e,u=h)),e=e.next;while(e!==a);return o}function KE(n,t){return te(n.prev,n,t.prev)<0&&te(t.next,n,n.next)<0}function QE(n,t,e,i){let r=n;do r.z===null&&(r.z=ch(r.x,r.y,t,e,i)),r.prevZ=r.prev,r.nextZ=r.next,r=r.next;while(r!==n);r.prevZ.nextZ=null,r.prevZ=null,jE(r)}function jE(n){let t,e,i,r,s,o,a,l,c=1;do{for(e=n,n=null,s=null,o=0;e;){for(o++,i=e,a=0,t=0;t<c&&(a++,i=i.nextZ,!!i);t++);for(l=c;a>0||l>0&&i;)a!==0&&(l===0||!i||e.z<=i.z)?(r=e,e=e.nextZ,a--):(r=i,i=i.nextZ,l--),s?s.nextZ=r:n=r,r.prevZ=s,s=r;e=i}s.nextZ=null,c*=2}while(o>1);return n}function ch(n,t,e,i,r){return n=32767*(n-e)*r,t=32767*(t-i)*r,n=(n|n<<8)&16711935,n=(n|n<<4)&252645135,n=(n|n<<2)&858993459,n=(n|n<<1)&1431655765,t=(t|t<<8)&16711935,t=(t|t<<4)&252645135,t=(t|t<<2)&858993459,t=(t|t<<1)&1431655765,n|t<<1}function tT(n){let t=n,e=n;do(t.x<e.x||t.x===e.x&&t.y<e.y)&&(e=t),t=t.next;while(t!==n);return e}function zr(n,t,e,i,r,s,o,a){return(r-o)*(t-a)-(n-o)*(s-a)>=0&&(n-o)*(i-a)-(e-o)*(t-a)>=0&&(e-o)*(s-a)-(r-o)*(i-a)>=0}function eT(n,t){return n.next.i!==t.i&&n.prev.i!==t.i&&!nT(n,t)&&(Mo(n,t)&&Mo(t,n)&&iT(n,t)&&(te(n.prev,n,t.prev)||te(n,t.prev,t))||Dl(n,t)&&te(n.prev,n,n.next)>0&&te(t.prev,t,t.next)>0)}function te(n,t,e){return(t.y-n.y)*(e.x-t.x)-(t.x-n.x)*(e.y-t.y)}function Dl(n,t){return n.x===t.x&&n.y===t.y}function L0(n,t,e,i){let r=Za(te(n,t,e)),s=Za(te(n,t,i)),o=Za(te(e,i,n)),a=Za(te(e,i,t));return!!(r!==s&&o!==a||r===0&&Ya(n,e,t)||s===0&&Ya(n,i,t)||o===0&&Ya(e,n,i)||a===0&&Ya(e,t,i))}function Ya(n,t,e){return t.x<=Math.max(n.x,e.x)&&t.x>=Math.min(n.x,e.x)&&t.y<=Math.max(n.y,e.y)&&t.y>=Math.min(n.y,e.y)}function Za(n){return n>0?1:n<0?-1:0}function nT(n,t){let e=n;do{if(e.i!==n.i&&e.next.i!==n.i&&e.i!==t.i&&e.next.i!==t.i&&L0(e,e.next,n,t))return!0;e=e.next}while(e!==n);return!1}function Mo(n,t){return te(n.prev,n,n.next)<0?te(n,t,n.next)>=0&&te(n,n.prev,t)>=0:te(n,t,n.prev)<0||te(n,n.next,t)<0}function iT(n,t){let e=n,i=!1,r=(n.x+t.x)/2,s=(n.y+t.y)/2;do e.y>s!=e.next.y>s&&e.next.y!==e.y&&r<(e.next.x-e.x)*(s-e.y)/(e.next.y-e.y)+e.x&&(i=!i),e=e.next;while(e!==n);return i}function P0(n,t){let e=new uh(n.i,n.x,n.y),i=new uh(t.i,t.x,t.y),r=n.next,s=t.prev;return n.next=t,t.prev=n,e.next=r,r.prev=e,i.next=e,e.prev=i,s.next=i,i.prev=s,i}function jg(n,t,e,i){let r=new uh(n,t,e);return i?(r.next=i.next,r.prev=i,i.next.prev=r,i.next=r):(r.prev=r,r.next=r),r}function bo(n){n.next.prev=n.prev,n.prev.next=n.next,n.prevZ&&(n.prevZ.nextZ=n.nextZ),n.nextZ&&(n.nextZ.prevZ=n.prevZ)}function uh(n,t,e){this.i=n,this.x=t,this.y=e,this.prev=null,this.next=null,this.z=null,this.prevZ=null,this.nextZ=null,this.steiner=!1}function rT(n,t,e,i){let r=0;for(let s=t,o=e-i;s<e;s+=i)r+=(n[o]-n[s])*(n[s+1]+n[o+1]),o=s;return r}var dn=class{static area(t){let e=t.length,i=0;for(let r=e-1,s=0;s<e;r=s++)i+=t[r].x*t[s].y-t[s].x*t[r].y;return i*.5}static isClockWise(t){return dn.area(t)<0}static triangulateShape(t,e){let i=[],r=[],s=[];t0(t),e0(i,t);let o=t.length;e.forEach(t0);for(let l=0;l<e.length;l++)r.push(o),o+=e[l].length,e0(i,e[l]);let a=VE.triangulate(i,r);for(let l=0;l<a.length;l+=3)s.push(a.slice(l,l+3));return s}};function t0(n){let t=n.length;t>2&&n[t-1].equals(n[0])&&n.pop()}function e0(n,t){for(let e=0;e<t.length;e++)n.push(t[e].x),n.push(t[e].y)}var ci=class extends Ht{constructor(t=new Un([new K(.5,.5),new K(-.5,.5),new K(-.5,-.5),new K(.5,-.5)]),e={}){super(),this.type="ExtrudeGeometry",this.parameters={shapes:t,options:e},t=Array.isArray(t)?t:[t];let i=this,r=[],s=[];for(let a=0,l=t.length;a<l;a++){let c=t[a];o(c)}this.setAttribute("position",new ee(r,3)),this.setAttribute("uv",new ee(s,2)),this.computeVertexNormals();function o(a){let l=[],c=e.curveSegments!==void 0?e.curveSegments:12,u=e.steps!==void 0?e.steps:1,h=e.depth!==void 0?e.depth:1,f=e.bevelEnabled!==void 0?e.bevelEnabled:!0,d=e.bevelThickness!==void 0?e.bevelThickness:.2,g=e.bevelSize!==void 0?e.bevelSize:d-.1,x=e.bevelOffset!==void 0?e.bevelOffset:0,v=e.bevelSegments!==void 0?e.bevelSegments:3,m=e.extrudePath,p=e.UVGenerator!==void 0?e.UVGenerator:sT;e.amount!==void 0&&(console.warn("THREE.ExtrudeBufferGeometry: amount has been renamed to depth."),h=e.amount);let b,_=!1,S,L,A,H;m&&(b=m.getSpacedPoints(u),_=!0,f=!1,S=m.computeFrenetFrames(u,!1),L=new T,A=new T,H=new T),f||(v=0,d=0,g=0,x=0);let tt=a.extractPoints(c),X=tt.shape,y=tt.holes;if(!dn.isClockWise(X)){X=X.reverse();for(let C=0,j=y.length;C<j;C++){let J=y[C];dn.isClockWise(J)&&(y[C]=J.reverse())}}let D=dn.triangulateShape(X,y),F=X;for(let C=0,j=y.length;C<j;C++){let J=y[C];X=X.concat(J)}function z(C,j,J){return j||console.error("THREE.ExtrudeGeometry: vec does not exist"),j.clone().multiplyScalar(J).add(C)}let N=X.length,V=D.length;function Q(C,j,J){let it,et,vt,bt=C.x-j.x,It=C.y-j.y,Zt=J.x-C.x,qt=J.y-C.y,E=bt*bt+It*It,w=bt*qt-It*Zt;if(Math.abs(w)>Number.EPSILON){let q=Math.sqrt(E),rt=Math.sqrt(Zt*Zt+qt*qt),gt=j.x-It/q,W=j.y+bt/q,_t=J.x-qt/rt,yt=J.y+Zt/rt,ut=((_t-gt)*qt-(yt-W)*Zt)/(bt*qt-It*Zt);it=gt+bt*ut-C.x,et=W+It*ut-C.y;let ct=it*it+et*et;if(ct<=2)return new K(it,et);vt=Math.sqrt(ct/2)}else{let q=!1;bt>Number.EPSILON?Zt>Number.EPSILON&&(q=!0):bt<-Number.EPSILON?Zt<-Number.EPSILON&&(q=!0):Math.sign(It)===Math.sign(qt)&&(q=!0),q?(it=-It,et=bt,vt=Math.sqrt(E)):(it=bt,et=It,vt=Math.sqrt(E/2))}return new K(it/vt,et/vt)}let at=[];for(let C=0,j=F.length,J=j-1,it=C+1;C<j;C++,J++,it++)J===j&&(J=0),it===j&&(it=0),at[C]=Q(F[C],F[J],F[it]);let G=[],$,lt=at.concat();for(let C=0,j=y.length;C<j;C++){let J=y[C];$=[];for(let it=0,et=J.length,vt=et-1,bt=it+1;it<et;it++,vt++,bt++)vt===et&&(vt=0),bt===et&&(bt=0),$[it]=Q(J[it],J[vt],J[bt]);G.push($),lt=lt.concat($)}for(let C=0;C<v;C++){let j=C/v,J=d*Math.cos(j*Math.PI/2),it=g*Math.sin(j*Math.PI/2)+x;for(let et=0,vt=F.length;et<vt;et++){let bt=z(F[et],at[et],it);mt(bt.x,bt.y,-J)}for(let et=0,vt=y.length;et<vt;et++){let bt=y[et];$=G[et];for(let It=0,Zt=bt.length;It<Zt;It++){let qt=z(bt[It],$[It],it);mt(qt.x,qt.y,-J)}}}let dt=g+x;for(let C=0;C<N;C++){let j=f?z(X[C],lt[C],dt):X[C];_?(A.copy(S.normals[0]).multiplyScalar(j.x),L.copy(S.binormals[0]).multiplyScalar(j.y),H.copy(b[0]).add(A).add(L),mt(H.x,H.y,H.z)):mt(j.x,j.y,0)}for(let C=1;C<=u;C++)for(let j=0;j<N;j++){let J=f?z(X[j],lt[j],dt):X[j];_?(A.copy(S.normals[C]).multiplyScalar(J.x),L.copy(S.binormals[C]).multiplyScalar(J.y),H.copy(b[C]).add(A).add(L),mt(H.x,H.y,H.z)):mt(J.x,J.y,h/u*C)}for(let C=v-1;C>=0;C--){let j=C/v,J=d*Math.cos(j*Math.PI/2),it=g*Math.sin(j*Math.PI/2)+x;for(let et=0,vt=F.length;et<vt;et++){let bt=z(F[et],at[et],it);mt(bt.x,bt.y,h+J)}for(let et=0,vt=y.length;et<vt;et++){let bt=y[et];$=G[et];for(let It=0,Zt=bt.length;It<Zt;It++){let qt=z(bt[It],$[It],it);_?mt(qt.x,qt.y+b[u-1].y,b[u-1].x+J):mt(qt.x,qt.y,h+J)}}}xt(),k();function xt(){let C=r.length/3;if(f){let j=0,J=N*j;for(let it=0;it<V;it++){let et=D[it];St(et[2]+J,et[1]+J,et[0]+J)}j=u+v*2,J=N*j;for(let it=0;it<V;it++){let et=D[it];St(et[0]+J,et[1]+J,et[2]+J)}}else{for(let j=0;j<V;j++){let J=D[j];St(J[2],J[1],J[0])}for(let j=0;j<V;j++){let J=D[j];St(J[0]+N*u,J[1]+N*u,J[2]+N*u)}}i.addGroup(C,r.length/3-C,0)}function k(){let C=r.length/3,j=0;Ft(F,j),j+=F.length;for(let J=0,it=y.length;J<it;J++){let et=y[J];Ft(et,j),j+=et.length}i.addGroup(C,r.length/3-C,1)}function Ft(C,j){let J=C.length;for(;--J>=0;){let it=J,et=J-1;et<0&&(et=C.length-1);for(let vt=0,bt=u+v*2;vt<bt;vt++){let It=N*vt,Zt=N*(vt+1),qt=j+it+It,E=j+et+It,w=j+et+Zt,q=j+it+Zt;B(qt,E,w,q)}}}function mt(C,j,J){l.push(C),l.push(j),l.push(J)}function St(C,j,J){st(C),st(j),st(J);let it=r.length/3,et=p.generateTopUV(i,r,it-3,it-2,it-1);nt(et[0]),nt(et[1]),nt(et[2])}function B(C,j,J,it){st(C),st(j),st(it),st(j),st(J),st(it);let et=r.length/3,vt=p.generateSideWallUV(i,r,et-6,et-3,et-2,et-1);nt(vt[0]),nt(vt[1]),nt(vt[3]),nt(vt[1]),nt(vt[2]),nt(vt[3])}function st(C){r.push(l[C*3+0]),r.push(l[C*3+1]),r.push(l[C*3+2])}function nt(C){s.push(C.x),s.push(C.y)}}}toJSON(){let t=super.toJSON(),e=this.parameters.shapes,i=this.parameters.options;return oT(e,i,t)}static fromJSON(t,e){let i=[];for(let s=0,o=t.shapes.length;s<o;s++){let a=e[t.shapes[s]];i.push(a)}let r=t.options.extrudePath;return r!==void 0&&(t.options.extrudePath=new C0[r.type]().fromJSON(r)),new ci(i,t.options)}},sT={generateTopUV:function(n,t,e,i,r){let s=t[e*3],o=t[e*3+1],a=t[i*3],l=t[i*3+1],c=t[r*3],u=t[r*3+1];return[new K(s,o),new K(a,l),new K(c,u)]},generateSideWallUV:function(n,t,e,i,r,s){let o=t[e*3],a=t[e*3+1],l=t[e*3+2],c=t[i*3],u=t[i*3+1],h=t[i*3+2],f=t[r*3],d=t[r*3+1],g=t[r*3+2],x=t[s*3],v=t[s*3+1],m=t[s*3+2];return Math.abs(a-u)<Math.abs(o-c)?[new K(o,1-l),new K(c,1-h),new K(f,1-g),new K(x,1-m)]:[new K(a,1-l),new K(u,1-h),new K(d,1-g),new K(v,1-m)]}};function oT(n,t,e){if(e.shapes=[],Array.isArray(n))for(let i=0,r=n.length;i<r;i++){let s=n[i];e.shapes.push(s.uuid)}else e.shapes.push(n.uuid);return t.extrudePath!==void 0&&(e.options.extrudePath=t.extrudePath.toJSON()),e}var qi=class extends Ht{constructor(t=new Un([new K(0,.5),new K(-.5,-.5),new K(.5,-.5)]),e=12){super(),this.type="ShapeGeometry",this.parameters={shapes:t,curveSegments:e};let i=[],r=[],s=[],o=[],a=0,l=0;if(Array.isArray(t)===!1)c(t);else for(let u=0;u<t.length;u++)c(t[u]),this.addGroup(a,l,u),a+=l,l=0;this.setIndex(i),this.setAttribute("position",new ee(r,3)),this.setAttribute("normal",new ee(s,3)),this.setAttribute("uv",new ee(o,2));function c(u){let h=r.length/3,f=u.extractPoints(e),d=f.shape,g=f.holes;dn.isClockWise(d)===!1&&(d=d.reverse());for(let v=0,m=g.length;v<m;v++){let p=g[v];dn.isClockWise(p)===!0&&(g[v]=p.reverse())}let x=dn.triangulateShape(d,g);for(let v=0,m=g.length;v<m;v++){let p=g[v];d=d.concat(p)}for(let v=0,m=d.length;v<m;v++){let p=d[v];r.push(p.x,p.y,0),s.push(0,0,1),o.push(p.x,p.y)}for(let v=0,m=x.length;v<m;v++){let p=x[v],b=p[0]+h,_=p[1]+h,S=p[2]+h;i.push(b,_,S),l+=3}}}toJSON(){let t=super.toJSON(),e=this.parameters.shapes;return aT(e,t)}static fromJSON(t,e){let i=[];for(let r=0,s=t.shapes.length;r<s;r++){let o=e[t.shapes[r]];i.push(o)}return new qi(i,t.curveSegments)}};function aT(n,t){if(t.shapes=[],Array.isArray(n))for(let e=0,i=n.length;e<i;e++){let r=n[e];t.shapes.push(r.uuid)}else t.shapes.push(n.uuid);return t}var hh=class extends xe{constructor(t){super(),this.type="ShadowMaterial",this.color=new ft(0),this.transparent=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this}};hh.prototype.isShadowMaterial=!0;var vl=class extends xe{constructor(t){super(),this.defines={STANDARD:""},this.type="MeshStandardMaterial",this.color=new ft(16777215),this.roughness=1,this.metalness=0,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ft(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ts,this.normalScale=new K(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.roughnessMap=null,this.metalnessMap=null,this.alphaMap=null,this.envMap=null,this.envMapIntensity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.defines={STANDARD:""},this.color.copy(t.color),this.roughness=t.roughness,this.metalness=t.metalness,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.roughnessMap=t.roughnessMap,this.metalnessMap=t.metalnessMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.envMapIntensity=t.envMapIntensity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this}};vl.prototype.isMeshStandardMaterial=!0;var fh=class extends vl{constructor(t){super(),this.defines={STANDARD:"",PHYSICAL:""},this.type="MeshPhysicalMaterial",this.clearcoatMap=null,this.clearcoatRoughness=0,this.clearcoatRoughnessMap=null,this.clearcoatNormalScale=new K(1,1),this.clearcoatNormalMap=null,this.ior=1.5,Object.defineProperty(this,"reflectivity",{get:function(){return Ie(2.5*(this.ior-1)/(this.ior+1),0,1)},set:function(e){this.ior=(1+.4*e)/(1-.4*e)}}),this.sheenColor=new ft(0),this.sheenColorMap=null,this.sheenRoughness=1,this.sheenRoughnessMap=null,this.transmissionMap=null,this.thickness=0,this.thicknessMap=null,this.attenuationDistance=0,this.attenuationColor=new ft(1,1,1),this.specularIntensity=1,this.specularIntensityMap=null,this.specularColor=new ft(1,1,1),this.specularColorMap=null,this._sheen=0,this._clearcoat=0,this._transmission=0,this.setValues(t)}get sheen(){return this._sheen}set sheen(t){this._sheen>0!=t>0&&this.version++,this._sheen=t}get clearcoat(){return this._clearcoat}set clearcoat(t){this._clearcoat>0!=t>0&&this.version++,this._clearcoat=t}get transmission(){return this._transmission}set transmission(t){this._transmission>0!=t>0&&this.version++,this._transmission=t}copy(t){return super.copy(t),this.defines={STANDARD:"",PHYSICAL:""},this.clearcoat=t.clearcoat,this.clearcoatMap=t.clearcoatMap,this.clearcoatRoughness=t.clearcoatRoughness,this.clearcoatRoughnessMap=t.clearcoatRoughnessMap,this.clearcoatNormalMap=t.clearcoatNormalMap,this.clearcoatNormalScale.copy(t.clearcoatNormalScale),this.ior=t.ior,this.sheen=t.sheen,this.sheenColor.copy(t.sheenColor),this.sheenColorMap=t.sheenColorMap,this.sheenRoughness=t.sheenRoughness,this.sheenRoughnessMap=t.sheenRoughnessMap,this.transmission=t.transmission,this.transmissionMap=t.transmissionMap,this.thickness=t.thickness,this.thicknessMap=t.thicknessMap,this.attenuationDistance=t.attenuationDistance,this.attenuationColor.copy(t.attenuationColor),this.specularIntensity=t.specularIntensity,this.specularIntensityMap=t.specularIntensityMap,this.specularColor.copy(t.specularColor),this.specularColorMap=t.specularColorMap,this}};fh.prototype.isMeshPhysicalMaterial=!0;var dh=class extends xe{constructor(t){super(),this.type="MeshPhongMaterial",this.color=new ft(16777215),this.specular=new ft(1118481),this.shininess=30,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ft(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ts,this.normalScale=new K(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=Cl,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.specular.copy(t.specular),this.shininess=t.shininess,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this}};dh.prototype.isMeshPhongMaterial=!0;var ph=class extends xe{constructor(t){super(),this.defines={TOON:""},this.type="MeshToonMaterial",this.color=new ft(16777215),this.map=null,this.gradientMap=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ft(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ts,this.normalScale=new K(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.gradientMap=t.gradientMap,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};ph.prototype.isMeshToonMaterial=!0;var mh=class extends xe{constructor(t){super(),this.type="MeshNormalMaterial",this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ts,this.normalScale=new K(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.flatShading=t.flatShading,this}};mh.prototype.isMeshNormalMaterial=!0;var gh=class extends xe{constructor(t){super(),this.type="MeshLambertMaterial",this.color=new ft(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ft(0),this.emissiveIntensity=1,this.emissiveMap=null,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=Cl,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};gh.prototype.isMeshLambertMaterial=!0;var xh=class extends xe{constructor(t){super(),this.defines={MATCAP:""},this.type="MeshMatcapMaterial",this.color=new ft(16777215),this.matcap=null,this.map=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ts,this.normalScale=new K(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.defines={MATCAP:""},this.color.copy(t.color),this.matcap=t.matcap,this.map=t.map,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.flatShading=t.flatShading,this}};xh.prototype.isMeshMatcapMaterial=!0;var yh=class extends zn{constructor(t){super(),this.type="LineDashedMaterial",this.scale=1,this.dashSize=3,this.gapSize=1,this.setValues(t)}copy(t){return super.copy(t),this.scale=t.scale,this.dashSize=t.dashSize,this.gapSize=t.gapSize,this}};yh.prototype.isLineDashedMaterial=!0;var Kt={arraySlice:function(n,t,e){return Kt.isTypedArray(n)?new n.constructor(n.subarray(t,e!==void 0?e:n.length)):n.slice(t,e)},convertArray:function(n,t,e){return!n||!e&&n.constructor===t?n:typeof t.BYTES_PER_ELEMENT=="number"?new t(n):Array.prototype.slice.call(n)},isTypedArray:function(n){return ArrayBuffer.isView(n)&&!(n instanceof DataView)},getKeyframeOrder:function(n){function t(r,s){return n[r]-n[s]}let e=n.length,i=new Array(e);for(let r=0;r!==e;++r)i[r]=r;return i.sort(t),i},sortedArray:function(n,t,e){let i=n.length,r=new n.constructor(i);for(let s=0,o=0;o!==i;++s){let a=e[s]*t;for(let l=0;l!==t;++l)r[o++]=n[a+l]}return r},flattenJSON:function(n,t,e,i){let r=1,s=n[0];for(;s!==void 0&&s[i]===void 0;)s=n[r++];if(s===void 0)return;let o=s[i];if(o!==void 0)if(Array.isArray(o))do o=s[i],o!==void 0&&(t.push(s.time),e.push.apply(e,o)),s=n[r++];while(s!==void 0);else if(o.toArray!==void 0)do o=s[i],o!==void 0&&(t.push(s.time),o.toArray(e,e.length)),s=n[r++];while(s!==void 0);else do o=s[i],o!==void 0&&(t.push(s.time),e.push(o)),s=n[r++];while(s!==void 0)},subclip:function(n,t,e,i,r=30){let s=n.clone();s.name=t;let o=[];for(let l=0;l<s.tracks.length;++l){let c=s.tracks[l],u=c.getValueSize(),h=[],f=[];for(let d=0;d<c.times.length;++d){let g=c.times[d]*r;if(!(g<e||g>=i)){h.push(c.times[d]);for(let x=0;x<u;++x)f.push(c.values[d*u+x])}}h.length!==0&&(c.times=Kt.convertArray(h,c.times.constructor),c.values=Kt.convertArray(f,c.values.constructor),o.push(c))}s.tracks=o;let a=1/0;for(let l=0;l<s.tracks.length;++l)a>s.tracks[l].times[0]&&(a=s.tracks[l].times[0]);for(let l=0;l<s.tracks.length;++l)s.tracks[l].shift(-1*a);return s.resetDuration(),s},makeClipAdditive:function(n,t=0,e=n,i=30){i<=0&&(i=30);let r=e.tracks.length,s=t/i;for(let o=0;o<r;++o){let a=e.tracks[o],l=a.ValueTypeName;if(l==="bool"||l==="string")continue;let c=n.tracks.find(function(m){return m.name===a.name&&m.ValueTypeName===l});if(c===void 0)continue;let u=0,h=a.getValueSize();a.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(u=h/3);let f=0,d=c.getValueSize();c.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(f=d/3);let g=a.times.length-1,x;if(s<=a.times[0]){let m=u,p=h-u;x=Kt.arraySlice(a.values,m,p)}else if(s>=a.times[g]){let m=g*h+u,p=m+h-u;x=Kt.arraySlice(a.values,m,p)}else{let m=a.createInterpolant(),p=u,b=h-u;m.evaluate(s),x=Kt.arraySlice(m.resultBuffer,p,b)}l==="quaternion"&&new Ee().fromArray(x).normalize().conjugate().toArray(x);let v=c.times.length;for(let m=0;m<v;++m){let p=m*d+f;if(l==="quaternion")Ee.multiplyQuaternionsFlat(c.values,p,x,0,c.values,p);else{let b=d-f*2;for(let _=0;_<b;++_)c.values[p+_]-=x[_]}}}return n.blendMode=d0,n}},pn=class{constructor(t,e,i,r){this.parameterPositions=t,this._cachedIndex=0,this.resultBuffer=r!==void 0?r:new e.constructor(i),this.sampleValues=e,this.valueSize=i,this.settings=null,this.DefaultSettings_={}}evaluate(t){let e=this.parameterPositions,i=this._cachedIndex,r=e[i],s=e[i-1];t:{e:{let o;n:{i:if(!(t<r)){for(let a=i+2;;){if(r===void 0){if(t<s)break i;return i=e.length,this._cachedIndex=i,this.afterEnd_(i-1,t,s)}if(i===a)break;if(s=r,r=e[++i],t<r)break e}o=e.length;break n}if(!(t>=s)){let a=e[1];t<a&&(i=2,s=a);for(let l=i-2;;){if(s===void 0)return this._cachedIndex=0,this.beforeStart_(0,t,r);if(i===l)break;if(r=s,s=e[--i-1],t>=s)break e}o=i,i=0;break n}break t}for(;i<o;){let a=i+o>>>1;t<e[a]?o=a:i=a+1}if(r=e[i],s=e[i-1],s===void 0)return this._cachedIndex=0,this.beforeStart_(0,t,r);if(r===void 0)return i=e.length,this._cachedIndex=i,this.afterEnd_(i-1,s,t)}this._cachedIndex=i,this.intervalChanged_(i,s,r)}return this.interpolate_(i,s,t,r)}getSettings_(){return this.settings||this.DefaultSettings_}copySampleValue_(t){let e=this.resultBuffer,i=this.sampleValues,r=this.valueSize,s=t*r;for(let o=0;o!==r;++o)e[o]=i[s+o];return e}interpolate_(){throw new Error("call to abstract method")}intervalChanged_(){}};pn.prototype.beforeStart_=pn.prototype.copySampleValue_;pn.prototype.afterEnd_=pn.prototype.copySampleValue_;var vh=class extends pn{constructor(t,e,i,r){super(t,e,i,r),this._weightPrev=-0,this._offsetPrev=-0,this._weightNext=-0,this._offsetNext=-0,this.DefaultSettings_={endingStart:Nr,endingEnd:Nr}}intervalChanged_(t,e,i){let r=this.parameterPositions,s=t-2,o=t+1,a=r[s],l=r[o];if(a===void 0)switch(this.getSettings_().endingStart){case Fr:s=t,a=2*e-i;break;case el:s=r.length-2,a=e+r[s]-r[s+1];break;default:s=t,a=i}if(l===void 0)switch(this.getSettings_().endingEnd){case Fr:o=t,l=2*i-e;break;case el:o=1,l=i+r[1]-r[0];break;default:o=t-1,l=e}let c=(i-e)*.5,u=this.valueSize;this._weightPrev=c/(e-a),this._weightNext=c/(l-i),this._offsetPrev=s*u,this._offsetNext=o*u}interpolate_(t,e,i,r){let s=this.resultBuffer,o=this.sampleValues,a=this.valueSize,l=t*a,c=l-a,u=this._offsetPrev,h=this._offsetNext,f=this._weightPrev,d=this._weightNext,g=(i-e)/(r-e),x=g*g,v=x*g,m=-f*v+2*f*x-f*g,p=(1+f)*v+(-1.5-2*f)*x+(-.5+f)*g+1,b=(-1-d)*v+(1.5+d)*x+.5*g,_=d*v-d*x;for(let S=0;S!==a;++S)s[S]=m*o[u+S]+p*o[c+S]+b*o[l+S]+_*o[h+S];return s}},_l=class extends pn{constructor(t,e,i,r){super(t,e,i,r)}interpolate_(t,e,i,r){let s=this.resultBuffer,o=this.sampleValues,a=this.valueSize,l=t*a,c=l-a,u=(i-e)/(r-e),h=1-u;for(let f=0;f!==a;++f)s[f]=o[c+f]*h+o[l+f]*u;return s}},_h=class extends pn{constructor(t,e,i,r){super(t,e,i,r)}interpolate_(t){return this.copySampleValue_(t-1)}},Xe=class{constructor(t,e,i,r){if(t===void 0)throw new Error("THREE.KeyframeTrack: track name is undefined");if(e===void 0||e.length===0)throw new Error("THREE.KeyframeTrack: no keyframes in track named "+t);this.name=t,this.times=Kt.convertArray(e,this.TimeBufferType),this.values=Kt.convertArray(i,this.ValueBufferType),this.setInterpolation(r||this.DefaultInterpolation)}static toJSON(t){let e=t.constructor,i;if(e.toJSON!==this.toJSON)i=e.toJSON(t);else{i={name:t.name,times:Kt.convertArray(t.times,Array),values:Kt.convertArray(t.values,Array)};let r=t.getInterpolation();r!==t.DefaultInterpolation&&(i.interpolation=r)}return i.type=t.ValueTypeName,i}InterpolantFactoryMethodDiscrete(t){return new _h(this.times,this.values,this.getValueSize(),t)}InterpolantFactoryMethodLinear(t){return new _l(this.times,this.values,this.getValueSize(),t)}InterpolantFactoryMethodSmooth(t){return new vh(this.times,this.values,this.getValueSize(),t)}setInterpolation(t){let e;switch(t){case ja:e=this.InterpolantFactoryMethodDiscrete;break;case tl:e=this.InterpolantFactoryMethodLinear;break;case eu:e=this.InterpolantFactoryMethodSmooth;break}if(e===void 0){let i="unsupported interpolation for "+this.ValueTypeName+" keyframe track named "+this.name;if(this.createInterpolant===void 0)if(t!==this.DefaultInterpolation)this.setInterpolation(this.DefaultInterpolation);else throw new Error(i);return console.warn("THREE.KeyframeTrack:",i),this}return this.createInterpolant=e,this}getInterpolation(){switch(this.createInterpolant){case this.InterpolantFactoryMethodDiscrete:return ja;case this.InterpolantFactoryMethodLinear:return tl;case this.InterpolantFactoryMethodSmooth:return eu}}getValueSize(){return this.values.length/this.times.length}shift(t){if(t!==0){let e=this.times;for(let i=0,r=e.length;i!==r;++i)e[i]+=t}return this}scale(t){if(t!==1){let e=this.times;for(let i=0,r=e.length;i!==r;++i)e[i]*=t}return this}trim(t,e){let i=this.times,r=i.length,s=0,o=r-1;for(;s!==r&&i[s]<t;)++s;for(;o!==-1&&i[o]>e;)--o;if(++o,s!==0||o!==r){s>=o&&(o=Math.max(o,1),s=o-1);let a=this.getValueSize();this.times=Kt.arraySlice(i,s,o),this.values=Kt.arraySlice(this.values,s*a,o*a)}return this}validate(){let t=!0,e=this.getValueSize();e-Math.floor(e)!==0&&(console.error("THREE.KeyframeTrack: Invalid value size in track.",this),t=!1);let i=this.times,r=this.values,s=i.length;s===0&&(console.error("THREE.KeyframeTrack: Track is empty.",this),t=!1);let o=null;for(let a=0;a!==s;a++){let l=i[a];if(typeof l=="number"&&isNaN(l)){console.error("THREE.KeyframeTrack: Time is not a valid number.",this,a,l),t=!1;break}if(o!==null&&o>l){console.error("THREE.KeyframeTrack: Out of order keys.",this,a,l,o),t=!1;break}o=l}if(r!==void 0&&Kt.isTypedArray(r))for(let a=0,l=r.length;a!==l;++a){let c=r[a];if(isNaN(c)){console.error("THREE.KeyframeTrack: Value is not a valid number.",this,a,c),t=!1;break}}return t}optimize(){let t=Kt.arraySlice(this.times),e=Kt.arraySlice(this.values),i=this.getValueSize(),r=this.getInterpolation()===eu,s=t.length-1,o=1;for(let a=1;a<s;++a){let l=!1,c=t[a],u=t[a+1];if(c!==u&&(a!==1||c!==t[0]))if(r)l=!0;else{let h=a*i,f=h-i,d=h+i;for(let g=0;g!==i;++g){let x=e[h+g];if(x!==e[f+g]||x!==e[d+g]){l=!0;break}}}if(l){if(a!==o){t[o]=t[a];let h=a*i,f=o*i;for(let d=0;d!==i;++d)e[f+d]=e[h+d]}++o}}if(s>0){t[o]=t[s];for(let a=s*i,l=o*i,c=0;c!==i;++c)e[l+c]=e[a+c];++o}return o!==t.length?(this.times=Kt.arraySlice(t,0,o),this.values=Kt.arraySlice(e,0,o*i)):(this.times=t,this.values=e),this}clone(){let t=Kt.arraySlice(this.times,0),e=Kt.arraySlice(this.values,0),i=this.constructor,r=new i(this.name,t,e);return r.createInterpolant=this.createInterpolant,r}};Xe.prototype.TimeBufferType=Float32Array;Xe.prototype.ValueBufferType=Float32Array;Xe.prototype.DefaultInterpolation=tl;var ui=class extends Xe{};ui.prototype.ValueTypeName="bool";ui.prototype.ValueBufferType=Array;ui.prototype.DefaultInterpolation=ja;ui.prototype.InterpolantFactoryMethodLinear=void 0;ui.prototype.InterpolantFactoryMethodSmooth=void 0;var wl=class extends Xe{};wl.prototype.ValueTypeName="color";var Kr=class extends Xe{};Kr.prototype.ValueTypeName="number";var wh=class extends pn{constructor(t,e,i,r){super(t,e,i,r)}interpolate_(t,e,i,r){let s=this.resultBuffer,o=this.sampleValues,a=this.valueSize,l=(i-e)/(r-e),c=t*a;for(let u=c+a;c!==u;c+=4)Ee.slerpFlat(s,0,o,c-a,o,c,l);return s}},Xi=class extends Xe{InterpolantFactoryMethodLinear(t){return new wh(this.times,this.values,this.getValueSize(),t)}};Xi.prototype.ValueTypeName="quaternion";Xi.prototype.DefaultInterpolation=tl;Xi.prototype.InterpolantFactoryMethodSmooth=void 0;var hi=class extends Xe{};hi.prototype.ValueTypeName="string";hi.prototype.ValueBufferType=Array;hi.prototype.DefaultInterpolation=ja;hi.prototype.InterpolantFactoryMethodLinear=void 0;hi.prototype.InterpolantFactoryMethodSmooth=void 0;var Qr=class extends Xe{};Qr.prototype.ValueTypeName="vector";var Ml=class{constructor(t,e=-1,i,r=Qh){this.name=t,this.tracks=i,this.duration=e,this.blendMode=r,this.uuid=tn(),this.duration<0&&this.resetDuration()}static parse(t){let e=[],i=t.tracks,r=1/(t.fps||1);for(let o=0,a=i.length;o!==a;++o)e.push(cT(i[o]).scale(r));let s=new this(t.name,t.duration,e,t.blendMode);return s.uuid=t.uuid,s}static toJSON(t){let e=[],i=t.tracks,r={name:t.name,duration:t.duration,tracks:e,uuid:t.uuid,blendMode:t.blendMode};for(let s=0,o=i.length;s!==o;++s)e.push(Xe.toJSON(i[s]));return r}static CreateFromMorphTargetSequence(t,e,i,r){let s=e.length,o=[];for(let a=0;a<s;a++){let l=[],c=[];l.push((a+s-1)%s,a,(a+1)%s),c.push(0,1,0);let u=Kt.getKeyframeOrder(l);l=Kt.sortedArray(l,1,u),c=Kt.sortedArray(c,1,u),!r&&l[0]===0&&(l.push(s),c.push(c[0])),o.push(new Kr(".morphTargetInfluences["+e[a].name+"]",l,c).scale(1/i))}return new this(t,-1,o)}static findByName(t,e){let i=t;if(!Array.isArray(t)){let r=t;i=r.geometry&&r.geometry.animations||r.animations}for(let r=0;r<i.length;r++)if(i[r].name===e)return i[r];return null}static CreateClipsFromMorphTargetSequences(t,e,i){let r={},s=/^([\w-]*?)([\d]+)$/;for(let a=0,l=t.length;a<l;a++){let c=t[a],u=c.name.match(s);if(u&&u.length>1){let h=u[1],f=r[h];f||(r[h]=f=[]),f.push(c)}}let o=[];for(let a in r)o.push(this.CreateFromMorphTargetSequence(a,r[a],e,i));return o}static parseAnimation(t,e){if(!t)return console.error("THREE.AnimationClip: No animation in JSONLoader data."),null;let i=function(h,f,d,g,x){if(d.length!==0){let v=[],m=[];Kt.flattenJSON(d,v,m,g),v.length!==0&&x.push(new h(f,v,m))}},r=[],s=t.name||"default",o=t.fps||30,a=t.blendMode,l=t.length||-1,c=t.hierarchy||[];for(let h=0;h<c.length;h++){let f=c[h].keys;if(!(!f||f.length===0))if(f[0].morphTargets){let d={},g;for(g=0;g<f.length;g++)if(f[g].morphTargets)for(let x=0;x<f[g].morphTargets.length;x++)d[f[g].morphTargets[x]]=-1;for(let x in d){let v=[],m=[];for(let p=0;p!==f[g].morphTargets.length;++p){let b=f[g];v.push(b.time),m.push(b.morphTarget===x?1:0)}r.push(new Kr(".morphTargetInfluence["+x+"]",v,m))}l=d.length*(o||1)}else{let d=".bones["+e[h].name+"]";i(Qr,d+".position",f,"pos",r),i(Xi,d+".quaternion",f,"rot",r),i(Qr,d+".scale",f,"scl",r)}}return r.length===0?null:new this(s,l,r,a)}resetDuration(){let t=this.tracks,e=0;for(let i=0,r=t.length;i!==r;++i){let s=this.tracks[i];e=Math.max(e,s.times[s.times.length-1])}return this.duration=e,this}trim(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].trim(0,this.duration);return this}validate(){let t=!0;for(let e=0;e<this.tracks.length;e++)t=t&&this.tracks[e].validate();return t}optimize(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].optimize();return this}clone(){let t=[];for(let e=0;e<this.tracks.length;e++)t.push(this.tracks[e].clone());return new this.constructor(this.name,this.duration,t,this.blendMode)}toJSON(){return this.constructor.toJSON(this)}};function lT(n){switch(n.toLowerCase()){case"scalar":case"double":case"float":case"number":case"integer":return Kr;case"vector":case"vector2":case"vector3":case"vector4":return Qr;case"color":return wl;case"quaternion":return Xi;case"bool":case"boolean":return ui;case"string":return hi}throw new Error("THREE.KeyframeTrack: Unsupported typeName: "+n)}function cT(n){if(n.type===void 0)throw new Error("THREE.KeyframeTrack: track type undefined, can not parse");let t=lT(n.type);if(n.times===void 0){let e=[],i=[];Kt.flattenJSON(n.keys,e,i,"value"),n.times=e,n.values=i}return t.parse!==void 0?t.parse(n):new t(n.name,n.times,n.values,n.interpolation)}var jr={enabled:!1,files:{},add:function(n,t){this.enabled!==!1&&(this.files[n]=t)},get:function(n){if(this.enabled!==!1)return this.files[n]},remove:function(n){delete this.files[n]},clear:function(){this.files={}}},Mh=class{constructor(t,e,i){let r=this,s=!1,o=0,a=0,l,c=[];this.onStart=void 0,this.onLoad=t,this.onProgress=e,this.onError=i,this.itemStart=function(u){a++,s===!1&&r.onStart!==void 0&&r.onStart(u,o,a),s=!0},this.itemEnd=function(u){o++,r.onProgress!==void 0&&r.onProgress(u,o,a),o===a&&(s=!1,r.onLoad!==void 0&&r.onLoad())},this.itemError=function(u){r.onError!==void 0&&r.onError(u)},this.resolveURL=function(u){return l?l(u):u},this.setURLModifier=function(u){return l=u,this},this.addHandler=function(u,h){return c.push(u,h),this},this.removeHandler=function(u){let h=c.indexOf(u);return h!==-1&&c.splice(h,2),this},this.getHandler=function(u){for(let h=0,f=c.length;h<f;h+=2){let d=c[h],g=c[h+1];if(d.global&&(d.lastIndex=0),d.test(u))return g}return null}}},uT=new Mh,mn=class{constructor(t){this.manager=t!==void 0?t:uT,this.crossOrigin="anonymous",this.withCredentials=!1,this.path="",this.resourcePath="",this.requestHeader={}}load(){}loadAsync(t,e){let i=this;return new Promise(function(r,s){i.load(t,r,e,s)})}parse(){}setCrossOrigin(t){return this.crossOrigin=t,this}setWithCredentials(t){return this.withCredentials=t,this}setPath(t){return this.path=t,this}setResourcePath(t){return this.resourcePath=t,this}setRequestHeader(t){return this.requestHeader=t,this}},Dn={},bh=class extends mn{constructor(t){super(t)}load(t,e,i,r){t===void 0&&(t=""),this.path!==void 0&&(t=this.path+t),t=this.manager.resolveURL(t);let s=jr.get(t);if(s!==void 0)return this.manager.itemStart(t),setTimeout(()=>{e&&e(s),this.manager.itemEnd(t)},0),s;if(Dn[t]!==void 0){Dn[t].push({onLoad:e,onProgress:i,onError:r});return}Dn[t]=[],Dn[t].push({onLoad:e,onProgress:i,onError:r});let o=new Request(t,{headers:new Headers(this.requestHeader),credentials:this.withCredentials?"include":"same-origin"}),a=this.mimeType,l=this.responseType;fetch(o).then(c=>{if(c.status===200||c.status===0){if(c.status===0&&console.warn("THREE.FileLoader: HTTP Status 0 received."),typeof ReadableStream=="undefined"||c.body.getReader===void 0)return c;let u=Dn[t],h=c.body.getReader(),f=c.headers.get("Content-Length"),d=f?parseInt(f):0,g=d!==0,x=0,v=new ReadableStream({start(m){p();function p(){h.read().then(({done:b,value:_})=>{if(b)m.close();else{x+=_.byteLength;let S=new ProgressEvent("progress",{lengthComputable:g,loaded:x,total:d});for(let L=0,A=u.length;L<A;L++){let H=u[L];H.onProgress&&H.onProgress(S)}m.enqueue(_),p()}})}}});return new Response(v)}else throw Error(`fetch for "${c.url}" responded with ${c.status}: ${c.statusText}`)}).then(c=>{switch(l){case"arraybuffer":return c.arrayBuffer();case"blob":return c.blob();case"document":return c.text().then(u=>new DOMParser().parseFromString(u,a));case"json":return c.json();default:if(a===void 0)return c.text();{let h=/charset="?([^;"\s]*)"?/i.exec(a),f=h&&h[1]?h[1].toLowerCase():void 0,d=new TextDecoder(f);return c.arrayBuffer().then(g=>d.decode(g))}}}).then(c=>{jr.add(t,c);let u=Dn[t];delete Dn[t];for(let h=0,f=u.length;h<f;h++){let d=u[h];d.onLoad&&d.onLoad(c)}}).catch(c=>{let u=Dn[t];if(u===void 0)throw this.manager.itemError(t),c;delete Dn[t];for(let h=0,f=u.length;h<f;h++){let d=u[h];d.onError&&d.onError(c)}this.manager.itemError(t)}).finally(()=>{this.manager.itemEnd(t)}),this.manager.itemStart(t)}setResponseType(t){return this.responseType=t,this}setMimeType(t){return this.mimeType=t,this}};var bl=class extends mn{constructor(t){super(t)}load(t,e,i,r){this.path!==void 0&&(t=this.path+t),t=this.manager.resolveURL(t);let s=this,o=jr.get(t);if(o!==void 0)return s.manager.itemStart(t),setTimeout(function(){e&&e(o),s.manager.itemEnd(t)},0),o;let a=ro("img");function l(){u(),jr.add(t,this),e&&e(this),s.manager.itemEnd(t)}function c(h){u(),r&&r(h),s.manager.itemError(t),s.manager.itemEnd(t)}function u(){a.removeEventListener("load",l,!1),a.removeEventListener("error",c,!1)}return a.addEventListener("load",l,!1),a.addEventListener("error",c,!1),t.substr(0,5)!=="data:"&&this.crossOrigin!==void 0&&(a.crossOrigin=this.crossOrigin),s.manager.itemStart(t),a.src=t,a}},Sh=class extends mn{constructor(t){super(t)}load(t,e,i,r){let s=new Wr,o=new bl(this.manager);o.setCrossOrigin(this.crossOrigin),o.setPath(this.path);let a=0;function l(c){o.load(t[c],function(u){s.images[c]=u,a++,a===6&&(s.needsUpdate=!0,e&&e(s))},void 0,r)}for(let c=0;c<t.length;++c)l(c);return s}};var Eh=class extends mn{constructor(t){super(t)}load(t,e,i,r){let s=new ae,o=new bl(this.manager);return o.setCrossOrigin(this.crossOrigin),o.setPath(this.path),o.load(t,function(a){s.image=a,s.needsUpdate=!0,e!==void 0&&e(s)},i,r),s}},Ye=class extends kt{constructor(t,e=1){super(),this.type="Light",this.color=new ft(t),this.intensity=e}dispose(){}copy(t){return super.copy(t),this.color.copy(t.color),this.intensity=t.intensity,this}toJSON(t){let e=super.toJSON(t);return e.object.color=this.color.getHex(),e.object.intensity=this.intensity,this.groundColor!==void 0&&(e.object.groundColor=this.groundColor.getHex()),this.distance!==void 0&&(e.object.distance=this.distance),this.angle!==void 0&&(e.object.angle=this.angle),this.decay!==void 0&&(e.object.decay=this.decay),this.penumbra!==void 0&&(e.object.penumbra=this.penumbra),this.shadow!==void 0&&(e.object.shadow=this.shadow.toJSON()),e}};Ye.prototype.isLight=!0;var Th=class extends Ye{constructor(t,e,i){super(t,i),this.type="HemisphereLight",this.position.copy(kt.DefaultUp),this.updateMatrix(),this.groundColor=new ft(e)}copy(t){return Ye.prototype.copy.call(this,t),this.groundColor.copy(t.groundColor),this}};Th.prototype.isHemisphereLight=!0;var n0=new wt,i0=new T,r0=new T,So=class{constructor(t){this.camera=t,this.bias=0,this.normalBias=0,this.radius=1,this.blurSamples=8,this.mapSize=new K(512,512),this.map=null,this.mapPass=null,this.matrix=new wt,this.autoUpdate=!0,this.needsUpdate=!1,this._frustum=new qr,this._frameExtents=new K(1,1),this._viewportCount=1,this._viewports=[new Wt(0,0,1,1)]}getViewportCount(){return this._viewportCount}getFrustum(){return this._frustum}updateMatrices(t){let e=this.camera,i=this.matrix;i0.setFromMatrixPosition(t.matrixWorld),e.position.copy(i0),r0.setFromMatrixPosition(t.target.matrixWorld),e.lookAt(r0),e.updateMatrixWorld(),n0.multiplyMatrices(e.projectionMatrix,e.matrixWorldInverse),this._frustum.setFromProjectionMatrix(n0),i.set(.5,0,0,.5,0,.5,0,.5,0,0,.5,.5,0,0,0,1),i.multiply(e.projectionMatrix),i.multiply(e.matrixWorldInverse)}getViewport(t){return this._viewports[t]}getFrameExtents(){return this._frameExtents}dispose(){this.map&&this.map.dispose(),this.mapPass&&this.mapPass.dispose()}copy(t){return this.camera=t.camera.clone(),this.bias=t.bias,this.radius=t.radius,this.mapSize.copy(t.mapSize),this}clone(){return new this.constructor().copy(this)}toJSON(){let t={};return this.bias!==0&&(t.bias=this.bias),this.normalBias!==0&&(t.normalBias=this.normalBias),this.radius!==1&&(t.radius=this.radius),(this.mapSize.x!==512||this.mapSize.y!==512)&&(t.mapSize=this.mapSize.toArray()),t.camera=this.camera.toJSON(!1).object,delete t.camera.matrix,t}},Sl=class extends So{constructor(){super(new Se(50,1,.5,500)),this.focus=1}updateMatrices(t){let e=this.camera,i=Vu*2*t.angle*this.focus,r=this.mapSize.width/this.mapSize.height,s=t.distance||e.far;(i!==e.fov||r!==e.aspect||s!==e.far)&&(e.fov=i,e.aspect=r,e.far=s,e.updateProjectionMatrix()),super.updateMatrices(t)}copy(t){return super.copy(t),this.focus=t.focus,this}};Sl.prototype.isSpotLightShadow=!0;var Ah=class extends Ye{constructor(t,e,i=0,r=Math.PI/3,s=0,o=1){super(t,e),this.type="SpotLight",this.position.copy(kt.DefaultUp),this.updateMatrix(),this.target=new kt,this.distance=i,this.angle=r,this.penumbra=s,this.decay=o,this.shadow=new Sl}get power(){return this.intensity*Math.PI}set power(t){this.intensity=t/Math.PI}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.distance=t.distance,this.angle=t.angle,this.penumbra=t.penumbra,this.decay=t.decay,this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}};Ah.prototype.isSpotLight=!0;var s0=new wt,Zs=new T,Nu=new T,El=class extends So{constructor(){super(new Se(90,1,.5,500)),this._frameExtents=new K(4,2),this._viewportCount=6,this._viewports=[new Wt(2,1,1,1),new Wt(0,1,1,1),new Wt(3,1,1,1),new Wt(1,1,1,1),new Wt(3,0,1,1),new Wt(1,0,1,1)],this._cubeDirections=[new T(1,0,0),new T(-1,0,0),new T(0,0,1),new T(0,0,-1),new T(0,1,0),new T(0,-1,0)],this._cubeUps=[new T(0,1,0),new T(0,1,0),new T(0,1,0),new T(0,1,0),new T(0,0,1),new T(0,0,-1)]}updateMatrices(t,e=0){let i=this.camera,r=this.matrix,s=t.distance||i.far;s!==i.far&&(i.far=s,i.updateProjectionMatrix()),Zs.setFromMatrixPosition(t.matrixWorld),i.position.copy(Zs),Nu.copy(i.position),Nu.add(this._cubeDirections[e]),i.up.copy(this._cubeUps[e]),i.lookAt(Nu),i.updateMatrixWorld(),r.makeTranslation(-Zs.x,-Zs.y,-Zs.z),s0.multiplyMatrices(i.projectionMatrix,i.matrixWorldInverse),this._frustum.setFromProjectionMatrix(s0)}};El.prototype.isPointLightShadow=!0;var Ch=class extends Ye{constructor(t,e,i=0,r=1){super(t,e),this.type="PointLight",this.distance=i,this.decay=r,this.shadow=new El}get power(){return this.intensity*4*Math.PI}set power(t){this.intensity=t/(4*Math.PI)}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.distance=t.distance,this.decay=t.decay,this.shadow=t.shadow.clone(),this}};Ch.prototype.isPointLight=!0;var Tl=class extends So{constructor(){super(new Vi(-5,5,5,-5,.5,500))}};Tl.prototype.isDirectionalLightShadow=!0;var Rh=class extends Ye{constructor(t,e){super(t,e),this.type="DirectionalLight",this.position.copy(kt.DefaultUp),this.updateMatrix(),this.target=new kt,this.shadow=new Tl}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}};Rh.prototype.isDirectionalLight=!0;var Lh=class extends Ye{constructor(t,e){super(t,e),this.type="AmbientLight"}};Lh.prototype.isAmbientLight=!0;var Ph=class extends Ye{constructor(t,e,i=10,r=10){super(t,e),this.type="RectAreaLight",this.width=i,this.height=r}get power(){return this.intensity*this.width*this.height*Math.PI}set power(t){this.intensity=t/(this.width*this.height*Math.PI)}copy(t){return super.copy(t),this.width=t.width,this.height=t.height,this}toJSON(t){let e=super.toJSON(t);return e.object.width=this.width,e.object.height=this.height,e}};Ph.prototype.isRectAreaLight=!0;var Al=class{constructor(){this.coefficients=[];for(let t=0;t<9;t++)this.coefficients.push(new T)}set(t){for(let e=0;e<9;e++)this.coefficients[e].copy(t[e]);return this}zero(){for(let t=0;t<9;t++)this.coefficients[t].set(0,0,0);return this}getAt(t,e){let i=t.x,r=t.y,s=t.z,o=this.coefficients;return e.copy(o[0]).multiplyScalar(.282095),e.addScaledVector(o[1],.488603*r),e.addScaledVector(o[2],.488603*s),e.addScaledVector(o[3],.488603*i),e.addScaledVector(o[4],1.092548*(i*r)),e.addScaledVector(o[5],1.092548*(r*s)),e.addScaledVector(o[6],.315392*(3*s*s-1)),e.addScaledVector(o[7],1.092548*(i*s)),e.addScaledVector(o[8],.546274*(i*i-r*r)),e}getIrradianceAt(t,e){let i=t.x,r=t.y,s=t.z,o=this.coefficients;return e.copy(o[0]).multiplyScalar(.886227),e.addScaledVector(o[1],2*.511664*r),e.addScaledVector(o[2],2*.511664*s),e.addScaledVector(o[3],2*.511664*i),e.addScaledVector(o[4],2*.429043*i*r),e.addScaledVector(o[5],2*.429043*r*s),e.addScaledVector(o[6],.743125*s*s-.247708),e.addScaledVector(o[7],2*.429043*i*s),e.addScaledVector(o[8],.429043*(i*i-r*r)),e}add(t){for(let e=0;e<9;e++)this.coefficients[e].add(t.coefficients[e]);return this}addScaledSH(t,e){for(let i=0;i<9;i++)this.coefficients[i].addScaledVector(t.coefficients[i],e);return this}scale(t){for(let e=0;e<9;e++)this.coefficients[e].multiplyScalar(t);return this}lerp(t,e){for(let i=0;i<9;i++)this.coefficients[i].lerp(t.coefficients[i],e);return this}equals(t){for(let e=0;e<9;e++)if(!this.coefficients[e].equals(t.coefficients[e]))return!1;return!0}copy(t){return this.set(t.coefficients)}clone(){return new this.constructor().copy(this)}fromArray(t,e=0){let i=this.coefficients;for(let r=0;r<9;r++)i[r].fromArray(t,e+r*3);return this}toArray(t=[],e=0){let i=this.coefficients;for(let r=0;r<9;r++)i[r].toArray(t,e+r*3);return t}static getBasisAt(t,e){let i=t.x,r=t.y,s=t.z;e[0]=.282095,e[1]=.488603*r,e[2]=.488603*s,e[3]=.488603*i,e[4]=1.092548*i*r,e[5]=1.092548*r*s,e[6]=.315392*(3*s*s-1),e[7]=1.092548*i*s,e[8]=.546274*(i*i-r*r)}};Al.prototype.isSphericalHarmonics3=!0;var Eo=class extends Ye{constructor(t=new Al,e=1){super(void 0,e),this.sh=t}copy(t){return super.copy(t),this.sh.copy(t.sh),this}fromJSON(t){return this.intensity=t.intensity,this.sh.fromArray(t.sh),this}toJSON(t){let e=super.toJSON(t);return e.object.sh=this.sh.toArray(),e}};Eo.prototype.isLightProbe=!0;var Dh=class{static decodeText(t){if(typeof TextDecoder!="undefined")return new TextDecoder().decode(t);let e="";for(let i=0,r=t.length;i<r;i++)e+=String.fromCharCode(t[i]);try{return decodeURIComponent(escape(e))}catch(i){return e}}static extractUrlBase(t){let e=t.lastIndexOf("/");return e===-1?"./":t.substr(0,e+1)}static resolveURL(t,e){return typeof t!="string"||t===""?"":(/^https?:\/\//i.test(e)&&/^\//.test(t)&&(e=e.replace(/(^https?:\/\/[^\/]+).*/i,"$1")),/^(https?:)?\/\//i.test(t)||/^data:.*,.*$/i.test(t)||/^blob:.*$/i.test(t)?t:e+t)}},Ih=class extends Ht{constructor(){super(),this.type="InstancedBufferGeometry",this.instanceCount=1/0}copy(t){return super.copy(t),this.instanceCount=t.instanceCount,this}clone(){return new this.constructor().copy(this)}toJSON(){let t=super.toJSON(this);return t.instanceCount=this.instanceCount,t.isInstancedBufferGeometry=!0,t}};Ih.prototype.isInstancedBufferGeometry=!0;var Nh=class extends mn{constructor(t){super(t),typeof createImageBitmap=="undefined"&&console.warn("THREE.ImageBitmapLoader: createImageBitmap() not supported."),typeof fetch=="undefined"&&console.warn("THREE.ImageBitmapLoader: fetch() not supported."),this.options={premultiplyAlpha:"none"}}setOptions(t){return this.options=t,this}load(t,e,i,r){t===void 0&&(t=""),this.path!==void 0&&(t=this.path+t),t=this.manager.resolveURL(t);let s=this,o=jr.get(t);if(o!==void 0)return s.manager.itemStart(t),setTimeout(function(){e&&e(o),s.manager.itemEnd(t)},0),o;let a={};a.credentials=this.crossOrigin==="anonymous"?"same-origin":"include",a.headers=this.requestHeader,fetch(t,a).then(function(l){return l.blob()}).then(function(l){return createImageBitmap(l,Object.assign(s.options,{colorSpaceConversion:"none"}))}).then(function(l){jr.add(t,l),e&&e(l),s.manager.itemEnd(t)}).catch(function(l){r&&r(l),s.manager.itemError(t),s.manager.itemEnd(t)}),s.manager.itemStart(t)}};Nh.prototype.isImageBitmapLoader=!0;var Ja,hT={getContext:function(){return Ja===void 0&&(Ja=new(window.AudioContext||window.webkitAudioContext)),Ja},setContext:function(n){Ja=n}},Fh=class extends mn{constructor(t){super(t)}load(t,e,i,r){let s=this,o=new bh(this.manager);o.setResponseType("arraybuffer"),o.setPath(this.path),o.setRequestHeader(this.requestHeader),o.setWithCredentials(this.withCredentials),o.load(t,function(a){try{let l=a.slice(0);hT.getContext().decodeAudioData(l,function(u){e(u)})}catch(l){r?r(l):console.error(l),s.manager.itemError(t)}},i,r)}},zh=class extends Eo{constructor(t,e,i=1){super(void 0,i);let r=new ft().set(t),s=new ft().set(e),o=new T(r.r,r.g,r.b),a=new T(s.r,s.g,s.b),l=Math.sqrt(Math.PI),c=l*Math.sqrt(.75);this.sh.coefficients[0].copy(o).add(a).multiplyScalar(l),this.sh.coefficients[1].copy(o).sub(a).multiplyScalar(c)}};zh.prototype.isHemisphereLightProbe=!0;var Uh=class extends Eo{constructor(t,e=1){super(void 0,e);let i=new ft().set(t);this.sh.coefficients[0].set(i.r,i.g,i.b).multiplyScalar(2*Math.sqrt(Math.PI))}};Uh.prototype.isAmbientLightProbe=!0;var Bh=class extends kt{constructor(t){super(),this.type="Audio",this.listener=t,this.context=t.context,this.gain=this.context.createGain(),this.gain.connect(t.getInput()),this.autoplay=!1,this.buffer=null,this.detune=0,this.loop=!1,this.loopStart=0,this.loopEnd=0,this.offset=0,this.duration=void 0,this.playbackRate=1,this.isPlaying=!1,this.hasPlaybackControl=!0,this.source=null,this.sourceType="empty",this._startedAt=0,this._progress=0,this._connected=!1,this.filters=[]}getOutput(){return this.gain}setNodeSource(t){return this.hasPlaybackControl=!1,this.sourceType="audioNode",this.source=t,this.connect(),this}setMediaElementSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaNode",this.source=this.context.createMediaElementSource(t),this.connect(),this}setMediaStreamSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaStreamNode",this.source=this.context.createMediaStreamSource(t),this.connect(),this}setBuffer(t){return this.buffer=t,this.sourceType="buffer",this.autoplay&&this.play(),this}play(t=0){if(this.isPlaying===!0){console.warn("THREE.Audio: Audio is already playing.");return}if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}this._startedAt=this.context.currentTime+t;let e=this.context.createBufferSource();return e.buffer=this.buffer,e.loop=this.loop,e.loopStart=this.loopStart,e.loopEnd=this.loopEnd,e.onended=this.onEnded.bind(this),e.start(this._startedAt,this._progress+this.offset,this.duration),this.isPlaying=!0,this.source=e,this.setDetune(this.detune),this.setPlaybackRate(this.playbackRate),this.connect()}pause(){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this.isPlaying===!0&&(this._progress+=Math.max(this.context.currentTime-this._startedAt,0)*this.playbackRate,this.loop===!0&&(this._progress=this._progress%(this.duration||this.buffer.duration)),this.source.stop(),this.source.onended=null,this.isPlaying=!1),this}stop(){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this._progress=0,this.source.stop(),this.source.onended=null,this.isPlaying=!1,this}connect(){if(this.filters.length>0){this.source.connect(this.filters[0]);for(let t=1,e=this.filters.length;t<e;t++)this.filters[t-1].connect(this.filters[t]);this.filters[this.filters.length-1].connect(this.getOutput())}else this.source.connect(this.getOutput());return this._connected=!0,this}disconnect(){if(this.filters.length>0){this.source.disconnect(this.filters[0]);for(let t=1,e=this.filters.length;t<e;t++)this.filters[t-1].disconnect(this.filters[t]);this.filters[this.filters.length-1].disconnect(this.getOutput())}else this.source.disconnect(this.getOutput());return this._connected=!1,this}getFilters(){return this.filters}setFilters(t){return t||(t=[]),this._connected===!0?(this.disconnect(),this.filters=t.slice(),this.connect()):this.filters=t.slice(),this}setDetune(t){if(this.detune=t,this.source.detune!==void 0)return this.isPlaying===!0&&this.source.detune.setTargetAtTime(this.detune,this.context.currentTime,.01),this}getDetune(){return this.detune}getFilter(){return this.getFilters()[0]}setFilter(t){return this.setFilters(t?[t]:[])}setPlaybackRate(t){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this.playbackRate=t,this.isPlaying===!0&&this.source.playbackRate.setTargetAtTime(this.playbackRate,this.context.currentTime,.01),this}getPlaybackRate(){return this.playbackRate}onEnded(){this.isPlaying=!1}getLoop(){return this.hasPlaybackControl===!1?(console.warn("THREE.Audio: this Audio has no playback control."),!1):this.loop}setLoop(t){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this.loop=t,this.isPlaying===!0&&(this.source.loop=this.loop),this}setLoopStart(t){return this.loopStart=t,this}setLoopEnd(t){return this.loopEnd=t,this}getVolume(){return this.gain.gain.value}setVolume(t){return this.gain.gain.setTargetAtTime(t,this.context.currentTime,.01),this}};var Oh=class{constructor(t,e=2048){this.analyser=t.context.createAnalyser(),this.analyser.fftSize=e,this.data=new Uint8Array(this.analyser.frequencyBinCount),t.getOutput().connect(this.analyser)}getFrequencyData(){return this.analyser.getByteFrequencyData(this.data),this.data}getAverageFrequency(){let t=0,e=this.getFrequencyData();for(let i=0;i<e.length;i++)t+=e[i];return t/e.length}},kh=class{constructor(t,e,i){this.binding=t,this.valueSize=i;let r,s,o;switch(e){case"quaternion":r=this._slerp,s=this._slerpAdditive,o=this._setAdditiveIdentityQuaternion,this.buffer=new Float64Array(i*6),this._workIndex=5;break;case"string":case"bool":r=this._select,s=this._select,o=this._setAdditiveIdentityOther,this.buffer=new Array(i*5);break;default:r=this._lerp,s=this._lerpAdditive,o=this._setAdditiveIdentityNumeric,this.buffer=new Float64Array(i*5)}this._mixBufferRegion=r,this._mixBufferRegionAdditive=s,this._setIdentity=o,this._origIndex=3,this._addIndex=4,this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,this.useCount=0,this.referenceCount=0}accumulate(t,e){let i=this.buffer,r=this.valueSize,s=t*r+r,o=this.cumulativeWeight;if(o===0){for(let a=0;a!==r;++a)i[s+a]=i[a];o=e}else{o+=e;let a=e/o;this._mixBufferRegion(i,s,0,a,r)}this.cumulativeWeight=o}accumulateAdditive(t){let e=this.buffer,i=this.valueSize,r=i*this._addIndex;this.cumulativeWeightAdditive===0&&this._setIdentity(),this._mixBufferRegionAdditive(e,r,0,t,i),this.cumulativeWeightAdditive+=t}apply(t){let e=this.valueSize,i=this.buffer,r=t*e+e,s=this.cumulativeWeight,o=this.cumulativeWeightAdditive,a=this.binding;if(this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,s<1){let l=e*this._origIndex;this._mixBufferRegion(i,r,l,1-s,e)}o>0&&this._mixBufferRegionAdditive(i,r,this._addIndex*e,1,e);for(let l=e,c=e+e;l!==c;++l)if(i[l]!==i[l+e]){a.setValue(i,r);break}}saveOriginalState(){let t=this.binding,e=this.buffer,i=this.valueSize,r=i*this._origIndex;t.getValue(e,r);for(let s=i,o=r;s!==o;++s)e[s]=e[r+s%i];this._setIdentity(),this.cumulativeWeight=0,this.cumulativeWeightAdditive=0}restoreOriginalState(){let t=this.valueSize*3;this.binding.setValue(this.buffer,t)}_setAdditiveIdentityNumeric(){let t=this._addIndex*this.valueSize,e=t+this.valueSize;for(let i=t;i<e;i++)this.buffer[i]=0}_setAdditiveIdentityQuaternion(){this._setAdditiveIdentityNumeric(),this.buffer[this._addIndex*this.valueSize+3]=1}_setAdditiveIdentityOther(){let t=this._origIndex*this.valueSize,e=this._addIndex*this.valueSize;for(let i=0;i<this.valueSize;i++)this.buffer[e+i]=this.buffer[t+i]}_select(t,e,i,r,s){if(r>=.5)for(let o=0;o!==s;++o)t[e+o]=t[i+o]}_slerp(t,e,i,r){Ee.slerpFlat(t,e,t,e,t,i,r)}_slerpAdditive(t,e,i,r,s){let o=this._workIndex*s;Ee.multiplyQuaternionsFlat(t,o,t,e,t,i),Ee.slerpFlat(t,e,t,e,t,o,r)}_lerp(t,e,i,r,s){let o=1-r;for(let a=0;a!==s;++a){let l=e+a;t[l]=t[l]*o+t[i+a]*r}}_lerpAdditive(t,e,i,r,s){for(let o=0;o!==s;++o){let a=e+o;t[a]=t[a]+t[i+o]*r}}},ef="\\[\\]\\.:\\/",fT=new RegExp("["+ef+"]","g"),nf="[^"+ef+"]",dT="[^"+ef.replace("\\.","")+"]",pT=/((?:WC+[\/:])*)/.source.replace("WC",nf),mT=/(WCOD+)?/.source.replace("WCOD",dT),gT=/(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace("WC",nf),xT=/\.(WC+)(?:\[(.+)\])?/.source.replace("WC",nf),yT=new RegExp("^"+pT+mT+gT+xT+"$"),vT=["material","materials","bones"],Hh=class{constructor(t,e,i){let r=i||Nt.parseTrackName(e);this._targetGroup=t,this._bindings=t.subscribe_(e,r)}getValue(t,e){this.bind();let i=this._targetGroup.nCachedObjects_,r=this._bindings[i];r!==void 0&&r.getValue(t,e)}setValue(t,e){let i=this._bindings;for(let r=this._targetGroup.nCachedObjects_,s=i.length;r!==s;++r)i[r].setValue(t,e)}bind(){let t=this._bindings;for(let e=this._targetGroup.nCachedObjects_,i=t.length;e!==i;++e)t[e].bind()}unbind(){let t=this._bindings;for(let e=this._targetGroup.nCachedObjects_,i=t.length;e!==i;++e)t[e].unbind()}},Nt=class{constructor(t,e,i){this.path=e,this.parsedPath=i||Nt.parseTrackName(e),this.node=Nt.findNode(t,this.parsedPath.nodeName)||t,this.rootNode=t,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}static create(t,e,i){return t&&t.isAnimationObjectGroup?new Nt.Composite(t,e,i):new Nt(t,e,i)}static sanitizeNodeName(t){return t.replace(/\s/g,"_").replace(fT,"")}static parseTrackName(t){let e=yT.exec(t);if(!e)throw new Error("PropertyBinding: Cannot parse trackName: "+t);let i={nodeName:e[2],objectName:e[3],objectIndex:e[4],propertyName:e[5],propertyIndex:e[6]},r=i.nodeName&&i.nodeName.lastIndexOf(".");if(r!==void 0&&r!==-1){let s=i.nodeName.substring(r+1);vT.indexOf(s)!==-1&&(i.nodeName=i.nodeName.substring(0,r),i.objectName=s)}if(i.propertyName===null||i.propertyName.length===0)throw new Error("PropertyBinding: can not parse propertyName from trackName: "+t);return i}static findNode(t,e){if(!e||e===""||e==="."||e===-1||e===t.name||e===t.uuid)return t;if(t.skeleton){let i=t.skeleton.getBoneByName(e);if(i!==void 0)return i}if(t.children){let i=function(s){for(let o=0;o<s.length;o++){let a=s[o];if(a.name===e||a.uuid===e)return a;let l=i(a.children);if(l)return l}return null},r=i(t.children);if(r)return r}return null}_getValue_unavailable(){}_setValue_unavailable(){}_getValue_direct(t,e){t[e]=this.targetObject[this.propertyName]}_getValue_array(t,e){let i=this.resolvedProperty;for(let r=0,s=i.length;r!==s;++r)t[e++]=i[r]}_getValue_arrayElement(t,e){t[e]=this.resolvedProperty[this.propertyIndex]}_getValue_toArray(t,e){this.resolvedProperty.toArray(t,e)}_setValue_direct(t,e){this.targetObject[this.propertyName]=t[e]}_setValue_direct_setNeedsUpdate(t,e){this.targetObject[this.propertyName]=t[e],this.targetObject.needsUpdate=!0}_setValue_direct_setMatrixWorldNeedsUpdate(t,e){this.targetObject[this.propertyName]=t[e],this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_array(t,e){let i=this.resolvedProperty;for(let r=0,s=i.length;r!==s;++r)i[r]=t[e++]}_setValue_array_setNeedsUpdate(t,e){let i=this.resolvedProperty;for(let r=0,s=i.length;r!==s;++r)i[r]=t[e++];this.targetObject.needsUpdate=!0}_setValue_array_setMatrixWorldNeedsUpdate(t,e){let i=this.resolvedProperty;for(let r=0,s=i.length;r!==s;++r)i[r]=t[e++];this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_arrayElement(t,e){this.resolvedProperty[this.propertyIndex]=t[e]}_setValue_arrayElement_setNeedsUpdate(t,e){this.resolvedProperty[this.propertyIndex]=t[e],this.targetObject.needsUpdate=!0}_setValue_arrayElement_setMatrixWorldNeedsUpdate(t,e){this.resolvedProperty[this.propertyIndex]=t[e],this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_fromArray(t,e){this.resolvedProperty.fromArray(t,e)}_setValue_fromArray_setNeedsUpdate(t,e){this.resolvedProperty.fromArray(t,e),this.targetObject.needsUpdate=!0}_setValue_fromArray_setMatrixWorldNeedsUpdate(t,e){this.resolvedProperty.fromArray(t,e),this.targetObject.matrixWorldNeedsUpdate=!0}_getValue_unbound(t,e){this.bind(),this.getValue(t,e)}_setValue_unbound(t,e){this.bind(),this.setValue(t,e)}bind(){let t=this.node,e=this.parsedPath,i=e.objectName,r=e.propertyName,s=e.propertyIndex;if(t||(t=Nt.findNode(this.rootNode,e.nodeName)||this.rootNode,this.node=t),this.getValue=this._getValue_unavailable,this.setValue=this._setValue_unavailable,!t){console.error("THREE.PropertyBinding: Trying to update node for track: "+this.path+" but it wasn't found.");return}if(i){let c=e.objectIndex;switch(i){case"materials":if(!t.material){console.error("THREE.PropertyBinding: Can not bind to material as node does not have a material.",this);return}if(!t.material.materials){console.error("THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.",this);return}t=t.material.materials;break;case"bones":if(!t.skeleton){console.error("THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.",this);return}t=t.skeleton.bones;for(let u=0;u<t.length;u++)if(t[u].name===c){c=u;break}break;default:if(t[i]===void 0){console.error("THREE.PropertyBinding: Can not bind to objectName of node undefined.",this);return}t=t[i]}if(c!==void 0){if(t[c]===void 0){console.error("THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.",this,t);return}t=t[c]}}let o=t[r];if(o===void 0){let c=e.nodeName;console.error("THREE.PropertyBinding: Trying to update property for track: "+c+"."+r+" but it wasn't found.",t);return}let a=this.Versioning.None;this.targetObject=t,t.needsUpdate!==void 0?a=this.Versioning.NeedsUpdate:t.matrixWorldNeedsUpdate!==void 0&&(a=this.Versioning.MatrixWorldNeedsUpdate);let l=this.BindingType.Direct;if(s!==void 0){if(r==="morphTargetInfluences"){if(!t.geometry){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.",this);return}if(t.geometry.isBufferGeometry){if(!t.geometry.morphAttributes){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.",this);return}t.morphTargetDictionary[s]!==void 0&&(s=t.morphTargetDictionary[s])}else{console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences on THREE.Geometry. Use THREE.BufferGeometry instead.",this);return}}l=this.BindingType.ArrayElement,this.resolvedProperty=o,this.propertyIndex=s}else o.fromArray!==void 0&&o.toArray!==void 0?(l=this.BindingType.HasFromToArray,this.resolvedProperty=o):Array.isArray(o)?(l=this.BindingType.EntireArray,this.resolvedProperty=o):this.propertyName=r;this.getValue=this.GetterByBindingType[l],this.setValue=this.SetterByBindingTypeAndVersioning[l][a]}unbind(){this.node=null,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}};Nt.Composite=Hh;Nt.prototype.BindingType={Direct:0,EntireArray:1,ArrayElement:2,HasFromToArray:3};Nt.prototype.Versioning={None:0,NeedsUpdate:1,MatrixWorldNeedsUpdate:2};Nt.prototype.GetterByBindingType=[Nt.prototype._getValue_direct,Nt.prototype._getValue_array,Nt.prototype._getValue_arrayElement,Nt.prototype._getValue_toArray];Nt.prototype.SetterByBindingTypeAndVersioning=[[Nt.prototype._setValue_direct,Nt.prototype._setValue_direct_setNeedsUpdate,Nt.prototype._setValue_direct_setMatrixWorldNeedsUpdate],[Nt.prototype._setValue_array,Nt.prototype._setValue_array_setNeedsUpdate,Nt.prototype._setValue_array_setMatrixWorldNeedsUpdate],[Nt.prototype._setValue_arrayElement,Nt.prototype._setValue_arrayElement_setNeedsUpdate,Nt.prototype._setValue_arrayElement_setMatrixWorldNeedsUpdate],[Nt.prototype._setValue_fromArray,Nt.prototype._setValue_fromArray_setNeedsUpdate,Nt.prototype._setValue_fromArray_setMatrixWorldNeedsUpdate]];var Vh=class{constructor(){this.uuid=tn(),this._objects=Array.prototype.slice.call(arguments),this.nCachedObjects_=0;let t={};this._indicesByUUID=t;for(let i=0,r=arguments.length;i!==r;++i)t[arguments[i].uuid]=i;this._paths=[],this._parsedPaths=[],this._bindings=[],this._bindingsIndicesByPath={};let e=this;this.stats={objects:{get total(){return e._objects.length},get inUse(){return this.total-e.nCachedObjects_}},get bindingsPerObject(){return e._bindings.length}}}add(){let t=this._objects,e=this._indicesByUUID,i=this._paths,r=this._parsedPaths,s=this._bindings,o=s.length,a,l=t.length,c=this.nCachedObjects_;for(let u=0,h=arguments.length;u!==h;++u){let f=arguments[u],d=f.uuid,g=e[d];if(g===void 0){g=l++,e[d]=g,t.push(f);for(let x=0,v=o;x!==v;++x)s[x].push(new Nt(f,i[x],r[x]))}else if(g<c){a=t[g];let x=--c,v=t[x];e[v.uuid]=g,t[g]=v,e[d]=x,t[x]=f;for(let m=0,p=o;m!==p;++m){let b=s[m],_=b[x],S=b[g];b[g]=_,S===void 0&&(S=new Nt(f,i[m],r[m])),b[x]=S}}else t[g]!==a&&console.error("THREE.AnimationObjectGroup: Different objects with the same UUID detected. Clean the caches or recreate your infrastructure when reloading scenes.")}this.nCachedObjects_=c}remove(){let t=this._objects,e=this._indicesByUUID,i=this._bindings,r=i.length,s=this.nCachedObjects_;for(let o=0,a=arguments.length;o!==a;++o){let l=arguments[o],c=l.uuid,u=e[c];if(u!==void 0&&u>=s){let h=s++,f=t[h];e[f.uuid]=u,t[u]=f,e[c]=h,t[h]=l;for(let d=0,g=r;d!==g;++d){let x=i[d],v=x[h],m=x[u];x[u]=v,x[h]=m}}}this.nCachedObjects_=s}uncache(){let t=this._objects,e=this._indicesByUUID,i=this._bindings,r=i.length,s=this.nCachedObjects_,o=t.length;for(let a=0,l=arguments.length;a!==l;++a){let c=arguments[a],u=c.uuid,h=e[u];if(h!==void 0)if(delete e[u],h<s){let f=--s,d=t[f],g=--o,x=t[g];e[d.uuid]=h,t[h]=d,e[x.uuid]=f,t[f]=x,t.pop();for(let v=0,m=r;v!==m;++v){let p=i[v],b=p[f],_=p[g];p[h]=b,p[f]=_,p.pop()}}else{let f=--o,d=t[f];f>0&&(e[d.uuid]=h),t[h]=d,t.pop();for(let g=0,x=r;g!==x;++g){let v=i[g];v[h]=v[f],v.pop()}}}this.nCachedObjects_=s}subscribe_(t,e){let i=this._bindingsIndicesByPath,r=i[t],s=this._bindings;if(r!==void 0)return s[r];let o=this._paths,a=this._parsedPaths,l=this._objects,c=l.length,u=this.nCachedObjects_,h=new Array(c);r=s.length,i[t]=r,o.push(t),a.push(e),s.push(h);for(let f=u,d=l.length;f!==d;++f){let g=l[f];h[f]=new Nt(g,t,e)}return h}unsubscribe_(t){let e=this._bindingsIndicesByPath,i=e[t];if(i!==void 0){let r=this._paths,s=this._parsedPaths,o=this._bindings,a=o.length-1,l=o[a],c=t[a];e[c]=i,o[i]=l,o.pop(),s[i]=s[a],s.pop(),r[i]=r[a],r.pop()}}};Vh.prototype.isAnimationObjectGroup=!0;var Gh=class{constructor(t,e,i=null,r=e.blendMode){this._mixer=t,this._clip=e,this._localRoot=i,this.blendMode=r;let s=e.tracks,o=s.length,a=new Array(o),l={endingStart:Nr,endingEnd:Nr};for(let c=0;c!==o;++c){let u=s[c].createInterpolant(null);a[c]=u,u.settings=l}this._interpolantSettings=l,this._interpolants=a,this._propertyBindings=new Array(o),this._cacheIndex=null,this._byClipCacheIndex=null,this._timeScaleInterpolant=null,this._weightInterpolant=null,this.loop=Zw,this._loopCount=-1,this._startTime=null,this.time=0,this.timeScale=1,this._effectiveTimeScale=1,this.weight=1,this._effectiveWeight=1,this.repetitions=1/0,this.paused=!1,this.enabled=!0,this.clampWhenFinished=!1,this.zeroSlopeAtStart=!0,this.zeroSlopeAtEnd=!0}play(){return this._mixer._activateAction(this),this}stop(){return this._mixer._deactivateAction(this),this.reset()}reset(){return this.paused=!1,this.enabled=!0,this.time=0,this._loopCount=-1,this._startTime=null,this.stopFading().stopWarping()}isRunning(){return this.enabled&&!this.paused&&this.timeScale!==0&&this._startTime===null&&this._mixer._isActiveAction(this)}isScheduled(){return this._mixer._isActiveAction(this)}startAt(t){return this._startTime=t,this}setLoop(t,e){return this.loop=t,this.repetitions=e,this}setEffectiveWeight(t){return this.weight=t,this._effectiveWeight=this.enabled?t:0,this.stopFading()}getEffectiveWeight(){return this._effectiveWeight}fadeIn(t){return this._scheduleFading(t,0,1)}fadeOut(t){return this._scheduleFading(t,1,0)}crossFadeFrom(t,e,i){if(t.fadeOut(e),this.fadeIn(e),i){let r=this._clip.duration,s=t._clip.duration,o=s/r,a=r/s;t.warp(1,o,e),this.warp(a,1,e)}return this}crossFadeTo(t,e,i){return t.crossFadeFrom(this,e,i)}stopFading(){let t=this._weightInterpolant;return t!==null&&(this._weightInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}setEffectiveTimeScale(t){return this.timeScale=t,this._effectiveTimeScale=this.paused?0:t,this.stopWarping()}getEffectiveTimeScale(){return this._effectiveTimeScale}setDuration(t){return this.timeScale=this._clip.duration/t,this.stopWarping()}syncWith(t){return this.time=t.time,this.timeScale=t.timeScale,this.stopWarping()}halt(t){return this.warp(this._effectiveTimeScale,0,t)}warp(t,e,i){let r=this._mixer,s=r.time,o=this.timeScale,a=this._timeScaleInterpolant;a===null&&(a=r._lendControlInterpolant(),this._timeScaleInterpolant=a);let l=a.parameterPositions,c=a.sampleValues;return l[0]=s,l[1]=s+i,c[0]=t/o,c[1]=e/o,this}stopWarping(){let t=this._timeScaleInterpolant;return t!==null&&(this._timeScaleInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}getMixer(){return this._mixer}getClip(){return this._clip}getRoot(){return this._localRoot||this._mixer._root}_update(t,e,i,r){if(!this.enabled){this._updateWeight(t);return}let s=this._startTime;if(s!==null){let l=(t-s)*i;if(l<0||i===0)return;this._startTime=null,e=i*l}e*=this._updateTimeScale(t);let o=this._updateTime(e),a=this._updateWeight(t);if(a>0){let l=this._interpolants,c=this._propertyBindings;switch(this.blendMode){case d0:for(let u=0,h=l.length;u!==h;++u)l[u].evaluate(o),c[u].accumulateAdditive(a);break;case Qh:default:for(let u=0,h=l.length;u!==h;++u)l[u].evaluate(o),c[u].accumulate(r,a)}}}_updateWeight(t){let e=0;if(this.enabled){e=this.weight;let i=this._weightInterpolant;if(i!==null){let r=i.evaluate(t)[0];e*=r,t>i.parameterPositions[1]&&(this.stopFading(),r===0&&(this.enabled=!1))}}return this._effectiveWeight=e,e}_updateTimeScale(t){let e=0;if(!this.paused){e=this.timeScale;let i=this._timeScaleInterpolant;i!==null&&(e*=i.evaluate(t)[0],t>i.parameterPositions[1]&&(this.stopWarping(),e===0?this.paused=!0:this.timeScale=e))}return this._effectiveTimeScale=e,e}_updateTime(t){let e=this._clip.duration,i=this.loop,r=this.time+t,s=this._loopCount,o=i===Jw;if(t===0)return s===-1?r:o&&(s&1)===1?e-r:r;if(i===Yw){s===-1&&(this._loopCount=0,this._setEndings(!0,!0,!1));t:{if(r>=e)r=e;else if(r<0)r=0;else{this.time=r;break t}this.clampWhenFinished?this.paused=!0:this.enabled=!1,this.time=r,this._mixer.dispatchEvent({type:"finished",action:this,direction:t<0?-1:1})}}else{if(s===-1&&(t>=0?(s=0,this._setEndings(!0,this.repetitions===0,o)):this._setEndings(this.repetitions===0,!0,o)),r>=e||r<0){let a=Math.floor(r/e);r-=e*a,s+=Math.abs(a);let l=this.repetitions-s;if(l<=0)this.clampWhenFinished?this.paused=!0:this.enabled=!1,r=t>0?e:0,this.time=r,this._mixer.dispatchEvent({type:"finished",action:this,direction:t>0?1:-1});else{if(l===1){let c=t<0;this._setEndings(c,!c,o)}else this._setEndings(!1,!1,o);this._loopCount=s,this.time=r,this._mixer.dispatchEvent({type:"loop",action:this,loopDelta:a})}}else this.time=r;if(o&&(s&1)===1)return e-r}return r}_setEndings(t,e,i){let r=this._interpolantSettings;i?(r.endingStart=Fr,r.endingEnd=Fr):(t?r.endingStart=this.zeroSlopeAtStart?Fr:Nr:r.endingStart=el,e?r.endingEnd=this.zeroSlopeAtEnd?Fr:Nr:r.endingEnd=el)}_scheduleFading(t,e,i){let r=this._mixer,s=r.time,o=this._weightInterpolant;o===null&&(o=r._lendControlInterpolant(),this._weightInterpolant=o);let a=o.parameterPositions,l=o.sampleValues;return a[0]=s,l[0]=e,a[1]=s+t,l[1]=i,this}},Wh=class extends In{constructor(t){super(),this._root=t,this._initMemoryManager(),this._accuIndex=0,this.time=0,this.timeScale=1}_bindAction(t,e){let i=t._localRoot||this._root,r=t._clip.tracks,s=r.length,o=t._propertyBindings,a=t._interpolants,l=i.uuid,c=this._bindingsByRootAndName,u=c[l];u===void 0&&(u={},c[l]=u);for(let h=0;h!==s;++h){let f=r[h],d=f.name,g=u[d];if(g!==void 0)++g.referenceCount,o[h]=g;else{if(g=o[h],g!==void 0){g._cacheIndex===null&&(++g.referenceCount,this._addInactiveBinding(g,l,d));continue}let x=e&&e._propertyBindings[h].binding.parsedPath;g=new kh(Nt.create(i,d,x),f.ValueTypeName,f.getValueSize()),++g.referenceCount,this._addInactiveBinding(g,l,d),o[h]=g}a[h].resultBuffer=g.buffer}}_activateAction(t){if(!this._isActiveAction(t)){if(t._cacheIndex===null){let i=(t._localRoot||this._root).uuid,r=t._clip.uuid,s=this._actionsByClip[r];this._bindAction(t,s&&s.knownActions[0]),this._addInactiveAction(t,r,i)}let e=t._propertyBindings;for(let i=0,r=e.length;i!==r;++i){let s=e[i];s.useCount++===0&&(this._lendBinding(s),s.saveOriginalState())}this._lendAction(t)}}_deactivateAction(t){if(this._isActiveAction(t)){let e=t._propertyBindings;for(let i=0,r=e.length;i!==r;++i){let s=e[i];--s.useCount===0&&(s.restoreOriginalState(),this._takeBackBinding(s))}this._takeBackAction(t)}}_initMemoryManager(){this._actions=[],this._nActiveActions=0,this._actionsByClip={},this._bindings=[],this._nActiveBindings=0,this._bindingsByRootAndName={},this._controlInterpolants=[],this._nActiveControlInterpolants=0;let t=this;this.stats={actions:{get total(){return t._actions.length},get inUse(){return t._nActiveActions}},bindings:{get total(){return t._bindings.length},get inUse(){return t._nActiveBindings}},controlInterpolants:{get total(){return t._controlInterpolants.length},get inUse(){return t._nActiveControlInterpolants}}}}_isActiveAction(t){let e=t._cacheIndex;return e!==null&&e<this._nActiveActions}_addInactiveAction(t,e,i){let r=this._actions,s=this._actionsByClip,o=s[e];if(o===void 0)o={knownActions:[t],actionByRoot:{}},t._byClipCacheIndex=0,s[e]=o;else{let a=o.knownActions;t._byClipCacheIndex=a.length,a.push(t)}t._cacheIndex=r.length,r.push(t),o.actionByRoot[i]=t}_removeInactiveAction(t){let e=this._actions,i=e[e.length-1],r=t._cacheIndex;i._cacheIndex=r,e[r]=i,e.pop(),t._cacheIndex=null;let s=t._clip.uuid,o=this._actionsByClip,a=o[s],l=a.knownActions,c=l[l.length-1],u=t._byClipCacheIndex;c._byClipCacheIndex=u,l[u]=c,l.pop(),t._byClipCacheIndex=null;let h=a.actionByRoot,f=(t._localRoot||this._root).uuid;delete h[f],l.length===0&&delete o[s],this._removeInactiveBindingsForAction(t)}_removeInactiveBindingsForAction(t){let e=t._propertyBindings;for(let i=0,r=e.length;i!==r;++i){let s=e[i];--s.referenceCount===0&&this._removeInactiveBinding(s)}}_lendAction(t){let e=this._actions,i=t._cacheIndex,r=this._nActiveActions++,s=e[r];t._cacheIndex=r,e[r]=t,s._cacheIndex=i,e[i]=s}_takeBackAction(t){let e=this._actions,i=t._cacheIndex,r=--this._nActiveActions,s=e[r];t._cacheIndex=r,e[r]=t,s._cacheIndex=i,e[i]=s}_addInactiveBinding(t,e,i){let r=this._bindingsByRootAndName,s=this._bindings,o=r[e];o===void 0&&(o={},r[e]=o),o[i]=t,t._cacheIndex=s.length,s.push(t)}_removeInactiveBinding(t){let e=this._bindings,i=t.binding,r=i.rootNode.uuid,s=i.path,o=this._bindingsByRootAndName,a=o[r],l=e[e.length-1],c=t._cacheIndex;l._cacheIndex=c,e[c]=l,e.pop(),delete a[s],Object.keys(a).length===0&&delete o[r]}_lendBinding(t){let e=this._bindings,i=t._cacheIndex,r=this._nActiveBindings++,s=e[r];t._cacheIndex=r,e[r]=t,s._cacheIndex=i,e[i]=s}_takeBackBinding(t){let e=this._bindings,i=t._cacheIndex,r=--this._nActiveBindings,s=e[r];t._cacheIndex=r,e[r]=t,s._cacheIndex=i,e[i]=s}_lendControlInterpolant(){let t=this._controlInterpolants,e=this._nActiveControlInterpolants++,i=t[e];return i===void 0&&(i=new _l(new Float32Array(2),new Float32Array(2),1,this._controlInterpolantsResultBuffer),i.__cacheIndex=e,t[e]=i),i}_takeBackControlInterpolant(t){let e=this._controlInterpolants,i=t.__cacheIndex,r=--this._nActiveControlInterpolants,s=e[r];t.__cacheIndex=r,e[r]=t,s.__cacheIndex=i,e[i]=s}clipAction(t,e,i){let r=e||this._root,s=r.uuid,o=typeof t=="string"?Ml.findByName(r,t):t,a=o!==null?o.uuid:t,l=this._actionsByClip[a],c=null;if(i===void 0&&(o!==null?i=o.blendMode:i=Qh),l!==void 0){let h=l.actionByRoot[s];if(h!==void 0&&h.blendMode===i)return h;c=l.knownActions[0],o===null&&(o=c._clip)}if(o===null)return null;let u=new Gh(this,o,e,i);return this._bindAction(u,c),this._addInactiveAction(u,a,s),u}existingAction(t,e){let i=e||this._root,r=i.uuid,s=typeof t=="string"?Ml.findByName(i,t):t,o=s?s.uuid:t,a=this._actionsByClip[o];return a!==void 0&&a.actionByRoot[r]||null}stopAllAction(){let t=this._actions,e=this._nActiveActions;for(let i=e-1;i>=0;--i)t[i].stop();return this}update(t){t*=this.timeScale;let e=this._actions,i=this._nActiveActions,r=this.time+=t,s=Math.sign(t),o=this._accuIndex^=1;for(let c=0;c!==i;++c)e[c]._update(r,t,s,o);let a=this._bindings,l=this._nActiveBindings;for(let c=0;c!==l;++c)a[c].apply(o);return this}setTime(t){this.time=0;for(let e=0;e<this._actions.length;e++)this._actions[e].time=0;return this.update(t)}getRoot(){return this._root}uncacheClip(t){let e=this._actions,i=t.uuid,r=this._actionsByClip,s=r[i];if(s!==void 0){let o=s.knownActions;for(let a=0,l=o.length;a!==l;++a){let c=o[a];this._deactivateAction(c);let u=c._cacheIndex,h=e[e.length-1];c._cacheIndex=null,c._byClipCacheIndex=null,h._cacheIndex=u,e[u]=h,e.pop(),this._removeInactiveBindingsForAction(c)}delete r[i]}}uncacheRoot(t){let e=t.uuid,i=this._actionsByClip;for(let o in i){let a=i[o].actionByRoot,l=a[e];l!==void 0&&(this._deactivateAction(l),this._removeInactiveAction(l))}let r=this._bindingsByRootAndName,s=r[e];if(s!==void 0)for(let o in s){let a=s[o];a.restoreOriginalState(),this._removeInactiveBinding(a)}}uncacheAction(t,e){let i=this.existingAction(t,e);i!==null&&(this._deactivateAction(i),this._removeInactiveAction(i))}};Wh.prototype._controlInterpolantsResultBuffer=new Float32Array(1);var To=class{constructor(t){typeof t=="string"&&(console.warn("THREE.Uniform: Type parameter is no longer needed."),t=arguments[1]),this.value=t}clone(){return new To(this.value.clone===void 0?this.value:this.value.clone())}},qh=class extends Gi{constructor(t,e,i=1){super(t,e),this.meshPerAttribute=i}copy(t){return super.copy(t),this.meshPerAttribute=t.meshPerAttribute,this}clone(t){let e=super.clone(t);return e.meshPerAttribute=this.meshPerAttribute,e}toJSON(t){let e=super.toJSON(t);return e.isInstancedInterleavedBuffer=!0,e.meshPerAttribute=this.meshPerAttribute,e}};qh.prototype.isInstancedInterleavedBuffer=!0;var Xh=class{constructor(t,e,i,r,s){this.buffer=t,this.type=e,this.itemSize=i,this.elementSize=r,this.count=s,this.version=0}set needsUpdate(t){t===!0&&this.version++}setBuffer(t){return this.buffer=t,this}setType(t,e){return this.type=t,this.elementSize=e,this}setItemSize(t){return this.itemSize=t,this}setCount(t){return this.count=t,this}};Xh.prototype.isGLBufferAttribute=!0;var o0=new K,Yi=class{constructor(t=new K(1/0,1/0),e=new K(-1/0,-1/0)){this.min=t,this.max=e}set(t,e){return this.min.copy(t),this.max.copy(e),this}setFromPoints(t){this.makeEmpty();for(let e=0,i=t.length;e<i;e++)this.expandByPoint(t[e]);return this}setFromCenterAndSize(t,e){let i=o0.copy(e).multiplyScalar(.5);return this.min.copy(t).sub(i),this.max.copy(t).add(i),this}clone(){return new this.constructor().copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=1/0,this.max.x=this.max.y=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y}getCenter(t){return this.isEmpty()?t.set(0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return this.isEmpty()?t.set(0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y}getParameter(t,e){return e.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y)}clampPoint(t,e){return e.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return o0.copy(t).clamp(this.min,this.max).sub(t).length()}intersect(t){return this.min.max(t.min),this.max.min(t.max),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}};Yi.prototype.isBox2=!0;var a0=new T,$a=new T,Yh=class{constructor(t=new T,e=new T){this.start=t,this.end=e}set(t,e){return this.start.copy(t),this.end.copy(e),this}copy(t){return this.start.copy(t.start),this.end.copy(t.end),this}getCenter(t){return t.addVectors(this.start,this.end).multiplyScalar(.5)}delta(t){return t.subVectors(this.end,this.start)}distanceSq(){return this.start.distanceToSquared(this.end)}distance(){return this.start.distanceTo(this.end)}at(t,e){return this.delta(e).multiplyScalar(t).add(this.start)}closestPointToPointParameter(t,e){a0.subVectors(t,this.start),$a.subVectors(this.end,this.start);let i=$a.dot($a),s=$a.dot(a0)/i;return e&&(s=Ie(s,0,1)),s}closestPointToPoint(t,e,i){let r=this.closestPointToPointParameter(t,e);return this.delta(i).multiplyScalar(r).add(this.start)}applyMatrix4(t){return this.start.applyMatrix4(t),this.end.applyMatrix4(t),this}equals(t){return t.start.equals(this.start)&&t.end.equals(this.end)}clone(){return new this.constructor().copy(this)}};var Qn=new T,Ka=new wt,Fu=new wt,Zh=class extends go{constructor(t){let e=D0(t),i=new Ht,r=[],s=[],o=new ft(0,0,1),a=new ft(0,1,0);for(let c=0;c<e.length;c++){let u=e[c];u.parent&&u.parent.isBone&&(r.push(0,0,0),r.push(0,0,0),s.push(o.r,o.g,o.b),s.push(a.r,a.g,a.b))}i.setAttribute("position",new ee(r,3)),i.setAttribute("color",new ee(s,3));let l=new zn({vertexColors:!0,depthTest:!1,depthWrite:!1,toneMapped:!1,transparent:!0});super(i,l),this.type="SkeletonHelper",this.isSkeletonHelper=!0,this.root=t,this.bones=e,this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1}updateMatrixWorld(t){let e=this.bones,i=this.geometry,r=i.getAttribute("position");Fu.copy(this.root.matrixWorld).invert();for(let s=0,o=0;s<e.length;s++){let a=e[s];a.parent&&a.parent.isBone&&(Ka.multiplyMatrices(Fu,a.matrixWorld),Qn.setFromMatrixPosition(Ka),r.setXYZ(o,Qn.x,Qn.y,Qn.z),Ka.multiplyMatrices(Fu,a.parent.matrixWorld),Qn.setFromMatrixPosition(Ka),r.setXYZ(o+1,Qn.x,Qn.y,Qn.z),o+=2)}i.getAttribute("position").needsUpdate=!0,super.updateMatrixWorld(t)}};function D0(n){let t=[];n&&n.isBone&&t.push(n);for(let e=0;e<n.children.length;e++)t.push.apply(t,D0(n.children[e]));return t}var Jh=class extends go{constructor(t=10,e=10,i=4473924,r=8947848){i=new ft(i),r=new ft(r);let s=e/2,o=t/e,a=t/2,l=[],c=[];for(let f=0,d=0,g=-a;f<=e;f++,g+=o){l.push(-a,0,g,a,0,g),l.push(g,0,-a,g,0,a);let x=f===s?i:r;x.toArray(c,d),d+=3,x.toArray(c,d),d+=3,x.toArray(c,d),d+=3,x.toArray(c,d),d+=3}let u=new Ht;u.setAttribute("position",new ee(l,3)),u.setAttribute("color",new ee(c,3));let h=new zn({vertexColors:!0,toneMapped:!1});super(u,h),this.type="GridHelper"}};var _T=new Float32Array(1),Ck=new Int32Array(_T.buffer);Fe.create=function(n,t){return console.log("THREE.Curve.create() has been deprecated"),n.prototype=Object.create(Fe.prototype),n.prototype.constructor=n,n.prototype.getPoint=t,n};_o.prototype.fromPoints=function(n){return console.warn("THREE.Path: .fromPoints() has been renamed to .setFromPoints()."),this.setFromPoints(n)};Jh.prototype.setColors=function(){console.error("THREE.GridHelper: setColors() has been deprecated, pass them in the constructor instead.")};Zh.prototype.update=function(){console.error("THREE.SkeletonHelper: update() no longer needs to be called.")};mn.prototype.extractUrlBase=function(n){return console.warn("THREE.Loader: .extractUrlBase() has been deprecated. Use THREE.LoaderUtils.extractUrlBase() instead."),Dh.extractUrlBase(n)};mn.Handlers={add:function(){console.error("THREE.Loader: Handlers.add() has been removed. Use LoadingManager.addHandler() instead.")},get:function(){console.error("THREE.Loader: Handlers.get() has been removed. Use LoadingManager.getHandler() instead.")}};Yi.prototype.center=function(n){return console.warn("THREE.Box2: .center() has been renamed to .getCenter()."),this.getCenter(n)};Yi.prototype.empty=function(){return console.warn("THREE.Box2: .empty() has been renamed to .isEmpty()."),this.isEmpty()};Yi.prototype.isIntersectionBox=function(n){return console.warn("THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(n)};Yi.prototype.size=function(n){return console.warn("THREE.Box2: .size() has been renamed to .getSize()."),this.getSize(n)};Ge.prototype.center=function(n){return console.warn("THREE.Box3: .center() has been renamed to .getCenter()."),this.getCenter(n)};Ge.prototype.empty=function(){return console.warn("THREE.Box3: .empty() has been renamed to .isEmpty()."),this.isEmpty()};Ge.prototype.isIntersectionBox=function(n){return console.warn("THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(n)};Ge.prototype.isIntersectionSphere=function(n){return console.warn("THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(n)};Ge.prototype.size=function(n){return console.warn("THREE.Box3: .size() has been renamed to .getSize()."),this.getSize(n)};si.prototype.empty=function(){return console.warn("THREE.Sphere: .empty() has been renamed to .isEmpty()."),this.isEmpty()};qr.prototype.setFromMatrix=function(n){return console.warn("THREE.Frustum: .setFromMatrix() has been renamed to .setFromProjectionMatrix()."),this.setFromProjectionMatrix(n)};Yh.prototype.center=function(n){return console.warn("THREE.Line3: .center() has been renamed to .getCenter()."),this.getCenter(n)};de.prototype.flattenToArrayOffset=function(n,t){return console.warn("THREE.Matrix3: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(n,t)};de.prototype.multiplyVector3=function(n){return console.warn("THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead."),n.applyMatrix3(this)};de.prototype.multiplyVector3Array=function(){console.error("THREE.Matrix3: .multiplyVector3Array() has been removed.")};de.prototype.applyToBufferAttribute=function(n){return console.warn("THREE.Matrix3: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix3( matrix ) instead."),n.applyMatrix3(this)};de.prototype.applyToVector3Array=function(){console.error("THREE.Matrix3: .applyToVector3Array() has been removed.")};de.prototype.getInverse=function(n){return console.warn("THREE.Matrix3: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(n).invert()};wt.prototype.extractPosition=function(n){return console.warn("THREE.Matrix4: .extractPosition() has been renamed to .copyPosition()."),this.copyPosition(n)};wt.prototype.flattenToArrayOffset=function(n,t){return console.warn("THREE.Matrix4: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(n,t)};wt.prototype.getPosition=function(){return console.warn("THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead."),new T().setFromMatrixColumn(this,3)};wt.prototype.setRotationFromQuaternion=function(n){return console.warn("THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion()."),this.makeRotationFromQuaternion(n)};wt.prototype.multiplyToArray=function(){console.warn("THREE.Matrix4: .multiplyToArray() has been removed.")};wt.prototype.multiplyVector3=function(n){return console.warn("THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)};wt.prototype.multiplyVector4=function(n){return console.warn("THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)};wt.prototype.multiplyVector3Array=function(){console.error("THREE.Matrix4: .multiplyVector3Array() has been removed.")};wt.prototype.rotateAxis=function(n){console.warn("THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead."),n.transformDirection(this)};wt.prototype.crossVector=function(n){return console.warn("THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)};wt.prototype.translate=function(){console.error("THREE.Matrix4: .translate() has been removed.")};wt.prototype.rotateX=function(){console.error("THREE.Matrix4: .rotateX() has been removed.")};wt.prototype.rotateY=function(){console.error("THREE.Matrix4: .rotateY() has been removed.")};wt.prototype.rotateZ=function(){console.error("THREE.Matrix4: .rotateZ() has been removed.")};wt.prototype.rotateByAxis=function(){console.error("THREE.Matrix4: .rotateByAxis() has been removed.")};wt.prototype.applyToBufferAttribute=function(n){return console.warn("THREE.Matrix4: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)};wt.prototype.applyToVector3Array=function(){console.error("THREE.Matrix4: .applyToVector3Array() has been removed.")};wt.prototype.makeFrustum=function(n,t,e,i,r,s){return console.warn("THREE.Matrix4: .makeFrustum() has been removed. Use .makePerspective( left, right, top, bottom, near, far ) instead."),this.makePerspective(n,t,i,e,r,s)};wt.prototype.getInverse=function(n){return console.warn("THREE.Matrix4: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(n).invert()};je.prototype.isIntersectionLine=function(n){return console.warn("THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine()."),this.intersectsLine(n)};Ee.prototype.multiplyVector3=function(n){return console.warn("THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead."),n.applyQuaternion(this)};Ee.prototype.inverse=function(){return console.warn("THREE.Quaternion: .inverse() has been renamed to invert()."),this.invert()};oi.prototype.isIntersectionBox=function(n){return console.warn("THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(n)};oi.prototype.isIntersectionPlane=function(n){return console.warn("THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane()."),this.intersectsPlane(n)};oi.prototype.isIntersectionSphere=function(n){return console.warn("THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(n)};re.prototype.area=function(){return console.warn("THREE.Triangle: .area() has been renamed to .getArea()."),this.getArea()};re.prototype.barycoordFromPoint=function(n,t){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),this.getBarycoord(n,t)};re.prototype.midpoint=function(n){return console.warn("THREE.Triangle: .midpoint() has been renamed to .getMidpoint()."),this.getMidpoint(n)};re.prototypenormal=function(n){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),this.getNormal(n)};re.prototype.plane=function(n){return console.warn("THREE.Triangle: .plane() has been renamed to .getPlane()."),this.getPlane(n)};re.barycoordFromPoint=function(n,t,e,i,r){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),re.getBarycoord(n,t,e,i,r)};re.normal=function(n,t,e,i){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),re.getNormal(n,t,e,i)};Un.prototype.extractAllPoints=function(n){return console.warn("THREE.Shape: .extractAllPoints() has been removed. Use .extractPoints() instead."),this.extractPoints(n)};Un.prototype.extrude=function(n){return console.warn("THREE.Shape: .extrude() has been removed. Use ExtrudeGeometry() instead."),new ci(this,n)};Un.prototype.makeGeometry=function(n){return console.warn("THREE.Shape: .makeGeometry() has been removed. Use ShapeGeometry() instead."),new qi(this,n)};K.prototype.fromAttribute=function(n,t,e){return console.warn("THREE.Vector2: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(n,t,e)};K.prototype.distanceToManhattan=function(n){return console.warn("THREE.Vector2: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(n)};K.prototype.lengthManhattan=function(){return console.warn("THREE.Vector2: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()};T.prototype.setEulerFromRotationMatrix=function(){console.error("THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.")};T.prototype.setEulerFromQuaternion=function(){console.error("THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.")};T.prototype.getPositionFromMatrix=function(n){return console.warn("THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition()."),this.setFromMatrixPosition(n)};T.prototype.getScaleFromMatrix=function(n){return console.warn("THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale()."),this.setFromMatrixScale(n)};T.prototype.getColumnFromMatrix=function(n,t){return console.warn("THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn()."),this.setFromMatrixColumn(t,n)};T.prototype.applyProjection=function(n){return console.warn("THREE.Vector3: .applyProjection() has been removed. Use .applyMatrix4( m ) instead."),this.applyMatrix4(n)};T.prototype.fromAttribute=function(n,t,e){return console.warn("THREE.Vector3: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(n,t,e)};T.prototype.distanceToManhattan=function(n){return console.warn("THREE.Vector3: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(n)};T.prototype.lengthManhattan=function(){return console.warn("THREE.Vector3: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()};Wt.prototype.fromAttribute=function(n,t,e){return console.warn("THREE.Vector4: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(n,t,e)};Wt.prototype.lengthManhattan=function(){return console.warn("THREE.Vector4: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()};kt.prototype.getChildByName=function(n){return console.warn("THREE.Object3D: .getChildByName() has been renamed to .getObjectByName()."),this.getObjectByName(n)};kt.prototype.renderDepth=function(){console.warn("THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.")};kt.prototype.translate=function(n,t){return console.warn("THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead."),this.translateOnAxis(t,n)};kt.prototype.getWorldRotation=function(){console.error("THREE.Object3D: .getWorldRotation() has been removed. Use THREE.Object3D.getWorldQuaternion( target ) instead.")};kt.prototype.applyMatrix=function(n){return console.warn("THREE.Object3D: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(n)};Object.defineProperties(kt.prototype,{eulerOrder:{get:function(){return console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order},set:function(n){console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order=n}},useQuaternion:{get:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")},set:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")}}});oe.prototype.setDrawMode=function(){console.error("THREE.Mesh: .setDrawMode() has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")};Object.defineProperties(oe.prototype,{drawMode:{get:function(){return console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode."),$w},set:function(){console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")}}});dl.prototype.initBones=function(){console.error("THREE.SkinnedMesh: initBones() has been removed.")};Se.prototype.setLens=function(n,t){console.warn("THREE.PerspectiveCamera.setLens is deprecated. Use .setFocalLength and .filmGauge for a photographic setup."),t!==void 0&&(this.filmGauge=t),this.setFocalLength(n)};Object.defineProperties(Ye.prototype,{onlyShadow:{set:function(){console.warn("THREE.Light: .onlyShadow has been removed.")}},shadowCameraFov:{set:function(n){console.warn("THREE.Light: .shadowCameraFov is now .shadow.camera.fov."),this.shadow.camera.fov=n}},shadowCameraLeft:{set:function(n){console.warn("THREE.Light: .shadowCameraLeft is now .shadow.camera.left."),this.shadow.camera.left=n}},shadowCameraRight:{set:function(n){console.warn("THREE.Light: .shadowCameraRight is now .shadow.camera.right."),this.shadow.camera.right=n}},shadowCameraTop:{set:function(n){console.warn("THREE.Light: .shadowCameraTop is now .shadow.camera.top."),this.shadow.camera.top=n}},shadowCameraBottom:{set:function(n){console.warn("THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom."),this.shadow.camera.bottom=n}},shadowCameraNear:{set:function(n){console.warn("THREE.Light: .shadowCameraNear is now .shadow.camera.near."),this.shadow.camera.near=n}},shadowCameraFar:{set:function(n){console.warn("THREE.Light: .shadowCameraFar is now .shadow.camera.far."),this.shadow.camera.far=n}},shadowCameraVisible:{set:function(){console.warn("THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.")}},shadowBias:{set:function(n){console.warn("THREE.Light: .shadowBias is now .shadow.bias."),this.shadow.bias=n}},shadowDarkness:{set:function(){console.warn("THREE.Light: .shadowDarkness has been removed.")}},shadowMapWidth:{set:function(n){console.warn("THREE.Light: .shadowMapWidth is now .shadow.mapSize.width."),this.shadow.mapSize.width=n}},shadowMapHeight:{set:function(n){console.warn("THREE.Light: .shadowMapHeight is now .shadow.mapSize.height."),this.shadow.mapSize.height=n}}});Object.defineProperties(Qt.prototype,{length:{get:function(){return console.warn("THREE.BufferAttribute: .length has been deprecated. Use .count instead."),this.array.length}},dynamic:{get:function(){return console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.usage===nl},set:function(){console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.setUsage(nl)}}});Qt.prototype.setDynamic=function(n){return console.warn("THREE.BufferAttribute: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(n===!0?nl:io),this};Qt.prototype.copyIndicesArray=function(){console.error("THREE.BufferAttribute: .copyIndicesArray() has been removed.")},Qt.prototype.setArray=function(){console.error("THREE.BufferAttribute: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")};Ht.prototype.addIndex=function(n){console.warn("THREE.BufferGeometry: .addIndex() has been renamed to .setIndex()."),this.setIndex(n)};Ht.prototype.addAttribute=function(n,t){return console.warn("THREE.BufferGeometry: .addAttribute() has been renamed to .setAttribute()."),!(t&&t.isBufferAttribute)&&!(t&&t.isInterleavedBufferAttribute)?(console.warn("THREE.BufferGeometry: .addAttribute() now expects ( name, attribute )."),this.setAttribute(n,new Qt(arguments[1],arguments[2]))):n==="index"?(console.warn("THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute."),this.setIndex(t),this):this.setAttribute(n,t)};Ht.prototype.addDrawCall=function(n,t,e){e!==void 0&&console.warn("THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset."),console.warn("THREE.BufferGeometry: .addDrawCall() is now .addGroup()."),this.addGroup(n,t)};Ht.prototype.clearDrawCalls=function(){console.warn("THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups()."),this.clearGroups()};Ht.prototype.computeOffsets=function(){console.warn("THREE.BufferGeometry: .computeOffsets() has been removed.")};Ht.prototype.removeAttribute=function(n){return console.warn("THREE.BufferGeometry: .removeAttribute() has been renamed to .deleteAttribute()."),this.deleteAttribute(n)};Ht.prototype.applyMatrix=function(n){return console.warn("THREE.BufferGeometry: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(n)};Object.defineProperties(Ht.prototype,{drawcalls:{get:function(){return console.error("THREE.BufferGeometry: .drawcalls has been renamed to .groups."),this.groups}},offsets:{get:function(){return console.warn("THREE.BufferGeometry: .offsets has been renamed to .groups."),this.groups}}});Gi.prototype.setDynamic=function(n){return console.warn("THREE.InterleavedBuffer: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(n===!0?nl:io),this};Gi.prototype.setArray=function(){console.error("THREE.InterleavedBuffer: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")};ci.prototype.getArrays=function(){console.error("THREE.ExtrudeGeometry: .getArrays() has been removed.")};ci.prototype.addShapeList=function(){console.error("THREE.ExtrudeGeometry: .addShapeList() has been removed.")};ci.prototype.addShape=function(){console.error("THREE.ExtrudeGeometry: .addShape() has been removed.")};Yr.prototype.dispose=function(){console.error("THREE.Scene: .dispose() has been removed.")};To.prototype.onUpdate=function(){return console.warn("THREE.Uniform: .onUpdate() has been removed. Use object.onBeforeRender() instead."),this};Object.defineProperties(xe.prototype,{wrapAround:{get:function(){console.warn("THREE.Material: .wrapAround has been removed.")},set:function(){console.warn("THREE.Material: .wrapAround has been removed.")}},overdraw:{get:function(){console.warn("THREE.Material: .overdraw has been removed.")},set:function(){console.warn("THREE.Material: .overdraw has been removed.")}},wrapRGB:{get:function(){return console.warn("THREE.Material: .wrapRGB has been removed."),new ft}},shading:{get:function(){console.error("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead.")},set:function(n){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=n===c0}},stencilMask:{get:function(){return console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask},set:function(n){console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask=n}},vertexTangents:{get:function(){console.warn("THREE."+this.type+": .vertexTangents has been removed.")},set:function(){console.warn("THREE."+this.type+": .vertexTangents has been removed.")}}});Object.defineProperties(Fn.prototype,{derivatives:{get:function(){return console.warn("THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives},set:function(n){console.warn("THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives=n}}});Vt.prototype.clearTarget=function(n,t,e,i){console.warn("THREE.WebGLRenderer: .clearTarget() has been deprecated. Use .setRenderTarget() and .clear() instead."),this.setRenderTarget(n),this.clear(t,e,i)};Vt.prototype.animate=function(n){console.warn("THREE.WebGLRenderer: .animate() is now .setAnimationLoop()."),this.setAnimationLoop(n)};Vt.prototype.getCurrentRenderTarget=function(){return console.warn("THREE.WebGLRenderer: .getCurrentRenderTarget() is now .getRenderTarget()."),this.getRenderTarget()};Vt.prototype.getMaxAnisotropy=function(){return console.warn("THREE.WebGLRenderer: .getMaxAnisotropy() is now .capabilities.getMaxAnisotropy()."),this.capabilities.getMaxAnisotropy()};Vt.prototype.getPrecision=function(){return console.warn("THREE.WebGLRenderer: .getPrecision() is now .capabilities.precision."),this.capabilities.precision};Vt.prototype.resetGLState=function(){return console.warn("THREE.WebGLRenderer: .resetGLState() is now .state.reset()."),this.state.reset()};Vt.prototype.supportsFloatTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( 'OES_texture_float' )."),this.extensions.get("OES_texture_float")};Vt.prototype.supportsHalfFloatTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( 'OES_texture_half_float' )."),this.extensions.get("OES_texture_half_float")};Vt.prototype.supportsStandardDerivatives=function(){return console.warn("THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( 'OES_standard_derivatives' )."),this.extensions.get("OES_standard_derivatives")};Vt.prototype.supportsCompressedTextureS3TC=function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( 'WEBGL_compressed_texture_s3tc' )."),this.extensions.get("WEBGL_compressed_texture_s3tc")};Vt.prototype.supportsCompressedTexturePVRTC=function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( 'WEBGL_compressed_texture_pvrtc' )."),this.extensions.get("WEBGL_compressed_texture_pvrtc")};Vt.prototype.supportsBlendMinMax=function(){return console.warn("THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( 'EXT_blend_minmax' )."),this.extensions.get("EXT_blend_minmax")};Vt.prototype.supportsVertexTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsVertexTextures() is now .capabilities.vertexTextures."),this.capabilities.vertexTextures};Vt.prototype.supportsInstancedArrays=function(){return console.warn("THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( 'ANGLE_instanced_arrays' )."),this.extensions.get("ANGLE_instanced_arrays")};Vt.prototype.enableScissorTest=function(n){console.warn("THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest()."),this.setScissorTest(n)};Vt.prototype.initMaterial=function(){console.warn("THREE.WebGLRenderer: .initMaterial() has been removed.")};Vt.prototype.addPrePlugin=function(){console.warn("THREE.WebGLRenderer: .addPrePlugin() has been removed.")};Vt.prototype.addPostPlugin=function(){console.warn("THREE.WebGLRenderer: .addPostPlugin() has been removed.")};Vt.prototype.updateShadowMap=function(){console.warn("THREE.WebGLRenderer: .updateShadowMap() has been removed.")};Vt.prototype.setFaceCulling=function(){console.warn("THREE.WebGLRenderer: .setFaceCulling() has been removed.")};Vt.prototype.allocTextureUnit=function(){console.warn("THREE.WebGLRenderer: .allocTextureUnit() has been removed.")};Vt.prototype.setTexture=function(){console.warn("THREE.WebGLRenderer: .setTexture() has been removed.")};Vt.prototype.setTexture2D=function(){console.warn("THREE.WebGLRenderer: .setTexture2D() has been removed.")};Vt.prototype.setTextureCube=function(){console.warn("THREE.WebGLRenderer: .setTextureCube() has been removed.")};Vt.prototype.getActiveMipMapLevel=function(){return console.warn("THREE.WebGLRenderer: .getActiveMipMapLevel() is now .getActiveMipmapLevel()."),this.getActiveMipmapLevel()};Object.defineProperties(Vt.prototype,{shadowMapEnabled:{get:function(){return this.shadowMap.enabled},set:function(n){console.warn("THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled."),this.shadowMap.enabled=n}},shadowMapType:{get:function(){return this.shadowMap.type},set:function(n){console.warn("THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type."),this.shadowMap.type=n}},shadowMapCullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")}},context:{get:function(){return console.warn("THREE.WebGLRenderer: .context has been removed. Use .getContext() instead."),this.getContext()}},vr:{get:function(){return console.warn("THREE.WebGLRenderer: .vr has been renamed to .xr"),this.xr}},gammaInput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead."),!1},set:function(){console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead.")}},gammaOutput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),!1},set:function(n){console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),this.outputEncoding=n===!0?$t:ri}},toneMappingWhitePoint:{get:function(){return console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed."),1},set:function(){console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed.")}},gammaFactor:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaFactor has been removed."),2},set:function(){console.warn("THREE.WebGLRenderer: .gammaFactor has been removed.")}}});Object.defineProperties(T0.prototype,{cullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")}},renderReverseSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")}},renderSingleSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")}}});Object.defineProperties(Ne.prototype,{wrapS:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS},set:function(n){console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS=n}},wrapT:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT},set:function(n){console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT=n}},magFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter},set:function(n){console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter=n}},minFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter},set:function(n){console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter=n}},anisotropy:{get:function(){return console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy},set:function(n){console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy=n}},offset:{get:function(){return console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset},set:function(n){console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset=n}},repeat:{get:function(){return console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat},set:function(n){console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat=n}},format:{get:function(){return console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format},set:function(n){console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format=n}},type:{get:function(){return console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type},set:function(n){console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type=n}},generateMipmaps:{get:function(){return console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps},set:function(n){console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps=n}}});Bh.prototype.load=function(n){console.warn("THREE.Audio: .load has been deprecated. Use THREE.AudioLoader instead.");let t=this;return new Fh().load(n,function(i){t.setBuffer(i)}),this};Oh.prototype.getData=function(){return console.warn("THREE.AudioAnalyser: .getData() is now .getFrequencyData()."),this.getFrequencyData()};ao.prototype.updateCubeMap=function(n,t){return console.warn("THREE.CubeCamera: .updateCubeMap() is now .update()."),this.update(n,t)};ao.prototype.clear=function(n,t,e,i){return console.warn("THREE.CubeCamera: .clear() is now .renderTarget.clear()."),this.renderTarget.clear(n,t,e,i)};Nn.crossOrigin=void 0;Nn.loadTexture=function(n,t,e,i){console.warn("THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.");let r=new Eh;r.setCrossOrigin(this.crossOrigin);let s=r.load(n,e,void 0,i);return t&&(s.mapping=t),s};Nn.loadTextureCube=function(n,t,e,i){console.warn("THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.");let r=new Sh;r.setCrossOrigin(this.crossOrigin);let s=r.load(n,e,void 0,i);return t&&(s.mapping=t),s};Nn.loadCompressedTexture=function(){console.error("THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.")};Nn.loadCompressedTextureCube=function(){console.error("THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.")};typeof __THREE_DEVTOOLS__!="undefined"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("register",{detail:{revision:$h}}));typeof window!="undefined"&&(window.__THREE__?console.warn("WARNING: Multiple instances of Three.js being imported."):window.__THREE__=$h);function rf(n,t,e){if(e===1)return new ft(t);let i=pi(t);if(!i)throw new Error(`d3 failed to recognize the color: ${t}`);return new ft(sc(i,n)(1-e))}var gn;(function(n){n[n.CIRCLE=0]="CIRCLE",n[n.LINE=1]="LINE",n[n.TRIANGLE=2]="TRIANGLE",n[n.TRAPEZOID=3]="TRAPEZOID"})(gn||(gn={}));function N0(n,t){let e=t.length/2,i=n.attributes.position;(!i||i.count!==e*3)&&(i=new Qt(new Float32Array(e*3),3),n.setAttribute("position",i));let r=i.array;for(let s=0;s<e;s++)r[s*3]=t[s*2],r[s*3+1]=t[s*2+1];i.needsUpdate=!0,n.setDrawRange(0,e*3),n.computeBoundingSphere()}function F0(n,t,e){let i=Math.max(t.length/2-1,0),r=i*2*3,s=r*3,o=n.attributes.position;(!o||o.count!==r)&&(o=new Qt(new Float32Array(s),3),n.setAttribute("position",o));let a=o.array;for(let l=0;l<i;l++){let[c,u,h,f]=[t[2*l],t[2*l+1],t[2*l+2],t[2*l+3]],d=new K(c,u),g=new K(h,f),x=new K(h-c,f-u),v=new K(-x.y,x.x).setLength(e/2),m=d.clone().add(v),p=d.clone().sub(v),b=g.clone().add(v),_=g.clone().sub(v),S=[m.x,m.y,0,p.x,p.y,0,b.x,b.y,0,b.x,b.y,0,p.x,p.y,0,_.x,_.y,0];a.set(S,l*S.length)}o.needsUpdate=!0,n.setDrawRange(0,s),n.computeBoundingSphere()}function Il(n,t,e,i){let{visible:r,color:s,opacity:o}=i;if(Array.isArray(t.material))throw new Error("Invariant error: only expect one material on an object");let a=t.material;if(a.visible!==r&&(a.visible=r,a.needsUpdate=!0),!r)return!1;let l=rf(n,s,o!=null?o:1),c=e(t.geometry);return t.geometry!==c&&(t.geometry=c),a.color.equals(l)||(a.color.set(l),a.needsUpdate=!0),!0}var wT={createScene:()=>new Yr},Ro=class{constructor(t,e,i,r){this.coordinator=e,this.scene=wT.createScene(),this.backgroundColor="#fff",Di.isOffscreenCanvasSupported()&&t instanceof OffscreenCanvas&&(t.style=t.style||{}),r&&t.addEventListener("webglcontextlost",r),this.renderer=new Vt({canvas:t,antialias:!0,alpha:!0}),this.renderer.setPixelRatio(i)}onResize(t){this.renderer.setSize(t.width,t.height)}destroyObject(t){let e=t.obj3d;if(this.scene.remove(e),e instanceof oe){e.geometry.dispose();let i=Array.isArray(e.material)?e.material:[e.material];for(let r of i)r.dispose()}}setUseDarkMode(t){this.backgroundColor=t?"#303030":"#fff"}createOrUpdateLineObject(t,e,i){var u;if(!t&&!i.visible)return null;let{visible:r,width:s}=i;if(!t){let h=rf(this.backgroundColor,i.color,(u=i.opacity)!=null?u:1),f=new Ht,d=new zn({color:h}),g=new oe(f,d);return d.visible=r,F0(f,e,s),this.scene.add(g),{type:gn.LINE,data:e,obj3d:g,width:s}}let{data:o,obj3d:a,width:l}=t;return Il(this.backgroundColor,a,h=>((s!==l||!o||!Di.arePolylinesEqual(o,e))&&F0(h,e,s),h),i)?{type:gn.LINE,data:e,obj3d:a,width:s}:t}createMesh(t,e){if(!e.visible)return null;let{visible:i,color:r,opacity:s}=e,o=rf(this.backgroundColor,r,s!=null?s:1),a=new ki({color:o,visible:i});return new oe(t,a)}createOrUpdateTriangleObject(t,e,i){let{size:r}=i,s=r*Math.sqrt(3)/2,o=new Float32Array([e.x-r/2,e.y-s/3,e.x+r/2,e.y-s/3,e.x,e.y+s*2/3]);if(!t){let l=new Ht;N0(l,o);let c=this.createMesh(l,i);return c===null?null:(this.scene.add(c),{type:gn.TRIANGLE,data:e,obj3d:c})}return Il(this.backgroundColor,t.obj3d,l=>(N0(l,o),l),i)?{type:gn.TRIANGLE,data:e,obj3d:t.obj3d}:t}createOrUpdateCircleObject(t,e,i){let{radius:r}=i,s=new Zr(i.radius);if(!t){let a=this.createMesh(s,i);return a===null?null:(a.position.set(e.x,e.y,0),this.scene.add(a),{type:gn.CIRCLE,data:{loc:e,radius:r},obj3d:a})}return Il(this.backgroundColor,t.obj3d,()=>s,i)?(t.obj3d.position.set(e.x,e.y,0),{type:gn.CIRCLE,data:{loc:e,radius:r},obj3d:t.obj3d}):t}createOrUpdateTrapezoidObject(t,e,i,r){if(e.y!==i.y)throw new RangeError("Input error: start.y != end.y.");let{altitude:s}=r,o=2/Math.sqrt(3)*s,a=new Un([new K(e.x-o/2,e.y-s/2),new K(e.x,e.y+s/2),new K(i.x,i.y+s/2),new K(i.x+o/2,i.y-s/2)]);a.autoClose=!0;let l=new qi(a);if(!t){let u=this.createMesh(l,r);return u===null?null:(this.scene.add(u),{type:gn.TRAPEZOID,data:[e,i],obj3d:u})}return Il(this.backgroundColor,t.obj3d,()=>l,r)?{type:gn.TRAPEZOID,data:[e,i],obj3d:t.obj3d}:t}flush(){this.renderer.render(this.scene,this.coordinator.getCamera())}dispose(){this.renderer.dispose()}};var Nl=class{constructor(t,e){this.renderCache=t,this.renderer=e}setLine(t,e,i){let r=this.renderer.createOrUpdateLineObject(this.renderCache.getFromPreviousFrame(t),e,i);r&&this.renderCache.setToCurrentFrame(t,r)}setTriangle(t,e,i){let r=this.renderer.createOrUpdateTriangleObject(this.renderCache.getFromPreviousFrame(t),e,i);r&&this.renderCache.setToCurrentFrame(t,r)}setCircle(t,e,i){let r=this.renderer.createOrUpdateCircleObject(this.renderCache.getFromPreviousFrame(t),e,i);r&&this.renderCache.setToCurrentFrame(t,r)}setTrapezoid(t,e,i,r){let s=this.renderer.createOrUpdateTrapezoidObject(this.renderCache.getFromPreviousFrame(t),e,i,r);s&&this.renderCache.setToCurrentFrame(t,s)}};var sf=class{constructor(){this.prevFrameCache=new Map,this.currFrameCache=new Map}getFromPreviousFrame(t){let e=this.prevFrameCache.get(t);return e!=null?e:null}setToCurrentFrame(t,e){this.currFrameCache.set(t,e)}finalizeFrameAndGetRemoved(){let t=[];for(let[e,i]of this.prevFrameCache.entries())this.currFrameCache.has(e)||t.push(i);return this.prevFrameCache=this.currFrameCache,this.currFrameCache=new Map,t}},Fl=class{constructor(t){this.rawSeriesData=[],this.series=[],this.paintDirty=!0,this.renderCache=new sf,this.coordinateIdentifier=null,this.layout={x:0,width:1,y:0,height:1},this.getMetadataMapImpl=t.getMetadataMap,this.coordinator=t.coordinator,this.renderer=t.renderer,this.paintBrush=new Nl(this.renderCache,this.renderer)}setLayoutRect(t){(this.layout.x!==t.x||this.layout.width!==t.width||this.layout.y!==t.y||this.layout.height!==t.height)&&(this.paintDirty=!0),this.layout=t}getLayoutRect(){return this.layout}getMetadataMap(){return this.getMetadataMapImpl()}markAsPaintDirty(){this.paintDirty=!0}render(){if(this.transformCoordinatesIfStale(),!!this.paintDirty){this.redraw();for(let t of this.renderCache.finalizeFrameAndGetRemoved())this.renderer.destroyObject(t);this.paintDirty=!1}}isCoordinateUpdated(){return this.coordinator.getUpdateIdentifier()!==this.coordinateIdentifier}clearCoordinateIdentifier(){this.coordinateIdentifier=null}setData(t){this.clearCoordinateIdentifier(),this.rawSeriesData=t}transformCoordinatesIfStale(){if(!this.isCoordinateUpdated())return;let t=this.getLayoutRect();this.series=new Array(this.rawSeriesData.length);for(let e=0;e<this.rawSeriesData.length;e++){let i=this.rawSeriesData[e];this.series[e]={id:i.id,polyline:new Float32Array(i.points.length*2)};for(let r=0;r<i.points.length;r++){let[s,o]=this.coordinator.transformDataToUiCoord(t,[i.points[r].x,i.points[r].y]);this.series[e].polyline[r*2]=s,this.series[e].polyline[r*2+1]=o}}this.coordinateIdentifier=this.coordinator.getUpdateIdentifier(),this.markAsPaintDirty()}};var Lo;(function(n){n[n.NUMBER=0]="NUMBER",n[n.NAN=1]="NAN"})(Lo||(Lo={}));var zl=class extends Fl{recordPartition(t,e,i){return t?{type:Lo.NUMBER,polyline:e}:{type:Lo.NAN,polyline:e.map((r,s)=>isNaN(r)?s%2===0?i.x:i.y:r)}}partitionPolyline(t){let e=[],i=0,r=!1,s=this.coordinator.transformDataToUiCoord(this.getLayoutRect(),[0,0]),o={x:s[0],y:s[1]},a=null;for(let l=0;l<t.length;l+=2){let c=t[l],u=t[l+1],h=isNaN(c)||isNaN(u);h!==r&&i!==l&&(e.push(this.recordPartition(!r,t.slice(i,l),a===null?{x:c,y:u}:a)),i=l),h||(a={x:c,y:u}),r=h}return i!==t.length-1&&e.push(this.recordPartition(!r,t.slice(i,t.length),a!=null?a:o)),e}redraw(){var t,e,i;for(let r of this.series){let o=this.getMetadataMap()[r.id];if(!o)continue;if(r.polyline.length%2!==0)throw new Error(`Cannot have odd length-ed polyline: ${r.polyline.length}`);let a=this.partitionPolyline(r.polyline);for(let[l,{type:c,polyline:u}]of a.entries())if(c===Lo.NUMBER)u.length===2?this.paintBrush.setCircle(JSON.stringify(["circle",r.id,l]),{x:u[0],y:u[1]},{color:o.color,visible:o.visible,opacity:(t=o.opacity)!=null?t:1,radius:4}):this.paintBrush.setLine(JSON.stringify(["line",r.id,l]),u,{color:o.color,visible:o.visible,opacity:(e=o.opacity)!=null?e:1,width:2});else if(!o.aux)for(let h=0;h<u.length;h+=2)this.paintBrush.setTriangle(JSON.stringify(["NaN",r.id,u[h],u[h+1]]),{x:u[h],y:u[h+1]},{color:o.color,visible:o.visible,opacity:(i=o.opacity)!=null?i:1,size:12})}}};var Ul=class extends dr{constructor(){super(...arguments),this.camera=new Vi(0,1e3,1e3,0,0,100)}isYAxisPointedDown(){return!1}setDomContainerRect(t){super.setDomContainerRect(t),this.camera.left=t.x,this.camera.right=t.x+t.width,this.camera.top=t.y+t.height,this.camera.bottom=t.y,this.camera.updateProjectionMatrix()}getCamera(){return this.camera}};var MT={requestAnimationFrame:n=>self.requestAnimationFrame(n)},Bl=class{constructor(t){switch(this.metadataMap={},this.shouldRepaint=!1,this.callbacks=t.callbacks,t.type){case Tn.SVG:{this.coordinator=new dr,this.renderer=new Os(t.container);break}case Tn.WEBGL:{let e=new Ul;this.coordinator=e,this.renderer=new Ro(t.container,e,t.devicePixelRatio,t.callbacks.onContextLost);break}}this.renderer.setUseDarkMode(t.useDarkMode),this.seriesLineView=new zl({renderer:this.renderer,coordinator:this.coordinator,getMetadataMap:()=>this.metadataMap}),this.resize(t.domDimension)}dispose(){}setXScaleType(t){this.coordinator.setXScale(fr(t)),this.scheduleRepaint()}setYScaleType(t){this.coordinator.setYScale(fr(t)),this.scheduleRepaint()}resize(t){this.coordinator.setDomContainerRect(No({x:0,y:0},t)),this.renderer.onResize(No({x:0,y:0},t)),this.seriesLineView.setLayoutRect(uf(No({},t),{x:0,y:0})),this.scheduleRepaint()}setMetadata(t){let e=!1;Object.entries(t).forEach(([i,r])=>{let s=this.metadataMap[i];(!s||r.color!==s.color||r.visible!==s.visible||r.opacity!==s.opacity)&&(e=!0),this.metadataMap[i]=r}),e&&this.seriesLineView.markAsPaintDirty(),this.scheduleRepaint()}setViewBox(t){this.coordinator.setViewBoxRect({x:t.x[0],width:t.x[1]-t.x[0],y:t.y[0],height:t.y[1]-t.y[0]}),this.scheduleRepaint()}setData(t){this.seriesLineView.setData(t),this.scheduleRepaint()}setUseDarkMode(t){this.renderer.setUseDarkMode(t),this.seriesLineView.markAsPaintDirty(),this.scheduleRepaint()}scheduleRepaint(){this.shouldRepaint||(this.shouldRepaint=!0,MT.requestAnimationFrame(()=>{this.repaint(),this.shouldRepaint=!1}))}repaint(){this.seriesLineView.render(),this.renderer.flush(),this.callbacks.onDrawEnd()}};function z0(n){let{flattenedSeries:t,idsAndLengths:e}=n,i=new Float64Array(t),r=[];if(i.length%2!==0)throw new Error("`flattenedSeries` must have even number of elements");let s=0;for(let{id:o,length:a}of e){let l=[];for(let c=0;c<a;c++)l.push({x:i[s++],y:i[s++]});r.push({id:o,points:l})}return r}var xn;(function(n){n[n.SERIES_DATA_UPDATED=0]="SERIES_DATA_UPDATED",n[n.SERIES_METADATA_CHANGED=1]="SERIES_METADATA_CHANGED",n[n.SCALE_UPDATED=2]="SCALE_UPDATED",n[n.VIEW_BOX_UPDATED=3]="VIEW_BOX_UPDATED",n[n.INIT=4]="INIT",n[n.DOM_RESIZED=5]="DOM_RESIZED",n[n.DARK_MODE_UPDATED=6]="DARK_MODE_UPDATED",n[n.DISPOSED=7]="DISPOSED"})(xn||(xn={}));var Po;(function(n){n[n.ON_REDRAW_END=0]="ON_REDRAW_END",n[n.ON_CONTEXT_LOST=1]="ON_CONTEXT_LOST"})(Po||(Po={}));self.addEventListener("message",n=>{bT(n.ports[0],n.data)});function bT(n,t){let{canvas:e,devicePixelRatio:i,dim:r,rendererType:s,useDarkMode:o}=t,a={onDrawEnd:()=>{n.postMessage({type:Po.ON_REDRAW_END})},onContextLost:()=>{n.postMessage({type:Po.ON_CONTEXT_LOST})}},l;switch(s){case Tn.WEBGL:l={type:Tn.WEBGL,domDimension:r,callbacks:a,container:e,devicePixelRatio:i,useDarkMode:o};break;default:throw new RangeError(`Invariant error: cannot have Offscreen chart for renderer type: ${s}`)}let c=new Bl(l);n.onmessage=function(u){let h=u.data;switch(h.type){case xn.SERIES_DATA_UPDATED:{let f=z0(h.compactDataSeries);c.setData(f);break}case xn.SERIES_METADATA_CHANGED:{c.setMetadata(h.metadata);break}case xn.VIEW_BOX_UPDATED:{c.setViewBox(h.extent);break}case xn.DOM_RESIZED:{c.resize(h.dim);break}case xn.DARK_MODE_UPDATED:{c.setUseDarkMode(h.useDarkMode);break}case xn.SCALE_UPDATED:{switch(h.axis){case"x":c.setXScaleType(h.scaleType);break;case"y":c.setYScaleType(h.scaleType);break;default:let f=h.axis;throw new RangeError(`Unknown axis: ${f}`)}break}case xn.DISPOSED:{c.dispose();break}}}}})();
/**
 * @license
 * Copyright 2010-2022 Three.js Authors
 * SPDX-License-Identifier: MIT
 */
//# sourceMappingURL=chart_worker.js.map
",
+              "headers": [
+                [
+                  "content-type",
+                  "text/javascript; charset=utf-8"
+                ]
+              ],
+              "ok": true,
+              "status": 200,
+              "status_text": ""
+            },
+            "https://localhost:6006/data/environment": {
+              "data": "eyJ2ZXJzaW9uIjogIjIuMTIuMSIsICJkYXRhX2xvY2F0aW9uIjogIi4vd29ya19kaXJzIiwgIndpbmRvd190aXRsZSI6ICIiLCAiZXhwZXJpbWVudF9uYW1lIjogIiIsICJleHBlcmltZW50X2Rlc2NyaXB0aW9uIjogIiIsICJjcmVhdGlvbl90aW1lIjogMCwgImRlYnVnIjogeyJkYXRhX3Byb3ZpZGVyIjogIk11bHRpcGxleGVyRGF0YVByb3ZpZGVyKGxvZ2Rpcj0nLi93b3JrX2RpcnMnKSIsICJmbGFncyI6IHsibG9nZGlyIjogIi4vd29ya19kaXJzIiwgImxvZ2Rpcl9zcGVjIjogIiIsICJob3N0IjogbnVsbCwgImJpbmRfYWxsIjogZmFsc2UsICJwb3J0IjogbnVsbCwgInJldXNlX3BvcnQiOiBmYWxzZSwgImxvYWRfZmFzdCI6ICJhdXRvIiwgImV4dHJhX2RhdGFfc2VydmVyX2ZsYWdzIjogIiIsICJncnBjX2NyZWRzX3R5cGUiOiAibG9jYWwiLCAiZ3JwY19kYXRhX3Byb3ZpZGVyIjogIiIsICJwdXJnZV9vcnBoYW5lZF9kYXRhIjogdHJ1ZSwgImRiIjogIiIsICJkYl9pbXBvcnQiOiBmYWxzZSwgImluc3BlY3QiOiBmYWxzZSwgInZlcnNpb25fdGIiOiBmYWxzZSwgInRhZyI6ICIiLCAiZXZlbnRfZmlsZSI6ICIiLCAicGF0aF9wcmVmaXgiOiAiIiwgIndpbmRvd190aXRsZSI6ICIiLCAibWF4X3JlbG9hZF90aHJlYWRzIjogMSwgInJlbG9hZF9pbnRlcnZhbCI6IDUuMCwgInJlbG9hZF90YXNrIjogImF1dG8iLCAicmVsb2FkX211bHRpZmlsZSI6IG51bGwsICJyZWxvYWRfbXVsdGlmaWxlX2luYWN0aXZlX3NlY3MiOiA4NjQwMCwgImdlbmVyaWNfZGF0YSI6ICJhdXRvIiwgInNhbXBsZXNfcGVyX3BsdWdpbiI6IHt9LCAiZGV0ZWN0X2ZpbGVfcmVwbGFjZW1lbnQiOiBudWxsLCAiY3VzdG9tX3ByZWRpY3RfZm4iOiAiIiwgIndpdF9kYXRhX2RpciI6ICIiLCAiX190ZW5zb3Jib2FyZF9zdWJjb21tYW5kIjogInNlcnZlIn19fQ==",
+              "headers": [
+                [
+                  "content-type",
+                  "application/json"
+                ]
+              ],
+              "ok": true,
+              "status": 200,
+              "status_text": ""
+            },
+            "https://localhost:6006/data/plugins_listing": {
+              "data": "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",
+              "headers": [
+                [
+                  "content-type",
+                  "application/json"
+                ]
+              ],
+              "ok": true,
+              "status": 200,
+              "status_text": ""
+            },
+            "https://localhost:6006/data/runs": {
+              "data": "WyJydG1kZXRfdGlueV8xeGI0LTIwZV9iYWxsb29uLzIwMjMwNDE3XzEwMjgzNS92aXNfZGF0YSJd",
+              "headers": [
+                [
+                  "content-type",
+                  "application/json"
+                ]
+              ],
+              "ok": true,
+              "status": 200,
+              "status_text": ""
+            },
+            "https://localhost:6006/experiment/defaultExperimentId/data/plugin/timeseries/tags": {
+              "data": "eyJzY2FsYXJzIjogeyJydW5UYWdJbmZvIjogeyJydG1kZXRfdGlueV8xeGI0LTIwZV9iYWxsb29uLzIwMjMwNDE3XzEwMjgzNS92aXNfZGF0YSI6IFsiY29jby9iYm94X21BUCIsICJjb2NvL2Jib3hfbUFQXzUwIiwgImNvY28vYmJveF9tQVBfNzUiLCAiY29jby9iYm94X21BUF9sIiwgImNvY28vYmJveF9tQVBfbSIsICJjb2NvL2Jib3hfbUFQX3MiLCAiZGF0YV90aW1lIiwgImVwb2NoIiwgImxvc3MiLCAibG9zc19iYm94IiwgImxvc3NfY2xzIiwgImxyIiwgIm1lbW9yeSIsICJ0aW1lIl19LCAidGFnRGVzY3JpcHRpb25zIjoge319LCAiaGlzdG9ncmFtcyI6IHsicnVuVGFnSW5mbyI6IHt9LCAidGFnRGVzY3JpcHRpb25zIjoge319LCAiaW1hZ2VzIjogeyJ0YWdEZXNjcmlwdGlvbnMiOiB7fSwgInRhZ1J1blNhbXBsZWRJbmZvIjoge319fQ==",
+              "headers": [
+                [
+                  "content-type",
+                  "application/json"
+                ]
+              ],
+              "ok": true,
+              "status": 200,
+              "status_text": ""
+            },
+            "https://localhost:6006/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22coco/bbox_mAP%22%7D%5D": {
+              "data": "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",
+              "headers": [
+                [
+                  "content-type",
+                  "application/json"
+                ]
+              ],
+              "ok": true,
+              "status": 200,
+              "status_text": ""
+            },
+            "https://localhost:6006/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22coco/bbox_mAP_50%22%7D%5D": {
+              "data": "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",
+              "headers": [
+                [
+                  "content-type",
+                  "application/json"
+                ]
+              ],
+              "ok": true,
+              "status": 200,
+              "status_text": ""
+            },
+            "https://localhost:6006/font-roboto/RxZJdnzeo3R5zSexge8UUZBw1xU1rKptJj_0jans920.woff2": {
+              "data": "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",
+              "headers": [
+                [
+                  "content-type",
+                  "font/woff2"
+                ]
+              ],
+              "ok": true,
+              "status": 200,
+              "status_text": ""
+            },
+            "https://localhost:6006/font-roboto/d-6IYplOFocCacKzxwXSOJBw1xU1rKptJj_0jans920.woff2": {
+              "data": "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",
+              "headers": [
+                [
+                  "content-type",
+                  "font/woff2"
+                ]
+              ],
+              "ok": true,
+              "status": 200,
+              "status_text": ""
+            },
+            "https://localhost:6006/font-roboto/vPcynSL0qHq_6dX7lKVByXYhjbSpvc47ee6xR_80Hnw.woff2": {
+              "data": "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",
+              "headers": [
+                [
+                  "content-type",
+                  "font/woff2"
+                ]
+              ],
+              "ok": true,
+              "status": 200,
+              "status_text": ""
+            },
+            "https://localhost:6006/icon_bundle.svg": {
+              "data": "<?xml version="1.0" ?><svg><defs><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="arrow_downward_24px"><path fill="#010101" d="M20 12l-1.41-1.41L13 16.17V4h-2v12.17l-5.58-5.59L4 12l8 8 8-8z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="arrow_upward_24px"><path d="M4 12l1.41 1.41L11 7.83V20h2V7.83l5.58 5.59L20 12l-8-8-8 8z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="brightness_6_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M20 15.31L23.31 12 20 8.69V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69zM12 18V6c3.31 0 6 2.69 6 6s-2.69 6-6 6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="bug_report_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M20 8h-2.81c-.45-.78-1.07-1.45-1.82-1.96L17 4.41 15.59 3l-2.17 2.17C12.96 5.06 12.49 5 12 5c-.49 0-.96.06-1.41.17L8.41 3 7 4.41l1.62 1.63C7.88 6.55 7.26 7.22 6.81 8H4v2h2.09c-.05.33-.09.66-.09 1v1H4v2h2v1c0 .34.04.67.09 1H4v2h2.81c1.04 1.79 2.97 3 5.19 3s4.15-1.21 5.19-3H20v-2h-2.09c.05-.33.09-.66.09-1v-1h2v-2h-2v-1c0-.34-.04-.67-.09-1H20V8zm-6 8h-4v-2h4v2zm0-4h-4v-2h4v2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="cancel_24px"><path d="M12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2zm5 13.59L15.59 17 12 13.41 8.41 17 7 15.59 10.59 12 7 8.41 8.41 7 12 10.59 15.59 7 17 8.41 13.41 12 17 15.59z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="change_history_24px"><path d="M12 7.77L18.39 18H5.61L12 7.77M12 4L2 20h20L12 4z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="chevron_left_24px"><path d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="chevron_right_24px"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="clear_24px"><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="close_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="content_copy_24px"><path d="M16 1H4c-1.1 0-2 .9-2 2v14h2V3h12V1zm3 4H8c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h11c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 16H8V7h11v14z"/></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="dark_mode_24px"><rect fill="none" height="24" width="24"/><path d="M12,3c-4.97,0-9,4.03-9,9s4.03,9,9,9s9-4.03,9-9c0-0.46-0.04-0.92-0.1-1.36c-0.98,1.37-2.58,2.26-4.4,2.26 c-2.98,0-5.4-2.42-5.4-5.4c0-1.81,0.89-3.42,2.26-4.4C12.92,3.04,12.46,3,12,3L12,3z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="done_24px"><path d="M9 16.2L4.8 12l-1.4 1.4L9 19 21 7l-1.4-1.4L9 16.2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="drag_indicator_24px"><path d="M0 0h24v24H0V0z" fill="none"/><path d="M11 18c0 1.1-.9 2-2 2s-2-.9-2-2 .9-2 2-2 2 .9 2 2zm-2-8c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0-6c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm6 4c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm0 2c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0 6c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="edit_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04c.39-.39.39-1.02 0-1.41l-2.34-2.34c-.39-.39-1.02-.39-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="error_24px"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-2h2v2zm0-4h-2V7h2v6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="expand_less_24px"><path d="M12 8l-6 6 1.41 1.41L12 10.83l4.59 4.58L18 14z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="expand_more_24px"><path d="M16.59 8.59L12 13.17 7.41 8.59 6 10l6 6 6-6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="filter_alt_24px"><g><path d="M0,0h24 M24,24H0" fill="none"/><path d="M4.25,5.61C6.27,8.2,10,13,10,13v6c0,0.55,0.45,1,1,1h2c0.55,0,1-0.45,1-1v-6c0,0,3.72-4.8,5.74-7.39 C20.25,4.95,19.78,4,18.95,4H5.04C4.21,4,3.74,4.95,4.25,5.61z"/><path d="M0,0h24v24H0V0z" fill="none"/></g></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="flag_24px"><path d="M14.4 6L14 4H5v17h2v-7h5.6l.4 2h7V6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="fullscreen_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M7 14H5v5h5v-2H7v-3zm-2-4h2V7h3V5H5v5zm12 7h-3v2h5v-5h-2v3zM14 5v2h3v3h2V5h-5z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="fullscreen_exit_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M5 16h3v3h2v-5H5v2zm3-8H5v2h5V5H8v3zm6 11h2v-3h3v-2h-5v5zm2-11V5h-2v5h5V8h-3z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="get_app_24px"><path d="M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="group_work_24px"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zM8 17.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5zM9.5 8c0-1.38 1.12-2.5 2.5-2.5s2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5S9.5 9.38 9.5 8zm6.5 9.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="help_outline_24px"><path d="M11 18h2v-2h-2v2zm1-16C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zm0-14c-2.21 0-4 1.79-4 4h2c0-1.1.9-2 2-2s2 .9 2 2c0 2-3 1.75-3 5h2c0-2.25 3-2.5 3-5 0-2.21-1.79-4-4-4z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="image_search_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M0 0h24v24H0V0z" fill="none"/><path d="M18 13v7H4V6h5.02c.05-.71.22-1.38.48-2H4c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2v-5l-2-2zm-1.5 5h-11l2.75-3.53 1.96 2.36 2.75-3.54zm2.8-9.11c.44-.7.7-1.51.7-2.39C20 4.01 17.99 2 15.5 2S11 4.01 11 6.5s2.01 4.5 4.49 4.5c.88 0 1.7-.26 2.39-.7L21 13.42 22.42 12 19.3 8.89zM15.5 9C14.12 9 13 7.88 13 6.5S14.12 4 15.5 4 18 5.12 18 6.5 16.88 9 15.5 9z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="info_outline_24px"><path d="M11 17h2v-6h-2v6zm1-15C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zM11 9h2V7h-2v2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="keep_24px"><g><rect fill="none" height="24" width="24"/></g><g><path d="M16,9V4l1,0c0.55,0,1-0.45,1-1v0c0-0.55-0.45-1-1-1H7C6.45,2,6,2.45,6,3v0 c0,0.55,0.45,1,1,1l1,0v5c0,1.66-1.34,3-3,3h0v2h5.97v7l1,1l1-1v-7H19v-2h0C17.34,12,16,10.66,16,9z" fill-rule="evenodd"/></g></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="keep_outline_24px"><g><rect fill="none" height="24" width="24"/></g><g><path d="M14,4v5c0,1.12,0.37,2.16,1,3H9c0.65-0.86,1-1.9,1-3V4H14 M17,2H7C6.45,2,6,2.45,6,3c0,0.55,0.45,1,1,1c0,0,0,0,0,0l1,0v5 c0,1.66-1.34,3-3,3v2h5.97v7l1,1l1-1v-7H19v-2c0,0,0,0,0,0c-1.66,0-3-1.34-3-3V4l1,0c0,0,0,0,0,0c0.55,0,1-0.45,1-1 C18,2.45,17.55,2,17,2L17,2z"/></g></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="light_mode_24px"><rect fill="none" height="24" width="24"/><path d="M12,7c-2.76,0-5,2.24-5,5s2.24,5,5,5s5-2.24,5-5S14.76,7,12,7L12,7z M2,13l2,0c0.55,0,1-0.45,1-1s-0.45-1-1-1l-2,0 c-0.55,0-1,0.45-1,1S1.45,13,2,13z M20,13l2,0c0.55,0,1-0.45,1-1s-0.45-1-1-1l-2,0c-0.55,0-1,0.45-1,1S19.45,13,20,13z M11,2v2 c0,0.55,0.45,1,1,1s1-0.45,1-1V2c0-0.55-0.45-1-1-1S11,1.45,11,2z M11,20v2c0,0.55,0.45,1,1,1s1-0.45,1-1v-2c0-0.55-0.45-1-1-1 C11.45,19,11,19.45,11,20z M5.99,4.58c-0.39-0.39-1.03-0.39-1.41,0c-0.39,0.39-0.39,1.03,0,1.41l1.06,1.06 c0.39,0.39,1.03,0.39,1.41,0s0.39-1.03,0-1.41L5.99,4.58z M18.36,16.95c-0.39-0.39-1.03-0.39-1.41,0c-0.39,0.39-0.39,1.03,0,1.41 l1.06,1.06c0.39,0.39,1.03,0.39,1.41,0c0.39-0.39,0.39-1.03,0-1.41L18.36,16.95z M19.42,5.99c0.39-0.39,0.39-1.03,0-1.41 c-0.39-0.39-1.03-0.39-1.41,0l-1.06,1.06c-0.39,0.39-0.39,1.03,0,1.41s1.03,0.39,1.41,0L19.42,5.99z M7.05,18.36 c0.39-0.39,0.39-1.03,0-1.41c-0.39-0.39-1.03-0.39-1.41,0l-1.06,1.06c-0.39,0.39-0.39,1.03,0,1.41s1.03,0.39,1.41,0L7.05,18.36z"/></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="line_weight_24px"><g><rect fill="none" height="24" width="24" x="0"/></g><g><g><g><path d="M3,17h18v-2H3V17z M3,20h18v-1H3V20z M3,13h18v-3H3V13z M3,4v4h18V4H3z"/></g></g></g></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="more_vert_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M12 8c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm0 2c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0 6c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="notifications_none_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M12 22c1.1 0 2-.9 2-2h-4c0 1.1.9 2 2 2zm6-6v-5c0-3.07-1.63-5.64-4.5-6.32V4c0-.83-.67-1.5-1.5-1.5s-1.5.67-1.5 1.5v.68C7.64 5.36 6 7.92 6 11v5l-2 2v1h16v-1l-2-2zm-2 1H8v-6c0-2.48 1.51-4.5 4-4.5s4 2.02 4 4.5v6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="palette_24px"><path d="M12 3c-4.97 0-9 4.03-9 9s4.03 9 9 9c.83 0 1.5-.67 1.5-1.5 0-.39-.15-.74-.39-1.01-.23-.26-.38-.61-.38-.99 0-.83.67-1.5 1.5-1.5H16c2.76 0 5-2.24 5-5 0-4.42-4.03-8-9-8zm-5.5 9c-.83 0-1.5-.67-1.5-1.5S5.67 9 6.5 9 8 9.67 8 10.5 7.33 12 6.5 12zm3-4C8.67 8 8 7.33 8 6.5S8.67 5 9.5 5s1.5.67 1.5 1.5S10.33 8 9.5 8zm5 0c-.83 0-1.5-.67-1.5-1.5S13.67 5 14.5 5s1.5.67 1.5 1.5S15.33 8 14.5 8zm3 4c-.83 0-1.5-.67-1.5-1.5S16.67 9 17.5 9s1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="refresh_24px"><path d="M17.65 6.35C16.2 4.9 14.21 4 12 4c-4.42 0-7.99 3.58-7.99 8s3.57 8 7.99 8c3.73 0 6.84-2.55 7.73-6h-2.08c-.82 2.33-3.04 4-5.65 4-3.31 0-6-2.69-6-6s2.69-6 6-6c1.66 0 3.14.69 4.22 1.78L13 11h7V4l-2.35 2.35z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="search_24px"><path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="settings_24px"><path d="M19.43 12.98c.04-.32.07-.64.07-.98s-.03-.66-.07-.98l2.11-1.65c.19-.15.24-.42.12-.64l-2-3.46c-.12-.22-.39-.3-.61-.22l-2.49 1c-.52-.4-1.08-.73-1.69-.98l-.38-2.65C14.46 2.18 14.25 2 14 2h-4c-.25 0-.46.18-.49.42l-.38 2.65c-.61.25-1.17.59-1.69.98l-2.49-1c-.23-.09-.49 0-.61.22l-2 3.46c-.13.22-.07.49.12.64l2.11 1.65c-.04.32-.07.65-.07.98s.03.66.07.98l-2.11 1.65c-.19.15-.24.42-.12.64l2 3.46c.12.22.39.3.61.22l2.49-1c.52.4 1.08.73 1.69.98l.38 2.65c.03.24.24.42.49.42h4c.25 0 .46-.18.49-.42l.38-2.65c.61-.25 1.17-.59 1.69-.98l2.49 1c.23.09.49 0 .61-.22l2-3.46c.12-.22.07-.49-.12-.64l-2.11-1.65zM12 15.5c-1.93 0-3.5-1.57-3.5-3.5s1.57-3.5 3.5-3.5 3.5 1.57 3.5 3.5-1.57 3.5-3.5 3.5z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="settings_backup_restore_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M14 12c0-1.1-.9-2-2-2s-2 .9-2 2 .9 2 2 2 2-.9 2-2zm-2-9c-4.97 0-9 4.03-9 9H0l4 4 4-4H5c0-3.87 3.13-7 7-7s7 3.13 7 7-3.13 7-7 7c-1.51 0-2.91-.49-4.06-1.3l-1.42 1.44C8.04 20.3 9.94 21 12 21c4.97 0 9-4.03 9-9s-4.03-9-9-9z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="settings_overscan_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M12.01 5.5L10 8h4l-1.99-2.5zM18 10v4l2.5-1.99L18 10zM6 10l-2.5 2.01L6 14v-4zm8 6h-4l2.01 2.5L14 16zm7-13H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16.01H3V4.99h18v14.02z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="visibility_off_24px"><path d="M12 7c2.76 0 5 2.24 5 5 0 .65-.13 1.26-.36 1.83l2.92 2.92c1.51-1.26 2.7-2.89 3.43-4.75-1.73-4.39-6-7.5-11-7.5-1.4 0-2.74.25-3.98.7l2.16 2.16C10.74 7.13 11.35 7 12 7zM2 4.27l2.28 2.28.46.46C3.08 8.3 1.78 10.02 1 12c1.73 4.39 6 7.5 11 7.5 1.55 0 3.03-.3 4.38-.84l.42.42L19.73 22 21 20.73 3.27 3 2 4.27zM7.53 9.8l1.55 1.55c-.05.21-.08.43-.08.65 0 1.66 1.34 3 3 3 .22 0 .44-.03.65-.08l1.55 1.55c-.67.33-1.41.53-2.2.53-2.76 0-5-2.24-5-5 0-.79.2-1.53.53-2.2zm4.31-.78l3.15 3.15.02-.16c0-1.66-1.34-3-3-3l-.17.01z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="warning_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z"/></svg></defs></svg>
",
+              "headers": [
+                [
+                  "content-type",
+                  "image/svg+xml; charset=utf-8"
+                ]
+              ],
+              "ok": true,
+              "status": 200,
+              "status_text": ""
+            },
+            "https://localhost:6006/index.js?_file_hash=486f34d2": {
+              "data": "var CLOSURE_NO_DEPS = true;
window.polymerSkipLoadingFontRoboto = true;
// Copyright 2014 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
//     You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//     See the License for the specific language governing permissions and
// limitations under the License.

!function(){var a={},b={},c={};!function(a,b){function c(a){if("number"==typeof a)return a;var b={};for(var c in a)b[c]=a[c];return b}function d(){this._delay=0,this._endDelay=0,this._fill="none",this._iterationStart=0,this._iterations=1,this._duration=0,this._playbackRate=1,this._direction="normal",this._easing="linear",this._easingFunction=x}function e(){return a.isDeprecated("Invalid timing inputs","2016-03-02","TypeError exceptions will be thrown instead.",!0)}function f(b,c,e){var f=new d;return c&&(f.fill="both",f.duration="auto"),"number"!=typeof b||isNaN(b)?void 0!==b&&Object.getOwnPropertyNames(b).forEach(function(c){if("auto"!=b[c]){if(("number"==typeof f[c]||"duration"==c)&&("number"!=typeof b[c]||isNaN(b[c])))return;if("fill"==c&&-1==v.indexOf(b[c]))return;if("direction"==c&&-1==w.indexOf(b[c]))return;if("playbackRate"==c&&1!==b[c]&&a.isDeprecated("AnimationEffectTiming.playbackRate","2014-11-28","Use Animation.playbackRate instead."))return;f[c]=b[c]}}):f.duration=b,f}function g(a){return"number"==typeof a&&(a=isNaN(a)?{duration:0}:{duration:a}),a}function h(b,c){return b=a.numericTimingToObject(b),f(b,c)}function i(a,b,c,d){return a<0||a>1||c<0||c>1?x:function(e){function f(a,b,c){return 3*a*(1-c)*(1-c)*c+3*b*(1-c)*c*c+c*c*c}if(e<=0){var g=0;return a>0?g=b/a:!b&&c>0&&(g=d/c),g*e}if(e>=1){var h=0;return c<1?h=(d-1)/(c-1):1==c&&a<1&&(h=(b-1)/(a-1)),1+h*(e-1)}for(var i=0,j=1;i<j;){var k=(i+j)/2,l=f(a,c,k);if(Math.abs(e-l)<1e-5)return f(b,d,k);l<e?i=k:j=k}return f(b,d,k)}}function j(a,b){return function(c){if(c>=1)return 1;var d=1/a;return(c+=b*d)-c%d}}function k(a){C||(C=document.createElement("div").style),C.animationTimingFunction="",C.animationTimingFunction=a;var b=C.animationTimingFunction;if(""==b&&e())throw new TypeError(a+" is not a valid value for easing");return b}function l(a){if("linear"==a)return x;var b=E.exec(a);if(b)return i.apply(this,b.slice(1).map(Number));var c=F.exec(a);if(c)return j(Number(c[1]),A);var d=G.exec(a);return d?j(Number(d[1]),{start:y,middle:z,end:A}[d[2]]):B[a]||x}function m(a){return Math.abs(n(a)/a.playbackRate)}function n(a){return 0===a.duration||0===a.iterations?0:a.duration*a.iterations}function o(a,b,c){if(null==b)return H;var d=c.delay+a+c.endDelay;return b<Math.min(c.delay,d)?I:b>=Math.min(c.delay+a,d)?J:K}function p(a,b,c,d,e){switch(d){case I:return"backwards"==b||"both"==b?0:null;case K:return c-e;case J:return"forwards"==b||"both"==b?a:null;case H:return null}}function q(a,b,c,d,e){var f=e;return 0===a?b!==I&&(f+=c):f+=d/a,f}function r(a,b,c,d,e,f){var g=a===1/0?b%1:a%1;return 0!==g||c!==J||0===d||0===e&&0!==f||(g=1),g}function s(a,b,c,d){return a===J&&b===1/0?1/0:1===c?Math.floor(d)-1:Math.floor(d)}function t(a,b,c){var d=a;if("normal"!==a&&"reverse"!==a){var e=b;"alternate-reverse"===a&&(e+=1),d="normal",e!==1/0&&e%2!=0&&(d="reverse")}return"normal"===d?c:1-c}function u(a,b,c){var d=o(a,b,c),e=p(a,c.fill,b,d,c.delay);if(null===e)return null;var f=q(c.duration,d,c.iterations,e,c.iterationStart),g=r(f,c.iterationStart,d,c.iterations,e,c.duration),h=s(d,c.iterations,g,f),i=t(c.direction,h,g);return c._easingFunction(i)}var v="backwards|forwards|both|none".split("|"),w="reverse|alternate|alternate-reverse".split("|"),x=function(a){return a};d.prototype={_setMember:function(b,c){this["_"+b]=c,this._effect&&(this._effect._timingInput[b]=c,this._effect._timing=a.normalizeTimingInput(this._effect._timingInput),this._effect.activeDuration=a.calculateActiveDuration(this._effect._timing),this._effect._animation&&this._effect._animation._rebuildUnderlyingAnimation())},get playbackRate(){return this._playbackRate},set delay(a){this._setMember("delay",a)},get delay(){return this._delay},set endDelay(a){this._setMember("endDelay",a)},get endDelay(){return this._endDelay},set fill(a){this._setMember("fill",a)},get fill(){return this._fill},set iterationStart(a){if((isNaN(a)||a<0)&&e())throw new TypeError("iterationStart must be a non-negative number, received: "+a);this._setMember("iterationStart",a)},get iterationStart(){return this._iterationStart},set duration(a){if("auto"!=a&&(isNaN(a)||a<0)&&e())throw new TypeError("duration must be non-negative or auto, received: "+a);this._setMember("duration",a)},get duration(){return this._duration},set direction(a){this._setMember("direction",a)},get direction(){return this._direction},set easing(a){this._easingFunction=l(k(a)),this._setMember("easing",a)},get easing(){return this._easing},set iterations(a){if((isNaN(a)||a<0)&&e())throw new TypeError("iterations must be non-negative, received: "+a);this._setMember("iterations",a)},get iterations(){return this._iterations}};var y=1,z=.5,A=0,B={ease:i(.25,.1,.25,1),"ease-in":i(.42,0,1,1),"ease-out":i(0,0,.58,1),"ease-in-out":i(.42,0,.58,1),"step-start":j(1,y),"step-middle":j(1,z),"step-end":j(1,A)},C=null,D="\\s*(-?\\d+\\.?\\d*|-?\\.\\d+)\\s*",E=new RegExp("cubic-bezier\\("+D+","+D+","+D+","+D+"\\)"),F=/steps\(\s*(\d+)\s*\)/,G=/steps\(\s*(\d+)\s*,\s*(start|middle|end)\s*\)/,H=0,I=1,J=2,K=3;a.cloneTimingInput=c,a.makeTiming=f,a.numericTimingToObject=g,a.normalizeTimingInput=h,a.calculateActiveDuration=m,a.calculateIterationProgress=u,a.calculatePhase=o,a.normalizeEasing=k,a.parseEasingFunction=l}(a),function(a,b){function c(a,b){return a in k?k[a][b]||b:b}function d(a){return"display"===a||0===a.lastIndexOf("animation",0)||0===a.lastIndexOf("transition",0)}function e(a,b,e){if(!d(a)){var f=h[a];if(f){i.style[a]=b;for(var g in f){var j=f[g],k=i.style[j];e[j]=c(j,k)}}else e[a]=c(a,b)}}function f(a){var b=[];for(var c in a)if(!(c in["easing","offset","composite"])){var d=a[c];Array.isArray(d)||(d=[d]);for(var e,f=d.length,g=0;g<f;g++)e={},e.offset="offset"in a?a.offset:1==f?1:g/(f-1),"easing"in a&&(e.easing=a.easing),"composite"in a&&(e.composite=a.composite),e[c]=d[g],b.push(e)}return b.sort(function(a,b){return a.offset-b.offset}),b}function g(b){function c(){var a=d.length;null==d[a-1].offset&&(d[a-1].offset=1),a>1&&null==d[0].offset&&(d[0].offset=0);for(var b=0,c=d[0].offset,e=1;e<a;e++){var f=d[e].offset;if(null!=f){for(var g=1;g<e-b;g++)d[b+g].offset=c+(f-c)*g/(e-b);b=e,c=f}}}if(null==b)return[];window.Symbol&&Symbol.iterator&&Array.prototype.from&&b[Symbol.iterator]&&(b=Array.from(b)),Array.isArray(b)||(b=f(b));for(var d=b.map(function(b){var c={};for(var d in b){var f=b[d];if("offset"==d){if(null!=f){if(f=Number(f),!isFinite(f))throw new TypeError("Keyframe offsets must be numbers.");if(f<0||f>1)throw new TypeError("Keyframe offsets must be between 0 and 1.")}}else if("composite"==d){if("add"==f||"accumulate"==f)throw{type:DOMException.NOT_SUPPORTED_ERR,name:"NotSupportedError",message:"add compositing is not supported"};if("replace"!=f)throw new TypeError("Invalid composite mode "+f+".")}else f="easing"==d?a.normalizeEasing(f):""+f;e(d,f,c)}return void 0==c.offset&&(c.offset=null),void 0==c.easing&&(c.easing="linear"),c}),g=!0,h=-1/0,i=0;i<d.length;i++){var j=d[i].offset;if(null!=j){if(j<h)throw new TypeError("Keyframes are not loosely sorted by offset. Sort or specify offsets.");h=j}else g=!1}return d=d.filter(function(a){return a.offset>=0&&a.offset<=1}),g||c(),d}var h={background:["backgroundImage","backgroundPosition","backgroundSize","backgroundRepeat","backgroundAttachment","backgroundOrigin","backgroundClip","backgroundColor"],border:["borderTopColor","borderTopStyle","borderTopWidth","borderRightColor","borderRightStyle","borderRightWidth","borderBottomColor","borderBottomStyle","borderBottomWidth","borderLeftColor","borderLeftStyle","borderLeftWidth"],borderBottom:["borderBottomWidth","borderBottomStyle","borderBottomColor"],borderColor:["borderTopColor","borderRightColor","borderBottomColor","borderLeftColor"],borderLeft:["borderLeftWidth","borderLeftStyle","borderLeftColor"],borderRadius:["borderTopLeftRadius","borderTopRightRadius","borderBottomRightRadius","borderBottomLeftRadius"],borderRight:["borderRightWidth","borderRightStyle","borderRightColor"],borderTop:["borderTopWidth","borderTopStyle","borderTopColor"],borderWidth:["borderTopWidth","borderRightWidth","borderBottomWidth","borderLeftWidth"],flex:["flexGrow","flexShrink","flexBasis"],font:["fontFamily","fontSize","fontStyle","fontVariant","fontWeight","lineHeight"],margin:["marginTop","marginRight","marginBottom","marginLeft"],outline:["outlineColor","outlineStyle","outlineWidth"],padding:["paddingTop","paddingRight","paddingBottom","paddingLeft"]},i=document.createElementNS("http://www.w3.org/1999/xhtml","div"),j={thin:"1px",medium:"3px",thick:"5px"},k={borderBottomWidth:j,borderLeftWidth:j,borderRightWidth:j,borderTopWidth:j,fontSize:{"xx-small":"60%","x-small":"75%",small:"89%",medium:"100%",large:"120%","x-large":"150%","xx-large":"200%"},fontWeight:{normal:"400",bold:"700"},outlineWidth:j,textShadow:{none:"0px 0px 0px transparent"},boxShadow:{none:"0px 0px 0px 0px transparent"}};a.convertToArrayForm=f,a.normalizeKeyframes=g}(a),function(a){var b={};a.isDeprecated=function(a,c,d,e){var f=e?"are":"is",g=new Date,h=new Date(c);return h.setMonth(h.getMonth()+3),!(g<h&&(a in b||console.warn("Web Animations: "+a+" "+f+" deprecated and will stop working on "+h.toDateString()+". "+d),b[a]=!0,1))},a.deprecated=function(b,c,d,e){var f=e?"are":"is";if(a.isDeprecated(b,c,d,e))throw new Error(b+" "+f+" no longer supported. "+d)}}(a),function(){if(document.documentElement.animate){var c=document.documentElement.animate([],0),d=!0;if(c&&(d=!1,"play|currentTime|pause|reverse|playbackRate|cancel|finish|startTime|playState".split("|").forEach(function(a){void 0===c[a]&&(d=!0)})),!d)return}!function(a,b,c){function d(a){for(var b={},c=0;c<a.length;c++)for(var d in a[c])if("offset"!=d&&"easing"!=d&&"composite"!=d){var e={offset:a[c].offset,easing:a[c].easing,value:a[c][d]};b[d]=b[d]||[],b[d].push(e)}for(var f in b){var g=b[f];if(0!=g[0].offset||1!=g[g.length-1].offset)throw{type:DOMException.NOT_SUPPORTED_ERR,name:"NotSupportedError",message:"Partial keyframes are not supported"}}return b}function e(c){var d=[];for(var e in c)for(var f=c[e],g=0;g<f.length-1;g++){var h=g,i=g+1,j=f[h].offset,k=f[i].offset,l=j,m=k;0==g&&(l=-1/0,0==k&&(i=h)),g==f.length-2&&(m=1/0,1==j&&(h=i)),d.push({applyFrom:l,applyTo:m,startOffset:f[h].offset,endOffset:f[i].offset,easingFunction:a.parseEasingFunction(f[h].easing),property:e,interpolation:b.propertyInterpolation(e,f[h].value,f[i].value)})}return d.sort(function(a,b){return a.startOffset-b.startOffset}),d}b.convertEffectInput=function(c){var f=a.normalizeKeyframes(c),g=d(f),h=e(g);return function(a,c){if(null!=c)h.filter(function(a){return c>=a.applyFrom&&c<a.applyTo}).forEach(function(d){var e=c-d.startOffset,f=d.endOffset-d.startOffset,g=0==f?0:d.easingFunction(e/f);b.apply(a,d.property,d.interpolation(g))});else for(var d in g)"offset"!=d&&"easing"!=d&&"composite"!=d&&b.clear(a,d)}}}(a,b),function(a,b,c){function d(a){return a.replace(/-(.)/g,function(a,b){return b.toUpperCase()})}function e(a,b,c){h[c]=h[c]||[],h[c].push([a,b])}function f(a,b,c){for(var f=0;f<c.length;f++){e(a,b,d(c[f]))}}function g(c,e,f){var g=c;/-/.test(c)&&!a.isDeprecated("Hyphenated property names","2016-03-22","Use camelCase instead.",!0)&&(g=d(c)),"initial"!=e&&"initial"!=f||("initial"==e&&(e=i[g]),"initial"==f&&(f=i[g]));for(var j=e==f?[]:h[g],k=0;j&&k<j.length;k++){var l=j[k][0](e),m=j[k][0](f);if(void 0!==l&&void 0!==m){var n=j[k][1](l,m);if(n){var o=b.Interpolation.apply(null,n);return function(a){return 0==a?e:1==a?f:o(a)}}}}return b.Interpolation(!1,!0,function(a){return a?f:e})}var h={};b.addPropertiesHandler=f;var i={backgroundColor:"transparent",backgroundPosition:"0% 0%",borderBottomColor:"currentColor",borderBottomLeftRadius:"0px",borderBottomRightRadius:"0px",borderBottomWidth:"3px",borderLeftColor:"currentColor",borderLeftWidth:"3px",borderRightColor:"currentColor",borderRightWidth:"3px",borderSpacing:"2px",borderTopColor:"currentColor",borderTopLeftRadius:"0px",borderTopRightRadius:"0px",borderTopWidth:"3px",bottom:"auto",clip:"rect(0px, 0px, 0px, 0px)",color:"black",fontSize:"100%",fontWeight:"400",height:"auto",left:"auto",letterSpacing:"normal",lineHeight:"120%",marginBottom:"0px",marginLeft:"0px",marginRight:"0px",marginTop:"0px",maxHeight:"none",maxWidth:"none",minHeight:"0px",minWidth:"0px",opacity:"1.0",outlineColor:"invert",outlineOffset:"0px",outlineWidth:"3px",paddingBottom:"0px",paddingLeft:"0px",paddingRight:"0px",paddingTop:"0px",right:"auto",strokeDasharray:"none",strokeDashoffset:"0px",textIndent:"0px",textShadow:"0px 0px 0px transparent",top:"auto",transform:"",verticalAlign:"0px",visibility:"visible",width:"auto",wordSpacing:"normal",zIndex:"auto"};b.propertyInterpolation=g}(a,b),function(a,b,c){function d(b){var c=a.calculateActiveDuration(b),d=function(d){return a.calculateIterationProgress(c,d,b)};return d._totalDuration=b.delay+c+b.endDelay,d}b.KeyframeEffect=function(c,e,f,g){var h,i=d(a.normalizeTimingInput(f)),j=b.convertEffectInput(e),k=function(){j(c,h)};return k._update=function(a){return null!==(h=i(a))},k._clear=function(){j(c,null)},k._hasSameTarget=function(a){return c===a},k._target=c,k._totalDuration=i._totalDuration,k._id=g,k}}(a,b),function(a,b){a.apply=function(b,c,d){b.style[a.propertyName(c)]=d},a.clear=function(b,c){b.style[a.propertyName(c)]=""}}(b),function(a){window.Element.prototype.animate=function(b,c){var d="";return c&&c.id&&(d=c.id),a.timeline._play(a.KeyframeEffect(this,b,c,d))}}(b),function(a,b){function c(a,b,d){if("number"==typeof a&&"number"==typeof b)return a*(1-d)+b*d;if("boolean"==typeof a&&"boolean"==typeof b)return d<.5?a:b;if(a.length==b.length){for(var e=[],f=0;f<a.length;f++)e.push(c(a[f],b[f],d));return e}throw"Mismatched interpolation arguments "+a+":"+b}a.Interpolation=function(a,b,d){return function(e){return d(c(a,b,e))}}}(b),function(a,b,c){a.sequenceNumber=0;var d=function(a,b,c){this.target=a,this.currentTime=b,this.timelineTime=c,this.type="finish",this.bubbles=!1,this.cancelable=!1,this.currentTarget=a,this.defaultPrevented=!1,this.eventPhase=Event.AT_TARGET,this.timeStamp=Date.now()};b.Animation=function(b){this.id="",b&&b._id&&(this.id=b._id),this._sequenceNumber=a.sequenceNumber++,this._currentTime=0,this._startTime=null,this._paused=!1,this._playbackRate=1,this._inTimeline=!0,this._finishedFlag=!0,this.onfinish=null,this._finishHandlers=[],this._effect=b,this._inEffect=this._effect._update(0),this._idle=!0,this._currentTimePending=!1},b.Animation.prototype={_ensureAlive:function(){this.playbackRate<0&&0===this.currentTime?this._inEffect=this._effect._update(-1):this._inEffect=this._effect._update(this.currentTime),this._inTimeline||!this._inEffect&&this._finishedFlag||(this._inTimeline=!0,b.timeline._animations.push(this))},_tickCurrentTime:function(a,b){a!=this._currentTime&&(this._currentTime=a,this._isFinished&&!b&&(this._currentTime=this._playbackRate>0?this._totalDuration:0),this._ensureAlive())},get currentTime(){return this._idle||this._currentTimePending?null:this._currentTime},set currentTime(a){a=+a,isNaN(a)||(b.restart(),this._paused||null==this._startTime||(this._startTime=this._timeline.currentTime-a/this._playbackRate),this._currentTimePending=!1,this._currentTime!=a&&(this._idle&&(this._idle=!1,this._paused=!0),this._tickCurrentTime(a,!0),b.applyDirtiedAnimation(this)))},get startTime(){return this._startTime},set startTime(a){a=+a,isNaN(a)||this._paused||this._idle||(this._startTime=a,this._tickCurrentTime((this._timeline.currentTime-this._startTime)*this.playbackRate),b.applyDirtiedAnimation(this))},get playbackRate(){return this._playbackRate},set playbackRate(a){if(a!=this._playbackRate){var c=this.currentTime;this._playbackRate=a,this._startTime=null,"paused"!=this.playState&&"idle"!=this.playState&&(this._finishedFlag=!1,this._idle=!1,this._ensureAlive(),b.applyDirtiedAnimation(this)),null!=c&&(this.currentTime=c)}},get _isFinished(){return!this._idle&&(this._playbackRate>0&&this._currentTime>=this._totalDuration||this._playbackRate<0&&this._currentTime<=0)},get _totalDuration(){return this._effect._totalDuration},get playState(){return this._idle?"idle":null==this._startTime&&!this._paused&&0!=this.playbackRate||this._currentTimePending?"pending":this._paused?"paused":this._isFinished?"finished":"running"},_rewind:function(){if(this._playbackRate>=0)this._currentTime=0;else{if(!(this._totalDuration<1/0))throw new DOMException("Unable to rewind negative playback rate animation with infinite duration","InvalidStateError");this._currentTime=this._totalDuration}},play:function(){this._paused=!1,(this._isFinished||this._idle)&&(this._rewind(),this._startTime=null),this._finishedFlag=!1,this._idle=!1,this._ensureAlive(),b.applyDirtiedAnimation(this)},pause:function(){this._isFinished||this._paused||this._idle?this._idle&&(this._rewind(),this._idle=!1):this._currentTimePending=!0,this._startTime=null,this._paused=!0},finish:function(){this._idle||(this.currentTime=this._playbackRate>0?this._totalDuration:0,this._startTime=this._totalDuration-this.currentTime,this._currentTimePending=!1,b.applyDirtiedAnimation(this))},cancel:function(){this._inEffect&&(this._inEffect=!1,this._idle=!0,this._paused=!1,this._finishedFlag=!0,this._currentTime=0,this._startTime=null,this._effect._update(null),b.applyDirtiedAnimation(this))},reverse:function(){this.playbackRate*=-1,this.play()},addEventListener:function(a,b){"function"==typeof b&&"finish"==a&&this._finishHandlers.push(b)},removeEventListener:function(a,b){if("finish"==a){var c=this._finishHandlers.indexOf(b);c>=0&&this._finishHandlers.splice(c,1)}},_fireEvents:function(a){if(this._isFinished){if(!this._finishedFlag){var b=new d(this,this._currentTime,a),c=this._finishHandlers.concat(this.onfinish?[this.onfinish]:[]);setTimeout(function(){c.forEach(function(a){a.call(b.target,b)})},0),this._finishedFlag=!0}}else this._finishedFlag=!1},_tick:function(a,b){this._idle||this._paused||(null==this._startTime?b&&(this.startTime=a-this._currentTime/this.playbackRate):this._isFinished||this._tickCurrentTime((a-this._startTime)*this.playbackRate)),b&&(this._currentTimePending=!1,this._fireEvents(a))},get _needsTick(){return this.playState in{pending:1,running:1}||!this._finishedFlag},_targetAnimations:function(){var a=this._effect._target;return a._activeAnimations||(a._activeAnimations=[]),a._activeAnimations},_markTarget:function(){var a=this._targetAnimations();-1===a.indexOf(this)&&a.push(this)},_unmarkTarget:function(){var a=this._targetAnimations(),b=a.indexOf(this);-1!==b&&a.splice(b,1)}}}(a,b),function(a,b,c){function d(a){var b=j;j=[],a<q.currentTime&&(a=q.currentTime),q._animations.sort(e),q._animations=h(a,!0,q._animations)[0],b.forEach(function(b){b[1](a)}),g(),l=void 0}function e(a,b){return a._sequenceNumber-b._sequenceNumber}function f(){this._animations=[],this.currentTime=window.performance&&performance.now?performance.now():0}function g(){o.forEach(function(a){a()}),o.length=0}function h(a,c,d){p=!0,n=!1,b.timeline.currentTime=a,m=!1;var e=[],f=[],g=[],h=[];return d.forEach(function(b){b._tick(a,c),b._inEffect?(f.push(b._effect),b._markTarget()):(e.push(b._effect),b._unmarkTarget()),b._needsTick&&(m=!0);var d=b._inEffect||b._needsTick;b._inTimeline=d,d?g.push(b):h.push(b)}),o.push.apply(o,e),o.push.apply(o,f),m&&requestAnimationFrame(function(){}),p=!1,[g,h]}var i=window.requestAnimationFrame,j=[],k=0;window.requestAnimationFrame=function(a){var b=k++;return 0==j.length&&i(d),j.push([b,a]),b},window.cancelAnimationFrame=function(a){j.forEach(function(b){b[0]==a&&(b[1]=function(){})})},f.prototype={_play:function(c){c._timing=a.normalizeTimingInput(c.timing);var d=new b.Animation(c);return d._idle=!1,d._timeline=this,this._animations.push(d),b.restart(),b.applyDirtiedAnimation(d),d}};var l=void 0,m=!1,n=!1;b.restart=function(){return m||(m=!0,requestAnimationFrame(function(){}),n=!0),n},b.applyDirtiedAnimation=function(a){if(!p){a._markTarget();var c=a._targetAnimations();c.sort(e),h(b.timeline.currentTime,!1,c.slice())[1].forEach(function(a){var b=q._animations.indexOf(a);-1!==b&&q._animations.splice(b,1)}),g()}};var o=[],p=!1,q=new f;b.timeline=q}(a,b),function(a){function b(a,b){var c=a.exec(b);if(c)return c=a.ignoreCase?c[0].toLowerCase():c[0],[c,b.substr(c.length)]}function c(a,b){b=b.replace(/^\s*/,"");var c=a(b);if(c)return[c[0],c[1].replace(/^\s*/,"")]}function d(a,d,e){a=c.bind(null,a);for(var f=[];;){var g=a(e);if(!g)return[f,e];if(f.push(g[0]),e=g[1],!(g=b(d,e))||""==g[1])return[f,e];e=g[1]}}function e(a,b){for(var c=0,d=0;d<b.length&&(!/\s|,/.test(b[d])||0!=c);d++)if("("==b[d])c++;else if(")"==b[d]&&(c--,0==c&&d++,c<=0))break;var e=a(b.substr(0,d));return void 0==e?void 0:[e,b.substr(d)]}function f(a,b){for(var c=a,d=b;c&&d;)c>d?c%=d:d%=c;return c=a*b/(c+d)}function g(a){return function(b){var c=a(b);return c&&(c[0]=void 0),c}}function h(a,b){return function(c){return a(c)||[b,c]}}function i(b,c){for(var d=[],e=0;e<b.length;e++){var f=a.consumeTrimmed(b[e],c);if(!f||""==f[0])return;void 0!==f[0]&&d.push(f[0]),c=f[1]}if(""==c)return d}function j(a,b,c,d,e){for(var g=[],h=[],i=[],j=f(d.length,e.length),k=0;k<j;k++){var l=b(d[k%d.length],e[k%e.length]);if(!l)return;g.push(l[0]),h.push(l[1]),i.push(l[2])}return[g,h,function(b){var d=b.map(function(a,b){return i[b](a)}).join(c);return a?a(d):d}]}function k(a,b,c){for(var d=[],e=[],f=[],g=0,h=0;h<c.length;h++)if("function"==typeof c[h]){var i=c[h](a[g],b[g++]);d.push(i[0]),e.push(i[1]),f.push(i[2])}else!function(a){d.push(!1),e.push(!1),f.push(function(){return c[a]})}(h);return[d,e,function(a){for(var b="",c=0;c<a.length;c++)b+=f[c](a[c]);return b}]}a.consumeToken=b,a.consumeTrimmed=c,a.consumeRepeated=d,a.consumeParenthesised=e,a.ignore=g,a.optional=h,a.consumeList=i,a.mergeNestedRepeated=j.bind(null,null),a.mergeWrappedNestedRepeated=j,a.mergeList=k}(b),function(a){function b(b){function c(b){var c=a.consumeToken(/^inset/i,b);return c?(d.inset=!0,c):(c=a.consumeLengthOrPercent(b))?(d.lengths.push(c[0]),c):(c=a.consumeColor(b),c?(d.color=c[0],c):void 0)}var d={inset:!1,lengths:[],color:null},e=a.consumeRepeated(c,/^/,b);if(e&&e[0].length)return[d,e[1]]}function c(c){var d=a.consumeRepeated(b,/^,/,c);if(d&&""==d[1])return d[0]}function d(b,c){for(;b.lengths.length<Math.max(b.lengths.length,c.lengths.length);)b.lengths.push({px:0});for(;c.lengths.length<Math.max(b.lengths.length,c.lengths.length);)c.lengths.push({px:0});if(b.inset==c.inset&&!!b.color==!!c.color){for(var d,e=[],f=[[],0],g=[[],0],h=0;h<b.lengths.length;h++){var i=a.mergeDimensions(b.lengths[h],c.lengths[h],2==h);f[0].push(i[0]),g[0].push(i[1]),e.push(i[2])}if(b.color&&c.color){var j=a.mergeColors(b.color,c.color);f[1]=j[0],g[1]=j[1],d=j[2]}return[f,g,function(a){for(var c=b.inset?"inset ":" ",f=0;f<e.length;f++)c+=e[f](a[0][f])+" ";return d&&(c+=d(a[1])),c}]}}function e(b,c,d,e){function f(a){return{inset:a,color:[0,0,0,0],lengths:[{px:0},{px:0},{px:0},{px:0}]}}for(var g=[],h=[],i=0;i<d.length||i<e.length;i++){var j=d[i]||f(e[i].inset),k=e[i]||f(d[i].inset);g.push(j),h.push(k)}return a.mergeNestedRepeated(b,c,g,h)}var f=e.bind(null,d,", ");a.addPropertiesHandler(c,f,["box-shadow","text-shadow"])}(b),function(a,b){function c(a){return a.toFixed(3).replace(/0+$/,"").replace(/\.$/,"")}function d(a,b,c){return Math.min(b,Math.max(a,c))}function e(a){if(/^\s*[-+]?(\d*\.)?\d+\s*$/.test(a))return Number(a)}function f(a,b){return[a,b,c]}function g(a,b){if(0!=a)return i(0,1/0)(a,b)}function h(a,b){return[a,b,function(a){return Math.round(d(1,1/0,a))}]}function i(a,b){return function(e,f){return[e,f,function(e){return c(d(a,b,e))}]}}function j(a){var b=a.trim().split(/\s*[\s,]\s*/);if(0!==b.length){for(var c=[],d=0;d<b.length;d++){var f=e(b[d]);if(void 0===f)return;c.push(f)}return c}}function k(a,b){if(a.length==b.length)return[a,b,function(a){return a.map(c).join(" ")}]}function l(a,b){return[a,b,Math.round]}a.clamp=d,a.addPropertiesHandler(j,k,["stroke-dasharray"]),a.addPropertiesHandler(e,i(0,1/0),["border-image-width","line-height"]),a.addPropertiesHandler(e,i(0,1),["opacity","shape-image-threshold"]),a.addPropertiesHandler(e,g,["flex-grow","flex-shrink"]),a.addPropertiesHandler(e,h,["orphans","widows"]),a.addPropertiesHandler(e,l,["z-index"]),a.parseNumber=e,a.parseNumberList=j,a.mergeNumbers=f,a.numberToString=c}(b),function(a,b){function c(a,b){if("visible"==a||"visible"==b)return[0,1,function(c){return c<=0?a:c>=1?b:"visible"}]}a.addPropertiesHandler(String,c,["visibility"])}(b),function(a,b){function c(a){a=a.trim(),f.fillStyle="#000",f.fillStyle=a;var b=f.fillStyle;if(f.fillStyle="#fff",f.fillStyle=a,b==f.fillStyle){f.fillRect(0,0,1,1);var c=f.getImageData(0,0,1,1).data;f.clearRect(0,0,1,1);var d=c[3]/255;return[c[0]*d,c[1]*d,c[2]*d,d]}}function d(b,c){return[b,c,function(b){function c(a){return Math.max(0,Math.min(255,a))}if(b[3])for(var d=0;d<3;d++)b[d]=Math.round(c(b[d]/b[3]));return b[3]=a.numberToString(a.clamp(0,1,b[3])),"rgba("+b.join(",")+")"}]}var e=document.createElementNS("http://www.w3.org/1999/xhtml","canvas");e.width=e.height=1;var f=e.getContext("2d");a.addPropertiesHandler(c,d,["background-color","border-bottom-color","border-left-color","border-right-color","border-top-color","color","fill","flood-color","lighting-color","outline-color","stop-color","stroke","text-decoration-color"]),a.consumeColor=a.consumeParenthesised.bind(null,c),a.mergeColors=d}(b),function(a,b){function c(a){function b(){var b=h.exec(a);g=b?b[0]:void 0}function c(){var a=Number(g);return b(),a}function d(){if("("!==g)return c();b();var a=f();return")"!==g?NaN:(b(),a)}function e(){for(var a=d();"*"===g||"/"===g;){var c=g;b();var e=d();"*"===c?a*=e:a/=e}return a}function f(){for(var a=e();"+"===g||"-"===g;){var c=g;b();var d=e();"+"===c?a+=d:a-=d}return a}var g,h=/([\+\-\w\.]+|[\(\)\*\/])/g;return b(),f()}function d(a,b){if("0"==(b=b.trim().toLowerCase())&&"px".search(a)>=0)return{px:0};if(/^[^(]*$|^calc/.test(b)){b=b.replace(/calc\(/g,"(");var d={};b=b.replace(a,function(a){return d[a]=null,"U"+a});for(var e="U("+a.source+")",f=b.replace(/[-+]?(\d*\.)?\d+([Ee][-+]?\d+)?/g,"N").replace(new RegExp("N"+e,"g"),"D").replace(/\s[+-]\s/g,"O").replace(/\s/g,""),g=[/N\*(D)/g,/(N|D)[*\/]N/g,/(N|D)O\1/g,/\((N|D)\)/g],h=0;h<g.length;)g[h].test(f)?(f=f.replace(g[h],"$1"),h=0):h++;if("D"==f){for(var i in d){var j=c(b.replace(new RegExp("U"+i,"g"),"").replace(new RegExp(e,"g"),"*0"));if(!isFinite(j))return;d[i]=j}return d}}}function e(a,b){return f(a,b,!0)}function f(b,c,d){var e,f=[];for(e in b)f.push(e);for(e in c)f.indexOf(e)<0&&f.push(e);return b=f.map(function(a){return b[a]||0}),c=f.map(function(a){return c[a]||0}),[b,c,function(b){var c=b.map(function(c,e){return 1==b.length&&d&&(c=Math.max(c,0)),a.numberToString(c)+f[e]}).join(" + ");return b.length>1?"calc("+c+")":c}]}var g="px|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc",h=d.bind(null,new RegExp(g,"g")),i=d.bind(null,new RegExp(g+"|%","g")),j=d.bind(null,/deg|rad|grad|turn/g);a.parseLength=h,a.parseLengthOrPercent=i,a.consumeLengthOrPercent=a.consumeParenthesised.bind(null,i),a.parseAngle=j,a.mergeDimensions=f;var k=a.consumeParenthesised.bind(null,h),l=a.consumeRepeated.bind(void 0,k,/^/),m=a.consumeRepeated.bind(void 0,l,/^,/);a.consumeSizePairList=m;var n=function(a){var b=m(a);if(b&&""==b[1])return b[0]},o=a.mergeNestedRepeated.bind(void 0,e," "),p=a.mergeNestedRepeated.bind(void 0,o,",");a.mergeNonNegativeSizePair=o,a.addPropertiesHandler(n,p,["background-size"]),a.addPropertiesHandler(i,e,["border-bottom-width","border-image-width","border-left-width","border-right-width","border-top-width","flex-basis","font-size","height","line-height","max-height","max-width","outline-width","width"]),a.addPropertiesHandler(i,f,["border-bottom-left-radius","border-bottom-right-radius","border-top-left-radius","border-top-right-radius","bottom","left","letter-spacing","margin-bottom","margin-left","margin-right","margin-top","min-height","min-width","outline-offset","padding-bottom","padding-left","padding-right","padding-top","perspective","right","shape-margin","stroke-dashoffset","text-indent","top","vertical-align","word-spacing"])}(b),function(a,b){function c(b){return a.consumeLengthOrPercent(b)||a.consumeToken(/^auto/,b)}function d(b){var d=a.consumeList([a.ignore(a.consumeToken.bind(null,/^rect/)),a.ignore(a.consumeToken.bind(null,/^\(/)),a.consumeRepeated.bind(null,c,/^,/),a.ignore(a.consumeToken.bind(null,/^\)/))],b);if(d&&4==d[0].length)return d[0]}function e(b,c){return"auto"==b||"auto"==c?[!0,!1,function(d){var e=d?b:c;if("auto"==e)return"auto";var f=a.mergeDimensions(e,e);return f[2](f[0])}]:a.mergeDimensions(b,c)}function f(a){return"rect("+a+")"}var g=a.mergeWrappedNestedRepeated.bind(null,f,e,", ");a.parseBox=d,a.mergeBoxes=g,a.addPropertiesHandler(d,g,["clip"])}(b),function(a,b){function c(a){return function(b){var c=0;return a.map(function(a){return a===k?b[c++]:a})}}function d(a){return a}function e(b){if("none"==(b=b.toLowerCase().trim()))return[];for(var c,d=/\s*(\w+)\(([^)]*)\)/g,e=[],f=0;c=d.exec(b);){if(c.index!=f)return;f=c.index+c[0].length;var g=c[1],h=n[g];if(!h)return;var i=c[2].split(","),j=h[0];if(j.length<i.length)return;for(var k=[],o=0;o<j.length;o++){var p,q=i[o],r=j[o];if(void 0===(p=q?{A:function(b){return"0"==b.trim()?m:a.parseAngle(b)},N:a.parseNumber,T:a.parseLengthOrPercent,L:a.parseLength}[r.toUpperCase()](q):{a:m,n:k[0],t:l}[r]))return;k.push(p)}if(e.push({t:g,d:k}),d.lastIndex==b.length)return e}}function f(a){return a.toFixed(6).replace(".000000","")}function g(b,c){if(b.decompositionPair!==c){b.decompositionPair=c;var d=a.makeMatrixDecomposition(b)}if(c.decompositionPair!==b){c.decompositionPair=b;var e=a.makeMatrixDecomposition(c)}return null==d[0]||null==e[0]?[[!1],[!0],function(a){return a?c[0].d:b[0].d}]:(d[0].push(0),e[0].push(1),[d,e,function(b){var c=a.quat(d[0][3],e[0][3],b[5]);return a.composeMatrix(b[0],b[1],b[2],c,b[4]).map(f).join(",")}])}function h(a){return a.replace(/[xy]/,"")}function i(a){return a.replace(/(x|y|z|3d)?$/,"3d")}function j(b,c){var d=a.makeMatrixDecomposition&&!0,e=!1;if(!b.length||!c.length){b.length||(e=!0,b=c,c=[]);for(var f=0;f<b.length;f++){var j=b[f].t,k=b[f].d,l="scale"==j.substr(0,5)?1:0;c.push({t:j,d:k.map(function(a){if("number"==typeof a)return l;var b={};for(var c in a)b[c]=l;return b})})}}var m=function(a,b){return"perspective"==a&&"perspective"==b||("matrix"==a||"matrix3d"==a)&&("matrix"==b||"matrix3d"==b)},o=[],p=[],q=[];if(b.length!=c.length){if(!d)return;var r=g(b,c);o=[r[0]],p=[r[1]],q=[["matrix",[r[2]]]]}else for(var f=0;f<b.length;f++){var j,s=b[f].t,t=c[f].t,u=b[f].d,v=c[f].d,w=n[s],x=n[t];if(m(s,t)){if(!d)return;var r=g([b[f]],[c[f]]);o.push(r[0]),p.push(r[1]),q.push(["matrix",[r[2]]])}else{if(s==t)j=s;else if(w[2]&&x[2]&&h(s)==h(t))j=h(s),u=w[2](u),v=x[2](v);else{if(!w[1]||!x[1]||i(s)!=i(t)){if(!d)return;var r=g(b,c);o=[r[0]],p=[r[1]],q=[["matrix",[r[2]]]];break}j=i(s),u=w[1](u),v=x[1](v)}for(var y=[],z=[],A=[],B=0;B<u.length;B++){var C="number"==typeof u[B]?a.mergeNumbers:a.mergeDimensions,r=C(u[B],v[B]);y[B]=r[0],z[B]=r[1],A.push(r[2])}o.push(y),p.push(z),q.push([j,A])}}if(e){var D=o;o=p,p=D}return[o,p,function(a){return a.map(function(a,b){var c=a.map(function(a,c){return q[b][1][c](a)}).join(",");return"matrix"==q[b][0]&&16==c.split(",").length&&(q[b][0]="matrix3d"),q[b][0]+"("+c+")"}).join(" ")}]}var k=null,l={px:0},m={deg:0},n={matrix:["NNNNNN",[k,k,0,0,k,k,0,0,0,0,1,0,k,k,0,1],d],matrix3d:["NNNNNNNNNNNNNNNN",d],rotate:["A"],rotatex:["A"],rotatey:["A"],rotatez:["A"],rotate3d:["NNNA"],perspective:["L"],scale:["Nn",c([k,k,1]),d],scalex:["N",c([k,1,1]),c([k,1])],scaley:["N",c([1,k,1]),c([1,k])],scalez:["N",c([1,1,k])],scale3d:["NNN",d],skew:["Aa",null,d],skewx:["A",null,c([k,m])],skewy:["A",null,c([m,k])],translate:["Tt",c([k,k,l]),d],translatex:["T",c([k,l,l]),c([k,l])],translatey:["T",c([l,k,l]),c([l,k])],translatez:["L",c([l,l,k])],translate3d:["TTL",d]};a.addPropertiesHandler(e,j,["transform"]),a.transformToSvgMatrix=function(b){var c=a.transformListToMatrix(e(b));return"matrix("+f(c[0])+" "+f(c[1])+" "+f(c[4])+" "+f(c[5])+" "+f(c[12])+" "+f(c[13])+")"}}(b),function(a,b){function c(a,b){b.concat([a]).forEach(function(b){b in document.documentElement.style&&(d[a]=b),e[b]=a})}var d={},e={};c("transform",["webkitTransform","msTransform"]),c("transformOrigin",["webkitTransformOrigin"]),c("perspective",["webkitPerspective"]),c("perspectiveOrigin",["webkitPerspectiveOrigin"]),a.propertyName=function(a){return d[a]||a},a.unprefixedPropertyName=function(a){return e[a]||a}}(b)}(),function(){if(void 0===document.createElement("div").animate([]).oncancel){var a;if(window.performance&&performance.now)var a=function(){return performance.now()};else var a=function(){return Date.now()};var b=function(a,b,c){this.target=a,this.currentTime=b,this.timelineTime=c,this.type="cancel",this.bubbles=!1,this.cancelable=!1,this.currentTarget=a,this.defaultPrevented=!1,this.eventPhase=Event.AT_TARGET,this.timeStamp=Date.now()},c=window.Element.prototype.animate;window.Element.prototype.animate=function(d,e){var f=c.call(this,d,e);f._cancelHandlers=[],f.oncancel=null;var g=f.cancel;f.cancel=function(){g.call(this);var c=new b(this,null,a()),d=this._cancelHandlers.concat(this.oncancel?[this.oncancel]:[]);setTimeout(function(){d.forEach(function(a){a.call(c.target,c)})},0)};var h=f.addEventListener;f.addEventListener=function(a,b){"function"==typeof b&&"cancel"==a?this._cancelHandlers.push(b):h.call(this,a,b)};var i=f.removeEventListener;return f.removeEventListener=function(a,b){if("cancel"==a){var c=this._cancelHandlers.indexOf(b);c>=0&&this._cancelHandlers.splice(c,1)}else i.call(this,a,b)},f}}}(),function(a){var b=document.documentElement,c=null,d=!1;try{var e=getComputedStyle(b).getPropertyValue("opacity"),f="0"==e?"1":"0";c=b.animate({opacity:[f,f]},{duration:1}),c.currentTime=0,d=getComputedStyle(b).getPropertyValue("opacity")==f}catch(a){}finally{c&&c.cancel()}if(!d){var g=window.Element.prototype.animate;window.Element.prototype.animate=function(b,c){return window.Symbol&&Symbol.iterator&&Array.prototype.from&&b[Symbol.iterator]&&(b=Array.from(b)),Array.isArray(b)||null===b||(b=a.convertToArrayForm(b)),g.call(this,b,c)}}}(a),function(a,b,c){function d(a){var c=b.timeline;c.currentTime=a,c._discardAnimations(),0==c._animations.length?f=!1:requestAnimationFrame(d)}var e=window.requestAnimationFrame;window.requestAnimationFrame=function(a){return e(function(c){b.timeline._updateAnimationsPromises(),a(c),b.timeline._updateAnimationsPromises()})},b.AnimationTimeline=function(){this._animations=[],this.currentTime=void 0},b.AnimationTimeline.prototype={getAnimations:function(){return this._discardAnimations(),this._animations.slice()},_updateAnimationsPromises:function(){b.animationsWithPromises=b.animationsWithPromises.filter(function(a){return a._updatePromises()})},_discardAnimations:function(){this._updateAnimationsPromises(),this._animations=this._animations.filter(function(a){return"finished"!=a.playState&&"idle"!=a.playState})},_play:function(a){var c=new b.Animation(a,this);return this._animations.push(c),b.restartWebAnimationsNextTick(),c._updatePromises(),c._animation.play(),c._updatePromises(),c},play:function(a){return a&&a.remove(),this._play(a)}};var f=!1;b.restartWebAnimationsNextTick=function(){f||(f=!0,requestAnimationFrame(d))};var g=new b.AnimationTimeline;b.timeline=g;try{Object.defineProperty(window.document,"timeline",{configurable:!0,get:function(){return g}})}catch(a){}try{window.document.timeline=g}catch(a){}}(0,c),function(a,b,c){b.animationsWithPromises=[],b.Animation=function(b,c){if(this.id="",b&&b._id&&(this.id=b._id),this.effect=b,b&&(b._animation=this),!c)throw new Error("Animation with null timeline is not supported");this._timeline=c,this._sequenceNumber=a.sequenceNumber++,this._holdTime=0,this._paused=!1,this._isGroup=!1,this._animation=null,this._childAnimations=[],this._callback=null,this._oldPlayState="idle",this._rebuildUnderlyingAnimation(),this._animation.cancel(),this._updatePromises()},b.Animation.prototype={_updatePromises:function(){var a=this._oldPlayState,b=this.playState;return this._readyPromise&&b!==a&&("idle"==b?(this._rejectReadyPromise(),this._readyPromise=void 0):"pending"==a?this._resolveReadyPromise():"pending"==b&&(this._readyPromise=void 0)),this._finishedPromise&&b!==a&&("idle"==b?(this._rejectFinishedPromise(),this._finishedPromise=void 0):"finished"==b?this._resolveFinishedPromise():"finished"==a&&(this._finishedPromise=void 0)),this._oldPlayState=this.playState,this._readyPromise||this._finishedPromise},_rebuildUnderlyingAnimation:function(){this._updatePromises();var a,c,d,e,f=!!this._animation;f&&(a=this.playbackRate,c=this._paused,d=this.startTime,e=this.currentTime,this._animation.cancel(),this._animation._wrapper=null,this._animation=null),(!this.effect||this.effect instanceof window.KeyframeEffect)&&(this._animation=b.newUnderlyingAnimationForKeyframeEffect(this.effect),b.bindAnimationForKeyframeEffect(this)),(this.effect instanceof window.SequenceEffect||this.effect instanceof window.GroupEffect)&&(this._animation=b.newUnderlyingAnimationForGroup(this.effect),b.bindAnimationForGroup(this)),this.effect&&this.effect._onsample&&b.bindAnimationForCustomEffect(this),f&&(1!=a&&(this.playbackRate=a),null!==d?this.startTime=d:null!==e?this.currentTime=e:null!==this._holdTime&&(this.currentTime=this._holdTime),c&&this.pause()),this._updatePromises()},_updateChildren:function(){if(this.effect&&"idle"!=this.playState){var a=this.effect._timing.delay;this._childAnimations.forEach(function(c){this._arrangeChildren(c,a),this.effect instanceof window.SequenceEffect&&(a+=b.groupChildDuration(c.effect))}.bind(this))}},_setExternalAnimation:function(a){if(this.effect&&this._isGroup)for(var b=0;b<this.effect.children.length;b++)this.effect.children[b]._animation=a,this._childAnimations[b]._setExternalAnimation(a)},_constructChildAnimations:function(){if(this.effect&&this._isGroup){var a=this.effect._timing.delay;this._removeChildAnimations(),this.effect.children.forEach(function(c){var d=b.timeline._play(c);this._childAnimations.push(d),d.playbackRate=this.playbackRate,this._paused&&d.pause(),c._animation=this.effect._animation,this._arrangeChildren(d,a),this.effect instanceof window.SequenceEffect&&(a+=b.groupChildDuration(c))}.bind(this))}},_arrangeChildren:function(a,b){null===this.startTime?a.currentTime=this.currentTime-b/this.playbackRate:a.startTime!==this.startTime+b/this.playbackRate&&(a.startTime=this.startTime+b/this.playbackRate)},get timeline(){return this._timeline},get playState(){return this._animation?this._animation.playState:"idle"},get finished(){return window.Promise?(this._finishedPromise||(-1==b.animationsWithPromises.indexOf(this)&&b.animationsWithPromises.push(this),this._finishedPromise=new Promise(function(a,b){this._resolveFinishedPromise=function(){a(this)},this._rejectFinishedPromise=function(){b({type:DOMException.ABORT_ERR,name:"AbortError"})}}.bind(this)),"finished"==this.playState&&this._resolveFinishedPromise()),this._finishedPromise):(console.warn("Animation Promises require JavaScript Promise constructor"),null)},get ready(){return window.Promise?(this._readyPromise||(-1==b.animationsWithPromises.indexOf(this)&&b.animationsWithPromises.push(this),this._readyPromise=new Promise(function(a,b){this._resolveReadyPromise=function(){a(this)},this._rejectReadyPromise=function(){b({type:DOMException.ABORT_ERR,name:"AbortError"})}}.bind(this)),"pending"!==this.playState&&this._resolveReadyPromise()),this._readyPromise):(console.warn("Animation Promises require JavaScript Promise constructor"),null)},get onfinish(){return this._animation.onfinish},set onfinish(a){this._animation.onfinish="function"==typeof a?function(b){b.target=this,a.call(this,b)}.bind(this):a},get oncancel(){return this._animation.oncancel},set oncancel(a){this._animation.oncancel="function"==typeof a?function(b){b.target=this,a.call(this,b)}.bind(this):a},get currentTime(){this._updatePromises();var a=this._animation.currentTime;return this._updatePromises(),a},set currentTime(a){this._updatePromises(),this._animation.currentTime=isFinite(a)?a:Math.sign(a)*Number.MAX_VALUE,this._register(),this._forEachChild(function(b,c){b.currentTime=a-c}),this._updatePromises()},get startTime(){return this._animation.startTime},set startTime(a){this._updatePromises(),this._animation.startTime=isFinite(a)?a:Math.sign(a)*Number.MAX_VALUE,this._register(),this._forEachChild(function(b,c){b.startTime=a+c}),this._updatePromises()},get playbackRate(){return this._animation.playbackRate},set playbackRate(a){this._updatePromises();var b=this.currentTime;this._animation.playbackRate=a,this._forEachChild(function(b){b.playbackRate=a}),null!==b&&(this.currentTime=b),this._updatePromises()},play:function(){this._updatePromises(),this._paused=!1,this._animation.play(),-1==this._timeline._animations.indexOf(this)&&this._timeline._animations.push(this),this._register(),b.awaitStartTime(this),this._forEachChild(function(a){var b=a.currentTime;a.play(),a.currentTime=b}),this._updatePromises()},pause:function(){this._updatePromises(),this.currentTime&&(this._holdTime=this.currentTime),this._animation.pause(),this._register(),this._forEachChild(function(a){a.pause()}),this._paused=!0,this._updatePromises()},finish:function(){this._updatePromises(),this._animation.finish(),this._register(),this._updatePromises()},cancel:function(){this._updatePromises(),this._animation.cancel(),this._register(),this._removeChildAnimations(),this._updatePromises()},reverse:function(){this._updatePromises();var a=this.currentTime;this._animation.reverse(),this._forEachChild(function(a){a.reverse()}),null!==a&&(this.currentTime=a),this._updatePromises()},addEventListener:function(a,b){var c=b;"function"==typeof b&&(c=function(a){a.target=this,b.call(this,a)}.bind(this),b._wrapper=c),this._animation.addEventListener(a,c)},removeEventListener:function(a,b){this._animation.removeEventListener(a,b&&b._wrapper||b)},_removeChildAnimations:function(){for(;this._childAnimations.length;)this._childAnimations.pop().cancel()},_forEachChild:function(b){var c=0;if(this.effect.children&&this._childAnimations.length<this.effect.children.length&&this._constructChildAnimations(),this._childAnimations.forEach(function(a){b.call(this,a,c),this.effect instanceof window.SequenceEffect&&(c+=a.effect.activeDuration)}.bind(this)),"pending"!=this.playState){var d=this.effect._timing,e=this.currentTime;null!==e&&(e=a.calculateIterationProgress(a.calculateActiveDuration(d),e,d)),(null==e||isNaN(e))&&this._removeChildAnimations()}}},window.Animation=b.Animation}(a,c),function(a,b,c){function d(b){this._frames=a.normalizeKeyframes(b)}function e(){for(var a=!1;i.length;)i.shift()._updateChildren(),a=!0;return a}var f=function(a){if(a._animation=void 0,a instanceof window.SequenceEffect||a instanceof window.GroupEffect)for(var b=0;b<a.children.length;b++)f(a.children[b])};b.removeMulti=function(a){for(var b=[],c=0;c<a.length;c++){var d=a[c];d._parent?(-1==b.indexOf(d._parent)&&b.push(d._parent),d._parent.children.splice(d._parent.children.indexOf(d),1),d._parent=null,f(d)):d._animation&&d._animation.effect==d&&(d._animation.cancel(),d._animation.effect=new KeyframeEffect(null,[]),d._animation._callback&&(d._animation._callback._animation=null),d._animation._rebuildUnderlyingAnimation(),f(d))}for(c=0;c<b.length;c++)b[c]._rebuild()},b.KeyframeEffect=function(b,c,e,f){return this.target=b,this._parent=null,e=a.numericTimingToObject(e),this._timingInput=a.cloneTimingInput(e),this._timing=a.normalizeTimingInput(e),this.timing=a.makeTiming(e,!1,this),this.timing._effect=this,"function"==typeof c?(a.deprecated("Custom KeyframeEffect","2015-06-22","Use KeyframeEffect.onsample instead."),this._normalizedKeyframes=c):this._normalizedKeyframes=new d(c),this._keyframes=c,this.activeDuration=a.calculateActiveDuration(this._timing),this._id=f,this},b.KeyframeEffect.prototype={getFrames:function(){return"function"==typeof this._normalizedKeyframes?this._normalizedKeyframes:this._normalizedKeyframes._frames},set onsample(a){if("function"==typeof this.getFrames())throw new Error("Setting onsample on custom effect KeyframeEffect is not supported.");this._onsample=a,this._animation&&this._animation._rebuildUnderlyingAnimation()},get parent(){return this._parent},clone:function(){if("function"==typeof this.getFrames())throw new Error("Cloning custom effects is not supported.");var b=new KeyframeEffect(this.target,[],a.cloneTimingInput(this._timingInput),this._id);return b._normalizedKeyframes=this._normalizedKeyframes,b._keyframes=this._keyframes,b},remove:function(){b.removeMulti([this])}};var g=Element.prototype.animate;Element.prototype.animate=function(a,c){var d="";return c&&c.id&&(d=c.id),b.timeline._play(new b.KeyframeEffect(this,a,c,d))};var h=document.createElementNS("http://www.w3.org/1999/xhtml","div");b.newUnderlyingAnimationForKeyframeEffect=function(a){if(a){var b=a.target||h,c=a._keyframes;"function"==typeof c&&(c=[]);var d=a._timingInput;d.id=a._id}else var b=h,c=[],d=0;return g.apply(b,[c,d])},b.bindAnimationForKeyframeEffect=function(a){a.effect&&"function"==typeof a.effect._normalizedKeyframes&&b.bindAnimationForCustomEffect(a)};var i=[];b.awaitStartTime=function(a){null===a.startTime&&a._isGroup&&(0==i.length&&requestAnimationFrame(e),i.push(a))};var j=window.getComputedStyle;Object.defineProperty(window,"getComputedStyle",{configurable:!0,enumerable:!0,value:function(){b.timeline._updateAnimationsPromises();var a=j.apply(this,arguments);return e()&&(a=j.apply(this,arguments)),b.timeline._updateAnimationsPromises(),a}}),window.KeyframeEffect=b.KeyframeEffect,window.Element.prototype.getAnimations=function(){return document.timeline.getAnimations().filter(function(a){return null!==a.effect&&a.effect.target==this}.bind(this))}}(a,c),function(a,b,c){function d(a){a._registered||(a._registered=!0,g.push(a),h||(h=!0,requestAnimationFrame(e)))}function e(a){var b=g;g=[],b.sort(function(a,b){return a._sequenceNumber-b._sequenceNumber}),b=b.filter(function(a){a();var b=a._animation?a._animation.playState:"idle";return"running"!=b&&"pending"!=b&&(a._registered=!1),a._registered}),g.push.apply(g,b),g.length?(h=!0,requestAnimationFrame(e)):h=!1}var f=(document.createElementNS("http://www.w3.org/1999/xhtml","div"),0);b.bindAnimationForCustomEffect=function(b){var c,e=b.effect.target,g="function"==typeof b.effect.getFrames();c=g?b.effect.getFrames():b.effect._onsample;var h=b.effect.timing,i=null;h=a.normalizeTimingInput(h);var j=function(){var d=j._animation?j._animation.currentTime:null;null!==d&&(d=a.calculateIterationProgress(a.calculateActiveDuration(h),d,h),isNaN(d)&&(d=null)),d!==i&&(g?c(d,e,b.effect):c(d,b.effect,b.effect._animation)),i=d};j._animation=b,j._registered=!1,j._sequenceNumber=f++,b._callback=j,d(j)};var g=[],h=!1;b.Animation.prototype._register=function(){this._callback&&d(this._callback)}}(a,c),function(a,b,c){function d(a){return a._timing.delay+a.activeDuration+a._timing.endDelay}function e(b,c,d){this._id=d,this._parent=null,this.children=b||[],this._reparent(this.children),c=a.numericTimingToObject(c),this._timingInput=a.cloneTimingInput(c),this._timing=a.normalizeTimingInput(c,!0),this.timing=a.makeTiming(c,!0,this),this.timing._effect=this,"auto"===this._timing.duration&&(this._timing.duration=this.activeDuration)}window.SequenceEffect=function(){e.apply(this,arguments)},window.GroupEffect=function(){e.apply(this,arguments)},e.prototype={_isAncestor:function(a){for(var b=this;null!==b;){if(b==a)return!0;b=b._parent}return!1},_rebuild:function(){for(var a=this;a;)"auto"===a.timing.duration&&(a._timing.duration=a.activeDuration),a=a._parent;this._animation&&this._animation._rebuildUnderlyingAnimation()},_reparent:function(a){b.removeMulti(a);for(var c=0;c<a.length;c++)a[c]._parent=this},_putChild:function(a,b){for(var c=b?"Cannot append an ancestor or self":"Cannot prepend an ancestor or self",d=0;d<a.length;d++)if(this._isAncestor(a[d]))throw{type:DOMException.HIERARCHY_REQUEST_ERR,name:"HierarchyRequestError",message:c};for(var d=0;d<a.length;d++)b?this.children.push(a[d]):this.children.unshift(a[d]);this._reparent(a),this._rebuild()},append:function(){this._putChild(arguments,!0)},prepend:function(){this._putChild(arguments,!1)},get parent(){return this._parent},get firstChild(){return this.children.length?this.children[0]:null},get lastChild(){return this.children.length?this.children[this.children.length-1]:null},clone:function(){for(var b=a.cloneTimingInput(this._timingInput),c=[],d=0;d<this.children.length;d++)c.push(this.children[d].clone());return this instanceof GroupEffect?new GroupEffect(c,b):new SequenceEffect(c,b)},remove:function(){b.removeMulti([this])}},window.SequenceEffect.prototype=Object.create(e.prototype),Object.defineProperty(window.SequenceEffect.prototype,"activeDuration",{get:function(){var a=0;return this.children.forEach(function(b){a+=d(b)}),Math.max(a,0)}}),window.GroupEffect.prototype=Object.create(e.prototype),Object.defineProperty(window.GroupEffect.prototype,"activeDuration",{get:function(){var a=0;return this.children.forEach(function(b){a=Math.max(a,d(b))}),a}}),b.newUnderlyingAnimationForGroup=function(c){var d,e=null,f=function(b){var c=d._wrapper;if(c&&"pending"!=c.playState&&c.effect)return null==b?void c._removeChildAnimations():0==b&&c.playbackRate<0&&(e||(e=a.normalizeTimingInput(c.effect.timing)),b=a.calculateIterationProgress(a.calculateActiveDuration(e),-1,e),isNaN(b)||null==b)?(c._forEachChild(function(a){a.currentTime=-1}),void c._removeChildAnimations()):void 0},g=new KeyframeEffect(null,[],c._timing,c._id);return g.onsample=f,d=b.timeline._play(g)},b.bindAnimationForGroup=function(a){a._animation._wrapper=a,a._isGroup=!0,b.awaitStartTime(a),a._constructChildAnimations(),a._setExternalAnimation(a)},b.groupChildDuration=d}(a,c)}();(()=>{var d1e=Object.create;var BM=Object.defineProperty,m1e=Object.defineProperties,g1e=Object.getOwnPropertyDescriptor,_1e=Object.getOwnPropertyDescriptors,y1e=Object.getOwnPropertyNames,hdt=Object.getOwnPropertySymbols,v1e=Object.getPrototypeOf,pdt=Object.prototype.hasOwnProperty,x1e=Object.prototype.propertyIsEnumerable;var EI=Math.pow,fdt=(e,t,r)=>t in e?BM(e,t,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[t]=r,Kl=(e,t)=>{for(var r in t||(t={}))pdt.call(t,r)&&fdt(e,r,t[r]);if(hdt)for(var r of hdt(t))x1e.call(t,r)&&fdt(e,r,t[r]);return e},Mx=(e,t)=>m1e(e,_1e(t));var Ex=(e=>typeof require!="undefined"?require:typeof Proxy!="undefined"?new Proxy(e,{get:(t,r)=>(typeof require!="undefined"?require:t)[r]}):e)(function(e){if(typeof require!="undefined")return require.apply(this,arguments);throw new Error('Dynamic require of "'+e+'" is not supported')});var M=(e,t)=>()=>(e&&(t=e(e=0)),t);var H=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports),Ks=(e,t)=>{for(var r in t)BM(e,r,{get:t[r],enumerable:!0})},ddt=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let i of y1e(t))!pdt.call(e,i)&&i!==r&&BM(e,i,{get:()=>t[i],enumerable:!(n=g1e(t,i))||n.enumerable});return e};var Ee=(e,t,r)=>(r=e!=null?d1e(v1e(e)):{},ddt(t||!e||!e.__esModule?BM(r,"default",{value:e,enumerable:!0}):r,e)),Ut=e=>ddt(BM({},"__esModule",{value:!0}),e);var Ri=(e,t,r)=>new Promise((n,i)=>{var o=l=>{try{s(r.next(l))}catch(c){i(c)}},a=l=>{try{s(r.throw(l))}catch(c){i(c)}},s=l=>l.done?n(l.value):Promise.resolve(l.value).then(o,a);s((r=r.apply(e,t)).next())});var Odt=H((l_r,AI)=>{var mdt,gdt,_dt,ydt,vdt,xdt,bdt,wdt,Sdt,TI,uG,Mdt,Edt,Tdt,Tx,Cdt,Adt,Pdt,Idt,Ldt,kdt,Rdt,Ndt,Ddt,CI;(function(e){var t=typeof global=="object"?global:typeof self=="object"?self:typeof this=="object"?this:{};typeof define=="function"&&define.amd?define("tslib",["exports"],function(n){e(r(t,r(n)))}):typeof AI=="object"&&typeof AI.exports=="object"?e(r(t,r(AI.exports))):e(r(t));function r(n,i){return n!==t&&(typeof Object.create=="function"?Object.defineProperty(n,"__esModule",{value:!0}):n.__esModule=!0),function(o,a){return n[o]=i?i(o,a):a}}})(function(e){var t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(n,i){n.__proto__=i}||function(n,i){for(var o in i)Object.prototype.hasOwnProperty.call(i,o)&&(n[o]=i[o])};mdt=function(n,i){if(typeof i!="function"&&i!==null)throw new TypeError("Class extends value "+String(i)+" is not a constructor or null");t(n,i);function o(){this.constructor=n}n.prototype=i===null?Object.create(i):(o.prototype=i.prototype,new o)},gdt=Object.assign||function(n){for(var i,o=1,a=arguments.length;o<a;o++){i=arguments[o];for(var s in i)Object.prototype.hasOwnProperty.call(i,s)&&(n[s]=i[s])}return n},_dt=function(n,i){var o={};for(var a in n)Object.prototype.hasOwnProperty.call(n,a)&&i.indexOf(a)<0&&(o[a]=n[a]);if(n!=null&&typeof Object.getOwnPropertySymbols=="function")for(var s=0,a=Object.getOwnPropertySymbols(n);s<a.length;s++)i.indexOf(a[s])<0&&Object.prototype.propertyIsEnumerable.call(n,a[s])&&(o[a[s]]=n[a[s]]);return o},ydt=function(n,i,o,a){var s=arguments.length,l=s<3?i:a===null?a=Object.getOwnPropertyDescriptor(i,o):a,c;if(typeof Reflect=="object"&&typeof Reflect.decorate=="function")l=Reflect.decorate(n,i,o,a);else for(var u=n.length-1;u>=0;u--)(c=n[u])&&(l=(s<3?c(l):s>3?c(i,o,l):c(i,o))||l);return s>3&&l&&Object.defineProperty(i,o,l),l},vdt=function(n,i){return function(o,a){i(o,a,n)}},xdt=function(n,i){if(typeof Reflect=="object"&&typeof Reflect.metadata=="function")return Reflect.metadata(n,i)},bdt=function(n,i,o,a){function s(l){return l instanceof o?l:new o(function(c){c(l)})}return new(o||(o=Promise))(function(l,c){function u(p){try{f(a.next(p))}catch(d){c(d)}}function h(p){try{f(a.throw(p))}catch(d){c(d)}}function f(p){p.done?l(p.value):s(p.value).then(u,h)}f((a=a.apply(n,i||[])).next())})},wdt=function(n,i){var o={label:0,sent:function(){if(l[0]&1)throw l[1];return l[1]},trys:[],ops:[]},a,s,l,c;return c={next:u(0),throw:u(1),return:u(2)},typeof Symbol=="function"&&(c[Symbol.iterator]=function(){return this}),c;function u(f){return function(p){return h([f,p])}}function h(f){if(a)throw new TypeError("Generator is already executing.");for(;c&&(c=0,f[0]&&(o=0)),o;)try{if(a=1,s&&(l=f[0]&2?s.return:f[0]?s.throw||((l=s.return)&&l.call(s),0):s.next)&&!(l=l.call(s,f[1])).done)return l;switch(s=0,l&&(f=[f[0]&2,l.value]),f[0]){case 0:case 1:l=f;break;case 4:return o.label++,{value:f[1],done:!1};case 5:o.label++,s=f[1],f=[0];continue;case 7:f=o.ops.pop(),o.trys.pop();continue;default:if(l=o.trys,!(l=l.length>0&&l[l.length-1])&&(f[0]===6||f[0]===2)){o=0;continue}if(f[0]===3&&(!l||f[1]>l[0]&&f[1]<l[3])){o.label=f[1];break}if(f[0]===6&&o.label<l[1]){o.label=l[1],l=f;break}if(l&&o.label<l[2]){o.label=l[2],o.ops.push(f);break}l[2]&&o.ops.pop(),o.trys.pop();continue}f=i.call(n,o)}catch(p){f=[6,p],s=0}finally{a=l=0}if(f[0]&5)throw f[1];return{value:f[0]?f[1]:void 0,done:!0}}},Sdt=function(n,i){for(var o in n)o!=="default"&&!Object.prototype.hasOwnProperty.call(i,o)&&CI(i,n,o)},CI=Object.create?function(n,i,o,a){a===void 0&&(a=o);var s=Object.getOwnPropertyDescriptor(i,o);(!s||("get"in s?!i.__esModule:s.writable||s.configurable))&&(s={enumerable:!0,get:function(){return i[o]}}),Object.defineProperty(n,a,s)}:function(n,i,o,a){a===void 0&&(a=o),n[a]=i[o]},TI=function(n){var i=typeof Symbol=="function"&&Symbol.iterator,o=i&&n[i],a=0;if(o)return o.call(n);if(n&&typeof n.length=="number")return{next:function(){return n&&a>=n.length&&(n=void 0),{value:n&&n[a++],done:!n}}};throw new TypeError(i?"Object is not iterable.":"Symbol.iterator is not defined.")},uG=function(n,i){var o=typeof Symbol=="function"&&n[Symbol.iterator];if(!o)return n;var a=o.call(n),s,l=[],c;try{for(;(i===void 0||i-- >0)&&!(s=a.next()).done;)l.push(s.value)}catch(u){c={error:u}}finally{try{s&&!s.done&&(o=a.return)&&o.call(a)}finally{if(c)throw c.error}}return l},Mdt=function(){for(var n=[],i=0;i<arguments.length;i++)n=n.concat(uG(arguments[i]));return n},Edt=function(){for(var n=0,i=0,o=arguments.length;i<o;i++)n+=arguments[i].length;for(var a=Array(n),s=0,i=0;i<o;i++)for(var l=arguments[i],c=0,u=l.length;c<u;c++,s++)a[s]=l[c];return a},Tdt=function(n,i,o){if(o||arguments.length===2)for(var a=0,s=i.length,l;a<s;a++)(l||!(a in i))&&(l||(l=Array.prototype.slice.call(i,0,a)),l[a]=i[a]);return n.concat(l||Array.prototype.slice.call(i))},Tx=function(n){return this instanceof Tx?(this.v=n,this):new Tx(n)},Cdt=function(n,i,o){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var a=o.apply(n,i||[]),s,l=[];return s={},c("next"),c("throw"),c("return"),s[Symbol.asyncIterator]=function(){return this},s;function c(g){a[g]&&(s[g]=function(_){return new Promise(function(y,x){l.push([g,_,y,x])>1||u(g,_)})})}function u(g,_){try{h(a[g](_))}catch(y){d(l[0][3],y)}}function h(g){g.value instanceof Tx?Promise.resolve(g.value.v).then(f,p):d(l[0][2],g)}function f(g){u("next",g)}function p(g){u("throw",g)}function d(g,_){g(_),l.shift(),l.length&&u(l[0][0],l[0][1])}},Adt=function(n){var i,o;return i={},a("next"),a("throw",function(s){throw s}),a("return"),i[Symbol.iterator]=function(){return this},i;function a(s,l){i[s]=n[s]?function(c){return(o=!o)?{value:Tx(n[s](c)),done:s==="return"}:l?l(c):c}:l}},Pdt=function(n){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var i=n[Symbol.asyncIterator],o;return i?i.call(n):(n=typeof TI=="function"?TI(n):n[Symbol.iterator](),o={},a("next"),a("throw"),a("return"),o[Symbol.asyncIterator]=function(){return this},o);function a(l){o[l]=n[l]&&function(c){return new Promise(function(u,h){c=n[l](c),s(u,h,c.done,c.value)})}}function s(l,c,u,h){Promise.resolve(h).then(function(f){l({value:f,done:u})},c)}},Idt=function(n,i){return Object.defineProperty?Object.defineProperty(n,"raw",{value:i}):n.raw=i,n};var r=Object.create?function(n,i){Object.defineProperty(n,"default",{enumerable:!0,value:i})}:function(n,i){n.default=i};Ldt=function(n){if(n&&n.__esModule)return n;var i={};if(n!=null)for(var o in n)o!=="default"&&Object.prototype.hasOwnProperty.call(n,o)&&CI(i,n,o);return r(i,n),i},kdt=function(n){return n&&n.__esModule?n:{default:n}},Rdt=function(n,i,o,a){if(o==="a"&&!a)throw new TypeError("Private accessor was defined without a getter");if(typeof i=="function"?n!==i||!a:!i.has(n))throw new TypeError("Cannot read private member from an object whose class did not declare it");return o==="m"?a:o==="a"?a.call(n):a?a.value:i.get(n)},Ndt=function(n,i,o,a,s){if(a==="m")throw new TypeError("Private method is not writable");if(a==="a"&&!s)throw new TypeError("Private accessor was defined without a setter");if(typeof i=="function"?n!==i||!s:!i.has(n))throw new TypeError("Cannot write private member to an object whose class did not declare it");return a==="a"?s.call(n,o):s?s.value=o:i.set(n,o),o},Ddt=function(n,i){if(i===null||typeof i!="object"&&typeof i!="function")throw new TypeError("Cannot use 'in' operator on non-object");return typeof n=="function"?i===n:n.has(i)},e("__extends",mdt),e("__assign",gdt),e("__rest",_dt),e("__decorate",ydt),e("__param",vdt),e("__metadata",xdt),e("__awaiter",bdt),e("__generator",wdt),e("__exportStar",Sdt),e("__createBinding",CI),e("__values",TI),e("__read",uG),e("__spread",Mdt),e("__spreadArrays",Edt),e("__spreadArray",Tdt),e("__await",Tx),e("__asyncGenerator",Cdt),e("__asyncDelegator",Adt),e("__asyncValues",Pdt),e("__makeTemplateObject",Idt),e("__importStar",Ldt),e("__importDefault",kdt),e("__classPrivateFieldGet",Rdt),e("__classPrivateFieldSet",Ndt),e("__classPrivateFieldIn",Ddt)})});var Oe=H((Rx,$M)=>{(function(){var e,t="4.17.21",r=200,n="Unsupported core-js use. Try https://npms.io/search?q=ponyfill.",i="Expected a function",o="Invalid `variable` option passed into `_.template`",a="__lodash_hash_undefined__",s=500,l="__lodash_placeholder__",c=1,u=2,h=4,f=1,p=2,d=1,g=2,_=4,y=8,x=16,b=32,S=64,C=128,P=256,k=512,O=30,D="...",B=800,I=16,L=1,R=2,F=3,z=1/0,U=9007199254740991,W=17976931348623157e292,Z=0/0,rt=4294967295,ot=rt-1,st=rt>>>1,St=[["ary",C],["bind",d],["bindKey",g],["curry",y],["curryRight",x],["flip",k],["partial",b],["partialRight",S],["rearg",P]],bt="[object Arguments]",Mt="[object Array]",lt="[object AsyncFunction]",Kt="[object Boolean]",_t="[object Date]",ct="[object DOMException]",X="[object Error]",et="[object Function]",dt="[object GeneratorFunction]",q="[object Map]",pt="[object Number]",ht="[object Null]",wt="[object Object]",kt="[object Promise]",ie="[object Proxy]",ee="[object RegExp]",Le="[object Set]",ar="[object String]",fr="[object Symbol]",tt="[object Undefined]",$="[object WeakMap]",It="[object WeakSet]",$t="[object ArrayBuffer]",he="[object DataView]",Tt="[object Float32Array]",be="[object Float64Array]",nt="[object Int8Array]",Ct="[object Int16Array]",Wt="[object Int32Array]",fe="[object Uint8Array]",at="[object Uint8ClampedArray]",se="[object Uint16Array]",Qt="[object Uint32Array]",Ce=/\b__p \+= '';/g,Pt=/\b(__p \+=) '' \+/g,Nt=/(__e\(.*?\)|\b__t\)) \+\n'';/g,ze=/&(?:amp|lt|gt|quot|#39);/g,yn=/[&<>"']/g,Wi=RegExp(ze.source),Ar=RegExp(yn.source),Pa=/<%-([\s\S]+?)%>/g,ho=/<%([\s\S]+?)%>/g,Ia=/<%=([\s\S]+?)%>/g,lx=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,cm=/^\w*$/,J0=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,cn=/[\\^$.*+?()[\]{}|]/g,cx=RegExp(cn.source),rp=/^\s+/,K=/\s/,gt=/\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,Et=/\{\n\/\* \[wrapped with (.+)\] \*/,xt=/,? & /,Ft=/[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g,Ve=/[()=,{}\[\]\/\s]/,Ue=/\\(\\)?/g,tr=/\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g,Ke=/\w*$/,Xr=/^[-+]0x[0-9a-f]+$/i,_r=/^0b[01]+$/i,Pr=/^\[object .+?Constructor\]$/,Xn=/^0o[0-7]+$/i,np=/^(?:0|[1-9]\d*)$/,um=/[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g,mr=/($^)/,Fl=/['\n\r\u2028\u2029\\]/g,$n="\\ud800-\\udfff",Bl="\\u0300-\\u036f",ux="\\ufe20-\\ufe2f",Hl="\\u20d0-\\u20ff",Vl=Bl+ux+Hl,Yi="\\u2700-\\u27bf",hm="a-z\\xdf-\\xf6\\xf8-\\xff",qs="\\xac\\xb1\\xd7\\xf7",hpe="\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf",fpe="\\u2000-\\u206f",ppe=" \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000",qht="A-Z\\xc0-\\xd6\\xd8-\\xde",Ght="\\ufe0e\\ufe0f",Wht=qs+hpe+fpe+ppe,tq="['\u2019]",dpe="["+$n+"]",Yht="["+Wht+"]",B6="["+Vl+"]",jht="\\d+",mpe="["+Yi+"]",Xht="["+hm+"]",$ht="[^"+$n+Wht+jht+Yi+hm+qht+"]",eq="\\ud83c[\\udffb-\\udfff]",gpe="(?:"+B6+"|"+eq+")",Kht="[^"+$n+"]",rq="(?:\\ud83c[\\udde6-\\uddff]){2}",nq="[\\ud800-\\udbff][\\udc00-\\udfff]",hx="["+qht+"]",Zht="\\u200d",Jht="(?:"+Xht+"|"+$ht+")",_pe="(?:"+hx+"|"+$ht+")",Qht="(?:"+tq+"(?:d|ll|m|re|s|t|ve))?",tft="(?:"+tq+"(?:D|LL|M|RE|S|T|VE))?",eft=gpe+"?",rft="["+Ght+"]?",ype="(?:"+Zht+"(?:"+[Kht,rq,nq].join("|")+")"+rft+eft+")*",vpe="\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])",xpe="\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])",nft=rft+eft+ype,bpe="(?:"+[mpe,rq,nq].join("|")+")"+nft,wpe="(?:"+[Kht+B6+"?",B6,rq,nq,dpe].join("|")+")",Spe=RegExp(tq,"g"),Mpe=RegExp(B6,"g"),iq=RegExp(eq+"(?="+eq+")|"+wpe+nft,"g"),Epe=RegExp([hx+"?"+Xht+"+"+Qht+"(?="+[Yht,hx,"$"].join("|")+")",_pe+"+"+tft+"(?="+[Yht,hx+Jht,"$"].join("|")+")",hx+"?"+Jht+"+"+Qht,hx+"+"+tft,xpe,vpe,jht,bpe].join("|"),"g"),Tpe=RegExp("["+Zht+$n+Vl+Ght+"]"),Cpe=/[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/,Ape=["Array","Buffer","DataView","Date","Error","Float32Array","Float64Array","Function","Int8Array","Int16Array","Int32Array","Map","Math","Object","Promise","RegExp","Set","String","Symbol","TypeError","Uint8Array","Uint8ClampedArray","Uint16Array","Uint32Array","WeakMap","_","clearTimeout","isFinite","parseInt","setTimeout"],Ppe=-1,Rn={};Rn[Tt]=Rn[be]=Rn[nt]=Rn[Ct]=Rn[Wt]=Rn[fe]=Rn[at]=Rn[se]=Rn[Qt]=!0,Rn[bt]=Rn[Mt]=Rn[$t]=Rn[Kt]=Rn[he]=Rn[_t]=Rn[X]=Rn[et]=Rn[q]=Rn[pt]=Rn[wt]=Rn[ee]=Rn[Le]=Rn[ar]=Rn[$]=!1;var Tn={};Tn[bt]=Tn[Mt]=Tn[$t]=Tn[he]=Tn[Kt]=Tn[_t]=Tn[Tt]=Tn[be]=Tn[nt]=Tn[Ct]=Tn[Wt]=Tn[q]=Tn[pt]=Tn[wt]=Tn[ee]=Tn[Le]=Tn[ar]=Tn[fr]=Tn[fe]=Tn[at]=Tn[se]=Tn[Qt]=!0,Tn[X]=Tn[et]=Tn[$]=!1;var Ipe={\u00C0:"A",\u00C1:"A",\u00C2:"A",\u00C3:"A",\u00C4:"A",\u00C5:"A",\u00E0:"a",\u00E1:"a",\u00E2:"a",\u00E3:"a",\u00E4:"a",\u00E5:"a",\u00C7:"C",\u00E7:"c",\u00D0:"D",\u00F0:"d",\u00C8:"E",\u00C9:"E",\u00CA:"E",\u00CB:"E",\u00E8:"e",\u00E9:"e",\u00EA:"e",\u00EB:"e",\u00CC:"I",\u00CD:"I",\u00CE:"I",\u00CF:"I",\u00EC:"i",\u00ED:"i",\u00EE:"i",\u00EF:"i",\u00D1:"N",\u00F1:"n",\u00D2:"O",\u00D3:"O",\u00D4:"O",\u00D5:"O",\u00D6:"O",\u00D8:"O",\u00F2:"o",\u00F3:"o",\u00F4:"o",\u00F5:"o",\u00F6:"o",\u00F8:"o",\u00D9:"U",\u00DA:"U",\u00DB:"U",\u00DC:"U",\u00F9:"u",\u00FA:"u",\u00FB:"u",\u00FC:"u",\u00DD:"Y",\u00FD:"y",\u00FF:"y",\u00C6:"Ae",\u00E6:"ae",\u00DE:"Th",\u00FE:"th",\u00DF:"ss",\u0100:"A",\u0102:"A",\u0104:"A",\u0101:"a",\u0103:"a",\u0105:"a",\u0106:"C",\u0108:"C",\u010A:"C",\u010C:"C",\u0107:"c",\u0109:"c",\u010B:"c",\u010D:"c",\u010E:"D",\u0110:"D",\u010F:"d",\u0111:"d",\u0112:"E",\u0114:"E",\u0116:"E",\u0118:"E",\u011A:"E",\u0113:"e",\u0115:"e",\u0117:"e",\u0119:"e",\u011B:"e",\u011C:"G",\u011E:"G",\u0120:"G",\u0122:"G",\u011D:"g",\u011F:"g",\u0121:"g",\u0123:"g",\u0124:"H",\u0126:"H",\u0125:"h",\u0127:"h",\u0128:"I",\u012A:"I",\u012C:"I",\u012E:"I",\u0130:"I",\u0129:"i",\u012B:"i",\u012D:"i",\u012F:"i",\u0131:"i",\u0134:"J",\u0135:"j",\u0136:"K",\u0137:"k",\u0138:"k",\u0139:"L",\u013B:"L",\u013D:"L",\u013F:"L",\u0141:"L",\u013A:"l",\u013C:"l",\u013E:"l",\u0140:"l",\u0142:"l",\u0143:"N",\u0145:"N",\u0147:"N",\u014A:"N",\u0144:"n",\u0146:"n",\u0148:"n",\u014B:"n",\u014C:"O",\u014E:"O",\u0150:"O",\u014D:"o",\u014F:"o",\u0151:"o",\u0154:"R",\u0156:"R",\u0158:"R",\u0155:"r",\u0157:"r",\u0159:"r",\u015A:"S",\u015C:"S",\u015E:"S",\u0160:"S",\u015B:"s",\u015D:"s",\u015F:"s",\u0161:"s",\u0162:"T",\u0164:"T",\u0166:"T",\u0163:"t",\u0165:"t",\u0167:"t",\u0168:"U",\u016A:"U",\u016C:"U",\u016E:"U",\u0170:"U",\u0172:"U",\u0169:"u",\u016B:"u",\u016D:"u",\u016F:"u",\u0171:"u",\u0173:"u",\u0174:"W",\u0175:"w",\u0176:"Y",\u0177:"y",\u0178:"Y",\u0179:"Z",\u017B:"Z",\u017D:"Z",\u017A:"z",\u017C:"z",\u017E:"z",\u0132:"IJ",\u0133:"ij",\u0152:"Oe",\u0153:"oe",\u0149:"'n",\u017F:"s"},Lpe={"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"},kpe={"&amp;":"&","&lt;":"<","&gt;":">","&quot;":'"',"&#39;":"'"},Rpe={"\\":"\\","'":"'","\n":"n","\r":"r","\u2028":"u2028","\u2029":"u2029"},Npe=parseFloat,Dpe=parseInt,ift=typeof global=="object"&&global&&global.Object===Object&&global,Ope=typeof self=="object"&&self&&self.Object===Object&&self,fo=ift||Ope||Function("return this")(),oq=typeof Rx=="object"&&Rx&&!Rx.nodeType&&Rx,Q0=oq&&typeof $M=="object"&&$M&&!$M.nodeType&&$M,oft=Q0&&Q0.exports===oq,aq=oft&&ift.process,Ul=function(){try{var ut=Q0&&Q0.require&&Q0.require("util").types;return ut||aq&&aq.binding&&aq.binding("util")}catch(At){}}(),aft=Ul&&Ul.isArrayBuffer,sft=Ul&&Ul.isDate,lft=Ul&&Ul.isMap,cft=Ul&&Ul.isRegExp,uft=Ul&&Ul.isSet,hft=Ul&&Ul.isTypedArray;function Gs(ut,At,vt){switch(vt.length){case 0:return ut.call(At);case 1:return ut.call(At,vt[0]);case 2:return ut.call(At,vt[0],vt[1]);case 3:return ut.call(At,vt[0],vt[1],vt[2])}return ut.apply(At,vt)}function zpe(ut,At,vt,ge){for(var We=-1,$r=ut==null?0:ut.length;++We<$r;){var ji=ut[We];At(ge,ji,vt(ji),ut)}return ge}function ql(ut,At){for(var vt=-1,ge=ut==null?0:ut.length;++vt<ge&&At(ut[vt],vt,ut)!==!1;);return ut}function Fpe(ut,At){for(var vt=ut==null?0:ut.length;vt--&&At(ut[vt],vt,ut)!==!1;);return ut}function fft(ut,At){for(var vt=-1,ge=ut==null?0:ut.length;++vt<ge;)if(!At(ut[vt],vt,ut))return!1;return!0}function fm(ut,At){for(var vt=-1,ge=ut==null?0:ut.length,We=0,$r=[];++vt<ge;){var ji=ut[vt];At(ji,vt,ut)&&($r[We++]=ji)}return $r}function H6(ut,At){var vt=ut==null?0:ut.length;return!!vt&&fx(ut,At,0)>-1}function sq(ut,At,vt){for(var ge=-1,We=ut==null?0:ut.length;++ge<We;)if(vt(At,ut[ge]))return!0;return!1}function Kn(ut,At){for(var vt=-1,ge=ut==null?0:ut.length,We=Array(ge);++vt<ge;)We[vt]=At(ut[vt],vt,ut);return We}function pm(ut,At){for(var vt=-1,ge=At.length,We=ut.length;++vt<ge;)ut[We+vt]=At[vt];return ut}function lq(ut,At,vt,ge){var We=-1,$r=ut==null?0:ut.length;for(ge&&$r&&(vt=ut[++We]);++We<$r;)vt=At(vt,ut[We],We,ut);return vt}function Bpe(ut,At,vt,ge){var We=ut==null?0:ut.length;for(ge&&We&&(vt=ut[--We]);We--;)vt=At(vt,ut[We],We,ut);return vt}function cq(ut,At){for(var vt=-1,ge=ut==null?0:ut.length;++vt<ge;)if(At(ut[vt],vt,ut))return!0;return!1}var Hpe=uq("length");function Vpe(ut){return ut.split("")}function Upe(ut){return ut.match(Ft)||[]}function pft(ut,At,vt){var ge;return vt(ut,function(We,$r,ji){if(At(We,$r,ji))return ge=$r,!1}),ge}function V6(ut,At,vt,ge){for(var We=ut.length,$r=vt+(ge?1:-1);ge?$r--:++$r<We;)if(At(ut[$r],$r,ut))return $r;return-1}function fx(ut,At,vt){return At===At?tde(ut,At,vt):V6(ut,dft,vt)}function qpe(ut,At,vt,ge){for(var We=vt-1,$r=ut.length;++We<$r;)if(ge(ut[We],At))return We;return-1}function dft(ut){return ut!==ut}function mft(ut,At){var vt=ut==null?0:ut.length;return vt?fq(ut,At)/vt:Z}function uq(ut){return function(At){return At==null?e:At[ut]}}function hq(ut){return function(At){return ut==null?e:ut[At]}}function gft(ut,At,vt,ge,We){return We(ut,function($r,ji,vn){vt=ge?(ge=!1,$r):At(vt,$r,ji,vn)}),vt}function Gpe(ut,At){var vt=ut.length;for(ut.sort(At);vt--;)ut[vt]=ut[vt].value;return ut}function fq(ut,At){for(var vt,ge=-1,We=ut.length;++ge<We;){var $r=At(ut[ge]);$r!==e&&(vt=vt===e?$r:vt+$r)}return vt}function pq(ut,At){for(var vt=-1,ge=Array(ut);++vt<ut;)ge[vt]=At(vt);return ge}function Wpe(ut,At){return Kn(At,function(vt){return[vt,ut[vt]]})}function _ft(ut){return ut&&ut.slice(0,bft(ut)+1).replace(rp,"")}function Ws(ut){return function(At){return ut(At)}}function dq(ut,At){return Kn(At,function(vt){return ut[vt]})}function MM(ut,At){return ut.has(At)}function yft(ut,At){for(var vt=-1,ge=ut.length;++vt<ge&&fx(At,ut[vt],0)>-1;);return vt}function vft(ut,At){for(var vt=ut.length;vt--&&fx(At,ut[vt],0)>-1;);return vt}function Ype(ut,At){for(var vt=ut.length,ge=0;vt--;)ut[vt]===At&&++ge;return ge}var jpe=hq(Ipe),Xpe=hq(Lpe);function $pe(ut){return"\\"+Rpe[ut]}function Kpe(ut,At){return ut==null?e:ut[At]}function px(ut){return Tpe.test(ut)}function Zpe(ut){return Cpe.test(ut)}function Jpe(ut){for(var At,vt=[];!(At=ut.next()).done;)vt.push(At.value);return vt}function mq(ut){var At=-1,vt=Array(ut.size);return ut.forEach(function(ge,We){vt[++At]=[We,ge]}),vt}function xft(ut,At){return function(vt){return ut(At(vt))}}function dm(ut,At){for(var vt=-1,ge=ut.length,We=0,$r=[];++vt<ge;){var ji=ut[vt];(ji===At||ji===l)&&(ut[vt]=l,$r[We++]=vt)}return $r}function U6(ut){var At=-1,vt=Array(ut.size);return ut.forEach(function(ge){vt[++At]=ge}),vt}function Qpe(ut){var At=-1,vt=Array(ut.size);return ut.forEach(function(ge){vt[++At]=[ge,ge]}),vt}function tde(ut,At,vt){for(var ge=vt-1,We=ut.length;++ge<We;)if(ut[ge]===At)return ge;return-1}function ede(ut,At,vt){for(var ge=vt+1;ge--;)if(ut[ge]===At)return ge;return ge}function dx(ut){return px(ut)?nde(ut):Hpe(ut)}function tu(ut){return px(ut)?ide(ut):Vpe(ut)}function bft(ut){for(var At=ut.length;At--&&K.test(ut.charAt(At)););return At}var rde=hq(kpe);function nde(ut){for(var At=iq.lastIndex=0;iq.test(ut);)++At;return At}function ide(ut){return ut.match(iq)||[]}function ode(ut){return ut.match(Epe)||[]}var ade=function ut(At){At=At==null?fo:mm.defaults(fo.Object(),At,mm.pick(fo,Ape));var vt=At.Array,ge=At.Date,We=At.Error,$r=At.Function,ji=At.Math,vn=At.Object,gq=At.RegExp,sde=At.String,Gl=At.TypeError,q6=vt.prototype,lde=$r.prototype,mx=vn.prototype,G6=At["__core-js_shared__"],W6=lde.toString,un=mx.hasOwnProperty,cde=0,wft=function(){var m=/[^.]+$/.exec(G6&&G6.keys&&G6.keys.IE_PROTO||"");return m?"Symbol(src)_1."+m:""}(),Y6=mx.toString,ude=W6.call(vn),hde=fo._,fde=gq("^"+W6.call(un).replace(cn,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$"),j6=oft?At.Buffer:e,gm=At.Symbol,X6=At.Uint8Array,Sft=j6?j6.allocUnsafe:e,$6=xft(vn.getPrototypeOf,vn),Mft=vn.create,Eft=mx.propertyIsEnumerable,K6=q6.splice,Tft=gm?gm.isConcatSpreadable:e,EM=gm?gm.iterator:e,t_=gm?gm.toStringTag:e,Z6=function(){try{var m=o_(vn,"defineProperty");return m({},"",{}),m}catch(v){}}(),pde=At.clearTimeout!==fo.clearTimeout&&At.clearTimeout,dde=ge&&ge.now!==fo.Date.now&&ge.now,mde=At.setTimeout!==fo.setTimeout&&At.setTimeout,J6=ji.ceil,Q6=ji.floor,_q=vn.getOwnPropertySymbols,gde=j6?j6.isBuffer:e,Cft=At.isFinite,_de=q6.join,yde=xft(vn.keys,vn),Xi=ji.max,ra=ji.min,vde=ge.now,xde=At.parseInt,Aft=ji.random,bde=q6.reverse,yq=o_(At,"DataView"),TM=o_(At,"Map"),vq=o_(At,"Promise"),gx=o_(At,"Set"),CM=o_(At,"WeakMap"),AM=o_(vn,"create"),tI=CM&&new CM,_x={},wde=a_(yq),Sde=a_(TM),Mde=a_(vq),Ede=a_(gx),Tde=a_(CM),eI=gm?gm.prototype:e,PM=eI?eI.valueOf:e,Pft=eI?eI.toString:e;function G(m){if(li(m)&&!$e(m)&&!(m instanceof gr)){if(m instanceof Wl)return m;if(un.call(m,"__wrapped__"))return Ipt(m)}return new Wl(m)}var yx=function(){function m(){}return function(v){if(!ri(v))return{};if(Mft)return Mft(v);m.prototype=v;var T=new m;return m.prototype=e,T}}();function rI(){}function Wl(m,v){this.__wrapped__=m,this.__actions__=[],this.__chain__=!!v,this.__index__=0,this.__values__=e}G.templateSettings={escape:Pa,evaluate:ho,interpolate:Ia,variable:"",imports:{_:G}},G.prototype=rI.prototype,G.prototype.constructor=G,Wl.prototype=yx(rI.prototype),Wl.prototype.constructor=Wl;function gr(m){this.__wrapped__=m,this.__actions__=[],this.__dir__=1,this.__filtered__=!1,this.__iteratees__=[],this.__takeCount__=rt,this.__views__=[]}function Cde(){var m=new gr(this.__wrapped__);return m.__actions__=ps(this.__actions__),m.__dir__=this.__dir__,m.__filtered__=this.__filtered__,m.__iteratees__=ps(this.__iteratees__),m.__takeCount__=this.__takeCount__,m.__views__=ps(this.__views__),m}function Ade(){if(this.__filtered__){var m=new gr(this);m.__dir__=-1,m.__filtered__=!0}else m=this.clone(),m.__dir__*=-1;return m}function Pde(){var m=this.__wrapped__.value(),v=this.__dir__,T=$e(m),N=v<0,V=T?m.length:0,Y=Vme(0,V,this.__views__),J=Y.start,it=Y.end,ft=it-J,Dt=N?it:J-1,Ot=this.__iteratees__,Vt=Ot.length,oe=0,Te=ra(ft,this.__takeCount__);if(!T||!N&&V==ft&&Te==ft)return Qft(m,this.__actions__);var Ne=[];t:for(;ft--&&oe<Te;){Dt+=v;for(var er=-1,De=m[Dt];++er<Vt;){var pr=Ot[er],yr=pr.iteratee,Xs=pr.type,Ra=yr(De);if(Xs==R)De=Ra;else if(!Ra){if(Xs==L)continue t;break t}}Ne[oe++]=De}return Ne}gr.prototype=yx(rI.prototype),gr.prototype.constructor=gr;function e_(m){var v=-1,T=m==null?0:m.length;for(this.clear();++v<T;){var N=m[v];this.set(N[0],N[1])}}function Ide(){this.__data__=AM?AM(null):{},this.size=0}function Lde(m){var v=this.has(m)&&delete this.__data__[m];return this.size-=v?1:0,v}function kde(m){var v=this.__data__;if(AM){var T=v[m];return T===a?e:T}return un.call(v,m)?v[m]:e}function Rde(m){var v=this.__data__;return AM?v[m]!==e:un.call(v,m)}function Nde(m,v){var T=this.__data__;return this.size+=this.has(m)?0:1,T[m]=AM&&v===e?a:v,this}e_.prototype.clear=Ide,e_.prototype.delete=Lde,e_.prototype.get=kde,e_.prototype.has=Rde,e_.prototype.set=Nde;function ip(m){var v=-1,T=m==null?0:m.length;for(this.clear();++v<T;){var N=m[v];this.set(N[0],N[1])}}function Dde(){this.__data__=[],this.size=0}function Ode(m){var v=this.__data__,T=nI(v,m);if(T<0)return!1;var N=v.length-1;return T==N?v.pop():K6.call(v,T,1),--this.size,!0}function zde(m){var v=this.__data__,T=nI(v,m);return T<0?e:v[T][1]}function Fde(m){return nI(this.__data__,m)>-1}function Bde(m,v){var T=this.__data__,N=nI(T,m);return N<0?(++this.size,T.push([m,v])):T[N][1]=v,this}ip.prototype.clear=Dde,ip.prototype.delete=Ode,ip.prototype.get=zde,ip.prototype.has=Fde,ip.prototype.set=Bde;function op(m){var v=-1,T=m==null?0:m.length;for(this.clear();++v<T;){var N=m[v];this.set(N[0],N[1])}}function Hde(){this.size=0,this.__data__={hash:new e_,map:new(TM||ip),string:new e_}}function Vde(m){var v=mI(this,m).delete(m);return this.size-=v?1:0,v}function Ude(m){return mI(this,m).get(m)}function qde(m){return mI(this,m).has(m)}function Gde(m,v){var T=mI(this,m),N=T.size;return T.set(m,v),this.size+=T.size==N?0:1,this}op.prototype.clear=Hde,op.prototype.delete=Vde,op.prototype.get=Ude,op.prototype.has=qde,op.prototype.set=Gde;function r_(m){var v=-1,T=m==null?0:m.length;for(this.__data__=new op;++v<T;)this.add(m[v])}function Wde(m){return this.__data__.set(m,a),this}function Yde(m){return this.__data__.has(m)}r_.prototype.add=r_.prototype.push=Wde,r_.prototype.has=Yde;function eu(m){var v=this.__data__=new ip(m);this.size=v.size}function jde(){this.__data__=new ip,this.size=0}function Xde(m){var v=this.__data__,T=v.delete(m);return this.size=v.size,T}function $de(m){return this.__data__.get(m)}function Kde(m){return this.__data__.has(m)}function Zde(m,v){var T=this.__data__;if(T instanceof ip){var N=T.__data__;if(!TM||N.length<r-1)return N.push([m,v]),this.size=++T.size,this;T=this.__data__=new op(N)}return T.set(m,v),this.size=T.size,this}eu.prototype.clear=jde,eu.prototype.delete=Xde,eu.prototype.get=$de,eu.prototype.has=Kde,eu.prototype.set=Zde;function Ift(m,v){var T=$e(m),N=!T&&s_(m),V=!T&&!N&&bm(m),Y=!T&&!N&&!V&&wx(m),J=T||N||V||Y,it=J?pq(m.length,sde):[],ft=it.length;for(var Dt in m)(v||un.call(m,Dt))&&!(J&&(Dt=="length"||V&&(Dt=="offset"||Dt=="parent")||Y&&(Dt=="buffer"||Dt=="byteLength"||Dt=="byteOffset")||cp(Dt,ft)))&&it.push(Dt);return it}function Lft(m){var v=m.length;return v?m[Iq(0,v-1)]:e}function Jde(m,v){return gI(ps(m),n_(v,0,m.length))}function Qde(m){return gI(ps(m))}function xq(m,v,T){(T!==e&&!ru(m[v],T)||T===e&&!(v in m))&&ap(m,v,T)}function IM(m,v,T){var N=m[v];(!(un.call(m,v)&&ru(N,T))||T===e&&!(v in m))&&ap(m,v,T)}function nI(m,v){for(var T=m.length;T--;)if(ru(m[T][0],v))return T;return-1}function tme(m,v,T,N){return _m(m,function(V,Y,J){v(N,V,T(V),J)}),N}function kft(m,v){return m&&gh(v,po(v),m)}function eme(m,v){return m&&gh(v,ms(v),m)}function ap(m,v,T){v=="__proto__"&&Z6?Z6(m,v,{configurable:!0,enumerable:!0,value:T,writable:!0}):m[v]=T}function bq(m,v){for(var T=-1,N=v.length,V=vt(N),Y=m==null;++T<N;)V[T]=Y?e:eG(m,v[T]);return V}function n_(m,v,T){return m===m&&(T!==e&&(m=m<=T?m:T),v!==e&&(m=m>=v?m:v)),m}function Yl(m,v,T,N,V,Y){var J,it=v&c,ft=v&u,Dt=v&h;if(T&&(J=V?T(m,N,V,Y):T(m)),J!==e)return J;if(!ri(m))return m;var Ot=$e(m);if(Ot){if(J=qme(m),!it)return ps(m,J)}else{var Vt=na(m),oe=Vt==et||Vt==dt;if(bm(m))return rpt(m,it);if(Vt==wt||Vt==bt||oe&&!V){if(J=ft||oe?{}:bpt(m),!it)return ft?kme(m,eme(J,m)):Lme(m,kft(J,m))}else{if(!Tn[Vt])return V?m:{};J=Gme(m,Vt,it)}}Y||(Y=new eu);var Te=Y.get(m);if(Te)return Te;Y.set(m,J),Kpt(m)?m.forEach(function(De){J.add(Yl(De,v,T,De,m,Y))}):Xpt(m)&&m.forEach(function(De,pr){J.set(pr,Yl(De,v,T,pr,m,Y))});var Ne=Dt?ft?Vq:Hq:ft?ms:po,er=Ot?e:Ne(m);return ql(er||m,function(De,pr){er&&(pr=De,De=m[pr]),IM(J,pr,Yl(De,v,T,pr,m,Y))}),J}function rme(m){var v=po(m);return function(T){return Rft(T,m,v)}}function Rft(m,v,T){var N=T.length;if(m==null)return!N;for(m=vn(m);N--;){var V=T[N],Y=v[V],J=m[V];if(J===e&&!(V in m)||!Y(J))return!1}return!0}function Nft(m,v,T){if(typeof m!="function")throw new Gl(i);return zM(function(){m.apply(e,T)},v)}function LM(m,v,T,N){var V=-1,Y=H6,J=!0,it=m.length,ft=[],Dt=v.length;if(!it)return ft;T&&(v=Kn(v,Ws(T))),N?(Y=sq,J=!1):v.length>=r&&(Y=MM,J=!1,v=new r_(v));t:for(;++V<it;){var Ot=m[V],Vt=T==null?Ot:T(Ot);if(Ot=N||Ot!==0?Ot:0,J&&Vt===Vt){for(var oe=Dt;oe--;)if(v[oe]===Vt)continue t;ft.push(Ot)}else Y(v,Vt,N)||ft.push(Ot)}return ft}var _m=spt(mh),Dft=spt(Sq,!0);function nme(m,v){var T=!0;return _m(m,function(N,V,Y){return T=!!v(N,V,Y),T}),T}function iI(m,v,T){for(var N=-1,V=m.length;++N<V;){var Y=m[N],J=v(Y);if(J!=null&&(it===e?J===J&&!js(J):T(J,it)))var it=J,ft=Y}return ft}function ime(m,v,T,N){var V=m.length;for(T=Qe(T),T<0&&(T=-T>V?0:V+T),N=N===e||N>V?V:Qe(N),N<0&&(N+=V),N=T>N?0:Jpt(N);T<N;)m[T++]=v;return m}function Oft(m,v){var T=[];return _m(m,function(N,V,Y){v(N,V,Y)&&T.push(N)}),T}function Ro(m,v,T,N,V){var Y=-1,J=m.length;for(T||(T=Yme),V||(V=[]);++Y<J;){var it=m[Y];v>0&&T(it)?v>1?Ro(it,v-1,T,N,V):pm(V,it):N||(V[V.length]=it)}return V}var wq=lpt(),zft=lpt(!0);function mh(m,v){return m&&wq(m,v,po)}function Sq(m,v){return m&&zft(m,v,po)}function oI(m,v){return fm(v,function(T){return up(m[T])})}function i_(m,v){v=vm(v,m);for(var T=0,N=v.length;m!=null&&T<N;)m=m[_h(v[T++])];return T&&T==N?m:e}function Fft(m,v,T){var N=v(m);return $e(m)?N:pm(N,T(m))}function La(m){return m==null?m===e?tt:ht:t_&&t_ in vn(m)?Hme(m):Qme(m)}function Mq(m,v){return m>v}function ome(m,v){return m!=null&&un.call(m,v)}function ame(m,v){return m!=null&&v in vn(m)}function sme(m,v,T){return m>=ra(v,T)&&m<Xi(v,T)}function Eq(m,v,T){for(var N=T?sq:H6,V=m[0].length,Y=m.length,J=Y,it=vt(Y),ft=1/0,Dt=[];J--;){var Ot=m[J];J&&v&&(Ot=Kn(Ot,Ws(v))),ft=ra(Ot.length,ft),it[J]=!T&&(v||V>=120&&Ot.length>=120)?new r_(J&&Ot):e}Ot=m[0];var Vt=-1,oe=it[0];t:for(;++Vt<V&&Dt.length<ft;){var Te=Ot[Vt],Ne=v?v(Te):Te;if(Te=T||Te!==0?Te:0,!(oe?MM(oe,Ne):N(Dt,Ne,T))){for(J=Y;--J;){var er=it[J];if(!(er?MM(er,Ne):N(m[J],Ne,T)))continue t}oe&&oe.push(Ne),Dt.push(Te)}}return Dt}function lme(m,v,T,N){return mh(m,function(V,Y,J){v(N,T(V),Y,J)}),N}function kM(m,v,T){v=vm(v,m),m=Ept(m,v);var N=m==null?m:m[_h(Xl(v))];return N==null?e:Gs(N,m,T)}function Bft(m){return li(m)&&La(m)==bt}function cme(m){return li(m)&&La(m)==$t}function ume(m){return li(m)&&La(m)==_t}function RM(m,v,T,N,V){return m===v?!0:m==null||v==null||!li(m)&&!li(v)?m!==m&&v!==v:hme(m,v,T,N,RM,V)}function hme(m,v,T,N,V,Y){var J=$e(m),it=$e(v),ft=J?Mt:na(m),Dt=it?Mt:na(v);ft=ft==bt?wt:ft,Dt=Dt==bt?wt:Dt;var Ot=ft==wt,Vt=Dt==wt,oe=ft==Dt;if(oe&&bm(m)){if(!bm(v))return!1;J=!0,Ot=!1}if(oe&&!Ot)return Y||(Y=new eu),J||wx(m)?ypt(m,v,T,N,V,Y):Fme(m,v,ft,T,N,V,Y);if(!(T&f)){var Te=Ot&&un.call(m,"__wrapped__"),Ne=Vt&&un.call(v,"__wrapped__");if(Te||Ne){var er=Te?m.value():m,De=Ne?v.value():v;return Y||(Y=new eu),V(er,De,T,N,Y)}}return oe?(Y||(Y=new eu),Bme(m,v,T,N,V,Y)):!1}function fme(m){return li(m)&&na(m)==q}function Tq(m,v,T,N){var V=T.length,Y=V,J=!N;if(m==null)return!Y;for(m=vn(m);V--;){var it=T[V];if(J&&it[2]?it[1]!==m[it[0]]:!(it[0]in m))return!1}for(;++V<Y;){it=T[V];var ft=it[0],Dt=m[ft],Ot=it[1];if(J&&it[2]){if(Dt===e&&!(ft in m))return!1}else{var Vt=new eu;if(N)var oe=N(Dt,Ot,ft,m,v,Vt);if(!(oe===e?RM(Ot,Dt,f|p,N,Vt):oe))return!1}}return!0}function Hft(m){if(!ri(m)||Xme(m))return!1;var v=up(m)?fde:Pr;return v.test(a_(m))}function pme(m){return li(m)&&La(m)==ee}function dme(m){return li(m)&&na(m)==Le}function mme(m){return li(m)&&wI(m.length)&&!!Rn[La(m)]}function Vft(m){return typeof m=="function"?m:m==null?gs:typeof m=="object"?$e(m)?Gft(m[0],m[1]):qft(m):cdt(m)}function Cq(m){if(!OM(m))return yde(m);var v=[];for(var T in vn(m))un.call(m,T)&&T!="constructor"&&v.push(T);return v}function gme(m){if(!ri(m))return Jme(m);var v=OM(m),T=[];for(var N in m)N=="constructor"&&(v||!un.call(m,N))||T.push(N);return T}function Aq(m,v){return m<v}function Uft(m,v){var T=-1,N=ds(m)?vt(m.length):[];return _m(m,function(V,Y,J){N[++T]=v(V,Y,J)}),N}function qft(m){var v=qq(m);return v.length==1&&v[0][2]?Spt(v[0][0],v[0][1]):function(T){return T===m||Tq(T,m,v)}}function Gft(m,v){return Wq(m)&&wpt(v)?Spt(_h(m),v):function(T){var N=eG(T,m);return N===e&&N===v?rG(T,m):RM(v,N,f|p)}}function aI(m,v,T,N,V){m!==v&&wq(v,function(Y,J){if(V||(V=new eu),ri(Y))_me(m,v,J,T,aI,N,V);else{var it=N?N(jq(m,J),Y,J+"",m,v,V):e;it===e&&(it=Y),xq(m,J,it)}},ms)}function _me(m,v,T,N,V,Y,J){var it=jq(m,T),ft=jq(v,T),Dt=J.get(ft);if(Dt){xq(m,T,Dt);return}var Ot=Y?Y(it,ft,T+"",m,v,J):e,Vt=Ot===e;if(Vt){var oe=$e(ft),Te=!oe&&bm(ft),Ne=!oe&&!Te&&wx(ft);Ot=ft,oe||Te||Ne?$e(it)?Ot=it:bi(it)?Ot=ps(it):Te?(Vt=!1,Ot=rpt(ft,!0)):Ne?(Vt=!1,Ot=npt(ft,!0)):Ot=[]:FM(ft)||s_(ft)?(Ot=it,s_(it)?Ot=Qpt(it):(!ri(it)||up(it))&&(Ot=bpt(ft))):Vt=!1}Vt&&(J.set(ft,Ot),V(Ot,ft,N,Y,J),J.delete(ft)),xq(m,T,Ot)}function Wft(m,v){var T=m.length;if(!!T)return v+=v<0?T:0,cp(v,T)?m[v]:e}function Yft(m,v,T){v.length?v=Kn(v,function(Y){return $e(Y)?function(J){return i_(J,Y.length===1?Y[0]:Y)}:Y}):v=[gs];var N=-1;v=Kn(v,Ws(ke()));var V=Uft(m,function(Y,J,it){var ft=Kn(v,function(Dt){return Dt(Y)});return{criteria:ft,index:++N,value:Y}});return Gpe(V,function(Y,J){return Ime(Y,J,T)})}function yme(m,v){return jft(m,v,function(T,N){return rG(m,N)})}function jft(m,v,T){for(var N=-1,V=v.length,Y={};++N<V;){var J=v[N],it=i_(m,J);T(it,J)&&NM(Y,vm(J,m),it)}return Y}function vme(m){return function(v){return i_(v,m)}}function Pq(m,v,T,N){var V=N?qpe:fx,Y=-1,J=v.length,it=m;for(m===v&&(v=ps(v)),T&&(it=Kn(m,Ws(T)));++Y<J;)for(var ft=0,Dt=v[Y],Ot=T?T(Dt):Dt;(ft=V(it,Ot,ft,N))>-1;)it!==m&&K6.call(it,ft,1),K6.call(m,ft,1);return m}function Xft(m,v){for(var T=m?v.length:0,N=T-1;T--;){var V=v[T];if(T==N||V!==Y){var Y=V;cp(V)?K6.call(m,V,1):Rq(m,V)}}return m}function Iq(m,v){return m+Q6(Aft()*(v-m+1))}function xme(m,v,T,N){for(var V=-1,Y=Xi(J6((v-m)/(T||1)),0),J=vt(Y);Y--;)J[N?Y:++V]=m,m+=T;return J}function Lq(m,v){var T="";if(!m||v<1||v>U)return T;do v%2&&(T+=m),v=Q6(v/2),v&&(m+=m);while(v);return T}function nr(m,v){return Xq(Mpt(m,v,gs),m+"")}function bme(m){return Lft(Sx(m))}function wme(m,v){var T=Sx(m);return gI(T,n_(v,0,T.length))}function NM(m,v,T,N){if(!ri(m))return m;v=vm(v,m);for(var V=-1,Y=v.length,J=Y-1,it=m;it!=null&&++V<Y;){var ft=_h(v[V]),Dt=T;if(ft==="__proto__"||ft==="constructor"||ft==="prototype")return m;if(V!=J){var Ot=it[ft];Dt=N?N(Ot,ft,it):e,Dt===e&&(Dt=ri(Ot)?Ot:cp(v[V+1])?[]:{})}IM(it,ft,Dt),it=it[ft]}return m}var $ft=tI?function(m,v){return tI.set(m,v),m}:gs,Sme=Z6?function(m,v){return Z6(m,"toString",{configurable:!0,enumerable:!1,value:iG(v),writable:!0})}:gs;function Mme(m){return gI(Sx(m))}function jl(m,v,T){var N=-1,V=m.length;v<0&&(v=-v>V?0:V+v),T=T>V?V:T,T<0&&(T+=V),V=v>T?0:T-v>>>0,v>>>=0;for(var Y=vt(V);++N<V;)Y[N]=m[N+v];return Y}function Eme(m,v){var T;return _m(m,function(N,V,Y){return T=v(N,V,Y),!T}),!!T}function sI(m,v,T){var N=0,V=m==null?N:m.length;if(typeof v=="number"&&v===v&&V<=st){for(;N<V;){var Y=N+V>>>1,J=m[Y];J!==null&&!js(J)&&(T?J<=v:J<v)?N=Y+1:V=Y}return V}return kq(m,v,gs,T)}function kq(m,v,T,N){var V=0,Y=m==null?0:m.length;if(Y===0)return 0;v=T(v);for(var J=v!==v,it=v===null,ft=js(v),Dt=v===e;V<Y;){var Ot=Q6((V+Y)/2),Vt=T(m[Ot]),oe=Vt!==e,Te=Vt===null,Ne=Vt===Vt,er=js(Vt);if(J)var De=N||Ne;else Dt?De=Ne&&(N||oe):it?De=Ne&&oe&&(N||!Te):ft?De=Ne&&oe&&!Te&&(N||!er):Te||er?De=!1:De=N?Vt<=v:Vt<v;De?V=Ot+1:Y=Ot}return ra(Y,ot)}function Kft(m,v){for(var T=-1,N=m.length,V=0,Y=[];++T<N;){var J=m[T],it=v?v(J):J;if(!T||!ru(it,ft)){var ft=it;Y[V++]=J===0?0:J}}return Y}function Zft(m){return typeof m=="number"?m:js(m)?Z:+m}function Ys(m){if(typeof m=="string")return m;if($e(m))return Kn(m,Ys)+"";if(js(m))return Pft?Pft.call(m):"";var v=m+"";return v=="0"&&1/m==-z?"-0":v}function ym(m,v,T){var N=-1,V=H6,Y=m.length,J=!0,it=[],ft=it;if(T)J=!1,V=sq;else if(Y>=r){var Dt=v?null:Ome(m);if(Dt)return U6(Dt);J=!1,V=MM,ft=new r_}else ft=v?[]:it;t:for(;++N<Y;){var Ot=m[N],Vt=v?v(Ot):Ot;if(Ot=T||Ot!==0?Ot:0,J&&Vt===Vt){for(var oe=ft.length;oe--;)if(ft[oe]===Vt)continue t;v&&ft.push(Vt),it.push(Ot)}else V(ft,Vt,T)||(ft!==it&&ft.push(Vt),it.push(Ot))}return it}function Rq(m,v){return v=vm(v,m),m=Ept(m,v),m==null||delete m[_h(Xl(v))]}function Jft(m,v,T,N){return NM(m,v,T(i_(m,v)),N)}function lI(m,v,T,N){for(var V=m.length,Y=N?V:-1;(N?Y--:++Y<V)&&v(m[Y],Y,m););return T?jl(m,N?0:Y,N?Y+1:V):jl(m,N?Y+1:0,N?V:Y)}function Qft(m,v){var T=m;return T instanceof gr&&(T=T.value()),lq(v,function(N,V){return V.func.apply(V.thisArg,pm([N],V.args))},T)}function Nq(m,v,T){var N=m.length;if(N<2)return N?ym(m[0]):[];for(var V=-1,Y=vt(N);++V<N;)for(var J=m[V],it=-1;++it<N;)it!=V&&(Y[V]=LM(Y[V]||J,m[it],v,T));return ym(Ro(Y,1),v,T)}function tpt(m,v,T){for(var N=-1,V=m.length,Y=v.length,J={};++N<V;){var it=N<Y?v[N]:e;T(J,m[N],it)}return J}function Dq(m){return bi(m)?m:[]}function Oq(m){return typeof m=="function"?m:gs}function vm(m,v){return $e(m)?m:Wq(m,v)?[m]:Ppt(on(m))}var Tme=nr;function xm(m,v,T){var N=m.length;return T=T===e?N:T,!v&&T>=N?m:jl(m,v,T)}var ept=pde||function(m){return fo.clearTimeout(m)};function rpt(m,v){if(v)return m.slice();var T=m.length,N=Sft?Sft(T):new m.constructor(T);return m.copy(N),N}function zq(m){var v=new m.constructor(m.byteLength);return new X6(v).set(new X6(m)),v}function Cme(m,v){var T=v?zq(m.buffer):m.buffer;return new m.constructor(T,m.byteOffset,m.byteLength)}function Ame(m){var v=new m.constructor(m.source,Ke.exec(m));return v.lastIndex=m.lastIndex,v}function Pme(m){return PM?vn(PM.call(m)):{}}function npt(m,v){var T=v?zq(m.buffer):m.buffer;return new m.constructor(T,m.byteOffset,m.length)}function ipt(m,v){if(m!==v){var T=m!==e,N=m===null,V=m===m,Y=js(m),J=v!==e,it=v===null,ft=v===v,Dt=js(v);if(!it&&!Dt&&!Y&&m>v||Y&&J&&ft&&!it&&!Dt||N&&J&&ft||!T&&ft||!V)return 1;if(!N&&!Y&&!Dt&&m<v||Dt&&T&&V&&!N&&!Y||it&&T&&V||!J&&V||!ft)return-1}return 0}function Ime(m,v,T){for(var N=-1,V=m.criteria,Y=v.criteria,J=V.length,it=T.length;++N<J;){var ft=ipt(V[N],Y[N]);if(ft){if(N>=it)return ft;var Dt=T[N];return ft*(Dt=="desc"?-1:1)}}return m.index-v.index}function opt(m,v,T,N){for(var V=-1,Y=m.length,J=T.length,it=-1,ft=v.length,Dt=Xi(Y-J,0),Ot=vt(ft+Dt),Vt=!N;++it<ft;)Ot[it]=v[it];for(;++V<J;)(Vt||V<Y)&&(Ot[T[V]]=m[V]);for(;Dt--;)Ot[it++]=m[V++];return Ot}function apt(m,v,T,N){for(var V=-1,Y=m.length,J=-1,it=T.length,ft=-1,Dt=v.length,Ot=Xi(Y-it,0),Vt=vt(Ot+Dt),oe=!N;++V<Ot;)Vt[V]=m[V];for(var Te=V;++ft<Dt;)Vt[Te+ft]=v[ft];for(;++J<it;)(oe||V<Y)&&(Vt[Te+T[J]]=m[V++]);return Vt}function ps(m,v){var T=-1,N=m.length;for(v||(v=vt(N));++T<N;)v[T]=m[T];return v}function gh(m,v,T,N){var V=!T;T||(T={});for(var Y=-1,J=v.length;++Y<J;){var it=v[Y],ft=N?N(T[it],m[it],it,T,m):e;ft===e&&(ft=m[it]),V?ap(T,it,ft):IM(T,it,ft)}return T}function Lme(m,v){return gh(m,Gq(m),v)}function kme(m,v){return gh(m,vpt(m),v)}function cI(m,v){return function(T,N){var V=$e(T)?zpe:tme,Y=v?v():{};return V(T,m,ke(N,2),Y)}}function vx(m){return nr(function(v,T){var N=-1,V=T.length,Y=V>1?T[V-1]:e,J=V>2?T[2]:e;for(Y=m.length>3&&typeof Y=="function"?(V--,Y):e,J&&ka(T[0],T[1],J)&&(Y=V<3?e:Y,V=1),v=vn(v);++N<V;){var it=T[N];it&&m(v,it,N,Y)}return v})}function spt(m,v){return function(T,N){if(T==null)return T;if(!ds(T))return m(T,N);for(var V=T.length,Y=v?V:-1,J=vn(T);(v?Y--:++Y<V)&&N(J[Y],Y,J)!==!1;);return T}}function lpt(m){return function(v,T,N){for(var V=-1,Y=vn(v),J=N(v),it=J.length;it--;){var ft=J[m?it:++V];if(T(Y[ft],ft,Y)===!1)break}return v}}function Rme(m,v,T){var N=v&d,V=DM(m);function Y(){var J=this&&this!==fo&&this instanceof Y?V:m;return J.apply(N?T:this,arguments)}return Y}function cpt(m){return function(v){v=on(v);var T=px(v)?tu(v):e,N=T?T[0]:v.charAt(0),V=T?xm(T,1).join(""):v.slice(1);return N[m]()+V}}function xx(m){return function(v){return lq(sdt(adt(v).replace(Spe,"")),m,"")}}function DM(m){return function(){var v=arguments;switch(v.length){case 0:return new m;case 1:return new m(v[0]);case 2:return new m(v[0],v[1]);case 3:return new m(v[0],v[1],v[2]);case 4:return new m(v[0],v[1],v[2],v[3]);case 5:return new m(v[0],v[1],v[2],v[3],v[4]);case 6:return new m(v[0],v[1],v[2],v[3],v[4],v[5]);case 7:return new m(v[0],v[1],v[2],v[3],v[4],v[5],v[6])}var T=yx(m.prototype),N=m.apply(T,v);return ri(N)?N:T}}function Nme(m,v,T){var N=DM(m);function V(){for(var Y=arguments.length,J=vt(Y),it=Y,ft=bx(V);it--;)J[it]=arguments[it];var Dt=Y<3&&J[0]!==ft&&J[Y-1]!==ft?[]:dm(J,ft);if(Y-=Dt.length,Y<T)return dpt(m,v,uI,V.placeholder,e,J,Dt,e,e,T-Y);var Ot=this&&this!==fo&&this instanceof V?N:m;return Gs(Ot,this,J)}return V}function upt(m){return function(v,T,N){var V=vn(v);if(!ds(v)){var Y=ke(T,3);v=po(v),T=function(it){return Y(V[it],it,V)}}var J=m(v,T,N);return J>-1?V[Y?v[J]:J]:e}}function hpt(m){return lp(function(v){var T=v.length,N=T,V=Wl.prototype.thru;for(m&&v.reverse();N--;){var Y=v[N];if(typeof Y!="function")throw new Gl(i);if(V&&!J&&dI(Y)=="wrapper")var J=new Wl([],!0)}for(N=J?N:T;++N<T;){Y=v[N];var it=dI(Y),ft=it=="wrapper"?Uq(Y):e;ft&&Yq(ft[0])&&ft[1]==(C|y|b|P)&&!ft[4].length&&ft[9]==1?J=J[dI(ft[0])].apply(J,ft[3]):J=Y.length==1&&Yq(Y)?J[it]():J.thru(Y)}return function(){var Dt=arguments,Ot=Dt[0];if(J&&Dt.length==1&&$e(Ot))return J.plant(Ot).value();for(var Vt=0,oe=T?v[Vt].apply(this,Dt):Ot;++Vt<T;)oe=v[Vt].call(this,oe);return oe}})}function uI(m,v,T,N,V,Y,J,it,ft,Dt){var Ot=v&C,Vt=v&d,oe=v&g,Te=v&(y|x),Ne=v&k,er=oe?e:DM(m);function De(){for(var pr=arguments.length,yr=vt(pr),Xs=pr;Xs--;)yr[Xs]=arguments[Xs];if(Te)var Ra=bx(De),$s=Ype(yr,Ra);if(N&&(yr=opt(yr,N,V,Te)),Y&&(yr=apt(yr,Y,J,Te)),pr-=$s,Te&&pr<Dt){var wi=dm(yr,Ra);return dpt(m,v,uI,De.placeholder,T,yr,wi,it,ft,Dt-pr)}var nu=Vt?T:this,fp=oe?nu[m]:m;return pr=yr.length,it?yr=tge(yr,it):Ne&&pr>1&&yr.reverse(),Ot&&ft<pr&&(yr.length=ft),this&&this!==fo&&this instanceof De&&(fp=er||DM(fp)),fp.apply(nu,yr)}return De}function fpt(m,v){return function(T,N){return lme(T,m,v(N),{})}}function hI(m,v){return function(T,N){var V;if(T===e&&N===e)return v;if(T!==e&&(V=T),N!==e){if(V===e)return N;typeof T=="string"||typeof N=="string"?(T=Ys(T),N=Ys(N)):(T=Zft(T),N=Zft(N)),V=m(T,N)}return V}}function Fq(m){return lp(function(v){return v=Kn(v,Ws(ke())),nr(function(T){var N=this;return m(v,function(V){return Gs(V,N,T)})})})}function fI(m,v){v=v===e?" ":Ys(v);var T=v.length;if(T<2)return T?Lq(v,m):v;var N=Lq(v,J6(m/dx(v)));return px(v)?xm(tu(N),0,m).join(""):N.slice(0,m)}function Dme(m,v,T,N){var V=v&d,Y=DM(m);function J(){for(var it=-1,ft=arguments.length,Dt=-1,Ot=N.length,Vt=vt(Ot+ft),oe=this&&this!==fo&&this instanceof J?Y:m;++Dt<Ot;)Vt[Dt]=N[Dt];for(;ft--;)Vt[Dt++]=arguments[++it];return Gs(oe,V?T:this,Vt)}return J}function ppt(m){return function(v,T,N){return N&&typeof N!="number"&&ka(v,T,N)&&(T=N=e),v=hp(v),T===e?(T=v,v=0):T=hp(T),N=N===e?v<T?1:-1:hp(N),xme(v,T,N,m)}}function pI(m){return function(v,T){return typeof v=="string"&&typeof T=="string"||(v=$l(v),T=$l(T)),m(v,T)}}function dpt(m,v,T,N,V,Y,J,it,ft,Dt){var Ot=v&y,Vt=Ot?J:e,oe=Ot?e:J,Te=Ot?Y:e,Ne=Ot?e:Y;v|=Ot?b:S,v&=~(Ot?S:b),v&_||(v&=~(d|g));var er=[m,v,V,Te,Vt,Ne,oe,it,ft,Dt],De=T.apply(e,er);return Yq(m)&&Tpt(De,er),De.placeholder=N,Cpt(De,m,v)}function Bq(m){var v=ji[m];return function(T,N){if(T=$l(T),N=N==null?0:ra(Qe(N),292),N&&Cft(T)){var V=(on(T)+"e").split("e"),Y=v(V[0]+"e"+(+V[1]+N));return V=(on(Y)+"e").split("e"),+(V[0]+"e"+(+V[1]-N))}return v(T)}}var Ome=gx&&1/U6(new gx([,-0]))[1]==z?function(m){return new gx(m)}:sG;function mpt(m){return function(v){var T=na(v);return T==q?mq(v):T==Le?Qpe(v):Wpe(v,m(v))}}function sp(m,v,T,N,V,Y,J,it){var ft=v&g;if(!ft&&typeof m!="function")throw new Gl(i);var Dt=N?N.length:0;if(Dt||(v&=~(b|S),N=V=e),J=J===e?J:Xi(Qe(J),0),it=it===e?it:Qe(it),Dt-=V?V.length:0,v&S){var Ot=N,Vt=V;N=V=e}var oe=ft?e:Uq(m),Te=[m,v,T,N,V,Ot,Vt,Y,J,it];if(oe&&Zme(Te,oe),m=Te[0],v=Te[1],T=Te[2],N=Te[3],V=Te[4],it=Te[9]=Te[9]===e?ft?0:m.length:Xi(Te[9]-Dt,0),!it&&v&(y|x)&&(v&=~(y|x)),!v||v==d)var Ne=Rme(m,v,T);else v==y||v==x?Ne=Nme(m,v,it):(v==b||v==(d|b))&&!V.length?Ne=Dme(m,v,T,N):Ne=uI.apply(e,Te);var er=oe?$ft:Tpt;return Cpt(er(Ne,Te),m,v)}function gpt(m,v,T,N){return m===e||ru(m,mx[T])&&!un.call(N,T)?v:m}function _pt(m,v,T,N,V,Y){return ri(m)&&ri(v)&&(Y.set(v,m),aI(m,v,e,_pt,Y),Y.delete(v)),m}function zme(m){return FM(m)?e:m}function ypt(m,v,T,N,V,Y){var J=T&f,it=m.length,ft=v.length;if(it!=ft&&!(J&&ft>it))return!1;var Dt=Y.get(m),Ot=Y.get(v);if(Dt&&Ot)return Dt==v&&Ot==m;var Vt=-1,oe=!0,Te=T&p?new r_:e;for(Y.set(m,v),Y.set(v,m);++Vt<it;){var Ne=m[Vt],er=v[Vt];if(N)var De=J?N(er,Ne,Vt,v,m,Y):N(Ne,er,Vt,m,v,Y);if(De!==e){if(De)continue;oe=!1;break}if(Te){if(!cq(v,function(pr,yr){if(!MM(Te,yr)&&(Ne===pr||V(Ne,pr,T,N,Y)))return Te.push(yr)})){oe=!1;break}}else if(!(Ne===er||V(Ne,er,T,N,Y))){oe=!1;break}}return Y.delete(m),Y.delete(v),oe}function Fme(m,v,T,N,V,Y,J){switch(T){case he:if(m.byteLength!=v.byteLength||m.byteOffset!=v.byteOffset)return!1;m=m.buffer,v=v.buffer;case $t:return!(m.byteLength!=v.byteLength||!Y(new X6(m),new X6(v)));case Kt:case _t:case pt:return ru(+m,+v);case X:return m.name==v.name&&m.message==v.message;case ee:case ar:return m==v+"";case q:var it=mq;case Le:var ft=N&f;if(it||(it=U6),m.size!=v.size&&!ft)return!1;var Dt=J.get(m);if(Dt)return Dt==v;N|=p,J.set(m,v);var Ot=ypt(it(m),it(v),N,V,Y,J);return J.delete(m),Ot;case fr:if(PM)return PM.call(m)==PM.call(v)}return!1}function Bme(m,v,T,N,V,Y){var J=T&f,it=Hq(m),ft=it.length,Dt=Hq(v),Ot=Dt.length;if(ft!=Ot&&!J)return!1;for(var Vt=ft;Vt--;){var oe=it[Vt];if(!(J?oe in v:un.call(v,oe)))return!1}var Te=Y.get(m),Ne=Y.get(v);if(Te&&Ne)return Te==v&&Ne==m;var er=!0;Y.set(m,v),Y.set(v,m);for(var De=J;++Vt<ft;){oe=it[Vt];var pr=m[oe],yr=v[oe];if(N)var Xs=J?N(yr,pr,oe,v,m,Y):N(pr,yr,oe,m,v,Y);if(!(Xs===e?pr===yr||V(pr,yr,T,N,Y):Xs)){er=!1;break}De||(De=oe=="constructor")}if(er&&!De){var Ra=m.constructor,$s=v.constructor;Ra!=$s&&"constructor"in m&&"constructor"in v&&!(typeof Ra=="function"&&Ra instanceof Ra&&typeof $s=="function"&&$s instanceof $s)&&(er=!1)}return Y.delete(m),Y.delete(v),er}function lp(m){return Xq(Mpt(m,e,Rpt),m+"")}function Hq(m){return Fft(m,po,Gq)}function Vq(m){return Fft(m,ms,vpt)}var Uq=tI?function(m){return tI.get(m)}:sG;function dI(m){for(var v=m.name+"",T=_x[v],N=un.call(_x,v)?T.length:0;N--;){var V=T[N],Y=V.func;if(Y==null||Y==m)return V.name}return v}function bx(m){var v=un.call(G,"placeholder")?G:m;return v.placeholder}function ke(){var m=G.iteratee||oG;return m=m===oG?Vft:m,arguments.length?m(arguments[0],arguments[1]):m}function mI(m,v){var T=m.__data__;return jme(v)?T[typeof v=="string"?"string":"hash"]:T.map}function qq(m){for(var v=po(m),T=v.length;T--;){var N=v[T],V=m[N];v[T]=[N,V,wpt(V)]}return v}function o_(m,v){var T=Kpe(m,v);return Hft(T)?T:e}function Hme(m){var v=un.call(m,t_),T=m[t_];try{m[t_]=e;var N=!0}catch(Y){}var V=Y6.call(m);return N&&(v?m[t_]=T:delete m[t_]),V}var Gq=_q?function(m){return m==null?[]:(m=vn(m),fm(_q(m),function(v){return Eft.call(m,v)}))}:lG,vpt=_q?function(m){for(var v=[];m;)pm(v,Gq(m)),m=$6(m);return v}:lG,na=La;(yq&&na(new yq(new ArrayBuffer(1)))!=he||TM&&na(new TM)!=q||vq&&na(vq.resolve())!=kt||gx&&na(new gx)!=Le||CM&&na(new CM)!=$)&&(na=function(m){var v=La(m),T=v==wt?m.constructor:e,N=T?a_(T):"";if(N)switch(N){case wde:return he;case Sde:return q;case Mde:return kt;case Ede:return Le;case Tde:return $}return v});function Vme(m,v,T){for(var N=-1,V=T.length;++N<V;){var Y=T[N],J=Y.size;switch(Y.type){case"drop":m+=J;break;case"dropRight":v-=J;break;case"take":v=ra(v,m+J);break;case"takeRight":m=Xi(m,v-J);break}}return{start:m,end:v}}function Ume(m){var v=m.match(Et);return v?v[1].split(xt):[]}function xpt(m,v,T){v=vm(v,m);for(var N=-1,V=v.length,Y=!1;++N<V;){var J=_h(v[N]);if(!(Y=m!=null&&T(m,J)))break;m=m[J]}return Y||++N!=V?Y:(V=m==null?0:m.length,!!V&&wI(V)&&cp(J,V)&&($e(m)||s_(m)))}function qme(m){var v=m.length,T=new m.constructor(v);return v&&typeof m[0]=="string"&&un.call(m,"index")&&(T.index=m.index,T.input=m.input),T}function bpt(m){return typeof m.constructor=="function"&&!OM(m)?yx($6(m)):{}}function Gme(m,v,T){var N=m.constructor;switch(v){case $t:return zq(m);case Kt:case _t:return new N(+m);case he:return Cme(m,T);case Tt:case be:case nt:case Ct:case Wt:case fe:case at:case se:case Qt:return npt(m,T);case q:return new N;case pt:case ar:return new N(m);case ee:return Ame(m);case Le:return new N;case fr:return Pme(m)}}function Wme(m,v){var T=v.length;if(!T)return m;var N=T-1;return v[N]=(T>1?"& ":"")+v[N],v=v.join(T>2?", ":" "),m.replace(gt,`{
/* [wrapped with `+v+`] */
`)}function Yme(m){return $e(m)||s_(m)||!!(Tft&&m&&m[Tft])}function cp(m,v){var T=typeof m;return v=v==null?U:v,!!v&&(T=="number"||T!="symbol"&&np.test(m))&&m>-1&&m%1==0&&m<v}function ka(m,v,T){if(!ri(T))return!1;var N=typeof v;return(N=="number"?ds(T)&&cp(v,T.length):N=="string"&&v in T)?ru(T[v],m):!1}function Wq(m,v){if($e(m))return!1;var T=typeof m;return T=="number"||T=="symbol"||T=="boolean"||m==null||js(m)?!0:cm.test(m)||!lx.test(m)||v!=null&&m in vn(v)}function jme(m){var v=typeof m;return v=="string"||v=="number"||v=="symbol"||v=="boolean"?m!=="__proto__":m===null}function Yq(m){var v=dI(m),T=G[v];if(typeof T!="function"||!(v in gr.prototype))return!1;if(m===T)return!0;var N=Uq(T);return!!N&&m===N[0]}function Xme(m){return!!wft&&wft in m}var $me=G6?up:cG;function OM(m){var v=m&&m.constructor,T=typeof v=="function"&&v.prototype||mx;return m===T}function wpt(m){return m===m&&!ri(m)}function Spt(m,v){return function(T){return T==null?!1:T[m]===v&&(v!==e||m in vn(T))}}function Kme(m){var v=xI(m,function(N){return T.size===s&&T.clear(),N}),T=v.cache;return v}function Zme(m,v){var T=m[1],N=v[1],V=T|N,Y=V<(d|g|C),J=N==C&&T==y||N==C&&T==P&&m[7].length<=v[8]||N==(C|P)&&v[7].length<=v[8]&&T==y;if(!(Y||J))return m;N&d&&(m[2]=v[2],V|=T&d?0:_);var it=v[3];if(it){var ft=m[3];m[3]=ft?opt(ft,it,v[4]):it,m[4]=ft?dm(m[3],l):v[4]}return it=v[5],it&&(ft=m[5],m[5]=ft?apt(ft,it,v[6]):it,m[6]=ft?dm(m[5],l):v[6]),it=v[7],it&&(m[7]=it),N&C&&(m[8]=m[8]==null?v[8]:ra(m[8],v[8])),m[9]==null&&(m[9]=v[9]),m[0]=v[0],m[1]=V,m}function Jme(m){var v=[];if(m!=null)for(var T in vn(m))v.push(T);return v}function Qme(m){return Y6.call(m)}function Mpt(m,v,T){return v=Xi(v===e?m.length-1:v,0),function(){for(var N=arguments,V=-1,Y=Xi(N.length-v,0),J=vt(Y);++V<Y;)J[V]=N[v+V];V=-1;for(var it=vt(v+1);++V<v;)it[V]=N[V];return it[v]=T(J),Gs(m,this,it)}}function Ept(m,v){return v.length<2?m:i_(m,jl(v,0,-1))}function tge(m,v){for(var T=m.length,N=ra(v.length,T),V=ps(m);N--;){var Y=v[N];m[N]=cp(Y,T)?V[Y]:e}return m}function jq(m,v){if(!(v==="constructor"&&typeof m[v]=="function")&&v!="__proto__")return m[v]}var Tpt=Apt($ft),zM=mde||function(m,v){return fo.setTimeout(m,v)},Xq=Apt(Sme);function Cpt(m,v,T){var N=v+"";return Xq(m,Wme(N,ege(Ume(N),T)))}function Apt(m){var v=0,T=0;return function(){var N=vde(),V=I-(N-T);if(T=N,V>0){if(++v>=B)return arguments[0]}else v=0;return m.apply(e,arguments)}}function gI(m,v){var T=-1,N=m.length,V=N-1;for(v=v===e?N:v;++T<v;){var Y=Iq(T,V),J=m[Y];m[Y]=m[T],m[T]=J}return m.length=v,m}var Ppt=Kme(function(m){var v=[];return m.charCodeAt(0)===46&&v.push(""),m.replace(J0,function(T,N,V,Y){v.push(V?Y.replace(Ue,"$1"):N||T)}),v});function _h(m){if(typeof m=="string"||js(m))return m;var v=m+"";return v=="0"&&1/m==-z?"-0":v}function a_(m){if(m!=null){try{return W6.call(m)}catch(v){}try{return m+""}catch(v){}}return""}function ege(m,v){return ql(St,function(T){var N="_."+T[0];v&T[1]&&!H6(m,N)&&m.push(N)}),m.sort()}function Ipt(m){if(m instanceof gr)return m.clone();var v=new Wl(m.__wrapped__,m.__chain__);return v.__actions__=ps(m.__actions__),v.__index__=m.__index__,v.__values__=m.__values__,v}function rge(m,v,T){(T?ka(m,v,T):v===e)?v=1:v=Xi(Qe(v),0);var N=m==null?0:m.length;if(!N||v<1)return[];for(var V=0,Y=0,J=vt(J6(N/v));V<N;)J[Y++]=jl(m,V,V+=v);return J}function nge(m){for(var v=-1,T=m==null?0:m.length,N=0,V=[];++v<T;){var Y=m[v];Y&&(V[N++]=Y)}return V}function ige(){var m=arguments.length;if(!m)return[];for(var v=vt(m-1),T=arguments[0],N=m;N--;)v[N-1]=arguments[N];return pm($e(T)?ps(T):[T],Ro(v,1))}var oge=nr(function(m,v){return bi(m)?LM(m,Ro(v,1,bi,!0)):[]}),age=nr(function(m,v){var T=Xl(v);return bi(T)&&(T=e),bi(m)?LM(m,Ro(v,1,bi,!0),ke(T,2)):[]}),sge=nr(function(m,v){var T=Xl(v);return bi(T)&&(T=e),bi(m)?LM(m,Ro(v,1,bi,!0),e,T):[]});function lge(m,v,T){var N=m==null?0:m.length;return N?(v=T||v===e?1:Qe(v),jl(m,v<0?0:v,N)):[]}function cge(m,v,T){var N=m==null?0:m.length;return N?(v=T||v===e?1:Qe(v),v=N-v,jl(m,0,v<0?0:v)):[]}function uge(m,v){return m&&m.length?lI(m,ke(v,3),!0,!0):[]}function hge(m,v){return m&&m.length?lI(m,ke(v,3),!0):[]}function fge(m,v,T,N){var V=m==null?0:m.length;return V?(T&&typeof T!="number"&&ka(m,v,T)&&(T=0,N=V),ime(m,v,T,N)):[]}function Lpt(m,v,T){var N=m==null?0:m.length;if(!N)return-1;var V=T==null?0:Qe(T);return V<0&&(V=Xi(N+V,0)),V6(m,ke(v,3),V)}function kpt(m,v,T){var N=m==null?0:m.length;if(!N)return-1;var V=N-1;return T!==e&&(V=Qe(T),V=T<0?Xi(N+V,0):ra(V,N-1)),V6(m,ke(v,3),V,!0)}function Rpt(m){var v=m==null?0:m.length;return v?Ro(m,1):[]}function pge(m){var v=m==null?0:m.length;return v?Ro(m,z):[]}function dge(m,v){var T=m==null?0:m.length;return T?(v=v===e?1:Qe(v),Ro(m,v)):[]}function mge(m){for(var v=-1,T=m==null?0:m.length,N={};++v<T;){var V=m[v];N[V[0]]=V[1]}return N}function Npt(m){return m&&m.length?m[0]:e}function gge(m,v,T){var N=m==null?0:m.length;if(!N)return-1;var V=T==null?0:Qe(T);return V<0&&(V=Xi(N+V,0)),fx(m,v,V)}function _ge(m){var v=m==null?0:m.length;return v?jl(m,0,-1):[]}var yge=nr(function(m){var v=Kn(m,Dq);return v.length&&v[0]===m[0]?Eq(v):[]}),vge=nr(function(m){var v=Xl(m),T=Kn(m,Dq);return v===Xl(T)?v=e:T.pop(),T.length&&T[0]===m[0]?Eq(T,ke(v,2)):[]}),xge=nr(function(m){var v=Xl(m),T=Kn(m,Dq);return v=typeof v=="function"?v:e,v&&T.pop(),T.length&&T[0]===m[0]?Eq(T,e,v):[]});function bge(m,v){return m==null?"":_de.call(m,v)}function Xl(m){var v=m==null?0:m.length;return v?m[v-1]:e}function wge(m,v,T){var N=m==null?0:m.length;if(!N)return-1;var V=N;return T!==e&&(V=Qe(T),V=V<0?Xi(N+V,0):ra(V,N-1)),v===v?ede(m,v,V):V6(m,dft,V,!0)}function Sge(m,v){return m&&m.length?Wft(m,Qe(v)):e}var Mge=nr(Dpt);function Dpt(m,v){return m&&m.length&&v&&v.length?Pq(m,v):m}function Ege(m,v,T){return m&&m.length&&v&&v.length?Pq(m,v,ke(T,2)):m}function Tge(m,v,T){return m&&m.length&&v&&v.length?Pq(m,v,e,T):m}var Cge=lp(function(m,v){var T=m==null?0:m.length,N=bq(m,v);return Xft(m,Kn(v,function(V){return cp(V,T)?+V:V}).sort(ipt)),N});function Age(m,v){var T=[];if(!(m&&m.length))return T;var N=-1,V=[],Y=m.length;for(v=ke(v,3);++N<Y;){var J=m[N];v(J,N,m)&&(T.push(J),V.push(N))}return Xft(m,V),T}function $q(m){return m==null?m:bde.call(m)}function Pge(m,v,T){var N=m==null?0:m.length;return N?(T&&typeof T!="number"&&ka(m,v,T)?(v=0,T=N):(v=v==null?0:Qe(v),T=T===e?N:Qe(T)),jl(m,v,T)):[]}function Ige(m,v){return sI(m,v)}function Lge(m,v,T){return kq(m,v,ke(T,2))}function kge(m,v){var T=m==null?0:m.length;if(T){var N=sI(m,v);if(N<T&&ru(m[N],v))return N}return-1}function Rge(m,v){return sI(m,v,!0)}function Nge(m,v,T){return kq(m,v,ke(T,2),!0)}function Dge(m,v){var T=m==null?0:m.length;if(T){var N=sI(m,v,!0)-1;if(ru(m[N],v))return N}return-1}function Oge(m){return m&&m.length?Kft(m):[]}function zge(m,v){return m&&m.length?Kft(m,ke(v,2)):[]}function Fge(m){var v=m==null?0:m.length;return v?jl(m,1,v):[]}function Bge(m,v,T){return m&&m.length?(v=T||v===e?1:Qe(v),jl(m,0,v<0?0:v)):[]}function Hge(m,v,T){var N=m==null?0:m.length;return N?(v=T||v===e?1:Qe(v),v=N-v,jl(m,v<0?0:v,N)):[]}function Vge(m,v){return m&&m.length?lI(m,ke(v,3),!1,!0):[]}function Uge(m,v){return m&&m.length?lI(m,ke(v,3)):[]}var qge=nr(function(m){return ym(Ro(m,1,bi,!0))}),Gge=nr(function(m){var v=Xl(m);return bi(v)&&(v=e),ym(Ro(m,1,bi,!0),ke(v,2))}),Wge=nr(function(m){var v=Xl(m);return v=typeof v=="function"?v:e,ym(Ro(m,1,bi,!0),e,v)});function Yge(m){return m&&m.length?ym(m):[]}function jge(m,v){return m&&m.length?ym(m,ke(v,2)):[]}function Xge(m,v){return v=typeof v=="function"?v:e,m&&m.length?ym(m,e,v):[]}function Kq(m){if(!(m&&m.length))return[];var v=0;return m=fm(m,function(T){if(bi(T))return v=Xi(T.length,v),!0}),pq(v,function(T){return Kn(m,uq(T))})}function Opt(m,v){if(!(m&&m.length))return[];var T=Kq(m);return v==null?T:Kn(T,function(N){return Gs(v,e,N)})}var $ge=nr(function(m,v){return bi(m)?LM(m,v):[]}),Kge=nr(function(m){return Nq(fm(m,bi))}),Zge=nr(function(m){var v=Xl(m);return bi(v)&&(v=e),Nq(fm(m,bi),ke(v,2))}),Jge=nr(function(m){var v=Xl(m);return v=typeof v=="function"?v:e,Nq(fm(m,bi),e,v)}),Qge=nr(Kq);function t0e(m,v){return tpt(m||[],v||[],IM)}function e0e(m,v){return tpt(m||[],v||[],NM)}var r0e=nr(function(m){var v=m.length,T=v>1?m[v-1]:e;return T=typeof T=="function"?(m.pop(),T):e,Opt(m,T)});function zpt(m){var v=G(m);return v.__chain__=!0,v}function n0e(m,v){return v(m),m}function _I(m,v){return v(m)}var i0e=lp(function(m){var v=m.length,T=v?m[0]:0,N=this.__wrapped__,V=function(Y){return bq(Y,m)};return v>1||this.__actions__.length||!(N instanceof gr)||!cp(T)?this.thru(V):(N=N.slice(T,+T+(v?1:0)),N.__actions__.push({func:_I,args:[V],thisArg:e}),new Wl(N,this.__chain__).thru(function(Y){return v&&!Y.length&&Y.push(e),Y}))});function o0e(){return zpt(this)}function a0e(){return new Wl(this.value(),this.__chain__)}function s0e(){this.__values__===e&&(this.__values__=Zpt(this.value()));var m=this.__index__>=this.__values__.length,v=m?e:this.__values__[this.__index__++];return{done:m,value:v}}function l0e(){return this}function c0e(m){for(var v,T=this;T instanceof rI;){var N=Ipt(T);N.__index__=0,N.__values__=e,v?V.__wrapped__=N:v=N;var V=N;T=T.__wrapped__}return V.__wrapped__=m,v}function u0e(){var m=this.__wrapped__;if(m instanceof gr){var v=m;return this.__actions__.length&&(v=new gr(this)),v=v.reverse(),v.__actions__.push({func:_I,args:[$q],thisArg:e}),new Wl(v,this.__chain__)}return this.thru($q)}function h0e(){return Qft(this.__wrapped__,this.__actions__)}var f0e=cI(function(m,v,T){un.call(m,T)?++m[T]:ap(m,T,1)});function p0e(m,v,T){var N=$e(m)?fft:nme;return T&&ka(m,v,T)&&(v=e),N(m,ke(v,3))}function d0e(m,v){var T=$e(m)?fm:Oft;return T(m,ke(v,3))}var m0e=upt(Lpt),g0e=upt(kpt);function _0e(m,v){return Ro(yI(m,v),1)}function y0e(m,v){return Ro(yI(m,v),z)}function v0e(m,v,T){return T=T===e?1:Qe(T),Ro(yI(m,v),T)}function Fpt(m,v){var T=$e(m)?ql:_m;return T(m,ke(v,3))}function Bpt(m,v){var T=$e(m)?Fpe:Dft;return T(m,ke(v,3))}var x0e=cI(function(m,v,T){un.call(m,T)?m[T].push(v):ap(m,T,[v])});function b0e(m,v,T,N){m=ds(m)?m:Sx(m),T=T&&!N?Qe(T):0;var V=m.length;return T<0&&(T=Xi(V+T,0)),SI(m)?T<=V&&m.indexOf(v,T)>-1:!!V&&fx(m,v,T)>-1}var w0e=nr(function(m,v,T){var N=-1,V=typeof v=="function",Y=ds(m)?vt(m.length):[];return _m(m,function(J){Y[++N]=V?Gs(v,J,T):kM(J,v,T)}),Y}),S0e=cI(function(m,v,T){ap(m,T,v)});function yI(m,v){var T=$e(m)?Kn:Uft;return T(m,ke(v,3))}function M0e(m,v,T,N){return m==null?[]:($e(v)||(v=v==null?[]:[v]),T=N?e:T,$e(T)||(T=T==null?[]:[T]),Yft(m,v,T))}var E0e=cI(function(m,v,T){m[T?0:1].push(v)},function(){return[[],[]]});function T0e(m,v,T){var N=$e(m)?lq:gft,V=arguments.length<3;return N(m,ke(v,4),T,V,_m)}function C0e(m,v,T){var N=$e(m)?Bpe:gft,V=arguments.length<3;return N(m,ke(v,4),T,V,Dft)}function A0e(m,v){var T=$e(m)?fm:Oft;return T(m,bI(ke(v,3)))}function P0e(m){var v=$e(m)?Lft:bme;return v(m)}function I0e(m,v,T){(T?ka(m,v,T):v===e)?v=1:v=Qe(v);var N=$e(m)?Jde:wme;return N(m,v)}function L0e(m){var v=$e(m)?Qde:Mme;return v(m)}function k0e(m){if(m==null)return 0;if(ds(m))return SI(m)?dx(m):m.length;var v=na(m);return v==q||v==Le?m.size:Cq(m).length}function R0e(m,v,T){var N=$e(m)?cq:Eme;return T&&ka(m,v,T)&&(v=e),N(m,ke(v,3))}var N0e=nr(function(m,v){if(m==null)return[];var T=v.length;return T>1&&ka(m,v[0],v[1])?v=[]:T>2&&ka(v[0],v[1],v[2])&&(v=[v[0]]),Yft(m,Ro(v,1),[])}),vI=dde||function(){return fo.Date.now()};function D0e(m,v){if(typeof v!="function")throw new Gl(i);return m=Qe(m),function(){if(--m<1)return v.apply(this,arguments)}}function Hpt(m,v,T){return v=T?e:v,v=m&&v==null?m.length:v,sp(m,C,e,e,e,e,v)}function Vpt(m,v){var T;if(typeof v!="function")throw new Gl(i);return m=Qe(m),function(){return--m>0&&(T=v.apply(this,arguments)),m<=1&&(v=e),T}}var Zq=nr(function(m,v,T){var N=d;if(T.length){var V=dm(T,bx(Zq));N|=b}return sp(m,N,v,T,V)}),Upt=nr(function(m,v,T){var N=d|g;if(T.length){var V=dm(T,bx(Upt));N|=b}return sp(v,N,m,T,V)});function qpt(m,v,T){v=T?e:v;var N=sp(m,y,e,e,e,e,e,v);return N.placeholder=qpt.placeholder,N}function Gpt(m,v,T){v=T?e:v;var N=sp(m,x,e,e,e,e,e,v);return N.placeholder=Gpt.placeholder,N}function Wpt(m,v,T){var N,V,Y,J,it,ft,Dt=0,Ot=!1,Vt=!1,oe=!0;if(typeof m!="function")throw new Gl(i);v=$l(v)||0,ri(T)&&(Ot=!!T.leading,Vt="maxWait"in T,Y=Vt?Xi($l(T.maxWait)||0,v):Y,oe="trailing"in T?!!T.trailing:oe);function Te(wi){var nu=N,fp=V;return N=V=e,Dt=wi,J=m.apply(fp,nu),J}function Ne(wi){return Dt=wi,it=zM(pr,v),Ot?Te(wi):J}function er(wi){var nu=wi-ft,fp=wi-Dt,udt=v-nu;return Vt?ra(udt,Y-fp):udt}function De(wi){var nu=wi-ft,fp=wi-Dt;return ft===e||nu>=v||nu<0||Vt&&fp>=Y}function pr(){var wi=vI();if(De(wi))return yr(wi);it=zM(pr,er(wi))}function yr(wi){return it=e,oe&&N?Te(wi):(N=V=e,J)}function Xs(){it!==e&&ept(it),Dt=0,N=ft=V=it=e}function Ra(){return it===e?J:yr(vI())}function $s(){var wi=vI(),nu=De(wi);if(N=arguments,V=this,ft=wi,nu){if(it===e)return Ne(ft);if(Vt)return ept(it),it=zM(pr,v),Te(ft)}return it===e&&(it=zM(pr,v)),J}return $s.cancel=Xs,$s.flush=Ra,$s}var O0e=nr(function(m,v){return Nft(m,1,v)}),z0e=nr(function(m,v,T){return Nft(m,$l(v)||0,T)});function F0e(m){return sp(m,k)}function xI(m,v){if(typeof m!="function"||v!=null&&typeof v!="function")throw new Gl(i);var T=function(){var N=arguments,V=v?v.apply(this,N):N[0],Y=T.cache;if(Y.has(V))return Y.get(V);var J=m.apply(this,N);return T.cache=Y.set(V,J)||Y,J};return T.cache=new(xI.Cache||op),T}xI.Cache=op;function bI(m){if(typeof m!="function")throw new Gl(i);return function(){var v=arguments;switch(v.length){case 0:return!m.call(this);case 1:return!m.call(this,v[0]);case 2:return!m.call(this,v[0],v[1]);case 3:return!m.call(this,v[0],v[1],v[2])}return!m.apply(this,v)}}function B0e(m){return Vpt(2,m)}var H0e=Tme(function(m,v){v=v.length==1&&$e(v[0])?Kn(v[0],Ws(ke())):Kn(Ro(v,1),Ws(ke()));var T=v.length;return nr(function(N){for(var V=-1,Y=ra(N.length,T);++V<Y;)N[V]=v[V].call(this,N[V]);return Gs(m,this,N)})}),Jq=nr(function(m,v){var T=dm(v,bx(Jq));return sp(m,b,e,v,T)}),Ypt=nr(function(m,v){var T=dm(v,bx(Ypt));return sp(m,S,e,v,T)}),V0e=lp(function(m,v){return sp(m,P,e,e,e,v)});function U0e(m,v){if(typeof m!="function")throw new Gl(i);return v=v===e?v:Qe(v),nr(m,v)}function q0e(m,v){if(typeof m!="function")throw new Gl(i);return v=v==null?0:Xi(Qe(v),0),nr(function(T){var N=T[v],V=xm(T,0,v);return N&&pm(V,N),Gs(m,this,V)})}function G0e(m,v,T){var N=!0,V=!0;if(typeof m!="function")throw new Gl(i);return ri(T)&&(N="leading"in T?!!T.leading:N,V="trailing"in T?!!T.trailing:V),Wpt(m,v,{leading:N,maxWait:v,trailing:V})}function W0e(m){return Hpt(m,1)}function Y0e(m,v){return Jq(Oq(v),m)}function j0e(){if(!arguments.length)return[];var m=arguments[0];return $e(m)?m:[m]}function X0e(m){return Yl(m,h)}function $0e(m,v){return v=typeof v=="function"?v:e,Yl(m,h,v)}function K0e(m){return Yl(m,c|h)}function Z0e(m,v){return v=typeof v=="function"?v:e,Yl(m,c|h,v)}function J0e(m,v){return v==null||Rft(m,v,po(v))}function ru(m,v){return m===v||m!==m&&v!==v}var Q0e=pI(Mq),t_e=pI(function(m,v){return m>=v}),s_=Bft(function(){return arguments}())?Bft:function(m){return li(m)&&un.call(m,"callee")&&!Eft.call(m,"callee")},$e=vt.isArray,e_e=aft?Ws(aft):cme;function ds(m){return m!=null&&wI(m.length)&&!up(m)}function bi(m){return li(m)&&ds(m)}function r_e(m){return m===!0||m===!1||li(m)&&La(m)==Kt}var bm=gde||cG,n_e=sft?Ws(sft):ume;function i_e(m){return li(m)&&m.nodeType===1&&!FM(m)}function o_e(m){if(m==null)return!0;if(ds(m)&&($e(m)||typeof m=="string"||typeof m.splice=="function"||bm(m)||wx(m)||s_(m)))return!m.length;var v=na(m);if(v==q||v==Le)return!m.size;if(OM(m))return!Cq(m).length;for(var T in m)if(un.call(m,T))return!1;return!0}function a_e(m,v){return RM(m,v)}function s_e(m,v,T){T=typeof T=="function"?T:e;var N=T?T(m,v):e;return N===e?RM(m,v,e,T):!!N}function Qq(m){if(!li(m))return!1;var v=La(m);return v==X||v==ct||typeof m.message=="string"&&typeof m.name=="string"&&!FM(m)}function l_e(m){return typeof m=="number"&&Cft(m)}function up(m){if(!ri(m))return!1;var v=La(m);return v==et||v==dt||v==lt||v==ie}function jpt(m){return typeof m=="number"&&m==Qe(m)}function wI(m){return typeof m=="number"&&m>-1&&m%1==0&&m<=U}function ri(m){var v=typeof m;return m!=null&&(v=="object"||v=="function")}function li(m){return m!=null&&typeof m=="object"}var Xpt=lft?Ws(lft):fme;function c_e(m,v){return m===v||Tq(m,v,qq(v))}function u_e(m,v,T){return T=typeof T=="function"?T:e,Tq(m,v,qq(v),T)}function h_e(m){return $pt(m)&&m!=+m}function f_e(m){if($me(m))throw new We(n);return Hft(m)}function p_e(m){return m===null}function d_e(m){return m==null}function $pt(m){return typeof m=="number"||li(m)&&La(m)==pt}function FM(m){if(!li(m)||La(m)!=wt)return!1;var v=$6(m);if(v===null)return!0;var T=un.call(v,"constructor")&&v.constructor;return typeof T=="function"&&T instanceof T&&W6.call(T)==ude}var tG=cft?Ws(cft):pme;function m_e(m){return jpt(m)&&m>=-U&&m<=U}var Kpt=uft?Ws(uft):dme;function SI(m){return typeof m=="string"||!$e(m)&&li(m)&&La(m)==ar}function js(m){return typeof m=="symbol"||li(m)&&La(m)==fr}var wx=hft?Ws(hft):mme;function g_e(m){return m===e}function __e(m){return li(m)&&na(m)==$}function y_e(m){return li(m)&&La(m)==It}var v_e=pI(Aq),x_e=pI(function(m,v){return m<=v});function Zpt(m){if(!m)return[];if(ds(m))return SI(m)?tu(m):ps(m);if(EM&&m[EM])return Jpe(m[EM]());var v=na(m),T=v==q?mq:v==Le?U6:Sx;return T(m)}function hp(m){if(!m)return m===0?m:0;if(m=$l(m),m===z||m===-z){var v=m<0?-1:1;return v*W}return m===m?m:0}function Qe(m){var v=hp(m),T=v%1;return v===v?T?v-T:v:0}function Jpt(m){return m?n_(Qe(m),0,rt):0}function $l(m){if(typeof m=="number")return m;if(js(m))return Z;if(ri(m)){var v=typeof m.valueOf=="function"?m.valueOf():m;m=ri(v)?v+"":v}if(typeof m!="string")return m===0?m:+m;m=_ft(m);var T=_r.test(m);return T||Xn.test(m)?Dpe(m.slice(2),T?2:8):Xr.test(m)?Z:+m}function Qpt(m){return gh(m,ms(m))}function b_e(m){return m?n_(Qe(m),-U,U):m===0?m:0}function on(m){return m==null?"":Ys(m)}var w_e=vx(function(m,v){if(OM(v)||ds(v)){gh(v,po(v),m);return}for(var T in v)un.call(v,T)&&IM(m,T,v[T])}),tdt=vx(function(m,v){gh(v,ms(v),m)}),MI=vx(function(m,v,T,N){gh(v,ms(v),m,N)}),S_e=vx(function(m,v,T,N){gh(v,po(v),m,N)}),M_e=lp(bq);function E_e(m,v){var T=yx(m);return v==null?T:kft(T,v)}var T_e=nr(function(m,v){m=vn(m);var T=-1,N=v.length,V=N>2?v[2]:e;for(V&&ka(v[0],v[1],V)&&(N=1);++T<N;)for(var Y=v[T],J=ms(Y),it=-1,ft=J.length;++it<ft;){var Dt=J[it],Ot=m[Dt];(Ot===e||ru(Ot,mx[Dt])&&!un.call(m,Dt))&&(m[Dt]=Y[Dt])}return m}),C_e=nr(function(m){return m.push(e,_pt),Gs(edt,e,m)});function A_e(m,v){return pft(m,ke(v,3),mh)}function P_e(m,v){return pft(m,ke(v,3),Sq)}function I_e(m,v){return m==null?m:wq(m,ke(v,3),ms)}function L_e(m,v){return m==null?m:zft(m,ke(v,3),ms)}function k_e(m,v){return m&&mh(m,ke(v,3))}function R_e(m,v){return m&&Sq(m,ke(v,3))}function N_e(m){return m==null?[]:oI(m,po(m))}function D_e(m){return m==null?[]:oI(m,ms(m))}function eG(m,v,T){var N=m==null?e:i_(m,v);return N===e?T:N}function O_e(m,v){return m!=null&&xpt(m,v,ome)}function rG(m,v){return m!=null&&xpt(m,v,ame)}var z_e=fpt(function(m,v,T){v!=null&&typeof v.toString!="function"&&(v=Y6.call(v)),m[v]=T},iG(gs)),F_e=fpt(function(m,v,T){v!=null&&typeof v.toString!="function"&&(v=Y6.call(v)),un.call(m,v)?m[v].push(T):m[v]=[T]},ke),B_e=nr(kM);function po(m){return ds(m)?Ift(m):Cq(m)}function ms(m){return ds(m)?Ift(m,!0):gme(m)}function H_e(m,v){var T={};return v=ke(v,3),mh(m,function(N,V,Y){ap(T,v(N,V,Y),N)}),T}function V_e(m,v){var T={};return v=ke(v,3),mh(m,function(N,V,Y){ap(T,V,v(N,V,Y))}),T}var U_e=vx(function(m,v,T){aI(m,v,T)}),edt=vx(function(m,v,T,N){aI(m,v,T,N)}),q_e=lp(function(m,v){var T={};if(m==null)return T;var N=!1;v=Kn(v,function(Y){return Y=vm(Y,m),N||(N=Y.length>1),Y}),gh(m,Vq(m),T),N&&(T=Yl(T,c|u|h,zme));for(var V=v.length;V--;)Rq(T,v[V]);return T});function G_e(m,v){return rdt(m,bI(ke(v)))}var W_e=lp(function(m,v){return m==null?{}:yme(m,v)});function rdt(m,v){if(m==null)return{};var T=Kn(Vq(m),function(N){return[N]});return v=ke(v),jft(m,T,function(N,V){return v(N,V[0])})}function Y_e(m,v,T){v=vm(v,m);var N=-1,V=v.length;for(V||(V=1,m=e);++N<V;){var Y=m==null?e:m[_h(v[N])];Y===e&&(N=V,Y=T),m=up(Y)?Y.call(m):Y}return m}function j_e(m,v,T){return m==null?m:NM(m,v,T)}function X_e(m,v,T,N){return N=typeof N=="function"?N:e,m==null?m:NM(m,v,T,N)}var ndt=mpt(po),idt=mpt(ms);function $_e(m,v,T){var N=$e(m),V=N||bm(m)||wx(m);if(v=ke(v,4),T==null){var Y=m&&m.constructor;V?T=N?new Y:[]:ri(m)?T=up(Y)?yx($6(m)):{}:T={}}return(V?ql:mh)(m,function(J,it,ft){return v(T,J,it,ft)}),T}function K_e(m,v){return m==null?!0:Rq(m,v)}function Z_e(m,v,T){return m==null?m:Jft(m,v,Oq(T))}function J_e(m,v,T,N){return N=typeof N=="function"?N:e,m==null?m:Jft(m,v,Oq(T),N)}function Sx(m){return m==null?[]:dq(m,po(m))}function Q_e(m){return m==null?[]:dq(m,ms(m))}function tye(m,v,T){return T===e&&(T=v,v=e),T!==e&&(T=$l(T),T=T===T?T:0),v!==e&&(v=$l(v),v=v===v?v:0),n_($l(m),v,T)}function eye(m,v,T){return v=hp(v),T===e?(T=v,v=0):T=hp(T),m=$l(m),sme(m,v,T)}function rye(m,v,T){if(T&&typeof T!="boolean"&&ka(m,v,T)&&(v=T=e),T===e&&(typeof v=="boolean"?(T=v,v=e):typeof m=="boolean"&&(T=m,m=e)),m===e&&v===e?(m=0,v=1):(m=hp(m),v===e?(v=m,m=0):v=hp(v)),m>v){var N=m;m=v,v=N}if(T||m%1||v%1){var V=Aft();return ra(m+V*(v-m+Npe("1e-"+((V+"").length-1))),v)}return Iq(m,v)}var nye=xx(function(m,v,T){return v=v.toLowerCase(),m+(T?odt(v):v)});function odt(m){return nG(on(m).toLowerCase())}function adt(m){return m=on(m),m&&m.replace(um,jpe).replace(Mpe,"")}function iye(m,v,T){m=on(m),v=Ys(v);var N=m.length;T=T===e?N:n_(Qe(T),0,N);var V=T;return T-=v.length,T>=0&&m.slice(T,V)==v}function oye(m){return m=on(m),m&&Ar.test(m)?m.replace(yn,Xpe):m}function aye(m){return m=on(m),m&&cx.test(m)?m.replace(cn,"\\$&"):m}var sye=xx(function(m,v,T){return m+(T?"-":"")+v.toLowerCase()}),lye=xx(function(m,v,T){return m+(T?" ":"")+v.toLowerCase()}),cye=cpt("toLowerCase");function uye(m,v,T){m=on(m),v=Qe(v);var N=v?dx(m):0;if(!v||N>=v)return m;var V=(v-N)/2;return fI(Q6(V),T)+m+fI(J6(V),T)}function hye(m,v,T){m=on(m),v=Qe(v);var N=v?dx(m):0;return v&&N<v?m+fI(v-N,T):m}function fye(m,v,T){m=on(m),v=Qe(v);var N=v?dx(m):0;return v&&N<v?fI(v-N,T)+m:m}function pye(m,v,T){return T||v==null?v=0:v&&(v=+v),xde(on(m).replace(rp,""),v||0)}function dye(m,v,T){return(T?ka(m,v,T):v===e)?v=1:v=Qe(v),Lq(on(m),v)}function mye(){var m=arguments,v=on(m[0]);return m.length<3?v:v.replace(m[1],m[2])}var gye=xx(function(m,v,T){return m+(T?"_":"")+v.toLowerCase()});function _ye(m,v,T){return T&&typeof T!="number"&&ka(m,v,T)&&(v=T=e),T=T===e?rt:T>>>0,T?(m=on(m),m&&(typeof v=="string"||v!=null&&!tG(v))&&(v=Ys(v),!v&&px(m))?xm(tu(m),0,T):m.split(v,T)):[]}var yye=xx(function(m,v,T){return m+(T?" ":"")+nG(v)});function vye(m,v,T){return m=on(m),T=T==null?0:n_(Qe(T),0,m.length),v=Ys(v),m.slice(T,T+v.length)==v}function xye(m,v,T){var N=G.templateSettings;T&&ka(m,v,T)&&(v=e),m=on(m),v=MI({},v,N,gpt);var V=MI({},v.imports,N.imports,gpt),Y=po(V),J=dq(V,Y),it,ft,Dt=0,Ot=v.interpolate||mr,Vt="__p += '",oe=gq((v.escape||mr).source+"|"+Ot.source+"|"+(Ot===Ia?tr:mr).source+"|"+(v.evaluate||mr).source+"|$","g"),Te="//# sourceURL="+(un.call(v,"sourceURL")?(v.sourceURL+"").replace(/\s/g," "):"lodash.templateSources["+ ++Ppe+"]")+`
`;m.replace(oe,function(De,pr,yr,Xs,Ra,$s){return yr||(yr=Xs),Vt+=m.slice(Dt,$s).replace(Fl,$pe),pr&&(it=!0,Vt+=`' +
__e(`+pr+`) +
'`),Ra&&(ft=!0,Vt+=`';
`+Ra+`;
__p += '`),yr&&(Vt+=`' +
((__t = (`+yr+`)) == null ? '' : __t) +
'`),Dt=$s+De.length,De}),Vt+=`';
`;var Ne=un.call(v,"variable")&&v.variable;if(!Ne)Vt=`with (obj) {
`+Vt+`
}
`;else if(Ve.test(Ne))throw new We(o);Vt=(ft?Vt.replace(Ce,""):Vt).replace(Pt,"$1").replace(Nt,"$1;"),Vt="function("+(Ne||"obj")+`) {
`+(Ne?"":`obj || (obj = {});
`)+"var __t, __p = ''"+(it?", __e = _.escape":"")+(ft?`, __j = Array.prototype.join;
function print() { __p += __j.call(arguments, '') }
`:`;
`)+Vt+`return __p
}`;var er=ldt(function(){return $r(Y,Te+"return "+Vt).apply(e,J)});if(er.source=Vt,Qq(er))throw er;return er}function bye(m){return on(m).toLowerCase()}function wye(m){return on(m).toUpperCase()}function Sye(m,v,T){if(m=on(m),m&&(T||v===e))return _ft(m);if(!m||!(v=Ys(v)))return m;var N=tu(m),V=tu(v),Y=yft(N,V),J=vft(N,V)+1;return xm(N,Y,J).join("")}function Mye(m,v,T){if(m=on(m),m&&(T||v===e))return m.slice(0,bft(m)+1);if(!m||!(v=Ys(v)))return m;var N=tu(m),V=vft(N,tu(v))+1;return xm(N,0,V).join("")}function Eye(m,v,T){if(m=on(m),m&&(T||v===e))return m.replace(rp,"");if(!m||!(v=Ys(v)))return m;var N=tu(m),V=yft(N,tu(v));return xm(N,V).join("")}function Tye(m,v){var T=O,N=D;if(ri(v)){var V="separator"in v?v.separator:V;T="length"in v?Qe(v.length):T,N="omission"in v?Ys(v.omission):N}m=on(m);var Y=m.length;if(px(m)){var J=tu(m);Y=J.length}if(T>=Y)return m;var it=T-dx(N);if(it<1)return N;var ft=J?xm(J,0,it).join(""):m.slice(0,it);if(V===e)return ft+N;if(J&&(it+=ft.length-it),tG(V)){if(m.slice(it).search(V)){var Dt,Ot=ft;for(V.global||(V=gq(V.source,on(Ke.exec(V))+"g")),V.lastIndex=0;Dt=V.exec(Ot);)var Vt=Dt.index;ft=ft.slice(0,Vt===e?it:Vt)}}else if(m.indexOf(Ys(V),it)!=it){var oe=ft.lastIndexOf(V);oe>-1&&(ft=ft.slice(0,oe))}return ft+N}function Cye(m){return m=on(m),m&&Wi.test(m)?m.replace(ze,rde):m}var Aye=xx(function(m,v,T){return m+(T?" ":"")+v.toUpperCase()}),nG=cpt("toUpperCase");function sdt(m,v,T){return m=on(m),v=T?e:v,v===e?Zpe(m)?ode(m):Upe(m):m.match(v)||[]}var ldt=nr(function(m,v){try{return Gs(m,e,v)}catch(T){return Qq(T)?T:new We(T)}}),Pye=lp(function(m,v){return ql(v,function(T){T=_h(T),ap(m,T,Zq(m[T],m))}),m});function Iye(m){var v=m==null?0:m.length,T=ke();return m=v?Kn(m,function(N){if(typeof N[1]!="function")throw new Gl(i);return[T(N[0]),N[1]]}):[],nr(function(N){for(var V=-1;++V<v;){var Y=m[V];if(Gs(Y[0],this,N))return Gs(Y[1],this,N)}})}function Lye(m){return rme(Yl(m,c))}function iG(m){return function(){return m}}function kye(m,v){return m==null||m!==m?v:m}var Rye=hpt(),Nye=hpt(!0);function gs(m){return m}function oG(m){return Vft(typeof m=="function"?m:Yl(m,c))}function Dye(m){return qft(Yl(m,c))}function Oye(m,v){return Gft(m,Yl(v,c))}var zye=nr(function(m,v){return function(T){return kM(T,m,v)}}),Fye=nr(function(m,v){return function(T){return kM(m,T,v)}});function aG(m,v,T){var N=po(v),V=oI(v,N);T==null&&!(ri(v)&&(V.length||!N.length))&&(T=v,v=m,m=this,V=oI(v,po(v)));var Y=!(ri(T)&&"chain"in T)||!!T.chain,J=up(m);return ql(V,function(it){var ft=v[it];m[it]=ft,J&&(m.prototype[it]=function(){var Dt=this.__chain__;if(Y||Dt){var Ot=m(this.__wrapped__),Vt=Ot.__actions__=ps(this.__actions__);return Vt.push({func:ft,args:arguments,thisArg:m}),Ot.__chain__=Dt,Ot}return ft.apply(m,pm([this.value()],arguments))})}),m}function Bye(){return fo._===this&&(fo._=hde),this}function sG(){}function Hye(m){return m=Qe(m),nr(function(v){return Wft(v,m)})}var Vye=Fq(Kn),Uye=Fq(fft),qye=Fq(cq);function cdt(m){return Wq(m)?uq(_h(m)):vme(m)}function Gye(m){return function(v){return m==null?e:i_(m,v)}}var Wye=ppt(),Yye=ppt(!0);function lG(){return[]}function cG(){return!1}function jye(){return{}}function Xye(){return""}function $ye(){return!0}function Kye(m,v){if(m=Qe(m),m<1||m>U)return[];var T=rt,N=ra(m,rt);v=ke(v),m-=rt;for(var V=pq(N,v);++T<m;)v(T);return V}function Zye(m){return $e(m)?Kn(m,_h):js(m)?[m]:ps(Ppt(on(m)))}function Jye(m){var v=++cde;return on(m)+v}var Qye=hI(function(m,v){return m+v},0),t1e=Bq("ceil"),e1e=hI(function(m,v){return m/v},1),r1e=Bq("floor");function n1e(m){return m&&m.length?iI(m,gs,Mq):e}function i1e(m,v){return m&&m.length?iI(m,ke(v,2),Mq):e}function o1e(m){return mft(m,gs)}function a1e(m,v){return mft(m,ke(v,2))}function s1e(m){return m&&m.length?iI(m,gs,Aq):e}function l1e(m,v){return m&&m.length?iI(m,ke(v,2),Aq):e}var c1e=hI(function(m,v){return m*v},1),u1e=Bq("round"),h1e=hI(function(m,v){return m-v},0);function f1e(m){return m&&m.length?fq(m,gs):0}function p1e(m,v){return m&&m.length?fq(m,ke(v,2)):0}return G.after=D0e,G.ary=Hpt,G.assign=w_e,G.assignIn=tdt,G.assignInWith=MI,G.assignWith=S_e,G.at=M_e,G.before=Vpt,G.bind=Zq,G.bindAll=Pye,G.bindKey=Upt,G.castArray=j0e,G.chain=zpt,G.chunk=rge,G.compact=nge,G.concat=ige,G.cond=Iye,G.conforms=Lye,G.constant=iG,G.countBy=f0e,G.create=E_e,G.curry=qpt,G.curryRight=Gpt,G.debounce=Wpt,G.defaults=T_e,G.defaultsDeep=C_e,G.defer=O0e,G.delay=z0e,G.difference=oge,G.differenceBy=age,G.differenceWith=sge,G.drop=lge,G.dropRight=cge,G.dropRightWhile=uge,G.dropWhile=hge,G.fill=fge,G.filter=d0e,G.flatMap=_0e,G.flatMapDeep=y0e,G.flatMapDepth=v0e,G.flatten=Rpt,G.flattenDeep=pge,G.flattenDepth=dge,G.flip=F0e,G.flow=Rye,G.flowRight=Nye,G.fromPairs=mge,G.functions=N_e,G.functionsIn=D_e,G.groupBy=x0e,G.initial=_ge,G.intersection=yge,G.intersectionBy=vge,G.intersectionWith=xge,G.invert=z_e,G.invertBy=F_e,G.invokeMap=w0e,G.iteratee=oG,G.keyBy=S0e,G.keys=po,G.keysIn=ms,G.map=yI,G.mapKeys=H_e,G.mapValues=V_e,G.matches=Dye,G.matchesProperty=Oye,G.memoize=xI,G.merge=U_e,G.mergeWith=edt,G.method=zye,G.methodOf=Fye,G.mixin=aG,G.negate=bI,G.nthArg=Hye,G.omit=q_e,G.omitBy=G_e,G.once=B0e,G.orderBy=M0e,G.over=Vye,G.overArgs=H0e,G.overEvery=Uye,G.overSome=qye,G.partial=Jq,G.partialRight=Ypt,G.partition=E0e,G.pick=W_e,G.pickBy=rdt,G.property=cdt,G.propertyOf=Gye,G.pull=Mge,G.pullAll=Dpt,G.pullAllBy=Ege,G.pullAllWith=Tge,G.pullAt=Cge,G.range=Wye,G.rangeRight=Yye,G.rearg=V0e,G.reject=A0e,G.remove=Age,G.rest=U0e,G.reverse=$q,G.sampleSize=I0e,G.set=j_e,G.setWith=X_e,G.shuffle=L0e,G.slice=Pge,G.sortBy=N0e,G.sortedUniq=Oge,G.sortedUniqBy=zge,G.split=_ye,G.spread=q0e,G.tail=Fge,G.take=Bge,G.takeRight=Hge,G.takeRightWhile=Vge,G.takeWhile=Uge,G.tap=n0e,G.throttle=G0e,G.thru=_I,G.toArray=Zpt,G.toPairs=ndt,G.toPairsIn=idt,G.toPath=Zye,G.toPlainObject=Qpt,G.transform=$_e,G.unary=W0e,G.union=qge,G.unionBy=Gge,G.unionWith=Wge,G.uniq=Yge,G.uniqBy=jge,G.uniqWith=Xge,G.unset=K_e,G.unzip=Kq,G.unzipWith=Opt,G.update=Z_e,G.updateWith=J_e,G.values=Sx,G.valuesIn=Q_e,G.without=$ge,G.words=sdt,G.wrap=Y0e,G.xor=Kge,G.xorBy=Zge,G.xorWith=Jge,G.zip=Qge,G.zipObject=t0e,G.zipObjectDeep=e0e,G.zipWith=r0e,G.entries=ndt,G.entriesIn=idt,G.extend=tdt,G.extendWith=MI,aG(G,G),G.add=Qye,G.attempt=ldt,G.camelCase=nye,G.capitalize=odt,G.ceil=t1e,G.clamp=tye,G.clone=X0e,G.cloneDeep=K0e,G.cloneDeepWith=Z0e,G.cloneWith=$0e,G.conformsTo=J0e,G.deburr=adt,G.defaultTo=kye,G.divide=e1e,G.endsWith=iye,G.eq=ru,G.escape=oye,G.escapeRegExp=aye,G.every=p0e,G.find=m0e,G.findIndex=Lpt,G.findKey=A_e,G.findLast=g0e,G.findLastIndex=kpt,G.findLastKey=P_e,G.floor=r1e,G.forEach=Fpt,G.forEachRight=Bpt,G.forIn=I_e,G.forInRight=L_e,G.forOwn=k_e,G.forOwnRight=R_e,G.get=eG,G.gt=Q0e,G.gte=t_e,G.has=O_e,G.hasIn=rG,G.head=Npt,G.identity=gs,G.includes=b0e,G.indexOf=gge,G.inRange=eye,G.invoke=B_e,G.isArguments=s_,G.isArray=$e,G.isArrayBuffer=e_e,G.isArrayLike=ds,G.isArrayLikeObject=bi,G.isBoolean=r_e,G.isBuffer=bm,G.isDate=n_e,G.isElement=i_e,G.isEmpty=o_e,G.isEqual=a_e,G.isEqualWith=s_e,G.isError=Qq,G.isFinite=l_e,G.isFunction=up,G.isInteger=jpt,G.isLength=wI,G.isMap=Xpt,G.isMatch=c_e,G.isMatchWith=u_e,G.isNaN=h_e,G.isNative=f_e,G.isNil=d_e,G.isNull=p_e,G.isNumber=$pt,G.isObject=ri,G.isObjectLike=li,G.isPlainObject=FM,G.isRegExp=tG,G.isSafeInteger=m_e,G.isSet=Kpt,G.isString=SI,G.isSymbol=js,G.isTypedArray=wx,G.isUndefined=g_e,G.isWeakMap=__e,G.isWeakSet=y_e,G.join=bge,G.kebabCase=sye,G.last=Xl,G.lastIndexOf=wge,G.lowerCase=lye,G.lowerFirst=cye,G.lt=v_e,G.lte=x_e,G.max=n1e,G.maxBy=i1e,G.mean=o1e,G.meanBy=a1e,G.min=s1e,G.minBy=l1e,G.stubArray=lG,G.stubFalse=cG,G.stubObject=jye,G.stubString=Xye,G.stubTrue=$ye,G.multiply=c1e,G.nth=Sge,G.noConflict=Bye,G.noop=sG,G.now=vI,G.pad=uye,G.padEnd=hye,G.padStart=fye,G.parseInt=pye,G.random=rye,G.reduce=T0e,G.reduceRight=C0e,G.repeat=dye,G.replace=mye,G.result=Y_e,G.round=u1e,G.runInContext=ut,G.sample=P0e,G.size=k0e,G.snakeCase=gye,G.some=R0e,G.sortedIndex=Ige,G.sortedIndexBy=Lge,G.sortedIndexOf=kge,G.sortedLastIndex=Rge,G.sortedLastIndexBy=Nge,G.sortedLastIndexOf=Dge,G.startCase=yye,G.startsWith=vye,G.subtract=h1e,G.sum=f1e,G.sumBy=p1e,G.template=xye,G.times=Kye,G.toFinite=hp,G.toInteger=Qe,G.toLength=Jpt,G.toLower=bye,G.toNumber=$l,G.toSafeInteger=b_e,G.toString=on,G.toUpper=wye,G.trim=Sye,G.trimEnd=Mye,G.trimStart=Eye,G.truncate=Tye,G.unescape=Cye,G.uniqueId=Jye,G.upperCase=Aye,G.upperFirst=nG,G.each=Fpt,G.eachRight=Bpt,G.first=Npt,aG(G,function(){var m={};return mh(G,function(v,T){un.call(G.prototype,T)||(m[T]=v)}),m}(),{chain:!1}),G.VERSION=t,ql(["bind","bindKey","curry","curryRight","partial","partialRight"],function(m){G[m].placeholder=G}),ql(["drop","take"],function(m,v){gr.prototype[m]=function(T){T=T===e?1:Xi(Qe(T),0);var N=this.__filtered__&&!v?new gr(this):this.clone();return N.__filtered__?N.__takeCount__=ra(T,N.__takeCount__):N.__views__.push({size:ra(T,rt),type:m+(N.__dir__<0?"Right":"")}),N},gr.prototype[m+"Right"]=function(T){return this.reverse()[m](T).reverse()}}),ql(["filter","map","takeWhile"],function(m,v){var T=v+1,N=T==L||T==F;gr.prototype[m]=function(V){var Y=this.clone();return Y.__iteratees__.push({iteratee:ke(V,3),type:T}),Y.__filtered__=Y.__filtered__||N,Y}}),ql(["head","last"],function(m,v){var T="take"+(v?"Right":"");gr.prototype[m]=function(){return this[T](1).value()[0]}}),ql(["initial","tail"],function(m,v){var T="drop"+(v?"":"Right");gr.prototype[m]=function(){return this.__filtered__?new gr(this):this[T](1)}}),gr.prototype.compact=function(){return this.filter(gs)},gr.prototype.find=function(m){return this.filter(m).head()},gr.prototype.findLast=function(m){return this.reverse().find(m)},gr.prototype.invokeMap=nr(function(m,v){return typeof m=="function"?new gr(this):this.map(function(T){return kM(T,m,v)})}),gr.prototype.reject=function(m){return this.filter(bI(ke(m)))},gr.prototype.slice=function(m,v){m=Qe(m);var T=this;return T.__filtered__&&(m>0||v<0)?new gr(T):(m<0?T=T.takeRight(-m):m&&(T=T.drop(m)),v!==e&&(v=Qe(v),T=v<0?T.dropRight(-v):T.take(v-m)),T)},gr.prototype.takeRightWhile=function(m){return this.reverse().takeWhile(m).reverse()},gr.prototype.toArray=function(){return this.take(rt)},mh(gr.prototype,function(m,v){var T=/^(?:filter|find|map|reject)|While$/.test(v),N=/^(?:head|last)$/.test(v),V=G[N?"take"+(v=="last"?"Right":""):v],Y=N||/^find/.test(v);!V||(G.prototype[v]=function(){var J=this.__wrapped__,it=N?[1]:arguments,ft=J instanceof gr,Dt=it[0],Ot=ft||$e(J),Vt=function(pr){var yr=V.apply(G,pm([pr],it));return N&&oe?yr[0]:yr};Ot&&T&&typeof Dt=="function"&&Dt.length!=1&&(ft=Ot=!1);var oe=this.__chain__,Te=!!this.__actions__.length,Ne=Y&&!oe,er=ft&&!Te;if(!Y&&Ot){J=er?J:new gr(this);var De=m.apply(J,it);return De.__actions__.push({func:_I,args:[Vt],thisArg:e}),new Wl(De,oe)}return Ne&&er?m.apply(this,it):(De=this.thru(Vt),Ne?N?De.value()[0]:De.value():De)})}),ql(["pop","push","shift","sort","splice","unshift"],function(m){var v=q6[m],T=/^(?:push|sort|unshift)$/.test(m)?"tap":"thru",N=/^(?:pop|shift)$/.test(m);G.prototype[m]=function(){var V=arguments;if(N&&!this.__chain__){var Y=this.value();return v.apply($e(Y)?Y:[],V)}return this[T](function(J){return v.apply($e(J)?J:[],V)})}}),mh(gr.prototype,function(m,v){var T=G[v];if(T){var N=T.name+"";un.call(_x,N)||(_x[N]=[]),_x[N].push({name:v,func:T})}}),_x[uI(e,g).name]=[{name:"wrapper",func:e}],gr.prototype.clone=Cde,gr.prototype.reverse=Ade,gr.prototype.value=Pde,G.prototype.at=i0e,G.prototype.chain=o0e,G.prototype.commit=a0e,G.prototype.next=s0e,G.prototype.plant=c0e,G.prototype.reverse=u0e,G.prototype.toJSON=G.prototype.valueOf=G.prototype.value=h0e,G.prototype.first=G.prototype.head,EM&&(G.prototype[EM]=l0e),G},mm=ade();typeof define=="function"&&typeof define.amd=="object"&&define.amd?(fo._=mm,define(function(){return mm})):Q0?((Q0.exports=mm)._=mm,oq._=mm):fo._=mm}).call(Rx)});function f_t(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r||/[\s.]/.test(n))throw new Error("illegal type: "+n);r[n]=[]}return new Z9(r)}function Z9(e){this._=e}function h2e(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function f2e(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function h_t(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=u2e,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var u2e,vs,p_t=M(()=>{u2e={value:function(){}};Z9.prototype=f_t.prototype={constructor:Z9,on:function(e,t){var r=this._,n=h2e(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=f2e(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=h_t(r[i],e.name,t);else if(t==null)for(i in r)r[i]=h_t(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new Z9(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};vs=f_t});var km=M(()=>{p_t()});function yY(e){return+e}var w1t=M(()=>{});function vY(e){return e*e}function xY(e){return e*(2-e)}function PL(e){return((e*=2)<=1?e*e:--e*(2-e)+1)/2}var S1t=M(()=>{});function bY(e){return e*e*e}function wY(e){return--e*e*e+1}function xs(e){return((e*=2)<=1?e*e*e:(e-=2)*e*e+2)/2}var M1t=M(()=>{});var SY,MY,EY,IL,E1t=M(()=>{SY=3,MY=function e(t){t=+t;function r(n){return Math.pow(n,t)}return r.exponent=e,r}(SY),EY=function e(t){t=+t;function r(n){return 1-Math.pow(1-n,t)}return r.exponent=e,r}(SY),IL=function e(t){t=+t;function r(n){return((n*=2)<=1?Math.pow(n,t):2-Math.pow(2-n,t))/2}return r.exponent=e,r}(SY)});function TY(e){return+e==1?1:1-Math.cos(e*C1t)}function CY(e){return Math.sin(e*C1t)}function LL(e){return(1-Math.cos(T1t*e))/2}var T1t,C1t,A1t=M(()=>{T1t=Math.PI,C1t=T1t/2});function Dh(e){return(Math.pow(2,-10*e)-.0009765625)*1.0009775171065494}var AY=M(()=>{});function PY(e){return Dh(1-+e)}function IY(e){return 1-Dh(e)}function kL(e){return((e*=2)<=1?Dh(1-e):2-Dh(e-1))/2}var P1t=M(()=>{AY()});function LY(e){return 1-Math.sqrt(1-e*e)}function kY(e){return Math.sqrt(1- --e*e)}function RL(e){return((e*=2)<=1?1-Math.sqrt(1-e*e):Math.sqrt(1-(e-=2)*e)+1)/2}var I1t=M(()=>{});function NY(e){return 1-P_(1-e)}function P_(e){return(e=+e)<RY?NL*e*e:e<oSe?NL*(e-=iSe)*e+aSe:e<lSe?NL*(e-=sSe)*e+cSe:NL*(e-=uSe)*e+hSe}function DY(e){return((e*=2)<=1?1-P_(1-e):P_(e-1)+1)/2}var RY,iSe,oSe,aSe,sSe,lSe,cSe,uSe,hSe,NL,L1t=M(()=>{RY=.36363636363636365,iSe=6/11,oSe=8/11,aSe=3/4,sSe=9/11,lSe=10/11,cSe=15/16,uSe=21/22,hSe=63/64,NL=1/RY/RY});var OY,zY,FY,DL,k1t=M(()=>{OY=1.70158,zY=function e(t){t=+t;function r(n){return(n=+n)*n*(t*(n-1)+n)}return r.overshoot=e,r}(OY),FY=function e(t){t=+t;function r(n){return--n*n*((n+1)*t+n)+1}return r.overshoot=e,r}(OY),DL=function e(t){t=+t;function r(n){return((n*=2)<1?n*n*((t+1)*n-t):(n-=2)*n*((t+1)*n+t)+2)/2}return r.overshoot=e,r}(OY)});var Sb,BY,HY,VY,OL,UY,R1t=M(()=>{AY();Sb=2*Math.PI,BY=1,HY=.3,VY=function e(t,r){var n=Math.asin(1/(t=Math.max(1,t)))*(r/=Sb);function i(o){return t*Dh(- --o)*Math.sin((n-o)/r)}return i.amplitude=function(o){return e(o,r*Sb)},i.period=function(o){return e(t,o)},i}(BY,HY),OL=function e(t,r){var n=Math.asin(1/(t=Math.max(1,t)))*(r/=Sb);function i(o){return 1-t*Dh(o=+o)*Math.sin((o+n)/r)}return i.amplitude=function(o){return e(o,r*Sb)},i.period=function(o){return e(t,o)},i}(BY,HY),UY=function e(t,r){var n=Math.asin(1/(t=Math.max(1,t)))*(r/=Sb);function i(o){return((o=o*2-1)<0?t*Dh(-o)*Math.sin((n-o)/r):2-t*Dh(o)*Math.sin((n+o)/r))/2}return i.amplitude=function(o){return e(o,r*Sb)},i.period=function(o){return e(t,o)},i}(BY,HY)});var N1t={};Ks(N1t,{easeBack:()=>DL,easeBackIn:()=>zY,easeBackInOut:()=>DL,easeBackOut:()=>FY,easeBounce:()=>P_,easeBounceIn:()=>NY,easeBounceInOut:()=>DY,easeBounceOut:()=>P_,easeCircle:()=>RL,easeCircleIn:()=>LY,easeCircleInOut:()=>RL,easeCircleOut:()=>kY,easeCubic:()=>xs,easeCubicIn:()=>bY,easeCubicInOut:()=>xs,easeCubicOut:()=>wY,easeElastic:()=>OL,easeElasticIn:()=>VY,easeElasticInOut:()=>UY,easeElasticOut:()=>OL,easeExp:()=>kL,easeExpIn:()=>PY,easeExpInOut:()=>kL,easeExpOut:()=>IY,easeLinear:()=>yY,easePoly:()=>IL,easePolyIn:()=>MY,easePolyInOut:()=>IL,easePolyOut:()=>EY,easeQuad:()=>PL,easeQuadIn:()=>vY,easeQuadInOut:()=>PL,easeQuadOut:()=>xY,easeSin:()=>LL,easeSinIn:()=>TY,easeSinInOut:()=>LL,easeSinOut:()=>CY});var I_=M(()=>{w1t();S1t();M1t();E1t();A1t();P1t();I1t();L1t();k1t();R1t()});function WL(){}function X1t(e,t){var r=new WL;if(e instanceof WL)e.each(function(s,l){r.set(l,s)});else if(Array.isArray(e)){var n=-1,i=e.length,o;if(t==null)for(;++n<i;)r.set(n,e[n]);else for(;++n<i;)r.set(t(o=e[n],n,e),o)}else if(e)for(var a in e)r.set(a,e[a]);return r}var el,Ji,YL=M(()=>{el="$";WL.prototype=X1t.prototype={constructor:WL,has:function(e){return el+e in this},get:function(e){return this[el+e]},set:function(e,t){return this[el+e]=t,this},remove:function(e){var t=el+e;return t in this&&delete this[t]},clear:function(){for(var e in this)e[0]===el&&delete this[e]},keys:function(){var e=[];for(var t in this)t[0]===el&&e.push(t.slice(1));return e},values:function(){var e=[];for(var t in this)t[0]===el&&e.push(this[t]);return e},entries:function(){var e=[];for(var t in this)t[0]===el&&e.push({key:t.slice(1),value:this[t]});return e},size:function(){var e=0;for(var t in this)t[0]===el&&++e;return e},empty:function(){for(var e in this)if(e[0]===el)return!1;return!0},each:function(e){for(var t in this)t[0]===el&&e(this[t],t.slice(1),this)}};Ji=X1t});function Z1t(){var e=[],t=[],r,n,i;function o(s,l,c,u){if(l>=e.length)return r!=null&&s.sort(r),n!=null?n(s):s;for(var h=-1,f=s.length,p=e[l++],d,g,_=Ji(),y,x=c();++h<f;)(y=_.get(d=p(g=s[h])+""))?y.push(g):_.set(d,[g]);return _.each(function(b,S){u(x,S,o(b,l,c,u))}),x}function a(s,l){if(++l>e.length)return s;var c,u=t[l-1];return n!=null&&l>=e.length?c=s.entries():(c=[],s.each(function(h,f){c.push({key:f,values:a(h,l)})})),u!=null?c.sort(function(h,f){return u(h.key,f.key)}):c}return i={object:function(s){return o(s,0,PSe,ISe)},map:function(s){return o(s,0,$1t,K1t)},entries:function(s){return a(o(s,0,$1t,K1t),0)},key:function(s){return e.push(s),i},sortKeys:function(s){return t[e.length-1]=s,i},sortValues:function(s){return r=s,i},rollup:function(s){return n=s,i}}}function PSe(){return{}}function ISe(e,t,r){e[t]=r}function $1t(){return Ji()}function K1t(e,t,r){e.set(t,r)}var J1t=M(()=>{YL()});function jL(){}function Q1t(e,t){var r=new jL;if(e instanceof jL)e.each(function(o){r.add(o)});else if(e){var n=-1,i=e.length;if(t==null)for(;++n<i;)r.add(e[n]);else for(;++n<i;)r.add(t(e[n],n,e))}return r}var k_,tvt,evt=M(()=>{YL();k_=Ji.prototype;jL.prototype=Q1t.prototype={constructor:jL,has:k_.has,add:function(e){return e+="",this[el+e]=e,this},remove:k_.remove,clear:k_.clear,values:k_.keys,size:k_.size,empty:k_.empty,each:k_.each};tvt=Q1t});function XL(e){var t=[];for(var r in e)t.push(r);return t}var rvt=M(()=>{});function nvt(e){var t=[];for(var r in e)t.push(e[r]);return t}var ivt=M(()=>{});function ovt(e){var t=[];for(var r in e)t.push({key:r,value:e[r]});return t}var avt=M(()=>{});var Tb=M(()=>{J1t();evt();YL();rvt();ivt();avt()});function dvt(e){return new Function("d","return {"+e.map(function(t,r){return JSON.stringify(t)+": d["+r+'] || ""'}).join(",")+"}")}function BSe(e,t){var r=dvt(e);return function(n,i){return t(r(n),i,e)}}function pvt(e){var t=Object.create(null),r=[];return e.forEach(function(n){for(var i in n)i in t||r.push(t[i]=i)}),r}function ws(e,t){var r=e+"",n=r.length;return n<t?new Array(t-n+1).join(0)+r:r}function HSe(e){return e<0?"-"+ws(-e,6):e>9999?"+"+ws(e,6):ws(e,4)}function VSe(e){var t=e.getUTCHours(),r=e.getUTCMinutes(),n=e.getUTCSeconds(),i=e.getUTCMilliseconds();return isNaN(e)?"Invalid Date":HSe(e.getUTCFullYear(),4)+"-"+ws(e.getUTCMonth()+1,2)+"-"+ws(e.getUTCDate(),2)+(i?"T"+ws(t,2)+":"+ws(r,2)+":"+ws(n,2)+"."+ws(i,3)+"Z":n?"T"+ws(t,2)+":"+ws(r,2)+":"+ws(n,2)+"Z":r||t?"T"+ws(t,2)+":"+ws(r,2)+"Z":"")}function Wm(e){var t=new RegExp('["'+e+`
\r]`),r=e.charCodeAt(0);function n(h,f){var p,d,g=i(h,function(_,y){if(p)return p(_,y-1);d=_,p=f?BSe(_,f):dvt(_)});return g.columns=d||[],g}function i(h,f){var p=[],d=h.length,g=0,_=0,y,x=d<=0,b=!1;h.charCodeAt(d-1)===VE&&--d,h.charCodeAt(d-1)===ij&&--d;function S(){if(x)return rj;if(b)return b=!1,fvt;var P,k=g,O;if(h.charCodeAt(k)===nj){for(;g++<d&&h.charCodeAt(g)!==nj||h.charCodeAt(++g)===nj;);return(P=g)>=d?x=!0:(O=h.charCodeAt(g++))===VE?b=!0:O===ij&&(b=!0,h.charCodeAt(g)===VE&&++g),h.slice(k+1,P-1).replace(/""/g,'"')}for(;g<d;){if((O=h.charCodeAt(P=g++))===VE)b=!0;else if(O===ij)b=!0,h.charCodeAt(g)===VE&&++g;else if(O!==r)continue;return h.slice(k,P)}return x=!0,h.slice(k,d)}for(;(y=S())!==rj;){for(var C=[];y!==fvt&&y!==rj;)C.push(y),y=S();f&&(C=f(C,_++))==null||p.push(C)}return p}function o(h,f){return h.map(function(p){return f.map(function(d){return u(p[d])}).join(e)})}function a(h,f){return f==null&&(f=pvt(h)),[f.map(u).join(e)].concat(o(h,f)).join(`
`)}function s(h,f){return f==null&&(f=pvt(h)),o(h,f).join(`
`)}function l(h){return h.map(c).join(`
`)}function c(h){return h.map(u).join(e)}function u(h){return h==null?"":h instanceof Date?VSe(h):t.test(h+="")?'"'+h.replace(/"/g,'""')+'"':h}return{parse:n,parseRows:i,format:a,formatBody:s,formatRows:l,formatRow:c,formatValue:u}}var fvt,rj,nj,VE,ij,QL=M(()=>{fvt={},rj={},nj=34,VE=10,ij=13});var R_,Cb,mvt,gvt,_vt,yvt,vvt,xvt,bvt=M(()=>{QL();R_=Wm(","),Cb=R_.parse,mvt=R_.parseRows,gvt=R_.format,_vt=R_.formatBody,yvt=R_.formatRows,vvt=R_.formatRow,xvt=R_.formatValue});var N_,Ab,wvt,Svt,Mvt,Evt,Tvt,Cvt,Avt=M(()=>{QL();N_=Wm("	"),Ab=N_.parse,wvt=N_.parseRows,Svt=N_.format,Mvt=N_.formatBody,Evt=N_.formatRows,Tvt=N_.formatRow,Cvt=N_.formatValue});function oj(e){for(var t in e){var r=e[t].trim(),n,i;if(!r)r=null;else if(r==="true")r=!0;else if(r==="false")r=!1;else if(r==="NaN")r=NaN;else if(!isNaN(n=+r))r=n;else if(i=r.match(/^([-+]\d{2})?\d{4}(-\d{2}(-\d{2})?)?(T\d{2}:\d{2}(:\d{2}(\.\d{3})?)?(Z|[-+]\d{2}:\d{2})?)?$/))USe&&!!i[4]&&!i[7]&&(r=r.replace(/-/g,"/").replace(/T/," ")),r=new Date(r);else continue;e[t]=r}return e}var USe,Pvt=M(()=>{USe=new Date("2019-01-01T00:00").getHours()||new Date("2019-07-01T00:00").getHours()});var UE=M(()=>{QL();bvt();Avt();Pvt()});var pe={};Ks(pe,{__assign:()=>p5e,__asyncDelegator:()=>S5e,__asyncGenerator:()=>w5e,__asyncValues:()=>M5e,__await:()=>V5,__awaiter:()=>y5e,__decorate:()=>m5e,__exportStar:()=>x5e,__extends:()=>f5e,__generator:()=>v5e,__makeTemplateObject:()=>E5e,__metadata:()=>_5e,__param:()=>g5e,__read:()=>J3t,__rest:()=>d5e,__spread:()=>b5e,__values:()=>v$});function f5e(e,t){h5e(e,t);function r(){this.constructor=e}e.prototype=t===null?Object.create(t):(r.prototype=t.prototype,new r)}function d5e(e,t){var r={};for(var n in e)Object.prototype.hasOwnProperty.call(e,n)&&t.indexOf(n)<0&&(r[n]=e[n]);if(e!=null&&typeof Object.getOwnPropertySymbols=="function")for(var i=0,n=Object.getOwnPropertySymbols(e);i<n.length;i++)t.indexOf(n[i])<0&&(r[n[i]]=e[n[i]]);return r}function m5e(e,t,r,n){var i=arguments.length,o=i<3?t:n===null?n=Object.getOwnPropertyDescriptor(t,r):n,a;if(typeof Reflect=="object"&&typeof Reflect.decorate=="function")o=Reflect.decorate(e,t,r,n);else for(var s=e.length-1;s>=0;s--)(a=e[s])&&(o=(i<3?a(o):i>3?a(t,r,o):a(t,r))||o);return i>3&&o&&Object.defineProperty(t,r,o),o}function g5e(e,t){return function(r,n){t(r,n,e)}}function _5e(e,t){if(typeof Reflect=="object"&&typeof Reflect.metadata=="function")return Reflect.metadata(e,t)}function y5e(e,t,r,n){return new(r||(r=Promise))(function(i,o){function a(c){try{l(n.next(c))}catch(u){o(u)}}function s(c){try{l(n.throw(c))}catch(u){o(u)}}function l(c){c.done?i(c.value):new r(function(u){u(c.value)}).then(a,s)}l((n=n.apply(e,t||[])).next())})}function v5e(e,t){var r={label:0,sent:function(){if(o[0]&1)throw o[1];return o[1]},trys:[],ops:[]},n,i,o,a;return a={next:s(0),throw:s(1),return:s(2)},typeof Symbol=="function"&&(a[Symbol.iterator]=function(){return this}),a;function s(c){return function(u){return l([c,u])}}function l(c){if(n)throw new TypeError("Generator is already executing.");for(;r;)try{if(n=1,i&&(o=i[c[0]&2?"return":c[0]?"throw":"next"])&&!(o=o.call(i,c[1])).done)return o;switch(i=0,o&&(c=[0,o.value]),c[0]){case 0:case 1:o=c;break;case 4:return r.label++,{value:c[1],done:!1};case 5:r.label++,i=c[1],c=[0];continue;case 7:c=r.ops.pop(),r.trys.pop();continue;default:if(o=r.trys,!(o=o.length>0&&o[o.length-1])&&(c[0]===6||c[0]===2)){r=0;continue}if(c[0]===3&&(!o||c[1]>o[0]&&c[1]<o[3])){r.label=c[1];break}if(c[0]===6&&r.label<o[1]){r.label=o[1],o=c;break}if(o&&r.label<o[2]){r.label=o[2],r.ops.push(c);break}o[2]&&r.ops.pop(),r.trys.pop();continue}c=t.call(e,r)}catch(u){c=[6,u],i=0}finally{n=o=0}if(c[0]&5)throw c[1];return{value:c[0]?c[1]:void 0,done:!0}}}function x5e(e,t){for(var r in e)t.hasOwnProperty(r)||(t[r]=e[r])}function v$(e){var t=typeof Symbol=="function"&&e[Symbol.iterator],r=0;return t?t.call(e):{next:function(){return e&&r>=e.length&&(e=void 0),{value:e&&e[r++],done:!e}}}}function J3t(e,t){var r=typeof Symbol=="function"&&e[Symbol.iterator];if(!r)return e;var n=r.call(e),i,o=[],a;try{for(;(t===void 0||t-- >0)&&!(i=n.next()).done;)o.push(i.value)}catch(s){a={error:s}}finally{try{i&&!i.done&&(r=n.return)&&r.call(n)}finally{if(a)throw a.error}}return o}function b5e(){for(var e=[],t=0;t<arguments.length;t++)e=e.concat(J3t(arguments[t]));return e}function V5(e){return this instanceof V5?(this.v=e,this):new V5(e)}function w5e(e,t,r){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var n=r.apply(e,t||[]),i,o=[];return i={},a("next"),a("throw"),a("return"),i[Symbol.asyncIterator]=function(){return this},i;function a(f){n[f]&&(i[f]=function(p){return new Promise(function(d,g){o.push([f,p,d,g])>1||s(f,p)})})}function s(f,p){try{l(n[f](p))}catch(d){h(o[0][3],d)}}function l(f){f.value instanceof V5?Promise.resolve(f.value.v).then(c,u):h(o[0][2],f)}function c(f){s("next",f)}function u(f){s("throw",f)}function h(f,p){f(p),o.shift(),o.length&&s(o[0][0],o[0][1])}}function S5e(e){var t,r;return t={},n("next"),n("throw",function(i){throw i}),n("return"),t[Symbol.iterator]=function(){return this},t;function n(i,o){e[i]&&(t[i]=function(a){return(r=!r)?{value:V5(e[i](a)),done:i==="return"}:o?o(a):a})}}function M5e(e){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var t=e[Symbol.asyncIterator];return t?t.call(e):typeof v$=="function"?v$(e):e[Symbol.iterator]()}function E5e(e,t){return Object.defineProperty?Object.defineProperty(e,"raw",{value:t}):e.raw=t,e}var h5e,p5e,de=M(()=>{h5e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])};p5e=Object.assign||function(t){for(var r,n=1,i=arguments.length;n<i;n++){r=arguments[n];for(var o in r)Object.prototype.hasOwnProperty.call(r,o)&&(t[o]=r[o])}return t}});var Q3t,tMt=M(()=>{Q3t="4.13.0"});function _c(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var py=M(()=>{});function oR(e){return e.length===1&&(e=T5e(e)),{left:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)<0?n=o+1:i=o}return n},right:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)>0?i=o:n=o+1}return n}}}function T5e(e){return function(t,r){return _c(e(t),r)}}var x$=M(()=>{py()});var eMt,b$,rMt,aR,w$=M(()=>{py();x$();eMt=oR(_c),b$=eMt.right,rMt=eMt.left,aR=b$});function nMt(e,t){t==null&&(t=S$);for(var r=0,n=e.length-1,i=e[0],o=new Array(n<0?0:n);r<n;)o[r]=t(i,i=e[++r]);return o}function S$(e,t){return[e,t]}var M$=M(()=>{});function iMt(e,t,r){var n=e.length,i=t.length,o=new Array(n*i),a,s,l,c;for(r==null&&(r=S$),a=l=0;a<n;++a)for(c=e[a],s=0;s<i;++s,++l)o[l]=r(c,t[s]);return o}var oMt=M(()=>{M$()});function aMt(e,t){return t<e?-1:t>e?1:t>=e?0:NaN}var sMt=M(()=>{});function al(e){return e===null?NaN:+e}var l2=M(()=>{});function sR(e,t){var r=e.length,n=0,i=-1,o=0,a,s,l=0;if(t==null)for(;++i<r;)isNaN(a=al(e[i]))||(s=a-o,o+=s/++n,l+=s*(a-o));else for(;++i<r;)isNaN(a=al(t(e[i],i,e)))||(s=a-o,o+=s/++n,l+=s*(a-o));if(n>1)return l/(n-1)}var E$=M(()=>{l2()});function lR(e,t){var r=sR(e,t);return r&&Math.sqrt(r)}var T$=M(()=>{E$()});function cR(e,t){var r=e.length,n=-1,i,o,a;if(t==null){for(;++n<r;)if((i=e[n])!=null&&i>=i)for(o=a=i;++n<r;)(i=e[n])!=null&&(o>i&&(o=i),a<i&&(a=i))}else for(;++n<r;)if((i=t(e[n],n,e))!=null&&i>=i)for(o=a=i;++n<r;)(i=t(e[n],n,e))!=null&&(o>i&&(o=i),a<i&&(a=i));return[o,a]}var C$=M(()=>{});var lMt,cMt,uMt,A$=M(()=>{lMt=Array.prototype,cMt=lMt.slice,uMt=lMt.map});function U5(e){return function(){return e}}var hMt=M(()=>{});function fMt(e){return e}var pMt=M(()=>{});function uR(e,t,r){e=+e,t=+t,r=(i=arguments.length)<2?(t=e,e=0,1):i<3?1:+r;for(var n=-1,i=Math.max(0,Math.ceil((t-e)/r))|0,o=new Array(i);++n<i;)o[n]=e+n*r;return o}var P$=M(()=>{});function dMt(e,t,r){var n,i=-1,o,a,s;if(t=+t,e=+e,r=+r,e===t&&r>0)return[e];if((n=t<e)&&(o=e,e=t,t=o),(s=R$(e,t,r))===0||!isFinite(s))return[];if(s>0)for(e=Math.ceil(e/s),t=Math.floor(t/s),a=new Array(o=Math.ceil(t-e+1));++i<o;)a[i]=(e+i)*s;else for(e=Math.floor(e*s),t=Math.ceil(t*s),a=new Array(o=Math.ceil(e-t+1));++i<o;)a[i]=(e-i)/s;return n&&a.reverse(),a}function R$(e,t,r){var n=(t-e)/Math.max(0,r),i=Math.floor(Math.log(n)/Math.LN10),o=n/Math.pow(10,i);return i>=0?(o>=I$?10:o>=L$?5:o>=k$?2:1)*Math.pow(10,i):-Math.pow(10,-i)/(o>=I$?10:o>=L$?5:o>=k$?2:1)}function hR(e,t,r){var n=Math.abs(t-e)/Math.max(0,r),i=Math.pow(10,Math.floor(Math.log(n)/Math.LN10)),o=n/i;return o>=I$?i*=10:o>=L$?i*=5:o>=k$&&(i*=2),t<e?-i:i}var I$,L$,k$,N$=M(()=>{I$=Math.sqrt(50),L$=Math.sqrt(10),k$=Math.sqrt(2)});function fR(e){return Math.ceil(Math.log(e.length)/Math.LN2)+1}var D$=M(()=>{});function mMt(){var e=fMt,t=cR,r=fR;function n(i){var o,a=i.length,s,l=new Array(a);for(o=0;o<a;++o)l[o]=e(i[o],o,i);var c=t(l),u=c[0],h=c[1],f=r(l,u,h);Array.isArray(f)||(f=hR(u,h,f),f=uR(Math.ceil(u/f)*f,Math.floor(h/f)*f,f));for(var p=f.length;f[0]<=u;)f.shift(),--p;for(;f[p-1]>h;)f.pop(),--p;var d=new Array(p+1),g;for(o=0;o<=p;++o)g=d[o]=[],g.x0=o>0?f[o-1]:u,g.x1=o<p?f[o]:h;for(o=0;o<a;++o)s=l[o],u<=s&&s<=h&&d[aR(f,s,0,p)].push(i[o]);return d}return n.value=function(i){return arguments.length?(e=typeof i=="function"?i:U5(i),n):e},n.domain=function(i){return arguments.length?(t=typeof i=="function"?i:U5([i[0],i[1]]),n):t},n.thresholds=function(i){return arguments.length?(r=typeof i=="function"?i:Array.isArray(i)?U5(cMt.call(i)):U5(i),n):r},n}var gMt=M(()=>{A$();w$();hMt();C$();pMt();P$();N$();D$()});function dy(e,t,r){if(r==null&&(r=al),!!(n=e.length)){if((t=+t)<=0||n<2)return+r(e[0],0,e);if(t>=1)return+r(e[n-1],n-1,e);var n,i=(n-1)*t,o=Math.floor(i),a=+r(e[o],o,e),s=+r(e[o+1],o+1,e);return a+(s-a)*(i-o)}}var pR=M(()=>{l2()});function _Mt(e,t,r){return e=uMt.call(e,al).sort(_c),Math.ceil((r-t)/(2*(dy(e,.75)-dy(e,.25))*Math.pow(e.length,-1/3)))}var yMt=M(()=>{A$();py();l2();pR()});function vMt(e,t,r){return Math.ceil((r-t)/(3.5*lR(e)*Math.pow(e.length,-1/3)))}var xMt=M(()=>{T$()});function bMt(e,t){var r=e.length,n=-1,i,o;if(t==null){for(;++n<r;)if((i=e[n])!=null&&i>=i)for(o=i;++n<r;)(i=e[n])!=null&&i>o&&(o=i)}else for(;++n<r;)if((i=t(e[n],n,e))!=null&&i>=i)for(o=i;++n<r;)(i=t(e[n],n,e))!=null&&i>o&&(o=i);return o}var wMt=M(()=>{});function SMt(e,t){var r=e.length,n=r,i=-1,o,a=0;if(t==null)for(;++i<r;)isNaN(o=al(e[i]))?--n:a+=o;else for(;++i<r;)isNaN(o=al(t(e[i],i,e)))?--n:a+=o;if(n)return a/n}var MMt=M(()=>{l2()});function EMt(e,t){var r=e.length,n=-1,i,o=[];if(t==null)for(;++n<r;)isNaN(i=al(e[n]))||o.push(i);else for(;++n<r;)isNaN(i=al(t(e[n],n,e)))||o.push(i);return dy(o.sort(_c),.5)}var TMt=M(()=>{py();l2();pR()});function CMt(e){for(var t=e.length,r,n=-1,i=0,o,a;++n<t;)i+=e[n].length;for(o=new Array(i);--t>=0;)for(a=e[t],r=a.length;--r>=0;)o[--i]=a[r];return o}var AMt=M(()=>{});function dR(e,t){var r=e.length,n=-1,i,o;if(t==null){for(;++n<r;)if((i=e[n])!=null&&i>=i)for(o=i;++n<r;)(i=e[n])!=null&&o>i&&(o=i)}else for(;++n<r;)if((i=t(e[n],n,e))!=null&&i>=i)for(o=i;++n<r;)(i=t(e[n],n,e))!=null&&o>i&&(o=i);return o}var O$=M(()=>{});function PMt(e,t){for(var r=t.length,n=new Array(r);r--;)n[r]=e[t[r]];return n}var IMt=M(()=>{});function LMt(e,t){if(!!(r=e.length)){var r,n=0,i=0,o,a=e[i];for(t==null&&(t=_c);++n<r;)(t(o=e[n],a)<0||t(a,a)!==0)&&(a=o,i=n);if(t(a,a)===0)return i}}var kMt=M(()=>{py()});function RMt(e,t,r){for(var n=(r==null?e.length:r)-(t=t==null?0:+t),i,o;n;)o=Math.random()*n--|0,i=e[n+t],e[n+t]=e[o+t],e[o+t]=i;return e}var NMt=M(()=>{});function DMt(e,t){var r=e.length,n=-1,i,o=0;if(t==null)for(;++n<r;)(i=+e[n])&&(o+=i);else for(;++n<r;)(i=+t(e[n],n,e))&&(o+=i);return o}var OMt=M(()=>{});function mR(e){if(!(o=e.length))return[];for(var t=-1,r=dR(e,C5e),n=new Array(r);++t<r;)for(var i=-1,o,a=n[t]=new Array(o);++i<o;)a[i]=e[i][t];return n}function C5e(e){return e.length}var z$=M(()=>{O$()});function zMt(){return mR(arguments)}var FMt=M(()=>{z$()});var BMt=M(()=>{w$();py();x$();oMt();sMt();T$();C$();gMt();yMt();xMt();D$();wMt();MMt();TMt();AMt();O$();M$();IMt();pR();P$();kMt();NMt();OMt();N$();z$();E$();FMt()});var gR,HMt=M(()=>{gR=Array.prototype.slice});function VMt(e){return e}var UMt=M(()=>{});function A5e(e){return"translate("+(e+.5)+",0)"}function P5e(e){return"translate(0,"+(e+.5)+")"}function I5e(e){return function(t){return+e(t)}}function L5e(e){var t=Math.max(0,e.bandwidth()-1)/2;return e.round()&&(t=Math.round(t)),function(r){return+e(r)+t}}function k5e(){return!this.__axis}function vR(e,t){var r=[],n=null,i=null,o=6,a=6,s=3,l=e===_R||e===q5?-1:1,c=e===q5||e===yR?"x":"y",u=e===_R||e===F$?A5e:P5e;function h(f){var p=n==null?t.ticks?t.ticks.apply(t,r):t.domain():n,d=i==null?t.tickFormat?t.tickFormat.apply(t,r):VMt:i,g=Math.max(o,0)+s,_=t.range(),y=+_[0]+.5,x=+_[_.length-1]+.5,b=(t.bandwidth?L5e:I5e)(t.copy()),S=f.selection?f.selection():f,C=S.selectAll(".domain").data([null]),P=S.selectAll(".tick").data(p,t).order(),k=P.exit(),O=P.enter().append("g").attr("class","tick"),D=P.select("line"),B=P.select("text");C=C.merge(C.enter().insert("path",".tick").attr("class","domain").attr("stroke","#000")),P=P.merge(O),D=D.merge(O.append("line").attr("stroke","#000").attr(c+"2",l*o)),B=B.merge(O.append("text").attr("fill","#000").attr(c,l*g).attr("dy",e===_R?"0em":e===F$?"0.71em":"0.32em")),f!==S&&(C=C.transition(f),P=P.transition(f),D=D.transition(f),B=B.transition(f),k=k.transition(f).attr("opacity",qMt).attr("transform",function(I){return isFinite(I=b(I))?u(I):this.getAttribute("transform")}),O.attr("opacity",qMt).attr("transform",function(I){var L=this.parentNode.__axis;return u(L&&isFinite(L=L(I))?L:b(I))})),k.remove(),C.attr("d",e===q5||e==yR?"M"+l*a+","+y+"H0.5V"+x+"H"+l*a:"M"+y+","+l*a+"V0.5H"+x+"V"+l*a),P.attr("opacity",1).attr("transform",function(I){return u(b(I))}),D.attr(c+"2",l*o),B.attr(c,l*g).text(d),S.filter(k5e).attr("fill","none").attr("font-size",10).attr("font-family","sans-serif").attr("text-anchor",e===yR?"start":e===q5?"end":"middle"),S.each(function(){this.__axis=b})}return h.scale=function(f){return arguments.length?(t=f,h):t},h.ticks=function(){return r=gR.call(arguments),h},h.tickArguments=function(f){return arguments.length?(r=f==null?[]:gR.call(f),h):r.slice()},h.tickValues=function(f){return arguments.length?(n=f==null?null:gR.call(f),h):n&&n.slice()},h.tickFormat=function(f){return arguments.length?(i=f,h):i},h.tickSize=function(f){return arguments.length?(o=a=+f,h):o},h.tickSizeInner=function(f){return arguments.length?(o=+f,h):o},h.tickSizeOuter=function(f){return arguments.length?(a=+f,h):a},h.tickPadding=function(f){return arguments.length?(s=+f,h):s},h}function GMt(e){return vR(_R,e)}function WMt(e){return vR(yR,e)}function YMt(e){return vR(F$,e)}function jMt(e){return vR(q5,e)}var _R,yR,F$,q5,qMt,XMt=M(()=>{HMt();UMt();_R=1,yR=2,F$=3,q5=4,qMt=1e-6});var $Mt=M(()=>{XMt()});function ZMt(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r||/[\s.]/.test(n))throw new Error("illegal type: "+n);r[n]=[]}return new xR(r)}function xR(e){this._=e}function N5e(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function D5e(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function KMt(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=R5e,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var R5e,G5,JMt=M(()=>{R5e={value:function(){}};xR.prototype=ZMt.prototype={constructor:xR,on:function(e,t){var r=this._,n=N5e(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=D5e(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=KMt(r[i],e.name,t);else if(t==null)for(i in r)r[i]=KMt(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new xR(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};G5=ZMt});var B$=M(()=>{JMt()});var bR,H$,V$=M(()=>{bR="http://www.w3.org/1999/xhtml",H$={svg:"http://www.w3.org/2000/svg",xhtml:bR,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"}});function Vp(e){var t=e+="",r=t.indexOf(":");return r>=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),H$.hasOwnProperty(t)?{space:H$[t],local:e}:e}var wR=M(()=>{V$()});function O5e(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===bR&&t.documentElement.namespaceURI===bR?t.createElement(e):t.createElementNS(r,e)}}function z5e(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function SR(e){var t=Vp(e);return(t.local?z5e:O5e)(t)}var U$=M(()=>{wR();V$()});function F5e(){}function my(e){return e==null?F5e:function(){return this.querySelector(e)}}var MR=M(()=>{});function QMt(e){typeof e!="function"&&(e=my(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=new Array(a),l,c,u=0;u<a;++u)(l=o[u])&&(c=e.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),s[u]=c);return new pi(n,this._parents)}var tEt=M(()=>{wu();MR()});function B5e(){return[]}function W5(e){return e==null?B5e:function(){return this.querySelectorAll(e)}}var q$=M(()=>{});function eEt(e){typeof e!="function"&&(e=W5(e));for(var t=this._groups,r=t.length,n=[],i=[],o=0;o<r;++o)for(var a=t[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&(n.push(e.call(l,l.__data__,c,a)),i.push(l));return new pi(n,i)}var rEt=M(()=>{wu();q$()});function Y5(e){return function(){return this.matches(e)}}var G$=M(()=>{});function nEt(e){typeof e!="function"&&(e=Y5(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new pi(n,this._parents)}var iEt=M(()=>{wu();G$()});function ER(e){return new Array(e.length)}var W$=M(()=>{});function oEt(){return new pi(this._enter||this._groups.map(ER),this._parents)}function j5(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}var Y$=M(()=>{W$();wu();j5.prototype={constructor:j5,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}}});function aEt(e){return function(){return e}}var sEt=M(()=>{});function H5e(e,t,r,n,i,o){for(var a=0,s,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],n[a]=s):r[a]=new j5(e,o[a]);for(;a<l;++a)(s=t[a])&&(i[a]=s)}function V5e(e,t,r,n,i,o,a){var s,l,c={},u=t.length,h=o.length,f=new Array(u),p;for(s=0;s<u;++s)(l=t[s])&&(f[s]=p=lEt+a.call(l,l.__data__,s,t),p in c?i[s]=l:c[p]=l);for(s=0;s<h;++s)p=lEt+a.call(e,o[s],s,o),(l=c[p])?(n[s]=l,l.__data__=o[s],c[p]=null):r[s]=new j5(e,o[s]);for(s=0;s<u;++s)(l=t[s])&&c[f[s]]===l&&(i[s]=l)}function cEt(e,t){if(!e)return p=new Array(this.size()),c=-1,this.each(function(P){p[++c]=P}),p;var r=t?V5e:H5e,n=this._parents,i=this._groups;typeof e!="function"&&(e=aEt(e));for(var o=i.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var u=n[c],h=i[c],f=h.length,p=e.call(u,u&&u.__data__,c,n),d=p.length,g=s[c]=new Array(d),_=a[c]=new Array(d),y=l[c]=new Array(f);r(u,h,g,_,y,p,t);for(var x=0,b=0,S,C;x<d;++x)if(S=g[x]){for(x>=b&&(b=x+1);!(C=_[b])&&++b<d;);S._next=C||null}}return a=new pi(a,n),a._enter=s,a._exit=l,a}var lEt,uEt=M(()=>{wu();Y$();sEt();lEt="$"});function hEt(){return new pi(this._exit||this._groups.map(ER),this._parents)}var fEt=M(()=>{W$();wu()});function pEt(e,t,r){var n=this.enter(),i=this,o=this.exit();return n=typeof e=="function"?e(n):n.append(e+""),t!=null&&(i=t(i)),r==null?o.remove():r(o),n&&i?n.merge(i).order():i}var dEt=M(()=>{});function mEt(e){for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new pi(a,this._parents)}var gEt=M(()=>{wu()});function _Et(){for(var e=this._groups,t=-1,r=e.length;++t<r;)for(var n=e[t],i=n.length-1,o=n[i],a;--i>=0;)(a=n[i])&&(o&&a.compareDocumentPosition(o)^4&&o.parentNode.insertBefore(a,o),o=a);return this}var yEt=M(()=>{});function vEt(e){e||(e=U5e);function t(h,f){return h&&f?e(h.__data__,f.__data__):!h-!f}for(var r=this._groups,n=r.length,i=new Array(n),o=0;o<n;++o){for(var a=r[o],s=a.length,l=i[o]=new Array(s),c,u=0;u<s;++u)(c=a[u])&&(l[u]=c);l.sort(t)}return new pi(i,this._parents).order()}function U5e(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var xEt=M(()=>{wu()});function bEt(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}var wEt=M(()=>{});function SEt(){var e=new Array(this.size()),t=-1;return this.each(function(){e[++t]=this}),e}var MEt=M(()=>{});function EEt(){for(var e=this._groups,t=0,r=e.length;t<r;++t)for(var n=e[t],i=0,o=n.length;i<o;++i){var a=n[i];if(a)return a}return null}var TEt=M(()=>{});function CEt(){var e=0;return this.each(function(){++e}),e}var AEt=M(()=>{});function PEt(){return!this.node()}var IEt=M(()=>{});function LEt(e){for(var t=this._groups,r=0,n=t.length;r<n;++r)for(var i=t[r],o=0,a=i.length,s;o<a;++o)(s=i[o])&&e.call(s,s.__data__,o,i);return this}var kEt=M(()=>{});function q5e(e){return function(){this.removeAttribute(e)}}function G5e(e){return function(){this.removeAttributeNS(e.space,e.local)}}function W5e(e,t){return function(){this.setAttribute(e,t)}}function Y5e(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function j5e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttribute(e):this.setAttribute(e,r)}}function X5e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,r)}}function REt(e,t){var r=Vp(e);if(arguments.length<2){var n=this.node();return r.local?n.getAttributeNS(r.space,r.local):n.getAttribute(r)}return this.each((t==null?r.local?G5e:q5e:typeof t=="function"?r.local?X5e:j5e:r.local?Y5e:W5e)(r,t))}var NEt=M(()=>{wR()});function TR(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}var j$=M(()=>{});function $5e(e){return function(){this.style.removeProperty(e)}}function K5e(e,t,r){return function(){this.style.setProperty(e,t,r)}}function Z5e(e,t,r){return function(){var n=t.apply(this,arguments);n==null?this.style.removeProperty(e):this.style.setProperty(e,n,r)}}function DEt(e,t,r){return arguments.length>1?this.each((t==null?$5e:typeof t=="function"?Z5e:K5e)(e,t,r==null?"":r)):ag(this.node(),e)}function ag(e,t){return e.style.getPropertyValue(t)||TR(e).getComputedStyle(e,null).getPropertyValue(t)}var X$=M(()=>{j$()});function J5e(e){return function(){delete this[e]}}function Q5e(e,t){return function(){this[e]=t}}function tTe(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function OEt(e,t){return arguments.length>1?this.each((t==null?J5e:typeof t=="function"?tTe:Q5e)(e,t)):this.node()[e]}var zEt=M(()=>{});function FEt(e){return e.trim().split(/^|\s+/)}function $$(e){return e.classList||new BEt(e)}function BEt(e){this._node=e,this._names=FEt(e.getAttribute("class")||"")}function HEt(e,t){for(var r=$$(e),n=-1,i=t.length;++n<i;)r.add(t[n])}function VEt(e,t){for(var r=$$(e),n=-1,i=t.length;++n<i;)r.remove(t[n])}function eTe(e){return function(){HEt(this,e)}}function rTe(e){return function(){VEt(this,e)}}function nTe(e,t){return function(){(t.apply(this,arguments)?HEt:VEt)(this,e)}}function UEt(e,t){var r=FEt(e+"");if(arguments.length<2){for(var n=$$(this.node()),i=-1,o=r.length;++i<o;)if(!n.contains(r[i]))return!1;return!0}return this.each((typeof t=="function"?nTe:t?eTe:rTe)(r,t))}var qEt=M(()=>{BEt.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}}});function iTe(){this.textContent=""}function oTe(e){return function(){this.textContent=e}}function aTe(e){return function(){var t=e.apply(this,arguments);this.textContent=t==null?"":t}}function GEt(e){return arguments.length?this.each(e==null?iTe:(typeof e=="function"?aTe:oTe)(e)):this.node().textContent}var WEt=M(()=>{});function sTe(){this.innerHTML=""}function lTe(e){return function(){this.innerHTML=e}}function cTe(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t==null?"":t}}function YEt(e){return arguments.length?this.each(e==null?sTe:(typeof e=="function"?cTe:lTe)(e)):this.node().innerHTML}var jEt=M(()=>{});function uTe(){this.nextSibling&&this.parentNode.appendChild(this)}function XEt(){return this.each(uTe)}var $Et=M(()=>{});function hTe(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function KEt(){return this.each(hTe)}var ZEt=M(()=>{});function JEt(e){var t=typeof e=="function"?e:SR(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}var QEt=M(()=>{U$()});function fTe(){return null}function t5t(e,t){var r=typeof e=="function"?e:SR(e),n=t==null?fTe:typeof t=="function"?t:my(t);return this.select(function(){return this.insertBefore(r.apply(this,arguments),n.apply(this,arguments)||null)})}var e5t=M(()=>{U$();MR()});function pTe(){var e=this.parentNode;e&&e.removeChild(this)}function r5t(){return this.each(pTe)}var n5t=M(()=>{});function dTe(){var e=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function mTe(){var e=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function i5t(e){return this.select(e?mTe:dTe)}var o5t=M(()=>{});function a5t(e){return arguments.length?this.property("__data__",e):this.node().__data__}var s5t=M(()=>{});function gTe(e,t,r){return e=u5t(e,t,r),function(n){var i=n.relatedTarget;(!i||i!==this&&!(i.compareDocumentPosition(this)&8))&&e.call(this,n)}}function u5t(e,t,r){return function(n){var i=wr;wr=n;try{e.call(this,this.__data__,t,r)}finally{wr=i}}}function _Te(e){return e.trim().split(/^|\s+/).map(function(t){var r="",n=t.indexOf(".");return n>=0&&(r=t.slice(n+1),t=t.slice(0,n)),{type:t,name:r}})}function yTe(e){return function(){var t=this.__on;if(!!t){for(var r=0,n=-1,i=t.length,o;r<i;++r)o=t[r],(!e.type||o.type===e.type)&&o.name===e.name?this.removeEventListener(o.type,o.listener,o.capture):t[++n]=o;++n?t.length=n:delete this.__on}}}function vTe(e,t,r){var n=c5t.hasOwnProperty(e.type)?gTe:u5t;return function(i,o,a){var s=this.__on,l,c=n(t,o,a);if(s){for(var u=0,h=s.length;u<h;++u)if((l=s[u]).type===e.type&&l.name===e.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=r),l.value=t;return}}this.addEventListener(e.type,c,r),l={type:e.type,name:e.name,value:t,listener:c,capture:r},s?s.push(l):this.__on=[l]}}function h5t(e,t,r){var n=_Te(e+""),i,o=n.length,a;if(arguments.length<2){var s=this.node().__on;if(s){for(var l=0,c=s.length,u;l<c;++l)for(i=0,u=s[l];i<o;++i)if((a=n[i]).type===u.type&&a.name===u.name)return u.value}return}for(s=t?vTe:yTe,r==null&&(r=!1),i=0;i<o;++i)this.each(s(n[i],t,r));return this}function K$(e,t,r,n){var i=wr;e.sourceEvent=wr,wr=e;try{return t.apply(r,n)}finally{wr=i}}var c5t,wr,l5t,CR=M(()=>{c5t={},wr=null;typeof document!="undefined"&&(l5t=document.documentElement,"onmouseenter"in l5t||(c5t={mouseenter:"mouseover",mouseleave:"mouseout"}))});function f5t(e,t,r){var n=TR(e),i=n.CustomEvent;typeof i=="function"?i=new i(t,r):(i=n.document.createEvent("Event"),r?(i.initEvent(t,r.bubbles,r.cancelable),i.detail=r.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function xTe(e,t){return function(){return f5t(this,e,t)}}function bTe(e,t){return function(){return f5t(this,e,t.apply(this,arguments))}}function p5t(e,t){return this.each((typeof t=="function"?bTe:xTe)(e,t))}var d5t=M(()=>{j$()});function pi(e,t){this._groups=e,this._parents=t}function m5t(){return new pi([[document.documentElement]],Z$)}var Z$,Up,wu=M(()=>{tEt();rEt();iEt();uEt();Y$();fEt();dEt();gEt();yEt();xEt();wEt();MEt();TEt();AEt();IEt();kEt();NEt();X$();zEt();qEt();WEt();jEt();$Et();ZEt();QEt();e5t();n5t();o5t();s5t();CR();d5t();Z$=[null];pi.prototype=m5t.prototype={constructor:pi,select:QMt,selectAll:eEt,filter:nEt,data:cEt,enter:oEt,exit:hEt,join:pEt,merge:mEt,order:_Et,sort:vEt,call:bEt,nodes:SEt,node:EEt,size:CEt,empty:PEt,each:LEt,attr:REt,style:DEt,property:OEt,classed:UEt,text:GEt,html:YEt,raise:XEt,lower:KEt,append:JEt,insert:t5t,remove:r5t,clone:i5t,datum:a5t,on:h5t,dispatch:p5t};Up=m5t});function qp(e){return typeof e=="string"?new pi([[document.querySelector(e)]],[document.documentElement]):new pi([[e]],Z$)}var g5t=M(()=>{wu()});function _5t(){for(var e=wr,t;t=e.sourceEvent;)e=t;return e}var y5t=M(()=>{CR()});function v5t(e,t){var r=e.ownerSVGElement||e;if(r.createSVGPoint){var n=r.createSVGPoint();return n.x=t.clientX,n.y=t.clientY,n=n.matrixTransform(e.getScreenCTM().inverse()),[n.x,n.y]}var i=e.getBoundingClientRect();return[t.clientX-i.left-e.clientLeft,t.clientY-i.top-e.clientTop]}var x5t=M(()=>{});function AR(e){var t=_5t();return t.changedTouches&&(t=t.changedTouches[0]),v5t(e,t)}var b5t=M(()=>{y5t();x5t()});var Es=M(()=>{G$();b5t();wR();g5t();wu();MR();q$();X$();CR()});function PR(){wr.preventDefault(),wr.stopImmediatePropagation()}var w5t=M(()=>{Es()});function J$(e){var t=e.document.documentElement,r=qp(e).on("dragstart.drag",PR,!0);"onselectstart"in t?r.on("selectstart.drag",PR,!0):(t.__noselect=t.style.MozUserSelect,t.style.MozUserSelect="none")}function Q$(e,t){var r=e.document.documentElement,n=qp(e).on("dragstart.drag",null);t&&(n.on("click.drag",PR,!0),setTimeout(function(){n.on("click.drag",null)},0)),"onselectstart"in r?n.on("selectstart.drag",null):(r.style.MozUserSelect=r.__noselect,delete r.__noselect)}var S5t=M(()=>{Es();w5t()});var M5t=M(()=>{S5t()});function IR(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function tK(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}var E5t=M(()=>{});function K5(){}function C5t(){return this.rgb().formatHex()}function PTe(){return R5t(this).formatHsl()}function A5t(){return this.rgb().formatRgb()}function Su(e){var t,r;return e=(e+"").trim().toLowerCase(),(t=wTe.exec(e))?(r=t[1].length,t=parseInt(t[1],16),r===6?P5t(t):r===3?new sl(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?LR(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?LR(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=STe.exec(e))?new sl(t[1],t[2],t[3],1):(t=MTe.exec(e))?new sl(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=ETe.exec(e))?LR(t[1],t[2],t[3],t[4]):(t=TTe.exec(e))?LR(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=CTe.exec(e))?k5t(t[1],t[2]/100,t[3]/100,1):(t=ATe.exec(e))?k5t(t[1],t[2]/100,t[3]/100,t[4]):T5t.hasOwnProperty(e)?P5t(T5t[e]):e==="transparent"?new sl(NaN,NaN,NaN,0):null}function P5t(e){return new sl(e>>16&255,e>>8&255,e&255,1)}function LR(e,t,r,n){return n<=0&&(e=t=r=NaN),new sl(e,t,r,n)}function ITe(e){return e instanceof K5||(e=Su(e)),e?(e=e.rgb(),new sl(e.r,e.g,e.b,e.opacity)):new sl}function u2(e,t,r,n){return arguments.length===1?ITe(e):new sl(e,t,r,n==null?1:n)}function sl(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}function I5t(){return"#"+eK(this.r)+eK(this.g)+eK(this.b)}function L5t(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}function eK(e){return e=Math.max(0,Math.min(255,Math.round(e)||0)),(e<16?"0":"")+e.toString(16)}function k5t(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new Kh(e,t,r,n)}function R5t(e){if(e instanceof Kh)return new Kh(e.h,e.s,e.l,e.opacity);if(e instanceof K5||(e=Su(e)),!e)return new Kh;if(e instanceof Kh)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new Kh(a,s,l,e.opacity)}function N5t(e,t,r,n){return arguments.length===1?R5t(e):new Kh(e,t,r,n==null?1:n)}function Kh(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}function rK(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var X5,kR,c2,$5,Zh,wTe,STe,MTe,ETe,TTe,CTe,ATe,T5t,D5t=M(()=>{E5t();X5=.7,kR=1/X5,c2="\\s*([+-]?\\d+)\\s*",$5="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",Zh="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",wTe=/^#([0-9a-f]{3,8})$/,STe=new RegExp("^rgb\\("+[c2,c2,c2]+"\\)$"),MTe=new RegExp("^rgb\\("+[Zh,Zh,Zh]+"\\)$"),ETe=new RegExp("^rgba\\("+[c2,c2,c2,$5]+"\\)$"),TTe=new RegExp("^rgba\\("+[Zh,Zh,Zh,$5]+"\\)$"),CTe=new RegExp("^hsl\\("+[$5,Zh,Zh]+"\\)$"),ATe=new RegExp("^hsla\\("+[$5,Zh,Zh,$5]+"\\)$"),T5t={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};IR(K5,Su,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:C5t,formatHex:C5t,formatHsl:PTe,formatRgb:A5t,toString:A5t});IR(sl,u2,tK(K5,{brighter:function(e){return e=e==null?kR:Math.pow(kR,e),new sl(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?X5:Math.pow(X5,e),new sl(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:I5t,formatHex:I5t,formatRgb:L5t,toString:L5t}));IR(Kh,N5t,tK(K5,{brighter:function(e){return e=e==null?kR:Math.pow(kR,e),new Kh(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?X5:Math.pow(X5,e),new Kh(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new sl(rK(e>=240?e-240:e+120,i,n),rK(e,i,n),rK(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(e===1?")":", "+e+")")}}))});var RR=M(()=>{D5t()});function nK(e,t,r,n,i){var o=e*e,a=o*e;return((1-3*e+3*o-a)*t+(4-6*o+3*a)*r+(1+3*e+3*o-3*a)*n+a*i)/6}function O5t(e){var t=e.length-1;return function(r){var n=r<=0?r=0:r>=1?(r=1,t-1):Math.floor(r*t),i=e[n],o=e[n+1],a=n>0?e[n-1]:2*i-o,s=n<t-1?e[n+2]:2*o-i;return nK((r-n/t)*t,a,i,o,s)}}var iK=M(()=>{});function z5t(e){var t=e.length;return function(r){var n=Math.floor(((r%=1)<0?++r:r)*t),i=e[(n+t-1)%t],o=e[n%t],a=e[(n+1)%t],s=e[(n+2)%t];return nK((r-n/t)*t,i,o,a,s)}}var F5t=M(()=>{iK()});function Z5(e){return function(){return e}}var oK=M(()=>{});function LTe(e,t){return function(r){return e+r*t}}function kTe(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function B5t(e){return(e=+e)==1?NR:function(t,r){return r-t?kTe(t,r,e):Z5(isNaN(t)?r:t)}}function NR(e,t){var r=t-e;return r?LTe(e,r):Z5(isNaN(e)?t:e)}var H5t=M(()=>{oK()});function V5t(e){return function(t){var r=t.length,n=new Array(r),i=new Array(r),o=new Array(r),a,s;for(a=0;a<r;++a)s=u2(t[a]),n[a]=s.r||0,i[a]=s.g||0,o[a]=s.b||0;return n=e(n),i=e(i),o=e(o),s.opacity=1,function(l){return s.r=n(l),s.g=i(l),s.b=o(l),s+""}}}var gy,RTe,NTe,aK=M(()=>{RR();iK();F5t();H5t();gy=function e(t){var r=B5t(t);function n(i,o){var a=r((i=u2(i)).r,(o=u2(o)).r),s=r(i.g,o.g),l=r(i.b,o.b),c=NR(i.opacity,o.opacity);return function(u){return i.r=a(u),i.g=s(u),i.b=l(u),i.opacity=c(u),i+""}}return n.gamma=e,n}(1);RTe=V5t(O5t),NTe=V5t(z5t)});function U5t(e,t){t||(t=[]);var r=e?Math.min(t.length,e.length):0,n=t.slice(),i;return function(o){for(i=0;i<r;++i)n[i]=e[i]*(1-o)+t[i]*o;return n}}function q5t(e){return ArrayBuffer.isView(e)&&!(e instanceof DataView)}var G5t=M(()=>{});function W5t(e,t){var r=t?t.length:0,n=e?Math.min(r,e.length):0,i=new Array(n),o=new Array(r),a;for(a=0;a<n;++a)i[a]=_y(e[a],t[a]);for(;a<r;++a)o[a]=t[a];return function(s){for(a=0;a<n;++a)o[a]=i[a](s);return o}}var Y5t=M(()=>{DR()});function j5t(e,t){var r=new Date;return e=+e,t=+t,function(n){return r.setTime(e*(1-n)+t*n),r}}var X5t=M(()=>{});function Ua(e,t){return e=+e,t=+t,function(r){return e*(1-r)+t*r}}var J5=M(()=>{});function $5t(e,t){var r={},n={},i;(e===null||typeof e!="object")&&(e={}),(t===null||typeof t!="object")&&(t={});for(i in t)i in e?r[i]=_y(e[i],t[i]):n[i]=t[i];return function(o){for(i in r)n[i]=r[i](o);return n}}var K5t=M(()=>{DR()});function DTe(e){return function(){return e}}function OTe(e){return function(t){return e(t)+""}}function Q5(e,t){var r=lK.lastIndex=sK.lastIndex=0,n,i,o,a=-1,s=[],l=[];for(e=e+"",t=t+"";(n=lK.exec(e))&&(i=sK.exec(t));)(o=i.index)>r&&(o=t.slice(r,o),s[a]?s[a]+=o:s[++a]=o),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:Ua(n,i)})),r=sK.lastIndex;return r<t.length&&(o=t.slice(r),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?OTe(l[0].x):DTe(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)s[(h=l[u]).i]=h.x(c);return s.join("")})}var lK,sK,cK=M(()=>{J5();lK=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,sK=new RegExp(lK.source,"g")});function _y(e,t){var r=typeof t,n;return t==null||r==="boolean"?Z5(t):(r==="number"?Ua:r==="string"?(n=Su(t))?(t=n,gy):Q5:t instanceof Su?gy:t instanceof Date?j5t:q5t(t)?U5t:Array.isArray(t)?W5t:typeof t.valueOf!="function"&&typeof t.toString!="function"||isNaN(t)?$5t:Ua)(e,t)}var DR=M(()=>{RR();aK();Y5t();X5t();J5();K5t();cK();oK();G5t()});function uK(e,t,r,n,i,o){var a,s,l;return(a=Math.sqrt(e*e+t*t))&&(e/=a,t/=a),(l=e*r+t*n)&&(r-=e*l,n-=t*l),(s=Math.sqrt(r*r+n*n))&&(r/=s,n/=s,l/=s),e*n<t*r&&(e=-e,t=-t,l=-l,a=-a),{translateX:i,translateY:o,rotate:Math.atan2(t,e)*Z5t,skewX:Math.atan(l)*Z5t,scaleX:a,scaleY:s}}var Z5t,OR,J5t=M(()=>{Z5t=180/Math.PI,OR={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1}});function tTt(e){return e==="none"?OR:(tT||(tT=document.createElement("DIV"),hK=document.documentElement,Q5t=document.defaultView),tT.style.transform=e,e=Q5t.getComputedStyle(hK.appendChild(tT),null).getPropertyValue("transform"),hK.removeChild(tT),e=e.slice(7,-1).split(","),uK(+e[0],+e[1],+e[2],+e[3],+e[4],+e[5]))}function eTt(e){return e==null?OR:(zR||(zR=document.createElementNS("http://www.w3.org/2000/svg","g")),zR.setAttribute("transform",e),(e=zR.transform.baseVal.consolidate())?(e=e.matrix,uK(e.a,e.b,e.c,e.d,e.e,e.f)):OR)}var tT,hK,Q5t,zR,rTt=M(()=>{J5t()});function nTt(e,t,r,n){function i(c){return c.length?c.pop()+" ":""}function o(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push("translate(",null,t,null,r);d.push({i:g-4,x:Ua(c,h)},{i:g-2,x:Ua(u,f)})}else(h||f)&&p.push("translate("+h+t+f+r)}function a(c,u,h,f){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),f.push({i:h.push(i(h)+"rotate(",null,n)-2,x:Ua(c,u)})):u&&h.push(i(h)+"rotate("+u+n)}function s(c,u,h,f){c!==u?f.push({i:h.push(i(h)+"skewX(",null,n)-2,x:Ua(c,u)}):u&&h.push(i(h)+"skewX("+u+n)}function l(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push(i(p)+"scale(",null,",",null,")");d.push({i:g-4,x:Ua(c,h)},{i:g-2,x:Ua(u,f)})}else(h!==1||f!==1)&&p.push(i(p)+"scale("+h+","+f+")")}return function(c,u){var h=[],f=[];return c=e(c),u=e(u),o(c.translateX,c.translateY,u.translateX,u.translateY,h,f),a(c.rotate,u.rotate,h,f),s(c.skewX,u.skewX,h,f),l(c.scaleX,c.scaleY,u.scaleX,u.scaleY,h,f),c=u=null,function(p){for(var d=-1,g=f.length,_;++d<g;)h[(_=f[d]).i]=_.x(p);return h.join("")}}}var fK,pK,iTt=M(()=>{J5();rTt();fK=nTt(tTt,"px, ","px)","deg)"),pK=nTt(eTt,", ",")",")")});var eT=M(()=>{DR();J5();cK();iTt();aK()});function f2(){return yy||(sTt(zTe),yy=oT.now()+HR)}function zTe(){yy=0}function aT(){this._call=this._time=this._next=null}function VR(e,t,r){var n=new aT;return n.restart(e,t,r),n}function lTt(){f2(),++h2;for(var e=FR,t;e;)(t=yy-e._time)>=0&&e._call.call(null,t),e=e._next;--h2}function oTt(){yy=(BR=oT.now())+HR,h2=nT=0;try{lTt()}finally{h2=0,BTe(),yy=0}}function FTe(){var e=oT.now(),t=e-BR;t>aTt&&(HR-=t,BR=e)}function BTe(){for(var e,t=FR,r,n=1/0;t;)t._call?(n>t._time&&(n=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:FR=r);iT=e,dK(n)}function dK(e){if(!h2){nT&&(nT=clearTimeout(nT));var t=e-yy;t>24?(e<1/0&&(nT=setTimeout(oTt,e-oT.now()-HR)),rT&&(rT=clearInterval(rT))):(rT||(BR=oT.now(),rT=setInterval(FTe,aTt)),h2=1,sTt(oTt))}}var h2,nT,rT,aTt,FR,iT,BR,yy,HR,oT,sTt,mK=M(()=>{h2=0,nT=0,rT=0,aTt=1e3,BR=0,yy=0,HR=0,oT=typeof performance=="object"&&performance.now?performance:Date,sTt=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};aT.prototype=VR.prototype={constructor:aT,restart:function(e,t,r){if(typeof e!="function")throw new TypeError("callback is not a function");r=(r==null?f2():+r)+(t==null?0:+t),!this._next&&iT!==this&&(iT?iT._next=this:FR=this,iT=this),this._call=e,this._time=r,dK()},stop:function(){this._call&&(this._call=null,this._time=1/0,dK())}}});function UR(e,t,r){var n=new aT;return t=t==null?0:+t,n.restart(function(i){n.stop(),e(i+t)},t,r),n}var cTt=M(()=>{mK()});var gK=M(()=>{mK();cTt()});function sg(e,t,r,n,i,o){var a=e.__transition;if(!a)e.__transition={};else if(r in a)return;UTe(e,r,{name:t,index:n,group:i,on:HTe,tween:VTe,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:hTt})}function lT(e,t){var r=Qi(e,t);if(r.state>hTt)throw new Error("too late; already scheduled");return r}function qa(e,t){var r=Qi(e,t);if(r.state>qR)throw new Error("too late; already running");return r}function Qi(e,t){var r=e.__transition;if(!r||!(r=r[t]))throw new Error("transition not found");return r}function UTe(e,t,r){var n=e.__transition,i;n[t]=r,r.timer=VR(o,0,r.time);function o(c){r.state=_K,r.timer.restart(a,r.delay,r.time),r.delay<=c&&a(c-r.delay)}function a(c){var u,h,f,p;if(r.state!==_K)return l();for(u in n)if(p=n[u],p.name===r.name){if(p.state===qR)return UR(a);p.state===uTt?(p.state=sT,p.timer.stop(),p.on.call("interrupt",e,e.__data__,p.index,p.group),delete n[u]):+u<t&&(p.state=sT,p.timer.stop(),p.on.call("cancel",e,e.__data__,p.index,p.group),delete n[u])}if(UR(function(){r.state===qR&&(r.state=uTt,r.timer.restart(s,r.delay,r.time),s(c))}),r.state=GR,r.on.call("start",e,e.__data__,r.index,r.group),r.state===GR){for(r.state=qR,i=new Array(f=r.tween.length),u=0,h=-1;u<f;++u)(p=r.tween[u].value.call(e,e.__data__,r.index,r.group))&&(i[++h]=p);i.length=h+1}}function s(c){for(var u=c<r.duration?r.ease.call(null,c/r.duration):(r.timer.restart(l),r.state=WR,1),h=-1,f=i.length;++h<f;)i[h].call(e,u);r.state===WR&&(r.on.call("end",e,e.__data__,r.index,r.group),l())}function l(){r.state=sT,r.timer.stop(),delete n[t];for(var c in n)return;delete e.__transition}}var HTe,VTe,hTt,_K,GR,qR,uTt,WR,sT,Ts=M(()=>{B$();gK();HTe=G5("start","end","cancel","interrupt"),VTe=[],hTt=0,_K=1,GR=2,qR=3,uTt=4,WR=5,sT=6});function p2(e,t){var r=e.__transition,n,i,o=!0,a;if(!!r){t=t==null?null:t+"";for(a in r){if((n=r[a]).name!==t){o=!1;continue}i=n.state>GR&&n.state<WR,n.state=sT,n.timer.stop(),n.on.call(i?"interrupt":"cancel",e,e.__data__,n.index,n.group),delete r[a]}o&&delete e.__transition}}var yK=M(()=>{Ts()});function fTt(e){return this.each(function(){p2(this,e)})}var pTt=M(()=>{yK()});function qTe(e,t){var r,n;return function(){var i=qa(this,e),o=i.tween;if(o!==r){n=r=o;for(var a=0,s=n.length;a<s;++a)if(n[a].name===t){n=n.slice(),n.splice(a,1);break}}i.tween=n}}function GTe(e,t,r){var n,i;if(typeof r!="function")throw new Error;return function(){var o=qa(this,e),a=o.tween;if(a!==n){i=(n=a).slice();for(var s={name:t,value:r},l=0,c=i.length;l<c;++l)if(i[l].name===t){i[l]=s;break}l===c&&i.push(s)}o.tween=i}}function dTt(e,t){var r=this._id;if(e+="",arguments.length<2){for(var n=Qi(this.node(),r).tween,i=0,o=n.length,a;i<o;++i)if((a=n[i]).name===e)return a.value;return null}return this.each((t==null?qTe:GTe)(r,e,t))}function d2(e,t,r){var n=e._id;return e.each(function(){var i=qa(this,n);(i.value||(i.value={}))[t]=r.apply(this,arguments)}),function(i){return Qi(i,n).value[t]}}var cT=M(()=>{Ts()});function YR(e,t){var r;return(typeof t=="number"?Ua:t instanceof Su?gy:(r=Su(t))?(t=r,gy):Q5)(e,t)}var vK=M(()=>{RR();eT()});function WTe(e){return function(){this.removeAttribute(e)}}function YTe(e){return function(){this.removeAttributeNS(e.space,e.local)}}function jTe(e,t,r){var n,i=r+"",o;return function(){var a=this.getAttribute(e);return a===i?null:a===n?o:o=t(n=a,r)}}function XTe(e,t,r){var n,i=r+"",o;return function(){var a=this.getAttributeNS(e.space,e.local);return a===i?null:a===n?o:o=t(n=a,r)}}function $Te(e,t,r){var n,i,o;return function(){var a,s=r(this),l;return s==null?void this.removeAttribute(e):(a=this.getAttribute(e),l=s+"",a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s)))}}function KTe(e,t,r){var n,i,o;return function(){var a,s=r(this),l;return s==null?void this.removeAttributeNS(e.space,e.local):(a=this.getAttributeNS(e.space,e.local),l=s+"",a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s)))}}function mTt(e,t){var r=Vp(e),n=r==="transform"?pK:YR;return this.attrTween(e,typeof t=="function"?(r.local?KTe:$Te)(r,n,d2(this,"attr."+e,t)):t==null?(r.local?YTe:WTe)(r):(r.local?XTe:jTe)(r,n,t))}var gTt=M(()=>{eT();Es();cT();vK()});function ZTe(e,t){return function(r){this.setAttribute(e,t.call(this,r))}}function JTe(e,t){return function(r){this.setAttributeNS(e.space,e.local,t.call(this,r))}}function QTe(e,t){var r,n;function i(){var o=t.apply(this,arguments);return o!==n&&(r=(n=o)&&JTe(e,o)),r}return i._value=t,i}function tCe(e,t){var r,n;function i(){var o=t.apply(this,arguments);return o!==n&&(r=(n=o)&&ZTe(e,o)),r}return i._value=t,i}function _Tt(e,t){var r="attr."+e;if(arguments.length<2)return(r=this.tween(r))&&r._value;if(t==null)return this.tween(r,null);if(typeof t!="function")throw new Error;var n=Vp(e);return this.tween(r,(n.local?QTe:tCe)(n,t))}var yTt=M(()=>{Es()});function eCe(e,t){return function(){lT(this,e).delay=+t.apply(this,arguments)}}function rCe(e,t){return t=+t,function(){lT(this,e).delay=t}}function vTt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?eCe:rCe)(t,e)):Qi(this.node(),t).delay}var xTt=M(()=>{Ts()});function nCe(e,t){return function(){qa(this,e).duration=+t.apply(this,arguments)}}function iCe(e,t){return t=+t,function(){qa(this,e).duration=t}}function bTt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?nCe:iCe)(t,e)):Qi(this.node(),t).duration}var wTt=M(()=>{Ts()});function oCe(e,t){if(typeof t!="function")throw new Error;return function(){qa(this,e).ease=t}}function STt(e){var t=this._id;return arguments.length?this.each(oCe(t,e)):Qi(this.node(),t).ease}var MTt=M(()=>{Ts()});function ETt(e){typeof e!="function"&&(e=Y5(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new ua(n,this._parents,this._name,this._id)}var TTt=M(()=>{Es();Gp()});function CTt(e){if(e._id!==this._id)throw new Error;for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new ua(a,this._parents,this._name,this._id)}var ATt=M(()=>{Gp()});function aCe(e){return(e+"").trim().split(/^|\s+/).every(function(t){var r=t.indexOf(".");return r>=0&&(t=t.slice(0,r)),!t||t==="start"})}function sCe(e,t,r){var n,i,o=aCe(t)?lT:qa;return function(){var a=o(this,e),s=a.on;s!==n&&(i=(n=s).copy()).on(t,r),a.on=i}}function PTt(e,t){var r=this._id;return arguments.length<2?Qi(this.node(),r).on.on(e):this.each(sCe(r,e,t))}var ITt=M(()=>{Ts()});function lCe(e){return function(){var t=this.parentNode;for(var r in this.__transition)if(+r!==e)return;t&&t.removeChild(this)}}function LTt(){return this.on("end.remove",lCe(this._id))}var kTt=M(()=>{});function RTt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=my(e));for(var n=this._groups,i=n.length,o=new Array(i),a=0;a<i;++a)for(var s=n[a],l=s.length,c=o[a]=new Array(l),u,h,f=0;f<l;++f)(u=s[f])&&(h=e.call(u,u.__data__,f,s))&&("__data__"in u&&(h.__data__=u.__data__),c[f]=h,sg(c[f],t,r,f,c,Qi(u,r)));return new ua(o,this._parents,t,r)}var NTt=M(()=>{Es();Gp();Ts()});function DTt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=W5(e));for(var n=this._groups,i=n.length,o=[],a=[],s=0;s<i;++s)for(var l=n[s],c=l.length,u,h=0;h<c;++h)if(u=l[h]){for(var f=e.call(u,u.__data__,h,l),p,d=Qi(u,r),g=0,_=f.length;g<_;++g)(p=f[g])&&sg(p,t,r,g,f,d);o.push(f),a.push(u)}return new ua(o,a,t,r)}var OTt=M(()=>{Es();Gp();Ts()});function zTt(){return new cCe(this._groups,this._parents)}var cCe,FTt=M(()=>{Es();cCe=Up.prototype.constructor});function uCe(e,t){var r,n,i;return function(){var o=ag(this,e),a=(this.style.removeProperty(e),ag(this,e));return o===a?null:o===r&&a===n?i:i=t(r=o,n=a)}}function BTt(e){return function(){this.style.removeProperty(e)}}function hCe(e,t,r){var n,i=r+"",o;return function(){var a=ag(this,e);return a===i?null:a===n?o:o=t(n=a,r)}}function fCe(e,t,r){var n,i,o;return function(){var a=ag(this,e),s=r(this),l=s+"";return s==null&&(l=s=(this.style.removeProperty(e),ag(this,e))),a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s))}}function pCe(e,t){var r,n,i,o="style."+t,a="end."+o,s;return function(){var l=qa(this,e),c=l.on,u=l.value[o]==null?s||(s=BTt(t)):void 0;(c!==r||i!==u)&&(n=(r=c).copy()).on(a,i=u),l.on=n}}function HTt(e,t,r){var n=(e+="")=="transform"?fK:YR;return t==null?this.styleTween(e,uCe(e,n)).on("end.style."+e,BTt(e)):typeof t=="function"?this.styleTween(e,fCe(e,n,d2(this,"style."+e,t))).each(pCe(this._id,e)):this.styleTween(e,hCe(e,n,t),r).on("end.style."+e,null)}var VTt=M(()=>{eT();Es();Ts();cT();vK()});function dCe(e,t,r){return function(n){this.style.setProperty(e,t.call(this,n),r)}}function mCe(e,t,r){var n,i;function o(){var a=t.apply(this,arguments);return a!==i&&(n=(i=a)&&dCe(e,a,r)),n}return o._value=t,o}function UTt(e,t,r){var n="style."+(e+="");if(arguments.length<2)return(n=this.tween(n))&&n._value;if(t==null)return this.tween(n,null);if(typeof t!="function")throw new Error;return this.tween(n,mCe(e,t,r==null?"":r))}var qTt=M(()=>{});function gCe(e){return function(){this.textContent=e}}function _Ce(e){return function(){var t=e(this);this.textContent=t==null?"":t}}function GTt(e){return this.tween("text",typeof e=="function"?_Ce(d2(this,"text",e)):gCe(e==null?"":e+""))}var WTt=M(()=>{cT()});function yCe(e){return function(t){this.textContent=e.call(this,t)}}function vCe(e){var t,r;function n(){var i=e.apply(this,arguments);return i!==r&&(t=(r=i)&&yCe(i)),t}return n._value=e,n}function YTt(e){var t="text";if(arguments.length<1)return(t=this.tween(t))&&t._value;if(e==null)return this.tween(t,null);if(typeof e!="function")throw new Error;return this.tween(t,vCe(e))}var jTt=M(()=>{});function XTt(){for(var e=this._name,t=this._id,r=jR(),n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)if(l=a[c]){var u=Qi(l,t);sg(l,e,r,c,a,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new ua(n,this._parents,e,r)}var $Tt=M(()=>{Gp();Ts()});function KTt(){var e,t,r=this,n=r._id,i=r.size();return new Promise(function(o,a){var s={value:a},l={value:function(){--i===0&&o()}};r.each(function(){var c=qa(this,n),u=c.on;u!==e&&(t=(e=u).copy(),t._.cancel.push(s),t._.interrupt.push(s),t._.end.push(l)),c.on=t})})}var ZTt=M(()=>{Ts()});function ua(e,t,r,n){this._groups=e,this._parents=t,this._name=r,this._id=n}function xK(e){return Up().transition(e)}function jR(){return++xCe}var xCe,m2,Gp=M(()=>{Es();gTt();yTt();xTt();wTt();MTt();TTt();ATt();ITt();kTt();NTt();OTt();FTt();VTt();qTt();WTt();jTt();$Tt();cT();ZTt();xCe=0;m2=Up.prototype;ua.prototype=xK.prototype={constructor:ua,select:RTt,selectAll:DTt,filter:ETt,merge:CTt,selection:zTt,transition:XTt,call:m2.call,nodes:m2.nodes,node:m2.node,size:m2.size,empty:m2.empty,each:m2.each,on:PTt,attr:mTt,attrTween:_Tt,style:HTt,styleTween:UTt,text:GTt,textTween:YTt,remove:LTt,tween:dTt,delay:vTt,duration:bTt,ease:STt,end:KTt}});function bCe(e,t){for(var r;!(r=e.__transition)||!(r=r[t]);)if(!(e=e.parentNode))return bK.time=f2(),bK;return r}function JTt(e){var t,r;e instanceof ua?(t=e._id,e=e._name):(t=jR(),(r=bK).time=f2(),e=e==null?null:e+"");for(var n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&sg(l,e,t,c,a,r||bCe(l,t));return new ua(n,this._parents,e,t)}var bK,QTt=M(()=>{Gp();Ts();I_();gK();bK={time:null,delay:0,duration:250,ease:xs}});var tCt=M(()=>{Es();pTt();QTt();Up.prototype.interrupt=fTt;Up.prototype.transition=JTt});var eCt=M(()=>{Gp();Ts()});var rCt=M(()=>{tCt();Gp();eCt();yK()});function wK(e){return function(){return e}}var nCt=M(()=>{});function iCt(e,t,r){this.target=e,this.type=t,this.selection=r}var oCt=M(()=>{});function SK(){wr.stopImmediatePropagation()}function uT(){wr.preventDefault(),wr.stopImmediatePropagation()}var aCt=M(()=>{Es()});function hT(e){return{type:e}}function ECe(){return!wr.button}function TCe(){var e=this.ownerSVGElement||this;return[[0,0],[e.width.baseVal.value,e.height.baseVal.value]]}function EK(e){for(;!e.__brush;)if(!(e=e.parentNode))return;return e.__brush}function TK(e){return e[0][0]===e[1][0]||e[0][1]===e[1][1]}function uCt(e){var t=e.__brush;return t?t.dim.output(t.selection):null}function hCt(){return CK(XR)}function fCt(){return CK($R)}function pCt(){return CK(wCe)}function CK(e){var t=TCe,r=ECe,n=G5(a,"start","brush","end"),i=6,o;function a(f){var p=f.property("__brush",h).selectAll(".overlay").data([hT("overlay")]);p.enter().append("rect").attr("class","overlay").attr("pointer-events","all").attr("cursor",Wp.overlay).merge(p).each(function(){var g=EK(this).extent;qp(this).attr("x",g[0][0]).attr("y",g[0][1]).attr("width",g[1][0]-g[0][0]).attr("height",g[1][1]-g[0][1])}),f.selectAll(".selection").data([hT("selection")]).enter().append("rect").attr("class","selection").attr("cursor",Wp.selection).attr("fill","#777").attr("fill-opacity",.3).attr("stroke","#fff").attr("shape-rendering","crispEdges");var d=f.selectAll(".handle").data(e.handles,function(g){return g.type});d.exit().remove(),d.enter().append("rect").attr("class",function(g){return"handle handle--"+g.type}).attr("cursor",function(g){return Wp[g.type]}),f.each(s).attr("fill","none").attr("pointer-events","all").style("-webkit-tap-highlight-color","rgba(0,0,0,0)").on("mousedown.brush touchstart.brush",u)}a.move=function(f,p){f.selection?f.on("start.brush",function(){l(this,arguments).beforestart().start()}).on("interrupt.brush end.brush",function(){l(this,arguments).end()}).tween("brush",function(){var d=this,g=d.__brush,_=l(d,arguments),y=g.selection,x=e.input(typeof p=="function"?p.apply(this,arguments):p,g.extent),b=_y(y,x);function S(C){g.selection=C===1&&TK(x)?null:b(C),s.call(d),_.brush()}return y&&x?S:S(1)}):f.each(function(){var d=this,g=arguments,_=d.__brush,y=e.input(typeof p=="function"?p.apply(d,g):p,_.extent),x=l(d,g).beforestart();p2(d),_.selection=y==null||TK(y)?null:y,s.call(d),x.start().brush().end()})};function s(){var f=qp(this),p=EK(this).selection;p?(f.selectAll(".selection").style("display",null).attr("x",p[0][0]).attr("y",p[0][1]).attr("width",p[1][0]-p[0][0]).attr("height",p[1][1]-p[0][1]),f.selectAll(".handle").style("display",null).attr("x",function(d){return d.type[d.type.length-1]==="e"?p[1][0]-i/2:p[0][0]-i/2}).attr("y",function(d){return d.type[0]==="s"?p[1][1]-i/2:p[0][1]-i/2}).attr("width",function(d){return d.type==="n"||d.type==="s"?p[1][0]-p[0][0]+i:i}).attr("height",function(d){return d.type==="e"||d.type==="w"?p[1][1]-p[0][1]+i:i})):f.selectAll(".selection,.handle").style("display","none").attr("x",null).attr("y",null).attr("width",null).attr("height",null)}function l(f,p){return f.__brush.emitter||new c(f,p)}function c(f,p){this.that=f,this.args=p,this.state=f.__brush,this.active=0}c.prototype={beforestart:function(){return++this.active===1&&(this.state.emitter=this,this.starting=!0),this},start:function(){return this.starting&&(this.starting=!1,this.emit("start")),this},brush:function(){return this.emit("brush"),this},end:function(){return--this.active===0&&(delete this.state.emitter,this.emit("end")),this},emit:function(f){K$(new iCt(a,f,e.output(this.state.selection)),n.apply,n,[f,this.that,this.args])}};function u(){if(wr.touches){if(wr.changedTouches.length<wr.touches.length)return uT()}else if(o)return;if(!r.apply(this,arguments))return;var f=this,p=wr.target.__data__.type,d=(wr.metaKey?p="overlay":p)==="selection"?sCt:wr.altKey?_2:g2,g=e===$R?null:SCe[p],_=e===XR?null:MCe[p],y=EK(f),x=y.extent,b=y.selection,S=x[0][0],C,P,k=x[0][1],O,D,B=x[1][0],I,L,R=x[1][1],F,z,U,W,Z,rt=g&&_&&wr.shiftKey,ot,st,St=AR(f),bt=St,Mt=l(f,arguments).beforestart();p==="overlay"?y.selection=b=[[C=e===$R?S:St[0],O=e===XR?k:St[1]],[I=e===$R?B:C,F=e===XR?R:O]]:(C=b[0][0],O=b[0][1],I=b[1][0],F=b[1][1]),P=C,D=O,L=I,z=F;var lt=qp(f).attr("pointer-events","none"),Kt=lt.selectAll(".overlay").attr("cursor",Wp[p]);if(wr.touches)lt.on("touchmove.brush",ct,!0).on("touchend.brush touchcancel.brush",et,!0);else{var _t=qp(wr.view).on("keydown.brush",dt,!0).on("keyup.brush",q,!0).on("mousemove.brush",ct,!0).on("mouseup.brush",et,!0);J$(wr.view)}SK(),p2(f),s.call(f),Mt.start();function ct(){var pt=AR(f);rt&&!ot&&!st&&(Math.abs(pt[0]-bt[0])>Math.abs(pt[1]-bt[1])?st=!0:ot=!0),bt=pt,Z=!0,uT(),X()}function X(){var pt;switch(U=bt[0]-St[0],W=bt[1]-St[1],d){case MK:case sCt:{g&&(U=Math.max(S-C,Math.min(B-I,U)),P=C+U,L=I+U),_&&(W=Math.max(k-O,Math.min(R-F,W)),D=O+W,z=F+W);break}case g2:{g<0?(U=Math.max(S-C,Math.min(B-C,U)),P=C+U,L=I):g>0&&(U=Math.max(S-I,Math.min(B-I,U)),P=C,L=I+U),_<0?(W=Math.max(k-O,Math.min(R-O,W)),D=O+W,z=F):_>0&&(W=Math.max(k-F,Math.min(R-F,W)),D=O,z=F+W);break}case _2:{g&&(P=Math.max(S,Math.min(B,C-U*g)),L=Math.max(S,Math.min(B,I+U*g))),_&&(D=Math.max(k,Math.min(R,O-W*_)),z=Math.max(k,Math.min(R,F+W*_)));break}}L<P&&(g*=-1,pt=C,C=I,I=pt,pt=P,P=L,L=pt,p in lCt&&Kt.attr("cursor",Wp[p=lCt[p]])),z<D&&(_*=-1,pt=O,O=F,F=pt,pt=D,D=z,z=pt,p in cCt&&Kt.attr("cursor",Wp[p=cCt[p]])),y.selection&&(b=y.selection),ot&&(P=b[0][0],L=b[1][0]),st&&(D=b[0][1],z=b[1][1]),(b[0][0]!==P||b[0][1]!==D||b[1][0]!==L||b[1][1]!==z)&&(y.selection=[[P,D],[L,z]],s.call(f),Mt.brush())}function et(){if(SK(),wr.touches){if(wr.touches.length)return;o&&clearTimeout(o),o=setTimeout(function(){o=null},500),lt.on("touchmove.brush touchend.brush touchcancel.brush",null)}else Q$(wr.view,Z),_t.on("keydown.brush keyup.brush mousemove.brush mouseup.brush",null);lt.attr("pointer-events","all"),Kt.attr("cursor",Wp.overlay),y.selection&&(b=y.selection),TK(b)&&(y.selection=null,s.call(f)),Mt.end()}function dt(){switch(wr.keyCode){case 16:{rt=g&&_;break}case 18:{d===g2&&(g&&(I=L-U*g,C=P+U*g),_&&(F=z-W*_,O=D+W*_),d=_2,X());break}case 32:{(d===g2||d===_2)&&(g<0?I=L-U:g>0&&(C=P-U),_<0?F=z-W:_>0&&(O=D-W),d=MK,Kt.attr("cursor",Wp.selection),X());break}default:return}uT()}function q(){switch(wr.keyCode){case 16:{rt&&(ot=st=rt=!1,X());break}case 18:{d===_2&&(g<0?I=L:g>0&&(C=P),_<0?F=z:_>0&&(O=D),d=g2,X());break}case 32:{d===MK&&(wr.altKey?(g&&(I=L-U*g,C=P+U*g),_&&(F=z-W*_,O=D+W*_),d=_2):(g<0?I=L:g>0&&(C=P),_<0?F=z:_>0&&(O=D),d=g2),Kt.attr("cursor",Wp[p]),X());break}default:return}uT()}}function h(){var f=this.__brush||{selection:null};return f.extent=t.apply(this,arguments),f.dim=e,f}return a.extent=function(f){return arguments.length?(t=typeof f=="function"?f:wK([[+f[0][0],+f[0][1]],[+f[1][0],+f[1][1]]]),a):t},a.filter=function(f){return arguments.length?(r=typeof f=="function"?f:wK(!!f),a):r},a.handleSize=function(f){return arguments.length?(i=+f,a):i},a.on=function(){var f=n.on.apply(n,arguments);return f===n?a:f},a}var sCt,MK,g2,_2,XR,$R,wCe,Wp,lCt,cCt,SCe,MCe,dCt=M(()=>{B$();M5t();eT();Es();rCt();nCt();oCt();aCt();sCt={name:"drag"},MK={name:"space"},g2={name:"handle"},_2={name:"center"},XR={name:"x",handles:["e","w"].map(hT),input:function(e,t){return e&&[[e[0],t[0][1]],[e[1],t[1][1]]]},output:function(e){return e&&[e[0][0],e[1][0]]}},$R={name:"y",handles:["n","s"].map(hT),input:function(e,t){return e&&[[t[0][0],e[0]],[t[1][0],e[1]]]},output:function(e){return e&&[e[0][1],e[1][1]]}},wCe={name:"xy",handles:["n","e","s","w","nw","ne","se","sw"].map(hT),input:function(e){return e},output:function(e){return e}},Wp={overlay:"crosshair",selection:"move",n:"ns-resize",e:"ew-resize",s:"ns-resize",w:"ew-resize",nw:"nwse-resize",ne:"nesw-resize",se:"nwse-resize",sw:"nesw-resize"},lCt={e:"w",w:"e",nw:"ne",ne:"nw",se:"sw",sw:"se"},cCt={n:"s",s:"n",nw:"sw",ne:"se",se:"ne",sw:"nw"},SCe={overlay:1,selection:1,n:null,e:1,s:null,w:-1,nw:-1,ne:1,se:1,sw:-1},MCe={overlay:1,selection:1,n:-1,e:null,s:1,w:null,nw:-1,ne:-1,se:1,sw:1}});var mCt=M(()=>{dCt()});function lg(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var vy=M(()=>{});function AK(e){return e.length===1&&(e=CCe(e)),{left:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)<0?n=o+1:i=o}return n},right:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)>0?i=o:n=o+1}return n}}}function CCe(e){return function(t,r){return lg(e(t),r)}}var PK=M(()=>{vy()});var gCt,ACe,PCe,IK=M(()=>{vy();PK();gCt=AK(lg),ACe=gCt.right,PCe=gCt.left});var LK=M(()=>{});var _Ct=M(()=>{LK()});var yCt=M(()=>{});var y2=M(()=>{});var kK=M(()=>{y2()});var RK=M(()=>{kK()});var NK=M(()=>{});var vCt,LCe,kCe,DK=M(()=>{vCt=Array.prototype,LCe=vCt.slice,kCe=vCt.map});var xCt=M(()=>{});var bCt=M(()=>{});function fT(e,t,r){e=+e,t=+t,r=(i=arguments.length)<2?(t=e,e=0,1):i<3?1:+r;for(var n=-1,i=Math.max(0,Math.ceil((t-e)/r))|0,o=new Array(i);++n<i;)o[n]=e+n*r;return o}var OK=M(()=>{});var fln,pln,dln,zK=M(()=>{fln=Math.sqrt(50),pln=Math.sqrt(10),dln=Math.sqrt(2)});var FK=M(()=>{});var wCt=M(()=>{DK();IK();xCt();NK();bCt();OK();zK();FK()});var ZR=M(()=>{y2()});var MCt=M(()=>{DK();vy();y2();ZR()});var ECt=M(()=>{RK()});var TCt=M(()=>{});var CCt=M(()=>{y2()});var ACt=M(()=>{vy();y2();ZR()});var PCt=M(()=>{});var BK=M(()=>{});var ICt=M(()=>{});var LCt=M(()=>{vy()});var kCt=M(()=>{});var RCt=M(()=>{});var HK=M(()=>{BK()});var NCt=M(()=>{HK()});var DCt=M(()=>{IK();vy();PK();_Ct();yCt();RK();NK();wCt();MCt();ECt();FK();TCt();CCt();ACt();PCt();BK();LK();ICt();ZR();OK();LCt();kCt();RCt();zK();HK();kK();NCt()});var VK,UK,OCt,pT,qK,GK,WK=M(()=>{VK=Math.cos,UK=Math.sin,OCt=Math.PI,pT=OCt/2,qK=OCt*2,GK=Math.max});function HCe(e){return function(t,r){return e(t.source.value+t.target.value,r.source.value+r.target.value)}}function zCt(){var e=0,t=null,r=null,n=null;function i(o){var a=o.length,s=[],l=fT(a),c=[],u=[],h=u.groups=new Array(a),f=new Array(a*a),p,d,g,_,y,x;for(p=0,y=-1;++y<a;){for(d=0,x=-1;++x<a;)d+=o[y][x];s.push(d),c.push(fT(a)),p+=d}for(t&&l.sort(function(B,I){return t(s[B],s[I])}),r&&c.forEach(function(B,I){B.sort(function(L,R){return r(o[I][L],o[I][R])})}),p=GK(0,qK-e*a)/p,_=p?e:qK/a,d=0,y=-1;++y<a;){for(g=d,x=-1;++x<a;){var b=l[y],S=c[b][x],C=o[b][S],P=d,k=d+=C*p;f[S*a+b]={index:b,subindex:S,startAngle:P,endAngle:k,value:C}}h[b]={index:b,startAngle:g,endAngle:d,value:s[b]},d+=_}for(y=-1;++y<a;)for(x=y-1;++x<a;){var O=f[x*a+y],D=f[y*a+x];(O.value||D.value)&&u.push(O.value<D.value?{source:D,target:O}:{source:O,target:D})}return n?u.sort(n):u}return i.padAngle=function(o){return arguments.length?(e=GK(0,o),i):e},i.sortGroups=function(o){return arguments.length?(t=o,i):t},i.sortSubgroups=function(o){return arguments.length?(r=o,i):r},i.sortChords=function(o){return arguments.length?(o==null?n=null:(n=HCe(o))._=o,i):n&&n._},i}var FCt=M(()=>{DCt();WK()});var BCt,HCt=M(()=>{BCt=Array.prototype.slice});function JR(e){return function(){return e}}var VCt=M(()=>{});function XK(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function UCt(){return new XK}var YK,jK,xy,VCe,$K,qCt=M(()=>{YK=Math.PI,jK=2*YK,xy=1e-6,VCe=jK-xy;XK.prototype=UCt.prototype={constructor:XK,moveTo:function(e,t){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)},closePath:function(){this._x1!==null&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(e,t){this._+="L"+(this._x1=+e)+","+(this._y1=+t)},quadraticCurveTo:function(e,t,r,n){this._+="Q"+ +e+","+ +t+","+(this._x1=+r)+","+(this._y1=+n)},bezierCurveTo:function(e,t,r,n,i,o){this._+="C"+ +e+","+ +t+","+ +r+","+ +n+","+(this._x1=+i)+","+(this._y1=+o)},arcTo:function(e,t,r,n,i){e=+e,t=+t,r=+r,n=+n,i=+i;var o=this._x1,a=this._y1,s=r-e,l=n-t,c=o-e,u=a-t,h=c*c+u*u;if(i<0)throw new Error("negative radius: "+i);if(this._x1===null)this._+="M"+(this._x1=e)+","+(this._y1=t);else if(h>xy)if(!(Math.abs(u*s-l*c)>xy)||!i)this._+="L"+(this._x1=e)+","+(this._y1=t);else{var f=r-o,p=n-a,d=s*s+l*l,g=f*f+p*p,_=Math.sqrt(d),y=Math.sqrt(h),x=i*Math.tan((YK-Math.acos((d+h-g)/(2*_*y)))/2),b=x/y,S=x/_;Math.abs(b-1)>xy&&(this._+="L"+(e+b*c)+","+(t+b*u)),this._+="A"+i+","+i+",0,0,"+ +(u*f>c*p)+","+(this._x1=e+S*s)+","+(this._y1=t+S*l)}},arc:function(e,t,r,n,i,o){e=+e,t=+t,r=+r,o=!!o;var a=r*Math.cos(n),s=r*Math.sin(n),l=e+a,c=t+s,u=1^o,h=o?n-i:i-n;if(r<0)throw new Error("negative radius: "+r);this._x1===null?this._+="M"+l+","+c:(Math.abs(this._x1-l)>xy||Math.abs(this._y1-c)>xy)&&(this._+="L"+l+","+c),r&&(h<0&&(h=h%jK+jK),h>VCe?this._+="A"+r+","+r+",0,1,"+u+","+(e-a)+","+(t-s)+"A"+r+","+r+",0,1,"+u+","+(this._x1=l)+","+(this._y1=c):h>xy&&(this._+="A"+r+","+r+",0,"+ +(h>=YK)+","+u+","+(this._x1=e+r*Math.cos(i))+","+(this._y1=t+r*Math.sin(i))))},rect:function(e,t,r,n){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)+"h"+ +r+"v"+ +n+"h"+-r+"Z"},toString:function(){return this._}};$K=UCt});var GCt=M(()=>{qCt()});function UCe(e){return e.source}function qCe(e){return e.target}function GCe(e){return e.radius}function WCe(e){return e.startAngle}function YCe(e){return e.endAngle}function WCt(){var e=UCe,t=qCe,r=GCe,n=WCe,i=YCe,o=null;function a(){var s,l=BCt.call(arguments),c=e.apply(this,l),u=t.apply(this,l),h=+r.apply(this,(l[0]=c,l)),f=n.apply(this,l)-pT,p=i.apply(this,l)-pT,d=h*VK(f),g=h*UK(f),_=+r.apply(this,(l[0]=u,l)),y=n.apply(this,l)-pT,x=i.apply(this,l)-pT;if(o||(o=s=$K()),o.moveTo(d,g),o.arc(0,0,h,f,p),(f!==y||p!==x)&&(o.quadraticCurveTo(0,0,_*VK(y),_*UK(y)),o.arc(0,0,_,y,x)),o.quadraticCurveTo(0,0,d,g),o.closePath(),s)return o=null,s+""||null}return a.radius=function(s){return arguments.length?(r=typeof s=="function"?s:JR(+s),a):r},a.startAngle=function(s){return arguments.length?(n=typeof s=="function"?s:JR(+s),a):n},a.endAngle=function(s){return arguments.length?(i=typeof s=="function"?s:JR(+s),a):i},a.source=function(s){return arguments.length?(e=s,a):e},a.target=function(s){return arguments.length?(t=s,a):t},a.context=function(s){return arguments.length?(o=s==null?null:s,a):o},a}var YCt=M(()=>{HCt();VCt();WK();GCt()});var jCt=M(()=>{FCt();YCt()});function QR(){}function XCt(e,t){var r=new QR;if(e instanceof QR)e.each(function(s,l){r.set(l,s)});else if(Array.isArray(e)){var n=-1,i=e.length,o;if(t==null)for(;++n<i;)r.set(n,e[n]);else for(;++n<i;)r.set(t(o=e[n],n,e),o)}else if(e)for(var a in e)r.set(a,e[a]);return r}var ll,by,tN=M(()=>{ll="$";QR.prototype=XCt.prototype={constructor:QR,has:function(e){return ll+e in this},get:function(e){return this[ll+e]},set:function(e,t){return this[ll+e]=t,this},remove:function(e){var t=ll+e;return t in this&&delete this[t]},clear:function(){for(var e in this)e[0]===ll&&delete this[e]},keys:function(){var e=[];for(var t in this)t[0]===ll&&e.push(t.slice(1));return e},values:function(){var e=[];for(var t in this)t[0]===ll&&e.push(this[t]);return e},entries:function(){var e=[];for(var t in this)t[0]===ll&&e.push({key:t.slice(1),value:this[t]});return e},size:function(){var e=0;for(var t in this)t[0]===ll&&++e;return e},empty:function(){for(var e in this)if(e[0]===ll)return!1;return!0},each:function(e){for(var t in this)t[0]===ll&&e(this[t],t.slice(1),this)}};by=XCt});function ZCt(){var e=[],t=[],r,n,i;function o(s,l,c,u){if(l>=e.length)return r!=null&&s.sort(r),n!=null?n(s):s;for(var h=-1,f=s.length,p=e[l++],d,g,_=by(),y,x=c();++h<f;)(y=_.get(d=p(g=s[h])+""))?y.push(g):_.set(d,[g]);return _.each(function(b,S){u(x,S,o(b,l,c,u))}),x}function a(s,l){if(++l>e.length)return s;var c,u=t[l-1];return n!=null&&l>=e.length?c=s.entries():(c=[],s.each(function(h,f){c.push({key:f,values:a(h,l)})})),u!=null?c.sort(function(h,f){return u(h.key,f.key)}):c}return i={object:function(s){return o(s,0,jCe,XCe)},map:function(s){return o(s,0,$Ct,KCt)},entries:function(s){return a(o(s,0,$Ct,KCt),0)},key:function(s){return e.push(s),i},sortKeys:function(s){return t[e.length-1]=s,i},sortValues:function(s){return r=s,i},rollup:function(s){return n=s,i}}}function jCe(){return{}}function XCe(e,t,r){e[t]=r}function $Ct(){return by()}function KCt(e,t,r){e.set(t,r)}var JCt=M(()=>{tN()});function eN(){}function QCt(e,t){var r=new eN;if(e instanceof eN)e.each(function(o){r.add(o)});else if(e){var n=-1,i=e.length;if(t==null)for(;++n<i;)r.add(e[n]);else for(;++n<i;)r.add(t(e[n],n,e))}return r}var wy,tAt,eAt=M(()=>{tN();wy=by.prototype;eN.prototype=QCt.prototype={constructor:eN,has:wy.has,add:function(e){return e+="",this[ll+e]=e,this},remove:wy.remove,clear:wy.clear,values:wy.keys,size:wy.size,empty:wy.empty,each:wy.each};tAt=QCt});function rAt(e){var t=[];for(var r in e)t.push(r);return t}var nAt=M(()=>{});function iAt(e){var t=[];for(var r in e)t.push(e[r]);return t}var oAt=M(()=>{});function aAt(e){var t=[];for(var r in e)t.push({key:r,value:e[r]});return t}var sAt=M(()=>{});var lAt=M(()=>{JCt();eAt();tN();nAt();oAt();sAt()});function Yp(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function cg(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}var rN=M(()=>{});function tf(){}function x2(e){var t;return e=(e+"").trim().toLowerCase(),(t=$Ce.exec(e))?(t=parseInt(t[1],16),new to(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1)):(t=KCe.exec(e))?uAt(parseInt(t[1],16)):(t=ZCe.exec(e))?new to(t[1],t[2],t[3],1):(t=JCe.exec(e))?new to(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=QCe.exec(e))?hAt(t[1],t[2],t[3],t[4]):(t=tAe.exec(e))?hAt(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=eAe.exec(e))?fAt(t[1],t[2]/100,t[3]/100,1):(t=rAe.exec(e))?fAt(t[1],t[2]/100,t[3]/100,t[4]):cAt.hasOwnProperty(e)?uAt(cAt[e]):e==="transparent"?new to(NaN,NaN,NaN,0):null}function uAt(e){return new to(e>>16&255,e>>8&255,e&255,1)}function hAt(e,t,r,n){return n<=0&&(e=t=r=NaN),new to(e,t,r,n)}function mT(e){return e instanceof tf||(e=x2(e)),e?(e=e.rgb(),new to(e.r,e.g,e.b,e.opacity)):new to}function ZK(e,t,r,n){return arguments.length===1?mT(e):new to(e,t,r,n==null?1:n)}function to(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}function fAt(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new Jh(e,t,r,n)}function nAe(e){if(e instanceof Jh)return new Jh(e.h,e.s,e.l,e.opacity);if(e instanceof tf||(e=x2(e)),!e)return new Jh;if(e instanceof Jh)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new Jh(a,s,l,e.opacity)}function JK(e,t,r,n){return arguments.length===1?nAe(e):new Jh(e,t,r,n==null?1:n)}function Jh(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}function KK(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var ug,Sy,v2,dT,Qh,$Ce,KCe,ZCe,JCe,QCe,tAe,eAe,rAe,cAt,nN=M(()=>{rN();ug=.7,Sy=1/ug,v2="\\s*([+-]?\\d+)\\s*",dT="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",Qh="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",$Ce=/^#([0-9a-f]{3})$/,KCe=/^#([0-9a-f]{6})$/,ZCe=new RegExp("^rgb\\("+[v2,v2,v2]+"\\)$"),JCe=new RegExp("^rgb\\("+[Qh,Qh,Qh]+"\\)$"),QCe=new RegExp("^rgba\\("+[v2,v2,v2,dT]+"\\)$"),tAe=new RegExp("^rgba\\("+[Qh,Qh,Qh,dT]+"\\)$"),eAe=new RegExp("^hsl\\("+[dT,Qh,Qh]+"\\)$"),rAe=new RegExp("^hsla\\("+[dT,Qh,Qh,dT]+"\\)$"),cAt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};Yp(tf,x2,{displayable:function(){return this.rgb().displayable()},toString:function(){return this.rgb()+""}});Yp(to,ZK,cg(tf,{brighter:function(e){return e=e==null?Sy:Math.pow(Sy,e),new to(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?ug:Math.pow(ug,e),new to(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return 0<=this.r&&this.r<=255&&0<=this.g&&this.g<=255&&0<=this.b&&this.b<=255&&0<=this.opacity&&this.opacity<=1},toString:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}}));Yp(Jh,JK,cg(tf,{brighter:function(e){return e=e==null?Sy:Math.pow(Sy,e),new Jh(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?ug:Math.pow(ug,e),new Jh(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new to(KK(e>=240?e-240:e+120,i,n),KK(e,i,n),KK(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1}}))});var iN,oN,QK=M(()=>{iN=Math.PI/180,oN=180/Math.PI});function iZ(e){if(e instanceof jp)return new jp(e.l,e.a,e.b,e.opacity);if(e instanceof hg){var t=e.h*iN;return new jp(e.l,Math.cos(t)*e.c,Math.sin(t)*e.c,e.opacity)}e instanceof to||(e=mT(e));var r=nZ(e.r),n=nZ(e.g),i=nZ(e.b),o=tZ((.4124564*r+.3575761*n+.1804375*i)/pAt),a=tZ((.2126729*r+.7151522*n+.072175*i)/dAt),s=tZ((.0193339*r+.119192*n+.9503041*i)/mAt);return new jp(116*a-16,500*(o-a),200*(a-s),e.opacity)}function sN(e,t,r,n){return arguments.length===1?iZ(e):new jp(e,t,r,n==null?1:n)}function jp(e,t,r,n){this.l=+e,this.a=+t,this.b=+r,this.opacity=+n}function tZ(e){return e>iAe?Math.pow(e,1/3):e/_At+gAt}function eZ(e){return e>b2?e*e*e:_At*(e-gAt)}function rZ(e){return 255*(e<=.0031308?12.92*e:1.055*Math.pow(e,1/2.4)-.055)}function nZ(e){return(e/=255)<=.04045?e/12.92:Math.pow((e+.055)/1.055,2.4)}function oAe(e){if(e instanceof hg)return new hg(e.h,e.c,e.l,e.opacity);e instanceof jp||(e=iZ(e));var t=Math.atan2(e.b,e.a)*oN;return new hg(t<0?t+360:t,Math.sqrt(e.a*e.a+e.b*e.b),e.l,e.opacity)}function oZ(e,t,r,n){return arguments.length===1?oAe(e):new hg(e,t,r,n==null?1:n)}function hg(e,t,r,n){this.h=+e,this.c=+t,this.l=+r,this.opacity=+n}var aN,pAt,dAt,mAt,gAt,b2,_At,iAe,yAt=M(()=>{rN();nN();QK();aN=18,pAt=.95047,dAt=1,mAt=1.08883,gAt=4/29,b2=6/29,_At=3*b2*b2,iAe=b2*b2*b2;Yp(jp,sN,cg(tf,{brighter:function(e){return new jp(this.l+aN*(e==null?1:e),this.a,this.b,this.opacity)},darker:function(e){return new jp(this.l-aN*(e==null?1:e),this.a,this.b,this.opacity)},rgb:function(){var e=(this.l+16)/116,t=isNaN(this.a)?e:e+this.a/500,r=isNaN(this.b)?e:e-this.b/200;return e=dAt*eZ(e),t=pAt*eZ(t),r=mAt*eZ(r),new to(rZ(3.2404542*t-1.5371385*e-.4985314*r),rZ(-.969266*t+1.8760108*e+.041556*r),rZ(.0556434*t-.2040259*e+1.0572252*r),this.opacity)}}));Yp(hg,oZ,cg(tf,{brighter:function(e){return new hg(this.h,this.c,this.l+aN*(e==null?1:e),this.opacity)},darker:function(e){return new hg(this.h,this.c,this.l-aN*(e==null?1:e),this.opacity)},rgb:function(){return iZ(this).rgb()}}))});function aAe(e){if(e instanceof My)return new My(e.h,e.s,e.l,e.opacity);e instanceof to||(e=mT(e));var t=e.r/255,r=e.g/255,n=e.b/255,i=(bAt*n+vAt*t-xAt*r)/(bAt+vAt-xAt),o=n-i,a=(gT*(r-i)-sZ*o)/lN,s=Math.sqrt(a*a+o*o)/(gT*i*(1-i)),l=s?Math.atan2(a,o)*oN-120:NaN;return new My(l<0?l+360:l,s,i,e.opacity)}function cN(e,t,r,n){return arguments.length===1?aAe(e):new My(e,t,r,n==null?1:n)}function My(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}var wAt,aZ,sZ,lN,gT,vAt,xAt,bAt,SAt=M(()=>{rN();nN();QK();wAt=-.14861,aZ=1.78277,sZ=-.29227,lN=-.90649,gT=1.97294,vAt=gT*lN,xAt=gT*aZ,bAt=aZ*sZ-lN*wAt;Yp(My,cN,cg(tf,{brighter:function(e){return e=e==null?Sy:Math.pow(Sy,e),new My(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?ug:Math.pow(ug,e),new My(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=isNaN(this.h)?0:(this.h+120)*iN,t=+this.l,r=isNaN(this.s)?0:this.s*t*(1-t),n=Math.cos(e),i=Math.sin(e);return new to(255*(t+r*(wAt*n+aZ*i)),255*(t+r*(sZ*n+lN*i)),255*(t+r*(gT*n)),this.opacity)}}))});var MAt=M(()=>{nN();yAt();SAt()});function TAt(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r)throw new Error("illegal type: "+n);r[n]=[]}return new uN(r)}function uN(e){this._=e}function lAe(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function cAe(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function EAt(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=sAe,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var sAe,CAt,AAt=M(()=>{sAe={value:function(){}};uN.prototype=TAt.prototype={constructor:uN,on:function(e,t){var r=this._,n=lAe(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=cAe(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=EAt(r[i],e.name,t);else if(t==null)for(i in r)r[i]=EAt(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new uN(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};CAt=TAt});var PAt=M(()=>{AAt()});function LAt(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r||/[\s.]/.test(n))throw new Error("illegal type: "+n);r[n]=[]}return new hN(r)}function hN(e){this._=e}function hAe(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function fAe(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function IAt(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=uAe,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var uAe,lZ,kAt=M(()=>{uAe={value:function(){}};hN.prototype=LAt.prototype={constructor:hN,on:function(e,t){var r=this._,n=hAe(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=fAe(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=IAt(r[i],e.name,t);else if(t==null)for(i in r)r[i]=IAt(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new hN(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};lZ=LAt});var RAt=M(()=>{kAt()});var fN,cZ,uZ=M(()=>{fN="http://www.w3.org/1999/xhtml",cZ={svg:"http://www.w3.org/2000/svg",xhtml:fN,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"}});function pN(e){var t=e+="",r=t.indexOf(":");return r>=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),cZ.hasOwnProperty(t)?{space:cZ[t],local:e}:e}var hZ=M(()=>{uZ()});function pAe(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===fN&&t.documentElement.namespaceURI===fN?t.createElement(e):t.createElementNS(r,e)}}function dAe(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function dN(e){var t=pN(e);return(t.local?dAe:pAe)(t)}var fZ=M(()=>{hZ();uZ()});function mAe(){}function mN(e){return e==null?mAe:function(){return this.querySelector(e)}}var pZ=M(()=>{});function NAt(e){typeof e!="function"&&(e=mN(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=new Array(a),l,c,u=0;u<a;++u)(l=o[u])&&(c=e.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),s[u]=c);return new di(n,this._parents)}var DAt=M(()=>{ef();pZ()});function gAe(){return[]}function OAt(e){return e==null?gAe:function(){return this.querySelectorAll(e)}}var zAt=M(()=>{});function FAt(e){typeof e!="function"&&(e=OAt(e));for(var t=this._groups,r=t.length,n=[],i=[],o=0;o<r;++o)for(var a=t[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&(n.push(e.call(l,l.__data__,c,a)),i.push(l));return new di(n,i)}var BAt=M(()=>{ef();zAt()});function HAt(e){return function(){return this.matches(e)}}var VAt=M(()=>{});function UAt(e){typeof e!="function"&&(e=HAt(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new di(n,this._parents)}var qAt=M(()=>{ef();VAt()});function gN(e){return new Array(e.length)}var dZ=M(()=>{});function GAt(){return new di(this._enter||this._groups.map(gN),this._parents)}function _T(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}var mZ=M(()=>{dZ();ef();_T.prototype={constructor:_T,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}}});function WAt(e){return function(){return e}}var YAt=M(()=>{});function _Ae(e,t,r,n,i,o){for(var a=0,s,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],n[a]=s):r[a]=new _T(e,o[a]);for(;a<l;++a)(s=t[a])&&(i[a]=s)}function yAe(e,t,r,n,i,o,a){var s,l,c={},u=t.length,h=o.length,f=new Array(u),p;for(s=0;s<u;++s)(l=t[s])&&(f[s]=p=jAt+a.call(l,l.__data__,s,t),p in c?i[s]=l:c[p]=l);for(s=0;s<h;++s)p=jAt+a.call(e,o[s],s,o),(l=c[p])?(n[s]=l,l.__data__=o[s],c[p]=null):r[s]=new _T(e,o[s]);for(s=0;s<u;++s)(l=t[s])&&c[f[s]]===l&&(i[s]=l)}function XAt(e,t){if(!e)return p=new Array(this.size()),c=-1,this.each(function(P){p[++c]=P}),p;var r=t?yAe:_Ae,n=this._parents,i=this._groups;typeof e!="function"&&(e=WAt(e));for(var o=i.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var u=n[c],h=i[c],f=h.length,p=e.call(u,u&&u.__data__,c,n),d=p.length,g=s[c]=new Array(d),_=a[c]=new Array(d),y=l[c]=new Array(f);r(u,h,g,_,y,p,t);for(var x=0,b=0,S,C;x<d;++x)if(S=g[x]){for(x>=b&&(b=x+1);!(C=_[b])&&++b<d;);S._next=C||null}}return a=new di(a,n),a._enter=s,a._exit=l,a}var jAt,$At=M(()=>{ef();mZ();YAt();jAt="$"});function KAt(){return new di(this._exit||this._groups.map(gN),this._parents)}var ZAt=M(()=>{dZ();ef()});function JAt(e,t,r){var n=this.enter(),i=this,o=this.exit();return n=typeof e=="function"?e(n):n.append(e+""),t!=null&&(i=t(i)),r==null?o.remove():r(o),n&&i?n.merge(i).order():i}var QAt=M(()=>{});function t4t(e){for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new di(a,this._parents)}var e4t=M(()=>{ef()});function r4t(){for(var e=this._groups,t=-1,r=e.length;++t<r;)for(var n=e[t],i=n.length-1,o=n[i],a;--i>=0;)(a=n[i])&&(o&&a.compareDocumentPosition(o)^4&&o.parentNode.insertBefore(a,o),o=a);return this}var n4t=M(()=>{});function i4t(e){e||(e=vAe);function t(h,f){return h&&f?e(h.__data__,f.__data__):!h-!f}for(var r=this._groups,n=r.length,i=new Array(n),o=0;o<n;++o){for(var a=r[o],s=a.length,l=i[o]=new Array(s),c,u=0;u<s;++u)(c=a[u])&&(l[u]=c);l.sort(t)}return new di(i,this._parents).order()}function vAe(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var o4t=M(()=>{ef()});function a4t(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}var s4t=M(()=>{});function l4t(){var e=new Array(this.size()),t=-1;return this.each(function(){e[++t]=this}),e}var c4t=M(()=>{});function u4t(){for(var e=this._groups,t=0,r=e.length;t<r;++t)for(var n=e[t],i=0,o=n.length;i<o;++i){var a=n[i];if(a)return a}return null}var h4t=M(()=>{});function f4t(){var e=0;return this.each(function(){++e}),e}var p4t=M(()=>{});function d4t(){return!this.node()}var m4t=M(()=>{});function g4t(e){for(var t=this._groups,r=0,n=t.length;r<n;++r)for(var i=t[r],o=0,a=i.length,s;o<a;++o)(s=i[o])&&e.call(s,s.__data__,o,i);return this}var _4t=M(()=>{});function xAe(e){return function(){this.removeAttribute(e)}}function bAe(e){return function(){this.removeAttributeNS(e.space,e.local)}}function wAe(e,t){return function(){this.setAttribute(e,t)}}function SAe(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function MAe(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttribute(e):this.setAttribute(e,r)}}function EAe(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,r)}}function y4t(e,t){var r=pN(e);if(arguments.length<2){var n=this.node();return r.local?n.getAttributeNS(r.space,r.local):n.getAttribute(r)}return this.each((t==null?r.local?bAe:xAe:typeof t=="function"?r.local?EAe:MAe:r.local?SAe:wAe)(r,t))}var v4t=M(()=>{hZ()});function _N(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}var gZ=M(()=>{});function TAe(e){return function(){this.style.removeProperty(e)}}function CAe(e,t,r){return function(){this.style.setProperty(e,t,r)}}function AAe(e,t,r){return function(){var n=t.apply(this,arguments);n==null?this.style.removeProperty(e):this.style.setProperty(e,n,r)}}function x4t(e,t,r){return arguments.length>1?this.each((t==null?TAe:typeof t=="function"?AAe:CAe)(e,t,r==null?"":r)):PAe(this.node(),e)}function PAe(e,t){return e.style.getPropertyValue(t)||_N(e).getComputedStyle(e,null).getPropertyValue(t)}var b4t=M(()=>{gZ()});function IAe(e){return function(){delete this[e]}}function LAe(e,t){return function(){this[e]=t}}function kAe(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function w4t(e,t){return arguments.length>1?this.each((t==null?IAe:typeof t=="function"?kAe:LAe)(e,t)):this.node()[e]}var S4t=M(()=>{});function M4t(e){return e.trim().split(/^|\s+/)}function _Z(e){return e.classList||new E4t(e)}function E4t(e){this._node=e,this._names=M4t(e.getAttribute("class")||"")}function T4t(e,t){for(var r=_Z(e),n=-1,i=t.length;++n<i;)r.add(t[n])}function C4t(e,t){for(var r=_Z(e),n=-1,i=t.length;++n<i;)r.remove(t[n])}function RAe(e){return function(){T4t(this,e)}}function NAe(e){return function(){C4t(this,e)}}function DAe(e,t){return function(){(t.apply(this,arguments)?T4t:C4t)(this,e)}}function A4t(e,t){var r=M4t(e+"");if(arguments.length<2){for(var n=_Z(this.node()),i=-1,o=r.length;++i<o;)if(!n.contains(r[i]))return!1;return!0}return this.each((typeof t=="function"?DAe:t?RAe:NAe)(r,t))}var P4t=M(()=>{E4t.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}}});function OAe(){this.textContent=""}function zAe(e){return function(){this.textContent=e}}function FAe(e){return function(){var t=e.apply(this,arguments);this.textContent=t==null?"":t}}function I4t(e){return arguments.length?this.each(e==null?OAe:(typeof e=="function"?FAe:zAe)(e)):this.node().textContent}var L4t=M(()=>{});function BAe(){this.innerHTML=""}function HAe(e){return function(){this.innerHTML=e}}function VAe(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t==null?"":t}}function k4t(e){return arguments.length?this.each(e==null?BAe:(typeof e=="function"?VAe:HAe)(e)):this.node().innerHTML}var R4t=M(()=>{});function UAe(){this.nextSibling&&this.parentNode.appendChild(this)}function N4t(){return this.each(UAe)}var D4t=M(()=>{});function qAe(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function O4t(){return this.each(qAe)}var z4t=M(()=>{});function F4t(e){var t=typeof e=="function"?e:dN(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}var B4t=M(()=>{fZ()});function GAe(){return null}function H4t(e,t){var r=typeof e=="function"?e:dN(e),n=t==null?GAe:typeof t=="function"?t:mN(t);return this.select(function(){return this.insertBefore(r.apply(this,arguments),n.apply(this,arguments)||null)})}var V4t=M(()=>{fZ();pZ()});function WAe(){var e=this.parentNode;e&&e.removeChild(this)}function U4t(){return this.each(WAe)}var q4t=M(()=>{});function YAe(){var e=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function jAe(){var e=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function G4t(e){return this.select(e?jAe:YAe)}var W4t=M(()=>{});function Y4t(e){return arguments.length?this.property("__data__",e):this.node().__data__}var j4t=M(()=>{});function XAe(e,t,r){return e=K4t(e,t,r),function(n){var i=n.relatedTarget;(!i||i!==this&&!(i.compareDocumentPosition(this)&8))&&e.call(this,n)}}function K4t(e,t,r){return function(n){var i=sn;sn=n;try{e.call(this,this.__data__,t,r)}finally{sn=i}}}function $Ae(e){return e.trim().split(/^|\s+/).map(function(t){var r="",n=t.indexOf(".");return n>=0&&(r=t.slice(n+1),t=t.slice(0,n)),{type:t,name:r}})}function KAe(e){return function(){var t=this.__on;if(!!t){for(var r=0,n=-1,i=t.length,o;r<i;++r)o=t[r],(!e.type||o.type===e.type)&&o.name===e.name?this.removeEventListener(o.type,o.listener,o.capture):t[++n]=o;++n?t.length=n:delete this.__on}}}function ZAe(e,t,r){var n=$4t.hasOwnProperty(e.type)?XAe:K4t;return function(i,o,a){var s=this.__on,l,c=n(t,o,a);if(s){for(var u=0,h=s.length;u<h;++u)if((l=s[u]).type===e.type&&l.name===e.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=r),l.value=t;return}}this.addEventListener(e.type,c,r),l={type:e.type,name:e.name,value:t,listener:c,capture:r},s?s.push(l):this.__on=[l]}}function Z4t(e,t,r){var n=$Ae(e+""),i,o=n.length,a;if(arguments.length<2){var s=this.node().__on;if(s){for(var l=0,c=s.length,u;l<c;++l)for(i=0,u=s[l];i<o;++i)if((a=n[i]).type===u.type&&a.name===u.name)return u.value}return}for(s=t?ZAe:KAe,r==null&&(r=!1),i=0;i<o;++i)this.each(s(n[i],t,r));return this}function yN(e,t,r,n){var i=sn;e.sourceEvent=sn,sn=e;try{return t.apply(r,n)}finally{sn=i}}var $4t,sn,X4t,vN=M(()=>{$4t={},sn=null;typeof document!="undefined"&&(X4t=document.documentElement,"onmouseenter"in X4t||($4t={mouseenter:"mouseover",mouseleave:"mouseout"}))});function J4t(e,t,r){var n=_N(e),i=n.CustomEvent;typeof i=="function"?i=new i(t,r):(i=n.document.createEvent("Event"),r?(i.initEvent(t,r.bubbles,r.cancelable),i.detail=r.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function JAe(e,t){return function(){return J4t(this,e,t)}}function QAe(e,t){return function(){return J4t(this,e,t.apply(this,arguments))}}function Q4t(e,t){return this.each((typeof t=="function"?QAe:JAe)(e,t))}var tPt=M(()=>{gZ()});function di(e,t){this._groups=e,this._parents=t}function t4e(){return new di([[document.documentElement]],yZ)}var yZ,ef=M(()=>{DAt();BAt();qAt();$At();mZ();ZAt();QAt();e4t();n4t();o4t();s4t();c4t();h4t();p4t();m4t();_4t();v4t();b4t();S4t();P4t();L4t();R4t();D4t();z4t();B4t();V4t();q4t();W4t();j4t();vN();tPt();yZ=[null];di.prototype=t4e.prototype={constructor:di,select:NAt,selectAll:FAt,filter:UAt,data:XAt,enter:GAt,exit:KAt,join:JAt,merge:t4t,order:r4t,sort:i4t,call:a4t,nodes:l4t,node:u4t,size:f4t,empty:d4t,each:g4t,attr:y4t,style:x4t,property:w4t,classed:A4t,text:I4t,html:k4t,raise:N4t,lower:O4t,append:F4t,insert:H4t,remove:U4t,clone:G4t,datum:Y4t,on:Z4t,dispatch:Q4t}});function Ey(e){return typeof e=="string"?new di([[document.querySelector(e)]],[document.documentElement]):new di([[e]],yZ)}var ePt=M(()=>{ef()});function xN(){for(var e=sn,t;t=e.sourceEvent;)e=t;return e}var vZ=M(()=>{vN()});function bN(e,t){var r=e.ownerSVGElement||e;if(r.createSVGPoint){var n=r.createSVGPoint();return n.x=t.clientX,n.y=t.clientY,n=n.matrixTransform(e.getScreenCTM().inverse()),[n.x,n.y]}var i=e.getBoundingClientRect();return[t.clientX-i.left-e.clientLeft,t.clientY-i.top-e.clientTop]}var xZ=M(()=>{});function bZ(e){var t=xN();return t.changedTouches&&(t=t.changedTouches[0]),bN(e,t)}var rPt=M(()=>{vZ();xZ()});function wZ(e,t,r){arguments.length<3&&(r=t,t=xN().changedTouches);for(var n=0,i=t?t.length:0,o;n<i;++n)if((o=t[n]).identifier===r)return bN(e,o);return null}var nPt=M(()=>{vZ();xZ()});var wN=M(()=>{rPt();ePt();nPt();vN()});function SN(){sn.stopImmediatePropagation()}function fg(){sn.preventDefault(),sn.stopImmediatePropagation()}var SZ=M(()=>{wN()});function MN(e){var t=e.document.documentElement,r=Ey(e).on("dragstart.drag",fg,!0);"onselectstart"in t?r.on("selectstart.drag",fg,!0):(t.__noselect=t.style.MozUserSelect,t.style.MozUserSelect="none")}function EN(e,t){var r=e.document.documentElement,n=Ey(e).on("dragstart.drag",null);t&&(n.on("click.drag",fg,!0),setTimeout(function(){n.on("click.drag",null)},0)),"onselectstart"in r?n.on("selectstart.drag",null):(r.style.MozUserSelect=r.__noselect,delete r.__noselect)}var MZ=M(()=>{wN();SZ()});function yT(e){return function(){return e}}var iPt=M(()=>{});function vT(e,t,r,n,i,o,a,s,l,c){this.target=e,this.type=t,this.subject=r,this.identifier=n,this.active=i,this.x=o,this.y=a,this.dx=s,this.dy=l,this._=c}var oPt=M(()=>{vT.prototype.on=function(){var e=this._.on.apply(this._,arguments);return e===this._?this:e}});function e4e(){return!sn.button}function r4e(){return this.parentNode}function n4e(e){return e==null?{x:sn.x,y:sn.y}:e}function i4e(){return"ontouchstart"in this}function aPt(){var e=e4e,t=r4e,r=n4e,n=i4e,i={},o=lZ("start","drag","end"),a=0,s,l,c,u,h=0;function f(S){S.on("mousedown.drag",p).filter(n).on("touchstart.drag",_).on("touchmove.drag",y).on("touchend.drag touchcancel.drag",x).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function p(){if(!(u||!e.apply(this,arguments))){var S=b("mouse",t.apply(this,arguments),bZ,this,arguments);!S||(Ey(sn.view).on("mousemove.drag",d,!0).on("mouseup.drag",g,!0),MN(sn.view),SN(),c=!1,s=sn.clientX,l=sn.clientY,S("start"))}}function d(){if(fg(),!c){var S=sn.clientX-s,C=sn.clientY-l;c=S*S+C*C>h}i.mouse("drag")}function g(){Ey(sn.view).on("mousemove.drag mouseup.drag",null),EN(sn.view,c),fg(),i.mouse("end")}function _(){if(!!e.apply(this,arguments)){var S=sn.changedTouches,C=t.apply(this,arguments),P=S.length,k,O;for(k=0;k<P;++k)(O=b(S[k].identifier,C,wZ,this,arguments))&&(SN(),O("start"))}}function y(){var S=sn.changedTouches,C=S.length,P,k;for(P=0;P<C;++P)(k=i[S[P].identifier])&&(fg(),k("drag"))}function x(){var S=sn.changedTouches,C=S.length,P,k;for(u&&clearTimeout(u),u=setTimeout(function(){u=null},500),P=0;P<C;++P)(k=i[S[P].identifier])&&(SN(),k("end"))}function b(S,C,P,k,O){var D=P(C,S),B,I,L,R=o.copy();if(!!yN(new vT(f,"beforestart",B,S,a,D[0],D[1],0,0,R),function(){return(sn.subject=B=r.apply(k,O))==null?!1:(I=B.x-D[0]||0,L=B.y-D[1]||0,!0)}))return function F(z){var U=D,W;switch(z){case"start":i[S]=F,W=a++;break;case"end":delete i[S],--a;case"drag":D=P(C,S),W=a;break}yN(new vT(f,z,B,S,W,D[0]+I,D[1]+L,D[0]-U[0],D[1]-U[1],R),R.apply,R,[z,k,O])}}return f.filter=function(S){return arguments.length?(e=typeof S=="function"?S:yT(!!S),f):e},f.container=function(S){return arguments.length?(t=typeof S=="function"?S:yT(S),f):t},f.subject=function(S){return arguments.length?(r=typeof S=="function"?S:yT(S),f):r},f.touchable=function(S){return arguments.length?(n=typeof S=="function"?S:yT(!!S),f):n},f.on=function(){var S=o.on.apply(o,arguments);return S===o?f:S},f.clickDistance=function(S){return arguments.length?(h=(S=+S)*S,f):Math.sqrt(h)},f}var sPt=M(()=>{RAt();wN();MZ();SZ();iPt();oPt()});var lPt=M(()=>{sPt();MZ()});function uPt(e){return new Function("d","return {"+e.map(function(t,r){return JSON.stringify(t)+": d["+r+"]"}).join(",")+"}")}function o4e(e,t){var r=uPt(e);return function(n,i){return t(r(n),i,e)}}function a4e(e){var t=Object.create(null),r=[];return e.forEach(function(n){for(var i in n)i in t||r.push(t[i]=i)}),r}function w2(e){var t=new RegExp('["'+e+`
\r]`),r=e.charCodeAt(0);function n(c,u){var h,f,p=i(c,function(d,g){if(h)return h(d,g-1);f=d,h=u?o4e(d,u):uPt(d)});return p.columns=f||[],p}function i(c,u){var h=[],f=c.length,p=0,d=0,g,_=f<=0,y=!1;c.charCodeAt(f-1)===xT&&--f,c.charCodeAt(f-1)===CZ&&--f;function x(){if(_)return EZ;if(y)return y=!1,cPt;var S,C=p,P;if(c.charCodeAt(C)===TZ){for(;p++<f&&c.charCodeAt(p)!==TZ||c.charCodeAt(++p)===TZ;);return(S=p)>=f?_=!0:(P=c.charCodeAt(p++))===xT?y=!0:P===CZ&&(y=!0,c.charCodeAt(p)===xT&&++p),c.slice(C+1,S-1).replace(/""/g,'"')}for(;p<f;){if((P=c.charCodeAt(S=p++))===xT)y=!0;else if(P===CZ)y=!0,c.charCodeAt(p)===xT&&++p;else if(P!==r)continue;return c.slice(C,S)}return _=!0,c.slice(C,f)}for(;(g=x())!==EZ;){for(var b=[];g!==cPt&&g!==EZ;)b.push(g),g=x();u&&(b=u(b,d++))==null||h.push(b)}return h}function o(c,u){return u==null&&(u=a4e(c)),[u.map(l).join(e)].concat(c.map(function(h){return u.map(function(f){return l(h[f])}).join(e)})).join(`
`)}function a(c){return c.map(s).join(`
`)}function s(c){return c.map(l).join(e)}function l(c){return c==null?"":t.test(c+="")?'"'+c.replace(/"/g,'""')+'"':c}return{parse:n,parseRows:i,format:o,formatRows:a}}var cPt,EZ,TZ,xT,CZ,TN=M(()=>{cPt={},EZ={},TZ=34,xT=10,CZ=13});var CN,hPt,fPt,pPt,dPt,mPt=M(()=>{TN();CN=w2(","),hPt=CN.parse,fPt=CN.parseRows,pPt=CN.format,dPt=CN.formatRows});var AN,gPt,_Pt,yPt,vPt,xPt=M(()=>{TN();AN=w2("	"),gPt=AN.parse,_Pt=AN.parseRows,yPt=AN.format,vPt=AN.formatRows});var bPt=M(()=>{TN();mPt();xPt()});function wPt(e){return+e}var SPt=M(()=>{});function MPt(e){return e*e}function EPt(e){return e*(2-e)}function AZ(e){return((e*=2)<=1?e*e:--e*(2-e)+1)/2}var TPt=M(()=>{});function CPt(e){return e*e*e}function APt(e){return--e*e*e+1}function PZ(e){return((e*=2)<=1?e*e*e:(e-=2)*e*e+2)/2}var PPt=M(()=>{});var IZ,IPt,LPt,LZ,kPt=M(()=>{IZ=3,IPt=function e(t){t=+t;function r(n){return Math.pow(n,t)}return r.exponent=e,r}(IZ),LPt=function e(t){t=+t;function r(n){return 1-Math.pow(1-n,t)}return r.exponent=e,r}(IZ),LZ=function e(t){t=+t;function r(n){return((n*=2)<=1?Math.pow(n,t):2-Math.pow(2-n,t))/2}return r.exponent=e,r}(IZ)});function DPt(e){return 1-Math.cos(e*NPt)}function OPt(e){return Math.sin(e*NPt)}function kZ(e){return(1-Math.cos(RPt*e))/2}var RPt,NPt,zPt=M(()=>{RPt=Math.PI,NPt=RPt/2});function FPt(e){return Math.pow(2,10*e-10)}function BPt(e){return 1-Math.pow(2,-10*e)}function RZ(e){return((e*=2)<=1?Math.pow(2,10*e-10):2-Math.pow(2,10-10*e))/2}var HPt=M(()=>{});function VPt(e){return 1-Math.sqrt(1-e*e)}function UPt(e){return Math.sqrt(1- --e*e)}function NZ(e){return((e*=2)<=1?1-Math.sqrt(1-e*e):Math.sqrt(1-(e-=2)*e)+1)/2}var qPt=M(()=>{});function GPt(e){return 1-S2(1-e)}function S2(e){return(e=+e)<DZ?PN*e*e:e<l4e?PN*(e-=s4e)*e+c4e:e<h4e?PN*(e-=u4e)*e+f4e:PN*(e-=p4e)*e+d4e}function WPt(e){return((e*=2)<=1?1-S2(1-e):S2(e-1)+1)/2}var DZ,s4e,l4e,c4e,u4e,h4e,f4e,p4e,d4e,PN,YPt=M(()=>{DZ=.36363636363636365,s4e=6/11,l4e=8/11,c4e=3/4,u4e=9/11,h4e=10/11,f4e=15/16,p4e=21/22,d4e=63/64,PN=1/DZ/DZ});var OZ,jPt,XPt,zZ,$Pt=M(()=>{OZ=1.70158,jPt=function e(t){t=+t;function r(n){return n*n*((t+1)*n-t)}return r.overshoot=e,r}(OZ),XPt=function e(t){t=+t;function r(n){return--n*n*((t+1)*n+t)+1}return r.overshoot=e,r}(OZ),zZ=function e(t){t=+t;function r(n){return((n*=2)<1?n*n*((t+1)*n-t):(n-=2)*n*((t+1)*n+t)+2)/2}return r.overshoot=e,r}(OZ)});var M2,FZ,BZ,KPt,HZ,ZPt,JPt=M(()=>{M2=2*Math.PI,FZ=1,BZ=.3,KPt=function e(t,r){var n=Math.asin(1/(t=Math.max(1,t)))*(r/=M2);function i(o){return t*Math.pow(2,10*--o)*Math.sin((n-o)/r)}return i.amplitude=function(o){return e(o,r*M2)},i.period=function(o){return e(t,o)},i}(FZ,BZ),HZ=function e(t,r){var n=Math.asin(1/(t=Math.max(1,t)))*(r/=M2);function i(o){return 1-t*Math.pow(2,-10*(o=+o))*Math.sin((o+n)/r)}return i.amplitude=function(o){return e(o,r*M2)},i.period=function(o){return e(t,o)},i}(FZ,BZ),ZPt=function e(t,r){var n=Math.asin(1/(t=Math.max(1,t)))*(r/=M2);function i(o){return((o=o*2-1)<0?t*Math.pow(2,10*o)*Math.sin((n-o)/r):2-t*Math.pow(2,-10*o)*Math.sin((n+o)/r))/2}return i.amplitude=function(o){return e(o,r*M2)},i.period=function(o){return e(t,o)},i}(FZ,BZ)});var QPt=M(()=>{SPt();TPt();PPt();kPt();zPt();HPt();qPt();YPt();$Pt();JPt()});function t6t(e,t){var r;e==null&&(e=0),t==null&&(t=0);function n(){var i,o=r.length,a,s=0,l=0;for(i=0;i<o;++i)a=r[i],s+=a.x,l+=a.y;for(s=s/o-e,l=l/o-t,i=0;i<o;++i)a=r[i],a.x-=s,a.y-=l}return n.initialize=function(i){r=i},n.x=function(i){return arguments.length?(e=+i,n):e},n.y=function(i){return arguments.length?(t=+i,n):t},n}var e6t=M(()=>{});function Fn(e){return function(){return e}}var Ty=M(()=>{});function Mu(){return(Math.random()-.5)*1e-6}var IN=M(()=>{});function r6t(e){var t=+this._x.call(null,e),r=+this._y.call(null,e);return n6t(this.cover(t,r),t,r,e)}function n6t(e,t,r,n){if(isNaN(t)||isNaN(r))return e;var i,o=e._root,a={data:n},s=e._x0,l=e._y0,c=e._x1,u=e._y1,h,f,p,d,g,_,y,x;if(!o)return e._root=a,e;for(;o.length;)if((g=t>=(h=(s+c)/2))?s=h:c=h,(_=r>=(f=(l+u)/2))?l=f:u=f,i=o,!(o=o[y=_<<1|g]))return i[y]=a,e;if(p=+e._x.call(null,o.data),d=+e._y.call(null,o.data),t===p&&r===d)return a.next=o,i?i[y]=a:e._root=a,e;do i=i?i[y]=new Array(4):e._root=new Array(4),(g=t>=(h=(s+c)/2))?s=h:c=h,(_=r>=(f=(l+u)/2))?l=f:u=f;while((y=_<<1|g)===(x=(d>=f)<<1|p>=h));return i[x]=o,i[y]=a,e}function i6t(e){var t,r,n=e.length,i,o,a=new Array(n),s=new Array(n),l=1/0,c=1/0,u=-1/0,h=-1/0;for(r=0;r<n;++r)isNaN(i=+this._x.call(null,t=e[r]))||isNaN(o=+this._y.call(null,t))||(a[r]=i,s[r]=o,i<l&&(l=i),i>u&&(u=i),o<c&&(c=o),o>h&&(h=o));if(l>u||c>h)return this;for(this.cover(l,c).cover(u,h),r=0;r<n;++r)n6t(this,a[r],s[r],e[r]);return this}var o6t=M(()=>{});function a6t(e,t){if(isNaN(e=+e)||isNaN(t=+t))return this;var r=this._x0,n=this._y0,i=this._x1,o=this._y1;if(isNaN(r))i=(r=Math.floor(e))+1,o=(n=Math.floor(t))+1;else{for(var a=i-r,s=this._root,l,c;r>e||e>=i||n>t||t>=o;)switch(c=(t<n)<<1|e<r,l=new Array(4),l[c]=s,s=l,a*=2,c){case 0:i=r+a,o=n+a;break;case 1:r=i-a,o=n+a;break;case 2:i=r+a,n=o-a;break;case 3:r=i-a,n=o-a;break}this._root&&this._root.length&&(this._root=s)}return this._x0=r,this._y0=n,this._x1=i,this._y1=o,this}var s6t=M(()=>{});function l6t(){var e=[];return this.visit(function(t){if(!t.length)do e.push(t.data);while(t=t.next)}),e}var c6t=M(()=>{});function u6t(e){return arguments.length?this.cover(+e[0][0],+e[0][1]).cover(+e[1][0],+e[1][1]):isNaN(this._x0)?void 0:[[this._x0,this._y0],[this._x1,this._y1]]}var h6t=M(()=>{});function So(e,t,r,n,i){this.node=e,this.x0=t,this.y0=r,this.x1=n,this.y1=i}var LN=M(()=>{});function f6t(e,t,r){var n,i=this._x0,o=this._y0,a,s,l,c,u=this._x1,h=this._y1,f=[],p=this._root,d,g;for(p&&f.push(new So(p,i,o,u,h)),r==null?r=1/0:(i=e-r,o=t-r,u=e+r,h=t+r,r*=r);d=f.pop();)if(!(!(p=d.node)||(a=d.x0)>u||(s=d.y0)>h||(l=d.x1)<i||(c=d.y1)<o))if(p.length){var _=(a+l)/2,y=(s+c)/2;f.push(new So(p[3],_,y,l,c),new So(p[2],a,y,_,c),new So(p[1],_,s,l,y),new So(p[0],a,s,_,y)),(g=(t>=y)<<1|e>=_)&&(d=f[f.length-1],f[f.length-1]=f[f.length-1-g],f[f.length-1-g]=d)}else{var x=e-+this._x.call(null,p.data),b=t-+this._y.call(null,p.data),S=x*x+b*b;if(S<r){var C=Math.sqrt(r=S);i=e-C,o=t-C,u=e+C,h=t+C,n=p.data}}return n}var p6t=M(()=>{LN()});function d6t(e){if(isNaN(u=+this._x.call(null,e))||isNaN(h=+this._y.call(null,e)))return this;var t,r=this._root,n,i,o,a=this._x0,s=this._y0,l=this._x1,c=this._y1,u,h,f,p,d,g,_,y;if(!r)return this;if(r.length)for(;;){if((d=u>=(f=(a+l)/2))?a=f:l=f,(g=h>=(p=(s+c)/2))?s=p:c=p,t=r,!(r=r[_=g<<1|d]))return this;if(!r.length)break;(t[_+1&3]||t[_+2&3]||t[_+3&3])&&(n=t,y=_)}for(;r.data!==e;)if(i=r,!(r=r.next))return this;return(o=r.next)&&delete r.next,i?(o?i.next=o:delete i.next,this):t?(o?t[_]=o:delete t[_],(r=t[0]||t[1]||t[2]||t[3])&&r===(t[3]||t[2]||t[1]||t[0])&&!r.length&&(n?n[y]=r:this._root=r),this):(this._root=o,this)}function m6t(e){for(var t=0,r=e.length;t<r;++t)this.remove(e[t]);return this}var g6t=M(()=>{});function _6t(){return this._root}var y6t=M(()=>{});function v6t(){var e=0;return this.visit(function(t){if(!t.length)do++e;while(t=t.next)}),e}var x6t=M(()=>{});function b6t(e){var t=[],r,n=this._root,i,o,a,s,l;for(n&&t.push(new So(n,this._x0,this._y0,this._x1,this._y1));r=t.pop();)if(!e(n=r.node,o=r.x0,a=r.y0,s=r.x1,l=r.y1)&&n.length){var c=(o+s)/2,u=(a+l)/2;(i=n[3])&&t.push(new So(i,c,u,s,l)),(i=n[2])&&t.push(new So(i,o,u,c,l)),(i=n[1])&&t.push(new So(i,c,a,s,u)),(i=n[0])&&t.push(new So(i,o,a,c,u))}return this}var w6t=M(()=>{LN()});function S6t(e){var t=[],r=[],n;for(this._root&&t.push(new So(this._root,this._x0,this._y0,this._x1,this._y1));n=t.pop();){var i=n.node;if(i.length){var o,a=n.x0,s=n.y0,l=n.x1,c=n.y1,u=(a+l)/2,h=(s+c)/2;(o=i[0])&&t.push(new So(o,a,s,u,h)),(o=i[1])&&t.push(new So(o,u,s,l,h)),(o=i[2])&&t.push(new So(o,a,h,u,c)),(o=i[3])&&t.push(new So(o,u,h,l,c))}r.push(n)}for(;n=r.pop();)e(n.node,n.x0,n.y0,n.x1,n.y1);return this}var M6t=M(()=>{LN()});function E6t(e){return e[0]}function T6t(e){return arguments.length?(this._x=e,this):this._x}var C6t=M(()=>{});function A6t(e){return e[1]}function P6t(e){return arguments.length?(this._y=e,this):this._y}var I6t=M(()=>{});function Cy(e,t,r){var n=new VZ(t==null?E6t:t,r==null?A6t:r,NaN,NaN,NaN,NaN);return e==null?n:n.addAll(e)}function VZ(e,t,r,n,i,o){this._x=e,this._y=t,this._x0=r,this._y0=n,this._x1=i,this._y1=o,this._root=void 0}function L6t(e){for(var t={data:e.data},r=t;e=e.next;)r=r.next={data:e.data};return t}var Ga,k6t=M(()=>{o6t();s6t();c6t();h6t();p6t();g6t();y6t();x6t();w6t();M6t();C6t();I6t();Ga=Cy.prototype=VZ.prototype;Ga.copy=function(){var e=new VZ(this._x,this._y,this._x0,this._y0,this._x1,this._y1),t=this._root,r,n;if(!t)return e;if(!t.length)return e._root=L6t(t),e;for(r=[{source:t,target:e._root=new Array(4)}];t=r.pop();)for(var i=0;i<4;++i)(n=t.source[i])&&(n.length?r.push({source:n,target:t.target[i]=new Array(4)}):t.target[i]=L6t(n));return e};Ga.add=r6t;Ga.addAll=i6t;Ga.cover=a6t;Ga.data=l6t;Ga.extent=u6t;Ga.find=f6t;Ga.remove=d6t;Ga.removeAll=m6t;Ga.root=_6t;Ga.size=v6t;Ga.visit=b6t;Ga.visitAfter=S6t;Ga.x=T6t;Ga.y=P6t});var UZ=M(()=>{k6t()});function m4e(e){return e.x+e.vx}function g4e(e){return e.y+e.vy}function R6t(e){var t,r,n=1,i=1;typeof e!="function"&&(e=Fn(e==null?1:+e));function o(){for(var l,c=t.length,u,h,f,p,d,g,_=0;_<i;++_)for(u=Cy(t,m4e,g4e).visitAfter(a),l=0;l<c;++l)h=t[l],d=r[h.index],g=d*d,f=h.x+h.vx,p=h.y+h.vy,u.visit(y);function y(x,b,S,C,P){var k=x.data,O=x.r,D=d+O;if(k){if(k.index>h.index){var B=f-k.x-k.vx,I=p-k.y-k.vy,L=B*B+I*I;L<D*D&&(B===0&&(B=Mu(),L+=B*B),I===0&&(I=Mu(),L+=I*I),L=(D-(L=Math.sqrt(L)))/L*n,h.vx+=(B*=L)*(D=(O*=O)/(g+O)),h.vy+=(I*=L)*D,k.vx-=B*(D=1-D),k.vy-=I*D)}return}return b>f+D||C<f-D||S>p+D||P<p-D}}function a(l){if(l.data)return l.r=r[l.data.index];for(var c=l.r=0;c<4;++c)l[c]&&l[c].r>l.r&&(l.r=l[c].r)}function s(){if(!!t){var l,c=t.length,u;for(r=new Array(c),l=0;l<c;++l)u=t[l],r[u.index]=+e(u,l,t)}}return o.initialize=function(l){t=l,s()},o.iterations=function(l){return arguments.length?(i=+l,o):i},o.strength=function(l){return arguments.length?(n=+l,o):n},o.radius=function(l){return arguments.length?(e=typeof l=="function"?l:Fn(+l),s(),o):e},o}var N6t=M(()=>{Ty();IN();UZ()});function kN(){}function D6t(e,t){var r=new kN;if(e instanceof kN)e.each(function(s,l){r.set(l,s)});else if(Array.isArray(e)){var n=-1,i=e.length,o;if(t==null)for(;++n<i;)r.set(n,e[n]);else for(;++n<i;)r.set(t(o=e[n],n,e),o)}else if(e)for(var a in e)r.set(a,e[a]);return r}var cl,pg,RN=M(()=>{cl="$";kN.prototype=D6t.prototype={constructor:kN,has:function(e){return cl+e in this},get:function(e){return this[cl+e]},set:function(e,t){return this[cl+e]=t,this},remove:function(e){var t=cl+e;return t in this&&delete this[t]},clear:function(){for(var e in this)e[0]===cl&&delete this[e]},keys:function(){var e=[];for(var t in this)t[0]===cl&&e.push(t.slice(1));return e},values:function(){var e=[];for(var t in this)t[0]===cl&&e.push(this[t]);return e},entries:function(){var e=[];for(var t in this)t[0]===cl&&e.push({key:t.slice(1),value:this[t]});return e},size:function(){var e=0;for(var t in this)t[0]===cl&&++e;return e},empty:function(){for(var e in this)if(e[0]===cl)return!1;return!0},each:function(e){for(var t in this)t[0]===cl&&e(this[t],t.slice(1),this)}};pg=D6t});var O6t=M(()=>{RN()});function NN(){}function _4e(e,t){var r=new NN;if(e instanceof NN)e.each(function(o){r.add(o)});else if(e){var n=-1,i=e.length;if(t==null)for(;++n<i;)r.add(e[n]);else for(;++n<i;)r.add(t(e[n],n,e))}return r}var Ay,z6t=M(()=>{RN();Ay=pg.prototype;NN.prototype=_4e.prototype={constructor:NN,has:Ay.has,add:function(e){return e+="",this[cl+e]=e,this},remove:Ay.remove,clear:Ay.clear,values:Ay.keys,size:Ay.size,empty:Ay.empty,each:Ay.each}});var F6t=M(()=>{});var B6t=M(()=>{});var H6t=M(()=>{});var qZ=M(()=>{O6t();z6t();RN();F6t();B6t();H6t()});function y4e(e){return e.index}function V6t(e,t){var r=e.get(t);if(!r)throw new Error("missing: "+t);return r}function U6t(e){var t=y4e,r=u,n,i=Fn(30),o,a,s,l,c=1;e==null&&(e=[]);function u(g){return 1/Math.min(s[g.source.index],s[g.target.index])}function h(g){for(var _=0,y=e.length;_<c;++_)for(var x=0,b,S,C,P,k,O,D;x<y;++x)b=e[x],S=b.source,C=b.target,P=C.x+C.vx-S.x-S.vx||Mu(),k=C.y+C.vy-S.y-S.vy||Mu(),O=Math.sqrt(P*P+k*k),O=(O-o[x])/O*g*n[x],P*=O,k*=O,C.vx-=P*(D=l[x]),C.vy-=k*D,S.vx+=P*(D=1-D),S.vy+=k*D}function f(){if(!!a){var g,_=a.length,y=e.length,x=pg(a,t),b;for(g=0,s=new Array(_);g<y;++g)b=e[g],b.index=g,typeof b.source!="object"&&(b.source=V6t(x,b.source)),typeof b.target!="object"&&(b.target=V6t(x,b.target)),s[b.source.index]=(s[b.source.index]||0)+1,s[b.target.index]=(s[b.target.index]||0)+1;for(g=0,l=new Array(y);g<y;++g)b=e[g],l[g]=s[b.source.index]/(s[b.source.index]+s[b.target.index]);n=new Array(y),p(),o=new Array(y),d()}}function p(){if(!!a)for(var g=0,_=e.length;g<_;++g)n[g]=+r(e[g],g,e)}function d(){if(!!a)for(var g=0,_=e.length;g<_;++g)o[g]=+i(e[g],g,e)}return h.initialize=function(g){a=g,f()},h.links=function(g){return arguments.length?(e=g,f(),h):e},h.id=function(g){return arguments.length?(t=g,h):t},h.iterations=function(g){return arguments.length?(c=+g,h):c},h.strength=function(g){return arguments.length?(r=typeof g=="function"?g:Fn(+g),p(),h):r},h.distance=function(g){return arguments.length?(i=typeof g=="function"?g:Fn(+g),d(),h):i},h}var q6t=M(()=>{Ty();IN();qZ()});function W6t(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r||/[\s.]/.test(n))throw new Error("illegal type: "+n);r[n]=[]}return new DN(r)}function DN(e){this._=e}function x4e(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function b4e(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function G6t(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=v4e,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var v4e,GZ,Y6t=M(()=>{v4e={value:function(){}};DN.prototype=W6t.prototype={constructor:DN,on:function(e,t){var r=this._,n=x4e(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=b4e(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=G6t(r[i],e.name,t);else if(t==null)for(i in r)r[i]=G6t(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new DN(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};GZ=W6t});var j6t=M(()=>{Y6t()});function jZ(){return Py||(K6t(w4e),Py=MT.now()+FN)}function w4e(){Py=0}function WZ(){this._call=this._time=this._next=null}function BN(e,t,r){var n=new WZ;return n.restart(e,t,r),n}function Z6t(){jZ(),++E2;for(var e=ON,t;e;)(t=Py-e._time)>=0&&e._call.call(null,t),e=e._next;--E2}function X6t(){Py=(zN=MT.now())+FN,E2=wT=0;try{Z6t()}finally{E2=0,M4e(),Py=0}}function S4e(){var e=MT.now(),t=e-zN;t>$6t&&(FN-=t,zN=e)}function M4e(){for(var e,t=ON,r,n=1/0;t;)t._call?(n>t._time&&(n=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:ON=r);ST=e,YZ(n)}function YZ(e){if(!E2){wT&&(wT=clearTimeout(wT));var t=e-Py;t>24?(e<1/0&&(wT=setTimeout(X6t,e-MT.now()-FN)),bT&&(bT=clearInterval(bT))):(bT||(zN=MT.now(),bT=setInterval(S4e,$6t)),E2=1,K6t(X6t))}}var E2,wT,bT,$6t,ON,ST,zN,Py,FN,MT,K6t,J6t=M(()=>{E2=0,wT=0,bT=0,$6t=1e3,zN=0,Py=0,FN=0,MT=typeof performance=="object"&&performance.now?performance:Date,K6t=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};WZ.prototype=BN.prototype={constructor:WZ,restart:function(e,t,r){if(typeof e!="function")throw new TypeError("callback is not a function");r=(r==null?jZ():+r)+(t==null?0:+t),!this._next&&ST!==this&&(ST?ST._next=this:ON=this,ST=this),this._call=e,this._time=r,YZ()},stop:function(){this._call&&(this._call=null,this._time=1/0,YZ())}}});var Q6t=M(()=>{J6t()});function tIt(e){return e.x}function eIt(e){return e.y}function rIt(e){var t,r=1,n=.001,i=1-Math.pow(n,1/300),o=0,a=.6,s=pg(),l=BN(u),c=GZ("tick","end");e==null&&(e=[]);function u(){h(),c.call("tick",t),r<n&&(l.stop(),c.call("end",t))}function h(){var d,g=e.length,_;for(r+=(o-r)*i,s.each(function(y){y(r)}),d=0;d<g;++d)_=e[d],_.fx==null?_.x+=_.vx*=a:(_.x=_.fx,_.vx=0),_.fy==null?_.y+=_.vy*=a:(_.y=_.fy,_.vy=0)}function f(){for(var d=0,g=e.length,_;d<g;++d){if(_=e[d],_.index=d,isNaN(_.x)||isNaN(_.y)){var y=E4e*Math.sqrt(d),x=d*T4e;_.x=y*Math.cos(x),_.y=y*Math.sin(x)}(isNaN(_.vx)||isNaN(_.vy))&&(_.vx=_.vy=0)}}function p(d){return d.initialize&&d.initialize(e),d}return f(),t={tick:h,restart:function(){return l.restart(u),t},stop:function(){return l.stop(),t},nodes:function(d){return arguments.length?(e=d,f(),s.each(p),t):e},alpha:function(d){return arguments.length?(r=+d,t):r},alphaMin:function(d){return arguments.length?(n=+d,t):n},alphaDecay:function(d){return arguments.length?(i=+d,t):+i},alphaTarget:function(d){return arguments.length?(o=+d,t):o},velocityDecay:function(d){return arguments.length?(a=1-d,t):1-a},force:function(d,g){return arguments.length>1?(g==null?s.remove(d):s.set(d,p(g)),t):s.get(d)},find:function(d,g,_){var y=0,x=e.length,b,S,C,P,k;for(_==null?_=1/0:_*=_,y=0;y<x;++y)P=e[y],b=d-P.x,S=g-P.y,C=b*b+S*S,C<_&&(k=P,_=C);return k},on:function(d,g){return arguments.length>1?(c.on(d,g),t):c.on(d)}}}var E4e,T4e,XZ=M(()=>{j6t();qZ();Q6t();E4e=10,T4e=Math.PI*(3-Math.sqrt(5))});function nIt(){var e,t,r,n=Fn(-30),i,o=1,a=1/0,s=.81;function l(f){var p,d=e.length,g=Cy(e,tIt,eIt).visitAfter(u);for(r=f,p=0;p<d;++p)t=e[p],g.visit(h)}function c(){if(!!e){var f,p=e.length,d;for(i=new Array(p),f=0;f<p;++f)d=e[f],i[d.index]=+n(d,f,e)}}function u(f){var p=0,d,g,_=0,y,x,b;if(f.length){for(y=x=b=0;b<4;++b)(d=f[b])&&(g=Math.abs(d.value))&&(p+=d.value,_+=g,y+=g*d.x,x+=g*d.y);f.x=y/_,f.y=x/_}else{d=f,d.x=d.data.x,d.y=d.data.y;do p+=i[d.data.index];while(d=d.next)}f.value=p}function h(f,p,d,g){if(!f.value)return!0;var _=f.x-t.x,y=f.y-t.y,x=g-p,b=_*_+y*y;if(x*x/s<b)return b<a&&(_===0&&(_=Mu(),b+=_*_),y===0&&(y=Mu(),b+=y*y),b<o&&(b=Math.sqrt(o*b)),t.vx+=_*f.value*r/b,t.vy+=y*f.value*r/b),!0;if(f.length||b>=a)return;(f.data!==t||f.next)&&(_===0&&(_=Mu(),b+=_*_),y===0&&(y=Mu(),b+=y*y),b<o&&(b=Math.sqrt(o*b)));do f.data!==t&&(x=i[f.data.index]*r/b,t.vx+=_*x,t.vy+=y*x);while(f=f.next)}return l.initialize=function(f){e=f,c()},l.strength=function(f){return arguments.length?(n=typeof f=="function"?f:Fn(+f),c(),l):n},l.distanceMin=function(f){return arguments.length?(o=f*f,l):Math.sqrt(o)},l.distanceMax=function(f){return arguments.length?(a=f*f,l):Math.sqrt(a)},l.theta=function(f){return arguments.length?(s=f*f,l):Math.sqrt(s)},l}var iIt=M(()=>{Ty();IN();UZ();XZ()});function oIt(e,t,r){var n,i=Fn(.1),o,a;typeof e!="function"&&(e=Fn(+e)),t==null&&(t=0),r==null&&(r=0);function s(c){for(var u=0,h=n.length;u<h;++u){var f=n[u],p=f.x-t||1e-6,d=f.y-r||1e-6,g=Math.sqrt(p*p+d*d),_=(a[u]-g)*o[u]*c/g;f.vx+=p*_,f.vy+=d*_}}function l(){if(!!n){var c,u=n.length;for(o=new Array(u),a=new Array(u),c=0;c<u;++c)a[c]=+e(n[c],c,n),o[c]=isNaN(a[c])?0:+i(n[c],c,n)}}return s.initialize=function(c){n=c,l()},s.strength=function(c){return arguments.length?(i=typeof c=="function"?c:Fn(+c),l(),s):i},s.radius=function(c){return arguments.length?(e=typeof c=="function"?c:Fn(+c),l(),s):e},s.x=function(c){return arguments.length?(t=+c,s):t},s.y=function(c){return arguments.length?(r=+c,s):r},s}var aIt=M(()=>{Ty()});function sIt(e){var t=Fn(.1),r,n,i;typeof e!="function"&&(e=Fn(e==null?0:+e));function o(s){for(var l=0,c=r.length,u;l<c;++l)u=r[l],u.vx+=(i[l]-u.x)*n[l]*s}function a(){if(!!r){var s,l=r.length;for(n=new Array(l),i=new Array(l),s=0;s<l;++s)n[s]=isNaN(i[s]=+e(r[s],s,r))?0:+t(r[s],s,r)}}return o.initialize=function(s){r=s,a()},o.strength=function(s){return arguments.length?(t=typeof s=="function"?s:Fn(+s),a(),o):t},o.x=function(s){return arguments.length?(e=typeof s=="function"?s:Fn(+s),a(),o):e},o}var lIt=M(()=>{Ty()});function cIt(e){var t=Fn(.1),r,n,i;typeof e!="function"&&(e=Fn(e==null?0:+e));function o(s){for(var l=0,c=r.length,u;l<c;++l)u=r[l],u.vy+=(i[l]-u.y)*n[l]*s}function a(){if(!!r){var s,l=r.length;for(n=new Array(l),i=new Array(l),s=0;s<l;++s)n[s]=isNaN(i[s]=+e(r[s],s,r))?0:+t(r[s],s,r)}}return o.initialize=function(s){r=s,a()},o.strength=function(s){return arguments.length?(t=typeof s=="function"?s:Fn(+s),a(),o):t},o.y=function(s){return arguments.length?(e=typeof s=="function"?s:Fn(+s),a(),o):e},o}var uIt=M(()=>{Ty()});var hIt=M(()=>{e6t();N6t();q6t();iIt();aIt();XZ();lIt();uIt()});function Iy(e,t){if((r=(e=t?e.toExponential(t-1):e.toExponential()).indexOf("e"))<0)return null;var r,n=e.slice(0,r);return[n.length>1?n[0]+n.slice(2):n,+e.slice(r+1)]}var HN=M(()=>{});function rf(e){return e=Iy(Math.abs(e)),e?e[1]:NaN}var ET=M(()=>{HN()});function fIt(e,t){return function(r,n){for(var i=r.length,o=[],a=0,s=e[0],l=0;i>0&&s>0&&(l+s+1>n&&(s=Math.max(1,n-l)),o.push(r.substring(i-=s,i+s)),!((l+=s+1)>n));)s=e[a=(a+1)%e.length];return o.reverse().join(t)}}var pIt=M(()=>{});function dIt(e){return function(t){return t.replace(/[0-9]/g,function(r){return e[+r]})}}var mIt=M(()=>{});function gIt(e,t){e=e.toPrecision(t);t:for(var r=e.length,n=1,i=-1,o;n<r;++n)switch(e[n]){case".":i=o=n;break;case"0":i===0&&(i=n),o=n;break;case"e":break t;default:i>0&&(i=0);break}return i>0?e.slice(0,i)+e.slice(o+1):e}var _It=M(()=>{});function yIt(e,t){var r=Iy(e,t);if(!r)return e+"";var n=r[0],i=r[1],o=i-($Z=Math.max(-8,Math.min(8,Math.floor(i/3)))*3)+1,a=n.length;return o===a?n:o>a?n+new Array(o-a+1).join("0"):o>0?n.slice(0,o)+"."+n.slice(o):"0."+new Array(1-o).join("0")+Iy(e,Math.max(0,t+o-1))[0]}var $Z,KZ=M(()=>{HN()});function ZZ(e,t){var r=Iy(e,t);if(!r)return e+"";var n=r[0],i=r[1];return i<0?"0."+new Array(-i).join("0")+n:n.length>i+1?n.slice(0,i+1)+"."+n.slice(i+1):n+new Array(i-n.length+2).join("0")}var vIt=M(()=>{HN()});var VN,JZ=M(()=>{_It();KZ();vIt();VN={"":gIt,"%":function(e,t){return(e*100).toFixed(t)},b:function(e){return Math.round(e).toString(2)},c:function(e){return e+""},d:function(e){return Math.round(e).toString(10)},e:function(e,t){return e.toExponential(t)},f:function(e,t){return e.toFixed(t)},g:function(e,t){return e.toPrecision(t)},o:function(e){return Math.round(e).toString(8)},p:function(e,t){return ZZ(e*100,t)},r:ZZ,s:yIt,X:function(e){return Math.round(e).toString(16).toUpperCase()},x:function(e){return Math.round(e).toString(16)}}});function Ly(e){return new QZ(e)}function QZ(e){if(!(t=C4e.exec(e)))throw new Error("invalid format: "+e);var t,r=t[1]||" ",n=t[2]||">",i=t[3]||"-",o=t[4]||"",a=!!t[5],s=t[6]&&+t[6],l=!!t[7],c=t[8]&&+t[8].slice(1),u=t[9]||"";u==="n"?(l=!0,u="g"):VN[u]||(u=""),(a||r==="0"&&n==="=")&&(a=!0,r="0",n="="),this.fill=r,this.align=n,this.sign=i,this.symbol=o,this.zero=a,this.width=s,this.comma=l,this.precision=c,this.type=u}var C4e,tJ=M(()=>{JZ();C4e=/^(?:(.)?([<>=^]))?([+\-\( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?([a-z%])?$/i;Ly.prototype=QZ.prototype;QZ.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(this.width==null?"":Math.max(1,this.width|0))+(this.comma?",":"")+(this.precision==null?"":"."+Math.max(0,this.precision|0))+this.type}});function eJ(e){return e}var xIt=M(()=>{});function UN(e){var t=e.grouping&&e.thousands?fIt(e.grouping,e.thousands):eJ,r=e.currency,n=e.decimal,i=e.numerals?dIt(e.numerals):eJ,o=e.percent||"%";function a(l){l=Ly(l);var c=l.fill,u=l.align,h=l.sign,f=l.symbol,p=l.zero,d=l.width,g=l.comma,_=l.precision,y=l.type,x=f==="$"?r[0]:f==="#"&&/[boxX]/.test(y)?"0"+y.toLowerCase():"",b=f==="$"?r[1]:/[%p]/.test(y)?o:"",S=VN[y],C=!y||/[defgprs%]/.test(y);_=_==null?y?6:12:/[gprs]/.test(y)?Math.max(1,Math.min(21,_)):Math.max(0,Math.min(20,_));function P(k){var O=x,D=b,B,I,L;if(y==="c")D=S(k)+D,k="";else{k=+k;var R=k<0;if(k=S(Math.abs(k),_),R&&+k==0&&(R=!1),O=(R?h==="("?h:"-":h==="-"||h==="("?"":h)+O,D=(y==="s"?bIt[8+$Z/3]:"")+D+(R&&h==="("?")":""),C){for(B=-1,I=k.length;++B<I;)if(L=k.charCodeAt(B),48>L||L>57){D=(L===46?n+k.slice(B+1):k.slice(B))+D,k=k.slice(0,B);break}}}g&&!p&&(k=t(k,1/0));var F=O.length+k.length+D.length,z=F<d?new Array(d-F+1).join(c):"";switch(g&&p&&(k=t(z+k,z.length?d-D.length:1/0),z=""),u){case"<":k=O+k+D+z;break;case"=":k=O+z+k+D;break;case"^":k=z.slice(0,F=z.length>>1)+O+k+D+z.slice(F);break;default:k=z+O+k+D;break}return i(k)}return P.toString=function(){return l+""},P}function s(l,c){var u=a((l=Ly(l),l.type="f",l)),h=Math.max(-8,Math.min(8,Math.floor(rf(c)/3)))*3,f=Math.pow(10,-h),p=bIt[8+h/3];return function(d){return u(f*d)+p}}return{format:a,formatPrefix:s}}var bIt,rJ=M(()=>{ET();pIt();mIt();tJ();JZ();KZ();xIt();bIt=["y","z","a","f","p","n","\xB5","m","","k","M","G","T","P","E","Z","Y"]});function GN(e){return qN=UN(e),nJ=qN.format,iJ=qN.formatPrefix,qN}var qN,nJ,iJ,wIt=M(()=>{rJ();GN({decimal:".",thousands:",",grouping:[3],currency:["$",""]})});function SIt(e){return Math.max(0,-rf(Math.abs(e)))}var MIt=M(()=>{ET()});function EIt(e,t){return Math.max(0,Math.max(-8,Math.min(8,Math.floor(rf(t)/3)))*3-rf(Math.abs(e)))}var TIt=M(()=>{ET()});function CIt(e,t){return e=Math.abs(e),t=Math.abs(t)-e,Math.max(0,rf(t)-rf(e))+1}var AIt=M(()=>{ET()});var PIt=M(()=>{wIt();rJ();tJ();MIt();TIt();AIt()});function Cs(){return new YN}function YN(){this.reset()}function IIt(e,t,r){var n=e.s=t+r,i=n-t,o=n-i;e.t=t-o+(r-i)}var WN,ky=M(()=>{YN.prototype={constructor:YN,reset:function(){this.s=this.t=0},add:function(e){IIt(WN,e,this.t),IIt(this,WN.s,this.s),this.s?this.t+=WN.t:this.s=WN.t},valueOf:function(){return this.s}};WN=new YN});function $N(e){return e>1?0:e<-1?rr:Math.acos(e)}function Jn(e){return e>1?Bn:e<-1?-Bn:Math.asin(e)}function aJ(e){return(e=Jt(e/2))*e}var ce,oJ,rr,Bn,T2,Bi,Ur,we,Ye,yc,Sn,ae,TT,jN,Ry,XN,Jt,dg,Rr,C2,lr=M(()=>{ce=1e-6,oJ=1e-12,rr=Math.PI,Bn=rr/2,T2=rr/4,Bi=rr*2,Ur=180/rr,we=rr/180,Ye=Math.abs,yc=Math.atan,Sn=Math.atan2,ae=Math.cos,TT=Math.ceil,jN=Math.exp,Ry=Math.log,XN=Math.pow,Jt=Math.sin,dg=Math.sign||function(e){return e>0?1:e<0?-1:0},Rr=Math.sqrt,C2=Math.tan});function qr(){}var Xp=M(()=>{});function KN(e,t){e&&kIt.hasOwnProperty(e.type)&&kIt[e.type](e,t)}function sJ(e,t,r){var n=-1,i=e.length-r,o;for(t.lineStart();++n<i;)o=e[n],t.point(o[0],o[1],o[2]);t.lineEnd()}function RIt(e,t){var r=-1,n=e.length;for(t.polygonStart();++r<n;)sJ(e[r],t,1);t.polygonEnd()}function Mo(e,t){e&&LIt.hasOwnProperty(e.type)?LIt[e.type](e,t):KN(e,t)}var LIt,kIt,mg=M(()=>{LIt={Feature:function(e,t){KN(e.geometry,t)},FeatureCollection:function(e,t){for(var r=e.features,n=-1,i=r.length;++n<i;)KN(r[n].geometry,t)}},kIt={Sphere:function(e,t){t.sphere()},Point:function(e,t){e=e.coordinates,t.point(e[0],e[1],e[2])},MultiPoint:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)e=r[n],t.point(e[0],e[1],e[2])},LineString:function(e,t){sJ(e.coordinates,t,0)},MultiLineString:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)sJ(r[n],t,0)},Polygon:function(e,t){RIt(e.coordinates,t)},MultiPolygon:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)RIt(r[n],t)},GeometryCollection:function(e,t){for(var r=e.geometries,n=-1,i=r.length;++n<i;)KN(r[n],t)}}});function A4e(){Eu.point=I4e}function P4e(){OIt(NIt,DIt)}function I4e(e,t){Eu.point=OIt,NIt=e,DIt=t,e*=we,t*=we,lJ=e,cJ=ae(t=t/2+T2),uJ=Jt(t)}function OIt(e,t){e*=we,t*=we,t=t/2+T2;var r=e-lJ,n=r>=0?1:-1,i=n*r,o=ae(t),a=Jt(t),s=uJ*a,l=cJ*o+s*ae(i),c=s*n*Jt(i);CT.add(Sn(c,l)),lJ=e,cJ=o,uJ=a}function zIt(e){return ZN.reset(),Mo(e,Eu),ZN*2}var CT,ZN,NIt,DIt,lJ,cJ,uJ,Eu,hJ=M(()=>{ky();lr();Xp();mg();CT=Cs(),ZN=Cs(),Eu={point:qr,lineStart:qr,lineEnd:qr,polygonStart:function(){CT.reset(),Eu.lineStart=A4e,Eu.lineEnd=P4e},polygonEnd:function(){var e=+CT;ZN.add(e<0?Bi+e:e),this.lineStart=this.lineEnd=this.point=qr},sphere:function(){ZN.add(Bi)}}});function Ny(e){return[Sn(e[1],e[0]),Jn(e[2])]}function vc(e){var t=e[0],r=e[1],n=ae(r);return[n*ae(t),n*Jt(t),Jt(r)]}function AT(e,t){return e[0]*t[0]+e[1]*t[1]+e[2]*t[2]}function $p(e,t){return[e[1]*t[2]-e[2]*t[1],e[2]*t[0]-e[0]*t[2],e[0]*t[1]-e[1]*t[0]]}function JN(e,t){e[0]+=t[0],e[1]+=t[1],e[2]+=t[2]}function PT(e,t){return[e[0]*t,e[1]*t,e[2]*t]}function Dy(e){var t=Rr(e[0]*e[0]+e[1]*e[1]+e[2]*e[2]);e[0]/=t,e[1]/=t,e[2]/=t}var A2=M(()=>{lr()});function fJ(e,t){gg.push(Zp=[mi=e,Ei=e]),t<hl&&(hl=t),t>xc&&(xc=t)}function qIt(e,t){var r=vc([e*we,t*we]);if(P2){var n=$p(P2,r),i=[n[1],-n[0],0],o=$p(i,n);Dy(o),o=Ny(o);var a=e-Oy,s=a>0?1:-1,l=o[0]*Ur*s,c,u=Ye(a)>180;u^(s*Oy<l&&l<s*e)?(c=o[1]*Ur,c>xc&&(xc=c)):(l=(l+360)%360-180,u^(s*Oy<l&&l<s*e)?(c=-o[1]*Ur,c<hl&&(hl=c)):(t<hl&&(hl=t),t>xc&&(xc=t))),u?e<Oy?ul(mi,e)>ul(mi,Ei)&&(Ei=e):ul(e,Ei)>ul(mi,Ei)&&(mi=e):Ei>=mi?(e<mi&&(mi=e),e>Ei&&(Ei=e)):e>Oy?ul(mi,e)>ul(mi,Ei)&&(Ei=e):ul(e,Ei)>ul(mi,Ei)&&(mi=e)}else gg.push(Zp=[mi=e,Ei=e]);t<hl&&(hl=t),t>xc&&(xc=t),P2=r,Oy=e}function FIt(){Kp.point=qIt}function BIt(){Zp[0]=mi,Zp[1]=Ei,Kp.point=fJ,P2=null}function GIt(e,t){if(P2){var r=e-Oy;IT.add(Ye(r)>180?r+(r>0?360:-360):r)}else VIt=e,UIt=t;Eu.point(e,t),qIt(e,t)}function L4e(){Eu.lineStart()}function k4e(){GIt(VIt,UIt),Eu.lineEnd(),Ye(IT)>ce&&(mi=-(Ei=180)),Zp[0]=mi,Zp[1]=Ei,P2=null}function ul(e,t){return(t-=e)<0?t+360:t}function R4e(e,t){return e[0]-t[0]}function HIt(e,t){return e[0]<=e[1]?e[0]<=t&&t<=e[1]:t<e[0]||e[1]<t}function WIt(e){var t,r,n,i,o,a,s;if(xc=Ei=-(mi=hl=1/0),gg=[],Mo(e,Kp),r=gg.length){for(gg.sort(R4e),t=1,n=gg[0],o=[n];t<r;++t)i=gg[t],HIt(n,i[0])||HIt(n,i[1])?(ul(n[0],i[1])>ul(n[0],n[1])&&(n[1]=i[1]),ul(i[0],n[1])>ul(n[0],n[1])&&(n[0]=i[0])):o.push(n=i);for(a=-1/0,r=o.length-1,t=0,n=o[r];t<=r;n=i,++t)i=o[t],(s=ul(n[1],i[0]))>a&&(a=s,mi=i[0],Ei=n[1])}return gg=Zp=null,mi===1/0||hl===1/0?[[NaN,NaN],[NaN,NaN]]:[[mi,hl],[Ei,xc]]}var mi,hl,Ei,xc,Oy,VIt,UIt,P2,IT,gg,Zp,Kp,YIt=M(()=>{ky();hJ();A2();lr();mg();IT=Cs(),Kp={point:fJ,lineStart:FIt,lineEnd:BIt,polygonStart:function(){Kp.point=GIt,Kp.lineStart=L4e,Kp.lineEnd=k4e,IT.reset(),Eu.polygonStart()},polygonEnd:function(){Eu.polygonEnd(),Kp.point=fJ,Kp.lineStart=FIt,Kp.lineEnd=BIt,CT<0?(mi=-(Ei=180),hl=-(xc=90)):IT>ce?xc=90:IT<-ce&&(hl=-90),Zp[0]=mi,Zp[1]=Ei}}});function gJ(e,t){e*=we,t*=we;var r=ae(t);kT(r*ae(e),r*Jt(e),Jt(t))}function kT(e,t,r){++LT,tD+=(e-tD)/LT,eD+=(t-eD)/LT,rD+=(r-rD)/LT}function jIt(){Tu.point=N4e}function N4e(e,t){e*=we,t*=we;var r=ae(t);Wa=r*ae(e),Ya=r*Jt(e),ja=Jt(t),Tu.point=D4e,kT(Wa,Ya,ja)}function D4e(e,t){e*=we,t*=we;var r=ae(t),n=r*ae(e),i=r*Jt(e),o=Jt(t),a=Sn(Rr((a=Ya*o-ja*i)*a+(a=ja*n-Wa*o)*a+(a=Wa*i-Ya*n)*a),Wa*n+Ya*i+ja*o);QN+=a,nD+=a*(Wa+(Wa=n)),iD+=a*(Ya+(Ya=i)),oD+=a*(ja+(ja=o)),kT(Wa,Ya,ja)}function XIt(){Tu.point=gJ}function O4e(){Tu.point=F4e}function z4e(){ZIt($It,KIt),Tu.point=gJ}function F4e(e,t){$It=e,KIt=t,e*=we,t*=we,Tu.point=ZIt;var r=ae(t);Wa=r*ae(e),Ya=r*Jt(e),ja=Jt(t),kT(Wa,Ya,ja)}function ZIt(e,t){e*=we,t*=we;var r=ae(t),n=r*ae(e),i=r*Jt(e),o=Jt(t),a=Ya*o-ja*i,s=ja*n-Wa*o,l=Wa*i-Ya*n,c=Rr(a*a+s*s+l*l),u=Jn(c),h=c&&-u/c;pJ+=h*a,dJ+=h*s,mJ+=h*l,QN+=u,nD+=u*(Wa+(Wa=n)),iD+=u*(Ya+(Ya=i)),oD+=u*(ja+(ja=o)),kT(Wa,Ya,ja)}function JIt(e){LT=QN=tD=eD=rD=nD=iD=oD=pJ=dJ=mJ=0,Mo(e,Tu);var t=pJ,r=dJ,n=mJ,i=t*t+r*r+n*n;return i<oJ&&(t=nD,r=iD,n=oD,QN<ce&&(t=tD,r=eD,n=rD),i=t*t+r*r+n*n,i<oJ)?[NaN,NaN]:[Sn(r,t)*Ur,Jn(n/Rr(i))*Ur]}var LT,QN,tD,eD,rD,nD,iD,oD,pJ,dJ,mJ,$It,KIt,Wa,Ya,ja,Tu,QIt=M(()=>{lr();Xp();mg();Tu={sphere:qr,point:gJ,lineStart:jIt,lineEnd:XIt,polygonStart:function(){Tu.lineStart=O4e,Tu.lineEnd=z4e},polygonEnd:function(){Tu.lineStart=jIt,Tu.lineEnd=XIt}}});function zy(e){return function(){return e}}var t9t=M(()=>{});function aD(e,t){function r(n,i){return n=e(n,i),t(n[0],n[1])}return e.invert&&t.invert&&(r.invert=function(n,i){return n=t.invert(n,i),n&&e.invert(n[0],n[1])}),r}var _J=M(()=>{});function yJ(e,t){return[e>rr?e-Bi:e<-rr?e+Bi:e,t]}function RT(e,t,r){return(e%=Bi)?t||r?aD(r9t(e),n9t(t,r)):r9t(e):t||r?n9t(t,r):yJ}function e9t(e){return function(t,r){return t+=e,[t>rr?t-Bi:t<-rr?t+Bi:t,r]}}function r9t(e){var t=e9t(e);return t.invert=e9t(-e),t}function n9t(e,t){var r=ae(e),n=Jt(e),i=ae(t),o=Jt(t);function a(s,l){var c=ae(l),u=ae(s)*c,h=Jt(s)*c,f=Jt(l),p=f*r+u*n;return[Sn(h*i-p*o,u*r-f*n),Jn(p*i+h*o)]}return a.invert=function(s,l){var c=ae(l),u=ae(s)*c,h=Jt(s)*c,f=Jt(l),p=f*i-h*o;return[Sn(h*i+f*o,u*r+p*n),Jn(p*r-u*n)]},a}function sD(e){e=RT(e[0]*we,e[1]*we,e.length>2?e[2]*we:0);function t(r){return r=e(r[0]*we,r[1]*we),r[0]*=Ur,r[1]*=Ur,r}return t.invert=function(r){return r=e.invert(r[0]*we,r[1]*we),r[0]*=Ur,r[1]*=Ur,r},t}var NT=M(()=>{_J();lr();yJ.invert=yJ});function vJ(e,t,r,n,i,o){if(!!r){var a=ae(t),s=Jt(t),l=n*r;i==null?(i=t+n*Bi,o=t-l/2):(i=i9t(a,i),o=i9t(a,o),(n>0?i<o:i>o)&&(i+=n*Bi));for(var c,u=i;n>0?u>o:u<o;u-=l)c=Ny([a,-s*ae(u),-s*Jt(u)]),e.point(c[0],c[1])}}function i9t(e,t){t=vc(t),t[0]-=e,Dy(t);var r=$N(-t[1]);return((-t[2]<0?-r:r)+Bi-ce)%Bi}function o9t(){var e=zy([0,0]),t=zy(90),r=zy(6),n,i,o={point:a};function a(l,c){n.push(l=i(l,c)),l[0]*=Ur,l[1]*=Ur}function s(){var l=e.apply(this,arguments),c=t.apply(this,arguments)*we,u=r.apply(this,arguments)*we;return n=[],i=RT(-l[0]*we,-l[1]*we,0).invert,vJ(o,c,u,1),l={type:"Polygon",coordinates:[n]},n=i=null,l}return s.center=function(l){return arguments.length?(e=typeof l=="function"?l:zy([+l[0],+l[1]]),s):e},s.radius=function(l){return arguments.length?(t=typeof l=="function"?l:zy(+l),s):t},s.precision=function(l){return arguments.length?(r=typeof l=="function"?l:zy(+l),s):r},s}var xJ=M(()=>{A2();t9t();lr();NT()});function lD(){var e=[],t;return{point:function(r,n){t.push([r,n])},lineStart:function(){e.push(t=[])},lineEnd:qr,rejoin:function(){e.length>1&&e.push(e.pop().concat(e.shift()))},result:function(){var r=e;return e=[],t=null,r}}}var bJ=M(()=>{Xp()});function I2(e,t){return Ye(e[0]-t[0])<ce&&Ye(e[1]-t[1])<ce}var wJ=M(()=>{lr()});function cD(e,t,r,n){this.x=e,this.z=t,this.o=r,this.e=n,this.v=!1,this.n=this.p=null}function uD(e,t,r,n,i){var o=[],a=[],s,l;if(e.forEach(function(d){if(!((g=d.length-1)<=0)){var g,_=d[0],y=d[g],x;if(I2(_,y)){for(i.lineStart(),s=0;s<g;++s)i.point((_=d[s])[0],_[1]);i.lineEnd();return}o.push(x=new cD(_,d,null,!0)),a.push(x.o=new cD(_,null,x,!1)),o.push(x=new cD(y,d,null,!1)),a.push(x.o=new cD(y,null,x,!0))}}),!!o.length){for(a.sort(t),a9t(o),a9t(a),s=0,l=a.length;s<l;++s)a[s].e=r=!r;for(var c=o[0],u,h;;){for(var f=c,p=!0;f.v;)if((f=f.n)===c)return;u=f.z,i.lineStart();do{if(f.v=f.o.v=!0,f.e){if(p)for(s=0,l=u.length;s<l;++s)i.point((h=u[s])[0],h[1]);else n(f.x,f.n.x,1,i);f=f.n}else{if(p)for(u=f.p.z,s=u.length-1;s>=0;--s)i.point((h=u[s])[0],h[1]);else n(f.x,f.p.x,-1,i);f=f.p}f=f.o,u=f.z,p=!p}while(!f.v);i.lineEnd()}}}function a9t(e){if(!!(t=e.length)){for(var t,r=0,n=e[0],i;++r<t;)n.n=i=e[r],i.p=n,n=i;n.n=i=e[0],i.p=n}}var SJ=M(()=>{wJ()});function hD(e,t){var r=t[0],n=t[1],i=[Jt(r),-ae(r),0],o=0,a=0;MJ.reset();for(var s=0,l=e.length;s<l;++s)if(!!(u=(c=e[s]).length))for(var c,u,h=c[u-1],f=h[0],p=h[1]/2+T2,d=Jt(p),g=ae(p),_=0;_<u;++_,f=x,d=S,g=C,h=y){var y=c[_],x=y[0],b=y[1]/2+T2,S=Jt(b),C=ae(b),P=x-f,k=P>=0?1:-1,O=k*P,D=O>rr,B=d*S;if(MJ.add(Sn(B*k*Jt(O),g*C+B*ae(O))),o+=D?P+k*Bi:P,D^f>=r^x>=r){var I=$p(vc(h),vc(y));Dy(I);var L=$p(i,I);Dy(L);var R=(D^P>=0?-1:1)*Jn(L[2]);(n>R||n===R&&(I[0]||I[1]))&&(a+=D^P>=0?1:-1)}}return(o<-ce||o<ce&&MJ<-ce)^a&1}var MJ,EJ=M(()=>{ky();A2();lr();MJ=Cs()});function _g(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var Fy=M(()=>{});function TJ(e){return e.length===1&&(e=B4e(e)),{left:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)<0?n=o+1:i=o}return n},right:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)>0?i=o:n=o+1}return n}}}function B4e(e){return function(t,r){return _g(e(t),r)}}var CJ=M(()=>{Fy()});var s9t,H4e,V4e,AJ=M(()=>{Fy();CJ();s9t=TJ(_g),H4e=s9t.right,V4e=s9t.left});var PJ=M(()=>{});var l9t=M(()=>{PJ()});var c9t=M(()=>{});var L2=M(()=>{});var IJ=M(()=>{L2()});var LJ=M(()=>{IJ()});var kJ=M(()=>{});var u9t,q4e,G4e,RJ=M(()=>{u9t=Array.prototype,q4e=u9t.slice,G4e=u9t.map});var h9t=M(()=>{});var f9t=M(()=>{});function Jp(e,t,r){e=+e,t=+t,r=(i=arguments.length)<2?(t=e,e=0,1):i<3?1:+r;for(var n=-1,i=Math.max(0,Math.ceil((t-e)/r))|0,o=new Array(i);++n<i;)o[n]=e+n*r;return o}var NJ=M(()=>{});var b0n,w0n,S0n,DJ=M(()=>{b0n=Math.sqrt(50),w0n=Math.sqrt(10),S0n=Math.sqrt(2)});var OJ=M(()=>{});var p9t=M(()=>{RJ();AJ();h9t();kJ();f9t();NJ();DJ();OJ()});var pD=M(()=>{L2()});var m9t=M(()=>{RJ();Fy();L2();pD()});var g9t=M(()=>{LJ()});var _9t=M(()=>{});var y9t=M(()=>{L2()});var v9t=M(()=>{Fy();L2();pD()});function DT(e){for(var t=e.length,r,n=-1,i=0,o,a;++n<t;)i+=e[n].length;for(o=new Array(i);--t>=0;)for(a=e[t],r=a.length;--r>=0;)o[--i]=a[r];return o}var x9t=M(()=>{});var zJ=M(()=>{});var b9t=M(()=>{});var w9t=M(()=>{Fy()});var S9t=M(()=>{});var M9t=M(()=>{});var FJ=M(()=>{zJ()});var E9t=M(()=>{FJ()});var dD=M(()=>{AJ();Fy();CJ();l9t();c9t();LJ();kJ();p9t();m9t();g9t();OJ();_9t();y9t();v9t();x9t();zJ();PJ();b9t();pD();NJ();w9t();S9t();M9t();DJ();FJ();IJ();E9t()});function mD(e,t,r,n){return function(i){var o=t(i),a=lD(),s=t(a),l=!1,c,u,h,f={point:p,lineStart:g,lineEnd:_,polygonStart:function(){f.point=y,f.lineStart=x,f.lineEnd=b,u=[],c=[]},polygonEnd:function(){f.point=p,f.lineStart=g,f.lineEnd=_,u=DT(u);var S=hD(c,n);u.length?(l||(i.polygonStart(),l=!0),uD(u,Q4e,S,r,i)):S&&(l||(i.polygonStart(),l=!0),i.lineStart(),r(null,null,1,i),i.lineEnd()),l&&(i.polygonEnd(),l=!1),u=c=null},sphere:function(){i.polygonStart(),i.lineStart(),r(null,null,1,i),i.lineEnd(),i.polygonEnd()}};function p(S,C){e(S,C)&&i.point(S,C)}function d(S,C){o.point(S,C)}function g(){f.point=d,o.lineStart()}function _(){f.point=p,o.lineEnd()}function y(S,C){h.push([S,C]),s.point(S,C)}function x(){s.lineStart(),h=[]}function b(){y(h[0][0],h[0][1]),s.lineEnd();var S=s.clean(),C=a.result(),P,k=C.length,O,D,B;if(h.pop(),c.push(h),h=null,!!k){if(S&1){if(D=C[0],(O=D.length-1)>0){for(l||(i.polygonStart(),l=!0),i.lineStart(),P=0;P<O;++P)i.point((B=D[P])[0],B[1]);i.lineEnd()}return}k>1&&S&2&&C.push(C.pop().concat(C.shift())),u.push(C.filter(J4e))}}return f}}function J4e(e){return e.length>1}function Q4e(e,t){return((e=e.x)[0]<0?e[1]-Bn-ce:Bn-e[1])-((t=t.x)[0]<0?t[1]-Bn-ce:Bn-t[1])}var BJ=M(()=>{bJ();SJ();lr();EJ();dD()});function tPe(e){var t=NaN,r=NaN,n=NaN,i;return{lineStart:function(){e.lineStart(),i=1},point:function(o,a){var s=o>0?rr:-rr,l=Ye(o-t);Ye(l-rr)<ce?(e.point(t,r=(r+a)/2>0?Bn:-Bn),e.point(n,r),e.lineEnd(),e.lineStart(),e.point(s,r),e.point(o,r),i=0):n!==s&&l>=rr&&(Ye(t-n)<ce&&(t-=n*ce),Ye(o-s)<ce&&(o-=s*ce),r=ePe(t,r,o,a),e.point(n,r),e.lineEnd(),e.lineStart(),e.point(s,r),i=0),e.point(t=o,r=a),n=s},lineEnd:function(){e.lineEnd(),t=r=NaN},clean:function(){return 2-i}}}function ePe(e,t,r,n){var i,o,a=Jt(e-r);return Ye(a)>ce?yc((Jt(t)*(o=ae(n))*Jt(r)-Jt(n)*(i=ae(t))*Jt(e))/(i*o*a)):(t+n)/2}function rPe(e,t,r,n){var i;if(e==null)i=r*Bn,n.point(-rr,i),n.point(0,i),n.point(rr,i),n.point(rr,0),n.point(rr,-i),n.point(0,-i),n.point(-rr,-i),n.point(-rr,0),n.point(-rr,i);else if(Ye(e[0]-t[0])>ce){var o=e[0]<t[0]?rr:-rr;i=r*o/2,n.point(-o,i),n.point(0,i),n.point(o,i)}else n.point(t[0],t[1])}var OT,HJ=M(()=>{BJ();lr();OT=mD(function(){return!0},tPe,rPe,[-rr,-Bn])});function gD(e){var t=ae(e),r=6*we,n=t>0,i=Ye(t)>ce;function o(u,h,f,p){vJ(p,e,r,f,u,h)}function a(u,h){return ae(u)*ae(h)>t}function s(u){var h,f,p,d,g;return{lineStart:function(){d=p=!1,g=1},point:function(_,y){var x=[_,y],b,S=a(_,y),C=n?S?0:c(_,y):S?c(_+(_<0?rr:-rr),y):0;if(!h&&(d=p=S)&&u.lineStart(),S!==p&&(b=l(h,x),(!b||I2(h,b)||I2(x,b))&&(x[0]+=ce,x[1]+=ce,S=a(x[0],x[1]))),S!==p)g=0,S?(u.lineStart(),b=l(x,h),u.point(b[0],b[1])):(b=l(h,x),u.point(b[0],b[1]),u.lineEnd()),h=b;else if(i&&h&&n^S){var P;!(C&f)&&(P=l(x,h,!0))&&(g=0,n?(u.lineStart(),u.point(P[0][0],P[0][1]),u.point(P[1][0],P[1][1]),u.lineEnd()):(u.point(P[1][0],P[1][1]),u.lineEnd(),u.lineStart(),u.point(P[0][0],P[0][1])))}S&&(!h||!I2(h,x))&&u.point(x[0],x[1]),h=x,p=S,f=C},lineEnd:function(){p&&u.lineEnd(),h=null},clean:function(){return g|(d&&p)<<1}}}function l(u,h,f){var p=vc(u),d=vc(h),g=[1,0,0],_=$p(p,d),y=AT(_,_),x=_[0],b=y-x*x;if(!b)return!f&&u;var S=t*y/b,C=-t*x/b,P=$p(g,_),k=PT(g,S),O=PT(_,C);JN(k,O);var D=P,B=AT(k,D),I=AT(D,D),L=B*B-I*(AT(k,k)-1);if(!(L<0)){var R=Rr(L),F=PT(D,(-B-R)/I);if(JN(F,k),F=Ny(F),!f)return F;var z=u[0],U=h[0],W=u[1],Z=h[1],rt;U<z&&(rt=z,z=U,U=rt);var ot=U-z,st=Ye(ot-rr)<ce,St=st||ot<ce;if(!st&&Z<W&&(rt=W,W=Z,Z=rt),St?st?W+Z>0^F[1]<(Ye(F[0]-z)<ce?W:Z):W<=F[1]&&F[1]<=Z:ot>rr^(z<=F[0]&&F[0]<=U)){var bt=PT(D,(-B+R)/I);return JN(bt,k),[F,Ny(bt)]}}}function c(u,h){var f=n?e:rr-e,p=0;return u<-f?p|=1:u>f&&(p|=2),h<-f?p|=4:h>f&&(p|=8),p}return mD(a,s,o,n?[0,-e]:[-rr,e-rr])}var VJ=M(()=>{A2();xJ();lr();wJ();BJ()});function T9t(e,t,r,n,i,o){var a=e[0],s=e[1],l=t[0],c=t[1],u=0,h=1,f=l-a,p=c-s,d;if(d=r-a,!(!f&&d>0)){if(d/=f,f<0){if(d<u)return;d<h&&(h=d)}else if(f>0){if(d>h)return;d>u&&(u=d)}if(d=i-a,!(!f&&d<0)){if(d/=f,f<0){if(d>h)return;d>u&&(u=d)}else if(f>0){if(d<u)return;d<h&&(h=d)}if(d=n-s,!(!p&&d>0)){if(d/=p,p<0){if(d<u)return;d<h&&(h=d)}else if(p>0){if(d>h)return;d>u&&(u=d)}if(d=o-s,!(!p&&d<0)){if(d/=p,p<0){if(d>h)return;d>u&&(u=d)}else if(p>0){if(d<u)return;d<h&&(h=d)}return u>0&&(e[0]=a+u*f,e[1]=s+u*p),h<1&&(t[0]=a+h*f,t[1]=s+h*p),!0}}}}}var C9t=M(()=>{});function Qp(e,t,r,n){function i(c,u){return e<=c&&c<=r&&t<=u&&u<=n}function o(c,u,h,f){var p=0,d=0;if(c==null||(p=a(c,h))!==(d=a(u,h))||l(c,u)<0^h>0)do f.point(p===0||p===3?e:r,p>1?n:t);while((p=(p+h+4)%4)!==d);else f.point(u[0],u[1])}function a(c,u){return Ye(c[0]-e)<ce?u>0?0:3:Ye(c[0]-r)<ce?u>0?2:1:Ye(c[1]-t)<ce?u>0?1:0:u>0?3:2}function s(c,u){return l(c.x,u.x)}function l(c,u){var h=a(c,1),f=a(u,1);return h!==f?h-f:h===0?u[1]-c[1]:h===1?c[0]-u[0]:h===2?c[1]-u[1]:u[0]-c[0]}return function(c){var u=c,h=lD(),f,p,d,g,_,y,x,b,S,C,P,k={point:O,lineStart:L,lineEnd:R,polygonStart:B,polygonEnd:I};function O(z,U){i(z,U)&&u.point(z,U)}function D(){for(var z=0,U=0,W=p.length;U<W;++U)for(var Z=p[U],rt=1,ot=Z.length,st=Z[0],St,bt,Mt=st[0],lt=st[1];rt<ot;++rt)St=Mt,bt=lt,st=Z[rt],Mt=st[0],lt=st[1],bt<=n?lt>n&&(Mt-St)*(n-bt)>(lt-bt)*(e-St)&&++z:lt<=n&&(Mt-St)*(n-bt)<(lt-bt)*(e-St)&&--z;return z}function B(){u=h,f=[],p=[],P=!0}function I(){var z=D(),U=P&&z,W=(f=DT(f)).length;(U||W)&&(c.polygonStart(),U&&(c.lineStart(),o(null,null,1,c),c.lineEnd()),W&&uD(f,s,z,o,c),c.polygonEnd()),u=c,f=p=d=null}function L(){k.point=F,p&&p.push(d=[]),C=!0,S=!1,x=b=NaN}function R(){f&&(F(g,_),y&&S&&h.rejoin(),f.push(h.result())),k.point=O,S&&u.lineEnd()}function F(z,U){var W=i(z,U);if(p&&d.push([z,U]),C)g=z,_=U,y=W,C=!1,W&&(u.lineStart(),u.point(z,U));else if(W&&S)u.point(z,U);else{var Z=[x=Math.max(_D,Math.min(zT,x)),b=Math.max(_D,Math.min(zT,b))],rt=[z=Math.max(_D,Math.min(zT,z)),U=Math.max(_D,Math.min(zT,U))];T9t(Z,rt,e,t,r,n)?(S||(u.lineStart(),u.point(Z[0],Z[1])),u.point(rt[0],rt[1]),W||u.lineEnd(),P=!1):W&&(u.lineStart(),u.point(z,U),P=!1)}x=z,b=U,S=W}return k}}var zT,_D,FT=M(()=>{lr();bJ();C9t();SJ();dD();zT=1e9,_D=-zT});function A9t(){var e=0,t=0,r=960,n=500,i,o,a;return a={stream:function(s){return i&&o===s?i:i=Qp(e,t,r,n)(o=s)},extent:function(s){return arguments.length?(e=+s[0][0],t=+s[0][1],r=+s[1][0],n=+s[1][1],i=o=null,a):[[e,t],[r,n]]}}}var P9t=M(()=>{FT()});function nPe(){k2.point=oPe,k2.lineEnd=iPe}function iPe(){k2.point=k2.lineEnd=qr}function oPe(e,t){e*=we,t*=we,qJ=e,yD=Jt(t),vD=ae(t),k2.point=aPe}function aPe(e,t){e*=we,t*=we;var r=Jt(t),n=ae(t),i=Ye(e-qJ),o=ae(i),a=Jt(i),s=n*a,l=vD*r-yD*n*o,c=yD*r+vD*n*o;UJ.add(Sn(Rr(s*s+l*l),c)),qJ=e,yD=r,vD=n}function xD(e){return UJ.reset(),Mo(e,k2),+UJ}var UJ,qJ,yD,vD,k2,GJ=M(()=>{ky();lr();Xp();mg();UJ=Cs(),k2={sphere:qr,point:qr,lineStart:nPe,lineEnd:qr,polygonStart:qr,polygonEnd:qr}});function By(e,t){return WJ[0]=e,WJ[1]=t,xD(sPe)}var WJ,sPe,YJ=M(()=>{GJ();WJ=[null,null],sPe={type:"LineString",coordinates:WJ}});function bD(e,t){return e&&L9t.hasOwnProperty(e.type)?L9t[e.type](e,t):!1}function k9t(e,t){return By(e,t)===0}function R9t(e,t){var r=By(e[0],e[1]),n=By(e[0],t),i=By(t,e[1]);return n+i<=r+ce}function N9t(e,t){return!!hD(e.map(lPe),D9t(t))}function lPe(e){return e=e.map(D9t),e.pop(),e}function D9t(e){return[e[0]*we,e[1]*we]}function O9t(e,t){return(e&&I9t.hasOwnProperty(e.type)?I9t[e.type]:bD)(e,t)}var I9t,L9t,z9t=M(()=>{EJ();YJ();lr();I9t={Feature:function(e,t){return bD(e.geometry,t)},FeatureCollection:function(e,t){for(var r=e.features,n=-1,i=r.length;++n<i;)if(bD(r[n].geometry,t))return!0;return!1}},L9t={Sphere:function(){return!0},Point:function(e,t){return k9t(e.coordinates,t)},MultiPoint:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)if(k9t(r[n],t))return!0;return!1},LineString:function(e,t){return R9t(e.coordinates,t)},MultiLineString:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)if(R9t(r[n],t))return!0;return!1},Polygon:function(e,t){return N9t(e.coordinates,t)},MultiPolygon:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)if(N9t(r[n],t))return!0;return!1},GeometryCollection:function(e,t){for(var r=e.geometries,n=-1,i=r.length;++n<i;)if(bD(r[n],t))return!0;return!1}}});function F9t(e,t,r){var n=Jp(e,t-ce,r).concat(t);return function(i){return n.map(function(o){return[i,o]})}}function B9t(e,t,r){var n=Jp(e,t-ce,r).concat(t);return function(i){return n.map(function(o){return[o,i]})}}function wD(){var e,t,r,n,i,o,a,s,l=10,c=l,u=90,h=360,f,p,d,g,_=2.5;function y(){return{type:"MultiLineString",coordinates:x()}}function x(){return Jp(TT(n/u)*u,r,u).map(d).concat(Jp(TT(s/h)*h,a,h).map(g)).concat(Jp(TT(t/l)*l,e,l).filter(function(b){return Ye(b%u)>ce}).map(f)).concat(Jp(TT(o/c)*c,i,c).filter(function(b){return Ye(b%h)>ce}).map(p))}return y.lines=function(){return x().map(function(b){return{type:"LineString",coordinates:b}})},y.outline=function(){return{type:"Polygon",coordinates:[d(n).concat(g(a).slice(1),d(r).reverse().slice(1),g(s).reverse().slice(1))]}},y.extent=function(b){return arguments.length?y.extentMajor(b).extentMinor(b):y.extentMinor()},y.extentMajor=function(b){return arguments.length?(n=+b[0][0],r=+b[1][0],s=+b[0][1],a=+b[1][1],n>r&&(b=n,n=r,r=b),s>a&&(b=s,s=a,a=b),y.precision(_)):[[n,s],[r,a]]},y.extentMinor=function(b){return arguments.length?(t=+b[0][0],e=+b[1][0],o=+b[0][1],i=+b[1][1],t>e&&(b=t,t=e,e=b),o>i&&(b=o,o=i,i=b),y.precision(_)):[[t,o],[e,i]]},y.step=function(b){return arguments.length?y.stepMajor(b).stepMinor(b):y.stepMinor()},y.stepMajor=function(b){return arguments.length?(u=+b[0],h=+b[1],y):[u,h]},y.stepMinor=function(b){return arguments.length?(l=+b[0],c=+b[1],y):[l,c]},y.precision=function(b){return arguments.length?(_=+b,f=F9t(o,i,90),p=B9t(t,e,_),d=F9t(s,a,90),g=B9t(n,r,_),y):_},y.extentMajor([[-180,-90+ce],[180,90-ce]]).extentMinor([[-180,-80-ce],[180,80+ce]])}function H9t(){return wD()()}var V9t=M(()=>{dD();lr()});function U9t(e,t){var r=e[0]*we,n=e[1]*we,i=t[0]*we,o=t[1]*we,a=ae(n),s=Jt(n),l=ae(o),c=Jt(o),u=a*ae(r),h=a*Jt(r),f=l*ae(i),p=l*Jt(i),d=2*Jn(Rr(aJ(o-n)+a*l*aJ(i-r))),g=Jt(d),_=d?function(y){var x=Jt(y*=d)/g,b=Jt(d-y)/g,S=b*u+x*f,C=b*h+x*p,P=b*s+x*c;return[Sn(C,S)*Ur,Sn(P,Rr(S*S+C*C))*Ur]}:function(){return[r*Ur,n*Ur]};return _.distance=d,_}var q9t=M(()=>{lr()});function nf(e){return e}var SD=M(()=>{});function cPe(){yg.point=uPe}function uPe(e,t){yg.point=Y9t,G9t=$J=e,W9t=KJ=t}function Y9t(e,t){XJ.add(KJ*e-$J*t),$J=e,KJ=t}function hPe(){Y9t(G9t,W9t)}var jJ,XJ,G9t,W9t,$J,KJ,yg,ZJ,j9t=M(()=>{ky();lr();Xp();jJ=Cs(),XJ=Cs(),yg={point:qr,lineStart:qr,lineEnd:qr,polygonStart:function(){yg.lineStart=cPe,yg.lineEnd=hPe},polygonEnd:function(){yg.lineStart=yg.lineEnd=yg.point=qr,jJ.add(Ye(XJ)),XJ.reset()},result:function(){var e=jJ/2;return jJ.reset(),e}};ZJ=yg});function pPe(e,t){e<R2&&(R2=e),e>BT&&(BT=e),t<MD&&(MD=t),t>ED&&(ED=t)}var R2,MD,BT,ED,fPe,N2,JJ=M(()=>{Xp();R2=1/0,MD=R2,BT=-R2,ED=BT,fPe={point:pPe,lineStart:qr,lineEnd:qr,polygonStart:qr,polygonEnd:qr,result:function(){var e=[[R2,MD],[BT,ED]];return BT=ED=-(MD=R2=1/0),e}};N2=fPe});function Hy(e,t){QJ+=e,tQ+=t,++HT}function X9t(){Cu.point=dPe}function dPe(e,t){Cu.point=mPe,Hy(of=e,af=t)}function mPe(e,t){var r=e-of,n=t-af,i=Rr(r*r+n*n);TD+=i*(of+e)/2,CD+=i*(af+t)/2,D2+=i,Hy(of=e,af=t)}function $9t(){Cu.point=Hy}function gPe(){Cu.point=yPe}function _Pe(){J9t(K9t,Z9t)}function yPe(e,t){Cu.point=J9t,Hy(K9t=of=e,Z9t=af=t)}function J9t(e,t){var r=e-of,n=t-af,i=Rr(r*r+n*n);TD+=i*(of+e)/2,CD+=i*(af+t)/2,D2+=i,i=af*e-of*t,eQ+=i*(of+e),rQ+=i*(af+t),VT+=i*3,Hy(of=e,af=t)}var QJ,tQ,HT,TD,CD,D2,eQ,rQ,VT,K9t,Z9t,of,af,Cu,nQ,Q9t=M(()=>{lr();QJ=0,tQ=0,HT=0,TD=0,CD=0,D2=0,eQ=0,rQ=0,VT=0,Cu={point:Hy,lineStart:X9t,lineEnd:$9t,polygonStart:function(){Cu.lineStart=gPe,Cu.lineEnd=_Pe},polygonEnd:function(){Cu.point=Hy,Cu.lineStart=X9t,Cu.lineEnd=$9t},result:function(){var e=VT?[eQ/VT,rQ/VT]:D2?[TD/D2,CD/D2]:HT?[QJ/HT,tQ/HT]:[NaN,NaN];return QJ=tQ=HT=TD=CD=D2=eQ=rQ=VT=0,e}};nQ=Cu});function AD(e){this._context=e}var tLt=M(()=>{lr();Xp();AD.prototype={_radius:4.5,pointRadius:function(e){return this._radius=e,this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){this._line===0&&this._context.closePath(),this._point=NaN},point:function(e,t){switch(this._point){case 0:{this._context.moveTo(e,t),this._point=1;break}case 1:{this._context.lineTo(e,t);break}default:{this._context.moveTo(e+this._radius,t),this._context.arc(e,t,this._radius,0,Bi);break}}},result:qr}});function vPe(e,t){PD.point=nLt,eLt=UT=e,rLt=qT=t}function nLt(e,t){UT-=e,qT-=t,oQ.add(Rr(UT*UT+qT*qT)),UT=e,qT=t}var oQ,iQ,eLt,rLt,UT,qT,PD,aQ,iLt=M(()=>{ky();lr();Xp();oQ=Cs(),PD={point:qr,lineStart:function(){PD.point=vPe},lineEnd:function(){iQ&&nLt(eLt,rLt),PD.point=qr},polygonStart:function(){iQ=!0},polygonEnd:function(){iQ=null},result:function(){var e=+oQ;return oQ.reset(),e}};aQ=PD});function ID(){this._string=[]}function oLt(e){return"m0,"+e+"a"+e+","+e+" 0 1,1 0,"+-2*e+"a"+e+","+e+" 0 1,1 0,"+2*e+"z"}var aLt=M(()=>{ID.prototype={_radius:4.5,_circle:oLt(4.5),pointRadius:function(e){return(e=+e)!==this._radius&&(this._radius=e,this._circle=null),this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){this._line===0&&this._string.push("Z"),this._point=NaN},point:function(e,t){switch(this._point){case 0:{this._string.push("M",e,",",t),this._point=1;break}case 1:{this._string.push("L",e,",",t);break}default:{this._circle==null&&(this._circle=oLt(this._radius)),this._string.push("M",e,",",t,this._circle);break}}},result:function(){if(this._string.length){var e=this._string.join("");return this._string=[],e}else return null}}});function sLt(e,t){var r=4.5,n,i;function o(a){return a&&(typeof r=="function"&&i.pointRadius(+r.apply(this,arguments)),Mo(a,n(i))),i.result()}return o.area=function(a){return Mo(a,n(ZJ)),ZJ.result()},o.measure=function(a){return Mo(a,n(aQ)),aQ.result()},o.bounds=function(a){return Mo(a,n(N2)),N2.result()},o.centroid=function(a){return Mo(a,n(nQ)),nQ.result()},o.projection=function(a){return arguments.length?(n=a==null?(e=null,nf):(e=a).stream,o):e},o.context=function(a){return arguments.length?(i=a==null?(t=null,new ID):new AD(t=a),typeof r!="function"&&i.pointRadius(r),o):t},o.pointRadius=function(a){return arguments.length?(r=typeof a=="function"?a:(i.pointRadius(+a),+a),o):r},o.projection(e).context(t)}var lLt=M(()=>{SD();mg();j9t();JJ();Q9t();tLt();iLt();aLt()});function cLt(e){return{stream:vg(e)}}function vg(e){return function(t){var r=new sQ;for(var n in e)r[n]=e[n];return r.stream=t,r}}function sQ(){}var GT=M(()=>{sQ.prototype={constructor:sQ,point:function(e,t){this.stream.point(e,t)},sphere:function(){this.stream.sphere()},lineStart:function(){this.stream.lineStart()},lineEnd:function(){this.stream.lineEnd()},polygonStart:function(){this.stream.polygonStart()},polygonEnd:function(){this.stream.polygonEnd()}}});function lQ(e,t,r){var n=e.clipExtent&&e.clipExtent();return e.scale(150).translate([0,0]),n!=null&&e.clipExtent(null),Mo(r,e.stream(N2)),t(N2.result()),n!=null&&e.clipExtent(n),e}function Vy(e,t,r){return lQ(e,function(n){var i=t[1][0]-t[0][0],o=t[1][1]-t[0][1],a=Math.min(i/(n[1][0]-n[0][0]),o/(n[1][1]-n[0][1])),s=+t[0][0]+(i-a*(n[1][0]+n[0][0]))/2,l=+t[0][1]+(o-a*(n[1][1]+n[0][1]))/2;e.scale(150*a).translate([s,l])},r)}function O2(e,t,r){return Vy(e,[[0,0],t],r)}function z2(e,t,r){return lQ(e,function(n){var i=+t,o=i/(n[1][0]-n[0][0]),a=(i-o*(n[1][0]+n[0][0]))/2,s=-o*n[0][1];e.scale(150*o).translate([a,s])},r)}function F2(e,t,r){return lQ(e,function(n){var i=+t,o=i/(n[1][1]-n[0][1]),a=-o*n[0][0],s=(i-o*(n[1][1]+n[0][1]))/2;e.scale(150*o).translate([a,s])},r)}var LD=M(()=>{mg();JJ()});function cQ(e,t){return+t?wPe(e,t):bPe(e)}function bPe(e){return vg({point:function(t,r){t=e(t,r),this.stream.point(t[0],t[1])}})}function wPe(e,t){function r(n,i,o,a,s,l,c,u,h,f,p,d,g,_){var y=c-n,x=u-i,b=y*y+x*x;if(b>4*t&&g--){var S=a+f,C=s+p,P=l+d,k=Rr(S*S+C*C+P*P),O=Jn(P/=k),D=Ye(Ye(P)-1)<ce||Ye(o-h)<ce?(o+h)/2:Sn(C,S),B=e(D,O),I=B[0],L=B[1],R=I-n,F=L-i,z=x*R-y*F;(z*z/b>t||Ye((y*R+x*F)/b-.5)>.3||a*f+s*p+l*d<xPe)&&(r(n,i,o,a,s,l,I,L,D,S/=k,C/=k,P,g,_),_.point(I,L),r(I,L,D,S,C,P,c,u,h,f,p,d,g,_))}}return function(n){var i,o,a,s,l,c,u,h,f,p,d,g,_={point:y,lineStart:x,lineEnd:S,polygonStart:function(){n.polygonStart(),_.lineStart=C},polygonEnd:function(){n.polygonEnd(),_.lineStart=x}};function y(O,D){O=e(O,D),n.point(O[0],O[1])}function x(){h=NaN,_.point=b,n.lineStart()}function b(O,D){var B=vc([O,D]),I=e(O,D);r(h,f,u,p,d,g,h=I[0],f=I[1],u=O,p=B[0],d=B[1],g=B[2],uLt,n),n.point(h,f)}function S(){_.point=y,n.lineEnd()}function C(){x(),_.point=P,_.lineEnd=k}function P(O,D){b(i=O,D),o=h,a=f,s=p,l=d,c=g,_.point=b}function k(){r(h,f,u,p,d,g,o,a,i,s,l,c,uLt,n),_.lineEnd=S,S()}return _}}var uLt,xPe,hLt=M(()=>{A2();lr();GT();uLt=16,xPe=ae(30*we)});function MPe(e){return vg({point:function(t,r){var n=e(t,r);return this.stream.point(n[0],n[1])}})}function eo(e){return WT(function(){return e})()}function WT(e){var t,r=150,n=480,i=250,o,a,s=0,l=0,c=0,u=0,h=0,f,p,d=null,g=OT,_=null,y,x,b,S=nf,C=.5,P=cQ(I,C),k,O;function D(F){return F=p(F[0]*we,F[1]*we),[F[0]*r+o,a-F[1]*r]}function B(F){return F=p.invert((F[0]-o)/r,(a-F[1])/r),F&&[F[0]*Ur,F[1]*Ur]}function I(F,z){return F=t(F,z),[F[0]*r+o,a-F[1]*r]}D.stream=function(F){return k&&O===F?k:k=SPe(MPe(f)(g(P(S(O=F)))))},D.preclip=function(F){return arguments.length?(g=F,d=void 0,R()):g},D.postclip=function(F){return arguments.length?(S=F,_=y=x=b=null,R()):S},D.clipAngle=function(F){return arguments.length?(g=+F?gD(d=F*we):(d=null,OT),R()):d*Ur},D.clipExtent=function(F){return arguments.length?(S=F==null?(_=y=x=b=null,nf):Qp(_=+F[0][0],y=+F[0][1],x=+F[1][0],b=+F[1][1]),R()):_==null?null:[[_,y],[x,b]]},D.scale=function(F){return arguments.length?(r=+F,L()):r},D.translate=function(F){return arguments.length?(n=+F[0],i=+F[1],L()):[n,i]},D.center=function(F){return arguments.length?(s=F[0]%360*we,l=F[1]%360*we,L()):[s*Ur,l*Ur]},D.rotate=function(F){return arguments.length?(c=F[0]%360*we,u=F[1]%360*we,h=F.length>2?F[2]%360*we:0,L()):[c*Ur,u*Ur,h*Ur]},D.precision=function(F){return arguments.length?(P=cQ(I,C=F*F),R()):Rr(C)},D.fitExtent=function(F,z){return Vy(D,F,z)},D.fitSize=function(F,z){return O2(D,F,z)},D.fitWidth=function(F,z){return z2(D,F,z)},D.fitHeight=function(F,z){return F2(D,F,z)};function L(){p=aD(f=RT(c,u,h),t);var F=t(s,l);return o=n-F[0]*r,a=i+F[1]*r,R()}function R(){return k=O=null,D}return function(){return t=e.apply(this,arguments),D.invert=t.invert&&B,L()}}var SPe,Au=M(()=>{HJ();VJ();FT();_J();SD();lr();NT();GT();LD();hLt();SPe=vg({point:function(e,t){this.stream.point(e*we,t*we)}})});function B2(e){var t=0,r=rr/3,n=WT(e),i=n(t,r);return i.parallels=function(o){return arguments.length?n(t=o[0]*we,r=o[1]*we):[t*Ur,r*Ur]},i}var kD=M(()=>{lr();Au()});function fLt(e){var t=ae(e);function r(n,i){return[n*t,Jt(i)/t]}return r.invert=function(n,i){return[n/t,Jn(i*t)]},r}var pLt=M(()=>{lr()});function uQ(e,t){var r=Jt(e),n=(r+Jt(t))/2;if(Ye(n)<ce)return fLt(e);var i=1+r*(2*n-r),o=Rr(i)/n;function a(s,l){var c=Rr(i-2*n*Jt(l))/n;return[c*Jt(s*=n),o-c*ae(s)]}return a.invert=function(s,l){var c=o-l;return[Sn(s,Ye(c))/n*dg(c),Jn((i-(s*s+c*c)*n*n)/(2*n))]},a}function Uy(){return B2(uQ).scale(155.424).center([0,33.6442])}var RD=M(()=>{lr();kD();pLt()});function ND(){return Uy().parallels([29.5,45.5]).scale(1070).translate([480,250]).rotate([96,0]).center([-.6,38.7])}var hQ=M(()=>{RD()});function EPe(e){var t=e.length;return{point:function(r,n){for(var i=-1;++i<t;)e[i].point(r,n)},sphere:function(){for(var r=-1;++r<t;)e[r].sphere()},lineStart:function(){for(var r=-1;++r<t;)e[r].lineStart()},lineEnd:function(){for(var r=-1;++r<t;)e[r].lineEnd()},polygonStart:function(){for(var r=-1;++r<t;)e[r].polygonStart()},polygonEnd:function(){for(var r=-1;++r<t;)e[r].polygonEnd()}}}function dLt(){var e,t,r=ND(),n,i=Uy().rotate([154,0]).center([-2,58.5]).parallels([55,65]),o,a=Uy().rotate([157,0]).center([-3,19.9]).parallels([8,18]),s,l,c={point:function(f,p){l=[f,p]}};function u(f){var p=f[0],d=f[1];return l=null,n.point(p,d),l||(o.point(p,d),l)||(s.point(p,d),l)}u.invert=function(f){var p=r.scale(),d=r.translate(),g=(f[0]-d[0])/p,_=(f[1]-d[1])/p;return(_>=.12&&_<.234&&g>=-.425&&g<-.214?i:_>=.166&&_<.234&&g>=-.214&&g<-.115?a:r).invert(f)},u.stream=function(f){return e&&t===f?e:e=EPe([r.stream(t=f),i.stream(f),a.stream(f)])},u.precision=function(f){return arguments.length?(r.precision(f),i.precision(f),a.precision(f),h()):r.precision()},u.scale=function(f){return arguments.length?(r.scale(f),i.scale(f*.35),a.scale(f),u.translate(r.translate())):r.scale()},u.translate=function(f){if(!arguments.length)return r.translate();var p=r.scale(),d=+f[0],g=+f[1];return n=r.translate(f).clipExtent([[d-.455*p,g-.238*p],[d+.455*p,g+.238*p]]).stream(c),o=i.translate([d-.307*p,g+.201*p]).clipExtent([[d-.425*p+ce,g+.12*p+ce],[d-.214*p-ce,g+.234*p-ce]]).stream(c),s=a.translate([d-.205*p,g+.212*p]).clipExtent([[d-.214*p+ce,g+.166*p+ce],[d-.115*p-ce,g+.234*p-ce]]).stream(c),h()},u.fitExtent=function(f,p){return Vy(u,f,p)},u.fitSize=function(f,p){return O2(u,f,p)},u.fitWidth=function(f,p){return z2(u,f,p)},u.fitHeight=function(f,p){return F2(u,f,p)};function h(){return e=t=null,u}return u.scale(1070)}var mLt=M(()=>{lr();hQ();RD();LD()});function DD(e){return function(t,r){var n=ae(t),i=ae(r),o=e(n*i);return[o*i*Jt(t),o*Jt(r)]}}function sf(e){return function(t,r){var n=Rr(t*t+r*r),i=e(n),o=Jt(i),a=ae(i);return[Sn(t*o,n*a),Jn(n&&r*o/n)]}}var H2=M(()=>{lr()});function gLt(){return eo(OD).scale(124.75).clipAngle(180-.001)}var OD,_Lt=M(()=>{lr();H2();Au();OD=DD(function(e){return Rr(2/(1+e))});OD.invert=sf(function(e){return 2*Jn(e/2)})});function yLt(){return eo(zD).scale(79.4188).clipAngle(180-.001)}var zD,vLt=M(()=>{lr();H2();Au();zD=DD(function(e){return(e=$N(e))&&e/Jt(e)});zD.invert=sf(function(e){return e})});function qy(e,t){return[e,Ry(C2((Bn+t)/2))]}function xLt(){return fQ(qy).scale(961/Bi)}function fQ(e){var t=eo(e),r=t.center,n=t.scale,i=t.translate,o=t.clipExtent,a=null,s,l,c;t.scale=function(h){return arguments.length?(n(h),u()):n()},t.translate=function(h){return arguments.length?(i(h),u()):i()},t.center=function(h){return arguments.length?(r(h),u()):r()},t.clipExtent=function(h){return arguments.length?(h==null?a=s=l=c=null:(a=+h[0][0],s=+h[0][1],l=+h[1][0],c=+h[1][1]),u()):a==null?null:[[a,s],[l,c]]};function u(){var h=rr*n(),f=t(sD(t.rotate()).invert([0,0]));return o(a==null?[[f[0]-h,f[1]-h],[f[0]+h,f[1]+h]]:e===qy?[[Math.max(f[0]-h,a),s],[Math.min(f[0]+h,l),c]]:[[a,Math.max(f[1]-h,s)],[l,Math.min(f[1]+h,c)]])}return u()}var FD=M(()=>{lr();NT();Au();qy.invert=function(e,t){return[e,2*yc(jN(t))-Bn]}});function BD(e){return C2((Bn+e)/2)}function pQ(e,t){var r=ae(e),n=e===t?Jt(e):Ry(r/ae(t))/Ry(BD(t)/BD(e)),i=r*XN(BD(e),n)/n;if(!n)return qy;function o(a,s){i>0?s<-Bn+ce&&(s=-Bn+ce):s>Bn-ce&&(s=Bn-ce);var l=i/XN(BD(s),n);return[l*Jt(n*a),i-l*ae(n*a)]}return o.invert=function(a,s){var l=i-s,c=dg(n)*Rr(a*a+l*l);return[Sn(a,Ye(l))/n*dg(l),2*yc(XN(i/c,1/n))-Bn]},o}function bLt(){return B2(pQ).scale(109.5).parallels([30,30])}var wLt=M(()=>{lr();kD();FD()});function Gy(e,t){return[e,t]}function SLt(){return eo(Gy).scale(152.63)}var dQ=M(()=>{Au();Gy.invert=Gy});function mQ(e,t){var r=ae(e),n=e===t?Jt(e):(r-ae(t))/(t-e),i=r/n+e;if(Ye(n)<ce)return Gy;function o(a,s){var l=i-s,c=n*a;return[l*Jt(c),i-l*ae(c)]}return o.invert=function(a,s){var l=i-s;return[Sn(a,Ye(l))/n*dg(l),i-dg(n)*Rr(a*a+l*l)]},o}function MLt(){return B2(mQ).scale(131.154).center([0,13.9389])}var ELt=M(()=>{lr();kD();dQ()});function HD(e,t){var r=ae(t),n=ae(e)*r;return[r*Jt(e)/n,Jt(t)/n]}function TLt(){return eo(HD).scale(144.049).clipAngle(60)}var CLt=M(()=>{lr();H2();Au();HD.invert=sf(yc)});function VD(e,t,r,n){return e===1&&t===1&&r===0&&n===0?nf:vg({point:function(i,o){this.stream.point(i*e+r,o*t+n)}})}function ALt(){var e=1,t=0,r=0,n=1,i=1,o=nf,a=null,s,l,c,u=nf,h,f,p;function d(){return h=f=null,p}return p={stream:function(g){return h&&f===g?h:h=o(u(f=g))},postclip:function(g){return arguments.length?(u=g,a=s=l=c=null,d()):u},clipExtent:function(g){return arguments.length?(u=g==null?(a=s=l=c=null,nf):Qp(a=+g[0][0],s=+g[0][1],l=+g[1][0],c=+g[1][1]),d()):a==null?null:[[a,s],[l,c]]},scale:function(g){return arguments.length?(o=VD((e=+g)*n,e*i,t,r),d()):e},translate:function(g){return arguments.length?(o=VD(e*n,e*i,t=+g[0],r=+g[1]),d()):[t,r]},reflectX:function(g){return arguments.length?(o=VD(e*(n=g?-1:1),e*i,t,r),d()):n<0},reflectY:function(g){return arguments.length?(o=VD(e*n,e*(i=g?-1:1),t,r),d()):i<0},fitExtent:function(g,_){return Vy(p,g,_)},fitSize:function(g,_){return O2(p,g,_)},fitWidth:function(g,_){return z2(p,g,_)},fitHeight:function(g,_){return F2(p,g,_)}}}var PLt=M(()=>{FT();SD();GT();LD()});function UD(e,t){var r=t*t,n=r*r;return[e*(.8707-.131979*r+n*(-.013791+n*(.003971*r-.001529*n))),t*(1.007226+r*(.015085+n*(-.044475+.028874*r-.005916*n)))]}function ILt(){return eo(UD).scale(175.295)}var LLt=M(()=>{Au();lr();UD.invert=function(e,t){var r=t,n=25,i;do{var o=r*r,a=o*o;r-=i=(r*(1.007226+o*(.015085+a*(-.044475+.028874*o-.005916*a)))-t)/(1.007226+o*(.015085*3+a*(-.044475*7+.028874*9*o-.005916*11*a)))}while(Ye(i)>ce&&--n>0);return[e/(.8707+(o=r*r)*(-.131979+o*(-.013791+o*o*o*(.003971-.001529*o)))),r]}});function qD(e,t){return[ae(t)*Jt(e),Jt(t)]}function kLt(){return eo(qD).scale(249.5).clipAngle(90+ce)}var RLt=M(()=>{lr();H2();Au();qD.invert=sf(Jn)});function GD(e,t){var r=ae(t),n=1+ae(e)*r;return[r*Jt(e)/n,Jt(t)/n]}function NLt(){return eo(GD).scale(250).clipAngle(142)}var DLt=M(()=>{lr();H2();Au();GD.invert=sf(function(e){return 2*yc(e)})});function WD(e,t){return[Ry(C2((Bn+t)/2)),-e]}function OLt(){var e=fQ(WD),t=e.center,r=e.rotate;return e.center=function(n){return arguments.length?t([-n[1],n[0]]):(n=t(),[n[1],-n[0]])},e.rotate=function(n){return arguments.length?r([n[0],n[1],n.length>2?n[2]+90:90]):(n=r(),[n[0],n[1],n[2]-90])},r([0,0,90]).scale(159.155)}var zLt=M(()=>{lr();FD();WD.invert=function(e,t){return[-t,2*yc(jN(e))-Bn]}});var FLt=M(()=>{hJ();YIt();QIt();xJ();HJ();VJ();P9t();FT();z9t();YJ();V9t();q9t();GJ();lLt();hQ();mLt();_Lt();vLt();wLt();RD();ELt();dQ();CLt();PLt();Au();FD();LLt();RLt();DLt();zLt();NT();mg();GT()});function TPe(e,t){return e.parent===t.parent?1:2}function CPe(e){return e.reduce(APe,0)/e.length}function APe(e,t){return e+t.x}function PPe(e){return 1+e.reduce(IPe,0)}function IPe(e,t){return Math.max(e,t.y)}function LPe(e){for(var t;t=e.children;)e=t[0];return e}function kPe(e){for(var t;t=e.children;)e=t[t.length-1];return e}function BLt(){var e=TPe,t=1,r=1,n=!1;function i(o){var a,s=0;o.eachAfter(function(f){var p=f.children;p?(f.x=CPe(p),f.y=PPe(p)):(f.x=a?s+=e(f,a):0,f.y=0,a=f)});var l=LPe(o),c=kPe(o),u=l.x-e(l,c)/2,h=c.x+e(c,l)/2;return o.eachAfter(n?function(f){f.x=(f.x-o.x)*t,f.y=(o.y-f.y)*r}:function(f){f.x=(f.x-u)/(h-u)*t,f.y=(1-(o.y?f.y/o.y:1))*r})}return i.separation=function(o){return arguments.length?(e=o,i):e},i.size=function(o){return arguments.length?(n=!1,t=+o[0],r=+o[1],i):n?null:[t,r]},i.nodeSize=function(o){return arguments.length?(n=!0,t=+o[0],r=+o[1],i):n?[t,r]:null},i}var HLt=M(()=>{});function RPe(e){var t=0,r=e.children,n=r&&r.length;if(!n)t=1;else for(;--n>=0;)t+=r[n].value;e.value=t}function VLt(){return this.eachAfter(RPe)}var ULt=M(()=>{});function qLt(e){var t=this,r,n=[t],i,o,a;do for(r=n.reverse(),n=[];t=r.pop();)if(e(t),i=t.children,i)for(o=0,a=i.length;o<a;++o)n.push(i[o]);while(n.length);return this}var GLt=M(()=>{});function WLt(e){for(var t=this,r=[t],n,i;t=r.pop();)if(e(t),n=t.children,n)for(i=n.length-1;i>=0;--i)r.push(n[i]);return this}var YLt=M(()=>{});function jLt(e){for(var t=this,r=[t],n=[],i,o,a;t=r.pop();)if(n.push(t),i=t.children,i)for(o=0,a=i.length;o<a;++o)r.push(i[o]);for(;t=n.pop();)e(t);return this}var XLt=M(()=>{});function $Lt(e){return this.eachAfter(function(t){for(var r=+e(t.data)||0,n=t.children,i=n&&n.length;--i>=0;)r+=n[i].value;t.value=r})}var KLt=M(()=>{});function ZLt(e){return this.eachBefore(function(t){t.children&&t.children.sort(e)})}var JLt=M(()=>{});function QLt(e){for(var t=this,r=NPe(t,e),n=[t];t!==r;)t=t.parent,n.push(t);for(var i=n.length;e!==r;)n.splice(i,0,e),e=e.parent;return n}function NPe(e,t){if(e===t)return e;var r=e.ancestors(),n=t.ancestors(),i=null;for(e=r.pop(),t=n.pop();e===t;)i=e,e=r.pop(),t=n.pop();return i}var tkt=M(()=>{});function ekt(){for(var e=this,t=[e];e=e.parent;)t.push(e);return t}var rkt=M(()=>{});function nkt(){var e=[];return this.each(function(t){e.push(t)}),e}var ikt=M(()=>{});function okt(){var e=[];return this.eachBefore(function(t){t.children||e.push(t)}),e}var akt=M(()=>{});function skt(){var e=this,t=[];return e.each(function(r){r!==e&&t.push({source:r.parent,target:r})}),t}var lkt=M(()=>{});function YT(e,t){var r=new xg(e),n=+e.value&&(r.value=e.value),i,o=[r],a,s,l,c;for(t==null&&(t=OPe);i=o.pop();)if(n&&(i.value=+i.data.value),(s=t(i.data))&&(c=s.length))for(i.children=new Array(c),l=c-1;l>=0;--l)o.push(a=i.children[l]=new xg(s[l])),a.parent=i,a.depth=i.depth+1;return r.eachBefore(gQ)}function DPe(){return YT(this).eachBefore(zPe)}function OPe(e){return e.children}function zPe(e){e.data=e.data.data}function gQ(e){var t=0;do e.height=t;while((e=e.parent)&&e.height<++t)}function xg(e){this.data=e,this.depth=this.height=0,this.parent=null}var YD=M(()=>{ULt();GLt();YLt();XLt();KLt();JLt();tkt();rkt();ikt();akt();lkt();xg.prototype=YT.prototype={constructor:xg,count:VLt,each:qLt,eachAfter:jLt,eachBefore:WLt,sum:$Lt,sort:ZLt,path:QLt,ancestors:ekt,descendants:nkt,leaves:okt,links:skt,copy:DPe}});function ukt(e){for(var t=e.length,r,n;t;)n=Math.random()*t--|0,r=e[t],e[t]=e[n],e[n]=r;return e}var ckt,hkt=M(()=>{ckt=Array.prototype.slice});function XD(e){for(var t=0,r=(e=ukt(ckt.call(e))).length,n=[],i,o;t<r;)i=e[t],o&&fkt(o,i)?++t:(o=BPe(n=FPe(n,i)),t=0);return o}function FPe(e,t){var r,n;if(_Q(t,e))return[t];for(r=0;r<e.length;++r)if(jD(t,e[r])&&_Q(jT(e[r],t),e))return[e[r],t];for(r=0;r<e.length-1;++r)for(n=r+1;n<e.length;++n)if(jD(jT(e[r],e[n]),t)&&jD(jT(e[r],t),e[n])&&jD(jT(e[n],t),e[r])&&_Q(pkt(e[r],e[n],t),e))return[e[r],e[n],t];throw new Error}function jD(e,t){var r=e.r-t.r,n=t.x-e.x,i=t.y-e.y;return r<0||r*r<n*n+i*i}function fkt(e,t){var r=e.r-t.r+1e-6,n=t.x-e.x,i=t.y-e.y;return r>0&&r*r>n*n+i*i}function _Q(e,t){for(var r=0;r<t.length;++r)if(!fkt(e,t[r]))return!1;return!0}function BPe(e){switch(e.length){case 1:return HPe(e[0]);case 2:return jT(e[0],e[1]);case 3:return pkt(e[0],e[1],e[2])}}function HPe(e){return{x:e.x,y:e.y,r:e.r}}function jT(e,t){var r=e.x,n=e.y,i=e.r,o=t.x,a=t.y,s=t.r,l=o-r,c=a-n,u=s-i,h=Math.sqrt(l*l+c*c);return{x:(r+o+l/h*u)/2,y:(n+a+c/h*u)/2,r:(h+i+s)/2}}function pkt(e,t,r){var n=e.x,i=e.y,o=e.r,a=t.x,s=t.y,l=t.r,c=r.x,u=r.y,h=r.r,f=n-a,p=n-c,d=i-s,g=i-u,_=l-o,y=h-o,x=n*n+i*i-o*o,b=x-a*a-s*s+l*l,S=x-c*c-u*u+h*h,C=p*d-f*g,P=(d*S-g*b)/(C*2)-n,k=(g*_-d*y)/C,O=(p*b-f*S)/(C*2)-i,D=(f*y-p*_)/C,B=k*k+D*D-1,I=2*(o+P*k+O*D),L=P*P+O*O-o*o,R=-(B?(I+Math.sqrt(I*I-4*B*L))/(2*B):L/I);return{x:n+P+k*R,y:i+O+D*R,r:R}}var yQ=M(()=>{hkt()});function dkt(e,t,r){var n=e.x,i=e.y,o=t.r+r.r,a=e.r+r.r,s=t.x-n,l=t.y-i,c=s*s+l*l;if(c){var u=.5+((a*=a)-(o*=o))/(2*c),h=Math.sqrt(Math.max(0,2*o*(a+c)-(a-=c)*a-o*o))/(2*c);r.x=n+u*s+h*l,r.y=i+u*l-h*s}else r.x=n+a,r.y=i}function mkt(e,t){var r=t.x-e.x,n=t.y-e.y,i=e.r+t.r;return i*i-1e-6>r*r+n*n}function gkt(e){var t=e._,r=e.next._,n=t.r+r.r,i=(t.x*r.r+r.x*t.r)/n,o=(t.y*r.r+r.y*t.r)/n;return i*i+o*o}function $D(e){this._=e,this.next=null,this.previous=null}function vQ(e){if(!(i=e.length))return 0;var t,r,n,i,o,a,s,l,c,u,h;if(t=e[0],t.x=0,t.y=0,!(i>1))return t.r;if(r=e[1],t.x=-r.r,r.x=t.r,r.y=0,!(i>2))return t.r+r.r;dkt(r,t,n=e[2]),t=new $D(t),r=new $D(r),n=new $D(n),t.next=n.previous=r,r.next=t.previous=n,n.next=r.previous=t;t:for(s=3;s<i;++s){dkt(t._,r._,n=e[s]),n=new $D(n),l=r.next,c=t.previous,u=r._.r,h=t._.r;do if(u<=h){if(mkt(l._,n._)){r=l,t.next=r,r.previous=t,--s;continue t}u+=l._.r,l=l.next}else{if(mkt(c._,n._)){t=c,t.next=r,r.previous=t,--s;continue t}h+=c._.r,c=c.previous}while(l!==c.next);for(n.previous=t,n.next=r,t.next=r.previous=r=n,o=gkt(t);(n=n.next)!==r;)(a=gkt(n))<o&&(t=n,o=a);r=t.next}for(t=[r._],n=r;(n=n.next)!==r;)t.push(n._);for(n=XD(t),s=0;s<i;++s)t=e[s],t.x-=n.x,t.y-=n.y;return n.r}function _kt(e){return vQ(e),e}var xQ=M(()=>{yQ()});function ykt(e){return e==null?null:V2(e)}function V2(e){if(typeof e!="function")throw new Error;return e}var KD=M(()=>{});function td(){return 0}function bg(e){return function(){return e}}var bQ=M(()=>{});function VPe(e){return Math.sqrt(e.value)}function bkt(){var e=null,t=1,r=1,n=td;function i(o){return o.x=t/2,o.y=r/2,e?o.eachBefore(vkt(e)).eachAfter(wQ(n,.5)).eachBefore(xkt(1)):o.eachBefore(vkt(VPe)).eachAfter(wQ(td,1)).eachAfter(wQ(n,o.r/Math.min(t,r))).eachBefore(xkt(Math.min(t,r)/(2*o.r))),o}return i.radius=function(o){return arguments.length?(e=ykt(o),i):e},i.size=function(o){return arguments.length?(t=+o[0],r=+o[1],i):[t,r]},i.padding=function(o){return arguments.length?(n=typeof o=="function"?o:bg(+o),i):n},i}function vkt(e){return function(t){t.children||(t.r=Math.max(0,+e(t)||0))}}function wQ(e,t){return function(r){if(n=r.children){var n,i,o=n.length,a=e(r)*t||0,s;if(a)for(i=0;i<o;++i)n[i].r+=a;if(s=vQ(n),a)for(i=0;i<o;++i)n[i].r-=a;r.r=s+a}}}function xkt(e){return function(t){var r=t.parent;t.r*=e,r&&(t.x=r.x+e*t.x,t.y=r.y+e*t.y)}}var wkt=M(()=>{xQ();KD();bQ()});function ZD(e){e.x0=Math.round(e.x0),e.y0=Math.round(e.y0),e.x1=Math.round(e.x1),e.y1=Math.round(e.y1)}var SQ=M(()=>{});function lf(e,t,r,n,i){for(var o=e.children,a,s=-1,l=o.length,c=e.value&&(n-t)/e.value;++s<l;)a=o[s],a.y0=r,a.y1=i,a.x0=t,a.x1=t+=a.value*c}var U2=M(()=>{});function Skt(){var e=1,t=1,r=0,n=!1;function i(a){var s=a.height+1;return a.x0=a.y0=r,a.x1=e,a.y1=t/s,a.eachBefore(o(t,s)),n&&a.eachBefore(ZD),a}function o(a,s){return function(l){l.children&&lf(l,l.x0,a*(l.depth+1)/s,l.x1,a*(l.depth+2)/s);var c=l.x0,u=l.y0,h=l.x1-r,f=l.y1-r;h<c&&(c=h=(c+h)/2),f<u&&(u=f=(u+f)/2),l.x0=c,l.y0=u,l.x1=h,l.y1=f}}return i.round=function(a){return arguments.length?(n=!!a,i):n},i.size=function(a){return arguments.length?(e=+a[0],t=+a[1],i):[e,t]},i.padding=function(a){return arguments.length?(r=+a,i):r},i}var Mkt=M(()=>{SQ();U2()});function qPe(e){return e.id}function GPe(e){return e.parentId}function Ckt(){var e=qPe,t=GPe;function r(n){var i,o,a=n.length,s,l,c,u=new Array(a),h,f,p={};for(o=0;o<a;++o)i=n[o],c=u[o]=new xg(i),(h=e(i,o,n))!=null&&(h+="")&&(f=Ekt+(c.id=h),p[f]=f in p?Tkt:c);for(o=0;o<a;++o)if(c=u[o],h=t(n[o],o,n),h==null||!(h+="")){if(s)throw new Error("multiple roots");s=c}else{if(l=p[Ekt+h],!l)throw new Error("missing: "+h);if(l===Tkt)throw new Error("ambiguous: "+h);l.children?l.children.push(c):l.children=[c],c.parent=l}if(!s)throw new Error("no root");if(s.parent=UPe,s.eachBefore(function(d){d.depth=d.parent.depth+1,--a}).eachBefore(gQ),s.parent=null,a>0)throw new Error("cycle");return s}return r.id=function(n){return arguments.length?(e=V2(n),r):e},r.parentId=function(n){return arguments.length?(t=V2(n),r):t},r}var Ekt,UPe,Tkt,Akt=M(()=>{KD();YD();Ekt="$",UPe={depth:-1},Tkt={}});function WPe(e,t){return e.parent===t.parent?1:2}function MQ(e){var t=e.children;return t?t[0]:e.t}function EQ(e){var t=e.children;return t?t[t.length-1]:e.t}function YPe(e,t,r){var n=r/(t.i-e.i);t.c-=n,t.s+=r,e.c+=n,t.z+=r,t.m+=r}function jPe(e){for(var t=0,r=0,n=e.children,i=n.length,o;--i>=0;)o=n[i],o.z+=t,o.m+=t,t+=o.s+(r+=o.c)}function XPe(e,t,r){return e.a.parent===t.parent?e.a:r}function JD(e,t){this._=e,this.parent=null,this.children=null,this.A=null,this.a=this,this.z=0,this.m=0,this.c=0,this.s=0,this.t=null,this.i=t}function $Pe(e){for(var t=new JD(e,0),r,n=[t],i,o,a,s;r=n.pop();)if(o=r._.children)for(r.children=new Array(s=o.length),a=s-1;a>=0;--a)n.push(i=r.children[a]=new JD(o[a],a)),i.parent=r;return(t.parent=new JD(null,0)).children=[t],t}function Pkt(){var e=WPe,t=1,r=1,n=null;function i(c){var u=$Pe(c);if(u.eachAfter(o),u.parent.m=-u.z,u.eachBefore(a),n)c.eachBefore(l);else{var h=c,f=c,p=c;c.eachBefore(function(x){x.x<h.x&&(h=x),x.x>f.x&&(f=x),x.depth>p.depth&&(p=x)});var d=h===f?1:e(h,f)/2,g=d-h.x,_=t/(f.x+d+g),y=r/(p.depth||1);c.eachBefore(function(x){x.x=(x.x+g)*_,x.y=x.depth*y})}return c}function o(c){var u=c.children,h=c.parent.children,f=c.i?h[c.i-1]:null;if(u){jPe(c);var p=(u[0].z+u[u.length-1].z)/2;f?(c.z=f.z+e(c._,f._),c.m=c.z-p):c.z=p}else f&&(c.z=f.z+e(c._,f._));c.parent.A=s(c,f,c.parent.A||h[0])}function a(c){c._.x=c.z+c.parent.m,c.m+=c.parent.m}function s(c,u,h){if(u){for(var f=c,p=c,d=u,g=f.parent.children[0],_=f.m,y=p.m,x=d.m,b=g.m,S;d=EQ(d),f=MQ(f),d&&f;)g=MQ(g),p=EQ(p),p.a=c,S=d.z+x-f.z-_+e(d._,f._),S>0&&(YPe(XPe(d,c,h),c,S),_+=S,y+=S),x+=d.m,_+=f.m,b+=g.m,y+=p.m;d&&!EQ(p)&&(p.t=d,p.m+=x-y),f&&!MQ(g)&&(g.t=f,g.m+=_-b,h=c)}return h}function l(c){c.x*=t,c.y=c.depth*r}return i.separation=function(c){return arguments.length?(e=c,i):e},i.size=function(c){return arguments.length?(n=!1,t=+c[0],r=+c[1],i):n?null:[t,r]},i.nodeSize=function(c){return arguments.length?(n=!0,t=+c[0],r=+c[1],i):n?[t,r]:null},i}var Ikt=M(()=>{YD();JD.prototype=Object.create(xg.prototype)});function wg(e,t,r,n,i){for(var o=e.children,a,s=-1,l=o.length,c=e.value&&(i-r)/e.value;++s<l;)a=o[s],a.x0=t,a.x1=n,a.y0=r,a.y1=r+=a.value*c}var XT=M(()=>{});function CQ(e,t,r,n,i,o){for(var a=[],s=t.children,l,c,u=0,h=0,f=s.length,p,d,g=t.value,_,y,x,b,S,C,P;u<f;){p=i-r,d=o-n;do _=s[h++].value;while(!_&&h<f);for(y=x=_,C=Math.max(d/p,p/d)/(g*e),P=_*_*C,S=Math.max(x/P,P/y);h<f;++h){if(_+=c=s[h].value,c<y&&(y=c),c>x&&(x=c),P=_*_*C,b=Math.max(x/P,P/y),b>S){_-=c;break}S=b}a.push(l={value:_,dice:p<d,children:s.slice(u,h)}),l.dice?lf(l,r,n,i,g?n+=d*_/g:o):wg(l,r,n,g?r+=p*_/g:i,o),g-=_,u=h}return a}var TQ,QD,tO=M(()=>{U2();XT();TQ=(1+Math.sqrt(5))/2;QD=function e(t){function r(n,i,o,a,s){CQ(t,n,i,o,a,s)}return r.ratio=function(n){return e((n=+n)>1?n:1)},r}(TQ)});function Lkt(){var e=QD,t=!1,r=1,n=1,i=[0],o=td,a=td,s=td,l=td,c=td;function u(f){return f.x0=f.y0=0,f.x1=r,f.y1=n,f.eachBefore(h),i=[0],t&&f.eachBefore(ZD),f}function h(f){var p=i[f.depth],d=f.x0+p,g=f.y0+p,_=f.x1-p,y=f.y1-p;_<d&&(d=_=(d+_)/2),y<g&&(g=y=(g+y)/2),f.x0=d,f.y0=g,f.x1=_,f.y1=y,f.children&&(p=i[f.depth+1]=o(f)/2,d+=c(f)-p,g+=a(f)-p,_-=s(f)-p,y-=l(f)-p,_<d&&(d=_=(d+_)/2),y<g&&(g=y=(g+y)/2),e(f,d,g,_,y))}return u.round=function(f){return arguments.length?(t=!!f,u):t},u.size=function(f){return arguments.length?(r=+f[0],n=+f[1],u):[r,n]},u.tile=function(f){return arguments.length?(e=V2(f),u):e},u.padding=function(f){return arguments.length?u.paddingInner(f).paddingOuter(f):u.paddingInner()},u.paddingInner=function(f){return arguments.length?(o=typeof f=="function"?f:bg(+f),u):o},u.paddingOuter=function(f){return arguments.length?u.paddingTop(f).paddingRight(f).paddingBottom(f).paddingLeft(f):u.paddingTop()},u.paddingTop=function(f){return arguments.length?(a=typeof f=="function"?f:bg(+f),u):a},u.paddingRight=function(f){return arguments.length?(s=typeof f=="function"?f:bg(+f),u):s},u.paddingBottom=function(f){return arguments.length?(l=typeof f=="function"?f:bg(+f),u):l},u.paddingLeft=function(f){return arguments.length?(c=typeof f=="function"?f:bg(+f),u):c},u}var kkt=M(()=>{SQ();tO();KD();bQ()});function Rkt(e,t,r,n,i){var o=e.children,a,s=o.length,l,c=new Array(s+1);for(c[0]=l=a=0;a<s;++a)c[a+1]=l+=o[a].value;u(0,s,e.value,t,r,n,i);function u(h,f,p,d,g,_,y){if(h>=f-1){var x=o[h];x.x0=d,x.y0=g,x.x1=_,x.y1=y;return}for(var b=c[h],S=p/2+b,C=h+1,P=f-1;C<P;){var k=C+P>>>1;c[k]<S?C=k+1:P=k}S-c[C-1]<c[C]-S&&h+1<C&&--C;var O=c[C]-b,D=p-O;if(_-d>y-g){var B=(d*D+_*O)/p;u(h,C,O,d,g,B,y),u(C,f,D,B,g,_,y)}else{var I=(g*D+y*O)/p;u(h,C,O,d,g,_,I),u(C,f,D,d,I,_,y)}}}var Nkt=M(()=>{});function Dkt(e,t,r,n,i){(e.depth&1?wg:lf)(e,t,r,n,i)}var Okt=M(()=>{U2();XT()});var zkt,Fkt=M(()=>{U2();XT();tO();zkt=function e(t){function r(n,i,o,a,s){if((l=n._squarify)&&l.ratio===t)for(var l,c,u,h,f=-1,p,d=l.length,g=n.value;++f<d;){for(c=l[f],u=c.children,h=c.value=0,p=u.length;h<p;++h)c.value+=u[h].value;c.dice?lf(c,i,o,a,o+=(s-o)*c.value/g):wg(c,i,o,i+=(a-i)*c.value/g,s),g-=c.value}else n._squarify=l=CQ(t,n,i,o,a,s),l.ratio=t}return r.ratio=function(n){return e((n=+n)>1?n:1)},r}(TQ)});var Bkt=M(()=>{HLt();YD();wkt();xQ();yQ();Mkt();Akt();Ikt();kkt();Nkt();U2();XT();Okt();tO();Fkt()});function ed(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function Sg(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}var eO=M(()=>{});function hf(){}function Vkt(){return this.rgb().formatHex()}function n6e(){return jkt(this).formatHsl()}function Ukt(){return this.rgb().formatRgb()}function Eg(e){var t,r;return e=(e+"").trim().toLowerCase(),(t=KPe.exec(e))?(r=t[1].length,t=parseInt(t[1],16),r===6?qkt(t):r===3?new ro(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?rO(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?rO(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=ZPe.exec(e))?new ro(t[1],t[2],t[3],1):(t=JPe.exec(e))?new ro(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=QPe.exec(e))?rO(t[1],t[2],t[3],t[4]):(t=t6e.exec(e))?rO(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=e6e.exec(e))?Ykt(t[1],t[2]/100,t[3]/100,1):(t=r6e.exec(e))?Ykt(t[1],t[2]/100,t[3]/100,t[4]):Hkt.hasOwnProperty(e)?qkt(Hkt[e]):e==="transparent"?new ro(NaN,NaN,NaN,0):null}function qkt(e){return new ro(e>>16&255,e>>8&255,e&255,1)}function rO(e,t,r,n){return n<=0&&(e=t=r=NaN),new ro(e,t,r,n)}function KT(e){return e instanceof hf||(e=Eg(e)),e?(e=e.rgb(),new ro(e.r,e.g,e.b,e.opacity)):new ro}function G2(e,t,r,n){return arguments.length===1?KT(e):new ro(e,t,r,n==null?1:n)}function ro(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}function Gkt(){return"#"+AQ(this.r)+AQ(this.g)+AQ(this.b)}function Wkt(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}function AQ(e){return e=Math.max(0,Math.min(255,Math.round(e)||0)),(e<16?"0":"")+e.toString(16)}function Ykt(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new cf(e,t,r,n)}function jkt(e){if(e instanceof cf)return new cf(e.h,e.s,e.l,e.opacity);if(e instanceof hf||(e=Eg(e)),!e)return new cf;if(e instanceof cf)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new cf(a,s,l,e.opacity)}function ZT(e,t,r,n){return arguments.length===1?jkt(e):new cf(e,t,r,n==null?1:n)}function cf(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}function PQ(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var Mg,Wy,q2,$T,uf,KPe,ZPe,JPe,QPe,t6e,e6e,r6e,Hkt,nO=M(()=>{eO();Mg=.7,Wy=1/Mg,q2="\\s*([+-]?\\d+)\\s*",$T="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",uf="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",KPe=/^#([0-9a-f]{3,8})$/,ZPe=new RegExp("^rgb\\("+[q2,q2,q2]+"\\)$"),JPe=new RegExp("^rgb\\("+[uf,uf,uf]+"\\)$"),QPe=new RegExp("^rgba\\("+[q2,q2,q2,$T]+"\\)$"),t6e=new RegExp("^rgba\\("+[uf,uf,uf,$T]+"\\)$"),e6e=new RegExp("^hsl\\("+[$T,uf,uf]+"\\)$"),r6e=new RegExp("^hsla\\("+[$T,uf,uf,$T]+"\\)$"),Hkt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};ed(hf,Eg,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:Vkt,formatHex:Vkt,formatHsl:n6e,formatRgb:Ukt,toString:Ukt});ed(ro,G2,Sg(hf,{brighter:function(e){return e=e==null?Wy:Math.pow(Wy,e),new ro(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?Mg:Math.pow(Mg,e),new ro(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:Gkt,formatHex:Gkt,formatRgb:Wkt,toString:Wkt}));ed(cf,ZT,Sg(hf,{brighter:function(e){return e=e==null?Wy:Math.pow(Wy,e),new cf(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Mg:Math.pow(Mg,e),new cf(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new ro(PQ(e>=240?e-240:e+120,i,n),PQ(e,i,n),PQ(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(e===1?")":", "+e+")")}}))});var iO,oO,IQ=M(()=>{iO=Math.PI/180,oO=180/Math.PI});function Qkt(e){if(e instanceof ff)return new ff(e.l,e.a,e.b,e.opacity);if(e instanceof rd)return t8t(e);e instanceof ro||(e=KT(e));var t=NQ(e.r),r=NQ(e.g),n=NQ(e.b),i=LQ((.2225045*t+.7168786*r+.0606169*n)/$kt),o,a;return t===r&&r===n?o=a=i:(o=LQ((.4360747*t+.3850649*r+.1430804*n)/Xkt),a=LQ((.0139322*t+.0971045*r+.7141733*n)/Kkt)),new ff(116*i-16,500*(o-i),200*(i-a),e.opacity)}function Y2(e,t,r,n){return arguments.length===1?Qkt(e):new ff(e,t,r,n==null?1:n)}function ff(e,t,r,n){this.l=+e,this.a=+t,this.b=+r,this.opacity=+n}function LQ(e){return e>i6e?Math.pow(e,1/3):e/Jkt+Zkt}function kQ(e){return e>W2?e*e*e:Jkt*(e-Zkt)}function RQ(e){return 255*(e<=.0031308?12.92*e:1.055*Math.pow(e,1/2.4)-.055)}function NQ(e){return(e/=255)<=.04045?e/12.92:Math.pow((e+.055)/1.055,2.4)}function o6e(e){if(e instanceof rd)return new rd(e.h,e.c,e.l,e.opacity);if(e instanceof ff||(e=Qkt(e)),e.a===0&&e.b===0)return new rd(NaN,0<e.l&&e.l<100?0:NaN,e.l,e.opacity);var t=Math.atan2(e.b,e.a)*oO;return new rd(t<0?t+360:t,Math.sqrt(e.a*e.a+e.b*e.b),e.l,e.opacity)}function JT(e,t,r,n){return arguments.length===1?o6e(e):new rd(e,t,r,n==null?1:n)}function rd(e,t,r,n){this.h=+e,this.c=+t,this.l=+r,this.opacity=+n}function t8t(e){if(isNaN(e.h))return new ff(e.l,0,0,e.opacity);var t=e.h*iO;return new ff(e.l,Math.cos(t)*e.c,Math.sin(t)*e.c,e.opacity)}var aO,Xkt,$kt,Kkt,Zkt,W2,Jkt,i6e,e8t=M(()=>{eO();nO();IQ();aO=18,Xkt=.96422,$kt=1,Kkt=.82521,Zkt=4/29,W2=6/29,Jkt=3*W2*W2,i6e=W2*W2*W2;ed(ff,Y2,Sg(hf,{brighter:function(e){return new ff(this.l+aO*(e==null?1:e),this.a,this.b,this.opacity)},darker:function(e){return new ff(this.l-aO*(e==null?1:e),this.a,this.b,this.opacity)},rgb:function(){var e=(this.l+16)/116,t=isNaN(this.a)?e:e+this.a/500,r=isNaN(this.b)?e:e-this.b/200;return t=Xkt*kQ(t),e=$kt*kQ(e),r=Kkt*kQ(r),new ro(RQ(3.1338561*t-1.6168667*e-.4906146*r),RQ(-.9787684*t+1.9161415*e+.033454*r),RQ(.0719453*t-.2289914*e+1.4052427*r),this.opacity)}}));ed(rd,JT,Sg(hf,{brighter:function(e){return new rd(this.h,this.c,this.l+aO*(e==null?1:e),this.opacity)},darker:function(e){return new rd(this.h,this.c,this.l-aO*(e==null?1:e),this.opacity)},rgb:function(){return t8t(this).rgb()}}))});function a6e(e){if(e instanceof Yy)return new Yy(e.h,e.s,e.l,e.opacity);e instanceof ro||(e=KT(e));var t=e.r/255,r=e.g/255,n=e.b/255,i=(i8t*n+r8t*t-n8t*r)/(i8t+r8t-n8t),o=n-i,a=(QT*(r-i)-OQ*o)/sO,s=Math.sqrt(a*a+o*o)/(QT*i*(1-i)),l=s?Math.atan2(a,o)*oO-120:NaN;return new Yy(l<0?l+360:l,s,i,e.opacity)}function j2(e,t,r,n){return arguments.length===1?a6e(e):new Yy(e,t,r,n==null?1:n)}function Yy(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}var o8t,DQ,OQ,sO,QT,r8t,n8t,i8t,a8t=M(()=>{eO();nO();IQ();o8t=-.14861,DQ=1.78277,OQ=-.29227,sO=-.90649,QT=1.97294,r8t=QT*sO,n8t=QT*DQ,i8t=DQ*OQ-sO*o8t;ed(Yy,j2,Sg(hf,{brighter:function(e){return e=e==null?Wy:Math.pow(Wy,e),new Yy(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Mg:Math.pow(Mg,e),new Yy(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=isNaN(this.h)?0:(this.h+120)*iO,t=+this.l,r=isNaN(this.s)?0:this.s*t*(1-t),n=Math.cos(e),i=Math.sin(e);return new ro(255*(t+r*(o8t*n+DQ*i)),255*(t+r*(OQ*n+sO*i)),255*(t+r*(QT*n)),this.opacity)}}))});var jy=M(()=>{nO();e8t();a8t()});function zQ(e,t,r,n,i){var o=e*e,a=o*e;return((1-3*e+3*o-a)*t+(4-6*o+3*a)*r+(1+3*e+3*o-3*a)*n+a*i)/6}function lO(e){var t=e.length-1;return function(r){var n=r<=0?r=0:r>=1?(r=1,t-1):Math.floor(r*t),i=e[n],o=e[n+1],a=n>0?e[n-1]:2*i-o,s=n<t-1?e[n+2]:2*o-i;return zQ((r-n/t)*t,a,i,o,s)}}var cO=M(()=>{});function uO(e){var t=e.length;return function(r){var n=Math.floor(((r%=1)<0?++r:r)*t),i=e[(n+t-1)%t],o=e[n%t],a=e[(n+1)%t],s=e[(n+2)%t];return zQ((r-n/t)*t,i,o,a,s)}}var FQ=M(()=>{cO()});function X2(e){return function(){return e}}var BQ=M(()=>{});function s8t(e,t){return function(r){return e+r*t}}function s6e(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function $2(e,t){var r=t-e;return r?s8t(e,r>180||r<-180?r-360*Math.round(r/360):r):X2(isNaN(e)?t:e)}function l8t(e){return(e=+e)==1?Qn:function(t,r){return r-t?s6e(t,r,e):X2(isNaN(t)?r:t)}}function Qn(e,t){var r=t-e;return r?s8t(e,r):X2(isNaN(e)?t:e)}var K2=M(()=>{BQ()});function c8t(e){return function(t){var r=t.length,n=new Array(r),i=new Array(r),o=new Array(r),a,s;for(a=0;a<r;++a)s=G2(t[a]),n[a]=s.r||0,i[a]=s.g||0,o[a]=s.b||0;return n=e(n),i=e(i),o=e(o),s.opacity=1,function(l){return s.r=n(l),s.g=i(l),s.b=o(l),s+""}}}var tC,u8t,h8t,HQ=M(()=>{jy();cO();FQ();K2();tC=function e(t){var r=l8t(t);function n(i,o){var a=r((i=G2(i)).r,(o=G2(o)).r),s=r(i.g,o.g),l=r(i.b,o.b),c=Qn(i.opacity,o.opacity);return function(u){return i.r=a(u),i.g=s(u),i.b=l(u),i.opacity=c(u),i+""}}return n.gamma=e,n}(1);u8t=c8t(lO),h8t=c8t(uO)});function hO(e,t){var r=t?t.length:0,n=e?Math.min(r,e.length):0,i=new Array(n),o=new Array(r),a;for(a=0;a<n;++a)i[a]=Z2(e[a],t[a]);for(;a<r;++a)o[a]=t[a];return function(s){for(a=0;a<n;++a)o[a]=i[a](s);return o}}var VQ=M(()=>{fO()});function pO(e,t){var r=new Date;return e=+e,t-=e,function(n){return r.setTime(e+t*n),r}}var UQ=M(()=>{});function As(e,t){return e=+e,t-=e,function(r){return e+t*r}}var eC=M(()=>{});function dO(e,t){var r={},n={},i;(e===null||typeof e!="object")&&(e={}),(t===null||typeof t!="object")&&(t={});for(i in t)i in e?r[i]=Z2(e[i],t[i]):n[i]=t[i];return function(o){for(i in r)n[i]=r[i](o);return n}}var qQ=M(()=>{fO()});function l6e(e){return function(){return e}}function c6e(e){return function(t){return e(t)+""}}function mO(e,t){var r=WQ.lastIndex=GQ.lastIndex=0,n,i,o,a=-1,s=[],l=[];for(e=e+"",t=t+"";(n=WQ.exec(e))&&(i=GQ.exec(t));)(o=i.index)>r&&(o=t.slice(r,o),s[a]?s[a]+=o:s[++a]=o),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:As(n,i)})),r=GQ.lastIndex;return r<t.length&&(o=t.slice(r),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?c6e(l[0].x):l6e(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)s[(h=l[u]).i]=h.x(c);return s.join("")})}var WQ,GQ,YQ=M(()=>{eC();WQ=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,GQ=new RegExp(WQ.source,"g")});function Z2(e,t){var r=typeof t,n;return t==null||r==="boolean"?X2(t):(r==="number"?As:r==="string"?(n=Eg(t))?(t=n,tC):mO:t instanceof Eg?tC:t instanceof Date?pO:Array.isArray(t)?hO:typeof t.valueOf!="function"&&typeof t.toString!="function"||isNaN(t)?dO:As)(e,t)}var fO=M(()=>{jy();HQ();VQ();UQ();eC();qQ();YQ();BQ()});function f8t(e,t){return e=+e,t-=e,function(r){return Math.round(e+t*r)}}var p8t=M(()=>{});function jQ(e,t,r,n,i,o){var a,s,l;return(a=Math.sqrt(e*e+t*t))&&(e/=a,t/=a),(l=e*r+t*n)&&(r-=e*l,n-=t*l),(s=Math.sqrt(r*r+n*n))&&(r/=s,n/=s,l/=s),e*n<t*r&&(e=-e,t=-t,l=-l,a=-a),{translateX:i,translateY:o,rotate:Math.atan2(t,e)*d8t,skewX:Math.atan(l)*d8t,scaleX:a,scaleY:s}}var d8t,gO,m8t=M(()=>{d8t=180/Math.PI,gO={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1}});function _8t(e){return e==="none"?gO:(rC||(rC=document.createElement("DIV"),XQ=document.documentElement,g8t=document.defaultView),rC.style.transform=e,e=g8t.getComputedStyle(XQ.appendChild(rC),null).getPropertyValue("transform"),XQ.removeChild(rC),e=e.slice(7,-1).split(","),jQ(+e[0],+e[1],+e[2],+e[3],+e[4],+e[5]))}function y8t(e){return e==null?gO:(_O||(_O=document.createElementNS("http://www.w3.org/2000/svg","g")),_O.setAttribute("transform",e),(e=_O.transform.baseVal.consolidate())?(e=e.matrix,jQ(e.a,e.b,e.c,e.d,e.e,e.f)):gO)}var rC,XQ,g8t,_O,v8t=M(()=>{m8t()});function x8t(e,t,r,n){function i(c){return c.length?c.pop()+" ":""}function o(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push("translate(",null,t,null,r);d.push({i:g-4,x:As(c,h)},{i:g-2,x:As(u,f)})}else(h||f)&&p.push("translate("+h+t+f+r)}function a(c,u,h,f){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),f.push({i:h.push(i(h)+"rotate(",null,n)-2,x:As(c,u)})):u&&h.push(i(h)+"rotate("+u+n)}function s(c,u,h,f){c!==u?f.push({i:h.push(i(h)+"skewX(",null,n)-2,x:As(c,u)}):u&&h.push(i(h)+"skewX("+u+n)}function l(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push(i(p)+"scale(",null,",",null,")");d.push({i:g-4,x:As(c,h)},{i:g-2,x:As(u,f)})}else(h!==1||f!==1)&&p.push(i(p)+"scale("+h+","+f+")")}return function(c,u){var h=[],f=[];return c=e(c),u=e(u),o(c.translateX,c.translateY,u.translateX,u.translateY,h,f),a(c.rotate,u.rotate,h,f),s(c.skewX,u.skewX,h,f),l(c.scaleX,c.scaleY,u.scaleX,u.scaleY,h,f),c=u=null,function(p){for(var d=-1,g=f.length,_;++d<g;)h[(_=f[d]).i]=_.x(p);return h.join("")}}}var b8t,w8t,S8t=M(()=>{eC();v8t();b8t=x8t(_8t,"px, ","px)","deg)"),w8t=x8t(y8t,", ",")",")")});function E8t(e){return((e=Math.exp(e))+1/e)/2}function h6e(e){return((e=Math.exp(e))-1/e)/2}function f6e(e){return((e=Math.exp(2*e))-1)/(e+1)}function T8t(e,t){var r=e[0],n=e[1],i=e[2],o=t[0],a=t[1],s=t[2],l=o-r,c=a-n,u=l*l+c*c,h,f;if(u<u6e)f=Math.log(s/i)/nC,h=function(x){return[r+x*l,n+x*c,i*Math.exp(nC*x*f)]};else{var p=Math.sqrt(u),d=(s*s-i*i+M8t*u)/(2*i*$Q*p),g=(s*s-i*i-M8t*u)/(2*s*$Q*p),_=Math.log(Math.sqrt(d*d+1)-d),y=Math.log(Math.sqrt(g*g+1)-g);f=(y-_)/nC,h=function(x){var b=x*f,S=E8t(_),C=i/($Q*p)*(S*f6e(nC*b+_)-h6e(_));return[r+C*l,n+C*c,i*S/E8t(nC*b+_)]}}return h.duration=f*1e3,h}var nC,$Q,M8t,u6e,C8t=M(()=>{nC=Math.SQRT2,$Q=2,M8t=4,u6e=1e-12});function A8t(e){return function(t,r){var n=e((t=ZT(t)).h,(r=ZT(r)).h),i=Qn(t.s,r.s),o=Qn(t.l,r.l),a=Qn(t.opacity,r.opacity);return function(s){return t.h=n(s),t.s=i(s),t.l=o(s),t.opacity=a(s),t+""}}}var P8t,I8t,L8t=M(()=>{jy();K2();P8t=A8t($2),I8t=A8t(Qn)});function KQ(e,t){var r=Qn((e=Y2(e)).l,(t=Y2(t)).l),n=Qn(e.a,t.a),i=Qn(e.b,t.b),o=Qn(e.opacity,t.opacity);return function(a){return e.l=r(a),e.a=n(a),e.b=i(a),e.opacity=o(a),e+""}}var k8t=M(()=>{jy();K2()});function R8t(e){return function(t,r){var n=e((t=JT(t)).h,(r=JT(r)).h),i=Qn(t.c,r.c),o=Qn(t.l,r.l),a=Qn(t.opacity,r.opacity);return function(s){return t.h=n(s),t.c=i(s),t.l=o(s),t.opacity=a(s),t+""}}}var N8t,D8t,O8t=M(()=>{jy();K2();N8t=R8t($2),D8t=R8t(Qn)});function z8t(e){return function t(r){r=+r;function n(i,o){var a=e((i=j2(i)).h,(o=j2(o)).h),s=Qn(i.s,o.s),l=Qn(i.l,o.l),c=Qn(i.opacity,o.opacity);return function(u){return i.h=a(u),i.s=s(u),i.l=l(Math.pow(u,r)),i.opacity=c(u),i+""}}return n.gamma=t,n}(1)}var F8t,B8t,H8t=M(()=>{jy();K2();F8t=z8t($2),B8t=z8t(Qn)});function V8t(e,t){for(var r=new Array(t),n=0;n<t;++n)r[n]=e(n/(t-1));return r}var U8t=M(()=>{});var q8t=M(()=>{fO();VQ();cO();FQ();UQ();eC();qQ();p8t();YQ();S8t();C8t();HQ();L8t();k8t();O8t();H8t();U8t()});function QQ(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function G8t(){return new QQ}var ZQ,JQ,Xy,p6e,W8t,Y8t=M(()=>{ZQ=Math.PI,JQ=2*ZQ,Xy=1e-6,p6e=JQ-Xy;QQ.prototype=G8t.prototype={constructor:QQ,moveTo:function(e,t){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)},closePath:function(){this._x1!==null&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(e,t){this._+="L"+(this._x1=+e)+","+(this._y1=+t)},quadraticCurveTo:function(e,t,r,n){this._+="Q"+ +e+","+ +t+","+(this._x1=+r)+","+(this._y1=+n)},bezierCurveTo:function(e,t,r,n,i,o){this._+="C"+ +e+","+ +t+","+ +r+","+ +n+","+(this._x1=+i)+","+(this._y1=+o)},arcTo:function(e,t,r,n,i){e=+e,t=+t,r=+r,n=+n,i=+i;var o=this._x1,a=this._y1,s=r-e,l=n-t,c=o-e,u=a-t,h=c*c+u*u;if(i<0)throw new Error("negative radius: "+i);if(this._x1===null)this._+="M"+(this._x1=e)+","+(this._y1=t);else if(h>Xy)if(!(Math.abs(u*s-l*c)>Xy)||!i)this._+="L"+(this._x1=e)+","+(this._y1=t);else{var f=r-o,p=n-a,d=s*s+l*l,g=f*f+p*p,_=Math.sqrt(d),y=Math.sqrt(h),x=i*Math.tan((ZQ-Math.acos((d+h-g)/(2*_*y)))/2),b=x/y,S=x/_;Math.abs(b-1)>Xy&&(this._+="L"+(e+b*c)+","+(t+b*u)),this._+="A"+i+","+i+",0,0,"+ +(u*f>c*p)+","+(this._x1=e+S*s)+","+(this._y1=t+S*l)}},arc:function(e,t,r,n,i,o){e=+e,t=+t,r=+r;var a=r*Math.cos(n),s=r*Math.sin(n),l=e+a,c=t+s,u=1^o,h=o?n-i:i-n;if(r<0)throw new Error("negative radius: "+r);this._x1===null?this._+="M"+l+","+c:(Math.abs(this._x1-l)>Xy||Math.abs(this._y1-c)>Xy)&&(this._+="L"+l+","+c),r&&(h<0&&(h=h%JQ+JQ),h>p6e?this._+="A"+r+","+r+",0,1,"+u+","+(e-a)+","+(t-s)+"A"+r+","+r+",0,1,"+u+","+(this._x1=l)+","+(this._y1=c):h>Xy&&(this._+="A"+r+","+r+",0,"+ +(h>=ZQ)+","+u+","+(this._x1=e+r*Math.cos(i))+","+(this._y1=t+r*Math.sin(i))))},rect:function(e,t,r,n){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)+"h"+ +r+"v"+ +n+"h"+-r+"Z"},toString:function(){return this._}};W8t=G8t});var j8t=M(()=>{Y8t()});function X8t(e){for(var t=-1,r=e.length,n,i=e[r-1],o=0;++t<r;)n=i,i=e[t],o+=n[1]*i[0]-n[0]*i[1];return o/2}var $8t=M(()=>{});function K8t(e){for(var t=-1,r=e.length,n=0,i=0,o,a=e[r-1],s,l=0;++t<r;)o=a,a=e[t],l+=s=o[0]*a[1]-a[0]*o[1],n+=(o[0]+a[0])*s,i+=(o[1]+a[1])*s;return l*=3,[n/l,i/l]}var Z8t=M(()=>{});function J8t(e,t,r){return(t[0]-e[0])*(r[1]-e[1])-(t[1]-e[1])*(r[0]-e[0])}var Q8t=M(()=>{});function d6e(e,t){return e[0]-t[0]||e[1]-t[1]}function tRt(e){for(var t=e.length,r=[0,1],n=2,i=2;i<t;++i){for(;n>1&&J8t(e[r[n-2]],e[r[n-1]],e[i])<=0;)--n;r[n++]=i}return r.slice(0,n)}function eRt(e){if((r=e.length)<3)return null;var t,r,n=new Array(r),i=new Array(r);for(t=0;t<r;++t)n[t]=[+e[t][0],+e[t][1],t];for(n.sort(d6e),t=0;t<r;++t)i[t]=[n[t][0],-n[t][1]];var o=tRt(n),a=tRt(i),s=a[0]===o[0],l=a[a.length-1]===o[o.length-1],c=[];for(t=o.length-1;t>=0;--t)c.push(e[n[o[t]][2]]);for(t=+s;t<a.length-l;++t)c.push(e[n[a[t]][2]]);return c}var rRt=M(()=>{Q8t()});function nRt(e,t){for(var r=e.length,n=e[r-1],i=t[0],o=t[1],a=n[0],s=n[1],l,c,u=!1,h=0;h<r;++h)n=e[h],l=n[0],c=n[1],c>o!=s>o&&i<(a-l)*(o-c)/(s-c)+l&&(u=!u),a=l,s=c;return u}var iRt=M(()=>{});function oRt(e){for(var t=-1,r=e.length,n=e[r-1],i,o,a=n[0],s=n[1],l=0;++t<r;)i=a,o=s,n=e[t],a=n[0],s=n[1],i-=a,o-=s,l+=Math.sqrt(i*i+o*o);return l}var aRt=M(()=>{});var sRt=M(()=>{$8t();Z8t();rRt();iRt();aRt()});function lRt(e){var t=+this._x.call(null,e),r=+this._y.call(null,e);return cRt(this.cover(t,r),t,r,e)}function cRt(e,t,r,n){if(isNaN(t)||isNaN(r))return e;var i,o=e._root,a={data:n},s=e._x0,l=e._y0,c=e._x1,u=e._y1,h,f,p,d,g,_,y,x;if(!o)return e._root=a,e;for(;o.length;)if((g=t>=(h=(s+c)/2))?s=h:c=h,(_=r>=(f=(l+u)/2))?l=f:u=f,i=o,!(o=o[y=_<<1|g]))return i[y]=a,e;if(p=+e._x.call(null,o.data),d=+e._y.call(null,o.data),t===p&&r===d)return a.next=o,i?i[y]=a:e._root=a,e;do i=i?i[y]=new Array(4):e._root=new Array(4),(g=t>=(h=(s+c)/2))?s=h:c=h,(_=r>=(f=(l+u)/2))?l=f:u=f;while((y=_<<1|g)===(x=(d>=f)<<1|p>=h));return i[x]=o,i[y]=a,e}function uRt(e){var t,r,n=e.length,i,o,a=new Array(n),s=new Array(n),l=1/0,c=1/0,u=-1/0,h=-1/0;for(r=0;r<n;++r)isNaN(i=+this._x.call(null,t=e[r]))||isNaN(o=+this._y.call(null,t))||(a[r]=i,s[r]=o,i<l&&(l=i),i>u&&(u=i),o<c&&(c=o),o>h&&(h=o));for(u<l&&(l=this._x0,u=this._x1),h<c&&(c=this._y0,h=this._y1),this.cover(l,c).cover(u,h),r=0;r<n;++r)cRt(this,a[r],s[r],e[r]);return this}var hRt=M(()=>{});function fRt(e,t){if(isNaN(e=+e)||isNaN(t=+t))return this;var r=this._x0,n=this._y0,i=this._x1,o=this._y1;if(isNaN(r))i=(r=Math.floor(e))+1,o=(n=Math.floor(t))+1;else if(r>e||e>i||n>t||t>o){var a=i-r,s=this._root,l,c;switch(c=(t<(n+o)/2)<<1|e<(r+i)/2){case 0:{do l=new Array(4),l[c]=s,s=l;while(a*=2,i=r+a,o=n+a,e>i||t>o);break}case 1:{do l=new Array(4),l[c]=s,s=l;while(a*=2,r=i-a,o=n+a,r>e||t>o);break}case 2:{do l=new Array(4),l[c]=s,s=l;while(a*=2,i=r+a,n=o-a,e>i||n>t);break}case 3:{do l=new Array(4),l[c]=s,s=l;while(a*=2,r=i-a,n=o-a,r>e||n>t);break}}this._root&&this._root.length&&(this._root=s)}else return this;return this._x0=r,this._y0=n,this._x1=i,this._y1=o,this}var pRt=M(()=>{});function dRt(){var e=[];return this.visit(function(t){if(!t.length)do e.push(t.data);while(t=t.next)}),e}var mRt=M(()=>{});function gRt(e){return arguments.length?this.cover(+e[0][0],+e[0][1]).cover(+e[1][0],+e[1][1]):isNaN(this._x0)?void 0:[[this._x0,this._y0],[this._x1,this._y1]]}var _Rt=M(()=>{});function Eo(e,t,r,n,i){this.node=e,this.x0=t,this.y0=r,this.x1=n,this.y1=i}var yO=M(()=>{});function yRt(e,t,r){var n,i=this._x0,o=this._y0,a,s,l,c,u=this._x1,h=this._y1,f=[],p=this._root,d,g;for(p&&f.push(new Eo(p,i,o,u,h)),r==null?r=1/0:(i=e-r,o=t-r,u=e+r,h=t+r,r*=r);d=f.pop();)if(!(!(p=d.node)||(a=d.x0)>u||(s=d.y0)>h||(l=d.x1)<i||(c=d.y1)<o))if(p.length){var _=(a+l)/2,y=(s+c)/2;f.push(new Eo(p[3],_,y,l,c),new Eo(p[2],a,y,_,c),new Eo(p[1],_,s,l,y),new Eo(p[0],a,s,_,y)),(g=(t>=y)<<1|e>=_)&&(d=f[f.length-1],f[f.length-1]=f[f.length-1-g],f[f.length-1-g]=d)}else{var x=e-+this._x.call(null,p.data),b=t-+this._y.call(null,p.data),S=x*x+b*b;if(S<r){var C=Math.sqrt(r=S);i=e-C,o=t-C,u=e+C,h=t+C,n=p.data}}return n}var vRt=M(()=>{yO()});function xRt(e){if(isNaN(u=+this._x.call(null,e))||isNaN(h=+this._y.call(null,e)))return this;var t,r=this._root,n,i,o,a=this._x0,s=this._y0,l=this._x1,c=this._y1,u,h,f,p,d,g,_,y;if(!r)return this;if(r.length)for(;;){if((d=u>=(f=(a+l)/2))?a=f:l=f,(g=h>=(p=(s+c)/2))?s=p:c=p,t=r,!(r=r[_=g<<1|d]))return this;if(!r.length)break;(t[_+1&3]||t[_+2&3]||t[_+3&3])&&(n=t,y=_)}for(;r.data!==e;)if(i=r,!(r=r.next))return this;return(o=r.next)&&delete r.next,i?(o?i.next=o:delete i.next,this):t?(o?t[_]=o:delete t[_],(r=t[0]||t[1]||t[2]||t[3])&&r===(t[3]||t[2]||t[1]||t[0])&&!r.length&&(n?n[y]=r:this._root=r),this):(this._root=o,this)}function bRt(e){for(var t=0,r=e.length;t<r;++t)this.remove(e[t]);return this}var wRt=M(()=>{});function SRt(){return this._root}var MRt=M(()=>{});function ERt(){var e=0;return this.visit(function(t){if(!t.length)do++e;while(t=t.next)}),e}var TRt=M(()=>{});function CRt(e){var t=[],r,n=this._root,i,o,a,s,l;for(n&&t.push(new Eo(n,this._x0,this._y0,this._x1,this._y1));r=t.pop();)if(!e(n=r.node,o=r.x0,a=r.y0,s=r.x1,l=r.y1)&&n.length){var c=(o+s)/2,u=(a+l)/2;(i=n[3])&&t.push(new Eo(i,c,u,s,l)),(i=n[2])&&t.push(new Eo(i,o,u,c,l)),(i=n[1])&&t.push(new Eo(i,c,a,s,u)),(i=n[0])&&t.push(new Eo(i,o,a,c,u))}return this}var ARt=M(()=>{yO()});function PRt(e){var t=[],r=[],n;for(this._root&&t.push(new Eo(this._root,this._x0,this._y0,this._x1,this._y1));n=t.pop();){var i=n.node;if(i.length){var o,a=n.x0,s=n.y0,l=n.x1,c=n.y1,u=(a+l)/2,h=(s+c)/2;(o=i[0])&&t.push(new Eo(o,a,s,u,h)),(o=i[1])&&t.push(new Eo(o,u,s,l,h)),(o=i[2])&&t.push(new Eo(o,a,h,u,c)),(o=i[3])&&t.push(new Eo(o,u,h,l,c))}r.push(n)}for(;n=r.pop();)e(n.node,n.x0,n.y0,n.x1,n.y1);return this}var IRt=M(()=>{yO()});function LRt(e){return e[0]}function kRt(e){return arguments.length?(this._x=e,this):this._x}var RRt=M(()=>{});function NRt(e){return e[1]}function DRt(e){return arguments.length?(this._y=e,this):this._y}var ORt=M(()=>{});function vO(e,t,r){var n=new ttt(t==null?LRt:t,r==null?NRt:r,NaN,NaN,NaN,NaN);return e==null?n:n.addAll(e)}function ttt(e,t,r,n,i,o){this._x=e,this._y=t,this._x0=r,this._y0=n,this._x1=i,this._y1=o,this._root=void 0}function zRt(e){for(var t={data:e.data},r=t;e=e.next;)r=r.next={data:e.data};return t}var Xa,FRt=M(()=>{hRt();pRt();mRt();_Rt();vRt();wRt();MRt();TRt();ARt();IRt();RRt();ORt();Xa=vO.prototype=ttt.prototype;Xa.copy=function(){var e=new ttt(this._x,this._y,this._x0,this._y0,this._x1,this._y1),t=this._root,r,n;if(!t)return e;if(!t.length)return e._root=zRt(t),e;for(r=[{source:t,target:e._root=new Array(4)}];t=r.pop();)for(var i=0;i<4;++i)(n=t.source[i])&&(n.length?r.push({source:n,target:t.target[i]=new Array(4)}):t.target[i]=zRt(n));return e};Xa.add=lRt;Xa.addAll=uRt;Xa.cover=fRt;Xa.data=dRt;Xa.extent=gRt;Xa.find=yRt;Xa.remove=xRt;Xa.removeAll=bRt;Xa.root=SRt;Xa.size=ERt;Xa.visit=CRt;Xa.visitAfter=PRt;Xa.x=kRt;Xa.y=DRt});var BRt=M(()=>{FRt()});var HRt,VRt=M(()=>{HRt=[].slice});function ett(e){this._size=e,this._call=this._error=null,this._tasks=[],this._data=[],this._waiting=this._active=this._ended=this._start=0}function URt(e){if(!e._start)try{g6e(e)}catch(t){if(e._tasks[e._ended+e._active-1])rtt(e,t);else if(!e._data)throw t}}function g6e(e){for(;e._start=e._waiting&&e._active<e._size;){var t=e._ended+e._active,r=e._tasks[t],n=r.length-1,i=r[n];r[n]=_6e(e,t),--e._waiting,++e._active,r=i.apply(null,r),e._tasks[t]&&(e._tasks[t]=r||m6e)}}function _6e(e,t){return function(r,n){!e._tasks[t]||(--e._active,++e._ended,e._tasks[t]=null,e._error==null&&(r!=null?rtt(e,r):(e._data[t]=n,e._waiting?URt(e):xO(e))))}}function rtt(e,t){var r=e._tasks.length,n;for(e._error=t,e._data=void 0,e._waiting=NaN;--r>=0;)if((n=e._tasks[r])&&(e._tasks[r]=null,n.abort))try{n.abort()}catch(i){}e._active=NaN,xO(e)}function xO(e){if(!e._active&&e._call){var t=e._data;e._data=void 0,e._call(e._error,t)}}function bO(e){if(e==null)e=1/0;else if(!((e=+e)>=1))throw new Error("invalid concurrency");return new ett(e)}var m6e,qRt=M(()=>{VRt();m6e={};ett.prototype=bO.prototype={constructor:ett,defer:function(e){if(typeof e!="function")throw new Error("invalid callback");if(this._call)throw new Error("defer after await");if(this._error!=null)return this;var t=HRt.call(arguments,1);return t.push(e),++this._waiting,this._tasks.push(t),URt(this),this},abort:function(){return this._error==null&&rtt(this,new Error("abort")),this},await:function(e){if(typeof e!="function")throw new Error("invalid callback");if(this._call)throw new Error("multiple await");return this._call=function(t,r){e.apply(null,[t].concat(r))},xO(this),this},awaitAll:function(e){if(typeof e!="function")throw new Error("invalid callback");if(this._call)throw new Error("multiple await");return this._call=e,xO(this),this}}});var GRt=M(()=>{qRt()});function bc(){return Math.random()}var $y=M(()=>{});var WRt,YRt=M(()=>{$y();WRt=function e(t){function r(n,i){return n=n==null?0:+n,i=i==null?1:+i,arguments.length===1?(i=n,n=0):i-=n,function(){return t()*i+n}}return r.source=e,r}(bc)});var wO,ntt=M(()=>{$y();wO=function e(t){function r(n,i){var o,a;return n=n==null?0:+n,i=i==null?1:+i,function(){var s;if(o!=null)s=o,o=null;else do o=t()*2-1,s=t()*2-1,a=o*o+s*s;while(!a||a>1);return n+i*s*Math.sqrt(-2*Math.log(a)/a)}}return r.source=e,r}(bc)});var jRt,XRt=M(()=>{$y();ntt();jRt=function e(t){function r(){var n=wO.source(t).apply(this,arguments);return function(){return Math.exp(n())}}return r.source=e,r}(bc)});var SO,itt=M(()=>{$y();SO=function e(t){function r(n){return function(){for(var i=0,o=0;o<n;++o)i+=t();return i}}return r.source=e,r}(bc)});var $Rt,KRt=M(()=>{$y();itt();$Rt=function e(t){function r(n){var i=SO.source(t)(n);return function(){return i()/n}}return r.source=e,r}(bc)});var ZRt,JRt=M(()=>{$y();ZRt=function e(t){function r(n){return function(){return-Math.log(1-t())/n}}return r.source=e,r}(bc)});var QRt=M(()=>{YRt();ntt();XRt();KRt();itt();JRt()});function J2(e,t){var r,n=vs("beforesend","progress","load","error"),i,o=Ji(),a=new XMLHttpRequest,s=null,l=null,c,u,h=0;typeof XDomainRequest!="undefined"&&!("withCredentials"in a)&&/^(http(s)?:)?\/\//.test(e)&&(a=new XDomainRequest),"onload"in a?a.onload=a.onerror=a.ontimeout=f:a.onreadystatechange=function(p){a.readyState>3&&f(p)};function f(p){var d=a.status,g;if(!d&&v6e(a)||d>=200&&d<300||d===304){if(c)try{g=c.call(r,a)}catch(_){n.call("error",r,_);return}else g=a;n.call("load",r,g)}else n.call("error",r,p)}if(a.onprogress=function(p){n.call("progress",r,p)},r={header:function(p,d){return p=(p+"").toLowerCase(),arguments.length<2?o.get(p):(d==null?o.remove(p):o.set(p,d+""),r)},mimeType:function(p){return arguments.length?(i=p==null?null:p+"",r):i},responseType:function(p){return arguments.length?(u=p,r):u},timeout:function(p){return arguments.length?(h=+p,r):h},user:function(p){return arguments.length<1?s:(s=p==null?null:p+"",r)},password:function(p){return arguments.length<1?l:(l=p==null?null:p+"",r)},response:function(p){return c=p,r},get:function(p,d){return r.send("GET",p,d)},post:function(p,d){return r.send("POST",p,d)},send:function(p,d,g){return a.open(p,e,!0,s,l),i!=null&&!o.has("accept")&&o.set("accept",i+",*/*"),a.setRequestHeader&&o.each(function(_,y){a.setRequestHeader(y,_)}),i!=null&&a.overrideMimeType&&a.overrideMimeType(i),u!=null&&(a.responseType=u),h>0&&(a.timeout=h),g==null&&typeof d=="function"&&(g=d,d=null),g!=null&&g.length===1&&(g=y6e(g)),g!=null&&r.on("error",g).on("load",function(_){g(null,_)}),n.call("beforesend",r,a),a.send(d==null?null:d),r},abort:function(){return a.abort(),r},on:function(){var p=n.on.apply(n,arguments);return p===n?r:p}},t!=null){if(typeof t!="function")throw new Error("invalid callback: "+t);return r.get(t)}return r}function y6e(e){return function(t,r){e(t==null?r:null)}}function v6e(e){var t=e.responseType;return t&&t!=="text"?e.response:e.responseText}var MO=M(()=>{Tb();km()});function Tg(e,t){return function(r,n){var i=J2(r).mimeType(e).response(t);if(n!=null){if(typeof n!="function")throw new Error("invalid callback: "+n);return i.get(n)}return i}}var iC=M(()=>{MO()});var tNt,eNt=M(()=>{iC();tNt=Tg("text/html",function(e){return document.createRange().createContextualFragment(e.responseText)})});var rNt,nNt=M(()=>{iC();rNt=Tg("application/json",function(e){return JSON.parse(e.responseText)})});var iNt,oNt=M(()=>{iC();iNt=Tg("text/plain",function(e){return e.responseText})});var aNt,sNt=M(()=>{iC();aNt=Tg("application/xml",function(e){var t=e.responseXML;if(!t)throw new Error("parse error");return t})});function EO(e,t){return function(r,n,i){arguments.length<3&&(i=n,n=null);var o=J2(r).mimeType(e);return o.row=function(a){return arguments.length?o.response(x6e(t,n=a)):n},o.row(n),i?o.get(i):o}}function x6e(e,t){return function(r){return e(r.responseText,t)}}var ott=M(()=>{MO()});var lNt,cNt=M(()=>{UE();ott();lNt=EO("text/csv",Cb)});var uNt,hNt=M(()=>{UE();ott();uNt=EO("text/tab-separated-values",Ab)});var fNt=M(()=>{MO();eNt();nNt();oNt();sNt();cNt();hNt()});function pf(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var Ky=M(()=>{});function oC(e){return e.length===1&&(e=b6e(e)),{left:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)<0?n=o+1:i=o}return n},right:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)>0?i=o:n=o+1}return n}}}function b6e(e){return function(t,r){return pf(e(t),r)}}var att=M(()=>{Ky()});var pNt,dNt,w6e,df,stt=M(()=>{Ky();att();pNt=oC(pf),dNt=pNt.right,w6e=pNt.left,df=dNt});var ltt=M(()=>{});var mNt=M(()=>{ltt()});var gNt=M(()=>{});function Q2(e){return e===null?NaN:+e}var tw=M(()=>{});var ctt=M(()=>{tw()});var utt=M(()=>{ctt()});var htt=M(()=>{});var _Nt,M6e,E6e,ftt=M(()=>{_Nt=Array.prototype,M6e=_Nt.slice,E6e=_Nt.map});var yNt=M(()=>{});var vNt=M(()=>{});function TO(e,t,r){e=+e,t=+t,r=(i=arguments.length)<2?(t=e,e=0,1):i<3?1:+r;for(var n=-1,i=Math.max(0,Math.ceil((t-e)/r))|0,o=new Array(i);++n<i;)o[n]=e+n*r;return o}var ptt=M(()=>{});function aC(e,t,r){var n,i=-1,o,a,s;if(t=+t,e=+e,r=+r,e===t&&r>0)return[e];if((n=t<e)&&(o=e,e=t,t=o),(s=ew(e,t,r))===0||!isFinite(s))return[];if(s>0)for(e=Math.ceil(e/s),t=Math.floor(t/s),a=new Array(o=Math.ceil(t-e+1));++i<o;)a[i]=(e+i)*s;else for(e=Math.floor(e*s),t=Math.ceil(t*s),a=new Array(o=Math.ceil(e-t+1));++i<o;)a[i]=(e-i)/s;return n&&a.reverse(),a}function ew(e,t,r){var n=(t-e)/Math.max(0,r),i=Math.floor(Math.log(n)/Math.LN10),o=n/Math.pow(10,i);return i>=0?(o>=dtt?10:o>=mtt?5:o>=gtt?2:1)*Math.pow(10,i):-Math.pow(10,-i)/(o>=dtt?10:o>=mtt?5:o>=gtt?2:1)}function Zy(e,t,r){var n=Math.abs(t-e)/Math.max(0,r),i=Math.pow(10,Math.floor(Math.log(n)/Math.LN10)),o=n/i;return o>=dtt?i*=10:o>=mtt?i*=5:o>=gtt&&(i*=2),t<e?-i:i}var dtt,mtt,gtt,_tt=M(()=>{dtt=Math.sqrt(50),mtt=Math.sqrt(10),gtt=Math.sqrt(2)});var ytt=M(()=>{});var xNt=M(()=>{ftt();stt();yNt();htt();vNt();ptt();_tt();ytt()});function sC(e,t,r){if(r==null&&(r=Q2),!!(n=e.length)){if((t=+t)<=0||n<2)return+r(e[0],0,e);if(t>=1)return+r(e[n-1],n-1,e);var n,i=(n-1)*t,o=Math.floor(i),a=+r(e[o],o,e),s=+r(e[o+1],o+1,e);return a+(s-a)*(i-o)}}var CO=M(()=>{tw()});var bNt=M(()=>{ftt();Ky();tw();CO()});var wNt=M(()=>{utt()});var SNt=M(()=>{});var MNt=M(()=>{tw()});var ENt=M(()=>{Ky();tw();CO()});var TNt=M(()=>{});var vtt=M(()=>{});var CNt=M(()=>{});var ANt=M(()=>{Ky()});var PNt=M(()=>{});var INt=M(()=>{});var xtt=M(()=>{vtt()});var LNt=M(()=>{xtt()});var mf=M(()=>{stt();Ky();att();mNt();gNt();utt();htt();xNt();bNt();wNt();ytt();SNt();MNt();ENt();TNt();vtt();ltt();CNt();CO();ptt();ANt();PNt();INt();_tt();xtt();ctt();LNt()});function AO(){}function kNt(e,t){var r=new AO;if(e instanceof AO)e.each(function(s,l){r.set(l,s)});else if(Array.isArray(e)){var n=-1,i=e.length,o;if(t==null)for(;++n<i;)r.set(n,e[n]);else for(;++n<i;)r.set(t(o=e[n],n,e),o)}else if(e)for(var a in e)r.set(a,e[a]);return r}var fl,Jy,PO=M(()=>{fl="$";AO.prototype=kNt.prototype={constructor:AO,has:function(e){return fl+e in this},get:function(e){return this[fl+e]},set:function(e,t){return this[fl+e]=t,this},remove:function(e){var t=fl+e;return t in this&&delete this[t]},clear:function(){for(var e in this)e[0]===fl&&delete this[e]},keys:function(){var e=[];for(var t in this)t[0]===fl&&e.push(t.slice(1));return e},values:function(){var e=[];for(var t in this)t[0]===fl&&e.push(this[t]);return e},entries:function(){var e=[];for(var t in this)t[0]===fl&&e.push({key:t.slice(1),value:this[t]});return e},size:function(){var e=0;for(var t in this)t[0]===fl&&++e;return e},empty:function(){for(var e in this)if(e[0]===fl)return!1;return!0},each:function(e){for(var t in this)t[0]===fl&&e(this[t],t.slice(1),this)}};Jy=kNt});var RNt=M(()=>{PO()});function IO(){}function L6e(e,t){var r=new IO;if(e instanceof IO)e.each(function(o){r.add(o)});else if(e){var n=-1,i=e.length;if(t==null)for(;++n<i;)r.add(e[n]);else for(;++n<i;)r.add(t(e[n],n,e))}return r}var Qy,NNt=M(()=>{PO();Qy=Jy.prototype;IO.prototype=L6e.prototype={constructor:IO,has:Qy.has,add:function(e){return e+="",this[fl+e]=e,this},remove:Qy.remove,clear:Qy.clear,values:Qy.keys,size:Qy.size,empty:Qy.empty,each:Qy.each}});var DNt=M(()=>{});var ONt=M(()=>{});var zNt=M(()=>{});var FNt=M(()=>{RNt();NNt();PO();DNt();ONt();zNt()});var BNt,rw,pl,Cg=M(()=>{BNt=Array.prototype,rw=BNt.map,pl=BNt.slice});function nw(e){var t=Jy(),r=[],n=LO;e=e==null?[]:pl.call(e);function i(o){var a=o+"",s=t.get(a);if(!s){if(n!==LO)return n;t.set(a,s=r.push(o))}return e[(s-1)%e.length]}return i.domain=function(o){if(!arguments.length)return r.slice();r=[],t=Jy();for(var a=-1,s=o.length,l,c;++a<s;)t.has(c=(l=o[a])+"")||t.set(c,r.push(l));return i},i.range=function(o){return arguments.length?(e=pl.call(o),i):e.slice()},i.unknown=function(o){return arguments.length?(n=o,i):n},i.copy=function(){return nw().domain(r).range(e).unknown(n)},i}var LO,btt=M(()=>{FNt();Cg();LO={name:"implicit"}});function lC(){var e=nw().unknown(void 0),t=e.domain,r=e.range,n=[0,1],i,o,a=!1,s=0,l=0,c=.5;delete e.unknown;function u(){var h=t().length,f=n[1]<n[0],p=n[f-0],d=n[1-f];i=(d-p)/Math.max(1,h-s+l*2),a&&(i=Math.floor(i)),p+=(d-p-i*(h-s))*c,o=i*(1-s),a&&(p=Math.round(p),o=Math.round(o));var g=TO(h).map(function(_){return p+i*_});return r(f?g.reverse():g)}return e.domain=function(h){return arguments.length?(t(h),u()):t()},e.range=function(h){return arguments.length?(n=[+h[0],+h[1]],u()):n.slice()},e.rangeRound=function(h){return n=[+h[0],+h[1]],a=!0,u()},e.bandwidth=function(){return o},e.step=function(){return i},e.round=function(h){return arguments.length?(a=!!h,u()):a},e.padding=function(h){return arguments.length?(s=l=Math.max(0,Math.min(1,h)),u()):s},e.paddingInner=function(h){return arguments.length?(s=Math.max(0,Math.min(1,h)),u()):s},e.paddingOuter=function(h){return arguments.length?(l=Math.max(0,Math.min(1,h)),u()):l},e.align=function(h){return arguments.length?(c=Math.max(0,Math.min(1,h)),u()):c},e.copy=function(){return lC().domain(t()).range(n).round(a).paddingInner(s).paddingOuter(l).align(c)},u()}function HNt(e){var t=e.copy;return e.padding=e.paddingOuter,delete e.paddingInner,delete e.paddingOuter,e.copy=function(){return HNt(t())},e}function VNt(){return HNt(lC().paddingInner(1))}var UNt=M(()=>{mf();btt()});function iw(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function cC(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}var wtt=M(()=>{});function e1(){}function GNt(){return this.rgb().formatHex()}function B6e(){return KNt(this).formatHsl()}function WNt(){return this.rgb().formatRgb()}function Pg(e){var t,r;return e=(e+"").trim().toLowerCase(),(t=k6e.exec(e))?(r=t[1].length,t=parseInt(t[1],16),r===6?YNt(t):r===3?new ha(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?kO(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?kO(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=R6e.exec(e))?new ha(t[1],t[2],t[3],1):(t=N6e.exec(e))?new ha(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=D6e.exec(e))?kO(t[1],t[2],t[3],t[4]):(t=O6e.exec(e))?kO(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=z6e.exec(e))?$Nt(t[1],t[2]/100,t[3]/100,1):(t=F6e.exec(e))?$Nt(t[1],t[2]/100,t[3]/100,t[4]):qNt.hasOwnProperty(e)?YNt(qNt[e]):e==="transparent"?new ha(NaN,NaN,NaN,0):null}function YNt(e){return new ha(e>>16&255,e>>8&255,e&255,1)}function kO(e,t,r,n){return n<=0&&(e=t=r=NaN),new ha(e,t,r,n)}function Ett(e){return e instanceof e1||(e=Pg(e)),e?(e=e.rgb(),new ha(e.r,e.g,e.b,e.opacity)):new ha}function aw(e,t,r,n){return arguments.length===1?Ett(e):new ha(e,t,r,n==null?1:n)}function ha(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}function jNt(){return"#"+Stt(this.r)+Stt(this.g)+Stt(this.b)}function XNt(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}function Stt(e){return e=Math.max(0,Math.min(255,Math.round(e)||0)),(e<16?"0":"")+e.toString(16)}function $Nt(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new gf(e,t,r,n)}function KNt(e){if(e instanceof gf)return new gf(e.h,e.s,e.l,e.opacity);if(e instanceof e1||(e=Pg(e)),!e)return new gf;if(e instanceof gf)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new gf(a,s,l,e.opacity)}function ZNt(e,t,r,n){return arguments.length===1?KNt(e):new gf(e,t,r,n==null?1:n)}function gf(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}function Mtt(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var Ag,t1,ow,uC,_f,k6e,R6e,N6e,D6e,O6e,z6e,F6e,qNt,Ttt=M(()=>{wtt();Ag=.7,t1=1/Ag,ow="\\s*([+-]?\\d+)\\s*",uC="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",_f="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",k6e=/^#([0-9a-f]{3,8})$/,R6e=new RegExp("^rgb\\("+[ow,ow,ow]+"\\)$"),N6e=new RegExp("^rgb\\("+[_f,_f,_f]+"\\)$"),D6e=new RegExp("^rgba\\("+[ow,ow,ow,uC]+"\\)$"),O6e=new RegExp("^rgba\\("+[_f,_f,_f,uC]+"\\)$"),z6e=new RegExp("^hsl\\("+[uC,_f,_f]+"\\)$"),F6e=new RegExp("^hsla\\("+[uC,_f,_f,uC]+"\\)$"),qNt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};iw(e1,Pg,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:GNt,formatHex:GNt,formatHsl:B6e,formatRgb:WNt,toString:WNt});iw(ha,aw,cC(e1,{brighter:function(e){return e=e==null?t1:Math.pow(t1,e),new ha(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?Ag:Math.pow(Ag,e),new ha(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:jNt,formatHex:jNt,formatRgb:XNt,toString:XNt}));iw(gf,ZNt,cC(e1,{brighter:function(e){return e=e==null?t1:Math.pow(t1,e),new gf(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Ag:Math.pow(Ag,e),new gf(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new ha(Mtt(e>=240?e-240:e+120,i,n),Mtt(e,i,n),Mtt(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(e===1?")":", "+e+")")}}))});var JNt,QNt,tDt=M(()=>{JNt=Math.PI/180,QNt=180/Math.PI});function H6e(e){if(e instanceof r1)return new r1(e.h,e.s,e.l,e.opacity);e instanceof ha||(e=Ett(e));var t=e.r/255,r=e.g/255,n=e.b/255,i=(nDt*n+eDt*t-rDt*r)/(nDt+eDt-rDt),o=n-i,a=(hC*(r-i)-Att*o)/RO,s=Math.sqrt(a*a+o*o)/(hC*i*(1-i)),l=s?Math.atan2(a,o)*QNt-120:NaN;return new r1(l<0?l+360:l,s,i,e.opacity)}function $a(e,t,r,n){return arguments.length===1?H6e(e):new r1(e,t,r,n==null?1:n)}function r1(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}var iDt,Ctt,Att,RO,hC,eDt,rDt,nDt,oDt=M(()=>{wtt();Ttt();tDt();iDt=-.14861,Ctt=1.78277,Att=-.29227,RO=-.90649,hC=1.97294,eDt=hC*RO,rDt=hC*Ctt,nDt=Ctt*Att-RO*iDt;iw(r1,$a,cC(e1,{brighter:function(e){return e=e==null?t1:Math.pow(t1,e),new r1(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Ag:Math.pow(Ag,e),new r1(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=isNaN(this.h)?0:(this.h+120)*JNt,t=+this.l,r=isNaN(this.s)?0:this.s*t*(1-t),n=Math.cos(e),i=Math.sin(e);return new ha(255*(t+r*(iDt*n+Ctt*i)),255*(t+r*(Att*n+RO*i)),255*(t+r*(hC*n)),this.opacity)}}))});var sw=M(()=>{Ttt();oDt()});function Ptt(e,t,r,n,i){var o=e*e,a=o*e;return((1-3*e+3*o-a)*t+(4-6*o+3*a)*r+(1+3*e+3*o-3*a)*n+a*i)/6}function aDt(e){var t=e.length-1;return function(r){var n=r<=0?r=0:r>=1?(r=1,t-1):Math.floor(r*t),i=e[n],o=e[n+1],a=n>0?e[n-1]:2*i-o,s=n<t-1?e[n+2]:2*o-i;return Ptt((r-n/t)*t,a,i,o,s)}}var Itt=M(()=>{});function sDt(e){var t=e.length;return function(r){var n=Math.floor(((r%=1)<0?++r:r)*t),i=e[(n+t-1)%t],o=e[n%t],a=e[(n+1)%t],s=e[(n+2)%t];return Ptt((r-n/t)*t,i,o,a,s)}}var lDt=M(()=>{Itt()});function lw(e){return function(){return e}}var Ltt=M(()=>{});function cDt(e,t){return function(r){return e+r*t}}function V6e(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function uDt(e,t){var r=t-e;return r?cDt(e,r>180||r<-180?r-360*Math.round(r/360):r):lw(isNaN(e)?t:e)}function hDt(e){return(e=+e)==1?nd:function(t,r){return r-t?V6e(t,r,e):lw(isNaN(t)?r:t)}}function nd(e,t){var r=t-e;return r?cDt(e,r):lw(isNaN(e)?t:e)}var ktt=M(()=>{Ltt()});function fDt(e){return function(t){var r=t.length,n=new Array(r),i=new Array(r),o=new Array(r),a,s;for(a=0;a<r;++a)s=aw(t[a]),n[a]=s.r||0,i[a]=s.g||0,o[a]=s.b||0;return n=e(n),i=e(i),o=e(o),s.opacity=1,function(l){return s.r=n(l),s.g=i(l),s.b=o(l),s+""}}}var Rtt,a5n,s5n,pDt=M(()=>{sw();Itt();lDt();ktt();Rtt=function e(t){var r=hDt(t);function n(i,o){var a=r((i=aw(i)).r,(o=aw(o)).r),s=r(i.g,o.g),l=r(i.b,o.b),c=nd(i.opacity,o.opacity);return function(u){return i.r=a(u),i.g=s(u),i.b=l(u),i.opacity=c(u),i+""}}return n.gamma=e,n}(1);a5n=fDt(aDt),s5n=fDt(sDt)});function dDt(e,t){t||(t=[]);var r=e?Math.min(t.length,e.length):0,n=t.slice(),i;return function(o){for(i=0;i<r;++i)n[i]=e[i]*(1-o)+t[i]*o;return n}}function mDt(e){return ArrayBuffer.isView(e)&&!(e instanceof DataView)}var gDt=M(()=>{});function _Dt(e,t){var r=t?t.length:0,n=e?Math.min(r,e.length):0,i=new Array(n),o=new Array(r),a;for(a=0;a<n;++a)i[a]=n1(e[a],t[a]);for(;a<r;++a)o[a]=t[a];return function(s){for(a=0;a<n;++a)o[a]=i[a](s);return o}}var yDt=M(()=>{NO()});function vDt(e,t){var r=new Date;return e=+e,t=+t,function(n){return r.setTime(e*(1-n)+t*n),r}}var xDt=M(()=>{});function yf(e,t){return e=+e,t=+t,function(r){return e*(1-r)+t*r}}var DO=M(()=>{});function bDt(e,t){var r={},n={},i;(e===null||typeof e!="object")&&(e={}),(t===null||typeof t!="object")&&(t={});for(i in t)i in e?r[i]=n1(e[i],t[i]):n[i]=t[i];return function(o){for(i in r)n[i]=r[i](o);return n}}var wDt=M(()=>{NO()});function U6e(e){return function(){return e}}function q6e(e){return function(t){return e(t)+""}}function SDt(e,t){var r=Dtt.lastIndex=Ntt.lastIndex=0,n,i,o,a=-1,s=[],l=[];for(e=e+"",t=t+"";(n=Dtt.exec(e))&&(i=Ntt.exec(t));)(o=i.index)>r&&(o=t.slice(r,o),s[a]?s[a]+=o:s[++a]=o),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:yf(n,i)})),r=Ntt.lastIndex;return r<t.length&&(o=t.slice(r),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?q6e(l[0].x):U6e(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)s[(h=l[u]).i]=h.x(c);return s.join("")})}var Dtt,Ntt,MDt=M(()=>{DO();Dtt=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,Ntt=new RegExp(Dtt.source,"g")});function n1(e,t){var r=typeof t,n;return t==null||r==="boolean"?lw(t):(r==="number"?yf:r==="string"?(n=Pg(t))?(t=n,Rtt):SDt:t instanceof Pg?Rtt:t instanceof Date?vDt:mDt(t)?dDt:Array.isArray(t)?_Dt:typeof t.valueOf!="function"&&typeof t.toString!="function"||isNaN(t)?bDt:yf)(e,t)}var NO=M(()=>{sw();pDt();yDt();xDt();DO();wDt();MDt();Ltt();gDt()});function Ott(e,t){return e=+e,t=+t,function(r){return Math.round(e*(1-r)+t*r)}}var EDt=M(()=>{});function TDt(e){return function t(r){r=+r;function n(i,o){var a=e((i=$a(i)).h,(o=$a(o)).h),s=nd(i.s,o.s),l=nd(i.l,o.l),c=nd(i.opacity,o.opacity);return function(u){return i.h=a(u),i.s=s(u),i.l=l(Math.pow(u,r)),i.opacity=c(u),i+""}}return n.gamma=t,n}(1)}var G6e,cw,CDt=M(()=>{sw();ktt();G6e=TDt(uDt),cw=TDt(nd)});var uw=M(()=>{NO();DO();EDt();CDt()});function hw(e){return function(){return e}}var OO=M(()=>{});function zO(e){return+e}var ztt=M(()=>{});function fC(e,t){return(t-=e=+e)?function(r){return(r-e)/t}:hw(t)}function W6e(e){return function(t,r){var n=e(t=+t,r=+r);return function(i){return i<=t?0:i>=r?1:n(i)}}}function Y6e(e){return function(t,r){var n=e(t=+t,r=+r);return function(i){return i<=0?t:i>=1?r:n(i)}}}function j6e(e,t,r,n){var i=e[0],o=e[1],a=t[0],s=t[1];return o<i?(i=r(o,i),a=n(s,a)):(i=r(i,o),a=n(a,s)),function(l){return a(i(l))}}function X6e(e,t,r,n){var i=Math.min(e.length,t.length)-1,o=new Array(i),a=new Array(i),s=-1;for(e[i]<e[0]&&(e=e.slice().reverse(),t=t.slice().reverse());++s<i;)o[s]=r(e[s],e[s+1]),a[s]=n(t[s],t[s+1]);return function(l){var c=df(e,l,1,i)-1;return a[c](o[c](l))}}function Ig(e,t){return t.domain(e.domain()).range(e.range()).interpolate(e.interpolate()).clamp(e.clamp())}function id(e,t){var r=ADt,n=ADt,i=n1,o=!1,a,s,l;function c(){return a=Math.min(r.length,n.length)>2?X6e:j6e,s=l=null,u}function u(h){return(s||(s=a(r,n,o?W6e(e):e,i)))(+h)}return u.invert=function(h){return(l||(l=a(n,r,fC,o?Y6e(t):t)))(+h)},u.domain=function(h){return arguments.length?(r=rw.call(h,zO),c()):r.slice()},u.range=function(h){return arguments.length?(n=pl.call(h),c()):n.slice()},u.rangeRound=function(h){return n=pl.call(h),i=Ott,c()},u.clamp=function(h){return arguments.length?(o=!!h,c()):o},u.interpolate=function(h){return arguments.length?(i=h,c()):i},c()}var ADt,pC=M(()=>{mf();uw();Cg();OO();ztt();ADt=[0,1]});function PDt(e){return Math.abs(e=Math.round(e))>=1e21?e.toLocaleString("en").replace(/,/g,""):e.toString(10)}function i1(e,t){if((r=(e=t?e.toExponential(t-1):e.toExponential()).indexOf("e"))<0)return null;var r,n=e.slice(0,r);return[n.length>1?n[0]+n.slice(2):n,+e.slice(r+1)]}var dC=M(()=>{});function vf(e){return e=i1(Math.abs(e)),e?e[1]:NaN}var mC=M(()=>{dC()});function IDt(e,t){return function(r,n){for(var i=r.length,o=[],a=0,s=e[0],l=0;i>0&&s>0&&(l+s+1>n&&(s=Math.max(1,n-l)),o.push(r.substring(i-=s,i+s)),!((l+=s+1)>n));)s=e[a=(a+1)%e.length];return o.reverse().join(t)}}var LDt=M(()=>{});function kDt(e){return function(t){return t.replace(/[0-9]/g,function(r){return e[+r]})}}var RDt=M(()=>{});function Lg(e){if(!(t=$6e.exec(e)))throw new Error("invalid format: "+e);var t;return new FO({fill:t[1],align:t[2],sign:t[3],symbol:t[4],zero:t[5],width:t[6],comma:t[7],precision:t[8]&&t[8].slice(1),trim:t[9],type:t[10]})}function FO(e){this.fill=e.fill===void 0?" ":e.fill+"",this.align=e.align===void 0?">":e.align+"",this.sign=e.sign===void 0?"-":e.sign+"",this.symbol=e.symbol===void 0?"":e.symbol+"",this.zero=!!e.zero,this.width=e.width===void 0?void 0:+e.width,this.comma=!!e.comma,this.precision=e.precision===void 0?void 0:+e.precision,this.trim=!!e.trim,this.type=e.type===void 0?"":e.type+""}var $6e,Ftt=M(()=>{$6e=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;Lg.prototype=FO.prototype;FO.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(this.width===void 0?"":Math.max(1,this.width|0))+(this.comma?",":"")+(this.precision===void 0?"":"."+Math.max(0,this.precision|0))+(this.trim?"~":"")+this.type}});function NDt(e){t:for(var t=e.length,r=1,n=-1,i;r<t;++r)switch(e[r]){case".":n=i=r;break;case"0":n===0&&(n=r),i=r;break;default:if(!+e[r])break t;n>0&&(n=0);break}return n>0?e.slice(0,n)+e.slice(i+1):e}var DDt=M(()=>{});function ODt(e,t){var r=i1(e,t);if(!r)return e+"";var n=r[0],i=r[1],o=i-(Btt=Math.max(-8,Math.min(8,Math.floor(i/3)))*3)+1,a=n.length;return o===a?n:o>a?n+new Array(o-a+1).join("0"):o>0?n.slice(0,o)+"."+n.slice(o):"0."+new Array(1-o).join("0")+i1(e,Math.max(0,t+o-1))[0]}var Btt,Htt=M(()=>{dC()});function Vtt(e,t){var r=i1(e,t);if(!r)return e+"";var n=r[0],i=r[1];return i<0?"0."+new Array(-i).join("0")+n:n.length>i+1?n.slice(0,i+1)+"."+n.slice(i+1):n+new Array(i-n.length+2).join("0")}var zDt=M(()=>{dC()});var Utt,FDt=M(()=>{dC();Htt();zDt();Utt={"%":function(e,t){return(e*100).toFixed(t)},b:function(e){return Math.round(e).toString(2)},c:function(e){return e+""},d:PDt,e:function(e,t){return e.toExponential(t)},f:function(e,t){return e.toFixed(t)},g:function(e,t){return e.toPrecision(t)},o:function(e){return Math.round(e).toString(8)},p:function(e,t){return Vtt(e*100,t)},r:Vtt,s:ODt,X:function(e){return Math.round(e).toString(16).toUpperCase()},x:function(e){return Math.round(e).toString(16)}}});function qtt(e){return e}var BDt=M(()=>{});function UDt(e){var t=e.grouping===void 0||e.thousands===void 0?qtt:IDt(HDt.call(e.grouping,Number),e.thousands+""),r=e.currency===void 0?"":e.currency[0]+"",n=e.currency===void 0?"":e.currency[1]+"",i=e.decimal===void 0?".":e.decimal+"",o=e.numerals===void 0?qtt:kDt(HDt.call(e.numerals,String)),a=e.percent===void 0?"%":e.percent+"",s=e.minus===void 0?"-":e.minus+"",l=e.nan===void 0?"NaN":e.nan+"";function c(h){h=Lg(h);var f=h.fill,p=h.align,d=h.sign,g=h.symbol,_=h.zero,y=h.width,x=h.comma,b=h.precision,S=h.trim,C=h.type;C==="n"?(x=!0,C="g"):Utt[C]||(b===void 0&&(b=12),S=!0,C="g"),(_||f==="0"&&p==="=")&&(_=!0,f="0",p="=");var P=g==="$"?r:g==="#"&&/[boxX]/.test(C)?"0"+C.toLowerCase():"",k=g==="$"?n:/[%p]/.test(C)?a:"",O=Utt[C],D=/[defgprs%]/.test(C);b=b===void 0?6:/[gprs]/.test(C)?Math.max(1,Math.min(21,b)):Math.max(0,Math.min(20,b));function B(I){var L=P,R=k,F,z,U;if(C==="c")R=O(I)+R,I="";else{I=+I;var W=I<0||1/I<0;if(I=isNaN(I)?l:O(Math.abs(I),b),S&&(I=NDt(I)),W&&+I==0&&d!=="+"&&(W=!1),L=(W?d==="("?d:s:d==="-"||d==="("?"":d)+L,R=(C==="s"?VDt[8+Btt/3]:"")+R+(W&&d==="("?")":""),D){for(F=-1,z=I.length;++F<z;)if(U=I.charCodeAt(F),48>U||U>57){R=(U===46?i+I.slice(F+1):I.slice(F))+R,I=I.slice(0,F);break}}}x&&!_&&(I=t(I,1/0));var Z=L.length+I.length+R.length,rt=Z<y?new Array(y-Z+1).join(f):"";switch(x&&_&&(I=t(rt+I,rt.length?y-R.length:1/0),rt=""),p){case"<":I=L+I+R+rt;break;case"=":I=L+rt+I+R;break;case"^":I=rt.slice(0,Z=rt.length>>1)+L+I+R+rt.slice(Z);break;default:I=rt+L+I+R;break}return o(I)}return B.toString=function(){return h+""},B}function u(h,f){var p=c((h=Lg(h),h.type="f",h)),d=Math.max(-8,Math.min(8,Math.floor(vf(f)/3)))*3,g=Math.pow(10,-d),_=VDt[8+d/3];return function(y){return p(g*y)+_}}return{format:c,formatPrefix:u}}var HDt,VDt,qDt=M(()=>{mC();LDt();RDt();Ftt();DDt();FDt();Htt();BDt();HDt=Array.prototype.map,VDt=["y","z","a","f","p","n","\xB5","m","","k","M","G","T","P","E","Z","Y"]});function Gtt(e){return BO=UDt(e),fw=BO.format,HO=BO.formatPrefix,BO}var BO,fw,HO,GDt=M(()=>{qDt();Gtt({decimal:".",thousands:",",grouping:[3],currency:["$",""],minus:"-"})});function Wtt(e){return Math.max(0,-vf(Math.abs(e)))}var WDt=M(()=>{mC()});function Ytt(e,t){return Math.max(0,Math.max(-8,Math.min(8,Math.floor(vf(t)/3)))*3-vf(Math.abs(e)))}var YDt=M(()=>{mC()});function jtt(e,t){return e=Math.abs(e),t=Math.abs(t)-e,Math.max(0,vf(t)-vf(e))+1}var jDt=M(()=>{mC()});var Xtt=M(()=>{GDt();Ftt();WDt();YDt();jDt()});function XDt(e,t,r){var n=e[0],i=e[e.length-1],o=Zy(n,i,t==null?10:t),a;switch(r=Lg(r==null?",f":r),r.type){case"s":{var s=Math.max(Math.abs(n),Math.abs(i));return r.precision==null&&!isNaN(a=Ytt(o,s))&&(r.precision=a),HO(r,s)}case"":case"e":case"g":case"p":case"r":{r.precision==null&&!isNaN(a=jtt(o,Math.max(Math.abs(n),Math.abs(i))))&&(r.precision=a-(r.type==="e"));break}case"f":case"%":{r.precision==null&&!isNaN(a=Wtt(o))&&(r.precision=a-(r.type==="%")*2);break}}return fw(r)}var $Dt=M(()=>{mf();Xtt()});function od(e){var t=e.domain;return e.ticks=function(r){var n=t();return aC(n[0],n[n.length-1],r==null?10:r)},e.tickFormat=function(r,n){return XDt(t(),r,n)},e.nice=function(r){r==null&&(r=10);var n=t(),i=0,o=n.length-1,a=n[i],s=n[o],l;return s<a&&(l=a,a=s,s=l,l=i,i=o,o=l),l=ew(a,s,r),l>0?(a=Math.floor(a/l)*l,s=Math.ceil(s/l)*l,l=ew(a,s,r)):l<0&&(a=Math.ceil(a*l)/l,s=Math.floor(s*l)/l,l=ew(a,s,r)),l>0?(n[i]=Math.floor(a/l)*l,n[o]=Math.ceil(s/l)*l,t(n)):l<0&&(n[i]=Math.ceil(a*l)/l,n[o]=Math.floor(s*l)/l,t(n)),e},e}function VO(){var e=id(fC,yf);return e.copy=function(){return Ig(e,VO())},od(e)}var pw=M(()=>{mf();uw();pC();$Dt()});function UO(){var e=[0,1];function t(r){return+r}return t.invert=t,t.domain=t.range=function(r){return arguments.length?(e=rw.call(r,zO),t):e.slice()},t.copy=function(){return UO().domain(e)},od(t)}var KDt=M(()=>{Cg();pw();ztt()});function qO(e,t){e=e.slice();var r=0,n=e.length-1,i=e[r],o=e[n],a;return o<i&&(a=r,r=n,n=a,a=i,i=o,o=a),e[r]=t.floor(i),e[n]=t.ceil(o),e}var $tt=M(()=>{});function K6e(e,t){return(t=Math.log(t/e))?function(r){return Math.log(r/e)/t}:hw(t)}function Z6e(e,t){return e<0?function(r){return-Math.pow(-t,r)*Math.pow(-e,1-r)}:function(r){return Math.pow(t,r)*Math.pow(e,1-r)}}function J6e(e){return isFinite(e)?+("1e"+e):e<0?0:e}function ZDt(e){return e===10?J6e:e===Math.E?Math.exp:function(t){return Math.pow(e,t)}}function JDt(e){return e===Math.E?Math.log:e===10&&Math.log10||e===2&&Math.log2||(e=Math.log(e),function(t){return Math.log(t)/e})}function QDt(e){return function(t){return-e(-t)}}function GO(){var e=id(K6e,Z6e).domain([1,10]),t=e.domain,r=10,n=JDt(10),i=ZDt(10);function o(){return n=JDt(r),i=ZDt(r),t()[0]<0&&(n=QDt(n),i=QDt(i)),e}return e.base=function(a){return arguments.length?(r=+a,o()):r},e.domain=function(a){return arguments.length?(t(a),o()):t()},e.ticks=function(a){var s=t(),l=s[0],c=s[s.length-1],u;(u=c<l)&&(h=l,l=c,c=h);var h=n(l),f=n(c),p,d,g,_=a==null?10:+a,y=[];if(!(r%1)&&f-h<_){if(h=Math.round(h)-1,f=Math.round(f)+1,l>0){for(;h<f;++h)for(d=1,p=i(h);d<r;++d)if(g=p*d,!(g<l)){if(g>c)break;y.push(g)}}else for(;h<f;++h)for(d=r-1,p=i(h);d>=1;--d)if(g=p*d,!(g<l)){if(g>c)break;y.push(g)}}else y=aC(h,f,Math.min(f-h,_)).map(i);return u?y.reverse():y},e.tickFormat=function(a,s){if(s==null&&(s=r===10?".0e":","),typeof s!="function"&&(s=fw(s)),a===1/0)return s;a==null&&(a=10);var l=Math.max(1,r*a/e.ticks().length);return function(c){var u=c/i(Math.round(n(c)));return u*r<r-.5&&(u*=r),u<=l?s(c):""}},e.nice=function(){return t(qO(t(),{floor:function(a){return i(Math.floor(n(a)))},ceil:function(a){return i(Math.ceil(n(a)))}}))},e.copy=function(){return Ig(e,GO().base(r))},e}var tOt=M(()=>{mf();Xtt();OO();$tt();pC()});function dw(e,t){return e<0?-Math.pow(-e,t):Math.pow(e,t)}function gC(){var e=1,t=id(n,i),r=t.domain;function n(o,a){return(a=dw(a,e)-(o=dw(o,e)))?function(s){return(dw(s,e)-o)/a}:hw(a)}function i(o,a){return a=dw(a,e)-(o=dw(o,e)),function(s){return dw(o+a*s,1/e)}}return t.exponent=function(o){return arguments.length?(e=+o,r(r())):e},t.copy=function(){return Ig(t,gC().exponent(e))},od(t)}function eOt(){return gC().exponent(.5)}var rOt=M(()=>{OO();pw();pC()});function WO(){var e=[],t=[],r=[];function n(){var o=0,a=Math.max(1,t.length);for(r=new Array(a-1);++o<a;)r[o-1]=sC(e,o/a);return i}function i(o){if(!isNaN(o=+o))return t[df(r,o)]}return i.invertExtent=function(o){var a=t.indexOf(o);return a<0?[NaN,NaN]:[a>0?r[a-1]:e[0],a<r.length?r[a]:e[e.length-1]]},i.domain=function(o){if(!arguments.length)return e.slice();e=[];for(var a=0,s=o.length,l;a<s;++a)l=o[a],l!=null&&!isNaN(l=+l)&&e.push(l);return e.sort(pf),n()},i.range=function(o){return arguments.length?(t=pl.call(o),n()):t.slice()},i.quantiles=function(){return r.slice()},i.copy=function(){return WO().domain(e).range(t)},i}var nOt=M(()=>{mf();Cg()});function YO(){var e=0,t=1,r=1,n=[.5],i=[0,1];function o(s){if(s<=s)return i[df(n,s,0,r)]}function a(){var s=-1;for(n=new Array(r);++s<r;)n[s]=((s+1)*t-(s-r)*e)/(r+1);return o}return o.domain=function(s){return arguments.length?(e=+s[0],t=+s[1],a()):[e,t]},o.range=function(s){return arguments.length?(r=(i=pl.call(s)).length-1,a()):i.slice()},o.invertExtent=function(s){var l=i.indexOf(s);return l<0?[NaN,NaN]:l<1?[e,n[0]]:l>=r?[n[r-1],t]:[n[l-1],n[l]]},o.copy=function(){return YO().domain([e,t]).range(i)},od(o)}var iOt=M(()=>{mf();Cg();pw()});function jO(){var e=[.5],t=[0,1],r=1;function n(i){if(i<=i)return t[df(e,i,0,r)]}return n.domain=function(i){return arguments.length?(e=pl.call(i),r=Math.min(e.length,t.length-1),n):e.slice()},n.range=function(i){return arguments.length?(t=pl.call(i),r=Math.min(e.length,t.length-1),n):t.slice()},n.invertExtent=function(i){var o=t.indexOf(i);return[e[o-1],e[o]]},n.copy=function(){return jO().domain(e).range(t)},n}var oOt=M(()=>{mf();Cg()});function Nr(e,t,r,n){function i(o){return e(o=arguments.length===0?new Date:new Date(+o)),o}return i.floor=function(o){return e(o=new Date(+o)),o},i.ceil=function(o){return e(o=new Date(o-1)),t(o,1),e(o),o},i.round=function(o){var a=i(o),s=i.ceil(o);return o-a<s-o?a:s},i.offset=function(o,a){return t(o=new Date(+o),a==null?1:Math.floor(a)),o},i.range=function(o,a,s){var l=[],c;if(o=i.ceil(o),s=s==null?1:Math.floor(s),!(o<a)||!(s>0))return l;do l.push(c=new Date(+o)),t(o,s),e(o);while(c<o&&o<a);return l},i.filter=function(o){return Nr(function(a){if(a>=a)for(;e(a),!o(a);)a.setTime(a-1)},function(a,s){if(a>=a)if(s<0)for(;++s<=0;)for(;t(a,-1),!o(a););else for(;--s>=0;)for(;t(a,1),!o(a););})},r&&(i.count=function(o,a){return Ktt.setTime(+o),Ztt.setTime(+a),e(Ktt),e(Ztt),Math.floor(r(Ktt,Ztt))},i.every=function(o){return o=Math.floor(o),!isFinite(o)||!(o>0)?null:o>1?i.filter(n?function(a){return n(a)%o===0}:function(a){return i.count(0,a)%o===0}):i}),i}var Ktt,Ztt,Ka=M(()=>{Ktt=new Date,Ztt=new Date});var XO,mw,aOt,sOt=M(()=>{Ka();XO=Nr(function(){},function(e,t){e.setTime(+e+t)},function(e,t){return t-e});XO.every=function(e){return e=Math.floor(e),!isFinite(e)||!(e>0)?null:e>1?Nr(function(t){t.setTime(Math.floor(t/e)*e)},function(t,r){t.setTime(+t+r*e)},function(t,r){return(r-t)/e}):XO};mw=XO,aOt=XO.range});var o1,wc,gw,$O,KO,xf=M(()=>{o1=1e3,wc=6e4,gw=36e5,$O=864e5,KO=6048e5});var lOt,_w,cOt,uOt=M(()=>{Ka();xf();lOt=Nr(function(e){e.setTime(e-e.getMilliseconds())},function(e,t){e.setTime(+e+t*o1)},function(e,t){return(t-e)/o1},function(e){return e.getUTCSeconds()}),_w=lOt,cOt=lOt.range});var hOt,Jtt,Q6e,fOt=M(()=>{Ka();xf();hOt=Nr(function(e){e.setTime(e-e.getMilliseconds()-e.getSeconds()*o1)},function(e,t){e.setTime(+e+t*wc)},function(e,t){return(t-e)/wc},function(e){return e.getMinutes()}),Jtt=hOt,Q6e=hOt.range});var pOt,Qtt,tIe,dOt=M(()=>{Ka();xf();pOt=Nr(function(e){e.setTime(e-e.getMilliseconds()-e.getSeconds()*o1-e.getMinutes()*wc)},function(e,t){e.setTime(+e+t*gw)},function(e,t){return(t-e)/gw},function(e){return e.getHours()}),Qtt=pOt,tIe=pOt.range});var mOt,yw,eIe,gOt=M(()=>{Ka();xf();mOt=Nr(function(e){e.setHours(0,0,0,0)},function(e,t){e.setDate(e.getDate()+t)},function(e,t){return(t-e-(t.getTimezoneOffset()-e.getTimezoneOffset())*wc)/$O},function(e){return e.getDate()-1}),yw=mOt,eIe=mOt.range});function a1(e){return Nr(function(t){t.setDate(t.getDate()-(t.getDay()+7-e)%7),t.setHours(0,0,0,0)},function(t,r){t.setDate(t.getDate()+r*7)},function(t,r){return(r-t-(r.getTimezoneOffset()-t.getTimezoneOffset())*wc)/KO})}var s1,vw,_Ot,yOt,kg,vOt,xOt,bOt,rIe,nIe,iIe,oIe,aIe,sIe,wOt=M(()=>{Ka();xf();s1=a1(0),vw=a1(1),_Ot=a1(2),yOt=a1(3),kg=a1(4),vOt=a1(5),xOt=a1(6),bOt=s1.range,rIe=vw.range,nIe=_Ot.range,iIe=yOt.range,oIe=kg.range,aIe=vOt.range,sIe=xOt.range});var SOt,tet,lIe,MOt=M(()=>{Ka();SOt=Nr(function(e){e.setDate(1),e.setHours(0,0,0,0)},function(e,t){e.setMonth(e.getMonth()+t)},function(e,t){return t.getMonth()-e.getMonth()+(t.getFullYear()-e.getFullYear())*12},function(e){return e.getMonth()}),tet=SOt,lIe=SOt.range});var eet,ad,cIe,EOt=M(()=>{Ka();eet=Nr(function(e){e.setMonth(0,1),e.setHours(0,0,0,0)},function(e,t){e.setFullYear(e.getFullYear()+t)},function(e,t){return t.getFullYear()-e.getFullYear()},function(e){return e.getFullYear()});eet.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:Nr(function(t){t.setFullYear(Math.floor(t.getFullYear()/e)*e),t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,r){t.setFullYear(t.getFullYear()+r*e)})};ad=eet,cIe=eet.range});var TOt,ret,uIe,COt=M(()=>{Ka();xf();TOt=Nr(function(e){e.setUTCSeconds(0,0)},function(e,t){e.setTime(+e+t*wc)},function(e,t){return(t-e)/wc},function(e){return e.getUTCMinutes()}),ret=TOt,uIe=TOt.range});var AOt,net,hIe,POt=M(()=>{Ka();xf();AOt=Nr(function(e){e.setUTCMinutes(0,0,0)},function(e,t){e.setTime(+e+t*gw)},function(e,t){return(t-e)/gw},function(e){return e.getUTCHours()}),net=AOt,hIe=AOt.range});var IOt,xw,fIe,LOt=M(()=>{Ka();xf();IOt=Nr(function(e){e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCDate(e.getUTCDate()+t)},function(e,t){return(t-e)/$O},function(e){return e.getUTCDate()-1}),xw=IOt,fIe=IOt.range});function l1(e){return Nr(function(t){t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-e)%7),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCDate(t.getUTCDate()+r*7)},function(t,r){return(r-t)/KO})}var c1,bw,kOt,ROt,Rg,NOt,DOt,OOt,pIe,dIe,mIe,gIe,_Ie,yIe,zOt=M(()=>{Ka();xf();c1=l1(0),bw=l1(1),kOt=l1(2),ROt=l1(3),Rg=l1(4),NOt=l1(5),DOt=l1(6),OOt=c1.range,pIe=bw.range,dIe=kOt.range,mIe=ROt.range,gIe=Rg.range,_Ie=NOt.range,yIe=DOt.range});var FOt,iet,vIe,BOt=M(()=>{Ka();FOt=Nr(function(e){e.setUTCDate(1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCMonth(e.getUTCMonth()+t)},function(e,t){return t.getUTCMonth()-e.getUTCMonth()+(t.getUTCFullYear()-e.getUTCFullYear())*12},function(e){return e.getUTCMonth()}),iet=FOt,vIe=FOt.range});var oet,sd,xIe,HOt=M(()=>{Ka();oet=Nr(function(e){e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCFullYear(e.getUTCFullYear()+t)},function(e,t){return t.getUTCFullYear()-e.getUTCFullYear()},function(e){return e.getUTCFullYear()});oet.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:Nr(function(t){t.setUTCFullYear(Math.floor(t.getUTCFullYear()/e)*e),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCFullYear(t.getUTCFullYear()+r*e)})};sd=oet,xIe=oet.range});var ZO=M(()=>{sOt();uOt();fOt();dOt();gOt();wOt();MOt();EOt();COt();POt();LOt();zOt();BOt();HOt()});function aet(e){if(0<=e.y&&e.y<100){var t=new Date(-1,e.m,e.d,e.H,e.M,e.S,e.L);return t.setFullYear(e.y),t}return new Date(e.y,e.m,e.d,e.H,e.M,e.S,e.L)}function set(e){if(0<=e.y&&e.y<100){var t=new Date(Date.UTC(-1,e.m,e.d,e.H,e.M,e.S,e.L));return t.setUTCFullYear(e.y),t}return new Date(Date.UTC(e.y,e.m,e.d,e.H,e.M,e.S,e.L))}function _C(e,t,r){return{y:e,m:t,d:r,H:0,M:0,S:0,L:0}}function cet(e){var t=e.dateTime,r=e.date,n=e.time,i=e.periods,o=e.days,a=e.shortDays,s=e.months,l=e.shortMonths,c=yC(i),u=vC(i),h=yC(o),f=vC(o),p=yC(a),d=vC(a),g=yC(s),_=vC(s),y=yC(l),x=vC(l),b={a:W,A:Z,b:rt,B:ot,c:null,d:YOt,e:YOt,f:qIe,g:QIe,G:e9e,H:HIe,I:VIe,j:UIe,L:ZOt,m:GIe,M:WIe,p:st,q:St,Q:$Ot,s:KOt,S:YIe,u:jIe,U:XIe,V:$Ie,w:KIe,W:ZIe,x:null,X:null,y:JIe,Y:t9e,Z:r9e,"%":XOt},S={a:bt,A:Mt,b:lt,B:Kt,c:null,d:jOt,e:jOt,f:a9e,g:g9e,G:y9e,H:n9e,I:i9e,j:o9e,L:QOt,m:s9e,M:l9e,p:_t,q:ct,Q:$Ot,s:KOt,S:c9e,u:u9e,U:h9e,V:f9e,w:p9e,W:d9e,x:null,X:null,y:m9e,Y:_9e,Z:v9e,"%":XOt},C={a:B,A:I,b:L,B:R,c:F,d:GOt,e:GOt,f:OIe,g:qOt,G:UOt,H:WOt,I:WOt,j:kIe,L:DIe,m:LIe,M:RIe,p:D,q:IIe,Q:FIe,s:BIe,S:NIe,u:EIe,U:TIe,V:CIe,w:MIe,W:AIe,x:z,X:U,y:qOt,Y:UOt,Z:PIe,"%":zIe};b.x=P(r,b),b.X=P(n,b),b.c=P(t,b),S.x=P(r,S),S.X=P(n,S),S.c=P(t,S);function P(X,et){return function(dt){var q=[],pt=-1,ht=0,wt=X.length,kt,ie,ee;for(dt instanceof Date||(dt=new Date(+dt));++pt<wt;)X.charCodeAt(pt)===37&&(q.push(X.slice(ht,pt)),(ie=VOt[kt=X.charAt(++pt)])!=null?kt=X.charAt(++pt):ie=kt==="e"?" ":"0",(ee=et[kt])&&(kt=ee(dt,ie)),q.push(kt),ht=pt+1);return q.push(X.slice(ht,pt)),q.join("")}}function k(X,et){return function(dt){var q=_C(1900,void 0,1),pt=O(q,X,dt+="",0),ht,wt;if(pt!=dt.length)return null;if("Q"in q)return new Date(q.Q);if("s"in q)return new Date(q.s*1e3+("L"in q?q.L:0));if(et&&!("Z"in q)&&(q.Z=0),"p"in q&&(q.H=q.H%12+q.p*12),q.m===void 0&&(q.m="q"in q?q.q:0),"V"in q){if(q.V<1||q.V>53)return null;"w"in q||(q.w=1),"Z"in q?(ht=set(_C(q.y,0,1)),wt=ht.getUTCDay(),ht=wt>4||wt===0?bw.ceil(ht):bw(ht),ht=xw.offset(ht,(q.V-1)*7),q.y=ht.getUTCFullYear(),q.m=ht.getUTCMonth(),q.d=ht.getUTCDate()+(q.w+6)%7):(ht=aet(_C(q.y,0,1)),wt=ht.getDay(),ht=wt>4||wt===0?vw.ceil(ht):vw(ht),ht=yw.offset(ht,(q.V-1)*7),q.y=ht.getFullYear(),q.m=ht.getMonth(),q.d=ht.getDate()+(q.w+6)%7)}else("W"in q||"U"in q)&&("w"in q||(q.w="u"in q?q.u%7:"W"in q?1:0),wt="Z"in q?set(_C(q.y,0,1)).getUTCDay():aet(_C(q.y,0,1)).getDay(),q.m=0,q.d="W"in q?(q.w+6)%7+q.W*7-(wt+5)%7:q.w+q.U*7-(wt+6)%7);return"Z"in q?(q.H+=q.Z/100|0,q.M+=q.Z%100,set(q)):aet(q)}}function O(X,et,dt,q){for(var pt=0,ht=et.length,wt=dt.length,kt,ie;pt<ht;){if(q>=wt)return-1;if(kt=et.charCodeAt(pt++),kt===37){if(kt=et.charAt(pt++),ie=C[kt in VOt?et.charAt(pt++):kt],!ie||(q=ie(X,dt,q))<0)return-1}else if(kt!=dt.charCodeAt(q++))return-1}return q}function D(X,et,dt){var q=c.exec(et.slice(dt));return q?(X.p=u[q[0].toLowerCase()],dt+q[0].length):-1}function B(X,et,dt){var q=p.exec(et.slice(dt));return q?(X.w=d[q[0].toLowerCase()],dt+q[0].length):-1}function I(X,et,dt){var q=h.exec(et.slice(dt));return q?(X.w=f[q[0].toLowerCase()],dt+q[0].length):-1}function L(X,et,dt){var q=y.exec(et.slice(dt));return q?(X.m=x[q[0].toLowerCase()],dt+q[0].length):-1}function R(X,et,dt){var q=g.exec(et.slice(dt));return q?(X.m=_[q[0].toLowerCase()],dt+q[0].length):-1}function F(X,et,dt){return O(X,t,et,dt)}function z(X,et,dt){return O(X,r,et,dt)}function U(X,et,dt){return O(X,n,et,dt)}function W(X){return a[X.getDay()]}function Z(X){return o[X.getDay()]}function rt(X){return l[X.getMonth()]}function ot(X){return s[X.getMonth()]}function st(X){return i[+(X.getHours()>=12)]}function St(X){return 1+~~(X.getMonth()/3)}function bt(X){return a[X.getUTCDay()]}function Mt(X){return o[X.getUTCDay()]}function lt(X){return l[X.getUTCMonth()]}function Kt(X){return s[X.getUTCMonth()]}function _t(X){return i[+(X.getUTCHours()>=12)]}function ct(X){return 1+~~(X.getUTCMonth()/3)}return{format:function(X){var et=P(X+="",b);return et.toString=function(){return X},et},parse:function(X){var et=k(X+="",!1);return et.toString=function(){return X},et},utcFormat:function(X){var et=P(X+="",S);return et.toString=function(){return X},et},utcParse:function(X){var et=k(X+="",!0);return et.toString=function(){return X},et}}}function Gr(e,t,r){var n=e<0?"-":"",i=(n?-e:e)+"",o=i.length;return n+(o<r?new Array(r-o+1).join(t)+i:i)}function SIe(e){return e.replace(wIe,"\\$&")}function yC(e){return new RegExp("^(?:"+e.map(SIe).join("|")+")","i")}function vC(e){for(var t={},r=-1,n=e.length;++r<n;)t[e[r].toLowerCase()]=r;return t}function MIe(e,t,r){var n=To.exec(t.slice(r,r+1));return n?(e.w=+n[0],r+n[0].length):-1}function EIe(e,t,r){var n=To.exec(t.slice(r,r+1));return n?(e.u=+n[0],r+n[0].length):-1}function TIe(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.U=+n[0],r+n[0].length):-1}function CIe(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.V=+n[0],r+n[0].length):-1}function AIe(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.W=+n[0],r+n[0].length):-1}function UOt(e,t,r){var n=To.exec(t.slice(r,r+4));return n?(e.y=+n[0],r+n[0].length):-1}function qOt(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.y=+n[0]+(+n[0]>68?1900:2e3),r+n[0].length):-1}function PIe(e,t,r){var n=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(t.slice(r,r+6));return n?(e.Z=n[1]?0:-(n[2]+(n[3]||"00")),r+n[0].length):-1}function IIe(e,t,r){var n=To.exec(t.slice(r,r+1));return n?(e.q=n[0]*3-3,r+n[0].length):-1}function LIe(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.m=n[0]-1,r+n[0].length):-1}function GOt(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.d=+n[0],r+n[0].length):-1}function kIe(e,t,r){var n=To.exec(t.slice(r,r+3));return n?(e.m=0,e.d=+n[0],r+n[0].length):-1}function WOt(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.H=+n[0],r+n[0].length):-1}function RIe(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.M=+n[0],r+n[0].length):-1}function NIe(e,t,r){var n=To.exec(t.slice(r,r+2));return n?(e.S=+n[0],r+n[0].length):-1}function DIe(e,t,r){var n=To.exec(t.slice(r,r+3));return n?(e.L=+n[0],r+n[0].length):-1}function OIe(e,t,r){var n=To.exec(t.slice(r,r+6));return n?(e.L=Math.floor(n[0]/1e3),r+n[0].length):-1}function zIe(e,t,r){var n=bIe.exec(t.slice(r,r+1));return n?r+n[0].length:-1}function FIe(e,t,r){var n=To.exec(t.slice(r));return n?(e.Q=+n[0],r+n[0].length):-1}function BIe(e,t,r){var n=To.exec(t.slice(r));return n?(e.s=+n[0],r+n[0].length):-1}function YOt(e,t){return Gr(e.getDate(),t,2)}function HIe(e,t){return Gr(e.getHours(),t,2)}function VIe(e,t){return Gr(e.getHours()%12||12,t,2)}function UIe(e,t){return Gr(1+yw.count(ad(e),e),t,3)}function ZOt(e,t){return Gr(e.getMilliseconds(),t,3)}function qIe(e,t){return ZOt(e,t)+"000"}function GIe(e,t){return Gr(e.getMonth()+1,t,2)}function WIe(e,t){return Gr(e.getMinutes(),t,2)}function YIe(e,t){return Gr(e.getSeconds(),t,2)}function jIe(e){var t=e.getDay();return t===0?7:t}function XIe(e,t){return Gr(s1.count(ad(e)-1,e),t,2)}function JOt(e){var t=e.getDay();return t>=4||t===0?kg(e):kg.ceil(e)}function $Ie(e,t){return e=JOt(e),Gr(kg.count(ad(e),e)+(ad(e).getDay()===4),t,2)}function KIe(e){return e.getDay()}function ZIe(e,t){return Gr(vw.count(ad(e)-1,e),t,2)}function JIe(e,t){return Gr(e.getFullYear()%100,t,2)}function QIe(e,t){return e=JOt(e),Gr(e.getFullYear()%100,t,2)}function t9e(e,t){return Gr(e.getFullYear()%1e4,t,4)}function e9e(e,t){var r=e.getDay();return e=r>=4||r===0?kg(e):kg.ceil(e),Gr(e.getFullYear()%1e4,t,4)}function r9e(e){var t=e.getTimezoneOffset();return(t>0?"-":(t*=-1,"+"))+Gr(t/60|0,"0",2)+Gr(t%60,"0",2)}function jOt(e,t){return Gr(e.getUTCDate(),t,2)}function n9e(e,t){return Gr(e.getUTCHours(),t,2)}function i9e(e,t){return Gr(e.getUTCHours()%12||12,t,2)}function o9e(e,t){return Gr(1+xw.count(sd(e),e),t,3)}function QOt(e,t){return Gr(e.getUTCMilliseconds(),t,3)}function a9e(e,t){return QOt(e,t)+"000"}function s9e(e,t){return Gr(e.getUTCMonth()+1,t,2)}function l9e(e,t){return Gr(e.getUTCMinutes(),t,2)}function c9e(e,t){return Gr(e.getUTCSeconds(),t,2)}function u9e(e){var t=e.getUTCDay();return t===0?7:t}function h9e(e,t){return Gr(c1.count(sd(e)-1,e),t,2)}function t7t(e){var t=e.getUTCDay();return t>=4||t===0?Rg(e):Rg.ceil(e)}function f9e(e,t){return e=t7t(e),Gr(Rg.count(sd(e),e)+(sd(e).getUTCDay()===4),t,2)}function p9e(e){return e.getUTCDay()}function d9e(e,t){return Gr(bw.count(sd(e)-1,e),t,2)}function m9e(e,t){return Gr(e.getUTCFullYear()%100,t,2)}function g9e(e,t){return e=t7t(e),Gr(e.getUTCFullYear()%100,t,2)}function _9e(e,t){return Gr(e.getUTCFullYear()%1e4,t,4)}function y9e(e,t){var r=e.getUTCDay();return e=r>=4||r===0?Rg(e):Rg.ceil(e),Gr(e.getUTCFullYear()%1e4,t,4)}function v9e(){return"+0000"}function XOt(){return"%"}function $Ot(e){return+e}function KOt(e){return Math.floor(+e/1e3)}var VOt,To,bIe,wIe,e7t=M(()=>{ZO();VOt={"-":"",_:" ",0:"0"},To=/^\s*\d+/,bIe=/^%/,wIe=/[\\^$*+?|[\]().{}]/g});function uet(e){return ww=cet(e),JO=ww.format,r7t=ww.parse,QO=ww.utcFormat,n7t=ww.utcParse,ww}var ww,JO,r7t,QO,n7t,i7t=M(()=>{e7t();uet({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]})});var het=M(()=>{i7t()});function b9e(e){return new Date(e)}function w9e(e){return e instanceof Date?+e:+new Date(+e)}function t7(e,t,r,n,i,o,a,s,l){var c=id(fC,yf),u=c.invert,h=c.domain,f=l(".%L"),p=l(":%S"),d=l("%I:%M"),g=l("%I %p"),_=l("%a %d"),y=l("%b %d"),x=l("%B"),b=l("%Y"),S=[[a,1,xC],[a,5,5*xC],[a,15,15*xC],[a,30,30*xC],[o,1,bC],[o,5,5*bC],[o,15,15*bC],[o,30,30*bC],[i,1,wC],[i,3,3*wC],[i,6,6*wC],[i,12,12*wC],[n,1,SC],[n,2,2*SC],[r,1,x9e],[t,1,o7t],[t,3,3*o7t],[e,1,fet]];function C(k){return(a(k)<k?f:o(k)<k?p:i(k)<k?d:n(k)<k?g:t(k)<k?r(k)<k?_:y:e(k)<k?x:b)(k)}function P(k,O,D,B){if(k==null&&(k=10),typeof k=="number"){var I=Math.abs(D-O)/k,L=oC(function(R){return R[2]}).right(S,I);L===S.length?(B=Zy(O/fet,D/fet,k),k=e):L?(L=S[I/S[L-1][2]<S[L][2]/I?L-1:L],B=L[1],k=L[0]):(B=Math.max(Zy(O,D,k),1),k=s)}return B==null?k:k.every(B)}return c.invert=function(k){return new Date(u(k))},c.domain=function(k){return arguments.length?h(rw.call(k,w9e)):h().map(b9e)},c.ticks=function(k,O){var D=h(),B=D[0],I=D[D.length-1],L=I<B,R;return L&&(R=B,B=I,I=R),R=P(k,B,I,O),R=R?R.range(B,I+1):[],L?R.reverse():R},c.tickFormat=function(k,O){return O==null?C:l(O)},c.nice=function(k,O){var D=h();return(k=P(k,D[0],D[D.length-1],O))?h(qO(D,k)):c},c.copy=function(){return Ig(c,t7(e,t,r,n,i,o,a,s,l))},c}function a7t(){return t7(ad,tet,s1,yw,Qtt,Jtt,_w,mw,JO).domain([new Date(2e3,0,1),new Date(2e3,0,2)])}var xC,bC,wC,SC,x9e,o7t,fet,pet=M(()=>{mf();uw();ZO();het();Cg();pC();$tt();xC=1e3,bC=xC*60,wC=bC*60,SC=wC*24,x9e=SC*7,o7t=SC*30,fet=SC*365});function s7t(){return t7(sd,iet,c1,xw,net,ret,_w,mw,QO).domain([Date.UTC(2e3,0,1),Date.UTC(2e3,0,2)])}var l7t=M(()=>{pet();het();ZO()});function dl(e){return e.match(/.{6}/g).map(function(t){return"#"+t})}var Sw=M(()=>{});var c7t,u7t=M(()=>{Sw();c7t=dl("1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf")});var h7t,f7t=M(()=>{Sw();h7t=dl("393b795254a36b6ecf9c9ede6379398ca252b5cf6bcedb9c8c6d31bd9e39e7ba52e7cb94843c39ad494ad6616be7969c7b4173a55194ce6dbdde9ed6")});var p7t,d7t=M(()=>{Sw();p7t=dl("3182bd6baed69ecae1c6dbefe6550dfd8d3cfdae6bfdd0a231a35474c476a1d99bc7e9c0756bb19e9ac8bcbddcdadaeb636363969696bdbdbdd9d9d9")});var m7t,g7t=M(()=>{Sw();m7t=dl("1f77b4aec7e8ff7f0effbb782ca02c98df8ad62728ff98969467bdc5b0d58c564bc49c94e377c2f7b6d27f7f7fc7c7c7bcbd22dbdb8d17becf9edae5")});var _7t,y7t=M(()=>{sw();uw();_7t=cw($a(300,.5,0),$a(-240,.5,1))});function b7t(e){(e<0||e>1)&&(e-=Math.floor(e));var t=Math.abs(e-.5);return e7.h=360*e-100,e7.s=1.5-1.5*t,e7.l=.8-.9*t,e7+""}var v7t,x7t,e7,w7t=M(()=>{sw();uw();v7t=cw($a(-100,.75,.35),$a(80,1.5,.8)),x7t=cw($a(260,.75,.35),$a(80,1.5,.8)),e7=$a()});function r7(e){var t=e.length;return function(r){return e[Math.max(0,Math.min(t-1,Math.floor(r*t)))]}}var S7t,M7t,E7t,T7t,C7t=M(()=>{Sw();S7t=r7(dl("44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725")),M7t=r7(dl("00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf")),E7t=r7(dl("00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4")),T7t=r7(dl("0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921"))});function n7(e){var t=0,r=1,n=!1;function i(o){var a=(o-t)/(r-t);return e(n?Math.max(0,Math.min(1,a)):a)}return i.domain=function(o){return arguments.length?(t=+o[0],r=+o[1],i):[t,r]},i.clamp=function(o){return arguments.length?(n=!!o,i):n},i.interpolator=function(o){return arguments.length?(e=o,i):e},i.copy=function(){return n7(e).domain([t,r]).clamp(n)},od(i)}var A7t=M(()=>{pw()});var P7t=M(()=>{UNt();KDt();pw();tOt();btt();rOt();nOt();iOt();oOt();pet();l7t();u7t();f7t();d7t();g7t();y7t();w7t();C7t();A7t()});var i7,MC,o7=M(()=>{i7="http://www.w3.org/1999/xhtml",MC={svg:"http://www.w3.org/2000/svg",xhtml:i7,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"}});function Mw(e){var t=e+="",r=t.indexOf(":");return r>=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),MC.hasOwnProperty(t)?{space:MC[t],local:e}:e}var a7=M(()=>{o7()});function S9e(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===i7&&t.documentElement.namespaceURI===i7?t.createElement(e):t.createElementNS(r,e)}}function M9e(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function Ng(e){var t=Mw(e);return(t.local?M9e:S9e)(t)}var EC=M(()=>{a7();o7()});function E9e(){}function Ew(e){return e==null?E9e:function(){return this.querySelector(e)}}var s7=M(()=>{});function I7t(e){typeof e!="function"&&(e=Ew(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=new Array(a),l,c,u=0;u<a;++u)(l=o[u])&&(c=e.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),s[u]=c);return new Hn(n,this._parents)}var L7t=M(()=>{Sc();s7()});function T9e(){return[]}function l7(e){return e==null?T9e:function(){return this.querySelectorAll(e)}}var det=M(()=>{});function k7t(e){typeof e!="function"&&(e=l7(e));for(var t=this._groups,r=t.length,n=[],i=[],o=0;o<r;++o)for(var a=t[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&(n.push(e.call(l,l.__data__,c,a)),i.push(l));return new Hn(n,i)}var R7t=M(()=>{Sc();det()});var D7t,Tw,N7t,c7,met=M(()=>{D7t=function(e){return function(){return this.matches(e)}};typeof document!="undefined"&&(Tw=document.documentElement,Tw.matches||(N7t=Tw.webkitMatchesSelector||Tw.msMatchesSelector||Tw.mozMatchesSelector||Tw.oMatchesSelector,D7t=function(e){return function(){return N7t.call(this,e)}}));c7=D7t});function O7t(e){typeof e!="function"&&(e=c7(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new Hn(n,this._parents)}var z7t=M(()=>{Sc();met()});function u7(e){return new Array(e.length)}var get=M(()=>{});function F7t(){return new Hn(this._enter||this._groups.map(u7),this._parents)}function TC(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}var _et=M(()=>{get();Sc();TC.prototype={constructor:TC,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}}});function B7t(e){return function(){return e}}var H7t=M(()=>{});function C9e(e,t,r,n,i,o){for(var a=0,s,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],n[a]=s):r[a]=new TC(e,o[a]);for(;a<l;++a)(s=t[a])&&(i[a]=s)}function A9e(e,t,r,n,i,o,a){var s,l,c={},u=t.length,h=o.length,f=new Array(u),p;for(s=0;s<u;++s)(l=t[s])&&(f[s]=p=V7t+a.call(l,l.__data__,s,t),p in c?i[s]=l:c[p]=l);for(s=0;s<h;++s)p=V7t+a.call(e,o[s],s,o),(l=c[p])?(n[s]=l,l.__data__=o[s],c[p]=null):r[s]=new TC(e,o[s]);for(s=0;s<u;++s)(l=t[s])&&c[f[s]]===l&&(i[s]=l)}function U7t(e,t){if(!e)return p=new Array(this.size()),c=-1,this.each(function(P){p[++c]=P}),p;var r=t?A9e:C9e,n=this._parents,i=this._groups;typeof e!="function"&&(e=B7t(e));for(var o=i.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var u=n[c],h=i[c],f=h.length,p=e.call(u,u&&u.__data__,c,n),d=p.length,g=s[c]=new Array(d),_=a[c]=new Array(d),y=l[c]=new Array(f);r(u,h,g,_,y,p,t);for(var x=0,b=0,S,C;x<d;++x)if(S=g[x]){for(x>=b&&(b=x+1);!(C=_[b])&&++b<d;);S._next=C||null}}return a=new Hn(a,n),a._enter=s,a._exit=l,a}var V7t,q7t=M(()=>{Sc();_et();H7t();V7t="$"});function G7t(){return new Hn(this._exit||this._groups.map(u7),this._parents)}var W7t=M(()=>{get();Sc()});function Y7t(e){for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new Hn(a,this._parents)}var j7t=M(()=>{Sc()});function X7t(){for(var e=this._groups,t=-1,r=e.length;++t<r;)for(var n=e[t],i=n.length-1,o=n[i],a;--i>=0;)(a=n[i])&&(o&&o!==a.nextSibling&&o.parentNode.insertBefore(a,o),o=a);return this}var $7t=M(()=>{});function K7t(e){e||(e=P9e);function t(h,f){return h&&f?e(h.__data__,f.__data__):!h-!f}for(var r=this._groups,n=r.length,i=new Array(n),o=0;o<n;++o){for(var a=r[o],s=a.length,l=i[o]=new Array(s),c,u=0;u<s;++u)(c=a[u])&&(l[u]=c);l.sort(t)}return new Hn(i,this._parents).order()}function P9e(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var Z7t=M(()=>{Sc()});function J7t(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}var Q7t=M(()=>{});function tzt(){var e=new Array(this.size()),t=-1;return this.each(function(){e[++t]=this}),e}var ezt=M(()=>{});function rzt(){for(var e=this._groups,t=0,r=e.length;t<r;++t)for(var n=e[t],i=0,o=n.length;i<o;++i){var a=n[i];if(a)return a}return null}var nzt=M(()=>{});function izt(){var e=0;return this.each(function(){++e}),e}var ozt=M(()=>{});function azt(){return!this.node()}var szt=M(()=>{});function lzt(e){for(var t=this._groups,r=0,n=t.length;r<n;++r)for(var i=t[r],o=0,a=i.length,s;o<a;++o)(s=i[o])&&e.call(s,s.__data__,o,i);return this}var czt=M(()=>{});function I9e(e){return function(){this.removeAttribute(e)}}function L9e(e){return function(){this.removeAttributeNS(e.space,e.local)}}function k9e(e,t){return function(){this.setAttribute(e,t)}}function R9e(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function N9e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttribute(e):this.setAttribute(e,r)}}function D9e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,r)}}function uzt(e,t){var r=Mw(e);if(arguments.length<2){var n=this.node();return r.local?n.getAttributeNS(r.space,r.local):n.getAttribute(r)}return this.each((t==null?r.local?L9e:I9e:typeof t=="function"?r.local?D9e:N9e:r.local?R9e:k9e)(r,t))}var hzt=M(()=>{a7()});function Cw(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}var h7=M(()=>{});function O9e(e){return function(){this.style.removeProperty(e)}}function z9e(e,t,r){return function(){this.style.setProperty(e,t,r)}}function F9e(e,t,r){return function(){var n=t.apply(this,arguments);n==null?this.style.removeProperty(e):this.style.setProperty(e,n,r)}}function fzt(e,t,r){return arguments.length>1?this.each((t==null?O9e:typeof t=="function"?F9e:z9e)(e,t,r==null?"":r)):yet(this.node(),e)}function yet(e,t){return e.style.getPropertyValue(t)||Cw(e).getComputedStyle(e,null).getPropertyValue(t)}var vet=M(()=>{h7()});function B9e(e){return function(){delete this[e]}}function H9e(e,t){return function(){this[e]=t}}function V9e(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function pzt(e,t){return arguments.length>1?this.each((t==null?B9e:typeof t=="function"?V9e:H9e)(e,t)):this.node()[e]}var dzt=M(()=>{});function mzt(e){return e.trim().split(/^|\s+/)}function xet(e){return e.classList||new gzt(e)}function gzt(e){this._node=e,this._names=mzt(e.getAttribute("class")||"")}function _zt(e,t){for(var r=xet(e),n=-1,i=t.length;++n<i;)r.add(t[n])}function yzt(e,t){for(var r=xet(e),n=-1,i=t.length;++n<i;)r.remove(t[n])}function U9e(e){return function(){_zt(this,e)}}function q9e(e){return function(){yzt(this,e)}}function G9e(e,t){return function(){(t.apply(this,arguments)?_zt:yzt)(this,e)}}function vzt(e,t){var r=mzt(e+"");if(arguments.length<2){for(var n=xet(this.node()),i=-1,o=r.length;++i<o;)if(!n.contains(r[i]))return!1;return!0}return this.each((typeof t=="function"?G9e:t?U9e:q9e)(r,t))}var xzt=M(()=>{gzt.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}}});function W9e(){this.textContent=""}function Y9e(e){return function(){this.textContent=e}}function j9e(e){return function(){var t=e.apply(this,arguments);this.textContent=t==null?"":t}}function bzt(e){return arguments.length?this.each(e==null?W9e:(typeof e=="function"?j9e:Y9e)(e)):this.node().textContent}var wzt=M(()=>{});function X9e(){this.innerHTML=""}function $9e(e){return function(){this.innerHTML=e}}function K9e(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t==null?"":t}}function Szt(e){return arguments.length?this.each(e==null?X9e:(typeof e=="function"?K9e:$9e)(e)):this.node().innerHTML}var Mzt=M(()=>{});function Z9e(){this.nextSibling&&this.parentNode.appendChild(this)}function Ezt(){return this.each(Z9e)}var Tzt=M(()=>{});function J9e(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function Czt(){return this.each(J9e)}var Azt=M(()=>{});function Pzt(e){var t=typeof e=="function"?e:Ng(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}var Izt=M(()=>{EC()});function Q9e(){return null}function Lzt(e,t){var r=typeof e=="function"?e:Ng(e),n=t==null?Q9e:typeof t=="function"?t:Ew(t);return this.select(function(){return this.insertBefore(r.apply(this,arguments),n.apply(this,arguments)||null)})}var kzt=M(()=>{EC();s7()});function tLe(){var e=this.parentNode;e&&e.removeChild(this)}function Rzt(){return this.each(tLe)}var Nzt=M(()=>{});function eLe(){return this.parentNode.insertBefore(this.cloneNode(!1),this.nextSibling)}function rLe(){return this.parentNode.insertBefore(this.cloneNode(!0),this.nextSibling)}function Dzt(e){return this.select(e?rLe:eLe)}var Ozt=M(()=>{});function zzt(e){return arguments.length?this.property("__data__",e):this.node().__data__}var Fzt=M(()=>{});function nLe(e,t,r){return e=Vzt(e,t,r),function(n){var i=n.relatedTarget;(!i||i!==this&&!(i.compareDocumentPosition(this)&8))&&e.call(this,n)}}function Vzt(e,t,r){return function(n){var i=Pu;Pu=n;try{e.call(this,this.__data__,t,r)}finally{Pu=i}}}function iLe(e){return e.trim().split(/^|\s+/).map(function(t){var r="",n=t.indexOf(".");return n>=0&&(r=t.slice(n+1),t=t.slice(0,n)),{type:t,name:r}})}function oLe(e){return function(){var t=this.__on;if(!!t){for(var r=0,n=-1,i=t.length,o;r<i;++r)o=t[r],(!e.type||o.type===e.type)&&o.name===e.name?this.removeEventListener(o.type,o.listener,o.capture):t[++n]=o;++n?t.length=n:delete this.__on}}}function aLe(e,t,r){var n=Hzt.hasOwnProperty(e.type)?nLe:Vzt;return function(i,o,a){var s=this.__on,l,c=n(t,o,a);if(s){for(var u=0,h=s.length;u<h;++u)if((l=s[u]).type===e.type&&l.name===e.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=r),l.value=t;return}}this.addEventListener(e.type,c,r),l={type:e.type,name:e.name,value:t,listener:c,capture:r},s?s.push(l):this.__on=[l]}}function Uzt(e,t,r){var n=iLe(e+""),i,o=n.length,a;if(arguments.length<2){var s=this.node().__on;if(s){for(var l=0,c=s.length,u;l<c;++l)for(i=0,u=s[l];i<o;++i)if((a=n[i]).type===u.type&&a.name===u.name)return u.value}return}for(s=t?aLe:oLe,r==null&&(r=!1),i=0;i<o;++i)this.each(s(n[i],t,r));return this}function qzt(e,t,r,n){var i=Pu;e.sourceEvent=Pu,Pu=e;try{return t.apply(r,n)}finally{Pu=i}}var Hzt,Pu,Bzt,f7=M(()=>{Hzt={},Pu=null;typeof document!="undefined"&&(Bzt=document.documentElement,"onmouseenter"in Bzt||(Hzt={mouseenter:"mouseover",mouseleave:"mouseout"}))});function Gzt(e,t,r){var n=Cw(e),i=n.CustomEvent;typeof i=="function"?i=new i(t,r):(i=n.document.createEvent("Event"),r?(i.initEvent(t,r.bubbles,r.cancelable),i.detail=r.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function sLe(e,t){return function(){return Gzt(this,e,t)}}function lLe(e,t){return function(){return Gzt(this,e,t.apply(this,arguments))}}function Wzt(e,t){return this.each((typeof t=="function"?lLe:sLe)(e,t))}var Yzt=M(()=>{h7()});function Hn(e,t){this._groups=e,this._parents=t}function jzt(){return new Hn([[document.documentElement]],CC)}var CC,Xzt,Sc=M(()=>{L7t();R7t();z7t();q7t();_et();W7t();j7t();$7t();Z7t();Q7t();ezt();nzt();ozt();szt();czt();hzt();vet();dzt();xzt();wzt();Mzt();Tzt();Azt();Izt();kzt();Nzt();Ozt();Fzt();f7();Yzt();CC=[null];Hn.prototype=jzt.prototype={constructor:Hn,select:I7t,selectAll:k7t,filter:O7t,data:U7t,enter:F7t,exit:G7t,merge:Y7t,order:X7t,sort:K7t,call:J7t,nodes:tzt,node:rzt,size:izt,empty:azt,each:lzt,attr:uzt,style:fzt,property:pzt,classed:vzt,text:bzt,html:Szt,raise:Ezt,lower:Czt,append:Pzt,insert:Lzt,remove:Rzt,clone:Dzt,datum:zzt,on:Uzt,dispatch:Wzt};Xzt=jzt});function p7(e){return typeof e=="string"?new Hn([[document.querySelector(e)]],[document.documentElement]):new Hn([[e]],CC)}var bet=M(()=>{Sc()});function $zt(e){return p7(Ng(e).call(document.documentElement))}var Kzt=M(()=>{EC();bet()});function d7(){return new wet}function wet(){this._="@"+(++cLe).toString(36)}var cLe,Zzt=M(()=>{cLe=0;wet.prototype=d7.prototype={constructor:wet,get:function(e){for(var t=this._;!(t in e);)if(!(e=e.parentNode))return;return e[t]},set:function(e,t){return e[this._]=t},remove:function(e){return this._ in e&&delete e[this._]},toString:function(){return this._}}});function Aw(){for(var e=Pu,t;t=e.sourceEvent;)e=t;return e}var m7=M(()=>{f7()});function Dg(e,t){var r=e.ownerSVGElement||e;if(r.createSVGPoint){var n=r.createSVGPoint();return n.x=t.clientX,n.y=t.clientY,n=n.matrixTransform(e.getScreenCTM().inverse()),[n.x,n.y]}var i=e.getBoundingClientRect();return[t.clientX-i.left-e.clientLeft,t.clientY-i.top-e.clientTop]}var AC=M(()=>{});function Jzt(e){var t=Aw();return t.changedTouches&&(t=t.changedTouches[0]),Dg(e,t)}var Qzt=M(()=>{m7();AC()});function tFt(e){return typeof e=="string"?new Hn([document.querySelectorAll(e)],[document.documentElement]):new Hn([e==null?[]:e],CC)}var eFt=M(()=>{Sc()});function rFt(e,t,r){arguments.length<3&&(r=t,t=Aw().changedTouches);for(var n=0,i=t?t.length:0,o;n<i;++n)if((o=t[n]).identifier===r)return Dg(e,o);return null}var nFt=M(()=>{m7();AC()});function iFt(e,t){t==null&&(t=Aw().touches);for(var r=0,n=t?t.length:0,i=new Array(n);r<n;++r)i[r]=Dg(e,t[r]);return i}var oFt=M(()=>{m7();AC()});var aFt=M(()=>{Kzt();EC();Zzt();met();Qzt();a7();o7();AC();bet();eFt();Sc();s7();det();vet();nFt();oFt();h7();f7()});function Tet(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function sFt(){return new Tet}var Met,Eet,u1,uLe,Iu,lFt=M(()=>{Met=Math.PI,Eet=2*Met,u1=1e-6,uLe=Eet-u1;Tet.prototype=sFt.prototype={constructor:Tet,moveTo:function(e,t){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)},closePath:function(){this._x1!==null&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(e,t){this._+="L"+(this._x1=+e)+","+(this._y1=+t)},quadraticCurveTo:function(e,t,r,n){this._+="Q"+ +e+","+ +t+","+(this._x1=+r)+","+(this._y1=+n)},bezierCurveTo:function(e,t,r,n,i,o){this._+="C"+ +e+","+ +t+","+ +r+","+ +n+","+(this._x1=+i)+","+(this._y1=+o)},arcTo:function(e,t,r,n,i){e=+e,t=+t,r=+r,n=+n,i=+i;var o=this._x1,a=this._y1,s=r-e,l=n-t,c=o-e,u=a-t,h=c*c+u*u;if(i<0)throw new Error("negative radius: "+i);if(this._x1===null)this._+="M"+(this._x1=e)+","+(this._y1=t);else if(h>u1)if(!(Math.abs(u*s-l*c)>u1)||!i)this._+="L"+(this._x1=e)+","+(this._y1=t);else{var f=r-o,p=n-a,d=s*s+l*l,g=f*f+p*p,_=Math.sqrt(d),y=Math.sqrt(h),x=i*Math.tan((Met-Math.acos((d+h-g)/(2*_*y)))/2),b=x/y,S=x/_;Math.abs(b-1)>u1&&(this._+="L"+(e+b*c)+","+(t+b*u)),this._+="A"+i+","+i+",0,0,"+ +(u*f>c*p)+","+(this._x1=e+S*s)+","+(this._y1=t+S*l)}},arc:function(e,t,r,n,i,o){e=+e,t=+t,r=+r,o=!!o;var a=r*Math.cos(n),s=r*Math.sin(n),l=e+a,c=t+s,u=1^o,h=o?n-i:i-n;if(r<0)throw new Error("negative radius: "+r);this._x1===null?this._+="M"+l+","+c:(Math.abs(this._x1-l)>u1||Math.abs(this._y1-c)>u1)&&(this._+="L"+l+","+c),r&&(h<0&&(h=h%Eet+Eet),h>uLe?this._+="A"+r+","+r+",0,1,"+u+","+(e-a)+","+(t-s)+"A"+r+","+r+",0,1,"+u+","+(this._x1=l)+","+(this._y1=c):h>u1&&(this._+="A"+r+","+r+",0,"+ +(h>=Met)+","+u+","+(this._x1=e+r*Math.cos(i))+","+(this._y1=t+r*Math.sin(i))))},rect:function(e,t,r,n){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)+"h"+ +r+"v"+ +n+"h"+-r+"Z"},toString:function(){return this._}};Iu=sFt});var Pw=M(()=>{lFt()});function Ge(e){return function(){return e}}var Og=M(()=>{});function uFt(e){return e>1?0:e<-1?ku:Math.acos(e)}function Aet(e){return e>=1?PC:e<=-1?-PC:Math.asin(e)}var Cet,Ho,zg,cFt,g7,Lu,h1,Co,ku,PC,Mc,Iw=M(()=>{Cet=Math.abs,Ho=Math.atan2,zg=Math.cos,cFt=Math.max,g7=Math.min,Lu=Math.sin,h1=Math.sqrt,Co=1e-12,ku=Math.PI,PC=ku/2,Mc=2*ku});function hLe(e){return e.innerRadius}function fLe(e){return e.outerRadius}function pLe(e){return e.startAngle}function dLe(e){return e.endAngle}function mLe(e){return e&&e.padAngle}function gLe(e,t,r,n,i,o,a,s){var l=r-e,c=n-t,u=a-i,h=s-o,f=(u*(t-o)-h*(e-i))/(h*l-u*c);return[e+f*l,t+f*c]}function _7(e,t,r,n,i,o,a){var s=e-r,l=t-n,c=(a?o:-o)/h1(s*s+l*l),u=c*l,h=-c*s,f=e+u,p=t+h,d=r+u,g=n+h,_=(f+d)/2,y=(p+g)/2,x=d-f,b=g-p,S=x*x+b*b,C=i-o,P=f*g-d*p,k=(b<0?-1:1)*h1(cFt(0,C*C*S-P*P)),O=(P*b-x*k)/S,D=(-P*x-b*k)/S,B=(P*b+x*k)/S,I=(-P*x+b*k)/S,L=O-_,R=D-y,F=B-_,z=I-y;return L*L+R*R>F*F+z*z&&(O=B,D=I),{cx:O,cy:D,x01:-u,y01:-h,x11:O*(i/C-1),y11:D*(i/C-1)}}function hFt(){var e=hLe,t=fLe,r=Ge(0),n=null,i=pLe,o=dLe,a=mLe,s=null;function l(){var c,u,h=+e.apply(this,arguments),f=+t.apply(this,arguments),p=i.apply(this,arguments)-PC,d=o.apply(this,arguments)-PC,g=Cet(d-p),_=d>p;if(s||(s=c=Iu()),f<h&&(u=f,f=h,h=u),!(f>Co))s.moveTo(0,0);else if(g>Mc-Co)s.moveTo(f*zg(p),f*Lu(p)),s.arc(0,0,f,p,d,!_),h>Co&&(s.moveTo(h*zg(d),h*Lu(d)),s.arc(0,0,h,d,p,_));else{var y=p,x=d,b=p,S=d,C=g,P=g,k=a.apply(this,arguments)/2,O=k>Co&&(n?+n.apply(this,arguments):h1(h*h+f*f)),D=g7(Cet(f-h)/2,+r.apply(this,arguments)),B=D,I=D,L,R;if(O>Co){var F=Aet(O/h*Lu(k)),z=Aet(O/f*Lu(k));(C-=F*2)>Co?(F*=_?1:-1,b+=F,S-=F):(C=0,b=S=(p+d)/2),(P-=z*2)>Co?(z*=_?1:-1,y+=z,x-=z):(P=0,y=x=(p+d)/2)}var U=f*zg(y),W=f*Lu(y),Z=h*zg(S),rt=h*Lu(S);if(D>Co){var ot=f*zg(x),st=f*Lu(x),St=h*zg(b),bt=h*Lu(b);if(g<ku){var Mt=C>Co?gLe(U,W,St,bt,ot,st,Z,rt):[Z,rt],lt=U-Mt[0],Kt=W-Mt[1],_t=ot-Mt[0],ct=st-Mt[1],X=1/Lu(uFt((lt*_t+Kt*ct)/(h1(lt*lt+Kt*Kt)*h1(_t*_t+ct*ct)))/2),et=h1(Mt[0]*Mt[0]+Mt[1]*Mt[1]);B=g7(D,(h-et)/(X-1)),I=g7(D,(f-et)/(X+1))}}P>Co?I>Co?(L=_7(St,bt,U,W,f,I,_),R=_7(ot,st,Z,rt,f,I,_),s.moveTo(L.cx+L.x01,L.cy+L.y01),I<D?s.arc(L.cx,L.cy,I,Ho(L.y01,L.x01),Ho(R.y01,R.x01),!_):(s.arc(L.cx,L.cy,I,Ho(L.y01,L.x01),Ho(L.y11,L.x11),!_),s.arc(0,0,f,Ho(L.cy+L.y11,L.cx+L.x11),Ho(R.cy+R.y11,R.cx+R.x11),!_),s.arc(R.cx,R.cy,I,Ho(R.y11,R.x11),Ho(R.y01,R.x01),!_))):(s.moveTo(U,W),s.arc(0,0,f,y,x,!_)):s.moveTo(U,W),!(h>Co)||!(C>Co)?s.lineTo(Z,rt):B>Co?(L=_7(Z,rt,ot,st,h,-B,_),R=_7(U,W,St,bt,h,-B,_),s.lineTo(L.cx+L.x01,L.cy+L.y01),B<D?s.arc(L.cx,L.cy,B,Ho(L.y01,L.x01),Ho(R.y01,R.x01),!_):(s.arc(L.cx,L.cy,B,Ho(L.y01,L.x01),Ho(L.y11,L.x11),!_),s.arc(0,0,h,Ho(L.cy+L.y11,L.cx+L.x11),Ho(R.cy+R.y11,R.cx+R.x11),_),s.arc(R.cx,R.cy,B,Ho(R.y11,R.x11),Ho(R.y01,R.x01),!_))):s.arc(0,0,h,S,b,_)}if(s.closePath(),c)return s=null,c+""||null}return l.centroid=function(){var c=(+e.apply(this,arguments)+ +t.apply(this,arguments))/2,u=(+i.apply(this,arguments)+ +o.apply(this,arguments))/2-ku/2;return[zg(u)*c,Lu(u)*c]},l.innerRadius=function(c){return arguments.length?(e=typeof c=="function"?c:Ge(+c),l):e},l.outerRadius=function(c){return arguments.length?(t=typeof c=="function"?c:Ge(+c),l):t},l.cornerRadius=function(c){return arguments.length?(r=typeof c=="function"?c:Ge(+c),l):r},l.padRadius=function(c){return arguments.length?(n=c==null?null:typeof c=="function"?c:Ge(+c),l):n},l.startAngle=function(c){return arguments.length?(i=typeof c=="function"?c:Ge(+c),l):i},l.endAngle=function(c){return arguments.length?(o=typeof c=="function"?c:Ge(+c),l):o},l.padAngle=function(c){return arguments.length?(a=typeof c=="function"?c:Ge(+c),l):a},l.context=function(c){return arguments.length?(s=c==null?null:c,l):s},l}var fFt=M(()=>{Pw();Og();Iw()});function pFt(e){this._context=e}function Fg(e){return new pFt(e)}var IC=M(()=>{pFt.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;default:this._context.lineTo(e,t);break}}}});function Lw(e){return e[0]}function kw(e){return e[1]}var y7=M(()=>{});function Rw(){var e=Lw,t=kw,r=Ge(!0),n=null,i=Fg,o=null;function a(s){var l,c=s.length,u,h=!1,f;for(n==null&&(o=i(f=Iu())),l=0;l<=c;++l)!(l<c&&r(u=s[l],l,s))===h&&((h=!h)?o.lineStart():o.lineEnd()),h&&o.point(+e(u,l,s),+t(u,l,s));if(f)return o=null,f+""||null}return a.x=function(s){return arguments.length?(e=typeof s=="function"?s:Ge(+s),a):e},a.y=function(s){return arguments.length?(t=typeof s=="function"?s:Ge(+s),a):t},a.defined=function(s){return arguments.length?(r=typeof s=="function"?s:Ge(!!s),a):r},a.curve=function(s){return arguments.length?(i=s,n!=null&&(o=i(n)),a):i},a.context=function(s){return arguments.length?(s==null?n=o=null:o=i(n=s),a):n},a}var v7=M(()=>{Pw();Og();IC();y7()});function x7(){var e=Lw,t=null,r=Ge(0),n=kw,i=Ge(!0),o=null,a=Fg,s=null;function l(u){var h,f,p,d=u.length,g,_=!1,y,x=new Array(d),b=new Array(d);for(o==null&&(s=a(y=Iu())),h=0;h<=d;++h){if(!(h<d&&i(g=u[h],h,u))===_)if(_=!_)f=h,s.areaStart(),s.lineStart();else{for(s.lineEnd(),s.lineStart(),p=h-1;p>=f;--p)s.point(x[p],b[p]);s.lineEnd(),s.areaEnd()}_&&(x[h]=+e(g,h,u),b[h]=+r(g,h,u),s.point(t?+t(g,h,u):x[h],n?+n(g,h,u):b[h]))}if(y)return s=null,y+""||null}function c(){return Rw().defined(i).curve(a).context(o)}return l.x=function(u){return arguments.length?(e=typeof u=="function"?u:Ge(+u),t=null,l):e},l.x0=function(u){return arguments.length?(e=typeof u=="function"?u:Ge(+u),l):e},l.x1=function(u){return arguments.length?(t=u==null?null:typeof u=="function"?u:Ge(+u),l):t},l.y=function(u){return arguments.length?(r=typeof u=="function"?u:Ge(+u),n=null,l):r},l.y0=function(u){return arguments.length?(r=typeof u=="function"?u:Ge(+u),l):r},l.y1=function(u){return arguments.length?(n=u==null?null:typeof u=="function"?u:Ge(+u),l):n},l.lineX0=l.lineY0=function(){return c().x(e).y(r)},l.lineY1=function(){return c().x(e).y(n)},l.lineX1=function(){return c().x(t).y(r)},l.defined=function(u){return arguments.length?(i=typeof u=="function"?u:Ge(!!u),l):i},l.curve=function(u){return arguments.length?(a=u,o!=null&&(s=a(o)),l):a},l.context=function(u){return arguments.length?(u==null?o=s=null:s=a(o=u),l):o},l}var Pet=M(()=>{Pw();Og();IC();v7();y7()});function dFt(e,t){return t<e?-1:t>e?1:t>=e?0:NaN}var mFt=M(()=>{});function gFt(e){return e}var _Ft=M(()=>{});function yFt(){var e=gFt,t=dFt,r=null,n=Ge(0),i=Ge(Mc),o=Ge(0);function a(s){var l,c=s.length,u,h,f=0,p=new Array(c),d=new Array(c),g=+n.apply(this,arguments),_=Math.min(Mc,Math.max(-Mc,i.apply(this,arguments)-g)),y,x=Math.min(Math.abs(_)/c,o.apply(this,arguments)),b=x*(_<0?-1:1),S;for(l=0;l<c;++l)(S=d[p[l]=l]=+e(s[l],l,s))>0&&(f+=S);for(t!=null?p.sort(function(C,P){return t(d[C],d[P])}):r!=null&&p.sort(function(C,P){return r(s[C],s[P])}),l=0,h=f?(_-c*b)/f:0;l<c;++l,g=y)u=p[l],S=d[u],y=g+(S>0?S*h:0)+b,d[u]={data:s[u],index:l,value:S,startAngle:g,endAngle:y,padAngle:x};return d}return a.value=function(s){return arguments.length?(e=typeof s=="function"?s:Ge(+s),a):e},a.sortValues=function(s){return arguments.length?(t=s,r=null,a):t},a.sort=function(s){return arguments.length?(r=s,t=null,a):r},a.startAngle=function(s){return arguments.length?(n=typeof s=="function"?s:Ge(+s),a):n},a.endAngle=function(s){return arguments.length?(i=typeof s=="function"?s:Ge(+s),a):i},a.padAngle=function(s){return arguments.length?(o=typeof s=="function"?s:Ge(+s),a):o},a}var vFt=M(()=>{Og();mFt();_Ft();Iw()});function xFt(e){this._curve=e}function Nw(e){function t(r){return new xFt(e(r))}return t._curve=e,t}var b7,Iet=M(()=>{IC();b7=Nw(Fg);xFt.prototype={areaStart:function(){this._curve.areaStart()},areaEnd:function(){this._curve.areaEnd()},lineStart:function(){this._curve.lineStart()},lineEnd:function(){this._curve.lineEnd()},point:function(e,t){this._curve.point(t*Math.sin(e),t*-Math.cos(e))}}});function Dw(e){var t=e.curve;return e.angle=e.x,delete e.x,e.radius=e.y,delete e.y,e.curve=function(r){return arguments.length?t(Nw(r)):t()._curve},e}function Let(){return Dw(Rw().curve(b7))}var ket=M(()=>{Iet();v7()});function Ret(){var e=x7().curve(b7),t=e.curve,r=e.lineX0,n=e.lineX1,i=e.lineY0,o=e.lineY1;return e.angle=e.x,delete e.x,e.startAngle=e.x0,delete e.x0,e.endAngle=e.x1,delete e.x1,e.radius=e.y,delete e.y,e.innerRadius=e.y0,delete e.y0,e.outerRadius=e.y1,delete e.y1,e.lineStartAngle=function(){return Dw(r())},delete e.lineX0,e.lineEndAngle=function(){return Dw(n())},delete e.lineX1,e.lineInnerRadius=function(){return Dw(i())},delete e.lineY0,e.lineOuterRadius=function(){return Dw(o())},delete e.lineY1,e.curve=function(a){return arguments.length?t(Nw(a)):t()._curve},e}var bFt=M(()=>{Iet();Pet();ket()});function f1(e,t){return[(t=+t)*Math.cos(e-=Math.PI/2),t*Math.sin(e)]}var Net=M(()=>{});var LC,Det=M(()=>{LC=Array.prototype.slice});function _Le(e){return e.source}function yLe(e){return e.target}function Oet(e){var t=_Le,r=yLe,n=Lw,i=kw,o=null;function a(){var s,l=LC.call(arguments),c=t.apply(this,l),u=r.apply(this,l);if(o||(o=s=Iu()),e(o,+n.apply(this,(l[0]=c,l)),+i.apply(this,l),+n.apply(this,(l[0]=u,l)),+i.apply(this,l)),s)return o=null,s+""||null}return a.source=function(s){return arguments.length?(t=s,a):t},a.target=function(s){return arguments.length?(r=s,a):r},a.x=function(s){return arguments.length?(n=typeof s=="function"?s:Ge(+s),a):n},a.y=function(s){return arguments.length?(i=typeof s=="function"?s:Ge(+s),a):i},a.context=function(s){return arguments.length?(o=s==null?null:s,a):o},a}function vLe(e,t,r,n,i){e.moveTo(t,r),e.bezierCurveTo(t=(t+n)/2,r,t,i,n,i)}function xLe(e,t,r,n,i){e.moveTo(t,r),e.bezierCurveTo(t,r=(r+i)/2,n,r,n,i)}function bLe(e,t,r,n,i){var o=f1(t,r),a=f1(t,r=(r+i)/2),s=f1(n,r),l=f1(n,i);e.moveTo(o[0],o[1]),e.bezierCurveTo(a[0],a[1],s[0],s[1],l[0],l[1])}function wFt(){return Oet(vLe)}function SFt(){return Oet(xLe)}function MFt(){var e=Oet(bLe);return e.angle=e.x,delete e.x,e.radius=e.y,delete e.y,e}var EFt=M(()=>{Pw();Det();Og();y7();Net()});var kC,zet=M(()=>{Iw();kC={draw:function(e,t){var r=Math.sqrt(t/ku);e.moveTo(r,0),e.arc(0,0,r,0,Mc)}}});var w7,Fet=M(()=>{w7={draw:function(e,t){var r=Math.sqrt(t/5)/2;e.moveTo(-3*r,-r),e.lineTo(-r,-r),e.lineTo(-r,-3*r),e.lineTo(r,-3*r),e.lineTo(r,-r),e.lineTo(3*r,-r),e.lineTo(3*r,r),e.lineTo(r,r),e.lineTo(r,3*r),e.lineTo(-r,3*r),e.lineTo(-r,r),e.lineTo(-3*r,r),e.closePath()}}});var TFt,wLe,S7,Bet=M(()=>{TFt=Math.sqrt(.3333333333333333),wLe=TFt*2,S7={draw:function(e,t){var r=Math.sqrt(t/wLe),n=r*TFt;e.moveTo(0,-r),e.lineTo(n,0),e.lineTo(0,r),e.lineTo(-n,0),e.closePath()}}});var SLe,CFt,MLe,ELe,M7,Het=M(()=>{Iw();SLe=.8908130915292852,CFt=Math.sin(ku/10)/Math.sin(7*ku/10),MLe=Math.sin(Mc/10)*CFt,ELe=-Math.cos(Mc/10)*CFt,M7={draw:function(e,t){var r=Math.sqrt(t*SLe),n=MLe*r,i=ELe*r;e.moveTo(0,-r),e.lineTo(n,i);for(var o=1;o<5;++o){var a=Mc*o/5,s=Math.cos(a),l=Math.sin(a);e.lineTo(l*r,-s*r),e.lineTo(s*n-l*i,l*n+s*i)}e.closePath()}}});var E7,Vet=M(()=>{E7={draw:function(e,t){var r=Math.sqrt(t),n=-r/2;e.rect(n,n,r,r)}}});var Uet,T7,qet=M(()=>{Uet=Math.sqrt(3),T7={draw:function(e,t){var r=-Math.sqrt(t/(Uet*3));e.moveTo(0,r*2),e.lineTo(-Uet*r,-r),e.lineTo(Uet*r,-r),e.closePath()}}});var Ec,Tc,Get,TLe,C7,Wet=M(()=>{Ec=-.5,Tc=Math.sqrt(3)/2,Get=1/Math.sqrt(12),TLe=(Get/2+1)*3,C7={draw:function(e,t){var r=Math.sqrt(t/TLe),n=r/2,i=r*Get,o=n,a=r*Get+r,s=-o,l=a;e.moveTo(n,i),e.lineTo(o,a),e.lineTo(s,l),e.lineTo(Ec*n-Tc*i,Tc*n+Ec*i),e.lineTo(Ec*o-Tc*a,Tc*o+Ec*a),e.lineTo(Ec*s-Tc*l,Tc*s+Ec*l),e.lineTo(Ec*n+Tc*i,Ec*i-Tc*n),e.lineTo(Ec*o+Tc*a,Ec*a-Tc*o),e.lineTo(Ec*s+Tc*l,Ec*l-Tc*s),e.closePath()}}});function PFt(){var e=Ge(kC),t=Ge(64),r=null;function n(){var i;if(r||(r=i=Iu()),e.apply(this,arguments).draw(r,+t.apply(this,arguments)),i)return r=null,i+""||null}return n.type=function(i){return arguments.length?(e=typeof i=="function"?i:Ge(i),n):e},n.size=function(i){return arguments.length?(t=typeof i=="function"?i:Ge(+i),n):t},n.context=function(i){return arguments.length?(r=i==null?null:i,n):r},n}var AFt,IFt=M(()=>{Pw();zet();Fet();Bet();Het();Vet();qet();Wet();Og();AFt=[kC,w7,S7,E7,M7,T7,C7]});function Cc(){}var RC=M(()=>{});function Ow(e,t,r){e._context.bezierCurveTo((2*e._x0+e._x1)/3,(2*e._y0+e._y1)/3,(e._x0+2*e._x1)/3,(e._y0+2*e._y1)/3,(e._x0+4*e._x1+t)/6,(e._y0+4*e._y1+r)/6)}function NC(e){this._context=e}function LFt(e){return new NC(e)}var DC=M(()=>{NC.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){switch(this._point){case 3:Ow(this,this._x1,this._y1);case 2:this._context.lineTo(this._x1,this._y1);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3,this._context.lineTo((5*this._x0+this._x1)/6,(5*this._y0+this._y1)/6);default:Ow(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}}});function kFt(e){this._context=e}function RFt(e){return new kFt(e)}var NFt=M(()=>{RC();DC();kFt.prototype={areaStart:Cc,areaEnd:Cc,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._y0=this._y1=this._y2=this._y3=this._y4=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x2,this._y2),this._context.closePath();break}case 2:{this._context.moveTo((this._x2+2*this._x3)/3,(this._y2+2*this._y3)/3),this._context.lineTo((this._x3+2*this._x2)/3,(this._y3+2*this._y2)/3),this._context.closePath();break}case 3:{this.point(this._x2,this._y2),this.point(this._x3,this._y3),this.point(this._x4,this._y4);break}}},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._x2=e,this._y2=t;break;case 1:this._point=2,this._x3=e,this._y3=t;break;case 2:this._point=3,this._x4=e,this._y4=t,this._context.moveTo((this._x0+4*this._x1+e)/6,(this._y0+4*this._y1+t)/6);break;default:Ow(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}}});function DFt(e){this._context=e}function OFt(e){return new DFt(e)}var zFt=M(()=>{DC();DFt.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3;var r=(this._x0+4*this._x1+e)/6,n=(this._y0+4*this._y1+t)/6;this._line?this._context.lineTo(r,n):this._context.moveTo(r,n);break;case 3:this._point=4;default:Ow(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}}});function FFt(e,t){this._basis=new NC(e),this._beta=t}var BFt,HFt=M(()=>{DC();FFt.prototype={lineStart:function(){this._x=[],this._y=[],this._basis.lineStart()},lineEnd:function(){var e=this._x,t=this._y,r=e.length-1;if(r>0)for(var n=e[0],i=t[0],o=e[r]-n,a=t[r]-i,s=-1,l;++s<=r;)l=s/r,this._basis.point(this._beta*e[s]+(1-this._beta)*(n+l*o),this._beta*t[s]+(1-this._beta)*(i+l*a));this._x=this._y=null,this._basis.lineEnd()},point:function(e,t){this._x.push(+e),this._y.push(+t)}};BFt=function e(t){function r(n){return t===1?new NC(n):new FFt(n,t)}return r.beta=function(n){return e(+n)},r}(.85)});function zw(e,t,r){e._context.bezierCurveTo(e._x1+e._k*(e._x2-e._x0),e._y1+e._k*(e._y2-e._y0),e._x2+e._k*(e._x1-t),e._y2+e._k*(e._y1-r),e._x2,e._y2)}function A7(e,t){this._context=e,this._k=(1-t)/6}var VFt,OC=M(()=>{A7.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:zw(this,this._x1,this._y1);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2,this._x1=e,this._y1=t;break;case 2:this._point=3;default:zw(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};VFt=function e(t){function r(n){return new A7(n,t)}return r.tension=function(n){return e(+n)},r}(0)});function P7(e,t){this._context=e,this._k=(1-t)/6}var UFt,Yet=M(()=>{RC();OC();P7.prototype={areaStart:Cc,areaEnd:Cc,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x3,this._y3),this._context.closePath();break}case 2:{this._context.lineTo(this._x3,this._y3),this._context.closePath();break}case 3:{this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5);break}}},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._x3=e,this._y3=t;break;case 1:this._point=2,this._context.moveTo(this._x4=e,this._y4=t);break;case 2:this._point=3,this._x5=e,this._y5=t;break;default:zw(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};UFt=function e(t){function r(n){return new P7(n,t)}return r.tension=function(n){return e(+n)},r}(0)});function I7(e,t){this._context=e,this._k=(1-t)/6}var qFt,jet=M(()=>{OC();I7.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:zw(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};qFt=function e(t){function r(n){return new I7(n,t)}return r.tension=function(n){return e(+n)},r}(0)});function zC(e,t,r){var n=e._x1,i=e._y1,o=e._x2,a=e._y2;if(e._l01_a>Co){var s=2*e._l01_2a+3*e._l01_a*e._l12_a+e._l12_2a,l=3*e._l01_a*(e._l01_a+e._l12_a);n=(n*s-e._x0*e._l12_2a+e._x2*e._l01_2a)/l,i=(i*s-e._y0*e._l12_2a+e._y2*e._l01_2a)/l}if(e._l23_a>Co){var c=2*e._l23_2a+3*e._l23_a*e._l12_a+e._l12_2a,u=3*e._l23_a*(e._l23_a+e._l12_a);o=(o*c+e._x1*e._l23_2a-t*e._l12_2a)/u,a=(a*c+e._y1*e._l23_2a-r*e._l12_2a)/u}e._context.bezierCurveTo(n,i,o,a,e._x2,e._y2)}function GFt(e,t){this._context=e,this._alpha=t}var WFt,L7=M(()=>{Iw();OC();GFt.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:this.point(this._x2,this._y2);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,n=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+n*n,this._alpha))}switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3;default:zC(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};WFt=function e(t){function r(n){return t?new GFt(n,t):new A7(n,0)}return r.alpha=function(n){return e(+n)},r}(.5)});function YFt(e,t){this._context=e,this._alpha=t}var jFt,XFt=M(()=>{Yet();RC();L7();YFt.prototype={areaStart:Cc,areaEnd:Cc,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x3,this._y3),this._context.closePath();break}case 2:{this._context.lineTo(this._x3,this._y3),this._context.closePath();break}case 3:{this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5);break}}},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,n=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+n*n,this._alpha))}switch(this._point){case 0:this._point=1,this._x3=e,this._y3=t;break;case 1:this._point=2,this._context.moveTo(this._x4=e,this._y4=t);break;case 2:this._point=3,this._x5=e,this._y5=t;break;default:zC(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};jFt=function e(t){function r(n){return t?new YFt(n,t):new P7(n,0)}return r.alpha=function(n){return e(+n)},r}(.5)});function $Ft(e,t){this._context=e,this._alpha=t}var KFt,ZFt=M(()=>{jet();L7();$Ft.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,n=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+n*n,this._alpha))}switch(this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:zC(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};KFt=function e(t){function r(n){return t?new $Ft(n,t):new I7(n,0)}return r.alpha=function(n){return e(+n)},r}(.5)});function JFt(e){this._context=e}function QFt(e){return new JFt(e)}var tBt=M(()=>{RC();JFt.prototype={areaStart:Cc,areaEnd:Cc,lineStart:function(){this._point=0},lineEnd:function(){this._point&&this._context.closePath()},point:function(e,t){e=+e,t=+t,this._point?this._context.lineTo(e,t):(this._point=1,this._context.moveTo(e,t))}}});function eBt(e){return e<0?-1:1}function rBt(e,t,r){var n=e._x1-e._x0,i=t-e._x1,o=(e._y1-e._y0)/(n||i<0&&-0),a=(r-e._y1)/(i||n<0&&-0),s=(o*i+a*n)/(n+i);return(eBt(o)+eBt(a))*Math.min(Math.abs(o),Math.abs(a),.5*Math.abs(s))||0}function nBt(e,t){var r=e._x1-e._x0;return r?(3*(e._y1-e._y0)/r-t)/2:t}function Xet(e,t,r){var n=e._x0,i=e._y0,o=e._x1,a=e._y1,s=(o-n)/3;e._context.bezierCurveTo(n+s,i+s*t,o-s,a-s*r,o,a)}function k7(e){this._context=e}function iBt(e){this._context=new oBt(e)}function oBt(e){this._context=e}function aBt(e){return new k7(e)}function sBt(e){return new iBt(e)}var lBt=M(()=>{k7.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=this._t0=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x1,this._y1);break;case 3:Xet(this,this._t0,nBt(this,this._t0));break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){var r=NaN;if(e=+e,t=+t,!(e===this._x1&&t===this._y1)){switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3,Xet(this,nBt(this,r=rBt(this,e,t)),r);break;default:Xet(this,this._t0,r=rBt(this,e,t));break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t,this._t0=r}}};(iBt.prototype=Object.create(k7.prototype)).point=function(e,t){k7.prototype.point.call(this,t,e)};oBt.prototype={moveTo:function(e,t){this._context.moveTo(t,e)},closePath:function(){this._context.closePath()},lineTo:function(e,t){this._context.lineTo(t,e)},bezierCurveTo:function(e,t,r,n,i,o){this._context.bezierCurveTo(t,e,n,r,o,i)}}});function uBt(e){this._context=e}function cBt(e){var t,r=e.length-1,n,i=new Array(r),o=new Array(r),a=new Array(r);for(i[0]=0,o[0]=2,a[0]=e[0]+2*e[1],t=1;t<r-1;++t)i[t]=1,o[t]=4,a[t]=4*e[t]+2*e[t+1];for(i[r-1]=2,o[r-1]=7,a[r-1]=8*e[r-1]+e[r],t=1;t<r;++t)n=i[t]/o[t-1],o[t]-=n,a[t]-=n*a[t-1];for(i[r-1]=a[r-1]/o[r-1],t=r-2;t>=0;--t)i[t]=(a[t]-i[t+1])/o[t];for(o[r-1]=(e[r]+i[r-1])/2,t=0;t<r-1;++t)o[t]=2*e[t+1]-i[t+1];return[i,o]}function hBt(e){return new uBt(e)}var fBt=M(()=>{uBt.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=[],this._y=[]},lineEnd:function(){var e=this._x,t=this._y,r=e.length;if(r)if(this._line?this._context.lineTo(e[0],t[0]):this._context.moveTo(e[0],t[0]),r===2)this._context.lineTo(e[1],t[1]);else for(var n=cBt(e),i=cBt(t),o=0,a=1;a<r;++o,++a)this._context.bezierCurveTo(n[0][o],i[0][o],n[1][o],i[1][o],e[a],t[a]);(this._line||this._line!==0&&r===1)&&this._context.closePath(),this._line=1-this._line,this._x=this._y=null},point:function(e,t){this._x.push(+e),this._y.push(+t)}}});function R7(e,t){this._context=e,this._t=t}function pBt(e){return new R7(e,.5)}function dBt(e){return new R7(e,0)}function mBt(e){return new R7(e,1)}var gBt=M(()=>{R7.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=this._y=NaN,this._point=0},lineEnd:function(){0<this._t&&this._t<1&&this._point===2&&this._context.lineTo(this._x,this._y),(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line>=0&&(this._t=1-this._t,this._line=1-this._line)},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;default:{if(this._t<=0)this._context.lineTo(this._x,t),this._context.lineTo(e,t);else{var r=this._x*(1-this._t)+e*this._t;this._context.lineTo(r,this._y),this._context.lineTo(r,t)}break}}this._x=e,this._y=t}}});function Ru(e,t){if((a=e.length)>1)for(var r=1,n,i,o=e[t[0]],a,s=o.length;r<a;++r)for(i=o,o=e[t[r]],n=0;n<s;++n)o[n][1]+=o[n][0]=isNaN(i[n][1])?i[n][0]:i[n][1]}var Fw=M(()=>{});function Nu(e){for(var t=e.length,r=new Array(t);--t>=0;)r[t]=t;return r}var Bw=M(()=>{});function CLe(e,t){return e[t]}function _Bt(){var e=Ge([]),t=Nu,r=Ru,n=CLe;function i(o){var a=e.apply(this,arguments),s,l=o.length,c=a.length,u=new Array(c),h;for(s=0;s<c;++s){for(var f=a[s],p=u[s]=new Array(l),d=0,g;d<l;++d)p[d]=g=[0,+n(o[d],f,d,o)],g.data=o[d];p.key=f}for(s=0,h=t(u);s<c;++s)u[h[s]].index=s;return r(u,h),u}return i.keys=function(o){return arguments.length?(e=typeof o=="function"?o:Ge(LC.call(o)),i):e},i.value=function(o){return arguments.length?(n=typeof o=="function"?o:Ge(+o),i):n},i.order=function(o){return arguments.length?(t=o==null?Nu:typeof o=="function"?o:Ge(LC.call(o)),i):t},i.offset=function(o){return arguments.length?(r=o==null?Ru:o,i):r},i}var yBt=M(()=>{Det();Og();Fw();Bw()});function vBt(e,t){if((n=e.length)>0){for(var r,n,i=0,o=e[0].length,a;i<o;++i){for(a=r=0;r<n;++r)a+=e[r][i][1]||0;if(a)for(r=0;r<n;++r)e[r][i][1]/=a}Ru(e,t)}}var xBt=M(()=>{Fw()});function bBt(e,t){if((l=e.length)>1)for(var r,n=0,i,o,a,s,l,c=e[t[0]].length;n<c;++n)for(a=s=0,r=0;r<l;++r)(o=(i=e[t[r]][n])[1]-i[0])>=0?(i[0]=a,i[1]=a+=o):o<0?(i[1]=s,i[0]=s+=o):i[0]=a}var wBt=M(()=>{});function SBt(e,t){if((i=e.length)>0){for(var r=0,n=e[t[0]],i,o=n.length;r<o;++r){for(var a=0,s=0;a<i;++a)s+=e[a][r][1]||0;n[r][1]+=n[r][0]=-s/2}Ru(e,t)}}var MBt=M(()=>{Fw()});function EBt(e,t){if(!(!((a=e.length)>0)||!((o=(i=e[t[0]]).length)>0))){for(var r=0,n=1,i,o,a;n<o;++n){for(var s=0,l=0,c=0;s<a;++s){for(var u=e[t[s]],h=u[n][1]||0,f=u[n-1][1]||0,p=(h-f)/2,d=0;d<s;++d){var g=e[t[d]],_=g[n][1]||0,y=g[n-1][1]||0;p+=_-y}l+=h,c+=p*h}i[n-1][1]+=i[n-1][0]=r,l&&(r-=c/l)}i[n-1][1]+=i[n-1][0]=r,Ru(e,t)}}var TBt=M(()=>{Fw()});function N7(e){var t=e.map($et);return Nu(e).sort(function(r,n){return t[r]-t[n]})}function $et(e){for(var t=0,r=-1,n=e.length,i;++r<n;)(i=+e[r][1])&&(t+=i);return t}var D7=M(()=>{Bw()});function CBt(e){return N7(e).reverse()}var ABt=M(()=>{D7()});function PBt(e){var t=e.length,r,n,i=e.map($et),o=Nu(e).sort(function(u,h){return i[h]-i[u]}),a=0,s=0,l=[],c=[];for(r=0;r<t;++r)n=o[r],a<s?(a+=i[n],l.push(n)):(s+=i[n],c.push(n));return c.reverse().concat(l)}var IBt=M(()=>{Bw();D7()});function LBt(e){return Nu(e).reverse()}var kBt=M(()=>{Bw()});var RBt=M(()=>{fFt();Pet();v7();vFt();bFt();ket();Net();EFt();IFt();zet();Fet();Bet();Vet();Het();qet();Wet();NFt();zFt();DC();HFt();Yet();jet();OC();XFt();ZFt();L7();tBt();IC();lBt();fBt();gBt();yBt();xBt();wBt();Fw();MBt();TBt();D7();ABt();IBt();Bw();kBt()});function Sr(e,t,r,n){function i(o){return e(o=new Date(+o)),o}return i.floor=i,i.ceil=function(o){return e(o=new Date(o-1)),t(o,1),e(o),o},i.round=function(o){var a=i(o),s=i.ceil(o);return o-a<s-o?a:s},i.offset=function(o,a){return t(o=new Date(+o),a==null?1:Math.floor(a)),o},i.range=function(o,a,s){var l=[],c;if(o=i.ceil(o),s=s==null?1:Math.floor(s),!(o<a)||!(s>0))return l;do l.push(c=new Date(+o)),t(o,s),e(o);while(c<o&&o<a);return l},i.filter=function(o){return Sr(function(a){if(a>=a)for(;e(a),!o(a);)a.setTime(a-1)},function(a,s){if(a>=a)if(s<0)for(;++s<=0;)for(;t(a,-1),!o(a););else for(;--s>=0;)for(;t(a,1),!o(a););})},r&&(i.count=function(o,a){return Ket.setTime(+o),Zet.setTime(+a),e(Ket),e(Zet),Math.floor(r(Ket,Zet))},i.every=function(o){return o=Math.floor(o),!isFinite(o)||!(o>0)?null:o>1?i.filter(n?function(a){return n(a)%o===0}:function(a){return i.count(0,a)%o===0}):i}),i}var Ket,Zet,fa=M(()=>{Ket=new Date,Zet=new Date});var O7,Jet,Qet,NBt=M(()=>{fa();O7=Sr(function(){},function(e,t){e.setTime(+e+t)},function(e,t){return t-e});O7.every=function(e){return e=Math.floor(e),!isFinite(e)||!(e>0)?null:e>1?Sr(function(t){t.setTime(Math.floor(t/e)*e)},function(t,r){t.setTime(+t+r*e)},function(t,r){return(r-t)/e}):O7};Jet=O7,Qet=O7.range});var FC,Ps,bf,z7,F7,wf=M(()=>{FC=1e3,Ps=6e4,bf=36e5,z7=864e5,F7=6048e5});var DBt,trt,ert,OBt=M(()=>{fa();wf();DBt=Sr(function(e){e.setTime(Math.floor(e/FC)*FC)},function(e,t){e.setTime(+e+t*FC)},function(e,t){return(t-e)/FC},function(e){return e.getUTCSeconds()}),trt=DBt,ert=DBt.range});var zBt,FBt,BBt,HBt=M(()=>{fa();wf();zBt=Sr(function(e){e.setTime(Math.floor(e/Ps)*Ps)},function(e,t){e.setTime(+e+t*Ps)},function(e,t){return(t-e)/Ps},function(e){return e.getMinutes()}),FBt=zBt,BBt=zBt.range});var VBt,UBt,qBt,GBt=M(()=>{fa();wf();VBt=Sr(function(e){var t=e.getTimezoneOffset()*Ps%bf;t<0&&(t+=bf),e.setTime(Math.floor((+e-t)/bf)*bf+t)},function(e,t){e.setTime(+e+t*bf)},function(e,t){return(t-e)/bf},function(e){return e.getHours()}),UBt=VBt,qBt=VBt.range});var WBt,YBt,jBt,XBt=M(()=>{fa();wf();WBt=Sr(function(e){e.setHours(0,0,0,0)},function(e,t){e.setDate(e.getDate()+t)},function(e,t){return(t-e-(t.getTimezoneOffset()-e.getTimezoneOffset())*Ps)/z7},function(e){return e.getDate()-1}),YBt=WBt,jBt=WBt.range});function p1(e){return Sr(function(t){t.setDate(t.getDate()-(t.getDay()+7-e)%7),t.setHours(0,0,0,0)},function(t,r){t.setDate(t.getDate()+r*7)},function(t,r){return(r-t-(r.getTimezoneOffset()-t.getTimezoneOffset())*Ps)/F7})}var B7,rrt,nrt,irt,ort,art,srt,lrt,$Bt,KBt,ZBt,JBt,QBt,tHt,eHt=M(()=>{fa();wf();B7=p1(0),rrt=p1(1),nrt=p1(2),irt=p1(3),ort=p1(4),art=p1(5),srt=p1(6),lrt=B7.range,$Bt=rrt.range,KBt=nrt.range,ZBt=irt.range,JBt=ort.range,QBt=art.range,tHt=srt.range});var rHt,nHt,iHt,oHt=M(()=>{fa();rHt=Sr(function(e){e.setDate(1),e.setHours(0,0,0,0)},function(e,t){e.setMonth(e.getMonth()+t)},function(e,t){return t.getMonth()-e.getMonth()+(t.getFullYear()-e.getFullYear())*12},function(e){return e.getMonth()}),nHt=rHt,iHt=rHt.range});var crt,aHt,sHt,lHt=M(()=>{fa();crt=Sr(function(e){e.setMonth(0,1),e.setHours(0,0,0,0)},function(e,t){e.setFullYear(e.getFullYear()+t)},function(e,t){return t.getFullYear()-e.getFullYear()},function(e){return e.getFullYear()});crt.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:Sr(function(t){t.setFullYear(Math.floor(t.getFullYear()/e)*e),t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,r){t.setFullYear(t.getFullYear()+r*e)})};aHt=crt,sHt=crt.range});var cHt,uHt,hHt,fHt=M(()=>{fa();wf();cHt=Sr(function(e){e.setUTCSeconds(0,0)},function(e,t){e.setTime(+e+t*Ps)},function(e,t){return(t-e)/Ps},function(e){return e.getUTCMinutes()}),uHt=cHt,hHt=cHt.range});var pHt,dHt,mHt,gHt=M(()=>{fa();wf();pHt=Sr(function(e){e.setUTCMinutes(0,0,0)},function(e,t){e.setTime(+e+t*bf)},function(e,t){return(t-e)/bf},function(e){return e.getUTCHours()}),dHt=pHt,mHt=pHt.range});var _Ht,yHt,vHt,xHt=M(()=>{fa();wf();_Ht=Sr(function(e){e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCDate(e.getUTCDate()+t)},function(e,t){return(t-e)/z7},function(e){return e.getUTCDate()-1}),yHt=_Ht,vHt=_Ht.range});function d1(e){return Sr(function(t){t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-e)%7),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCDate(t.getUTCDate()+r*7)},function(t,r){return(r-t)/F7})}var H7,urt,hrt,frt,prt,drt,mrt,grt,bHt,wHt,SHt,MHt,EHt,THt,CHt=M(()=>{fa();wf();H7=d1(0),urt=d1(1),hrt=d1(2),frt=d1(3),prt=d1(4),drt=d1(5),mrt=d1(6),grt=H7.range,bHt=urt.range,wHt=hrt.range,SHt=frt.range,MHt=prt.range,EHt=drt.range,THt=mrt.range});var AHt,PHt,IHt,LHt=M(()=>{fa();AHt=Sr(function(e){e.setUTCDate(1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCMonth(e.getUTCMonth()+t)},function(e,t){return t.getUTCMonth()-e.getUTCMonth()+(t.getUTCFullYear()-e.getUTCFullYear())*12},function(e){return e.getUTCMonth()}),PHt=AHt,IHt=AHt.range});var _rt,kHt,RHt,NHt=M(()=>{fa();_rt=Sr(function(e){e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCFullYear(e.getUTCFullYear()+t)},function(e,t){return t.getUTCFullYear()-e.getUTCFullYear()},function(e){return e.getUTCFullYear()});_rt.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:Sr(function(t){t.setUTCFullYear(Math.floor(t.getUTCFullYear()/e)*e),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCFullYear(t.getUTCFullYear()+r*e)})};kHt=_rt,RHt=_rt.range});var DHt=M(()=>{fa();NBt();OBt();HBt();GBt();XBt();eHt();oHt();lHt();fHt();gHt();xHt();CHt();LHt();NHt()});function pa(e,t,r,n){function i(o){return e(o=arguments.length===0?new Date:new Date(+o)),o}return i.floor=function(o){return e(o=new Date(+o)),o},i.ceil=function(o){return e(o=new Date(o-1)),t(o,1),e(o),o},i.round=function(o){var a=i(o),s=i.ceil(o);return o-a<s-o?a:s},i.offset=function(o,a){return t(o=new Date(+o),a==null?1:Math.floor(a)),o},i.range=function(o,a,s){var l=[],c;if(o=i.ceil(o),s=s==null?1:Math.floor(s),!(o<a)||!(s>0))return l;do l.push(c=new Date(+o)),t(o,s),e(o);while(c<o&&o<a);return l},i.filter=function(o){return pa(function(a){if(a>=a)for(;e(a),!o(a);)a.setTime(a-1)},function(a,s){if(a>=a)if(s<0)for(;++s<=0;)for(;t(a,-1),!o(a););else for(;--s>=0;)for(;t(a,1),!o(a););})},r&&(i.count=function(o,a){return yrt.setTime(+o),vrt.setTime(+a),e(yrt),e(vrt),Math.floor(r(yrt,vrt))},i.every=function(o){return o=Math.floor(o),!isFinite(o)||!(o>0)?null:o>1?i.filter(n?function(a){return n(a)%o===0}:function(a){return i.count(0,a)%o===0}):i}),i}var yrt,vrt,m1=M(()=>{yrt=new Date,vrt=new Date});var V7,U7,q7,BC=M(()=>{V7=6e4,U7=864e5,q7=6048e5});var OHt,G7,ALe,zHt=M(()=>{m1();BC();OHt=pa(function(e){e.setHours(0,0,0,0)},function(e,t){e.setDate(e.getDate()+t)},function(e,t){return(t-e-(t.getTimezoneOffset()-e.getTimezoneOffset())*V7)/U7},function(e){return e.getDate()-1}),G7=OHt,ALe=OHt.range});function g1(e){return pa(function(t){t.setDate(t.getDate()-(t.getDay()+7-e)%7),t.setHours(0,0,0,0)},function(t,r){t.setDate(t.getDate()+r*7)},function(t,r){return(r-t-(r.getTimezoneOffset()-t.getTimezoneOffset())*V7)/q7})}var HC,Hw,FHt,BHt,Vw,HHt,VHt,UHt,PLe,ILe,LLe,kLe,RLe,NLe,qHt=M(()=>{m1();BC();HC=g1(0),Hw=g1(1),FHt=g1(2),BHt=g1(3),Vw=g1(4),HHt=g1(5),VHt=g1(6),UHt=HC.range,PLe=Hw.range,ILe=FHt.range,LLe=BHt.range,kLe=Vw.range,RLe=HHt.range,NLe=VHt.range});var xrt,_1,DLe,GHt=M(()=>{m1();xrt=pa(function(e){e.setMonth(0,1),e.setHours(0,0,0,0)},function(e,t){e.setFullYear(e.getFullYear()+t)},function(e,t){return t.getFullYear()-e.getFullYear()},function(e){return e.getFullYear()});xrt.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:pa(function(t){t.setFullYear(Math.floor(t.getFullYear()/e)*e),t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,r){t.setFullYear(t.getFullYear()+r*e)})};_1=xrt,DLe=xrt.range});var WHt,W7,OLe,YHt=M(()=>{m1();BC();WHt=pa(function(e){e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCDate(e.getUTCDate()+t)},function(e,t){return(t-e)/U7},function(e){return e.getUTCDate()-1}),W7=WHt,OLe=WHt.range});function y1(e){return pa(function(t){t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-e)%7),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCDate(t.getUTCDate()+r*7)},function(t,r){return(r-t)/q7})}var VC,Uw,jHt,XHt,qw,$Ht,KHt,ZHt,zLe,FLe,BLe,HLe,VLe,ULe,JHt=M(()=>{m1();BC();VC=y1(0),Uw=y1(1),jHt=y1(2),XHt=y1(3),qw=y1(4),$Ht=y1(5),KHt=y1(6),ZHt=VC.range,zLe=Uw.range,FLe=jHt.range,BLe=XHt.range,HLe=qw.range,VLe=$Ht.range,ULe=KHt.range});var brt,v1,qLe,QHt=M(()=>{m1();brt=pa(function(e){e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCFullYear(e.getUTCFullYear()+t)},function(e,t){return t.getUTCFullYear()-e.getUTCFullYear()},function(e){return e.getUTCFullYear()});brt.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:pa(function(t){t.setUTCFullYear(Math.floor(t.getUTCFullYear()/e)*e),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCFullYear(t.getUTCFullYear()+r*e)})};v1=brt,qLe=brt.range});var tVt=M(()=>{zHt();qHt();GHt();YHt();JHt();QHt()});function GLe(e){if(0<=e.y&&e.y<100){var t=new Date(-1,e.m,e.d,e.H,e.M,e.S,e.L);return t.setFullYear(e.y),t}return new Date(e.y,e.m,e.d,e.H,e.M,e.S,e.L)}function Y7(e){if(0<=e.y&&e.y<100){var t=new Date(Date.UTC(-1,e.m,e.d,e.H,e.M,e.S,e.L));return t.setUTCFullYear(e.y),t}return new Date(Date.UTC(e.y,e.m,e.d,e.H,e.M,e.S,e.L))}function UC(e){return{y:e,m:0,d:1,H:0,M:0,S:0,L:0}}function WC(e){var t=e.dateTime,r=e.date,n=e.time,i=e.periods,o=e.days,a=e.shortDays,s=e.months,l=e.shortMonths,c=qC(i),u=GC(i),h=qC(o),f=GC(o),p=qC(a),d=GC(a),g=qC(s),_=GC(s),y=qC(l),x=GC(l),b={a:W,A:Z,b:rt,B:ot,c:null,d:iVt,e:iVt,f:dke,H:hke,I:fke,j:pke,L:cVt,m:mke,M:gke,p:st,Q:sVt,s:lVt,S:_ke,u:yke,U:vke,V:xke,w:bke,W:wke,x:null,X:null,y:Ske,Y:Mke,Z:Eke,"%":aVt},S={a:St,A:bt,b:Mt,B:lt,c:null,d:oVt,e:oVt,f:Pke,H:Tke,I:Cke,j:Ake,L:uVt,m:Ike,M:Lke,p:Kt,Q:sVt,s:lVt,S:kke,u:Rke,U:Nke,V:Dke,w:Oke,W:zke,x:null,X:null,y:Fke,Y:Bke,Z:Hke,"%":aVt},C={a:B,A:I,b:L,B:R,c:F,d:rVt,e:rVt,f:ske,H:nVt,I:nVt,j:nke,L:ake,m:rke,M:ike,p:D,Q:cke,s:uke,S:oke,u:$Le,U:KLe,V:ZLe,w:XLe,W:JLe,x:z,X:U,y:tke,Y:QLe,Z:eke,"%":lke};b.x=P(r,b),b.X=P(n,b),b.c=P(t,b),S.x=P(r,S),S.X=P(n,S),S.c=P(t,S);function P(_t,ct){return function(X){var et=[],dt=-1,q=0,pt=_t.length,ht,wt,kt;for(X instanceof Date||(X=new Date(+X));++dt<pt;)_t.charCodeAt(dt)===37&&(et.push(_t.slice(q,dt)),(wt=eVt[ht=_t.charAt(++dt)])!=null?ht=_t.charAt(++dt):wt=ht==="e"?" ":"0",(kt=ct[ht])&&(ht=kt(X,wt)),et.push(ht),q=dt+1);return et.push(_t.slice(q,dt)),et.join("")}}function k(_t,ct){return function(X){var et=UC(1900),dt=O(et,_t,X+="",0),q,pt;if(dt!=X.length)return null;if("Q"in et)return new Date(et.Q);if("p"in et&&(et.H=et.H%12+et.p*12),"V"in et){if(et.V<1||et.V>53)return null;"w"in et||(et.w=1),"Z"in et?(q=Y7(UC(et.y)),pt=q.getUTCDay(),q=pt>4||pt===0?Uw.ceil(q):Uw(q),q=W7.offset(q,(et.V-1)*7),et.y=q.getUTCFullYear(),et.m=q.getUTCMonth(),et.d=q.getUTCDate()+(et.w+6)%7):(q=ct(UC(et.y)),pt=q.getDay(),q=pt>4||pt===0?Hw.ceil(q):Hw(q),q=G7.offset(q,(et.V-1)*7),et.y=q.getFullYear(),et.m=q.getMonth(),et.d=q.getDate()+(et.w+6)%7)}else("W"in et||"U"in et)&&("w"in et||(et.w="u"in et?et.u%7:"W"in et?1:0),pt="Z"in et?Y7(UC(et.y)).getUTCDay():ct(UC(et.y)).getDay(),et.m=0,et.d="W"in et?(et.w+6)%7+et.W*7-(pt+5)%7:et.w+et.U*7-(pt+6)%7);return"Z"in et?(et.H+=et.Z/100|0,et.M+=et.Z%100,Y7(et)):ct(et)}}function O(_t,ct,X,et){for(var dt=0,q=ct.length,pt=X.length,ht,wt;dt<q;){if(et>=pt)return-1;if(ht=ct.charCodeAt(dt++),ht===37){if(ht=ct.charAt(dt++),wt=C[ht in eVt?ct.charAt(dt++):ht],!wt||(et=wt(_t,X,et))<0)return-1}else if(ht!=X.charCodeAt(et++))return-1}return et}function D(_t,ct,X){var et=c.exec(ct.slice(X));return et?(_t.p=u[et[0].toLowerCase()],X+et[0].length):-1}function B(_t,ct,X){var et=p.exec(ct.slice(X));return et?(_t.w=d[et[0].toLowerCase()],X+et[0].length):-1}function I(_t,ct,X){var et=h.exec(ct.slice(X));return et?(_t.w=f[et[0].toLowerCase()],X+et[0].length):-1}function L(_t,ct,X){var et=y.exec(ct.slice(X));return et?(_t.m=x[et[0].toLowerCase()],X+et[0].length):-1}function R(_t,ct,X){var et=g.exec(ct.slice(X));return et?(_t.m=_[et[0].toLowerCase()],X+et[0].length):-1}function F(_t,ct,X){return O(_t,t,ct,X)}function z(_t,ct,X){return O(_t,r,ct,X)}function U(_t,ct,X){return O(_t,n,ct,X)}function W(_t){return a[_t.getDay()]}function Z(_t){return o[_t.getDay()]}function rt(_t){return l[_t.getMonth()]}function ot(_t){return s[_t.getMonth()]}function st(_t){return i[+(_t.getHours()>=12)]}function St(_t){return a[_t.getUTCDay()]}function bt(_t){return o[_t.getUTCDay()]}function Mt(_t){return l[_t.getUTCMonth()]}function lt(_t){return s[_t.getUTCMonth()]}function Kt(_t){return i[+(_t.getUTCHours()>=12)]}return{format:function(_t){var ct=P(_t+="",b);return ct.toString=function(){return _t},ct},parse:function(_t){var ct=k(_t+="",GLe);return ct.toString=function(){return _t},ct},utcFormat:function(_t){var ct=P(_t+="",S);return ct.toString=function(){return _t},ct},utcParse:function(_t){var ct=k(_t,Y7);return ct.toString=function(){return _t},ct}}}function gn(e,t,r){var n=e<0?"-":"",i=(n?-e:e)+"",o=i.length;return n+(o<r?new Array(r-o+1).join(t)+i:i)}function jLe(e){return e.replace(YLe,"\\$&")}function qC(e){return new RegExp("^(?:"+e.map(jLe).join("|")+")","i")}function GC(e){for(var t={},r=-1,n=e.length;++r<n;)t[e[r].toLowerCase()]=r;return t}function XLe(e,t,r){var n=Vo.exec(t.slice(r,r+1));return n?(e.w=+n[0],r+n[0].length):-1}function $Le(e,t,r){var n=Vo.exec(t.slice(r,r+1));return n?(e.u=+n[0],r+n[0].length):-1}function KLe(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.U=+n[0],r+n[0].length):-1}function ZLe(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.V=+n[0],r+n[0].length):-1}function JLe(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.W=+n[0],r+n[0].length):-1}function QLe(e,t,r){var n=Vo.exec(t.slice(r,r+4));return n?(e.y=+n[0],r+n[0].length):-1}function tke(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.y=+n[0]+(+n[0]>68?1900:2e3),r+n[0].length):-1}function eke(e,t,r){var n=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(t.slice(r,r+6));return n?(e.Z=n[1]?0:-(n[2]+(n[3]||"00")),r+n[0].length):-1}function rke(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.m=n[0]-1,r+n[0].length):-1}function rVt(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.d=+n[0],r+n[0].length):-1}function nke(e,t,r){var n=Vo.exec(t.slice(r,r+3));return n?(e.m=0,e.d=+n[0],r+n[0].length):-1}function nVt(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.H=+n[0],r+n[0].length):-1}function ike(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.M=+n[0],r+n[0].length):-1}function oke(e,t,r){var n=Vo.exec(t.slice(r,r+2));return n?(e.S=+n[0],r+n[0].length):-1}function ake(e,t,r){var n=Vo.exec(t.slice(r,r+3));return n?(e.L=+n[0],r+n[0].length):-1}function ske(e,t,r){var n=Vo.exec(t.slice(r,r+6));return n?(e.L=Math.floor(n[0]/1e3),r+n[0].length):-1}function lke(e,t,r){var n=WLe.exec(t.slice(r,r+1));return n?r+n[0].length:-1}function cke(e,t,r){var n=Vo.exec(t.slice(r));return n?(e.Q=+n[0],r+n[0].length):-1}function uke(e,t,r){var n=Vo.exec(t.slice(r));return n?(e.Q=+n[0]*1e3,r+n[0].length):-1}function iVt(e,t){return gn(e.getDate(),t,2)}function hke(e,t){return gn(e.getHours(),t,2)}function fke(e,t){return gn(e.getHours()%12||12,t,2)}function pke(e,t){return gn(1+G7.count(_1(e),e),t,3)}function cVt(e,t){return gn(e.getMilliseconds(),t,3)}function dke(e,t){return cVt(e,t)+"000"}function mke(e,t){return gn(e.getMonth()+1,t,2)}function gke(e,t){return gn(e.getMinutes(),t,2)}function _ke(e,t){return gn(e.getSeconds(),t,2)}function yke(e){var t=e.getDay();return t===0?7:t}function vke(e,t){return gn(HC.count(_1(e),e),t,2)}function xke(e,t){var r=e.getDay();return e=r>=4||r===0?Vw(e):Vw.ceil(e),gn(Vw.count(_1(e),e)+(_1(e).getDay()===4),t,2)}function bke(e){return e.getDay()}function wke(e,t){return gn(Hw.count(_1(e),e),t,2)}function Ske(e,t){return gn(e.getFullYear()%100,t,2)}function Mke(e,t){return gn(e.getFullYear()%1e4,t,4)}function Eke(e){var t=e.getTimezoneOffset();return(t>0?"-":(t*=-1,"+"))+gn(t/60|0,"0",2)+gn(t%60,"0",2)}function oVt(e,t){return gn(e.getUTCDate(),t,2)}function Tke(e,t){return gn(e.getUTCHours(),t,2)}function Cke(e,t){return gn(e.getUTCHours()%12||12,t,2)}function Ake(e,t){return gn(1+W7.count(v1(e),e),t,3)}function uVt(e,t){return gn(e.getUTCMilliseconds(),t,3)}function Pke(e,t){return uVt(e,t)+"000"}function Ike(e,t){return gn(e.getUTCMonth()+1,t,2)}function Lke(e,t){return gn(e.getUTCMinutes(),t,2)}function kke(e,t){return gn(e.getUTCSeconds(),t,2)}function Rke(e){var t=e.getUTCDay();return t===0?7:t}function Nke(e,t){return gn(VC.count(v1(e),e),t,2)}function Dke(e,t){var r=e.getUTCDay();return e=r>=4||r===0?qw(e):qw.ceil(e),gn(qw.count(v1(e),e)+(v1(e).getUTCDay()===4),t,2)}function Oke(e){return e.getUTCDay()}function zke(e,t){return gn(Uw.count(v1(e),e),t,2)}function Fke(e,t){return gn(e.getUTCFullYear()%100,t,2)}function Bke(e,t){return gn(e.getUTCFullYear()%1e4,t,4)}function Hke(){return"+0000"}function aVt(){return"%"}function sVt(e){return+e}function lVt(e){return Math.floor(+e/1e3)}var eVt,Vo,WLe,YLe,wrt=M(()=>{tVt();eVt={"-":"",_:" ",0:"0"},Vo=/^\s*\d+/,WLe=/^%/,YLe=/[\\^$*+?|[\]().{}]/g});function j7(e){return Gw=WC(e),Srt=Gw.format,Mrt=Gw.parse,YC=Gw.utcFormat,jC=Gw.utcParse,Gw}var Gw,Srt,Mrt,YC,jC,X7=M(()=>{wrt();j7({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]})});function Vke(e){return e.toISOString()}var Ert,Uke,hVt,Trt=M(()=>{X7();Ert="%Y-%m-%dT%H:%M:%S.%LZ";Uke=Date.prototype.toISOString?Vke:YC(Ert),hVt=Uke});function qke(e){var t=new Date(e);return isNaN(t)?null:t}var Gke,fVt,pVt=M(()=>{Trt();X7();Gke=+new Date("2000-01-01T00:00:00.000Z")?qke:jC(Ert),fVt=Gke});var dVt=M(()=>{X7();wrt();Trt();pVt()});function Yw(){return x1||(_Vt(Wke),x1=ZC.now()+Z7)}function Wke(){x1=0}function b1(){this._call=this._time=this._next=null}function Art(e,t,r){var n=new b1;return n.restart(e,t,r),n}function Prt(){Yw(),++Ww;for(var e=$7,t;e;)(t=x1-e._time)>=0&&e._call.call(null,t),e=e._next;--Ww}function mVt(){x1=(K7=ZC.now())+Z7,Ww=$C=0;try{Prt()}finally{Ww=0,jke(),x1=0}}function Yke(){var e=ZC.now(),t=e-K7;t>gVt&&(Z7-=t,K7=e)}function jke(){for(var e,t=$7,r,n=1/0;t;)t._call?(n>t._time&&(n=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:$7=r);KC=e,Crt(n)}function Crt(e){if(!Ww){$C&&($C=clearTimeout($C));var t=e-x1;t>24?(e<1/0&&($C=setTimeout(mVt,e-ZC.now()-Z7)),XC&&(XC=clearInterval(XC))):(XC||(K7=ZC.now(),XC=setInterval(Yke,gVt)),Ww=1,_Vt(mVt))}}var Ww,$C,XC,gVt,$7,KC,K7,x1,Z7,ZC,_Vt,J7=M(()=>{Ww=0,$C=0,XC=0,gVt=1e3,K7=0,x1=0,Z7=0,ZC=typeof performance=="object"&&performance.now?performance:Date,_Vt=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};b1.prototype=Art.prototype={constructor:b1,restart:function(e,t,r){if(typeof e!="function")throw new TypeError("callback is not a function");r=(r==null?Yw():+r)+(t==null?0:+t),!this._next&&KC!==this&&(KC?KC._next=this:$7=this,KC=this),this._call=e,this._time=r,Crt()},stop:function(){this._call&&(this._call=null,this._time=1/0,Crt())}}});function yVt(e,t,r){var n=new b1;return t=t==null?0:+t,n.restart(function(i){n.stop(),e(i+t)},t,r),n}var vVt=M(()=>{J7()});function xVt(e,t,r){var n=new b1,i=t;return t==null?(n.restart(e,t,r),n):(t=+t,r=r==null?Yw():+r,n.restart(function o(a){a+=i,n.restart(o,i+=t,r),e(a)},t,r),n)}var bVt=M(()=>{J7()});var wVt=M(()=>{J7();vVt();bVt()});var Q7,Irt,Lrt=M(()=>{Q7="http://www.w3.org/1999/xhtml",Irt={svg:"http://www.w3.org/2000/svg",xhtml:Q7,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"}});function ld(e){var t=e+="",r=t.indexOf(":");return r>=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),Irt.hasOwnProperty(t)?{space:Irt[t],local:e}:e}var tz=M(()=>{Lrt()});function Xke(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===Q7&&t.documentElement.namespaceURI===Q7?t.createElement(e):t.createElementNS(r,e)}}function $ke(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function ez(e){var t=ld(e);return(t.local?$ke:Xke)(t)}var krt=M(()=>{tz();Lrt()});function Kke(){}function w1(e){return e==null?Kke:function(){return this.querySelector(e)}}var rz=M(()=>{});function SVt(e){typeof e!="function"&&(e=w1(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=new Array(a),l,c,u=0;u<a;++u)(l=o[u])&&(c=e.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),s[u]=c);return new no(n,this._parents)}var MVt=M(()=>{Sf();rz()});function Zke(){return[]}function JC(e){return e==null?Zke:function(){return this.querySelectorAll(e)}}var Rrt=M(()=>{});function EVt(e){typeof e!="function"&&(e=JC(e));for(var t=this._groups,r=t.length,n=[],i=[],o=0;o<r;++o)for(var a=t[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&(n.push(e.call(l,l.__data__,c,a)),i.push(l));return new no(n,i)}var TVt=M(()=>{Sf();Rrt()});function QC(e){return function(){return this.matches(e)}}var Nrt=M(()=>{});function CVt(e){typeof e!="function"&&(e=QC(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new no(n,this._parents)}var AVt=M(()=>{Sf();Nrt()});function nz(e){return new Array(e.length)}var Drt=M(()=>{});function PVt(){return new no(this._enter||this._groups.map(nz),this._parents)}function tA(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}var Ort=M(()=>{Drt();Sf();tA.prototype={constructor:tA,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}}});function IVt(e){return function(){return e}}var LVt=M(()=>{});function Jke(e,t,r,n,i,o){for(var a=0,s,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],n[a]=s):r[a]=new tA(e,o[a]);for(;a<l;++a)(s=t[a])&&(i[a]=s)}function Qke(e,t,r,n,i,o,a){var s,l,c={},u=t.length,h=o.length,f=new Array(u),p;for(s=0;s<u;++s)(l=t[s])&&(f[s]=p=kVt+a.call(l,l.__data__,s,t),p in c?i[s]=l:c[p]=l);for(s=0;s<h;++s)p=kVt+a.call(e,o[s],s,o),(l=c[p])?(n[s]=l,l.__data__=o[s],c[p]=null):r[s]=new tA(e,o[s]);for(s=0;s<u;++s)(l=t[s])&&c[f[s]]===l&&(i[s]=l)}function RVt(e,t){if(!e)return p=new Array(this.size()),c=-1,this.each(function(P){p[++c]=P}),p;var r=t?Qke:Jke,n=this._parents,i=this._groups;typeof e!="function"&&(e=IVt(e));for(var o=i.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var u=n[c],h=i[c],f=h.length,p=e.call(u,u&&u.__data__,c,n),d=p.length,g=s[c]=new Array(d),_=a[c]=new Array(d),y=l[c]=new Array(f);r(u,h,g,_,y,p,t);for(var x=0,b=0,S,C;x<d;++x)if(S=g[x]){for(x>=b&&(b=x+1);!(C=_[b])&&++b<d;);S._next=C||null}}return a=new no(a,n),a._enter=s,a._exit=l,a}var kVt,NVt=M(()=>{Sf();Ort();LVt();kVt="$"});function DVt(){return new no(this._exit||this._groups.map(nz),this._parents)}var OVt=M(()=>{Drt();Sf()});function zVt(e,t,r){var n=this.enter(),i=this,o=this.exit();return n=typeof e=="function"?e(n):n.append(e+""),t!=null&&(i=t(i)),r==null?o.remove():r(o),n&&i?n.merge(i).order():i}var FVt=M(()=>{});function BVt(e){for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new no(a,this._parents)}var HVt=M(()=>{Sf()});function VVt(){for(var e=this._groups,t=-1,r=e.length;++t<r;)for(var n=e[t],i=n.length-1,o=n[i],a;--i>=0;)(a=n[i])&&(o&&a.compareDocumentPosition(o)^4&&o.parentNode.insertBefore(a,o),o=a);return this}var UVt=M(()=>{});function qVt(e){e||(e=t8e);function t(h,f){return h&&f?e(h.__data__,f.__data__):!h-!f}for(var r=this._groups,n=r.length,i=new Array(n),o=0;o<n;++o){for(var a=r[o],s=a.length,l=i[o]=new Array(s),c,u=0;u<s;++u)(c=a[u])&&(l[u]=c);l.sort(t)}return new no(i,this._parents).order()}function t8e(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var GVt=M(()=>{Sf()});function WVt(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}var YVt=M(()=>{});function jVt(){var e=new Array(this.size()),t=-1;return this.each(function(){e[++t]=this}),e}var XVt=M(()=>{});function $Vt(){for(var e=this._groups,t=0,r=e.length;t<r;++t)for(var n=e[t],i=0,o=n.length;i<o;++i){var a=n[i];if(a)return a}return null}var KVt=M(()=>{});function ZVt(){var e=0;return this.each(function(){++e}),e}var JVt=M(()=>{});function QVt(){return!this.node()}var tUt=M(()=>{});function eUt(e){for(var t=this._groups,r=0,n=t.length;r<n;++r)for(var i=t[r],o=0,a=i.length,s;o<a;++o)(s=i[o])&&e.call(s,s.__data__,o,i);return this}var rUt=M(()=>{});function e8e(e){return function(){this.removeAttribute(e)}}function r8e(e){return function(){this.removeAttributeNS(e.space,e.local)}}function n8e(e,t){return function(){this.setAttribute(e,t)}}function i8e(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function o8e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttribute(e):this.setAttribute(e,r)}}function a8e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,r)}}function nUt(e,t){var r=ld(e);if(arguments.length<2){var n=this.node();return r.local?n.getAttributeNS(r.space,r.local):n.getAttribute(r)}return this.each((t==null?r.local?r8e:e8e:typeof t=="function"?r.local?a8e:o8e:r.local?i8e:n8e)(r,t))}var iUt=M(()=>{tz()});function iz(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}var zrt=M(()=>{});function s8e(e){return function(){this.style.removeProperty(e)}}function l8e(e,t,r){return function(){this.style.setProperty(e,t,r)}}function c8e(e,t,r){return function(){var n=t.apply(this,arguments);n==null?this.style.removeProperty(e):this.style.setProperty(e,n,r)}}function oUt(e,t,r){return arguments.length>1?this.each((t==null?s8e:typeof t=="function"?c8e:l8e)(e,t,r==null?"":r)):Bg(this.node(),e)}function Bg(e,t){return e.style.getPropertyValue(t)||iz(e).getComputedStyle(e,null).getPropertyValue(t)}var Frt=M(()=>{zrt()});function u8e(e){return function(){delete this[e]}}function h8e(e,t){return function(){this[e]=t}}function f8e(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function aUt(e,t){return arguments.length>1?this.each((t==null?u8e:typeof t=="function"?f8e:h8e)(e,t)):this.node()[e]}var sUt=M(()=>{});function lUt(e){return e.trim().split(/^|\s+/)}function Brt(e){return e.classList||new cUt(e)}function cUt(e){this._node=e,this._names=lUt(e.getAttribute("class")||"")}function uUt(e,t){for(var r=Brt(e),n=-1,i=t.length;++n<i;)r.add(t[n])}function hUt(e,t){for(var r=Brt(e),n=-1,i=t.length;++n<i;)r.remove(t[n])}function p8e(e){return function(){uUt(this,e)}}function d8e(e){return function(){hUt(this,e)}}function m8e(e,t){return function(){(t.apply(this,arguments)?uUt:hUt)(this,e)}}function fUt(e,t){var r=lUt(e+"");if(arguments.length<2){for(var n=Brt(this.node()),i=-1,o=r.length;++i<o;)if(!n.contains(r[i]))return!1;return!0}return this.each((typeof t=="function"?m8e:t?p8e:d8e)(r,t))}var pUt=M(()=>{cUt.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}}});function g8e(){this.textContent=""}function _8e(e){return function(){this.textContent=e}}function y8e(e){return function(){var t=e.apply(this,arguments);this.textContent=t==null?"":t}}function dUt(e){return arguments.length?this.each(e==null?g8e:(typeof e=="function"?y8e:_8e)(e)):this.node().textContent}var mUt=M(()=>{});function v8e(){this.innerHTML=""}function x8e(e){return function(){this.innerHTML=e}}function b8e(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t==null?"":t}}function gUt(e){return arguments.length?this.each(e==null?v8e:(typeof e=="function"?b8e:x8e)(e)):this.node().innerHTML}var _Ut=M(()=>{});function w8e(){this.nextSibling&&this.parentNode.appendChild(this)}function yUt(){return this.each(w8e)}var vUt=M(()=>{});function S8e(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function xUt(){return this.each(S8e)}var bUt=M(()=>{});function wUt(e){var t=typeof e=="function"?e:ez(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}var SUt=M(()=>{krt()});function M8e(){return null}function MUt(e,t){var r=typeof e=="function"?e:ez(e),n=t==null?M8e:typeof t=="function"?t:w1(t);return this.select(function(){return this.insertBefore(r.apply(this,arguments),n.apply(this,arguments)||null)})}var EUt=M(()=>{krt();rz()});function E8e(){var e=this.parentNode;e&&e.removeChild(this)}function TUt(){return this.each(E8e)}var CUt=M(()=>{});function T8e(){var e=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function C8e(){var e=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function AUt(e){return this.select(e?C8e:T8e)}var PUt=M(()=>{});function IUt(e){return arguments.length?this.property("__data__",e):this.node().__data__}var LUt=M(()=>{});function A8e(e,t,r){return e=NUt(e,t,r),function(n){var i=n.relatedTarget;(!i||i!==this&&!(i.compareDocumentPosition(this)&8))&&e.call(this,n)}}function NUt(e,t,r){return function(n){var i=Hrt;Hrt=n;try{e.call(this,this.__data__,t,r)}finally{Hrt=i}}}function P8e(e){return e.trim().split(/^|\s+/).map(function(t){var r="",n=t.indexOf(".");return n>=0&&(r=t.slice(n+1),t=t.slice(0,n)),{type:t,name:r}})}function I8e(e){return function(){var t=this.__on;if(!!t){for(var r=0,n=-1,i=t.length,o;r<i;++r)o=t[r],(!e.type||o.type===e.type)&&o.name===e.name?this.removeEventListener(o.type,o.listener,o.capture):t[++n]=o;++n?t.length=n:delete this.__on}}}function L8e(e,t,r){var n=RUt.hasOwnProperty(e.type)?A8e:NUt;return function(i,o,a){var s=this.__on,l,c=n(t,o,a);if(s){for(var u=0,h=s.length;u<h;++u)if((l=s[u]).type===e.type&&l.name===e.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=r),l.value=t;return}}this.addEventListener(e.type,c,r),l={type:e.type,name:e.name,value:t,listener:c,capture:r},s?s.push(l):this.__on=[l]}}function DUt(e,t,r){var n=P8e(e+""),i,o=n.length,a;if(arguments.length<2){var s=this.node().__on;if(s){for(var l=0,c=s.length,u;l<c;++l)for(i=0,u=s[l];i<o;++i)if((a=n[i]).type===u.type&&a.name===u.name)return u.value}return}for(s=t?L8e:I8e,r==null&&(r=!1),i=0;i<o;++i)this.each(s(n[i],t,r));return this}var RUt,Hrt,kUt,OUt=M(()=>{RUt={},Hrt=null;typeof document!="undefined"&&(kUt=document.documentElement,"onmouseenter"in kUt||(RUt={mouseenter:"mouseover",mouseleave:"mouseout"}))});function zUt(e,t,r){var n=iz(e),i=n.CustomEvent;typeof i=="function"?i=new i(t,r):(i=n.document.createEvent("Event"),r?(i.initEvent(t,r.bubbles,r.cancelable),i.detail=r.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function k8e(e,t){return function(){return zUt(this,e,t)}}function R8e(e,t){return function(){return zUt(this,e,t.apply(this,arguments))}}function FUt(e,t){return this.each((typeof t=="function"?R8e:k8e)(e,t))}var BUt=M(()=>{zrt()});function no(e,t){this._groups=e,this._parents=t}function HUt(){return new no([[document.documentElement]],N8e)}var N8e,cd,Sf=M(()=>{MVt();TVt();AVt();NVt();Ort();OVt();FVt();HVt();UVt();GVt();YVt();XVt();KVt();JVt();tUt();rUt();iUt();Frt();sUt();pUt();mUt();_Ut();vUt();bUt();SUt();EUt();CUt();PUt();LUt();OUt();BUt();N8e=[null];no.prototype=HUt.prototype={constructor:no,select:SVt,selectAll:EVt,filter:CVt,data:RVt,enter:PVt,exit:DVt,join:zVt,merge:BVt,order:VVt,sort:qVt,call:WVt,nodes:jVt,node:$Vt,size:ZVt,empty:QVt,each:eUt,attr:nUt,style:oUt,property:aUt,classed:fUt,text:dUt,html:gUt,raise:yUt,lower:xUt,append:wUt,insert:MUt,remove:TUt,clone:AUt,datum:IUt,on:DUt,dispatch:FUt};cd=HUt});var Mf=M(()=>{Nrt();tz();Sf();rz();Rrt();Frt()});function UUt(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r||/[\s.]/.test(n))throw new Error("illegal type: "+n);r[n]=[]}return new oz(r)}function oz(e){this._=e}function O8e(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function z8e(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function VUt(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=D8e,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var D8e,Vrt,qUt=M(()=>{D8e={value:function(){}};oz.prototype=UUt.prototype={constructor:oz,on:function(e,t){var r=this._,n=O8e(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=z8e(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=VUt(r[i],e.name,t);else if(t==null)for(i in r)r[i]=VUt(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new oz(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};Vrt=UUt});var GUt=M(()=>{qUt()});function Xw(){return S1||(jUt(F8e),S1=iA.now()+lz)}function F8e(){S1=0}function oA(){this._call=this._time=this._next=null}function cz(e,t,r){var n=new oA;return n.restart(e,t,r),n}function XUt(){Xw(),++jw;for(var e=az,t;e;)(t=S1-e._time)>=0&&e._call.call(null,t),e=e._next;--jw}function WUt(){S1=(sz=iA.now())+lz,jw=rA=0;try{XUt()}finally{jw=0,H8e(),S1=0}}function B8e(){var e=iA.now(),t=e-sz;t>YUt&&(lz-=t,sz=e)}function H8e(){for(var e,t=az,r,n=1/0;t;)t._call?(n>t._time&&(n=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:az=r);nA=e,Urt(n)}function Urt(e){if(!jw){rA&&(rA=clearTimeout(rA));var t=e-S1;t>24?(e<1/0&&(rA=setTimeout(WUt,e-iA.now()-lz)),eA&&(eA=clearInterval(eA))):(eA||(sz=iA.now(),eA=setInterval(B8e,YUt)),jw=1,jUt(WUt))}}var jw,rA,eA,YUt,az,nA,sz,S1,lz,iA,jUt,qrt=M(()=>{jw=0,rA=0,eA=0,YUt=1e3,sz=0,S1=0,lz=0,iA=typeof performance=="object"&&performance.now?performance:Date,jUt=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};oA.prototype=cz.prototype={constructor:oA,restart:function(e,t,r){if(typeof e!="function")throw new TypeError("callback is not a function");r=(r==null?Xw():+r)+(t==null?0:+t),!this._next&&nA!==this&&(nA?nA._next=this:az=this,nA=this),this._call=e,this._time=r,Urt()},stop:function(){this._call&&(this._call=null,this._time=1/0,Urt())}}});function uz(e,t,r){var n=new oA;return t=t==null?0:+t,n.restart(function(i){n.stop(),e(i+t)},t,r),n}var $Ut=M(()=>{qrt()});var Grt=M(()=>{qrt();$Ut()});function Hg(e,t,r,n,i,o){var a=e.__transition;if(!a)e.__transition={};else if(r in a)return;q8e(e,r,{name:t,index:n,group:i,on:V8e,tween:U8e,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:ZUt})}function lA(e,t){var r=io(e,t);if(r.state>ZUt)throw new Error("too late; already scheduled");return r}function Du(e,t){var r=io(e,t);if(r.state>sA)throw new Error("too late; already started");return r}function io(e,t){var r=e.__transition;if(!r||!(r=r[t]))throw new Error("transition not found");return r}function q8e(e,t,r){var n=e.__transition,i;n[t]=r,r.timer=cz(o,0,r.time);function o(c){r.state=hz,r.timer.restart(a,r.delay,r.time),r.delay<=c&&a(c-r.delay)}function a(c){var u,h,f,p;if(r.state!==hz)return l();for(u in n)if(p=n[u],p.name===r.name){if(p.state===Wrt)return uz(a);p.state===KUt?(p.state=aA,p.timer.stop(),p.on.call("interrupt",e,e.__data__,p.index,p.group),delete n[u]):+u<t&&(p.state=aA,p.timer.stop(),delete n[u])}if(uz(function(){r.state===Wrt&&(r.state=KUt,r.timer.restart(s,r.delay,r.time),s(c))}),r.state=sA,r.on.call("start",e,e.__data__,r.index,r.group),r.state===sA){for(r.state=Wrt,i=new Array(f=r.tween.length),u=0,h=-1;u<f;++u)(p=r.tween[u].value.call(e,e.__data__,r.index,r.group))&&(i[++h]=p);i.length=h+1}}function s(c){for(var u=c<r.duration?r.ease.call(null,c/r.duration):(r.timer.restart(l),r.state=fz,1),h=-1,f=i.length;++h<f;)i[h].call(null,u);r.state===fz&&(r.on.call("end",e,e.__data__,r.index,r.group),l())}function l(){r.state=aA,r.timer.stop(),delete n[t];for(var c in n)return;delete e.__transition}}var V8e,U8e,ZUt,hz,sA,Wrt,KUt,fz,aA,Ac=M(()=>{GUt();Grt();V8e=Vrt("start","end","interrupt"),U8e=[],ZUt=0,hz=1,sA=2,Wrt=3,KUt=4,fz=5,aA=6});function pz(e,t){var r=e.__transition,n,i,o=!0,a;if(!!r){t=t==null?null:t+"";for(a in r){if((n=r[a]).name!==t){o=!1;continue}i=n.state>sA&&n.state<fz,n.state=aA,n.timer.stop(),i&&n.on.call("interrupt",e,e.__data__,n.index,n.group),delete r[a]}o&&delete e.__transition}}var Yrt=M(()=>{Ac()});function JUt(e){return this.each(function(){pz(this,e)})}var QUt=M(()=>{Yrt()});function dz(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function jrt(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}var tqt=M(()=>{});function hA(){}function rqt(){return this.rgb().formatHex()}function Z8e(){return lqt(this).formatHsl()}function nqt(){return this.rgb().formatRgb()}function Vg(e){var t,r;return e=(e+"").trim().toLowerCase(),(t=G8e.exec(e))?(r=t[1].length,t=parseInt(t[1],16),r===6?iqt(t):r===3?new ml(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?mz(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?mz(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=W8e.exec(e))?new ml(t[1],t[2],t[3],1):(t=Y8e.exec(e))?new ml(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=j8e.exec(e))?mz(t[1],t[2],t[3],t[4]):(t=X8e.exec(e))?mz(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=$8e.exec(e))?sqt(t[1],t[2]/100,t[3]/100,1):(t=K8e.exec(e))?sqt(t[1],t[2]/100,t[3]/100,t[4]):eqt.hasOwnProperty(e)?iqt(eqt[e]):e==="transparent"?new ml(NaN,NaN,NaN,0):null}function iqt(e){return new ml(e>>16&255,e>>8&255,e&255,1)}function mz(e,t,r,n){return n<=0&&(e=t=r=NaN),new ml(e,t,r,n)}function J8e(e){return e instanceof hA||(e=Vg(e)),e?(e=e.rgb(),new ml(e.r,e.g,e.b,e.opacity)):new ml}function Kw(e,t,r,n){return arguments.length===1?J8e(e):new ml(e,t,r,n==null?1:n)}function ml(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}function oqt(){return"#"+Xrt(this.r)+Xrt(this.g)+Xrt(this.b)}function aqt(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}function Xrt(e){return e=Math.max(0,Math.min(255,Math.round(e)||0)),(e<16?"0":"")+e.toString(16)}function sqt(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new Ef(e,t,r,n)}function lqt(e){if(e instanceof Ef)return new Ef(e.h,e.s,e.l,e.opacity);if(e instanceof hA||(e=Vg(e)),!e)return new Ef;if(e instanceof Ef)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new Ef(a,s,l,e.opacity)}function cqt(e,t,r,n){return arguments.length===1?lqt(e):new Ef(e,t,r,n==null?1:n)}function Ef(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}function $rt(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var cA,gz,$w,uA,Tf,G8e,W8e,Y8e,j8e,X8e,$8e,K8e,eqt,uqt=M(()=>{tqt();cA=.7,gz=1/cA,$w="\\s*([+-]?\\d+)\\s*",uA="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",Tf="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",G8e=/^#([0-9a-f]{3,8})$/,W8e=new RegExp("^rgb\\("+[$w,$w,$w]+"\\)$"),Y8e=new RegExp("^rgb\\("+[Tf,Tf,Tf]+"\\)$"),j8e=new RegExp("^rgba\\("+[$w,$w,$w,uA]+"\\)$"),X8e=new RegExp("^rgba\\("+[Tf,Tf,Tf,uA]+"\\)$"),$8e=new RegExp("^hsl\\("+[uA,Tf,Tf]+"\\)$"),K8e=new RegExp("^hsla\\("+[uA,Tf,Tf,uA]+"\\)$"),eqt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};dz(hA,Vg,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:rqt,formatHex:rqt,formatHsl:Z8e,formatRgb:nqt,toString:nqt});dz(ml,Kw,jrt(hA,{brighter:function(e){return e=e==null?gz:Math.pow(gz,e),new ml(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?cA:Math.pow(cA,e),new ml(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:oqt,formatHex:oqt,formatRgb:aqt,toString:aqt}));dz(Ef,cqt,jrt(hA,{brighter:function(e){return e=e==null?gz:Math.pow(gz,e),new Ef(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?cA:Math.pow(cA,e),new Ef(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new ml($rt(e>=240?e-240:e+120,i,n),$rt(e,i,n),$rt(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(e===1?")":", "+e+")")}}))});var Krt=M(()=>{uqt()});function Zrt(e,t,r,n,i){var o=e*e,a=o*e;return((1-3*e+3*o-a)*t+(4-6*o+3*a)*r+(1+3*e+3*o-3*a)*n+a*i)/6}function hqt(e){var t=e.length-1;return function(r){var n=r<=0?r=0:r>=1?(r=1,t-1):Math.floor(r*t),i=e[n],o=e[n+1],a=n>0?e[n-1]:2*i-o,s=n<t-1?e[n+2]:2*o-i;return Zrt((r-n/t)*t,a,i,o,s)}}var Jrt=M(()=>{});function fqt(e){var t=e.length;return function(r){var n=Math.floor(((r%=1)<0?++r:r)*t),i=e[(n+t-1)%t],o=e[n%t],a=e[(n+1)%t],s=e[(n+2)%t];return Zrt((r-n/t)*t,i,o,a,s)}}var pqt=M(()=>{Jrt()});function Qrt(e){return function(){return e}}var dqt=M(()=>{});function Q8e(e,t){return function(r){return e+r*t}}function tRe(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function mqt(e){return(e=+e)==1?_z:function(t,r){return r-t?tRe(t,r,e):Qrt(isNaN(t)?r:t)}}function _z(e,t){var r=t-e;return r?Q8e(e,r):Qrt(isNaN(e)?t:e)}var gqt=M(()=>{dqt()});function _qt(e){return function(t){var r=t.length,n=new Array(r),i=new Array(r),o=new Array(r),a,s;for(a=0;a<r;++a)s=Kw(t[a]),n[a]=s.r||0,i[a]=s.g||0,o[a]=s.b||0;return n=e(n),i=e(i),o=e(o),s.opacity=1,function(l){return s.r=n(l),s.g=i(l),s.b=o(l),s+""}}}var yz,eRe,rRe,yqt=M(()=>{Krt();Jrt();pqt();gqt();yz=function e(t){var r=mqt(t);function n(i,o){var a=r((i=Kw(i)).r,(o=Kw(o)).r),s=r(i.g,o.g),l=r(i.b,o.b),c=_z(i.opacity,o.opacity);return function(u){return i.r=a(u),i.g=s(u),i.b=l(u),i.opacity=c(u),i+""}}return n.gamma=e,n}(1);eRe=_qt(hqt),rRe=_qt(fqt)});function Pc(e,t){return e=+e,t=+t,function(r){return e*(1-r)+t*r}}var vz=M(()=>{});function nRe(e){return function(){return e}}function iRe(e){return function(t){return e(t)+""}}function rnt(e,t){var r=ent.lastIndex=tnt.lastIndex=0,n,i,o,a=-1,s=[],l=[];for(e=e+"",t=t+"";(n=ent.exec(e))&&(i=tnt.exec(t));)(o=i.index)>r&&(o=t.slice(r,o),s[a]?s[a]+=o:s[++a]=o),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:Pc(n,i)})),r=tnt.lastIndex;return r<t.length&&(o=t.slice(r),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?iRe(l[0].x):nRe(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)s[(h=l[u]).i]=h.x(c);return s.join("")})}var ent,tnt,vqt=M(()=>{vz();ent=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,tnt=new RegExp(ent.source,"g")});function nnt(e,t,r,n,i,o){var a,s,l;return(a=Math.sqrt(e*e+t*t))&&(e/=a,t/=a),(l=e*r+t*n)&&(r-=e*l,n-=t*l),(s=Math.sqrt(r*r+n*n))&&(r/=s,n/=s,l/=s),e*n<t*r&&(e=-e,t=-t,l=-l,a=-a),{translateX:i,translateY:o,rotate:Math.atan2(t,e)*xqt,skewX:Math.atan(l)*xqt,scaleX:a,scaleY:s}}var xqt,xz,bqt=M(()=>{xqt=180/Math.PI,xz={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1}});function Sqt(e){return e==="none"?xz:(fA||(fA=document.createElement("DIV"),int=document.documentElement,wqt=document.defaultView),fA.style.transform=e,e=wqt.getComputedStyle(int.appendChild(fA),null).getPropertyValue("transform"),int.removeChild(fA),e=e.slice(7,-1).split(","),nnt(+e[0],+e[1],+e[2],+e[3],+e[4],+e[5]))}function Mqt(e){return e==null?xz:(bz||(bz=document.createElementNS("http://www.w3.org/2000/svg","g")),bz.setAttribute("transform",e),(e=bz.transform.baseVal.consolidate())?(e=e.matrix,nnt(e.a,e.b,e.c,e.d,e.e,e.f)):xz)}var fA,int,wqt,bz,Eqt=M(()=>{bqt()});function Tqt(e,t,r,n){function i(c){return c.length?c.pop()+" ":""}function o(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push("translate(",null,t,null,r);d.push({i:g-4,x:Pc(c,h)},{i:g-2,x:Pc(u,f)})}else(h||f)&&p.push("translate("+h+t+f+r)}function a(c,u,h,f){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),f.push({i:h.push(i(h)+"rotate(",null,n)-2,x:Pc(c,u)})):u&&h.push(i(h)+"rotate("+u+n)}function s(c,u,h,f){c!==u?f.push({i:h.push(i(h)+"skewX(",null,n)-2,x:Pc(c,u)}):u&&h.push(i(h)+"skewX("+u+n)}function l(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push(i(p)+"scale(",null,",",null,")");d.push({i:g-4,x:Pc(c,h)},{i:g-2,x:Pc(u,f)})}else(h!==1||f!==1)&&p.push(i(p)+"scale("+h+","+f+")")}return function(c,u){var h=[],f=[];return c=e(c),u=e(u),o(c.translateX,c.translateY,u.translateX,u.translateY,h,f),a(c.rotate,u.rotate,h,f),s(c.skewX,u.skewX,h,f),l(c.scaleX,c.scaleY,u.scaleX,u.scaleY,h,f),c=u=null,function(p){for(var d=-1,g=f.length,_;++d<g;)h[(_=f[d]).i]=_.x(p);return h.join("")}}}var ont,ant,Cqt=M(()=>{vz();Eqt();ont=Tqt(Sqt,"px, ","px)","deg)"),ant=Tqt(Mqt,", ",")",")")});var wz=M(()=>{vz();vqt();Cqt();yqt()});function oRe(e,t){var r,n;return function(){var i=Du(this,e),o=i.tween;if(o!==r){n=r=o;for(var a=0,s=n.length;a<s;++a)if(n[a].name===t){n=n.slice(),n.splice(a,1);break}}i.tween=n}}function aRe(e,t,r){var n,i;if(typeof r!="function")throw new Error;return function(){var o=Du(this,e),a=o.tween;if(a!==n){i=(n=a).slice();for(var s={name:t,value:r},l=0,c=i.length;l<c;++l)if(i[l].name===t){i[l]=s;break}l===c&&i.push(s)}o.tween=i}}function Aqt(e,t){var r=this._id;if(e+="",arguments.length<2){for(var n=io(this.node(),r).tween,i=0,o=n.length,a;i<o;++i)if((a=n[i]).name===e)return a.value;return null}return this.each((t==null?oRe:aRe)(r,e,t))}function Zw(e,t,r){var n=e._id;return e.each(function(){var i=Du(this,n);(i.value||(i.value={}))[t]=r.apply(this,arguments)}),function(i){return io(i,n).value[t]}}var pA=M(()=>{Ac()});function Sz(e,t){var r;return(typeof t=="number"?Pc:t instanceof Vg?yz:(r=Vg(t))?(t=r,yz):rnt)(e,t)}var snt=M(()=>{Krt();wz()});function sRe(e){return function(){this.removeAttribute(e)}}function lRe(e){return function(){this.removeAttributeNS(e.space,e.local)}}function cRe(e,t,r){var n,i;return function(){var o=this.getAttribute(e);return o===r?null:o===n?i:i=t(n=o,r)}}function uRe(e,t,r){var n,i;return function(){var o=this.getAttributeNS(e.space,e.local);return o===r?null:o===n?i:i=t(n=o,r)}}function hRe(e,t,r){var n,i,o;return function(){var a,s=r(this);return s==null?void this.removeAttribute(e):(a=this.getAttribute(e),a===s?null:a===n&&s===i?o:o=t(n=a,i=s))}}function fRe(e,t,r){var n,i,o;return function(){var a,s=r(this);return s==null?void this.removeAttributeNS(e.space,e.local):(a=this.getAttributeNS(e.space,e.local),a===s?null:a===n&&s===i?o:o=t(n=a,i=s))}}function Pqt(e,t){var r=ld(e),n=r==="transform"?ant:Sz;return this.attrTween(e,typeof t=="function"?(r.local?fRe:hRe)(r,n,Zw(this,"attr."+e,t)):t==null?(r.local?lRe:sRe)(r):(r.local?uRe:cRe)(r,n,t+""))}var Iqt=M(()=>{wz();Mf();pA();snt()});function pRe(e,t){function r(){var n=this,i=t.apply(n,arguments);return i&&function(o){n.setAttributeNS(e.space,e.local,i(o))}}return r._value=t,r}function dRe(e,t){function r(){var n=this,i=t.apply(n,arguments);return i&&function(o){n.setAttribute(e,i(o))}}return r._value=t,r}function Lqt(e,t){var r="attr."+e;if(arguments.length<2)return(r=this.tween(r))&&r._value;if(t==null)return this.tween(r,null);if(typeof t!="function")throw new Error;var n=ld(e);return this.tween(r,(n.local?pRe:dRe)(n,t))}var kqt=M(()=>{Mf()});function mRe(e,t){return function(){lA(this,e).delay=+t.apply(this,arguments)}}function gRe(e,t){return t=+t,function(){lA(this,e).delay=t}}function Rqt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?mRe:gRe)(t,e)):io(this.node(),t).delay}var Nqt=M(()=>{Ac()});function _Re(e,t){return function(){Du(this,e).duration=+t.apply(this,arguments)}}function yRe(e,t){return t=+t,function(){Du(this,e).duration=t}}function Dqt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?_Re:yRe)(t,e)):io(this.node(),t).duration}var Oqt=M(()=>{Ac()});function vRe(e,t){if(typeof t!="function")throw new Error;return function(){Du(this,e).ease=t}}function zqt(e){var t=this._id;return arguments.length?this.each(vRe(t,e)):io(this.node(),t).ease}var Fqt=M(()=>{Ac()});function Bqt(e){typeof e!="function"&&(e=QC(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new Uo(n,this._parents,this._name,this._id)}var Hqt=M(()=>{Mf();ud()});function Vqt(e){if(e._id!==this._id)throw new Error;for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new Uo(a,this._parents,this._name,this._id)}var Uqt=M(()=>{ud()});function xRe(e){return(e+"").trim().split(/^|\s+/).every(function(t){var r=t.indexOf(".");return r>=0&&(t=t.slice(0,r)),!t||t==="start"})}function bRe(e,t,r){var n,i,o=xRe(t)?lA:Du;return function(){var a=o(this,e),s=a.on;s!==n&&(i=(n=s).copy()).on(t,r),a.on=i}}function qqt(e,t){var r=this._id;return arguments.length<2?io(this.node(),r).on.on(e):this.each(bRe(r,e,t))}var Gqt=M(()=>{Ac()});function wRe(e){return function(){var t=this.parentNode;for(var r in this.__transition)if(+r!==e)return;t&&t.removeChild(this)}}function Wqt(){return this.on("end.remove",wRe(this._id))}var Yqt=M(()=>{});function jqt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=w1(e));for(var n=this._groups,i=n.length,o=new Array(i),a=0;a<i;++a)for(var s=n[a],l=s.length,c=o[a]=new Array(l),u,h,f=0;f<l;++f)(u=s[f])&&(h=e.call(u,u.__data__,f,s))&&("__data__"in u&&(h.__data__=u.__data__),c[f]=h,Hg(c[f],t,r,f,c,io(u,r)));return new Uo(o,this._parents,t,r)}var Xqt=M(()=>{Mf();ud();Ac()});function $qt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=JC(e));for(var n=this._groups,i=n.length,o=[],a=[],s=0;s<i;++s)for(var l=n[s],c=l.length,u,h=0;h<c;++h)if(u=l[h]){for(var f=e.call(u,u.__data__,h,l),p,d=io(u,r),g=0,_=f.length;g<_;++g)(p=f[g])&&Hg(p,t,r,g,f,d);o.push(f),a.push(u)}return new Uo(o,a,t,r)}var Kqt=M(()=>{Mf();ud();Ac()});function Zqt(){return new SRe(this._groups,this._parents)}var SRe,Jqt=M(()=>{Mf();SRe=cd.prototype.constructor});function MRe(e,t){var r,n,i;return function(){var o=Bg(this,e),a=(this.style.removeProperty(e),Bg(this,e));return o===a?null:o===r&&a===n?i:i=t(r=o,n=a)}}function ERe(e){return function(){this.style.removeProperty(e)}}function TRe(e,t,r){var n,i;return function(){var o=Bg(this,e);return o===r?null:o===n?i:i=t(n=o,r)}}function CRe(e,t,r){var n,i,o;return function(){var a=Bg(this,e),s=r(this);return s==null&&(s=(this.style.removeProperty(e),Bg(this,e))),a===s?null:a===n&&s===i?o:o=t(n=a,i=s)}}function Qqt(e,t,r){var n=(e+="")=="transform"?ont:Sz;return t==null?this.styleTween(e,MRe(e,n)).on("end.style."+e,ERe(e)):this.styleTween(e,typeof t=="function"?CRe(e,n,Zw(this,"style."+e,t)):TRe(e,n,t+""),r)}var tGt=M(()=>{wz();Mf();pA();snt()});function ARe(e,t,r){function n(){var i=this,o=t.apply(i,arguments);return o&&function(a){i.style.setProperty(e,o(a),r)}}return n._value=t,n}function eGt(e,t,r){var n="style."+(e+="");if(arguments.length<2)return(n=this.tween(n))&&n._value;if(t==null)return this.tween(n,null);if(typeof t!="function")throw new Error;return this.tween(n,ARe(e,t,r==null?"":r))}var rGt=M(()=>{});function PRe(e){return function(){this.textContent=e}}function IRe(e){return function(){var t=e(this);this.textContent=t==null?"":t}}function nGt(e){return this.tween("text",typeof e=="function"?IRe(Zw(this,"text",e)):PRe(e==null?"":e+""))}var iGt=M(()=>{pA()});function oGt(){for(var e=this._name,t=this._id,r=Mz(),n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)if(l=a[c]){var u=io(l,t);Hg(l,e,r,c,a,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new Uo(n,this._parents,e,r)}var aGt=M(()=>{ud();Ac()});function Uo(e,t,r,n){this._groups=e,this._parents=t,this._name=r,this._id=n}function Ez(e){return cd().transition(e)}function Mz(){return++LRe}var LRe,Jw,ud=M(()=>{Mf();Iqt();kqt();Nqt();Oqt();Fqt();Hqt();Uqt();Gqt();Yqt();Xqt();Kqt();Jqt();tGt();rGt();iGt();aGt();pA();LRe=0;Jw=cd.prototype;Uo.prototype=Ez.prototype={constructor:Uo,select:jqt,selectAll:$qt,filter:Bqt,merge:Vqt,selection:Zqt,transition:oGt,call:Jw.call,nodes:Jw.nodes,node:Jw.node,size:Jw.size,empty:Jw.empty,each:Jw.each,on:qqt,attr:Pqt,attrTween:Lqt,style:Qqt,styleTween:eGt,text:nGt,remove:Wqt,tween:Aqt,delay:Rqt,duration:Dqt,ease:zqt}});function kRe(e,t){for(var r;!(r=e.__transition)||!(r=r[t]);)if(!(e=e.parentNode))return lnt.time=Xw(),lnt;return r}function sGt(e){var t,r;e instanceof Uo?(t=e._id,e=e._name):(t=Mz(),(r=lnt).time=Xw(),e=e==null?null:e+"");for(var n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&Hg(l,e,t,c,a,r||kRe(l,t));return new Uo(n,this._parents,e,t)}var lnt,lGt=M(()=>{ud();Ac();I_();Grt();lnt={time:null,delay:0,duration:250,ease:xs}});var cGt=M(()=>{Mf();QUt();lGt();cd.prototype.interrupt=JUt;cd.prototype.transition=sGt});function uGt(e,t){var r=e.__transition,n,i;if(r){t=t==null?null:t+"";for(i in r)if((n=r[i]).state>hz&&n.name===t)return new Uo([[e]],RRe,t,+i)}return null}var RRe,hGt=M(()=>{ud();Ac();RRe=[null]});var fGt=M(()=>{cGt();ud();hGt();Yrt()});function cnt(e){return function(){return e}}var pGt=M(()=>{});function dGt(e){return e[0]}function mGt(e){return e[1]}var gGt=M(()=>{});function unt(){this._=null}function Qw(e){e.U=e.C=e.L=e.R=e.P=e.N=null}function dA(e,t){var r=t,n=t.R,i=r.U;i?i.L===r?i.L=n:i.R=n:e._=n,n.U=i,r.U=n,r.R=n.L,r.R&&(r.R.U=r),n.L=r}function mA(e,t){var r=t,n=t.L,i=r.U;i?i.L===r?i.L=n:i.R=n:e._=n,n.U=i,r.U=n,r.L=n.R,r.L&&(r.L.U=r),n.R=r}function _Gt(e){for(;e.L;)e=e.L;return e}var hnt,Tz=M(()=>{unt.prototype={constructor:unt,insert:function(e,t){var r,n,i;if(e){if(t.P=e,t.N=e.N,e.N&&(e.N.P=t),e.N=t,e.R){for(e=e.R;e.L;)e=e.L;e.L=t}else e.R=t;r=e}else this._?(e=_Gt(this._),t.P=null,t.N=e,e.P=e.L=t,r=e):(t.P=t.N=null,this._=t,r=null);for(t.L=t.R=null,t.U=r,t.C=!0,e=t;r&&r.C;)n=r.U,r===n.L?(i=n.R,i&&i.C?(r.C=i.C=!1,n.C=!0,e=n):(e===r.R&&(dA(this,r),e=r,r=e.U),r.C=!1,n.C=!0,mA(this,n))):(i=n.L,i&&i.C?(r.C=i.C=!1,n.C=!0,e=n):(e===r.L&&(mA(this,r),e=r,r=e.U),r.C=!1,n.C=!0,dA(this,n))),r=e.U;this._.C=!1},remove:function(e){e.N&&(e.N.P=e.P),e.P&&(e.P.N=e.N),e.N=e.P=null;var t=e.U,r,n=e.L,i=e.R,o,a;if(n?i?o=_Gt(i):o=n:o=i,t?t.L===e?t.L=o:t.R=o:this._=o,n&&i?(a=o.C,o.C=e.C,o.L=n,n.U=o,o!==i?(t=o.U,o.U=e.U,e=o.R,t.L=e,o.R=i,i.U=o):(o.U=t,t=o,e=o.R)):(a=e.C,e=o),e&&(e.U=t),!a){if(e&&e.C){e.C=!1;return}do{if(e===this._)break;if(e===t.L){if(r=t.R,r.C&&(r.C=!1,t.C=!0,dA(this,t),r=t.R),r.L&&r.L.C||r.R&&r.R.C){(!r.R||!r.R.C)&&(r.L.C=!1,r.C=!0,mA(this,r),r=t.R),r.C=t.C,t.C=r.R.C=!1,dA(this,t),e=this._;break}}else if(r=t.L,r.C&&(r.C=!1,t.C=!0,mA(this,t),r=t.L),r.L&&r.L.C||r.R&&r.R.C){(!r.L||!r.L.C)&&(r.R.C=!1,r.C=!0,dA(this,r),r=t.L),r.C=t.C,t.C=r.L.C=!1,mA(this,t),e=this._;break}r.C=!0,e=t,t=t.U}while(!e.C);e&&(e.C=!1)}}};hnt=unt});function tS(e,t,r,n){var i=[null,null],o=Ao.push(i)-1;return i.left=e,i.right=t,r&&gA(i,e,t,r),n&&gA(i,t,e,n),Za[e.index].halfedges.push(o),Za[t.index].halfedges.push(o),i}function eS(e,t,r){var n=[t,r];return n.left=e,n}function gA(e,t,r,n){!e[0]&&!e[1]?(e[0]=n,e.left=t,e.right=r):e.left===r?e[1]=n:e[0]=n}function NRe(e,t,r,n,i){var o=e[0],a=e[1],s=o[0],l=o[1],c=a[0],u=a[1],h=0,f=1,p=c-s,d=u-l,g;if(g=t-s,!(!p&&g>0)){if(g/=p,p<0){if(g<h)return;g<f&&(f=g)}else if(p>0){if(g>f)return;g>h&&(h=g)}if(g=n-s,!(!p&&g<0)){if(g/=p,p<0){if(g>f)return;g>h&&(h=g)}else if(p>0){if(g<h)return;g<f&&(f=g)}if(g=r-l,!(!d&&g>0)){if(g/=d,d<0){if(g<h)return;g<f&&(f=g)}else if(d>0){if(g>f)return;g>h&&(h=g)}if(g=i-l,!(!d&&g<0)){if(g/=d,d<0){if(g>f)return;g>h&&(h=g)}else if(d>0){if(g<h)return;g<f&&(f=g)}return!(h>0)&&!(f<1)||(h>0&&(e[0]=[s+h*p,l+h*d]),f<1&&(e[1]=[s+f*p,l+f*d])),!0}}}}}function DRe(e,t,r,n,i){var o=e[1];if(o)return!0;var a=e[0],s=e.left,l=e.right,c=s[0],u=s[1],h=l[0],f=l[1],p=(c+h)/2,d=(u+f)/2,g,_;if(f===u){if(p<t||p>=n)return;if(c>h){if(!a)a=[p,r];else if(a[1]>=i)return;o=[p,i]}else{if(!a)a=[p,i];else if(a[1]<r)return;o=[p,r]}}else if(g=(c-h)/(f-u),_=d-g*p,g<-1||g>1)if(c>h){if(!a)a=[(r-_)/g,r];else if(a[1]>=i)return;o=[(i-_)/g,i]}else{if(!a)a=[(i-_)/g,i];else if(a[1]<r)return;o=[(r-_)/g,r]}else if(u<f){if(!a)a=[t,g*t+_];else if(a[0]>=n)return;o=[n,g*n+_]}else{if(!a)a=[n,g*n+_];else if(a[0]<t)return;o=[t,g*t+_]}return e[0]=a,e[1]=o,!0}function yGt(e,t,r,n){for(var i=Ao.length,o;i--;)(!DRe(o=Ao[i],e,t,r,n)||!NRe(o,e,t,r,n)||!(Math.abs(o[0][0]-o[1][0])>Wr||Math.abs(o[0][1]-o[1][1])>Wr))&&delete Ao[i]}var Cz=M(()=>{rS()});function vGt(e){return Za[e.index]={site:e,halfedges:[]}}function ORe(e,t){var r=e.site,n=t.left,i=t.right;return r===i&&(i=n,n=r),i?Math.atan2(i[1]-n[1],i[0]-n[0]):(r===n?(n=t[1],i=t[0]):(n=t[0],i=t[1]),Math.atan2(n[0]-i[0],i[1]-n[1]))}function fnt(e,t){return t[+(t.left!==e.site)]}function zRe(e,t){return t[+(t.left===e.site)]}function xGt(){for(var e=0,t=Za.length,r,n,i,o;e<t;++e)if((r=Za[e])&&(o=(n=r.halfedges).length)){var a=new Array(o),s=new Array(o);for(i=0;i<o;++i)a[i]=i,s[i]=ORe(r,Ao[n[i]]);for(a.sort(function(l,c){return s[c]-s[l]}),i=0;i<o;++i)s[i]=n[a[i]];for(i=0;i<o;++i)n[i]=s[i]}}function bGt(e,t,r,n){var i=Za.length,o,a,s,l,c,u,h,f,p,d,g,_,y=!0;for(o=0;o<i;++o)if(a=Za[o]){for(s=a.site,c=a.halfedges,l=c.length;l--;)Ao[c[l]]||c.splice(l,1);for(l=0,u=c.length;l<u;)d=zRe(a,Ao[c[l]]),g=d[0],_=d[1],h=fnt(a,Ao[c[++l%u]]),f=h[0],p=h[1],(Math.abs(g-f)>Wr||Math.abs(_-p)>Wr)&&(c.splice(l,0,Ao.push(eS(s,d,Math.abs(g-e)<Wr&&n-_>Wr?[e,Math.abs(f-e)<Wr?p:n]:Math.abs(_-n)<Wr&&r-g>Wr?[Math.abs(p-n)<Wr?f:r,n]:Math.abs(g-r)<Wr&&_-t>Wr?[r,Math.abs(f-r)<Wr?p:t]:Math.abs(_-t)<Wr&&g-e>Wr?[Math.abs(p-t)<Wr?f:e,t]:null))-1),++u);u&&(y=!1)}if(y){var x,b,S,C=1/0;for(o=0,y=null;o<i;++o)(a=Za[o])&&(s=a.site,x=s[0]-e,b=s[1]-t,S=x*x+b*b,S<C&&(C=S,y=a));if(y){var P=[e,t],k=[e,n],O=[r,n],D=[r,t];y.halfedges.push(Ao.push(eS(s=y.site,P,k))-1,Ao.push(eS(s,k,O))-1,Ao.push(eS(s,O,D))-1,Ao.push(eS(s,D,P))-1)}}for(o=0;o<i;++o)(a=Za[o])&&(a.halfedges.length||delete Za[o])}var pnt=M(()=>{Cz();rS()});function FRe(){Qw(this),this.x=this.y=this.arc=this.site=this.cy=null}function M1(e){var t=e.P,r=e.N;if(!(!t||!r)){var n=t.site,i=e.site,o=r.site;if(n!==o){var a=i[0],s=i[1],l=n[0]-a,c=n[1]-s,u=o[0]-a,h=o[1]-s,f=2*(l*h-c*u);if(!(f>=-SGt)){var p=l*l+c*c,d=u*u+h*h,g=(h*p-c*d)/f,_=(l*d-u*p)/f,y=wGt.pop()||new FRe;y.arc=e,y.site=i,y.x=g+a,y.y=(y.cy=_+s)+Math.sqrt(g*g+_*_),e.circle=y;for(var x=null,b=nS._;b;)if(y.y<b.y||y.y===b.y&&y.x<=b.x)if(b.L)b=b.L;else{x=b.P;break}else if(b.R)b=b.R;else{x=b;break}nS.insert(x,y),x||(Az=y)}}}}function E1(e){var t=e.circle;t&&(t.P||(Az=t.N),nS.remove(t),wGt.push(t),Qw(t),e.circle=null)}var wGt,Az,dnt=M(()=>{Tz();rS();wGt=[]});function BRe(){Qw(this),this.edge=this.site=this.circle=null}function MGt(e){var t=EGt.pop()||new BRe;return t.site=e,t}function mnt(e){E1(e),T1.remove(e),EGt.push(e),Qw(e)}function TGt(e){var t=e.circle,r=t.x,n=t.cy,i=[r,n],o=e.P,a=e.N,s=[e];mnt(e);for(var l=o;l.circle&&Math.abs(r-l.circle.x)<Wr&&Math.abs(n-l.circle.cy)<Wr;)o=l.P,s.unshift(l),mnt(l),l=o;s.unshift(l),E1(l);for(var c=a;c.circle&&Math.abs(r-c.circle.x)<Wr&&Math.abs(n-c.circle.cy)<Wr;)a=c.N,s.push(c),mnt(c),c=a;s.push(c),E1(c);var u=s.length,h;for(h=1;h<u;++h)c=s[h],l=s[h-1],gA(c.edge,l.site,c.site,i);l=s[0],c=s[u-1],c.edge=tS(l.site,c.site,null,i),M1(l),M1(c)}function CGt(e){for(var t=e[0],r=e[1],n,i,o,a,s=T1._;s;)if(o=AGt(s,r)-t,o>Wr)s=s.L;else if(a=t-HRe(s,r),a>Wr){if(!s.R){n=s;break}s=s.R}else{o>-Wr?(n=s.P,i=s):a>-Wr?(n=s,i=s.N):n=i=s;break}vGt(e);var l=MGt(e);if(T1.insert(n,l),!(!n&&!i)){if(n===i){E1(n),i=MGt(n.site),T1.insert(l,i),l.edge=i.edge=tS(n.site,l.site),M1(n),M1(i);return}if(!i){l.edge=tS(n.site,l.site);return}E1(n),E1(i);var c=n.site,u=c[0],h=c[1],f=e[0]-u,p=e[1]-h,d=i.site,g=d[0]-u,_=d[1]-h,y=2*(f*_-p*g),x=f*f+p*p,b=g*g+_*_,S=[(_*x-p*b)/y+u,(f*b-g*x)/y+h];gA(i.edge,c,d,S),l.edge=tS(c,e,null,S),i.edge=tS(e,d,null,S),M1(n),M1(i)}}function AGt(e,t){var r=e.site,n=r[0],i=r[1],o=i-t;if(!o)return n;var a=e.P;if(!a)return-1/0;r=a.site;var s=r[0],l=r[1],c=l-t;if(!c)return s;var u=s-n,h=1/o-1/c,f=u/c;return h?(-f+Math.sqrt(f*f-2*h*(u*u/(-2*c)-l+c/2+i-o/2)))/h+n:(n+s)/2}function HRe(e,t){var r=e.N;if(r)return AGt(r,t);var n=e.site;return n[1]===t?n[0]:1/0}var EGt,PGt=M(()=>{Tz();pnt();dnt();Cz();rS();EGt=[]});function VRe(e,t,r){return(e[0]-r[0])*(t[1]-e[1])-(e[0]-t[0])*(r[1]-e[1])}function URe(e,t){return t[1]-e[1]||t[0]-e[0]}function _A(e,t){var r=e.sort(URe).pop(),n,i,o;for(Ao=[],Za=new Array(e.length),T1=new hnt,nS=new hnt;;)if(o=Az,r&&(!o||r[1]<o.y||r[1]===o.y&&r[0]<o.x))(r[0]!==n||r[1]!==i)&&(CGt(r),n=r[0],i=r[1]),r=e.pop();else if(o)TGt(o.arc);else break;if(xGt(),t){var a=+t[0][0],s=+t[0][1],l=+t[1][0],c=+t[1][1];yGt(a,s,l,c),bGt(a,s,l,c)}this.edges=Ao,this.cells=Za,T1=nS=Ao=Za=null}var Wr,SGt,T1,Za,nS,Ao,rS=M(()=>{PGt();pnt();dnt();Cz();Tz();Wr=1e-6,SGt=1e-12;_A.prototype={constructor:_A,polygons:function(){var e=this.edges;return this.cells.map(function(t){var r=t.halfedges.map(function(n){return fnt(t,e[n])});return r.data=t.site.data,r})},triangles:function(){var e=[],t=this.edges;return this.cells.forEach(function(r,n){if(!!(s=(o=r.halfedges).length))for(var i=r.site,o,a=-1,s,l,c=t[o[s-1]],u=c.left===i?c.right:c.left;++a<s;)l=u,c=t[o[a]],u=c.left===i?c.right:c.left,l&&u&&n<l.index&&n<u.index&&VRe(i,l,u)<0&&e.push([i.data,l.data,u.data])}),e},links:function(){return this.edges.filter(function(e){return e.right}).map(function(e){return{source:e.left.data,target:e.right.data}})},find:function(e,t,r){for(var n=this,i,o=n._found||0,a=n.cells.length,s;!(s=n.cells[o]);)if(++o>=a)return null;var l=e-s.site[0],c=t-s.site[1],u=l*l+c*c;do s=n.cells[i=o],o=null,s.halfedges.forEach(function(h){var f=n.edges[h],p=f.left;if(!((p===s.site||!p)&&!(p=f.right))){var d=e-p[0],g=t-p[1],_=d*d+g*g;_<u&&(u=_,o=p.index)}});while(o!==null);return n._found=i,r==null||u<=r*r?s.site:null}}});function IGt(){var e=dGt,t=mGt,r=null;function n(i){return new _A(i.map(function(o,a){var s=[Math.round(e(o,a,i)/Wr)*Wr,Math.round(t(o,a,i)/Wr)*Wr];return s.index=a,s.data=o,s}),r)}return n.polygons=function(i){return n(i).polygons()},n.links=function(i){return n(i).links()},n.triangles=function(i){return n(i).triangles()},n.x=function(i){return arguments.length?(e=typeof i=="function"?i:cnt(+i),n):e},n.y=function(i){return arguments.length?(t=typeof i=="function"?i:cnt(+i),n):t},n.extent=function(i){return arguments.length?(r=i==null?null:[[+i[0][0],+i[0][1]],[+i[1][0],+i[1][1]]],n):r&&[[r[0][0],r[0][1]],[r[1][0],r[1][1]]]},n.size=function(i){return arguments.length?(r=i==null?null:[[0,0],[+i[0],+i[1]]],n):r&&[r[1][0]-r[0][0],r[1][1]-r[0][1]]},n}var LGt=M(()=>{pGt();gGt();rS()});var kGt=M(()=>{LGt()});function NGt(){for(var e=0,t=arguments.length,r={},n;e<t;++e){if(!(n=arguments[e]+"")||n in r||/[\s.]/.test(n))throw new Error("illegal type: "+n);r[n]=[]}return new Pz(r)}function Pz(e){this._=e}function GRe(e,t){return e.trim().split(/^|\s+/).map(function(r){var n="",i=r.indexOf(".");if(i>=0&&(n=r.slice(i+1),r=r.slice(0,i)),r&&!t.hasOwnProperty(r))throw new Error("unknown type: "+r);return{type:r,name:n}})}function WRe(e,t){for(var r=0,n=e.length,i;r<n;++r)if((i=e[r]).name===t)return i.value}function RGt(e,t,r){for(var n=0,i=e.length;n<i;++n)if(e[n].name===t){e[n]=qRe,e=e.slice(0,n).concat(e.slice(n+1));break}return r!=null&&e.push({name:t,value:r}),e}var qRe,yA,DGt=M(()=>{qRe={value:function(){}};Pz.prototype=NGt.prototype={constructor:Pz,on:function(e,t){var r=this._,n=GRe(e+"",r),i,o=-1,a=n.length;if(arguments.length<2){for(;++o<a;)if((i=(e=n[o]).type)&&(i=WRe(r[i],e.name)))return i;return}if(t!=null&&typeof t!="function")throw new Error("invalid callback: "+t);for(;++o<a;)if(i=(e=n[o]).type)r[i]=RGt(r[i],e.name,t);else if(t==null)for(i in r)r[i]=RGt(r[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var r in t)e[r]=t[r].slice();return new Pz(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var r=new Array(i),n=0,i,o;n<i;++n)r[n]=arguments[n+2];if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(o=this._[e],n=0,i=o.length;n<i;++n)o[n].value.apply(t,r)},apply:function(e,t,r){if(!this._.hasOwnProperty(e))throw new Error("unknown type: "+e);for(var n=this._[e],i=0,o=n.length;i<o;++i)n[i].value.apply(t,r)}};yA=NGt});var gnt=M(()=>{DGt()});var Iz,_nt,ynt=M(()=>{Iz="http://www.w3.org/1999/xhtml",_nt={svg:"http://www.w3.org/2000/svg",xhtml:Iz,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"}});function hd(e){var t=e+="",r=t.indexOf(":");return r>=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),_nt.hasOwnProperty(t)?{space:_nt[t],local:e}:e}var Lz=M(()=>{ynt()});function YRe(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===Iz&&t.documentElement.namespaceURI===Iz?t.createElement(e):t.createElementNS(r,e)}}function jRe(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function kz(e){var t=hd(e);return(t.local?jRe:YRe)(t)}var vnt=M(()=>{Lz();ynt()});function XRe(){}function C1(e){return e==null?XRe:function(){return this.querySelector(e)}}var Rz=M(()=>{});function OGt(e){typeof e!="function"&&(e=C1(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=new Array(a),l,c,u=0;u<a;++u)(l=o[u])&&(c=e.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),s[u]=c);return new gi(n,this._parents)}var zGt=M(()=>{Ou();Rz()});function $Re(){return[]}function vA(e){return e==null?$Re:function(){return this.querySelectorAll(e)}}var xnt=M(()=>{});function FGt(e){typeof e!="function"&&(e=vA(e));for(var t=this._groups,r=t.length,n=[],i=[],o=0;o<r;++o)for(var a=t[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&(n.push(e.call(l,l.__data__,c,a)),i.push(l));return new gi(n,i)}var BGt=M(()=>{Ou();xnt()});function xA(e){return function(){return this.matches(e)}}var bnt=M(()=>{});function HGt(e){typeof e!="function"&&(e=xA(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new gi(n,this._parents)}var VGt=M(()=>{Ou();bnt()});function Nz(e){return new Array(e.length)}var wnt=M(()=>{});function UGt(){return new gi(this._enter||this._groups.map(Nz),this._parents)}function bA(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}var Snt=M(()=>{wnt();Ou();bA.prototype={constructor:bA,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}}});function qGt(e){return function(){return e}}var GGt=M(()=>{});function KRe(e,t,r,n,i,o){for(var a=0,s,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],n[a]=s):r[a]=new bA(e,o[a]);for(;a<l;++a)(s=t[a])&&(i[a]=s)}function ZRe(e,t,r,n,i,o,a){var s,l,c={},u=t.length,h=o.length,f=new Array(u),p;for(s=0;s<u;++s)(l=t[s])&&(f[s]=p=WGt+a.call(l,l.__data__,s,t),p in c?i[s]=l:c[p]=l);for(s=0;s<h;++s)p=WGt+a.call(e,o[s],s,o),(l=c[p])?(n[s]=l,l.__data__=o[s],c[p]=null):r[s]=new bA(e,o[s]);for(s=0;s<u;++s)(l=t[s])&&c[f[s]]===l&&(i[s]=l)}function YGt(e,t){if(!e)return p=new Array(this.size()),c=-1,this.each(function(P){p[++c]=P}),p;var r=t?ZRe:KRe,n=this._parents,i=this._groups;typeof e!="function"&&(e=qGt(e));for(var o=i.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var u=n[c],h=i[c],f=h.length,p=e.call(u,u&&u.__data__,c,n),d=p.length,g=s[c]=new Array(d),_=a[c]=new Array(d),y=l[c]=new Array(f);r(u,h,g,_,y,p,t);for(var x=0,b=0,S,C;x<d;++x)if(S=g[x]){for(x>=b&&(b=x+1);!(C=_[b])&&++b<d;);S._next=C||null}}return a=new gi(a,n),a._enter=s,a._exit=l,a}var WGt,jGt=M(()=>{Ou();Snt();GGt();WGt="$"});function XGt(){return new gi(this._exit||this._groups.map(Nz),this._parents)}var $Gt=M(()=>{wnt();Ou()});function KGt(e,t,r){var n=this.enter(),i=this,o=this.exit();return n=typeof e=="function"?e(n):n.append(e+""),t!=null&&(i=t(i)),r==null?o.remove():r(o),n&&i?n.merge(i).order():i}var ZGt=M(()=>{});function JGt(e){for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new gi(a,this._parents)}var QGt=M(()=>{Ou()});function tWt(){for(var e=this._groups,t=-1,r=e.length;++t<r;)for(var n=e[t],i=n.length-1,o=n[i],a;--i>=0;)(a=n[i])&&(o&&a.compareDocumentPosition(o)^4&&o.parentNode.insertBefore(a,o),o=a);return this}var eWt=M(()=>{});function rWt(e){e||(e=JRe);function t(h,f){return h&&f?e(h.__data__,f.__data__):!h-!f}for(var r=this._groups,n=r.length,i=new Array(n),o=0;o<n;++o){for(var a=r[o],s=a.length,l=i[o]=new Array(s),c,u=0;u<s;++u)(c=a[u])&&(l[u]=c);l.sort(t)}return new gi(i,this._parents).order()}function JRe(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}var nWt=M(()=>{Ou()});function iWt(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}var oWt=M(()=>{});function aWt(){var e=new Array(this.size()),t=-1;return this.each(function(){e[++t]=this}),e}var sWt=M(()=>{});function lWt(){for(var e=this._groups,t=0,r=e.length;t<r;++t)for(var n=e[t],i=0,o=n.length;i<o;++i){var a=n[i];if(a)return a}return null}var cWt=M(()=>{});function uWt(){var e=0;return this.each(function(){++e}),e}var hWt=M(()=>{});function fWt(){return!this.node()}var pWt=M(()=>{});function dWt(e){for(var t=this._groups,r=0,n=t.length;r<n;++r)for(var i=t[r],o=0,a=i.length,s;o<a;++o)(s=i[o])&&e.call(s,s.__data__,o,i);return this}var mWt=M(()=>{});function QRe(e){return function(){this.removeAttribute(e)}}function tNe(e){return function(){this.removeAttributeNS(e.space,e.local)}}function eNe(e,t){return function(){this.setAttribute(e,t)}}function rNe(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function nNe(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttribute(e):this.setAttribute(e,r)}}function iNe(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,r)}}function gWt(e,t){var r=hd(e);if(arguments.length<2){var n=this.node();return r.local?n.getAttributeNS(r.space,r.local):n.getAttribute(r)}return this.each((t==null?r.local?tNe:QRe:typeof t=="function"?r.local?iNe:nNe:r.local?rNe:eNe)(r,t))}var _Wt=M(()=>{Lz()});function Dz(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}var Mnt=M(()=>{});function oNe(e){return function(){this.style.removeProperty(e)}}function aNe(e,t,r){return function(){this.style.setProperty(e,t,r)}}function sNe(e,t,r){return function(){var n=t.apply(this,arguments);n==null?this.style.removeProperty(e):this.style.setProperty(e,n,r)}}function yWt(e,t,r){return arguments.length>1?this.each((t==null?oNe:typeof t=="function"?sNe:aNe)(e,t,r==null?"":r)):Ug(this.node(),e)}function Ug(e,t){return e.style.getPropertyValue(t)||Dz(e).getComputedStyle(e,null).getPropertyValue(t)}var Ent=M(()=>{Mnt()});function lNe(e){return function(){delete this[e]}}function cNe(e,t){return function(){this[e]=t}}function uNe(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function vWt(e,t){return arguments.length>1?this.each((t==null?lNe:typeof t=="function"?uNe:cNe)(e,t)):this.node()[e]}var xWt=M(()=>{});function bWt(e){return e.trim().split(/^|\s+/)}function Tnt(e){return e.classList||new wWt(e)}function wWt(e){this._node=e,this._names=bWt(e.getAttribute("class")||"")}function SWt(e,t){for(var r=Tnt(e),n=-1,i=t.length;++n<i;)r.add(t[n])}function MWt(e,t){for(var r=Tnt(e),n=-1,i=t.length;++n<i;)r.remove(t[n])}function hNe(e){return function(){SWt(this,e)}}function fNe(e){return function(){MWt(this,e)}}function pNe(e,t){return function(){(t.apply(this,arguments)?SWt:MWt)(this,e)}}function EWt(e,t){var r=bWt(e+"");if(arguments.length<2){for(var n=Tnt(this.node()),i=-1,o=r.length;++i<o;)if(!n.contains(r[i]))return!1;return!0}return this.each((typeof t=="function"?pNe:t?hNe:fNe)(r,t))}var TWt=M(()=>{wWt.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}}});function dNe(){this.textContent=""}function mNe(e){return function(){this.textContent=e}}function gNe(e){return function(){var t=e.apply(this,arguments);this.textContent=t==null?"":t}}function CWt(e){return arguments.length?this.each(e==null?dNe:(typeof e=="function"?gNe:mNe)(e)):this.node().textContent}var AWt=M(()=>{});function _Ne(){this.innerHTML=""}function yNe(e){return function(){this.innerHTML=e}}function vNe(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t==null?"":t}}function PWt(e){return arguments.length?this.each(e==null?_Ne:(typeof e=="function"?vNe:yNe)(e)):this.node().innerHTML}var IWt=M(()=>{});function xNe(){this.nextSibling&&this.parentNode.appendChild(this)}function LWt(){return this.each(xNe)}var kWt=M(()=>{});function bNe(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function RWt(){return this.each(bNe)}var NWt=M(()=>{});function DWt(e){var t=typeof e=="function"?e:kz(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}var OWt=M(()=>{vnt()});function wNe(){return null}function zWt(e,t){var r=typeof e=="function"?e:kz(e),n=t==null?wNe:typeof t=="function"?t:C1(t);return this.select(function(){return this.insertBefore(r.apply(this,arguments),n.apply(this,arguments)||null)})}var FWt=M(()=>{vnt();Rz()});function SNe(){var e=this.parentNode;e&&e.removeChild(this)}function BWt(){return this.each(SNe)}var HWt=M(()=>{});function MNe(){var e=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function ENe(){var e=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function VWt(e){return this.select(e?ENe:MNe)}var UWt=M(()=>{});function qWt(e){return arguments.length?this.property("__data__",e):this.node().__data__}var GWt=M(()=>{});function TNe(e,t,r){return e=jWt(e,t,r),function(n){var i=n.relatedTarget;(!i||i!==this&&!(i.compareDocumentPosition(this)&8))&&e.call(this,n)}}function jWt(e,t,r){return function(n){var i=Yr;Yr=n;try{e.call(this,this.__data__,t,r)}finally{Yr=i}}}function CNe(e){return e.trim().split(/^|\s+/).map(function(t){var r="",n=t.indexOf(".");return n>=0&&(r=t.slice(n+1),t=t.slice(0,n)),{type:t,name:r}})}function ANe(e){return function(){var t=this.__on;if(!!t){for(var r=0,n=-1,i=t.length,o;r<i;++r)o=t[r],(!e.type||o.type===e.type)&&o.name===e.name?this.removeEventListener(o.type,o.listener,o.capture):t[++n]=o;++n?t.length=n:delete this.__on}}}function PNe(e,t,r){var n=YWt.hasOwnProperty(e.type)?TNe:jWt;return function(i,o,a){var s=this.__on,l,c=n(t,o,a);if(s){for(var u=0,h=s.length;u<h;++u)if((l=s[u]).type===e.type&&l.name===e.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=r),l.value=t;return}}this.addEventListener(e.type,c,r),l={type:e.type,name:e.name,value:t,listener:c,capture:r},s?s.push(l):this.__on=[l]}}function XWt(e,t,r){var n=CNe(e+""),i,o=n.length,a;if(arguments.length<2){var s=this.node().__on;if(s){for(var l=0,c=s.length,u;l<c;++l)for(i=0,u=s[l];i<o;++i)if((a=n[i]).type===u.type&&a.name===u.name)return u.value}return}for(s=t?PNe:ANe,r==null&&(r=!1),i=0;i<o;++i)this.each(s(n[i],t,r));return this}function Cnt(e,t,r,n){var i=Yr;e.sourceEvent=Yr,Yr=e;try{return t.apply(r,n)}finally{Yr=i}}var YWt,Yr,WWt,Oz=M(()=>{YWt={},Yr=null;typeof document!="undefined"&&(WWt=document.documentElement,"onmouseenter"in WWt||(YWt={mouseenter:"mouseover",mouseleave:"mouseout"}))});function $Wt(e,t,r){var n=Dz(e),i=n.CustomEvent;typeof i=="function"?i=new i(t,r):(i=n.document.createEvent("Event"),r?(i.initEvent(t,r.bubbles,r.cancelable),i.detail=r.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function INe(e,t){return function(){return $Wt(this,e,t)}}function LNe(e,t){return function(){return $Wt(this,e,t.apply(this,arguments))}}function KWt(e,t){return this.each((typeof t=="function"?LNe:INe)(e,t))}var ZWt=M(()=>{Mnt()});function gi(e,t){this._groups=e,this._parents=t}function JWt(){return new gi([[document.documentElement]],Ant)}var Ant,fd,Ou=M(()=>{zGt();BGt();VGt();jGt();Snt();$Gt();ZGt();QGt();eWt();nWt();oWt();sWt();cWt();hWt();pWt();mWt();_Wt();Ent();xWt();TWt();AWt();IWt();kWt();NWt();OWt();FWt();HWt();UWt();GWt();Oz();ZWt();Ant=[null];gi.prototype=JWt.prototype={constructor:gi,select:OGt,selectAll:FGt,filter:HGt,data:YGt,enter:UGt,exit:XGt,join:KGt,merge:JGt,order:tWt,sort:rWt,call:iWt,nodes:aWt,node:lWt,size:uWt,empty:fWt,each:dWt,attr:gWt,style:yWt,property:vWt,classed:EWt,text:CWt,html:PWt,raise:LWt,lower:RWt,append:DWt,insert:zWt,remove:BWt,clone:VWt,datum:qWt,on:XWt,dispatch:KWt};fd=JWt});function pd(e){return typeof e=="string"?new gi([[document.querySelector(e)]],[document.documentElement]):new gi([[e]],Ant)}var QWt=M(()=>{Ou()});function zz(){for(var e=Yr,t;t=e.sourceEvent;)e=t;return e}var Pnt=M(()=>{Oz()});function Fz(e,t){var r=e.ownerSVGElement||e;if(r.createSVGPoint){var n=r.createSVGPoint();return n.x=t.clientX,n.y=t.clientY,n=n.matrixTransform(e.getScreenCTM().inverse()),[n.x,n.y]}var i=e.getBoundingClientRect();return[t.clientX-i.left-e.clientLeft,t.clientY-i.top-e.clientTop]}var Int=M(()=>{});function iS(e){var t=zz();return t.changedTouches&&(t=t.changedTouches[0]),Fz(e,t)}var tYt=M(()=>{Pnt();Int()});function Bz(e,t,r){arguments.length<3&&(r=t,t=zz().changedTouches);for(var n=0,i=t?t.length:0,o;n<i;++n)if((o=t[n]).identifier===r)return Fz(e,o);return null}var eYt=M(()=>{Pnt();Int()});var Is=M(()=>{bnt();tYt();Lz();QWt();Ou();Rz();xnt();Ent();eYt();Oz()});function Hz(){Yr.preventDefault(),Yr.stopImmediatePropagation()}var rYt=M(()=>{Is()});function Lnt(e){var t=e.document.documentElement,r=pd(e).on("dragstart.drag",Hz,!0);"onselectstart"in t?r.on("selectstart.drag",Hz,!0):(t.__noselect=t.style.MozUserSelect,t.style.MozUserSelect="none")}function knt(e,t){var r=e.document.documentElement,n=pd(e).on("dragstart.drag",null);t&&(n.on("click.drag",Hz,!0),setTimeout(function(){n.on("click.drag",null)},0)),"onselectstart"in r?n.on("selectstart.drag",null):(r.style.MozUserSelect=r.__noselect,delete r.__noselect)}var nYt=M(()=>{Is();rYt()});var iYt=M(()=>{nYt()});function Vz(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function Rnt(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}var oYt=M(()=>{});function MA(){}function sYt(){return this.rgb().formatHex()}function BNe(){return pYt(this).formatHsl()}function lYt(){return this.rgb().formatRgb()}function qg(e){var t,r;return e=(e+"").trim().toLowerCase(),(t=kNe.exec(e))?(r=t[1].length,t=parseInt(t[1],16),r===6?cYt(t):r===3?new gl(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?Uz(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?Uz(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=RNe.exec(e))?new gl(t[1],t[2],t[3],1):(t=NNe.exec(e))?new gl(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=DNe.exec(e))?Uz(t[1],t[2],t[3],t[4]):(t=ONe.exec(e))?Uz(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=zNe.exec(e))?fYt(t[1],t[2]/100,t[3]/100,1):(t=FNe.exec(e))?fYt(t[1],t[2]/100,t[3]/100,t[4]):aYt.hasOwnProperty(e)?cYt(aYt[e]):e==="transparent"?new gl(NaN,NaN,NaN,0):null}function cYt(e){return new gl(e>>16&255,e>>8&255,e&255,1)}function Uz(e,t,r,n){return n<=0&&(e=t=r=NaN),new gl(e,t,r,n)}function HNe(e){return e instanceof MA||(e=qg(e)),e?(e=e.rgb(),new gl(e.r,e.g,e.b,e.opacity)):new gl}function aS(e,t,r,n){return arguments.length===1?HNe(e):new gl(e,t,r,n==null?1:n)}function gl(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}function uYt(){return"#"+Nnt(this.r)+Nnt(this.g)+Nnt(this.b)}function hYt(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}function Nnt(e){return e=Math.max(0,Math.min(255,Math.round(e)||0)),(e<16?"0":"")+e.toString(16)}function fYt(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new Cf(e,t,r,n)}function pYt(e){if(e instanceof Cf)return new Cf(e.h,e.s,e.l,e.opacity);if(e instanceof MA||(e=qg(e)),!e)return new Cf;if(e instanceof Cf)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new Cf(a,s,l,e.opacity)}function dYt(e,t,r,n){return arguments.length===1?pYt(e):new Cf(e,t,r,n==null?1:n)}function Cf(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}function Dnt(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var wA,qz,oS,SA,Af,kNe,RNe,NNe,DNe,ONe,zNe,FNe,aYt,mYt=M(()=>{oYt();wA=.7,qz=1/wA,oS="\\s*([+-]?\\d+)\\s*",SA="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",Af="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",kNe=/^#([0-9a-f]{3,8})$/,RNe=new RegExp("^rgb\\("+[oS,oS,oS]+"\\)$"),NNe=new RegExp("^rgb\\("+[Af,Af,Af]+"\\)$"),DNe=new RegExp("^rgba\\("+[oS,oS,oS,SA]+"\\)$"),ONe=new RegExp("^rgba\\("+[Af,Af,Af,SA]+"\\)$"),zNe=new RegExp("^hsl\\("+[SA,Af,Af]+"\\)$"),FNe=new RegExp("^hsla\\("+[SA,Af,Af,SA]+"\\)$"),aYt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};Vz(MA,qg,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:sYt,formatHex:sYt,formatHsl:BNe,formatRgb:lYt,toString:lYt});Vz(gl,aS,Rnt(MA,{brighter:function(e){return e=e==null?qz:Math.pow(qz,e),new gl(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?wA:Math.pow(wA,e),new gl(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:uYt,formatHex:uYt,formatRgb:hYt,toString:hYt}));Vz(Cf,dYt,Rnt(MA,{brighter:function(e){return e=e==null?qz:Math.pow(qz,e),new Cf(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?wA:Math.pow(wA,e),new Cf(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new gl(Dnt(e>=240?e-240:e+120,i,n),Dnt(e,i,n),Dnt(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(e===1?")":", "+e+")")}}))});var Ont=M(()=>{mYt()});function znt(e,t,r,n,i){var o=e*e,a=o*e;return((1-3*e+3*o-a)*t+(4-6*o+3*a)*r+(1+3*e+3*o-3*a)*n+a*i)/6}function gYt(e){var t=e.length-1;return function(r){var n=r<=0?r=0:r>=1?(r=1,t-1):Math.floor(r*t),i=e[n],o=e[n+1],a=n>0?e[n-1]:2*i-o,s=n<t-1?e[n+2]:2*o-i;return znt((r-n/t)*t,a,i,o,s)}}var Fnt=M(()=>{});function _Yt(e){var t=e.length;return function(r){var n=Math.floor(((r%=1)<0?++r:r)*t),i=e[(n+t-1)%t],o=e[n%t],a=e[(n+1)%t],s=e[(n+2)%t];return znt((r-n/t)*t,i,o,a,s)}}var yYt=M(()=>{Fnt()});function Bnt(e){return function(){return e}}var vYt=M(()=>{});function VNe(e,t){return function(r){return e+r*t}}function UNe(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function xYt(e){return(e=+e)==1?Gz:function(t,r){return r-t?UNe(t,r,e):Bnt(isNaN(t)?r:t)}}function Gz(e,t){var r=t-e;return r?VNe(e,r):Bnt(isNaN(e)?t:e)}var bYt=M(()=>{vYt()});function wYt(e){return function(t){var r=t.length,n=new Array(r),i=new Array(r),o=new Array(r),a,s;for(a=0;a<r;++a)s=aS(t[a]),n[a]=s.r||0,i[a]=s.g||0,o[a]=s.b||0;return n=e(n),i=e(i),o=e(o),s.opacity=1,function(l){return s.r=n(l),s.g=i(l),s.b=o(l),s+""}}}var Wz,qNe,GNe,SYt=M(()=>{Ont();Fnt();yYt();bYt();Wz=function e(t){var r=xYt(t);function n(i,o){var a=r((i=aS(i)).r,(o=aS(o)).r),s=r(i.g,o.g),l=r(i.b,o.b),c=Gz(i.opacity,o.opacity);return function(u){return i.r=a(u),i.g=s(u),i.b=l(u),i.opacity=c(u),i+""}}return n.gamma=e,n}(1);qNe=wYt(gYt),GNe=wYt(_Yt)});function Ic(e,t){return e=+e,t=+t,function(r){return e*(1-r)+t*r}}var Yz=M(()=>{});function WNe(e){return function(){return e}}function YNe(e){return function(t){return e(t)+""}}function Unt(e,t){var r=Vnt.lastIndex=Hnt.lastIndex=0,n,i,o,a=-1,s=[],l=[];for(e=e+"",t=t+"";(n=Vnt.exec(e))&&(i=Hnt.exec(t));)(o=i.index)>r&&(o=t.slice(r,o),s[a]?s[a]+=o:s[++a]=o),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:Ic(n,i)})),r=Hnt.lastIndex;return r<t.length&&(o=t.slice(r),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?YNe(l[0].x):WNe(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)s[(h=l[u]).i]=h.x(c);return s.join("")})}var Vnt,Hnt,MYt=M(()=>{Yz();Vnt=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,Hnt=new RegExp(Vnt.source,"g")});function qnt(e,t,r,n,i,o){var a,s,l;return(a=Math.sqrt(e*e+t*t))&&(e/=a,t/=a),(l=e*r+t*n)&&(r-=e*l,n-=t*l),(s=Math.sqrt(r*r+n*n))&&(r/=s,n/=s,l/=s),e*n<t*r&&(e=-e,t=-t,l=-l,a=-a),{translateX:i,translateY:o,rotate:Math.atan2(t,e)*EYt,skewX:Math.atan(l)*EYt,scaleX:a,scaleY:s}}var EYt,jz,TYt=M(()=>{EYt=180/Math.PI,jz={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1}});function AYt(e){return e==="none"?jz:(EA||(EA=document.createElement("DIV"),Gnt=document.documentElement,CYt=document.defaultView),EA.style.transform=e,e=CYt.getComputedStyle(Gnt.appendChild(EA),null).getPropertyValue("transform"),Gnt.removeChild(EA),e=e.slice(7,-1).split(","),qnt(+e[0],+e[1],+e[2],+e[3],+e[4],+e[5]))}function PYt(e){return e==null?jz:(Xz||(Xz=document.createElementNS("http://www.w3.org/2000/svg","g")),Xz.setAttribute("transform",e),(e=Xz.transform.baseVal.consolidate())?(e=e.matrix,qnt(e.a,e.b,e.c,e.d,e.e,e.f)):jz)}var EA,Gnt,CYt,Xz,IYt=M(()=>{TYt()});function LYt(e,t,r,n){function i(c){return c.length?c.pop()+" ":""}function o(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push("translate(",null,t,null,r);d.push({i:g-4,x:Ic(c,h)},{i:g-2,x:Ic(u,f)})}else(h||f)&&p.push("translate("+h+t+f+r)}function a(c,u,h,f){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),f.push({i:h.push(i(h)+"rotate(",null,n)-2,x:Ic(c,u)})):u&&h.push(i(h)+"rotate("+u+n)}function s(c,u,h,f){c!==u?f.push({i:h.push(i(h)+"skewX(",null,n)-2,x:Ic(c,u)}):u&&h.push(i(h)+"skewX("+u+n)}function l(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push(i(p)+"scale(",null,",",null,")");d.push({i:g-4,x:Ic(c,h)},{i:g-2,x:Ic(u,f)})}else(h!==1||f!==1)&&p.push(i(p)+"scale("+h+","+f+")")}return function(c,u){var h=[],f=[];return c=e(c),u=e(u),o(c.translateX,c.translateY,u.translateX,u.translateY,h,f),a(c.rotate,u.rotate,h,f),s(c.skewX,u.skewX,h,f),l(c.scaleX,c.scaleY,u.scaleX,u.scaleY,h,f),c=u=null,function(p){for(var d=-1,g=f.length,_;++d<g;)h[(_=f[d]).i]=_.x(p);return h.join("")}}}var Wnt,Ynt,kYt=M(()=>{Yz();IYt();Wnt=LYt(AYt,"px, ","px)","deg)"),Ynt=LYt(PYt,", ",")",")")});function NYt(e){return((e=Math.exp(e))+1/e)/2}function XNe(e){return((e=Math.exp(e))-1/e)/2}function $Ne(e){return((e=Math.exp(2*e))-1)/(e+1)}function Xnt(e,t){var r=e[0],n=e[1],i=e[2],o=t[0],a=t[1],s=t[2],l=o-r,c=a-n,u=l*l+c*c,h,f;if(u<jNe)f=Math.log(s/i)/TA,h=function(x){return[r+x*l,n+x*c,i*Math.exp(TA*x*f)]};else{var p=Math.sqrt(u),d=(s*s-i*i+RYt*u)/(2*i*jnt*p),g=(s*s-i*i-RYt*u)/(2*s*jnt*p),_=Math.log(Math.sqrt(d*d+1)-d),y=Math.log(Math.sqrt(g*g+1)-g);f=(y-_)/TA,h=function(x){var b=x*f,S=NYt(_),C=i/(jnt*p)*(S*$Ne(TA*b+_)-XNe(_));return[r+C*l,n+C*c,i*S/NYt(TA*b+_)]}}return h.duration=f*1e3,h}var TA,jnt,RYt,jNe,DYt=M(()=>{TA=Math.SQRT2,jnt=2,RYt=4,jNe=1e-12});var CA=M(()=>{Yz();MYt();kYt();DYt();SYt()});function lS(){return A1||(FYt(KNe),A1=LA.now()+Zz)}function KNe(){A1=0}function kA(){this._call=this._time=this._next=null}function Jz(e,t,r){var n=new kA;return n.restart(e,t,r),n}function BYt(){lS(),++sS;for(var e=$z,t;e;)(t=A1-e._time)>=0&&e._call.call(null,t),e=e._next;--sS}function OYt(){A1=(Kz=LA.now())+Zz,sS=PA=0;try{BYt()}finally{sS=0,JNe(),A1=0}}function ZNe(){var e=LA.now(),t=e-Kz;t>zYt&&(Zz-=t,Kz=e)}function JNe(){for(var e,t=$z,r,n=1/0;t;)t._call?(n>t._time&&(n=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:$z=r);IA=e,$nt(n)}function $nt(e){if(!sS){PA&&(PA=clearTimeout(PA));var t=e-A1;t>24?(e<1/0&&(PA=setTimeout(OYt,e-LA.now()-Zz)),AA&&(AA=clearInterval(AA))):(AA||(Kz=LA.now(),AA=setInterval(ZNe,zYt)),sS=1,FYt(OYt))}}var sS,PA,AA,zYt,$z,IA,Kz,A1,Zz,LA,FYt,Knt=M(()=>{sS=0,PA=0,AA=0,zYt=1e3,Kz=0,A1=0,Zz=0,LA=typeof performance=="object"&&performance.now?performance:Date,FYt=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};kA.prototype=Jz.prototype={constructor:kA,restart:function(e,t,r){if(typeof e!="function")throw new TypeError("callback is not a function");r=(r==null?lS():+r)+(t==null?0:+t),!this._next&&IA!==this&&(IA?IA._next=this:$z=this,IA=this),this._call=e,this._time=r,$nt()},stop:function(){this._call&&(this._call=null,this._time=1/0,$nt())}}});function Qz(e,t,r){var n=new kA;return t=t==null?0:+t,n.restart(function(i){n.stop(),e(i+t)},t,r),n}var HYt=M(()=>{Knt()});var Znt=M(()=>{Knt();HYt()});function Gg(e,t,r,n,i,o){var a=e.__transition;if(!a)e.__transition={};else if(r in a)return;eDe(e,r,{name:t,index:n,group:i,on:QNe,tween:tDe,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:UYt})}function NA(e,t){var r=oo(e,t);if(r.state>UYt)throw new Error("too late; already scheduled");return r}function Ja(e,t){var r=oo(e,t);if(r.state>tF)throw new Error("too late; already running");return r}function oo(e,t){var r=e.__transition;if(!r||!(r=r[t]))throw new Error("transition not found");return r}function eDe(e,t,r){var n=e.__transition,i;n[t]=r,r.timer=Jz(o,0,r.time);function o(c){r.state=Jnt,r.timer.restart(a,r.delay,r.time),r.delay<=c&&a(c-r.delay)}function a(c){var u,h,f,p;if(r.state!==Jnt)return l();for(u in n)if(p=n[u],p.name===r.name){if(p.state===tF)return Qz(a);p.state===VYt?(p.state=RA,p.timer.stop(),p.on.call("interrupt",e,e.__data__,p.index,p.group),delete n[u]):+u<t&&(p.state=RA,p.timer.stop(),p.on.call("cancel",e,e.__data__,p.index,p.group),delete n[u])}if(Qz(function(){r.state===tF&&(r.state=VYt,r.timer.restart(s,r.delay,r.time),s(c))}),r.state=eF,r.on.call("start",e,e.__data__,r.index,r.group),r.state===eF){for(r.state=tF,i=new Array(f=r.tween.length),u=0,h=-1;u<f;++u)(p=r.tween[u].value.call(e,e.__data__,r.index,r.group))&&(i[++h]=p);i.length=h+1}}function s(c){for(var u=c<r.duration?r.ease.call(null,c/r.duration):(r.timer.restart(l),r.state=rF,1),h=-1,f=i.length;++h<f;)i[h].call(e,u);r.state===rF&&(r.on.call("end",e,e.__data__,r.index,r.group),l())}function l(){r.state=RA,r.timer.stop(),delete n[t];for(var c in n)return;delete e.__transition}}var QNe,tDe,UYt,Jnt,eF,tF,VYt,rF,RA,Ls=M(()=>{gnt();Znt();QNe=yA("start","end","cancel","interrupt"),tDe=[],UYt=0,Jnt=1,eF=2,tF=3,VYt=4,rF=5,RA=6});function P1(e,t){var r=e.__transition,n,i,o=!0,a;if(!!r){t=t==null?null:t+"";for(a in r){if((n=r[a]).name!==t){o=!1;continue}i=n.state>eF&&n.state<rF,n.state=RA,n.timer.stop(),n.on.call(i?"interrupt":"cancel",e,e.__data__,n.index,n.group),delete r[a]}o&&delete e.__transition}}var Qnt=M(()=>{Ls()});function qYt(e){return this.each(function(){P1(this,e)})}var GYt=M(()=>{Qnt()});function rDe(e,t){var r,n;return function(){var i=Ja(this,e),o=i.tween;if(o!==r){n=r=o;for(var a=0,s=n.length;a<s;++a)if(n[a].name===t){n=n.slice(),n.splice(a,1);break}}i.tween=n}}function nDe(e,t,r){var n,i;if(typeof r!="function")throw new Error;return function(){var o=Ja(this,e),a=o.tween;if(a!==n){i=(n=a).slice();for(var s={name:t,value:r},l=0,c=i.length;l<c;++l)if(i[l].name===t){i[l]=s;break}l===c&&i.push(s)}o.tween=i}}function WYt(e,t){var r=this._id;if(e+="",arguments.length<2){for(var n=oo(this.node(),r).tween,i=0,o=n.length,a;i<o;++i)if((a=n[i]).name===e)return a.value;return null}return this.each((t==null?rDe:nDe)(r,e,t))}function cS(e,t,r){var n=e._id;return e.each(function(){var i=Ja(this,n);(i.value||(i.value={}))[t]=r.apply(this,arguments)}),function(i){return oo(i,n).value[t]}}var DA=M(()=>{Ls()});function nF(e,t){var r;return(typeof t=="number"?Ic:t instanceof qg?Wz:(r=qg(t))?(t=r,Wz):Unt)(e,t)}var tit=M(()=>{Ont();CA()});function iDe(e){return function(){this.removeAttribute(e)}}function oDe(e){return function(){this.removeAttributeNS(e.space,e.local)}}function aDe(e,t,r){var n,i=r+"",o;return function(){var a=this.getAttribute(e);return a===i?null:a===n?o:o=t(n=a,r)}}function sDe(e,t,r){var n,i=r+"",o;return function(){var a=this.getAttributeNS(e.space,e.local);return a===i?null:a===n?o:o=t(n=a,r)}}function lDe(e,t,r){var n,i,o;return function(){var a,s=r(this),l;return s==null?void this.removeAttribute(e):(a=this.getAttribute(e),l=s+"",a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s)))}}function cDe(e,t,r){var n,i,o;return function(){var a,s=r(this),l;return s==null?void this.removeAttributeNS(e.space,e.local):(a=this.getAttributeNS(e.space,e.local),l=s+"",a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s)))}}function YYt(e,t){var r=hd(e),n=r==="transform"?Ynt:nF;return this.attrTween(e,typeof t=="function"?(r.local?cDe:lDe)(r,n,cS(this,"attr."+e,t)):t==null?(r.local?oDe:iDe)(r):(r.local?sDe:aDe)(r,n,t))}var jYt=M(()=>{CA();Is();DA();tit()});function uDe(e,t){return function(r){this.setAttribute(e,t.call(this,r))}}function hDe(e,t){return function(r){this.setAttributeNS(e.space,e.local,t.call(this,r))}}function fDe(e,t){var r,n;function i(){var o=t.apply(this,arguments);return o!==n&&(r=(n=o)&&hDe(e,o)),r}return i._value=t,i}function pDe(e,t){var r,n;function i(){var o=t.apply(this,arguments);return o!==n&&(r=(n=o)&&uDe(e,o)),r}return i._value=t,i}function XYt(e,t){var r="attr."+e;if(arguments.length<2)return(r=this.tween(r))&&r._value;if(t==null)return this.tween(r,null);if(typeof t!="function")throw new Error;var n=hd(e);return this.tween(r,(n.local?fDe:pDe)(n,t))}var $Yt=M(()=>{Is()});function dDe(e,t){return function(){NA(this,e).delay=+t.apply(this,arguments)}}function mDe(e,t){return t=+t,function(){NA(this,e).delay=t}}function KYt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?dDe:mDe)(t,e)):oo(this.node(),t).delay}var ZYt=M(()=>{Ls()});function gDe(e,t){return function(){Ja(this,e).duration=+t.apply(this,arguments)}}function _De(e,t){return t=+t,function(){Ja(this,e).duration=t}}function JYt(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?gDe:_De)(t,e)):oo(this.node(),t).duration}var QYt=M(()=>{Ls()});function yDe(e,t){if(typeof t!="function")throw new Error;return function(){Ja(this,e).ease=t}}function tjt(e){var t=this._id;return arguments.length?this.each(yDe(t,e)):oo(this.node(),t).ease}var ejt=M(()=>{Ls()});function rjt(e){typeof e!="function"&&(e=xA(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new da(n,this._parents,this._name,this._id)}var njt=M(()=>{Is();dd()});function ijt(e){if(e._id!==this._id)throw new Error;for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new da(a,this._parents,this._name,this._id)}var ojt=M(()=>{dd()});function vDe(e){return(e+"").trim().split(/^|\s+/).every(function(t){var r=t.indexOf(".");return r>=0&&(t=t.slice(0,r)),!t||t==="start"})}function xDe(e,t,r){var n,i,o=vDe(t)?NA:Ja;return function(){var a=o(this,e),s=a.on;s!==n&&(i=(n=s).copy()).on(t,r),a.on=i}}function ajt(e,t){var r=this._id;return arguments.length<2?oo(this.node(),r).on.on(e):this.each(xDe(r,e,t))}var sjt=M(()=>{Ls()});function bDe(e){return function(){var t=this.parentNode;for(var r in this.__transition)if(+r!==e)return;t&&t.removeChild(this)}}function ljt(){return this.on("end.remove",bDe(this._id))}var cjt=M(()=>{});function ujt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=C1(e));for(var n=this._groups,i=n.length,o=new Array(i),a=0;a<i;++a)for(var s=n[a],l=s.length,c=o[a]=new Array(l),u,h,f=0;f<l;++f)(u=s[f])&&(h=e.call(u,u.__data__,f,s))&&("__data__"in u&&(h.__data__=u.__data__),c[f]=h,Gg(c[f],t,r,f,c,oo(u,r)));return new da(o,this._parents,t,r)}var hjt=M(()=>{Is();dd();Ls()});function fjt(e){var t=this._name,r=this._id;typeof e!="function"&&(e=vA(e));for(var n=this._groups,i=n.length,o=[],a=[],s=0;s<i;++s)for(var l=n[s],c=l.length,u,h=0;h<c;++h)if(u=l[h]){for(var f=e.call(u,u.__data__,h,l),p,d=oo(u,r),g=0,_=f.length;g<_;++g)(p=f[g])&&Gg(p,t,r,g,f,d);o.push(f),a.push(u)}return new da(o,a,t,r)}var pjt=M(()=>{Is();dd();Ls()});function djt(){return new wDe(this._groups,this._parents)}var wDe,mjt=M(()=>{Is();wDe=fd.prototype.constructor});function SDe(e,t){var r,n,i;return function(){var o=Ug(this,e),a=(this.style.removeProperty(e),Ug(this,e));return o===a?null:o===r&&a===n?i:i=t(r=o,n=a)}}function gjt(e){return function(){this.style.removeProperty(e)}}function MDe(e,t,r){var n,i=r+"",o;return function(){var a=Ug(this,e);return a===i?null:a===n?o:o=t(n=a,r)}}function EDe(e,t,r){var n,i,o;return function(){var a=Ug(this,e),s=r(this),l=s+"";return s==null&&(l=s=(this.style.removeProperty(e),Ug(this,e))),a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s))}}function TDe(e,t){var r,n,i,o="style."+t,a="end."+o,s;return function(){var l=Ja(this,e),c=l.on,u=l.value[o]==null?s||(s=gjt(t)):void 0;(c!==r||i!==u)&&(n=(r=c).copy()).on(a,i=u),l.on=n}}function _jt(e,t,r){var n=(e+="")=="transform"?Wnt:nF;return t==null?this.styleTween(e,SDe(e,n)).on("end.style."+e,gjt(e)):typeof t=="function"?this.styleTween(e,EDe(e,n,cS(this,"style."+e,t))).each(TDe(this._id,e)):this.styleTween(e,MDe(e,n,t),r).on("end.style."+e,null)}var yjt=M(()=>{CA();Is();Ls();DA();tit()});function CDe(e,t,r){return function(n){this.style.setProperty(e,t.call(this,n),r)}}function ADe(e,t,r){var n,i;function o(){var a=t.apply(this,arguments);return a!==i&&(n=(i=a)&&CDe(e,a,r)),n}return o._value=t,o}function vjt(e,t,r){var n="style."+(e+="");if(arguments.length<2)return(n=this.tween(n))&&n._value;if(t==null)return this.tween(n,null);if(typeof t!="function")throw new Error;return this.tween(n,ADe(e,t,r==null?"":r))}var xjt=M(()=>{});function PDe(e){return function(){this.textContent=e}}function IDe(e){return function(){var t=e(this);this.textContent=t==null?"":t}}function bjt(e){return this.tween("text",typeof e=="function"?IDe(cS(this,"text",e)):PDe(e==null?"":e+""))}var wjt=M(()=>{DA()});function LDe(e){return function(t){this.textContent=e.call(this,t)}}function kDe(e){var t,r;function n(){var i=e.apply(this,arguments);return i!==r&&(t=(r=i)&&LDe(i)),t}return n._value=e,n}function Sjt(e){var t="text";if(arguments.length<1)return(t=this.tween(t))&&t._value;if(e==null)return this.tween(t,null);if(typeof e!="function")throw new Error;return this.tween(t,kDe(e))}var Mjt=M(()=>{});function Ejt(){for(var e=this._name,t=this._id,r=iF(),n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)if(l=a[c]){var u=oo(l,t);Gg(l,e,r,c,a,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new da(n,this._parents,e,r)}var Tjt=M(()=>{dd();Ls()});function Cjt(){var e,t,r=this,n=r._id,i=r.size();return new Promise(function(o,a){var s={value:a},l={value:function(){--i===0&&o()}};r.each(function(){var c=Ja(this,n),u=c.on;u!==e&&(t=(e=u).copy(),t._.cancel.push(s),t._.interrupt.push(s),t._.end.push(l)),c.on=t})})}var Ajt=M(()=>{Ls()});function da(e,t,r,n){this._groups=e,this._parents=t,this._name=r,this._id=n}function eit(e){return fd().transition(e)}function iF(){return++RDe}var RDe,uS,dd=M(()=>{Is();jYt();$Yt();ZYt();QYt();ejt();njt();ojt();sjt();cjt();hjt();pjt();mjt();yjt();xjt();wjt();Mjt();Tjt();DA();Ajt();RDe=0;uS=fd.prototype;da.prototype=eit.prototype={constructor:da,select:ujt,selectAll:fjt,filter:rjt,merge:ijt,selection:djt,transition:Ejt,call:uS.call,nodes:uS.nodes,node:uS.node,size:uS.size,empty:uS.empty,each:uS.each,on:ajt,attr:YYt,attrTween:XYt,style:_jt,styleTween:vjt,text:bjt,textTween:Sjt,remove:ljt,tween:WYt,delay:KYt,duration:JYt,ease:tjt,end:Cjt}});function NDe(e,t){for(var r;!(r=e.__transition)||!(r=r[t]);)if(!(e=e.parentNode))return rit.time=lS(),rit;return r}function Pjt(e){var t,r;e instanceof da?(t=e._id,e=e._name):(t=iF(),(r=rit).time=lS(),e=e==null?null:e+"");for(var n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&Gg(l,e,t,c,a,r||NDe(l,t));return new da(n,this._parents,e,t)}var rit,Ijt=M(()=>{dd();Ls();I_();Znt();rit={time:null,delay:0,duration:250,ease:xs}});var Ljt=M(()=>{Is();GYt();Ijt();fd.prototype.interrupt=qYt;fd.prototype.transition=Pjt});var kjt=M(()=>{dd();Ls()});var Rjt=M(()=>{Ljt();dd();kjt();Qnt()});function OA(e){return function(){return e}}var Njt=M(()=>{});function nit(e,t,r){this.target=e,this.type=t,this.transform=r}var Djt=M(()=>{});function Pf(e,t,r){this.k=e,this.x=t,this.y=r}function oF(e){return e.__zoom||hS}var hS,iit=M(()=>{Pf.prototype={constructor:Pf,scale:function(e){return e===1?this:new Pf(this.k*e,this.x,this.y)},translate:function(e,t){return e===0&t===0?this:new Pf(this.k,this.x+this.k*e,this.y+this.k*t)},apply:function(e){return[e[0]*this.k+this.x,e[1]*this.k+this.y]},applyX:function(e){return e*this.k+this.x},applyY:function(e){return e*this.k+this.y},invert:function(e){return[(e[0]-this.x)/this.k,(e[1]-this.y)/this.k]},invertX:function(e){return(e-this.x)/this.k},invertY:function(e){return(e-this.y)/this.k},rescaleX:function(e){return e.copy().domain(e.range().map(this.invertX,this).map(e.invert,e))},rescaleY:function(e){return e.copy().domain(e.range().map(this.invertY,this).map(e.invert,e))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};hS=new Pf(1,0,0);oF.prototype=Pf.prototype});function aF(){Yr.stopImmediatePropagation()}function fS(){Yr.preventDefault(),Yr.stopImmediatePropagation()}var Ojt=M(()=>{Is()});function DDe(){return!Yr.button}function ODe(){var e=this,t,r;return e instanceof SVGElement?(e=e.ownerSVGElement||e,t=e.width.baseVal.value,r=e.height.baseVal.value):(t=e.clientWidth,r=e.clientHeight),[[0,0],[t,r]]}function zjt(){return this.__zoom||hS}function zDe(){return-Yr.deltaY*(Yr.deltaMode?120:1)/500}function FDe(){return"ontouchstart"in this}function BDe(e,t,r){var n=e.invertX(t[0][0])-r[0][0],i=e.invertX(t[1][0])-r[1][0],o=e.invertY(t[0][1])-r[0][1],a=e.invertY(t[1][1])-r[1][1];return e.translate(i>n?(n+i)/2:Math.min(0,n)||Math.max(0,i),a>o?(o+a)/2:Math.min(0,o)||Math.max(0,a))}function Fjt(){var e=DDe,t=ODe,r=BDe,n=zDe,i=FDe,o=[0,1/0],a=[[-1/0,-1/0],[1/0,1/0]],s=250,l=Xnt,c=[],u=yA("start","zoom","end"),h,f,p=500,d=150,g=0;function _(R){R.property("__zoom",zjt).on("wheel.zoom",k).on("mousedown.zoom",O).on("dblclick.zoom",D).filter(i).on("touchstart.zoom",B).on("touchmove.zoom",I).on("touchend.zoom touchcancel.zoom",L).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}_.transform=function(R,F){var z=R.selection?R.selection():R;z.property("__zoom",zjt),R!==z?S(R,F):z.interrupt().each(function(){C(this,arguments).start().zoom(null,typeof F=="function"?F.apply(this,arguments):F).end()})},_.scaleBy=function(R,F){_.scaleTo(R,function(){var z=this.__zoom.k,U=typeof F=="function"?F.apply(this,arguments):F;return z*U})},_.scaleTo=function(R,F){_.transform(R,function(){var z=t.apply(this,arguments),U=this.__zoom,W=b(z),Z=U.invert(W),rt=typeof F=="function"?F.apply(this,arguments):F;return r(x(y(U,rt),W,Z),z,a)})},_.translateBy=function(R,F,z){_.transform(R,function(){return r(this.__zoom.translate(typeof F=="function"?F.apply(this,arguments):F,typeof z=="function"?z.apply(this,arguments):z),t.apply(this,arguments),a)})},_.translateTo=function(R,F,z){_.transform(R,function(){var U=t.apply(this,arguments),W=this.__zoom,Z=b(U);return r(hS.translate(Z[0],Z[1]).scale(W.k).translate(typeof F=="function"?-F.apply(this,arguments):-F,typeof z=="function"?-z.apply(this,arguments):-z),U,a)})};function y(R,F){return F=Math.max(o[0],Math.min(o[1],F)),F===R.k?R:new Pf(F,R.x,R.y)}function x(R,F,z){var U=F[0]-z[0]*R.k,W=F[1]-z[1]*R.k;return U===R.x&&W===R.y?R:new Pf(R.k,U,W)}function b(R){return[(+R[0][0]+ +R[1][0])/2,(+R[0][1]+ +R[1][1])/2]}function S(R,F,z){R.on("start.zoom",function(){C(this,arguments).start()}).on("interrupt.zoom end.zoom",function(){C(this,arguments).end()}).tween("zoom",function(){var U=this,W=arguments,Z=C(U,W),rt=t.apply(U,W),ot=z||b(rt),st=Math.max(rt[1][0]-rt[0][0],rt[1][1]-rt[0][1]),St=U.__zoom,bt=typeof F=="function"?F.apply(U,W):F,Mt=l(St.invert(ot).concat(st/St.k),bt.invert(ot).concat(st/bt.k));return function(lt){if(lt===1)lt=bt;else{var Kt=Mt(lt),_t=st/Kt[2];lt=new Pf(_t,ot[0]-Kt[0]*_t,ot[1]-Kt[1]*_t)}Z.zoom(null,lt)}})}function C(R,F){for(var z=0,U=c.length,W;z<U;++z)if((W=c[z]).that===R)return W;return new P(R,F)}function P(R,F){this.that=R,this.args=F,this.index=-1,this.active=0,this.extent=t.apply(R,F)}P.prototype={start:function(){return++this.active===1&&(this.index=c.push(this)-1,this.emit("start")),this},zoom:function(R,F){return this.mouse&&R!=="mouse"&&(this.mouse[1]=F.invert(this.mouse[0])),this.touch0&&R!=="touch"&&(this.touch0[1]=F.invert(this.touch0[0])),this.touch1&&R!=="touch"&&(this.touch1[1]=F.invert(this.touch1[0])),this.that.__zoom=F,this.emit("zoom"),this},end:function(){return--this.active===0&&(c.splice(this.index,1),this.index=-1,this.emit("end")),this},emit:function(R){Cnt(new nit(_,R,this.that.__zoom),u.apply,u,[R,this.that,this.args])}};function k(){if(!e.apply(this,arguments))return;var R=C(this,arguments),F=this.__zoom,z=Math.max(o[0],Math.min(o[1],F.k*Math.pow(2,n.apply(this,arguments)))),U=iS(this);if(R.wheel)(R.mouse[0][0]!==U[0]||R.mouse[0][1]!==U[1])&&(R.mouse[1]=F.invert(R.mouse[0]=U)),clearTimeout(R.wheel);else{if(F.k===z)return;R.mouse=[U,F.invert(U)],P1(this),R.start()}fS(),R.wheel=setTimeout(W,d),R.zoom("mouse",r(x(y(F,z),R.mouse[0],R.mouse[1]),R.extent,a));function W(){R.wheel=null,R.end()}}function O(){if(f||!e.apply(this,arguments))return;var R=C(this,arguments),F=pd(Yr.view).on("mousemove.zoom",Z,!0).on("mouseup.zoom",rt,!0),z=iS(this),U=Yr.clientX,W=Yr.clientY;Lnt(Yr.view),aF(),R.mouse=[z,this.__zoom.invert(z)],P1(this),R.start();function Z(){if(fS(),!R.moved){var ot=Yr.clientX-U,st=Yr.clientY-W;R.moved=ot*ot+st*st>g}R.zoom("mouse",r(x(R.that.__zoom,R.mouse[0]=iS(R.that),R.mouse[1]),R.extent,a))}function rt(){F.on("mousemove.zoom mouseup.zoom",null),knt(Yr.view,R.moved),fS(),R.end()}}function D(){if(!!e.apply(this,arguments)){var R=this.__zoom,F=iS(this),z=R.invert(F),U=R.k*(Yr.shiftKey?.5:2),W=r(x(y(R,U),F,z),t.apply(this,arguments),a);fS(),s>0?pd(this).transition().duration(s).call(S,W,F):pd(this).call(_.transform,W)}}function B(){if(!!e.apply(this,arguments)){var R=C(this,arguments),F=Yr.changedTouches,z,U=F.length,W,Z,rt;for(aF(),W=0;W<U;++W)Z=F[W],rt=Bz(this,F,Z.identifier),rt=[rt,this.__zoom.invert(rt),Z.identifier],R.touch0?R.touch1||(R.touch1=rt):(R.touch0=rt,z=!0);if(h&&(h=clearTimeout(h),!R.touch1)){R.end(),rt=pd(this).on("dblclick.zoom"),rt&&rt.apply(this,arguments);return}z&&(h=setTimeout(function(){h=null},p),P1(this),R.start())}}function I(){var R=C(this,arguments),F=Yr.changedTouches,z=F.length,U,W,Z,rt;for(fS(),h&&(h=clearTimeout(h)),U=0;U<z;++U)W=F[U],Z=Bz(this,F,W.identifier),R.touch0&&R.touch0[2]===W.identifier?R.touch0[0]=Z:R.touch1&&R.touch1[2]===W.identifier&&(R.touch1[0]=Z);if(W=R.that.__zoom,R.touch1){var ot=R.touch0[0],st=R.touch0[1],St=R.touch1[0],bt=R.touch1[1],Mt=(Mt=St[0]-ot[0])*Mt+(Mt=St[1]-ot[1])*Mt,lt=(lt=bt[0]-st[0])*lt+(lt=bt[1]-st[1])*lt;W=y(W,Math.sqrt(Mt/lt)),Z=[(ot[0]+St[0])/2,(ot[1]+St[1])/2],rt=[(st[0]+bt[0])/2,(st[1]+bt[1])/2]}else if(R.touch0)Z=R.touch0[0],rt=R.touch0[1];else return;R.zoom("touch",r(x(W,Z,rt),R.extent,a))}function L(){var R=C(this,arguments),F=Yr.changedTouches,z=F.length,U,W;for(aF(),f&&clearTimeout(f),f=setTimeout(function(){f=null},p),U=0;U<z;++U)W=F[U],R.touch0&&R.touch0[2]===W.identifier?delete R.touch0:R.touch1&&R.touch1[2]===W.identifier&&delete R.touch1;R.touch1&&!R.touch0&&(R.touch0=R.touch1,delete R.touch1),R.touch0?R.touch0[1]=this.__zoom.invert(R.touch0[0]):R.end()}return _.wheelDelta=function(R){return arguments.length?(n=typeof R=="function"?R:OA(+R),_):n},_.filter=function(R){return arguments.length?(e=typeof R=="function"?R:OA(!!R),_):e},_.touchable=function(R){return arguments.length?(i=typeof R=="function"?R:OA(!!R),_):i},_.extent=function(R){return arguments.length?(t=typeof R=="function"?R:OA([[+R[0][0],+R[0][1]],[+R[1][0],+R[1][1]]]),_):t},_.scaleExtent=function(R){return arguments.length?(o[0]=+R[0],o[1]=+R[1],_):[o[0],o[1]]},_.translateExtent=function(R){return arguments.length?(a[0][0]=+R[0][0],a[1][0]=+R[1][0],a[0][1]=+R[0][1],a[1][1]=+R[1][1],_):[[a[0][0],a[0][1]],[a[1][0],a[1][1]]]},_.constrain=function(R){return arguments.length?(r=R,_):r},_.duration=function(R){return arguments.length?(s=+R,_):s},_.interpolate=function(R){return arguments.length?(l=R,_):l},_.on=function(){var R=u.on.apply(u,arguments);return R===u?_:R},_.clickDistance=function(R){return arguments.length?(g=(R=+R)*R,_):Math.sqrt(g)},_}var Bjt=M(()=>{gnt();iYt();CA();Is();Rjt();Njt();Djt();iit();Ojt()});var Hjt=M(()=>{Bjt();iit()});var Mr={};Ks(Mr,{active:()=>uGt,arc:()=>hFt,area:()=>x7,areaRadial:()=>Ret,ascending:()=>_c,axisBottom:()=>YMt,axisLeft:()=>jMt,axisRight:()=>WMt,axisTop:()=>GMt,bisect:()=>aR,bisectLeft:()=>rMt,bisectRight:()=>b$,bisector:()=>oR,brush:()=>pCt,brushSelection:()=>uCt,brushX:()=>hCt,brushY:()=>fCt,chord:()=>zCt,clientPoint:()=>Dg,cluster:()=>BLt,color:()=>x2,create:()=>$zt,creator:()=>Ng,cross:()=>iMt,csv:()=>lNt,csvFormat:()=>pPt,csvFormatRows:()=>dPt,csvParse:()=>hPt,csvParseRows:()=>fPt,cubehelix:()=>cN,curveBasis:()=>LFt,curveBasisClosed:()=>RFt,curveBasisOpen:()=>OFt,curveBundle:()=>BFt,curveCardinal:()=>VFt,curveCardinalClosed:()=>UFt,curveCardinalOpen:()=>qFt,curveCatmullRom:()=>WFt,curveCatmullRomClosed:()=>jFt,curveCatmullRomOpen:()=>KFt,curveLinear:()=>Fg,curveLinearClosed:()=>QFt,curveMonotoneX:()=>aBt,curveMonotoneY:()=>sBt,curveNatural:()=>hBt,curveStep:()=>pBt,curveStepAfter:()=>mBt,curveStepBefore:()=>dBt,customEvent:()=>qzt,descending:()=>aMt,deviation:()=>lR,dispatch:()=>CAt,drag:()=>aPt,dragDisable:()=>MN,dragEnable:()=>EN,dsvFormat:()=>w2,easeBack:()=>zZ,easeBackIn:()=>jPt,easeBackInOut:()=>zZ,easeBackOut:()=>XPt,easeBounce:()=>S2,easeBounceIn:()=>GPt,easeBounceInOut:()=>WPt,easeBounceOut:()=>S2,easeCircle:()=>NZ,easeCircleIn:()=>VPt,easeCircleInOut:()=>NZ,easeCircleOut:()=>UPt,easeCubic:()=>PZ,easeCubicIn:()=>CPt,easeCubicInOut:()=>PZ,easeCubicOut:()=>APt,easeElastic:()=>HZ,easeElasticIn:()=>KPt,easeElasticInOut:()=>ZPt,easeElasticOut:()=>HZ,easeExp:()=>RZ,easeExpIn:()=>FPt,easeExpInOut:()=>RZ,easeExpOut:()=>BPt,easeLinear:()=>wPt,easePoly:()=>LZ,easePolyIn:()=>IPt,easePolyInOut:()=>LZ,easePolyOut:()=>LPt,easeQuad:()=>AZ,easeQuadIn:()=>MPt,easeQuadInOut:()=>AZ,easeQuadOut:()=>EPt,easeSin:()=>kZ,easeSinIn:()=>DPt,easeSinInOut:()=>kZ,easeSinOut:()=>OPt,entries:()=>aAt,event:()=>Pu,extent:()=>cR,forceCenter:()=>t6t,forceCollide:()=>R6t,forceLink:()=>U6t,forceManyBody:()=>nIt,forceRadial:()=>oIt,forceSimulation:()=>rIt,forceX:()=>sIt,forceY:()=>cIt,format:()=>nJ,formatDefaultLocale:()=>GN,formatLocale:()=>UN,formatPrefix:()=>iJ,formatSpecifier:()=>Ly,geoAlbers:()=>ND,geoAlbersUsa:()=>dLt,geoArea:()=>zIt,geoAzimuthalEqualArea:()=>gLt,geoAzimuthalEqualAreaRaw:()=>OD,geoAzimuthalEquidistant:()=>yLt,geoAzimuthalEquidistantRaw:()=>zD,geoBounds:()=>WIt,geoCentroid:()=>JIt,geoCircle:()=>o9t,geoClipAntimeridian:()=>OT,geoClipCircle:()=>gD,geoClipExtent:()=>A9t,geoClipRectangle:()=>Qp,geoConicConformal:()=>bLt,geoConicConformalRaw:()=>pQ,geoConicEqualArea:()=>Uy,geoConicEqualAreaRaw:()=>uQ,geoConicEquidistant:()=>MLt,geoConicEquidistantRaw:()=>mQ,geoContains:()=>O9t,geoDistance:()=>By,geoEquirectangular:()=>SLt,geoEquirectangularRaw:()=>Gy,geoGnomonic:()=>TLt,geoGnomonicRaw:()=>HD,geoGraticule:()=>wD,geoGraticule10:()=>H9t,geoIdentity:()=>ALt,geoInterpolate:()=>U9t,geoLength:()=>xD,geoMercator:()=>xLt,geoMercatorRaw:()=>qy,geoNaturalEarth1:()=>ILt,geoNaturalEarth1Raw:()=>UD,geoOrthographic:()=>kLt,geoOrthographicRaw:()=>qD,geoPath:()=>sLt,geoProjection:()=>eo,geoProjectionMutator:()=>WT,geoRotation:()=>sD,geoStereographic:()=>NLt,geoStereographicRaw:()=>GD,geoStream:()=>Mo,geoTransform:()=>cLt,geoTransverseMercator:()=>OLt,geoTransverseMercatorRaw:()=>WD,hcl:()=>oZ,hierarchy:()=>YT,histogram:()=>mMt,hsl:()=>JK,html:()=>tNt,interpolate:()=>Z2,interpolateArray:()=>hO,interpolateBasis:()=>lO,interpolateBasisClosed:()=>uO,interpolateCool:()=>x7t,interpolateCubehelix:()=>F8t,interpolateCubehelixDefault:()=>_7t,interpolateCubehelixLong:()=>B8t,interpolateDate:()=>pO,interpolateHcl:()=>N8t,interpolateHclLong:()=>D8t,interpolateHsl:()=>P8t,interpolateHslLong:()=>I8t,interpolateInferno:()=>E7t,interpolateLab:()=>KQ,interpolateMagma:()=>M7t,interpolateNumber:()=>As,interpolateObject:()=>dO,interpolatePlasma:()=>T7t,interpolateRainbow:()=>b7t,interpolateRgb:()=>tC,interpolateRgbBasis:()=>u8t,interpolateRgbBasisClosed:()=>h8t,interpolateRound:()=>f8t,interpolateString:()=>mO,interpolateTransformCss:()=>b8t,interpolateTransformSvg:()=>w8t,interpolateViridis:()=>S7t,interpolateWarm:()=>v7t,interpolateZoom:()=>T8t,interrupt:()=>pz,interval:()=>xVt,isoFormat:()=>hVt,isoParse:()=>fVt,json:()=>rNt,keys:()=>rAt,lab:()=>sN,line:()=>Rw,lineRadial:()=>Let,linkHorizontal:()=>wFt,linkRadial:()=>MFt,linkVertical:()=>SFt,local:()=>d7,map:()=>by,matcher:()=>c7,max:()=>bMt,mean:()=>SMt,median:()=>EMt,merge:()=>CMt,min:()=>dR,mouse:()=>Jzt,namespace:()=>Mw,namespaces:()=>MC,nest:()=>ZCt,now:()=>Yw,pack:()=>bkt,packEnclose:()=>XD,packSiblings:()=>_kt,pairs:()=>nMt,partition:()=>Skt,path:()=>W8t,permute:()=>PMt,pie:()=>yFt,pointRadial:()=>f1,polygonArea:()=>X8t,polygonCentroid:()=>K8t,polygonContains:()=>nRt,polygonHull:()=>eRt,polygonLength:()=>oRt,precisionFixed:()=>SIt,precisionPrefix:()=>EIt,precisionRound:()=>CIt,quadtree:()=>vO,quantile:()=>dy,quantize:()=>V8t,queue:()=>bO,radialArea:()=>Ret,radialLine:()=>Let,randomBates:()=>$Rt,randomExponential:()=>ZRt,randomIrwinHall:()=>SO,randomLogNormal:()=>jRt,randomNormal:()=>wO,randomUniform:()=>WRt,range:()=>uR,request:()=>J2,rgb:()=>ZK,ribbon:()=>WCt,scaleBand:()=>lC,scaleIdentity:()=>UO,scaleImplicit:()=>LO,scaleLinear:()=>VO,scaleLog:()=>GO,scaleOrdinal:()=>nw,scalePoint:()=>VNt,scalePow:()=>gC,scaleQuantile:()=>WO,scaleQuantize:()=>YO,scaleSequential:()=>n7,scaleSqrt:()=>eOt,scaleThreshold:()=>jO,scaleTime:()=>a7t,scaleUtc:()=>s7t,scan:()=>LMt,schemeCategory10:()=>c7t,schemeCategory20:()=>m7t,schemeCategory20b:()=>h7t,schemeCategory20c:()=>p7t,select:()=>p7,selectAll:()=>tFt,selection:()=>Xzt,selector:()=>Ew,selectorAll:()=>l7,set:()=>tAt,shuffle:()=>RMt,stack:()=>_Bt,stackOffsetDiverging:()=>bBt,stackOffsetExpand:()=>vBt,stackOffsetNone:()=>Ru,stackOffsetSilhouette:()=>SBt,stackOffsetWiggle:()=>EBt,stackOrderAscending:()=>N7,stackOrderDescending:()=>CBt,stackOrderInsideOut:()=>PBt,stackOrderNone:()=>Nu,stackOrderReverse:()=>LBt,stratify:()=>Ckt,style:()=>yet,sum:()=>DMt,symbol:()=>PFt,symbolCircle:()=>kC,symbolCross:()=>w7,symbolDiamond:()=>S7,symbolSquare:()=>E7,symbolStar:()=>M7,symbolTriangle:()=>T7,symbolWye:()=>C7,symbols:()=>AFt,text:()=>iNt,thresholdFreedmanDiaconis:()=>_Mt,thresholdScott:()=>vMt,thresholdSturges:()=>fR,tickIncrement:()=>R$,tickStep:()=>hR,ticks:()=>dMt,timeDay:()=>YBt,timeDays:()=>jBt,timeFormat:()=>Srt,timeFormatDefaultLocale:()=>j7,timeFormatLocale:()=>WC,timeFriday:()=>art,timeFridays:()=>QBt,timeHour:()=>UBt,timeHours:()=>qBt,timeInterval:()=>Sr,timeMillisecond:()=>Jet,timeMilliseconds:()=>Qet,timeMinute:()=>FBt,timeMinutes:()=>BBt,timeMonday:()=>rrt,timeMondays:()=>$Bt,timeMonth:()=>nHt,timeMonths:()=>iHt,timeParse:()=>Mrt,timeSaturday:()=>srt,timeSaturdays:()=>tHt,timeSecond:()=>trt,timeSeconds:()=>ert,timeSunday:()=>B7,timeSundays:()=>lrt,timeThursday:()=>ort,timeThursdays:()=>JBt,timeTuesday:()=>nrt,timeTuesdays:()=>KBt,timeWednesday:()=>irt,timeWednesdays:()=>ZBt,timeWeek:()=>B7,timeWeeks:()=>lrt,timeYear:()=>aHt,timeYears:()=>sHt,timeout:()=>yVt,timer:()=>Art,timerFlush:()=>Prt,touch:()=>rFt,touches:()=>iFt,transition:()=>Ez,transpose:()=>mR,tree:()=>Pkt,treemap:()=>Lkt,treemapBinary:()=>Rkt,treemapDice:()=>lf,treemapResquarify:()=>zkt,treemapSlice:()=>wg,treemapSliceDice:()=>Dkt,treemapSquarify:()=>QD,tsv:()=>uNt,tsvFormat:()=>yPt,tsvFormatRows:()=>vPt,tsvParse:()=>gPt,tsvParseRows:()=>_Pt,utcDay:()=>yHt,utcDays:()=>vHt,utcFormat:()=>YC,utcFriday:()=>drt,utcFridays:()=>EHt,utcHour:()=>dHt,utcHours:()=>mHt,utcMillisecond:()=>Jet,utcMilliseconds:()=>Qet,utcMinute:()=>uHt,utcMinutes:()=>hHt,utcMonday:()=>urt,utcMondays:()=>bHt,utcMonth:()=>PHt,utcMonths:()=>IHt,utcParse:()=>jC,utcSaturday:()=>mrt,utcSaturdays:()=>THt,utcSecond:()=>trt,utcSeconds:()=>ert,utcSunday:()=>H7,utcSundays:()=>grt,utcThursday:()=>prt,utcThursdays:()=>MHt,utcTuesday:()=>hrt,utcTuesdays:()=>wHt,utcWednesday:()=>frt,utcWednesdays:()=>SHt,utcWeek:()=>H7,utcWeeks:()=>grt,utcYear:()=>kHt,utcYears:()=>RHt,values:()=>iAt,variance:()=>sR,version:()=>Q3t,voronoi:()=>IGt,window:()=>Cw,xml:()=>aNt,zip:()=>zMt,zoom:()=>Fjt,zoomIdentity:()=>hS,zoomTransform:()=>oF});var Er=M(()=>{tMt();BMt();$Mt();mCt();jCt();lAt();MAt();PAt();lPt();bPt();QPt();hIt();PIt();FLt();Bkt();q8t();j8t();sRt();BRt();GRt();QRt();fNt();P7t();aFt();RBt();DHt();dVt();wVt();fGt();kGt();Hjt()});var Gjt=H(qjt=>{"use strict";Object.defineProperty(qjt,"__esModule",{value:!0});var Vjt=(Er(),Ut(Mr)),Wg=Vjt,Ujt=Vjt;function HDe(e,t){return e.each(function(){var r=t.apply(this,arguments),n=Wg.select(this);for(var i in r)n.attr(i,r[i])})}function VDe(e,t){for(var r in t)e.attr(r,t[r]);return e}function UDe(e){return(typeof e=="function"?HDe:VDe)(this,e)}function qDe(e,t,r){return e.each(function(){var n=t.apply(this,arguments),i=Wg.select(this);for(var o in n)i.style(o,n[o],r)})}function GDe(e,t,r){for(var n in t)e.style(n,t[n],r);return e}function WDe(e,t){return(typeof e=="function"?qDe:GDe)(this,e,t==null?"":t)}function YDe(e,t){return e.each(function(){var r=t.apply(this,arguments),n=Wg.select(this);for(var i in r)n.property(i,r[i])})}function jDe(e,t){for(var r in t)e.property(r,t[r]);return e}function XDe(e){return(typeof e=="function"?YDe:jDe)(this,e)}function $De(e,t){return e.each(function(){var r=t.apply(this,arguments),n=Wg.select(this).transition(e);for(var i in r)n.attr(i,r[i])})}function KDe(e,t){for(var r in t)e.attr(r,t[r]);return e}function ZDe(e){return(typeof e=="function"?$De:KDe)(this,e)}function JDe(e,t,r){return e.each(function(){var n=t.apply(this,arguments),i=Wg.select(this).transition(e);for(var o in n)i.style(o,n[o],r)})}function QDe(e,t,r){for(var n in t)e.style(n,t[n],r);return e}function tOe(e,t){return(typeof e=="function"?JDe:QDe)(this,e,t==null?"":t)}Wg.selection.prototype.attrs=UDe;Wg.selection.prototype.styles=WDe;Wg.selection.prototype.properties=XDe;Ujt.transition.prototype.attrs=ZDe;Ujt.transition.prototype.styles=tOe});var Yg=H(oit=>{"use strict";Object.defineProperty(oit,"__esModule",{value:!0});var Wjt=(Er(),Ut(Mr));function eOe(e){if(e.attrs==null)if(e.nodes==null){var t=[];return e.each(function(){t.push(this)}),Wjt.selectAll(t)}else return Wjt.selectAll(e.nodes());else return e}oit.coerceExternalD3=eOe});var If=H(ait=>{"use strict";Object.defineProperty(ait,"__esModule",{value:!0});function rOe(e){return e.reduce(function(t,r){return t[r]=r,t},{})}ait.makeEnum=rOe});var jjt=H(sF=>{"use strict";Object.defineProperty(sF,"__esModule",{value:!0});var dr=(I_(),Ut(N1t)),nOe=Yg(),iOe=If(),Yjt={linear:dr.easeLinear,quad:dr.easeQuad,quadIn:dr.easeQuadIn,quadOut:dr.easeQuadOut,quadInOut:dr.easeQuadInOut,cubic:dr.easeCubic,cubicIn:dr.easeCubicIn,cubicOut:dr.easeCubicOut,cubicInOut:dr.easeCubicInOut,poly:dr.easePoly,polyIn:dr.easePolyIn,polyOut:dr.easePolyOut,polyInOut:dr.easePolyInOut,sin:dr.easeSin,sinIn:dr.easeSinIn,sinOut:dr.easeSinOut,sinInOut:dr.easeSinInOut,exp:dr.easeExp,expIn:dr.easeExpIn,expOut:dr.easeExpOut,expInOut:dr.easeExpInOut,circle:dr.easeCircle,circleIn:dr.easeCircleIn,circleOut:dr.easeCircleOut,circleInOut:dr.easeCircleInOut,bounce:dr.easeBounce,bounceIn:dr.easeBounceIn,bounceOut:dr.easeBounceOut,bounceInOut:dr.easeBounceInOut,back:dr.easeBack,backIn:dr.easeBackIn,backOut:dr.easeBackOut,backInOut:dr.easeBackInOut,elastic:dr.easeElastic,elasticIn:dr.easeElasticIn,elasticOut:dr.easeElasticOut,elasticInOut:dr.easeElasticInOut};sF.EaseName=iOe.makeEnum(["linear","quad","quadIn","quadOut","quadInOut","cubic","cubicIn","cubicOut","cubicInOut","poly","polyIn","polyOut","polyInOut","sin","sinIn","sinOut","sinInOut","exp","expIn","expOut","expInOut","circle","circleIn","circleOut","circleInOut","bounce","bounceIn","bounceOut","bounceInOut","back","backIn","backOut","backInOut","elastic","elasticIn","elasticOut","elasticInOut"]);var oOe=function(){function e(){this._startDelay=e._DEFAULT_START_DELAY_MILLISECONDS,this._stepDuration=e._DEFAULT_STEP_DURATION_MILLISECONDS,this._stepDelay=e._DEFAULT_ITERATIVE_DELAY_MILLISECONDS,this._maxTotalDuration=e._DEFAULT_MAX_TOTAL_DURATION_MILLISECONDS,this._easingMode=e._DEFAULT_EASING_MODE}return e.prototype.totalTime=function(t){var r=this._getAdjustedIterativeDelay(t);return this.startDelay()+r*Math.max(t-1,0)+this.stepDuration()},e.prototype.animate=function(t,r){var n=this;t=nOe.coerceExternalD3(t);var i=t.size(),o=this._getAdjustedIterativeDelay(i);return t.transition().ease(this._getEaseFactory()).duration(this.stepDuration()).delay(function(a,s){return n.startDelay()+o*s}).attrs(r)},e.prototype.startDelay=function(t){return t==null?this._startDelay:(this._startDelay=t,this)},e.prototype.stepDuration=function(t){return t==null?Math.min(this._stepDuration,this._maxTotalDuration):(this._stepDuration=t,this)},e.prototype.stepDelay=function(t){return t==null?this._stepDelay:(this._stepDelay=t,this)},e.prototype.maxTotalDuration=function(t){return t==null?this._maxTotalDuration:(this._maxTotalDuration=t,this)},e.prototype.easingMode=function(t){return t==null?this._easingMode:(this._easingMode=t,this)},e.prototype._getEaseFactory=function(){var t=this.easingMode();if(typeof t=="string"){var r=Yjt[t];return r==null?Yjt.linear:r}else return t},e.prototype._getAdjustedIterativeDelay=function(t){var r=this.maxTotalDuration()-this.stepDuration();r=Math.max(r,0);var n=r/Math.max(t-1,1);return Math.min(this.stepDelay(),n)},e._DEFAULT_START_DELAY_MILLISECONDS=0,e._DEFAULT_STEP_DURATION_MILLISECONDS=300,e._DEFAULT_ITERATIVE_DELAY_MILLISECONDS=15,e._DEFAULT_MAX_TOTAL_DURATION_MILLISECONDS=1/0,e._DEFAULT_EASING_MODE="expOut",e}();sF.Easing=oOe});var Xjt=H(sit=>{"use strict";Object.defineProperty(sit,"__esModule",{value:!0});var aOe=Yg(),sOe=function(){function e(){}return e.prototype.totalTime=function(t){return 0},e.prototype.animate=function(t,r){return t=aOe.coerceExternalD3(t),t.attrs(r)},e}();sit.Null=sOe});var Lf=H(lF=>{"use strict";Object.defineProperty(lF,"__esModule",{value:!0});var $jt=(de(),Ut(pe));$jt.__exportStar(jjt(),lF);$jt.__exportStar(Xjt(),lF)});var Kjt=H(lit=>{"use strict";Object.defineProperty(lit,"__esModule",{value:!0});var lOe=function(){function e(t){this.cache={},this.compute=t}return e.prototype.get=function(t){return this.cache.hasOwnProperty(t)||(this.cache[t]=this.compute(t)),this.cache[t]},e.prototype.clear=function(){return this.cache={},this},e}();lit.Cache=lOe});var Zjt=H(cit=>{"use strict";Object.defineProperty(cit,"__esModule",{value:!0});var cOe=function(){function e(){}return e.arrayEq=function(t,r){if(t==null||r==null)return t===r;if(t.length!==r.length)return!1;for(var n=0;n<t.length;n++)if(t[n]!==r[n])return!1;return!0},e.objEq=function(t,r){if(t==null||r==null)return t===r;var n=Object.keys(t).sort(),i=Object.keys(r).sort(),o=n.map(function(s){return t[s]}),a=i.map(function(s){return r[s]});return e.arrayEq(n,i)&&e.arrayEq(o,a)},e.strictEq=function(t,r){return t===r},e.defaults=function(t){for(var r=[],n=1;n<arguments.length;n++)r[n-1]=arguments[n];if(t==null)throw new TypeError("Cannot convert undefined or null to object");var i=Object(t);return r.forEach(function(o){if(o!=null)for(var a in o)Object.prototype.hasOwnProperty.call(o,a)&&(i[a]=o[a])}),i},e}();cit.Methods=cOe});var Jjt=H(uit=>{"use strict";Object.defineProperty(uit,"__esModule",{value:!0});var uOe=function(){function e(){}return e.combineWhitespace=function(t){return t.replace(/[ \t]+/g," ")},e.isNotEmptyString=function(t){return t&&t.trim()!==""},e.trimStart=function(t,r){if(!t)return t;var n=t.split(""),i=r?function(o){return o.split(r).some(e.isNotEmptyString)}:e.isNotEmptyString;return n.reduce(function(o,a){return i(o+a)?o+a:o},"")},e.trimEnd=function(t,r){if(!t)return t;var n=t.split("");return n.reverse(),n=e.trimStart(n.join(""),r).split(""),n.reverse(),n.join("")},e}();uit.StringMethods=uOe});var Qjt=H(hit=>{"use strict";Object.defineProperty(hit,"__esModule",{value:!0});var hOe=function(){function e(){this.WordDividerRegExp=new RegExp("\\W"),this.WhitespaceRegExp=new RegExp("\\s")}return e.prototype.tokenize=function(t){var r=this;return t.split("").reduce(function(n,i){return n.slice(0,-1).concat(r.shouldCreateNewToken(n[n.length-1],i))},[""])},e.prototype.shouldCreateNewToken=function(t,r){if(!t)return[r];var n=t[t.length-1];return this.WhitespaceRegExp.test(n)&&this.WhitespaceRegExp.test(r)?[t+r]:this.WhitespaceRegExp.test(n)||this.WhitespaceRegExp.test(r)?[t,r]:this.WordDividerRegExp.test(n)?n===r?[t+r]:[t,r]:[t+r]},e}();hit.Tokenizer=hOe});var pS=H(cF=>{"use strict";function uF(e){for(var t in e)cF.hasOwnProperty(t)||(cF[t]=e[t])}Object.defineProperty(cF,"__esModule",{value:!0});uF(Kjt());uF(Zjt());uF(Jjt());uF(Qjt())});var eXt=H(fit=>{"use strict";Object.defineProperty(fit,"__esModule",{value:!0});var tXt=pS(),fOe={textRotation:0,textShear:0,xAlign:"left",yAlign:"top"},hF=function(){function e(t,r,n){this._measurer=t,this._penFactory=r,this._wrapper=n}return e.prototype.measurer=function(t){return this._measurer=t,this},e.prototype.wrapper=function(t){return this._wrapper=t,this},e.prototype.penFactory=function(t){return this._penFactory=t,this},e.prototype.write=function(t,r,n,i,o){if(i===void 0&&(i={}),i=tXt.Methods.defaults({},fOe,i),e.SupportedRotation.indexOf(i.textRotation)===-1)throw new Error("unsupported rotation - "+i.textRotation+". Supported rotations are "+e.SupportedRotation.join(", "));if(i.textShear!=null&&i.textShear<-80||i.textShear>80)throw new Error("unsupported shear angle - "+i.textShear+". Must be between -80 and 80");var a=Math.abs(Math.abs(i.textRotation)-90)>45,s=a?r:n,l=a?n:r,c=i.textShear,u=c*Math.PI/180,h=this._measurer.measure().height,f=h*Math.tan(u),p=s/Math.cos(u)-Math.abs(f),d=l*Math.cos(u),g=tXt.StringMethods.combineWhitespace(t),_=this._wrapper?this._wrapper.wrap(g,this._measurer,p,d).wrappedText:g,y=_.split(`
`),x=e.XOffsetFactor[i.xAlign]*p*Math.sin(u),b=e.YOffsetFactor[i.yAlign]*(d-y.length*h),S=x-b,C=[0,0],P=i.textRotation+c;switch(i.textRotation){case 90:C=[r+S,0];break;case-90:C=[-S,n];break;case 180:C=[r,n+S];break;default:C=[0,-S];break}var k=this._penFactory.createPen(t,{translate:C,rotate:P},o);this.writeLines(y,k,p,h,f,i.xAlign),k.destroy!=null&&k.destroy()},e.prototype.writeLines=function(t,r,n,i,o,a){t.forEach(function(s,l){var c=o>0?(l+1)*o:l*o;r.write(s,n,a,c,(l+1)*i)})},e}();hF.XOffsetFactor={center:.5,left:0,right:1};hF.YOffsetFactor={bottom:1,center:.5,top:0};hF.SupportedRotation=[-90,0,180,90];fit.Writer=hF});var zA=H(fF=>{"use strict";function pOe(e){for(var t in e)fF.hasOwnProperty(t)||(fF[t]=e[t])}Object.defineProperty(fF,"__esModule",{value:!0});pOe(eXt())});var pit=H(pF=>{"use strict";Object.defineProperty(pF,"__esModule",{value:!0});var FA=function(){function e(){}return e.append=function(t,r){for(var n=[],i=2;i<arguments.length;i++)n[i-2]=arguments[i];var o=e.create.apply(e,[r].concat(n));return t.appendChild(o),o},e.create=function(t){for(var r=[],n=1;n<arguments.length;n++)r[n-1]=arguments[n];var i=document.createElement(t);return e.addClasses.apply(e,[i].concat(r)),i},e.addClasses=function(t){for(var r=[],n=1;n<arguments.length;n++)r[n-1]=arguments[n];r=r.filter(function(i){return i!=null}),t.classList!=null?r.forEach(function(i){t.classList.add(i)}):t.setAttribute("class",r.join(" "))},e.getDimensions=function(t){if(t.getBoundingClientRect)try{var r=t.getBoundingClientRect(),n=r.width,i=r.height;return{width:n,height:i}}catch(o){}return{height:0,width:0}},e}();pF.HtmlUtils=FA;var dOe=function(){function e(t,r,n){n===void 0&&(n=!1);var i=this;this.element=t,this.className=r,this.addTitle=n,this.createRuler=function(){return function(o){var a=FA.append(i.element,"span","text-tmp",i.className);a.textContent=o;var s=FA.getDimensions(a);return i.element.removeChild(a),s}},this.createPen=function(o,a,s){s==null&&(s=i.element);var l=FA.append(s,"div","text-block",i.className);return l.style.position="relative",l.style.transform="translate(0, -1em) "+("translate("+a.translate[0]+"px, "+a.translate[1]+"px) ")+("rotate("+a.rotate+"deg)"),l.style.transformOrigin="0 1.2em",i.addTitle&&l.setAttribute("title",o),i.createHtmlLinePen(l)}}return e.prototype.setAddTitle=function(t){this.addTitle=t},e.prototype.createHtmlLinePen=function(t){return{write:function(r,n,i,o,a){var s=FA.append(t,"div","text-line");s.textContent=r,s.style.width=n+"px",s.style.textAlign=i,s.style.position="absolute",s.style.whiteSpace="nowrap",s.style.top=a+"px",s.style.left=o+"px"}}},e}();pF.HtmlContext=dOe});var iXt=H(dF=>{"use strict";Object.defineProperty(dF,"__esModule",{value:!0});var mOe=zA(),rXt=pit(),jg=function(){function e(){}return e.append=function(t,r){for(var n=[],i=2;i<arguments.length;i++)n[i-2]=arguments[i];var o=e.create.apply(e,[r].concat(n));return t.appendChild(o),o},e.create=function(t){for(var r=[],n=1;n<arguments.length;n++)r[n-1]=arguments[n];var i=document.createElementNS(e.SVG_NS,t);return rXt.HtmlUtils.addClasses.apply(rXt.HtmlUtils,[i].concat(r)),i},e.getDimensions=function(t){if(t.getBBox)try{var r=t.getBBox(),n=r.width,i=r.height;return{width:n,height:i}}catch(o){}return{height:0,width:0}},e}();jg.SVG_NS="http://www.w3.org/2000/svg";dF.SvgUtils=jg;var nXt=function(){function e(t,r,n){n===void 0&&(n=!1);var i=this;this.element=t,this.className=r,this.addTitleElement=n,this.createRuler=function(){var o=i.getTextElements(i.element),a=o.parentElement,s=o.containerElement,l=o.textElement;return function(c){a.appendChild(s),l.textContent=c;var u=jg.getDimensions(l);return a.removeChild(s),u}},this.createPen=function(o,a,s){s==null&&(s=i.element);var l=jg.append(s,"g","text-container",i.className);i.addTitleElement&&(jg.append(l,"title").textContent=o,l.setAttribute("title",o));var c=jg.append(l,"g","text-area");return c.setAttribute("transform","translate("+a.translate[0]+","+a.translate[1]+")"+("rotate("+a.rotate+")")),i.createSvgLinePen(c)}}return e.prototype.setAddTitleElement=function(t){this.addTitleElement=t},e.prototype.createSvgLinePen=function(t){return{write:function(r,n,i,o,a){o+=n*mOe.Writer.XOffsetFactor[i];var s=jg.append(t,"text","text-line");s.textContent=r,s.setAttribute("text-anchor",e.AnchorMap[i]),s.setAttribute("transform","translate("+o+","+a+")"),s.setAttribute("y","-0.25em")}}},e.prototype.getTextElements=function(t){if(t.tagName==="text"){var r=t.parentElement;return r==null&&(r=t.parentNode),r.removeChild(t),{containerElement:t,parentElement:r,textElement:t}}var n=t.querySelector("text");if(n!=null){var r=n.parentElement;return r==null&&(r=n.parentNode),r.removeChild(n),{containerElement:n,parentElement:r,textElement:n}}var i=jg.create("text",this.className);return{containerElement:i,parentElement:t,textElement:i}},e}();nXt.AnchorMap={center:"middle",left:"start",right:"end"};dF.SvgContext=nXt});var oXt=H(dit=>{"use strict";Object.defineProperty(dit,"__esModule",{value:!0});var gOe=zA(),_Oe="#444",yOe=function(){function e(t,r,n){r===void 0&&(r=10),n===void 0&&(n={});var i=this;this.ctx=t,this.lineHeight=r,this.style=n,this.createRuler=function(){return function(o){i.ctx.font=i.style.font;var a=i.ctx.measureText(o).width;return{width:a,height:i.lineHeight}}},this.createPen=function(o,a,s){return s==null&&(s=i.ctx),s.save(),s.translate(a.translate[0],a.translate[1]),s.rotate(a.rotate*Math.PI/180),i.createCanvasPen(s)},this.style.fill===void 0&&(this.style.fill=_Oe)}return e.prototype.createCanvasPen=function(t){var r=this;return{destroy:function(){t.restore()},write:function(n,i,o,a,s){a+=i*gOe.Writer.XOffsetFactor[o],t.textAlign=o,r.style.font!=null&&(t.font=r.style.font),r.style.fill!=null&&(t.fillStyle=r.style.fill,t.fillText(n,a,s)),r.style.stroke!=null&&(t.strokeStyle=r.style.fill,t.strokeText(n,a,s))}}},e}();dit.CanvasContext=yOe});var git=H(mF=>{"use strict";function mit(e){for(var t in e)mF.hasOwnProperty(t)||(mF[t]=e[t])}Object.defineProperty(mF,"__esModule",{value:!0});mit(iXt());mit(oXt());mit(pit())});var gF=H(_it=>{"use strict";Object.defineProperty(_it,"__esModule",{value:!0});var aXt=function(){function e(t){t.createRuler!=null?this.ruler=t.createRuler():this.ruler=t}return e.prototype.measure=function(t){return t===void 0&&(t=e.HEIGHT_TEXT),this.ruler(t)},e}();aXt.HEIGHT_TEXT="bdpql";_it.AbstractMeasurer=aXt});var yit=H(BA=>{"use strict";var vOe=BA&&BA.__extends||function(){var e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,r){t.__proto__=r}||function(t,r){for(var n in r)r.hasOwnProperty(n)&&(t[n]=r[n])};return function(t,r){e(t,r);function n(){this.constructor=t}t.prototype=r===null?Object.create(r):(n.prototype=r.prototype,new n)}}();Object.defineProperty(BA,"__esModule",{value:!0});var _F=gF(),xOe=function(e){vOe(t,e);function t(r,n){n===void 0&&(n=!1);var i=e.call(this,r)||this;return i.useGuards=n,i}return t.prototype._addGuards=function(r){return _F.AbstractMeasurer.HEIGHT_TEXT+r+_F.AbstractMeasurer.HEIGHT_TEXT},t.prototype._measureLine=function(r,n){n===void 0&&(n=!1);var i=this.useGuards||n||/^[\t ]$/.test(r),o=i?this._addGuards(r):r,a=e.prototype.measure.call(this,o);return a.width-=i?2*this.getGuardWidth():0,a},t.prototype.measure=function(r){var n=this;if(r===void 0&&(r=_F.AbstractMeasurer.HEIGHT_TEXT),r.trim()==="")return{width:0,height:0};var i=r.trim().split(`
`).map(function(o){return n._measureLine(o)});return{height:i.reduce(function(o,a){return o+a.height},0),width:i.reduce(function(o,a){return Math.max(o,a.width)},0)}},t.prototype.getGuardWidth=function(){return this.guardWidth==null&&(this.guardWidth=e.prototype.measure.call(this).width),this.guardWidth},t}(_F.AbstractMeasurer);BA.Measurer=xOe});var vit=H(HA=>{"use strict";var bOe=HA&&HA.__extends||function(){var e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,r){t.__proto__=r}||function(t,r){for(var n in r)r.hasOwnProperty(n)&&(t[n]=r[n])};return function(t,r){e(t,r);function n(){this.constructor=t}t.prototype=r===null?Object.create(r):(n.prototype=r.prototype,new n)}}();Object.defineProperty(HA,"__esModule",{value:!0});var wOe=yit(),SOe=function(e){bOe(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t.prototype._measureCharacter=function(r){return e.prototype._measureLine.call(this,r)},t.prototype._measureLine=function(r){var n=this,i=r.split("").map(function(o){return n._measureCharacter(o)});return{height:i.reduce(function(o,a){return Math.max(o,a.height)},0),width:i.reduce(function(o,a){return o+a.width},0)}},t}(wOe.Measurer);HA.CharacterMeasurer=SOe});var xit=H(VA=>{"use strict";var MOe=VA&&VA.__extends||function(){var e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,r){t.__proto__=r}||function(t,r){for(var n in r)r.hasOwnProperty(n)&&(t[n]=r[n])};return function(t,r){e(t,r);function n(){this.constructor=t}t.prototype=r===null?Object.create(r):(n.prototype=r.prototype,new n)}}();Object.defineProperty(VA,"__esModule",{value:!0});var EOe=pS(),TOe=vit(),COe=function(e){MOe(t,e);function t(r,n){var i=e.call(this,r,n)||this;return i.cache=new EOe.Cache(function(o){return i._measureCharacterNotFromCache(o)}),i}return t.prototype._measureCharacterNotFromCache=function(r){return e.prototype._measureCharacter.call(this,r)},t.prototype._measureCharacter=function(r){return this.cache.get(r)},t.prototype.reset=function(){this.cache.clear()},t}(TOe.CharacterMeasurer);VA.CacheCharacterMeasurer=COe});var sXt=H(UA=>{"use strict";var AOe=UA&&UA.__extends||function(){var e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,r){t.__proto__=r}||function(t,r){for(var n in r)r.hasOwnProperty(n)&&(t[n]=r[n])};return function(t,r){e(t,r);function n(){this.constructor=t}t.prototype=r===null?Object.create(r):(n.prototype=r.prototype,new n)}}();Object.defineProperty(UA,"__esModule",{value:!0});var POe=pS(),IOe=gF(),LOe=xit(),kOe=function(e){AOe(t,e);function t(r){var n=e.call(this,r)||this;return n.dimCache=new POe.Cache(function(i){return n._measureNotFromCache(i)}),n}return t.prototype._measureNotFromCache=function(r){return e.prototype.measure.call(this,r)},t.prototype.measure=function(r){return r===void 0&&(r=IOe.AbstractMeasurer.HEIGHT_TEXT),this.dimCache.get(r)},t.prototype.reset=function(){this.dimCache.clear(),e.prototype.reset.call(this)},t}(LOe.CacheCharacterMeasurer);UA.CacheMeasurer=kOe});var bit=H(yF=>{"use strict";function qA(e){for(var t in e)yF.hasOwnProperty(t)||(yF[t]=e[t])}Object.defineProperty(yF,"__esModule",{value:!0});qA(gF());qA(xit());qA(sXt());qA(vit());qA(yit())});var Sit=H(wit=>{"use strict";Object.defineProperty(wit,"__esModule",{value:!0});var GA=pS(),ROe=function(){function e(){this.maxLines(1/0),this.textTrimming("ellipsis"),this.allowBreakingWords(!1),this._tokenizer=new GA.Tokenizer,this._breakingCharacter="-"}return e.prototype.maxLines=function(t){return t==null?this._maxLines:(this._maxLines=t,this)},e.prototype.textTrimming=function(t){if(t==null)return this._textTrimming;if(t!=="ellipsis"&&t!=="none")throw new Error(t+" - unsupported text trimming option.");return this._textTrimming=t,this},e.prototype.allowBreakingWords=function(t){return t==null?this._allowBreakingWords:(this._allowBreakingWords=t,this)},e.prototype.wrap=function(t,r,n,i){var o=this;i===void 0&&(i=1/0);var a={noBrokeWords:0,noLines:0,originalText:t,truncatedText:"",wrappedText:""},s={availableLines:Math.min(Math.floor(i/r.measure().height),this._maxLines),availableWidth:n,canFitText:!0,currentLine:"",wrapping:a},l=t.split(`
`);return l.reduce(function(c,u,h){return o.breakLineToFitWidth(c,u,h!==l.length-1,r)},s).wrapping},e.prototype.breakLineToFitWidth=function(t,r,n,i){var o=this;!t.canFitText&&t.wrapping.truncatedText!==""&&(t.wrapping.truncatedText+=`
`);var a=this._tokenizer.tokenize(r);t=a.reduce(function(l,c){return o.wrapNextToken(c,l,i)},t);var s=GA.StringMethods.trimEnd(t.currentLine);return t.wrapping.noLines+=+(s!==""),t.wrapping.noLines===t.availableLines&&this._textTrimming!=="none"&&n?t.canFitText=!1:t.wrapping.wrappedText+=s,t.currentLine=`
`,t},e.prototype.canFitToken=function(t,r,n){var i=this,o=t.split("").map(function(a,s){return s!==t.length-1?a+i._breakingCharacter:a});return n.measure(t).width<=r||o.every(function(a){return n.measure(a).width<=r})},e.prototype.addEllipsis=function(t,r,n){if(this._textTrimming==="none")return{remainingToken:"",wrappedToken:t};var i=t.substring(0).trim(),o=n.measure(i).width,a=n.measure("...").width,s=t.length>0&&t[0]===`
`?`
`:"";if(r<=a){var l=a/3,c=Math.floor(r/l);return{remainingToken:t,wrappedToken:s+"...".substr(0,c)}}for(;o+a>r;)i=GA.StringMethods.trimEnd(i.substr(0,i.length-1)),o=n.measure(i).width;return{remainingToken:GA.StringMethods.trimEnd(t.substring(i.length),"-").trim(),wrappedToken:s+i+"..."}},e.prototype.wrapNextToken=function(t,r,n){if(!r.canFitText||r.availableLines===r.wrapping.noLines||!this.canFitToken(t,r.availableWidth,n))return this.finishWrapping(t,r,n);for(var i=t;i;){var o=this.breakTokenToFitInWidth(i,r.currentLine,r.availableWidth,n);if(r.currentLine=o.line,i=o.remainingToken,i!=null)if(r.wrapping.noBrokeWords+=+o.breakWord,++r.wrapping.noLines,r.availableLines===r.wrapping.noLines){var a=this.addEllipsis(r.currentLine,r.availableWidth,n);return r.wrapping.wrappedText+=a.wrappedToken,r.wrapping.truncatedText+=a.remainingToken+i,r.currentLine=`
`,r}else r.wrapping.wrappedText+=GA.StringMethods.trimEnd(r.currentLine),r.currentLine=`
`}return r},e.prototype.finishWrapping=function(t,r,n){if(r.canFitText&&r.availableLines!==r.wrapping.noLines&&this._textTrimming!=="none"){var i=this.addEllipsis(r.currentLine+t,r.availableWidth,n);r.wrapping.wrappedText+=i.wrappedToken,r.wrapping.truncatedText+=i.remainingToken,r.wrapping.noBrokeWords+=+(i.remainingToken.length<t.length),r.wrapping.noLines+=+(i.wrappedToken.length>0),r.currentLine=""}else r.wrapping.truncatedText+=t;return r.canFitText=!1,r},e.prototype.breakTokenToFitInWidth=function(t,r,n,i,o){if(o===void 0&&(o=this._breakingCharacter),i.measure(r+t).width<=n)return{breakWord:!1,line:r+t,remainingToken:null};if(t.trim()==="")return{breakWord:!1,line:r,remainingToken:""};if(!this._allowBreakingWords&&r.trim()!=="")return{breakWord:!1,line:r,remainingToken:t};for(var a=0;a<t.length&&i.measure(r+t.substring(0,a+1)+o).width<=n;)++a;var s="";return a>0&&(s=o),{breakWord:a>0,line:r+t.substring(0,a)+s,remainingToken:t.substring(a)}},e}();wit.Wrapper=ROe});var cXt=H(WA=>{"use strict";var NOe=WA&&WA.__extends||function(){var e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,r){t.__proto__=r}||function(t,r){for(var n in r)r.hasOwnProperty(n)&&(t[n]=r[n])};return function(t,r){e(t,r);function n(){this.constructor=t}t.prototype=r===null?Object.create(r):(n.prototype=r.prototype,new n)}}();Object.defineProperty(WA,"__esModule",{value:!0});var DOe=Sit(),lXt=function(e){NOe(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t.prototype.wrap=function(r,n,i,o){var a=this;o===void 0&&(o=1/0);var s=r.split(`
`);if(s.length>1)throw new Error("SingleLineWrapper is designed to work only on single line");var l=function(g){return e.prototype.wrap.call(a,r,n,g,o)},c=l(i);if(c.noLines<2)return c;for(var u=0,h=i,f=0;f<t.NO_WRAP_ITERATIONS&&h>u;++f){var p=(h+u)/2,d=l(p);this.areSameResults(c,d)?(h=p,c=d):u=p}return c},t.prototype.areSameResults=function(r,n){return r.noLines===n.noLines&&r.truncatedText===n.truncatedText},t}(DOe.Wrapper);lXt.NO_WRAP_ITERATIONS=5;WA.SingleLineWrapper=lXt});var Mit=H(vF=>{"use strict";function uXt(e){for(var t in e)vF.hasOwnProperty(t)||(vF[t]=e[t])}Object.defineProperty(vF,"__esModule",{value:!0});uXt(cXt());uXt(Sit())});var hXt=H(Tit=>{"use strict";Object.defineProperty(Tit,"__esModule",{value:!0});var Eit=git(),OOe=bit(),zOe=Mit(),FOe=zA(),BOe=function(){function e(t){this.context=t,this.measurer=new OOe.CacheMeasurer(this.context),this.wrapper=new zOe.Wrapper,this.writer=new FOe.Writer(this.measurer,this.context,this.wrapper)}return e.svg=function(t,r,n){return new e(new Eit.SvgContext(t,r,n))},e.canvas=function(t,r,n){return new e(new Eit.CanvasContext(t,r,n))},e.html=function(t,r,n){return new e(new Eit.HtmlContext(t,r,n))},e.prototype.write=function(t,r,n,i,o){this.writer.write(t,r,n,i,o)},e.prototype.clearMeasurerCache=function(){this.measurer.reset()},e}();Tit.Typesetter=BOe});var _l=H(xF=>{"use strict";function dS(e){for(var t in e)xF.hasOwnProperty(t)||(xF[t]=e[t])}Object.defineProperty(xF,"__esModule",{value:!0});dS(git());dS(bit());dS(hXt());dS(pS());dS(Mit());dS(zA())});var fXt=H(mS=>{"use strict";Object.defineProperty(mS,"__esModule",{value:!0});var HOe=(Er(),Ut(Mr)),VOe=window.Array;function UOe(e,t){if(e.length!==t.length)throw new Error("attempted to add arrays of unequal length");return e.map(function(r,n){return e[n]+t[n]})}mS.add=UOe;function qOe(e){var t=HOe.set(),r=[];return e.forEach(function(n){t.has(String(n))||(t.add(String(n)),r.push(n))}),r}mS.uniq=qOe;function GOe(e){return VOe.prototype.concat.apply([],e)}mS.flatten=GOe;function WOe(e,t){for(var r=[],n=0;n<t;n++)r[n]=typeof e=="function"?e(n):e;return r}mS.createFilledArray=WOe});var mXt=H(YA=>{"use strict";Object.defineProperty(YA,"__esModule",{value:!0});var dXt=(Er(),Ut(Mr)),YOe=window.Math;function jOe(e,t){var r=pXt(e)+.05,n=pXt(t)+.05;return r>n?r/n:n/r}YA.contrast=jOe;function XOe(e,t){var r=dXt.color(e).brighter(t);return r.rgb().toString()}YA.lightenColor=XOe;function $Oe(e,t){e.classed(t,!0);var r=e.style("background-color");if(r==="transparent")return null;var n=/\((.+)\)/.exec(r);if(!n)return null;var i=n[1].split(",").map(function(a){var s=+a,l=s.toString(16);return s<16?"0"+l:l});if(i.length===4&&i[3]==="00")return null;var o="#"+i.join("");return e.classed(t,!1),o}YA.colorTest=$Oe;function pXt(e){var t=dXt.rgb(e),r=function(a){return a=a/255,a<=.03928?a/12.92:YOe.pow((a+.055)/1.055,2.4)},n=r(t.r),i=r(t.g),o=r(t.b);return .2126*n+.7152*i+.0722*o}});var Ait=H(ao=>{"use strict";Object.defineProperty(ao,"__esModule",{value:!0});var Cit=(Er(),Ut(Mr)),ma=window.Math;function KOe(e,t){for(var r=t;r!=null&&r!==e;)r=r.parentNode;return r===e}ao.contains=KOe;function _Xt(e){var t;try{t=e.node().getBBox()}catch(r){t={x:0,y:0,width:0,height:0}}return t}ao.elementBBox=_Xt;function ZOe(e){if(e instanceof SVGElement)return _Xt(Cit.select(e));if(e instanceof HTMLElement){var t=e.getBoundingClientRect();return{x:t.left,y:t.top,width:t.width,height:t.height}}else return{x:0,y:0,width:0,height:0}}ao.entityBounds=ZOe;ao.SCREEN_REFRESH_RATE_MILLISECONDS=1e3/60;function JOe(e){window.requestAnimationFrame!=null?window.requestAnimationFrame(e):setTimeout(e,ao.SCREEN_REFRESH_RATE_MILLISECONDS)}ao.requestAnimationFramePolyfill=JOe;function QOe(e){var t=e instanceof Cit.selection?e.node():e,r=window.getComputedStyle(t);return kf(r,"width")+kf(r,"padding-left")+kf(r,"padding-right")+kf(r,"border-left-width")+kf(r,"border-right-width")}ao.elementWidth=QOe;function t7e(e){var t=e instanceof Cit.selection?e.node():e,r=window.getComputedStyle(t);return kf(r,"height")+kf(r,"padding-top")+kf(r,"padding-bottom")+kf(r,"border-top-width")+kf(r,"border-bottom-width")}ao.elementHeight=t7e;var Lc="\\s",jA="(?:[-+]?[0-9]*\\.?[0-9]+)",yXt="(?:(?:"+Lc+"+,?"+Lc+"*)|(?:,"+Lc+"*))",e7e=new RegExp("translate"+Lc+"*\\("+Lc+"*("+jA+")(?:"+yXt+"("+jA+"))?"+Lc+"*\\)"),r7e=new RegExp("rotate"+Lc+"*\\("+Lc+"*("+jA+")"+Lc+"*\\)"),n7e=new RegExp("scale"+Lc+"*\\("+Lc+"*("+jA+")(?:"+yXt+"("+jA+"))?"+Lc+"*\\)");function i7e(e){var t=e7e.exec(e.attr("transform"));if(t!=null){var r=t[1],n=t[2],i=n===void 0?0:n;return[+r,+i]}else return[0,0]}ao.getTranslateValues=i7e;function o7e(e){var t=r7e.exec(e.attr("transform"));if(t!=null){var r=t[1];return+r}else return 0}ao.getRotate=o7e;function a7e(e){var t=n7e.exec(e.attr("transform"));if(t!=null){var r=t[1],n=t[2];return[+r,n==null?+r:+n]}else return[0,0]}ao.getScaleValues=a7e;function s7e(e,t){return!(ma.floor(e.right)<=ma.ceil(t.left)||ma.ceil(e.left)>=ma.floor(t.right)||ma.floor(e.bottom)<=ma.ceil(t.top)||ma.ceil(e.top)>=ma.floor(t.bottom))}ao.clientRectsOverlap=s7e;function l7e(e,t){return{left:e.left-t,top:e.top-t,right:e.right+t,bottom:e.bottom+t,width:e.width+t*2,height:e.height+t*2}}ao.expandRect=l7e;function c7e(e,t){return ma.floor(t.left)<=ma.ceil(e.left)&&ma.floor(t.top)<=ma.ceil(e.top)&&ma.floor(e.right)<=ma.ceil(t.right)&&ma.floor(e.bottom)<=ma.ceil(t.bottom)}ao.clientRectInside=c7e;function u7e(e,t,r,n){n===void 0&&(n=.5);var i=gXt(e),o=gXt(t);return r.x+r.width>=i.min-n&&r.x<=i.max+n&&r.y+r.height>=o.min-n&&r.y<=o.max+n}ao.intersectsBBox=u7e;function gXt(e){if(typeof e=="number"){var t=e;return{min:t,max:t}}var r=e;if(r instanceof Object&&"min"in r&&"max"in r)return r;throw new Error("input '"+e+"' can't be parsed as an Range")}function kf(e,t){var r=e.getPropertyValue(t),n=parseFloat(r);return n||0}function h7e(e){for(var t=[];e&&e instanceof HTMLElement;)t.push(e),e=e.parentElement;return t}ao.getHtmlElementAncestors=h7e;function f7e(e){var t=window.getComputedStyle(e,null),r=t.getPropertyValue("-webkit-transform")||t.getPropertyValue("-moz-transform")||t.getPropertyValue("-ms-transform")||t.getPropertyValue("-o-transform")||t.getPropertyValue("transform");return m7e(r)}ao.getElementTransform=f7e;var p7e=/^matrix\(([^)]+)\)$/,d7e=/[, ]+/;function m7e(e){if(e==null||e==="none")return null;var t=e.match(p7e);if(t==null||t.length<2)return null;var r=t[1].split(d7e).map(function(n){return parseFloat(n)});return r.length!=6?null:r}});var Pit=H(so=>{"use strict";Object.defineProperty(so,"__esModule",{value:!0});var wF=(Er(),Ut(Mr)),vXt=Ait(),md=window.Math,g7e=[1,0,0,1,0,0];function _7e(e,t,r){return md.min(t,r)<=e&&e<=md.max(t,r)}so.inRange=_7e;function y7e(e,t,r){return md.min(md.max(t,e),r)}so.clamp=y7e;function v7e(e,t,r){var n=typeof t=="function"?t:null,i=n==null?t:r,o=n==null?wF.max(e):wF.max(e,n);return o!==void 0?o:i}so.max=v7e;function x7e(e,t,r){var n=typeof t=="function"?t:null,i=n==null?t:r,o=n==null?wF.min(e):wF.min(e,n);return o!==void 0?o:i}so.min=x7e;function b7e(e){return e!==e}so.isNaN=b7e;function w7e(e){return typeof e=="number"&&e-e<1}so.isValidNumber=w7e;function S7e(e,t,r){if(r===void 0&&(r=1),r===0)throw new Error("step cannot be 0");for(var n=md.max(md.ceil((t-e)/r),0),i=[],o=0;o<n;++o)i[o]=e+r*o;return i}so.range=S7e;function M7e(e,t){return md.pow(t.y-e.y,2)+md.pow(t.x-e.x,2)}so.distanceSquared=M7e;function E7e(e){return e/360*md.PI*2}so.degreesToRadians=E7e;function T7e(e,t){return t.topLeft.x<=e.x&&t.bottomRight.x>=e.x&&t.topLeft.y<=e.y&&t.bottomRight.y>=e.y}so.within=T7e;function C7e(e,t,r,n,i,o,a,s){return e<=i+a&&i<=e+r&&t<=o+s&&o<=t+n}so.boundsIntersects=C7e;function A7e(e){for(var t=vXt.getHtmlElementAncestors(e),r=g7e,n=null,i=0,o=t;i<o.length;i++){var a=o[i],s=vXt.getElementTransform(a);if(s!=null){var l=a.clientWidth/2,c=a.clientHeight/2;r=bF(r,[l,c]),r=xXt(r,bXt(s)),r=bF(r,[-l,-c])}var u=a.scrollLeft,h=a.scrollTop;(n===null||a===n)&&(u-=a.offsetLeft+a.clientLeft,h-=a.offsetTop+a.clientTop,n=a.offsetParent),r=bF(r,[u,h])}return r}so.getCumulativeTransform=A7e;function xXt(e,t){return[e[0]*t[0]+e[2]*t[1],e[1]*t[0]+e[3]*t[1],e[0]*t[2]+e[2]*t[3],e[1]*t[2]+e[3]*t[3],e[0]*t[4]+e[2]*t[5]+e[4],e[1]*t[4]+e[3]*t[5]+e[5]]}so.multiplyMatrix=xXt;function P7e(e,t){return[t[0],t[1],t[2],t[3],t[4]+e[0],t[5]+e[1]]}so.premultiplyTranslate=P7e;function bF(e,t){return[e[0],e[1],e[2],e[3],e[0]*t[0]+e[2]*t[1]+e[4],e[1]*t[0]+e[3]*t[1]+e[5]]}so.multiplyTranslate=bF;function bXt(e){var t=e[0]*e[3]-e[1]*e[2];if(t===0)throw new Error("singular matrix");var r=1/t;return[r*e[3],r*-e[1],r*-e[2],r*e[0],r*(-e[3]*e[4]+e[2]*e[5]),r*(e[1]*e[4]+-e[0]*e[5])]}so.invertMatrix=bXt;function I7e(e,t){return{x:e[0]*t.x+e[2]*t.y+e[4],y:e[1]*t.x+e[3]*t.y+e[5]}}so.applyTransform=I7e});var wXt=H(SF=>{"use strict";Object.defineProperty(SF,"__esModule",{value:!0});var L7e=function(){function e(){}return e.prototype.split=function(t,r){for(var n=Math.ceil(t.length/2),i=0;i<n;i++)r[0].insert(t[i]);for(var i=n;i<t.length;i++)r[1].insert(t[i])},e}();SF.SplitStrategyTrivial=L7e;var k7e=function(){function e(){}return e.prototype.split=function(t,r){for(t=t.slice(),this.chooseFirstSplit(t,r);t.length>0;)this.addNext(t,r)},e.prototype.chooseFirstSplit=function(t,r){for(var n=0,i=0,o=t.length-1,a=t.length-1,s=1;s<t.length-1;s++){var l=t[s];l.bounds.xl>t[o].bounds.xl?o=s:l.bounds.xh<t[n].bounds.xh&&(n=s),l.bounds.yl>t[a].bounds.yl?a=s:l.bounds.yh<t[i].bounds.yh&&(i=s)}var c=Math.abs(t[n].bounds.xh-t[o].bounds.xl),u=Math.abs(t[i].bounds.yh-t[a].bounds.yl),h=c>u?[n,o]:[i,a],f=h[0],p=h[1];f===p&&(f=0,p=t.length-1),r[0].insert(t.splice(Math.max(f,p),1)[0]),r[1].insert(t.splice(Math.min(f,p),1)[0])},e.prototype.addNext=function(t,r){for(var n=null,i=null,o=null,a=0;a<t.length;a++){var s=t[a],l=r[0].unionAreaDifference(s.bounds),c=r[1].unionAreaDifference(s.bounds);(l<i||n==null)&&(n=a,i=l,o=r[0]),c<i&&(n=a,i=c,o=r[1])}o.insert(t.splice(n,1)[0])},e}();SF.SplitStrategyLinear=k7e});var Lit=H(gd=>{"use strict";Object.defineProperty(gd,"__esModule",{value:!0});var R7e=wXt(),N7e=5,D7e=new R7e.SplitStrategyLinear,Rf;(function(e){e[e.PASS=0]="PASS",e[e.FAIL=1]="FAIL",e[e.PASS_AND_OVERWRITE=2]="PASS_AND_OVERWRITE"})(Rf=gd.QueryPredicateResult||(gd.QueryPredicateResult={}));function MF(e,t,r){var n=1/0,i=1/0,o=1/0;return function(a){var s=t(a.bounds,e),l=r(a.bounds,e);return a.value!=null?s<n?(n=s,i=s,o=l,Rf.PASS_AND_OVERWRITE):s===n?Rf.PASS:Rf.FAIL:s>o?Rf.FAIL:(i=Math.min(s,i),o=Math.max(l,o),Rf.PASS)}}gd.createMinimizingNodePredicate=MF;function Iit(e,t){return function(r,n){return t(n.bounds,e)-t(r.bounds,e)}}gd.createNodeSort=Iit;var O7e=function(){function e(t,r){t===void 0&&(t=N7e),r===void 0&&(r=D7e),this.maxNodeChildren=t,this.splitStrategy=r,this.root=new EF(!0),this.size=0}return e.prototype.getRoot=function(){return this.root},e.prototype.clear=function(){this.root=new EF(!0),this.size=0},e.prototype.insert=function(t,r){for(var n=this.root;!n.leaf;)n=n.subtree(t);var i=EF.valueNode(t,r);for(n.insert(i),this.size+=1;n.overflow(this.maxNodeChildren);)n=n.split(this.splitStrategy),n.parent==null&&(this.root=n);return i},e.prototype.locate=function(t){return this.query(function(r){return r.contains(t)})},e.prototype.locateNearest=function(t){var r=MF(t,Qa.distanceSquaredToNearEdge,Qa.distanceSquaredToFarEdge),n=this.queryNodes(r);return n.map(function(i){return i.value})},e.prototype.locateNearestX=function(t){var r=MF(t,Qa.absoluteDistanceToNearEdgeX,Qa.absoluteDistanceToFarEdgeX),n=this.queryNodes(r);return n.sort(Iit(t,Qa.absoluteDistanceToNearEdgeY)),n.map(function(i){return i.value})},e.prototype.locateNearestY=function(t){var r=MF(t,Qa.absoluteDistanceToNearEdgeY,Qa.absoluteDistanceToFarEdgeY),n=this.queryNodes(r);return n.sort(Iit(t,Qa.absoluteDistanceToNearEdgeX)),n.map(function(i){return i.value})},e.prototype.intersect=function(t){return this.query(function(r){return Qa.isBoundsOverlapBounds(r,t)})},e.prototype.intersectX=function(t){return this.query(function(r){return Qa.isBoundsOverlapX(r,t)})},e.prototype.intersectY=function(t){return this.query(function(r){return Qa.isBoundsOverlapY(r,t)})},e.prototype.query=function(t){var r=[];if(this.root.bounds!=null&&!t(this.root.bounds))return r;for(var n=[this.root];n.length>0;)for(var i=n.shift(),o=0;o<i.entries.length;o++){var a=i.entries[o];t(a.bounds)&&(i.leaf?r.push(a.value):n.push(a))}return r},e.prototype.queryNodes=function(t){var r=[];if(this.root.bounds!=null&&t(this.root)===Rf.FAIL)return r;for(var n=[this.root];n.length>0;)for(var i=n.shift(),o=0;o<i.entries.length;o++){var a=i.entries[o],s=t(a);s===Rf.PASS_AND_OVERWRITE&&(r=[]),(s===Rf.PASS||s===Rf.PASS_AND_OVERWRITE)&&(i.leaf?r.push(a):n.push(a))}return r},e}();gd.RTree=O7e;var EF=function(){function e(t){this.leaf=t,this.bounds=null,this.entries=[],this.parent=null,this.value=null}return e.valueNode=function(t,r){var n=new e(!0);return n.bounds=t,n.value=r,n},e.prototype.overflow=function(t){return this.entries.length>t},e.prototype.insert=function(t){this.entries.push(t),t.parent=this;for(var r=this;r!=null;)r.bounds=Qa.unionAll([r.bounds,t.bounds]),r=r.parent;return this},e.prototype.remove=function(t){var r=this.entries.indexOf(t);if(r>=0){this.entries.splice(r,1);for(var n=this;n!=null;)n.bounds=Qa.unionAll(n.entries.map(function(i){return i.bounds})),n=n.parent}return this},e.prototype.subtree=function(t){for(var r=1/0,n=null,i=0;i<this.entries.length;i++){var o=this.entries[i],a=o.unionAreaDifference(t);(a<r||a===r&&n!=null&&o.entries.length<n.entries.length)&&(n=o)}return n},e.prototype.split=function(t){this.parent!=null&&this.parent.remove(this);var r=[new e(this.leaf),new e(this.leaf)];t.split(this.entries,r);var n=this.parent!=null?this.parent:new e(!1);return n.insert(r[0]),n.insert(r[1]),n.leaf=!1,n},e.prototype.unionAreaDifference=function(t){return Math.abs(Qa.union(this.bounds,t).area()-this.bounds.area())},e.prototype.maxDepth=function(){return this.leaf?1:1+this.entries.map(function(t){return t.maxDepth()}).reduce(function(t,r){return Math.max(t,r)})},e}();gd.RTreeNode=EF;var Qa=function(){function e(t,r,n,i){this.xl=t,this.yl=r,this.xh=n,this.yh=i,this.width=this.xh-this.xl,this.height=this.yh-this.yl}return e.xywh=function(t,r,n,i){return new e(t,r,t+n,r+i)},e.entityBounds=function(t){return new e(t.x,t.y,t.x+t.width,t.y+t.height)},e.bounds=function(t){return e.pointPair(t.topLeft,t.bottomRight)},e.pointPair=function(t,r){return new e(Math.min(t.x,r.x),Math.min(t.y,r.y),Math.max(t.x,r.x),Math.max(t.y,r.y))},e.points=function(t){if(t.length<2)throw new Error("need at least 2 points to create bounds");var r=t.map(function(i){return i.x}),n=t.map(function(i){return i.y});return new e(r.reduce(function(i,o){return Math.min(i,o)}),n.reduce(function(i,o){return Math.min(i,o)}),r.reduce(function(i,o){return Math.max(i,o)}),n.reduce(function(i,o){return Math.max(i,o)}))},e.union=function(t,r){return new e(Math.min(t.xl,r.xl),Math.min(t.yl,r.yl),Math.max(t.xh,r.xh),Math.max(t.yh,r.yh))},e.unionAll=function(t){return t=t.filter(function(r){return r!=null}),t.length===0?null:t.reduce(function(r,n){return e.union(r,n)})},e.isBoundsOverlapBounds=function(t,r){return e.isBoundsOverlapX(t,r)&&e.isBoundsOverlapY(t,r)},e.isBoundsOverlapX=function(t,r){return!(t.xh<r.xl)&&!(t.xl>r.xh)},e.isBoundsOverlapY=function(t,r){return!(t.yh<r.yl)&&!(t.yl>r.yh)},e.absoluteDistanceToNearEdgeX=function(t,r){var n=t.width/2,i=t.xl+n;return Math.max(Math.abs(r.x-i)-n,0)},e.absoluteDistanceToNearEdgeY=function(t,r){var n=t.height/2,i=t.yl+n;return Math.max(Math.abs(r.y-i)-n,0)},e.absoluteDistanceToFarEdgeX=function(t,r){var n=e.absoluteDistanceToNearEdgeX(t,r);return n===0?0:n+t.width},e.absoluteDistanceToFarEdgeY=function(t,r){var n=e.absoluteDistanceToNearEdgeY(t,r);return n===0?0:n+t.height},e.distanceSquaredToNearEdge=function(t,r){var n=e.absoluteDistanceToNearEdgeX(t,r),i=e.absoluteDistanceToNearEdgeY(t,r);return n*n+i*i},e.distanceSquaredToFarEdge=function(t,r){var n=e.absoluteDistanceToFarEdgeX(t,r),i=e.absoluteDistanceToFarEdgeY(t,r);return n*n+i*i},e.prototype.area=function(){return this.areaCached==null&&(this.areaCached=(this.xh-this.xl)*(this.yh-this.yl)),this.areaCached},e.prototype.contains=function(t){return this.xl<=t.x&&this.xh>=t.x&&this.yl<=t.y&&this.yh>=t.y},e}();gd.RTreeBounds=Qa});var EXt=H(_d=>{"use strict";Object.defineProperty(_d,"__esModule",{value:!0});var SXt=(Er(),Ut(Mr)),z7e=Oe(),Xg=Fe(),F7e=If();_d.IStackingOrder=F7e.makeEnum(["topdown","bottomup"]);var MXt=window.Math;function B7e(e,t,r,n){n===void 0&&(n="bottomup");var i=SXt.map(),o=SXt.map(),a=new Xg.Map;n==="topdown"&&(e=e.slice(),e.reverse());for(var s=0,l=e;s<l.length;s++){for(var c=l[s],u=new Xg.Map,h=c.data(),f=h.length,p=0;p<f;p++){var d=h[p],g=t(d,p,c),_=_d.normalizeKey(g),y=+r(d,p,c),x=void 0,b=y>=0?i:o;b.has(_)?(x=b.get(_),b.set(_,x+y)):(x=0,b.set(_,y)),u.set(_,{offset:x,value:y,axisValue:g,originalDatum:d,originalDataset:c,originalIndex:p})}a.set(c,u)}return a}_d.stack=B7e;function H7e(e){var t=new Xg.Map,r=new Xg.Map;return e.forEach(function(n){n.forEach(function(i,o){var a=i.offset+i.value,s=Xg.Math.max([a,i.offset],i.offset),l=Xg.Math.min([a,i.offset],i.offset),c=i.axisValue;t.has(o)?t.get(o).extent<s&&t.set(o,{extent:s,axisValue:c,stackedDatum:i}):t.set(o,{extent:s,axisValue:c,stackedDatum:i}),r.has(o)?r.get(o).extent>l&&r.set(o,{extent:l,axisValue:c,stackedDatum:i}):r.set(o,{extent:l,axisValue:c,stackedDatum:i})})}),{maximumExtents:t,minimumExtents:r}}_d.stackedExtents=H7e;function V7e(e,t,r){var n=[];e.forEach(function(a,s){for(var l=s.data(),c=l.length,u=0;u<c;u++){var h=l[u];if(!(r!=null&&!r(h,u,s))){var f=a.get(_d.normalizeKey(t(h,u,s)));n.push(f.value+f.offset)}}});var i=Xg.Math.max(n,0),o=Xg.Math.min(n,0);return[MXt.min(o,0),MXt.max(0,i)]}_d.stackedExtent=V7e;_d.normalizeKey=z7e.memoize(function(e){return String(e)})});var XA=H(TF=>{"use strict";Object.defineProperty(TF,"__esModule",{value:!0});TF.SHOW_WARNINGS=!0;TF.ADD_TITLE_ELEMENTS=!0});var CF=H(gS=>{"use strict";Object.defineProperty(gS,"__esModule",{value:!0});var U7e=XA();function TXt(e){!U7e.SHOW_WARNINGS||console.warn(e)}gS.warn=TXt;function CXt(e,t){for(var r=[],n=2;n<arguments.length;n++)r[n-2]=arguments[n];return t===0?(e(r),-1):window.setTimeout(e,t,r)}gS.setTimeout=CXt;function q7e(e,t,r){var n=null,i=[],o=function(){t.apply(r,i)};return function(){i=Array.prototype.slice.call(arguments),clearTimeout(n),n=CXt(o,e)}}gS.debounce=q7e;function G7e(e,t,r){r===void 0&&(r=""),TXt("Method "+e+" has been deprecated in version "+t+". Please refer to the release notes. "+r)}gS.deprecated=G7e});var AXt=H(kit=>{"use strict";Object.defineProperty(kit,"__esModule",{value:!0});var W7e=function(){function e(t,r,n){this.entryIndex=t,this.exitIndex=t,this.minIndex=t,this.maxIndex=t,this.bucketValue=r,this.minValue=n,this.maxValue=n}return e.prototype.isInBucket=function(t){return t==this.bucketValue},e.prototype.addToBucket=function(t,r){t<this.minValue&&(this.minValue=t,this.minIndex=r),t>this.maxValue&&(this.maxValue=t,this.maxIndex=r),this.exitIndex=r},e.prototype.getUniqueIndices=function(){var t=[this.entryIndex,this.maxIndex,this.minIndex,this.exitIndex];return t.filter(function(r,n){return n==0||r!=t[n-1]})},e}();kit.Bucket=W7e});var Nit=H(Rit=>{"use strict";Object.defineProperty(Rit,"__esModule",{value:!0});var Y7e=function(){function e(){typeof window.Set=="function"?this._es6Set=new window.Set:this._values=[],this.size=0}return e.prototype.add=function(t){return this._es6Set!=null?(this._es6Set.add(t),this.size=this._es6Set.size,this):(this.has(t)||(this._values.push(t),this.size=this._values.length),this)},e.prototype.delete=function(t){if(this._es6Set!=null){var r=this._es6Set.delete(t);return this.size=this._es6Set.size,r}var n=this._values.indexOf(t);return n!==-1?(this._values.splice(n,1),this.size=this._values.length,!0):!1},e.prototype.has=function(t){return this._es6Set!=null?this._es6Set.has(t):this._values.indexOf(t)!==-1},e.prototype.forEach=function(t,r){var n=this;if(this._es6Set!=null){var i=function(o,a){return t.call(r,o,a,n)};this._es6Set.forEach(i,r);return}this._values.forEach(function(o){t.call(r,o,o,n)})},e}();Rit.Set=Y7e});var PXt=H(Dit=>{"use strict";Object.defineProperty(Dit,"__esModule",{value:!0});var j7e=(de(),Ut(pe)),X7e=Nit(),$7e=function(e){j7e.__extends(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t.prototype.callCallbacks=function(){for(var r=this,n=[],i=0;i<arguments.length;i++)n[i]=arguments[i];return this.forEach(function(o){o.apply(r,n)}),this},t}(X7e.Set);Dit.CallbackSet=$7e});var IXt=H(Oit=>{"use strict";Object.defineProperty(Oit,"__esModule",{value:!0});var $g=Lit(),K7e=function(){function e(){this._entities=[],this._rtree=new $g.RTree}return e.prototype.addAll=function(t,r,n){if(this._entities=this._entities.concat(t),n!==void 0)for(var i=$g.RTreeBounds.bounds(n),o=0;o<t.length;o++){var a=t[o],s=$g.RTreeBounds.entityBounds(r(a));$g.RTreeBounds.isBoundsOverlapBounds(i,s)&&this._rtree.insert(s,a)}else for(var o=0;o<t.length;o++){var a=t[o],s=$g.RTreeBounds.entityBounds(r(a));this._rtree.insert(s,a)}},e.prototype.entityNearest=function(t){return this._rtree.locateNearest(t).pop()},e.prototype.entityNearestX=function(t){return this._rtree.locateNearestX(t).pop()},e.prototype.entityNearestY=function(t){return this._rtree.locateNearestY(t).pop()},e.prototype.entitiesInBounds=function(t){return this._rtree.intersect($g.RTreeBounds.entityBounds(t))},e.prototype.entitiesInXBounds=function(t){return this._rtree.intersectX($g.RTreeBounds.entityBounds(t))},e.prototype.entitiesInYBounds=function(t){return this._rtree.intersectY($g.RTreeBounds.entityBounds(t))},e.prototype.entities=function(){return this._entities},e}();Oit.EntityStore=K7e});var LXt=H(zit=>{"use strict";Object.defineProperty(zit,"__esModule",{value:!0});var Z7e=Pit(),J7e=function(){function e(){typeof window.Map=="function"?this._es6Map=new window.Map:this._keyValuePairs=[]}return e.prototype.set=function(t,r){if(Z7e.isNaN(t))throw new Error("NaN may not be used as a key to the Map");if(this._es6Map!=null)return this._es6Map.set(t,r),this;for(var n=0;n<this._keyValuePairs.length;n++)if(this._keyValuePairs[n].key===t)return this._keyValuePairs[n].value=r,this;return this._keyValuePairs.push({key:t,value:r}),this},e.prototype.get=function(t){if(this._es6Map!=null)return this._es6Map.get(t);for(var r=0;r<this._keyValuePairs.length;r++)if(this._keyValuePairs[r].key===t)return this._keyValuePairs[r].value},e.prototype.has=function(t){if(this._es6Map!=null)return this._es6Map.has(t);for(var r=0;r<this._keyValuePairs.length;r++)if(this._keyValuePairs[r].key===t)return!0;return!1},e.prototype.forEach=function(t,r){var n=this;if(this._es6Map!=null){var i=function(o,a){return t.call(r,o,a,n)};this._es6Map.forEach(i,r);return}this._keyValuePairs.forEach(function(o){t.call(r,o.value,o.key,n)})},e.prototype.delete=function(t){if(this._es6Map!=null)return this._es6Map.delete(t);for(var r=0;r<this._keyValuePairs.length;r++)if(this._keyValuePairs[r].key===t)return this._keyValuePairs.splice(r,1),!0;return!1},e}();zit.Map=J7e});var kXt=H(Fit=>{"use strict";Object.defineProperty(Fit,"__esModule",{value:!0});function Q7e(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];for(var r={},n=0,i=e;n<i.length;n++)for(var o=i[n],a=Object.keys(o),s=0,l=a;s<l.length;s++){var c=l[s];r[c]=o[c]}return r}Fit.assign=Q7e});var DXt=H(AF=>{"use strict";Object.defineProperty(AF,"__esModule",{value:!0});var Bit=Fe(),RXt="__Plottable_ClientTranslator";function tze(e){var t=e.root().rootElement().node(),r=t[RXt];return r==null&&(r=new NXt(t),t[RXt]=r),r}AF.getTranslator=tze;var NXt=function(){function e(t){this._rootElement=t}return e.prototype.computePosition=function(t,r){var n={x:t,y:r},i=Bit.Math.getCumulativeTransform(this._rootElement);if(i==null)return n;var o=Bit.Math.applyTransform(i,n);return o},e.isEventInside=function(t,r){return Bit.DOM.contains(t.root().rootElement().node(),r.target)},e}();AF.Translator=NXt});var Fe=H(qo=>{"use strict";Object.defineProperty(qo,"__esModule",{value:!0});var Kg=(de(),Ut(pe)),eze=fXt();qo.Array=eze;var rze=mXt();qo.Color=rze;var nze=Ait();qo.DOM=nze;var ize=Pit();qo.Math=ize;var oze=Lit();qo.RTree=oze;var aze=EXt();qo.Stacking=aze;var sze=CF();qo.Window=sze;Kg.__exportStar(AXt(),qo);Kg.__exportStar(PXt(),qo);Kg.__exportStar(Yg(),qo);Kg.__exportStar(IXt(),qo);Kg.__exportStar(LXt(),qo);Kg.__exportStar(kXt(),qo);Kg.__exportStar(Nit(),qo);Kg.__exportStar(DXt(),qo)});var Vit=H($A=>{"use strict";Object.defineProperty($A,"__esModule",{value:!0});var OXt=Fe(),Hit=PF(),lze=function(){function e(){}return e.prototype.render=function(){Hit.flush()},e}();$A.Immediate=lze;var cze=function(){function e(){}return e.prototype.render=function(){OXt.DOM.requestAnimationFramePolyfill(Hit.flush)},e}();$A.AnimationFrame=cze;var uze=function(){function e(){this._timeoutMsec=OXt.DOM.SCREEN_REFRESH_RATE_MILLISECONDS}return e.prototype.render=function(){setTimeout(Hit.flush,this._timeoutMsec)},e}();$A.Timeout=uze});var PF=H(zu=>{"use strict";Object.defineProperty(zu,"__esModule",{value:!0});var _S=Fe(),hze=If(),IF=Vit(),ZA=new _S.Set,Uit=new _S.Set,LF=!1,qit=!1;zu.Policy=hze.makeEnum(["immediate","animationFrame","timeout"]);var KA=new IF.AnimationFrame;function fze(e){if(e==null)return KA;switch(e){case zu.Policy.immediate:KA=new IF.Immediate;break;case zu.Policy.animationFrame:KA=new IF.AnimationFrame;break;case zu.Policy.timeout:KA=new IF.Timeout;break;default:_S.Window.warn("Unrecognized renderPolicy: "+e)}}zu.renderPolicy=fze;function pze(e){qit&&_S.Window.warn("Registered to render while other components are flushing: request may be ignored"),ZA.add(e),FXt()}zu.registerToRender=pze;function zXt(e){Uit.add(e),ZA.add(e),FXt()}zu.registerToComputeLayoutAndRender=zXt;function dze(e){zXt(e)}zu.registerToComputeLayout=dze;function FXt(){LF||(LF=!0,KA.render())}function mze(){if(LF){Uit.forEach(function(t){return t.computeLayout()}),ZA.forEach(function(t){return t.render()}),qit=!0;var e=new _S.Set;ZA.forEach(function(t){try{t.renderImmediately()}catch(r){window.setTimeout(function(){throw r},0),e.add(t)}}),Uit=new _S.Set,ZA=e,LF=!1,qit=!1}}zu.flush=mze});var kc=H(JA=>{"use strict";Object.defineProperty(JA,"__esModule",{value:!0});var BXt=(Er(),Ut(Mr)),kF=PF(),yS=Fe(),gze=Oe(),HXt=Yg(),VXt=If();JA.XAlignment=VXt.makeEnum(["left","center","right"]);JA.YAlignment=VXt.makeEnum(["top","center","bottom"]);var _ze=function(){function e(){this._overflowHidden=!1,this._origin={x:0,y:0},this._xAlignment="left",this._yAlignment="top",this._isSetup=!1,this._isAnchored=!1,this._cssClasses=new yS.Set,this._destroyed=!1,this._onAnchorCallbacks=new yS.CallbackSet,this._onDetachCallbacks=new yS.CallbackSet,this._cssClasses.add("component")}return e.prototype.anchor=function(t){if(t=HXt.coerceExternalD3(t),this._destroyed)throw new Error("Can't reuse destroy()-ed Components!");return this.isRoot()&&(this._rootElement=t,this._rootElement.classed("plottable",!0)),this._element!=null?t.node().appendChild(this._element.node()):(this._element=t.append("div"),this._setup()),this._isAnchored=!0,this._onAnchorCallbacks.callCallbacks(this),this},e.prototype.onAnchor=function(t){return this._isAnchored&&t(this),this._onAnchorCallbacks.add(t),this},e.prototype.offAnchor=function(t){return this._onAnchorCallbacks.delete(t),this},e.prototype._setup=function(){var t=this;this._isSetup||(this._cssClasses.forEach(function(r){t._element.classed(r,!0)}),this._cssClasses=new yS.Set,this._backgroundContainer=this._element.append("svg").classed("background-container",!0),this._content=this._element.append("svg").classed("content",!0),this._foregroundContainer=this._element.append("svg").classed("foreground-container",!0),this._overflowHidden?this._content.classed("component-overflow-hidden",!0):this._content.classed("component-overflow-visible",!0),this._isSetup=!0)},e.prototype.requestedSpace=function(t,r){return{minWidth:0,minHeight:0}},e.prototype.computeLayout=function(t,r,n){if(t==null||r==null||n==null){if(this._element==null)throw new Error("anchor() must be called before computeLayout()");if(this._rootElement!=null){t={x:0,y:0};var i=this._rootElement.node();r=yS.DOM.elementWidth(i),n=yS.DOM.elementHeight(i)}else throw new Error("null arguments cannot be passed to computeLayout() on a non-root, unanchored node")}var o=this._sizeFromOffer(r,n),a=o.height,s=o.width,l=e._xAlignToProportion[this._xAlignment],c=e._yAlignToProportion[this._yAlignment],u=t.x+(r-s)*l,h=t.y+(n-a)*c;return this.setBounds(s,a,u,h),this},e.prototype.setBounds=function(t,r,n,i){return n===void 0&&(n=0),i===void 0&&(i=0),this._width=t,this._height=r,this._origin={x:n,y:i},this._element!=null&&this._element.styles({left:n+"px",height:r+"px",top:i+"px",width:t+"px"}),this._resizeHandler!=null&&this._resizeHandler({width:t,height:r}),this},e.prototype._sizeFromOffer=function(t,r){var n=this.requestedSpace(t,r);return{width:this.fixedWidth()?Math.min(t,n.minWidth):t,height:this.fixedHeight()?Math.min(r,n.minHeight):r}},e.prototype.render=function(){return this._isAnchored&&this._isSetup&&this.width()>=0&&this.height()>=0&&kF.registerToRender(this),this},e.prototype.renderLowPriority=function(){return this.render()},e.prototype._scheduleComputeLayout=function(){this._isAnchored&&this._isSetup&&kF.registerToComputeLayoutAndRender(this)},e.prototype.onResize=function(t){return this._resizeHandler=t,this},e.prototype.renderImmediately=function(){return this},e.prototype.redraw=function(){return this._isAnchored&&this._isSetup&&(this.isRoot()?this._scheduleComputeLayout():this.parent().redraw()),this},e.prototype.invalidateCache=function(){},e.prototype.renderTo=function(t){if(this.detach(),t!=null){var r=void 0;if(typeof t=="string"||gze.isElement(t)?r=BXt.select(t):r=HXt.coerceExternalD3(t),!r.node()||r.node().nodeName==null)throw new Error("Plottable requires a valid Element to renderTo");if(r.node().nodeName==="svg")throw new Error("Plottable 3.x and later can only renderTo an HTML component; pass a div instead!");this.anchor(r)}if(this._element==null)throw new Error("If a Component has never been rendered before, then renderTo must be given a node to render to, or a d3.Selection, or a selector string");return kF.registerToComputeLayoutAndRender(this),kF.flush(),this},e.prototype.xAlignment=function(t){if(t==null)return this._xAlignment;if(t=t.toLowerCase(),e._xAlignToProportion[t]==null)throw new Error("Unsupported alignment: "+t);return this._xAlignment=t,this.redraw(),this},e.prototype.yAlignment=function(t){if(t==null)return this._yAlignment;if(t=t.toLowerCase(),e._yAlignToProportion[t]==null)throw new Error("Unsupported alignment: "+t);return this._yAlignment=t,this.redraw(),this},e.prototype.hasClass=function(t){return t==null?!1:this._element==null?this._cssClasses.has(t):this._element.classed(t)},e.prototype.addClass=function(t){return t==null?this:(this._element==null?this._cssClasses.add(t):this._element.classed(t,!0),this)},e.prototype.removeClass=function(t){return t==null?this:(this._element==null?this._cssClasses.delete(t):this._element.classed(t,!1),this)},e.prototype.fixedWidth=function(){return!1},e.prototype.fixedHeight=function(){return!1},e.prototype.detach=function(){return this.parent(null),this._isAnchored&&this._element.remove(),this._isAnchored=!1,this._onDetachCallbacks.callCallbacks(this),this},e.prototype.onDetach=function(t){return this._onDetachCallbacks.add(t),this},e.prototype.offDetach=function(t){return this._onDetachCallbacks.delete(t),this},e.prototype.parent=function(t){if(t===void 0)return this._parent;if(t!==null&&!t.has(this))throw new Error("Passed invalid parent");return this._parent=t,this},e.prototype.bounds=function(){var t=this.origin();return{topLeft:t,bottomRight:{x:t.x+this.width(),y:t.y+this.height()}}},e.prototype.destroy=function(){this._destroyed=!0,this.detach()},e.prototype.width=function(){return this._width},e.prototype.height=function(){return this._height},e.prototype.origin=function(){return{x:this._origin.x,y:this._origin.y}},e.prototype.originToRoot=function(){for(var t=this.origin(),r=this.parent();r!=null;){var n=r.origin();t.x+=n.x,t.y+=n.y,r=r.parent()}return t},e.prototype.root=function(){for(var t=this;!t.isRoot();)t=t.parent();return t},e.prototype.isRoot=function(){return this.parent()==null},e.prototype.foreground=function(){return this._foregroundContainer},e.prototype.content=function(){return this._content},e.prototype.element=function(){return this._element},e.prototype.rootElement=function(){return this.root()._rootElement},e.prototype.background=function(){return this._backgroundContainer},e._xAlignToProportion={left:0,center:.5,right:1},e._yAlignToProportion={top:0,center:.5,bottom:1},e}();JA.Component=_ze});var Bu=H(Fu=>{"use strict";Object.defineProperty(Fu,"__esModule",{value:!0});var vS=(Er(),Ut(Mr)),yze=!1;function vze(e,t,r){e===void 0&&(e=2),t===void 0&&(t="$"),r===void 0&&(r=!0);var n=Git(e);return function(i){var o=n(Math.abs(i));return o!==""&&(r?o=t+o:o+=t,i<0&&(o="-"+o)),o}}Fu.currency=vze;function Git(e){return e===void 0&&(e=3),RF(e),function(t){return t.toFixed(e)}}Fu.fixed=Git;function xze(e){return e===void 0&&(e=3),RF(e),function(t){if(typeof t=="number"){var r=Math.pow(10,e);return String(Math.round(t*r)/r)}else return String(t)}}Fu.general=xze;function bze(){return function(e){return String(e)}}Fu.identity=bze;function wze(e){e===void 0&&(e=0);var t=Git(e);return function(r){var n=r*100,i=r.toString(),o=Math.pow(10,i.length-(i.indexOf(".")+1));return n=parseInt((n*o).toString(),10)/o,t(n)+"%"}}Fu.percentage=wze;function Sze(e){return e===void 0&&(e=3),RF(e),function(t){return vS.format("."+e+"s")(t)}}Fu.siSuffix=Sze;function Mze(e){e===void 0&&(e=3),RF(e);var t="KMBTQ",r=vS.format("."+e+"e"),n=vS.format("."+e+"f"),i=Math.pow(10,3*(t.length+1)),o=Math.pow(10,-e);return function(a){var s=Math.abs(a);if((s<o||s>=i)&&s!==0)return r(a);for(var l=-1;s>=Math.pow(1e3,l+2)&&l<t.length-1;)l++;var c="";return l===-1?c=n(a):c=n(a/Math.pow(1e3,l+1))+t[l],(a>0&&c.substr(0,4)==="1000"||a<0&&c.substr(0,5)==="-1000")&&(l<t.length-1?(l++,c=n(a/Math.pow(1e3,l+1))+t[l]):c=r(a)),c}}Fu.shortScale=Mze;function Eze(){var e=[{specifier:".%L",predicate:function(t){return t.getMilliseconds()!==0}},{specifier:":%S",predicate:function(t){return t.getSeconds()!==0}},{specifier:"%I:%M",predicate:function(t){return t.getMinutes()!==0}},{specifier:"%I %p",predicate:function(t){return t.getHours()!==0}},{specifier:"%a %d",predicate:function(t){return t.getDay()!==0&&t.getDate()!==1}},{specifier:"%b %d",predicate:function(t){return t.getDate()!==1}},{specifier:"%b",predicate:function(t){return t.getMonth()!==0}}];return function(t){var r=e.filter(function(i){return i.predicate(t)}),n=r.length>0?r[0].specifier:"%Y";return vS.timeFormat(n)(t)}}Fu.multiTime=Eze;function Tze(e,t){return t===void 0&&(t=yze),t?vS.utcFormat(e):vS.timeFormat(e)}Fu.time=Tze;function RF(e){if(e<0||e>20)throw new RangeError("Formatter precision must be between 0 and 20");if(e!==Math.floor(e))throw new RangeError("Formatter precision must be an integer")}});var QA=H(NF=>{"use strict";Object.defineProperty(NF,"__esModule",{value:!0});var Cze=(de(),Ut(pe)),yd=(Er(),Ut(Mr)),Wit=_l(),Aze=kc(),UXt=Bu(),xS=Fe(),Pze=If();NF.AxisOrientation=Pze.makeEnum(["bottom","left","right","top"]);var Ize=function(e){Cze.__extends(t,e);function t(r,n){var i=e.call(this)||this;if(i._endTickLength=5,i._innerTickLength=5,i._tickLabelPadding=10,i._margin=15,i._showEndTickLabels=!1,i._annotationsEnabled=!1,i._annotationTierCount=1,r==null||n==null)throw new Error("Axis requires a scale and orientation");return i._scale=r,i.orientation(n),i._setDefaultAlignment(),i.addClass("axis"),i.isHorizontal()?i.addClass("x-axis"):i.addClass("y-axis"),i.formatter(UXt.identity()),i._rescaleCallback=function(o){return i._rescale()},i._scale.onUpdate(i._rescaleCallback),i._annotatedTicks=[],i._annotationFormatter=UXt.identity(),i}return t.prototype.destroy=function(){e.prototype.destroy.call(this),this._scale.offUpdate(this._rescaleCallback)},t.prototype.tickLabelDataOnElement=function(r){if(r!=null){for(var n;r!=null&&r.classList&&n===void 0;)r.classList.contains(t.TICK_LABEL_CLASS)?n=r:r=r.parentNode;return r===void 0?void 0:yd.select(r).datum()}},t.prototype._computeWidth=function(){return this._maxLabelTickLength()},t.prototype._computeHeight=function(){return this._maxLabelTickLength()},t.prototype.requestedSpace=function(r,n){var i=0,o=0;if(this.isHorizontal()){if(o=this._computeHeight()+this._margin,this.annotationsEnabled()){var a=this._annotationMeasurer.measure().height+2*t._ANNOTATION_LABEL_PADDING;o+=a*this.annotationTierCount()}}else if(i=this._computeWidth()+this._margin,this.annotationsEnabled()){var a=this._annotationMeasurer.measure().height+2*t._ANNOTATION_LABEL_PADDING;i+=a*this.annotationTierCount()}return{minWidth:i,minHeight:o}},t.prototype.fixedHeight=function(){return this.isHorizontal()},t.prototype.fixedWidth=function(){return!this.isHorizontal()},t.prototype._rescale=function(){this.render()},t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this.isHorizontal()?this._scale.range([0,this.width()]):this._scale.range([this.height(),0]),this},t.prototype._sizeFromOffer=function(r,n){var i=this.requestedSpace(r,n);return this.isHorizontal()?{width:r,height:i.minHeight}:{height:n,width:i.minWidth}},t.prototype._setup=function(){e.prototype._setup.call(this),this._tickMarkContainer=this.content().append("g").classed(t.TICK_MARK_CLASS+"-container",!0),this._tickLabelContainer=this.content().append("g").classed(t.TICK_LABEL_CLASS+"-container",!0),this._baseline=this.content().append("line").classed("baseline",!0),this._annotationContainer=this.content().append("g").classed("annotation-container",!0),this._annotationContainer.append("g").classed("annotation-line-container",!0),this._annotationContainer.append("g").classed("annotation-circle-container",!0),this._annotationContainer.append("g").classed("annotation-rect-container",!0);var r=this._annotationContainer.append("g").classed("annotation-label-container",!0),n=new Wit.SvgContext(r.node());this._annotationMeasurer=new Wit.CacheMeasurer(n),this._annotationWriter=new Wit.Writer(this._annotationMeasurer,n)},t.prototype._getTickValues=function(){return[]},t.prototype.renderImmediately=function(){var r=this._getTickValues(),n=this._tickMarkContainer.selectAll("."+t.TICK_MARK_CLASS).data(r),i=n.enter().append("line").classed(t.TICK_MARK_CLASS,!0).merge(n);return i.attrs(this._generateTickMarkAttrHash()),yd.select(i.nodes()[0]).classed(t.END_TICK_MARK_CLASS,!0).attrs(this._generateTickMarkAttrHash(!0)),yd.select(i.nodes()[r.length-1]).classed(t.END_TICK_MARK_CLASS,!0).attrs(this._generateTickMarkAttrHash(!0)),n.exit().remove(),this._baseline.attrs(this._generateBaselineAttrHash()),this.annotationsEnabled()?this._drawAnnotations():this._removeAnnotations(),this},t.prototype.annotatedTicks=function(r){return r==null?this._annotatedTicks:(this._annotatedTicks=r,this.render(),this)},t.prototype.annotationFormatter=function(r){return r==null?this._annotationFormatter:(this._annotationFormatter=r,this.render(),this)},t.prototype.annotationsEnabled=function(r){return r==null?this._annotationsEnabled:(this._annotationsEnabled=r,this.redraw(),this)},t.prototype.annotationTierCount=function(r){if(r==null)return this._annotationTierCount;if(r<0)throw new Error("annotationTierCount cannot be negative");return this._annotationTierCount=r,this.redraw(),this},t.prototype._drawAnnotations=function(){var r=this,n=t._ANNOTATION_LABEL_PADDING,i=new xS.Map,o=this._annotatedTicksToRender();o.forEach(function(P){var k=r._annotationMeasurer.measure(r.annotationFormatter()(P)),O={width:k.width+2*n,height:k.height+2*n};i.set(P,O)});var a=this._annotationMeasurer.measure().height+2*n,s=this._annotationToTier(i),l=new xS.Set,c=this.isHorizontal()?this.height():this.width(),u=this._coreSize(),h=Math.min(this.annotationTierCount(),Math.floor((c-u)/a));s.forEach(function(P,k){(P===-1||P>=h)&&l.add(k)});var f=function(P,k,O){var D=P.selectAll("."+O).data(o),B=D.enter().append(k).classed(O,!0).merge(D);return D.exit().remove(),B},p=function(P){switch(r.orientation()){case"bottom":case"right":return s.get(P)*a+u;case"top":case"left":return c-u-s.get(P)*a}},d=function(P){return r._scale.scale(P)},g=function(P){return l.has(P)?"hidden":"visible"},_;switch(this.orientation()){case"bottom":case"right":_=0;break;case"top":_=this.height();break;case"left":_=this.width();break}var y=this.isHorizontal();f(this._annotationContainer.select(".annotation-line-container"),"line",t.ANNOTATION_LINE_CLASS).attrs({x1:y?d:_,x2:y?d:p,y1:y?_:d,y2:y?p:d,visibility:g}),f(this._annotationContainer.select(".annotation-circle-container"),"circle",t.ANNOTATION_CIRCLE_CLASS).attrs({cx:y?d:_,cy:y?_:d,r:3});var x=function(P){switch(r.orientation()){case"bottom":case"right":return p(P);case"top":case"left":return p(P)-i.get(P).height}};f(this._annotationContainer.select(".annotation-rect-container"),"rect",t.ANNOTATION_RECT_CLASS).attrs({x:y?d:x,y:y?x:d,width:y?function(P){return i.get(P).width}:function(P){return i.get(P).height},height:y?function(P){return i.get(P).height}:function(P){return i.get(P).width},visibility:g});var b=this._annotationWriter,S=this.annotationFormatter(),C=f(this._annotationContainer.select(".annotation-label-container"),"g",t.ANNOTATION_LABEL_CLASS);C.selectAll(".text-container").remove(),C.attrs({transform:function(P){var k=y?d(P):x(P),O=y?x(P):d(P);return"translate("+k+","+O+")"},visibility:g}).each(function(P){b.write(S(P),y?i.get(P).width:i.get(P).height,y?i.get(P).height:i.get(P).width,{xAlign:"center",yAlign:"center",textRotation:y?0:90},yd.select(this).node())})},t.prototype._annotatedTicksToRender=function(){var r=this,n=this._scale.range();return xS.Array.uniq(this.annotatedTicks().filter(function(i){return i==null?!1:xS.Math.inRange(r._scale.scale(i),n[0],n[1])}))},t.prototype._coreSize=function(){var r=this.isHorizontal()?this.height():this.width(),n=this.isHorizontal()?this._computeHeight():this._computeWidth();return Math.min(n,r)},t.prototype._annotationTierHeight=function(){return this._annotationMeasurer.measure().height+2*t._ANNOTATION_LABEL_PADDING},t.prototype._annotationToTier=function(r){var n=this,i=[[]],o=new xS.Map,a=this.isHorizontal()?this.width():this.height();return this._annotatedTicksToRender().forEach(function(s){var l=n._scale.scale(s),c=r.get(s).width;if(l<0||l+c>a){o.set(s,-1);return}for(var u=function(f){return i[f].some(function(p){var d=n._scale.scale(p),g=r.get(p).width;return l+c>=d&&l<=d+g})},h=0;u(h);)h++,i.length===h&&i.push([]);i[h].push(s),o.set(s,h)}),o},t.prototype._removeAnnotations=function(){this._annotationContainer.selectAll(".annotation-line").remove(),this._annotationContainer.selectAll(".annotation-circle").remove(),this._annotationContainer.selectAll(".annotation-rect").remove(),this._annotationContainer.selectAll(".annotation-label").remove()},t.prototype._generateBaselineAttrHash=function(){var r={x1:0,y1:0,x2:0,y2:0};switch(this._orientation){case"bottom":r.x2=this.width();break;case"top":r.x2=this.width(),r.y1=this.height(),r.y2=this.height();break;case"left":r.x1=this.width(),r.x2=this.width(),r.y2=this.height();break;case"right":r.y2=this.height();break}return r},t.prototype._generateTickMarkAttrHash=function(r){var n=this;r===void 0&&(r=!1);var i={x1:0,y1:0,x2:0,y2:0},o=function(s){return n._scale.scale(s)};this.isHorizontal()?(i.x1=o,i.x2=o):(i.y1=o,i.y2=o);var a=r?this._endTickLength:this._innerTickLength;switch(this._orientation){case"bottom":i.y2=a;break;case"top":i.y1=this.height(),i.y2=this.height()-a;break;case"left":i.x1=this.width(),i.x2=this.width()-a;break;case"right":i.x2=a;break}return i},t.prototype._setDefaultAlignment=function(){switch(this._orientation){case"bottom":this.yAlignment("top");break;case"top":this.yAlignment("bottom");break;case"left":this.xAlignment("right");break;case"right":this.xAlignment("left");break}},t.prototype.isHorizontal=function(){return this._orientation==="top"||this._orientation==="bottom"},t.prototype.getScale=function(){return this._scale},t.prototype.formatter=function(r){return r==null?this._formatter:(this._formatter=r,this.redraw(),this)},t.prototype.innerTickLength=function(r){if(r==null)return this._innerTickLength;if(r<0)throw new Error("inner tick length must be positive");return this._innerTickLength=r,this.redraw(),this},t.prototype.endTickLength=function(r){if(r==null)return this._endTickLength;if(r<0)throw new Error("end tick length must be positive");return this._endTickLength=r,this.redraw(),this},t.prototype._maxLabelTickLength=function(){return this.showEndTickLabels()?Math.max(this.innerTickLength(),this.endTickLength()):this.innerTickLength()},t.prototype.tickLabelPadding=function(r){if(r==null)return this._tickLabelPadding;if(r<0)throw new Error("tick label padding must be positive");return this._tickLabelPadding=r,this.redraw(),this},t.prototype.margin=function(r){if(r==null)return this._margin;if(r<0)throw new Error("margin size must be positive");return this._margin=r,this.redraw(),this},t.prototype.orientation=function(r){if(r==null)return this._orientation;var n=r.toLowerCase();if(n!=="top"&&n!=="bottom"&&n!=="left"&&n!=="right")throw new Error("unsupported orientation");return this._orientation=n,this.redraw(),this},t.prototype.showEndTickLabels=function(r){return r==null?this._showEndTickLabels:(this._showEndTickLabels=r,this.render(),this)},t.prototype._showAllTickMarks=function(){this._tickMarkContainer.selectAll("."+t.TICK_MARK_CLASS).each(function(){yd.select(this).style("visibility","inherit")})},t.prototype._showAllTickLabels=function(){this._tickLabelContainer.selectAll("."+t.TICK_LABEL_CLASS).each(function(){yd.select(this).style("visibility","inherit")})},t.prototype._hideOverflowingTickLabels=function(){var r=this.element().node().getBoundingClientRect(),n=this._tickLabelContainer.selectAll("."+t.TICK_LABEL_CLASS);n.empty()||n.each(function(i,o){xS.DOM.clientRectInside(this.getBoundingClientRect(),r)||yd.select(this).style("visibility","hidden")})},t.prototype._hideTickMarksWithoutLabel=function(){var r=this._tickMarkContainer.selectAll("."+t.TICK_MARK_CLASS),n=this._tickLabelContainer.selectAll("."+t.TICK_LABEL_CLASS).filter(function(o,a){var s=yd.select(this).style("visibility");return s==="inherit"||s==="visible"}),i=n.data();r.each(function(o,a){i.indexOf(o)===-1&&yd.select(this).style("visibility","hidden")})},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._annotationMeasurer.reset()},t.END_TICK_MARK_CLASS="end-tick-mark",t.TICK_MARK_CLASS="tick-mark",t.TICK_LABEL_CLASS="tick-label",t.ANNOTATION_LINE_CLASS="annotation-line",t.ANNOTATION_RECT_CLASS="annotation-rect",t.ANNOTATION_CIRCLE_CLASS="annotation-circle",t.ANNOTATION_LABEL_CLASS="annotation-label",t._ANNOTATION_LABEL_PADDING=4,t}(Aze.Component);NF.Axis=Ize});var GXt=H(Xit=>{"use strict";Object.defineProperty(Xit,"__esModule",{value:!0});var Lze=(de(),Ut(pe)),Yit=(Er(),Ut(Mr)),DF=_l(),kze=kc(),qXt=Fe(),jit=QA(),Rze=function(e){Lze.__extends(t,e);function t(r,n){n===void 0&&(n="bottom");var i=e.call(this,r,n)||this;return i._tickLabelAngle=0,i._tickLabelShearAngle=0,i.addClass("category-axis"),i}return Object.defineProperty(t.prototype,"_wrapper",{get:function(){var r=new DF.Wrapper;return this._tickLabelMaxLines!=null&&r.maxLines(this._tickLabelMaxLines),r},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"_writer",{get:function(){return new DF.Writer(this._measurer,this._typesetterContext,this._wrapper)},enumerable:!0,configurable:!0}),t.prototype._setup=function(){e.prototype._setup.call(this),this._typesetterContext=new DF.SvgContext(this._tickLabelContainer.node()),this._measurer=new DF.CacheMeasurer(this._typesetterContext)},t.prototype._rescale=function(){return this.redraw()},t.prototype.requestedSpace=function(r,n){var i=this.isHorizontal()?0:this._tickSpaceRequired()+this.margin(),o=this.isHorizontal()?this._tickSpaceRequired()+this.margin():0;if(this._scale.domain().length===0)return{minWidth:0,minHeight:0};if(this.annotationsEnabled()){var a=this._annotationTierHeight()*this.annotationTierCount();this.isHorizontal()?o+=a:i+=a}var s=this._measureTickLabels(r,n);return{minWidth:s.usedWidth+i,minHeight:s.usedHeight+o}},t.prototype._coreSize=function(){var r=this.isHorizontal()?this.height():this.width(),n=this.isHorizontal()?this.requestedSpace(this.width(),this.height()).minHeight:this.requestedSpace(this.width(),this.height()).minWidth,i=this.margin()+this._annotationTierHeight(),o=n-i;return Math.min(o,r)},t.prototype._getTickValues=function(){return this.getDownsampleInfo().domain},t.prototype._sizeFromOffer=function(r,n){return kze.Component.prototype._sizeFromOffer.call(this,r,n)},t.prototype.getDownsampleInfo=function(r,n){r===void 0&&(r=this._scale),n===void 0&&(n=r.invertRange());var i=this._tickLabelAngle===0?1:1/Math.cos(this._tickLabelShearAngle/180*Math.PI),o=t._MINIMUM_WIDTH_PER_LABEL_PX*i,a=Math.ceil(o/r.stepWidth());return{domain:n.filter(function(s,l){return l%a===0}),stepWidth:a*r.stepWidth()}},t.prototype.tickLabelAngle=function(r){if(r==null)return this._tickLabelAngle;if(r!==0&&r!==90&&r!==-90)throw new Error("Angle "+r+" not supported; only 0, 90, and -90 are valid values");return this._tickLabelAngle=r,this.redraw(),this},t.prototype.tickLabelShearAngle=function(r){if(r==null)return this._tickLabelShearAngle;if(r<-80||r>80)throw new Error("Angle "+r+" not supported; Must be between [-80, 80]");return this._tickLabelShearAngle=r,this.redraw(),this},t.prototype.tickLabelMaxWidth=function(r){return arguments.length===0?this._tickLabelMaxWidth:(this._tickLabelMaxWidth=r,this.redraw(),this)},t.prototype.tickLabelMaxLines=function(r){return arguments.length===0?this._tickLabelMaxLines:(this._tickLabelMaxLines=r,this.redraw(),this)},t.prototype._tickSpaceRequired=function(){return this._maxLabelTickLength()+this.tickLabelPadding()},t.prototype._drawTicks=function(r,n){var i=this,o,a;switch(this.tickLabelAngle()){case 0:o={left:"right",right:"left",top:"center",bottom:"center"},a={left:"center",right:"center",top:"bottom",bottom:"top"};break;case 90:o={left:"center",right:"center",top:"right",bottom:"left"},a={left:"top",right:"bottom",top:"center",bottom:"center"};break;case-90:o={left:"center",right:"center",top:"left",bottom:"right"},a={left:"bottom",right:"top",top:"center",bottom:"center"};break}n.each(function(s){var l=Yit.select(this),c=i.isHorizontal()?r:i.width()-i._tickSpaceRequired(),u=i.isHorizontal()?i.height()-i._tickSpaceRequired():r,h={xAlign:o[i.orientation()],yAlign:a[i.orientation()],textRotation:i.tickLabelAngle(),textShear:i.tickLabelShearAngle()};if(i._tickLabelMaxWidth!=null){if(i.orientation()==="left"&&c>i._tickLabelMaxWidth){var f=c-i._tickLabelMaxWidth,p=l.attr("transform")+" translate("+f+", 0)";l.attr("transform",p)}c=Math.min(c,i._tickLabelMaxWidth)}i._writer.write(i.formatter()(s),c,u,h,l.node())})},t.prototype._measureTickLabels=function(r,n){var i=this,o=this._scale,a=o.cloneWithoutProviders().range([0,this.isHorizontal()?r:n]),s=this.getDownsampleInfo(a),l=s.domain,c=s.stepWidth,u=r-this._tickSpaceRequired();this.isHorizontal()&&(u=c,this._tickLabelAngle!==0&&(u=n-this._tickSpaceRequired()),u=Math.max(u,0));var h=c;this.isHorizontal()&&(h=n-this._tickSpaceRequired(),this._tickLabelAngle!==0&&(h=r-this._tickSpaceRequired()),h=Math.max(h,0)),this._tickLabelMaxWidth!=null&&(u=Math.min(u,this._tickLabelMaxWidth));var f=l.map(function(x){return i._wrapper.wrap(i.formatter()(x),i._measurer,u,h)}),p=this.isHorizontal()&&this._tickLabelAngle===0?Yit.sum:qXt.Math.max,d=this.isHorizontal()&&this._tickLabelAngle===0?qXt.Math.max:Yit.sum,g=p(f,function(x){return i._measurer.measure(x.wrappedText).width},0),_=d(f,function(x){return i._measurer.measure(x.wrappedText).height},0);return this._tickLabelAngle!==0&&(y=[_,g],g=y[0],_=y[1]),{usedWidth:g,usedHeight:_};var y},t.prototype.renderImmediately=function(){var r=this;e.prototype.renderImmediately.call(this);var n=this._scale,i=this.getDownsampleInfo(n),o=i.domain,a=i.stepWidth,s=a;this.isHorizontal()&&this._tickLabelMaxWidth!=null&&(s=Math.min(s,this._tickLabelMaxWidth));var l=function(p,d){var g=n.scale(p)-s/2,_=r.isHorizontal()?g:0,y=r.isHorizontal()?0:g;return"translate("+_+","+y+")"},c=this._tickLabelContainer.selectAll("."+jit.Axis.TICK_LABEL_CLASS).data(o),u=c.enter().append("g").classed(jit.Axis.TICK_LABEL_CLASS,!0).merge(c);c.exit().remove(),u.attr("transform",l),u.text(""),this._drawTicks(a,u);var h=this.orientation()==="right"?this._tickSpaceRequired():0,f=this.orientation()==="bottom"?this._tickSpaceRequired():0;return this._tickLabelContainer.attr("transform","translate("+h+","+f+")"),this._showAllTickMarks(),this._showAllTickLabels(),this._hideTickMarksWithoutLabel(),this},t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this.isHorizontal()||this._scale.range([0,this.height()]),this},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._measurer.reset()},t._MINIMUM_WIDTH_PER_LABEL_PX=15,t}(jit.Axis);Xit.Category=Rze});var WXt=H(Kit=>{"use strict";Object.defineProperty(Kit,"__esModule",{value:!0});var Nze=(de(),Ut(pe)),OF=(Er(),Ut(Mr)),$it=_l(),Dze=Bu(),bS=Fe(),wS=QA(),Oze=function(e){Nze.__extends(t,e);function t(r,n){var i=e.call(this,r,n)||this;return i._tickLabelPositioning="center",i._usesTextWidthApproximation=!1,i.formatter(Dze.general()),i}return t.prototype._setup=function(){e.prototype._setup.call(this);var r=new $it.SvgContext(this._tickLabelContainer.node(),wS.Axis.TICK_LABEL_CLASS);this._measurer=new $it.CacheMeasurer(r),this._wrapper=new $it.Wrapper().maxLines(1)},t.prototype._computeWidth=function(){var r=this._usesTextWidthApproximation?this._computeApproximateTextWidth():this._computeExactTextWidth();return this._tickLabelPositioning==="center"?this._maxLabelTickLength()+this.tickLabelPadding()+r:Math.max(this._maxLabelTickLength(),this.tickLabelPadding()+r)},t.prototype._computeExactTextWidth=function(){var r=this,n=this._getTickValues(),i=n.map(function(o){var a=r.formatter()(o);return r._measurer.measure(a).width});return bS.Math.max(i,0)},t.prototype._computeApproximateTextWidth=function(){var r=this,n=this._getTickValues(),i=this._measurer.measure("M").width,o=n.map(function(a){var s=r.formatter()(a);return s.length*i});return bS.Math.max(o,0)},t.prototype._computeHeight=function(){var r=this._measurer.measure().height;return this._tickLabelPositioning==="center"?this._maxLabelTickLength()+this.tickLabelPadding()+r:Math.max(this._maxLabelTickLength(),this.tickLabelPadding()+r)},t.prototype._getTickValues=function(){var r=this._scale,n=r.domain(),i=n[0]<=n[1]?n[0]:n[1],o=n[0]>=n[1]?n[0]:n[1];return r.ticks().filter(function(a){return a>=i&&a<=o})},t.prototype._rescale=function(){if(!!this._isSetup){if(!this.isHorizontal()){var r=this._computeWidth();if(r>this.width()||r<this.width()-this.margin()){this.redraw();return}}this.render()}},t.prototype.renderImmediately=function(){var r=this;e.prototype.renderImmediately.call(this);var n={x:0,y:0,dx:"0em",dy:"0.3em"},i=this._maxLabelTickLength(),o=this.tickLabelPadding(),a="middle",s=0,l=0,c=0,u=0;if(this.isHorizontal())switch(this._tickLabelPositioning){case"left":a="end",s=-o,u=o;break;case"center":u=i+o;break;case"right":a="start",s=o,u=o;break}else switch(this._tickLabelPositioning){case"top":n.dy="-0.3em",c=o,l=-o;break;case"center":c=i+o;break;case"bottom":n.dy="1em",c=o,l=o;break}var h=this._generateTickMarkAttrHash();switch(this.orientation()){case"bottom":n.x=h.x1,n.dy="0.95em",l=h.y1+u;break;case"top":n.x=h.x1,n.dy="-.25em",l=h.y1-u;break;case"left":a="end",s=h.x1-c,n.y=h.y1;break;case"right":a="start",s=h.x1+c,n.y=h.y1;break}var f=this._getTickValues(),p=this._tickLabelContainer.selectAll("."+wS.Axis.TICK_LABEL_CLASS).data(f);p.exit().remove();var d=p.enter().append("text").classed(wS.Axis.TICK_LABEL_CLASS,!0).merge(p);d.style("text-anchor",a).style("visibility","inherit").attrs(n).text(function(_){return r.formatter()(_)});var g="translate("+s+", "+l+")";return this._tickLabelContainer.attr("transform",g),this._showAllTickMarks(),this.showEndTickLabels()||this._hideEndTickLabels(),this._hideOverflowingTickLabels(),this._hideOverlappingTickLabels(),this._tickLabelPositioning!=="center"&&this._hideTickMarksWithoutLabel(),this},t.prototype.tickLabelPosition=function(r){if(r==null)return this._tickLabelPositioning;var n=r.toLowerCase();if(this.isHorizontal()){if(!(n==="left"||n==="center"||n==="right"))throw new Error(n+" is not a valid tick label position for a horizontal NumericAxis")}else if(!(n==="top"||n==="center"||n==="bottom"))throw new Error(n+" is not a valid tick label position for a vertical NumericAxis");return this._tickLabelPositioning=n,this.redraw(),this},t.prototype.usesTextWidthApproximation=function(r){return r==null?this._usesTextWidthApproximation:(this._usesTextWidthApproximation=r,this)},t.prototype._hideEndTickLabels=function(){var r=this.element().node().getBoundingClientRect(),n=this._tickLabelContainer.selectAll("."+wS.Axis.TICK_LABEL_CLASS);if(n.size()!==0){var i=n.nodes()[0];bS.DOM.clientRectInside(i.getBoundingClientRect(),r)||OF.select(i).style("visibility","hidden");var o=n.nodes()[n.size()-1];bS.DOM.clientRectInside(o.getBoundingClientRect(),r)||OF.select(o).style("visibility","hidden")}},t.prototype._hideOverlappingTickLabels=function(){for(var r=this._tickLabelContainer.selectAll("."+wS.Axis.TICK_LABEL_CLASS).filter(function(o,a){var s=OF.select(this).style("visibility");return s==="inherit"||s==="visible"}),n=r.nodes().map(function(o){return o.getBoundingClientRect()}),i=1;!this._hasOverlapWithInterval(i,n)&&i<n.length;)i+=1;r.each(function(o,a){var s=OF.select(this);a%i!==0&&s.style("visibility","hidden")})},t.prototype._hasOverlapWithInterval=function(r,n){for(var i=this._tickLabelPositioning==="center"?this.tickLabelPadding():this.tickLabelPadding()*3,o=n.map(function(c){return bS.DOM.expandRect(c,i)}),a=0;a<o.length-r;a+=r){var s=o[a],l=o[a+r];if(bS.DOM.clientRectsOverlap(s,l))return!1}return!0},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._measurer.reset()},t}(wS.Axis);Kit.Numeric=Oze});var YXt=H(zF=>{"use strict";Object.defineProperty(zF,"__esModule",{value:!0});var zze=Fe();function Fze(e){if(e<=0)throw new Error("interval must be positive number");return function(t){var r=t.domain(),n=Math.min(r[0],r[1]),i=Math.max(r[0],r[1]),o=Math.ceil(n/e)*e,a=Math.floor((i-o)/e)+1,s=n%e===0?[]:[n],l=zze.Math.range(0,a).map(function(u){return o+u*e}),c=i%e===0?[]:[i];return s.concat(l).concat(c)}}zF.intervalTickGenerator=Fze;function Bze(){return function(e){var t=e.defaultTicks();return t.filter(function(r,n){return r%1===0||n===0||n===t.length-1})}}zF.integerTickGenerator=Bze});var t4=H(I1=>{"use strict";Object.defineProperty(I1,"__esModule",{value:!0});function Jit(e,t,r){return r-(r-e)*t}I1.zoomOut=Jit;function Zit(e,t,r){return(e*t-r)/(t-1)}function Hze(e,t,r,n,i,o,a){return t=jXt(e,t,n,i),XXt(e,t,r,o,a)}I1.constrainedZoom=Hze;function jXt(e,t,r,n){var i=t>1,o=i?n:r;if(o==null)return t;var a=e.getTransformationDomain(),s=a[0],l=a[1],c=Math.abs(l-s),u=i?Math.min:Math.max;return u(t,o/c)}I1.constrainZoomExtents=jXt;function XXt(e,t,r,n,i){if(t<=1)return{centerPoint:r,zoomAmount:t};if(n==null&&i==null)return{centerPoint:r,zoomAmount:t};var o=$Xt(e),a=Uze(e),s=a?1/0:-1/0,l=a?-1/0:1/0;n=n==null?s:n,i=i==null?l:i;var c=e.getTransformationDomain(),u=c[0],h=c[1],f=e.scaleTransformation(i),p=e.scaleTransformation(h),d=Jit(p,t,r),g=e.scaleTransformation(n),_=e.scaleTransformation(u),y=Jit(_,t,r),x=Math.abs(f-g),b=Math.abs(d-y);if(b>x){var S=(f-g)/(p-_);if(S!==1){var C=Zit(p,S,f);return{centerPoint:C,zoomAmount:S}}else return{centerPoint:r,zoomAmount:S}}else return d>f!=o?{centerPoint:Zit(p,t,f),zoomAmount:t}:y<g!=o?{centerPoint:Zit(_,t,g),zoomAmount:t}:{centerPoint:r,zoomAmount:t}}I1.constrainZoomValues=XXt;function Vze(e,t,r,n){var i=e.getTransformationDomain(),o=i[0],a=i[1],s=$Xt(e);if(t>0!==s){var l=n;if(l!=null){var c=e.scaleTransformation(a),u=e.scaleTransformation(l);t=(s?Math.max:Math.min)(c+t,u)-c}}else{var l=r;if(l!=null){var h=e.scaleTransformation(o),f=e.scaleTransformation(l);t=(s?Math.min:Math.max)(h+t,f)-h}}return t}I1.constrainedTranslation=Vze;function $Xt(e){var t=e.range();return t[1]<t[0]}function Uze(e){var t=e.getTransformationDomain();return t[1]<t[0]}});var L1=H(Qit=>{"use strict";Object.defineProperty(Qit,"__esModule",{value:!0});var KXt=Fe(),qze=function(){function e(){this._autoDomainAutomatically=!0,this._domainModificationInProgress=!1,this._updateId=0,this._callbacks=new KXt.CallbackSet,this._includedValuesProviders=new KXt.Set}return e.prototype.extentOfValues=function(t){return[]},e.prototype._getAllIncludedValues=function(t){var r=this;t===void 0&&(t=!1);var n=[];return this._includedValuesProviders.forEach(function(i){var o=i(r,t);n=n.concat(o)}),n},e.prototype._getExtent=function(){return[]},e.prototype.onUpdate=function(t){return this._callbacks.add(t),this},e.prototype.offUpdate=function(t){return this._callbacks.delete(t),this},e.prototype._dispatchUpdate=function(){this._updateId++,this._callbacks.callCallbacks(this)},e.prototype.autoDomain=function(){return this._autoDomainAutomatically=!0,this._setDomain(this._getExtent()),this},e.prototype.autoDomainIfAutomaticMode=function(){this._autoDomainAutomatically&&this.autoDomain()},e.prototype.scale=function(t){throw new Error("Subclasses should override scale")},e.prototype.ticks=function(){return this.domain()},e.prototype.domain=function(t){return t==null?this._getDomain():(this._autoDomainAutomatically=!1,this._setDomain(t),this)},e.prototype._getDomain=function(){throw new Error("Subclasses should override _getDomain")},e.prototype._setDomain=function(t){this._domainModificationInProgress||(this._domainModificationInProgress=!0,this._backingScaleDomain(t),this._dispatchUpdate(),this._domainModificationInProgress=!1)},e.prototype._backingScaleDomain=function(t){throw new Error("Subclasses should override _backingDomain")},e.prototype.range=function(t){return t==null?this._getRange():(this._setRange(t),this)},e.prototype._getRange=function(){throw new Error("Subclasses should override _getRange")},e.prototype._setRange=function(t){throw new Error("Subclasses should override _setRange")},e.prototype.addIncludedValuesProvider=function(t){return this._includedValuesProviders.add(t),this.autoDomainIfAutomaticMode(),this},e.prototype.removeIncludedValuesProvider=function(t){return this._includedValuesProviders.delete(t),this.autoDomainIfAutomaticMode(),this},e.prototype.updateId=function(){return this._updateId},e}();Qit.Scale=qze});var rot=H(eot=>{"use strict";Object.defineProperty(eot,"__esModule",{value:!0});var Gze=(de(),Ut(pe)),FF=(Er(),Ut(Mr)),Wze=t4(),ZXt=Fe(),Yze=L1(),tot=[0,1],jze=function(e){Gze.__extends(t,e);function t(){var r=e.call(this)||this;r._range=[0,1],r._d3Scale=FF.scaleBand(),r._d3Scale.range(tot),r._d3TransformationScale=FF.scaleLinear(),r._d3TransformationScale.domain(tot);var n=.3;return r._innerPadding=t._convertToPlottableInnerPadding(n),r._outerPadding=t._convertToPlottableOuterPadding(.5,n),r}return t.prototype.cloneWithoutProviders=function(){var r=new t().domain(this.domain()).range(this.range()).innerPadding(this.innerPadding()).outerPadding(this.outerPadding());return r._d3TransformationScale.domain(this._d3TransformationScale.domain()),r},t.prototype.extentOfValues=function(r){return ZXt.Array.uniq(r)},t.prototype._getExtent=function(){return ZXt.Array.uniq(this._getAllIncludedValues())},t.prototype.domain=function(r){return e.prototype.domain.call(this,r)},t.prototype.invertRange=function(r){var n=this;r===void 0&&(r=this.range());var i=this._d3Scale.bandwidth(),o=this.invertedTransformation(r[0]),a=this.invertedTransformation(r[1]),s=this._d3Scale.domain(),l=s.map(function(h){return n._d3Scale(h)+i/2}),c=FF.bisect(l,o),u=FF.bisect(l,a);return s.slice(c,u)},t.prototype.range=function(r){return e.prototype.range.call(this,r)},t._convertToPlottableInnerPadding=function(r){return 1/(1-r)-1},t._convertToPlottableOuterPadding=function(r,n){return r/(1-n)},t.prototype._setBands=function(){var r=1-1/(1+this.innerPadding()),n=this.outerPadding()/(1+this.innerPadding());this._d3Scale.paddingInner(r),this._d3Scale.paddingOuter(n)},t.prototype.rangeBand=function(){return this._rescaleBand(this._d3Scale.bandwidth())},t.prototype.stepWidth=function(){return this._rescaleBand(this._d3Scale.bandwidth()*(1+this.innerPadding()))},t.prototype.ticks=function(){return this.domain()},t.prototype.innerPadding=function(r){return r==null?this._innerPadding:(this._innerPadding=r,this.range(this.range()),this._dispatchUpdate(),this)},t.prototype.outerPadding=function(r){return r==null?this._outerPadding:(this._outerPadding=r,this.range(this.range()),this._dispatchUpdate(),this)},t.prototype.scale=function(r){var n=this._d3Scale(r)+this._d3Scale.bandwidth()/2;return this._d3TransformationScale(n)},t.prototype.zoom=function(r,n){var i=this,o=function(a){return i._d3TransformationScale.invert(Wze.zoomOut(a,r,n))};this._d3TransformationScale.domain(this._d3TransformationScale.range().map(o)),this._dispatchUpdate()},t.prototype.pan=function(r){var n=this,i=function(o){return n._d3TransformationScale.invert(o+r)};this._d3TransformationScale.domain(this._d3TransformationScale.range().map(i)),this._dispatchUpdate()},t.prototype.scaleTransformation=function(r){return this._d3TransformationScale(r)},t.prototype.invertedTransformation=function(r){return this._d3TransformationScale.invert(r)},t.prototype.getTransformationExtent=function(){return tot},t.prototype.getTransformationDomain=function(){return this._d3TransformationScale.domain()},t.prototype.setTransformationDomain=function(r){this._d3TransformationScale.domain(r),this._dispatchUpdate()},t.prototype._getDomain=function(){return this._backingScaleDomain()},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this._setBands(),this)},t.prototype._getRange=function(){return this._range},t.prototype._setRange=function(r){this._range=r,this._d3TransformationScale.range(r),this._setBands()},t.prototype._rescaleBand=function(r){return Math.abs(this._d3TransformationScale(r)-this._d3TransformationScale(0))},t}(Yze.Scale);eot.Category=jze});var JXt=H(not=>{"use strict";Object.defineProperty(not,"__esModule",{value:!0});var Xze=(de(),Ut(pe)),Nf=(Er(),Ut(Mr)),SS=Fe(),$ze=L1(),Kze=function(){function e(){this.count=0,this.tracker={}}return e.prototype.getIndex=function(t){if(this.tracker[t]!=null)return this.tracker[t];var r=this.count;return this.tracker[t]=r,this.count+=1,r},e.prototype.clear=function(){this.count=0,this.tracker={}},e}(),Zze=function(e){Xze.__extends(t,e);function t(r){var n=e.call(this)||this;n._rangeLength=1,n._tracker=new Kze;var i;switch(r){case null:case void 0:t._plottableColorCache==null&&(t._plottableColorCache=t._getPlottableColors()),i=Nf.scaleOrdinal().range(t._plottableColorCache);break;case"Category10":case"category10":case"10":i=Nf.scaleOrdinal(Nf.schemeCategory10);break;case"Category20":case"category20":case"20":i=Nf.scaleOrdinal(Nf.schemeCategory20);break;case"Category20b":case"category20b":case"20b":i=Nf.scaleOrdinal(Nf.schemeCategory20b);break;case"Category20c":case"category20c":case"20c":i=Nf.scaleOrdinal(Nf.schemeCategory20c);break;default:throw new Error("Unsupported ColorScale type")}return n._d3Scale=i,n._rangeLength=n._d3Scale.range().length,n}return t.prototype.extentOfValues=function(r){return SS.Array.uniq(r)},t.prototype._getExtent=function(){return SS.Array.uniq(this._getAllIncludedValues())},t.invalidateColorCache=function(){t._plottableColorCache=null},t._getPlottableColors=function(){for(var r=[],n=Nf.select("body").append("plottable-color-tester"),i=SS.Color.colorTest(n,""),o=0,a=SS.Color.colorTest(n,"plottable-colors-0");a!=null&&o<this._MAXIMUM_COLORS_FROM_CSS&&!(a===i&&a===r[r.length-1]);)r.push(a),o++,a=SS.Color.colorTest(n,"plottable-colors-"+o);return n.remove(),r},t.prototype.scale=function(r){var n=this._d3Scale(r),i=this._tracker.getIndex(r),o=Math.floor(i/this._rangeLength);if(o===0)return n;var a=Math.log(o*t._LOOP_LIGHTEN_FACTOR+1);return SS.Color.lightenColor(n,a)},t.prototype._getDomain=function(){return this._backingScaleDomain()},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this._tracker.clear(),this)},t.prototype._getRange=function(){return this._d3Scale.range()},t.prototype._setRange=function(r){this._d3Scale.range(r),this._rangeLength=r.length},t._LOOP_LIGHTEN_FACTOR=1.6,t._MAXIMUM_COLORS_FROM_CSS=256,t}($ze.Scale);not.Color=Zze});var t$t=H(iot=>{"use strict";Object.defineProperty(iot,"__esModule",{value:!0});var Jze=(de(),Ut(pe)),MS=(Er(),Ut(Mr)),QXt=Fe(),Qze=L1(),tFe=function(e){Jze.__extends(t,e);function t(r){r===void 0&&(r="linear");var n=e.call(this)||this;switch(r){case"linear":n._colorScale=MS.scaleLinear();break;case"log":n._colorScale=MS.scaleLog();break;case"sqrt":n._colorScale=MS.scaleSqrt();break;case"pow":n._colorScale=MS.scalePow();break}if(n._colorScale==null)throw new Error("unknown QuantitativeScale scale type "+r);return n.range(t.REDS),n}return t.prototype.extentOfValues=function(r){var n=MS.extent(r);return n[0]==null||n[1]==null?[]:n},t.prototype._d3InterpolatedScale=function(){return this._colorScale.range([0,1]).interpolate(this._interpolateColors())},t.prototype._interpolateColors=function(){var r=this._colorRange;if(r.length<2)throw new Error("Color scale arrays must have at least two elements.");return function(n,i){return function(o){o=Math.max(0,Math.min(1,o));var a=o*(r.length-1),s=Math.floor(a),l=Math.ceil(a),c=a-s;return MS.interpolateLab(r[s],r[l])(c)}}},t.prototype._resetScale=function(){this._d3Scale=this._d3InterpolatedScale(),this.autoDomainIfAutomaticMode(),this._dispatchUpdate()},t.prototype.autoDomain=function(){var r=this._getAllIncludedValues();return r.length>0&&this._setDomain([QXt.Math.min(r,0),QXt.Math.max(r,0)]),this},t.prototype.scale=function(r){return this._d3Scale(r)},t.prototype._getDomain=function(){return this._backingScaleDomain()},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this)},t.prototype._getRange=function(){return this._colorRange},t.prototype._setRange=function(r){this._colorRange=r,this._resetScale()},t.REDS=["#FFFFFF","#FFF6E1","#FEF4C0","#FED976","#FEB24C","#FD8D3C","#FC4E2A","#E31A1C","#B10026"],t.BLUES=["#FFFFFF","#CCFFFF","#A5FFFD","#85F7FB","#6ED3EF","#55A7E0","#417FD0","#2545D3","#0B02E1"],t.POSNEG=["#0B02E1","#2545D3","#417FD0","#55A7E0","#6ED3EF","#85F7FB","#A5FFFD","#CCFFFF","#FFFFFF","#FFF6E1","#FEF4C0","#FED976","#FEB24C","#FD8D3C","#FC4E2A","#E31A1C","#B10026"],t}(Qze.Scale);iot.InterpolatedColor=tFe});var vd=H(oot=>{"use strict";Object.defineProperty(oot,"__esModule",{value:!0});var eFe=(de(),Ut(pe)),rFe=(Er(),Ut(Mr)),nFe=t4(),ES=Fe(),iFe=L1(),oFe=function(e){eFe.__extends(t,e);function t(){var r=e.call(this)||this;return r._tickGenerator=function(n){return n.defaultTicks()},r._padProportion=.05,r._snappingDomainEnabled=!0,r._paddingExceptionsProviders=new ES.Set,r}return t.prototype.autoDomain=function(){return this._domainMin=null,this._domainMax=null,e.prototype.autoDomain.call(this),this},t.prototype.autoDomainIfAutomaticMode=function(){if(this._domainMin!=null&&this._domainMax!=null){this._setDomain([this._domainMin,this._domainMax]);return}var r=this._getExtent();if(this._domainMin!=null){var n=r[1];this._domainMin>=n&&(n=this._expandSingleValueDomain([this._domainMin,this._domainMin])[1]),this._setDomain([this._domainMin,n]);return}if(this._domainMax!=null){var i=r[0];this._domainMax<=i&&(i=this._expandSingleValueDomain([this._domainMax,this._domainMax])[0]),this._setDomain([i,this._domainMax]);return}e.prototype.autoDomainIfAutomaticMode.call(this)},t.prototype._getUnboundedExtent=function(r){r===void 0&&(r=!1);var n=this._getAllIncludedValues(r),i=this._defaultExtent();if(n.length!==0){var o=[ES.Math.min(n,i[0]),ES.Math.max(n,i[1])];i=this._padDomain(o)}return i},t.prototype._getExtent=function(){var r=this._getUnboundedExtent();return this._domainMin!=null&&(r[0]=this._domainMin),this._domainMax!=null&&(r[1]=this._domainMax),r},t.prototype.addPaddingExceptionsProvider=function(r){return this._paddingExceptionsProviders.add(r),this.autoDomainIfAutomaticMode(),this},t.prototype.removePaddingExceptionsProvider=function(r){return this._paddingExceptionsProviders.delete(r),this.autoDomainIfAutomaticMode(),this},t.prototype.padProportion=function(r){if(r==null)return this._padProportion;if(r<0)throw new Error("padProportion must be non-negative");return this._padProportion=r,this.autoDomainIfAutomaticMode(),this},t.prototype._padDomain=function(r){var n=this;if(r[0].valueOf()===r[1].valueOf())return this._expandSingleValueDomain(r);if(this._padProportion===0)return r;var i=this._padProportion/2,o=r[0],a=r[1],s=!1,l=!1;this._paddingExceptionsProviders.forEach(function(f){var p=f(n);p.forEach(function(d){d.valueOf()===o.valueOf()&&(s=!0),d.valueOf()===a.valueOf()&&(l=!0)})});var c=this._backingScaleDomain();this._backingScaleDomain(r);var u=s?o:this.invert(this.scale(o)-(this.scale(a)-this.scale(o))*i),h=l?a:this.invert(this.scale(a)+(this.scale(a)-this.scale(o))*i);return this._backingScaleDomain(c),this._snappingDomainEnabled?this._niceDomain([u,h]):[u,h]},t.prototype.snappingDomainEnabled=function(r){return r==null?this._snappingDomainEnabled:(this._snappingDomainEnabled=r,this.autoDomainIfAutomaticMode(),this)},t.prototype._expandSingleValueDomain=function(r){return r},t.prototype.invert=function(r){throw new Error("Subclasses should override invert")},t.prototype.domain=function(r){return r!=null&&(this._domainMin=r[0],this._domainMax=r[1]),e.prototype.domain.call(this,r)},t.prototype.domainMin=function(r){return r==null?this.domain()[0]:(this._domainMin=r,this.autoDomainIfAutomaticMode(),this)},t.prototype.domainMax=function(r){return r==null?this.domain()[1]:(this._domainMax=r,this.autoDomainIfAutomaticMode(),this)},t.prototype.extentOfValues=function(r){var n=rFe.extent(r.filter(function(i){return ES.Math.isValidNumber(+i)}));return n[0]==null||n[1]==null?[]:n},t.prototype.zoom=function(r,n){var i=this,o=function(a){return i.invert(nFe.zoomOut(a,r,n))};this.domain(this.range().map(o))},t.prototype.pan=function(r){var n=this,i=function(o){return n.invert(o+r)};this.domain(this.range().map(i))},t.prototype.scaleTransformation=function(r){throw new Error("Subclasses should override scaleTransformation")},t.prototype.invertedTransformation=function(r){throw new Error("Subclasses should override invertedTransformation")},t.prototype.getTransformationExtent=function(){throw new Error("Subclasses should override getTransformationExtent")},t.prototype.getTransformationDomain=function(){throw new Error("Subclasses should override getTransformationDomain")},t.prototype.setTransformationDomain=function(r){throw new Error("Subclasses should override setTransformationDomain")},t.prototype._setDomain=function(r){var n=function(i){return ES.Math.isNaN(i)||i===1/0||i===-1/0};if(n(r[0])||n(r[1])){ES.Window.warn("Warning: QuantitativeScales cannot take NaN or Infinity as a domain value. Ignoring.");return}e.prototype._setDomain.call(this,r)},t.prototype.defaultTicks=function(){throw new Error("Subclasses should override _getDefaultTicks")},t.prototype.ticks=function(){return this._tickGenerator(this)},t.prototype._niceDomain=function(r,n){throw new Error("Subclasses should override _niceDomain")},t.prototype._defaultExtent=function(){throw new Error("Subclasses should override _defaultExtent")},t.prototype.tickGenerator=function(r){return r==null?this._tickGenerator:(this._tickGenerator=r,this)},t._DEFAULT_NUM_TICKS=10,t}(iFe.Scale);oot.QuantitativeScale=oFe});var e$t=H(aot=>{"use strict";Object.defineProperty(aot,"__esModule",{value:!0});var aFe=(de(),Ut(pe)),sFe=(Er(),Ut(Mr)),lFe=vd(),cFe=function(e){aFe.__extends(t,e);function t(){var r=e.call(this)||this;return r._d3Scale=sFe.scaleLinear(),r}return t.prototype._defaultExtent=function(){return[0,1]},t.prototype._expandSingleValueDomain=function(r){return r[0]===r[1]?[r[0]-1,r[1]+1]:r},t.prototype.scale=function(r){return this._d3Scale(r)},t.prototype.scaleTransformation=function(r){return this.scale(r)},t.prototype.invertedTransformation=function(r){return this.invert(r)},t.prototype.getTransformationExtent=function(){return this._getUnboundedExtent(!0)},t.prototype.getTransformationDomain=function(){return this.domain()},t.prototype.setTransformationDomain=function(r){this.domain(r)},t.prototype._getDomain=function(){return this._backingScaleDomain()},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this)},t.prototype._getRange=function(){return this._d3Scale.range()},t.prototype._setRange=function(r){this._d3Scale.range(r)},t.prototype.invert=function(r){return this._d3Scale.invert(r)},t.prototype.defaultTicks=function(){return this._d3Scale.ticks(t._DEFAULT_NUM_TICKS)},t.prototype._niceDomain=function(r,n){return this._d3Scale.copy().domain(r).nice(n).domain()},t}(lFe.QuantitativeScale);aot.Linear=cFe});var r$t=H(sot=>{"use strict";Object.defineProperty(sot,"__esModule",{value:!0});var uFe=(de(),Ut(pe)),hFe=(Er(),Ut(Mr)),fFe=vd(),pFe=function(e){uFe.__extends(t,e);function t(r){r===void 0&&(r=10);var n=e.call(this)||this;return n._d3Scale=hFe.scaleLog().base(r),n._setDomain(n._defaultExtent()),n}return t.prototype._defaultExtent=function(){return[1,this._d3Scale.base()]},t.prototype._expandSingleValueDomain=function(r){return r[0]===r[1]?[r[0]/this._d3Scale.base(),r[1]*this._d3Scale.base()]:r},t.prototype.scale=function(r){return this._d3Scale(r)},t.prototype.scaleTransformation=function(r){return this.scale(r)},t.prototype.invertedTransformation=function(r){return this.invert(r)},t.prototype.getTransformationExtent=function(){return this._getUnboundedExtent(!0)},t.prototype.getTransformationDomain=function(){return this.domain()},t.prototype.setTransformationDomain=function(r){this.domain(r)},t.prototype._getDomain=function(){return this._backingScaleDomain()},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this)},t.prototype._getRange=function(){return this._d3Scale.range()},t.prototype._setRange=function(r){this._d3Scale.range(r)},t.prototype.invert=function(r){return this._d3Scale.invert(r)},t.prototype.defaultTicks=function(){return this._d3Scale.ticks(t._DEFAULT_NUM_TICKS)},t.prototype._niceDomain=function(r,n){return this._d3Scale.copy().domain(r).nice().domain()},t}(fFe.QuantitativeScale);sot.Log=pFe});var n$t=H(cot=>{"use strict";Object.defineProperty(cot,"__esModule",{value:!0});var dFe=(de(),Ut(pe)),e4=(Er(),Ut(Mr)),TS=Fe(),lot=ks(),mFe=vd(),gFe=function(e){dFe.__extends(t,e);function t(r){r===void 0&&(r=10);var n=e.call(this)||this;if(n._logTickGenerator=function(i){var o=function(x,b,S){return[x,b,S].sort(function(C,P){return C-P})[1]},a=TS.Math.min(n._untransformedDomain,0),s=TS.Math.max(n._untransformedDomain,0),l=a,c=o(a,s,-n._pivot),u=o(a,s,n._pivot),h=s,f=n._logTicks(-c,-l).map(function(x){return-x}).reverse(),p=n._logTicks(u,h),d=Math.max(a,-n._pivot),g=Math.min(s,n._pivot),_=e4.scaleLinear().domain([d,g]).ticks(n._howManyTicks(d,g)),y=f.concat(_).concat(p);return y.length<=1&&(y=e4.scaleLinear().domain([a,s]).ticks(lot.ModifiedLog._DEFAULT_NUM_TICKS)),y},n._d3Scale=e4.scaleLinear(),n._base=r,n._pivot=n._base,n._setDomain(n._defaultExtent()),n.tickGenerator(n._logTickGenerator),r<=1)throw new Error("ModifiedLogScale: The base must be > 1");return n}return t.prototype._adjustedLog=function(r){var n=r<0?-1:1;return r*=n,r<this._pivot&&(r+=(this._pivot-r)/this._pivot),r=Math.log(r)/Math.log(this._base),r*=n,r},t.prototype._invertedAdjustedLog=function(r){var n=r<0?-1:1;return r*=n,r=Math.pow(this._base,r),r<this._pivot&&(r=this._pivot*(r-1)/(this._pivot-1)),r*=n,r},t.prototype.scale=function(r){return this._d3Scale(this._adjustedLog(r))},t.prototype.invert=function(r){return this._invertedAdjustedLog(this._d3Scale.invert(r))},t.prototype.scaleTransformation=function(r){return this.scale(r)},t.prototype.invertedTransformation=function(r){return this.invert(r)},t.prototype.getTransformationExtent=function(){return this._getUnboundedExtent(!0)},t.prototype.getTransformationDomain=function(){return this.domain()},t.prototype.setTransformationDomain=function(r){this.domain(r)},t.prototype._getDomain=function(){return this._untransformedDomain},t.prototype._setDomain=function(r){this._untransformedDomain=r;var n=[this._adjustedLog(r[0]),this._adjustedLog(r[1])];e.prototype._setDomain.call(this,n)},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this)},t.prototype._logTicks=function(r,n){var i=this,o=this._howManyTicks(r,n);if(o===0)return[];var a=Math.floor(Math.log(r)/Math.log(this._base)),s=Math.ceil(Math.log(n)/Math.log(this._base)),l=e4.range(s,a,-Math.ceil((s-a)/o)),c=e4.range(this._base,1,-(this._base-1)).map(Math.floor),u=TS.Array.uniq(c),h=l.map(function(g){return u.map(function(_){return Math.pow(i._base,g-1)*_})}),f=TS.Array.flatten(h),p=f.filter(function(g){return r<=g&&g<=n}),d=p.sort(function(g,_){return g-_});return d},t.prototype._howManyTicks=function(r,n){var i=this._adjustedLog(TS.Math.min(this._untransformedDomain,0)),o=this._adjustedLog(TS.Math.max(this._untransformedDomain,0)),a=this._adjustedLog(r),s=this._adjustedLog(n),l=(s-a)/(o-i),c=Math.ceil(l*lot.ModifiedLog._DEFAULT_NUM_TICKS);return c},t.prototype._niceDomain=function(r,n){return r},t.prototype._defaultExtent=function(){return[0,this._base]},t.prototype._expandSingleValueDomain=function(r){if(r[0]===r[1]){var n=r[0];return n>0?[n/this._base,n*this._base]:n===0?[-this._base,this._base]:[n*this._base,n/this._base]}return r},t.prototype._getRange=function(){return this._d3Scale.range()},t.prototype._setRange=function(r){this._d3Scale.range(r)},t.prototype.defaultTicks=function(){return this._d3Scale.ticks(lot.ModifiedLog._DEFAULT_NUM_TICKS)},t}(mFe.QuantitativeScale);cot.ModifiedLog=gFe});var i$t=H(uot=>{"use strict";Object.defineProperty(uot,"__esModule",{value:!0});var _Fe=(de(),Ut(pe)),ga=(Er(),Ut(Mr)),k1=BF(),yFe=vd(),vFe=function(e){_Fe.__extends(t,e);function t(){var r=e.call(this)||this;return r._d3Scale=ga.scaleTime(),r.autoDomain(),r}return t.prototype.tickInterval=function(r,n,i){n===void 0&&(n=1),i===void 0&&(i=!1);var o=ga.scaleTime(),a=t.timeIntervalToD3Time(r,i).every(n);return o.domain(this.domain()),o.range(this.range()),o.ticks(a)},t.prototype._setDomain=function(r){if(r[1]<r[0])throw new Error("Scale.Time domain values must be in chronological order");return e.prototype._setDomain.call(this,r)},t.prototype._defaultExtent=function(){return[new Date("1970-01-01"),new Date("1970-01-02")]},t.prototype._expandSingleValueDomain=function(r){var n=r[0].getTime(),i=r[1].getTime();if(n===i){var o=new Date(n);o.setDate(o.getDate()-1);var a=new Date(i);return a.setDate(a.getDate()+1),[o,a]}return r},t.prototype.scale=function(r){return this._d3Scale(r)},t.prototype.scaleTransformation=function(r){return this.scale(new Date(r))},t.prototype.invertedTransformation=function(r){return this.invert(r).getTime()},t.prototype.getTransformationExtent=function(){var r=this._getUnboundedExtent(!0);return[r[0].valueOf(),r[1].valueOf()]},t.prototype.getTransformationDomain=function(){var r=this.domain();return[r[0].valueOf(),r[1].valueOf()]},t.prototype.setTransformationDomain=function(r){var n=r[0],i=r[1];this.domain([new Date(n),new Date(i)])},t.prototype._getDomain=function(){return this._backingScaleDomain()},t.prototype._backingScaleDomain=function(r){return r==null?this._d3Scale.domain():(this._d3Scale.domain(r),this)},t.prototype._getRange=function(){return this._d3Scale.range()},t.prototype._setRange=function(r){this._d3Scale.range(r)},t.prototype.invert=function(r){return this._d3Scale.invert(r)},t.prototype.defaultTicks=function(){return this._d3Scale.ticks(t._DEFAULT_NUM_TICKS)},t.prototype._niceDomain=function(r){return this._d3Scale.copy().domain(r).nice().domain()},t.timeIntervalToD3Time=function(r,n){switch(r){case k1.TimeInterval.second:return n?ga.utcSecond:ga.timeSecond;case k1.TimeInterval.minute:return n?ga.utcMinute:ga.timeMinute;case k1.TimeInterval.hour:return n?ga.utcHour:ga.timeHour;case k1.TimeInterval.day:return n?ga.utcDay:ga.timeDay;case k1.TimeInterval.week:return n?ga.utcWeek:ga.timeWeek;case k1.TimeInterval.month:return n?ga.utcMonth:ga.timeMonth;case k1.TimeInterval.year:return n?ga.utcYear:ga.timeYear;default:throw Error("TimeInterval specified does not exist: "+r)}},t}(yFe.QuantitativeScale);uot.Time=vFe});var ks=H(Hu=>{"use strict";Object.defineProperty(Hu,"__esModule",{value:!0});var R1=(de(),Ut(pe)),xFe=YXt();Hu.TickGenerators=xFe;R1.__exportStar(rot(),Hu);R1.__exportStar(JXt(),Hu);R1.__exportStar(t$t(),Hu);R1.__exportStar(e$t(),Hu);R1.__exportStar(r$t(),Hu);R1.__exportStar(n$t(),Hu);R1.__exportStar(i$t(),Hu);var bFe=rot(),wFe=vd();function SFe(e){return e instanceof wFe.QuantitativeScale||e instanceof bFe.Category}Hu.isTransformable=SFe});var BF=H(Se=>{"use strict";Object.defineProperty(Se,"__esModule",{value:!0});var MFe=(de(),Ut(pe)),Vu=(Er(),Ut(Mr)),o$t=_l(),a$t=Bu(),EFe=ks(),r4=Fe(),hot=If(),ts=QA();Se.TimeInterval=hot.makeEnum(["second","minute","hour","day","week","month","year"]);Se.TimeAxisOrientation=hot.makeEnum(["top","bottom"]);Se.TierLabelPosition=hot.makeEnum(["between","center"]);var TFe=function(e){MFe.__extends(t,e);function t(r,n,i){var o=e.call(this,r,n)||this;return o._maxTimeIntervalPrecision=null,o._tierLabelPositions=[],o._useUTC=i,o.addClass("time-axis"),o.tickLabelPadding(5),o.axisConfigurations(t._DEFAULT_TIME_AXIS_CONFIGURATIONS(o._useUTC)),o.annotationFormatter(a$t.time("%a %b %d, %Y",o._useUTC)),o}return t.prototype.tierLabelPositions=function(r){if(r==null)return this._tierLabelPositions;if(!r.every(function(n){return n.toLowerCase()==="between"||n.toLowerCase()==="center"}))throw new Error("Unsupported position for tier labels");return this._tierLabelPositions=r,this.redraw(),this},t.prototype.maxTimeIntervalPrecision=function(r){return r==null?this._maxTimeIntervalPrecision:(this._maxTimeIntervalPrecision=r,this.redraw(),this)},t.prototype.currentAxisConfiguration=function(){return this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex]},t.prototype.axisConfigurations=function(r){if(r==null)return this._possibleTimeAxisConfigurations;this._possibleTimeAxisConfigurations=r,this._numTiers=r4.Math.max(this._possibleTimeAxisConfigurations.map(function(a){return a.length}),0),this._isAnchored&&this._setupDomElements();for(var n=this.tierLabelPositions(),i=[],o=0;o<this._numTiers;o++)i.push(n[o]||"between");return this.tierLabelPositions(i),this.redraw(),this},t.prototype._getMostPreciseConfigurationIndex=function(){var r=this,n=this._possibleTimeAxisConfigurations.length;return this._possibleTimeAxisConfigurations.forEach(function(i,o){o<n&&i.every(function(a){return r._checkTimeAxisTierConfiguration(a)})&&(n=o)}),n===this._possibleTimeAxisConfigurations.length&&(r4.Window.warn("zoomed out too far: could not find suitable interval to display labels"),--n),n},t.prototype.orientation=function(r){if(r&&(r.toLowerCase()==="right"||r.toLowerCase()==="left"))throw new Error(r+" is not a supported orientation for TimeAxis - only horizontal orientations are supported");return e.prototype.orientation.call(this,r)},t.prototype._computeHeight=function(){var r=this._measurer.measure().height;this._tierHeights=[];for(var n=0;n<this._numTiers;n++)this._tierHeights.push(r+this.tickLabelPadding()+(this._tierLabelPositions[n]==="between"?0:this._maxLabelTickLength()));return Vu.sum(this._tierHeights)},t.prototype._getIntervalLength=function(r){var n=this._scale.domain()[0],i=EFe.Time.timeIntervalToD3Time(r.interval,this._useUTC),o=i.offset(n,r.step);if(o>this._scale.domain()[1])return this.width();var a=Math.abs(this._scale.scale(o)-this._scale.scale(n));return a},t.prototype._maxWidthForInterval=function(r){return this._measurer.measure(r.formatter(t._LONG_DATE)).width},t.prototype._checkTimeAxisTierConfiguration=function(r){if(this._maxTimeIntervalPrecision!=null){var n=t._SORTED_TIME_INTERVAL_INDEX[this._maxTimeIntervalPrecision],i=t._SORTED_TIME_INTERVAL_INDEX[r.interval];if(n!=null&&i!=null&&i<n)return!1}var o=this._maxWidthForInterval(r)+2*this.tickLabelPadding();return Math.min(this._getIntervalLength(r),this.width())>=o},t.prototype._sizeFromOffer=function(r,n){var i=e.prototype._sizeFromOffer.call(this,r,n),o=this._tierHeights.reduce(function(s,l,c,u){return s+l>i.height?s:s+l}),a=this.margin()+(this.annotationsEnabled()?this.annotationTierCount()*this._annotationTierHeight():0);return i.height=Math.min(i.height,o+a),i},t.prototype._setup=function(){e.prototype._setup.call(this),this._setupDomElements()},t.prototype._setupDomElements=function(){this.content().selectAll("."+t.TIME_AXIS_TIER_CLASS).remove(),this._tierLabelContainers=[],this._tierMarkContainers=[],this._tierBaselines=[],this._tickLabelContainer.remove(),this._baseline.remove();for(var r=0;r<this._numTiers;++r){var n=this.content().append("g").classed(t.TIME_AXIS_TIER_CLASS,!0);this._tierLabelContainers.push(n.append("g").classed(ts.Axis.TICK_LABEL_CLASS+"-container",!0)),this._tierMarkContainers.push(n.append("g").classed(ts.Axis.TICK_MARK_CLASS+"-container",!0)),this._tierBaselines.push(n.append("line").classed("baseline",!0))}var i=new o$t.SvgContext(this._tierLabelContainers[0].node());this._measurer=new o$t.CacheMeasurer(i)},t.prototype._getTickIntervalValues=function(r){return this._scale.tickInterval(r.interval,r.step,this._useUTC)},t.prototype._getTickValues=function(){var r=this;return this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex].reduce(function(n,i){return n.concat(r._getTickIntervalValues(i))},[])},t.prototype._cleanTiers=function(){for(var r=0;r<this._tierLabelContainers.length;r++)this._tierLabelContainers[r].selectAll("."+ts.Axis.TICK_LABEL_CLASS).remove(),this._tierMarkContainers[r].selectAll("."+ts.Axis.TICK_MARK_CLASS).remove(),this._tierBaselines[r].style("visibility","hidden")},t.prototype._getTickValuesForConfiguration=function(r){var n=this._scale.tickInterval(r.interval,r.step,this._useUTC),i=this._scale.domain(),o=n.map(function(a){return a.valueOf()});return o.indexOf(i[0].valueOf())===-1&&n.unshift(i[0]),o.indexOf(i[1].valueOf())===-1&&n.push(i[1]),n},t.prototype._renderTierLabels=function(r,n,i){var o=this,a=this._getTickValuesForConfiguration(n),s=[];this._tierLabelPositions[i]==="between"&&n.step===1?a.map(function(g,_){_+1>=a.length||s.push(new Date((a[_+1].valueOf()-a[_].valueOf())/2+a[_].valueOf()))}):s=a;var l=r.selectAll("."+ts.Axis.TICK_LABEL_CLASS).data(s,function(g){return String(g.valueOf())}),c=l.enter().append("g").classed(ts.Axis.TICK_LABEL_CLASS,!0);c.append("text");var u=this._tierLabelPositions[i]==="center"||n.step===1?0:this.tickLabelPadding(),h;this.orientation()==="bottom"?h=Vu.sum(this._tierHeights.slice(0,i+1))-this.tickLabelPadding():this._tierLabelPositions[i]==="center"?h=this.height()-Vu.sum(this._tierHeights.slice(0,i))-this.tickLabelPadding()-this._maxLabelTickLength():h=this.height()-Vu.sum(this._tierHeights.slice(0,i))-this.tickLabelPadding();var f=l.merge(c),p=f.selectAll("text");p.size()>0&&p.attr("transform","translate("+u+","+h+")"),l.exit().remove(),f.attr("transform",function(g){return"translate("+o._scale.scale(g)+",0)"});var d=this._tierLabelPositions[i]==="center"||n.step===1?"middle":"start";f.selectAll("text").text(n.formatter).style("text-anchor",d)},t.prototype._renderTickMarks=function(r,n){var i=this._tierMarkContainers[n].selectAll("."+ts.Axis.TICK_MARK_CLASS).data(r),o=i.enter().append("line").classed(ts.Axis.TICK_MARK_CLASS,!0).merge(i),a=this._generateTickMarkAttrHash(),s=this._tierHeights.slice(0,n).reduce(function(l,c){return l+c},0);this.orientation()==="bottom"?(a.y1=s,a.y2=s+(this._tierLabelPositions[n]==="center"?this.innerTickLength():this._tierHeights[n])):(a.y1=this.height()-s,a.y2=this.height()-(s+(this._tierLabelPositions[n]==="center"?this.innerTickLength():this._tierHeights[n]))),o.attrs(a),this.orientation()==="bottom"?(a.y1=s,a.y2=s+(this._tierLabelPositions[n]==="center"?this.endTickLength():this._tierHeights[n])):(a.y1=this.height()-s,a.y2=this.height()-(s+(this._tierLabelPositions[n]==="center"?this.endTickLength():this._tierHeights[n]))),Vu.select(o.nodes()[0]).attrs(a),Vu.select(o.nodes()[o.size()-1]).attrs(a),Vu.select(o.nodes()[0]).classed(ts.Axis.END_TICK_MARK_CLASS,!0),Vu.select(o.nodes()[o.size()-1]).classed(ts.Axis.END_TICK_MARK_CLASS,!0),i.exit().remove()},t.prototype._renderLabellessTickMarks=function(r){var n=this._tickMarkContainer.selectAll("."+ts.Axis.TICK_MARK_CLASS).data(r),i=n.enter().append("line").classed(ts.Axis.TICK_MARK_CLASS,!0).merge(n),o=this._generateTickMarkAttrHash();o.y2=this.orientation()==="bottom"?this.tickLabelPadding():this.height()-this.tickLabelPadding(),i.attrs(o),n.exit().remove()},t.prototype._generateLabellessTicks=function(){return this._mostPreciseConfigIndex<1?[]:this._getTickIntervalValues(this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex-1][0])},t.prototype.renderImmediately=function(){var r=this;this._mostPreciseConfigIndex=this._getMostPreciseConfigurationIndex();var n=this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex];this._cleanTiers(),n.forEach(function(h,f){return r._renderTierLabels(r._tierLabelContainers[f],h,f)});for(var i=n.map(function(h,f){return r._getTickValuesForConfiguration(h)}),o=0,a=0;a<Math.max(n.length,1);++a){var s=this._generateBaselineAttrHash();s.y1+=this.orientation()==="bottom"?o:-o,s.y2=s.y1,this._tierBaselines[a].attrs(s).style("visibility","inherit"),o+=this._tierHeights[a]}var l=[],c=this._scale.domain(),u=this._scale.scale(c[1])-this._scale.scale(c[0]);this._getIntervalLength(n[0])*1.5>=u&&(l=this._generateLabellessTicks()),this._renderLabellessTickMarks(l),this._hideOverflowingTiers();for(var a=0;a<n.length;++a)this._renderTickMarks(i[a],a),this._hideOverlappingAndCutOffLabels(a);return this.annotationsEnabled()?this._drawAnnotations():this._removeAnnotations(),this},t.prototype._hideOverflowingTiers=function(){var r=this,n=this.height(),i=0;this.content().selectAll("."+t.TIME_AXIS_TIER_CLASS).attr("visibility",function(o,a){return i+=r._tierHeights[a],i<=n?"inherit":"hidden"})},t.prototype._hideOverlappingAndCutOffLabels=function(r){var n=this,i=this.element().node().getBoundingClientRect(),o=function(u){return Math.floor(i.left)<=Math.ceil(u.left)&&Math.floor(i.top)<=Math.ceil(u.top)&&Math.floor(u.right)<=Math.ceil(i.left+n.width())&&Math.floor(u.bottom)<=Math.ceil(i.top+n.height())},a=this._tierMarkContainers[r].selectAll("."+ts.Axis.TICK_MARK_CLASS).filter(function(u,h){var f=Vu.select(this).style("visibility");return f==="visible"||f==="inherit"}),s=a.nodes().map(function(u){return u.getBoundingClientRect()}),l=this._tierLabelContainers[r].selectAll("."+ts.Axis.TICK_LABEL_CLASS).filter(function(u,h){var f=Vu.select(this).style("visibility");return f==="visible"||f==="inherit"}),c;l.each(function(u,h){var f=this.getBoundingClientRect(),p=Vu.select(this),d=s[h],g=s[h+1],_=c!=null&&r4.DOM.clientRectsOverlap(f,c),y=d!=null&&r4.DOM.clientRectsOverlap(f,d),x=g!=null&&r4.DOM.clientRectsOverlap(f,g);!o(f)||_||y||x?p.style("visibility","hidden"):(c=f,p.style("visibility","inherit"))})},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._measurer.reset()},t.TIME_AXIS_TIER_CLASS="time-axis-tier",t._SORTED_TIME_INTERVAL_INDEX=(xd={},xd[Se.TimeInterval.second]=0,xd[Se.TimeInterval.minute]=1,xd[Se.TimeInterval.hour]=2,xd[Se.TimeInterval.day]=3,xd[Se.TimeInterval.week]=4,xd[Se.TimeInterval.month]=5,xd[Se.TimeInterval.year]=6,xd),t._DEFAULT_TIME_AXIS_CONFIGURATIONS=function(r){var n=function(i){return a$t.time(i,r)};return[[{interval:Se.TimeInterval.second,step:1,formatter:n("%I:%M:%S %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.second,step:5,formatter:n("%I:%M:%S %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.second,step:10,formatter:n("%I:%M:%S %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.second,step:15,formatter:n("%I:%M:%S %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.second,step:30,formatter:n("%I:%M:%S %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.minute,step:1,formatter:n("%I:%M %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.minute,step:5,formatter:n("%I:%M %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.minute,step:10,formatter:n("%I:%M %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.minute,step:15,formatter:n("%I:%M %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.minute,step:30,formatter:n("%I:%M %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.hour,step:1,formatter:n("%I %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.hour,step:3,formatter:n("%I %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.hour,step:6,formatter:n("%I %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.hour,step:12,formatter:n("%I %p")},{interval:Se.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:Se.TimeInterval.day,step:1,formatter:n("%a %e")},{interval:Se.TimeInterval.month,step:1,formatter:n("%B %Y")}],[{interval:Se.TimeInterval.day,step:1,formatter:n("%e")},{interval:Se.TimeInterval.month,step:1,formatter:n("%B %Y")}],[{interval:Se.TimeInterval.month,step:1,formatter:n("%B")},{interval:Se.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:Se.TimeInterval.month,step:1,formatter:n("%b")},{interval:Se.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:Se.TimeInterval.month,step:3,formatter:n("%b")},{interval:Se.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:Se.TimeInterval.month,step:6,formatter:n("%b")},{interval:Se.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:1,formatter:n("%y")}],[{interval:Se.TimeInterval.year,step:5,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:25,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:50,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:100,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:200,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:500,formatter:n("%Y")}],[{interval:Se.TimeInterval.year,step:1e3,formatter:n("%Y")}]]},t._LONG_DATE=new Date(9999,8,29,12,59,9999),t}(ts.Axis);Se.Time=TFe;var xd});var s$t=H(n4=>{"use strict";Object.defineProperty(n4,"__esModule",{value:!0});var fot=(de(),Ut(pe));fot.__exportStar(GXt(),n4);fot.__exportStar(WXt(),n4);fot.__exportStar(BF(),n4)});var i4=H(pot=>{"use strict";Object.defineProperty(pot,"__esModule",{value:!0});var CFe=Fe(),AFe=function(){function e(){this._eventToProcessingFunction={},this._eventTarget=document,this._eventNameToCallbackSet={},this._connected=!1}return e.prototype._hasNoCallbacks=function(){for(var t=Object.keys(this._eventNameToCallbackSet),r=0;r<t.length;r++)if(this._eventNameToCallbackSet[t[r]].size!==0)return!1;return!0},e.prototype._connect=function(){var t=this;this._connected||(Object.keys(this._eventToProcessingFunction).forEach(function(r){var n=t._eventToProcessingFunction[r],i=r==="wheel"?{passive:!1}:void 0;t._eventTarget.addEventListener(r,n,i)}),this._connected=!0)},e.prototype._disconnect=function(){var t=this;this._connected&&this._hasNoCallbacks()&&(Object.keys(this._eventToProcessingFunction).forEach(function(r){var n=t._eventToProcessingFunction[r];t._eventTarget.removeEventListener(r,n)}),this._connected=!1)},e.prototype._addCallbackForEvent=function(t,r){this._eventNameToCallbackSet[t]==null&&(this._eventNameToCallbackSet[t]=new CFe.CallbackSet),this._eventNameToCallbackSet[t].add(r),this._connect()},e.prototype._removeCallbackForEvent=function(t,r){this._eventNameToCallbackSet[t]!=null&&this._eventNameToCallbackSet[t].delete(r),this._disconnect()},e.prototype._callCallbacksForEvent=function(t){for(var r=[],n=1;n<arguments.length;n++)r[n-1]=arguments[n];var i=this._eventNameToCallbackSet[t];i!=null&&i.callCallbacks.apply(i,r)},e}();pot.Dispatcher=AFe});var l$t=H(dot=>{"use strict";Object.defineProperty(dot,"__esModule",{value:!0});var PFe=(de(),Ut(pe)),IFe=i4(),LFe=function(e){PFe.__extends(t,e);function t(){var r=e.call(this)||this;return r._eventToProcessingFunction[t._KEYDOWN_EVENT_NAME]=function(n){return r._processKeydown(n)},r._eventToProcessingFunction[t._KEYUP_EVENT_NAME]=function(n){return r._processKeyup(n)},r}return t.getDispatcher=function(){var r=document[t._DISPATCHER_KEY];return r==null&&(r=new t,document[t._DISPATCHER_KEY]=r),r},t.prototype._processKeydown=function(r){this._callCallbacksForEvent(t._KEYDOWN_EVENT_NAME,r.keyCode,r)},t.prototype._processKeyup=function(r){this._callCallbacksForEvent(t._KEYUP_EVENT_NAME,r.keyCode,r)},t.prototype.onKeyDown=function(r){return this._addCallbackForEvent(t._KEYDOWN_EVENT_NAME,r),this},t.prototype.offKeyDown=function(r){return this._removeCallbackForEvent(t._KEYDOWN_EVENT_NAME,r),this},t.prototype.onKeyUp=function(r){return this._addCallbackForEvent(t._KEYUP_EVENT_NAME,r),this},t.prototype.offKeyUp=function(r){return this._removeCallbackForEvent(t._KEYUP_EVENT_NAME,r),this},t._DISPATCHER_KEY="__Plottable_Dispatcher_Key",t._KEYDOWN_EVENT_NAME="keydown",t._KEYUP_EVENT_NAME="keyup",t}(IFe.Dispatcher);dot.Key=LFe});var u$t=H(mot=>{"use strict";Object.defineProperty(mot,"__esModule",{value:!0});var kFe=(de(),Ut(pe)),c$t=Fe(),RFe=i4(),NFe=function(e){kFe.__extends(t,e);function t(r){var n=e.call(this)||this;n._lastMousePosition={x:-1,y:-1},n._translator=c$t.getTranslator(r);var i=function(o){return n._measureAndDispatch(r,o,t._MOUSEMOVE_EVENT_NAME,"page")};return n._eventToProcessingFunction[t._MOUSEOVER_EVENT_NAME]=i,n._eventToProcessingFunction[t._MOUSEMOVE_EVENT_NAME]=i,n._eventToProcessingFunction[t._MOUSEOUT_EVENT_NAME]=i,n._eventToProcessingFunction[t._MOUSEDOWN_EVENT_NAME]=function(o){return n._measureAndDispatch(r,o,t._MOUSEDOWN_EVENT_NAME)},n._eventToProcessingFunction[t._MOUSEUP_EVENT_NAME]=function(o){return n._measureAndDispatch(r,o,t._MOUSEUP_EVENT_NAME,"page")},n._eventToProcessingFunction[t._WHEEL_EVENT_NAME]=function(o){return n._measureAndDispatch(r,o,t._WHEEL_EVENT_NAME)},n._eventToProcessingFunction[t._DBLCLICK_EVENT_NAME]=function(o){return n._measureAndDispatch(r,o,t._DBLCLICK_EVENT_NAME)},n}return t.getDispatcher=function(r){var n=r.root().rootElement(),i=n[t._DISPATCHER_KEY];return i==null&&(i=new t(r),n[t._DISPATCHER_KEY]=i),i},t.prototype.onMouseMove=function(r){return this._addCallbackForEvent(t._MOUSEMOVE_EVENT_NAME,r),this},t.prototype.offMouseMove=function(r){return this._removeCallbackForEvent(t._MOUSEMOVE_EVENT_NAME,r),this},t.prototype.onMouseDown=function(r){return this._addCallbackForEvent(t._MOUSEDOWN_EVENT_NAME,r),this},t.prototype.offMouseDown=function(r){return this._removeCallbackForEvent(t._MOUSEDOWN_EVENT_NAME,r),this},t.prototype.onMouseUp=function(r){return this._addCallbackForEvent(t._MOUSEUP_EVENT_NAME,r),this},t.prototype.offMouseUp=function(r){return this._removeCallbackForEvent(t._MOUSEUP_EVENT_NAME,r),this},t.prototype.onWheel=function(r){return this._addCallbackForEvent(t._WHEEL_EVENT_NAME,r),this},t.prototype.offWheel=function(r){return this._removeCallbackForEvent(t._WHEEL_EVENT_NAME,r),this},t.prototype.onDblClick=function(r){return this._addCallbackForEvent(t._DBLCLICK_EVENT_NAME,r),this},t.prototype.offDblClick=function(r){return this._removeCallbackForEvent(t._DBLCLICK_EVENT_NAME,r),this},t.prototype._measureAndDispatch=function(r,n,i,o){if(o===void 0&&(o="element"),o!=="page"&&o!=="element")throw new Error("Invalid scope '"+o+"', must be 'element' or 'page'");if(o==="page"||this.eventInside(r,n)){var a=this._translator.computePosition(n.clientX,n.clientY);this._lastMousePosition=a,this._callCallbacksForEvent(i,this.lastMousePosition(),n)}},t.prototype.eventInside=function(r,n){return c$t.Translator.isEventInside(r,n)},t.prototype.lastMousePosition=function(){return this._lastMousePosition},t._DISPATCHER_KEY="__Plottable_Dispatcher_Mouse",t._MOUSEOVER_EVENT_NAME="mouseover",t._MOUSEMOVE_EVENT_NAME="mousemove",t._MOUSEOUT_EVENT_NAME="mouseout",t._MOUSEDOWN_EVENT_NAME="mousedown",t._MOUSEUP_EVENT_NAME="mouseup",t._WHEEL_EVENT_NAME="wheel",t._DBLCLICK_EVENT_NAME="dblclick",t}(RFe.Dispatcher);mot.Mouse=NFe});var f$t=H(got=>{"use strict";Object.defineProperty(got,"__esModule",{value:!0});var DFe=(de(),Ut(pe)),h$t=Fe(),OFe=i4(),zFe=function(e){DFe.__extends(t,e);function t(r){var n=e.call(this)||this;return n._translator=h$t.getTranslator(r),n._eventToProcessingFunction[t._TOUCHSTART_EVENT_NAME]=function(i){return n._measureAndDispatch(r,i,t._TOUCHSTART_EVENT_NAME,"page")},n._eventToProcessingFunction[t._TOUCHMOVE_EVENT_NAME]=function(i){return n._measureAndDispatch(r,i,t._TOUCHMOVE_EVENT_NAME,"page")},n._eventToProcessingFunction[t._TOUCHEND_EVENT_NAME]=function(i){return n._measureAndDispatch(r,i,t._TOUCHEND_EVENT_NAME,"page")},n._eventToProcessingFunction[t._TOUCHCANCEL_EVENT_NAME]=function(i){return n._measureAndDispatch(r,i,t._TOUCHCANCEL_EVENT_NAME,"page")},n}return t.getDispatcher=function(r){var n=r.root().rootElement(),i=n[t._DISPATCHER_KEY];return i==null&&(i=new t(r),n[t._DISPATCHER_KEY]=i),i},t.prototype.onTouchStart=function(r){return this._addCallbackForEvent(t._TOUCHSTART_EVENT_NAME,r),this},t.prototype.offTouchStart=function(r){return this._removeCallbackForEvent(t._TOUCHSTART_EVENT_NAME,r),this},t.prototype.onTouchMove=function(r){return this._addCallbackForEvent(t._TOUCHMOVE_EVENT_NAME,r),this},t.prototype.offTouchMove=function(r){return this._removeCallbackForEvent(t._TOUCHMOVE_EVENT_NAME,r),this},t.prototype.onTouchEnd=function(r){return this._addCallbackForEvent(t._TOUCHEND_EVENT_NAME,r),this},t.prototype.offTouchEnd=function(r){return this._removeCallbackForEvent(t._TOUCHEND_EVENT_NAME,r),this},t.prototype.onTouchCancel=function(r){return this._addCallbackForEvent(t._TOUCHCANCEL_EVENT_NAME,r),this},t.prototype.offTouchCancel=function(r){return this._removeCallbackForEvent(t._TOUCHCANCEL_EVENT_NAME,r),this},t.prototype._measureAndDispatch=function(r,n,i,o){if(o===void 0&&(o="element"),o!=="page"&&o!=="element")throw new Error("Invalid scope '"+o+"', must be 'element' or 'page'");if(!(o==="element"&&!this.eventInside(r,n))){for(var a=n.changedTouches,s={},l=[],c=0;c<a.length;c++){var u=a[c],h=u.identifier,f=this._translator.computePosition(u.clientX,u.clientY);f!=null&&(s[h]=f,l.push(h))}l.length>0&&this._callCallbacksForEvent(i,l,s,n)}},t.prototype.eventInside=function(r,n){return h$t.Translator.isEventInside(r,n)},t._DISPATCHER_KEY="__Plottable_Dispatcher_Touch",t._TOUCHSTART_EVENT_NAME="touchstart",t._TOUCHMOVE_EVENT_NAME="touchmove",t._TOUCHEND_EVENT_NAME="touchend",t._TOUCHCANCEL_EVENT_NAME="touchcancel",t}(OFe.Dispatcher);got.Touch=zFe});var N1=H(o4=>{"use strict";Object.defineProperty(o4,"__esModule",{value:!0});var _ot=(de(),Ut(pe));_ot.__exportStar(l$t(),o4);_ot.__exportStar(u$t(),o4);_ot.__exportStar(f$t(),o4)});var D1=H(yot=>{"use strict";Object.defineProperty(yot,"__esModule",{value:!0});var FFe=function(){function e(){var t=this;this._anchorCallback=function(r){return t._anchor(r)},this._enabled=!0}return e.prototype.attachTo=function(t){return this._disconnect(),this._componentAttachedTo=t,this._connect(),this},e.prototype.detachFrom=function(t){return this.detach()},e.prototype.detach=function(){return this._disconnect(),this._componentAttachedTo=null,this},e.prototype.enabled=function(t){return t==null?this._enabled:(this._enabled=t,this._enabled?this._connect():this._disconnect(),this)},e.prototype._anchor=function(t){this._isAnchored=!0},e.prototype._unanchor=function(){this._isAnchored=!1},e.prototype._translateToComponentSpace=function(t){var r=this._componentAttachedTo.originToRoot();return{x:t.x-r.x,y:t.y-r.y}},e.prototype._isInsideComponent=function(t){return 0<=t.x&&0<=t.y&&t.x<=this._componentAttachedTo.width()&&t.y<=this._componentAttachedTo.height()},e.prototype._connect=function(){this.enabled()&&this._componentAttachedTo!=null&&!this._isAnchored&&this._componentAttachedTo.onAnchor(this._anchorCallback)},e.prototype._disconnect=function(){this._isAnchored&&this._unanchor(),this._componentAttachedTo!=null&&this._componentAttachedTo.offAnchor(this._anchorCallback)},e}();yot.Interaction=FFe});var m$t=H(vot=>{"use strict";Object.defineProperty(vot,"__esModule",{value:!0});var BFe=(de(),Ut(pe)),p$t=N1(),d$t=Fe(),HFe=D1(),VFe=function(e){BFe.__extends(t,e);function t(){var r=e!==null&&e.apply(this,arguments)||this;return r._clickedDown=!1,r._doubleClicking=!1,r._onClickCallbacks=new d$t.CallbackSet,r._onDoubleClickCallbacks=new d$t.CallbackSet,r._mouseDownCallback=function(n,i){return r._handleClickDown(n,i)},r._mouseUpCallback=function(n,i){return r._handleClickUp(n,i)},r._dblClickCallback=function(n,i){return r._handleDblClick(n,i)},r._touchStartCallback=function(n,i,o){return r._handleClickDown(i[n[0]],o)},r._touchEndCallback=function(n,i,o){return r._handleClickUp(i[n[0]],o)},r._touchCancelCallback=function(n,i){return r._clickedDown=!1},r}return t.prototype._anchor=function(r){e.prototype._anchor.call(this,r),this._mouseDispatcher=p$t.Mouse.getDispatcher(r),this._mouseDispatcher.onMouseDown(this._mouseDownCallback),this._mouseDispatcher.onMouseUp(this._mouseUpCallback),this._mouseDispatcher.onDblClick(this._dblClickCallback),this._touchDispatcher=p$t.Touch.getDispatcher(r),this._touchDispatcher.onTouchStart(this._touchStartCallback),this._touchDispatcher.onTouchEnd(this._touchEndCallback),this._touchDispatcher.onTouchCancel(this._touchCancelCallback)},t.prototype._unanchor=function(){e.prototype._unanchor.call(this),this._mouseDispatcher.offMouseDown(this._mouseDownCallback),this._mouseDispatcher.offMouseUp(this._mouseUpCallback),this._mouseDispatcher.offDblClick(this._dblClickCallback),this._mouseDispatcher=null,this._touchDispatcher.offTouchStart(this._touchStartCallback),this._touchDispatcher.offTouchEnd(this._touchEndCallback),this._touchDispatcher.offTouchCancel(this._touchCancelCallback),this._touchDispatcher=null},t.prototype._handleClickDown=function(r,n){var i=this._translateToComponentSpace(r);this._isInsideComponent(i)&&(this._clickedDown=!0,this._clickedPoint=i)},t.prototype._handleClickUp=function(r,n){var i=this,o=this._translateToComponentSpace(r);this._clickedDown&&t._pointsEqual(o,this._clickedPoint)&&setTimeout(function(){i._doubleClicking||i._onClickCallbacks.callCallbacks(o,n)},0),this._clickedDown=!1},t.prototype._handleDblClick=function(r,n){var i=this,o=this._translateToComponentSpace(r);this._doubleClicking=!0,this._onDoubleClickCallbacks.callCallbacks(o,n),setTimeout(function(){return i._doubleClicking=!1},0)},t._pointsEqual=function(r,n){return r.x===n.x&&r.y===n.y},t.prototype.onClick=function(r){return this._onClickCallbacks.add(r),this},t.prototype.offClick=function(r){return this._onClickCallbacks.delete(r),this},t.prototype.onDoubleClick=function(r){return this._onDoubleClickCallbacks.add(r),this},t.prototype.offDoubleClick=function(r){return this._onDoubleClickCallbacks.delete(r),this},t}(HFe.Interaction);vot.Click=VFe});var _$t=H(xot=>{"use strict";Object.defineProperty(xot,"__esModule",{value:!0});var UFe=(de(),Ut(pe)),g$t=N1(),a4=Fe(),qFe=D1(),GFe=function(e){UFe.__extends(t,e);function t(r){var n=e.call(this)||this;return n._dragging=!1,n._constrainedToComponent=!0,n._mouseFilter=t._DEFAULT_MOUSE_FILTER,n._dragStartCallbacks=new a4.CallbackSet,n._dragCallbacks=new a4.CallbackSet,n._dragEndCallbacks=new a4.CallbackSet,n._mouseDownCallback=function(i,o){return n._startDrag(i,o)},n._mouseMoveCallback=function(i,o){return n._doDrag(i,o)},n._mouseUpCallback=function(i,o){return n._endDrag(i,o)},n._touchStartCallback=function(i,o,a){return n._startDrag(o[i[0]],a)},n._touchMoveCallback=function(i,o,a){return n._doDrag(o[i[0]],a)},n._touchEndCallback=function(i,o,a){return n._endDrag(o[i[0]],a)},n._mouseButton=r!==void 0?r:0,n}return t.prototype._anchor=function(r){e.prototype._anchor.call(this,r),this._mouseDispatcher=g$t.Mouse.getDispatcher(this._componentAttachedTo),this._mouseDispatcher.onMouseDown(this._mouseDownCallback),this._mouseDispatcher.onMouseMove(this._mouseMoveCallback),this._mouseDispatcher.onMouseUp(this._mouseUpCallback),this._touchDispatcher=g$t.Touch.getDispatcher(this._componentAttachedTo),this._touchDispatcher.onTouchStart(this._touchStartCallback),this._touchDispatcher.onTouchMove(this._touchMoveCallback),this._touchDispatcher.onTouchEnd(this._touchEndCallback)},t.prototype._unanchor=function(){e.prototype._unanchor.call(this),this._mouseDispatcher.offMouseDown(this._mouseDownCallback),this._mouseDispatcher.offMouseMove(this._mouseMoveCallback),this._mouseDispatcher.offMouseUp(this._mouseUpCallback),this._mouseDispatcher=null,this._touchDispatcher.offTouchStart(this._touchStartCallback),this._touchDispatcher.offTouchMove(this._touchMoveCallback),this._touchDispatcher.offTouchEnd(this._touchEndCallback),this._touchDispatcher=null},t.prototype._translateAndConstrain=function(r){var n=this._translateToComponentSpace(r);return this._constrainedToComponent?{x:a4.Math.clamp(n.x,0,this._componentAttachedTo.width()),y:a4.Math.clamp(n.y,0,this._componentAttachedTo.height())}:n},t.prototype._startDrag=function(r,n){if(!(n instanceof MouseEvent&&!this._mouseFilter(n))){var i=this._translateToComponentSpace(r);this._isInsideComponent(i)&&(n.preventDefault(),this._dragging=!0,this._dragOrigin=i,this._dragStartCallbacks.callCallbacks(this._dragOrigin))}},t.prototype._doDrag=function(r,n){this._dragging&&this._dragCallbacks.callCallbacks(this._dragOrigin,this._translateAndConstrain(r))},t.prototype._endDrag=function(r,n){n instanceof MouseEvent&&n.button!==this._mouseButton||this._dragging&&(this._dragging=!1,this._dragEndCallbacks.callCallbacks(this._dragOrigin,this._translateAndConstrain(r)))},t.prototype.constrainedToComponent=function(r){return r==null?this._constrainedToComponent:(this._constrainedToComponent=r,this)},t.prototype.mouseFilter=function(r){return arguments.length===0?this._mouseFilter:(this._mouseFilter=r,this)},t.prototype.onDragStart=function(r){return this._dragStartCallbacks.add(r),this},t.prototype.offDragStart=function(r){return this._dragStartCallbacks.delete(r),this},t.prototype.onDrag=function(r){return this._dragCallbacks.add(r),this},t.prototype.offDrag=function(r){return this._dragCallbacks.delete(r),this},t.prototype.onDragEnd=function(r){return this._dragEndCallbacks.add(r),this},t.prototype.offDragEnd=function(r){return this._dragEndCallbacks.delete(r),this},t._DEFAULT_MOUSE_FILTER=function(r){return r.button===0},t}(qFe.Interaction);xot.Drag=GFe});var Sot=H(wot=>{"use strict";Object.defineProperty(wot,"__esModule",{value:!0});var WFe=(de(),Ut(pe)),y$t=N1(),bot=Fe(),YFe=D1(),jFe=function(e){WFe.__extends(t,e);function t(){var r=e!==null&&e.apply(this,arguments)||this;return r._keyPressCallbacks={},r._keyReleaseCallbacks={},r._mouseMoveCallback=function(n){return!1},r._downedKeys=new bot.Set,r._keyDownCallback=function(n,i){return r._handleKeyDownEvent(n,i)},r._keyUpCallback=function(n){return r._handleKeyUpEvent(n)},r}return t.prototype._anchor=function(r){e.prototype._anchor.call(this,r),this._positionDispatcher=y$t.Mouse.getDispatcher(this._componentAttachedTo),this._positionDispatcher.onMouseMove(this._mouseMoveCallback),this._keyDispatcher=y$t.Key.getDispatcher(),this._keyDispatcher.onKeyDown(this._keyDownCallback),this._keyDispatcher.onKeyUp(this._keyUpCallback)},t.prototype._unanchor=function(){e.prototype._unanchor.call(this),this._positionDispatcher.offMouseMove(this._mouseMoveCallback),this._positionDispatcher=null,this._keyDispatcher.offKeyDown(this._keyDownCallback),this._keyDispatcher.offKeyUp(this._keyUpCallback),this._keyDispatcher=null},t.prototype._handleKeyDownEvent=function(r,n){var i=this._translateToComponentSpace(this._positionDispatcher.lastMousePosition());this._isInsideComponent(i)&&!n.repeat&&(this._keyPressCallbacks[r]&&this._keyPressCallbacks[r].callCallbacks(r),this._downedKeys.add(r))},t.prototype._handleKeyUpEvent=function(r){this._downedKeys.has(r)&&this._keyReleaseCallbacks[r]&&this._keyReleaseCallbacks[r].callCallbacks(r),this._downedKeys.delete(r)},t.prototype.onKeyPress=function(r,n){return this._keyPressCallbacks[r]||(this._keyPressCallbacks[r]=new bot.CallbackSet),this._keyPressCallbacks[r].add(n),this},t.prototype.offKeyPress=function(r,n){return this._keyPressCallbacks[r].delete(n),this._keyPressCallbacks[r].size===0&&delete this._keyPressCallbacks[r],this},t.prototype.onKeyRelease=function(r,n){return this._keyReleaseCallbacks[r]||(this._keyReleaseCallbacks[r]=new bot.CallbackSet),this._keyReleaseCallbacks[r].add(n),this},t.prototype.offKeyRelease=function(r,n){return this._keyReleaseCallbacks[r].delete(n),this._keyReleaseCallbacks[r].size===0&&delete this._keyReleaseCallbacks[r],this},t}(YFe.Interaction);wot.Key=jFe});var w$t=H(Mot=>{"use strict";Object.defineProperty(Mot,"__esModule",{value:!0});var XFe=(de(),Ut(pe)),$Fe=(Er(),Ut(Mr)),v$t=N1(),x$t=ks(),yl=Fe(),KFe=s4(),ZFe=D1(),b$t=t4(),JFe=function(e){XFe.__extends(t,e);function t(r,n){var i=e.call(this)||this;return i._wheelFilter=function(o){return!0},i._wheelCallback=function(o,a){return i._handleWheelEvent(o,a)},i._touchStartCallback=function(o,a,s){return i._handleTouchStart(o,a,s)},i._touchMoveCallback=function(o,a,s){return i._handlePinch(o,a,s)},i._touchEndCallback=function(o,a,s){return i._handleTouchEnd(o,a,s)},i._touchCancelCallback=function(o,a,s){return i._handleTouchEnd(o,a,s)},i._panEndCallbacks=new yl.CallbackSet,i._zoomEndCallbacks=new yl.CallbackSet,i._panZoomUpdateCallbacks=new yl.CallbackSet,i._xScales=new yl.Set,i._yScales=new yl.Set,i._dragInteraction=new KFe.Drag,i._setupDragInteraction(),i._touchIds=$Fe.map(),i._minDomainExtents=new yl.Map,i._maxDomainExtents=new yl.Map,i._minDomainValues=new yl.Map,i._maxDomainValues=new yl.Map,r!=null&&i.addXScale(r),n!=null&&i.addYScale(n),i}return t.prototype.dragInteraction=function(){return this._dragInteraction},t.prototype.wheelFilter=function(r){return arguments.length===0?this._wheelFilter:(this._wheelFilter=r,this)},t.prototype.pan=function(r){var n=this;this.xScales().forEach(function(i){i.pan(n._constrainedTranslation(i,r.x))}),this.yScales().forEach(function(i){i.pan(n._constrainedTranslation(i,r.y))}),this._panZoomUpdateCallbacks.callCallbacks()},t.prototype.zoom=function(r,n,i){var o=this;i===void 0&&(i=!0);var a,s;return n!=null&&(a=n.x,s=n.y,i&&(this.xScales().forEach(function(l){var c=o._constrainedZoom(l,r,a);a=c.centerPoint,r=c.zoomAmount}),this.yScales().forEach(function(l){var c=o._constrainedZoom(l,r,s);s=c.centerPoint,r=c.zoomAmount}))),this.xScales().forEach(function(l){var c=l.range(),u=a==null?(c[1]+c[0])/2:a;l.zoom(r,u)}),this.yScales().forEach(function(l){var c=l.range(),u=s==null?(c[1]+c[0])/2:s;l.zoom(r,u)}),this._panZoomUpdateCallbacks.callCallbacks(),{zoomAmount:r,centerValue:{centerX:a,centerY:s}}},t.prototype._anchor=function(r){e.prototype._anchor.call(this,r),this._dragInteraction.attachTo(r),this._mouseDispatcher=v$t.Mouse.getDispatcher(this._componentAttachedTo),this._mouseDispatcher.onWheel(this._wheelCallback),this._touchDispatcher=v$t.Touch.getDispatcher(this._componentAttachedTo),this._touchDispatcher.onTouchStart(this._touchStartCallback),this._touchDispatcher.onTouchMove(this._touchMoveCallback),this._touchDispatcher.onTouchEnd(this._touchEndCallback),this._touchDispatcher.onTouchCancel(this._touchCancelCallback)},t.prototype._unanchor=function(){e.prototype._unanchor.call(this),this._mouseDispatcher.offWheel(this._wheelCallback),this._mouseDispatcher=null,this._touchDispatcher.offTouchStart(this._touchStartCallback),this._touchDispatcher.offTouchMove(this._touchMoveCallback),this._touchDispatcher.offTouchEnd(this._touchEndCallback),this._touchDispatcher.offTouchCancel(this._touchCancelCallback),this._touchDispatcher=null,this._dragInteraction.detach()},t.prototype._handleTouchStart=function(r,n,i){for(var o=0;o<r.length&&this._touchIds.size()<2;o++){var a=r[o];this._touchIds.set(a.toString(),this._translateToComponentSpace(n[a]))}},t.prototype._handlePinch=function(r,n,i){var o=this;if(!(this._touchIds.size()<2)){var a=this._touchIds.values();if(!(!this._isInsideComponent(this._translateToComponentSpace(a[0]))||!this._isInsideComponent(this._translateToComponentSpace(a[1])))){var s=t._pointDistance(a[0],a[1]);if(s!==0){r.forEach(function(S){o._touchIds.has(S.toString())&&o._touchIds.set(S.toString(),o._translateToComponentSpace(n[S]))});var l=this._touchIds.values(),c=t._pointDistance(l[0],l[1]);if(c!==0){var u=s/c,h=l.map(function(S,C){return{x:(S.x-a[C].x)/u,y:(S.y-a[C].y)/u}}),f=t.centerPoint(a[0],a[1]),p=this.zoom(u,f),d=p.centerValue,g=p.zoomAmount,_=d.centerX,y=d.centerY,x=a.map(function(S,C){return{x:h[C].x*g+S.x,y:h[C].y*g+S.y}}),b={x:_-(x[0].x+x[1].x)/2,y:y-(x[0].y+x[1].y)/2};this.pan(b)}}}}},t.centerPoint=function(r,n){var i=Math.min(r.x,n.x),o=Math.max(r.x,n.x),a=Math.min(r.y,n.y),s=Math.max(r.y,n.y);return{x:(i+o)/2,y:(s+a)/2}},t._pointDistance=function(r,n){var i=Math.min(r.x,n.x),o=Math.max(r.x,n.x),a=Math.min(r.y,n.y),s=Math.max(r.y,n.y);return Math.sqrt(Math.pow(o-i,2)+Math.pow(s-a,2))},t.prototype._handleTouchEnd=function(r,n,i){var o=this;r.forEach(function(a){o._touchIds.remove(a.toString())}),this._touchIds.size()>0&&this._zoomEndCallbacks.callCallbacks()},t.prototype._handleWheelEvent=function(r,n){if(!!this._wheelFilter(n)){var i=this._translateToComponentSpace(r);if(this._isInsideComponent(i)){n.preventDefault();var o=n.deltaY!==0?n.deltaY:n.deltaX,a=o*(n.deltaMode?t._PIXELS_PER_LINE:1),s=Math.pow(2,a*.002);this.zoom(s,i),this._zoomEndCallbacks.callCallbacks()}}},t.prototype._constrainedZoom=function(r,n,i){return b$t.constrainedZoom(r,n,i,this.minDomainExtent(r),this.maxDomainExtent(r),this.minDomainValue(r),this.maxDomainValue(r))},t.prototype._constrainedTranslation=function(r,n){return b$t.constrainedTranslation(r,n,this.minDomainValue(r),this.maxDomainValue(r))},t.prototype._setupDragInteraction=function(){var r=this;this._dragInteraction.constrainedToComponent(!1);var n;this._dragInteraction.onDragStart(function(){return n=null}),this._dragInteraction.onDrag(function(i,o){if(!(r._touchIds.size()>=2)){var a={x:(n==null?i.x:n.x)-o.x,y:(n==null?i.y:n.y)-o.y};r.pan(a),n=o}}),this._dragInteraction.onDragEnd(function(){return r._panEndCallbacks.callCallbacks()})},t.prototype._nonLinearScaleWithExtents=function(r){return this.minDomainExtent(r)!=null&&this.maxDomainExtent(r)!=null&&!(r instanceof x$t.Linear)&&!(r instanceof x$t.Time)},t.prototype.xScales=function(r){var n=this;if(r==null){var i=[];return this._xScales.forEach(function(o){i.push(o)}),i}return this._xScales=new yl.Set,r.forEach(function(o){n.addXScale(o)}),this},t.prototype.yScales=function(r){var n=this;if(r==null){var i=[];return this._yScales.forEach(function(o){i.push(o)}),i}return this._yScales=new yl.Set,r.forEach(function(o){n.addYScale(o)}),this},t.prototype.addXScale=function(r){return this._xScales.add(r),this},t.prototype.removeXScale=function(r){return this._xScales.delete(r),this._minDomainExtents.delete(r),this._maxDomainExtents.delete(r),this._minDomainValues.delete(r),this._maxDomainValues.delete(r),this},t.prototype.addYScale=function(r){return this._yScales.add(r),this},t.prototype.removeYScale=function(r){return this._yScales.delete(r),this._minDomainExtents.delete(r),this._maxDomainExtents.delete(r),this._minDomainValues.delete(r),this._maxDomainValues.delete(r),this},t.prototype.minDomainExtent=function(r,n){if(n==null)return this._minDomainExtents.get(r);if(n.valueOf()<0)throw new Error("extent must be non-negative");var i=this.maxDomainExtent(r);if(i!=null&&i.valueOf()<n.valueOf())throw new Error("minDomainExtent must be smaller than maxDomainExtent for the same Scale");return this._nonLinearScaleWithExtents(r)&&yl.Window.warn("Panning and zooming with extents on a nonlinear scale may have unintended behavior."),this._minDomainExtents.set(r,n),this},t.prototype.maxDomainExtent=function(r,n){if(n==null)return this._maxDomainExtents.get(r);if(n.valueOf()<=0)throw new Error("extent must be positive");var i=this.minDomainExtent(r);if(i!=null&&n.valueOf()<i.valueOf())throw new Error("maxDomainExtent must be larger than minDomainExtent for the same Scale");return this._nonLinearScaleWithExtents(r)&&yl.Window.warn("Panning and zooming with extents on a nonlinear scale may have unintended behavior."),this._maxDomainExtents.set(r,n),this},t.prototype.minDomainValue=function(r,n){return n==null?this._minDomainValues.get(r):(this._minDomainValues.set(r,n),this)},t.prototype.maxDomainValue=function(r,n){return n==null?this._maxDomainValues.get(r):(this._maxDomainValues.set(r,n),this)},t.prototype.setMinMaxDomainValuesTo=function(r){this._minDomainValues.delete(r),this._maxDomainValues.delete(r);var n=r.getTransformationDomain(),i=n[0],o=n[1];return this.minDomainValue(r,i),this.maxDomainValue(r,o),this},t.prototype.onPanEnd=function(r){return this._panEndCallbacks.add(r),this},t.prototype.offPanEnd=function(r){return this._panEndCallbacks.delete(r),this},t.prototype.onZoomEnd=function(r){return this._zoomEndCallbacks.add(r),this},t.prototype.offZoomEnd=function(r){return this._zoomEndCallbacks.delete(r),this},t.prototype.onPanZoomUpdate=function(r){return this._panZoomUpdateCallbacks.add(r),this},t.prototype.offPanZoomUpdate=function(r){return this._panZoomUpdateCallbacks.delete(r),this},t._PIXELS_PER_LINE=120,t}(ZFe.Interaction);Mot.PanZoom=JFe});var M$t=H(Tot=>{"use strict";Object.defineProperty(Tot,"__esModule",{value:!0});var QFe=(de(),Ut(pe)),S$t=N1(),Eot=Fe(),tBe=D1(),eBe=function(e){QFe.__extends(t,e);function t(){var r=e!==null&&e.apply(this,arguments)||this;return r._overComponent=!1,r._pointerEnterCallbacks=new Eot.CallbackSet,r._pointerMoveCallbacks=new Eot.CallbackSet,r._pointerExitCallbacks=new Eot.CallbackSet,r._mouseMoveCallback=function(n,i){return r._handleMouseEvent(n,i)},r._touchStartCallback=function(n,i,o){return r._handleTouchEvent(i[n[0]],o)},r}return t.prototype._anchor=function(r){e.prototype._anchor.call(this,r),this._mouseDispatcher=S$t.Mouse.getDispatcher(this._componentAttachedTo),this._mouseDispatcher.onMouseMove(this._mouseMoveCallback),this._touchDispatcher=S$t.Touch.getDispatcher(this._componentAttachedTo),this._touchDispatcher.onTouchStart(this._touchStartCallback)},t.prototype._unanchor=function(){e.prototype._unanchor.call(this),this._mouseDispatcher.offMouseMove(this._mouseMoveCallback),this._mouseDispatcher=null,this._touchDispatcher.offTouchStart(this._touchStartCallback),this._touchDispatcher=null},t.prototype._handleMouseEvent=function(r,n){var i=this._mouseDispatcher.eventInside(this._componentAttachedTo,n);this._handlePointerEvent(r,i)},t.prototype._handleTouchEvent=function(r,n){var i=this._touchDispatcher.eventInside(this._componentAttachedTo,n);this._handlePointerEvent(r,i)},t.prototype._handlePointerEvent=function(r,n){var i=this._translateToComponentSpace(r),o=this._isInsideComponent(i);o&&n?(this._overComponent||this._pointerEnterCallbacks.callCallbacks(i),this._pointerMoveCallbacks.callCallbacks(i)):this._overComponent&&this._pointerExitCallbacks.callCallbacks(i),this._overComponent=o&&n},t.prototype.onPointerEnter=function(r){return this._pointerEnterCallbacks.add(r),this},t.prototype.offPointerEnter=function(r){return this._pointerEnterCallbacks.delete(r),this},t.prototype.onPointerMove=function(r){return this._pointerMoveCallbacks.add(r),this},t.prototype.offPointerMove=function(r){return this._pointerMoveCallbacks.delete(r),this},t.prototype.onPointerExit=function(r){return this._pointerExitCallbacks.add(r),this},t.prototype.offPointerExit=function(r){return this._pointerExitCallbacks.delete(r),this},t}(tBe.Interaction);Tot.Pointer=eBe});var s4=H(Zg=>{"use strict";Object.defineProperty(Zg,"__esModule",{value:!0});var l4=(de(),Ut(pe));l4.__exportStar(m$t(),Zg);l4.__exportStar(_$t(),Zg);l4.__exportStar(Sot(),Zg);l4.__exportStar(w$t(),Zg);l4.__exportStar(M$t(),Zg);var rBe=t4();Zg.zoomOut=rBe.zoomOut});var Cot=H(c4=>{"use strict";Object.defineProperty(c4,"__esModule",{value:!0});var nBe=(de(),Ut(pe)),HF=Fe(),iBe=kc(),es;(function(e){e[e.VALUE=0]="VALUE",e[e.PIXEL=1]="PIXEL"})(es=c4.PropertyMode||(c4.PropertyMode={}));var oBe=function(e){nBe.__extends(t,e);function t(){var r=e.call(this)||this;return r._boxVisible=!1,r._boxBounds={topLeft:{x:0,y:0},bottomRight:{x:0,y:0}},r._xBoundsMode=es.PIXEL,r._yBoundsMode=es.PIXEL,r.addClass("selection-box-layer"),r._adjustBoundsCallback=function(){r.render()},r._overflowHidden=!0,r._xExtent=[void 0,void 0],r._yExtent=[void 0,void 0],r}return t.prototype._setup=function(){e.prototype._setup.call(this),this._box=this.content().append("g").classed("selection-box",!0).remove(),this._boxArea=this._box.append("rect").classed("selection-area",!0)},t.prototype._sizeFromOffer=function(r,n){return{width:r,height:n}},t.prototype.bounds=function(r){return r==null?this._getBounds():(this._setBounds(r),this._xBoundsMode=es.PIXEL,this._yBoundsMode=es.PIXEL,this.render(),this)},t.prototype._setBounds=function(r){var n={x:Math.min(r.topLeft.x,r.bottomRight.x),y:Math.min(r.topLeft.y,r.bottomRight.y)},i={x:Math.max(r.topLeft.x,r.bottomRight.x),y:Math.max(r.topLeft.y,r.bottomRight.y)};this._boxBounds={topLeft:n,bottomRight:i}},t.prototype._getBounds=function(){return{topLeft:{x:this._xBoundsMode===es.PIXEL?this._boxBounds.topLeft.x:this._xScale==null?0:Math.min(this.xScale().scale(this.xExtent()[0]),this.xScale().scale(this.xExtent()[1])),y:this._yBoundsMode===es.PIXEL?this._boxBounds.topLeft.y:this._yScale==null?0:Math.min(this.yScale().scale(this.yExtent()[0]),this.yScale().scale(this.yExtent()[1]))},bottomRight:{x:this._xBoundsMode===es.PIXEL?this._boxBounds.bottomRight.x:this._xScale==null?0:Math.max(this.xScale().scale(this.xExtent()[0]),this.xScale().scale(this.xExtent()[1])),y:this._yBoundsMode===es.PIXEL?this._boxBounds.bottomRight.y:this._yScale==null?0:Math.max(this.yScale().scale(this.yExtent()[0]),this.yScale().scale(this.yExtent()[1]))}}},t.prototype.renderImmediately=function(){if(e.prototype.renderImmediately.call(this),this._boxVisible){var r=this.bounds(),n=r.topLeft.y,i=r.bottomRight.y,o=r.topLeft.x,a=r.bottomRight.x;if(!(HF.Math.isValidNumber(n)&&HF.Math.isValidNumber(i)&&HF.Math.isValidNumber(o)&&HF.Math.isValidNumber(a)))throw new Error("bounds have not been properly set");this._boxArea.attrs({x:o,y:n,width:a-o,height:i-n}),this.content().node().appendChild(this._box.node())}else this._box.remove();return this},t.prototype.boxVisible=function(r){return r==null?this._boxVisible:(this._boxVisible=r,this.render(),this)},t.prototype.fixedWidth=function(){return!0},t.prototype.fixedHeight=function(){return!0},t.prototype.xScale=function(r){return r==null?this._xScale:(this._xScale!=null&&this._xScale.offUpdate(this._adjustBoundsCallback),this._xScale=r,this._xBoundsMode=es.VALUE,this._xScale.onUpdate(this._adjustBoundsCallback),this.render(),this)},t.prototype.yScale=function(r){return r==null?this._yScale:(this._yScale!=null&&this._yScale.offUpdate(this._adjustBoundsCallback),this._yScale=r,this._yBoundsMode=es.VALUE,this._yScale.onUpdate(this._adjustBoundsCallback),this.render(),this)},t.prototype.xExtent=function(r){return r==null?this._getXExtent():(this._setXExtent(r),this._xBoundsMode=es.VALUE,this.render(),this)},t.prototype._getXExtent=function(){return this._xBoundsMode===es.VALUE?this._xExtent:this._xScale==null?[void 0,void 0]:[this._xScale.invert(this._boxBounds.topLeft.x),this._xScale.invert(this._boxBounds.bottomRight.x)]},t.prototype._setXExtent=function(r){this._xExtent=r},t.prototype.yExtent=function(r){return r==null?this._getYExtent():(this._setYExtent(r),this._yBoundsMode=es.VALUE,this.render(),this)},t.prototype._getYExtent=function(){return this._yBoundsMode===es.VALUE?this._yExtent:this._yScale==null?[void 0,void 0]:[this._yScale.invert(this._boxBounds.topLeft.y),this._yScale.invert(this._boxBounds.bottomRight.y)]},t.prototype._setYExtent=function(r){this._yExtent=r},t.prototype.destroy=function(){e.prototype.destroy.call(this),this._xScale!=null&&this.xScale().offUpdate(this._adjustBoundsCallback),this._yScale!=null&&this.yScale().offUpdate(this._adjustBoundsCallback)},t}(iBe.Component);c4.SelectionBoxLayer=oBe});var UF=H(Pot=>{"use strict";Object.defineProperty(Pot,"__esModule",{value:!0});var aBe=(de(),Ut(pe)),sBe=s4(),Aot=Fe(),lBe=Yg(),VF=Iot(),cBe=Cot(),uBe=function(e){aBe.__extends(t,e);function t(){var r=e.call(this)||this;return r._detectionRadius=3,r._resizable=!1,r._movable=!1,r._hasCorners=!0,r.addClass("drag-box-layer"),r._dragInteraction=new sBe.Drag,r._setUpCallbacks(),r._dragInteraction.attachTo(r),r._dragStartCallbacks=new Aot.CallbackSet,r._dragCallbacks=new Aot.CallbackSet,r._dragEndCallbacks=new Aot.CallbackSet,r}return t.prototype._setUpCallbacks=function(){var r=this,n,i,o,a,s={newBox:0,resize:1,move:2},l=s.newBox,c=function(f){n=r._getResizingEdges(f);var p=r.bounds(),d=p.topLeft.x<=f.x&&f.x<=p.bottomRight.x&&p.topLeft.y<=f.y&&f.y<=p.bottomRight.y;r.boxVisible()&&(n.top||n.bottom||n.left||n.right)?l=s.resize:r.boxVisible()&&r.movable()&&d?l=s.move:(l=s.newBox,r._setBounds({topLeft:f,bottomRight:f}),r._xBoundsMode===VF.PropertyMode.VALUE&&r.xScale()!=null&&r._setXExtent([r.xScale().invert(f.x),r.xScale().invert(f.x)]),r._yBoundsMode===VF.PropertyMode.VALUE&&r.yScale()!=null&&r._setYExtent([r.yScale().invert(f.y),r.yScale().invert(f.y)]),r.render()),r.boxVisible(!0),p=r.bounds(),i={x:p.topLeft.x,y:p.topLeft.y},o={x:p.bottomRight.x,y:p.bottomRight.y},a=f,r._dragStartCallbacks.callCallbacks(p)},u=function(f,p){switch(l){case s.newBox:o.x=p.x,o.y=p.y;break;case s.resize:n.bottom?o.y=p.y:n.top&&(i.y=p.y),n.right?o.x=p.x:n.left&&(i.x=p.x);break;case s.move:var d=p.x-a.x,g=p.y-a.y;i.x+=d,i.y+=g,o.x+=d,o.y+=g,a=p;break}r._setBounds({topLeft:i,bottomRight:o}),r._xBoundsMode===VF.PropertyMode.VALUE&&r.xScale()!=null&&r._setXExtent([r.xScale().invert(i.x),r.xScale().invert(o.x)]),r._yBoundsMode===VF.PropertyMode.VALUE&&r.yScale()!=null&&r._setYExtent([r.yScale().invert(i.y),r.yScale().invert(o.y)]),r.render(),r._dragCallbacks.callCallbacks(r.bounds())},h=function(f,p){l===s.newBox&&f.x===p.x&&f.y===p.y&&r.boxVisible(!1),r._dragEndCallbacks.callCallbacks(r.bounds())};this._dragInteraction.onDragStart(c),this._dragInteraction.onDrag(u),this._dragInteraction.onDragEnd(h),this._disconnectInteraction=function(){r._dragInteraction.offDragStart(c),r._dragInteraction.offDrag(u),r._dragInteraction.offDragEnd(h),r._dragInteraction.detach()}},t.prototype._setup=function(){var r=this;e.prototype._setup.call(this);var n=function(){return r._box.append("line").styles({opacity:0,stroke:"pink","pointer-events":"visibleStroke"})};if(this._detectionEdgeT=n().classed("drag-edge-tb",!0),this._detectionEdgeB=n().classed("drag-edge-tb",!0),this._detectionEdgeL=n().classed("drag-edge-lr",!0),this._detectionEdgeR=n().classed("drag-edge-lr",!0),this._hasCorners){var i=function(){return r._box.append("circle").styles({opacity:0,fill:"pink","pointer-events":"visibleFill"})};this._detectionCornerTL=i().classed("drag-corner-tl",!0),this._detectionCornerTR=i().classed("drag-corner-tr",!0),this._detectionCornerBL=i().classed("drag-corner-bl",!0),this._detectionCornerBR=i().classed("drag-corner-br",!0)}},t.prototype._getResizingEdges=function(r){var n={top:!1,bottom:!1,left:!1,right:!1};if(!this.resizable())return n;var i=this.bounds(),o=i.topLeft.y,a=i.bottomRight.y,s=i.topLeft.x,l=i.bottomRight.x,c=this._detectionRadius;return s-c<=r.x&&r.x<=l+c&&(n.top=o-c<=r.y&&r.y<=o+c,n.bottom=a-c<=r.y&&r.y<=a+c),o-c<=r.y&&r.y<=a+c&&(n.left=s-c<=r.x&&r.x<=s+c,n.right=l-c<=r.x&&r.x<=l+c),n},t.prototype.renderImmediately=function(){if(e.prototype.renderImmediately.call(this),this.boxVisible()){var r=this.bounds(),n=r.topLeft.y,i=r.bottomRight.y,o=r.topLeft.x,a=r.bottomRight.x;this._detectionEdgeT.attrs({x1:o,y1:n,x2:a,y2:n,"stroke-width":this._detectionRadius*2}),this._detectionEdgeB.attrs({x1:o,y1:i,x2:a,y2:i,"stroke-width":this._detectionRadius*2}),this._detectionEdgeL.attrs({x1:o,y1:n,x2:o,y2:i,"stroke-width":this._detectionRadius*2}),this._detectionEdgeR.attrs({x1:a,y1:n,x2:a,y2:i,"stroke-width":this._detectionRadius*2}),this._hasCorners&&(this._detectionCornerTL.attrs({cx:o,cy:n,r:this._detectionRadius}),this._detectionCornerTR.attrs({cx:a,cy:n,r:this._detectionRadius}),this._detectionCornerBL.attrs({cx:o,cy:i,r:this._detectionRadius}),this._detectionCornerBR.attrs({cx:a,cy:i,r:this._detectionRadius}))}return this},t.prototype.detectionRadius=function(r){if(r==null)return this._detectionRadius;if(r<0)throw new Error("detection radius cannot be negative.");return this._detectionRadius=r,this.render(),this},t.prototype.resizable=function(r){return r==null?this._resizable:(this._resizable=r,this._setResizableClasses(r),this)},t.prototype._setResizableClasses=function(r){r&&this.enabled()?(this.addClass("x-resizable"),this.addClass("y-resizable")):(this.removeClass("x-resizable"),this.removeClass("y-resizable"))},t.prototype.movable=function(r){return r==null?this._movable:(this._movable=r,this._setMovableClass(),this)},t.prototype._setMovableClass=function(){this.movable()&&this.enabled()?this.addClass("movable"):this.removeClass("movable")},t.prototype.onDragStart=function(r){return this._dragStartCallbacks.add(r),this},t.prototype.offDragStart=function(r){return this._dragStartCallbacks.delete(r),this},t.prototype.onDrag=function(r){return this._dragCallbacks.add(r),this},t.prototype.offDrag=function(r){return this._dragCallbacks.delete(r),this},t.prototype.onDragEnd=function(r){return this._dragEndCallbacks.add(r),this},t.prototype.offDragEnd=function(r){return this._dragEndCallbacks.delete(r),this},t.prototype.dragInteraction=function(){return this._dragInteraction},t.prototype.enabled=function(r){return r==null?this._dragInteraction.enabled():(this._dragInteraction.enabled(r),this._setResizableClasses(this.resizable()),this._setMovableClass(),this)},t.prototype.destroy=function(){var r=this;e.prototype.destroy.call(this),this._dragStartCallbacks.forEach(function(n){return r._dragCallbacks.delete(n)}),this._dragCallbacks.forEach(function(n){return r._dragCallbacks.delete(n)}),this._dragEndCallbacks.forEach(function(n){return r._dragEndCallbacks.delete(n)}),this._disconnectInteraction()},t.prototype.detach=function(){return this._resetState(),this._dragInteraction.detach(),e.prototype.detach.call(this),this},t.prototype.anchor=function(r){return r=lBe.coerceExternalD3(r),this._dragInteraction.attachTo(this),e.prototype.anchor.call(this,r),this},t.prototype._resetState=function(){this.bounds({topLeft:{x:0,y:0},bottomRight:{x:0,y:0}})},t}(cBe.SelectionBoxLayer);Pot.DragBoxLayer=uBe});var kot=H(Lot=>{"use strict";Object.defineProperty(Lot,"__esModule",{value:!0});var hBe=(de(),Ut(pe)),fBe=Fe(),pBe=kc(),O1;(function(e){e[e.VALUE=0]="VALUE",e[e.PIXEL=1]="PIXEL"})(O1||(O1={}));var dBe=function(e){hBe.__extends(t,e);function t(r){var n=e.call(this)||this;if(n._mode=O1.VALUE,r!==t.ORIENTATION_VERTICAL&&r!==t.ORIENTATION_HORIZONTAL)throw new Error(r+" is not a valid orientation for GuideLineLayer");return n._orientation=r,n._overflowHidden=!0,n.addClass("guide-line-layer"),n._isVertical()?n.addClass("vertical"):n.addClass("horizontal"),n._scaleUpdateCallback=function(){n._syncPixelPositionAndValue(),n.render()},n}return t.prototype._setup=function(){e.prototype._setup.call(this),this._guideLine=this.content().append("line").classed("guide-line",!0)},t.prototype._sizeFromOffer=function(r,n){return{width:r,height:n}},t.prototype._isVertical=function(){return this._orientation===t.ORIENTATION_VERTICAL},t.prototype.fixedWidth=function(){return!0},t.prototype.fixedHeight=function(){return!0},t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this.scale()!=null&&(this._isVertical()?this.scale().range([0,this.width()]):this.scale().range([this.height(),0])),this},t.prototype.renderImmediately=function(){return e.prototype.renderImmediately.call(this),this._syncPixelPositionAndValue(),this._guideLine.attrs({x1:this._isVertical()?this.pixelPosition():0,y1:this._isVertical()?0:this.pixelPosition(),x2:this._isVertical()?this.pixelPosition():this.width(),y2:this._isVertical()?this.height():this.pixelPosition()}),this},t.prototype._syncPixelPositionAndValue=function(){this.scale()!=null&&(this._mode===O1.VALUE&&this.value()!=null?this._pixelPosition=this.scale().scale(this.value()):this._mode===O1.PIXEL&&this.pixelPosition()!=null&&(this._value=this.scale().invert(this.pixelPosition())))},t.prototype._setPixelPositionWithoutChangingMode=function(r){this._pixelPosition=r,this.scale()!=null&&(this._value=this.scale().invert(this.pixelPosition())),this.render()},t.prototype.scale=function(r){if(r==null)return this._scale;var n=this._scale;return n!=null&&n.offUpdate(this._scaleUpdateCallback),this._scale=r,this._scale.onUpdate(this._scaleUpdateCallback),this._syncPixelPositionAndValue(),this.redraw(),this},t.prototype.value=function(r){return r==null?this._value:(this._value=r,this._mode=O1.VALUE,this._syncPixelPositionAndValue(),this.render(),this)},t.prototype.pixelPosition=function(r){if(r==null)return this._pixelPosition;if(!fBe.Math.isValidNumber(r))throw new Error("pixelPosition must be a finite number");return this._pixelPosition=r,this._mode=O1.PIXEL,this._syncPixelPositionAndValue(),this.render(),this},t.prototype.destroy=function(){e.prototype.destroy.call(this),this.scale()!=null&&this.scale().offUpdate(this._scaleUpdateCallback)},t.ORIENTATION_VERTICAL="vertical",t.ORIENTATION_HORIZONTAL="horizontal",t}(pBe.Component);Lot.GuideLineLayer=dBe});var E$t=H(Not=>{"use strict";Object.defineProperty(Not,"__esModule",{value:!0});var mBe=(de(),Ut(pe)),gBe=kot(),_Be=s4(),Rot=Fe(),yBe=function(e){mBe.__extends(t,e);function t(r){var n=e.call(this,r)||this;n._detectionRadius=3,n._enabled=!0,n.addClass("drag-line-layer"),n.addClass("enabled"),n._dragInteraction=new _Be.Drag,n._dragInteraction.attachTo(n);var i=function(c){return n._isVertical()&&n.pixelPosition()-n.detectionRadius()<=c.x&&c.x<=n.pixelPosition()+n.detectionRadius()||!n._isVertical()&&n.pixelPosition()-n.detectionRadius()<=c.y&&c.y<=n.pixelPosition()+n.detectionRadius()},o=!1,a=function(c){i(c)&&(o=!0,n._dragStartCallbacks.callCallbacks(n))};n._dragInteraction.onDragStart(a);var s=function(c,u){o&&(n._setPixelPositionWithoutChangingMode(n._isVertical()?u.x:u.y),n._dragCallbacks.callCallbacks(n))};n._dragInteraction.onDrag(s);var l=function(c,u){o&&(o=!1,n._dragEndCallbacks.callCallbacks(n))};return n._dragInteraction.onDragEnd(l),n._disconnectInteraction=function(){n._dragInteraction.offDragStart(a),n._dragInteraction.offDrag(s),n._dragInteraction.offDragEnd(l),n._dragInteraction.detach()},n._dragStartCallbacks=new Rot.CallbackSet,n._dragCallbacks=new Rot.CallbackSet,n._dragEndCallbacks=new Rot.CallbackSet,n}return t.prototype._setup=function(){e.prototype._setup.call(this),this._detectionEdge=this.content().append("line").styles({opacity:0,stroke:"pink","pointer-events":"visibleStroke"}).classed("drag-edge",!0)},t.prototype.renderImmediately=function(){return e.prototype.renderImmediately.call(this),this._detectionEdge.attrs({x1:this._isVertical()?this.pixelPosition():0,y1:this._isVertical()?0:this.pixelPosition(),x2:this._isVertical()?this.pixelPosition():this.width(),y2:this._isVertical()?this.height():this.pixelPosition(),"stroke-width":this._detectionRadius*2}),this},t.prototype.detectionRadius=function(r){if(r==null)return this._detectionRadius;if(r<0)throw new Error("detection radius cannot be negative.");return this._detectionRadius=r,this.render(),this},t.prototype.enabled=function(r){return r==null?this._enabled:(this._enabled=r,r?this.addClass("enabled"):this.removeClass("enabled"),this._dragInteraction.enabled(r),this)},t.prototype.onDragStart=function(r){return this._dragStartCallbacks.add(r),this},t.prototype.offDragStart=function(r){return this._dragStartCallbacks.delete(r),this},t.prototype.onDrag=function(r){return this._dragCallbacks.add(r),this},t.prototype.offDrag=function(r){return this._dragCallbacks.delete(r),this},t.prototype.onDragEnd=function(r){return this._dragEndCallbacks.add(r),this},t.prototype.offDragEnd=function(r){return this._dragEndCallbacks.delete(r),this},t.prototype.destroy=function(){var r=this;e.prototype.destroy.call(this),this._dragStartCallbacks.forEach(function(n){return r._dragStartCallbacks.delete(n)}),this._dragCallbacks.forEach(function(n){return r._dragCallbacks.delete(n)}),this._dragEndCallbacks.forEach(function(n){return r._dragEndCallbacks.delete(n)}),this._disconnectInteraction()},t}(gBe.GuideLineLayer);Not.DragLineLayer=yBe});var T$t=H(Dot=>{"use strict";Object.defineProperty(Dot,"__esModule",{value:!0});var vBe=(de(),Ut(pe)),xBe=kc();function qF(e,t,r){var n={};if(r!==void 0)for(var i=0;i<r.length;i++){var o=r[i-1],a=r[i];n[a]=o}return function(s){var l=e.scale(s);if(!t)return l;var c,u=n[s]===void 0?void 0:e.scale(n[s]);return u!==void 0&&(c=u+(l-u)/2),c}}var bBe=function(e){vBe.__extends(t,e);function t(r,n){var i=e.call(this)||this;return i.addClass("gridlines"),i._xScale=r,i._yScale=n,i._renderCallback=function(o){return i.render()},i._xScale&&i._xScale.onUpdate(i._renderCallback),i._yScale&&i._yScale.onUpdate(i._renderCallback),i}return t.prototype.betweenX=function(r){return r===void 0?this._betweenX:(r!==this._betweenX&&(this._betweenX=r,this.render()),this)},t.prototype.betweenY=function(r){return r===void 0?this._betweenY:(r!==this._betweenY&&(this._betweenY=r,this.render()),this)},t.prototype.destroy=function(){return e.prototype.destroy.call(this),this._xScale&&this._xScale.offUpdate(this._renderCallback),this._yScale&&this._yScale.offUpdate(this._renderCallback),this},t.prototype._setup=function(){e.prototype._setup.call(this),this._xLinesContainer=this.content().append("g").classed("x-gridlines",!0),this._yLinesContainer=this.content().append("g").classed("y-gridlines",!0)},t.prototype.renderImmediately=function(){return e.prototype.renderImmediately.call(this),this._redrawXLines(),this._redrawYLines(),this},t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this._xScale!=null&&this._xScale.range([0,this.width()]),this._yScale!=null&&this._yScale.range([this.height(),0]),this},t.prototype._redrawXLines=function(){if(this._xScale){var r=this.betweenX(),n=this._xScale.ticks().slice(r?1:0),i=this._xLinesContainer.selectAll("line").data(n),o=i.enter().append("line").merge(i);o.attr("x1",qF(this._xScale,r,this._xScale.ticks())).attr("y1",0).attr("x2",qF(this._xScale,r,this._xScale.ticks())).attr("y2",this.height()).classed("betweenline",r).classed("zeroline",function(a){return a===0}),i.exit().remove()}},t.prototype._redrawYLines=function(){if(this._yScale){var r=this.betweenY(),n=this._yScale.ticks().slice(r?1:0),i=this._yLinesContainer.selectAll("line").data(n),o=i.enter().append("line").merge(i);o.attr("x1",0).attr("y1",qF(this._yScale,r,this._yScale.ticks())).attr("x2",this.width()).attr("y2",qF(this._yScale,r,this._yScale.ticks())).classed("betweenline",r).classed("zeroline",function(a){return a===0}),i.exit().remove()}},t}(xBe.Component);Dot.Gridlines=bBe});var GF=H(Oot=>{"use strict";Object.defineProperty(Oot,"__esModule",{value:!0});var wBe=(de(),Ut(pe)),SBe=Yg(),MBe=kc(),EBe=function(e){wBe.__extends(t,e);function t(){var r=e.call(this)||this;return r._detachCallback=function(n){return r.remove(n)},r}return t.prototype.anchor=function(r){var n=this;return r=SBe.coerceExternalD3(r),e.prototype.anchor.call(this,r),this._forEach(function(i){return i.anchor(n.element())}),this},t.prototype.render=function(){return this._forEach(function(r){return r.render()}),this},t.prototype.has=function(r){throw new Error("has() is not implemented on ComponentContainer")},t.prototype._adoptAndAnchor=function(r){r.parent(this),r.onDetach(this._detachCallback),this._isAnchored&&r.anchor(this.element())},t.prototype.remove=function(r){return this.has(r)&&(r.offDetach(this._detachCallback),this._remove(r),r.detach(),this.redraw()),this},t.prototype._remove=function(r){return!1},t.prototype._forEach=function(r){throw new Error("_forEach() is not implemented on ComponentContainer")},t.prototype.destroy=function(){e.prototype.destroy.call(this),this._forEach(function(r){return r.destroy()})},t.prototype.invalidateCache=function(){this._forEach(function(r){return r.invalidateCache()})},t}(MBe.Component);Oot.ComponentContainer=EBe});var Fot=H(zot=>{"use strict";Object.defineProperty(zot,"__esModule",{value:!0});var TBe=(de(),Ut(pe)),C$t=Fe(),CBe=GF(),ABe=function(e){TBe.__extends(t,e);function t(r){r===void 0&&(r=[]);var n=e.call(this)||this;return n._components=[],n.addClass("component-group"),r.forEach(function(i){return n.append(i)}),n}return t.prototype._forEach=function(r){this.components().forEach(r)},t.prototype.has=function(r){return this._components.indexOf(r)>=0},t.prototype.requestedSpace=function(r,n){var i=this._components.map(function(o){return o.requestedSpace(r,n)});return{minWidth:C$t.Math.max(i,function(o){return o.minWidth},0),minHeight:C$t.Math.max(i,function(o){return o.minHeight},0)}},t.prototype.computeLayout=function(r,n,i){var o=this;return e.prototype.computeLayout.call(this,r,n,i),this._forEach(function(a){a.computeLayout({x:0,y:0},o.width(),o.height())}),this},t.prototype._sizeFromOffer=function(r,n){return{width:r,height:n}},t.prototype.fixedWidth=function(){return this._components.every(function(r){return r.fixedWidth()})},t.prototype.fixedHeight=function(){return this._components.every(function(r){return r.fixedHeight()})},t.prototype.components=function(){return this._components.slice()},t.prototype.append=function(r){return r!=null&&!this.has(r)&&(r.detach(),this._components.push(r),this._adoptAndAnchor(r),this.redraw()),this},t.prototype._remove=function(r){var n=this._components.indexOf(r);return n>=0?(this._components.splice(n,1),!0):!1},t}(CBe.ComponentContainer);zot.Group=ABe});var A$t=H(Bot=>{"use strict";Object.defineProperty(Bot,"__esModule",{value:!0});var PBe=(de(),Ut(pe)),WF=_l(),IBe=XA(),LBe=Bu(),kBe=Fe(),RBe=kc(),NBe=function(e){PBe.__extends(t,e);function t(r){var n=e.call(this)||this;if(n._textPadding=5,r==null)throw new Error("InterpolatedColorLegend requires a interpolatedColorScale");return n._scale=r,n._redrawCallback=function(i){return n.redraw()},n._scale.onUpdate(n._redrawCallback),n._formatter=LBe.general(),n._orientation="horizontal",n._expands=!1,n.addClass("legend"),n.addClass("interpolated-color-legend"),n}return t.prototype.destroy=function(){e.prototype.destroy.call(this),this._scale.offUpdate(this._redrawCallback)},t.prototype.formatter=function(r){return r===void 0?this._formatter:(this._formatter=r,this.redraw(),this)},t.prototype.expands=function(r){return r==null?this._expands:(this._expands=r,this.redraw(),this)},t._ensureOrientation=function(r){if(r=r.toLowerCase(),r==="horizontal"||r==="left"||r==="right")return r;throw new Error('"'+r+'" is not a valid orientation for InterpolatedColorLegend')},t.prototype.orientation=function(r){return r==null?this._orientation:(this._orientation=t._ensureOrientation(r),this.redraw(),this)},t.prototype.fixedWidth=function(){return!this.expands()||this._isVertical()},t.prototype.fixedHeight=function(){return!this.expands()||!this._isVertical()},t.prototype._generateTicks=function(r){r===void 0&&(r=t._DEFAULT_NUM_SWATCHES);var n=this._scale.domain();if(r===1)return[n[0]];for(var i=(n[1]-n[0])/(r-1),o=[],a=0;a<r;a++)o.push(n[0]+i*a);return o},t.prototype._setup=function(){e.prototype._setup.call(this),this._swatchContainer=this.content().append("g").classed("swatch-container",!0),this._swatchBoundingBox=this.content().append("rect").classed("swatch-bounding-box",!0),this._lowerLabel=this.content().append("g").classed(t.LEGEND_LABEL_CLASS,!0),this._upperLabel=this.content().append("g").classed(t.LEGEND_LABEL_CLASS,!0);var r=new WF.SvgContext(this.content().node());this._measurer=new WF.Measurer(r),this._wrapper=new WF.Wrapper,this._writer=new WF.Writer(this._measurer,r,this._wrapper)},t.prototype.requestedSpace=function(r,n){var i=this,o=this._measurer.measure().height,a=o,s=this._scale.domain(),l=s.map(function(p){return i._measurer.measure(i._formatter(p)).width}),c,u,h=t._DEFAULT_NUM_SWATCHES;if(this._isVertical()){var f=kBe.Math.max(l,0);u=a+o+this._textPadding+f+this._textPadding,c=h*o}else c=a+o+a,u=this._textPadding+l[0]+h*o+l[1]+this._textPadding;return{minWidth:u,minHeight:c}},t.prototype._isVertical=function(){return this._orientation!=="horizontal"},t.prototype.renderImmediately=function(){var r=this;e.prototype.renderImmediately.call(this);var n=this._scale.domain(),i=this._formatter(n[0]),o=this._measurer.measure(i).width,a=this._formatter(n[1]),s=this._measurer.measure(a).width,l=this._measurer.measure().height,c=this._textPadding,u={x:0,y:0},h={x:0,y:0},f={xAlign:"center",yAlign:"center",textRotation:0},p={xAlign:"center",yAlign:"center",textRotation:0},d,g,_,y,x={x:0,y:0,width:0,height:0},b,S;if(this._isVertical()){S=Math.floor(this.height());var C=Math.max(o,s);b=(this.width()-C-2*this._textPadding)/2,d=Math.max(this.width()-b-2*c-C,0),g=1,y=function(L,R){return r.height()-(R+1)},p.yAlign="top",u.y=0,f.yAlign="bottom",h.y=0,this._orientation==="left"?(_=function(L,R){return c+C+c},p.xAlign="right",u.x=-(b+d+c),f.xAlign="right",h.x=-(b+d+c)):(_=function(L,R){return b},p.xAlign="left",u.x=b+d+c,f.xAlign="left",h.x=b+d+c),x.width=d,x.height=S*g}else b=Math.max(c,(this.height()-l)/2),S=Math.max(Math.floor(this.width()-c*4-o-s),0),d=1,g=Math.max(this.height()-2*b,0),_=function(L,R){return Math.floor(o+2*c)+R},y=function(L,R){return b},p.xAlign="right",u.x=-c,f.xAlign="left",h.x=c,x.y=b,x.width=S*d,x.height=g;x.x=_(null,0),this._upperLabel.text(""),this._writer.write(a,this.width(),this.height(),p,this._upperLabel.node());var P="translate("+u.x+", "+u.y+")";this._upperLabel.attr("transform",P),this._lowerLabel.text(""),this._writer.write(i,this.width(),this.height(),f,this._lowerLabel.node());var k="translate("+h.x+", "+h.y+")";this._lowerLabel.attr("transform",k),this._swatchBoundingBox.attrs(x);var O=this._generateTicks(S),D=this._swatchContainer.selectAll("rect.swatch").data(O),B=D.enter().append("rect").classed("swatch",!0),I=D.merge(B);return D.exit().remove(),I.attrs({fill:function(L,R){return r._scale.scale(L)},width:d,height:g,x:_,y,"shape-rendering":"crispEdges"}),IBe.ADD_TITLE_ELEMENTS&&B.append("title").text(function(L){return r._formatter(L)}),this},t._DEFAULT_NUM_SWATCHES=11,t.LEGEND_LABEL_CLASS="legend-label",t}(RBe.Component);Bot.InterpolatedColorLegend=NBe});var Uot=H(u4=>{"use strict";Object.defineProperty(u4,"__esModule",{value:!0});var Hot=(de(),Ut(pe)),YF=_l(),DBe=kc(),Vot=function(e){Hot.__extends(t,e);function t(r,n){r===void 0&&(r=""),n===void 0&&(n=0);var i=e.call(this)||this;return i.addClass("label"),i.text(r),i.angle(n),i.xAlignment("center").yAlignment("center"),i._padding=0,i}return t.prototype.requestedSpace=function(r,n){var i=this._measurer.measure(this._text),o=(this.angle()===0?i.width:i.height)+2*this.padding(),a=(this.angle()===0?i.height:i.width)+2*this.padding();return{minWidth:o,minHeight:a}},t.prototype._setup=function(){e.prototype._setup.call(this),this._textContainer=this.content().append("g");var r=new YF.SvgContext(this._textContainer.node());this._measurer=new YF.CacheMeasurer(r),this._wrapper=new YF.Wrapper,this._writer=new YF.Writer(this._measurer,r,this._wrapper),this.text(this._text)},t.prototype.text=function(r){if(r==null)return this._text;if(typeof r!="string")throw new Error("Label.text() only takes strings as input");return this._text=r,this.redraw(),this},t.prototype.angle=function(r){if(r==null)return this._angle;if(r%=360,r>180?r-=360:r<-180&&(r+=360),r===-90||r===0||r===90)this._angle=r;else throw new Error(r+" is not a valid angle for Label");return this.redraw(),this},t.prototype.padding=function(r){if(r==null)return this._padding;if(r=+r,r<0)throw new Error(r+" is not a valid padding value. Cannot be less than 0.");return this._padding=r,this.redraw(),this},t.prototype.fixedWidth=function(){return!0},t.prototype.fixedHeight=function(){return!0},t.prototype.renderImmediately=function(){e.prototype.renderImmediately.call(this),this._textContainer.selectAll("g").remove();var r=this._measurer.measure(this._text),n=Math.max(Math.min((this.height()-r.height)/2,this.padding()),0),i=Math.max(Math.min((this.width()-r.width)/2,this.padding()),0);this._textContainer.attr("transform","translate("+i+","+n+")");var o=this.width()-2*i,a=this.height()-2*n,s={xAlign:this.xAlignment(),yAlign:this.yAlignment(),textRotation:this.angle()};return this._writer.write(this._text,o,a,s),this},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._measurer.reset()},t}(DBe.Component);u4.Label=Vot;var OBe=function(e){Hot.__extends(t,e);function t(r,n){var i=e.call(this,r,n)||this;return i.addClass(t.TITLE_LABEL_CLASS),i}return t.TITLE_LABEL_CLASS="title-label",t}(Vot);u4.TitleLabel=OBe;var zBe=function(e){Hot.__extends(t,e);function t(r,n){var i=e.call(this,r,n)||this;return i.addClass(t.AXIS_LABEL_CLASS),i}return t.AXIS_LABEL_CLASS="axis-label",t}(Vot);u4.AxisLabel=zBe});var jF=H(bd=>{"use strict";Object.defineProperty(bd,"__esModule",{value:!0});var Rs=(Er(),Ut(Mr));function FBe(){return function(e){return Rs.symbol().type(Rs.symbolCircle).size(Math.PI*Math.pow(e/2,2))}}bd.circle=FBe;function BBe(){return function(e){return Rs.symbol().type(Rs.symbolSquare).size(Math.pow(e,2))}}bd.square=BBe;function HBe(){return function(e){return Rs.symbol().type(Rs.symbolCross).size(5/9*Math.pow(e,2))}}bd.cross=HBe;function VBe(){return function(e){return Rs.symbol().type(Rs.symbolDiamond).size(Math.tan(Math.PI/6)*Math.pow(e,2)/2)}}bd.diamond=VBe;function UBe(){return function(e){return Rs.symbol().type(Rs.symbolTriangle).size(Math.sqrt(3)*Math.pow(e/2,2))}}bd.triangle=UBe;var qBe=.8908130915292852;function GBe(){return function(e){return Rs.symbol().type(Rs.symbolStar).size(qBe*Math.pow(e/2,2))}}bd.star=GBe;var WBe=(1/Math.sqrt(12)/2+1)*3;function YBe(){return function(e){return Rs.symbol().type(Rs.symbolWye).size(WBe*Math.pow(e/2.4,2))}}bd.wye=YBe});var P$t=H(Got=>{"use strict";Object.defineProperty(Got,"__esModule",{value:!0});var jBe=(de(),Ut(pe)),z1=(Er(),Ut(Mr)),XF=_l(),XBe=XA(),$Be=Bu(),KBe=jF(),Jg=Fe(),ZBe=kc(),qot=function(){function e(t,r,n){t===void 0&&(t=[]),r===void 0&&(r=0),n===void 0&&(n=1/0),this.columns=t,this.bottomPadding=r,this.maxWidth=n}return e.prototype.addColumn=function(t){var r=t.width,n=this.getWidthAvailable();t.width=Math.min(n,r),this.columns.push(t)},e.prototype.getBounds=function(t){for(var r=this.columns[t],n=0,i=0;i<t;i++)n+=this.columns[i].width;return{topLeft:{x:n,y:0},bottomRight:{x:n+r.width,y:r.height}}},e.prototype.getHeight=function(){return Jg.Math.max(this.columns.map(function(t){var r=t.height;return r}),0)+this.bottomPadding},e.prototype.getWidth=function(){return Math.min(this.columns.reduce(function(t,r){var n=r.width;return t+n},0),this.maxWidth)},e.prototype.getWidthAvailable=function(){var t=this.getWidth();return Math.max(this.maxWidth-t,0)},e}(),JBe=function(){function e(t,r,n,i){t===void 0&&(t=1/0),r===void 0&&(r=1/0),n===void 0&&(n=0),i===void 0&&(i=[]),this.maxWidth=t,this.maxHeight=r,this.padding=n,this.rows=i}return e.prototype.addRow=function(t){t.maxWidth=this.maxWidth-this.padding*2,this.rows.push(t)},e.prototype.getColumnBounds=function(t,r){var n=this.getRowBounds(t),i=this.rows[t].getBounds(r);return i.topLeft.x+=n.topLeft.x,i.bottomRight.x+=n.topLeft.x,i.topLeft.y+=n.topLeft.y,i.bottomRight.y+=n.topLeft.y,i},e.prototype.getRowBounds=function(t){for(var r=this.padding,n=this.padding,i=0;i<t;i++)n+=this.rows[i].getHeight();var o={topLeft:{x:r,y:n},bottomRight:{x:r+this.rows[t].getWidth(),y:n+this.rows[t].getHeight()}};return o},e.prototype.getHeight=function(){return Math.min(this.rows.reduce(function(t,r){return t+r.getHeight()},0)+this.padding*2,this.maxHeight)},e.prototype.getWidth=function(){return Math.min(Jg.Math.max(this.rows.map(function(t){return t.getWidth()}),0)+this.padding*2,this.maxWidth)},e}(),QBe=function(e){jBe.__extends(t,e);function t(r){var n=e.call(this)||this;if(n._padding=5,n._rowBottomPadding=3,n.addClass("legend"),n.maxEntriesPerRow(1),r==null)throw new Error("Legend requires a colorScale");return n._colorScale=r,n._redrawCallback=function(i){return n.redraw()},n._colorScale.onUpdate(n._redrawCallback),n._formatter=$Be.identity(),n.maxLinesPerEntry(1),n.xAlignment("right").yAlignment("top"),n.comparator(function(i,o){var a=n._colorScale.domain().slice().map(function(s){return n._formatter(s)});return a.indexOf(i)-a.indexOf(o)}),n._symbolFactoryAccessor=function(){return KBe.circle()},n._symbolOpacityAccessor=function(){return 1},n}return t.prototype._setup=function(){e.prototype._setup.call(this);var r=this.content().append("g").classed(t.LEGEND_ROW_CLASS,!0),n=r.append("g").classed(t.LEGEND_ENTRY_CLASS,!0);n.append("text");var i=new XF.SvgContext(r.node(),null,XBe.ADD_TITLE_ELEMENTS);this._measurer=new XF.CacheMeasurer(i),this._wrapper=new XF.Wrapper().maxLines(this.maxLinesPerEntry()),this._writer=new XF.Writer(this._measurer,i,this._wrapper)},t.prototype.formatter=function(r){return r==null?this._formatter:(this._formatter=r,this.redraw(),this)},t.prototype.maxEntriesPerRow=function(r){return r==null?this._maxEntriesPerRow:(this._maxEntriesPerRow=r,this.redraw(),this)},t.prototype.maxLinesPerEntry=function(r){return r==null?this._maxLinesPerEntry:(this._maxLinesPerEntry=r,this.redraw(),this)},t.prototype.maxWidth=function(r){return r==null?this._maxWidth:(this._maxWidth=r,this.redraw(),this)},t.prototype.comparator=function(r){return r==null?this._comparator:(this._comparator=r,this.redraw(),this)},t.prototype.colorScale=function(r){return r!=null?(this._colorScale.offUpdate(this._redrawCallback),this._colorScale=r,this._colorScale.onUpdate(this._redrawCallback),this.redraw(),this):this._colorScale},t.prototype.destroy=function(){e.prototype.destroy.call(this),this._colorScale.offUpdate(this._redrawCallback)},t.prototype._buildLegendTable=function(r,n){var i=this,o=this._measurer.measure().height,a=new JBe(r,n,this._padding),s=this._colorScale.domain().slice().sort(function(c,u){return i._comparator(i._formatter(c),i._formatter(u))}),l=new qot;return a.addRow(l),l.bottomPadding=this._rowBottomPadding,s.forEach(function(c,u){l.columns.length/2===i.maxEntriesPerRow()&&(l=new qot,l.bottomPadding=i._rowBottomPadding,a.addRow(l));var h=l.getWidthAvailable(),f=i._formatter(c),p=i._measurer.measure(f).width,d=h-o-p<0;d&&l.columns.length>1&&(l=new qot,l.bottomPadding=i._rowBottomPadding,a.addRow(l));var g={width:o,height:o,data:{name:c,type:"symbol"}};l.addColumn(g),h=l.getWidthAvailable();var _=Math.min(h,p);i._wrapper.maxLines(i.maxLinesPerEntry());var y=i._wrapper.wrap(f,i._measurer,_).noLines,x=y*o,b={width:_,height:x,data:{name:c,type:"text"}};l.addColumn(b)}),a},t.prototype.requestedSpace=function(r,n){var i=this._buildLegendTable(Jg.Math.min([this.maxWidth(),r],r),n);return{minHeight:i.getHeight(),minWidth:i.getWidth()}},t.prototype.entitiesAt=function(r){var n=this;if(!this._isSetup)return[];var i=this._buildLegendTable(this.width(),this.height());return i.rows.reduce(function(o,a,s){if(o.length!==0)return o;var l=i.getRowBounds(s),c=Jg.Math.within(r,l);return c?a.columns.reduce(function(u,h,f){var p=i.getColumnBounds(s,f),d=Jg.Math.within(r,p);if(d){var g=n.content().selectAll("."+t.LEGEND_ROW_CLASS).nodes()[s],_=z1.select(g).selectAll("."+t.LEGEND_ENTRY_CLASS).nodes()[Math.floor(f/2)],y=z1.select(_).select("."+t.LEGEND_SYMBOL_CLASS),x=Jg.DOM.getTranslateValues(z1.select(g)),b=Jg.DOM.getTranslateValues(y);return[{bounds:Jg.DOM.elementBBox(z1.select(g)),datum:h.data.name,position:{x:x[0]+b[0],y:x[1]+b[1]},selection:z1.select(_),component:n}]}return u},o):o},[])},t.prototype.renderImmediately=function(){e.prototype.renderImmediately.call(this);var r=this._buildLegendTable(this.width(),this.height());this.content().selectAll("*").remove();var n=this.content().selectAll("g."+t.LEGEND_ROW_CLASS).data(r.rows),i=n.enter().append("g").classed(t.LEGEND_ROW_CLASS,!0).merge(n);n.exit().remove(),i.attr("transform",function(a,s){var l=r.getRowBounds(s);return"translate("+l.topLeft.x+", "+l.topLeft.y+")"});var o=this;return i.each(function(a,s){for(var l=[],c=0;c<a.columns.length;c+=2)l.push([a.columns[c],a.columns[c+1]]);var u=z1.select(this).selectAll("g."+t.LEGEND_ENTRY_CLASS).data(l),h=u.enter().append("g").classed(t.LEGEND_ENTRY_CLASS,!0).merge(u);h.append("path").attr("d",function(f,p){var d=f[0];return o.symbol()(d.data.name,s)(d.height*.6)(null)}).attr("transform",function(f,p){var d=f[0],g=r.rows[s].columns.indexOf(d),_=r.getColumnBounds(s,g);return"translate("+(_.topLeft.x+d.width/2)+", "+d.height/2+")"}).attr("fill",function(f){return o._colorScale.scale(f[0].data.name)}).attr("opacity",function(f,p){return o.symbolOpacity()(f[0].data.name,s)}).classed(t.LEGEND_SYMBOL_CLASS,!0),h.append("g").classed("text-container",!0).attr("transform",function(f,p){var d=f[1],g=r.rows[s].columns.indexOf(d),_=r.getColumnBounds(s,g);return"translate("+_.topLeft.x+", 0)"}).each(function(f,p,d){var g=z1.select(this),_=f[1],y={xAlign:"left",yAlign:"top",textRotation:0};o._writer.write(o._formatter(_.data.name),_.width,o.height(),y,g.node())}),u.exit().remove()}),this},t.prototype.symbol=function(r){return r==null?this._symbolFactoryAccessor:(this._symbolFactoryAccessor=r,this.render(),this)},t.prototype.symbolOpacity=function(r){return r==null?this._symbolOpacityAccessor:(typeof r=="number"?this._symbolOpacityAccessor=function(){return r}:this._symbolOpacityAccessor=r,this.render(),this)},t.prototype.fixedWidth=function(){return!0},t.prototype.fixedHeight=function(){return!0},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._measurer.reset()},t.LEGEND_ROW_CLASS="legend-row",t.LEGEND_ENTRY_CLASS="legend-entry",t.LEGEND_SYMBOL_CLASS="legend-symbol",t}(ZBe.Component);Got.Legend=QBe});var Wot=H($F=>{"use strict";Object.defineProperty($F,"__esModule",{value:!0});var tHe;(function(e){e.MAIN="main",e.RESET="reset"})(tHe=$F.Animator||($F.Animator={}))});var L$t=H((Gqn,I$t)=>{"use strict";I$t.exports=function(t){return t!=null&&typeof t=="object"&&Array.isArray(t)===!1}});var N$t=H((Wqn,R$t)=>{"use strict";var eHe=L$t();function k$t(e){return eHe(e)===!0&&Object.prototype.toString.call(e)==="[object Object]"}R$t.exports=function(t){var r,n;return!(k$t(t)===!1||(r=t.constructor,typeof r!="function")||(n=r.prototype,k$t(n)===!1)||n.hasOwnProperty("isPrototypeOf")===!1)}});var jot=H(Yot=>{"use strict";Object.defineProperty(Yot,"__esModule",{value:!0});var rHe=Fe(),D$t=0,nHe=function(){function e(t,r){t===void 0&&(t=[]),r===void 0&&(r={}),this._updateId=D$t++,this._data=t,this._metadata=r,this._callbacks=new rHe.CallbackSet}return e.prototype.onUpdate=function(t){return this._callbacks.add(t),this},e.prototype.offUpdate=function(t){return this._callbacks.delete(t),this},e.prototype.data=function(t){return t==null?this._data:(this._data=t,this._dispatchUpdate(),this)},e.prototype.metadata=function(t){return t==null?this._metadata:(this._metadata=t,this._dispatchUpdate(),this)},e.prototype.updateId=function(){return this._updateId},e.prototype._dispatchUpdate=function(){this._updateId=D$t++,this._callbacks.callCallbacks(this)},e}();Yot.Dataset=nHe});var Kot=H(Rc=>{"use strict";Object.defineProperty(Rc,"__esModule",{value:!0});var Xot=(de(),Ut(pe)),iHe=N$t(),oHe=jot(),aHe=L1();function $ot(e){return e instanceof f4?e:e instanceof Date?h4(e.valueOf()):e instanceof aHe.Scale?O$t(e):e instanceof oHe.Dataset?z$t(e):iHe(e)?KF(e):Array.isArray(e)?F$t(e):h4(e)}Rc.sign=$ot;function O$t(e){var t={domain:e.domain(),range:e.range(),updateId:e.updateId(),ref:h4(e)};return KF(t)}Rc.signScale=O$t;function z$t(e){var t={ref:h4(e),updateId:e.updateId()};return KF(t)}Rc.signDataset=z$t;function h4(e){return new H$t(e)}Rc.signRef=h4;function F$t(e){return new B$t(e.map(function(t){return $ot(t)}))}Rc.signArray=F$t;function KF(e){var t={};for(var r in e)e.hasOwnProperty(r)&&(t[r]=$ot(e[r]));return new V$t(t)}Rc.signObj=KF;var f4=function(){function e(){}return e.prototype.isDifferent=function(t){return t instanceof this.constructor?this.isSignatureDifferent(t):!0},e}();Rc.Signature=f4;var B$t=function(e){Xot.__extends(t,e);function t(r){var n=e.call(this)||this;return n.array=r,n}return t.prototype.isSignatureDifferent=function(r){if(r.array.length!==this.array.length)return!0;for(var n=0;n<this.array.length;n++)if(this.array[n].isDifferent(r.array[n]))return!0;return!1},t}(f4);Rc.ArraySignature=B$t;var H$t=function(e){Xot.__extends(t,e);function t(r){var n=e.call(this)||this;return n.ref=r,n}return t.prototype.isSignatureDifferent=function(r){return this.ref!==r.ref},t}(f4);Rc.ReferenceSignature=H$t;var V$t=function(e){Xot.__extends(t,e);function t(r){var n=e.call(this)||this;return n.obj=r,n}return t.prototype.isSignatureDifferent=function(r){var n=Object.keys(this.obj),i=Object.keys(r.obj);if(n.length!==i.length)return!0;for(var o=0,a=n;o<a.length;o++){var s=a[o];if(!r.obj.hasOwnProperty(s)||this.obj[s].isDifferent(r.obj[s]))return!0}return!1},t}(f4);Rc.ObjectSignature=V$t});var U$t=H(Zot=>{"use strict";Object.defineProperty(Zot,"__esModule",{value:!0});var sHe=Kot();function lHe(e){var t=void 0,r,n=!1,i=!1,o=function(){for(var a=[],s=0;s<arguments.length;s++)a[s]=arguments[s];if(n)return r;var l=sHe.signArray(a);return t===void 0||t.isDifferent(l)?(i&&console.warn("cache miss! computing"),t=l,r=e.apply(this,a)):i&&console.warn("cache hit!"),r};return o.doLocked=function(a){if(n)throw new Error("Locking an already locked memoize function!");n=!0;var s=a.apply(this);return n=!1,s},o.logPerformance=function(a){return a===void 0&&(a=!0),i=a,this},o}Zot.memoize=lHe});var W$t=H(ZF=>{"use strict";Object.defineProperty(ZF,"__esModule",{value:!0});var cHe=Oe(),Jot=function(){function e(){this.map=Object.create(null),this.exists=Object.create(null)}return e.prototype.delete=function(t){return delete this.map[t],delete this.exists[t],!0},e.prototype.get=function(t){return this.map[t]},e.prototype.has=function(t){return!!this.exists[t]},e.prototype.set=function(t,r){return this.map[t]=r,this.exists[t]=!0,this},e}(),q$t=function(){function e(){this.map=new Jot}return e.prototype.get=function(t){return this.map.get(t[0]).get(t[1])},e.prototype.has=function(t){return this.map.has(t[0])&&this.map.get(t[0]).has(t[1])},e.prototype.set=function(t,r){return this.map.has(t[0])||this.map.set(t[0],new Jot),this.map.get(t[0]).set(t[1],r),this},e.prototype.delete=function(t){return this.map.has(t[0])&&this.map.get(t[0]).delete(t[1]),!0},e.prototype.clear=function(){this.map=new Jot},e.resolver=function(t,r,n){return[n.updateId(),r]},e}();function G$t(e){var t=cHe.memoize(e,q$t.resolver);return t.cache=new q$t,t}ZF.memoizeProjector=G$t;function uHe(e){return Object.keys(e).forEach(function(t){e[t]=G$t(e[t])}),e}ZF.memoizeProjectors=uHe});var Y$t=H(Qot=>{"use strict";Object.defineProperty(Qot,"__esModule",{value:!0});var hHe=CS();function fHe(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var r=e.slice(0,-1),n=e[e.length-1],i=hHe.memoize(n),o=function(){var a=this,s=r.map(function(l){return l.apply(a)});return i.apply(void 0,s)};return o}Qot.memThunk=fHe});var CS=H(AS=>{"use strict";Object.defineProperty(AS,"__esModule",{value:!0});var tat=(de(),Ut(pe));tat.__exportStar(U$t(),AS);tat.__exportStar(W$t(),AS);tat.__exportStar(Y$t(),AS);var pHe=Kot();AS.sign=pHe.sign});var F1=H(Nc=>{"use strict";Object.defineProperty(Nc,"__esModule",{value:!0});var j$t=(Er(),Ut(Mr)),dHe=function(){function e(t,r){this._context=t,this._drawStep=r}return e.prototype.getDrawStep=function(){return this._drawStep},e.prototype.draw=function(t,r){var n=r[r.length-1].attrToAppliedProjector;this._context.save(),this._drawStep(this._context,t,n),this._context.restore()},e.prototype.getVisualPrimitives=function(){return[]},e.prototype.getVisualPrimitiveAtIndex=function(t){return null},e.prototype.remove=function(){},e}();Nc.CanvasDrawer=dHe;Nc.ContextStyleAttrs=["fill-opacity","fill","opacity","stroke-opacity","stroke-width","stroke","stroke-dasharray"];function mHe(e,t,r,n){var i=Nc.ContextStyleAttrs.concat(t);return X$t(e,i,r,n)}Nc.resolveAttributesSubsetWithStyles=mHe;function X$t(e,t,r,n){for(var i={},o=0,a=t;o<a.length;o++){var s=a[o];e.hasOwnProperty(s)&&(i[s]=e[s](r,n))}return i}Nc.resolveAttributes=X$t;function gHe(e){var t=e.opacity!=null?parseFloat(e.opacity):1,r=e["stroke-opacity"]!=null?parseFloat(e["stroke-opacity"]):1;return r*t}function _He(e){var t=e.opacity!=null?parseFloat(e.opacity):1,r=e["fill-opacity"]!=null?parseFloat(e["fill-opacity"]):1;return r*t}function $$t(e){return e["stroke-width"]!=null?parseFloat(e["stroke-width"]):1}Nc.getStrokeWidth=$$t;function K$t(e){var t=e["stroke-dasharray"];if(t!=null)try{return t.split(/[ ,]+/).map(function(r){return parseInt(r,10)})}catch(r){return console.error("getStrokeDashArray failed with: "+r),[]}return[]}Nc.getStrokeDashArray=K$t;function yHe(e,t,r,n){e.save(),e.beginPath(),t.context(e),t(r),e.lineJoin="round",eat(e,n),e.restore()}Nc.renderArea=yHe;function vHe(e,t,r,n){e.save(),e.beginPath(),t.context(e),t(r),e.lineJoin="round",eat(e,n),e.restore()}Nc.renderLine=vHe;function eat(e,t){if(t.stroke){e.lineWidth=$$t(t);var r=j$t.color(t.stroke),n=K$t(t);e.setLineDash(n),r.opacity*=gHe(t),e.strokeStyle=r.toString(),e.stroke()}if(t.fill){var i=j$t.color(t.fill);i.opacity*=_He(t),e.fillStyle=i.toString(),e.fill()}}Nc.renderPathWithStyle=eat});var Uu=H(rat=>{"use strict";Object.defineProperty(rat,"__esModule",{value:!0});var xHe=function(){function e(t,r){this._svgDrawerFactory=t,this._canvasDrawerFactory=r}return e.prototype.useSVG=function(t){this._currentDrawer!=null&&this._currentDrawer.remove();var r=this._svgDrawerFactory();r.attachTo(t),this._currentDrawer=r},e.prototype.useCanvas=function(t){this._currentDrawer!=null&&this._currentDrawer.remove(),this._currentDrawer=this._canvasDrawerFactory(t.node().getContext("2d"))},e.prototype.getDrawer=function(){return this._currentDrawer},e.prototype.remove=function(){this._currentDrawer!=null&&this._currentDrawer.remove()},e.prototype.draw=function(t,r){this._currentDrawer.draw(t,r)},e.prototype.getVisualPrimitives=function(){return this._currentDrawer.getVisualPrimitives()},e.prototype.getVisualPrimitiveAtIndex=function(t){return this._currentDrawer.getVisualPrimitiveAtIndex(t)},e}();rat.ProxyDrawer=xHe});var Df=H(nat=>{"use strict";Object.defineProperty(nat,"__esModule",{value:!0});var bHe=(Er(),Ut(Mr)),Z$t=Fe(),wHe=function(){function e(t,r){this._root=bHe.select(document.createElementNS("http://www.w3.org/2000/svg","g")),this._className=r,this._svgElementName=t}return e.prototype.draw=function(t,r){var n=this;this._createAndDestroyDOMElements(t);for(var i=0,o=r.length,a=function(l){var c=r[l];Z$t.Window.setTimeout(function(){return n._drawStep(c)},i),i+=c.animator.totalTime(t.length)},s=0;s<o;s++)a(s)},e.prototype.getVisualPrimitives=function(){return this._cachedVisualPrimitivesNodes==null&&(this._cachedVisualPrimitivesNodes=this._selection.nodes()),this._cachedVisualPrimitivesNodes},e.prototype.getVisualPrimitiveAtIndex=function(t){return this._cachedVisualPrimitivesNodeMap==null?null:this._cachedVisualPrimitivesNodeMap.get(t)},e.prototype.remove=function(){this._root.remove()},e.prototype.attachTo=function(t){t.node().appendChild(this._root.node())},e.prototype.getRoot=function(){return this._root},e.prototype.selector=function(){return this._svgElementName},e.prototype._applyDefaultAttributes=function(t){},e.prototype._createAndDestroyDOMElements=function(t){var r=t.map(function(a,s){return a!=null?{d:a,i:s}:null}),n=r.filter(function(a){return a!=null}),i=this._root.selectAll(this.selector()).data(n);this._selection=i.enter().append(this._svgElementName).merge(i),i.exit().remove();var o=new Z$t.Map;this._selection.each(function(a){o.set(a.i,this)}),this._cachedVisualPrimitivesNodeMap=o,this._cachedVisualPrimitivesNodes=null,this._selection.data(this._selection.data().map(function(a){var s=a.d;return s})),this._className!=null&&this._selection.classed(this._className,!0),this._applyDefaultAttributes(this._selection)},e.prototype._drawStep=function(t){var r=this,n=["fill","stroke"];n.forEach(function(i){t.attrToAppliedProjector[i]!=null&&r._selection.attr(i,t.attrToAppliedProjector[i])}),t.animator.animate(this._selection,t.attrToAppliedProjector),this._className!=null&&this._selection.classed(this._className,!0)},e}();nat.SVGDrawer=wHe});var oat=H(iat=>{"use strict";Object.defineProperty(iat,"__esModule",{value:!0});var J$t=function(){function e(){var t=this;this.scale=0,this.translate=0,this.cachedDomain=[null,null],this.lastSeenDomain=[null,null],this.updateDomain=function(r){t.lastSeenDomain=r.getTransformationDomain();var n=r.scaleTransformation(t.cachedDomain[1])-r.scaleTransformation(t.cachedDomain[0]),i=r.scaleTransformation(t.lastSeenDomain[1])-r.scaleTransformation(t.lastSeenDomain[0]);t.scale=n/i||1,t.translate=r.scaleTransformation(t.cachedDomain[0])-r.scaleTransformation(t.lastSeenDomain[0])*t.scale||0}}return e.prototype.reset=function(){this.scale=1,this.translate=0,this.cachedDomain=this.lastSeenDomain},e.prototype.setDomain=function(t){this.cachedDomain=t.getTransformationDomain()},e}(),SHe=function(){function e(t,r){var n=this;this.renderCallback=t,this.applyTransformCallback=r,this.domainTransformX=new J$t,this.domainTransformY=new J$t,this.renderDeferred=function(){n.applyTransform(),clearTimeout(n.timeoutToken),n.timeoutToken=setTimeout(function(){n.renderCallback()},e.DEFERRED_RENDERING_DELAY)}}return e.prototype.setDomains=function(t,r){t&&this.domainTransformX.setDomain(t),r&&this.domainTransformY.setDomain(r),this.renderDeferred()},e.prototype.updateDomains=function(t,r){t&&this.domainTransformX.updateDomain(t),r&&this.domainTransformY.updateDomain(r),this.renderDeferred()},e.prototype.resetTransforms=function(){this.domainTransformX.reset(),this.domainTransformY.reset(),this.applyTransform()},e.prototype.applyTransform=function(){this.applyTransformCallback(this.domainTransformX.translate,this.domainTransformY.translate,this.domainTransformX.scale,this.domainTransformY.scale)},e.DEFERRED_RENDERING_DELAY=200,e}();iat.DeferredRenderer=SHe});var rs=H(JF=>{"use strict";Object.defineProperty(JF,"__esModule",{value:!0});var MHe=(de(),Ut(pe)),wd=(Er(),Ut(Mr)),p4=Lf(),Sd=Fe(),Q$t=Wot(),aat=CS(),EHe=kc(),THe=F1(),CHe=Uu(),AHe=Df(),PHe=Yg(),IHe=If(),LHe=oat();JF.Renderer=IHe.makeEnum(["svg","canvas"]);var kHe=function(e){MHe.__extends(t,e);function t(){var r=e.call(this)||this;r._dataChanged=!1,r._attrExtents={},r._animate=!1,r._animators={},r._propertyExtents={},r._resetEntityStore=function(){r._cachedEntityStore=void 0},r._overflowHidden=!0,r.addClass("plot"),r._datasetToDrawer=new Sd.Map,r._attrBindings=wd.map(),r._includedValuesProvider=function(i,o){return r._includedValuesForScale(i,o)},r._renderCallback=function(){return r.render()},r._onDatasetUpdateCallback=function(){return r._onDatasetUpdate()},r._propertyBindings=wd.map();var n=new p4.Easing().maxTotalDuration(t._ANIMATION_MAX_DURATION);return r.animator(Q$t.Animator.MAIN,n),r.animator(Q$t.Animator.RESET,new p4.Null),r._deferredResetEntityStore=Sd.Window.debounce(LHe.DeferredRenderer.DEFERRED_RENDERING_DELAY,r._resetEntityStore),r}return t.getTotalDrawTime=function(r,n){return n.reduce(function(i,o){return i+o.animator.totalTime(r.length)},0)},t.applyDrawSteps=function(r,n){var i=r.map(function(o){var a=o.attrToProjector,s={};return Object.keys(a).forEach(function(l){s[l]=function(c,u){return a[l](c,u,n)}}),{attrToAppliedProjector:s,animator:o.animator}});return i},t.prototype.anchor=function(r){return r=PHe.coerceExternalD3(r),e.prototype.anchor.call(this,r),this._dataChanged=!0,this._resetEntityStore(),this._updateExtents(),this},t.prototype._setup=function(){var r=this;this._isSetup||(e.prototype._setup.call(this),this._canvas!=null&&this._appendCanvasNode(),this._renderArea=this.content().append("g").classed("render-area",!0),this.datasets().forEach(function(n){return r._createNodesForDataset(n)}))},t.prototype._appendCanvasNode=function(){var r=this.element().select(".plot-canvas-container");r.empty()&&(r=this.element().append("div").classed("plot-canvas-container",!0),r.node().appendChild(this._canvas.node()))},t.prototype.setBounds=function(r,n,i,o){if(e.prototype.setBounds.call(this,r,n,i,o),this._updateExtents(),this._canvas!=null){if(this._bufferCanvas&&!this._bufferCanvasValid){this._bufferCanvas.attr("width",this._canvas.attr("width")),this._bufferCanvas.attr("height",this._canvas.attr("height"));var a=this._bufferCanvas.node().getContext("2d");if(a){var s=this._canvas.node();s.width>0&&s.height>0?a.canvas.width>0&&a.canvas.height>0&&a.drawImage(s,0,0):console.warn("Failed to fill buffer canvas with with 0x0 canvas")}this._bufferCanvasValid=!0}var l=window.devicePixelRatio!=null?window.devicePixelRatio:1;this._canvas.attr("width",r*l),this._canvas.attr("height",n*l);var c=this._canvas.node().getContext("2d");if(c&&(c.setTransform(l,0,0,l,0,0),this._bufferCanvas)){var u=this._bufferCanvas.node();u.width>0&&u.height>0?c.canvas.width>0&&c.canvas.height>0&&c.drawImage(u,0,0,r,n):console.warn("Failed to fill canvas with 0x0 buffer canvas")}}return this},t.prototype.destroy=function(){var r=this;e.prototype.destroy.call(this),this._scales().forEach(function(n){return n.offUpdate(r._renderCallback)}),this.datasets([])},t.prototype._createNodesForDataset=function(r){var n=this._datasetToDrawer.get(r);return this.renderer()==="svg"?n.useSVG(this._renderArea):n.useCanvas(this._canvas),n},t.prototype._createDrawer=function(r){return new CHe.ProxyDrawer(function(){return new AHe.SVGDrawer("path","")},function(n){return new THe.CanvasDrawer(n,function(){})})},t.prototype._getAnimator=function(r){return this._animateOnNextRender()?this._animators[r]||new p4.Null:new p4.Null},t.prototype._onDatasetUpdate=function(){this._updateExtents(),this._dataChanged=!0,this._resetEntityStore(),this.renderLowPriority()},t.prototype.attr=function(r,n,i){return n==null?this._attrBindings.get(r):(this._bindAttr(r,n,i),this.render(),this)},t.prototype._bindProperty=function(r,n,i,o){var a=this._propertyBindings.get(r),s=a!=null?a.scale:null,l=typeof n=="function"?n:function(){return n};this._propertyBindings.set(r,{accessor:l,scale:i,postScale:o}),s!=null&&this._uninstallScaleForKey(s,r),i!=null&&this._installScaleForKey(i,r),this._clearAttrToProjectorCache()},t.prototype._bindAttr=function(r,n,i){var o=this._attrBindings.get(r),a=o!=null?o.scale:null,s=typeof n=="function"?n:function(){return n};this._attrBindings.set(r,{accessor:s,scale:i}),a!=null&&this._uninstallScaleForKey(a,r),i!=null&&this._installScaleForKey(i,r),this._clearAttrToProjectorCache()},t.prototype._clearAttrToProjectorCache=function(){delete this._cachedAttrToProjector},t.prototype._getAttrToProjector=function(){if(this._cachedAttrToProjector==null){var r=this._generateAttrToProjector();t.OPTIMIZE_MEMOIZE_PROJECTORS&&(r=aat.memoizeProjectors(r)),this._cachedAttrToProjector=r}return Sd.assign({},this._cachedAttrToProjector)},t.prototype._generateAttrToProjector=function(){var r={};this._attrBindings.each(function(i,o){r[o]=t._scaledAccessor(i)});var n=this._propertyProjectors();return Object.keys(n).forEach(function(i){r[i]==null&&(r[i]=n[i])}),r},t.prototype.renderImmediately=function(){return e.prototype.renderImmediately.call(this),this._isAnchored&&(this._paint(),this._dataChanged=!1),this},t.prototype.renderLowPriority=function(){return this._renderCallback(),this},t.prototype.animated=function(r){return r==null?this._animate:(this._animate=r,this)},t.prototype.detach=function(){return e.prototype.detach.call(this),this._updateExtents(),this},t.prototype._scales=function(){var r=[];return this._attrBindings.each(function(n,i){var o=n.scale;o!=null&&r.indexOf(o)===-1&&r.push(o)}),this._propertyBindings.each(function(n,i){var o=n.scale;o!=null&&r.indexOf(o)===-1&&r.push(o)}),r},t.prototype._updateExtents=function(){var r=this;this._resetEntityStore(),this._scales().forEach(function(n){return n.addIncludedValuesProvider(r._includedValuesProvider)})},t.prototype._filterForProperty=function(r){return null},t.prototype.getExtentsForAttr=function(r){var n=this;if(this._attrExtents[r]==null){var i=aat.memThunk(function(){return n.datasets()},function(){return n._attrBindings.get(r)},function(o,a){return a==null||a.accessor==null?null:o.map(function(s){return tKt(s,a,null)})});this._attrExtents[r]=i}return this._attrExtents[r]()},t.prototype.getExtentsForProperty=function(r){var n=this;if(this._propertyExtents[r]==null){var i=aat.memThunk(function(){return n.datasets()},function(){return n._propertyBindings.get(r)},function(){return n._filterForProperty(r)},function(o,a,s){return a==null||a.accessor==null?null:o.map(function(l){return tKt(l,a,s)})});this._propertyExtents[r]=i}return this._propertyExtents[r]()},t.prototype._includedValuesForScale=function(r,n){var i=this;if(!this._isAnchored&&!n)return[];var o=[];return this._attrBindings.each(function(a,s){if(a.scale===r){var l=i.getExtentsForAttr(s);l!=null&&(o=o.concat(wd.merge(l)))}}),this._propertyBindings.each(function(a,s){if(a.scale===r){var l=i.getExtentsForProperty(s);l!=null&&(o=o.concat(wd.merge(l)))}}),o},t.prototype.animator=function(r,n){return n===void 0?this._animators[r]:(this._animators[r]=n,this)},t.prototype.renderer=function(r){var n=this;return r===void 0?this._canvas==null?"svg":"canvas":(this._canvas==null&&r==="canvas"?(this._canvas=wd.select(document.createElement("canvas")).classed("plot-canvas",!0),this._bufferCanvas=wd.select(document.createElement("canvas")),this.element()!=null&&this._appendCanvasNode(),this._datasetToDrawer.forEach(function(i){i.useCanvas(n._canvas)}),this.render()):this._canvas!=null&&r=="svg"&&(this._canvas.remove(),this._canvas=null,this._bufferCanvas=null,this._datasetToDrawer.forEach(function(i){i.useSVG(n._renderArea)}),this.render()),this)},t.prototype.addDataset=function(r){return this._addDataset(r),this._onDatasetUpdate(),this},t.prototype._addDataset=function(r){this._removeDataset(r);var n=this._createDrawer(r);return this._datasetToDrawer.set(r,n),this._isSetup&&this._createNodesForDataset(r),r.onUpdate(this._onDatasetUpdateCallback),this},t.prototype.removeDataset=function(r){return this._removeDataset(r),this._onDatasetUpdate(),this},t.prototype._removeDataset=function(r){return this.datasets().indexOf(r)===-1?this:(this._removeDatasetNodes(r),r.offUpdate(this._onDatasetUpdateCallback),this._datasetToDrawer.delete(r),this)},t.prototype._removeDatasetNodes=function(r){var n=this._datasetToDrawer.get(r);n.remove()},t.prototype.datasets=function(r){var n=this,i=[];return this._datasetToDrawer.forEach(function(o,a){return i.push(a)}),r==null?i:(i.forEach(function(o){return n._removeDataset(o)}),r.forEach(function(o){return n._addDataset(o)}),this._onDatasetUpdate(),this)},t.prototype._generateDrawSteps=function(){return[{attrToProjector:this._getAttrToProjector(),animator:new p4.Null}]},t.prototype._additionalPaint=function(r){},t.prototype._buildLightweightPlotEntities=function(r){var n=this,i=[];return r.forEach(function(o,a){for(var s=n._datasetToDrawer.get(o),l=0,c=o.data(),u=c.length,h=function(p){var d=c[p],g=n._pixelPoint(d,p,o);if(Sd.Math.isNaN(g.x)||Sd.Math.isNaN(g.y))return"continue";var _=n;i.push({datum:d,get position(){return _._pixelPoint.call(_,d,p,o)},index:p,dataset:o,datasetIndex:a,component:n,drawer:s,validDatumIndex:l}),l++},f=0;f<u;f++)h(f)}),i},t.prototype._getDataToDraw=function(){var r=new Sd.Map;return this.datasets().forEach(function(n){return r.set(n,n.data())}),r},t.prototype._paint=function(){var r=this;delete this._cachedAttrToProjector;var n=this._generateDrawSteps(),i=this._getDataToDraw(),o=this.datasets().map(function(u){return r._datasetToDrawer.get(u)});if(this.renderer()==="canvas"){var a=this._canvas.node(),s=a.getContext("2d");s.clearRect(0,0,a.clientWidth,a.clientHeight),this._bufferCanvasValid=!1}this.datasets().forEach(function(u,h){var f=t.applyDrawSteps(n,u);o[h].draw(i.get(u),f)});var l=this.datasets().map(function(u,h){return t.getTotalDrawTime(i.get(u),n)}),c=Sd.Math.max(l,0);this._additionalPaint(c)},t.prototype.selections=function(r){var n=this;if(r===void 0&&(r=this.datasets()),this.renderer()==="canvas")return wd.selectAll();var i=[];return r.forEach(function(o){var a=n._datasetToDrawer.get(o);if(a!=null){var s=a.getVisualPrimitives();i.push.apply(i,s)}}),wd.selectAll(i)},t.prototype.entities=function(r){var n=this;return this._getEntityStore(r).entities().map(function(i){return n._lightweightPlotEntityToPlotEntity(i)})},t.prototype.filterEntities=function(r){var n=this;return this._getEntityStore().entities().filter(r).map(function(i){return n._lightweightPlotEntityToPlotEntity(i)})},t.prototype._getEntityStore=function(r){var n=this,i=function(a){return n._entityBounds(a)};if(r!==void 0){var o=new Sd.EntityStore;return o.addAll(this._buildLightweightPlotEntities(r),i,this._localOriginBounds()),o}else if(this._cachedEntityStore===void 0){var o=new Sd.EntityStore;o.addAll(this._buildLightweightPlotEntities(this.datasets()),i,this._localOriginBounds()),this._cachedEntityStore=o}return this._cachedEntityStore},t.prototype._localOriginBounds=function(){return{topLeft:{x:0,y:0},bottomRight:{x:this.width(),y:this.height()}}},t.prototype._entityBounds=function(r){var n=r.datum,i=r.index,o=r.dataset,a=this._pixelPoint(n,i,o),s=a.x,l=a.y;return{x:s,y:l,width:0,height:0}},t.prototype._lightweightPlotEntityToPlotEntity=function(r){var n={bounds:this._entityBounds(r),component:r.component,dataset:r.dataset,datasetIndex:r.datasetIndex,datum:r.datum,index:r.index,position:r.position,selection:wd.select(r.drawer.getVisualPrimitiveAtIndex(r.validDatumIndex))};return n},t.prototype.entitiesAt=function(r){throw new Error("plots must implement entitiesAt")},t.prototype.entityNearest=function(r){var n=this._getEntityStore().entityNearest(r);return n===void 0?void 0:this._lightweightPlotEntityToPlotEntity(n)},t.prototype.entitiesIn=function(r,n){var i;if(n==null){var o=r;i={x:o.topLeft.x,y:o.topLeft.y,width:o.bottomRight.x-o.topLeft.x,height:o.bottomRight.y-o.topLeft.y}}else{var a=r;i={x:a.min,y:n.min,width:a.max-a.min,height:n.max-n.min}}return this.entitiesInBounds(i)},t.prototype.entitiesInBounds=function(r){var n=this,i=this._getEntityStore().entitiesInBounds(r);if(!!i)return i.map(function(o){return n._lightweightPlotEntityToPlotEntity(o)})},t.prototype.entitiesInXBounds=function(r){var n=this,i=this._getEntityStore().entitiesInXBounds(r);if(!!i)return i.map(function(o){return n._lightweightPlotEntityToPlotEntity(o)})},t.prototype.entitiesInYBounds=function(r){var n=this,i=this._getEntityStore().entitiesInYBounds(r);if(!!i)return i.map(function(o){return n._lightweightPlotEntityToPlotEntity(o)})},t.prototype._uninstallScaleForKey=function(r,n){r.offUpdate(this._renderCallback),r.offUpdate(this._deferredResetEntityStore),r.removeIncludedValuesProvider(this._includedValuesProvider)},t.prototype._installScaleForKey=function(r,n){r.onUpdate(this._renderCallback),r.onUpdate(this._deferredResetEntityStore),r.addIncludedValuesProvider(this._includedValuesProvider)},t.prototype._propertyProjectors=function(){return{}},t._scaledAccessor=function(r){var n=r.scale,i=r.accessor,o=r.postScale,a=n==null?i:function(l,c,u){return n.scale(i(l,c,u))},s=o==null?a:function(l,c,u){return o(a(l,c,u),l,c,u)};return s},t.prototype._pixelPoint=function(r,n,i){return{x:0,y:0}},t.prototype._animateOnNextRender=function(){return this._animate&&this._dataChanged},t.OPTIMIZE_MEMOIZE_PROJECTORS=!1,t._ANIMATION_MAX_DURATION=600,t}(EHe.Component);JF.Plot=kHe;function tKt(e,t,r){var n=t.accessor,i=t.scale;if(i==null)return[];var o=e.data();r!=null&&(o=o.filter(function(l,c){return r(l,c,e)}));var a=function(l,c){return n(l,c,e)},s=o.map(a);return i.extentOfValues(s)}});var eKt=H(sat=>{"use strict";Object.defineProperty(sat,"__esModule",{value:!0});var RHe=(de(),Ut(pe)),NHe=rs(),DHe=Fe(),OHe=Fot(),zHe=function(e){RHe.__extends(t,e);function t(){return e!==null&&e.apply(this,arguments)||this}return t.prototype.entityNearest=function(r){var n,i=1/0;return this.components().forEach(function(o){var a=o,s=a.entityNearest(r);if(s!=null){var l=DHe.Math.distanceSquared(s.position,r);l<=i&&(i=l,n=s)}}),n},t.prototype.append=function(r){if(r!=null&&!(r instanceof NHe.Plot))throw new Error("Plot Group only accepts plots");return e.prototype.append.call(this,r),this},t}(OHe.Group);sat.PlotGroup=zHe});var rKt=H(lat=>{"use strict";Object.defineProperty(lat,"__esModule",{value:!0});var FHe=(de(),Ut(pe)),qu=(Er(),Ut(Mr)),Go=Fe(),BHe=GF(),HHe=function(e){FHe.__extends(t,e);function t(r){r===void 0&&(r=[]);var n=e.call(this)||this;return n._rowPadding=0,n._columnPadding=0,n._rows=[],n._rowWeights=[],n._columnWeights=[],n._nRows=0,n._nCols=0,n._calculatedLayout=null,n.addClass("table"),r.forEach(function(i,o){i.forEach(function(a,s){a!=null&&n.add(a,o,s)})}),n}return t.prototype._forEach=function(r){for(var n=0;n<this._nRows;n++)for(var i=0;i<this._nCols;i++)this._rows[n][i]!=null&&r(this._rows[n][i])},t.prototype.has=function(r){for(var n=0;n<this._nRows;n++)for(var i=0;i<this._nCols;i++)if(this._rows[n][i]===r)return!0;return!1},t.prototype.componentAt=function(r,n){return r<0||r>=this._nRows||n<0||n>=this._nCols?null:this._rows[r][n]},t.prototype.add=function(r,n,i){if(r==null)throw Error("Cannot add null to a table cell");if(!this.has(r)){var o=this._rows[n]&&this._rows[n][i];if(o!=null)throw new Error("cell is occupied");r.detach(),this._nRows=Math.max(n+1,this._nRows),this._nCols=Math.max(i+1,this._nCols),this._padTableToSize(this._nRows,this._nCols),this._rows[n][i]=r,this._adoptAndAnchor(r),this.redraw()}return this},t.prototype._remove=function(r){for(var n=0;n<this._nRows;n++)for(var i=0;i<this._nCols;i++)if(this._rows[n][i]===r)return this._rows[n][i]=null,!0;return!1},t.prototype._iterateLayout=function(r,n,i){i===void 0&&(i=!1);for(var o=this._rows,a=qu.transpose(this._rows),s=r-this._columnPadding*(this._nCols-1),l=n-this._rowPadding*(this._nRows-1),c=t._calcComponentWeights(this._rowWeights,o,function(z){return z==null||z.fixedHeight()}),u=t._calcComponentWeights(this._columnWeights,a,function(z){return z==null||z.fixedWidth()}),h=u.map(function(z){return z===0?.5:z}),f=c.map(function(z){return z===0?.5:z}),p=t._calcProportionalSpace(h,s),d=t._calcProportionalSpace(f,l),g=Go.Array.createFilledArray(0,this._nCols),_=Go.Array.createFilledArray(0,this._nRows),y,x,b=0,S,C,P;;){var k=Go.Array.add(_,d),O=Go.Array.add(g,p);S=this._determineGuarantees(O,k,i),g=S.guaranteedWidths,_=S.guaranteedHeights,C=S.wantsWidthArr.some(function(z){return z}),P=S.wantsHeightArr.some(function(z){return z});var D=y,B=x;y=s-qu.sum(S.guaranteedWidths),x=l-qu.sum(S.guaranteedHeights);var I=void 0;C?(I=S.wantsWidthArr.map(function(z){return z?.1:0}),I=Go.Array.add(I,u)):I=u;var L=void 0;P?(L=S.wantsHeightArr.map(function(z){return z?.1:0}),L=Go.Array.add(L,c)):L=c,p=t._calcProportionalSpace(I,y),d=t._calcProportionalSpace(L,x),b++;var R=y>0&&y!==D,F=x>0&&x!==B;if(!(R||F)||b>5)break}return y=s-qu.sum(S.guaranteedWidths),x=l-qu.sum(S.guaranteedHeights),p=t._calcProportionalSpace(u,y),d=t._calcProportionalSpace(c,x),{colProportionalSpace:p,rowProportionalSpace:d,guaranteedWidths:S.guaranteedWidths,guaranteedHeights:S.guaranteedHeights,wantsWidth:C,wantsHeight:P}},t.prototype._determineGuarantees=function(r,n,i){i===void 0&&(i=!1);var o=Go.Array.createFilledArray(0,this._nCols),a=Go.Array.createFilledArray(0,this._nRows),s=Go.Array.createFilledArray(!1,this._nCols),l=Go.Array.createFilledArray(!1,this._nRows);return this._rows.forEach(function(c,u){c.forEach(function(h,f){var p;h!=null?p=h.requestedSpace(r[f],n[u]):p={minWidth:0,minHeight:0};var d=i?Math.min(p.minWidth,r[f]):p.minWidth;o[f]=Math.max(o[f],d);var g=i?Math.min(p.minHeight,n[u]):p.minHeight;a[u]=Math.max(a[u],g);var _=p.minWidth>r[f];s[f]=s[f]||_;var y=p.minHeight>n[u];l[u]=l[u]||y})}),{guaranteedWidths:o,guaranteedHeights:a,wantsWidthArr:s,wantsHeightArr:l}},t.prototype.requestedSpace=function(r,n){return this._calculatedLayout=this._iterateLayout(r,n),{minWidth:qu.sum(this._calculatedLayout.guaranteedWidths),minHeight:qu.sum(this._calculatedLayout.guaranteedHeights)}},t.prototype.computeLayout=function(r,n,i){var o=this;e.prototype.computeLayout.call(this,r,n,i);var a=qu.sum(this._calculatedLayout.guaranteedWidths),s=qu.sum(this._calculatedLayout.guaranteedHeights),l=this._calculatedLayout;(a>this.width()||s>this.height())&&(l=this._iterateLayout(this.width(),this.height(),!0));var c=0,u=Go.Array.add(l.rowProportionalSpace,l.guaranteedHeights),h=Go.Array.add(l.colProportionalSpace,l.guaranteedWidths);return this._rows.forEach(function(f,p){var d=0;f.forEach(function(g,_){g!=null&&g.computeLayout({x:d,y:c},h[_],u[p]),d+=h[_]+o._columnPadding}),c+=u[p]+o._rowPadding}),this},t.prototype.rowPadding=function(r){if(r==null)return this._rowPadding;if(!Go.Math.isValidNumber(r)||r<0)throw Error("rowPadding must be a non-negative finite value");return this._rowPadding=r,this.redraw(),this},t.prototype.columnPadding=function(r){if(r==null)return this._columnPadding;if(!Go.Math.isValidNumber(r)||r<0)throw Error("columnPadding must be a non-negative finite value");return this._columnPadding=r,this.redraw(),this},t.prototype.rowWeight=function(r,n){if(n==null)return this._rowWeights[r];if(!Go.Math.isValidNumber(n)||n<0)throw Error("rowWeight must be a non-negative finite value");return this._rowWeights[r]=n,this.redraw(),this},t.prototype.columnWeight=function(r,n){if(n==null)return this._columnWeights[r];if(!Go.Math.isValidNumber(n)||n<0)throw Error("columnWeight must be a non-negative finite value");return this._columnWeights[r]=n,this.redraw(),this},t.prototype.fixedWidth=function(){var r=qu.transpose(this._rows);return t._fixedSpace(r,function(n){return n==null||n.fixedWidth()})},t.prototype.fixedHeight=function(){return t._fixedSpace(this._rows,function(r){return r==null||r.fixedHeight()})},t.prototype._padTableToSize=function(r,n){for(var i=0;i<r;i++){this._rows[i]===void 0&&(this._rows[i]=[],this._rowWeights[i]=null);for(var o=0;o<n;o++)this._rows[i][o]===void 0&&(this._rows[i][o]=null)}for(var o=0;o<n;o++)this._columnWeights[o]===void 0&&(this._columnWeights[o]=null)},t._calcComponentWeights=function(r,n,i){return r.map(function(o,a){if(o!=null)return o;var s=n[a].map(i),l=s.reduce(function(c,u){return c&&u},!0);return l?0:1})},t._calcProportionalSpace=function(r,n){var i=qu.sum(r);return i===0?Go.Array.createFilledArray(0,r.length):r.map(function(o){return n*o/i})},t._fixedSpace=function(r,n){var i=function(a){return a.reduce(function(s,l){return s&&l},!0)},o=function(a){return i(a.map(n))};return i(r.map(o))},t}(BHe.ComponentContainer);lat.Table=HHe});var nKt=H(cat=>{"use strict";Object.defineProperty(cat,"__esModule",{value:!0});var VHe=(de(),Ut(pe)),UHe=Uot(),qHe=2,GHe=function(e){VHe.__extends(t,e);function t(){var r=e!==null&&e.apply(this,arguments)||this;return r._maxLines=qHe,r}return t.prototype.requestedSpace=function(r,n){this._wrapper.maxLines(this._maxLines);var i=this.angle()===0?r:n;i===0&&(i=1/0);var o=this._wrapper.wrap(this._text,this._measurer,i),a=this._measurer.measure(o.wrappedText),s=(this.angle()===0?a.width:a.height)+2*this.padding(),l=(this.angle()===0?a.height:a.width)+2*this.padding();return{minWidth:s,minHeight:l}},t.prototype.maxLines=function(r){return arguments.length===0?this._maxLines:(this._maxLines=r,this.redraw(),this)},t}(UHe.Label);cat.WrappedLabel=GHe});var iKt=H(uat=>{"use strict";Object.defineProperty(uat,"__esModule",{value:!0});var WHe=(de(),Ut(pe)),YHe=UF(),jHe=function(e){WHe.__extends(t,e);function t(){var r=e.call(this)||this;return r.addClass("x-drag-box-layer"),r._hasCorners=!1,r}return t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this._setBounds(this.bounds()),this},t.prototype._setBounds=function(r){e.prototype._setBounds.call(this,{topLeft:{x:r.topLeft.x,y:0},bottomRight:{x:r.bottomRight.x,y:this.height()}})},t.prototype._setResizableClasses=function(r){r&&this.enabled()?this.addClass("x-resizable"):this.removeClass("x-resizable")},t.prototype.yScale=function(r){if(r==null)return e.prototype.yScale.call(this);throw new Error("yScales cannot be set on an XDragBoxLayer")},t.prototype.yExtent=function(r){if(r==null)return e.prototype.yExtent.call(this);throw new Error("XDragBoxLayer has no yExtent")},t}(YHe.DragBoxLayer);uat.XDragBoxLayer=jHe});var oKt=H(hat=>{"use strict";Object.defineProperty(hat,"__esModule",{value:!0});var XHe=(de(),Ut(pe)),$He=UF(),KHe=function(e){XHe.__extends(t,e);function t(){var r=e.call(this)||this;return r.addClass("y-drag-box-layer"),r._hasCorners=!1,r}return t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this._setBounds(this.bounds()),this},t.prototype._setBounds=function(r){e.prototype._setBounds.call(this,{topLeft:{x:0,y:r.topLeft.y},bottomRight:{x:this.width(),y:r.bottomRight.y}})},t.prototype._setResizableClasses=function(r){r&&this.enabled()?this.addClass("y-resizable"):this.removeClass("y-resizable")},t.prototype.xScale=function(r){if(r==null)return e.prototype.xScale.call(this);throw new Error("xScales cannot be set on an YDragBoxLayer")},t.prototype.xExtent=function(r){if(r==null)return e.prototype.xExtent.call(this);throw new Error("YDragBoxLayer has no xExtent")},t}($He.DragBoxLayer);hat.YDragBoxLayer=KHe});var Iot=H(_a=>{"use strict";Object.defineProperty(_a,"__esModule",{value:!0});var Ns=(de(),Ut(pe));Ns.__exportStar(UF(),_a);Ns.__exportStar(E$t(),_a);Ns.__exportStar(T$t(),_a);Ns.__exportStar(Fot(),_a);Ns.__exportStar(kot(),_a);Ns.__exportStar(A$t(),_a);Ns.__exportStar(Uot(),_a);Ns.__exportStar(P$t(),_a);Ns.__exportStar(eKt(),_a);Ns.__exportStar(Cot(),_a);Ns.__exportStar(rKt(),_a);Ns.__exportStar(nKt(),_a);Ns.__exportStar(iKt(),_a);Ns.__exportStar(oKt(),_a)});var pat=H(fat=>{"use strict";Object.defineProperty(fat,"__esModule",{value:!0});var ZHe=(de(),Ut(pe)),JHe=Df(),QHe=function(e){ZHe.__extends(t,e);function t(){return e.call(this,"path","arc fill")||this}return t.prototype._applyDefaultAttributes=function(r){r.style("stroke","none")},t}(JHe.SVGDrawer);fat.ArcSVGDrawer=QHe});var mat=H(dat=>{"use strict";Object.defineProperty(dat,"__esModule",{value:!0});var tVe=(de(),Ut(pe)),eVe=Df(),rVe=function(e){tVe.__extends(t,e);function t(){return e.call(this,"path","arc outline")||this}return t.prototype._applyDefaultAttributes=function(r){r.style("fill","none")},t}(eVe.SVGDrawer);dat.ArcOutlineSVGDrawer=rVe});var gat=H(tB=>{"use strict";Object.defineProperty(tB,"__esModule",{value:!0});var nVe=(de(),Ut(pe)),QF=F1(),iVe=Df(),oVe=function(e){nVe.__extends(t,e);function t(){return e.call(this,"path","area")||this}return t.prototype._applyDefaultAttributes=function(r){r.style("stroke","none")},t.prototype.getVisualPrimitiveAtIndex=function(r){return e.prototype.getVisualPrimitiveAtIndex.call(this,0)},t}(iVe.SVGDrawer);tB.AreaSVGDrawer=oVe;var aVe=["opacity","fill","fill-opacity"],sVe=["opacity","stroke","stroke-width"];function lVe(e,t){return function(r,n,i){var o=QF.resolveAttributes(i,aVe,n[0],0);QF.renderArea(r,e(),n[0],o);var a=QF.resolveAttributes(i,sVe,n[0],0);QF.renderLine(r,t(),n[0],a)}}tB.makeAreaCanvasDrawStep=lVe});var rB=H(eB=>{"use strict";Object.defineProperty(eB,"__esModule",{value:!0});var cVe=(de(),Ut(pe)),aKt=F1(),uVe=Df(),hVe=function(e){cVe.__extends(t,e);function t(){return e.call(this,"path","line")||this}return t.prototype._applyDefaultAttributes=function(r){r.style("fill","none")},t.prototype.getVisualPrimitiveAtIndex=function(r){return e.prototype.getVisualPrimitiveAtIndex.call(this,0)},t}(uVe.SVGDrawer);eB.LineSVGDrawer=hVe;var fVe=["opacity","stroke-opacity","stroke-width","stroke","stroke-dasharray"];function pVe(e){return function(t,r,n){var i=aKt.resolveAttributes(n,fVe,r[0],0);aKt.renderLine(t,e(),r[0],i)}}eB.makeLineCanvasDrawStep=pVe});var iB=H(PS=>{"use strict";Object.defineProperty(PS,"__esModule",{value:!0});var sKt=(de(),Ut(pe)),nB=F1(),dVe=Df(),mVe=function(e){sKt.__extends(t,e);function t(r){r===void 0&&(r="");var n=e.call(this,"rect","")||this;return n._rootClassName=r,n._root.classed(n._rootClassName,!0),n}return t}(dVe.SVGDrawer);PS.RectangleSVGDrawer=mVe;var gVe=nB.ContextStyleAttrs.concat(["x","y","width","height"]);PS.RectangleCanvasDrawStep=function(e,t,r){e.save();for(var n=t.length,i=0;i<n;i++){var o=t[i];if(o!=null){var a=nB.resolveAttributes(r,gVe,o,i);e.beginPath(),e.rect(a.x,a.y,a.width,a.height),nB.renderPathWithStyle(e,a)}}e.restore()};var _Ve=function(e){sKt.__extends(t,e);function t(r){return e.call(this,r,PS.RectangleCanvasDrawStep)||this}return t}(nB.CanvasDrawer);PS.RectangleCanvasDrawer=_Ve});var yat=H(_at=>{"use strict";Object.defineProperty(_at,"__esModule",{value:!0});var yVe=(de(),Ut(pe)),vVe=Df(),xVe=function(e){yVe.__extends(t,e);function t(){return e.call(this,"line","")||this}return t}(vVe.SVGDrawer);_at.SegmentSVGDrawer=xVe});var lKt=H(vat=>{"use strict";Object.defineProperty(vat,"__esModule",{value:!0});var bVe=function(){function e(t,r,n){n===void 0&&(n=window.devicePixelRatio),this.screenWidth=t,this.screenHeight=r,this.devicePixelRatio=n,this.pixelWidth=t*n,this.pixelHeight=r*n,this.canvas=document.createElement("canvas"),this.ctx=this.canvas.getContext("2d"),e.sizePixels(this.ctx,t,r,n)}return e.sizePixels=function(t,r,n,i){var o=t.canvas;o.width=r*i,o.height=n*i,o.style.width=r+"px",o.style.height=n+"px",t.setTransform(1,0,0,1,0,0),t.scale(i,i)},e.prototype.blit=function(t,r,n){r===void 0&&(r=0),n===void 0&&(n=0),t.drawImage(this.canvas,r,n,this.screenWidth,this.screenHeight)},e.prototype.blitCenter=function(t,r,n){r===void 0&&(r=0),n===void 0&&(n=0),this.blit(t,Math.floor(r-this.screenWidth/2),Math.floor(n-this.screenHeight/2))},e.prototype.resize=function(t,r,n){n===void 0&&(n=!1);var i=this.devicePixelRatio;return this.screenWidth=t,this.screenHeight=r,this.pixelWidth=t*i,this.pixelHeight=r*i,e.sizePixels(this.ctx,t,r,i),n&&this.ctx.translate(t/2,t/2),this},e.prototype.clear=function(t){var r=this,n=r.pixelWidth,i=r.pixelHeight,o=r.ctx;return o.save(),o.setTransform(1,0,0,1,0,0),t==null?o.clearRect(0,0,n,i):(o.fillStyle=t,o.fillRect(0,0,n,i)),o.restore(),this},e.prototype.getImageData=function(){return this.ctx.getImageData(0,0,this.pixelWidth,this.pixelHeight)},e}();vat.CanvasBuffer=bVe});var xat=H(oB=>{"use strict";Object.defineProperty(oB,"__esModule",{value:!0});var wVe=(de(),Ut(pe)),d4=F1(),SVe=lKt(),MVe=Df(),EVe=function(e){wVe.__extends(t,e);function t(){return e.call(this,"path","symbol")||this}return t}(MVe.SVGDrawer);oB.SymbolSVGDrawer=EVe;var TVe=d4.ContextStyleAttrs.concat(["x","y"]);function CVe(e,t,r,n){var i=this;return function(o,a,s){for(var l=o.canvas,c=l.clientWidth,u=l.clientHeight,h=n===void 0?new SVe.CanvasBuffer(0,0):n,f=t(),p=r(),d=null,g=null,_=null,y=0;y<a.length;y++){var x=a[y];if(x!=null){var b=d4.resolveAttributes(s,TVe,x,y),S=p(x,y,e);if(!!AVe(c,u,b.x,b.y,S)){var C=PVe(d,b,d4.ContextStyleAttrs),P=f(x,y,i._dataset);if(!(C&&_==S&&g==P)){var k=d4.getStrokeWidth(b),O=S+k+1;(O>h.screenWidth||O>h.screenHeight)&&h.resize(O,O,!0),h.clear();var D=h.ctx;D.beginPath(),P(S).context(D)(null),D.closePath(),d4.renderPathWithStyle(D,b),g=P,_=S,d=b}h.blitCenter(o,b.x,b.y)}}}}}oB.makeSymbolCanvasDrawStep=CVe;function AVe(e,t,r,n,i){return r+i>=0&&r-i<=e&&n+i>=0&&n-i<=t}function PVe(e,t,r){if(e==null)return!1;for(var n=0;n<r.length;n++){var i=r[n];if(e[i]!=t[i])return!1}return!0}});var B1=H(Dc=>{"use strict";Object.defineProperty(Dc,"__esModule",{value:!0});var Of=(de(),Ut(pe));Of.__exportStar(pat(),Dc);Of.__exportStar(mat(),Dc);Of.__exportStar(gat(),Dc);Of.__exportStar(F1(),Dc);Of.__exportStar(Uu(),Dc);Of.__exportStar(rB(),Dc);Of.__exportStar(iB(),Dc);Of.__exportStar(yat(),Dc);Of.__exportStar(Df(),Dc);Of.__exportStar(xat(),Dc)});var H1=H(wat=>{"use strict";Object.defineProperty(wat,"__esModule",{value:!0});var IVe=(de(),Ut(pe)),cKt=ks(),bat=Fe(),LVe=oat(),m4=rs(),kVe=function(e){IVe.__extends(t,e);function t(){var r=e.call(this)||this;return r._autoAdjustXScaleDomain=!1,r._autoAdjustYScaleDomain=!1,r._deferredRendering=!1,r._applyDeferredRenderingTransform=function(n,i,o,a){!r._isAnchored||(r._renderArea!=null&&r._renderArea.attr("transform","translate("+n+", "+i+") scale("+o+", "+a+")"),r._canvas!=null&&r._canvas.style("transform","translate("+n+"px, "+i+"px) scale("+o+", "+a+")"))},r.addClass("xy-plot"),r._adjustYDomainOnChangeFromXCallback=function(n){return r._adjustYDomainOnChangeFromX()},r._adjustXDomainOnChangeFromYCallback=function(n){return r._adjustXDomainOnChangeFromY()},r._renderCallback=function(){if(r.deferredRendering()){var n=r.x()&&r.x().scale,i=r.y()&&r.y().scale;r._deferredRenderer.updateDomains(n,i)}else r.render()},r._deferredRenderer=new LVe.DeferredRenderer(function(){return r.render()},r._applyDeferredRenderingTransform),r}return t.prototype.render=function(){return this.deferredRendering()&&this._deferredRenderer.resetTransforms(),e.prototype.render.call(this)},t.prototype.deferredRendering=function(r){if(r==null)return this._deferredRendering;if(r){var n=this.x()&&this.x().scale,i=this.y()&&this.y().scale;this._deferredRenderer.setDomains(n,i)}return this._deferredRendering=r,this},t.prototype.x=function(r,n,i){if(r==null)return this._propertyBindings.get(t._X_KEY);this._bindProperty(t._X_KEY,r,n,i);var o=this.width();return n!=null&&o!=null&&n.range([0,o]),this._autoAdjustYScaleDomain&&this._updateYExtentsAndAutodomain(),this.render(),this},t.prototype.y=function(r,n,i){if(r==null)return this._propertyBindings.get(t._Y_KEY);this._bindProperty(t._Y_KEY,r,n,i);var o=this.height();return n!=null&&o!=null&&(n instanceof cKt.Category?n.range([0,o]):n.range([o,0])),this._autoAdjustXScaleDomain&&this._updateXExtentsAndAutodomain(),this.render(),this},t.prototype._filterForProperty=function(r){return r==="x"&&this._autoAdjustXScaleDomain?this._makeFilterByProperty("y"):(r==="y"||r==="y0")&&this._autoAdjustYScaleDomain?this._makeFilterByProperty("x"):null},t.prototype._makeFilterByProperty=function(r){var n=this._propertyBindings.get(r);if(n!=null){var i=n.accessor,o=n.scale;if(o!=null)return function(a,s,l){var c=o.range();return bat.Math.inRange(o.scale(i(a,s,l)),c[0],c[1])}}return null},t.prototype._uninstallScaleForKey=function(r,n){e.prototype._uninstallScaleForKey.call(this,r,n);var i=n===t._X_KEY?this._adjustYDomainOnChangeFromXCallback:this._adjustXDomainOnChangeFromYCallback;r.offUpdate(i)},t.prototype._installScaleForKey=function(r,n){e.prototype._installScaleForKey.call(this,r,n);var i=n===t._X_KEY?this._adjustYDomainOnChangeFromXCallback:this._adjustXDomainOnChangeFromYCallback;r.onUpdate(i)},t.prototype.destroy=function(){return e.prototype.destroy.call(this),this.x().scale&&this.x().scale.offUpdate(this._adjustYDomainOnChangeFromXCallback),this.y().scale&&this.y().scale.offUpdate(this._adjustXDomainOnChangeFromYCallback),this},t.prototype.autorangeMode=function(r){if(r==null)return this._autoAdjustXScaleDomain?"x":this._autoAdjustYScaleDomain?"y":"none";switch(r){case"x":this._autoAdjustXScaleDomain=!0,this._autoAdjustYScaleDomain=!1,this._adjustXDomainOnChangeFromY();break;case"y":this._autoAdjustXScaleDomain=!1,this._autoAdjustYScaleDomain=!0,this._adjustYDomainOnChangeFromX();break;case"none":this._autoAdjustXScaleDomain=!1,this._autoAdjustYScaleDomain=!1;break;default:throw new Error("Invalid scale name '"+r+"', must be 'x', 'y' or 'none'")}return this},t.prototype.computeLayout=function(r,n,i){e.prototype.computeLayout.call(this,r,n,i);var o=this.x(),a=o&&o.scale;a!=null&&a.range([0,this.width()]);var s=this.y(),l=s&&s.scale;return l!=null&&(l instanceof cKt.Category?l.range([0,this.height()]):l.range([this.height(),0])),this},t.prototype._updateXExtentsAndAutodomain=function(){var r=this.x().scale;r!=null&&r.autoDomain()},t.prototype._updateYExtentsAndAutodomain=function(){var r=this.y().scale;r!=null&&r.autoDomain()},t.prototype.showAllData=function(){return this._updateXExtentsAndAutodomain(),this._updateYExtentsAndAutodomain(),this},t.prototype._adjustYDomainOnChangeFromX=function(){!this._projectorsReady()||this._autoAdjustYScaleDomain&&this._updateYExtentsAndAutodomain()},t.prototype._adjustXDomainOnChangeFromY=function(){!this._projectorsReady()||this._autoAdjustXScaleDomain&&this._updateXExtentsAndAutodomain()},t.prototype._projectorsReady=function(){var r=this.x(),n=this.y();return r!=null&&r.accessor!=null&&n!=null&&n.accessor!=null},t.prototype._pixelPoint=function(r,n,i){var o=m4.Plot._scaledAccessor(this.x()),a=m4.Plot._scaledAccessor(this.y());return{x:o(r,n,i),y:a(r,n,i)}},t.prototype._getDataToDraw=function(){var r=this,n=e.prototype._getDataToDraw.call(this),i=this.attr("defined"),o=function(a,s,l){var c=m4.Plot._scaledAccessor(r.x())(a,s,l),u=m4.Plot._scaledAccessor(r.y())(a,s,l);return i&&i.accessor(a,s,l)===!1?!1:bat.Math.isValidNumber(c)&&bat.Math.isValidNumber(u)};return this.datasets().forEach(function(a){n.set(a,n.get(a).filter(function(s,l){return o(s,l,a)}))}),n},t._X_KEY="x",t._Y_KEY="y",t}(m4.Plot);wat.XYPlot=kVe});var Mat=H(sB=>{"use strict";Object.defineProperty(sB,"__esModule",{value:!0});var RVe=(de(),Ut(pe)),ya=(Er(),Ut(Mr)),NVe=Lf(),DVe=B1(),OVe=Uu(),uKt=rB(),zVe=ks(),aB=vd(),Qg=Fe(),FVe=If(),Sat=IS(),vl=rs(),BVe=H1(),hKt={linear:ya.curveLinear,linearClosed:ya.curveLinearClosed,step:ya.curveStep,stepBefore:ya.curveStepBefore,stepAfter:ya.curveStepAfter,basis:ya.curveBasis,basisOpen:ya.curveBasisOpen,basisClosed:ya.curveBasisClosed,bundle:ya.curveBundle,cardinal:ya.curveCardinal,cardinalOpen:ya.curveCardinalOpen,cardinalClosed:ya.curveCardinalClosed,monotone:ya.curveMonotoneX};sB.CurveName=FVe.makeEnum(["linear","linearClosed","step","stepBefore","stepAfter","basis","basisOpen","basisClosed","bundle","cardinal","cardinalOpen","cardinalClosed","monotone"]);var HVe=function(e){RVe.__extends(t,e);function t(){var r=e.call(this)||this;r._curve="linear",r._autorangeSmooth=!1,r._croppedRenderingEnabled=!0,r._collapseDenseVerticalLinesEnabled=!1,r._downsamplingEnabled=!1,r.addClass("line-plot");var n=new NVe.Easing;return n.stepDuration(vl.Plot._ANIMATION_MAX_DURATION),n.easingMode("expInOut"),n.maxTotalDuration(vl.Plot._ANIMATION_MAX_DURATION),r.animator(Sat.Animator.MAIN,n),r.attr("stroke",new zVe.Color().range()[0]),r.attr("stroke-width","2px"),r}return t.prototype.x=function(r,n,i){return r==null?e.prototype.x.call(this):(e.prototype.x.call(this,r,n,i),this._setScaleSnapping(),this)},t.prototype.y=function(r,n,i){return r==null?e.prototype.y.call(this):(e.prototype.y.call(this,r,n,i),this._setScaleSnapping(),this)},t.prototype.autorangeMode=function(r){return r==null?e.prototype.autorangeMode.call(this):(e.prototype.autorangeMode.call(this,r),this._setScaleSnapping(),this)},t.prototype.autorangeSmooth=function(r){return r==null?this._autorangeSmooth:(this._autorangeSmooth=r,this._setScaleSnapping(),this)},t.prototype._setScaleSnapping=function(){this.autorangeMode()==="x"&&this.x()&&this.x().scale&&this.x().scale instanceof aB.QuantitativeScale&&this.x().scale.snappingDomainEnabled(!this.autorangeSmooth()),this.autorangeMode()==="y"&&this.y()&&this.y().scale&&this.y().scale instanceof aB.QuantitativeScale&&this.y().scale.snappingDomainEnabled(!this.autorangeSmooth())},t.prototype.curve=function(r){return r==null?this._curve:(this._curve=r,this.render(),this)},t.prototype.downsamplingEnabled=function(r){return r==null?this._downsamplingEnabled:(this._downsamplingEnabled=r,this)},t.prototype.croppedRenderingEnabled=function(r){return r==null?this._croppedRenderingEnabled:(this._croppedRenderingEnabled=r,this.render(),this)},t.prototype.collapseDenseLinesEnabled=function(r){return r==null?this._collapseDenseVerticalLinesEnabled:(this._collapseDenseVerticalLinesEnabled=r,this.render(),this)},t.prototype._createDrawer=function(r){var n=this;return new OVe.ProxyDrawer(function(){return new uKt.LineSVGDrawer},function(i){return new DVe.CanvasDrawer(i,uKt.makeLineCanvasDrawStep(function(){return n._d3LineFactory(r)}))})},t.prototype.getExtentsForProperty=function(r){var n=e.prototype.getExtentsForProperty.call(this,r);if(!this._autorangeSmooth||this.autorangeMode()!==r||this.autorangeMode()!=="x"&&this.autorangeMode()!=="y")return n;var i=this._getEdgeIntersectionPoints(),o;return this.autorangeMode()==="y"?o=i.left.concat(i.right).map(function(a){return a.y}):o=i.top.concat(i.bottom).map(function(a){return a.x}),n.map(function(a){return ya.extent(ya.merge([a,o]))})},t.prototype._getEdgeIntersectionPoints=function(){var r=this;if(!(this.y().scale instanceof aB.QuantitativeScale&&this.x().scale instanceof aB.QuantitativeScale))return{left:[],right:[],top:[],bottom:[]};var n=this.y().scale,i=this.x().scale,o={left:[],right:[],top:[],bottom:[]},a=i.scale(i.domain()[0]),s=i.scale(i.domain()[1]),l=n.scale(n.domain()[0]),c=n.scale(n.domain()[1]);return this.datasets().forEach(function(u){for(var h=u.data(),f,p,d,g,_,y,x,b,S=1;S<h.length;S++)_=x||i.scale(r.x().accessor(h[S-1],S-1,u)),y=b||n.scale(r.y().accessor(h[S-1],S-1,u)),x=i.scale(r.x().accessor(h[S],S,u)),b=n.scale(r.y().accessor(h[S],S,u)),_<a==a<=x&&(f=a-_,p=x-_,g=b-y,d=f*g/p,o.left.push({x:a,y:n.invert(y+d)})),_<s==s<=x&&(f=s-_,p=x-_,g=b-y,d=f*g/p,o.right.push({x:s,y:n.invert(y+d)})),y<c==c<=b&&(p=x-_,d=c-y,g=b-y,f=d*p/g,o.top.push({x:i.invert(_+f),y:c})),y<l==l<=b&&(p=x-_,d=l-y,g=b-y,f=d*p/g,o.bottom.push({x:i.invert(_+f),y:l}))}),o},t.prototype._getResetYFunction=function(){var r=this.y().scale.domain(),n=Math.max(r[0],r[1]),i=Math.min(r[0],r[1]),o=n<0&&n||i>0&&i||0,a=this.y().scale.scale(o);return function(s,l,c){return a}},t.prototype._generateDrawSteps=function(){var r=[];if(this._animateOnNextRender()){var n=this._getAttrToProjector();n.d=this._constructLineProjector(vl.Plot._scaledAccessor(this.x()),this._getResetYFunction()),r.push({attrToProjector:n,animator:this._getAnimator(Sat.Animator.RESET)})}return r.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(Sat.Animator.MAIN)}),r},t.prototype._generateAttrToProjector=function(){var r=e.prototype._generateAttrToProjector.call(this);return Object.keys(r).forEach(function(n){if(n!=="d"){var i=r[n];r[n]=function(o,a,s){return o.length>0?i(o[0],a,s):null}}}),r},t.prototype.entitiesAt=function(r){var n=this.entityNearestByXThenY(r);return n!=null?[n]:[]},t.prototype.entityNearestByXThenY=function(r){for(var n=1/0,i=1/0,o,a=this.bounds(),s=this.entities(),l=s.length,c=0;c<l;c++){var u=s[c];if(!!Qg.Math.within(u.position,a)){var h=Math.abs(r.x-u.position.x),f=Math.abs(r.y-u.position.y);(h<n||h===n&&f<i)&&(o=u,n=h,i=f)}}return o},t.prototype._propertyProjectors=function(){var r=e.prototype._propertyProjectors.call(this);return r.d=this._constructLineProjector(vl.Plot._scaledAccessor(this.x()),vl.Plot._scaledAccessor(this.y())),r},t.prototype._constructLineProjector=function(r,n){var i=this;return function(o,a,s){return i._d3LineFactory(s,r,n)(o)}},t.prototype._d3LineFactory=function(r,n,i){n===void 0&&(n=vl.Plot._scaledAccessor(this.x())),i===void 0&&(i=vl.Plot._scaledAccessor(this.y()));var o=function(a,s,l){var c=n(a,s,l),u=i(a,s,l);return Qg.Math.isValidNumber(c)&&Qg.Math.isValidNumber(u)};return ya.line().x(function(a,s){return n(a,s,r)}).y(function(a,s){return i(a,s,r)}).curve(this._getCurveFactory()).defined(function(a,s){return o(a,s,r)})},t.prototype._getCurveFactory=function(){var r=this.curve();if(typeof r=="string"){var n=hKt[r];return n==null?hKt.linear:n}else return r},t.prototype._getDataToDraw=function(){var r=this,n=new Qg.Map;return this.datasets().forEach(function(i){var o=i.data();if(!r._croppedRenderingEnabled&&!r._downsamplingEnabled){n.set(i,[o]);return}for(var a=[],s=o.length,l=0;l<s;l++)a[l]=l;r._croppedRenderingEnabled&&(a=r._filterCroppedRendering(i,a)),r._downsamplingEnabled&&(a=r._filterDownsampling(i,a)),r._collapseDenseVerticalLinesEnabled&&(a=r._filterDenseLines(i,a));for(var c=[],u=a.length,l=0;l<u;l++){var h=a[l];c[l]=o[h]}n.set(i,[c])}),n},t.prototype._filterCroppedRendering=function(r,n){for(var i=this,o=vl.Plot._scaledAccessor(this.x()),a=vl.Plot._scaledAccessor(this.y()),s=r.data(),l=[],c=function(x,b){return Qg.Math.inRange(x,0,i.width())&&Qg.Math.inRange(b,0,i.height())},u=0;u<n.length;u++){var h=o(s[n[u]],n[u],r),f=a(s[n[u]],n[u],r),p=c(h,f);if(!p&&n[u-1]!=null&&s[n[u-1]]!=null){var d=o(s[n[u-1]],n[u-1],r),g=a(s[n[u-1]],n[u-1],r);p=p||c(d,g)}if(!p&&n[u+1]!=null&&s[n[u+1]]!=null){var _=o(s[n[u+1]],n[u+1],r),y=a(s[n[u+1]],n[u+1],r);p=p||c(_,y)}p&&l.push(n[u])}return l},t.prototype._filterDownsampling=function(r,n){if(n.length===0)return[];for(var i=r.data(),o=vl.Plot._scaledAccessor(this.x()),a=vl.Plot._scaledAccessor(this.y()),s=[n[0]],l=function(k,O){var D=o(i[n[k]],n[k],r),B=a(i[n[k]],n[k],r),I=o(i[n[k+1]],n[k+1],r),L=a(i[n[k+1]],n[k+1],r);if(O===1/0)return Math.floor(D)===Math.floor(I);var R=B+(I-D)*O;return Math.floor(L)===Math.floor(R)},c=0;c<n.length-1;){for(var u=n[c],h=o(i[n[c]],n[c],r),f=a(i[n[c]],n[c],r),p=o(i[n[c+1]],n[c+1],r),d=a(i[n[c+1]],n[c+1],r),g=Math.floor(h)===Math.floor(p)?1/0:(d-f)/(p-h),_=n[c],y=g===1/0?f:h,x=_,b=y,S=!0;c<n.length-1&&(S||l(c,g));){c++,S=!1;var C=g===1/0?a(i[n[c]],n[c],r):o(i[n[c]],n[c],r);C>b&&(b=C,x=n[c]),C<y&&(y=C,_=n[c])}var P=n[c];_!==u&&s.push(_),x!==_&&x!==u&&s.push(x),P!==u&&P!==_&&P!==x&&s.push(P)}return s},t.prototype._filterDenseLines=function(r,n){if(n.length===0)return[];var i=r.data(),o=vl.Plot._scaledAccessor(this.x()),a=vl.Plot._scaledAccessor(this.y()),s=function(c){return o(i[c],c,r)},l=function(c){return a(i[c],c,r)};return this._bucketByX(r,n,s,l)},t.prototype._bucketByX=function(r,n,i,o){for(var a=[],s=r.data(),l=null,c=n.length,u=0;u<=c;++u){var h=n[u];if(s[h]!=null){var f=Math.floor(i(h)),p=o(h);l==null?l=new Qg.Bucket(h,f,p):l.isInBucket(f)?l.addToBucket(p,h):(a.push.apply(a,l.getUniqueIndices()),l=new Qg.Bucket(h,f,p))}}return l!=null&&a.push.apply(a,l.getUniqueIndices()),a},t}(BVe.XYPlot);sB.Line=HVe});var Cat=H(Tat=>{"use strict";Object.defineProperty(Tat,"__esModule",{value:!0});var VVe=(de(),Ut(pe)),lB=(Er(),Ut(Mr)),UVe=ks(),g4=Fe(),Eat=B1(),fKt=gat(),qVe=Uu(),pKt=rB(),cB=IS(),GVe=Mat(),Ds=rs(),WVe=function(e){VVe.__extends(t,e);function t(){var r=e.call(this)||this;return r.addClass("area-plot"),r.y0(0),r.attr("fill-opacity",.25),r.attr("fill",new UVe.Color().range()[0]),r._lineDrawers=new g4.Map,r}return t.prototype.y=function(r,n){if(r==null)return e.prototype.y.call(this);if(n==null?e.prototype.y.call(this,r):e.prototype.y.call(this,r,n),n!=null){var i=this.y0().accessor;i!=null&&this._bindProperty(t._Y0_KEY,i,n),this._updateYScale()}return this},t.prototype.y0=function(r){if(r==null)return this._propertyBindings.get(t._Y0_KEY);var n=this.y(),i=n&&n.scale;return this._bindProperty(t._Y0_KEY,r,i),this._updateYScale(),this.render(),this},t.prototype._onDatasetUpdate=function(){e.prototype._onDatasetUpdate.call(this),this._updateYScale()},t.prototype._addDataset=function(r){var n=this;return this._lineDrawers.set(r,new Eat.ProxyDrawer(function(){return new pKt.LineSVGDrawer},function(i){return new Eat.CanvasDrawer(i,pKt.makeLineCanvasDrawStep(function(){var o=Ds.Plot._scaledAccessor(n.x()),a=Ds.Plot._scaledAccessor(n.y());return n._d3LineFactory(r,o,a)}))})),e.prototype._addDataset.call(this,r),this},t.prototype._createNodesForDataset=function(r){e.prototype._createNodesForDataset.call(this,r);var n=this._lineDrawers.get(r);return this.renderer()==="svg"?n.useSVG(this._renderArea):n.useCanvas(this._canvas),n},t.prototype._removeDatasetNodes=function(r){e.prototype._removeDatasetNodes.call(this,r),this._lineDrawers.get(r).remove()},t.prototype._additionalPaint=function(){var r=this,n=this._generateLineDrawSteps(),i=this._getDataToDraw();this.datasets().forEach(function(o){var a=Ds.Plot.applyDrawSteps(n,o);r._lineDrawers.get(o).draw(i.get(o),a)})},t.prototype._generateLineDrawSteps=function(){var r=[];if(this._animateOnNextRender()){var n=this._generateLineAttrToProjector();n.d=this._constructLineProjector(Ds.Plot._scaledAccessor(this.x()),this._getResetYFunction()),r.push({attrToProjector:n,animator:this._getAnimator(cB.Animator.RESET)})}return r.push({attrToProjector:this._generateLineAttrToProjector(),animator:this._getAnimator(cB.Animator.MAIN)}),r},t.prototype._generateLineAttrToProjector=function(){var r=this._getAttrToProjector();return r.d=this._constructLineProjector(Ds.Plot._scaledAccessor(this.x()),Ds.Plot._scaledAccessor(this.y())),r},t.prototype._createDrawer=function(r){var n=this;return new qVe.ProxyDrawer(function(){return new fKt.AreaSVGDrawer},function(i){return new Eat.CanvasDrawer(i,fKt.makeAreaCanvasDrawStep(function(){var o=n._coordinateProjectors(),a=o[0],s=o[1],l=o[2],c=n._createDefinedProjector(a,s);return n._createAreaGenerator(a,s,l,c,r)},function(){var o=n._coordinateProjectors(),a=o[0],s=o[1],l=n._createDefinedProjector(a,s);return n._createTopLineGenerator(a,s,l,r)}))})},t.prototype._generateDrawSteps=function(){var r=[];if(this._animateOnNextRender()){var n=this._getAttrToProjector();n.d=this._constructAreaProjector(Ds.Plot._scaledAccessor(this.x()),this._getResetYFunction(),Ds.Plot._scaledAccessor(this.y0())),r.push({attrToProjector:n,animator:this._getAnimator(cB.Animator.RESET)})}return r.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(cB.Animator.MAIN)}),r},t.prototype._updateYScale=function(){var r=this.getExtentsForProperty("y0"),n=g4.Array.flatten(r),i=g4.Array.uniq(n),o=i.length===1?i[0]:null,a=this.y(),s=a&&a.scale;s!=null&&(this._constantBaselineValueProvider!=null&&(s.removePaddingExceptionsProvider(this._constantBaselineValueProvider),this._constantBaselineValueProvider=null),o!=null&&(this._constantBaselineValueProvider=function(){return[o]},s.addPaddingExceptionsProvider(this._constantBaselineValueProvider)))},t.prototype._getResetYFunction=function(){return Ds.Plot._scaledAccessor(this.y0())},t.prototype._coordinateProjectors=function(){return[Ds.Plot._scaledAccessor(this.x()),Ds.Plot._scaledAccessor(this.y()),Ds.Plot._scaledAccessor(this.y0())]},t.prototype._propertyProjectors=function(){var r=e.prototype._propertyProjectors.call(this),n=this._coordinateProjectors(),i=n[0],o=n[1],a=n[2];return r.d=this._constructAreaProjector(i,o,a),r},t.prototype.selections=function(r){var n=this;if(r===void 0&&(r=this.datasets()),this.renderer()==="canvas")return lB.selectAll();var i=e.prototype.selections.call(this,r).nodes(),o=r.map(function(a){return n._lineDrawers.get(a)}).filter(function(a){return a!=null});return o.forEach(function(a){return i.push.apply(i,a.getVisualPrimitives())}),lB.selectAll(i)},t.prototype._constructAreaProjector=function(r,n,i){var o=this,a=this._createDefinedProjector(Ds.Plot._scaledAccessor(this.x()),Ds.Plot._scaledAccessor(this.y()));return function(s,l,c){var u=o._createAreaGenerator(r,n,i,a,c);return u(s)}},t.prototype._createDefinedProjector=function(r,n){return function(i,o,a){var s=r(i,o,a),l=n(i,o,a);return g4.Math.isValidNumber(s)&&g4.Math.isValidNumber(l)}},t.prototype._createAreaGenerator=function(r,n,i,o,a){var s=this._getCurveFactory(),l=lB.area().x(function(c,u){return r(c,u,a)}).y1(function(c,u){return n(c,u,a)}).y0(function(c,u){return i(c,u,a)}).curve(s).defined(function(c,u){return o(c,u,a)});return l},t.prototype._createTopLineGenerator=function(r,n,i,o){var a=this._getCurveFactory(),s=lB.line().x(function(l,c){return r(l,c,o)}).y(function(l,c){return n(l,c,o)}).curve(a).defined(function(l,c){return i(l,c,o)});return s},t._Y0_KEY="y0",t}(GVe.Line);Tat.Area=WVe});var _4=H(Gu=>{"use strict";Object.defineProperty(Gu,"__esModule",{value:!0});var YVe=(de(),Ut(pe)),Pat=(Er(),Ut(Mr)),Aat=_l(),jVe=Lf(),XVe=Bu(),$Ve=B1(),KVe=Uu(),ZVe=iB(),JVe=CS(),Iat=ks(),dKt=vd(),xl=Fe(),kat=If(),mKt=IS(),uB=rs(),QVe=H1();Gu.BarOrientation=kat.makeEnum(["vertical","horizontal"]);Gu.LabelsPosition=kat.makeEnum(["start","middle","end","outside"]);Gu.BarAlignment=kat.makeEnum(["start","middle","end"]);var Lat=function(e){YVe.__extends(t,e);function t(r){r===void 0&&(r="vertical");var n=e.call(this)||this;if(n._labelFormatter=XVe.identity(),n._labelsEnabled=!1,n._labelsPosition=Gu.LabelsPosition.end,n._hideBarsIfAnyAreTooWide=!0,n._barAlignment="middle",n._computeBarPixelThickness=JVe.memoize(tUe),n._fixedBarPixelThickness=!0,n.addClass("bar-plot"),r!=="vertical"&&r!=="horizontal")throw new Error(r+" is not a valid orientation for Plots.Bar");return n._isVertical=r==="vertical",n.animator("baseline",new jVe.Null),n.attr("fill",new Iat.Color().range()[0]),n.attr(t._BAR_THICKNESS_KEY,function(){return n._barPixelThickness()}),n._labelConfig=new xl.Map,n._baselineValueProvider=function(){return[n.baselineValue()]},n}return t.prototype.computeLayout=function(r,n,i){return e.prototype.computeLayout.call(this,r,n,i),this._updateExtents(),this},t.prototype.x=function(r,n){return r==null?e.prototype.x.call(this):(n==null?e.prototype.x.call(this,r):e.prototype.x.call(this,r,n),this._updateThicknessAttr(),this._updateLengthScale(),this)},t.prototype.y=function(r,n){return r==null?e.prototype.y.call(this):(n==null?e.prototype.y.call(this,r):e.prototype.y.call(this,r,n),this._updateLengthScale(),this)},t.prototype.length=function(){return this._isVertical?this.y():this.x()},t.prototype.position=function(){return this._isVertical?this.x():this.y()},t.prototype.barEnd=function(r){if(r==null)return this._propertyBindings.get(t._BAR_END_KEY);var n=this.position(),i=n&&n.scale;return this._bindProperty(t._BAR_END_KEY,r,i),this._updateThicknessAttr(),this._updateLengthScale(),this.render(),this},t.prototype.barAlignment=function(r){return r==null?this._barAlignment:(this._barAlignment=r,this._clearAttrToProjectorCache(),this.render(),this)},t.prototype.orientation=function(){return this._isVertical?"vertical":"horizontal"},t.prototype._createDrawer=function(){return new KVe.ProxyDrawer(function(){return new ZVe.RectangleSVGDrawer(t._BAR_AREA_CLASS)},function(r){return new $Ve.RectangleCanvasDrawer(r)})},t.prototype._setup=function(){e.prototype._setup.call(this),this._baseline=this._renderArea.append("line").classed("baseline",!0)},t.prototype.baselineValue=function(r){if(r==null){if(this._baselineValue!=null)return this._baselineValue;if(!this._projectorsReady())return 0;var n=this.length().scale;return n&&n instanceof Iat.Time?new Date(0):0}return this._baselineValue=r,this._updateLengthScale(),this._clearAttrToProjectorCache(),this.render(),this},t.prototype.addDataset=function(r){return e.prototype.addDataset.call(this,r),this},t.prototype._addDataset=function(r){return e.prototype._addDataset.call(this,r),this},t.prototype.removeDataset=function(r){return e.prototype.removeDataset.call(this,r),this},t.prototype._removeDataset=function(r){return e.prototype._removeDataset.call(this,r),this},t.prototype.datasets=function(r){return r==null?e.prototype.datasets.call(this):(e.prototype.datasets.call(this,r),this)},t.prototype.labelsEnabled=function(r,n){return r==null?this._labelsEnabled:(this._labelsEnabled=r,n!=null&&(this._labelsPosition=n),this._clearAttrToProjectorCache(),this.render(),this)},t.prototype.labelFormatter=function(r){return r==null?this._labelFormatter:(this._labelFormatter=r,this._clearAttrToProjectorCache(),this.render(),this)},t.prototype._createNodesForDataset=function(r){var n=e.prototype._createNodesForDataset.call(this,r),i=this._renderArea.append("g").classed(t._LABEL_AREA_CLASS,!0),o=new Aat.SvgContext(i.node()),a=new Aat.CacheMeasurer(o),s=new Aat.Writer(a,o);return this._labelConfig.set(r,{labelArea:i,measurer:a,writer:s}),n},t.prototype._removeDatasetNodes=function(r){e.prototype._removeDatasetNodes.call(this,r);var n=this._labelConfig.get(r);n!=null&&(n.labelArea.remove(),this._labelConfig.delete(r))},t.prototype.entityNearest=function(r){var n=this,i=function(){var o=n._isVertical?n._getEntityStore().entityNearestX(r):n._getEntityStore().entityNearestY(r);return o===void 0?void 0:n._lightweightPlotEntityToPlotEntity(o)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(i):i()},t.prototype.entitiesAt=function(r){var n=this,i=function(){return n._entitiesIntersecting(r.x,r.y)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(i):i()},t.prototype.entitiesInBounds=function(r){var n=this,i=function(){return e.prototype.entitiesInBounds.call(n,r)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(i):i()},t.prototype.entitiesInXBounds=function(r){var n=this,i=function(){return e.prototype.entitiesInXBounds.call(n,r)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(i):i()},t.prototype.entitiesInYBounds=function(r){var n=this,i=function(){return e.prototype.entitiesInYBounds.call(n,r)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(i):i()},t.prototype._entitiesIntersecting=function(r,n){for(var i=[],o=this._getEntityStore().entities(),a=o.length,s=0;s<a;s++){var l=o[s];xl.DOM.intersectsBBox(r,n,this._entityBounds(l))&&i.push(this._lightweightPlotEntityToPlotEntity(l))}return i},t.prototype._updateLengthScale=function(){if(!!this._projectorsReady()){var r=this.length().scale;r instanceof dKt.QuantitativeScale&&(r.addPaddingExceptionsProvider(this._baselineValueProvider),r.addIncludedValuesProvider(this._baselineValueProvider))}},t.prototype.renderImmediately=function(){var r=this;return this._barPixelThickness(),this._computeBarPixelThickness.doLocked(function(){return e.prototype.renderImmediately.call(r)})},t.prototype._additionalPaint=function(r){var n=this,i=this.length().scale,o=i.scale(this.baselineValue()),a={x1:this._isVertical?0:o,y1:this._isVertical?o:0,x2:this._isVertical?this.width():o,y2:this._isVertical?o:this.height()};this._getAnimator("baseline").animate(this._baseline,a),this.datasets().forEach(function(s){return n._labelConfig.get(s).labelArea.selectAll("g").remove()}),this._labelsEnabled&&xl.Window.setTimeout(function(){return n._drawLabels()},r)},t.prototype.getExtentsForProperty=function(r){var n=this,i=e.prototype.getExtentsForProperty.call(this,r),o;if(r==="x"&&this._isVertical)o=this.x();else if(r==="y"&&!this._isVertical)o=this.y();else return i;if(!(o&&o.scale&&o.scale instanceof dKt.QuantitativeScale))return i;var a=o.scale,s=this._barPixelThickness();return i=i.map(function(l){return Pat.extent([a.invert(n._getPositionAttr(a.scale(l[0]),s)),a.invert(n._getPositionAttr(a.scale(l[0]),s)+s),a.invert(n._getPositionAttr(a.scale(l[1]),s)),a.invert(n._getPositionAttr(a.scale(l[1]),s)+s)])}),i},t.prototype._getPositionAttr=function(r,n){switch(this._isVertical||(r-=n,n*=-1),this._barAlignment){case"start":return r;case"end":return r-n;case"middle":default:return r-n/2}},t.prototype._drawLabels=function(){var r=this,n=this._getDataToDraw(),i=this._getAttrToProjector(),o=this.datasets().some(function(a){return n.get(a).some(function(s,l){return s==null?!1:r._drawLabel(s,l,a,i)})});this._hideBarsIfAnyAreTooWide&&o&&this.datasets().forEach(function(a){return r._labelConfig.get(a).labelArea.selectAll("g").remove()})},t.prototype._drawLabel=function(r,n,i,o){var a=this._labelConfig.get(i),s=a.labelArea,l=a.measurer,c=a.writer,u=this.length().accessor,h=u(r,n,i),f=this.length().scale,p=f!=null?f.scale(h):h,d=f!=null?f.scale(this.baselineValue()):this.baselineValue(),g={x:o.x(r,n,i),y:o.y(r,n,i)},_={width:o.width(r,n,i),height:o.height(r,n,i)},y=this._labelFormatter(h,r,n,i),x=l.measure(y),b=this._shouldShowLabelOnBar(g,_,x),S=this._isVertical?p<=d:p<d,C=this._calculateLabelProperties(g,_,x,b,S),P=C.containerDimensions,k=C.labelContainerOrigin,O=C.labelOrigin,D=C.alignment,B=o.fill(r,n,i),I=this._createLabelContainer(s,k,O,x,b,B),L={xAlign:D.x,yAlign:D.y};c.write(y,P.width,P.height,L,I.node());var R=this._isVertical?_.width<x.width:_.height<x.height;return R},t.prototype._shouldShowLabelOnBar=function(r,n,i){if(this._labelsPosition===Gu.LabelsPosition.outside)return!1;var o=this._isVertical?r.y:r.x,a=this._isVertical?n.height:n.width,s=this._isVertical?this.height():this.width(),l=this._isVertical?i.height:i.width,c=o+a,u=a;return c>s?u=s-o:o<0&&(u=c),l+t._LABEL_MARGIN_INSIDE_BAR<=u},t.prototype._calculateLabelProperties=function(r,n,i,o,a){var s=this,l=this._isVertical?r.y:r.x,c=this._isVertical?n.height:n.width,u=this._isVertical?i.height:i.width,h="center",f=c,p=l,d=l,g=function(_){switch(_){case"topLeft":h=s._isVertical?"top":"left",p+=t._LABEL_MARGIN_INSIDE_BAR,d+=t._LABEL_MARGIN_INSIDE_BAR;return;case"center":d+=(c+u)/2;return;case"bottomRight":h=s._isVertical?"bottom":"right",p-=t._LABEL_MARGIN_INSIDE_BAR,d+=f-t._LABEL_MARGIN_INSIDE_BAR-u;return}};if(o)switch(this._labelsPosition){case Gu.LabelsPosition.start:g(a?"bottomRight":"topLeft");break;case Gu.LabelsPosition.middle:g("center");break;case Gu.LabelsPosition.end:g(a?"topLeft":"bottomRight");break}else a?(h=this._isVertical?"top":"left",f=c+t._LABEL_MARGIN_INSIDE_BAR+u,p-=t._LABEL_MARGIN_INSIDE_BAR+u,d-=t._LABEL_MARGIN_INSIDE_BAR+u):(h=this._isVertical?"bottom":"right",f=c+t._LABEL_MARGIN_INSIDE_BAR+u,d+=c+t._LABEL_MARGIN_INSIDE_BAR);return{containerDimensions:{width:this._isVertical?n.width:f,height:this._isVertical?f:n.height},labelContainerOrigin:{x:this._isVertical?r.x:p,y:this._isVertical?p:r.y},labelOrigin:{x:this._isVertical?r.x+n.width/2-i.width/2:d,y:this._isVertical?d:r.y+n.height/2-i.height/2},alignment:{x:this._isVertical?"center":h,y:this._isVertical?h:"center"}}},t.prototype._createLabelContainer=function(r,n,i,o,a,s){var l=r.append("g").attr("transform","translate("+n.x+", "+n.y+")");if(a){l.classed("on-bar-label",!0);var c=xl.Color.contrast("white",s)*1.6<xl.Color.contrast("black",s);l.classed(c?"dark-label":"light-label",!0)}else l.classed("off-bar-label",!0);return l},t.prototype._generateDrawSteps=function(){var r=[];if(this._animateOnNextRender()){var n=this._getAttrToProjector(),i=this.length().scale,o=i.scale(this.baselineValue()),a=this._isVertical?"y":"x",s=this._isVertical?"height":"width";n[a]=function(){return o},n[s]=function(){return 0},r.push({attrToProjector:n,animator:this._getAnimator(mKt.Animator.RESET)})}return r.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(mKt.Animator.MAIN)}),r},t.prototype._generateAttrToProjector=function(){var r=this,n=e.prototype._generateAttrToProjector.call(this),i=this.length().scale,o=i.scale(this.baselineValue()),a=this._isVertical?"y":"x",s=this._isVertical?"x":"y",l=uB.Plot._scaledAccessor(this.position()),c=uB.Plot._scaledAccessor(this.length()),u=function(d,g,_){return Math.abs(o-c(d,g,_))},h=n[t._BAR_THICKNESS_KEY],f=n.gap,p=f==null?h:function(d,g,_){var y=h(d,g,_);return y<t._BAR_GAPLESS_THRESHOLD_PX?y:y-f(d,g,_)};return n.width=this._isVertical?p:u,n.height=this._isVertical?u:p,n[a]=function(d,g,_){var y=c(d,g,_);return y>o?o:y},n[s]=function(d,g,_){return r._getPositionAttr(l(d,g,_),h(d,g,_))},n},t.prototype._updateThicknessAttr=function(){var r=this,n=this.position(),i=this.barEnd();n!=null&&i!=null?(this._fixedBarPixelThickness=!1,this.attr(t._BAR_THICKNESS_KEY,function(o,a,s){var l=n.accessor(o,a,s),c=i.accessor(o,a,s);return l=n.scale?n.scale.scale(l):l,c=i.scale?i.scale.scale(c):c,Math.abs(c-l)})):(this._fixedBarPixelThickness=!0,this.attr(t._BAR_THICKNESS_KEY,function(){return r._barPixelThickness()}))},t.prototype._barPixelThickness=function(){return this._fixedBarPixelThickness&&this._projectorsReady()?this._computeBarPixelThickness(this.position(),this.datasets(),this._isVertical?this.width():this.height()):0},t.prototype.entities=function(r){if(r===void 0&&(r=this.datasets()),!this._projectorsReady())return[];var n=e.prototype.entities.call(this,r);return n},t.prototype._entityBounds=function(r){var n=r.datum,i=r.index,o=r.dataset;return this._pixelBounds(n,i,o)},t.prototype._pixelBounds=function(r,n,i){var o=this._getAttrToProjector();return{x:o.x(r,n,i),y:o.y(r,n,i),width:o.width(r,n,i),height:o.height(r,n,i)}},t.prototype._pixelPoint=function(r,n,i){var o=this._pixelBounds(r,n,i),a=(this._isVertical?uB.Plot._scaledAccessor(this.y()):uB.Plot._scaledAccessor(this.x()))(r,n,i),s=(this._isVertical?this.y().scale:this.x().scale).scale(this.baselineValue());return this._pixelPointBar(a,s,o)},t.prototype._pixelPointBar=function(r,n,i){var o,a;return this._isVertical?(o=i.x+i.width/2,a=r<=n?i.y:i.y+i.height):(o=r>=n?i.x+i.width:i.x,a=i.y+i.height/2),{x:o,y:a}},t.prototype._uninstallScaleForKey=function(r,n){e.prototype._uninstallScaleForKey.call(this,r,n)},t.prototype._getDataToDraw=function(){var r=this,n=new xl.Map,i=this._getAttrToProjector(),o=this.width(),a=this.height();return this.datasets().forEach(function(s){var l=s.data().map(function(c,u){var h=r._isDatumOnScreen(i,o,a,c,u,s);return h?c:null});n.set(s,l)}),n},t.prototype._isDatumOnScreen=function(r,n,i,o,a,s){var l=r.x(o,a,s),c=r.y(o,a,s),u=r.width(o,a,s),h=r.height(o,a,s),f=xl.Math.isValidNumber(l)&&xl.Math.isValidNumber(c)&&xl.Math.isValidNumber(u)&&xl.Math.isValidNumber(h);return f?xl.Math.boundsIntersects(l,c,u,h,0,0,n,i):!1},t.prototype.invalidateCache=function(){var r=this;e.prototype.invalidateCache.call(this),this.datasets().forEach(function(n){return r._labelConfig.get(n).measurer.reset()})},t._BAR_THICKNESS_RATIO=.95,t._BAR_GAPLESS_THRESHOLD_PX=3,t._SINGLE_BAR_DIMENSION_RATIO=.4,t._BAR_AREA_CLASS="bar-area",t._BAR_END_KEY="barEnd",t._BAR_THICKNESS_KEY="width",t._LABEL_AREA_CLASS="bar-label-text-area",t._LABEL_MARGIN_INSIDE_BAR=10,t}(QVe.XYPlot);Gu.Bar=Lat;function tUe(e,t,r){var n,i=e.scale;if(i instanceof Iat.Category)n=i.rangeBand();else{var o=e.accessor,a=Pat.set(xl.Array.flatten(t.map(function(c){return c.data().map(function(u,h){return o(u,h,c)}).filter(function(u){return u!=null}).map(function(u){return u.valueOf()})}))).values().map(function(c){return+c});a.sort(function(c,u){return c-u});var s=a.map(function(c){return i.scale(c)}),l=Pat.pairs(s);n=xl.Math.min(l,function(c,u){return Math.abs(c[1]-c[0])},r*Lat._SINGLE_BAR_DIMENSION_RATIO),n*=Lat._BAR_THICKNESS_RATIO}return n}});var _Kt=H(Rat=>{"use strict";Object.defineProperty(Rat,"__esModule",{value:!0});var eUe=(de(),Ut(pe)),rUe=ks(),nUe=Fe(),gKt=_4(),iUe=rs(),oUe=function(e){eUe.__extends(t,e);function t(r){r===void 0&&(r="vertical");var n=e.call(this,r)||this;return n._clusterOffsets=new nUe.Map,n}return t.prototype._generateAttrToProjector=function(){var r=this,n=e.prototype._generateAttrToProjector.call(this),i=this._makeInnerScale(),o=function(l,c){return i.rangeBand()};n.width=this._isVertical?o:n.width,n.height=this._isVertical?n.height:o;var a=n.x,s=n.y;return n.x=this._isVertical?function(l,c,u){return a(l,c,u)+r._clusterOffsets.get(u)}:function(l,c,u){return a(l,c,u)},n.y=this._isVertical?function(l,c,u){return s(l,c,u)}:function(l,c,u){return s(l,c,u)+r._clusterOffsets.get(u)},n},t.prototype._updateClusterPosition=function(){var r=this,n=this._makeInnerScale();this.datasets().forEach(function(i,o){return r._clusterOffsets.set(i,n.scale(String(o))-n.rangeBand()/2)})},t.prototype._makeInnerScale=function(){var r=new rUe.Category;r.domain(this.datasets().map(function(i,o){return String(o)}));var n=iUe.Plot._scaledAccessor(this.attr(gKt.Bar._BAR_THICKNESS_KEY));return r.range([0,n(null,0,null)]),r},t.prototype._getDataToDraw=function(){return this._updateClusterPosition(),e.prototype._getDataToDraw.call(this)},t}(gKt.Bar);Rat.ClusteredBar=oUe});var yKt=H(Dat=>{"use strict";Object.defineProperty(Dat,"__esModule",{value:!0});var aUe=(de(),Ut(pe)),y4=(Er(),Ut(Mr)),Nat=_l(),sUe=Lf(),lUe=Bu(),cUe=ks(),V1=Fe(),uUe=pat(),hUe=mat(),fUe=Uu(),pUe=CF(),Md=rs(),dUe=function(e){aUe.__extends(t,e);function t(){var r=e.call(this)||this;return r._startAngle=0,r._endAngle=2*Math.PI,r._labelFormatter=lUe.identity(),r._labelsEnabled=!1,r.innerRadius(0),r.outerRadius(function(){var n=r._pieCenter();return Math.min(Math.max(r.width()-n.x,n.x),Math.max(r.height()-n.y,n.y))}),r.addClass("pie-plot"),r.attr("fill",function(n,i){return String(i)},new cUe.Color),r._strokeDrawers=new V1.Map,r}return t.prototype._setup=function(){var r=this;e.prototype._setup.call(this),this._strokeDrawers.forEach(function(n){return n.attachTo(r._renderArea)})},t.prototype.computeLayout=function(r,n,i){e.prototype.computeLayout.call(this,r,n,i);var o=this._pieCenter();this._renderArea.attr("transform","translate("+o.x+","+o.y+")");var a=Math.min(Math.max(this.width()-o.x,o.x),Math.max(this.height()-o.y,o.y));return this.innerRadius().scale!=null&&this.innerRadius().scale.range([0,a]),this.outerRadius().scale!=null&&this.outerRadius().scale.range([0,a]),this},t.prototype.addDataset=function(r){return e.prototype.addDataset.call(this,r),this},t.prototype._addDataset=function(r){if(this.datasets().length===1)return V1.Window.warn("Only one dataset is supported in Pie plots"),this;this._updatePieAngles(),e.prototype._addDataset.call(this,r);var n=new hUe.ArcOutlineSVGDrawer;return this._isSetup&&n.attachTo(this._renderArea),this._strokeDrawers.set(r,n),this},t.prototype.removeDataset=function(r){return e.prototype.removeDataset.call(this,r),this},t.prototype._removeDatasetNodes=function(r){e.prototype._removeDatasetNodes.call(this,r),this._strokeDrawers.get(r).remove()},t.prototype._removeDataset=function(r){return e.prototype._removeDataset.call(this,r),this._strokeDrawers.delete(r),this._startAngles=[],this._endAngles=[],this},t.prototype.selections=function(r){var n=this;r===void 0&&(r=this.datasets());var i=e.prototype.selections.call(this,r).nodes();return r.forEach(function(o){var a=n._strokeDrawers.get(o);a!=null&&i.push.apply(i,a.getVisualPrimitives())}),y4.selectAll(i)},t.prototype._onDatasetUpdate=function(){e.prototype._onDatasetUpdate.call(this),this._updatePieAngles(),this.render()},t.prototype._createDrawer=function(){return new fUe.ProxyDrawer(function(){return new uUe.ArcSVGDrawer},function(){return pUe.warn("canvas renderer is not supported on Pie Plot!"),null})},t.prototype.entities=function(r){var n=this;r===void 0&&(r=this.datasets());var i=e.prototype.entities.call(this,r);return i.map(function(o){o.position.x+=n.width()/2,o.position.y+=n.height()/2;var a=y4.select(n._strokeDrawers.get(o.dataset).getVisualPrimitiveAtIndex(o.index)),s=o;return s.strokeSelection=a,s})},t.prototype.sectorValue=function(r,n){return r==null?this._propertyBindings.get(t._SECTOR_VALUE_KEY):(this._bindProperty(t._SECTOR_VALUE_KEY,r,n),this._updatePieAngles(),this.render(),this)},t.prototype.innerRadius=function(r,n){return r==null?this._propertyBindings.get(t._INNER_RADIUS_KEY):(this._bindProperty(t._INNER_RADIUS_KEY,r,n),this.render(),this)},t.prototype.outerRadius=function(r,n){return r==null?this._propertyBindings.get(t._OUTER_RADIUS_KEY):(this._bindProperty(t._OUTER_RADIUS_KEY,r,n),this.render(),this)},t.prototype.startAngle=function(r){return r==null?this._startAngle:(this._startAngle=r,this._updatePieAngles(),this.render(),this)},t.prototype.endAngle=function(r){return r==null?this._endAngle:(this._endAngle=r,this._updatePieAngles(),this.render(),this)},t.prototype.labelsEnabled=function(r){return r==null?this._labelsEnabled:(this._labelsEnabled=r,this.render(),this)},t.prototype.labelFormatter=function(r){return r==null?this._labelFormatter:(this._labelFormatter=r,this.render(),this)},t.prototype.entitiesAt=function(r){var n={x:this.width()/2,y:this.height()/2},i={x:r.x-n.x,y:r.y-n.y},o=this._sliceIndexForPoint(i);return o==null?[]:[this.entities()[o]]},t.prototype._propertyProjectors=function(){var r=this,n=e.prototype._propertyProjectors.call(this),i=Md.Plot._scaledAccessor(this.innerRadius()),o=Md.Plot._scaledAccessor(this.outerRadius());return n.d=function(a,s,l){return y4.arc().innerRadius(i(a,s,l)).outerRadius(o(a,s,l)).startAngle(r._startAngles[s]).endAngle(r._endAngles[s])(a,s)},n},t.prototype._updatePieAngles=function(){if(this.sectorValue()!=null&&this.datasets().length!==0){var r=Md.Plot._scaledAccessor(this.sectorValue()),n=this.datasets()[0],i=this._getDataToDraw().get(n),o=y4.pie().sort(null).startAngle(this._startAngle).endAngle(this._endAngle).value(function(a,s){return r(a,s,n)})(i);this._startAngles=o.map(function(a){return a.startAngle}),this._endAngles=o.map(function(a){return a.endAngle})}},t.prototype._pieCenter=function(){var r=this._startAngle<this._endAngle?this._startAngle:this._endAngle,n=this._startAngle<this._endAngle?this._endAngle:this._startAngle,i=Math.sin(r),o=Math.cos(r),a=Math.sin(n),s=Math.cos(n),l,c,u,h;return i>=0&&a>=0?o>=0&&s>=0?(l=o,c=0,h=0,u=a):o<0&&s<0?(l=0,c=-s,h=0,u=i):o>=0&&s<0?(l=o,c=-s,h=0,u=i):o<0&&s>=0&&(l=1,c=1,h=1,u=Math.max(i,a)):i>=0&&a<0?o>=0&&s>=0?(l=Math.max(o,s),c=1,h=1,u=1):o<0&&s<0?(l=0,c=1,h=-a,u=i):o>=0&&s<0?(l=o,c=1,h=-a,u=1):o<0&&s>=0&&(l=s,c=1,h=1,u=i):i<0&&a>=0?o>=0&&s>=0?(l=1,c=0,h=-i,u=a):o<0&&s<0?(l=1,c=Math.max(-o,-s),h=1,u=1):o>=0&&s<0?(l=1,c=-s,h=-i,u=1):o<0&&s>=0&&(l=1,c=-o,h=1,u=a):i<0&&a<0&&(o>=0&&s>=0?(l=s,c=0,h=-i,u=0):o<0&&s<0?(l=0,c=-o,h=-a,u=0):o>=0&&s<0?(l=1,c=1,h=Math.max(o,-s),u=1):o<0&&s>=0&&(l=s,c=-o,h=1,u=0)),{x:h+u==0?0:h/(h+u)*this.width(),y:l+c==0?0:l/(l+c)*this.height()}},t.prototype._getDataToDraw=function(){var r=e.prototype._getDataToDraw.call(this);if(this.datasets().length===0)return r;var n=Md.Plot._scaledAccessor(this.sectorValue()),i=this.datasets()[0],o=r.get(i),a=o.filter(function(s,l){return t._isValidData(n(s,l,i))});return r.set(i,a),r},t._isValidData=function(r){return V1.Math.isValidNumber(r)&&r>=0},t.prototype._pixelPoint=function(r,n,i){var o=Md.Plot._scaledAccessor(this.sectorValue());if(!t._isValidData(o(r,n,i)))return{x:NaN,y:NaN};var a=Md.Plot._scaledAccessor(this.innerRadius())(r,n,i),s=Md.Plot._scaledAccessor(this.outerRadius())(r,n,i),l=(a+s)/2,c=y4.pie().sort(null).value(function(p,d){var g=o(p,d,i);return t._isValidData(g)?g:0}).startAngle(this._startAngle).endAngle(this._endAngle)(i.data()),u=c[n].startAngle,h=c[n].endAngle,f=(u+h)/2;return{x:l*Math.sin(f),y:-l*Math.cos(f)}},t.prototype._additionalPaint=function(r){var n=this;this._renderArea.select(".label-area").remove(),this._labelsEnabled&&V1.Window.setTimeout(function(){return n._drawLabels()},r);var i=this._generateStrokeDrawSteps(),o=this._getDataToDraw();this.datasets().forEach(function(a){var s=Md.Plot.applyDrawSteps(i,a);n._strokeDrawers.get(a).draw(o.get(a),s)})},t.prototype._generateStrokeDrawSteps=function(){var r=this._getAttrToProjector();return[{attrToProjector:r,animator:new sUe.Null}]},t.prototype._sliceIndexForPoint=function(r){var n=Math.sqrt(Math.pow(r.x,2)+Math.pow(r.y,2)),i=Math.acos(-r.y/n);r.x<0&&(i=Math.PI*2-i);for(var o,a=0;a<this._startAngles.length;a++)if(this._startAngles[a]<i&&this._endAngles[a]>i){o=a;break}if(o!==void 0){var s=this.datasets()[0],l=s.data()[o],c=this.innerRadius().accessor(l,o,s),u=this.outerRadius().accessor(l,o,s);if(n>c&&n<u)return o}return null},t.prototype._drawLabels=function(){for(var r=this,n=this._getAttrToProjector(),i=this._renderArea.append("g").classed("label-area",!0),o=new Nat.SvgContext(i.node()),a=new Nat.CacheMeasurer(o),s=new Nat.Writer(a,o),l=this.datasets()[0],c=this._getDataToDraw().get(l),u=c.length,h=function(d){var g=c[d],_=f.sectorValue().accessor(g,d,l);if(!V1.Math.isValidNumber(_))return"continue";_=f._labelFormatter(_,g,d,l);var y=a.measure(_),x=(f._endAngles[d]+f._startAngles[d])/2,b=f.outerRadius().accessor(g,d,l);f.outerRadius().scale&&(b=f.outerRadius().scale.scale(b));var S=f.innerRadius().accessor(g,d,l);f.innerRadius().scale&&(S=f.innerRadius().scale.scale(S));var C=(b+S)/2,P=Math.sin(x)*C-y.width/2,k=-Math.cos(x)*C-y.height/2,O=[{x:P,y:k},{x:P,y:k+y.height},{x:P+y.width,y:k},{x:P+y.width,y:k+y.height}],D=O.every(function(z){return Math.abs(z.x)<=r.width()/2&&Math.abs(z.y)<=r.height()/2});if(D){var B=O.map(function(z){return r._sliceIndexForPoint(z)});D=B.every(function(z){return z===d})}var I=n.fill(g,d,l),L=V1.Color.contrast("white",I)*1.6<V1.Color.contrast("black",I),R=i.append("g").attr("transform","translate("+P+","+k+")"),F=L?"dark-label":"light-label";R.classed(F,!0),R.style("visibility",D?"inherit":"hidden"),s.write(_,y.width,y.height,{xAlign:"center",yAlign:"center"},R.node())},f=this,p=0;p<u;p++)h(p)},t._INNER_RADIUS_KEY="inner-radius",t._OUTER_RADIUS_KEY="outer-radius",t._SECTOR_VALUE_KEY="sector-value",t}(Md.Plot);Dat.Pie=dUe});var vKt=H(zat=>{"use strict";Object.defineProperty(zat,"__esModule",{value:!0});var mUe=(de(),Ut(pe)),gUe=(Er(),Ut(Mr)),Oat=_l(),_Ue=Lf(),yUe=B1(),vUe=Uu(),xUe=iB(),hB=ks(),Oc=Fe(),fB=rs(),bUe=H1(),wUe=function(e){mUe.__extends(t,e);function t(){var r=e.call(this)||this;return r._labelsEnabled=!1,r._label=null,r.animator("rectangles",new _Ue.Null),r.addClass("rectangle-plot"),r.attr("fill",new hB.Color().range()[0]),r}return t.prototype._createDrawer=function(){return new vUe.ProxyDrawer(function(){return new xUe.RectangleSVGDrawer},function(r){return new yUe.RectangleCanvasDrawer(r)})},t.prototype._generateAttrToProjector=function(){var r=this,n=e.prototype._generateAttrToProjector.call(this),i=fB.Plot._scaledAccessor(this.x()),o=n[t._X2_KEY],a=fB.Plot._scaledAccessor(this.y()),s=n[t._Y2_KEY],l=this.x().scale,c=this.y().scale;return o!=null?(n.width=function(u,h,f){return Math.abs(o(u,h,f)-i(u,h,f))},n.x=function(u,h,f){return Math.min(o(u,h,f),i(u,h,f))}):(n.width=function(u,h,f){return r._rectangleWidth(l)},n.x=function(u,h,f){return i(u,h,f)-.5*n.width(u,h,f)}),s!=null?(n.height=function(u,h,f){return Math.abs(s(u,h,f)-a(u,h,f))},n.y=function(u,h,f){return Math.max(s(u,h,f),a(u,h,f))-n.height(u,h,f)}):(n.height=function(u,h,f){return r._rectangleWidth(c)},n.y=function(u,h,f){return a(u,h,f)-.5*n.height(u,h,f)}),delete n[t._X2_KEY],delete n[t._Y2_KEY],n},t.prototype._generateDrawSteps=function(){return[{attrToProjector:this._getAttrToProjector(),animator:this._getAnimator("rectangles")}]},t.prototype._filterForProperty=function(r){return r==="x2"?e.prototype._filterForProperty.call(this,"x"):r==="y2"?e.prototype._filterForProperty.call(this,"y"):e.prototype._filterForProperty.call(this,r)},t.prototype.x=function(r,n,i){if(r==null)return e.prototype.x.call(this);if(n==null?e.prototype.x.call(this,r):e.prototype.x.call(this,r,n,i),n!=null){var o=this.x2(),a=o&&o.accessor;a!=null&&this._bindProperty(t._X2_KEY,a,n,o.postScale)}return n instanceof hB.Category&&n.innerPadding(0).outerPadding(0),this},t.prototype.x2=function(r,n){if(r==null)return this._propertyBindings.get(t._X2_KEY);var i=this.x(),o=i&&i.scale;return this._bindProperty(t._X2_KEY,r,o,n),this.render(),this},t.prototype.y=function(r,n,i){if(r==null)return e.prototype.y.call(this);if(n==null?e.prototype.y.call(this,r):e.prototype.y.call(this,r,n,i),n!=null){var o=this.y2(),a=o&&o.accessor;a!=null&&this._bindProperty(t._Y2_KEY,a,n,o.postScale)}return n instanceof hB.Category&&n.innerPadding(0).outerPadding(0),this},t.prototype.y2=function(r,n){if(r==null)return this._propertyBindings.get(t._Y2_KEY);var i=this.y(),o=i&&i.scale;return this._bindProperty(t._Y2_KEY,r,o,n),this.render(),this},t.prototype.entitiesAt=function(r){var n=this._getAttrToProjector();return this.entities().filter(function(i){var o=i.datum,a=i.index,s=i.dataset,l=n.x(o,a,s),c=n.y(o,a,s),u=n.width(o,a,s),h=n.height(o,a,s);return l<=r.x&&r.x<=l+u&&c<=r.y&&r.y<=c+h})},t.prototype._entityBounds=function(r){var n=r.datum,i=r.index,o=r.dataset;return this._entityBBox(n,i,o,this._getAttrToProjector())},t.prototype._entityBBox=function(r,n,i,o){return{x:o.x(r,n,i),y:o.y(r,n,i),width:o.width(r,n,i),height:o.height(r,n,i)}},t.prototype.label=function(r){return r==null?this._label:(this._label=r,this.render(),this)},t.prototype.labelsEnabled=function(r){return r==null?this._labelsEnabled:(this._labelsEnabled=r,this.render(),this)},t.prototype._propertyProjectors=function(){var r=e.prototype._propertyProjectors.call(this);return this.x2()!=null&&(r.x2=fB.Plot._scaledAccessor(this.x2())),this.y2()!=null&&(r.y2=fB.Plot._scaledAccessor(this.y2())),r},t.prototype._pixelPoint=function(r,n,i){var o=this._getAttrToProjector(),a=o.x(r,n,i),s=o.y(r,n,i),l=o.width(r,n,i),c=o.height(r,n,i),u=a+l/2,h=s+c/2;return{x:u,y:h}},t.prototype._rectangleWidth=function(r){if(r instanceof hB.Category)return r.rangeBand();var n=r===this.x().scale?this.x().accessor:this.y().accessor,i=gUe.set(Oc.Array.flatten(this.datasets().map(function(c){return c.data().map(function(u,h){return n(u,h,c).valueOf()})}))).values().map(function(c){return+c}),o=Oc.Math.min(i,0),a=Oc.Math.max(i,0),s=r.scale(o),l=r.scale(a);return(l-s)/Math.abs(a-o)},t.prototype._getDataToDraw=function(){var r=new Oc.Map,n=this._getAttrToProjector();return this.datasets().forEach(function(i){var o=i.data().map(function(a,s){var l=Oc.Math.isValidNumber(n.x(a,s,i))&&Oc.Math.isValidNumber(n.y(a,s,i))&&Oc.Math.isValidNumber(n.width(a,s,i))&&Oc.Math.isValidNumber(n.height(a,s,i));return l?a:null});r.set(i,o)}),r},t.prototype._additionalPaint=function(r){var n=this;this._renderArea.selectAll(".label-area").remove(),this._labelsEnabled&&this.label()!=null&&Oc.Window.setTimeout(function(){return n._drawLabels()},r)},t.prototype._drawLabels=function(){var r=this,n=this._getDataToDraw();this.datasets().forEach(function(i,o){return r._drawLabel(n,i,o)})},t.prototype._drawLabel=function(r,n,i){for(var o=this._getAttrToProjector(),a=this._renderArea.append("g").classed("label-area",!0),s=new Oat.SvgContext(a.node()),l=new Oat.CacheMeasurer(s),c=new Oat.Writer(l,s),u=this.x().scale.range(),h=this.y().scale.range(),f=Math.min.apply(null,u),p=Math.max.apply(null,u),d=Math.min.apply(null,h),g=Math.max.apply(null,h),_=r.get(n),y=_.length,x=0;x<y;x++){var b=_[x];if(b!=null){var S=""+this.label()(b,x,n),C=l.measure(S),P=o.x(b,x,n),k=o.y(b,x,n),O=o.width(b,x,n),D=o.height(b,x,n);if(C.height<=D&&C.width<=O){var B=(O-C.width)/2,I=(D-C.height)/2;P+=B,k+=I;var L={min:P,max:P+C.width},R={min:k,max:k+C.height};if(L.min<f||L.max>p||R.min<d||R.max>g||this._overlayLabel(L,R,x,i,r))continue;var F=o.fill(b,x,n),z=Oc.Color.contrast("white",F)*1.6<Oc.Color.contrast("black",F),U=a.append("g").attr("transform","translate("+P+","+k+")"),W=z?"dark-label":"light-label";U.classed(W,!0),c.write(S,C.width,C.height,{xAlign:"center",yAlign:"center"},U.node())}}}},t.prototype._overlayLabel=function(r,n,i,o,a){for(var s=this._getAttrToProjector(),l=this.datasets(),c=o;c<l.length;c++)for(var u=l[c],h=a.get(u),f=h.length,p=c===o?i+1:0;p<f;p++)if(Oc.DOM.intersectsBBox(r,n,this._entityBBox(h[p],p,u,s)))return!0;return!1},t._X2_KEY="x2",t._Y2_KEY="y2",t}(bUe.XYPlot);zat.Rectangle=wUe});var bKt=H(Vat=>{"use strict";Object.defineProperty(Vat,"__esModule",{value:!0});var SUe=(de(),Ut(pe)),Fat=_l(),MUe=Bu(),EUe=jF(),TUe=Uu(),xKt=xat(),CUe=Lf(),AUe=B1(),PUe=ks(),Bat=Fe(),Hat=IS(),bl=rs(),IUe=H1(),LUe=function(e){SUe.__extends(t,e);function t(){var r=e.call(this)||this;r._labelFormatter=MUe.identity(),r._labelsEnabled=!1,r.addClass("scatter-plot");var n=new CUe.Easing;n.startDelay(5),n.stepDuration(250),n.maxTotalDuration(bl.Plot._ANIMATION_MAX_DURATION),r.animator(Hat.Animator.MAIN,n),r.attr("opacity",.6),r.attr("fill",new PUe.Color().range()[0]),r.size(6);var i=EUe.circle();return r.symbol(function(){return i}),r._labelConfig=new Bat.Map,r}return t.prototype._buildLightweightPlotEntities=function(r){var n=this,i=e.prototype._buildLightweightPlotEntities.call(this,r);return i.map(function(o){var a=bl.Plot._scaledAccessor(n.size())(o.datum,o.index,o.dataset);return o.diameter=a,o})},t.prototype._createDrawer=function(r){var n=this;return new TUe.ProxyDrawer(function(){return new xKt.SymbolSVGDrawer},function(i){return new AUe.CanvasDrawer(i,xKt.makeSymbolCanvasDrawStep(r,function(){return bl.Plot._scaledAccessor(n.symbol())},function(){return bl.Plot._scaledAccessor(n.size())}))})},t.prototype.size=function(r,n){return r==null?this._propertyBindings.get(t._SIZE_KEY):(this._bindProperty(t._SIZE_KEY,r,n),this.render(),this)},t.prototype.symbol=function(r){return r==null?this._propertyBindings.get(t._SYMBOL_KEY):(this._propertyBindings.set(t._SYMBOL_KEY,{accessor:r}),this.render(),this)},t.prototype._generateDrawSteps=function(){var r=[];if(this._animateOnNextRender()){var n=this._getAttrToProjector(),i=bl.Plot._scaledAccessor(this.symbol());n.d=function(o,a,s){return i(o,a,s)(0)(null)},r.push({attrToProjector:n,animator:this._getAnimator(Hat.Animator.RESET)})}return r.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(Hat.Animator.MAIN)}),r},t.prototype._propertyProjectors=function(){var r=e.prototype._propertyProjectors.call(this),n=bl.Plot._scaledAccessor(this.x()),i=bl.Plot._scaledAccessor(this.y());return r.x=n,r.y=i,r.transform=function(o,a,s){return"translate("+n(o,a,s)+","+i(o,a,s)+")"},r.d=this._constructSymbolGenerator(),r},t.prototype._constructSymbolGenerator=function(){var r=bl.Plot._scaledAccessor(this.symbol()),n=bl.Plot._scaledAccessor(this.size());return function(i,o,a){return r(i,o,a)(n(i,o,a))(null)}},t.prototype._entityBounds=function(r){return{x:r.position.x-r.diameter/2,y:r.position.y-r.diameter/2,width:r.diameter,height:r.diameter}},t.prototype._entityVisibleOnPlot=function(r,n){var i={min:n.topLeft.x,max:n.bottomRight.x},o={min:n.topLeft.y,max:n.bottomRight.y},a=this._entityBounds(r);return Bat.DOM.intersectsBBox(i,o,a)},t.prototype.entitiesAt=function(r){var n=bl.Plot._scaledAccessor(this.x()),i=bl.Plot._scaledAccessor(this.y()),o=bl.Plot._scaledAccessor(this.size());return this.entities().filter(function(a){var s=a.datum,l=a.index,c=a.dataset,u=n(s,l,c),h=i(s,l,c),f=o(s,l,c);return u-f/2<=r.x&&r.x<=u+f/2&&h-f/2<=r.y&&r.y<=h+f/2})},t.prototype.labelsEnabled=function(r){return r==null?this._labelsEnabled:(this._labelsEnabled=r,this._clearAttrToProjectorCache(),this.render(),this)},t.prototype._createNodesForDataset=function(r){var n=e.prototype._createNodesForDataset.call(this,r),i=this._renderArea.append("g").classed(t._LABEL_AREA_CLASS,!0),o=new Fat.SvgContext(i.node()),a=new Fat.CacheMeasurer(o),s=new Fat.Writer(a,o);return this._labelConfig.set(r,{labelArea:i,measurer:a,writer:s}),n},t.prototype._removeDatasetNodes=function(r){e.prototype._removeDatasetNodes.call(this,r);var n=this._labelConfig.get(r);n!=null&&(n.labelArea.remove(),this._labelConfig.delete(r))},t.prototype._additionalPaint=function(r){var n=this;this.datasets().forEach(function(i){return n._labelConfig.get(i).labelArea.selectAll("g").remove()}),this._labelsEnabled&&Bat.Window.setTimeout(function(){return n._drawLabels()},r)},t.prototype._drawLabels=function(){var r=this,n=this._getDataToDraw(),i=this._getAttrToProjector();this.datasets().forEach(function(o){for(var a=n.get(o),s=a.length,l=0;l<s;l++){var c=a[l];c!=null&&r._drawLabel(c,l,o,i)}})},t.prototype._drawLabel=function(r,n,i,o){if(r.label!=null){var a=this._labelConfig.get(i),s=a.labelArea,l=a.measurer,c=a.writer,u={x:o.x(r,n,i),y:o.y(r,n,i)},h=bl.Plot._scaledAccessor(this.size()),f=h(r,n,i),p=this._labelFormatter(r.label,r,n,i),d=l.measure(p),g=this._calculateLabelProperties(u,f,d),_=g.containerDimensions,y=g.labelContainerOrigin,x=g.labelOrigin,b=g.alignment,S=this._createLabelContainer(s,y,x,d),C={xAlign:b.x,yAlign:b.y};c.write(p,_.width,_.height,C,S.node())}},t.prototype._calculateLabelProperties=function(r,n,i){var o=n<i.height?n/2+t._LABEL_MARGIN_FROM_BUBBLE:0;return{containerDimensions:{width:i.width,height:i.height},labelContainerOrigin:{x:r.x-i.width/2,y:r.y-i.height/2+o},labelOrigin:{x:r.x,y:r.y},alignment:{x:"center",y:"center"}}},t.prototype._createLabelContainer=function(r,n,i,o){var a=r.append("g").attr("transform","translate("+n.x+", "+n.y+")");return a.classed("on-bar-label",!0),a},t._SIZE_KEY="size",t._SYMBOL_KEY="symbol",t._LABEL_AREA_CLASS="scatter-label-text-area",t._LABEL_MARGIN_FROM_BUBBLE=15,t}(IUe.XYPlot);Vat.Scatter=LUe});var wKt=H(Uat=>{"use strict";Object.defineProperty(Uat,"__esModule",{value:!0});var kUe=(de(),Ut(pe)),RUe=Lf(),NUe=Uu(),DUe=yat(),OUe=ks(),zUe=CF(),LS=rs(),FUe=H1(),BUe=function(e){kUe.__extends(t,e);function t(){var r=e.call(this)||this;return r.addClass("segment-plot"),r.attr("stroke",new OUe.Color().range()[0]),r.attr("stroke-width","2px"),r}return t.prototype._createDrawer=function(){return new NUe.ProxyDrawer(function(){return new DUe.SegmentSVGDrawer},function(){return zUe.warn("canvas renderer is not supported on Segment Plot!"),null})},t.prototype._generateDrawSteps=function(){return[{attrToProjector:this._getAttrToProjector(),animator:new RUe.Null}]},t.prototype._filterForProperty=function(r){return r==="x2"?e.prototype._filterForProperty.call(this,"x"):r==="y2"?e.prototype._filterForProperty.call(this,"y"):e.prototype._filterForProperty.call(this,r)},t.prototype.x=function(r,n){if(r==null)return e.prototype.x.call(this);if(n==null)e.prototype.x.call(this,r);else{e.prototype.x.call(this,r,n);var i=this.x2(),o=i&&i.accessor;o!=null&&this._bindProperty(t._X2_KEY,o,n)}return this},t.prototype.x2=function(r){if(r==null)return this._propertyBindings.get(t._X2_KEY);var n=this.x(),i=n&&n.scale;return this._bindProperty(t._X2_KEY,r,i),this.render(),this},t.prototype.y=function(r,n){if(r==null)return e.prototype.y.call(this);if(n==null)e.prototype.y.call(this,r);else{e.prototype.y.call(this,r,n);var i=this.y2(),o=i&&i.accessor;o!=null&&this._bindProperty(t._Y2_KEY,o,n)}return this},t.prototype.y2=function(r){if(r==null)return this._propertyBindings.get(t._Y2_KEY);var n=this.y(),i=n&&n.scale;return this._bindProperty(t._Y2_KEY,r,i),this.render(),this},t.prototype._propertyProjectors=function(){var r=e.prototype._propertyProjectors.call(this);return r.x1=LS.Plot._scaledAccessor(this.x()),r.x2=this.x2()==null?LS.Plot._scaledAccessor(this.x()):LS.Plot._scaledAccessor(this.x2()),r.y1=LS.Plot._scaledAccessor(this.y()),r.y2=this.y2()==null?LS.Plot._scaledAccessor(this.y()):LS.Plot._scaledAccessor(this.y2()),r},t.prototype.entitiesAt=function(r){var n=this.entityNearest(r);return n!=null?[n]:[]},t.prototype.entitiesIn=function(r,n){var i,o;if(n==null){var a=r;i={min:a.topLeft.x,max:a.bottomRight.x},o={min:a.topLeft.y,max:a.bottomRight.y}}else i=r,o=n;return this._entitiesIntersecting(i,o)},t.prototype._entitiesIntersecting=function(r,n){for(var i=[],o=this._getAttrToProjector(),a=this.entities(),s=a.length,l=0;l<s;l++){var c=a[l];this._lineIntersectsBox(c,r,n,o)&&i.push(c)}return i},t.prototype._lineIntersectsBox=function(r,n,i,o){var a=this,s=o.x1(r.datum,r.index,r.dataset),l=o.x2(r.datum,r.index,r.dataset),c=o.y1(r.datum,r.index,r.dataset),u=o.y2(r.datum,r.index,r.dataset);if(n.min<=s&&s<=n.max&&i.min<=c&&c<=i.max||n.min<=l&&l<=n.max&&i.min<=u&&u<=i.max)return!0;var h={x:s,y:c},f={x:l,y:u},p=[{x:n.min,y:i.min},{x:n.min,y:i.max},{x:n.max,y:i.max},{x:n.max,y:i.min}],d=p.filter(function(g,_){return _!==0?a._lineIntersectsSegment(h,f,g,p[_-1])&&a._lineIntersectsSegment(g,p[_-1],h,f):!1});return d.length>0},t.prototype._lineIntersectsSegment=function(r,n,i,o){var a=function(s,l,c){return(l.x-s.x)*(c.y-l.y)-(l.y-s.y)*(c.x-l.x)};return a(r,n,i)*a(r,n,o)<0},t._X2_KEY="x2",t._Y2_KEY="y2",t}(FUe.XYPlot);Uat.Segment=BUe});var EKt=H(qat=>{"use strict";Object.defineProperty(qat,"__esModule",{value:!0});var HUe=(de(),Ut(pe)),SKt=(Er(),Ut(Mr)),VUe=Lf(),MKt=CS(),t0=Fe(),UUe=Cat(),qUe=rs(),GUe=function(e){HUe.__extends(t,e);function t(){var r=e.call(this)||this;return r._stackingResult=MKt.memThunk(function(){return r.datasets()},function(){return r.x().accessor},function(){return r.y().accessor},function(){return r._stackingOrder},function(n,i,o,a){return t0.Stacking.stack(n,i,o,a)}),r._stackedExtent=MKt.memThunk(r._stackingResult,function(){return r.x().accessor},function(){return r._filterForProperty("y")},function(n,i,o){return t0.Stacking.stackedExtent(n,i,o)}),r._baselineValue=0,r._stackingOrder="bottomup",r.addClass("stacked-area-plot"),r._baselineValueProvider=function(){return[r._baselineValue]},r.croppedRenderingEnabled(!1),r}return t.prototype.croppedRenderingEnabled=function(r){return r==null?e.prototype.croppedRenderingEnabled.call(this):r?(t0.Window.warn("Warning: Stacked Area Plot does not support cropped rendering."),this):e.prototype.croppedRenderingEnabled.call(this,r)},t.prototype._getAnimator=function(r){return new VUe.Null},t.prototype._setup=function(){e.prototype._setup.call(this),this._baseline=this._renderArea.append("line").classed("baseline",!0)},t.prototype.x=function(r,n){return r==null?e.prototype.x.call(this):(n==null?e.prototype.x.call(this,r):e.prototype.x.call(this,r,n),this._checkSameDomain(),this)},t.prototype.y=function(r,n){return r==null?e.prototype.y.call(this):(n==null?e.prototype.y.call(this,r):e.prototype.y.call(this,r,n),this._checkSameDomain(),this)},t.prototype.yOffset=function(r,n){var i=this._stackingResult();if(i!=null){var o=i.get(r);if(o!=null){var a=o.get(String(n));if(a!=null)return a.offset}}},t.prototype.stackingOrder=function(r){return r==null?this._stackingOrder:(this._stackingOrder=r,this._onDatasetUpdate(),this)},t.prototype.downsamplingEnabled=function(r){return r==null?e.prototype.downsamplingEnabled.call(this):(t0.Window.warn("Warning: Stacked Area Plot does not support downsampling"),this)},t.prototype._additionalPaint=function(){var r=this.y().scale.scale(this._baselineValue),n={x1:0,y1:r,x2:this.width(),y2:r};this._getAnimator("baseline").animate(this._baseline,n)},t.prototype._updateYScale=function(){var r=this.y(),n=r&&r.scale;n!=null&&(n.addPaddingExceptionsProvider(this._baselineValueProvider),n.addIncludedValuesProvider(this._baselineValueProvider))},t.prototype._onDatasetUpdate=function(){return this._checkSameDomain(),e.prototype._onDatasetUpdate.call(this),this},t.prototype.getExtentsForProperty=function(r){var n="y";return r===n?[this._stackedExtent()]:e.prototype.getExtentsForProperty.call(this,r)},t.prototype._checkSameDomain=function(){if(!!this._projectorsReady()){var r=this.datasets(),n=this.x().accessor,i=r.map(function(a){return SKt.set(a.data().map(function(s,l){return t0.Stacking.normalizeKey(n(s,l,a))})).values()}),o=t._domainKeys(r,n);i.some(function(a){return a.length!==o.length})&&t0.Window.warn("the domains across the datasets are not the same. Plot may produce unintended behavior.")}},t._domainKeys=function(r,n){var i=SKt.set();return r.forEach(function(o){for(var a=o.data(),s=a.length,l=0;l<s;l++){var c=a[l];i.add(n(c,l,o))}}),i.values()},t.prototype._coordinateProjectors=function(){var r=this,n=qUe.Plot._scaledAccessor(this.x()),i=this.y().accessor,o=this.x().accessor,a=function(u,h,f){return t0.Stacking.normalizeKey(o(u,h,f))},s=this._stackingResult(),l=function(u,h,f){var p=+i(u,h,f),d=s.get(f).get(a(u,h,f)).offset;return r.y().scale.scale(p+d)},c=function(u,h,f){var p=s.get(f).get(a(u,h,f)).offset;return r.y().scale.scale(p)};return[n,l,c]},t.prototype._propertyProjectors=function(){var r=e.prototype._propertyProjectors.call(this),n=this._coordinateProjectors(),i=n[0],o=n[1],a=n[2];return r.d=this._constructAreaProjector(i,o,a),r},t.prototype._pixelPoint=function(r,n,i){var o=e.prototype._pixelPoint.call(this,r,n,i),a=this.x().accessor(r,n,i),s=this.y().accessor(r,n,i),l=this.y().scale.scale(+s+this._stackingResult().get(i).get(t0.Stacking.normalizeKey(a)).offset);return{x:o.x,y:l}},t}(UUe.Area);qat.StackedArea=GUe});var CKt=H(Yat=>{"use strict";Object.defineProperty(Yat,"__esModule",{value:!0});var WUe=(de(),Ut(pe)),Gat=_l(),YUe=Bu(),TKt=CS(),pB=Fe(),Wat=_4(),jUe=rs(),XUe=function(e){WUe.__extends(t,e);function t(r){r===void 0&&(r="vertical");var n=e.call(this,r)||this;return n._extremaFormatter=YUe.identity(),n._stackingResult=TKt.memThunk(function(){return n.datasets()},function(){return n.position().accessor},function(){return n.length().accessor},function(){return n._stackingOrder},function(i,o,a,s){return pB.Stacking.stack(i,o,a,s)}),n._stackedExtent=TKt.memThunk(n._stackingResult,function(){return n.position().accessor},function(){return n._filterForProperty(n._isVertical?"y":"x")},function(i,o,a){return pB.Stacking.stackedExtent(i,o,a)}),n.addClass("stacked-bar-plot"),n._stackingOrder="bottomup",n}return t.prototype.stackingOrder=function(r){return r==null?this._stackingOrder:(this._stackingOrder=r,this._onDatasetUpdate(),this)},t.prototype.extremaFormatter=function(r){return arguments.length===0?this._extremaFormatter:(this._extremaFormatter=r,this.render(),this)},t.prototype._setup=function(){e.prototype._setup.call(this),this._labelArea=this._renderArea.append("g").classed(Wat.Bar._LABEL_AREA_CLASS,!0);var r=new Gat.SvgContext(this._labelArea.node());this._measurer=new Gat.CacheMeasurer(r),this._writer=new Gat.Writer(this._measurer,r)},t.prototype._drawLabels=function(){var r=this;e.prototype._drawLabels.call(this),this._labelArea.selectAll("g").remove();var n=+this.baselineValue(),i=this.position().scale,o=this.length().scale,a=pB.Stacking.stackedExtents(this._stackingResult()),s=a.maximumExtents,l=a.minimumExtents,c=[],u=function(f,p,d){var g=p.topLeft,_=g.x,y=g.y,x=p.bottomRight.x-p.topLeft.x,b=p.bottomRight.y-p.topLeft.y,S=r._isVertical?x>d:b>d;if(!S){var C=r._labelArea.append("g").attr("transform","translate("+_+", "+y+")");C.classed("stacked-bar-label",!0);var P={xAlign:"center",yAlign:"center"};r._writer.write(f,x,b,P,C.node())}return S},h=function(f,p){var d=r._generateAttrToProjector(),g=r.width(),_=r.height();f.forEach(function(y){if(y.extent!==n){var x=r.extremaFormatter()(y.extent),b=r._measurer.measure(x),S=y.stackedDatum,C=S.originalDatum,P=S.originalIndex,k=S.originalDataset;if(!r._isDatumOnScreen(d,g,_,C,P,k))return;var O=jUe.Plot._scaledAccessor(r.attr(Wat.Bar._BAR_THICKNESS_KEY))(C,P,k),D=o.scale(y.extent),B=r._getPositionAttr(i.scale(y.axisValue),O)+O/2,I=r._isVertical?{x:B,y:D}:{x:D,y:B},L=p(I,b,O),R=u(x,{topLeft:L,bottomRight:{x:L.x+b.width,y:L.y+b.height}},O);c.push(R)}})};h(s,function(f,p,d){var g=r._isVertical?p.width:p.height,_=r._isVertical?p.height:p.width;return{x:r._isVertical?f.x-g/2:f.x+t._EXTREMA_LABEL_MARGIN_FROM_BAR,y:r._isVertical?f.y-_:f.y-g/2}}),h(l,function(f,p,d){var g=r._isVertical?p.width:p.height,_=r._isVertical?p.height:p.width;return{x:r._isVertical?f.x-g/2:f.x-_,y:r._isVertical?f.y+t._EXTREMA_LABEL_MARGIN_FROM_BAR:f.y-g/2}}),c.some(function(f){return f})&&this._labelArea.selectAll("g").remove()},t.prototype._generateAttrToProjector=function(){var r=this,n=e.prototype._generateAttrToProjector.call(this),i=this._isVertical?"y":"x",o=this.length().scale,a=this.length().accessor,s=this.position().accessor,l=function(d,g,_){return pB.Stacking.normalizeKey(s(d,g,_))},c=this._stackingResult(),u=function(d,g,_){return o.scale(c.get(_).get(l(d,g,_)).offset)},h=function(d,g,_){return o.scale(+a(d,g,_)+c.get(_).get(l(d,g,_)).offset)},f=function(d,g,_){return Math.abs(h(d,g,_)-u(d,g,_))};n[this._isVertical?"height":"width"]=f;var p=function(d,g,_){return+a(d,g,_)<0?u(d,g,_):h(d,g,_)};return n[i]=function(d,g,_){return r._isVertical?p(d,g,_):p(d,g,_)-f(d,g,_)},n},t.prototype.getExtentsForProperty=function(r){var n=this._isVertical?"y":"x";return r===n?[this._stackedExtent()]:e.prototype.getExtentsForProperty.call(this,r)},t.prototype.invalidateCache=function(){e.prototype.invalidateCache.call(this),this._measurer.reset()},t._EXTREMA_LABEL_MARGIN_FROM_BAR=5,t}(Wat.Bar);Yat.StackedBar=XUe});var AKt=H(jat=>{"use strict";Object.defineProperty(jat,"__esModule",{value:!0});var $Ue=(de(),Ut(pe)),KUe=Fe(),ZUe=_4(),JUe=rs(),QUe=function(e){$Ue.__extends(t,e);function t(){var r=e.call(this)||this;return r._connectorsEnabled=!1,r.addClass("waterfall-plot"),r}return t.prototype.connectorsEnabled=function(r){return r==null?this._connectorsEnabled:(this._connectorsEnabled=r,this)},t.prototype.total=function(r){return r==null?this._propertyBindings.get(t._TOTAL_KEY):(this._bindProperty(t._TOTAL_KEY,r,null),this)},t.prototype._additionalPaint=function(r){var n=this;this._connectorArea.selectAll("line").remove(),this._connectorsEnabled&&KUe.Window.setTimeout(function(){return n._drawConnectors()},r)},t.prototype._createNodesForDataset=function(r){var n=e.prototype._createNodesForDataset.call(this,r);return this._connectorArea=this._renderArea.append("g").classed(t._CONNECTOR_AREA_CLASS,!0),n},t.prototype.getExtentsForProperty=function(r){var n="y";return r===n?[this._extent]:e.prototype.getExtentsForProperty.call(this,r)},t.prototype._generateAttrToProjector=function(){var r=this,n=e.prototype._generateAttrToProjector.call(this),i=this.y().scale,o=JUe.Plot._scaledAccessor(this.total()),a=this.attr("y");a==null&&(n.y=function(l,c,u){var h=r.y().accessor(l,c,u),f=o(l,c,u);if(f)return Math.min(i.scale(h),i.scale(0));var p=r._subtotals[c];if(c===0)return h<0?i.scale(p-h):i.scale(p);var d=r._subtotals[c-1];return p>d?i.scale(p):i.scale(d)});var s=this.attr("height");return s==null&&(n.height=function(l,c,u){var h=o(l,c,u),f=r.y().accessor(l,c,u);if(h)return Math.abs(i.scale(f)-i.scale(0));var p=r._subtotals[c];if(c===0)return Math.abs(i.scale(p)-i.scale(p-f));var d=r._subtotals[c-1];return Math.abs(i.scale(p)-i.scale(d))}),n.class=function(l,c,u){var h="";r.attr("class")!=null&&(h=r.attr("class").accessor(l,c,u)+" ");var f=o(l,c,u);if(f)return h+t._BAR_TOTAL_CLASS;var p=r.y().accessor(l,c,u);return h+(p>0?t._BAR_GROWTH_CLASS:t._BAR_DECLINE_CLASS)},n},t.prototype._onDatasetUpdate=function(){return this._updateSubtotals(),e.prototype._onDatasetUpdate.call(this),this},t.prototype._calculateSubtotalsAndExtent=function(r){for(var n=Number.MAX_VALUE,i=Number.MIN_VALUE,o=0,a=!1,s=r.data(),l=s.length,c=0;c<l;c++){var u=s[c],h=this.y().accessor(u,c,r),f=this.total().accessor(u,c,r);if((!f||c===0)&&(o+=h),this._subtotals.push(o),o<n&&(n=o),o>i&&(i=o),f&&(h<n&&(n=h),h>i&&(i=h)),!a&&f){for(var p=h-o,d=0;d<this._subtotals.length;d++)this._subtotals[d]+=p;a=!0,o+=p,n+=p,i+=p}}this._extent=[n,i]},t.prototype._drawConnectors=function(){for(var r=this._getAttrToProjector(),n=this.datasets()[0],i=1;i<n.data().length;i++){var o=i-1,a=n.data()[i],s=n.data()[o],l=r.x(s,o,n),c=r.x(a,i,n)+r.width(a,i,n),u=r.y(a,i,n);(this._subtotals[i]>0&&this._subtotals[i]>this._subtotals[o]||this._subtotals[i]<0&&this._subtotals[i]>=this._subtotals[o])&&(u=r.y(a,i,n)+r.height(a,i,n)),this._connectorArea.append("line").classed(t._CONNECTOR_CLASS,!0).attr("x1",l).attr("x2",c).attr("y1",u).attr("y2",u)}},t.prototype._updateSubtotals=function(){var r=this.datasets();if(r.length>0){var n=r[r.length-1];this._subtotals=new Array,this._calculateSubtotalsAndExtent(n)}},t._BAR_DECLINE_CLASS="waterfall-decline",t._BAR_GROWTH_CLASS="waterfall-growth",t._BAR_TOTAL_CLASS="waterfall-total",t._CONNECTOR_CLASS="connector",t._CONNECTOR_AREA_CLASS="connector-area",t._TOTAL_KEY="total",t}(ZUe.Bar);jat.Waterfall=QUe});var IS=H(Os=>{"use strict";Object.defineProperty(Os,"__esModule",{value:!0});var zc=(de(),Ut(pe));zc.__exportStar(Cat(),Os);zc.__exportStar(_4(),Os);zc.__exportStar(Wot(),Os);zc.__exportStar(_Kt(),Os);zc.__exportStar(Mat(),Os);zc.__exportStar(yKt(),Os);zc.__exportStar(vKt(),Os);zc.__exportStar(bKt(),Os);zc.__exportStar(wKt(),Os);zc.__exportStar(EKt(),Os);zc.__exportStar(CKt(),Os);zc.__exportStar(AKt(),Os)});var PKt=H(Xat=>{"use strict";Object.defineProperty(Xat,"__esModule",{value:!0});Xat.version="3.9.0"});var wl=H(ln=>{"use strict";Object.defineProperty(ln,"__esModule",{value:!0});var Fc=(de(),Ut(pe));Gjt();var tqe=Lf();ln.Animators=tqe;var eqe=s$t();ln.Axes=eqe;var rqe=Iot();ln.Components=rqe;var nqe=XA();ln.Configs=nqe;var iqe=Bu();ln.Formatters=iqe;var oqe=PF();ln.RenderController=oqe;var aqe=Vit();ln.RenderPolicies=aqe;var sqe=jF();ln.SymbolFactories=sqe;var lqe=N1();ln.Dispatchers=lqe;var cqe=B1();ln.Drawers=cqe;var uqe=s4();ln.Interactions=uqe;var hqe=IS();ln.Plots=hqe;var fqe=ks();ln.Scales=fqe;var pqe=Fe();ln.Utils=pqe;Fc.__exportStar(QA(),ln);var dqe=BF();ln.TimeInterval=dqe.TimeInterval;Fc.__exportStar(kc(),ln);Fc.__exportStar(GF(),ln);Fc.__exportStar(jot(),ln);var mqe=PKt();ln.version=mqe.version;Fc.__exportStar(i4(),ln);Fc.__exportStar(Uu(),ln);Fc.__exportStar(D1(),ln);Fc.__exportStar(Sot(),ln);Fc.__exportStar(H1(),ln);Fc.__exportStar(rs(),ln);Fc.__exportStar(vd(),ln);Fc.__exportStar(L1(),ln)});var XKt=H((Kjn,jKt)=>{function Nqe(){this.__data__=[],this.size=0}jKt.exports=Nqe});var Y1=H((Zjn,$Kt)=>{function Dqe(e,t){return e===t||e!==e&&t!==t}$Kt.exports=Dqe});var S4=H((Jjn,KKt)=>{var Oqe=Y1();function zqe(e,t){for(var r=e.length;r--;)if(Oqe(e[r][0],t))return r;return-1}KKt.exports=zqe});var JKt=H((Qjn,ZKt)=>{var Fqe=S4(),Bqe=Array.prototype,Hqe=Bqe.splice;function Vqe(e){var t=this.__data__,r=Fqe(t,e);if(r<0)return!1;var n=t.length-1;return r==n?t.pop():Hqe.call(t,r,1),--this.size,!0}ZKt.exports=Vqe});var tZt=H((tXn,QKt)=>{var Uqe=S4();function qqe(e){var t=this.__data__,r=Uqe(t,e);return r<0?void 0:t[r][1]}QKt.exports=qqe});var rZt=H((eXn,eZt)=>{var Gqe=S4();function Wqe(e){return Gqe(this.__data__,e)>-1}eZt.exports=Wqe});var iZt=H((rXn,nZt)=>{var Yqe=S4();function jqe(e,t){var r=this.__data__,n=Yqe(r,e);return n<0?(++this.size,r.push([e,t])):r[n][1]=t,this}nZt.exports=jqe});var M4=H((nXn,oZt)=>{var Xqe=XKt(),$qe=JKt(),Kqe=tZt(),Zqe=rZt(),Jqe=iZt();function zS(e){var t=-1,r=e==null?0:e.length;for(this.clear();++t<r;){var n=e[t];this.set(n[0],n[1])}}zS.prototype.clear=Xqe;zS.prototype.delete=$qe;zS.prototype.get=Kqe;zS.prototype.has=Zqe;zS.prototype.set=Jqe;oZt.exports=zS});var sZt=H((iXn,aZt)=>{var Qqe=M4();function tGe(){this.__data__=new Qqe,this.size=0}aZt.exports=tGe});var cZt=H((oXn,lZt)=>{function eGe(e){var t=this.__data__,r=t.delete(e);return this.size=t.size,r}lZt.exports=eGe});var hZt=H((aXn,uZt)=>{function rGe(e){return this.__data__.get(e)}uZt.exports=rGe});var pZt=H((sXn,fZt)=>{function nGe(e){return this.__data__.has(e)}fZt.exports=nGe});var ust=H((lXn,dZt)=>{var iGe=typeof global=="object"&&global&&global.Object===Object&&global;dZt.exports=iGe});var Hc=H((cXn,mZt)=>{var oGe=ust(),aGe=typeof self=="object"&&self&&self.Object===Object&&self,sGe=oGe||aGe||Function("return this")();mZt.exports=sGe});var j1=H((uXn,gZt)=>{var lGe=Hc(),cGe=lGe.Symbol;gZt.exports=cGe});var xZt=H((hXn,vZt)=>{var _Zt=j1(),yZt=Object.prototype,uGe=yZt.hasOwnProperty,hGe=yZt.toString,E4=_Zt?_Zt.toStringTag:void 0;function fGe(e){var t=uGe.call(e,E4),r=e[E4];try{e[E4]=void 0;var n=!0}catch(o){}var i=hGe.call(e);return n&&(t?e[E4]=r:delete e[E4]),i}vZt.exports=fGe});var wZt=H((fXn,bZt)=>{var pGe=Object.prototype,dGe=pGe.toString;function mGe(e){return dGe.call(e)}bZt.exports=mGe});var s0=H((pXn,EZt)=>{var SZt=j1(),gGe=xZt(),_Ge=wZt(),yGe="[object Null]",vGe="[object Undefined]",MZt=SZt?SZt.toStringTag:void 0;function xGe(e){return e==null?e===void 0?vGe:yGe:MZt&&MZt in Object(e)?gGe(e):_Ge(e)}EZt.exports=xGe});var Ml=H((dXn,TZt)=>{function bGe(e){var t=typeof e;return e!=null&&(t=="object"||t=="function")}TZt.exports=bGe});var FS=H((mXn,CZt)=>{var wGe=s0(),SGe=Ml(),MGe="[object AsyncFunction]",EGe="[object Function]",TGe="[object GeneratorFunction]",CGe="[object Proxy]";function AGe(e){if(!SGe(e))return!1;var t=wGe(e);return t==EGe||t==TGe||t==MGe||t==CGe}CZt.exports=AGe});var PZt=H((gXn,AZt)=>{var PGe=Hc(),IGe=PGe["__core-js_shared__"];AZt.exports=IGe});var kZt=H((_Xn,LZt)=>{var hst=PZt(),IZt=function(){var e=/[^.]+$/.exec(hst&&hst.keys&&hst.keys.IE_PROTO||"");return e?"Symbol(src)_1."+e:""}();function LGe(e){return!!IZt&&IZt in e}LZt.exports=LGe});var fst=H((yXn,RZt)=>{var kGe=Function.prototype,RGe=kGe.toString;function NGe(e){if(e!=null){try{return RGe.call(e)}catch(t){}try{return e+""}catch(t){}}return""}RZt.exports=NGe});var DZt=H((vXn,NZt)=>{var DGe=FS(),OGe=kZt(),zGe=Ml(),FGe=fst(),BGe=/[\\^$.*+?()[\]{}|]/g,HGe=/^\[object .+?Constructor\]$/,VGe=Function.prototype,UGe=Object.prototype,qGe=VGe.toString,GGe=UGe.hasOwnProperty,WGe=RegExp("^"+qGe.call(GGe).replace(BGe,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$");function YGe(e){if(!zGe(e)||OGe(e))return!1;var t=DGe(e)?WGe:HGe;return t.test(FGe(e))}NZt.exports=YGe});var zZt=H((xXn,OZt)=>{function jGe(e,t){return e==null?void 0:e[t]}OZt.exports=jGe});var l0=H((bXn,FZt)=>{var XGe=DZt(),$Ge=zZt();function KGe(e,t){var r=$Ge(e,t);return XGe(r)?r:void 0}FZt.exports=KGe});var OB=H((wXn,BZt)=>{var ZGe=l0(),JGe=Hc(),QGe=ZGe(JGe,"Map");BZt.exports=QGe});var T4=H((SXn,HZt)=>{var tWe=l0(),eWe=tWe(Object,"create");HZt.exports=eWe});var qZt=H((MXn,UZt)=>{var VZt=T4();function rWe(){this.__data__=VZt?VZt(null):{},this.size=0}UZt.exports=rWe});var WZt=H((EXn,GZt)=>{function nWe(e){var t=this.has(e)&&delete this.__data__[e];return this.size-=t?1:0,t}GZt.exports=nWe});var jZt=H((TXn,YZt)=>{var iWe=T4(),oWe="__lodash_hash_undefined__",aWe=Object.prototype,sWe=aWe.hasOwnProperty;function lWe(e){var t=this.__data__;if(iWe){var r=t[e];return r===oWe?void 0:r}return sWe.call(t,e)?t[e]:void 0}YZt.exports=lWe});var $Zt=H((CXn,XZt)=>{var cWe=T4(),uWe=Object.prototype,hWe=uWe.hasOwnProperty;function fWe(e){var t=this.__data__;return cWe?t[e]!==void 0:hWe.call(t,e)}XZt.exports=fWe});var ZZt=H((AXn,KZt)=>{var pWe=T4(),dWe="__lodash_hash_undefined__";function mWe(e,t){var r=this.__data__;return this.size+=this.has(e)?0:1,r[e]=pWe&&t===void 0?dWe:t,this}KZt.exports=mWe});var QZt=H((PXn,JZt)=>{var gWe=qZt(),_We=WZt(),yWe=jZt(),vWe=$Zt(),xWe=ZZt();function BS(e){var t=-1,r=e==null?0:e.length;for(this.clear();++t<r;){var n=e[t];this.set(n[0],n[1])}}BS.prototype.clear=gWe;BS.prototype.delete=_We;BS.prototype.get=yWe;BS.prototype.has=vWe;BS.prototype.set=xWe;JZt.exports=BS});var rJt=H((IXn,eJt)=>{var tJt=QZt(),bWe=M4(),wWe=OB();function SWe(){this.size=0,this.__data__={hash:new tJt,map:new(wWe||bWe),string:new tJt}}eJt.exports=SWe});var iJt=H((LXn,nJt)=>{function MWe(e){var t=typeof e;return t=="string"||t=="number"||t=="symbol"||t=="boolean"?e!=="__proto__":e===null}nJt.exports=MWe});var C4=H((kXn,oJt)=>{var EWe=iJt();function TWe(e,t){var r=e.__data__;return EWe(t)?r[typeof t=="string"?"string":"hash"]:r.map}oJt.exports=TWe});var sJt=H((RXn,aJt)=>{var CWe=C4();function AWe(e){var t=CWe(this,e).delete(e);return this.size-=t?1:0,t}aJt.exports=AWe});var cJt=H((NXn,lJt)=>{var PWe=C4();function IWe(e){return PWe(this,e).get(e)}lJt.exports=IWe});var hJt=H((DXn,uJt)=>{var LWe=C4();function kWe(e){return LWe(this,e).has(e)}uJt.exports=kWe});var pJt=H((OXn,fJt)=>{var RWe=C4();function NWe(e,t){var r=RWe(this,e),n=r.size;return r.set(e,t),this.size+=r.size==n?0:1,this}fJt.exports=NWe});var zB=H((zXn,dJt)=>{var DWe=rJt(),OWe=sJt(),zWe=cJt(),FWe=hJt(),BWe=pJt();function HS(e){var t=-1,r=e==null?0:e.length;for(this.clear();++t<r;){var n=e[t];this.set(n[0],n[1])}}HS.prototype.clear=DWe;HS.prototype.delete=OWe;HS.prototype.get=zWe;HS.prototype.has=FWe;HS.prototype.set=BWe;dJt.exports=HS});var gJt=H((FXn,mJt)=>{var HWe=M4(),VWe=OB(),UWe=zB(),qWe=200;function GWe(e,t){var r=this.__data__;if(r instanceof HWe){var n=r.__data__;if(!VWe||n.length<qWe-1)return n.push([e,t]),this.size=++r.size,this;r=this.__data__=new UWe(n)}return r.set(e,t),this.size=r.size,this}mJt.exports=GWe});var A4=H((BXn,_Jt)=>{var WWe=M4(),YWe=sZt(),jWe=cZt(),XWe=hZt(),$We=pZt(),KWe=gJt();function VS(e){var t=this.__data__=new WWe(e);this.size=t.size}VS.prototype.clear=YWe;VS.prototype.delete=jWe;VS.prototype.get=XWe;VS.prototype.has=$We;VS.prototype.set=KWe;_Jt.exports=VS});var FB=H((HXn,yJt)=>{function ZWe(e,t){for(var r=-1,n=e==null?0:e.length;++r<n&&t(e[r],r,e)!==!1;);return e}yJt.exports=ZWe});var pst=H((VXn,vJt)=>{var JWe=l0(),QWe=function(){try{var e=JWe(Object,"defineProperty");return e({},"",{}),e}catch(t){}}();vJt.exports=QWe});var P4=H((UXn,bJt)=>{var xJt=pst();function tYe(e,t,r){t=="__proto__"&&xJt?xJt(e,t,{configurable:!0,enumerable:!0,value:r,writable:!0}):e[t]=r}bJt.exports=tYe});var I4=H((qXn,wJt)=>{var eYe=P4(),rYe=Y1(),nYe=Object.prototype,iYe=nYe.hasOwnProperty;function oYe(e,t,r){var n=e[t];(!(iYe.call(e,t)&&rYe(n,r))||r===void 0&&!(t in e))&&eYe(e,t,r)}wJt.exports=oYe});var US=H((GXn,SJt)=>{var aYe=I4(),sYe=P4();function lYe(e,t,r,n){var i=!r;r||(r={});for(var o=-1,a=t.length;++o<a;){var s=t[o],l=n?n(r[s],e[s],s,r,e):void 0;l===void 0&&(l=e[s]),i?sYe(r,s,l):aYe(r,s,l)}return r}SJt.exports=lYe});var EJt=H((WXn,MJt)=>{function cYe(e,t){for(var r=-1,n=Array(e);++r<e;)n[r]=t(r);return n}MJt.exports=cYe});var Yu=H((YXn,TJt)=>{function uYe(e){return e!=null&&typeof e=="object"}TJt.exports=uYe});var AJt=H((jXn,CJt)=>{var hYe=s0(),fYe=Yu(),pYe="[object Arguments]";function dYe(e){return fYe(e)&&hYe(e)==pYe}CJt.exports=dYe});var qS=H((XXn,LJt)=>{var PJt=AJt(),mYe=Yu(),IJt=Object.prototype,gYe=IJt.hasOwnProperty,_Ye=IJt.propertyIsEnumerable,yYe=PJt(function(){return arguments}())?PJt:function(e){return mYe(e)&&gYe.call(e,"callee")&&!_Ye.call(e,"callee")};LJt.exports=yYe});var Ti=H(($Xn,kJt)=>{var vYe=Array.isArray;kJt.exports=vYe});var NJt=H((KXn,RJt)=>{function xYe(){return!1}RJt.exports=xYe});var X1=H((L4,GS)=>{var bYe=Hc(),wYe=NJt(),zJt=typeof L4=="object"&&L4&&!L4.nodeType&&L4,DJt=zJt&&typeof GS=="object"&&GS&&!GS.nodeType&&GS,SYe=DJt&&DJt.exports===zJt,OJt=SYe?bYe.Buffer:void 0,MYe=OJt?OJt.isBuffer:void 0,EYe=MYe||wYe;GS.exports=EYe});var k4=H((ZXn,FJt)=>{var TYe=9007199254740991,CYe=/^(?:0|[1-9]\d*)$/;function AYe(e,t){var r=typeof e;return t=t==null?TYe:t,!!t&&(r=="number"||r!="symbol"&&CYe.test(e))&&e>-1&&e%1==0&&e<t}FJt.exports=AYe});var BB=H((JXn,BJt)=>{var PYe=9007199254740991;function IYe(e){return typeof e=="number"&&e>-1&&e%1==0&&e<=PYe}BJt.exports=IYe});var VJt=H((QXn,HJt)=>{var LYe=s0(),kYe=BB(),RYe=Yu(),NYe="[object Arguments]",DYe="[object Array]",OYe="[object Boolean]",zYe="[object Date]",FYe="[object Error]",BYe="[object Function]",HYe="[object Map]",VYe="[object Number]",UYe="[object Object]",qYe="[object RegExp]",GYe="[object Set]",WYe="[object String]",YYe="[object WeakMap]",jYe="[object ArrayBuffer]",XYe="[object DataView]",$Ye="[object Float32Array]",KYe="[object Float64Array]",ZYe="[object Int8Array]",JYe="[object Int16Array]",QYe="[object Int32Array]",tje="[object Uint8Array]",eje="[object Uint8ClampedArray]",rje="[object Uint16Array]",nje="[object Uint32Array]",Un={};Un[$Ye]=Un[KYe]=Un[ZYe]=Un[JYe]=Un[QYe]=Un[tje]=Un[eje]=Un[rje]=Un[nje]=!0;Un[NYe]=Un[DYe]=Un[jYe]=Un[OYe]=Un[XYe]=Un[zYe]=Un[FYe]=Un[BYe]=Un[HYe]=Un[VYe]=Un[UYe]=Un[qYe]=Un[GYe]=Un[WYe]=Un[YYe]=!1;function ije(e){return RYe(e)&&kYe(e.length)&&!!Un[LYe(e)]}HJt.exports=ije});var R4=H((t$n,UJt)=>{function oje(e){return function(t){return e(t)}}UJt.exports=oje});var HB=H((N4,WS)=>{var aje=ust(),qJt=typeof N4=="object"&&N4&&!N4.nodeType&&N4,D4=qJt&&typeof WS=="object"&&WS&&!WS.nodeType&&WS,sje=D4&&D4.exports===qJt,dst=sje&&aje.process,lje=function(){try{var e=D4&&D4.require&&D4.require("util").types;return e||dst&&dst.binding&&dst.binding("util")}catch(t){}}();WS.exports=lje});var YS=H((e$n,YJt)=>{var cje=VJt(),uje=R4(),GJt=HB(),WJt=GJt&&GJt.isTypedArray,hje=WJt?uje(WJt):cje;YJt.exports=hje});var mst=H((r$n,jJt)=>{var fje=EJt(),pje=qS(),dje=Ti(),mje=X1(),gje=k4(),_je=YS(),yje=Object.prototype,vje=yje.hasOwnProperty;function xje(e,t){var r=dje(e),n=!r&&pje(e),i=!r&&!n&&mje(e),o=!r&&!n&&!i&&_je(e),a=r||n||i||o,s=a?fje(e.length,String):[],l=s.length;for(var c in e)(t||vje.call(e,c))&&!(a&&(c=="length"||i&&(c=="offset"||c=="parent")||o&&(c=="buffer"||c=="byteLength"||c=="byteOffset")||gje(c,l)))&&s.push(c);return s}jJt.exports=xje});var O4=H((n$n,XJt)=>{var bje=Object.prototype;function wje(e){var t=e&&e.constructor,r=typeof t=="function"&&t.prototype||bje;return e===r}XJt.exports=wje});var gst=H((i$n,$Jt)=>{function Sje(e,t){return function(r){return e(t(r))}}$Jt.exports=Sje});var ZJt=H((o$n,KJt)=>{var Mje=gst(),Eje=Mje(Object.keys,Object);KJt.exports=Eje});var VB=H((a$n,JJt)=>{var Tje=O4(),Cje=ZJt(),Aje=Object.prototype,Pje=Aje.hasOwnProperty;function Ije(e){if(!Tje(e))return Cje(e);var t=[];for(var r in Object(e))Pje.call(e,r)&&r!="constructor"&&t.push(r);return t}JJt.exports=Ije});var Bf=H((s$n,QJt)=>{var Lje=FS(),kje=BB();function Rje(e){return e!=null&&kje(e.length)&&!Lje(e)}QJt.exports=Rje});var Ad=H((l$n,tQt)=>{var Nje=mst(),Dje=VB(),Oje=Bf();function zje(e){return Oje(e)?Nje(e):Dje(e)}tQt.exports=zje});var rQt=H((c$n,eQt)=>{var Fje=US(),Bje=Ad();function Hje(e,t){return e&&Fje(t,Bje(t),e)}eQt.exports=Hje});var iQt=H((u$n,nQt)=>{function Vje(e){var t=[];if(e!=null)for(var r in Object(e))t.push(r);return t}nQt.exports=Vje});var aQt=H((h$n,oQt)=>{var Uje=Ml(),qje=O4(),Gje=iQt(),Wje=Object.prototype,Yje=Wje.hasOwnProperty;function jje(e){if(!Uje(e))return Gje(e);var t=qje(e),r=[];for(var n in e)n=="constructor"&&(t||!Yje.call(e,n))||r.push(n);return r}oQt.exports=jje});var c0=H((f$n,sQt)=>{var Xje=mst(),$je=aQt(),Kje=Bf();function Zje(e){return Kje(e)?Xje(e,!0):$je(e)}sQt.exports=Zje});var cQt=H((p$n,lQt)=>{var Jje=US(),Qje=c0();function tXe(e,t){return e&&Jje(t,Qje(t),e)}lQt.exports=tXe});var _st=H((z4,jS)=>{var eXe=Hc(),pQt=typeof z4=="object"&&z4&&!z4.nodeType&&z4,uQt=pQt&&typeof jS=="object"&&jS&&!jS.nodeType&&jS,rXe=uQt&&uQt.exports===pQt,hQt=rXe?eXe.Buffer:void 0,fQt=hQt?hQt.allocUnsafe:void 0;function nXe(e,t){if(t)return e.slice();var r=e.length,n=fQt?fQt(r):new e.constructor(r);return e.copy(n),n}jS.exports=nXe});var yst=H((d$n,dQt)=>{function iXe(e,t){var r=-1,n=e.length;for(t||(t=Array(n));++r<n;)t[r]=e[r];return t}dQt.exports=iXe});var vst=H((m$n,mQt)=>{function oXe(e,t){for(var r=-1,n=e==null?0:e.length,i=0,o=[];++r<n;){var a=e[r];t(a,r,e)&&(o[i++]=a)}return o}mQt.exports=oXe});var xst=H((g$n,gQt)=>{function aXe(){return[]}gQt.exports=aXe});var UB=H((_$n,yQt)=>{var sXe=vst(),lXe=xst(),cXe=Object.prototype,uXe=cXe.propertyIsEnumerable,_Qt=Object.getOwnPropertySymbols,hXe=_Qt?function(e){return e==null?[]:(e=Object(e),sXe(_Qt(e),function(t){return uXe.call(e,t)}))}:lXe;yQt.exports=hXe});var xQt=H((y$n,vQt)=>{var fXe=US(),pXe=UB();function dXe(e,t){return fXe(e,pXe(e),t)}vQt.exports=dXe});var qB=H((v$n,bQt)=>{function mXe(e,t){for(var r=-1,n=t.length,i=e.length;++r<n;)e[i+r]=t[r];return e}bQt.exports=mXe});var F4=H((x$n,wQt)=>{var gXe=gst(),_Xe=gXe(Object.getPrototypeOf,Object);wQt.exports=_Xe});var bst=H((b$n,SQt)=>{var yXe=qB(),vXe=F4(),xXe=UB(),bXe=xst(),wXe=Object.getOwnPropertySymbols,SXe=wXe?function(e){for(var t=[];e;)yXe(t,xXe(e)),e=vXe(e);return t}:bXe;SQt.exports=SXe});var EQt=H((w$n,MQt)=>{var MXe=US(),EXe=bst();function TXe(e,t){return MXe(e,EXe(e),t)}MQt.exports=TXe});var wst=H((S$n,TQt)=>{var CXe=qB(),AXe=Ti();function PXe(e,t,r){var n=t(e);return AXe(e)?n:CXe(n,r(e))}TQt.exports=PXe});var Sst=H((M$n,CQt)=>{var IXe=wst(),LXe=UB(),kXe=Ad();function RXe(e){return IXe(e,kXe,LXe)}CQt.exports=RXe});var PQt=H((E$n,AQt)=>{var NXe=wst(),DXe=bst(),OXe=c0();function zXe(e){return NXe(e,OXe,DXe)}AQt.exports=zXe});var LQt=H((T$n,IQt)=>{var FXe=l0(),BXe=Hc(),HXe=FXe(BXe,"DataView");IQt.exports=HXe});var RQt=H((C$n,kQt)=>{var VXe=l0(),UXe=Hc(),qXe=VXe(UXe,"Promise");kQt.exports=qXe});var Mst=H((A$n,NQt)=>{var GXe=l0(),WXe=Hc(),YXe=GXe(WXe,"Set");NQt.exports=YXe});var OQt=H((P$n,DQt)=>{var jXe=l0(),XXe=Hc(),$Xe=jXe(XXe,"WeakMap");DQt.exports=$Xe});var K1=H((I$n,qQt)=>{var Est=LQt(),Tst=OB(),Cst=RQt(),Ast=Mst(),Pst=OQt(),UQt=s0(),XS=fst(),zQt="[object Map]",KXe="[object Object]",FQt="[object Promise]",BQt="[object Set]",HQt="[object WeakMap]",VQt="[object DataView]",ZXe=XS(Est),JXe=XS(Tst),QXe=XS(Cst),t$e=XS(Ast),e$e=XS(Pst),$1=UQt;(Est&&$1(new Est(new ArrayBuffer(1)))!=VQt||Tst&&$1(new Tst)!=zQt||Cst&&$1(Cst.resolve())!=FQt||Ast&&$1(new Ast)!=BQt||Pst&&$1(new Pst)!=HQt)&&($1=function(e){var t=UQt(e),r=t==KXe?e.constructor:void 0,n=r?XS(r):"";if(n)switch(n){case ZXe:return VQt;case JXe:return zQt;case QXe:return FQt;case t$e:return BQt;case e$e:return HQt}return t});qQt.exports=$1});var WQt=H((L$n,GQt)=>{var r$e=Object.prototype,n$e=r$e.hasOwnProperty;function i$e(e){var t=e.length,r=new e.constructor(t);return t&&typeof e[0]=="string"&&n$e.call(e,"index")&&(r.index=e.index,r.input=e.input),r}GQt.exports=i$e});var Ist=H((k$n,YQt)=>{var o$e=Hc(),a$e=o$e.Uint8Array;YQt.exports=a$e});var GB=H((R$n,XQt)=>{var jQt=Ist();function s$e(e){var t=new e.constructor(e.byteLength);return new jQt(t).set(new jQt(e)),t}XQt.exports=s$e});var KQt=H((N$n,$Qt)=>{var l$e=GB();function c$e(e,t){var r=t?l$e(e.buffer):e.buffer;return new e.constructor(r,e.byteOffset,e.byteLength)}$Qt.exports=c$e});var JQt=H((D$n,ZQt)=>{var u$e=/\w*$/;function h$e(e){var t=new e.constructor(e.source,u$e.exec(e));return t.lastIndex=e.lastIndex,t}ZQt.exports=h$e});var nte=H((O$n,rte)=>{var QQt=j1(),tte=QQt?QQt.prototype:void 0,ete=tte?tte.valueOf:void 0;function f$e(e){return ete?Object(ete.call(e)):{}}rte.exports=f$e});var Lst=H((z$n,ite)=>{var p$e=GB();function d$e(e,t){var r=t?p$e(e.buffer):e.buffer;return new e.constructor(r,e.byteOffset,e.length)}ite.exports=d$e});var ate=H((F$n,ote)=>{var m$e=GB(),g$e=KQt(),_$e=JQt(),y$e=nte(),v$e=Lst(),x$e="[object Boolean]",b$e="[object Date]",w$e="[object Map]",S$e="[object Number]",M$e="[object RegExp]",E$e="[object Set]",T$e="[object String]",C$e="[object Symbol]",A$e="[object ArrayBuffer]",P$e="[object DataView]",I$e="[object Float32Array]",L$e="[object Float64Array]",k$e="[object Int8Array]",R$e="[object Int16Array]",N$e="[object Int32Array]",D$e="[object Uint8Array]",O$e="[object Uint8ClampedArray]",z$e="[object Uint16Array]",F$e="[object Uint32Array]";function B$e(e,t,r){var n=e.constructor;switch(t){case A$e:return m$e(e);case x$e:case b$e:return new n(+e);case P$e:return g$e(e,r);case I$e:case L$e:case k$e:case R$e:case N$e:case D$e:case O$e:case z$e:case F$e:return v$e(e,r);case w$e:return new n;case S$e:case T$e:return new n(e);case M$e:return _$e(e);case E$e:return new n;case C$e:return y$e(e)}}ote.exports=B$e});var kst=H((B$n,lte)=>{var H$e=Ml(),ste=Object.create,V$e=function(){function e(){}return function(t){if(!H$e(t))return{};if(ste)return ste(t);e.prototype=t;var r=new e;return e.prototype=void 0,r}}();lte.exports=V$e});var Rst=H((H$n,cte)=>{var U$e=kst(),q$e=F4(),G$e=O4();function W$e(e){return typeof e.constructor=="function"&&!G$e(e)?U$e(q$e(e)):{}}cte.exports=W$e});var hte=H((V$n,ute)=>{var Y$e=K1(),j$e=Yu(),X$e="[object Map]";function $$e(e){return j$e(e)&&Y$e(e)==X$e}ute.exports=$$e});var mte=H((U$n,dte)=>{var K$e=hte(),Z$e=R4(),fte=HB(),pte=fte&&fte.isMap,J$e=pte?Z$e(pte):K$e;dte.exports=J$e});var _te=H((q$n,gte)=>{var Q$e=K1(),tKe=Yu(),eKe="[object Set]";function rKe(e){return tKe(e)&&Q$e(e)==eKe}gte.exports=rKe});var bte=H((G$n,xte)=>{var nKe=_te(),iKe=R4(),yte=HB(),vte=yte&&yte.isSet,oKe=vte?iKe(vte):nKe;xte.exports=oKe});var Nst=H((W$n,Ete)=>{var aKe=A4(),sKe=FB(),lKe=I4(),cKe=rQt(),uKe=cQt(),hKe=_st(),fKe=yst(),pKe=xQt(),dKe=EQt(),mKe=Sst(),gKe=PQt(),_Ke=K1(),yKe=WQt(),vKe=ate(),xKe=Rst(),bKe=Ti(),wKe=X1(),SKe=mte(),MKe=Ml(),EKe=bte(),TKe=Ad(),CKe=c0(),AKe=1,PKe=2,IKe=4,wte="[object Arguments]",LKe="[object Array]",kKe="[object Boolean]",RKe="[object Date]",NKe="[object Error]",Ste="[object Function]",DKe="[object GeneratorFunction]",OKe="[object Map]",zKe="[object Number]",Mte="[object Object]",FKe="[object RegExp]",BKe="[object Set]",HKe="[object String]",VKe="[object Symbol]",UKe="[object WeakMap]",qKe="[object ArrayBuffer]",GKe="[object DataView]",WKe="[object Float32Array]",YKe="[object Float64Array]",jKe="[object Int8Array]",XKe="[object Int16Array]",$Ke="[object Int32Array]",KKe="[object Uint8Array]",ZKe="[object Uint8ClampedArray]",JKe="[object Uint16Array]",QKe="[object Uint32Array]",An={};An[wte]=An[LKe]=An[qKe]=An[GKe]=An[kKe]=An[RKe]=An[WKe]=An[YKe]=An[jKe]=An[XKe]=An[$Ke]=An[OKe]=An[zKe]=An[Mte]=An[FKe]=An[BKe]=An[HKe]=An[VKe]=An[KKe]=An[ZKe]=An[JKe]=An[QKe]=!0;An[NKe]=An[Ste]=An[UKe]=!1;function WB(e,t,r,n,i,o){var a,s=t&AKe,l=t&PKe,c=t&IKe;if(r&&(a=i?r(e,n,i,o):r(e)),a!==void 0)return a;if(!MKe(e))return e;var u=bKe(e);if(u){if(a=yKe(e),!s)return fKe(e,a)}else{var h=_Ke(e),f=h==Ste||h==DKe;if(wKe(e))return hKe(e,s);if(h==Mte||h==wte||f&&!i){if(a=l||f?{}:xKe(e),!s)return l?dKe(e,uKe(a,e)):pKe(e,cKe(a,e))}else{if(!An[h])return i?e:{};a=vKe(e,h,s)}}o||(o=new aKe);var p=o.get(e);if(p)return p;o.set(e,a),EKe(e)?e.forEach(function(_){a.add(WB(_,t,r,_,e,o))}):SKe(e)&&e.forEach(function(_,y){a.set(y,WB(_,t,r,y,e,o))});var d=c?l?gKe:mKe:l?CKe:TKe,g=u?void 0:d(e);return sKe(g||e,function(_,y){g&&(y=_,_=e[y]),lKe(a,y,WB(_,t,r,y,e,o))}),a}Ete.exports=WB});var Cte=H((Y$n,Tte)=>{var tZe=Nst(),eZe=4;function rZe(e){return tZe(e,eZe)}Tte.exports=rZe});var YB=H((j$n,Ate)=>{function nZe(e){return function(){return e}}Ate.exports=nZe});var Ite=H((X$n,Pte)=>{function iZe(e){return function(t,r,n){for(var i=-1,o=Object(t),a=n(t),s=a.length;s--;){var l=a[e?s:++i];if(r(o[l],l,o)===!1)break}return t}}Pte.exports=iZe});var jB=H(($$n,Lte)=>{var oZe=Ite(),aZe=oZe();Lte.exports=aZe});var XB=H((K$n,kte)=>{var sZe=jB(),lZe=Ad();function cZe(e,t){return e&&sZe(e,t,lZe)}kte.exports=cZe});var Nte=H((Z$n,Rte)=>{var uZe=Bf();function hZe(e,t){return function(r,n){if(r==null)return r;if(!uZe(r))return e(r,n);for(var i=r.length,o=t?i:-1,a=Object(r);(t?o--:++o<i)&&n(a[o],o,a)!==!1;);return r}}Rte.exports=hZe});var B4=H((J$n,Dte)=>{var fZe=XB(),pZe=Nte(),dZe=pZe(fZe);Dte.exports=dZe});var u0=H((Q$n,Ote)=>{function mZe(e){return e}Ote.exports=mZe});var Dst=H((tKn,zte)=>{var gZe=u0();function _Ze(e){return typeof e=="function"?e:gZe}zte.exports=_Ze});var Ost=H((eKn,Fte)=>{var yZe=FB(),vZe=B4(),xZe=Dst(),bZe=Ti();function wZe(e,t){var r=bZe(e)?yZe:vZe;return r(e,xZe(t))}Fte.exports=wZe});var zst=H((rKn,Bte)=>{Bte.exports=Ost()});var Vte=H((nKn,Hte)=>{var SZe=B4();function MZe(e,t){var r=[];return SZe(e,function(n,i,o){t(n,i,o)&&r.push(n)}),r}Hte.exports=MZe});var qte=H((iKn,Ute)=>{var EZe="__lodash_hash_undefined__";function TZe(e){return this.__data__.set(e,EZe),this}Ute.exports=TZe});var Wte=H((oKn,Gte)=>{function CZe(e){return this.__data__.has(e)}Gte.exports=CZe});var Fst=H((aKn,Yte)=>{var AZe=zB(),PZe=qte(),IZe=Wte();function $B(e){var t=-1,r=e==null?0:e.length;for(this.__data__=new AZe;++t<r;)this.add(e[t])}$B.prototype.add=$B.prototype.push=PZe;$B.prototype.has=IZe;Yte.exports=$B});var Xte=H((sKn,jte)=>{function LZe(e,t){for(var r=-1,n=e==null?0:e.length;++r<n;)if(t(e[r],r,e))return!0;return!1}jte.exports=LZe});var Bst=H((lKn,$te)=>{function kZe(e,t){return e.has(t)}$te.exports=kZe});var Hst=H((cKn,Kte)=>{var RZe=Fst(),NZe=Xte(),DZe=Bst(),OZe=1,zZe=2;function FZe(e,t,r,n,i,o){var a=r&OZe,s=e.length,l=t.length;if(s!=l&&!(a&&l>s))return!1;var c=o.get(e),u=o.get(t);if(c&&u)return c==t&&u==e;var h=-1,f=!0,p=r&zZe?new RZe:void 0;for(o.set(e,t),o.set(t,e);++h<s;){var d=e[h],g=t[h];if(n)var _=a?n(g,d,h,t,e,o):n(d,g,h,e,t,o);if(_!==void 0){if(_)continue;f=!1;break}if(p){if(!NZe(t,function(y,x){if(!DZe(p,x)&&(d===y||i(d,y,r,n,o)))return p.push(x)})){f=!1;break}}else if(!(d===g||i(d,g,r,n,o))){f=!1;break}}return o.delete(e),o.delete(t),f}Kte.exports=FZe});var Jte=H((uKn,Zte)=>{function BZe(e){var t=-1,r=Array(e.size);return e.forEach(function(n,i){r[++t]=[i,n]}),r}Zte.exports=BZe});var KB=H((hKn,Qte)=>{function HZe(e){var t=-1,r=Array(e.size);return e.forEach(function(n){r[++t]=n}),r}Qte.exports=HZe});var iee=H((fKn,nee)=>{var tee=j1(),eee=Ist(),VZe=Y1(),UZe=Hst(),qZe=Jte(),GZe=KB(),WZe=1,YZe=2,jZe="[object Boolean]",XZe="[object Date]",$Ze="[object Error]",KZe="[object Map]",ZZe="[object Number]",JZe="[object RegExp]",QZe="[object Set]",tJe="[object String]",eJe="[object Symbol]",rJe="[object ArrayBuffer]",nJe="[object DataView]",ree=tee?tee.prototype:void 0,Vst=ree?ree.valueOf:void 0;function iJe(e,t,r,n,i,o,a){switch(r){case nJe:if(e.byteLength!=t.byteLength||e.byteOffset!=t.byteOffset)return!1;e=e.buffer,t=t.buffer;case rJe:return!(e.byteLength!=t.byteLength||!o(new eee(e),new eee(t)));case jZe:case XZe:case ZZe:return VZe(+e,+t);case $Ze:return e.name==t.name&&e.message==t.message;case JZe:case tJe:return e==t+"";case KZe:var s=qZe;case QZe:var l=n&WZe;if(s||(s=GZe),e.size!=t.size&&!l)return!1;var c=a.get(e);if(c)return c==t;n|=YZe,a.set(e,t);var u=UZe(s(e),s(t),n,i,o,a);return a.delete(e),u;case eJe:if(Vst)return Vst.call(e)==Vst.call(t)}return!1}nee.exports=iJe});var see=H((pKn,aee)=>{var oee=Sst(),oJe=1,aJe=Object.prototype,sJe=aJe.hasOwnProperty;function lJe(e,t,r,n,i,o){var a=r&oJe,s=oee(e),l=s.length,c=oee(t),u=c.length;if(l!=u&&!a)return!1;for(var h=l;h--;){var f=s[h];if(!(a?f in t:sJe.call(t,f)))return!1}var p=o.get(e),d=o.get(t);if(p&&d)return p==t&&d==e;var g=!0;o.set(e,t),o.set(t,e);for(var _=a;++h<l;){f=s[h];var y=e[f],x=t[f];if(n)var b=a?n(x,y,f,t,e,o):n(y,x,f,e,t,o);if(!(b===void 0?y===x||i(y,x,r,n,o):b)){g=!1;break}_||(_=f=="constructor")}if(g&&!_){var S=e.constructor,C=t.constructor;S!=C&&"constructor"in e&&"constructor"in t&&!(typeof S=="function"&&S instanceof S&&typeof C=="function"&&C instanceof C)&&(g=!1)}return o.delete(e),o.delete(t),g}aee.exports=lJe});var mee=H((dKn,dee)=>{var Ust=A4(),cJe=Hst(),uJe=iee(),hJe=see(),lee=K1(),cee=Ti(),uee=X1(),fJe=YS(),pJe=1,hee="[object Arguments]",fee="[object Array]",ZB="[object Object]",dJe=Object.prototype,pee=dJe.hasOwnProperty;function mJe(e,t,r,n,i,o){var a=cee(e),s=cee(t),l=a?fee:lee(e),c=s?fee:lee(t);l=l==hee?ZB:l,c=c==hee?ZB:c;var u=l==ZB,h=c==ZB,f=l==c;if(f&&uee(e)){if(!uee(t))return!1;a=!0,u=!1}if(f&&!u)return o||(o=new Ust),a||fJe(e)?cJe(e,t,r,n,i,o):uJe(e,t,l,r,n,i,o);if(!(r&pJe)){var p=u&&pee.call(e,"__wrapped__"),d=h&&pee.call(t,"__wrapped__");if(p||d){var g=p?e.value():e,_=d?t.value():t;return o||(o=new Ust),i(g,_,r,n,o)}}return f?(o||(o=new Ust),hJe(e,t,r,n,i,o)):!1}dee.exports=mJe});var qst=H((mKn,yee)=>{var gJe=mee(),gee=Yu();function _ee(e,t,r,n,i){return e===t?!0:e==null||t==null||!gee(e)&&!gee(t)?e!==e&&t!==t:gJe(e,t,r,n,_ee,i)}yee.exports=_ee});var xee=H((gKn,vee)=>{var _Je=A4(),yJe=qst(),vJe=1,xJe=2;function bJe(e,t,r,n){var i=r.length,o=i,a=!n;if(e==null)return!o;for(e=Object(e);i--;){var s=r[i];if(a&&s[2]?s[1]!==e[s[0]]:!(s[0]in e))return!1}for(;++i<o;){s=r[i];var l=s[0],c=e[l],u=s[1];if(a&&s[2]){if(c===void 0&&!(l in e))return!1}else{var h=new _Je;if(n)var f=n(c,u,l,e,t,h);if(!(f===void 0?yJe(u,c,vJe|xJe,n,h):f))return!1}}return!0}vee.exports=bJe});var Gst=H((_Kn,bee)=>{var wJe=Ml();function SJe(e){return e===e&&!wJe(e)}bee.exports=SJe});var See=H((yKn,wee)=>{var MJe=Gst(),EJe=Ad();function TJe(e){for(var t=EJe(e),r=t.length;r--;){var n=t[r],i=e[n];t[r]=[n,i,MJe(i)]}return t}wee.exports=TJe});var Wst=H((vKn,Mee)=>{function CJe(e,t){return function(r){return r==null?!1:r[e]===t&&(t!==void 0||e in Object(r))}}Mee.exports=CJe});var Tee=H((xKn,Eee)=>{var AJe=xee(),PJe=See(),IJe=Wst();function LJe(e){var t=PJe(e);return t.length==1&&t[0][2]?IJe(t[0][0],t[0][1]):function(r){return r===e||AJe(r,e,t)}}Eee.exports=LJe});var Z1=H((bKn,Cee)=>{var kJe=s0(),RJe=Yu(),NJe="[object Symbol]";function DJe(e){return typeof e=="symbol"||RJe(e)&&kJe(e)==NJe}Cee.exports=DJe});var JB=H((wKn,Aee)=>{var OJe=Ti(),zJe=Z1(),FJe=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,BJe=/^\w*$/;function HJe(e,t){if(OJe(e))return!1;var r=typeof e;return r=="number"||r=="symbol"||r=="boolean"||e==null||zJe(e)?!0:BJe.test(e)||!FJe.test(e)||t!=null&&e in Object(t)}Aee.exports=HJe});var Lee=H((SKn,Iee)=>{var Pee=zB(),VJe="Expected a function";function Yst(e,t){if(typeof e!="function"||t!=null&&typeof t!="function")throw new TypeError(VJe);var r=function(){var n=arguments,i=t?t.apply(this,n):n[0],o=r.cache;if(o.has(i))return o.get(i);var a=e.apply(this,n);return r.cache=o.set(i,a)||o,a};return r.cache=new(Yst.Cache||Pee),r}Yst.Cache=Pee;Iee.exports=Yst});var Ree=H((MKn,kee)=>{var UJe=Lee(),qJe=500;function GJe(e){var t=UJe(e,function(n){return r.size===qJe&&r.clear(),n}),r=t.cache;return t}kee.exports=GJe});var Dee=H((EKn,Nee)=>{var WJe=Ree(),YJe=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,jJe=/\\(\\)?/g,XJe=WJe(function(e){var t=[];return e.charCodeAt(0)===46&&t.push(""),e.replace(YJe,function(r,n,i,o){t.push(i?o.replace(jJe,"$1"):n||r)}),t});Nee.exports=XJe});var H4=H((TKn,Oee)=>{function $Je(e,t){for(var r=-1,n=e==null?0:e.length,i=Array(n);++r<n;)i[r]=t(e[r],r,e);return i}Oee.exports=$Je});var Uee=H((CKn,Vee)=>{var zee=j1(),KJe=H4(),ZJe=Ti(),JJe=Z1(),QJe=1/0,Fee=zee?zee.prototype:void 0,Bee=Fee?Fee.toString:void 0;function Hee(e){if(typeof e=="string")return e;if(ZJe(e))return KJe(e,Hee)+"";if(JJe(e))return Bee?Bee.call(e):"";var t=e+"";return t=="0"&&1/e==-QJe?"-0":t}Vee.exports=Hee});var jst=H((AKn,qee)=>{var tQe=Uee();function eQe(e){return e==null?"":tQe(e)}qee.exports=eQe});var V4=H((PKn,Gee)=>{var rQe=Ti(),nQe=JB(),iQe=Dee(),oQe=jst();function aQe(e,t){return rQe(e)?e:nQe(e,t)?[e]:iQe(oQe(e))}Gee.exports=aQe});var $S=H((IKn,Wee)=>{var sQe=Z1(),lQe=1/0;function cQe(e){if(typeof e=="string"||sQe(e))return e;var t=e+"";return t=="0"&&1/e==-lQe?"-0":t}Wee.exports=cQe});var U4=H((LKn,Yee)=>{var uQe=V4(),hQe=$S();function fQe(e,t){t=uQe(t,e);for(var r=0,n=t.length;e!=null&&r<n;)e=e[hQe(t[r++])];return r&&r==n?e:void 0}Yee.exports=fQe});var Xee=H((kKn,jee)=>{var pQe=U4();function dQe(e,t,r){var n=e==null?void 0:pQe(e,t);return n===void 0?r:n}jee.exports=dQe});var Kee=H((RKn,$ee)=>{function mQe(e,t){return e!=null&&t in Object(e)}$ee.exports=mQe});var Xst=H((NKn,Zee)=>{var gQe=V4(),_Qe=qS(),yQe=Ti(),vQe=k4(),xQe=BB(),bQe=$S();function wQe(e,t,r){t=gQe(t,e);for(var n=-1,i=t.length,o=!1;++n<i;){var a=bQe(t[n]);if(!(o=e!=null&&r(e,a)))break;e=e[a]}return o||++n!=i?o:(i=e==null?0:e.length,!!i&&xQe(i)&&vQe(a,i)&&(yQe(e)||_Qe(e)))}Zee.exports=wQe});var $st=H((DKn,Jee)=>{var SQe=Kee(),MQe=Xst();function EQe(e,t){return e!=null&&MQe(e,t,SQe)}Jee.exports=EQe});var tre=H((OKn,Qee)=>{var TQe=qst(),CQe=Xee(),AQe=$st(),PQe=JB(),IQe=Gst(),LQe=Wst(),kQe=$S(),RQe=1,NQe=2;function DQe(e,t){return PQe(e)&&IQe(t)?LQe(kQe(e),t):function(r){var n=CQe(r,e);return n===void 0&&n===t?AQe(r,e):TQe(t,n,RQe|NQe)}}Qee.exports=DQe});var Kst=H((zKn,ere)=>{function OQe(e){return function(t){return t==null?void 0:t[e]}}ere.exports=OQe});var nre=H((FKn,rre)=>{var zQe=U4();function FQe(e){return function(t){return zQe(t,e)}}rre.exports=FQe});var ore=H((BKn,ire)=>{var BQe=Kst(),HQe=nre(),VQe=JB(),UQe=$S();function qQe(e){return VQe(e)?BQe(UQe(e)):HQe(e)}ire.exports=qQe});var Hf=H((HKn,are)=>{var GQe=Tee(),WQe=tre(),YQe=u0(),jQe=Ti(),XQe=ore();function $Qe(e){return typeof e=="function"?e:e==null?YQe:typeof e=="object"?jQe(e)?WQe(e[0],e[1]):GQe(e):XQe(e)}are.exports=$Qe});var Zst=H((VKn,sre)=>{var KQe=vst(),ZQe=Vte(),JQe=Hf(),QQe=Ti();function ttr(e,t){var r=QQe(e)?KQe:ZQe;return r(e,JQe(t,3))}sre.exports=ttr});var cre=H((UKn,lre)=>{var etr=Object.prototype,rtr=etr.hasOwnProperty;function ntr(e,t){return e!=null&&rtr.call(e,t)}lre.exports=ntr});var Jst=H((qKn,ure)=>{var itr=cre(),otr=Xst();function atr(e,t){return e!=null&&otr(e,t,itr)}ure.exports=atr});var fre=H((GKn,hre)=>{var str=VB(),ltr=K1(),ctr=qS(),utr=Ti(),htr=Bf(),ftr=X1(),ptr=O4(),dtr=YS(),mtr="[object Map]",gtr="[object Set]",_tr=Object.prototype,ytr=_tr.hasOwnProperty;function vtr(e){if(e==null)return!0;if(htr(e)&&(utr(e)||typeof e=="string"||typeof e.splice=="function"||ftr(e)||dtr(e)||ctr(e)))return!e.length;var t=ltr(e);if(t==mtr||t==gtr)return!e.size;if(ptr(e))return!str(e).length;for(var r in e)if(ytr.call(e,r))return!1;return!0}hre.exports=vtr});var Qst=H((WKn,pre)=>{function xtr(e){return e===void 0}pre.exports=xtr});var tlt=H((YKn,dre)=>{var btr=B4(),wtr=Bf();function Str(e,t){var r=-1,n=wtr(e)?Array(e.length):[];return btr(e,function(i,o,a){n[++r]=t(i,o,a)}),n}dre.exports=Str});var elt=H((jKn,mre)=>{var Mtr=H4(),Etr=Hf(),Ttr=tlt(),Ctr=Ti();function Atr(e,t){var r=Ctr(e)?Mtr:Ttr;return r(e,Etr(t,3))}mre.exports=Atr});var _re=H((XKn,gre)=>{function Ptr(e,t,r,n){var i=-1,o=e==null?0:e.length;for(n&&o&&(r=e[++i]);++i<o;)r=t(r,e[i],i,e);return r}gre.exports=Ptr});var vre=H(($Kn,yre)=>{function Itr(e,t,r,n,i){return i(e,function(o,a,s){r=n?(n=!1,o):t(r,o,a,s)}),r}yre.exports=Itr});var rlt=H((KKn,xre)=>{var Ltr=_re(),ktr=B4(),Rtr=Hf(),Ntr=vre(),Dtr=Ti();function Otr(e,t,r){var n=Dtr(e)?Ltr:Ntr,i=arguments.length<3;return n(e,Rtr(t,4),r,i,ktr)}xre.exports=Otr});var wre=H((ZKn,bre)=>{var ztr=s0(),Ftr=Ti(),Btr=Yu(),Htr="[object String]";function Vtr(e){return typeof e=="string"||!Ftr(e)&&Btr(e)&&ztr(e)==Htr}bre.exports=Vtr});var Mre=H((JKn,Sre)=>{var Utr=Kst(),qtr=Utr("length");Sre.exports=qtr});var Tre=H((QKn,Ere)=>{var Gtr="\\ud800-\\udfff",Wtr="\\u0300-\\u036f",Ytr="\\ufe20-\\ufe2f",jtr="\\u20d0-\\u20ff",Xtr=Wtr+Ytr+jtr,$tr="\\ufe0e\\ufe0f",Ktr="\\u200d",Ztr=RegExp("["+Ktr+Gtr+Xtr+$tr+"]");function Jtr(e){return Ztr.test(e)}Ere.exports=Jtr});var Dre=H((tZn,Nre)=>{var Are="\\ud800-\\udfff",Qtr="\\u0300-\\u036f",ter="\\ufe20-\\ufe2f",eer="\\u20d0-\\u20ff",rer=Qtr+ter+eer,ner="\\ufe0e\\ufe0f",ier="["+Are+"]",nlt="["+rer+"]",ilt="\\ud83c[\\udffb-\\udfff]",oer="(?:"+nlt+"|"+ilt+")",Pre="[^"+Are+"]",Ire="(?:\\ud83c[\\udde6-\\uddff]){2}",Lre="[\\ud800-\\udbff][\\udc00-\\udfff]",aer="\\u200d",kre=oer+"?",Rre="["+ner+"]?",ser="(?:"+aer+"(?:"+[Pre,Ire,Lre].join("|")+")"+Rre+kre+")*",ler=Rre+kre+ser,cer="(?:"+[Pre+nlt+"?",nlt,Ire,Lre,ier].join("|")+")",Cre=RegExp(ilt+"(?="+ilt+")|"+cer+ler,"g");function uer(e){for(var t=Cre.lastIndex=0;Cre.test(e);)++t;return t}Nre.exports=uer});var zre=H((eZn,Ore)=>{var her=Mre(),fer=Tre(),per=Dre();function der(e){return fer(e)?per(e):her(e)}Ore.exports=der});var Bre=H((rZn,Fre)=>{var mer=VB(),ger=K1(),_er=Bf(),yer=wre(),ver=zre(),xer="[object Map]",ber="[object Set]";function wer(e){if(e==null)return 0;if(_er(e))return yer(e)?ver(e):e.length;var t=ger(e);return t==xer||t==ber?e.size:mer(e).length}Fre.exports=wer});var Vre=H((nZn,Hre)=>{var Ser=FB(),Mer=kst(),Eer=XB(),Ter=Hf(),Cer=F4(),Aer=Ti(),Per=X1(),Ier=FS(),Ler=Ml(),ker=YS();function Rer(e,t,r){var n=Aer(e),i=n||Per(e)||ker(e);if(t=Ter(t,4),r==null){var o=e&&e.constructor;i?r=n?new o:[]:Ler(e)?r=Ier(o)?Mer(Cer(e)):{}:r={}}return(i?Ser:Eer)(e,function(a,s,l){return t(r,a,s,l)}),r}Hre.exports=Rer});var Wre=H((iZn,Gre)=>{var Ure=j1(),Ner=qS(),Der=Ti(),qre=Ure?Ure.isConcatSpreadable:void 0;function Oer(e){return Der(e)||Ner(e)||!!(qre&&e&&e[qre])}Gre.exports=Oer});var QB=H((oZn,jre)=>{var zer=qB(),Fer=Wre();function Yre(e,t,r,n,i){var o=-1,a=e.length;for(r||(r=Fer),i||(i=[]);++o<a;){var s=e[o];t>0&&r(s)?t>1?Yre(s,t-1,r,n,i):zer(i,s):n||(i[i.length]=s)}return i}jre.exports=Yre});var $re=H((aZn,Xre)=>{function Ber(e,t,r){switch(r.length){case 0:return e.call(t);case 1:return e.call(t,r[0]);case 2:return e.call(t,r[0],r[1]);case 3:return e.call(t,r[0],r[1],r[2])}return e.apply(t,r)}Xre.exports=Ber});var olt=H((sZn,Zre)=>{var Her=$re(),Kre=Math.max;function Ver(e,t,r){return t=Kre(t===void 0?e.length-1:t,0),function(){for(var n=arguments,i=-1,o=Kre(n.length-t,0),a=Array(o);++i<o;)a[i]=n[t+i];i=-1;for(var s=Array(t+1);++i<t;)s[i]=n[i];return s[t]=r(a),Her(e,this,s)}}Zre.exports=Ver});var tne=H((lZn,Qre)=>{var Uer=YB(),Jre=pst(),qer=u0(),Ger=Jre?function(e,t){return Jre(e,"toString",{configurable:!0,enumerable:!1,value:Uer(t),writable:!0})}:qer;Qre.exports=Ger});var rne=H((cZn,ene)=>{var Wer=800,Yer=16,jer=Date.now;function Xer(e){var t=0,r=0;return function(){var n=jer(),i=Yer-(n-r);if(r=n,i>0){if(++t>=Wer)return arguments[0]}else t=0;return e.apply(void 0,arguments)}}ene.exports=Xer});var alt=H((uZn,nne)=>{var $er=tne(),Ker=rne(),Zer=Ker($er);nne.exports=Zer});var q4=H((hZn,ine)=>{var Jer=u0(),Qer=olt(),trr=alt();function err(e,t){return trr(Qer(e,t,Jer),e+"")}ine.exports=err});var slt=H((fZn,one)=>{function rrr(e,t,r,n){for(var i=e.length,o=r+(n?1:-1);n?o--:++o<i;)if(t(e[o],o,e))return o;return-1}one.exports=rrr});var sne=H((pZn,ane)=>{function nrr(e){return e!==e}ane.exports=nrr});var cne=H((dZn,lne)=>{function irr(e,t,r){for(var n=r-1,i=e.length;++n<i;)if(e[n]===t)return n;return-1}lne.exports=irr});var hne=H((mZn,une)=>{var orr=slt(),arr=sne(),srr=cne();function lrr(e,t,r){return t===t?srr(e,t,r):orr(e,arr,r)}une.exports=lrr});var pne=H((gZn,fne)=>{var crr=hne();function urr(e,t){var r=e==null?0:e.length;return!!r&&crr(e,t,0)>-1}fne.exports=urr});var mne=H((_Zn,dne)=>{function hrr(e,t,r){for(var n=-1,i=e==null?0:e.length;++n<i;)if(r(t,e[n]))return!0;return!1}dne.exports=hrr});var _ne=H((yZn,gne)=>{function frr(){}gne.exports=frr});var vne=H((vZn,yne)=>{var llt=Mst(),prr=_ne(),drr=KB(),mrr=1/0,grr=llt&&1/drr(new llt([,-0]))[1]==mrr?function(e){return new llt(e)}:prr;yne.exports=grr});var bne=H((xZn,xne)=>{var _rr=Fst(),yrr=pne(),vrr=mne(),xrr=Bst(),brr=vne(),wrr=KB(),Srr=200;function Mrr(e,t,r){var n=-1,i=yrr,o=e.length,a=!0,s=[],l=s;if(r)a=!1,i=vrr;else if(o>=Srr){var c=t?null:brr(e);if(c)return wrr(c);a=!1,i=xrr,l=new _rr}else l=t?[]:s;t:for(;++n<o;){var u=e[n],h=t?t(u):u;if(u=r||u!==0?u:0,a&&h===h){for(var f=l.length;f--;)if(l[f]===h)continue t;t&&l.push(h),s.push(u)}else i(l,h,r)||(l!==s&&l.push(h),s.push(u))}return s}xne.exports=Mrr});var clt=H((bZn,wne)=>{var Err=Bf(),Trr=Yu();function Crr(e){return Trr(e)&&Err(e)}wne.exports=Crr});var Mne=H((wZn,Sne)=>{var Arr=QB(),Prr=q4(),Irr=bne(),Lrr=clt(),krr=Prr(function(e){return Irr(Arr(e,1,Lrr,!0))});Sne.exports=krr});var Tne=H((SZn,Ene)=>{var Rrr=H4();function Nrr(e,t){return Rrr(t,function(r){return e[r]})}Ene.exports=Nrr});var ult=H((MZn,Cne)=>{var Drr=Tne(),Orr=Ad();function zrr(e){return e==null?[]:Drr(e,Orr(e))}Cne.exports=zrr});var El=H((EZn,Ane)=>{var tH;if(typeof Ex=="function")try{tH={clone:Cte(),constant:YB(),each:zst(),filter:Zst(),has:Jst(),isArray:Ti(),isEmpty:fre(),isFunction:FS(),isUndefined:Qst(),keys:Ad(),map:elt(),reduce:rlt(),size:Bre(),transform:Vre(),union:Mne(),values:ult()}}catch(e){}tH||(tH=window._);Ane.exports=tH});var eH=H((CZn,kne)=>{"use strict";var je=El();kne.exports=cr;var Frr="\0",J1="\0",Pne="";function cr(e){this._isDirected=je.has(e,"directed")?e.directed:!0,this._isMultigraph=je.has(e,"multigraph")?e.multigraph:!1,this._isCompound=je.has(e,"compound")?e.compound:!1,this._label=void 0,this._defaultNodeLabelFn=je.constant(void 0),this._defaultEdgeLabelFn=je.constant(void 0),this._nodes={},this._isCompound&&(this._parent={},this._children={},this._children[J1]={}),this._in={},this._preds={},this._out={},this._sucs={},this._edgeObjs={},this._edgeLabels={}}cr.prototype._nodeCount=0;cr.prototype._edgeCount=0;cr.prototype.isDirected=function(){return this._isDirected};cr.prototype.isMultigraph=function(){return this._isMultigraph};cr.prototype.isCompound=function(){return this._isCompound};cr.prototype.setGraph=function(e){return this._label=e,this};cr.prototype.graph=function(){return this._label};cr.prototype.setDefaultNodeLabel=function(e){return je.isFunction(e)||(e=je.constant(e)),this._defaultNodeLabelFn=e,this};cr.prototype.nodeCount=function(){return this._nodeCount};cr.prototype.nodes=function(){return je.keys(this._nodes)};cr.prototype.sources=function(){var e=this;return je.filter(this.nodes(),function(t){return je.isEmpty(e._in[t])})};cr.prototype.sinks=function(){var e=this;return je.filter(this.nodes(),function(t){return je.isEmpty(e._out[t])})};cr.prototype.setNodes=function(e,t){var r=arguments,n=this;return je.each(e,function(i){r.length>1?n.setNode(i,t):n.setNode(i)}),this};cr.prototype.setNode=function(e,t){return je.has(this._nodes,e)?(arguments.length>1&&(this._nodes[e]=t),this):(this._nodes[e]=arguments.length>1?t:this._defaultNodeLabelFn(e),this._isCompound&&(this._parent[e]=J1,this._children[e]={},this._children[J1][e]=!0),this._in[e]={},this._preds[e]={},this._out[e]={},this._sucs[e]={},++this._nodeCount,this)};cr.prototype.node=function(e){return this._nodes[e]};cr.prototype.hasNode=function(e){return je.has(this._nodes,e)};cr.prototype.removeNode=function(e){var t=this;if(je.has(this._nodes,e)){var r=function(n){t.removeEdge(t._edgeObjs[n])};delete this._nodes[e],this._isCompound&&(this._removeFromParentsChildList(e),delete this._parent[e],je.each(this.children(e),function(n){t.setParent(n)}),delete this._children[e]),je.each(je.keys(this._in[e]),r),delete this._in[e],delete this._preds[e],je.each(je.keys(this._out[e]),r),delete this._out[e],delete this._sucs[e],--this._nodeCount}return this};cr.prototype.setParent=function(e,t){if(!this._isCompound)throw new Error("Cannot set parent in a non-compound graph");if(je.isUndefined(t))t=J1;else{t+="";for(var r=t;!je.isUndefined(r);r=this.parent(r))if(r===e)throw new Error("Setting "+t+" as parent of "+e+" would create a cycle");this.setNode(t)}return this.setNode(e),this._removeFromParentsChildList(e),this._parent[e]=t,this._children[t][e]=!0,this};cr.prototype._removeFromParentsChildList=function(e){delete this._children[this._parent[e]][e]};cr.prototype.parent=function(e){if(this._isCompound){var t=this._parent[e];if(t!==J1)return t}};cr.prototype.children=function(e){if(je.isUndefined(e)&&(e=J1),this._isCompound){var t=this._children[e];if(t)return je.keys(t)}else{if(e===J1)return this.nodes();if(this.hasNode(e))return[]}};cr.prototype.predecessors=function(e){var t=this._preds[e];if(t)return je.keys(t)};cr.prototype.successors=function(e){var t=this._sucs[e];if(t)return je.keys(t)};cr.prototype.neighbors=function(e){var t=this.predecessors(e);if(t)return je.union(t,this.successors(e))};cr.prototype.isLeaf=function(e){var t;return this.isDirected()?t=this.successors(e):t=this.neighbors(e),t.length===0};cr.prototype.filterNodes=function(e){var t=new this.constructor({directed:this._isDirected,multigraph:this._isMultigraph,compound:this._isCompound});t.setGraph(this.graph());var r=this;je.each(this._nodes,function(o,a){e(a)&&t.setNode(a,o)}),je.each(this._edgeObjs,function(o){t.hasNode(o.v)&&t.hasNode(o.w)&&t.setEdge(o,r.edge(o))});var n={};function i(o){var a=r.parent(o);return a===void 0||t.hasNode(a)?(n[o]=a,a):a in n?n[a]:i(a)}return this._isCompound&&je.each(t.nodes(),function(o){t.setParent(o,i(o))}),t};cr.prototype.setDefaultEdgeLabel=function(e){return je.isFunction(e)||(e=je.constant(e)),this._defaultEdgeLabelFn=e,this};cr.prototype.edgeCount=function(){return this._edgeCount};cr.prototype.edges=function(){return je.values(this._edgeObjs)};cr.prototype.setPath=function(e,t){var r=this,n=arguments;return je.reduce(e,function(i,o){return n.length>1?r.setEdge(i,o,t):r.setEdge(i,o),o}),this};cr.prototype.setEdge=function(){var e,t,r,n,i=!1,o=arguments[0];typeof o=="object"&&o!==null&&"v"in o?(e=o.v,t=o.w,r=o.name,arguments.length===2&&(n=arguments[1],i=!0)):(e=o,t=arguments[1],r=arguments[3],arguments.length>2&&(n=arguments[2],i=!0)),e=""+e,t=""+t,je.isUndefined(r)||(r=""+r);var a=G4(this._isDirected,e,t,r);if(je.has(this._edgeLabels,a))return i&&(this._edgeLabels[a]=n),this;if(!je.isUndefined(r)&&!this._isMultigraph)throw new Error("Cannot set a named edge when isMultigraph = false");this.setNode(e),this.setNode(t),this._edgeLabels[a]=i?n:this._defaultEdgeLabelFn(e,t,r);var s=Brr(this._isDirected,e,t,r);return e=s.v,t=s.w,Object.freeze(s),this._edgeObjs[a]=s,Ine(this._preds[t],e),Ine(this._sucs[e],t),this._in[t][a]=s,this._out[e][a]=s,this._edgeCount++,this};cr.prototype.edge=function(e,t,r){var n=arguments.length===1?hlt(this._isDirected,arguments[0]):G4(this._isDirected,e,t,r);return this._edgeLabels[n]};cr.prototype.hasEdge=function(e,t,r){var n=arguments.length===1?hlt(this._isDirected,arguments[0]):G4(this._isDirected,e,t,r);return je.has(this._edgeLabels,n)};cr.prototype.removeEdge=function(e,t,r){var n=arguments.length===1?hlt(this._isDirected,arguments[0]):G4(this._isDirected,e,t,r),i=this._edgeObjs[n];return i&&(e=i.v,t=i.w,delete this._edgeLabels[n],delete this._edgeObjs[n],Lne(this._preds[t],e),Lne(this._sucs[e],t),delete this._in[t][n],delete this._out[e][n],this._edgeCount--),this};cr.prototype.inEdges=function(e,t){var r=this._in[e];if(r){var n=je.values(r);return t?je.filter(n,function(i){return i.v===t}):n}};cr.prototype.outEdges=function(e,t){var r=this._out[e];if(r){var n=je.values(r);return t?je.filter(n,function(i){return i.w===t}):n}};cr.prototype.nodeEdges=function(e,t){var r=this.inEdges(e,t);if(r)return r.concat(this.outEdges(e,t))};function Ine(e,t){e[t]?e[t]++:e[t]=1}function Lne(e,t){--e[t]||delete e[t]}function G4(e,t,r,n){var i=""+t,o=""+r;if(!e&&i>o){var a=i;i=o,o=a}return i+Pne+o+Pne+(je.isUndefined(n)?Frr:n)}function Brr(e,t,r,n){var i=""+t,o=""+r;if(!e&&i>o){var a=i;i=o,o=a}var s={v:i,w:o};return n&&(s.name=n),s}function hlt(e,t){return G4(e,t.v,t.w,t.name)}});var Nne=H((AZn,Rne)=>{Rne.exports="2.1.8"});var One=H((PZn,Dne)=>{Dne.exports={Graph:eH(),version:Nne()}});var Fne=H((IZn,zne)=>{var Vf=El(),Hrr=eH();zne.exports={write:Vrr,read:Grr};function Vrr(e){var t={options:{directed:e.isDirected(),multigraph:e.isMultigraph(),compound:e.isCompound()},nodes:Urr(e),edges:qrr(e)};return Vf.isUndefined(e.graph())||(t.value=Vf.clone(e.graph())),t}function Urr(e){return Vf.map(e.nodes(),function(t){var r=e.node(t),n=e.parent(t),i={v:t};return Vf.isUndefined(r)||(i.value=r),Vf.isUndefined(n)||(i.parent=n),i})}function qrr(e){return Vf.map(e.edges(),function(t){var r=e.edge(t),n={v:t.v,w:t.w};return Vf.isUndefined(t.name)||(n.name=t.name),Vf.isUndefined(r)||(n.value=r),n})}function Grr(e){var t=new Hrr(e.options).setGraph(e.value);return Vf.each(e.nodes,function(r){t.setNode(r.v,r.value),r.parent&&t.setParent(r.v,r.parent)}),Vf.each(e.edges,function(r){t.setEdge({v:r.v,w:r.w,name:r.name},r.value)}),t}});var Hne=H((LZn,Bne)=>{var rH=El();Bne.exports=Wrr;function Wrr(e){var t={},r=[],n;function i(o){rH.has(t,o)||(t[o]=!0,n.push(o),rH.each(e.successors(o),i),rH.each(e.predecessors(o),i))}return rH.each(e.nodes(),function(o){n=[],i(o),n.length&&r.push(n)}),r}});var flt=H((kZn,Une)=>{var Vne=El();Une.exports=Vc;function Vc(){this._arr=[],this._keyIndices={}}Vc.prototype.size=function(){return this._arr.length};Vc.prototype.keys=function(){return this._arr.map(function(e){return e.key})};Vc.prototype.has=function(e){return Vne.has(this._keyIndices,e)};Vc.prototype.priority=function(e){var t=this._keyIndices[e];if(t!==void 0)return this._arr[t].priority};Vc.prototype.min=function(){if(this.size()===0)throw new Error("Queue underflow");return this._arr[0].key};Vc.prototype.add=function(e,t){var r=this._keyIndices;if(e=String(e),!Vne.has(r,e)){var n=this._arr,i=n.length;return r[e]=i,n.push({key:e,priority:t}),this._decrease(i),!0}return!1};Vc.prototype.removeMin=function(){this._swap(0,this._arr.length-1);var e=this._arr.pop();return delete this._keyIndices[e.key],this._heapify(0),e.key};Vc.prototype.decrease=function(e,t){var r=this._keyIndices[e];if(t>this._arr[r].priority)throw new Error("New priority is greater than current priority. Key: "+e+" Old: "+this._arr[r].priority+" New: "+t);this._arr[r].priority=t,this._decrease(r)};Vc.prototype._heapify=function(e){var t=this._arr,r=2*e,n=r+1,i=e;r<t.length&&(i=t[r].priority<t[i].priority?r:i,n<t.length&&(i=t[n].priority<t[i].priority?n:i),i!==e&&(this._swap(e,i),this._heapify(i)))};Vc.prototype._decrease=function(e){for(var t=this._arr,r=t[e].priority,n;e!==0&&(n=e>>1,!(t[n].priority<r));)this._swap(e,n),e=n};Vc.prototype._swap=function(e,t){var r=this._arr,n=this._keyIndices,i=r[e],o=r[t];r[e]=o,r[t]=i,n[o.key]=e,n[i.key]=t}});var plt=H((RZn,qne)=>{var Yrr=El(),jrr=flt();qne.exports=$rr;var Xrr=Yrr.constant(1);function $rr(e,t,r,n){return Krr(e,String(t),r||Xrr,n||function(i){return e.outEdges(i)})}function Krr(e,t,r,n){var i={},o=new jrr,a,s,l=function(c){var u=c.v!==a?c.v:c.w,h=i[u],f=r(c),p=s.distance+f;if(f<0)throw new Error("dijkstra does not allow negative edge weights. Bad edge: "+c+" Weight: "+f);p<h.distance&&(h.distance=p,h.predecessor=a,o.decrease(u,p))};for(e.nodes().forEach(function(c){var u=c===t?0:Number.POSITIVE_INFINITY;i[c]={distance:u},o.add(c,u)});o.size()>0&&(a=o.removeMin(),s=i[a],s.distance!==Number.POSITIVE_INFINITY);)n(a).forEach(l);return i}});var Wne=H((NZn,Gne)=>{var Zrr=plt(),Jrr=El();Gne.exports=Qrr;function Qrr(e,t,r){return Jrr.transform(e.nodes(),function(n,i){n[i]=Zrr(e,i,t,r)},{})}});var dlt=H((DZn,jne)=>{var Yne=El();jne.exports=tnr;function tnr(e){var t=0,r=[],n={},i=[];function o(a){var s=n[a]={onStack:!0,lowlink:t,index:t++};if(r.push(a),e.successors(a).forEach(function(u){Yne.has(n,u)?n[u].onStack&&(s.lowlink=Math.min(s.lowlink,n[u].index)):(o(u),s.lowlink=Math.min(s.lowlink,n[u].lowlink))}),s.lowlink===s.index){var l=[],c;do c=r.pop(),n[c].onStack=!1,l.push(c);while(a!==c);i.push(l)}}return e.nodes().forEach(function(a){Yne.has(n,a)||o(a)}),i}});var $ne=H((OZn,Xne)=>{var enr=El(),rnr=dlt();Xne.exports=nnr;function nnr(e){return enr.filter(rnr(e),function(t){return t.length>1||t.length===1&&e.hasEdge(t[0],t[0])})}});var Zne=H((zZn,Kne)=>{var inr=El();Kne.exports=anr;var onr=inr.constant(1);function anr(e,t,r){return snr(e,t||onr,r||function(n){return e.outEdges(n)})}function snr(e,t,r){var n={},i=e.nodes();return i.forEach(function(o){n[o]={},n[o][o]={distance:0},i.forEach(function(a){o!==a&&(n[o][a]={distance:Number.POSITIVE_INFINITY})}),r(o).forEach(function(a){var s=a.v===o?a.w:a.v,l=t(a);n[o][s]={distance:l,predecessor:o}})}),i.forEach(function(o){var a=n[o];i.forEach(function(s){var l=n[s];i.forEach(function(c){var u=l[o],h=a[c],f=l[c],p=u.distance+h.distance;p<f.distance&&(f.distance=p,f.predecessor=h.predecessor)})})}),n}});var mlt=H((FZn,Qne)=>{var W4=El();Qne.exports=Jne;Jne.CycleException=nH;function Jne(e){var t={},r={},n=[];function i(o){if(W4.has(r,o))throw new nH;W4.has(t,o)||(r[o]=!0,t[o]=!0,W4.each(e.predecessors(o),i),delete r[o],n.push(o))}if(W4.each(e.sinks(),i),W4.size(t)!==e.nodeCount())throw new nH;return n}function nH(){}nH.prototype=new Error});var rie=H((BZn,eie)=>{var tie=mlt();eie.exports=lnr;function lnr(e){try{tie(e)}catch(t){if(t instanceof tie.CycleException)return!1;throw t}return!0}});var glt=H((HZn,iie)=>{var iH=El();iie.exports=cnr;function cnr(e,t,r){iH.isArray(t)||(t=[t]);var n=(e.isDirected()?e.successors:e.neighbors).bind(e),i=[],o={};return iH.each(t,function(a){if(!e.hasNode(a))throw new Error("Graph does not have node: "+a);nie(e,a,r==="post",o,n,i)}),i}function nie(e,t,r,n,i,o){iH.has(n,t)||(n[t]=!0,r||o.push(t),iH.each(i(t),function(a){nie(e,a,r,n,i,o)}),r&&o.push(t))}});var aie=H((VZn,oie)=>{var unr=glt();oie.exports=hnr;function hnr(e,t){return unr(e,t,"post")}});var lie=H((UZn,sie)=>{var fnr=glt();sie.exports=pnr;function pnr(e,t){return fnr(e,t,"pre")}});var hie=H((qZn,uie)=>{var cie=El(),dnr=eH(),mnr=flt();uie.exports=gnr;function gnr(e,t){var r=new dnr,n={},i=new mnr,o;function a(l){var c=l.v===o?l.w:l.v,u=i.priority(c);if(u!==void 0){var h=t(l);h<u&&(n[c]=o,i.decrease(c,h))}}if(e.nodeCount()===0)return r;cie.each(e.nodes(),function(l){i.add(l,Number.POSITIVE_INFINITY),r.setNode(l)}),i.decrease(e.nodes()[0],0);for(var s=!1;i.size()>0;){if(o=i.removeMin(),cie.has(n,o))r.setEdge(o,n[o]);else{if(s)throw new Error("Input graph is not connected: "+e);s=!0}e.nodeEdges(o).forEach(a)}return r}});var pie=H((GZn,fie)=>{fie.exports={components:Hne(),dijkstra:plt(),dijkstraAll:Wne(),findCycles:$ne(),floydWarshall:Zne(),isAcyclic:rie(),postorder:aie(),preorder:lie(),prim:hie(),tarjan:dlt(),topsort:mlt()}});var gie=H((WZn,mie)=>{var die=One();mie.exports={Graph:die.Graph,json:Fne(),alg:pie(),version:die.version}});var Uc=H((YZn,_ie)=>{var oH;if(typeof Ex=="function")try{oH=gie()}catch(e){}oH||(oH=window.graphlib);_ie.exports=oH});var vie=H((XZn,yie)=>{var _nr=Nst(),ynr=1,vnr=4;function xnr(e){return _nr(e,ynr|vnr)}yie.exports=xnr});var Y4=H(($Zn,xie)=>{var bnr=Y1(),wnr=Bf(),Snr=k4(),Mnr=Ml();function Enr(e,t,r){if(!Mnr(r))return!1;var n=typeof t;return(n=="number"?wnr(r)&&Snr(t,r.length):n=="string"&&t in r)?bnr(r[t],e):!1}xie.exports=Enr});var Sie=H((KZn,wie)=>{var Tnr=q4(),Cnr=Y1(),Anr=Y4(),Pnr=c0(),bie=Object.prototype,Inr=bie.hasOwnProperty,Lnr=Tnr(function(e,t){e=Object(e);var r=-1,n=t.length,i=n>2?t[2]:void 0;for(i&&Anr(t[0],t[1],i)&&(n=1);++r<n;)for(var o=t[r],a=Pnr(o),s=-1,l=a.length;++s<l;){var c=a[s],u=e[c];(u===void 0||Cnr(u,bie[c])&&!Inr.call(e,c))&&(e[c]=o[c])}return e});wie.exports=Lnr});var Eie=H((ZZn,Mie)=>{var knr=Hf(),Rnr=Bf(),Nnr=Ad();function Dnr(e){return function(t,r,n){var i=Object(t);if(!Rnr(t)){var o=knr(r,3);t=Nnr(t),r=function(s){return o(i[s],s,i)}}var a=e(t,r,n);return a>-1?i[o?t[a]:a]:void 0}}Mie.exports=Dnr});var Cie=H((JZn,Tie)=>{var Onr=/\s/;function znr(e){for(var t=e.length;t--&&Onr.test(e.charAt(t)););return t}Tie.exports=znr});var Pie=H((QZn,Aie)=>{var Fnr=Cie(),Bnr=/^\s+/;function Hnr(e){return e&&e.slice(0,Fnr(e)+1).replace(Bnr,"")}Aie.exports=Hnr});var Rie=H((tJn,kie)=>{var Vnr=Pie(),Iie=Ml(),Unr=Z1(),Lie=0/0,qnr=/^[-+]0x[0-9a-f]+$/i,Gnr=/^0b[01]+$/i,Wnr=/^0o[0-7]+$/i,Ynr=parseInt;function jnr(e){if(typeof e=="number")return e;if(Unr(e))return Lie;if(Iie(e)){var t=typeof e.valueOf=="function"?e.valueOf():e;e=Iie(t)?t+"":t}if(typeof e!="string")return e===0?e:+e;e=Vnr(e);var r=Gnr.test(e);return r||Wnr.test(e)?Ynr(e.slice(2),r?2:8):qnr.test(e)?Lie:+e}kie.exports=jnr});var _lt=H((eJn,Die)=>{var Xnr=Rie(),Nie=1/0,$nr=17976931348623157e292;function Knr(e){if(!e)return e===0?e:0;if(e=Xnr(e),e===Nie||e===-Nie){var t=e<0?-1:1;return t*$nr}return e===e?e:0}Die.exports=Knr});var zie=H((rJn,Oie)=>{var Znr=_lt();function Jnr(e){var t=Znr(e),r=t%1;return t===t?r?t-r:t:0}Oie.exports=Jnr});var Bie=H((nJn,Fie)=>{var Qnr=slt(),tir=Hf(),eir=zie(),rir=Math.max;function nir(e,t,r){var n=e==null?0:e.length;if(!n)return-1;var i=r==null?0:eir(r);return i<0&&(i=rir(n+i,0)),Qnr(e,tir(t,3),i)}Fie.exports=nir});var Vie=H((iJn,Hie)=>{var iir=Eie(),oir=Bie(),air=iir(oir);Hie.exports=air});var ylt=H((oJn,Uie)=>{var sir=QB();function lir(e){var t=e==null?0:e.length;return t?sir(e,1):[]}Uie.exports=lir});var Gie=H((aJn,qie)=>{var cir=jB(),uir=Dst(),hir=c0();function fir(e,t){return e==null?e:cir(e,uir(t),hir)}qie.exports=fir});var Yie=H((sJn,Wie)=>{function pir(e){var t=e==null?0:e.length;return t?e[t-1]:void 0}Wie.exports=pir});var Xie=H((lJn,jie)=>{var dir=P4(),mir=XB(),gir=Hf();function _ir(e,t){var r={};return t=gir(t,3),mir(e,function(n,i,o){dir(r,i,t(n,i,o))}),r}jie.exports=_ir});var aH=H((cJn,$ie)=>{var yir=Z1();function vir(e,t,r){for(var n=-1,i=e.length;++n<i;){var o=e[n],a=t(o);if(a!=null&&(s===void 0?a===a&&!yir(a):r(a,s)))var s=a,l=o}return l}$ie.exports=vir});var Zie=H((uJn,Kie)=>{function xir(e,t){return e>t}Kie.exports=xir});var Qie=H((hJn,Jie)=>{var bir=aH(),wir=Zie(),Sir=u0();function Mir(e){return e&&e.length?bir(e,Sir,wir):void 0}Jie.exports=Mir});var vlt=H((fJn,toe)=>{var Eir=P4(),Tir=Y1();function Cir(e,t,r){(r!==void 0&&!Tir(e[t],r)||r===void 0&&!(t in e))&&Eir(e,t,r)}toe.exports=Cir});var noe=H((pJn,roe)=>{var Air=s0(),Pir=F4(),Iir=Yu(),Lir="[object Object]",kir=Function.prototype,Rir=Object.prototype,eoe=kir.toString,Nir=Rir.hasOwnProperty,Dir=eoe.call(Object);function Oir(e){if(!Iir(e)||Air(e)!=Lir)return!1;var t=Pir(e);if(t===null)return!0;var r=Nir.call(t,"constructor")&&t.constructor;return typeof r=="function"&&r instanceof r&&eoe.call(r)==Dir}roe.exports=Oir});var xlt=H((dJn,ioe)=>{function zir(e,t){if(!(t==="constructor"&&typeof e[t]=="function")&&t!="__proto__")return e[t]}ioe.exports=zir});var aoe=H((mJn,ooe)=>{var Fir=US(),Bir=c0();function Hir(e){return Fir(e,Bir(e))}ooe.exports=Hir});var foe=H((gJn,hoe)=>{var soe=vlt(),Vir=_st(),Uir=Lst(),qir=yst(),Gir=Rst(),loe=qS(),coe=Ti(),Wir=clt(),Yir=X1(),jir=FS(),Xir=Ml(),$ir=noe(),Kir=YS(),uoe=xlt(),Zir=aoe();function Jir(e,t,r,n,i,o,a){var s=uoe(e,r),l=uoe(t,r),c=a.get(l);if(c){soe(e,r,c);return}var u=o?o(s,l,r+"",e,t,a):void 0,h=u===void 0;if(h){var f=coe(l),p=!f&&Yir(l),d=!f&&!p&&Kir(l);u=l,f||p||d?coe(s)?u=s:Wir(s)?u=qir(s):p?(h=!1,u=Vir(l,!0)):d?(h=!1,u=Uir(l,!0)):u=[]:$ir(l)||loe(l)?(u=s,loe(s)?u=Zir(s):(!Xir(s)||jir(s))&&(u=Gir(l))):h=!1}h&&(a.set(l,u),i(u,l,n,o,a),a.delete(l)),soe(e,r,u)}hoe.exports=Jir});var moe=H((_Jn,doe)=>{var Qir=A4(),tor=vlt(),eor=jB(),ror=foe(),nor=Ml(),ior=c0(),oor=xlt();function poe(e,t,r,n,i){e!==t&&eor(t,function(o,a){if(i||(i=new Qir),nor(o))ror(e,t,a,r,poe,n,i);else{var s=n?n(oor(e,a),o,a+"",e,t,i):void 0;s===void 0&&(s=o),tor(e,a,s)}},ior)}doe.exports=poe});var _oe=H((yJn,goe)=>{var aor=q4(),sor=Y4();function lor(e){return aor(function(t,r){var n=-1,i=r.length,o=i>1?r[i-1]:void 0,a=i>2?r[2]:void 0;for(o=e.length>3&&typeof o=="function"?(i--,o):void 0,a&&sor(r[0],r[1],a)&&(o=i<3?void 0:o,i=1),t=Object(t);++n<i;){var s=r[n];s&&e(t,s,n,o)}return t})}goe.exports=lor});var voe=H((vJn,yoe)=>{var cor=moe(),uor=_oe(),hor=uor(function(e,t,r){cor(e,t,r)});yoe.exports=hor});var blt=H((xJn,xoe)=>{function por(e,t){return e<t}xoe.exports=por});var woe=H((bJn,boe)=>{var dor=aH(),mor=blt(),gor=u0();function _or(e){return e&&e.length?dor(e,gor,mor):void 0}boe.exports=_or});var Moe=H((wJn,Soe)=>{var yor=aH(),vor=Hf(),xor=blt();function bor(e,t){return e&&e.length?yor(e,vor(t,2),xor):void 0}Soe.exports=bor});var Toe=H((SJn,Eoe)=>{var wor=Hc(),Sor=function(){return wor.Date.now()};Eoe.exports=Sor});var Poe=H((MJn,Aoe)=>{var Mor=I4(),Eor=V4(),Tor=k4(),Coe=Ml(),Cor=$S();function Aor(e,t,r,n){if(!Coe(e))return e;t=Eor(t,e);for(var i=-1,o=t.length,a=o-1,s=e;s!=null&&++i<o;){var l=Cor(t[i]),c=r;if(l==="__proto__"||l==="constructor"||l==="prototype")return e;if(i!=a){var u=s[l];c=n?n(u,l,s):void 0,c===void 0&&(c=Coe(u)?u:Tor(t[i+1])?[]:{})}Mor(s,l,c),s=s[l]}return e}Aoe.exports=Aor});var Loe=H((EJn,Ioe)=>{var Por=U4(),Ior=Poe(),Lor=V4();function kor(e,t,r){for(var n=-1,i=t.length,o={};++n<i;){var a=t[n],s=Por(e,a);r(s,a)&&Ior(o,Lor(a,e),s)}return o}Ioe.exports=kor});var Roe=H((TJn,koe)=>{var Ror=Loe(),Nor=$st();function Dor(e,t){return Ror(e,t,function(r,n){return Nor(e,n)})}koe.exports=Dor});var Doe=H((CJn,Noe)=>{var Oor=ylt(),zor=olt(),For=alt();function Bor(e){return For(zor(e,void 0,Oor),e+"")}Noe.exports=Bor});var zoe=H((AJn,Ooe)=>{var Hor=Roe(),Vor=Doe(),Uor=Vor(function(e,t){return e==null?{}:Hor(e,t)});Ooe.exports=Uor});var Boe=H((PJn,Foe)=>{var qor=Math.ceil,Gor=Math.max;function Wor(e,t,r,n){for(var i=-1,o=Gor(qor((t-e)/(r||1)),0),a=Array(o);o--;)a[n?o:++i]=e,e+=r;return a}Foe.exports=Wor});var Voe=H((IJn,Hoe)=>{var Yor=Boe(),jor=Y4(),wlt=_lt();function Xor(e){return function(t,r,n){return n&&typeof n!="number"&&jor(t,r,n)&&(r=n=void 0),t=wlt(t),r===void 0?(r=t,t=0):r=wlt(r),n=n===void 0?t<r?1:-1:wlt(n),Yor(t,r,n,e)}}Hoe.exports=Xor});var qoe=H((LJn,Uoe)=>{var $or=Voe(),Kor=$or();Uoe.exports=Kor});var Woe=H((kJn,Goe)=>{function Zor(e,t){var r=e.length;for(e.sort(t);r--;)e[r]=e[r].value;return e}Goe.exports=Zor});var Xoe=H((RJn,joe)=>{var Yoe=Z1();function Jor(e,t){if(e!==t){var r=e!==void 0,n=e===null,i=e===e,o=Yoe(e),a=t!==void 0,s=t===null,l=t===t,c=Yoe(t);if(!s&&!c&&!o&&e>t||o&&a&&l&&!s&&!c||n&&a&&l||!r&&l||!i)return 1;if(!n&&!o&&!c&&e<t||c&&r&&i&&!n&&!o||s&&r&&i||!a&&i||!l)return-1}return 0}joe.exports=Jor});var Koe=H((NJn,$oe)=>{var Qor=Xoe();function tar(e,t,r){for(var n=-1,i=e.criteria,o=t.criteria,a=i.length,s=r.length;++n<a;){var l=Qor(i[n],o[n]);if(l){if(n>=s)return l;var c=r[n];return l*(c=="desc"?-1:1)}}return e.index-t.index}$oe.exports=tar});var Joe=H((DJn,Zoe)=>{var Slt=H4(),ear=U4(),rar=Hf(),nar=tlt(),iar=Woe(),oar=R4(),aar=Koe(),sar=u0(),lar=Ti();function car(e,t,r){t.length?t=Slt(t,function(o){return lar(o)?function(a){return ear(a,o.length===1?o[0]:o)}:o}):t=[sar];var n=-1;t=Slt(t,oar(rar));var i=nar(e,function(o,a,s){var l=Slt(t,function(c){return c(o)});return{criteria:l,index:++n,value:o}});return iar(i,function(o,a){return aar(o,a,r)})}Zoe.exports=car});var eae=H((OJn,tae)=>{var uar=QB(),har=Joe(),far=q4(),Qoe=Y4(),par=far(function(e,t){if(e==null)return[];var r=t.length;return r>1&&Qoe(e,t[0],t[1])?t=[]:r>2&&Qoe(t[0],t[1],t[2])&&(t=[t[0]]),har(e,uar(t,1),[])});tae.exports=par});var nae=H((zJn,rae)=>{var dar=jst(),mar=0;function gar(e){var t=++mar;return dar(e)+t}rae.exports=gar});var oae=H((FJn,iae)=>{function _ar(e,t,r){for(var n=-1,i=e.length,o=t.length,a={};++n<i;){var s=n<o?t[n]:void 0;r(a,e[n],s)}return a}iae.exports=_ar});var sae=H((BJn,aae)=>{var yar=I4(),xar=oae();function bar(e,t){return xar(e||[],t||[],yar)}aae.exports=bar});var qn=H((HJn,lae)=>{var sH;if(typeof Ex=="function")try{sH={cloneDeep:vie(),constant:YB(),defaults:Sie(),each:zst(),filter:Zst(),find:Vie(),flatten:ylt(),forEach:Ost(),forIn:Gie(),has:Jst(),isUndefined:Qst(),last:Yie(),map:elt(),mapValues:Xie(),max:Qie(),merge:voe(),min:woe(),minBy:Moe(),now:Toe(),pick:zoe(),range:qoe(),reduce:rlt(),sortBy:eae(),uniqueId:nae(),values:ult(),zipObject:sae()}}catch(e){}sH||(sH=window._);lae.exports=sH});var hae=H((UJn,uae)=>{uae.exports=lH;function lH(){var e={};e._next=e._prev=e,this._sentinel=e}lH.prototype.dequeue=function(){var e=this._sentinel,t=e._prev;if(t!==e)return cae(t),t};lH.prototype.enqueue=function(e){var t=this._sentinel;e._prev&&e._next&&cae(e),e._next=t._next,t._next._prev=e,t._next=e,e._prev=t};lH.prototype.toString=function(){for(var e=[],t=this._sentinel,r=t._prev;r!==t;)e.push(JSON.stringify(r,war)),r=r._prev;return"["+e.join(", ")+"]"};function cae(e){e._prev._next=e._next,e._next._prev=e._prev,delete e._next,delete e._prev}function war(e,t){if(e!=="_next"&&e!=="_prev")return t}});var pae=H((qJn,fae)=>{var Pd=qn(),Sar=Uc().Graph,Mar=hae();fae.exports=Tar;var Ear=Pd.constant(1);function Tar(e,t){if(e.nodeCount()<=1)return[];var r=Aar(e,t||Ear),n=Car(r.graph,r.buckets,r.zeroIdx);return Pd.flatten(Pd.map(n,function(i){return e.outEdges(i.v,i.w)}),!0)}function Car(e,t,r){for(var n=[],i=t[t.length-1],o=t[0],a;e.nodeCount();){for(;a=o.dequeue();)Mlt(e,t,r,a);for(;a=i.dequeue();)Mlt(e,t,r,a);if(e.nodeCount()){for(var s=t.length-2;s>0;--s)if(a=t[s].dequeue(),a){n=n.concat(Mlt(e,t,r,a,!0));break}}}return n}function Mlt(e,t,r,n,i){var o=i?[]:void 0;return Pd.forEach(e.inEdges(n.v),function(a){var s=e.edge(a),l=e.node(a.v);i&&o.push({v:a.v,w:a.w}),l.out-=s,Elt(t,r,l)}),Pd.forEach(e.outEdges(n.v),function(a){var s=e.edge(a),l=a.w,c=e.node(l);c.in-=s,Elt(t,r,c)}),e.removeNode(n.v),o}function Aar(e,t){var r=new Sar,n=0,i=0;Pd.forEach(e.nodes(),function(s){r.setNode(s,{v:s,in:0,out:0})}),Pd.forEach(e.edges(),function(s){var l=r.edge(s.v,s.w)||0,c=t(s),u=l+c;r.setEdge(s.v,s.w,u),i=Math.max(i,r.node(s.v).out+=c),n=Math.max(n,r.node(s.w).in+=c)});var o=Pd.range(i+n+3).map(function(){return new Mar}),a=n+1;return Pd.forEach(r.nodes(),function(s){Elt(o,a,r.node(s))}),{graph:r,buckets:o,zeroIdx:a}}function Elt(e,t,r){r.out?r.in?e[r.out-r.in+t].enqueue(r):e[e.length-1].enqueue(r):e[0].enqueue(r)}});var mae=H((GJn,dae)=>{"use strict";var Q1=qn(),Par=pae();dae.exports={run:Iar,undo:kar};function Iar(e){var t=e.graph().acyclicer==="greedy"?Par(e,r(e)):Lar(e);Q1.forEach(t,function(n){var i=e.edge(n);e.removeEdge(n),i.forwardName=n.name,i.reversed=!0,e.setEdge(n.w,n.v,i,Q1.uniqueId("rev"))});function r(n){return function(i){return n.edge(i).weight}}}function Lar(e){var t=[],r={},n={};function i(o){Q1.has(n,o)||(n[o]=!0,r[o]=!0,Q1.forEach(e.outEdges(o),function(a){Q1.has(r,a.w)?t.push(a):i(a.w)}),delete r[o])}return Q1.forEach(e.nodes(),i),t}function kar(e){Q1.forEach(e.edges(),function(t){var r=e.edge(t);if(r.reversed){e.removeEdge(t);var n=r.forwardName;delete r.reversed,delete r.forwardName,e.setEdge(t.w,t.v,r,n)}})}});var ns=H((WJn,vae)=>{"use strict";var Qr=qn(),gae=Uc().Graph;vae.exports={addDummyNode:_ae,simplify:Rar,asNonCompoundGraph:Nar,successorWeights:Dar,predecessorWeights:Oar,intersectRect:zar,buildLayerMatrix:Far,normalizeRanks:Bar,removeEmptyRanks:Har,addBorderNode:Var,maxRank:yae,partition:Uar,time:qar,notime:Gar};function _ae(e,t,r,n){var i;do i=Qr.uniqueId(n);while(e.hasNode(i));return r.dummy=t,e.setNode(i,r),i}function Rar(e){var t=new gae().setGraph(e.graph());return Qr.forEach(e.nodes(),function(r){t.setNode(r,e.node(r))}),Qr.forEach(e.edges(),function(r){var n=t.edge(r.v,r.w)||{weight:0,minlen:1},i=e.edge(r);t.setEdge(r.v,r.w,{weight:n.weight+i.weight,minlen:Math.max(n.minlen,i.minlen)})}),t}function Nar(e){var t=new gae({multigraph:e.isMultigraph()}).setGraph(e.graph());return Qr.forEach(e.nodes(),function(r){e.children(r).length||t.setNode(r,e.node(r))}),Qr.forEach(e.edges(),function(r){t.setEdge(r,e.edge(r))}),t}function Dar(e){var t=Qr.map(e.nodes(),function(r){var n={};return Qr.forEach(e.outEdges(r),function(i){n[i.w]=(n[i.w]||0)+e.edge(i).weight}),n});return Qr.zipObject(e.nodes(),t)}function Oar(e){var t=Qr.map(e.nodes(),function(r){var n={};return Qr.forEach(e.inEdges(r),function(i){n[i.v]=(n[i.v]||0)+e.edge(i).weight}),n});return Qr.zipObject(e.nodes(),t)}function zar(e,t){var r=e.x,n=e.y,i=t.x-r,o=t.y-n,a=e.width/2,s=e.height/2;if(!i&&!o)throw new Error("Not possible to find intersection inside of the rectangle");var l,c;return Math.abs(o)*a>Math.abs(i)*s?(o<0&&(s=-s),l=s*i/o,c=s):(i<0&&(a=-a),l=a,c=a*o/i),{x:r+l,y:n+c}}function Far(e){var t=Qr.map(Qr.range(yae(e)+1),function(){return[]});return Qr.forEach(e.nodes(),function(r){var n=e.node(r),i=n.rank;Qr.isUndefined(i)||(t[i][n.order]=r)}),t}function Bar(e){var t=Qr.min(Qr.map(e.nodes(),function(r){return e.node(r).rank}));Qr.forEach(e.nodes(),function(r){var n=e.node(r);Qr.has(n,"rank")&&(n.rank-=t)})}function Har(e){var t=Qr.min(Qr.map(e.nodes(),function(o){return e.node(o).rank})),r=[];Qr.forEach(e.nodes(),function(o){var a=e.node(o).rank-t;r[a]||(r[a]=[]),r[a].push(o)});var n=0,i=e.graph().nodeRankFactor;Qr.forEach(r,function(o,a){Qr.isUndefined(o)&&a%i!==0?--n:n&&Qr.forEach(o,function(s){e.node(s).rank+=n})})}function Var(e,t,r,n){var i={width:0,height:0};return arguments.length>=4&&(i.rank=r,i.order=n),_ae(e,"border",i,t)}function yae(e){return Qr.max(Qr.map(e.nodes(),function(t){var r=e.node(t).rank;if(!Qr.isUndefined(r))return r}))}function Uar(e,t){var r={lhs:[],rhs:[]};return Qr.forEach(e,function(n){t(n)?r.lhs.push(n):r.rhs.push(n)}),r}function qar(e,t){var r=Qr.now();try{return t()}finally{console.log(e+" time: "+(Qr.now()-r)+"ms")}}function Gar(e,t){return t()}});var wae=H((YJn,bae)=>{"use strict";var xae=qn(),War=ns();bae.exports={run:Yar,undo:Xar};function Yar(e){e.graph().dummyChains=[],xae.forEach(e.edges(),function(t){jar(e,t)})}function jar(e,t){var r=t.v,n=e.node(r).rank,i=t.w,o=e.node(i).rank,a=t.name,s=e.edge(t),l=s.labelRank;if(o!==n+1){e.removeEdge(t);var c,u,h;for(h=0,++n;n<o;++h,++n)s.points=[],u={width:0,height:0,edgeLabel:s,edgeObj:t,rank:n},c=War.addDummyNode(e,"edge",u,"_d"),n===l&&(u.width=s.width,u.height=s.height,u.dummy="edge-label",u.labelpos=s.labelpos),e.setEdge(r,c,{weight:s.weight},a),h===0&&e.graph().dummyChains.push(c),r=c;e.setEdge(r,i,{weight:s.weight},a)}}function Xar(e){xae.forEach(e.graph().dummyChains,function(t){var r=e.node(t),n=r.edgeLabel,i;for(e.setEdge(r.edgeObj,n);r.dummy;)i=e.successors(t)[0],e.removeNode(t),n.points.push({x:r.x,y:r.y}),r.dummy==="edge-label"&&(n.x=r.x,n.y=r.y,n.width=r.width,n.height=r.height),t=i,r=e.node(t)})}});var j4=H((jJn,Sae)=>{"use strict";var cH=qn();Sae.exports={longestPath:$ar,slack:Kar};function $ar(e){var t={};function r(n){var i=e.node(n);if(cH.has(t,n))return i.rank;t[n]=!0;var o=cH.min(cH.map(e.outEdges(n),function(a){return r(a.w)-e.edge(a).minlen}));return(o===Number.POSITIVE_INFINITY||o===void 0||o===null)&&(o=0),i.rank=o}cH.forEach(e.sources(),r)}function Kar(e,t){return e.node(t.w).rank-e.node(t.v).rank-e.edge(t).minlen}});var Tlt=H((XJn,Mae)=>{"use strict";var uH=qn(),Zar=Uc().Graph,hH=j4().slack;Mae.exports=Jar;function Jar(e){var t=new Zar({directed:!1}),r=e.nodes()[0],n=e.nodeCount();t.setNode(r,{});for(var i,o;Qar(t,e)<n;)i=tsr(t,e),o=t.hasNode(i.v)?hH(e,i):-hH(e,i),esr(t,e,o);return t}function Qar(e,t){function r(n){uH.forEach(t.nodeEdges(n),function(i){var o=i.v,a=n===o?i.w:o;!e.hasNode(a)&&!hH(t,i)&&(e.setNode(a,{}),e.setEdge(n,a,{}),r(a))})}return uH.forEach(e.nodes(),r),e.nodeCount()}function tsr(e,t){return uH.minBy(t.edges(),function(r){if(e.hasNode(r.v)!==e.hasNode(r.w))return hH(t,r)})}function esr(e,t,r){uH.forEach(e.nodes(),function(n){t.node(n).rank+=r})}});var kae=H(($Jn,Lae)=>{"use strict";var Id=qn(),rsr=Tlt(),nsr=j4().slack,isr=j4().longestPath,osr=Uc().alg.preorder,asr=Uc().alg.postorder,ssr=ns().simplify;Lae.exports=tv;tv.initLowLimValues=Alt;tv.initCutValues=Clt;tv.calcCutValue=Tae;tv.leaveEdge=Aae;tv.enterEdge=Pae;tv.exchangeEdges=Iae;function tv(e){e=ssr(e),isr(e);var t=rsr(e);Alt(t),Clt(t,e);for(var r,n;r=Aae(t);)n=Pae(t,e,r),Iae(t,e,r,n)}function Clt(e,t){var r=asr(e,e.nodes());r=r.slice(0,r.length-1),Id.forEach(r,function(n){lsr(e,t,n)})}function lsr(e,t,r){var n=e.node(r),i=n.parent;e.edge(r,i).cutvalue=Tae(e,t,r)}function Tae(e,t,r){var n=e.node(r),i=n.parent,o=!0,a=t.edge(r,i),s=0;return a||(o=!1,a=t.edge(i,r)),s=a.weight,Id.forEach(t.nodeEdges(r),function(l){var c=l.v===r,u=c?l.w:l.v;if(u!==i){var h=c===o,f=t.edge(l).weight;if(s+=h?f:-f,usr(e,r,u)){var p=e.edge(r,u).cutvalue;s+=h?-p:p}}}),s}function Alt(e,t){arguments.length<2&&(t=e.nodes()[0]),Cae(e,{},1,t)}function Cae(e,t,r,n,i){var o=r,a=e.node(n);return t[n]=!0,Id.forEach(e.neighbors(n),function(s){Id.has(t,s)||(r=Cae(e,t,r,s,n))}),a.low=o,a.lim=r++,i?a.parent=i:delete a.parent,r}function Aae(e){return Id.find(e.edges(),function(t){return e.edge(t).cutvalue<0})}function Pae(e,t,r){var n=r.v,i=r.w;t.hasEdge(n,i)||(n=r.w,i=r.v);var o=e.node(n),a=e.node(i),s=o,l=!1;o.lim>a.lim&&(s=a,l=!0);var c=Id.filter(t.edges(),function(u){return l===Eae(e,e.node(u.v),s)&&l!==Eae(e,e.node(u.w),s)});return Id.minBy(c,function(u){return nsr(t,u)})}function Iae(e,t,r,n){var i=r.v,o=r.w;e.removeEdge(i,o),e.setEdge(n.v,n.w,{}),Alt(e),Clt(e,t),csr(e,t)}function csr(e,t){var r=Id.find(e.nodes(),function(i){return!t.node(i).parent}),n=osr(e,r);n=n.slice(1),Id.forEach(n,function(i){var o=e.node(i).parent,a=t.edge(i,o),s=!1;a||(a=t.edge(o,i),s=!0),t.node(i).rank=t.node(o).rank+(s?a.minlen:-a.minlen)})}function usr(e,t,r){return e.hasEdge(t,r)}function Eae(e,t,r){return r.low<=t.lim&&t.lim<=r.lim}});var Oae=H((KJn,Dae)=>{"use strict";var hsr=j4(),Nae=hsr.longestPath,fsr=Tlt(),psr=kae();Dae.exports=dsr;function dsr(e){switch(e.graph().ranker){case"network-simplex":Rae(e);break;case"tight-tree":gsr(e);break;case"longest-path":msr(e);break;default:Rae(e)}}var msr=Nae;function gsr(e){Nae(e),fsr(e)}function Rae(e){psr(e)}});var Fae=H((ZJn,zae)=>{var Plt=qn();zae.exports=_sr;function _sr(e){var t=vsr(e);Plt.forEach(e.graph().dummyChains,function(r){for(var n=e.node(r),i=n.edgeObj,o=ysr(e,t,i.v,i.w),a=o.path,s=o.lca,l=0,c=a[l],u=!0;r!==i.w;){if(n=e.node(r),u){for(;(c=a[l])!==s&&e.node(c).maxRank<n.rank;)l++;c===s&&(u=!1)}if(!u){for(;l<a.length-1&&e.node(c=a[l+1]).minRank<=n.rank;)l++;c=a[l]}e.setParent(r,c),r=e.successors(r)[0]}})}function ysr(e,t,r,n){var i=[],o=[],a=Math.min(t[r].low,t[n].low),s=Math.max(t[r].lim,t[n].lim),l,c;l=r;do l=e.parent(l),i.push(l);while(l&&(t[l].low>a||s>t[l].lim));for(c=l,l=n;(l=e.parent(l))!==c;)o.push(l);return{path:i.concat(o.reverse()),lca:c}}function vsr(e){var t={},r=0;function n(i){var o=r;Plt.forEach(e.children(i),n),t[i]={low:o,lim:r++}}return Plt.forEach(e.children(),n),t}});var Vae=H((JJn,Hae)=>{var Ld=qn(),Ilt=ns();Hae.exports={run:xsr,cleanup:Ssr};function xsr(e){var t=Ilt.addDummyNode(e,"root",{},"_root"),r=bsr(e),n=Ld.max(Ld.values(r))-1,i=2*n+1;e.graph().nestingRoot=t,Ld.forEach(e.edges(),function(a){e.edge(a).minlen*=i});var o=wsr(e)+1;Ld.forEach(e.children(),function(a){Bae(e,t,i,o,n,r,a)}),e.graph().nodeRankFactor=i}function Bae(e,t,r,n,i,o,a){var s=e.children(a);if(!s.length){a!==t&&e.setEdge(t,a,{weight:0,minlen:r});return}var l=Ilt.addBorderNode(e,"_bt"),c=Ilt.addBorderNode(e,"_bb"),u=e.node(a);e.setParent(l,a),u.borderTop=l,e.setParent(c,a),u.borderBottom=c,Ld.forEach(s,function(h){Bae(e,t,r,n,i,o,h);var f=e.node(h),p=f.borderTop?f.borderTop:h,d=f.borderBottom?f.borderBottom:h,g=f.borderTop?n:2*n,_=p!==d?1:i-o[a]+1;e.setEdge(l,p,{weight:g,minlen:_,nestingEdge:!0}),e.setEdge(d,c,{weight:g,minlen:_,nestingEdge:!0})}),e.parent(a)||e.setEdge(t,l,{weight:0,minlen:i+o[a]})}function bsr(e){var t={};function r(n,i){var o=e.children(n);o&&o.length&&Ld.forEach(o,function(a){r(a,i+1)}),t[n]=i}return Ld.forEach(e.children(),function(n){r(n,1)}),t}function wsr(e){return Ld.reduce(e.edges(),function(t,r){return t+e.edge(r).weight},0)}function Ssr(e){var t=e.graph();e.removeNode(t.nestingRoot),delete t.nestingRoot,Ld.forEach(e.edges(),function(r){var n=e.edge(r);n.nestingEdge&&e.removeEdge(r)})}});var Gae=H((QJn,qae)=>{var Llt=qn(),Msr=ns();qae.exports=Esr;function Esr(e){function t(r){var n=e.children(r),i=e.node(r);if(n.length&&Llt.forEach(n,t),Llt.has(i,"minRank")){i.borderLeft=[],i.borderRight=[];for(var o=i.minRank,a=i.maxRank+1;o<a;++o)Uae(e,"borderLeft","_bl",r,i,o),Uae(e,"borderRight","_br",r,i,o)}}Llt.forEach(e.children(),t)}function Uae(e,t,r,n,i,o){var a={width:0,height:0,rank:o,borderType:t},s=i[t][o-1],l=Msr.addDummyNode(e,"border",a,r);i[t][o]=l,e.setParent(l,n),s&&e.setEdge(s,l,{weight:1})}});var Xae=H((tQn,jae)=>{"use strict";var Uf=qn();jae.exports={adjust:Tsr,undo:Csr};function Tsr(e){var t=e.graph().rankdir.toLowerCase();(t==="lr"||t==="rl")&&Yae(e)}function Csr(e){var t=e.graph().rankdir.toLowerCase();(t==="bt"||t==="rl")&&Asr(e),(t==="lr"||t==="rl")&&(Psr(e),Yae(e))}function Yae(e){Uf.forEach(e.nodes(),function(t){Wae(e.node(t))}),Uf.forEach(e.edges(),function(t){Wae(e.edge(t))})}function Wae(e){var t=e.width;e.width=e.height,e.height=t}function Asr(e){Uf.forEach(e.nodes(),function(t){klt(e.node(t))}),Uf.forEach(e.edges(),function(t){var r=e.edge(t);Uf.forEach(r.points,klt),Uf.has(r,"y")&&klt(r)})}function klt(e){e.y=-e.y}function Psr(e){Uf.forEach(e.nodes(),function(t){Rlt(e.node(t))}),Uf.forEach(e.edges(),function(t){var r=e.edge(t);Uf.forEach(r.points,Rlt),Uf.has(r,"x")&&Rlt(r)})}function Rlt(e){var t=e.x;e.x=e.y,e.y=t}});var Kae=H((eQn,$ae)=>{"use strict";var kd=qn();$ae.exports=Isr;function Isr(e){var t={},r=kd.filter(e.nodes(),function(s){return!e.children(s).length}),n=kd.max(kd.map(r,function(s){return e.node(s).rank})),i=kd.map(kd.range(n+1),function(){return[]});function o(s){if(!kd.has(t,s)){t[s]=!0;var l=e.node(s);i[l.rank].push(s),kd.forEach(e.successors(s),o)}}var a=kd.sortBy(r,function(s){return e.node(s).rank});return kd.forEach(a,o),i}});var Jae=H((rQn,Zae)=>{"use strict";var h0=qn();Zae.exports=Lsr;function Lsr(e,t){for(var r=0,n=1;n<t.length;++n)r+=ksr(e,t[n-1],t[n]);return r}function ksr(e,t,r){for(var n=h0.zipObject(r,h0.map(r,function(c,u){return u})),i=h0.flatten(h0.map(t,function(c){return h0.sortBy(h0.map(e.outEdges(c),function(u){return{pos:n[u.w],weight:e.edge(u).weight}}),"pos")}),!0),o=1;o<r.length;)o<<=1;var a=2*o-1;o-=1;var s=h0.map(new Array(a),function(){return 0}),l=0;return h0.forEach(i.forEach(function(c){var u=c.pos+o;s[u]+=c.weight;for(var h=0;u>0;)u%2&&(h+=s[u+1]),u=u-1>>1,s[u]+=c.weight;l+=c.weight*h})),l}});var ese=H((nQn,tse)=>{var Qae=qn();tse.exports=Rsr;function Rsr(e,t){return Qae.map(t,function(r){var n=e.inEdges(r);if(n.length){var i=Qae.reduce(n,function(o,a){var s=e.edge(a),l=e.node(a.v);return{sum:o.sum+s.weight*l.order,weight:o.weight+s.weight}},{sum:0,weight:0});return{v:r,barycenter:i.sum/i.weight,weight:i.weight}}else return{v:r}})}});var nse=H((iQn,rse)=>{"use strict";var Tl=qn();rse.exports=Nsr;function Nsr(e,t){var r={};Tl.forEach(e,function(i,o){var a=r[i.v]={indegree:0,in:[],out:[],vs:[i.v],i:o};Tl.isUndefined(i.barycenter)||(a.barycenter=i.barycenter,a.weight=i.weight)}),Tl.forEach(t.edges(),function(i){var o=r[i.v],a=r[i.w];!Tl.isUndefined(o)&&!Tl.isUndefined(a)&&(a.indegree++,o.out.push(r[i.w]))});var n=Tl.filter(r,function(i){return!i.indegree});return Dsr(n)}function Dsr(e){var t=[];function r(o){return function(a){a.merged||(Tl.isUndefined(a.barycenter)||Tl.isUndefined(o.barycenter)||a.barycenter>=o.barycenter)&&Osr(o,a)}}function n(o){return function(a){a.in.push(o),--a.indegree===0&&e.push(a)}}for(;e.length;){var i=e.pop();t.push(i),Tl.forEach(i.in.reverse(),r(i)),Tl.forEach(i.out,n(i))}return Tl.map(Tl.filter(t,function(o){return!o.merged}),function(o){return Tl.pick(o,["vs","i","barycenter","weight"])})}function Osr(e,t){var r=0,n=0;e.weight&&(r+=e.barycenter*e.weight,n+=e.weight),t.weight&&(r+=t.barycenter*t.weight,n+=t.weight),e.vs=t.vs.concat(e.vs),e.barycenter=r/n,e.weight=n,e.i=Math.min(t.i,e.i),t.merged=!0}});var ase=H((oQn,ose)=>{var X4=qn(),zsr=ns();ose.exports=Fsr;function Fsr(e,t){var r=zsr.partition(e,function(u){return X4.has(u,"barycenter")}),n=r.lhs,i=X4.sortBy(r.rhs,function(u){return-u.i}),o=[],a=0,s=0,l=0;n.sort(Bsr(!!t)),l=ise(o,i,l),X4.forEach(n,function(u){l+=u.vs.length,o.push(u.vs),a+=u.barycenter*u.weight,s+=u.weight,l=ise(o,i,l)});var c={vs:X4.flatten(o,!0)};return s&&(c.barycenter=a/s,c.weight=s),c}function ise(e,t,r){for(var n;t.length&&(n=X4.last(t)).i<=r;)t.pop(),e.push(n.vs),r++;return r}function Bsr(e){return function(t,r){return t.barycenter<r.barycenter?-1:t.barycenter>r.barycenter?1:e?r.i-t.i:t.i-r.i}}});var cse=H((aQn,lse)=>{var f0=qn(),Hsr=ese(),Vsr=nse(),Usr=ase();lse.exports=sse;function sse(e,t,r,n){var i=e.children(t),o=e.node(t),a=o?o.borderLeft:void 0,s=o?o.borderRight:void 0,l={};a&&(i=f0.filter(i,function(d){return d!==a&&d!==s}));var c=Hsr(e,i);f0.forEach(c,function(d){if(e.children(d.v).length){var g=sse(e,d.v,r,n);l[d.v]=g,f0.has(g,"barycenter")&&Gsr(d,g)}});var u=Vsr(c,r);qsr(u,l);var h=Usr(u,n);if(a&&(h.vs=f0.flatten([a,h.vs,s],!0),e.predecessors(a).length)){var f=e.node(e.predecessors(a)[0]),p=e.node(e.predecessors(s)[0]);f0.has(h,"barycenter")||(h.barycenter=0,h.weight=0),h.barycenter=(h.barycenter*h.weight+f.order+p.order)/(h.weight+2),h.weight+=2}return h}function qsr(e,t){f0.forEach(e,function(r){r.vs=f0.flatten(r.vs.map(function(n){return t[n]?t[n].vs:n}),!0)})}function Gsr(e,t){f0.isUndefined(e.barycenter)?(e.barycenter=t.barycenter,e.weight=t.weight):(e.barycenter=(e.barycenter*e.weight+t.barycenter*t.weight)/(e.weight+t.weight),e.weight+=t.weight)}});var hse=H((sQn,use)=>{var $4=qn(),Wsr=Uc().Graph;use.exports=Ysr;function Ysr(e,t,r){var n=jsr(e),i=new Wsr({compound:!0}).setGraph({root:n}).setDefaultNodeLabel(function(o){return e.node(o)});return $4.forEach(e.nodes(),function(o){var a=e.node(o),s=e.parent(o);(a.rank===t||a.minRank<=t&&t<=a.maxRank)&&(i.setNode(o),i.setParent(o,s||n),$4.forEach(e[r](o),function(l){var c=l.v===o?l.w:l.v,u=i.edge(c,o),h=$4.isUndefined(u)?0:u.weight;i.setEdge(c,o,{weight:e.edge(l).weight+h})}),$4.has(a,"minRank")&&i.setNode(o,{borderLeft:a.borderLeft[t],borderRight:a.borderRight[t]}))}),i}function jsr(e){for(var t;e.hasNode(t=$4.uniqueId("_root")););return t}});var pse=H((lQn,fse)=>{var Xsr=qn();fse.exports=$sr;function $sr(e,t,r){var n={},i;Xsr.forEach(r,function(o){for(var a=e.parent(o),s,l;a;){if(s=e.parent(a),s?(l=n[s],n[s]=a):(l=i,i=a),l&&l!==a){t.setEdge(l,a);return}a=s}})}});var yse=H((cQn,_se)=>{"use strict";var p0=qn(),Ksr=Kae(),Zsr=Jae(),Jsr=cse(),Qsr=hse(),tlr=pse(),elr=Uc().Graph,dse=ns();_se.exports=rlr;function rlr(e){var t=dse.maxRank(e),r=mse(e,p0.range(1,t+1),"inEdges"),n=mse(e,p0.range(t-1,-1,-1),"outEdges"),i=Ksr(e);gse(e,i);for(var o=Number.POSITIVE_INFINITY,a,s=0,l=0;l<4;++s,++l){nlr(s%2?r:n,s%4>=2),i=dse.buildLayerMatrix(e);var c=Zsr(e,i);c<o&&(l=0,a=p0.cloneDeep(i),o=c)}gse(e,a)}function mse(e,t,r){return p0.map(t,function(n){return Qsr(e,n,r)})}function nlr(e,t){var r=new elr;p0.forEach(e,function(n){var i=n.graph().root,o=Jsr(n,i,r,t);p0.forEach(o.vs,function(a,s){n.node(a).order=s}),tlr(n,r,o.vs)})}function gse(e,t){p0.forEach(t,function(r){p0.forEach(r,function(n,i){e.node(n).order=i})})}});var Ase=H((uQn,Cse)=>{"use strict";var Xe=qn(),ilr=Uc().Graph,olr=ns();Cse.exports={positionX:llr,findType1Conflicts:vse,findType2Conflicts:xse,addConflict:Nlt,hasConflict:bse,verticalAlignment:wse,horizontalCompaction:Sse,alignCoordinates:Ese,findSmallestWidthAlignment:Mse,balance:Tse};function vse(e,t){var r={};function n(i,o){var a=0,s=0,l=i.length,c=Xe.last(o);return Xe.forEach(o,function(u,h){var f=alr(e,u),p=f?e.node(f).order:l;(f||u===c)&&(Xe.forEach(o.slice(s,h+1),function(d){Xe.forEach(e.predecessors(d),function(g){var _=e.node(g),y=_.order;(y<a||p<y)&&!(_.dummy&&e.node(d).dummy)&&Nlt(r,g,d)})}),s=h+1,a=p)}),o}return Xe.reduce(t,n),r}function xse(e,t){var r={};function n(o,a,s,l,c){var u;Xe.forEach(Xe.range(a,s),function(h){u=o[h],e.node(u).dummy&&Xe.forEach(e.predecessors(u),function(f){var p=e.node(f);p.dummy&&(p.order<l||p.order>c)&&Nlt(r,f,u)})})}function i(o,a){var s=-1,l,c=0;return Xe.forEach(a,function(u,h){if(e.node(u).dummy==="border"){var f=e.predecessors(u);f.length&&(l=e.node(f[0]).order,n(a,c,h,s,l),c=h,s=l)}n(a,c,a.length,l,o.length)}),a}return Xe.reduce(t,i),r}function alr(e,t){if(e.node(t).dummy)return Xe.find(e.predecessors(t),function(r){return e.node(r).dummy})}function Nlt(e,t,r){if(t>r){var n=t;t=r,r=n}var i=e[t];i||(e[t]=i={}),i[r]=!0}function bse(e,t,r){if(t>r){var n=t;t=r,r=n}return Xe.has(e[t],r)}function wse(e,t,r,n){var i={},o={},a={};return Xe.forEach(t,function(s){Xe.forEach(s,function(l,c){i[l]=l,o[l]=l,a[l]=c})}),Xe.forEach(t,function(s){var l=-1;Xe.forEach(s,function(c){var u=n(c);if(u.length){u=Xe.sortBy(u,function(g){return a[g]});for(var h=(u.length-1)/2,f=Math.floor(h),p=Math.ceil(h);f<=p;++f){var d=u[f];o[c]===c&&l<a[d]&&!bse(r,c,d)&&(o[d]=c,o[c]=i[c]=i[d],l=a[d])}}})}),{root:i,align:o}}function Sse(e,t,r,n,i){var o={},a=slr(e,t,r,i),s=i?"borderLeft":"borderRight";function l(h,f){for(var p=a.nodes(),d=p.pop(),g={};d;)g[d]?h(d):(g[d]=!0,p.push(d),p=p.concat(f(d))),d=p.pop()}function c(h){o[h]=a.inEdges(h).reduce(function(f,p){return Math.max(f,o[p.v]+a.edge(p))},0)}function u(h){var f=a.outEdges(h).reduce(function(d,g){return Math.min(d,o[g.w]-a.edge(g))},Number.POSITIVE_INFINITY),p=e.node(h);f!==Number.POSITIVE_INFINITY&&p.borderType!==s&&(o[h]=Math.max(o[h],f))}return l(c,a.predecessors.bind(a)),l(u,a.successors.bind(a)),Xe.forEach(n,function(h){o[h]=o[r[h]]}),o}function slr(e,t,r,n){var i=new ilr,o=e.graph(),a=clr(o.nodesep,o.edgesep,n);return Xe.forEach(t,function(s){var l;Xe.forEach(s,function(c){var u=r[c];if(i.setNode(u),l){var h=r[l],f=i.edge(h,u);i.setEdge(h,u,Math.max(a(e,c,l),f||0))}l=c})}),i}function Mse(e,t){return Xe.minBy(Xe.values(t),function(r){var n=Number.NEGATIVE_INFINITY,i=Number.POSITIVE_INFINITY;return Xe.forIn(r,function(o,a){var s=ulr(e,a)/2;n=Math.max(o+s,n),i=Math.min(o-s,i)}),n-i})}function Ese(e,t){var r=Xe.values(t),n=Xe.min(r),i=Xe.max(r);Xe.forEach(["u","d"],function(o){Xe.forEach(["l","r"],function(a){var s=o+a,l=e[s],c;if(l!==t){var u=Xe.values(l);c=a==="l"?n-Xe.min(u):i-Xe.max(u),c&&(e[s]=Xe.mapValues(l,function(h){return h+c}))}})})}function Tse(e,t){return Xe.mapValues(e.ul,function(r,n){if(t)return e[t.toLowerCase()][n];var i=Xe.sortBy(Xe.map(e,n));return(i[1]+i[2])/2})}function llr(e){var t=olr.buildLayerMatrix(e),r=Xe.merge(vse(e,t),xse(e,t)),n={},i;Xe.forEach(["u","d"],function(a){i=a==="u"?t:Xe.values(t).reverse(),Xe.forEach(["l","r"],function(s){s==="r"&&(i=Xe.map(i,function(h){return Xe.values(h).reverse()}));var l=(a==="u"?e.predecessors:e.successors).bind(e),c=wse(e,i,r,l),u=Sse(e,i,c.root,c.align,s==="r");s==="r"&&(u=Xe.mapValues(u,function(h){return-h})),n[a+s]=u})});var o=Mse(e,n);return Ese(n,o),Tse(n,e.graph().align)}function clr(e,t,r){return function(n,i,o){var a=n.node(i),s=n.node(o),l=0,c;if(l+=a.width/2,Xe.has(a,"labelpos"))switch(a.labelpos.toLowerCase()){case"l":c=-a.width/2;break;case"r":c=a.width/2;break}if(c&&(l+=r?c:-c),c=0,l+=(a.dummy?t:e)/2,l+=(s.dummy?t:e)/2,l+=s.width/2,Xe.has(s,"labelpos"))switch(s.labelpos.toLowerCase()){case"l":c=s.width/2;break;case"r":c=-s.width/2;break}return c&&(l+=r?c:-c),c=0,l}}function ulr(e,t){return e.node(t).width}});var Lse=H((hQn,Ise)=>{"use strict";var K4=qn(),Pse=ns(),hlr=Ase().positionX;Ise.exports=flr;function flr(e){e=Pse.asNonCompoundGraph(e),plr(e),K4.forEach(hlr(e),function(t,r){e.node(r).x=t})}function plr(e){var t=Pse.buildLayerMatrix(e),r=e.graph().ranksep,n=0;K4.forEach(t,function(i){var o=K4.max(K4.map(i,function(a){return e.node(a).height}));K4.forEach(i,function(a){e.node(a).y=n+o/2}),n+=o+r})}});var zse=H((fQn,Ose)=>{"use strict";var ir=qn(),kse=mae(),Rse=wae(),dlr=Oae(),mlr=ns().normalizeRanks,glr=Fae(),_lr=ns().removeEmptyRanks,Nse=Vae(),ylr=Gae(),Dse=Xae(),vlr=yse(),xlr=Lse(),d0=ns(),blr=Uc().Graph;Ose.exports=wlr;function wlr(e,t){var r=t&&t.debugTiming?d0.time:d0.notime;r("layout",function(){var n=r("  buildLayoutGraph",function(){return Rlr(e)});r("  runLayout",function(){Slr(n,r)}),r("  updateInputGraph",function(){Mlr(e,n)})})}function Slr(e,t){t("    makeSpaceForEdgeLabels",function(){Nlr(e)}),t("    removeSelfEdges",function(){qlr(e)}),t("    acyclic",function(){kse.run(e)}),t("    nestingGraph.run",function(){Nse.run(e)}),t("    rank",function(){dlr(d0.asNonCompoundGraph(e))}),t("    injectEdgeLabelProxies",function(){Dlr(e)}),t("    removeEmptyRanks",function(){_lr(e)}),t("    nestingGraph.cleanup",function(){Nse.cleanup(e)}),t("    normalizeRanks",function(){mlr(e)}),t("    assignRankMinMax",function(){Olr(e)}),t("    removeEdgeLabelProxies",function(){zlr(e)}),t("    normalize.run",function(){Rse.run(e)}),t("    parentDummyChains",function(){glr(e)}),t("    addBorderSegments",function(){ylr(e)}),t("    order",function(){vlr(e)}),t("    insertSelfEdges",function(){Glr(e)}),t("    adjustCoordinateSystem",function(){Dse.adjust(e)}),t("    position",function(){xlr(e)}),t("    positionSelfEdges",function(){Wlr(e)}),t("    removeBorderNodes",function(){Ulr(e)}),t("    normalize.undo",function(){Rse.undo(e)}),t("    fixupEdgeLabelCoords",function(){Hlr(e)}),t("    undoCoordinateSystem",function(){Dse.undo(e)}),t("    translateGraph",function(){Flr(e)}),t("    assignNodeIntersects",function(){Blr(e)}),t("    reversePoints",function(){Vlr(e)}),t("    acyclic.undo",function(){kse.undo(e)})}function Mlr(e,t){ir.forEach(e.nodes(),function(r){var n=e.node(r),i=t.node(r);n&&(n.x=i.x,n.y=i.y,t.children(r).length&&(n.width=i.width,n.height=i.height))}),ir.forEach(e.edges(),function(r){var n=e.edge(r),i=t.edge(r);n.points=i.points,ir.has(i,"x")&&(n.x=i.x,n.y=i.y)}),e.graph().width=t.graph().width,e.graph().height=t.graph().height}var Elr=["nodesep","edgesep","ranksep","marginx","marginy"],Tlr={ranksep:50,edgesep:20,nodesep:50,rankdir:"tb"},Clr=["acyclicer","ranker","rankdir","align"],Alr=["width","height"],Plr={width:0,height:0},Ilr=["minlen","weight","width","height","labeloffset"],Llr={minlen:1,weight:1,width:0,height:0,labeloffset:10,labelpos:"r"},klr=["labelpos"];function Rlr(e){var t=new blr({multigraph:!0,compound:!0}),r=Olt(e.graph());return t.setGraph(ir.merge({},Tlr,Dlt(r,Elr),ir.pick(r,Clr))),ir.forEach(e.nodes(),function(n){var i=Olt(e.node(n));t.setNode(n,ir.defaults(Dlt(i,Alr),Plr)),t.setParent(n,e.parent(n))}),ir.forEach(e.edges(),function(n){var i=Olt(e.edge(n));t.setEdge(n,ir.merge({},Llr,Dlt(i,Ilr),ir.pick(i,klr)))}),t}function Nlr(e){var t=e.graph();t.ranksep/=2,ir.forEach(e.edges(),function(r){var n=e.edge(r);n.minlen*=2,n.labelpos.toLowerCase()!=="c"&&(t.rankdir==="TB"||t.rankdir==="BT"?n.width+=n.labeloffset:n.height+=n.labeloffset)})}function Dlr(e){ir.forEach(e.edges(),function(t){var r=e.edge(t);if(r.width&&r.height){var n=e.node(t.v),i=e.node(t.w),o={rank:(i.rank-n.rank)/2+n.rank,e:t};d0.addDummyNode(e,"edge-proxy",o,"_ep")}})}function Olr(e){var t=0;ir.forEach(e.nodes(),function(r){var n=e.node(r);n.borderTop&&(n.minRank=e.node(n.borderTop).rank,n.maxRank=e.node(n.borderBottom).rank,t=ir.max(t,n.maxRank))}),e.graph().maxRank=t}function zlr(e){ir.forEach(e.nodes(),function(t){var r=e.node(t);r.dummy==="edge-proxy"&&(e.edge(r.e).labelRank=r.rank,e.removeNode(t))})}function Flr(e){var t=Number.POSITIVE_INFINITY,r=0,n=Number.POSITIVE_INFINITY,i=0,o=e.graph(),a=o.marginx||0,s=o.marginy||0;function l(c){var u=c.x,h=c.y,f=c.width,p=c.height;t=Math.min(t,u-f/2),r=Math.max(r,u+f/2),n=Math.min(n,h-p/2),i=Math.max(i,h+p/2)}ir.forEach(e.nodes(),function(c){l(e.node(c))}),ir.forEach(e.edges(),function(c){var u=e.edge(c);ir.has(u,"x")&&l(u)}),t-=a,n-=s,ir.forEach(e.nodes(),function(c){var u=e.node(c);u.x-=t,u.y-=n}),ir.forEach(e.edges(),function(c){var u=e.edge(c);ir.forEach(u.points,function(h){h.x-=t,h.y-=n}),ir.has(u,"x")&&(u.x-=t),ir.has(u,"y")&&(u.y-=n)}),o.width=r-t+a,o.height=i-n+s}function Blr(e){ir.forEach(e.edges(),function(t){var r=e.edge(t),n=e.node(t.v),i=e.node(t.w),o,a;r.points?(o=r.points[0],a=r.points[r.points.length-1]):(r.points=[],o=i,a=n),r.points.unshift(d0.intersectRect(n,o)),r.points.push(d0.intersectRect(i,a))})}function Hlr(e){ir.forEach(e.edges(),function(t){var r=e.edge(t);if(ir.has(r,"x"))switch((r.labelpos==="l"||r.labelpos==="r")&&(r.width-=r.labeloffset),r.labelpos){case"l":r.x-=r.width/2+r.labeloffset;break;case"r":r.x+=r.width/2+r.labeloffset;break}})}function Vlr(e){ir.forEach(e.edges(),function(t){var r=e.edge(t);r.reversed&&r.points.reverse()})}function Ulr(e){ir.forEach(e.nodes(),function(t){if(e.children(t).length){var r=e.node(t),n=e.node(r.borderTop),i=e.node(r.borderBottom),o=e.node(ir.last(r.borderLeft)),a=e.node(ir.last(r.borderRight));r.width=Math.abs(a.x-o.x),r.height=Math.abs(i.y-n.y),r.x=o.x+r.width/2,r.y=n.y+r.height/2}}),ir.forEach(e.nodes(),function(t){e.node(t).dummy==="border"&&e.removeNode(t)})}function qlr(e){ir.forEach(e.edges(),function(t){if(t.v===t.w){var r=e.node(t.v);r.selfEdges||(r.selfEdges=[]),r.selfEdges.push({e:t,label:e.edge(t)}),e.removeEdge(t)}})}function Glr(e){var t=d0.buildLayerMatrix(e);ir.forEach(t,function(r){var n=0;ir.forEach(r,function(i,o){var a=e.node(i);a.order=o+n,ir.forEach(a.selfEdges,function(s){d0.addDummyNode(e,"selfedge",{width:s.label.width,height:s.label.height,rank:a.rank,order:o+ ++n,e:s.e,label:s.label},"_se")}),delete a.selfEdges})})}function Wlr(e){ir.forEach(e.nodes(),function(t){var r=e.node(t);if(r.dummy==="selfedge"){var n=e.node(r.e.v),i=n.x+n.width/2,o=n.y,a=r.x-i,s=n.height/2;e.setEdge(r.e,r.label),e.removeNode(t),r.label.points=[{x:i+2*a/3,y:o-s},{x:i+5*a/6,y:o-s},{x:i+a,y:o},{x:i+5*a/6,y:o+s},{x:i+2*a/3,y:o+s}],r.label.x=r.x,r.label.y=r.y}})}function Dlt(e,t){return ir.mapValues(ir.pick(e,t),Number)}function Olt(e){var t={};return ir.forEach(e,function(r,n){t[n.toLowerCase()]=r}),t}});var Bse=H((pQn,Fse)=>{var fH=qn(),Ylr=ns(),jlr=Uc().Graph;Fse.exports={debugOrdering:Xlr};function Xlr(e){var t=Ylr.buildLayerMatrix(e),r=new jlr({compound:!0,multigraph:!0}).setGraph({});return fH.forEach(e.nodes(),function(n){r.setNode(n,{label:n}),r.setParent(n,"layer"+e.node(n).rank)}),fH.forEach(e.edges(),function(n){r.setEdge(n.v,n.w,{},n.name)}),fH.forEach(t,function(n,i){var o="layer"+i;r.setNode(o,{rank:"same"}),fH.reduce(n,function(a,s){return r.setEdge(a,s,{style:"invis"}),s})}),r}});var Vse=H((dQn,Hse)=>{Hse.exports="0.8.5"});var zlt=H((mQn,Use)=>{Use.exports={graphlib:Uc(),layout:zse(),debug:Bse(),util:{time:ns().time,notime:ns().notime},version:Vse()}});var zdt=Ee(Odt(),1),{__extends:c_r,__assign:u_r,__rest:h_r,__decorate:E,__param:f_r,__metadata:w,__awaiter:p_r,__generator:d_r,__exportStar:m_r,__createBinding:g_r,__values:__r,__read:y_r,__spread:v_r,__spreadArrays:x_r,__spreadArray:b_r,__await:w_r,__asyncGenerator:S_r,__asyncDelegator:M_r,__asyncValues:E_r,__makeTemplateObject:T_r,__importStar:C_r,__importDefault:A_r,__classPrivateFieldGet:P_r,__classPrivateFieldSet:I_r,__classPrivateFieldIn:L_r}=zdt.default;function yt(e){return t=>{if(e)if(t.hasOwnProperty("is")){if(e!==t.is)throw new Error(`custom element tag names do not match: (${e} !== ${t.is})`)}else Object.defineProperty(t,"is",{value:e});window.customElements.define(t.is,t)}}function Fdt(e,t,r){e.constructor.hasOwnProperty("properties")||Object.defineProperty(e.constructor,"properties",{value:{}}),e.constructor.properties[t]=Object.assign({},e.constructor.properties[t],r)}function A(e){return(t,r)=>{Fdt(t,r,e)}}function Bt(...e){return(t,r)=>{t.constructor.hasOwnProperty("observers")||Object.defineProperty(t.constructor,"observers",{value:[]}),t.constructor.observers.push(`${r}(${e.join(",")})`)}}function Rt(e,...t){return(r,n,i)=>{let o=`__compute${n}`;Object.defineProperty(r,o,{value:i.get}),i.get=void 0;let a=[e,...t].join(",");Fdt(r,n,{computed:`${o}(${a})`})}}var R_r=Bdt((e,t)=>e.querySelector(t)),N_r=Bdt((e,t)=>e.querySelectorAll(t));function Bdt(e){return t=>(r,n)=>{Object.defineProperty(r,n,{get(){return e(this.shadowRoot,t)},enumerable:!0,configurable:!0})}}window.JSCompiler_renameProperty=function(e,t){return e};var b1e=/(url\()([^)]*)(\))/g,w1e=/(^\/[^\/])|(^#)|(^[\w-\d]*:)/,PI,Zs;function l_(e,t){if(e&&w1e.test(e)||e==="//")return e;if(PI===void 0){PI=!1;try{let r=new URL("b","http://a");r.pathname="c%20d",PI=r.href==="http://a/c%20d"}catch(r){}}if(t||(t=document.baseURI||window.location.href),PI)try{return new URL(e,t).href}catch(r){return e}return Zs||(Zs=document.implementation.createHTMLDocument("temp"),Zs.base=Zs.createElement("base"),Zs.head.appendChild(Zs.base),Zs.anchor=Zs.createElement("a"),Zs.body.appendChild(Zs.anchor)),Zs.base.href=t,Zs.anchor.href=e,Zs.anchor.href||e}function HM(e,t){return e.replace(b1e,function(r,n,i,o){return n+"'"+l_(i.replace(/["']/g,""),t)+"'"+o})}function Cx(e){return e.substring(0,e.lastIndexOf("/")+1)}var c_=!window.ShadyDOM||!window.ShadyDOM.inUse,H_r=Boolean(!window.ShadyCSS||window.ShadyCSS.nativeCss),V_r=!window.customElements.polyfillWrapFlushCallback,Hdt=c_&&"adoptedStyleSheets"in Document.prototype&&"replaceSync"in CSSStyleSheet.prototype&&(()=>{try{let e=new CSSStyleSheet;e.replaceSync("");let t=document.createElement("div");return t.attachShadow({mode:"open"}),t.shadowRoot.adoptedStyleSheets=[e],t.shadowRoot.adoptedStyleSheets[0]===e}catch(e){return!1}})(),Vdt=window.Polymer&&window.Polymer.rootPath||Cx(document.baseURI||window.location.href);var VM=window.Polymer&&window.Polymer.sanitizeDOMValue||void 0;var Udt=window.Polymer&&window.Polymer.setPassiveTouchGestures||!1;var iu=window.Polymer&&window.Polymer.strictTemplatePolicy||!1;var qdt=window.Polymer&&window.Polymer.allowTemplateFromDomModule||!1;var pp=window.Polymer&&window.Polymer.legacyOptimizations||!1;var II=window.Polymer&&window.Polymer.legacyWarnings||!1;var Gdt=window.Polymer&&window.Polymer.syncInitialRender||!1;var LI=window.Polymer&&window.Polymer.legacyUndefined||!1;var Wdt=window.Polymer&&window.Polymer.orderedComputed||!1;var hG=!0;var fG=window.Polymer&&window.Polymer.removeNestedTemplates||!1;var kI=window.Polymer&&window.Polymer.fastDomIf||!1;var UM=window.Polymer&&window.Polymer.suppressTemplateNotifications||!1;var qM=window.Polymer&&window.Polymer.legacyNoObservedAttributes||!1;var Ydt=window.Polymer&&window.Polymer.useAdoptedStyleSheetsWithBuiltCSS||!1;var S1e=0;function jdt(){}jdt.prototype.__mixinApplications;jdt.prototype.__mixinSet;var Nn=function(e){let t=e.__mixinApplications;t||(t=new WeakMap,e.__mixinApplications=t);let r=S1e++;function n(i){let o=i.__mixinSet;if(o&&o[r])return i;let a=t,s=a.get(i);if(!s){s=e(i),a.set(i,s);let l=Object.create(s.__mixinSet||o||null);l[r]=!0,s.__mixinSet=l}return s}return n};var pG={},Kdt={};function Xdt(e,t){pG[e]=Kdt[e.toLowerCase()]=t}function $dt(e){return pG[e]||Kdt[e.toLowerCase()]}function M1e(e){e.querySelector("style")&&console.warn("dom-module %s has style outside template",e.id)}var ou=class extends HTMLElement{static get observedAttributes(){return["id"]}static import(t,r){if(t){let n=$dt(t);return n&&r?n.querySelector(r):n}return null}attributeChangedCallback(t,r,n,i){r!==n&&this.register()}get assetpath(){if(!this.__assetpath){let t=window.HTMLImports&&HTMLImports.importForElement?HTMLImports.importForElement(this)||document:this.ownerDocument,r=l_(this.getAttribute("assetpath")||"",t.baseURI);this.__assetpath=Cx(r)}return this.__assetpath}register(t){if(t=t||this.id,t){if(iu&&$dt(t)!==void 0)throw Xdt(t,null),new Error(`strictTemplatePolicy: dom-module ${t} re-registered`);this.id=t,Xdt(t,this),M1e(this)}}};ou.prototype.modules=pG;customElements.define("dom-module",ou);var E1e="link[rel=import][type~=css]",T1e="include",Zdt="shady-unscoped";function dG(e){return ou.import(e)}function Jdt(e){let t=e.body?e.body:e,r=HM(t.textContent,e.baseURI),n=document.createElement("style");return n.textContent=r,n}function C1e(e){let t=e.trim().split(/\s+/),r=[];for(let n=0;n<t.length;n++)r.push(...A1e(t[n]));return r}function A1e(e){let t=dG(e);if(!t)return console.warn("Could not find style data in module named",e),[];if(t._styles===void 0){let r=[];r.push(...mG(t));let n=t.querySelector("template");n&&r.push(...RI(n,t.assetpath)),t._styles=r}return t._styles}function RI(e,t){if(!e._styles){let r=[],n=e.content.querySelectorAll("style");for(let i=0;i<n.length;i++){let o=n[i],a=o.getAttribute(T1e);a&&r.push(...C1e(a).filter(function(s,l,c){return c.indexOf(s)===l})),t&&(o.textContent=HM(o.textContent,t)),r.push(o)}e._styles=r}return e._styles}function Qdt(e){let t=dG(e);return t?mG(t):[]}function mG(e){let t=[],r=e.querySelectorAll(E1e);for(let n=0;n<r.length;n++){let i=r[n];if(i.import){let o=i.import,a=i.hasAttribute(Zdt);if(a&&!o._unscopedStyle){let s=Jdt(o);s.setAttribute(Zdt,""),o._unscopedStyle=s}else o._style||(o._style=Jdt(o));t.push(a?o._unscopedStyle:o._style)}}return t}function tmt(e){let t=e.trim().split(/\s+/),r="";for(let n=0;n<t.length;n++)r+=P1e(t[n]);return r}function P1e(e){let t=dG(e);if(t&&t._cssText===void 0){let r=L1e(t),n=t.querySelector("template");n&&(r+=I1e(n,t.assetpath)),t._cssText=r||null}return t||console.warn("Could not find style data in module named",e),t&&t._cssText||""}function I1e(e,t){let r="",n=RI(e,t);for(let i=0;i<n.length;i++){let o=n[i];o.parentNode&&o.parentNode.removeChild(o),r+=o.textContent}return r}function L1e(e){let t="",r=mG(e);for(let n=0;n<r.length;n++)t+=r[n].textContent;return t}var ue=window.ShadyDOM&&window.ShadyDOM.noPatch&&window.ShadyDOM.wrap?window.ShadyDOM.wrap:window.ShadyDOM?e=>ShadyDOM.patch(e):e=>e;function NI(e){return e.indexOf(".")>=0}function au(e){let t=e.indexOf(".");return t===-1?e:e.slice(0,t)}function gG(e,t){return e.indexOf(t+".")===0}function Ax(e,t){return t.indexOf(e+".")===0}function dp(e,t,r){return t+r.slice(e.length)}function DI(e,t){return e===t||gG(e,t)||Ax(e,t)}function Px(e){if(Array.isArray(e)){let t=[];for(let r=0;r<e.length;r++){let n=e[r].toString().split(".");for(let i=0;i<n.length;i++)t.push(n[i])}return t.join(".")}else return e}function emt(e){return Array.isArray(e)?Px(e).split("."):e.toString().split(".")}function No(e,t,r){let n=e,i=emt(t);for(let o=0;o<i.length;o++){if(!n)return;let a=i[o];n=n[a]}return r&&(r.path=i.join(".")),n}function _G(e,t,r){let n=e,i=emt(t),o=i[i.length-1];if(i.length>1){for(let a=0;a<i.length-1;a++){let s=i[a];if(n=n[s],!n)return}n[o]=r}else n[t]=r;return i.join(".")}var OI={},k1e=/-[a-z]/g,R1e=/([A-Z])/g;function wm(e){return OI[e]||(OI[e]=e.indexOf("-")<0?e:e.replace(k1e,t=>t[1].toUpperCase()))}function Ix(e){return OI[e]||(OI[e]=e.replace(R1e,"-$1").toLowerCase())}var N1e=0,rmt=0,Lx=[],D1e=0,yG=!1,nmt=document.createTextNode("");new window.MutationObserver(O1e).observe(nmt,{characterData:!0});function O1e(){yG=!1;let e=Lx.length;for(let t=0;t<e;t++){let r=Lx[t];if(r)try{r()}catch(n){setTimeout(()=>{throw n})}}Lx.splice(0,e),rmt+=e}var mo={after(e){return{run(t){return window.setTimeout(t,e)},cancel(t){window.clearTimeout(t)}}},run(e,t){return window.setTimeout(e,t)},cancel(e){window.clearTimeout(e)}};var Ni={run(e){return window.requestAnimationFrame(e)},cancel(e){window.cancelAnimationFrame(e)}};var kx={run(e){return window.requestIdleCallback?window.requestIdleCallback(e):window.setTimeout(e,16)},cancel(e){window.cancelIdleCallback?window.cancelIdleCallback(e):window.clearTimeout(e)}};var ci={run(e){return yG||(yG=!0,nmt.textContent=D1e++),Lx.push(e),N1e++},cancel(e){let t=e-rmt;if(t>=0){if(!Lx[t])throw new Error("invalid async handle: "+e);Lx[t]=null}}};var z1e=ci,zI=Nn(e=>{class t extends e{static createProperties(n){let i=this.prototype;for(let o in n)o in i||i._createPropertyAccessor(o)}static attributeNameForProperty(n){return n.toLowerCase()}static typeForProperty(n){}_createPropertyAccessor(n,i){this._addPropertyToAttributeMap(n),this.hasOwnProperty(JSCompiler_renameProperty("__dataHasAccessor",this))||(this.__dataHasAccessor=Object.assign({},this.__dataHasAccessor)),this.__dataHasAccessor[n]||(this.__dataHasAccessor[n]=!0,this._definePropertyAccessor(n,i))}_addPropertyToAttributeMap(n){this.hasOwnProperty(JSCompiler_renameProperty("__dataAttributes",this))||(this.__dataAttributes=Object.assign({},this.__dataAttributes));let i=this.__dataAttributes[n];return i||(i=this.constructor.attributeNameForProperty(n),this.__dataAttributes[i]=n),i}_definePropertyAccessor(n,i){Object.defineProperty(this,n,{get(){return this.__data[n]},set:i?function(){}:function(o){this._setPendingProperty(n,o,!0)&&this._invalidateProperties()}})}constructor(){super(),this.__dataEnabled=!1,this.__dataReady=!1,this.__dataInvalid=!1,this.__data={},this.__dataPending=null,this.__dataOld=null,this.__dataInstanceProps=null,this.__dataCounter=0,this.__serializing=!1,this._initializeProperties()}ready(){this.__dataReady=!0,this._flushProperties()}_initializeProperties(){for(let n in this.__dataHasAccessor)this.hasOwnProperty(n)&&(this.__dataInstanceProps=this.__dataInstanceProps||{},this.__dataInstanceProps[n]=this[n],delete this[n])}_initializeInstanceProperties(n){Object.assign(this,n)}_setProperty(n,i){this._setPendingProperty(n,i)&&this._invalidateProperties()}_getProperty(n){return this.__data[n]}_setPendingProperty(n,i,o){let a=this.__data[n],s=this._shouldPropertyChange(n,i,a);return s&&(this.__dataPending||(this.__dataPending={},this.__dataOld={}),this.__dataOld&&!(n in this.__dataOld)&&(this.__dataOld[n]=a),this.__data[n]=i,this.__dataPending[n]=i),s}_isPropertyPending(n){return!!(this.__dataPending&&this.__dataPending.hasOwnProperty(n))}_invalidateProperties(){!this.__dataInvalid&&this.__dataReady&&(this.__dataInvalid=!0,z1e.run(()=>{this.__dataInvalid&&(this.__dataInvalid=!1,this._flushProperties())}))}_enableProperties(){this.__dataEnabled||(this.__dataEnabled=!0,this.__dataInstanceProps&&(this._initializeInstanceProperties(this.__dataInstanceProps),this.__dataInstanceProps=null),this.ready())}_flushProperties(){this.__dataCounter++;let n=this.__data,i=this.__dataPending,o=this.__dataOld;this._shouldPropertiesChange(n,i,o)&&(this.__dataPending=null,this.__dataOld=null,this._propertiesChanged(n,i,o)),this.__dataCounter--}_shouldPropertiesChange(n,i,o){return Boolean(i)}_propertiesChanged(n,i,o){}_shouldPropertyChange(n,i,o){return o!==i&&(o===o||i===i)}attributeChangedCallback(n,i,o,a){i!==o&&this._attributeToProperty(n,o),super.attributeChangedCallback&&super.attributeChangedCallback(n,i,o,a)}_attributeToProperty(n,i,o){if(!this.__serializing){let a=this.__dataAttributes,s=a&&a[n]||n;this[s]=this._deserializeValue(i,o||this.constructor.typeForProperty(s))}}_propertyToAttribute(n,i,o){this.__serializing=!0,o=arguments.length<3?this[n]:o,this._valueToNodeAttribute(this,o,i||this.constructor.attributeNameForProperty(n)),this.__serializing=!1}_valueToNodeAttribute(n,i,o){let a=this._serializeValue(i);(o==="class"||o==="name"||o==="slot")&&(n=ue(n)),a===void 0?n.removeAttribute(o):n.setAttribute(o,a)}_serializeValue(n){switch(typeof n){case"boolean":return n?"":void 0;default:return n!=null?n.toString():void 0}}_deserializeValue(n,i){switch(i){case Boolean:return n!==null;case Number:return Number(n);default:return n}}}return t});var imt={},FI=HTMLElement.prototype;for(;FI;){let e=Object.getOwnPropertyNames(FI);for(let t=0;t<e.length;t++)imt[e[t]]=!0;FI=Object.getPrototypeOf(FI)}function F1e(e,t){if(!imt[t]){let r=e[t];r!==void 0&&(e.__data?e._setPendingProperty(t,r):(e.__dataProto?e.hasOwnProperty(JSCompiler_renameProperty("__dataProto",e))||(e.__dataProto=Object.create(e.__dataProto)):e.__dataProto={},e.__dataProto[t]=r))}}var BI=Nn(e=>{let t=zI(e);class r extends t{static createPropertiesForAttributes(){let i=this.observedAttributes;for(let o=0;o<i.length;o++)this.prototype._createPropertyAccessor(wm(i[o]))}static attributeNameForProperty(i){return Ix(i)}_initializeProperties(){this.__dataProto&&(this._initializeProtoProperties(this.__dataProto),this.__dataProto=null),super._initializeProperties()}_initializeProtoProperties(i){for(let o in i)this._setProperty(o,i[o])}_ensureAttribute(i,o){let a=this;a.hasAttribute(i)||this._valueToNodeAttribute(a,o,i)}_serializeValue(i){switch(typeof i){case"object":if(i instanceof Date)return i.toString();if(i)try{return JSON.stringify(i)}catch(o){return""}default:return super._serializeValue(i)}}_deserializeValue(i,o){let a;switch(o){case Object:try{a=JSON.parse(i)}catch(s){a=i}break;case Array:try{a=JSON.parse(i)}catch(s){a=null,console.warn(`Polymer::Attributes: couldn't decode Array as JSON: ${i}`)}break;case Date:a=isNaN(i)?String(i):Number(i),a=new Date(a);break;default:a=super._deserializeValue(i,o);break}return a}_definePropertyAccessor(i,o){F1e(this,i),super._definePropertyAccessor(i,o)}_hasAccessor(i){return this.__dataHasAccessor&&this.__dataHasAccessor[i]}_isPropertyPending(i){return Boolean(this.__dataPending&&i in this.__dataPending)}}return r});var B1e={"dom-if":!0,"dom-repeat":!0},omt=!1,amt=!1;function H1e(){if(!omt){omt=!0;let e=document.createElement("textarea");e.placeholder="a",amt=e.placeholder===e.textContent}return amt}function V1e(e){H1e()&&e.localName==="textarea"&&e.placeholder&&e.placeholder===e.textContent&&(e.textContent=null)}function U1e(e){let t=e.getAttribute("is");if(t&&B1e[t]){let r=e;for(r.removeAttribute("is"),e=r.ownerDocument.createElement(t),r.parentNode.replaceChild(e,r),e.appendChild(r);r.attributes.length;)e.setAttribute(r.attributes[0].name,r.attributes[0].value),r.removeAttribute(r.attributes[0].name)}return e}function smt(e,t){let r=t.parentInfo&&smt(e,t.parentInfo);if(r){for(let n=r.firstChild,i=0;n;n=n.nextSibling)if(t.parentIndex===i++)return n}else return e}function q1e(e,t,r,n){n.id&&(t[n.id]=r)}function G1e(e,t,r){if(r.events&&r.events.length)for(let n=0,i=r.events,o;n<i.length&&(o=i[n]);n++)e._addMethodEventListenerToNode(t,o.name,o.value,e)}function W1e(e,t,r,n){r.templateInfo&&(t._templateInfo=r.templateInfo,t._parentTemplateInfo=n)}function Y1e(e,t,r){return e=e._methodHost||e,function(i){e[r]?e[r](i,i.detail):console.warn("listener method `"+r+"` not defined")}}var lmt=Nn(e=>{class t extends e{static _parseTemplate(n,i){if(!n._templateInfo){let o=n._templateInfo={};o.nodeInfoList=[],o.nestedTemplate=Boolean(i),o.stripWhiteSpace=i&&i.stripWhiteSpace||n.hasAttribute("strip-whitespace"),this._parseTemplateContent(n,o,{parent:null})}return n._templateInfo}static _parseTemplateContent(n,i,o){return this._parseTemplateNode(n.content,i,o)}static _parseTemplateNode(n,i,o){let a=!1,s=n;return s.localName=="template"&&!s.hasAttribute("preserve-content")?a=this._parseTemplateNestedTemplate(s,i,o)||a:s.localName==="slot"&&(i.hasInsertionPoint=!0),V1e(s),s.firstChild&&this._parseTemplateChildNodes(s,i,o),s.hasAttributes&&s.hasAttributes()&&(a=this._parseTemplateNodeAttributes(s,i,o)||a),a||o.noted}static _parseTemplateChildNodes(n,i,o){if(!(n.localName==="script"||n.localName==="style"))for(let a=n.firstChild,s=0,l;a;a=l){if(a.localName=="template"&&(a=U1e(a)),l=a.nextSibling,a.nodeType===Node.TEXT_NODE){let u=l;for(;u&&u.nodeType===Node.TEXT_NODE;)a.textContent+=u.textContent,l=u.nextSibling,n.removeChild(u),u=l;if(i.stripWhiteSpace&&!a.textContent.trim()){n.removeChild(a);continue}}let c={parentIndex:s,parentInfo:o};this._parseTemplateNode(a,i,c)&&(c.infoIndex=i.nodeInfoList.push(c)-1),a.parentNode&&s++}}static _parseTemplateNestedTemplate(n,i,o){let a=n,s=this._parseTemplate(a,i);return(s.content=a.content.ownerDocument.createDocumentFragment()).appendChild(a.content),o.templateInfo=s,!0}static _parseTemplateNodeAttributes(n,i,o){let a=!1,s=Array.from(n.attributes);for(let l=s.length-1,c;c=s[l];l--)a=this._parseTemplateNodeAttribute(n,i,o,c.name,c.value)||a;return a}static _parseTemplateNodeAttribute(n,i,o,a,s){return a.slice(0,3)==="on-"?(n.removeAttribute(a),o.events=o.events||[],o.events.push({name:a.slice(3),value:s}),!0):a==="id"?(o.id=s,!0):!1}static _contentForTemplate(n){let i=n._templateInfo;return i&&i.content||n.content}_stampTemplate(n,i){n&&!n.content&&window.HTMLTemplateElement&&HTMLTemplateElement.decorate&&HTMLTemplateElement.decorate(n),i=i||this.constructor._parseTemplate(n);let o=i.nodeInfoList,a=i.content||n.content,s=document.importNode(a,!0);s.__noInsertionPoint=!i.hasInsertionPoint;let l=s.nodeList=new Array(o.length);s.$={};for(let c=0,u=o.length,h;c<u&&(h=o[c]);c++){let f=l[c]=smt(s,h);q1e(this,s.$,f,h),W1e(this,f,h,i),G1e(this,f,h)}return s=s,s}_addMethodEventListenerToNode(n,i,o,a){a=a||n;let s=Y1e(a,i,o);return this._addEventListenerToNode(n,i,s),s}_addEventListenerToNode(n,i,o){n.addEventListener(i,o)}_removeEventListenerFromNode(n,i,o){n.removeEventListener(i,o)}}return t});var jM=0,XM=[],zr={COMPUTE:"__computeEffects",REFLECT:"__reflectEffects",NOTIFY:"__notifyEffects",PROPAGATE:"__propagateEffects",OBSERVE:"__observeEffects",READ_ONLY:"__readOnly"},gmt="__computeInfo",j1e=/[A-Z]/;function vG(e,t,r){let n=e[t];if(!n)n=e[t]={};else if(!e.hasOwnProperty(t)&&(n=e[t]=Object.create(e[t]),r))for(let i in n){let o=n[i],a=n[i]=Array(o.length);for(let s=0;s<o.length;s++)a[s]=o[s]}return n}function YM(e,t,r,n,i,o){if(t){let a=!1,s=jM++;for(let l in r){let c=i?au(l):l,u=t[c];if(u)for(let h=0,f=u.length,p;h<f&&(p=u[h]);h++)(!p.info||p.info.lastRun!==s)&&(!i||SG(l,p.trigger))&&(p.info&&(p.info.lastRun=s),p.fn(e,l,r,n,p.info,i,o),a=!0)}return a}return!1}function X1e(e,t,r,n,i,o,a,s){let l=!1,c=a?au(n):n,u=t[c];if(u)for(let h=0,f=u.length,p;h<f&&(p=u[h]);h++)(!p.info||p.info.lastRun!==r)&&(!a||SG(n,p.trigger))&&(p.info&&(p.info.lastRun=r),p.fn(e,n,i,o,p.info,a,s),l=!0);return l}function SG(e,t){if(t){let r=t.name;return r==e||!!(t.structured&&gG(r,e))||!!(t.wildcard&&Ax(r,e))}else return!0}function cmt(e,t,r,n,i){let o=typeof i.method=="string"?e[i.method]:i.method,a=i.property;o?o.call(e,e.__data[a],n[a]):i.dynamicFn||console.warn("observer method `"+i.method+"` not defined")}function $1e(e,t,r,n,i){let o=e[zr.NOTIFY],a,s=jM++;for(let c in t)t[c]&&(o&&X1e(e,o,s,c,r,n,i)||i&&K1e(e,c,r))&&(a=!0);let l;a&&(l=e.__dataHost)&&l._invalidateProperties&&l._invalidateProperties()}function K1e(e,t,r){let n=au(t);if(n!==t){let i=Ix(n)+"-changed";return _mt(e,i,r[t],t),!0}return!1}function _mt(e,t,r,n){let i={value:r,queueProperty:!0};n&&(i.path=n),ue(e).dispatchEvent(new CustomEvent(t,{detail:i}))}function Z1e(e,t,r,n,i,o){let s=(o?au(t):t)!=t?t:null,l=s?No(e,s):e.__data[t];s&&l===void 0&&(l=r[t]),_mt(e,i.eventName,l,s)}function J1e(e,t,r,n,i){let o,a=e.detail,s=a&&a.path;s?(n=dp(r,n,s),o=a&&a.value):o=e.currentTarget[r],o=i?!o:o,(!t[zr.READ_ONLY]||!t[zr.READ_ONLY][n])&&t._setPendingPropertyOrPath(n,o,!0,Boolean(s))&&(!a||!a.queueProperty)&&t._invalidateProperties()}function Q1e(e,t,r,n,i){let o=e.__data[t];VM&&(o=VM(o,i.attrName,"attribute",e)),e._propertyToAttribute(t,i.attrName,o)}function tve(e,t,r,n){let i=e[zr.COMPUTE];if(i)if(Wdt){jM++;let o=rve(e),a=[];for(let l in t)umt(l,i,a,o,n);let s;for(;s=a.shift();)ymt(e,"",t,r,s)&&umt(s.methodInfo,i,a,o,n);Object.assign(r,e.__dataOld),Object.assign(t,e.__dataPending),e.__dataPending=null}else{let o=t;for(;YM(e,i,o,r,n);)Object.assign(r,e.__dataOld),Object.assign(t,e.__dataPending),o=e.__dataPending,e.__dataPending=null}}var eve=(e,t,r)=>{let n=0,i=t.length-1,o=-1;for(;n<=i;){let a=n+i>>1,s=r.get(t[a].methodInfo)-r.get(e.methodInfo);if(s<0)n=a+1;else if(s>0)i=a-1;else{o=a;break}}o<0&&(o=i+1),t.splice(o,0,e)},umt=(e,t,r,n,i)=>{let o=i?au(e):e,a=t[o];if(a)for(let s=0;s<a.length;s++){let l=a[s];l.info.lastRun!==jM&&(!i||SG(e,l.trigger))&&(l.info.lastRun=jM,eve(l.info,r,n))}};function rve(e){let t=e.constructor.__orderedComputedDeps;if(!t){t=new Map;let r=e[zr.COMPUTE],{counts:n,ready:i,total:o}=nve(e),a;for(;a=i.shift();){t.set(a,t.size);let s=r[a];s&&s.forEach(l=>{let c=l.info.methodInfo;--o,--n[c]===0&&i.push(c)})}o!==0&&console.warn(`Computed graph for ${e.localName} incomplete; circular?`),e.constructor.__orderedComputedDeps=t}return t}function nve(e){let t=e[gmt],r={},n=e[zr.COMPUTE],i=[],o=0;for(let a in t){let s=t[a];o+=r[a]=s.args.filter(l=>!l.literal).length+(s.dynamicFn?1:0)}for(let a in n)t[a]||i.push(a);return{counts:r,ready:i,total:o}}function ymt(e,t,r,n,i){let o=wG(e,t,r,n,i);if(o===XM)return!1;let a=i.methodInfo;return e.__dataHasAccessor&&e.__dataHasAccessor[a]?e._setPendingProperty(a,o,!0):(e[a]=o,!1)}function ive(e,t,r){let n=e.__dataLinkedPaths;if(n){let i;for(let o in n){let a=n[o];Ax(o,t)?(i=dp(o,a,t),e._setPendingPropertyOrPath(i,r,!0,!0)):Ax(a,t)&&(i=dp(a,o,t),e._setPendingPropertyOrPath(i,r,!0,!0))}}}function xG(e,t,r,n,i,o,a){r.bindings=r.bindings||[];let s={kind:n,target:i,parts:o,literal:a,isCompound:o.length!==1};if(r.bindings.push(s),cve(s)){let{event:c,negate:u}=s.parts[0];s.listenerEvent=c||Ix(i)+"-changed",s.listenerNegate=u}let l=t.nodeInfoList.length;for(let c=0;c<s.parts.length;c++){let u=s.parts[c];u.compoundIndex=c,ove(e,t,s,u,l)}}function ove(e,t,r,n,i){if(!n.literal)if(r.kind==="attribute"&&r.target[0]==="-")console.warn("Cannot set attribute "+r.target+' because "-" is not a valid attribute starting character');else{let o=n.dependencies,a={index:i,binding:r,part:n,evaluator:e};for(let s=0;s<o.length;s++){let l=o[s];typeof l=="string"&&(l=xmt(l),l.wildcard=!0),e._addTemplatePropertyEffect(t,l.rootProperty,{fn:ave,info:a,trigger:l})}}}function ave(e,t,r,n,i,o,a){let s=a[i.index],l=i.binding,c=i.part;if(o&&c.source&&t.length>c.source.length&&l.kind=="property"&&!l.isCompound&&s.__isPropertyEffectsClient&&s.__dataHasAccessor&&s.__dataHasAccessor[l.target]){let u=r[t];t=dp(c.source,l.target,t),s._setPendingPropertyOrPath(t,u,!1,!0)&&e._enqueueClient(s)}else{let u=i.evaluator._evaluateBinding(e,c,t,r,n,o);u!==XM&&sve(e,s,l,c,u)}}function sve(e,t,r,n,i){if(i=lve(t,i,r,n),VM&&(i=VM(i,r.target,r.kind,t)),r.kind=="attribute")e._valueToNodeAttribute(t,i,r.target);else{let o=r.target;t.__isPropertyEffectsClient&&t.__dataHasAccessor&&t.__dataHasAccessor[o]?(!t[zr.READ_ONLY]||!t[zr.READ_ONLY][o])&&t._setPendingProperty(o,i)&&e._enqueueClient(t):e._setUnmanagedPropertyToNode(t,o,i)}}function lve(e,t,r,n){if(r.isCompound){let i=e.__dataCompoundStorage[r.target];i[n.compoundIndex]=t,t=i.join("")}return r.kind!=="attribute"&&(r.target==="textContent"||r.target==="value"&&(e.localName==="input"||e.localName==="textarea"))&&(t=t==null?"":t),t}function cve(e){return Boolean(e.target)&&e.kind!="attribute"&&e.kind!="text"&&!e.isCompound&&e.parts[0].mode==="{"}function uve(e,t){let{nodeList:r,nodeInfoList:n}=t;if(n.length)for(let i=0;i<n.length;i++){let o=n[i],a=r[i],s=o.bindings;if(s)for(let l=0;l<s.length;l++){let c=s[l];hve(a,c),fve(a,e,c)}a.__dataHost=e}}function hve(e,t){if(t.isCompound){let r=e.__dataCompoundStorage||(e.__dataCompoundStorage={}),n=t.parts,i=new Array(n.length);for(let a=0;a<n.length;a++)i[a]=n[a].literal;let o=t.target;r[o]=i,t.literal&&t.kind=="property"&&(o==="className"&&(e=ue(e)),e[o]=t.literal)}}function fve(e,t,r){if(r.listenerEvent){let n=r.parts[0];e.addEventListener(r.listenerEvent,function(i){J1e(i,t,r.target,n.source,n.negate)})}}function hmt(e,t,r,n,i,o){o=t.static||o&&(typeof o!="object"||o[t.methodName]);let a={methodName:t.methodName,args:t.args,methodInfo:i,dynamicFn:o};for(let s=0,l;s<t.args.length&&(l=t.args[s]);s++)l.literal||e._addPropertyEffect(l.rootProperty,r,{fn:n,info:a,trigger:l});return o&&e._addPropertyEffect(t.methodName,r,{fn:n,info:a}),a}function wG(e,t,r,n,i){let o=e._methodHost||e,a=o[i.methodName];if(a){let s=e._marshalArgs(i.args,t,r);return s===XM?XM:a.apply(o,s)}else i.dynamicFn||console.warn("method `"+i.methodName+"` not defined")}var pve=[],vmt="(?:[a-zA-Z_$][\\w.:$\\-*]*)",dve="(?:[-+]?[0-9]*\\.?[0-9]+(?:[eE][-+]?[0-9]+)?)",mve="(?:'(?:[^'\\\\]|\\\\.)*')",gve='(?:"(?:[^"\\\\]|\\\\.)*")',_ve="(?:"+mve+"|"+gve+")",fmt="(?:("+vmt+"|"+dve+"|"+_ve+")\\s*)",yve="(?:"+fmt+"(?:,\\s*"+fmt+")*)",vve="(?:\\(\\s*(?:"+yve+"?)\\)\\s*)",xve="("+vmt+"\\s*"+vve+"?)",bve="(\\[\\[|{{)\\s*",wve="(?:]]|}})",Sve="(?:(!)\\s*)?",Mve=bve+Sve+xve+wve,pmt=new RegExp(Mve,"g");function dmt(e){let t="";for(let r=0;r<e.length;r++)t+=e[r].literal||"";return t}function bG(e){let t=e.match(/([^\s]+?)\(([\s\S]*)\)/);if(t){let n={methodName:t[1],static:!0,args:pve};if(t[2].trim()){let i=t[2].replace(/\\,/g,"&comma;").split(",");return Eve(i,n)}else return n}return null}function Eve(e,t){return t.args=e.map(function(r){let n=xmt(r);return n.literal||(t.static=!1),n},this),t}function xmt(e){let t=e.trim().replace(/&comma;/g,",").replace(/\\(.)/g,"$1"),r={name:t,value:"",literal:!1},n=t[0];switch(n==="-"&&(n=t[1]),n>="0"&&n<="9"&&(n="#"),n){case"'":case'"':r.value=t.slice(1,-1),r.literal=!0;break;case"#":r.value=Number(t),r.literal=!0;break}return r.literal||(r.rootProperty=au(t),r.structured=NI(t),r.structured&&(r.wildcard=t.slice(-2)==".*",r.wildcard&&(r.name=t.slice(0,-2)))),r}function mmt(e,t,r){let n=No(e,r);return n===void 0&&(n=t[r]),n}function bmt(e,t,r,n){let i={indexSplices:n};LI&&!e._overrideLegacyUndefined&&(t.splices=i),e.notifyPath(r+".splices",i),e.notifyPath(r+".length",t.length),LI&&!e._overrideLegacyUndefined&&(i.indexSplices=[])}function GM(e,t,r,n,i,o){bmt(e,t,r,[{index:n,addedCount:i,removed:o,object:t,type:"splice"}])}function Tve(e){return e[0].toUpperCase()+e.substring(1)}var u_=Nn(e=>{let t=lmt(BI(e));class r extends t{constructor(){super(),this.__isPropertyEffectsClient=!0,this.__dataClientsReady,this.__dataPendingClients,this.__dataToNotify,this.__dataLinkedPaths,this.__dataHasPaths,this.__dataCompoundStorage,this.__dataHost,this.__dataTemp,this.__dataClientsInitialized,this.__data,this.__dataPending,this.__dataOld,this.__computeEffects,this.__computeInfo,this.__reflectEffects,this.__notifyEffects,this.__propagateEffects,this.__observeEffects,this.__readOnly,this.__templateInfo,this._overrideLegacyUndefined}get PROPERTY_EFFECT_TYPES(){return zr}_initializeProperties(){super._initializeProperties(),this._registerHost(),this.__dataClientsReady=!1,this.__dataPendingClients=null,this.__dataToNotify=null,this.__dataLinkedPaths=null,this.__dataHasPaths=!1,this.__dataCompoundStorage=this.__dataCompoundStorage||null,this.__dataHost=this.__dataHost||null,this.__dataTemp={},this.__dataClientsInitialized=!1}_registerHost(){if(WM.length){let i=WM[WM.length-1];i._enqueueClient(this),this.__dataHost=i}}_initializeProtoProperties(i){this.__data=Object.create(i),this.__dataPending=Object.create(i),this.__dataOld={}}_initializeInstanceProperties(i){let o=this[zr.READ_ONLY];for(let a in i)(!o||!o[a])&&(this.__dataPending=this.__dataPending||{},this.__dataOld=this.__dataOld||{},this.__data[a]=this.__dataPending[a]=i[a])}_addPropertyEffect(i,o,a){this._createPropertyAccessor(i,o==zr.READ_ONLY);let s=vG(this,o,!0)[i];s||(s=this[o][i]=[]),s.push(a)}_removePropertyEffect(i,o,a){let s=vG(this,o,!0)[i],l=s.indexOf(a);l>=0&&s.splice(l,1)}_hasPropertyEffect(i,o){let a=this[o];return Boolean(a&&a[i])}_hasReadOnlyEffect(i){return this._hasPropertyEffect(i,zr.READ_ONLY)}_hasNotifyEffect(i){return this._hasPropertyEffect(i,zr.NOTIFY)}_hasReflectEffect(i){return this._hasPropertyEffect(i,zr.REFLECT)}_hasComputedEffect(i){return this._hasPropertyEffect(i,zr.COMPUTE)}_setPendingPropertyOrPath(i,o,a,s){if(s||au(Array.isArray(i)?i[0]:i)!==i){if(!s){let l=No(this,i);if(i=_G(this,i,o),!i||!super._shouldPropertyChange(i,o,l))return!1}if(this.__dataHasPaths=!0,this._setPendingProperty(i,o,a))return ive(this,i,o),!0}else{if(this.__dataHasAccessor&&this.__dataHasAccessor[i])return this._setPendingProperty(i,o,a);this[i]=o}return!1}_setUnmanagedPropertyToNode(i,o,a){(a!==i[o]||typeof a=="object")&&(o==="className"&&(i=ue(i)),i[o]=a)}_setPendingProperty(i,o,a){let s=this.__dataHasPaths&&NI(i),l=s?this.__dataTemp:this.__data;return this._shouldPropertyChange(i,o,l[i])?(this.__dataPending||(this.__dataPending={},this.__dataOld={}),i in this.__dataOld||(this.__dataOld[i]=this.__data[i]),s?this.__dataTemp[i]=o:this.__data[i]=o,this.__dataPending[i]=o,(s||this[zr.NOTIFY]&&this[zr.NOTIFY][i])&&(this.__dataToNotify=this.__dataToNotify||{},this.__dataToNotify[i]=a),!0):!1}_setProperty(i,o){this._setPendingProperty(i,o,!0)&&this._invalidateProperties()}_invalidateProperties(){this.__dataReady&&this._flushProperties()}_enqueueClient(i){this.__dataPendingClients=this.__dataPendingClients||[],i!==this&&this.__dataPendingClients.push(i)}_flushClients(){this.__dataClientsReady?this.__enableOrFlushClients():(this.__dataClientsReady=!0,this._readyClients(),this.__dataReady=!0)}__enableOrFlushClients(){let i=this.__dataPendingClients;if(i){this.__dataPendingClients=null;for(let o=0;o<i.length;o++){let a=i[o];a.__dataEnabled?a.__dataPending&&a._flushProperties():a._enableProperties()}}}_readyClients(){this.__enableOrFlushClients()}setProperties(i,o){for(let a in i)(o||!this[zr.READ_ONLY]||!this[zr.READ_ONLY][a])&&this._setPendingPropertyOrPath(a,i[a],!0);this._invalidateProperties()}ready(){this._flushProperties(),this.__dataClientsReady||this._flushClients(),this.__dataPending&&this._flushProperties()}_propertiesChanged(i,o,a){let s=this.__dataHasPaths;this.__dataHasPaths=!1;let l;tve(this,o,a,s),l=this.__dataToNotify,this.__dataToNotify=null,this._propagatePropertyChanges(o,a,s),this._flushClients(),YM(this,this[zr.REFLECT],o,a,s),YM(this,this[zr.OBSERVE],o,a,s),l&&$1e(this,l,o,a,s),this.__dataCounter==1&&(this.__dataTemp={})}_propagatePropertyChanges(i,o,a){this[zr.PROPAGATE]&&YM(this,this[zr.PROPAGATE],i,o,a),this.__templateInfo&&this._runEffectsForTemplate(this.__templateInfo,i,o,a)}_runEffectsForTemplate(i,o,a,s){let l=(c,u)=>{YM(this,i.propertyEffects,c,a,u,i.nodeList);for(let h=i.firstChild;h;h=h.nextSibling)this._runEffectsForTemplate(h,c,a,u)};i.runEffects?i.runEffects(l,o,s):l(o,s)}linkPaths(i,o){i=Px(i),o=Px(o),this.__dataLinkedPaths=this.__dataLinkedPaths||{},this.__dataLinkedPaths[i]=o}unlinkPaths(i){i=Px(i),this.__dataLinkedPaths&&delete this.__dataLinkedPaths[i]}notifySplices(i,o){let a={path:""},s=No(this,i,a);bmt(this,s,a.path,o)}get(i,o){return No(o||this,i)}set(i,o,a){a?_G(a,i,o):(!this[zr.READ_ONLY]||!this[zr.READ_ONLY][i])&&this._setPendingPropertyOrPath(i,o,!0)&&this._invalidateProperties()}push(i,...o){let a={path:""},s=No(this,i,a),l=s.length,c=s.push(...o);return o.length&&GM(this,s,a.path,l,o.length,[]),c}pop(i){let o={path:""},a=No(this,i,o),s=Boolean(a.length),l=a.pop();return s&&GM(this,a,o.path,a.length,0,[l]),l}splice(i,o,a,...s){let l={path:""},c=No(this,i,l);o<0?o=c.length-Math.floor(-o):o&&(o=Math.floor(o));let u;return arguments.length===2?u=c.splice(o):u=c.splice(o,a,...s),(s.length||u.length)&&GM(this,c,l.path,o,s.length,u),u}shift(i){let o={path:""},a=No(this,i,o),s=Boolean(a.length),l=a.shift();return s&&GM(this,a,o.path,0,0,[l]),l}unshift(i,...o){let a={path:""},s=No(this,i,a),l=s.unshift(...o);return o.length&&GM(this,s,a.path,0,o.length,[]),l}notifyPath(i,o){let a;if(arguments.length==1){let s={path:""};o=No(this,i,s),a=s.path}else Array.isArray(i)?a=Px(i):a=i;this._setPendingPropertyOrPath(a,o,!0,!0)&&this._invalidateProperties()}_createReadOnlyProperty(i,o){this._addPropertyEffect(i,zr.READ_ONLY),o&&(this["_set"+Tve(i)]=function(a){this._setProperty(i,a)})}_createPropertyObserver(i,o,a){let s={property:i,method:o,dynamicFn:Boolean(a)};this._addPropertyEffect(i,zr.OBSERVE,{fn:cmt,info:s,trigger:{name:i}}),a&&this._addPropertyEffect(o,zr.OBSERVE,{fn:cmt,info:s,trigger:{name:o}})}_createMethodObserver(i,o){let a=bG(i);if(!a)throw new Error("Malformed observer expression '"+i+"'");hmt(this,a,zr.OBSERVE,wG,null,o)}_createNotifyingProperty(i){this._addPropertyEffect(i,zr.NOTIFY,{fn:Z1e,info:{eventName:Ix(i)+"-changed",property:i}})}_createReflectedProperty(i){let o=this.constructor.attributeNameForProperty(i);o[0]==="-"?console.warn("Property "+i+" cannot be reflected to attribute "+o+' because "-" is not a valid starting attribute name. Use a lowercase first letter for the property instead.'):this._addPropertyEffect(i,zr.REFLECT,{fn:Q1e,info:{attrName:o}})}_createComputedProperty(i,o,a){let s=bG(o);if(!s)throw new Error("Malformed computed expression '"+o+"'");let l=hmt(this,s,zr.COMPUTE,ymt,i,a);vG(this,gmt)[i]=l}_marshalArgs(i,o,a){let s=this.__data,l=[];for(let c=0,u=i.length;c<u;c++){let{name:h,structured:f,wildcard:p,value:d,literal:g}=i[c];if(!g)if(p){let _=Ax(h,o),y=mmt(s,a,_?o:h);d={path:_?o:h,value:y,base:_?No(s,h):y}}else d=f?mmt(s,a,h):s[h];if(LI&&!this._overrideLegacyUndefined&&d===void 0&&i.length>1)return XM;l[c]=d}return l}static addPropertyEffect(i,o,a){this.prototype._addPropertyEffect(i,o,a)}static createPropertyObserver(i,o,a){this.prototype._createPropertyObserver(i,o,a)}static createMethodObserver(i,o){this.prototype._createMethodObserver(i,o)}static createNotifyingProperty(i){this.prototype._createNotifyingProperty(i)}static createReadOnlyProperty(i,o){this.prototype._createReadOnlyProperty(i,o)}static createReflectedProperty(i){this.prototype._createReflectedProperty(i)}static createComputedProperty(i,o,a){this.prototype._createComputedProperty(i,o,a)}static bindTemplate(i){return this.prototype._bindTemplate(i)}_bindTemplate(i,o){let a=this.constructor._parseTemplate(i),s=this.__preBoundTemplateInfo==a;if(!s)for(let l in a.propertyEffects)this._createPropertyAccessor(l);if(o)if(a=Object.create(a),a.wasPreBound=s,!this.__templateInfo)this.__templateInfo=a;else{let l=i._parentTemplateInfo||this.__templateInfo,c=l.lastChild;a.parent=l,l.lastChild=a,a.previousSibling=c,c?c.nextSibling=a:l.firstChild=a}else this.__preBoundTemplateInfo=a;return a}static _addTemplatePropertyEffect(i,o,a){let s=i.hostProps=i.hostProps||{};s[o]=!0;let l=i.propertyEffects=i.propertyEffects||{};(l[o]=l[o]||[]).push(a)}_stampTemplate(i,o){o=o||this._bindTemplate(i,!0),WM.push(this);let a=super._stampTemplate(i,o);if(WM.pop(),o.nodeList=a.nodeList,!o.wasPreBound){let s=o.childNodes=[];for(let l=a.firstChild;l;l=l.nextSibling)s.push(l)}return a.templateInfo=o,uve(this,o),this.__dataClientsReady&&(this._runEffectsForTemplate(o,this.__data,null,!1),this._flushClients()),a}_removeBoundDom(i){let o=i.templateInfo,{previousSibling:a,nextSibling:s,parent:l}=o;a?a.nextSibling=s:l&&(l.firstChild=s),s?s.previousSibling=a:l&&(l.lastChild=a),o.nextSibling=o.previousSibling=null;let c=o.childNodes;for(let u=0;u<c.length;u++){let h=c[u];ue(ue(h).parentNode).removeChild(h)}}static _parseTemplateNode(i,o,a){let s=t._parseTemplateNode.call(this,i,o,a);if(i.nodeType===Node.TEXT_NODE){let l=this._parseBindings(i.textContent,o);l&&(i.textContent=dmt(l)||" ",xG(this,o,a,"text","textContent",l),s=!0)}return s}static _parseTemplateNodeAttribute(i,o,a,s,l){let c=this._parseBindings(l,o);if(c){let u=s,h="property";j1e.test(s)?h="attribute":s[s.length-1]=="$"&&(s=s.slice(0,-1),h="attribute");let f=dmt(c);return f&&h=="attribute"&&(s=="class"&&i.hasAttribute("class")&&(f+=" "+i.getAttribute(s)),i.setAttribute(s,f)),h=="attribute"&&u=="disable-upgrade$"&&i.setAttribute(s,""),i.localName==="input"&&u==="value"&&i.setAttribute(u,""),i.removeAttribute(u),h==="property"&&(s=wm(s)),xG(this,o,a,h,s,c,f),!0}else return t._parseTemplateNodeAttribute.call(this,i,o,a,s,l)}static _parseTemplateNestedTemplate(i,o,a){let s=t._parseTemplateNestedTemplate.call(this,i,o,a),l=i.parentNode,c=a.templateInfo,u=l.localName==="dom-if",h=l.localName==="dom-repeat";fG&&(u||h)&&(l.removeChild(i),a=a.parentInfo,a.templateInfo=c,a.noted=!0,s=!1);let f=c.hostProps;if(kI&&u)f&&(o.hostProps=Object.assign(o.hostProps||{},f),fG||(a.parentInfo.noted=!0));else{let p="{";for(let d in f){let g=[{mode:p,source:d,dependencies:[d],hostProp:!0}];xG(this,o,a,"property","_host_"+d,g)}}return s}static _parseBindings(i,o){let a=[],s=0,l;for(;(l=pmt.exec(i))!==null;){l.index>s&&a.push({literal:i.slice(s,l.index)});let c=l[1][0],u=Boolean(l[2]),h=l[3].trim(),f=!1,p="",d=-1;c=="{"&&(d=h.indexOf("::"))>0&&(p=h.substring(d+2),h=h.substring(0,d),f=!0);let g=bG(h),_=[];if(g){let{args:y,methodName:x}=g;for(let S=0;S<y.length;S++){let C=y[S];C.literal||_.push(C)}let b=o.dynamicFns;(b&&b[x]||g.static)&&(_.push(x),g.dynamicFn=!0)}else _.push(h);a.push({source:h,mode:c,negate:u,customEvent:f,signature:g,dependencies:_,event:p}),s=pmt.lastIndex}if(s&&s<i.length){let c=i.substring(s);c&&a.push({literal:c})}return a.length?a:null}static _evaluateBinding(i,o,a,s,l,c){let u;return o.signature?u=wG(i,a,s,l,o.signature):a!=o.source?u=No(i,o.source):c&&NI(a)?u=No(i,a):u=i.__data[a],o.negate&&(u=!u),u}}return r}),WM=[];var Cve=0;function wmt(){Cve++}var Ave=[];function HI(e){Ave.push(e)}function Pve(e){let t={};for(let r in e){let n=e[r];t[r]=typeof n=="function"?{type:n}:n}return t}var Smt=Nn(e=>{let t=zI(e);function r(o){let a=Object.getPrototypeOf(o);return a.prototype instanceof i?a:null}function n(o){if(!o.hasOwnProperty(JSCompiler_renameProperty("__ownProperties",o))){let a=null;if(o.hasOwnProperty(JSCompiler_renameProperty("properties",o))){let s=o.properties;s&&(a=Pve(s))}o.__ownProperties=a}return o.__ownProperties}class i extends t{static get observedAttributes(){if(!this.hasOwnProperty(JSCompiler_renameProperty("__observedAttributes",this))){HI(this.prototype);let a=this._properties;this.__observedAttributes=a?Object.keys(a).map(s=>this.prototype._addPropertyToAttributeMap(s)):[]}return this.__observedAttributes}static finalize(){if(!this.hasOwnProperty(JSCompiler_renameProperty("__finalized",this))){let a=r(this);a&&a.finalize(),this.__finalized=!0,this._finalizeClass()}}static _finalizeClass(){let a=n(this);a&&this.createProperties(a)}static get _properties(){if(!this.hasOwnProperty(JSCompiler_renameProperty("__properties",this))){let a=r(this);this.__properties=Object.assign({},a&&a._properties,n(this))}return this.__properties}static typeForProperty(a){let s=this._properties[a];return s&&s.type}_initializeProperties(){wmt(),this.constructor.finalize(),super._initializeProperties()}connectedCallback(){super.connectedCallback&&super.connectedCallback(),this._enableProperties()}disconnectedCallback(){super.disconnectedCallback&&super.disconnectedCallback()}}return i});var Mmt="3.4.1",VI=window.ShadyCSS&&window.ShadyCSS.cssBuild,Sm=Nn(e=>{let t=Smt(u_(e));function r(l){if(!l.hasOwnProperty(JSCompiler_renameProperty("__propertyDefaults",l))){l.__propertyDefaults=null;let c=l._properties;for(let u in c){let h=c[u];"value"in h&&(l.__propertyDefaults=l.__propertyDefaults||{},l.__propertyDefaults[u]=h)}}return l.__propertyDefaults}function n(l){return l.hasOwnProperty(JSCompiler_renameProperty("__ownObservers",l))||(l.__ownObservers=l.hasOwnProperty(JSCompiler_renameProperty("observers",l))?l.observers:null),l.__ownObservers}function i(l,c,u,h){u.computed&&(u.readOnly=!0),u.computed&&(l._hasReadOnlyEffect(c)?console.warn(`Cannot redefine computed property '${c}'.`):l._createComputedProperty(c,u.computed,h)),u.readOnly&&!l._hasReadOnlyEffect(c)?l._createReadOnlyProperty(c,!u.computed):u.readOnly===!1&&l._hasReadOnlyEffect(c)&&console.warn(`Cannot make readOnly property '${c}' non-readOnly.`),u.reflectToAttribute&&!l._hasReflectEffect(c)?l._createReflectedProperty(c):u.reflectToAttribute===!1&&l._hasReflectEffect(c)&&console.warn(`Cannot make reflected property '${c}' non-reflected.`),u.notify&&!l._hasNotifyEffect(c)?l._createNotifyingProperty(c):u.notify===!1&&l._hasNotifyEffect(c)&&console.warn(`Cannot make notify property '${c}' non-notify.`),u.observer&&l._createPropertyObserver(c,u.observer,h[u.observer]),l._addPropertyToAttributeMap(c)}function o(l,c,u,h){if(!VI){let f=c.content.querySelectorAll("style"),p=RI(c),d=Qdt(u),g=c.content.firstElementChild;for(let y=0;y<d.length;y++){let x=d[y];x.textContent=l._processStyleText(x.textContent,h),c.content.insertBefore(x,g)}let _=0;for(let y=0;y<p.length;y++){let x=p[y],b=f[_];b!==x?(x=x.cloneNode(!0),b.parentNode.insertBefore(x,b)):_++,x.textContent=l._processStyleText(x.textContent,h)}}if(window.ShadyCSS&&window.ShadyCSS.prepareTemplate(c,u),Ydt&&VI&&Hdt){let f=c.content.querySelectorAll("style");if(f){let p="";Array.from(f).forEach(d=>{p+=d.textContent,d.parentNode.removeChild(d)}),l._styleSheet=new CSSStyleSheet,l._styleSheet.replaceSync(p)}}}function a(l){let c=null;if(l&&(!iu||qdt)&&(c=ou.import(l,"template"),iu&&!c))throw new Error(`strictTemplatePolicy: expecting dom-module or null template for ${l}`);return c}class s extends t{static get polymerElementVersion(){return Mmt}static _finalizeClass(){t._finalizeClass.call(this);let c=n(this);c&&this.createObservers(c,this._properties),this._prepareTemplate()}static _prepareTemplate(){let c=this.template;c&&(typeof c=="string"?(console.error("template getter must return HTMLTemplateElement"),c=null):pp||(c=c.cloneNode(!0))),this.prototype._template=c}static createProperties(c){for(let u in c)i(this.prototype,u,c[u],c)}static createObservers(c,u){let h=this.prototype;for(let f=0;f<c.length;f++)h._createMethodObserver(c[f],u)}static get template(){if(!this.hasOwnProperty(JSCompiler_renameProperty("_template",this))){let c=this.prototype.hasOwnProperty(JSCompiler_renameProperty("_template",this.prototype))?this.prototype._template:void 0;this._template=c!==void 0?c:this.hasOwnProperty(JSCompiler_renameProperty("is",this))&&a(this.is)||Object.getPrototypeOf(this.prototype).constructor.template}return this._template}static set template(c){this._template=c}static get importPath(){if(!this.hasOwnProperty(JSCompiler_renameProperty("_importPath",this))){let c=this.importMeta;if(c)this._importPath=Cx(c.url);else{let u=ou.import(this.is);this._importPath=u&&u.assetpath||Object.getPrototypeOf(this.prototype).constructor.importPath}}return this._importPath}constructor(){super(),this._template,this._importPath,this.rootPath,this.importPath,this.root,this.$}_initializeProperties(){this.constructor.finalize(),this.constructor._finalizeTemplate(this.localName),super._initializeProperties(),this.rootPath=Vdt,this.importPath=this.constructor.importPath;let c=r(this.constructor);if(!!c)for(let u in c){let h=c[u];if(this._canApplyPropertyDefault(u)){let f=typeof h.value=="function"?h.value.call(this):h.value;this._hasAccessor(u)?this._setPendingProperty(u,f,!0):this[u]=f}}}_canApplyPropertyDefault(c){return!this.hasOwnProperty(c)}static _processStyleText(c,u){return HM(c,u)}static _finalizeTemplate(c){let u=this.prototype._template;if(u&&!u.__polymerFinalized){u.__polymerFinalized=!0;let h=this.importPath,f=h?l_(h):"";o(this,u,c,f),this.prototype._bindTemplate(u)}}connectedCallback(){window.ShadyCSS&&this._template&&window.ShadyCSS.styleElement(this),super.connectedCallback()}ready(){this._template&&(this.root=this._stampTemplate(this._template),this.$=this.root.$),super.ready()}_readyClients(){this._template&&(this.root=this._attachDom(this.root)),super._readyClients()}_attachDom(c){let u=ue(this);if(u.attachShadow)return c?(u.shadowRoot||(u.attachShadow({mode:"open",shadyUpgradeFragment:c}),u.shadowRoot.appendChild(c),this.constructor._styleSheet&&(u.shadowRoot.adoptedStyleSheets=[this.constructor._styleSheet])),Gdt&&window.ShadyDOM&&window.ShadyDOM.flushInitial(u.shadowRoot),u.shadowRoot):null;throw new Error("ShadowDOM not available. PolymerElement can create dom as children instead of in ShadowDOM by setting `this.root = this;` before `ready`.")}updateStyles(c){window.ShadyCSS&&window.ShadyCSS.styleSubtree(this,c)}resolveUrl(c,u){return!u&&this.importPath&&(u=l_(this.importPath)),l_(c,u)}static _parseTemplateContent(c,u,h){return u.dynamicFns=u.dynamicFns||this._properties,t._parseTemplateContent.call(this,c,u,h)}static _addTemplatePropertyEffect(c,u,h){return II&&!(u in this._properties)&&!(h.info.part.signature&&h.info.part.signature.static)&&!h.info.part.hostProp&&!c.nestedTemplate&&console.warn(`Property '${u}' used in template but not declared in 'properties'; attribute will not be observed.`),t._addTemplatePropertyEffect.call(this,c,u,h)}}return s});var UI=class{constructor(t){this.value=t.toString()}toString(){return this.value}};function Ive(e){if(e instanceof UI)return e.value;throw new Error(`non-literal value passed to Polymer's htmlLiteral function: ${e}`)}function Lve(e){if(e instanceof HTMLTemplateElement)return e.innerHTML;if(e instanceof UI)return Ive(e);throw new Error(`non-template value passed to Polymer's html function: ${e}`)}var Q=function(t,...r){let n=document.createElement("template");return n.innerHTML=r.reduce((i,o,a)=>i+Lve(o)+t[a+1],t[0]),n};var mt=Sm(HTMLElement);var fy=Ee(Oe(),1);var h_=!(window.ShadyDOM&&window.ShadyDOM.inUse),qI;function Emt(e){e&&e.shimcssproperties?qI=!1:qI=h_||Boolean(!navigator.userAgent.match(/AppleWebKit\/601|Edge\/15/)&&window.CSS&&CSS.supports&&CSS.supports("box-shadow","0 0 0 var(--foo)"))}var Mm;window.ShadyCSS&&window.ShadyCSS.cssBuild!==void 0&&(Mm=window.ShadyCSS.cssBuild);var GI=Boolean(window.ShadyCSS&&window.ShadyCSS.disableRuntime);window.ShadyCSS&&window.ShadyCSS.nativeCss!==void 0?qI=window.ShadyCSS.nativeCss:window.ShadyCSS?(Emt(window.ShadyCSS),window.ShadyCSS=void 0):Emt(window.WebComponents&&window.WebComponents.flags);var Nx=qI;var WI=class{constructor(){this.start=0,this.end=0,this.previous=null,this.parent=null,this.rules=null,this.parsedCssText="",this.cssText="",this.atRule=!1,this.type=0,this.keyframesName="",this.selector="",this.parsedSelector=""}};function MG(e){return e=kve(e),Tmt(Rve(e),e)}function kve(e){return e.replace(gp.comments,"").replace(gp.port,"")}function Rve(e){let t=new WI;t.start=0,t.end=e.length;let r=t;for(let n=0,i=e.length;n<i;n++)if(e[n]===Cmt){r.rules||(r.rules=[]);let o=r,a=o.rules[o.rules.length-1]||null;r=new WI,r.start=n+1,r.parent=o,r.previous=a,o.rules.push(r)}else e[n]===Amt&&(r.end=n+1,r=r.parent||t);return t}function Tmt(e,t){let r=t.substring(e.start,e.end-1);if(e.parsedCssText=e.cssText=r.trim(),e.parent){let i=e.previous?e.previous.end:e.parent.start;r=t.substring(i,e.start-1),r=Nve(r),r=r.replace(gp.multipleSpaces," "),r=r.substring(r.lastIndexOf(";")+1);let o=e.parsedSelector=e.selector=r.trim();e.atRule=o.indexOf(Hve)===0,e.atRule?o.indexOf(Bve)===0?e.type=mp.MEDIA_RULE:o.match(gp.keyframesRule)&&(e.type=mp.KEYFRAMES_RULE,e.keyframesName=e.selector.split(gp.multipleSpaces).pop()):o.indexOf(Pmt)===0?e.type=mp.MIXIN_RULE:e.type=mp.STYLE_RULE}let n=e.rules;if(n)for(let i=0,o=n.length,a;i<o&&(a=n[i]);i++)Tmt(a,t);return e}function Nve(e){return e.replace(/\\([0-9a-f]{1,6})\s/gi,function(){let t=arguments[1],r=6-t.length;for(;r--;)t="0"+t;return"\\"+t})}function EG(e,t,r=""){let n="";if(e.cssText||e.rules){let i=e.rules;if(i&&!Dve(i))for(let o=0,a=i.length,s;o<a&&(s=i[o]);o++)n=EG(s,t,n);else n=t?e.cssText:Ove(e.cssText),n=n.trim(),n&&(n="  "+n+`
`)}return n&&(e.selector&&(r+=e.selector+" "+Cmt+`
`),r+=n,e.selector&&(r+=Amt+`

`)),r}function Dve(e){let t=e[0];return Boolean(t)&&Boolean(t.selector)&&t.selector.indexOf(Pmt)===0}function Ove(e){return e=zve(e),Fve(e)}function zve(e){return e.replace(gp.customProp,"").replace(gp.mixinProp,"")}function Fve(e){return e.replace(gp.mixinApply,"").replace(gp.varApply,"")}var mp={STYLE_RULE:1,KEYFRAMES_RULE:7,MEDIA_RULE:4,MIXIN_RULE:1e3},Cmt="{",Amt="}",gp={comments:/\/\*[^*]*\*+([^/*][^*]*\*+)*\//gim,port:/@import[^;]*;/gim,customProp:/(?:^[^;\-\s}]+)?--[^;{}]*?:[^{};]*?(?:[;\n]|$)/gim,mixinProp:/(?:^[^;\-\s}]+)?--[^;{}]*?:[^{};]*?{[^}]*?}(?:[;\n]|$)?/gim,mixinApply:/@apply\s*\(?[^);]*\)?\s*(?:[;\n]|$)?/gim,varApply:/[^;:]*?:[^;]*?var\([^;]*\)(?:[;\n]|$)?/gim,keyframesRule:/^@[^\s]*keyframes/,multipleSpaces:/\s+/g},Pmt="--",Bve="@media",Hve="@";var KM=/(?:^|[;\s{]\s*)(--[\w-]*?)\s*:\s*(?:((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};{])+)|\{([^}]*)\}(?:(?=[;\s}])|$))/gi,Dx=/(?:^|\W+)@apply\s*\(?([^);\n]*)\)?/gi;var Imt=/@media\s(.*)/;var Lmt=new Set,Vve="shady-unscoped";function kmt(e){let t=e.textContent;if(!Lmt.has(t)){Lmt.add(t);let r=document.createElement("style");r.setAttribute("shady-unscoped",""),r.textContent=t,document.head.appendChild(r)}}function Rmt(e){return e.hasAttribute(Vve)}function ZM(e,t){return e?(typeof e=="string"&&(e=MG(e)),t&&Ox(e,t),EG(e,Nx)):""}function TG(e){return!e.__cssRules&&e.textContent&&(e.__cssRules=MG(e.textContent)),e.__cssRules||null}function Ox(e,t,r,n){if(!e)return;let i=!1,o=e.type;if(n&&o===mp.MEDIA_RULE){let s=e.selector.match(Imt);s&&(window.matchMedia(s[1]).matches||(i=!0))}o===mp.STYLE_RULE?t(e):r&&o===mp.KEYFRAMES_RULE?r(e):o===mp.MIXIN_RULE&&(i=!0);let a=e.rules;if(a&&!i)for(let s=0,l=a.length,c;s<l&&(c=a[s]);s++)Ox(c,t,r,n)}function Uve(e,t){let r=0;for(let n=t,i=e.length;n<i;n++)if(e[n]==="(")r++;else if(e[n]===")"&&--r===0)return n;return-1}function CG(e,t){let r=e.indexOf("var(");if(r===-1)return t(e,"","","");let n=Uve(e,r+3),i=e.substring(r+4,n),o=e.substring(0,r),a=CG(e.substring(n+1),t),s=i.indexOf(",");if(s===-1)return t(o,i.trim(),"",a);let l=i.substring(0,s).trim(),c=i.substring(s+1).trim();return t(o,l,c,a)}var n1r=window.ShadyDOM&&window.ShadyDOM.wrap||(e=>e);function Nmt(e){let t=e.localName,r="",n="";return t?t.indexOf("-")>-1?r=t:(n=t,r=e.getAttribute&&e.getAttribute("is")||""):(r=e.is,n=e.extends),{is:r,typeExtension:n}}function Dmt(e){let t=[],r=e.querySelectorAll("style");for(let n=0;n<r.length;n++){let i=r[n];Rmt(i)?h_||(kmt(i),i.parentNode.removeChild(i)):(t.push(i.textContent),i.parentNode.removeChild(i))}return t.join("").trim()}var Omt="css-build";function qve(e){if(Mm!==void 0)return Mm;if(e.__cssBuild===void 0){let t=e.getAttribute(Omt);if(t)e.__cssBuild=t;else{let r=Gve(e);r!==""&&Wve(e),e.__cssBuild=r}}return e.__cssBuild||""}function AG(e){return qve(e)!==""}function Gve(e){let t=e.localName==="template"?e.content.firstChild:e.firstChild;if(t instanceof Comment){let r=t.textContent.trim().split(":");if(r[0]===Omt)return r[1]}return""}function Wve(e){let t=e.localName==="template"?e.content.firstChild:e.firstChild;t.parentNode.removeChild(t)}function JM(e,t){for(let r in t)r===null?e.style.removeProperty(r):e.style.setProperty(r,t[r])}function YI(e,t){let r=window.getComputedStyle(e).getPropertyValue(t);return r?r.trim():""}function zmt(e){let t=Dx.test(e)||KM.test(e);return Dx.lastIndex=0,KM.lastIndex=0,t}var Yve=/;\s*/m,jve=/^\s*(initial)|(inherit)\s*$/,Fmt=/\s*!important/,PG="_-_";var IG=class{constructor(){this._map={}}set(t,r){t=t.trim(),this._map[t]={properties:r,dependants:{}}}get(t){return t=t.trim(),this._map[t]||null}},jI=null,Do=class{constructor(){this._currentElement=null,this._measureElement=null,this._map=new IG}detectMixin(t){return zmt(t)}gatherStyles(t){let r=Dmt(t.content);if(r){let n=document.createElement("style");return n.textContent=r,t.content.insertBefore(n,t.content.firstChild),n}return null}transformTemplate(t,r){t._gatheredStyle===void 0&&(t._gatheredStyle=this.gatherStyles(t));let n=t._gatheredStyle;return n?this.transformStyle(n,r):null}transformStyle(t,r=""){let n=TG(t);return this.transformRules(n,r),t.textContent=ZM(n),n}transformCustomStyle(t){let r=TG(t);return Ox(r,n=>{n.selector===":root"&&(n.selector="html"),this.transformRule(n)}),t.textContent=ZM(r),r}transformRules(t,r){this._currentElement=r,Ox(t,n=>{this.transformRule(n)}),this._currentElement=null}transformRule(t){t.cssText=this.transformCssText(t.parsedCssText,t),t.selector===":root"&&(t.selector=":host > *")}transformCssText(t,r){return t=t.replace(KM,(n,i,o,a)=>this._produceCssProperties(n,i,o,a,r)),this._consumeCssProperties(t,r)}_getInitialValueForProperty(t){return this._measureElement||(this._measureElement=document.createElement("meta"),this._measureElement.setAttribute("apply-shim-measure",""),this._measureElement.style.all="initial",document.head.appendChild(this._measureElement)),window.getComputedStyle(this._measureElement).getPropertyValue(t)}_fallbacksFromPreviousRules(t){let r=t;for(;r.parent;)r=r.parent;let n={},i=!1;return Ox(r,o=>{i=i||o===t,!i&&o.selector===t.selector&&Object.assign(n,this._cssTextToMap(o.parsedCssText))}),n}_consumeCssProperties(t,r){let n=null;for(;n=Dx.exec(t);){let i=n[0],o=n[1],a=n.index,s=a+i.indexOf("@apply"),l=a+i.length,c=t.slice(0,s),u=t.slice(l),h=r?this._fallbacksFromPreviousRules(r):{};Object.assign(h,this._cssTextToMap(c));let f=this._atApplyToCssProperties(o,h);t=`${c}${f}${u}`,Dx.lastIndex=a+f.length}return t}_atApplyToCssProperties(t,r){t=t.replace(Yve,"");let n=[],i=this._map.get(t);if(i||(this._map.set(t,{}),i=this._map.get(t)),i){this._currentElement&&(i.dependants[this._currentElement]=!0);let o,a,s,l=i.properties;for(o in l)s=r&&r[o],a=[o,": var(",t,PG,o],s&&a.push(",",s.replace(Fmt,"")),a.push(")"),Fmt.test(l[o])&&a.push(" !important"),n.push(a.join(""))}return n.join("; ")}_replaceInitialOrInherit(t,r){let n=jve.exec(r);return n&&(n[1]?r=this._getInitialValueForProperty(t):r="apply-shim-inherit"),r}_cssTextToMap(t,r=!1){let n=t.split(";"),i,o,a={};for(let s=0,l,c;s<n.length;s++)l=n[s],l&&(c=l.split(":"),c.length>1&&(i=c[0].trim(),o=c.slice(1).join(":"),r&&(o=this._replaceInitialOrInherit(i,o)),a[i]=o));return a}_invalidateMixinEntry(t){if(!!jI)for(let r in t.dependants)r!==this._currentElement&&jI(r)}_produceCssProperties(t,r,n,i,o){if(n&&CG(n,(_,y)=>{y&&this._map.get(y)&&(i=`@apply ${y};`)}),!i)return t;let a=this._consumeCssProperties(""+i,o),s=t.slice(0,t.indexOf("--")),l=this._cssTextToMap(a,!0),c=l,u=this._map.get(r),h=u&&u.properties;h?c=Object.assign(Object.create(h),l):this._map.set(r,c);let f=[],p,d,g=!1;for(p in c)d=l[p],d===void 0&&(d="initial"),h&&!(p in h)&&(g=!0),f.push(`${r}${PG}${p}: ${d}`);return g&&this._invalidateMixinEntry(u),u&&(u.properties=c),n&&(s=`${t};${s}`),`${s}${f.join("; ")};`}};Do.prototype.detectMixin=Do.prototype.detectMixin;Do.prototype.transformStyle=Do.prototype.transformStyle;Do.prototype.transformCustomStyle=Do.prototype.transformCustomStyle;Do.prototype.transformRules=Do.prototype.transformRules;Do.prototype.transformRule=Do.prototype.transformRule;Do.prototype.transformTemplate=Do.prototype.transformTemplate;Do.prototype._separator=PG;Object.defineProperty(Do.prototype,"invalidCallback",{get(){return jI},set(e){jI=e}});var Bmt=Do;var Xve={},QM=Xve;var XI="_applyShimCurrentVersion",zx="_applyShimNextVersion",$I="_applyShimValidatingVersion",$ve=Promise.resolve();function Hmt(e){let t=QM[e];t&&Kve(t)}function Kve(e){e[XI]=e[XI]||0,e[$I]=e[$I]||0,e[zx]=(e[zx]||0)+1}function LG(e){return e[XI]===e[zx]}function Vmt(e){return!LG(e)&&e[$I]===e[zx]}function Umt(e){e[$I]=e[zx],e._validating||(e._validating=!0,$ve.then(function(){e[XI]=e[zx],e._validating=!1}))}var kG=null,qmt=window.HTMLImports&&window.HTMLImports.whenReady||null,RG;function KI(e){requestAnimationFrame(function(){qmt?qmt(e):(kG||(kG=new Promise(t=>{RG=t}),document.readyState==="complete"?RG():document.addEventListener("readystatechange",()=>{document.readyState==="complete"&&RG()})),kG.then(function(){e&&e()}))})}var Gmt="__seenByShadyCSS",ZI="__shadyCSSCachedStyle",JI=null,tE=null,Zl=class{constructor(){this.customStyles=[],this.enqueued=!1,KI(()=>{window.ShadyCSS.flushCustomStyles&&window.ShadyCSS.flushCustomStyles()})}enqueueDocumentValidation(){this.enqueued||!tE||(this.enqueued=!0,KI(tE))}addCustomStyle(t){t[Gmt]||(t[Gmt]=!0,this.customStyles.push(t),this.enqueueDocumentValidation())}getStyleForCustomStyle(t){if(t[ZI])return t[ZI];let r;return t.getStyle?r=t.getStyle():r=t,r}processStyles(){let t=this.customStyles;for(let r=0;r<t.length;r++){let n=t[r];if(n[ZI])continue;let i=this.getStyleForCustomStyle(n);if(i){let o=i.__appliedElement||i;JI&&JI(o),n[ZI]=o}}return t}};Zl.prototype.addCustomStyle=Zl.prototype.addCustomStyle;Zl.prototype.getStyleForCustomStyle=Zl.prototype.getStyleForCustomStyle;Zl.prototype.processStyles=Zl.prototype.processStyles;Object.defineProperties(Zl.prototype,{transformCallback:{get(){return JI},set(e){JI=e}},validateCallback:{get(){return tE},set(e){let t=!1;tE||(t=!0),tE=e,t&&this.enqueueDocumentValidation()}}});var eE=new Bmt,NG=class{constructor(){this.customStyleInterface=null,eE.invalidCallback=Hmt}ensure(){this.customStyleInterface||window.ShadyCSS.CustomStyleInterface&&(this.customStyleInterface=window.ShadyCSS.CustomStyleInterface,this.customStyleInterface.transformCallback=t=>{eE.transformCustomStyle(t)},this.customStyleInterface.validateCallback=()=>{requestAnimationFrame(()=>{this.customStyleInterface.enqueued&&this.flushCustomStyles()})})}prepareTemplate(t,r){if(this.ensure(),AG(t))return;QM[r]=t;let n=eE.transformTemplate(t,r);t._styleAst=n}flushCustomStyles(){if(this.ensure(),!this.customStyleInterface)return;let t=this.customStyleInterface.processStyles();if(!!this.customStyleInterface.enqueued){for(let r=0;r<t.length;r++){let n=t[r],i=this.customStyleInterface.getStyleForCustomStyle(n);i&&eE.transformCustomStyle(i)}this.customStyleInterface.enqueued=!1}}styleSubtree(t,r){if(this.ensure(),r&&JM(t,r),t.shadowRoot){this.styleElement(t);let n=t.shadowRoot.children||t.shadowRoot.childNodes;for(let i=0;i<n.length;i++)this.styleSubtree(n[i])}else{let n=t.children||t.childNodes;for(let i=0;i<n.length;i++)this.styleSubtree(n[i])}}styleElement(t){this.ensure();let{is:r}=Nmt(t),n=QM[r];if(!(n&&AG(n))&&n&&!LG(n)){Vmt(n)||(this.prepareTemplate(n,r),Umt(n));let i=t.shadowRoot;if(i){let o=i.querySelector("style");o&&(o.__cssRules=n._styleAst,o.textContent=ZM(n._styleAst))}}}styleDocument(t){this.ensure(),this.styleSubtree(document.body,t)}};if(!window.ShadyCSS||!window.ShadyCSS.ScopingShim){let e=new NG,t=window.ShadyCSS&&window.ShadyCSS.CustomStyleInterface;window.ShadyCSS={prepareTemplate(r,n,i){e.flushCustomStyles(),e.prepareTemplate(r,n)},prepareTemplateStyles(r,n,i){window.ShadyCSS.prepareTemplate(r,n,i)},prepareTemplateDom(r,n){},styleSubtree(r,n){e.flushCustomStyles(),e.styleSubtree(r,n)},styleElement(r){e.flushCustomStyles(),e.styleElement(r)},styleDocument(r){e.flushCustomStyles(),e.styleDocument(r)},getComputedStyleValue(r,n){return YI(r,n)},flushCustomStyles(){e.flushCustomStyles()},nativeCss:Nx,nativeShadow:h_,cssBuild:Mm,disableRuntime:GI},t&&(window.ShadyCSS.CustomStyleInterface=t)}window.ShadyCSS.ApplyShim=eE;var sr=class{constructor(){this._asyncModule=null,this._callback=null,this._timer=null}setConfig(t,r){this._asyncModule=t,this._callback=r,this._timer=this._asyncModule.run(()=>{this._timer=null,rE.delete(this),this._callback()})}cancel(){this.isActive()&&(this._cancelAsync(),rE.delete(this))}_cancelAsync(){this.isActive()&&(this._asyncModule.cancel(this._timer),this._timer=null)}flush(){this.isActive()&&(this.cancel(),this._callback())}isActive(){return this._timer!=null}static debounce(t,r,n){return t instanceof sr?t._cancelAsync():t=new sr,t.setConfig(r,n),t}},rE=new Set,Jl=function(e){rE.add(e)},Wmt=function(){let e=Boolean(rE.size);return rE.forEach(t=>{try{t.flush()}catch(r){setTimeout(()=>{throw r})}}),e};var FG=typeof document.head.style.touchAction=="string",t9="__polymerGestures",QI="__polymerGesturesHandled",OG="__polymerGesturesTouchAction",Ymt=25,jmt=5,Jve=2,Qve=2500,Jmt=["mousedown","mousemove","mouseup","click"],txe=[0,1,4,2],exe=function(){try{return new MouseEvent("test",{buttons:1}).buttons===1}catch(e){return!1}}();function BG(e){return Jmt.indexOf(e)>-1}var HG=!1;(function(){try{let e=Object.defineProperty({},"passive",{get(){HG=!0}});window.addEventListener("test",null,e),window.removeEventListener("test",null,e)}catch(e){}})();function Qmt(e){if(!(BG(e)||e==="touchend")&&FG&&HG&&Udt)return{passive:!0}}var tgt=navigator.userAgent.match(/iP(?:[oa]d|hone)|Android/),zG=[],rxe={button:!0,input:!0,keygen:!0,meter:!0,output:!0,textarea:!0,progress:!0,select:!0},nxe={button:!0,command:!0,fieldset:!0,input:!0,keygen:!0,optgroup:!0,option:!0,select:!0,textarea:!0};function ixe(e){return rxe[e.localName]||!1}function oxe(e){let t=Array.prototype.slice.call(e.labels||[]);if(!t.length){t=[];let r=e.getRootNode();if(e.id){let n=r.querySelectorAll(`label[for = ${e.id}]`);for(let i=0;i<n.length;i++)t.push(n[i])}}return t}var Xmt=function(e){let t=e.sourceCapabilities;if(!(t&&!t.firesTouchEvents)&&(e[QI]={skip:!0},e.type==="click")){let r=!1,n=r9(e);for(let i=0;i<n.length;i++){if(n[i].nodeType===Node.ELEMENT_NODE){if(n[i].localName==="label")zG.push(n[i]);else if(ixe(n[i])){let o=oxe(n[i]);for(let a=0;a<o.length;a++)r=r||zG.indexOf(o[a])>-1}}if(n[i]===ia.mouse.target)return}if(r)return;e.preventDefault(),e.stopPropagation()}};function $mt(e){let t=tgt?["click"]:Jmt;for(let r=0,n;r<t.length;r++)n=t[r],e?(zG.length=0,document.addEventListener(n,Xmt,!0)):document.removeEventListener(n,Xmt,!0)}function axe(e){if(!hG)return;ia.mouse.mouseIgnoreJob||$mt(!0);let t=function(){$mt(),ia.mouse.target=null,ia.mouse.mouseIgnoreJob=null};ia.mouse.target=r9(e)[0],ia.mouse.mouseIgnoreJob=sr.debounce(ia.mouse.mouseIgnoreJob,mo.after(Qve),t)}function p_(e){let t=e.type;if(!BG(t))return!1;if(t==="mousemove"){let r=e.buttons===void 0?1:e.buttons;return e instanceof window.MouseEvent&&!exe&&(r=txe[e.which]||0),Boolean(r&1)}else return(e.button===void 0?0:e.button)===0}function sxe(e){if(e.type==="click"){if(e.detail===0)return!0;let t=_p(e);if(!t.nodeType||t.nodeType!==Node.ELEMENT_NODE)return!0;let r=t.getBoundingClientRect(),n=e.pageX,i=e.pageY;return!(n>=r.left&&n<=r.right&&i>=r.top&&i<=r.bottom)}return!1}var ia={mouse:{target:null,mouseIgnoreJob:null},touch:{x:0,y:0,id:-1,scrollDecided:!1}};function lxe(e){let t="auto",r=r9(e);for(let n=0,i;n<r.length;n++)if(i=r[n],i[OG]){t=i[OG];break}return t}function egt(e,t,r){e.movefn=t,e.upfn=r,document.addEventListener("mousemove",t),document.addEventListener("mouseup",r)}function Fx(e){document.removeEventListener("mousemove",e.movefn),document.removeEventListener("mouseup",e.upfn),e.movefn=null,e.upfn=null}hG&&document.addEventListener("touchend",axe,HG?{passive:!0}:!1);var r9=window.ShadyDOM&&window.ShadyDOM.noPatch?window.ShadyDOM.composedPath:e=>e.composedPath&&e.composedPath()||[],iE={},f_=[];function cxe(e,t){let r=document.elementFromPoint(e,t),n=r;for(;n&&n.shadowRoot&&!window.ShadyDOM;){let i=n;if(n=n.shadowRoot.elementFromPoint(e,t),i===n)break;n&&(r=n)}return r}function _p(e){let t=r9(e);return t.length>0?t[0]:e.target}function rgt(e){let t,r=e.type,i=e.currentTarget[t9];if(!i)return;let o=i[r];if(!!o){if(!e[QI]&&(e[QI]={},r.slice(0,5)==="touch")){e=e;let a=e.changedTouches[0];if(r==="touchstart"&&e.touches.length===1&&(ia.touch.id=a.identifier),ia.touch.id!==a.identifier)return;FG||(r==="touchstart"||r==="touchmove")&&uxe(e)}if(t=e[QI],!t.skip){for(let a=0,s;a<f_.length;a++)s=f_[a],o[s.name]&&!t[s.name]&&s.flow&&s.flow.start.indexOf(e.type)>-1&&s.reset&&s.reset();for(let a=0,s;a<f_.length;a++)s=f_[a],o[s.name]&&!t[s.name]&&(t[s.name]=!0,s[r](e))}}}function uxe(e){let t=e.changedTouches[0],r=e.type;if(r==="touchstart")ia.touch.x=t.clientX,ia.touch.y=t.clientY,ia.touch.scrollDecided=!1;else if(r==="touchmove"){if(ia.touch.scrollDecided)return;ia.touch.scrollDecided=!0;let n=lxe(e),i=!1,o=Math.abs(ia.touch.x-t.clientX),a=Math.abs(ia.touch.y-t.clientY);e.cancelable&&(n==="none"?i=!0:n==="pan-x"?i=a>o:n==="pan-y"&&(i=o>a)),i?e.preventDefault():e9("track")}}function Em(e,t,r){return iE[t]?(hxe(e,t,r),!0):!1}function ngt(e,t,r){return iE[t]?(fxe(e,t,r),!0):!1}function hxe(e,t,r){let n=iE[t],i=n.deps,o=n.name,a=e[t9];a||(e[t9]=a={});for(let s=0,l,c;s<i.length;s++)l=i[s],!(tgt&&BG(l)&&l!=="click")&&(c=a[l],c||(a[l]=c={_count:0}),c._count===0&&e.addEventListener(l,rgt,Qmt(l)),c[o]=(c[o]||0)+1,c._count=(c._count||0)+1);e.addEventListener(t,r),n.touchAction&&d_(e,n.touchAction)}function fxe(e,t,r){let n=iE[t],i=n.deps,o=n.name,a=e[t9];if(a)for(let s=0,l,c;s<i.length;s++)l=i[s],c=a[l],c&&c[o]&&(c[o]=(c[o]||1)-1,c._count=(c._count||1)-1,c._count===0&&e.removeEventListener(l,rgt,Qmt(l)));e.removeEventListener(t,r)}function VG(e){f_.push(e);for(let t=0;t<e.emits.length;t++)iE[e.emits[t]]=e}function pxe(e){for(let t=0,r;t<f_.length;t++){r=f_[t];for(let n=0,i;n<r.emits.length;n++)if(i=r.emits[n],i===e)return r}return null}function d_(e,t){FG&&e instanceof HTMLElement&&ci.run(()=>{e.style.touchAction=t}),e[OG]=t}function UG(e,t,r){let n=new Event(t,{bubbles:!0,cancelable:!0,composed:!0});if(n.detail=r,ue(e).dispatchEvent(n),n.defaultPrevented){let i=r.preventer||r.sourceEvent;i&&i.preventDefault&&i.preventDefault()}}function e9(e){let t=pxe(e);t.info&&(t.info.prevent=!0)}VG({name:"downup",deps:["mousedown","touchstart","touchend"],flow:{start:["mousedown","touchstart"],end:["mouseup","touchend"]},emits:["down","up"],info:{movefn:null,upfn:null},reset:function(){Fx(this.info)},mousedown:function(e){if(!p_(e))return;let t=_p(e),r=this,n=function(a){p_(a)||(nE("up",t,a),Fx(r.info))},i=function(a){p_(a)&&nE("up",t,a),Fx(r.info)};egt(this.info,n,i),nE("down",t,e)},touchstart:function(e){nE("down",_p(e),e.changedTouches[0],e)},touchend:function(e){nE("up",_p(e),e.changedTouches[0],e)}});function nE(e,t,r,n){!t||UG(t,e,{x:r.clientX,y:r.clientY,sourceEvent:r,preventer:n,prevent:function(i){return e9(i)}})}VG({name:"track",touchAction:"none",deps:["mousedown","touchstart","touchmove","touchend"],flow:{start:["mousedown","touchstart"],end:["mouseup","touchend"]},emits:["track"],info:{x:0,y:0,state:"start",started:!1,moves:[],addMove:function(e){this.moves.length>Jve&&this.moves.shift(),this.moves.push(e)},movefn:null,upfn:null,prevent:!1},reset:function(){this.info.state="start",this.info.started=!1,this.info.moves=[],this.info.x=0,this.info.y=0,this.info.prevent=!1,Fx(this.info)},mousedown:function(e){if(!p_(e))return;let t=_p(e),r=this,n=function(a){let s=a.clientX,l=a.clientY;Kmt(r.info,s,l)&&(r.info.state=r.info.started?a.type==="mouseup"?"end":"track":"start",r.info.state==="start"&&e9("tap"),r.info.addMove({x:s,y:l}),p_(a)||(r.info.state="end",Fx(r.info)),t&&DG(r.info,t,a),r.info.started=!0)},i=function(a){r.info.started&&n(a),Fx(r.info)};egt(this.info,n,i),this.info.x=e.clientX,this.info.y=e.clientY},touchstart:function(e){let t=e.changedTouches[0];this.info.x=t.clientX,this.info.y=t.clientY},touchmove:function(e){let t=_p(e),r=e.changedTouches[0],n=r.clientX,i=r.clientY;Kmt(this.info,n,i)&&(this.info.state==="start"&&e9("tap"),this.info.addMove({x:n,y:i}),DG(this.info,t,r),this.info.state="track",this.info.started=!0)},touchend:function(e){let t=_p(e),r=e.changedTouches[0];this.info.started&&(this.info.state="end",this.info.addMove({x:r.clientX,y:r.clientY}),DG(this.info,t,r))}});function Kmt(e,t,r){if(e.prevent)return!1;if(e.started)return!0;let n=Math.abs(e.x-t),i=Math.abs(e.y-r);return n>=jmt||i>=jmt}function DG(e,t,r){if(!t)return;let n=e.moves[e.moves.length-2],i=e.moves[e.moves.length-1],o=i.x-e.x,a=i.y-e.y,s,l=0;n&&(s=i.x-n.x,l=i.y-n.y),UG(t,"track",{state:e.state,x:r.clientX,y:r.clientY,dx:o,dy:a,ddx:s,ddy:l,sourceEvent:r,hover:function(){return cxe(r.clientX,r.clientY)}})}VG({name:"tap",deps:["mousedown","click","touchstart","touchend"],flow:{start:["mousedown","touchstart"],end:["click","touchend"]},emits:["tap"],info:{x:NaN,y:NaN,prevent:!1},reset:function(){this.info.x=NaN,this.info.y=NaN,this.info.prevent=!1},mousedown:function(e){p_(e)&&(this.info.x=e.clientX,this.info.y=e.clientY)},click:function(e){p_(e)&&Zmt(this.info,e)},touchstart:function(e){let t=e.changedTouches[0];this.info.x=t.clientX,this.info.y=t.clientY},touchend:function(e){Zmt(this.info,e.changedTouches[0],e)}});function Zmt(e,t,r){let n=Math.abs(t.clientX-e.x),i=Math.abs(t.clientY-e.y),o=_p(r||t);!o||nxe[o.localName]&&o.hasAttribute("disabled")||(isNaN(n)||isNaN(i)||n<=Ymt&&i<=Ymt||sxe(t))&&(e.prevent||UG(o,"tap",{x:t.clientX,y:t.clientY,sourceEvent:t,preventer:r}))}var igt=_p;var yh=Nn(e=>{class t extends e{_addEventListenerToNode(n,i,o){Em(n,i,o)||super._addEventListenerToNode(n,i,o)}_removeEventListenerFromNode(n,i,o){ngt(n,i,o)||super._removeEventListenerFromNode(n,i,o)}}return t});var dxe=/:host\(:dir\((ltr|rtl)\)\)/g,mxe=':host([dir="$1"])',gxe=/([\s\w-#\.\[\]\*]*):dir\((ltr|rtl)\)/g,_xe=':host([dir="$2"]) $1',yxe=/:dir\((?:ltr|rtl)\)/,agt=Boolean(window.ShadyDOM&&window.ShadyDOM.inUse),oE=[],aE=null,qG="";function sgt(){qG=document.documentElement.getAttribute("dir")}function lgt(e){e.__autoDirOptOut||e.setAttribute("dir",qG)}function cgt(){sgt(),qG=document.documentElement.getAttribute("dir");for(let e=0;e<oE.length;e++)lgt(oE[e])}function vxe(){aE&&aE.takeRecords().length&&cgt()}var ugt=Nn(e=>{agt||aE||(sgt(),aE=new MutationObserver(cgt),aE.observe(document.documentElement,{attributes:!0,attributeFilter:["dir"]}));let t=BI(e);class r extends t{static _processStyleText(i,o){return i=t._processStyleText.call(this,i,o),!agt&&yxe.test(i)&&(i=this._replaceDirInCssText(i),this.__activateDir=!0),i}static _replaceDirInCssText(i){let o=i;return o=o.replace(dxe,mxe),o=o.replace(gxe,_xe),o}constructor(){super(),this.__autoDirOptOut=!1}ready(){super.ready(),this.__autoDirOptOut=this.hasAttribute("dir")}connectedCallback(){t.prototype.connectedCallback&&super.connectedCallback(),this.constructor.__activateDir&&(vxe(),oE.push(this),lgt(this))}disconnectedCallback(){if(t.prototype.disconnectedCallback&&super.disconnectedCallback(),this.constructor.__activateDir){let i=oE.indexOf(this);i>-1&&oE.splice(i,1)}}}return r.__activateDir=!1,r});var n9=!1,hgt=[],fgt=[];function pgt(){n9=!0,requestAnimationFrame(function(){n9=!1,xxe(hgt),setTimeout(function(){bxe(fgt)})})}function xxe(e){for(;e.length;)dgt(e.shift())}function bxe(e){for(let t=0,r=e.length;t<r;t++)dgt(e.shift())}function dgt(e){let t=e[0],r=e[1],n=e[2];try{r.apply(t,n)}catch(i){setTimeout(()=>{throw i})}}function mgt(e,t,r){n9||pgt(),hgt.push([e,t,r])}function Tm(e,t,r){n9||pgt(),fgt.push([e,t,r])}function ggt(){document.body.removeAttribute("unresolved")}document.readyState==="interactive"||document.readyState==="complete"?ggt():window.addEventListener("DOMContentLoaded",ggt);function sE(e,t,r){return{index:e,removed:t,addedCount:r}}var _gt=0,ygt=1,GG=2,WG=3;function wxe(e,t,r,n,i,o){let a=o-i+1,s=r-t+1,l=new Array(a);for(let c=0;c<a;c++)l[c]=new Array(s),l[c][0]=c;for(let c=0;c<s;c++)l[0][c]=c;for(let c=1;c<a;c++)for(let u=1;u<s;u++)if(YG(e[t+u-1],n[i+c-1]))l[c][u]=l[c-1][u-1];else{let h=l[c-1][u]+1,f=l[c][u-1]+1;l[c][u]=h<f?h:f}return l}function Sxe(e){let t=e.length-1,r=e[0].length-1,n=e[t][r],i=[];for(;t>0||r>0;){if(t==0){i.push(GG),r--;continue}if(r==0){i.push(WG),t--;continue}let o=e[t-1][r-1],a=e[t-1][r],s=e[t][r-1],l;a<s?l=a<o?a:o:l=s<o?s:o,l==o?(o==n?i.push(_gt):(i.push(ygt),n=o),t--,r--):l==a?(i.push(WG),t--,n=a):(i.push(GG),r--,n=s)}return i.reverse(),i}function Mxe(e,t,r,n,i,o){let a=0,s=0,l,c=Math.min(r-t,o-i);if(t==0&&i==0&&(a=Exe(e,n,c)),r==e.length&&o==n.length&&(s=Txe(e,n,c-a)),t+=a,i+=a,r-=s,o-=s,r-t==0&&o-i==0)return[];if(t==r){for(l=sE(t,[],0);i<o;)l.removed.push(n[i++]);return[l]}else if(i==o)return[sE(t,[],r-t)];let u=Sxe(wxe(e,t,r,n,i,o));l=void 0;let h=[],f=t,p=i;for(let d=0;d<u.length;d++)switch(u[d]){case _gt:l&&(h.push(l),l=void 0),f++,p++;break;case ygt:l||(l=sE(f,[],0)),l.addedCount++,f++,l.removed.push(n[p]),p++;break;case GG:l||(l=sE(f,[],0)),l.addedCount++,f++;break;case WG:l||(l=sE(f,[],0)),l.removed.push(n[p]),p++;break}return l&&h.push(l),h}function Exe(e,t,r){for(let n=0;n<r;n++)if(!YG(e[n],t[n]))return n;return r}function Txe(e,t,r){let n=e.length,i=t.length,o=0;for(;o<r&&YG(e[--n],t[--i]);)o++;return o}function i9(e,t){return Mxe(e,0,e.length,t,0,t.length)}function YG(e,t){return e===t}function Bx(e){return e.localName==="slot"}var vh=class{static getFlattenedNodes(e){let t=ue(e);return Bx(e)?(e=e,t.assignedNodes({flatten:!0})):Array.from(t.childNodes).map(r=>Bx(r)?(r=r,ue(r).assignedNodes({flatten:!0})):[r]).reduce((r,n)=>r.concat(n),[])}constructor(e,t){this._shadyChildrenObserver=null,this._nativeChildrenObserver=null,this._connected=!1,this._target=e,this.callback=t,this._effectiveNodes=[],this._observer=null,this._scheduled=!1,this._boundSchedule=()=>{this._schedule()},this.connect(),this._schedule()}connect(){Bx(this._target)?this._listenSlots([this._target]):ue(this._target).children&&(this._listenSlots(ue(this._target).children),window.ShadyDOM?this._shadyChildrenObserver=window.ShadyDOM.observeChildren(this._target,e=>{this._processMutations(e)}):(this._nativeChildrenObserver=new MutationObserver(e=>{this._processMutations(e)}),this._nativeChildrenObserver.observe(this._target,{childList:!0}))),this._connected=!0}disconnect(){Bx(this._target)?this._unlistenSlots([this._target]):ue(this._target).children&&(this._unlistenSlots(ue(this._target).children),window.ShadyDOM&&this._shadyChildrenObserver?(window.ShadyDOM.unobserveChildren(this._shadyChildrenObserver),this._shadyChildrenObserver=null):this._nativeChildrenObserver&&(this._nativeChildrenObserver.disconnect(),this._nativeChildrenObserver=null)),this._connected=!1}_schedule(){this._scheduled||(this._scheduled=!0,ci.run(()=>this.flush()))}_processMutations(e){this._processSlotMutations(e),this.flush()}_processSlotMutations(e){if(e)for(let t=0;t<e.length;t++){let r=e[t];r.addedNodes&&this._listenSlots(r.addedNodes),r.removedNodes&&this._unlistenSlots(r.removedNodes)}}flush(){if(!this._connected)return!1;window.ShadyDOM&&ShadyDOM.flush(),this._nativeChildrenObserver?this._processSlotMutations(this._nativeChildrenObserver.takeRecords()):this._shadyChildrenObserver&&this._processSlotMutations(this._shadyChildrenObserver.takeRecords()),this._scheduled=!1;let e={target:this._target,addedNodes:[],removedNodes:[]},t=this.constructor.getFlattenedNodes(this._target),r=i9(t,this._effectiveNodes);for(let i=0,o;i<r.length&&(o=r[i]);i++)for(let a=0,s;a<o.removed.length&&(s=o.removed[a]);a++)e.removedNodes.push(s);for(let i=0,o;i<r.length&&(o=r[i]);i++)for(let a=o.index;a<o.index+o.addedCount;a++)e.addedNodes.push(t[a]);this._effectiveNodes=t;let n=!1;return(e.addedNodes.length||e.removedNodes.length)&&(n=!0,this.callback.call(this._target,e)),n}_listenSlots(e){for(let t=0;t<e.length;t++){let r=e[t];Bx(r)&&r.addEventListener("slotchange",this._boundSchedule)}}_unlistenSlots(e){for(let t=0;t<e.length;t++){let r=e[t];Bx(r)&&r.removeEventListener("slotchange",this._boundSchedule)}}};var ui=function(){let e,t;do e=window.ShadyDOM&&ShadyDOM.flush(),window.ShadyCSS&&window.ShadyCSS.ScopingShim&&window.ShadyCSS.ScopingShim.flush(),t=Wmt();while(e||t)};var Hx=Element.prototype,Cxe=Hx.matches||Hx.matchesSelector||Hx.mozMatchesSelector||Hx.msMatchesSelector||Hx.oMatchesSelector||Hx.webkitMatchesSelector,XG=function(e,t){return Cxe.call(e,t)},Kr=class{constructor(t){window.ShadyDOM&&window.ShadyDOM.inUse&&window.ShadyDOM.patch(t),this.node=t}observeNodes(t){return new vh(this.node,t)}unobserveNodes(t){t.disconnect()}notifyObserver(){}deepContains(t){if(ue(this.node).contains(t))return!0;let r=t,n=t.ownerDocument;for(;r&&r!==n&&r!==this.node;)r=ue(r).parentNode||ue(r).host;return r===this.node}getOwnerRoot(){return ue(this.node).getRootNode()}getDistributedNodes(){return this.node.localName==="slot"?ue(this.node).assignedNodes({flatten:!0}):[]}getDestinationInsertionPoints(){let t=[],r=ue(this.node).assignedSlot;for(;r;)t.push(r),r=ue(r).assignedSlot;return t}importNode(t,r){let n=this.node instanceof Document?this.node:this.node.ownerDocument;return ue(n).importNode(t,r)}getEffectiveChildNodes(){return vh.getFlattenedNodes(this.node)}queryDistributedElements(t){let r=this.getEffectiveChildNodes(),n=[];for(let i=0,o=r.length,a;i<o&&(a=r[i]);i++)a.nodeType===Node.ELEMENT_NODE&&XG(a,t)&&n.push(a);return n}get activeElement(){let t=this.node;return t._activeElement!==void 0?t._activeElement:t.activeElement}};function Axe(e,t){for(let r=0;r<t.length;r++){let n=t[r];e[n]=function(){return this.node[n].apply(this.node,arguments)}}}function vgt(e,t){for(let r=0;r<t.length;r++){let n=t[r];Object.defineProperty(e,n,{get:function(){return this.node[n]},configurable:!0})}}function Pxe(e,t){for(let r=0;r<t.length;r++){let n=t[r];Object.defineProperty(e,n,{get:function(){return this.node[n]},set:function(i){this.node[n]=i},configurable:!0})}}var lE=class{constructor(t){this.event=t}get rootTarget(){return this.path[0]}get localTarget(){return this.event.target}get path(){return this.event.composedPath()}};Kr.prototype.cloneNode;Kr.prototype.appendChild;Kr.prototype.insertBefore;Kr.prototype.removeChild;Kr.prototype.replaceChild;Kr.prototype.setAttribute;Kr.prototype.removeAttribute;Kr.prototype.querySelector;Kr.prototype.querySelectorAll;Kr.prototype.parentNode;Kr.prototype.firstChild;Kr.prototype.lastChild;Kr.prototype.nextSibling;Kr.prototype.previousSibling;Kr.prototype.firstElementChild;Kr.prototype.lastElementChild;Kr.prototype.nextElementSibling;Kr.prototype.previousElementSibling;Kr.prototype.childNodes;Kr.prototype.children;Kr.prototype.classList;Kr.prototype.textContent;Kr.prototype.innerHTML;var jG=Kr;if(window.ShadyDOM&&window.ShadyDOM.inUse&&window.ShadyDOM.noPatch&&window.ShadyDOM.Wrapper){class e extends window.ShadyDOM.Wrapper{}Object.getOwnPropertyNames(Kr.prototype).forEach(t=>{t!="activeElement"&&(e.prototype[t]=Kr.prototype[t])}),vgt(e.prototype,["classList"]),jG=e,Object.defineProperties(lE.prototype,{localTarget:{get(){let t=this.event.currentTarget,r=t&&zt(t).getOwnerRoot(),n=this.path;for(let i=0;i<n.length;i++){let o=n[i];if(zt(o).getOwnerRoot()===r)return o}},configurable:!0},path:{get(){return window.ShadyDOM.composedPath(this.event)},configurable:!0}})}else Axe(Kr.prototype,["cloneNode","appendChild","insertBefore","removeChild","replaceChild","setAttribute","removeAttribute","querySelector","querySelectorAll"]),vgt(Kr.prototype,["parentNode","firstChild","lastChild","nextSibling","previousSibling","firstElementChild","lastElementChild","nextElementSibling","previousElementSibling","childNodes","children","classList"]),Pxe(Kr.prototype,["textContent","innerHTML","className"]);var zt=function(e){if(e=e||document,e instanceof jG||e instanceof lE)return e;let t=e.__domApi;return t||(e instanceof Event?t=new lE(e):t=new jG(e),e.__domApi=t),t};var $G=window.ShadyDOM,xgt=window.ShadyCSS;function bgt(e,t){return ue(e).getRootNode()===t}function wgt(e,t=!1){if(!$G||!xgt||!$G.handlesDynamicScoping)return null;let r=xgt.ScopingShim;if(!r)return null;let n=r.scopeForNode(e),i=ue(e).getRootNode(),o=a=>{if(!bgt(a,i))return;let s=Array.from($G.nativeMethods.querySelectorAll.call(a,"*"));s.push(a);for(let l=0;l<s.length;l++){let c=s[l];if(!bgt(c,i))continue;let u=r.currentScopeForNode(c);u!==n&&(u!==""&&r.unscopeNode(c,u),r.scopeNode(c,n))}};if(o(e),t){let a=new MutationObserver(s=>{for(let l=0;l<s.length;l++){let c=s[l];for(let u=0;u<c.addedNodes.length;u++){let h=c.addedNodes[u];h.nodeType===Node.ELEMENT_NODE&&o(h)}}});return a.observe(e,{childList:!0,subtree:!0}),a}else return null}var KG="disable-upgrade",ZG=e=>{for(;e;){let t=Object.getOwnPropertyDescriptor(e,"observedAttributes");if(t)return t.get;e=Object.getPrototypeOf(e.prototype).constructor}return()=>[]},gvr=Nn(e=>{let t=Sm(e),r=ZG(t);class n extends t{constructor(){super(),this.__isUpgradeDisabled}static get observedAttributes(){return r.call(this).concat(KG)}_initializeProperties(){this.hasAttribute(KG)?this.__isUpgradeDisabled=!0:super._initializeProperties()}_enableProperties(){this.__isUpgradeDisabled||super._enableProperties()}_canApplyPropertyDefault(o){return super._canApplyPropertyDefault(o)&&!(this.__isUpgradeDisabled&&this._isPropertyPending(o))}attributeChangedCallback(o,a,s,l){o==KG?this.__isUpgradeDisabled&&s==null&&(super._initializeProperties(),this.__isUpgradeDisabled=!1,ue(this).isConnected&&super.connectedCallback()):super.attributeChangedCallback(o,a,s,l)}connectedCallback(){this.__isUpgradeDisabled||super.connectedCallback()}disconnectedCallback(){this.__isUpgradeDisabled||super.disconnectedCallback()}}return n});var o9="disable-upgrade",Ixe=window.ShadyCSS,Gt=Nn(e=>{let t=yh(Sm(e)),r=VI?t:ugt(t),n=ZG(r),i={x:"pan-x",y:"pan-y",none:"none",all:"auto"};class o extends r{constructor(){super(),this.isAttached,this.__boundListeners,this._debouncers,this.__isUpgradeDisabled,this.__needsAttributesAtConnected,this._legacyForceObservedAttributes}static get importMeta(){return this.prototype.importMeta}created(){}__attributeReaction(s,l,c){(this.__dataAttributes&&this.__dataAttributes[s]||s===o9)&&this.attributeChangedCallback(s,l,c,null)}setAttribute(s,l){if(qM&&!this._legacyForceObservedAttributes){let c=this.getAttribute(s);super.setAttribute(s,l),this.__attributeReaction(s,c,String(l))}else super.setAttribute(s,l)}removeAttribute(s){if(qM&&!this._legacyForceObservedAttributes){let l=this.getAttribute(s);super.removeAttribute(s),this.__attributeReaction(s,l,null)}else super.removeAttribute(s)}static get observedAttributes(){return qM&&!this.prototype._legacyForceObservedAttributes?(this.hasOwnProperty(JSCompiler_renameProperty("__observedAttributes",this))||(this.__observedAttributes=[],HI(this.prototype)),this.__observedAttributes):n.call(this).concat(o9)}_enableProperties(){this.__isUpgradeDisabled||super._enableProperties()}_canApplyPropertyDefault(s){return super._canApplyPropertyDefault(s)&&!(this.__isUpgradeDisabled&&this._isPropertyPending(s))}connectedCallback(){this.__needsAttributesAtConnected&&this._takeAttributes(),this.__isUpgradeDisabled||(super.connectedCallback(),this.isAttached=!0,this.attached())}attached(){}disconnectedCallback(){this.__isUpgradeDisabled||(super.disconnectedCallback(),this.isAttached=!1,this.detached())}detached(){}attributeChangedCallback(s,l,c,u){l!==c&&(s==o9?this.__isUpgradeDisabled&&c==null&&(this._initializeProperties(),this.__isUpgradeDisabled=!1,ue(this).isConnected&&this.connectedCallback()):(super.attributeChangedCallback(s,l,c,u),this.attributeChanged(s,l,c)))}attributeChanged(s,l,c){}_initializeProperties(){if(pp&&this.hasAttribute(o9))this.__isUpgradeDisabled=!0;else{let s=Object.getPrototypeOf(this);s.hasOwnProperty(JSCompiler_renameProperty("__hasRegisterFinished",s))||(this._registered(),s.__hasRegisterFinished=!0),super._initializeProperties(),this.root=this,this.created(),qM&&!this._legacyForceObservedAttributes&&(this.hasAttributes()?this._takeAttributes():this.parentNode||(this.__needsAttributesAtConnected=!0)),this._applyListeners()}}_takeAttributes(){let s=this.attributes;for(let l=0,c=s.length;l<c;l++){let u=s[l];this.__attributeReaction(u.name,null,u.value)}}_registered(){}ready(){this._ensureAttributes(),super.ready()}_ensureAttributes(){}_applyListeners(){}serialize(s){return this._serializeValue(s)}deserialize(s,l){return this._deserializeValue(s,l)}reflectPropertyToAttribute(s,l,c){this._propertyToAttribute(s,l,c)}serializeValueToAttribute(s,l,c){this._valueToNodeAttribute(c||this,s,l)}extend(s,l){if(!(s&&l))return s||l;let c=Object.getOwnPropertyNames(l);for(let u=0,h;u<c.length&&(h=c[u]);u++){let f=Object.getOwnPropertyDescriptor(l,h);f&&Object.defineProperty(s,h,f)}return s}mixin(s,l){for(let c in l)s[c]=l[c];return s}chainObject(s,l){return s&&l&&s!==l&&(s.__proto__=l),s}instanceTemplate(s){let l=this.constructor._contentForTemplate(s);return document.importNode(l,!0)}fire(s,l,c){c=c||{},l=l==null?{}:l;let u=new Event(s,{bubbles:c.bubbles===void 0?!0:c.bubbles,cancelable:Boolean(c.cancelable),composed:c.composed===void 0?!0:c.composed});u.detail=l;let h=c.node||this;return ue(h).dispatchEvent(u),u}listen(s,l,c){s=s||this;let u=this.__boundListeners||(this.__boundListeners=new WeakMap),h=u.get(s);h||(h={},u.set(s,h));let f=l+c;h[f]||(h[f]=this._addMethodEventListenerToNode(s,l,c,this))}unlisten(s,l,c){s=s||this;let u=this.__boundListeners&&this.__boundListeners.get(s),h=l+c,f=u&&u[h];f&&(this._removeEventListenerFromNode(s,l,f),u[h]=null)}setScrollDirection(s,l){d_(l||this,i[s]||"auto")}$$(s){return this.root.querySelector(s)}get domHost(){let s=ue(this).getRootNode();return s instanceof DocumentFragment?s.host:s}distributeContent(){let l=zt(this);window.ShadyDOM&&l.shadowRoot&&ShadyDOM.flush()}getEffectiveChildNodes(){return zt(this).getEffectiveChildNodes()}queryDistributedElements(s){return zt(this).queryDistributedElements(s)}getEffectiveChildren(){return this.getEffectiveChildNodes().filter(function(l){return l.nodeType===Node.ELEMENT_NODE})}getEffectiveTextContent(){let s=this.getEffectiveChildNodes(),l=[];for(let c=0,u;u=s[c];c++)u.nodeType!==Node.COMMENT_NODE&&l.push(u.textContent);return l.join("")}queryEffectiveChildren(s){let l=this.queryDistributedElements(s);return l&&l[0]}queryAllEffectiveChildren(s){return this.queryDistributedElements(s)}getContentChildNodes(s){let l=this.root.querySelector(s||"slot");return l?zt(l).getDistributedNodes():[]}getContentChildren(s){return this.getContentChildNodes(s).filter(function(c){return c.nodeType===Node.ELEMENT_NODE})}isLightDescendant(s){let l=this;return l!==s&&ue(l).contains(s)&&ue(l).getRootNode()===ue(s).getRootNode()}isLocalDescendant(s){return this.root===ue(s).getRootNode()}scopeSubtree(s,l=!1){return wgt(s,l)}getComputedStyleValue(s){return Ixe.getComputedStyleValue(this,s)}debounce(s,l,c){return this._debouncers=this._debouncers||{},this._debouncers[s]=sr.debounce(this._debouncers[s],c>0?mo.after(c):ci,l.bind(this))}isDebouncerActive(s){this._debouncers=this._debouncers||{};let l=this._debouncers[s];return!!(l&&l.isActive())}flushDebouncer(s){this._debouncers=this._debouncers||{};let l=this._debouncers[s];l&&l.flush()}cancelDebouncer(s){this._debouncers=this._debouncers||{};let l=this._debouncers[s];l&&l.cancel()}async(s,l){return l>0?mo.run(s.bind(this),l):~ci.run(s.bind(this))}cancelAsync(s){s<0?ci.cancel(~s):mo.cancel(s)}create(s,l){let c=document.createElement(s);if(l)if(c.setProperties)c.setProperties(l);else for(let u in l)c[u]=l[u];return c}elementMatches(s,l){return XG(l||this,s)}toggleAttribute(s,l){let c=this;return arguments.length===3&&(c=arguments[2]),arguments.length==1&&(l=!c.hasAttribute(s)),l?(ue(c).setAttribute(s,""),!0):(ue(c).removeAttribute(s),!1)}toggleClass(s,l,c){c=c||this,arguments.length==1&&(l=!c.classList.contains(s)),l?c.classList.add(s):c.classList.remove(s)}transform(s,l){l=l||this,l.style.webkitTransform=s,l.style.transform=s}translate3d(s,l,c,u){u=u||this,this.transform("translate3d("+s+","+l+","+c+")",u)}arrayDelete(s,l){let c;if(Array.isArray(s)){if(c=s.indexOf(l),c>=0)return s.splice(c,1)}else if(c=No(this,s).indexOf(l),c>=0)return this.splice(s,c,1);return null}_logger(s,l){switch(Array.isArray(l)&&l.length===1&&Array.isArray(l[0])&&(l=l[0]),s){case"log":case"warn":case"error":console[s](...l)}}_log(...s){this._logger("log",s)}_warn(...s){this._logger("warn",s)}_error(...s){this._logger("error",s)}_logf(s,...l){return["[%s::%s]",this.is,s,...l]}}return o.prototype.is="",o});var Cm=Ee(Oe(),1);function xh(e,t){let r=0,n=0;for(;;){if(r===e.length)return n===t.length?0:-1;if(n===t.length)return 1;if(m_(e[r])&&m_(t[n])){let i=r,o=n;r=Sgt(e,r+1),n=Sgt(t,n+1);let a=parseFloat(e.slice(i,r)),s=parseFloat(t.slice(o,n));if(a<s)return-1;if(a>s)return 1;continue}if(JG(e[r])){if(!JG(t[n]))return-1}else{if(JG(t[n]))return 1;if(e[r]<t[n])return-1;if(e[r]>t[n])return 1}r++,n++}}function Sgt(e,t){let r;(function(i){i[i.NATURAL=0]="NATURAL",i[i.REAL=1]="REAL",i[i.EXPONENT_SIGN=2]="EXPONENT_SIGN",i[i.EXPONENT=3]="EXPONENT"})(r||(r={}));let n=r.NATURAL;for(;t<e.length;t++)if(n===r.NATURAL){if(e[t]===".")n=r.REAL;else if(e[t]==="e"||e[t]==="E")n=r.EXPONENT_SIGN;else if(!m_(e[t]))break}else if(n===r.REAL){if(e[t]==="e"||e[t]==="E")n=r.EXPONENT_SIGN;else if(!m_(e[t]))break}else if(n===r.EXPONENT_SIGN)if(m_(e[t])||e[t]==="+"||e[t]==="-")n=r.EXPONENT;else break;else if(n===r.EXPONENT&&!m_(e[t]))break;return t}function m_(e){return"0"<=e&&e<="9"}function JG(e){return e==="/"||e==="_"||m_(e)}var Lxe=[];function kxe(e){return Cm.keys(e).sort(xh)}function $i(e){return Cm.union.apply(null,Cm.values(e)).sort(xh)}function Rxe(e,t){let r=[];return t.forEach(n=>r=r.concat(e[n])),Cm.uniq(r).sort(xh)}var Egt="X-TensorBoard-Feature-Flags";var tW={};Ks(tW,{getFeatureFlags:()=>Dxe,getFeatureFlagsToSendToServer:()=>QG,initializeFeatureFlags:()=>Tgt,setFeatureFlags:()=>Nxe});var a9,s9;Tgt();function Tgt(){a9=null,s9=null}function Nxe(e,t){a9=e,s9=t}function Dxe(){if(a9===null)throw Error("FeatureFlags have not yet been determined by TensorBoard.");return a9}function QG(){if(s9===null)throw Error("FeatureFlags have not yet been determined by TensorBoard.");return s9}var l9=class extends Error{constructor(){super(...arguments),this.name="RequestCancellationError"}},Vx=class extends Error{constructor(t){super(t),this.name="InvalidRequestOptionsError",Object.setPrototypeOf(this,Vx.prototype)}},cE=class extends Error{constructor(t,r){super(),this.message=`RequestNetworkError: ${t.status} at ${r}`,this.name="RequestNetworkError",this.req=t,this.url=r}},Am;(function(e){e.GET="GET",e.POST="POST"})(Am||(Am={}));var Ux=class{validate(){if(this.methodType===Am.GET&&this.body)throw new Vx("body must be missing for a GET request.")}},Ae=class{constructor(t=1e3,r=3){this._queue=[],this._nActiveRequests=0,this._nSimultaneousRequests=t,this._maxRetries=r}request(t,r){let n=zxe(r);return this.requestWithOptions(t,n)}requestWithOptions(t,r){return r.validate(),new Promise((i,o)=>{let a={resolve:i,reject:o};this._queue.push(a),this.launchRequests()}).then(()=>this.promiseWithRetries(t,this._maxRetries,r)).then(i=>(this._nActiveRequests--,this.launchRequests(),i),i=>(i.name==="RequestNetworkError"&&(this._nActiveRequests--,this.launchRequests()),Promise.reject(i)))}fetch(t,r){return new Promise((n,i)=>{let o={resolve:n,reject:i};this._queue.push(o),this.launchRequests()}).then(()=>{let n=1;return new Promise(i=>{let o=()=>{fetch(t,r).then(a=>{if(!a.ok&&this._maxRetries>n){n++,o();return}i(a),this._nActiveRequests--,this.launchRequests()})};o()})})}clearQueue(){var t;for(;this._queue.length>0;)(t=this._queue.pop())==null||t.reject(new l9("Request cancelled by clearQueue"))}activeRequests(){return this._nActiveRequests}outstandingRequests(){return this._nActiveRequests+this._queue.length}launchRequests(){for(;this._nActiveRequests<this._nSimultaneousRequests&&this._queue.length>0;)this._nActiveRequests++,this._queue.pop().resolve(void 0)}promiseWithRetries(t,r,n){var i=a=>a,o=a=>r>0?this.promiseWithRetries(t,r-1,n):Promise.reject(a);return this._promiseFromUrl(t,n).then(i,o)}_promiseFromUrl(t,r){return new Promise((n,i)=>{let o=Oxe(r.methodType,t,r.withCredentials,r.contentType);o.setRequestHeader(Egt,JSON.stringify(QG())),o.onload=function(){o.status===200?n(JSON.parse(o.responseText)):i(new cE(o,t))},o.onerror=function(){i(new cE(o,t))},r.body?o.send(r.body):o.send()})}};function Oxe(e,t,r,n){let i=new XMLHttpRequest;return i.open(e,t),r&&(i.withCredentials=r),n&&i.setRequestHeader("Content-Type",n),i}function zxe(e){let t=new Ux;return e?(t.methodType=Am.POST,t.body=Fxe(e),t):(t.methodType=Am.GET,t)}function Fxe(e){let t=new FormData;for(let[r,n]of Object.entries(e)){let i=Array.isArray(n)?n:[n];for(let o of i)t.append(r,o)}return t}var Cgt="experimentalPlugin",Bxe=new URLSearchParams(window.location.search),Agt=Pgt();function Pgt(e="data",t=Bxe){return e[e.length-1]==="/"&&(e=e.slice(0,e.length-1)),{environment:()=>qx(e,"/environment"),experiments:()=>qx(e,"/experiments"),pluginRoute:(r,n,i)=>qx(e+"/plugin",`/${r}${n}`,i),pluginsListing:()=>qx(e,"/plugins_listing",eW({[Cgt]:t.getAll(Cgt)})),runs:()=>qx(e,"/runs"),runsForExperiment:r=>qx(e,"/experiment_runs",eW({experiment:String(r)}))}}function ve(){return Agt}function Hxe(e){if(e==null)throw new Error("Router required, but got: "+e);Agt=e}function qx(e,t,r=new URLSearchParams){let n=e+t;return String(r)&&(n+=(t.includes("?")?"&":"?")+String(r)),n}function eW(e={}){let t=Object.keys(e).sort().filter(n=>e[n]),r=new URLSearchParams;return t.forEach(n=>{let i=e[n];(Array.isArray(i)?i:[i]).forEach(a=>r.append(n,a))}),r}var c9=Ee(Oe(),1);var Na;(function(e){e[e.SEARCH_RESULTS=0]="SEARCH_RESULTS",e[e.PREFIX_GROUP=1]="PREFIX_GROUP"})(Na||(Na={}));function Vxe(e,t){let r=(()=>{try{return new RegExp(t)}catch(n){return null}})();return{name:t,metadata:{type:Na.SEARCH_RESULTS,validRegex:!!r,universalRegex:t===".*"},items:r?e.filter(n=>n.match(r)):[]}}function Uxe(e,t="/"){let r=[],n={};return e.forEach(i=>{let o=i.indexOf(t),a=o>=0?i.slice(0,o):i;if(!n[a]){let s={name:a,metadata:{type:Na.PREFIX_GROUP},items:[]};n[a]=s,r.push(s)}n[a].items.push(i)}),r}function qxe(e,t=""){let r=[Vxe(e,t)],n=Uxe(e);return Array().concat(r,n)}function uE(e,t,r){let n=$i(e),i=qxe(n,r),o=Gxe(c9.pick(e,t));return i.map(({name:a,metadata:s,items:l})=>({name:a,metadata:s,items:l.map(c=>({tag:c,runs:(o.get(c)||[]).slice()}))}))}function Gxe(e){let t=new Map;return Object.keys(e).forEach(r=>{e[r].forEach(n=>{let i=t.get(n)||[];i.push(r),t.set(n,i)})}),t}function Wxe(e,t){let r=xh(e.tag,t.tag);return r!=0?r:xh(e.run,t.run)}function Ql(e,t,r){let n=uE(e,t,r);function i(o){let a=c9.flatten(o.items.map(({tag:s,runs:l})=>l.map(c=>({tag:s,run:c}))));return a.sort(Wxe),{name:o.name,metadata:o.metadata,items:a}}return n.map(i)}var uW={};Ks(uW,{IronResizableBehavior:()=>Js});var Yxe={attached:!0,detached:!0,ready:!0,created:!0,beforeRegister:!0,registered:!0,attributeChanged:!0,listeners:!0,hostAttributes:!0},Rgt={attached:!0,detached:!0,ready:!0,created:!0,beforeRegister:!0,registered:!0,attributeChanged:!0,behaviors:!0,_noAccessors:!0},jxe=Object.assign({listeners:!0,hostAttributes:!0,properties:!0,observers:!0},Rgt);function Xxe(e,t,r){let n=e._noAccessors,i=Object.getOwnPropertyNames(e);for(let o=0;o<i.length;o++){let a=i[o];if(!(a in r))if(n)t[a]=e[a];else{let s=Object.getOwnPropertyDescriptor(e,a);s&&(s.configurable=!0,Object.defineProperty(t,a,s))}}}function Ngt(e,t){return zgt({},Gt(t),e)}function $xe(e,t,r){for(let n=0;n<t.length;n++)Dgt(e,t[n],r,jxe)}function Dgt(e,t,r,n){Xxe(t,e,n);for(let i in Yxe)t[i]&&(r[i]=r[i]||[],r[i].push(t[i]))}function Ogt(e,t,r){t=t||[];for(let n=e.length-1;n>=0;n--){let i=e[n];i?Array.isArray(i)?Ogt(i,t):t.indexOf(i)<0&&(!r||r.indexOf(i)<0)&&t.unshift(i):console.warn("behavior is null, check for missing or 404 import")}return t}function Lgt(e,t){for(let r in t){let n=e[r],i=t[r];!("value"in i)&&n&&"value"in n?e[r]=Object.assign({value:n.value},i):e[r]=i}}var kgt=Gt(HTMLElement);function zgt(e,t,r){let n,i={};class o extends t{static _finalizeClass(){if(!this.hasOwnProperty(JSCompiler_renameProperty("generatedFrom",this)))t._finalizeClass.call(this);else{if(n)for(let l=0,c;l<n.length;l++)c=n[l],c.properties&&this.createProperties(c.properties),c.observers&&this.createObservers(c.observers,c.properties);e.properties&&this.createProperties(e.properties),e.observers&&this.createObservers(e.observers,e.properties),this._prepareTemplate()}}static get properties(){let l={};if(n)for(let c=0;c<n.length;c++)Lgt(l,n[c].properties);return Lgt(l,e.properties),l}static get observers(){let l=[];if(n)for(let c=0,u;c<n.length;c++)u=n[c],u.observers&&(l=l.concat(u.observers));return e.observers&&(l=l.concat(e.observers)),l}created(){super.created();let l=i.created;if(l)for(let c=0;c<l.length;c++)l[c].call(this)}_registered(){let l=o.prototype;if(!l.hasOwnProperty(JSCompiler_renameProperty("__hasRegisterFinished",l))){l.__hasRegisterFinished=!0,super._registered(),pp&&a(l);let c=Object.getPrototypeOf(this),u=i.beforeRegister;if(u)for(let h=0;h<u.length;h++)u[h].call(c);if(u=i.registered,u)for(let h=0;h<u.length;h++)u[h].call(c)}}_applyListeners(){super._applyListeners();let l=i.listeners;if(l)for(let c=0;c<l.length;c++){let u=l[c];if(u)for(let h in u)this._addMethodEventListenerToNode(this,h,u[h])}}_ensureAttributes(){let l=i.hostAttributes;if(l)for(let c=l.length-1;c>=0;c--){let u=l[c];for(let h in u)this._ensureAttribute(h,u[h])}super._ensureAttributes()}ready(){super.ready();let l=i.ready;if(l)for(let c=0;c<l.length;c++)l[c].call(this)}attached(){super.attached();let l=i.attached;if(l)for(let c=0;c<l.length;c++)l[c].call(this)}detached(){super.detached();let l=i.detached;if(l)for(let c=0;c<l.length;c++)l[c].call(this)}attributeChanged(l,c,u){super.attributeChanged();let h=i.attributeChanged;if(h)for(let f=0;f<h.length;f++)h[f].call(this,l,c,u)}}if(r){Array.isArray(r)||(r=[r]);let s=t.prototype.behaviors;n=Ogt(r,null,s),o.prototype.behaviors=s?s.concat(r):n}let a=s=>{n&&$xe(s,n,i),Dgt(s,e,i,Rgt)};return pp||a(o.prototype),o.generatedFrom=e,o}var u9=function(e,t){e||console.warn("Polymer.Class requires `info` argument");let r=t?t(kgt):kgt;return r=zgt(e,r,e.behaviors),r.is=r.prototype.is=e.is,r};var Yt=function(e){let t;return typeof e=="function"?t=e:t=Yt.Class(e),e._legacyForceObservedAttributes&&(t.prototype._legacyForceObservedAttributes=e._legacyForceObservedAttributes),customElements.define(t.is,t),t};Yt.Class=u9;function rW(e,t,r,n,i){let o;i&&(o=typeof r=="object"&&r!==null,o&&(n=e.__dataTemp[t]));let a=n!==r&&(n===n||r===r);return o&&a&&(e.__dataTemp[t]=r),a}var Gx=Nn(e=>{class t extends e{_shouldPropertyChange(n,i,o){return rW(this,n,i,o,!0)}}return t}),h9=Nn(e=>{class t extends e{static get properties(){return{mutableData:Boolean}}_shouldPropertyChange(n,i,o){return rW(this,n,i,o,this.mutableData)}}return t});Gx._mutablePropertyChange=rW;var nW=null;function iW(){return nW}iW.prototype=Object.create(HTMLTemplateElement.prototype,{constructor:{value:iW,writable:!0}});var Bgt=u_(iW),Kxe=Gx(Bgt);function Zxe(e,t){nW=e,Object.setPrototypeOf(e,t.prototype),new t,nW=null}var Jxe=u_(class{});function oW(e,t){for(let r=0;r<t.length;r++){let n=t[r];if(Boolean(e)!=Boolean(n.__hideTemplateChildren__))if(n.nodeType===Node.TEXT_NODE)e?(n.__polymerTextContent__=n.textContent,n.textContent=""):n.textContent=n.__polymerTextContent__;else if(n.localName==="slot")if(e)n.__polymerReplaced__=document.createComment("hidden-slot"),ue(ue(n).parentNode).replaceChild(n.__polymerReplaced__,n);else{let i=n.__polymerReplaced__;i&&ue(ue(i).parentNode).replaceChild(n,i)}else n.style&&(e?(n.__polymerDisplay__=n.style.display,n.style.display="none"):n.style.display=n.__polymerDisplay__);n.__hideTemplateChildren__=e,n._showHideChildren&&n._showHideChildren(e)}}var bh=class extends Jxe{constructor(t){super(),this._configureProperties(t),this.root=this._stampTemplate(this.__dataHost);let r=[];this.children=r;for(let i=this.root.firstChild;i;i=i.nextSibling)r.push(i),i.__templatizeInstance=this;this.__templatizeOwner&&this.__templatizeOwner.__hideTemplateChildren__&&this._showHideChildren(!0);let n=this.__templatizeOptions;(t&&n.instanceProps||!n.instanceProps)&&this._enableProperties()}_configureProperties(t){if(this.__templatizeOptions.forwardHostProp)for(let n in this.__hostProps)this._setPendingProperty(n,this.__dataHost["_host_"+n]);for(let n in t)this._setPendingProperty(n,t[n])}forwardHostProp(t,r){this._setPendingPropertyOrPath(t,r,!1,!0)&&this.__dataHost._enqueueClient(this)}_addEventListenerToNode(t,r,n){if(this._methodHost&&this.__templatizeOptions.parentModel)this._methodHost._addEventListenerToNode(t,r,i=>{i.model=this,n(i)});else{let i=this.__dataHost.__dataHost;i&&i._addEventListenerToNode(t,r,n)}}_showHideChildren(t){oW(t,this.children)}_setUnmanagedPropertyToNode(t,r,n){t.__hideTemplateChildren__&&t.nodeType==Node.TEXT_NODE&&r=="textContent"?t.__polymerTextContent__=n:super._setUnmanagedPropertyToNode(t,r,n)}get parentModel(){let t=this.__parentModel;if(!t){let r;t=this;do t=t.__dataHost.__dataHost;while((r=t.__templatizeOptions)&&!r.parentModel);this.__parentModel=t}return t}dispatchEvent(t){return!0}};bh.prototype.__dataHost;bh.prototype.__templatizeOptions;bh.prototype._methodHost;bh.prototype.__templatizeOwner;bh.prototype.__hostProps;var Qxe=Gx(bh);function Fgt(e){let t=e.__dataHost;return t&&t._methodHost||t}function tbe(e,t,r){let n=r.mutableData?Qxe:bh;tc.mixin&&(n=tc.mixin(n));let i=class extends n{};return i.prototype.__templatizeOptions=r,i.prototype._bindTemplate(e),nbe(i,e,t,r),i}function ebe(e,t,r,n){let i=r.forwardHostProp;if(i&&t.hasHostProps){let o=e.localName=="template",a=t.templatizeTemplateClass;if(!a){if(o){let l=r.mutableData?Kxe:Bgt;class c extends l{}a=t.templatizeTemplateClass=c}else{let l=e.constructor;class c extends l{}a=t.templatizeTemplateClass=c}let s=t.hostProps;for(let l in s)a.prototype._addPropertyEffect("_host_"+l,a.prototype.PROPERTY_EFFECT_TYPES.PROPAGATE,{fn:rbe(l,i)}),a.prototype._createNotifyingProperty("_host_"+l);II&&n&&abe(t,r,n)}if(e.__dataProto&&Object.assign(e.__data,e.__dataProto),o)Zxe(e,a),e.__dataTemp={},e.__dataPending=null,e.__dataOld=null,e._enableProperties();else{Object.setPrototypeOf(e,a.prototype);let s=t.hostProps;for(let l in s)if(l="_host_"+l,l in e){let c=e[l];delete e[l],e.__data[l]=c}}}}function rbe(e,t){return function(n,i,o){t.call(n.__templatizeOwner,i.substring(6),o[i])}}function nbe(e,t,r,n){let i=r.hostProps||{};for(let o in n.instanceProps){delete i[o];let a=n.notifyInstanceProp;a&&e.prototype._addPropertyEffect(o,e.prototype.PROPERTY_EFFECT_TYPES.NOTIFY,{fn:ibe(o,a)})}if(n.forwardHostProp&&t.__dataHost)for(let o in i)r.hasHostProps||(r.hasHostProps=!0),e.prototype._addPropertyEffect(o,e.prototype.PROPERTY_EFFECT_TYPES.NOTIFY,{fn:obe()})}function ibe(e,t){return function(n,i,o){t.call(n.__templatizeOwner,n,i,o[i])}}function obe(){return function(t,r,n){t.__dataHost._setPendingPropertyOrPath("_host_"+r,n[r],!0,!0)}}function tc(e,t,r){if(iu&&!Fgt(e))throw new Error("strictTemplatePolicy: template owner not trusted");if(r=r||{},e.__templatizeOwner)throw new Error("A <template> can only be templatized once");e.__templatizeOwner=t;let i=(t?t.constructor:bh)._parseTemplate(e),o=i.templatizeInstanceClass;o||(o=tbe(e,i,r),i.templatizeInstanceClass=o);let a=Fgt(e);ebe(e,i,r,a);let s=class extends o{};return s.prototype._methodHost=a,s.prototype.__dataHost=e,s.prototype.__templatizeOwner=t,s.prototype.__hostProps=i.hostProps,s=s,s}function abe(e,t,r){let n=r.constructor._properties,{propertyEffects:i}=e,{instanceProps:o}=t;for(let a in i)if(!n[a]&&!(o&&o[a])){let s=i[a];for(let l=0;l<s.length;l++){let{part:c}=s[l].info;if(!(c.signature&&c.signature.static)){console.warn(`Property '${a}' used in template but not declared in 'properties'; attribute will not be observed.`);break}}}}function f9(e,t){let r;for(;t;)if(r=t.__dataHost?t:t.__templatizeInstance)if(r.__dataHost!=e)t=r.__dataHost;else return r;else t=ue(t).parentNode;return null}var Hgt={templatize(e,t){this._templatizerTemplate=e,this.ctor=tc(e,this,{mutableData:Boolean(t),parentModel:this._parentModel,instanceProps:this._instanceProps,forwardHostProp:this._forwardHostPropV2,notifyInstanceProp:this._notifyInstancePropV2})},stamp(e){return new this.ctor(e)},modelForElement(e){return f9(this._templatizerTemplate,e)}};var Vgt=!1;function Wx(){if(pp&&!c_){if(!Vgt){Vgt=!0;let e=document.createElement("style");e.textContent="dom-bind,dom-if,dom-repeat{display:none;}",document.head.appendChild(e)}return!0}return!1}var sbe=yh(h9(u_(HTMLElement))),aW=class extends sbe{static get observedAttributes(){return["mutable-data"]}constructor(){if(super(),iu)throw new Error("strictTemplatePolicy: dom-bind not allowed");this.root=null,this.$=null,this.__children=null}attributeChangedCallback(t,r,n,i){this.mutableData=!0}connectedCallback(){Wx()||(this.style.display="none"),this.render()}disconnectedCallback(){this.__removeChildren()}__insertChildren(){ue(ue(this).parentNode).insertBefore(this.root,this)}__removeChildren(){if(this.__children)for(let t=0;t<this.__children.length;t++)this.root.appendChild(this.__children[t])}render(){let t;if(!this.__children){if(t=t||this.querySelector("template"),!t){let r=new MutationObserver(()=>{if(t=this.querySelector("template"),t)r.disconnect(),this.render();else throw new Error("dom-bind requires a <template> child")});r.observe(this,{childList:!0});return}this.root=this._stampTemplate(t),this.$=this.root.$,this.__children=[];for(let r=this.root.firstChild;r;r=r.nextSibling)this.__children[this.__children.length]=r;this._enableProperties()}this.__insertChildren(),this.dispatchEvent(new CustomEvent("dom-change",{bubbles:!0,composed:!0}))}};customElements.define("dom-bind",aW);var lbe=h9(mt),p9=class extends lbe{static get is(){return"dom-repeat"}static get template(){return null}static get properties(){return{items:{type:Array},as:{type:String,value:"item"},indexAs:{type:String,value:"index"},itemsIndexAs:{type:String,value:"itemsIndex"},sort:{type:Function,observer:"__sortChanged"},filter:{type:Function,observer:"__filterChanged"},observe:{type:String,observer:"__observeChanged"},delay:Number,renderedItemCount:{type:Number,notify:!UM,readOnly:!0},initialCount:{type:Number},targetFramerate:{type:Number,value:20},_targetFrameTime:{type:Number,computed:"__computeFrameTime(targetFramerate)"},notifyDomChange:{type:Boolean},reuseChunkedInstances:{type:Boolean}}}static get observers(){return["__itemsChanged(items.*)"]}constructor(){super(),this.__instances=[],this.__renderDebouncer=null,this.__itemsIdxToInstIdx={},this.__chunkCount=null,this.__renderStartTime=null,this.__itemsArrayChanged=!1,this.__shouldMeasureChunk=!1,this.__shouldContinueChunking=!1,this.__chunkingId=0,this.__sortFn=null,this.__filterFn=null,this.__observePaths=null,this.__ctor=null,this.__isDetached=!0,this.template=null,this._templateInfo}disconnectedCallback(){super.disconnectedCallback(),this.__isDetached=!0;for(let t=0;t<this.__instances.length;t++)this.__detachInstance(t)}connectedCallback(){if(super.connectedCallback(),Wx()||(this.style.display="none"),this.__isDetached){this.__isDetached=!1;let t=ue(ue(this).parentNode);for(let r=0;r<this.__instances.length;r++)this.__attachInstance(r,t)}}__ensureTemplatized(){if(!this.__ctor){let t=this,r=this.template=t._templateInfo?t:this.querySelector("template");if(!r){let i=new MutationObserver(()=>{if(this.querySelector("template"))i.disconnect(),this.__render();else throw new Error("dom-repeat requires a <template> child")});return i.observe(this,{childList:!0}),!1}let n={};n[this.as]=!0,n[this.indexAs]=!0,n[this.itemsIndexAs]=!0,this.__ctor=tc(r,this,{mutableData:this.mutableData,parentModel:!0,instanceProps:n,forwardHostProp:function(i,o){let a=this.__instances;for(let s=0,l;s<a.length&&(l=a[s]);s++)l.forwardHostProp(i,o)},notifyInstanceProp:function(i,o,a){if(DI(this.as,o)){let s=i[this.itemsIndexAs];o==this.as&&(this.items[s]=a);let l=dp(this.as,`${JSCompiler_renameProperty("items",this)}.${s}`,o);this.notifyPath(l,a)}}})}return!0}__getMethodHost(){return this.__dataHost._methodHost||this.__dataHost}__functionFromPropertyValue(t){if(typeof t=="string"){let r=t,n=this.__getMethodHost();return function(){return n[r].apply(n,arguments)}}return t}__sortChanged(t){this.__sortFn=this.__functionFromPropertyValue(t),this.items&&this.__debounceRender(this.__render)}__filterChanged(t){this.__filterFn=this.__functionFromPropertyValue(t),this.items&&this.__debounceRender(this.__render)}__computeFrameTime(t){return Math.ceil(1e3/t)}__observeChanged(){this.__observePaths=this.observe&&this.observe.replace(".*",".").split(" ")}__handleObservedPaths(t){if(this.__sortFn||this.__filterFn){if(!t)this.__debounceRender(this.__render,this.delay);else if(this.__observePaths){let r=this.__observePaths;for(let n=0;n<r.length;n++)t.indexOf(r[n])===0&&this.__debounceRender(this.__render,this.delay)}}}__itemsChanged(t){this.items&&!Array.isArray(this.items)&&console.warn("dom-repeat expected array for `items`, found",this.items),this.__handleItemPath(t.path,t.value)||(t.path==="items"&&(this.__itemsArrayChanged=!0),this.__debounceRender(this.__render))}__debounceRender(t,r=0){this.__renderDebouncer=sr.debounce(this.__renderDebouncer,r>0?mo.after(r):ci,t.bind(this)),Jl(this.__renderDebouncer)}render(){this.__debounceRender(this.__render),ui()}__render(){if(!this.__ensureTemplatized())return;let t=this.items||[],r=this.__sortAndFilterItems(t),n=this.__calculateLimit(r.length);this.__updateInstances(t,n,r),this.initialCount&&(this.__shouldMeasureChunk||this.__shouldContinueChunking)&&(cancelAnimationFrame(this.__chunkingId),this.__chunkingId=requestAnimationFrame(()=>this.__continueChunking())),this._setRenderedItemCount(this.__instances.length),(!UM||this.notifyDomChange)&&this.dispatchEvent(new CustomEvent("dom-change",{bubbles:!0,composed:!0}))}__sortAndFilterItems(t){let r=new Array(t.length);for(let n=0;n<t.length;n++)r[n]=n;return this.__filterFn&&(r=r.filter((n,i,o)=>this.__filterFn(t[n],i,o))),this.__sortFn&&r.sort((n,i)=>this.__sortFn(t[n],t[i])),r}__calculateLimit(t){let r=t,n=this.__instances.length;if(this.initialCount){let i;!this.__chunkCount||this.__itemsArrayChanged&&!this.reuseChunkedInstances?(r=Math.min(t,this.initialCount),i=Math.max(r-n,0),this.__chunkCount=i||1):(i=Math.min(Math.max(t-n,0),this.__chunkCount),r=Math.min(n+i,t)),this.__shouldMeasureChunk=i===this.__chunkCount,this.__shouldContinueChunking=r<t,this.__renderStartTime=performance.now()}return this.__itemsArrayChanged=!1,r}__continueChunking(){if(this.__shouldMeasureChunk){let t=performance.now()-this.__renderStartTime,r=this._targetFrameTime/t;this.__chunkCount=Math.round(this.__chunkCount*r)||1}this.__shouldContinueChunking&&this.__debounceRender(this.__render)}__updateInstances(t,r,n){let i=this.__itemsIdxToInstIdx={},o;for(o=0;o<r;o++){let a=this.__instances[o],s=n[o],l=t[s];i[s]=o,a?(a._setPendingProperty(this.as,l),a._setPendingProperty(this.indexAs,o),a._setPendingProperty(this.itemsIndexAs,s),a._flushProperties()):this.__insertInstance(l,o,s)}for(let a=this.__instances.length-1;a>=o;a--)this.__detachAndRemoveInstance(a)}__detachInstance(t){let r=this.__instances[t],n=ue(r.root);for(let i=0;i<r.children.length;i++){let o=r.children[i];n.appendChild(o)}return r}__attachInstance(t,r){let n=this.__instances[t];r.insertBefore(n.root,this)}__detachAndRemoveInstance(t){this.__detachInstance(t),this.__instances.splice(t,1)}__stampInstance(t,r,n){let i={};return i[this.as]=t,i[this.indexAs]=r,i[this.itemsIndexAs]=n,new this.__ctor(i)}__insertInstance(t,r,n){let i=this.__stampInstance(t,r,n),o=this.__instances[r+1],a=o?o.children[0]:this;return ue(ue(this).parentNode).insertBefore(i.root,a),this.__instances[r]=i,i}_showHideChildren(t){for(let r=0;r<this.__instances.length;r++)this.__instances[r]._showHideChildren(t)}__handleItemPath(t,r){let n=t.slice(6),i=n.indexOf("."),o=i<0?n:n.substring(0,i);if(o==parseInt(o,10)){let a=i<0?"":n.substring(i+1);this.__handleObservedPaths(a);let s=this.__itemsIdxToInstIdx[o],l=this.__instances[s];if(l){let c=this.as+(a?"."+a:"");l._setPendingPropertyOrPath(c,r,!1,!0),l._flushProperties()}return!0}}itemForElement(t){let r=this.modelForElement(t);return r&&r[this.as]}indexForElement(t){let r=this.modelForElement(t);return r&&r[this.indexAs]}modelForElement(t){return f9(this.template,t)}};customElements.define(p9.is,p9);var d9=class extends mt{static get is(){return"dom-if"}static get template(){return null}static get properties(){return{if:{type:Boolean,observer:"__debounceRender"},restamp:{type:Boolean,observer:"__debounceRender"},notifyDomChange:{type:Boolean}}}constructor(){super(),this.__renderDebouncer=null,this._lastIf=!1,this.__hideTemplateChildren__=!1,this.__template,this._templateInfo}__debounceRender(){this.__renderDebouncer=sr.debounce(this.__renderDebouncer,ci,()=>this.__render()),Jl(this.__renderDebouncer)}disconnectedCallback(){super.disconnectedCallback();let t=ue(this).parentNode;(!t||t.nodeType==Node.DOCUMENT_FRAGMENT_NODE&&!ue(t).host)&&this.__teardownInstance()}connectedCallback(){super.connectedCallback(),Wx()||(this.style.display="none"),this.if&&this.__debounceRender()}__ensureTemplate(){if(!this.__template){let t=this,r=t._templateInfo?t:ue(t).querySelector("template");if(!r){let n=new MutationObserver(()=>{if(ue(this).querySelector("template"))n.disconnect(),this.__render();else throw new Error("dom-if requires a <template> child")});return n.observe(this,{childList:!0}),!1}this.__template=r}return!0}__ensureInstance(){let t=ue(this).parentNode;if(this.__hasInstance()){let r=this.__getInstanceNodes();if(r&&r.length&&ue(this).previousSibling!==r[r.length-1])for(let i=0,o;i<r.length&&(o=r[i]);i++)ue(t).insertBefore(o,this)}else{if(!t||!this.__ensureTemplate())return!1;this.__createAndInsertInstance(t)}return!0}render(){ui()}__render(){if(this.if){if(!this.__ensureInstance())return}else this.restamp&&this.__teardownInstance();this._showHideChildren(),(!UM||this.notifyDomChange)&&this.if!=this._lastIf&&(this.dispatchEvent(new CustomEvent("dom-change",{bubbles:!0,composed:!0})),this._lastIf=this.if)}__hasInstance(){}__getInstanceNodes(){}__createAndInsertInstance(t){}__teardownInstance(){}_showHideChildren(){}},sW=class extends d9{constructor(){super(),this.__instance=null,this.__syncInfo=null}__hasInstance(){return Boolean(this.__instance)}__getInstanceNodes(){return this.__instance.templateInfo.childNodes}__createAndInsertInstance(t){let r=this.__dataHost||this;if(iu&&!this.__dataHost)throw new Error("strictTemplatePolicy: template owner not trusted");let n=r._bindTemplate(this.__template,!0);n.runEffects=(i,o,a)=>{let s=this.__syncInfo;if(this.if)s&&(this.__syncInfo=null,this._showHideChildren(),o=Object.assign(s.changedProps,o)),i(o,a);else if(this.__instance)if(s||(s=this.__syncInfo={runEffects:i,changedProps:{}}),a)for(let l in o){let c=au(l);s.changedProps[c]=this.__dataHost[c]}else Object.assign(s.changedProps,o)},this.__instance=r._stampTemplate(this.__template,n),ue(t).insertBefore(this.__instance,this)}__syncHostProperties(){let t=this.__syncInfo;t&&(this.__syncInfo=null,t.runEffects(t.changedProps,!1))}__teardownInstance(){let t=this.__dataHost||this;this.__instance&&(t._removeBoundDom(this.__instance),this.__instance=null,this.__syncInfo=null)}_showHideChildren(){let t=this.__hideTemplateChildren__||!this.if;this.__instance&&Boolean(this.__instance.__hidden)!==t&&(this.__instance.__hidden=t,oW(t,this.__instance.templateInfo.childNodes)),t||this.__syncHostProperties()}},lW=class extends d9{constructor(){super(),this.__ctor=null,this.__instance=null,this.__invalidProps=null}__hasInstance(){return Boolean(this.__instance)}__getInstanceNodes(){return this.__instance.children}__createAndInsertInstance(t){this.__ctor||(this.__ctor=tc(this.__template,this,{mutableData:!0,forwardHostProp:function(r,n){this.__instance&&(this.if?this.__instance.forwardHostProp(r,n):(this.__invalidProps=this.__invalidProps||Object.create(null),this.__invalidProps[au(r)]=!0))}})),this.__instance=new this.__ctor,ue(t).insertBefore(this.__instance.root,this)}__teardownInstance(){if(this.__instance){let t=this.__instance.children;if(t&&t.length){let r=ue(t[0]).parentNode;if(r){r=ue(r);for(let n=0,i;n<t.length&&(i=t[n]);n++)r.removeChild(i)}}this.__invalidProps=null,this.__instance=null}}__syncHostProperties(){let t=this.__invalidProps;if(t){this.__invalidProps=null;for(let r in t)this.__instance._setPendingProperty(r,this.__dataHost[r]);this.__instance._flushProperties()}}_showHideChildren(){let t=this.__hideTemplateChildren__||!this.if;this.__instance&&Boolean(this.__instance.__hidden)!==t&&(this.__instance.__hidden=t,this.__instance._showHideChildren(t)),t||this.__syncHostProperties()}},Ugt=kI?sW:lW;customElements.define(Ugt.is,Ugt);var cbe=Nn(e=>{let t=Sm(e);class r extends t{static get properties(){return{items:{type:Array},multi:{type:Boolean,value:!1},selected:{type:Object,notify:!0},selectedItem:{type:Object,notify:!0},toggle:{type:Boolean,value:!1}}}static get observers(){return["__updateSelection(multi, items.*)"]}constructor(){super(),this.__lastItems=null,this.__lastMulti=null,this.__selectedMap=null}__updateSelection(i,o){let a=o.path;if(a==JSCompiler_renameProperty("items",this)){let s=o.base||[],l=this.__lastItems,c=this.__lastMulti;if(i!==c&&this.clearSelection(),l){let u=i9(s,l);this.__applySplices(u)}this.__lastItems=s,this.__lastMulti=i}else if(o.path==`${JSCompiler_renameProperty("items",this)}.splices`)this.__applySplices(o.value.indexSplices);else{let s=a.slice(`${JSCompiler_renameProperty("items",this)}.`.length),l=parseInt(s,10);s.indexOf(".")<0&&s==l&&this.__deselectChangedIdx(l)}}__applySplices(i){let o=this.__selectedMap;for(let s=0;s<i.length;s++){let l=i[s];o.forEach((c,u)=>{c<l.index||(c>=l.index+l.removed.length?o.set(u,c+l.addedCount-l.removed.length):o.set(u,-1))});for(let c=0;c<l.addedCount;c++){let u=l.index+c;o.has(this.items[u])&&o.set(this.items[u],u)}}this.__updateLinks();let a=0;o.forEach((s,l)=>{s<0?(this.multi?this.splice(JSCompiler_renameProperty("selected",this),a,1):this.selected=this.selectedItem=null,o.delete(l)):a++})}__updateLinks(){if(this.__dataLinkedPaths={},this.multi){let i=0;this.__selectedMap.forEach(o=>{o>=0&&this.linkPaths(`${JSCompiler_renameProperty("items",this)}.${o}`,`${JSCompiler_renameProperty("selected",this)}.${i++}`)})}else this.__selectedMap.forEach(i=>{this.linkPaths(JSCompiler_renameProperty("selected",this),`${JSCompiler_renameProperty("items",this)}.${i}`),this.linkPaths(JSCompiler_renameProperty("selectedItem",this),`${JSCompiler_renameProperty("items",this)}.${i}`)})}clearSelection(){this.__dataLinkedPaths={},this.__selectedMap=new Map,this.selected=this.multi?[]:null,this.selectedItem=null}isSelected(i){return this.__selectedMap.has(i)}isIndexSelected(i){return this.isSelected(this.items[i])}__deselectChangedIdx(i){let o=this.__selectedIndexForItemIndex(i);if(o>=0){let a=0;this.__selectedMap.forEach((s,l)=>{o==a++&&this.deselect(l)})}}__selectedIndexForItemIndex(i){let o=this.__dataLinkedPaths[`${JSCompiler_renameProperty("items",this)}.${i}`];if(o)return parseInt(o.slice(`${JSCompiler_renameProperty("selected",this)}.`.length),10)}deselect(i){let o=this.__selectedMap.get(i);if(o>=0){this.__selectedMap.delete(i);let a;this.multi&&(a=this.__selectedIndexForItemIndex(o)),this.__updateLinks(),this.multi?this.splice(JSCompiler_renameProperty("selected",this),a,1):this.selected=this.selectedItem=null}}deselectIndex(i){this.deselect(this.items[i])}select(i){this.selectIndex(this.items.indexOf(i))}selectIndex(i){let o=this.items[i];this.isSelected(o)?this.toggle&&this.deselectIndex(i):(this.multi||this.__selectedMap.clear(),this.__selectedMap.set(o,i),this.__updateLinks(),this.multi?this.push(JSCompiler_renameProperty("selected",this),o):this.selected=this.selectedItem=o)}}return r});var ube=cbe(mt),m9=class extends ube{static get is(){return"array-selector"}static get template(){return null}};customElements.define(m9.is,m9);var g9=new Zl;window.ShadyCSS||(window.ShadyCSS={prepareTemplate(e,t,r){},prepareTemplateDom(e,t){},prepareTemplateStyles(e,t,r){},styleSubtree(e,t){g9.processStyles(),JM(e,t)},styleElement(e){g9.processStyles()},styleDocument(e){g9.processStyles(),JM(document.body,e)},getComputedStyleValue(e,t){return YI(e,t)},flushCustomStyles(){},nativeCss:Nx,nativeShadow:h_,cssBuild:Mm,disableRuntime:GI});window.ShadyCSS.CustomStyleInterface=g9;var qgt="include",hbe=window.ShadyCSS.CustomStyleInterface,cW=class extends HTMLElement{constructor(){super(),this._style=null,hbe.addCustomStyle(this)}getStyle(){if(this._style)return this._style;let t=this.querySelector("style");if(!t)return null;this._style=t;let r=t.getAttribute(qgt);return r&&(t.removeAttribute(qgt),t.textContent=tmt(r)+t.textContent),this.ownerDocument!==window.document&&window.document.head.appendChild(this),this._style}};window.customElements.define("custom-style",cW);var Ggt;Ggt=Gx._mutablePropertyChange;var Wgt={properties:{mutableData:Boolean},_shouldPropertyChange(e,t,r){return Ggt(this,e,t,r,this.mutableData)}};var Da=Gt(HTMLElement).prototype;var _9=new Set,Js={properties:{_parentResizable:{type:Object,observer:"_parentResizableChanged"},_notifyingDescendant:{type:Boolean,value:!1}},listeners:{"iron-request-resize-notifications":"_onIronRequestResizeNotifications"},created:function(){this._interestedResizables=[],this._boundNotifyResize=this.notifyResize.bind(this),this._boundOnDescendantIronResize=this._onDescendantIronResize.bind(this)},attached:function(){this._requestResizeNotifications()},detached:function(){this._parentResizable?this._parentResizable.stopResizeNotificationsFor(this):(_9.delete(this),window.removeEventListener("resize",this._boundNotifyResize)),this._parentResizable=null},notifyResize:function(){!this.isAttached||(this._interestedResizables.forEach(function(e){this.resizerShouldNotify(e)&&this._notifyDescendant(e)},this),this._fireResize())},assignParentResizable:function(e){this._parentResizable&&this._parentResizable.stopResizeNotificationsFor(this),this._parentResizable=e,e&&e._interestedResizables.indexOf(this)===-1&&(e._interestedResizables.push(this),e._subscribeIronResize(this))},stopResizeNotificationsFor:function(e){var t=this._interestedResizables.indexOf(e);t>-1&&(this._interestedResizables.splice(t,1),this._unsubscribeIronResize(e))},_subscribeIronResize:function(e){e.addEventListener("iron-resize",this._boundOnDescendantIronResize)},_unsubscribeIronResize:function(e){e.removeEventListener("iron-resize",this._boundOnDescendantIronResize)},resizerShouldNotify:function(e){return!0},_onDescendantIronResize:function(e){if(this._notifyingDescendant){e.stopPropagation();return}c_||this._fireResize()},_fireResize:function(){this.fire("iron-resize",null,{node:this,bubbles:!1})},_onIronRequestResizeNotifications:function(e){var t=zt(e).rootTarget;t!==this&&(t.assignParentResizable(this),this._notifyDescendant(t),e.stopPropagation())},_parentResizableChanged:function(e){e&&window.removeEventListener("resize",this._boundNotifyResize)},_notifyDescendant:function(e){!this.isAttached||(this._notifyingDescendant=!0,e.notifyResize(),this._notifyingDescendant=!1)},_requestResizeNotifications:function(){if(!!this.isAttached)if(document.readyState==="loading"){var e=this._requestResizeNotifications.bind(this);document.addEventListener("readystatechange",function t(){document.removeEventListener("readystatechange",t),e()})}else this._findParent(),this._parentResizable?this._parentResizable._interestedResizables.forEach(function(t){t!==this&&t._findParent()},this):(_9.forEach(function(t){t!==this&&t._findParent()},this),window.addEventListener("resize",this._boundNotifyResize),this.notifyResize())},_findParent:function(){this.assignParentResizable(null),this.fire("iron-request-resize-notifications",null,{node:this,bubbles:!0,cancelable:!0}),this._parentResizable?_9.delete(this):_9.add(this)}};Yt({_template:Q`
    <style>
      :host {
        display: block;
        transition-duration: var(--iron-collapse-transition-duration, 300ms);
        /* Safari 10 needs this property prefixed to correctly apply the custom property */
        -webkit-transition-duration: var(--iron-collapse-transition-duration, 300ms);
        overflow: visible;
      }

      :host(.iron-collapse-closed) {
        display: none;
      }

      :host(:not(.iron-collapse-opened)) {
        overflow: hidden;
      }
    </style>

    <slot></slot>
`,is:"iron-collapse",behaviors:[Js],properties:{horizontal:{type:Boolean,value:!1,observer:"_horizontalChanged"},opened:{type:Boolean,value:!1,notify:!0,observer:"_openedChanged"},transitioning:{type:Boolean,notify:!0,readOnly:!0},noAnimation:{type:Boolean},_desiredSize:{type:String,value:""}},get dimension(){return this.horizontal?"width":"height"},get _dimensionMax(){return this.horizontal?"maxWidth":"maxHeight"},get _dimensionMaxCss(){return this.horizontal?"max-width":"max-height"},hostAttributes:{role:"group","aria-hidden":"true"},listeners:{transitionend:"_onTransitionEnd"},toggle:function(){this.opened=!this.opened},show:function(){this.opened=!0},hide:function(){this.opened=!1},updateSize:function(e,t){e=e==="auto"?"":e;var r=t&&!this.noAnimation&&this.isAttached&&this._desiredSize!==e;if(this._desiredSize=e,this._updateTransition(!1),r){var n=this._calcSize();e===""&&(this.style[this._dimensionMax]="",e=this._calcSize()),this.style[this._dimensionMax]=n,this.scrollTop=this.scrollTop,this._updateTransition(!0),r=e!==n}this.style[this._dimensionMax]=e,r||this._transitionEnd()},enableTransition:function(e){Da._warn("`enableTransition()` is deprecated, use `noAnimation` instead."),this.noAnimation=!e},_updateTransition:function(e){this.style.transitionDuration=e&&!this.noAnimation?"":"0s"},_horizontalChanged:function(){this.style.transitionProperty=this._dimensionMaxCss;var e=this._dimensionMax==="maxWidth"?"maxHeight":"maxWidth";this.style[e]="",this.updateSize(this.opened?"auto":"0px",!1)},_openedChanged:function(){this.setAttribute("aria-hidden",!this.opened),this._setTransitioning(!0),this.toggleClass("iron-collapse-closed",!1),this.toggleClass("iron-collapse-opened",!1),this.updateSize(this.opened?"auto":"0px",!0),this.opened&&this.focus()},_transitionEnd:function(){this.style[this._dimensionMax]=this._desiredSize,this.toggleClass("iron-collapse-closed",!this.opened),this.toggleClass("iron-collapse-opened",this.opened),this._updateTransition(!1),this.notifyResize(),this._setTransitioning(!1)},_onTransitionEnd:function(e){zt(e).rootTarget===this&&this._transitionEnd()},_calcSize:function(){return this.getBoundingClientRect()[this.dimension]+"px"}});var Ygt=Q`
/* Most common used flex styles*/
<dom-module id="iron-flex">
  <template>
    <style>
      .layout.horizontal,
      .layout.vertical {
        display: -ms-flexbox;
        display: -webkit-flex;
        display: flex;
      }

      .layout.inline {
        display: -ms-inline-flexbox;
        display: -webkit-inline-flex;
        display: inline-flex;
      }

      .layout.horizontal {
        -ms-flex-direction: row;
        -webkit-flex-direction: row;
        flex-direction: row;
      }

      .layout.vertical {
        -ms-flex-direction: column;
        -webkit-flex-direction: column;
        flex-direction: column;
      }

      .layout.wrap {
        -ms-flex-wrap: wrap;
        -webkit-flex-wrap: wrap;
        flex-wrap: wrap;
      }

      .layout.no-wrap {
        -ms-flex-wrap: nowrap;
        -webkit-flex-wrap: nowrap;
        flex-wrap: nowrap;
      }

      .layout.center,
      .layout.center-center {
        -ms-flex-align: center;
        -webkit-align-items: center;
        align-items: center;
      }

      .layout.center-justified,
      .layout.center-center {
        -ms-flex-pack: center;
        -webkit-justify-content: center;
        justify-content: center;
      }

      .flex {
        -ms-flex: 1 1 0.000000001px;
        -webkit-flex: 1;
        flex: 1;
        -webkit-flex-basis: 0.000000001px;
        flex-basis: 0.000000001px;
      }

      .flex-auto {
        -ms-flex: 1 1 auto;
        -webkit-flex: 1 1 auto;
        flex: 1 1 auto;
      }

      .flex-none {
        -ms-flex: none;
        -webkit-flex: none;
        flex: none;
      }
    </style>
  </template>
</dom-module>
/* Basic flexbox reverse styles */
<dom-module id="iron-flex-reverse">
  <template>
    <style>
      .layout.horizontal-reverse,
      .layout.vertical-reverse {
        display: -ms-flexbox;
        display: -webkit-flex;
        display: flex;
      }

      .layout.horizontal-reverse {
        -ms-flex-direction: row-reverse;
        -webkit-flex-direction: row-reverse;
        flex-direction: row-reverse;
      }

      .layout.vertical-reverse {
        -ms-flex-direction: column-reverse;
        -webkit-flex-direction: column-reverse;
        flex-direction: column-reverse;
      }

      .layout.wrap-reverse {
        -ms-flex-wrap: wrap-reverse;
        -webkit-flex-wrap: wrap-reverse;
        flex-wrap: wrap-reverse;
      }
    </style>
  </template>
</dom-module>
/* Flexbox alignment */
<dom-module id="iron-flex-alignment">
  <template>
    <style>
      /**
       * Alignment in cross axis.
       */
      .layout.start {
        -ms-flex-align: start;
        -webkit-align-items: flex-start;
        align-items: flex-start;
      }

      .layout.center,
      .layout.center-center {
        -ms-flex-align: center;
        -webkit-align-items: center;
        align-items: center;
      }

      .layout.end {
        -ms-flex-align: end;
        -webkit-align-items: flex-end;
        align-items: flex-end;
      }

      .layout.baseline {
        -ms-flex-align: baseline;
        -webkit-align-items: baseline;
        align-items: baseline;
      }

      /**
       * Alignment in main axis.
       */
      .layout.start-justified {
        -ms-flex-pack: start;
        -webkit-justify-content: flex-start;
        justify-content: flex-start;
      }

      .layout.center-justified,
      .layout.center-center {
        -ms-flex-pack: center;
        -webkit-justify-content: center;
        justify-content: center;
      }

      .layout.end-justified {
        -ms-flex-pack: end;
        -webkit-justify-content: flex-end;
        justify-content: flex-end;
      }

      .layout.around-justified {
        -ms-flex-pack: distribute;
        -webkit-justify-content: space-around;
        justify-content: space-around;
      }

      .layout.justified {
        -ms-flex-pack: justify;
        -webkit-justify-content: space-between;
        justify-content: space-between;
      }

      /**
       * Self alignment.
       */
      .self-start {
        -ms-align-self: flex-start;
        -webkit-align-self: flex-start;
        align-self: flex-start;
      }

      .self-center {
        -ms-align-self: center;
        -webkit-align-self: center;
        align-self: center;
      }

      .self-end {
        -ms-align-self: flex-end;
        -webkit-align-self: flex-end;
        align-self: flex-end;
      }

      .self-stretch {
        -ms-align-self: stretch;
        -webkit-align-self: stretch;
        align-self: stretch;
      }

      .self-baseline {
        -ms-align-self: baseline;
        -webkit-align-self: baseline;
        align-self: baseline;
      }

      /**
       * multi-line alignment in main axis.
       */
      .layout.start-aligned {
        -ms-flex-line-pack: start;  /* IE10 */
        -ms-align-content: flex-start;
        -webkit-align-content: flex-start;
        align-content: flex-start;
      }

      .layout.end-aligned {
        -ms-flex-line-pack: end;  /* IE10 */
        -ms-align-content: flex-end;
        -webkit-align-content: flex-end;
        align-content: flex-end;
      }

      .layout.center-aligned {
        -ms-flex-line-pack: center;  /* IE10 */
        -ms-align-content: center;
        -webkit-align-content: center;
        align-content: center;
      }

      .layout.between-aligned {
        -ms-flex-line-pack: justify;  /* IE10 */
        -ms-align-content: space-between;
        -webkit-align-content: space-between;
        align-content: space-between;
      }

      .layout.around-aligned {
        -ms-flex-line-pack: distribute;  /* IE10 */
        -ms-align-content: space-around;
        -webkit-align-content: space-around;
        align-content: space-around;
      }
    </style>
  </template>
</dom-module>
/* Non-flexbox positioning helper styles */
<dom-module id="iron-flex-factors">
  <template>
    <style>
      .flex,
      .flex-1 {
        -ms-flex: 1 1 0.000000001px;
        -webkit-flex: 1;
        flex: 1;
        -webkit-flex-basis: 0.000000001px;
        flex-basis: 0.000000001px;
      }

      .flex-2 {
        -ms-flex: 2;
        -webkit-flex: 2;
        flex: 2;
      }

      .flex-3 {
        -ms-flex: 3;
        -webkit-flex: 3;
        flex: 3;
      }

      .flex-4 {
        -ms-flex: 4;
        -webkit-flex: 4;
        flex: 4;
      }

      .flex-5 {
        -ms-flex: 5;
        -webkit-flex: 5;
        flex: 5;
      }

      .flex-6 {
        -ms-flex: 6;
        -webkit-flex: 6;
        flex: 6;
      }

      .flex-7 {
        -ms-flex: 7;
        -webkit-flex: 7;
        flex: 7;
      }

      .flex-8 {
        -ms-flex: 8;
        -webkit-flex: 8;
        flex: 8;
      }

      .flex-9 {
        -ms-flex: 9;
        -webkit-flex: 9;
        flex: 9;
      }

      .flex-10 {
        -ms-flex: 10;
        -webkit-flex: 10;
        flex: 10;
      }

      .flex-11 {
        -ms-flex: 11;
        -webkit-flex: 11;
        flex: 11;
      }

      .flex-12 {
        -ms-flex: 12;
        -webkit-flex: 12;
        flex: 12;
      }
    </style>
  </template>
</dom-module>
<dom-module id="iron-positioning">
  <template>
    <style>
      .block {
        display: block;
      }

      [hidden] {
        display: none !important;
      }

      .invisible {
        visibility: hidden !important;
      }

      .relative {
        position: relative;
      }

      .fit {
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
      }

      body.fullbleed {
        margin: 0;
        height: 100vh;
      }

      .scroll {
        -webkit-overflow-scrolling: touch;
        overflow: auto;
      }

      /* fixed position */
      .fixed-bottom,
      .fixed-left,
      .fixed-right,
      .fixed-top {
        position: fixed;
      }

      .fixed-top {
        top: 0;
        left: 0;
        right: 0;
      }

      .fixed-right {
        top: 0;
        right: 0;
        bottom: 0;
      }

      .fixed-bottom {
        right: 0;
        bottom: 0;
        left: 0;
      }

      .fixed-left {
        top: 0;
        bottom: 0;
        left: 0;
      }
    </style>
  </template>
</dom-module>
`;Ygt.setAttribute("style","display: none;");document.head.appendChild(Ygt.content);var jgt=Q`
<custom-style>
  <style is="custom-style">
    [hidden] {
      display: none !important;
    }
  </style>
</custom-style>
<custom-style>
  <style is="custom-style">
    html {

      --layout: {
        display: -ms-flexbox;
        display: -webkit-flex;
        display: flex;
      };

      --layout-inline: {
        display: -ms-inline-flexbox;
        display: -webkit-inline-flex;
        display: inline-flex;
      };

      --layout-horizontal: {
        @apply --layout;

        -ms-flex-direction: row;
        -webkit-flex-direction: row;
        flex-direction: row;
      };

      --layout-horizontal-reverse: {
        @apply --layout;

        -ms-flex-direction: row-reverse;
        -webkit-flex-direction: row-reverse;
        flex-direction: row-reverse;
      };

      --layout-vertical: {
        @apply --layout;

        -ms-flex-direction: column;
        -webkit-flex-direction: column;
        flex-direction: column;
      };

      --layout-vertical-reverse: {
        @apply --layout;

        -ms-flex-direction: column-reverse;
        -webkit-flex-direction: column-reverse;
        flex-direction: column-reverse;
      };

      --layout-wrap: {
        -ms-flex-wrap: wrap;
        -webkit-flex-wrap: wrap;
        flex-wrap: wrap;
      };

      --layout-wrap-reverse: {
        -ms-flex-wrap: wrap-reverse;
        -webkit-flex-wrap: wrap-reverse;
        flex-wrap: wrap-reverse;
      };

      --layout-flex-auto: {
        -ms-flex: 1 1 auto;
        -webkit-flex: 1 1 auto;
        flex: 1 1 auto;
      };

      --layout-flex-none: {
        -ms-flex: none;
        -webkit-flex: none;
        flex: none;
      };

      --layout-flex: {
        -ms-flex: 1 1 0.000000001px;
        -webkit-flex: 1;
        flex: 1;
        -webkit-flex-basis: 0.000000001px;
        flex-basis: 0.000000001px;
      };

      --layout-flex-2: {
        -ms-flex: 2;
        -webkit-flex: 2;
        flex: 2;
      };

      --layout-flex-3: {
        -ms-flex: 3;
        -webkit-flex: 3;
        flex: 3;
      };

      --layout-flex-4: {
        -ms-flex: 4;
        -webkit-flex: 4;
        flex: 4;
      };

      --layout-flex-5: {
        -ms-flex: 5;
        -webkit-flex: 5;
        flex: 5;
      };

      --layout-flex-6: {
        -ms-flex: 6;
        -webkit-flex: 6;
        flex: 6;
      };

      --layout-flex-7: {
        -ms-flex: 7;
        -webkit-flex: 7;
        flex: 7;
      };

      --layout-flex-8: {
        -ms-flex: 8;
        -webkit-flex: 8;
        flex: 8;
      };

      --layout-flex-9: {
        -ms-flex: 9;
        -webkit-flex: 9;
        flex: 9;
      };

      --layout-flex-10: {
        -ms-flex: 10;
        -webkit-flex: 10;
        flex: 10;
      };

      --layout-flex-11: {
        -ms-flex: 11;
        -webkit-flex: 11;
        flex: 11;
      };

      --layout-flex-12: {
        -ms-flex: 12;
        -webkit-flex: 12;
        flex: 12;
      };

      /* alignment in cross axis */

      --layout-start: {
        -ms-flex-align: start;
        -webkit-align-items: flex-start;
        align-items: flex-start;
      };

      --layout-center: {
        -ms-flex-align: center;
        -webkit-align-items: center;
        align-items: center;
      };

      --layout-end: {
        -ms-flex-align: end;
        -webkit-align-items: flex-end;
        align-items: flex-end;
      };

      --layout-baseline: {
        -ms-flex-align: baseline;
        -webkit-align-items: baseline;
        align-items: baseline;
      };

      /* alignment in main axis */

      --layout-start-justified: {
        -ms-flex-pack: start;
        -webkit-justify-content: flex-start;
        justify-content: flex-start;
      };

      --layout-center-justified: {
        -ms-flex-pack: center;
        -webkit-justify-content: center;
        justify-content: center;
      };

      --layout-end-justified: {
        -ms-flex-pack: end;
        -webkit-justify-content: flex-end;
        justify-content: flex-end;
      };

      --layout-around-justified: {
        -ms-flex-pack: distribute;
        -webkit-justify-content: space-around;
        justify-content: space-around;
      };

      --layout-justified: {
        -ms-flex-pack: justify;
        -webkit-justify-content: space-between;
        justify-content: space-between;
      };

      --layout-center-center: {
        @apply --layout-center;
        @apply --layout-center-justified;
      };

      /* self alignment */

      --layout-self-start: {
        -ms-align-self: flex-start;
        -webkit-align-self: flex-start;
        align-self: flex-start;
      };

      --layout-self-center: {
        -ms-align-self: center;
        -webkit-align-self: center;
        align-self: center;
      };

      --layout-self-end: {
        -ms-align-self: flex-end;
        -webkit-align-self: flex-end;
        align-self: flex-end;
      };

      --layout-self-stretch: {
        -ms-align-self: stretch;
        -webkit-align-self: stretch;
        align-self: stretch;
      };

      --layout-self-baseline: {
        -ms-align-self: baseline;
        -webkit-align-self: baseline;
        align-self: baseline;
      };

      /* multi-line alignment in main axis */

      --layout-start-aligned: {
        -ms-flex-line-pack: start;  /* IE10 */
        -ms-align-content: flex-start;
        -webkit-align-content: flex-start;
        align-content: flex-start;
      };

      --layout-end-aligned: {
        -ms-flex-line-pack: end;  /* IE10 */
        -ms-align-content: flex-end;
        -webkit-align-content: flex-end;
        align-content: flex-end;
      };

      --layout-center-aligned: {
        -ms-flex-line-pack: center;  /* IE10 */
        -ms-align-content: center;
        -webkit-align-content: center;
        align-content: center;
      };

      --layout-between-aligned: {
        -ms-flex-line-pack: justify;  /* IE10 */
        -ms-align-content: space-between;
        -webkit-align-content: space-between;
        align-content: space-between;
      };

      --layout-around-aligned: {
        -ms-flex-line-pack: distribute;  /* IE10 */
        -ms-align-content: space-around;
        -webkit-align-content: space-around;
        align-content: space-around;
      };

      /*******************************
                Other Layout
      *******************************/

      --layout-block: {
        display: block;
      };

      --layout-invisible: {
        visibility: hidden !important;
      };

      --layout-relative: {
        position: relative;
      };

      --layout-fit: {
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
      };

      --layout-scroll: {
        -webkit-overflow-scrolling: touch;
        overflow: auto;
      };

      --layout-fullbleed: {
        margin: 0;
        height: 100vh;
      };

      /* fixed position */

      --layout-fixed-top: {
        position: fixed;
        top: 0;
        left: 0;
        right: 0;
      };

      --layout-fixed-right: {
        position: fixed;
        top: 0;
        right: 0;
        bottom: 0;
      };

      --layout-fixed-bottom: {
        position: fixed;
        right: 0;
        bottom: 0;
        left: 0;
      };

      --layout-fixed-left: {
        position: fixed;
        top: 0;
        bottom: 0;
        left: 0;
      };

    }
  </style>
</custom-style>`;jgt.setAttribute("style","display: none;");document.head.appendChild(jgt.content);var Xgt=document.createElement("style");Xgt.textContent="[hidden] { display: none !important; }";document.head.appendChild(Xgt);var go=class{constructor(t){go[" "](t),this.type=t&&t.type||"default",this.key=t&&t.key,t&&"value"in t&&(this.value=t.value)}get value(){var t=this.type,r=this.key;if(t&&r)return go.types[t]&&go.types[t][r]}set value(t){var r=this.type,n=this.key;r&&n&&(r=go.types[r]=go.types[r]||{},t==null?delete r[n]:r[n]=t)}get list(){var t=this.type;if(t){var r=go.types[this.type];return r?Object.keys(r).map(function(n){return fbe[this.type][n]},this):[]}}byKey(t){return this.key=t,this.value}};go[" "]=function(){};go.types={};var fbe=go.types;Yt({is:"iron-meta",properties:{type:{type:String,value:"default"},key:{type:String},value:{type:String,notify:!0},self:{type:Boolean,observer:"_selfChanged"},__meta:{type:Boolean,computed:"__computeMeta(type, key, value)"}},hostAttributes:{hidden:!0},__computeMeta:function(e,t,r){var n=new go({type:e,key:t});return r!==void 0&&r!==n.value?n.value=r:this.value!==n.value&&(this.value=n.value),n},get list(){return this.__meta&&this.__meta.list},_selfChanged:function(e){e&&(this.value=this)},byKey:function(e){return new go({type:this.type,key:e}).value}});Yt({_template:Q`
    <style>
      :host {
        @apply --layout-inline;
        @apply --layout-center-center;
        position: relative;

        vertical-align: middle;

        fill: var(--iron-icon-fill-color, currentcolor);
        stroke: var(--iron-icon-stroke-color, none);

        width: var(--iron-icon-width, 24px);
        height: var(--iron-icon-height, 24px);
        @apply --iron-icon;
      }

      :host([hidden]) {
        display: none;
      }
    </style>
`,is:"iron-icon",properties:{icon:{type:String},theme:{type:String},src:{type:String},_meta:{value:Da.create("iron-meta",{type:"iconset"})}},observers:["_updateIcon(_meta, isAttached)","_updateIcon(theme, isAttached)","_srcChanged(src, isAttached)","_iconChanged(icon, isAttached)"],_DEFAULT_ICONSET:"icons",_iconChanged:function(e){var t=(e||"").split(":");this._iconName=t.pop(),this._iconsetName=t.pop()||this._DEFAULT_ICONSET,this._updateIcon()},_srcChanged:function(e){this._updateIcon()},_usesIconset:function(){return this.icon||!this.src},_updateIcon:function(){this._usesIconset()?(this._img&&this._img.parentNode&&zt(this.root).removeChild(this._img),this._iconName===""?this._iconset&&this._iconset.removeIcon(this):this._iconsetName&&this._meta&&(this._iconset=this._meta.byKey(this._iconsetName),this._iconset?(this._iconset.applyIcon(this,this._iconName,this.theme),this.unlisten(window,"iron-iconset-added","_updateIcon")):this.listen(window,"iron-iconset-added","_updateIcon"))):(this._iconset&&this._iconset.removeIcon(this),this._img||(this._img=document.createElement("img"),this._img.style.width="100%",this._img.style.height="100%",this._img.draggable=!1),this._img.src=this.src,zt(this.root).appendChild(this._img))}});Yt({is:"iron-iconset-svg",properties:{name:{type:String,observer:"_nameChanged"},size:{type:Number,value:24},rtlMirroring:{type:Boolean,value:!1},useGlobalRtlAttribute:{type:Boolean,value:!1}},created:function(){this._meta=new go({type:"iconset",key:null,value:null})},attached:function(){this.style.display="none"},getIconNames:function(){return this._icons=this._createIconMap(),Object.keys(this._icons).map(function(e){return this.name+":"+e},this)},applyIcon:function(e,t){this.removeIcon(e);var r=this._cloneIcon(t,this.rtlMirroring&&this._targetIsRTL(e));if(r){var n=zt(e.root||e);return n.insertBefore(r,n.childNodes[0]),e._svgIcon=r}return null},removeIcon:function(e){e._svgIcon&&(zt(e.root||e).removeChild(e._svgIcon),e._svgIcon=null)},_targetIsRTL:function(e){if(this.__targetIsRTL==null)if(this.useGlobalRtlAttribute){var t=document.body&&document.body.hasAttribute("dir")?document.body:document.documentElement;this.__targetIsRTL=t.getAttribute("dir")==="rtl"}else e&&e.nodeType!==Node.ELEMENT_NODE&&(e=e.host),this.__targetIsRTL=e&&window.getComputedStyle(e).direction==="rtl";return this.__targetIsRTL},_nameChanged:function(){this._meta.value=null,this._meta.key=this.name,this._meta.value=this,this.async(function(){this.fire("iron-iconset-added",this,{node:window})})},_createIconMap:function(){var e=Object.create(null);return zt(this).querySelectorAll("[id]").forEach(function(t){e[t.id]=t}),e},_cloneIcon:function(e,t){return this._icons=this._icons||this._createIconMap(),this._prepareSvgClone(this._icons[e],this.size,t)},_prepareSvgClone:function(e,t,r){if(e){var n=e.cloneNode(!0),i=document.createElementNS("http://www.w3.org/2000/svg","svg"),o=n.getAttribute("viewBox")||"0 0 "+t+" "+t,a="pointer-events: none; display: block; width: 100%; height: 100%;";return r&&n.hasAttribute("mirror-in-rtl")&&(a+="-webkit-transform:scale(-1,1);transform:scale(-1,1);transform-origin:center;"),i.setAttribute("viewBox",o),i.setAttribute("preserveAspectRatio","xMidYMid meet"),i.setAttribute("focusable","false"),i.style.cssText=a,i.appendChild(n).removeAttribute("id"),i}return null}});var pbe=Q`<iron-iconset-svg name="image" size="24">
<svg><defs>
<g id="add-a-photo"><path d="M3 4V1h2v3h3v2H5v3H3V6H0V4h3zm3 6V7h3V4h7l1.83 2H21c1.1 0 2 .9 2 2v12c0 1.1-.9 2-2 2H5c-1.1 0-2-.9-2-2V10h3zm7 9c2.76 0 5-2.24 5-5s-2.24-5-5-5-5 2.24-5 5 2.24 5 5 5zm-3.2-5c0 1.77 1.43 3.2 3.2 3.2s3.2-1.43 3.2-3.2-1.43-3.2-3.2-3.2-3.2 1.43-3.2 3.2z"></path></g>
<g id="add-to-photos"><path d="M4 6H2v14c0 1.1.9 2 2 2h14v-2H4V6zm16-4H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-1 9h-4v4h-2v-4H9V9h4V5h2v4h4v2z"></path></g>
<g id="adjust"><path d="M12 2C6.49 2 2 6.49 2 12s4.49 10 10 10 10-4.49 10-10S17.51 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zm3-8c0 1.66-1.34 3-3 3s-3-1.34-3-3 1.34-3 3-3 3 1.34 3 3z"></path></g>
<g id="assistant"><path d="M19 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h4l3 3 3-3h4c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-5.12 10.88L12 17l-1.88-4.12L6 11l4.12-1.88L12 5l1.88 4.12L18 11l-4.12 1.88z"></path></g>
<g id="assistant-photo"><path d="M14.4 6L14 4H5v17h2v-7h5.6l.4 2h7V6z"></path></g>
<g id="audiotrack"><path d="M12 3v9.28c-.47-.17-.97-.28-1.5-.28C8.01 12 6 14.01 6 16.5S8.01 21 10.5 21c2.31 0 4.2-1.75 4.45-4H15V6h4V3h-7z"></path></g>
<g id="blur-circular"><path d="M10 9c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0 4c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zM7 9.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm3 7c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm-3-3c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm3-6c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM14 9c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0-1.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm3 6c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm0-4c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm2-3.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm0-3.5c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1z"></path></g>
<g id="blur-linear"><path d="M5 17.5c.83 0 1.5-.67 1.5-1.5s-.67-1.5-1.5-1.5-1.5.67-1.5 1.5.67 1.5 1.5 1.5zM9 13c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0-4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zM3 21h18v-2H3v2zM5 9.5c.83 0 1.5-.67 1.5-1.5S5.83 6.5 5 6.5 3.5 7.17 3.5 8 4.17 9.5 5 9.5zm0 4c.83 0 1.5-.67 1.5-1.5s-.67-1.5-1.5-1.5-1.5.67-1.5 1.5.67 1.5 1.5 1.5zM9 17c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm8-.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM3 3v2h18V3H3zm14 5.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm0 4c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM13 9c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0 4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0 4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1z"></path></g>
<g id="blur-off"><path d="M14 7c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm-.2 4.48l.2.02c.83 0 1.5-.67 1.5-1.5s-.67-1.5-1.5-1.5-1.5.67-1.5 1.5l.02.2c.09.67.61 1.19 1.28 1.28zM14 3.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm-4 0c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm11 7c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM10 7c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm8 8c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0-4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0-4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm-4 13.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM2.5 5.27l3.78 3.78L6 9c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1c0-.1-.03-.19-.06-.28l2.81 2.81c-.71.11-1.25.73-1.25 1.47 0 .83.67 1.5 1.5 1.5.74 0 1.36-.54 1.47-1.25l2.81 2.81c-.09-.03-.18-.06-.28-.06-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1c0-.1-.03-.19-.06-.28l3.78 3.78L20 20.23 3.77 4 2.5 5.27zM10 17c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm11-3.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM6 13c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zM3 9.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm7 11c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM6 17c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm-3-3.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5z"></path></g>
<g id="blur-on"><path d="M6 13c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0 4c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0-8c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm-3 .5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM6 5c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm15 5.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM14 7c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0-3.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm-11 10c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm7 7c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm0-17c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM10 7c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0 5.5c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5zm8 .5c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0 4c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0-8c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0-4c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm3 8.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM14 17c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0 3.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm-4-12c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5zm0 8.5c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm4-4.5c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5zm0-4c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5z"></path></g>
<g id="brightness-1"><circle cx="12" cy="12" r="10"></circle></g>
<g id="brightness-2"><path d="M10 2c-1.82 0-3.53.5-5 1.35C7.99 5.08 10 8.3 10 12s-2.01 6.92-5 8.65C6.47 21.5 8.18 22 10 22c5.52 0 10-4.48 10-10S15.52 2 10 2z"></path></g>
<g id="brightness-3"><path d="M9 2c-1.05 0-2.05.16-3 .46 4.06 1.27 7 5.06 7 9.54 0 4.48-2.94 8.27-7 9.54.95.3 1.95.46 3 .46 5.52 0 10-4.48 10-10S14.52 2 9 2z"></path></g>
<g id="brightness-4"><path d="M20 8.69V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69L23.31 12 20 8.69zM12 18c-.89 0-1.74-.2-2.5-.55C11.56 16.5 13 14.42 13 12s-1.44-4.5-3.5-5.45C10.26 6.2 11.11 6 12 6c3.31 0 6 2.69 6 6s-2.69 6-6 6z"></path></g>
<g id="brightness-5"><path d="M20 15.31L23.31 12 20 8.69V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69zM12 18c-3.31 0-6-2.69-6-6s2.69-6 6-6 6 2.69 6 6-2.69 6-6 6z"></path></g>
<g id="brightness-6"><path d="M20 15.31L23.31 12 20 8.69V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69zM12 18V6c3.31 0 6 2.69 6 6s-2.69 6-6 6z"></path></g>
<g id="brightness-7"><path d="M20 8.69V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69L23.31 12 20 8.69zM12 18c-3.31 0-6-2.69-6-6s2.69-6 6-6 6 2.69 6 6-2.69 6-6 6zm0-10c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4z"></path></g>
<g id="broken-image"><path d="M21 5v6.59l-3-3.01-4 4.01-4-4-4 4-3-3.01V5c0-1.1.9-2 2-2h14c1.1 0 2 .9 2 2zm-3 6.42l3 3.01V19c0 1.1-.9 2-2 2H5c-1.1 0-2-.9-2-2v-6.58l3 2.99 4-4 4 4 4-3.99z"></path></g>
<g id="brush"><path d="M7 14c-1.66 0-3 1.34-3 3 0 1.31-1.16 2-2 2 .92 1.22 2.49 2 4 2 2.21 0 4-1.79 4-4 0-1.66-1.34-3-3-3zm13.71-9.37l-1.34-1.34c-.39-.39-1.02-.39-1.41 0L9 12.25 11.75 15l8.96-8.96c.39-.39.39-1.02 0-1.41z"></path></g>
<g id="burst-mode"><path d="M1 5h2v14H1zm4 0h2v14H5zm17 0H10c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h12c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1zM11 17l2.5-3.15L15.29 16l2.5-3.22L21 17H11z"></path></g>
<g id="camera"><path d="M9.4 10.5l4.77-8.26C13.47 2.09 12.75 2 12 2c-2.4 0-4.6.85-6.32 2.25l3.66 6.35.06-.1zM21.54 9c-.92-2.92-3.15-5.26-6-6.34L11.88 9h9.66zm.26 1h-7.49l.29.5 4.76 8.25C21 16.97 22 14.61 22 12c0-.69-.07-1.35-.2-2zM8.54 12l-3.9-6.75C3.01 7.03 2 9.39 2 12c0 .69.07 1.35.2 2h7.49l-1.15-2zm-6.08 3c.92 2.92 3.15 5.26 6 6.34L12.12 15H2.46zm11.27 0l-3.9 6.76c.7.15 1.42.24 2.17.24 2.4 0 4.6-.85 6.32-2.25l-3.66-6.35-.93 1.6z"></path></g>
<g id="camera-alt"><circle cx="12" cy="12" r="3.2"></circle><path d="M9 2L7.17 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2h-3.17L15 2H9zm3 15c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5z"></path></g>
<g id="camera-front"><path d="M10 20H5v2h5v2l3-3-3-3v2zm4 0v2h5v-2h-5zM12 8c1.1 0 2-.9 2-2s-.9-2-2-2-1.99.9-1.99 2S10.9 8 12 8zm5-8H7C5.9 0 5 .9 5 2v14c0 1.1.9 2 2 2h10c1.1 0 2-.9 2-2V2c0-1.1-.9-2-2-2zM7 2h10v10.5c0-1.67-3.33-2.5-5-2.5s-5 .83-5 2.5V2z"></path></g>
<g id="camera-rear"><path d="M10 20H5v2h5v2l3-3-3-3v2zm4 0v2h5v-2h-5zm3-20H7C5.9 0 5 .9 5 2v14c0 1.1.9 2 2 2h10c1.1 0 2-.9 2-2V2c0-1.1-.9-2-2-2zm-5 6c-1.11 0-2-.9-2-2s.89-2 1.99-2 2 .9 2 2C14 5.1 13.1 6 12 6z"></path></g>
<g id="camera-roll"><path d="M14 5c0-1.1-.9-2-2-2h-1V2c0-.55-.45-1-1-1H6c-.55 0-1 .45-1 1v1H4c-1.1 0-2 .9-2 2v15c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2h8V5h-8zm-2 13h-2v-2h2v2zm0-9h-2V7h2v2zm4 9h-2v-2h2v2zm0-9h-2V7h2v2zm4 9h-2v-2h2v2zm0-9h-2V7h2v2z"></path></g>
<g id="center-focus-strong"><path d="M12 8c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm-7 7H3v4c0 1.1.9 2 2 2h4v-2H5v-4zM5 5h4V3H5c-1.1 0-2 .9-2 2v4h2V5zm14-2h-4v2h4v4h2V5c0-1.1-.9-2-2-2zm0 16h-4v2h4c1.1 0 2-.9 2-2v-4h-2v4z"></path></g>
<g id="center-focus-weak"><path d="M5 15H3v4c0 1.1.9 2 2 2h4v-2H5v-4zM5 5h4V3H5c-1.1 0-2 .9-2 2v4h2V5zm14-2h-4v2h4v4h2V5c0-1.1-.9-2-2-2zm0 16h-4v2h4c1.1 0 2-.9 2-2v-4h-2v4zM12 8c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm0 6c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2z"></path></g>
<g id="collections"><path d="M22 16V4c0-1.1-.9-2-2-2H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2zm-11-4l2.03 2.71L16 11l4 5H8l3-4zM2 6v14c0 1.1.9 2 2 2h14v-2H4V6H2z"></path></g>
<g id="collections-bookmark"><path d="M4 6H2v14c0 1.1.9 2 2 2h14v-2H4V6zm16-4H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm0 10l-2.5-1.5L15 12V4h5v8z"></path></g>
<g id="color-lens"><path d="M12 3c-4.97 0-9 4.03-9 9s4.03 9 9 9c.83 0 1.5-.67 1.5-1.5 0-.39-.15-.74-.39-1.01-.23-.26-.38-.61-.38-.99 0-.83.67-1.5 1.5-1.5H16c2.76 0 5-2.24 5-5 0-4.42-4.03-8-9-8zm-5.5 9c-.83 0-1.5-.67-1.5-1.5S5.67 9 6.5 9 8 9.67 8 10.5 7.33 12 6.5 12zm3-4C8.67 8 8 7.33 8 6.5S8.67 5 9.5 5s1.5.67 1.5 1.5S10.33 8 9.5 8zm5 0c-.83 0-1.5-.67-1.5-1.5S13.67 5 14.5 5s1.5.67 1.5 1.5S15.33 8 14.5 8zm3 4c-.83 0-1.5-.67-1.5-1.5S16.67 9 17.5 9s1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"></path></g>
<g id="colorize"><path d="M20.71 5.63l-2.34-2.34c-.39-.39-1.02-.39-1.41 0l-3.12 3.12-1.93-1.91-1.41 1.41 1.42 1.42L3 16.25V21h4.75l8.92-8.92 1.42 1.42 1.41-1.41-1.92-1.92 3.12-3.12c.4-.4.4-1.03.01-1.42zM6.92 19L5 17.08l8.06-8.06 1.92 1.92L6.92 19z"></path></g>
<g id="compare"><path d="M10 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h5v2h2V1h-2v2zm0 15H5l5-6v6zm9-15h-5v2h5v13l-5-6v9h5c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2z"></path></g>
<g id="control-point"><path d="M13 7h-2v4H7v2h4v4h2v-4h4v-2h-4V7zm-1-5C6.49 2 2 6.49 2 12s4.49 10 10 10 10-4.49 10-10S17.51 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="control-point-duplicate"><path d="M16 8h-2v3h-3v2h3v3h2v-3h3v-2h-3zM2 12c0-2.79 1.64-5.2 4.01-6.32V3.52C2.52 4.76 0 8.09 0 12s2.52 7.24 6.01 8.48v-2.16C3.64 17.2 2 14.79 2 12zm13-9c-4.96 0-9 4.04-9 9s4.04 9 9 9 9-4.04 9-9-4.04-9-9-9zm0 16c-3.86 0-7-3.14-7-7s3.14-7 7-7 7 3.14 7 7-3.14 7-7 7z"></path></g>
<g id="crop"><path d="M17 15h2V7c0-1.1-.9-2-2-2H9v2h8v8zM7 17V1H5v4H1v2h4v10c0 1.1.9 2 2 2h10v4h2v-4h4v-2H7z"></path></g>
<g id="crop-16-9"><path d="M19 6H5c-1.1 0-2 .9-2 2v8c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2zm0 10H5V8h14v8z"></path></g>
<g id="crop-3-2"><path d="M19 4H5c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 14H5V6h14v12z"></path></g>
<g id="crop-5-4"><path d="M19 5H5c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 12H5V7h14v10z"></path></g>
<g id="crop-7-5"><path d="M19 7H5c-1.1 0-2 .9-2 2v6c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V9c0-1.1-.9-2-2-2zm0 8H5V9h14v6z"></path></g>
<g id="crop-din"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V5h14v14z"></path></g>
<g id="crop-free"><path d="M3 5v4h2V5h4V3H5c-1.1 0-2 .9-2 2zm2 10H3v4c0 1.1.9 2 2 2h4v-2H5v-4zm14 4h-4v2h4c1.1 0 2-.9 2-2v-4h-2v4zm0-16h-4v2h4v4h2V5c0-1.1-.9-2-2-2z"></path></g>
<g id="crop-landscape"><path d="M19 5H5c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 12H5V7h14v10z"></path></g>
<g id="crop-original"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V5h14v14zm-5.04-6.71l-2.75 3.54-1.96-2.36L6.5 17h11l-3.54-4.71z"></path></g>
<g id="crop-portrait"><path d="M17 3H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h10c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H7V5h10v14z"></path></g>
<g id="crop-rotate"><path d="M7.47 21.49C4.2 19.93 1.86 16.76 1.5 13H0c.51 6.16 5.66 11 11.95 11 .23 0 .44-.02.66-.03L8.8 20.15l-1.33 1.34zM12.05 0c-.23 0-.44.02-.66.04l3.81 3.81 1.33-1.33C19.8 4.07 22.14 7.24 22.5 11H24c-.51-6.16-5.66-11-11.95-11zM16 14h2V8c0-1.11-.9-2-2-2h-6v2h6v6zm-8 2V4H6v2H4v2h2v8c0 1.1.89 2 2 2h8v2h2v-2h2v-2H8z"></path></g>
<g id="crop-square"><path d="M18 4H6c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 14H6V6h12v12z"></path></g>
<g id="dehaze"><path d="M2 15.5v2h20v-2H2zm0-5v2h20v-2H2zm0-5v2h20v-2H2z"></path></g>
<g id="details"><path d="M3 4l9 16 9-16H3zm3.38 2h11.25L12 16 6.38 6z"></path></g>
<g id="edit"><path d="M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04c.39-.39.39-1.02 0-1.41l-2.34-2.34c-.39-.39-1.02-.39-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z"></path></g>
<g id="exposure"><path d="M15 17v2h2v-2h2v-2h-2v-2h-2v2h-2v2h2zm5-15H4c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM5 5h6v2H5V5zm15 15H4L20 4v16z"></path></g>
<g id="exposure-neg-1"><path d="M4 11v2h8v-2H4zm15 7h-2V7.38L14 8.4V6.7L18.7 5h.3v13z"></path></g>
<g id="exposure-neg-2"><path d="M15.05 16.29l2.86-3.07c.38-.39.72-.79 1.04-1.18.32-.39.59-.78.82-1.17.23-.39.41-.78.54-1.17s.19-.79.19-1.18c0-.53-.09-1.02-.27-1.46-.18-.44-.44-.81-.78-1.11-.34-.31-.77-.54-1.26-.71-.51-.16-1.08-.24-1.72-.24-.69 0-1.31.11-1.85.32-.54.21-1 .51-1.36.88-.37.37-.65.8-.84 1.3-.18.47-.27.97-.28 1.5h2.14c.01-.31.05-.6.13-.87.09-.29.23-.54.4-.75.18-.21.41-.37.68-.49.27-.12.6-.18.96-.18.31 0 .58.05.81.15.23.1.43.25.59.43.16.18.28.4.37.65.08.25.13.52.13.81 0 .22-.03.43-.08.65-.06.22-.15.45-.29.7-.14.25-.32.53-.56.83-.23.3-.52.65-.88 1.03l-4.17 4.55V18H21v-1.71h-5.95zM2 11v2h8v-2H2z"></path></g>
<g id="exposure-plus-1"><path d="M10 7H8v4H4v2h4v4h2v-4h4v-2h-4V7zm10 11h-2V7.38L15 8.4V6.7L19.7 5h.3v13z"></path></g>
<g id="exposure-plus-2"><path d="M16.05 16.29l2.86-3.07c.38-.39.72-.79 1.04-1.18.32-.39.59-.78.82-1.17.23-.39.41-.78.54-1.17.13-.39.19-.79.19-1.18 0-.53-.09-1.02-.27-1.46-.18-.44-.44-.81-.78-1.11-.34-.31-.77-.54-1.26-.71-.51-.16-1.08-.24-1.72-.24-.69 0-1.31.11-1.85.32-.54.21-1 .51-1.36.88-.37.37-.65.8-.84 1.3-.18.47-.27.97-.28 1.5h2.14c.01-.31.05-.6.13-.87.09-.29.23-.54.4-.75.18-.21.41-.37.68-.49.27-.12.6-.18.96-.18.31 0 .58.05.81.15.23.1.43.25.59.43.16.18.28.4.37.65.08.25.13.52.13.81 0 .22-.03.43-.08.65-.06.22-.15.45-.29.7-.14.25-.32.53-.56.83-.23.3-.52.65-.88 1.03l-4.17 4.55V18H22v-1.71h-5.95zM8 7H6v4H2v2h4v4h2v-4h4v-2H8V7z"></path></g>
<g id="exposure-zero"><path d="M16.14 12.5c0 1-.1 1.85-.3 2.55-.2.7-.48 1.27-.83 1.7-.36.44-.79.75-1.3.95-.51.2-1.07.3-1.7.3-.62 0-1.18-.1-1.69-.3-.51-.2-.95-.51-1.31-.95-.36-.44-.65-1.01-.85-1.7-.2-.7-.3-1.55-.3-2.55v-2.04c0-1 .1-1.85.3-2.55.2-.7.48-1.26.84-1.69.36-.43.8-.74 1.31-.93C10.81 5.1 11.38 5 12 5c.63 0 1.19.1 1.7.29.51.19.95.5 1.31.93.36.43.64.99.84 1.69.2.7.3 1.54.3 2.55v2.04zm-2.11-2.36c0-.64-.05-1.18-.13-1.62-.09-.44-.22-.79-.4-1.06-.17-.27-.39-.46-.64-.58-.25-.13-.54-.19-.86-.19-.32 0-.61.06-.86.18s-.47.31-.64.58c-.17.27-.31.62-.4 1.06s-.13.98-.13 1.62v2.67c0 .64.05 1.18.14 1.62.09.45.23.81.4 1.09s.39.48.64.61.54.19.87.19c.33 0 .62-.06.87-.19s.46-.33.63-.61c.17-.28.3-.64.39-1.09.09-.45.13-.99.13-1.62v-2.66z"></path></g>
<g id="filter"><path d="M15.96 10.29l-2.75 3.54-1.96-2.36L8.5 15h11l-3.54-4.71zM3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14z"></path></g>
<g id="filter-1"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm11 10h2V5h-4v2h2v8zm7-14H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14z"></path></g>
<g id="filter-2"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zm-4-4h-4v-2h2c1.1 0 2-.89 2-2V7c0-1.11-.9-2-2-2h-4v2h4v2h-2c-1.1 0-2 .89-2 2v4h6v-2z"></path></g>
<g id="filter-3"><path d="M21 1H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zM3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm14 8v-1.5c0-.83-.67-1.5-1.5-1.5.83 0 1.5-.67 1.5-1.5V7c0-1.11-.9-2-2-2h-4v2h4v2h-2v2h2v2h-4v2h4c1.1 0 2-.89 2-2z"></path></g>
<g id="filter-4"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm12 10h2V5h-2v4h-2V5h-2v6h4v4zm6-14H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14z"></path></g>
<g id="filter-5"><path d="M21 1H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zM3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm14 8v-2c0-1.11-.9-2-2-2h-2V7h4V5h-6v6h4v2h-4v2h4c1.1 0 2-.89 2-2z"></path></g>
<g id="filter-6"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zm-8-2h2c1.1 0 2-.89 2-2v-2c0-1.11-.9-2-2-2h-2V7h4V5h-4c-1.1 0-2 .89-2 2v6c0 1.11.9 2 2 2zm0-4h2v2h-2v-2z"></path></g>
<g id="filter-7"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zm-8-2l4-8V5h-6v2h4l-4 8h2z"></path></g>
<g id="filter-8"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zm-8-2h2c1.1 0 2-.89 2-2v-1.5c0-.83-.67-1.5-1.5-1.5.83 0 1.5-.67 1.5-1.5V7c0-1.11-.9-2-2-2h-2c-1.1 0-2 .89-2 2v1.5c0 .83.67 1.5 1.5 1.5-.83 0-1.5.67-1.5 1.5V13c0 1.11.9 2 2 2zm0-8h2v2h-2V7zm0 4h2v2h-2v-2z"></path></g>
<g id="filter-9"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zM15 5h-2c-1.1 0-2 .89-2 2v2c0 1.11.9 2 2 2h2v2h-4v2h4c1.1 0 2-.89 2-2V7c0-1.11-.9-2-2-2zm0 4h-2V7h2v2z"></path></g>
<g id="filter-9-plus"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm11 7V8c0-1.11-.9-2-2-2h-1c-1.1 0-2 .89-2 2v1c0 1.11.9 2 2 2h1v1H9v2h3c1.1 0 2-.89 2-2zm-3-3V8h1v1h-1zm10-8H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 8h-2V7h-2v2h-2v2h2v2h2v-2h2v6H7V3h14v6z"></path></g>
<g id="filter-b-and-w"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16l-7-8v8H5l7-8V5h7v14z"></path></g>
<g id="filter-center-focus"><path d="M5 15H3v4c0 1.1.9 2 2 2h4v-2H5v-4zM5 5h4V3H5c-1.1 0-2 .9-2 2v4h2V5zm14-2h-4v2h4v4h2V5c0-1.1-.9-2-2-2zm0 16h-4v2h4c1.1 0 2-.9 2-2v-4h-2v4zM12 9c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3z"></path></g>
<g id="filter-drama"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.61 5.64 5.36 8.04 2.35 8.36 0 10.9 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM19 18H6c-2.21 0-4-1.79-4-4s1.79-4 4-4 4 1.79 4 4h2c0-2.76-1.86-5.08-4.4-5.78C8.61 6.88 10.2 6 12 6c3.03 0 5.5 2.47 5.5 5.5v.5H19c1.65 0 3 1.35 3 3s-1.35 3-3 3z"></path></g>
<g id="filter-frames"><path d="M20 4h-4l-4-4-4 4H4c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 16H4V6h4.52l3.52-3.5L15.52 6H20v14zM18 8H6v10h12"></path></g>
<g id="filter-hdr"><path d="M14 6l-3.75 5 2.85 3.8-1.6 1.2C9.81 13.75 7 10 7 10l-6 8h22L14 6z"></path></g>
<g id="filter-none"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14z"></path></g>
<g id="filter-tilt-shift"><path d="M11 4.07V2.05c-2.01.2-3.84 1-5.32 2.21L7.1 5.69c1.11-.86 2.44-1.44 3.9-1.62zm7.32.19C16.84 3.05 15.01 2.25 13 2.05v2.02c1.46.18 2.79.76 3.9 1.62l1.42-1.43zM19.93 11h2.02c-.2-2.01-1-3.84-2.21-5.32L18.31 7.1c.86 1.11 1.44 2.44 1.62 3.9zM5.69 7.1L4.26 5.68C3.05 7.16 2.25 8.99 2.05 11h2.02c.18-1.46.76-2.79 1.62-3.9zM4.07 13H2.05c.2 2.01 1 3.84 2.21 5.32l1.43-1.43c-.86-1.1-1.44-2.43-1.62-3.89zM15 12c0-1.66-1.34-3-3-3s-3 1.34-3 3 1.34 3 3 3 3-1.34 3-3zm3.31 4.9l1.43 1.43c1.21-1.48 2.01-3.32 2.21-5.32h-2.02c-.18 1.45-.76 2.78-1.62 3.89zM13 19.93v2.02c2.01-.2 3.84-1 5.32-2.21l-1.43-1.43c-1.1.86-2.43 1.44-3.89 1.62zm-7.32-.19C7.16 20.95 9 21.75 11 21.95v-2.02c-1.46-.18-2.79-.76-3.9-1.62l-1.42 1.43z"></path></g>
<g id="filter-vintage"><path d="M18.7 12.4c-.28-.16-.57-.29-.86-.4.29-.11.58-.24.86-.4 1.92-1.11 2.99-3.12 3-5.19-1.79-1.03-4.07-1.11-6 0-.28.16-.54.35-.78.54.05-.31.08-.63.08-.95 0-2.22-1.21-4.15-3-5.19C10.21 1.85 9 3.78 9 6c0 .32.03.64.08.95-.24-.2-.5-.39-.78-.55-1.92-1.11-4.2-1.03-6 0 0 2.07 1.07 4.08 3 5.19.28.16.57.29.86.4-.29.11-.58.24-.86.4-1.92 1.11-2.99 3.12-3 5.19 1.79 1.03 4.07 1.11 6 0 .28-.16.54-.35.78-.54-.05.32-.08.64-.08.96 0 2.22 1.21 4.15 3 5.19 1.79-1.04 3-2.97 3-5.19 0-.32-.03-.64-.08-.95.24.2.5.38.78.54 1.92 1.11 4.2 1.03 6 0-.01-2.07-1.08-4.08-3-5.19zM12 16c-2.21 0-4-1.79-4-4s1.79-4 4-4 4 1.79 4 4-1.79 4-4 4z"></path></g>
<g id="flare"><path d="M7 11H1v2h6v-2zm2.17-3.24L7.05 5.64 5.64 7.05l2.12 2.12 1.41-1.41zM13 1h-2v6h2V1zm5.36 6.05l-1.41-1.41-2.12 2.12 1.41 1.41 2.12-2.12zM17 11v2h6v-2h-6zm-5-2c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3zm2.83 7.24l2.12 2.12 1.41-1.41-2.12-2.12-1.41 1.41zm-9.19.71l1.41 1.41 2.12-2.12-1.41-1.41-2.12 2.12zM11 23h2v-6h-2v6z"></path></g>
<g id="flash-auto"><path d="M3 2v12h3v9l7-12H9l4-9H3zm16 0h-2l-3.2 9h1.9l.7-2h3.2l.7 2h1.9L19 2zm-2.15 5.65L18 4l1.15 3.65h-2.3z"></path></g>
<g id="flash-off"><path d="M3.27 3L2 4.27l5 5V13h3v9l3.58-6.14L17.73 20 19 18.73 3.27 3zM17 10h-4l4-8H7v2.18l8.46 8.46L17 10z"></path></g>
<g id="flash-on"><path d="M7 2v11h3v9l7-12h-4l4-8z"></path></g>
<g id="flip"><path d="M15 21h2v-2h-2v2zm4-12h2V7h-2v2zM3 5v14c0 1.1.9 2 2 2h4v-2H5V5h4V3H5c-1.1 0-2 .9-2 2zm16-2v2h2c0-1.1-.9-2-2-2zm-8 20h2V1h-2v22zm8-6h2v-2h-2v2zM15 5h2V3h-2v2zm4 8h2v-2h-2v2zm0 8c1.1 0 2-.9 2-2h-2v2z"></path></g>
<g id="gradient"><path d="M11 9h2v2h-2zm-2 2h2v2H9zm4 0h2v2h-2zm2-2h2v2h-2zM7 9h2v2H7zm12-6H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 18H7v-2h2v2zm4 0h-2v-2h2v2zm4 0h-2v-2h2v2zm2-7h-2v2h2v2h-2v-2h-2v2h-2v-2h-2v2H9v-2H7v2H5v-2h2v-2H5V5h14v6z"></path></g>
<g id="grain"><path d="M10 12c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zM6 8c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0 8c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm12-8c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm-4 8c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm4-4c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm-4-4c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm-4-4c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"></path></g>
<g id="grid-off"><path d="M8 4v1.45l2 2V4h4v4h-3.45l2 2H14v1.45l2 2V10h4v4h-3.45l2 2H20v1.45l2 2V4c0-1.1-.9-2-2-2H4.55l2 2H8zm8 0h4v4h-4V4zM1.27 1.27L0 2.55l2 2V20c0 1.1.9 2 2 2h15.46l2 2 1.27-1.27L1.27 1.27zM10 12.55L11.45 14H10v-1.45zm-6-6L5.45 8H4V6.55zM8 20H4v-4h4v4zm0-6H4v-4h3.45l.55.55V14zm6 6h-4v-4h3.45l.55.54V20zm2 0v-1.46L17.46 20H16z"></path></g>
<g id="grid-on"><path d="M20 2H4c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM8 20H4v-4h4v4zm0-6H4v-4h4v4zm0-6H4V4h4v4zm6 12h-4v-4h4v4zm0-6h-4v-4h4v4zm0-6h-4V4h4v4zm6 12h-4v-4h4v4zm0-6h-4v-4h4v4zm0-6h-4V4h4v4z"></path></g>
<g id="hdr-off"><path d="M17.5 15v-2h1.1l.9 2H21l-.9-2.1c.5-.2.9-.8.9-1.4v-1c0-.8-.7-1.5-1.5-1.5H16v4.9l1.1 1.1h.4zm0-4.5h2v1h-2v-1zm-4.5 0v.4l1.5 1.5v-1.9c0-.8-.7-1.5-1.5-1.5h-1.9l1.5 1.5h.4zm-3.5-1l-7-7-1.1 1L6.9 9h-.4v2h-2V9H3v6h1.5v-2.5h2V15H8v-4.9l1.5 1.5V15h3.4l7.6 7.6 1.1-1.1-12.1-12z"></path></g>
<g id="hdr-on"><path d="M21 11.5v-1c0-.8-.7-1.5-1.5-1.5H16v6h1.5v-2h1.1l.9 2H21l-.9-2.1c.5-.3.9-.8.9-1.4zm-1.5 0h-2v-1h2v1zm-13-.5h-2V9H3v6h1.5v-2.5h2V15H8V9H6.5v2zM13 9H9.5v6H13c.8 0 1.5-.7 1.5-1.5v-3c0-.8-.7-1.5-1.5-1.5zm0 4.5h-2v-3h2v3z"></path></g>
<g id="hdr-strong"><path d="M17 6c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zM5 8c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm0 6c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2z"></path></g>
<g id="hdr-weak"><path d="M5 8c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm12-2c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm0 10c-2.21 0-4-1.79-4-4s1.79-4 4-4 4 1.79 4 4-1.79 4-4 4z"></path></g>
<g id="healing"><path d="M17.73 12.02l3.98-3.98c.39-.39.39-1.02 0-1.41l-4.34-4.34c-.39-.39-1.02-.39-1.41 0l-3.98 3.98L8 2.29C7.8 2.1 7.55 2 7.29 2c-.25 0-.51.1-.7.29L2.25 6.63c-.39.39-.39 1.02 0 1.41l3.98 3.98L2.25 16c-.39.39-.39 1.02 0 1.41l4.34 4.34c.39.39 1.02.39 1.41 0l3.98-3.98 3.98 3.98c.2.2.45.29.71.29.26 0 .51-.1.71-.29l4.34-4.34c.39-.39.39-1.02 0-1.41l-3.99-3.98zM12 9c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm-4.71 1.96L3.66 7.34l3.63-3.63 3.62 3.62-3.62 3.63zM10 13c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1zm2 2c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1zm2-4c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm2.66 9.34l-3.63-3.62 3.63-3.63 3.62 3.62-3.62 3.63z"></path></g>
<g id="image"><path d="M21 19V5c0-1.1-.9-2-2-2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2zM8.5 13.5l2.5 3.01L14.5 12l4.5 6H5l3.5-4.5z"></path></g>
<g id="image-aspect-ratio"><path d="M16 10h-2v2h2v-2zm0 4h-2v2h2v-2zm-8-4H6v2h2v-2zm4 0h-2v2h2v-2zm8-6H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 14H4V6h16v12z"></path></g>
<g id="iso"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM5.5 7.5h2v-2H9v2h2V9H9v2H7.5V9h-2V7.5zM19 19H5L19 5v14zm-2-2v-1.5h-5V17h5z"></path></g>
<g id="landscape"><path d="M14 6l-3.75 5 2.85 3.8-1.6 1.2C9.81 13.75 7 10 7 10l-6 8h22L14 6z"></path></g>
<g id="leak-add"><path d="M6 3H3v3c1.66 0 3-1.34 3-3zm8 0h-2c0 4.97-4.03 9-9 9v2c6.08 0 11-4.93 11-11zm-4 0H8c0 2.76-2.24 5-5 5v2c3.87 0 7-3.13 7-7zm0 18h2c0-4.97 4.03-9 9-9v-2c-6.07 0-11 4.93-11 11zm8 0h3v-3c-1.66 0-3 1.34-3 3zm-4 0h2c0-2.76 2.24-5 5-5v-2c-3.87 0-7 3.13-7 7z"></path></g>
<g id="leak-remove"><path d="M10 3H8c0 .37-.04.72-.12 1.06l1.59 1.59C9.81 4.84 10 3.94 10 3zM3 4.27l2.84 2.84C5.03 7.67 4.06 8 3 8v2c1.61 0 3.09-.55 4.27-1.46L8.7 9.97C7.14 11.24 5.16 12 3 12v2c2.71 0 5.19-.99 7.11-2.62l2.5 2.5C10.99 15.81 10 18.29 10 21h2c0-2.16.76-4.14 2.03-5.69l1.43 1.43C14.55 17.91 14 19.39 14 21h2c0-1.06.33-2.03.89-2.84L19.73 21 21 19.73 4.27 3 3 4.27zM14 3h-2c0 1.5-.37 2.91-1.02 4.16l1.46 1.46C13.42 6.98 14 5.06 14 3zm5.94 13.12c.34-.08.69-.12 1.06-.12v-2c-.94 0-1.84.19-2.66.52l1.6 1.6zm-4.56-4.56l1.46 1.46C18.09 12.37 19.5 12 21 12v-2c-2.06 0-3.98.58-5.62 1.56z"></path></g>
<g id="lens"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2z"></path></g>
<g id="linked-camera"><circle cx="12" cy="14" r="3.2"></circle><path d="M16 3.33c2.58 0 4.67 2.09 4.67 4.67H22c0-3.31-2.69-6-6-6v1.33M16 6c1.11 0 2 .89 2 2h1.33c0-1.84-1.49-3.33-3.33-3.33V6"></path><path d="M17 9c0-1.11-.89-2-2-2V4H9L7.17 6H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V9h-5zm-5 10c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5z"></path></g>
<g id="looks"><path d="M12 10c-3.86 0-7 3.14-7 7h2c0-2.76 2.24-5 5-5s5 2.24 5 5h2c0-3.86-3.14-7-7-7zm0-4C5.93 6 1 10.93 1 17h2c0-4.96 4.04-9 9-9s9 4.04 9 9h2c0-6.07-4.93-11-11-11z"></path></g>
<g id="looks-3"><path d="M19.01 3h-14c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 7.5c0 .83-.67 1.5-1.5 1.5.83 0 1.5.67 1.5 1.5V15c0 1.11-.9 2-2 2h-4v-2h4v-2h-2v-2h2V9h-4V7h4c1.1 0 2 .89 2 2v1.5z"></path></g>
<g id="looks-4"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 14h-2v-4H9V7h2v4h2V7h2v10z"></path></g>
<g id="looks-5"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 6h-4v2h2c1.1 0 2 .89 2 2v2c0 1.11-.9 2-2 2H9v-2h4v-2H9V7h6v2z"></path></g>
<g id="looks-6"><path d="M11 15h2v-2h-2v2zm8-12H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 6h-4v2h2c1.1 0 2 .89 2 2v2c0 1.11-.9 2-2 2h-2c-1.1 0-2-.89-2-2V9c0-1.11.9-2 2-2h4v2z"></path></g>
<g id="looks-one"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-5 14h-2V9h-2V7h4v10z"></path></g>
<g id="looks-two"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 8c0 1.11-.9 2-2 2h-2v2h4v2H9v-4c0-1.11.9-2 2-2h2V9H9V7h4c1.1 0 2 .89 2 2v2z"></path></g>
<g id="loupe"><path d="M13 7h-2v4H7v2h4v4h2v-4h4v-2h-4V7zm-1-5C6.49 2 2 6.49 2 12s4.49 10 10 10h8c1.1 0 2-.9 2-2v-8c0-5.51-4.49-10-10-10zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="monochrome-photos"><path d="M20 5h-3.2L15 3H9L7.2 5H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 14h-8v-1c-2.8 0-5-2.2-5-5s2.2-5 5-5V7h8v12zm-3-6c0-2.8-2.2-5-5-5v1.8c1.8 0 3.2 1.4 3.2 3.2s-1.4 3.2-3.2 3.2V18c2.8 0 5-2.2 5-5zm-8.2 0c0 1.8 1.4 3.2 3.2 3.2V9.8c-1.8 0-3.2 1.4-3.2 3.2z"></path></g>
<g id="movie-creation"><path d="M18 4l2 4h-3l-2-4h-2l2 4h-3l-2-4H8l2 4H7L5 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4h-4z"></path></g>
<g id="movie-filter"><path d="M18 4l2 3h-3l-2-3h-2l2 3h-3l-2-3H8l2 3H7L5 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4h-4zm-6.75 11.25L10 18l-1.25-2.75L6 14l2.75-1.25L10 10l1.25 2.75L14 14l-2.75 1.25zm5.69-3.31L16 14l-.94-2.06L13 11l2.06-.94L16 8l.94 2.06L19 11l-2.06.94z"></path></g>
<g id="music-note"><path d="M12 3v10.55c-.59-.34-1.27-.55-2-.55-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4V7h4V3h-6z"></path></g>
<g id="nature"><path d="M13 16.12c3.47-.41 6.17-3.36 6.17-6.95 0-3.87-3.13-7-7-7s-7 3.13-7 7c0 3.47 2.52 6.34 5.83 6.89V20H5v2h14v-2h-6v-3.88z"></path></g>
<g id="nature-people"><path d="M22.17 9.17c0-3.87-3.13-7-7-7s-7 3.13-7 7c0 3.47 2.52 6.34 5.83 6.89V20H6v-3h1v-4c0-.55-.45-1-1-1H3c-.55 0-1 .45-1 1v4h1v5h16v-2h-3v-3.88c3.47-.41 6.17-3.36 6.17-6.95zM4.5 11c.83 0 1.5-.67 1.5-1.5S5.33 8 4.5 8 3 8.67 3 9.5 3.67 11 4.5 11z"></path></g>
<g id="navigate-before"><path d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"></path></g>
<g id="navigate-next"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"></path></g>
<g id="palette"><path d="M12 3c-4.97 0-9 4.03-9 9s4.03 9 9 9c.83 0 1.5-.67 1.5-1.5 0-.39-.15-.74-.39-1.01-.23-.26-.38-.61-.38-.99 0-.83.67-1.5 1.5-1.5H16c2.76 0 5-2.24 5-5 0-4.42-4.03-8-9-8zm-5.5 9c-.83 0-1.5-.67-1.5-1.5S5.67 9 6.5 9 8 9.67 8 10.5 7.33 12 6.5 12zm3-4C8.67 8 8 7.33 8 6.5S8.67 5 9.5 5s1.5.67 1.5 1.5S10.33 8 9.5 8zm5 0c-.83 0-1.5-.67-1.5-1.5S13.67 5 14.5 5s1.5.67 1.5 1.5S15.33 8 14.5 8zm3 4c-.83 0-1.5-.67-1.5-1.5S16.67 9 17.5 9s1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"></path></g>
<g id="panorama"><path d="M23 18V6c0-1.1-.9-2-2-2H3c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2zM8.5 12.5l2.5 3.01L14.5 11l4.5 6H5l3.5-4.5z"></path></g>
<g id="panorama-fish-eye"><path d="M12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="panorama-horizontal"><path d="M20 6.54v10.91c-2.6-.77-5.28-1.16-8-1.16-2.72 0-5.4.39-8 1.16V6.54c2.6.77 5.28 1.16 8 1.16 2.72.01 5.4-.38 8-1.16M21.43 4c-.1 0-.2.02-.31.06C18.18 5.16 15.09 5.7 12 5.7c-3.09 0-6.18-.55-9.12-1.64-.11-.04-.22-.06-.31-.06-.34 0-.57.23-.57.63v14.75c0 .39.23.62.57.62.1 0 .2-.02.31-.06 2.94-1.1 6.03-1.64 9.12-1.64 3.09 0 6.18.55 9.12 1.64.11.04.21.06.31.06.33 0 .57-.23.57-.63V4.63c0-.4-.24-.63-.57-.63z"></path></g>
<g id="panorama-vertical"><path d="M19.94 21.12c-1.1-2.94-1.64-6.03-1.64-9.12 0-3.09.55-6.18 1.64-9.12.04-.11.06-.22.06-.31 0-.34-.23-.57-.63-.57H4.63c-.4 0-.63.23-.63.57 0 .1.02.2.06.31C5.16 5.82 5.71 8.91 5.71 12c0 3.09-.55 6.18-1.64 9.12-.05.11-.07.22-.07.31 0 .33.23.57.63.57h14.75c.39 0 .63-.24.63-.57-.01-.1-.03-.2-.07-.31zM6.54 20c.77-2.6 1.16-5.28 1.16-8 0-2.72-.39-5.4-1.16-8h10.91c-.77 2.6-1.16 5.28-1.16 8 0 2.72.39 5.4 1.16 8H6.54z"></path></g>
<g id="panorama-wide-angle"><path d="M12 6c2.45 0 4.71.2 7.29.64.47 1.78.71 3.58.71 5.36 0 1.78-.24 3.58-.71 5.36-2.58.44-4.84.64-7.29.64s-4.71-.2-7.29-.64C4.24 15.58 4 13.78 4 12c0-1.78.24-3.58.71-5.36C7.29 6.2 9.55 6 12 6m0-2c-2.73 0-5.22.24-7.95.72l-.93.16-.25.9C2.29 7.85 2 9.93 2 12s.29 4.15.87 6.22l.25.89.93.16c2.73.49 5.22.73 7.95.73s5.22-.24 7.95-.72l.93-.16.25-.89c.58-2.08.87-4.16.87-6.23s-.29-4.15-.87-6.22l-.25-.89-.93-.16C17.22 4.24 14.73 4 12 4z"></path></g>
<g id="photo"><path d="M21 19V5c0-1.1-.9-2-2-2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2zM8.5 13.5l2.5 3.01L14.5 12l4.5 6H5l3.5-4.5z"></path></g>
<g id="photo-album"><path d="M18 2H6c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM6 4h5v8l-2.5-1.5L6 12V4zm0 15l3-3.86 2.14 2.58 3-3.86L18 19H6z"></path></g>
<g id="photo-camera"><circle cx="12" cy="12" r="3.2"></circle><path d="M9 2L7.17 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2h-3.17L15 2H9zm3 15c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5z"></path></g>
<g id="photo-filter"><path d="M19.02 10v9H5V5h9V3H5.02c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2v-9h-2zM17 10l.94-2.06L20 7l-2.06-.94L17 4l-.94 2.06L14 7l2.06.94zm-3.75.75L12 8l-1.25 2.75L8 12l2.75 1.25L12 16l1.25-2.75L16 12z"></path></g>
<g id="photo-library"><path d="M22 16V4c0-1.1-.9-2-2-2H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2zm-11-4l2.03 2.71L16 11l4 5H8l3-4zM2 6v14c0 1.1.9 2 2 2h14v-2H4V6H2z"></path></g>
<g id="photo-size-select-actual"><path d="M21 3H3C2 3 1 4 1 5v14c0 1.1.9 2 2 2h18c1 0 2-1 2-2V5c0-1-1-2-2-2zM5 17l3.5-4.5 2.5 3.01L14.5 11l4.5 6H5z"></path></g>
<g id="photo-size-select-large"><path d="M21 15h2v2h-2v-2zm0-4h2v2h-2v-2zm2 8h-2v2c1 0 2-1 2-2zM13 3h2v2h-2V3zm8 4h2v2h-2V7zm0-4v2h2c0-1-1-2-2-2zM1 7h2v2H1V7zm16-4h2v2h-2V3zm0 16h2v2h-2v-2zM3 3C2 3 1 4 1 5h2V3zm6 0h2v2H9V3zM5 3h2v2H5V3zm-4 8v8c0 1.1.9 2 2 2h12V11H1zm2 8l2.5-3.21 1.79 2.15 2.5-3.22L13 19H3z"></path></g>
<g id="photo-size-select-small"><path d="M23 15h-2v2h2v-2zm0-4h-2v2h2v-2zm0 8h-2v2c1 0 2-1 2-2zM15 3h-2v2h2V3zm8 4h-2v2h2V7zm-2-4v2h2c0-1-1-2-2-2zM3 21h8v-6H1v4c0 1.1.9 2 2 2zM3 7H1v2h2V7zm12 12h-2v2h2v-2zm4-16h-2v2h2V3zm0 16h-2v2h2v-2zM3 3C2 3 1 4 1 5h2V3zm0 8H1v2h2v-2zm8-8H9v2h2V3zM7 3H5v2h2V3z"></path></g>
<g id="picture-as-pdf"><path d="M20 2H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-8.5 7.5c0 .83-.67 1.5-1.5 1.5H9v2H7.5V7H10c.83 0 1.5.67 1.5 1.5v1zm5 2c0 .83-.67 1.5-1.5 1.5h-2.5V7H15c.83 0 1.5.67 1.5 1.5v3zm4-3H19v1h1.5V11H19v2h-1.5V7h3v1.5zM9 9.5h1v-1H9v1zM4 6H2v14c0 1.1.9 2 2 2h14v-2H4V6zm10 5.5h1v-3h-1v3z"></path></g>
<g id="portrait"><path d="M12 12.25c1.24 0 2.25-1.01 2.25-2.25S13.24 7.75 12 7.75 9.75 8.76 9.75 10s1.01 2.25 2.25 2.25zm4.5 4c0-1.5-3-2.25-4.5-2.25s-4.5.75-4.5 2.25V17h9v-.75zM19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V5h14v14z"></path></g>
<g id="remove-red-eye"><path d="M12 4.5C7 4.5 2.73 7.61 1 12c1.73 4.39 6 7.5 11 7.5s9.27-3.11 11-7.5c-1.73-4.39-6-7.5-11-7.5zM12 17c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5zm0-8c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3z"></path></g>
<g id="rotate-90-degrees-ccw"><path d="M7.34 6.41L.86 12.9l6.49 6.48 6.49-6.48-6.5-6.49zM3.69 12.9l3.66-3.66L11 12.9l-3.66 3.66-3.65-3.66zm15.67-6.26C17.61 4.88 15.3 4 13 4V.76L8.76 5 13 9.24V6c1.79 0 3.58.68 4.95 2.05 2.73 2.73 2.73 7.17 0 9.9C16.58 19.32 14.79 20 13 20c-.97 0-1.94-.21-2.84-.61l-1.49 1.49C10.02 21.62 11.51 22 13 22c2.3 0 4.61-.88 6.36-2.64 3.52-3.51 3.52-9.21 0-12.72z"></path></g>
<g id="rotate-left"><path d="M7.11 8.53L5.7 7.11C4.8 8.27 4.24 9.61 4.07 11h2.02c.14-.87.49-1.72 1.02-2.47zM6.09 13H4.07c.17 1.39.72 2.73 1.62 3.89l1.41-1.42c-.52-.75-.87-1.59-1.01-2.47zm1.01 5.32c1.16.9 2.51 1.44 3.9 1.61V17.9c-.87-.15-1.71-.49-2.46-1.03L7.1 18.32zM13 4.07V1L8.45 5.55 13 10V6.09c2.84.48 5 2.94 5 5.91s-2.16 5.43-5 5.91v2.02c3.95-.49 7-3.85 7-7.93s-3.05-7.44-7-7.93z"></path></g>
<g id="rotate-right"><path d="M15.55 5.55L11 1v3.07C7.06 4.56 4 7.92 4 12s3.05 7.44 7 7.93v-2.02c-2.84-.48-5-2.94-5-5.91s2.16-5.43 5-5.91V10l4.55-4.45zM19.93 11c-.17-1.39-.72-2.73-1.62-3.89l-1.42 1.42c.54.75.88 1.6 1.02 2.47h2.02zM13 17.9v2.02c1.39-.17 2.74-.71 3.9-1.61l-1.44-1.44c-.75.54-1.59.89-2.46 1.03zm3.89-2.42l1.42 1.41c.9-1.16 1.45-2.5 1.62-3.89h-2.02c-.14.87-.48 1.72-1.02 2.48z"></path></g>
<g id="slideshow"><path d="M10 8v8l5-4-5-4zm9-5H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V5h14v14z"></path></g>
<g id="straighten"><path d="M21 6H3c-1.1 0-2 .9-2 2v8c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2zm0 10H3V8h2v4h2V8h2v4h2V8h2v4h2V8h2v4h2V8h2v8z"></path></g>
<g id="style"><path d="M2.53 19.65l1.34.56v-9.03l-2.43 5.86c-.41 1.02.08 2.19 1.09 2.61zm19.5-3.7L17.07 3.98c-.31-.75-1.04-1.21-1.81-1.23-.26 0-.53.04-.79.15L7.1 5.95c-.75.31-1.21 1.03-1.23 1.8-.01.27.04.54.15.8l4.96 11.97c.31.76 1.05 1.22 1.83 1.23.26 0 .52-.05.77-.15l7.36-3.05c1.02-.42 1.51-1.59 1.09-2.6zM7.88 8.75c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1zm-2 11c0 1.1.9 2 2 2h1.45l-3.45-8.34v6.34z"></path></g>
<g id="switch-camera"><path d="M20 4h-3.17L15 2H9L7.17 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm-5 11.5V13H9v2.5L5.5 12 9 8.5V11h6V8.5l3.5 3.5-3.5 3.5z"></path></g>
<g id="switch-video"><path d="M18 9.5V6c0-.55-.45-1-1-1H3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h14c.55 0 1-.45 1-1v-3.5l4 4v-13l-4 4zm-5 6V13H7v2.5L3.5 12 7 8.5V11h6V8.5l3.5 3.5-3.5 3.5z"></path></g>
<g id="tag-faces"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm3.5-9c.83 0 1.5-.67 1.5-1.5S16.33 8 15.5 8 14 8.67 14 9.5s.67 1.5 1.5 1.5zm-7 0c.83 0 1.5-.67 1.5-1.5S9.33 8 8.5 8 7 8.67 7 9.5 7.67 11 8.5 11zm3.5 6.5c2.33 0 4.31-1.46 5.11-3.5H6.89c.8 2.04 2.78 3.5 5.11 3.5z"></path></g>
<g id="texture"><path d="M19.51 3.08L3.08 19.51c.09.34.27.65.51.9.25.24.56.42.9.51L20.93 4.49c-.19-.69-.73-1.23-1.42-1.41zM11.88 3L3 11.88v2.83L14.71 3h-2.83zM5 3c-1.1 0-2 .9-2 2v2l4-4H5zm14 18c.55 0 1.05-.22 1.41-.59.37-.36.59-.86.59-1.41v-2l-4 4h2zm-9.71 0h2.83L21 12.12V9.29L9.29 21z"></path></g>
<g id="timelapse"><path d="M16.24 7.76C15.07 6.59 13.54 6 12 6v6l-4.24 4.24c2.34 2.34 6.14 2.34 8.49 0 2.34-2.34 2.34-6.14-.01-8.48zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"></path></g>
<g id="timer"><path d="M15 1H9v2h6V1zm-4 13h2V8h-2v6zm8.03-6.61l1.42-1.42c-.43-.51-.9-.99-1.41-1.41l-1.42 1.42C16.07 4.74 14.12 4 12 4c-4.97 0-9 4.03-9 9s4.02 9 9 9 9-4.03 9-9c0-2.12-.74-4.07-1.97-5.61zM12 20c-3.87 0-7-3.13-7-7s3.13-7 7-7 7 3.13 7 7-3.13 7-7 7z"></path></g>
<g id="timer-10"><path d="M0 7.72V9.4l3-1V18h2V6h-.25L0 7.72zm23.78 6.65c-.14-.28-.35-.53-.63-.74-.28-.21-.61-.39-1.01-.53s-.85-.27-1.35-.38c-.35-.07-.64-.15-.87-.23-.23-.08-.41-.16-.55-.25-.14-.09-.23-.19-.28-.3-.05-.11-.08-.24-.08-.39 0-.14.03-.28.09-.41.06-.13.15-.25.27-.34.12-.1.27-.18.45-.24s.4-.09.64-.09c.25 0 .47.04.66.11.19.07.35.17.48.29.13.12.22.26.29.42.06.16.1.32.1.49h1.95c0-.39-.08-.75-.24-1.09-.16-.34-.39-.63-.69-.88-.3-.25-.66-.44-1.09-.59C21.49 9.07 21 9 20.46 9c-.51 0-.98.07-1.39.21-.41.14-.77.33-1.06.57-.29.24-.51.52-.67.84-.16.32-.23.65-.23 1.01s.08.69.23.96c.15.28.36.52.64.73.27.21.6.38.98.53.38.14.81.26 1.27.36.39.08.71.17.95.26s.43.19.57.29c.13.1.22.22.27.34.05.12.07.25.07.39 0 .32-.13.57-.4.77-.27.2-.66.29-1.17.29-.22 0-.43-.02-.64-.08-.21-.05-.4-.13-.56-.24-.17-.11-.3-.26-.41-.44-.11-.18-.17-.41-.18-.67h-1.89c0 .36.08.71.24 1.05.16.34.39.65.7.93.31.27.69.49 1.15.66.46.17.98.25 1.58.25.53 0 1.01-.06 1.44-.19.43-.13.8-.31 1.11-.54.31-.23.54-.51.71-.83.17-.32.25-.67.25-1.06-.02-.4-.09-.74-.24-1.02zm-9.96-7.32c-.34-.4-.75-.7-1.23-.88-.47-.18-1.01-.27-1.59-.27-.58 0-1.11.09-1.59.27-.48.18-.89.47-1.23.88-.34.41-.6.93-.79 1.59-.18.65-.28 1.45-.28 2.39v1.92c0 .94.09 1.74.28 2.39.19.66.45 1.19.8 1.6.34.41.75.71 1.23.89.48.18 1.01.28 1.59.28.59 0 1.12-.09 1.59-.28.48-.18.88-.48 1.22-.89.34-.41.6-.94.78-1.6.18-.65.28-1.45.28-2.39v-1.92c0-.94-.09-1.74-.28-2.39-.18-.66-.44-1.19-.78-1.59zm-.92 6.17c0 .6-.04 1.11-.12 1.53-.08.42-.2.76-.36 1.02-.16.26-.36.45-.59.57-.23.12-.51.18-.82.18-.3 0-.58-.06-.82-.18s-.44-.31-.6-.57c-.16-.26-.29-.6-.38-1.02-.09-.42-.13-.93-.13-1.53v-2.5c0-.6.04-1.11.13-1.52.09-.41.21-.74.38-1 .16-.25.36-.43.6-.55.24-.11.51-.17.81-.17.31 0 .58.06.81.17.24.11.44.29.6.55.16.25.29.58.37.99.08.41.13.92.13 1.52v2.51z"></path></g>
<g id="timer-3"><path d="M11.61 12.97c-.16-.24-.36-.46-.62-.65-.25-.19-.56-.35-.93-.48.3-.14.57-.3.8-.5.23-.2.42-.41.57-.64.15-.23.27-.46.34-.71.08-.24.11-.49.11-.73 0-.55-.09-1.04-.28-1.46-.18-.42-.44-.77-.78-1.06-.33-.28-.73-.5-1.2-.64-.45-.13-.97-.2-1.53-.2-.55 0-1.06.08-1.52.24-.47.17-.87.4-1.2.69-.33.29-.6.63-.78 1.03-.2.39-.29.83-.29 1.29h1.98c0-.26.05-.49.14-.69.09-.2.22-.38.38-.52.17-.14.36-.25.58-.33.22-.08.46-.12.73-.12.61 0 1.06.16 1.36.47.3.31.44.75.44 1.32 0 .27-.04.52-.12.74-.08.22-.21.41-.38.57-.17.16-.38.28-.63.37-.25.09-.55.13-.89.13H6.72v1.57H7.9c.34 0 .64.04.91.11.27.08.5.19.69.35.19.16.34.36.44.61.1.24.16.54.16.87 0 .62-.18 1.09-.53 1.42-.35.33-.84.49-1.45.49-.29 0-.56-.04-.8-.13-.24-.08-.44-.2-.61-.36-.17-.16-.3-.34-.39-.56-.09-.22-.14-.46-.14-.72H4.19c0 .55.11 1.03.32 1.45.21.42.5.77.86 1.05s.77.49 1.24.63.96.21 1.48.21c.57 0 1.09-.08 1.58-.23.49-.15.91-.38 1.26-.68.36-.3.64-.66.84-1.1.2-.43.3-.93.3-1.48 0-.29-.04-.58-.11-.86-.08-.25-.19-.51-.35-.76zm9.26 1.4c-.14-.28-.35-.53-.63-.74-.28-.21-.61-.39-1.01-.53s-.85-.27-1.35-.38c-.35-.07-.64-.15-.87-.23-.23-.08-.41-.16-.55-.25-.14-.09-.23-.19-.28-.3-.05-.11-.08-.24-.08-.39s.03-.28.09-.41c.06-.13.15-.25.27-.34.12-.1.27-.18.45-.24s.4-.09.64-.09c.25 0 .47.04.66.11.19.07.35.17.48.29.13.12.22.26.29.42.06.16.1.32.1.49h1.95c0-.39-.08-.75-.24-1.09-.16-.34-.39-.63-.69-.88-.3-.25-.66-.44-1.09-.59-.43-.15-.92-.22-1.46-.22-.51 0-.98.07-1.39.21-.41.14-.77.33-1.06.57-.29.24-.51.52-.67.84-.16.32-.23.65-.23 1.01s.08.68.23.96c.15.28.37.52.64.73.27.21.6.38.98.53.38.14.81.26 1.27.36.39.08.71.17.95.26s.43.19.57.29c.13.1.22.22.27.34.05.12.07.25.07.39 0 .32-.13.57-.4.77-.27.2-.66.29-1.17.29-.22 0-.43-.02-.64-.08-.21-.05-.4-.13-.56-.24-.17-.11-.3-.26-.41-.44-.11-.18-.17-.41-.18-.67h-1.89c0 .36.08.71.24 1.05.16.34.39.65.7.93.31.27.69.49 1.15.66.46.17.98.25 1.58.25.53 0 1.01-.06 1.44-.19.43-.13.8-.31 1.11-.54.31-.23.54-.51.71-.83.17-.32.25-.67.25-1.06-.02-.4-.09-.74-.24-1.02z"></path></g>
<g id="timer-off"><path d="M19.04 4.55l-1.42 1.42C16.07 4.74 14.12 4 12 4c-1.83 0-3.53.55-4.95 1.48l1.46 1.46C9.53 6.35 10.73 6 12 6c3.87 0 7 3.13 7 7 0 1.27-.35 2.47-.94 3.49l1.45 1.45C20.45 16.53 21 14.83 21 13c0-2.12-.74-4.07-1.97-5.61l1.42-1.42-1.41-1.42zM15 1H9v2h6V1zm-4 8.44l2 2V8h-2v1.44zM3.02 4L1.75 5.27 4.5 8.03C3.55 9.45 3 11.16 3 13c0 4.97 4.02 9 9 9 1.84 0 3.55-.55 4.98-1.5l2.5 2.5 1.27-1.27-7.71-7.71L3.02 4zM12 20c-3.87 0-7-3.13-7-7 0-1.28.35-2.48.95-3.52l9.56 9.56c-1.03.61-2.23.96-3.51.96z"></path></g>
<g id="tonality"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm-1 17.93c-3.94-.49-7-3.85-7-7.93s3.05-7.44 7-7.93v15.86zm2-15.86c1.03.13 2 .45 2.87.93H13v-.93zM13 7h5.24c.25.31.48.65.68 1H13V7zm0 3h6.74c.08.33.15.66.19 1H13v-1zm0 9.93V19h2.87c-.87.48-1.84.8-2.87.93zM18.24 17H13v-1h5.92c-.2.35-.43.69-.68 1zm1.5-3H13v-1h6.93c-.04.34-.11.67-.19 1z"></path></g>
<g id="transform"><path d="M22 18v-2H8V4h2L7 1 4 4h2v2H2v2h4v8c0 1.1.9 2 2 2h8v2h-2l3 3 3-3h-2v-2h4zM10 8h6v6h2V8c0-1.1-.9-2-2-2h-6v2z"></path></g>
<g id="tune"><path d="M3 17v2h6v-2H3zM3 5v2h10V5H3zm10 16v-2h8v-2h-8v-2h-2v6h2zM7 9v2H3v2h4v2h2V9H7zm14 4v-2H11v2h10zm-6-4h2V7h4V5h-4V3h-2v6z"></path></g>
<g id="view-comfy"><path d="M3 9h4V5H3v4zm0 5h4v-4H3v4zm5 0h4v-4H8v4zm5 0h4v-4h-4v4zM8 9h4V5H8v4zm5-4v4h4V5h-4zm5 9h4v-4h-4v4zM3 19h4v-4H3v4zm5 0h4v-4H8v4zm5 0h4v-4h-4v4zm5 0h4v-4h-4v4zm0-14v4h4V5h-4z"></path></g>
<g id="view-compact"><path d="M3 19h6v-7H3v7zm7 0h12v-7H10v7zM3 5v6h19V5H3z"></path></g>
<g id="vignette"><path d="M21 3H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-9 15c-4.42 0-8-2.69-8-6s3.58-6 8-6 8 2.69 8 6-3.58 6-8 6z"></path></g>
<g id="wb-auto"><path d="M6.85 12.65h2.3L8 9l-1.15 3.65zM22 7l-1.2 6.29L19.3 7h-1.6l-1.49 6.29L15 7h-.76C12.77 5.17 10.53 4 8 4c-4.42 0-8 3.58-8 8s3.58 8 8 8c3.13 0 5.84-1.81 7.15-4.43l.1.43H17l1.5-6.1L20 16h1.75l2.05-9H22zm-11.7 9l-.7-2H6.4l-.7 2H3.8L7 7h2l3.2 9h-1.9z"></path></g>
<g id="wb-cloudy"><path d="M19.36 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.64-4.96z"></path></g>
<g id="wb-incandescent"><path d="M3.55 18.54l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8zM11 22.45h2V19.5h-2v2.95zM4 10.5H1v2h3v-2zm11-4.19V1.5H9v4.81C7.21 7.35 6 9.28 6 11.5c0 3.31 2.69 6 6 6s6-2.69 6-6c0-2.22-1.21-4.15-3-5.19zm5 4.19v2h3v-2h-3zm-2.76 7.66l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4z"></path></g>
<g id="wb-iridescent"><path d="M5 14.5h14v-6H5v6zM11 .55V3.5h2V.55h-2zm8.04 2.5l-1.79 1.79 1.41 1.41 1.8-1.79-1.42-1.41zM13 22.45V19.5h-2v2.95h2zm7.45-3.91l-1.8-1.79-1.41 1.41 1.79 1.8 1.42-1.42zM3.55 4.46l1.79 1.79 1.41-1.41-1.79-1.79-1.41 1.41zm1.41 15.49l1.79-1.8-1.41-1.41-1.79 1.79 1.41 1.42z"></path></g>
<g id="wb-sunny"><path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"></path></g>
</defs></svg>
</iron-iconset-svg>`;document.head.appendChild(pbe.content);var dbe=Q`<iron-iconset-svg name="icons" size="24">
<svg><defs>
<g id="3d-rotation"><path d="M7.52 21.48C4.25 19.94 1.91 16.76 1.55 13H.05C.56 19.16 5.71 24 12 24l.66-.03-3.81-3.81-1.33 1.32zm.89-6.52c-.19 0-.37-.03-.52-.08-.16-.06-.29-.13-.4-.24-.11-.1-.2-.22-.26-.37-.06-.14-.09-.3-.09-.47h-1.3c0 .36.07.68.21.95.14.27.33.5.56.69.24.18.51.32.82.41.3.1.62.15.96.15.37 0 .72-.05 1.03-.15.32-.1.6-.25.83-.44s.42-.43.55-.72c.13-.29.2-.61.2-.97 0-.19-.02-.38-.07-.56-.05-.18-.12-.35-.23-.51-.1-.16-.24-.3-.4-.43-.17-.13-.37-.23-.61-.31.2-.09.37-.2.52-.33.15-.13.27-.27.37-.42.1-.15.17-.3.22-.46.05-.16.07-.32.07-.48 0-.36-.06-.68-.18-.96-.12-.28-.29-.51-.51-.69-.2-.19-.47-.33-.77-.43C9.1 8.05 8.76 8 8.39 8c-.36 0-.69.05-1 .16-.3.11-.57.26-.79.45-.21.19-.38.41-.51.67-.12.26-.18.54-.18.85h1.3c0-.17.03-.32.09-.45s.14-.25.25-.34c.11-.09.23-.17.38-.22.15-.05.3-.08.48-.08.4 0 .7.1.89.31.19.2.29.49.29.86 0 .18-.03.34-.08.49-.05.15-.14.27-.25.37-.11.1-.25.18-.41.24-.16.06-.36.09-.58.09H7.5v1.03h.77c.22 0 .42.02.6.07s.33.13.45.23c.12.11.22.24.29.4.07.16.1.35.1.57 0 .41-.12.72-.35.93-.23.23-.55.33-.95.33zm8.55-5.92c-.32-.33-.7-.59-1.14-.77-.43-.18-.92-.27-1.46-.27H12v8h2.3c.55 0 1.06-.09 1.51-.27.45-.18.84-.43 1.16-.76.32-.33.57-.73.74-1.19.17-.47.26-.99.26-1.57v-.4c0-.58-.09-1.1-.26-1.57-.18-.47-.43-.87-.75-1.2zm-.39 3.16c0 .42-.05.79-.14 1.13-.1.33-.24.62-.43.85-.19.23-.43.41-.71.53-.29.12-.62.18-.99.18h-.91V9.12h.97c.72 0 1.27.23 1.64.69.38.46.57 1.12.57 1.99v.4zM12 0l-.66.03 3.81 3.81 1.33-1.33c3.27 1.55 5.61 4.72 5.96 8.48h1.5C23.44 4.84 18.29 0 12 0z"></path></g>
<g id="accessibility"><path d="M12 2c1.1 0 2 .9 2 2s-.9 2-2 2-2-.9-2-2 .9-2 2-2zm9 7h-6v13h-2v-6h-2v6H9V9H3V7h18v2z"></path></g>
<g id="accessible"><circle cx="12" cy="4" r="2"></circle><path d="M19 13v-2c-1.54.02-3.09-.75-4.07-1.83l-1.29-1.43c-.17-.19-.38-.34-.61-.45-.01 0-.01-.01-.02-.01H13c-.35-.2-.75-.3-1.19-.26C10.76 7.11 10 8.04 10 9.09V15c0 1.1.9 2 2 2h5v5h2v-5.5c0-1.1-.9-2-2-2h-3v-3.45c1.29 1.07 3.25 1.94 5 1.95zm-6.17 5c-.41 1.16-1.52 2-2.83 2-1.66 0-3-1.34-3-3 0-1.31.84-2.41 2-2.83V12.1c-2.28.46-4 2.48-4 4.9 0 2.76 2.24 5 5 5 2.42 0 4.44-1.72 4.9-4h-2.07z"></path></g>
<g id="account-balance"><path d="M4 10v7h3v-7H4zm6 0v7h3v-7h-3zM2 22h19v-3H2v3zm14-12v7h3v-7h-3zm-4.5-9L2 6v2h19V6l-9.5-5z"></path></g>
<g id="account-balance-wallet"><path d="M21 18v1c0 1.1-.9 2-2 2H5c-1.11 0-2-.9-2-2V5c0-1.1.89-2 2-2h14c1.1 0 2 .9 2 2v1h-9c-1.11 0-2 .9-2 2v8c0 1.1.89 2 2 2h9zm-9-2h10V8H12v8zm4-2.5c-.83 0-1.5-.67-1.5-1.5s.67-1.5 1.5-1.5 1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"></path></g>
<g id="account-box"><path d="M3 5v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2H5c-1.11 0-2 .9-2 2zm12 4c0 1.66-1.34 3-3 3s-3-1.34-3-3 1.34-3 3-3 3 1.34 3 3zm-9 8c0-2 4-3.1 6-3.1s6 1.1 6 3.1v1H6v-1z"></path></g>
<g id="account-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 3c1.66 0 3 1.34 3 3s-1.34 3-3 3-3-1.34-3-3 1.34-3 3-3zm0 14.2c-2.5 0-4.71-1.28-6-3.22.03-1.99 4-3.08 6-3.08 1.99 0 5.97 1.09 6 3.08-1.29 1.94-3.5 3.22-6 3.22z"></path></g>
<g id="add"><path d="M19 13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z"></path></g>
<g id="add-alert"><path d="M10.01 21.01c0 1.1.89 1.99 1.99 1.99s1.99-.89 1.99-1.99h-3.98zm8.87-4.19V11c0-3.25-2.25-5.97-5.29-6.69v-.72C13.59 2.71 12.88 2 12 2s-1.59.71-1.59 1.59v.72C7.37 5.03 5.12 7.75 5.12 11v5.82L3 18.94V20h18v-1.06l-2.12-2.12zM16 13.01h-3v3h-2v-3H8V11h3V8h2v3h3v2.01z"></path></g>
<g id="add-box"><path d="M19 3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-2 10h-4v4h-2v-4H7v-2h4V7h2v4h4v2z"></path></g>
<g id="add-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm5 11h-4v4h-2v-4H7v-2h4V7h2v4h4v2z"></path></g>
<g id="add-circle-outline"><path d="M13 7h-2v4H7v2h4v4h2v-4h4v-2h-4V7zm-1-5C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="add-shopping-cart"><path d="M11 9h2V6h3V4h-3V1h-2v3H8v2h3v3zm-4 9c-1.1 0-1.99.9-1.99 2S5.9 22 7 22s2-.9 2-2-.9-2-2-2zm10 0c-1.1 0-1.99.9-1.99 2s.89 2 1.99 2 2-.9 2-2-.9-2-2-2zm-9.83-3.25l.03-.12.9-1.63h7.45c.75 0 1.41-.41 1.75-1.03l3.86-7.01L19.42 4h-.01l-1.1 2-2.76 5H8.53l-.13-.27L6.16 6l-.95-2-.94-2H1v2h2l3.6 7.59-1.35 2.45c-.16.28-.25.61-.25.96 0 1.1.9 2 2 2h12v-2H7.42c-.13 0-.25-.11-.25-.25z"></path></g>
<g id="alarm"><path d="M22 5.72l-4.6-3.86-1.29 1.53 4.6 3.86L22 5.72zM7.88 3.39L6.6 1.86 2 5.71l1.29 1.53 4.59-3.85zM12.5 8H11v6l4.75 2.85.75-1.23-4-2.37V8zM12 4c-4.97 0-9 4.03-9 9s4.02 9 9 9c4.97 0 9-4.03 9-9s-4.03-9-9-9zm0 16c-3.87 0-7-3.13-7-7s3.13-7 7-7 7 3.13 7 7-3.13 7-7 7z"></path></g>
<g id="alarm-add"><path d="M7.88 3.39L6.6 1.86 2 5.71l1.29 1.53 4.59-3.85zM22 5.72l-4.6-3.86-1.29 1.53 4.6 3.86L22 5.72zM12 4c-4.97 0-9 4.03-9 9s4.02 9 9 9c4.97 0 9-4.03 9-9s-4.03-9-9-9zm0 16c-3.87 0-7-3.13-7-7s3.13-7 7-7 7 3.13 7 7-3.13 7-7 7zm1-11h-2v3H8v2h3v3h2v-3h3v-2h-3V9z"></path></g>
<g id="alarm-off"><path d="M12 6c3.87 0 7 3.13 7 7 0 .84-.16 1.65-.43 2.4l1.52 1.52c.58-1.19.91-2.51.91-3.92 0-4.97-4.03-9-9-9-1.41 0-2.73.33-3.92.91L9.6 6.43C10.35 6.16 11.16 6 12 6zm10-.28l-4.6-3.86-1.29 1.53 4.6 3.86L22 5.72zM2.92 2.29L1.65 3.57 2.98 4.9l-1.11.93 1.42 1.42 1.11-.94.8.8C3.83 8.69 3 10.75 3 13c0 4.97 4.02 9 9 9 2.25 0 4.31-.83 5.89-2.2l2.2 2.2 1.27-1.27L3.89 3.27l-.97-.98zm13.55 16.1C15.26 19.39 13.7 20 12 20c-3.87 0-7-3.13-7-7 0-1.7.61-3.26 1.61-4.47l9.86 9.86zM8.02 3.28L6.6 1.86l-.86.71 1.42 1.42.86-.71z"></path></g>
<g id="alarm-on"><path d="M22 5.72l-4.6-3.86-1.29 1.53 4.6 3.86L22 5.72zM7.88 3.39L6.6 1.86 2 5.71l1.29 1.53 4.59-3.85zM12 4c-4.97 0-9 4.03-9 9s4.02 9 9 9c4.97 0 9-4.03 9-9s-4.03-9-9-9zm0 16c-3.87 0-7-3.13-7-7s3.13-7 7-7 7 3.13 7 7-3.13 7-7 7zm-1.46-5.47L8.41 12.4l-1.06 1.06 3.18 3.18 6-6-1.06-1.06-4.93 4.95z"></path></g>
<g id="all-out"><path d="M16.21 4.16l4 4v-4zm4 12l-4 4h4zm-12 4l-4-4v4zm-4-12l4-4h-4zm12.95-.95c-2.73-2.73-7.17-2.73-9.9 0s-2.73 7.17 0 9.9 7.17 2.73 9.9 0 2.73-7.16 0-9.9zm-1.1 8.8c-2.13 2.13-5.57 2.13-7.7 0s-2.13-5.57 0-7.7 5.57-2.13 7.7 0 2.13 5.57 0 7.7z"></path></g>
<g id="android"><path d="M6 18c0 .55.45 1 1 1h1v3.5c0 .83.67 1.5 1.5 1.5s1.5-.67 1.5-1.5V19h2v3.5c0 .83.67 1.5 1.5 1.5s1.5-.67 1.5-1.5V19h1c.55 0 1-.45 1-1V8H6v10zM3.5 8C2.67 8 2 8.67 2 9.5v7c0 .83.67 1.5 1.5 1.5S5 17.33 5 16.5v-7C5 8.67 4.33 8 3.5 8zm17 0c-.83 0-1.5.67-1.5 1.5v7c0 .83.67 1.5 1.5 1.5s1.5-.67 1.5-1.5v-7c0-.83-.67-1.5-1.5-1.5zm-4.97-5.84l1.3-1.3c.2-.2.2-.51 0-.71-.2-.2-.51-.2-.71 0l-1.48 1.48C13.85 1.23 12.95 1 12 1c-.96 0-1.86.23-2.66.63L7.85.15c-.2-.2-.51-.2-.71 0-.2.2-.2.51 0 .71l1.31 1.31C6.97 3.26 6 5.01 6 7h12c0-1.99-.97-3.75-2.47-4.84zM10 5H9V4h1v1zm5 0h-1V4h1v1z"></path></g>
<g id="announcement"><path d="M20 2H4c-1.1 0-1.99.9-1.99 2L2 22l4-4h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-7 9h-2V5h2v6zm0 4h-2v-2h2v2z"></path></g>
<g id="apps"><path d="M4 8h4V4H4v4zm6 12h4v-4h-4v4zm-6 0h4v-4H4v4zm0-6h4v-4H4v4zm6 0h4v-4h-4v4zm6-10v4h4V4h-4zm-6 4h4V4h-4v4zm6 6h4v-4h-4v4zm0 6h4v-4h-4v4z"></path></g>
<g id="archive"><path d="M20.54 5.23l-1.39-1.68C18.88 3.21 18.47 3 18 3H6c-.47 0-.88.21-1.16.55L3.46 5.23C3.17 5.57 3 6.02 3 6.5V19c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V6.5c0-.48-.17-.93-.46-1.27zM12 17.5L6.5 12H10v-2h4v2h3.5L12 17.5zM5.12 5l.81-1h12l.94 1H5.12z"></path></g>
<g id="arrow-back"><path d="M20 11H7.83l5.59-5.59L12 4l-8 8 8 8 1.41-1.41L7.83 13H20v-2z"></path></g>
<g id="arrow-downward"><path d="M20 12l-1.41-1.41L13 16.17V4h-2v12.17l-5.58-5.59L4 12l8 8 8-8z"></path></g>
<g id="arrow-drop-down"><path d="M7 10l5 5 5-5z"></path></g>
<g id="arrow-drop-down-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 12l-4-4h8l-4 4z"></path></g>
<g id="arrow-drop-up"><path d="M7 14l5-5 5 5z"></path></g>
<g id="arrow-forward"><path d="M12 4l-1.41 1.41L16.17 11H4v2h12.17l-5.58 5.59L12 20l8-8z"></path></g>
<g id="arrow-upward"><path d="M4 12l1.41 1.41L11 7.83V20h2V7.83l5.58 5.59L20 12l-8-8-8 8z"></path></g>
<g id="aspect-ratio"><path d="M19 12h-2v3h-3v2h5v-5zM7 9h3V7H5v5h2V9zm14-6H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16.01H3V4.99h18v14.02z"></path></g>
<g id="assessment"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z"></path></g>
<g id="assignment"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm2 14H7v-2h7v2zm3-4H7v-2h10v2zm0-4H7V7h10v2z"></path></g>
<g id="assignment-ind"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm0 4c1.66 0 3 1.34 3 3s-1.34 3-3 3-3-1.34-3-3 1.34-3 3-3zm6 12H6v-1.4c0-2 4-3.1 6-3.1s6 1.1 6 3.1V19z"></path></g>
<g id="assignment-late"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-6 15h-2v-2h2v2zm0-4h-2V8h2v6zm-1-9c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1z"></path></g>
<g id="assignment-return"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm4 12h-4v3l-5-5 5-5v3h4v4z"></path></g>
<g id="assignment-returned"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm0 15l-5-5h3V9h4v4h3l-5 5z"></path></g>
<g id="assignment-turned-in"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm-2 14l-4-4 1.41-1.41L10 14.17l6.59-6.59L18 9l-8 8z"></path></g>
<g id="attachment"><path d="M2 12.5C2 9.46 4.46 7 7.5 7H18c2.21 0 4 1.79 4 4s-1.79 4-4 4H9.5C8.12 15 7 13.88 7 12.5S8.12 10 9.5 10H17v2H9.41c-.55 0-.55 1 0 1H18c1.1 0 2-.9 2-2s-.9-2-2-2H7.5C5.57 9 4 10.57 4 12.5S5.57 16 7.5 16H17v2H7.5C4.46 18 2 15.54 2 12.5z"></path></g>
<g id="autorenew"><path d="M12 6v3l4-4-4-4v3c-4.42 0-8 3.58-8 8 0 1.57.46 3.03 1.24 4.26L6.7 14.8c-.45-.83-.7-1.79-.7-2.8 0-3.31 2.69-6 6-6zm6.76 1.74L17.3 9.2c.44.84.7 1.79.7 2.8 0 3.31-2.69 6-6 6v-3l-4 4 4 4v-3c4.42 0 8-3.58 8-8 0-1.57-.46-3.03-1.24-4.26z"></path></g>
<g id="backspace"><path d="M22 3H7c-.69 0-1.23.35-1.59.88L0 12l5.41 8.11c.36.53.9.89 1.59.89h15c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-3 12.59L17.59 17 14 13.41 10.41 17 9 15.59 12.59 12 9 8.41 10.41 7 14 10.59 17.59 7 19 8.41 15.41 12 19 15.59z"></path></g>
<g id="backup"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM14 13v4h-4v-4H7l5-5 5 5h-3z"></path></g>
<g id="block"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zM4 12c0-4.42 3.58-8 8-8 1.85 0 3.55.63 4.9 1.69L5.69 16.9C4.63 15.55 4 13.85 4 12zm8 8c-1.85 0-3.55-.63-4.9-1.69L18.31 7.1C19.37 8.45 20 10.15 20 12c0 4.42-3.58 8-8 8z"></path></g>
<g id="book"><path d="M18 2H6c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM6 4h5v8l-2.5-1.5L6 12V4z"></path></g>
<g id="bookmark"><path d="M17 3H7c-1.1 0-1.99.9-1.99 2L5 21l7-3 7 3V5c0-1.1-.9-2-2-2z"></path></g>
<g id="bookmark-border"><path d="M17 3H7c-1.1 0-1.99.9-1.99 2L5 21l7-3 7 3V5c0-1.1-.9-2-2-2zm0 15l-5-2.18L7 18V5h10v13z"></path></g>
<g id="bug-report"><path d="M20 8h-2.81c-.45-.78-1.07-1.45-1.82-1.96L17 4.41 15.59 3l-2.17 2.17C12.96 5.06 12.49 5 12 5c-.49 0-.96.06-1.41.17L8.41 3 7 4.41l1.62 1.63C7.88 6.55 7.26 7.22 6.81 8H4v2h2.09c-.05.33-.09.66-.09 1v1H4v2h2v1c0 .34.04.67.09 1H4v2h2.81c1.04 1.79 2.97 3 5.19 3s4.15-1.21 5.19-3H20v-2h-2.09c.05-.33.09-.66.09-1v-1h2v-2h-2v-1c0-.34-.04-.67-.09-1H20V8zm-6 8h-4v-2h4v2zm0-4h-4v-2h4v2z"></path></g>
<g id="build"><path d="M22.7 19l-9.1-9.1c.9-2.3.4-5-1.5-6.9-2-2-5-2.4-7.4-1.3L9 6 6 9 1.6 4.7C.4 7.1.9 10.1 2.9 12.1c1.9 1.9 4.6 2.4 6.9 1.5l9.1 9.1c.4.4 1 .4 1.4 0l2.3-2.3c.5-.4.5-1.1.1-1.4z"></path></g>
<g id="cached"><path d="M19 8l-4 4h3c0 3.31-2.69 6-6 6-1.01 0-1.97-.25-2.8-.7l-1.46 1.46C8.97 19.54 10.43 20 12 20c4.42 0 8-3.58 8-8h3l-4-4zM6 12c0-3.31 2.69-6 6-6 1.01 0 1.97.25 2.8.7l1.46-1.46C15.03 4.46 13.57 4 12 4c-4.42 0-8 3.58-8 8H1l4 4 4-4H6z"></path></g>
<g id="camera-enhance"><path d="M9 3L7.17 5H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2h-3.17L15 3H9zm3 15c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5zm0-1l1.25-2.75L16 13l-2.75-1.25L12 9l-1.25 2.75L8 13l2.75 1.25z"></path></g>
<g id="cancel"><path d="M12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2zm5 13.59L15.59 17 12 13.41 8.41 17 7 15.59 10.59 12 7 8.41 8.41 7 12 10.59 15.59 7 17 8.41 13.41 12 17 15.59z"></path></g>
<g id="card-giftcard"><path d="M20 6h-2.18c.11-.31.18-.65.18-1 0-1.66-1.34-3-3-3-1.05 0-1.96.54-2.5 1.35l-.5.67-.5-.68C10.96 2.54 10.05 2 9 2 7.34 2 6 3.34 6 5c0 .35.07.69.18 1H4c-1.11 0-1.99.89-1.99 2L2 19c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zm-5-2c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zM9 4c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm11 15H4v-2h16v2zm0-5H4V8h5.08L7 10.83 8.62 12 11 8.76l1-1.36 1 1.36L15.38 12 17 10.83 14.92 8H20v6z"></path></g>
<g id="card-membership"><path d="M20 2H4c-1.11 0-2 .89-2 2v11c0 1.11.89 2 2 2h4v5l4-2 4 2v-5h4c1.11 0 2-.89 2-2V4c0-1.11-.89-2-2-2zm0 13H4v-2h16v2zm0-5H4V4h16v6z"></path></g>
<g id="card-travel"><path d="M20 6h-3V4c0-1.11-.89-2-2-2H9c-1.11 0-2 .89-2 2v2H4c-1.11 0-2 .89-2 2v11c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zM9 4h6v2H9V4zm11 15H4v-2h16v2zm0-5H4V8h3v2h2V8h6v2h2V8h3v6z"></path></g>
<g id="change-history"><path d="M12 7.77L18.39 18H5.61L12 7.77M12 4L2 20h20L12 4z"></path></g>
<g id="check"><path d="M9 16.17L4.83 12l-1.42 1.41L9 19 21 7l-1.41-1.41z"></path></g>
<g id="check-box"><path d="M19 3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.11 0 2-.9 2-2V5c0-1.1-.89-2-2-2zm-9 14l-5-5 1.41-1.41L10 14.17l7.59-7.59L19 8l-9 9z"></path></g>
<g id="check-box-outline-blank"><path d="M19 5v14H5V5h14m0-2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2z"></path></g>
<g id="check-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm-2 15l-5-5 1.41-1.41L10 14.17l7.59-7.59L19 8l-9 9z"></path></g>
<g id="chevron-left"><path d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"></path></g>
<g id="chevron-right"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"></path></g>
<g id="chrome-reader-mode"><path d="M13 12h7v1.5h-7zm0-2.5h7V11h-7zm0 5h7V16h-7zM21 4H3c-1.1 0-2 .9-2 2v13c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 15h-9V6h9v13z"></path></g>
<g id="class"><path d="M18 2H6c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM6 4h5v8l-2.5-1.5L6 12V4z"></path></g>
<g id="clear"><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"></path></g>
<g id="close"><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"></path></g>
<g id="cloud"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96z"></path></g>
<g id="cloud-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm4.5 14H8c-1.66 0-3-1.34-3-3s1.34-3 3-3l.14.01C8.58 8.28 10.13 7 12 7c2.21 0 4 1.79 4 4h.5c1.38 0 2.5 1.12 2.5 2.5S17.88 16 16.5 16z"></path></g>
<g id="cloud-done"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM10 17l-3.5-3.5 1.41-1.41L10 14.17 15.18 9l1.41 1.41L10 17z"></path></g>
<g id="cloud-download"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM17 13l-5 5-5-5h3V9h4v4h3z"></path></g>
<g id="cloud-off"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4c-1.48 0-2.85.43-4.01 1.17l1.46 1.46C10.21 6.23 11.08 6 12 6c3.04 0 5.5 2.46 5.5 5.5v.5H19c1.66 0 3 1.34 3 3 0 1.13-.64 2.11-1.56 2.62l1.45 1.45C23.16 18.16 24 16.68 24 15c0-2.64-2.05-4.78-4.65-4.96zM3 5.27l2.75 2.74C2.56 8.15 0 10.77 0 14c0 3.31 2.69 6 6 6h11.73l2 2L21 20.73 4.27 4 3 5.27zM7.73 10l8 8H6c-2.21 0-4-1.79-4-4s1.79-4 4-4h1.73z"></path></g>
<g id="cloud-queue"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM19 18H6c-2.21 0-4-1.79-4-4s1.79-4 4-4h.71C7.37 7.69 9.48 6 12 6c3.04 0 5.5 2.46 5.5 5.5v.5H19c1.66 0 3 1.34 3 3s-1.34 3-3 3z"></path></g>
<g id="cloud-upload"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM14 13v4h-4v-4H7l5-5 5 5h-3z"></path></g>
<g id="code"><path d="M9.4 16.6L4.8 12l4.6-4.6L8 6l-6 6 6 6 1.4-1.4zm5.2 0l4.6-4.6-4.6-4.6L16 6l6 6-6 6-1.4-1.4z"></path></g>
<g id="compare-arrows"><path d="M9.01 14H2v2h7.01v3L13 15l-3.99-4v3zm5.98-1v-3H22V8h-7.01V5L11 9l3.99 4z"></path></g>
<g id="content-copy"><path d="M16 1H4c-1.1 0-2 .9-2 2v14h2V3h12V1zm3 4H8c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h11c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 16H8V7h11v14z"></path></g>
<g id="content-cut"><path d="M9.64 7.64c.23-.5.36-1.05.36-1.64 0-2.21-1.79-4-4-4S2 3.79 2 6s1.79 4 4 4c.59 0 1.14-.13 1.64-.36L10 12l-2.36 2.36C7.14 14.13 6.59 14 6 14c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4c0-.59-.13-1.14-.36-1.64L12 14l7 7h3v-1L9.64 7.64zM6 8c-1.1 0-2-.89-2-2s.9-2 2-2 2 .89 2 2-.9 2-2 2zm0 12c-1.1 0-2-.89-2-2s.9-2 2-2 2 .89 2 2-.9 2-2 2zm6-7.5c-.28 0-.5-.22-.5-.5s.22-.5.5-.5.5.22.5.5-.22.5-.5.5zM19 3l-6 6 2 2 7-7V3z"></path></g>
<g id="content-paste"><path d="M19 2h-4.18C14.4.84 13.3 0 12 0c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm7 18H5V4h2v3h10V4h2v16z"></path></g>
<g id="copyright"><path d="M10.08 10.86c.05-.33.16-.62.3-.87s.34-.46.59-.62c.24-.15.54-.22.91-.23.23.01.44.05.63.13.2.09.38.21.52.36s.25.33.34.53.13.42.14.64h1.79c-.02-.47-.11-.9-.28-1.29s-.4-.73-.7-1.01-.66-.5-1.08-.66-.88-.23-1.39-.23c-.65 0-1.22.11-1.7.34s-.88.53-1.2.92-.56.84-.71 1.36S8 11.29 8 11.87v.27c0 .58.08 1.12.23 1.64s.39.97.71 1.35.72.69 1.2.91 1.05.34 1.7.34c.47 0 .91-.08 1.32-.23s.77-.36 1.08-.63.56-.58.74-.94.29-.74.3-1.15h-1.79c-.01.21-.06.4-.15.58s-.21.33-.36.46-.32.23-.52.3c-.19.07-.39.09-.6.1-.36-.01-.66-.08-.89-.23-.25-.16-.45-.37-.59-.62s-.25-.55-.3-.88-.08-.67-.08-1v-.27c0-.35.03-.68.08-1.01zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="create"><path d="M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04c.39-.39.39-1.02 0-1.41l-2.34-2.34c-.39-.39-1.02-.39-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z"></path></g>
<g id="create-new-folder"><path d="M20 6h-8l-2-2H4c-1.11 0-1.99.89-1.99 2L2 18c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zm-1 8h-3v3h-2v-3h-3v-2h3V9h2v3h3v2z"></path></g>
<g id="credit-card"><path d="M20 4H4c-1.11 0-1.99.89-1.99 2L2 18c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V6c0-1.11-.89-2-2-2zm0 14H4v-6h16v6zm0-10H4V6h16v2z"></path></g>
<g id="dashboard"><path d="M3 13h8V3H3v10zm0 8h8v-6H3v6zm10 0h8V11h-8v10zm0-18v6h8V3h-8z"></path></g>
<g id="date-range"><path d="M9 11H7v2h2v-2zm4 0h-2v2h2v-2zm4 0h-2v2h2v-2zm2-7h-1V2h-2v2H8V2H6v2H5c-1.11 0-1.99.9-1.99 2L3 20c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 16H5V9h14v11z"></path></g>
<g id="delete"><path d="M6 19c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V7H6v12zM19 4h-3.5l-1-1h-5l-1 1H5v2h14V4z"></path></g>
<g id="delete-forever"><path d="M6 19c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V7H6v12zm2.46-7.12l1.41-1.41L12 12.59l2.12-2.12 1.41 1.41L13.41 14l2.12 2.12-1.41 1.41L12 15.41l-2.12 2.12-1.41-1.41L10.59 14l-2.13-2.12zM15.5 4l-1-1h-5l-1 1H5v2h14V4z"></path></g>
<g id="delete-sweep"><path d="M15 16h4v2h-4zm0-8h7v2h-7zm0 4h6v2h-6zM3 18c0 1.1.9 2 2 2h6c1.1 0 2-.9 2-2V8H3v10zM14 5h-3l-1-1H6L5 5H2v2h12z"></path></g>
<g id="description"><path d="M14 2H6c-1.1 0-1.99.9-1.99 2L4 20c0 1.1.89 2 1.99 2H18c1.1 0 2-.9 2-2V8l-6-6zm2 16H8v-2h8v2zm0-4H8v-2h8v2zm-3-5V3.5L18.5 9H13z"></path></g>
<g id="dns"><path d="M20 13H4c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h16c.55 0 1-.45 1-1v-6c0-.55-.45-1-1-1zM7 19c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zM20 3H4c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h16c.55 0 1-.45 1-1V4c0-.55-.45-1-1-1zM7 9c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2z"></path></g>
<g id="done"><path d="M9 16.2L4.8 12l-1.4 1.4L9 19 21 7l-1.4-1.4L9 16.2z"></path></g>
<g id="done-all"><path d="M18 7l-1.41-1.41-6.34 6.34 1.41 1.41L18 7zm4.24-1.41L11.66 16.17 7.48 12l-1.41 1.41L11.66 19l12-12-1.42-1.41zM.41 13.41L6 19l1.41-1.41L1.83 12 .41 13.41z"></path></g>
<g id="donut-large"><path d="M11 5.08V2c-5 .5-9 4.81-9 10s4 9.5 9 10v-3.08c-3-.48-6-3.4-6-6.92s3-6.44 6-6.92zM18.97 11H22c-.47-5-4-8.53-9-9v3.08C16 5.51 18.54 8 18.97 11zM13 18.92V22c5-.47 8.53-4 9-9h-3.03c-.43 3-2.97 5.49-5.97 5.92z"></path></g>
<g id="donut-small"><path d="M11 9.16V2c-5 .5-9 4.79-9 10s4 9.5 9 10v-7.16c-1-.41-2-1.52-2-2.84s1-2.43 2-2.84zM14.86 11H22c-.48-4.75-4-8.53-9-9v7.16c1 .3 1.52.98 1.86 1.84zM13 14.84V22c5-.47 8.52-4.25 9-9h-7.14c-.34.86-.86 1.54-1.86 1.84z"></path></g>
<g id="drafts"><path d="M21.99 8c0-.72-.37-1.35-.94-1.7L12 1 2.95 6.3C2.38 6.65 2 7.28 2 8v10c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2l-.01-10zM12 13L3.74 7.84 12 3l8.26 4.84L12 13z"></path></g>
<g id="eject"><path d="M5 17h14v2H5zm7-12L5.33 15h13.34z"></path></g>
<g id="error"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-2h2v2zm0-4h-2V7h2v6z"></path></g>
<g id="error-outline"><path d="M11 15h2v2h-2zm0-8h2v6h-2zm.99-5C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"></path></g>
<g id="euro-symbol"><path d="M15 18.5c-2.51 0-4.68-1.42-5.76-3.5H15v-2H8.58c-.05-.33-.08-.66-.08-1s.03-.67.08-1H15V9H9.24C10.32 6.92 12.5 5.5 15 5.5c1.61 0 3.09.59 4.23 1.57L21 5.3C19.41 3.87 17.3 3 15 3c-3.92 0-7.24 2.51-8.48 6H3v2h3.06c-.04.33-.06.66-.06 1 0 .34.02.67.06 1H3v2h3.52c1.24 3.49 4.56 6 8.48 6 2.31 0 4.41-.87 6-2.3l-1.78-1.77c-1.13.98-2.6 1.57-4.22 1.57z"></path></g>
<g id="event"><path d="M17 12h-5v5h5v-5zM16 1v2H8V1H6v2H5c-1.11 0-1.99.9-1.99 2L3 19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2h-1V1h-2zm3 18H5V8h14v11z"></path></g>
<g id="event-seat"><path d="M4 18v3h3v-3h10v3h3v-6H4zm15-8h3v3h-3zM2 10h3v3H2zm15 3H7V5c0-1.1.9-2 2-2h6c1.1 0 2 .9 2 2v8z"></path></g>
<g id="exit-to-app"><path d="M10.09 15.59L11.5 17l5-5-5-5-1.41 1.41L12.67 11H3v2h9.67l-2.58 2.59zM19 3H5c-1.11 0-2 .9-2 2v4h2V5h14v14H5v-4H3v4c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2z"></path></g>
<g id="expand-less"><path d="M12 8l-6 6 1.41 1.41L12 10.83l4.59 4.58L18 14z"></path></g>
<g id="expand-more"><path d="M16.59 8.59L12 13.17 7.41 8.59 6 10l6 6 6-6z"></path></g>
<g id="explore"><path d="M12 10.9c-.61 0-1.1.49-1.1 1.1s.49 1.1 1.1 1.1c.61 0 1.1-.49 1.1-1.1s-.49-1.1-1.1-1.1zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm2.19 12.19L6 18l3.81-8.19L18 6l-3.81 8.19z"></path></g>
<g id="extension"><path d="M20.5 11H19V7c0-1.1-.9-2-2-2h-4V3.5C13 2.12 11.88 1 10.5 1S8 2.12 8 3.5V5H4c-1.1 0-1.99.9-1.99 2v3.8H3.5c1.49 0 2.7 1.21 2.7 2.7s-1.21 2.7-2.7 2.7H2V20c0 1.1.9 2 2 2h3.8v-1.5c0-1.49 1.21-2.7 2.7-2.7 1.49 0 2.7 1.21 2.7 2.7V22H17c1.1 0 2-.9 2-2v-4h1.5c1.38 0 2.5-1.12 2.5-2.5S21.88 11 20.5 11z"></path></g>
<g id="face"><path d="M9 11.75c-.69 0-1.25.56-1.25 1.25s.56 1.25 1.25 1.25 1.25-.56 1.25-1.25-.56-1.25-1.25-1.25zm6 0c-.69 0-1.25.56-1.25 1.25s.56 1.25 1.25 1.25 1.25-.56 1.25-1.25-.56-1.25-1.25-1.25zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8 0-.29.02-.58.05-.86 2.36-1.05 4.23-2.98 5.21-5.37C11.07 8.33 14.05 10 17.42 10c.78 0 1.53-.09 2.25-.26.21.71.33 1.47.33 2.26 0 4.41-3.59 8-8 8z"></path></g>
<g id="favorite"><path d="M12 21.35l-1.45-1.32C5.4 15.36 2 12.28 2 8.5 2 5.42 4.42 3 7.5 3c1.74 0 3.41.81 4.5 2.09C13.09 3.81 14.76 3 16.5 3 19.58 3 22 5.42 22 8.5c0 3.78-3.4 6.86-8.55 11.54L12 21.35z"></path></g>
<g id="favorite-border"><path d="M16.5 3c-1.74 0-3.41.81-4.5 2.09C10.91 3.81 9.24 3 7.5 3 4.42 3 2 5.42 2 8.5c0 3.78 3.4 6.86 8.55 11.54L12 21.35l1.45-1.32C18.6 15.36 22 12.28 22 8.5 22 5.42 19.58 3 16.5 3zm-4.4 15.55l-.1.1-.1-.1C7.14 14.24 4 11.39 4 8.5 4 6.5 5.5 5 7.5 5c1.54 0 3.04.99 3.57 2.36h1.87C13.46 5.99 14.96 5 16.5 5c2 0 3.5 1.5 3.5 3.5 0 2.89-3.14 5.74-7.9 10.05z"></path></g>
<g id="feedback"><path d="M20 2H4c-1.1 0-1.99.9-1.99 2L2 22l4-4h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-7 12h-2v-2h2v2zm0-4h-2V6h2v4z"></path></g>
<g id="file-download"><path d="M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z"></path></g>
<g id="file-upload"><path d="M9 16h6v-6h4l-7-7-7 7h4zm-4 2h14v2H5z"></path></g>
<g id="filter-list"><path d="M10 18h4v-2h-4v2zM3 6v2h18V6H3zm3 7h12v-2H6v2z"></path></g>
<g id="find-in-page"><path d="M20 19.59V8l-6-6H6c-1.1 0-1.99.9-1.99 2L4 20c0 1.1.89 2 1.99 2H18c.45 0 .85-.15 1.19-.4l-4.43-4.43c-.8.52-1.74.83-2.76.83-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5c0 1.02-.31 1.96-.83 2.75L20 19.59zM9 13c0 1.66 1.34 3 3 3s3-1.34 3-3-1.34-3-3-3-3 1.34-3 3z"></path></g>
<g id="find-replace"><path d="M11 6c1.38 0 2.63.56 3.54 1.46L12 10h6V4l-2.05 2.05C14.68 4.78 12.93 4 11 4c-3.53 0-6.43 2.61-6.92 6H6.1c.46-2.28 2.48-4 4.9-4zm5.64 9.14c.66-.9 1.12-1.97 1.28-3.14H15.9c-.46 2.28-2.48 4-4.9 4-1.38 0-2.63-.56-3.54-1.46L10 12H4v6l2.05-2.05C7.32 17.22 9.07 18 11 18c1.55 0 2.98-.51 4.14-1.36L20 21.49 21.49 20l-4.85-4.86z"></path></g>
<g id="fingerprint"><path d="M17.81 4.47c-.08 0-.16-.02-.23-.06C15.66 3.42 14 3 12.01 3c-1.98 0-3.86.47-5.57 1.41-.24.13-.54.04-.68-.2-.13-.24-.04-.55.2-.68C7.82 2.52 9.86 2 12.01 2c2.13 0 3.99.47 6.03 1.52.25.13.34.43.21.67-.09.18-.26.28-.44.28zM3.5 9.72c-.1 0-.2-.03-.29-.09-.23-.16-.28-.47-.12-.7.99-1.4 2.25-2.5 3.75-3.27C9.98 4.04 14 4.03 17.15 5.65c1.5.77 2.76 1.86 3.75 3.25.16.22.11.54-.12.7-.23.16-.54.11-.7-.12-.9-1.26-2.04-2.25-3.39-2.94-2.87-1.47-6.54-1.47-9.4.01-1.36.7-2.5 1.7-3.4 2.96-.08.14-.23.21-.39.21zm6.25 12.07c-.13 0-.26-.05-.35-.15-.87-.87-1.34-1.43-2.01-2.64-.69-1.23-1.05-2.73-1.05-4.34 0-2.97 2.54-5.39 5.66-5.39s5.66 2.42 5.66 5.39c0 .28-.22.5-.5.5s-.5-.22-.5-.5c0-2.42-2.09-4.39-4.66-4.39-2.57 0-4.66 1.97-4.66 4.39 0 1.44.32 2.77.93 3.85.64 1.15 1.08 1.64 1.85 2.42.19.2.19.51 0 .71-.11.1-.24.15-.37.15zm7.17-1.85c-1.19 0-2.24-.3-3.1-.89-1.49-1.01-2.38-2.65-2.38-4.39 0-.28.22-.5.5-.5s.5.22.5.5c0 1.41.72 2.74 1.94 3.56.71.48 1.54.71 2.54.71.24 0 .64-.03 1.04-.1.27-.05.53.13.58.41.05.27-.13.53-.41.58-.57.11-1.07.12-1.21.12zM14.91 22c-.04 0-.09-.01-.13-.02-1.59-.44-2.63-1.03-3.72-2.1-1.4-1.39-2.17-3.24-2.17-5.22 0-1.62 1.38-2.94 3.08-2.94 1.7 0 3.08 1.32 3.08 2.94 0 1.07.93 1.94 2.08 1.94s2.08-.87 2.08-1.94c0-3.77-3.25-6.83-7.25-6.83-2.84 0-5.44 1.58-6.61 4.03-.39.81-.59 1.76-.59 2.8 0 .78.07 2.01.67 3.61.1.26-.03.55-.29.64-.26.1-.55-.04-.64-.29-.49-1.31-.73-2.61-.73-3.96 0-1.2.23-2.29.68-3.24 1.33-2.79 4.28-4.6 7.51-4.6 4.55 0 8.25 3.51 8.25 7.83 0 1.62-1.38 2.94-3.08 2.94s-3.08-1.32-3.08-2.94c0-1.07-.93-1.94-2.08-1.94s-2.08.87-2.08 1.94c0 1.71.66 3.31 1.87 4.51.95.94 1.86 1.46 3.27 1.85.27.07.42.35.35.61-.05.23-.26.38-.47.38z"></path></g>
<g id="first-page"><path d="M18.41 16.59L13.82 12l4.59-4.59L17 6l-6 6 6 6zM6 6h2v12H6z"></path></g>
<g id="flag"><path d="M14.4 6L14 4H5v17h2v-7h5.6l.4 2h7V6z"></path></g>
<g id="flight-land"><path d="M2.5 19h19v2h-19zm7.18-5.73l4.35 1.16 5.31 1.42c.8.21 1.62-.26 1.84-1.06.21-.8-.26-1.62-1.06-1.84l-5.31-1.42-2.76-9.02L10.12 2v8.28L5.15 8.95l-.93-2.32-1.45-.39v5.17l1.6.43 5.31 1.43z"></path></g>
<g id="flight-takeoff"><path d="M2.5 19h19v2h-19zm19.57-9.36c-.21-.8-1.04-1.28-1.84-1.06L14.92 10l-6.9-6.43-1.93.51 4.14 7.17-4.97 1.33-1.97-1.54-1.45.39 1.82 3.16.77 1.33 1.6-.43 5.31-1.42 4.35-1.16L21 11.49c.81-.23 1.28-1.05 1.07-1.85z"></path></g>
<g id="flip-to-back"><path d="M9 7H7v2h2V7zm0 4H7v2h2v-2zm0-8c-1.11 0-2 .9-2 2h2V3zm4 12h-2v2h2v-2zm6-12v2h2c0-1.1-.9-2-2-2zm-6 0h-2v2h2V3zM9 17v-2H7c0 1.1.89 2 2 2zm10-4h2v-2h-2v2zm0-4h2V7h-2v2zm0 8c1.1 0 2-.9 2-2h-2v2zM5 7H3v12c0 1.1.89 2 2 2h12v-2H5V7zm10-2h2V3h-2v2zm0 12h2v-2h-2v2z"></path></g>
<g id="flip-to-front"><path d="M3 13h2v-2H3v2zm0 4h2v-2H3v2zm2 4v-2H3c0 1.1.89 2 2 2zM3 9h2V7H3v2zm12 12h2v-2h-2v2zm4-18H9c-1.11 0-2 .9-2 2v10c0 1.1.89 2 2 2h10c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 12H9V5h10v10zm-8 6h2v-2h-2v2zm-4 0h2v-2H7v2z"></path></g>
<g id="folder"><path d="M10 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2h-8l-2-2z"></path></g>
<g id="folder-open"><path d="M20 6h-8l-2-2H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2zm0 12H4V8h16v10z"></path></g>
<g id="folder-shared"><path d="M20 6h-8l-2-2H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2zm-5 3c1.1 0 2 .9 2 2s-.9 2-2 2-2-.9-2-2 .9-2 2-2zm4 8h-8v-1c0-1.33 2.67-2 4-2s4 .67 4 2v1z"></path></g>
<g id="font-download"><path d="M9.93 13.5h4.14L12 7.98zM20 2H4c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-4.05 16.5l-1.14-3H9.17l-1.12 3H5.96l5.11-13h1.86l5.11 13h-2.09z"></path></g>
<g id="forward"><path d="M12 8V4l8 8-8 8v-4H4V8z"></path></g>
<g id="fullscreen"><path d="M7 14H5v5h5v-2H7v-3zm-2-4h2V7h3V5H5v5zm12 7h-3v2h5v-5h-2v3zM14 5v2h3v3h2V5h-5z"></path></g>
<g id="fullscreen-exit"><path d="M5 16h3v3h2v-5H5v2zm3-8H5v2h5V5H8v3zm6 11h2v-3h3v-2h-5v5zm2-11V5h-2v5h5V8h-3z"></path></g>
<g id="g-translate"><path d="M20 5h-9.12L10 2H4c-1.1 0-2 .9-2 2v13c0 1.1.9 2 2 2h7l1 3h8c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zM7.17 14.59c-2.25 0-4.09-1.83-4.09-4.09s1.83-4.09 4.09-4.09c1.04 0 1.99.37 2.74 1.07l.07.06-1.23 1.18-.06-.05c-.29-.27-.78-.59-1.52-.59-1.31 0-2.38 1.09-2.38 2.42s1.07 2.42 2.38 2.42c1.37 0 1.96-.87 2.12-1.46H7.08V9.91h3.95l.01.07c.04.21.05.4.05.61 0 2.35-1.61 4-3.92 4zm6.03-1.71c.33.6.74 1.18 1.19 1.7l-.54.53-.65-2.23zm.77-.76h-.99l-.31-1.04h3.99s-.34 1.31-1.56 2.74c-.52-.62-.89-1.23-1.13-1.7zM21 20c0 .55-.45 1-1 1h-7l2-2-.81-2.77.92-.92L17.79 18l.73-.73-2.71-2.68c.9-1.03 1.6-2.25 1.92-3.51H19v-1.04h-3.64V9h-1.04v1.04h-1.96L11.18 6H20c.55 0 1 .45 1 1v13z"></path></g>
<g id="gavel"><path d="M1 21h12v2H1zM5.245 8.07l2.83-2.827 14.14 14.142-2.828 2.828zM12.317 1l5.657 5.656-2.83 2.83-5.654-5.66zM3.825 9.485l5.657 5.657-2.828 2.828-5.657-5.657z"></path></g>
<g id="gesture"><path d="M4.59 6.89c.7-.71 1.4-1.35 1.71-1.22.5.2 0 1.03-.3 1.52-.25.42-2.86 3.89-2.86 6.31 0 1.28.48 2.34 1.34 2.98.75.56 1.74.73 2.64.46 1.07-.31 1.95-1.4 3.06-2.77 1.21-1.49 2.83-3.44 4.08-3.44 1.63 0 1.65 1.01 1.76 1.79-3.78.64-5.38 3.67-5.38 5.37 0 1.7 1.44 3.09 3.21 3.09 1.63 0 4.29-1.33 4.69-6.1H21v-2.5h-2.47c-.15-1.65-1.09-4.2-4.03-4.2-2.25 0-4.18 1.91-4.94 2.84-.58.73-2.06 2.48-2.29 2.72-.25.3-.68.84-1.11.84-.45 0-.72-.83-.36-1.92.35-1.09 1.4-2.86 1.85-3.52.78-1.14 1.3-1.92 1.3-3.28C8.95 3.69 7.31 3 6.44 3 5.12 3 3.97 4 3.72 4.25c-.36.36-.66.66-.88.93l1.75 1.71zm9.29 11.66c-.31 0-.74-.26-.74-.72 0-.6.73-2.2 2.87-2.76-.3 2.69-1.43 3.48-2.13 3.48z"></path></g>
<g id="get-app"><path d="M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z"></path></g>
<g id="gif"><path d="M11.5 9H13v6h-1.5zM9 9H6c-.6 0-1 .5-1 1v4c0 .5.4 1 1 1h3c.6 0 1-.5 1-1v-2H8.5v1.5h-2v-3H10V10c0-.5-.4-1-1-1zm10 1.5V9h-4.5v6H16v-2h2v-1.5h-2v-1z"></path></g>
<g id="grade"><path d="M12 17.27L18.18 21l-1.64-7.03L22 9.24l-7.19-.61L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21z"></path></g>
<g id="group-work"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zM8 17.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5zM9.5 8c0-1.38 1.12-2.5 2.5-2.5s2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5S9.5 9.38 9.5 8zm6.5 9.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5z"></path></g>
<g id="help"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 17h-2v-2h2v2zm2.07-7.75l-.9.92C13.45 12.9 13 13.5 13 15h-2v-.5c0-1.1.45-2.1 1.17-2.83l1.24-1.26c.37-.36.59-.86.59-1.41 0-1.1-.9-2-2-2s-2 .9-2 2H8c0-2.21 1.79-4 4-4s4 1.79 4 4c0 .88-.36 1.68-.93 2.25z"></path></g>
<g id="help-outline"><path d="M11 18h2v-2h-2v2zm1-16C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zm0-14c-2.21 0-4 1.79-4 4h2c0-1.1.9-2 2-2s2 .9 2 2c0 2-3 1.75-3 5h2c0-2.25 3-2.5 3-5 0-2.21-1.79-4-4-4z"></path></g>
<g id="highlight-off"><path d="M14.59 8L12 10.59 9.41 8 8 9.41 10.59 12 8 14.59 9.41 16 12 13.41 14.59 16 16 14.59 13.41 12 16 9.41 14.59 8zM12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="history"><path d="M13 3c-4.97 0-9 4.03-9 9H1l3.89 3.89.07.14L9 12H6c0-3.87 3.13-7 7-7s7 3.13 7 7-3.13 7-7 7c-1.93 0-3.68-.79-4.94-2.06l-1.42 1.42C8.27 19.99 10.51 21 13 21c4.97 0 9-4.03 9-9s-4.03-9-9-9zm-1 5v5l4.28 2.54.72-1.21-3.5-2.08V8H12z"></path></g>
<g id="home"><path d="M10 20v-6h4v6h5v-8h3L12 3 2 12h3v8z"></path></g>
<g id="hourglass-empty"><path d="M6 2v6h.01L6 8.01 10 12l-4 4 .01.01H6V22h12v-5.99h-.01L18 16l-4-4 4-3.99-.01-.01H18V2H6zm10 14.5V20H8v-3.5l4-4 4 4zm-4-5l-4-4V4h8v3.5l-4 4z"></path></g>
<g id="hourglass-full"><path d="M6 2v6h.01L6 8.01 10 12l-4 4 .01.01H6V22h12v-5.99h-.01L18 16l-4-4 4-3.99-.01-.01H18V2H6z"></path></g>
<g id="http"><path d="M4.5 11h-2V9H1v6h1.5v-2.5h2V15H6V9H4.5v2zm2.5-.5h1.5V15H10v-4.5h1.5V9H7v1.5zm5.5 0H14V15h1.5v-4.5H17V9h-4.5v1.5zm9-1.5H18v6h1.5v-2h2c.8 0 1.5-.7 1.5-1.5v-1c0-.8-.7-1.5-1.5-1.5zm0 2.5h-2v-1h2v1z"></path></g>
<g id="https"><path d="M18 8h-1V6c0-2.76-2.24-5-5-5S7 3.24 7 6v2H6c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V10c0-1.1-.9-2-2-2zm-6 9c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zm3.1-9H8.9V6c0-1.71 1.39-3.1 3.1-3.1 1.71 0 3.1 1.39 3.1 3.1v2z"></path></g>
<g id="important-devices"><path d="M23 11.01L18 11c-.55 0-1 .45-1 1v9c0 .55.45 1 1 1h5c.55 0 1-.45 1-1v-9c0-.55-.45-.99-1-.99zM23 20h-5v-7h5v7zM20 2H2C.89 2 0 2.89 0 4v12c0 1.1.89 2 2 2h7v2H7v2h8v-2h-2v-2h2v-2H2V4h18v5h2V4c0-1.11-.9-2-2-2zm-8.03 7L11 6l-.97 3H7l2.47 1.76-.94 2.91 2.47-1.8 2.47 1.8-.94-2.91L15 9h-3.03z"></path></g>
<g id="inbox"><path d="M19 3H4.99c-1.11 0-1.98.89-1.98 2L3 19c0 1.1.88 2 1.99 2H19c1.1 0 2-.9 2-2V5c0-1.11-.9-2-2-2zm0 12h-4c0 1.66-1.35 3-3 3s-3-1.34-3-3H4.99V5H19v10z"></path></g>
<g id="indeterminate-check-box"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-2 10H7v-2h10v2z"></path></g>
<g id="info"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-6h2v6zm0-8h-2V7h2v2z"></path></g>
<g id="info-outline"><path d="M11 17h2v-6h-2v6zm1-15C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zM11 9h2V7h-2v2z"></path></g>
<g id="input"><path d="M21 3.01H3c-1.1 0-2 .9-2 2V9h2V4.99h18v14.03H3V15H1v4.01c0 1.1.9 1.98 2 1.98h18c1.1 0 2-.88 2-1.98v-14c0-1.11-.9-2-2-2zM11 16l4-4-4-4v3H1v2h10v3z"></path></g>
<g id="invert-colors"><path d="M17.66 7.93L12 2.27 6.34 7.93c-3.12 3.12-3.12 8.19 0 11.31C7.9 20.8 9.95 21.58 12 21.58c2.05 0 4.1-.78 5.66-2.34 3.12-3.12 3.12-8.19 0-11.31zM12 19.59c-1.6 0-3.11-.62-4.24-1.76C6.62 16.69 6 15.19 6 13.59s.62-3.11 1.76-4.24L12 5.1v14.49z"></path></g>
<g id="label"><path d="M17.63 5.84C17.27 5.33 16.67 5 16 5L5 5.01C3.9 5.01 3 5.9 3 7v10c0 1.1.9 1.99 2 1.99L16 19c.67 0 1.27-.33 1.63-.84L22 12l-4.37-6.16z"></path></g>
<g id="label-outline"><path d="M17.63 5.84C17.27 5.33 16.67 5 16 5L5 5.01C3.9 5.01 3 5.9 3 7v10c0 1.1.9 1.99 2 1.99L16 19c.67 0 1.27-.33 1.63-.84L22 12l-4.37-6.16zM16 17H5V7h11l3.55 5L16 17z"></path></g>
<g id="language"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zm6.93 6h-2.95c-.32-1.25-.78-2.45-1.38-3.56 1.84.63 3.37 1.91 4.33 3.56zM12 4.04c.83 1.2 1.48 2.53 1.91 3.96h-3.82c.43-1.43 1.08-2.76 1.91-3.96zM4.26 14C4.1 13.36 4 12.69 4 12s.1-1.36.26-2h3.38c-.08.66-.14 1.32-.14 2 0 .68.06 1.34.14 2H4.26zm.82 2h2.95c.32 1.25.78 2.45 1.38 3.56-1.84-.63-3.37-1.9-4.33-3.56zm2.95-8H5.08c.96-1.66 2.49-2.93 4.33-3.56C8.81 5.55 8.35 6.75 8.03 8zM12 19.96c-.83-1.2-1.48-2.53-1.91-3.96h3.82c-.43 1.43-1.08 2.76-1.91 3.96zM14.34 14H9.66c-.09-.66-.16-1.32-.16-2 0-.68.07-1.35.16-2h4.68c.09.65.16 1.32.16 2 0 .68-.07 1.34-.16 2zm.25 5.56c.6-1.11 1.06-2.31 1.38-3.56h2.95c-.96 1.65-2.49 2.93-4.33 3.56zM16.36 14c.08-.66.14-1.32.14-2 0-.68-.06-1.34-.14-2h3.38c.16.64.26 1.31.26 2s-.1 1.36-.26 2h-3.38z"></path></g>
<g id="last-page"><path d="M5.59 7.41L10.18 12l-4.59 4.59L7 18l6-6-6-6zM16 6h2v12h-2z"></path></g>
<g id="launch"><path d="M19 19H5V5h7V3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2v-7h-2v7zM14 3v2h3.59l-9.83 9.83 1.41 1.41L19 6.41V10h2V3h-7z"></path></g>
<g id="lightbulb-outline"><path d="M9 21c0 .55.45 1 1 1h4c.55 0 1-.45 1-1v-1H9v1zm3-19C8.14 2 5 5.14 5 9c0 2.38 1.19 4.47 3 5.74V17c0 .55.45 1 1 1h6c.55 0 1-.45 1-1v-2.26c1.81-1.27 3-3.36 3-5.74 0-3.86-3.14-7-7-7zm2.85 11.1l-.85.6V16h-4v-2.3l-.85-.6C7.8 12.16 7 10.63 7 9c0-2.76 2.24-5 5-5s5 2.24 5 5c0 1.63-.8 3.16-2.15 4.1z"></path></g>
<g id="line-style"><path d="M3 16h5v-2H3v2zm6.5 0h5v-2h-5v2zm6.5 0h5v-2h-5v2zM3 20h2v-2H3v2zm4 0h2v-2H7v2zm4 0h2v-2h-2v2zm4 0h2v-2h-2v2zm4 0h2v-2h-2v2zM3 12h8v-2H3v2zm10 0h8v-2h-8v2zM3 4v4h18V4H3z"></path></g>
<g id="line-weight"><path d="M3 17h18v-2H3v2zm0 3h18v-1H3v1zm0-7h18v-3H3v3zm0-9v4h18V4H3z"></path></g>
<g id="link"><path d="M3.9 12c0-1.71 1.39-3.1 3.1-3.1h4V7H7c-2.76 0-5 2.24-5 5s2.24 5 5 5h4v-1.9H7c-1.71 0-3.1-1.39-3.1-3.1zM8 13h8v-2H8v2zm9-6h-4v1.9h4c1.71 0 3.1 1.39 3.1 3.1s-1.39 3.1-3.1 3.1h-4V17h4c2.76 0 5-2.24 5-5s-2.24-5-5-5z"></path></g>
<g id="list"><path d="M3 13h2v-2H3v2zm0 4h2v-2H3v2zm0-8h2V7H3v2zm4 4h14v-2H7v2zm0 4h14v-2H7v2zM7 7v2h14V7H7z"></path></g>
<g id="lock"><path d="M18 8h-1V6c0-2.76-2.24-5-5-5S7 3.24 7 6v2H6c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V10c0-1.1-.9-2-2-2zm-6 9c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zm3.1-9H8.9V6c0-1.71 1.39-3.1 3.1-3.1 1.71 0 3.1 1.39 3.1 3.1v2z"></path></g>
<g id="lock-open"><path d="M12 17c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm6-9h-1V6c0-2.76-2.24-5-5-5S7 3.24 7 6h1.9c0-1.71 1.39-3.1 3.1-3.1 1.71 0 3.1 1.39 3.1 3.1v2H6c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V10c0-1.1-.9-2-2-2zm0 12H6V10h12v10z"></path></g>
<g id="lock-outline"><path d="M12 17c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm6-9h-1V6c0-2.76-2.24-5-5-5S7 3.24 7 6v2H6c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V10c0-1.1-.9-2-2-2zM8.9 6c0-1.71 1.39-3.1 3.1-3.1s3.1 1.39 3.1 3.1v2H8.9V6zM18 20H6V10h12v10z"></path></g>
<g id="low-priority"><path d="M14 5h8v2h-8zm0 5.5h8v2h-8zm0 5.5h8v2h-8zM2 11.5C2 15.08 4.92 18 8.5 18H9v2l3-3-3-3v2h-.5C6.02 16 4 13.98 4 11.5S6.02 7 8.5 7H12V5H8.5C4.92 5 2 7.92 2 11.5z"></path></g>
<g id="loyalty"><path d="M21.41 11.58l-9-9C12.05 2.22 11.55 2 11 2H4c-1.1 0-2 .9-2 2v7c0 .55.22 1.05.59 1.42l9 9c.36.36.86.58 1.41.58.55 0 1.05-.22 1.41-.59l7-7c.37-.36.59-.86.59-1.41 0-.55-.23-1.06-.59-1.42zM5.5 7C4.67 7 4 6.33 4 5.5S4.67 4 5.5 4 7 4.67 7 5.5 6.33 7 5.5 7zm11.77 8.27L13 19.54l-4.27-4.27C8.28 14.81 8 14.19 8 13.5c0-1.38 1.12-2.5 2.5-2.5.69 0 1.32.28 1.77.74l.73.72.73-.73c.45-.45 1.08-.73 1.77-.73 1.38 0 2.5 1.12 2.5 2.5 0 .69-.28 1.32-.73 1.77z"></path></g>
<g id="mail"><path d="M20 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 4l-8 5-8-5V6l8 5 8-5v2z"></path></g>
<g id="markunread"><path d="M20 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 4l-8 5-8-5V6l8 5 8-5v2z"></path></g>
<g id="markunread-mailbox"><path d="M20 6H10v6H8V4h6V0H6v6H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2z"></path></g>
<g id="menu"><path d="M3 18h18v-2H3v2zm0-5h18v-2H3v2zm0-7v2h18V6H3z"></path></g>
<g id="more-horiz"><path d="M6 10c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm12 0c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm-6 0c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"></path></g>
<g id="more-vert"><path d="M12 8c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm0 2c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0 6c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"></path></g>
<g id="motorcycle"><path d="M19.44 9.03L15.41 5H11v2h3.59l2 2H5c-2.8 0-5 2.2-5 5s2.2 5 5 5c2.46 0 4.45-1.69 4.9-4h1.65l2.77-2.77c-.21.54-.32 1.14-.32 1.77 0 2.8 2.2 5 5 5s5-2.2 5-5c0-2.65-1.97-4.77-4.56-4.97zM7.82 15C7.4 16.15 6.28 17 5 17c-1.63 0-3-1.37-3-3s1.37-3 3-3c1.28 0 2.4.85 2.82 2H5v2h2.82zM19 17c-1.66 0-3-1.34-3-3s1.34-3 3-3 3 1.34 3 3-1.34 3-3 3z"></path></g>
<g id="move-to-inbox"><path d="M19 3H4.99c-1.11 0-1.98.9-1.98 2L3 19c0 1.1.88 2 1.99 2H19c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 12h-4c0 1.66-1.35 3-3 3s-3-1.34-3-3H4.99V5H19v10zm-3-5h-2V7h-4v3H8l4 4 4-4z"></path></g>
<g id="next-week"><path d="M20 7h-4V5c0-.55-.22-1.05-.59-1.41C15.05 3.22 14.55 3 14 3h-4c-1.1 0-2 .9-2 2v2H4c-1.1 0-2 .9-2 2v11c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V9c0-1.1-.9-2-2-2zM10 5h4v2h-4V5zm1 13.5l-1-1 3-3-3-3 1-1 4 4-4 4z"></path></g>
<g id="note-add"><path d="M14 2H6c-1.1 0-1.99.9-1.99 2L4 20c0 1.1.89 2 1.99 2H18c1.1 0 2-.9 2-2V8l-6-6zm2 14h-3v3h-2v-3H8v-2h3v-3h2v3h3v2zm-3-7V3.5L18.5 9H13z"></path></g>
<g id="offline-pin"><path d="M12 2C6.5 2 2 6.5 2 12s4.5 10 10 10 10-4.5 10-10S17.5 2 12 2zm5 16H7v-2h10v2zm-6.7-4L7 10.7l1.4-1.4 1.9 1.9 5.3-5.3L17 7.3 10.3 14z"></path></g>
<g id="opacity"><path d="M17.66 8L12 2.35 6.34 8C4.78 9.56 4 11.64 4 13.64s.78 4.11 2.34 5.67 3.61 2.35 5.66 2.35 4.1-.79 5.66-2.35S20 15.64 20 13.64 19.22 9.56 17.66 8zM6 14c.01-2 .62-3.27 1.76-4.4L12 5.27l4.24 4.38C17.38 10.77 17.99 12 18 14H6z"></path></g>
<g id="open-in-browser"><path d="M19 4H5c-1.11 0-2 .9-2 2v12c0 1.1.89 2 2 2h4v-2H5V8h14v10h-4v2h4c1.1 0 2-.9 2-2V6c0-1.1-.89-2-2-2zm-7 6l-4 4h3v6h2v-6h3l-4-4z"></path></g>
<g id="open-in-new"><path d="M19 19H5V5h7V3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2v-7h-2v7zM14 3v2h3.59l-9.83 9.83 1.41 1.41L19 6.41V10h2V3h-7z"></path></g>
<g id="open-with"><path d="M10 9h4V6h3l-5-5-5 5h3v3zm-1 1H6V7l-5 5 5 5v-3h3v-4zm14 2l-5-5v3h-3v4h3v3l5-5zm-9 3h-4v3H7l5 5 5-5h-3v-3z"></path></g>
<g id="pageview"><path d="M11.5 9C10.12 9 9 10.12 9 11.5s1.12 2.5 2.5 2.5 2.5-1.12 2.5-2.5S12.88 9 11.5 9zM20 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm-3.21 14.21l-2.91-2.91c-.69.44-1.51.7-2.39.7C9.01 16 7 13.99 7 11.5S9.01 7 11.5 7 16 9.01 16 11.5c0 .88-.26 1.69-.7 2.39l2.91 2.9-1.42 1.42z"></path></g>
<g id="pan-tool"><path d="M23 5.5V20c0 2.2-1.8 4-4 4h-7.3c-1.08 0-2.1-.43-2.85-1.19L1 14.83s1.26-1.23 1.3-1.25c.22-.19.49-.29.79-.29.22 0 .42.06.6.16.04.01 4.31 2.46 4.31 2.46V4c0-.83.67-1.5 1.5-1.5S11 3.17 11 4v7h1V1.5c0-.83.67-1.5 1.5-1.5S15 .67 15 1.5V11h1V2.5c0-.83.67-1.5 1.5-1.5s1.5.67 1.5 1.5V11h1V5.5c0-.83.67-1.5 1.5-1.5s1.5.67 1.5 1.5z"></path></g>
<g id="payment"><path d="M20 4H4c-1.11 0-1.99.89-1.99 2L2 18c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V6c0-1.11-.89-2-2-2zm0 14H4v-6h16v6zm0-10H4V6h16v2z"></path></g>
<g id="perm-camera-mic"><path d="M20 5h-3.17L15 3H9L7.17 5H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h7v-2.09c-2.83-.48-5-2.94-5-5.91h2c0 2.21 1.79 4 4 4s4-1.79 4-4h2c0 2.97-2.17 5.43-5 5.91V21h7c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm-6 8c0 1.1-.9 2-2 2s-2-.9-2-2V9c0-1.1.9-2 2-2s2 .9 2 2v4z"></path></g>
<g id="perm-contact-calendar"><path d="M19 3h-1V1h-2v2H8V1H6v2H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 3c1.66 0 3 1.34 3 3s-1.34 3-3 3-3-1.34-3-3 1.34-3 3-3zm6 12H6v-1c0-2 4-3.1 6-3.1s6 1.1 6 3.1v1z"></path></g>
<g id="perm-data-setting"><path d="M18.99 11.5c.34 0 .67.03 1 .07L20 0 0 20h11.56c-.04-.33-.07-.66-.07-1 0-4.14 3.36-7.5 7.5-7.5zm3.71 7.99c.02-.16.04-.32.04-.49 0-.17-.01-.33-.04-.49l1.06-.83c.09-.08.12-.21.06-.32l-1-1.73c-.06-.11-.19-.15-.31-.11l-1.24.5c-.26-.2-.54-.37-.85-.49l-.19-1.32c-.01-.12-.12-.21-.24-.21h-2c-.12 0-.23.09-.25.21l-.19 1.32c-.3.13-.59.29-.85.49l-1.24-.5c-.11-.04-.24 0-.31.11l-1 1.73c-.06.11-.04.24.06.32l1.06.83c-.02.16-.03.32-.03.49 0 .17.01.33.03.49l-1.06.83c-.09.08-.12.21-.06.32l1 1.73c.06.11.19.15.31.11l1.24-.5c.26.2.54.37.85.49l.19 1.32c.02.12.12.21.25.21h2c.12 0 .23-.09.25-.21l.19-1.32c.3-.13.59-.29.84-.49l1.25.5c.11.04.24 0 .31-.11l1-1.73c.06-.11.03-.24-.06-.32l-1.07-.83zm-3.71 1.01c-.83 0-1.5-.67-1.5-1.5s.67-1.5 1.5-1.5 1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"></path></g>
<g id="perm-device-information"><path d="M13 7h-2v2h2V7zm0 4h-2v6h2v-6zm4-9.99L7 1c-1.1 0-2 .9-2 2v18c0 1.1.9 2 2 2h10c1.1 0 2-.9 2-2V3c0-1.1-.9-1.99-2-1.99zM17 19H7V5h10v14z"></path></g>
<g id="perm-identity"><path d="M12 5.9c1.16 0 2.1.94 2.1 2.1s-.94 2.1-2.1 2.1S9.9 9.16 9.9 8s.94-2.1 2.1-2.1m0 9c2.97 0 6.1 1.46 6.1 2.1v1.1H5.9V17c0-.64 3.13-2.1 6.1-2.1M12 4C9.79 4 8 5.79 8 8s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm0 9c-2.67 0-8 1.34-8 4v3h16v-3c0-2.66-5.33-4-8-4z"></path></g>
<g id="perm-media"><path d="M2 6H0v5h.01L0 20c0 1.1.9 2 2 2h18v-2H2V6zm20-2h-8l-2-2H6c-1.1 0-1.99.9-1.99 2L4 16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zM7 15l4.5-6 3.5 4.51 2.5-3.01L21 15H7z"></path></g>
<g id="perm-phone-msg"><path d="M20 15.5c-1.25 0-2.45-.2-3.57-.57-.35-.11-.74-.03-1.02.24l-2.2 2.2c-2.83-1.44-5.15-3.75-6.59-6.58l2.2-2.21c.28-.27.36-.66.25-1.01C8.7 6.45 8.5 5.25 8.5 4c0-.55-.45-1-1-1H4c-.55 0-1 .45-1 1 0 9.39 7.61 17 17 17 .55 0 1-.45 1-1v-3.5c0-.55-.45-1-1-1zM12 3v10l3-3h6V3h-9z"></path></g>
<g id="perm-scan-wifi"><path d="M12 3C6.95 3 3.15 4.85 0 7.23L12 22 24 7.25C20.85 4.87 17.05 3 12 3zm1 13h-2v-6h2v6zm-2-8V6h2v2h-2z"></path></g>
<g id="pets"><circle cx="4.5" cy="9.5" r="2.5"></circle><circle cx="9" cy="5.5" r="2.5"></circle><circle cx="15" cy="5.5" r="2.5"></circle><circle cx="19.5" cy="9.5" r="2.5"></circle><path d="M17.34 14.86c-.87-1.02-1.6-1.89-2.48-2.91-.46-.54-1.05-1.08-1.75-1.32-.11-.04-.22-.07-.33-.09-.25-.04-.52-.04-.78-.04s-.53 0-.79.05c-.11.02-.22.05-.33.09-.7.24-1.28.78-1.75 1.32-.87 1.02-1.6 1.89-2.48 2.91-1.31 1.31-2.92 2.76-2.62 4.79.29 1.02 1.02 2.03 2.33 2.32.73.15 3.06-.44 5.54-.44h.18c2.48 0 4.81.58 5.54.44 1.31-.29 2.04-1.31 2.33-2.32.31-2.04-1.3-3.49-2.61-4.8z"></path></g>
<g id="picture-in-picture"><path d="M19 7h-8v6h8V7zm2-4H3c-1.1 0-2 .9-2 2v14c0 1.1.9 1.98 2 1.98h18c1.1 0 2-.88 2-1.98V5c0-1.1-.9-2-2-2zm0 16.01H3V4.98h18v14.03z"></path></g>
<g id="picture-in-picture-alt"><path d="M19 11h-8v6h8v-6zm4 8V4.98C23 3.88 22.1 3 21 3H3c-1.1 0-2 .88-2 1.98V19c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2zm-2 .02H3V4.97h18v14.05z"></path></g>
<g id="play-for-work"><path d="M11 5v5.59H7.5l4.5 4.5 4.5-4.5H13V5h-2zm-5 9c0 3.31 2.69 6 6 6s6-2.69 6-6h-2c0 2.21-1.79 4-4 4s-4-1.79-4-4H6z"></path></g>
<g id="polymer"><path d="M19 4h-4L7.11 16.63 4.5 12 9 4H5L.5 12 5 20h4l7.89-12.63L19.5 12 15 20h4l4.5-8z"></path></g>
<g id="power-settings-new"><path d="M13 3h-2v10h2V3zm4.83 2.17l-1.42 1.42C17.99 7.86 19 9.81 19 12c0 3.87-3.13 7-7 7s-7-3.13-7-7c0-2.19 1.01-4.14 2.58-5.42L6.17 5.17C4.23 6.82 3 9.26 3 12c0 4.97 4.03 9 9 9s9-4.03 9-9c0-2.74-1.23-5.18-3.17-6.83z"></path></g>
<g id="pregnant-woman"><path d="M9 4c0-1.11.89-2 2-2s2 .89 2 2-.89 2-2 2-2-.89-2-2zm7 9c-.01-1.34-.83-2.51-2-3 0-1.66-1.34-3-3-3s-3 1.34-3 3v7h2v5h3v-5h3v-4z"></path></g>
<g id="print"><path d="M19 8H5c-1.66 0-3 1.34-3 3v6h4v4h12v-4h4v-6c0-1.66-1.34-3-3-3zm-3 11H8v-5h8v5zm3-7c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1zm-1-9H6v4h12V3z"></path></g>
<g id="query-builder"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm.5-13H11v6l5.25 3.15.75-1.23-4.5-2.67z"></path></g>
<g id="question-answer"><path d="M21 6h-2v9H6v2c0 .55.45 1 1 1h11l4 4V7c0-.55-.45-1-1-1zm-4 6V3c0-.55-.45-1-1-1H3c-.55 0-1 .45-1 1v14l4-4h10c.55 0 1-.45 1-1z"></path></g>
<g id="radio-button-checked"><path d="M12 7c-2.76 0-5 2.24-5 5s2.24 5 5 5 5-2.24 5-5-2.24-5-5-5zm0-5C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"></path></g>
<g id="radio-button-unchecked"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"></path></g>
<g id="receipt"><path d="M18 17H6v-2h12v2zm0-4H6v-2h12v2zm0-4H6V7h12v2zM3 22l1.5-1.5L6 22l1.5-1.5L9 22l1.5-1.5L12 22l1.5-1.5L15 22l1.5-1.5L18 22l1.5-1.5L21 22V2l-1.5 1.5L18 2l-1.5 1.5L15 2l-1.5 1.5L12 2l-1.5 1.5L9 2 7.5 3.5 6 2 4.5 3.5 3 2v20z"></path></g>
<g id="record-voice-over"><circle cx="9" cy="9" r="4"></circle><path d="M9 15c-2.67 0-8 1.34-8 4v2h16v-2c0-2.66-5.33-4-8-4zm7.76-9.64l-1.68 1.69c.84 1.18.84 2.71 0 3.89l1.68 1.69c2.02-2.02 2.02-5.07 0-7.27zM20.07 2l-1.63 1.63c2.77 3.02 2.77 7.56 0 10.74L20.07 16c3.9-3.89 3.91-9.95 0-14z"></path></g>
<g id="redeem"><path d="M20 6h-2.18c.11-.31.18-.65.18-1 0-1.66-1.34-3-3-3-1.05 0-1.96.54-2.5 1.35l-.5.67-.5-.68C10.96 2.54 10.05 2 9 2 7.34 2 6 3.34 6 5c0 .35.07.69.18 1H4c-1.11 0-1.99.89-1.99 2L2 19c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zm-5-2c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zM9 4c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm11 15H4v-2h16v2zm0-5H4V8h5.08L7 10.83 8.62 12 11 8.76l1-1.36 1 1.36L15.38 12 17 10.83 14.92 8H20v6z"></path></g>
<g id="redo"><path d="M18.4 10.6C16.55 8.99 14.15 8 11.5 8c-4.65 0-8.58 3.03-9.96 7.22L3.9 16c1.05-3.19 4.05-5.5 7.6-5.5 1.95 0 3.73.72 5.12 1.88L13 16h9V7l-3.6 3.6z"></path></g>
<g id="refresh"><path d="M17.65 6.35C16.2 4.9 14.21 4 12 4c-4.42 0-7.99 3.58-7.99 8s3.57 8 7.99 8c3.73 0 6.84-2.55 7.73-6h-2.08c-.82 2.33-3.04 4-5.65 4-3.31 0-6-2.69-6-6s2.69-6 6-6c1.66 0 3.14.69 4.22 1.78L13 11h7V4l-2.35 2.35z"></path></g>
<g id="remove"><path d="M19 13H5v-2h14v2z"></path></g>
<g id="remove-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm5 11H7v-2h10v2z"></path></g>
<g id="remove-circle-outline"><path d="M7 11v2h10v-2H7zm5-9C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="remove-shopping-cart"><path d="M22.73 22.73L2.77 2.77 2 2l-.73-.73L0 2.54l4.39 4.39 2.21 4.66-1.35 2.45c-.16.28-.25.61-.25.96 0 1.1.9 2 2 2h7.46l1.38 1.38c-.5.36-.83.95-.83 1.62 0 1.1.89 2 1.99 2 .67 0 1.26-.33 1.62-.84L21.46 24l1.27-1.27zM7.42 15c-.14 0-.25-.11-.25-.25l.03-.12.9-1.63h2.36l2 2H7.42zm8.13-2c.75 0 1.41-.41 1.75-1.03l3.58-6.49c.08-.14.12-.31.12-.48 0-.55-.45-1-1-1H6.54l9.01 9zM7 18c-1.1 0-1.99.9-1.99 2S5.9 22 7 22s2-.9 2-2-.9-2-2-2z"></path></g>
<g id="reorder"><path d="M3 15h18v-2H3v2zm0 4h18v-2H3v2zm0-8h18V9H3v2zm0-6v2h18V5H3z"></path></g>
<g id="reply"><path d="M10 9V5l-7 7 7 7v-4.1c5 0 8.5 1.6 11 5.1-1-5-4-10-11-11z"></path></g>
<g id="reply-all"><path d="M7 8V5l-7 7 7 7v-3l-4-4 4-4zm6 1V5l-7 7 7 7v-4.1c5 0 8.5 1.6 11 5.1-1-5-4-10-11-11z"></path></g>
<g id="report"><path d="M15.73 3H8.27L3 8.27v7.46L8.27 21h7.46L21 15.73V8.27L15.73 3zM12 17.3c-.72 0-1.3-.58-1.3-1.3 0-.72.58-1.3 1.3-1.3.72 0 1.3.58 1.3 1.3 0 .72-.58 1.3-1.3 1.3zm1-4.3h-2V7h2v6z"></path></g>
<g id="report-problem"><path d="M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z"></path></g>
<g id="restore"><path d="M13 3c-4.97 0-9 4.03-9 9H1l3.89 3.89.07.14L9 12H6c0-3.87 3.13-7 7-7s7 3.13 7 7-3.13 7-7 7c-1.93 0-3.68-.79-4.94-2.06l-1.42 1.42C8.27 19.99 10.51 21 13 21c4.97 0 9-4.03 9-9s-4.03-9-9-9zm-1 5v5l4.28 2.54.72-1.21-3.5-2.08V8H12z"></path></g>
<g id="restore-page"><path d="M14 2H6c-1.1 0-1.99.9-1.99 2L4 20c0 1.1.89 2 1.99 2H18c1.1 0 2-.9 2-2V8l-6-6zm-2 16c-2.05 0-3.81-1.24-4.58-3h1.71c.63.9 1.68 1.5 2.87 1.5 1.93 0 3.5-1.57 3.5-3.5S13.93 9.5 12 9.5c-1.35 0-2.52.78-3.1 1.9l1.6 1.6h-4V9l1.3 1.3C8.69 8.92 10.23 8 12 8c2.76 0 5 2.24 5 5s-2.24 5-5 5z"></path></g>
<g id="room"><path d="M12 2C8.13 2 5 5.13 5 9c0 5.25 7 13 7 13s7-7.75 7-13c0-3.87-3.13-7-7-7zm0 9.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5z"></path></g>
<g id="rounded-corner"><path d="M19 19h2v2h-2v-2zm0-2h2v-2h-2v2zM3 13h2v-2H3v2zm0 4h2v-2H3v2zm0-8h2V7H3v2zm0-4h2V3H3v2zm4 0h2V3H7v2zm8 16h2v-2h-2v2zm-4 0h2v-2h-2v2zm4 0h2v-2h-2v2zm-8 0h2v-2H7v2zm-4 0h2v-2H3v2zM21 8c0-2.76-2.24-5-5-5h-5v2h5c1.65 0 3 1.35 3 3v5h2V8z"></path></g>
<g id="rowing"><path d="M8.5 14.5L4 19l1.5 1.5L9 17h2l-2.5-2.5zM15 1c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm6 20.01L18 24l-2.99-3.01V19.5l-7.1-7.09c-.31.05-.61.07-.91.07v-2.16c1.66.03 3.61-.87 4.67-2.04l1.4-1.55c.19-.21.43-.38.69-.5.29-.14.62-.23.96-.23h.03C15.99 6.01 17 7.02 17 8.26v5.75c0 .84-.35 1.61-.92 2.16l-3.58-3.58v-2.27c-.63.52-1.43 1.02-2.29 1.39L16.5 18H18l3 3.01z"></path></g>
<g id="save"><path d="M17 3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V7l-4-4zm-5 16c-1.66 0-3-1.34-3-3s1.34-3 3-3 3 1.34 3 3-1.34 3-3 3zm3-10H5V5h10v4z"></path></g>
<g id="schedule"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm.5-13H11v6l5.25 3.15.75-1.23-4.5-2.67z"></path></g>
<g id="search"><path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z"></path></g>
<g id="select-all"><path d="M3 5h2V3c-1.1 0-2 .9-2 2zm0 8h2v-2H3v2zm4 8h2v-2H7v2zM3 9h2V7H3v2zm10-6h-2v2h2V3zm6 0v2h2c0-1.1-.9-2-2-2zM5 21v-2H3c0 1.1.9 2 2 2zm-2-4h2v-2H3v2zM9 3H7v2h2V3zm2 18h2v-2h-2v2zm8-8h2v-2h-2v2zm0 8c1.1 0 2-.9 2-2h-2v2zm0-12h2V7h-2v2zm0 8h2v-2h-2v2zm-4 4h2v-2h-2v2zm0-16h2V3h-2v2zM7 17h10V7H7v10zm2-8h6v6H9V9z"></path></g>
<g id="send"><path d="M2.01 21L23 12 2.01 3 2 10l15 2-15 2z"></path></g>
<g id="settings"><path d="M19.43 12.98c.04-.32.07-.64.07-.98s-.03-.66-.07-.98l2.11-1.65c.19-.15.24-.42.12-.64l-2-3.46c-.12-.22-.39-.3-.61-.22l-2.49 1c-.52-.4-1.08-.73-1.69-.98l-.38-2.65C14.46 2.18 14.25 2 14 2h-4c-.25 0-.46.18-.49.42l-.38 2.65c-.61.25-1.17.59-1.69.98l-2.49-1c-.23-.09-.49 0-.61.22l-2 3.46c-.13.22-.07.49.12.64l2.11 1.65c-.04.32-.07.65-.07.98s.03.66.07.98l-2.11 1.65c-.19.15-.24.42-.12.64l2 3.46c.12.22.39.3.61.22l2.49-1c.52.4 1.08.73 1.69.98l.38 2.65c.03.24.24.42.49.42h4c.25 0 .46-.18.49-.42l.38-2.65c.61-.25 1.17-.59 1.69-.98l2.49 1c.23.09.49 0 .61-.22l2-3.46c.12-.22.07-.49-.12-.64l-2.11-1.65zM12 15.5c-1.93 0-3.5-1.57-3.5-3.5s1.57-3.5 3.5-3.5 3.5 1.57 3.5 3.5-1.57 3.5-3.5 3.5z"></path></g>
<g id="settings-applications"><path d="M12 10c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm7-7H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.11 0 2-.9 2-2V5c0-1.1-.89-2-2-2zm-1.75 9c0 .23-.02.46-.05.68l1.48 1.16c.13.11.17.3.08.45l-1.4 2.42c-.09.15-.27.21-.43.15l-1.74-.7c-.36.28-.76.51-1.18.69l-.26 1.85c-.03.17-.18.3-.35.3h-2.8c-.17 0-.32-.13-.35-.29l-.26-1.85c-.43-.18-.82-.41-1.18-.69l-1.74.7c-.16.06-.34 0-.43-.15l-1.4-2.42c-.09-.15-.05-.34.08-.45l1.48-1.16c-.03-.23-.05-.46-.05-.69 0-.23.02-.46.05-.68l-1.48-1.16c-.13-.11-.17-.3-.08-.45l1.4-2.42c.09-.15.27-.21.43-.15l1.74.7c.36-.28.76-.51 1.18-.69l.26-1.85c.03-.17.18-.3.35-.3h2.8c.17 0 .32.13.35.29l.26 1.85c.43.18.82.41 1.18.69l1.74-.7c.16-.06.34 0 .43.15l1.4 2.42c.09.15.05.34-.08.45l-1.48 1.16c.03.23.05.46.05.69z"></path></g>
<g id="settings-backup-restore"><path d="M14 12c0-1.1-.9-2-2-2s-2 .9-2 2 .9 2 2 2 2-.9 2-2zm-2-9c-4.97 0-9 4.03-9 9H0l4 4 4-4H5c0-3.87 3.13-7 7-7s7 3.13 7 7-3.13 7-7 7c-1.51 0-2.91-.49-4.06-1.3l-1.42 1.44C8.04 20.3 9.94 21 12 21c4.97 0 9-4.03 9-9s-4.03-9-9-9z"></path></g>
<g id="settings-bluetooth"><path d="M11 24h2v-2h-2v2zm-4 0h2v-2H7v2zm8 0h2v-2h-2v2zm2.71-18.29L12 0h-1v7.59L6.41 3 5 4.41 10.59 10 5 15.59 6.41 17 11 12.41V20h1l5.71-5.71-4.3-4.29 4.3-4.29zM13 3.83l1.88 1.88L13 7.59V3.83zm1.88 10.46L13 16.17v-3.76l1.88 1.88z"></path></g>
<g id="settings-brightness"><path d="M21 3H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16.01H3V4.99h18v14.02zM8 16h2.5l1.5 1.5 1.5-1.5H16v-2.5l1.5-1.5-1.5-1.5V8h-2.5L12 6.5 10.5 8H8v2.5L6.5 12 8 13.5V16zm4-7c1.66 0 3 1.34 3 3s-1.34 3-3 3V9z"></path></g>
<g id="settings-cell"><path d="M7 24h2v-2H7v2zm4 0h2v-2h-2v2zm4 0h2v-2h-2v2zM16 .01L8 0C6.9 0 6 .9 6 2v16c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V2c0-1.1-.9-1.99-2-1.99zM16 16H8V4h8v12z"></path></g>
<g id="settings-ethernet"><path d="M7.77 6.76L6.23 5.48.82 12l5.41 6.52 1.54-1.28L3.42 12l4.35-5.24zM7 13h2v-2H7v2zm10-2h-2v2h2v-2zm-6 2h2v-2h-2v2zm6.77-7.52l-1.54 1.28L20.58 12l-4.35 5.24 1.54 1.28L23.18 12l-5.41-6.52z"></path></g>
<g id="settings-input-antenna"><path d="M12 5c-3.87 0-7 3.13-7 7h2c0-2.76 2.24-5 5-5s5 2.24 5 5h2c0-3.87-3.13-7-7-7zm1 9.29c.88-.39 1.5-1.26 1.5-2.29 0-1.38-1.12-2.5-2.5-2.5S9.5 10.62 9.5 12c0 1.02.62 1.9 1.5 2.29v3.3L7.59 21 9 22.41l3-3 3 3L16.41 21 13 17.59v-3.3zM12 1C5.93 1 1 5.93 1 12h2c0-4.97 4.03-9 9-9s9 4.03 9 9h2c0-6.07-4.93-11-11-11z"></path></g>
<g id="settings-input-component"><path d="M5 2c0-.55-.45-1-1-1s-1 .45-1 1v4H1v6h6V6H5V2zm4 14c0 1.3.84 2.4 2 2.82V23h2v-4.18c1.16-.41 2-1.51 2-2.82v-2H9v2zm-8 0c0 1.3.84 2.4 2 2.82V23h2v-4.18C6.16 18.4 7 17.3 7 16v-2H1v2zM21 6V2c0-.55-.45-1-1-1s-1 .45-1 1v4h-2v6h6V6h-2zm-8-4c0-.55-.45-1-1-1s-1 .45-1 1v4H9v6h6V6h-2V2zm4 14c0 1.3.84 2.4 2 2.82V23h2v-4.18c1.16-.41 2-1.51 2-2.82v-2h-6v2z"></path></g>
<g id="settings-input-composite"><path d="M5 2c0-.55-.45-1-1-1s-1 .45-1 1v4H1v6h6V6H5V2zm4 14c0 1.3.84 2.4 2 2.82V23h2v-4.18c1.16-.41 2-1.51 2-2.82v-2H9v2zm-8 0c0 1.3.84 2.4 2 2.82V23h2v-4.18C6.16 18.4 7 17.3 7 16v-2H1v2zM21 6V2c0-.55-.45-1-1-1s-1 .45-1 1v4h-2v6h6V6h-2zm-8-4c0-.55-.45-1-1-1s-1 .45-1 1v4H9v6h6V6h-2V2zm4 14c0 1.3.84 2.4 2 2.82V23h2v-4.18c1.16-.41 2-1.51 2-2.82v-2h-6v2z"></path></g>
<g id="settings-input-hdmi"><path d="M18 7V4c0-1.1-.9-2-2-2H8c-1.1 0-2 .9-2 2v3H5v6l3 6v3h8v-3l3-6V7h-1zM8 4h8v3h-2V5h-1v2h-2V5h-1v2H8V4z"></path></g>
<g id="settings-input-svideo"><path d="M8 11.5c0-.83-.67-1.5-1.5-1.5S5 10.67 5 11.5 5.67 13 6.5 13 8 12.33 8 11.5zm7-5c0-.83-.67-1.5-1.5-1.5h-3C9.67 5 9 5.67 9 6.5S9.67 8 10.5 8h3c.83 0 1.5-.67 1.5-1.5zM8.5 15c-.83 0-1.5.67-1.5 1.5S7.67 18 8.5 18s1.5-.67 1.5-1.5S9.33 15 8.5 15zM12 1C5.93 1 1 5.93 1 12s4.93 11 11 11 11-4.93 11-11S18.07 1 12 1zm0 20c-4.96 0-9-4.04-9-9s4.04-9 9-9 9 4.04 9 9-4.04 9-9 9zm5.5-11c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5zm-2 5c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5z"></path></g>
<g id="settings-overscan"><path d="M12.01 5.5L10 8h4l-1.99-2.5zM18 10v4l2.5-1.99L18 10zM6 10l-2.5 2.01L6 14v-4zm8 6h-4l2.01 2.5L14 16zm7-13H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16.01H3V4.99h18v14.02z"></path></g>
<g id="settings-phone"><path d="M13 9h-2v2h2V9zm4 0h-2v2h2V9zm3 6.5c-1.25 0-2.45-.2-3.57-.57-.35-.11-.74-.03-1.02.24l-2.2 2.2c-2.83-1.44-5.15-3.75-6.59-6.58l2.2-2.21c.28-.27.36-.66.25-1.01C8.7 6.45 8.5 5.25 8.5 4c0-.55-.45-1-1-1H4c-.55 0-1 .45-1 1 0 9.39 7.61 17 17 17 .55 0 1-.45 1-1v-3.5c0-.55-.45-1-1-1zM19 9v2h2V9h-2z"></path></g>
<g id="settings-power"><path d="M7 24h2v-2H7v2zm4 0h2v-2h-2v2zm2-22h-2v10h2V2zm3.56 2.44l-1.45 1.45C16.84 6.94 18 8.83 18 11c0 3.31-2.69 6-6 6s-6-2.69-6-6c0-2.17 1.16-4.06 2.88-5.12L7.44 4.44C5.36 5.88 4 8.28 4 11c0 4.42 3.58 8 8 8s8-3.58 8-8c0-2.72-1.36-5.12-3.44-6.56zM15 24h2v-2h-2v2z"></path></g>
<g id="settings-remote"><path d="M15 9H9c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h6c.55 0 1-.45 1-1V10c0-.55-.45-1-1-1zm-3 6c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zM7.05 6.05l1.41 1.41C9.37 6.56 10.62 6 12 6s2.63.56 3.54 1.46l1.41-1.41C15.68 4.78 13.93 4 12 4s-3.68.78-4.95 2.05zM12 0C8.96 0 6.21 1.23 4.22 3.22l1.41 1.41C7.26 3.01 9.51 2 12 2s4.74 1.01 6.36 2.64l1.41-1.41C17.79 1.23 15.04 0 12 0z"></path></g>
<g id="settings-voice"><path d="M7 24h2v-2H7v2zm5-11c1.66 0 2.99-1.34 2.99-3L15 4c0-1.66-1.34-3-3-3S9 2.34 9 4v6c0 1.66 1.34 3 3 3zm-1 11h2v-2h-2v2zm4 0h2v-2h-2v2zm4-14h-1.7c0 3-2.54 5.1-5.3 5.1S6.7 13 6.7 10H5c0 3.41 2.72 6.23 6 6.72V20h2v-3.28c3.28-.49 6-3.31 6-6.72z"></path></g>
<g id="shop"><path d="M16 6V4c0-1.11-.89-2-2-2h-4c-1.11 0-2 .89-2 2v2H2v13c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V6h-6zm-6-2h4v2h-4V4zM9 18V9l7.5 4L9 18z"></path></g>
<g id="shop-two"><path d="M3 9H1v11c0 1.11.89 2 2 2h14c1.11 0 2-.89 2-2H3V9zm15-4V3c0-1.11-.89-2-2-2h-4c-1.11 0-2 .89-2 2v2H5v11c0 1.11.89 2 2 2h14c1.11 0 2-.89 2-2V5h-5zm-6-2h4v2h-4V3zm0 12V8l5.5 3-5.5 4z"></path></g>
<g id="shopping-basket"><path d="M17.21 9l-4.38-6.56c-.19-.28-.51-.42-.83-.42-.32 0-.64.14-.83.43L6.79 9H2c-.55 0-1 .45-1 1 0 .09.01.18.04.27l2.54 9.27c.23.84 1 1.46 1.92 1.46h13c.92 0 1.69-.62 1.93-1.46l2.54-9.27L23 10c0-.55-.45-1-1-1h-4.79zM9 9l3-4.4L15 9H9zm3 8c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2z"></path></g>
<g id="shopping-cart"><path d="M7 18c-1.1 0-1.99.9-1.99 2S5.9 22 7 22s2-.9 2-2-.9-2-2-2zM1 2v2h2l3.6 7.59-1.35 2.45c-.16.28-.25.61-.25.96 0 1.1.9 2 2 2h12v-2H7.42c-.14 0-.25-.11-.25-.25l.03-.12.9-1.63h7.45c.75 0 1.41-.41 1.75-1.03l3.58-6.49c.08-.14.12-.31.12-.48 0-.55-.45-1-1-1H5.21l-.94-2H1zm16 16c-1.1 0-1.99.9-1.99 2s.89 2 1.99 2 2-.9 2-2-.9-2-2-2z"></path></g>
<g id="sort"><path d="M3 18h6v-2H3v2zM3 6v2h18V6H3zm0 7h12v-2H3v2z"></path></g>
<g id="speaker-notes"><path d="M20 2H4c-1.1 0-1.99.9-1.99 2L2 22l4-4h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM8 14H6v-2h2v2zm0-3H6V9h2v2zm0-3H6V6h2v2zm7 6h-5v-2h5v2zm3-3h-8V9h8v2zm0-3h-8V6h8v2z"></path></g>
<g id="speaker-notes-off"><path d="M10.54 11l-.54-.54L7.54 8 6 6.46 2.38 2.84 1.27 1.73 0 3l2.01 2.01L2 22l4-4h9l5.73 5.73L22 22.46 17.54 18l-7-7zM8 14H6v-2h2v2zm-2-3V9l2 2H6zm14-9H4.08L10 7.92V6h8v2h-7.92l1 1H18v2h-4.92l6.99 6.99C21.14 17.95 22 17.08 22 16V4c0-1.1-.9-2-2-2z"></path></g>
<g id="spellcheck"><path d="M12.45 16h2.09L9.43 3H7.57L2.46 16h2.09l1.12-3h5.64l1.14 3zm-6.02-5L8.5 5.48 10.57 11H6.43zm15.16.59l-8.09 8.09L9.83 16l-1.41 1.41 5.09 5.09L23 13l-1.41-1.41z"></path></g>
<g id="star"><path d="M12 17.27L18.18 21l-1.64-7.03L22 9.24l-7.19-.61L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21z"></path></g>
<g id="star-border"><path d="M22 9.24l-7.19-.62L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21 12 17.27 18.18 21l-1.63-7.03L22 9.24zM12 15.4l-3.76 2.27 1-4.28-3.32-2.88 4.38-.38L12 6.1l1.71 4.04 4.38.38-3.32 2.88 1 4.28L12 15.4z"></path></g>
<g id="star-half"><path d="M22 9.24l-7.19-.62L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21 12 17.27 18.18 21l-1.63-7.03L22 9.24zM12 15.4V6.1l1.71 4.04 4.38.38-3.32 2.88 1 4.28L12 15.4z"></path></g>
<g id="stars"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zm4.24 16L12 15.45 7.77 18l1.12-4.81-3.73-3.23 4.92-.42L12 5l1.92 4.53 4.92.42-3.73 3.23L16.23 18z"></path></g>
<g id="store"><path d="M20 4H4v2h16V4zm1 10v-2l-1-5H4l-1 5v2h1v6h10v-6h4v6h2v-6h1zm-9 4H6v-4h6v4z"></path></g>
<g id="subdirectory-arrow-left"><path d="M11 9l1.42 1.42L8.83 14H18V4h2v12H8.83l3.59 3.58L11 21l-6-6 6-6z"></path></g>
<g id="subdirectory-arrow-right"><path d="M19 15l-6 6-1.42-1.42L15.17 16H4V4h2v10h9.17l-3.59-3.58L13 9l6 6z"></path></g>
<g id="subject"><path d="M14 17H4v2h10v-2zm6-8H4v2h16V9zM4 15h16v-2H4v2zM4 5v2h16V5H4z"></path></g>
<g id="supervisor-account"><path d="M16.5 12c1.38 0 2.49-1.12 2.49-2.5S17.88 7 16.5 7C15.12 7 14 8.12 14 9.5s1.12 2.5 2.5 2.5zM9 11c1.66 0 2.99-1.34 2.99-3S10.66 5 9 5C7.34 5 6 6.34 6 8s1.34 3 3 3zm7.5 3c-1.83 0-5.5.92-5.5 2.75V19h11v-2.25c0-1.83-3.67-2.75-5.5-2.75zM9 13c-2.33 0-7 1.17-7 3.5V19h7v-2.25c0-.85.33-2.34 2.37-3.47C10.5 13.1 9.66 13 9 13z"></path></g>
<g id="swap-horiz"><path d="M6.99 11L3 15l3.99 4v-3H14v-2H6.99v-3zM21 9l-3.99-4v3H10v2h7.01v3L21 9z"></path></g>
<g id="swap-vert"><path d="M16 17.01V10h-2v7.01h-3L15 21l4-3.99h-3zM9 3L5 6.99h3V14h2V6.99h3L9 3z"></path></g>
<g id="swap-vertical-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zM6.5 9L10 5.5 13.5 9H11v4H9V9H6.5zm11 6L14 18.5 10.5 15H13v-4h2v4h2.5z"></path></g>
<g id="system-update-alt"><path d="M12 16.5l4-4h-3v-9h-2v9H8l4 4zm9-13h-6v1.99h6v14.03H3V5.49h6V3.5H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2v-14c0-1.1-.9-2-2-2z"></path></g>
<g id="tab"><path d="M21 3H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H3V5h10v4h8v10z"></path></g>
<g id="tab-unselected"><path d="M1 9h2V7H1v2zm0 4h2v-2H1v2zm0-8h2V3c-1.1 0-2 .9-2 2zm8 16h2v-2H9v2zm-8-4h2v-2H1v2zm2 4v-2H1c0 1.1.9 2 2 2zM21 3h-8v6h10V5c0-1.1-.9-2-2-2zm0 14h2v-2h-2v2zM9 5h2V3H9v2zM5 21h2v-2H5v2zM5 5h2V3H5v2zm16 16c1.1 0 2-.9 2-2h-2v2zm0-8h2v-2h-2v2zm-8 8h2v-2h-2v2zm4 0h2v-2h-2v2z"></path></g>
<g id="text-format"><path d="M5 17v2h14v-2H5zm4.5-4.2h5l.9 2.2h2.1L12.75 4h-1.5L6.5 15h2.1l.9-2.2zM12 5.98L13.87 11h-3.74L12 5.98z"></path></g>
<g id="theaters"><path d="M18 3v2h-2V3H8v2H6V3H4v18h2v-2h2v2h8v-2h2v2h2V3h-2zM8 17H6v-2h2v2zm0-4H6v-2h2v2zm0-4H6V7h2v2zm10 8h-2v-2h2v2zm0-4h-2v-2h2v2zm0-4h-2V7h2v2z"></path></g>
<g id="thumb-down"><path d="M15 3H6c-.83 0-1.54.5-1.84 1.22l-3.02 7.05c-.09.23-.14.47-.14.73v1.91l.01.01L1 14c0 1.1.9 2 2 2h6.31l-.95 4.57-.03.32c0 .41.17.79.44 1.06L9.83 23l6.59-6.59c.36-.36.58-.86.58-1.41V5c0-1.1-.9-2-2-2zm4 0v12h4V3h-4z"></path></g>
<g id="thumb-up"><path d="M1 21h4V9H1v12zm22-11c0-1.1-.9-2-2-2h-6.31l.95-4.57.03-.32c0-.41-.17-.79-.44-1.06L14.17 1 7.59 7.59C7.22 7.95 7 8.45 7 9v10c0 1.1.9 2 2 2h9c.83 0 1.54-.5 1.84-1.22l3.02-7.05c.09-.23.14-.47.14-.73v-1.91l-.01-.01L23 10z"></path></g>
<g id="thumbs-up-down"><path d="M12 6c0-.55-.45-1-1-1H5.82l.66-3.18.02-.23c0-.31-.13-.59-.33-.8L5.38 0 .44 4.94C.17 5.21 0 5.59 0 6v6.5c0 .83.67 1.5 1.5 1.5h6.75c.62 0 1.15-.38 1.38-.91l2.26-5.29c.07-.17.11-.36.11-.55V6zm10.5 4h-6.75c-.62 0-1.15.38-1.38.91l-2.26 5.29c-.07.17-.11.36-.11.55V18c0 .55.45 1 1 1h5.18l-.66 3.18-.02.24c0 .31.13.59.33.8l.79.78 4.94-4.94c.27-.27.44-.65.44-1.06v-6.5c0-.83-.67-1.5-1.5-1.5z"></path></g>
<g id="timeline"><path d="M23 8c0 1.1-.9 2-2 2-.18 0-.35-.02-.51-.07l-3.56 3.55c.05.16.07.34.07.52 0 1.1-.9 2-2 2s-2-.9-2-2c0-.18.02-.36.07-.52l-2.55-2.55c-.16.05-.34.07-.52.07s-.36-.02-.52-.07l-4.55 4.56c.05.16.07.33.07.51 0 1.1-.9 2-2 2s-2-.9-2-2 .9-2 2-2c.18 0 .35.02.51.07l4.56-4.55C8.02 9.36 8 9.18 8 9c0-1.1.9-2 2-2s2 .9 2 2c0 .18-.02.36-.07.52l2.55 2.55c.16-.05.34-.07.52-.07s.36.02.52.07l3.55-3.56C19.02 8.35 19 8.18 19 8c0-1.1.9-2 2-2s2 .9 2 2z"></path></g>
<g id="toc"><path d="M3 9h14V7H3v2zm0 4h14v-2H3v2zm0 4h14v-2H3v2zm16 0h2v-2h-2v2zm0-10v2h2V7h-2zm0 6h2v-2h-2v2z"></path></g>
<g id="today"><path d="M19 3h-1V1h-2v2H8V1H6v2H5c-1.11 0-1.99.9-1.99 2L3 19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V8h14v11zM7 10h5v5H7z"></path></g>
<g id="toll"><path d="M15 4c-4.42 0-8 3.58-8 8s3.58 8 8 8 8-3.58 8-8-3.58-8-8-8zm0 14c-3.31 0-6-2.69-6-6s2.69-6 6-6 6 2.69 6 6-2.69 6-6 6zM3 12c0-2.61 1.67-4.83 4-5.65V4.26C3.55 5.15 1 8.27 1 12s2.55 6.85 6 7.74v-2.09c-2.33-.82-4-3.04-4-5.65z"></path></g>
<g id="touch-app"><path d="M9 11.24V7.5C9 6.12 10.12 5 11.5 5S14 6.12 14 7.5v3.74c1.21-.81 2-2.18 2-3.74C16 5.01 13.99 3 11.5 3S7 5.01 7 7.5c0 1.56.79 2.93 2 3.74zm9.84 4.63l-4.54-2.26c-.17-.07-.35-.11-.54-.11H13v-6c0-.83-.67-1.5-1.5-1.5S10 6.67 10 7.5v10.74l-3.43-.72c-.08-.01-.15-.03-.24-.03-.31 0-.59.13-.79.33l-.79.8 4.94 4.94c.27.27.65.44 1.06.44h6.79c.75 0 1.33-.55 1.44-1.28l.75-5.27c.01-.07.02-.14.02-.2 0-.62-.38-1.16-.91-1.38z"></path></g>
<g id="track-changes"><path d="M19.07 4.93l-1.41 1.41C19.1 7.79 20 9.79 20 12c0 4.42-3.58 8-8 8s-8-3.58-8-8c0-4.08 3.05-7.44 7-7.93v2.02C8.16 6.57 6 9.03 6 12c0 3.31 2.69 6 6 6s6-2.69 6-6c0-1.66-.67-3.16-1.76-4.24l-1.41 1.41C15.55 9.9 16 10.9 16 12c0 2.21-1.79 4-4 4s-4-1.79-4-4c0-1.86 1.28-3.41 3-3.86v2.14c-.6.35-1 .98-1 1.72 0 1.1.9 2 2 2s2-.9 2-2c0-.74-.4-1.38-1-1.72V2h-1C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10c0-2.76-1.12-5.26-2.93-7.07z"></path></g>
<g id="translate"><path d="M12.87 15.07l-2.54-2.51.03-.03c1.74-1.94 2.98-4.17 3.71-6.53H17V4h-7V2H8v2H1v1.99h11.17C11.5 7.92 10.44 9.75 9 11.35 8.07 10.32 7.3 9.19 6.69 8h-2c.73 1.63 1.73 3.17 2.98 4.56l-5.09 5.02L4 19l5-5 3.11 3.11.76-2.04zM18.5 10h-2L12 22h2l1.12-3h4.75L21 22h2l-4.5-12zm-2.62 7l1.62-4.33L19.12 17h-3.24z"></path></g>
<g id="trending-down"><path d="M16 18l2.29-2.29-4.88-4.88-4 4L2 7.41 3.41 6l6 6 4-4 6.3 6.29L22 12v6z"></path></g>
<g id="trending-flat"><path d="M22 12l-4-4v3H3v2h15v3z"></path></g>
<g id="trending-up"><path d="M16 6l2.29 2.29-4.88 4.88-4-4L2 16.59 3.41 18l6-6 4 4 6.3-6.29L22 12V6z"></path></g>
<g id="turned-in"><path d="M17 3H7c-1.1 0-1.99.9-1.99 2L5 21l7-3 7 3V5c0-1.1-.9-2-2-2z"></path></g>
<g id="turned-in-not"><path d="M17 3H7c-1.1 0-1.99.9-1.99 2L5 21l7-3 7 3V5c0-1.1-.9-2-2-2zm0 15l-5-2.18L7 18V5h10v13z"></path></g>
<g id="unarchive"><path d="M20.55 5.22l-1.39-1.68C18.88 3.21 18.47 3 18 3H6c-.47 0-.88.21-1.15.55L3.46 5.22C3.17 5.57 3 6.01 3 6.5V19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V6.5c0-.49-.17-.93-.45-1.28zM12 9.5l5.5 5.5H14v2h-4v-2H6.5L12 9.5zM5.12 5l.82-1h12l.93 1H5.12z"></path></g>
<g id="undo"><path d="M12.5 8c-2.65 0-5.05.99-6.9 2.6L2 7v9h9l-3.62-3.62c1.39-1.16 3.16-1.88 5.12-1.88 3.54 0 6.55 2.31 7.6 5.5l2.37-.78C21.08 11.03 17.15 8 12.5 8z"></path></g>
<g id="unfold-less"><path d="M7.41 18.59L8.83 20 12 16.83 15.17 20l1.41-1.41L12 14l-4.59 4.59zm9.18-13.18L15.17 4 12 7.17 8.83 4 7.41 5.41 12 10l4.59-4.59z"></path></g>
<g id="unfold-more"><path d="M12 5.83L15.17 9l1.41-1.41L12 3 7.41 7.59 8.83 9 12 5.83zm0 12.34L8.83 15l-1.41 1.41L12 21l4.59-4.59L15.17 15 12 18.17z"></path></g>
<g id="update"><path d="M21 10.12h-6.78l2.74-2.82c-2.73-2.7-7.15-2.8-9.88-.1-2.73 2.71-2.73 7.08 0 9.79 2.73 2.71 7.15 2.71 9.88 0C18.32 15.65 19 14.08 19 12.1h2c0 1.98-.88 4.55-2.64 6.29-3.51 3.48-9.21 3.48-12.72 0-3.5-3.47-3.53-9.11-.02-12.58 3.51-3.47 9.14-3.47 12.65 0L21 3v7.12zM12.5 8v4.25l3.5 2.08-.72 1.21L11 13V8h1.5z"></path></g>
<g id="verified-user"><path d="M12 1L3 5v6c0 5.55 3.84 10.74 9 12 5.16-1.26 9-6.45 9-12V5l-9-4zm-2 16l-4-4 1.41-1.41L10 14.17l6.59-6.59L18 9l-8 8z"></path></g>
<g id="view-agenda"><path d="M20 13H3c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h17c.55 0 1-.45 1-1v-6c0-.55-.45-1-1-1zm0-10H3c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h17c.55 0 1-.45 1-1V4c0-.55-.45-1-1-1z"></path></g>
<g id="view-array"><path d="M4 18h3V5H4v13zM18 5v13h3V5h-3zM8 18h9V5H8v13z"></path></g>
<g id="view-carousel"><path d="M7 19h10V4H7v15zm-5-2h4V6H2v11zM18 6v11h4V6h-4z"></path></g>
<g id="view-column"><path d="M10 18h5V5h-5v13zm-6 0h5V5H4v13zM16 5v13h5V5h-5z"></path></g>
<g id="view-day"><path d="M2 21h19v-3H2v3zM20 8H3c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h17c.55 0 1-.45 1-1V9c0-.55-.45-1-1-1zM2 3v3h19V3H2z"></path></g>
<g id="view-headline"><path d="M4 15h16v-2H4v2zm0 4h16v-2H4v2zm0-8h16V9H4v2zm0-6v2h16V5H4z"></path></g>
<g id="view-list"><path d="M4 14h4v-4H4v4zm0 5h4v-4H4v4zM4 9h4V5H4v4zm5 5h12v-4H9v4zm0 5h12v-4H9v4zM9 5v4h12V5H9z"></path></g>
<g id="view-module"><path d="M4 11h5V5H4v6zm0 7h5v-6H4v6zm6 0h5v-6h-5v6zm6 0h5v-6h-5v6zm-6-7h5V5h-5v6zm6-6v6h5V5h-5z"></path></g>
<g id="view-quilt"><path d="M10 18h5v-6h-5v6zm-6 0h5V5H4v13zm12 0h5v-6h-5v6zM10 5v6h11V5H10z"></path></g>
<g id="view-stream"><path d="M4 18h17v-6H4v6zM4 5v6h17V5H4z"></path></g>
<g id="view-week"><path d="M6 5H3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h3c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1zm14 0h-3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h3c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1zm-7 0h-3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h3c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1z"></path></g>
<g id="visibility"><path d="M12 4.5C7 4.5 2.73 7.61 1 12c1.73 4.39 6 7.5 11 7.5s9.27-3.11 11-7.5c-1.73-4.39-6-7.5-11-7.5zM12 17c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5zm0-8c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3z"></path></g>
<g id="visibility-off"><path d="M12 7c2.76 0 5 2.24 5 5 0 .65-.13 1.26-.36 1.83l2.92 2.92c1.51-1.26 2.7-2.89 3.43-4.75-1.73-4.39-6-7.5-11-7.5-1.4 0-2.74.25-3.98.7l2.16 2.16C10.74 7.13 11.35 7 12 7zM2 4.27l2.28 2.28.46.46C3.08 8.3 1.78 10.02 1 12c1.73 4.39 6 7.5 11 7.5 1.55 0 3.03-.3 4.38-.84l.42.42L19.73 22 21 20.73 3.27 3 2 4.27zM7.53 9.8l1.55 1.55c-.05.21-.08.43-.08.65 0 1.66 1.34 3 3 3 .22 0 .44-.03.65-.08l1.55 1.55c-.67.33-1.41.53-2.2.53-2.76 0-5-2.24-5-5 0-.79.2-1.53.53-2.2zm4.31-.78l3.15 3.15.02-.16c0-1.66-1.34-3-3-3l-.17.01z"></path></g>
<g id="warning"><path d="M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z"></path></g>
<g id="watch-later"><path d="M12 2C6.5 2 2 6.5 2 12s4.5 10 10 10 10-4.5 10-10S17.5 2 12 2zm4.2 14.2L11 13V7h1.5v5.2l4.5 2.7-.8 1.3z"></path></g>
<g id="weekend"><path d="M21 10c-1.1 0-2 .9-2 2v3H5v-3c0-1.1-.9-2-2-2s-2 .9-2 2v5c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2v-5c0-1.1-.9-2-2-2zm-3-5H6c-1.1 0-2 .9-2 2v2.15c1.16.41 2 1.51 2 2.82V14h12v-2.03c0-1.3.84-2.4 2-2.82V7c0-1.1-.9-2-2-2z"></path></g>
<g id="work"><path d="M20 6h-4V4c0-1.11-.89-2-2-2h-4c-1.11 0-2 .89-2 2v2H4c-1.11 0-1.99.89-1.99 2L2 19c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zm-6 0h-4V4h4v2z"></path></g>
<g id="youtube-searched-for"><path d="M17.01 14h-.8l-.27-.27c.98-1.14 1.57-2.61 1.57-4.23 0-3.59-2.91-6.5-6.5-6.5s-6.5 3-6.5 6.5H2l3.84 4 4.16-4H6.51C6.51 7 8.53 5 11.01 5s4.5 2.01 4.5 4.5c0 2.48-2.02 4.5-4.5 4.5-.65 0-1.26-.14-1.82-.38L7.71 15.1c.97.57 2.09.9 3.3.9 1.61 0 3.08-.59 4.22-1.57l.27.27v.79l5.01 4.99L22 19l-4.99-5z"></path></g>
<g id="zoom-in"><path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14zm2.5-4h-2v2H9v-2H7V9h2V7h1v2h2v1z"></path></g>
<g id="zoom-out"><path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14zM7 9h5v1H7z"></path></g>
</defs></svg>
</iron-iconset-svg>`;document.head.appendChild(dbe.content);var $gt={"U+0008":"backspace","U+0009":"tab","U+001B":"esc","U+0020":"space","U+007F":"del"},mbe={8:"backspace",9:"tab",13:"enter",27:"esc",33:"pageup",34:"pagedown",35:"end",36:"home",32:"space",37:"left",38:"up",39:"right",40:"down",46:"del",106:"*"},Kgt={shift:"shiftKey",ctrl:"ctrlKey",alt:"altKey",meta:"metaKey"},gbe=/[a-z0-9*]/,_be=/U\+/,ybe=/^arrow/,vbe=/^space(bar)?/,xbe=/^escape$/;function Zgt(e,t){var r="";if(e){var n=e.toLowerCase();n===" "||vbe.test(n)?r="space":xbe.test(n)?r="esc":n.length==1?(!t||gbe.test(n))&&(r=n):ybe.test(n)?r=n.replace("arrow",""):n=="multiply"?r="*":r=n}return r}function bbe(e){var t="";return e&&(e in $gt?t=$gt[e]:_be.test(e)?(e=parseInt(e.replace("U+","0x"),16),t=String.fromCharCode(e).toLowerCase()):t=e.toLowerCase()),t}function wbe(e){var t="";return Number(e)&&(e>=65&&e<=90?t=String.fromCharCode(32+e):e>=112&&e<=123?t="f"+(e-112+1):e>=48&&e<=57?t=String(e-48):e>=96&&e<=105?t=String(e-96):t=mbe[e]),t}function Sbe(e,t){return e.key?Zgt(e.key,t):e.detail&&e.detail.key?Zgt(e.detail.key,t):bbe(e.keyIdentifier)||wbe(e.keyCode)||""}function Jgt(e,t){var r=Sbe(t,e.hasModifiers);return r===e.key&&(!e.hasModifiers||!!t.shiftKey==!!e.shiftKey&&!!t.ctrlKey==!!e.ctrlKey&&!!t.altKey==!!e.altKey&&!!t.metaKey==!!e.metaKey)}function Mbe(e){return e.length===1?{combo:e,key:e,event:"keydown"}:e.split("+").reduce(function(t,r){var n=r.split(":"),i=n[0],o=n[1];return i in Kgt?(t[Kgt[i]]=!0,t.hasModifiers=!0):(t.key=i,t.event=o||"keydown"),t},{combo:e.split(":").shift()})}function Qgt(e){return e.trim().split(" ").map(function(t){return Mbe(t)})}var Oo={properties:{keyEventTarget:{type:Object,value:function(){return this}},stopKeyboardEventPropagation:{type:Boolean,value:!1},_boundKeyHandlers:{type:Array,value:function(){return[]}},_imperativeKeyBindings:{type:Object,value:function(){return{}}}},observers:["_resetKeyEventListeners(keyEventTarget, _boundKeyHandlers)"],keyBindings:{},registered:function(){this._prepKeyBindings()},attached:function(){this._listenKeyEventListeners()},detached:function(){this._unlistenKeyEventListeners()},addOwnKeyBinding:function(e,t){this._imperativeKeyBindings[e]=t,this._prepKeyBindings(),this._resetKeyEventListeners()},removeOwnKeyBindings:function(){this._imperativeKeyBindings={},this._prepKeyBindings(),this._resetKeyEventListeners()},keyboardEventMatchesKeys:function(e,t){for(var r=Qgt(t),n=0;n<r.length;++n)if(Jgt(r[n],e))return!0;return!1},_collectKeyBindings:function(){var e=this.behaviors.map(function(t){return t.keyBindings});return e.indexOf(this.keyBindings)===-1&&e.push(this.keyBindings),e},_prepKeyBindings:function(){this._keyBindings={},this._collectKeyBindings().forEach(function(r){for(var n in r)this._addKeyBinding(n,r[n])},this);for(var e in this._imperativeKeyBindings)this._addKeyBinding(e,this._imperativeKeyBindings[e]);for(var t in this._keyBindings)this._keyBindings[t].sort(function(r,n){var i=r[0].hasModifiers,o=n[0].hasModifiers;return i===o?0:i?-1:1})},_addKeyBinding:function(e,t){Qgt(e).forEach(function(r){this._keyBindings[r.event]=this._keyBindings[r.event]||[],this._keyBindings[r.event].push([r,t])},this)},_resetKeyEventListeners:function(){this._unlistenKeyEventListeners(),this.isAttached&&this._listenKeyEventListeners()},_listenKeyEventListeners:function(){!this.keyEventTarget||Object.keys(this._keyBindings).forEach(function(e){var t=this._keyBindings[e],r=this._onKeyBindingEvent.bind(this,t);this._boundKeyHandlers.push([this.keyEventTarget,e,r]),this.keyEventTarget.addEventListener(e,r)},this)},_unlistenKeyEventListeners:function(){for(var e,t,r,n;this._boundKeyHandlers.length;)e=this._boundKeyHandlers.pop(),t=e[0],r=e[1],n=e[2],t.removeEventListener(r,n)},_onKeyBindingEvent:function(e,t){if(this.stopKeyboardEventPropagation&&t.stopPropagation(),!t.defaultPrevented)for(var r=0;r<e.length;r++){var n=e[r][0],i=e[r][1];if(Jgt(n,t)&&(this._triggerKeyHandler(n,i,t),t.defaultPrevented))return}},_triggerKeyHandler:function(e,t,r){var n=Object.create(e);n.keyboardEvent=r;var i=new CustomEvent(e.event,{detail:n,cancelable:!0});this[t].call(this,i),i.defaultPrevented&&r.preventDefault()}};var y9={properties:{scrollTarget:{type:HTMLElement,value:function(){return this._defaultScrollTarget}}},observers:["_scrollTargetChanged(scrollTarget, isAttached)"],_shouldHaveListener:!0,_scrollTargetChanged:function(e,t){var r;if(this._oldScrollTarget&&(this._toggleScrollListener(!1,this._oldScrollTarget),this._oldScrollTarget=null),!!t)if(e==="document")this.scrollTarget=this._doc;else if(typeof e=="string"){var n=this.domHost;this.scrollTarget=n&&n.$?n.$[e]:zt(this.ownerDocument).querySelector("#"+e)}else this._isValidScrollTarget()&&(this._oldScrollTarget=e,this._toggleScrollListener(this._shouldHaveListener,e))},_scrollHandler:function(){},get _defaultScrollTarget(){return this._doc},get _doc(){return this.ownerDocument.documentElement},get _scrollTop(){return this._isValidScrollTarget()?this.scrollTarget===this._doc?window.pageYOffset:this.scrollTarget.scrollTop:0},get _scrollLeft(){return this._isValidScrollTarget()?this.scrollTarget===this._doc?window.pageXOffset:this.scrollTarget.scrollLeft:0},set _scrollTop(e){this.scrollTarget===this._doc?window.scrollTo(window.pageXOffset,e):this._isValidScrollTarget()&&(this.scrollTarget.scrollTop=e)},set _scrollLeft(e){this.scrollTarget===this._doc?window.scrollTo(e,window.pageYOffset):this._isValidScrollTarget()&&(this.scrollTarget.scrollLeft=e)},scroll:function(e,t){var r;typeof e=="object"?(r=e.left,t=e.top):r=e,r=r||0,t=t||0,this.scrollTarget===this._doc?window.scrollTo(r,t):this._isValidScrollTarget()&&(this.scrollTarget.scrollLeft=r,this.scrollTarget.scrollTop=t)},get _scrollTargetWidth(){return this._isValidScrollTarget()?this.scrollTarget===this._doc?window.innerWidth:this.scrollTarget.offsetWidth:0},get _scrollTargetHeight(){return this._isValidScrollTarget()?this.scrollTarget===this._doc?window.innerHeight:this.scrollTarget.offsetHeight:0},_isValidScrollTarget:function(){return this.scrollTarget instanceof HTMLElement},_toggleScrollListener:function(e,t){var r=t===this._doc?window:t;e?this._boundScrollHandler||(this._boundScrollHandler=this._scrollHandler.bind(this),r.addEventListener("scroll",this._boundScrollHandler)):this._boundScrollHandler&&(r.removeEventListener("scroll",this._boundScrollHandler),this._boundScrollHandler=null)},toggleScrollListener:function(e){this._shouldHaveListener=e,this._toggleScrollListener(e,this.scrollTarget)}};var t0t=navigator.userAgent.match(/iP(?:hone|ad;(?: U;)? CPU) OS (\d+)/),Ebe=t0t&&t0t[1]>=8,e0t=3,r0t="-10000px",hE=-100;Yt({_template:Q`
    <style>
      :host {
        display: block;
      }

      @media only screen and (-webkit-max-device-pixel-ratio: 1) {
        :host {
          will-change: transform;
        }
      }

      #items {
        @apply --iron-list-items-container;
        position: relative;
      }

      :host(:not([grid])) #items > ::slotted(*) {
        width: 100%;
      }

      #items > ::slotted(*) {
        box-sizing: border-box;
        margin: 0;
        position: absolute;
        top: 0;
        will-change: transform;
      }
    </style>

    <array-selector id="selector" items="{{items}}" selected="{{selectedItems}}" selected-item="{{selectedItem}}"></array-selector>

    <div id="items">
      <slot></slot>
    </div>
`,is:"iron-list",properties:{items:{type:Array},as:{type:String,value:"item"},indexAs:{type:String,value:"index"},selectedAs:{type:String,value:"selected"},grid:{type:Boolean,value:!1,reflectToAttribute:!0,observer:"_gridChanged"},selectionEnabled:{type:Boolean,value:!1},selectedItem:{type:Object,notify:!0},selectedItems:{type:Object,notify:!0},multiSelection:{type:Boolean,value:!1},scrollOffset:{type:Number,value:0}},observers:["_itemsChanged(items.*)","_selectionEnabledChanged(selectionEnabled)","_multiSelectionChanged(multiSelection)","_setOverflow(scrollTarget, scrollOffset)"],behaviors:[Hgt,Js,y9,Wgt],_ratio:.5,_scrollerPaddingTop:0,_scrollPosition:0,_physicalSize:0,_physicalAverage:0,_physicalAverageCount:0,_physicalTop:0,_virtualCount:0,_estScrollHeight:0,_scrollHeight:0,_viewportHeight:0,_viewportWidth:0,_physicalItems:null,_physicalSizes:null,_firstVisibleIndexVal:null,_lastVisibleIndexVal:null,_maxPages:2,_focusedItem:null,_focusedVirtualIndex:-1,_focusedPhysicalIndex:-1,_offscreenFocusedItem:null,_focusBackfillItem:null,_itemsPerRow:1,_itemWidth:0,_rowHeight:0,_templateCost:0,_parentModel:!0,get _physicalBottom(){return this._physicalTop+this._physicalSize},get _scrollBottom(){return this._scrollPosition+this._viewportHeight},get _virtualEnd(){return this._virtualStart+this._physicalCount-1},get _hiddenContentSize(){var e=this.grid?this._physicalRows*this._rowHeight:this._physicalSize;return e-this._viewportHeight},get _itemsParent(){return zt(zt(this._userTemplate).parentNode)},get _maxScrollTop(){return this._estScrollHeight-this._viewportHeight+this._scrollOffset},get _maxVirtualStart(){var e=this._convertIndexToCompleteRow(this._virtualCount);return Math.max(0,e-this._physicalCount)},set _virtualStart(e){e=this._clamp(e,0,this._maxVirtualStart),this.grid&&(e=e-e%this._itemsPerRow),this._virtualStartVal=e},get _virtualStart(){return this._virtualStartVal||0},set _physicalStart(e){e=e%this._physicalCount,e<0&&(e=this._physicalCount+e),this.grid&&(e=e-e%this._itemsPerRow),this._physicalStartVal=e},get _physicalStart(){return this._physicalStartVal||0},get _physicalEnd(){return(this._physicalStart+this._physicalCount-1)%this._physicalCount},set _physicalCount(e){this._physicalCountVal=e},get _physicalCount(){return this._physicalCountVal||0},get _optPhysicalSize(){return this._viewportHeight===0?1/0:this._viewportHeight*this._maxPages},get _isVisible(){return Boolean(this.offsetWidth||this.offsetHeight)},get firstVisibleIndex(){var e=this._firstVisibleIndexVal;if(e==null){var t=this._physicalTop+this._scrollOffset;e=this._iterateItems(function(r,n){if(t+=this._getPhysicalSizeIncrement(r),t>this._scrollPosition)return this.grid?n-n%this._itemsPerRow:n;if(this.grid&&this._virtualCount-1===n)return n-n%this._itemsPerRow})||0,this._firstVisibleIndexVal=e}return e},get lastVisibleIndex(){var e=this._lastVisibleIndexVal;if(e==null){if(this.grid)e=Math.min(this._virtualCount,this.firstVisibleIndex+this._estRowsInView*this._itemsPerRow-1);else{var t=this._physicalTop+this._scrollOffset;this._iterateItems(function(r,n){t<this._scrollBottom&&(e=n),t+=this._getPhysicalSizeIncrement(r)})}this._lastVisibleIndexVal=e}return e},get _defaultScrollTarget(){return this},get _virtualRowCount(){return Math.ceil(this._virtualCount/this._itemsPerRow)},get _estRowsInView(){return Math.ceil(this._viewportHeight/this._rowHeight)},get _physicalRows(){return Math.ceil(this._physicalCount/this._itemsPerRow)},get _scrollOffset(){return this._scrollerPaddingTop+this.scrollOffset},ready:function(){this.addEventListener("focus",this._didFocus.bind(this),!0)},attached:function(){this._debounce("_render",this._render,Ni),this.listen(this,"iron-resize","_resizeHandler"),this.listen(this,"keydown","_keydownHandler")},detached:function(){this.unlisten(this,"iron-resize","_resizeHandler"),this.unlisten(this,"keydown","_keydownHandler")},_setOverflow:function(e){this.style.webkitOverflowScrolling=e===this?"touch":"",this.style.overflowY=e===this?"auto":"",this._lastVisibleIndexVal=null,this._firstVisibleIndexVal=null,this._debounce("_render",this._render,Ni)},updateViewportBoundaries:function(){var e=window.getComputedStyle(this);this._scrollerPaddingTop=this.scrollTarget===this?0:parseInt(e["padding-top"],10),this._isRTL=Boolean(e.direction==="rtl"),this._viewportWidth=this.$.items.offsetWidth,this._viewportHeight=this._scrollTargetHeight,this.grid&&this._updateGridMetrics()},_scrollHandler:function(){var e=Math.max(0,Math.min(this._maxScrollTop,this._scrollTop)),t=e-this._scrollPosition,r=t>=0;if(this._scrollPosition=e,this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,Math.abs(t)>this._physicalSize&&this._physicalSize>0){t=t-this._scrollOffset;var n=Math.round(t/this._physicalAverage)*this._itemsPerRow;this._virtualStart=this._virtualStart+n,this._physicalStart=this._physicalStart+n,this._physicalTop=Math.min(Math.floor(this._virtualStart/this._itemsPerRow)*this._physicalAverage,this._scrollPosition),this._update()}else if(this._physicalCount>0){var i=this._getReusables(r);r?(this._physicalTop=i.physicalTop,this._virtualStart=this._virtualStart+i.indexes.length,this._physicalStart=this._physicalStart+i.indexes.length):(this._virtualStart=this._virtualStart-i.indexes.length,this._physicalStart=this._physicalStart-i.indexes.length),this._update(i.indexes,r?null:i.indexes),this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,0),ci)}},_getReusables:function(e){var t,r,n,i,o=[],a=this._hiddenContentSize*this._ratio,s=this._virtualStart,l=this._virtualEnd,c=this._physicalCount,u=this._physicalTop+this._scrollOffset,h=this._physicalBottom+this._scrollOffset,f=this._scrollPosition,p=this._scrollBottom;for(e?(t=this._physicalStart,r=this._physicalEnd,n=f-u):(t=this._physicalEnd,r=this._physicalStart,n=h-p);i=this._getPhysicalSizeIncrement(t),n=n-i,!(o.length>=c||n<=a);)if(e){if(l+o.length+1>=this._virtualCount||u+i>=f-this._scrollOffset)break;o.push(t),u=u+i,t=(t+1)%c}else{if(s-o.length<=0||u+this._physicalSize-i<=p)break;o.push(t),u=u-i,t=t===0?c-1:t-1}return{indexes:o,physicalTop:u-this._scrollOffset}},_update:function(e,t){if(!(e&&e.length===0||this._physicalCount===0)){if(this._manageFocus(),this._assignModels(e),this._updateMetrics(e),t)for(;t.length;){var r=t.pop();this._physicalTop-=this._getPhysicalSizeIncrement(r)}this._positionItems(),this._updateScrollerSize()}},_createPool:function(e){this._ensureTemplatized();var t,r,n=new Array(e);for(t=0;t<e;t++)r=this.stamp(null),n[t]=r.root.querySelector("*"),this._itemsParent.appendChild(r.root);return n},_isClientFull:function(){return this._scrollBottom!=0&&this._physicalBottom-1>=this._scrollBottom&&this._physicalTop<=this._scrollPosition},_increasePoolIfNeeded:function(e){var t=this._clamp(this._physicalCount+e,e0t,this._virtualCount-this._virtualStart);if(t=this._convertIndexToCompleteRow(t),this.grid){var r=t%this._itemsPerRow;r&&t-r<=this._physicalCount&&(t+=this._itemsPerRow),t-=r}var n=t-this._physicalCount,i=Math.round(this._physicalCount*.5);if(!(n<0)){if(n>0){var o=window.performance.now();[].push.apply(this._physicalItems,this._createPool(n));for(var a=0;a<n;a++)this._physicalSizes.push(0);this._physicalCount=this._physicalCount+n,this._physicalStart>this._physicalEnd&&this._isIndexRendered(this._focusedVirtualIndex)&&this._getPhysicalIndex(this._focusedVirtualIndex)<this._physicalEnd&&(this._physicalStart=this._physicalStart+n),this._update(),this._templateCost=(window.performance.now()-o)/n,i=Math.round(this._physicalCount*.5)}this._virtualEnd>=this._virtualCount-1||i===0||(this._isClientFull()?this._physicalSize<this._optPhysicalSize&&this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,this._clamp(Math.round(50/this._templateCost),1,i)),kx):this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,i),ci))}},_render:function(){if(!(!this.isAttached||!this._isVisible))if(this._physicalCount!==0){var e=this._getReusables(!0);this._physicalTop=e.physicalTop,this._virtualStart=this._virtualStart+e.indexes.length,this._physicalStart=this._physicalStart+e.indexes.length,this._update(e.indexes),this._update(),this._increasePoolIfNeeded(0)}else this._virtualCount>0&&(this.updateViewportBoundaries(),this._increasePoolIfNeeded(e0t))},_ensureTemplatized:function(){if(!this.ctor){this._userTemplate=this.queryEffectiveChildren("template"),this._userTemplate||console.warn("iron-list requires a template to be provided in light-dom");var e={};e.__key__=!0,e[this.as]=!0,e[this.indexAs]=!0,e[this.selectedAs]=!0,e.tabIndex=!0,this._instanceProps=e,this.templatize(this._userTemplate,this.mutableData)}},_gridChanged:function(e,t){typeof t!="undefined"&&(this.notifyResize(),ui(),e&&this._updateGridMetrics())},_itemsChanged:function(e){if(e.path==="items")this._virtualStart=0,this._physicalTop=0,this._virtualCount=this.items?this.items.length:0,this._physicalIndexForKey={},this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,this._physicalCount=this._physicalCount||0,this._physicalItems=this._physicalItems||[],this._physicalSizes=this._physicalSizes||[],this._physicalStart=0,this._scrollTop>this._scrollOffset&&this._resetScrollPosition(0),this._removeFocusedItem(),this._debounce("_render",this._render,Ni);else if(e.path==="items.splices"){this._adjustVirtualIndex(e.value.indexSplices),this._virtualCount=this.items?this.items.length:0;var t=e.value.indexSplices.some(function(i){return i.addedCount>0||i.removed.length>0});if(t){var r=this._getActiveElement();this.contains(r)&&r.blur()}var n=e.value.indexSplices.some(function(i){return i.index+i.addedCount>=this._virtualStart&&i.index<=this._virtualEnd},this);(!this._isClientFull()||n)&&this._debounce("_render",this._render,Ni)}else e.path!=="items.length"&&this._forwardItemPath(e.path,e.value)},_forwardItemPath:function(e,t){e=e.slice(6);var r=e.indexOf(".");r===-1&&(r=e.length);var n,i,o,a=this.modelForElement(this._offscreenFocusedItem),s=parseInt(e.substring(0,r),10);n=this._isIndexRendered(s),n?(i=this._getPhysicalIndex(s),o=this.modelForElement(this._physicalItems[i])):a&&(o=a),!(!o||o[this.indexAs]!==s)&&(e=e.substring(r+1),e=this.as+(e?"."+e:""),o._setPendingPropertyOrPath(e,t,!1,!0),o._flushProperties&&o._flushProperties(),n&&(this._updateMetrics([i]),this._positionItems(),this._updateScrollerSize()))},_adjustVirtualIndex:function(e){e.forEach(function(t){if(t.removed.forEach(this._removeItem,this),t.index<this._virtualStart){var r=Math.max(t.addedCount-t.removed.length,t.index-this._virtualStart);this._virtualStart=this._virtualStart+r,this._focusedVirtualIndex>=0&&(this._focusedVirtualIndex=this._focusedVirtualIndex+r)}},this)},_removeItem:function(e){this.$.selector.deselect(e),this._focusedItem&&this.modelForElement(this._focusedItem)[this.as]===e&&this._removeFocusedItem()},_iterateItems:function(e,t){var r,n,i,o;if(arguments.length===2&&t){for(o=0;o<t.length;o++)if(r=t[o],n=this._computeVidx(r),(i=e.call(this,r,n))!=null)return i}else{for(r=this._physicalStart,n=this._virtualStart;r<this._physicalCount;r++,n++)if((i=e.call(this,r,n))!=null)return i;for(r=0;r<this._physicalStart;r++,n++)if((i=e.call(this,r,n))!=null)return i}},_computeVidx:function(e){return e>=this._physicalStart?this._virtualStart+(e-this._physicalStart):this._virtualStart+(this._physicalCount-this._physicalStart)+e},_assignModels:function(e){this._iterateItems(function(t,r){var n=this._physicalItems[t],i=this.items&&this.items[r];if(i!=null){var o=this.modelForElement(n);o.__key__=null,this._forwardProperty(o,this.as,i),this._forwardProperty(o,this.selectedAs,this.$.selector.isSelected(i)),this._forwardProperty(o,this.indexAs,r),this._forwardProperty(o,"tabIndex",this._focusedVirtualIndex===r?0:-1),this._physicalIndexForKey[o.__key__]=t,o._flushProperties&&o._flushProperties(!0),n.removeAttribute("hidden")}else n.setAttribute("hidden","")},e)},_updateMetrics:function(e){ui();var t=0,r=0,n=this._physicalAverageCount,i=this._physicalAverage;this._iterateItems(function(o,a){r+=this._physicalSizes[o],this._physicalSizes[o]=this._physicalItems[o].offsetHeight,t+=this._physicalSizes[o],this._physicalAverageCount+=this._physicalSizes[o]?1:0},e),this.grid?(this._updateGridMetrics(),this._physicalSize=Math.ceil(this._physicalCount/this._itemsPerRow)*this._rowHeight):(r=this._itemsPerRow===1?r:Math.ceil(this._physicalCount/this._itemsPerRow)*this._rowHeight,this._physicalSize=this._physicalSize+t-r,this._itemsPerRow=1),this._physicalAverageCount!==n&&(this._physicalAverage=Math.round((i*n+t)/this._physicalAverageCount))},_updateGridMetrics:function(){this._itemWidth=this._physicalCount>0?this._physicalItems[0].getBoundingClientRect().width:200,this._rowHeight=this._physicalCount>0?this._physicalItems[0].offsetHeight:200,this._itemsPerRow=this._itemWidth?Math.floor(this._viewportWidth/this._itemWidth):this._itemsPerRow},_positionItems:function(){this._adjustScrollPosition();var e=this._physicalTop;if(this.grid){var t=this._itemsPerRow*this._itemWidth,r=(this._viewportWidth-t)/2;this._iterateItems(function(n,i){var o=i%this._itemsPerRow,a=Math.floor(o*this._itemWidth+r);this._isRTL&&(a=a*-1),this.translate3d(a+"px",e+"px",0,this._physicalItems[n]),this._shouldRenderNextRow(i)&&(e+=this._rowHeight)})}else{let n=[];this._iterateItems(function(i,o){let a=this._physicalItems[i];this.translate3d(0,e+"px",0,a),e+=this._physicalSizes[i];let s=a.id;s&&n.push(s)}),n.length&&this.setAttribute("aria-owns",n.join(" "))}},_getPhysicalSizeIncrement:function(e){return this.grid?this._computeVidx(e)%this._itemsPerRow!==this._itemsPerRow-1?0:this._rowHeight:this._physicalSizes[e]},_shouldRenderNextRow:function(e){return e%this._itemsPerRow===this._itemsPerRow-1},_adjustScrollPosition:function(){var e=this._virtualStart===0?this._physicalTop:Math.min(this._scrollPosition+this._physicalTop,0);if(e!==0){this._physicalTop=this._physicalTop-e;var t=this._scrollPosition;!Ebe&&t>0&&this._resetScrollPosition(t-e)}},_resetScrollPosition:function(e){this.scrollTarget&&e>=0&&(this._scrollTop=e,this._scrollPosition=this._scrollTop)},_updateScrollerSize:function(e){this.grid?this._estScrollHeight=this._virtualRowCount*this._rowHeight:this._estScrollHeight=this._physicalBottom+Math.max(this._virtualCount-this._physicalCount-this._virtualStart,0)*this._physicalAverage,e=e||this._scrollHeight===0,e=e||this._scrollPosition>=this._estScrollHeight-this._physicalSize,e=e||this.grid&&this.$.items.style.height<this._estScrollHeight,(e||Math.abs(this._estScrollHeight-this._scrollHeight)>=this._viewportHeight)&&(this.$.items.style.height=this._estScrollHeight+"px",this._scrollHeight=this._estScrollHeight)},scrollToItem:function(e){return this.scrollToIndex(this.items.indexOf(e))},scrollToIndex:function(e){if(!(typeof e!="number"||e<0||e>this.items.length-1)&&(ui(),this._physicalCount!==0)){e=this._clamp(e,0,this._virtualCount-1),(!this._isIndexRendered(e)||e>=this._maxVirtualStart)&&(this._virtualStart=this.grid?e-this._itemsPerRow*2:e-1),this._manageFocus(),this._assignModels(),this._updateMetrics(),this._physicalTop=Math.floor(this._virtualStart/this._itemsPerRow)*this._physicalAverage;for(var t=this._physicalStart,r=this._virtualStart,n=0,i=this._hiddenContentSize;r<e&&n<=i;)n=n+this._getPhysicalSizeIncrement(t),t=(t+1)%this._physicalCount,r++;this._updateScrollerSize(!0),this._positionItems(),this._resetScrollPosition(this._physicalTop+this._scrollOffset+n),this._increasePoolIfNeeded(0),this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null}},_resetAverage:function(){this._physicalAverage=0,this._physicalAverageCount=0},_resizeHandler:function(){this._debounce("_render",function(){this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,this._isVisible?(this.updateViewportBoundaries(),this.toggleScrollListener(!0),this._resetAverage(),this._render()):this.toggleScrollListener(!1)},Ni)},selectItem:function(e){return this.selectIndex(this.items.indexOf(e))},selectIndex:function(e){if(!(e<0||e>=this._virtualCount)){if(!this.multiSelection&&this.selectedItem&&this.clearSelection(),this._isIndexRendered(e)){var t=this.modelForElement(this._physicalItems[this._getPhysicalIndex(e)]);t&&(t[this.selectedAs]=!0),this.updateSizeForIndex(e)}this.$.selector.selectIndex(e)}},deselectItem:function(e){return this.deselectIndex(this.items.indexOf(e))},deselectIndex:function(e){if(!(e<0||e>=this._virtualCount)){if(this._isIndexRendered(e)){var t=this.modelForElement(this._physicalItems[this._getPhysicalIndex(e)]);t[this.selectedAs]=!1,this.updateSizeForIndex(e)}this.$.selector.deselectIndex(e)}},toggleSelectionForItem:function(e){return this.toggleSelectionForIndex(this.items.indexOf(e))},toggleSelectionForIndex:function(e){var t=this.$.selector.isIndexSelected?this.$.selector.isIndexSelected(e):this.$.selector.isSelected(this.items[e]);t?this.deselectIndex(e):this.selectIndex(e)},clearSelection:function(){this._iterateItems(function(e,t){this.modelForElement(this._physicalItems[e])[this.selectedAs]=!1}),this.$.selector.clearSelection()},_selectionEnabledChanged:function(e){var t=e?this.listen:this.unlisten;t.call(this,this,"tap","_selectionHandler")},_selectionHandler:function(e){var t=this.modelForElement(e.target);if(!!t){var r,n,i=zt(e).path[0],o=this._getActiveElement(),a=this._physicalItems[this._getPhysicalIndex(t[this.indexAs])];i.localName==="input"||i.localName==="button"||i.localName==="select"||(r=t.tabIndex,t.tabIndex=hE,n=o?o.tabIndex:-1,t.tabIndex=r,!(o&&a!==o&&a.contains(o)&&n!==hE)&&this.toggleSelectionForItem(t[this.as]))}},_multiSelectionChanged:function(e){this.clearSelection(),this.$.selector.multi=e},updateSizeForItem:function(e){return this.updateSizeForIndex(this.items.indexOf(e))},updateSizeForIndex:function(e){return this._isIndexRendered(e)&&(this._updateMetrics([this._getPhysicalIndex(e)]),this._positionItems()),null},_manageFocus:function(){var e=this._focusedVirtualIndex;e>=0&&e<this._virtualCount?this._isIndexRendered(e)?this._restoreFocusedItem():this._createFocusBackfillItem():this._virtualCount>0&&this._physicalCount>0&&(this._focusedPhysicalIndex=this._physicalStart,this._focusedVirtualIndex=this._virtualStart,this._focusedItem=this._physicalItems[this._physicalStart])},_convertIndexToCompleteRow:function(e){return this._itemsPerRow=this._itemsPerRow||1,this.grid?Math.ceil(e/this._itemsPerRow)*this._itemsPerRow:e},_isIndexRendered:function(e){return e>=this._virtualStart&&e<=this._virtualEnd},_isIndexVisible:function(e){return e>=this.firstVisibleIndex&&e<=this.lastVisibleIndex},_getPhysicalIndex:function(e){return(this._physicalStart+(e-this._virtualStart))%this._physicalCount},focusItem:function(e){this._focusPhysicalItem(e)},_focusPhysicalItem:function(e){if(!(e<0||e>=this._virtualCount)){this._restoreFocusedItem(),this._isIndexRendered(e)||this.scrollToIndex(e);var t=this._physicalItems[this._getPhysicalIndex(e)],r=this.modelForElement(t),n;r.tabIndex=hE,t.tabIndex===hE&&(n=t),n||(n=zt(t).querySelector('[tabindex="'+hE+'"]')),r.tabIndex=0,this._focusedVirtualIndex=e,n&&n.focus()}},_removeFocusedItem:function(){this._offscreenFocusedItem&&this._itemsParent.removeChild(this._offscreenFocusedItem),this._offscreenFocusedItem=null,this._focusBackfillItem=null,this._focusedItem=null,this._focusedVirtualIndex=-1,this._focusedPhysicalIndex=-1},_createFocusBackfillItem:function(){var e=this._focusedPhysicalIndex;if(!(this._offscreenFocusedItem||this._focusedVirtualIndex<0)){if(!this._focusBackfillItem){var t=this.stamp(null);this._focusBackfillItem=t.root.querySelector("*"),this._itemsParent.appendChild(t.root)}this._offscreenFocusedItem=this._physicalItems[e],this.modelForElement(this._offscreenFocusedItem).tabIndex=0,this._physicalItems[e]=this._focusBackfillItem,this._focusedPhysicalIndex=e,this.translate3d(0,r0t,0,this._offscreenFocusedItem)}},_restoreFocusedItem:function(){if(!(!this._offscreenFocusedItem||this._focusedVirtualIndex<0)){this._assignModels();var e=this._focusedPhysicalIndex=this._getPhysicalIndex(this._focusedVirtualIndex),t=this._physicalItems[e];if(!!t){var r=this.modelForElement(t),n=this.modelForElement(this._offscreenFocusedItem);r[this.as]===n[this.as]?(this._focusBackfillItem=t,r.tabIndex=-1,this._physicalItems[e]=this._offscreenFocusedItem,this.translate3d(0,r0t,0,this._focusBackfillItem)):(this._removeFocusedItem(),this._focusBackfillItem=null),this._offscreenFocusedItem=null}}},_didFocus:function(e){var t=this.modelForElement(e.target),r=this.modelForElement(this._focusedItem),n=this._offscreenFocusedItem!==null,i=this._focusedVirtualIndex;!t||(r===t?this._isIndexVisible(i)||this.scrollToIndex(i):(this._restoreFocusedItem(),r&&(r.tabIndex=-1),t.tabIndex=0,i=t[this.indexAs],this._focusedVirtualIndex=i,this._focusedPhysicalIndex=this._getPhysicalIndex(i),this._focusedItem=this._physicalItems[this._focusedPhysicalIndex],n&&!this._offscreenFocusedItem&&this._update()))},_keydownHandler:function(e){switch(e.keyCode){case 40:this._focusedVirtualIndex<this._virtualCount-1&&e.preventDefault(),this._focusPhysicalItem(this._focusedVirtualIndex+(this.grid?this._itemsPerRow:1));break;case 39:this.grid&&this._focusPhysicalItem(this._focusedVirtualIndex+(this._isRTL?-1:1));break;case 38:this._focusedVirtualIndex>0&&e.preventDefault(),this._focusPhysicalItem(this._focusedVirtualIndex-(this.grid?this._itemsPerRow:1));break;case 37:this.grid&&this._focusPhysicalItem(this._focusedVirtualIndex+(this._isRTL?1:-1));break;case 13:this._focusPhysicalItem(this._focusedVirtualIndex),this.selectionEnabled&&this._selectionHandler(e);break}},_clamp:function(e,t,r){return Math.min(r,Math.max(t,e))},_debounce:function(e,t,r){this._debouncers=this._debouncers||{},this._debouncers[e]=sr.debounce(this._debouncers[e],r,t.bind(this)),Jl(this._debouncers[e])},_forwardProperty:function(e,t,r){e._setPendingProperty(t,r)},_forwardHostPropV2:function(e,t){(this._physicalItems||[]).concat([this._offscreenFocusedItem,this._focusBackfillItem]).forEach(function(r){r&&this.modelForElement(r).forwardHostProp(e,t)},this)},_notifyInstancePropV2:function(e,t,r){if(DI(this.as,t)){var n=e[this.indexAs];t==this.as&&(this.items[n]=r),this.notifyPath(dp(this.as,"items."+n,t),r)}},_getStampedChildren:function(){return this._physicalItems},_forwardInstancePath:function(e,t,r){t.indexOf(this.as+".")===0&&this.notifyPath("items."+e.__key__+"."+t.slice(this.as.length+1),r)},_forwardParentPath:function(e,t){(this._physicalItems||[]).concat([this._offscreenFocusedItem,this._focusBackfillItem]).forEach(function(r){r&&this.modelForElement(r).notifyPath(e,t)},this)},_forwardParentProp:function(e,t){(this._physicalItems||[]).concat([this._offscreenFocusedItem,this._focusBackfillItem]).forEach(function(r){r&&(this.modelForElement(r)[e]=t)},this)},_getActiveElement:function(){var e=this._itemsParent.node.domHost;return zt(e?e.root:document).activeElement}});var v9=class{constructor(t){this.selection=[],this.selectCallback=t}get(){return this.multi?this.selection.slice():this.selection[0]}clear(t){this.selection.slice().forEach(function(r){(!t||t.indexOf(r)<0)&&this.setItemSelected(r,!1)},this)}isSelected(t){return this.selection.indexOf(t)>=0}setItemSelected(t,r){if(t!=null&&r!==this.isSelected(t)){if(r)this.selection.push(t);else{var n=this.selection.indexOf(t);n>=0&&this.selection.splice(n,1)}this.selectCallback&&this.selectCallback(t,r)}}select(t){this.multi?this.toggle(t):this.get()!==t&&(this.setItemSelected(this.get(),!1),this.setItemSelected(t,!0))}toggle(t){this.setItemSelected(t,!this.isSelected(t))}};var wh={properties:{attrForSelected:{type:String,value:null},selected:{type:String,notify:!0},selectedItem:{type:Object,readOnly:!0,notify:!0},activateEvent:{type:String,value:"tap",observer:"_activateEventChanged"},selectable:String,selectedClass:{type:String,value:"iron-selected"},selectedAttribute:{type:String,value:null},fallbackSelection:{type:String,value:null},items:{type:Array,readOnly:!0,notify:!0,value:function(){return[]}},_excludedLocalNames:{type:Object,value:function(){return{template:1,"dom-bind":1,"dom-if":1,"dom-repeat":1}}}},observers:["_updateAttrForSelected(attrForSelected)","_updateSelected(selected)","_checkFallback(fallbackSelection)"],created:function(){this._bindFilterItem=this._filterItem.bind(this),this._selection=new v9(this._applySelection.bind(this))},attached:function(){this._observer=this._observeItems(this),this._addListener(this.activateEvent)},detached:function(){this._observer&&zt(this).unobserveNodes(this._observer),this._removeListener(this.activateEvent)},indexOf:function(e){return this.items?this.items.indexOf(e):-1},select:function(e){this.selected=e},selectPrevious:function(){var e=this.items.length,t=e-1;this.selected!==void 0&&(t=(Number(this._valueToIndex(this.selected))-1+e)%e),this.selected=this._indexToValue(t)},selectNext:function(){var e=0;this.selected!==void 0&&(e=(Number(this._valueToIndex(this.selected))+1)%this.items.length),this.selected=this._indexToValue(e)},selectIndex:function(e){this.select(this._indexToValue(e))},forceSynchronousItemUpdate:function(){this._observer&&typeof this._observer.flush=="function"?this._observer.flush():this._updateItems()},get _shouldUpdateSelection(){return this.selected!=null},_checkFallback:function(){this._updateSelected()},_addListener:function(e){this.listen(this,e,"_activateHandler")},_removeListener:function(e){this.unlisten(this,e,"_activateHandler")},_activateEventChanged:function(e,t){this._removeListener(t),this._addListener(e)},_updateItems:function(){var e=zt(this).queryDistributedElements(this.selectable||"*");e=Array.prototype.filter.call(e,this._bindFilterItem),this._setItems(e)},_updateAttrForSelected:function(){this.selectedItem&&(this.selected=this._valueForItem(this.selectedItem))},_updateSelected:function(){this._selectSelected(this.selected)},_selectSelected:function(e){if(!!this.items){var t=this._valueToItem(this.selected);t?this._selection.select(t):this._selection.clear(),this.fallbackSelection&&this.items.length&&this._selection.get()===void 0&&(this.selected=this.fallbackSelection)}},_filterItem:function(e){return!this._excludedLocalNames[e.localName]},_valueToItem:function(e){return e==null?null:this.items[this._valueToIndex(e)]},_valueToIndex:function(e){if(this.attrForSelected){for(var t=0,r;r=this.items[t];t++)if(this._valueForItem(r)==e)return t}else return Number(e)},_indexToValue:function(e){if(this.attrForSelected){var t=this.items[e];if(t)return this._valueForItem(t)}else return e},_valueForItem:function(e){if(!e)return null;if(!this.attrForSelected){var t=this.indexOf(e);return t===-1?null:t}var r=e[wm(this.attrForSelected)];return r!=null?r:e.getAttribute(this.attrForSelected)},_applySelection:function(e,t){this.selectedClass&&this.toggleClass(this.selectedClass,t,e),this.selectedAttribute&&this.toggleAttribute(this.selectedAttribute,t,e),this._selectionChange(),this.fire("iron-"+(t?"select":"deselect"),{item:e})},_selectionChange:function(){this._setSelectedItem(this._selection.get())},_observeItems:function(e){return zt(e).observeNodes(function(t){this._updateItems(),this._updateSelected(),this.fire("iron-items-changed",t,{bubbles:!1,cancelable:!1})})},_activateHandler:function(e){for(var t=e.target,r=this.items;t&&t!=this;){var n=r.indexOf(t);if(n>=0){var i=this._indexToValue(n);this._itemActivate(i,t);return}t=t.parentNode}},_itemActivate:function(e,t){this.fire("iron-activate",{selected:e,item:t},{cancelable:!0}).defaultPrevented||this.select(e)}};Yt({_template:Q`
    <style>
      :host {
        display: block;
      }

      :host > ::slotted(:not(slot):not(.iron-selected)) {
        display: none !important;
      }
    </style>

    <slot></slot>
`,is:"iron-pages",behaviors:[Js,wh],properties:{activateEvent:{type:String,value:null}},observers:["_selectedPageChanged(selected)"],_selectedPageChanged:function(e,t){this.async(this.notifyResize)}});var n0t=Q`
<custom-style>
  <style is="custom-style">
    html {

      --shadow-transition: {
        transition: box-shadow 0.28s cubic-bezier(0.4, 0, 0.2, 1);
      };

      --shadow-none: {
        box-shadow: none;
      };

      /* from http://codepen.io/shyndman/pen/c5394ddf2e8b2a5c9185904b57421cdb */

      --shadow-elevation-2dp: {
        box-shadow: 0 2px 2px 0 rgba(0, 0, 0, 0.14),
                    0 1px 5px 0 rgba(0, 0, 0, 0.12),
                    0 3px 1px -2px rgba(0, 0, 0, 0.2);
      };

      --shadow-elevation-3dp: {
        box-shadow: 0 3px 4px 0 rgba(0, 0, 0, 0.14),
                    0 1px 8px 0 rgba(0, 0, 0, 0.12),
                    0 3px 3px -2px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-4dp: {
        box-shadow: 0 4px 5px 0 rgba(0, 0, 0, 0.14),
                    0 1px 10px 0 rgba(0, 0, 0, 0.12),
                    0 2px 4px -1px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-6dp: {
        box-shadow: 0 6px 10px 0 rgba(0, 0, 0, 0.14),
                    0 1px 18px 0 rgba(0, 0, 0, 0.12),
                    0 3px 5px -1px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-8dp: {
        box-shadow: 0 8px 10px 1px rgba(0, 0, 0, 0.14),
                    0 3px 14px 2px rgba(0, 0, 0, 0.12),
                    0 5px 5px -3px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-12dp: {
        box-shadow: 0 12px 16px 1px rgba(0, 0, 0, 0.14),
                    0 4px 22px 3px rgba(0, 0, 0, 0.12),
                    0 6px 7px -4px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-16dp: {
        box-shadow: 0 16px 24px 2px rgba(0, 0, 0, 0.14),
                    0  6px 30px 5px rgba(0, 0, 0, 0.12),
                    0  8px 10px -5px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-24dp: {
        box-shadow: 0 24px 38px 3px rgba(0, 0, 0, 0.14),
                    0 9px 46px 8px rgba(0, 0, 0, 0.12),
                    0 11px 15px -7px rgba(0, 0, 0, 0.4);
      };
    }
  </style>
</custom-style>`;n0t.setAttribute("style","display: none;");document.head.appendChild(n0t.content);var i0t=Q`
<dom-module id="paper-material-styles">
  <template>
    <style>
      html {
        --paper-material: {
          display: block;
          position: relative;
        };
        --paper-material-elevation-1: {
          @apply --shadow-elevation-2dp;
        };
        --paper-material-elevation-2: {
          @apply --shadow-elevation-4dp;
        };
        --paper-material-elevation-3: {
          @apply --shadow-elevation-6dp;
        };
        --paper-material-elevation-4: {
          @apply --shadow-elevation-8dp;
        };
        --paper-material-elevation-5: {
          @apply --shadow-elevation-16dp;
        };
      }
      .paper-material {
        @apply --paper-material;
      }
      .paper-material[elevation="1"] {
        @apply --paper-material-elevation-1;
      }
      .paper-material[elevation="2"] {
        @apply --paper-material-elevation-2;
      }
      .paper-material[elevation="3"] {
        @apply --paper-material-elevation-3;
      }
      .paper-material[elevation="4"] {
        @apply --paper-material-elevation-4;
      }
      .paper-material[elevation="5"] {
        @apply --paper-material-elevation-5;
      }

      /* Duplicate the styles because of https://github.com/webcomponents/shadycss/issues/193 */
      :host {
        --paper-material: {
          display: block;
          position: relative;
        };
        --paper-material-elevation-1: {
          @apply --shadow-elevation-2dp;
        };
        --paper-material-elevation-2: {
          @apply --shadow-elevation-4dp;
        };
        --paper-material-elevation-3: {
          @apply --shadow-elevation-6dp;
        };
        --paper-material-elevation-4: {
          @apply --shadow-elevation-8dp;
        };
        --paper-material-elevation-5: {
          @apply --shadow-elevation-16dp;
        };
      }
      :host(.paper-material) {
        @apply --paper-material;
      }
      :host(.paper-material[elevation="1"]) {
        @apply --paper-material-elevation-1;
      }
      :host(.paper-material[elevation="2"]) {
        @apply --paper-material-elevation-2;
      }
      :host(.paper-material[elevation="3"]) {
        @apply --paper-material-elevation-3;
      }
      :host(.paper-material[elevation="4"]) {
        @apply --paper-material-elevation-4;
      }
      :host(.paper-material[elevation="5"]) {
        @apply --paper-material-elevation-5;
      }
    </style>
  </template>
</dom-module>`;i0t.setAttribute("style","display: none;");document.head.appendChild(i0t.content);var Di={properties:{focused:{type:Boolean,value:!1,notify:!0,readOnly:!0,reflectToAttribute:!0},disabled:{type:Boolean,value:!1,notify:!0,observer:"_disabledChanged",reflectToAttribute:!0},_oldTabIndex:{type:String},_boundFocusBlurHandler:{type:Function,value:function(){return this._focusBlurHandler.bind(this)}}},observers:["_changedControlState(focused, disabled)"],ready:function(){this.addEventListener("focus",this._boundFocusBlurHandler,!0),this.addEventListener("blur",this._boundFocusBlurHandler,!0)},_focusBlurHandler:function(e){this._setFocused(e.type==="focus")},_disabledChanged:function(e,t){this.setAttribute("aria-disabled",e?"true":"false"),this.style.pointerEvents=e?"none":"",e?(this._oldTabIndex=this.getAttribute("tabindex"),this._setFocused(!1),this.tabIndex=-1,this.blur()):this._oldTabIndex!==void 0&&(this._oldTabIndex===null?this.removeAttribute("tabindex"):this.setAttribute("tabindex",this._oldTabIndex))},_changedControlState:function(){this._controlStateChanged&&this._controlStateChanged()}};var Yx={properties:{pressed:{type:Boolean,readOnly:!0,value:!1,reflectToAttribute:!0,observer:"_pressedChanged"},toggles:{type:Boolean,value:!1,reflectToAttribute:!0},active:{type:Boolean,value:!1,notify:!0,reflectToAttribute:!0},pointerDown:{type:Boolean,readOnly:!0,value:!1},receivedFocusFromKeyboard:{type:Boolean,readOnly:!0},ariaActiveAttribute:{type:String,value:"aria-pressed",observer:"_ariaActiveAttributeChanged"}},listeners:{down:"_downHandler",up:"_upHandler",tap:"_tapHandler"},observers:["_focusChanged(focused)","_activeChanged(active, ariaActiveAttribute)"],keyBindings:{"enter:keydown":"_asyncClick","space:keydown":"_spaceKeyDownHandler","space:keyup":"_spaceKeyUpHandler"},_mouseEventRe:/^mouse/,_tapHandler:function(){this.toggles?this._userActivate(!this.active):this.active=!1},_focusChanged:function(e){this._detectKeyboardFocus(e),e||this._setPressed(!1)},_detectKeyboardFocus:function(e){this._setReceivedFocusFromKeyboard(!this.pointerDown&&e)},_userActivate:function(e){this.active!==e&&(this.active=e,this.fire("change"))},_downHandler:function(e){this._setPointerDown(!0),this._setPressed(!0),this._setReceivedFocusFromKeyboard(!1)},_upHandler:function(){this._setPointerDown(!1),this._setPressed(!1)},_spaceKeyDownHandler:function(e){var t=e.detail.keyboardEvent,r=zt(t).localTarget;this.isLightDescendant(r)||(t.preventDefault(),t.stopImmediatePropagation(),this._setPressed(!0))},_spaceKeyUpHandler:function(e){var t=e.detail.keyboardEvent,r=zt(t).localTarget;this.isLightDescendant(r)||(this.pressed&&this._asyncClick(),this._setPressed(!1))},_asyncClick:function(){this.async(function(){this.click()},1)},_pressedChanged:function(e){this._changedButtonState()},_ariaActiveAttributeChanged:function(e,t){t&&t!=e&&this.hasAttribute(t)&&this.removeAttribute(t)},_activeChanged:function(e,t){this.toggles?this.setAttribute(this.ariaActiveAttribute,e?"true":"false"):this.removeAttribute(this.ariaActiveAttribute),this._changedButtonState()},_controlStateChanged:function(){this.disabled?this._setPressed(!1):this._changedButtonState()},_changedButtonState:function(){this._buttonStateChanged&&this._buttonStateChanged()}},Sh=[Oo,Yx];var Mh={distance:function(e,t,r,n){var i=e-r,o=t-n;return Math.sqrt(i*i+o*o)},now:window.performance&&window.performance.now?window.performance.now.bind(window.performance):Date.now};function o0t(e){this.element=e,this.width=this.boundingRect.width,this.height=this.boundingRect.height,this.size=Math.max(this.width,this.height)}o0t.prototype={get boundingRect(){return this.element.getBoundingClientRect()},furthestCornerDistanceFrom:function(e,t){var r=Mh.distance(e,t,0,0),n=Mh.distance(e,t,this.width,0),i=Mh.distance(e,t,0,this.height),o=Mh.distance(e,t,this.width,this.height);return Math.max(r,n,i,o)}};function g_(e){this.element=e,this.color=window.getComputedStyle(e).color,this.wave=document.createElement("div"),this.waveContainer=document.createElement("div"),this.wave.style.backgroundColor=this.color,this.wave.classList.add("wave"),this.waveContainer.classList.add("wave-container"),zt(this.waveContainer).appendChild(this.wave),this.resetInteractionState()}g_.MAX_RADIUS=300;g_.prototype={get recenters(){return this.element.recenters},get center(){return this.element.center},get mouseDownElapsed(){var e;return this.mouseDownStart?(e=Mh.now()-this.mouseDownStart,this.mouseUpStart&&(e-=this.mouseUpElapsed),e):0},get mouseUpElapsed(){return this.mouseUpStart?Mh.now()-this.mouseUpStart:0},get mouseDownElapsedSeconds(){return this.mouseDownElapsed/1e3},get mouseUpElapsedSeconds(){return this.mouseUpElapsed/1e3},get mouseInteractionSeconds(){return this.mouseDownElapsedSeconds+this.mouseUpElapsedSeconds},get initialOpacity(){return this.element.initialOpacity},get opacityDecayVelocity(){return this.element.opacityDecayVelocity},get radius(){var e=this.containerMetrics.width*this.containerMetrics.width,t=this.containerMetrics.height*this.containerMetrics.height,r=Math.min(Math.sqrt(e+t),g_.MAX_RADIUS)*1.1+5,n=1.1-.2*(r/g_.MAX_RADIUS),i=this.mouseInteractionSeconds/n,o=r*(1-Math.pow(80,-i));return Math.abs(o)},get opacity(){return this.mouseUpStart?Math.max(0,this.initialOpacity-this.mouseUpElapsedSeconds*this.opacityDecayVelocity):this.initialOpacity},get outerOpacity(){var e=this.mouseUpElapsedSeconds*.3,t=this.opacity;return Math.max(0,Math.min(e,t))},get isOpacityFullyDecayed(){return this.opacity<.01&&this.radius>=Math.min(this.maxRadius,g_.MAX_RADIUS)},get isRestingAtMaxRadius(){return this.opacity>=this.initialOpacity&&this.radius>=Math.min(this.maxRadius,g_.MAX_RADIUS)},get isAnimationComplete(){return this.mouseUpStart?this.isOpacityFullyDecayed:this.isRestingAtMaxRadius},get translationFraction(){return Math.min(1,this.radius/this.containerMetrics.size*2/Math.sqrt(2))},get xNow(){return this.xEnd?this.xStart+this.translationFraction*(this.xEnd-this.xStart):this.xStart},get yNow(){return this.yEnd?this.yStart+this.translationFraction*(this.yEnd-this.yStart):this.yStart},get isMouseDown(){return this.mouseDownStart&&!this.mouseUpStart},resetInteractionState:function(){this.maxRadius=0,this.mouseDownStart=0,this.mouseUpStart=0,this.xStart=0,this.yStart=0,this.xEnd=0,this.yEnd=0,this.slideDistance=0,this.containerMetrics=new o0t(this.element)},draw:function(){var e,t,r;this.wave.style.opacity=this.opacity,e=this.radius/(this.containerMetrics.size/2),t=this.xNow-this.containerMetrics.width/2,r=this.yNow-this.containerMetrics.height/2,this.waveContainer.style.webkitTransform="translate("+t+"px, "+r+"px)",this.waveContainer.style.transform="translate3d("+t+"px, "+r+"px, 0)",this.wave.style.webkitTransform="scale("+e+","+e+")",this.wave.style.transform="scale3d("+e+","+e+",1)"},downAction:function(e){var t=this.containerMetrics.width/2,r=this.containerMetrics.height/2;this.resetInteractionState(),this.mouseDownStart=Mh.now(),this.center?(this.xStart=t,this.yStart=r,this.slideDistance=Mh.distance(this.xStart,this.yStart,this.xEnd,this.yEnd)):(this.xStart=e?e.detail.x-this.containerMetrics.boundingRect.left:this.containerMetrics.width/2,this.yStart=e?e.detail.y-this.containerMetrics.boundingRect.top:this.containerMetrics.height/2),this.recenters&&(this.xEnd=t,this.yEnd=r,this.slideDistance=Mh.distance(this.xStart,this.yStart,this.xEnd,this.yEnd)),this.maxRadius=this.containerMetrics.furthestCornerDistanceFrom(this.xStart,this.yStart),this.waveContainer.style.top=(this.containerMetrics.height-this.containerMetrics.size)/2+"px",this.waveContainer.style.left=(this.containerMetrics.width-this.containerMetrics.size)/2+"px",this.waveContainer.style.width=this.containerMetrics.size+"px",this.waveContainer.style.height=this.containerMetrics.size+"px"},upAction:function(e){!this.isMouseDown||(this.mouseUpStart=Mh.now())},remove:function(){zt(zt(this.waveContainer).parentNode).removeChild(this.waveContainer)}};Yt({_template:Q`
    <style>
      :host {
        display: block;
        position: absolute;
        border-radius: inherit;
        overflow: hidden;
        top: 0;
        left: 0;
        right: 0;
        bottom: 0;

        /* See PolymerElements/paper-behaviors/issues/34. On non-Chrome browsers,
         * creating a node (with a position:absolute) in the middle of an event
         * handler "interrupts" that event handler (which happens when the
         * ripple is created on demand) */
        pointer-events: none;
      }

      :host([animating]) {
        /* This resolves a rendering issue in Chrome (as of 40) where the
           ripple is not properly clipped by its parent (which may have
           rounded corners). See: http://jsbin.com/temexa/4

           Note: We only apply this style conditionally. Otherwise, the browser
           will create a new compositing layer for every ripple element on the
           page, and that would be bad. */
        -webkit-transform: translate(0, 0);
        transform: translate3d(0, 0, 0);
      }

      #background,
      #waves,
      .wave-container,
      .wave {
        pointer-events: none;
        position: absolute;
        top: 0;
        left: 0;
        width: 100%;
        height: 100%;
      }

      #background,
      .wave {
        opacity: 0;
      }

      #waves,
      .wave {
        overflow: hidden;
      }

      .wave-container,
      .wave {
        border-radius: 50%;
      }

      :host(.circle) #background,
      :host(.circle) #waves {
        border-radius: 50%;
      }

      :host(.circle) .wave-container {
        overflow: hidden;
      }
    </style>

    <div id="background"></div>
    <div id="waves"></div>
`,is:"paper-ripple",behaviors:[Oo],properties:{initialOpacity:{type:Number,value:.25},opacityDecayVelocity:{type:Number,value:.8},recenters:{type:Boolean,value:!1},center:{type:Boolean,value:!1},ripples:{type:Array,value:function(){return[]}},animating:{type:Boolean,readOnly:!0,reflectToAttribute:!0,value:!1},holdDown:{type:Boolean,value:!1,observer:"_holdDownChanged"},noink:{type:Boolean,value:!1},_animating:{type:Boolean},_boundAnimate:{type:Function,value:function(){return this.animate.bind(this)}}},get target(){return this.keyEventTarget},keyBindings:{"enter:keydown":"_onEnterKeydown","space:keydown":"_onSpaceKeydown","space:keyup":"_onSpaceKeyup"},attached:function(){zt(this).parentNode.nodeType==11?this.keyEventTarget=zt(this).getOwnerRoot().host:this.keyEventTarget=zt(this).parentNode;var e=this.keyEventTarget;this.listen(e,"up","uiUpAction"),this.listen(e,"down","uiDownAction")},detached:function(){this.unlisten(this.keyEventTarget,"up","uiUpAction"),this.unlisten(this.keyEventTarget,"down","uiDownAction"),this.keyEventTarget=null},get shouldKeepAnimating(){for(var e=0;e<this.ripples.length;++e)if(!this.ripples[e].isAnimationComplete)return!0;return!1},simulatedRipple:function(){this.downAction(null),this.async(function(){this.upAction()},1)},uiDownAction:function(e){this.noink||this.downAction(e)},downAction:function(e){if(!(this.holdDown&&this.ripples.length>0)){var t=this.addRipple();t.downAction(e),this._animating||(this._animating=!0,this.animate())}},uiUpAction:function(e){this.noink||this.upAction(e)},upAction:function(e){this.holdDown||(this.ripples.forEach(function(t){t.upAction(e)}),this._animating=!0,this.animate())},onAnimationComplete:function(){this._animating=!1,this.$.background.style.backgroundColor="",this.fire("transitionend")},addRipple:function(){var e=new g_(this);return zt(this.$.waves).appendChild(e.waveContainer),this.$.background.style.backgroundColor=e.color,this.ripples.push(e),this._setAnimating(!0),e},removeRipple:function(e){var t=this.ripples.indexOf(e);t<0||(this.ripples.splice(t,1),e.remove(),this.ripples.length||this._setAnimating(!1))},animate:function(){if(!!this._animating){var e,t;for(e=0;e<this.ripples.length;++e)t=this.ripples[e],t.draw(),this.$.background.style.opacity=t.outerOpacity,t.isOpacityFullyDecayed&&!t.isRestingAtMaxRadius&&this.removeRipple(t);!this.shouldKeepAnimating&&this.ripples.length===0?this.onAnimationComplete():window.requestAnimationFrame(this._boundAnimate)}},animateRipple:function(){return this.animate()},_onEnterKeydown:function(){this.uiDownAction(),this.async(this.uiUpAction,1)},_onSpaceKeydown:function(){this.uiDownAction()},_onSpaceKeyup:function(){this.uiUpAction()},_holdDownChanged:function(e,t){t!==void 0&&(e?this.downAction():this.upAction())}});var su={properties:{noink:{type:Boolean,observer:"_noinkChanged"},_rippleContainer:{type:Object}},_buttonStateChanged:function(){this.focused&&this.ensureRipple()},_downHandler:function(e){Yx._downHandler.call(this,e),this.pressed&&this.ensureRipple(e)},ensureRipple:function(e){if(!this.hasRipple()){this._ripple=this._createRipple(),this._ripple.noink=this.noink;var t=this._rippleContainer||this.root;if(t&&zt(t).appendChild(this._ripple),e){var r=zt(this._rippleContainer||this),n=zt(e).rootTarget;r.deepContains(n)&&this._ripple.uiDownAction(e)}}},getRipple:function(){return this.ensureRipple(),this._ripple},hasRipple:function(){return Boolean(this._ripple)},_createRipple:function(){var e=document.createElement("paper-ripple");return e},_noinkChanged:function(e){this.hasRipple()&&(this._ripple.noink=e)}};var hW={properties:{elevation:{type:Number,reflectToAttribute:!0,readOnly:!0}},observers:["_calculateElevation(focused, disabled, active, pressed, receivedFocusFromKeyboard)","_computeKeyboardClass(receivedFocusFromKeyboard)"],hostAttributes:{role:"button",tabindex:"0",animated:!0},_calculateElevation:function(){var e=1;this.disabled?e=0:this.active||this.pressed?e=4:this.receivedFocusFromKeyboard&&(e=3),this._setElevation(e)},_computeKeyboardClass:function(e){this.toggleClass("keyboard-focus",e)},_spaceKeyDownHandler:function(e){Yx._spaceKeyDownHandler.call(this,e),this.hasRipple()&&this.getRipple().ripples.length<1&&this._ripple.uiDownAction()},_spaceKeyUpHandler:function(e){Yx._spaceKeyUpHandler.call(this,e),this.hasRipple()&&this._ripple.uiUpAction()}},a0t=[Sh,Di,su,hW];var s0t=Q`
  <style include="paper-material-styles">
    /* Need to specify the same specificity as the styles imported from paper-material. */
    :host {
      @apply --layout-inline;
      @apply --layout-center-center;
      position: relative;
      box-sizing: border-box;
      min-width: 5.14em;
      margin: 0 0.29em;
      background: transparent;
      -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
      -webkit-tap-highlight-color: transparent;
      font: inherit;
      text-transform: uppercase;
      outline-width: 0;
      border-radius: 3px;
      -moz-user-select: none;
      -ms-user-select: none;
      -webkit-user-select: none;
      user-select: none;
      cursor: pointer;
      z-index: 0;
      padding: 0.7em 0.57em;

      @apply --paper-font-common-base;
      @apply --paper-button;
    }

    :host([elevation="1"]) {
      @apply --paper-material-elevation-1;
    }

    :host([elevation="2"]) {
      @apply --paper-material-elevation-2;
    }

    :host([elevation="3"]) {
      @apply --paper-material-elevation-3;
    }

    :host([elevation="4"]) {
      @apply --paper-material-elevation-4;
    }

    :host([elevation="5"]) {
      @apply --paper-material-elevation-5;
    }

    :host([hidden]) {
      display: none !important;
    }

    :host([raised].keyboard-focus) {
      font-weight: bold;
      @apply --paper-button-raised-keyboard-focus;
    }

    :host(:not([raised]).keyboard-focus) {
      font-weight: bold;
      @apply --paper-button-flat-keyboard-focus;
    }

    :host([disabled]) {
      background: none;
      color: #a8a8a8;
      cursor: auto;
      pointer-events: none;

      @apply --paper-button-disabled;
    }

    :host([disabled][raised]) {
      background: #eaeaea;
    }


    :host([animated]) {
      @apply --shadow-transition;
    }

    paper-ripple {
      color: var(--paper-button-ink-color);
    }
  </style>

  <slot></slot>`;s0t.setAttribute("strip-whitespace","");Yt({_template:s0t,is:"paper-button",behaviors:[a0t],properties:{raised:{type:Boolean,reflectToAttribute:!0,value:!1,observer:"_calculateElevation"}},_calculateElevation:function(){this.raised?hW._calculateElevation.apply(this):this._setElevation(0)}});var l0t=Q`
<custom-style>
  <style is="custom-style">
    html {

      /* Material Design color palette for Google products */

      --google-red-100: #f4c7c3;
      --google-red-300: #e67c73;
      --google-red-500: #db4437;
      --google-red-700: #c53929;

      --google-blue-100: #c6dafc;
      --google-blue-300: #7baaf7;
      --google-blue-500: #4285f4;
      --google-blue-700: #3367d6;

      --google-green-100: #b7e1cd;
      --google-green-300: #57bb8a;
      --google-green-500: #0f9d58;
      --google-green-700: #0b8043;

      --google-yellow-100: #fce8b2;
      --google-yellow-300: #f7cb4d;
      --google-yellow-500: #f4b400;
      --google-yellow-700: #f09300;

      --google-grey-100: #f5f5f5;
      --google-grey-300: #e0e0e0;
      --google-grey-500: #9e9e9e;
      --google-grey-700: #616161;

      /* Material Design color palette from online spec document */

      --paper-red-50: #ffebee;
      --paper-red-100: #ffcdd2;
      --paper-red-200: #ef9a9a;
      --paper-red-300: #e57373;
      --paper-red-400: #ef5350;
      --paper-red-500: #f44336;
      --paper-red-600: #e53935;
      --paper-red-700: #d32f2f;
      --paper-red-800: #c62828;
      --paper-red-900: #b71c1c;
      --paper-red-a100: #ff8a80;
      --paper-red-a200: #ff5252;
      --paper-red-a400: #ff1744;
      --paper-red-a700: #d50000;

      --paper-pink-50: #fce4ec;
      --paper-pink-100: #f8bbd0;
      --paper-pink-200: #f48fb1;
      --paper-pink-300: #f06292;
      --paper-pink-400: #ec407a;
      --paper-pink-500: #e91e63;
      --paper-pink-600: #d81b60;
      --paper-pink-700: #c2185b;
      --paper-pink-800: #ad1457;
      --paper-pink-900: #880e4f;
      --paper-pink-a100: #ff80ab;
      --paper-pink-a200: #ff4081;
      --paper-pink-a400: #f50057;
      --paper-pink-a700: #c51162;

      --paper-purple-50: #f3e5f5;
      --paper-purple-100: #e1bee7;
      --paper-purple-200: #ce93d8;
      --paper-purple-300: #ba68c8;
      --paper-purple-400: #ab47bc;
      --paper-purple-500: #9c27b0;
      --paper-purple-600: #8e24aa;
      --paper-purple-700: #7b1fa2;
      --paper-purple-800: #6a1b9a;
      --paper-purple-900: #4a148c;
      --paper-purple-a100: #ea80fc;
      --paper-purple-a200: #e040fb;
      --paper-purple-a400: #d500f9;
      --paper-purple-a700: #aa00ff;

      --paper-deep-purple-50: #ede7f6;
      --paper-deep-purple-100: #d1c4e9;
      --paper-deep-purple-200: #b39ddb;
      --paper-deep-purple-300: #9575cd;
      --paper-deep-purple-400: #7e57c2;
      --paper-deep-purple-500: #673ab7;
      --paper-deep-purple-600: #5e35b1;
      --paper-deep-purple-700: #512da8;
      --paper-deep-purple-800: #4527a0;
      --paper-deep-purple-900: #311b92;
      --paper-deep-purple-a100: #b388ff;
      --paper-deep-purple-a200: #7c4dff;
      --paper-deep-purple-a400: #651fff;
      --paper-deep-purple-a700: #6200ea;

      --paper-indigo-50: #e8eaf6;
      --paper-indigo-100: #c5cae9;
      --paper-indigo-200: #9fa8da;
      --paper-indigo-300: #7986cb;
      --paper-indigo-400: #5c6bc0;
      --paper-indigo-500: #3f51b5;
      --paper-indigo-600: #3949ab;
      --paper-indigo-700: #303f9f;
      --paper-indigo-800: #283593;
      --paper-indigo-900: #1a237e;
      --paper-indigo-a100: #8c9eff;
      --paper-indigo-a200: #536dfe;
      --paper-indigo-a400: #3d5afe;
      --paper-indigo-a700: #304ffe;

      --paper-blue-50: #e3f2fd;
      --paper-blue-100: #bbdefb;
      --paper-blue-200: #90caf9;
      --paper-blue-300: #64b5f6;
      --paper-blue-400: #42a5f5;
      --paper-blue-500: #2196f3;
      --paper-blue-600: #1e88e5;
      --paper-blue-700: #1976d2;
      --paper-blue-800: #1565c0;
      --paper-blue-900: #0d47a1;
      --paper-blue-a100: #82b1ff;
      --paper-blue-a200: #448aff;
      --paper-blue-a400: #2979ff;
      --paper-blue-a700: #2962ff;

      --paper-light-blue-50: #e1f5fe;
      --paper-light-blue-100: #b3e5fc;
      --paper-light-blue-200: #81d4fa;
      --paper-light-blue-300: #4fc3f7;
      --paper-light-blue-400: #29b6f6;
      --paper-light-blue-500: #03a9f4;
      --paper-light-blue-600: #039be5;
      --paper-light-blue-700: #0288d1;
      --paper-light-blue-800: #0277bd;
      --paper-light-blue-900: #01579b;
      --paper-light-blue-a100: #80d8ff;
      --paper-light-blue-a200: #40c4ff;
      --paper-light-blue-a400: #00b0ff;
      --paper-light-blue-a700: #0091ea;

      --paper-cyan-50: #e0f7fa;
      --paper-cyan-100: #b2ebf2;
      --paper-cyan-200: #80deea;
      --paper-cyan-300: #4dd0e1;
      --paper-cyan-400: #26c6da;
      --paper-cyan-500: #00bcd4;
      --paper-cyan-600: #00acc1;
      --paper-cyan-700: #0097a7;
      --paper-cyan-800: #00838f;
      --paper-cyan-900: #006064;
      --paper-cyan-a100: #84ffff;
      --paper-cyan-a200: #18ffff;
      --paper-cyan-a400: #00e5ff;
      --paper-cyan-a700: #00b8d4;

      --paper-teal-50: #e0f2f1;
      --paper-teal-100: #b2dfdb;
      --paper-teal-200: #80cbc4;
      --paper-teal-300: #4db6ac;
      --paper-teal-400: #26a69a;
      --paper-teal-500: #009688;
      --paper-teal-600: #00897b;
      --paper-teal-700: #00796b;
      --paper-teal-800: #00695c;
      --paper-teal-900: #004d40;
      --paper-teal-a100: #a7ffeb;
      --paper-teal-a200: #64ffda;
      --paper-teal-a400: #1de9b6;
      --paper-teal-a700: #00bfa5;

      --paper-green-50: #e8f5e9;
      --paper-green-100: #c8e6c9;
      --paper-green-200: #a5d6a7;
      --paper-green-300: #81c784;
      --paper-green-400: #66bb6a;
      --paper-green-500: #4caf50;
      --paper-green-600: #43a047;
      --paper-green-700: #388e3c;
      --paper-green-800: #2e7d32;
      --paper-green-900: #1b5e20;
      --paper-green-a100: #b9f6ca;
      --paper-green-a200: #69f0ae;
      --paper-green-a400: #00e676;
      --paper-green-a700: #00c853;

      --paper-light-green-50: #f1f8e9;
      --paper-light-green-100: #dcedc8;
      --paper-light-green-200: #c5e1a5;
      --paper-light-green-300: #aed581;
      --paper-light-green-400: #9ccc65;
      --paper-light-green-500: #8bc34a;
      --paper-light-green-600: #7cb342;
      --paper-light-green-700: #689f38;
      --paper-light-green-800: #558b2f;
      --paper-light-green-900: #33691e;
      --paper-light-green-a100: #ccff90;
      --paper-light-green-a200: #b2ff59;
      --paper-light-green-a400: #76ff03;
      --paper-light-green-a700: #64dd17;

      --paper-lime-50: #f9fbe7;
      --paper-lime-100: #f0f4c3;
      --paper-lime-200: #e6ee9c;
      --paper-lime-300: #dce775;
      --paper-lime-400: #d4e157;
      --paper-lime-500: #cddc39;
      --paper-lime-600: #c0ca33;
      --paper-lime-700: #afb42b;
      --paper-lime-800: #9e9d24;
      --paper-lime-900: #827717;
      --paper-lime-a100: #f4ff81;
      --paper-lime-a200: #eeff41;
      --paper-lime-a400: #c6ff00;
      --paper-lime-a700: #aeea00;

      --paper-yellow-50: #fffde7;
      --paper-yellow-100: #fff9c4;
      --paper-yellow-200: #fff59d;
      --paper-yellow-300: #fff176;
      --paper-yellow-400: #ffee58;
      --paper-yellow-500: #ffeb3b;
      --paper-yellow-600: #fdd835;
      --paper-yellow-700: #fbc02d;
      --paper-yellow-800: #f9a825;
      --paper-yellow-900: #f57f17;
      --paper-yellow-a100: #ffff8d;
      --paper-yellow-a200: #ffff00;
      --paper-yellow-a400: #ffea00;
      --paper-yellow-a700: #ffd600;

      --paper-amber-50: #fff8e1;
      --paper-amber-100: #ffecb3;
      --paper-amber-200: #ffe082;
      --paper-amber-300: #ffd54f;
      --paper-amber-400: #ffca28;
      --paper-amber-500: #ffc107;
      --paper-amber-600: #ffb300;
      --paper-amber-700: #ffa000;
      --paper-amber-800: #ff8f00;
      --paper-amber-900: #ff6f00;
      --paper-amber-a100: #ffe57f;
      --paper-amber-a200: #ffd740;
      --paper-amber-a400: #ffc400;
      --paper-amber-a700: #ffab00;

      --paper-orange-50: #fff3e0;
      --paper-orange-100: #ffe0b2;
      --paper-orange-200: #ffcc80;
      --paper-orange-300: #ffb74d;
      --paper-orange-400: #ffa726;
      --paper-orange-500: #ff9800;
      --paper-orange-600: #fb8c00;
      --paper-orange-700: #f57c00;
      --paper-orange-800: #ef6c00;
      --paper-orange-900: #e65100;
      --paper-orange-a100: #ffd180;
      --paper-orange-a200: #ffab40;
      --paper-orange-a400: #ff9100;
      --paper-orange-a700: #ff6500;

      --paper-deep-orange-50: #fbe9e7;
      --paper-deep-orange-100: #ffccbc;
      --paper-deep-orange-200: #ffab91;
      --paper-deep-orange-300: #ff8a65;
      --paper-deep-orange-400: #ff7043;
      --paper-deep-orange-500: #ff5722;
      --paper-deep-orange-600: #f4511e;
      --paper-deep-orange-700: #e64a19;
      --paper-deep-orange-800: #d84315;
      --paper-deep-orange-900: #bf360c;
      --paper-deep-orange-a100: #ff9e80;
      --paper-deep-orange-a200: #ff6e40;
      --paper-deep-orange-a400: #ff3d00;
      --paper-deep-orange-a700: #dd2c00;

      --paper-brown-50: #efebe9;
      --paper-brown-100: #d7ccc8;
      --paper-brown-200: #bcaaa4;
      --paper-brown-300: #a1887f;
      --paper-brown-400: #8d6e63;
      --paper-brown-500: #795548;
      --paper-brown-600: #6d4c41;
      --paper-brown-700: #5d4037;
      --paper-brown-800: #4e342e;
      --paper-brown-900: #3e2723;

      --paper-grey-50: #fafafa;
      --paper-grey-100: #f5f5f5;
      --paper-grey-200: #eeeeee;
      --paper-grey-300: #e0e0e0;
      --paper-grey-400: #bdbdbd;
      --paper-grey-500: #9e9e9e;
      --paper-grey-600: #757575;
      --paper-grey-700: #616161;
      --paper-grey-800: #424242;
      --paper-grey-900: #212121;

      --paper-blue-grey-50: #eceff1;
      --paper-blue-grey-100: #cfd8dc;
      --paper-blue-grey-200: #b0bec5;
      --paper-blue-grey-300: #90a4ae;
      --paper-blue-grey-400: #78909c;
      --paper-blue-grey-500: #607d8b;
      --paper-blue-grey-600: #546e7a;
      --paper-blue-grey-700: #455a64;
      --paper-blue-grey-800: #37474f;
      --paper-blue-grey-900: #263238;

      /* opacity for dark text on a light background */
      --dark-divider-opacity: 0.12;
      --dark-disabled-opacity: 0.38; /* or hint text or icon */
      --dark-secondary-opacity: 0.54;
      --dark-primary-opacity: 0.87;

      /* opacity for light text on a dark background */
      --light-divider-opacity: 0.12;
      --light-disabled-opacity: 0.3; /* or hint text or icon */
      --light-secondary-opacity: 0.7;
      --light-primary-opacity: 1.0;

    }

  </style>
</custom-style>
`;l0t.setAttribute("style","display: none;");document.head.appendChild(l0t.content);var c0t=Q`
<custom-style>
  <style is="custom-style">
    html {
      /*
       * You can use these generic variables in your elements for easy theming.
       * For example, if all your elements use \`--primary-text-color\` as its main
       * color, then switching from a light to a dark theme is just a matter of
       * changing the value of \`--primary-text-color\` in your application.
       */
      --primary-text-color: var(--light-theme-text-color);
      --primary-background-color: var(--light-theme-background-color);
      --secondary-text-color: var(--light-theme-secondary-color);
      --disabled-text-color: var(--light-theme-disabled-color);
      --divider-color: var(--light-theme-divider-color);
      --error-color: var(--paper-deep-orange-a700);

      /*
       * Primary and accent colors. Also see color.js for more colors.
       */
      --primary-color: var(--paper-indigo-500);
      --light-primary-color: var(--paper-indigo-100);
      --dark-primary-color: var(--paper-indigo-700);

      --accent-color: var(--paper-pink-a200);
      --light-accent-color: var(--paper-pink-a100);
      --dark-accent-color: var(--paper-pink-a400);


      /*
       * Material Design Light background theme
       */
      --light-theme-background-color: #ffffff;
      --light-theme-base-color: #000000;
      --light-theme-text-color: var(--paper-grey-900);
      --light-theme-secondary-color: #737373;  /* for secondary text and icons */
      --light-theme-disabled-color: #9b9b9b;  /* disabled/hint text */
      --light-theme-divider-color: #dbdbdb;

      /*
       * Material Design Dark background theme
       */
      --dark-theme-background-color: var(--paper-grey-900);
      --dark-theme-base-color: #ffffff;
      --dark-theme-text-color: #ffffff;
      --dark-theme-secondary-color: #bcbcbc;  /* for secondary text and icons */
      --dark-theme-disabled-color: #646464;  /* disabled/hint text */
      --dark-theme-divider-color: #3c3c3c;

      /*
       * Deprecated values because of their confusing names.
       */
      --text-primary-color: var(--dark-theme-text-color);
      --default-primary-color: var(--primary-color);
    }
  </style>
</custom-style>`;c0t.setAttribute("style","display: none;");document.head.appendChild(c0t.content);var Eh={properties:{name:{type:String},value:{notify:!0,type:String},required:{type:Boolean,value:!1}},attached:function(){},detached:function(){}};var fW=null,Th={properties:{validator:{type:String},invalid:{notify:!0,reflectToAttribute:!0,type:Boolean,value:!1,observer:"_invalidChanged"}},registered:function(){fW=new go({type:"validator"})},_invalidChanged:function(){this.invalid?this.setAttribute("aria-invalid","true"):this.removeAttribute("aria-invalid")},get _validator(){return fW&&fW.byKey(this.validator)},hasValidator:function(){return this._validator!=null},validate:function(e){return e===void 0&&this.value!==void 0?this.invalid=!this._getValidity(this.value):this.invalid=!this._getValidity(e),!this.invalid},_getValidity:function(e){return this.hasValidator()?this._validator.validate(e):!0}};var pW={properties:{checked:{type:Boolean,value:!1,reflectToAttribute:!0,notify:!0,observer:"_checkedChanged"},toggles:{type:Boolean,value:!0,reflectToAttribute:!0},value:{type:String,value:"on",observer:"_valueChanged"}},observers:["_requiredChanged(required)"],created:function(){this._hasIronCheckedElementBehavior=!0},_getValidity:function(e){return this.disabled||!this.required||this.checked},_requiredChanged:function(){this.required?this.setAttribute("aria-required","true"):this.removeAttribute("aria-required")},_checkedChanged:function(){this.active=this.checked,this.fire("iron-change")},_valueChanged:function(){(this.value===void 0||this.value===null)&&(this.value="on")}},u0t=[Eh,Th,pW];var fE={observers:["_focusedChanged(receivedFocusFromKeyboard)"],_focusedChanged:function(e){e&&this.ensureRipple(),this.hasRipple()&&(this._ripple.holdDown=e)},_createRipple:function(){var e=su._createRipple();return e.id="ink",e.setAttribute("center",""),e.classList.add("circle"),e}},jx=[Sh,Di,su,fE];var Tbe={_checkedChanged:function(){pW._checkedChanged.call(this),this.hasRipple()&&(this.checked?this._ripple.setAttribute("checked",""):this._ripple.removeAttribute("checked"))},_buttonStateChanged:function(){su._buttonStateChanged.call(this),!this.disabled&&this.isAttached&&(this.checked=this.active)}},Xx=[jx,u0t,Tbe];var h0t=Q`<style>
  :host {
    display: inline-block;
    white-space: nowrap;
    cursor: pointer;
    --calculated-paper-checkbox-size: var(--paper-checkbox-size, 18px);
    /* -1px is a sentinel for the default and is replaced in \`attached\`. */
    --calculated-paper-checkbox-ink-size: var(--paper-checkbox-ink-size, -1px);
    @apply --paper-font-common-base;
    line-height: 0;
    -webkit-tap-highlight-color: transparent;
  }

  :host([hidden]) {
    display: none !important;
  }

  :host(:focus) {
    outline: none;
  }

  .hidden {
    display: none;
  }

  #checkboxContainer {
    display: inline-block;
    position: relative;
    width: var(--calculated-paper-checkbox-size);
    height: var(--calculated-paper-checkbox-size);
    min-width: var(--calculated-paper-checkbox-size);
    margin: var(--paper-checkbox-margin, initial);
    vertical-align: var(--paper-checkbox-vertical-align, middle);
    background-color: var(--paper-checkbox-unchecked-background-color, transparent);
  }

  #ink {
    position: absolute;

    /* Center the ripple in the checkbox by negative offsetting it by
     * (inkWidth - rippleWidth) / 2 */
    top: calc(0px - (var(--calculated-paper-checkbox-ink-size) - var(--calculated-paper-checkbox-size)) / 2);
    left: calc(0px - (var(--calculated-paper-checkbox-ink-size) - var(--calculated-paper-checkbox-size)) / 2);
    width: var(--calculated-paper-checkbox-ink-size);
    height: var(--calculated-paper-checkbox-ink-size);
    color: var(--paper-checkbox-unchecked-ink-color, var(--primary-text-color));
    opacity: 0.6;
    pointer-events: none;
  }

  #ink:dir(rtl) {
    right: calc(0px - (var(--calculated-paper-checkbox-ink-size) - var(--calculated-paper-checkbox-size)) / 2);
    left: auto;
  }

  #ink[checked] {
    color: var(--paper-checkbox-checked-ink-color, var(--primary-color));
  }

  #checkbox {
    position: relative;
    box-sizing: border-box;
    height: 100%;
    border: solid 2px;
    border-color: var(--paper-checkbox-unchecked-color, var(--primary-text-color));
    border-radius: 2px;
    pointer-events: none;
    -webkit-transition: background-color 140ms, border-color 140ms;
    transition: background-color 140ms, border-color 140ms;

    -webkit-transition-duration: var(--paper-checkbox-animation-duration, 140ms);
    transition-duration: var(--paper-checkbox-animation-duration, 140ms);
  }

  /* checkbox checked animations */
  #checkbox.checked #checkmark {
    -webkit-animation: checkmark-expand 140ms ease-out forwards;
    animation: checkmark-expand 140ms ease-out forwards;

    -webkit-animation-duration: var(--paper-checkbox-animation-duration, 140ms);
    animation-duration: var(--paper-checkbox-animation-duration, 140ms);
  }

  @-webkit-keyframes checkmark-expand {
    0% {
      -webkit-transform: scale(0, 0) rotate(45deg);
    }
    100% {
      -webkit-transform: scale(1, 1) rotate(45deg);
    }
  }

  @keyframes checkmark-expand {
    0% {
      transform: scale(0, 0) rotate(45deg);
    }
    100% {
      transform: scale(1, 1) rotate(45deg);
    }
  }

  #checkbox.checked {
    background-color: var(--paper-checkbox-checked-color, var(--primary-color));
    border-color: var(--paper-checkbox-checked-color, var(--primary-color));
  }

  #checkmark {
    position: absolute;
    width: 36%;
    height: 70%;
    border-style: solid;
    border-top: none;
    border-left: none;
    border-right-width: calc(2/15 * var(--calculated-paper-checkbox-size));
    border-bottom-width: calc(2/15 * var(--calculated-paper-checkbox-size));
    border-color: var(--paper-checkbox-checkmark-color, white);
    -webkit-transform-origin: 97% 86%;
    transform-origin: 97% 86%;
    box-sizing: content-box; /* protect against page-level box-sizing */
  }

  #checkmark:dir(rtl) {
    -webkit-transform-origin: 50% 14%;
    transform-origin: 50% 14%;
  }

  /* label */
  #checkboxLabel {
    position: relative;
    display: inline-block;
    vertical-align: middle;
    padding-left: var(--paper-checkbox-label-spacing, 8px);
    white-space: normal;
    line-height: normal;
    color: var(--paper-checkbox-label-color, var(--primary-text-color));
    @apply --paper-checkbox-label;
  }

  :host([checked]) #checkboxLabel {
    color: var(--paper-checkbox-label-checked-color, var(--paper-checkbox-label-color, var(--primary-text-color)));
    @apply --paper-checkbox-label-checked;
  }

  #checkboxLabel:dir(rtl) {
    padding-right: var(--paper-checkbox-label-spacing, 8px);
    padding-left: 0;
  }

  #checkboxLabel[hidden] {
    display: none;
  }

  /* disabled state */

  :host([disabled]) #checkbox {
    opacity: 0.5;
    border-color: var(--paper-checkbox-unchecked-color, var(--primary-text-color));
  }

  :host([disabled][checked]) #checkbox {
    background-color: var(--paper-checkbox-unchecked-color, var(--primary-text-color));
    opacity: 0.5;
  }

  :host([disabled]) #checkboxLabel  {
    opacity: 0.65;
  }

  /* invalid state */
  #checkbox.invalid:not(.checked) {
    border-color: var(--paper-checkbox-error-color, var(--error-color));
  }
</style>

<div id="checkboxContainer">
  <div id="checkbox" class$="[[_computeCheckboxClass(checked, invalid)]]">
    <div id="checkmark" class$="[[_computeCheckmarkClass(checked)]]"></div>
  </div>
</div>

<div id="checkboxLabel"><slot></slot></div>`;h0t.setAttribute("strip-whitespace","");Yt({_template:h0t,is:"paper-checkbox",behaviors:[Xx],hostAttributes:{role:"checkbox","aria-checked":!1,tabindex:0},properties:{ariaActiveAttribute:{type:String,value:"aria-checked"}},attached:function(){Tm(this,function(){var e=this.getComputedStyleValue("--calculated-paper-checkbox-ink-size").trim();if(e==="-1px"){var t=this.getComputedStyleValue("--calculated-paper-checkbox-size").trim(),r="px",n=t.match(/[A-Za-z]+$/);n!==null&&(r=n[0]);var i=parseFloat(t),o=8/3*i;r==="px"&&(o=Math.floor(o),o%2!==i%2&&o++),this.updateStyles({"--paper-checkbox-ink-size":o+r})}})},_computeCheckboxClass:function(e,t){var r="";return e&&(r+="checked "),t&&(r+="invalid"),r},_computeCheckmarkClass:function(e){return e?"":"hidden"},_createRipple:function(){return this._rippleContainer=this.$.checkboxContainer,fE._createRipple.call(this)}});if(!window.polymerSkipLoadingFontRoboto){let e=document.createElement("link");e.rel="stylesheet",e.type="text/css",e.crossOrigin="anonymous",e.href="https://fonts.googleapis.com/css?family=Roboto+Mono:400,700|Roboto:400,300,300italic,400italic,500,500italic,700,700italic",document.head.appendChild(e)}var f0t=Q`<custom-style>
  <style is="custom-style">
    html {

      /* Shared Styles */
      --paper-font-common-base: {
        font-family: 'Roboto', 'Noto', sans-serif;
        -webkit-font-smoothing: antialiased;
      };

      --paper-font-common-code: {
        font-family: 'Roboto Mono', 'Consolas', 'Menlo', monospace;
        -webkit-font-smoothing: antialiased;
      };

      --paper-font-common-expensive-kerning: {
        text-rendering: optimizeLegibility;
      };

      --paper-font-common-nowrap: {
        white-space: nowrap;
        overflow: hidden;
        text-overflow: ellipsis;
      };

      /* Material Font Styles */

      --paper-font-display4: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 112px;
        font-weight: 300;
        letter-spacing: -.044em;
        line-height: 120px;
      };

      --paper-font-display3: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 56px;
        font-weight: 400;
        letter-spacing: -.026em;
        line-height: 60px;
      };

      --paper-font-display2: {
        @apply --paper-font-common-base;

        font-size: 45px;
        font-weight: 400;
        letter-spacing: -.018em;
        line-height: 48px;
      };

      --paper-font-display1: {
        @apply --paper-font-common-base;

        font-size: 34px;
        font-weight: 400;
        letter-spacing: -.01em;
        line-height: 40px;
      };

      --paper-font-headline: {
        @apply --paper-font-common-base;

        font-size: 24px;
        font-weight: 400;
        letter-spacing: -.012em;
        line-height: 32px;
      };

      --paper-font-title: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 20px;
        font-weight: 500;
        line-height: 28px;
      };

      --paper-font-subhead: {
        @apply --paper-font-common-base;

        font-size: 16px;
        font-weight: 400;
        line-height: 24px;
      };

      --paper-font-body2: {
        @apply --paper-font-common-base;

        font-size: 14px;
        font-weight: 500;
        line-height: 24px;
      };

      --paper-font-body1: {
        @apply --paper-font-common-base;

        font-size: 14px;
        font-weight: 400;
        line-height: 20px;
      };

      --paper-font-caption: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 12px;
        font-weight: 400;
        letter-spacing: 0.011em;
        line-height: 20px;
      };

      --paper-font-menu: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 13px;
        font-weight: 500;
        line-height: 24px;
      };

      --paper-font-button: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 14px;
        font-weight: 500;
        letter-spacing: 0.018em;
        line-height: 24px;
        text-transform: uppercase;
      };

      --paper-font-code2: {
        @apply --paper-font-common-code;

        font-size: 14px;
        font-weight: 700;
        line-height: 20px;
      };

      --paper-font-code1: {
        @apply --paper-font-common-code;

        font-size: 14px;
        font-weight: 500;
        line-height: 20px;
      };

    }

  </style>
</custom-style>`;f0t.setAttribute("style","display: none;");document.head.appendChild(f0t.content);var dW=document.createElement("template");dW.setAttribute("style","display: none;");dW.innerHTML=`<dom-module id="paper-dialog-shared-styles">
  <template>
    <style>
      :host {
        display: block;
        margin: 24px 40px;

        background: var(--paper-dialog-background-color, var(--primary-background-color));
        color: var(--paper-dialog-color, var(--primary-text-color));

        @apply --paper-font-body1;
        @apply --shadow-elevation-16dp;
        @apply --paper-dialog;
      }

      :host > ::slotted(*) {
        margin-top: 20px;
        padding: 0 24px;
      }

      :host > ::slotted(.no-padding) {
        padding: 0;
      }

      
      :host > ::slotted(*:first-child) {
        margin-top: 24px;
      }

      :host > ::slotted(*:last-child) {
        margin-bottom: 24px;
      }

      /* In 1.x, this selector was \`:host > ::content h2\`. In 2.x <slot> allows
      to select direct children only, which increases the weight of this
      selector, so we have to re-define first-child/last-child margins below. */
      :host > ::slotted(h2) {
        position: relative;
        margin: 0;

        @apply --paper-font-title;
        @apply --paper-dialog-title;
      }

      /* Apply mixin again, in case it sets margin-top. */
      :host > ::slotted(h2:first-child) {
        margin-top: 24px;
        @apply --paper-dialog-title;
      }

      /* Apply mixin again, in case it sets margin-bottom. */
      :host > ::slotted(h2:last-child) {
        margin-bottom: 24px;
        @apply --paper-dialog-title;
      }

      :host > ::slotted(.paper-dialog-buttons),
      :host > ::slotted(.buttons) {
        position: relative;
        padding: 8px 8px 8px 24px;
        margin: 0;

        color: var(--paper-dialog-button-color, var(--primary-color));

        @apply --layout-horizontal;
        @apply --layout-end-justified;
      }
    </style>
  </template>
</dom-module>`;document.head.appendChild(dW.content);var p0t={properties:{animationConfig:{type:Object},entryAnimation:{observer:"_entryAnimationChanged",type:String},exitAnimation:{observer:"_exitAnimationChanged",type:String}},_entryAnimationChanged:function(){this.animationConfig=this.animationConfig||{},this.animationConfig.entry=[{name:this.entryAnimation,node:this}]},_exitAnimationChanged:function(){this.animationConfig=this.animationConfig||{},this.animationConfig.exit=[{name:this.exitAnimation,node:this}]},_copyProperties:function(e,t){for(var r in t)e[r]=t[r]},_cloneConfig:function(e){var t={isClone:!0};return this._copyProperties(t,e),t},_getAnimationConfigRecursive:function(e,t,r){if(!!this.animationConfig){if(this.animationConfig.value&&typeof this.animationConfig.value=="function"){this._warn(this._logf("playAnimation","Please put 'animationConfig' inside of your components 'properties' object instead of outside of it."));return}var n;if(e?n=this.animationConfig[e]:n=this.animationConfig,Array.isArray(n)||(n=[n]),n)for(var i,o=0;i=n[o];o++)if(i.animatable)i.animatable._getAnimationConfigRecursive(i.type||e,t,r);else if(i.id){var a=t[i.id];a?(a.isClone||(t[i.id]=this._cloneConfig(a),a=t[i.id]),this._copyProperties(a,i)):t[i.id]=i}else r.push(i)}},getAnimationConfig:function(e){var t={},r=[];this._getAnimationConfigRecursive(e,t,r);for(var n in t)r.push(t[n]);return r}};var Cbe={_configureAnimations:function(e){var t=[],r=[];if(e.length>0)for(let i,o=0;i=e[o];o++){let a=document.createElement(i.name);if(a.isNeonAnimation){let s=null;a.configure||(a.configure=function(l){return null}),s=a.configure(i),r.push({result:s,config:i,neonAnimation:a})}else console.warn(this.is+":",i.name,"not found!")}for(var n=0;n<r.length;n++){let i=r[n].result,o=r[n].config,a=r[n].neonAnimation;try{typeof i.cancel!="function"&&(i=document.timeline.play(i))}catch(s){i=null,console.warn("Couldnt play","(",o.name,").",s)}i&&t.push({neonAnimation:a,config:o,animation:i})}return t},_shouldComplete:function(e){for(var t=!0,r=0;r<e.length;r++)if(e[r].animation.playState!="finished"){t=!1;break}return t},_complete:function(e){for(var t=0;t<e.length;t++)e[t].neonAnimation.complete(e[t].config);for(var t=0;t<e.length;t++)e[t].animation.cancel()},playAnimation:function(e,t){var r=this.getAnimationConfig(e);if(!!r){this._active=this._active||{},this._active[e]&&(this._complete(this._active[e]),delete this._active[e]);var n=this._configureAnimations(r);if(n.length==0){this.fire("neon-animation-finish",t,{bubbles:!1});return}this._active[e]=n;for(var i=0;i<n.length;i++)n[i].animation.onfinish=function(){this._shouldComplete(n)&&(this._complete(n),delete this._active[e],this.fire("neon-animation-finish",t,{bubbles:!1}))}.bind(this)}},cancelAnimation:function(){for(var e in this._active){var t=this._active[e];for(var r in t)t[r].animation.cancel()}this._active={}}},x9=[p0t,Cbe];var b9,Abe=()=>{if(b9!==void 0)return b9;let e=document.createElement("div");Object.assign(e.style,{overflow:"auto",position:"fixed",left:"0px",top:"0px",maxWidth:"100px",maxHeight:"100px"});let t=document.createElement("div");return t.style.width="200px",t.style.height="200px",e.appendChild(t),document.body.appendChild(e),b9=Math.abs(e.offsetWidth-100)>1?e.offsetWidth-e.clientWidth:0,document.body.removeChild(e),b9},d0t={properties:{sizingTarget:{type:Object,value:function(){return this}},fitInto:{type:Object,value:window},noOverlap:{type:Boolean},positionTarget:{type:Element},horizontalAlign:{type:String},verticalAlign:{type:String},dynamicAlign:{type:Boolean},horizontalOffset:{type:Number,value:0,notify:!0},verticalOffset:{type:Number,value:0,notify:!0},autoFitOnAttach:{type:Boolean,value:!1},expandSizingTargetForScrollbars:{type:Boolean,value:!1},_fitInfo:{type:Object}},get _fitWidth(){var e;return this.fitInto===window?e=this.fitInto.innerWidth:e=this.fitInto.getBoundingClientRect().width,e},get _fitHeight(){var e;return this.fitInto===window?e=this.fitInto.innerHeight:e=this.fitInto.getBoundingClientRect().height,e},get _fitLeft(){var e;return this.fitInto===window?e=0:e=this.fitInto.getBoundingClientRect().left,e},get _fitTop(){var e;return this.fitInto===window?e=0:e=this.fitInto.getBoundingClientRect().top,e},get _defaultPositionTarget(){var e=zt(this).parentNode;return e&&e.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&(e=e.host),e},get _localeHorizontalAlign(){if(this._isRTL){if(this.horizontalAlign==="right")return"left";if(this.horizontalAlign==="left")return"right"}return this.horizontalAlign},get __shouldPosition(){return(this.horizontalAlign||this.verticalAlign)&&this.positionTarget},get _isRTL(){return typeof this._memoizedIsRTL=="undefined"&&(this._memoizedIsRTL=window.getComputedStyle(this).direction=="rtl"),this._memoizedIsRTL},attached:function(){this.positionTarget=this.positionTarget||this._defaultPositionTarget,this.autoFitOnAttach&&(window.getComputedStyle(this).display==="none"?setTimeout(function(){this.fit()}.bind(this)):(window.ShadyDOM&&ShadyDOM.flush(),this.fit()))},detached:function(){this.__deferredFit&&(clearTimeout(this.__deferredFit),this.__deferredFit=null)},fit:function(){this.position(),this.constrain(),this.center()},_discoverInfo:function(){if(!this._fitInfo){var e=window.getComputedStyle(this),t=window.getComputedStyle(this.sizingTarget);this._fitInfo={inlineStyle:{top:this.style.top||"",left:this.style.left||"",position:this.style.position||""},sizerInlineStyle:{maxWidth:this.sizingTarget.style.maxWidth||"",maxHeight:this.sizingTarget.style.maxHeight||"",boxSizing:this.sizingTarget.style.boxSizing||""},positionedBy:{vertically:e.top!=="auto"?"top":e.bottom!=="auto"?"bottom":null,horizontally:e.left!=="auto"?"left":e.right!=="auto"?"right":null},sizedBy:{height:t.maxHeight!=="none",width:t.maxWidth!=="none",minWidth:parseInt(t.minWidth,10)||0,minHeight:parseInt(t.minHeight,10)||0},margin:{top:parseInt(e.marginTop,10)||0,right:parseInt(e.marginRight,10)||0,bottom:parseInt(e.marginBottom,10)||0,left:parseInt(e.marginLeft,10)||0}}}},resetFit:function(){var e=this._fitInfo||{};for(var t in e.sizerInlineStyle)this.sizingTarget.style[t]=e.sizerInlineStyle[t];for(var t in e.inlineStyle)this.style[t]=e.inlineStyle[t];this._fitInfo=null},refit:function(){var e=this.sizingTarget.scrollLeft,t=this.sizingTarget.scrollTop;this.resetFit(),this.fit(),this.sizingTarget.scrollLeft=e,this.sizingTarget.scrollTop=t},position:function(){if(!this.__shouldPosition)return;this._discoverInfo(),window.ShadyDOM&&window.ShadyDOM.flush(),this.style.position="fixed",this.sizingTarget.style.boxSizing="border-box",this.style.left="0px",this.style.top="0px";var e=this.getBoundingClientRect(),t=this.__getNormalizedRect(this.positionTarget),r=this.__getNormalizedRect(this.fitInto);let n,i,o,a;this.expandSizingTargetForScrollbars&&(n=this.sizingTarget.offsetWidth,i=this.sizingTarget.offsetHeight,o=this.sizingTarget.clientWidth,a=this.sizingTarget.clientHeight);var s=this._fitInfo.margin,l={width:e.width+s.left+s.right,height:e.height+s.top+s.bottom},c=this.__getPosition(this._localeHorizontalAlign,this.verticalAlign,l,e,t,r),u=c.left+s.left,h=c.top+s.top,f=Math.min(r.right-s.right,u+e.width),p=Math.min(r.bottom-s.bottom,h+e.height);u=Math.max(r.left+s.left,Math.min(u,f-this._fitInfo.sizedBy.minWidth)),h=Math.max(r.top+s.top,Math.min(h,p-this._fitInfo.sizedBy.minHeight));let d=Math.max(f-u,this._fitInfo.sizedBy.minWidth),g=Math.max(p-h,this._fitInfo.sizedBy.minHeight);this.sizingTarget.style.maxWidth=d+"px",this.sizingTarget.style.maxHeight=g+"px";let _=u-e.left,y=h-e.top;if(this.style.left=`${_}px`,this.style.top=`${y}px`,this.expandSizingTargetForScrollbars){let x=this.sizingTarget.offsetHeight,b=this.sizingTarget.clientHeight,S=i-a,P=x-b-S;if(P>0){let L=r.height-s.top-s.bottom,R=Math.min(L,g+P);this.sizingTarget.style.maxHeight=`${R}px`;let F=this.sizingTarget.offsetHeight,z=F-x,U;c.verticalAlign==="top"?U=y:c.verticalAlign==="middle"?U=y-z/2:c.verticalAlign==="bottom"&&(U=y-z),U=Math.max(r.top+s.top,Math.min(U,r.bottom-s.bottom-F)),this.style.top=`${U}px`}let k=this.sizingTarget.offsetWidth,O=this.sizingTarget.clientWidth,D=n-o,I=k-O-D;if(I>0){let L=Abe(),R=r.width-s.left-s.right,F=Math.min(R,d+I-L);this.sizingTarget.style.maxWidth=`${F}px`;let z=this.sizingTarget.offsetWidth+L,U=z-k,W;c.horizontalAlign==="left"?W=_:c.horizontalAlign==="center"?W=_-U/2:c.horizontalAlign==="right"&&(W=_-U),W=Math.max(r.left+s.left,Math.min(W,r.right-s.right-z)),this.style.left=`${W}px`}}},constrain:function(){if(!this.__shouldPosition){this._discoverInfo();var e=this._fitInfo;e.positionedBy.vertically||(this.style.position="fixed",this.style.top="0px"),e.positionedBy.horizontally||(this.style.position="fixed",this.style.left="0px"),this.sizingTarget.style.boxSizing="border-box";var t=this.getBoundingClientRect();e.sizedBy.height||this.__sizeDimension(t,e.positionedBy.vertically,"top","bottom","Height"),e.sizedBy.width||this.__sizeDimension(t,e.positionedBy.horizontally,"left","right","Width")}},_sizeDimension:function(e,t,r,n,i){this.__sizeDimension(e,t,r,n,i)},__sizeDimension:function(e,t,r,n,i){var o=this._fitInfo,a=this.__getNormalizedRect(this.fitInto),s=i==="Width"?a.width:a.height,l=t===n,c=l?s-e[n]:e[r],u=o.margin[l?r:n],h="offset"+i,f=this[h]-this.sizingTarget[h];this.sizingTarget.style["max"+i]=s-u-c-f+"px"},center:function(){if(!this.__shouldPosition){this._discoverInfo();var e=this._fitInfo.positionedBy;if(!(e.vertically&&e.horizontally)){this.style.position="fixed",e.vertically||(this.style.top="0px"),e.horizontally||(this.style.left="0px");var t=this.getBoundingClientRect(),r=this.__getNormalizedRect(this.fitInto);if(!e.vertically){var n=r.top-t.top+(r.height-t.height)/2;this.style.top=n+"px"}if(!e.horizontally){var i=r.left-t.left+(r.width-t.width)/2;this.style.left=i+"px"}}}},__getNormalizedRect:function(e){return e===document.documentElement||e===window?{top:0,left:0,width:window.innerWidth,height:window.innerHeight,right:window.innerWidth,bottom:window.innerHeight}:e.getBoundingClientRect()},__getOffscreenArea:function(e,t,r){var n=Math.min(0,e.top)+Math.min(0,r.bottom-(e.top+t.height)),i=Math.min(0,e.left)+Math.min(0,r.right-(e.left+t.width));return Math.abs(n)*t.width+Math.abs(i)*t.height},__getPosition:function(e,t,r,n,i,o){var a=[{verticalAlign:"top",horizontalAlign:"left",top:i.top+this.verticalOffset,left:i.left+this.horizontalOffset},{verticalAlign:"top",horizontalAlign:"right",top:i.top+this.verticalOffset,left:i.right-r.width-this.horizontalOffset},{verticalAlign:"bottom",horizontalAlign:"left",top:i.bottom-r.height-this.verticalOffset,left:i.left+this.horizontalOffset},{verticalAlign:"bottom",horizontalAlign:"right",top:i.bottom-r.height-this.verticalOffset,left:i.right-r.width-this.horizontalOffset}];if(this.noOverlap){for(var s=0,l=a.length;s<l;s++){var c={};for(var u in a[s])c[u]=a[s][u];a.push(c)}a[0].top=a[1].top+=i.height,a[2].top=a[3].top-=i.height,a[4].left=a[6].left+=i.width,a[5].left=a[7].left-=i.width}t=t==="auto"?null:t,e=e==="auto"?null:e,(!e||e==="center")&&(a.push({verticalAlign:"top",horizontalAlign:"center",top:i.top+this.verticalOffset+(this.noOverlap?i.height:0),left:i.left-n.width/2+i.width/2+this.horizontalOffset}),a.push({verticalAlign:"bottom",horizontalAlign:"center",top:i.bottom-r.height-this.verticalOffset-(this.noOverlap?i.height:0),left:i.left-n.width/2+i.width/2+this.horizontalOffset})),(!t||t==="middle")&&(a.push({verticalAlign:"middle",horizontalAlign:"left",top:i.top-n.height/2+i.height/2+this.verticalOffset,left:i.left+this.horizontalOffset+(this.noOverlap?i.width:0)}),a.push({verticalAlign:"middle",horizontalAlign:"right",top:i.top-n.height/2+i.height/2+this.verticalOffset,left:i.right-r.width-this.horizontalOffset-(this.noOverlap?i.width:0)})),t==="middle"&&e==="center"&&a.push({verticalAlign:"middle",horizontalAlign:"center",top:i.top-n.height/2+i.height/2+this.verticalOffset,left:i.left-n.width/2+i.width/2+this.horizontalOffset});for(var h,s=0;s<a.length;s++){var f=a[s],p=f.verticalAlign===t,d=f.horizontalAlign===e;if(!this.dynamicAlign&&!this.noOverlap&&p&&d){h=f;break}var g=(!t||p)&&(!e||d);if(!(!this.dynamicAlign&&!g)){if(f.offscreenArea=this.__getOffscreenArea(f,r,o),f.offscreenArea===0&&g){h=f;break}h=h||f;var _=f.offscreenArea-h.offscreenArea;(_<0||_===0&&(p||d))&&(h=f)}}return h}};var $x=Element.prototype,w9=$x.matches||$x.matchesSelector||$x.mozMatchesSelector||$x.msMatchesSelector||$x.oMatchesSelector||$x.webkitMatchesSelector,mW=class{getTabbableNodes(t){var r=[],n=this._collectTabbableNodes(t,r);return n?this._sortByTabIndex(r):r}isFocusable(t){return w9.call(t,"input, select, textarea, button, object")?w9.call(t,":not([disabled])"):w9.call(t,"a[href], area[href], iframe, [tabindex], [contentEditable]")}isTabbable(t){return this.isFocusable(t)&&w9.call(t,':not([tabindex="-1"])')&&this._isVisible(t)}_normalizedTabIndex(t){if(this.isFocusable(t)){var r=t.getAttribute("tabindex")||0;return Number(r)}return-1}_collectTabbableNodes(t,r){if(t.nodeType!==Node.ELEMENT_NODE)return!1;var n=t;if(!this._isVisible(n))return!1;var i=this._normalizedTabIndex(n),o=i>0;i>=0&&r.push(n);var a;n.localName==="content"||n.localName==="slot"?a=zt(n).getDistributedNodes():a=zt(n.root||n).children;for(var s=0;s<a.length;s++)o=this._collectTabbableNodes(a[s],r)||o;return o}_isVisible(t){var r=t.style;return r.visibility!=="hidden"&&r.display!=="none"?(r=window.getComputedStyle(t),r.visibility!=="hidden"&&r.display!=="none"):!1}_sortByTabIndex(t){var r=t.length;if(r<2)return t;var n=Math.ceil(r/2),i=this._sortByTabIndex(t.slice(0,n)),o=this._sortByTabIndex(t.slice(n));return this._mergeSortByTabIndex(i,o)}_mergeSortByTabIndex(t,r){for(var n=[];t.length>0&&r.length>0;)this._hasLowerTabOrder(t[0],r[0])?n.push(r.shift()):n.push(t.shift());return n.concat(t,r)}_hasLowerTabOrder(t,r){var n=Math.max(t.tabIndex,0),i=Math.max(r.tabIndex,0);return n===0||i===0?i>n:n>i}},m0t=new mW;Yt({_template:Q`
    <style>
      :host {
        position: fixed;
        top: 0;
        left: 0;
        width: 100%;
        height: 100%;
        background-color: var(--iron-overlay-backdrop-background-color, #000);
        opacity: 0;
        transition: opacity 0.2s;
        pointer-events: none;
        @apply --iron-overlay-backdrop;
      }

      :host(.opened) {
        opacity: var(--iron-overlay-backdrop-opacity, 0.6);
        pointer-events: auto;
        @apply --iron-overlay-backdrop-opened;
      }
    </style>

    <slot></slot>
`,is:"iron-overlay-backdrop",properties:{opened:{reflectToAttribute:!0,type:Boolean,value:!1,observer:"_openedChanged"}},listeners:{transitionend:"_onTransitionend"},created:function(){this.__openedRaf=null},attached:function(){this.opened&&this._openedChanged(this.opened)},prepare:function(){this.opened&&!this.parentNode&&zt(document.body).appendChild(this)},open:function(){this.opened=!0},close:function(){this.opened=!1},complete:function(){!this.opened&&this.parentNode===document.body&&zt(this.parentNode).removeChild(this)},_onTransitionend:function(e){e&&e.target===this&&this.complete()},_openedChanged:function(e){if(e)this.prepare();else{var t=window.getComputedStyle(this);(t.transitionDuration==="0s"||t.opacity==0)&&this.complete()}!this.isAttached||(this.__openedRaf&&(window.cancelAnimationFrame(this.__openedRaf),this.__openedRaf=null),this.scrollTop=this.scrollTop,this.__openedRaf=window.requestAnimationFrame(function(){this.__openedRaf=null,this.toggleClass("opened",this.opened)}.bind(this)))}});var gW=class{constructor(){this._overlays=[],this._minimumZ=101,this._backdropElement=null,Em(document.documentElement,"tap",function(){}),document.addEventListener("tap",this._onCaptureClick.bind(this),!0),document.addEventListener("focus",this._onCaptureFocus.bind(this),!0),document.addEventListener("keydown",this._onCaptureKeyDown.bind(this),!0)}get backdropElement(){return this._backdropElement||(this._backdropElement=document.createElement("iron-overlay-backdrop")),this._backdropElement}get deepActiveElement(){var t=document.activeElement;for((!t||!(t instanceof Element))&&(t=document.body);t.root&&zt(t.root).activeElement;)t=zt(t.root).activeElement;return t}_bringOverlayAtIndexToFront(t){var r=this._overlays[t];if(!!r){var n=this._overlays.length-1,i=this._overlays[n];if(i&&this._shouldBeBehindOverlay(r,i)&&n--,!(t>=n)){var o=Math.max(this.currentOverlayZ(),this._minimumZ);for(this._getZ(r)<=o&&this._applyOverlayZ(r,o);t<n;)this._overlays[t]=this._overlays[t+1],t++;this._overlays[n]=r}}}addOrRemoveOverlay(t){t.opened?this.addOverlay(t):this.removeOverlay(t)}addOverlay(t){var r=this._overlays.indexOf(t);if(r>=0){this._bringOverlayAtIndexToFront(r),this.trackBackdrop();return}var n=this._overlays.length,i=this._overlays[n-1],o=Math.max(this._getZ(i),this._minimumZ),a=this._getZ(t);if(i&&this._shouldBeBehindOverlay(t,i)){this._applyOverlayZ(i,o),n--;var s=this._overlays[n-1];o=Math.max(this._getZ(s),this._minimumZ)}a<=o&&this._applyOverlayZ(t,o),this._overlays.splice(n,0,t),this.trackBackdrop()}removeOverlay(t){var r=this._overlays.indexOf(t);r!==-1&&(this._overlays.splice(r,1),this.trackBackdrop())}currentOverlay(){var t=this._overlays.length-1;return this._overlays[t]}currentOverlayZ(){return this._getZ(this.currentOverlay())}ensureMinimumZ(t){this._minimumZ=Math.max(this._minimumZ,t)}focusOverlay(){var t=this.currentOverlay();t&&t._applyFocus()}trackBackdrop(){var t=this._overlayWithBackdrop();!t&&!this._backdropElement||(this.backdropElement.style.zIndex=this._getZ(t)-1,this.backdropElement.opened=!!t,this.backdropElement.prepare())}getBackdrops(){for(var t=[],r=0;r<this._overlays.length;r++)this._overlays[r].withBackdrop&&t.push(this._overlays[r]);return t}backdropZ(){return this._getZ(this._overlayWithBackdrop())-1}_overlayWithBackdrop(){for(var t=this._overlays.length-1;t>=0;t--)if(this._overlays[t].withBackdrop)return this._overlays[t]}_getZ(t){var r=this._minimumZ;if(t){var n=Number(t.style.zIndex||window.getComputedStyle(t).zIndex);n===n&&(r=n)}return r}_setZ(t,r){t.style.zIndex=r}_applyOverlayZ(t,r){this._setZ(t,r+2)}_overlayInPath(t){t=t||[];for(var r=0;r<t.length;r++)if(t[r]._manager===this)return t[r]}_onCaptureClick(t){var r=this._overlays.length-1;if(r!==-1)for(var n=zt(t).path,i;(i=this._overlays[r])&&this._overlayInPath(n)!==i&&(i._onCaptureClick(t),i.allowClickThrough);)r--}_onCaptureFocus(t){var r=this.currentOverlay();r&&r._onCaptureFocus(t)}_onCaptureKeyDown(t){var r=this.currentOverlay();r&&(Oo.keyboardEventMatchesKeys(t,"esc")?r._onCaptureEsc(t):Oo.keyboardEventMatchesKeys(t,"tab")&&r._onCaptureTab(t))}_shouldBeBehindOverlay(t,r){return!t.alwaysOnTop&&r.alwaysOnTop}},g0t=new gW;var M9={pageX:0,pageY:0},_0t=null,_W=[],E9=["wheel","mousewheel","DOMMouseScroll","touchstart","touchmove"],S9,yW;function y0t(e){Ch.indexOf(e)>=0||(Ch.length===0&&Ibe(),Ch.push(e),yW=Ch[Ch.length-1],x0t=[],b0t=[])}function v0t(e){var t=Ch.indexOf(e);t!==-1&&(Ch.splice(t,1),yW=Ch[Ch.length-1],x0t=[],b0t=[],Ch.length===0&&Lbe())}var Ch=[],x0t=null,b0t=null;function Pbe(e){if(e.cancelable&&kbe(e)&&e.preventDefault(),e.targetTouches){var t=e.targetTouches[0];M9.pageX=t.pageX,M9.pageY=t.pageY}}function Ibe(){S9=S9||Pbe.bind(void 0);for(var e=0,t=E9.length;e<t;e++)document.addEventListener(E9[e],S9,{capture:!0,passive:!1})}function Lbe(){for(var e=0,t=E9.length;e<t;e++)document.removeEventListener(E9[e],S9,{capture:!0,passive:!1})}function kbe(e){var t=zt(e).rootTarget;if(e.type!=="touchmove"&&_0t!==t&&(_0t=t,_W=Rbe(zt(e).path)),!_W.length)return!0;if(e.type==="touchstart")return!1;var r=Dbe(e);return!Nbe(_W,r.deltaX,r.deltaY)}function Rbe(e){for(var t=[],r=e.indexOf(yW),n=0;n<=r;n++)if(e[n].nodeType===Node.ELEMENT_NODE){var i=e[n],o=i.style;o.overflow!=="scroll"&&o.overflow!=="auto"&&(o=window.getComputedStyle(i)),(o.overflow==="scroll"||o.overflow==="auto")&&t.push(i)}return t}function Nbe(e,t,r){if(!(!t&&!r))for(var n=Math.abs(r)>=Math.abs(t),i=0;i<e.length;i++){var o=e[i],a=!1;if(n?a=r<0?o.scrollTop>0:o.scrollTop<o.scrollHeight-o.clientHeight:a=t<0?o.scrollLeft>0:o.scrollLeft<o.scrollWidth-o.clientWidth,a)return o}}function Dbe(e){var t={deltaX:e.deltaX,deltaY:e.deltaY};if(!("deltaX"in e)){if("wheelDeltaX"in e&&"wheelDeltaY"in e)t.deltaX=-e.wheelDeltaX,t.deltaY=-e.wheelDeltaY;else if("wheelDelta"in e)t.deltaX=0,t.deltaY=-e.wheelDelta;else if("axis"in e)t.deltaX=e.axis===1?e.detail:0,t.deltaY=e.axis===2?e.detail:0;else if(e.targetTouches){var r=e.targetTouches[0];t.deltaX=M9.pageX-r.pageX,t.deltaY=M9.pageY-r.pageY}}return t}var Pm={properties:{opened:{observer:"_openedChanged",type:Boolean,value:!1,notify:!0},canceled:{observer:"_canceledChanged",readOnly:!0,type:Boolean,value:!1},withBackdrop:{observer:"_withBackdropChanged",type:Boolean},noAutoFocus:{type:Boolean,value:!1},noCancelOnEscKey:{type:Boolean,value:!1},noCancelOnOutsideClick:{type:Boolean,value:!1},closingReason:{type:Object},restoreFocusOnClose:{type:Boolean,value:!1},allowClickThrough:{type:Boolean},alwaysOnTop:{type:Boolean},scrollAction:{type:String},_manager:{type:Object,value:g0t},_focusedChild:{type:Object}},listeners:{"iron-resize":"_onIronResize"},observers:["__updateScrollObservers(isAttached, opened, scrollAction)"],get backdropElement(){return this._manager.backdropElement},get _focusNode(){return this._focusedChild||zt(this).querySelector("[autofocus]")||this},get _focusableNodes(){return m0t.getTabbableNodes(this)},ready:function(){this.__isAnimating=!1,this.__shouldRemoveTabIndex=!1,this.__firstFocusableNode=this.__lastFocusableNode=null,this.__rafs={},this.__restoreFocusNode=null,this.__scrollTop=this.__scrollLeft=null,this.__onCaptureScroll=this.__onCaptureScroll.bind(this),this.__rootNodes=null,this._ensureSetup()},attached:function(){this.opened&&this._openedChanged(this.opened),this._observer=zt(this).observeNodes(this._onNodesChange)},detached:function(){this._observer&&zt(this).unobserveNodes(this._observer),this._observer=null;for(var e in this.__rafs)this.__rafs[e]!==null&&cancelAnimationFrame(this.__rafs[e]);this.__rafs={},this._manager.removeOverlay(this),this.__isAnimating&&(this.opened?this._finishRenderOpened():(this._applyFocus(),this._finishRenderClosed()))},toggle:function(){this._setCanceled(!1),this.opened=!this.opened},open:function(){this._setCanceled(!1),this.opened=!0},close:function(){this._setCanceled(!1),this.opened=!1},cancel:function(e){var t=this.fire("iron-overlay-canceled",e,{cancelable:!0});t.defaultPrevented||(this._setCanceled(!0),this.opened=!1)},invalidateTabbables:function(){this.__firstFocusableNode=this.__lastFocusableNode=null},_ensureSetup:function(){this._overlaySetup||(this._overlaySetup=!0,this.style.outline="none",this.style.display="none")},_openedChanged:function(e){e?this.removeAttribute("aria-hidden"):this.setAttribute("aria-hidden","true"),this.isAttached&&(this.__isAnimating=!0,this.__deraf("__openedChanged",this.__openedChanged))},_canceledChanged:function(){this.closingReason=this.closingReason||{},this.closingReason.canceled=this.canceled},_withBackdropChanged:function(){this.withBackdrop&&!this.hasAttribute("tabindex")?(this.setAttribute("tabindex","-1"),this.__shouldRemoveTabIndex=!0):this.__shouldRemoveTabIndex&&(this.removeAttribute("tabindex"),this.__shouldRemoveTabIndex=!1),this.opened&&this.isAttached&&this._manager.trackBackdrop()},_prepareRenderOpened:function(){this.__restoreFocusNode=this._manager.deepActiveElement,this._preparePositioning(),this.refit(),this._finishPositioning(),this.noAutoFocus&&document.activeElement===this._focusNode&&(this._focusNode.blur(),this.__restoreFocusNode.focus())},_renderOpened:function(){this._finishRenderOpened()},_renderClosed:function(){this._finishRenderClosed()},_finishRenderOpened:function(){this.notifyResize(),this.__isAnimating=!1,this.fire("iron-overlay-opened")},_finishRenderClosed:function(){this.style.display="none",this.style.zIndex="",this.notifyResize(),this.__isAnimating=!1,this.fire("iron-overlay-closed",this.closingReason)},_preparePositioning:function(){this.style.transition=this.style.webkitTransition="none",this.style.transform=this.style.webkitTransform="none",this.style.display=""},_finishPositioning:function(){this.style.display="none",this.scrollTop=this.scrollTop,this.style.transition=this.style.webkitTransition="",this.style.transform=this.style.webkitTransform="",this.style.display="",this.scrollTop=this.scrollTop},_applyFocus:function(){if(this.opened)this.noAutoFocus||this._focusNode.focus();else{if(this.restoreFocusOnClose&&this.__restoreFocusNode){var e=this._manager.deepActiveElement;(e===document.body||zbe(this,e))&&this.__restoreFocusNode.focus()}this.__restoreFocusNode=null,this._focusNode.blur(),this._focusedChild=null}},_onCaptureClick:function(e){this.noCancelOnOutsideClick||this.cancel(e)},_onCaptureFocus:function(e){if(!!this.withBackdrop){var t=zt(e).path;t.indexOf(this)===-1?(e.stopPropagation(),this._applyFocus()):this._focusedChild=t[0]}},_onCaptureEsc:function(e){this.noCancelOnEscKey||this.cancel(e)},_onCaptureTab:function(e){if(!!this.withBackdrop){this.__ensureFirstLastFocusables();var t=e.shiftKey,r=t?this.__firstFocusableNode:this.__lastFocusableNode,n=t?this.__lastFocusableNode:this.__firstFocusableNode,i=!1;if(r===n)i=!0;else{var o=this._manager.deepActiveElement;i=o===r||o===this}i&&(e.preventDefault(),this._focusedChild=n,this._applyFocus())}},_onIronResize:function(){this.opened&&!this.__isAnimating&&this.__deraf("refit",this.refit)},_onNodesChange:function(){this.opened&&!this.__isAnimating&&(this.invalidateTabbables(),this.notifyResize())},__ensureFirstLastFocusables:function(){var e=this._focusableNodes;this.__firstFocusableNode=e[0],this.__lastFocusableNode=e[e.length-1]},__openedChanged:function(){this.opened?(this._prepareRenderOpened(),this._manager.addOverlay(this),this._applyFocus(),this._renderOpened()):(this._manager.removeOverlay(this),this._applyFocus(),this._renderClosed())},__deraf:function(e,t){var r=this.__rafs;r[e]!==null&&cancelAnimationFrame(r[e]),r[e]=requestAnimationFrame(function(){r[e]=null,t.call(this)}.bind(this))},__updateScrollObservers:function(e,t,r){!e||!t||!this.__isValidScrollAction(r)?(v0t(this),this.__removeScrollListeners()):(r==="lock"&&(this.__saveScrollPosition(),y0t(this)),this.__addScrollListeners())},__addScrollListeners:function(){if(!this.__rootNodes){if(this.__rootNodes=[],c_)for(var e=this;e;)e.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&e.host&&this.__rootNodes.push(e),e=e.host||e.assignedSlot||e.parentNode;this.__rootNodes.push(document)}this.__rootNodes.forEach(function(t){t.addEventListener("scroll",this.__onCaptureScroll,{capture:!0,passive:!0})},this)},__removeScrollListeners:function(){this.__rootNodes&&this.__rootNodes.forEach(function(e){e.removeEventListener("scroll",this.__onCaptureScroll,{capture:!0,passive:!0})},this),this.isAttached||(this.__rootNodes=null)},__isValidScrollAction:function(e){return e==="lock"||e==="refit"||e==="cancel"},__onCaptureScroll:function(e){if(!this.__isAnimating&&!(zt(e).path.indexOf(this)>=0))switch(this.scrollAction){case"lock":this.__restoreScrollPosition();break;case"refit":this.__deraf("refit",this.refit);break;case"cancel":this.cancel(e);break}},__saveScrollPosition:function(){document.scrollingElement?(this.__scrollTop=document.scrollingElement.scrollTop,this.__scrollLeft=document.scrollingElement.scrollLeft):(this.__scrollTop=Math.max(document.documentElement.scrollTop,document.body.scrollTop),this.__scrollLeft=Math.max(document.documentElement.scrollLeft,document.body.scrollLeft))},__restoreScrollPosition:function(){document.scrollingElement?(document.scrollingElement.scrollTop=this.__scrollTop,document.scrollingElement.scrollLeft=this.__scrollLeft):(document.documentElement.scrollTop=document.body.scrollTop=this.__scrollTop,document.documentElement.scrollLeft=document.body.scrollLeft=this.__scrollLeft)}},Obe=e=>e.assignedSlot||e.parentNode||e.host,zbe=(e,t)=>{for(let r=t;r;r=Obe(r))if(r===e)return!0;return!1},Kx=[d0t,Js,Pm];var vW={hostAttributes:{role:"dialog",tabindex:"-1"},properties:{modal:{type:Boolean,value:!1},__readied:{type:Boolean,value:!1}},observers:["_modalChanged(modal, __readied)"],listeners:{tap:"_onDialogClick"},ready:function(){this.__prevNoCancelOnOutsideClick=this.noCancelOnOutsideClick,this.__prevNoCancelOnEscKey=this.noCancelOnEscKey,this.__prevWithBackdrop=this.withBackdrop,this.__readied=!0},_modalChanged:function(e,t){!t||(e?(this.__prevNoCancelOnOutsideClick=this.noCancelOnOutsideClick,this.__prevNoCancelOnEscKey=this.noCancelOnEscKey,this.__prevWithBackdrop=this.withBackdrop,this.noCancelOnOutsideClick=!0,this.noCancelOnEscKey=!0,this.withBackdrop=!0):(this.noCancelOnOutsideClick=this.noCancelOnOutsideClick&&this.__prevNoCancelOnOutsideClick,this.noCancelOnEscKey=this.noCancelOnEscKey&&this.__prevNoCancelOnEscKey,this.withBackdrop=this.withBackdrop&&this.__prevWithBackdrop))},_updateClosingReasonConfirmed:function(e){this.closingReason=this.closingReason||{},this.closingReason.confirmed=e},_onDialogClick:function(e){for(var t=zt(e).path,r=0,n=t.indexOf(this);r<n;r++){var i=t[r];if(i.hasAttribute&&(i.hasAttribute("dialog-dismiss")||i.hasAttribute("dialog-confirm"))){this._updateClosingReasonConfirmed(i.hasAttribute("dialog-confirm")),this.close(),e.stopPropagation();break}}}},w0t=[Kx,vW];Yt({_template:Q`
    <style include="paper-dialog-shared-styles"></style>
    <slot></slot>
`,is:"paper-dialog",behaviors:[w0t,x9],listeners:{"neon-animation-finish":"_onNeonAnimationFinish"},_renderOpened:function(){this.cancelAnimation(),this.playAnimation("entry")},_renderClosed:function(){this.cancelAnimation(),this.playAnimation("exit")},_onNeonAnimationFinish:function(){this.opened?this._finishRenderOpened():this._finishRenderClosed()}});Yt({_template:Q`
    <style>

      :host {
        display: block;
        @apply --layout-relative;
      }

      :host(.is-scrolled:not(:first-child))::before {
        content: '';
        position: absolute;
        top: 0;
        left: 0;
        right: 0;
        height: 1px;
        background: var(--divider-color);
      }

      :host(.can-scroll:not(.scrolled-to-bottom):not(:last-child))::after {
        content: '';
        position: absolute;
        bottom: 0;
        left: 0;
        right: 0;
        height: 1px;
        background: var(--divider-color);
      }

      .scrollable {
        padding: 0 24px;

        @apply --layout-scroll;
        @apply --paper-dialog-scrollable;
      }

      .fit {
        @apply --layout-fit;
      }
    </style>

    <div id="scrollable" class="scrollable" on-scroll="updateScrollState">
      <slot></slot>
    </div>
`,is:"paper-dialog-scrollable",properties:{dialogElement:{type:Object}},get scrollTarget(){return this.$.scrollable},ready:function(){this._ensureTarget(),this.classList.add("no-padding")},attached:function(){this._ensureTarget(),requestAnimationFrame(this.updateScrollState.bind(this))},updateScrollState:function(){this.toggleClass("is-scrolled",this.scrollTarget.scrollTop>0),this.toggleClass("can-scroll",this.scrollTarget.offsetHeight<this.scrollTarget.scrollHeight),this.toggleClass("scrolled-to-bottom",this.scrollTarget.scrollTop+this.scrollTarget.offsetHeight>=this.scrollTarget.scrollHeight)},_ensureTarget:function(){this.dialogElement=this.dialogElement||this.parentElement,this.dialogElement&&this.dialogElement.behaviors&&this.dialogElement.behaviors.indexOf(vW)>=0?(this.dialogElement.sizingTarget=this.scrollTarget,this.scrollTarget.classList.remove("fit")):this.dialogElement&&this.scrollTarget.classList.add("fit")}});var ec=Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
        position: fixed;
        clip: rect(0px,0px,0px,0px);
      }
    </style>
    <div aria-live$="[[mode]]">[[_text]]</div>
`,is:"iron-a11y-announcer",properties:{mode:{type:String,value:"polite"},timeout:{type:Number,value:150},_text:{type:String,value:""}},created:function(){ec.instance||(ec.instance=this),document.addEventListener("iron-announce",this._onIronAnnounce.bind(this))},announce:function(e){this._text="",this.async(function(){this._text=e},this.timeout)},_onIronAnnounce:function(e){e.detail&&e.detail.text&&this.announce(e.detail.text)}});ec.instance=null;ec.requestAvailability=function(){ec.instance||(ec.instance=document.createElement("iron-a11y-announcer")),document.body?document.body.appendChild(ec.instance):document.addEventListener("load",function(){document.body.appendChild(ec.instance)})};Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
      }
    </style>
    <slot id="content"></slot>
`,is:"iron-input",behaviors:[Th],properties:{bindValue:{type:String,value:""},value:{type:String,computed:"_computeValue(bindValue)"},allowedPattern:{type:String},autoValidate:{type:Boolean,value:!1},_inputElement:Object},observers:["_bindValueChanged(bindValue, _inputElement)"],listeners:{input:"_onInput",keypress:"_onKeypress"},created:function(){ec.requestAvailability(),this._previousValidInput="",this._patternAlreadyChecked=!1},attached:function(){this._observer=zt(this).observeNodes(function(e){this._initSlottedInput()}.bind(this))},detached:function(){this._observer&&(zt(this).unobserveNodes(this._observer),this._observer=null)},get inputElement(){return this._inputElement},_initSlottedInput:function(){this._inputElement=this.getEffectiveChildren()[0],this.inputElement&&this.inputElement.value&&(this.bindValue=this.inputElement.value),this.fire("iron-input-ready")},get _patternRegExp(){var e;if(this.allowedPattern)e=new RegExp(this.allowedPattern);else switch(this.inputElement.type){case"number":e=/[0-9.,e-]/;break}return e},_bindValueChanged:function(e,t){!t||(e===void 0?t.value=null:e!==t.value&&(this.inputElement.value=e),this.autoValidate&&this.validate(),this.fire("bind-value-changed",{value:e}))},_onInput:function(){if(this.allowedPattern&&!this._patternAlreadyChecked){var e=this._checkPatternValidity();e||(this._announceInvalidCharacter("Invalid string of characters not entered."),this.inputElement.value=this._previousValidInput)}this.bindValue=this._previousValidInput=this.inputElement.value,this._patternAlreadyChecked=!1},_isPrintable:function(e){var t=e.keyCode==8||e.keyCode==9||e.keyCode==13||e.keyCode==27,r=e.keyCode==19||e.keyCode==20||e.keyCode==45||e.keyCode==46||e.keyCode==144||e.keyCode==145||e.keyCode>32&&e.keyCode<41||e.keyCode>111&&e.keyCode<124;return!t&&!(e.charCode==0&&r)},_onKeypress:function(e){if(!(!this.allowedPattern&&this.inputElement.type!=="number")){var t=this._patternRegExp;if(!!t&&!(e.metaKey||e.ctrlKey||e.altKey)){this._patternAlreadyChecked=!0;var r=String.fromCharCode(e.charCode);this._isPrintable(e)&&!t.test(r)&&(e.preventDefault(),this._announceInvalidCharacter("Invalid character "+r+" not entered."))}}},_checkPatternValidity:function(){var e=this._patternRegExp;if(!e)return!0;for(var t=0;t<this.inputElement.value.length;t++)if(!e.test(this.inputElement.value[t]))return!1;return!0},validate:function(){if(!this.inputElement)return this.invalid=!1,!0;var e=this.inputElement.checkValidity();return e&&(this.required&&this.bindValue===""?e=!1:this.hasValidator()&&(e=Th.validate.call(this,this.bindValue))),this.invalid=!e,this.fire("iron-input-validate"),e},_announceInvalidCharacter:function(e){this.fire("iron-announce",{text:e})},_computeValue:function(e){return e}});var T9={attached:function(){this.fire("addon-attached")},update:function(e){}};Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
        float: right;

        @apply --paper-font-caption;
        @apply --paper-input-char-counter;
      }

      :host([hidden]) {
        display: none !important;
      }

      :host(:dir(rtl)) {
        float: left;
      }
    </style>

    <span>[[_charCounterStr]]</span>
`,is:"paper-input-char-counter",behaviors:[T9],properties:{_charCounterStr:{type:String,value:"0"}},update:function(e){if(!!e.inputElement){e.value=e.value||"";var t=e.value.toString().length.toString();e.inputElement.hasAttribute("maxlength")&&(t+="/"+e.inputElement.getAttribute("maxlength")),this._charCounterStr=t}}});var S0t=Q`
<custom-style>
  <style is="custom-style">
    html {
      --paper-input-container-shared-input-style: {
        position: relative; /* to make a stacking context */
        outline: none;
        box-shadow: none;
        padding: 0;
        margin: 0;
        width: 100%;
        max-width: 100%;
        background: transparent;
        border: none;
        color: var(--paper-input-container-input-color, var(--primary-text-color));
        -webkit-appearance: none;
        text-align: inherit;
        vertical-align: var(--paper-input-container-input-align, bottom);

        @apply --paper-font-subhead;
      };
    }
  </style>
</custom-style>
`;S0t.setAttribute("style","display: none;");document.head.appendChild(S0t.content);Yt({_template:Q`
    <style>
      :host {
        display: block;
        padding: 8px 0;
        @apply --paper-input-container;
      }

      :host([inline]) {
        display: inline-block;
      }

      :host([disabled]) {
        pointer-events: none;
        opacity: 0.33;

        @apply --paper-input-container-disabled;
      }

      :host([hidden]) {
        display: none !important;
      }

      [hidden] {
        display: none !important;
      }

      .floated-label-placeholder {
        @apply --paper-font-caption;
      }

      .underline {
        height: 2px;
        position: relative;
      }

      .focused-line {
        @apply --layout-fit;
        border-bottom: 2px solid var(--paper-input-container-focus-color, var(--primary-color));

        -webkit-transform-origin: center center;
        transform-origin: center center;
        -webkit-transform: scale3d(0,1,1);
        transform: scale3d(0,1,1);

        @apply --paper-input-container-underline-focus;
      }

      .underline.is-highlighted .focused-line {
        -webkit-transform: none;
        transform: none;
        -webkit-transition: -webkit-transform 0.25s;
        transition: transform 0.25s;

        @apply --paper-transition-easing;
      }

      .underline.is-invalid .focused-line {
        border-color: var(--paper-input-container-invalid-color, var(--error-color));
        -webkit-transform: none;
        transform: none;
        -webkit-transition: -webkit-transform 0.25s;
        transition: transform 0.25s;

        @apply --paper-transition-easing;
      }

      .unfocused-line {
        @apply --layout-fit;
        border-bottom: 1px solid var(--paper-input-container-color, var(--secondary-text-color));
        @apply --paper-input-container-underline;
      }

      :host([disabled]) .unfocused-line {
        border-bottom: 1px dashed;
        border-color: var(--paper-input-container-color, var(--secondary-text-color));
        @apply --paper-input-container-underline-disabled;
      }

      .input-wrapper {
        @apply --layout-horizontal;
        @apply --layout-center;
        position: relative;
      }

      .input-content {
        @apply --layout-flex-auto;
        @apply --layout-relative;
        max-width: 100%;
      }

      .input-content ::slotted(label),
      .input-content ::slotted(.paper-input-label) {
        position: absolute;
        top: 0;
        left: 0;
        width: 100%;
        font: inherit;
        color: var(--paper-input-container-color, var(--secondary-text-color));
        -webkit-transition: -webkit-transform 0.25s, width 0.25s;
        transition: transform 0.25s, width 0.25s;
        -webkit-transform-origin: left top;
        transform-origin: left top;
        /* Fix for safari not focusing 0-height date/time inputs with -webkit-apperance: none; */
        min-height: 1px;

        @apply --paper-font-common-nowrap;
        @apply --paper-font-subhead;
        @apply --paper-input-container-label;
        @apply --paper-transition-easing;
      }


      .input-content ::slotted(label):before,
      .input-content ::slotted(.paper-input-label):before {
        @apply --paper-input-container-label-before;
      }

      .input-content ::slotted(label):after,
      .input-content ::slotted(.paper-input-label):after {
        @apply --paper-input-container-label-after;
      }

      .input-content.label-is-floating ::slotted(label),
      .input-content.label-is-floating ::slotted(.paper-input-label) {
        -webkit-transform: translateY(-75%) scale(0.75);
        transform: translateY(-75%) scale(0.75);

        /* Since we scale to 75/100 of the size, we actually have 100/75 of the
        original space now available */
        width: 133%;

        @apply --paper-input-container-label-floating;
      }

      :host(:dir(rtl)) .input-content.label-is-floating ::slotted(label),
      :host(:dir(rtl)) .input-content.label-is-floating ::slotted(.paper-input-label) {
        right: 0;
        left: auto;
        -webkit-transform-origin: right top;
        transform-origin: right top;
      }

      .input-content.label-is-highlighted ::slotted(label),
      .input-content.label-is-highlighted ::slotted(.paper-input-label) {
        color: var(--paper-input-container-focus-color, var(--primary-color));

        @apply --paper-input-container-label-focus;
      }

      .input-content.is-invalid ::slotted(label),
      .input-content.is-invalid ::slotted(.paper-input-label) {
        color: var(--paper-input-container-invalid-color, var(--error-color));
      }

      .input-content.label-is-hidden ::slotted(label),
      .input-content.label-is-hidden ::slotted(.paper-input-label) {
        visibility: hidden;
      }

      .input-content ::slotted(input),
      .input-content ::slotted(iron-input),
      .input-content ::slotted(textarea),
      .input-content ::slotted(iron-autogrow-textarea),
      .input-content ::slotted(.paper-input-input) {
        @apply --paper-input-container-shared-input-style;
        /* The apply shim doesn't apply the nested color custom property,
          so we have to re-apply it here. */
        color: var(--paper-input-container-input-color, var(--primary-text-color));
        @apply --paper-input-container-input;
      }

      .input-content ::slotted(input)::-webkit-outer-spin-button,
      .input-content ::slotted(input)::-webkit-inner-spin-button {
        @apply --paper-input-container-input-webkit-spinner;
      }

      .input-content.focused ::slotted(input),
      .input-content.focused ::slotted(iron-input),
      .input-content.focused ::slotted(textarea),
      .input-content.focused ::slotted(iron-autogrow-textarea),
      .input-content.focused ::slotted(.paper-input-input) {
        @apply --paper-input-container-input-focus;
      }

      .input-content.is-invalid ::slotted(input),
      .input-content.is-invalid ::slotted(iron-input),
      .input-content.is-invalid ::slotted(textarea),
      .input-content.is-invalid ::slotted(iron-autogrow-textarea),
      .input-content.is-invalid ::slotted(.paper-input-input) {
        @apply --paper-input-container-input-invalid;
      }

      .prefix ::slotted(*) {
        display: inline-block;
        @apply --paper-font-subhead;
        @apply --layout-flex-none;
        @apply --paper-input-prefix;
      }

      .suffix ::slotted(*) {
        display: inline-block;
        @apply --paper-font-subhead;
        @apply --layout-flex-none;

        @apply --paper-input-suffix;
      }

      /* Firefox sets a min-width on the input, which can cause layout issues */
      .input-content ::slotted(input) {
        min-width: 0;
      }

      .input-content ::slotted(textarea) {
        resize: none;
      }

      .add-on-content {
        position: relative;
      }

      .add-on-content.is-invalid ::slotted(*) {
        color: var(--paper-input-container-invalid-color, var(--error-color));
      }

      .add-on-content.is-highlighted ::slotted(*) {
        color: var(--paper-input-container-focus-color, var(--primary-color));
      }
    </style>

    <div class="floated-label-placeholder" aria-hidden="true" hidden="[[noLabelFloat]]">&nbsp;</div>

    <div class="input-wrapper">
      <span class="prefix"><slot name="prefix"></slot></span>

      <div class$="[[_computeInputContentClass(noLabelFloat,alwaysFloatLabel,focused,invalid,_inputHasContent)]]" id="labelAndInputContainer">
        <slot name="label"></slot>
        <slot name="input"></slot>
      </div>

      <span class="suffix"><slot name="suffix"></slot></span>
    </div>

    <div class$="[[_computeUnderlineClass(focused,invalid)]]">
      <div class="unfocused-line"></div>
      <div class="focused-line"></div>
    </div>

    <div class$="[[_computeAddOnContentClass(focused,invalid)]]">
      <slot name="add-on"></slot>
    </div>
`,is:"paper-input-container",properties:{noLabelFloat:{type:Boolean,value:!1},alwaysFloatLabel:{type:Boolean,value:!1},attrForValue:{type:String,value:"bind-value"},autoValidate:{type:Boolean,value:!1},invalid:{observer:"_invalidChanged",type:Boolean,value:!1},focused:{readOnly:!0,type:Boolean,value:!1,notify:!0},_addons:{type:Array},_inputHasContent:{type:Boolean,value:!1},_inputSelector:{type:String,value:"input,iron-input,textarea,.paper-input-input"},_boundOnFocus:{type:Function,value:function(){return this._onFocus.bind(this)}},_boundOnBlur:{type:Function,value:function(){return this._onBlur.bind(this)}},_boundOnInput:{type:Function,value:function(){return this._onInput.bind(this)}},_boundValueChanged:{type:Function,value:function(){return this._onValueChanged.bind(this)}}},listeners:{"addon-attached":"_onAddonAttached","iron-input-validate":"_onIronInputValidate"},get _valueChangedEvent(){return this.attrForValue+"-changed"},get _propertyForValue(){return wm(this.attrForValue)},get _inputElement(){return zt(this).querySelector(this._inputSelector)},get _inputElementValue(){return this._inputElement[this._propertyForValue]||this._inputElement.value},ready:function(){this.__isFirstValueUpdate=!0,this._addons||(this._addons=[]),this.addEventListener("focus",this._boundOnFocus,!0),this.addEventListener("blur",this._boundOnBlur,!0)},attached:function(){this.attrForValue?this._inputElement.addEventListener(this._valueChangedEvent,this._boundValueChanged):this.addEventListener("input",this._onInput),this._inputElementValue&&this._inputElementValue!=""?this._handleValueAndAutoValidate(this._inputElement):this._handleValue(this._inputElement)},_onAddonAttached:function(e){this._addons||(this._addons=[]);var t=e.target;this._addons.indexOf(t)===-1&&(this._addons.push(t),this.isAttached&&this._handleValue(this._inputElement))},_onFocus:function(){this._setFocused(!0)},_onBlur:function(){this._setFocused(!1),this._handleValueAndAutoValidate(this._inputElement)},_onInput:function(e){this._handleValueAndAutoValidate(e.target)},_onValueChanged:function(e){var t=e.target;this.__isFirstValueUpdate&&(this.__isFirstValueUpdate=!1,t.value===void 0||t.value==="")||this._handleValueAndAutoValidate(e.target)},_handleValue:function(e){var t=this._inputElementValue;t||t===0||e.type==="number"&&!e.checkValidity()?this._inputHasContent=!0:this._inputHasContent=!1,this.updateAddons({inputElement:e,value:t,invalid:this.invalid})},_handleValueAndAutoValidate:function(e){if(this.autoValidate&&e){var t;e.validate?t=e.validate(this._inputElementValue):t=e.checkValidity(),this.invalid=!t}this._handleValue(e)},_onIronInputValidate:function(e){this.invalid=this._inputElement.invalid},_invalidChanged:function(){this._addons&&this.updateAddons({invalid:this.invalid})},updateAddons:function(e){for(var t,r=0;t=this._addons[r];r++)t.update(e)},_computeInputContentClass:function(e,t,r,n,i){var o="input-content";if(e)i&&(o+=" label-is-hidden"),n&&(o+=" is-invalid");else{var a=this.querySelector("label");t||i?(o+=" label-is-floating",this.$.labelAndInputContainer.style.position="static",n?o+=" is-invalid":r&&(o+=" label-is-highlighted")):(a&&(this.$.labelAndInputContainer.style.position="relative"),n&&(o+=" is-invalid"))}return r&&(o+=" focused"),o},_computeUnderlineClass:function(e,t){var r="underline";return t?r+=" is-invalid":e&&(r+=" is-highlighted"),r},_computeAddOnContentClass:function(e,t){var r="add-on-content";return t?r+=" is-invalid":e&&(r+=" is-highlighted"),r}});Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
        visibility: hidden;

        color: var(--paper-input-container-invalid-color, var(--error-color));

        @apply --paper-font-caption;
        @apply --paper-input-error;
        position: absolute;
        left:0;
        right:0;
      }

      :host([invalid]) {
        visibility: visible;
      }

      #a11yWrapper {
        visibility: hidden;
      }

      :host([invalid]) #a11yWrapper {
        visibility: visible;
      }
    </style>

    <!--
    If the paper-input-error element is directly referenced by an
    \`aria-describedby\` attribute, such as when used as a paper-input add-on,
    then applying \`visibility: hidden;\` to the paper-input-error element itself
    does not hide the error.

    For more information, see:
    https://www.w3.org/TR/accname-1.1/#mapping_additional_nd_description
    -->
    <div id="a11yWrapper">
      <slot></slot>
    </div>
`,is:"paper-input-error",behaviors:[T9],properties:{invalid:{readOnly:!0,reflectToAttribute:!0,type:Boolean}},update:function(e){this._setInvalid(e.invalid)}});var Zx={};Zx.NextLabelID=1;Zx.NextAddonID=1;Zx.NextInputID=1;var Fbe={properties:{label:{type:String},value:{notify:!0,type:String},disabled:{type:Boolean,value:!1},invalid:{type:Boolean,value:!1,notify:!0},allowedPattern:{type:String},type:{type:String},list:{type:String},pattern:{type:String},required:{type:Boolean,value:!1},errorMessage:{type:String},charCounter:{type:Boolean,value:!1},noLabelFloat:{type:Boolean,value:!1},alwaysFloatLabel:{type:Boolean,value:!1},autoValidate:{type:Boolean,value:!1},validator:{type:String},autocomplete:{type:String,value:"off"},autofocus:{type:Boolean,observer:"_autofocusChanged"},inputmode:{type:String},minlength:{type:Number},maxlength:{type:Number},min:{type:String},max:{type:String},step:{type:String},name:{type:String},placeholder:{type:String,value:""},readonly:{type:Boolean,value:!1},size:{type:Number},autocapitalize:{type:String,value:"none"},autocorrect:{type:String,value:"off"},autosave:{type:String},results:{type:Number},accept:{type:String},multiple:{type:Boolean},_ariaDescribedBy:{type:String,value:""},_ariaLabelledBy:{type:String,value:""},_inputId:{type:String,value:""}},listeners:{"addon-attached":"_onAddonAttached"},keyBindings:{"shift+tab:keydown":"_onShiftTabDown"},hostAttributes:{tabindex:0},get inputElement(){return this.$||(this.$={}),this.$.input||(this._generateInputId(),this.$.input=this.$$("#"+this._inputId)),this.$.input},get _focusableElement(){return this.inputElement},created:function(){this._typesThatHaveText=["date","datetime","datetime-local","month","time","week","file"]},attached:function(){this._updateAriaLabelledBy(),!mt&&this.inputElement&&this._typesThatHaveText.indexOf(this.inputElement.type)!==-1&&(this.alwaysFloatLabel=!0)},_appendStringWithSpace:function(e,t){return e?e=e+" "+t:e=t,e},_onAddonAttached:function(e){var t=zt(e).rootTarget;if(t.id)this._ariaDescribedBy=this._appendStringWithSpace(this._ariaDescribedBy,t.id);else{var r="paper-input-add-on-"+Zx.NextAddonID++;t.id=r,this._ariaDescribedBy=this._appendStringWithSpace(this._ariaDescribedBy,r)}},validate:function(){return this.inputElement.validate()},_focusBlurHandler:function(e){Di._focusBlurHandler.call(this,e),this.focused&&!this._shiftTabPressed&&this._focusableElement&&this._focusableElement.focus()},_onShiftTabDown:function(e){var t=this.getAttribute("tabindex");this._shiftTabPressed=!0,this.setAttribute("tabindex","-1"),this.async(function(){this.setAttribute("tabindex",t),this._shiftTabPressed=!1},1)},_handleAutoValidate:function(){this.autoValidate&&this.validate()},updateValueAndPreserveCaret:function(e){try{var t=this.inputElement.selectionStart;this.value=e,this.inputElement.selectionStart=t,this.inputElement.selectionEnd=t}catch(r){this.value=e}},_computeAlwaysFloatLabel:function(e,t){return t||e},_updateAriaLabelledBy:function(){var e=zt(this.root).querySelector("label");if(!e){this._ariaLabelledBy="";return}var t;e.id?t=e.id:(t="paper-input-label-"+Zx.NextLabelID++,e.id=t),this._ariaLabelledBy=t},_generateInputId:function(){(!this._inputId||this._inputId==="")&&(this._inputId="input-"+Zx.NextInputID++)},_onChange:function(e){this.shadowRoot&&this.fire(e.type,{sourceEvent:e},{node:this,bubbles:e.bubbles,cancelable:e.cancelable})},_autofocusChanged:function(){if(this.autofocus&&this._focusableElement){var e=document.activeElement,t=e instanceof HTMLElement,r=t&&e!==document.body&&e!==document.documentElement;r||this._focusableElement.focus()}}},C9=[Di,Oo,Fbe];Yt({is:"paper-input",_template:Q`
    <style>
      :host {
        display: block;
      }

      :host([focused]) {
        outline: none;
      }

      :host([hidden]) {
        display: none !important;
      }

      input {
        /* Firefox sets a min-width on the input, which can cause layout issues */
        min-width: 0;
      }

      /* In 1.x, the <input> is distributed to paper-input-container, which styles it.
      In 2.x the <iron-input> is distributed to paper-input-container, which styles
      it, but in order for this to work correctly, we need to reset some
      of the native input's properties to inherit (from the iron-input) */
      iron-input > input {
        @apply --paper-input-container-shared-input-style;
        font-family: inherit;
        font-weight: inherit;
        font-size: inherit;
        letter-spacing: inherit;
        word-spacing: inherit;
        line-height: inherit;
        text-shadow: inherit;
        color: inherit;
        cursor: inherit;
      }

      input:disabled {
        @apply --paper-input-container-input-disabled;
      }

      input::-webkit-outer-spin-button,
      input::-webkit-inner-spin-button {
        @apply --paper-input-container-input-webkit-spinner;
      }

      input::-webkit-clear-button {
        @apply --paper-input-container-input-webkit-clear;
      }

      input::-webkit-calendar-picker-indicator {
        @apply --paper-input-container-input-webkit-calendar-picker-indicator;
      }

      input::-webkit-input-placeholder {
        color: var(--paper-input-container-color, var(--secondary-text-color));
      }

      input:-moz-placeholder {
        color: var(--paper-input-container-color, var(--secondary-text-color));
      }

      input::-moz-placeholder {
        color: var(--paper-input-container-color, var(--secondary-text-color));
      }

      input::-ms-clear {
        @apply --paper-input-container-ms-clear;
      }

      input::-ms-reveal {
        @apply --paper-input-container-ms-reveal;
      }

      input:-ms-input-placeholder {
        color: var(--paper-input-container-color, var(--secondary-text-color));
      }

      label {
        pointer-events: none;
      }
    </style>

    <paper-input-container id="container" no-label-float="[[noLabelFloat]]" always-float-label="[[_computeAlwaysFloatLabel(alwaysFloatLabel,placeholder)]]" auto-validate$="[[autoValidate]]" disabled$="[[disabled]]" invalid="[[invalid]]">

      <slot name="prefix" slot="prefix"></slot>

      <label hidden$="[[!label]]" aria-hidden="true" for$="[[_inputId]]" slot="label">[[label]]</label>

      <!-- Need to bind maxlength so that the paper-input-char-counter works correctly -->
      <iron-input bind-value="{{value}}" slot="input" class="input-element" id$="[[_inputId]]" maxlength$="[[maxlength]]" allowed-pattern="[[allowedPattern]]" invalid="{{invalid}}" validator="[[validator]]">
        <input aria-labelledby$="[[_ariaLabelledBy]]" aria-describedby$="[[_ariaDescribedBy]]" disabled$="[[disabled]]" title$="[[title]]" type$="[[type]]" pattern$="[[pattern]]" required$="[[required]]" autocomplete$="[[autocomplete]]" autofocus$="[[autofocus]]" inputmode$="[[inputmode]]" minlength$="[[minlength]]" maxlength$="[[maxlength]]" min$="[[min]]" max$="[[max]]" step$="[[step]]" name$="[[name]]" placeholder$="[[placeholder]]" readonly$="[[readonly]]" list$="[[list]]" size$="[[size]]" autocapitalize$="[[autocapitalize]]" autocorrect$="[[autocorrect]]" on-change="_onChange" tabindex$="[[tabIndex]]" autosave$="[[autosave]]" results$="[[results]]" accept$="[[accept]]" multiple$="[[multiple]]" role$="[[inputRole]]" aria-haspopup$="[[inputAriaHaspopup]]">
      </iron-input>

      <slot name="suffix" slot="suffix"></slot>

      <template is="dom-if" if="[[errorMessage]]">
        <paper-input-error aria-live="assertive" slot="add-on">[[errorMessage]]</paper-input-error>
      </template>

      <template is="dom-if" if="[[charCounter]]">
        <paper-input-char-counter slot="add-on"></paper-input-char-counter>
      </template>

    </paper-input-container>
  `,behaviors:[C9,Eh],properties:{value:{type:String},inputRole:{type:String,value:void 0},inputAriaHaspopup:{type:String,value:void 0}},get _focusableElement(){return this.inputElement._inputElement},listeners:{"iron-input-ready":"_onIronInputReady"},_onIronInputReady:function(){this.$.nativeInput||(this.$.nativeInput=this.$$("input")),this.inputElement&&this._typesThatHaveText.indexOf(this.$.nativeInput.type)!==-1&&(this.alwaysFloatLabel=!0),this.inputElement.bindValue&&this.$.container._handleValueAndAutoValidate(this.inputElement)}});Yt({_template:Q`
    <style>
      :host {
        position: fixed;
      }

      #contentWrapper ::slotted(*) {
        overflow: auto;
      }

      #contentWrapper.animating ::slotted(*) {
        overflow: hidden;
        pointer-events: none;
      }
    </style>

    <div id="contentWrapper">
      <slot id="content" name="dropdown-content"></slot>
    </div>
`,is:"iron-dropdown",behaviors:[Di,Oo,Kx,x9],properties:{horizontalAlign:{type:String,value:"left",reflectToAttribute:!0},verticalAlign:{type:String,value:"top",reflectToAttribute:!0},openAnimationConfig:{type:Object},closeAnimationConfig:{type:Object},focusTarget:{type:Object},noAnimations:{type:Boolean,value:!1},allowOutsideScroll:{type:Boolean,value:!1,observer:"_allowOutsideScrollChanged"}},listeners:{"neon-animation-finish":"_onNeonAnimationFinish"},observers:["_updateOverlayPosition(positionTarget, verticalAlign, horizontalAlign, verticalOffset, horizontalOffset)"],get containedElement(){for(var e=zt(this.$.content).getDistributedNodes(),t=0,r=e.length;t<r;t++)if(e[t].nodeType===Node.ELEMENT_NODE)return e[t]},ready:function(){this.scrollAction||(this.scrollAction=this.allowOutsideScroll?"refit":"lock"),this._readied=!0},attached:function(){(!this.sizingTarget||this.sizingTarget===this)&&(this.sizingTarget=this.containedElement||this)},detached:function(){this.cancelAnimation()},_openedChanged:function(){this.opened&&this.disabled?this.cancel():(this.cancelAnimation(),this._updateAnimationConfig(),Pm._openedChanged.apply(this,arguments))},_renderOpened:function(){!this.noAnimations&&this.animationConfig.open?(this.$.contentWrapper.classList.add("animating"),this.playAnimation("open")):Pm._renderOpened.apply(this,arguments)},_renderClosed:function(){!this.noAnimations&&this.animationConfig.close?(this.$.contentWrapper.classList.add("animating"),this.playAnimation("close")):Pm._renderClosed.apply(this,arguments)},_onNeonAnimationFinish:function(){this.$.contentWrapper.classList.remove("animating"),this.opened?this._finishRenderOpened():this._finishRenderClosed()},_updateAnimationConfig:function(){for(var e=this.containedElement,t=[].concat(this.openAnimationConfig||[]).concat(this.closeAnimationConfig||[]),r=0;r<t.length;r++)t[r].node=e;this.animationConfig={open:this.openAnimationConfig,close:this.closeAnimationConfig}},_updateOverlayPosition:function(){this.isAttached&&this.notifyResize()},_allowOutsideScrollChanged:function(e){!this._readied||(e?(!this.scrollAction||this.scrollAction==="lock")&&(this.scrollAction="refit"):this.scrollAction="lock")},_applyFocus:function(){var e=this.focusTarget||this.containedElement;e&&this.opened&&!this.noAutoFocus?e.focus():Pm._applyFocus.apply(this,arguments)}});var yp={properties:{animationTiming:{type:Object,value:function(){return{duration:500,easing:"cubic-bezier(0.4, 0, 0.2, 1)",fill:"both"}}}},isNeonAnimation:!0,created:function(){document.body.animate||console.warn("No web animations detected. This element will not function without a web animations polyfill.")},timingFromConfig:function(e){if(e.timing)for(var t in e.timing)this.animationTiming[t]=e.timing[t];return this.animationTiming},setPrefixedProperty:function(e,t,r){for(var n={transform:["webkitTransform"],transformOrigin:["mozTransformOrigin","webkitTransformOrigin"]},i=n[t],o,a=0;o=i[a];a++)e.style[o]=r;e.style[t]=r},complete:function(e){}};Yt({is:"fade-in-animation",behaviors:[yp],configure:function(e){var t=e.node;return this._effect=new KeyframeEffect(t,[{opacity:"0"},{opacity:"1"}],this.timingFromConfig(e)),this._effect}});Yt({is:"fade-out-animation",behaviors:[yp],configure:function(e){var t=e.node;return this._effect=new KeyframeEffect(t,[{opacity:"1"},{opacity:"0"}],this.timingFromConfig(e)),this._effect}});Yt({is:"paper-menu-grow-height-animation",_template:null,behaviors:[yp],configure:function(e){var t=e.node,r=t.getBoundingClientRect(),n=r.height;return this._effect=new KeyframeEffect(t,[{height:n/2+"px"},{height:n+"px"}],this.timingFromConfig(e)),this._effect}});Yt({is:"paper-menu-grow-width-animation",_template:null,behaviors:[yp],configure:function(e){var t=e.node,r=t.getBoundingClientRect(),n=r.width;return this._effect=new KeyframeEffect(t,[{width:n/2+"px"},{width:n+"px"}],this.timingFromConfig(e)),this._effect}});Yt({is:"paper-menu-shrink-width-animation",_template:null,behaviors:[yp],configure:function(e){var t=e.node,r=t.getBoundingClientRect(),n=r.width;return this._effect=new KeyframeEffect(t,[{width:n+"px"},{width:n-n/20+"px"}],this.timingFromConfig(e)),this._effect}});Yt({is:"paper-menu-shrink-height-animation",_template:null,behaviors:[yp],configure:function(e){var t=e.node,r=t.getBoundingClientRect(),n=r.height;return this.setPrefixedProperty(t,"transformOrigin","0 0"),this._effect=new KeyframeEffect(t,[{height:n+"px",transform:"translateY(0)"},{height:n/2+"px",transform:"translateY(-20px)"}],this.timingFromConfig(e)),this._effect}});var pE={ANIMATION_CUBIC_BEZIER:"cubic-bezier(.3,.95,.5,1)",MAX_ANIMATION_TIME_MS:400},Bbe=Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
        position: relative;
        padding: 8px;
        outline: none;

        @apply --paper-menu-button;
      }

      :host([disabled]) {
        cursor: auto;
        color: var(--disabled-text-color);

        @apply --paper-menu-button-disabled;
      }

      iron-dropdown {
        @apply --paper-menu-button-dropdown;
      }

      .dropdown-content {
        @apply --shadow-elevation-2dp;

        position: relative;
        border-radius: 2px;
        background-color: var(--paper-menu-button-dropdown-background, var(--primary-background-color));

        @apply --paper-menu-button-content;
      }

      :host([vertical-align="top"]) .dropdown-content {
        margin-bottom: 20px;
        margin-top: -10px;
        top: 10px;
      }

      :host([vertical-align="bottom"]) .dropdown-content {
        bottom: 10px;
        margin-bottom: -10px;
        margin-top: 20px;
      }

      #trigger {
        cursor: pointer;
      }
    </style>

    <div id="trigger" on-tap="toggle">
      <slot name="dropdown-trigger"></slot>
    </div>

    <iron-dropdown id="dropdown" opened="{{opened}}" horizontal-align="[[horizontalAlign]]" vertical-align="[[verticalAlign]]" dynamic-align="[[dynamicAlign]]" horizontal-offset="[[horizontalOffset]]" vertical-offset="[[verticalOffset]]" no-overlap="[[noOverlap]]" open-animation-config="[[openAnimationConfig]]" close-animation-config="[[closeAnimationConfig]]" no-animations="[[noAnimations]]" focus-target="[[_dropdownContent]]" allow-outside-scroll="[[allowOutsideScroll]]" restore-focus-on-close="[[restoreFocusOnClose]]" on-iron-overlay-canceled="__onIronOverlayCanceled" expand-sizing-target-for-scrollbars="[[expandSizingTargetForScrollbars]]">
      <div slot="dropdown-content" class="dropdown-content">
        <slot id="content" name="dropdown-content"></slot>
      </div>
    </iron-dropdown>
`,is:"paper-menu-button",behaviors:[Oo,Di],properties:{opened:{type:Boolean,value:!1,notify:!0,observer:"_openedChanged"},horizontalAlign:{type:String,value:"left",reflectToAttribute:!0},verticalAlign:{type:String,value:"top",reflectToAttribute:!0},dynamicAlign:{type:Boolean},horizontalOffset:{type:Number,value:0,notify:!0},verticalOffset:{type:Number,value:0,notify:!0},noOverlap:{type:Boolean},noAnimations:{type:Boolean,value:!1},ignoreSelect:{type:Boolean,value:!1},closeOnActivate:{type:Boolean,value:!1},openAnimationConfig:{type:Object,value:function(){return[{name:"fade-in-animation",timing:{delay:100,duration:200}},{name:"paper-menu-grow-width-animation",timing:{delay:100,duration:150,easing:pE.ANIMATION_CUBIC_BEZIER}},{name:"paper-menu-grow-height-animation",timing:{delay:100,duration:275,easing:pE.ANIMATION_CUBIC_BEZIER}}]}},closeAnimationConfig:{type:Object,value:function(){return[{name:"fade-out-animation",timing:{duration:150}},{name:"paper-menu-shrink-width-animation",timing:{delay:100,duration:50,easing:pE.ANIMATION_CUBIC_BEZIER}},{name:"paper-menu-shrink-height-animation",timing:{duration:200,easing:"ease-in"}}]}},allowOutsideScroll:{type:Boolean,value:!1},restoreFocusOnClose:{type:Boolean,value:!0},expandSizingTargetForScrollbars:{type:Boolean,value:!1},_dropdownContent:{type:Object}},hostAttributes:{role:"group","aria-haspopup":"true"},listeners:{"iron-activate":"_onIronActivate","iron-select":"_onIronSelect"},get contentElement(){for(var e=zt(this.$.content).getDistributedNodes(),t=0,r=e.length;t<r;t++)if(e[t].nodeType===Node.ELEMENT_NODE)return e[t]},toggle:function(){this.opened?this.close():this.open()},open:function(){this.disabled||this.$.dropdown.open()},close:function(){this.$.dropdown.close()},_onIronSelect:function(e){this.ignoreSelect||this.close()},_onIronActivate:function(e){this.closeOnActivate&&this.close()},_openedChanged:function(e,t){e?(this._dropdownContent=this.contentElement,this.fire("paper-dropdown-open")):t!=null&&this.fire("paper-dropdown-close")},_disabledChanged:function(e){Di._disabledChanged.apply(this,arguments),e&&this.opened&&this.close()},__onIronOverlayCanceled:function(e){var t=e.detail,r=this.$.trigger,n=zt(t).path;n.indexOf(r)>-1&&e.preventDefault()}});Object.keys(pE).forEach(function(e){Bbe[e]=pE[e]});var xW=document.createElement("template");xW.setAttribute("style","display: none;");xW.innerHTML=`<iron-iconset-svg name="paper-dropdown-menu" size="24">
<svg><defs>
<g id="arrow-drop-down"><path d="M7 10l5 5 5-5z"></path></g>
</defs></svg>
</iron-iconset-svg>`;document.head.appendChild(xW.content);var bW=document.createElement("template");bW.setAttribute("style","display: none;");bW.innerHTML=`<dom-module id="paper-dropdown-menu-shared-styles">
  <template>
    <style>
      :host {
        display: inline-block;
        position: relative;
        text-align: left;

        /* NOTE(cdata): Both values are needed, since some phones require the
         * value to be \`transparent\`.
         */
        -webkit-tap-highlight-color: rgba(0,0,0,0);
        -webkit-tap-highlight-color: transparent;

        --paper-input-container-input: {
          overflow: hidden;
          white-space: nowrap;
          text-overflow: ellipsis;
          max-width: 100%;
          box-sizing: border-box;
          cursor: pointer;
        };

        @apply --paper-dropdown-menu;
      }

      /* paper-dropdown-menu and paper-dropdown-menu-light both delegate focus
       * to other internal elements which manage focus styling. */
      :host(:focus) {
        outline: none;
      }

      :host(:dir(rtl)) {
        text-align: right;

        @apply(--paper-dropdown-menu);
      }

      :host([disabled]) {
        @apply --paper-dropdown-menu-disabled;
      }

      :host([noink]) paper-ripple {
        display: none;
      }

      :host([no-label-float]) paper-ripple {
        top: 8px;
      }

      paper-ripple {
        top: 12px;
        left: 0px;
        bottom: 8px;
        right: 0px;

        @apply --paper-dropdown-menu-ripple;
      }

      paper-menu-button {
        display: block;
        padding: 0;

        @apply --paper-dropdown-menu-button;
      }

      paper-input {
        @apply --paper-dropdown-menu-input;
      }

      iron-icon {
        color: var(--disabled-text-color);

        @apply --paper-dropdown-menu-icon;
      }
    </style>
  </template>
</dom-module>`;document.head.appendChild(bW.content);var Hbe=Gt(HTMLElement);Yt({_template:Q`
    <style include="paper-dropdown-menu-shared-styles"></style>

    <paper-menu-button id="menuButton" vertical-align="[[verticalAlign]]" horizontal-align="[[horizontalAlign]]" dynamic-align="[[dynamicAlign]]" vertical-offset="[[_computeMenuVerticalOffset(noLabelFloat, verticalOffset)]]" disabled="[[disabled]]" no-animations="[[noAnimations]]" on-iron-select="_onIronSelect" on-iron-deselect="_onIronDeselect" opened="{{opened}}" close-on-activate allow-outside-scroll="[[allowOutsideScroll]]" restore-focus-on-close="[[restoreFocusOnClose]]" expand-sizing-target-for-scrollbars="[[expandSizingTargetForScrollbars]]">
      <!-- support hybrid mode: user might be using paper-menu-button 1.x which distributes via <content> -->
      <div class="dropdown-trigger" slot="dropdown-trigger">
        <paper-ripple></paper-ripple>
        <!-- paper-input has type="text" for a11y, do not remove -->
        <paper-input id="input" type="text" invalid="[[invalid]]" readonly disabled="[[disabled]]" value="[[value]]" placeholder="[[placeholder]]" error-message="[[errorMessage]]" always-float-label="[[alwaysFloatLabel]]" no-label-float="[[noLabelFloat]]" label="[[label]]" input-role="button" input-aria-haspopup="listbox" autocomplete="off">
          <!-- support hybrid mode: user might be using paper-input 1.x which distributes via <content> -->
          <iron-icon icon="paper-dropdown-menu:arrow-drop-down" suffix slot="suffix"></iron-icon>
        </paper-input>
      </div>
      <slot id="content" name="dropdown-content" slot="dropdown-content"></slot>
    </paper-menu-button>
`,is:"paper-dropdown-menu",behaviors:[Sh,Di,Eh,Th],properties:{selectedItemLabel:{type:String,notify:!0,readOnly:!0},selectedItem:{type:Object,notify:!0,readOnly:!0},value:{type:String,notify:!0},label:{type:String},placeholder:{type:String},errorMessage:{type:String},opened:{type:Boolean,notify:!0,value:!1,observer:"_openedChanged"},allowOutsideScroll:{type:Boolean,value:!1},noLabelFloat:{type:Boolean,value:!1,reflectToAttribute:!0},alwaysFloatLabel:{type:Boolean,value:!1},noAnimations:{type:Boolean,value:!1},horizontalAlign:{type:String,value:"right"},verticalAlign:{type:String,value:"top"},verticalOffset:Number,dynamicAlign:{type:Boolean},restoreFocusOnClose:{type:Boolean,value:!0},expandSizingTargetForScrollbars:{type:Boolean,value:!1}},listeners:{tap:"_onTap"},keyBindings:{"up down":"open",esc:"close"},observers:["_selectedItemChanged(selectedItem)"],_attachDom(e){let t=ue(this);return t.attachShadow({mode:"open",delegatesFocus:!0,shadyUpgradeFragment:e}),t.shadowRoot.appendChild(e),Hbe.prototype._attachDom.call(this,e)},focus(){this.$.input._focusableElement.focus()},attached:function(){var e=this.contentElement;e&&e.selectedItem&&this._setSelectedItem(e.selectedItem)},get contentElement(){for(var e=zt(this.$.content).getDistributedNodes(),t=0,r=e.length;t<r;t++)if(e[t].nodeType===Node.ELEMENT_NODE)return e[t]},open:function(){this.$.menuButton.open()},close:function(){this.$.menuButton.close()},_onIronSelect:function(e){this._setSelectedItem(e.detail.item)},_onIronDeselect:function(e){this._setSelectedItem(null)},_onTap:function(e){igt(e)===this&&this.open()},_selectedItemChanged:function(e){var t="";e?t=e.label||e.getAttribute("label")||e.textContent.trim():t="",this.value=t,this._setSelectedItemLabel(t)},_computeMenuVerticalOffset:function(e,t){return t||(e?-4:8)},_getValidity:function(e){return this.disabled||!this.required||this.required&&!!this.value},_openedChanged:function(){var e=this.opened?"true":"false",t=this.contentElement;t&&t.setAttribute("aria-expanded",e)}});var wW=1,M0t=2,A9={outerScroll:{scroll:!0},shadowMode:{standard:M0t,waterfall:wW,"waterfall-tall":wW},tallMode:{"waterfall-tall":!0}};Yt({_template:Q`
    <style>
      :host {
        @apply --layout-vertical;
        position: relative;
        height: 100%;
        @apply --paper-header-panel;
      }

      #mainContainer {
        @apply --layout-flex;
        position: relative;
        overflow-y: auto;
        overflow-x: hidden;
        -webkit-overflow-scrolling: touch;
      }

      #mainPanel {
        @apply --layout-vertical;
        @apply --layout-flex;
        position: relative;
        min-height: 0;
        @apply --paper-header-panel-body;
      }

      #mainContainer {
        @apply --paper-header-panel-container;
      }

      /*
       * mode: scroll
       */
      :host([mode=scroll]) #mainContainer {
        @apply --paper-header-panel-scroll-container;
        overflow: visible;
      }

      :host([mode=scroll]) {
        overflow-y: auto;
        overflow-x: hidden;
        -webkit-overflow-scrolling: touch;
      }

      /*
       * mode: cover
       */
      :host([mode=cover]) #mainContainer {
        @apply --paper-header-panel-cover-container;
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
      }

      :host([mode=cover]) #mainPanel {
        position: static;
      }

      /*
       * mode: standard
       */
      :host([mode=standard]) #mainContainer {
        @apply --paper-header-panel-standard-container;
      }

      /*
       * mode: seamed
       */
      :host([mode=seamed]) #mainContainer {
        @apply --paper-header-panel-seamed-container;
      }


      /*
       * mode: waterfall
       */
      :host([mode=waterfall]) #mainContainer {
        @apply --paper-header-panel-waterfall-container;
      }

      /*
       * mode: waterfall-tall
       */
      :host([mode=waterfall-tall]) #mainContainer {
        @apply --paper-header-panel-waterfall-tall-container;
      }

      #dropShadow {
        transition: opacity 0.5s;
        height: 6px;
        box-shadow: inset 0px 5px 6px -3px rgba(0, 0, 0, 0.4);
        @apply --paper-header-panel-shadow;
        position: absolute;
        top: 0;
        left: 0;
        right: 0;
        opacity: 0;
        pointer-events: none;
      }

      #dropShadow.has-shadow {
        opacity: 1;
      }

      #mainContainer > ::slotted(.fit) {
        @apply --layout-fit;
      }

    </style>

    <slot id="headerSlot" name="header"></slot>

    <div id="mainPanel">
      <div id="mainContainer" class\$="[[_computeMainContainerClass(mode)]]">
        <slot></slot>
      </div>
      <div id="dropShadow"></div>
    </div>
`,is:"paper-header-panel",properties:{mode:{type:String,value:"standard",observer:"_modeChanged",reflectToAttribute:!0},shadow:{type:Boolean,value:!1},tallClass:{type:String,value:"tall"},atTop:{type:Boolean,value:!0,notify:!0,readOnly:!0,reflectToAttribute:!0}},observers:["_computeDropShadowHidden(atTop, mode, shadow)"],attached:function(){this._addListener(),this._keepScrollingState()},detached:function(){this._removeListener()},ready:function(){this.scrollHandler=this._scroll.bind(this),console.warn(this.is,"is deprecated. Please use app-layout instead!")},get header(){return zt(this.$.headerSlot).getDistributedNodes()[0]},get scroller(){return this._getScrollerForMode(this.mode)},get visibleShadow(){return this.$.dropShadow.classList.contains("has-shadow")},_computeDropShadowHidden:function(e,t,r){var n=A9.shadowMode[t];this.shadow?this.toggleClass("has-shadow",!0,this.$.dropShadow):n===M0t?this.toggleClass("has-shadow",!0,this.$.dropShadow):n===wW&&!e?this.toggleClass("has-shadow",!0,this.$.dropShadow):this.toggleClass("has-shadow",!1,this.$.dropShadow)},_computeMainContainerClass:function(e){var t={};return t.flex=e!=="cover",Object.keys(t).filter(function(r){return t[r]}).join(" ")},_addListener:function(){this.scroller.addEventListener("scroll",this.scrollHandler)},_removeListener:function(){this.scroller.removeEventListener("scroll",this.scrollHandler)},_modeChanged:function(e,t){var r=A9,n=this.header,i=200;n&&(r.tallMode[t]&&!r.tallMode[e]?(n.classList.remove(this.tallClass),this.async(function(){n.classList.remove("animate")},i)):this.toggleClass("animate",r.tallMode[e],n)),this._keepScrollingState()},_keepScrollingState:function(){var e=this.scroller,t=this.header;this._setAtTop(e.scrollTop===0),t&&this.tallClass&&A9.tallMode[this.mode]&&this.toggleClass(this.tallClass,this.atTop||t.classList.contains(this.tallClass)&&e.scrollHeight<this.offsetHeight,t)},_scroll:function(){this._keepScrollingState(),this.fire("content-scroll",{target:this.scroller},{bubbles:!1})},_getScrollerForMode:function(e){return A9.outerScroll[e]?this:this.$.mainContainer}});Yt({is:"paper-icon-button",_template:Q`
    <style>
      :host {
        display: inline-block;
        position: relative;
        padding: 8px;
        outline: none;
        -webkit-user-select: none;
        -moz-user-select: none;
        -ms-user-select: none;
        user-select: none;
        cursor: pointer;
        z-index: 0;
        line-height: 1;

        width: 40px;
        height: 40px;

        /*
          NOTE: Both values are needed, since some phones require the value to
          be \`transparent\`.
        */
        -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
        -webkit-tap-highlight-color: transparent;

        /* Because of polymer/2558, this style has lower specificity than * */
        box-sizing: border-box !important;

        @apply --paper-icon-button;
      }

      :host #ink {
        color: var(--paper-icon-button-ink-color, var(--primary-text-color));
        opacity: 0.6;
      }

      :host([disabled]) {
        color: var(--paper-icon-button-disabled-text, var(--disabled-text-color));
        pointer-events: none;
        cursor: auto;

        @apply --paper-icon-button-disabled;
      }

      :host([hidden]) {
        display: none !important;
      }

      :host(:hover) {
        @apply --paper-icon-button-hover;
      }

      iron-icon {
        --iron-icon-width: 100%;
        --iron-icon-height: 100%;
      }
    </style>

    <iron-icon id="icon" src="[[src]]" icon="[[icon]]"
               alt$="[[alt]]"></iron-icon>
  `,hostAttributes:{role:"button",tabindex:"0"},behaviors:[jx],registered:function(){this._template.setAttribute("strip-whitespace","")},properties:{src:{type:String},icon:{type:String},alt:{type:String,observer:"_altChanged"}},_altChanged:function(e,t){var r=this.getAttribute("aria-label");(!r||t==r)&&this.setAttribute("aria-label",e)}});Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
        position: relative;
        width: 400px;
        border: 1px solid;
        padding: 2px;
        -moz-appearance: textarea;
        -webkit-appearance: textarea;
        overflow: hidden;
      }

      .mirror-text {
        visibility: hidden;
        word-wrap: break-word;
        @apply --iron-autogrow-textarea;
      }

      .fit {
        @apply --layout-fit;
      }

      textarea {
        position: relative;
        outline: none;
        border: none;
        resize: none;
        background: inherit;
        color: inherit;
        /* see comments in template */
        width: 100%;
        height: 100%;
        font-size: inherit;
        font-family: inherit;
        line-height: inherit;
        text-align: inherit;
        @apply --iron-autogrow-textarea;
      }

      textarea::-webkit-input-placeholder {
        @apply --iron-autogrow-textarea-placeholder;
      }

      textarea:-moz-placeholder {
        @apply --iron-autogrow-textarea-placeholder;
      }

      textarea::-moz-placeholder {
        @apply --iron-autogrow-textarea-placeholder;
      }

      textarea:-ms-input-placeholder {
        @apply --iron-autogrow-textarea-placeholder;
      }
    </style>

    <!-- the mirror sizes the input/textarea so it grows with typing -->
    <!-- use &#160; instead &nbsp; of to allow this element to be used in XHTML -->
    <div id="mirror" class="mirror-text" aria-hidden="true">&nbsp;</div>

    <!-- size the input/textarea with a div, because the textarea has intrinsic size in ff -->
    <div class="textarea-container fit">
      <textarea id="textarea" name$="[[name]]" aria-label$="[[label]]" autocomplete$="[[autocomplete]]" autofocus$="[[autofocus]]" autocapitalize$="[[autocapitalize]]" inputmode$="[[inputmode]]" placeholder$="[[placeholder]]" readonly$="[[readonly]]" required$="[[required]]" disabled$="[[disabled]]" rows$="[[rows]]" minlength$="[[minlength]]" maxlength$="[[maxlength]]"></textarea>
    </div>
`,is:"iron-autogrow-textarea",behaviors:[Th,Di],properties:{value:{observer:"_valueChanged",type:String,notify:!0},bindValue:{observer:"_bindValueChanged",type:String,notify:!0},rows:{type:Number,value:1,observer:"_updateCached"},maxRows:{type:Number,value:0,observer:"_updateCached"},autocomplete:{type:String,value:"off"},autofocus:{type:Boolean,value:!1},autocapitalize:{type:String,value:"none"},inputmode:{type:String},placeholder:{type:String},readonly:{type:String},required:{type:Boolean},minlength:{type:Number},maxlength:{type:Number},label:{type:String}},listeners:{input:"_onInput"},get textarea(){return this.$.textarea},get selectionStart(){return this.$.textarea.selectionStart},get selectionEnd(){return this.$.textarea.selectionEnd},set selectionStart(e){this.$.textarea.selectionStart=e},set selectionEnd(e){this.$.textarea.selectionEnd=e},attached:function(){var e=navigator.userAgent.match(/iP(?:[oa]d|hone)/)&&!navigator.userAgent.match(/OS 1[3456789]/);e&&(this.$.textarea.style.marginLeft="-3px")},validate:function(){var e=this.$.textarea.validity.valid;return e&&(this.required&&this.value===""?e=!1:this.hasValidator()&&(e=Th.validate.call(this,this.value))),this.invalid=!e,this.fire("iron-input-validate"),e},_bindValueChanged:function(e){this.value=e},_valueChanged:function(e){var t=this.textarea;!t||(t.value!==e&&(t.value=e||e===0?e:""),this.bindValue=e,this.$.mirror.innerHTML=this._valueForMirror(),this.fire("bind-value-changed",{value:this.bindValue}))},_onInput:function(e){var t=zt(e).path;this.value=t?t[0].value:e.target.value},_constrain:function(e){var t;for(e=e||[""],this.maxRows>0&&e.length>this.maxRows?t=e.slice(0,this.maxRows):t=e.slice(0);this.rows>0&&t.length<this.rows;)t.push("");return t.join("<br/>")+"&#160;"},_valueForMirror:function(){var e=this.textarea;if(!!e)return this.tokens=e&&e.value?e.value.replace(/&/gm,"&amp;").replace(/"/gm,"&quot;").replace(/'/gm,"&#39;").replace(/</gm,"&lt;").replace(/>/gm,"&gt;").split(`
`):[""],this._constrain(this.tokens)},_updateCached:function(){this.$.mirror.innerHTML=this._constrain(this.tokens)}});Yt({_template:Q`
    <style>
      :host {
        display: block;
      }

      :host([hidden]) {
        display: none !important;
      }

      label {
        pointer-events: none;
      }
    </style>

    <paper-input-container no-label-float$="[[noLabelFloat]]" always-float-label="[[_computeAlwaysFloatLabel(alwaysFloatLabel,placeholder)]]" auto-validate$="[[autoValidate]]" disabled$="[[disabled]]" invalid="[[invalid]]">

      <label hidden$="[[!label]]" aria-hidden="true" for$="[[_inputId]]" slot="label">[[label]]</label>

      <iron-autogrow-textarea class="paper-input-input" slot="input" id$="[[_inputId]]" aria-labelledby$="[[_ariaLabelledBy]]" aria-describedby$="[[_ariaDescribedBy]]" bind-value="{{value}}" invalid="{{invalid}}" validator$="[[validator]]" disabled$="[[disabled]]" autocomplete$="[[autocomplete]]" autofocus$="[[autofocus]]" inputmode$="[[inputmode]]" name$="[[name]]" placeholder$="[[placeholder]]" readonly$="[[readonly]]" required$="[[required]]" minlength$="[[minlength]]" maxlength$="[[maxlength]]" autocapitalize$="[[autocapitalize]]" rows$="[[rows]]" max-rows$="[[maxRows]]" on-change="_onChange"></iron-autogrow-textarea>

      <template is="dom-if" if="[[errorMessage]]">
        <paper-input-error aria-live="assertive" slot="add-on">[[errorMessage]]</paper-input-error>
      </template>

      <template is="dom-if" if="[[charCounter]]">
        <paper-input-char-counter slot="add-on"></paper-input-char-counter>
      </template>

    </paper-input-container>
`,is:"paper-textarea",behaviors:[C9,Eh],properties:{_ariaLabelledBy:{observer:"_ariaLabelledByChanged",type:String},_ariaDescribedBy:{observer:"_ariaDescribedByChanged",type:String},value:{type:String},rows:{type:Number,value:1},maxRows:{type:Number,value:0}},get selectionStart(){return this.$.input.textarea.selectionStart},set selectionStart(e){this.$.input.textarea.selectionStart=e},get selectionEnd(){return this.$.input.textarea.selectionEnd},set selectionEnd(e){this.$.input.textarea.selectionEnd=e},_ariaLabelledByChanged:function(e){this._focusableElement.setAttribute("aria-labelledby",e)},_ariaDescribedByChanged:function(e){this._focusableElement.setAttribute("aria-describedby",e)},get _focusableElement(){return this.inputElement.textarea}});var SW=document.createElement("template");SW.setAttribute("style","display: none;");SW.innerHTML=`<dom-module id="paper-item-shared-styles">
  <template>
    <style>
      :host, .paper-item {
        display: block;
        position: relative;
        min-height: var(--paper-item-min-height, 48px);
        padding: 0px 16px;
      }

      .paper-item {
        @apply --paper-font-subhead;
        border:none;
        outline: none;
        background: white;
        width: 100%;
        text-align: left;
      }

      :host([hidden]), .paper-item[hidden] {
        display: none !important;
      }

      :host(.iron-selected), .paper-item.iron-selected {
        font-weight: var(--paper-item-selected-weight, bold);

        @apply --paper-item-selected;
      }

      :host([disabled]), .paper-item[disabled] {
        color: var(--paper-item-disabled-color, var(--disabled-text-color));

        @apply --paper-item-disabled;
      }

      :host(:focus), .paper-item:focus {
        position: relative;
        outline: 0;

        @apply --paper-item-focused;
      }

      :host(:focus):before, .paper-item:focus:before {
        @apply --layout-fit;

        background: currentColor;
        content: '';
        opacity: var(--dark-divider-opacity);
        pointer-events: none;

        @apply --paper-item-focused-before;
      }
    </style>
  </template>
</dom-module>`;document.head.appendChild(SW.content);var Vbe={hostAttributes:{role:"option",tabindex:"0"}},P9=[Sh,Di,Vbe];Yt({_template:Q`
    <style include="paper-item-shared-styles">
      :host {
        @apply --layout-horizontal;
        @apply --layout-center;
        @apply --paper-font-subhead;

        @apply --paper-item;
      }
    </style>
    <slot></slot>
`,is:"paper-item",behaviors:[P9]});Yt({_template:Q`
    <style>
      :host {
        overflow: hidden; /* needed for text-overflow: ellipsis to work on ff */
        @apply --layout-vertical;
        @apply --layout-center-justified;
        @apply --layout-flex;
      }

      :host([two-line]) {
        min-height: var(--paper-item-body-two-line-min-height, 72px);
      }

      :host([three-line]) {
        min-height: var(--paper-item-body-three-line-min-height, 88px);
      }

      :host > ::slotted(*) {
        overflow: hidden;
        text-overflow: ellipsis;
        white-space: nowrap;
      }

      :host > ::slotted([secondary]) {
        @apply --paper-font-body1;

        color: var(--paper-item-body-secondary-color, var(--secondary-text-color));

        @apply --paper-item-body-secondary;
      }
    </style>

    <slot></slot>
`,is:"paper-item-body"});Yt({_template:Q`
    <style include="paper-item-shared-styles"></style>
    <style>
      :host {
        @apply --layout-horizontal;
        @apply --layout-center;
        @apply --paper-font-subhead;

        @apply --paper-item;
        @apply --paper-icon-item;
      }

      .content-icon {
        @apply --layout-horizontal;
        @apply --layout-center;

        width: var(--paper-item-icon-width, 56px);
        @apply --paper-item-icon;
      }
    </style>

    <div id="contentIcon" class="content-icon">
      <slot name="item-icon"></slot>
    </div>
    <slot></slot>
`,is:"paper-icon-item",behaviors:[P9]});var MW={properties:{multi:{type:Boolean,value:!1,observer:"multiChanged"},selectedValues:{type:Array,notify:!0,value:function(){return[]}},selectedItems:{type:Array,readOnly:!0,notify:!0,value:function(){return[]}}},observers:["_updateSelected(selectedValues.splices)"],select:function(e){this.multi?this._toggleSelected(e):this.selected=e},multiChanged:function(e){this._selection.multi=e,this._updateSelected()},get _shouldUpdateSelection(){return this.selected!=null||this.selectedValues!=null&&this.selectedValues.length},_updateAttrForSelected:function(){this.multi?this.selectedItems&&this.selectedItems.length>0&&(this.selectedValues=this.selectedItems.map(function(e){return this._indexToValue(this.indexOf(e))},this).filter(function(e){return e!=null},this)):wh._updateAttrForSelected.apply(this)},_updateSelected:function(){this.multi?this._selectMulti(this.selectedValues):this._selectSelected(this.selected)},_selectMulti:function(e){e=e||[];var t=(this._valuesToItems(e)||[]).filter(function(i){return i!=null});this._selection.clear(t);for(var r=0;r<t.length;r++)this._selection.setItemSelected(t[r],!0);if(this.fallbackSelection&&!this._selection.get().length){var n=this._valueToItem(this.fallbackSelection);n&&this.select(this.fallbackSelection)}},_selectionChange:function(){var e=this._selection.get();this.multi?(this._setSelectedItems(e),this._setSelectedItem(e.length?e[0]:null)):e!=null?(this._setSelectedItems([e]),this._setSelectedItem(e)):(this._setSelectedItems([]),this._setSelectedItem(null))},_toggleSelected:function(e){var t=this.selectedValues.indexOf(e),r=t<0;r?this.push("selectedValues",e):this.splice("selectedValues",t,1)},_valuesToItems:function(e){return e==null?null:e.map(function(t){return this._valueToItem(t)},this)}},E0t=[wh,MW];var __={properties:{focusedItem:{observer:"_focusedItemChanged",readOnly:!0,type:Object},attrForItemTitle:{type:String},disabled:{type:Boolean,value:!1,observer:"_disabledChanged"}},_MODIFIER_KEYS:["Alt","AltGraph","CapsLock","Control","Fn","FnLock","Hyper","Meta","NumLock","OS","ScrollLock","Shift","Super","Symbol","SymbolLock"],_SEARCH_RESET_TIMEOUT_MS:1e3,_previousTabIndex:0,hostAttributes:{role:"menu"},observers:["_updateMultiselectable(multi)"],listeners:{focus:"_onFocus",keydown:"_onKeydown","iron-items-changed":"_onIronItemsChanged"},keyBindings:{up:"_onUpKey",down:"_onDownKey",esc:"_onEscKey","shift+tab:keydown":"_onShiftTabDown"},attached:function(){this._resetTabindices()},select:function(e){this._defaultFocusAsync&&(this.cancelAsync(this._defaultFocusAsync),this._defaultFocusAsync=null);var t=this._valueToItem(e);t&&t.hasAttribute("disabled")||(this._setFocusedItem(t),MW.select.apply(this,arguments))},_resetTabindices:function(){var e=this.multi?this.selectedItems&&this.selectedItems[0]:this.selectedItem;this.items.forEach(function(t){t.setAttribute("tabindex",t===e?"0":"-1"),t.setAttribute("aria-selected",this._selection.isSelected(t))},this)},_updateMultiselectable:function(e){e?this.setAttribute("aria-multiselectable","true"):this.removeAttribute("aria-multiselectable")},_focusWithKeyboardEvent:function(e){if(this._MODIFIER_KEYS.indexOf(e.key)===-1){this.cancelDebouncer("_clearSearchText");var t=this._searchText||"",r=e.key&&e.key.length==1?e.key:String.fromCharCode(e.keyCode);t+=r.toLocaleLowerCase();for(var n=t.length,i=0,o;o=this.items[i];i++)if(!o.hasAttribute("disabled")){var a=this.attrForItemTitle||"textContent",s=(o[a]||o.getAttribute(a)||"").trim();if(!(s.length<n)&&s.slice(0,n).toLocaleLowerCase()==t){this._setFocusedItem(o);break}}this._searchText=t,this.debounce("_clearSearchText",this._clearSearchText,this._SEARCH_RESET_TIMEOUT_MS)}},_clearSearchText:function(){this._searchText=""},_focusPrevious:function(){for(var e=this.items.length,t=Number(this.indexOf(this.focusedItem)),r=1;r<e+1;r++){var n=this.items[(t-r+e)%e];if(!n.hasAttribute("disabled")){var i=zt(n).getOwnerRoot()||document;if(this._setFocusedItem(n),zt(i).activeElement==n)return}}},_focusNext:function(){for(var e=this.items.length,t=Number(this.indexOf(this.focusedItem)),r=1;r<e+1;r++){var n=this.items[(t+r)%e];if(!n.hasAttribute("disabled")){var i=zt(n).getOwnerRoot()||document;if(this._setFocusedItem(n),zt(i).activeElement==n)return}}},_applySelection:function(e,t){t?e.setAttribute("aria-selected","true"):e.setAttribute("aria-selected","false"),wh._applySelection.apply(this,arguments)},_focusedItemChanged:function(e,t){t&&t.setAttribute("tabindex","-1"),e&&!e.hasAttribute("disabled")&&!this.disabled&&(e.setAttribute("tabindex","0"),e.focus())},_onIronItemsChanged:function(e){e.detail.addedNodes.length&&this._resetTabindices()},_onShiftTabDown:function(e){var t=this.getAttribute("tabindex");__._shiftTabPressed=!0,this._setFocusedItem(null),this.setAttribute("tabindex","-1"),this.async(function(){this.setAttribute("tabindex",t),__._shiftTabPressed=!1},1)},_onFocus:function(e){if(!__._shiftTabPressed){var t=zt(e).rootTarget;t!==this&&typeof t.tabIndex!="undefined"&&!this.isLightDescendant(t)||(this._defaultFocusAsync=this.async(function(){var r=this.multi?this.selectedItems&&this.selectedItems[0]:this.selectedItem;this._setFocusedItem(null),r?this._setFocusedItem(r):this.items[0]&&this._focusNext()}))}},_onUpKey:function(e){this._focusPrevious(),e.detail.keyboardEvent.preventDefault()},_onDownKey:function(e){this._focusNext(),e.detail.keyboardEvent.preventDefault()},_onEscKey:function(e){var t=this.focusedItem;t&&t.blur()},_onKeydown:function(e){this.keyboardEventMatchesKeys(e,"up down esc")||this._focusWithKeyboardEvent(e),e.stopPropagation()},_activateHandler:function(e){wh._activateHandler.call(this,e),e.stopPropagation()},_disabledChanged:function(e){e?(this._previousTabIndex=this.hasAttribute("tabindex")?this.tabIndex:0,this.removeAttribute("tabindex")):this.hasAttribute("tabindex")||this.setAttribute("tabindex",this._previousTabIndex)}};__._shiftTabPressed=!1;var I9=[E0t,Oo,__];Yt({_template:Q`
    <style>
      :host {
        display: block;
        padding: 8px 0;

        background: var(--paper-listbox-background-color, var(--primary-background-color));
        color: var(--paper-listbox-color, var(--primary-text-color));

        @apply --paper-listbox;
      }
    </style>

    <slot></slot>
`,is:"paper-listbox",behaviors:[I9],hostAttributes:{role:"listbox"}});var T0t=Q`
<dom-module id="paper-material-shared-styles">
  <template>
    <style>
      :host {
        display: block;
        position: relative;
      }

      :host([elevation="1"]) {
        @apply --shadow-elevation-2dp;
      }

      :host([elevation="2"]) {
        @apply --shadow-elevation-4dp;
      }

      :host([elevation="3"]) {
        @apply --shadow-elevation-6dp;
      }

      :host([elevation="4"]) {
        @apply --shadow-elevation-8dp;
      }

      :host([elevation="5"]) {
        @apply --shadow-elevation-16dp;
      }
    </style>
  </template>
</dom-module>
`;T0t.setAttribute("style","display: none;");document.body.appendChild(T0t.content);Yt({_template:Q`
    <style include="paper-material-shared-styles"></style>
    <style>
      :host([animated]) {
        @apply --shadow-transition;
      }
      :host {
        @apply --paper-material;
      }
    </style>

    <slot></slot>
`,is:"paper-material",properties:{elevation:{type:Number,reflectToAttribute:!0,value:1},animated:{type:Boolean,reflectToAttribute:!0,value:!1}}});var L9={properties:{value:{type:Number,value:0,notify:!0,reflectToAttribute:!0},min:{type:Number,value:0,notify:!0},max:{type:Number,value:100,notify:!0},step:{type:Number,value:1,notify:!0},ratio:{type:Number,value:0,readOnly:!0,notify:!0}},observers:["_update(value, min, max, step)"],_calcRatio:function(e){return(this._clampValue(e)-this.min)/(this.max-this.min)},_clampValue:function(e){return Math.min(this.max,Math.max(this.min,this._calcStep(e)))},_calcStep:function(e){if(e=parseFloat(e),!this.step)return e;var t=Math.round((e-this.min)/this.step);return this.step<1?t/(1/this.step)+this.min:t*this.step+this.min},_validateValue:function(){var e=this._clampValue(this.value);return this.value=this.oldValue=isNaN(e)?this.oldValue:e,this.value!==e},_update:function(){this._validateValue(),this._setRatio(this._calcRatio(this.value)*100)}};Yt({_template:Q`
    <style>
      :host {
        display: block;
        width: 200px;
        position: relative;
        overflow: hidden;
      }

      :host([hidden]), [hidden] {
        display: none !important;
      }

      #progressContainer {
        @apply --paper-progress-container;
        position: relative;
      }

      #progressContainer,
      /* the stripe for the indeterminate animation*/
      .indeterminate::after {
        height: var(--paper-progress-height, 4px);
      }

      #primaryProgress,
      #secondaryProgress,
      .indeterminate::after {
        @apply --layout-fit;
      }

      #progressContainer,
      .indeterminate::after {
        background: var(--paper-progress-container-color, var(--google-grey-300));
      }

      :host(.transiting) #primaryProgress,
      :host(.transiting) #secondaryProgress {
        -webkit-transition-property: -webkit-transform;
        transition-property: transform;

        /* Duration */
        -webkit-transition-duration: var(--paper-progress-transition-duration, 0.08s);
        transition-duration: var(--paper-progress-transition-duration, 0.08s);

        /* Timing function */
        -webkit-transition-timing-function: var(--paper-progress-transition-timing-function, ease);
        transition-timing-function: var(--paper-progress-transition-timing-function, ease);

        /* Delay */
        -webkit-transition-delay: var(--paper-progress-transition-delay, 0s);
        transition-delay: var(--paper-progress-transition-delay, 0s);
      }

      #primaryProgress,
      #secondaryProgress {
        @apply --layout-fit;
        -webkit-transform-origin: left center;
        transform-origin: left center;
        -webkit-transform: scaleX(0);
        transform: scaleX(0);
        will-change: transform;
      }

      #primaryProgress {
        background: var(--paper-progress-active-color, var(--google-green-500));
      }

      #secondaryProgress {
        background: var(--paper-progress-secondary-color, var(--google-green-100));
      }

      :host([disabled]) #primaryProgress {
        background: var(--paper-progress-disabled-active-color, var(--google-grey-500));
      }

      :host([disabled]) #secondaryProgress {
        background: var(--paper-progress-disabled-secondary-color, var(--google-grey-300));
      }

      :host(:not([disabled])) #primaryProgress.indeterminate {
        -webkit-transform-origin: right center;
        transform-origin: right center;
        -webkit-animation: indeterminate-bar var(--paper-progress-indeterminate-cycle-duration, 2s) linear infinite;
        animation: indeterminate-bar var(--paper-progress-indeterminate-cycle-duration, 2s) linear infinite;
      }

      :host(:not([disabled])) #primaryProgress.indeterminate::after {
        content: "";
        -webkit-transform-origin: center center;
        transform-origin: center center;

        -webkit-animation: indeterminate-splitter var(--paper-progress-indeterminate-cycle-duration, 2s) linear infinite;
        animation: indeterminate-splitter var(--paper-progress-indeterminate-cycle-duration, 2s) linear infinite;
      }

      @-webkit-keyframes indeterminate-bar {
        0% {
          -webkit-transform: scaleX(1) translateX(-100%);
        }
        50% {
          -webkit-transform: scaleX(1) translateX(0%);
        }
        75% {
          -webkit-transform: scaleX(1) translateX(0%);
          -webkit-animation-timing-function: cubic-bezier(.28,.62,.37,.91);
        }
        100% {
          -webkit-transform: scaleX(0) translateX(0%);
        }
      }

      @-webkit-keyframes indeterminate-splitter {
        0% {
          -webkit-transform: scaleX(.75) translateX(-125%);
        }
        30% {
          -webkit-transform: scaleX(.75) translateX(-125%);
          -webkit-animation-timing-function: cubic-bezier(.42,0,.6,.8);
        }
        90% {
          -webkit-transform: scaleX(.75) translateX(125%);
        }
        100% {
          -webkit-transform: scaleX(.75) translateX(125%);
        }
      }

      @keyframes indeterminate-bar {
        0% {
          transform: scaleX(1) translateX(-100%);
        }
        50% {
          transform: scaleX(1) translateX(0%);
        }
        75% {
          transform: scaleX(1) translateX(0%);
          animation-timing-function: cubic-bezier(.28,.62,.37,.91);
        }
        100% {
          transform: scaleX(0) translateX(0%);
        }
      }

      @keyframes indeterminate-splitter {
        0% {
          transform: scaleX(.75) translateX(-125%);
        }
        30% {
          transform: scaleX(.75) translateX(-125%);
          animation-timing-function: cubic-bezier(.42,0,.6,.8);
        }
        90% {
          transform: scaleX(.75) translateX(125%);
        }
        100% {
          transform: scaleX(.75) translateX(125%);
        }
      }
    </style>

    <div id="progressContainer">
      <div id="secondaryProgress" hidden\$="[[_hideSecondaryProgress(secondaryRatio)]]"></div>
      <div id="primaryProgress"></div>
    </div>
`,is:"paper-progress",behaviors:[L9],properties:{secondaryProgress:{type:Number,value:0},secondaryRatio:{type:Number,value:0,readOnly:!0},indeterminate:{type:Boolean,value:!1,observer:"_toggleIndeterminate"},disabled:{type:Boolean,value:!1,reflectToAttribute:!0,observer:"_disabledChanged"}},observers:["_progressChanged(secondaryProgress, value, min, max, indeterminate)"],hostAttributes:{role:"progressbar"},_toggleIndeterminate:function(e){this.toggleClass("indeterminate",e,this.$.primaryProgress)},_transformProgress:function(e,t){var r="scaleX("+t/100+")";e.style.transform=e.style.webkitTransform=r},_mainRatioChanged:function(e){this._transformProgress(this.$.primaryProgress,e)},_progressChanged:function(e,t,r,n,i){e=this._clampValue(e),t=this._clampValue(t);var o=this._calcRatio(e)*100,a=this._calcRatio(t)*100;this._setSecondaryRatio(o),this._transformProgress(this.$.secondaryProgress,o),this._transformProgress(this.$.primaryProgress,a),this.secondaryProgress=e,i?this.removeAttribute("aria-valuenow"):this.setAttribute("aria-valuenow",t),this.setAttribute("aria-valuemin",r),this.setAttribute("aria-valuemax",n)},_disabledChanged:function(e){this.setAttribute("aria-disabled",e?"true":"false")},_hideSecondaryProgress:function(e){return e===0}});var C0t=Q`
<style>
  :host {
    display: inline-block;
    line-height: 0;
    white-space: nowrap;
    cursor: pointer;
    @apply --paper-font-common-base;
    --calculated-paper-radio-button-size: var(--paper-radio-button-size, 16px);
    /* -1px is a sentinel for the default and is replace in \`attached\`. */
    --calculated-paper-radio-button-ink-size: var(--paper-radio-button-ink-size, -1px);
  }

  :host(:focus) {
    outline: none;
  }

  #radioContainer {
    @apply --layout-inline;
    @apply --layout-center-center;
    position: relative;
    width: var(--calculated-paper-radio-button-size);
    height: var(--calculated-paper-radio-button-size);
    vertical-align: middle;

    @apply --paper-radio-button-radio-container;
  }

  #ink {
    position: absolute;
    top: 50%;
    left: 50%;
    right: auto;
    width: var(--calculated-paper-radio-button-ink-size);
    height: var(--calculated-paper-radio-button-ink-size);
    color: var(--paper-radio-button-unchecked-ink-color, var(--primary-text-color));
    opacity: 0.6;
    pointer-events: none;
    -webkit-transform: translate(-50%, -50%);
    transform: translate(-50%, -50%);
  }

  #ink[checked] {
    color: var(--paper-radio-button-checked-ink-color, var(--primary-color));
  }

  #offRadio, #onRadio {
    position: absolute;
    box-sizing: border-box;
    top: 0;
    left: 0;
    width: 100%;
    height: 100%;
    border-radius: 50%;
  }

  #offRadio {
    border: 2px solid var(--paper-radio-button-unchecked-color, var(--primary-text-color));
    background-color: var(--paper-radio-button-unchecked-background-color, transparent);
    transition: border-color 0.28s;
  }

  #onRadio {
    background-color: var(--paper-radio-button-checked-color, var(--primary-color));
    -webkit-transform: scale(0);
    transform: scale(0);
    transition: -webkit-transform ease 0.28s;
    transition: transform ease 0.28s;
    will-change: transform;
  }

  :host([checked]) #offRadio {
    border-color: var(--paper-radio-button-checked-color, var(--primary-color));
  }

  :host([checked]) #onRadio {
    -webkit-transform: scale(0.5);
    transform: scale(0.5);
  }

  #radioLabel {
    line-height: normal;
    position: relative;
    display: inline-block;
    vertical-align: middle;
    margin-left: var(--paper-radio-button-label-spacing, 10px);
    white-space: normal;
    color: var(--paper-radio-button-label-color, var(--primary-text-color));

    @apply --paper-radio-button-label;
  }

  :host([checked]) #radioLabel {
    @apply --paper-radio-button-label-checked;
  }

  #radioLabel:dir(rtl) {
    margin-left: 0;
    margin-right: var(--paper-radio-button-label-spacing, 10px);
  }

  #radioLabel[hidden] {
    display: none;
  }

  /* disabled state */

  :host([disabled]) #offRadio {
    border-color: var(--paper-radio-button-unchecked-color, var(--primary-text-color));
    opacity: 0.5;
  }

  :host([disabled][checked]) #onRadio {
    background-color: var(--paper-radio-button-unchecked-color, var(--primary-text-color));
    opacity: 0.5;
  }

  :host([disabled]) #radioLabel {
    /* slightly darker than the button, so that it's readable */
    opacity: 0.65;
  }
</style>

<div id="radioContainer">
  <div id="offRadio"></div>
  <div id="onRadio"></div>
</div>

<div id="radioLabel"><slot></slot></div>`;C0t.setAttribute("strip-whitespace","");Yt({_template:C0t,is:"paper-radio-button",behaviors:[Xx],hostAttributes:{role:"radio","aria-checked":!1,tabindex:0},properties:{ariaActiveAttribute:{type:String,value:"aria-checked"}},ready:function(){this._rippleContainer=this.$.radioContainer},attached:function(){Tm(this,function(){var e=this.getComputedStyleValue("--calculated-paper-radio-button-ink-size").trim();if(e==="-1px"){var t=parseFloat(this.getComputedStyleValue("--calculated-paper-radio-button-size").trim()),r=Math.floor(3*t);r%2!==t%2&&r++,this.updateStyles({"--paper-radio-button-ink-size":r+"px"})}})}});var k9={hostAttributes:{role:"menubar"},keyBindings:{left:"_onLeftKey",right:"_onRightKey"},_onUpKey:function(e){this.focusedItem.click(),e.detail.keyboardEvent.preventDefault()},_onDownKey:function(e){this.focusedItem.click(),e.detail.keyboardEvent.preventDefault()},get _isRTL(){return window.getComputedStyle(this).direction==="rtl"},_onLeftKey:function(e){this._isRTL?this._focusNext():this._focusPrevious(),e.detail.keyboardEvent.preventDefault()},_onRightKey:function(e){this._isRTL?this._focusPrevious():this._focusNext(),e.detail.keyboardEvent.preventDefault()},_onKeydown:function(e){this.keyboardEventMatchesKeys(e,"up down left right esc")||this._focusWithKeyboardEvent(e)}},R9=[I9,k9];Yt({_template:Q`
    <style>
      :host {
        display: inline-block;
      }

      :host ::slotted(*) {
        padding: var(--paper-radio-group-item-padding, 12px);
      }
    </style>

    <slot></slot>
`,is:"paper-radio-group",behaviors:[R9],hostAttributes:{role:"radiogroup"},properties:{attrForSelected:{type:String,value:"name"},selectedAttribute:{type:String,value:"checked"},selectable:{type:String,value:"paper-radio-button"},allowEmptySelection:{type:Boolean,value:!1}},select:function(e){var t=this._valueToItem(e);if(!(t&&t.hasAttribute("disabled"))){if(this.selected){var r=this._valueToItem(this.selected);if(this.selected==e)if(this.allowEmptySelection)e="";else{r&&(r.checked=!0);return}r&&(r.checked=!1)}wh.select.apply(this,[e]),this.fire("paper-radio-group-changed")}},_activateFocusedItem:function(){this._itemActivate(this._valueForItem(this.focusedItem),this.focusedItem)},_onUpKey:function(e){this._focusPrevious(),e.preventDefault(),this._activateFocusedItem()},_onDownKey:function(e){this._focusNext(),e.preventDefault(),this._activateFocusedItem()},_onLeftKey:function(e){k9._onLeftKey.apply(this,arguments),this._activateFocusedItem()},_onRightKey:function(e){k9._onRightKey.apply(this,arguments),this._activateFocusedItem()}});var A0t=Q`
  <style>
    :host {
      @apply --layout;
      @apply --layout-justified;
      @apply --layout-center;
      width: 200px;
      cursor: default;
      -webkit-user-select: none;
      -moz-user-select: none;
      -ms-user-select: none;
      user-select: none;
      -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
      --paper-progress-active-color: var(--paper-slider-active-color, var(--google-blue-700));
      --paper-progress-secondary-color: var(--paper-slider-secondary-color, var(--google-blue-300));
      --paper-progress-disabled-active-color: var(--paper-slider-disabled-active-color, var(--paper-grey-400));
      --paper-progress-disabled-secondary-color: var(--paper-slider-disabled-secondary-color, var(--paper-grey-400));
      --calculated-paper-slider-height: var(--paper-slider-height, 2px);
    }

    /* focus shows the ripple */
    :host(:focus) {
      outline: none;
    }

    /**
      * NOTE(keanulee): Though :host-context is not universally supported, some pages
      * still rely on paper-slider being flipped when dir="rtl" is set on body. For full
      * compatibility, dir="rtl" must be explicitly set on paper-slider.
      */
    :dir(rtl) #sliderContainer {
      -webkit-transform: scaleX(-1);
      transform: scaleX(-1);
    }

    /**
      * NOTE(keanulee): This is separate from the rule above because :host-context may
      * not be recognized.
      */
    :host([dir="rtl"]) #sliderContainer {
      -webkit-transform: scaleX(-1);
      transform: scaleX(-1);
    }

    /**
      * NOTE(keanulee): Needed to override the :host-context rule (where supported)
      * to support LTR sliders in RTL pages.
      */
    :host([dir="ltr"]) #sliderContainer {
      -webkit-transform: scaleX(1);
      transform: scaleX(1);
    }

    #sliderContainer {
      position: relative;
      width: 100%;
      height: calc(30px + var(--calculated-paper-slider-height));
      margin-left: calc(15px + var(--calculated-paper-slider-height)/2);
      margin-right: calc(15px + var(--calculated-paper-slider-height)/2);
    }

    #sliderContainer:focus {
      outline: 0;
    }

    #sliderContainer.editable {
      margin-top: 12px;
      margin-bottom: 12px;
    }

    .bar-container {
      position: absolute;
      top: 0;
      bottom: 0;
      left: 0;
      right: 0;
      overflow: hidden;
    }

    .ring > .bar-container {
      left: calc(5px + var(--calculated-paper-slider-height)/2);
      transition: left 0.18s ease;
    }

    .ring.expand.dragging > .bar-container {
      transition: none;
    }

    .ring.expand:not(.pin) > .bar-container {
      left: calc(8px + var(--calculated-paper-slider-height)/2);
    }

    #sliderBar {
      padding: 15px 0;
      width: 100%;
      background-color: var(--paper-slider-bar-color, transparent);
      --paper-progress-container-color: var(--paper-slider-container-color, var(--paper-grey-400));
      --paper-progress-height: var(--calculated-paper-slider-height);
    }

    .slider-markers {
      position: absolute;
      /* slider-knob is 30px + the slider-height so that the markers should start at a offset of 15px*/
      top: 15px;
      height: var(--calculated-paper-slider-height);
      left: 0;
      right: -1px;
      box-sizing: border-box;
      pointer-events: none;
      @apply --layout-horizontal;
    }

    .slider-marker {
      @apply --layout-flex;
    }
    .slider-markers::after,
    .slider-marker::after {
      content: "";
      display: block;
      margin-left: -1px;
      width: 2px;
      height: var(--calculated-paper-slider-height);
      border-radius: 50%;
      background-color: var(--paper-slider-markers-color, #000);
    }

    .slider-knob {
      position: absolute;
      left: 0;
      top: 0;
      margin-left: calc(-15px - var(--calculated-paper-slider-height)/2);
      width: calc(30px + var(--calculated-paper-slider-height));
      height: calc(30px + var(--calculated-paper-slider-height));
    }

    .transiting > .slider-knob {
      transition: left 0.08s ease;
    }

    .slider-knob:focus {
      outline: none;
    }

    .slider-knob.dragging {
      transition: none;
    }

    .snaps > .slider-knob.dragging {
      transition: -webkit-transform 0.08s ease;
      transition: transform 0.08s ease;
    }

    .slider-knob-inner {
      margin: 10px;
      width: calc(100% - 20px);
      height: calc(100% - 20px);
      background-color: var(--paper-slider-knob-color, var(--google-blue-700));
      border: 2px solid var(--paper-slider-knob-color, var(--google-blue-700));
      border-radius: 50%;

      -moz-box-sizing: border-box;
      box-sizing: border-box;

      transition-property: -webkit-transform, background-color, border;
      transition-property: transform, background-color, border;
      transition-duration: 0.18s;
      transition-timing-function: ease;
    }

    .expand:not(.pin) > .slider-knob > .slider-knob-inner {
      -webkit-transform: scale(1.5);
      transform: scale(1.5);
    }

    .ring > .slider-knob > .slider-knob-inner {
      background-color: var(--paper-slider-knob-start-color, transparent);
      border: 2px solid var(--paper-slider-knob-start-border-color, var(--paper-grey-400));
    }

    .slider-knob-inner::before {
      background-color: var(--paper-slider-pin-color, var(--google-blue-700));
    }

    .pin > .slider-knob > .slider-knob-inner::before {
      content: "";
      position: absolute;
      top: 0;
      left: 50%;
      margin-left: -13px;
      width: 26px;
      height: 26px;
      border-radius: 50% 50% 50% 0;

      -webkit-transform: rotate(-45deg) scale(0) translate(0);
      transform: rotate(-45deg) scale(0) translate(0);
    }

    .slider-knob-inner::before,
    .slider-knob-inner::after {
      transition: -webkit-transform .18s ease, background-color .18s ease;
      transition: transform .18s ease, background-color .18s ease;
    }

    .pin.ring > .slider-knob > .slider-knob-inner::before {
      background-color: var(--paper-slider-pin-start-color, var(--paper-grey-400));
    }

    .pin.expand > .slider-knob > .slider-knob-inner::before {
      -webkit-transform: rotate(-45deg) scale(1) translate(17px, -17px);
      transform: rotate(-45deg) scale(1) translate(17px, -17px);
    }

    .pin > .slider-knob > .slider-knob-inner::after {
      content: attr(value);
      position: absolute;
      top: 0;
      left: 50%;
      margin-left: -16px;
      width: 32px;
      height: 26px;
      text-align: center;
      color: var(--paper-slider-font-color, #fff);
      font-size: 10px;

      -webkit-transform: scale(0) translate(0);
      transform: scale(0) translate(0);
    }

    .pin.expand > .slider-knob > .slider-knob-inner::after {
      -webkit-transform: scale(1) translate(0, -17px);
      transform: scale(1) translate(0, -17px);
    }

    /* paper-input */
    .slider-input {
      width: 50px;
      overflow: hidden;
      --paper-input-container-input: {
        text-align: center;
        @apply --paper-slider-input-container-input;
      };
      @apply --paper-slider-input;
    }

    /* disabled state */
    #sliderContainer.disabled {
      pointer-events: none;
    }

    .disabled > .slider-knob > .slider-knob-inner {
      background-color: var(--paper-slider-disabled-knob-color, var(--paper-grey-400));
      border: 2px solid var(--paper-slider-disabled-knob-color, var(--paper-grey-400));
      -webkit-transform: scale3d(0.75, 0.75, 1);
      transform: scale3d(0.75, 0.75, 1);
    }

    .disabled.ring > .slider-knob > .slider-knob-inner {
      background-color: var(--paper-slider-knob-start-color, transparent);
      border: 2px solid var(--paper-slider-knob-start-border-color, var(--paper-grey-400));
    }

    paper-ripple {
      color: var(--paper-slider-knob-color, var(--google-blue-700));
    }
  </style>

  <div id="sliderContainer" class\$="[[_getClassNames(disabled, pin, snaps, immediateValue, min, expand, dragging, transiting, editable)]]">
    <div class="bar-container">
      <paper-progress disabled\$="[[disabled]]" id="sliderBar" aria-hidden="true" min="[[min]]" max="[[max]]" step="[[step]]" value="[[immediateValue]]" secondary-progress="[[secondaryProgress]]" on-down="_bardown" on-up="_resetKnob" on-track="_bartrack" on-tap="_barclick">
      </paper-progress>
    </div>

    <template is="dom-if" if="[[snaps]]">
      <div class="slider-markers">
        <template is="dom-repeat" items="[[markers]]">
          <div class="slider-marker"></div>
        </template>
      </div>
    </template>

    <div id="sliderKnob" class="slider-knob" on-down="_knobdown" on-up="_resetKnob" on-track="_onTrack" on-transitionend="_knobTransitionEnd">
        <div class="slider-knob-inner" value\$="[[immediateValue]]"></div>
    </div>
  </div>

  <template is="dom-if" if="[[editable]]">
    <paper-input id="input" type="number" step="[[step]]" min="[[min]]" max="[[max]]" class="slider-input" disabled\$="[[disabled]]" value="[[immediateValue]]" on-change="_changeValue" on-keydown="_inputKeyDown" no-label-float>
    </paper-input>
  </template>
`;A0t.setAttribute("strip-whitespace","");Yt({_template:A0t,is:"paper-slider",behaviors:[Oo,Eh,jx,L9],properties:{value:{type:Number,value:0},snaps:{type:Boolean,value:!1,notify:!0},pin:{type:Boolean,value:!1,notify:!0},secondaryProgress:{type:Number,value:0,notify:!0,observer:"_secondaryProgressChanged"},editable:{type:Boolean,value:!1},immediateValue:{type:Number,value:0,readOnly:!0,notify:!0},maxMarkers:{type:Number,value:0,notify:!0},expand:{type:Boolean,value:!1,readOnly:!0},ignoreBarTouch:{type:Boolean,value:!1},dragging:{type:Boolean,value:!1,readOnly:!0,notify:!0},transiting:{type:Boolean,value:!1,readOnly:!0},markers:{type:Array,readOnly:!0,value:function(){return[]}}},observers:["_updateKnob(value, min, max, snaps, step)","_valueChanged(value)","_immediateValueChanged(immediateValue)","_updateMarkers(maxMarkers, min, max, snaps)"],hostAttributes:{role:"slider",tabindex:0},keyBindings:{left:"_leftKey",right:"_rightKey","down pagedown home":"_decrementKey","up pageup end":"_incrementKey"},ready:function(){this.ignoreBarTouch&&d_(this.$.sliderBar,"auto")},increment:function(){this.value=this._clampValue(this.value+this.step)},decrement:function(){this.value=this._clampValue(this.value-this.step)},_updateKnob:function(e,t,r,n,i){this.setAttribute("aria-valuemin",t),this.setAttribute("aria-valuemax",r),this.setAttribute("aria-valuenow",e),this._positionKnob(this._calcRatio(e)*100)},_valueChanged:function(){this.fire("value-change",{composed:!0})},_immediateValueChanged:function(){this.dragging?this.fire("immediate-value-change",{composed:!0}):this.value=this.immediateValue},_secondaryProgressChanged:function(){this.secondaryProgress=this._clampValue(this.secondaryProgress)},_expandKnob:function(){this._setExpand(!0)},_resetKnob:function(){this.cancelDebouncer("expandKnob"),this._setExpand(!1)},_positionKnob:function(e){this._setImmediateValue(this._calcStep(this._calcKnobPosition(e))),this._setRatio(this._calcRatio(this.immediateValue)*100),this.$.sliderKnob.style.left=this.ratio+"%",this.dragging&&(this._knobstartx=this.ratio*this._w/100,this.translate3d(0,0,0,this.$.sliderKnob))},_calcKnobPosition:function(e){return(this.max-this.min)*e/100+this.min},_onTrack:function(e){switch(e.stopPropagation(),e.detail.state){case"start":this._trackStart(e);break;case"track":this._trackX(e);break;case"end":this._trackEnd();break}},_trackStart:function(e){this._setTransiting(!1),this._w=this.$.sliderBar.offsetWidth,this._x=this.ratio*this._w/100,this._startx=this._x,this._knobstartx=this._startx,this._minx=-this._startx,this._maxx=this._w-this._startx,this.$.sliderKnob.classList.add("dragging"),this._setDragging(!0)},_trackX:function(e){this.dragging||this._trackStart(e);var t=this._isRTL?-1:1,r=Math.min(this._maxx,Math.max(this._minx,e.detail.dx*t));this._x=this._startx+r;var n=this._calcStep(this._calcKnobPosition(this._x/this._w*100));this._setImmediateValue(n);var i=this._calcRatio(this.immediateValue)*this._w-this._knobstartx;this.translate3d(i+"px",0,0,this.$.sliderKnob)},_trackEnd:function(){var e=this.$.sliderKnob.style;this.$.sliderKnob.classList.remove("dragging"),this._setDragging(!1),this._resetKnob(),this.value=this.immediateValue,e.transform=e.webkitTransform="",this.fire("change",{composed:!0})},_knobdown:function(e){this._expandKnob(),e.preventDefault(),this.focus()},_bartrack:function(e){this._allowBarEvent(e)&&this._onTrack(e)},_barclick:function(e){this._w=this.$.sliderBar.offsetWidth;var t=this.$.sliderBar.getBoundingClientRect(),r=(e.detail.x-t.left)/this._w*100;this._isRTL&&(r=100-r);var n=this.ratio;this._setTransiting(!0),this._positionKnob(r),n===this.ratio&&this._setTransiting(!1),this.async(function(){this.fire("change",{composed:!0})}),e.preventDefault(),this.focus()},_bardown:function(e){this._allowBarEvent(e)&&(this.debounce("expandKnob",this._expandKnob,60),this._barclick(e))},_knobTransitionEnd:function(e){e.target===this.$.sliderKnob&&this._setTransiting(!1)},_updateMarkers:function(e,t,r,n){n||this._setMarkers([]);var i=Math.round((r-t)/this.step);i>e&&(i=e),(i<0||!isFinite(i))&&(i=0),this._setMarkers(new Array(i))},_mergeClasses:function(e){return Object.keys(e).filter(function(t){return e[t]}).join(" ")},_getClassNames:function(){return this._mergeClasses({disabled:this.disabled,pin:this.pin,snaps:this.snaps,ring:this.immediateValue<=this.min,expand:this.expand,dragging:this.dragging,transiting:this.transiting,editable:this.editable})},_allowBarEvent:function(e){return!this.ignoreBarTouch||e.detail.sourceEvent instanceof MouseEvent},get _isRTL(){return this.__isRTL===void 0&&(this.__isRTL=window.getComputedStyle(this).direction==="rtl"),this.__isRTL},_leftKey:function(e){this._isRTL?this._incrementKey(e):this._decrementKey(e)},_rightKey:function(e){this._isRTL?this._decrementKey(e):this._incrementKey(e)},_incrementKey:function(e){this.disabled||(e.detail.key==="end"?this.value=this.max:this.increment(),this.fire("change"),e.preventDefault())},_decrementKey:function(e){this.disabled||(e.detail.key==="home"?this.value=this.min:this.decrement(),this.fire("change"),e.preventDefault())},_changeValue:function(e){this.value=e.target.value,this.fire("change",{composed:!0})},_inputKeyDown:function(e){e.stopPropagation()},_createRipple:function(){return this._rippleContainer=this.$.sliderKnob,fE._createRipple.call(this)},_focusedChanged:function(e){e&&this.ensureRipple(),this.hasRipple()&&(e?this._ripple.style.display="":this._ripple.style.display="none",this._ripple.holdDown=e)}});var EW=document.createElement("template");EW.setAttribute("style","display: none;");EW.innerHTML=`<dom-module id="paper-spinner-styles">
  <template>
    <style>
      /*
      /**************************/
      /* STYLES FOR THE SPINNER */
      /**************************/

      /*
       * Constants:
       *      ARCSIZE     = 270 degrees (amount of circle the arc takes up)
       *      ARCTIME     = 1333ms (time it takes to expand and contract arc)
       *      ARCSTARTROT = 216 degrees (how much the start location of the arc
       *                                should rotate each time, 216 gives us a
       *                                5 pointed star shape (it's 360/5 * 3).
       *                                For a 7 pointed star, we might do
       *                                360/7 * 3 = 154.286)
       *      SHRINK_TIME = 400ms
       */

      :host {
        display: inline-block;
        position: relative;
        width: 28px;
        height: 28px;

        /* 360 * ARCTIME / (ARCSTARTROT + (360-ARCSIZE)) */
        --paper-spinner-container-rotation-duration: 1568ms;

        /* ARCTIME */
        --paper-spinner-expand-contract-duration: 1333ms;

        /* 4 * ARCTIME */
        --paper-spinner-full-cycle-duration: 5332ms;

        /* SHRINK_TIME */
        --paper-spinner-cooldown-duration: 400ms;
      }

      #spinnerContainer {
        width: 100%;
        height: 100%;

        /* The spinner does not have any contents that would have to be
         * flipped if the direction changes. Always use ltr so that the
         * style works out correctly in both cases. */
        direction: ltr;
      }

      #spinnerContainer.active {
        -webkit-animation: container-rotate var(--paper-spinner-container-rotation-duration) linear infinite;
        animation: container-rotate var(--paper-spinner-container-rotation-duration) linear infinite;
      }

      @-webkit-keyframes container-rotate {
        to { -webkit-transform: rotate(360deg) }
      }

      @keyframes container-rotate {
        to { transform: rotate(360deg) }
      }

      .spinner-layer {
        position: absolute;
        width: 100%;
        height: 100%;
        opacity: 0;
        white-space: nowrap;
        color: var(--paper-spinner-color, var(--google-blue-500));
      }

      .layer-1 {
        color: var(--paper-spinner-layer-1-color, var(--google-blue-500));
      }

      .layer-2 {
        color: var(--paper-spinner-layer-2-color, var(--google-red-500));
      }

      .layer-3 {
        color: var(--paper-spinner-layer-3-color, var(--google-yellow-500));
      }

      .layer-4 {
        color: var(--paper-spinner-layer-4-color, var(--google-green-500));
      }

      /**
       * IMPORTANT NOTE ABOUT CSS ANIMATION PROPERTIES (keanulee):
       *
       * iOS Safari (tested on iOS 8.1) does not handle animation-delay very well - it doesn't
       * guarantee that the animation will start _exactly_ after that value. So we avoid using
       * animation-delay and instead set custom keyframes for each color (as layer-2undant as it
       * seems).
       */
      .active .spinner-layer {
        -webkit-animation-name: fill-unfill-rotate;
        -webkit-animation-duration: var(--paper-spinner-full-cycle-duration);
        -webkit-animation-timing-function: cubic-bezier(0.4, 0.0, 0.2, 1);
        -webkit-animation-iteration-count: infinite;
        animation-name: fill-unfill-rotate;
        animation-duration: var(--paper-spinner-full-cycle-duration);
        animation-timing-function: cubic-bezier(0.4, 0.0, 0.2, 1);
        animation-iteration-count: infinite;
        opacity: 1;
      }

      .active .spinner-layer.layer-1 {
        -webkit-animation-name: fill-unfill-rotate, layer-1-fade-in-out;
        animation-name: fill-unfill-rotate, layer-1-fade-in-out;
      }

      .active .spinner-layer.layer-2 {
        -webkit-animation-name: fill-unfill-rotate, layer-2-fade-in-out;
        animation-name: fill-unfill-rotate, layer-2-fade-in-out;
      }

      .active .spinner-layer.layer-3 {
        -webkit-animation-name: fill-unfill-rotate, layer-3-fade-in-out;
        animation-name: fill-unfill-rotate, layer-3-fade-in-out;
      }

      .active .spinner-layer.layer-4 {
        -webkit-animation-name: fill-unfill-rotate, layer-4-fade-in-out;
        animation-name: fill-unfill-rotate, layer-4-fade-in-out;
      }

      @-webkit-keyframes fill-unfill-rotate {
        12.5% { -webkit-transform: rotate(135deg) } /* 0.5 * ARCSIZE */
        25%   { -webkit-transform: rotate(270deg) } /* 1   * ARCSIZE */
        37.5% { -webkit-transform: rotate(405deg) } /* 1.5 * ARCSIZE */
        50%   { -webkit-transform: rotate(540deg) } /* 2   * ARCSIZE */
        62.5% { -webkit-transform: rotate(675deg) } /* 2.5 * ARCSIZE */
        75%   { -webkit-transform: rotate(810deg) } /* 3   * ARCSIZE */
        87.5% { -webkit-transform: rotate(945deg) } /* 3.5 * ARCSIZE */
        to    { -webkit-transform: rotate(1080deg) } /* 4   * ARCSIZE */
      }

      @keyframes fill-unfill-rotate {
        12.5% { transform: rotate(135deg) } /* 0.5 * ARCSIZE */
        25%   { transform: rotate(270deg) } /* 1   * ARCSIZE */
        37.5% { transform: rotate(405deg) } /* 1.5 * ARCSIZE */
        50%   { transform: rotate(540deg) } /* 2   * ARCSIZE */
        62.5% { transform: rotate(675deg) } /* 2.5 * ARCSIZE */
        75%   { transform: rotate(810deg) } /* 3   * ARCSIZE */
        87.5% { transform: rotate(945deg) } /* 3.5 * ARCSIZE */
        to    { transform: rotate(1080deg) } /* 4   * ARCSIZE */
      }

      @-webkit-keyframes layer-1-fade-in-out {
        0% { opacity: 1 }
        25% { opacity: 1 }
        26% { opacity: 0 }
        89% { opacity: 0 }
        90% { opacity: 1 }
        to { opacity: 1 }
      }

      @keyframes layer-1-fade-in-out {
        0% { opacity: 1 }
        25% { opacity: 1 }
        26% { opacity: 0 }
        89% { opacity: 0 }
        90% { opacity: 1 }
        to { opacity: 1 }
      }

      @-webkit-keyframes layer-2-fade-in-out {
        0% { opacity: 0 }
        15% { opacity: 0 }
        25% { opacity: 1 }
        50% { opacity: 1 }
        51% { opacity: 0 }
        to { opacity: 0 }
      }

      @keyframes layer-2-fade-in-out {
        0% { opacity: 0 }
        15% { opacity: 0 }
        25% { opacity: 1 }
        50% { opacity: 1 }
        51% { opacity: 0 }
        to { opacity: 0 }
      }

      @-webkit-keyframes layer-3-fade-in-out {
        0% { opacity: 0 }
        40% { opacity: 0 }
        50% { opacity: 1 }
        75% { opacity: 1 }
        76% { opacity: 0 }
        to { opacity: 0 }
      }

      @keyframes layer-3-fade-in-out {
        0% { opacity: 0 }
        40% { opacity: 0 }
        50% { opacity: 1 }
        75% { opacity: 1 }
        76% { opacity: 0 }
        to { opacity: 0 }
      }

      @-webkit-keyframes layer-4-fade-in-out {
        0% { opacity: 0 }
        65% { opacity: 0 }
        75% { opacity: 1 }
        90% { opacity: 1 }
        to { opacity: 0 }
      }

      @keyframes layer-4-fade-in-out {
        0% { opacity: 0 }
        65% { opacity: 0 }
        75% { opacity: 1 }
        90% { opacity: 1 }
        to { opacity: 0 }
      }

      .circle-clipper {
        display: inline-block;
        position: relative;
        width: 50%;
        height: 100%;
        overflow: hidden;
      }

      /**
       * Patch the gap that appear between the two adjacent div.circle-clipper while the
       * spinner is rotating (appears on Chrome 50, Safari 9.1.1, and Edge).
       */
      .spinner-layer::after {
        content: '';
        left: 45%;
        width: 10%;
        border-top-style: solid;
      }

      .spinner-layer::after,
      .circle-clipper .circle {
        box-sizing: border-box;
        position: absolute;
        top: 0;
        border-width: var(--paper-spinner-stroke-width, 3px);
        border-radius: 50%;
      }

      .circle-clipper .circle {
        bottom: 0;
        width: 200%;
        border-style: solid;
        border-bottom-color: transparent !important;
      }

      .circle-clipper.left .circle {
        left: 0;
        border-right-color: transparent !important;
        -webkit-transform: rotate(129deg);
        transform: rotate(129deg);
      }

      .circle-clipper.right .circle {
        left: -100%;
        border-left-color: transparent !important;
        -webkit-transform: rotate(-129deg);
        transform: rotate(-129deg);
      }

      .active .gap-patch::after,
      .active .circle-clipper .circle {
        -webkit-animation-duration: var(--paper-spinner-expand-contract-duration);
        -webkit-animation-timing-function: cubic-bezier(0.4, 0.0, 0.2, 1);
        -webkit-animation-iteration-count: infinite;
        animation-duration: var(--paper-spinner-expand-contract-duration);
        animation-timing-function: cubic-bezier(0.4, 0.0, 0.2, 1);
        animation-iteration-count: infinite;
      }

      .active .circle-clipper.left .circle {
        -webkit-animation-name: left-spin;
        animation-name: left-spin;
      }

      .active .circle-clipper.right .circle {
        -webkit-animation-name: right-spin;
        animation-name: right-spin;
      }

      @-webkit-keyframes left-spin {
        0% { -webkit-transform: rotate(130deg) }
        50% { -webkit-transform: rotate(-5deg) }
        to { -webkit-transform: rotate(130deg) }
      }

      @keyframes left-spin {
        0% { transform: rotate(130deg) }
        50% { transform: rotate(-5deg) }
        to { transform: rotate(130deg) }
      }

      @-webkit-keyframes right-spin {
        0% { -webkit-transform: rotate(-130deg) }
        50% { -webkit-transform: rotate(5deg) }
        to { -webkit-transform: rotate(-130deg) }
      }

      @keyframes right-spin {
        0% { transform: rotate(-130deg) }
        50% { transform: rotate(5deg) }
        to { transform: rotate(-130deg) }
      }

      #spinnerContainer.cooldown {
        -webkit-animation: container-rotate var(--paper-spinner-container-rotation-duration) linear infinite, fade-out var(--paper-spinner-cooldown-duration) cubic-bezier(0.4, 0.0, 0.2, 1);
        animation: container-rotate var(--paper-spinner-container-rotation-duration) linear infinite, fade-out var(--paper-spinner-cooldown-duration) cubic-bezier(0.4, 0.0, 0.2, 1);
      }

      @-webkit-keyframes fade-out {
        0% { opacity: 1 }
        to { opacity: 0 }
      }

      @keyframes fade-out {
        0% { opacity: 1 }
        to { opacity: 0 }
      }
    </style>
  </template>
</dom-module>`;document.head.appendChild(EW.content);var N9={properties:{active:{type:Boolean,value:!1,reflectToAttribute:!0,observer:"__activeChanged"},alt:{type:String,value:"loading",observer:"__altChanged"},__coolingDown:{type:Boolean,value:!1}},__computeContainerClasses:function(e,t){return[e||t?"active":"",t?"cooldown":""].join(" ")},__activeChanged:function(e,t){this.__setAriaHidden(!e),this.__coolingDown=!e&&t},__altChanged:function(e){e==="loading"?this.alt=this.getAttribute("aria-label")||e:(this.__setAriaHidden(e===""),this.setAttribute("aria-label",e))},__setAriaHidden:function(e){var t="aria-hidden";e?this.setAttribute(t,"true"):this.removeAttribute(t)},__reset:function(){this.active=!1,this.__coolingDown=!1}};var P0t=Q`
  <style include="paper-spinner-styles"></style>

  <div id="spinnerContainer" class-name="[[__computeContainerClasses(active, __coolingDown)]]" on-animationend="__reset" on-webkit-animation-end="__reset">
    <div class="spinner-layer layer-1">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>

    <div class="spinner-layer layer-2">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>

    <div class="spinner-layer layer-3">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>

    <div class="spinner-layer layer-4">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>
  </div>
`;P0t.setAttribute("strip-whitespace","");Yt({_template:P0t,is:"paper-spinner",behaviors:[N9]});var I0t=Q`
  <style include="paper-spinner-styles"></style>

  <div id="spinnerContainer" class-name="[[__computeContainerClasses(active, __coolingDown)]]" on-animationend="__reset" on-webkit-animation-end="__reset">
    <div class="spinner-layer">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>
  </div>
`;I0t.setAttribute("strip-whitespace","");Yt({_template:I0t,is:"paper-spinner-lite",behaviors:[N9]});var Ube=Q`<iron-iconset-svg name="paper-tabs" size="24">
<svg><defs>
<g id="chevron-left"><path d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"></path></g>
<g id="chevron-right"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"></path></g>
</defs></svg>
</iron-iconset-svg>`;document.head.appendChild(Ube.content);Yt({_template:Q`
    <style>
      :host {
        @apply --layout-inline;
        @apply --layout-center;
        @apply --layout-center-justified;
        @apply --layout-flex-auto;

        position: relative;
        padding: 0 12px;
        overflow: hidden;
        cursor: pointer;
        vertical-align: middle;

        @apply --paper-font-common-base;
        @apply --paper-tab;
      }

      :host(:focus) {
        outline: none;
      }

      :host([link]) {
        padding: 0;
      }

      .tab-content {
        height: 100%;
        transform: translateZ(0);
          -webkit-transform: translateZ(0);
        transition: opacity 0.1s cubic-bezier(0.4, 0.0, 1, 1);
        @apply --layout-horizontal;
        @apply --layout-center-center;
        @apply --layout-flex-auto;
        @apply --paper-tab-content;
      }

      :host(:not(.iron-selected)) > .tab-content {
        opacity: 0.8;

        @apply --paper-tab-content-unselected;
      }

      :host(:focus) .tab-content {
        opacity: 1;
        font-weight: 700;

        @apply --paper-tab-content-focused;
      }

      paper-ripple {
        color: var(--paper-tab-ink, var(--paper-yellow-a100));
      }

      .tab-content > ::slotted(a) {
        @apply --layout-flex-auto;

        height: 100%;
      }
    </style>

    <div class="tab-content">
      <slot></slot>
    </div>
`,is:"paper-tab",behaviors:[Di,Sh,su],properties:{link:{type:Boolean,value:!1,reflectToAttribute:!0}},hostAttributes:{role:"tab"},listeners:{down:"_updateNoink",tap:"_onTap"},attached:function(){this._updateNoink()},get _parentNoink(){var e=zt(this).parentNode;return!!e&&!!e.noink},_updateNoink:function(){this.noink=!!this.noink||!!this._parentNoink},_onTap:function(e){if(this.link){var t=this.queryEffectiveChildren("a");if(!t||e.target===t)return;t.click()}}});Yt({_template:Q`
    <style>
      :host {
        @apply --layout;
        @apply --layout-center;

        height: 48px;
        font-size: 14px;
        font-weight: 500;
        overflow: hidden;
        -moz-user-select: none;
        -ms-user-select: none;
        -webkit-user-select: none;
        user-select: none;

        /* NOTE: Both values are needed, since some phones require the value to be \`transparent\`. */
        -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
        -webkit-tap-highlight-color: transparent;

        @apply --paper-tabs;
      }

      :host(:dir(rtl)) {
        @apply --layout-horizontal-reverse;
      }

      #tabsContainer {
        position: relative;
        height: 100%;
        white-space: nowrap;
        overflow: hidden;
        @apply --layout-flex-auto;
        @apply --paper-tabs-container;
      }

      #tabsContent {
        height: 100%;
        -moz-flex-basis: auto;
        -ms-flex-basis: auto;
        flex-basis: auto;
        @apply --paper-tabs-content;
      }

      #tabsContent.scrollable {
        position: absolute;
        white-space: nowrap;
      }

      #tabsContent:not(.scrollable),
      #tabsContent.scrollable.fit-container {
        @apply --layout-horizontal;
      }

      #tabsContent.scrollable.fit-container {
        min-width: 100%;
      }

      #tabsContent.scrollable.fit-container > ::slotted(*) {
        /* IE - prevent tabs from compressing when they should scroll. */
        -ms-flex: 1 0 auto;
        -webkit-flex: 1 0 auto;
        flex: 1 0 auto;
      }

      .hidden {
        display: none;
      }

      .not-visible {
        opacity: 0;
        cursor: default;
      }

      paper-icon-button {
        width: 48px;
        height: 48px;
        padding: 12px;
        margin: 0 4px;
      }

      #selectionBar {
        position: absolute;
        height: 0;
        bottom: 0;
        left: 0;
        right: 0;
        border-bottom: 2px solid var(--paper-tabs-selection-bar-color, var(--paper-yellow-a100));
          -webkit-transform: scale(0);
        transform: scale(0);
          -webkit-transform-origin: left center;
        transform-origin: left center;
          transition: -webkit-transform;
        transition: transform;

        @apply --paper-tabs-selection-bar;
      }

      #selectionBar.align-bottom {
        top: 0;
        bottom: auto;
      }

      #selectionBar.expand {
        transition-duration: 0.15s;
        transition-timing-function: cubic-bezier(0.4, 0.0, 1, 1);
      }

      #selectionBar.contract {
        transition-duration: 0.18s;
        transition-timing-function: cubic-bezier(0.0, 0.0, 0.2, 1);
      }

      #tabsContent > ::slotted(:not(#selectionBar)) {
        height: 100%;
      }
    </style>

    <paper-icon-button icon="paper-tabs:chevron-left" class$="[[_computeScrollButtonClass(_leftHidden, scrollable, hideScrollButtons)]]" on-up="_onScrollButtonUp" on-down="_onLeftScrollButtonDown" tabindex="-1"></paper-icon-button>

    <div id="tabsContainer" on-track="_scroll" on-down="_down">
      <div id="tabsContent" class$="[[_computeTabsContentClass(scrollable, fitContainer)]]">
        <div id="selectionBar" class$="[[_computeSelectionBarClass(noBar, alignBottom)]]" on-transitionend="_onBarTransitionEnd"></div>
        <slot></slot>
      </div>
    </div>

    <paper-icon-button icon="paper-tabs:chevron-right" class$="[[_computeScrollButtonClass(_rightHidden, scrollable, hideScrollButtons)]]" on-up="_onScrollButtonUp" on-down="_onRightScrollButtonDown" tabindex="-1"></paper-icon-button>
`,is:"paper-tabs",behaviors:[Js,R9],properties:{noink:{type:Boolean,value:!1,observer:"_noinkChanged"},noBar:{type:Boolean,value:!1},noSlide:{type:Boolean,value:!1},scrollable:{type:Boolean,value:!1},fitContainer:{type:Boolean,value:!1},disableDrag:{type:Boolean,value:!1},hideScrollButtons:{type:Boolean,value:!1},alignBottom:{type:Boolean,value:!1},selectable:{type:String,value:"paper-tab"},autoselect:{type:Boolean,value:!1},autoselectDelay:{type:Number,value:0},_step:{type:Number,value:10},_holdDelay:{type:Number,value:1},_leftHidden:{type:Boolean,value:!1},_rightHidden:{type:Boolean,value:!1},_previousTab:{type:Object}},hostAttributes:{role:"tablist"},listeners:{"iron-resize":"_onTabSizingChanged","iron-items-changed":"_onTabSizingChanged","iron-select":"_onIronSelect","iron-deselect":"_onIronDeselect"},keyBindings:{"left:keyup right:keyup":"_onArrowKeyup"},created:function(){this._holdJob=null,this._pendingActivationItem=void 0,this._pendingActivationTimeout=void 0,this._bindDelayedActivationHandler=this._delayedActivationHandler.bind(this),this.addEventListener("blur",this._onBlurCapture.bind(this),!0)},ready:function(){this.setScrollDirection("y",this.$.tabsContainer)},detached:function(){this._cancelPendingActivation()},_noinkChanged:function(e){var t=zt(this).querySelectorAll("paper-tab");t.forEach(e?this._setNoinkAttribute:this._removeNoinkAttribute)},_setNoinkAttribute:function(e){e.setAttribute("noink","")},_removeNoinkAttribute:function(e){e.removeAttribute("noink")},_computeScrollButtonClass:function(e,t,r){return!t||r?"hidden":e?"not-visible":""},_computeTabsContentClass:function(e,t){return e?"scrollable"+(t?" fit-container":""):" fit-container"},_computeSelectionBarClass:function(e,t){return e?"hidden":t?"align-bottom":""},_onTabSizingChanged:function(){this.debounce("_onTabSizingChanged",function(){this._scroll(),this._tabChanged(this.selectedItem)},10)},_onIronSelect:function(e){this._tabChanged(e.detail.item,this._previousTab),this._previousTab=e.detail.item,this.cancelDebouncer("tab-changed")},_onIronDeselect:function(e){this.debounce("tab-changed",function(){this._tabChanged(null,this._previousTab),this._previousTab=null},1)},_activateHandler:function(){this._cancelPendingActivation(),__._activateHandler.apply(this,arguments)},_scheduleActivation:function(e,t){this._pendingActivationItem=e,this._pendingActivationTimeout=this.async(this._bindDelayedActivationHandler,t)},_delayedActivationHandler:function(){var e=this._pendingActivationItem;this._pendingActivationItem=void 0,this._pendingActivationTimeout=void 0,e.fire(this.activateEvent,null,{bubbles:!0,cancelable:!0})},_cancelPendingActivation:function(){this._pendingActivationTimeout!==void 0&&(this.cancelAsync(this._pendingActivationTimeout),this._pendingActivationItem=void 0,this._pendingActivationTimeout=void 0)},_onArrowKeyup:function(e){this.autoselect&&this._scheduleActivation(this.focusedItem,this.autoselectDelay)},_onBlurCapture:function(e){e.target===this._pendingActivationItem&&this._cancelPendingActivation()},get _tabContainerScrollSize(){return Math.max(0,this.$.tabsContainer.scrollWidth-this.$.tabsContainer.offsetWidth)},_scroll:function(e,t){if(!!this.scrollable){var r=t&&-t.ddx||0;this._affectScroll(r)}},_down:function(e){this.async(function(){this._defaultFocusAsync&&(this.cancelAsync(this._defaultFocusAsync),this._defaultFocusAsync=null)},1)},_affectScroll:function(e){this.$.tabsContainer.scrollLeft+=e;var t=this.$.tabsContainer.scrollLeft;this._leftHidden=t===0,this._rightHidden=t===this._tabContainerScrollSize},_onLeftScrollButtonDown:function(){this._scrollToLeft(),this._holdJob=setInterval(this._scrollToLeft.bind(this),this._holdDelay)},_onRightScrollButtonDown:function(){this._scrollToRight(),this._holdJob=setInterval(this._scrollToRight.bind(this),this._holdDelay)},_onScrollButtonUp:function(){clearInterval(this._holdJob),this._holdJob=null},_scrollToLeft:function(){this._affectScroll(-this._step)},_scrollToRight:function(){this._affectScroll(this._step)},_tabChanged:function(e,t){if(!e){this.$.selectionBar.classList.remove("expand"),this.$.selectionBar.classList.remove("contract"),this._positionBar(0,0);return}var r=this.$.tabsContent.getBoundingClientRect(),n=r.width,i=e.getBoundingClientRect(),o=i.left-r.left;if(this._pos={width:this._calcPercent(i.width,n),left:this._calcPercent(o,n)},this.noSlide||t==null){this.$.selectionBar.classList.remove("expand"),this.$.selectionBar.classList.remove("contract"),this._positionBar(this._pos.width,this._pos.left);return}var a=t.getBoundingClientRect(),s=this.items.indexOf(t),l=this.items.indexOf(e),c=5;this.$.selectionBar.classList.add("expand");var u=s<l,h=this._isRTL;h&&(u=!u),u?this._positionBar(this._calcPercent(i.left+i.width-a.left,n)-c,this._left):this._positionBar(this._calcPercent(a.left+a.width-i.left,n)-c,this._calcPercent(o,n)+c),this.scrollable&&this._scrollToSelectedIfNeeded(i.width,o)},_scrollToSelectedIfNeeded:function(e,t){var r=t-this.$.tabsContainer.scrollLeft;r<0?this.$.tabsContainer.scrollLeft+=r:(r+=e-this.$.tabsContainer.offsetWidth,r>0&&(this.$.tabsContainer.scrollLeft+=r))},_calcPercent:function(e,t){return 100*e/t},_positionBar:function(e,t){e=e||0,t=t||0,this._width=e,this._left=t,this.transform("translateX("+t+"%) scaleX("+e/100+")",this.$.selectionBar)},_onBarTransitionEnd:function(e){var t=this.$.selectionBar.classList;t.contains("expand")?(t.remove("expand"),t.add("contract"),this._positionBar(this._pos.width,this._pos.left)):t.contains("contract")&&t.remove("contract")}});var Jx=null;Yt({_template:Q`
    <style>
      :host {
        display: block;
        position: fixed;
        background-color: var(--paper-toast-background-color, #323232);
        color: var(--paper-toast-color, #f1f1f1);
        min-height: 48px;
        min-width: 288px;
        padding: 16px 24px;
        box-sizing: border-box;
        box-shadow: 0 2px 5px 0 rgba(0, 0, 0, 0.26);
        border-radius: 2px;
        margin: 12px;
        font-size: 14px;
        cursor: default;
        -webkit-transition: -webkit-transform 0.3s, opacity 0.3s;
        transition: transform 0.3s, opacity 0.3s;
        opacity: 0;
        -webkit-transform: translateY(100px);
        transform: translateY(100px);
        @apply --paper-font-common-base;
      }

      :host(.capsule) {
        border-radius: 24px;
      }

      :host(.fit-bottom) {
        width: 100%;
        min-width: 0;
        border-radius: 0;
        margin: 0;
      }

      :host(.paper-toast-open) {
        opacity: 1;
        -webkit-transform: translateY(0px);
        transform: translateY(0px);
      }
    </style>

    <span id="label">{{text}}</span>
    <slot></slot>
`,is:"paper-toast",behaviors:[Kx],properties:{fitInto:{type:Object,value:window,observer:"_onFitIntoChanged"},horizontalAlign:{type:String,value:"left"},verticalAlign:{type:String,value:"bottom"},duration:{type:Number,value:3e3},text:{type:String,value:""},noCancelOnOutsideClick:{type:Boolean,value:!0},noAutoFocus:{type:Boolean,value:!0}},listeners:{transitionend:"__onTransitionEnd"},get visible(){return Da._warn("`visible` is deprecated, use `opened` instead"),this.opened},get _canAutoClose(){return this.duration>0&&this.duration!==1/0},created:function(){this._autoClose=null,ec.requestAvailability()},show:function(e){typeof e=="string"&&(e={text:e});for(var t in e)t.indexOf("_")===0?Da._warn('The property "'+t+'" is private and was not set.'):t in this?this[t]=e[t]:Da._warn('The property "'+t+'" is not valid.');this.open()},hide:function(){this.close()},__onTransitionEnd:function(e){e&&e.target===this&&e.propertyName==="opacity"&&(this.opened?this._finishRenderOpened():this._finishRenderClosed())},_openedChanged:function(){this._autoClose!==null&&(this.cancelAsync(this._autoClose),this._autoClose=null),this.opened?(Jx&&Jx!==this&&Jx.close(),Jx=this,this.fire("iron-announce",{text:this.text}),this._canAutoClose&&(this._autoClose=this.async(this.close,this.duration))):Jx===this&&(Jx=null),Pm._openedChanged.apply(this,arguments)},_renderOpened:function(){this.classList.add("paper-toast-open")},_renderClosed:function(){this.classList.remove("paper-toast-open")},_onFitIntoChanged:function(e){this.positionTarget=e}});var L0t=Q`

    <style>
      :host {
        display: inline-block;
        @apply --layout-horizontal;
        @apply --layout-center;
        @apply --paper-font-common-base;
      }

      :host([disabled]) {
        pointer-events: none;
      }

      :host(:focus) {
        outline:none;
      }

      .toggle-bar {
        position: absolute;
        height: 100%;
        width: 100%;
        border-radius: 8px;
        pointer-events: none;
        opacity: 0.4;
        transition: background-color linear .08s;
        background-color: var(--paper-toggle-button-unchecked-bar-color, #000000);

        @apply --paper-toggle-button-unchecked-bar;
      }

      .toggle-button {
        position: absolute;
        top: -3px;
        left: 0;
        height: 20px;
        width: 20px;
        border-radius: 50%;
        box-shadow: 0 1px 5px 0 rgba(0, 0, 0, 0.6);
        transition: -webkit-transform linear .08s, background-color linear .08s;
        transition: transform linear .08s, background-color linear .08s;
        will-change: transform;
        background-color: var(--paper-toggle-button-unchecked-button-color, var(--paper-grey-50));

        @apply --paper-toggle-button-unchecked-button;
      }

      .toggle-button.dragging {
        -webkit-transition: none;
        transition: none;
      }

      :host([checked]:not([disabled])) .toggle-bar {
        opacity: 0.5;
        background-color: var(--paper-toggle-button-checked-bar-color, var(--primary-color));

        @apply --paper-toggle-button-checked-bar;
      }

      :host([disabled]) .toggle-bar {
        background-color: #000;
        opacity: 0.12;
      }

      :host([checked]) .toggle-button {
        -webkit-transform: translate(16px, 0);
        transform: translate(16px, 0);
      }

      :host([checked]:not([disabled])) .toggle-button {
        background-color: var(--paper-toggle-button-checked-button-color, var(--primary-color));

        @apply --paper-toggle-button-checked-button;
      }

      :host([disabled]) .toggle-button {
        background-color: #bdbdbd;
        opacity: 1;
      }

      .toggle-ink {
        position: absolute;
        top: -14px;
        left: -14px;
        right: auto;
        bottom: auto;
        width: 48px;
        height: 48px;
        opacity: 0.5;
        pointer-events: none;
        color: var(--paper-toggle-button-unchecked-ink-color, var(--primary-text-color));

        @apply --paper-toggle-button-unchecked-ink;
      }

      :host([checked]) .toggle-ink {
        color: var(--paper-toggle-button-checked-ink-color, var(--primary-color));

        @apply --paper-toggle-button-checked-ink;
      }

      .toggle-container {
        display: inline-block;
        position: relative;
        width: 36px;
        height: 14px;
        /* The toggle button has an absolute position of -3px; The extra 1px
        /* accounts for the toggle button shadow box. */
        margin: 4px 1px;
      }

      .toggle-label {
        position: relative;
        display: inline-block;
        vertical-align: middle;
        padding-left: var(--paper-toggle-button-label-spacing, 8px);
        pointer-events: none;
        color: var(--paper-toggle-button-label-color, var(--primary-text-color));
      }

      /* invalid state */
      :host([invalid]) .toggle-bar {
        background-color: var(--paper-toggle-button-invalid-bar-color, var(--error-color));
      }

      :host([invalid]) .toggle-button {
        background-color: var(--paper-toggle-button-invalid-button-color, var(--error-color));
      }

      :host([invalid]) .toggle-ink {
        color: var(--paper-toggle-button-invalid-ink-color, var(--error-color));
      }
    </style>

    <div class="toggle-container">
      <div id="toggleBar" class="toggle-bar"></div>
      <div id="toggleButton" class="toggle-button"></div>
    </div>

    <div class="toggle-label"><slot></slot></div>

  `;L0t.setAttribute("strip-whitespace","");Yt({_template:L0t,is:"paper-toggle-button",behaviors:[Xx],hostAttributes:{role:"button","aria-pressed":"false",tabindex:0},properties:{},listeners:{track:"_ontrack"},attached:function(){Tm(this,function(){d_(this,"pan-y")})},_ontrack:function(e){var t=e.detail;t.state==="start"?this._trackStart(t):t.state==="track"?this._trackMove(t):t.state==="end"&&this._trackEnd(t)},_trackStart:function(e){this._width=this.$.toggleBar.offsetWidth/2,this._trackChecked=this.checked,this.$.toggleButton.classList.add("dragging")},_trackMove:function(e){var t=e.dx;this._x=Math.min(this._width,Math.max(0,this._trackChecked?this._width+t:t)),this.translate3d(this._x+"px",0,0,this.$.toggleButton),this._userActivate(this._x>this._width/2)},_trackEnd:function(e){this.$.toggleButton.classList.remove("dragging"),this.transform("",this.$.toggleButton)},_createRipple:function(){this._rippleContainer=this.$.toggleButton;var e=su._createRipple();return e.id="ink",e.setAttribute("recenters",""),e.classList.add("circle","toggle-ink"),e}});Yt({_template:Q`
    <style>
      :host {
        --calculated-paper-toolbar-height: var(--paper-toolbar-height, 64px);
        --calculated-paper-toolbar-sm-height: var(--paper-toolbar-sm-height, 56px);
        display: block;
        position: relative;
        box-sizing: border-box;
        -moz-box-sizing: border-box;
        height: var(--calculated-paper-toolbar-height);
        background: var(--paper-toolbar-background, var(--primary-color));
        color: var(--paper-toolbar-color, var(--dark-theme-text-color));
        @apply --paper-toolbar;
      }

      :host(.animate) {
        transition: var(--paper-toolbar-transition, height 0.18s ease-in);
      }

      :host(.medium-tall) {
        height: calc(var(--calculated-paper-toolbar-height) * 2);
        @apply --paper-toolbar-medium;
      }

      :host(.tall) {
        height: calc(var(--calculated-paper-toolbar-height) * 3);
        @apply --paper-toolbar-tall;
      }

      .toolbar-tools {
        position: relative;
        height: var(--calculated-paper-toolbar-height);
        padding: 0 16px;
        pointer-events: none;
        @apply --layout-horizontal;
        @apply --layout-center;
        @apply --paper-toolbar-content;
      }

      /*
       * TODO: Where should media query breakpoints live so they can be shared between elements?
       */

      @media (max-width: 600px) {
        :host {
          height: var(--calculated-paper-toolbar-sm-height);
        }

        :host(.medium-tall) {
          height: calc(var(--calculated-paper-toolbar-sm-height) * 2);
        }

        :host(.tall) {
          height: calc(var(--calculated-paper-toolbar-sm-height) * 3);
        }

        .toolbar-tools {
          height: var(--calculated-paper-toolbar-sm-height);
        }
      }

      #topBar {
        position: relative;
      }

      /* middle bar */
      #middleBar {
        position: absolute;
        top: 0;
        right: 0;
        left: 0;
      }

      :host(.tall) #middleBar,
      :host(.medium-tall) #middleBar {
        -webkit-transform: translateY(100%);
        transform: translateY(100%);
      }

      /* bottom bar */
      #bottomBar {
        position: absolute;
        right: 0;
        bottom: 0;
        left: 0;
      }

      /*
       * make elements (e.g. buttons) respond to mouse/touch events
       *
       * \`.toolbar-tools\` disables touch events so multiple toolbars can stack and not
       * absorb events. All children must have pointer events re-enabled to work as
       * expected.
       */
      .toolbar-tools > ::slotted(*:not([disabled])) {
        pointer-events: auto;
      }

      .toolbar-tools > ::slotted(.title) {
        @apply --paper-font-common-base;
        white-space: nowrap;
        overflow: hidden;
        text-overflow: ellipsis;
        font-size: 20px;
        font-weight: 400;
        line-height: 1;
        pointer-events: none;
        @apply --layout-flex;
      }

      .toolbar-tools > ::slotted(.title) {
        margin-left: 56px;
      }

      .toolbar-tools > ::slotted(paper-icon-button + .title) {
        margin-left: 0;
      }

      /**
       * The --paper-toolbar-title mixin is applied here instead of above to
       * fix the issue with margin-left being ignored due to css ordering.
       */
      .toolbar-tools > ::slotted(.title) {
        @apply --paper-toolbar-title;
      }

      .toolbar-tools > ::slotted(paper-icon-button[icon=menu]) {
        margin-right: 24px;
      }

      .toolbar-tools > ::slotted(.fit) {
        position: absolute;
        top: auto;
        right: 0;
        bottom: 0;
        left: 0;
        width: auto;
        margin: 0;
      }

      /* TODO(noms): Until we have a better solution for classes that don't use
       * /deep/ create our own.
       */
      .start-justified {
        @apply --layout-start-justified;
      }

      .center-justified {
        @apply --layout-center-justified;
      }

      .end-justified {
        @apply --layout-end-justified;
      }

      .around-justified {
        @apply --layout-around-justified;
      }

      .justified {
        @apply --layout-justified;
      }
    </style>

    <div id="topBar" class\$="toolbar-tools [[_computeBarExtraClasses(justify)]]">
      <slot name="top"></slot>
    </div>

    <div id="middleBar" class\$="toolbar-tools [[_computeBarExtraClasses(middleJustify)]]">
      <slot name="middle"></slot>
    </div>

    <div id="bottomBar" class\$="toolbar-tools [[_computeBarExtraClasses(bottomJustify)]]">
      <slot name="bottom"></slot>
    </div>
`,is:"paper-toolbar",hostAttributes:{role:"toolbar"},properties:{bottomJustify:{type:String,value:""},justify:{type:String,value:""},middleJustify:{type:String,value:""}},ready:function(){console.warn(this.is,"is deprecated. Please use app-layout instead!")},attached:function(){this._observer=this._observe(this),this._updateAriaLabelledBy()},detached:function(){this._observer&&this._observer.disconnect()},_observe:function(e){var t=new MutationObserver(function(){this._updateAriaLabelledBy()}.bind(this));return t.observe(e,{childList:!0,subtree:!0}),t},_updateAriaLabelledBy:function(){ui();for(var e=[],t=Array.prototype.slice.call(zt(this.root).querySelectorAll("slot")).concat(Array.prototype.slice.call(zt(this.root).querySelectorAll("content"))),r,n=0;r=t[n];n++)for(var i=zt(r).getDistributedNodes(),o,a=0;o=i[a];a++)if(o.classList&&o.classList.contains("title"))if(o.id)e.push(o.id);else{var s="paper-toolbar-label-"+Math.floor(Math.random()*1e4);o.id=s,e.push(s)}e.length>0&&this.setAttribute("aria-labelledby",e.join(" "))},_computeBarExtraClasses:function(e){return e?e+(e==="justified"?"":"-justified"):""}});Yt({_template:Q`
    <style>
      :host {
        display: block;
        position: absolute;
        outline: none;
        z-index: 1002;
        -moz-user-select: none;
        -ms-user-select: none;
        -webkit-user-select: none;
        user-select: none;
        cursor: default;
      }

      #tooltip {
        display: block;
        outline: none;
        @apply --paper-font-common-base;
        font-size: 10px;
        line-height: 1;
        background-color: var(--paper-tooltip-background, #616161);
        color: var(--paper-tooltip-text-color, white);
        padding: 8px;
        border-radius: 2px;
        @apply --paper-tooltip;
      }

      @keyframes keyFrameScaleUp {
        0% {
          transform: scale(0.0);
        }
        100% {
          transform: scale(1.0);
        }
      }

      @keyframes keyFrameScaleDown {
        0% {
          transform: scale(1.0);
        }
        100% {
          transform: scale(0.0);
        }
      }

      @keyframes keyFrameFadeInOpacity {
        0% {
          opacity: 0;
        }
        100% {
          opacity: var(--paper-tooltip-opacity, 0.9);
        }
      }

      @keyframes keyFrameFadeOutOpacity {
        0% {
          opacity: var(--paper-tooltip-opacity, 0.9);
        }
        100% {
          opacity: 0;
        }
      }

      @keyframes keyFrameSlideDownIn {
        0% {
          transform: translateY(-2000px);
          opacity: 0;
        }
        10% {
          opacity: 0.2;
        }
        100% {
          transform: translateY(0);
          opacity: var(--paper-tooltip-opacity, 0.9);
        }
      }

      @keyframes keyFrameSlideDownOut {
        0% {
          transform: translateY(0);
          opacity: var(--paper-tooltip-opacity, 0.9);
        }
        10% {
          opacity: 0.2;
        }
        100% {
          transform: translateY(-2000px);
          opacity: 0;
        }
      }

      .fade-in-animation {
        opacity: 0;
        animation-delay: var(--paper-tooltip-delay-in, 500ms);
        animation-name: keyFrameFadeInOpacity;
        animation-iteration-count: 1;
        animation-timing-function: ease-in;
        animation-duration: var(--paper-tooltip-duration-in, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .fade-out-animation {
        opacity: var(--paper-tooltip-opacity, 0.9);
        animation-delay: var(--paper-tooltip-delay-out, 0ms);
        animation-name: keyFrameFadeOutOpacity;
        animation-iteration-count: 1;
        animation-timing-function: ease-in;
        animation-duration: var(--paper-tooltip-duration-out, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .scale-up-animation {
        transform: scale(0);
        opacity: var(--paper-tooltip-opacity, 0.9);
        animation-delay: var(--paper-tooltip-delay-in, 500ms);
        animation-name: keyFrameScaleUp;
        animation-iteration-count: 1;
        animation-timing-function: ease-in;
        animation-duration: var(--paper-tooltip-duration-in, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .scale-down-animation {
        transform: scale(1);
        opacity: var(--paper-tooltip-opacity, 0.9);
        animation-delay: var(--paper-tooltip-delay-out, 500ms);
        animation-name: keyFrameScaleDown;
        animation-iteration-count: 1;
        animation-timing-function: ease-in;
        animation-duration: var(--paper-tooltip-duration-out, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .slide-down-animation {
        transform: translateY(-2000px);
        opacity: 0;
        animation-delay: var(--paper-tooltip-delay-out, 500ms);
        animation-name: keyFrameSlideDownIn;
        animation-iteration-count: 1;
        animation-timing-function: cubic-bezier(0.0, 0.0, 0.2, 1);
        animation-duration: var(--paper-tooltip-duration-out, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .slide-down-animation-out {
        transform: translateY(0);
        opacity: var(--paper-tooltip-opacity, 0.9);
        animation-delay: var(--paper-tooltip-delay-out, 500ms);
        animation-name: keyFrameSlideDownOut;
        animation-iteration-count: 1;
        animation-timing-function: cubic-bezier(0.4, 0.0, 1, 1);
        animation-duration: var(--paper-tooltip-duration-out, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .cancel-animation {
        animation-delay: -30s !important;
      }

      /* Thanks IE 10. */

      .hidden {
        display: none !important;
      }
    </style>

    <div id="tooltip" class="hidden">
      <slot></slot>
    </div>
`,is:"paper-tooltip",hostAttributes:{role:"tooltip",tabindex:-1},properties:{for:{type:String,observer:"_findTarget"},manualMode:{type:Boolean,value:!1,observer:"_manualModeChanged"},position:{type:String,value:"bottom"},fitToVisibleBounds:{type:Boolean,value:!1},offset:{type:Number,value:14},marginTop:{type:Number,value:14},animationDelay:{type:Number,value:500,observer:"_delayChange"},animationEntry:{type:String,value:""},animationExit:{type:String,value:""},animationConfig:{type:Object,value:function(){return{entry:[{name:"fade-in-animation",node:this,timing:{delay:0}}],exit:[{name:"fade-out-animation",node:this}]}}},_showing:{type:Boolean,value:!1}},listeners:{webkitAnimationEnd:"_onAnimationEnd"},get target(){var e=zt(this).parentNode,t=zt(this).getOwnerRoot(),r;return this.for?r=zt(t).querySelector("#"+this.for):r=e.nodeType==Node.DOCUMENT_FRAGMENT_NODE?t.host:e,r},attached:function(){this._findTarget()},detached:function(){this.manualMode||this._removeListeners()},playAnimation:function(e){e==="entry"?this.show():e==="exit"&&this.hide()},cancelAnimation:function(){this.$.tooltip.classList.add("cancel-animation")},show:function(){if(!this._showing){if(zt(this).textContent.trim()===""){for(var e=!0,t=zt(this).getEffectiveChildNodes(),r=0;r<t.length;r++)if(t[r].textContent.trim()!==""){e=!1;break}if(e)return}this._showing=!0,this.$.tooltip.classList.remove("hidden"),this.$.tooltip.classList.remove("cancel-animation"),this.$.tooltip.classList.remove(this._getAnimationType("exit")),this.updatePosition(),this._animationPlaying=!0,this.$.tooltip.classList.add(this._getAnimationType("entry"))}},hide:function(){if(!!this._showing){if(this._animationPlaying){this._showing=!1,this._cancelAnimation();return}else this._onAnimationFinish();this._showing=!1,this._animationPlaying=!0}},updatePosition:function(){if(!(!this._target||!this.offsetParent)){var e=this.offset;this.marginTop!=14&&this.offset==14&&(e=this.marginTop);var t=this.offsetParent.getBoundingClientRect(),r=this._target.getBoundingClientRect(),n=this.getBoundingClientRect(),i=(r.width-n.width)/2,o=(r.height-n.height)/2,a=r.left-t.left,s=r.top-t.top,l,c;switch(this.position){case"top":l=a+i,c=s-n.height-e;break;case"bottom":l=a+i,c=s+r.height+e;break;case"left":l=a-n.width-e,c=s+o;break;case"right":l=a+r.width+e,c=s+o;break}this.fitToVisibleBounds?(t.left+l+n.width>window.innerWidth?(this.style.right="0px",this.style.left="auto"):(this.style.left=Math.max(0,l)+"px",this.style.right="auto"),t.top+c+n.height>window.innerHeight?(this.style.bottom=t.height-s+e+"px",this.style.top="auto"):(this.style.top=Math.max(-t.top,c)+"px",this.style.bottom="auto")):(this.style.left=l+"px",this.style.top=c+"px")}},_addListeners:function(){this._target&&(this.listen(this._target,"mouseenter","show"),this.listen(this._target,"focus","show"),this.listen(this._target,"mouseleave","hide"),this.listen(this._target,"blur","hide"),this.listen(this._target,"tap","hide")),this.listen(this.$.tooltip,"animationend","_onAnimationEnd"),this.listen(this,"mouseenter","hide")},_findTarget:function(){this.manualMode||this._removeListeners(),this._target=this.target,this.manualMode||this._addListeners()},_delayChange:function(e){e!==500&&this.updateStyles({"--paper-tooltip-delay-in":e+"ms"})},_manualModeChanged:function(){this.manualMode?this._removeListeners():this._addListeners()},_cancelAnimation:function(){this.$.tooltip.classList.remove(this._getAnimationType("entry")),this.$.tooltip.classList.remove(this._getAnimationType("exit")),this.$.tooltip.classList.remove("cancel-animation"),this.$.tooltip.classList.add("hidden")},_onAnimationFinish:function(){this._showing&&(this.$.tooltip.classList.remove(this._getAnimationType("entry")),this.$.tooltip.classList.remove("cancel-animation"),this.$.tooltip.classList.add(this._getAnimationType("exit")))},_onAnimationEnd:function(){this._animationPlaying=!1,this._showing||(this.$.tooltip.classList.remove(this._getAnimationType("exit")),this.$.tooltip.classList.add("hidden"))},_getAnimationType:function(e){if(e==="entry"&&this.animationEntry!=="")return this.animationEntry;if(e==="exit"&&this.animationExit!=="")return this.animationExit;if(this.animationConfig[e]&&typeof this.animationConfig[e][0].name=="string"){if(this.animationConfig[e][0].timing&&this.animationConfig[e][0].timing.delay&&this.animationConfig[e][0].timing.delay!==0){var t=this.animationConfig[e][0].timing.delay;e==="entry"?this.updateStyles({"--paper-tooltip-delay-in":t+"ms"}):e==="exit"&&this.updateStyles({"--paper-tooltip-delay-out":t+"ms"})}return this.animationConfig[e][0].name}},_removeListeners:function(){this._target&&(this.unlisten(this._target,"mouseenter","show"),this.unlisten(this._target,"focus","show"),this.unlisten(this._target,"mouseleave","hide"),this.unlisten(this._target,"blur","hide"),this.unlisten(this._target,"tap","hide")),this.unlisten(this.$.tooltip,"animationend","_onAnimationEnd"),this.unlisten(this,"mouseenter","hide")}});var rb=Ee(Oe(),1);var dE=class{constructor(t){this.listener=t}},TW=new Set,D9=new Set;window.addEventListener("hashchange",()=>{TW.forEach(e=>e.listener())});window.addEventListener("storage",()=>{D9.forEach(e=>e.listener())});function mE(e){let t=new dE(e);return TW.add(t),t}function CW(e){let t=new dE(e);return D9.add(t),t}function AW(){D9.forEach(e=>e.listener())}function PW(e){TW.delete(e)}function IW(e){D9.delete(e)}var RW={};Ks(RW,{getFakeHash:()=>kW,setFakeHash:()=>LW,setUseHash:()=>qbe,useHash:()=>O9});var k0t=!1;function qbe(e){k0t=e}function O9(){return k0t}var R0t="";function LW(e){R0t=e}function kW(){return R0t}var Qx="__tab__",NW={};function N0t(){return NW}function D0t(e){NW=e}mE(()=>{NW=eb(tb())});function tb(){return O9()?window.location.hash.slice(1):kW()}function eb(e){let t={};return e.split("&").forEach(n=>{let i=n.split("=");i.length===1?t[Qx]=i[0]:i.length===2&&(t[decodeURIComponent(i[0])]=decodeURIComponent(i[1]))}),t}function z9(e,t=!1){if(O9())if(t){let r=new URL(window.location.href);r.hash=e,window.history.replaceState(window.history.state,"",r.toString())}else window.location.hash=e;else LW(e)}function F9(e){let t="";e[Qx]!==void 0&&(t+=e[Qx]);let r=Object.keys(e).map(n=>[n,e[n]]).filter(n=>n[0]!==Qx).map(n=>encodeURIComponent(n[0])+"="+encodeURIComponent(n[1])).join("&");return r.length>0?t+"&"+r:t}function O0t(e,t=!1){let r=eb(tb());delete r[e],z9(F9(r),t)}var F0t="disambiguator",{get:Gbe,set:Wbe,getInitializer:y_,getObserver:v_,disposeBinding:Ybe}=yE(e=>e,e=>e),{get:jbe,set:Xbe,getInitializer:vp,getObserver:xp,disposeBinding:$be}=yE(e=>e==="true"?!0:e==="false"?!1:void 0,e=>e.toString()),{get:DW,set:OW,getInitializer:gE,getObserver:_E,disposeBinding:Kbe}=yE(e=>+e,e=>e.toString()),{get:Zbe,set:Jbe,getInitializer:zW,getObserver:FW,disposeBinding:Qbe}=yE(e=>JSON.parse(atob(e)),e=>btoa(JSON.stringify(e)));function yE(e,t){let r=[],n=[];function i(c,u={}){let{defaultValue:h,useLocalStorage:f=!1}=u,p=f?window.localStorage.getItem(c):eb(tb())[c];return p==null?rb.cloneDeep(h):e(p)}function o(c,u,h={}){let{defaultValue:f,useLocalStorage:p=!1,useLocationReplace:d=!1}=h,g=t(u);if(p)window.localStorage.setItem(c,g),AW();else if(!rb.isEqual(u,i(c,{useLocalStorage:p})))if(rb.isEqual(u,f))O0t(c,d);else{let _=eb(tb());_[c]=g,z9(F9(_),d)}}function a(c,u){let h=Kl({defaultValue:u.defaultValue,polymerProperty:c,useLocalStorage:!1},u);return function(){let f=z0t(this,c),p=()=>{let _=i(f,h),y=this[h.polymerProperty];rb.isEqual(_,y)||(this[h.polymerProperty]=_)},g=(h.useLocalStorage?CW:mE)(()=>p());return h.useLocalStorage?n.push(g):r.push(g),p(),this[h.polymerProperty]}}function s(){r.forEach(c=>PW(c)),n.forEach(c=>IW(c))}function l(c,u){let h=Kl({defaultValue:u.defaultValue,polymerProperty:c,useLocalStorage:!1},u);return function(){let f=z0t(this,c),p=this[h.polymerProperty];o(f,p,h)}}return{get:i,set:o,getInitializer:a,getObserver:l,disposeBinding:s}}function t2e(){let e=new Set(["examplesPath","hideModelPane2","modelName1","modelName2","inferenceAddress1","inferenceAddress2","modelType","modelVersion1","modelVersion2","modelSignature1","modelSignature2","maxExamples","labelVocabPath","multiClass","sequenceExamples","maxClassesToDisplay","samplingOdds","usePredictApi","predictInputTensor","predictOutputTensor"]),t=eb(tb());if(t[Qx]==="whatif"){for(let r of e)if(r in t){let n=t[r];t[`p.whatif.${r}`]=n}}z9(F9(t)),D0t(t)}function z0t(e,t){let r=e[F0t];return(r==null?[t]:[r,t]).join(".")}var vE=class extends mt{constructor(){super(...arguments),this._tagFilter=y_("tagFilter",{defaultValue:"",useLocalStorage:!1,polymerProperty:"_tagFilter"}).call(this),this._tagFilterObserver=v_("tagFilter",{defaultValue:"",useLocalStorage:!1,polymerProperty:"_tagFilter"})}_computeTagFilter(){return this._tagFilter}};vE.template=Q`
    <paper-input
      no-label-float=""
      label="Filter tags (regular expressions supported)"
      value="{{_tagFilter}}"
      class="search-input"
    >
      <iron-icon prefix="" icon="search" slot="prefix"></iron-icon>
    </paper-input>
    <style>
      :host {
        display: block;
        margin: 10px 5px 10px 10px;
      }
    </style>
  `;E([A({type:String,notify:!0,computed:"_computeTagFilter(_tagFilter)"}),w("design:type",String)],vE.prototype,"tagFilter",void 0);E([A({type:String,observer:"_tagFilterObserver"}),w("design:type",String)],vE.prototype,"_tagFilter",void 0);vE=E([yt("tf-tag-filterer")],vE);function _s(e){let{moduleName:t,styleContent:r}=e,n=document.createElement("dom-module"),i=document.createElement("template"),o=[];e.styleDependencies&&e.styleDependencies.forEach(s=>{let l=document.createElement("style");l.setAttribute("include",s),o.push(l)});let a=document.createElement("style");Object.assign(a,{textContent:r}),o.forEach(s=>{i.content.appendChild(s)}),i.content.appendChild(a),n.appendChild(i),n.register(t)}_s({moduleName:"dashboard-style",styleDependencies:["iron-flex"],styleContent:`
      :host {
        --sidebar-vertical-padding: 15px;
        --sidebar-left-padding: 30px;
      }

      [slot='sidebar'] {
        box-sizing: border-box;
        display: flex;
        flex-direction: column;
        height: 100%;
        margin-right: 10px;
        overflow-x: hidden;
        padding: 5px 0;
        text-overflow: ellipsis;
      }

      .settings {
        min-height: 50px;
        overflow-x: hidden;
        overflow-y: auto;
        will-change: transform;
      }

      .runs-selector {
        display: flex;
        flex-grow: 1;
        min-height: 200px;
      }

      tf-runs-selector {
        flex-grow: 1;
        flex-shrink: 1;
        left: var(--sidebar-left-padding);
        max-height: calc(100% - var(--sidebar-vertical-padding) * 2);
        overflow: hidden;
        position: absolute;
        right: 0;
      }

      .search-input {
        margin: 10px 5px 0 10px;
      }

      .sidebar-section {
        border-top: solid 1px var(--tb-ui-border);
        margin-right: 10px;
        padding: var(--sidebar-vertical-padding) 0
          var(--sidebar-vertical-padding) var(--sidebar-left-padding);
        position: relative;
        overflow: hidden;
      }

      .sidebar-section:first-of-type {
        border: none;
      }

      .sidebar-section paper-button {
        margin: 5px;
      }

      .sidebar-section paper-button:first-of-type {
        margin-left: 0 !important;
      }

      .sidebar-section paper-button:last-of-type {
        margin-right: 0 !important;
      }

      .sidebar-section > :first-child {
        margin-top: 0;
        padding-top: 0;
      }

      .sidebar-section > :last-child {
        margin-bottom: 0;
        padding-bottom: 0;
      }

      .sidebar-section h3 {
        color: var(--tb-secondary-text-color);
        display: block;
        font-size: 14px;
        font-weight: normal;
        margin: 10px 0 5px;
        pointer-events: none;
      }

      paper-checkbox {
        --paper-checkbox-checked-color: var(--tb-ui-dark-accent);
        --paper-checkbox-unchecked-color: var(--tb-ui-dark-accent);
        font-size: 15px;
        margin-top: 5px;
      }

      a {
        color: var(--tb-link);
      }

      a:visited {
        color: var(--tb-link-visited);
      }
  `});function _o(e){return class extends e{connectedCallback(){super.connectedCallback(),this._maybeSetDarkMode(),this.observer=new MutationObserver(r=>{r.some(i=>i.attributeName==="class")&&this._maybeSetDarkMode()}),this.observer.observe(document.body,{attributes:!0})}disconnectedCallback(){var r;super.disconnectedCallback(),(r=this.observer)==null||r.disconnect()}_maybeSetDarkMode(){this.classList.toggle("dark-mode",document.body.classList.contains("dark-mode"))}}}_s({moduleName:"scrollbar-style",styleContent:`
    .scrollbar::-webkit-scrollbar-track {
      visibility: hidden;
    }

    .scrollbar::-webkit-scrollbar {
      width: 10px;
    }

    .scrollbar::-webkit-scrollbar-thumb {
      border-radius: 10px;
      -webkit-box-shadow: inset 0 0 2px rgba(0, 0, 0, 0.3);
      background-color: var(--paper-grey-500);
      color: var(--paper-grey-900);
    }
    .scrollbar {
      box-sizing: border-box;
    }
  `});var HW=document.createElement("style");HW.setAttribute("is","custom-style");HW.textContent=`
  :root {
    --tb-orange-weak: #ffa726;
    --tb-orange-strong: #f57c00;
    --tb-orange-dark: #dc7320;
    --tb-grey-darker: #e2e2e2;
    --tb-grey-lighter: #f3f3f3;
    --tb-ui-dark-accent: #757575;
    --tb-ui-light-accent: #e0e0e0;
    --tb-ui-border: var(--paper-grey-300);
    --tb-graph-faded: #e0d4b3;
    --tb-secondary-text-color: var(--paper-grey-800);
    --tb-raised-button-shadow-color: rgba(0, 0, 0, 0.2);
    --primary-background-color: #fff;
    --secondary-background-color: #e9e9e9;
    --tb-layout-background-color: #f5f5f5;
    --tb-link: #1976d2; /* material blue 700. */
    --tb-link-visited: #7b1fa2; /* material purple 700. */
  }

  :root .dark-mode {
    --tb-ui-border: var(--paper-grey-700);
    --tb-ui-dark-accent: var(--paper-grey-400);
    --tb-ui-light-accent: var(--paper-grey-600);
    --tb-secondary-text-color: var(--paper-grey-400);
    --tb-raised-button-shadow-color: rgba(255, 255, 255, 0.5);
    --primary-text-color: #fff;
    --secondary-text-color: var(--paper-grey-400);
    --primary-background-color: #303030;  /* material grey A400. */
    --secondary-background-color: #3a3a3a;
    --tb-layout-background-color: #3a3a3a;
    --tb-link: #42a5f5; /* material blue 400. */
    --tb-link-visited: #ba68c8; /* material purple 300. */
    /* Overrides paper-material */
    --shadow-elevation-2dp_-_box-shadow: 0 2px 2px 0 rgba(255, 255, 255, 0.14),
      0 1px 5px 0 rgba(255, 255, 255, 0.12),
      0 3px 1px -2px rgba(255, 255, 255, 0.2);
  }
`;document.head.appendChild(HW);var VW=class extends _o(mt){};VW.template=Q`
    <div id="sidebar">
      <slot name="sidebar"></slot>
    </div>

    <div id="center">
      <slot name="center" class="scollbar"></slot>
    </div>
    <style include="scrollbar-style"></style>
    <style>
      :host {
        background-color: #f5f5f5;
        display: flex;
        flex-direction: row;
        height: 100%;
      }

      :host(.dark-mode) {
        background-color: var(--secondary-background-color);
      }

      #sidebar {
        flex: 0 0 var(--tf-dashboard-layout-sidebar-basis, 25%);
        height: 100%;
        max-width: var(--tf-dashboard-layout-sidebar-max-width, 350px);
        min-width: var(--tf-dashboard-layout-sidebar-min-width, 270px);
        overflow-y: auto;
        text-overflow: ellipsis;
      }

      #center {
        flex-grow: 1;
        flex-shrink: 1;
        height: 100%;
        overflow: hidden;
      }

      ::slotted([slot='center']) {
        contain: strict;
        height: 100%;
        overflow-x: hidden;
        overflow-y: auto;
        width: 100%;
        will-change: transform;
      }

      .tf-graph-dashboard #center {
        background: #fff;
      }
    </style>
  `;VW=E([yt("tf-dashboard-layout")],VW);var B0t="TF.TensorBoard.PaginatedView.limit",e2e=12,Ah=null,UW=new Set;function qW(e){UW.add(e)}function GW(e){UW.delete(e)}function WW(){return Ah==null&&(Ah=DW(B0t,{useLocalStorage:!0}),(Ah==null||!isFinite(Ah)||Ah<=0)&&(Ah=e2e)),Ah}function r2e(e){if(e!==Math.floor(e))throw new Error(`limit must be an integer, but got: ${e}`);if(e<=0)throw new Error(`limit must be positive, but got: ${e}`);e!==Ah&&(Ah=e,OW(B0t,Ah,{useLocalStorage:!0}),UW.forEach(t=>{t()}))}var nb=class extends mt{updateArrayProp(t,r,n){let i=this.get(t),o=r;if(!Array.isArray(o))throw RangeError(`Expected new value to '${t}' to be an array.`);Array.isArray(i)||(i=[],this.set(t,i));let a=new Set(o.map((c,u)=>n(c,u))),s=0,l=0;for(;s<i.length&&l<o.length;){if(a.has(n(i[s],s)))n(i[s],s)==n(o[l],l)?this.set(`${t}.${s}`,o[l]):this.splice(t,s,0,o[l]);else{this.splice(t,s,1);continue}l++,s++}s<i.length&&this.splice(t,s),l<o.length&&this.push(t,...o.slice(l))}};var Oi=class extends nb{constructor(){super(...arguments),this.as="item",this._contentActive=!0,this._domBootstrapped=!1,this._ctor=null,this._renderedItems=[],this._renderedTemplateInst=new Map,this._lruCachedItems=new Map,this._cacheSize=10,this._getItemKey=t=>JSON.stringify(t),this._isConnected=!1}connectedCallback(){super.connectedCallback(),this._isConnected=!0}setCacheSize(t){this._cacheSize=t}setGetItemKey(t){this._getItemKey=t}updateDom(t){this.updateArrayProp("_renderedItems",t,this._getItemKey)}_ensureTemplatized(){if(!this.isConnected)return!1;if(!this._ctor){let t=this.querySelector("template");this._ctor=tc(t,this,{parentModel:!0,instanceProps:{[this.as]:!0,active:this._contentActive},forwardHostProp:function(r,n){this._renderedTemplateInst.forEach(i=>{i.forwardHostProp(r,n)})}})}return!0}_bootstrapDom(){if(!this._ensureTemplatized()||this._domBootstrapped)return;new MutationObserver(r=>{for(let n of r)if(n.type==="childList")for(let i of Array.from(n.addedNodes))i instanceof Element&&i.setAttribute("slot","items")}).observe(this,{childList:!0}),Array.from(this.children).forEach(r=>{this.removeChild(r)}),this._lruCachedItems.clear(),this._renderedItems.forEach((r,n)=>this._insertItem(r,n)),this._domBootstrapped=!0}_updateActive(){!this._domBootstrapped||Array.from(this._renderedTemplateInst.values()).forEach(t=>{t.notifyPath("active",this._contentActive)})}_updateDom(t){if(!!this._domBootstrapped&&!(t.path=="_renderedItems"||t.path=="_renderedItems.length"))if(t.path==="_renderedItems.splices")t.value.indexSplices.forEach(n=>{let{index:i,addedCount:o,object:a,removed:s}=n;s.forEach(l=>{this._removeItem(l,this.children[i])}),a.slice(i,i+o).forEach((l,c)=>this._insertItem(l,i+c)),this._trimCache()});else{let r=this._getItemKey(t.value);this._renderedTemplateInst.has(r)?this._renderedTemplateInst.get(r).notifyPath(this.as,t.value):console.warn(`Expected '${r}' to exist in the DOM but could not find one.`)}}_insertItem(t,r){if(!this._ensureTemplatized())throw new Error("Expected templatized before inserting an item");let n,i=this._getItemKey(t);if(this._lruCachedItems.has(i))n=this._lruCachedItems.get(i),this._lruCachedItems.delete(i),this._renderedTemplateInst.get(i).notifyPath("active",this._contentActive);else{let o={[this.as]:t,active:this._contentActive},a=new this._ctor(o);n=a.root,this._renderedTemplateInst.set(i,a)}this.children[r]?this.insertBefore(n,this.children[r]):((n.nodeType==Node.DOCUMENT_FRAGMENT_NODE?Array.from(n.children):[n]).forEach(a=>a.setAttribute("slot","items")),this.appendChild(n))}_removeItem(t,r){r.parentNode&&r.parentNode.removeChild(r);let n=this._getItemKey(t);this._lruCachedItems.set(n,r),this._renderedTemplateInst.get(n).notifyPath("active",!1)}_trimCache(){for(;this._lruCachedItems.size>this._cacheSize;){let[t]=this._lruCachedItems.keys();this._lruCachedItems.delete(t),this._renderedTemplateInst.delete(t)}}};E([A({type:String}),w("design:type",Object)],Oi.prototype,"as",void 0);E([A({type:Array}),w("design:type",Array)],Oi.prototype,"items",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Oi.prototype,"_contentActive",void 0);E([A({type:Boolean}),w("design:type",Object)],Oi.prototype,"_domBootstrapped",void 0);E([A({type:Object}),w("design:type",Object)],Oi.prototype,"_ctor",void 0);E([A({type:Array}),w("design:type",Array)],Oi.prototype,"_renderedItems",void 0);E([A({type:Object}),w("design:type",Object)],Oi.prototype,"_renderedTemplateInst",void 0);E([A({type:Object}),w("design:type",Object)],Oi.prototype,"_lruCachedItems",void 0);E([A({type:Number}),w("design:type",Object)],Oi.prototype,"_cacheSize",void 0);E([A({type:Object}),w("design:type",Object)],Oi.prototype,"_getItemKey",void 0);E([A({type:Boolean}),w("design:type",Object)],Oi.prototype,"_isConnected",void 0);E([Bt("_isConnected"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Oi.prototype,"_bootstrapDom",null);E([Bt("_contentActive"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Oi.prototype,"_updateActive",null);E([Bt("_renderedItems.*","_domBootstrapped"),w("design:type",Function),w("design:paramtypes",[Object]),w("design:returntype",void 0)],Oi.prototype,"_updateDom",null);E([Bt("_cacheSize"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Oi.prototype,"_trimCache",null);var hn=class extends Oi{constructor(){super(...arguments),this.disablePagination=!1,this.getCategoryItemKey=t=>JSON.stringify(t),this._limit=12,this._activeIndex=0,this._pageInputRawValue="",this._pageInputFocused=!1}_computeCount(){return this.category.items.length}get _hasMultiple(){return this._count>1}_togglePane(){this.opened=!this.opened}_changeContentActive(t){this._contentActive=t}_onPaneRenderedChanged(t,r){t&&t!==r&&this.$.ifRendered.render()}_computePaneRendered(t){return!(t.metadata.type===Na.SEARCH_RESULTS&&t.name==="")}get _itemsRendered(){return this._paneRendered&&this.opened}_computeIsSearchResults(t){return t===Na.SEARCH_RESULTS}_computeIsInvalidSearchResults(t){return t.type===Na.SEARCH_RESULTS&&!t.validRegex}_computeIsUniversalSearchQuery(t){return t.type===Na.SEARCH_RESULTS&&t.universalRegex}_isCompositeSearch(){let{type:t,compositeSearch:r}=this.category.metadata;return r&&t===Na.SEARCH_RESULTS}ready(){super.ready(),this.opened=this.initialOpened==null?!0:this.initialOpened,this._limitListener=()=>{this.set("_limit",WW())},qW(this._limitListener),this._limitListener()}detached(){GW(this._limitListener)}_updateRenderedItems(){var t=this._itemsRendered,r=this._limit,n=this._activeIndex,i=this.disablePagination;if(!t)return;let o=Math.floor(n/r),a=this.category.items||[],s=i?a:a.slice(o*r,(o+1)*r);this.updateDom(s)}_limitChanged(t){this.setCacheSize(t*2)}_getCategoryItemKeyChanged(){this.setGetItemKey(this.getCategoryItemKey)}get _currentPage(){var t=this._limit,r=this._activeIndex;return Math.floor(r/t)+1}_computePageCount(t,r){return this.category?Math.ceil(this.category.items.length/r):0}get _multiplePagesExist(){var t=this._pageCount,r=this.disablePagination;return!r&&t>1}get _hasPreviousPage(){var t=this._currentPage;return t>1}get _hasNextPage(){var t=this._currentPage,r=this._pageCount;return t<r}_computeInputWidth(t){return`calc(${t.toString().length}em + 20px)`}_setActiveIndex(t){let r=(this.category.items||[]).length-1;t>r&&(t=r),t<0&&(t=0),this.set("_activeIndex",t)}_clampActiveIndex(){this._setActiveIndex(this._activeIndex)}_performPreviousPage(){this._setActiveIndex(this._activeIndex-this._limit)}_performNextPage(){this._setActiveIndex(this._activeIndex+this._limit)}_computePageInputValue(t,r,n){return t?r:n.toString()}_handlePageInputEvent(t){this.set("_pageInputRawValue",t.target.value);let r=Number(t.target.value||NaN);if(isNaN(r))return;let n=Math.max(1,Math.min(r,this._pageCount))-1;this._setActiveIndex(this._limit*n)}_handlePageChangeEvent(){this.set("_pageInputRawValue",this._currentPage.toString())}_handlePageFocusEvent(){this.set("_pageInputRawValue",this._pageInputValue),this.set("_pageInputFocused",!0)}_handlePageBlurEvent(){this.set("_pageInputFocused",!1)}_updatePageInputValue(t){var n;let r=(n=this.shadowRoot)==null?void 0:n.querySelector("#page-input input");r&&(r.value=t)}_updateInputWidth(){this.updateStyles({"--tf-category-paginated-view-page-input-width":this._inputWidth})}};hn.template=Q`
    <template is="dom-if" if="[[_paneRendered]]" id="ifRendered">
      <button class="heading" on-tap="_togglePane" open-button$="[[opened]]">
        <span class="name">
          <template is="dom-if" if="[[_isSearchResults]]">
            <template is="dom-if" if="[[_isCompositeSearch(category)]]">
              <span>Tags matching multiple experiments</span>
              <template is="dom-if" if="[[_isInvalidSearchResults]]">
                <span
                  >&nbsp;<strong>(malformed regular expression)</strong></span
                >
              </template>
            </template>
            <template is="dom-if" if="[[!_isCompositeSearch(category)]]">
              <span class="light">Tags matching /</span>
              <span class="category-name" title$="[[category.name]]"
                >[[category.name]]</span
              >
              <span class="light">/</span>
              <template is="dom-if" if="[[_isUniversalSearchQuery]]">
                <span> (all tags)</span>
              </template>
              <template is="dom-if" if="[[_isInvalidSearchResults]]">
                <span> <strong>(malformed regular expression)</strong></span>
              </template>
            </template>
          </template>
          <template is="dom-if" if="[[!_isSearchResults]]">
            <span class="category-name" title$="[[category.name]]"
              >[[category.name]]</span
            >
          </template>
        </span>
        <span class="count">
          <template is="dom-if" if="[[_hasMultiple]]">
            <span>[[_count]]</span>
          </template>
          <iron-icon icon="expand-more" class="expand-arrow"></iron-icon>
        </span>
      </button>
      <!-- TODO(stephanwlee): investigate further. For some reason,
        transitionend that the iron-collapse relies on sometimes does not
        trigger when rendering a chart with a spinner. A toy example cannot
        reproduce this bug. -->
      <iron-collapse opened="[[opened]]" no-animation="">
        <div class="content">
          <span id="top-of-container"></span>
          <template is="dom-if" if="[[_multiplePagesExist]]">
            <div class="big-page-buttons" style="margin-bottom: 10px;">
              <paper-button
                on-tap="_performPreviousPage"
                disabled$="[[!_hasPreviousPage]]"
                >Previous page</paper-button
              >
              <paper-button
                on-tap="_performNextPage"
                disabled$="[[!_hasNextPage]]"
                >Next page</paper-button
              >
            </div>
          </template>

          <div id="items">
            <slot name="items"></slot>
          </div>
          <template is="dom-if" if="[[_multiplePagesExist]]">
            <div id="controls-container">
              <div style="display: inline-block; padding: 0 5px">
                Page
                <paper-input
                  id="page-input"
                  type="number"
                  no-label-float=""
                  min="1"
                  max="[[_pageCount]]"
                  value="[[_pageInputValue]]"
                  on-input="_handlePageInputEvent"
                  on-change="_handlePageChangeEvent"
                  on-focus="_handlePageFocusEvent"
                  on-blur="_handlePageBlurEvent"
                ></paper-input>
                of [[_pageCount]]
              </div>
            </div>

            <div class="big-page-buttons" style="margin-top: 10px;">
              <paper-button
                on-tap="_performPreviousPage"
                disabled$="[[!_hasPreviousPage]]"
                >Previous page</paper-button
              >
              <paper-button
                on-tap="_performNextPage"
                disabled$="[[!_hasNextPage]]"
                >Next page</paper-button
              >
            </div>
          </template>
        </div>
      </iron-collapse>
    </template>
    <style>
      :host {
        display: block;
        margin: 0 5px 1px 10px;
      }

      :host(:first-of-type) {
        margin-top: 10px;
      }

      :host(:last-of-type) {
        margin-bottom: 20px;
      }

      .heading {
        background-color: var(--primary-background-color);
        border: none;
        color: inherit;
        cursor: pointer;
        width: 100%;
        font-size: 15px;
        line-height: 1;
        box-shadow: 0 1px 5px var(--tb-raised-button-shadow-color);
        padding: 10px 15px;
        display: flex;
        align-items: center;
        justify-content: space-between;
      }

      .heading::-moz-focus-inner {
        padding: 10px 15px;
      }

      [open-button] {
        border-bottom-left-radius: 0 !important;
        border-bottom-right-radius: 0 !important;
      }

      [open-button] .expand-arrow {
        transform: rotateZ(180deg);
      }

      .name {
        display: inline-flex;
        overflow: hidden;
      }

      .light {
        color: var(--paper-grey-500);
      }

      .category-name {
        white-space: pre;
        overflow: hidden;
        text-overflow: ellipsis;
        padding: 2px 0;
      }

      .count {
        margin: 0 5px;
        font-size: 12px;
        color: var(--paper-grey-500);
        display: flex;
        align-items: center;
        flex: none;
      }

      .heading::-moz-focus-inner {
        padding: 10px 15px;
      }

      .content {
        display: flex;
        flex-direction: column;
        background-color: var(--primary-background-color);
        border-bottom-left-radius: 2px;
        border-bottom-right-radius: 2px;
        border-top: none;
        border: 1px solid #dedede;
        padding: 15px;
      }

      .light {
        color: var(--paper-grey-500);
      }

      #controls-container {
        justify-content: center;
        display: flex;
        flex-direction: row;
        flex-grow: 0;
        flex-shrink: 0;
        width: 100%;
      }

      #controls-container paper-button {
        display: inline-block;
      }

      .big-page-buttons {
        display: flex;
      }

      .big-page-buttons paper-button {
        background-color: var(--tb-ui-light-accent);
        color: var(--tb-ui-dark-accent);
        display: inline-block;
        flex-basis: 0;
        flex-grow: 1;
        flex-shrink: 1;
        font-size: 13px;
      }

      .big-page-buttons paper-button[disabled] {
        background: none;
      }

      slot {
        display: flex;
        flex-direction: row;
        flex-wrap: wrap;
      }

      ::slotted([slot='items']) {
        /* Tooltip for descriptions and others break with more strict ones. */
        contain: style;
      }

      #page-input {
        display: inline-block;
        width: var(--tf-category-paginated-view-page-input-width, 100%);
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],hn.prototype,"category",void 0);E([A({type:Boolean}),w("design:type",Boolean)],hn.prototype,"initialOpened",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],hn.prototype,"opened",void 0);E([A({type:Boolean}),w("design:type",Boolean)],hn.prototype,"disablePagination",void 0);E([A({type:Number,computed:"_computeCount(category.items.*)"}),w("design:type",Number)],hn.prototype,"_count",void 0);E([A({type:Boolean,computed:"_computePaneRendered(category)",observer:"_onPaneRenderedChanged"}),w("design:type",Boolean)],hn.prototype,"_paneRendered",void 0);E([A({type:Boolean,computed:"_computeIsSearchResults(category.metadata.type)"}),w("design:type",Boolean)],hn.prototype,"_isSearchResults",void 0);E([A({type:Boolean,computed:"_computeIsInvalidSearchResults(category.metadata)"}),w("design:type",Boolean)],hn.prototype,"_isInvalidSearchResults",void 0);E([A({type:Boolean,computed:"_computeIsUniversalSearchQuery(category.metadata)"}),w("design:type",Boolean)],hn.prototype,"_isUniversalSearchQuery",void 0);E([A({type:Object,observer:"_getCategoryItemKeyChanged"}),w("design:type",Object)],hn.prototype,"getCategoryItemKey",void 0);E([A({type:Number,observer:"_limitChanged"}),w("design:type",Number)],hn.prototype,"_limit",void 0);E([A({type:Number}),w("design:type",Number)],hn.prototype,"_activeIndex",void 0);E([A({type:Number,computed:"_computePageCount(category.items.*, _limit)"}),w("design:type",Number)],hn.prototype,"_pageCount",void 0);E([A({type:String,computed:"_computeInputWidth(_pageCount)",observer:"_updateInputWidth"}),w("design:type",String)],hn.prototype,"_inputWidth",void 0);E([A({type:String,computed:"_computePageInputValue(_pageInputFocused, _pageInputRawValue, _currentPage)",observer:"_updatePageInputValue"}),w("design:type",String)],hn.prototype,"_pageInputValue",void 0);E([A({type:String}),w("design:type",String)],hn.prototype,"_pageInputRawValue",void 0);E([A({type:Boolean}),w("design:type",Boolean)],hn.prototype,"_pageInputFocused",void 0);E([Rt("_count"),w("design:type",Boolean),w("design:paramtypes",[])],hn.prototype,"_hasMultiple",null);E([Bt("opened"),w("design:type",Function),w("design:paramtypes",[Boolean]),w("design:returntype",void 0)],hn.prototype,"_changeContentActive",null);E([Rt("opened","_paneRendered"),w("design:type",Boolean),w("design:paramtypes",[])],hn.prototype,"_itemsRendered",null);E([Bt("_itemsRendered","category.items.*","_limit","_activeIndex","_pageCount","disablePagination"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],hn.prototype,"_updateRenderedItems",null);E([Rt("_limit","_activeIndex"),w("design:type",Number),w("design:paramtypes",[])],hn.prototype,"_currentPage",null);E([Rt("_pageCount","disablePagination"),w("design:type",Boolean),w("design:paramtypes",[])],hn.prototype,"_multiplePagesExist",null);E([Rt("_currentPage"),w("design:type",Boolean),w("design:paramtypes",[])],hn.prototype,"_hasPreviousPage",null);E([Rt("_currentPage","_pageCount"),w("design:type",Boolean),w("design:paramtypes",[])],hn.prototype,"_hasNextPage",null);E([Bt("category.items.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],hn.prototype,"_clampActiveIndex",null);hn=E([yt("tf-category-paginated-view")],hn);var H0t=Ee(Oe(),1);var B9=class{constructor(t){this.listener=t}},bp=class{constructor(){this.requestManager=new Ae(1),this._listeners=new Set,this.initialized=!1}refresh(){return this.load().then(()=>{this.initialized=!0})}addListener(t){let r=new B9(t);return this._listeners.add(r),r}removeListenerByKey(t){this._listeners.delete(t)}emitChange(){this._listeners.forEach(t=>{try{t.listener()}catch(r){}})}};var H9=class extends bp{load(){let t=ve().environment();return this.requestManager.request(t).then(r=>{let n={dataLocation:r.data_location,windowTitle:r.window_title};r.experiment_name!==void 0&&(n.experimentName=r.experiment_name),r.experiment_description!==void 0&&(n.experimentDescription=r.experiment_description),r.creation_time!==void 0&&(n.creationTime=r.creation_time),!H0t.isEqual(this.environment,n)&&(this.environment=n,this.emitChange())})}getDataLocation(){return this.environment?this.environment.dataLocation:""}getWindowTitle(){return this.environment?this.environment.windowTitle:""}getExperimentName(){return this.environment?this.environment.experimentName:""}getExperimentDescription(){return this.environment?this.environment.experimentDescription:""}getCreationTime(){return this.environment?this.environment.creationTime:null}},ib=new H9;var V0t=Ee(Oe(),1);var V9=class extends bp{constructor(){super(...arguments),this._runs=[]}load(){let t=ve().runs();return this.requestManager.request(t).then(r=>{V0t.isEqual(this._runs,r)||(this._runs=r,this.emitChange())})}getRuns(){return this._runs.slice()}},wp=new V9;var Vr={};Ks(Vr,{FormatSpecifier:()=>qE,active:()=>O1t,arc:()=>NSt,area:()=>O8,areaRadial:()=>a$,ascending:()=>oa,autoType:()=>oj,axisBottom:()=>K9,axisLeft:()=>lb,axisRight:()=>u_t,axisTop:()=>c_t,bisect:()=>ys,bisectLeft:()=>G0t,bisectRight:()=>YW,bisector:()=>ob,blob:()=>Ivt,brush:()=>qL,brushSelection:()=>VL,brushX:()=>U1t,brushY:()=>UL,buffer:()=>Lvt,chord:()=>G1t,clientPoint:()=>Dm,cluster:()=>Hbt,color:()=>rc,contourDensity:()=>hvt,contours:()=>KL,create:()=>ryt,creator:()=>Rm,cross:()=>U9,csv:()=>Rvt,csvFormat:()=>gvt,csvFormatBody:()=>_vt,csvFormatRow:()=>vvt,csvFormatRows:()=>yvt,csvFormatValue:()=>xvt,csvParse:()=>Cb,csvParseRows:()=>mvt,cubehelix:()=>la,curveBasis:()=>G8,curveBasisClosed:()=>XSt,curveBasisOpen:()=>KSt,curveBundle:()=>JSt,curveCardinal:()=>QSt,curveCardinalClosed:()=>t3t,curveCardinalOpen:()=>e3t,curveCatmullRom:()=>n3t,curveCatmullRomClosed:()=>o3t,curveCatmullRomOpen:()=>s3t,curveLinear:()=>Yh,curveLinearClosed:()=>c3t,curveMonotoneX:()=>m3t,curveMonotoneY:()=>g3t,curveNatural:()=>v3t,curveStep:()=>x3t,curveStepAfter:()=>w3t,curveStepBefore:()=>b3t,customEvent:()=>Mp,descending:()=>Y0t,deviation:()=>G9,dispatch:()=>vs,drag:()=>pb,dragDisable:()=>zm,dragEnable:()=>Fm,dsv:()=>aj,dsvFormat:()=>Wm,easeBack:()=>DL,easeBackIn:()=>zY,easeBackInOut:()=>DL,easeBackOut:()=>FY,easeBounce:()=>P_,easeBounceIn:()=>NY,easeBounceInOut:()=>DY,easeBounceOut:()=>P_,easeCircle:()=>RL,easeCircleIn:()=>LY,easeCircleInOut:()=>RL,easeCircleOut:()=>kY,easeCubic:()=>xs,easeCubicIn:()=>bY,easeCubicInOut:()=>xs,easeCubicOut:()=>wY,easeElastic:()=>OL,easeElasticIn:()=>VY,easeElasticInOut:()=>UY,easeElasticOut:()=>OL,easeExp:()=>kL,easeExpIn:()=>PY,easeExpInOut:()=>kL,easeExpOut:()=>IY,easeLinear:()=>yY,easePoly:()=>IL,easePolyIn:()=>MY,easePolyInOut:()=>IL,easePolyOut:()=>EY,easeQuad:()=>PL,easeQuadIn:()=>vY,easeQuadInOut:()=>PL,easeQuadOut:()=>xY,easeSin:()=>LL,easeSinIn:()=>TY,easeSinInOut:()=>LL,easeSinOut:()=>CY,entries:()=>ovt,event:()=>qt,extent:()=>aa,forceCenter:()=>Hvt,forceCollide:()=>oxt,forceLink:()=>sxt,forceManyBody:()=>hxt,forceRadial:()=>fxt,forceSimulation:()=>uxt,forceX:()=>pxt,forceY:()=>dxt,format:()=>xn,formatDefaultLocale:()=>rk,formatLocale:()=>tk,formatPrefix:()=>GE,formatSpecifier:()=>Lp,geoAlbers:()=>Vk,geoAlbersUsa:()=>Tbt,geoArea:()=>Pxt,geoAzimuthalEqualArea:()=>Cbt,geoAzimuthalEqualAreaRaw:()=>qk,geoAzimuthalEquidistant:()=>Abt,geoAzimuthalEquidistantRaw:()=>Gk,geoBounds:()=>zxt,geoCentroid:()=>qxt,geoCircle:()=>Xxt,geoClipAntimeridian:()=>t5,geoClipCircle:()=>Ck,geoClipExtent:()=>Zxt,geoClipRectangle:()=>Dp,geoConicConformal:()=>Ibt,geoConicConformalRaw:()=>Xj,geoConicEqualArea:()=>W_,geoConicEqualAreaRaw:()=>Yj,geoConicEquidistant:()=>kbt,geoConicEquidistantRaw:()=>$j,geoContains:()=>ibt,geoDistance:()=>Nb,geoEqualEarth:()=>Rbt,geoEqualEarthRaw:()=>jk,geoEquirectangular:()=>Lbt,geoEquirectangularRaw:()=>j_,geoGnomonic:()=>Nbt,geoGnomonicRaw:()=>Xk,geoGraticule:()=>Rk,geoGraticule10:()=>sbt,geoIdentity:()=>Dbt,geoInterpolate:()=>lbt,geoLength:()=>Lk,geoMercator:()=>Pbt,geoMercatorRaw:()=>Y_,geoNaturalEarth1:()=>Obt,geoNaturalEarth1Raw:()=>$k,geoOrthographic:()=>zbt,geoOrthographicRaw:()=>Kk,geoPath:()=>bbt,geoProjection:()=>Mi,geoProjectionMutator:()=>s5,geoRotation:()=>bk,geoStereographic:()=>Fbt,geoStereographicRaw:()=>Zk,geoStream:()=>vo,geoTransform:()=>wbt,geoTransverseMercator:()=>Bbt,geoTransverseMercatorRaw:()=>Jk,gray:()=>yyt,hcl:()=>gb,hierarchy:()=>f5,histogram:()=>Z0t,hsl:()=>Vm,html:()=>Fvt,image:()=>Dvt,interpolate:()=>nc,interpolateArray:()=>Iyt,interpolateBasis:()=>sL,interpolateBasisClosed:()=>lL,interpolateBlues:()=>mSt,interpolateBrBG:()=>Xwt,interpolateBuGn:()=>nSt,interpolateBuPu:()=>iSt,interpolateCividis:()=>bSt,interpolateCool:()=>MSt,interpolateCubehelix:()=>jyt,interpolateCubehelixDefault:()=>wSt,interpolateCubehelixLong:()=>E_,interpolateDate:()=>hL,interpolateDiscrete:()=>Lyt,interpolateGnBu:()=>oSt,interpolateGreens:()=>gSt,interpolateGreys:()=>_St,interpolateHcl:()=>Gyt,interpolateHclLong:()=>Wyt,interpolateHsl:()=>Vyt,interpolateHslLong:()=>Uyt,interpolateHue:()=>kyt,interpolateInferno:()=>ISt,interpolateLab:()=>M_,interpolateMagma:()=>PSt,interpolateNumber:()=>zi,interpolateNumberArray:()=>yb,interpolateObject:()=>fL,interpolateOrRd:()=>aSt,interpolateOranges:()=>xSt,interpolatePRGn:()=>$wt,interpolatePiYG:()=>Kwt,interpolatePlasma:()=>LSt,interpolatePuBu:()=>lSt,interpolatePuBuGn:()=>sSt,interpolatePuOr:()=>Zwt,interpolatePuRd:()=>cSt,interpolatePurples:()=>ySt,interpolateRainbow:()=>ESt,interpolateRdBu:()=>Jwt,interpolateRdGy:()=>Qwt,interpolateRdPu:()=>uSt,interpolateRdYlBu:()=>tSt,interpolateRdYlGn:()=>eSt,interpolateReds:()=>vSt,interpolateRgb:()=>qm,interpolateRgbBasis:()=>cL,interpolateRgbBasisClosed:()=>Pyt,interpolateRound:()=>pL,interpolateSinebow:()=>TSt,interpolateSpectral:()=>rSt,interpolateString:()=>vb,interpolateTransformCss:()=>gL,interpolateTransformSvg:()=>_L,interpolateTurbo:()=>CSt,interpolateViridis:()=>ASt,interpolateWarm:()=>SSt,interpolateYlGn:()=>fSt,interpolateYlGnBu:()=>hSt,interpolateYlOrBr:()=>pSt,interpolateYlOrRd:()=>dSt,interpolateZoom:()=>yL,interrupt:()=>hu,interval:()=>Jyt,isoFormat:()=>Rwt,isoParse:()=>Nwt,json:()=>Ovt,keys:()=>XL,lab:()=>w_,lch:()=>xyt,line:()=>vu,lineRadial:()=>o$,linkHorizontal:()=>HSt,linkRadial:()=>USt,linkVertical:()=>VSt,local:()=>tL,map:()=>Ji,matcher:()=>ub,max:()=>lu,mean:()=>t_t,median:()=>e_t,merge:()=>Im,min:()=>Lm,mouse:()=>zo,namespace:()=>Ph,namespaces:()=>wE,nest:()=>Z1t,now:()=>Ap,pack:()=>c2t,packEnclose:()=>t8,packSiblings:()=>o2t,pairs:()=>W0t,partition:()=>u2t,path:()=>bs,permute:()=>r_t,pie:()=>FSt,piecewise:()=>mY,pointRadial:()=>ly,polygonArea:()=>v2t,polygonCentroid:()=>x2t,polygonContains:()=>M2t,polygonHull:()=>S2t,polygonLength:()=>E2t,precisionFixed:()=>nk,precisionPrefix:()=>ik,precisionRound:()=>ok,quadtree:()=>zh,quantile:()=>sa,quantize:()=>Xyt,radialArea:()=>a$,radialLine:()=>o$,randomBates:()=>A2t,randomExponential:()=>P2t,randomIrwinHall:()=>a8,randomLogNormal:()=>C2t,randomNormal:()=>o8,randomUniform:()=>T2t,range:()=>Ir,rgb:()=>cu,ribbon:()=>j1t,scaleBand:()=>Qm,scaleDiverging:()=>P8,scaleDivergingLog:()=>AX,scaleDivergingPow:()=>I8,scaleDivergingSqrt:()=>Fwt,scaleDivergingSymlog:()=>PX,scaleIdentity:()=>c8,scaleImplicit:()=>s8,scaleLinear:()=>zn,scaleLog:()=>cc,scaleOrdinal:()=>gu,scalePoint:()=>tg,scalePow:()=>K_,scaleQuantile:()=>eg,scaleQuantize:()=>qb,scaleSequential:()=>E8,scaleSequentialLog:()=>TX,scaleSequentialPow:()=>T8,scaleSequentialQuantile:()=>C8,scaleSequentialSqrt:()=>zwt,scaleSequentialSymlog:()=>CX,scaleSqrt:()=>V2t,scaleSymlog:()=>h8,scaleThreshold:()=>f8,scaleTime:()=>Yb,scaleUtc:()=>Owt,scan:()=>n_t,schemeAccent:()=>Bwt,schemeBlues:()=>ZX,schemeBrBG:()=>IX,schemeBuGn:()=>BX,schemeBuPu:()=>HX,schemeCategory10:()=>jb,schemeDark2:()=>Hwt,schemeGnBu:()=>VX,schemeGreens:()=>JX,schemeGreys:()=>QX,schemeOrRd:()=>UX,schemeOranges:()=>r$,schemePRGn:()=>LX,schemePaired:()=>Vwt,schemePastel1:()=>Uwt,schemePastel2:()=>qwt,schemePiYG:()=>kX,schemePuBu:()=>GX,schemePuBuGn:()=>qX,schemePuOr:()=>RX,schemePuRd:()=>WX,schemePurples:()=>t$,schemeRdBu:()=>NX,schemeRdGy:()=>DX,schemeRdPu:()=>YX,schemeRdYlBu:()=>OX,schemeRdYlGn:()=>zX,schemeReds:()=>e$,schemeSet1:()=>Gwt,schemeSet2:()=>Wwt,schemeSet3:()=>Ywt,schemeSpectral:()=>FX,schemeTableau10:()=>jwt,schemeYlGn:()=>XX,schemeYlGnBu:()=>jX,schemeYlOrBr:()=>$X,schemeYlOrRd:()=>KX,select:()=>Ht,selectAll:()=>Ep,selection:()=>Ih,selector:()=>Nm,selectorAll:()=>cb,set:()=>tvt,shuffle:()=>i_t,stack:()=>S3t,stackOffsetDiverging:()=>E3t,stackOffsetExpand:()=>M3t,stackOffsetNone:()=>xu,stackOffsetSilhouette:()=>T3t,stackOffsetWiggle:()=>C3t,stackOrderAppearance:()=>K8,stackOrderAscending:()=>Z8,stackOrderDescending:()=>A3t,stackOrderInsideOut:()=>P3t,stackOrderNone:()=>bu,stackOrderReverse:()=>I3t,stratify:()=>p2t,style:()=>Sp,sum:()=>o_t,svg:()=>Bvt,symbol:()=>YSt,symbolCircle:()=>L5,symbolCross:()=>F8,symbolDiamond:()=>B8,symbolSquare:()=>V8,symbolStar:()=>H8,symbolTriangle:()=>U8,symbolWye:()=>q8,symbols:()=>WSt,text:()=>D_,thresholdFreedmanDiaconis:()=>J0t,thresholdScott:()=>Q0t,thresholdSturges:()=>sb,tickFormat:()=>l8,tickIncrement:()=>x_,tickStep:()=>tl,ticks:()=>ab,timeDay:()=>ty,timeDays:()=>X2t,timeFormat:()=>S5,timeFormatDefaultLocale:()=>w8,timeFormatLocale:()=>w5,timeFriday:()=>hX,timeFridays:()=>Q2t,timeHour:()=>_8,timeHours:()=>Y2t,timeInterval:()=>br,timeMillisecond:()=>Z_,timeMilliseconds:()=>sX,timeMinute:()=>g8,timeMinutes:()=>G2t,timeMonday:()=>ry,timeMondays:()=>$2t,timeMonth:()=>y8,timeMonths:()=>rwt,timeParse:()=>SX,timeSaturday:()=>fX,timeSaturdays:()=>twt,timeSecond:()=>Q_,timeSeconds:()=>lX,timeSunday:()=>rg,timeSundays:()=>pX,timeThursday:()=>zp,timeThursdays:()=>J2t,timeTuesday:()=>cX,timeTuesdays:()=>K2t,timeWednesday:()=>uX,timeWednesdays:()=>Z2t,timeWeek:()=>rg,timeWeeks:()=>pX,timeYear:()=>Gh,timeYears:()=>nwt,timeout:()=>OE,timer:()=>A_,timerFlush:()=>_Y,touch:()=>Tp,touches:()=>nyt,transition:()=>AL,transpose:()=>W9,tree:()=>d2t,treemap:()=>m2t,treemapBinary:()=>g2t,treemapDice:()=>Uh,treemapResquarify:()=>y2t,treemapSlice:()=>Jm,treemapSliceDice:()=>_2t,treemapSquarify:()=>i8,tsv:()=>Nvt,tsvFormat:()=>Svt,tsvFormatBody:()=>Mvt,tsvFormatRow:()=>Tvt,tsvFormatRows:()=>Evt,tsvFormatValue:()=>Cvt,tsvParse:()=>Ab,tsvParseRows:()=>wvt,utcDay:()=>ny,utcDays:()=>cwt,utcFormat:()=>ay,utcFriday:()=>_X,utcFridays:()=>dwt,utcHour:()=>x8,utcHours:()=>swt,utcMillisecond:()=>Z_,utcMilliseconds:()=>sX,utcMinute:()=>v8,utcMinutes:()=>owt,utcMonday:()=>oy,utcMondays:()=>uwt,utcMonth:()=>b8,utcMonths:()=>_wt,utcParse:()=>M5,utcSaturday:()=>yX,utcSaturdays:()=>mwt,utcSecond:()=>Q_,utcSeconds:()=>lX,utcSunday:()=>ng,utcSundays:()=>vX,utcThursday:()=>Fp,utcThursdays:()=>pwt,utcTuesday:()=>mX,utcTuesdays:()=>hwt,utcWednesday:()=>gX,utcWednesdays:()=>fwt,utcWeek:()=>ng,utcWeeks:()=>vX,utcYear:()=>Wh,utcYears:()=>ywt,values:()=>nvt,variance:()=>q9,version:()=>U0t,voronoi:()=>W3t,window:()=>hb,xml:()=>zvt,zip:()=>a_t,zoom:()=>tR,zoomIdentity:()=>Xh,zoomTransform:()=>i2});var U0t="5.7.0";function oa(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}function ob(e){return e.length===1&&(e=n2e(e)),{left:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)<0?n=o+1:i=o}return n},right:function(t,r,n,i){for(n==null&&(n=0),i==null&&(i=t.length);n<i;){var o=n+i>>>1;e(t[o],r)>0?i=o:n=o+1}return n}}}function n2e(e){return function(t,r){return oa(e(t),r)}}var q0t=ob(oa),YW=q0t.right,G0t=q0t.left,ys=YW;function W0t(e,t){t==null&&(t=jW);for(var r=0,n=e.length-1,i=e[0],o=new Array(n<0?0:n);r<n;)o[r]=t(i,i=e[++r]);return o}function jW(e,t){return[e,t]}function U9(e,t,r){var n=e.length,i=t.length,o=new Array(n*i),a,s,l,c;for(r==null&&(r=jW),a=l=0;a<n;++a)for(c=e[a],s=0;s<i;++s,++l)o[l]=r(c,t[s]);return o}function Y0t(e,t){return t<e?-1:t>e?1:t>=e?0:NaN}function Qs(e){return e===null?NaN:+e}function q9(e,t){var r=e.length,n=0,i=-1,o=0,a,s,l=0;if(t==null)for(;++i<r;)isNaN(a=Qs(e[i]))||(s=a-o,o+=s/++n,l+=s*(a-o));else for(;++i<r;)isNaN(a=Qs(t(e[i],i,e)))||(s=a-o,o+=s/++n,l+=s*(a-o));if(n>1)return l/(n-1)}function G9(e,t){var r=q9(e,t);return r&&Math.sqrt(r)}function aa(e,t){var r=e.length,n=-1,i,o,a;if(t==null){for(;++n<r;)if((i=e[n])!=null&&i>=i)for(o=a=i;++n<r;)(i=e[n])!=null&&(o>i&&(o=i),a<i&&(a=i))}else for(;++n<r;)if((i=t(e[n],n,e))!=null&&i>=i)for(o=a=i;++n<r;)(i=t(e[n],n,e))!=null&&(o>i&&(o=i),a<i&&(a=i));return[o,a]}var j0t=Array.prototype,X0t=j0t.slice,$0t=j0t.map;function xE(e){return function(){return e}}function K0t(e){return e}function Ir(e,t,r){e=+e,t=+t,r=(i=arguments.length)<2?(t=e,e=0,1):i<3?1:+r;for(var n=-1,i=Math.max(0,Math.ceil((t-e)/r))|0,o=new Array(i);++n<i;)o[n]=e+n*r;return o}var XW=Math.sqrt(50),$W=Math.sqrt(10),KW=Math.sqrt(2);function ab(e,t,r){var n,i=-1,o,a,s;if(t=+t,e=+e,r=+r,e===t&&r>0)return[e];if((n=t<e)&&(o=e,e=t,t=o),(s=x_(e,t,r))===0||!isFinite(s))return[];if(s>0)for(e=Math.ceil(e/s),t=Math.floor(t/s),a=new Array(o=Math.ceil(t-e+1));++i<o;)a[i]=(e+i)*s;else for(e=Math.floor(e*s),t=Math.ceil(t*s),a=new Array(o=Math.ceil(e-t+1));++i<o;)a[i]=(e-i)/s;return n&&a.reverse(),a}function x_(e,t,r){var n=(t-e)/Math.max(0,r),i=Math.floor(Math.log(n)/Math.LN10),o=n/Math.pow(10,i);return i>=0?(o>=XW?10:o>=$W?5:o>=KW?2:1)*Math.pow(10,i):-Math.pow(10,-i)/(o>=XW?10:o>=$W?5:o>=KW?2:1)}function tl(e,t,r){var n=Math.abs(t-e)/Math.max(0,r),i=Math.pow(10,Math.floor(Math.log(n)/Math.LN10)),o=n/i;return o>=XW?i*=10:o>=$W?i*=5:o>=KW&&(i*=2),t<e?-i:i}function sb(e){return Math.ceil(Math.log(e.length)/Math.LN2)+1}function Z0t(){var e=K0t,t=aa,r=sb;function n(i){var o,a=i.length,s,l=new Array(a);for(o=0;o<a;++o)l[o]=e(i[o],o,i);var c=t(l),u=c[0],h=c[1],f=r(l,u,h);Array.isArray(f)||(f=tl(u,h,f),f=Ir(Math.ceil(u/f)*f,h,f));for(var p=f.length;f[0]<=u;)f.shift(),--p;for(;f[p-1]>h;)f.pop(),--p;var d=new Array(p+1),g;for(o=0;o<=p;++o)g=d[o]=[],g.x0=o>0?f[o-1]:u,g.x1=o<p?f[o]:h;for(o=0;o<a;++o)s=l[o],u<=s&&s<=h&&d[ys(f,s,0,p)].push(i[o]);return d}return n.value=function(i){return arguments.length?(e=typeof i=="function"?i:xE(i),n):e},n.domain=function(i){return arguments.length?(t=typeof i=="function"?i:xE([i[0],i[1]]),n):t},n.thresholds=function(i){return arguments.length?(r=typeof i=="function"?i:Array.isArray(i)?xE(X0t.call(i)):xE(i),n):r},n}function sa(e,t,r){if(r==null&&(r=Qs),!!(n=e.length)){if((t=+t)<=0||n<2)return+r(e[0],0,e);if(t>=1)return+r(e[n-1],n-1,e);var n,i=(n-1)*t,o=Math.floor(i),a=+r(e[o],o,e),s=+r(e[o+1],o+1,e);return a+(s-a)*(i-o)}}function J0t(e,t,r){return e=$0t.call(e,Qs).sort(oa),Math.ceil((r-t)/(2*(sa(e,.75)-sa(e,.25))*Math.pow(e.length,-1/3)))}function Q0t(e,t,r){return Math.ceil((r-t)/(3.5*G9(e)*Math.pow(e.length,-1/3)))}function lu(e,t){var r=e.length,n=-1,i,o;if(t==null){for(;++n<r;)if((i=e[n])!=null&&i>=i)for(o=i;++n<r;)(i=e[n])!=null&&i>o&&(o=i)}else for(;++n<r;)if((i=t(e[n],n,e))!=null&&i>=i)for(o=i;++n<r;)(i=t(e[n],n,e))!=null&&i>o&&(o=i);return o}function t_t(e,t){var r=e.length,n=r,i=-1,o,a=0;if(t==null)for(;++i<r;)isNaN(o=Qs(e[i]))?--n:a+=o;else for(;++i<r;)isNaN(o=Qs(t(e[i],i,e)))?--n:a+=o;if(n)return a/n}function e_t(e,t){var r=e.length,n=-1,i,o=[];if(t==null)for(;++n<r;)isNaN(i=Qs(e[n]))||o.push(i);else for(;++n<r;)isNaN(i=Qs(t(e[n],n,e)))||o.push(i);return sa(o.sort(oa),.5)}function Im(e){for(var t=e.length,r,n=-1,i=0,o,a;++n<t;)i+=e[n].length;for(o=new Array(i);--t>=0;)for(a=e[t],r=a.length;--r>=0;)o[--i]=a[r];return o}function Lm(e,t){var r=e.length,n=-1,i,o;if(t==null){for(;++n<r;)if((i=e[n])!=null&&i>=i)for(o=i;++n<r;)(i=e[n])!=null&&o>i&&(o=i)}else for(;++n<r;)if((i=t(e[n],n,e))!=null&&i>=i)for(o=i;++n<r;)(i=t(e[n],n,e))!=null&&o>i&&(o=i);return o}function r_t(e,t){for(var r=t.length,n=new Array(r);r--;)n[r]=e[t[r]];return n}function n_t(e,t){if(!!(r=e.length)){var r,n=0,i=0,o,a=e[i];for(t==null&&(t=oa);++n<r;)(t(o=e[n],a)<0||t(a,a)!==0)&&(a=o,i=n);if(t(a,a)===0)return i}}function i_t(e,t,r){for(var n=(r==null?e.length:r)-(t=t==null?0:+t),i,o;n;)o=Math.random()*n--|0,i=e[n+t],e[n+t]=e[o+t],e[o+t]=i;return e}function o_t(e,t){var r=e.length,n=-1,i,o=0;if(t==null)for(;++n<r;)(i=+e[n])&&(o+=i);else for(;++n<r;)(i=+t(e[n],n,e))&&(o+=i);return o}function W9(e){if(!(o=e.length))return[];for(var t=-1,r=Lm(e,i2e),n=new Array(r);++t<r;)for(var i=-1,o,a=n[t]=new Array(o);++i<o;)a[i]=e[i][t];return n}function i2e(e){return e.length}function a_t(){return W9(arguments)}var Y9=Array.prototype.slice;function s_t(e){return e}var j9=1,X9=2,ZW=3,bE=4,l_t=1e-6;function o2e(e){return"translate("+(e+.5)+",0)"}function a2e(e){return"translate(0,"+(e+.5)+")"}function s2e(e){return function(t){return+e(t)}}function l2e(e){var t=Math.max(0,e.bandwidth()-1)/2;return e.round()&&(t=Math.round(t)),function(r){return+e(r)+t}}function c2e(){return!this.__axis}function $9(e,t){var r=[],n=null,i=null,o=6,a=6,s=3,l=e===j9||e===bE?-1:1,c=e===bE||e===X9?"x":"y",u=e===j9||e===ZW?o2e:a2e;function h(f){var p=n==null?t.ticks?t.ticks.apply(t,r):t.domain():n,d=i==null?t.tickFormat?t.tickFormat.apply(t,r):s_t:i,g=Math.max(o,0)+s,_=t.range(),y=+_[0]+.5,x=+_[_.length-1]+.5,b=(t.bandwidth?l2e:s2e)(t.copy()),S=f.selection?f.selection():f,C=S.selectAll(".domain").data([null]),P=S.selectAll(".tick").data(p,t).order(),k=P.exit(),O=P.enter().append("g").attr("class","tick"),D=P.select("line"),B=P.select("text");C=C.merge(C.enter().insert("path",".tick").attr("class","domain").attr("stroke","currentColor")),P=P.merge(O),D=D.merge(O.append("line").attr("stroke","currentColor").attr(c+"2",l*o)),B=B.merge(O.append("text").attr("fill","currentColor").attr(c,l*g).attr("dy",e===j9?"0em":e===ZW?"0.71em":"0.32em")),f!==S&&(C=C.transition(f),P=P.transition(f),D=D.transition(f),B=B.transition(f),k=k.transition(f).attr("opacity",l_t).attr("transform",function(I){return isFinite(I=b(I))?u(I):this.getAttribute("transform")}),O.attr("opacity",l_t).attr("transform",function(I){var L=this.parentNode.__axis;return u(L&&isFinite(L=L(I))?L:b(I))})),k.remove(),C.attr("d",e===bE||e==X9?a?"M"+l*a+","+y+"H0.5V"+x+"H"+l*a:"M0.5,"+y+"V"+x:a?"M"+y+","+l*a+"V0.5H"+x+"V"+l*a:"M"+y+",0.5H"+x),P.attr("opacity",1).attr("transform",function(I){return u(b(I))}),D.attr(c+"2",l*o),B.attr(c,l*g).text(d),S.filter(c2e).attr("fill","none").attr("font-size",10).attr("font-family","sans-serif").attr("text-anchor",e===X9?"start":e===bE?"end":"middle"),S.each(function(){this.__axis=b})}return h.scale=function(f){return arguments.length?(t=f,h):t},h.ticks=function(){return r=Y9.call(arguments),h},h.tickArguments=function(f){return arguments.length?(r=f==null?[]:Y9.call(f),h):r.slice()},h.tickValues=function(f){return arguments.length?(n=f==null?null:Y9.call(f),h):n&&n.slice()},h.tickFormat=function(f){return arguments.length?(i=f,h):i},h.tickSize=function(f){return arguments.length?(o=a=+f,h):o},h.tickSizeInner=function(f){return arguments.length?(o=+f,h):o},h.tickSizeOuter=function(f){return arguments.length?(a=+f,h):a},h.tickPadding=function(f){return arguments.length?(s=+f,h):s},h}function c_t(e){return $9(j9,e)}function u_t(e){return $9(X9,e)}function K9(e){return $9(ZW,e)}function lb(e){return $9(bE,e)}km();km();var J9="http://www.w3.org/1999/xhtml",wE={svg:"http://www.w3.org/2000/svg",xhtml:J9,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};function Ph(e){var t=e+="",r=t.indexOf(":");return r>=0&&(t=e.slice(0,r))!=="xmlns"&&(e=e.slice(r+1)),wE.hasOwnProperty(t)?{space:wE[t],local:e}:e}function p2e(e){return function(){var t=this.ownerDocument,r=this.namespaceURI;return r===J9&&t.documentElement.namespaceURI===J9?t.createElement(e):t.createElementNS(r,e)}}function d2e(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function Rm(e){var t=Ph(e);return(t.local?d2e:p2e)(t)}function m2e(){}function Nm(e){return e==null?m2e:function(){return this.querySelector(e)}}function d_t(e){typeof e!="function"&&(e=Nm(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=new Array(a),l,c,u=0;u<a;++u)(l=o[u])&&(c=e.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),s[u]=c);return new Dn(n,this._parents)}function g2e(){return[]}function cb(e){return e==null?g2e:function(){return this.querySelectorAll(e)}}function m_t(e){typeof e!="function"&&(e=cb(e));for(var t=this._groups,r=t.length,n=[],i=[],o=0;o<r;++o)for(var a=t[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&(n.push(e.call(l,l.__data__,c,a)),i.push(l));return new Dn(n,i)}function ub(e){return function(){return this.matches(e)}}function g_t(e){typeof e!="function"&&(e=ub(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new Dn(n,this._parents)}function Q9(e){return new Array(e.length)}function __t(){return new Dn(this._enter||this._groups.map(Q9),this._parents)}function SE(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}SE.prototype={constructor:SE,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}};function y_t(e){return function(){return e}}var v_t="$";function _2e(e,t,r,n,i,o){for(var a=0,s,l=t.length,c=o.length;a<c;++a)(s=t[a])?(s.__data__=o[a],n[a]=s):r[a]=new SE(e,o[a]);for(;a<l;++a)(s=t[a])&&(i[a]=s)}function y2e(e,t,r,n,i,o,a){var s,l,c={},u=t.length,h=o.length,f=new Array(u),p;for(s=0;s<u;++s)(l=t[s])&&(f[s]=p=v_t+a.call(l,l.__data__,s,t),p in c?i[s]=l:c[p]=l);for(s=0;s<h;++s)p=v_t+a.call(e,o[s],s,o),(l=c[p])?(n[s]=l,l.__data__=o[s],c[p]=null):r[s]=new SE(e,o[s]);for(s=0;s<u;++s)(l=t[s])&&c[f[s]]===l&&(i[s]=l)}function x_t(e,t){if(!e)return p=new Array(this.size()),c=-1,this.each(function(P){p[++c]=P}),p;var r=t?y2e:_2e,n=this._parents,i=this._groups;typeof e!="function"&&(e=y_t(e));for(var o=i.length,a=new Array(o),s=new Array(o),l=new Array(o),c=0;c<o;++c){var u=n[c],h=i[c],f=h.length,p=e.call(u,u&&u.__data__,c,n),d=p.length,g=s[c]=new Array(d),_=a[c]=new Array(d),y=l[c]=new Array(f);r(u,h,g,_,y,p,t);for(var x=0,b=0,S,C;x<d;++x)if(S=g[x]){for(x>=b&&(b=x+1);!(C=_[b])&&++b<d;);S._next=C||null}}return a=new Dn(a,n),a._enter=s,a._exit=l,a}function b_t(){return new Dn(this._exit||this._groups.map(Q9),this._parents)}function w_t(e,t,r){var n=this.enter(),i=this,o=this.exit();return n=typeof e=="function"?e(n):n.append(e+""),t!=null&&(i=t(i)),r==null?o.remove():r(o),n&&i?n.merge(i).order():i}function S_t(e){for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new Dn(a,this._parents)}function M_t(){for(var e=this._groups,t=-1,r=e.length;++t<r;)for(var n=e[t],i=n.length-1,o=n[i],a;--i>=0;)(a=n[i])&&(o&&a.compareDocumentPosition(o)^4&&o.parentNode.insertBefore(a,o),o=a);return this}function E_t(e){e||(e=v2e);function t(h,f){return h&&f?e(h.__data__,f.__data__):!h-!f}for(var r=this._groups,n=r.length,i=new Array(n),o=0;o<n;++o){for(var a=r[o],s=a.length,l=i[o]=new Array(s),c,u=0;u<s;++u)(c=a[u])&&(l[u]=c);l.sort(t)}return new Dn(i,this._parents).order()}function v2e(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}function T_t(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}function C_t(){var e=new Array(this.size()),t=-1;return this.each(function(){e[++t]=this}),e}function A_t(){for(var e=this._groups,t=0,r=e.length;t<r;++t)for(var n=e[t],i=0,o=n.length;i<o;++i){var a=n[i];if(a)return a}return null}function P_t(){var e=0;return this.each(function(){++e}),e}function I_t(){return!this.node()}function L_t(e){for(var t=this._groups,r=0,n=t.length;r<n;++r)for(var i=t[r],o=0,a=i.length,s;o<a;++o)(s=i[o])&&e.call(s,s.__data__,o,i);return this}function x2e(e){return function(){this.removeAttribute(e)}}function b2e(e){return function(){this.removeAttributeNS(e.space,e.local)}}function w2e(e,t){return function(){this.setAttribute(e,t)}}function S2e(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function M2e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttribute(e):this.setAttribute(e,r)}}function E2e(e,t){return function(){var r=t.apply(this,arguments);r==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,r)}}function k_t(e,t){var r=Ph(e);if(arguments.length<2){var n=this.node();return r.local?n.getAttributeNS(r.space,r.local):n.getAttribute(r)}return this.each((t==null?r.local?b2e:x2e:typeof t=="function"?r.local?E2e:M2e:r.local?S2e:w2e)(r,t))}function hb(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}function T2e(e){return function(){this.style.removeProperty(e)}}function C2e(e,t,r){return function(){this.style.setProperty(e,t,r)}}function A2e(e,t,r){return function(){var n=t.apply(this,arguments);n==null?this.style.removeProperty(e):this.style.setProperty(e,n,r)}}function R_t(e,t,r){return arguments.length>1?this.each((t==null?T2e:typeof t=="function"?A2e:C2e)(e,t,r==null?"":r)):Sp(this.node(),e)}function Sp(e,t){return e.style.getPropertyValue(t)||hb(e).getComputedStyle(e,null).getPropertyValue(t)}function P2e(e){return function(){delete this[e]}}function I2e(e,t){return function(){this[e]=t}}function L2e(e,t){return function(){var r=t.apply(this,arguments);r==null?delete this[e]:this[e]=r}}function N_t(e,t){return arguments.length>1?this.each((t==null?P2e:typeof t=="function"?L2e:I2e)(e,t)):this.node()[e]}function D_t(e){return e.trim().split(/^|\s+/)}function JW(e){return e.classList||new O_t(e)}function O_t(e){this._node=e,this._names=D_t(e.getAttribute("class")||"")}O_t.prototype={add:function(e){var t=this._names.indexOf(e);t<0&&(this._names.push(e),this._node.setAttribute("class",this._names.join(" ")))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(e){return this._names.indexOf(e)>=0}};function z_t(e,t){for(var r=JW(e),n=-1,i=t.length;++n<i;)r.add(t[n])}function F_t(e,t){for(var r=JW(e),n=-1,i=t.length;++n<i;)r.remove(t[n])}function k2e(e){return function(){z_t(this,e)}}function R2e(e){return function(){F_t(this,e)}}function N2e(e,t){return function(){(t.apply(this,arguments)?z_t:F_t)(this,e)}}function B_t(e,t){var r=D_t(e+"");if(arguments.length<2){for(var n=JW(this.node()),i=-1,o=r.length;++i<o;)if(!n.contains(r[i]))return!1;return!0}return this.each((typeof t=="function"?N2e:t?k2e:R2e)(r,t))}function D2e(){this.textContent=""}function O2e(e){return function(){this.textContent=e}}function z2e(e){return function(){var t=e.apply(this,arguments);this.textContent=t==null?"":t}}function H_t(e){return arguments.length?this.each(e==null?D2e:(typeof e=="function"?z2e:O2e)(e)):this.node().textContent}function F2e(){this.innerHTML=""}function B2e(e){return function(){this.innerHTML=e}}function H2e(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t==null?"":t}}function V_t(e){return arguments.length?this.each(e==null?F2e:(typeof e=="function"?H2e:B2e)(e)):this.node().innerHTML}function V2e(){this.nextSibling&&this.parentNode.appendChild(this)}function U_t(){return this.each(V2e)}function U2e(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function q_t(){return this.each(U2e)}function G_t(e){var t=typeof e=="function"?e:Rm(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}function q2e(){return null}function W_t(e,t){var r=typeof e=="function"?e:Rm(e),n=t==null?q2e:typeof t=="function"?t:Nm(t);return this.select(function(){return this.insertBefore(r.apply(this,arguments),n.apply(this,arguments)||null)})}function G2e(){var e=this.parentNode;e&&e.removeChild(this)}function Y_t(){return this.each(G2e)}function W2e(){var e=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function Y2e(){var e=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function j_t(e){return this.select(e?Y2e:W2e)}function X_t(e){return arguments.length?this.property("__data__",e):this.node().__data__}var K_t={},qt=null;typeof document!="undefined"&&($_t=document.documentElement,"onmouseenter"in $_t||(K_t={mouseenter:"mouseover",mouseleave:"mouseout"}));var $_t;function j2e(e,t,r){return e=Z_t(e,t,r),function(n){var i=n.relatedTarget;(!i||i!==this&&!(i.compareDocumentPosition(this)&8))&&e.call(this,n)}}function Z_t(e,t,r){return function(n){var i=qt;qt=n;try{e.call(this,this.__data__,t,r)}finally{qt=i}}}function X2e(e){return e.trim().split(/^|\s+/).map(function(t){var r="",n=t.indexOf(".");return n>=0&&(r=t.slice(n+1),t=t.slice(0,n)),{type:t,name:r}})}function $2e(e){return function(){var t=this.__on;if(!!t){for(var r=0,n=-1,i=t.length,o;r<i;++r)o=t[r],(!e.type||o.type===e.type)&&o.name===e.name?this.removeEventListener(o.type,o.listener,o.capture):t[++n]=o;++n?t.length=n:delete this.__on}}}function K2e(e,t,r){var n=K_t.hasOwnProperty(e.type)?j2e:Z_t;return function(i,o,a){var s=this.__on,l,c=n(t,o,a);if(s){for(var u=0,h=s.length;u<h;++u)if((l=s[u]).type===e.type&&l.name===e.name){this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=r),l.value=t;return}}this.addEventListener(e.type,c,r),l={type:e.type,name:e.name,value:t,listener:c,capture:r},s?s.push(l):this.__on=[l]}}function J_t(e,t,r){var n=X2e(e+""),i,o=n.length,a;if(arguments.length<2){var s=this.node().__on;if(s){for(var l=0,c=s.length,u;l<c;++l)for(i=0,u=s[l];i<o;++i)if((a=n[i]).type===u.type&&a.name===u.name)return u.value}return}for(s=t?K2e:$2e,r==null&&(r=!1),i=0;i<o;++i)this.each(s(n[i],t,r));return this}function Mp(e,t,r,n){var i=qt;e.sourceEvent=qt,qt=e;try{return t.apply(r,n)}finally{qt=i}}function Q_t(e,t,r){var n=hb(e),i=n.CustomEvent;typeof i=="function"?i=new i(t,r):(i=n.document.createEvent("Event"),r?(i.initEvent(t,r.bubbles,r.cancelable),i.detail=r.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function Z2e(e,t){return function(){return Q_t(this,e,t)}}function J2e(e,t){return function(){return Q_t(this,e,t.apply(this,arguments))}}function tyt(e,t){return this.each((typeof t=="function"?J2e:Z2e)(e,t))}var ME=[null];function Dn(e,t){this._groups=e,this._parents=t}function eyt(){return new Dn([[document.documentElement]],ME)}Dn.prototype=eyt.prototype={constructor:Dn,select:d_t,selectAll:m_t,filter:g_t,data:x_t,enter:__t,exit:b_t,join:w_t,merge:S_t,order:M_t,sort:E_t,call:T_t,nodes:C_t,node:A_t,size:P_t,empty:I_t,each:L_t,attr:k_t,style:R_t,property:N_t,classed:B_t,text:H_t,html:V_t,raise:U_t,lower:q_t,append:G_t,insert:W_t,remove:Y_t,clone:j_t,datum:X_t,on:J_t,dispatch:tyt};var Ih=eyt;function Ht(e){return typeof e=="string"?new Dn([[document.querySelector(e)]],[document.documentElement]):new Dn([[e]],ME)}function ryt(e){return Ht(Rm(e).call(document.documentElement))}var Q2e=0;function tL(){return new QW}function QW(){this._="@"+(++Q2e).toString(36)}QW.prototype=tL.prototype={constructor:QW,get:function(e){for(var t=this._;!(t in e);)if(!(e=e.parentNode))return;return e[t]},set:function(e,t){return e[this._]=t},remove:function(e){return this._ in e&&delete e[this._]},toString:function(){return this._}};function fb(){for(var e=qt,t;t=e.sourceEvent;)e=t;return e}function Dm(e,t){var r=e.ownerSVGElement||e;if(r.createSVGPoint){var n=r.createSVGPoint();return n.x=t.clientX,n.y=t.clientY,n=n.matrixTransform(e.getScreenCTM().inverse()),[n.x,n.y]}var i=e.getBoundingClientRect();return[t.clientX-i.left-e.clientLeft,t.clientY-i.top-e.clientTop]}function zo(e){var t=fb();return t.changedTouches&&(t=t.changedTouches[0]),Dm(e,t)}function Ep(e){return typeof e=="string"?new Dn([document.querySelectorAll(e)],[document.documentElement]):new Dn([e==null?[]:e],ME)}function Tp(e,t,r){arguments.length<3&&(r=t,t=fb().changedTouches);for(var n=0,i=t?t.length:0,o;n<i;++n)if((o=t[n]).identifier===r)return Dm(e,o);return null}function nyt(e,t){t==null&&(t=fb().touches);for(var r=0,n=t?t.length:0,i=new Array(n);r<n;++r)i[r]=Dm(e,t[r]);return i}function eL(){qt.stopImmediatePropagation()}function Om(){qt.preventDefault(),qt.stopImmediatePropagation()}function zm(e){var t=e.document.documentElement,r=Ht(e).on("dragstart.drag",Om,!0);"onselectstart"in t?r.on("selectstart.drag",Om,!0):(t.__noselect=t.style.MozUserSelect,t.style.MozUserSelect="none")}function Fm(e,t){var r=e.document.documentElement,n=Ht(e).on("dragstart.drag",null);t&&(n.on("click.drag",Om,!0),setTimeout(function(){n.on("click.drag",null)},0)),"onselectstart"in r?n.on("selectstart.drag",null):(r.style.MozUserSelect=r.__noselect,delete r.__noselect)}function EE(e){return function(){return e}}function TE(e,t,r,n,i,o,a,s,l,c){this.target=e,this.type=t,this.subject=r,this.identifier=n,this.active=i,this.x=o,this.y=a,this.dx=s,this.dy=l,this._=c}TE.prototype.on=function(){var e=this._.on.apply(this._,arguments);return e===this._?this:e};function twe(){return!qt.ctrlKey&&!qt.button}function ewe(){return this.parentNode}function rwe(e){return e==null?{x:qt.x,y:qt.y}:e}function nwe(){return navigator.maxTouchPoints||"ontouchstart"in this}function pb(){var e=twe,t=ewe,r=rwe,n=nwe,i={},o=vs("start","drag","end"),a=0,s,l,c,u,h=0;function f(S){S.on("mousedown.drag",p).filter(n).on("touchstart.drag",_).on("touchmove.drag",y).on("touchend.drag touchcancel.drag",x).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function p(){if(!(u||!e.apply(this,arguments))){var S=b("mouse",t.apply(this,arguments),zo,this,arguments);!S||(Ht(qt.view).on("mousemove.drag",d,!0).on("mouseup.drag",g,!0),zm(qt.view),eL(),c=!1,s=qt.clientX,l=qt.clientY,S("start"))}}function d(){if(Om(),!c){var S=qt.clientX-s,C=qt.clientY-l;c=S*S+C*C>h}i.mouse("drag")}function g(){Ht(qt.view).on("mousemove.drag mouseup.drag",null),Fm(qt.view,c),Om(),i.mouse("end")}function _(){if(!!e.apply(this,arguments)){var S=qt.changedTouches,C=t.apply(this,arguments),P=S.length,k,O;for(k=0;k<P;++k)(O=b(S[k].identifier,C,Tp,this,arguments))&&(eL(),O("start"))}}function y(){var S=qt.changedTouches,C=S.length,P,k;for(P=0;P<C;++P)(k=i[S[P].identifier])&&(Om(),k("drag"))}function x(){var S=qt.changedTouches,C=S.length,P,k;for(u&&clearTimeout(u),u=setTimeout(function(){u=null},500),P=0;P<C;++P)(k=i[S[P].identifier])&&(eL(),k("end"))}function b(S,C,P,k,O){var D=P(C,S),B,I,L,R=o.copy();if(!!Mp(new TE(f,"beforestart",B,S,a,D[0],D[1],0,0,R),function(){return(qt.subject=B=r.apply(k,O))==null?!1:(I=B.x-D[0]||0,L=B.y-D[1]||0,!0)}))return function F(z){var U=D,W;switch(z){case"start":i[S]=F,W=a++;break;case"end":delete i[S],--a;case"drag":D=P(C,S),W=a;break}Mp(new TE(f,z,B,S,W,D[0]+I,D[1]+L,D[0]-U[0],D[1]-U[1],R),R.apply,R,[z,k,O])}}return f.filter=function(S){return arguments.length?(e=typeof S=="function"?S:EE(!!S),f):e},f.container=function(S){return arguments.length?(t=typeof S=="function"?S:EE(S),f):t},f.subject=function(S){return arguments.length?(r=typeof S=="function"?S:EE(S),f):r},f.touchable=function(S){return arguments.length?(n=typeof S=="function"?S:EE(!!S),f):n},f.on=function(){var S=o.on.apply(o,arguments);return S===o?f:S},f.clickDistance=function(S){return arguments.length?(h=(S=+S)*S,f):Math.sqrt(h)},f}function Cp(e,t,r){e.prototype=t.prototype=r,r.constructor=e}function Bm(e,t){var r=Object.create(e.prototype);for(var n in t)r[n]=t[n];return r}function Rh(){}var Hm=.7,b_=1/Hm,db="\\s*([+-]?\\d+)\\s*",CE="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",kh="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",iwe=/^#([0-9a-f]{3,8})$/,owe=new RegExp("^rgb\\("+[db,db,db]+"\\)$"),awe=new RegExp("^rgb\\("+[kh,kh,kh]+"\\)$"),swe=new RegExp("^rgba\\("+[db,db,db,CE]+"\\)$"),lwe=new RegExp("^rgba\\("+[kh,kh,kh,CE]+"\\)$"),cwe=new RegExp("^hsl\\("+[CE,kh,kh]+"\\)$"),uwe=new RegExp("^hsla\\("+[CE,kh,kh,CE]+"\\)$"),iyt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};Cp(Rh,rc,{copy:function(e){return Object.assign(new this.constructor,this,e)},displayable:function(){return this.rgb().displayable()},hex:oyt,formatHex:oyt,formatHsl:hwe,formatRgb:ayt,toString:ayt});function oyt(){return this.rgb().formatHex()}function hwe(){return hyt(this).formatHsl()}function ayt(){return this.rgb().formatRgb()}function rc(e){var t,r;return e=(e+"").trim().toLowerCase(),(t=iwe.exec(e))?(r=t[1].length,t=parseInt(t[1],16),r===6?syt(t):r===3?new Ki(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):r===8?rL(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):r===4?rL(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=owe.exec(e))?new Ki(t[1],t[2],t[3],1):(t=awe.exec(e))?new Ki(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=swe.exec(e))?rL(t[1],t[2],t[3],t[4]):(t=lwe.exec(e))?rL(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=cwe.exec(e))?uyt(t[1],t[2]/100,t[3]/100,1):(t=uwe.exec(e))?uyt(t[1],t[2]/100,t[3]/100,t[4]):iyt.hasOwnProperty(e)?syt(iyt[e]):e==="transparent"?new Ki(NaN,NaN,NaN,0):null}function syt(e){return new Ki(e>>16&255,e>>8&255,e&255,1)}function rL(e,t,r,n){return n<=0&&(e=t=r=NaN),new Ki(e,t,r,n)}function AE(e){return e instanceof Rh||(e=rc(e)),e?(e=e.rgb(),new Ki(e.r,e.g,e.b,e.opacity)):new Ki}function cu(e,t,r,n){return arguments.length===1?AE(e):new Ki(e,t,r,n==null?1:n)}function Ki(e,t,r,n){this.r=+e,this.g=+t,this.b=+r,this.opacity=+n}Cp(Ki,cu,Bm(Rh,{brighter:function(e){return e=e==null?b_:Math.pow(b_,e),new Ki(this.r*e,this.g*e,this.b*e,this.opacity)},darker:function(e){return e=e==null?Hm:Math.pow(Hm,e),new Ki(this.r*e,this.g*e,this.b*e,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:lyt,formatHex:lyt,formatRgb:cyt,toString:cyt}));function lyt(){return"#"+tY(this.r)+tY(this.g)+tY(this.b)}function cyt(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(e===1?")":", "+e+")")}function tY(e){return e=Math.max(0,Math.min(255,Math.round(e)||0)),(e<16?"0":"")+e.toString(16)}function uyt(e,t,r,n){return n<=0?e=t=r=NaN:r<=0||r>=1?e=t=NaN:t<=0&&(e=NaN),new Lh(e,t,r,n)}function hyt(e){if(e instanceof Lh)return new Lh(e.h,e.s,e.l,e.opacity);if(e instanceof Rh||(e=rc(e)),!e)return new Lh;if(e instanceof Lh)return e;e=e.rgb();var t=e.r/255,r=e.g/255,n=e.b/255,i=Math.min(t,r,n),o=Math.max(t,r,n),a=NaN,s=o-i,l=(o+i)/2;return s?(t===o?a=(r-n)/s+(r<n)*6:r===o?a=(n-t)/s+2:a=(t-r)/s+4,s/=l<.5?o+i:2-o-i,a*=60):s=l>0&&l<1?0:a,new Lh(a,s,l,e.opacity)}function Vm(e,t,r,n){return arguments.length===1?hyt(e):new Lh(e,t,r,n==null?1:n)}function Lh(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}Cp(Lh,Vm,Bm(Rh,{brighter:function(e){return e=e==null?b_:Math.pow(b_,e),new Lh(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Hm:Math.pow(Hm,e),new Lh(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*t,i=2*r-n;return new Ki(eY(e>=240?e-240:e+120,i,n),eY(e,i,n),eY(e<120?e+240:e-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var e=this.opacity;return e=isNaN(e)?1:Math.max(0,Math.min(1,e)),(e===1?"hsl(":"hsla(")+(this.h||0)+", "+(this.s||0)*100+"%, "+(this.l||0)*100+"%"+(e===1?")":", "+e+")")}}));function eY(e,t,r){return(e<60?t+(r-t)*e/60:e<180?r:e<240?t+(r-t)*(240-e)/60:t)*255}var nL=Math.PI/180,iL=180/Math.PI;var oL=18,fyt=.96422,pyt=1,dyt=.82521,myt=4/29,mb=6/29,gyt=3*mb*mb,fwe=mb*mb*mb;function _yt(e){if(e instanceof uu)return new uu(e.l,e.a,e.b,e.opacity);if(e instanceof Nh)return byt(e);e instanceof Ki||(e=AE(e));var t=oY(e.r),r=oY(e.g),n=oY(e.b),i=rY((.2225045*t+.7168786*r+.0606169*n)/pyt),o,a;return t===r&&r===n?o=a=i:(o=rY((.4360747*t+.3850649*r+.1430804*n)/fyt),a=rY((.0139322*t+.0971045*r+.7141733*n)/dyt)),new uu(116*i-16,500*(o-i),200*(i-a),e.opacity)}function yyt(e,t){return new uu(e,0,0,t==null?1:t)}function w_(e,t,r,n){return arguments.length===1?_yt(e):new uu(e,t,r,n==null?1:n)}function uu(e,t,r,n){this.l=+e,this.a=+t,this.b=+r,this.opacity=+n}Cp(uu,w_,Bm(Rh,{brighter:function(e){return new uu(this.l+oL*(e==null?1:e),this.a,this.b,this.opacity)},darker:function(e){return new uu(this.l-oL*(e==null?1:e),this.a,this.b,this.opacity)},rgb:function(){var e=(this.l+16)/116,t=isNaN(this.a)?e:e+this.a/500,r=isNaN(this.b)?e:e-this.b/200;return t=fyt*nY(t),e=pyt*nY(e),r=dyt*nY(r),new Ki(iY(3.1338561*t-1.6168667*e-.4906146*r),iY(-.9787684*t+1.9161415*e+.033454*r),iY(.0719453*t-.2289914*e+1.4052427*r),this.opacity)}}));function rY(e){return e>fwe?Math.pow(e,1/3):e/gyt+myt}function nY(e){return e>mb?e*e*e:gyt*(e-myt)}function iY(e){return 255*(e<=.0031308?12.92*e:1.055*Math.pow(e,1/2.4)-.055)}function oY(e){return(e/=255)<=.04045?e/12.92:Math.pow((e+.055)/1.055,2.4)}function vyt(e){if(e instanceof Nh)return new Nh(e.h,e.c,e.l,e.opacity);if(e instanceof uu||(e=_yt(e)),e.a===0&&e.b===0)return new Nh(NaN,0<e.l&&e.l<100?0:NaN,e.l,e.opacity);var t=Math.atan2(e.b,e.a)*iL;return new Nh(t<0?t+360:t,Math.sqrt(e.a*e.a+e.b*e.b),e.l,e.opacity)}function xyt(e,t,r,n){return arguments.length===1?vyt(e):new Nh(r,t,e,n==null?1:n)}function gb(e,t,r,n){return arguments.length===1?vyt(e):new Nh(e,t,r,n==null?1:n)}function Nh(e,t,r,n){this.h=+e,this.c=+t,this.l=+r,this.opacity=+n}function byt(e){if(isNaN(e.h))return new uu(e.l,0,0,e.opacity);var t=e.h*nL;return new uu(e.l,Math.cos(t)*e.c,Math.sin(t)*e.c,e.opacity)}Cp(Nh,gb,Bm(Rh,{brighter:function(e){return new Nh(this.h,this.c,this.l+oL*(e==null?1:e),this.opacity)},darker:function(e){return new Nh(this.h,this.c,this.l-oL*(e==null?1:e),this.opacity)},rgb:function(){return byt(this).rgb()}}));var Eyt=-.14861,aY=1.78277,sY=-.29227,aL=-.90649,PE=1.97294,wyt=PE*aL,Syt=PE*aY,Myt=aY*sY-aL*Eyt;function pwe(e){if(e instanceof S_)return new S_(e.h,e.s,e.l,e.opacity);e instanceof Ki||(e=AE(e));var t=e.r/255,r=e.g/255,n=e.b/255,i=(Myt*n+wyt*t-Syt*r)/(Myt+wyt-Syt),o=n-i,a=(PE*(r-i)-sY*o)/aL,s=Math.sqrt(a*a+o*o)/(PE*i*(1-i)),l=s?Math.atan2(a,o)*iL-120:NaN;return new S_(l<0?l+360:l,s,i,e.opacity)}function la(e,t,r,n){return arguments.length===1?pwe(e):new S_(e,t,r,n==null?1:n)}function S_(e,t,r,n){this.h=+e,this.s=+t,this.l=+r,this.opacity=+n}Cp(S_,la,Bm(Rh,{brighter:function(e){return e=e==null?b_:Math.pow(b_,e),new S_(this.h,this.s,this.l*e,this.opacity)},darker:function(e){return e=e==null?Hm:Math.pow(Hm,e),new S_(this.h,this.s,this.l*e,this.opacity)},rgb:function(){var e=isNaN(this.h)?0:(this.h+120)*nL,t=+this.l,r=isNaN(this.s)?0:this.s*t*(1-t),n=Math.cos(e),i=Math.sin(e);return new Ki(255*(t+r*(Eyt*n+aY*i)),255*(t+r*(sY*n+aL*i)),255*(t+r*(PE*n)),this.opacity)}}));function lY(e,t,r,n,i){var o=e*e,a=o*e;return((1-3*e+3*o-a)*t+(4-6*o+3*a)*r+(1+3*e+3*o-3*a)*n+a*i)/6}function sL(e){var t=e.length-1;return function(r){var n=r<=0?r=0:r>=1?(r=1,t-1):Math.floor(r*t),i=e[n],o=e[n+1],a=n>0?e[n-1]:2*i-o,s=n<t-1?e[n+2]:2*o-i;return lY((r-n/t)*t,a,i,o,s)}}function lL(e){var t=e.length;return function(r){var n=Math.floor(((r%=1)<0?++r:r)*t),i=e[(n+t-1)%t],o=e[n%t],a=e[(n+1)%t],s=e[(n+2)%t];return lY((r-n/t)*t,i,o,a,s)}}function _b(e){return function(){return e}}function Tyt(e,t){return function(r){return e+r*t}}function dwe(e,t,r){return e=Math.pow(e,r),t=Math.pow(t,r)-e,r=1/r,function(n){return Math.pow(e+n*t,r)}}function Um(e,t){var r=t-e;return r?Tyt(e,r>180||r<-180?r-360*Math.round(r/360):r):_b(isNaN(e)?t:e)}function Cyt(e){return(e=+e)==1?Zn:function(t,r){return r-t?dwe(t,r,e):_b(isNaN(t)?r:t)}}function Zn(e,t){var r=t-e;return r?Tyt(e,r):_b(isNaN(e)?t:e)}var qm=function e(t){var r=Cyt(t);function n(i,o){var a=r((i=cu(i)).r,(o=cu(o)).r),s=r(i.g,o.g),l=r(i.b,o.b),c=Zn(i.opacity,o.opacity);return function(u){return i.r=a(u),i.g=s(u),i.b=l(u),i.opacity=c(u),i+""}}return n.gamma=e,n}(1);function Ayt(e){return function(t){var r=t.length,n=new Array(r),i=new Array(r),o=new Array(r),a,s;for(a=0;a<r;++a)s=cu(t[a]),n[a]=s.r||0,i[a]=s.g||0,o[a]=s.b||0;return n=e(n),i=e(i),o=e(o),s.opacity=1,function(l){return s.r=n(l),s.g=i(l),s.b=o(l),s+""}}}var cL=Ayt(sL),Pyt=Ayt(lL);function yb(e,t){t||(t=[]);var r=e?Math.min(t.length,e.length):0,n=t.slice(),i;return function(o){for(i=0;i<r;++i)n[i]=e[i]*(1-o)+t[i]*o;return n}}function uL(e){return ArrayBuffer.isView(e)&&!(e instanceof DataView)}function Iyt(e,t){return(uL(t)?yb:cY)(e,t)}function cY(e,t){var r=t?t.length:0,n=e?Math.min(r,e.length):0,i=new Array(n),o=new Array(r),a;for(a=0;a<n;++a)i[a]=nc(e[a],t[a]);for(;a<r;++a)o[a]=t[a];return function(s){for(a=0;a<n;++a)o[a]=i[a](s);return o}}function hL(e,t){var r=new Date;return e=+e,t=+t,function(n){return r.setTime(e*(1-n)+t*n),r}}function zi(e,t){return e=+e,t=+t,function(r){return e*(1-r)+t*r}}function fL(e,t){var r={},n={},i;(e===null||typeof e!="object")&&(e={}),(t===null||typeof t!="object")&&(t={});for(i in t)i in e?r[i]=nc(e[i],t[i]):n[i]=t[i];return function(o){for(i in r)n[i]=r[i](o);return n}}var hY=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,uY=new RegExp(hY.source,"g");function mwe(e){return function(){return e}}function gwe(e){return function(t){return e(t)+""}}function vb(e,t){var r=hY.lastIndex=uY.lastIndex=0,n,i,o,a=-1,s=[],l=[];for(e=e+"",t=t+"";(n=hY.exec(e))&&(i=uY.exec(t));)(o=i.index)>r&&(o=t.slice(r,o),s[a]?s[a]+=o:s[++a]=o),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:zi(n,i)})),r=uY.lastIndex;return r<t.length&&(o=t.slice(r),s[a]?s[a]+=o:s[++a]=o),s.length<2?l[0]?gwe(l[0].x):mwe(t):(t=l.length,function(c){for(var u=0,h;u<t;++u)s[(h=l[u]).i]=h.x(c);return s.join("")})}function nc(e,t){var r=typeof t,n;return t==null||r==="boolean"?_b(t):(r==="number"?zi:r==="string"?(n=rc(t))?(t=n,qm):vb:t instanceof rc?qm:t instanceof Date?hL:uL(t)?yb:Array.isArray(t)?cY:typeof t.valueOf!="function"&&typeof t.toString!="function"||isNaN(t)?fL:zi)(e,t)}function Lyt(e){var t=e.length;return function(r){return e[Math.max(0,Math.min(t-1,Math.floor(r*t)))]}}function kyt(e,t){var r=Um(+e,+t);return function(n){var i=r(n);return i-360*Math.floor(i/360)}}function pL(e,t){return e=+e,t=+t,function(r){return Math.round(e*(1-r)+t*r)}}var Ryt=180/Math.PI,dL={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1};function fY(e,t,r,n,i,o){var a,s,l;return(a=Math.sqrt(e*e+t*t))&&(e/=a,t/=a),(l=e*r+t*n)&&(r-=e*l,n-=t*l),(s=Math.sqrt(r*r+n*n))&&(r/=s,n/=s,l/=s),e*n<t*r&&(e=-e,t=-t,l=-l,a=-a),{translateX:i,translateY:o,rotate:Math.atan2(t,e)*Ryt,skewX:Math.atan(l)*Ryt,scaleX:a,scaleY:s}}var IE,pY,Nyt,mL;function Dyt(e){return e==="none"?dL:(IE||(IE=document.createElement("DIV"),pY=document.documentElement,Nyt=document.defaultView),IE.style.transform=e,e=Nyt.getComputedStyle(pY.appendChild(IE),null).getPropertyValue("transform"),pY.removeChild(IE),e=e.slice(7,-1).split(","),fY(+e[0],+e[1],+e[2],+e[3],+e[4],+e[5]))}function Oyt(e){return e==null?dL:(mL||(mL=document.createElementNS("http://www.w3.org/2000/svg","g")),mL.setAttribute("transform",e),(e=mL.transform.baseVal.consolidate())?(e=e.matrix,fY(e.a,e.b,e.c,e.d,e.e,e.f)):dL)}function zyt(e,t,r,n){function i(c){return c.length?c.pop()+" ":""}function o(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push("translate(",null,t,null,r);d.push({i:g-4,x:zi(c,h)},{i:g-2,x:zi(u,f)})}else(h||f)&&p.push("translate("+h+t+f+r)}function a(c,u,h,f){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),f.push({i:h.push(i(h)+"rotate(",null,n)-2,x:zi(c,u)})):u&&h.push(i(h)+"rotate("+u+n)}function s(c,u,h,f){c!==u?f.push({i:h.push(i(h)+"skewX(",null,n)-2,x:zi(c,u)}):u&&h.push(i(h)+"skewX("+u+n)}function l(c,u,h,f,p,d){if(c!==h||u!==f){var g=p.push(i(p)+"scale(",null,",",null,")");d.push({i:g-4,x:zi(c,h)},{i:g-2,x:zi(u,f)})}else(h!==1||f!==1)&&p.push(i(p)+"scale("+h+","+f+")")}return function(c,u){var h=[],f=[];return c=e(c),u=e(u),o(c.translateX,c.translateY,u.translateX,u.translateY,h,f),a(c.rotate,u.rotate,h,f),s(c.skewX,u.skewX,h,f),l(c.scaleX,c.scaleY,u.scaleX,u.scaleY,h,f),c=u=null,function(p){for(var d=-1,g=f.length,_;++d<g;)h[(_=f[d]).i]=_.x(p);return h.join("")}}}var gL=zyt(Dyt,"px, ","px)","deg)"),_L=zyt(Oyt,", ",")",")");var LE=Math.SQRT2,dY=2,Fyt=4,_we=1e-12;function Byt(e){return((e=Math.exp(e))+1/e)/2}function ywe(e){return((e=Math.exp(e))-1/e)/2}function vwe(e){return((e=Math.exp(2*e))-1)/(e+1)}function yL(e,t){var r=e[0],n=e[1],i=e[2],o=t[0],a=t[1],s=t[2],l=o-r,c=a-n,u=l*l+c*c,h,f;if(u<_we)f=Math.log(s/i)/LE,h=function(x){return[r+x*l,n+x*c,i*Math.exp(LE*x*f)]};else{var p=Math.sqrt(u),d=(s*s-i*i+Fyt*u)/(2*i*dY*p),g=(s*s-i*i-Fyt*u)/(2*s*dY*p),_=Math.log(Math.sqrt(d*d+1)-d),y=Math.log(Math.sqrt(g*g+1)-g);f=(y-_)/LE,h=function(x){var b=x*f,S=Byt(_),C=i/(dY*p)*(S*vwe(LE*b+_)-ywe(_));return[r+C*l,n+C*c,i*S/Byt(LE*b+_)]}}return h.duration=f*1e3,h}function Hyt(e){return function(t,r){var n=e((t=Vm(t)).h,(r=Vm(r)).h),i=Zn(t.s,r.s),o=Zn(t.l,r.l),a=Zn(t.opacity,r.opacity);return function(s){return t.h=n(s),t.s=i(s),t.l=o(s),t.opacity=a(s),t+""}}}var Vyt=Hyt(Um),Uyt=Hyt(Zn);function M_(e,t){var r=Zn((e=w_(e)).l,(t=w_(t)).l),n=Zn(e.a,t.a),i=Zn(e.b,t.b),o=Zn(e.opacity,t.opacity);return function(a){return e.l=r(a),e.a=n(a),e.b=i(a),e.opacity=o(a),e+""}}function qyt(e){return function(t,r){var n=e((t=gb(t)).h,(r=gb(r)).h),i=Zn(t.c,r.c),o=Zn(t.l,r.l),a=Zn(t.opacity,r.opacity);return function(s){return t.h=n(s),t.c=i(s),t.l=o(s),t.opacity=a(s),t+""}}}var Gyt=qyt(Um),Wyt=qyt(Zn);function Yyt(e){return function t(r){r=+r;function n(i,o){var a=e((i=la(i)).h,(o=la(o)).h),s=Zn(i.s,o.s),l=Zn(i.l,o.l),c=Zn(i.opacity,o.opacity);return function(u){return i.h=a(u),i.s=s(u),i.l=l(Math.pow(u,r)),i.opacity=c(u),i+""}}return n.gamma=t,n}(1)}var jyt=Yyt(Um),E_=Yyt(Zn);function mY(e,t){for(var r=0,n=t.length-1,i=t[0],o=new Array(n<0?0:n);r<n;)o[r]=e(i,i=t[++r]);return function(a){var s=Math.max(0,Math.min(n-1,Math.floor(a*=n)));return o[s](a-s)}}function Xyt(e,t){for(var r=new Array(t),n=0;n<t;++n)r[n]=e(n/(t-1));return r}km();var xb=0,RE=0,kE=0,Kyt=1e3,vL,NE,xL=0,T_=0,bL=0,DE=typeof performance=="object"&&performance.now?performance:Date,Zyt=typeof window=="object"&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};function Ap(){return T_||(Zyt(xwe),T_=DE.now()+bL)}function xwe(){T_=0}function C_(){this._call=this._time=this._next=null}C_.prototype=A_.prototype={constructor:C_,restart:function(e,t,r){if(typeof e!="function")throw new TypeError("callback is not a function");r=(r==null?Ap():+r)+(t==null?0:+t),!this._next&&NE!==this&&(NE?NE._next=this:vL=this,NE=this),this._call=e,this._time=r,gY()},stop:function(){this._call&&(this._call=null,this._time=1/0,gY())}};function A_(e,t,r){var n=new C_;return n.restart(e,t,r),n}function _Y(){Ap(),++xb;for(var e=vL,t;e;)(t=T_-e._time)>=0&&e._call.call(null,t),e=e._next;--xb}function $yt(){T_=(xL=DE.now())+bL,xb=RE=0;try{_Y()}finally{xb=0,wwe(),T_=0}}function bwe(){var e=DE.now(),t=e-xL;t>Kyt&&(bL-=t,xL=e)}function wwe(){for(var e,t=vL,r,n=1/0;t;)t._call?(n>t._time&&(n=t._time),e=t,t=t._next):(r=t._next,t._next=null,t=e?e._next=r:vL=r);NE=e,gY(n)}function gY(e){if(!xb){RE&&(RE=clearTimeout(RE));var t=e-T_;t>24?(e<1/0&&(RE=setTimeout($yt,e-DE.now()-bL)),kE&&(kE=clearInterval(kE))):(kE||(xL=DE.now(),kE=setInterval(bwe,Kyt)),xb=1,Zyt($yt))}}function OE(e,t,r){var n=new C_;return t=t==null?0:+t,n.restart(function(i){n.stop(),e(i+t)},t,r),n}function Jyt(e,t,r){var n=new C_,i=t;return t==null?(n.restart(e,t,r),n):(t=+t,r=r==null?Ap():+r,n.restart(function o(a){a+=i,n.restart(o,i+=t,r),e(a)},t,r),n)}var Swe=vs("start","end","cancel","interrupt"),Mwe=[],t1t=0,SL=1,ML=2,wL=3,Qyt=4,EL=5,zE=6;function Gm(e,t,r,n,i,o){var a=e.__transition;if(!a)e.__transition={};else if(r in a)return;Ewe(e,r,{name:t,index:n,group:i,on:Swe,tween:Mwe,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:t1t})}function FE(e,t){var r=Zi(e,t);if(r.state>t1t)throw new Error("too late; already scheduled");return r}function Oa(e,t){var r=Zi(e,t);if(r.state>wL)throw new Error("too late; already running");return r}function Zi(e,t){var r=e.__transition;if(!r||!(r=r[t]))throw new Error("transition not found");return r}function Ewe(e,t,r){var n=e.__transition,i;n[t]=r,r.timer=A_(o,0,r.time);function o(c){r.state=SL,r.timer.restart(a,r.delay,r.time),r.delay<=c&&a(c-r.delay)}function a(c){var u,h,f,p;if(r.state!==SL)return l();for(u in n)if(p=n[u],p.name===r.name){if(p.state===wL)return OE(a);p.state===Qyt?(p.state=zE,p.timer.stop(),p.on.call("interrupt",e,e.__data__,p.index,p.group),delete n[u]):+u<t&&(p.state=zE,p.timer.stop(),p.on.call("cancel",e,e.__data__,p.index,p.group),delete n[u])}if(OE(function(){r.state===wL&&(r.state=Qyt,r.timer.restart(s,r.delay,r.time),s(c))}),r.state=ML,r.on.call("start",e,e.__data__,r.index,r.group),r.state===ML){for(r.state=wL,i=new Array(f=r.tween.length),u=0,h=-1;u<f;++u)(p=r.tween[u].value.call(e,e.__data__,r.index,r.group))&&(i[++h]=p);i.length=h+1}}function s(c){for(var u=c<r.duration?r.ease.call(null,c/r.duration):(r.timer.restart(l),r.state=EL,1),h=-1,f=i.length;++h<f;)i[h].call(e,u);r.state===EL&&(r.on.call("end",e,e.__data__,r.index,r.group),l())}function l(){r.state=zE,r.timer.stop(),delete n[t];for(var c in n)return;delete e.__transition}}function hu(e,t){var r=e.__transition,n,i,o=!0,a;if(!!r){t=t==null?null:t+"";for(a in r){if((n=r[a]).name!==t){o=!1;continue}i=n.state>ML&&n.state<EL,n.state=zE,n.timer.stop(),n.on.call(i?"interrupt":"cancel",e,e.__data__,n.index,n.group),delete r[a]}o&&delete e.__transition}}function e1t(e){return this.each(function(){hu(this,e)})}function Twe(e,t){var r,n;return function(){var i=Oa(this,e),o=i.tween;if(o!==r){n=r=o;for(var a=0,s=n.length;a<s;++a)if(n[a].name===t){n=n.slice(),n.splice(a,1);break}}i.tween=n}}function Cwe(e,t,r){var n,i;if(typeof r!="function")throw new Error;return function(){var o=Oa(this,e),a=o.tween;if(a!==n){i=(n=a).slice();for(var s={name:t,value:r},l=0,c=i.length;l<c;++l)if(i[l].name===t){i[l]=s;break}l===c&&i.push(s)}o.tween=i}}function r1t(e,t){var r=this._id;if(e+="",arguments.length<2){for(var n=Zi(this.node(),r).tween,i=0,o=n.length,a;i<o;++i)if((a=n[i]).name===e)return a.value;return null}return this.each((t==null?Twe:Cwe)(r,e,t))}function bb(e,t,r){var n=e._id;return e.each(function(){var i=Oa(this,n);(i.value||(i.value={}))[t]=r.apply(this,arguments)}),function(i){return Zi(i,n).value[t]}}function TL(e,t){var r;return(typeof t=="number"?zi:t instanceof rc?qm:(r=rc(t))?(t=r,qm):vb)(e,t)}function Awe(e){return function(){this.removeAttribute(e)}}function Pwe(e){return function(){this.removeAttributeNS(e.space,e.local)}}function Iwe(e,t,r){var n,i=r+"",o;return function(){var a=this.getAttribute(e);return a===i?null:a===n?o:o=t(n=a,r)}}function Lwe(e,t,r){var n,i=r+"",o;return function(){var a=this.getAttributeNS(e.space,e.local);return a===i?null:a===n?o:o=t(n=a,r)}}function kwe(e,t,r){var n,i,o;return function(){var a,s=r(this),l;return s==null?void this.removeAttribute(e):(a=this.getAttribute(e),l=s+"",a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s)))}}function Rwe(e,t,r){var n,i,o;return function(){var a,s=r(this),l;return s==null?void this.removeAttributeNS(e.space,e.local):(a=this.getAttributeNS(e.space,e.local),l=s+"",a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s)))}}function n1t(e,t){var r=Ph(e),n=r==="transform"?_L:TL;return this.attrTween(e,typeof t=="function"?(r.local?Rwe:kwe)(r,n,bb(this,"attr."+e,t)):t==null?(r.local?Pwe:Awe)(r):(r.local?Lwe:Iwe)(r,n,t))}function Nwe(e,t){return function(r){this.setAttribute(e,t.call(this,r))}}function Dwe(e,t){return function(r){this.setAttributeNS(e.space,e.local,t.call(this,r))}}function Owe(e,t){var r,n;function i(){var o=t.apply(this,arguments);return o!==n&&(r=(n=o)&&Dwe(e,o)),r}return i._value=t,i}function zwe(e,t){var r,n;function i(){var o=t.apply(this,arguments);return o!==n&&(r=(n=o)&&Nwe(e,o)),r}return i._value=t,i}function i1t(e,t){var r="attr."+e;if(arguments.length<2)return(r=this.tween(r))&&r._value;if(t==null)return this.tween(r,null);if(typeof t!="function")throw new Error;var n=Ph(e);return this.tween(r,(n.local?Owe:zwe)(n,t))}function Fwe(e,t){return function(){FE(this,e).delay=+t.apply(this,arguments)}}function Bwe(e,t){return t=+t,function(){FE(this,e).delay=t}}function o1t(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?Fwe:Bwe)(t,e)):Zi(this.node(),t).delay}function Hwe(e,t){return function(){Oa(this,e).duration=+t.apply(this,arguments)}}function Vwe(e,t){return t=+t,function(){Oa(this,e).duration=t}}function a1t(e){var t=this._id;return arguments.length?this.each((typeof e=="function"?Hwe:Vwe)(t,e)):Zi(this.node(),t).duration}function Uwe(e,t){if(typeof t!="function")throw new Error;return function(){Oa(this,e).ease=t}}function s1t(e){var t=this._id;return arguments.length?this.each(Uwe(t,e)):Zi(this.node(),t).ease}function l1t(e){typeof e!="function"&&(e=ub(e));for(var t=this._groups,r=t.length,n=new Array(r),i=0;i<r;++i)for(var o=t[i],a=o.length,s=n[i]=[],l,c=0;c<a;++c)(l=o[c])&&e.call(l,l.__data__,c,o)&&s.push(l);return new Fo(n,this._parents,this._name,this._id)}function c1t(e){if(e._id!==this._id)throw new Error;for(var t=this._groups,r=e._groups,n=t.length,i=r.length,o=Math.min(n,i),a=new Array(n),s=0;s<o;++s)for(var l=t[s],c=r[s],u=l.length,h=a[s]=new Array(u),f,p=0;p<u;++p)(f=l[p]||c[p])&&(h[p]=f);for(;s<n;++s)a[s]=t[s];return new Fo(a,this._parents,this._name,this._id)}function qwe(e){return(e+"").trim().split(/^|\s+/).every(function(t){var r=t.indexOf(".");return r>=0&&(t=t.slice(0,r)),!t||t==="start"})}function Gwe(e,t,r){var n,i,o=qwe(t)?FE:Oa;return function(){var a=o(this,e),s=a.on;s!==n&&(i=(n=s).copy()).on(t,r),a.on=i}}function u1t(e,t){var r=this._id;return arguments.length<2?Zi(this.node(),r).on.on(e):this.each(Gwe(r,e,t))}function Wwe(e){return function(){var t=this.parentNode;for(var r in this.__transition)if(+r!==e)return;t&&t.removeChild(this)}}function h1t(){return this.on("end.remove",Wwe(this._id))}function f1t(e){var t=this._name,r=this._id;typeof e!="function"&&(e=Nm(e));for(var n=this._groups,i=n.length,o=new Array(i),a=0;a<i;++a)for(var s=n[a],l=s.length,c=o[a]=new Array(l),u,h,f=0;f<l;++f)(u=s[f])&&(h=e.call(u,u.__data__,f,s))&&("__data__"in u&&(h.__data__=u.__data__),c[f]=h,Gm(c[f],t,r,f,c,Zi(u,r)));return new Fo(o,this._parents,t,r)}function p1t(e){var t=this._name,r=this._id;typeof e!="function"&&(e=cb(e));for(var n=this._groups,i=n.length,o=[],a=[],s=0;s<i;++s)for(var l=n[s],c=l.length,u,h=0;h<c;++h)if(u=l[h]){for(var f=e.call(u,u.__data__,h,l),p,d=Zi(u,r),g=0,_=f.length;g<_;++g)(p=f[g])&&Gm(p,t,r,g,f,d);o.push(f),a.push(u)}return new Fo(o,a,t,r)}var Ywe=Ih.prototype.constructor;function d1t(){return new Ywe(this._groups,this._parents)}function jwe(e,t){var r,n,i;return function(){var o=Sp(this,e),a=(this.style.removeProperty(e),Sp(this,e));return o===a?null:o===r&&a===n?i:i=t(r=o,n=a)}}function m1t(e){return function(){this.style.removeProperty(e)}}function Xwe(e,t,r){var n,i=r+"",o;return function(){var a=Sp(this,e);return a===i?null:a===n?o:o=t(n=a,r)}}function $we(e,t,r){var n,i,o;return function(){var a=Sp(this,e),s=r(this),l=s+"";return s==null&&(l=s=(this.style.removeProperty(e),Sp(this,e))),a===l?null:a===n&&l===i?o:(i=l,o=t(n=a,s))}}function Kwe(e,t){var r,n,i,o="style."+t,a="end."+o,s;return function(){var l=Oa(this,e),c=l.on,u=l.value[o]==null?s||(s=m1t(t)):void 0;(c!==r||i!==u)&&(n=(r=c).copy()).on(a,i=u),l.on=n}}function g1t(e,t,r){var n=(e+="")=="transform"?gL:TL;return t==null?this.styleTween(e,jwe(e,n)).on("end.style."+e,m1t(e)):typeof t=="function"?this.styleTween(e,$we(e,n,bb(this,"style."+e,t))).each(Kwe(this._id,e)):this.styleTween(e,Xwe(e,n,t),r).on("end.style."+e,null)}function Zwe(e,t,r){return function(n){this.style.setProperty(e,t.call(this,n),r)}}function Jwe(e,t,r){var n,i;function o(){var a=t.apply(this,arguments);return a!==i&&(n=(i=a)&&Zwe(e,a,r)),n}return o._value=t,o}function _1t(e,t,r){var n="style."+(e+="");if(arguments.length<2)return(n=this.tween(n))&&n._value;if(t==null)return this.tween(n,null);if(typeof t!="function")throw new Error;return this.tween(n,Jwe(e,t,r==null?"":r))}function Qwe(e){return function(){this.textContent=e}}function tSe(e){return function(){var t=e(this);this.textContent=t==null?"":t}}function y1t(e){return this.tween("text",typeof e=="function"?tSe(bb(this,"text",e)):Qwe(e==null?"":e+""))}function eSe(e){return function(t){this.textContent=e.call(this,t)}}function rSe(e){var t,r;function n(){var i=e.apply(this,arguments);return i!==r&&(t=(r=i)&&eSe(i)),t}return n._value=e,n}function v1t(e){var t="text";if(arguments.length<1)return(t=this.tween(t))&&t._value;if(e==null)return this.tween(t,null);if(typeof e!="function")throw new Error;return this.tween(t,rSe(e))}function x1t(){for(var e=this._name,t=this._id,r=CL(),n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)if(l=a[c]){var u=Zi(l,t);Gm(l,e,r,c,a,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new Fo(n,this._parents,e,r)}function b1t(){var e,t,r=this,n=r._id,i=r.size();return new Promise(function(o,a){var s={value:a},l={value:function(){--i===0&&o()}};r.each(function(){var c=Oa(this,n),u=c.on;u!==e&&(t=(e=u).copy(),t._.cancel.push(s),t._.interrupt.push(s),t._.end.push(l)),c.on=t})})}var nSe=0;function Fo(e,t,r,n){this._groups=e,this._parents=t,this._name=r,this._id=n}function AL(e){return Ih().transition(e)}function CL(){return++nSe}var wb=Ih.prototype;Fo.prototype=AL.prototype={constructor:Fo,select:f1t,selectAll:p1t,filter:l1t,merge:c1t,selection:d1t,transition:x1t,call:wb.call,nodes:wb.nodes,node:wb.node,size:wb.size,empty:wb.empty,each:wb.each,on:u1t,attr:n1t,attrTween:i1t,style:g1t,styleTween:_1t,text:y1t,textTween:v1t,remove:h1t,tween:r1t,delay:o1t,duration:a1t,ease:s1t,end:b1t};I_();var qY={time:null,delay:0,duration:250,ease:xs};function fSe(e,t){for(var r;!(r=e.__transition)||!(r=r[t]);)if(!(e=e.parentNode))return qY.time=Ap(),qY;return r}function D1t(e){var t,r;e instanceof Fo?(t=e._id,e=e._name):(t=CL(),(r=qY).time=Ap(),e=e==null?null:e+"");for(var n=this._groups,i=n.length,o=0;o<i;++o)for(var a=n[o],s=a.length,l,c=0;c<s;++c)(l=a[c])&&Gm(l,e,t,c,a,r||fSe(l,t));return new Fo(n,this._parents,e,t)}Ih.prototype.interrupt=e1t;Ih.prototype.transition=D1t;var pSe=[null];function O1t(e,t){var r=e.__transition,n,i;if(r){t=t==null?null:t+"";for(i in r)if((n=r[i]).state>SL&&n.name===t)return new Fo([[e]],pSe,t,+i)}return null}function zL(e){return function(){return e}}function z1t(e,t,r){this.target=e,this.type=t,this.selection=r}function GY(){qt.stopImmediatePropagation()}function FL(){qt.preventDefault(),qt.stopImmediatePropagation()}var F1t={name:"drag"},WY={name:"space"},Mb={name:"handle"},Eb={name:"center"};function B1t(e){return[+e[0],+e[1]]}function jY(e){return[B1t(e[0]),B1t(e[1])]}function dSe(e){return function(t){return Tp(t,qt.touches,e)}}var BL={name:"x",handles:["w","e"].map(BE),input:function(e,t){return e==null?null:[[+e[0],t[0][1]],[+e[1],t[1][1]]]},output:function(e){return e&&[e[0][0],e[1][0]]}},HL={name:"y",handles:["n","s"].map(BE),input:function(e,t){return e==null?null:[[t[0][0],+e[0]],[t[1][0],+e[1]]]},output:function(e){return e&&[e[0][1],e[1][1]]}},mSe={name:"xy",handles:["n","w","e","s","nw","ne","sw","se"].map(BE),input:function(e){return e==null?null:jY(e)},output:function(e){return e}},Pp={overlay:"crosshair",selection:"move",n:"ns-resize",e:"ew-resize",s:"ns-resize",w:"ew-resize",nw:"nwse-resize",ne:"nesw-resize",se:"nwse-resize",sw:"nesw-resize"},H1t={e:"w",w:"e",nw:"ne",ne:"nw",se:"sw",sw:"se"},V1t={n:"s",s:"n",nw:"sw",ne:"se",se:"ne",sw:"nw"},gSe={overlay:1,selection:1,n:null,e:1,s:null,w:-1,nw:-1,ne:1,se:1,sw:-1},_Se={overlay:1,selection:1,n:-1,e:null,s:1,w:null,nw:-1,ne:-1,se:1,sw:1};function BE(e){return{type:e}}function ySe(){return!qt.ctrlKey&&!qt.button}function vSe(){var e=this.ownerSVGElement||this;return e.hasAttribute("viewBox")?(e=e.viewBox.baseVal,[[e.x,e.y],[e.x+e.width,e.y+e.height]]):[[0,0],[e.width.baseVal.value,e.height.baseVal.value]]}function xSe(){return navigator.maxTouchPoints||"ontouchstart"in this}function YY(e){for(;!e.__brush;)if(!(e=e.parentNode))return;return e.__brush}function bSe(e){return e[0][0]===e[1][0]||e[0][1]===e[1][1]}function VL(e){var t=e.__brush;return t?t.dim.output(t.selection):null}function U1t(){return XY(BL)}function UL(){return XY(HL)}function qL(){return XY(mSe)}function XY(e){var t=vSe,r=ySe,n=xSe,i=!0,o=vs("start","brush","end"),a=6,s;function l(_){var y=_.property("__brush",g).selectAll(".overlay").data([BE("overlay")]);y.enter().append("rect").attr("class","overlay").attr("pointer-events","all").attr("cursor",Pp.overlay).merge(y).each(function(){var b=YY(this).extent;Ht(this).attr("x",b[0][0]).attr("y",b[0][1]).attr("width",b[1][0]-b[0][0]).attr("height",b[1][1]-b[0][1])}),_.selectAll(".selection").data([BE("selection")]).enter().append("rect").attr("class","selection").attr("cursor",Pp.selection).attr("fill","#777").attr("fill-opacity",.3).attr("stroke","#fff").attr("shape-rendering","crispEdges");var x=_.selectAll(".handle").data(e.handles,function(b){return b.type});x.exit().remove(),x.enter().append("rect").attr("class",function(b){return"handle handle--"+b.type}).attr("cursor",function(b){return Pp[b.type]}),_.each(c).attr("fill","none").attr("pointer-events","all").on("mousedown.brush",f).filter(n).on("touchstart.brush",f).on("touchmove.brush",p).on("touchend.brush touchcancel.brush",d).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}l.move=function(_,y){_.selection?_.on("start.brush",function(){u(this,arguments).beforestart().start()}).on("interrupt.brush end.brush",function(){u(this,arguments).end()}).tween("brush",function(){var x=this,b=x.__brush,S=u(x,arguments),C=b.selection,P=e.input(typeof y=="function"?y.apply(this,arguments):y,b.extent),k=nc(C,P);function O(D){b.selection=D===1&&P===null?null:k(D),c.call(x),S.brush()}return C!==null&&P!==null?O:O(1)}):_.each(function(){var x=this,b=arguments,S=x.__brush,C=e.input(typeof y=="function"?y.apply(x,b):y,S.extent),P=u(x,b).beforestart();hu(x),S.selection=C===null?null:C,c.call(x),P.start().brush().end()})},l.clear=function(_){l.move(_,null)};function c(){var _=Ht(this),y=YY(this).selection;y?(_.selectAll(".selection").style("display",null).attr("x",y[0][0]).attr("y",y[0][1]).attr("width",y[1][0]-y[0][0]).attr("height",y[1][1]-y[0][1]),_.selectAll(".handle").style("display",null).attr("x",function(x){return x.type[x.type.length-1]==="e"?y[1][0]-a/2:y[0][0]-a/2}).attr("y",function(x){return x.type[0]==="s"?y[1][1]-a/2:y[0][1]-a/2}).attr("width",function(x){return x.type==="n"||x.type==="s"?y[1][0]-y[0][0]+a:a}).attr("height",function(x){return x.type==="e"||x.type==="w"?y[1][1]-y[0][1]+a:a})):_.selectAll(".selection,.handle").style("display","none").attr("x",null).attr("y",null).attr("width",null).attr("height",null)}function u(_,y,x){var b=_.__brush.emitter;return b&&(!x||!b.clean)?b:new h(_,y,x)}function h(_,y,x){this.that=_,this.args=y,this.state=_.__brush,this.active=0,this.clean=x}h.prototype={beforestart:function(){return++this.active===1&&(this.state.emitter=this,this.starting=!0),this},start:function(){return this.starting?(this.starting=!1,this.emit("start")):this.emit("brush"),this},brush:function(){return this.emit("brush"),this},end:function(){return--this.active===0&&(delete this.state.emitter,this.emit("end")),this},emit:function(_){Mp(new z1t(l,_,e.output(this.state.selection)),o.apply,o,[_,this.that,this.args])}};function f(){if(s&&!qt.touches||!r.apply(this,arguments))return;var _=this,y=qt.target.__data__.type,x=(i&&qt.metaKey?y="overlay":y)==="selection"?F1t:i&&qt.altKey?Eb:Mb,b=e===HL?null:gSe[y],S=e===BL?null:_Se[y],C=YY(_),P=C.extent,k=C.selection,O=P[0][0],D,B,I=P[0][1],L,R,F=P[1][0],z,U,W=P[1][1],Z,rt,ot=0,st=0,St,bt=b&&S&&i&&qt.shiftKey,Mt,lt,Kt=qt.touches?dSe(qt.changedTouches[0].identifier):zo,_t=Kt(_),ct=_t,X=u(_,arguments,!0).beforestart();y==="overlay"?(k&&(St=!0),C.selection=k=[[D=e===HL?O:_t[0],L=e===BL?I:_t[1]],[z=e===HL?F:D,Z=e===BL?W:L]]):(D=k[0][0],L=k[0][1],z=k[1][0],Z=k[1][1]),B=D,R=L,U=z,rt=Z;var et=Ht(_).attr("pointer-events","none"),dt=et.selectAll(".overlay").attr("cursor",Pp[y]);if(qt.touches)X.moved=pt,X.ended=wt;else{var q=Ht(qt.view).on("mousemove.brush",pt,!0).on("mouseup.brush",wt,!0);i&&q.on("keydown.brush",kt,!0).on("keyup.brush",ie,!0),zm(qt.view)}GY(),hu(_),c.call(_),X.start();function pt(){var ee=Kt(_);bt&&!Mt&&!lt&&(Math.abs(ee[0]-ct[0])>Math.abs(ee[1]-ct[1])?lt=!0:Mt=!0),ct=ee,St=!0,FL(),ht()}function ht(){var ee;switch(ot=ct[0]-_t[0],st=ct[1]-_t[1],x){case WY:case F1t:{b&&(ot=Math.max(O-D,Math.min(F-z,ot)),B=D+ot,U=z+ot),S&&(st=Math.max(I-L,Math.min(W-Z,st)),R=L+st,rt=Z+st);break}case Mb:{b<0?(ot=Math.max(O-D,Math.min(F-D,ot)),B=D+ot,U=z):b>0&&(ot=Math.max(O-z,Math.min(F-z,ot)),B=D,U=z+ot),S<0?(st=Math.max(I-L,Math.min(W-L,st)),R=L+st,rt=Z):S>0&&(st=Math.max(I-Z,Math.min(W-Z,st)),R=L,rt=Z+st);break}case Eb:{b&&(B=Math.max(O,Math.min(F,D-ot*b)),U=Math.max(O,Math.min(F,z+ot*b))),S&&(R=Math.max(I,Math.min(W,L-st*S)),rt=Math.max(I,Math.min(W,Z+st*S)));break}}U<B&&(b*=-1,ee=D,D=z,z=ee,ee=B,B=U,U=ee,y in H1t&&dt.attr("cursor",Pp[y=H1t[y]])),rt<R&&(S*=-1,ee=L,L=Z,Z=ee,ee=R,R=rt,rt=ee,y in V1t&&dt.attr("cursor",Pp[y=V1t[y]])),C.selection&&(k=C.selection),Mt&&(B=k[0][0],U=k[1][0]),lt&&(R=k[0][1],rt=k[1][1]),(k[0][0]!==B||k[0][1]!==R||k[1][0]!==U||k[1][1]!==rt)&&(C.selection=[[B,R],[U,rt]],c.call(_),X.brush())}function wt(){if(GY(),qt.touches){if(qt.touches.length)return;s&&clearTimeout(s),s=setTimeout(function(){s=null},500)}else Fm(qt.view,St),q.on("keydown.brush keyup.brush mousemove.brush mouseup.brush",null);et.attr("pointer-events","all"),dt.attr("cursor",Pp.overlay),C.selection&&(k=C.selection),bSe(k)&&(C.selection=null,c.call(_)),X.end()}function kt(){switch(qt.keyCode){case 16:{bt=b&&S;break}case 18:{x===Mb&&(b&&(z=U-ot*b,D=B+ot*b),S&&(Z=rt-st*S,L=R+st*S),x=Eb,ht());break}case 32:{(x===Mb||x===Eb)&&(b<0?z=U-ot:b>0&&(D=B-ot),S<0?Z=rt-st:S>0&&(L=R-st),x=WY,dt.attr("cursor",Pp.selection),ht());break}default:return}FL()}function ie(){switch(qt.keyCode){case 16:{bt&&(Mt=lt=bt=!1,ht());break}case 18:{x===Eb&&(b<0?z=U:b>0&&(D=B),S<0?Z=rt:S>0&&(L=R),x=Mb,ht());break}case 32:{x===WY&&(qt.altKey?(b&&(z=U-ot*b,D=B+ot*b),S&&(Z=rt-st*S,L=R+st*S),x=Eb):(b<0?z=U:b>0&&(D=B),S<0?Z=rt:S>0&&(L=R),x=Mb),dt.attr("cursor",Pp[y]),ht());break}default:return}FL()}}function p(){u(this,arguments).moved()}function d(){u(this,arguments).ended()}function g(){var _=this.__brush||{selection:null};return _.extent=jY(t.apply(this,arguments)),_.dim=e,_}return l.extent=function(_){return arguments.length?(t=typeof _=="function"?_:zL(jY(_)),l):t},l.filter=function(_){return arguments.length?(r=typeof _=="function"?_:zL(!!_),l):r},l.touchable=function(_){return arguments.length?(n=typeof _=="function"?_:zL(!!_),l):n},l.handleSize=function(_){return arguments.length?(a=+_,l):a},l.keyModifiers=function(_){return arguments.length?(i=!!_,l):i},l.on=function(){var _=o.on.apply(o,arguments);return _===o?l:_},l}var $Y=Math.cos,KY=Math.sin,q1t=Math.PI,HE=q1t/2,ZY=q1t*2,JY=Math.max;function wSe(e){return function(t,r){return e(t.source.value+t.target.value,r.source.value+r.target.value)}}function G1t(){var e=0,t=null,r=null,n=null;function i(o){var a=o.length,s=[],l=Ir(a),c=[],u=[],h=u.groups=new Array(a),f=new Array(a*a),p,d,g,_,y,x;for(p=0,y=-1;++y<a;){for(d=0,x=-1;++x<a;)d+=o[y][x];s.push(d),c.push(Ir(a)),p+=d}for(t&&l.sort(function(B,I){return t(s[B],s[I])}),r&&c.forEach(function(B,I){B.sort(function(L,R){return r(o[I][L],o[I][R])})}),p=JY(0,ZY-e*a)/p,_=p?e:ZY/a,d=0,y=-1;++y<a;){for(g=d,x=-1;++x<a;){var b=l[y],S=c[b][x],C=o[b][S],P=d,k=d+=C*p;f[S*a+b]={index:b,subindex:S,startAngle:P,endAngle:k,value:C}}h[b]={index:b,startAngle:g,endAngle:d,value:s[b]},d+=_}for(y=-1;++y<a;)for(x=y-1;++x<a;){var O=f[x*a+y],D=f[y*a+x];(O.value||D.value)&&u.push(O.value<D.value?{source:D,target:O}:{source:O,target:D})}return n?u.sort(n):u}return i.padAngle=function(o){return arguments.length?(e=JY(0,o),i):e},i.sortGroups=function(o){return arguments.length?(t=o,i):t},i.sortSubgroups=function(o){return arguments.length?(r=o,i):r},i.sortChords=function(o){return arguments.length?(o==null?n=null:(n=wSe(o))._=o,i):n&&n._},i}var W1t=Array.prototype.slice;function GL(e){return function(){return e}}var QY=Math.PI,tj=2*QY,L_=1e-6,SSe=tj-L_;function ej(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function Y1t(){return new ej}ej.prototype=Y1t.prototype={constructor:ej,moveTo:function(e,t){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)},closePath:function(){this._x1!==null&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(e,t){this._+="L"+(this._x1=+e)+","+(this._y1=+t)},quadraticCurveTo:function(e,t,r,n){this._+="Q"+ +e+","+ +t+","+(this._x1=+r)+","+(this._y1=+n)},bezierCurveTo:function(e,t,r,n,i,o){this._+="C"+ +e+","+ +t+","+ +r+","+ +n+","+(this._x1=+i)+","+(this._y1=+o)},arcTo:function(e,t,r,n,i){e=+e,t=+t,r=+r,n=+n,i=+i;var o=this._x1,a=this._y1,s=r-e,l=n-t,c=o-e,u=a-t,h=c*c+u*u;if(i<0)throw new Error("negative radius: "+i);if(this._x1===null)this._+="M"+(this._x1=e)+","+(this._y1=t);else if(h>L_)if(!(Math.abs(u*s-l*c)>L_)||!i)this._+="L"+(this._x1=e)+","+(this._y1=t);else{var f=r-o,p=n-a,d=s*s+l*l,g=f*f+p*p,_=Math.sqrt(d),y=Math.sqrt(h),x=i*Math.tan((QY-Math.acos((d+h-g)/(2*_*y)))/2),b=x/y,S=x/_;Math.abs(b-1)>L_&&(this._+="L"+(e+b*c)+","+(t+b*u)),this._+="A"+i+","+i+",0,0,"+ +(u*f>c*p)+","+(this._x1=e+S*s)+","+(this._y1=t+S*l)}},arc:function(e,t,r,n,i,o){e=+e,t=+t,r=+r,o=!!o;var a=r*Math.cos(n),s=r*Math.sin(n),l=e+a,c=t+s,u=1^o,h=o?n-i:i-n;if(r<0)throw new Error("negative radius: "+r);this._x1===null?this._+="M"+l+","+c:(Math.abs(this._x1-l)>L_||Math.abs(this._y1-c)>L_)&&(this._+="L"+l+","+c),r&&(h<0&&(h=h%tj+tj),h>SSe?this._+="A"+r+","+r+",0,1,"+u+","+(e-a)+","+(t-s)+"A"+r+","+r+",0,1,"+u+","+(this._x1=l)+","+(this._y1=c):h>L_&&(this._+="A"+r+","+r+",0,"+ +(h>=QY)+","+u+","+(this._x1=e+r*Math.cos(i))+","+(this._y1=t+r*Math.sin(i))))},rect:function(e,t,r,n){this._+="M"+(this._x0=this._x1=+e)+","+(this._y0=this._y1=+t)+"h"+ +r+"v"+ +n+"h"+-r+"Z"},toString:function(){return this._}};var bs=Y1t;function MSe(e){return e.source}function ESe(e){return e.target}function TSe(e){return e.radius}function CSe(e){return e.startAngle}function ASe(e){return e.endAngle}function j1t(){var e=MSe,t=ESe,r=TSe,n=CSe,i=ASe,o=null;function a(){var s,l=W1t.call(arguments),c=e.apply(this,l),u=t.apply(this,l),h=+r.apply(this,(l[0]=c,l)),f=n.apply(this,l)-HE,p=i.apply(this,l)-HE,d=h*$Y(f),g=h*KY(f),_=+r.apply(this,(l[0]=u,l)),y=n.apply(this,l)-HE,x=i.apply(this,l)-HE;if(o||(o=s=bs()),o.moveTo(d,g),o.arc(0,0,h,f,p),(f!==y||p!==x)&&(o.quadraticCurveTo(0,0,_*$Y(y),_*KY(y)),o.arc(0,0,_,y,x)),o.quadraticCurveTo(0,0,d,g),o.closePath(),s)return o=null,s+""||null}return a.radius=function(s){return arguments.length?(r=typeof s=="function"?s:GL(+s),a):r},a.startAngle=function(s){return arguments.length?(n=typeof s=="function"?s:GL(+s),a):n},a.endAngle=function(s){return arguments.length?(i=typeof s=="function"?s:GL(+s),a):i},a.source=function(s){return arguments.length?(e=s,a):e},a.target=function(s){return arguments.length?(t=s,a):t},a.context=function(s){return arguments.length?(o=s==null?null:s,a):o},a}Tb();var LSe=Array.prototype,$L=LSe.slice;function svt(e,t){return e-t}function lvt(e){for(var t=0,r=e.length,n=e[r-1][1]*e[0][0]-e[r-1][0]*e[0][1];++t<r;)n+=e[t-1][1]*e[t][0]-e[t-1][0]*e[t][1];return n}function Oh(e){return function(){return e}}function cvt(e,t){for(var r=-1,n=t.length,i;++r<n;)if(i=kSe(e,t[r]))return i;return 0}function kSe(e,t){for(var r=t[0],n=t[1],i=-1,o=0,a=e.length,s=a-1;o<a;s=o++){var l=e[o],c=l[0],u=l[1],h=e[s],f=h[0],p=h[1];if(RSe(l,h,t))return 0;u>n!=p>n&&r<(f-c)*(n-u)/(p-u)+c&&(i=-i)}return i}function RSe(e,t,r){var n;return NSe(e,t,r)&&DSe(e[n=+(e[0]===t[0])],r[n],t[n])}function NSe(e,t,r){return(t[0]-e[0])*(r[1]-e[1])===(r[0]-e[0])*(t[1]-e[1])}function DSe(e,t,r){return e<=t&&t<=r||r<=t&&t<=e}function uvt(){}var Ip=[[],[[[1,1.5],[.5,1]]],[[[1.5,1],[1,1.5]]],[[[1.5,1],[.5,1]]],[[[1,.5],[1.5,1]]],[[[1,1.5],[.5,1]],[[1,.5],[1.5,1]]],[[[1,.5],[1,1.5]]],[[[1,.5],[.5,1]]],[[[.5,1],[1,.5]]],[[[1,1.5],[1,.5]]],[[[.5,1],[1,.5]],[[1.5,1],[1,1.5]]],[[[1.5,1],[1,.5]]],[[[.5,1],[1.5,1]]],[[[1,1.5],[1.5,1]]],[[[.5,1],[1,1.5]]],[]];function KL(){var e=1,t=1,r=sb,n=l;function i(c){var u=r(c);if(Array.isArray(u))u=u.slice().sort(svt);else{var h=aa(c),f=h[0],p=h[1];u=tl(f,p,u),u=Ir(Math.floor(f/u)*u,Math.floor(p/u)*u,u)}return u.map(function(d){return o(c,d)})}function o(c,u){var h=[],f=[];return a(c,u,function(p){n(p,c,u),lvt(p)>0?h.push([p]):f.push(p)}),f.forEach(function(p){for(var d=0,g=h.length,_;d<g;++d)if(cvt((_=h[d])[0],p)!==-1){_.push(p);return}}),{type:"MultiPolygon",value:u,coordinates:h}}function a(c,u,h){var f=new Array,p=new Array,d,g,_,y,x,b;for(d=g=-1,y=c[0]>=u,Ip[y<<1].forEach(S);++d<e-1;)_=y,y=c[d+1]>=u,Ip[_|y<<1].forEach(S);for(Ip[y<<0].forEach(S);++g<t-1;){for(d=-1,y=c[g*e+e]>=u,x=c[g*e]>=u,Ip[y<<1|x<<2].forEach(S);++d<e-1;)_=y,y=c[g*e+e+d+1]>=u,b=x,x=c[g*e+d+1]>=u,Ip[_|y<<1|x<<2|b<<3].forEach(S);Ip[y|x<<3].forEach(S)}for(d=-1,x=c[g*e]>=u,Ip[x<<2].forEach(S);++d<e-1;)b=x,x=c[g*e+d+1]>=u,Ip[x<<2|b<<3].forEach(S);Ip[x<<3].forEach(S);function S(C){var P=[C[0][0]+d,C[0][1]+g],k=[C[1][0]+d,C[1][1]+g],O=s(P),D=s(k),B,I;(B=p[O])?(I=f[D])?(delete p[B.end],delete f[I.start],B===I?(B.ring.push(k),h(B.ring)):f[B.start]=p[I.end]={start:B.start,end:I.end,ring:B.ring.concat(I.ring)}):(delete p[B.end],B.ring.push(k),p[B.end=D]=B):(B=f[D])?(I=p[O])?(delete f[B.start],delete p[I.end],B===I?(B.ring.push(k),h(B.ring)):f[I.start]=p[B.end]={start:I.start,end:B.end,ring:I.ring.concat(B.ring)}):(delete f[B.start],B.ring.unshift(P),f[B.start=O]=B):f[O]=p[D]={start:O,end:D,ring:[P,k]}}}function s(c){return c[0]*2+c[1]*(e+1)*4}function l(c,u,h){c.forEach(function(f){var p=f[0],d=f[1],g=p|0,_=d|0,y,x=u[_*e+g];p>0&&p<e&&g===p&&(y=u[_*e+g-1],f[0]=p+(h-y)/(x-y)-.5),d>0&&d<t&&_===d&&(y=u[(_-1)*e+g],f[1]=d+(h-y)/(x-y)-.5)})}return i.contour=o,i.size=function(c){if(!arguments.length)return[e,t];var u=Math.ceil(c[0]),h=Math.ceil(c[1]);if(!(u>0)||!(h>0))throw new Error("invalid size");return e=u,t=h,i},i.thresholds=function(c){return arguments.length?(r=typeof c=="function"?c:Array.isArray(c)?Oh($L.call(c)):Oh(c),i):r},i.smooth=function(c){return arguments.length?(n=c?l:uvt,i):n===l},i}function ZL(e,t,r){for(var n=e.width,i=e.height,o=(r<<1)+1,a=0;a<i;++a)for(var s=0,l=0;s<n+r;++s)s<n&&(l+=e.data[s+a*n]),s>=r&&(s>=o&&(l-=e.data[s-o+a*n]),t.data[s-r+a*n]=l/Math.min(s+1,n-1+o-s,o))}function JL(e,t,r){for(var n=e.width,i=e.height,o=(r<<1)+1,a=0;a<n;++a)for(var s=0,l=0;s<i+r;++s)s<i&&(l+=e.data[a+s*n]),s>=r&&(s>=o&&(l-=e.data[a+(s-o)*n]),t.data[a+(s-r)*n]=l/Math.min(s+1,i-1+o-s,o))}function OSe(e){return e[0]}function zSe(e){return e[1]}function FSe(){return 1}function hvt(){var e=OSe,t=zSe,r=FSe,n=960,i=500,o=20,a=2,s=o*3,l=n+s*2>>a,c=i+s*2>>a,u=Oh(20);function h(y){var x=new Float32Array(l*c),b=new Float32Array(l*c);y.forEach(function(P,k,O){var D=+e(P,k,O)+s>>a,B=+t(P,k,O)+s>>a,I=+r(P,k,O);D>=0&&D<l&&B>=0&&B<c&&(x[D+B*l]+=I)}),ZL({width:l,height:c,data:x},{width:l,height:c,data:b},o>>a),JL({width:l,height:c,data:b},{width:l,height:c,data:x},o>>a),ZL({width:l,height:c,data:x},{width:l,height:c,data:b},o>>a),JL({width:l,height:c,data:b},{width:l,height:c,data:x},o>>a),ZL({width:l,height:c,data:x},{width:l,height:c,data:b},o>>a),JL({width:l,height:c,data:b},{width:l,height:c,data:x},o>>a);var S=u(x);if(!Array.isArray(S)){var C=lu(x);S=tl(0,C,S),S=Ir(0,Math.floor(C/S)*S,S),S.shift()}return KL().thresholds(S).size([l,c])(x).map(f)}function f(y){return y.value*=Math.pow(2,-2*a),y.coordinates.forEach(p),y}function p(y){y.forEach(d)}function d(y){y.forEach(g)}function g(y){y[0]=y[0]*Math.pow(2,a)-s,y[1]=y[1]*Math.pow(2,a)-s}function _(){return s=o*3,l=n+s*2>>a,c=i+s*2>>a,h}return h.x=function(y){return arguments.length?(e=typeof y=="function"?y:Oh(+y),h):e},h.y=function(y){return arguments.length?(t=typeof y=="function"?y:Oh(+y),h):t},h.weight=function(y){return arguments.length?(r=typeof y=="function"?y:Oh(+y),h):r},h.size=function(y){if(!arguments.length)return[n,i];var x=Math.ceil(y[0]),b=Math.ceil(y[1]);if(!(x>=0)&&!(x>=0))throw new Error("invalid size");return n=x,i=b,_()},h.cellSize=function(y){if(!arguments.length)return 1<<a;if(!((y=+y)>=1))throw new Error("invalid cell size");return a=Math.floor(Math.log(y)/Math.LN2),_()},h.thresholds=function(y){return arguments.length?(u=typeof y=="function"?y:Array.isArray(y)?Oh($L.call(y)):Oh(y),h):u},h.bandwidth=function(y){if(!arguments.length)return Math.sqrt(o*(o+1));if(!((y=+y)>=0))throw new Error("invalid bandwidth");return o=Math.round((Math.sqrt(4*y*y+1)-1)/2),_()},h}km();UE();I_();function qSe(e){if(!e.ok)throw new Error(e.status+" "+e.statusText);return e.blob()}function Ivt(e,t){return fetch(e,t).then(qSe)}function GSe(e){if(!e.ok)throw new Error(e.status+" "+e.statusText);return e.arrayBuffer()}function Lvt(e,t){return fetch(e,t).then(GSe)}UE();function WSe(e){if(!e.ok)throw new Error(e.status+" "+e.statusText);return e.text()}function D_(e,t){return fetch(e,t).then(WSe)}function kvt(e){return function(t,r,n){return arguments.length===2&&typeof r=="function"&&(n=r,r=void 0),D_(t,r).then(function(i){return e(i,n)})}}function aj(e,t,r,n){arguments.length===3&&typeof r=="function"&&(n=r,r=void 0);var i=Wm(e);return D_(t,r).then(function(o){return i.parse(o,n)})}var Rvt=kvt(Cb),Nvt=kvt(Ab);function Dvt(e,t){return new Promise(function(r,n){var i=new Image;for(var o in t)i[o]=t[o];i.onerror=n,i.onload=function(){r(i)},i.src=e})}function YSe(e){if(!e.ok)throw new Error(e.status+" "+e.statusText);if(!(e.status===204||e.status===205))return e.json()}function Ovt(e,t){return fetch(e,t).then(YSe)}function sj(e){return function(t,r){return D_(t,r).then(function(n){return new DOMParser().parseFromString(n,e)})}}var zvt=sj("application/xml"),Fvt=sj("text/html"),Bvt=sj("image/svg+xml");function Hvt(e,t){var r;e==null&&(e=0),t==null&&(t=0);function n(){var i,o=r.length,a,s=0,l=0;for(i=0;i<o;++i)a=r[i],s+=a.x,l+=a.y;for(s=s/o-e,l=l/o-t,i=0;i<o;++i)a=r[i],a.x-=s,a.y-=l}return n.initialize=function(i){r=i},n.x=function(i){return arguments.length?(e=+i,n):e},n.y=function(i){return arguments.length?(t=+i,n):t},n}function On(e){return function(){return e}}function fu(){return(Math.random()-.5)*1e-6}function Vvt(e){var t=+this._x.call(null,e),r=+this._y.call(null,e);return Uvt(this.cover(t,r),t,r,e)}function Uvt(e,t,r,n){if(isNaN(t)||isNaN(r))return e;var i,o=e._root,a={data:n},s=e._x0,l=e._y0,c=e._x1,u=e._y1,h,f,p,d,g,_,y,x;if(!o)return e._root=a,e;for(;o.length;)if((g=t>=(h=(s+c)/2))?s=h:c=h,(_=r>=(f=(l+u)/2))?l=f:u=f,i=o,!(o=o[y=_<<1|g]))return i[y]=a,e;if(p=+e._x.call(null,o.data),d=+e._y.call(null,o.data),t===p&&r===d)return a.next=o,i?i[y]=a:e._root=a,e;do i=i?i[y]=new Array(4):e._root=new Array(4),(g=t>=(h=(s+c)/2))?s=h:c=h,(_=r>=(f=(l+u)/2))?l=f:u=f;while((y=_<<1|g)===(x=(d>=f)<<1|p>=h));return i[x]=o,i[y]=a,e}function qvt(e){var t,r,n=e.length,i,o,a=new Array(n),s=new Array(n),l=1/0,c=1/0,u=-1/0,h=-1/0;for(r=0;r<n;++r)isNaN(i=+this._x.call(null,t=e[r]))||isNaN(o=+this._y.call(null,t))||(a[r]=i,s[r]=o,i<l&&(l=i),i>u&&(u=i),o<c&&(c=o),o>h&&(h=o));if(l>u||c>h)return this;for(this.cover(l,c).cover(u,h),r=0;r<n;++r)Uvt(this,a[r],s[r],e[r]);return this}function Gvt(e,t){if(isNaN(e=+e)||isNaN(t=+t))return this;var r=this._x0,n=this._y0,i=this._x1,o=this._y1;if(isNaN(r))i=(r=Math.floor(e))+1,o=(n=Math.floor(t))+1;else{for(var a=i-r,s=this._root,l,c;r>e||e>=i||n>t||t>=o;)switch(c=(t<n)<<1|e<r,l=new Array(4),l[c]=s,s=l,a*=2,c){case 0:i=r+a,o=n+a;break;case 1:r=i-a,o=n+a;break;case 2:i=r+a,n=o-a;break;case 3:r=i-a,n=o-a;break}this._root&&this._root.length&&(this._root=s)}return this._x0=r,this._y0=n,this._x1=i,this._y1=o,this}function Wvt(){var e=[];return this.visit(function(t){if(!t.length)do e.push(t.data);while(t=t.next)}),e}function Yvt(e){return arguments.length?this.cover(+e[0][0],+e[0][1]).cover(+e[1][0],+e[1][1]):isNaN(this._x0)?void 0:[[this._x0,this._y0],[this._x1,this._y1]]}function yo(e,t,r,n,i){this.node=e,this.x0=t,this.y0=r,this.x1=n,this.y1=i}function jvt(e,t,r){var n,i=this._x0,o=this._y0,a,s,l,c,u=this._x1,h=this._y1,f=[],p=this._root,d,g;for(p&&f.push(new yo(p,i,o,u,h)),r==null?r=1/0:(i=e-r,o=t-r,u=e+r,h=t+r,r*=r);d=f.pop();)if(!(!(p=d.node)||(a=d.x0)>u||(s=d.y0)>h||(l=d.x1)<i||(c=d.y1)<o))if(p.length){var _=(a+l)/2,y=(s+c)/2;f.push(new yo(p[3],_,y,l,c),new yo(p[2],a,y,_,c),new yo(p[1],_,s,l,y),new yo(p[0],a,s,_,y)),(g=(t>=y)<<1|e>=_)&&(d=f[f.length-1],f[f.length-1]=f[f.length-1-g],f[f.length-1-g]=d)}else{var x=e-+this._x.call(null,p.data),b=t-+this._y.call(null,p.data),S=x*x+b*b;if(S<r){var C=Math.sqrt(r=S);i=e-C,o=t-C,u=e+C,h=t+C,n=p.data}}return n}function Xvt(e){if(isNaN(u=+this._x.call(null,e))||isNaN(h=+this._y.call(null,e)))return this;var t,r=this._root,n,i,o,a=this._x0,s=this._y0,l=this._x1,c=this._y1,u,h,f,p,d,g,_,y;if(!r)return this;if(r.length)for(;;){if((d=u>=(f=(a+l)/2))?a=f:l=f,(g=h>=(p=(s+c)/2))?s=p:c=p,t=r,!(r=r[_=g<<1|d]))return this;if(!r.length)break;(t[_+1&3]||t[_+2&3]||t[_+3&3])&&(n=t,y=_)}for(;r.data!==e;)if(i=r,!(r=r.next))return this;return(o=r.next)&&delete r.next,i?(o?i.next=o:delete i.next,this):t?(o?t[_]=o:delete t[_],(r=t[0]||t[1]||t[2]||t[3])&&r===(t[3]||t[2]||t[1]||t[0])&&!r.length&&(n?n[y]=r:this._root=r),this):(this._root=o,this)}function $vt(e){for(var t=0,r=e.length;t<r;++t)this.remove(e[t]);return this}function Kvt(){return this._root}function Zvt(){var e=0;return this.visit(function(t){if(!t.length)do++e;while(t=t.next)}),e}function Jvt(e){var t=[],r,n=this._root,i,o,a,s,l;for(n&&t.push(new yo(n,this._x0,this._y0,this._x1,this._y1));r=t.pop();)if(!e(n=r.node,o=r.x0,a=r.y0,s=r.x1,l=r.y1)&&n.length){var c=(o+s)/2,u=(a+l)/2;(i=n[3])&&t.push(new yo(i,c,u,s,l)),(i=n[2])&&t.push(new yo(i,o,u,c,l)),(i=n[1])&&t.push(new yo(i,c,a,s,u)),(i=n[0])&&t.push(new yo(i,o,a,c,u))}return this}function Qvt(e){var t=[],r=[],n;for(this._root&&t.push(new yo(this._root,this._x0,this._y0,this._x1,this._y1));n=t.pop();){var i=n.node;if(i.length){var o,a=n.x0,s=n.y0,l=n.x1,c=n.y1,u=(a+l)/2,h=(s+c)/2;(o=i[0])&&t.push(new yo(o,a,s,u,h)),(o=i[1])&&t.push(new yo(o,u,s,l,h)),(o=i[2])&&t.push(new yo(o,a,h,u,c)),(o=i[3])&&t.push(new yo(o,u,h,l,c))}r.push(n)}for(;n=r.pop();)e(n.node,n.x0,n.y0,n.x1,n.y1);return this}function txt(e){return e[0]}function ext(e){return arguments.length?(this._x=e,this):this._x}function rxt(e){return e[1]}function nxt(e){return arguments.length?(this._y=e,this):this._y}function zh(e,t,r){var n=new lj(t==null?txt:t,r==null?rxt:r,NaN,NaN,NaN,NaN);return e==null?n:n.addAll(e)}function lj(e,t,r,n,i,o){this._x=e,this._y=t,this._x0=r,this._y0=n,this._x1=i,this._y1=o,this._root=void 0}function ixt(e){for(var t={data:e.data},r=t;e=e.next;)r=r.next={data:e.data};return t}var za=zh.prototype=lj.prototype;za.copy=function(){var e=new lj(this._x,this._y,this._x0,this._y0,this._x1,this._y1),t=this._root,r,n;if(!t)return e;if(!t.length)return e._root=ixt(t),e;for(r=[{source:t,target:e._root=new Array(4)}];t=r.pop();)for(var i=0;i<4;++i)(n=t.source[i])&&(n.length?r.push({source:n,target:t.target[i]=new Array(4)}):t.target[i]=ixt(n));return e};za.add=Vvt;za.addAll=qvt;za.cover=Gvt;za.data=Wvt;za.extent=Yvt;za.find=jvt;za.remove=Xvt;za.removeAll=$vt;za.root=Kvt;za.size=Zvt;za.visit=Jvt;za.visitAfter=Qvt;za.x=ext;za.y=nxt;function jSe(e){return e.x+e.vx}function XSe(e){return e.y+e.vy}function oxt(e){var t,r,n=1,i=1;typeof e!="function"&&(e=On(e==null?1:+e));function o(){for(var l,c=t.length,u,h,f,p,d,g,_=0;_<i;++_)for(u=zh(t,jSe,XSe).visitAfter(a),l=0;l<c;++l)h=t[l],d=r[h.index],g=d*d,f=h.x+h.vx,p=h.y+h.vy,u.visit(y);function y(x,b,S,C,P){var k=x.data,O=x.r,D=d+O;if(k){if(k.index>h.index){var B=f-k.x-k.vx,I=p-k.y-k.vy,L=B*B+I*I;L<D*D&&(B===0&&(B=fu(),L+=B*B),I===0&&(I=fu(),L+=I*I),L=(D-(L=Math.sqrt(L)))/L*n,h.vx+=(B*=L)*(D=(O*=O)/(g+O)),h.vy+=(I*=L)*D,k.vx-=B*(D=1-D),k.vy-=I*D)}return}return b>f+D||C<f-D||S>p+D||P<p-D}}function a(l){if(l.data)return l.r=r[l.data.index];for(var c=l.r=0;c<4;++c)l[c]&&l[c].r>l.r&&(l.r=l[c].r)}function s(){if(!!t){var l,c=t.length,u;for(r=new Array(c),l=0;l<c;++l)u=t[l],r[u.index]=+e(u,l,t)}}return o.initialize=function(l){t=l,s()},o.iterations=function(l){return arguments.length?(i=+l,o):i},o.strength=function(l){return arguments.length?(n=+l,o):n},o.radius=function(l){return arguments.length?(e=typeof l=="function"?l:On(+l),s(),o):e},o}Tb();function $Se(e){return e.index}function axt(e,t){var r=e.get(t);if(!r)throw new Error("missing: "+t);return r}function sxt(e){var t=$Se,r=u,n,i=On(30),o,a,s,l,c=1;e==null&&(e=[]);function u(g){return 1/Math.min(s[g.source.index],s[g.target.index])}function h(g){for(var _=0,y=e.length;_<c;++_)for(var x=0,b,S,C,P,k,O,D;x<y;++x)b=e[x],S=b.source,C=b.target,P=C.x+C.vx-S.x-S.vx||fu(),k=C.y+C.vy-S.y-S.vy||fu(),O=Math.sqrt(P*P+k*k),O=(O-o[x])/O*g*n[x],P*=O,k*=O,C.vx-=P*(D=l[x]),C.vy-=k*D,S.vx+=P*(D=1-D),S.vy+=k*D}function f(){if(!!a){var g,_=a.length,y=e.length,x=Ji(a,t),b;for(g=0,s=new Array(_);g<y;++g)b=e[g],b.index=g,typeof b.source!="object"&&(b.source=axt(x,b.source)),typeof b.target!="object"&&(b.target=axt(x,b.target)),s[b.source.index]=(s[b.source.index]||0)+1,s[b.target.index]=(s[b.target.index]||0)+1;for(g=0,l=new Array(y);g<y;++g)b=e[g],l[g]=s[b.source.index]/(s[b.source.index]+s[b.target.index]);n=new Array(y),p(),o=new Array(y),d()}}function p(){if(!!a)for(var g=0,_=e.length;g<_;++g)n[g]=+r(e[g],g,e)}function d(){if(!!a)for(var g=0,_=e.length;g<_;++g)o[g]=+i(e[g],g,e)}return h.initialize=function(g){a=g,f()},h.links=function(g){return arguments.length?(e=g,f(),h):e},h.id=function(g){return arguments.length?(t=g,h):t},h.iterations=function(g){return arguments.length?(c=+g,h):c},h.strength=function(g){return arguments.length?(r=typeof g=="function"?g:On(+g),p(),h):r},h.distance=function(g){return arguments.length?(i=typeof g=="function"?g:On(+g),d(),h):i},h}km();Tb();function lxt(e){return e.x}function cxt(e){return e.y}var KSe=10,ZSe=Math.PI*(3-Math.sqrt(5));function uxt(e){var t,r=1,n=.001,i=1-Math.pow(n,1/300),o=0,a=.6,s=Ji(),l=A_(u),c=vs("tick","end");e==null&&(e=[]);function u(){h(),c.call("tick",t),r<n&&(l.stop(),c.call("end",t))}function h(d){var g,_=e.length,y;d===void 0&&(d=1);for(var x=0;x<d;++x)for(r+=(o-r)*i,s.each(function(b){b(r)}),g=0;g<_;++g)y=e[g],y.fx==null?y.x+=y.vx*=a:(y.x=y.fx,y.vx=0),y.fy==null?y.y+=y.vy*=a:(y.y=y.fy,y.vy=0);return t}function f(){for(var d=0,g=e.length,_;d<g;++d){if(_=e[d],_.index=d,_.fx!=null&&(_.x=_.fx),_.fy!=null&&(_.y=_.fy),isNaN(_.x)||isNaN(_.y)){var y=KSe*Math.sqrt(d),x=d*ZSe;_.x=y*Math.cos(x),_.y=y*Math.sin(x)}(isNaN(_.vx)||isNaN(_.vy))&&(_.vx=_.vy=0)}}function p(d){return d.initialize&&d.initialize(e),d}return f(),t={tick:h,restart:function(){return l.restart(u),t},stop:function(){return l.stop(),t},nodes:function(d){return arguments.length?(e=d,f(),s.each(p),t):e},alpha:function(d){return arguments.length?(r=+d,t):r},alphaMin:function(d){return arguments.length?(n=+d,t):n},alphaDecay:function(d){return arguments.length?(i=+d,t):+i},alphaTarget:function(d){return arguments.length?(o=+d,t):o},velocityDecay:function(d){return arguments.length?(a=1-d,t):1-a},force:function(d,g){return arguments.length>1?(g==null?s.remove(d):s.set(d,p(g)),t):s.get(d)},find:function(d,g,_){var y=0,x=e.length,b,S,C,P,k;for(_==null?_=1/0:_*=_,y=0;y<x;++y)P=e[y],b=d-P.x,S=g-P.y,C=b*b+S*S,C<_&&(k=P,_=C);return k},on:function(d,g){return arguments.length>1?(c.on(d,g),t):c.on(d)}}}function hxt(){var e,t,r,n=On(-30),i,o=1,a=1/0,s=.81;function l(f){var p,d=e.length,g=zh(e,lxt,cxt).visitAfter(u);for(r=f,p=0;p<d;++p)t=e[p],g.visit(h)}function c(){if(!!e){var f,p=e.length,d;for(i=new Array(p),f=0;f<p;++f)d=e[f],i[d.index]=+n(d,f,e)}}function u(f){var p=0,d,g,_=0,y,x,b;if(f.length){for(y=x=b=0;b<4;++b)(d=f[b])&&(g=Math.abs(d.value))&&(p+=d.value,_+=g,y+=g*d.x,x+=g*d.y);f.x=y/_,f.y=x/_}else{d=f,d.x=d.data.x,d.y=d.data.y;do p+=i[d.data.index];while(d=d.next)}f.value=p}function h(f,p,d,g){if(!f.value)return!0;var _=f.x-t.x,y=f.y-t.y,x=g-p,b=_*_+y*y;if(x*x/s<b)return b<a&&(_===0&&(_=fu(),b+=_*_),y===0&&(y=fu(),b+=y*y),b<o&&(b=Math.sqrt(o*b)),t.vx+=_*f.value*r/b,t.vy+=y*f.value*r/b),!0;if(f.length||b>=a)return;(f.data!==t||f.next)&&(_===0&&(_=fu(),b+=_*_),y===0&&(y=fu(),b+=y*y),b<o&&(b=Math.sqrt(o*b)));do f.data!==t&&(x=i[f.data.index]*r/b,t.vx+=_*x,t.vy+=y*x);while(f=f.next)}return l.initialize=function(f){e=f,c()},l.strength=function(f){return arguments.length?(n=typeof f=="function"?f:On(+f),c(),l):n},l.distanceMin=function(f){return arguments.length?(o=f*f,l):Math.sqrt(o)},l.distanceMax=function(f){return arguments.length?(a=f*f,l):Math.sqrt(a)},l.theta=function(f){return arguments.length?(s=f*f,l):Math.sqrt(s)},l}function fxt(e,t,r){var n,i=On(.1),o,a;typeof e!="function"&&(e=On(+e)),t==null&&(t=0),r==null&&(r=0);function s(c){for(var u=0,h=n.length;u<h;++u){var f=n[u],p=f.x-t||1e-6,d=f.y-r||1e-6,g=Math.sqrt(p*p+d*d),_=(a[u]-g)*o[u]*c/g;f.vx+=p*_,f.vy+=d*_}}function l(){if(!!n){var c,u=n.length;for(o=new Array(u),a=new Array(u),c=0;c<u;++c)a[c]=+e(n[c],c,n),o[c]=isNaN(a[c])?0:+i(n[c],c,n)}}return s.initialize=function(c){n=c,l()},s.strength=function(c){return arguments.length?(i=typeof c=="function"?c:On(+c),l(),s):i},s.radius=function(c){return arguments.length?(e=typeof c=="function"?c:On(+c),l(),s):e},s.x=function(c){return arguments.length?(t=+c,s):t},s.y=function(c){return arguments.length?(r=+c,s):r},s}function pxt(e){var t=On(.1),r,n,i;typeof e!="function"&&(e=On(e==null?0:+e));function o(s){for(var l=0,c=r.length,u;l<c;++l)u=r[l],u.vx+=(i[l]-u.x)*n[l]*s}function a(){if(!!r){var s,l=r.length;for(n=new Array(l),i=new Array(l),s=0;s<l;++s)n[s]=isNaN(i[s]=+e(r[s],s,r))?0:+t(r[s],s,r)}}return o.initialize=function(s){r=s,a()},o.strength=function(s){return arguments.length?(t=typeof s=="function"?s:On(+s),a(),o):t},o.x=function(s){return arguments.length?(e=typeof s=="function"?s:On(+s),a(),o):e},o}function dxt(e){var t=On(.1),r,n,i;typeof e!="function"&&(e=On(e==null?0:+e));function o(s){for(var l=0,c=r.length,u;l<c;++l)u=r[l],u.vy+=(i[l]-u.y)*n[l]*s}function a(){if(!!r){var s,l=r.length;for(n=new Array(l),i=new Array(l),s=0;s<l;++s)n[s]=isNaN(i[s]=+e(r[s],s,r))?0:+t(r[s],s,r)}}return o.initialize=function(s){r=s,a()},o.strength=function(s){return arguments.length?(t=typeof s=="function"?s:On(+s),a(),o):t},o.y=function(s){return arguments.length?(e=typeof s=="function"?s:On(+s),a(),o):e},o}function mxt(e){return Math.abs(e=Math.round(e))>=1e21?e.toLocaleString("en").replace(/,/g,""):e.toString(10)}function O_(e,t){if((r=(e=t?e.toExponential(t-1):e.toExponential()).indexOf("e"))<0)return null;var r,n=e.slice(0,r);return[n.length>1?n[0]+n.slice(2):n,+e.slice(r+1)]}function Fh(e){return e=O_(Math.abs(e)),e?e[1]:NaN}function gxt(e,t){return function(r,n){for(var i=r.length,o=[],a=0,s=e[0],l=0;i>0&&s>0&&(l+s+1>n&&(s=Math.max(1,n-l)),o.push(r.substring(i-=s,i+s)),!((l+=s+1)>n));)s=e[a=(a+1)%e.length];return o.reverse().join(t)}}function _xt(e){return function(t){return t.replace(/[0-9]/g,function(r){return e[+r]})}}var JSe=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function Lp(e){if(!(t=JSe.exec(e)))throw new Error("invalid format: "+e);var t;return new qE({fill:t[1],align:t[2],sign:t[3],symbol:t[4],zero:t[5],width:t[6],comma:t[7],precision:t[8]&&t[8].slice(1),trim:t[9],type:t[10]})}Lp.prototype=qE.prototype;function qE(e){this.fill=e.fill===void 0?" ":e.fill+"",this.align=e.align===void 0?">":e.align+"",this.sign=e.sign===void 0?"-":e.sign+"",this.symbol=e.symbol===void 0?"":e.symbol+"",this.zero=!!e.zero,this.width=e.width===void 0?void 0:+e.width,this.comma=!!e.comma,this.precision=e.precision===void 0?void 0:+e.precision,this.trim=!!e.trim,this.type=e.type===void 0?"":e.type+""}qE.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(this.width===void 0?"":Math.max(1,this.width|0))+(this.comma?",":"")+(this.precision===void 0?"":"."+Math.max(0,this.precision|0))+(this.trim?"~":"")+this.type};function yxt(e){t:for(var t=e.length,r=1,n=-1,i;r<t;++r)switch(e[r]){case".":n=i=r;break;case"0":n===0&&(n=r),i=r;break;default:if(!+e[r])break t;n>0&&(n=0);break}return n>0?e.slice(0,n)+e.slice(i+1):e}var cj;function vxt(e,t){var r=O_(e,t);if(!r)return e+"";var n=r[0],i=r[1],o=i-(cj=Math.max(-8,Math.min(8,Math.floor(i/3)))*3)+1,a=n.length;return o===a?n:o>a?n+new Array(o-a+1).join("0"):o>0?n.slice(0,o)+"."+n.slice(o):"0."+new Array(1-o).join("0")+O_(e,Math.max(0,t+o-1))[0]}function uj(e,t){var r=O_(e,t);if(!r)return e+"";var n=r[0],i=r[1];return i<0?"0."+new Array(-i).join("0")+n:n.length>i+1?n.slice(0,i+1)+"."+n.slice(i+1):n+new Array(i-n.length+2).join("0")}var hj={"%":function(e,t){return(e*100).toFixed(t)},b:function(e){return Math.round(e).toString(2)},c:function(e){return e+""},d:mxt,e:function(e,t){return e.toExponential(t)},f:function(e,t){return e.toFixed(t)},g:function(e,t){return e.toPrecision(t)},o:function(e){return Math.round(e).toString(8)},p:function(e,t){return uj(e*100,t)},r:uj,s:vxt,X:function(e){return Math.round(e).toString(16).toUpperCase()},x:function(e){return Math.round(e).toString(16)}};function fj(e){return e}var xxt=Array.prototype.map,bxt=["y","z","a","f","p","n","\xB5","m","","k","M","G","T","P","E","Z","Y"];function tk(e){var t=e.grouping===void 0||e.thousands===void 0?fj:gxt(xxt.call(e.grouping,Number),e.thousands+""),r=e.currency===void 0?"":e.currency[0]+"",n=e.currency===void 0?"":e.currency[1]+"",i=e.decimal===void 0?".":e.decimal+"",o=e.numerals===void 0?fj:_xt(xxt.call(e.numerals,String)),a=e.percent===void 0?"%":e.percent+"",s=e.minus===void 0?"-":e.minus+"",l=e.nan===void 0?"NaN":e.nan+"";function c(h){h=Lp(h);var f=h.fill,p=h.align,d=h.sign,g=h.symbol,_=h.zero,y=h.width,x=h.comma,b=h.precision,S=h.trim,C=h.type;C==="n"?(x=!0,C="g"):hj[C]||(b===void 0&&(b=12),S=!0,C="g"),(_||f==="0"&&p==="=")&&(_=!0,f="0",p="=");var P=g==="$"?r:g==="#"&&/[boxX]/.test(C)?"0"+C.toLowerCase():"",k=g==="$"?n:/[%p]/.test(C)?a:"",O=hj[C],D=/[defgprs%]/.test(C);b=b===void 0?6:/[gprs]/.test(C)?Math.max(1,Math.min(21,b)):Math.max(0,Math.min(20,b));function B(I){var L=P,R=k,F,z,U;if(C==="c")R=O(I)+R,I="";else{I=+I;var W=I<0||1/I<0;if(I=isNaN(I)?l:O(Math.abs(I),b),S&&(I=yxt(I)),W&&+I==0&&d!=="+"&&(W=!1),L=(W?d==="("?d:s:d==="-"||d==="("?"":d)+L,R=(C==="s"?bxt[8+cj/3]:"")+R+(W&&d==="("?")":""),D){for(F=-1,z=I.length;++F<z;)if(U=I.charCodeAt(F),48>U||U>57){R=(U===46?i+I.slice(F+1):I.slice(F))+R,I=I.slice(0,F);break}}}x&&!_&&(I=t(I,1/0));var Z=L.length+I.length+R.length,rt=Z<y?new Array(y-Z+1).join(f):"";switch(x&&_&&(I=t(rt+I,rt.length?y-R.length:1/0),rt=""),p){case"<":I=L+I+R+rt;break;case"=":I=L+rt+I+R;break;case"^":I=rt.slice(0,Z=rt.length>>1)+L+I+R+rt.slice(Z);break;default:I=rt+L+I+R;break}return o(I)}return B.toString=function(){return h+""},B}function u(h,f){var p=c((h=Lp(h),h.type="f",h)),d=Math.max(-8,Math.min(8,Math.floor(Fh(f)/3)))*3,g=Math.pow(10,-d),_=bxt[8+d/3];return function(y){return p(g*y)+_}}return{format:c,formatPrefix:u}}var ek,xn,GE;rk({decimal:".",thousands:",",grouping:[3],currency:["$",""],minus:"-"});function rk(e){return ek=tk(e),xn=ek.format,GE=ek.formatPrefix,ek}function nk(e){return Math.max(0,-Fh(Math.abs(e)))}function ik(e,t){return Math.max(0,Math.max(-8,Math.min(8,Math.floor(Fh(t)/3)))*3-Fh(Math.abs(e)))}function ok(e,t){return e=Math.abs(e),t=Math.abs(t)-e,Math.max(0,Fh(t)-Fh(e))+1}function Ss(){return new sk}function sk(){this.reset()}sk.prototype={constructor:sk,reset:function(){this.s=this.t=0},add:function(e){wxt(ak,e,this.t),wxt(this,ak.s,this.s),this.s?this.t+=ak.t:this.s=ak.t},valueOf:function(){return this.s}};var ak=new sk;function wxt(e,t,r){var n=e.s=t+r,i=n-t,o=n-i;e.t=t-o+(r-i)}var le=1e-6,z_=1e-12,Be=Math.PI,mn=Be/2,Pb=Be/4,Si=Be*2,vr=180/Be,_e=Be/180,Re=Math.abs,ic=Math.atan,bn=Math.atan2,Zt=Math.cos,WE=Math.ceil,lk=Math.exp;var F_=Math.log,ck=Math.pow,Xt=Math.sin,ca=Math.sign||function(e){return e>0?1:e<0?-1:0},xr=Math.sqrt,Ib=Math.tan;function uk(e){return e>1?0:e<-1?Be:Math.acos(e)}function wn(e){return e>1?mn:e<-1?-mn:Math.asin(e)}function pj(e){return(e=Xt(e/2))*e}function Fr(){}function hk(e,t){e&&Mxt.hasOwnProperty(e.type)&&Mxt[e.type](e,t)}var Sxt={Feature:function(e,t){hk(e.geometry,t)},FeatureCollection:function(e,t){for(var r=e.features,n=-1,i=r.length;++n<i;)hk(r[n].geometry,t)}},Mxt={Sphere:function(e,t){t.sphere()},Point:function(e,t){e=e.coordinates,t.point(e[0],e[1],e[2])},MultiPoint:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)e=r[n],t.point(e[0],e[1],e[2])},LineString:function(e,t){dj(e.coordinates,t,0)},MultiLineString:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)dj(r[n],t,0)},Polygon:function(e,t){Ext(e.coordinates,t)},MultiPolygon:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)Ext(r[n],t)},GeometryCollection:function(e,t){for(var r=e.geometries,n=-1,i=r.length;++n<i;)hk(r[n],t)}};function dj(e,t,r){var n=-1,i=e.length-r,o;for(t.lineStart();++n<i;)o=e[n],t.point(o[0],o[1],o[2]);t.lineEnd()}function Ext(e,t){var r=-1,n=e.length;for(t.polygonStart();++r<n;)dj(e[r],t,1);t.polygonEnd()}function vo(e,t){e&&Sxt.hasOwnProperty(e.type)?Sxt[e.type](e,t):hk(e,t)}var YE=Ss(),fk=Ss(),Txt,Cxt,mj,gj,_j,pu={point:Fr,lineStart:Fr,lineEnd:Fr,polygonStart:function(){YE.reset(),pu.lineStart=QSe,pu.lineEnd=t3e},polygonEnd:function(){var e=+YE;fk.add(e<0?Si+e:e),this.lineStart=this.lineEnd=this.point=Fr},sphere:function(){fk.add(Si)}};function QSe(){pu.point=e3e}function t3e(){Axt(Txt,Cxt)}function e3e(e,t){pu.point=Axt,Txt=e,Cxt=t,e*=_e,t*=_e,mj=e,gj=Zt(t=t/2+Pb),_j=Xt(t)}function Axt(e,t){e*=_e,t*=_e,t=t/2+Pb;var r=e-mj,n=r>=0?1:-1,i=n*r,o=Zt(t),a=Xt(t),s=_j*a,l=gj*o+s*Zt(i),c=s*n*Xt(i);YE.add(bn(c,l)),mj=e,gj=o,_j=a}function Pxt(e){return fk.reset(),vo(e,pu),fk*2}function B_(e){return[bn(e[1],e[0]),wn(e[2])]}function oc(e){var t=e[0],r=e[1],n=Zt(r);return[n*Zt(t),n*Xt(t),Xt(r)]}function jE(e,t){return e[0]*t[0]+e[1]*t[1]+e[2]*t[2]}function kp(e,t){return[e[1]*t[2]-e[2]*t[1],e[2]*t[0]-e[0]*t[2],e[0]*t[1]-e[1]*t[0]]}function pk(e,t){e[0]+=t[0],e[1]+=t[1],e[2]+=t[2]}function XE(e,t){return[e[0]*t,e[1]*t,e[2]*t]}function H_(e){var t=xr(e[0]*e[0]+e[1]*e[1]+e[2]*e[2]);e[0]/=t,e[1]/=t,e[2]/=t}var ni,Ms,hi,nl,V_,Rxt,Nxt,Lb,$E=Ss(),Ym,Np,Rp={point:yj,lineStart:Ixt,lineEnd:Lxt,polygonStart:function(){Rp.point=Oxt,Rp.lineStart=r3e,Rp.lineEnd=n3e,$E.reset(),pu.polygonStart()},polygonEnd:function(){pu.polygonEnd(),Rp.point=yj,Rp.lineStart=Ixt,Rp.lineEnd=Lxt,YE<0?(ni=-(hi=180),Ms=-(nl=90)):$E>le?nl=90:$E<-le&&(Ms=-90),Np[0]=ni,Np[1]=hi},sphere:function(){ni=-(hi=180),Ms=-(nl=90)}};function yj(e,t){Ym.push(Np=[ni=e,hi=e]),t<Ms&&(Ms=t),t>nl&&(nl=t)}function Dxt(e,t){var r=oc([e*_e,t*_e]);if(Lb){var n=kp(Lb,r),i=[n[1],-n[0],0],o=kp(i,n);H_(o),o=B_(o);var a=e-V_,s=a>0?1:-1,l=o[0]*vr*s,c,u=Re(a)>180;u^(s*V_<l&&l<s*e)?(c=o[1]*vr,c>nl&&(nl=c)):(l=(l+360)%360-180,u^(s*V_<l&&l<s*e)?(c=-o[1]*vr,c<Ms&&(Ms=c)):(t<Ms&&(Ms=t),t>nl&&(nl=t))),u?e<V_?rl(ni,e)>rl(ni,hi)&&(hi=e):rl(e,hi)>rl(ni,hi)&&(ni=e):hi>=ni?(e<ni&&(ni=e),e>hi&&(hi=e)):e>V_?rl(ni,e)>rl(ni,hi)&&(hi=e):rl(e,hi)>rl(ni,hi)&&(ni=e)}else Ym.push(Np=[ni=e,hi=e]);t<Ms&&(Ms=t),t>nl&&(nl=t),Lb=r,V_=e}function Ixt(){Rp.point=Dxt}function Lxt(){Np[0]=ni,Np[1]=hi,Rp.point=yj,Lb=null}function Oxt(e,t){if(Lb){var r=e-V_;$E.add(Re(r)>180?r+(r>0?360:-360):r)}else Rxt=e,Nxt=t;pu.point(e,t),Dxt(e,t)}function r3e(){pu.lineStart()}function n3e(){Oxt(Rxt,Nxt),pu.lineEnd(),Re($E)>le&&(ni=-(hi=180)),Np[0]=ni,Np[1]=hi,Lb=null}function rl(e,t){return(t-=e)<0?t+360:t}function i3e(e,t){return e[0]-t[0]}function kxt(e,t){return e[0]<=e[1]?e[0]<=t&&t<=e[1]:t<e[0]||e[1]<t}function zxt(e){var t,r,n,i,o,a,s;if(nl=hi=-(ni=Ms=1/0),Ym=[],vo(e,Rp),r=Ym.length){for(Ym.sort(i3e),t=1,n=Ym[0],o=[n];t<r;++t)i=Ym[t],kxt(n,i[0])||kxt(n,i[1])?(rl(n[0],i[1])>rl(n[0],n[1])&&(n[1]=i[1]),rl(i[0],n[1])>rl(n[0],n[1])&&(n[0]=i[0])):o.push(n=i);for(a=-1/0,r=o.length-1,t=0,n=o[r];t<=r;n=i,++t)i=o[t],(s=rl(n[1],i[0]))>a&&(a=s,ni=i[0],hi=n[1])}return Ym=Np=null,ni===1/0||Ms===1/0?[[NaN,NaN],[NaN,NaN]]:[[ni,Ms],[hi,nl]]}var KE,dk,mk,gk,_k,yk,vk,xk,vj,xj,bj,Hxt,Vxt,Fa,Ba,Ha,du={sphere:Fr,point:wj,lineStart:Fxt,lineEnd:Bxt,polygonStart:function(){du.lineStart=s3e,du.lineEnd=l3e},polygonEnd:function(){du.lineStart=Fxt,du.lineEnd=Bxt}};function wj(e,t){e*=_e,t*=_e;var r=Zt(t);ZE(r*Zt(e),r*Xt(e),Xt(t))}function ZE(e,t,r){++KE,mk+=(e-mk)/KE,gk+=(t-gk)/KE,_k+=(r-_k)/KE}function Fxt(){du.point=o3e}function o3e(e,t){e*=_e,t*=_e;var r=Zt(t);Fa=r*Zt(e),Ba=r*Xt(e),Ha=Xt(t),du.point=a3e,ZE(Fa,Ba,Ha)}function a3e(e,t){e*=_e,t*=_e;var r=Zt(t),n=r*Zt(e),i=r*Xt(e),o=Xt(t),a=bn(xr((a=Ba*o-Ha*i)*a+(a=Ha*n-Fa*o)*a+(a=Fa*i-Ba*n)*a),Fa*n+Ba*i+Ha*o);dk+=a,yk+=a*(Fa+(Fa=n)),vk+=a*(Ba+(Ba=i)),xk+=a*(Ha+(Ha=o)),ZE(Fa,Ba,Ha)}function Bxt(){du.point=wj}function s3e(){du.point=c3e}function l3e(){Uxt(Hxt,Vxt),du.point=wj}function c3e(e,t){Hxt=e,Vxt=t,e*=_e,t*=_e,du.point=Uxt;var r=Zt(t);Fa=r*Zt(e),Ba=r*Xt(e),Ha=Xt(t),ZE(Fa,Ba,Ha)}function Uxt(e,t){e*=_e,t*=_e;var r=Zt(t),n=r*Zt(e),i=r*Xt(e),o=Xt(t),a=Ba*o-Ha*i,s=Ha*n-Fa*o,l=Fa*i-Ba*n,c=xr(a*a+s*s+l*l),u=wn(c),h=c&&-u/c;vj+=h*a,xj+=h*s,bj+=h*l,dk+=u,yk+=u*(Fa+(Fa=n)),vk+=u*(Ba+(Ba=i)),xk+=u*(Ha+(Ha=o)),ZE(Fa,Ba,Ha)}function qxt(e){KE=dk=mk=gk=_k=yk=vk=xk=vj=xj=bj=0,vo(e,du);var t=vj,r=xj,n=bj,i=t*t+r*r+n*n;return i<z_&&(t=yk,r=vk,n=xk,dk<le&&(t=mk,r=gk,n=_k),i=t*t+r*r+n*n,i<z_)?[NaN,NaN]:[bn(r,t)*vr,wn(n/xr(i))*vr]}function U_(e){return function(){return e}}function JE(e,t){function r(n,i){return n=e(n,i),t(n[0],n[1])}return e.invert&&t.invert&&(r.invert=function(n,i){return n=t.invert(n,i),n&&e.invert(n[0],n[1])}),r}function Sj(e,t){return[Re(e)>Be?e+Math.round(-e/Si)*Si:e,t]}Sj.invert=Sj;function QE(e,t,r){return(e%=Si)?t||r?JE(Wxt(e),Yxt(t,r)):Wxt(e):t||r?Yxt(t,r):Sj}function Gxt(e){return function(t,r){return t+=e,[t>Be?t-Si:t<-Be?t+Si:t,r]}}function Wxt(e){var t=Gxt(e);return t.invert=Gxt(-e),t}function Yxt(e,t){var r=Zt(e),n=Xt(e),i=Zt(t),o=Xt(t);function a(s,l){var c=Zt(l),u=Zt(s)*c,h=Xt(s)*c,f=Xt(l),p=f*r+u*n;return[bn(h*i-p*o,u*r-f*n),wn(p*i+h*o)]}return a.invert=function(s,l){var c=Zt(l),u=Zt(s)*c,h=Xt(s)*c,f=Xt(l),p=f*i-h*o;return[bn(h*i+f*o,u*r+p*n),wn(p*r-u*n)]},a}function bk(e){e=QE(e[0]*_e,e[1]*_e,e.length>2?e[2]*_e:0);function t(r){return r=e(r[0]*_e,r[1]*_e),r[0]*=vr,r[1]*=vr,r}return t.invert=function(r){return r=e.invert(r[0]*_e,r[1]*_e),r[0]*=vr,r[1]*=vr,r},t}function Mj(e,t,r,n,i,o){if(!!r){var a=Zt(t),s=Xt(t),l=n*r;i==null?(i=t+n*Si,o=t-l/2):(i=jxt(a,i),o=jxt(a,o),(n>0?i<o:i>o)&&(i+=n*Si));for(var c,u=i;n>0?u>o:u<o;u-=l)c=B_([a,-s*Zt(u),-s*Xt(u)]),e.point(c[0],c[1])}}function jxt(e,t){t=oc(t),t[0]-=e,H_(t);var r=uk(-t[1]);return((-t[2]<0?-r:r)+Si-le)%Si}function Xxt(){var e=U_([0,0]),t=U_(90),r=U_(6),n,i,o={point:a};function a(l,c){n.push(l=i(l,c)),l[0]*=vr,l[1]*=vr}function s(){var l=e.apply(this,arguments),c=t.apply(this,arguments)*_e,u=r.apply(this,arguments)*_e;return n=[],i=QE(-l[0]*_e,-l[1]*_e,0).invert,Mj(o,c,u,1),l={type:"Polygon",coordinates:[n]},n=i=null,l}return s.center=function(l){return arguments.length?(e=typeof l=="function"?l:U_([+l[0],+l[1]]),s):e},s.radius=function(l){return arguments.length?(t=typeof l=="function"?l:U_(+l),s):t},s.precision=function(l){return arguments.length?(r=typeof l=="function"?l:U_(+l),s):r},s}function wk(){var e=[],t;return{point:function(r,n,i){t.push([r,n,i])},lineStart:function(){e.push(t=[])},lineEnd:Fr,rejoin:function(){e.length>1&&e.push(e.pop().concat(e.shift()))},result:function(){var r=e;return e=[],t=null,r}}}function kb(e,t){return Re(e[0]-t[0])<le&&Re(e[1]-t[1])<le}function Sk(e,t,r,n){this.x=e,this.z=t,this.o=r,this.e=n,this.v=!1,this.n=this.p=null}function Mk(e,t,r,n,i){var o=[],a=[],s,l;if(e.forEach(function(d){if(!((g=d.length-1)<=0)){var g,_=d[0],y=d[g],x;if(kb(_,y)){if(!_[2]&&!y[2]){for(i.lineStart(),s=0;s<g;++s)i.point((_=d[s])[0],_[1]);i.lineEnd();return}y[0]+=2*le}o.push(x=new Sk(_,d,null,!0)),a.push(x.o=new Sk(_,null,x,!1)),o.push(x=new Sk(y,d,null,!1)),a.push(x.o=new Sk(y,null,x,!0))}}),!!o.length){for(a.sort(t),$xt(o),$xt(a),s=0,l=a.length;s<l;++s)a[s].e=r=!r;for(var c=o[0],u,h;;){for(var f=c,p=!0;f.v;)if((f=f.n)===c)return;u=f.z,i.lineStart();do{if(f.v=f.o.v=!0,f.e){if(p)for(s=0,l=u.length;s<l;++s)i.point((h=u[s])[0],h[1]);else n(f.x,f.n.x,1,i);f=f.n}else{if(p)for(u=f.p.z,s=u.length-1;s>=0;--s)i.point((h=u[s])[0],h[1]);else n(f.x,f.p.x,-1,i);f=f.p}f=f.o,u=f.z,p=!p}while(!f.v);i.lineEnd()}}}function $xt(e){if(!!(t=e.length)){for(var t,r=0,n=e[0],i;++r<t;)n.n=i=e[r],i.p=n,n=i;n.n=i=e[0],i.p=n}}var Ej=Ss();function Tj(e){return Re(e[0])<=Be?e[0]:ca(e[0])*((Re(e[0])+Be)%Si-Be)}function Ek(e,t){var r=Tj(t),n=t[1],i=Xt(n),o=[Xt(r),-Zt(r),0],a=0,s=0;Ej.reset(),i===1?n=mn+le:i===-1&&(n=-mn-le);for(var l=0,c=e.length;l<c;++l)if(!!(h=(u=e[l]).length))for(var u,h,f=u[h-1],p=Tj(f),d=f[1]/2+Pb,g=Xt(d),_=Zt(d),y=0;y<h;++y,p=b,g=C,_=P,f=x){var x=u[y],b=Tj(x),S=x[1]/2+Pb,C=Xt(S),P=Zt(S),k=b-p,O=k>=0?1:-1,D=O*k,B=D>Be,I=g*C;if(Ej.add(bn(I*O*Xt(D),_*P+I*Zt(D))),a+=B?k+O*Si:k,B^p>=r^b>=r){var L=kp(oc(f),oc(x));H_(L);var R=kp(o,L);H_(R);var F=(B^k>=0?-1:1)*wn(R[2]);(n>F||n===F&&(L[0]||L[1]))&&(s+=B^k>=0?1:-1)}}return(a<-le||a<le&&Ej<-le)^s&1}function Tk(e,t,r,n){return function(i){var o=t(i),a=wk(),s=t(a),l=!1,c,u,h,f={point:p,lineStart:g,lineEnd:_,polygonStart:function(){f.point=y,f.lineStart=x,f.lineEnd=b,u=[],c=[]},polygonEnd:function(){f.point=p,f.lineStart=g,f.lineEnd=_,u=Im(u);var S=Ek(c,n);u.length?(l||(i.polygonStart(),l=!0),Mk(u,h3e,S,r,i)):S&&(l||(i.polygonStart(),l=!0),i.lineStart(),r(null,null,1,i),i.lineEnd()),l&&(i.polygonEnd(),l=!1),u=c=null},sphere:function(){i.polygonStart(),i.lineStart(),r(null,null,1,i),i.lineEnd(),i.polygonEnd()}};function p(S,C){e(S,C)&&i.point(S,C)}function d(S,C){o.point(S,C)}function g(){f.point=d,o.lineStart()}function _(){f.point=p,o.lineEnd()}function y(S,C){h.push([S,C]),s.point(S,C)}function x(){s.lineStart(),h=[]}function b(){y(h[0][0],h[0][1]),s.lineEnd();var S=s.clean(),C=a.result(),P,k=C.length,O,D,B;if(h.pop(),c.push(h),h=null,!!k){if(S&1){if(D=C[0],(O=D.length-1)>0){for(l||(i.polygonStart(),l=!0),i.lineStart(),P=0;P<O;++P)i.point((B=D[P])[0],B[1]);i.lineEnd()}return}k>1&&S&2&&C.push(C.pop().concat(C.shift())),u.push(C.filter(u3e))}}return f}}function u3e(e){return e.length>1}function h3e(e,t){return((e=e.x)[0]<0?e[1]-mn-le:mn-e[1])-((t=t.x)[0]<0?t[1]-mn-le:mn-t[1])}var t5=Tk(function(){return!0},f3e,d3e,[-Be,-mn]);function f3e(e){var t=NaN,r=NaN,n=NaN,i;return{lineStart:function(){e.lineStart(),i=1},point:function(o,a){var s=o>0?Be:-Be,l=Re(o-t);Re(l-Be)<le?(e.point(t,r=(r+a)/2>0?mn:-mn),e.point(n,r),e.lineEnd(),e.lineStart(),e.point(s,r),e.point(o,r),i=0):n!==s&&l>=Be&&(Re(t-n)<le&&(t-=n*le),Re(o-s)<le&&(o-=s*le),r=p3e(t,r,o,a),e.point(n,r),e.lineEnd(),e.lineStart(),e.point(s,r),i=0),e.point(t=o,r=a),n=s},lineEnd:function(){e.lineEnd(),t=r=NaN},clean:function(){return 2-i}}}function p3e(e,t,r,n){var i,o,a=Xt(e-r);return Re(a)>le?ic((Xt(t)*(o=Zt(n))*Xt(r)-Xt(n)*(i=Zt(t))*Xt(e))/(i*o*a)):(t+n)/2}function d3e(e,t,r,n){var i;if(e==null)i=r*mn,n.point(-Be,i),n.point(0,i),n.point(Be,i),n.point(Be,0),n.point(Be,-i),n.point(0,-i),n.point(-Be,-i),n.point(-Be,0),n.point(-Be,i);else if(Re(e[0]-t[0])>le){var o=e[0]<t[0]?Be:-Be;i=r*o/2,n.point(-o,i),n.point(0,i),n.point(o,i)}else n.point(t[0],t[1])}function Ck(e){var t=Zt(e),r=6*_e,n=t>0,i=Re(t)>le;function o(u,h,f,p){Mj(p,e,r,f,u,h)}function a(u,h){return Zt(u)*Zt(h)>t}function s(u){var h,f,p,d,g;return{lineStart:function(){d=p=!1,g=1},point:function(_,y){var x=[_,y],b,S=a(_,y),C=n?S?0:c(_,y):S?c(_+(_<0?Be:-Be),y):0;if(!h&&(d=p=S)&&u.lineStart(),S!==p&&(b=l(h,x),(!b||kb(h,b)||kb(x,b))&&(x[2]=1)),S!==p)g=0,S?(u.lineStart(),b=l(x,h),u.point(b[0],b[1])):(b=l(h,x),u.point(b[0],b[1],2),u.lineEnd()),h=b;else if(i&&h&&n^S){var P;!(C&f)&&(P=l(x,h,!0))&&(g=0,n?(u.lineStart(),u.point(P[0][0],P[0][1]),u.point(P[1][0],P[1][1]),u.lineEnd()):(u.point(P[1][0],P[1][1]),u.lineEnd(),u.lineStart(),u.point(P[0][0],P[0][1],3)))}S&&(!h||!kb(h,x))&&u.point(x[0],x[1]),h=x,p=S,f=C},lineEnd:function(){p&&u.lineEnd(),h=null},clean:function(){return g|(d&&p)<<1}}}function l(u,h,f){var p=oc(u),d=oc(h),g=[1,0,0],_=kp(p,d),y=jE(_,_),x=_[0],b=y-x*x;if(!b)return!f&&u;var S=t*y/b,C=-t*x/b,P=kp(g,_),k=XE(g,S),O=XE(_,C);pk(k,O);var D=P,B=jE(k,D),I=jE(D,D),L=B*B-I*(jE(k,k)-1);if(!(L<0)){var R=xr(L),F=XE(D,(-B-R)/I);if(pk(F,k),F=B_(F),!f)return F;var z=u[0],U=h[0],W=u[1],Z=h[1],rt;U<z&&(rt=z,z=U,U=rt);var ot=U-z,st=Re(ot-Be)<le,St=st||ot<le;if(!st&&Z<W&&(rt=W,W=Z,Z=rt),St?st?W+Z>0^F[1]<(Re(F[0]-z)<le?W:Z):W<=F[1]&&F[1]<=Z:ot>Be^(z<=F[0]&&F[0]<=U)){var bt=XE(D,(-B+R)/I);return pk(bt,k),[F,B_(bt)]}}}function c(u,h){var f=n?e:Be-e,p=0;return u<-f?p|=1:u>f&&(p|=2),h<-f?p|=4:h>f&&(p|=8),p}return Tk(a,s,o,n?[0,-e]:[-Be,e-Be])}function Kxt(e,t,r,n,i,o){var a=e[0],s=e[1],l=t[0],c=t[1],u=0,h=1,f=l-a,p=c-s,d;if(d=r-a,!(!f&&d>0)){if(d/=f,f<0){if(d<u)return;d<h&&(h=d)}else if(f>0){if(d>h)return;d>u&&(u=d)}if(d=i-a,!(!f&&d<0)){if(d/=f,f<0){if(d>h)return;d>u&&(u=d)}else if(f>0){if(d<u)return;d<h&&(h=d)}if(d=n-s,!(!p&&d>0)){if(d/=p,p<0){if(d<u)return;d<h&&(h=d)}else if(p>0){if(d>h)return;d>u&&(u=d)}if(d=o-s,!(!p&&d<0)){if(d/=p,p<0){if(d>h)return;d>u&&(u=d)}else if(p>0){if(d<u)return;d<h&&(h=d)}return u>0&&(e[0]=a+u*f,e[1]=s+u*p),h<1&&(t[0]=a+h*f,t[1]=s+h*p),!0}}}}}var e5=1e9,Ak=-e5;function Dp(e,t,r,n){function i(c,u){return e<=c&&c<=r&&t<=u&&u<=n}function o(c,u,h,f){var p=0,d=0;if(c==null||(p=a(c,h))!==(d=a(u,h))||l(c,u)<0^h>0)do f.point(p===0||p===3?e:r,p>1?n:t);while((p=(p+h+4)%4)!==d);else f.point(u[0],u[1])}function a(c,u){return Re(c[0]-e)<le?u>0?0:3:Re(c[0]-r)<le?u>0?2:1:Re(c[1]-t)<le?u>0?1:0:u>0?3:2}function s(c,u){return l(c.x,u.x)}function l(c,u){var h=a(c,1),f=a(u,1);return h!==f?h-f:h===0?u[1]-c[1]:h===1?c[0]-u[0]:h===2?c[1]-u[1]:u[0]-c[0]}return function(c){var u=c,h=wk(),f,p,d,g,_,y,x,b,S,C,P,k={point:O,lineStart:L,lineEnd:R,polygonStart:B,polygonEnd:I};function O(z,U){i(z,U)&&u.point(z,U)}function D(){for(var z=0,U=0,W=p.length;U<W;++U)for(var Z=p[U],rt=1,ot=Z.length,st=Z[0],St,bt,Mt=st[0],lt=st[1];rt<ot;++rt)St=Mt,bt=lt,st=Z[rt],Mt=st[0],lt=st[1],bt<=n?lt>n&&(Mt-St)*(n-bt)>(lt-bt)*(e-St)&&++z:lt<=n&&(Mt-St)*(n-bt)<(lt-bt)*(e-St)&&--z;return z}function B(){u=h,f=[],p=[],P=!0}function I(){var z=D(),U=P&&z,W=(f=Im(f)).length;(U||W)&&(c.polygonStart(),U&&(c.lineStart(),o(null,null,1,c),c.lineEnd()),W&&Mk(f,s,z,o,c),c.polygonEnd()),u=c,f=p=d=null}function L(){k.point=F,p&&p.push(d=[]),C=!0,S=!1,x=b=NaN}function R(){f&&(F(g,_),y&&S&&h.rejoin(),f.push(h.result())),k.point=O,S&&u.lineEnd()}function F(z,U){var W=i(z,U);if(p&&d.push([z,U]),C)g=z,_=U,y=W,C=!1,W&&(u.lineStart(),u.point(z,U));else if(W&&S)u.point(z,U);else{var Z=[x=Math.max(Ak,Math.min(e5,x)),b=Math.max(Ak,Math.min(e5,b))],rt=[z=Math.max(Ak,Math.min(e5,z)),U=Math.max(Ak,Math.min(e5,U))];Kxt(Z,rt,e,t,r,n)?(S||(u.lineStart(),u.point(Z[0],Z[1])),u.point(rt[0],rt[1]),W||u.lineEnd(),P=!1):W&&(u.lineStart(),u.point(z,U),P=!1)}x=z,b=U,S=W}return k}}function Zxt(){var e=0,t=0,r=960,n=500,i,o,a;return a={stream:function(s){return i&&o===s?i:i=Dp(e,t,r,n)(o=s)},extent:function(s){return arguments.length?(e=+s[0][0],t=+s[0][1],r=+s[1][0],n=+s[1][1],i=o=null,a):[[e,t],[r,n]]}}}var Cj=Ss(),Aj,Pk,Ik,Rb={sphere:Fr,point:Fr,lineStart:m3e,lineEnd:Fr,polygonStart:Fr,polygonEnd:Fr};function m3e(){Rb.point=_3e,Rb.lineEnd=g3e}function g3e(){Rb.point=Rb.lineEnd=Fr}function _3e(e,t){e*=_e,t*=_e,Aj=e,Pk=Xt(t),Ik=Zt(t),Rb.point=y3e}function y3e(e,t){e*=_e,t*=_e;var r=Xt(t),n=Zt(t),i=Re(e-Aj),o=Zt(i),a=Xt(i),s=n*a,l=Ik*r-Pk*n*o,c=Pk*r+Ik*n*o;Cj.add(bn(xr(s*s+l*l),c)),Aj=e,Pk=r,Ik=n}function Lk(e){return Cj.reset(),vo(e,Rb),+Cj}var Pj=[null,null],v3e={type:"LineString",coordinates:Pj};function Nb(e,t){return Pj[0]=e,Pj[1]=t,Lk(v3e)}var Jxt={Feature:function(e,t){return kk(e.geometry,t)},FeatureCollection:function(e,t){for(var r=e.features,n=-1,i=r.length;++n<i;)if(kk(r[n].geometry,t))return!0;return!1}},Qxt={Sphere:function(){return!0},Point:function(e,t){return tbt(e.coordinates,t)},MultiPoint:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)if(tbt(r[n],t))return!0;return!1},LineString:function(e,t){return ebt(e.coordinates,t)},MultiLineString:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)if(ebt(r[n],t))return!0;return!1},Polygon:function(e,t){return rbt(e.coordinates,t)},MultiPolygon:function(e,t){for(var r=e.coordinates,n=-1,i=r.length;++n<i;)if(rbt(r[n],t))return!0;return!1},GeometryCollection:function(e,t){for(var r=e.geometries,n=-1,i=r.length;++n<i;)if(kk(r[n],t))return!0;return!1}};function kk(e,t){return e&&Qxt.hasOwnProperty(e.type)?Qxt[e.type](e,t):!1}function tbt(e,t){return Nb(e,t)===0}function ebt(e,t){for(var r,n,i,o=0,a=e.length;o<a;o++){if(n=Nb(e[o],t),n===0||o>0&&(i=Nb(e[o],e[o-1]),i>0&&r<=i&&n<=i&&(r+n-i)*(1-Math.pow((r-n)/i,2))<z_*i))return!0;r=n}return!1}function rbt(e,t){return!!Ek(e.map(x3e),nbt(t))}function x3e(e){return e=e.map(nbt),e.pop(),e}function nbt(e){return[e[0]*_e,e[1]*_e]}function ibt(e,t){return(e&&Jxt.hasOwnProperty(e.type)?Jxt[e.type]:kk)(e,t)}function obt(e,t,r){var n=Ir(e,t-le,r).concat(t);return function(i){return n.map(function(o){return[i,o]})}}function abt(e,t,r){var n=Ir(e,t-le,r).concat(t);return function(i){return n.map(function(o){return[o,i]})}}function Rk(){var e,t,r,n,i,o,a,s,l=10,c=l,u=90,h=360,f,p,d,g,_=2.5;function y(){return{type:"MultiLineString",coordinates:x()}}function x(){return Ir(WE(n/u)*u,r,u).map(d).concat(Ir(WE(s/h)*h,a,h).map(g)).concat(Ir(WE(t/l)*l,e,l).filter(function(b){return Re(b%u)>le}).map(f)).concat(Ir(WE(o/c)*c,i,c).filter(function(b){return Re(b%h)>le}).map(p))}return y.lines=function(){return x().map(function(b){return{type:"LineString",coordinates:b}})},y.outline=function(){return{type:"Polygon",coordinates:[d(n).concat(g(a).slice(1),d(r).reverse().slice(1),g(s).reverse().slice(1))]}},y.extent=function(b){return arguments.length?y.extentMajor(b).extentMinor(b):y.extentMinor()},y.extentMajor=function(b){return arguments.length?(n=+b[0][0],r=+b[1][0],s=+b[0][1],a=+b[1][1],n>r&&(b=n,n=r,r=b),s>a&&(b=s,s=a,a=b),y.precision(_)):[[n,s],[r,a]]},y.extentMinor=function(b){return arguments.length?(t=+b[0][0],e=+b[1][0],o=+b[0][1],i=+b[1][1],t>e&&(b=t,t=e,e=b),o>i&&(b=o,o=i,i=b),y.precision(_)):[[t,o],[e,i]]},y.step=function(b){return arguments.length?y.stepMajor(b).stepMinor(b):y.stepMinor()},y.stepMajor=function(b){return arguments.length?(u=+b[0],h=+b[1],y):[u,h]},y.stepMinor=function(b){return arguments.length?(l=+b[0],c=+b[1],y):[l,c]},y.precision=function(b){return arguments.length?(_=+b,f=obt(o,i,90),p=abt(t,e,_),d=obt(s,a,90),g=abt(n,r,_),y):_},y.extentMajor([[-180,-90+le],[180,90-le]]).extentMinor([[-180,-80-le],[180,80+le]])}function sbt(){return Rk()()}function lbt(e,t){var r=e[0]*_e,n=e[1]*_e,i=t[0]*_e,o=t[1]*_e,a=Zt(n),s=Xt(n),l=Zt(o),c=Xt(o),u=a*Zt(r),h=a*Xt(r),f=l*Zt(i),p=l*Xt(i),d=2*wn(xr(pj(o-n)+a*l*pj(i-r))),g=Xt(d),_=d?function(y){var x=Xt(y*=d)/g,b=Xt(d-y)/g,S=b*u+x*f,C=b*h+x*p,P=b*s+x*c;return[bn(C,S)*vr,bn(P,xr(S*S+C*C))*vr]}:function(){return[r*vr,n*vr]};return _.distance=d,_}function jm(e){return e}var Ij=Ss(),Lj=Ss(),cbt,ubt,kj,Rj,Xm={point:Fr,lineStart:Fr,lineEnd:Fr,polygonStart:function(){Xm.lineStart=b3e,Xm.lineEnd=S3e},polygonEnd:function(){Xm.lineStart=Xm.lineEnd=Xm.point=Fr,Ij.add(Re(Lj)),Lj.reset()},result:function(){var e=Ij/2;return Ij.reset(),e}};function b3e(){Xm.point=w3e}function w3e(e,t){Xm.point=hbt,cbt=kj=e,ubt=Rj=t}function hbt(e,t){Lj.add(Rj*e-kj*t),kj=e,Rj=t}function S3e(){hbt(cbt,ubt)}var Nj=Xm;var Db=1/0,Nk=Db,r5=-Db,Dk=r5,M3e={point:E3e,lineStart:Fr,lineEnd:Fr,polygonStart:Fr,polygonEnd:Fr,result:function(){var e=[[Db,Nk],[r5,Dk]];return r5=Dk=-(Nk=Db=1/0),e}};function E3e(e,t){e<Db&&(Db=e),e>r5&&(r5=e),t<Nk&&(Nk=t),t>Dk&&(Dk=t)}var Ob=M3e;var Dj=0,Oj=0,n5=0,Ok=0,zk=0,zb=0,zj=0,Fj=0,i5=0,dbt,mbt,Bh,Hh,mu={point:q_,lineStart:fbt,lineEnd:pbt,polygonStart:function(){mu.lineStart=A3e,mu.lineEnd=P3e},polygonEnd:function(){mu.point=q_,mu.lineStart=fbt,mu.lineEnd=pbt},result:function(){var e=i5?[zj/i5,Fj/i5]:zb?[Ok/zb,zk/zb]:n5?[Dj/n5,Oj/n5]:[NaN,NaN];return Dj=Oj=n5=Ok=zk=zb=zj=Fj=i5=0,e}};function q_(e,t){Dj+=e,Oj+=t,++n5}function fbt(){mu.point=T3e}function T3e(e,t){mu.point=C3e,q_(Bh=e,Hh=t)}function C3e(e,t){var r=e-Bh,n=t-Hh,i=xr(r*r+n*n);Ok+=i*(Bh+e)/2,zk+=i*(Hh+t)/2,zb+=i,q_(Bh=e,Hh=t)}function pbt(){mu.point=q_}function A3e(){mu.point=I3e}function P3e(){gbt(dbt,mbt)}function I3e(e,t){mu.point=gbt,q_(dbt=Bh=e,mbt=Hh=t)}function gbt(e,t){var r=e-Bh,n=t-Hh,i=xr(r*r+n*n);Ok+=i*(Bh+e)/2,zk+=i*(Hh+t)/2,zb+=i,i=Hh*e-Bh*t,zj+=i*(Bh+e),Fj+=i*(Hh+t),i5+=i*3,q_(Bh=e,Hh=t)}var Bj=mu;function Fk(e){this._context=e}Fk.prototype={_radius:4.5,pointRadius:function(e){return this._radius=e,this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){this._line===0&&this._context.closePath(),this._point=NaN},point:function(e,t){switch(this._point){case 0:{this._context.moveTo(e,t),this._point=1;break}case 1:{this._context.lineTo(e,t);break}default:{this._context.moveTo(e+this._radius,t),this._context.arc(e,t,this._radius,0,Si);break}}},result:Fr};var Vj=Ss(),Hj,_bt,ybt,o5,a5,Bk={point:Fr,lineStart:function(){Bk.point=L3e},lineEnd:function(){Hj&&vbt(_bt,ybt),Bk.point=Fr},polygonStart:function(){Hj=!0},polygonEnd:function(){Hj=null},result:function(){var e=+Vj;return Vj.reset(),e}};function L3e(e,t){Bk.point=vbt,_bt=o5=e,ybt=a5=t}function vbt(e,t){o5-=e,a5-=t,Vj.add(xr(o5*o5+a5*a5)),o5=e,a5=t}var Uj=Bk;function Hk(){this._string=[]}Hk.prototype={_radius:4.5,_circle:xbt(4.5),pointRadius:function(e){return(e=+e)!==this._radius&&(this._radius=e,this._circle=null),this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){this._line===0&&this._string.push("Z"),this._point=NaN},point:function(e,t){switch(this._point){case 0:{this._string.push("M",e,",",t),this._point=1;break}case 1:{this._string.push("L",e,",",t);break}default:{this._circle==null&&(this._circle=xbt(this._radius)),this._string.push("M",e,",",t,this._circle);break}}},result:function(){if(this._string.length){var e=this._string.join("");return this._string=[],e}else return null}};function xbt(e){return"m0,"+e+"a"+e+","+e+" 0 1,1 0,"+-2*e+"a"+e+","+e+" 0 1,1 0,"+2*e+"z"}function bbt(e,t){var r=4.5,n,i;function o(a){return a&&(typeof r=="function"&&i.pointRadius(+r.apply(this,arguments)),vo(a,n(i))),i.result()}return o.area=function(a){return vo(a,n(Nj)),Nj.result()},o.measure=function(a){return vo(a,n(Uj)),Uj.result()},o.bounds=function(a){return vo(a,n(Ob)),Ob.result()},o.centroid=function(a){return vo(a,n(Bj)),Bj.result()},o.projection=function(a){return arguments.length?(n=a==null?(e=null,jm):(e=a).stream,o):e},o.context=function(a){return arguments.length?(i=a==null?(t=null,new Hk):new Fk(t=a),typeof r!="function"&&i.pointRadius(r),o):t},o.pointRadius=function(a){return arguments.length?(r=typeof a=="function"?a:(i.pointRadius(+a),+a),o):r},o.projection(e).context(t)}function wbt(e){return{stream:$m(e)}}function $m(e){return function(t){var r=new qj;for(var n in e)r[n]=e[n];return r.stream=t,r}}function qj(){}qj.prototype={constructor:qj,point:function(e,t){this.stream.point(e,t)},sphere:function(){this.stream.sphere()},lineStart:function(){this.stream.lineStart()},lineEnd:function(){this.stream.lineEnd()},polygonStart:function(){this.stream.polygonStart()},polygonEnd:function(){this.stream.polygonEnd()}};function Gj(e,t,r){var n=e.clipExtent&&e.clipExtent();return e.scale(150).translate([0,0]),n!=null&&e.clipExtent(null),vo(r,e.stream(Ob)),t(Ob.result()),n!=null&&e.clipExtent(n),e}function G_(e,t,r){return Gj(e,function(n){var i=t[1][0]-t[0][0],o=t[1][1]-t[0][1],a=Math.min(i/(n[1][0]-n[0][0]),o/(n[1][1]-n[0][1])),s=+t[0][0]+(i-a*(n[1][0]+n[0][0]))/2,l=+t[0][1]+(o-a*(n[1][1]+n[0][1]))/2;e.scale(150*a).translate([s,l])},r)}function Fb(e,t,r){return G_(e,[[0,0],t],r)}function Bb(e,t,r){return Gj(e,function(n){var i=+t,o=i/(n[1][0]-n[0][0]),a=(i-o*(n[1][0]+n[0][0]))/2,s=-o*n[0][1];e.scale(150*o).translate([a,s])},r)}function Hb(e,t,r){return Gj(e,function(n){var i=+t,o=i/(n[1][1]-n[0][1]),a=-o*n[0][0],s=(i-o*(n[1][1]+n[0][1]))/2;e.scale(150*o).translate([a,s])},r)}var Sbt=16,k3e=Zt(30*_e);function Wj(e,t){return+t?N3e(e,t):R3e(e)}function R3e(e){return $m({point:function(t,r){t=e(t,r),this.stream.point(t[0],t[1])}})}function N3e(e,t){function r(n,i,o,a,s,l,c,u,h,f,p,d,g,_){var y=c-n,x=u-i,b=y*y+x*x;if(b>4*t&&g--){var S=a+f,C=s+p,P=l+d,k=xr(S*S+C*C+P*P),O=wn(P/=k),D=Re(Re(P)-1)<le||Re(o-h)<le?(o+h)/2:bn(C,S),B=e(D,O),I=B[0],L=B[1],R=I-n,F=L-i,z=x*R-y*F;(z*z/b>t||Re((y*R+x*F)/b-.5)>.3||a*f+s*p+l*d<k3e)&&(r(n,i,o,a,s,l,I,L,D,S/=k,C/=k,P,g,_),_.point(I,L),r(I,L,D,S,C,P,c,u,h,f,p,d,g,_))}}return function(n){var i,o,a,s,l,c,u,h,f,p,d,g,_={point:y,lineStart:x,lineEnd:S,polygonStart:function(){n.polygonStart(),_.lineStart=C},polygonEnd:function(){n.polygonEnd(),_.lineStart=x}};function y(O,D){O=e(O,D),n.point(O[0],O[1])}function x(){h=NaN,_.point=b,n.lineStart()}function b(O,D){var B=oc([O,D]),I=e(O,D);r(h,f,u,p,d,g,h=I[0],f=I[1],u=O,p=B[0],d=B[1],g=B[2],Sbt,n),n.point(h,f)}function S(){_.point=y,n.lineEnd()}function C(){x(),_.point=P,_.lineEnd=k}function P(O,D){b(i=O,D),o=h,a=f,s=p,l=d,c=g,_.point=b}function k(){r(h,f,u,p,d,g,o,a,i,s,l,c,Sbt,n),_.lineEnd=S,S()}return _}}var D3e=$m({point:function(e,t){this.stream.point(e*_e,t*_e)}});function O3e(e){return $m({point:function(t,r){var n=e(t,r);return this.stream.point(n[0],n[1])}})}function z3e(e,t,r,n,i){function o(a,s){return a*=n,s*=i,[t+e*a,r-e*s]}return o.invert=function(a,s){return[(a-t)/e*n,(r-s)/e*i]},o}function Mbt(e,t,r,n,i,o){var a=Zt(o),s=Xt(o),l=a*e,c=s*e,u=a/e,h=s/e,f=(s*r-a*t)/e,p=(s*t+a*r)/e;function d(g,_){return g*=n,_*=i,[l*g-c*_+t,r-c*g-l*_]}return d.invert=function(g,_){return[n*(u*g-h*_+f),i*(p-h*g-u*_)]},d}function Mi(e){return s5(function(){return e})()}function s5(e){var t,r=150,n=480,i=250,o=0,a=0,s=0,l=0,c=0,u,h=0,f=1,p=1,d=null,g=t5,_=null,y,x,b,S=jm,C=.5,P,k,O,D,B;function I(z){return O(z[0]*_e,z[1]*_e)}function L(z){return z=O.invert(z[0],z[1]),z&&[z[0]*vr,z[1]*vr]}I.stream=function(z){return D&&B===z?D:D=D3e(O3e(u)(g(P(S(B=z)))))},I.preclip=function(z){return arguments.length?(g=z,d=void 0,F()):g},I.postclip=function(z){return arguments.length?(S=z,_=y=x=b=null,F()):S},I.clipAngle=function(z){return arguments.length?(g=+z?Ck(d=z*_e):(d=null,t5),F()):d*vr},I.clipExtent=function(z){return arguments.length?(S=z==null?(_=y=x=b=null,jm):Dp(_=+z[0][0],y=+z[0][1],x=+z[1][0],b=+z[1][1]),F()):_==null?null:[[_,y],[x,b]]},I.scale=function(z){return arguments.length?(r=+z,R()):r},I.translate=function(z){return arguments.length?(n=+z[0],i=+z[1],R()):[n,i]},I.center=function(z){return arguments.length?(o=z[0]%360*_e,a=z[1]%360*_e,R()):[o*vr,a*vr]},I.rotate=function(z){return arguments.length?(s=z[0]%360*_e,l=z[1]%360*_e,c=z.length>2?z[2]%360*_e:0,R()):[s*vr,l*vr,c*vr]},I.angle=function(z){return arguments.length?(h=z%360*_e,R()):h*vr},I.reflectX=function(z){return arguments.length?(f=z?-1:1,R()):f<0},I.reflectY=function(z){return arguments.length?(p=z?-1:1,R()):p<0},I.precision=function(z){return arguments.length?(P=Wj(k,C=z*z),F()):xr(C)},I.fitExtent=function(z,U){return G_(I,z,U)},I.fitSize=function(z,U){return Fb(I,z,U)},I.fitWidth=function(z,U){return Bb(I,z,U)},I.fitHeight=function(z,U){return Hb(I,z,U)};function R(){var z=Mbt(r,0,0,f,p,h).apply(null,t(o,a)),U=(h?Mbt:z3e)(r,n-z[0],i-z[1],f,p,h);return u=QE(s,l,c),k=JE(t,U),O=JE(u,k),P=Wj(k,C),F()}function F(){return D=B=null,I}return function(){return t=e.apply(this,arguments),I.invert=t.invert&&L,R()}}function Vb(e){var t=0,r=Be/3,n=s5(e),i=n(t,r);return i.parallels=function(o){return arguments.length?n(t=o[0]*_e,r=o[1]*_e):[t*vr,r*vr]},i}function Ebt(e){var t=Zt(e);function r(n,i){return[n*t,Xt(i)/t]}return r.invert=function(n,i){return[n/t,wn(i*t)]},r}function Yj(e,t){var r=Xt(e),n=(r+Xt(t))/2;if(Re(n)<le)return Ebt(e);var i=1+r*(2*n-r),o=xr(i)/n;function a(s,l){var c=xr(i-2*n*Xt(l))/n;return[c*Xt(s*=n),o-c*Zt(s)]}return a.invert=function(s,l){var c=o-l,u=bn(s,Re(c))*ca(c);return c*n<0&&(u-=Be*ca(s)*ca(c)),[u/n,wn((i-(s*s+c*c)*n*n)/(2*n))]},a}function W_(){return Vb(Yj).scale(155.424).center([0,33.6442])}function Vk(){return W_().parallels([29.5,45.5]).scale(1070).translate([480,250]).rotate([96,0]).center([-.6,38.7])}function F3e(e){var t=e.length;return{point:function(r,n){for(var i=-1;++i<t;)e[i].point(r,n)},sphere:function(){for(var r=-1;++r<t;)e[r].sphere()},lineStart:function(){for(var r=-1;++r<t;)e[r].lineStart()},lineEnd:function(){for(var r=-1;++r<t;)e[r].lineEnd()},polygonStart:function(){for(var r=-1;++r<t;)e[r].polygonStart()},polygonEnd:function(){for(var r=-1;++r<t;)e[r].polygonEnd()}}}function Tbt(){var e,t,r=Vk(),n,i=W_().rotate([154,0]).center([-2,58.5]).parallels([55,65]),o,a=W_().rotate([157,0]).center([-3,19.9]).parallels([8,18]),s,l,c={point:function(f,p){l=[f,p]}};function u(f){var p=f[0],d=f[1];return l=null,n.point(p,d),l||(o.point(p,d),l)||(s.point(p,d),l)}u.invert=function(f){var p=r.scale(),d=r.translate(),g=(f[0]-d[0])/p,_=(f[1]-d[1])/p;return(_>=.12&&_<.234&&g>=-.425&&g<-.214?i:_>=.166&&_<.234&&g>=-.214&&g<-.115?a:r).invert(f)},u.stream=function(f){return e&&t===f?e:e=F3e([r.stream(t=f),i.stream(f),a.stream(f)])},u.precision=function(f){return arguments.length?(r.precision(f),i.precision(f),a.precision(f),h()):r.precision()},u.scale=function(f){return arguments.length?(r.scale(f),i.scale(f*.35),a.scale(f),u.translate(r.translate())):r.scale()},u.translate=function(f){if(!arguments.length)return r.translate();var p=r.scale(),d=+f[0],g=+f[1];return n=r.translate(f).clipExtent([[d-.455*p,g-.238*p],[d+.455*p,g+.238*p]]).stream(c),o=i.translate([d-.307*p,g+.201*p]).clipExtent([[d-.425*p+le,g+.12*p+le],[d-.214*p-le,g+.234*p-le]]).stream(c),s=a.translate([d-.205*p,g+.212*p]).clipExtent([[d-.214*p+le,g+.166*p+le],[d-.115*p-le,g+.234*p-le]]).stream(c),h()},u.fitExtent=function(f,p){return G_(u,f,p)},u.fitSize=function(f,p){return Fb(u,f,p)},u.fitWidth=function(f,p){return Bb(u,f,p)},u.fitHeight=function(f,p){return Hb(u,f,p)};function h(){return e=t=null,u}return u.scale(1070)}function Uk(e){return function(t,r){var n=Zt(t),i=Zt(r),o=e(n*i);return[o*i*Xt(t),o*Xt(r)]}}function Vh(e){return function(t,r){var n=xr(t*t+r*r),i=e(n),o=Xt(i),a=Zt(i);return[bn(t*o,n*a),wn(n&&r*o/n)]}}var qk=Uk(function(e){return xr(2/(1+e))});qk.invert=Vh(function(e){return 2*wn(e/2)});function Cbt(){return Mi(qk).scale(124.75).clipAngle(180-.001)}var Gk=Uk(function(e){return(e=uk(e))&&e/Xt(e)});Gk.invert=Vh(function(e){return e});function Abt(){return Mi(Gk).scale(79.4188).clipAngle(180-.001)}function Y_(e,t){return[e,F_(Ib((mn+t)/2))]}Y_.invert=function(e,t){return[e,2*ic(lk(t))-mn]};function Pbt(){return jj(Y_).scale(961/Si)}function jj(e){var t=Mi(e),r=t.center,n=t.scale,i=t.translate,o=t.clipExtent,a=null,s,l,c;t.scale=function(h){return arguments.length?(n(h),u()):n()},t.translate=function(h){return arguments.length?(i(h),u()):i()},t.center=function(h){return arguments.length?(r(h),u()):r()},t.clipExtent=function(h){return arguments.length?(h==null?a=s=l=c=null:(a=+h[0][0],s=+h[0][1],l=+h[1][0],c=+h[1][1]),u()):a==null?null:[[a,s],[l,c]]};function u(){var h=Be*n(),f=t(bk(t.rotate()).invert([0,0]));return o(a==null?[[f[0]-h,f[1]-h],[f[0]+h,f[1]+h]]:e===Y_?[[Math.max(f[0]-h,a),s],[Math.min(f[0]+h,l),c]]:[[a,Math.max(f[1]-h,s)],[l,Math.min(f[1]+h,c)]])}return u()}function Wk(e){return Ib((mn+e)/2)}function Xj(e,t){var r=Zt(e),n=e===t?Xt(e):F_(r/Zt(t))/F_(Wk(t)/Wk(e)),i=r*ck(Wk(e),n)/n;if(!n)return Y_;function o(a,s){i>0?s<-mn+le&&(s=-mn+le):s>mn-le&&(s=mn-le);var l=i/ck(Wk(s),n);return[l*Xt(n*a),i-l*Zt(n*a)]}return o.invert=function(a,s){var l=i-s,c=ca(n)*xr(a*a+l*l),u=bn(a,Re(l))*ca(l);return l*n<0&&(u-=Be*ca(a)*ca(l)),[u/n,2*ic(ck(i/c,1/n))-mn]},o}function Ibt(){return Vb(Xj).scale(109.5).parallels([30,30])}function j_(e,t){return[e,t]}j_.invert=j_;function Lbt(){return Mi(j_).scale(152.63)}function $j(e,t){var r=Zt(e),n=e===t?Xt(e):(r-Zt(t))/(t-e),i=r/n+e;if(Re(n)<le)return j_;function o(a,s){var l=i-s,c=n*a;return[l*Xt(c),i-l*Zt(c)]}return o.invert=function(a,s){var l=i-s,c=bn(a,Re(l))*ca(l);return l*n<0&&(c-=Be*ca(a)*ca(l)),[c/n,i-ca(n)*xr(a*a+l*l)]},o}function kbt(){return Vb($j).scale(131.154).center([0,13.9389])}var l5=1.340264,c5=-.081106,u5=893e-6,h5=.003796,Yk=xr(3)/2,B3e=12;function jk(e,t){var r=wn(Yk*Xt(t)),n=r*r,i=n*n*n;return[e*Zt(r)/(Yk*(l5+3*c5*n+i*(7*u5+9*h5*n))),r*(l5+c5*n+i*(u5+h5*n))]}jk.invert=function(e,t){for(var r=t,n=r*r,i=n*n*n,o=0,a,s,l;o<B3e&&(s=r*(l5+c5*n+i*(u5+h5*n))-t,l=l5+3*c5*n+i*(7*u5+9*h5*n),r-=a=s/l,n=r*r,i=n*n*n,!(Re(a)<z_));++o);return[Yk*e*(l5+3*c5*n+i*(7*u5+9*h5*n))/Zt(r),wn(Xt(r)/Yk)]};function Rbt(){return Mi(jk).scale(177.158)}function Xk(e,t){var r=Zt(t),n=Zt(e)*r;return[r*Xt(e)/n,Xt(t)/n]}Xk.invert=Vh(ic);function Nbt(){return Mi(Xk).scale(144.049).clipAngle(60)}function Dbt(){var e=1,t=0,r=0,n=1,i=1,o=0,a,s,l=null,c,u,h,f=1,p=1,d=$m({point:function(S,C){var P=b([S,C]);this.stream.point(P[0],P[1])}}),g=jm,_,y;function x(){return f=e*n,p=e*i,_=y=null,b}function b(S){var C=S[0]*f,P=S[1]*p;if(o){var k=P*a-C*s;C=C*a+P*s,P=k}return[C+t,P+r]}return b.invert=function(S){var C=S[0]-t,P=S[1]-r;if(o){var k=P*a+C*s;C=C*a-P*s,P=k}return[C/f,P/p]},b.stream=function(S){return _&&y===S?_:_=d(g(y=S))},b.postclip=function(S){return arguments.length?(g=S,l=c=u=h=null,x()):g},b.clipExtent=function(S){return arguments.length?(g=S==null?(l=c=u=h=null,jm):Dp(l=+S[0][0],c=+S[0][1],u=+S[1][0],h=+S[1][1]),x()):l==null?null:[[l,c],[u,h]]},b.scale=function(S){return arguments.length?(e=+S,x()):e},b.translate=function(S){return arguments.length?(t=+S[0],r=+S[1],x()):[t,r]},b.angle=function(S){return arguments.length?(o=S%360*_e,s=Xt(o),a=Zt(o),x()):o*vr},b.reflectX=function(S){return arguments.length?(n=S?-1:1,x()):n<0},b.reflectY=function(S){return arguments.length?(i=S?-1:1,x()):i<0},b.fitExtent=function(S,C){return G_(b,S,C)},b.fitSize=function(S,C){return Fb(b,S,C)},b.fitWidth=function(S,C){return Bb(b,S,C)},b.fitHeight=function(S,C){return Hb(b,S,C)},b}function $k(e,t){var r=t*t,n=r*r;return[e*(.8707-.131979*r+n*(-.013791+n*(.003971*r-.001529*n))),t*(1.007226+r*(.015085+n*(-.044475+.028874*r-.005916*n)))]}$k.invert=function(e,t){var r=t,n=25,i;do{var o=r*r,a=o*o;r-=i=(r*(1.007226+o*(.015085+a*(-.044475+.028874*o-.005916*a)))-t)/(1.007226+o*(.015085*3+a*(-.044475*7+.028874*9*o-.005916*11*a)))}while(Re(i)>le&&--n>0);return[e/(.8707+(o=r*r)*(-.131979+o*(-.013791+o*o*o*(.003971-.001529*o)))),r]};function Obt(){return Mi($k).scale(175.295)}function Kk(e,t){return[Zt(t)*Xt(e),Xt(t)]}Kk.invert=Vh(wn);function zbt(){return Mi(Kk).scale(249.5).clipAngle(90+le)}function Zk(e,t){var r=Zt(t),n=1+Zt(e)*r;return[r*Xt(e)/n,Xt(t)/n]}Zk.invert=Vh(function(e){return 2*ic(e)});function Fbt(){return Mi(Zk).scale(250).clipAngle(142)}function Jk(e,t){return[F_(Ib((mn+t)/2)),-e]}Jk.invert=function(e,t){return[-t,2*ic(lk(e))-mn]};function Bbt(){var e=jj(Jk),t=e.center,r=e.rotate;return e.center=function(n){return arguments.length?t([-n[1],n[0]]):(n=t(),[n[1],-n[0]])},e.rotate=function(n){return arguments.length?r([n[0],n[1],n.length>2?n[2]+90:90]):(n=r(),[n[0],n[1],n[2]-90])},r([0,0,90]).scale(159.155)}function H3e(e,t){return e.parent===t.parent?1:2}function V3e(e){return e.reduce(U3e,0)/e.length}function U3e(e,t){return e+t.x}function q3e(e){return 1+e.reduce(G3e,0)}function G3e(e,t){return Math.max(e,t.y)}function W3e(e){for(var t;t=e.children;)e=t[0];return e}function Y3e(e){for(var t;t=e.children;)e=t[t.length-1];return e}function Hbt(){var e=H3e,t=1,r=1,n=!1;function i(o){var a,s=0;o.eachAfter(function(f){var p=f.children;p?(f.x=V3e(p),f.y=q3e(p)):(f.x=a?s+=e(f,a):0,f.y=0,a=f)});var l=W3e(o),c=Y3e(o),u=l.x-e(l,c)/2,h=c.x+e(c,l)/2;return o.eachAfter(n?function(f){f.x=(f.x-o.x)*t,f.y=(o.y-f.y)*r}:function(f){f.x=(f.x-u)/(h-u)*t,f.y=(1-(o.y?f.y/o.y:1))*r})}return i.separation=function(o){return arguments.length?(e=o,i):e},i.size=function(o){return arguments.length?(n=!1,t=+o[0],r=+o[1],i):n?null:[t,r]},i.nodeSize=function(o){return arguments.length?(n=!0,t=+o[0],r=+o[1],i):n?[t,r]:null},i}function j3e(e){var t=0,r=e.children,n=r&&r.length;if(!n)t=1;else for(;--n>=0;)t+=r[n].value;e.value=t}function Vbt(){return this.eachAfter(j3e)}function Ubt(e){var t=this,r,n=[t],i,o,a;do for(r=n.reverse(),n=[];t=r.pop();)if(e(t),i=t.children,i)for(o=0,a=i.length;o<a;++o)n.push(i[o]);while(n.length);return this}function qbt(e){for(var t=this,r=[t],n,i;t=r.pop();)if(e(t),n=t.children,n)for(i=n.length-1;i>=0;--i)r.push(n[i]);return this}function Gbt(e){for(var t=this,r=[t],n=[],i,o,a;t=r.pop();)if(n.push(t),i=t.children,i)for(o=0,a=i.length;o<a;++o)r.push(i[o]);for(;t=n.pop();)e(t);return this}function Wbt(e){return this.eachAfter(function(t){for(var r=+e(t.data)||0,n=t.children,i=n&&n.length;--i>=0;)r+=n[i].value;t.value=r})}function Ybt(e){return this.eachBefore(function(t){t.children&&t.children.sort(e)})}function jbt(e){for(var t=this,r=X3e(t,e),n=[t];t!==r;)t=t.parent,n.push(t);for(var i=n.length;e!==r;)n.splice(i,0,e),e=e.parent;return n}function X3e(e,t){if(e===t)return e;var r=e.ancestors(),n=t.ancestors(),i=null;for(e=r.pop(),t=n.pop();e===t;)i=e,e=r.pop(),t=n.pop();return i}function Xbt(){for(var e=this,t=[e];e=e.parent;)t.push(e);return t}function $bt(){var e=[];return this.each(function(t){e.push(t)}),e}function Kbt(){var e=[];return this.eachBefore(function(t){t.children||e.push(t)}),e}function Zbt(){var e=this,t=[];return e.each(function(r){r!==e&&t.push({source:r.parent,target:r})}),t}function f5(e,t){var r=new Km(e),n=+e.value&&(r.value=e.value),i,o=[r],a,s,l,c;for(t==null&&(t=K3e);i=o.pop();)if(n&&(i.value=+i.data.value),(s=t(i.data))&&(c=s.length))for(i.children=new Array(c),l=c-1;l>=0;--l)o.push(a=i.children[l]=new Km(s[l])),a.parent=i,a.depth=i.depth+1;return r.eachBefore(Kj)}function $3e(){return f5(this).eachBefore(Z3e)}function K3e(e){return e.children}function Z3e(e){e.data=e.data.data}function Kj(e){var t=0;do e.height=t;while((e=e.parent)&&e.height<++t)}function Km(e){this.data=e,this.depth=this.height=0,this.parent=null}Km.prototype=f5.prototype={constructor:Km,count:Vbt,each:Ubt,eachAfter:Gbt,eachBefore:qbt,sum:Wbt,sort:Ybt,path:jbt,ancestors:Xbt,descendants:$bt,leaves:Kbt,links:Zbt,copy:$3e};var Jbt=Array.prototype.slice;function Qbt(e){for(var t=e.length,r,n;t;)n=Math.random()*t--|0,r=e[t],e[t]=e[n],e[n]=r;return e}function t8(e){for(var t=0,r=(e=Qbt(Jbt.call(e))).length,n=[],i,o;t<r;)i=e[t],o&&t2t(o,i)?++t:(o=Q3e(n=J3e(n,i)),t=0);return o}function J3e(e,t){var r,n;if(Zj(t,e))return[t];for(r=0;r<e.length;++r)if(Qk(t,e[r])&&Zj(p5(e[r],t),e))return[e[r],t];for(r=0;r<e.length-1;++r)for(n=r+1;n<e.length;++n)if(Qk(p5(e[r],e[n]),t)&&Qk(p5(e[r],t),e[n])&&Qk(p5(e[n],t),e[r])&&Zj(e2t(e[r],e[n],t),e))return[e[r],e[n],t];throw new Error}function Qk(e,t){var r=e.r-t.r,n=t.x-e.x,i=t.y-e.y;return r<0||r*r<n*n+i*i}function t2t(e,t){var r=e.r-t.r+1e-6,n=t.x-e.x,i=t.y-e.y;return r>0&&r*r>n*n+i*i}function Zj(e,t){for(var r=0;r<t.length;++r)if(!t2t(e,t[r]))return!1;return!0}function Q3e(e){switch(e.length){case 1:return tMe(e[0]);case 2:return p5(e[0],e[1]);case 3:return e2t(e[0],e[1],e[2])}}function tMe(e){return{x:e.x,y:e.y,r:e.r}}function p5(e,t){var r=e.x,n=e.y,i=e.r,o=t.x,a=t.y,s=t.r,l=o-r,c=a-n,u=s-i,h=Math.sqrt(l*l+c*c);return{x:(r+o+l/h*u)/2,y:(n+a+c/h*u)/2,r:(h+i+s)/2}}function e2t(e,t,r){var n=e.x,i=e.y,o=e.r,a=t.x,s=t.y,l=t.r,c=r.x,u=r.y,h=r.r,f=n-a,p=n-c,d=i-s,g=i-u,_=l-o,y=h-o,x=n*n+i*i-o*o,b=x-a*a-s*s+l*l,S=x-c*c-u*u+h*h,C=p*d-f*g,P=(d*S-g*b)/(C*2)-n,k=(g*_-d*y)/C,O=(p*b-f*S)/(C*2)-i,D=(f*y-p*_)/C,B=k*k+D*D-1,I=2*(o+P*k+O*D),L=P*P+O*O-o*o,R=-(B?(I+Math.sqrt(I*I-4*B*L))/(2*B):L/I);return{x:n+P+k*R,y:i+O+D*R,r:R}}function r2t(e,t,r){var n=e.x-t.x,i,o,a=e.y-t.y,s,l,c=n*n+a*a;c?(o=t.r+r.r,o*=o,l=e.r+r.r,l*=l,o>l?(i=(c+l-o)/(2*c),s=Math.sqrt(Math.max(0,l/c-i*i)),r.x=e.x-i*n-s*a,r.y=e.y-i*a+s*n):(i=(c+o-l)/(2*c),s=Math.sqrt(Math.max(0,o/c-i*i)),r.x=t.x+i*n-s*a,r.y=t.y+i*a+s*n)):(r.x=t.x+r.r,r.y=t.y)}function n2t(e,t){var r=e.r+t.r-1e-6,n=t.x-e.x,i=t.y-e.y;return r>0&&r*r>n*n+i*i}function i2t(e){var t=e._,r=e.next._,n=t.r+r.r,i=(t.x*r.r+r.x*t.r)/n,o=(t.y*r.r+r.y*t.r)/n;return i*i+o*o}function e8(e){this._=e,this.next=null,this.previous=null}function Jj(e){if(!(i=e.length))return 0;var t,r,n,i,o,a,s,l,c,u,h;if(t=e[0],t.x=0,t.y=0,!(i>1))return t.r;if(r=e[1],t.x=-r.r,r.x=t.r,r.y=0,!(i>2))return t.r+r.r;r2t(r,t,n=e[2]),t=new e8(t),r=new e8(r),n=new e8(n),t.next=n.previous=r,r.next=t.previous=n,n.next=r.previous=t;t:for(s=3;s<i;++s){r2t(t._,r._,n=e[s]),n=new e8(n),l=r.next,c=t.previous,u=r._.r,h=t._.r;do if(u<=h){if(n2t(l._,n._)){r=l,t.next=r,r.previous=t,--s;continue t}u+=l._.r,l=l.next}else{if(n2t(c._,n._)){t=c,t.next=r,r.previous=t,--s;continue t}h+=c._.r,c=c.previous}while(l!==c.next);for(n.previous=t,n.next=r,t.next=r.previous=r=n,o=i2t(t);(n=n.next)!==r;)(a=i2t(n))<o&&(t=n,o=a);r=t.next}for(t=[r._],n=r;(n=n.next)!==r;)t.push(n._);for(n=t8(t),s=0;s<i;++s)t=e[s],t.x-=n.x,t.y-=n.y;return n.r}function o2t(e){return Jj(e),e}function a2t(e){return e==null?null:Ub(e)}function Ub(e){if(typeof e!="function")throw new Error;return e}function Op(){return 0}function Zm(e){return function(){return e}}function eMe(e){return Math.sqrt(e.value)}function c2t(){var e=null,t=1,r=1,n=Op;function i(o){return o.x=t/2,o.y=r/2,e?o.eachBefore(s2t(e)).eachAfter(Qj(n,.5)).eachBefore(l2t(1)):o.eachBefore(s2t(eMe)).eachAfter(Qj(Op,1)).eachAfter(Qj(n,o.r/Math.min(t,r))).eachBefore(l2t(Math.min(t,r)/(2*o.r))),o}return i.radius=function(o){return arguments.length?(e=a2t(o),i):e},i.size=function(o){return arguments.length?(t=+o[0],r=+o[1],i):[t,r]},i.padding=function(o){return arguments.length?(n=typeof o=="function"?o:Zm(+o),i):n},i}function s2t(e){return function(t){t.children||(t.r=Math.max(0,+e(t)||0))}}function Qj(e,t){return function(r){if(n=r.children){var n,i,o=n.length,a=e(r)*t||0,s;if(a)for(i=0;i<o;++i)n[i].r+=a;if(s=Jj(n),a)for(i=0;i<o;++i)n[i].r-=a;r.r=s+a}}}function l2t(e){return function(t){var r=t.parent;t.r*=e,r&&(t.x=r.x+e*t.x,t.y=r.y+e*t.y)}}function r8(e){e.x0=Math.round(e.x0),e.y0=Math.round(e.y0),e.x1=Math.round(e.x1),e.y1=Math.round(e.y1)}function Uh(e,t,r,n,i){for(var o=e.children,a,s=-1,l=o.length,c=e.value&&(n-t)/e.value;++s<l;)a=o[s],a.y0=r,a.y1=i,a.x0=t,a.x1=t+=a.value*c}function u2t(){var e=1,t=1,r=0,n=!1;function i(a){var s=a.height+1;return a.x0=a.y0=r,a.x1=e,a.y1=t/s,a.eachBefore(o(t,s)),n&&a.eachBefore(r8),a}function o(a,s){return function(l){l.children&&Uh(l,l.x0,a*(l.depth+1)/s,l.x1,a*(l.depth+2)/s);var c=l.x0,u=l.y0,h=l.x1-r,f=l.y1-r;h<c&&(c=h=(c+h)/2),f<u&&(u=f=(u+f)/2),l.x0=c,l.y0=u,l.x1=h,l.y1=f}}return i.round=function(a){return arguments.length?(n=!!a,i):n},i.size=function(a){return arguments.length?(e=+a[0],t=+a[1],i):[e,t]},i.padding=function(a){return arguments.length?(r=+a,i):r},i}var h2t="$",rMe={depth:-1},f2t={};function nMe(e){return e.id}function iMe(e){return e.parentId}function p2t(){var e=nMe,t=iMe;function r(n){var i,o,a=n.length,s,l,c,u=new Array(a),h,f,p={};for(o=0;o<a;++o)i=n[o],c=u[o]=new Km(i),(h=e(i,o,n))!=null&&(h+="")&&(f=h2t+(c.id=h),p[f]=f in p?f2t:c);for(o=0;o<a;++o)if(c=u[o],h=t(n[o],o,n),h==null||!(h+="")){if(s)throw new Error("multiple roots");s=c}else{if(l=p[h2t+h],!l)throw new Error("missing: "+h);if(l===f2t)throw new Error("ambiguous: "+h);l.children?l.children.push(c):l.children=[c],c.parent=l}if(!s)throw new Error("no root");if(s.parent=rMe,s.eachBefore(function(d){d.depth=d.parent.depth+1,--a}).eachBefore(Kj),s.parent=null,a>0)throw new Error("cycle");return s}return r.id=function(n){return arguments.length?(e=Ub(n),r):e},r.parentId=function(n){return arguments.length?(t=Ub(n),r):t},r}function oMe(e,t){return e.parent===t.parent?1:2}function tX(e){var t=e.children;return t?t[0]:e.t}function eX(e){var t=e.children;return t?t[t.length-1]:e.t}function aMe(e,t,r){var n=r/(t.i-e.i);t.c-=n,t.s+=r,e.c+=n,t.z+=r,t.m+=r}function sMe(e){for(var t=0,r=0,n=e.children,i=n.length,o;--i>=0;)o=n[i],o.z+=t,o.m+=t,t+=o.s+(r+=o.c)}function lMe(e,t,r){return e.a.parent===t.parent?e.a:r}function n8(e,t){this._=e,this.parent=null,this.children=null,this.A=null,this.a=this,this.z=0,this.m=0,this.c=0,this.s=0,this.t=null,this.i=t}n8.prototype=Object.create(Km.prototype);function cMe(e){for(var t=new n8(e,0),r,n=[t],i,o,a,s;r=n.pop();)if(o=r._.children)for(r.children=new Array(s=o.length),a=s-1;a>=0;--a)n.push(i=r.children[a]=new n8(o[a],a)),i.parent=r;return(t.parent=new n8(null,0)).children=[t],t}function d2t(){var e=oMe,t=1,r=1,n=null;function i(c){var u=cMe(c);if(u.eachAfter(o),u.parent.m=-u.z,u.eachBefore(a),n)c.eachBefore(l);else{var h=c,f=c,p=c;c.eachBefore(function(x){x.x<h.x&&(h=x),x.x>f.x&&(f=x),x.depth>p.depth&&(p=x)});var d=h===f?1:e(h,f)/2,g=d-h.x,_=t/(f.x+d+g),y=r/(p.depth||1);c.eachBefore(function(x){x.x=(x.x+g)*_,x.y=x.depth*y})}return c}function o(c){var u=c.children,h=c.parent.children,f=c.i?h[c.i-1]:null;if(u){sMe(c);var p=(u[0].z+u[u.length-1].z)/2;f?(c.z=f.z+e(c._,f._),c.m=c.z-p):c.z=p}else f&&(c.z=f.z+e(c._,f._));c.parent.A=s(c,f,c.parent.A||h[0])}function a(c){c._.x=c.z+c.parent.m,c.m+=c.parent.m}function s(c,u,h){if(u){for(var f=c,p=c,d=u,g=f.parent.children[0],_=f.m,y=p.m,x=d.m,b=g.m,S;d=eX(d),f=tX(f),d&&f;)g=tX(g),p=eX(p),p.a=c,S=d.z+x-f.z-_+e(d._,f._),S>0&&(aMe(lMe(d,c,h),c,S),_+=S,y+=S),x+=d.m,_+=f.m,b+=g.m,y+=p.m;d&&!eX(p)&&(p.t=d,p.m+=x-y),f&&!tX(g)&&(g.t=f,g.m+=_-b,h=c)}return h}function l(c){c.x*=t,c.y=c.depth*r}return i.separation=function(c){return arguments.length?(e=c,i):e},i.size=function(c){return arguments.length?(n=!1,t=+c[0],r=+c[1],i):n?null:[t,r]},i.nodeSize=function(c){return arguments.length?(n=!0,t=+c[0],r=+c[1],i):n?[t,r]:null},i}function Jm(e,t,r,n,i){for(var o=e.children,a,s=-1,l=o.length,c=e.value&&(i-r)/e.value;++s<l;)a=o[s],a.x0=t,a.x1=n,a.y0=r,a.y1=r+=a.value*c}var rX=(1+Math.sqrt(5))/2;function nX(e,t,r,n,i,o){for(var a=[],s=t.children,l,c,u=0,h=0,f=s.length,p,d,g=t.value,_,y,x,b,S,C,P;u<f;){p=i-r,d=o-n;do _=s[h++].value;while(!_&&h<f);for(y=x=_,C=Math.max(d/p,p/d)/(g*e),P=_*_*C,S=Math.max(x/P,P/y);h<f;++h){if(_+=c=s[h].value,c<y&&(y=c),c>x&&(x=c),P=_*_*C,b=Math.max(x/P,P/y),b>S){_-=c;break}S=b}a.push(l={value:_,dice:p<d,children:s.slice(u,h)}),l.dice?Uh(l,r,n,i,g?n+=d*_/g:o):Jm(l,r,n,g?r+=p*_/g:i,o),g-=_,u=h}return a}var i8=function e(t){function r(n,i,o,a,s){nX(t,n,i,o,a,s)}return r.ratio=function(n){return e((n=+n)>1?n:1)},r}(rX);function m2t(){var e=i8,t=!1,r=1,n=1,i=[0],o=Op,a=Op,s=Op,l=Op,c=Op;function u(f){return f.x0=f.y0=0,f.x1=r,f.y1=n,f.eachBefore(h),i=[0],t&&f.eachBefore(r8),f}function h(f){var p=i[f.depth],d=f.x0+p,g=f.y0+p,_=f.x1-p,y=f.y1-p;_<d&&(d=_=(d+_)/2),y<g&&(g=y=(g+y)/2),f.x0=d,f.y0=g,f.x1=_,f.y1=y,f.children&&(p=i[f.depth+1]=o(f)/2,d+=c(f)-p,g+=a(f)-p,_-=s(f)-p,y-=l(f)-p,_<d&&(d=_=(d+_)/2),y<g&&(g=y=(g+y)/2),e(f,d,g,_,y))}return u.round=function(f){return arguments.length?(t=!!f,u):t},u.size=function(f){return arguments.length?(r=+f[0],n=+f[1],u):[r,n]},u.tile=function(f){return arguments.length?(e=Ub(f),u):e},u.padding=function(f){return arguments.length?u.paddingInner(f).paddingOuter(f):u.paddingInner()},u.paddingInner=function(f){return arguments.length?(o=typeof f=="function"?f:Zm(+f),u):o},u.paddingOuter=function(f){return arguments.length?u.paddingTop(f).paddingRight(f).paddingBottom(f).paddingLeft(f):u.paddingTop()},u.paddingTop=function(f){return arguments.length?(a=typeof f=="function"?f:Zm(+f),u):a},u.paddingRight=function(f){return arguments.length?(s=typeof f=="function"?f:Zm(+f),u):s},u.paddingBottom=function(f){return arguments.length?(l=typeof f=="function"?f:Zm(+f),u):l},u.paddingLeft=function(f){return arguments.length?(c=typeof f=="function"?f:Zm(+f),u):c},u}function g2t(e,t,r,n,i){var o=e.children,a,s=o.length,l,c=new Array(s+1);for(c[0]=l=a=0;a<s;++a)c[a+1]=l+=o[a].value;u(0,s,e.value,t,r,n,i);function u(h,f,p,d,g,_,y){if(h>=f-1){var x=o[h];x.x0=d,x.y0=g,x.x1=_,x.y1=y;return}for(var b=c[h],S=p/2+b,C=h+1,P=f-1;C<P;){var k=C+P>>>1;c[k]<S?C=k+1:P=k}S-c[C-1]<c[C]-S&&h+1<C&&--C;var O=c[C]-b,D=p-O;if(_-d>y-g){var B=(d*D+_*O)/p;u(h,C,O,d,g,B,y),u(C,f,D,B,g,_,y)}else{var I=(g*D+y*O)/p;u(h,C,O,d,g,_,I),u(C,f,D,d,I,_,y)}}}function _2t(e,t,r,n,i){(e.depth&1?Jm:Uh)(e,t,r,n,i)}var y2t=function e(t){function r(n,i,o,a,s){if((l=n._squarify)&&l.ratio===t)for(var l,c,u,h,f=-1,p,d=l.length,g=n.value;++f<d;){for(c=l[f],u=c.children,h=c.value=0,p=u.length;h<p;++h)c.value+=u[h].value;c.dice?Uh(c,i,o,a,o+=(s-o)*c.value/g):Jm(c,i,o,i+=(a-i)*c.value/g,s),g-=c.value}else n._squarify=l=nX(t,n,i,o,a,s),l.ratio=t}return r.ratio=function(n){return e((n=+n)>1?n:1)},r}(rX);function v2t(e){for(var t=-1,r=e.length,n,i=e[r-1],o=0;++t<r;)n=i,i=e[t],o+=n[1]*i[0]-n[0]*i[1];return o/2}function x2t(e){for(var t=-1,r=e.length,n=0,i=0,o,a=e[r-1],s,l=0;++t<r;)o=a,a=e[t],l+=s=o[0]*a[1]-a[0]*o[1],n+=(o[0]+a[0])*s,i+=(o[1]+a[1])*s;return l*=3,[n/l,i/l]}function b2t(e,t,r){return(t[0]-e[0])*(r[1]-e[1])-(t[1]-e[1])*(r[0]-e[0])}function uMe(e,t){return e[0]-t[0]||e[1]-t[1]}function w2t(e){for(var t=e.length,r=[0,1],n=2,i=2;i<t;++i){for(;n>1&&b2t(e[r[n-2]],e[r[n-1]],e[i])<=0;)--n;r[n++]=i}return r.slice(0,n)}function S2t(e){if((r=e.length)<3)return null;var t,r,n=new Array(r),i=new Array(r);for(t=0;t<r;++t)n[t]=[+e[t][0],+e[t][1],t];for(n.sort(uMe),t=0;t<r;++t)i[t]=[n[t][0],-n[t][1]];var o=w2t(n),a=w2t(i),s=a[0]===o[0],l=a[a.length-1]===o[o.length-1],c=[];for(t=o.length-1;t>=0;--t)c.push(e[n[o[t]][2]]);for(t=+s;t<a.length-l;++t)c.push(e[n[a[t]][2]]);return c}function M2t(e,t){for(var r=e.length,n=e[r-1],i=t[0],o=t[1],a=n[0],s=n[1],l,c,u=!1,h=0;h<r;++h)n=e[h],l=n[0],c=n[1],c>o!=s>o&&i<(a-l)*(o-c)/(s-c)+l&&(u=!u),a=l,s=c;return u}function E2t(e){for(var t=-1,r=e.length,n=e[r-1],i,o,a=n[0],s=n[1],l=0;++t<r;)i=a,o=s,n=e[t],a=n[0],s=n[1],i-=a,o-=s,l+=Math.sqrt(i*i+o*o);return l}function ac(){return Math.random()}var T2t=function e(t){function r(n,i){return n=n==null?0:+n,i=i==null?1:+i,arguments.length===1?(i=n,n=0):i-=n,function(){return t()*i+n}}return r.source=e,r}(ac);var o8=function e(t){function r(n,i){var o,a;return n=n==null?0:+n,i=i==null?1:+i,function(){var s;if(o!=null)s=o,o=null;else do o=t()*2-1,s=t()*2-1,a=o*o+s*s;while(!a||a>1);return n+i*s*Math.sqrt(-2*Math.log(a)/a)}}return r.source=e,r}(ac);var C2t=function e(t){function r(){var n=o8.source(t).apply(this,arguments);return function(){return Math.exp(n())}}return r.source=e,r}(ac);var a8=function e(t){function r(n){return function(){for(var i=0,o=0;o<n;++o)i+=t();return i}}return r.source=e,r}(ac);var A2t=function e(t){function r(n){var i=a8.source(t)(n);return function(){return i()/n}}return r.source=e,r}(ac);var P2t=function e(t){function r(n){return function(){return-Math.log(1-t())/n}}return r.source=e,r}(ac);function fi(e,t){switch(arguments.length){case 0:break;case 1:this.range(e);break;default:this.range(t).domain(e);break}return this}function sc(e,t){switch(arguments.length){case 0:break;case 1:this.interpolator(e);break;default:this.interpolator(t).domain(e);break}return this}Tb();var I2t=Array.prototype,X_=I2t.map,lc=I2t.slice;var s8={name:"implicit"};function gu(){var e=Ji(),t=[],r=[],n=s8;function i(o){var a=o+"",s=e.get(a);if(!s){if(n!==s8)return n;e.set(a,s=t.push(o))}return r[(s-1)%r.length]}return i.domain=function(o){if(!arguments.length)return t.slice();t=[],e=Ji();for(var a=-1,s=o.length,l,c;++a<s;)e.has(c=(l=o[a])+"")||e.set(c,t.push(l));return i},i.range=function(o){return arguments.length?(r=lc.call(o),i):r.slice()},i.unknown=function(o){return arguments.length?(n=o,i):n},i.copy=function(){return gu(t,r).unknown(n)},fi.apply(i,arguments),i}function Qm(){var e=gu().unknown(void 0),t=e.domain,r=e.range,n=[0,1],i,o,a=!1,s=0,l=0,c=.5;delete e.unknown;function u(){var h=t().length,f=n[1]<n[0],p=n[f-0],d=n[1-f];i=(d-p)/Math.max(1,h-s+l*2),a&&(i=Math.floor(i)),p+=(d-p-i*(h-s))*c,o=i*(1-s),a&&(p=Math.round(p),o=Math.round(o));var g=Ir(h).map(function(_){return p+i*_});return r(f?g.reverse():g)}return e.domain=function(h){return arguments.length?(t(h),u()):t()},e.range=function(h){return arguments.length?(n=[+h[0],+h[1]],u()):n.slice()},e.rangeRound=function(h){return n=[+h[0],+h[1]],a=!0,u()},e.bandwidth=function(){return o},e.step=function(){return i},e.round=function(h){return arguments.length?(a=!!h,u()):a},e.padding=function(h){return arguments.length?(s=Math.min(1,l=+h),u()):s},e.paddingInner=function(h){return arguments.length?(s=Math.min(1,h),u()):s},e.paddingOuter=function(h){return arguments.length?(l=+h,u()):l},e.align=function(h){return arguments.length?(c=Math.max(0,Math.min(1,h)),u()):c},e.copy=function(){return Qm(t(),n).round(a).paddingInner(s).paddingOuter(l).align(c)},fi.apply(u(),arguments)}function L2t(e){var t=e.copy;return e.padding=e.paddingOuter,delete e.paddingInner,delete e.paddingOuter,e.copy=function(){return L2t(t())},e}function tg(){return L2t(Qm.apply(null,arguments).paddingInner(1))}function k2t(e){return function(){return e}}function d5(e){return+e}var R2t=[0,1];function ii(e){return e}function iX(e,t){return(t-=e=+e)?function(r){return(r-e)/t}:k2t(isNaN(t)?NaN:.5)}function N2t(e){var t=e[0],r=e[e.length-1],n;return t>r&&(n=t,t=r,r=n),function(i){return Math.max(t,Math.min(r,i))}}function hMe(e,t,r){var n=e[0],i=e[1],o=t[0],a=t[1];return i<n?(n=iX(i,n),o=r(a,o)):(n=iX(n,i),o=r(o,a)),function(s){return o(n(s))}}function fMe(e,t,r){var n=Math.min(e.length,t.length)-1,i=new Array(n),o=new Array(n),a=-1;for(e[n]<e[0]&&(e=e.slice().reverse(),t=t.slice().reverse());++a<n;)i[a]=iX(e[a],e[a+1]),o[a]=r(t[a],t[a+1]);return function(s){var l=ys(e,s,1,n)-1;return o[l](i[l](s))}}function qh(e,t){return t.domain(e.domain()).range(e.range()).interpolate(e.interpolate()).clamp(e.clamp()).unknown(e.unknown())}function $_(){var e=R2t,t=R2t,r=nc,n,i,o,a=ii,s,l,c;function u(){return s=Math.min(e.length,t.length)>2?fMe:hMe,l=c=null,h}function h(f){return isNaN(f=+f)?o:(l||(l=s(e.map(n),t,r)))(n(a(f)))}return h.invert=function(f){return a(i((c||(c=s(t,e.map(n),zi)))(f)))},h.domain=function(f){return arguments.length?(e=X_.call(f,d5),a===ii||(a=N2t(e)),u()):e.slice()},h.range=function(f){return arguments.length?(t=lc.call(f),u()):t.slice()},h.rangeRound=function(f){return t=lc.call(f),r=pL,u()},h.clamp=function(f){return arguments.length?(a=f?N2t(e):ii,h):a!==ii},h.interpolate=function(f){return arguments.length?(r=f,u()):r},h.unknown=function(f){return arguments.length?(o=f,h):o},function(f,p){return n=f,i=p,u()}}function m5(e,t){return $_()(e,t)}function l8(e,t,r,n){var i=tl(e,t,r),o;switch(n=Lp(n==null?",f":n),n.type){case"s":{var a=Math.max(Math.abs(e),Math.abs(t));return n.precision==null&&!isNaN(o=ik(i,a))&&(n.precision=o),GE(n,a)}case"":case"e":case"g":case"p":case"r":{n.precision==null&&!isNaN(o=ok(i,Math.max(Math.abs(e),Math.abs(t))))&&(n.precision=o-(n.type==="e"));break}case"f":case"%":{n.precision==null&&!isNaN(o=nk(i))&&(n.precision=o-(n.type==="%")*2);break}}return xn(n)}function il(e){var t=e.domain;return e.ticks=function(r){var n=t();return ab(n[0],n[n.length-1],r==null?10:r)},e.tickFormat=function(r,n){var i=t();return l8(i[0],i[i.length-1],r==null?10:r,n)},e.nice=function(r){r==null&&(r=10);var n=t(),i=0,o=n.length-1,a=n[i],s=n[o],l;return s<a&&(l=a,a=s,s=l,l=i,i=o,o=l),l=x_(a,s,r),l>0?(a=Math.floor(a/l)*l,s=Math.ceil(s/l)*l,l=x_(a,s,r)):l<0&&(a=Math.ceil(a*l)/l,s=Math.floor(s*l)/l,l=x_(a,s,r)),l>0?(n[i]=Math.floor(a/l)*l,n[o]=Math.ceil(s/l)*l,t(n)):l<0&&(n[i]=Math.ceil(a*l)/l,n[o]=Math.floor(s*l)/l,t(n)),e},e}function zn(){var e=m5(ii,ii);return e.copy=function(){return qh(e,zn())},fi.apply(e,arguments),il(e)}function c8(e){var t;function r(n){return isNaN(n=+n)?t:n}return r.invert=r,r.domain=r.range=function(n){return arguments.length?(e=X_.call(n,d5),r):e.slice()},r.unknown=function(n){return arguments.length?(t=n,r):t},r.copy=function(){return c8(e).unknown(t)},e=arguments.length?X_.call(e,d5):[0,1],il(r)}function u8(e,t){e=e.slice();var r=0,n=e.length-1,i=e[r],o=e[n],a;return o<i&&(a=r,r=n,n=a,a=i,i=o,o=a),e[r]=t.floor(i),e[n]=t.ceil(o),e}function D2t(e){return Math.log(e)}function O2t(e){return Math.exp(e)}function pMe(e){return-Math.log(-e)}function dMe(e){return-Math.exp(-e)}function mMe(e){return isFinite(e)?+("1e"+e):e<0?0:e}function gMe(e){return e===10?mMe:e===Math.E?Math.exp:function(t){return Math.pow(e,t)}}function _Me(e){return e===Math.E?Math.log:e===10&&Math.log10||e===2&&Math.log2||(e=Math.log(e),function(t){return Math.log(t)/e})}function z2t(e){return function(t){return-e(-t)}}function g5(e){var t=e(D2t,O2t),r=t.domain,n=10,i,o;function a(){return i=_Me(n),o=gMe(n),r()[0]<0?(i=z2t(i),o=z2t(o),e(pMe,dMe)):e(D2t,O2t),t}return t.base=function(s){return arguments.length?(n=+s,a()):n},t.domain=function(s){return arguments.length?(r(s),a()):r()},t.ticks=function(s){var l=r(),c=l[0],u=l[l.length-1],h;(h=u<c)&&(f=c,c=u,u=f);var f=i(c),p=i(u),d,g,_,y=s==null?10:+s,x=[];if(!(n%1)&&p-f<y){if(f=Math.round(f)-1,p=Math.round(p)+1,c>0){for(;f<p;++f)for(g=1,d=o(f);g<n;++g)if(_=d*g,!(_<c)){if(_>u)break;x.push(_)}}else for(;f<p;++f)for(g=n-1,d=o(f);g>=1;--g)if(_=d*g,!(_<c)){if(_>u)break;x.push(_)}}else x=ab(f,p,Math.min(p-f,y)).map(o);return h?x.reverse():x},t.tickFormat=function(s,l){if(l==null&&(l=n===10?".0e":","),typeof l!="function"&&(l=xn(l)),s===1/0)return l;s==null&&(s=10);var c=Math.max(1,n*s/t.ticks().length);return function(u){var h=u/o(Math.round(i(u)));return h*n<n-.5&&(h*=n),h<=c?l(u):""}},t.nice=function(){return r(u8(r(),{floor:function(s){return o(Math.floor(i(s)))},ceil:function(s){return o(Math.ceil(i(s)))}}))},t}function cc(){var e=g5($_()).domain([1,10]);return e.copy=function(){return qh(e,cc()).base(e.base())},fi.apply(e,arguments),e}function F2t(e){return function(t){return Math.sign(t)*Math.log1p(Math.abs(t/e))}}function B2t(e){return function(t){return Math.sign(t)*Math.expm1(Math.abs(t))*e}}function _5(e){var t=1,r=e(F2t(t),B2t(t));return r.constant=function(n){return arguments.length?e(F2t(t=+n),B2t(t)):t},il(r)}function h8(){var e=_5($_());return e.copy=function(){return qh(e,h8()).constant(e.constant())},fi.apply(e,arguments)}function H2t(e){return function(t){return t<0?-Math.pow(-t,e):Math.pow(t,e)}}function yMe(e){return e<0?-Math.sqrt(-e):Math.sqrt(e)}function vMe(e){return e<0?-e*e:e*e}function y5(e){var t=e(ii,ii),r=1;function n(){return r===1?e(ii,ii):r===.5?e(yMe,vMe):e(H2t(r),H2t(1/r))}return t.exponent=function(i){return arguments.length?(r=+i,n()):r},il(t)}function K_(){var e=y5($_());return e.copy=function(){return qh(e,K_()).exponent(e.exponent())},fi.apply(e,arguments),e}function V2t(){return K_.apply(null,arguments).exponent(.5)}function eg(){var e=[],t=[],r=[],n;function i(){var a=0,s=Math.max(1,t.length);for(r=new Array(s-1);++a<s;)r[a-1]=sa(e,a/s);return o}function o(a){return isNaN(a=+a)?n:t[ys(r,a)]}return o.invertExtent=function(a){var s=t.indexOf(a);return s<0?[NaN,NaN]:[s>0?r[s-1]:e[0],s<r.length?r[s]:e[e.length-1]]},o.domain=function(a){if(!arguments.length)return e.slice();e=[];for(var s=0,l=a.length,c;s<l;++s)c=a[s],c!=null&&!isNaN(c=+c)&&e.push(c);return e.sort(oa),i()},o.range=function(a){return arguments.length?(t=lc.call(a),i()):t.slice()},o.unknown=function(a){return arguments.length?(n=a,o):n},o.quantiles=function(){return r.slice()},o.copy=function(){return eg().domain(e).range(t).unknown(n)},fi.apply(o,arguments)}function qb(){var e=0,t=1,r=1,n=[.5],i=[0,1],o;function a(l){return l<=l?i[ys(n,l,0,r)]:o}function s(){var l=-1;for(n=new Array(r);++l<r;)n[l]=((l+1)*t-(l-r)*e)/(r+1);return a}return a.domain=function(l){return arguments.length?(e=+l[0],t=+l[1],s()):[e,t]},a.range=function(l){return arguments.length?(r=(i=lc.call(l)).length-1,s()):i.slice()},a.invertExtent=function(l){var c=i.indexOf(l);return c<0?[NaN,NaN]:c<1?[e,n[0]]:c>=r?[n[r-1],t]:[n[c-1],n[c]]},a.unknown=function(l){return arguments.length&&(o=l),a},a.thresholds=function(){return n.slice()},a.copy=function(){return qb().domain([e,t]).range(i).unknown(o)},fi.apply(il(a),arguments)}function f8(){var e=[.5],t=[0,1],r,n=1;function i(o){return o<=o?t[ys(e,o,0,n)]:r}return i.domain=function(o){return arguments.length?(e=lc.call(o),n=Math.min(e.length,t.length-1),i):e.slice()},i.range=function(o){return arguments.length?(t=lc.call(o),n=Math.min(e.length,t.length-1),i):t.slice()},i.invertExtent=function(o){var a=t.indexOf(o);return[e[a-1],e[a]]},i.unknown=function(o){return arguments.length?(r=o,i):r},i.copy=function(){return f8().domain(e).range(t).unknown(r)},fi.apply(i,arguments)}var oX=new Date,aX=new Date;function br(e,t,r,n){function i(o){return e(o=arguments.length===0?new Date:new Date(+o)),o}return i.floor=function(o){return e(o=new Date(+o)),o},i.ceil=function(o){return e(o=new Date(o-1)),t(o,1),e(o),o},i.round=function(o){var a=i(o),s=i.ceil(o);return o-a<s-o?a:s},i.offset=function(o,a){return t(o=new Date(+o),a==null?1:Math.floor(a)),o},i.range=function(o,a,s){var l=[],c;if(o=i.ceil(o),s=s==null?1:Math.floor(s),!(o<a)||!(s>0))return l;do l.push(c=new Date(+o)),t(o,s),e(o);while(c<o&&o<a);return l},i.filter=function(o){return br(function(a){if(a>=a)for(;e(a),!o(a);)a.setTime(a-1)},function(a,s){if(a>=a)if(s<0)for(;++s<=0;)for(;t(a,-1),!o(a););else for(;--s>=0;)for(;t(a,1),!o(a););})},r&&(i.count=function(o,a){return oX.setTime(+o),aX.setTime(+a),e(oX),e(aX),Math.floor(r(oX,aX))},i.every=function(o){return o=Math.floor(o),!isFinite(o)||!(o>0)?null:o>1?i.filter(n?function(a){return n(a)%o===0}:function(a){return i.count(0,a)%o===0}):i}),i}var p8=br(function(){},function(e,t){e.setTime(+e+t)},function(e,t){return t-e});p8.every=function(e){return e=Math.floor(e),!isFinite(e)||!(e>0)?null:e>1?br(function(t){t.setTime(Math.floor(t/e)*e)},function(t,r){t.setTime(+t+r*e)},function(t,r){return(r-t)/e}):p8};var Z_=p8,sX=p8.range;var J_=1e3,uc=6e4,Gb=36e5,d8=864e5,m8=6048e5;var U2t=br(function(e){e.setTime(e-e.getMilliseconds())},function(e,t){e.setTime(+e+t*J_)},function(e,t){return(t-e)/J_},function(e){return e.getUTCSeconds()}),Q_=U2t,lX=U2t.range;var q2t=br(function(e){e.setTime(e-e.getMilliseconds()-e.getSeconds()*J_)},function(e,t){e.setTime(+e+t*uc)},function(e,t){return(t-e)/uc},function(e){return e.getMinutes()}),g8=q2t,G2t=q2t.range;var W2t=br(function(e){e.setTime(e-e.getMilliseconds()-e.getSeconds()*J_-e.getMinutes()*uc)},function(e,t){e.setTime(+e+t*Gb)},function(e,t){return(t-e)/Gb},function(e){return e.getHours()}),_8=W2t,Y2t=W2t.range;var j2t=br(function(e){e.setHours(0,0,0,0)},function(e,t){e.setDate(e.getDate()+t)},function(e,t){return(t-e-(t.getTimezoneOffset()-e.getTimezoneOffset())*uc)/d8},function(e){return e.getDate()-1}),ty=j2t,X2t=j2t.range;function ey(e){return br(function(t){t.setDate(t.getDate()-(t.getDay()+7-e)%7),t.setHours(0,0,0,0)},function(t,r){t.setDate(t.getDate()+r*7)},function(t,r){return(r-t-(r.getTimezoneOffset()-t.getTimezoneOffset())*uc)/m8})}var rg=ey(0),ry=ey(1),cX=ey(2),uX=ey(3),zp=ey(4),hX=ey(5),fX=ey(6),pX=rg.range,$2t=ry.range,K2t=cX.range,Z2t=uX.range,J2t=zp.range,Q2t=hX.range,twt=fX.range;var ewt=br(function(e){e.setDate(1),e.setHours(0,0,0,0)},function(e,t){e.setMonth(e.getMonth()+t)},function(e,t){return t.getMonth()-e.getMonth()+(t.getFullYear()-e.getFullYear())*12},function(e){return e.getMonth()}),y8=ewt,rwt=ewt.range;var dX=br(function(e){e.setMonth(0,1),e.setHours(0,0,0,0)},function(e,t){e.setFullYear(e.getFullYear()+t)},function(e,t){return t.getFullYear()-e.getFullYear()},function(e){return e.getFullYear()});dX.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:br(function(t){t.setFullYear(Math.floor(t.getFullYear()/e)*e),t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,r){t.setFullYear(t.getFullYear()+r*e)})};var Gh=dX,nwt=dX.range;var iwt=br(function(e){e.setUTCSeconds(0,0)},function(e,t){e.setTime(+e+t*uc)},function(e,t){return(t-e)/uc},function(e){return e.getUTCMinutes()}),v8=iwt,owt=iwt.range;var awt=br(function(e){e.setUTCMinutes(0,0,0)},function(e,t){e.setTime(+e+t*Gb)},function(e,t){return(t-e)/Gb},function(e){return e.getUTCHours()}),x8=awt,swt=awt.range;var lwt=br(function(e){e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCDate(e.getUTCDate()+t)},function(e,t){return(t-e)/d8},function(e){return e.getUTCDate()-1}),ny=lwt,cwt=lwt.range;function iy(e){return br(function(t){t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-e)%7),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCDate(t.getUTCDate()+r*7)},function(t,r){return(r-t)/m8})}var ng=iy(0),oy=iy(1),mX=iy(2),gX=iy(3),Fp=iy(4),_X=iy(5),yX=iy(6),vX=ng.range,uwt=oy.range,hwt=mX.range,fwt=gX.range,pwt=Fp.range,dwt=_X.range,mwt=yX.range;var gwt=br(function(e){e.setUTCDate(1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCMonth(e.getUTCMonth()+t)},function(e,t){return t.getUTCMonth()-e.getUTCMonth()+(t.getUTCFullYear()-e.getUTCFullYear())*12},function(e){return e.getUTCMonth()}),b8=gwt,_wt=gwt.range;var xX=br(function(e){e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0)},function(e,t){e.setUTCFullYear(e.getUTCFullYear()+t)},function(e,t){return t.getUTCFullYear()-e.getUTCFullYear()},function(e){return e.getUTCFullYear()});xX.every=function(e){return!isFinite(e=Math.floor(e))||!(e>0)?null:br(function(t){t.setUTCFullYear(Math.floor(t.getUTCFullYear()/e)*e),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,r){t.setUTCFullYear(t.getUTCFullYear()+r*e)})};var Wh=xX,ywt=xX.range;function bX(e){if(0<=e.y&&e.y<100){var t=new Date(-1,e.m,e.d,e.H,e.M,e.S,e.L);return t.setFullYear(e.y),t}return new Date(e.y,e.m,e.d,e.H,e.M,e.S,e.L)}function wX(e){if(0<=e.y&&e.y<100){var t=new Date(Date.UTC(-1,e.m,e.d,e.H,e.M,e.S,e.L));return t.setUTCFullYear(e.y),t}return new Date(Date.UTC(e.y,e.m,e.d,e.H,e.M,e.S,e.L))}function v5(e,t,r){return{y:e,m:t,d:r,H:0,M:0,S:0,L:0}}function w5(e){var t=e.dateTime,r=e.date,n=e.time,i=e.periods,o=e.days,a=e.shortDays,s=e.months,l=e.shortMonths,c=x5(i),u=b5(i),h=x5(o),f=b5(o),p=x5(a),d=b5(a),g=x5(s),_=b5(s),y=x5(l),x=b5(l),b={a:W,A:Z,b:rt,B:ot,c:null,d:Mwt,e:Mwt,f:UMe,g:JMe,G:tEe,H:BMe,I:HMe,j:VMe,L:Pwt,m:qMe,M:GMe,p:st,q:St,Q:Cwt,s:Awt,S:WMe,u:YMe,U:jMe,V:XMe,w:$Me,W:KMe,x:null,X:null,y:ZMe,Y:QMe,Z:eEe,"%":Twt},S={a:bt,A:Mt,b:lt,B:Kt,c:null,d:Ewt,e:Ewt,f:oEe,g:mEe,G:_Ee,H:rEe,I:nEe,j:iEe,L:Lwt,m:aEe,M:sEe,p:_t,q:ct,Q:Cwt,s:Awt,S:lEe,u:cEe,U:uEe,V:hEe,w:fEe,W:pEe,x:null,X:null,y:dEe,Y:gEe,Z:yEe,"%":Twt},C={a:B,A:I,b:L,B:R,c:F,d:wwt,e:wwt,f:DMe,g:bwt,G:xwt,H:Swt,I:Swt,j:LMe,L:NMe,m:IMe,M:kMe,p:D,q:PMe,Q:zMe,s:FMe,S:RMe,u:MMe,U:EMe,V:TMe,w:SMe,W:CMe,x:z,X:U,y:bwt,Y:xwt,Z:AMe,"%":OMe};b.x=P(r,b),b.X=P(n,b),b.c=P(t,b),S.x=P(r,S),S.X=P(n,S),S.c=P(t,S);function P(X,et){return function(dt){var q=[],pt=-1,ht=0,wt=X.length,kt,ie,ee;for(dt instanceof Date||(dt=new Date(+dt));++pt<wt;)X.charCodeAt(pt)===37&&(q.push(X.slice(ht,pt)),(ie=vwt[kt=X.charAt(++pt)])!=null?kt=X.charAt(++pt):ie=kt==="e"?" ":"0",(ee=et[kt])&&(kt=ee(dt,ie)),q.push(kt),ht=pt+1);return q.push(X.slice(ht,pt)),q.join("")}}function k(X,et){return function(dt){var q=v5(1900,void 0,1),pt=O(q,X,dt+="",0),ht,wt;if(pt!=dt.length)return null;if("Q"in q)return new Date(q.Q);if("s"in q)return new Date(q.s*1e3+("L"in q?q.L:0));if(et&&!("Z"in q)&&(q.Z=0),"p"in q&&(q.H=q.H%12+q.p*12),q.m===void 0&&(q.m="q"in q?q.q:0),"V"in q){if(q.V<1||q.V>53)return null;"w"in q||(q.w=1),"Z"in q?(ht=wX(v5(q.y,0,1)),wt=ht.getUTCDay(),ht=wt>4||wt===0?oy.ceil(ht):oy(ht),ht=ny.offset(ht,(q.V-1)*7),q.y=ht.getUTCFullYear(),q.m=ht.getUTCMonth(),q.d=ht.getUTCDate()+(q.w+6)%7):(ht=bX(v5(q.y,0,1)),wt=ht.getDay(),ht=wt>4||wt===0?ry.ceil(ht):ry(ht),ht=ty.offset(ht,(q.V-1)*7),q.y=ht.getFullYear(),q.m=ht.getMonth(),q.d=ht.getDate()+(q.w+6)%7)}else("W"in q||"U"in q)&&("w"in q||(q.w="u"in q?q.u%7:"W"in q?1:0),wt="Z"in q?wX(v5(q.y,0,1)).getUTCDay():bX(v5(q.y,0,1)).getDay(),q.m=0,q.d="W"in q?(q.w+6)%7+q.W*7-(wt+5)%7:q.w+q.U*7-(wt+6)%7);return"Z"in q?(q.H+=q.Z/100|0,q.M+=q.Z%100,wX(q)):bX(q)}}function O(X,et,dt,q){for(var pt=0,ht=et.length,wt=dt.length,kt,ie;pt<ht;){if(q>=wt)return-1;if(kt=et.charCodeAt(pt++),kt===37){if(kt=et.charAt(pt++),ie=C[kt in vwt?et.charAt(pt++):kt],!ie||(q=ie(X,dt,q))<0)return-1}else if(kt!=dt.charCodeAt(q++))return-1}return q}function D(X,et,dt){var q=c.exec(et.slice(dt));return q?(X.p=u[q[0].toLowerCase()],dt+q[0].length):-1}function B(X,et,dt){var q=p.exec(et.slice(dt));return q?(X.w=d[q[0].toLowerCase()],dt+q[0].length):-1}function I(X,et,dt){var q=h.exec(et.slice(dt));return q?(X.w=f[q[0].toLowerCase()],dt+q[0].length):-1}function L(X,et,dt){var q=y.exec(et.slice(dt));return q?(X.m=x[q[0].toLowerCase()],dt+q[0].length):-1}function R(X,et,dt){var q=g.exec(et.slice(dt));return q?(X.m=_[q[0].toLowerCase()],dt+q[0].length):-1}function F(X,et,dt){return O(X,t,et,dt)}function z(X,et,dt){return O(X,r,et,dt)}function U(X,et,dt){return O(X,n,et,dt)}function W(X){return a[X.getDay()]}function Z(X){return o[X.getDay()]}function rt(X){return l[X.getMonth()]}function ot(X){return s[X.getMonth()]}function st(X){return i[+(X.getHours()>=12)]}function St(X){return 1+~~(X.getMonth()/3)}function bt(X){return a[X.getUTCDay()]}function Mt(X){return o[X.getUTCDay()]}function lt(X){return l[X.getUTCMonth()]}function Kt(X){return s[X.getUTCMonth()]}function _t(X){return i[+(X.getUTCHours()>=12)]}function ct(X){return 1+~~(X.getUTCMonth()/3)}return{format:function(X){var et=P(X+="",b);return et.toString=function(){return X},et},parse:function(X){var et=k(X+="",!1);return et.toString=function(){return X},et},utcFormat:function(X){var et=P(X+="",S);return et.toString=function(){return X},et},utcParse:function(X){var et=k(X+="",!0);return et.toString=function(){return X},et}}}var vwt={"-":"",_:" ",0:"0"},xo=/^\s*\d+/,xMe=/^%/,bMe=/[\\^$*+?|[\]().{}]/g;function Br(e,t,r){var n=e<0?"-":"",i=(n?-e:e)+"",o=i.length;return n+(o<r?new Array(r-o+1).join(t)+i:i)}function wMe(e){return e.replace(bMe,"\\$&")}function x5(e){return new RegExp("^(?:"+e.map(wMe).join("|")+")","i")}function b5(e){for(var t={},r=-1,n=e.length;++r<n;)t[e[r].toLowerCase()]=r;return t}function SMe(e,t,r){var n=xo.exec(t.slice(r,r+1));return n?(e.w=+n[0],r+n[0].length):-1}function MMe(e,t,r){var n=xo.exec(t.slice(r,r+1));return n?(e.u=+n[0],r+n[0].length):-1}function EMe(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.U=+n[0],r+n[0].length):-1}function TMe(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.V=+n[0],r+n[0].length):-1}function CMe(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.W=+n[0],r+n[0].length):-1}function xwt(e,t,r){var n=xo.exec(t.slice(r,r+4));return n?(e.y=+n[0],r+n[0].length):-1}function bwt(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.y=+n[0]+(+n[0]>68?1900:2e3),r+n[0].length):-1}function AMe(e,t,r){var n=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(t.slice(r,r+6));return n?(e.Z=n[1]?0:-(n[2]+(n[3]||"00")),r+n[0].length):-1}function PMe(e,t,r){var n=xo.exec(t.slice(r,r+1));return n?(e.q=n[0]*3-3,r+n[0].length):-1}function IMe(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.m=n[0]-1,r+n[0].length):-1}function wwt(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.d=+n[0],r+n[0].length):-1}function LMe(e,t,r){var n=xo.exec(t.slice(r,r+3));return n?(e.m=0,e.d=+n[0],r+n[0].length):-1}function Swt(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.H=+n[0],r+n[0].length):-1}function kMe(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.M=+n[0],r+n[0].length):-1}function RMe(e,t,r){var n=xo.exec(t.slice(r,r+2));return n?(e.S=+n[0],r+n[0].length):-1}function NMe(e,t,r){var n=xo.exec(t.slice(r,r+3));return n?(e.L=+n[0],r+n[0].length):-1}function DMe(e,t,r){var n=xo.exec(t.slice(r,r+6));return n?(e.L=Math.floor(n[0]/1e3),r+n[0].length):-1}function OMe(e,t,r){var n=xMe.exec(t.slice(r,r+1));return n?r+n[0].length:-1}function zMe(e,t,r){var n=xo.exec(t.slice(r));return n?(e.Q=+n[0],r+n[0].length):-1}function FMe(e,t,r){var n=xo.exec(t.slice(r));return n?(e.s=+n[0],r+n[0].length):-1}function Mwt(e,t){return Br(e.getDate(),t,2)}function BMe(e,t){return Br(e.getHours(),t,2)}function HMe(e,t){return Br(e.getHours()%12||12,t,2)}function VMe(e,t){return Br(1+ty.count(Gh(e),e),t,3)}function Pwt(e,t){return Br(e.getMilliseconds(),t,3)}function UMe(e,t){return Pwt(e,t)+"000"}function qMe(e,t){return Br(e.getMonth()+1,t,2)}function GMe(e,t){return Br(e.getMinutes(),t,2)}function WMe(e,t){return Br(e.getSeconds(),t,2)}function YMe(e){var t=e.getDay();return t===0?7:t}function jMe(e,t){return Br(rg.count(Gh(e)-1,e),t,2)}function Iwt(e){var t=e.getDay();return t>=4||t===0?zp(e):zp.ceil(e)}function XMe(e,t){return e=Iwt(e),Br(zp.count(Gh(e),e)+(Gh(e).getDay()===4),t,2)}function $Me(e){return e.getDay()}function KMe(e,t){return Br(ry.count(Gh(e)-1,e),t,2)}function ZMe(e,t){return Br(e.getFullYear()%100,t,2)}function JMe(e,t){return e=Iwt(e),Br(e.getFullYear()%100,t,2)}function QMe(e,t){return Br(e.getFullYear()%1e4,t,4)}function tEe(e,t){var r=e.getDay();return e=r>=4||r===0?zp(e):zp.ceil(e),Br(e.getFullYear()%1e4,t,4)}function eEe(e){var t=e.getTimezoneOffset();return(t>0?"-":(t*=-1,"+"))+Br(t/60|0,"0",2)+Br(t%60,"0",2)}function Ewt(e,t){return Br(e.getUTCDate(),t,2)}function rEe(e,t){return Br(e.getUTCHours(),t,2)}function nEe(e,t){return Br(e.getUTCHours()%12||12,t,2)}function iEe(e,t){return Br(1+ny.count(Wh(e),e),t,3)}function Lwt(e,t){return Br(e.getUTCMilliseconds(),t,3)}function oEe(e,t){return Lwt(e,t)+"000"}function aEe(e,t){return Br(e.getUTCMonth()+1,t,2)}function sEe(e,t){return Br(e.getUTCMinutes(),t,2)}function lEe(e,t){return Br(e.getUTCSeconds(),t,2)}function cEe(e){var t=e.getUTCDay();return t===0?7:t}function uEe(e,t){return Br(ng.count(Wh(e)-1,e),t,2)}function kwt(e){var t=e.getUTCDay();return t>=4||t===0?Fp(e):Fp.ceil(e)}function hEe(e,t){return e=kwt(e),Br(Fp.count(Wh(e),e)+(Wh(e).getUTCDay()===4),t,2)}function fEe(e){return e.getUTCDay()}function pEe(e,t){return Br(oy.count(Wh(e)-1,e),t,2)}function dEe(e,t){return Br(e.getUTCFullYear()%100,t,2)}function mEe(e,t){return e=kwt(e),Br(e.getUTCFullYear()%100,t,2)}function gEe(e,t){return Br(e.getUTCFullYear()%1e4,t,4)}function _Ee(e,t){var r=e.getUTCDay();return e=r>=4||r===0?Fp(e):Fp.ceil(e),Br(e.getUTCFullYear()%1e4,t,4)}function yEe(){return"+0000"}function Twt(){return"%"}function Cwt(e){return+e}function Awt(e){return Math.floor(+e/1e3)}var Wb,S5,SX,ay,M5;w8({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]});function w8(e){return Wb=w5(e),S5=Wb.format,SX=Wb.parse,ay=Wb.utcFormat,M5=Wb.utcParse,Wb}var MX="%Y-%m-%dT%H:%M:%S.%LZ";function vEe(e){return e.toISOString()}var xEe=Date.prototype.toISOString?vEe:ay(MX),Rwt=xEe;function bEe(e){var t=new Date(e);return isNaN(t)?null:t}var wEe=+new Date("2000-01-01T00:00:00.000Z")?bEe:M5(MX),Nwt=wEe;var E5=1e3,T5=E5*60,C5=T5*60,A5=C5*24,SEe=A5*7,Dwt=A5*30,EX=A5*365;function MEe(e){return new Date(e)}function EEe(e){return e instanceof Date?+e:+new Date(+e)}function S8(e,t,r,n,i,o,a,s,l){var c=m5(ii,ii),u=c.invert,h=c.domain,f=l(".%L"),p=l(":%S"),d=l("%I:%M"),g=l("%I %p"),_=l("%a %d"),y=l("%b %d"),x=l("%B"),b=l("%Y"),S=[[a,1,E5],[a,5,5*E5],[a,15,15*E5],[a,30,30*E5],[o,1,T5],[o,5,5*T5],[o,15,15*T5],[o,30,30*T5],[i,1,C5],[i,3,3*C5],[i,6,6*C5],[i,12,12*C5],[n,1,A5],[n,2,2*A5],[r,1,SEe],[t,1,Dwt],[t,3,3*Dwt],[e,1,EX]];function C(k){return(a(k)<k?f:o(k)<k?p:i(k)<k?d:n(k)<k?g:t(k)<k?r(k)<k?_:y:e(k)<k?x:b)(k)}function P(k,O,D,B){if(k==null&&(k=10),typeof k=="number"){var I=Math.abs(D-O)/k,L=ob(function(R){return R[2]}).right(S,I);L===S.length?(B=tl(O/EX,D/EX,k),k=e):L?(L=S[I/S[L-1][2]<S[L][2]/I?L-1:L],B=L[1],k=L[0]):(B=Math.max(tl(O,D,k),1),k=s)}return B==null?k:k.every(B)}return c.invert=function(k){return new Date(u(k))},c.domain=function(k){return arguments.length?h(X_.call(k,EEe)):h().map(MEe)},c.ticks=function(k,O){var D=h(),B=D[0],I=D[D.length-1],L=I<B,R;return L&&(R=B,B=I,I=R),R=P(k,B,I,O),R=R?R.range(B,I+1):[],L?R.reverse():R},c.tickFormat=function(k,O){return O==null?C:l(O)},c.nice=function(k,O){var D=h();return(k=P(k,D[0],D[D.length-1],O))?h(u8(D,k)):c},c.copy=function(){return qh(c,S8(e,t,r,n,i,o,a,s,l))},c}function Yb(){return fi.apply(S8(Gh,y8,rg,ty,_8,g8,Q_,Z_,S5).domain([new Date(2e3,0,1),new Date(2e3,0,2)]),arguments)}function Owt(){return fi.apply(S8(Wh,b8,ng,ny,x8,v8,Q_,Z_,ay).domain([Date.UTC(2e3,0,1),Date.UTC(2e3,0,2)]),arguments)}function M8(){var e=0,t=1,r,n,i,o,a=ii,s=!1,l;function c(u){return isNaN(u=+u)?l:a(i===0?.5:(u=(o(u)-r)*i,s?Math.max(0,Math.min(1,u)):u))}return c.domain=function(u){return arguments.length?(r=o(e=+u[0]),n=o(t=+u[1]),i=r===n?0:1/(n-r),c):[e,t]},c.clamp=function(u){return arguments.length?(s=!!u,c):s},c.interpolator=function(u){return arguments.length?(a=u,c):a},c.unknown=function(u){return arguments.length?(l=u,c):l},function(u){return o=u,r=u(e),n=u(t),i=r===n?0:1/(n-r),c}}function Bp(e,t){return t.domain(e.domain()).interpolator(e.interpolator()).clamp(e.clamp()).unknown(e.unknown())}function E8(){var e=il(M8()(ii));return e.copy=function(){return Bp(e,E8())},sc.apply(e,arguments)}function TX(){var e=g5(M8()).domain([1,10]);return e.copy=function(){return Bp(e,TX()).base(e.base())},sc.apply(e,arguments)}function CX(){var e=_5(M8());return e.copy=function(){return Bp(e,CX()).constant(e.constant())},sc.apply(e,arguments)}function T8(){var e=y5(M8());return e.copy=function(){return Bp(e,T8()).exponent(e.exponent())},sc.apply(e,arguments)}function zwt(){return T8.apply(null,arguments).exponent(.5)}function C8(){var e=[],t=ii;function r(n){if(!isNaN(n=+n))return t((ys(e,n)-1)/(e.length-1))}return r.domain=function(n){if(!arguments.length)return e.slice();e=[];for(var i=0,o=n.length,a;i<o;++i)a=n[i],a!=null&&!isNaN(a=+a)&&e.push(a);return e.sort(oa),r},r.interpolator=function(n){return arguments.length?(t=n,r):t},r.copy=function(){return C8(t).domain(e)},sc.apply(r,arguments)}function A8(){var e=0,t=.5,r=1,n,i,o,a,s,l=ii,c,u=!1,h;function f(p){return isNaN(p=+p)?h:(p=.5+((p=+c(p))-i)*(p<i?a:s),l(u?Math.max(0,Math.min(1,p)):p))}return f.domain=function(p){return arguments.length?(n=c(e=+p[0]),i=c(t=+p[1]),o=c(r=+p[2]),a=n===i?0:.5/(i-n),s=i===o?0:.5/(o-i),f):[e,t,r]},f.clamp=function(p){return arguments.length?(u=!!p,f):u},f.interpolator=function(p){return arguments.length?(l=p,f):l},f.unknown=function(p){return arguments.length?(h=p,f):h},function(p){return c=p,n=p(e),i=p(t),o=p(r),a=n===i?0:.5/(i-n),s=i===o?0:.5/(o-i),f}}function P8(){var e=il(A8()(ii));return e.copy=function(){return Bp(e,P8())},sc.apply(e,arguments)}function AX(){var e=g5(A8()).domain([.1,1,10]);return e.copy=function(){return Bp(e,AX()).base(e.base())},sc.apply(e,arguments)}function PX(){var e=_5(A8());return e.copy=function(){return Bp(e,PX()).constant(e.constant())},sc.apply(e,arguments)}function I8(){var e=y5(A8());return e.copy=function(){return Bp(e,I8()).exponent(e.exponent())},sc.apply(e,arguments)}function Fwt(){return I8.apply(null,arguments).exponent(.5)}function te(e){for(var t=e.length/6|0,r=new Array(t),n=0;n<t;)r[n]="#"+e.slice(n*6,++n*6);return r}var jb=te("1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf");var Bwt=te("7fc97fbeaed4fdc086ffff99386cb0f0027fbf5b17666666");var Hwt=te("1b9e77d95f027570b3e7298a66a61ee6ab02a6761d666666");var Vwt=te("a6cee31f78b4b2df8a33a02cfb9a99e31a1cfdbf6fff7f00cab2d66a3d9affff99b15928");var Uwt=te("fbb4aeb3cde3ccebc5decbe4fed9a6ffffcce5d8bdfddaecf2f2f2");var qwt=te("b3e2cdfdcdaccbd5e8f4cae4e6f5c9fff2aef1e2cccccccc");var Gwt=te("e41a1c377eb84daf4a984ea3ff7f00ffff33a65628f781bf999999");var Wwt=te("66c2a5fc8d628da0cbe78ac3a6d854ffd92fe5c494b3b3b3");var Ywt=te("8dd3c7ffffb3bebadafb807280b1d3fdb462b3de69fccde5d9d9d9bc80bdccebc5ffed6f");var jwt=te("4e79a7f28e2ce1575976b7b259a14fedc949af7aa1ff9da79c755fbab0ab");function Ie(e){return cL(e[e.length-1])}var IX=new Array(3).concat("d8b365f5f5f55ab4ac","a6611adfc27d80cdc1018571","a6611adfc27df5f5f580cdc1018571","8c510ad8b365f6e8c3c7eae55ab4ac01665e","8c510ad8b365f6e8c3f5f5f5c7eae55ab4ac01665e","8c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e","8c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e","5430058c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e003c30","5430058c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e003c30").map(te),Xwt=Ie(IX);var LX=new Array(3).concat("af8dc3f7f7f77fbf7b","7b3294c2a5cfa6dba0008837","7b3294c2a5cff7f7f7a6dba0008837","762a83af8dc3e7d4e8d9f0d37fbf7b1b7837","762a83af8dc3e7d4e8f7f7f7d9f0d37fbf7b1b7837","762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b7837","762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b7837","40004b762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b783700441b","40004b762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b783700441b").map(te),$wt=Ie(LX);var kX=new Array(3).concat("e9a3c9f7f7f7a1d76a","d01c8bf1b6dab8e1864dac26","d01c8bf1b6daf7f7f7b8e1864dac26","c51b7de9a3c9fde0efe6f5d0a1d76a4d9221","c51b7de9a3c9fde0eff7f7f7e6f5d0a1d76a4d9221","c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221","c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221","8e0152c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221276419","8e0152c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221276419").map(te),Kwt=Ie(kX);var RX=new Array(3).concat("998ec3f7f7f7f1a340","5e3c99b2abd2fdb863e66101","5e3c99b2abd2f7f7f7fdb863e66101","542788998ec3d8daebfee0b6f1a340b35806","542788998ec3d8daebf7f7f7fee0b6f1a340b35806","5427888073acb2abd2d8daebfee0b6fdb863e08214b35806","5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b35806","2d004b5427888073acb2abd2d8daebfee0b6fdb863e08214b358067f3b08","2d004b5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b358067f3b08").map(te),Zwt=Ie(RX);var NX=new Array(3).concat("ef8a62f7f7f767a9cf","ca0020f4a58292c5de0571b0","ca0020f4a582f7f7f792c5de0571b0","b2182bef8a62fddbc7d1e5f067a9cf2166ac","b2182bef8a62fddbc7f7f7f7d1e5f067a9cf2166ac","b2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac","b2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac","67001fb2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac053061","67001fb2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac053061").map(te),Jwt=Ie(NX);var DX=new Array(3).concat("ef8a62ffffff999999","ca0020f4a582bababa404040","ca0020f4a582ffffffbababa404040","b2182bef8a62fddbc7e0e0e09999994d4d4d","b2182bef8a62fddbc7ffffffe0e0e09999994d4d4d","b2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d","b2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d","67001fb2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d1a1a1a","67001fb2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d1a1a1a").map(te),Qwt=Ie(DX);var OX=new Array(3).concat("fc8d59ffffbf91bfdb","d7191cfdae61abd9e92c7bb6","d7191cfdae61ffffbfabd9e92c7bb6","d73027fc8d59fee090e0f3f891bfdb4575b4","d73027fc8d59fee090ffffbfe0f3f891bfdb4575b4","d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4","d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4","a50026d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4313695","a50026d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4313695").map(te),tSt=Ie(OX);var zX=new Array(3).concat("fc8d59ffffbf91cf60","d7191cfdae61a6d96a1a9641","d7191cfdae61ffffbfa6d96a1a9641","d73027fc8d59fee08bd9ef8b91cf601a9850","d73027fc8d59fee08bffffbfd9ef8b91cf601a9850","d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850","d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850","a50026d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850006837","a50026d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850006837").map(te),eSt=Ie(zX);var FX=new Array(3).concat("fc8d59ffffbf99d594","d7191cfdae61abdda42b83ba","d7191cfdae61ffffbfabdda42b83ba","d53e4ffc8d59fee08be6f59899d5943288bd","d53e4ffc8d59fee08bffffbfe6f59899d5943288bd","d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd","d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd","9e0142d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd5e4fa2","9e0142d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd5e4fa2").map(te),rSt=Ie(FX);var BX=new Array(3).concat("e5f5f999d8c92ca25f","edf8fbb2e2e266c2a4238b45","edf8fbb2e2e266c2a42ca25f006d2c","edf8fbccece699d8c966c2a42ca25f006d2c","edf8fbccece699d8c966c2a441ae76238b45005824","f7fcfde5f5f9ccece699d8c966c2a441ae76238b45005824","f7fcfde5f5f9ccece699d8c966c2a441ae76238b45006d2c00441b").map(te),nSt=Ie(BX);var HX=new Array(3).concat("e0ecf49ebcda8856a7","edf8fbb3cde38c96c688419d","edf8fbb3cde38c96c68856a7810f7c","edf8fbbfd3e69ebcda8c96c68856a7810f7c","edf8fbbfd3e69ebcda8c96c68c6bb188419d6e016b","f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d6e016b","f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d810f7c4d004b").map(te),iSt=Ie(HX);var VX=new Array(3).concat("e0f3dba8ddb543a2ca","f0f9e8bae4bc7bccc42b8cbe","f0f9e8bae4bc7bccc443a2ca0868ac","f0f9e8ccebc5a8ddb57bccc443a2ca0868ac","f0f9e8ccebc5a8ddb57bccc44eb3d32b8cbe08589e","f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe08589e","f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe0868ac084081").map(te),oSt=Ie(VX);var UX=new Array(3).concat("fee8c8fdbb84e34a33","fef0d9fdcc8afc8d59d7301f","fef0d9fdcc8afc8d59e34a33b30000","fef0d9fdd49efdbb84fc8d59e34a33b30000","fef0d9fdd49efdbb84fc8d59ef6548d7301f990000","fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301f990000","fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301fb300007f0000").map(te),aSt=Ie(UX);var qX=new Array(3).concat("ece2f0a6bddb1c9099","f6eff7bdc9e167a9cf02818a","f6eff7bdc9e167a9cf1c9099016c59","f6eff7d0d1e6a6bddb67a9cf1c9099016c59","f6eff7d0d1e6a6bddb67a9cf3690c002818a016450","fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016450","fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016c59014636").map(te),sSt=Ie(qX);var GX=new Array(3).concat("ece7f2a6bddb2b8cbe","f1eef6bdc9e174a9cf0570b0","f1eef6bdc9e174a9cf2b8cbe045a8d","f1eef6d0d1e6a6bddb74a9cf2b8cbe045a8d","f1eef6d0d1e6a6bddb74a9cf3690c00570b0034e7b","fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0034e7b","fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0045a8d023858").map(te),lSt=Ie(GX);var WX=new Array(3).concat("e7e1efc994c7dd1c77","f1eef6d7b5d8df65b0ce1256","f1eef6d7b5d8df65b0dd1c77980043","f1eef6d4b9dac994c7df65b0dd1c77980043","f1eef6d4b9dac994c7df65b0e7298ace125691003f","f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125691003f","f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125698004367001f").map(te),cSt=Ie(WX);var YX=new Array(3).concat("fde0ddfa9fb5c51b8a","feebe2fbb4b9f768a1ae017e","feebe2fbb4b9f768a1c51b8a7a0177","feebe2fcc5c0fa9fb5f768a1c51b8a7a0177","feebe2fcc5c0fa9fb5f768a1dd3497ae017e7a0177","fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a0177","fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a017749006a").map(te),uSt=Ie(YX);var jX=new Array(3).concat("edf8b17fcdbb2c7fb8","ffffcca1dab441b6c4225ea8","ffffcca1dab441b6c42c7fb8253494","ffffccc7e9b47fcdbb41b6c42c7fb8253494","ffffccc7e9b47fcdbb41b6c41d91c0225ea80c2c84","ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea80c2c84","ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea8253494081d58").map(te),hSt=Ie(jX);var XX=new Array(3).concat("f7fcb9addd8e31a354","ffffccc2e69978c679238443","ffffccc2e69978c67931a354006837","ffffccd9f0a3addd8e78c67931a354006837","ffffccd9f0a3addd8e78c67941ab5d238443005a32","ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443005a32","ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443006837004529").map(te),fSt=Ie(XX);var $X=new Array(3).concat("fff7bcfec44fd95f0e","ffffd4fed98efe9929cc4c02","ffffd4fed98efe9929d95f0e993404","ffffd4fee391fec44ffe9929d95f0e993404","ffffd4fee391fec44ffe9929ec7014cc4c028c2d04","ffffe5fff7bcfee391fec44ffe9929ec7014cc4c028c2d04","ffffe5fff7bcfee391fec44ffe9929ec7014cc4c02993404662506").map(te),pSt=Ie($X);var KX=new Array(3).concat("ffeda0feb24cf03b20","ffffb2fecc5cfd8d3ce31a1c","ffffb2fecc5cfd8d3cf03b20bd0026","ffffb2fed976feb24cfd8d3cf03b20bd0026","ffffb2fed976feb24cfd8d3cfc4e2ae31a1cb10026","ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cb10026","ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cbd0026800026").map(te),dSt=Ie(KX);var ZX=new Array(3).concat("deebf79ecae13182bd","eff3ffbdd7e76baed62171b5","eff3ffbdd7e76baed63182bd08519c","eff3ffc6dbef9ecae16baed63182bd08519c","eff3ffc6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b508519c08306b").map(te),mSt=Ie(ZX);var JX=new Array(3).concat("e5f5e0a1d99b31a354","edf8e9bae4b374c476238b45","edf8e9bae4b374c47631a354006d2c","edf8e9c7e9c0a1d99b74c47631a354006d2c","edf8e9c7e9c0a1d99b74c47641ab5d238b45005a32","f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45005a32","f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45006d2c00441b").map(te),gSt=Ie(JX);var QX=new Array(3).concat("f0f0f0bdbdbd636363","f7f7f7cccccc969696525252","f7f7f7cccccc969696636363252525","f7f7f7d9d9d9bdbdbd969696636363252525","f7f7f7d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525000000").map(te),_St=Ie(QX);var t$=new Array(3).concat("efedf5bcbddc756bb1","f2f0f7cbc9e29e9ac86a51a3","f2f0f7cbc9e29e9ac8756bb154278f","f2f0f7dadaebbcbddc9e9ac8756bb154278f","f2f0f7dadaebbcbddc9e9ac8807dba6a51a34a1486","fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a34a1486","fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a354278f3f007d").map(te),ySt=Ie(t$);var e$=new Array(3).concat("fee0d2fc9272de2d26","fee5d9fcae91fb6a4acb181d","fee5d9fcae91fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181da50f1567000d").map(te),vSt=Ie(e$);var r$=new Array(3).concat("fee6cefdae6be6550d","feeddefdbe85fd8d3cd94701","feeddefdbe85fd8d3ce6550da63603","feeddefdd0a2fdae6bfd8d3ce6550da63603","feeddefdd0a2fdae6bfd8d3cf16913d948018c2d04","fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d948018c2d04","fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d94801a636037f2704").map(te),xSt=Ie(r$);function bSt(e){return e=Math.max(0,Math.min(1,e)),"rgb("+Math.max(0,Math.min(255,Math.round(-4.54-e*(35.34-e*(2381.73-e*(6402.7-e*(7024.72-e*2710.57)))))))+", "+Math.max(0,Math.min(255,Math.round(32.49+e*(170.73+e*(52.82-e*(131.46-e*(176.58-e*67.37)))))))+", "+Math.max(0,Math.min(255,Math.round(81.24+e*(442.36-e*(2482.43-e*(6167.24-e*(6614.94-e*2475.67)))))))+")"}var wSt=E_(la(300,.5,0),la(-240,.5,1));var SSt=E_(la(-100,.75,.35),la(80,1.5,.8)),MSt=E_(la(260,.75,.35),la(80,1.5,.8)),L8=la();function ESt(e){(e<0||e>1)&&(e-=Math.floor(e));var t=Math.abs(e-.5);return L8.h=360*e-100,L8.s=1.5-1.5*t,L8.l=.8-.9*t,L8+""}var k8=cu(),TEe=Math.PI/3,CEe=Math.PI*2/3;function TSt(e){var t;return e=(.5-e)*Math.PI,k8.r=255*(t=Math.sin(e))*t,k8.g=255*(t=Math.sin(e+TEe))*t,k8.b=255*(t=Math.sin(e+CEe))*t,k8+""}function CSt(e){return e=Math.max(0,Math.min(1,e)),"rgb("+Math.max(0,Math.min(255,Math.round(34.61+e*(1172.33-e*(10793.56-e*(33300.12-e*(38394.49-e*14825.05)))))))+", "+Math.max(0,Math.min(255,Math.round(23.31+e*(557.33+e*(1225.33-e*(3574.96-e*(1073.77+e*707.56)))))))+", "+Math.max(0,Math.min(255,Math.round(27.2+e*(3211.1-e*(15327.97-e*(27814-e*(22569.18-e*6838.66)))))))+")"}function R8(e){var t=e.length;return function(r){return e[Math.max(0,Math.min(t-1,Math.floor(r*t)))]}}var ASt=R8(te("44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725")),PSt=R8(te("00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf")),ISt=R8(te("00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4")),LSt=R8(te("0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921"));function qe(e){return function(){return e}}var n$=Math.abs,Bo=Math.atan2,ig=Math.cos,kSt=Math.max,N8=Math.min,_u=Math.sin,sy=Math.sqrt,bo=1e-12,yu=Math.PI,P5=yu/2,hc=2*yu;function RSt(e){return e>1?0:e<-1?yu:Math.acos(e)}function i$(e){return e>=1?P5:e<=-1?-P5:Math.asin(e)}function AEe(e){return e.innerRadius}function PEe(e){return e.outerRadius}function IEe(e){return e.startAngle}function LEe(e){return e.endAngle}function kEe(e){return e&&e.padAngle}function REe(e,t,r,n,i,o,a,s){var l=r-e,c=n-t,u=a-i,h=s-o,f=h*l-u*c;if(!(f*f<bo))return f=(u*(t-o)-h*(e-i))/f,[e+f*l,t+f*c]}function D8(e,t,r,n,i,o,a){var s=e-r,l=t-n,c=(a?o:-o)/sy(s*s+l*l),u=c*l,h=-c*s,f=e+u,p=t+h,d=r+u,g=n+h,_=(f+d)/2,y=(p+g)/2,x=d-f,b=g-p,S=x*x+b*b,C=i-o,P=f*g-d*p,k=(b<0?-1:1)*sy(kSt(0,C*C*S-P*P)),O=(P*b-x*k)/S,D=(-P*x-b*k)/S,B=(P*b+x*k)/S,I=(-P*x+b*k)/S,L=O-_,R=D-y,F=B-_,z=I-y;return L*L+R*R>F*F+z*z&&(O=B,D=I),{cx:O,cy:D,x01:-u,y01:-h,x11:O*(i/C-1),y11:D*(i/C-1)}}function NSt(){var e=AEe,t=PEe,r=qe(0),n=null,i=IEe,o=LEe,a=kEe,s=null;function l(){var c,u,h=+e.apply(this,arguments),f=+t.apply(this,arguments),p=i.apply(this,arguments)-P5,d=o.apply(this,arguments)-P5,g=n$(d-p),_=d>p;if(s||(s=c=bs()),f<h&&(u=f,f=h,h=u),!(f>bo))s.moveTo(0,0);else if(g>hc-bo)s.moveTo(f*ig(p),f*_u(p)),s.arc(0,0,f,p,d,!_),h>bo&&(s.moveTo(h*ig(d),h*_u(d)),s.arc(0,0,h,d,p,_));else{var y=p,x=d,b=p,S=d,C=g,P=g,k=a.apply(this,arguments)/2,O=k>bo&&(n?+n.apply(this,arguments):sy(h*h+f*f)),D=N8(n$(f-h)/2,+r.apply(this,arguments)),B=D,I=D,L,R;if(O>bo){var F=i$(O/h*_u(k)),z=i$(O/f*_u(k));(C-=F*2)>bo?(F*=_?1:-1,b+=F,S-=F):(C=0,b=S=(p+d)/2),(P-=z*2)>bo?(z*=_?1:-1,y+=z,x-=z):(P=0,y=x=(p+d)/2)}var U=f*ig(y),W=f*_u(y),Z=h*ig(S),rt=h*_u(S);if(D>bo){var ot=f*ig(x),st=f*_u(x),St=h*ig(b),bt=h*_u(b),Mt;if(g<yu&&(Mt=REe(U,W,St,bt,ot,st,Z,rt))){var lt=U-Mt[0],Kt=W-Mt[1],_t=ot-Mt[0],ct=st-Mt[1],X=1/_u(RSt((lt*_t+Kt*ct)/(sy(lt*lt+Kt*Kt)*sy(_t*_t+ct*ct)))/2),et=sy(Mt[0]*Mt[0]+Mt[1]*Mt[1]);B=N8(D,(h-et)/(X-1)),I=N8(D,(f-et)/(X+1))}}P>bo?I>bo?(L=D8(St,bt,U,W,f,I,_),R=D8(ot,st,Z,rt,f,I,_),s.moveTo(L.cx+L.x01,L.cy+L.y01),I<D?s.arc(L.cx,L.cy,I,Bo(L.y01,L.x01),Bo(R.y01,R.x01),!_):(s.arc(L.cx,L.cy,I,Bo(L.y01,L.x01),Bo(L.y11,L.x11),!_),s.arc(0,0,f,Bo(L.cy+L.y11,L.cx+L.x11),Bo(R.cy+R.y11,R.cx+R.x11),!_),s.arc(R.cx,R.cy,I,Bo(R.y11,R.x11),Bo(R.y01,R.x01),!_))):(s.moveTo(U,W),s.arc(0,0,f,y,x,!_)):s.moveTo(U,W),!(h>bo)||!(C>bo)?s.lineTo(Z,rt):B>bo?(L=D8(Z,rt,ot,st,h,-B,_),R=D8(U,W,St,bt,h,-B,_),s.lineTo(L.cx+L.x01,L.cy+L.y01),B<D?s.arc(L.cx,L.cy,B,Bo(L.y01,L.x01),Bo(R.y01,R.x01),!_):(s.arc(L.cx,L.cy,B,Bo(L.y01,L.x01),Bo(L.y11,L.x11),!_),s.arc(0,0,h,Bo(L.cy+L.y11,L.cx+L.x11),Bo(R.cy+R.y11,R.cx+R.x11),_),s.arc(R.cx,R.cy,B,Bo(R.y11,R.x11),Bo(R.y01,R.x01),!_))):s.arc(0,0,h,S,b,_)}if(s.closePath(),c)return s=null,c+""||null}return l.centroid=function(){var c=(+e.apply(this,arguments)+ +t.apply(this,arguments))/2,u=(+i.apply(this,arguments)+ +o.apply(this,arguments))/2-yu/2;return[ig(u)*c,_u(u)*c]},l.innerRadius=function(c){return arguments.length?(e=typeof c=="function"?c:qe(+c),l):e},l.outerRadius=function(c){return arguments.length?(t=typeof c=="function"?c:qe(+c),l):t},l.cornerRadius=function(c){return arguments.length?(r=typeof c=="function"?c:qe(+c),l):r},l.padRadius=function(c){return arguments.length?(n=c==null?null:typeof c=="function"?c:qe(+c),l):n},l.startAngle=function(c){return arguments.length?(i=typeof c=="function"?c:qe(+c),l):i},l.endAngle=function(c){return arguments.length?(o=typeof c=="function"?c:qe(+c),l):o},l.padAngle=function(c){return arguments.length?(a=typeof c=="function"?c:qe(+c),l):a},l.context=function(c){return arguments.length?(s=c==null?null:c,l):s},l}function DSt(e){this._context=e}DSt.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;default:this._context.lineTo(e,t);break}}};function Yh(e){return new DSt(e)}function Xb(e){return e[0]}function $b(e){return e[1]}function vu(){var e=Xb,t=$b,r=qe(!0),n=null,i=Yh,o=null;function a(s){var l,c=s.length,u,h=!1,f;for(n==null&&(o=i(f=bs())),l=0;l<=c;++l)!(l<c&&r(u=s[l],l,s))===h&&((h=!h)?o.lineStart():o.lineEnd()),h&&o.point(+e(u,l,s),+t(u,l,s));if(f)return o=null,f+""||null}return a.x=function(s){return arguments.length?(e=typeof s=="function"?s:qe(+s),a):e},a.y=function(s){return arguments.length?(t=typeof s=="function"?s:qe(+s),a):t},a.defined=function(s){return arguments.length?(r=typeof s=="function"?s:qe(!!s),a):r},a.curve=function(s){return arguments.length?(i=s,n!=null&&(o=i(n)),a):i},a.context=function(s){return arguments.length?(s==null?n=o=null:o=i(n=s),a):n},a}function O8(){var e=Xb,t=null,r=qe(0),n=$b,i=qe(!0),o=null,a=Yh,s=null;function l(u){var h,f,p,d=u.length,g,_=!1,y,x=new Array(d),b=new Array(d);for(o==null&&(s=a(y=bs())),h=0;h<=d;++h){if(!(h<d&&i(g=u[h],h,u))===_)if(_=!_)f=h,s.areaStart(),s.lineStart();else{for(s.lineEnd(),s.lineStart(),p=h-1;p>=f;--p)s.point(x[p],b[p]);s.lineEnd(),s.areaEnd()}_&&(x[h]=+e(g,h,u),b[h]=+r(g,h,u),s.point(t?+t(g,h,u):x[h],n?+n(g,h,u):b[h]))}if(y)return s=null,y+""||null}function c(){return vu().defined(i).curve(a).context(o)}return l.x=function(u){return arguments.length?(e=typeof u=="function"?u:qe(+u),t=null,l):e},l.x0=function(u){return arguments.length?(e=typeof u=="function"?u:qe(+u),l):e},l.x1=function(u){return arguments.length?(t=u==null?null:typeof u=="function"?u:qe(+u),l):t},l.y=function(u){return arguments.length?(r=typeof u=="function"?u:qe(+u),n=null,l):r},l.y0=function(u){return arguments.length?(r=typeof u=="function"?u:qe(+u),l):r},l.y1=function(u){return arguments.length?(n=u==null?null:typeof u=="function"?u:qe(+u),l):n},l.lineX0=l.lineY0=function(){return c().x(e).y(r)},l.lineY1=function(){return c().x(e).y(n)},l.lineX1=function(){return c().x(t).y(r)},l.defined=function(u){return arguments.length?(i=typeof u=="function"?u:qe(!!u),l):i},l.curve=function(u){return arguments.length?(a=u,o!=null&&(s=a(o)),l):a},l.context=function(u){return arguments.length?(u==null?o=s=null:s=a(o=u),l):o},l}function OSt(e,t){return t<e?-1:t>e?1:t>=e?0:NaN}function zSt(e){return e}function FSt(){var e=zSt,t=OSt,r=null,n=qe(0),i=qe(hc),o=qe(0);function a(s){var l,c=s.length,u,h,f=0,p=new Array(c),d=new Array(c),g=+n.apply(this,arguments),_=Math.min(hc,Math.max(-hc,i.apply(this,arguments)-g)),y,x=Math.min(Math.abs(_)/c,o.apply(this,arguments)),b=x*(_<0?-1:1),S;for(l=0;l<c;++l)(S=d[p[l]=l]=+e(s[l],l,s))>0&&(f+=S);for(t!=null?p.sort(function(C,P){return t(d[C],d[P])}):r!=null&&p.sort(function(C,P){return r(s[C],s[P])}),l=0,h=f?(_-c*b)/f:0;l<c;++l,g=y)u=p[l],S=d[u],y=g+(S>0?S*h:0)+b,d[u]={data:s[u],index:l,value:S,startAngle:g,endAngle:y,padAngle:x};return d}return a.value=function(s){return arguments.length?(e=typeof s=="function"?s:qe(+s),a):e},a.sortValues=function(s){return arguments.length?(t=s,r=null,a):t},a.sort=function(s){return arguments.length?(r=s,t=null,a):r},a.startAngle=function(s){return arguments.length?(n=typeof s=="function"?s:qe(+s),a):n},a.endAngle=function(s){return arguments.length?(i=typeof s=="function"?s:qe(+s),a):i},a.padAngle=function(s){return arguments.length?(o=typeof s=="function"?s:qe(+s),a):o},a}var z8=Kb(Yh);function BSt(e){this._curve=e}BSt.prototype={areaStart:function(){this._curve.areaStart()},areaEnd:function(){this._curve.areaEnd()},lineStart:function(){this._curve.lineStart()},lineEnd:function(){this._curve.lineEnd()},point:function(e,t){this._curve.point(t*Math.sin(e),t*-Math.cos(e))}};function Kb(e){function t(r){return new BSt(e(r))}return t._curve=e,t}function Zb(e){var t=e.curve;return e.angle=e.x,delete e.x,e.radius=e.y,delete e.y,e.curve=function(r){return arguments.length?t(Kb(r)):t()._curve},e}function o$(){return Zb(vu().curve(z8))}function a$(){var e=O8().curve(z8),t=e.curve,r=e.lineX0,n=e.lineX1,i=e.lineY0,o=e.lineY1;return e.angle=e.x,delete e.x,e.startAngle=e.x0,delete e.x0,e.endAngle=e.x1,delete e.x1,e.radius=e.y,delete e.y,e.innerRadius=e.y0,delete e.y0,e.outerRadius=e.y1,delete e.y1,e.lineStartAngle=function(){return Zb(r())},delete e.lineX0,e.lineEndAngle=function(){return Zb(n())},delete e.lineX1,e.lineInnerRadius=function(){return Zb(i())},delete e.lineY0,e.lineOuterRadius=function(){return Zb(o())},delete e.lineY1,e.curve=function(a){return arguments.length?t(Kb(a)):t()._curve},e}function ly(e,t){return[(t=+t)*Math.cos(e-=Math.PI/2),t*Math.sin(e)]}var I5=Array.prototype.slice;function NEe(e){return e.source}function DEe(e){return e.target}function s$(e){var t=NEe,r=DEe,n=Xb,i=$b,o=null;function a(){var s,l=I5.call(arguments),c=t.apply(this,l),u=r.apply(this,l);if(o||(o=s=bs()),e(o,+n.apply(this,(l[0]=c,l)),+i.apply(this,l),+n.apply(this,(l[0]=u,l)),+i.apply(this,l)),s)return o=null,s+""||null}return a.source=function(s){return arguments.length?(t=s,a):t},a.target=function(s){return arguments.length?(r=s,a):r},a.x=function(s){return arguments.length?(n=typeof s=="function"?s:qe(+s),a):n},a.y=function(s){return arguments.length?(i=typeof s=="function"?s:qe(+s),a):i},a.context=function(s){return arguments.length?(o=s==null?null:s,a):o},a}function OEe(e,t,r,n,i){e.moveTo(t,r),e.bezierCurveTo(t=(t+n)/2,r,t,i,n,i)}function zEe(e,t,r,n,i){e.moveTo(t,r),e.bezierCurveTo(t,r=(r+i)/2,n,r,n,i)}function FEe(e,t,r,n,i){var o=ly(t,r),a=ly(t,r=(r+i)/2),s=ly(n,r),l=ly(n,i);e.moveTo(o[0],o[1]),e.bezierCurveTo(a[0],a[1],s[0],s[1],l[0],l[1])}function HSt(){return s$(OEe)}function VSt(){return s$(zEe)}function USt(){var e=s$(FEe);return e.angle=e.x,delete e.x,e.radius=e.y,delete e.y,e}var L5={draw:function(e,t){var r=Math.sqrt(t/yu);e.moveTo(r,0),e.arc(0,0,r,0,hc)}};var F8={draw:function(e,t){var r=Math.sqrt(t/5)/2;e.moveTo(-3*r,-r),e.lineTo(-r,-r),e.lineTo(-r,-3*r),e.lineTo(r,-3*r),e.lineTo(r,-r),e.lineTo(3*r,-r),e.lineTo(3*r,r),e.lineTo(r,r),e.lineTo(r,3*r),e.lineTo(-r,3*r),e.lineTo(-r,r),e.lineTo(-3*r,r),e.closePath()}};var qSt=Math.sqrt(.3333333333333333),BEe=qSt*2,B8={draw:function(e,t){var r=Math.sqrt(t/BEe),n=r*qSt;e.moveTo(0,-r),e.lineTo(n,0),e.lineTo(0,r),e.lineTo(-n,0),e.closePath()}};var HEe=.8908130915292852,GSt=Math.sin(yu/10)/Math.sin(7*yu/10),VEe=Math.sin(hc/10)*GSt,UEe=-Math.cos(hc/10)*GSt,H8={draw:function(e,t){var r=Math.sqrt(t*HEe),n=VEe*r,i=UEe*r;e.moveTo(0,-r),e.lineTo(n,i);for(var o=1;o<5;++o){var a=hc*o/5,s=Math.cos(a),l=Math.sin(a);e.lineTo(l*r,-s*r),e.lineTo(s*n-l*i,l*n+s*i)}e.closePath()}};var V8={draw:function(e,t){var r=Math.sqrt(t),n=-r/2;e.rect(n,n,r,r)}};var l$=Math.sqrt(3),U8={draw:function(e,t){var r=-Math.sqrt(t/(l$*3));e.moveTo(0,r*2),e.lineTo(-l$*r,-r),e.lineTo(l$*r,-r),e.closePath()}};var fc=-.5,pc=Math.sqrt(3)/2,c$=1/Math.sqrt(12),qEe=(c$/2+1)*3,q8={draw:function(e,t){var r=Math.sqrt(t/qEe),n=r/2,i=r*c$,o=n,a=r*c$+r,s=-o,l=a;e.moveTo(n,i),e.lineTo(o,a),e.lineTo(s,l),e.lineTo(fc*n-pc*i,pc*n+fc*i),e.lineTo(fc*o-pc*a,pc*o+fc*a),e.lineTo(fc*s-pc*l,pc*s+fc*l),e.lineTo(fc*n+pc*i,fc*i-pc*n),e.lineTo(fc*o+pc*a,fc*a-pc*o),e.lineTo(fc*s+pc*l,fc*l-pc*s),e.closePath()}};var WSt=[L5,F8,B8,V8,H8,U8,q8];function YSt(){var e=qe(L5),t=qe(64),r=null;function n(){var i;if(r||(r=i=bs()),e.apply(this,arguments).draw(r,+t.apply(this,arguments)),i)return r=null,i+""||null}return n.type=function(i){return arguments.length?(e=typeof i=="function"?i:qe(i),n):e},n.size=function(i){return arguments.length?(t=typeof i=="function"?i:qe(+i),n):t},n.context=function(i){return arguments.length?(r=i==null?null:i,n):r},n}function dc(){}function Jb(e,t,r){e._context.bezierCurveTo((2*e._x0+e._x1)/3,(2*e._y0+e._y1)/3,(e._x0+2*e._x1)/3,(e._y0+2*e._y1)/3,(e._x0+4*e._x1+t)/6,(e._y0+4*e._y1+r)/6)}function k5(e){this._context=e}k5.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){switch(this._point){case 3:Jb(this,this._x1,this._y1);case 2:this._context.lineTo(this._x1,this._y1);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3,this._context.lineTo((5*this._x0+this._x1)/6,(5*this._y0+this._y1)/6);default:Jb(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}};function G8(e){return new k5(e)}function jSt(e){this._context=e}jSt.prototype={areaStart:dc,areaEnd:dc,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._y0=this._y1=this._y2=this._y3=this._y4=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x2,this._y2),this._context.closePath();break}case 2:{this._context.moveTo((this._x2+2*this._x3)/3,(this._y2+2*this._y3)/3),this._context.lineTo((this._x3+2*this._x2)/3,(this._y3+2*this._y2)/3),this._context.closePath();break}case 3:{this.point(this._x2,this._y2),this.point(this._x3,this._y3),this.point(this._x4,this._y4);break}}},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._x2=e,this._y2=t;break;case 1:this._point=2,this._x3=e,this._y3=t;break;case 2:this._point=3,this._x4=e,this._y4=t,this._context.moveTo((this._x0+4*this._x1+e)/6,(this._y0+4*this._y1+t)/6);break;default:Jb(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}};function XSt(e){return new jSt(e)}function $St(e){this._context=e}$St.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3;var r=(this._x0+4*this._x1+e)/6,n=(this._y0+4*this._y1+t)/6;this._line?this._context.lineTo(r,n):this._context.moveTo(r,n);break;case 3:this._point=4;default:Jb(this,e,t);break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t}};function KSt(e){return new $St(e)}function ZSt(e,t){this._basis=new k5(e),this._beta=t}ZSt.prototype={lineStart:function(){this._x=[],this._y=[],this._basis.lineStart()},lineEnd:function(){var e=this._x,t=this._y,r=e.length-1;if(r>0)for(var n=e[0],i=t[0],o=e[r]-n,a=t[r]-i,s=-1,l;++s<=r;)l=s/r,this._basis.point(this._beta*e[s]+(1-this._beta)*(n+l*o),this._beta*t[s]+(1-this._beta)*(i+l*a));this._x=this._y=null,this._basis.lineEnd()},point:function(e,t){this._x.push(+e),this._y.push(+t)}};var JSt=function e(t){function r(n){return t===1?new k5(n):new ZSt(n,t)}return r.beta=function(n){return e(+n)},r}(.85);function Qb(e,t,r){e._context.bezierCurveTo(e._x1+e._k*(e._x2-e._x0),e._y1+e._k*(e._y2-e._y0),e._x2+e._k*(e._x1-t),e._y2+e._k*(e._y1-r),e._x2,e._y2)}function W8(e,t){this._context=e,this._k=(1-t)/6}W8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:Qb(this,this._x1,this._y1);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2,this._x1=e,this._y1=t;break;case 2:this._point=3;default:Qb(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var QSt=function e(t){function r(n){return new W8(n,t)}return r.tension=function(n){return e(+n)},r}(0);function Y8(e,t){this._context=e,this._k=(1-t)/6}Y8.prototype={areaStart:dc,areaEnd:dc,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x3,this._y3),this._context.closePath();break}case 2:{this._context.lineTo(this._x3,this._y3),this._context.closePath();break}case 3:{this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5);break}}},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._x3=e,this._y3=t;break;case 1:this._point=2,this._context.moveTo(this._x4=e,this._y4=t);break;case 2:this._point=3,this._x5=e,this._y5=t;break;default:Qb(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var t3t=function e(t){function r(n){return new Y8(n,t)}return r.tension=function(n){return e(+n)},r}(0);function j8(e,t){this._context=e,this._k=(1-t)/6}j8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:Qb(this,e,t);break}this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var e3t=function e(t){function r(n){return new j8(n,t)}return r.tension=function(n){return e(+n)},r}(0);function R5(e,t,r){var n=e._x1,i=e._y1,o=e._x2,a=e._y2;if(e._l01_a>bo){var s=2*e._l01_2a+3*e._l01_a*e._l12_a+e._l12_2a,l=3*e._l01_a*(e._l01_a+e._l12_a);n=(n*s-e._x0*e._l12_2a+e._x2*e._l01_2a)/l,i=(i*s-e._y0*e._l12_2a+e._y2*e._l01_2a)/l}if(e._l23_a>bo){var c=2*e._l23_2a+3*e._l23_a*e._l12_a+e._l12_2a,u=3*e._l23_a*(e._l23_a+e._l12_a);o=(o*c+e._x1*e._l23_2a-t*e._l12_2a)/u,a=(a*c+e._y1*e._l23_2a-r*e._l12_2a)/u}e._context.bezierCurveTo(n,i,o,a,e._x2,e._y2)}function r3t(e,t){this._context=e,this._alpha=t}r3t.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:this.point(this._x2,this._y2);break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,n=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+n*n,this._alpha))}switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3;default:R5(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var n3t=function e(t){function r(n){return t?new r3t(n,t):new W8(n,0)}return r.alpha=function(n){return e(+n)},r}(.5);function i3t(e,t){this._context=e,this._alpha=t}i3t.prototype={areaStart:dc,areaEnd:dc,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 1:{this._context.moveTo(this._x3,this._y3),this._context.closePath();break}case 2:{this._context.lineTo(this._x3,this._y3),this._context.closePath();break}case 3:{this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5);break}}},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,n=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+n*n,this._alpha))}switch(this._point){case 0:this._point=1,this._x3=e,this._y3=t;break;case 1:this._point=2,this._context.moveTo(this._x4=e,this._y4=t);break;case 2:this._point=3,this._x5=e,this._y5=t;break;default:R5(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var o3t=function e(t){function r(n){return t?new i3t(n,t):new Y8(n,0)}return r.alpha=function(n){return e(+n)},r}(.5);function a3t(e,t){this._context=e,this._alpha=t}a3t.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){(this._line||this._line!==0&&this._point===3)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){if(e=+e,t=+t,this._point){var r=this._x2-e,n=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(r*r+n*n,this._alpha))}switch(this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:R5(this,e,t);break}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=e,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var s3t=function e(t){function r(n){return t?new a3t(n,t):new j8(n,0)}return r.alpha=function(n){return e(+n)},r}(.5);function l3t(e){this._context=e}l3t.prototype={areaStart:dc,areaEnd:dc,lineStart:function(){this._point=0},lineEnd:function(){this._point&&this._context.closePath()},point:function(e,t){e=+e,t=+t,this._point?this._context.lineTo(e,t):(this._point=1,this._context.moveTo(e,t))}};function c3t(e){return new l3t(e)}function u3t(e){return e<0?-1:1}function h3t(e,t,r){var n=e._x1-e._x0,i=t-e._x1,o=(e._y1-e._y0)/(n||i<0&&-0),a=(r-e._y1)/(i||n<0&&-0),s=(o*i+a*n)/(n+i);return(u3t(o)+u3t(a))*Math.min(Math.abs(o),Math.abs(a),.5*Math.abs(s))||0}function f3t(e,t){var r=e._x1-e._x0;return r?(3*(e._y1-e._y0)/r-t)/2:t}function u$(e,t,r){var n=e._x0,i=e._y0,o=e._x1,a=e._y1,s=(o-n)/3;e._context.bezierCurveTo(n+s,i+s*t,o-s,a-s*r,o,a)}function X8(e){this._context=e}X8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=this._t0=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x1,this._y1);break;case 3:u$(this,this._t0,f3t(this,this._t0));break}(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line=1-this._line},point:function(e,t){var r=NaN;if(e=+e,t=+t,!(e===this._x1&&t===this._y1)){switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;break;case 2:this._point=3,u$(this,f3t(this,r=h3t(this,e,t)),r);break;default:u$(this,this._t0,r=h3t(this,e,t));break}this._x0=this._x1,this._x1=e,this._y0=this._y1,this._y1=t,this._t0=r}}};function p3t(e){this._context=new d3t(e)}(p3t.prototype=Object.create(X8.prototype)).point=function(e,t){X8.prototype.point.call(this,t,e)};function d3t(e){this._context=e}d3t.prototype={moveTo:function(e,t){this._context.moveTo(t,e)},closePath:function(){this._context.closePath()},lineTo:function(e,t){this._context.lineTo(t,e)},bezierCurveTo:function(e,t,r,n,i,o){this._context.bezierCurveTo(t,e,n,r,o,i)}};function m3t(e){return new X8(e)}function g3t(e){return new p3t(e)}function y3t(e){this._context=e}y3t.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=[],this._y=[]},lineEnd:function(){var e=this._x,t=this._y,r=e.length;if(r)if(this._line?this._context.lineTo(e[0],t[0]):this._context.moveTo(e[0],t[0]),r===2)this._context.lineTo(e[1],t[1]);else for(var n=_3t(e),i=_3t(t),o=0,a=1;a<r;++o,++a)this._context.bezierCurveTo(n[0][o],i[0][o],n[1][o],i[1][o],e[a],t[a]);(this._line||this._line!==0&&r===1)&&this._context.closePath(),this._line=1-this._line,this._x=this._y=null},point:function(e,t){this._x.push(+e),this._y.push(+t)}};function _3t(e){var t,r=e.length-1,n,i=new Array(r),o=new Array(r),a=new Array(r);for(i[0]=0,o[0]=2,a[0]=e[0]+2*e[1],t=1;t<r-1;++t)i[t]=1,o[t]=4,a[t]=4*e[t]+2*e[t+1];for(i[r-1]=2,o[r-1]=7,a[r-1]=8*e[r-1]+e[r],t=1;t<r;++t)n=i[t]/o[t-1],o[t]-=n,a[t]-=n*a[t-1];for(i[r-1]=a[r-1]/o[r-1],t=r-2;t>=0;--t)i[t]=(a[t]-i[t+1])/o[t];for(o[r-1]=(e[r]+i[r-1])/2,t=0;t<r-1;++t)o[t]=2*e[t+1]-i[t+1];return[i,o]}function v3t(e){return new y3t(e)}function $8(e,t){this._context=e,this._t=t}$8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=this._y=NaN,this._point=0},lineEnd:function(){0<this._t&&this._t<1&&this._point===2&&this._context.lineTo(this._x,this._y),(this._line||this._line!==0&&this._point===1)&&this._context.closePath(),this._line>=0&&(this._t=1-this._t,this._line=1-this._line)},point:function(e,t){switch(e=+e,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(e,t):this._context.moveTo(e,t);break;case 1:this._point=2;default:{if(this._t<=0)this._context.lineTo(this._x,t),this._context.lineTo(e,t);else{var r=this._x*(1-this._t)+e*this._t;this._context.lineTo(r,this._y),this._context.lineTo(r,t)}break}}this._x=e,this._y=t}};function x3t(e){return new $8(e,.5)}function b3t(e){return new $8(e,0)}function w3t(e){return new $8(e,1)}function xu(e,t){if((a=e.length)>1)for(var r=1,n,i,o=e[t[0]],a,s=o.length;r<a;++r)for(i=o,o=e[t[r]],n=0;n<s;++n)o[n][1]+=o[n][0]=isNaN(i[n][1])?i[n][0]:i[n][1]}function bu(e){for(var t=e.length,r=new Array(t);--t>=0;)r[t]=t;return r}function GEe(e,t){return e[t]}function S3t(){var e=qe([]),t=bu,r=xu,n=GEe;function i(o){var a=e.apply(this,arguments),s,l=o.length,c=a.length,u=new Array(c),h;for(s=0;s<c;++s){for(var f=a[s],p=u[s]=new Array(l),d=0,g;d<l;++d)p[d]=g=[0,+n(o[d],f,d,o)],g.data=o[d];p.key=f}for(s=0,h=t(u);s<c;++s)u[h[s]].index=s;return r(u,h),u}return i.keys=function(o){return arguments.length?(e=typeof o=="function"?o:qe(I5.call(o)),i):e},i.value=function(o){return arguments.length?(n=typeof o=="function"?o:qe(+o),i):n},i.order=function(o){return arguments.length?(t=o==null?bu:typeof o=="function"?o:qe(I5.call(o)),i):t},i.offset=function(o){return arguments.length?(r=o==null?xu:o,i):r},i}function M3t(e,t){if((n=e.length)>0){for(var r,n,i=0,o=e[0].length,a;i<o;++i){for(a=r=0;r<n;++r)a+=e[r][i][1]||0;if(a)for(r=0;r<n;++r)e[r][i][1]/=a}xu(e,t)}}function E3t(e,t){if((l=e.length)>0)for(var r,n=0,i,o,a,s,l,c=e[t[0]].length;n<c;++n)for(a=s=0,r=0;r<l;++r)(o=(i=e[t[r]][n])[1]-i[0])>0?(i[0]=a,i[1]=a+=o):o<0?(i[1]=s,i[0]=s+=o):(i[0]=0,i[1]=o)}function T3t(e,t){if((i=e.length)>0){for(var r=0,n=e[t[0]],i,o=n.length;r<o;++r){for(var a=0,s=0;a<i;++a)s+=e[a][r][1]||0;n[r][1]+=n[r][0]=-s/2}xu(e,t)}}function C3t(e,t){if(!(!((a=e.length)>0)||!((o=(i=e[t[0]]).length)>0))){for(var r=0,n=1,i,o,a;n<o;++n){for(var s=0,l=0,c=0;s<a;++s){for(var u=e[t[s]],h=u[n][1]||0,f=u[n-1][1]||0,p=(h-f)/2,d=0;d<s;++d){var g=e[t[d]],_=g[n][1]||0,y=g[n-1][1]||0;p+=_-y}l+=h,c+=p*h}i[n-1][1]+=i[n-1][0]=r,l&&(r-=c/l)}i[n-1][1]+=i[n-1][0]=r,xu(e,t)}}function K8(e){var t=e.map(WEe);return bu(e).sort(function(r,n){return t[r]-t[n]})}function WEe(e){for(var t=-1,r=0,n=e.length,i,o=-1/0;++t<n;)(i=+e[t][1])>o&&(o=i,r=t);return r}function Z8(e){var t=e.map(h$);return bu(e).sort(function(r,n){return t[r]-t[n]})}function h$(e){for(var t=0,r=-1,n=e.length,i;++r<n;)(i=+e[r][1])&&(t+=i);return t}function A3t(e){return Z8(e).reverse()}function P3t(e){var t=e.length,r,n,i=e.map(h$),o=K8(e),a=0,s=0,l=[],c=[];for(r=0;r<t;++r)n=o[r],a<s?(a+=i[n],l.push(n)):(s+=i[n],c.push(n));return c.reverse().concat(l)}function I3t(e){return bu(e).reverse()}function f$(e){return function(){return e}}function L3t(e){return e[0]}function k3t(e){return e[1]}function p$(){this._=null}function t2(e){e.U=e.C=e.L=e.R=e.P=e.N=null}p$.prototype={constructor:p$,insert:function(e,t){var r,n,i;if(e){if(t.P=e,t.N=e.N,e.N&&(e.N.P=t),e.N=t,e.R){for(e=e.R;e.L;)e=e.L;e.L=t}else e.R=t;r=e}else this._?(e=R3t(this._),t.P=null,t.N=e,e.P=e.L=t,r=e):(t.P=t.N=null,this._=t,r=null);for(t.L=t.R=null,t.U=r,t.C=!0,e=t;r&&r.C;)n=r.U,r===n.L?(i=n.R,i&&i.C?(r.C=i.C=!1,n.C=!0,e=n):(e===r.R&&(N5(this,r),e=r,r=e.U),r.C=!1,n.C=!0,D5(this,n))):(i=n.L,i&&i.C?(r.C=i.C=!1,n.C=!0,e=n):(e===r.L&&(D5(this,r),e=r,r=e.U),r.C=!1,n.C=!0,N5(this,n))),r=e.U;this._.C=!1},remove:function(e){e.N&&(e.N.P=e.P),e.P&&(e.P.N=e.N),e.N=e.P=null;var t=e.U,r,n=e.L,i=e.R,o,a;if(n?i?o=R3t(i):o=n:o=i,t?t.L===e?t.L=o:t.R=o:this._=o,n&&i?(a=o.C,o.C=e.C,o.L=n,n.U=o,o!==i?(t=o.U,o.U=e.U,e=o.R,t.L=e,o.R=i,i.U=o):(o.U=t,t=o,e=o.R)):(a=e.C,e=o),e&&(e.U=t),!a){if(e&&e.C){e.C=!1;return}do{if(e===this._)break;if(e===t.L){if(r=t.R,r.C&&(r.C=!1,t.C=!0,N5(this,t),r=t.R),r.L&&r.L.C||r.R&&r.R.C){(!r.R||!r.R.C)&&(r.L.C=!1,r.C=!0,D5(this,r),r=t.R),r.C=t.C,t.C=r.R.C=!1,N5(this,t),e=this._;break}}else if(r=t.L,r.C&&(r.C=!1,t.C=!0,D5(this,t),r=t.L),r.L&&r.L.C||r.R&&r.R.C){(!r.L||!r.L.C)&&(r.R.C=!1,r.C=!0,N5(this,r),r=t.L),r.C=t.C,t.C=r.L.C=!1,D5(this,t),e=this._;break}r.C=!0,e=t,t=t.U}while(!e.C);e&&(e.C=!1)}}};function N5(e,t){var r=t,n=t.R,i=r.U;i?i.L===r?i.L=n:i.R=n:e._=n,n.U=i,r.U=n,r.R=n.L,r.R&&(r.R.U=r),n.L=r}function D5(e,t){var r=t,n=t.L,i=r.U;i?i.L===r?i.L=n:i.R=n:e._=n,n.U=i,r.U=n,r.L=n.R,r.L&&(r.L.U=r),n.R=r}function R3t(e){for(;e.L;)e=e.L;return e}var d$=p$;function e2(e,t,r,n){var i=[null,null],o=wo.push(i)-1;return i.left=e,i.right=t,r&&O5(i,e,t,r),n&&O5(i,t,e,n),Va[e.index].halfedges.push(o),Va[t.index].halfedges.push(o),i}function r2(e,t,r){var n=[t,r];return n.left=e,n}function O5(e,t,r,n){!e[0]&&!e[1]?(e[0]=n,e.left=t,e.right=r):e.left===r?e[1]=n:e[0]=n}function YEe(e,t,r,n,i){var o=e[0],a=e[1],s=o[0],l=o[1],c=a[0],u=a[1],h=0,f=1,p=c-s,d=u-l,g;if(g=t-s,!(!p&&g>0)){if(g/=p,p<0){if(g<h)return;g<f&&(f=g)}else if(p>0){if(g>f)return;g>h&&(h=g)}if(g=n-s,!(!p&&g<0)){if(g/=p,p<0){if(g>f)return;g>h&&(h=g)}else if(p>0){if(g<h)return;g<f&&(f=g)}if(g=r-l,!(!d&&g>0)){if(g/=d,d<0){if(g<h)return;g<f&&(f=g)}else if(d>0){if(g>f)return;g>h&&(h=g)}if(g=i-l,!(!d&&g<0)){if(g/=d,d<0){if(g>f)return;g>h&&(h=g)}else if(d>0){if(g<h)return;g<f&&(f=g)}return!(h>0)&&!(f<1)||(h>0&&(e[0]=[s+h*p,l+h*d]),f<1&&(e[1]=[s+f*p,l+f*d])),!0}}}}}function jEe(e,t,r,n,i){var o=e[1];if(o)return!0;var a=e[0],s=e.left,l=e.right,c=s[0],u=s[1],h=l[0],f=l[1],p=(c+h)/2,d=(u+f)/2,g,_;if(f===u){if(p<t||p>=n)return;if(c>h){if(!a)a=[p,r];else if(a[1]>=i)return;o=[p,i]}else{if(!a)a=[p,i];else if(a[1]<r)return;o=[p,r]}}else if(g=(c-h)/(f-u),_=d-g*p,g<-1||g>1)if(c>h){if(!a)a=[(r-_)/g,r];else if(a[1]>=i)return;o=[(i-_)/g,i]}else{if(!a)a=[(i-_)/g,i];else if(a[1]<r)return;o=[(r-_)/g,r]}else if(u<f){if(!a)a=[t,g*t+_];else if(a[0]>=n)return;o=[n,g*n+_]}else{if(!a)a=[n,g*n+_];else if(a[0]<t)return;o=[t,g*t+_]}return e[0]=a,e[1]=o,!0}function N3t(e,t,r,n){for(var i=wo.length,o;i--;)(!jEe(o=wo[i],e,t,r,n)||!YEe(o,e,t,r,n)||!(Math.abs(o[0][0]-o[1][0])>Hr||Math.abs(o[0][1]-o[1][1])>Hr))&&delete wo[i]}function D3t(e){return Va[e.index]={site:e,halfedges:[]}}function XEe(e,t){var r=e.site,n=t.left,i=t.right;return r===i&&(i=n,n=r),i?Math.atan2(i[1]-n[1],i[0]-n[0]):(r===n?(n=t[1],i=t[0]):(n=t[0],i=t[1]),Math.atan2(n[0]-i[0],i[1]-n[1]))}function m$(e,t){return t[+(t.left!==e.site)]}function $Ee(e,t){return t[+(t.left===e.site)]}function O3t(){for(var e=0,t=Va.length,r,n,i,o;e<t;++e)if((r=Va[e])&&(o=(n=r.halfedges).length)){var a=new Array(o),s=new Array(o);for(i=0;i<o;++i)a[i]=i,s[i]=XEe(r,wo[n[i]]);for(a.sort(function(l,c){return s[c]-s[l]}),i=0;i<o;++i)s[i]=n[a[i]];for(i=0;i<o;++i)n[i]=s[i]}}function z3t(e,t,r,n){var i=Va.length,o,a,s,l,c,u,h,f,p,d,g,_,y=!0;for(o=0;o<i;++o)if(a=Va[o]){for(s=a.site,c=a.halfedges,l=c.length;l--;)wo[c[l]]||c.splice(l,1);for(l=0,u=c.length;l<u;)d=$Ee(a,wo[c[l]]),g=d[0],_=d[1],h=m$(a,wo[c[++l%u]]),f=h[0],p=h[1],(Math.abs(g-f)>Hr||Math.abs(_-p)>Hr)&&(c.splice(l,0,wo.push(r2(s,d,Math.abs(g-e)<Hr&&n-_>Hr?[e,Math.abs(f-e)<Hr?p:n]:Math.abs(_-n)<Hr&&r-g>Hr?[Math.abs(p-n)<Hr?f:r,n]:Math.abs(g-r)<Hr&&_-t>Hr?[r,Math.abs(f-r)<Hr?p:t]:Math.abs(_-t)<Hr&&g-e>Hr?[Math.abs(p-t)<Hr?f:e,t]:null))-1),++u);u&&(y=!1)}if(y){var x,b,S,C=1/0;for(o=0,y=null;o<i;++o)(a=Va[o])&&(s=a.site,x=s[0]-e,b=s[1]-t,S=x*x+b*b,S<C&&(C=S,y=a));if(y){var P=[e,t],k=[e,n],O=[r,n],D=[r,t];y.halfedges.push(wo.push(r2(s=y.site,P,k))-1,wo.push(r2(s,k,O))-1,wo.push(r2(s,O,D))-1,wo.push(r2(s,D,P))-1)}}for(o=0;o<i;++o)(a=Va[o])&&(a.halfedges.length||delete Va[o])}var F3t=[],J8;function KEe(){t2(this),this.x=this.y=this.arc=this.site=this.cy=null}function cy(e){var t=e.P,r=e.N;if(!(!t||!r)){var n=t.site,i=e.site,o=r.site;if(n!==o){var a=i[0],s=i[1],l=n[0]-a,c=n[1]-s,u=o[0]-a,h=o[1]-s,f=2*(l*h-c*u);if(!(f>=-B3t)){var p=l*l+c*c,d=u*u+h*h,g=(h*p-c*d)/f,_=(l*d-u*p)/f,y=F3t.pop()||new KEe;y.arc=e,y.site=i,y.x=g+a,y.y=(y.cy=_+s)+Math.sqrt(g*g+_*_),e.circle=y;for(var x=null,b=n2._;b;)if(y.y<b.y||y.y===b.y&&y.x<=b.x)if(b.L)b=b.L;else{x=b.P;break}else if(b.R)b=b.R;else{x=b;break}n2.insert(x,y),x||(J8=y)}}}}function uy(e){var t=e.circle;t&&(t.P||(J8=t.N),n2.remove(t),F3t.push(t),t2(t),e.circle=null)}var V3t=[];function ZEe(){t2(this),this.edge=this.site=this.circle=null}function H3t(e){var t=V3t.pop()||new ZEe;return t.site=e,t}function g$(e){uy(e),hy.remove(e),V3t.push(e),t2(e)}function U3t(e){var t=e.circle,r=t.x,n=t.cy,i=[r,n],o=e.P,a=e.N,s=[e];g$(e);for(var l=o;l.circle&&Math.abs(r-l.circle.x)<Hr&&Math.abs(n-l.circle.cy)<Hr;)o=l.P,s.unshift(l),g$(l),l=o;s.unshift(l),uy(l);for(var c=a;c.circle&&Math.abs(r-c.circle.x)<Hr&&Math.abs(n-c.circle.cy)<Hr;)a=c.N,s.push(c),g$(c),c=a;s.push(c),uy(c);var u=s.length,h;for(h=1;h<u;++h)c=s[h],l=s[h-1],O5(c.edge,l.site,c.site,i);l=s[0],c=s[u-1],c.edge=e2(l.site,c.site,null,i),cy(l),cy(c)}function q3t(e){for(var t=e[0],r=e[1],n,i,o,a,s=hy._;s;)if(o=G3t(s,r)-t,o>Hr)s=s.L;else if(a=t-JEe(s,r),a>Hr){if(!s.R){n=s;break}s=s.R}else{o>-Hr?(n=s.P,i=s):a>-Hr?(n=s,i=s.N):n=i=s;break}D3t(e);var l=H3t(e);if(hy.insert(n,l),!(!n&&!i)){if(n===i){uy(n),i=H3t(n.site),hy.insert(l,i),l.edge=i.edge=e2(n.site,l.site),cy(n),cy(i);return}if(!i){l.edge=e2(n.site,l.site);return}uy(n),uy(i);var c=n.site,u=c[0],h=c[1],f=e[0]-u,p=e[1]-h,d=i.site,g=d[0]-u,_=d[1]-h,y=2*(f*_-p*g),x=f*f+p*p,b=g*g+_*_,S=[(_*x-p*b)/y+u,(f*b-g*x)/y+h];O5(i.edge,c,d,S),l.edge=e2(c,e,null,S),i.edge=e2(e,d,null,S),cy(n),cy(i)}}function G3t(e,t){var r=e.site,n=r[0],i=r[1],o=i-t;if(!o)return n;var a=e.P;if(!a)return-1/0;r=a.site;var s=r[0],l=r[1],c=l-t;if(!c)return s;var u=s-n,h=1/o-1/c,f=u/c;return h?(-f+Math.sqrt(f*f-2*h*(u*u/(-2*c)-l+c/2+i-o/2)))/h+n:(n+s)/2}function JEe(e,t){var r=e.N;if(r)return G3t(r,t);var n=e.site;return n[1]===t?n[0]:1/0}var Hr=1e-6,B3t=1e-12,hy,Va,n2,wo;function QEe(e,t,r){return(e[0]-r[0])*(t[1]-e[1])-(e[0]-t[0])*(r[1]-e[1])}function t5e(e,t){return t[1]-e[1]||t[0]-e[0]}function z5(e,t){var r=e.sort(t5e).pop(),n,i,o;for(wo=[],Va=new Array(e.length),hy=new d$,n2=new d$;;)if(o=J8,r&&(!o||r[1]<o.y||r[1]===o.y&&r[0]<o.x))(r[0]!==n||r[1]!==i)&&(q3t(r),n=r[0],i=r[1]),r=e.pop();else if(o)U3t(o.arc);else break;if(O3t(),t){var a=+t[0][0],s=+t[0][1],l=+t[1][0],c=+t[1][1];N3t(a,s,l,c),z3t(a,s,l,c)}this.edges=wo,this.cells=Va,hy=n2=wo=Va=null}z5.prototype={constructor:z5,polygons:function(){var e=this.edges;return this.cells.map(function(t){var r=t.halfedges.map(function(n){return m$(t,e[n])});return r.data=t.site.data,r})},triangles:function(){var e=[],t=this.edges;return this.cells.forEach(function(r,n){if(!!(s=(o=r.halfedges).length))for(var i=r.site,o,a=-1,s,l,c=t[o[s-1]],u=c.left===i?c.right:c.left;++a<s;)l=u,c=t[o[a]],u=c.left===i?c.right:c.left,l&&u&&n<l.index&&n<u.index&&QEe(i,l,u)<0&&e.push([i.data,l.data,u.data])}),e},links:function(){return this.edges.filter(function(e){return e.right}).map(function(e){return{source:e.left.data,target:e.right.data}})},find:function(e,t,r){for(var n=this,i,o=n._found||0,a=n.cells.length,s;!(s=n.cells[o]);)if(++o>=a)return null;var l=e-s.site[0],c=t-s.site[1],u=l*l+c*c;do s=n.cells[i=o],o=null,s.halfedges.forEach(function(h){var f=n.edges[h],p=f.left;if(!((p===s.site||!p)&&!(p=f.right))){var d=e-p[0],g=t-p[1],_=d*d+g*g;_<u&&(u=_,o=p.index)}});while(o!==null);return n._found=i,r==null||u<=r*r?s.site:null}};function W3t(){var e=L3t,t=k3t,r=null;function n(i){return new z5(i.map(function(o,a){var s=[Math.round(e(o,a,i)/Hr)*Hr,Math.round(t(o,a,i)/Hr)*Hr];return s.index=a,s.data=o,s}),r)}return n.polygons=function(i){return n(i).polygons()},n.links=function(i){return n(i).links()},n.triangles=function(i){return n(i).triangles()},n.x=function(i){return arguments.length?(e=typeof i=="function"?i:f$(+i),n):e},n.y=function(i){return arguments.length?(t=typeof i=="function"?i:f$(+i),n):t},n.extent=function(i){return arguments.length?(r=i==null?null:[[+i[0][0],+i[0][1]],[+i[1][0],+i[1][1]]],n):r&&[[r[0][0],r[0][1]],[r[1][0],r[1][1]]]},n.size=function(i){return arguments.length?(r=i==null?null:[[0,0],[+i[0],+i[1]]],n):r&&[r[1][0]-r[0][0],r[1][1]-r[0][1]]},n}km();function F5(e){return function(){return e}}function _$(e,t,r){this.target=e,this.type=t,this.transform=r}function jh(e,t,r){this.k=e,this.x=t,this.y=r}jh.prototype={constructor:jh,scale:function(e){return e===1?this:new jh(this.k*e,this.x,this.y)},translate:function(e,t){return e===0&t===0?this:new jh(this.k,this.x+this.k*e,this.y+this.k*t)},apply:function(e){return[e[0]*this.k+this.x,e[1]*this.k+this.y]},applyX:function(e){return e*this.k+this.x},applyY:function(e){return e*this.k+this.y},invert:function(e){return[(e[0]-this.x)/this.k,(e[1]-this.y)/this.k]},invertX:function(e){return(e-this.x)/this.k},invertY:function(e){return(e-this.y)/this.k},rescaleX:function(e){return e.copy().domain(e.range().map(this.invertX,this).map(e.invert,e))},rescaleY:function(e){return e.copy().domain(e.range().map(this.invertY,this).map(e.invert,e))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};var Xh=new jh(1,0,0);i2.prototype=jh.prototype;function i2(e){for(;!e.__zoom;)if(!(e=e.parentNode))return Xh;return e.__zoom}function Q8(){qt.stopImmediatePropagation()}function o2(){qt.preventDefault(),qt.stopImmediatePropagation()}function e5e(){return!qt.ctrlKey&&!qt.button}function r5e(){var e=this;return e instanceof SVGElement?(e=e.ownerSVGElement||e,e.hasAttribute("viewBox")?(e=e.viewBox.baseVal,[[e.x,e.y],[e.x+e.width,e.y+e.height]]):[[0,0],[e.width.baseVal.value,e.height.baseVal.value]]):[[0,0],[e.clientWidth,e.clientHeight]]}function Y3t(){return this.__zoom||Xh}function n5e(){return-qt.deltaY*(qt.deltaMode===1?.05:qt.deltaMode?1:.002)}function i5e(){return navigator.maxTouchPoints||"ontouchstart"in this}function o5e(e,t,r){var n=e.invertX(t[0][0])-r[0][0],i=e.invertX(t[1][0])-r[1][0],o=e.invertY(t[0][1])-r[0][1],a=e.invertY(t[1][1])-r[1][1];return e.translate(i>n?(n+i)/2:Math.min(0,n)||Math.max(0,i),a>o?(o+a)/2:Math.min(0,o)||Math.max(0,a))}function tR(){var e=e5e,t=r5e,r=o5e,n=n5e,i=i5e,o=[0,1/0],a=[[-1/0,-1/0],[1/0,1/0]],s=250,l=yL,c=vs("start","zoom","end"),u,h,f=500,p=150,d=0;function g(L){L.property("__zoom",Y3t).on("wheel.zoom",P).on("mousedown.zoom",k).on("dblclick.zoom",O).filter(i).on("touchstart.zoom",D).on("touchmove.zoom",B).on("touchend.zoom touchcancel.zoom",I).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}g.transform=function(L,R,F){var z=L.selection?L.selection():L;z.property("__zoom",Y3t),L!==z?b(L,R,F):z.interrupt().each(function(){S(this,arguments).start().zoom(null,typeof R=="function"?R.apply(this,arguments):R).end()})},g.scaleBy=function(L,R,F){g.scaleTo(L,function(){var z=this.__zoom.k,U=typeof R=="function"?R.apply(this,arguments):R;return z*U},F)},g.scaleTo=function(L,R,F){g.transform(L,function(){var z=t.apply(this,arguments),U=this.__zoom,W=F==null?x(z):typeof F=="function"?F.apply(this,arguments):F,Z=U.invert(W),rt=typeof R=="function"?R.apply(this,arguments):R;return r(y(_(U,rt),W,Z),z,a)},F)},g.translateBy=function(L,R,F){g.transform(L,function(){return r(this.__zoom.translate(typeof R=="function"?R.apply(this,arguments):R,typeof F=="function"?F.apply(this,arguments):F),t.apply(this,arguments),a)})},g.translateTo=function(L,R,F,z){g.transform(L,function(){var U=t.apply(this,arguments),W=this.__zoom,Z=z==null?x(U):typeof z=="function"?z.apply(this,arguments):z;return r(Xh.translate(Z[0],Z[1]).scale(W.k).translate(typeof R=="function"?-R.apply(this,arguments):-R,typeof F=="function"?-F.apply(this,arguments):-F),U,a)},z)};function _(L,R){return R=Math.max(o[0],Math.min(o[1],R)),R===L.k?L:new jh(R,L.x,L.y)}function y(L,R,F){var z=R[0]-F[0]*L.k,U=R[1]-F[1]*L.k;return z===L.x&&U===L.y?L:new jh(L.k,z,U)}function x(L){return[(+L[0][0]+ +L[1][0])/2,(+L[0][1]+ +L[1][1])/2]}function b(L,R,F){L.on("start.zoom",function(){S(this,arguments).start()}).on("interrupt.zoom end.zoom",function(){S(this,arguments).end()}).tween("zoom",function(){var z=this,U=arguments,W=S(z,U),Z=t.apply(z,U),rt=F==null?x(Z):typeof F=="function"?F.apply(z,U):F,ot=Math.max(Z[1][0]-Z[0][0],Z[1][1]-Z[0][1]),st=z.__zoom,St=typeof R=="function"?R.apply(z,U):R,bt=l(st.invert(rt).concat(ot/st.k),St.invert(rt).concat(ot/St.k));return function(Mt){if(Mt===1)Mt=St;else{var lt=bt(Mt),Kt=ot/lt[2];Mt=new jh(Kt,rt[0]-lt[0]*Kt,rt[1]-lt[1]*Kt)}W.zoom(null,Mt)}})}function S(L,R,F){return!F&&L.__zooming||new C(L,R)}function C(L,R){this.that=L,this.args=R,this.active=0,this.extent=t.apply(L,R),this.taps=0}C.prototype={start:function(){return++this.active===1&&(this.that.__zooming=this,this.emit("start")),this},zoom:function(L,R){return this.mouse&&L!=="mouse"&&(this.mouse[1]=R.invert(this.mouse[0])),this.touch0&&L!=="touch"&&(this.touch0[1]=R.invert(this.touch0[0])),this.touch1&&L!=="touch"&&(this.touch1[1]=R.invert(this.touch1[0])),this.that.__zoom=R,this.emit("zoom"),this},end:function(){return--this.active===0&&(delete this.that.__zooming,this.emit("end")),this},emit:function(L){Mp(new _$(g,L,this.that.__zoom),c.apply,c,[L,this.that,this.args])}};function P(){if(!e.apply(this,arguments))return;var L=S(this,arguments),R=this.__zoom,F=Math.max(o[0],Math.min(o[1],R.k*Math.pow(2,n.apply(this,arguments)))),z=zo(this);if(L.wheel)(L.mouse[0][0]!==z[0]||L.mouse[0][1]!==z[1])&&(L.mouse[1]=R.invert(L.mouse[0]=z)),clearTimeout(L.wheel);else{if(R.k===F)return;L.mouse=[z,R.invert(z)],hu(this),L.start()}o2(),L.wheel=setTimeout(U,p),L.zoom("mouse",r(y(_(R,F),L.mouse[0],L.mouse[1]),L.extent,a));function U(){L.wheel=null,L.end()}}function k(){if(h||!e.apply(this,arguments))return;var L=S(this,arguments,!0),R=Ht(qt.view).on("mousemove.zoom",W,!0).on("mouseup.zoom",Z,!0),F=zo(this),z=qt.clientX,U=qt.clientY;zm(qt.view),Q8(),L.mouse=[F,this.__zoom.invert(F)],hu(this),L.start();function W(){if(o2(),!L.moved){var rt=qt.clientX-z,ot=qt.clientY-U;L.moved=rt*rt+ot*ot>d}L.zoom("mouse",r(y(L.that.__zoom,L.mouse[0]=zo(L.that),L.mouse[1]),L.extent,a))}function Z(){R.on("mousemove.zoom mouseup.zoom",null),Fm(qt.view,L.moved),o2(),L.end()}}function O(){if(!!e.apply(this,arguments)){var L=this.__zoom,R=zo(this),F=L.invert(R),z=L.k*(qt.shiftKey?.5:2),U=r(y(_(L,z),R,F),t.apply(this,arguments),a);o2(),s>0?Ht(this).transition().duration(s).call(b,U,R):Ht(this).call(g.transform,U)}}function D(){if(!!e.apply(this,arguments)){var L=qt.touches,R=L.length,F=S(this,arguments,qt.changedTouches.length===R),z,U,W,Z;for(Q8(),U=0;U<R;++U)W=L[U],Z=Tp(this,L,W.identifier),Z=[Z,this.__zoom.invert(Z),W.identifier],F.touch0?!F.touch1&&F.touch0[2]!==Z[2]&&(F.touch1=Z,F.taps=0):(F.touch0=Z,z=!0,F.taps=1+!!u);u&&(u=clearTimeout(u)),z&&(F.taps<2&&(u=setTimeout(function(){u=null},f)),hu(this),F.start())}}function B(){if(!!this.__zooming){var L=S(this,arguments),R=qt.changedTouches,F=R.length,z,U,W,Z;for(o2(),u&&(u=clearTimeout(u)),L.taps=0,z=0;z<F;++z)U=R[z],W=Tp(this,R,U.identifier),L.touch0&&L.touch0[2]===U.identifier?L.touch0[0]=W:L.touch1&&L.touch1[2]===U.identifier&&(L.touch1[0]=W);if(U=L.that.__zoom,L.touch1){var rt=L.touch0[0],ot=L.touch0[1],st=L.touch1[0],St=L.touch1[1],bt=(bt=st[0]-rt[0])*bt+(bt=st[1]-rt[1])*bt,Mt=(Mt=St[0]-ot[0])*Mt+(Mt=St[1]-ot[1])*Mt;U=_(U,Math.sqrt(bt/Mt)),W=[(rt[0]+st[0])/2,(rt[1]+st[1])/2],Z=[(ot[0]+St[0])/2,(ot[1]+St[1])/2]}else if(L.touch0)W=L.touch0[0],Z=L.touch0[1];else return;L.zoom("touch",r(y(U,W,Z),L.extent,a))}}function I(){if(!!this.__zooming){var L=S(this,arguments),R=qt.changedTouches,F=R.length,z,U;for(Q8(),h&&clearTimeout(h),h=setTimeout(function(){h=null},f),z=0;z<F;++z)U=R[z],L.touch0&&L.touch0[2]===U.identifier?delete L.touch0:L.touch1&&L.touch1[2]===U.identifier&&delete L.touch1;if(L.touch1&&!L.touch0&&(L.touch0=L.touch1,delete L.touch1),L.touch0)L.touch0[1]=this.__zoom.invert(L.touch0[0]);else if(L.end(),L.taps===2){var W=Ht(this).on("dblclick.zoom");W&&W.apply(this,arguments)}}}return g.wheelDelta=function(L){return arguments.length?(n=typeof L=="function"?L:F5(+L),g):n},g.filter=function(L){return arguments.length?(e=typeof L=="function"?L:F5(!!L),g):e},g.touchable=function(L){return arguments.length?(i=typeof L=="function"?L:F5(!!L),g):i},g.extent=function(L){return arguments.length?(t=typeof L=="function"?L:F5([[+L[0][0],+L[0][1]],[+L[1][0],+L[1][1]]]),g):t},g.scaleExtent=function(L){return arguments.length?(o[0]=+L[0],o[1]=+L[1],g):[o[0],o[1]]},g.translateExtent=function(L){return arguments.length?(a[0][0]=+L[0][0],a[1][0]=+L[1][0],a[0][1]=+L[0][1],a[1][1]=+L[1][1],g):[[a[0][0],a[0][1]],[a[1][0],a[1][1]]]},g.constrain=function(L){return arguments.length?(r=L,g):r},g.duration=function(L){return arguments.length?(s=+L,g):s},g.interpolate=function(L){return arguments.length?(l=L,g):l},g.on=function(){var L=c.on.apply(c,arguments);return L===c?g:L},g.clickDistance=function(L){return arguments.length?(d=(L=+L)*L,g):Math.sqrt(d)},g}var j3t=Ee(Oe(),1);var eR=class extends bp{constructor(){super(...arguments),this._experiments=[]}load(){let t=ve().experiments();return this.requestManager.request(t).then(r=>{j3t.isEqual(this._experiments,r)||(this._experiments=r,this.emitChange())})}getExperiments(){return this._experiments.slice()}},rR=new eR;var a5e={googleStandard:["#db4437","#ff7043","#f4b400","#0f9d58","#00796b","#00acc1","#4285f4","#5c6bc0","#ab47bc"],googleCool:["#9e9d24","#0f9d58","#00796b","#00acc1","#4285f4","#5c6bc0","#607d8b"],googleWarm:["#795548","#ab47bc","#f06292","#c2185b","#db4437","#ff7043","#f4b400"],googleColorBlindAssist:["#ff7043","#00ACC1","#AB47BC","#2A56C6","#0b8043","#F7CB4D","#c0ca33","#5e35b1","#A52714"],tensorboardColorBlindAssist:["#ff7043","#0077bb","#cc3311","#33bbee","#ee3377","#009988","#bbbbbb"],colorBlindAssist1:["#4477aa","#44aaaa","#aaaa44","#aa7744","#aa4455","#aa4488"],colorBlindAssist2:["#88ccee","#44aa99","#117733","#999933","#ddcc77","#cc6677","#882255","#aa4499"],colorBlindAssist3:["#332288","#6699cc","#88ccee","#44aa99","#117733","#999933","#ddcc77","#cc6677","#aa4466","#882255","#661100","#aa4499"],colorBlindAssist4:["#4477aa","#66ccee","#228833","#ccbb44","#ee6677","#aa3377","#bbbbbb"],colorBlindAssist5:["#FF6DB6","#920000","#924900","#DBD100","#24FF24","#006DDB","#490092"],mldash:["#E47EAD","#F4640D","#FAA300","#F5E636","#00A077","#0077B8","#00B7ED"]},nR=a5e.tensorboardColorBlindAssist;var y$=class{constructor(t=nR){this.palette=t,this.identifiers=Ji()}setDomain(t){return this.identifiers=Ji(),t.forEach((r,n)=>{this.identifiers.set(r,this.palette[n%this.palette.length])}),this}getColor(t){if(!this.identifiers.has(t))throw new Error(`String ${t} was not in the domain.`);return this.identifiers.get(t)}};function X3t(e,t){let r=new y$;function n(){r.setDomain(t())}return e.addListener(n),n(),i=>r.getColor(i)}var fn=X3t(wp,()=>wp.getRuns()),lQr=X3t(rR,()=>rR.getExperiments().map(({name:e})=>e));var og=Ee(Oe(),1);_s({moduleName:"run-color-style",styleContent:`
    [color-class='light-blue'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-light-blue-500);
      --paper-checkbox-checked-ink-color: var(--paper-light-blue-500);
      --paper-checkbox-unchecked-color: var(--paper-light-blue-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-light-blue-900);
    }
    [color-class='red'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-red-500);
      --paper-checkbox-checked-ink-color: var(--paper-red-500);
      --paper-checkbox-unchecked-color: var(--paper-red-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-red-900);
    }
    [color-class='green'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-green-500);
      --paper-checkbox-checked-ink-color: var(--paper-green-500);
      --paper-checkbox-unchecked-color: var(--paper-green-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-green-900);
    }
    [color-class='purple'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-purple-500);
      --paper-checkbox-checked-ink-color: var(--paper-purple-500);
      --paper-checkbox-unchecked-color: var(--paper-purple-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-purple-900);
    }
    [color-class='teal'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-teal-500);
      --paper-checkbox-checked-ink-color: var(--paper-teal-500);
      --paper-checkbox-unchecked-color: var(--paper-teal-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-teal-900);
    }
    [color-class='pink'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-pink-500);
      --paper-checkbox-checked-ink-color: var(--paper-pink-500);
      --paper-checkbox-unchecked-color: var(--paper-pink-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-pink-900);
    }
    [color-class='orange'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-orange-500);
      --paper-checkbox-checked-ink-color: var(--paper-orange-500);
      --paper-checkbox-unchecked-color: var(--paper-orange-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-orange-900);
    }
    [color-class='brown'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-brown-500);
      --paper-checkbox-checked-ink-color: var(--paper-brown-500);
      --paper-checkbox-unchecked-color: var(--paper-brown-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-brown-900);
    }
    [color-class='indigo'] paper-checkbox {
      --paper-checkbox-checked-color: var(--paper-indigo-500);
      --paper-checkbox-checked-ink-color: var(--paper-indigo-500);
      --paper-checkbox-unchecked-color: var(--paper-indigo-900);
      --paper-checkbox-unchecked-ink-color: var(--paper-indigo-900);
    }
  `});var ol=class extends Gt(mt){constructor(){super(...arguments),this.names=[],this.coloring={getColor:()=>""},this.regex="",this.selectionState={},this.maxNamesToEnableByDefault=40,this._debouncedRegexChange=this._debouncedRegexChangeImpl()}_debouncedRegexChangeImpl(){var t=og.debounce(r=>{this.regex=r},150,{leading:!1});return function(){var r=this.$$("#names-regex").value;r==""?this.async(()=>{this.regex=r},30):t(r)}}get _regex(){var t=this.regex;try{return new RegExp(t)}catch(r){return null}}_setIsolatorIcon(){var i;var t=this.selectionState,r=og.filter(og.values(t)).length,n=Array.prototype.slice.call((i=this.root)==null?void 0:i.querySelectorAll(".isolator"));n.forEach(function(o){r===1&&t[o.name]?o.icon="radio-button-checked":o.icon="radio-button-unchecked"})}computeNamesMatchingRegex(t,r){let n=this._regex;return n?this.names.filter(i=>n.test(i)):this.names}computeOutSelected(t,r){var n=this.selectionState,i=this.maxNamesToEnableByDefault,o=this.namesMatchingRegex.length<=i;return this.namesMatchingRegex.filter(a=>n[a]==null?o:n[a])}synchronizeColors(t){var i,o,a,s;this._setIsolatorIcon(),((o=(i=this.root)==null?void 0:i.querySelectorAll("paper-checkbox"))!=null?o:[]).forEach(l=>{let c=this.coloring.getColor(l.name);l.updateStyles({"--paper-checkbox-checked-color":c,"--paper-checkbox-checked-ink-color":c,"--paper-checkbox-unchecked-color":c,"--paper-checkbox-unchecked-ink-color":c})}),((s=(a=this.root)==null?void 0:a.querySelectorAll(".isolator"))!=null?s:[]).forEach(l=>{let c=this.coloring.getColor(l.name);l.style.color=c}),window.requestAnimationFrame(()=>{this.updateStyles()})}_isolateName(t){var r=t.target.name,n={};this.names.forEach(function(i){n[i]=i==r}),this.selectionState=n}_checkboxChange(t){var r=t.target;let n=og.clone(this.selectionState);n[r.name]=r.checked,this.selectionState=n}_isChecked(t,r){return this.outSelected.indexOf(t)!=-1}toggleAll(){let t=this.namesMatchingRegex.some(n=>this.outSelected.includes(n)),r={};this.names.forEach(n=>{r[n]=!t}),this.selectionState=r}};ol.template=Q`
    <style include="scrollbar-style"></style>
    <style include="run-color-style"></style>

    <paper-input
      id="names-regex"
      no-label-float=""
      label="Write a regex to filter runs"
      value="[[regex]]"
      on-bind-value-changed="_debouncedRegexChange"
    ></paper-input>
    <div id="outer-container" class="scrollbar">
      <template
        is="dom-repeat"
        items="[[namesMatchingRegex]]"
        on-dom-change="synchronizeColors"
      >
        <div class="name-row">
          <div
            class="icon-container checkbox-container vertical-align-container"
          >
            <paper-checkbox
              class="checkbox vertical-align-center"
              id$="checkbox-[[item]]"
              name="[[item]]"
              checked$="[[_isChecked(item, selectionState.*)]]"
              on-change="_checkboxChange"
            ></paper-checkbox>
          </div>
          <div
            class="icon-container isolator-container vertical-align-container"
          >
            <paper-icon-button
              icon="radio-button-unchecked"
              class="isolator vertical-align-center"
              on-tap="_isolateName"
              name="[[item]]"
            ></paper-icon-button>
          </div>
          <div class="item-label-container">
            <span>[[item]]</span>
          </div>
        </div>
      </template>
    </div>
    <style>
      paper-input {
        --paper-input-container-focus-color: var(--tb-orange-strong);
        --paper-input-container-input: {
          font-size: 14px;
        }
        --paper-input-container-label: {
          font-size: 14px;
        }
      }
      :host {
        display: flex;
        flex-direction: column;
        height: 100%;
        overflow: hidden;
      }
      #outer-container {
        contain: content;
        flex-grow: 1;
        flex-shrink: 1;
        overflow-x: hidden;
        overflow-y: auto;
        width: 100%;
        will-change: transform;
        word-wrap: break-word;
      }
      .name-row {
        contain: content;
        padding-top: 5px;
        padding-bottom: 5px;
        display: flex;
        flex-direction: row;
        font-size: 13px;
        word-break: break-all; /* makes wrapping of hyperparam strings better */
      }
      .icon-container {
        flex-grow: 0;
        flex-shrink: 0;
        padding-left: 2px;
      }
      .checkbox {
        padding-left: 2px;
        width: 18px;
        height: 18px;
      }
      .isolator {
        width: 18px;
        height: 18px;
        padding: 0px;
      }
      .isolator-container {
        padding-left: 6px;
        padding-right: 3px;
      }
      .checkbox-container {
        padding-left: 2px;
      }
      .item-label-container {
        padding-left: 5px;
        flex-grow: 1;
        flex-shrink: 1;
        width: 0px; /* hack to get the flex-grow to work properly */
      }
      .tooltip-value-container {
        display: flex;
        justify-content: center;
        flex-grow: 0;
        flex-shrink: 0;
        text-align: right;
        padding-left: 2px;
      }
      .vertical-align-container {
        display: flex;
        justify-content: center;
      }
      .vertical-align-container .vertical-align-center {
        align-self: center;
      }
      .vertical-align-container .vertical-align-top {
        align-self: start;
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],ol.prototype,"names",void 0);E([A({type:Object}),w("design:type",Object)],ol.prototype,"coloring",void 0);E([A({type:String,notify:!0}),w("design:type",String)],ol.prototype,"regex",void 0);E([A({type:Array,computed:"computeNamesMatchingRegex(names.*, _regex)"}),w("design:type",Array)],ol.prototype,"namesMatchingRegex",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],ol.prototype,"selectionState",void 0);E([A({type:Array,notify:!0,computed:"computeOutSelected(namesMatchingRegex.*, selectionState.*)"}),w("design:type",Array)],ol.prototype,"outSelected",void 0);E([A({type:Number}),w("design:type",Number)],ol.prototype,"maxNamesToEnableByDefault",void 0);E([A({type:Object}),w("design:type",Object)],ol.prototype,"_debouncedRegexChange",void 0);E([Rt("regex"),w("design:type",Object),w("design:paramtypes",[])],ol.prototype,"_regex",null);E([Bt("selectionState","names"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],ol.prototype,"_setIsolatorIcon",null);ol=E([yt("tf-multi-checkbox")],ol);var a2=class extends mt{get _parts(){var t=this.value,r=this.delimiterPattern;let n=[];for(;;){let i=new RegExp(r,"g");if(i.test(t),i.lastIndex===0){n.push(t);break}else n.push(t.slice(0,i.lastIndex)),t=t.slice(i.lastIndex)}return n}};a2.template=Q`
    <!--
      This ugly formatting is required to prevent spaces from slipping
      into the HTML.
    -->
    <template is="dom-repeat" items="[[_parts]]" as="part"
      >[[part]]<wbr
    /></template>
  `;E([A({type:String}),w("design:type",String)],a2.prototype,"value",void 0);E([A({type:String}),w("design:type",String)],a2.prototype,"delimiterPattern",void 0);E([Rt("value","delimiterPattern"),w("design:type",Array),w("design:paramtypes",[])],a2.prototype,"_parts",null);a2=E([yt("tf-wbr-string")],a2);var mc=class extends Gt(mt){constructor(){super(...arguments),this.runSelectionState=zW("runSelectionState",{defaultValue:{}}).call(this),this.regexInput=y_("regexInput",{defaultValue:""}).call(this),this._dataLocationClipLength=250,this._dataLocationDelimiterPattern="[/=_,-]",this.coloring={getColor:fn},this._storeRunSelectionState=FW("runSelectionState",{defaultValue:{}}),this._regexObserver=v_("regexInput",{defaultValue:""})}attached(){this._runStoreListener=wp.addListener(()=>{this.set("runs",wp.getRuns())}),this.set("runs",wp.getRuns()),this._envStoreListener=ib.addListener(()=>{this.set("dataLocation",ib.getDataLocation())}),this.set("dataLocation",ib.getDataLocation())}detached(){wp.removeListenerByKey(this._runStoreListener),ib.removeListenerByKey(this._envStoreListener)}_toggleAll(){this.$.multiCheckbox.toggleAll()}get _clippedDataLocation(){var t=this.dataLocation,r=this._dataLocationClipLength;if(t!==void 0)return t.length>r?t.substring(0,r):t}_openDataLocationDialog(t){t.preventDefault(),this.$$("#data-location-dialog").open()}_shouldShowExpandDataLocationButton(t,r){return t&&t.length>r}};mc.template=Q`
    <paper-dialog with-backdrop="" id="data-location-dialog">
      <h2>Data Location</h2>
      <tf-wbr-string
        value="[[dataLocation]]"
        delimiter-pattern="[[_dataLocationDelimiterPattern]]"
      >
      </tf-wbr-string
    ></paper-dialog>
    <div id="top-text">
      <h3 id="tooltip-help" class="tooltip-container">Runs</h3>
    </div>
    <tf-multi-checkbox
      id="multiCheckbox"
      names="[[runs]]"
      selection-state="{{runSelectionState}}"
      out-selected="{{selectedRuns}}"
      regex="{{regexInput}}"
      coloring="[[coloring]]"
    ></tf-multi-checkbox>
    <paper-button class="x-button" id="toggle-all" on-tap="_toggleAll">
      Toggle All Runs
    </paper-button>
    <template is="dom-if" if="[[dataLocation]]">
      <div id="data-location">
        <tf-wbr-string
          value="[[_clippedDataLocation]]"
          delimiter-pattern="[[_dataLocationDelimiterPattern]]"
        ></tf-wbr-string
        ><!--
          We use HTML comments to remove spaces before the ellipsis.
        --><template
          is="dom-if"
          if="[[_shouldShowExpandDataLocationButton(dataLocation, _dataLocationClipLength)]]"
          ><!--
          --><a href="" on-click="_openDataLocationDialog">…</a>
        </template>
      </div>
    </template>
    <style>
      :host {
        box-sizing: border-box;
        display: flex;
        flex-direction: column;
        padding-bottom: 10px;
      }
      #top-text {
        color: var(--tb-secondary-text-color);
        width: 100%;
        flex-grow: 0;
        flex-shrink: 0;
        padding-right: 16px;
        box-sizing: border-box;
      }
      tf-wbr-string {
        overflow-wrap: break-word;
      }
      tf-multi-checkbox {
        display: flex;
        flex-grow: 1;
        flex-shrink: 1;
        overflow: hidden;
      }
      .x-button {
        font-size: 13px;
        background-color: var(--tb-ui-light-accent);
        color: var(--tb-ui-dark-accent);
      }
      #tooltip-help {
        color: var(--tb-secondary-text-color);
        margin: 0;
        font-weight: normal;
        font-size: 14px;
        margin-bottom: 5px;
      }
      paper-button {
        margin-left: 0;
      }
      #data-location {
        color: var(--tb-ui-dark-accent);
        font-size: 13px;
        margin: 5px 0 0 0;
        max-width: 288px;
      }
    </style>
  `;E([A({type:Object,observer:"_storeRunSelectionState"}),w("design:type",Object)],mc.prototype,"runSelectionState",void 0);E([A({type:String,observer:"_regexObserver"}),w("design:type",String)],mc.prototype,"regexInput",void 0);E([A({type:Array,notify:!0}),w("design:type",Array)],mc.prototype,"selectedRuns",void 0);E([A({type:Array}),w("design:type",Array)],mc.prototype,"runs",void 0);E([A({type:String,notify:!0}),w("design:type",String)],mc.prototype,"dataLocation",void 0);E([A({type:Number}),w("design:type",Number)],mc.prototype,"_dataLocationClipLength",void 0);E([A({type:String}),w("design:type",String)],mc.prototype,"_dataLocationDelimiterPattern",void 0);E([A({type:Object}),w("design:type",Object)],mc.prototype,"coloring",void 0);E([Rt("dataLocation","_dataLocationClipLength"),w("design:type",Object),w("design:paramtypes",[])],mc.prototype,"_clippedDataLocation",null);mc=E([yt("tf-runs-selector")],mc);var an=class{constructor(){this.cancellationCount=0}cancellable(t){let r=this.cancellationCount;return n=>{let i=this.cancellationCount!==r;return t({value:n,cancelled:i})}}cancelAll(){this.cancellationCount++}};var B5=class extends Gt(mt){constructor(){super(...arguments),this.html=""}get sanitizedHtml(){return this.html}attached(){window.requestAnimationFrame(()=>{this.scopeSubtree(this.$.markdown,!0)})}};B5.template=Q`
    <div id="markdown" inner-h-t-m-l="[[sanitizedHtml]]"></div>
    <style>
      /*
       * Reduce topmost and bottommost margins from 16px to 0.3em (renders
       * at about 4.8px) to keep the layout compact. This improves the
       * appearance when there is only one line of text; standard Markdown
       * renderers will still include a \`<p>\` element.
       *
       * By targeting only the top-level, extremal elements, we preserve any
       * actual paragraph breaks and only change the padding against the
       * component edges.
       */
      #markdown > p:first-child {
        margin-top: 0.3em;
      }
      #markdown > p:last-child {
        margin-bottom: 0.3em;
      }

      /* Pleasant styles for Markdown tables. */
      #markdown table {
        border-collapse: collapse;
      }
      #markdown table th {
        font-weight: 600;
      }
      #markdown table th,
      #markdown table td {
        padding: 6px 13px;
        border: 1px solid var(--tb-ui-border, #dfe2e5);
      }
      #markdown table tr {
        background-color: inherit;
        border-top: 1px solid var(--tb-ui-border, #c6cbd1);
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],B5.prototype,"html",void 0);E([Rt("html"),w("design:type",Object),w("design:paramtypes",[])],B5.prototype,"sanitizedHtml",null);B5=E([yt("tf-markdown-view")],B5);_s({moduleName:"tf-card-heading-style",styleContent:`
    figcaption {
      width: 100%;
    }

    /** Horizontal line of labels. */
    .heading-row {
      margin-top: -4px;
      display: flex;
      flex-direction: row;
      flex-wrap: wrap;
    }

    /** Piece of text in the figure caption. */
    .heading-label {
      flex-grow: 1;
      margin-top: 4px;
      max-width: 100%;
      word-wrap: break-word;
    }

    /** Makes label show on the right. */
    .heading-right {
      flex-grow: 0;
    }
  `});function s2(e){return e?e.toString().replace(/GMT-\d+ \(([^)]+)\)/,"$1"):""}function $3t(e){let t=l5e(e);return t?Math.round((t[0]*299+t[1]*587+t[2]*114)/1e3)>125?"inherit":"#eee":"inherit"}function l5e(e){if(!e)return null;let t=e.match(/^#([0-9a-f]{1,2})([0-9a-f]{1,2})([0-9a-f]{1,2})$/);if(!t)return null;if(e.length==4)for(var r=1;r<=3;r++)t[r]=t[r]+t[r];return[parseInt(t[1],16),parseInt(t[2],16),parseInt(t[3],16)]}var gc=class extends mt{constructor(){super(...arguments),this.displayName=null,this.tag=null,this.run=null,this.description=null,this.color=null}_updateHeadingStyle(){this.updateStyles({"--tf-card-heading-background-color":this._runBackground,"--tf-card-heading-color":this._runColor})}_computeRunBackground(t){return t||"none"}_computeRunColor(t){return $3t(t)}get _nameLabel(){var t=this.displayName,r=this.tag;return t||r||""}get _tagLabel(){var t=this.displayName,r=this.tag;return r&&r!==t?r:""}_toggleDescriptionDialog(t){let r=this.$.descriptionDialog;r.positionTarget=t.target,r.toggle()}};gc.template=Q`
    <div class="container">
      <figcaption class="content">
        <div class="heading-row">
          <template is="dom-if" if="[[_nameLabel]]">
            <div itemprop="name" class="heading-label name">[[_nameLabel]]</div>
          </template>
          <template is="dom-if" if="[[run]]">
            <!-- Extra wrapping span needed to avoid flexbox blockification. -->
            <!-- (see flexbox spec, section 4 "Flex Items") -->
            <span>
              <span
                itemprop="run"
                id="heading-run"
                class="heading-label heading-right run"
                >[[run]]</span
              >
            </span>
          </template>
        </div>
        <template is="dom-if" if="[[_tagLabel]]">
          <div class="heading-row">
            <div class="heading-label">
              tag: <span itemprop="tag">[[_tagLabel]]</span>
            </div>
          </div>
        </template>
        <slot></slot>
      </figcaption>
      <template is="dom-if" if="[[description]]">
        <paper-icon-button
          icon="info"
          on-tap="_toggleDescriptionDialog"
          title="Show summary description"
        ></paper-icon-button>
      </template>
      <paper-dialog
        id="descriptionDialog"
        no-overlap=""
        horizontal-align="auto"
        vertical-align="auto"
      >
        <paper-dialog-scrollable>
          <tf-markdown-view html="[[description]]"></tf-markdown-view>
        </paper-dialog-scrollable>
      </paper-dialog>
    </div>
    <style include="tf-card-heading-style">
      .container {
        display: flex;
      }
      .content {
        font-size: 12px;
        flex-grow: 1;
      }
      .name {
        font-size: 14px;
      }
      .run {
        font-size: 11px;
        width: auto;
        border-radius: 3px;
        font-weight: bold;
        padding: 1px 4px 2px;
      }
      paper-icon-button {
        flex-grow: 0;
      }
      paper-dialog-scrollable {
        max-width: 640px;
      }
      #heading-run {
        background: var(--tf-card-heading-background-color);
        color: var(--tf-card-heading-color);
      }
    </style>
  `;E([A({type:String}),w("design:type",Object)],gc.prototype,"displayName",void 0);E([A({type:String}),w("design:type",Object)],gc.prototype,"tag",void 0);E([A({type:String}),w("design:type",Object)],gc.prototype,"run",void 0);E([A({type:String}),w("design:type",Object)],gc.prototype,"description",void 0);E([A({type:String}),w("design:type",Object)],gc.prototype,"color",void 0);E([A({type:String,computed:"_computeRunBackground(color)",readOnly:!0,observer:"_updateHeadingStyle"}),w("design:type",String)],gc.prototype,"_runBackground",void 0);E([A({type:String,computed:"_computeRunColor(color)",readOnly:!0,observer:"_updateHeadingStyle"}),w("design:type",String)],gc.prototype,"_runColor",void 0);E([Rt("displayName","tag"),w("design:type",String),w("design:paramtypes",[])],gc.prototype,"_nameLabel",null);E([Rt("displayName","tag"),w("design:type",String),w("design:paramtypes",[])],gc.prototype,"_tagLabel",null);gc=E([yt("tf-card-heading")],gc);var Fi=class extends Gt(mt){constructor(){super(...arguments),this._metadataCanceller=new an,this._steps=[],this._attached=!1}get _runColor(){var t=this.run;return fn(t)}get _hasAtLeastOneStep(){var t=this._steps;return!!t&&t.length>0}get _hasMultipleSteps(){var t=this._steps;return!!t&&t.length>1}get _maxStepIndex(){var t=this._steps;return t.length-1}get _currentDatum(){var t=this._steps,r=this._stepIndex;return t[r]}get _sampleText(){var t=this.sample;return`${t+1}`}get _hasMultipleSamples(){var t=this.totalSamples;return t>1}attached(){this._attached=!0,this.reload()}_reloadOnRunTagChange(){this.reload()}reload(){if(!this._attached)return;this._metadataCanceller.cancelAll();let r=ve().pluginRoute("audio","/audio",new URLSearchParams({tag:this.tag,run:this.run,sample:String(this.sample)})),n=this._metadataCanceller.cancellable(i=>{if(i.cancelled)return;let a=i.value.map(this._createStepDatum.bind(this));this.set("_steps",a),this.set("_stepIndex",a.length-1)});this.requestManager.request(r).then(n)}_createStepDatum(t){let r=new URLSearchParams(t.query);r.append("ts",String(t.wall_time));let n=ve().pluginRoute("audio","/individualAudio",r);return{wall_time:s2(new Date(t.wall_time*1e3)),step:t.step,label:t.label,contentType:t.contentType,url:n}}};Fi.template=Q`
    <tf-card-heading
      tag="[[tag]]"
      run="[[run]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
      color="[[_runColor]]"
    >
      <template is="dom-if" if="[[_hasMultipleSamples]]">
        <div class="heading-row">
          <div class="heading-label">
            sample: [[_sampleText]] of [[totalSamples]]
          </div>
        </div>
      </template>
      <template is="dom-if" if="[[_hasAtLeastOneStep]]">
        <div class="heading-row">
          <div class="heading-label">
            step <strong>[[_currentDatum.step]]</strong>
          </div>
          <template is="dom-if" if="[[_currentDatum.wall_time]]">
            <div class="heading-label heading-right">
              [[_currentDatum.wall_time]]
            </div>
          </template>
        </div>
      </template>
      <template is="dom-if" if="[[_hasMultipleSteps]]">
        <div class="heading-row">
          <paper-slider
            id="steps"
            immediate-value="{{_stepIndex}}"
            max="[[_maxStepIndex]]"
            max-markers="[[_maxStepIndex]]"
            snaps=""
            step="1"
            value="{{_stepIndex}}"
          ></paper-slider>
        </div>
      </template>
    </tf-card-heading>
    <template is="dom-if" if="[[_hasAtLeastOneStep]]">
      <audio
        controls=""
        src$="[[_currentDatum.url]]"
        type$="[[_currentDatum.contentType]]"
      ></audio>
      <tf-markdown-view html="[[_currentDatum.label]]"></tf-markdown-view>
    </template>
    <div id="main-audio-container"></div>

    <style include="tf-card-heading-style">
      :host {
        display: block;
        width: 350px;
        height: auto;
        position: relative;
        --step-slider-knob-color: #424242;
        margin-right: 15px;
        margin-bottom: 15px;
      }

      #steps {
        height: 15px;
        margin: 0 0 0 -15px;
        width: 100%;
        box-sizing: border-box;
        padding: 0 5px; /* so the slider knob doesn't butt out */
        margin-top: 5px;
        --paper-slider-active-color: var(--step-slider-knob-color);
        --paper-slider-knob-color: var(--step-slider-knob-color);
        --paper-slider-pin-color: var(--step-slider-knob-color);
        --paper-slider-knob-start-color: var(--step-slider-knob-color);
        --paper-slider-knob-start-border-color: var(--step-slider-knob-color);
        --paper-slider-pin-start-color: var(--step-slider-knob-color);
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],Fi.prototype,"run",void 0);E([A({type:String}),w("design:type",String)],Fi.prototype,"tag",void 0);E([A({type:Number}),w("design:type",Number)],Fi.prototype,"sample",void 0);E([A({type:Number}),w("design:type",Number)],Fi.prototype,"totalSamples",void 0);E([A({type:Object}),w("design:type",Object)],Fi.prototype,"tagMetadata",void 0);E([A({type:Object}),w("design:type",Ae)],Fi.prototype,"requestManager",void 0);E([A({type:Object}),w("design:type",an)],Fi.prototype,"_metadataCanceller",void 0);E([A({type:Array}),w("design:type",Array)],Fi.prototype,"_steps",void 0);E([A({type:Number}),w("design:type",Number)],Fi.prototype,"_stepIndex",void 0);E([Rt("run"),w("design:type",String),w("design:paramtypes",[])],Fi.prototype,"_runColor",null);E([Rt("_steps"),w("design:type",Boolean),w("design:paramtypes",[])],Fi.prototype,"_hasAtLeastOneStep",null);E([Rt("_steps"),w("design:type",Boolean),w("design:paramtypes",[])],Fi.prototype,"_hasMultipleSteps",null);E([Rt("_steps"),w("design:type",Number),w("design:paramtypes",[])],Fi.prototype,"_maxStepIndex",null);E([Rt("_steps","_stepIndex"),w("design:type",Object),w("design:paramtypes",[])],Fi.prototype,"_currentDatum",null);E([Rt("sample"),w("design:type",String),w("design:paramtypes",[])],Fi.prototype,"_sampleText",null);E([Rt("totalSamples"),w("design:type",Boolean),w("design:paramtypes",[])],Fi.prototype,"_hasMultipleSamples",null);E([Bt("run","tag"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Fi.prototype,"_reloadOnRunTagChange",null);Fi=E([yt("tf-audio-loader")],Fi);var $h=class extends Gt(mt){constructor(){super(...arguments),this.reloadOnReady=!0,this._tagFilter="",this._requestManager=new Ae}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then(()=>{this._reloadAudio()})}_fetchTags(){let t=ve().pluginRoute("audio","/tags");return this._requestManager.request(t).then(r=>{if(fy.isEqual(r,this._runToTagInfo))return;let n=fy.mapValues(r,o=>Object.keys(o)),i=$i(n);this.set("_dataNotFound",i.length===0),this.set("_runToTagInfo",r)})}_reloadAudio(){var t;(t=this.root)==null||t.querySelectorAll("tf-audio-loader").forEach(r=>{r.reload()})}_shouldOpen(t){return t<=2}get _categories(){var t=this._runToTagInfo,r=this._selectedRuns,n=this._tagFilter;let i=fy.mapValues(t,l=>Object.keys(l)),o=Ql(i,r,n);function a(l){let c=t[l.run][l.tag].samples;return fy.range(c).map(u=>Object.assign({},l,{sample:u,totalSamples:c}))}return o.map(l=>Object.assign({},l,{items:[].concat.apply([],l.items.map(a))}))}_tagMetadata(t,r,n){return t[r][n]}};$h.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="sidebar-section runs-selector">
          <tf-runs-selector
            id="runs-selector"
            selected-runs="{{_selectedRuns}}"
          ></tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No audio data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any audio data to your event files.</li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-audio-loader
                  active="[[active]]"
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  sample="[[item.sample]]"
                  total-samples="[[item.totalSamples]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.run, item.tag)]]"
                  request-manager="[[_requestManager]]"
                ></tf-audio-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>
    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],$h.prototype,"reloadOnReady",void 0);E([A({type:Array}),w("design:type",Array)],$h.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],$h.prototype,"_runToTagInfo",void 0);E([A({type:Boolean}),w("design:type",Boolean)],$h.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],$h.prototype,"_tagFilter",void 0);E([A({type:Object}),w("design:type",Ae)],$h.prototype,"_requestManager",void 0);E([Rt("_runToTagInfo","_selectedRuns","_tagFilter"),w("design:type",Array),w("design:paramtypes",[])],$h.prototype,"_categories",null);$h=E([yt("tf-audio-dashboard")],$h);var H5=class extends Gt(mt){attached(){this.async(function(){this.getEffectiveChildren().forEach(function(t){this.listen(t,"tap","_selectTarget")}.bind(this))})}_selectTarget(t){this.selectedId=t.currentTarget.id}_selectedIdChanged(){var t=this.queryEffectiveChildren("#"+this.selectedId);!t||(this.getEffectiveChildren().forEach(function(r){r.classList.remove("selected")}),t.classList.add("selected"))}};H5.template=Q`
    <div id="wrap">
      <h3>[[name]]</h3>
      <div class="content-wrapper"><slot></slot></div>
    </div>
    <style>
      .content-wrapper ::slotted(*) {
        background: none;
        color: var(--tb-ui-dark-accent);
        font-size: 13px;
        margin-top: 10px;
      }

      .content-wrapper ::slotted(*) {
        background: none;
        color: var(--tb-ui-dark-accent);
        font-size: 13px;
        margin-top: 10px;
      }

      .content-wrapper ::slotted(.selected) {
        background-color: var(--tb-ui-dark-accent);
        color: white !important;
      }

      h3 {
        color: var(--tb-secondary-text-color);
        display: block;
        font-size: 14px;
        font-weight: normal;
        margin: 0 0 5px;
        pointer-events: none;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],H5.prototype,"name",void 0);E([A({type:String,notify:!0,observer:"_selectedIdChanged"}),w("design:type",String)],H5.prototype,"selectedId",void 0);H5=E([yt("tf-option-selector")],H5);function iR(e,t){let r,n={};Object.keys(e).forEach(a=>{let s=e[a];r===void 0&&(r=s.displayName),r!==s.displayName&&(r=null),n[s.description]===void 0&&(n[s.description]=[]),n[s.description].push(a)});let i=r!=null?r:t,o=(()=>{let a=Object.keys(n);return a.length===0?"":a.length===1?a[0]:`<p><strong>Multiple descriptions:</strong></p><ul>${a.map(c=>{let u=n[c].map(p=>`<code>${p.replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/&/g,"&amp;")}</code>`),h=u.length>2?u.slice(0,u.length-1).join(", ")+", and "+u[u.length-1]:u.join(" and ");return`<li><p>For ${c5e(u.length,"run","runs")} ${h}:</p>${c}</li>`}).join("")}</ul>`})();return{displayName:i,description:o}}function c5e(e,t,r){return e===1?t:r}var Z3t=Ee(Oe(),1);var Hp=class extends mt{constructor(){super(...arguments),this.weight=.6,this._updateWeight=Z3t.debounce(function(t){this.weight=t},250)}_immediateWeightNumberForPaperSliderChanged(){this._inputWeightStringForPaperInput=this._immediateWeightNumberForPaperSlider.toString(),this._updateWeight.call(this,this._immediateWeightNumberForPaperSlider)}_inputWeightStringForPaperInputChanged(){+this._inputWeightStringForPaperInput<0?this._inputWeightStringForPaperInput="0":+this._inputWeightStringForPaperInput>1&&(this._inputWeightStringForPaperInput="1");var t=+this._inputWeightStringForPaperInput;isNaN(t)||this._updateWeight.call(this,t)}};Hp.template=Q`
    <h3 class="title">Smoothing</h3>
    <div class="smoothing-block">
      <paper-slider
        id="slider"
        immediate-value="{{_immediateWeightNumberForPaperSlider}}"
        max="[[max]]"
        min="[[min]]"
        pin
        step="[[step]]"
        type="number"
        value="{{weight}}"
      ></paper-slider>
      <paper-input
        id="input"
        label="weight"
        no-label-float
        value="{{_inputWeightStringForPaperInput}}"
        type="number"
        step="[[step]]"
        min="[[min]]"
        max="[[max]]"
      ></paper-input>
    </div>
    <style>
      .title {
        color: var(--tb-secondary-text-color);
        margin: 0;
        font-weight: normal;
        font-size: 14px;
        margin-bottom: 5px;
      }

      .smoothing-block {
        display: flex;
      }

      paper-slider {
        --paper-slider-active-color: var(--tb-orange-strong);
        --paper-slider-knob-color: var(--tb-orange-strong);
        --paper-slider-knob-start-border-color: var(--tb-orange-strong);
        --paper-slider-knob-start-color: var(--tb-orange-strong);
        --paper-slider-markers-color: var(--tb-orange-strong);
        --paper-slider-pin-color: var(--tb-orange-strong);
        --paper-slider-pin-start-color: var(--tb-orange-strong);
        flex-grow: 2;
      }

      paper-input {
        --paper-input-container-focus-color: var(--tb-orange-strong);
        --paper-input-container-input: {
          font-size: 14px;
        }
        --paper-input-container-label: {
          font-size: 14px;
        }
        width: 60px;
      }
    </style>
  `;E([A({type:Number}),w("design:type",Number)],Hp.prototype,"step",void 0);E([A({type:Number}),w("design:type",Number)],Hp.prototype,"max",void 0);E([A({type:Number}),w("design:type",Number)],Hp.prototype,"min",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],Hp.prototype,"weight",void 0);E([A({type:Number,notify:!0,observer:"_immediateWeightNumberForPaperSliderChanged"}),w("design:type",Number)],Hp.prototype,"_immediateWeightNumberForPaperSlider",void 0);E([A({type:String,notify:!0,observer:"_inputWeightStringForPaperInputChanged"}),w("design:type",String)],Hp.prototype,"_inputWeightStringForPaperInput",void 0);Hp=E([yt("tf-smoothing-input")],Hp);var Yo=Ee(Oe(),1);function Cn(e,t){let r=Object.keys(t).sort().filter(a=>t[a]!==void 0);if(!r.length)return e;let n=e.indexOf("?")!==-1?"&":"?",o=Array().concat(...r.map(a=>{let s=t[a];return(Array.isArray(s)?s:[s]).map(c=>`${a}=${u5e(c)}`)})).join("&");return e+n+o}function u5e(e){return encodeURIComponent(e).replace(/\(/g,"%28").replace(/\)/g,"%29")}var GKt=Ee(Oe(),1),HWn=Ee(wl(),1);var IKt=Ee(Oe(),1);var v4;(function(e){e[e.LOADING=0]="LOADING",e[e.LOADED=1]="LOADED"})(v4||(v4={}));function kS(e){return class extends e{constructor(){super(...arguments),this.loadKey="",this.dataToLoad=[],this.getDataLoadName=r=>String(r),this.dataLoading=!1,this.dataLoadedAtLeastOnce=!1,this._isConnected=!1,this._dataLoadState=new Map,this._canceller=new an,this._loadDataAsync=null,this._loadData=IKt.throttle(this._loadDataImpl,100,{leading:!0,trailing:!0})}connectedCallback(){super.connectedCallback(),this._isConnected=!0}disconnectedCallback(){super.disconnectedCallback(),this._isConnected=!1}static get properties(){return{active:{type:Boolean,observer:"_loadDataIfActive"},_isConnected:{type:Boolean},loadKey:{type:String},dataToLoad:{type:Array},getDataLoadName:{type:Object},loadDataCallback:{type:Object},requestData:{type:Object}}}static get observers(){return["_dataToLoadChanged(_isConnected, dataToLoad.*)"]}onLoadFinish(){}reload(){this._dataLoadState.clear(),this._loadData()}reset(){this._loadDataAsync!=null&&(clearTimeout(this._loadDataAsync),this._loadDataAsync=null),this._canceller&&this._canceller.cancelAll(),this._dataLoadState&&this._dataLoadState.clear(),this._isConnected&&this._loadData()}_dataToLoadChanged(){this._isConnected&&this._loadData()}detached(){this._loadDataAsync!=null&&(clearTimeout(this._loadDataAsync),this._loadDataAsync=null)}_loadDataIfActive(){this.active&&this._loadData()}_loadDataImpl(){!this.active||(this._loadDataAsync!==null&&clearTimeout(this._loadDataAsync),this._loadDataAsync=setTimeout(this._canceller.cancellable(r=>{if(r.cancelled)return;this.dataLoading=!0;let n=this.dataToLoad.filter(a=>{let s=this.getDataLoadName(a);return!this._dataLoadState.has(s)});for(let a of n){let s=this.getDataLoadName(a);this._dataLoadState.set(s,v4.LOADING)}let i=this._canceller.cancellable(a=>{if(a.cancelled)return;let{item:s,data:l}=a.value,c=this.getDataLoadName(s);this._dataLoadState.set(c,v4.LOADED),this.loadDataCallback(this,s,l)}),o=this._canceller.cancellable(a=>{if(!a.cancelled){let l=a.value,c=new Set(n.map(h=>this.getDataLoadName(h)));this.dataToLoad.some(h=>c.has(this.getDataLoadName(h)))&&this.onLoadFinish(),this._loadDataAsync=null,this.dataLoadedAtLeastOnce=!0}Array.from(this._dataLoadState.values()).includes(v4.LOADING)||(this.dataLoading=!1)});this.requestData(n,i,()=>o(void 0))})))}}}var gqe=Ee(Oe(),1),Wo=Ee(wl(),1),RS=[{character:"\u25FC",method:Wo.SymbolFactories.square},{character:"\u25C6",method:Wo.SymbolFactories.diamond},{character:"\u25B2",method:Wo.SymbolFactories.triangle},{character:"\u2605",method:Wo.SymbolFactories.star},{character:"\u271A",method:Wo.SymbolFactories.cross}],Ed;(function(e){e.STEP="step",e.RELATIVE="relative",e.WALL_TIME="wall_time"})(Ed||(Ed={}));var e0=4,_qe=4,dB=3,mB=20,gB=4,LKt=6;function Wu(e){return t=>{let r=Math.abs(t);r<1e-15&&(r=0);let n;return r>=1e4?n=xn("."+e+"~e"):r>0&&r<.01?n=xn("."+e+"~e"):n=xn("."+e+"~g"),n(t)}}var x4=xn(`.${_qe}~s`);function $at(){let e=new Wo.Scales.Linear;e.tickGenerator(Wo.Scales.TickGenerators.integerTickGenerator());let t=new Wo.Axes.Numeric(e,"bottom");return t.formatter(x4),{scale:e,axis:t,accessor:r=>r.step}}var _B=Wo.Formatters.time("%a %b %e, %H:%M:%S");function yqe(){let e=new Wo.Scales.Time;return{scale:e,axis:new Wo.Axes.Time(e,"bottom"),accessor:t=>t.wall_time}}var r0=(e,t,r)=>{if(e.relative!=null)return e.relative;let n=r.data(),i=n.length>0?+n[0].wall_time:0;return(+e.wall_time-i)/(60*60*1e3)},yB=e=>{let t="",r=Math.floor(e/24);e-=r*24,r&&(t+=r+"d ");let n=Math.floor(e);e-=n,e*=60,(n||r)&&(t+=n+"h ");let i=Math.floor(e);e-=i,e*=60,(i||n||r)&&(t+=i+"m ");let o=Math.floor(e);return t+o+"s"};function vqe(){let e=new Wo.Scales.Linear;return{scale:e,axis:new Wo.Axes.Numeric(e,"bottom"),accessor:r0}}function vB(e){switch(e){case Ed.STEP:return $at();case Ed.WALL_TIME:return yqe();case Ed.RELATIVE:return vqe();default:throw new Error("invalid xType: "+e)}}var zs=Ee(Oe(),1),Mn=Ee(wl(),1);var va=Ee(wl(),1);function xqe(e){let t=[],r=e;for(;r&&r instanceof HTMLElement;)if(t.push(r),r.assignedSlot)r=r.assignedSlot;else if(r.parentElement)r=r.parentElement;else{let n=r.parentNode;n instanceof DocumentFragment?r=n.host:r=n!==r?n:null}return t}var bqe=[1,0,0,1,0,0];function wqe(e){let t=xqe(e),r=bqe,n=null;for(let i of t){let o=va.Utils.DOM.getElementTransform(i);if(o!=null){let l=i.clientWidth/2,c=i.clientHeight/2;r=va.Utils.Math.multiplyTranslate(r,[l,c]),r=va.Utils.Math.multiplyMatrix(r,va.Utils.Math.invertMatrix(o)),r=va.Utils.Math.multiplyTranslate(r,[-l,-c])}let a=i.scrollLeft,s=i.scrollTop;(n===null||i===n)&&(a-=i.offsetLeft+i.clientLeft,s-=i.offsetTop+i.clientTop,n=i.offsetParent),r=va.Utils.Math.multiplyTranslate(r,[a,s])}return r}var bB=class extends va.Utils.Translator{computePosition(t,r){let n={x:t,y:r},i=wqe(this._rootElement);return i==null?n:va.Utils.Math.applyTransform(i,n)}},U1=class extends va.Dispatchers.Mouse{constructor(t){super(t),this._eventTarget=t.root().rootElement().node(),this._translator=new bB(t.root().rootElement().node())}static getDispatcher(t){let r=t.root().rootElement(),n=r[U1._DISPATCHER_KEY];return n||(n=new U1(t),r[U1._DISPATCHER_KEY]=n),n}},q1=class extends va.Dispatchers.Touch{constructor(t){super(t),this._eventTarget=t.root().rootElement().node(),this._translator=new bB(t.root().rootElement().node())}static getDispatcher(t){let r=t.root().rootElement(),n=r[q1._DISPATCHER_KEY];return n||(n=new q1(t),r[q1._DISPATCHER_KEY]=n),n}};va.Interaction.prototype._isInsideComponent=function(e){return 0<=e.x&&0<=e.y&&e.x<this._componentAttachedTo.width()&&e.y<this._componentAttachedTo.height()};var wB=class extends va.Interactions.Pointer{_anchor(t){let r=this;r._isAnchored=!0,r._mouseDispatcher=U1.getDispatcher(r._componentAttachedTo),r._mouseDispatcher.onMouseMove(r._mouseMoveCallback),r._touchDispatcher=q1.getDispatcher(r._componentAttachedTo),r._touchDispatcher.onTouchStart(r._touchStartCallback)}};var kKt=Ee(Oe(),1);var G1;(function(e){e.AUTO="auto",e.BOTTOM="bottom",e.RIGHT="right"})(G1||(G1={}));var Sqe={boxShadow:"0 1px 4px rgba(0, 0, 0, .3)",opacity:0,position:"fixed",willChange:"transform",zIndex:5},b4=class extends Gt(mt){constructor(){super(...arguments),this.position=G1.AUTO,this.minDistFromEdge=15,this._styleCache=null,this._raf=null,this._tunnel=null}ready(){this._styleCache=null,this._raf=null,this._tunnel=null}attached(){this._tunnel=this._createTunnel(),this._hideOnBlur=()=>{document.hidden&&this.hide()},window.addEventListener("visibilitychange",this._hideOnBlur)}detached(){this.hide(),this._removeTunnel(this._tunnel),this._tunnel=null,window.removeEventListener("visibilitychange",this._hideOnBlur)}content(){return this._tunnel.shadowRoot}hide(){this._raf!==null&&window.cancelAnimationFrame(this._raf),this._styleCache=null,this._tunnel.style.opacity=0}updateAndPosition(t){this._raf!==null&&window.cancelAnimationFrame(this._raf),this._raf=window.requestAnimationFrame(()=>{!this.isAttached||this._repositionImpl(t)})}_repositionImpl(t){let r=this._tunnel,n=t.getBoundingClientRect(),i=r.getBoundingClientRect(),o=window.innerHeight,a=document.body.clientWidth,s=n.top,l=s+n.height,c=i.height+mB,u=null,h=Math.max(this.minDistFromEdge,n.left),f=null,p=s;this.position==G1.RIGHT?h=n.right:(p=l+mB,a<h+i.width+this.minDistFromEdge&&(h=null,f=this.minDistFromEdge)),this.position==G1.AUTO&&n.top-c>0&&o<n.top+n.height+c&&(p=null,u=o-s+mB);let d={contain:"content",opacity:1,left:h?`${h}px`:null,right:f?`${f}px`:null,top:p?`${p}px`:null,bottom:u?`${u}px`:null};kKt.isEqual(this._styleCache,d)||(Object.assign(r.style,d),this._styleCache=d)}_createTunnel(){if(!this.contentComponentName)throw new RangeError("Require `contentComponentName` to be a name of a Polymer component");let t=document.createElement(this.contentComponentName);return Object.assign(t.style,Sqe),document.body.appendChild(t),t}_removeTunnel(t){document.body.removeChild(t)}};E([A({type:String}),w("design:type",String)],b4.prototype,"contentComponentName",void 0);E([A({type:String}),w("design:type",String)],b4.prototype,"position",void 0);E([A({type:Number}),w("design:type",Number)],b4.prototype,"minDistFromEdge",void 0);b4=E([yt("vz-chart-tooltip")],b4);var NS=Ee(wl(),1);var DKt=1e4,OKt=.001,zKt=xn(".2~e"),Mqe=xn(".4~r"),RKt=xn(",~");function NKt(e){if(e===0)return"0";let t=Math.abs(e);return t>=DKt||t<OKt?zKt(e):Mqe(e)}var Zat={formatTick:NKt,formatShort:NKt,formatReadable(e){let t=Math.abs(e);return t>=DKt||t<OKt?zKt(e):RKt(e)},formatLong:RKt},jGn=new Intl.NumberFormat(void 0,{maximumFractionDigits:3});var XGn=xn("0.3~s"),$Gn=xn(",.3~f");var Eqe=1e3,Tqe=60*Eqe,Cqe=60*Tqe,Aqe=24*Cqe,KGn=365*Aqe,ZGn=xn(".4~");var Pqe=Yb().tickFormat(),Kat,FKt={formatTick(e){return Pqe(new Date(e))},formatShort(e){return new Date(e).toLocaleString(Kat,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric"})},formatReadable(e){return new Date(e).toLocaleString(Kat,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short"})},formatLong(e){return new Date(e).toLocaleString(Kat,{year:"numeric",month:"long",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short",fractionalSecondDigits:3})}};var Td;(function(e){e[e.LINEAR=0]="LINEAR",e[e.LOG10=1]="LOG10",e[e.TIME=2]="TIME"})(Td||(Td={}));function BKt(e){switch(e){case Td.LINEAR:return new Jat;case Td.LOG10:return new Qat;case Td.TIME:return new tst;default:let t=e;throw new RangeError(`ScaleType ${t} not supported.`)}}var Iqe=.05,Jat=class{constructor(){this.defaultFormatter=Zat}transform(t,r,n){let[i,o]=t,a=o-i,[s,l]=r,c=l-s;return a===0?s:c/a*(n-i)+s}forward(t,r,n){return this.transform(t,r,n)}reverse(t,r,n){return this.transform(r,t,n)}niceDomain(t){let[r,n]=t;if(n<r)throw new Error("Unexpected input: min is larger than max");if(n===r)return r===0?[-1,1]:r<0?[2*r,0]:[0,2*r];let i=zn(),o=(n-r+Number.EPSILON)*Iqe,[a,s]=i.domain([r-o,n+o]).nice().domain();return[a,s]}ticks(t,r){return zn().domain(t).ticks(r)}isSafeNumber(t){return Number.isFinite(t)}},Qat=class{constructor(){this.defaultFormatter=Zat}transform(t){return Math.log10(t>0?t:Number.MIN_VALUE)}untransform(t){return Math.exp(t/Math.LOG10E)}forward(t,r,n){if(n<=0)return r[0];let[i,o]=t,[a,s]=r,l=this.transform(i),u=this.transform(o)-l,h=s-a;return n=this.transform(n),h/(u+Number.EPSILON)*(n-l)+a}reverse(t,r,n){let[i,o]=t,[a,s]=r,l=this.transform(i),u=this.transform(o)-l,h=s-a,f=u/(h+Number.EPSILON)*(n-a)+l;return this.untransform(f)}niceDomain(t){let[r,n]=t;if(r>n)throw new Error("Unexpected input: min is larger than max");let i=Math.max(r,Number.MIN_VALUE),o=Math.max(n,Number.MIN_VALUE);return n<=0?[Number.MIN_VALUE,1]:[Math.max(Number.MIN_VALUE,i*.5),o*2]}ticks(t,r){let n=t[0]<=0?Number.MIN_VALUE:t[0],i=t[1]<=0?Number.MIN_VALUE:t[1],o=cc().domain([n,i]).ticks(r);return o.length?o:t}isSafeNumber(t){return Number.isFinite(t)&&t>0}},tst=class{constructor(){this.scale=Yb(),this.defaultFormatter=FKt}forward(t,r,n){return this.scale.domain(t).range(r)(n)}reverse(t,r,n){return this.scale.domain(t).range(r).invert(n).getTime()}niceDomain(t){let[r,n]=this.scale.domain(t).nice().domain();return[r.getTime(),n.getTime()]}ticks(t,r){return this.scale.domain(t).ticks(r).map(n=>n.getTime())}isSafeNumber(t){return Number.isFinite(t)}};var SB=class extends NS.Scales.Linear{constructor(){super(),this._ignoreOutlier=!1,this.padProportion(.2)}setValueProviderForDomain(t){return this._valueProviderForDomain=t,this}_niceDomain(t,r){let[n,i]=t;return BKt(Td.LINEAR).niceDomain([n,i])}_getUnboundedExtent(t){let r=this._getAllIncludedValues(t),n=this._defaultExtent();if(r.length!==0){let i=[NS.Utils.Math.min(r,n[0]),NS.Utils.Math.max(r,n[1])];n=this._niceDomain(i)}return n}_getAllIncludedValues(t=!1){let r=this._valueProviderForDomain?this._valueProviderForDomain():[];return this.extentOfValues(r)}extentOfValues(t){let r=t.filter(o=>NS.Utils.Math.isValidNumber(o)),n=r;if(this.ignoreOutlier()){let o=r.sort((l,c)=>l-c),a=sa(o,.05),s=sa(o,.95);n=r.filter(l=>l>=a&&l<=s)}let i=aa(n);return i[0]==null||i[1]==null?[]:i}ignoreOutlier(t){return typeof t=="boolean"?(this._ignoreOutlier=t,this):this._ignoreOutlier}};var TB=Ee(wl(),1);var HKt=Ee(wl(),1),MB=class extends HKt.QuantitativeScale{constructor(){super(...arguments),this._ignoreOutlier=!1}setValueProviderForDomain(t){return this._valueProviderForDomain=t,this}ignoreOutlier(t){return typeof t=="boolean"?(this._ignoreOutlier=t,this):this._ignoreOutlier}_getAllIncludedValues(t=!1){let r=this._valueProviderForDomain?this._valueProviderForDomain():[];return this.extentOfValues(r)}};var EB=Math.pow(2,-1074);function w4(e){return Math.log10(e)}function est(e){return Math.pow(10,e)}var CB=class extends MB{constructor(){super(),this._d3LogScale=cc(),this.padProportion(.2)}scale(t){return t<=0?NaN:this._d3LogScale(t)}invert(t){return this._d3LogScale.invert(t)}scaleTransformation(t){return this.scale(t)}invertedTransformation(t){return this.invert(t)}getTransformationDomain(){return this.domain()}setTransformationDomain(t){this.domain(t)}getTransformationExtent(){return this._getUnboundedExtent(!0)}_getDomain(){return this._untransformedDomain}_setDomain(t){this._untransformedDomain=t;let[r,n]=t;super._setDomain([Math.max(EB,r),n])}_niceDomain(t,r){let[n,i]=t,o=Math.max(w4(EB),w4(n)),a=w4(i),s=a-o,l=s?s*this.padProportion():1;return[est(Math.max(w4(EB),o-l)),est(a+l)]}_getUnboundedExtent(t){let r=this._getAllIncludedValues(t),n=this._defaultExtent();if(r.length!==0){let i=[TB.Utils.Math.min(r,n[0]),TB.Utils.Math.max(r,n[1])];n=this._niceDomain(i)}return n}_getAllIncludedValues(t=!1){return super._getAllIncludedValues().map(n=>n>0?n:EB)}_defaultExtent(){return[1,10]}_backingScaleDomain(t){return t==null?this._d3LogScale.domain():(this._d3LogScale.domain(t),this)}_getRange(){return this._d3LogScale.range()}_setRange(t){this._d3LogScale.range(t)}defaultTicks(){return this._d3LogScale.ticks(1)}ticks(){return this._d3LogScale.ticks()}extentOfValues(t){let r=t.filter(o=>TB.Utils.Math.isValidNumber(o)&&o>0),n=r;if(this.ignoreOutlier()){let a=r.map(w4).sort((c,u)=>c-u),s=sa(a,.05),l=sa(a,.95);n=a.filter(c=>c>=s&&c<=l).map(est)}let i=aa(n);return i[0]==null||i[1]==null?[]:i}};var Cd=Ee(wl(),1);var n0=Ee(wl(),1),AB=class extends n0.Components.SelectionBoxLayer{constructor(t,r,n){super(),this.easeFn=xs,this._animationTime=750,this.xScale(t),this.yScale(r),this._dragInteraction=new n0.Interactions.Drag,this._doubleClickInteraction=new n0.Interactions.Click,this.setupCallbacks(),this.unzoomMethod=n,this.onDetach(()=>{this._doubleClickInteraction.detachFrom(this),this._dragInteraction.detachFrom(this)}),this.onAnchor(()=>{this._doubleClickInteraction.attachTo(this),this._dragInteraction.attachTo(this)})}interactionStart(t){this.onStart=t}interactionEnd(t){this.onEnd=t}dragInteraction(){return this._dragInteraction}setupCallbacks(){let t=!1;this._dragInteraction.onDragStart(r=>{this.bounds({topLeft:r,bottomRight:r}),this.onStart()}),this._dragInteraction.onDrag((r,n)=>{this.bounds({topLeft:r,bottomRight:n}),this.boxVisible(!0),t=!0}),this._dragInteraction.onDragEnd((r,n)=>{this.boxVisible(!1),this.bounds({topLeft:r,bottomRight:n}),t?this.zoom():this.onEnd(),t=!1}),this._doubleClickInteraction.onDoubleClick(this.unzoom.bind(this))}animationTime(t){if(t==null)return this._animationTime;if(t<0)throw new Error("animationTime cannot be negative");return this._animationTime=t,this}ease(t){if(typeof t!="function")throw new Error("ease function must be a function");return(t(0)!==0||t(1)!==1)&&n0.Utils.Window.warn("Easing function does not maintain invariant f(0)==0 && f(1)==1. Bad behavior may result."),this.easeFn=t,this}zoom(){let t=this.xExtent()[0].valueOf(),r=this.xExtent()[1].valueOf(),n=this.yExtent()[1].valueOf(),i=this.yExtent()[0].valueOf();t===r||n===i||this.interpolateZoom(t,r,n,i)}unzoom(){let t=this.xScale();t._domainMin=null,t._domainMax=null;let r=t._getExtent();this.xScale().domain(r),this.unzoomMethod()}isZooming(t){this._dragInteraction.enabled(!t),this._doubleClickInteraction.enabled(!t)}interpolateZoom(t,r,n,i){let o=this.xScale().domain()[0].valueOf(),a=this.xScale().domain()[1].valueOf(),s=this.yScale().domain()[0].valueOf(),l=this.yScale().domain()[1].valueOf(),c=this.easeFn,u=(p,d,g)=>zi(p,d)(c(g));this.isZooming(!0);let h=Date.now(),f=()=>{let d=Date.now()-h,g=this._animationTime===0?1:Math.min(1,d/this._animationTime),_=u(o,t,g),y=u(a,r,g),x=u(s,n,g),b=u(l,i,g);this.xScale().domain([_,y]),this.yScale().domain([x,b]),g<1?n0.Utils.DOM.requestAnimationFramePolyfill(f):(this.onEnd(),this.isZooming(!1))};f()}};var xa;(function(e){e[e.NONE=0]="NONE",e[e.DRAG_ZOOMING=1]="DRAG_ZOOMING",e[e.PANNING=2]="PANNING"})(xa||(xa={}));var zf=class extends Cd.Components.Group{constructor(t,r,n){super(),this.state=xa.NONE,this.panStartCallback=new Cd.Utils.CallbackSet,this.panEndCallback=new Cd.Utils.CallbackSet,this.panZoom=new Cd.Interactions.PanZoom(t,r),this.panZoom.dragInteraction().mouseFilter(o=>zf.isPanKey(o)&&o.button===0),this.panZoom.wheelFilter(this.canScrollZoom),this.dragZoomLayer=new AB(t,r,n),this.dragZoomLayer.dragInteraction().mouseFilter(o=>!zf.isPanKey(o)&&o.button===0),this.append(this.dragZoomLayer);let i=this.onWheel.bind(this);this.onAnchor(()=>{this._mouseDispatcher=Cd.Dispatchers.Mouse.getDispatcher(this),this._mouseDispatcher.onWheel(i),this.panZoom.attachTo(this)}),this.onDetach(()=>{this.panZoom.detachFrom(this),this._mouseDispatcher&&(this._mouseDispatcher.offWheel(i),this._mouseDispatcher=null)}),this.panZoom.dragInteraction().onDragStart(()=>{this.state==xa.NONE&&this.setState(xa.PANNING)}),this.panZoom.dragInteraction().onDragEnd(()=>{this.state==xa.PANNING&&this.setState(xa.NONE)}),this.dragZoomLayer.dragInteraction().onDragStart(()=>{this.state==xa.NONE&&this.setState(xa.DRAG_ZOOMING)}),this.dragZoomLayer.dragInteraction().onDragEnd(()=>{this.state==xa.DRAG_ZOOMING&&this.setState(xa.NONE)})}onWheel(t,r){if(this.canScrollZoom(r))return;let n=this.element();if(!n.select(".help").empty())return;let i=n.append("div").classed("help",!0);i.append("span").text("Alt + Scroll to Zoom"),i.on("animationend",()=>void i.remove())}static isPanKey(t){return Boolean(t.altKey)||Boolean(t.shiftKey)}canScrollZoom(t){return t.altKey}setState(t){if(this.state==t)return;let r=this.state;this.state=t,this.root().removeClass(this.stateClassName(r)),this.root().addClass(this.stateClassName(t)),r==xa.PANNING&&this.panEndCallback.callCallbacks(),t==xa.PANNING&&this.panStartCallback.callCallbacks()}stateClassName(t){switch(t){case xa.PANNING:return"panning";case xa.DRAG_ZOOMING:return"drag-zooming";case xa.NONE:default:return""}}onPanStart(t){this.panStartCallback.add(t)}onPanEnd(t){this.panEndCallback.add(t)}onScrollZoom(t){this.panZoom.onZoomEnd(t)}onDragZoomStart(t){this.dragZoomLayer.interactionStart(t)}onDragZoomEnd(t){this.dragZoomLayer.interactionEnd(t)}};var PB;(function(e){e[e.TEXT=0]="TEXT",e[e.DOM=1]="DOM"})(PB||(PB={}));var Ff;(function(e){e.LOG="log",e.LINEAR="linear"})(Ff||(Ff={}));var VKt=20,DS=class{constructor(t,r,n,i,o,a,s,l,c,u,h){this.dirtyDatasets=new Set,this.seriesNames=[],this.name2datasets={},this.colorScale=i,this.tooltip=o,this.datasets=[],this._ignoreYOutliers=!1,this.lastPointsDataset=new Mn.Dataset,this.nanDataset=new Mn.Dataset,this.yValueAccessor=r,this.symbolFunction=u,this._defaultXRange=l,this._defaultYRange=c,this.tooltipColumns=a,this.buildChart(t,r,n,s,h)}buildChart(t,r,n,i,o){this.destroy();let a=t();this.xAccessor=a.accessor,this.xScale=a.scale,this.xAxis=a.axis,this.xAxis.margin(1).tickLabelPadding(3),o&&this.xAxis.formatter(o),this.yScale=DS.getYScaleFromType(n),this.yScale.setValueProviderForDomain(()=>this.getValuesForYAxisDomainCompute()),this.yAxis=new Mn.Axes.Numeric(this.yScale,"left");let s=Wu(dB);this.yAxis.margin(0).tickLabelPadding(5).formatter(s),this.yAxis.usesTextWidthApproximation(!0),this.fillArea=i;let l=new zf(this.xScale,this.yScale,()=>this.resetDomain());this.tooltipInteraction=this.createTooltipInteraction(l),this.tooltipPointsComponent=new Mn.Component;let c=this.buildPlot(this.xScale,this.yScale,i);this.gridlines=new Mn.Components.Gridlines(this.xScale,this.yScale);let u=null;n!==Ff.LOG&&(u=new Mn.Components.GuideLineLayer("horizontal"),u.scale(this.yScale).value(0));let h=new Mn.Components.GuideLineLayer("vertical");h.scale(this.xScale).value(0),this.center=new Mn.Components.Group([this.gridlines,u,h,c,this.tooltipPointsComponent,l]),this.center.addClass("main"),this.outer=new Mn.Components.Table([[this.yAxis,this.center],[null,this.xAxis]])}buildPlot(t,r,n){n&&(this.marginAreaPlot=new Mn.Plots.Area,this.marginAreaPlot.x(this.xAccessor,t),this.marginAreaPlot.y(n.higherAccessor,r),this.marginAreaPlot.y0(n.lowerAccessor),this.marginAreaPlot.attr("fill",(c,u,h)=>this.colorScale.scale(h.metadata().name)),this.marginAreaPlot.attr("fill-opacity",.3),this.marginAreaPlot.attr("stroke-width",0)),this.smoothedAccessor=c=>c.smoothed;let i=new Mn.Plots.Line;i.x(this.xAccessor,t),i.y(this.yValueAccessor,r),i.attr("stroke",(c,u,h)=>this.colorScale.scale(h.metadata().name)),this.linePlot=i,this.setupTooltips(i);let o=new Mn.Plots.Line;if(o.x(this.xAccessor,t),o.y(this.smoothedAccessor,r),o.attr("stroke",(c,u,h)=>this.colorScale.scale(h.metadata().name)),this.smoothLinePlot=o,this.symbolFunction){let c=new Mn.Plots.Scatter;c.x(this.xAccessor,t),c.y(this.yValueAccessor,r),c.attr("fill",(u,h,f)=>this.colorScale.scale(f.metadata().name)),c.attr("opacity",1),c.size(gB*2),c.symbol((u,h,f)=>this.symbolFunction(f.metadata().name)),this.markersScatterPlot=c}let a=new Mn.Plots.Scatter;a.x(this.xAccessor,t),a.y(this.yValueAccessor,r),a.attr("fill",c=>this.colorScale.scale(c.name)),a.attr("opacity",1),a.size(gB*2),a.datasets([this.lastPointsDataset]),this.scatterPlot=a;let s=new Mn.Plots.Scatter;s.x(this.xAccessor,t),s.y(c=>c.displayY,r),s.attr("fill",c=>this.colorScale.scale(c.name)),s.attr("opacity",1),s.size(LKt*2),s.datasets([this.nanDataset]),s.symbol(Mn.SymbolFactories.triangle),this.nanDisplay=s;let l=[s,a,o,i];return this.marginAreaPlot&&l.push(this.marginAreaPlot),this.markersScatterPlot&&l.push(this.markersScatterPlot),new Mn.Components.Group(l)}ignoreYOutliers(t){t!==this._ignoreYOutliers&&(this._ignoreYOutliers=t,this.updateSpecialDatasets(),this.yScale.ignoreOutlier(t),this.resetYDomain())}getValuesForYAxisDomainCompute(){let t=this.getAccessorsForComputingYRange(),r=n=>t.map(i=>n.data().map(o=>i(o,-1,n)));return zs.flattenDeep(this.datasets.map(r)).filter(isFinite)}updateSpecialDatasets(){let t=this.getYAxisAccessor(),r=this.datasets.map(o=>{let a=null,s=o.data().filter(l=>!isNaN(t(l,-1,o)));if(s.length>0){let l=s.length-1;a=s[l],a.name=o.metadata().name,a.relative=r0(a,-1,o)}return a}).filter(o=>o!=null);this.lastPointsDataset.data(r),this.markersScatterPlot&&this.markersScatterPlot.datasets(this.datasets.map(this.createSampledDatasetForMarkers));let n=o=>{let a=null,s=o.data(),l=0;for(;l<s.length&&a==null;)isNaN(t(s[l],-1,o))||(a=t(s[l],-1,o)),l++;a==null&&(a=0);let c=[];for(l=0;l<s.length;l++)isNaN(t(s[l],-1,o))?(s[l].name=o.metadata().name,s[l].displayY=a,s[l].relative=r0(s[l],-1,o),c.push(s[l])):a=t(s[l],-1,o);return c},i=zs.flatten(this.datasets.map(n));this.nanDataset.data(i)}resetDomain(){this.resetXDomain(),this.resetYDomain()}resetXDomain(){let t;if(this._defaultXRange!=null)t=this._defaultXRange;else{let r=this.xScale;r._domainMin=null,r._domainMax=null,t=r._getExtent()}this.xScale.domain(t)}resetYDomain(){this._defaultYRange!=null?this.yScale.domain(this._defaultYRange):(this.yScale.autoDomain(),this.yScale.domain(this.yScale.domain()))}getAccessorsForComputingYRange(){let t=[this.getYAxisAccessor()];return this.fillArea&&t.push(this.fillArea.lowerAccessor,this.fillArea.higherAccessor),t}getYAxisAccessor(){return this.smoothingEnabled?this.smoothedAccessor:this.yValueAccessor}createTooltipInteraction(t){let r=new wB,n=()=>{r.enabled(!1),this.hideTooltips()},i=()=>r.enabled(!0);return t.onPanStart(n),t.onDragZoomStart(n),t.onPanEnd(i),t.onDragZoomEnd(i),t.onScrollZoom(()=>this.updateTooltipContent(this._lastMousePosition)),r.onPointerMove(o=>{this._lastMousePosition=o,this.updateTooltipContent(o)}),r.onPointerExit(()=>this.hideTooltips()),r}updateTooltipContent(t){!this.linePlot||(window.cancelAnimationFrame(this._tooltipUpdateAnimationFrame),this._tooltipUpdateAnimationFrame=window.requestAnimationFrame(()=>{let r={x:t.x,y:t.y},n=this.gridlines.content().node().getBBox(),i=this.linePlot.datasets().map(l=>this.findClosestPoint(r,l)).filter(l=>Boolean(l)),o=Mn.Utils.DOM.intersectsBBox,a=i.filter(l=>o(l.x,l.y,n)||isNaN(this.yValueAccessor(l.datum,0,l.dataset))),s=a.filter(l=>!isNaN(this.yValueAccessor(l.datum,0,l.dataset)));if(i.length!==0){this.scatterPlot.attr("display","none");let l=this.tooltipPointsComponent.content().selectAll(".point").data(s,c=>c.dataset.metadata().name);l.enter().append("circle").classed("point",!0),l.attr("r",gB).attr("cx",c=>c.x).attr("cy",c=>c.y).style("stroke","none").attr("fill",c=>this.colorScale.scale(c.dataset.metadata().name)),l.exit().remove(),this.drawTooltips(a,r,this.tooltipColumns)}else this.hideTooltips()}))}hideTooltips(){window.cancelAnimationFrame(this._tooltipUpdateAnimationFrame),this.tooltip.hide(),this.scatterPlot.attr("display","block"),this.tooltipPointsComponent.content().selectAll(".point").remove()}setupTooltips(t){t.onDetach(()=>{this.tooltipInteraction.detachFrom(t),this.tooltipInteraction.enabled(!1)}),t.onAnchor(()=>{this.tooltipInteraction.attachTo(t),this.tooltipInteraction.enabled(!0)})}drawTooltips(t,r,n){if(!t.length){this.tooltip.hide();return}let{colorScale:i}=this;n=[{title:"",static:!1,evalType:PB.DOM,evaluate(d){return Ht(this).select("span").style("background-color",()=>i.scale(d.dataset.metadata().name)),""},enter(d){Ht(this).append("span").classed("swatch",!0).style("background-color",()=>i.scale(d.dataset.metadata().name))}},...n];let a=Wu(e0),s=d=>Math.pow(d.x-r.x,2)+Math.pow(d.y-r.y,2),l=zs.min(t.map(s)),c=this.smoothingEnabled?this.smoothedAccessor:this.yValueAccessor;this.tooltipSortingMethod==="ascending"?t=zs.sortBy(t,d=>c(d.datum,-1,d.dataset)):this.tooltipSortingMethod==="descending"?t=zs.sortBy(t,d=>c(d.datum,-1,d.dataset)).reverse():this.tooltipSortingMethod==="nearest"?t=zs.sortBy(t,s):t=t.slice(0).reverse();let u=this,h=Ht(this.tooltip.content()).select("table"),f=h.select("thead").selectAll("th").data(n,(d,g,_)=>d.title);f.enter().append("th").text(d=>d.title).nodes(),f.exit().remove();let p=h.select("tbody").selectAll("tr").data(t,(d,g,_)=>d.dataset.metadata().name);p.classed("distant",d=>{let g=d.dataset.data()[0],_=zs.last(d.dataset.data()),y=this.xScale.scale(this.xAccessor(g,0,d.dataset)),x=this.xScale.scale(this.xAccessor(_,0,d.dataset)),b=this.smoothingEnabled?d.datum.smoothed:this.yValueAccessor(d.datum,0,d.dataset);return r.x<y||r.x>x||isNaN(b)}).classed("closest",d=>s(d)===l).each(function(d){u.drawTooltipRow(this,n,d)}).order(),p.exit().remove(),p.enter().append("tr").each(function(d){u.drawTooltipRow(this,n,d)}).nodes(),this.tooltip.updateAndPosition(this.targetSVG.node())}drawTooltipRow(t,r,n){let i=this,o=Ht(t).selectAll("td").data(r);o.each(function(a){a.static||i.drawTooltipColumn.call(i,this,a,n)}),o.exit().remove(),o.enter().append("td").each(function(a){"enter"in a&&a.enter.call(this,n),i.drawTooltipColumn.call(i,this,a,n)})}drawTooltipColumn(t,r,n){let{smoothingEnabled:i}=this;"evalType"in r&&r.evalType==PB.DOM?r.evaluate.call(t,n,{smoothingEnabled:i}):Ht(t).text(r.evaluate.call(t,n,{smoothingEnabled:i}))}findClosestPoint(t,r){let n=r.data().map((s,l)=>this.xScale.scale(this.xAccessor(s,l,r))),i=zs.sortedIndex(n,t.x);if(n.length==0)return null;if(i===n.length)i=i-1;else if(i!==0){let s=Math.abs(n[i-1]-t.x),l=Math.abs(n[i]-t.x);i=s<l?i-1:i}let o=r.data()[i],a=this.smoothingEnabled?this.smoothedAccessor(o,i,r):this.yValueAccessor(o,i,r);return{x:n[i],y:this.yScale.scale(a),datum:o,dataset:r}}resmoothDataset(t){let r=t.data(),n=this.smoothingWeight,i=r.length>0?0:NaN,o=0,a=r.map((l,c)=>this.yValueAccessor(l,c,t)),s=a.every(l=>l==a[0]);r.forEach((l,c)=>{let u=a[c];if(s||!Number.isFinite(u))l.smoothed=u;else{i=i*n+(1-n)*u,o++;let h=1;n!==1&&(h=1-Math.pow(n,o)),l.smoothed=i/h}})}getDataset(t){return this.name2datasets[t]===void 0&&(this.name2datasets[t]=new Mn.Dataset([],{name:t,meta:null})),this.name2datasets[t]}static getYScaleFromType(t){if(t===Ff.LOG)return new CB;if(t===Ff.LINEAR)return new SB;throw new Error("Unrecognized yScale type "+t)}setVisibleSeries(t){this.disableChanges(),t=t.sort(),t.reverse(),this.seriesNames=t}disableChanges(){this.dirtyDatasets.size||(this.linePlot.datasets([]),this.smoothLinePlot&&this.smoothLinePlot.datasets([]),this.marginAreaPlot&&this.marginAreaPlot.datasets([]))}commitChanges(){this.datasets=this.seriesNames.map(t=>this.getDataset(t)),[...this.dirtyDatasets].forEach(t=>{this.smoothingEnabled&&this.resmoothDataset(this.getDataset(t))}),this.updateSpecialDatasets(),this.linePlot.datasets(this.datasets),this.smoothingEnabled&&this.smoothLinePlot.datasets(this.datasets),this.marginAreaPlot&&this.marginAreaPlot.datasets(this.datasets),this.measureBBoxAndMaybeInvalidateLayoutInRaf(),this.dirtyDatasets.clear()}createSampledDatasetForMarkers(t){let r=t.data();if(r.length<=VKt)return t;let n=Math.ceil(r.length/VKt),i=new Array(Math.floor(r.length/n));for(let o=0,a=0;o<i.length;o++,a+=n)i[o]=r[a];return new Mn.Dataset(i,t.metadata())}setSeriesData(t,r){this.disableChanges(),this.getDataset(t).data(r),this.dirtyDatasets.add(t)}setSeriesMetadata(t,r){this.disableChanges(),this.getDataset(t).metadata(Mx(Kl({},this.getDataset(t).metadata()),{meta:r})),this.dirtyDatasets.add(t)}smoothingUpdate(t){this.smoothingWeight=t,this.datasets.forEach(r=>this.resmoothDataset(r)),this.smoothingEnabled||(this.linePlot.addClass("ghost"),this.scatterPlot.y(this.smoothedAccessor,this.yScale),this.smoothingEnabled=!0,this.smoothLinePlot.datasets(this.datasets)),this.markersScatterPlot&&this.markersScatterPlot.y(this.getYAxisAccessor(),this.yScale),this.updateSpecialDatasets()}smoothingDisable(){this.smoothingEnabled&&(this.linePlot.removeClass("ghost"),this.scatterPlot.y(this.yValueAccessor,this.yScale),this.smoothLinePlot.datasets([]),this.smoothingEnabled=!1,this.updateSpecialDatasets()),this.markersScatterPlot&&this.markersScatterPlot.y(this.getYAxisAccessor(),this.yScale)}setColorScale(t){this.colorScale=t}setTooltipColumns(t){this.tooltipColumns=t}setTooltipSortingMethod(t){this.tooltipSortingMethod=t}renderTo(t){this.targetSVG=t,this.outer.renderTo(t),this._defaultXRange!=null&&this.resetXDomain(),this._defaultYRange!=null&&this.resetYDomain(),this.measureBBoxAndMaybeInvalidateLayoutInRaf()}redraw(){window.cancelAnimationFrame(this._redrawRaf),this._redrawRaf=window.requestAnimationFrame(()=>{this.measureBBoxAndMaybeInvalidateLayout(),this.outer.redraw()})}measureBBoxAndMaybeInvalidateLayoutInRaf(){window.cancelAnimationFrame(this._invalidateLayoutRaf),this._invalidateLayoutRaf=window.requestAnimationFrame(()=>{this.measureBBoxAndMaybeInvalidateLayout()})}measureBBoxAndMaybeInvalidateLayout(){if(this._lastDrawBBox){let{width:t}=this._lastDrawBBox,{width:r}=this.targetSVG.node().getBoundingClientRect();t==0&&t<r&&this.outer.invalidateCache()}this._lastDrawBBox=this.targetSVG.node().getBoundingClientRect()}destroy(){window.cancelAnimationFrame(this._redrawRaf),window.cancelAnimationFrame(this._invalidateLayoutRaf),this.outer&&this.outer.destroy()}onAnchor(t){this.outer&&this.outer.onAnchor(t)}isDataFitToDomain(){return t(this.xAxis.getScale())&&t(this.yAxis.getScale());function t(r){let n=r.getTransformationDomain(),i=r.getTransformationExtent();return i[0]===n[0]&&i[1]===n[1]}}};var qKt=Ee(Oe(),1),ist=Ee(wl(),1);_s({moduleName:"plottable-style",styleContent:`
    
.plottable-colors-0 {
  background-color: #5279c7; /* INDIGO */
}

.plottable-colors-1 {
  background-color: #fd373e; /* CORAL_RED */
}

.plottable-colors-2 {
  background-color: #63c261; /* FERN */
}

.plottable-colors-3 {
  background-color: #fad419; /* BRIGHT_SUN */
}

.plottable-colors-4 {
  background-color: #2c2b6f; /* JACARTA */
}

.plottable-colors-5 {
  background-color: #ff7939; /* BURNING_ORANGE */
}

.plottable-colors-6 {
  background-color: #db2e65; /* CERISE_RED */
}

.plottable-colors-7 {
  background-color: #99ce50; /* CONIFER */
}

.plottable-colors-8 {
  background-color: #962565; /* ROYAL_HEATH */
}

.plottable-colors-9 {
  background-color: #06cccc; /* ROBINS_EGG_BLUE */
}

/**
 * User-supplied renderTo element.
 */
.plottable {
  display: block; /* must be block elements for width/height calculations to work in Firefox. */
  pointer-events: visibleFill;
  position: relative;
  /**
   * Pre 3.0, users could set the dimension of the root element in two ways: either using CSS
   * (inline or through a stylesheet), or using the SVG width/height attributes. By default, we
   * set the SVG width/height attributes to 100%.
   *
   * Post 3.0 the root element is always a normal div and the only way to set the dimensions is
   * to use CSS. To replicate the "100%-by-default" behavior, we apply width/height 100%.
   */
  width: 100%;
  height: 100%;
}

/**
 * The _element that roots each Component's DOM.
 */
.plottable .component {
  /* Allow components to be positioned with explicit left/top/width/height styles */
  position: absolute;
}

.plottable .background-container,
.plottable .content,
.plottable .foreground-container {
  position: absolute;
  width: 100%;
  height: 100%;
}

/**
 * Don't allow svg elements above the content to steal events
 */
.plottable .foreground-container {
  pointer-events: none;
}

.plottable .component-overflow-hidden {
  overflow: hidden;
}

.plottable .component-overflow-visible {
  overflow: visible;
}

.plottable .plot-canvas-container {
  width: 100%;
  height: 100%;
  overflow: hidden;
}

.plottable .plot-canvas {
  width: 100%;
  height: 100%;
  /**
   * Play well with deferred rendering.
   */
  transform-origin: 0px 0px 0px;
}

.plottable text {
  text-rendering: geometricPrecision;
}

.plottable .label text {
  fill: #32313F;
}

.plottable .bar-label-text-area text,
.plottable .scatter-label-text-area text {
  font-size: 12px;
}

.plottable .label-area text {
  fill: #32313F;
  font-size: 14px;
}

.plottable .light-label text {
  fill: white;
}

.plottable .dark-label text {
  fill: #32313F;
}

.plottable .off-bar-label text {
  fill: #32313F;
}

.plottable .stacked-bar-label text {
  fill: #32313F;
  font-style: normal;
}

.plottable .stacked-bar-plot .off-bar-label {
  /* HACKHACK #2795: correct off-bar label logic to be implemented on StackedBar */
  visibility: hidden !important;
}

.plottable .axis-label text {
  font-size: 10px;
  font-weight: bold;
  letter-spacing: 1px;
  line-height: normal;
  text-transform: uppercase;
}

.plottable .title-label text {
  font-size: 20px;
  font-weight: bold;
}

.plottable .axis line.baseline {
  stroke: #CCC;
  stroke-width: 1px;
}

.plottable .axis line.tick-mark {
  stroke: #CCC;
  stroke-width: 1px;
}

.plottable .axis text {
  fill: #32313F;
  font-size: 12px;
  font-weight: 200;
  line-height: normal;
}

.plottable .axis .annotation-circle {
  fill: white;
  stroke-width: 1px;
  stroke: #CCC;
}

.plottable .axis .annotation-line {
  stroke: #CCC;
  stroke-width: 1px;
}

.plottable .axis .annotation-rect {
  stroke: #CCC;
  stroke-width: 1px;
  fill: white;
}

.plottable .bar-plot .baseline {
  stroke: #999;
}

.plottable .gridlines line {
  stroke: #3C3C3C; /* hackhack: gridlines should be solid; see #820 */
  opacity: 0.25;
  stroke-width: 1px;
}

.plottable .selection-box-layer .selection-area {
  fill: black;
  fill-opacity: 0.03;
  stroke: #CCC;
}
/* DragBoxLayer */
.plottable .drag-box-layer.x-resizable .drag-edge-lr {
  cursor: ew-resize;
}
.plottable .drag-box-layer.y-resizable .drag-edge-tb {
  cursor: ns-resize;
}

.plottable .drag-box-layer.x-resizable.y-resizable .drag-corner-tl {
  cursor: nwse-resize;
}
.plottable .drag-box-layer.x-resizable.y-resizable .drag-corner-tr {
  cursor: nesw-resize;
}
.plottable .drag-box-layer.x-resizable.y-resizable .drag-corner-bl {
  cursor: nesw-resize;
}
.plottable .drag-box-layer.x-resizable.y-resizable .drag-corner-br {
  cursor: nwse-resize;
}

.plottable .drag-box-layer.movable .selection-area {
  cursor: move; /* IE fallback */
  cursor: -moz-grab;
  cursor: -webkit-grab;
  cursor: grab;
}

.plottable .drag-box-layer.movable .selection-area:active {
  cursor: -moz-grabbing;
  cursor: -webkit-grabbing;
  cursor: grabbing;
}
/* /DragBoxLayer */

.plottable .guide-line-layer line.guide-line {
  stroke: #CCC;
  stroke-width: 1px;
}

.plottable .drag-line-layer.enabled.vertical line.drag-edge {
  cursor: ew-resize;
}

.plottable .drag-line-layer.enabled.horizontal line.drag-edge {
  cursor: ns-resize;
}

.plottable .legend text {
  fill: #32313F;
  font-size: 12px;
  font-weight: bold;
  line-height: normal;
}

.plottable .interpolated-color-legend rect.swatch-bounding-box {
  fill: none;
  stroke: #CCC;
  stroke-width: 1px;
  pointer-events: none;
}

.plottable .waterfall-plot line.connector {
  stroke: #CCC;
  stroke-width: 1px;
}

.plottable .pie-plot .arc.outline {
  stroke-linejoin: round;
}

`});var i0;(function(e){e.GROUP="G",e.DIV="DIV",e.SVG="SVG",e.TEXT="TEXT"})(i0||(i0={}));var rst=class{constructor(t){this.uniqueId=0,this.root=t}exportAsString(){let t=this.convert(this.root);if(!t)return"";let r=this.createRootSvg();return r.appendChild(t),r.outerHTML}createUniqueId(t){return`${t}_${this.uniqueId++}`}getSize(){return this.root.getBoundingClientRect()}createRootSvg(){let t=document.createElement("svg"),r=this.getSize();return t.setAttributeNS("svg","viewBox",`0 0 ${r.width} ${r.height}`),t.setAttribute("xmlns","http://www.w3.org/2000/svg"),t}createConvertedNode(t){let r=t.nodeName.toUpperCase();if(t.nodeType==Node.ELEMENT_NODE&&(r==i0.DIV||r==i0.SVG)){let n=document.createElement(i0.GROUP),i=window.getComputedStyle(t),o=parseInt(i.left,10),a=parseInt(i.top,10);if(o||a){let s=this.createUniqueId("clip");n.setAttribute("transform",`translate(${o}, ${a})`),n.setAttribute("clip-path",`url(#${s})`);let l=parseInt(i.width,10),c=parseInt(i.height,10),u=document.createElement("rect");u.setAttribute("width",String(l)),u.setAttribute("height",String(c));let h=document.createElementNS("svg","clipPath");h.id=s,h.appendChild(u),n.appendChild(h)}return n}else return t.cloneNode()}convert(t){let r=this.createConvertedNode(t);return Array.from(t.childNodes).map(i=>this.convert(i)).filter(Boolean).forEach(i=>{r.appendChild(i)}),r.nodeName.toUpperCase()==i0.GROUP&&!r.hasChildNodes()||this.shouldOmitNode(t)?null:this.stripClass(this.transferStyle(t,r))}stripClass(t){return t.nodeType==Node.ELEMENT_NODE&&t.removeAttribute("class"),t}transferStyle(t,r){if(r.nodeType!=Node.ELEMENT_NODE)return r;let n=r,i=r.nodeName.toUpperCase(),o=window.getComputedStyle(t);return i==i0.TEXT&&Object.assign(n.style,{fontFamily:o.fontFamily,fontSize:o.fontSize,fontWeight:o.fontWeight}),i!=i0.GROUP&&(n.setAttribute("fill",o.fill),n.setAttribute("stroke",o.stroke),n.setAttribute("stroke-width",o.strokeWidth)),o.opacity!="1"&&n.setAttribute("opacity",o.opacity),r}shouldOmitNode(t){return!1}},IB=class extends rst{shouldOmitNode(t){return t.nodeType==Node.ELEMENT_NODE?t.classList.contains("scatter-plot"):!1}};_s({moduleName:"vz-pan-zoom-style",styleContent:`
    .help {
      align-items: center;
      animation-delay: 1s;
      animation-duration: 1s;
      animation-name: fade-out;
      background: rgba(30, 30, 30, 0.6);
      bottom: 0;
      color: #fff;
      display: flex;
      justify-content: center;
      left: 0;
      opacity: 1;
      padding: 20px;
      pointer-events: none;
      position: absolute;
      right: 0;
      top: 0;
    }

    .help > span {
      white-space: normal;
    }

    @keyframes fade-out {
      0% {
        opacity: 1;
      }

      100% {
        opacity: 0;
      }
    }
  `});var Lqe=Wu(e0),UKt=e=>isNaN(e)?"NaN":Lqe(e),ost=[{title:"Name",evaluate:e=>e.dataset.metadata().name},{title:"Smoothed",evaluate(e,t){let{smoothingEnabled:r}=t;return UKt(r?e.datum.smoothed:e.datum.scalar)}},{title:"Value",evaluate:e=>UKt(e.datum.scalar)},{title:"Step",evaluate:e=>x4(e.datum.step)},{title:"Time",evaluate:e=>_B(e.datum.wall_time)},{title:"Relative",evaluate:e=>yB(r0(e.datum,-1,e.dataset))}],Zr=class extends Gt(mt){constructor(){super(...arguments),this.colorScale=new ist.Scales.Color().range(jb.slice(0)),this.smoothingEnabled=!1,this.smoothingWeight=.6,this.xType=null,this.xComponentsCreationMethod=null,this.yValueAccessor=t=>t.scalar,this.tooltipColumns=ost,this.yScaleType=Ff.LINEAR,this.ignoreYOutliers=!1,this.tooltipSortingMethod="default",this.tooltipPosition=G1.BOTTOM,this._visibleSeriesCache=[],this._seriesDataCache={},this._seriesMetadataCache={},this._makeChartAsyncCallbackId=null}ready(){super.ready(),this.scopeSubtree(this.$.chartdiv,!0)}attached(){let t={capture:!0,passive:!0};this._listen(this,"mousedown",this._onMouseDown.bind(this),t),this._listen(this,"mouseup",this._onMouseUp.bind(this),t),this._listen(window,"keydown",this._onKeyDown.bind(this),t),this._listen(window,"keyup",this._onKeyUp.bind(this),t)}detached(){this._makeChartAsyncCallbackId!==null&&(this.cancelAsync(this._makeChartAsyncCallbackId),this._makeChartAsyncCallbackId=null),this._chart&&(this._chart.destroy(),this._chart=void 0),this._listeners&&(this._listeners.forEach(({node:t,eventName:r,func:n,option:i})=>{t.removeEventListener(r,n,i)}),this._listeners.clear())}_listen(t,r,n,i={}){this._listeners||(this._listeners=new Set),this._listeners.add({node:t,eventName:r,func:n,option:i}),t.addEventListener(r,n,i)}_onKeyDown(t){this.toggleClass("pankey",zf.isPanKey(t))}_onKeyUp(t){this.toggleClass("pankey",zf.isPanKey(t))}_onMouseDown(t){this.toggleClass("mousedown",!0)}_onMouseUp(t){this.toggleClass("mousedown",!1)}isDataFitToDomain(){return this._chart?this._chart.isDataFitToDomain():!0}setVisibleSeries(t){qKt.isEqual(this._visibleSeriesCache,t)||(this._visibleSeriesCache=t)}setSeriesData(t,r){this._seriesDataCache[t]=r,this._chart&&this._chart.setSeriesData(t,r)}setSeriesMetadata(t,r){this._seriesMetadataCache[t]=r,this._chart&&this._chart.setSeriesMetadata(t,r)}commitChanges(){!this._chart||this._chart.commitChanges()}resetDomain(){this._chart&&this._chart.resetDomain()}redraw(){this._chart&&this._chart.redraw()}_makeChart(){this._makeChartAsyncCallbackId!==null&&(this.cancelAsync(this._makeChartAsyncCallbackId),this._makeChartAsyncCallbackId=null),this._makeChartAsyncCallbackId=this.async(function(){this._makeChartAsyncCallbackId=null;let t=this.xComponentsCreationMethod;if(!this.xType&&!t?t=$at:this.xType&&(t=()=>vB(this.xType)),!(!t||!this.yValueAccessor||!this.tooltipColumns)){var r=new DS(t,this.yValueAccessor,this.yScaleType,this.colorScale,this.$.tooltip,this.tooltipColumns,this.fillArea,this.defaultXRange,this.defaultYRange,this.symbolFunction,this.xAxisFormatter),n=Ht(this.$.chartdiv);r.renderTo(n),this._chart&&this._chart.destroy(),this._chart=r,this._chart.onAnchor(()=>this.fire("chart-attached"))}},350)}_reloadFromCache(){!this._chart||(this._visibleSeriesCache.forEach(t=>{this._chart.setSeriesData(t,this._seriesDataCache[t]||[])}),this._visibleSeriesCache.filter(t=>this._seriesMetadataCache[t]).forEach(t=>{this._chart.setSeriesMetadata(t,this._seriesMetadataCache[t])}),this._chart.setVisibleSeries(this._visibleSeriesCache),this._chart.commitChanges())}_smoothingChanged(){!this._chart||(this.smoothingEnabled?this._chart.smoothingUpdate(this.smoothingWeight):this._chart.smoothingDisable())}_outliersChanged(){!this._chart||this._chart.ignoreYOutliers(this.ignoreYOutliers)}_colorScaleChanged(){!this._chart||(this._chart.setColorScale(this.colorScale),this._chart.redraw())}_tooltipColumnsChanged(){!this._chart||this._chart.setTooltipColumns(this.tooltipColumns)}_tooltipSortingMethodChanged(){!this._chart||this._chart.setTooltipSortingMethod(this.tooltipSortingMethod)}getExporter(){return new IB(this.$.chartdiv)}};Zr.template=Q`
    <div id="chartdiv"></div>
    <vz-chart-tooltip
      id="tooltip"
      position="[[tooltipPosition]]"
      content-component-name="vz-line-chart-tooltip"
    ></vz-chart-tooltip>
    <style include="plottable-style"></style>
    <style include="vz-pan-zoom-style"></style>
    <style>
      :host {
        -moz-user-select: none;
        -webkit-user-select: none;
        display: flex;
        flex-direction: column;
        flex-grow: 1;
        flex-shrink: 1;
        outline: none;
        position: relative;
        white-space: nowrap;
      }
      div {
        -webkit-user-select: none;
        -moz-user-select: none;
        flex-grow: 1;
        flex-shrink: 1;
      }

      #chartdiv .main {
        contain: strict;
        cursor: crosshair;
      }

      :host(.pankey) #chartdiv :not(.drag-zooming) .main {
        cursor: -webkit-grab;
        cursor: grab;
      }

      :host(.mousedown) #chartdiv .panning .main {
        cursor: -webkit-grabbing;
        cursor: grabbing;
      }

      #chartdiv {
        contain: strict;
      }

      #chartdiv line.guide-line {
        stroke: #999;
        stroke-width: 1.5px;
      }
      #chartdiv:hover .main {
        will-change: transform;
      }

      .ghost {
        opacity: 0.2;
        stroke-width: 1px;
      }

      .plottable .axis text {
        fill: currentColor;
      }

      .plottable .gridlines line {
        stroke: var(--tb-secondary-text-color);
      }
    </style>
  `;E([A({type:Object}),w("design:type",ist.Scales.Color)],Zr.prototype,"colorScale",void 0);E([A({type:Object}),w("design:type",Function)],Zr.prototype,"symbolFunction",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],Zr.prototype,"smoothingEnabled",void 0);E([A({type:Number}),w("design:type",Number)],Zr.prototype,"smoothingWeight",void 0);E([A({type:String}),w("design:type",Object)],Zr.prototype,"xType",void 0);E([A({type:Object}),w("design:type",Object)],Zr.prototype,"xComponentsCreationMethod",void 0);E([A({type:Object}),w("design:type",Function)],Zr.prototype,"xAxisFormatter",void 0);E([A({type:Object}),w("design:type",Function)],Zr.prototype,"yValueAccessor",void 0);E([A({type:Array}),w("design:type",Array)],Zr.prototype,"tooltipColumns",void 0);E([A({type:Object}),w("design:type",Object)],Zr.prototype,"fillArea",void 0);E([A({type:Array}),w("design:type",Array)],Zr.prototype,"defaultXRange",void 0);E([A({type:Array}),w("design:type",Array)],Zr.prototype,"defaultYRange",void 0);E([A({type:String}),w("design:type",String)],Zr.prototype,"yScaleType",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Zr.prototype,"ignoreYOutliers",void 0);E([A({type:String}),w("design:type",String)],Zr.prototype,"tooltipSortingMethod",void 0);E([A({type:String}),w("design:type",String)],Zr.prototype,"tooltipPosition",void 0);E([A({type:Object}),w("design:type",Object)],Zr.prototype,"_chart",void 0);E([A({type:Array}),w("design:type",Array)],Zr.prototype,"_visibleSeriesCache",void 0);E([A({type:Object}),w("design:type",Object)],Zr.prototype,"_seriesDataCache",void 0);E([A({type:Object}),w("design:type",Object)],Zr.prototype,"_seriesMetadataCache",void 0);E([A({type:Number}),w("design:type",Object)],Zr.prototype,"_makeChartAsyncCallbackId",void 0);E([Bt("xComponentsCreationMethod","xType","yValueAccessor","yScaleType","isAttached"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_makeChart",null);E([Bt("_chart","_visibleSeriesCache"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_reloadFromCache",null);E([Bt("smoothingEnabled","smoothingWeight","_chart"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_smoothingChanged",null);E([Bt("ignoreYOutliers","_chart"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_outliersChanged",null);E([Bt("colorScale"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_colorScaleChanged",null);E([Bt("tooltipColumns"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_tooltipColumnsChanged",null);E([Bt("tooltipSortingMethod","_chart"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Zr.prototype,"_tooltipSortingMethodChanged",null);Zr=E([yt("vz-line-chart2")],Zr);var nst=class extends mt{};nst.template=Q`
    <div class="content">
      <table>
        <thead></thead>
        <tbody></tbody>
      </table>
    </div>
    <style>
      :host {
        pointer-events: none;
      }

      .content {
        background: rgba(0, 0, 0, 0.8);
        border-radius: 4px;
        color: #fff;
        overflow: hidden;
        pointer-events: none;
      }

      table {
        font-size: 13px;
        line-height: 1.4em;
        margin-top: 10px;
        padding: 8px;
      }

      thead {
        font-size: 14px;
      }

      tbody {
        font-size: 13px;
        line-height: 21px;
        white-space: nowrap;
      }

      td {
        padding: 0 5px;
      }

      .swatch {
        border-radius: 50%;
        display: block;
        height: 18px;
        width: 18px;
      }

      .closest .swatch {
        box-shadow: inset 0 0 0 2px #fff;
      }

      th {
        padding: 0 5px;
        text-align: left;
      }

      .distant td:not(.swatch) {
        opacity: 0.8;
      }

      .ghost {
        opacity: 0.2;
        stroke-width: 1px;
      }
    </style>
  `;nst=E([yt("vz-line-chart-tooltip")],nst);var ast=[],kqe=0,Rqe=GKt.throttle(function e(){if(ast.length==0)return;let t=ast.shift();t&&t.active&&(t.redraw(),t._maybeRenderedInBadState=!1),window.cancelAnimationFrame(kqe),window.requestAnimationFrame(e)},100),Vn=class extends kS(Gt(mt)){constructor(){super(...arguments),this._redrawRaf=null,this.active=!1,this.logScaleActive=!1,this.colorScale={scale:fn},this._resetDomainOnNextLoad=!0,this._maybeRenderedInBadState=!1}onLoadFinish(){this.commitChanges(),this.dataToLoad.length>0&&this._resetDomainOnNextLoad&&(this._resetDomainOnNextLoad=!1,this.getChart().resetDomain()),this.redraw()}disconnectedCallback(){super.disconnectedCallback(),this._redrawRaf!==null&&cancelAnimationFrame(this._redrawRaf)}exportAsSvgString(){return this.getChart().getExporter().exportAsString()}getChart(){return this.$.chart}resetDomain(){this.getChart().resetDomain()}setSeriesData(t,r){this.getChart().setSeriesData(t,r)}setSeriesMetadata(t,r){this.getChart().setSeriesMetadata(t,r)}commitChanges(){this.getChart().commitChanges()}redraw(){this._redrawRaf!==null&&cancelAnimationFrame(this._redrawRaf),this._redrawRaf=window.requestAnimationFrame(()=>{this.active?this.getChart().redraw():this._maybeRenderedInBadState=!0})}_loadKeyChanged(){this.reset(),this._resetDomainOnNextLoad=!0}_dataSeriesChanged(){this.getChart().setVisibleSeries(this.dataSeries)}_logScaleChanged(t){let r=this.getChart();r.yScaleType=t?Ff.LOG:Ff.LINEAR,this.redraw()}_fixBadStateWhenActive(){this.active&&this._maybeRenderedInBadState&&(ast.push(this),Rqe())}_onChartAttached(){this.active||(this._maybeRenderedInBadState=!0)}};Vn.template=Q`
    <div id="chart-and-spinner-container">
      <vz-line-chart2
        id="chart"
        data-loading$="[[dataLoading]]"
        data-loaded-once$="[[dataLoadedAtLeastOnce]]"
        color-scale="[[colorScale]]"
        default-x-range="[[defaultXRange]]"
        default-y-range="[[defaultYRange]]"
        fill-area="[[fillArea]]"
        ignore-y-outliers="[[ignoreYOutliers]]"
        on-chart-attached="_onChartAttached"
        smoothing-enabled="[[smoothingEnabled]]"
        smoothing-weight="[[smoothingWeight]]"
        symbol-function="[[symbolFunction]]"
        tooltip-columns="[[tooltipColumns]]"
        tooltip-position="[[tooltipPosition]]"
        tooltip-sorting-method="[[tooltipSortingMethod]]"
        x-components-creation-method="[[xComponentsCreationMethod]]"
        x-type="[[xType]]"
        y-value-accessor="[[yValueAccessor]]"
      ></vz-line-chart2>
      <template is="dom-if" if="[[dataLoading]]">
        <div id="loading-spinner-container">
          <paper-spinner-lite active=""></paper-spinner-lite>
        </div>
      </template>
    </div>
    <style>
      :host {
        height: 100%;
        width: 100%;
        display: flex;
        flex-direction: column;
      }

      :host([_maybe-rendered-in-bad-state]) vz-line-chart {
        visibility: hidden;
      }

      #chart-and-spinner-container {
        display: flex;
        flex-grow: 1;
        position: relative;
      }

      #loading-spinner-container {
        align-items: center;
        bottom: 0;
        display: flex;
        display: flex;
        justify-content: center;
        left: 0;
        pointer-events: none;
        position: absolute;
        right: 0;
        top: 0;
      }

      vz-line-chart2 {
        -webkit-user-select: none;
        -moz-user-select: none;
      }

      vz-line-chart2[data-loading] {
        opacity: 0.3;
      }
    </style>
  `;E([A({type:Boolean,observer:"_fixBadStateWhenActive"}),w("design:type",Boolean)],Vn.prototype,"active",void 0);E([A({type:Array}),w("design:type",Array)],Vn.prototype,"dataSeries",void 0);E([A({type:Object}),w("design:type",Ae)],Vn.prototype,"requestManager",void 0);E([A({type:Boolean,observer:"_logScaleChanged"}),w("design:type",Boolean)],Vn.prototype,"logScaleActive",void 0);E([A({type:Object}),w("design:type",Object)],Vn.prototype,"xComponentsCreationMethod",void 0);E([A({type:String}),w("design:type",String)],Vn.prototype,"xType",void 0);E([A({type:Object}),w("design:type",Function)],Vn.prototype,"yValueAccessor",void 0);E([A({type:Object}),w("design:type",Object)],Vn.prototype,"fillArea",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Vn.prototype,"smoothingEnabled",void 0);E([A({type:Number}),w("design:type",Number)],Vn.prototype,"smoothingWeight",void 0);E([A({type:Array}),w("design:type",Array)],Vn.prototype,"tooltipColumns",void 0);E([A({type:String}),w("design:type",Object)],Vn.prototype,"tooltipSortingMethod",void 0);E([A({type:String}),w("design:type",String)],Vn.prototype,"tooltipPosition",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Vn.prototype,"ignoreYOutliers",void 0);E([A({type:Array}),w("design:type",Array)],Vn.prototype,"defaultXRange",void 0);E([A({type:Array}),w("design:type",Array)],Vn.prototype,"defaultYRange",void 0);E([A({type:Object}),w("design:type",Function)],Vn.prototype,"symbolFunction",void 0);E([A({type:Object}),w("design:type",Object)],Vn.prototype,"colorScale",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Vn.prototype,"_resetDomainOnNextLoad",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],Vn.prototype,"_maybeRenderedInBadState",void 0);E([Bt("loadKey"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Vn.prototype,"_loadKeyChanged",null);E([Bt("dataSeries.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Vn.prototype,"_dataSeriesChanged",null);Vn=E([yt("tf-line-chart-data-loader")],Vn);_s({moduleName:"tf-custom-scalar-card-style",styleContent:`
    :host {
      margin: 5px 10px;
      display: inline-block;
      width: 330px;
      vertical-align: text-top;
    }

    :host([_expanded]) {
      width: 100%;
    }

    :host([_expanded]) #tf-line-chart-data-loader-container {
      height: 400px;
    }

    h1 {
      font-size: 19px;
      font-weight: normal;
    }

    #tf-line-chart-data-loader-container {
      height: 200px;
      width: 100%;
    }

    #buttons {
      display: flex;
      flex-direction: row;
    }

    paper-icon-button {
      color: #2196f3;
      border-radius: 100%;
      width: 32px;
      height: 32px;
      padding: 4px;
    }

    paper-icon-button[selected] {
      background: var(--tb-ui-light-accent);
    }

    .download-links {
      display: flex;
      height: 32px;
    }

    .download-links a {
      font-size: 10px;
      align-self: center;
      margin: 2px;
    }

    .download-links paper-dropdown-menu {
      width: 100px;
      --paper-input-container-label: {
        font-size: 10px;
      }
      --paper-input-container-input: {
        font-size: 10px;
      }
    }
  `});var OS=class{constructor(t,r,n,i,o){this.run=t,this.tag=r,this.name=n,this.scalarData=i,this.symbol=o}getName(){return this.name}setData(t){this.scalarData=t}getData(){return this.scalarData}getRun(){return this.run}getTag(){return this.tag}getSymbol(){return this.symbol}};function LB(e,t){return`${t} (${e})`}var W1=class{constructor(t){this.runBasedColorScale=t}scale(t){return this.runBasedColorScale.scale(this.parseRunName(t))}parseRunName(t){let r=t.match(/\((.*)\)$/);return r?r[1]:""}};var Jr=class extends Gt(mt){constructor(){super(...arguments),this.active=!0,this._colorScale=new W1({scale:fn}),this._nameToDataSeries={},this._expanded=!1,this._requestData=(t,r,n)=>{let o=ve().pluginRoute("custom_scalars","/scalars");Promise.all(t.map(a=>{let s=a,l=this._tagFilter,c=Cn(o,{tag:l,run:s});return this.requestManager.request(c).then(u=>void r({item:a,data:u}))})).finally(()=>void n())},this._runToNextAvailableSymbolIndex={},this._matchesListOpened=!1,this._fillArea={lowerAccessor:t=>t.lower,higherAccessor:t=>t.upper},this._tooltipColumns=(()=>{let t=Wu(e0),r=n=>isNaN(n)?"NaN":t(n);return[{title:"Name",evaluate:n=>n.dataset.metadata().name},{title:"Value",evaluate:n=>r(n.datum.scalar)},{title:"Lower Margin",evaluate:n=>r(n.datum.lower)},{title:"Upper Margin",evaluate:n=>r(n.datum.upper)},{title:"Step",evaluate:n=>x4(n.datum.step)},{title:"Time",evaluate:n=>_B(n.datum.wall_time)},{title:"Relative",evaluate:n=>yB(r0(n.datum,-1,n.dataset))}]})(),this._missingTags=[],this._missingTagsCollapsibleOpened=!1}reload(){this.$.loader.reload()}redraw(){this.$.loader.redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}_toggleLogScale(){this.set("_logScaleActive",!this._logScaleActive)}_resetDomain(){let t=this.$.loader;t&&t.resetDomain()}_csvUrl(t,r){if(!r)return"";let n=this._downloadDataUrl(t,r);return Cn(n,{format:"csv"})}_jsonUrl(t,r){if(!r)return"";let n=this._downloadDataUrl(t,r);return Cn(n,{format:"json"})}_downloadDataUrl(t,r){let n=t[r],i={tag:n.getTag(),run:n.getRun()};return Cn(ve().pluginRoute("custom_scalars","/download_data"),i)}_createProcessDataFunction(t){return(r,n,i)=>{if(!i.regex_valid){this.set("_tagFilterInvalid",!0);return}let o=Yo.clone(this._nameToDataSeries),a=[];Yo.forEach(t,l=>{let c=!1,u=i.tag_to_events[l.value],h=i.tag_to_events[l.lower],f=i.tag_to_events[l.upper];if(Yo.isUndefined(u)&&(a.push(l.value),c=!0),Yo.isUndefined(h)&&(a.push(l.lower),c=!0),Yo.isUndefined(f)&&(a.push(l.upper),c=!0),c)return;let p=b=>b[1],d=this._findStepMismatch(l,u.map(p),h.map(p),f.map(p));if(d){this.set("_stepsMismatch",d);return}let g=b=>b[2],_=u.map((b,S)=>({wall_time:new Date(b[0]*1e3),step:p(b),scalar:g(b),lower:g(h[S]),upper:g(f[S])})),y=LB(n,l.value),x=o[y];if(x)x.setData(_);else{let b=this._createNewDataSeries(n,l.value,y,_);o[y]=b}}),this.set("_nameToDataSeries",o);let s=Yo.findIndex(this._missingTags,l=>l.run===n);if(a.length&&a.length!=3){let l={run:n,tags:a};s>=0?this.splice("_missingTags",s,1,l):this.push("_missingTags",l)}else s>=0&&this.splice("_missingTags",s,1)}}_findStepMismatch(t,r,n,i){return Yo.isEqual(n,r)&&Yo.isEqual(i,r)?null:{seriesObject:t,valueSteps:r,lowerSteps:n,upperSteps:i}}_createNewDataSeries(t,r,n,i){this._runToNextAvailableSymbolIndex[t]|=0;let o=RS[this._runToNextAvailableSymbolIndex[t]],a=new OS(t,r,n,i,o),s=RS.length;return this._runToNextAvailableSymbolIndex[t]=(this._runToNextAvailableSymbolIndex[t]+1)%s,a}_updateChart(){var t=this._nameToDataSeries;Yo.forOwn(t,r=>{this.$.loader.setSeriesData(r.getName(),r.getData())}),this.$.loader.commitChanges()}get _seriesNames(){let t=new Set(this.runs);return Object.entries(this._nameToDataSeries).filter(([r,n])=>t.has(n.run)).map(([r])=>r)}_determineColor(t,r){return t.scale(r)}_refreshDataSeries(){var t=this._tagFilter;this.set("_nameToDataSeries",{})}_createSymbolFunction(){return t=>this._nameToDataSeries[t].getSymbol().method()}_determineSymbol(t,r){return t[r].getSymbol().character}get _tagFilter(){var t=this.marginChartSeries;return Yo.flatten(t.map(i=>[i.value,i.lower,i.upper])).map(i=>"("+this._escapeRegexCharacters(i)+")").join("|")}_escapeRegexCharacters(t){return t.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}_getToggleCollapsibleIcon(t){return t?"expand-less":"expand-more"}_toggleMatchesOpen(){this.set("_matchesListOpened",!this._matchesListOpened)}get _titleDisplayString(){var t=this.title;return t||"untitled"}_separateWithCommas(t){return t.join(", ")}_toggleMissingTagsCollapsibleOpen(){this.set("_missingTagsCollapsibleOpened",!this._missingTagsCollapsibleOpened)}_matchListEntryColorUpdated(){var r;let t=this.$$("#match-list-repeat");!t||(r=this.root)==null||r.querySelectorAll(".match-list-entry").forEach(n=>{let i=t.itemForElement(n);n.style.color=this._determineColor(this._colorScale,i)})}};Jr.template=Q`
    <tf-card-heading display-name="[[_titleDisplayString]]"></tf-card-heading>
    <div id="tf-line-chart-data-loader-container">
      <tf-line-chart-data-loader
        id="loader"
        active="[[active]]"
        color-scale="[[_colorScale]]"
        data-series="[[_seriesNames]]"
        fill-area="[[_fillArea]]"
        ignore-y-outliers="[[ignoreYOutliers]]"
        load-key="[[_tagFilter]]"
        data-to-load="[[runs]]"
        request-data="[[_requestData]]"
        log-scale-active="[[_logScaleActive]]"
        load-data-callback="[[_createProcessDataFunction(marginChartSeries)]]"
        request-manager="[[requestManager]]"
        symbol-function="[[_createSymbolFunction()]]"
        tooltip-columns="[[_tooltipColumns]]"
        tooltip-sorting-method="[[tooltipSortingMethod]]"
        x-type="[[xType]]"
      >
      </tf-line-chart-data-loader>
    </div>
    <div id="buttons">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
      <paper-icon-button
        selected$="[[_logScaleActive]]"
        icon="line-weight"
        on-tap="_toggleLogScale"
        title="Toggle y-axis log scale"
      ></paper-icon-button>
      <paper-icon-button
        icon="settings-overscan"
        on-tap="_resetDomain"
        title="Fit domain to data"
      ></paper-icon-button>
      <span style="flex-grow: 1"></span>
      <template is="dom-if" if="[[showDownloadLinks]]">
        <div class="download-links">
          <paper-dropdown-menu
            no-label-float="true"
            label="series to download"
            selected-item-label="{{_dataSeriesNameToDownload}}"
          >
            <paper-listbox class="dropdown-content" slot="dropdown-content">
              <template
                is="dom-repeat"
                items="[[_seriesNames]]"
                as="dataSeriesName"
              >
                <paper-item no-label-float="true"
                  >[[dataSeriesName]]</paper-item
                >
              </template>
            </paper-listbox>
          </paper-dropdown-menu>
          <a
            download="[[_dataSeriesNameToDownload]].csv"
            href="[[_csvUrl(_nameToDataSeries, _dataSeriesNameToDownload)]]"
            >CSV</a
          >
          <a
            download="[[_dataSeriesNameToDownload]].json"
            href="[[_jsonUrl(_nameToDataSeries, _dataSeriesNameToDownload)]]"
            >JSON</a
          >
        </div>
      </template>
    </div>

    <!-- here -->
    <template is="dom-if" if="[[_missingTags.length]]">
      <div class="collapsible-list-title">
        <paper-icon-button
          icon="[[_getToggleCollapsibleIcon(_missingTagsCollapsibleOpened)]]"
          on-click="_toggleMissingTagsCollapsibleOpen"
          class="toggle-collapsible-button"
        >
        </paper-icon-button>
        <span class="collapsible-title-text">
          <iron-icon icon="icons:error"></iron-icon> Missing Tags
        </span>
      </div>
      <iron-collapse opened="[[_missingTagsCollapsibleOpened]]">
        <div class="error-content">
          <iron-icon class="error-icon" icon="icons:error"></iron-icon>
          <template is="dom-repeat" items="[[_missingTags]]" as="missingEntry">
            <div class="missing-tags-for-run-container">
              Run "[[missingEntry.run]]" lacks data for tags
              <ul>
                <template
                  is="dom-repeat"
                  items="[[missingEntry.tags]]"
                  as="tag"
                >
                  <li>[[tag]]</li>
                </template>
              </ul>
            </div>
          </template>
        </div>
      </iron-collapse>
    </template>

    <template is="dom-if" if="[[_tagFilterInvalid]]">
      <div class="error-content">
        <iron-icon class="error-icon" icon="icons:error"></iron-icon>
        This regular expresion is invalid:<br />
        <span class="invalid-regex">[[_tagFilter]]</span>
      </div>
    </template>

    <template is="dom-if" if="[[_stepsMismatch]]">
      <div class="error-content">
        <iron-icon class="error-icon" icon="icons:error"></iron-icon>
        The steps for value, lower, and upper tags do not match:
        <ul>
          <li>
            <span class="tag-name">[[_stepsMismatch.seriesObject.value]]</span>:
            [[_separateWithCommas(_stepsMismatch.valueSteps)]]
          </li>
          <li>
            <span class="tag-name">[[_stepsMismatch.seriesObject.lower]]</span>:
            [[_separateWithCommas(_stepsMismatch.lowerSteps)]]
          </li>
          <li>
            <span class="tag-name">[[_stepsMismatch.seriesObject.upper]]</span>:
            [[_separateWithCommas(_stepsMismatch.upperSteps)]]
          </li>
        </ul>
      </div>
    </template>

    <div id="matches-container">
      <div class="collapsible-list-title">
        <template is="dom-if" if="[[_seriesNames.length]]">
          <paper-icon-button
            icon="[[_getToggleCollapsibleIcon(_matchesListOpened)]]"
            on-click="_toggleMatchesOpen"
            class="toggle-matches-button"
          >
          </paper-icon-button>
        </template>

        <span class="collapsible-title-text">
          Matches ([[_seriesNames.length]])
        </span>
      </div>
      <template is="dom-if" if="[[_seriesNames.length]]">
        <iron-collapse opened="[[_matchesListOpened]]">
          <div id="matches-list">
            <template
              is="dom-repeat"
              items="[[_seriesNames]]"
              as="seriesName"
              id="match-list-repeat"
              on-dom-change="_matchListEntryColorUpdated"
            >
              <div class="match-list-entry">
                <span class="match-entry-symbol">
                  [[_determineSymbol(_nameToDataSeries, seriesName)]]
                </span>
                [[seriesName]]
              </div>
            </template>
          </div>
        </iron-collapse>
      </template>
    </div>

    <style include="tf-custom-scalar-card-style"></style>
    <style>
      .error-content {
        background: #f00;
        border-radius: 5px;
        color: #fff;
        margin: 10px 0 0 0;
        padding: 10px;
      }

      .error-icon {
        display: block;
        fill: #fff;
        margin: 0 auto 5px auto;
      }

      .invalid-regex {
        font-weight: bold;
      }

      .error-content ul {
        margin: 1px 0 0 0;
        padding: 0 0 0 19px;
      }

      .tag-name {
        font-weight: bold;
      }

      .collapsible-list-title {
        margin: 10px 0 5px 0;
      }

      .collapsible-title-text {
        vertical-align: middle;
      }

      #matches-list {
        max-height: 200px;
        overflow-y: auto;
      }

      .match-list-entry {
        margin: 0 0 5px 0;
      }

      .match-entry-symbol {
        font-family: arial, sans-serif;
        display: inline-block;
        width: 10px;
      }

      .missing-tags-for-run-container {
        margin: 8px 0 0 0;
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],Jr.prototype,"runs",void 0);E([A({type:String}),w("design:type",String)],Jr.prototype,"xType",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"active",void 0);E([A({type:String}),w("design:type",String)],Jr.prototype,"title",void 0);E([A({type:Array}),w("design:type",Array)],Jr.prototype,"marginChartSeries",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"ignoreYOutliers",void 0);E([A({type:Object}),w("design:type",Ae)],Jr.prototype,"requestManager",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"showDownloadLinks",void 0);E([A({type:Object}),w("design:type",Object)],Jr.prototype,"tagMetadata",void 0);E([A({type:String}),w("design:type",String)],Jr.prototype,"tooltipSortingMethod",void 0);E([A({type:Object}),w("design:type",Object)],Jr.prototype,"_colorScale",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"_tagFilterInvalid",void 0);E([A({type:Object}),w("design:type",Object)],Jr.prototype,"_nameToDataSeries",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],Jr.prototype,"_expanded",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"_logScaleActive",void 0);E([A({type:Object}),w("design:type",Function)],Jr.prototype,"_requestData",void 0);E([A({type:Object}),w("design:type",Object)],Jr.prototype,"_runToNextAvailableSymbolIndex",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"_matchesListOpened",void 0);E([A({type:Object}),w("design:type",Object)],Jr.prototype,"_fillArea",void 0);E([A({type:Array}),w("design:type",Array)],Jr.prototype,"_tooltipColumns",void 0);E([A({type:Array}),w("design:type",Array)],Jr.prototype,"_missingTags",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Jr.prototype,"_missingTagsCollapsibleOpened",void 0);E([A({type:Object}),w("design:type",Object)],Jr.prototype,"_stepsMismatch",void 0);E([Bt("_nameToDataSeries"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Jr.prototype,"_updateChart",null);E([Rt("_nameToDataSeries","runs"),w("design:type",Object),w("design:paramtypes",[])],Jr.prototype,"_seriesNames",null);E([Bt("_tagFilter"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Jr.prototype,"_refreshDataSeries",null);E([Rt("marginChartSeries"),w("design:type",String),w("design:paramtypes",[])],Jr.prototype,"_tagFilter",null);E([Rt("title"),w("design:type",String),w("design:paramtypes",[])],Jr.prototype,"_titleDisplayString",null);Jr=E([yt("tf-custom-scalar-margin-chart-card")],Jr);var o0=Ee(Oe(),1);var kB={};Ks(kB,{BaseStore:()=>bp,Canceller:()=>an,EnvironmentStore:()=>H9,ExperimentsStore:()=>eR,HttpMethodType:()=>Am,InvalidRequestOptionsError:()=>Vx,ListenKey:()=>B9,RequestCancellationError:()=>l9,RequestManager:()=>Ae,RequestNetworkError:()=>cE,RequestOptions:()=>Ux,RunsStore:()=>V9,TYPES:()=>Lxe,addParams:()=>Cn,createRouter:()=>Pgt,createSearchParam:()=>eW,environmentStore:()=>ib,experimentsStore:()=>rR,filterTags:()=>Rxe,getRouter:()=>ve,getRunsNamed:()=>kxe,getTags:()=>$i,runsStore:()=>wp,setRouter:()=>Hxe});var En=class extends Gt(mt){constructor(){super(...arguments),this.active=!0,this._colorScale=new W1({scale:fn}),this._nameToDataSeries={},this._expanded=!1,this._requestData=(t,r,n)=>{let o=ve().pluginRoute("custom_scalars","/scalars");Promise.all(t.map(a=>{let s=a,l=this._tagFilter,c=Cn(o,{tag:l,run:s});return this.requestManager.request(c).then(u=>void r({item:a,data:u}))})).finally(()=>void n())},this._runToNextAvailableSymbolIndex={},this._matchesListOpened=!1}reload(){this.$.loader.reload()}redraw(){this.$.loader.redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}_toggleLogScale(){this.set("_logScaleActive",!this._logScaleActive)}_resetDomain(){let t=this.$.loader;t&&t.resetDomain()}_csvUrl(t,r){if(!r)return"";let n=this._downloadDataUrl(t,r);return Cn(n,{format:"csv"})}_jsonUrl(t,r){if(!r)return"";let n=this._downloadDataUrl(t,r);return Cn(n,{format:"json"})}_downloadDataUrl(t,r){let n=t[r],i={tag:n.getTag(),run:n.getRun()};return Cn(ve().pluginRoute("custom_scalars","/download_data"),i)}_createProcessDataFunction(){return(t,r,n)=>{if(n.regex_valid){let i=o0.clone(this._nameToDataSeries);o0.forOwn(n.tag_to_events,(o,a)=>{let s=o.map(u=>({wall_time:new Date(u[0]*1e3),step:u[1],scalar:u[2]})),l=LB(r,a),c=i[l];if(c)c.setData(s);else{o0.isUndefined(this._runToNextAvailableSymbolIndex[r])&&(this._runToNextAvailableSymbolIndex[r]=0);let u=RS[this._runToNextAvailableSymbolIndex[r]],h=new OS(r,a,l,s,u);i[l]=h;let f=RS.length;this._runToNextAvailableSymbolIndex[r]=(this._runToNextAvailableSymbolIndex[r]+1)%f}}),this.set("_nameToDataSeries",i)}}}_updateChart(){var t=this._nameToDataSeries;Object.entries(t).forEach(([r,n])=>{this.$.loader.setSeriesData(r,n.getData())}),this.$.loader.commitChanges()}_computeSelectedRunsSet(t){let r={};return o0.forEach(t,n=>{r[n]=1}),r}get _seriesNames(){let t=new Set(this.runs);return Object.entries(this._nameToDataSeries).filter(([r,n])=>t.has(n.run)).map(([r])=>r)}_determineColor(t,r){return t.scale(r)}_refreshDataSeries(){var t=this._tagFilter;this.set("_nameToDataSeries",{})}_createSymbolFunction(){return t=>this._nameToDataSeries[t].getSymbol().method()}_determineSymbol(t,r){return t[r].getSymbol().character}get _tagFilter(){var t=this.tagRegexes;return t.length===1?t[0]:t.map(r=>"("+r+")").join("|")}_getToggleMatchesIcon(t){return t?"expand-less":"expand-more"}_toggleMatchesOpen(){this.set("_matchesListOpened",!this._matchesListOpened)}get _titleDisplayString(){var t=this.title;return t||"untitled"}_matchListEntryColorUpdated(t){var n;let r=this.$$("#match-list-repeat");!r||(n=this.root)==null||n.querySelectorAll(".match-list-entry").forEach(i=>{let o=r.itemForElement(i);i.style.color=this._determineColor(this._colorScale,o)})}};En.template=Q`
    <tf-card-heading display-name="[[_titleDisplayString]]"></tf-card-heading>
    <div id="tf-line-chart-data-loader-container">
      <tf-line-chart-data-loader
        id="loader"
        active="[[active]]"
        color-scale="[[_colorScale]]"
        data-series="[[_seriesNames]]"
        ignore-y-outliers="[[ignoreYOutliers]]"
        load-key="[[_tagFilter]]"
        data-to-load="[[runs]]"
        request-data="[[_requestData]]"
        log-scale-active="[[_logScaleActive]]"
        load-data-callback="[[_createProcessDataFunction()]]"
        request-manager="[[requestManager]]"
        smoothing-enabled="[[smoothingEnabled]]"
        smoothing-weight="[[smoothingWeight]]"
        symbol-function="[[_createSymbolFunction()]]"
        tooltip-sorting-method="[[tooltipSortingMethod]]"
        x-type="[[xType]]"
      >
      </tf-line-chart-data-loader>
    </div>
    <div id="buttons">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
      <paper-icon-button
        selected$="[[_logScaleActive]]"
        icon="line-weight"
        on-tap="_toggleLogScale"
        title="Toggle y-axis log scale"
      ></paper-icon-button>
      <paper-icon-button
        icon="settings-overscan"
        on-tap="_resetDomain"
        title="Fit domain to data"
      ></paper-icon-button>
      <span style="flex-grow: 1"></span>
      <template is="dom-if" if="[[showDownloadLinks]]">
        <div class="download-links">
          <paper-dropdown-menu
            no-label-float="true"
            label="series to download"
            selected-item-label="{{_dataSeriesNameToDownload}}"
          >
            <paper-listbox class="dropdown-content" slot="dropdown-content">
              <template
                is="dom-repeat"
                items="[[_seriesNames]]"
                as="dataSeriesName"
              >
                <paper-item no-label-float="true"
                  >[[dataSeriesName]]</paper-item
                >
              </template>
            </paper-listbox>
          </paper-dropdown-menu>
          <a
            download="[[_dataSeriesNameToDownload]].csv"
            href="[[_csvUrl(_nameToDataSeries, _dataSeriesNameToDownload)]]"
            >CSV</a
          >
          <a
            download="[[_dataSeriesNameToDownload]].json"
            href="[[_jsonUrl(_nameToDataSeries, _dataSeriesNameToDownload)]]"
            >JSON</a
          >
        </div>
      </template>
    </div>
    <div id="matches-container">
      <div id="matches-list-title">
        <template is="dom-if" if="[[_seriesNames.length]]">
          <paper-icon-button
            icon="[[_getToggleMatchesIcon(_matchesListOpened)]]"
            on-click="_toggleMatchesOpen"
            class="toggle-matches-button"
          >
          </paper-icon-button>
        </template>

        <span class="matches-text"> Matches ([[_seriesNames.length]]) </span>
      </div>
      <template is="dom-if" if="[[_seriesNames.length]]">
        <iron-collapse opened="[[_matchesListOpened]]">
          <div id="matches-list">
            <template
              is="dom-repeat"
              items="[[_seriesNames]]"
              as="seriesName"
              id="match-list-repeat"
              on-dom-change="_matchListEntryColorUpdated"
            >
              <div class="match-list-entry">
                <span class="match-entry-symbol">
                  [[_determineSymbol(_nameToDataSeries, seriesName)]]
                </span>
                [[seriesName]]
              </div>
            </template>
          </div>
        </iron-collapse>
      </template>
    </div>

    <style include="tf-custom-scalar-card-style"></style>
    <style>
      #matches-list-title {
        margin: 10px 0 5px 0;
      }

      #matches-list {
        max-height: 200px;
        overflow-y: auto;
      }

      .match-list-entry {
        margin: 0 0 5px 0;
      }

      .match-entry-symbol {
        font-family: arial, sans-serif;
        display: inline-block;
        width: 10px;
      }

      .matches-text {
        vertical-align: middle;
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],En.prototype,"runs",void 0);E([A({type:String}),w("design:type",String)],En.prototype,"xType",void 0);E([A({type:Boolean}),w("design:type",Boolean)],En.prototype,"active",void 0);E([A({type:String}),w("design:type",String)],En.prototype,"title",void 0);E([A({type:Array}),w("design:type",Array)],En.prototype,"tagRegexes",void 0);E([A({type:Boolean}),w("design:type",Boolean)],En.prototype,"ignoreYOutliers",void 0);E([A({type:Object}),w("design:type",Ae)],En.prototype,"requestManager",void 0);E([A({type:Boolean}),w("design:type",Boolean)],En.prototype,"showDownloadLinks",void 0);E([A({type:Boolean}),w("design:type",Boolean)],En.prototype,"smoothingEnabled",void 0);E([A({type:Number}),w("design:type",Number)],En.prototype,"smoothingWeight",void 0);E([A({type:Object}),w("design:type",Object)],En.prototype,"tagMetadata",void 0);E([A({type:String}),w("design:type",String)],En.prototype,"tooltipSortingMethod",void 0);E([A({type:Object}),w("design:type",W1)],En.prototype,"_colorScale",void 0);E([A({type:Object}),w("design:type",Object)],En.prototype,"_nameToDataSeries",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],En.prototype,"_expanded",void 0);E([A({type:Boolean}),w("design:type",Boolean)],En.prototype,"_logScaleActive",void 0);E([A({type:Object}),w("design:type",Function)],En.prototype,"_requestData",void 0);E([A({type:Object}),w("design:type",Object)],En.prototype,"_runToNextAvailableSymbolIndex",void 0);E([A({type:Boolean}),w("design:type",Boolean)],En.prototype,"_matchesListOpened",void 0);E([Bt("_nameToDataSeries"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],En.prototype,"_updateChart",null);E([Rt("_nameToDataSeries","runs"),w("design:type",Object),w("design:paramtypes",[])],En.prototype,"_seriesNames",null);E([Bt("_tagFilter"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],En.prototype,"_refreshDataSeries",null);E([Rt("tagRegexes"),w("design:type",String),w("design:paramtypes",[])],En.prototype,"_tagFilter",null);E([Rt("title"),w("design:type",String),w("design:paramtypes",[])],En.prototype,"_titleDisplayString",null);En=E([yt("tf-custom-scalar-multi-line-chart-card")],En);var jo=class extends mt{constructor(){super(...arguments),this._requestManager=new Ae(50),this._canceller=new an,this._showDownloadLinks=vp("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}).call(this),this._smoothingWeight=gE("_smoothingWeight",{defaultValue:.6}).call(this),this._ignoreYOutliers=vp("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0}).call(this),this._xType="step",this._active=!0,this.reloadOnReady=!0,this._showDownloadLinksObserver=xp("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}),this._smoothingWeightObserver=_E("_smoothingWeight",{defaultValue:.6}),this._ignoreYOutliersObserver=xp("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0})}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){let t=ve().pluginsListing(),r=this._canceller.cancellable(n=>{n.cancelled||(this.set("_dataNotFound",!n.value.custom_scalars),!this._dataNotFound&&this._retrieveLayoutAndData())});this._requestManager.request(t).then(r)}_reloadCharts(){var r;let t=(r=this.root)==null?void 0:r.querySelectorAll("tf-custom-scalar-margin-chart-card, tf-custom-scalar-multi-line-chart-card");t==null||t.forEach(n=>{n.reload()})}_retrieveLayoutAndData(){let t=ve().pluginRoute("custom_scalars","/layout"),r=this._canceller.cancellable(n=>{n.cancelled||(this.set("_layout",n.value),this._dataNotFound||this._reloadCharts())});this._requestManager.request(t).then(r)}get _smoothingEnabled(){var t=this._smoothingWeight;return t>0}get _categories(){var t=this._layout;if(!t.category)return[];let r=!1;return this._openedCategories||(r=!0,this._openedCategories={}),t.category.map(i=>(r&&!i.closed&&(this._openedCategories[i.title]=!0),{name:i.title,items:i.chart,metadata:{type:Na.PREFIX_GROUP,opened:!!this._openedCategories[i.title]}}))}_categoryOpenedToggled(t){let r=t.target;r.opened?this._openedCategories[r.category.name]=!0:delete this._openedCategories[r.category.name]}};jo.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <div class="line-item">
              <paper-checkbox checked="{{_showDownloadLinks}}"
                >Show data download links</paper-checkbox
              >
            </div>
            <div class="line-item">
              <paper-checkbox checked="{{_ignoreYOutliers}}"
                >Ignore outliers in chart scaling</paper-checkbox
              >
            </div>
            <div id="tooltip-sorting">
              <div id="tooltip-sorting-label">Tooltip sorting method:</div>
              <paper-dropdown-menu
                no-label-float=""
                selected-item-label="{{_tooltipSortingMethod}}"
              >
                <paper-listbox
                  class="dropdown-content"
                  selected="0"
                  slot="dropdown-content"
                >
                  <paper-item>default</paper-item>
                  <paper-item>descending</paper-item>
                  <paper-item>ascending</paper-item>
                  <paper-item>nearest</paper-item>
                </paper-listbox>
              </paper-dropdown-menu>
            </div>
          </div>
          <div class="sidebar-section">
            <tf-smoothing-input
              weight="{{_smoothingWeight}}"
              step="0.001"
              min="0"
              max="1"
            ></tf-smoothing-input>
          </div>
          <div class="sidebar-section">
            <tf-option-selector
              id="x-type-selector"
              name="Horizontal Axis"
              selected-id="{{_xType}}"
            >
              <paper-button id="step">step</paper-button
              ><!--
            --><paper-button id="relative">relative</paper-button
              ><!--
            --><paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center" id="categories-container">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>The custom scalars dashboard is inactive.</h3>
            <p>Probable causes:</p>
            <ol>
              <li>You haven't laid out the dashboard.</li>
              <li>You haven’t written any scalar data to your event files.</li>
            </ol>

            <p>
              To lay out the dashboard, pass a <code>Layout</code> protobuffer
              to the <code>set_layout</code> method. For example,
            </p>
            <pre>
from tensorboard import summary
from tensorboard.plugins.custom_scalar import layout_pb2
...
# This action does not have to be performed at every step, so the action is not
# taken care of by an op in the graph. We only need to specify the layout once
# (instead of per step).
layout_summary = summary_lib.custom_scalar_pb(layout_pb2.Layout(
  category=[
    layout_pb2.Category(
      title='losses',
      chart=[
          layout_pb2.Chart(
              title='losses',
              multiline=layout_pb2.MultilineChartContent(
                tag=[r'loss.*'],
              )),
          layout_pb2.Chart(
              title='baz',
              margin=layout_pb2.MarginChartContent(
                series=[
                  layout_pb2.MarginChartContent.Series(
                    value='loss/baz/scalar_summary',
                    lower='baz_lower/baz/scalar_summary',
                    upper='baz_upper/baz/scalar_summary'),
                ],
              )),
      ]),
    layout_pb2.Category(
      title='trig functions',
      chart=[
          layout_pb2.Chart(
              title='wave trig functions',
              multiline=layout_pb2.MultilineChartContent(
                tag=[r'trigFunctions/cosine', r'trigFunctions/sine'],
              )),
          # The range of tangent is different. Let's give it its own chart.
          layout_pb2.Chart(
              title='tan',
              multiline=layout_pb2.MultilineChartContent(
                tag=[r'trigFunctions/tangent'],
              )),
      ],
      # This category we care less about. Let's make it initially closed.
      closed=True),
  ]))
writer.add_summary(layout_summary)
</pre
            >
            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              as="chart"
              category="[[category]]"
              disable-pagination
              initial-opened="[[category.metadata.opened]]"
            >
              <template>
                <template is="dom-if" if="[[chart.multiline]]">
                  <tf-custom-scalar-multi-line-chart-card
                    active="[[active]]"
                    request-manager="[[_requestManager]]"
                    runs="[[_selectedRuns]]"
                    title="[[chart.title]]"
                    x-type="[[_xType]]"
                    smoothing-enabled="[[_smoothingEnabled]]"
                    smoothing-weight="[[_smoothingWeight]]"
                    tooltip-sorting-method="[[tooltipSortingMethod]]"
                    ignore-y-outliers="[[_ignoreYOutliers]]"
                    show-download-links="[[_showDownloadLinks]]"
                    tag-regexes="[[chart.multiline.tag]]"
                  ></tf-custom-scalar-multi-line-chart-card>
                </template>
                <template is="dom-if" if="[[chart.margin]]">
                  <tf-custom-scalar-margin-chart-card
                    active="[[active]]"
                    request-manager="[[_requestManager]]"
                    runs="[[_selectedRuns]]"
                    title="[[chart.title]]"
                    x-type="[[_xType]]"
                    tooltip-sorting-method="[[tooltipSortingMethod]]"
                    ignore-y-outliers="[[_ignoreYOutliers]]"
                    show-download-links="[[_showDownloadLinks]]"
                    margin-chart-series="[[chart.margin.series]]"
                  ></tf-custom-scalar-margin-chart-card>
                </template>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      #tooltip-sorting {
        align-items: center;
        display: flex;
        font-size: 14px;
        margin-top: 15px;
      }
      #tooltip-sorting paper-dropdown-menu {
        margin-left: 10px;
        --paper-input-container-focus-color: var(--tb-orange-strong);
        width: 105px;
      }
      .line-item {
        display: block;
        padding-top: 5px;
      }
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Ae)],jo.prototype,"_requestManager",void 0);E([A({type:Object}),w("design:type",an)],jo.prototype,"_canceller",void 0);E([A({type:Array}),w("design:type",Array)],jo.prototype,"_selectedRuns",void 0);E([A({type:Boolean,notify:!0,observer:"_showDownloadLinksObserver"}),w("design:type",Boolean)],jo.prototype,"_showDownloadLinks",void 0);E([A({type:Number,notify:!0,observer:"_smoothingWeightObserver"}),w("design:type",Number)],jo.prototype,"_smoothingWeight",void 0);E([A({type:Boolean,observer:"_ignoreYOutliersObserver"}),w("design:type",Boolean)],jo.prototype,"_ignoreYOutliers",void 0);E([A({type:String}),w("design:type",String)],jo.prototype,"_xType",void 0);E([A({type:Object}),w("design:type",Object)],jo.prototype,"_layout",void 0);E([A({type:Boolean}),w("design:type",Boolean)],jo.prototype,"_dataNotFound",void 0);E([A({type:Object}),w("design:type",Object)],jo.prototype,"_openedCategories",void 0);E([A({type:Boolean}),w("design:type",Boolean)],jo.prototype,"_active",void 0);E([A({type:Boolean}),w("design:type",Boolean)],jo.prototype,"reloadOnReady",void 0);E([Rt("_smoothingWeight"),w("design:type",Boolean),w("design:paramtypes",[])],jo.prototype,"_smoothingEnabled",null);E([Rt("_layout"),w("design:type",Array),w("design:paramtypes",[])],jo.prototype,"_categories",null);jo=E([yt("tf-custom-scalar-dashboard")],jo);var NB=Ee(Oe(),1);var sst=Ee(Oe(),1),ba=Ee(wl(),1);var RB=class{constructor(t,r){this.run2datasets={},this.colorScale=r,this.buildChart(t)}getDataset(t){return this.run2datasets[t]===void 0&&(this.run2datasets[t]=new ba.Dataset([],{run:t})),this.run2datasets[t]}buildChart(t){this.outer&&this.outer.destroy();let r=vB(t);this.xAccessor=r.accessor,this.xScale=r.scale,this.xAxis=r.axis,this.xAxis.margin(0),this.xAxis.tickLabelPadding(3),this.yScale=new ba.Scales.Linear,this.yAxis=new ba.Axes.Numeric(this.yScale,"left");let n=Wu(dB);this.yAxis.margin(0).tickLabelPadding(5).formatter(n),this.yAxis.usesTextWidthApproximation(!0);let i=this.buildPlot(this.xAccessor,this.xScale,this.yScale);this.gridlines=new ba.Components.Gridlines(this.xScale,this.yScale),this.center=new ba.Components.Group([this.gridlines,i]),this.outer=new ba.Components.Table([[this.yAxis,this.center],[null,this.xAxis]])}buildPlot(t,r,n){let i=[0,228,1587,3085,5e3,6915,8413,9772,1e4],o=sst.range(i.length-1).map(h=>(i[h+1]-i[h])/2500),a=i.map((h,f)=>p=>p[f][1]),s=4,l=a[s],c=sst.range(a.length-1).map(h=>{let f=new ba.Plots.Area;f.x(t,r);let p=h>s?a[h]:a[h+1],d=h>s?a[h+1]:a[h];return f.y(d,n),f.y0(p),f.attr("fill",(g,_,y)=>this.colorScale.scale(y.metadata().run)),f.attr("stroke",(g,_,y)=>this.colorScale.scale(y.metadata().run)),f.attr("stroke-weight",(g,_,y)=>"0.5px"),f.attr("stroke-opacity",()=>o[h]),f.attr("fill-opacity",()=>o[h]),f}),u=new ba.Plots.Line;return u.x(t,r),u.y(l,n),u.attr("stroke",(h,f,p)=>this.colorScale.scale(p.run)),this.plots=c,new ba.Components.Group(c)}setVisibleSeries(t){this.runs=t;let r=t.map(n=>this.getDataset(n));this.plots.forEach(n=>n.datasets(r))}setSeriesData(t,r){this.getDataset(t).data(r)}renderTo(t){this.targetSVG=t,this.outer.renderTo(t)}redraw(){this.outer.redraw()}destroy(){this.outer.destroy()}},Bc=class extends Gt(mt){constructor(){super(...arguments),this.colorScale=new ba.Scales.Color().range(jb.slice()),this.xType="step",this._visibleSeriesCache=[],this._seriesDataCache={},this._makeChartAsyncCallbackId=null}setVisibleSeries(t){this._visibleSeriesCache=t,this._chart&&(this._chart.setVisibleSeries(t),this.redraw())}setSeriesData(t,r){this._seriesDataCache[t]=r,this._chart&&this._chart.setSeriesData(t,r)}redraw(){this._chart.redraw()}_makeChart(){var t=this.xType,r=this.colorScale,n=this._attached;this._makeChartAsyncCallbackId!==null&&this.cancelAsync(this._makeChartAsyncCallbackId),this._makeChartAsyncCallbackId=this.async(function(){if(this._makeChartAsyncCallbackId=null,!!n){this._chart&&this._chart.destroy();var i=new RB(t,r),o=Ht(this.$.chartdiv);i.renderTo(o),this._chart=i}},350)}_reloadFromCache(){this._chart&&(this._chart.setVisibleSeries(this._visibleSeriesCache),this._visibleSeriesCache.forEach(function(t){this._chart.setSeriesData(t,this._seriesDataCache[t]||[])}.bind(this)))}attached(){this._attached=!0}detached(){this._attached=!1}};Bc.template=Q`
    <style include="plottable-style"></style>
    <div id="chartdiv"></div>
    <style>
      :host {
        -webkit-user-select: none;
        -moz-user-select: none;
        display: flex;
        flex-direction: column;
        flex-grow: 1;
        flex-shrink: 1;
        position: relative;
      }
      #chartdiv {
        -webkit-user-select: none;
        -moz-user-select: none;
        flex-grow: 1;
        flex-shrink: 1;
      }
      .plottable .axis text {
        fill: currentColor;
      }
    </style>
  `;E([A({type:Object}),w("design:type",ba.Scales.Color)],Bc.prototype,"colorScale",void 0);E([A({type:String}),w("design:type",String)],Bc.prototype,"xType",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Bc.prototype,"_attached",void 0);E([A({type:Object}),w("design:type",RB)],Bc.prototype,"_chart",void 0);E([A({type:Array}),w("design:type",Array)],Bc.prototype,"_visibleSeriesCache",void 0);E([A({type:Object}),w("design:type",Object)],Bc.prototype,"_seriesDataCache",void 0);E([A({type:Number}),w("design:type",Object)],Bc.prototype,"_makeChartAsyncCallbackId",void 0);E([Bt("xType","colorScale","_attached"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Bc.prototype,"_makeChart",null);E([Bt("_chart"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Bc.prototype,"_reloadFromCache",null);Bc=E([yt("vz-distribution-chart")],Bc);var wa=class extends kS(Gt(mt)){constructor(){super(...arguments),this.getDataLoadName=({run:t})=>t,this.requestData=(t,r,n)=>{let o=ve().pluginRoute("distributions","/distributions");Promise.all(t.map(a=>{let s=Cn(o,{tag:a.tag,run:a.run});return this.requestManager.request(s).then(l=>void r({item:a,data:l}))})).finally(()=>void n())},this.loadDataCallback=(t,r,n)=>{let i=n.map(a=>{let[s,l,c]=a;return c.wall_time=new Date(s*1e3),c.step=l,c}),o=this.getDataLoadName(r);this.$.chart.setSeriesData(o,i),this.$.chart.setVisibleSeries([o])},this._colorScale={scale:fn},this._expanded=!1,this._canceller=new an}_reloadOnRunTagChange(){this.reload()}_updateDataToLoad(){var t=this.run,r=this.tag;this.dataToLoad=[{run:t,tag:r}]}get _runColor(){var t=this.run;return this._colorScale.scale(t)}redraw(){this.$.chart.redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}};wa.template=Q`
    <tf-card-heading
      tag="[[tag]]"
      run="[[run]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
      color="[[_runColor]]"
    ></tf-card-heading>
    <!--
      The main distribution that we render. Data is set directly with
      \`setSeriesData\`, not with a bound property.
    -->
    <vz-distribution-chart
      id="chart"
      x-type="[[xType]]"
      color-scale="[[_colorScale]]"
    ></vz-distribution-chart>
    <div style="display: flex; flex-direction: row;">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
    </div>
    <style>
      :host {
        display: flex;
        flex-direction: column;
        width: 330px;
        height: 235px;
        margin-right: 10px;
        margin-bottom: 15px;
      }
      :host([_expanded]) {
        width: 700px;
        height: 500px;
      }

      vz-histogram-timeseries {
        -moz-user-select: none;
        -webkit-user-select: none;
      }

      paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }
      paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }

      tf-card-heading {
        margin-bottom: 10px;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],wa.prototype,"run",void 0);E([A({type:String}),w("design:type",String)],wa.prototype,"tag",void 0);E([A({type:Object}),w("design:type",Object)],wa.prototype,"tagMetadata",void 0);E([A({type:String}),w("design:type",String)],wa.prototype,"xType",void 0);E([A({type:Object}),w("design:type",Object)],wa.prototype,"getDataLoadName",void 0);E([A({type:Object}),w("design:type",Object)],wa.prototype,"loadDataCallback",void 0);E([A({type:Object}),w("design:type",Object)],wa.prototype,"_colorScale",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],wa.prototype,"_expanded",void 0);E([A({type:Object}),w("design:type",Ae)],wa.prototype,"requestManager",void 0);E([A({type:Object}),w("design:type",an)],wa.prototype,"_canceller",void 0);E([Bt("run","tag"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],wa.prototype,"_reloadOnRunTagChange",null);E([Bt("run","tag"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],wa.prototype,"_updateDataToLoad",null);E([Rt("run"),w("design:type",String),w("design:paramtypes",[])],wa.prototype,"_runColor",null);wa=E([yt("tf-distribution-loader")],wa);var Sl=class extends Gt(mt){constructor(){super(...arguments),this.reloadOnReady=!0,this._xType="step",this._requestManager=new Ae}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then(()=>{this._reloadDistributions()})}_fetchTags(){let t=ve().pluginRoute("distributions","/tags");return this._requestManager.request(t).then(r=>{if(NB.isEqual(r,this._runToTagInfo))return;let n=NB.mapValues(r,o=>Object.keys(o)),i=$i(n);this.set("_dataNotFound",i.length===0),this.set("_runToTag",n),this.set("_runToTagInfo",r),this.async(()=>{this.set("_categoriesDomReady",!0)})})}_reloadDistributions(){var t;(t=this.root)==null||t.querySelectorAll("tf-distribution-loader").forEach(r=>{r.reload()})}_shouldOpen(t){return t<=2}get _categories(){var t=this._runToTag,r=this._selectedRuns,n=this._tagFilter,i=this._categoriesDomReady;return Ql(t,r,n)}_tagMetadata(t,r,n){return t[r][n]}};Sl.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <tf-option-selector
              id="xTypeSelector"
              name="Horizontal axis"
              selected-id="{{_xType}}"
            >
              <paper-button id="step">step</paper-button>
              <paper-button id="relative">relative</paper-button>
              <paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>

      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No distribution data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>
                You haven’t written any histogram data to your event files.
                (Histograms and distributions both use the histogram summary
                operation.)
              </li>

              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-distribution-loader
                  active="[[active]]"
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.run, item.tag)]]"
                  x-type="[[_xType]]"
                  request-manager="[[_requestManager]]"
                ></tf-distribution-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],Sl.prototype,"reloadOnReady",void 0);E([A({type:String}),w("design:type",String)],Sl.prototype,"_xType",void 0);E([A({type:Array}),w("design:type",Array)],Sl.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],Sl.prototype,"_runToTag",void 0);E([A({type:Object}),w("design:type",Object)],Sl.prototype,"_runToTagInfo",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Sl.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],Sl.prototype,"_tagFilter",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Sl.prototype,"_categoriesDomReady",void 0);E([A({type:Object}),w("design:type",Ae)],Sl.prototype,"_requestManager",void 0);E([Rt("_runToTag","_selectedRuns","_tagFilter","_categoriesDomReady"),w("design:type",Array),w("design:paramtypes",[])],Sl.prototype,"_categories",null);Sl=E([yt("tf-distribution-dashboard")],Sl);var DB={};Ks(DB,{DISAMBIGUATOR:()=>F0t,ListenKey:()=>dE,addHashListener:()=>mE,addStorageListener:()=>CW,disposeBooleanBinding:()=>$be,disposeNumberBinding:()=>Kbe,disposeObjectBinding:()=>Qbe,disposeStringBinding:()=>Ybe,fireStorageChanged:()=>AW,getBoolean:()=>jbe,getBooleanInitializer:()=>vp,getBooleanObserver:()=>xp,getNumber:()=>DW,getNumberInitializer:()=>gE,getNumberObserver:()=>_E,getObject:()=>Zbe,getObjectInitializer:()=>zW,getObjectObserver:()=>FW,getString:()=>Gbe,getStringInitializer:()=>y_,getStringObserver:()=>v_,getUrlHashDict:()=>N0t,makeBindings:()=>yE,migrateLegacyURLScheme:()=>t2e,removeHashListenerByKey:()=>PW,removeStorageListenerByKey:()=>IW,setBoolean:()=>Xbe,setNumber:()=>OW,setObject:()=>Jbe,setString:()=>Wbe});var oct=Ee(Oe(),1);var WKt="Graph dashboard actions",YKt="Graph dashboard timings",lst;(function(e){e.FETCH_PBTXT_BYTES="FETCH_PBTXT_BYTES",e.FETCH_PBTXT_BYTES_FROM_FILESYSTEM="FETCH_PBTXT_BYTES_FROM_FILESYSTEM",e.FETCH_PBTXT_BYTES_FROM_SERVER="FETCH_PBTXT_BYTES_FROM_SERVER",e.PARSE_PBTXT_INTO_OBJECT="PARSE_PBTXT_INTO_OBJECT",e.FETCH_METADATA_PBTXT_BYTES="FETCH_METADATA_PBTXT_BYTES",e.PARSE_METADATA_PBTXT_INTO_OBJECT="PARSE_METADATA_PBTXT_INTO_OBJECT",e.NORMALIZING_NAMES="NORMALIZING_NAMES",e.BUILD_SLIM_GRAPH="BUILD_SLIM_GRAPH",e.HIERARCHY_ADD_NODES="HIERARCHY_ADD_NODES",e.HIERARCHY_DETECT_SERIES="HIERARCHY_DETECT_SERIES",e.HIERARCHY_ADD_EDGES="HIERARCHY_ADD_EDGES",e.HIERARCHY_FIND_SIMILAR_SUBGRAPHS="HIERARCHY_FIND_SIMILAR_SUBGRAPHS",e.RENDER_BUILD_HIERARCHY="RENDER_BUILD_HIERARCHY",e.RENDER_SCENE_LAYOUT="RENDER_SCENE_LAYOUT",e.RENDER_SCENE_BUILD_SCENE="RENDER_SCENE_BUILD_SCENE",e.GRAPH_LOAD_SUCCEEDED="GRAPH_LOAD_SUCCEEDED",e.GRAPH_LOAD_FAILED="GRAPH_LOAD_FAILED"})(lst||(lst={}));var cst;(function(e){e.NODE_EXPANSION_TOGGLED="NODE_EXPANSION_TOGGLED",e.NODE_SEARCH_RESULT_FOCUSED="NODE_SEARCH_RESULT_FOCUSED",e.NODE_AUXILIARY_EXTRACTION_CHANGED="NODE_AUXILIARY_EXTRACTION_CHANGED",e.GRAPH_TYPE_CHANGED="GRAPH_TYPE_CHANGED",e.TRACE_INPUT_MODE_TOGGLED="TRACE_INPUT_MODE_TOGGLED",e.NODE_COLOR_MODE_CHANGED="NODE_COLOR_MODE_CHANGED",e.UPLOADED_GRAPH_FROM_FILESYSTEM="UPLOADED_GRAPH_FROM_FILESYSTEM"})(cst||(cst={}));var jr=Kl(Kl({},lst),cst);var Jse=Ee(zlt(),1),pn=Ee(Oe(),1);var Fs;(function(e){e.OP_GRAPH="op_graph",e.CONCEPTUAL_GRAPH="conceptual_graph",e.PROFILE="profile"})(Fs||(Fs={}));var ye={Node:{CONTAINER:"nodes",GROUP:"node",SHAPE:"nodeshape",COLOR_TARGET:"nodecolortarget",LABEL:"nodelabel",BUTTON_CONTAINER:"buttoncontainer",BUTTON_CIRCLE:"buttoncircle",EXPAND_BUTTON:"expandbutton",COLLAPSE_BUTTON:"collapsebutton"},Edge:{CONTAINER:"edges",GROUP:"edge",LINE:"edgeline",REFERENCE_EDGE:"referenceedge",REF_LINE:"refline",SELECTABLE:"selectableedge",SELECTED:"selectededge",STRUCTURAL:"structural"},Annotation:{OUTBOX:"out-annotations",INBOX:"in-annotations",GROUP:"annotation",NODE:"annotation-node",EDGE:"annotation-edge",CONTROL_EDGE:"annotation-control-edge",LABEL:"annotation-label",ELLIPSIS:"annotation-ellipsis"},Scene:{GROUP:"scene",CORE:"core",FUNCTION_LIBRARY:"function-library",INEXTRACT:"in-extract",OUTEXTRACT:"out-extract"},Subscene:{GROUP:"subscene"},OPNODE:"op",METANODE:"meta",SERIESNODE:"series",BRIDGENODE:"bridge",ELLIPSISNODE:"ellipsis"},Z4={Edge:{LABEL:3.5},Annotation:{LABEL:5},Node:{EXPANDED_LABEL:9,SERIES_LABEL:8,OP_LABEL:6,HEALTH_PILL_STAT_LABEL:4}},ju="http://www.w3.org/2000/svg";function m0(e,t,r){let n=e.node().childNodes;for(let i=0;i<n.length;i++){let o=n[i];if(o.tagName===t){if(r instanceof Array){let a=!0;for(let s=0;s<r.length;s++)a=a&&o.classList.contains(r[s]);if(a)return Ht(o)}else if(!r||o.classList.contains(r))return Ht(o)}}return Ht(null)}function Pn(e,t,r,n){let i=m0(e,t,r);if(!i.empty())return i;let o=document.createElementNS("http://www.w3.org/2000/svg",t);if(r instanceof Array)for(let a=0;a<r.length;a++)o.classList.add(r[a]);else o.classList.add(r);return n?e.node().insertBefore(o,n):e.node().appendChild(o),Ht(o).datum(e.datum())}var KS=class{constructor(t){this.totalBytes=0,this.outputSize=t}addExecutionTime(t,r){this.startTime!=null?this.startTime=Math.min(this.startTime,t):this.startTime=t,this.endTime!=null?this.endTime=Math.max(this.endTime,r):this.endTime=r}addBytesAllocation(t){this.totalBytes!=null?this.totalBytes=Math.max(this.totalBytes,t):this.totalBytes=t}combine(t){t.totalBytes!=null&&(this.totalBytes+=t.totalBytes),t.getTotalMicros()!=null&&this.addExecutionTime(t.startTime,t.endTime)}getTotalMicros(){return this.startTime==null||this.endTime==null?null:this.endTime-this.startTime}},J4=.75,Q4=12,$lr=.3,Klr=[1,5e6],qse=K_().exponent($lr).domain(Klr).range([J4,Q4]).clamp(!0);var ZS=Ee(Oe(),1);var Wse=20;function Zlr(e){return e.hasOwnProperty("timingId")}function Po(e){Zlr(e)?(YKt,e.timingId,e.eventValue,void 0):(WKt,e.actionId,e.eventLabel,void 0)}function Rd(e,t,r){let n=Date.now(),i=t(),o=Date.now()-n;return console.log(e,":",o,"ms"),r&&Po({timingId:r,eventValue:o}),i}function rP(e){return{setMessage:function(t){e.set("progress",{value:e.progress.value,msg:t})},updateProgress:function(t){e.set("progress",{value:e.progress.value+t,msg:e.progress.msg})},reportError:function(t,r){console.error(r.stack),e.set("progress",{value:e.progress.value,msg:t,error:!0})}}}function JS(e,t,r){return{setMessage:function(n){e.setMessage(r+": "+n)},updateProgress:function(n){e.updateProgress(n*t/100)},reportError:function(n,i){e.reportError(r+": "+n,i)}}}function Yse(e,t,r,n,i){n.setMessage(e);try{let o=Rd(e,r,i);return n.updateProgress(t),o}catch(o){return n.reportError("Failed "+e,o),null}}function ev(e,t,r,n,i){return new Promise((o,a)=>{n.setMessage(e),setTimeout(function(){try{let s=Rd(e,r,i);n.updateProgress(t),o(s)}catch(s){n.reportError("Failed "+e,s)}},Wse)})}function dH(e,t,r,n,i){return new Promise((o,a)=>{let s=function(l){n.reportError("Failed "+e,l),a(l)};n.setMessage(e),setTimeout(function(){try{let l=Date.now();r().then(function(c){let u=Date.now()-l;console.log(e,":",u,"ms"),n.updateProgress(t),Po({timingId:i,eventValue:u}),o(c)}).catch(s)}catch(l){s(l)}},Wse)})}function jse(e){return e.replace(/([:.\[\],/\\\(\)])/g,"\\$1")}var nP=[{symbol:"B"},{symbol:"KB",numUnits:1024},{symbol:"MB",numUnits:1024},{symbol:"GB",numUnits:1024},{symbol:"TB",numUnits:1024},{symbol:"PB",numUnits:1024}],iP=[{symbol:"\xB5s"},{symbol:"ms",numUnits:1e3},{symbol:"s",numUnits:1e3},{symbol:"min",numUnits:60},{symbol:"hr",numUnits:60},{symbol:"days",numUnits:24}];function Nd(e,t,r=0){return r+1<t.length&&e>=t[r+1].numUnits?Nd(e/t[r+1].numUnits,t,r+1):Number(e.toPrecision(3))+" "+t[r].symbol}function mH(e){return!!(e&&(e.totalBytes>0||e.getTotalMicros()>0||e.outputSize))}function Flt(e){if(e.length<2)return e;let t=0,r=0,n=ZS.min(ZS.map(e,i=>i.length));for(;;){t++;let i=ZS.map(e,a=>a.substring(0,t));if(i.every((a,s)=>s===0?!0:a===i[s-1])){if(t>=n)return e;r=t}else break}return ZS.map(e,i=>i.substring(r))}function Xse(e){var t=+new Date-+new Date(e/1e3);return t<3e4?"just now":t<6e4?Math.floor(t/1e3)+" seconds ago":t<12e4?"a minute ago":t<36e5?Math.floor(t/6e4)+" minutes ago":Math.floor(t/36e5)==1?"an hour ago":t<864e5?Math.floor(t/36e5)+" hours ago":t<1728e5?"yesterday":Math.floor(t/864e5)+" days ago"}var Jlr=document.createElement("canvas"),eP=Jlr.getContext("2d");function Gse(e,t){return eP&&(eP.font=`${t}px Roboto, sans-serif`),eP==null?void 0:eP.measureText(e).width}function $se(e,t,r){if(!e)return"";if(Gse(e,t)<=r)return e;let n=0,i=e.length;for(;n<i;){let o=n+Math.round((i-n)/2),a=e.slice(0,o)+"\u2026";Gse(a,t)<=r?n=o:i=o-1}return n===0?e[0]:e.slice(0,n)+"\u2026"}var pH=class{constructor(){this.eventTypeToListeners=new Map}getListeners(t){return this.eventTypeToListeners.has(t)||this.eventTypeToListeners.set(t,[]),this.eventTypeToListeners.get(t)}addListener(t,r){var n;(n=this.getListeners(t))==null||n.push(r)}removeListener(t,r){var i;let n=(i=this.getListeners(t))==null?void 0:i.filter(o=>o!==r);this.eventTypeToListeners.set(t,n)}dispatchEvent(t,r){for(let n of this.getListeners(t))n(r)}};var Al="/",qc="__root__",Sa="__function_library__",Qse="_too_large_attrs";var tle="--",g0;(function(e){e[e.FULL=0]="FULL",e[e.EMBEDDED=1]="EMBEDDED",e[e.META=2]="META",e[e.SERIES=3]="SERIES",e[e.CORE=4]="CORE",e[e.SHADOW=5]="SHADOW",e[e.BRIDGE=6]="BRIDGE",e[e.EDGE=7]="EDGE"})(g0||(g0={}));var jt;(function(e){e[e.META=0]="META",e[e.OP=1]="OP",e[e.SERIES=2]="SERIES",e[e.BRIDGE=3]="BRIDGE",e[e.ELLIPSIS=4]="ELLIPSIS"})(jt||(jt={}));var ur;(function(e){e[e.INCLUDE=0]="INCLUDE",e[e.EXCLUDE=1]="EXCLUDE",e[e.UNSPECIFIED=2]="UNSPECIFIED"})(ur||(ur={}));var is;(function(e){e[e.GROUP=0]="GROUP",e[e.UNGROUP=1]="UNGROUP"})(is||(is={}));var Qlr="_output_shapes",tcr="_XlaCluster",Xu=class{constructor(){this.nodes={},this.edges=[]}},gH=class{constructor(t){this.type=jt.ELLIPSIS,this.isGroupNode=!1,this.cardinality=1,this.parentNode=null,this.stats=null,this.setNumMoreNodes(t),this.include=ur.UNSPECIFIED}setNumMoreNodes(t){this.numMoreNodes=t,this.name="... "+t+" more"}},_0=class{constructor(t){this.op=t.op,this.name=t.name,this.device=t.device,this.attr=t.attr,this.inputs=icr(t.input),this.outputShapes=ecr(t.attr),this.xlaCluster=rcr(t.attr),this.compatible=!1,this.type=jt.OP,this.isGroupNode=!1,this.cardinality=1,this.inEmbeddings=[],this.outEmbeddings=[],this.parentNode=null,this.include=ur.UNSPECIFIED,this.owningSeries=null}};function sP(e,t={}){return new oP(e,t)}function ele(e,t,r){pn.each(e.nodes,n=>{n.stats=null}),pn.each(t.dev_stats,n=>{r&&!r[n.device]||pn.each(n.node_stats,i=>{let o=i.node_name in e.nodes?i.node_name:aP(i.node_name);if(!(o in e.nodes))return;let a=0;i.memory&&pn.each(i.memory,l=>{l.total_bytes&&(l.total_bytes>0?a+=Number(l.total_bytes):console.log("ignoring negative memory allocation for "+o))});let s=null;i.output&&(s=pn.map(i.output,l=>pn.map(l.tensor_description.shape.dim,c=>Number(c.size)))),e.nodes[o].device=n.device,e.nodes[o].stats==null&&(e.nodes[o].stats=new KS(s)),e.nodes[o].stats.addBytesAllocation(a),i.all_end_rel_micros&&(i.all_end_rel_micros>0?e.nodes[o].stats.addExecutionTime(i.all_start_micros,i.all_start_micros+i.all_end_rel_micros):console.log("ignoring negative runtime for "+o))})})}var oP=class{constructor(t,r={}){this.name=t,this.type=jt.META,this.depth=1,this.isGroupNode=!0,this.cardinality=0,this.metagraph=e3(t,g0.META,r),this.bridgegraph=null,this.opHistogram={},this.deviceHistogram={},this.xlaClusterHistogram={},this.compatibilityHistogram={compatible:0,incompatible:0},this.templateId=null,this.parentNode=null,this.hasNonControlEdges=!1,this.include=ur.UNSPECIFIED,this.associatedFunction=""}getFirstChild(){return this.metagraph.node(this.metagraph.nodes()[0])}getRootOp(){let t=this.name.split("/"),r=this.name+"/("+t[t.length-1]+")";return this.metagraph.node(r)}leaves(){let t=[],r=[this],n;for(;r.length;){let i=r.shift();i!=null&&i.isGroupNode?(n=i.metagraph,pn.each(n.nodes(),o=>r.push(n.node(o)))):t.push(i==null?void 0:i.name)}return t}};function Vlt(e,t){return new qf(e,t)}var qf=class{constructor(t,r){this.v=t,this.w=r,this.baseEdgeList=[],this.inbound=null,this.numRegularEdges=0,this.numControlEdges=0,this.numRefEdges=0,this.totalSize=0}addBaseEdge(t,r){this.baseEdgeList.push(t),t.isControlDependency?this.numControlEdges+=1:this.numRegularEdges+=1,t.isReferenceEdge&&(this.numRefEdges+=1),this.totalSize+=qf.computeSizeOfEdge(t,r),r.maxMetaEdgeSize=Math.max(r.maxMetaEdgeSize,this.totalSize)}static computeSizeOfEdge(t,r){let n=r.node(t.v);if(!n.outputShapes)return 1;r.hasShapeInfo=!0;let i=Object.keys(n.outputShapes).map(o=>n.outputShapes[o]).map(o=>o==null?1:o.reduce((a,s)=>(s===-1&&(s=1),a*s),1));return pn.sum(i)}};function QS(e,t,r,n,i,o){return new Hlt(e,t,r,n,i,o)}function t3(e,t,r,n,i){let o=typeof n!="undefined"&&typeof i!="undefined"?"["+n+"-"+i+"]":"#",a=e+o+t;return(r?r+"/":"")+a}var Hlt=class{constructor(t,r,n,i,o,a){this.name=o||t3(t,r,n),this.type=jt.SERIES,this.hasLoop=!1,this.prefix=t,this.suffix=r,this.clusterId=i,this.ids=[],this.parent=n,this.isGroupNode=!0,this.cardinality=0,this.metagraph=e3(o,g0.SERIES,a),this.bridgegraph=null,this.parentNode=null,this.deviceHistogram={},this.xlaClusterHistogram={},this.compatibilityHistogram={compatible:0,incompatible:0},this.hasNonControlEdges=!1,this.include=ur.UNSPECIFIED}};function ecr(e){let t=null;if(!e)return null;for(let r=0;r<e.length;r++){let{key:n,value:i}=e[r];if(n===Qlr){if(!i.list||!i.list.shape)return null;let o=i.list.shape.map(a=>a.unknown_rank?null:a.dim==null||a.dim.length===1&&a.dim[0].size==null?[]:a.dim.map(s=>s.size));return e.splice(r,1),o}}return null}function rcr(e){if(!e)return null;for(let t=0;t<e.length;t++)if(e[t].key===tcr)return e[t].value.s||null;return null}var ncr=/^([^:]+):((\w+:|)\d+)$/;function icr(e){let t=[],r=null;for(let n of e||[]){let i=n.startsWith("^");i&&(n=n.substring(1));let o=n,a="0",s=n.includes(":")&&n.match(ncr);s&&(o=s[1],a=s[2]),r!==o&&(r=o,t.push({name:o,outputTensorKey:a,isControlDependency:i}))}return t}function Blt(e,t,r,n,i,o){if(t===r.name)return;let a=i.refEdges[r.op+" "+o]===!0;e.edges.push({v:t,w:r.name,outputTensorKey:n.outputTensorKey,isControlDependency:n.isControlDependency,isReferenceEdge:a})}var rle={enableEmbedding:!0,inEmbeddingTypes:["Const"],outEmbeddingTypes:["^[a-zA-Z]+Summary$"],refEdges:{"Assign 0":!0,"AssignAdd 0":!0,"AssignSub 0":!0,"assign 0":!0,"assign_add 0":!0,"assign_sub 0":!0,"count_up_to 0":!0,"ScatterAdd 0":!0,"ScatterSub 0":!0,"ScatterUpdate 0":!0,"scatter_add 0":!0,"scatter_sub 0":!0,"scatter_update 0":!0}};function nle(e,t,r){let n={},i={},o={},a=Kse(t.inEmbeddingTypes),s=Kse(t.outEmbeddingTypes),l=[],c=e.node,u=new Array(c.length);return ev("Normalizing names",30,()=>{let h=new Array(c.length),f=0,p=g=>{let _=new _0(g);return a(_)?(l.push(_.name),n[_.name]=_,_):s(_)?(l.push(_.name),i[_.name]=_,pn.each(_.inputs,y=>{let x=y.name;o[x]=o[x]||[],o[x].push(_)}),_):(h[f]=_,u[f]=_.name,f++,_)};pn.each(c,p);let d=g=>{let _=Sa+g.signature.name;if(p({name:_,input:[],device:"",op:"",attr:[]}),g.signature.input_arg){let b=0,S=C=>{let P=p({name:_+Al+C.name,input:[],device:"",op:"input_arg",attr:[{key:"T",value:{type:C.type}}]});P.functionInputIndex=b,b++};g.signature.input_arg.name?S(g.signature.input_arg):pn.each(g.signature.input_arg,S)}let y=0,x={};if(g.signature.output_arg){let b=S=>{x[_+Al+S.name]=y,y++};g.signature.output_arg.name?b(g.signature.output_arg):pn.each(g.signature.output_arg,b)}pn.each(g.node_def,b=>{b.name=_+"/"+b.name,typeof b.input=="string"&&(b.input=[b.input]);let S=p(b);pn.isNumber(x[b.name])&&(S.functionOutputIndex=x[b.name]),pn.each(S.inputs,C=>{C.name=_+Al+C.name})})};return e.library&&e.library.function&&pn.each(e.library.function,d),h.splice(f),u.splice(f),h},r,jr.NORMALIZING_NAMES).then(h=>ev("Building the data structure",70,()=>{let f=ocr(u,l),p=new Xu;return pn.each(h,d=>{let g=f[d.name]||d.name;p.nodes[g]=d,d.name in o&&(d.outEmbeddings=o[d.name],pn.each(d.outEmbeddings,_=>{_.name=f[_.name]||_.name})),d.name=g}),pn.each(h,d=>{pn.each(d.inputs,(g,_)=>{let y=g.name;if(y in n){let x=n[y];d.inEmbeddings.push(x);for(let b of x.inputs)Blt(p,f[b.name]||b.name,d,b,t,_)}else if(y in i){let x=i[y];for(let b of x.inputs)Blt(p,f[b.name]||b.name,d,g,t,_)}else Blt(p,f[y]||y,d,g,t,_)})}),pn.each(n,(d,g)=>{d.name=f[d.name]||d.name}),p},r,jr.BUILD_SLIM_GRAPH))}function e3(e,t,r={}){let n=new Jse.graphlib.Graph(r);return n.setGraph({name:e,rankdir:r.rankdir||"BT",type:t}),n}function Kse(e){return function(t){for(let r=0;r<e.length;r++){let n=new RegExp(e[r]);if(typeof t.op=="string"&&t.op.match(n))return!0}return!1}}function aP(e){let t=e.split(Al);return e+Al+"("+t[t.length-1]+")"}function ocr(e,t){let r={},n={};e.sort();for(let i=0;i<e.length-1;++i){let o=e[i];pn.each(lP(o).slice(0,-1),a=>{n[a]=!0});for(let a=i+1;a<e.length;++a){let s=e[a];if(pn.startsWith(s,o)){if(s.length>o.length&&s.charAt(o.length)===Al){r[o]=aP(o);break}}else break}}return pn.each(t,i=>{i in n&&(r[i]=aP(i))}),r}function Zse(e){let t=e.nodes().map(function(r){var n;return(n=e.neighbors(r))==null?void 0:n.length});return t.sort(),t}function ile(e,t){let r=Zse(e),n=Zse(t);for(let i=0;i<r.length;i++)if(r[i]!==n[i])return!1;return!0}function lP(e,t){let r=[],n=e.indexOf(Al);for(;n>=0;)r.push(e.substring(0,n)),n=e.indexOf(Al,n+1);if(t){let i=t[e];i&&r.push(i)}return r.push(e),r}function _H(e){return e===ur.EXCLUDE?"Add to main graph":"Remove from main graph"}function ole(e){return e===is.GROUP?"Ungroup this series of nodes":"Group this series of nodes"}var He=Ee(Oe(),1);var rv=Ee(Oe(),1);function ale(e,t){let r=scr(e),n=lcr(r,t);return Object.keys(n).sort(i=>n[i].level).reduce((i,o)=>(i[o]=n[o],i),{})}function acr(e){let t=rv.map({depth:e.depth,"|V|":e.metagraph.nodes().length,"|E|":e.metagraph.edges().length},function(n,i){return i+"="+n}).join(" "),r=rv.map(e.opHistogram,function(n,i){return i+"="+n}).join(",");return t+" [ops] "+r}function scr(e){let t=e.getNodeMap(),r=Object.keys(t).reduce((n,i)=>{let o=t[i];if(o.type!==jt.META)return n;let a=i.split("/").length-1,s=acr(o),l=n[s]||{nodes:[],level:a};return n[s]=l,l.nodes.push(o),l.level>a&&(l.level=a),n},{});return Object.keys(r).map(n=>[n,r[n]]).filter(([n,i])=>{let{nodes:o}=i;if(o.length>1)return!0;let a=o[0];return a.type===jt.META&&a.associatedFunction}).sort(([n,i])=>i.nodes[0].depth)}function lcr(e,t){return rv.reduce(e,function(n,i){let o=i[0],a=i[1].nodes,s=[];return a.forEach(function(l){for(let c=0;c<s.length;c++)if(!t||ccr(s[c].metanode.metagraph,l.metagraph)){l.templateId=s[c].metanode.templateId,s[c].members.push(l.name);return}l.templateId=o+"["+s.length+"]",s.push({metanode:l,members:[l.name]})}),s.forEach(function(l){n[l.metanode.templateId]={level:i[1].level,nodes:l.members}}),n},{})}function yH(e,t,r){return rv.sortBy(e,[n=>t.node(n).op,n=>t.node(n).templateId,n=>{var i;return(i=t.neighbors(n))==null?void 0:i.length},n=>{var i;return(i=t.predecessors(n))==null?void 0:i.length},n=>{var i;return(i=t.successors(n))==null?void 0:i.length},n=>n.substr(r.length)])}function ccr(e,t){if(!ile(e,t))return!1;let r=e.graph().name,n=t.graph().name,i={},o={},a=[];function s(u,h){let f=u.substr(r.length),p=h.substr(n.length);return i[f]^o[p]?(console.warn("different visit pattern","["+r+"]",f,"["+n+"]",p),!0):(i[f]||(i[f]=o[p]=!0,a.push({n1:u,n2:h})),!1)}let l=e.sources(),c=t.sources();if(l.length!==c.length)return console.log("different source length"),!1;l=yH(l,e,r),c=yH(c,t,n);for(let u=0;u<l.length;u++)if(s(l[u],c[u]))return!1;for(;a.length>0;){let u=a.pop();if(!ucr(e.node(u==null?void 0:u.n1),t.node(u==null?void 0:u.n2)))return!1;let f=e.successors(u==null?void 0:u.n1),p=t.successors(u==null?void 0:u.n2);if((f==null?void 0:f.length)!==(p==null?void 0:p.length))return console.log("# of successors mismatch",f,p),!1;f=yH(f,e,r),p=yH(p,t,n);for(let d=0;d<(f==null?void 0:f.length);d++)if(s(f==null?void 0:f[d],p==null?void 0:p[d]))return!1}return!0}function ucr(e,t){if(e.type===jt.META){let r=e,n=t;return!!r.templateId&&!!n.templateId&&r.templateId===n.templateId}else{if(e.type===jt.OP&&t.type===jt.OP)return e.op===t.op;if(e.type===jt.SERIES&&t.type===jt.SERIES){let r=e,n=t,i=r.metagraph.nodeCount();return i===n.metagraph.nodeCount()&&(i===0||r.metagraph.node(r.metagraph.nodes()[0]).op===n.metagraph.node(n.metagraph.nodes()[0]).op)}}return!1}var Dd;(function(e){e[e.TEMPLATES_UPDATED=0]="TEMPLATES_UPDATED"})(Dd||(Dd={}));var os=class extends pH{constructor(t){super(),this.hasShapeInfo=!1,this.maxMetaEdgeSize=1,this.graphOptions={},this.templates=null,this.graphOptions.compound=!0,this.graphOptions.rankdir=t.rankDirection,this.root=sP(qc,this.graphOptions),this.libraryFunctions={},this.seriesGroupMap=new Map(t.seriesMap),this.devices=null,this.xlaClusters=null,this.verifyTemplate=t.verifyTemplate,this.index={},this.index[qc]=this.root,this.orderings={}}getSeriesGroupType(t){var r;return(r=this.seriesGroupMap.get(t))!=null?r:is.GROUP}setSeriesGroupType(t,r){return this.seriesGroupMap.set(t,r)}buildSeriesGroupMapToggled(t){let r=this.getSeriesGroupType(t)===is.GROUP?is.UNGROUP:is.GROUP;return new Map([...this.seriesGroupMap,[t,r]])}getNodeMap(){return this.index}node(t){return this.index[t]}setNode(t,r){this.index[t]=r}getBridgegraph(t){let r=this.index[t];if(!r)throw Error("Could not find node in hierarchy: "+t);if(!("metagraph"in r))return null;let n=r;if(n.bridgegraph)return n.bridgegraph;let i=n.bridgegraph=e3("BRIDGEGRAPH",g0.BRIDGE,this.graphOptions);if(!r.parentNode||!("metagraph"in r.parentNode))return i;let o=r.parentNode,a=o.metagraph,s=this.getBridgegraph(o.name);return He.each([a,s],l=>{l.edges().filter(c=>c.v===t||c.w===t).forEach(c=>{let u=c.w===t,h=l.edge(c);He.each(h.baseEdgeList,f=>{let[p,d]=u?[f.w,c.v]:[f.v,c.w],g=this.getChildName(t,p),_={v:u?d:g,w:u?g:d},y=i.edge(_);y||(y=Vlt(_.v,_.w),y.inbound=u,i.setEdge(_.v,_.w,y)),y.addBaseEdge(f,this)})})}),i}getChildName(t,r){let n=this.index[r];for(;n;){if(n.parentNode&&n.parentNode.name===t)return n.name;n=n.parentNode}throw Error("Could not find immediate child for descendant: "+r)}getPredecessors(t){let r=this.index[t];if(!r)throw Error("Could not find node with name: "+t);let n=this.getOneWayEdges(r,!0);return r.isGroupNode||He.each(r.inEmbeddings,i=>{He.each(r.inputs,o=>{if(o.name===i.name){let a=new qf(i.name,t);a.addBaseEdge({isControlDependency:o.isControlDependency,outputTensorKey:o.outputTensorKey,isReferenceEdge:!1,v:i.name,w:t},this),n.regular.push(a)}})}),n}getSuccessors(t){let r=this.index[t];if(!r)throw Error("Could not find node with name: "+t);let n=this.getOneWayEdges(r,!1);return r.isGroupNode||He.each(r.outEmbeddings,i=>{He.each(i.inputs,o=>{if(o.name===t){let a=new qf(t,i.name);a.addBaseEdge({isControlDependency:o.isControlDependency,outputTensorKey:o.outputTensorKey,isReferenceEdge:!1,v:t,w:i.name},this),n.regular.push(a)}})}),n}getOneWayEdges(t,r){let n={control:[],regular:[]};if(!t.parentNode||!t.parentNode.isGroupNode)return n;let i=t.parentNode,o=i.metagraph,a=this.getBridgegraph(i.name);return sle(o,t,r,n),sle(a,t,r,n),n}getTopologicalOrdering(t){let r=this.index[t];if(!r)throw Error("Could not find node with name: "+t);if(!r.isGroupNode)return null;if(t in this.orderings)return this.orderings[t];let n={},i={},o=r.metagraph;He.each(o.edges(),c=>{!o.edge(c).numRegularEdges||(c.v in n||(n[c.v]=[]),n[c.v].push(c.w),i[c.w]=!0)});let a=He.difference(He.keys(n),He.keys(i)),s=this.orderings[t]={},l=0;for(;a.length;){let c=a.shift();s[c]=l++,He.each(n[c],u=>a.push(u)),delete n[c]}return s}getTemplateIndex(){if(!this.templates)return null;let t=XL(this.templates);if(!t.length)return null;let r=gu().domain(t).range(Ir(0,t.length));return n=>r(n)}updateTemplates(){Rd("Finding similar subgraphs",()=>{this.templates=ale(this,this.verifyTemplate),this.dispatchEvent(Dd.TEMPLATES_UPDATED)},jr.HIERARCHY_FIND_SIMILAR_SUBGRAPHS)}};function sle(e,t,r,n){let i=r?e.inEdges(t.name):e.outEdges(t.name);He.each(i,o=>{let a=e.edge(o);(a.numRegularEdges?n.regular:n.control).push(a)})}var r3={verifyTemplate:!0,seriesNodeMinSize:5,seriesMap:new Map,rankDirection:"BT",useGeneralizedSeriesPatterns:!1};function xH(e,t,r){let n=new os(t),i={};return ev("Adding nodes",30,()=>{let o={},a={};He.each(e.nodes,(s,l)=>{s.device&&(o[s.device]=!0),s.xlaCluster&&(a[s.xlaCluster]=!0)}),n.devices=He.keys(o),n.xlaClusters=He.keys(a),fcr(n,e)},r,jr.HIERARCHY_ADD_NODES).then(()=>ev("Detect series",30,()=>{t.seriesNodeMinSize>0&&ule(n.root,n,i,t.seriesNodeMinSize,t.seriesMap,t.useGeneralizedSeriesPatterns)},r,jr.HIERARCHY_DETECT_SERIES)).then(()=>ev("Adding edges",40,()=>{pcr(n,e,i)},r,jr.HIERARCHY_ADD_EDGES)).then(()=>n)}function lle(e,t){let r={},n={};He.each(e.root.leaves(),i=>{let o=e.node(i);o.device!=null&&(r[o.device]=!0),o.xlaCluster!=null&&(n[o.xlaCluster]=!0)}),e.devices=He.keys(r),e.xlaClusters=He.keys(n),He.each(e.getNodeMap(),(i,o)=>{i.isGroupNode&&(i.stats=new KS(null),i.deviceHistogram={})}),He.each(e.root.leaves(),i=>{let o=e.node(i),a=o;for(;a.parentNode!=null;){if(o.device!=null){let s=a.parentNode.deviceHistogram;s[o.device]=(s[o.device]||0)+1}if(o.xlaCluster!=null){let s=a.parentNode.xlaClusterHistogram;s[o.xlaCluster]=(s[o.xlaCluster]||0)+1}o.stats!=null&&a.parentNode.stats.combine(o.stats),a=a.parentNode}})}function cle(e){let t=[],r={};return He.each(e.root.leaves(),n=>{let i=e.node(n);if(i.type==jt.OP){let o=i;if(!o.compatible)if(o.owningSeries){if(e.getSeriesGroupType(o.owningSeries)===is.UNGROUP)t.push(o);else if(!r[o.owningSeries]){let a=e.node(o.owningSeries);a&&(r[o.owningSeries]=a,t.push(a))}}else t.push(o);He.each(o.inEmbeddings,a=>{a.compatible||t.push(a)}),He.each(o.outEmbeddings,a=>{a.compatible||t.push(a)})}}),t}function fcr(e,t){let r={};He.each(t.nodes,(n,i)=>{let o=lP(n.name),a=e.root;a.depth=Math.max(o.length,a.depth),r[n.op]||(r[n.op]=[]),r[n.op].push(n);for(let s=0;s<o.length&&(a.depth=Math.max(a.depth,o.length-s),a.cardinality+=n.cardinality,a.opHistogram[n.op]=(a.opHistogram[n.op]||0)+1,n.device!=null&&(a.deviceHistogram[n.device]=(a.deviceHistogram[n.device]||0)+1),n.xlaCluster!=null&&(a.xlaClusterHistogram[n.xlaCluster]=(a.xlaClusterHistogram[n.xlaCluster]||0)+1),n.compatible?a.compatibilityHistogram.compatible=(a.compatibilityHistogram.compatible||0)+1:a.compatibilityHistogram.incompatible=(a.compatibilityHistogram.incompatible||0)+1,He.each(n.inEmbeddings,u=>{u.compatible?a.compatibilityHistogram.compatible=(a.compatibilityHistogram.compatible||0)+1:a.compatibilityHistogram.incompatible=(a.compatibilityHistogram.incompatible||0)+1}),He.each(n.outEmbeddings,u=>{u.compatible?a.compatibilityHistogram.compatible=(a.compatibilityHistogram.compatible||0)+1:a.compatibilityHistogram.incompatible=(a.compatibilityHistogram.incompatible||0)+1}),s!==o.length-1);s++){let l=o[s],c=e.node(l);if(!c&&(c=sP(l,e.graphOptions),c.parentNode=a,e.setNode(l,c),a.metagraph.setNode(l,c),l.indexOf(Sa)===0&&a.name===qc)){let u=l.substring(Sa.length);r[u]||(r[u]=[]),e.libraryFunctions[u]={node:c,usages:r[u]},c.associatedFunction=u}a=c}e.setNode(n.name,n),n.parentNode=a,a.metagraph.setNode(n.name,n),He.each(n.inEmbeddings,function(s){e.setNode(s.name,s),s.parentNode=n}),He.each(n.outEmbeddings,function(s){e.setNode(s.name,s),s.parentNode=n})})}function pcr(e,t,r){let n=e.getNodeMap(),i=[],o=[],a=(s,l)=>{let c=0;for(;s;)l[c++]=s.name,s=s.parentNode;return c-1};He.each(t.edges,s=>{let l=a(t.nodes[s.v],i),c=a(t.nodes[s.w],o);if(l===-1||c===-1)return;for(;i[l]===o[c];)if(l--,c--,l<0||c<0)throw Error("No difference found between ancestor paths.");let u=n[i[l+1]],h=i[l],f=o[c],p=u.metagraph.edge(h,f);p||(p=Vlt(h,f),u.metagraph.setEdge(h,f,p)),!u.hasNonControlEdges&&!s.isControlDependency&&(u.hasNonControlEdges=!0),p.addBaseEdge(s,e)})}function ule(e,t,r,n,i,o){let a=e.metagraph;He.each(a.nodes(),u=>{let h=a.node(u);h.type===jt.META&&ule(h,t,r,n,i,o)});let s=dcr(a),c=(o?gcr:mcr)(s,a,t.graphOptions);He.each(c,function(u,h){let f=u.metagraph.nodes();He.each(f,p=>{let d=a.node(p);d.owningSeries||(d.owningSeries=h)}),f.length<n&&t.getSeriesGroupType(u.name)===is.GROUP&&t.setSeriesGroupType(u.name,is.UNGROUP),t.getSeriesGroupType(u.name)!==is.UNGROUP&&(t.setNode(h,u),a.setNode(h,u),He.each(f,p=>{let d=a.node(p);u.metagraph.setNode(p,d),u.parentNode=d.parentNode,u.cardinality++,d.device!=null&&(u.deviceHistogram[d.device]=(u.deviceHistogram[d.device]||0)+1),d.xlaCluster!=null&&(u.xlaClusterHistogram[d.xlaCluster]=(u.xlaClusterHistogram[d.xlaCluster]||0)+1),d.compatible?u.compatibilityHistogram.compatible=(u.compatibilityHistogram.compatible||0)+1:u.compatibilityHistogram.incompatible=(u.compatibilityHistogram.incompatible||0)+1,He.each(d.inEmbeddings,g=>{g.compatible?u.compatibilityHistogram.compatible=(u.compatibilityHistogram.compatible||0)+1:u.compatibilityHistogram.incompatible=(u.compatibilityHistogram.incompatible||0)+1}),He.each(d.outEmbeddings,g=>{g.compatible?u.compatibilityHistogram.compatible=(u.compatibilityHistogram.compatible||0)+1:u.compatibilityHistogram.incompatible=(u.compatibilityHistogram.incompatible||0)+1}),d.parentNode=u,r[p]=h,a.removeNode(p)}))})}function dcr(e){let t={};return He.reduce(e.nodes(),(r,n)=>{let i=e.node(n);if(i.type===jt.META)return r;let o=i.op;return o&&(r[o]=r[o]||[],r[o].push(i.name)),r},t)}function mcr(e,t,r){let n={};return He.each(e,function(i,o){if(i.length<=1)return;let a={};He.each(i,function(s){let l=s.charAt(s.length-1)==="*",c=s.split("/"),u=c[c.length-1],h=c.slice(0,c.length-1).join("/"),f=u.match(/^(\D*)(\d+)$/),p,d,g="";f?(p=f[1],d=f[2]):(p=l?u.substr(0,u.length-1):u,d=0,g=l?"*":"");let _=t3(p,g,h);a[_]=a[_]||[];let y=QS(p,g,h,+d,s,r);a[_].push(y)}),He.each(a,function(s,l){if(s.length<2)return;s.sort(function(u,h){return+u.clusterId-+h.clusterId});let c=[s[0]];for(let u=1;u<s.length;u++){let h=s[u];if(h.clusterId===c[c.length-1].clusterId+1){c.push(h);continue}vH(c,n,+o,t,r),c=[h]}vH(c,n,+o,t,r)})}),n}function gcr(e,t,r){let n={};return He.each(e,function(i,o){if(i.length<=1)return;let a={},s={};He.each(i,function(c){let u=c.charAt(c.length-1)==="*",h=c.split("/"),f=h[h.length-1],p=h.slice(0,h.length-1).join("/"),d=/(\d+)/g,g=[],_,y,x,b,S,C=0;for(;_=d.exec(f);)++C,y=f.slice(0,_.index),x=_[0],b=f.slice(_.index+_[0].length),S=t3(y,b,p),a[S]=a[S],a[S]||(a[S]=QS(y,b,p,+x,c,r)),a[S].ids.push(x),s[c]=s[c]||[],s[c].push([S,x]);C<1&&(y=u?f.substr(0,f.length-1):f,x=0,b=u?"*":"",S=t3(y,b,p),a[S]=a[S],a[S]||(a[S]=QS(y,b,p,+x,c,r)),a[S].ids.push(x),s[c]=s[c]||[],s[c].push([S,x]))});var l={};He.each(s,function(c,u){c.sort(function(y,x){return a[x[0]].ids.length-a[y[0]].ids.length});var h=c[0][0],f=c[0][1];l[h]=l[h]||[];let p=u.split("/"),d=p[p.length-1],g=p.slice(0,p.length-1).join("/");var _=QS(a[h].prefix,a[h].suffix,g,+f,u,r);l[h].push(_)}),He.each(l,function(c,u){if(c.length<2)return;c.sort(function(f,p){return+f.clusterId-+p.clusterId});let h=[c[0]];for(let f=1;f<c.length;f++){let p=c[f];if(p.clusterId===h[h.length-1].clusterId+1){h.push(p);continue}vH(h,n,+o,t,r),h=[p]}vH(h,n,+o,t,r)})}),n}function vH(e,t,r,n,i){if(e.length>1){let o=t3(e[0].prefix,e[0].suffix,e[0].parent,e[0].clusterId,e[e.length-1].clusterId),a=QS(e[0].prefix,e[0].suffix,e[0].parent,r,o,i);He.each(e,function(s){a.ids.push(s.clusterId),a.metagraph.setNode(s.name,n.node(s.name))}),t[o]=a}}var me=Ee(Oe(),1);var y0={DEFAULT_FILL:"#ffffff",DEFAULT_STROKE:"#b2b2b2",COMPATIBLE:"#0f9d58",INCOMPATIBLE:"#db4437"},Ku={DEFAULT_FILL:"#d9d9d9",DEFAULT_STROKE:"#a6a6a6",SATURATION:.6,LIGHTNESS:.85,EXPANDED_COLOR:"#f0f0f0",HUES:[220,100,180,40,20,340,260,300,140,60],STRUCTURE_PALETTE(e,t){let r=Ku.HUES,n=r.length,i=r[e%n],o=Math.sin(i*Math.PI/360),a=t?30:90-60*o,s=t?95:80;return Vm(i,.01*a,.01*s).toString()},DEVICE_PALETTE(e){return Ku.STRUCTURE_PALETTE(e)},XLA_CLUSTER_PALETTE(e){return Ku.STRUCTURE_PALETTE(e)},UNKNOWN:"#eee",GRADIENT_OUTLINE:"#888"},Ult={DEFAULT_FILL:"white",DEFAULT_STROKE:"#b2b2b2"},Xo={minNodeCountForExtraction:15,minDegreeForExtraction:5,maxControlDegree:4,maxBridgePathDegree:4,outExtractTypes:["NoOp"],inExtractTypes:[],detachAllEdgesForHighDegree:!0,extractIsolatedNodesWithAnnotationsOnOneSide:!0,enableBridgegraph:!0,minMaxColors:["#fff5f0","#fb6a4a"],maxAnnotations:5},_cr=new RegExp("^(?:"+Sa+")?(\\w+)_[a-z0-9]{8}(?:_\\d+)?$"),lo=class{constructor(t,r,n){this.hierarchy=t,this.displayingStats=r,this.autoExtractNodes=n,this.index={},this.renderedOpNames=[],this.computeScales(),this.hasSubhierarchy={},this.root=new wH(t.root,t.graphOptions),this.index[t.root.name]=this.root,this.renderedOpNames.push(t.root.name),this.buildSubhierarchy(t.root.name),this.root.expanded=!0,this.traceInputs=!1}computeScales(){this.deviceColorMap=gu().domain(this.hierarchy.devices).range(me.map(Ir(this.hierarchy.devices.length),Ku.DEVICE_PALETTE)),this.xlaClusterColorMap=gu().domain(this.hierarchy.xlaClusters).range(me.map(Ir(this.hierarchy.xlaClusters.length),Ku.XLA_CLUSTER_PALETTE));let t=this.hierarchy.root.metagraph,r=lu(t.nodes(),(i,o)=>{let a=t.node(i);if(a.stats!=null)return a.stats.totalBytes});this.memoryUsageScale=zn().domain([0,r]).range(Xo.minMaxColors);let n=lu(t.nodes(),(i,o)=>{let a=t.node(i);if(a.stats!=null)return a.stats.getTotalMicros()});this.computeTimeScale=zn().domain([0,n]).range(Xo.minMaxColors),this.edgeWidthSizedBasedScale=this.hierarchy.hasShapeInfo?qse:zn().domain([1,this.hierarchy.maxMetaEdgeSize]).range([J4,Q4])}getRenderNodeByName(t){return this.index[t]}getNodeByName(t){return this.hierarchy.node(t)}colorHistogram(t,r){if(Object.keys(t).length>0){let n=me.sum(Object.keys(t).map(i=>t[i]));return Object.keys(t).map(i=>({color:r(i),proportion:t[i]/n}))}return null}getOrCreateRenderNodeByName(t){if(!t)return null;if(t in this.index)return this.index[t];let r=this.hierarchy.node(t);if(!r)return null;let n=r.isGroupNode?new wH(r,this.hierarchy.graphOptions):new Gf(r);this.index[t]=n,this.renderedOpNames.push(t),r.stats&&(n.memoryColor=this.memoryUsageScale(r.stats.totalBytes),n.computeTimeColor=this.computeTimeScale(r.stats.getTotalMicros())),n.isFadedOut=this.displayingStats&&!mH(r.stats);var i=null,o=null,a=null;if(r.isGroupNode){i=r.deviceHistogram,o=r.xlaClusterHistogram;let s=r.compatibilityHistogram.compatible,l=r.compatibilityHistogram.incompatible;(s!=0||l!=0)&&(a=s/(s+l))}else{let s=n.node.device;s&&(i={[s]:1});let l=n.node.xlaCluster;l&&(o={[l]:1}),n.node.type===jt.OP&&(a=n.node.compatible?1:0)}return i&&(n.deviceColors=this.colorHistogram(i,this.deviceColorMap)),o&&(n.xlaClusterColors=this.colorHistogram(o,this.xlaClusterColorMap)),a!=null&&(n.compatibilityColors=[{color:y0.COMPATIBLE,proportion:a},{color:y0.INCOMPATIBLE,proportion:1-a}]),this.index[t]}getNearestVisibleAncestor(t){let r=lP(t),n=0,i=null,o=t;for(;n<r.length&&(o=r[n],i=this.getRenderNodeByName(o),!!i.expanded);n++);if(n==r.length-2){let a=r[n+1];if(i!=null&&i.inAnnotations.nodeNames[a]||i!=null&&i.outAnnotations.nodeNames[a])return a}return o}setDepth(t){ple(this.root,+t)}isNodeAuxiliary(t){let r=this.getRenderNodeByName(t.node.parentNode.name),n=me.find(r.isolatedInExtract,i=>i.node.name===t.node.name);return n?!0:(n=me.find(r.isolatedOutExtract,i=>i.node.name===t.node.name),!!n)}getNamesOfRenderedOps(){return this.renderedOpNames}cloneAndAddFunctionOpNode(t,r,n,i){let o=n.name.replace(r,i),a=t.metagraph.node(o);if(a)return a;a=new _0({name:o,input:[],device:n.device,op:n.op,attr:me.cloneDeep(n.attr)}),a.cardinality=n.cardinality,a.include=n.include,a.outputShapes=me.cloneDeep(n.outputShapes),a.xlaCluster=n.xlaCluster,a.functionInputIndex=n.functionInputIndex,a.functionOutputIndex=n.functionOutputIndex,a.inputs=n.inputs.map(l=>{let c=me.clone(l);return c.name=l.name.replace(r,i),c}),a.parentNode=t,t.metagraph.setNode(a.name,a),this.hierarchy.setNode(a.name,a);let s=l=>this.cloneAndAddFunctionOpNode(t,r,l,i);return a.inEmbeddings=n.inEmbeddings.map(s),a.outEmbeddings=n.outEmbeddings.map(s),a}cloneFunctionLibraryMetanode(t,r,n,i,o){let a={},s=this.cloneFunctionLibraryMetanodeHelper(t,r,n,i,o,a);return me.isEmpty(a)||this.patchEdgesFromFunctionOutputs(r,a),s}cloneFunctionLibraryMetanodeHelper(t,r,n,i,o,a){let s=sP(n.name.replace(i,o));return s.depth=n.depth,s.cardinality=n.cardinality,s.templateId=n.templateId,s.opHistogram=me.clone(n.opHistogram),s.deviceHistogram=me.clone(n.deviceHistogram),s.xlaClusterHistogram=me.clone(n.xlaClusterHistogram),s.hasNonControlEdges=n.hasNonControlEdges,s.include=n.include,s.nodeAttributes=me.clone(n.nodeAttributes),s.associatedFunction=n.associatedFunction,me.each(n.metagraph.nodes(),l=>{let c=n.metagraph.node(l);switch(c.type){case jt.META:let u=this.cloneFunctionLibraryMetanodeHelper(t,r,c,i,o,a);u.parentNode=s,s.metagraph.setNode(u.name,u),this.hierarchy.setNode(u.name,u);break;case jt.OP:let h=this.cloneAndAddFunctionOpNode(s,i,c,o);me.isNumber(h.functionInputIndex)&&this.patchEdgesIntoFunctionInputs(r,h),me.isNumber(h.functionOutputIndex)&&(a[h.functionOutputIndex]=h);break;default:console.warn(c.name+" is oddly neither a metanode nor an opnode.")}}),this.cloneLibraryMetanodeEdges(n,s,i,o),s}cloneLibraryMetanodeEdges(t,r,n,i){me.each(t.metagraph.edges(),o=>{let a=t.metagraph.edge(o),s=a.v.replace(n,i),l=a.w.replace(n,i),c=new qf(s,l);c.inbound=a.inbound,c.numRegularEdges=a.numRegularEdges,c.numControlEdges=a.numControlEdges,c.numRefEdges=a.numRefEdges,c.totalSize=a.totalSize,a.baseEdgeList&&(c.baseEdgeList=a.baseEdgeList.map(u=>{let h=me.clone(u);return h.v=u.v.replace(n,i),h.w=u.w.replace(n,i),h})),r.metagraph.node(l)?r.metagraph.setEdge(s,l,c):r.metagraph.setEdge(l,s,c)})}patchEdgesIntoFunctionInputs(t,r){let n=Math.min(r.functionInputIndex,t.inputs.length-1),i=me.clone(t.inputs[n]);for(;i.isControlDependency;)n++,i=t.inputs[n];r.inputs.push(i);let o=this.hierarchy.getPredecessors(t.name),a,s=0;me.each(o.regular,l=>{if(s+=l.numRegularEdges,s>n)return a=l,!1}),me.each(a.baseEdgeList,l=>{l.w===t.name&&(l.w=r.name),l.v===t.name&&(l.v=r.name)})}patchEdgesFromFunctionOutputs(t,r){let n=this.hierarchy.getSuccessors(t.name);me.each(n.regular,i=>{me.each(i.baseEdgeList,o=>{let a=this.hierarchy.node(o.w);me.each(a.inputs,s=>{if(s.name===t.name){let l=r[s.outputTensorKey];s.name=l.name,s.outputTensorKey=o.outputTensorKey}})}),me.each(i.baseEdgeList,o=>{o.v=r[o.outputTensorKey].name,o.outputTensorKey="0"})})}buildSubhierarchy(t){if(t in this.hasSubhierarchy)return;this.hasSubhierarchy[t]=!0;let r=this.index[t];if(r.node.type!==jt.META&&r.node.type!==jt.SERIES)return;let n=r,i=n.node.metagraph,o=n.coreGraph,a=[],s=[];me.isEmpty(this.hierarchy.libraryFunctions)||(me.each(i.nodes(),d=>{let g=i.node(d),_=this.hierarchy.libraryFunctions[g.op];if(!_||d.indexOf(Sa)===0)return;let y=this.cloneFunctionLibraryMetanode(i,g,_.node,_.node.name,g.name);a.push(g),s.push(y)}),me.each(s,(d,g)=>{let _=a[g];d.parentNode=_.parentNode,i.setNode(_.name,d),this.hierarchy.setNode(_.name,d)})),me.each(i.nodes(),d=>{let g=this.getOrCreateRenderNodeByName(d),_=g.node;o.setNode(d,g),_.isGroupNode||(me.each(_.inEmbeddings,y=>{let x=new Od(null),b=new Gf(y);hle(g,y,b,x,_i.CONSTANT),this.index[y.name]=b}),me.each(_.outEmbeddings,y=>{let x=new Od(null),b=new Gf(y);fle(g,y,b,x,_i.SUMMARY),this.index[y.name]=b}))}),me.each(i.edges(),d=>{let g=i.edge(d),_=new Od(g);_.isFadedOut=this.index[d.v].isFadedOut||this.index[d.w].isFadedOut,o.setEdge(d.v,d.w,_)}),n.node.type===jt.META&&Mcr(n,this.autoExtractNodes),me.isEmpty(this.hierarchy.libraryFunctions)||this.buildSubhierarchiesForNeededFunctions(i),t===qc&&me.forOwn(this.hierarchy.libraryFunctions,(d,g)=>{let _=d.node,y=this.getOrCreateRenderNodeByName(_.name);n.libraryFunctionsExtract.push(y),y.node.include=ur.EXCLUDE,o.removeNode(_.name)});let l=n.node.parentNode;if(!l)return;let c=this.index[l.name],u=(d,...g)=>g.concat([d?"IN":"OUT"]).join("~~"),h=this.hierarchy.getBridgegraph(t),f={in:{},out:{},control:{}};me.each(h.edges(),d=>{let g=!!i.node(d.w),_=g?d.v:d.w;h.edge(d).numRegularEdges?g?f.out[_]=(f.out[_]||0)+1:f.in[_]=(f.in[_]||0)+1:f.control[_]=(f.control[_]||0)+1});let p=this.hierarchy.getNodeMap();me.each(h.edges(),d=>{let g=h.edge(d),_=!!i.node(d.w),[y,x]=_?[d.w,d.v]:[d.v,d.w],b=this.index[y],S=this.index[x],C=S?S.node:p[x],P=!g.numRegularEdges&&f.control[x]>Xo.maxControlDegree,[,k]=_?[r.inAnnotations,b.inAnnotations]:[r.outAnnotations,b.outAnnotations],D=(_?f.out:f.in)[x]>Xo.maxBridgePathDegree,B=null,I=!1;if(Xo.enableBridgegraph&&!D&&!P&&b.isInCore()){let W=Z=>{let rt=_?{v:Z,w:t}:{v:t,w:Z};return c.coreGraph.edge(rt)};B=W(x),B||(B=W(u(_,x,l.name))),I=!!B}let L=!1;if(B&&!g.numRegularEdges){let W=B,Z=c.node;for(;W.adjoiningMetaedge;)W=W.adjoiningMetaedge,Z=Z.parentNode;let rt=this.hierarchy.getTopologicalOrdering(Z.name),ot=W.metaedge;L=rt[ot.v]>rt[ot.w]}if(I=I&&!L,!I){k.push(new i3(C,S,new Od(g),_i.SHORTCUT,_));return}let R=u(_,t),F=u(_,x,t),z=o.node(F);if(!z){let W=o.node(R);if(!W){let rt={name:R,type:jt.BRIDGE,isGroupNode:!1,cardinality:0,parentNode:null,stats:null,include:ur.UNSPECIFIED,inbound:_,nodeAttributes:{}};W=new Gf(rt),this.index[R]=W,o.setNode(R,W)}let Z={name:F,type:jt.BRIDGE,isGroupNode:!1,cardinality:1,parentNode:null,stats:null,include:ur.UNSPECIFIED,inbound:_,nodeAttributes:{}};z=new Gf(Z),this.index[F]=z,o.setNode(F,z),o.setParent(F,R),W.node.cardinality++}let U=new Od(g);U.adjoiningMetaedge=B,_?o.setEdge(F,y,U):o.setEdge(y,F,U)}),me.each([!0,!1],d=>{let g=u(d,t),_=o.node(g);!_||me.each(o.nodes(),y=>{var k,O;if(o.node(y).node.type===jt.BRIDGE||!(d?!((k=o.predecessors(y))!=null&&k.length):!((O=o.successors(y))!=null&&O.length)))return;let S=u(d,t,"STRUCTURAL_TARGET"),C=o.node(S);if(!C){let D={name:S,type:jt.BRIDGE,isGroupNode:!1,cardinality:1,parentNode:null,stats:null,include:ur.UNSPECIFIED,inbound:d,nodeAttributes:{}};C=new Gf(D),C.structural=!0,this.index[S]=C,o.setNode(S,C),_.node.cardinality++,o.setParent(S,g)}let P=new Od(null);P.structural=!0,P.weight--,d?o.setEdge(S,y,P):o.setEdge(y,S,P)})})}buildSubhierarchiesForNeededFunctions(t){me.each(t.edges(),r=>{let n=t.edge(r),i=new Od(n);me.forEach(i.metaedge.baseEdgeList,o=>{let a=o.v.split(Al);for(let s=a.length;s>=0;s--){let l=a.slice(0,s),c=this.hierarchy.node(l.join(Al));if(c){if(c.type===jt.OP&&this.hierarchy.libraryFunctions[c.op])for(let u=1;u<l.length;u++){let h=l.slice(0,u).join(Al);!h||this.buildSubhierarchy(h)}break}}})})}},i3=class{constructor(t,r,n,i,o){this.node=t,this.renderNodeInfo=r,this.renderMetaedgeInfo=n,this.annotationType=i,this.dx=0,this.dy=0,this.width=0,this.height=0,n&&n.metaedge&&(this.v=n.metaedge.v,this.w=n.metaedge.w),this.isIn=o,this.points=[]}},_i;(function(e){e[e.SHORTCUT=0]="SHORTCUT",e[e.CONSTANT=1]="CONSTANT",e[e.SUMMARY=2]="SUMMARY",e[e.ELLIPSIS=3]="ELLIPSIS"})(_i||(_i={}));var bH=class{constructor(){this.list=[],this.nodeNames={}}push(t){if(t.node.name in this.nodeNames)return;if(this.nodeNames[t.node.name]=!0,this.list.length<Xo.maxAnnotations){this.list.push(t);return}let r=this.list[this.list.length-1];if(r.annotationType===_i.ELLIPSIS){let i=r.node;i.setNumMoreNodes(++i.numMoreNodes);return}let n=new gH(1);this.list.push(new i3(n,new Gf(n),null,_i.ELLIPSIS,t.isIn))}},Gf=class{constructor(t){if(this.node=t,this.expanded=!1,this.inAnnotations=new bH,this.outAnnotations=new bH,this.x=0,this.y=0,this.width=0,this.height=0,this.inboxWidth=0,this.outboxWidth=0,this.excluded=!1,this.structural=!1,this.labelOffset=0,this.radius=0,this.labelHeight=0,this.paddingTop=0,this.paddingLeft=0,this.paddingRight=0,this.paddingBottom=0,this.isInExtract=!1,this.isOutExtract=!1,this.coreBox={width:0,height:0},this.isFadedOut=!1,this.displayName=t.name.substring(t.name.lastIndexOf(Al)+1),t.type===jt.META&&t.associatedFunction){let r=this.displayName.match(_cr);r?this.displayName=r[1]:me.startsWith(this.displayName,Sa)&&(this.displayName=this.displayName.substring(Sa.length))}}isInCore(){return!this.isInExtract&&!this.isOutExtract&&!this.isLibraryFunction}},Od=class{constructor(t){this.metaedge=t,this.adjoiningMetaedge=null,this.structural=!1,this.weight=1,this.isFadedOut=!1}};function hle(e,t,r,n,i){let o=new i3(t,r,n,i,!0);e.inAnnotations.push(o)}function fle(e,t,r,n,i){let o=new i3(t,r,n,i,!1);e.outAnnotations.push(o)}function ycr(e,t){me.each(e.nodes(),r=>{let n=e.node(r);if(n.expanded=t>1,t>0)switch(n.node.type){case jt.META:case jt.SERIES:ple(n,t-1);break}})}var wH=class extends Gf{constructor(t,r){super(t);let i=t.metagraph.graph();this.coreGraph=e3(i.name,g0.CORE,r),this.inExtractBox={width:0,height:0},this.outExtractBox={width:0,height:0},this.libraryFunctionsBox={width:0,height:0},this.isolatedInExtract=[],this.isolatedOutExtract=[],this.libraryFunctionsExtract=[]}};function ple(e,t){e.coreGraph&&ycr(e.coreGraph,t)}function cP(e,t,r){let n=e.node(t),i=e.node(r),o=e.edge(t,r);(n.node.include===ur.INCLUDE||i.node.include===ur.INCLUDE)&&n.node.include!==ur.EXCLUDE&&i.node.include!==ur.EXCLUDE||(fle(n,i.node,i,o,_i.SHORTCUT),hle(i,n.node,n,o,_i.SHORTCUT),e.removeEdge(t,r))}function qlt(e,t,r){var o;let n=e.coreGraph,i=n.node(t);i.isOutExtract=!0,me.each(n.predecessors(t),(a,s)=>{cP(n,a,t)}),(Xo.detachAllEdgesForHighDegree||r)&&me.each(n.successors(t),(a,s)=>{cP(n,t,a)}),((o=n.neighbors(t))==null?void 0:o.length)===0&&(i.node.include=ur.EXCLUDE,e.isolatedOutExtract.push(i),n.removeNode(t))}function Glt(e,t,r){var o;let n=e.coreGraph,i=n.node(t);i.isInExtract=!0,me.each(n.successors(t),(a,s)=>{cP(n,t,a)}),(Xo.detachAllEdgesForHighDegree||r)&&me.each(n.predecessors(t),(a,s)=>{cP(n,a,t)}),((o=n.neighbors(t))==null?void 0:o.length)===0&&(i.node.include=ur.EXCLUDE,e.isolatedInExtract.push(i),n.removeNode(t))}function dle(e,t){if(e.type===jt.OP){for(let r=0;r<t.length;r++)if(e.op===t[r])return!0}else if(e.type===jt.META){let r=e.getRootOp();if(r){for(let n=0;n<t.length;n++)if(r.op===t[n])return!0}}return!1}function vcr(e){let t=e.coreGraph;me.each(t.nodes(),r=>{var i,o;t.node(r).node.include===ur.EXCLUDE&&!r.startsWith(Sa)&&(((i=e.coreGraph.outEdges(r))==null?void 0:i.length)>((o=e.coreGraph.inEdges(r))==null?void 0:o.length)?qlt(e,r,!0):Glt(e,r,!0))})}function xcr(e){let t=e.coreGraph;me.each(t.nodes(),r=>{let n=t.node(r);n.node.include===ur.UNSPECIFIED&&dle(n.node,Xo.outExtractTypes)&&qlt(e,r)})}function bcr(e){let t=e.coreGraph;me.each(t.nodes(),r=>{let n=t.node(r);n.node.include===ur.UNSPECIFIED&&dle(n.node,Xo.inExtractTypes)&&Glt(e,r)})}function wcr(e){let t=e.coreGraph,r={},n={},i=0;if(me.each(t.nodes(),_=>{var b,S,C,P;if(t.node(_).node.include!==ur.UNSPECIFIED)return;let y=me.reduce(t.predecessors(_),(k,O)=>{let D=t.edge(O,_).metaedge;return k+(D.numRegularEdges?1:0)},0);y===0&&((b=t.predecessors(_))==null?void 0:b.length)>0&&(y=(S=t.predecessors(_))==null?void 0:S.length);let x=me.reduce(t.successors(_),(k,O)=>{let D=t.edge(_,O).metaedge;return k+(D.numRegularEdges?1:0)},0);x===0&&((C=t.successors(_))==null?void 0:C.length)>0&&(x=(P=t.successors(_))==null?void 0:P.length),r[_]=y,n[_]=x,i++}),i<Xo.minNodeCountForExtraction)return;let o=Xo.minDegreeForExtraction-1,a=Math.round(i*.75),s=Math.round(i*.25),l=Object.keys(r).sort((_,y)=>r[_]-r[y]),c=r[l[a]],u=r[l[s]],h=c+c-u;h=Math.max(h,o);for(let _=i-1;r[l[_]]>h;_--)Glt(e,l[_]);let f=Object.keys(n).sort((_,y)=>n[_]-n[y]),p=n[f[a]],d=n[f[s]],g=p+(p-d)*4;g=Math.max(g,o);for(let _=i-1;n[f[_]]>g;_--){let y=t.node(f[_]);!y||y.isInExtract||qlt(e,f[_])}}function Scr(e){let t=e.coreGraph,r={};me.each(t.edges(),n=>{t.edge(n).metaedge.numRegularEdges||((r[n.v]=r[n.v]||[]).push(n),(r[n.w]=r[n.w]||[]).push(n))}),me.each(r,(n,i)=>{n.length>Xo.maxControlDegree&&me.each(n,o=>cP(t,o.v,o.w))})}function Mcr(e,t){vcr(e),Xo.outExtractTypes.length&&xcr(e),Xo.inExtractTypes.length&&bcr(e),t&&wcr(e),Xo.maxControlDegree&&Scr(e);let r=e.coreGraph;me.each(r.nodes(),n=>{var a;let i=r.node(n),o=(a=r.neighbors(n))==null?void 0:a.length;if(i.node.include===ur.UNSPECIFIED&&o===0){let s=i.outAnnotations.list.length>0,l=i.inAnnotations.list.length>0;i.isInExtract?(e.isolatedInExtract.push(i),i.node.include=ur.EXCLUDE,r.removeNode(n)):i.isOutExtract?(e.isolatedOutExtract.push(i),i.node.include=ur.EXCLUDE,r.removeNode(n)):Xo.extractIsolatedNodesWithAnnotationsOnOneSide&&(s&&!l?(i.isInExtract=!0,e.isolatedInExtract.push(i),i.node.include=ur.EXCLUDE,r.removeNode(n)):l&&!s&&(i.isOutExtract=!0,e.isolatedOutExtract.push(i),i.node.include=ur.EXCLUDE,r.removeNode(n)))}})}function mle(e,t,r){let n=r.split("/"),i=n[n.length-1].match(/(.*):\w+/);(i==null?void 0:i.length)===2&&(n[n.length-1]=i==null?void 0:i[1]);let o=n[0],a=t.getRenderNodeByName(o);for(let s=1;s<n.length&&a.node.type!==jt.OP;s++)t.buildSubhierarchy(o),a.expanded=!0,e.setNodeExpanded(a),o+="/"+n[s],a=t.getRenderNodeByName(o);return a.node.name}var vle=Ee(zlt(),1),Ze=Ee(Oe(),1);var Tr={animation:{duration:250},graph:{meta:{nodeSep:5,rankSep:25,edgeSep:5},series:{nodeSep:5,rankSep:25,edgeSep:5},padding:{paddingTop:40,paddingLeft:20}},subscene:{meta:{paddingTop:10,paddingBottom:10,paddingLeft:10,paddingRight:10,labelHeight:20,extractXOffset:15,extractYOffset:20},series:{paddingTop:10,paddingBottom:10,paddingLeft:10,paddingRight:10,labelHeight:10}},nodeSize:{meta:{radius:5,width:60,maxLabelWidth:52,height:zn().domain([1,200]).range([15,60]).clamp(!0),expandButtonRadius:3},op:{width:15,height:6,radius:3,labelOffset:-8,maxLabelWidth:30},series:{expanded:{radius:10,labelOffset:0},vertical:{width:16,height:13,labelOffset:-13},horizontal:{width:24,height:8,radius:10,labelOffset:-10}},bridge:{width:20,height:20,radius:2,labelOffset:0}},shortcutSize:{op:{width:10,height:4},meta:{width:12,height:4,radius:1},series:{width:14,height:4}},annotations:{inboxWidth:50,outboxWidth:50,xOffset:10,yOffset:3,labelOffset:2,maxLabelWidth:40},constant:{size:{width:4,height:4}},series:{maxStackCount:3,parallelStackOffsetRatio:.2,towerStackOffsetRatio:.5},minimap:{size:150}},o3=140;function SH(e){e.node.isGroupNode&&Tcr(e),e.node.type===jt.META?Ccr(e):e.node.type===jt.SERIES&&Acr(e)}function Ecr(e){e.inboxWidth=e.inAnnotations.list.length>0?Tr.annotations.inboxWidth:0,e.outboxWidth=e.outAnnotations.list.length>0?Tr.annotations.outboxWidth:0,e.coreBox.width=e.width,e.coreBox.height=e.height;let t=e.displayName.length,r=3;e.width=Math.max(e.coreBox.width+e.inboxWidth+e.outboxWidth,t*r)}function Tcr(e){let t=e.coreGraph.nodes().map(r=>e.coreGraph.node(r)).concat(e.isolatedInExtract,e.isolatedOutExtract,e.libraryFunctionsExtract);Ze.each(t,r=>{switch(r.node.type){case jt.OP:Ze.extend(r,Tr.nodeSize.op);break;case jt.BRIDGE:Ze.extend(r,Tr.nodeSize.bridge);break;case jt.META:r.expanded?SH(r):(Ze.extend(r,Tr.nodeSize.meta),r.height=Tr.nodeSize.meta.height(r.node.cardinality));break;case jt.SERIES:if(r.expanded)Ze.extend(r,Tr.nodeSize.series.expanded),SH(r);else{let i=r.node.hasNonControlEdges?Tr.nodeSize.series.vertical:Tr.nodeSize.series.horizontal;Ze.extend(r,i)}break;default:throw Error("Unrecognized node type: "+r.node.type)}r.expanded||Ecr(r),Pcr(r)})}function xle(e,t){Ze.extend(e.graph(),{nodesep:t.nodeSep,ranksep:t.rankSep,edgesep:t.edgeSep});let r=[],n=[];if(Ze.each(e.nodes(),l=>{e.node(l).node.type===jt.BRIDGE?r.push(l):n.push(l)}),!n.length)return{width:0,height:0};vle.layout(e);let i=1/0,o=1/0,a=-1/0,s=-1/0;return Ze.each(n,l=>{let c=e.node(l),u=.5*c.width,h=c.x-u,f=c.x+u;i=h<i?h:i,a=f>a?f:a;let p=.5*c.height,d=c.y-p,g=c.y+p;o=d<o?d:o,s=g>s?g:s}),Ze.each(e.edges(),l=>{let c=e.edge(l);if(c.structural)return;let u=e.node(c.metaedge.v),h=e.node(c.metaedge.w);if(c.points.length===3&&Icr(c.points)){if(u!=null){let d=u.expanded?u.x:v0(u);c.points[0].x=d}if(h!=null){let d=h.expanded?h.x:v0(h);c.points[2].x=d}c.points=[c.points[0],c.points[1]]}let f=c.points[c.points.length-2];h!=null&&(c.points[c.points.length-1]=yle(f,h));let p=c.points[1];u!=null&&(c.points[0]=yle(p,u)),Ze.each(c.points,d=>{i=d.x<i?d.x:i,a=d.x>a?d.x:a,o=d.y<o?d.y:o,s=d.y>s?d.y:s})}),Ze.each(e.nodes(),l=>{let c=e.node(l);c.x-=i,c.y-=o}),Ze.each(e.edges(),l=>{Ze.each(e.edge(l).points,c=>{c.x-=i,c.y-=o})}),{width:a-i,height:s-o}}function Ccr(e){let t=Tr.subscene.meta;Ze.extend(e,t),Ze.extend(e.coreBox,xle(e.coreGraph,Tr.graph.meta));let r=e.isolatedInExtract.length?Ze.maxBy(e.isolatedInExtract,c=>c.width).width:null;e.inExtractBox.width=r!=null?r:0,e.inExtractBox.height=Ze.reduce(e.isolatedInExtract,(c,u,h)=>{let f=h>0?t.extractYOffset:0;return u.x=0,u.y=c+f+u.height/2,c+f+u.height},0);let n=e.isolatedOutExtract.length?Ze.maxBy(e.isolatedOutExtract,c=>c.width).width:null;e.outExtractBox.width=n!=null?n:0,e.outExtractBox.height=Ze.reduce(e.isolatedOutExtract,(c,u,h)=>{let f=h>0?t.extractYOffset:0;return u.x=0,u.y=c+f+u.height/2,c+f+u.height},0);let i=e.libraryFunctionsExtract.length?Ze.maxBy(e.libraryFunctionsExtract,c=>c.width).width:null;e.libraryFunctionsBox.width=i!=null?i:0,e.libraryFunctionsBox.height=Ze.reduce(e.libraryFunctionsExtract,(c,u,h)=>{let f=h>0?t.extractYOffset:0;return u.x=0,u.y=c+f+u.height/2,c+f+u.height},0);let o=0;e.isolatedInExtract.length>0&&o++,e.isolatedOutExtract.length>0&&o++,e.libraryFunctionsExtract.length>0&&o++,e.coreGraph.nodeCount()>0&&o++;let a=Tr.subscene.meta.extractXOffset,s=o<=1?0:o*a,l=Math.max(o3,e.inExtractBox.width+e.outExtractBox.width);e.coreBox.width+=l+s+e.libraryFunctionsBox.width+s,e.coreBox.height=t.labelHeight+Math.max(e.inExtractBox.height,e.coreBox.height,e.libraryFunctionsBox.height,e.outExtractBox.height),e.width=e.coreBox.width+t.paddingLeft+t.paddingRight,e.height=e.paddingTop+e.coreBox.height+e.paddingBottom}function Acr(e){let t=e.coreGraph,r=Tr.subscene.series;Ze.extend(e,r),Ze.extend(e.coreBox,xle(e.coreGraph,Tr.graph.series)),Ze.each(t.nodes(),n=>{t.node(n).excluded=!1}),e.width=e.coreBox.width+r.paddingLeft+r.paddingRight,e.height=e.coreBox.height+r.paddingTop+r.paddingBottom}function Pcr(e){if(e.expanded)return;let t=e.inAnnotations.list,r=e.outAnnotations.list;Ze.each(t,u=>gle(u)),Ze.each(r,u=>gle(u));let n=Tr.annotations,i=Ze.reduce(t,(u,h,f)=>{let p=f>0?n.yOffset:0;return h.dx=-(e.coreBox.width+h.width)/2-n.xOffset,h.dy=u+p+h.height/2,u+p+h.height},0);Ze.each(t,u=>{u.dy-=i/2,u.labelOffset=n.labelOffset});let o=Ze.reduce(r,(u,h,f)=>{let p=f>0?n.yOffset:0;return h.dx=(e.coreBox.width+h.width)/2+n.xOffset,h.dy=u+p+h.height/2,u+p+h.height},0);Ze.each(r,u=>{u.dy-=o/2,u.labelOffset=n.labelOffset});let a=Math.min(e.height/2-e.radius,i/2);a=a<0?0:a;let s=zn().domain([0,t.length-1]).range([-a,a]);Ze.each(t,(u,h)=>{u.points=[{dx:u.dx+u.width/2,dy:u.dy},{dx:-e.coreBox.width/2,dy:t.length>1?s(h):0}]});let l=Math.min(e.height/2-e.radius,o/2);l=l<0?0:l;let c=zn().domain([0,r.length-1]).range([-l,l]);Ze.each(r,(u,h)=>{u.points=[{dx:e.coreBox.width/2,dy:r.length>1?c(h):0},{dx:u.dx-u.width/2,dy:u.dy}]}),e.height=Math.max(e.height,i,o)}function gle(e){switch(e.annotationType){case _i.CONSTANT:Ze.extend(e,Tr.constant.size);break;case _i.SHORTCUT:if(e.node.type===jt.OP)Ze.extend(e,Tr.shortcutSize.op);else if(e.node.type===jt.META)Ze.extend(e,Tr.shortcutSize.meta);else if(e.node.type===jt.SERIES)Ze.extend(e,Tr.shortcutSize.series);else throw Error("Invalid node type: "+e.node.type);break;case _i.SUMMARY:Ze.extend(e,Tr.constant.size);break}}function v0(e){if(e.expanded)return e.x;let t=e.inAnnotations.list.length?e.inboxWidth:0;return e.x-e.width/2+t+e.coreBox.width/2}function _le(e,t){let r=t.x-e.x,n=t.y-e.y;return 180*Math.atan(n/r)/Math.PI}function Icr(e){let t=_le(e[0],e[1]);for(let r=1;r<e.length-1;r++){let n=_le(e[r],e[r+1]);if(Math.abs(n-t)>1)return!1;t=n}return!0}function yle(e,t){let r=t.expanded?t.x:v0(t),n=t.y,i=e.x-r,o=e.y-n,a=t.expanded?t.width:t.coreBox.width,s=t.expanded?t.height:t.coreBox.height,l,c;return Math.abs(o)*a/2>Math.abs(i)*s/2?(o<0&&(s=-s),l=o===0?0:s/2*i/o,c=s/2):(i<0&&(a=-a),l=a/2,c=i===0?0:a/2*o/i),{x:r+l,y:n+c}}var Pl=m0,Hi=ye,Lcr=320,kcr=150,hP=[{background_color:"#CC2F2C",label:"NaN"},{background_color:"#FF8D00",label:"-\u221E"},{background_color:"#EAEAEA",label:"-"},{background_color:"#A5A5A5",label:"0"},{background_color:"#262626",label:"+"},{background_color:"#003ED4",label:"+\u221E"}];function wle(e,t,r,n){let i=e.getBoundingClientRect(),o=null;try{if(o=t.getBBox(),(o==null?void 0:o.width)===0)return}catch(c){return}let a=.9*Math.min(i.width/(o==null?void 0:o.width),i.height/(o==null?void 0:o.height),2),s=Tr.graph,l=Xh.scale(a).translate(s.padding.paddingLeft,s.padding.paddingTop);Ht(e).transition().duration(500).call(r.transform,l).on("end.fitted",()=>{r.on("end.fitted",null),n()})}function Sle(e,t,r,n){let i=Ht(t).select(`[data-name="${e}"]`).node();if(!i)return console.warn(`panToNode() failed for node name "${e}"`),!1;let o=i.getBBox(),a=i.getScreenCTM(),s=t.createSVGPoint(),l=t.createSVGPoint();s.x=o.x,s.y=o.y,l.x=o.x+o.width,l.y=o.y+o.height,s=s.matrixTransform(a),l=l.matrixTransform(a);let c=(p,d,g,_)=>!(p>g&&d<_),u=t.getBoundingClientRect(),h=u.left+u.width-Lcr,f=u.top+u.height-kcr;if(c(s.x,l.x,u.left,h)||c(s.y,l.y,u.top,f)){let p=(s.x+l.x)/2,d=(s.y+l.y)/2,g=u.left+u.width/2-p,_=u.top+u.height/2-d,y=i2(t);return Ht(t).transition().duration(500).call(n.translateBy,g/y.k,_/y.k),!0}return!1}function Mle(e,t){let r=t.node.type===jt.SERIES?0:Tr.subscene.meta.labelHeight;a3(Pl(e,"g",Hi.Scene.CORE),0,r);let n=t.isolatedInExtract.length>0,i=t.isolatedOutExtract.length>0,o=t.libraryFunctionsExtract.length>0,a=Tr.subscene.meta.extractXOffset,s=0;if(n&&(s+=t.outExtractBox.width),i&&(s+=t.outExtractBox.width),n){let l=t.coreBox.width;s<o3?l=l-o3+t.inExtractBox.width/2:l=l-t.inExtractBox.width/2-t.outExtractBox.width-(i?a:0),l=l-t.libraryFunctionsBox.width-(o?a:0),a3(Pl(e,"g",Hi.Scene.INEXTRACT),l,r)}if(i){let l=t.coreBox.width;s<o3?l=l-o3+t.outExtractBox.width/2:l-=t.outExtractBox.width/2,l=l-t.libraryFunctionsBox.width-(o?a:0),a3(Pl(e,"g",Hi.Scene.OUTEXTRACT),l,r)}if(o){let l=t.coreBox.width-t.libraryFunctionsBox.width/2;a3(Pl(e,"g",Hi.Scene.FUNCTION_LIBRARY),l,r)}}function Ele(e,t){Ht(e).on("click",()=>{t.fire("graph-select")})}function a3(e,t,r){e.attr("transform")!=null&&(e=e.transition("position")),e.attr("transform","translate("+t+","+r+")")}function zd(e,t,r,n,i){e.transition().attr("x",t-n/2).attr("y",r-i/2).attr("width",n).attr("height",i)}function Tle(e,t,r,n,i){let o=i/2,a=n/2,s=[[t,r-o],[t+a,r+o],[t-a,r+o]];e.transition().attr("points",s.map(l=>l.join(",")).join(" "))}function Cle(e,t){let r=v0(t),n=t.expanded?t.width:t.coreBox.width,i=t.expanded?t.height:t.coreBox.height,o=r+n/2-6,a=t.y-i/2+6;t.node.type===jt.SERIES&&!t.expanded&&(o+=10,a-=2);let s="translate("+o+","+a+")";e.selectAll("path").transition().attr("transform",s),e.select("circle").transition().attr({cx:o,cy:a,r:Tr.nodeSize.meta.expandButtonRadius})}function MH(e,t,r,n,i){e.transition().attr("cx",t).attr("cy",r).attr("rx",n/2).attr("ry",i/2)}function ble(e,t){return t?e.toFixed(0):Math.abs(e)>=1?e.toFixed(1):e.toExponential(1)}function Rcr(e,t,r,n){let i="Device: "+e.device_name+`
`;i+="dtype: "+e.dtype+`
`;let o="(scalar)";e.shape.length>0&&(o="("+e.shape.join(",")+")"),i+=`
shape: `+o+`

`,i+="#(elements): "+t+`
`;let a=[];for(let s=0;s<r.length;s++)r[s]>0&&a.push("#("+hP[s].label+"): "+r[s]);return i+=a.join(", ")+`

`,n.max>=n.min&&(i+="min: "+n.min+", max: "+n.max+`
`,i+="mean: "+n.mean+", stddev: "+n.stddev),i}function Ncr(e,t,r,n,i=60,o=10,a=0,s){if(Ht(e.parentNode).selectAll(".health-pill").remove(),!t)return;let l=t.value,c=l.slice(2,8),u=c[0],h=c[1],f=c[5],p=l[1],d={min:l[8],max:l[9],mean:l[10],stddev:Math.sqrt(l[11])};i==null&&(i=60),o==null&&(o=10),a==null&&(a=0),r!=null&&r.node.type===jt.OP&&(i/=2,o/=2);let g=document.createElementNS(ju,"g");g.classList.add("health-pill");let _=document.createElementNS(ju,"defs");g.appendChild(_);let y=document.createElementNS(ju,"linearGradient"),x="health-pill-gradient-"+n;y.setAttribute("id",x);let b=0,S="0%";for(let D=0;D<c.length;D++){if(!c[D])continue;b+=c[D];let B=document.createElementNS(ju,"stop");B.setAttribute("offset",S),B.setAttribute("stop-color",hP[D].background_color),y.appendChild(B);let I=document.createElementNS(ju,"stop"),L=b*100/p+"%";I.setAttribute("offset",L),I.setAttribute("stop-color",hP[D].background_color),y.appendChild(I),S=L}_.appendChild(y);let C=document.createElementNS(ju,"rect");C.setAttribute("fill","url(#"+x+")"),C.setAttribute("width",String(i)),C.setAttribute("height",String(o)),C.setAttribute("y",String(a)),g.appendChild(C);let P=document.createElementNS(ju,"title");P.textContent=Rcr(t,p,c,d),g.appendChild(P);let k=!1;if(r!=null){let D=r.x-i/2,B=r.y-o-r.height/2-2;if(r.labelOffset<0&&(B+=r.labelOffset),g.setAttribute("transform","translate("+D+", "+B+")"),c[2]||c[3]||c[4]){let L=r.node.attr;if(L&&L.length){for(let R=0;R<L.length;R++)if(L[R].key==="T"){let F=L[R].value.type;k=F&&/^DT_(BOOL|INT|UINT)/.test(F);break}}}}let O=document.createElementNS(ju,"text");if(Number.isFinite(d.min)&&Number.isFinite(d.max)){let D=ble(d.min,k),B=ble(d.max,k);if(p>1?O.textContent=D+" ~ "+B:O.textContent=D,u>0||h>0||f>0){O.textContent+=" (";let I=[];u>0&&I.push(`NaN\xD7${u}`),h>0&&I.push(`-\u221E\xD7${h}`),f>0&&I.push(`+\u221E\xD7${f}`),O.textContent+=I.join("; ")+")"}}else O.textContent="(No finite elements)";O.classList.add("health-pill-stats"),s==null&&(s=i/2),O.setAttribute("x",String(s)),O.setAttribute("y",String(a-2)),g.appendChild(O),zt(e.parentNode).appendChild(g)}function Ale(e,t,r){if(!t)return;let n=1;Ht(e).selectAll("g.nodeshape").each(function(o){let a=t[o.node.name],s=a?a[r]:null;Ncr(this,s,o,n++)})}var Gn;(function(e){e.NONE="none",e.COMPUTE_TIME="compute_time",e.DEVICE="device",e.MEMORY="memory",e.OP_COMPATIBILITY="op_compatibility",e.STRUCTURE="structure",e.XLA_CLUSTER="xla_cluster"})(Gn||(Gn={}));var dP=Ee(Oe(),1);var Vi=Ee(Oe(),1);function Dcr(e){let t=0,r=0,n=e;for(;n&&n.offsetLeft>=0&&n.offsetTop>=0;)t+=n.offsetLeft-n.scrollLeft,r+=n.offsetTop-n.scrollTop,n=n.offsetParent;return{left:t,top:r}}function Ylt(e,t){let r=e.getContextMenu(),n=Ht(e.getContextMenu());return function(i,o){let a=qt,s=Dcr(e);n.style("display","block").style("left",a.clientX-s.left+1+"px").style("top",a.clientY-s.top+1+"px"),a.preventDefault(),a.stopPropagation();function l(u){u&&u.composedPath().includes(r)||(n.style("display","none"),document.body.removeEventListener("mousedown",l,{capture:!0}))}document.body.addEventListener("mousedown",l,{capture:!0}),n.text(""),n.append("ul").selectAll("li").data(t).enter().append("li").on("click",(u,h)=>{u.action(this,i,o),l()}).text(function(u){return u.title(i)})}}var CH=Ee(Oe(),1);var zcr="\xD7",Ple=qb().domain([J4,Q4]).range(["small","medium","large","xlarge"]),Fcr=2.5;function fP(e){return e.v+tle+e.w}function kle(e,t,r){let n=r,i=[];i=CH.reduce(t.edges(),(s,l)=>{let c=t.edge(l);return s.push({v:l.v,w:l.w,label:c}),s},i);let a=Pn(e,"g",ye.Edge.CONTAINER).selectAll(function(){return this.childNodes}).data(i,fP);return a.enter().append("g").attr("class",ye.Edge.GROUP).attr("data-edge",fP).each(function(s){let l=Ht(this);s.label.edgeGroup=l,n._edgeGroupIndex[fP(s)]=l,n.handleEdgeSelected&&l.on("click",c=>{qt.stopPropagation(),n.fire("edge-select",{edgeData:c,edgeGroup:l})}),$lt(l,s,n)}).merge(a).each(function(){Hcr(r,this)}).each(function(s){Vcr(Ht(this),s,n)}),a.exit().each(s=>{delete n._edgeGroupIndex[fP(s)]}).remove(),a}function jlt(e,t){let r=t.getNodeByName(e.v);if(r.outputShapes==null||CH.isEmpty(r.outputShapes))return null;let n=r.outputShapes[e.outputTensorKey];return n==null?null:n.length===0?"scalar":n.map(i=>i===-1?"?":i).join(zcr)}function Xlt(e,t){return t.edgeLabelFunction?t.edgeLabelFunction(e,t):e.baseEdgeList.length>1?e.baseEdgeList.length+" tensors":jlt(e.baseEdgeList[0],t)}function Ile(e,t,r){let n=document.createElementNS(ju,"path");for(let i=1;i<e.length;i++)if(n.setAttribute("d",r(e.slice(0,i))),n.getTotalLength()>t)return i-1;return e.length-1}function Lle(e,t,r){let n=vu().x(u=>u.x).y(u=>u.y),i=Ht(document.createElementNS("http://www.w3.org/2000/svg","path")).attr("d",n(e)),o=+t.attr("markerWidth"),a=t.attr("viewBox").split(" ").map(Number),s=a[2]-a[0],l=+t.attr("refX"),c=i.node();if(r){let u=1-l/s,h=o*u,f=c.getPointAtLength(h),p=Ile(e,h,n);return e[p-1]={x:f.x,y:f.y},e.slice(p-1)}else{let u=1-l/s,h=c.getTotalLength()-o*u,f=c.getPointAtLength(h),p=Ile(e,h,n);return e[p]={x:f.x,y:f.y},e.slice(0,p+1)}}function $lt(e,t,r,n){n=n||ye.Edge.LINE,t.label&&t.label.structural&&(n+=" "+ye.Edge.STRUCTURAL),t.label&&t.label.metaedge&&t.label.metaedge.numRefEdges&&(n+=" "+ye.Edge.REFERENCE_EDGE),r.handleEdgeSelected&&(n+=" "+ye.Edge.SELECTABLE);let i="path_"+fP(t),o;if(r.renderHierarchy.edgeWidthFunction)o=r.renderHierarchy.edgeWidthFunction(t,n);else{let c=1;t.label!=null&&t.label.metaedge!=null&&(c=t.label.metaedge.totalSize),o=r.renderHierarchy.edgeWidthSizedBasedScale(c)}let a=e.append("path").attr("id",i).attr("class",n).style("stroke-width",o+"px");if(t.label&&t.label.metaedge)if(t.label.metaedge.numRefEdges){let c=`reference-arrowhead-${Ple(o)}`;a.style("marker-start",`url(#${c})`),t.label.startMarkerId=c}else{let c=`dataflow-arrowhead-${Ple(o)}`;a.style("marker-end",`url(#${c})`),t.label.endMarkerId=c}if(t.label==null||t.label.metaedge==null)return;let s=Xlt(t.label.metaedge,r.renderHierarchy);if(s==null)return;let l=o>Fcr?"central":"text-after-edge";e.append("text").append("textPath").attr("xlink:href","#"+i).attr("startOffset","50%").attr("text-anchor","middle").attr("dominant-baseline","central").text(s)}var TH=vu().curve(G8).x(e=>e.x).y(e=>e.y);function Bcr(e,t,r,n,i){let o=r.label,a=o.adjoiningMetaedge,s=o.points,{shadowRoot:l}=e;if(r.label.startMarkerId&&(s=Lle(s,Ht(l==null?void 0:l.querySelector("#"+r.label.startMarkerId)),!0)),r.label.endMarkerId&&(s=Lle(s,Ht(l==null?void 0:l.querySelector("#"+r.label.endMarkerId)),!1)),!a)return nc(i,TH(s));let c=a.edgeGroup.node().firstChild,u=o.metaedge.inbound;return function(h){var g;let f=c.getPointAtLength(u?c.getTotalLength():0).matrixTransform(c.getCTM()).matrixTransform((g=t.getCTM())==null?void 0:g.inverse()),p=u?0:s.length-1;return s[p].x=f.x,s[p].y=f.y,TH(s)}}function Hcr(e,t){Ht(t).select("path."+ye.Edge.LINE).transition().attrTween("d",function(r,n,i){return Bcr(e,this,r,n,i)})}function Vcr(e,t,r){e.classed("faded",t.label.isFadedOut);let n=t.label.metaedge;e.select("path."+ye.Edge.LINE).classed("control-dep",n&&!n.numRegularEdges)}function AH(e,t,r){let i=Pn(e,"g",ye.Node.CONTAINER).selectAll(function(){return this.childNodes}).data(t,o=>o.node.name+":"+o.node.type);return i.enter().append("g").attr("data-name",o=>o.node.name).each(function(o){let a=Ht(this);r.addNodeGroup(o.node.name,a)}).merge(i).attr("class",o=>ye.Node.GROUP+" "+Hle(o)).each(function(o){let a=Ht(this),s=Pn(a,"g",ye.Annotation.INBOX);Ole(s,o.inAnnotations,o,r);let l=Pn(a,"g",ye.Annotation.OUTBOX);Ole(l,o.outAnnotations,o,r);let c=Ble(a,o,ye.Node.SHAPE);o.node.isGroupNode&&qcr(c,o,r),Dle(c,o,r),Ucr(a,o,r);let u=Wcr(a,o,r);Dle(u,o,r,o.node.type===jt.META),s3(a,o,r),jcr(a,o)}),i.exit().each(function(o){r.removeNodeGroup(o.node.name);let a=Ht(this);o.inAnnotations.list.length>0&&a.select("."+ye.Annotation.INBOX).selectAll("."+ye.Annotation.GROUP).each(s=>{r.removeAnnotationGroup(s,o)}),o.outAnnotations.list.length>0&&a.select("."+ye.Annotation.OUTBOX).selectAll("."+ye.Annotation.GROUP).each(s=>{r.removeAnnotationGroup(s,o)})}).remove(),i}function Ucr(e,t,r){if(t.node.isGroupNode){if(t.expanded)return rct(e,t,r,ye.Subscene.GROUP);Pl(e,"g",ye.Subscene.GROUP).remove()}return null}function Nle(e,t){let r=t.x-t.width/2+t.paddingLeft,n=t.y-t.height/2+t.paddingTop,i=Pl(e,"g",ye.Subscene.GROUP);a3(i,r,n)}function qcr(e,t,r){let n=Pn(e,"g",ye.Node.BUTTON_CONTAINER);Pn(n,"circle",ye.Node.BUTTON_CIRCLE),Pn(n,"path",ye.Node.EXPAND_BUTTON).attr("d","M0,-2.2 V2.2 M-2.2,0 H2.2"),Pn(n,"path",ye.Node.COLLAPSE_BUTTON).attr("d","M-2.2,0 H2.2"),n.on("click",i=>{qt.stopPropagation(),r.fire("node-toggle-expand",{name:i.node.name})}),Cle(n,t)}function Dle(e,t,r,n){if(n){e.attr("pointer-events","none");return}let i=Ylt(r,zle(t.node,r));e.on("dblclick",o=>{r.fire("node-toggle-expand",{name:o.node.name})}).on("mouseover",o=>{r.isNodeExpanded(o)||r.fire("node-highlight",{name:o.node.name})}).on("mouseout",o=>{r.isNodeExpanded(o)||r.fire("node-unhighlight",{name:o.node.name})}).on("click",o=>{qt.stopPropagation(),r.fire("node-select",{name:o.node.name})}).on("contextmenu",(o,a)=>{r.fire("node-select",{name:o.node.name}),i.call(o,a)})}function zle(e,t){let r=[{title:n=>_H(e.include),action:(n,i,o)=>{t.fire("node-toggle-extract",{name:e.name})}}];return t.nodeContextMenuItems&&(r=r.concat(t.nodeContextMenuItems)),Qlt(e)&&r.push({title:n=>tct(e),action:(n,i,o)=>{t.fire("node-toggle-seriesgroup",{name:PH(e)})}}),r}function Qlt(e){return PH(e)!==null}function PH(e){return e?e.type===jt.SERIES?e.name:e.type===jt.OP?e.owningSeries:null:null}function Gcr(e){let t=null;if(e)e.type===jt.SERIES?t=e:e.parentNode&&e.parentNode.type===jt.SERIES&&(t=e.parentNode);else return null;return t}function tct(e){return ole(Gcr(e)!==null?is.GROUP:is.UNGROUP)}function Wcr(e,t,r){var c;let n=t.displayName,i=t.node.type===jt.META&&!t.expanded,o=Pn(e,"text",ye.Node.LABEL),a=o.node();(c=a.parentNode)==null||c.appendChild(a),o.attr("dy",".35em").attr("text-anchor","middle");let s=8;switch(t.node.type){case jt.META:s=t.expanded?Z4.Node.EXPANDED_LABEL:Z4.Node.SERIES_LABEL;break;case jt.OP:s=Z4.Node.OP_LABEL;break}if(i){n.length>r.maxMetanodeLabelLength&&(n=n.substr(0,r.maxMetanodeLabelLength-2)+"\u2026");let u=Ycr(r);o.attr("font-size",u(n.length)+"px"),s=u(n.length)}let l=o.text(n);return Fle(l,t.node.type,s,t),o}function Fle(e,t,r,n){let i=e.node(),o=i.textContent,a=null;switch(t){case jt.META:n&&!n.expanded&&(a=Tr.nodeSize.meta.maxLabelWidth);break;case jt.OP:a=Tr.nodeSize.op.maxLabelWidth;break;case-1:a=Tr.annotations.maxLabelWidth;break;default:break}if(a!==null)return i.textContent=$se(i.textContent,r,a),e.append("title").text(o)}var Klt=null;function Ycr(e){return Klt||(Klt=zn().domain([e.maxMetanodeLabelLengthLargeFont,e.maxMetanodeLabelLength]).range([e.maxMetanodeLabelLengthFontSize,e.minMetanodeLabelLengthFontSize]).clamp(!0)),Klt}function pP(e,t,r,n){Pl(e,"text",ye.Node.LABEL).transition().attr("x",t).attr("y",r+n)}function Ble(e,t,r){let n=Pn(e,"g",r);switch(t.node.type){case jt.OP:let i=t.node;if(Vi.isNumber(i.functionInputIndex)||Vi.isNumber(i.functionOutputIndex)){Pn(n,"polygon",ye.Node.COLOR_TARGET);break}Pn(n,"ellipse",ye.Node.COLOR_TARGET);break;case jt.SERIES:let o="annotation",a=t;a.coreGraph&&(o=a.node.hasNonControlEdges?"vertical":"horizontal");let s=[ye.Node.COLOR_TARGET];a.isFadedOut&&s.push("faded-ellipse"),Pn(n,"use",s).attr("xlink:href","#op-series-"+o+"-stamp"),Pn(n,"rect",ye.Node.COLOR_TARGET).attr("rx",t.radius).attr("ry",t.radius);break;case jt.BRIDGE:Pn(n,"rect",ye.Node.COLOR_TARGET).attr("rx",t.radius).attr("ry",t.radius);break;case jt.META:Pn(n,"rect",ye.Node.COLOR_TARGET).attr("rx",t.radius).attr("ry",t.radius);break;default:throw Error("Unrecognized node type: "+t.node.type)}return n}function Hle(e){switch(e.node.type){case jt.OP:return ye.OPNODE;case jt.META:return ye.METANODE;case jt.SERIES:return ye.SERIESNODE;case jt.BRIDGE:return ye.BRIDGENODE;case jt.ELLIPSIS:return ye.ELLIPSISNODE}throw Error("Unrecognized node type: "+e.node.type)}function jcr(e,t){let r=Pl(e,"g",ye.Node.SHAPE),n=v0(t);switch(t.node.type){case jt.OP:{let i=t.node;if(Vi.isNumber(i.functionInputIndex)||Vi.isNumber(i.functionOutputIndex)){let o=Pl(r,"polygon");Tle(o,t.x,t.y,t.coreBox.width,t.coreBox.height)}else{let o=Pl(r,"ellipse");MH(o,n,t.y,t.coreBox.width,t.coreBox.height)}pP(e,n,t.y,t.labelOffset);break}case jt.META:{let i=r.selectAll("rect");t.expanded?(zd(i,t.x,t.y,t.width,t.height),Nle(e,t),pP(e,n,t.y,-t.height/2+t.labelHeight/2)):(zd(i,n,t.y,t.coreBox.width,t.coreBox.height),pP(e,n,t.y,0));break}case jt.SERIES:{let i=Pl(r,"use");t.expanded?(zd(i,t.x,t.y,t.width,t.height),Nle(e,t),pP(e,n,t.y,-t.height/2+t.labelHeight/2)):(zd(i,n,t.y,t.coreBox.width,t.coreBox.height),pP(e,n,t.y,t.labelOffset));break}case jt.BRIDGE:{let i=Pl(r,"rect");zd(i,t.x,t.y,t.width,t.height);break}default:throw Error("Unrecognized node type: "+t.node.type)}}function Zlt(e,t,r){let n=jse(e);if(!r)return`url(#${n})`;let i=Ht(r),o=i.select("defs#_graph-gradients");o.empty()&&(o=i.append("defs").attr("id","_graph-gradients"));let a=o.select("linearGradient#"+n);if(a.empty()){a=o.append("linearGradient").attr("id",e),a.selectAll("*").remove();let s=0;Vi.each(t,l=>{let c=l.color;a.append("stop").attr("offset",s).attr("stop-color",c),a.append("stop").attr("offset",s+l.proportion).attr("stop-color",c),s+=l.proportion})}return`url(#${n})`}function IH(e){Ht(e).select("defs#_graph-gradients").remove()}function LH(e,t,r,n,i){let o=Ku;switch(e=e||(()=>0),t){case Gn.NONE:case Gn.STRUCTURE:if(r.node.type===jt.META){let a=r.node.templateId;return t===Gn.STRUCTURE&&a!==null?o.STRUCTURE_PALETTE(e(a),n):o.UNKNOWN}else return r.node.type===jt.SERIES?n?o.EXPANDED_COLOR:"white":r.node.type===jt.BRIDGE?r.structural?"#f0e":r.node.inbound?"#0ef":"#fe0":Vi.isNumber(r.node.functionInputIndex)?"#795548":Vi.isNumber(r.node.functionOutputIndex)?"#009688":"white";case Gn.DEVICE:return r.deviceColors==null?o.UNKNOWN:n?o.EXPANDED_COLOR:Zlt("device-"+r.node.name,r.deviceColors,i);case Gn.XLA_CLUSTER:return r.xlaClusterColors==null?o.UNKNOWN:n?o.EXPANDED_COLOR:Zlt("xla-"+r.node.name,r.xlaClusterColors,i);case Gn.COMPUTE_TIME:return n?o.EXPANDED_COLOR:r.computeTimeColor||o.UNKNOWN;case Gn.MEMORY:return n?o.EXPANDED_COLOR:r.memoryColor||o.UNKNOWN;case Gn.OP_COMPATIBILITY:return r.compatibilityColors==null?o.UNKNOWN:n?o.EXPANDED_COLOR:Zlt("op-compat-"+r.node.name,r.compatibilityColors,i);default:throw new Error("Unknown case to color nodes by")}}function s3(e,t,r,n){n=n||ye.Node.SHAPE;let i=r.isNodeHighlighted(t.node.name),o=r.isNodeSelected(t.node.name),a=t.isInExtract||t.isOutExtract||t.isLibraryFunction,s=t.expanded&&n!==ye.Annotation.NODE,l=t.isFadedOut;e.classed("highlighted",i),e.classed("selected",o),e.classed("extract",a),e.classed("expanded",s),e.classed("faded",l);let c=e.select("."+n+" ."+ye.Node.COLOR_TARGET),u=LH(r.templateIndex,r.colorBy,t,s,r.getGraphSvgRoot());c.style("fill",u),c.style("stroke",o?null:ect(u))}function ect(e){return e.substring(0,3)==="url"?Ku.GRADIENT_OUTLINE:cu(e).darker().toString()}function Vle(e,t,r,n){let i=Ht(e);if(i.selectAll(".input-highlight").classed("input-highlight",!1),i.selectAll(".non-input").classed("non-input",!1),i.selectAll(".input-parent").classed("input-parent",!1),i.selectAll(".input-child").classed("input-child",!1),i.selectAll(".input-edge-highlight").classed("input-edge-highlight",!1),i.selectAll(".non-input-edge-highlight").classed("non-input-edge-highlight",!1),i.selectAll(".input-highlight-selected").classed("input-highlight-selected",!1),!t||!n||!r)return;let o=Ule(r,t),a={};Vi.each(o,function(c){a=qle(e,t,c,a)});let s=Object.keys(a),l=$cr(t,s);Kcr(e,l),i.selectAll("g.node:not(.selected):not(.input-highlight):not(.input-parent):not(.input-children)").classed("non-input",!0).each(function(c){let u=c.node.name;i.selectAll(`[data-name="${u}"]`).classed("non-input",!0)}),i.selectAll("g.edge:not(.input-edge-highlight)").classed("non-input-edge-highlight",!0)}function Ule(e,t){let r=[],n=t.getNodeByName(e);if(n instanceof _0)return[n].concat(n.inEmbeddings);let i=n.metagraph.nodes();return Vi.each(i,function(o){r=r.concat(Ule(o,t))}),r}function qle(e,t,r,n){if(n[r.name])return n;n[r.name]=!0;let i=r.inputs,o=Jlt(t,r);Ht(e).select(`.node[data-name="${o.name}"]`).classed("input-highlight",!0);let a={};Vi.each(i,function(u){let h=t.getNodeByName(u.name);if(h===void 0)return;if(h instanceof oP){let d=aP(h.name);h=t.getNodeByName(d)}let f=Jlt(t,h),p=a[f.name];p?p.opNodes.push(h):a[f.name]={visibleParent:f,opNodes:[h]}});let s={},l=[o];s[o.name]={traced:!1,index:0,connectionEndpoints:[]};let c=o;for(let u=1;c.name!==qc;u++)c=c.parentNode,s[c.name]={traced:!1,index:u,connectionEndpoints:[]},l[u]=c;return Vi.forOwn(a,function(u,h){let f=u.visibleParent;Vi.each(u.opNodes,function(p){n=qle(e,t,p,n)}),f.name!==o.name&&Xcr(e,f,s,l)}),n}function Xcr(e,t,r,n){let i=t,o=t,a=[];for(;!r[i.name];)o.name!==i.name&&a.push([o,i]),o=i,i=i.parentNode;let s=r[i.name].index,l=n[Math.max(s-1,0)].name,c=l,u=o.name,h=o.name,f=Ht(e);f.selectAll(`[data-edge="${h}--${l}"]`).classed("input-edge-highlight",!0),Vi.each(a,function(p){let d=p[0],g=p[1],_=`[data-edge="${d.name}--${c}~~${g.name}~~OUT"]`;f.selectAll(_).classed("input-edge-highlight",!0)});for(let p=1;p<s;p++){let d=n[p-1],g=n[p],_=`[data-edge="${u}~~${g.name}~~IN--${d.name}"]`;f.selectAll(_).classed("input-edge-highlight",!0)}}function $cr(e,t){let r={};return Vi.each(t,function(n){let i=e.getNodeByName(n),o=Jlt(e,i);r[o.name]=o}),r}function Kcr(e,t){Vi.forOwn(t,function(r){let n=r;for(;n.name!==qc;){let i=Ht(e).select(`.node[data-name="${n.name}"]`);i.nodes().length&&!i.classed("input-highlight")&&!i.classed("selected")&&!i.classed("op")&&i.classed("input-parent",!0),n=n.parentNode}})}function Jlt(e,t){let r=!1,n=t;for(;!r;)if(t=n,n=t.parentNode,n===void 0)r=!0;else{let i=e.getRenderNodeByName(n.name);i&&(i.expanded||n instanceof _0)&&(r=!0)}return t}function Ole(e,t,r,n){let i=e.selectAll(function(){return this.childNodes}).data(t.list,o=>o.node.name);return i.enter().append("g").attr("data-name",o=>o.node.name).each(function(o){let a=Ht(this);n.addAnnotationGroup(o,r,a);let s=ye.Annotation.EDGE,l=o.renderMetaedgeInfo&&o.renderMetaedgeInfo.metaedge;l&&!l.numRegularEdges&&(s+=" "+ye.Annotation.CONTROL_EDGE),l&&l.numRefEdges&&(s+=" "+ye.Edge.REF_LINE),$lt(a,o,n,s),o.annotationType!==_i.ELLIPSIS?(Qcr(a,o),Jcr(a,o)):Gle(a,o.node.name,o,ye.Annotation.ELLIPSIS)}).merge(i).attr("class",o=>ye.Annotation.GROUP+" "+Zcr(o.annotationType)+" "+Hle(o)).each(function(o){let a=Ht(this);eur(a,r,o,n),o.annotationType!==_i.ELLIPSIS&&tur(a,r,o,n)}),i.exit().each(function(o){n.removeAnnotationGroup(o,r)}).remove(),i}function Zcr(e){return(_i[e]||"").toLowerCase()||null}function Jcr(e,t){if(t.annotationType===_i.SUMMARY)Pn(e,"use").attr("class","summary").attr("xlink:href","#summary-icon").attr("cursor","pointer");else{let r=Ble(e,t,ye.Annotation.NODE);Pn(r,"title").text(t.node.name)}}function Qcr(e,t){let r=t.node.name.split("/"),n=r[r.length-1];return Gle(e,n,t,null)}function Gle(e,t,r,n){let i=ye.Annotation.LABEL;n&&(i+=" "+n);let o=e.append("text").attr("class",i).attr("dy",".35em").attr("text-anchor",r.isIn?"end":"start").text(t);return Fle(o,-1,Z4.Annotation.LABEL)}function tur(e,t,r,n){e.on("mouseover",i=>{n.fire("annotation-highlight",{name:i.node.name,hostName:t.node.name})}).on("mouseout",i=>{n.fire("annotation-unhighlight",{name:i.node.name,hostName:t.node.name})}).on("click",i=>{qt.stopPropagation(),n.fire("annotation-select",{name:i.node.name,hostName:t.node.name})}),r.annotationType!==_i.SUMMARY&&r.annotationType!==_i.CONSTANT&&e.on("contextmenu",Ylt(n,zle(r.node,n)))}function eur(e,t,r,n){let i=v0(t);r.renderNodeInfo&&r.annotationType!==_i.ELLIPSIS&&s3(e,r.renderNodeInfo,n,ye.Annotation.NODE),r.annotationType===_i.SUMMARY&&(r.width+=10),e.select("text."+ye.Annotation.LABEL).transition().attr("x",i+r.dx+(r.isIn?-1:1)*(r.width/2+r.labelOffset)).attr("y",t.y+r.dy),e.select("use.summary").transition().attr("x",i+r.dx-3).attr("y",t.y+r.dy-6),MH(e.select("."+ye.Annotation.NODE+" ellipse"),i+r.dx,t.y+r.dy,r.width,r.height),zd(e.select("."+ye.Annotation.NODE+" rect"),i+r.dx,t.y+r.dy,r.width,r.height),zd(e.select("."+ye.Annotation.NODE+" use"),i+r.dx,t.y+r.dy,r.width,r.height),e.select("path."+ye.Annotation.EDGE).transition().attr("d",o=>{let a=o.points.map(s=>({x:s.dx+i,y:s.dy+t.y}));return TH(a)})}function rct(e,t,r,n){n=n||ye.Scene.GROUP;let i=m0(e,"g",n).empty(),o=Pn(e,"g",n),a=Pn(o,"g",ye.Scene.CORE),s=Vi.reduce(t.coreGraph.nodes(),(l,c)=>{let u=t.coreGraph.node(c);return u.excluded||l.push(u),l},Array());if(t.node.type===jt.SERIES&&s.reverse(),kle(a,t.coreGraph,r),AH(a,s,r),t.isolatedInExtract.length>0){let l=Pn(o,"g",ye.Scene.INEXTRACT);AH(l,t.isolatedInExtract,r)}else m0(o,"g",ye.Scene.INEXTRACT).remove();if(t.isolatedOutExtract.length>0){let l=Pn(o,"g",ye.Scene.OUTEXTRACT);AH(l,t.isolatedOutExtract,r)}else m0(o,"g",ye.Scene.OUTEXTRACT).remove();if(t.libraryFunctionsExtract.length>0){let l=Pn(o,"g",ye.Scene.FUNCTION_LIBRARY);AH(l,t.libraryFunctionsExtract,r)}else m0(o,"g",ye.Scene.FUNCTION_LIBRARY).remove();return Mle(o,t),i&&o.attr("opacity",0).transition().attr("opacity",1),o}var rur=.8,kH=class{constructor(t,r,n,i,o,a){this.svg=t,this.labelPadding=a,this.zoomG=r,this.mainZoom=n,this.maxWandH=o;let s=Ht(i.shadowRoot),l=s.select("svg"),c=l.select("rect"),u=f=>{this.viewpointCoord.x=qt.x,this.viewpointCoord.y=qt.y,this.updateViewpoint()};this.viewpointCoord={x:0,y:0};let h=pb().subject(Object).on("drag",u);c.datum(this.viewpointCoord).call(h),l.on("click",()=>{if(qt.defaultPrevented)return;let f=Number(c.attr("width")),p=Number(c.attr("height")),d=zo(l.node());this.viewpointCoord.x=d[0]-f/2,this.viewpointCoord.y=d[1]-p/2,this.updateViewpoint()}),this.viewpoint=c.node(),this.minimapSvg=l.node(),this.minimap=i,this.canvas=s.select("canvas.first").node(),this.canvasBuffer=s.select("canvas.second").node(),this.downloadCanvas=s.select("canvas.download").node(),Ht(this.downloadCanvas).style("display","none"),this.update()}updateViewpoint(){Ht(this.viewpoint).attr("x",this.viewpointCoord.x).attr("y",this.viewpointCoord.y);let t=-this.viewpointCoord.x*this.scaleMain/this.scaleMinimap,r=-this.viewpointCoord.y*this.scaleMain/this.scaleMinimap;Ht(this.svg).call(this.mainZoom.transform,Xh.translate(t,r).scale(this.scaleMain))}getImageBlob(){return new Promise(t=>{this.downloadCanvas.toBlob(r=>{t(r)},"image/png")})}update(){let t=null;try{if(t=this.zoomG.getBBox(),t.width===0)return}catch(p){return}let r=Ht(this.svg),n="",i=this.svg,a=(i.getRootNode?i.getRootNode():this.svg.parentNode).styleSheets;for(let p=0;p<a.length;p++)try{let d=a[p].cssRules||a[p].rules;if(d==null)continue;for(let g=0;g<d.length;g++)n+=d[g].cssText.replace(/ ?tf-[\w-]+ ?/g,"")+`
`}catch(d){if(d.name!=="SecurityError")throw d}let s=r.append("style");s.text(n);let l=Ht(this.zoomG),c=l.attr("transform");l.attr("transform",null),t.height+=t.y,t.width+=t.x,t.height+=this.labelPadding*2,t.width+=this.labelPadding*2,r.attr("width",t.width).attr("height",t.height),this.scaleMinimap=this.maxWandH/Math.max(t.width,t.height),this.minimapSize={width:t.width*this.scaleMinimap,height:t.height*this.scaleMinimap},Ht(this.minimapSvg).attr(this.minimapSize),Ht(this.canvasBuffer).attr(this.minimapSize);let u=Ht(this.downloadCanvas);u.style("width",t.width),u.style("height",t.height),u.attr("width",3*t.width),u.attr("height",3*t.height),this.translate!=null&&this.zoom!=null&&requestAnimationFrame(()=>this.zoom());let h=new XMLSerializer().serializeToString(this.svg);s.remove(),r.attr("width",null).attr("height",null),l.attr("transform",c);let f=new Image;f.onload=()=>{let p=this.canvasBuffer.getContext("2d");p==null||p.clearRect(0,0,this.canvasBuffer.width,this.canvasBuffer.height),p==null||p.drawImage(f,0,0,this.minimapSize.width,this.minimapSize.height),requestAnimationFrame(()=>{Ht(this.canvasBuffer).style("display",null),Ht(this.canvas).style("display","none"),[this.canvas,this.canvasBuffer]=[this.canvasBuffer,this.canvas]});let d=this.downloadCanvas.getContext("2d");d==null||d.clearRect(0,0,this.downloadCanvas.width,this.downloadCanvas.height),d==null||d.drawImage(f,0,0,this.downloadCanvas.width,this.downloadCanvas.height)},f.onerror=()=>{let p=new Blob([h],{type:"image/svg+xml;charset=utf-8"});f.src=URL.createObjectURL(p)},f.src="data:image/svg+xml;charset=utf-8,"+encodeURIComponent(h)}zoom(t){if(this.scaleMinimap==null)return;t&&(this.translate=[t.x,t.y],this.scaleMain=t.k);let r=this.svg.getBoundingClientRect(),n=Ht(this.viewpoint);this.viewpointCoord.x=-this.translate[0]*this.scaleMinimap/this.scaleMain,this.viewpointCoord.y=-this.translate[1]*this.scaleMinimap/this.scaleMain;let i=r.width*this.scaleMinimap/this.scaleMain,o=r.height*this.scaleMinimap/this.scaleMain;n.attr("x",this.viewpointCoord.x).attr("y",this.viewpointCoord.y).attr("width",i).attr("height",o);let a=this.minimapSize.width,s=this.minimapSize.height,l=this.viewpointCoord.x,c=this.viewpointCoord.y,u=Math.min(Math.max(0,l+i),a)-Math.min(Math.max(0,l),a),h=Math.min(Math.max(0,c+o),s)-Math.min(Math.max(0,c),s);u*h/(a*s)<rur?this.minimap.classList.remove("hidden"):this.minimap.classList.add("hidden")}};var ict=class extends mt{init(t,r,n,i,o){return new kH(t,r,n,this,i,o)}};ict.template=Q`
    <style>
      :host {
        background-color: white;
        transition: opacity 0.3s linear;
        pointer-events: auto;
      }

      :host(.hidden) {
        opacity: 0;
        pointer-events: none;
      }

      canvas {
        border: 1px solid #999;
      }

      rect {
        fill: white;
        stroke: #111111;
        stroke-width: 1px;
        fill-opacity: 0;
        filter: url(#minimapDropShadow);
        cursor: move;
      }

      svg {
        position: absolute;
      }
    </style>
    <svg>
      <defs>
        <filter
          id="minimapDropShadow"
          x="-20%"
          y="-20%"
          width="150%"
          height="150%"
        >
          <feOffset result="offOut" in="SourceGraphic" dx="1" dy="1"></feOffset>
          <feColorMatrix
            result="matrixOut"
            in="offOut"
            type="matrix"
            values="0.1 0 0 0 0 0 0.1 0 0 0 0 0 0.1 0 0 0 0 0 0.5 0"
          ></feColorMatrix>
          <feGaussianBlur
            result="blurOut"
            in="matrixOut"
            stdDeviation="2"
          ></feGaussianBlur>
          <feBlend in="SourceGraphic" in2="blurOut" mode="normal"></feBlend>
        </filter>
      </defs>
      <rect></rect>
    </svg>
    <canvas class="first"></canvas>
    <!-- Additional canvas to use as buffer to avoid flickering between updates -->
    <canvas class="second"></canvas>
    <canvas class="download"></canvas>
  `;ict=E([yt("tf-graph-minimap")],ict);var Wle=Q`
  <style>
    :host(.dark-mode) {
      filter: invert(1);
    }

    :host {
      display: flex;
      font-size: 20px;
      height: 100%;
      width: 100%;
    }

    #svg {
      flex: 1;
      font-family: Roboto, sans-serif;
      height: 100%;
      overflow: hidden;
      width: 100%;
    }

    #hidden {
      position: fixed;
      top: 0px;
      visibility: hidden;
    }

    text {
      user-select: none;
    }

    /* --- Node and annotation-node for Metanode --- */

    .meta > .nodeshape > rect,
    .meta > .annotation-node > rect {
      cursor: pointer;
      fill: hsl(0, 0%, 70%);
    }
    .node.meta.highlighted > .nodeshape > rect,
    .node.meta.highlighted > .annotation-node > rect {
      stroke-width: 2;
    }
    .annotation.meta.highlighted > .nodeshape > rect,
    .annotation.meta.highlighted > .annotation-node > rect {
      stroke-width: 1;
    }
    .meta.selected > .nodeshape > rect,
    .meta.selected > .annotation-node > rect {
      stroke: red;
      stroke-width: 2;
    }
    .node.meta.selected.expanded > .nodeshape > rect,
    .node.meta.selected.expanded > .annotation-node > rect {
      stroke: red;
      stroke-width: 3;
    }
    .annotation.meta.selected > .nodeshape > rect,
    .annotation.meta.selected > .annotation-node > rect {
      stroke: red;
      stroke-width: 2;
    }
    .node.meta.selected.expanded.highlighted > .nodeshape > rect,
    .node.meta.selected.expanded.highlighted > .annotation-node > rect {
      stroke: red;
      stroke-width: 4;
    }

    .faded,
    .faded rect,
    .faded ellipse,
    .faded path,
    .faded use,
    #rectHatch line,
    #ellipseHatch line {
      color: #e0d4b3 !important;
      fill: white;
      stroke: #e0d4b3 !important;
    }

    .faded path {
      stroke-width: 1px !important;
    }

    .faded rect {
      fill: url(#rectHatch) !important;
    }

    .faded ellipse,
    .faded use {
      fill: url(#ellipseHatch) !important;
    }

    .faded text {
      opacity: 0;
    }

    /* Rules used for input-tracing. */
    .input-highlight > * > rect,
    .input-highlight > * > ellipse,
    .input-highlight > * > use {
      fill: white;
      stroke: #ff9800 !important;
    }

    /*  - Faded non-input styling */
    .non-input > * > rect,
.non-input > * > ellipse,
.non-input > * > use,
/* For Const nodes. */
.non-input > * > .constant:not([class*="input-highlight"]) >
  .annotation-node > ellipse,
/* For styling of annotation nodes of non-input nodes. */
.non-input > g > .annotation > .annotation-node > rect {
      stroke: #e0d4b3 !important;
      stroke-width: inherit;
      stroke-dasharray: inherit;
    }

    .non-input path {
      visibility: hidden;
    }

    .non-input > .nodeshape > rect,
.non-input > .annotation-node > rect,
/* For styling of annotation nodes of non-input nodes. */
.non-input > g > .annotation > .annotation-node > rect {
      fill: url(#rectHatch) !important;
    }

    .non-input ellipse,
    .non-input use {
      fill: url(#ellipseHatch) !important;
    }

    .non-input > text {
      opacity: 0;
    }

    .non-input .annotation > .annotation-edge {
      marker-end: url(#annotation-arrowhead-faded);
    }

    .non-input .annotation > .annotation-edge.refline {
      marker-start: url(#ref-annotation-arrowhead-faded);
    }

    /* Input edges. */
    .input-edge-highlight > text {
      fill: black !important;
    }
    .input-highlight > .in-annotations > .annotation > .annotation-edge,
    .input-highlight-selected
      > .in-annotations
      > .annotation
      > .annotation-edge {
      stroke: #999 !important;
    }

    /* Non-input edges. */
    .non-input-edge-highlight,
.non-input > g > .annotation > path,
/* Annotation styles (label and edges respectively). */
.non-input > g >
.annotation:not(.input-highlight):not(.input-highlight-selected) >
.annotation-label
/*.annotation-edge*/ {
      visibility: hidden;
    }

    /* --- Op Node --- */

    .op > .nodeshape > .nodecolortarget,
    .op > .annotation-node > .nodecolortarget {
      cursor: pointer;
      fill: #fff;
      stroke: #ccc;
    }

    .op.selected > .nodeshape > .nodecolortarget,
    .op.selected > .annotation-node > .nodecolortarget {
      stroke: red;
      stroke-width: 2;
    }

    .op.highlighted > .nodeshape > .nodecolortarget,
    .op.highlighted > .annotation-node > .nodecolortarget {
      stroke-width: 2;
    }

    /* --- Series Node --- */

    /* By default, don't show the series background <rect>. */
    .series > .nodeshape > rect {
      fill: hsl(0, 0%, 70%);
      fill-opacity: 0;
      stroke-dasharray: 5, 5;
      stroke-opacity: 0;
      cursor: pointer;
    }

    /* Once expanded, show the series background <rect> and hide the <use>. */
    .series.expanded > .nodeshape > rect {
      fill-opacity: 0.15;
      stroke: hsl(0, 0%, 70%);
      stroke-opacity: 1;
    }
    .series.expanded > .nodeshape > use {
      visibility: hidden;
    }

    /**
 * TODO: Simplify this by applying a stable class name to all <g>
 * elements that currently have either the nodeshape or annotation-node classes.
 */
    .series > .nodeshape > use,
    .series > .annotation-node > use {
      stroke: #ccc;
    }
    .series.highlighted > .nodeshape > use,
    .series.highlighted > .annotation-node > use {
      stroke-width: 2;
    }
    .series.selected > .nodeshape > use,
    .series.selected > .annotation-node > use {
      stroke: red;
      stroke-width: 2;
    }

    .series.selected > .nodeshape > rect {
      stroke: red;
      stroke-width: 2;
    }

    .annotation.series.selected > .annotation-node > use {
      stroke: red;
      stroke-width: 2;
    }

    /* --- Bridge Node --- */
    .bridge > .nodeshape > rect {
      stroke: #f0f;
      opacity: 0.2;
      display: none;
    }

    /* --- Structural Elements --- */
    .edge > path.edgeline.structural {
      stroke: #f0f;
      opacity: 0.2;
      display: none;
    }

    /* Reference Edge */
    .edge > path.edgeline.referenceedge {
      stroke: #ffb74d;
      opacity: 1;
    }

    /* --- Series Nodes --- */

    /* Hide the rect for a series' annotation. */
    .series > .annotation-node > rect {
      display: none;
    }

    /* --- Node label --- */

    .node {
      /* Provide a hint to browsers to avoid using their static rasterization
      at initial scale, which looks very pixelated on Chromium when zoomed in.
      Note that we intentionally do *not* use 'will-change: transform' and
      'translateZ(0) here, which introduce blurriness on Firefox.
      See https://github.com/tensorflow/tensorboard/issues/4744 */
      transform: translateZ(1px);
    }

    .node > text.nodelabel {
      cursor: pointer;
      fill: #444;
    }

    .meta.expanded > text.nodelabel {
      font-size: 9px;
    }

    .series > text.nodelabel {
      font-size: 8px;
    }

    .op > text.nodelabel {
      font-size: 6px;
    }

    .bridge > text.nodelabel {
      display: none;
    }

    .node.meta.expanded > text.nodelabel {
      cursor: normal;
    }

    .annotation.meta.highlighted > text.annotation-label {
      fill: #50a3f7;
    }

    .annotation.meta.selected > text.annotation-label {
      fill: #4285f4;
    }

    /* --- Annotation --- */

    /* only applied for annotations that are not summary or constant.
(.summary, .constant gets overridden below) */
    .annotation > .annotation-node > * {
      stroke-width: 0.5;
      stroke-dasharray: 1, 1;
    }

    .annotation.summary > .annotation-node > *,
    .annotation.constant > .annotation-node > * {
      stroke-width: 1;
      stroke-dasharray: none;
    }

    .annotation > .annotation-edge {
      fill: none;
      stroke: #aaa;
      stroke-width: 0.5;
      marker-end: url(#annotation-arrowhead);
    }

    .faded .annotation > .annotation-edge {
      marker-end: url(#annotation-arrowhead-faded);
    }

    .annotation > .annotation-edge.refline {
      marker-start: url(#ref-annotation-arrowhead);
    }

    .faded .annotation > .annotation-edge.refline {
      marker-start: url(#ref-annotation-arrowhead-faded);
    }

    .annotation > .annotation-control-edge {
      stroke-dasharray: 1, 1;
    }

    #annotation-arrowhead {
      fill: #aaa;
    }

    #annotation-arrowhead-faded {
      fill: #e0d4b3;
    }

    #ref-annotation-arrowhead {
      fill: #aaa;
    }

    #ref-annotation-arrowhead-faded {
      fill: #e0d4b3;
    }

    .annotation > .annotation-label {
      font-size: 5px;
      cursor: pointer;
    }
    .annotation > .annotation-label.annotation-ellipsis {
      cursor: default;
    }

    /* Hide annotations on expanded meta nodes since they're redundant. */
    .expanded > .in-annotations,
    .expanded > .out-annotations {
      display: none;
    }

    /* --- Annotation: Constant --- */

    .constant > .annotation-node > ellipse {
      cursor: pointer;
      fill: white;
      stroke: #848484;
    }

    .constant.selected > .annotation-node > ellipse {
      fill: white;
      stroke: red;
    }

    .constant.highlighted > .annotation-node > ellipse {
      stroke-width: 1.5;
    }

    /* --- Annotation: Summary --- */

    .summary > .annotation-node > ellipse {
      cursor: pointer;
      fill: #db4437;
      stroke: #db4437;
    }

    .summary.selected > .annotation-node > ellipse {
      fill: #a52714;
      stroke: #a52714;
    }

    .summary.highlighted > .annotation-node > ellipse {
      stroke-width: 1.5;
    }

    /* --- Edge --- */

    .edge > path.edgeline {
      fill: none;
      stroke: #bbb;
      stroke-linecap: round;
      stroke-width: 0.75;
    }

    .edge .selectableedge {
      cursor: pointer;
    }

    .selectededge > path.edgeline {
      cursor: default;
      stroke: #f00;
    }

    .edge.selectededge text {
      fill: #000;
    }

    /* Labels showing tensor shapes on edges */
    .edge > text {
      font-size: 3.5px;
      fill: #666;
    }

    .dataflow-arrowhead {
      fill: #bbb;
    }

    .reference-arrowhead {
      fill: #ffb74d;
    }

    .selected-arrowhead {
      fill: #f00;
    }

    .edge .control-dep {
      stroke-dasharray: 2, 2;
    }

    /* --- Group node expand/collapse button --- */

    /* Hides expand/collapse buttons when a node isn't expanded or highlighted. Using
   incredibly small opacity so that the bounding box of the <g> parent still takes
   this container into account even when it isn't visible */
    .node:not(.highlighted):not(.expanded) > .nodeshape > .buttoncontainer {
      opacity: 0.01;
    }
    .node.highlighted > .nodeshape > .buttoncontainer {
      cursor: pointer;
    }
    .buttoncircle {
      fill: #e7811d;
    }
    .buttoncircle:hover {
      fill: #b96717;
    }
    .expandbutton,
    .collapsebutton {
      stroke: white;
    }
    /* Do not let the path elements in the button take pointer focus */
    .node > .nodeshape > .buttoncontainer > .expandbutton,
    .node > .nodeshape > .buttoncontainer > .collapsebutton {
      pointer-events: none;
    }
    /* Only show the expand button when a node is collapsed and only show the
   collapse button when a node is expanded. */
    .node.expanded > .nodeshape > .buttoncontainer > .expandbutton {
      display: none;
    }
    .node:not(.expanded) > .nodeshape > .buttoncontainer > .collapsebutton {
      display: none;
    }

    .health-pill-stats {
      font-size: 4px;
      text-anchor: middle;
    }

    .health-pill rect {
      filter: url(#health-pill-shadow);
      rx: 3;
      ry: 3;
    }

    .titleContainer {
      position: relative;
      top: 20px;
    }

    .title,
    .auxTitle,
    .functionLibraryTitle {
      position: absolute;
    }

    #minimap {
      position: absolute;
      right: 20px;
      bottom: 20px;
    }

    .context-menu {
      position: absolute;
      display: none;
      background-color: #e2e2e2;
      border-radius: 2px;
      font-size: 14px;
      min-width: 150px;
      border: 1px solid #d4d4d4;
    }

    .context-menu ul {
      list-style-type: none;
      margin: 0;
      padding: 0;
      cursor: default;
    }

    .context-menu ul li {
      padding: 4px 16px;
    }

    .context-menu ul li:hover {
      background-color: #f3913e;
      color: white;
    }
  </style>
  <div class="titleContainer">
    <div id="title" class="title">Main Graph</div>
    <div id="auxTitle" class="auxTitle">Auxiliary Nodes</div>
    <div id="functionLibraryTitle" class="functionLibraryTitle">Functions</div>
  </div>
  <svg id="svg">
    <defs>
      <!-- Arrow heads for reference edge paths of different predefined sizes per color. -->
      <path
        id="reference-arrowhead-path"
        d="M 0,0 L 10,5 L 0,10 C 3,7 3,3 0,0"
      ></path>
      <marker
        class="reference-arrowhead"
        id="reference-arrowhead-small"
        viewBox="0 0 10 10"
        markerWidth="5"
        markerHeight="5"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#reference-arrowhead-path"></use>
      </marker>
      <marker
        class="reference-arrowhead"
        id="reference-arrowhead-medium"
        viewBox="0 0 10 10"
        markerWidth="13"
        markerHeight="13"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#reference-arrowhead-path"></use>
      </marker>
      <marker
        class="reference-arrowhead"
        id="reference-arrowhead-large"
        viewBox="0 0 10 10"
        markerWidth="16"
        markerHeight="16"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#reference-arrowhead-path"></use>
      </marker>
      <marker
        class="reference-arrowhead"
        id="reference-arrowhead-xlarge"
        viewBox="0 0 10 10"
        markerWidth="20"
        markerHeight="20"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#reference-arrowhead-path"></use>
      </marker>

      <!-- Arrow heads for dataflow edge paths of different predefined sizes per color. -->
      <path
        id="dataflow-arrowhead-path"
        d="M 0,0 L 10,5 L 0,10 C 3,7 3,3 0,0"
      ></path>
      <marker
        class="dataflow-arrowhead"
        id="dataflow-arrowhead-small"
        viewBox="0 0 10 10"
        markerWidth="5"
        markerHeight="5"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#dataflow-arrowhead-path"></use>
      </marker>
      <marker
        class="dataflow-arrowhead"
        id="dataflow-arrowhead-medium"
        viewBox="0 0 10 10"
        markerWidth="13"
        markerHeight="13"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#dataflow-arrowhead-path"></use>
      </marker>
      <marker
        class="dataflow-arrowhead"
        id="dataflow-arrowhead-large"
        viewBox="0 0 10 10"
        markerWidth="16"
        markerHeight="16"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#dataflow-arrowhead-path"></use>
      </marker>
      <marker
        class="dataflow-arrowhead"
        id="dataflow-arrowhead-xlarge"
        viewBox="0 0 10 10"
        markerWidth="20"
        markerHeight="20"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#dataflow-arrowhead-path"></use>
      </marker>

      <!-- Arrow head for annotation edge paths. -->
      <marker
        id="annotation-arrowhead"
        markerWidth="5"
        markerHeight="5"
        refX="5"
        refY="2.5"
        orient="auto"
      >
        <path d="M 0,0 L 5,2.5 L 0,5 L 0,0"></path>
      </marker>
      <marker
        id="annotation-arrowhead-faded"
        markerWidth="5"
        markerHeight="5"
        refX="5"
        refY="2.5"
        orient="auto"
      >
        <path d="M 0,0 L 5,2.5 L 0,5 L 0,0"></path>
      </marker>
      <marker
        id="ref-annotation-arrowhead"
        markerWidth="5"
        markerHeight="5"
        refX="0"
        refY="2.5"
        orient="auto"
      >
        <path d="M 5,0 L 0,2.5 L 5,5 L 5,0"></path>
      </marker>
      <marker
        id="ref-annotation-arrowhead-faded"
        markerWidth="5"
        markerHeight="5"
        refX="0"
        refY="2.5"
        orient="auto"
      >
        <path d="M 5,0 L 0,2.5 L 5,5 L 5,0"></path>
      </marker>
      <!-- Template for an Op node ellipse. -->
      <ellipse
        id="op-node-stamp"
        rx="7.5"
        ry="3"
        stroke="inherit"
        fill="inherit"
      ></ellipse>
      <!-- Template for an Op node annotation ellipse (smaller). -->
      <ellipse
        id="op-node-annotation-stamp"
        rx="5"
        ry="2"
        stroke="inherit"
        fill="inherit"
      ></ellipse>
      <!-- Vertically stacked series of Op nodes when unexpanded. -->
      <g id="op-series-vertical-stamp">
        <use xlink:href="#op-node-stamp" x="8" y="9"></use>
        <use xlink:href="#op-node-stamp" x="8" y="6"></use>
        <use xlink:href="#op-node-stamp" x="8" y="3"></use>
      </g>
      <!-- Horizontally stacked series of Op nodes when unexpanded. -->
      <g id="op-series-horizontal-stamp">
        <use xlink:href="#op-node-stamp" x="16" y="4"></use>
        <use xlink:href="#op-node-stamp" x="12" y="4"></use>
        <use xlink:href="#op-node-stamp" x="8" y="4"></use>
      </g>
      <!-- Horizontally stacked series of Op nodes for annotation. -->
      <g id="op-series-annotation-stamp">
        <use xlink:href="#op-node-annotation-stamp" x="9" y="2"></use>
        <use xlink:href="#op-node-annotation-stamp" x="7" y="2"></use>
        <use xlink:href="#op-node-annotation-stamp" x="5" y="2"></use>
      </g>
      <svg
        id="summary-icon"
        fill="#848484"
        height="12"
        viewBox="0 0 24 24"
        width="12"
      >
        <path
          d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z"
        ></path>
      </svg>

      <!-- Hatch patterns for faded out nodes. -->
      <pattern
        id="rectHatch"
        patternTransform="rotate(45 0 0)"
        width="5"
        height="5"
        patternUnits="userSpaceOnUse"
      >
        <line x1="0" y1="0" x2="0" y2="5" style="stroke-width: 1"></line>
      </pattern>
      <pattern
        id="ellipseHatch"
        patternTransform="rotate(45 0 0)"
        width="2"
        height="2"
        patternUnits="userSpaceOnUse"
      >
        <line x1="0" y1="0" x2="0" y2="2" style="stroke-width: 1"></line>
      </pattern>

      <!-- A shadow for health pills. -->
      <filter
        id="health-pill-shadow"
        x="-40%"
        y="-40%"
        width="180%"
        height="180%"
      >
        <feGaussianBlur in="SourceAlpha" stdDeviation="0.8"></feGaussianBlur>
        <feOffset dx="0" dy="0" result="offsetblur"></feOffset>
        <feFlood flood-color="#000000"></feFlood>
        <feComposite in2="offsetblur" operator="in"></feComposite>
        <feMerge>
          <feMergeNode></feMergeNode>
          <feMergeNode in="SourceGraphic"></feMergeNode>
        </feMerge>
      </filter>
    </defs>
    <!-- Make a large rectangle that fills the svg space so that
  zoom events get captured on safari -->
    <rect fill="white" width="10000" height="10000"></rect>
    <g id="root"></g>
  </svg>
  <tf-graph-minimap id="minimap"></tf-graph-minimap>
  <div id="contextMenu" class="context-menu"></div>
`;var Lr=class extends Gt(_o(mt)){constructor(){super(...arguments),this._zoomed=!1,this._zoomStartCoords=null,this._zoomTransform=null,this._maxZoomDistanceForClick=20,this._nodeGroupIndex={},this._annotationGroupIndex={},this._edgeGroupIndex={},this.maxMetanodeLabelLengthFontSize=9,this.minMetanodeLabelLengthFontSize=6,this.maxMetanodeLabelLengthLargeFont=11,this.maxMetanodeLabelLength=18}getNode(t){return this.renderHierarchy.getRenderNodeByName(t)}isNodeExpanded(t){return t.expanded}setNodeExpanded(t){this._build(this.renderHierarchy),this._updateLabels(!this._zoomed)}panToNode(t){Sle(t,this.$.svg,this.$.root,this._zoom)&&(this._zoomed=!0)}getGraphSvgRoot(){return this.$.svg}getContextMenu(){return this.$.contextMenu}_resetState(){this._nodeGroupIndex={},this._annotationGroupIndex={},this._edgeGroupIndex={},this._updateLabels(!1),Ht(this.$.svg).select("#root").selectAll("*").remove(),IH(this.$.svg)}_build(t){this.templateIndex=t.hierarchy.getTemplateIndex(),Rd("tf-graph-scene (layout):",function(){SH(t.root)}.bind(this),jr.RENDER_SCENE_LAYOUT),Rd("tf-graph-scene (build scene):",function(){rct(Ht(this.$.root),t.root,this),Ele(this.$.svg,this),this._updateInputTrace()}.bind(this),jr.RENDER_SCENE_BUILD_SCENE),setTimeout(function(){this._updateHealthPills(this.nodeNamesToHealthPills,this.healthPillStepIndex),this.minimap.update()}.bind(this),Tr.animation.duration)}ready(){super.ready(),this._zoom=tR().on("end",function(){if(this._zoomStartCoords){var t=Math.sqrt(Math.pow(this._zoomStartCoords.x-this._zoomTransform.x,2)+Math.pow(this._zoomStartCoords.y-this._zoomTransform.y,2));t<this._maxZoomDistanceForClick?this._fireEnableClick():setTimeout(this._fireEnableClick.bind(this),50)}this._zoomStartCoords=null}.bind(this)).on("zoom",function(){this._zoomTransform=qt.transform,this._zoomStartCoords||(this._zoomStartCoords=this._zoomTransform,this.fire("disable-click")),this._zoomed=!0,Ht(this.$.root).attr("transform",qt.transform),this.minimap.zoom(qt.transform)}.bind(this)),Ht(this.$.svg).call(this._zoom).on("dblclick.zoom",null),Ht(window).on("resize",function(){this.minimap.zoom()}.bind(this)),this.minimap=this.$.minimap.init(this.$.svg,this.$.root,this._zoom,Tr.minimap.size,Tr.subscene.meta.labelHeight)}attached(){this.set("_isAttached",!0)}detached(){this.set("_isAttached",!1)}_renderHierarchyChanged(){var t=this.renderHierarchy;this._hasRenderHierarchyBeenFitOnce=!1,this._resetState(),this._build(t)}_animateAndFit(){var t=this._isAttached;this._hasRenderHierarchyBeenFitOnce||!t||setTimeout(this.fit.bind(this),Tr.animation.duration)}_updateLabels(t){var r=this.$$(".title"),n=r.style,i=this.$$(".auxTitle"),o=i.style,a=this.$$(".functionLibraryTitle").style;let s=Ht(this.$.svg);var l=s.select("."+Hi.Scene.GROUP+">."+Hi.Scene.CORE).node();if(t&&l&&this.progress&&this.progress.value===100){var c=s.select("."+Hi.Scene.GROUP+">."+Hi.Scene.INEXTRACT).node()||s.select("."+Hi.Scene.GROUP+">."+Hi.Scene.OUTEXTRACT).node(),u=l.getCTM().e,h=c?c.getCTM().e:null;n.display="inline",n.left=u+"px",h!==null&&h!==u?(o.display="inline",h=Math.max(u+r.getBoundingClientRect().width,h),o.left=h+"px"):o.display="none";let f=s.select("."+Hi.Scene.GROUP+">."+Hi.Scene.FUNCTION_LIBRARY).node(),p=f?f.getCTM().e:null;p!==null&&p!==h?(a.display="inline",p=Math.max(h+i.getBoundingClientRect().width,p),a.left=p+"px"):a.display="none"}else n.display="none",o.display="none",a.display="none"}nodeColorsChanged(){this.renderHierarchy!=null&&(this.templateIndex=this.renderHierarchy.hierarchy.getTemplateIndex(),dP.each(this._nodeGroupIndex,(t,r)=>{this._updateNodeState(r)}),this.minimap.update())}fit(){this._hasRenderHierarchyBeenFitOnce=!0,wle(this.$.svg,this.$.root,this._zoom,function(){this._zoomed=!1}.bind(this))}getImageBlob(){return this.minimap.getImageBlob()}isNodeSelected(t){return t===this.selectedNode}isNodeHighlighted(t){return t===this.highlightedNode}addAnnotationGroup(t,r,n){var i=t.node.name;this._annotationGroupIndex[i]=this._annotationGroupIndex[i]||{},this._annotationGroupIndex[i][r.node.name]=n}getAnnotationGroupsIndex(t){return this._annotationGroupIndex[t]}removeAnnotationGroup(t,r){delete this._annotationGroupIndex[t.node.name][r.node.name]}addNodeGroup(t,r){this._nodeGroupIndex[t]=r}getNodeGroup(t){return this._nodeGroupIndex[t]}removeNodeGroup(t){delete this._nodeGroupIndex[t]}addEdgeGroup(t,r){this._edgeGroupIndex[t]=r}getEdgeGroup(t){return this._edgeGroupIndex[t]}_updateHealthPills(){var t=this.nodeNamesToHealthPills,r=this.healthPillStepIndex;Ale(this.$.svg,t,r)}_updateNodeState(t){var r=this.getNode(t),n=this.getNodeGroup(t);if(n&&s3(n,r,this),r.node.type===jt.META&&r.node.associatedFunction&&!r.isLibraryFunction){var i=Sa+r.node.associatedFunction,o=Ht("."+Hi.Scene.GROUP+">."+Hi.Scene.FUNCTION_LIBRARY+' g[data-name="'+i+'"]');s3(o,r,this)}var a=this.getAnnotationGroupsIndex(t);dP.each(a,(s,l)=>{s3(s,r,this,Hi.Annotation.NODE)})}_selectedNodeChanged(t,r){if(t!==r&&(r&&this._updateNodeState(r),!!t)){this.minimap.update();for(var n=this.renderHierarchy.hierarchy.node(t),i=[];n.parentNode!=null&&n.parentNode.name!=qc;)n=n.parentNode,i.push(n.name);var o;dP.forEachRight(i,a=>{this.renderHierarchy.buildSubhierarchy(a);var s=this.renderHierarchy.getRenderNodeByName(a);s.node.isGroupNode&&!s.expanded&&(s.expanded=!0,o||(o=s))}),o&&(this.setNodeExpanded(o),this._zoomed=!0),t&&this._updateNodeState(t),setTimeout(()=>{this.panToNode(t)},Tr.animation.duration)}}_highlightedNodeChanged(t,r){t!==r&&(t&&this._updateNodeState(t),r&&this._updateNodeState(r))}_onZoomChanged(){this._updateLabels(!this._zoomed)}_fireEnableClick(){this.fire("enable-click")}_updateInputTrace(){Vle(this.getGraphSvgRoot(),this.renderHierarchy,this.selectedNode,this.traceInputs)}};Lr.template=Wle;E([A({type:Object}),w("design:type",lo)],Lr.prototype,"renderHierarchy",void 0);E([A({type:String}),w("design:type",String)],Lr.prototype,"name",void 0);E([A({type:String}),w("design:type",String)],Lr.prototype,"colorBy",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Lr.prototype,"traceInputs",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Lr.prototype,"_hasRenderHierarchyBeenFitOnce",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Lr.prototype,"_isAttached",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"_zoom",void 0);E([A({type:String,observer:"_highlightedNodeChanged"}),w("design:type",String)],Lr.prototype,"highlightedNode",void 0);E([A({type:String,observer:"_selectedNodeChanged"}),w("design:type",String)],Lr.prototype,"selectedNode",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"handleEdgeSelected",void 0);E([A({type:Boolean,observer:"_onZoomChanged"}),w("design:type",Boolean)],Lr.prototype,"_zoomed",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"_zoomStartCoords",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"_zoomTransform",void 0);E([A({type:Number}),w("design:type",Number)],Lr.prototype,"_maxZoomDistanceForClick",void 0);E([A({type:Object}),w("design:type",Function)],Lr.prototype,"templateIndex",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"_nodeGroupIndex",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"_annotationGroupIndex",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"_edgeGroupIndex",void 0);E([A({type:Number}),w("design:type",Number)],Lr.prototype,"maxMetanodeLabelLengthFontSize",void 0);E([A({type:Number}),w("design:type",Number)],Lr.prototype,"minMetanodeLabelLengthFontSize",void 0);E([A({type:Number}),w("design:type",Number)],Lr.prototype,"maxMetanodeLabelLengthLargeFont",void 0);E([A({type:Number}),w("design:type",Number)],Lr.prototype,"maxMetanodeLabelLength",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"progress",void 0);E([A({type:Array}),w("design:type",Array)],Lr.prototype,"nodeContextMenuItems",void 0);E([A({type:Object}),w("design:type",Object)],Lr.prototype,"nodeNamesToHealthPills",void 0);E([A({type:Number}),w("design:type",Number)],Lr.prototype,"healthPillStepIndex",void 0);E([Bt("renderHierarchy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Lr.prototype,"_renderHierarchyChanged",null);E([Bt("_isAttached","renderHierarchy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Lr.prototype,"_animateAndFit",null);E([Bt("colorBy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Lr.prototype,"nodeColorsChanged",null);E([Bt("nodeNamesToHealthPills","healthPillStepIndex"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Lr.prototype,"_updateHealthPills",null);E([Bt("traceInputs","selectedNode"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Lr.prototype,"_updateInputTrace",null);Lr=E([yt("tf-graph-scene")],Lr);var Dr=class extends Gt(mt){constructor(){super(...arguments),this._renderDepth=1,this._allowGraphSelect=!0,this.edgeWidthFunction="",this.handleNodeSelected="",this.edgeLabelFunction="",this.handleEdgeSelected=""}panToNode(t){this.$$("tf-graph-scene").panToNode(t)}_autoExtractNodesChanged(){var t=this.graphHierarchy;if(!!t){for(let r of Object.values(t.getNodeMap()))r.include=ur.UNSPECIFIED;this._buildRenderHierarchy(t)}}_buildNewRenderHierarchy(){var t=this.graphHierarchy;!t||this._buildRenderHierarchy(t)}_statsChanged(){var t=this.stats,r=this.devicesForStats;this.graphHierarchy&&(t&&r&&(ele(this.basicGraph,t,r),lle(this.graphHierarchy,t)),this._buildRenderHierarchy(this.graphHierarchy))}ready(){super.ready(),this.addEventListener("graph-select",this._graphSelected.bind(this)),this.addEventListener("disable-click",this._disableClick.bind(this)),this.addEventListener("enable-click",this._enableClick.bind(this)),this.addEventListener("node-toggle-expand",this._nodeToggleExpand.bind(this)),this.addEventListener("node-select",this._nodeSelected.bind(this)),this.addEventListener("node-highlight",this._nodeHighlighted.bind(this)),this.addEventListener("node-unhighlight",this._nodeUnhighlighted.bind(this)),this.addEventListener("node-toggle-extract",this._nodeToggleExtract.bind(this)),this.addEventListener("node-toggle-seriesgroup",this._nodeToggleSeriesGroup.bind(this)),this.addEventListener("edge-select",this._edgeSelected.bind(this)),this.addEventListener("annotation-select",this._nodeSelected.bind(this)),this.addEventListener("annotation-highlight",this._nodeHighlighted.bind(this)),this.addEventListener("annotation-unhighlight",this._nodeUnhighlighted.bind(this))}_buildRenderHierarchy(t){if(t.root.type!==jt.META)return;let r=this,n=Rd("new tf_graph_render.Hierarchy",()=>{let i=new lo(t,!!this.stats,this.autoExtractNodes);i.edgeLabelFunction=this.edgeLabelFunction,i.edgeWidthFunction=this.edgeWidthFunction;function o(a){return{minValue:a.domain()[0],maxValue:a.domain()[1],startColor:a.range()[0],endColor:a.range()[1]}}return r._setColorByParams({compute_time:o(i.computeTimeScale),memory:o(i.memoryUsageScale),device:oct.map(i.deviceColorMap.domain(),function(a){return{device:a,color:i.deviceColorMap(a)}}),xla_cluster:oct.map(i.xlaClusterColorMap.domain(),function(a){return{xla_cluster:a,color:i.xlaClusterColorMap(a)}})}),i},jr.RENDER_BUILD_HIERARCHY);r._setRenderHierarchy(n)}_getVisible(t){return t&&this.renderHierarchy.getNearestVisibleAncestor(t)}fit(){this.$.scene.fit()}getImageBlob(){return this.$.scene.getImageBlob()}_graphChanged(){!this.graphHierarchy||(this.graphHierarchy.addListener(Dd.TEMPLATES_UPDATED,()=>{this.$.scene.nodeColorsChanged()}),this.fire("graph-select"))}_graphSelected(t){this._allowGraphSelect&&(this.set("selectedNode",null),this.set("selectedEdge",null)),this._allowGraphSelect=!0}_disableClick(t){this._allowGraphSelect=!1}_enableClick(t){this._allowGraphSelect=!0}_selectedNodeChanged(){var t=this.selectedNode;this.handleNodeSelected&&this.handleNodeSelected(t)}_selectedEdgeChanged(){var t=this.selectedEdge;this._deselectPreviousEdge(),t&&(this._lastSelectedEdgeGroup.classed(Hi.Edge.SELECTED,!0),this._updateMarkerOfSelectedEdge(t)),this.handleEdgeSelected&&this.handleEdgeSelected(t)}_nodeSelected(t){this._allowGraphSelect&&this.set("selectedNode",t.detail.name),this._allowGraphSelect=!0}_edgeSelected(t){this._allowGraphSelect&&(this.set("_lastSelectedEdgeGroup",t.detail.edgeGroup),this.set("selectedEdge",t.detail.edgeData)),this._allowGraphSelect=!0}_nodeHighlighted(t){this.set("highlightedNode",t.detail.name)}_nodeUnhighlighted(t){this.set("highlightedNode",null)}_nodeToggleExpand(t){this._nodeSelected(t);var r=t.detail.name,n=this.renderHierarchy.getRenderNodeByName(r);n.node.type!==jt.OP&&(this.renderHierarchy.buildSubhierarchy(r),n.expanded=!n.expanded,this.async(function(){this.$.scene.setNodeExpanded(n)},75),Po({actionId:jr.NODE_EXPANSION_TOGGLED,eventLabel:n.expanded?"expanded":"collapsed"}))}_nodeToggleExtract(t){var r=t.detail.name;this.nodeToggleExtract(r)}nodeToggleExtract(t){let r=this.renderHierarchy.getRenderNodeByName(t);r.node.include==ur.INCLUDE?r.node.include=ur.EXCLUDE:r.node.include==ur.EXCLUDE?r.node.include=ur.INCLUDE:r.node.include=this.renderHierarchy.isNodeAuxiliary(r)?ur.INCLUDE:ur.EXCLUDE,this._buildRenderHierarchy(this.graphHierarchy),Po({actionId:jr.NODE_AUXILIARY_EXTRACTION_CHANGED,eventLabel:r.node.include===ur.INCLUDE?"Auxiliary to Main":"Main to Auxiliary"})}_nodeToggleSeriesGroup(t){var r=t.detail.name;this.nodeToggleSeriesGroup(r)}nodeToggleSeriesGroup(t){this.set("progress",{value:0,msg:""});var r=rP(this),n=JS(r,100,"Namespace hierarchy");let i=Mx(Kl({},this.hierarchyParams),{seriesMap:this.graphHierarchy.buildSeriesGroupMapToggled(t)});xH(this.basicGraph,i,n).then(function(o){this.set("graphHierarchy",o),this._buildRenderHierarchy(this.graphHierarchy)}.bind(this))}_deselectPreviousEdge(){let t="."+Hi.Edge.SELECTED;Ht(t).classed(Hi.Edge.SELECTED,!1).each((r,n)=>{if(r.label){let i=Ht(this).selectAll("path.edgeline");r.label.startMarkerId&&i.style("marker-start",`url(#${r.label.startMarkerId})`),r.label.endMarkerId&&i.style("marker-end",`url(#${r.label.endMarkerId})`)}})}_updateMarkerOfSelectedEdge(t){var r;if(t.label){let n=t.label.startMarkerId||t.label.endMarkerId;if(n){let i=n.replace("dataflow-","selected-"),o=this.$$("#"+i);if(!o){let s=this.$.scene.querySelector("#"+n);o=s==null?void 0:s.cloneNode(!0),o.setAttribute("id",i),o.classList.add("selected-arrowhead"),(r=s==null?void 0:s.parentNode)==null||r.appendChild(o)}let a=t.label.startMarkerId?"marker-start":"marker-end";this._lastSelectedEdgeGroup.selectAll("path.edgeline").style(a,`url(#${i})`)}}}not(t){return!t}};Dr.template=Q`
    <style>
      .container {
        width: 100%;
        height: 100%;
        background: white;
        box-shadow: 0 1px 5px rgba(0, 0, 0, 0.2);
      }

      .vertical {
        width: 100%;
        height: 100%;
        @apply --layout-vertical;
      }

      .auto {
        @apply --layout-flex-auto;
        @apply --layout-vertical;
      }

      h2 {
        text-align: center;
      }

      paper-button {
        text-transform: none;
      }
    </style>
    <div class="container">
      <div class="vertical">
        <template is="dom-if" if="[[title]]">
          <h2>[[title]]</h2>
        </template>
        <tf-graph-scene
          id="scene"
          class="auto"
          render-hierarchy="[[renderHierarchy]]"
          highlighted-node="[[_getVisible(highlightedNode)]]"
          selected-node="{{selectedNode}}"
          selected-edge="{{selectedEdge}}"
          color-by="[[colorBy]]"
          progress="[[progress]]"
          node-context-menu-items="[[nodeContextMenuItems]]"
          node-names-to-health-pills="[[nodeNamesToHealthPills]]"
          health-pill-step-index="{{healthPillStepIndex}}"
          handle-edge-selected="[[handleEdgeSelected]]"
          trace-inputs="[[traceInputs]]"
        ></tf-graph-scene>
      </div>
    </div>
  `;E([A({type:Object,notify:!0,observer:"_graphChanged"}),w("design:type",os)],Dr.prototype,"graphHierarchy",void 0);E([A({type:Object}),w("design:type",Xu)],Dr.prototype,"basicGraph",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"stats",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"devicesForStats",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"hierarchyParams",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],Dr.prototype,"progress",void 0);E([A({type:String}),w("design:type",String)],Dr.prototype,"title",void 0);E([A({type:String,notify:!0}),w("design:type",String)],Dr.prototype,"selectedNode",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],Dr.prototype,"selectedEdge",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"_lastSelectedEdgeGroup",void 0);E([A({type:String,notify:!0}),w("design:type",String)],Dr.prototype,"highlightedNode",void 0);E([A({type:String}),w("design:type",String)],Dr.prototype,"colorBy",void 0);E([A({type:Object,notify:!0,readOnly:!0}),w("design:type",Object)],Dr.prototype,"colorByParams",void 0);E([A({type:Object,readOnly:!0,notify:!0}),w("design:type",lo)],Dr.prototype,"renderHierarchy",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Dr.prototype,"traceInputs",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Dr.prototype,"autoExtractNodes",void 0);E([A({type:Array}),w("design:type",Array)],Dr.prototype,"nodeContextMenuItems",void 0);E([A({type:Number}),w("design:type",Number)],Dr.prototype,"_renderDepth",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Dr.prototype,"_allowGraphSelect",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"nodeNamesToHealthPills",void 0);E([A({type:Number}),w("design:type",Number)],Dr.prototype,"healthPillStepIndex",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"edgeWidthFunction",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"handleNodeSelected",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"edgeLabelFunction",void 0);E([A({type:Object}),w("design:type",Object)],Dr.prototype,"handleEdgeSelected",void 0);E([Bt("autoExtractNodes"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Dr.prototype,"_autoExtractNodesChanged",null);E([Bt("graphHierarchy","edgeWidthFunction","handleNodeSelected","edgeLabelFunction","handleEdgeSelected"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Dr.prototype,"_buildNewRenderHierarchy",null);E([Bt("stats","devicesForStats"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Dr.prototype,"_statsChanged",null);E([Bt("selectedNode"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Dr.prototype,"_selectedNodeChanged",null);E([Bt("selectedEdge"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Dr.prototype,"_selectedEdgeChanged",null);Dr=E([yt("tf-graph")],Dr);var co=class extends Gt(mt){constructor(){super(...arguments),this.specificHealthPillStep=0,this.healthPillEntries=hP}ready(){super.ready();var t=document.getElementById("mainContainer"),r=document.querySelector("tf-dashboard-layout .scrollbar");t&&r&&(t.style.overflow="hidden",r.style.overflow="hidden")}_healthPillsAvailable(t,r){return t&&r}_computeTensorCountString(t,r){return t?t[r].toFixed(0):""}get healthPillValuesForSelectedNode(){var t=this.nodeNamesToHealthPills,r=this.healthPillStepIndex,n=this.selectedNode,i=this.allStepsModeEnabled,o=this.areHealthPillsLoading;if(o||!n)return null;let a=t[n];if(!a)return null;let s=a[i?0:r];return s?s.value.slice(2,8):null}get _currentStepDisplayValue(){var t=this.nodeNamesToHealthPills,r=this.healthPillStepIndex,n=this.allStepsModeEnabled,i=this.specificHealthPillStep,o=this.areHealthPillsLoading;if(n)return i.toFixed(0);if(o)return 0;for(let a in t)return t[a][r].step.toFixed(0);return 0}get _biggestStepEverSeen(){var t=this.nodeNamesToHealthPills;for(let n in t){var r=t[n];return Math.max(this._biggestStepEverSeen,r[r.length-1].step)}return this._biggestStepEverSeen||0}get _maxStepIndex(){var t=this.nodeNamesToHealthPills;for(let r in t)return t[r].length-1;return 0}_hasDebuggerNumericAlerts(t){return t&&t.length}_updateAlertsList(){var t=this.debuggerNumericAlerts,r=this.$$("#numeric-alerts-body");if(!!r){r.innerText="";for(var n=0;n<t.length;n++){var i=t[n],o=document.createElement("tr"),a=document.createElement("td");a.innerText=Xse(i.first_timestamp),a.classList.add("first-offense-td"),o.appendChild(a);var s=document.createElement("td");s.classList.add("tensor-device-td");var l=document.createElement("div");l.classList.add("tensor-section-within-table"),l.innerText=i.tensor_name,this._addOpExpansionListener(l,i.tensor_name),s.appendChild(l);var c=document.createElement("div");c.classList.add("device-section-within-table"),c.innerText="("+i.device_name+")",s.appendChild(c),o.appendChild(s);var u=document.createElement("div");u.classList.add("mini-health-pill");var h=document.createElement("td");if(h.classList.add("mini-health-pill-td"),h.appendChild(u),o.appendChild(h),i.neg_inf_event_count){var f=document.createElement("div");f.classList.add("negative-inf-mini-health-pill-section"),f.innerText=i.neg_inf_event_count,f.setAttribute("title",i.neg_inf_event_count+" events with -\u221E"),u.appendChild(f)}if(i.pos_inf_event_count){var p=document.createElement("div");p.classList.add("positive-inf-mini-health-pill-section"),p.innerText=i.pos_inf_event_count,p.setAttribute("title",i.pos_inf_event_count+" events with +\u221E"),u.appendChild(p)}if(i.nan_event_count){var d=document.createElement("div");d.classList.add("nan-mini-health-pill-section"),d.innerText=i.nan_event_count,d.setAttribute("title",i.nan_event_count+" events with NaN"),u.appendChild(d)}zt(r).appendChild(o)}}}_addOpExpansionListener(t,r){t.addEventListener("click",()=>{var n=mle(document.getElementById("scene"),this.renderHierarchy,r),i,o=document.querySelector("tf-graph-info#graph-info");o&&(i=o.scrollHeight-o.scrollTop);var a=this.selectedNode;this.set("selectedNode",n);var s=()=>{o.scrollTop=o.scrollHeight-i};o&&(a?s():window.setTimeout(s,20))})}};co.template=Q`
    <style>
      :host {
        font-size: 12px;
        margin: 0;
        padding: 0;
        display: block;
      }

      h2 {
        padding: 0;
        text-align: center;
        margin: 0;
      }

      .health-pill-legend {
        padding: 15px;
      }

      .health-pill-legend h2 {
        text-align: left;
      }

      .health-pill-entry {
        margin: 10px 10px 10px 0;
      }

      .health-pill-entry .color-preview {
        width: 26px;
        height: 26px;
        border-radius: 3px;
        display: inline-block;
        margin: 0 10px 0 0;
      }

      .health-pill-entry .color-label,
      .health-pill-entry .tensor-count {
        color: #777;
        display: inline-block;
        height: 26px;
        font-size: 22px;
        line-height: 26px;
        vertical-align: top;
      }

      .health-pill-entry .tensor-count {
        float: right;
      }

      #health-pill-step-slider {
        width: 100%;
        margin: 0 0 0 -15px;
        /* 31 comes from adding a padding of 15px from both sides of the paper-slider, subtracting
   * 1px so that the slider width aligns with the image (the last slider marker takes up 1px),
   * and adding 2px to account for a border of 1px on both sides of the image. 30 - 1 + 2.
   * Apparently, the paper-slider lacks a mixin for those padding values. */
        width: calc(100% + 31px);
      }

      #health-pills-loading-spinner {
        width: 20px;
        height: 20px;
        vertical-align: top;
      }

      #health-pill-step-number-input {
        text-align: center;
        vertical-align: top;
      }

      #numeric-alerts-table-container {
        max-height: 400px;
        overflow-x: hidden;
        overflow-y: auto;
      }

      #numeric-alerts-table {
        text-align: left;
      }

      #numeric-alerts-table td {
        vertical-align: top;
      }

      #numeric-alerts-table .first-offense-td {
        display: inline-block;
      }

      .first-offense-td {
        width: 80px;
      }

      .tensor-device-td {
        max-width: 140px;
        word-wrap: break-word;
      }

      .tensor-section-within-table {
        color: #266236;
        cursor: pointer;
        opacity: 0.8;
        text-decoration: underline;
      }

      .tensor-section-within-table:hover {
        opacity: 1;
      }

      .device-section-within-table {
        color: #666;
      }

      .mini-health-pill {
        width: 130px;
      }

      .mini-health-pill > div {
        height: 100%;
        width: 60px;
        border-radius: 3px;
      }

      #event-counts-th {
        padding: 0 0 0 10px;
      }

      .negative-inf-mini-health-pill-section {
        background: rgb(255, 141, 0);
        width: 20px;
      }

      .positive-inf-mini-health-pill-section {
        background: rgb(0, 62, 212);
        width: 20px;
      }

      .nan-mini-health-pill-section {
        background: rgb(204, 47, 44);
        width: 20px;
      }

      .negative-inf-mini-health-pill-section,
      .positive-inf-mini-health-pill-section,
      .nan-mini-health-pill-section {
        color: #fff;
        display: inline-block;
        height: 100%;
        line-height: 20px;
        margin: 0 0 0 10px;
        text-align: center;
      }

      .no-numeric-alerts-notification {
        margin: 0;
      }
    </style>
    <paper-material elevation="1" class="card health-pill-legend">
      <div class="title">
        Enable all (not just sampled) steps. Requires slow disk read.
      </div>
      <paper-toggle-button
        id="enableAllStepsModeToggle"
        checked="{{allStepsModeEnabled}}"
      >
      </paper-toggle-button>
      <h2>
        Step of Health Pills:
        <template is="dom-if" if="[[allStepsModeEnabled]]">
          <input
            type="number"
            id="health-pill-step-number-input"
            min="0"
            max="[[_biggestStepEverSeen]]"
            value="{{specificHealthPillStep::input}}"
          />
        </template>
        <template is="dom-if" if="[[!allStepsModeEnabled]]">
          [[_currentStepDisplayValue]]
        </template>
        <paper-spinner-lite
          active
          hidden$="[[!areHealthPillsLoading]]"
          id="health-pills-loading-spinner"
        ></paper-spinner-lite>
      </h2>
      <template is="dom-if" if="[[allStepsModeEnabled]]">
        <paper-slider
          id="health-pill-step-slider"
          immediate-value="{{specificHealthPillStep}}"
          max="[[_biggestStepEverSeen]]"
          snaps
          step="1"
          value="{{specificHealthPillStep}}"
        ></paper-slider>
      </template>
      <template is="dom-if" if="[[!allStepsModeEnabled]]">
        <template is="dom-if" if="[[_maxStepIndex]]">
          <paper-slider
            id="health-pill-step-slider"
            immediate-value="{{healthPillStepIndex}}"
            max="[[_maxStepIndex]]"
            snaps
            step="1"
            value="{{healthPillStepIndex}}"
          ></paper-slider>
        </template>
      </template>
      <h2>
        Health Pill
        <template is="dom-if" if="[[healthPillValuesForSelectedNode]]">
          Counts for Selected Node
        </template>
        <template is="dom-if" if="[[!healthPillValuesForSelectedNode]]">
          Legend
        </template>
      </h2>
      <template is="dom-repeat" items="[[healthPillEntries]]">
        <div class="health-pill-entry">
          <div
            class="color-preview"
            style="background:[[item.background_color]]"
          ></div>
          <div class="color-label">[[item.label]]</div>
          <div class="tensor-count">
            [[_computeTensorCountString(healthPillValuesForSelectedNode,
            index)]]
          </div>
        </div>
      </template>
      <div hidden$="[[!_hasDebuggerNumericAlerts(debuggerNumericAlerts)]]">
        <h2 id="numeric-alerts-header">Numeric Alerts</h2>
        <p>Alerts are sorted from top to bottom by increasing timestamp.</p>
        <div id="numeric-alerts-table-container">
          <table id="numeric-alerts-table">
            <thead>
              <tr>
                <th>First Offense</th>
                <th>Tensor (Device)</th>
                <th id="event-counts-th">Event Counts</th>
              </tr>
            </thead>
            <tbody id="numeric-alerts-body"></tbody>
          </table>
        </div>
      </div>
      <template
        is="dom-if"
        if="[[!_hasDebuggerNumericAlerts(debuggerNumericAlerts)]]"
      >
        <p class="no-numeric-alerts-notification">
          No numeric alerts so far. That is likely good. Alerts indicate the
          presence of NaN or (+/-) Infinity values, which may be concerning.
        </p>
      </template>
    </paper-material>
  `;E([A({type:Object}),w("design:type",lo)],co.prototype,"renderHierarchy",void 0);E([A({type:Array,notify:!0}),w("design:type",Object)],co.prototype,"debuggerNumericAlerts",void 0);E([A({type:Object}),w("design:type",Object)],co.prototype,"nodeNamesToHealthPills",void 0);E([A({type:Number,notify:!0}),w("design:type",Object)],co.prototype,"healthPillStepIndex",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],co.prototype,"specificHealthPillStep",void 0);E([A({type:String,notify:!0}),w("design:type",Object)],co.prototype,"selectedNode",void 0);E([A({type:String,notify:!0}),w("design:type",Object)],co.prototype,"highlightedNode",void 0);E([A({type:Number,notify:!0}),w("design:type",Object)],co.prototype,"selectedNodeInclude",void 0);E([A({type:Boolean}),w("design:type",Object)],co.prototype,"areHealthPillsLoading",void 0);E([A({type:Array}),w("design:type",Array)],co.prototype,"healthPillEntries",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Object)],co.prototype,"allStepsModeEnabled",void 0);E([Rt("nodeNamesToHealthPills","healthPillStepIndex","selectedNode","allStepsModeEnabled","areHealthPillsLoading"),w("design:type",Object),w("design:paramtypes",[])],co.prototype,"healthPillValuesForSelectedNode",null);E([Rt("nodeNamesToHealthPills","healthPillStepIndex","allStepsModeEnabled","specificHealthPillStep","areHealthPillsLoading"),w("design:type",Object),w("design:paramtypes",[])],co.prototype,"_currentStepDisplayValue",null);E([Rt("nodeNamesToHealthPills"),w("design:type",Number),w("design:paramtypes",[])],co.prototype,"_biggestStepEverSeen",null);E([Rt("nodeNamesToHealthPills"),w("design:type",Number),w("design:paramtypes",[])],co.prototype,"_maxStepIndex",null);E([Bt("debuggerNumericAlerts"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],co.prototype,"_updateAlertsList",null);co=E([yt("tf-graph-debugger-data-card")],co);var act={};Ks(act,{GraphIconType:()=>nv});var nv;(function(e){e.CONST="CONST",e.META="META",e.OP="OP",e.SERIES="SERIES",e.SUMMARY="SUMMARY"})(nv||(nv={}));var Zu=class extends Gt(_o(mt)){constructor(){super(...arguments),this.vertical=!1,this.fillOverride=null,this.strokeOverride=null,this.height=20,this.faded=!1}getSvgDefinableElement(){return this.$.svgDefs}get _fill(){var t=this.type,r=this.fillOverride;if(r!=null)return r;switch(t){case nv.META:return Ku.DEFAULT_FILL;case nv.SERIES:return Ult.DEFAULT_FILL;default:return y0.DEFAULT_FILL}}get _stroke(){var t=this.type,r=this.strokeOverride;if(r!=null)return r;switch(t){case nv.META:return Ku.DEFAULT_STROKE;case nv.SERIES:return Ult.DEFAULT_STROKE;default:return y0.DEFAULT_STROKE}}_isType(t,r){return t===r}_fadedClass(t,r){return t?"faded-"+r:""}};Zu.template=Q`
    <style>
      :host {
        font-size: 0;
      }

      :host(.dark-mode) svg {
        filter: invert(1);
      }

      .faded-rect {
        fill: url(#rectHatch);
      }

      .faded-ellipse {
        fill: url(#ellipseHatch);
      }

      .faded-rect,
      .faded-ellipse,
      .faded-series {
        stroke: var(--tb-graph-faded) !important;
      }
      #rectHatch line,
      #ellipseHatch line {
        color: #e0d4b3 !important;
        fill: white;
        stroke: #e0d4b3 !important;
      }
    </style>
    <!-- SVG for definitions -->
    <svg height="0" width="0" id="svgDefs">
      <defs>
        <!-- Hatch patterns for faded out nodes. -->
        <pattern
          id="rectHatch"
          patternTransform="rotate(45 0 0)"
          width="5"
          height="5"
          patternUnits="userSpaceOnUse"
        >
          <line x1="0" y1="0" x2="0" y2="5" style="stroke-width: 1"></line>
        </pattern>
        <pattern
          id="ellipseHatch"
          patternTransform="rotate(45 0 0)"
          width="2"
          height="2"
          patternUnits="userSpaceOnUse"
        >
          <line x1="0" y1="0" x2="0" y2="2" style="stroke-width: 1"></line>
        </pattern>
        <!-- Template for an Op node ellipse. -->
        <ellipse
          id="op-node-stamp"
          rx="7.5"
          ry="3"
          stroke="inherit"
          fill="inherit"
        ></ellipse>
        <!-- Template for an Op node annotation ellipse (smaller). -->
        <ellipse
          id="op-node-annotation-stamp"
          rx="5"
          ry="2"
          stroke="inherit"
          fill="inherit"
        ></ellipse>
        <!-- Vertically stacked series of Op nodes when unexpanded. -->
        <g id="op-series-vertical-stamp">
          <use xlink:href="#op-node-stamp" x="8" y="9"></use>
          <use xlink:href="#op-node-stamp" x="8" y="6"></use>
          <use xlink:href="#op-node-stamp" x="8" y="3"></use>
        </g>
        <g id="op-series-horizontal-stamp">
          <use xlink:href="#op-node-stamp" x="16" y="4"></use>
          <use xlink:href="#op-node-stamp" x="12" y="4"></use>
          <use xlink:href="#op-node-stamp" x="8" y="4"></use>
        </g>
        <g
          id="summary-icon"
          fill="#848484"
          height="12"
          viewBox="0 0 24 24"
          width="12"
        >
          <path
            d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z"
          ></path>
        </g>
      </defs>
    </svg>
    <template is="dom-if" if="[[_isType(type, 'CONST')]]">
      <svg
        height$="[[height]]"
        preserveAspectRatio="xMinYMid meet"
        viewBox="0 0 10 10"
      >
        <circle
          cx="5"
          cy="5"
          r="3"
          fill$="[[_fill]]"
          stroke$="[[_stroke]]"
        ></circle>
      </svg>
    </template>
    <template is="dom-if" if="[[_isType(type, 'SUMMARY')]]">
      <svg
        width$="[[height]]"
        height$="[[height]]"
        viewBox="0 0 24 24"
        fill="#848484"
      >
        <path
          d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z"
        ></path>
      </svg>
    </template>
    <template is="dom-if" if="[[_isType(type, 'OP')]]">
      <svg
        height$="[[height]]"
        preserveAspectRatio="xMinYMid meet"
        viewBox="0 0 16 8"
      >
        <use
          xmlns:xlink="http://www.w3.org/1999/xlink"
          xlink:href="#op-node-stamp"
          fill$="[[_fill]]"
          stroke$="[[_stroke]]"
          class$="{{_fadedClass(faded, 'ellipse')}}"
          x="8"
          y="4"
        ></use>
      </svg>
    </template>
    <template is="dom-if" if="[[_isType(type, 'META')]]">
      <svg
        height$="[[height]]"
        preserveAspectRatio="xMinYMid meet"
        viewBox="0 0 37 16"
      >
        <rect
          x="1"
          y="1"
          fill$="[[_fill]]"
          stroke$="[[_stroke]]"
          class$="{{_fadedClass(faded, 'rect')}}"
          stroke-width="2px"
          height="14"
          width="35"
          rx="5"
          ry="5"
        ></rect>
      </svg>
    </template>
    <template is="dom-if" if="[[_isType(type, 'SERIES')]]">
      <template is="dom-if" if="[[vertical]]">
        <svg
          height$="[[height]]"
          preserveAspectRatio="xMinYMid meet"
          viewBox="0 0 16 15"
        >
          <use
            xmlns:xlink="http://www.w3.org/1999/xlink"
            xlink:href="#op-series-vertical-stamp"
            fill$="[[_fill]]"
            stroke$="[[_stroke]]"
            class$="{{_fadedClass(faded, 'series')}}"
            x="0"
            y="2"
          ></use>
        </svg>
      </template>
      <template is="dom-if" if="[[!vertical]]">
        <svg
          height$="[[height]]"
          preserveAspectRatio="xMinYMid meet"
          viewBox="0 0 24 10"
        >
          <use
            xmlns:xlink="http://www.w3.org/1999/xlink"
            xlink:href="#op-series-horizontal-stamp"
            fill$="[[_fill]]"
            stroke$="[[_stroke]]"
            class$="{{_fadedClass(faded, 'series')}}"
            x="0"
            y="1"
          ></use>
        </svg>
      </template>
    </template>
  `;E([A({type:String}),w("design:type",String)],Zu.prototype,"type",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Zu.prototype,"vertical",void 0);E([A({type:String}),w("design:type",Object)],Zu.prototype,"fillOverride",void 0);E([A({type:String}),w("design:type",Object)],Zu.prototype,"strokeOverride",void 0);E([A({type:Number}),w("design:type",Number)],Zu.prototype,"height",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Zu.prototype,"faded",void 0);E([Rt("type","fillOverride"),w("design:type",String),w("design:paramtypes",[])],Zu.prototype,"_fill",null);E([Rt("type","strokeOverride"),w("design:type",String),w("design:paramtypes",[])],Zu.prototype,"_stroke",null);Zu=E([yt("tf-graph-icon")],Zu);var Bs=class extends Gt(mt){constructor(){super(...arguments),this.node=null,this.renderInfo=null,this.colorBy=Gn.STRUCTURE,this.templateIndex=null,this.type=null,this.vertical=!1,this.const=!1,this.summary=!1,this.fill=null,this.height=20}_computeFillOverride(t,r,n,i,o){return t&&r&&i?LH(i,n,r,!1):o}_getStrokeOverride(t){return t?ect(t):null}_getType(t,r,n,i){let{GraphIconType:o}=act;if(t)switch(t.type){case jt.OP:{let a=t.op;return typeof a!="string"?o.OP:a==="Const"||n?o.CONST:a.endsWith("Summary")||r?o.SUMMARY:o.OP}case jt.META:return o.META;case jt.SERIES:return o.SERIES}return i}_isVertical(t,r){return t?t.hasNonControlEdges:!!r}_getFaded(t){return t&&t.isFadedOut}_onFillOverrideChanged(t,r){let{node:n,renderInfo:i,colorBy:o,templateIndex:a}=this;t!==r&&IH(this.$.icon.getSvgDefinableElement()),n&&i&&a&&LH(a,o,i,!1,this.$.icon.getSvgDefinableElement())}};Bs.template=Q`
    <style>
      tf-graph-icon {
        --tb-graph-faded: var(--tb-graph-faded);
      }
    </style>
    <tf-graph-icon
      id="icon"
      type="[[_getType(node, summary, const, type)]]"
      height="[[height]]"
      fill-override="[[_fillOverride]]"
      stroke-override="[[_getStrokeOverride(_fillOverride)]]"
      faded="[[_getFaded(renderInfo)]]"
      vertical="[[_isVertical(node, vertical)]]"
    ></tf-graph-icon>
  `;E([A({type:Object}),w("design:type",Object)],Bs.prototype,"node",void 0);E([A({type:Object}),w("design:type",Object)],Bs.prototype,"renderInfo",void 0);E([A({type:Object}),w("design:type",String)],Bs.prototype,"colorBy",void 0);E([A({type:Object}),w("design:type",Object)],Bs.prototype,"templateIndex",void 0);E([A({type:String}),w("design:type",Object)],Bs.prototype,"type",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Bs.prototype,"vertical",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Bs.prototype,"const",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Bs.prototype,"summary",void 0);E([A({type:String}),w("design:type",Object)],Bs.prototype,"fill",void 0);E([A({type:Number}),w("design:type",Number)],Bs.prototype,"height",void 0);E([A({type:String,computed:"_computeFillOverride(node, renderInfo, colorBy, templateIndex, fill)",observer:"_onFillOverrideChanged"}),w("design:type",String)],Bs.prototype,"_fillOverride",void 0);Bs=E([yt("tf-node-icon")],Bs);var Gc=class extends Gt(mt){_itemTypeChanged(){this.itemType!=="subnode"?this.$["list-item"].classList.add("clickable"):this.$["list-item"].classList.remove("clickable")}_nodeListener(t){this.fire("node-list-item-"+t.type,{nodeName:this.name,type:this.itemType})}_fadedClass(t){return t&&t.isFadedOut?"faded":""}};Gc.template=Q`
    <style>
      #list-item {
        width: 100%;
        color: var(--secondary-text-color);
        font-size: 11pt;
        font-weight: 400;
        position: relative;
        display: inline-block;
      }

      #list-item:hover {
        background-color: var(--google-yellow-100);
      }

      .clickable {
        cursor: pointer;
      }

      #list-item span {
        margin-left: 40px;
      }

      #list-item.excluded span {
        color: #999;
      }

      #list-item span.edge-label {
        float: right;
        font-size: 10px;
        margin-left: 3px;
        margin-right: 5px;
      }

      .node-icon {
        position: absolute;
        top: 1px;
        left: 2px;
      }

      .faded span {
        color: var(--tb-graph-faded);
      }
    </style>

    <div
      id="list-item"
      on-mouseover="_nodeListener"
      on-mouseout="_nodeListener"
      on-click="_nodeListener"
    >
      <div class$="{{_fadedClass(itemRenderInfo)}}">
        <tf-node-icon
          class="node-icon"
          height="12"
          color-by="[[colorBy]]"
          color-by-params="[[colorByParams]]"
          node="[[itemNode]]"
          render-info="[[itemRenderInfo]]"
          template-index="[[templateIndex]]"
        >
        </tf-node-icon>
        <span title$="[[name]]">[[name]]</span>
      </div>
    </div>
  `;E([A({type:Object}),w("design:type",Object)],Gc.prototype,"cardNode",void 0);E([A({type:Object}),w("design:type",Object)],Gc.prototype,"itemNode",void 0);E([A({type:String}),w("design:type",String)],Gc.prototype,"edgeLabel",void 0);E([A({type:Object}),w("design:type",Object)],Gc.prototype,"itemRenderInfo",void 0);E([A({type:String}),w("design:type",String)],Gc.prototype,"name",void 0);E([A({type:String,observer:"_itemTypeChanged"}),w("design:type",String)],Gc.prototype,"itemType",void 0);E([A({type:String}),w("design:type",String)],Gc.prototype,"colorBy",void 0);E([A({type:Object}),w("design:type",Object)],Gc.prototype,"colorByParams",void 0);E([A({type:Object}),w("design:type",Function)],Gc.prototype,"templateIndex",void 0);Gc=E([yt("tf-graph-op-compat-list-item")],Gc);var as=class extends Gt(_o(mt)){constructor(){super(...arguments),this._expanded=!0,this._opCompatColor=y0.COMPATIBLE,this._opIncompatColor=y0.INCOMPATIBLE,this._templateIndex=null}_getNode(t,r){return r.node(t)}_getRenderInfo(t,r){return this.renderHierarchy.getOrCreateRenderNodeByName(t)}_toggleExpanded(){this._expanded=!this._expanded}_getToggleIcon(t){return t?"expand-less":"expand-more"}_resizeList(t){var r=document.querySelector(t);r&&r.fire("iron-resize")}get _incompatibleOpNodes(){let t=this.graphHierarchy;return!t||!t.root?[]:(this.async(this._resizeList.bind(this,"#incompatibleOpsList")),cle(t))}get _opCompatScore(){var t=this.graphHierarchy;if(t&&t.root){var r=t.root,n=r.compatibilityHistogram.compatible,i=r.compatibilityHistogram.incompatible;if(n==0&&i==0)return 0;var o=n+i;return Math.floor(100*n/o)/100}return 0}get _opCompatScoreLabel(){var t=this._opCompatScore;return xn(".0%")(t)}get _totalIncompatOps(){var t=this.graphHierarchy;return t&&t.root?t.root.compatibilityHistogram.incompatible:0}_graphHierarchyChanged(){this._templateIndex=this.graphHierarchy.getTemplateIndex(),this.graphHierarchy.addListener(Dd.TEMPLATES_UPDATED,()=>{this._templateIndex=this.graphHierarchy.getTemplateIndex()})}};as.template=Q`
    <style>
      :host {
        max-height: 500px;
      }

      .incompatible-ops-list {
        height: 350px;
        max-height: 400px;
        overflow-y: scroll;
        display: flex;
        flex-direction: column;
      }

      iron-list {
        flex: 1 1 auto;
      }

      paper-item {
        padding: 0;
        background: var(--secondary-background-color);
      }

      paper-item-body[two-line] {
        min-height: 0;
        padding: 8px 12px 4px;
      }

      .expandedInfo {
        padding: 8px 12px;
        font-weight: 500;
        font-size: 12pt;
        width: 100%;
      }

      .node-name {
        white-space: normal;
        word-wrap: break-word;
        font-size: 14pt;
        font-weight: 500;
      }

      .subtitle {
        color: var(--secondary-text-color);
        font-size: 12pt;
      }

      .toggle-button {
        float: right;
        max-height: 20px;
        max-width: 20px;
        padding: 0;
      }

      .non-control-list-item {
        padding-left: 10px;
      }

      div.op-compat-display {
        margin-top: 10px;
        display: inline-block;
      }

      /**
       * Sadly, because the whole body is inverted in color, legends also need
       * to be inverted.
       **/
      :host(.dark-mode) div.op-compat-display {
        filter: invert(1);
      }

      svg.op-compat {
        width: 250px;
        height: 25px;
        float: left;
      }

      div.op-compat-value {
        float: right;
        height: 100%;
        font-size: 14px;
        color: black;
        margin-left: 10px;
      }
    </style>

    <paper-item>
      <paper-item-body two-line>
        <div>
          <paper-icon-button
            icon="{{_getToggleIcon(_expanded)}}"
            on-click="_toggleExpanded"
            class="toggle-button"
          >
          </paper-icon-button>
          <div class="node-name" id="nodetitle">[[nodeTitle]]</div>
        </div>
        <div secondary>
          <div class="subtitle">
            <div class="op-compat-display">
              <svg
                class="op-compat"
                preserveAspectRatio="xMinYMid meet"
                viewBox="0 0 250 25"
              >
                <defs>
                  <linearGradient id="op-compat-fill">
                    <stop offset="0" stop-color$="[[_opCompatColor]]"></stop>
                    <stop
                      offset$="[[_opCompatScore]]"
                      stop-color$="[[_opCompatColor]]"
                    ></stop>
                    <stop
                      offset$="[[_opCompatScore]]"
                      stop-color$="[[_opIncompatColor]]"
                    ></stop>
                    <stop offset="1" stop-color$="[[_opIncompatColor ]]"></stop>
                  </linearGradient>
                </defs>
                <rect
                  height="25"
                  width="250"
                  rx="5"
                  ry="5"
                  style="fill: url('#op-compat-fill');"
                ></rect>
              </svg>
              <div class="op-compat-value">[[_opCompatScoreLabel]]</div>
            </div>
          </div>
        </div>
      </paper-item-body>
    </paper-item>

    <iron-collapse opened="{{_expanded}}">
      <template is="dom-if" if="{{_expanded}}" restamp="true">
        <div class="expandedInfo">
          Incompatible Operations: (<span>[[_totalIncompatOps]]</span>)
          <iron-list
            class="incompatible-ops-list"
            id="incompatibleOpsList"
            items="[[_incompatibleOpNodes]]"
          >
            <template>
              <tf-graph-op-compat-list-item
                class="non-control-list-item"
                item-node="[[item]]"
                item-render-info="[[_getRenderInfo(item.name, renderHierarchy)]]"
                name="[[item.name]]"
                template-index="[[_templateIndex]]"
                color-by="[[colorBy]]"
                item-type="incompatible-ops"
              >
              </tf-graph-op-compat-list-item>
            </template>
          </iron-list>
        </div>
      </template>
    </iron-collapse>
  `;E([A({type:Object}),w("design:type",os)],as.prototype,"graphHierarchy",void 0);E([A({type:Object}),w("design:type",lo)],as.prototype,"renderHierarchy",void 0);E([A({type:String}),w("design:type",String)],as.prototype,"nodeTitle",void 0);E([A({type:Boolean}),w("design:type",Boolean)],as.prototype,"_expanded",void 0);E([A({type:String}),w("design:type",String)],as.prototype,"_opCompatColor",void 0);E([A({type:String}),w("design:type",String)],as.prototype,"_opIncompatColor",void 0);E([A({type:Object}),w("design:type",Object)],as.prototype,"_templateIndex",void 0);E([Rt("graphHierarchy"),w("design:type",Array),w("design:paramtypes",[])],as.prototype,"_incompatibleOpNodes",null);E([Rt("graphHierarchy"),w("design:type",Number),w("design:paramtypes",[])],as.prototype,"_opCompatScore",null);E([Rt("_opCompatScore"),w("design:type",String),w("design:paramtypes",[])],as.prototype,"_opCompatScoreLabel",null);E([Rt("graphHierarchy"),w("design:type",Number),w("design:paramtypes",[])],as.prototype,"_totalIncompatOps",null);E([Bt("graphHierarchy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],as.prototype,"_graphHierarchyChanged",null);as=E([yt("tf-graph-op-compat-card")],as);var l3=Ee(Oe(),1);var Wc=class extends Gt(_o(mt)){_itemTypeChanged(){this.itemType!=="subnode"?this.$["list-item"].classList.add("clickable"):this.$["list-item"].classList.remove("clickable")}_nodeListener(t){this.fire("node-list-item-"+t.type,{cardNode:this.cardNode.name,nodeName:this.name,type:this.itemType})}_fadedClass(t){return t&&t.isFadedOut?"faded":""}};Wc.template=Q`
    <style>
      #list-item {
        width: 100%;
        color: var(--secondary-text-color);
        font-size: 11pt;
        font-weight: 400;
        position: relative;
        display: inline-block;
      }

      #list-item:hover {
        background-color: var(--google-yellow-100);
      }

      :host(.dark-mode) #list-item:hover {
        background-color: var(--paper-yellow-900);
        color: #fff;
      }

      .clickable {
        cursor: pointer;
      }

      #list-item span {
        margin-left: 40px;
      }

      #list-item.excluded span {
        color: #999;
      }

      #list-item span.edge-label {
        float: right;
        font-size: 10px;
        margin-left: 3px;
        margin-right: 5px;
      }

      .node-icon {
        position: absolute;
        top: 1px;
        left: 2px;
      }

      .faded span {
        color: var(--tb-graph-faded);
      }
    </style>
    <div
      id="list-item"
      on-mouseover="_nodeListener"
      on-mouseout="_nodeListener"
      on-click="_nodeListener"
    >
      <div class$="{{_fadedClass(itemRenderInfo)}}">
        <tf-node-icon
          class="node-icon"
          height="12"
          color-by="[[colorBy]]"
          color-by-params="[[colorByParams]]"
          node="[[itemNode]]"
          render-info="[[itemRenderInfo]]"
          template-index="[[templateIndex]]"
        ></tf-node-icon>
        <span title$="[[name]]">[[name]]</span>
        <span class="edge-label">[[edgeLabel]]</span>
      </div>
    </div>
  `;E([A({type:Object}),w("design:type",Object)],Wc.prototype,"cardNode",void 0);E([A({type:Object}),w("design:type",Object)],Wc.prototype,"itemNode",void 0);E([A({type:String}),w("design:type",String)],Wc.prototype,"edgeLabel",void 0);E([A({type:Object}),w("design:type",Object)],Wc.prototype,"itemRenderInfo",void 0);E([A({type:String}),w("design:type",String)],Wc.prototype,"name",void 0);E([A({type:String,observer:"_itemTypeChanged"}),w("design:type",String)],Wc.prototype,"itemType",void 0);E([A({type:String}),w("design:type",String)],Wc.prototype,"colorBy",void 0);E([A({type:Object}),w("design:type",Object)],Wc.prototype,"colorByParams",void 0);E([A({type:Object}),w("design:type",Object)],Wc.prototype,"templateIndex",void 0);Wc=E([yt("tf-node-list-item")],Wc);var dn=class extends Gt(mt){constructor(){super(...arguments),this._expanded=!0,this._openedControlPred=!1,this._openedControlSucc=!1,this._templateIndex=null}expandNode(){this.fire("_node.expand",this.node)}_getNode(t,r){return r.node(t)}_getNodeStats(t,r){var n=this._getNode(t,r);return n?n.stats:null}_getTotalMicros(t){return t?t.getTotalMicros():0}get _hasDisplayableNodeStats(){var t=this._nodeStats;return mH(t)}get _nodeStatsFormattedBytes(){var t=this._nodeStats;if(!(!t||!t.totalBytes))return Nd(t.totalBytes,nP)}get _nodeStatsFormattedComputeTime(){var t=this._nodeStats;if(!(!t||!t.getTotalMicros()))return Nd(t.getTotalMicros(),iP)}get _nodeStatsFormattedOutputSizes(){var t=this._nodeStats;if(!(!t||!t.outputSize||!t.outputSize.length))return l3.map(t.outputSize,function(r){return r.length===0?"scalar":"["+r.join(", ")+"]"})}_getRenderInfo(t,r){return this.renderHierarchy.getOrCreateRenderNodeByName(t)}get _attributes(){var t=this._node;if(this.async(this._resizeList.bind(this,"#attributesList")),!t||!t.attr)return[];var r=[];return l3.each(t.attr,function(n){n.key===Qse?r=r.concat(n.value.list.s.map(function(i){return{key:i,value:"Too large to show..."}})):r.push({key:n.key,value:JSON.stringify(n.value)})}),r}get _device(){var t=this._node;return t?t.device:null}get _successors(){var t=this._node,r=this.graphHierarchy;return this._refreshNodeItemList("inputsList"),t?this._convertEdgeListToEdgeInfoList(r.getSuccessors(t.name),!1,t.isGroupNode):{regular:[],control:[]}}get _predecessors(){var t=this._node,r=this.graphHierarchy;return this._refreshNodeItemList("outputsList"),t?this._convertEdgeListToEdgeInfoList(r.getPredecessors(t.name),!0,t.isGroupNode):{regular:[],control:[]}}get _functionUsages(){var t=this._node,r=this.graphHierarchy;if(this._refreshNodeItemList("functionUsagesList"),!t||t.type!==jt.META)return[];let n=r.libraryFunctions[t.associatedFunction];return n?n.usages:[]}_refreshNodeItemList(t){this.async(this._resizeList.bind(this,`#${t}`))}_convertEdgeListToEdgeInfoList(t,r,n){var i=a=>l3.map(a.baseEdgeList,s=>{var l=r?s.v:s.w;return{name:l,node:this._getNode(l,this.graphHierarchy),edgeLabel:jlt(s,this.renderHierarchy),renderInfo:this._getRenderInfo(l,this.renderHierarchy)}}),o=function(a){var s=[];return l3.each(a,l=>{var c=r?l.v:l.w;!n||l.baseEdgeList.length==1?s=s.concat(i(l)):s.push({name:c,node:this._getNode(c,this.graphHierarchy),edgeLabel:Xlt(l,this.renderHierarchy),renderInfo:this._getRenderInfo(c,this.renderHierarchy)})}),s}.bind(this);return{regular:o(t.regular),control:o(t.control)}}get _subnodes(){var t=this._node;return t&&t.metagraph?t.metagraph.nodes():null}get _totalPredecessors(){var t=this._predecessors;return t.regular.length+t.control.length}get _totalSuccessors(){var t=this._successors;return t.regular.length+t.control.length}_toggleControlPred(){this._openedControlPred=!this._openedControlPred}_toggleControlSucc(){this._openedControlSucc=!this._openedControlSucc}_toggleExpanded(){this._expanded=!this._expanded}_getToggleIcon(t){return t?"expand-less":"expand-more"}_resetState(){this._openedControlPred=!1,this._openedControlSucc=!1,this.set("_groupButtonText",tct(this._node))}_resizeList(t){var r=document.querySelector(t);r&&r.fire("iron-resize")}_toggleInclude(){this.fire("node-toggle-inclusion",{name:this.graphNodeName})}_nodeIncludeStateChanged(t,r){this.set("_auxButtonText",_H(t))}_toggleGroup(){var t=PH(this._node);this.fire("node-toggle-seriesgroup",{name:t})}_isLibraryFunction(t){return t&&t.name.startsWith(Sa)}_isInSeries(t){return Qlt(t)}_graphHierarchyChanged(){this._templateIndex=this.graphHierarchy.getTemplateIndex(),this.graphHierarchy.addListener(Dd.TEMPLATES_UPDATED,()=>{this._templateIndex=this.graphHierarchy.getTemplateIndex()})}};dn.template=Q`
    <style>
      .sub-list-group {
        font-weight: 500;
        font-size: 12pt;
        padding-bottom: 8px;
        width: 100%;
      }

      .sub-list {
        max-height: 300px;
        overflow-y: scroll;
      }

      .attr-left {
        float: left;
        width: 30%;
        word-wrap: break-word;
        color: var(--secondary-text-color);
        font-size: 11pt;
        font-weight: 400;
      }

      .attr-right {
        margin-left: 30%;
        word-wrap: break-word;
        color: var(--secondary-text-color);
        font-weight: 400;
      }

      .sub-list-table {
        display: table;
        width: 100%;
      }

      .sub-list-table-row {
        display: table-row;
      }

      .sub-list-table-row .sub-list-table-cell:last-child {
        text-align: right;
      }

      .sub-list-table-cell {
        color: var(--secondary-text-color);
        display: table-cell;
        font-size: 11pt;
        font-weight: 400;
        max-width: 200px;
        padding: 0 4px;
      }

      paper-item {
        padding: 0;
        background: var(--primary-background-color);
      }

      paper-item-body[two-line] {
        min-height: 0;
        padding: 8px 12px 4px;
      }

      .expandedInfo {
        padding: 8px 12px;
      }

      .controlDeps {
        padding: 0 0 0 8px;
      }

      .node-name {
        white-space: normal;
        word-wrap: break-word;
        font-size: 14pt;
        font-weight: 500;
      }

      .node-icon {
        float: right;
      }

      .subtitle {
        color: var(--secondary-text-color);
        font-size: 12pt;
      }

      .controlLine {
        font-size: 11pt;
        font-weight: 400;
      }

      .toggle-button {
        float: right;
        max-height: 20px;
        max-width: 20px;
        padding: 0;
      }

      .control-toggle-button {
        float: left;
        max-height: 20px;
        max-width: 20px;
        padding: 0;
      }

      .toggle-include-group {
        padding-top: 4px;
      }

      .toggle-include {
        margin: 5px 6px;
        text-transform: none;
        padding: 4px 6px;
        font-size: 10pt;
        background-color: #fafafa;
        color: #666;
      }

      .toggle-include:hover {
        background-color: var(--google-yellow-100);
      }

      .non-control-list-item {
        padding-left: 10px;
      }
    </style>
    <paper-item>
      <paper-item-body two-line>
        <div>
          <paper-icon-button
            icon="{{_getToggleIcon(_expanded)}}"
            on-click="_toggleExpanded"
            class="toggle-button"
          >
          </paper-icon-button>
          <div class="node-name">
            <tf-wbr-string value="[[_node.name]]" delimiter-pattern="/">
            </tf-wbr-string>
          </div>
        </div>
        <div secondary>
          <tf-node-icon
            class="node-icon"
            node="[[_node]]"
            render-info="[[_getRenderInfo(graphNodeName, renderHierarchy)]]"
            color-by="[[colorBy]]"
            template-index="[[_templateIndex]]"
          ></tf-node-icon>
          <template is="dom-if" if="{{_node.op}}">
            <div class="subtitle">
              Operation:
              <span>[[_node.op]]</span>
            </div>
          </template>
          <template is="dom-if" if="{{_node.metagraph}}">
            <div class="subtitle">
              Subgraph:
              <span>[[_node.cardinality]]</span> nodes
            </div>
          </template>
        </div>
      </paper-item-body>
    </paper-item>
    <iron-collapse opened="{{_expanded}}">
      <template is="dom-if" if="{{_expanded}}" restamp="true">
        <div class="expandedInfo">
          <div class="sub-list-group attributes">
            Attributes (<span>[[_attributes.length]]</span>)
            <iron-list
              class="sub-list"
              id="attributesList"
              items="[[_attributes]]"
            >
              <template>
                <div>
                  <div class="attr-left">[[item.key]]</div>
                  <div class="attr-right">[[item.value]]</div>
                </div>
              </template>
            </iron-list>
          </div>

          <template is="dom-if" if="{{_device}}">
            <div class="sub-list-group device">
              <div class="attr-left">Device</div>
              <div class="attr-right">[[_device]]</div>
            </div>
          </template>

          <div class="sub-list-group predecessors">
            Inputs (<span>[[_totalPredecessors]]</span>)
            <iron-list
              class="sub-list"
              id="inputsList"
              items="[[_predecessors.regular]]"
            >
              <template>
                <tf-node-list-item
                  class="non-control-list-item"
                  card-node="[[_node]]"
                  item-node="[[item.node]]"
                  edge-label="[[item.edgeLabel]]"
                  item-render-info="[[item.renderInfo]]"
                  name="[[item.name]]"
                  item-type="predecessors"
                  color-by="[[colorBy]]"
                  template-index="[[_templateIndex]]"
                >
                </tf-node-list-item>
              </template>
            </iron-list>
            <template is="dom-if" if="[[_predecessors.control.length]]">
              <div class="controlDeps">
                <div class="controlLine">
                  <paper-icon-button
                    icon="{{_getToggleIcon(_openedControlPred)}}"
                    on-click="_toggleControlPred"
                    class="control-toggle-button"
                  >
                  </paper-icon-button>
                  Control dependencies
                </div>
                <iron-collapse opened="{{_openedControlPred}}" no-animation>
                  <template
                    is="dom-if"
                    if="{{_openedControlPred}}"
                    restamp="true"
                  >
                    <iron-list
                      class="sub-list"
                      items="[[_predecessors.control]]"
                    >
                      <template>
                        <tf-node-list-item
                          card-node="[[_node]]"
                          item-node="[[item.node]]"
                          item-render-info="[[item.renderInfo]]"
                          name="[[item.name]]"
                          item-type="predecessors"
                          color-by="[[colorBy]]"
                          template-index="[[_templateIndex]]"
                        >
                        </tf-node-list-item>
                      </template>
                    </iron-list>
                  </template>
                </iron-collapse>
              </div>
            </template>
          </div>

          <div class="sub-list-group successors">
            Outputs (<span>[[_totalSuccessors]]</span>)
            <iron-list
              class="sub-list"
              id="outputsList"
              items="[[_successors.regular]]"
            >
              <template>
                <tf-node-list-item
                  class="non-control-list-item"
                  card-node="[[_node]]"
                  item-node="[[item.node]]"
                  edge-label="[[item.edgeLabel]]"
                  item-render-info="[[item.renderInfo]]"
                  name="[[item.name]]"
                  item-type="successor"
                  color-by="[[colorBy]]"
                  template-index="[[_templateIndex]]"
                >
                </tf-node-list-item>
              </template>
            </iron-list>
            <template is="dom-if" if="[[_successors.control.length]]">
              <div class="controlDeps">
                <div class="controlLine">
                  <paper-icon-button
                    icon="{{_getToggleIcon(_openedControlSucc)}}"
                    on-click="_toggleControlSucc"
                    class="control-toggle-button"
                  >
                  </paper-icon-button>
                  Control dependencies
                </div>
                <iron-collapse opened="{{_openedControlSucc}}" no-animation>
                  <template
                    is="dom-if"
                    if="{{_openedControlSucc}}"
                    restamp="true"
                  >
                    <iron-list class="sub-list" items="[[_successors.control]]">
                      <template>
                        <tf-node-list-item
                          card-node="[[_node]]"
                          item-node="[[item.node]]"
                          item-render-info="[[item.renderInfo]]"
                          name="[[item.name]]"
                          item-type="successors"
                          color-by="[[colorBy]]"
                          template-index="[[_templateIndex]]"
                        >
                        </tf-node-list-item>
                      </template>
                    </iron-list>
                  </template>
                </iron-collapse>
              </div>
            </template>
          </div>
          <template is="dom-if" if="{{_hasDisplayableNodeStats}}">
            <div class="sub-list-group node-stats">
              Node Stats
              <div class="sub-list-table">
                <template is="dom-if" if="{{_nodeStats.totalBytes}}">
                  <div class="sub-list-table-row">
                    <div class="sub-list-table-cell">Memory</div>
                    <div class="sub-list-table-cell">
                      [[_nodeStatsFormattedBytes]]
                    </div>
                  </div>
                </template>
                <template is="dom-if" if="{{_getTotalMicros(_nodeStats)}}">
                  <div class="sub-list-table-row">
                    <div class="sub-list-table-cell">Compute Time</div>
                    <div class="sub-list-table-cell">
                      [[_nodeStatsFormattedComputeTime]]
                    </div>
                  </div>
                </template>
                <template is="dom-if" if="{{_nodeStats.outputSize}}">
                  <div class="sub-list-table-row">
                    <div class="sub-list-table-cell">Tensor Output Sizes</div>
                    <div class="sub-list-table-cell">
                      <template
                        is="dom-repeat"
                        items="{{_nodeStatsFormattedOutputSizes}}"
                      >
                        [[item]] <br />
                      </template>
                    </div>
                  </div>
                </template>
              </div>
            </div>
          </template>

          <template is="dom-if" if="[[_functionUsages.length]]">
            <div class="sub-list-group predecessors">
              Usages of the Function (<span>[[_functionUsages.length]]</span>)
              <iron-list
                class="sub-list"
                id="functionUsagesList"
                items="[[_functionUsages]]"
              >
                <template>
                  <tf-node-list-item
                    class="non-control-list-item"
                    card-node="[[_node]]"
                    item-node="[[item]]"
                    name="[[item.name]]"
                    item-type="functionUsages"
                    color-by="[[colorBy]]"
                    template-index="[[_templateIndex]]"
                  >
                  </tf-node-list-item>
                </template>
              </iron-list>
            </div>
          </template>

          <template is="dom-if" if="[[!_isLibraryFunction(_node)]]">
            <div class="toggle-include-group">
              <paper-button
                raised
                class="toggle-include"
                on-click="_toggleInclude"
              >
                <span>[[_auxButtonText]]</span>
              </paper-button>
            </div>
          </template>

          <template is="dom-if" if="{{_isInSeries(_node)}}">
            <div class="toggle-include-group">
              <paper-button
                raised
                class="toggle-include"
                on-click="_toggleGroup"
              >
                <span>[[_groupButtonText]]</span>
              </paper-button>
            </div>
          </template>
        </div>
      </template>
    </iron-collapse>
  `;E([A({type:String}),w("design:type",String)],dn.prototype,"graphNodeName",void 0);E([A({type:Object}),w("design:type",os)],dn.prototype,"graphHierarchy",void 0);E([A({type:Object}),w("design:type",Object)],dn.prototype,"renderHierarchy",void 0);E([A({type:String}),w("design:type",String)],dn.prototype,"colorBy",void 0);E([A({type:Object,computed:"_getNode(graphNodeName, graphHierarchy)",observer:"_resetState"}),w("design:type",Object)],dn.prototype,"_node",void 0);E([A({type:Object,computed:"_getNodeStats(graphNodeName, graphHierarchy)",observer:"_resetState"}),w("design:type",Object)],dn.prototype,"_nodeStats",void 0);E([A({type:Number,observer:"_nodeIncludeStateChanged"}),w("design:type",Number)],dn.prototype,"nodeInclude",void 0);E([A({type:Boolean}),w("design:type",Boolean)],dn.prototype,"_expanded",void 0);E([A({type:Boolean}),w("design:type",Boolean)],dn.prototype,"_openedControlPred",void 0);E([A({type:Boolean}),w("design:type",Boolean)],dn.prototype,"_openedControlSucc",void 0);E([A({type:String}),w("design:type",String)],dn.prototype,"_auxButtonText",void 0);E([A({type:String}),w("design:type",String)],dn.prototype,"_groupButtonText",void 0);E([A({type:Object}),w("design:type",Function)],dn.prototype,"_templateIndex",void 0);E([Rt("_nodeStats"),w("design:type",Boolean),w("design:paramtypes",[])],dn.prototype,"_hasDisplayableNodeStats",null);E([Rt("_nodeStats"),w("design:type",Object),w("design:paramtypes",[])],dn.prototype,"_nodeStatsFormattedBytes",null);E([Rt("_nodeStats"),w("design:type",Object),w("design:paramtypes",[])],dn.prototype,"_nodeStatsFormattedComputeTime",null);E([Rt("_nodeStats"),w("design:type",Object),w("design:paramtypes",[])],dn.prototype,"_nodeStatsFormattedOutputSizes",null);E([Rt("_node"),w("design:type",Array),w("design:paramtypes",[])],dn.prototype,"_attributes",null);E([Rt("_node"),w("design:type",String),w("design:paramtypes",[])],dn.prototype,"_device",null);E([Rt("_node","graphHierarchy"),w("design:type",Object),w("design:paramtypes",[])],dn.prototype,"_successors",null);E([Rt("_node","graphHierarchy"),w("design:type",Object),w("design:paramtypes",[])],dn.prototype,"_predecessors",null);E([Rt("_node","graphHierarchy"),w("design:type",Array),w("design:paramtypes",[])],dn.prototype,"_functionUsages",null);E([Rt("_node"),w("design:type",Array),w("design:paramtypes",[])],dn.prototype,"_subnodes",null);E([Rt("_predecessors"),w("design:type",Number),w("design:paramtypes",[])],dn.prototype,"_totalPredecessors",null);E([Rt("_successors"),w("design:type",Number),w("design:paramtypes",[])],dn.prototype,"_totalSuccessors",null);E([Bt("graphHierarchy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],dn.prototype,"_graphHierarchyChanged",null);dn=E([yt("tf-node-info")],dn);var ss=class extends Gt(mt){ready(){super.ready(),this.addEventListener("node-list-item-click",this._nodeListItemClicked.bind(this)),this.addEventListener("node-list-item-mouseover",this._nodeListItemMouseover.bind(this)),this.addEventListener("node-list-item-mouseout",this._nodeListItemMouseout.bind(this))}_nodeListItemClicked(t){this.selectedNode=t.detail.nodeName}_nodeListItemMouseover(t){this.highlightedNode=t.detail.nodeName}_nodeListItemMouseout(){this.highlightedNode=null}_healthPillsAvailable(t,r){return t&&r&&Object.keys(r).length>0}_equals(t,r){return t===r}};ss.template=Q`
    <style>
      :host {
        background: var(--secondary-background-color);
        font-size: 12px;
        margin: 0;
        padding: 0;
        display: block;
        max-height: 650px;
        overflow-x: hidden;
        overflow-y: auto;
      }

      h2 {
        padding: 0;
        text-align: center;
        margin: 0;
      }
    </style>
    <template is="dom-if" if="{{selectedNode}}">
      <paper-material elevation="1" class="card">
        <tf-node-info
          graph-hierarchy="[[graphHierarchy]]"
          render-hierarchy="[[renderHierarchy]]"
          flat-graph="[[graph]]"
          graph-node-name="[[selectedNode]]"
          node-include="[[selectedNodeInclude]]"
          highlighted-node="{{highlightedNode}}"
          color-by="[[colorBy]]"
        >
        </tf-node-info>
      </paper-material>
    </template>
    <template is="dom-if" if="[[_equals(colorBy, 'op_compatibility')]]">
      <tf-graph-op-compat-card
        graph-hierarchy="[[graphHierarchy]]"
        render-hierarchy="[[renderHierarchy]]"
        color-by="[[colorBy]]"
        node-title="[[compatNodeTitle]]"
      >
      </tf-graph-op-compat-card>
    </template>
    <template
      is="dom-if"
      if="[[_healthPillsAvailable(debuggerDataEnabled, nodeNamesToHealthPills)]]"
    >
      <tf-graph-debugger-data-card
        render-hierarchy="[[renderHierarchy]]"
        debugger-numeric-alerts="[[debuggerNumericAlerts]]"
        node-names-to-health-pills="[[nodeNamesToHealthPills]]"
        selected-node="{{selectedNode}}"
        highlighted-node="{{highlightedNode}}"
        are-health-pills-loading="[[areHealthPillsLoading]]"
        all-steps-mode-enabled="{{allStepsModeEnabled}}"
        specific-health-pill-step="{{specificHealthPillStep}}"
        health-pill-step-index="{{healthPillStepIndex}}"
      >
      </tf-graph-debugger-data-card>
    </template>
  `;E([A({type:String}),w("design:type",String)],ss.prototype,"title",void 0);E([A({type:Object}),w("design:type",os)],ss.prototype,"graphHierarchy",void 0);E([A({type:Object}),w("design:type",Xu)],ss.prototype,"graph",void 0);E([A({type:Object}),w("design:type",lo)],ss.prototype,"renderHierarchy",void 0);E([A({type:Object}),w("design:type",Object)],ss.prototype,"nodeNamesToHealthPills",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],ss.prototype,"healthPillStepIndex",void 0);E([A({type:String}),w("design:type",String)],ss.prototype,"colorBy",void 0);E([A({type:String}),w("design:type",String)],ss.prototype,"compatNodeTitle",void 0);E([A({type:String,notify:!0}),w("design:type",String)],ss.prototype,"selectedNode",void 0);E([A({type:String,notify:!0}),w("design:type",String)],ss.prototype,"highlightedNode",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],ss.prototype,"selectedNodeInclude",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ss.prototype,"debuggerDataEnabled",void 0);ss=E([yt("tf-graph-info")],ss);var iur={MAX_NODE_COUNT:1e4,MAX_EDGE_COUNT:1e4},tn=class extends Gt(mt){constructor(){super(...arguments),this.hierarchyParams=r3,this.allStepsModeEnabled=!1,this.specificHealthPillStep=0,this.compatNodeTitle="TPU Compatibility"}fit(){this.$.graph.fit()}downloadAsImage(t){return Ri(this,null,function*(){let r=yield this.$.graph.getImageBlob(),n=document.createElement("a");n.href=URL.createObjectURL(r),n.download=t,n.click(),URL.revokeObjectURL(n.href)})}_isNotComplete(t){return t.value<100}_getContainerClass(t){var r="container";return t.error&&(r+=" error"),this._isNotComplete(t)&&(r+=" loading"),r}_onNodeInclusionToggled(t){this.$.graph.nodeToggleExtract(t.detail.name)}_onNodeSeriesGroupToggled(t){this.$.graph.nodeToggleSeriesGroup(t.detail.name)}_updateNodeInclude(){let t=this.renderHierarchy?this.renderHierarchy.getNodeByName(this.selectedNode):null;this._selectedNodeInclude=t?t.include:ur.UNSPECIFIED}_slimGraphChanged(){if(!this.graph)return;let{MAX_NODE_COUNT:t,MAX_EDGE_COUNT:r}=iur;Object.keys(this.graph.nodes).length>t&&this.graph.edges.length>r&&this.colorBy===Gn.STRUCTURE&&(this.colorBy=Gn.NONE)}_ensureTemplates(){!this.graphHierarchy||this.colorBy!==Gn.STRUCTURE||this.graphHierarchy.getTemplateIndex()||this.graphHierarchy.updateTemplates()}};tn.template=Q`
    <style>
      ::host {
        display: block;
      }

      /deep/ .close {
        position: absolute;
        cursor: pointer;
        left: 15px;
        bottom: 15px;
      }

      .container {
        width: 100%;
        height: 100%;
        opacity: 1;
      }

      .container.loading {
        cursor: progress;
        opacity: 0.1;
      }

      .container.loading.error {
        cursor: auto;
      }

      #info {
        position: absolute;
        right: 5px;
        top: 5px;
        padding: 0px;
        max-width: 380px;
        min-width: 320px;
        background-color: rgba(255, 255, 255, 0.9);
        @apply --shadow-elevation-2dp;
      }

      #main {
        width: 100%;
        height: 100%;
      }

      #progress-bar {
        display: flex;
        flex-direction: column;
        align-items: center;
        justify-content: center;
        width: 100%;
        position: absolute;
        top: 40px;
        left: 0;
        font-size: 13px;
      }

      #progress-msg {
        margin-bottom: 5px;
        white-space: pre-wrap;
        width: 400px;
      }

      paper-progress {
        width: 400px;
        --paper-progress-height: 6px;
        --paper-progress-active-color: #f3913e;
      }

      .context-menu {
        position: absolute;
        display: none;
        background-color: #e2e2e2;
        border-radius: 2px;
        font-size: 14px;
        min-width: 150px;
        border: 1px solid #d4d4d4;
      }

      /deep/ .context-menu ul {
        list-style-type: none;
        margin: 0;
        padding: 0;
        cursor: default;
      }

      /deep/ .context-menu ul li {
        padding: 4px 16px;
      }

      /deep/ .context-menu ul li:hover {
        background-color: #f3913e;
        color: white;
      }
    </style>
    <template is="dom-if" if="[[_isNotComplete(progress)]]">
      <div id="progress-bar">
        <div id="progress-msg">[[progress.msg]]</div>
        <paper-progress value="[[progress.value]]"></paper-progress>
      </div>
    </template>
    <div class$="[[_getContainerClass(progress)]]">
      <div id="main">
        <tf-graph
          id="graph"
          graph-hierarchy="{{graphHierarchy}}"
          basic-graph="[[graph]]"
          hierarchy-params="[[hierarchyParams]]"
          render-hierarchy="{{renderHierarchy}}"
          devices-for-stats="[[devicesForStats]]"
          stats="[[stats]]"
          selected-node="{{selectedNode}}"
          highlighted-node="{{_highlightedNode}}"
          color-by="[[colorBy]]"
          color-by-params="{{colorByParams}}"
          progress="{{progress}}"
          edge-label-function="[[edgeLabelFunction]]"
          edge-width-function="[[edgeWidthFunction]]"
          node-names-to-health-pills="[[nodeNamesToHealthPills]]"
          health-pill-step-index="[[healthPillStepIndex]]"
          handle-node-selected="[[handleNodeSelected]]"
          handle-edge-selected="[[handleEdgeSelected]]"
          trace-inputs="[[traceInputs]]"
          auto-extract-nodes="[[autoExtractNodes]]"
        ></tf-graph>
      </div>
      <div id="info">
        <tf-graph-info
          id="graph-info"
          title="selected"
          graph-hierarchy="[[graphHierarchy]]"
          render-hierarchy="[[renderHierarchy]]"
          graph="[[graph]]"
          selected-node="{{selectedNode}}"
          selected-node-include="{{_selectedNodeInclude}}"
          highlighted-node="{{_highlightedNode}}"
          color-by="[[colorBy]]"
          color-by-params="[[colorByParams]]"
          debugger-data-enabled="[[debuggerDataEnabled]]"
          are-health-pills-loading="[[areHealthPillsLoading]]"
          debugger-numeric-alerts="[[debuggerNumericAlerts]]"
          node-names-to-health-pills="[[nodeNamesToHealthPills]]"
          all-steps-mode-enabled="{{allStepsModeEnabled}}"
          specific-health-pill-step="{{specificHealthPillStep}}"
          health-pill-step-index="{{healthPillStepIndex}}"
          compat-node-title="[[compatNodeTitle]]"
          on-node-toggle-inclusion="_onNodeInclusionToggled"
          on-node-toggle-seriesgroup="_onNodeSeriesGroupToggled"
        ></tf-graph-info>
      </div>
    </div>
  `;E([A({type:Object}),w("design:type",os)],tn.prototype,"graphHierarchy",void 0);E([A({type:Object}),w("design:type",Xu)],tn.prototype,"graph",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"hierarchyParams",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"stats",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"progress",void 0);E([A({type:Boolean}),w("design:type",Boolean)],tn.prototype,"traceInputs",void 0);E([A({type:Boolean}),w("design:type",Boolean)],tn.prototype,"autoExtractNodes",void 0);E([A({type:String,notify:!0}),w("design:type",String)],tn.prototype,"colorBy",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],tn.prototype,"colorByParams",void 0);E([A({type:Object,notify:!0}),w("design:type",lo)],tn.prototype,"renderHierarchy",void 0);E([A({type:Boolean}),w("design:type",Boolean)],tn.prototype,"debuggerDataEnabled",void 0);E([A({type:Boolean}),w("design:type",Boolean)],tn.prototype,"areHealthPillsLoading",void 0);E([A({type:Array,notify:!0}),w("design:type",Array)],tn.prototype,"debuggerNumericAlerts",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"nodeNamesToHealthPills",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],tn.prototype,"allStepsModeEnabled",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],tn.prototype,"specificHealthPillStep",void 0);E([A({type:Number}),w("design:type",Number)],tn.prototype,"healthPillStepIndex",void 0);E([A({type:String,notify:!0}),w("design:type",String)],tn.prototype,"selectedNode",void 0);E([A({type:String}),w("design:type",String)],tn.prototype,"compatNodeTitle",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"edgeWidthFunction",void 0);E([A({type:Number}),w("design:type",Number)],tn.prototype,"_selectedNodeInclude",void 0);E([A({type:String}),w("design:type",String)],tn.prototype,"_highlightedNode",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"handleNodeSelected",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"edgeLabelFunction",void 0);E([A({type:Object}),w("design:type",Object)],tn.prototype,"handleEdgeSelected",void 0);E([Bt("selectedNode","renderHierarchy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],tn.prototype,"_updateNodeInclude",null);E([Bt("graph"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],tn.prototype,"_slimGraphChanged",null);E([Bt("colorBy","graphHierarchy"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],tn.prototype,"_ensureTemplates",null);tn=E([yt("tf-graph-board")],tn);var c3=Ee(Oe(),1);var Ju=class{isNotTpuOp(t){return t.toLowerCase().search("cpu:")!=-1||t.toLowerCase().search("gpu:")!=-1?!0:t.toLowerCase().search("tpu")==-1}opValid(t){return t.name.search(Sa)==0||!t.op||t.device&&this.isNotTpuOp(t.device)||t.device&&t.device.search("TPU_SYSTEM")!=-1?!0:c3.includes(Ju.WHITELIST,t.op)}};Ju.WHITELIST=["Abs","Acos","Acosh","Add","AddN","AddV2","AdjustContrastv2","AdjustHue","AdjustSaturation","All","AllToAll","Angle","Any","ApproximateEqual","ArgMax","ArgMin","Asin","Asinh","Assert","AssignAddVariableOp","AssignSubVariableOp","AssignVariableOp","Atan","Atan2","Atanh","AvgPool","AvgPool3D","AvgPool3DGrad","AvgPoolGrad","BatchMatMul","BatchMatMulV2","BatchToSpace","BatchToSpaceND","BesselI0e","BesselI1e","Betainc","BiasAdd","BiasAddGrad","BiasAddV1","Bitcast","BitwiseAnd","BitwiseOr","BitwiseXor","BroadcastArgs","BroadcastGradientArgs","BroadcastTo","Bucketize","Case","Cast","Ceil","CheckNumerics","Cholesky","ClipByValue","CollectivePermute","CollectiveReduceV2","Complex","ComplexAbs","Concat","ConcatOffset","ConcatV2","Conj","ConjugateTranspose","Const","ControlTrigger","Conv2D","Conv2DBackpropFilter","Conv2DBackpropInput","Conv3D","Conv3DBackpropFilterV2","Conv3DBackpropInputV2","Cos","Cosh","Cross","CrossReplicaSum","Cumprod","Cumsum","DataFormatDimMap","DataFormatVecPermute","DepthToSpace","DepthwiseConv2dNative","DepthwiseConv2dNativeBackpropFilter","DepthwiseConv2dNativeBackpropInput","Dequantize","DeviceIndex","Diag","DiagPart","Digamma","Div","DivNoNan","DynamicStitch","Einsum","Elu","EluGrad","Empty","EmptyTensorList","EnsureShape","Equal","Erf","Erfc","Erfinv","Exp","ExpandDims","Expm1","ExtractImagePatches","FFT","FFT2D","FFT3D","FakeParam","FakeQuantWithMinMaxArgs","FakeQuantWithMinMaxArgsGradient","FakeQuantWithMinMaxVars","FakeQuantWithMinMaxVarsGradient","Fill","Floor","FloorDiv","FloorMod","FusedBatchNorm","FusedBatchNormGrad","FusedBatchNormGradV2","FusedBatchNormGradV3","FusedBatchNormV2","FusedBatchNormV3","Gather","GatherNd","GatherV2","GetItem","Greater","GreaterEqual","HSVToRGB","IFFT","IFFT2D","IFFT3D","IRFFT","IRFFT2D","IRFFT3D","Identity","IdentityN","If","Igamma","IgammaGradA","Igammac","Imag","InTopKV2","InfeedDequeue","InfeedDequeueTuple","InplaceAdd","InplaceUpdate","Inv","Invert","InvertPermutation","IsFinite","IsInf","IsNan","KthOrderStatistic","L2Loss","LRN","LRNGrad","LeakyRelu","LeakyReluGrad","LeftShift","Less","LessEqual","Lgamma","LinSpace","ListDiff","Log","Log1p","LogSoftmax","LogicalAnd","LogicalNot","LogicalOr","LowerBound","MakeUnique","MatMul","MatrixBandPart","MatrixDiag","MatrixDiagPart","MatrixDiagPartV2","MatrixDiagPartV3","MatrixDiagV2","MatrixDiagV3","MatrixInverse","MatrixSetDiag","MatrixSetDiagV2","MatrixSetDiagV3","MatrixSolve","MatrixTriangularSolve","Max","MaxPool","MaxPool3D","MaxPool3DGrad","MaxPool3DGradGrad","MaxPoolGrad","MaxPoolGradGrad","MaxPoolGradGradV2","MaxPoolGradV2","MaxPoolV2","Maximum","Mean","Min","Minimum","MirrorPad","MirrorPadGrad","Mod","Mul","MulNoNan","Multinomial","Ndtri","Neg","NextAfter","NoOp","NonMaxSuppressionV4","NotEqual","OneHot","OnesLike","OutfeedEnqueue","OutfeedEnqueueTuple","Pack","Pad","PadV2","ParallelDynamicStitch","ParameterizedTruncatedNormal","PartitionedCall","PlaceholderWithDefault","Polygamma","PopulationCount","Pow","PreventGradient","Prod","Qr","QuantizeAndDequantizeV2","QuantizeAndDequantizeV3","RFFT","RFFT2D","RFFT3D","RGBToHSV","RandomGammaGrad","RandomShuffle","RandomStandardNormal","RandomUniform","RandomUniformInt","Range","Rank","ReadVariableOp","Real","RealDiv","Reciprocal","ReciprocalGrad","Relu","Relu6","Relu6Grad","ReluGrad","Reshape","ResizeBilinear","ResizeBilinearGrad","ResizeNearestNeighbor","ResizeNearestNeighborGrad","ResourceApplyAdaMax","ResourceApplyAdadelta","ResourceApplyAdagrad","ResourceApplyAdagradDA","ResourceApplyAdagradV2","ResourceApplyAdam","ResourceApplyAddSign","ResourceApplyCenteredRMSProp","ResourceApplyFtrl","ResourceApplyFtrlV2","ResourceApplyGradientDescent","ResourceApplyKerasMomentum","ResourceApplyMomentum","ResourceApplyPowerSign","ResourceApplyProximalAdagrad","ResourceApplyProximalGradientDescent","ResourceApplyRMSProp","ResourceGather","ResourceScatterAdd","ResourceScatterDiv","ResourceScatterMax","ResourceScatterMin","ResourceScatterMul","ResourceScatterNdAdd","ResourceScatterNdSub","ResourceScatterNdUpdate","ResourceScatterSub","ResourceScatterUpdate","ResourceStridedSliceAssign","Reverse","ReverseSequence","ReverseV2","RightShift","Rint","RngReadAndSkip","RngSkip","Roll","Round","Rsqrt","RsqrtGrad","ScatterNd","Select","SelectV2","SelfAdjointEigV2","Selu","SeluGrad","Shape","ShapeN","Sigmoid","SigmoidGrad","Sign","Sin","Sinh","Size","Slice","Snapshot","Softmax","SoftmaxCrossEntropyWithLogits","Softplus","SoftplusGrad","Softsign","SoftsignGrad","SpaceToBatch","SpaceToBatchND","SpaceToDepth","SparseMatMul","SparseSoftmaxCrossEntropyWithLogits","SparseToDense","Split","SplitV","Sqrt","SqrtGrad","Square","SquaredDifference","Squeeze","StackCloseV2","StackPopV2","StackPushV2","StackV2","StatefulPartitionedCall","StatefulStandardNormalV2","StatefulTruncatedNormal","StatefulUniform","StatefulUniformFullInt","StatefulUniformInt","StatelessCase","StatelessIf","StatelessMultinomial","StatelessRandomGetAlg","StatelessRandomGetKeyCounter","StatelessRandomGetKeyCounterAlg","StatelessRandomNormal","StatelessRandomNormalV2","StatelessRandomUniform","StatelessRandomUniformFullInt","StatelessRandomUniformFullIntV2","StatelessRandomUniformInt","StatelessRandomUniformIntV2","StatelessRandomUniformV2","StatelessTruncatedNormal","StatelessTruncatedNormalV2","StatelessWhile","StopGradient","StridedSlice","StridedSliceGrad","Sub","Sum","Svd","SymbolicGradient","TPUEmbeddingActivations","Tan","Tanh","TanhGrad","TensorArrayCloseV3","TensorArrayConcatV3","TensorArrayGatherV3","TensorArrayGradV3","TensorArrayReadV3","TensorArrayScatterV3","TensorArraySizeV3","TensorArraySplitV3","TensorArrayV3","TensorArrayWriteV3","TensorListConcatV2","TensorListElementShape","TensorListFromTensor","TensorListGather","TensorListGetItem","TensorListLength","TensorListPopBack","TensorListPushBack","TensorListReserve","TensorListSetItem","TensorListSplit","TensorListStack","TensorScatterAdd","TensorScatterMax","TensorScatterMin","TensorScatterSub","TensorScatterUpdate","TensorStridedSliceUpdate","Tile","TopKUnique","TopKV2","TopKWithUnique","Transpose","TridiagonalSolve","TruncateDiv","TruncateMod","TruncatedNormal","Unique","Unpack","UnsortedSegmentMax","UnsortedSegmentMin","UnsortedSegmentProd","UnsortedSegmentSum","UpperBound","VarIsInitializedOp","VariableShape","Where","While","Xdivy","XlaBroadcastHelper","XlaConv","XlaConvV2","XlaDequantize","XlaDot","XlaDotV2","XlaDynamicSlice","XlaDynamicUpdateSlice","XlaEinsum","XlaGather","XlaHostCompute","XlaIf","XlaKeyValueSort","XlaPad","XlaRecv","XlaRecvFromHost","XlaReduce","XlaReduceWindow","XlaReplicaId","XlaScatter","XlaSelectAndScatter","XlaSelfAdjointEig","XlaSend","XlaSendToHost","XlaSetBound","XlaSetDynamicDimensionSize","XlaSharding","XlaSort","XlaSpmdFullToShardShape","XlaSpmdShardToFullShape","XlaSvd","XlaVariadicReduce","XlaVariadicSort","XlaWhile","Xlog1py","Xlogy","ZerosLike","Zeta","Enter","Exit","LoopCond","Merge","NextIteration","Switch","_Arg","_ArrayToList","_FusedBatchNormEx","_ListToArray","_ParallelConcatUpdate","_RecvTPUEmbeddingActivations","_RecvTPUEmbeddingDeduplicationData","_Retval","_SendTPUEmbeddingGradients","_TPUCompile","_TPUExecute","_UnaryOpsComposition","TPUCompilationResult","TPUReplicatedInput","TPUReplicatedOutput","TPUReplicateMetadata","MergeV2Checkpoints","RestoreV2","SaveV2","Abort","Assert","Assign","Placeholder","PlaceholderV2","ShardedFilename","StringJoin","Variable","VariableV2","VarHandleOp","AudioSummary","AudioSummaryV2","DebugNumericSummary","HistogramSummary","ImageSummary","MergeSummary","ScalarSummary","StatsAggregatorSummary"];function Yle(e,t){if(t===null)throw new Error("Compatibility provider required, but got: "+t);c3.each(e.nodes,r=>{r.compatible=t.opValid(r),c3.each(r.inEmbeddings,n=>{n.compatible=t.opValid(n)}),c3.each(r.outEmbeddings,n=>{n.compatible=t.opValid(n)})})}var mP=Ee(Oe(),1);var jle=Ee(Oe(),1);var Il=class extends Gt(mt){constructor(){super(...arguments),this._rawRegexInput="",this._previousRegexInput="",this._searchTimeoutDelay=150,this._maxRegexResults=42}get _regexInput(){var t=this.renderHierarchy,r=this._rawRegexInput;return r.trim()}_regexInputChanged(){var t=this._regexInput;this._requestSearch()}_clearSearchResults(){this.set("_regexMatches",[])}_requestSearch(){if(!this._searchPending){if(this._regexInput===this._previousRegexInput){this._searchPending=!1;return}this._searchPending=!0,this._executeSearch(),this.async(()=>{this._searchPending=!1,this._requestSearch()},this._searchTimeoutDelay)}}_executeSearch(){if(this._previousRegexInput=this._regexInput,!this._regexInput){this._clearSearchResults();return}try{var t=new RegExp(this._regexInput)}catch(i){this._clearSearchResults();return}let r=[],n=this.renderHierarchy.hierarchy.getNodeMap();jle.each(n,(i,o)=>{if(r.length>=this._maxRegexResults)return!1;!t.test(o)||r.push(o)}),this.set("_regexMatches",r)}_matchClicked(t){let r=t.model.item;this.set("selectedNode",r),Po({actionId:jr.NODE_SEARCH_RESULT_FOCUSED})}};Il.template=Q`
    <div id="search-container">
      <paper-input
        id="runs-regex"
        label="Search nodes (regex)"
        value="{{_rawRegexInput}}"
      >
      </paper-input>
      <div id="search-results-anchor">
        <div id="search-results">
          <template is="dom-repeat" items="[[_regexMatches]]">
            <div id="search-match" on-click="_matchClicked">[[item]]</div>
          </template>
        </div>
      </div>
    </div>
    <style>
      #search-container {
        width: 100%;
        overflow: visible;
      }

      #runs-regex {
        width: 100%;
      }

      #search-results-anchor {
        position: relative;
      }

      #search-results {
        color: #fff;
        position: absolute;
        max-height: 200px;
        overflow-x: hidden;
        overflow-y: auto;
        text-align: right;
        max-width: 100%;
        box-sizing: border-box;
      }

      #search-match {
        background: var(--tb-orange-strong);
        padding: 3px;
        float: right;
        width: 100%;
        box-sizing: border-box;
        direction: rtl;
      }

      #search-match:hover {
        background: var(--tb-orange-weak);
        cursor: pointer;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],Il.prototype,"renderHierarchy",void 0);E([A({type:String,notify:!0}),w("design:type",String)],Il.prototype,"selectedNode",void 0);E([A({type:String}),w("design:type",String)],Il.prototype,"_rawRegexInput",void 0);E([A({type:String}),w("design:type",String)],Il.prototype,"_previousRegexInput",void 0);E([A({type:Number}),w("design:type",Number)],Il.prototype,"_searchTimeoutDelay",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Il.prototype,"_searchPending",void 0);E([A({type:Number}),w("design:type",Number)],Il.prototype,"_maxRegexResults",void 0);E([A({type:Array}),w("design:type",Array)],Il.prototype,"_regexMatches",void 0);E([Rt("renderHierarchy","_rawRegexInput"),w("design:type",String),w("design:paramtypes",[])],Il.prototype,"_regexInput",null);E([Bt("_regexInput"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Il.prototype,"_regexInputChanged",null);Il=E([yt("tf-graph-node-search")],Il);var cct=/device:([^:]+:[0-9]+)$/,lct=[{regex:cct}],Xle=[],our=new Set([Gn.COMPUTE_TIME,Gn.MEMORY]),In=class extends Gt(_o(mt)){constructor(){super(...arguments),this.ColorBy=Gn,this.stats=null,this.devicesForStats=null,this.colorBy=Gn.STRUCTURE,this.datasets=[],this._selectedRunIndex=0,this.traceInputs=!1,this.autoExtractNodes=!0,this._selectedTagIndex=0,this._selectedGraphType=Fs.OP_GRAPH,this.showSessionRunsDropdown=!0,this.showUploadButton=!0,this._legendOpened=!0,this._downloadFilename="graph.png"}_onGraphTypeChangedByUserGesture(){Po({actionId:jr.GRAPH_TYPE_CHANGED,eventLabel:this._selectedGraphType})}_onColorByChangedByUserGesture(){Po({actionId:jr.NODE_COLOR_MODE_CHANGED,eventLabel:this.colorBy})}_onTraceInputsChangedByUserGesture(){Po({actionId:jr.TRACE_INPUT_MODE_TOGGLED})}_xlaClustersProvided(t){return t&&t.hierarchy&&t.hierarchy.xlaClusters.length>0}_statsChanged(t){if(t!=null){var r={},n=mP.each(t.dev_stats,function(i){var o=mP.some(lct,function(s){return s.regex.test(i.device)}),a=mP.some(Xle,function(s){return s.regex.test(i.device)});o&&!a&&(r[i.device]=!0)});this.set("devicesForStats",r)}}get _currentDevices(){var t=this.devicesForStats;let r=this.stats,o=(r?r.dev_stats:[]).map(s=>s.device).filter(s=>lct.some(l=>l.regex.test(s))),a=Flt(o);if(a.length==1){let s=a[0].match(cct);s&&(a[0]=s[1])}return o.map((s,l)=>{let c=null;return Xle.forEach(u=>{u.regex.test(s)&&(c=u.msg)}),{device:s,suffix:a[l],used:t==null?void 0:t[s],ignoredMsg:c}})}_deviceCheckboxClicked(t){let r=t.target,n=Object.assign({},this.devicesForStats),i=r.value;r.checked?n[i]=!0:delete n[i],this.set("devicesForStats",n)}_numTags(t,r){return this._getTags(t,r).length}_getTags(t,r){return!t||!t[r]?[]:t[r].tags}_fit(){this.fire("fit-tap")}_isGradientColoring(t,r){return our.has(r)&&t!=null}_equals(t,r){return t===r}get _currentDeviceParams(){var t=this.colorByParams;let r=t.device.filter(o=>lct.some(a=>a.regex.test(o.device))),n=Flt(r.map(o=>o.device));if(n.length==1){var i=n[0].match(cct);i&&(n[0]=i[1])}return r.map((o,a)=>({device:n[a],color:o.color}))}get _currentXlaClusterParams(){var t=this.colorByParams;return t.xla_cluster}get _currentGradientParams(){var t=this.colorByParams,r=this.colorBy;if(!this._isGradientColoring(this.stats,r))return null;let n=t[r],i=n.minValue,o=n.maxValue;return r===Gn.MEMORY?(i=Nd(i,nP),o=Nd(o,nP)):r===Gn.COMPUTE_TIME&&(i=Nd(i,iP),o=Nd(o,iP)),{minValue:i,maxValue:o,startColor:n.startColor,endColor:n.endColor}}download(){this.fire("download-image-requested",this._downloadFilename)}_updateFileInput(t){var a;let r=(a=t.target.files)==null?void 0:a[0];if(!r)return;let n=r.name,i=n.lastIndexOf(".");i>=0&&(n=n.substring(0,i));let o=n.lastIndexOf("/");o>=0&&(n=n.substring(o+1)),this._setDownloadFilename(n),this.set("selectedFile",t),Po({actionId:jr.UPLOADED_GRAPH_FROM_FILESYSTEM})}_datasetsChanged(t,r){var n;r!=null&&(this._selectedRunIndex=0),this._setDownloadFilename((n=this.datasets[this._selectedRunIndex])==null?void 0:n.name)}_computeSelection(t,r,n,i){return!t[r]||!t[r].tags[n]?null:{run:t[r].name,tag:t[r].tags[n].tag,type:i}}_selectedRunIndexChanged(t){var r;!this.datasets||(this.colorBy=Gn.STRUCTURE,this._selectedTagIndex=0,this._selectedGraphType=this._getDefaultSelectionType(),this.traceInputs=!1,this._setDownloadFilename((r=this.datasets[t])==null?void 0:r.name))}_selectedTagIndexChanged(){this._selectedGraphType=this._getDefaultSelectionType()}_getDefaultSelectionType(){let{datasets:t,_selectedRunIndex:r,_selectedTagIndex:n}=this;if(!t||!t[r]||!t[r].tags[n]||t[r].tags[n].opGraph)return Fs.OP_GRAPH;let i=t[r];return i.tags[n].profile?Fs.PROFILE:i.tags[n].conceptualGraph?Fs.CONCEPTUAL_GRAPH:Fs.OP_GRAPH}_getFile(){this.$$("#file").click()}_setDownloadFilename(t){this._downloadFilename=(t||"graph")+".png"}_statsNotNull(t){return t!==null}_toggleLegendOpen(){this.set("_legendOpened",!this._legendOpened)}_getToggleLegendIcon(t){return t?"expand-more":"expand-less"}_getSelectionOpGraphDisabled(t,r,n){return!t[r]||!t[r].tags[n]||!t[r].tags[n].opGraph}_getSelectionProfileDisabled(t,r,n){return!t[r]||!t[r].tags[n]||!t[r].tags[n].profile}_getSelectionConceptualGraphDisabled(t,r,n){return!t[r]||!t[r].tags[n]||!t[r].tags[n].conceptualGraph}};In.template=Q`
    <style>
      :host {
        color: #555;
        display: flex;
        flex-direction: column;
        font-size: 12px;
        width: 100%;
        --tb-graph-controls-title-color: #000;
        --tb-graph-controls-legend-text-color: #000;
        --tb-graph-controls-text-color: #555;
        --tb-graph-controls-title-font-size: 14px;
        --tb-graph-controls-subtitle-font-size: 14px;
        --paper-input-container-shared-input-style_-_font-size: 14px;
        --paper-font-subhead_-_font-size: 14px;
      }

      :host(.dark-mode) {
        --tb-graph-controls-title-color: #fff;
        --tb-graph-controls-legend-text-color: #f3f3f3;
        --tb-graph-controls-text-color: #eee;
      }

      paper-dropdown-menu {
        --paper-dropdown-menu-input: {
          padding: 0;
          color: gray;
        }
        --iron-icon-width: 15px;
        --iron-icon-height: 15px;
        --primary-text-color: gray;
        --paper-item-min-height: 30px;
      }

      paper-button[raised].keyboard-focus {
        font-weight: normal;
      }

      .run-dropdown {
        --paper-input-container: {
          padding: 5px 0 5px 5px;
        }
      }

      table {
        border-collapse: collapse;
        border-spacing: 0;
      }

      table tr {
        height: 20px;
      }

      table td {
        padding: 0;
        margin: 0;
      }

      .allcontrols {
        padding: 0 20px 20px;
        flex-grow: 1;
        overflow-y: auto;
      }

      .legend-holder {
        background: var(--secondary-background-color);
        box-sizing: border-box;
        color: var(--tb-graph-controls-text-color);
        width: 100%;
      }

      .legend-toolbar {
        appearance: none;
        background-color: inherit;
        border-top: 1px solid #ccc;
        border-bottom: 1px solid #ccc;
        border-right: none;
        border-left: none;
        cursor: pointer;
        color: var(--tb-graph-controls-legend-text-color);
        font: inherit;
        display: flex;
        align-items: center;
        justify-content: space-between;
        width: 100%;
      }

      .legend-toolbar,
      .legend-content {
        padding: 8px 20px;
      }

      .toggle-legend-button {
        max-height: 20px;
        max-width: 20px;
        padding: 0;
      }

      .toggle-legend-text {
        font-size: var(--tb-graph-controls-subtitle-font-size);
      }

      paper-radio-button {
        display: block;
        padding: 5px;
      }
      svg.icon,
      tf-graph-icon {
        width: 60px;
        height: 18px;
      }
      .domainValues {
        margin-bottom: 10px;
        width: 165px;
      }
      .domainStart {
        float: left;
      }
      .domainEnd {
        float: right;
      }
      .colorBox {
        width: 20px;
      }

      .image-icon {
        width: 24px;
        height: 24px;
      }

      .help-icon {
        height: 15px;
        margin: 0;
        padding: 0;
      }

      .gray {
        color: #666;
      }

      .title {
        font-size: var(--tb-graph-controls-title-font-size);
        margin: 8px 5px 8px 0;
        color: var(--tb-graph-controls-title-color);
      }
      .title small {
        font-weight: normal;
      }
      .deviceList,
      .xlaClusterList {
        max-height: 200px;
        overflow-y: auto;
      }

      #file {
        padding: 8px 0;
      }

      .color-legend-row {
        align-items: center;
        clear: both;
        display: flex;
        height: 20px;
        margin-top: 5px;
      }

      .color-legend-row .label,
      .color-legend-row svg,
      .color-legend-row tf-graph-icon {
        flex: 0 0 40px;
        margin-right: 20px;
      }

      .devices-checkbox input {
        text-align: left;
        vertical-align: middle;
      }

      .control-holder .icon-button {
        font-size: var(--tb-graph-controls-subtitle-font-size);
        margin: 0 -5px;
        padding: 5px;
        display: flex;
        justify-content: flex-start;
        color: var(--tb-graph-controls-text-color);
      }

      .button-text {
        padding-left: 20px;
        text-transform: none;
      }

      .upload-button {
        width: 165px;
        height: 25px;
        text-transform: none;
        margin-top: 4px;
      }

      .button-icon {
        width: 26px;
        height: 26px;
        color: var(--paper-orange-500);
      }

      .hidden-input {
        display: none;
      }

      .allcontrols .control-holder {
        clear: both;
        display: flex;
        justify-content: space-between;
      }

      .allcontrols .control-holder.control-options {
        padding: 0 0 15px 15px;
        flex-direction: column;
      }

      .allcontrols .control-holder paper-toggle-button {
        margin-bottom: 5px;
      }

      span.counter {
        font-size: var(--tb-graph-controls-subtitle-font-size);
        color: gray;
        margin-left: 4px;
      }

      .runs-row .title,
      .tags-row .title {
        display: flex;
        align-items: baseline;
      }

      .runs-row paper-item,
      .tags-row paper-item {
        --paper-item: {
          white-space: nowrap;
        }
      }

      table.control-holder {
        border: 0;
        border-collapse: collapse;
      }

      table.tf-graph-controls td.input-element-table-data {
        padding: 0 0 0 20px;
      }

      .spacer {
        flex-grow: 1;
      }

      .color-text {
        overflow: hidden;
      }

      .color-text.gradient-container {
        margin: 0 5px;
      }

      /** Override inline styles that suppress pointer events for disabled buttons. Otherwise, the */
      /*  tooltips do not appear. */
      paper-radio-group paper-radio-button {
        pointer-events: auto !important;
      }

      .legend-clarifier {
        color: #266236;
        cursor: help;
        display: inline-block;
        text-decoration: underline;
      }

      .legend-clarifier paper-tooltip {
        width: 150px;
      }

      /** Otherwise, polymer UI controls appear atop node search. */
      tf-graph-node-search {
        z-index: 1;
        width: 100%;
      }

      paper-dropdown-menu {
        flex-grow: 1;
      }
    </style>

    <div class="allcontrols">
      <div class="control-holder">
        <tf-graph-node-search
          selected-node="{{selectedNode}}"
          render-hierarchy="[[renderHierarchy]]"
        ></tf-graph-node-search>
      </div>
      <div class="control-holder">
        <paper-button class="icon-button" on-tap="_fit" alt="Fit to screen">
          <iron-icon icon="aspect-ratio" class="button-icon"></iron-icon>
          <span class="button-text">Fit to screen</span>
        </paper-button>
      </div>
      <div class="control-holder">
        <paper-button
          class="icon-button"
          on-click="download"
          alt="Download PNG"
        >
          <iron-icon icon="file-download" class="button-icon"></iron-icon>
          <span class="button-text">Download PNG</span>
        </paper-button>
      </div>
      <template is="dom-if" if="[[showUploadButton]]">
        <div class="control-holder">
          <paper-button
            class="icon-button"
            on-click="_getFile"
            alt="Upload file"
            title="Upload a pbtxt file to view a graph from the local filesystem"
          >
            <iron-icon icon="file-upload" class="button-icon"></iron-icon>
            <span class="button-text">Upload file</span>
          </paper-button>

          <div class="hidden-input">
            <input
              type="file"
              id="file"
              name="file"
              on-change="_updateFileInput"
              accept=".pbtxt"
            />
          </div>
        </div>
      </template>
      <div class="control-holder runs-row">
        <div class="title">
          Run <span class="counter">([[datasets.length]])</span>
        </div>
        <paper-dropdown-menu
          no-label-float
          no-animations
          noink
          horizontal-align="left"
          class="run-dropdown"
        >
          <paper-listbox
            class="dropdown-content"
            selected="{{_selectedRunIndex}}"
            slot="dropdown-content"
          >
            <template is="dom-repeat" items="[[datasets]]">
              <paper-item>[[item.name]]</paper-item>
            </template>
          </paper-listbox>
        </paper-dropdown-menu>
      </div>
      <template is="dom-if" if="[[showSessionRunsDropdown]]">
        <div class="control-holder tags-row">
          <div class="title">
            Tag
            <span class="counter"
              >([[_numTags(datasets, _selectedRunIndex)]])</span
            >
          </div>
          <paper-dropdown-menu
            no-label-float
            no-animations
            horizontal-align="left"
            noink
            class="run-dropdown"
          >
            <paper-listbox
              class="dropdown-content"
              selected="{{_selectedTagIndex}}"
              slot="dropdown-content"
            >
              <template
                is="dom-repeat"
                items="[[_getTags(datasets, _selectedRunIndex)]]"
              >
                <paper-item>[[item.displayName]]</paper-item>
              </template>
            </paper-listbox>
          </paper-dropdown-menu>
        </div>
      </template>
      <div class="title">Graph type</div>
      <div class="control-holder control-options">
        <paper-radio-group
          selected="{{_selectedGraphType}}"
          on-paper-radio-group-changed="_onGraphTypeChangedByUserGesture"
        >
          <!-- Note that the name has to match that of tf_graph_common.SelectionType. -->
          <paper-radio-button
            name="op_graph"
            disabled="[[_getSelectionOpGraphDisabled(datasets, _selectedRunIndex, _selectedTagIndex)]]"
            >Op graph</paper-radio-button
          >
          <paper-radio-button
            name="conceptual_graph"
            disabled="[[_getSelectionConceptualGraphDisabled(datasets, _selectedRunIndex, _selectedTagIndex)]]"
            >Conceptual graph</paper-radio-button
          >
          <paper-radio-button
            name="profile"
            disabled="[[_getSelectionProfileDisabled(datasets, _selectedRunIndex, _selectedTagIndex)]]"
            >Profile</paper-radio-button
          >
        </paper-radio-group>
      </div>
      <div class="title">Node options</div>
      <div class="control-holder control-options">
        <paper-toggle-button
          checked="{{traceInputs}}"
          on-change="_onTraceInputsChangedByUserGesture"
        >
          Trace inputs
        </paper-toggle-button>
        <paper-toggle-button checked="{{autoExtractNodes}}">
          Auto-extract high-degree nodes
        </paper-toggle-button>
      </div>
      <template is="dom-if" if="[[healthPillsFeatureEnabled]]">
        <div class="control-holder">
          <paper-toggle-button checked="{{healthPillsToggledOn}}"
            >Show health pills</paper-toggle-button
          >
        </div>
      </template>
      <div class="title">Color by</div>
      <div class="control-holder control-options">
        <paper-radio-group
          selected="{{colorBy}}"
          on-paper-radio-group-changed="_onColorByChangedByUserGesture"
        >
          <paper-radio-button name="[[ColorBy.NONE]]">None</paper-radio-button>

          <paper-radio-button name="[[ColorBy.STRUCTURE]]"
            >Structure</paper-radio-button
          >

          <paper-radio-button name="[[ColorBy.DEVICE]]"
            >Device</paper-radio-button
          >

          <paper-radio-button
            id="xla-cluster-radio-button"
            name="[[ColorBy.XLA_CLUSTER]]"
            disabled="[[!_xlaClustersProvided(renderHierarchy)]]"
          >
            XLA cluster
          </paper-radio-button>
          <paper-tooltip
            animation-delay="0"
            for="xla-cluster-radio-button"
            position="right"
            offset="0"
          >
            Coloring by XLA cluster is only enabled if at least 1 op specifies
            an XLA cluster.
          </paper-tooltip>

          <paper-radio-button
            id="compute-time-radio-button"
            name="[[ColorBy.COMPUTE_TIME]]"
            disabled="[[!stats]]"
          >
            Compute time
          </paper-radio-button>
          <paper-tooltip
            animation-delay="0"
            for="compute-time-radio-button"
            position="right"
            offset="0"
          >
            Coloring by compute time is only enabled if the RunMetadata proto is
            passed to the FileWriter when a specific session is run.
          </paper-tooltip>

          <paper-radio-button
            id="memory-radio-button"
            name="[[ColorBy.MEMORY]]"
            disabled="[[!stats]]"
          >
            Memory
          </paper-radio-button>
          <paper-tooltip
            animation-delay="0"
            for="memory-radio-button"
            position="right"
            offset="0"
          >
            Coloring by memory is only enabled if the RunMetadata proto is
            passed to the FileWriter when a specific session is run.
          </paper-tooltip>

          <paper-radio-button
            id="tpu-compatibility-radio-button"
            name="[[ColorBy.OP_COMPATIBILITY]]"
          >
            TPU compatibility
          </paper-radio-button>
          <paper-tooltip
            animation-delay="0"
            for="tpu-compatibility-radio-button"
            position="right"
            offset="0"
          >
            Coloring by whether an operation is compatible for the TPU device.
          </paper-tooltip>
        </paper-radio-group>
        <span class="spacer"></span>
      </div>
    </div>
    <div class="legend-holder">
      <button class="legend-toolbar" on-click="_toggleLegendOpen">
        <span class="toggle-legend-text">Legend</span>
        <iron-icon
          icon="[[_getToggleLegendIcon(_legendOpened)]]"
          class="toggle-legend-button"
        >
        </iron-icon>
      </button>
      <iron-collapse opened="[[_legendOpened]]" class="legend-content">
        <!-- Color-mode-specific legend items -->
        <div>
          <template is="dom-if" if="[[_isGradientColoring(stats, colorBy)]]">
            <svg width="140" height="20" class="color-text gradient-container">
              <defs>
                <linearGradient
                  id="linearGradient"
                  x1="0%"
                  y1="0%"
                  x2="100%"
                  y2="0%"
                >
                  <stop
                    class="start"
                    offset="0%"
                    stop-color$="[[_currentGradientParams.startColor]]"
                  ></stop>
                  <stop
                    class="end"
                    offset="100%"
                    stop-color$="[[_currentGradientParams.endColor]]"
                  ></stop>
                </linearGradient>
              </defs>
              <rect
                x="0"
                y="0"
                width="135"
                height="20"
                fill="url(#linearGradient)"
                stroke="black"
              ></rect>
            </svg>
            <div class="domainValues color-text">
              <div class="domainStart">[[_currentGradientParams.minValue]]</div>
              <div class="domainEnd">[[_currentGradientParams.maxValue]]</div>
            </div>
            <br style="clear: both" />
            <div>Devices included in stats:</div>
            <div class="deviceList">
              <template is="dom-repeat" items="[[_currentDevices]]">
                <div class="color-legend-row devices-checkbox">
                  <span
                    ><input
                      type="checkbox"
                      value$="[[item.device]]"
                      checked$="[[item.used]]"
                      on-click="_deviceCheckboxClicked"
                  /></span>
                  <span>[[item.suffix]]</span>
                  <template is="dom-if" if="[[item.ignoredMsg]]">
                    <paper-icon-button
                      icon="help"
                      class="help-icon"
                    ></paper-icon-button>
                    <paper-tooltip
                      position="right"
                      offset="0"
                      animation-delay="0"
                      >[[item.ignoredMsg]]</paper-tooltip
                    >
                  </template>
                </div>
              </template>
            </div>
          </template>
          <template is="dom-if" if="[[_equals(colorBy, 'structure')]]">
            <div class="color-text">
              <div class="color-legend-row">
                <span class="label"> colors </span>
                <span class="color-legend-value">same substructure</span>
              </div>
              <div class="color-legend-row">
                <tf-graph-icon
                  type="META"
                  height="16"
                  fill-override="#eee"
                  stroke-override="#a6a6a6"
                ></tf-graph-icon>
                <span class="color-legend-value">unique substructure</span>
              </div>
            </div>
          </template>
          <template is="dom-if" if="[[_equals(colorBy, 'device')]]">
            <div>
              <template is="dom-repeat" items="[[_currentDeviceParams]]">
                <div class="color-legend-row">
                  <tf-graph-icon
                    type="META"
                    height="16"
                    fill-override="[[item.color]]"
                    stroke-override="#a6a6a6"
                  ></tf-graph-icon>
                  <span class="color-legend-value">[[item.device]]</span>
                </div>
              </template>
              <div class="color-legend-row">
                <tf-graph-icon
                  type="META"
                  height="16"
                  fill-override="#eee"
                  stroke-override="#a6a6a6"
                ></tf-graph-icon>
                <span class="color-legend-value">unknown device</span>
              </div>
            </div>
          </template>
          <template is="dom-if" if="[[_equals(colorBy, 'xla_cluster')]]">
            <div>
              <template is="dom-repeat" items="[[_currentXlaClusterParams]]">
                <div class="color-legend-row">
                  <svg>
                    <use
                      xmlns:xlink="http://www.w3.org/1999/xlink"
                      xlink:href="#unfilled-rect"
                      x="0"
                      y="0"
                      style="fill:[[item.color]]"
                    ></use>
                  </svg>
                  <span class="color-legend-value">[[item.xla_cluster]]</span>
                </div>
              </template>
              <div class="color-legend-row">
                <svg>
                  <use
                    xmlns:xlink="http://www.w3.org/1999/xlink"
                    xlink:href="#grey-rect"
                    x="0"
                    y="0"
                  ></use>
                </svg>
                <span class="color-legend-value">unknown XLA cluster</span>
              </div>
            </div>
          </template>
          <template is="dom-if" if="[[_equals(colorBy, 'op_compatibility')]]">
            <div class="color-text">
              <div class="color-legend-row">
                <tf-graph-icon
                  type="OP"
                  height="16"
                  fill-override="#0f9d58"
                  stroke-override="#ccc"
                ></tf-graph-icon>
                <span class="color-legend-value">Valid Op</span>
              </div>
              <div class="color-legend-row">
                <tf-graph-icon
                  type="OP"
                  height="16"
                  fill-override="#db4437"
                  stroke-override="#ccc"
                ></tf-graph-icon>
                <span class="color-legend-value">Invalid Op</span>
              </div>
            </div>
          </template>
          <template is="dom-if" if="[[_statsNotNull(stats)]]">
            <div class="color-legend-row">
              <tf-graph-icon type="META" height="16" faded></tf-graph-icon>
              <span class="color-legend-value">unused substructure</span>
            </div>
          </template>
        </div>

        <!-- Common legend items -->
        <div>
          <table>
            <tbody>
              <tr>
                <td></td>
                <td>(* = expandable)</td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon
                    type="META"
                    height="16"
                    fill-override="#d9d9d9"
                    stroke-override="#ccc"
                  ></tf-graph-icon>
                </td>
                <td>
                  Namespace<span class="gray">*</span>
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Encapsulates a set of nodes. Namespace is hierarchical and
                      based on scope.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon type="OP" height="16"></tf-graph-icon>
                </td>
                <td>
                  OpNode
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Node that performs an operation. These nodes cannot
                      expand.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon type="SERIES" height="16"></tf-graph-icon>
                </td>
                <td>
                  Unconnected series<span class="gray">*</span>
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Sequence of numbered nodes that are not connected to each
                      other.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon
                    type="SERIES"
                    height="16"
                    vertical
                  ></tf-graph-icon>
                </td>
                <td>
                  Connected series<span class="gray">*</span>
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Sequence of numbered nodes that are connected to each
                      other.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <svg class="icon">
                    <circle
                      fill="white"
                      stroke="#848484"
                      cx="10"
                      cy="10"
                      r="5"
                    ></circle>
                  </svg>
                </td>
                <td>
                  Constant
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Node that outputs a constant value.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon type="SUMMARY" height="20"></tf-graph-icon>
                </td>
                <td>
                  Summary
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Node that collects data for visualization within
                      TensorBoard.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <svg
                    class="icon"
                    height="15px"
                    preserveAspectRatio="xMinYMid meet"
                    viewBox="0 0 15 15"
                  >
                    <defs>
                      <marker
                        id="dataflow-arrowhead-legend"
                        fill="#bbb"
                        markerWidth="10"
                        markerHeight="10"
                        refX="9"
                        refY="5"
                        orient="auto-start-reverse"
                      >
                        <path d="M 0,0 L 10,5 L 0,10 C 3,7 3,3 0,0"></path>
                      </marker>
                    </defs>
                    <path
                      marker-end="url(#dataflow-arrowhead-legend)"
                      stroke="#bbb"
                      d="M2 9 l 29 0"
                      stroke-linecap="round"
                    ></path>
                  </svg>
                </td>
                <td>
                  Dataflow edge
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Edge showing the data flow between operations. Edges flow
                      upwards unless arrowheads specify otherwise.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <svg
                    class="icon"
                    height="15px"
                    preserveAspectRatio="xMinYMid meet"
                    viewBox="0 0 15 15"
                  >
                    <path
                      stroke="#bbb"
                      d="M2 9 l 29 0"
                      stroke-linecap="round"
                      stroke-dasharray="2, 2"
                    ></path>
                  </svg>
                </td>
                <td>
                  Control dependency edge
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Edge showing the control dependency between operations.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <svg
                    class="icon"
                    height="15px"
                    preserveAspectRatio="xMinYMid meet"
                    viewBox="0 0 15 15"
                  >
                    <defs>
                      <marker
                        id="reference-arrowhead-legend"
                        fill="#FFB74D"
                        markerWidth="10"
                        markerHeight="10"
                        refX="9"
                        refY="5"
                        orient="auto-start-reverse"
                      >
                        <path d="M 0,0 L 10,5 L 0,10 C 3,7 3,3 0,0"></path>
                      </marker>
                    </defs>
                    <path
                      marker-end="url(#reference-arrowhead-legend)"
                      stroke="#FFB74D"
                      d="M2 9 l 29 0"
                      stroke-linecap="round"
                    ></path>
                  </svg>
                </td>
                <td>
                  Reference edge
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Edge showing that the outgoing operation node can mutate
                      the incoming tensor.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
            </tbody>
          </table>
        </div>
      </iron-collapse>
    </div>
  `;E([A({type:Object,observer:"_statsChanged"}),w("design:type",Object)],In.prototype,"stats",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],In.prototype,"devicesForStats",void 0);E([A({type:String,notify:!0}),w("design:type",String)],In.prototype,"colorBy",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],In.prototype,"colorByParams",void 0);E([A({type:Array,observer:"_datasetsChanged"}),w("design:type",Object)],In.prototype,"datasets",void 0);E([A({type:Object}),w("design:type",lo)],In.prototype,"renderHierarchy",void 0);E([A({type:Object,notify:!0,readOnly:!0,computed:"_computeSelection(datasets, _selectedRunIndex, _selectedTagIndex, _selectedGraphType)"}),w("design:type",Object)],In.prototype,"selection",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],In.prototype,"selectedFile",void 0);E([A({type:Number,observer:"_selectedRunIndexChanged"}),w("design:type",Number)],In.prototype,"_selectedRunIndex",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],In.prototype,"traceInputs",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],In.prototype,"autoExtractNodes",void 0);E([A({type:Number,observer:"_selectedTagIndexChanged"}),w("design:type",Number)],In.prototype,"_selectedTagIndex",void 0);E([A({type:String}),w("design:type",String)],In.prototype,"_selectedGraphType",void 0);E([A({type:String,notify:!0}),w("design:type",String)],In.prototype,"selectedNode",void 0);E([A({type:Boolean}),w("design:type",Boolean)],In.prototype,"showSessionRunsDropdown",void 0);E([A({type:Boolean}),w("design:type",Boolean)],In.prototype,"showUploadButton",void 0);E([A({type:Boolean}),w("design:type",Boolean)],In.prototype,"healthPillsFeatureEnabled",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],In.prototype,"healthPillsToggledOn",void 0);E([A({type:Boolean}),w("design:type",Boolean)],In.prototype,"_legendOpened",void 0);E([Rt("devicesForStats"),w("design:type",Array),w("design:paramtypes",[])],In.prototype,"_currentDevices",null);E([Rt("colorByParams"),w("design:type",Array),w("design:paramtypes",[])],In.prototype,"_currentDeviceParams",null);E([Rt("colorByParams"),w("design:type",Array),w("design:paramtypes",[])],In.prototype,"_currentXlaClusterParams",null);E([Rt("colorByParams","colorBy"),w("design:type",Object),w("design:paramtypes",[])],In.prototype,"_currentGradientParams",null);In=E([yt("tf-graph-controls")],In);function aur(e){if(e==="true")return!0;if(e==="false")return!1;if(e[0]==='"')return e.substring(1,e.length-1);let r=parseFloat(e);return isNaN(r)?e:r}function $le(e){return new Promise((t,r)=>{fetch(e).then(n=>{n.ok?n.arrayBuffer().then(t,r):n.text().then(r,r)})})}function Kle(e,t){return Yse("Reading metadata pbtxt",40,()=>e==null?Promise.resolve(null):$le(e),t,jr.FETCH_METADATA_PBTXT_BYTES).then(r=>dH("Parsing metadata.pbtxt",60,()=>r!=null?hur(r):Promise.resolve(null),t,jr.PARSE_METADATA_PBTXT_INTO_OBJECT))}function Zle(e,t,r){return dH("Reading graph pbtxt",40,()=>Ri(this,null,function*(){let n=Date.now();if(t){let o=yield new Promise(function(a,s){let l=new FileReader;l.onload=()=>a(l.result),l.onerror=()=>s(l.error),l.readAsArrayBuffer(t)});return Po({timingId:jr.FETCH_PBTXT_BYTES_FROM_FILESYSTEM,eventValue:Date.now()-n}),o}let i=yield $le(e);return Po({timingId:jr.FETCH_PBTXT_BYTES_FROM_SERVER,eventValue:Date.now()-n}),i}),r,jr.FETCH_PBTXT_BYTES).then(n=>dH("Parsing graph.pbtxt",60,()=>uur(n),r,jr.PARSE_PBTXT_INTO_OBJECT))}function sur(e,t,r=1e6,n=`
`){return new Promise(function(i,o){function a(s,l,c){let u=c>=e.byteLength,h=l.split(n);h[0]=s+h[0];let f=u?"":h.pop();for(let g of h)try{t(g)}catch(_){o(_);return}if(u){i(!0);return}let p=new Blob([e.slice(c,c+r)]),d=new FileReader;d.onload=function(g){a(f,g.target.result,c+r)},d.readAsText(p)}a("","",0)})}var lur={"library.function":!0,"library.function.node_def":!0,"library.function.node_def.input":!0,"library.function.node_def.attr":!0,"library.function.node_def.attr.value.list.b":!0,"library.function.node_def.attr.value.list.f":!0,"library.function.node_def.attr.value.list.func":!0,"library.function.node_def.attr.value.list.i":!0,"library.function.node_def.attr.value.list.s":!0,"library.function.node_def.attr.value.list.shape":!0,"library.function.node_def.attr.value.list.shape.dim":!0,"library.function.node_def.attr.value.list.tensor":!0,"library.function.node_def.attr.value.list.type":!0,"library.function.node_def.attr.value.shape.dim":!0,"library.function.node_def.attr.value.tensor.string_val":!0,"library.function.node_def.attr.value.tensor.tensor_shape.dim":!0,"library.function.signature.input_arg":!0,"library.function.signature.output_arg":!0,"library.versions":!0,node:!0,"node.input":!0,"node.attr":!0,"node.attr.value.list.b":!0,"node.attr.value.list.f":!0,"node.attr.value.list.func":!0,"node.attr.value.list.i":!0,"node.attr.value.list.s":!0,"node.attr.value.list.shape":!0,"node.attr.value.list.shape.dim":!0,"node.attr.value.list.tensor":!0,"node.attr.value.list.type":!0,"node.attr.value.shape.dim":!0,"node.attr.value.tensor.string_val":!0,"node.attr.value.tensor.tensor_shape.dim":!0},cur={"step_stats.dev_stats":!0,"step_stats.dev_stats.node_stats":!0,"step_stats.dev_stats.node_stats.output":!0,"step_stats.dev_stats.node_stats.memory":!0,"step_stats.dev_stats.node_stats.output.tensor_description.shape.dim":!0};function uur(e){return Jle(e,lur)}function hur(e){return Jle(e,cur).then(t=>t.step_stats)}function Jle(e,t){let r={},n=[],i=[],o=r;function a(l){let c=l.indexOf(":"),u=l.substring(0,c).trim(),h=aur(l.substring(c+2).trim());return{name:u,value:h}}function s(l,c,u,h){let f=l[c];f==null?l[c]=h.join(".")in t?[u]:u:Array.isArray(f)?f.push(u):l[c]=[f,u]}return sur(e,function(l){if(l=l.trim(),!!l)switch(l[l.length-1]){case"{":let c=l.substring(0,l.length-2).trim(),u={};n.push(o),i.push(c),s(o,c,u,i),o=u;break;case"}":o=n.pop(),i.pop();break;default:let h=a(l);s(o,h.name,h.value,i.concat(h.name));break}}).then(function(){return r})}function tce(e,t,r,n=new Ju,i=r3){let o=JS(e,30,"Data"),a=JS(e,20,"Graph"),s=JS(e,50,"Namespace hierarchy"),l=Date.now();return Zle(t,r,o).then(function(c){if(!c.node)throw new Error("The graph is empty. This can happen when TensorFlow could not trace any graph. Please refer to https://github.com/tensorflow/tensorboard/issues/1961 for more information.");return nle(c,rle,a)},()=>{throw new Error("Malformed GraphDef. This can sometimes be caused by a bad network connection or difficulty reconciling multiple GraphDefs; for the latter case, please refer to https://github.com/tensorflow/tensorboard/issues/1929.")}).then(c=>Ri(this,null,function*(){Yle(c,n);let u=yield xH(c,i,s);return Po({timingId:jr.GRAPH_LOAD_SUCCEEDED,eventValue:Date.now()-l}),{graph:c,graphHierarchy:u}})).catch(c=>{let u=`Graph visualization failed.

${c}`;throw e.reportError(u,c),Po({timingId:jr.GRAPH_LOAD_FAILED,eventValue:Date.now()-l}),c})}var Hs=class extends Gt(mt){constructor(){super(...arguments),this.compatibilityProvider=new Ju,this.hierarchyParams=r3,this._template=null}_selectionChanged(){!this.selection||this.debounce("selectionchange",()=>{this._load(this.selection)})}_load(t){let{run:r,tag:n,type:i}=t;switch(i){case Fs.OP_GRAPH:case Fs.CONCEPTUAL_GRAPH:{(function(){this._setOutStats(null)}).bind(this)();let o=new URLSearchParams;o.set("run",r),o.set("conceptual",String(i===Fs.CONCEPTUAL_GRAPH)),n&&o.set("tag",n);let a=ve().pluginRoute("graphs","/graph",o);return this._fetchAndConstructHierarchicalGraph(a).then(()=>{this._graphRunTag={run:r,tag:n}})}case Fs.PROFILE:{let{tags:o}=this.datasets.find(({name:f})=>f===r),s=o.find(f=>f.tag===n).opGraph?n:null;console.assert(o.find(f=>f.tag===s),`Required tag (${s}) is missing.`);let c=!this._graphRunTag||this._graphRunTag.run!==r||this._graphRunTag.tag!==s?this._load({run:r,tag:s,type:Fs.OP_GRAPH}):Promise.resolve(),u=new URLSearchParams;u.set("tag",n),u.set("run",r);let h=ve().pluginRoute("graphs","/run_metadata",u);return c.then(()=>this._readAndParseMetadata(h))}default:return Promise.reject(new Error(`Unknown selection type: ${i}`))}}_readAndParseMetadata(t){this.set("progress",{value:0,msg:""});var r=rP(this);Kle(t,r).then(function(n){this._setOutStats(n)}.bind(this))}_fetchAndConstructHierarchicalGraph(t,r){this.set("progress",{value:0,msg:""});let n=rP(this);return tce(n,t,r!==void 0?r:null,this.compatibilityProvider,this.hierarchyParams).then(function({graph:i,graphHierarchy:o}){this._setOutGraph(i),this._setOutGraphHierarchy(o)}.bind(this))}_selectedFileChanged(){var i;var t=this.selectedFile;if(!t)return;let r=t.target,n=(i=r.files)==null?void 0:i[0];!n||(r.value="",this._fetchAndConstructHierarchicalGraph(null,n))}};E([A({type:Array}),w("design:type",Array)],Hs.prototype,"datasets",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],Hs.prototype,"progress",void 0);E([A({type:Object}),w("design:type",Object)],Hs.prototype,"selection",void 0);E([A({type:Object}),w("design:type",Object)],Hs.prototype,"selectedFile",void 0);E([A({type:Object}),w("design:type",Object)],Hs.prototype,"compatibilityProvider",void 0);E([A({type:Object}),w("design:type",Object)],Hs.prototype,"hierarchyParams",void 0);E([A({type:Object,readOnly:!0,notify:!0}),w("design:type",os)],Hs.prototype,"outGraphHierarchy",void 0);E([A({type:Object,readOnly:!0,notify:!0}),w("design:type",Xu)],Hs.prototype,"outGraph",void 0);E([A({type:Object,readOnly:!0,notify:!0}),w("design:type",Object)],Hs.prototype,"outStats",void 0);E([A({type:Object}),w("design:type",Object)],Hs.prototype,"_graphRunTag",void 0);E([Bt("selection","compatibilityProvider"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Hs.prototype,"_selectionChanged",null);E([Bt("selectedFile","compatibilityProvider"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Hs.prototype,"_selectedFileChanged",null);Hs=E([yt("tf-graph-dashboard-loader")],Hs);var ece="run";var Or=class extends Gt(mt){constructor(){super(...arguments),this._datasets=[],this._datasetsFetched=!1,this._selectedDataset=0,this._requestManager=new Ae,this._canceller=new an,this.specificHealthPillStep=0,this.healthPillsToggledOn=!1,this._debuggerNumericAlerts=[],this._nodeNamesToHealthPills={},this._healthPillRequestId=1,this._healthPillStepRequestTimerDelay=500,this.run=y_(ece,{defaultValue:"",useLocalStorage:!1}).call(this),this._runObserver=v_(ece,{defaultValue:"",polymerProperty:"run",useLocalStorage:!1})}attached(){this.set("_isAttached",!0)}detached(){this.set("_isAttached",!1)}ready(){super.ready(),this.addEventListener("node-toggle-expand",this._handleNodeToggleExpand.bind(this))}reload(){this._debuggerDataEnabled||this._requestManager.request(ve().pluginsListing()).then(this._canceller.cancellable(t=>{t.cancelled||t.value.debugger&&this.set("_debuggerDataEnabled",!0)})),this._maybeFetchHealthPills()}_fit(){this.$$("#graphboard").fit()}_onDownloadImageRequested(t){this.$$("#graphboard").downloadAsImage(t.detail)}_getGraphDisplayClassName(t,r){return t||r.length?"":"no-graph"}_fetchDataset(){return this._requestManager.request(ve().pluginRoute("graphs","/info"))}_fetchHealthPills(t,r){let n={node_names:JSON.stringify(t),run:"__debugger_data__"};r!==void 0&&(n.step=r);let i=ve().pluginRoute("debugger","/health_pills");return this._requestManager.request(i,n)}_fetchDebuggerNumericsAlerts(){return this._requestManager.request(ve().pluginRoute("debugger","/numerics_alert_report"))}_graphUrl(t,r,n){return ve().pluginRoute("graphs","/graph",new URLSearchParams({run:t,limit_attr_size:r,large_attrs_key:n}))}_shouldRequestHealthPills(){return this._debuggerDataEnabled&&this.healthPillsToggledOn&&this._renderHierarchy&&this._datasetsState(this._datasetsFetched,this._datasets,"PRESENT")}_maybeInitializeDashboard(){var t=this._isAttached;this._initialized||!t||(this.set("_compatibilityProvider",new Ju),this._initialized=!0,this._fetchDataset().then(r=>{let n=Object.keys(r);this._datasets=n.sort(xh).map(i=>{let o=r[i],s=Object.keys(o.tags).sort(xh).map(c=>o.tags[c]).map(({tag:c,conceptual_graph:u,op_graph:h,profile:f})=>({tag:c,displayName:c,conceptualGraph:u,opGraph:h,profile:f})),l=o.run_graph?[{tag:null,displayName:"Default",conceptualGraph:!1,opGraph:!0,profile:!1},...s]:s;return{name:i,tags:l}}),this._datasetsFetched=!0}))}_determineSelectedDataset(){var t=this._datasetsFetched,r=this._datasets,n=this.run;if(!n){this.set("_selectedDataset",0);return}let i=r.findIndex(o=>o.name===n);if(i===-1){if(t){let o=this.$$("#error-dialog");o.textContent=`No dataset named "${n}" could be found.`,o.open()}return}this.set("_selectedDataset",i)}_updateSelectedDatasetName(){var t=this._datasetsFetched,r=this._datasets,n=this._selectedDataset;!t||r.length<=n||this.set("run",r[n].name)}_requestHealthPills(){this.set("_areHealthPillsLoading",!0);var t=++this._healthPillRequestId;this._healthPillStepRequestTimerId!==null&&(window.clearTimeout(this._healthPillStepRequestTimerId),this._healthPillStepRequestTimerId=null),this.allStepsModeEnabled?this._healthPillStepRequestTimerId=setTimeout(function(){this._healthPillStepRequestTimerId=null,this._initiateNetworkRequestForHealthPills(t)}.bind(this),this._healthPillStepRequestTimerDelay):this._initiateNetworkRequestForHealthPills(t)}_initiateNetworkRequestForHealthPills(t){if(this._healthPillRequestId!==t)return;let r=this.allStepsModeEnabled?this.specificHealthPillStep:void 0,n=this._fetchHealthPills(this._renderHierarchy.getNamesOfRenderedOps(),r),i=this._fetchDebuggerNumericsAlerts();Promise.all([n,i]).then(function(o){var a=o[0],s=o[1];if(!!this.healthPillsToggledOn&&t===this._healthPillRequestId){for(var l in a){this.set("_healthPillStepIndex",a[l].length-1);break}this.set("_debuggerNumericAlerts",s),this.set("_nodeNamesToHealthPills",a),this.set("_areHealthPillsLoading",!1),this.set("_healthPillStepRequestTimerId",null)}}.bind(this))}_datasetsState(t,r,n){return t?!r||!r.length?n==="EMPTY":n==="PRESENT":n==="NOT_LOADED"}_renderHierarchyChanged(t){this.reload()}_handleNodeToggleExpand(){this._maybeFetchHealthPills()}_healthPillsToggledOnChanged(t){t?this.reload():this.set("_nodeNamesToHealthPills",{})}_maybeFetchHealthPills(){!this._shouldRequestHealthPills()||this._requestHealthPills()}};Or.template=Q`
    <paper-dialog id="error-dialog" with-backdrop></paper-dialog>
    <tf-dashboard-layout>
      <tf-graph-controls
        id="controls"
        class="sidebar"
        slot="sidebar"
        devices-for-stats="{{_devicesForStats}}"
        color-by-params="[[_colorByParams]]"
        stats="[[_stats]]"
        color-by="{{_colorBy}}"
        datasets="[[_datasets]]"
        render-hierarchy="[[_renderHierarchy]]"
        selection="{{_selection}}"
        selected-file="{{_selectedFile}}"
        selected-node="{{_selectedNode}}"
        health-pills-feature-enabled="[[_debuggerDataEnabled]]"
        health-pills-toggled-on="{{healthPillsToggledOn}}"
        on-fit-tap="_fit"
        trace-inputs="{{_traceInputs}}"
        auto-extract-nodes="{{_autoExtractNodes}}"
        on-download-image-requested="_onDownloadImageRequested"
      ></tf-graph-controls>
      <div
        class$="center [[_getGraphDisplayClassName(_selectedFile, _datasets)]]"
        slot="center"
      >
        <tf-graph-dashboard-loader
          id="loader"
          datasets="[[_datasets]]"
          selection="[[_selection]]"
          selected-file="[[_selectedFile]]"
          out-graph-hierarchy="{{_graphHierarchy}}"
          out-graph="{{_graph}}"
          out-stats="{{_stats}}"
          progress="{{_progress}}"
          hierarchy-params="[[_hierarchyParams]]"
          compatibility-provider="[[_compatibilityProvider]]"
        ></tf-graph-dashboard-loader>
        <div class="no-data-message">
          <h3>No graph definition files were found.</h3>
          <p>
            To store a graph, create a
            <code>tf.summary.FileWriter</code>
            and pass the graph either via the constructor, or by calling its
            <code>add_graph()</code> method. You may want to check out the
            <a href="https://www.tensorflow.org/tensorboard/graphs"
              >examining the TensorFlow graph tutorial</a
            >.
          </p>

          <p>
            If you’re new to using TensorBoard, and want to find out how to add
            data and set up your event files, check out the
            <a
              href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
              >README</a
            >
            and perhaps the
            <a
              href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
              >TensorBoard tutorial</a
            >.
          </p>

          <p>
            If you think TensorBoard is configured properly, please see
            <a
              href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
              >the section of the README devoted to missing data problems</a
            >
            and consider filing an issue on GitHub.
          </p>
        </div>
        <div class="graphboard">
          <tf-graph-board
            id="graphboard"
            devices-for-stats="[[_devicesForStats]]"
            color-by="{{_colorBy}}"
            color-by-params="{{_colorByParams}}"
            graph-hierarchy="[[_graphHierarchy]]"
            graph="[[_graph]]"
            hierarchy-params="[[_hierarchyParams]]"
            progress="[[_progress]]"
            debugger-data-enabled="[[_debuggerDataEnabled]]"
            are-health-pills-loading="[[_areHealthPillsLoading]]"
            debugger-numeric-alerts="[[_debuggerNumericAlerts]]"
            node-names-to-health-pills="[[_nodeNamesToHealthPills]]"
            all-steps-mode-enabled="{{allStepsModeEnabled}}"
            specific-health-pill-step="{{specificHealthPillStep}}"
            health-pill-step-index="[[_healthPillStepIndex]]"
            render-hierarchy="{{_renderHierarchy}}"
            selected-node="{{_selectedNode}}"
            stats="[[_stats]]"
            trace-inputs="[[_traceInputs]]"
            auto-extract-nodes="[[_autoExtractNodes]]"
          ></tf-graph-board>
        </div>
      </div>
    </tf-dashboard-layout>
    <style>
      :host /deep/ {
        font-family: 'Roboto', sans-serif;
      }

      .sidebar {
        display: flex;
        height: 100%;
      }

      .center {
        position: relative;
        height: 100%;
      }

      paper-dialog {
        padding: 20px;
      }

      .no-data-message {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }

      .graphboard {
        height: 100%;
      }

      .no-graph .graphboard {
        display: none;
      }

      .center:not(.no-graph) .no-data-message {
        display: none;
      }

      a {
        color: var(--tb-link);
      }

      a:visited {
        color: var(--tb-link-visited);
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],Or.prototype,"_datasets",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_datasetsFetched",void 0);E([A({type:Number}),w("design:type",Number)],Or.prototype,"_selectedDataset",void 0);E([A({type:Object,observer:"_renderHierarchyChanged"}),w("design:type",lo)],Or.prototype,"_renderHierarchy",void 0);E([A({type:Object}),w("design:type",Ae)],Or.prototype,"_requestManager",void 0);E([A({type:Object}),w("design:type",an)],Or.prototype,"_canceller",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_debuggerDataEnabled",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"allStepsModeEnabled",void 0);E([A({type:Number}),w("design:type",Number)],Or.prototype,"specificHealthPillStep",void 0);E([A({type:Boolean,observer:"_healthPillsToggledOnChanged"}),w("design:type",Boolean)],Or.prototype,"healthPillsToggledOn",void 0);E([A({type:String,notify:!0}),w("design:type",String)],Or.prototype,"selectedNode",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_isAttached",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_initialized",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_areHealthPillsLoading",void 0);E([A({type:Array,notify:!0}),w("design:type",Array)],Or.prototype,"_debuggerNumericAlerts",void 0);E([A({type:Object}),w("design:type",Object)],Or.prototype,"_nodeNamesToHealthPills",void 0);E([A({type:Number}),w("design:type",Number)],Or.prototype,"_healthPillStepIndex",void 0);E([A({type:Number}),w("design:type",Number)],Or.prototype,"_healthPillRequestId",void 0);E([A({type:Number}),w("design:type",Object)],Or.prototype,"_healthPillStepRequestTimerId",void 0);E([A({type:Number}),w("design:type",Number)],Or.prototype,"_healthPillStepRequestTimerDelay",void 0);E([A({type:Array}),w("design:type",Array)],Or.prototype,"runs",void 0);E([A({type:String,notify:!0,observer:"_runObserver"}),w("design:type",String)],Or.prototype,"run",void 0);E([A({type:Object}),w("design:type",Object)],Or.prototype,"_selection",void 0);E([A({type:Object}),w("design:type",Object)],Or.prototype,"_compatibilityProvider",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_traceInputs",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Or.prototype,"_autoExtractNodes",void 0);E([A({type:Object}),w("design:type",Object)],Or.prototype,"_selectedFile",void 0);E([Bt("_isAttached"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Or.prototype,"_maybeInitializeDashboard",null);E([Bt("_datasetsFetched","_datasets","run"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Or.prototype,"_determineSelectedDataset",null);E([Bt("_datasetsFetched","_datasets","_selectedDataset"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Or.prototype,"_updateSelectedDatasetName",null);Or=E([yt("tf-graph-dashboard")],Or);var RH=Ee(Oe(),1);var kr=Vr,Ma=class extends Gt(_o(mt)){constructor(){super(...arguments),this.mode="offset",this.timeProperty="step",this.bins="bins",this.x="x",this.dx="dx",this.y="y",this.colorScale=kr.scaleOrdinal(kr.schemeCategory10),this.modeTransitionDuration=500,this._name=null,this._data=null}ready(){super.ready(),this.scopeSubtree(this.$.svg,!0)}attached(){this._attached=!0}detached(){this._attached=!1}setSeriesData(t,r){this._name=t,this._data=r,this.redraw()}_redrawOnChange(){this.redraw()}redraw(){this._draw(0)}_modeRedraw(){this._draw(this.modeTransitionDuration)}_draw(t){if(!this._attached||!this._data)return;if(t===void 0)throw new Error("vz-histogram-timeseries _draw needs duration");if(this._data.length<=0)throw new Error("Not enough steps in the data");if(!this._data[0].hasOwnProperty(this.bins))throw new Error("No bins property of '"+this.bins+"' in data");if(this._data[0][this.bins].length<=0)throw new Error("Must have at least one bin in bins in data");if(!this._data[0][this.bins][0].hasOwnProperty(this.x))throw new Error("No x property '"+this.x+"' on bins data");if(!this._data[0][this.bins][0].hasOwnProperty(this.dx))throw new Error("No dx property '"+this.dx+"' on bins data");if(!this._data[0][this.bins][0].hasOwnProperty(this.y))throw new Error("No y property '"+this.y+"' on bins data");var r=this.timeProperty,n=this.x,i=this.bins,o=this.dx,a=this.y,s=this._data,l=this._name,c=this.mode,u=kr.hcl(this.colorScale(l)),h=kr.select(this.$.tooltip),f=function(Nt){return Nt[n]},p=function(Nt){return Nt[a]},d=function(Nt){return Nt[o]},g=function(Nt){return Nt[n]+Nt[o]},_=function(Nt){return Nt[r]};r==="relative"&&(_=function(Nt){return Nt.wall_time-s[0].wall_time});var y=this.$.svg.getBoundingClientRect(),x=y.width,b=y.height,S,C={top:5,right:60,bottom:20,left:24};c==="offset"?(S=b/2.5,C.top=S+5):S=b-C.top-C.bottom;var P=x-C.left-C.right,k=b-C.top-C.bottom,O=kr.min(s,f),D=kr.max(s,g),B=kr.format(".3n"),I=kr.format(".0f");r==="wall_time"?I=kr.timeFormat("%m/%d %X"):r==="relative"&&(I=function(Nt){return kr.format(".1r")(Nt/36e5)+"h"});var L=s.map(function(Nt,ze){return[kr.min(Nt[i],f),kr.max(Nt[i],g)]}),R=s.map(function(Nt){return kr.extent(Nt[i],p)}),F=500,z=kr.extent(s,_),U=(r==="wall_time"?kr.scaleTime():kr.scaleLinear()).domain(z).range([0,c==="offset"?k:0]),W=kr.scaleLinear().domain([0,kr.max(s,function(Nt,ze){return R[ze][1]})]).range([S,0]),Z=kr.scaleLinear().domain(W.domain()).range([F,0]),rt=kr.scaleLinear().domain([kr.min(s,function(Nt,ze){return L[ze][0]}),kr.max(s,function(Nt,ze){return L[ze][1]})]).nice().range([0,P]),ot=kr.scaleLinear().domain(rt.domain()).range([0,F]);let st=kr.scaleLinear().domain(kr.extent(s,_)).range([u.brighter(),u.darker()]).interpolate(kr.interpolateHcl);var St=kr.axisBottom(rt).ticks(Math.max(2,P/20)),bt=kr.axisRight(U).ticks(Math.max(2,k/15)).tickFormat(I),Mt=kr.axisRight(W).ticks(Math.max(2,k/15)).tickSize(P+5).tickFormat(B),lt=function(Nt){return Nt[n]+Nt[o]/2},Kt=kr.line().x(function(Nt){return ot(lt(Nt))}).y(function(Nt){return Z(Nt[a])}),_t=function(Nt){return"M"+ot(lt(Nt[0]))+","+Z(0)+"L"+Kt(Nt).slice(1)+"L"+ot(lt(Nt[Nt.length-1]))+","+Z(0)},ct=this.$.svg,X=kr.select(ct),et=X.transition().duration(t),dt=X.select("g").classed("small",function(){return P>0&&P<=150}).classed("medium",function(){return P>150&&P<=300}).classed("large",function(){return P>300}),q=et.select("g").attr("transform","translate("+C.left+","+C.top+")"),pt=kr.bisector(g).left,ht=dt.select(".stage").on("mouseover",function(){Tt.style("opacity",1),Ct.style("opacity",1),at.style("opacity",1),Ce.style("opacity",1),h.style("opacity",1)}).on("mouseout",function(){Tt.style("opacity",0),Ct.style("opacity",0),at.style("opacity",0),Ce.style("opacity",0),Tt.classed("hover-closest",!1),It.classed("outline-hover",!1),h.style("opacity",0)}).on("mousemove",Pt),wt=ht.select(".background").attr("transform","translate("+-C.left+","+-C.top+")").attr("width",x).attr("height",b),kt=ht.selectAll(".histogram").data(s),ie=kt.exit().remove(),ee=kt.enter().append("g").attr("class","histogram"),Le=ee.merge(kt).sort(function(Nt,ze){return _(Nt)-_(ze)}),ar=q.selectAll(".histogram").attr("transform",function(Nt){return"translate(0, "+(c==="offset"?U(_(Nt))-S:0)+")"}),fr=ee.append("line").attr("class","baseline"),tt=ar.select(".baseline").style("stroke-opacity",function(Nt){return c==="offset"?.1:0}).attr("y1",S).attr("y2",S).attr("x2",P),$=ee.append("path").attr("class","outline"),It=Le.select(".outline").attr("vector-effect","non-scaling-stroke").attr("d",function(Nt){return _t(Nt[i])}).style("stroke-width",1),$t=ar.select(".outline").attr("transform","scale("+P/F+", "+S/F+")").style("stroke",function(Nt){return c==="offset"?"":st(_(Nt))}).style("fill-opacity",function(Nt){return c==="offset"?1:0}).style("fill",function(Nt){return st(_(Nt))}),he=ee.append("g").attr("class","hover"),Tt=Le.select(".hover").style("fill",function(Nt){return st(_(Nt))});he.append("circle").attr("r",2),he.append("text").style("display","none").attr("dx",4);var be=dt.select(".x-axis-hover").selectAll(".label").data(["x"]),nt=be.enter().append("g").attr("class","label"),Ct=be.merge(nt);nt.append("rect").attr("x",-20).attr("y",6).attr("width",40).attr("height",14),nt.append("line").attr("x1",0).attr("x2",0).attr("y1",0).attr("y2",6),nt.append("text").attr("dy",18);var Wt=dt.select(".y-axis-hover").selectAll(".label").data(["y"]),fe=Wt.enter().append("g").attr("class","label"),at=Wt.merge(fe);fe.append("rect").attr("x",8).attr("y",-6).attr("width",40).attr("height",14),fe.append("line").attr("x1",0).attr("x2",6).attr("y1",0).attr("y2",0),fe.append("text").attr("dx",8).attr("dy",4);var se=dt.select(".y-slice-axis-hover").selectAll(".label").data(["y"]),Qt=se.enter().append("g").attr("class","label"),Ce=se.merge(Qt);Qt.append("rect").attr("x",8).attr("y",-6).attr("width",40).attr("height",14),Qt.append("line").attr("x1",0).attr("x2",6).attr("y1",0).attr("y2",0),Qt.append("text").attr("dx",8).attr("dy",4),q.select(".y.axis.slice").style("opacity",c==="offset"?0:1).attr("transform","translate(0, "+(c==="offset"?-S:0)+")").call(Mt),q.select(".x.axis").attr("transform","translate(0, "+k+")").call(St),q.select(".y.axis").style("opacity",c==="offset"?1:0).attr("transform","translate("+P+", "+(c==="offset"?0:k)+")").call(bt),q.selectAll(".tick text").attr("fill","#aaa"),q.selectAll(".axis path.domain").attr("stroke","none");function Pt(){var Nt=kr.mouse(this),ze=rt.invert(Nt[0]),yn=U.invert(Nt[1]);function Wi(cn){return Math.min(cn[i].length-1,pt(cn[i],ze))}var Ar,Pa=1/0,ho;Tt.attr("transform",function(cn,cx){var rp=Wi(cn);ho=cn;var K=rt(cn[i][rp][n]+cn[i][rp][o]/2),gt=W(cn[i][rp][a]),Et=c==="offset"?U(_(cn))-(S-gt):gt,xt=Math.abs(Nt[1]-Et);return xt<Pa&&(Pa=xt,Ar=cn),"translate("+K+","+gt+")"}),Tt.select("text").text(function(cn){var cx=Wi(cn);return cn[i][cx][a]}),Tt.classed("hover-closest",function(cn){return cn===Ar}),It.classed("outline-hover",function(cn){return cn===Ar});var Ia=Wi(ho);Ct.attr("transform",function(cn){return"translate("+rt(ho[i][Ia][n]+ho[i][Ia][o]/2)+", "+k+")"}).select("text").text(function(cn){return B(ho[i][Ia][n]+ho[i][Ia][o]/2)});var lx=bt.tickFormat();at.attr("transform",function(cn){return"translate("+P+", "+(c==="offset"?U(_(Ar)):0)+")"}).style("display",c==="offset"?"":"none").select("text").text(function(cn){return lx(_(Ar))});var cm=Mt.tickFormat();Ce.attr("transform",function(cn){return"translate("+P+", "+(c==="offset"?0:W(Ar[i][Ia][a]))+")"}).style("display",c==="offset"?"none":"").select("text").text(function(cn){return cm(Ar[i][Ia][a])});var J0=kr.mouse(ct);h.style("transform","translate("+(J0[0]+15)+"px,"+(J0[1]-15)+"px)").select("span").text(c==="offset"?cm(Ar[i][Ia][a]):(r==="step"?"step ":"")+lx(_(Ar)))}}};Ma.template=Q`
    <div id="tooltip"><span></span></div>
    <svg id="svg">
      <g>
        <g class="axis x"></g>
        <g class="axis y"></g>
        <g class="axis y slice"></g>
        <g class="stage">
          <rect class="background"></rect>
        </g>
        <g class="x-axis-hover"></g>
        <g class="y-axis-hover"></g>
        <g class="y-slice-axis-hover"></g>
      </g>
    </svg>

    <style>
      :host {
        color: #aaa;
        display: flex;
        flex-direction: column;
        flex-grow: 1;
        flex-shrink: 1;
        position: relative;
        --vz-histogram-timeseries-hover-bg-color: #fff;
        --vz-histogram-timeseries-outline-color: #fff;
        --vz-histogram-timeseries-hover-outline-color: #000;
      }

      :host(.dark-mode) {
        --vz-histogram-timeseries-hover-bg-color: var(
          --primary-background-color
        );
        --vz-histogram-timeseries-outline-color: var(--paper-grey-600);
        --vz-histogram-timeseries-hover-outline-color: #fff;
      }

      svg {
        font-family: roboto, sans-serif;
        overflow: visible;
        display: block;
        width: 100%;
        flex-grow: 1;
        flex-shrink: 1;
      }

      text {
        fill: currentColor;
      }

      #tooltip {
        position: absolute;
        display: block;
        opacity: 0;
        font-weight: bold;
        font-size: 11px;
      }

      .background {
        fill-opacity: 0;
        fill: red;
      }

      .histogram {
        pointer-events: none;
      }

      .hover {
        font-size: 9px;
        dominant-baseline: middle;
        opacity: 0;
      }

      .hover circle {
        stroke: white;
        stroke-opacity: 0.5;
        stroke-width: 1px;
      }

      .hover text {
        fill: black;
        opacity: 0;
      }

      .hover.hover-closest circle {
        fill: var(--vz-histogram-timeseries-hover-outline-color) !important;
      }

      .hover.hover-closest text {
        opacity: 1;
      }

      .baseline {
        stroke: black;
        stroke-opacity: 0.1;
      }

      .outline {
        fill: none;
        stroke: var(--vz-histogram-timeseries-outline-color);
        stroke-opacity: 0.5;
      }

      .outline.outline-hover {
        stroke: var(--vz-histogram-timeseries-hover-outline-color) !important;
        stroke-opacity: 1;
      }

      .x-axis-hover,
      .y-axis-hover,
      .y-slice-axis-hover {
        pointer-events: none;
      }

      .x-axis-hover .label,
      .y-axis-hover .label,
      .y-slice-axis-hover .label {
        opacity: 0;
        font-weight: bold;
        font-size: 11px;
        text-anchor: end;
      }

      .x-axis-hover text {
        text-anchor: middle;
      }

      .y-axis-hover text,
      .y-slice-axis-hover text {
        text-anchor: start;
      }

      .x-axis-hover line,
      .y-axis-hover line,
      .y-slice-axis-hover line {
        stroke: currentColor;
      }

      .x-axis-hover rect,
      .y-axis-hover rect,
      .y-slice-axis-hover rect {
        fill: var(--vz-histogram-timeseries-hover-bg-color);
      }

      #tooltip,
      .x-axis-hover text,
      .y-axis-hover text,
      .y-slice-axis-hover text {
        color: var(--vz-histogram-timeseries-hover-outline-color);
      }

      .axis {
        font-size: 11px;
      }

      .axis path.domain {
        fill: none;
      }

      .axis .tick line {
        stroke: #ddd;
      }

      .axis.slice {
        opacity: 0;
      }

      .axis.slice .tick line {
        stroke-dasharray: 2;
      }

      .small .axis text {
        display: none;
      }
      .small .axis .tick:first-of-type text {
        display: block;
      }
      .small .axis .tick:last-of-type text {
        display: block;
      }
      .medium .axis text {
        display: none;
      }
      .medium .axis .tick:nth-child(2n + 1) text {
        display: block;
      }
      .large .axis text {
        display: none;
      }
      .large .axis .tick:nth-child(2n + 1) text {
        display: block;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],Ma.prototype,"mode",void 0);E([A({type:String}),w("design:type",String)],Ma.prototype,"timeProperty",void 0);E([A({type:String}),w("design:type",String)],Ma.prototype,"bins",void 0);E([A({type:String}),w("design:type",String)],Ma.prototype,"x",void 0);E([A({type:String}),w("design:type",String)],Ma.prototype,"dx",void 0);E([A({type:String}),w("design:type",String)],Ma.prototype,"y",void 0);E([A({type:Object}),w("design:type",Object)],Ma.prototype,"colorScale",void 0);E([A({type:Number}),w("design:type",Number)],Ma.prototype,"modeTransitionDuration",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Ma.prototype,"_attached",void 0);E([A({type:String}),w("design:type",Object)],Ma.prototype,"_name",void 0);E([A({type:Array}),w("design:type",Object)],Ma.prototype,"_data",void 0);E([Bt("timeProperty","colorScale","_attached"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ma.prototype,"_redrawOnChange",null);E([Bt("mode"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ma.prototype,"_modeRedraw",null);Ma=E([yt("vz-histogram-timeseries")],Ma);function pur(e){let[t,r,n]=e;return{wall_time:t,step:r,min:Lm(n.map(([i,,])=>i)),max:lu(n.map(([,i])=>i)),buckets:n.map(([i,o,a])=>({left:i,right:o,count:a}))}}function dur(e,t,r,n=30){(t===void 0||r==null)&&(t=0,r=0),r===t&&(r=t*1.1+1,t=t/1.1-1);let i=(r-t)/n,o=0,a=[];for(let s=0;s<n;s++){let l=t+s*i,c=l+i,u=0;for(;o<e.buckets.length;){let h=Math.min(r,e.buckets[o].right),f=Math.max(t,e.buckets[o].left);if(h-f>0){let d=Math.min(h,c)-Math.max(f,l),g=d/(h-f)*e.buckets[o].count;u+=d>0?g:0}else{let d=c>=r;u+=l<=f&&(d?h<=c:h<c)?e.buckets[o].count:0}if(h>c)break;o++}a.push({x:l,dx:i,y:u})}return a}function rce(e){let t=e.map(pur),r=Lm(t,i=>i.min),n=lu(t,i=>i.max);return t.map(i=>({wall_time:i.wall_time,step:i.step,bins:dur(i,r,n)}))}var Ea=class extends kS(Gt(mt)){constructor(){super(...arguments),this.getDataLoadName=({run:t})=>t,this.requestData=(t,r,n)=>{let o=ve().pluginRoute("histograms","/histograms");Promise.all(t.map(a=>{let s=Cn(o,{tag:a.tag,run:a.run});return this.requestManager.request(s).then(l=>void r({item:a,data:l}))})).finally(()=>void n())},this.loadDataCallback=(t,r,n)=>{let i=rce(n),o=this.getDataLoadName(r);this.$.chart.setSeriesData(o,i)},this._colorScaleFunction=fn,this._expanded=!1}_reloadOnRunTagRequestManagerChange(){this.reload()}_updateDataToLoad(){var t=this.run,r=this.tag;this.dataToLoad=[{run:t,tag:r}]}get _runColor(){var t=this.run;return this._colorScaleFunction(t)}redraw(){this.$.chart.redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}};Ea.template=Q`
    <tf-card-heading
      tag="[[tag]]"
      run="[[run]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
      color="[[_runColor]]"
    ></tf-card-heading>
    <!--
      The main histogram that we render. Data is set directly with
      \`setSeriesData\`, not with a bound property.
    -->
    <vz-histogram-timeseries
      id="chart"
      time-property="[[timeProperty]]"
      mode="[[histogramMode]]"
      color-scale="[[_colorScaleFunction]]"
    ></vz-histogram-timeseries>
    <div style="display: flex; flex-direction: row;">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
    </div>
    <style>
      :host {
        display: flex;
        flex-direction: column;
        width: 330px;
        height: 235px;
        margin-right: 10px;
        margin-bottom: 15px;
      }
      :host([_expanded]) {
        width: 700px;
        height: 500px;
      }

      vz-histogram-timeseries {
        -moz-user-select: none;
        -webkit-user-select: none;
        will-change: transform;
      }

      paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }

      paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }

      tf-card-heading {
        margin-bottom: 10px;
        width: 90%;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],Ea.prototype,"run",void 0);E([A({type:String}),w("design:type",String)],Ea.prototype,"tag",void 0);E([A({type:Object}),w("design:type",Object)],Ea.prototype,"getDataLoadName",void 0);E([A({type:Object}),w("design:type",Ae)],Ea.prototype,"requestManager",void 0);E([A({type:Object}),w("design:type",Object)],Ea.prototype,"loadDataCallback",void 0);E([A({type:Object}),w("design:type",Object)],Ea.prototype,"tagMetadata",void 0);E([A({type:String}),w("design:type",String)],Ea.prototype,"timeProperty",void 0);E([A({type:String}),w("design:type",String)],Ea.prototype,"histogramMode",void 0);E([A({type:Object}),w("design:type",Function)],Ea.prototype,"_colorScaleFunction",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],Ea.prototype,"_expanded",void 0);E([Bt("run","tag","requestManager"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ea.prototype,"_reloadOnRunTagRequestManagerChange",null);E([Bt("run","tag"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Ea.prototype,"_updateDataToLoad",null);E([Rt("run"),w("design:type",String),w("design:paramtypes",[])],Ea.prototype,"_runColor",null);Ea=E([yt("tf-histogram-loader")],Ea);var ls=class extends Gt(mt){constructor(){super(...arguments),this.reloadOnReady=!0,this._histogramMode="offset",this._timeProperty="step",this._restamp=!1,this._requestManager=new Ae}_redrawCategoryPane(t,r){!r||t.target.querySelectorAll("tf-histogram-loader").forEach(n=>n.redraw())}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then(()=>{this._reloadHistograms()})}_fetchTags(){let t=ve().pluginRoute("histograms","/tags");return this._requestManager.request(t).then(r=>{if(RH.isEqual(r,this._runToTagInfo))return;let n=RH.mapValues(r,o=>Object.keys(o)),i=$i(n);this.set("_dataNotFound",i.length===0),this.set("_runToTag",n),this.set("_runToTagInfo",r),this.async(()=>{this.set("_categoriesDomReady",!0)})})}_reloadHistograms(){var t;(t=this.root)==null||t.querySelectorAll("tf-histogram-loader").forEach(r=>{r.reload()})}_shouldOpen(t){return t<=2}get _categories(){var t=this._runToTag,r=this._selectedRuns,n=this._tagFilter,i=this._categoriesDomReady;return Ql(t,r,n)}_tagMetadata(t,r,n){return t[r][n]}};ls.template=Q`
    <tf-dashboard-layout>
      <div slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <tf-option-selector
              id="histogramModeSelector"
              name="Histogram mode"
              selected-id="{{_histogramMode}}"
            >
              <paper-button id="overlay">overlay</paper-button>
              <paper-button id="offset">offset</paper-button>
            </tf-option-selector>
          </div>
          <div class="sidebar-section">
            <tf-option-selector
              id="timePropertySelector"
              name="Offset time axis"
              selected-id="{{_timeProperty}}"
            >
              <paper-button id="step">step</paper-button>
              <paper-button id="relative">relative</paper-button>
              <paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No histogram data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>
                You haven’t written any histogram data to your event files.
              </li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-histogram-loader
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  active="[[active]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.run, item.tag)]]"
                  time-property="[[_timeProperty]]"
                  histogram-mode="[[_histogramMode]]"
                  request-manager="[[_requestManager]]"
                ></tf-histogram-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],ls.prototype,"reloadOnReady",void 0);E([A({type:String}),w("design:type",String)],ls.prototype,"_histogramMode",void 0);E([A({type:String}),w("design:type",String)],ls.prototype,"_timeProperty",void 0);E([A({type:Array}),w("design:type",Array)],ls.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],ls.prototype,"_runToTag",void 0);E([A({type:Object}),w("design:type",Object)],ls.prototype,"_runToTagInfo",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ls.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],ls.prototype,"_tagFilter",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ls.prototype,"_restamp",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ls.prototype,"_categoriesDomReady",void 0);E([A({type:Object}),w("design:type",Ae)],ls.prototype,"_requestManager",void 0);E([Rt("_runToTag","_selectedRuns","_tagFilter","_categoriesDomReady"),w("design:type",Array),w("design:paramtypes",[])],ls.prototype,"_categories",null);ls=E([yt("tf-histogram-dashboard")],ls);var u3=class{constructor(t,r,n=!0){this._apiUrl=t,this._requestManager=r,this._useHttpGet=n}getExperiment(t){return this._sendRequest("experiment",t)}getDownloadUrl(t,r,n){return this._apiUrl+"/download_data?"+new URLSearchParams({format:t,columnsVisibility:JSON.stringify(n),request:JSON.stringify(r)})}listSessionGroups(t){return this._sendRequest("session_groups",t)}listMetricEvals(t){return this._sendRequest("metric_evals",t)}_sendRequest(t,r){if(this._useHttpGet){let o=encodeURIComponent(JSON.stringify(r)),a=this._apiUrl+"/"+t+"?request="+o;return this._requestManager.request(a)}let n=new Ux;n.withCredentials=!0,n.methodType=Am.POST,n.contentType="text/plain",n.body=JSON.stringify(r);let i=this._apiUrl+"/"+t;return this._requestManager.requestWithOptions(i,n)}};var fce=Ee(Oe(),1);var NH=class extends mt{constructor(){super(...arguments),this.orientation="horizontal"}};NH.template=Q`
    <slot name="content"></slot>

    <style>
      :host {
        display: block;
      }

      :host slot {
        display: flex;
        height: 100%;
        width: 100%;
      }

      :host ::slotted(*) {
        flex: 0 0 auto;
      }

      :host([orientation='horizontal']) slot {
        flex-direction: row;
        overflow-x: auto;
      }

      :host([orientation='vertical']) slot {
        flex-direction: column;
        overflow-y: auto;
      }

      :host ::slotted(*:not(:last-child)) {
        border: 0 solid var(--divider-color, #ccc);
      }

      :host([orientation='vertical']) ::slotted(*:not(:last-child)) {
        border-bottom-width: 5px;
      }

      :host([orientation='horizontal']) ::slotted(*:not(:last-child)) {
        border-right-width: 5px;
      }
    </style>
  `;E([A({type:String,reflectToAttribute:!0}),w("design:type",String)],NH.prototype,"orientation",void 0);NH=E([yt("hparams-split-layout")],NH);var cs={};Ks(cs,{columnValueByIndex:()=>x0,columnValueByVisibleIndex:()=>FH,euclideanDist:()=>h3,filterSet:()=>Mur,getAbsoluteColumnIndex:()=>OH,hashOfString:()=>mct,hparamName:()=>Fd,hparamValueByIndex:()=>ace,hparamValueByName:()=>oce,hparamValueByVisibleIndex:()=>uce,isNullOrUndefined:()=>bur,l2NormSquared:()=>p3,metricName:()=>Qu,metricValueByIndex:()=>sce,metricValueByName:()=>f3,metricValueByVisibleIndex:()=>zH,numColumns:()=>hct,numHParams:()=>nce,numMetrics:()=>ice,numVisibleColumns:()=>_ur,numVisibleHParams:()=>lce,numVisibleMetrics:()=>cce,numericColumnExtent:()=>fct,pointToRectangleDist:()=>hce,prettyPrint:()=>b0,prettyPrintHParamValueByName:()=>yur,prettyPrintMetricValueByName:()=>vur,quadTreeVisitPointsInDisk:()=>Sur,quadTreeVisitPointsInRect:()=>wur,rotateStr:()=>xur,schemaColumnName:()=>uct,schemaVisibleColumnName:()=>gur,sessionGroupWithName:()=>pct,setArrayObservably:()=>dct,translateStr:()=>_P,visibleNumericColumnExtent:()=>gP});var DH=Ee(Oe(),1);function Fd(e){return e.displayName!==""&&e.displayName!==void 0?e.displayName:e.name}function Qu(e){if(e.displayName!==""&&e.displayName!==void 0)return e.displayName;let t=e.name.group,r=e.name.tag;return t===void 0&&(t=""),r===void 0&&(r=""),t===""?r:t+"."+r}function uct(e,t){if(t<e.hparamColumns.length)return Fd(e.hparamColumns[t].hparamInfo);let r=t-e.hparamColumns.length;return Qu(e.metricColumns[r].metricInfo)}function nce(e){return e.hparamColumns.length}function ice(e){return e.metricColumns.length}function hct(e){return nce(e)+ice(e)}function oce(e,t){return e[t]}function f3(e,t){return e.find(r=>DH.isEqual(r.name,t))}function ace(e,t,r){return t.hparams[e.hparamColumns[r].hparamInfo.name]}function sce(e,t,r){let n=e.metricColumns[r].metricInfo.name,i=f3(t.metricValues,n);return i===void 0?void 0:i.value}function x0(e,t,r){return r<e.hparamColumns.length?ace(e,t,r):sce(e,t,r-e.hparamColumns.length)}function fct(e,t,r){return aa(t,n=>x0(e,n,r))}function OH(e,t,r){let n;if(r<t.hparamInfos.length)n=e.hparamColumns.findIndex(i=>i.hparamInfo.name===t.hparamInfos[r].name);else{let i=r-t.hparamInfos.length,o=t.metricInfos[i].name;n=e.hparamColumns.length+e.metricColumns.findIndex(a=>a.metricInfo.name===o)}return console.assert(n!==-1),n}function gur(e,t){if(t<e.hparamInfos.length)return Fd(e.hparamInfos[t]);let r=t-e.hparamInfos.length;return Qu(e.metricInfos[r])}function lce(e){return e.hparamInfos.length}function cce(e){return e.metricInfos.length}function _ur(e){return lce(e)+cce(e)}function gP(e,t,r){return aa(t,n=>FH(e,n,r))}function yur(e,t){return b0(oce(e,t))}function vur(e,t){return b0(f3(e,t))}function pct(e,t){return e.find(r=>r.name===t)}function uce(e,t,r){return t.hparams[e.hparamInfos[r].name]}function zH(e,t,r){let n=e.metricInfos[r].name,i=f3(t.metricValues,n);return i===void 0?void 0:i.value}function FH(e,t,r){return r<e.hparamInfos.length?uce(e,t,r):zH(e,t,r-e.hparamInfos.length)}function b0(e){return DH.isNumber(e)?e.toPrecision(5):e===void 0?"":e.toString()}function p3(e,t){return e*e+t*t}function h3(e,t,r,n){return Math.sqrt(p3(e-r,t-n))}function hce(e,t,r,n,i,o){if(e<r&&t<n)return h3(e,t,r,n);if(r<=e&&e<i&&t<n)return n-t;if(i<=e&&t<n)return h3(e,t,i,n);if(e<r&&n<=t&&t<o)return r-e;if(r<=e&&e<i&&n<=t&&t<o)return 0;if(i<=e&&n<=t&&t<o)return e-i;if(e<r&&o<=t)return h3(e,t,r,o);if(r<=e&&e<i&&o<=t)return t-o;if(i<=e&&o<=t)return h3(e,t,i,o);throw"Point (x,y) must be in one of the regions defined above."}function _P(e,t){return t===void 0?"translate("+e+")":"translate("+e+","+t+")"}function xur(e,t,r){let n="rotate("+e;return t!==void 0&&r!==void 0&&(n=n+","+t+","+r),n=n+")",n}function bur(e){return e==null}function wur(e,t,r,n,i,o){e.visit((a,s,l,c,u)=>{if(a.length===void 0){do{let h=e.x()(a.data),f=e.y()(a.data);t<=h&&h<n&&r<=f&&f<i&&o(a.data)}while(a=a.next);return!0}return s>=n||c<=t||l>=i||u<=r})}function Sur(e,t,r,n,i){e.visit((o,a,s,l,c)=>{if(o.length===void 0){do{let u=e.x()(o.data),h=e.y()(o.data),f=h3(t,r,u,h);f<=n&&i(o.data,f)}while(o=o.next);return!0}return hce(t,r,a,s,l,c)>n})}function Mur(e,t){let r=new Set;return e.forEach(n=>{t(n)&&r.add(n)}),r}function dct(e,t,r){let n=e.get(t,e);if(!Array.isArray(n)){e.set(t,r);return}e.splice.apply(e,[t,0,n.length].concat(r))}function mct(e){let t=0;for(let r=0;r<e.length;++r)t=t*31+e.charCodeAt(r)&4294967295;return t+EI(2,31)}var ti=class extends Gt(mt){constructor(){super(...arguments),this.configuration={schema:{hparamColumns:Array(),metricColumns:Array()},columnsVisibility:Array(),visibleSchema:{hparamInfos:Array(),metricInfos:Array()}},this.sessionGroups=[],this.dataLoadedWithNonEmptyHparams=!1,this.dataLoadedWithEmptyHparams=!1,this._statuses=[{value:"STATUS_UNKNOWN",displayName:"Unknown",allowed:!0},{value:"STATUS_SUCCESS",displayName:"Success",allowed:!0},{value:"STATUS_FAILURE",displayName:"Failure",allowed:!0},{value:"STATUS_RUNNING",displayName:"Running",allowed:!0}],this._getExperimentResolved=new Promise(t=>{this._resolveGetExperiment=t}),this._listSessionGroupsCanceller=new an,this._pageSizeInput={value:"100",invalid:!1},this._pageNumberInput={value:"1",invalid:!1},this._pageCountStr="?",this._hparamName=Fd,this._metricName=Qu,this._prettyPrint=b0}reload(){this._queryServer()}_csvUrl(t,r){return this._downloadDataUrl(t,r,"csv")}_jsonUrl(t,r){return this._downloadDataUrl(t,r,"json")}_latexUrl(t,r){return this._downloadDataUrl(t,r,"latex")}_downloadDataUrl(t,r,n){let i=r.columnsVisibility;return this.backend.getDownloadUrl(n,t,i)}_computeExperimentAndRelatedProps(){let t=cs;if(t.isNullOrUndefined(this.backend)||t.isNullOrUndefined(this.experimentName))return;let r={experimentName:this.experimentName};this.backend.getExperiment(r).then(n=>{fce.isEqual(n,this._experiment)||(this.set("_experiment",n),this._computeHParams(),this._computeMetrics(),this._queryServer(),this._resolveGetExperiment())}).finally(()=>{this._computeDataFound()})}_computeDataFound(){let t=Boolean(this._experiment&&this._experiment.hparamInfos&&this._experiment.hparamInfos.length>0&&this._experiment.metricInfos&&this._experiment.metricInfos.length>0);this.set("dataLoadedWithNonEmptyHparams",t),this.set("dataLoadedWithEmptyHparams",!t)}_computeHParams(){let t=[];this._experiment.hparamInfos.forEach((n,i)=>{let o={info:n,displayed:i<5,filter:{}};o.info.hasOwnProperty("domainDiscrete")?(o.filter.domainDiscrete=[],o.info.domainDiscrete.forEach(a=>{o.filter.domainDiscrete.push({value:a,checked:!0})})):o.info.type==="DATA_TYPE_BOOL"?o.filter.domainDiscrete=[{value:!1,checked:!0},{value:!0,checked:!0}]:o.info.type==="DATA_TYPE_FLOAT64"?o.filter.interval={min:{value:"",invalid:!1},max:{value:"",invalid:!1}}:o.info.type==="DATA_TYPE_STRING"?o.filter.regexp="":console.warn("unknown hparam.info.type: %s",o.info.type),t.push(o)}),this.set("_hparams",t)}_computeMetrics(){let t=[];this._experiment.metricInfos.forEach((n,i)=>{let o={info:n,filter:{interval:{min:{value:"",invalid:!1},max:{value:"",invalid:!1}}},displayed:i<5};t.push(o)}),this.set("_metrics",t)}_computeSchema(){return!this._hparams||!this._metrics?{hparamColumns:[],metricColumns:[]}:{hparamColumns:this._hparams.map(t=>({hparamInfo:t.info})),metricColumns:this._metrics.map(t=>({metricInfo:t.info}))}}_updateConfiguration(){this.debounce("_updateConfiguration",()=>{this.configuration={schema:this._computeSchema(),columnsVisibility:this._computeColumnsVisibility(),visibleSchema:this._computeVisibleSchema()}})}_computeColumnsVisibility(){return!this._hparams||!this._metrics?[]:this._hparams.map(t=>t.displayed).concat(this._metrics.map(t=>t.displayed))}_computeVisibleSchema(){if(!this._hparams||!this._metrics)return{hparamInfos:[],metricInfos:[]};let t=this._hparams.filter(n=>n.displayed).map(n=>n.info),r=this._metrics.filter(n=>n.displayed).map(n=>n.info);return{hparamInfos:t,metricInfos:r}}_queryServer(){this.debounce("queryServer",()=>this._queryServerNoDebounce(),100)}_queryServerNoDebounce(){if(!(!this._hparams||!this._metrics))return this._sendListSessionGroupsRequest().then(this._listSessionGroupsCanceller.cancellable(({value:t,cancelled:r})=>{if(!r){if(t.totalSize>=0){let n=+this._pageSizeInput.value;this.set("_pageCountStr",String(Math.ceil(t.totalSize/n))),this.set("_totalSessionGroupsCountStr",t.totalSize)}else this.set("_pageCountStr","?"),this.set("_totalSessionGroupsCountStr","Unknown");dct(this,"sessionGroups",t.sessionGroups)}}))}_sendListSessionGroupsRequest(){let t=this._buildListSessionGroupsRequest();if(t!==null)return this.set("_sessionGroupsRequest",t),this._listSessionGroupsCanceller.cancelAll(),this.backend.listSessionGroups(t)}_buildListSessionGroupsRequest(){let t=this,r=!0;function n(u){let h=t.get(u+".min.value");console.assert(h!==void 0);let f=h===""?"-Infinity":+h;t.set(u+".min.invalid",isNaN(f)),r=r&&!isNaN(f);let p=t.get(u+".max.value");console.assert(p!==void 0);let d=p===""?"Infinity":+p;return t.set(u+".max.invalid",isNaN(d)),r=r&&!isNaN(d),isNaN(f)||isNaN(d)?null:{minValue:f,maxValue:d}}function i(u){let h=t.get(u+".value");console.assert(h!==void 0);let f=+h,p=Number.isInteger(f)&&f>0;return t.set(u+".invalid",!p),r=r&&p,p?f:null}let o=this._statuses.filter(u=>u.allowed).map(u=>u.value),a=[];if(this._hparams.forEach((u,h)=>{let f={hparam:u.info.name};u.filter.domainDiscrete?(f.filterDiscrete=[],u.filter.domainDiscrete.forEach(p=>{p.checked&&f.filterDiscrete.push(p.value)})):u.filter.interval?f.filterInterval=n("_hparams."+h+".filter.interval"):u.filter.regexp&&(f.filterRegexp=u.filter.regexp),a.push(f)}),this._metrics.forEach((u,h)=>{let f={metric:u.info.name,filterInterval:n("_metrics."+h+".filter.interval")};a.push(f)}),this._sortByIndex!==void 0&&this._sortDirection!==void 0){if(!(this._sortByIndex in a))return console.error("No column in colParams with index sortByIndex: %s",this._sortByIndex),null;a[this._sortByIndex].order=this._sortDirection===0?"ORDER_ASC":"ORDER_DESC"}let s=i("_pageNumberInput")||0,l=i("_pageSizeInput")||0;if(!r)return null;let c=l*(s-1);return{experimentName:this.experimentName,allowedStatuses:o,colParams:a,startIndex:c,sliceSize:l}}_metricSortByIndex(t){return t+this._hparams.length}};ti.template=Q`
    <hparams-split-layout orientation="vertical">
      <div slot="content" class="section hyperparameters">
        <div class="section-title">Hyperparameters</div>
        <template is="dom-repeat" items="{{_hparams}}" as="hparam">
          <div class="hparam">
            <paper-checkbox
              checked="{{hparam.displayed}}"
              class="hparam-checkbox"
            >
              [[_hparamName(hparam.info)]]
            </paper-checkbox>
            <!-- Precisely one of the templates below will be stamped.-->
            <!-- 1. A list of checkboxes -->
            <template is="dom-if" if="[[hparam.filter.domainDiscrete]]">
              <template
                is="dom-repeat"
                items="[[hparam.filter.domainDiscrete]]"
              >
                <paper-checkbox
                  checked="{{item.checked}}"
                  class="discrete-value-checkbox"
                  on-change="_queryServer"
                >
                  [[_prettyPrint(item.value)]]
                </paper-checkbox>
              </template>
            </template>
            <!-- 2. A numeric interval -->
            <template is="dom-if" if="[[hparam.filter.interval]]">
              <paper-input
                label="Min"
                value="{{hparam.filter.interval.min.value}}"
                allowed_pattern="[0-9.e\\-]"
                on-value-changed="_queryServer"
                error-message="Invalid input"
                invalid="[[hparam.filter.interval.min.invalid]]"
                placeholder="-infinity"
              >
              </paper-input>
              <paper-input
                label="Max"
                value="{{hparam.filter.interval.max.value}}"
                allowed_pattern="[0-9.e\\-]"
                on-value-changed="_queryServer"
                error-message="Invalid input"
                invalid="[[hparam.filter.interval.max.invalid]]"
                placeholder="+infinity"
              >
              </paper-input>
            </template>
            <!-- 3. A regexp -->
            <template is="dom-if" if="[[hparam.filter.regexp]]">
              <paper-input
                label="Regular expression"
                value="{{hparam.filter.regexp}}"
                on-value-changed="_queryServer"
              >
              </paper-input>
            </template>
          </div>
        </template>
      </div>
      <div slot="content" class="section metrics">
        <div class="section-title">Metrics</div>
        <template is="dom-repeat" items="{{_metrics}}" as="metric">
          <div class="metric">
            <!-- TODO(erez): Make it easier to handle a large number of
                  metrics:
                  1. Add an 'isolator' radio-button to select just one
                  metric and
                  hide all the rest
                  2. Add a 'toggle-all' button that will hide/unhide
                    all the
                  metrics.
                  Use similar logic/appearance to the run-selector of
                  scalars.-->
            <paper-checkbox
              checked="{{metric.displayed}}"
              class="metric-checkbox"
            >
              [[_metricName(metric.info)]]
            </paper-checkbox>
            <div class="inline-element">
              <paper-input
                label="Min"
                value="{{metric.filter.interval.min.value}}"
                allowed-pattern="[0-9.e\\-]"
                on-value-changed="_queryServer"
                error-message="Invalid input"
                invalid="{{metric.filter.interval.min.invalid}}"
                placeholder="-infinity"
              >
              </paper-input>
            </div>
            <div class="inline-element">
              <paper-input
                label="Max"
                allowed-pattern="[0-9.e\\-]"
                value="{{metric.filter.interval.max.value}}"
                on-value-changed="_queryServer"
                error-message="Invalid input"
                invalid="{{metric.filter.interval.max.invalid}}"
                placeholder="+infinity"
              >
              </paper-input>
            </div>
          </div>
        </template>
      </div>
      <div slot="content" class="section status">
        <div class="section-title">Status</div>
        <template is="dom-repeat" items="[[_statuses]]" as="status">
          <paper-checkbox checked="{{status.allowed}}" on-change="_queryServer">
            [[status.displayName]]
          </paper-checkbox>
        </template>
      </div>
      <div slot="content" class="section sorting">
        <div class="section-title">Sorting</div>
        <paper-dropdown-menu
          label="Sort by"
          on-selected-item-changed="_queryServer"
          horizontal-align="left"
        >
          <paper-listbox
            class="dropdown-content"
            slot="dropdown-content"
            selected="{{_sortByIndex}}"
            on-selected-item-changed="_queryServer"
          >
            <template is="dom-repeat" items="[[_hparams]]" as="hparam">
              <paper-item> [[_hparamName(hparam.info)]] </paper-item>
            </template>
            <template is="dom-repeat" items="[[_metrics]]" as="metric">
              <paper-item> [[_metricName(metric.info)]] </paper-item>
            </template>
          </paper-listbox>
        </paper-dropdown-menu>
        <paper-dropdown-menu
          label="Direction"
          on-selected-item-changed="_queryServer"
          horizontal-align="left"
        >
          <paper-listbox
            class="dropdown-content"
            slot="dropdown-content"
            selected="{{_sortDirection}}"
          >
            <paper-item>Ascending</paper-item>
            <paper-item>Descending</paper-item>
          </paper-listbox>
        </paper-dropdown-menu>
      </div>
      <div slot="content" class="section paging">
        <div class="section-title">Paging</div>
        <div>
          Number of matching session groups: [[_totalSessionGroupsCountStr]]
        </div>
        <div class="inline-element page-number-input">
          <paper-input
            label="Page #"
            value="{{_pageNumberInput.value}}"
            allowed-pattern="[0-9]"
            error-message="Invalid input"
            invalid="[[_pageNumberInput.invalid]]"
            on-value-changed="_queryServer"
          >
            <div slot="suffix" class="page-suffix">/ [[_pageCountStr]]</div>
          </paper-input>
        </div>
        <div class="inline-element page-size-input">
          <paper-input
            label="Max # of session groups per page:"
            value="{{_pageSizeInput.value}}"
            allowed-pattern="[0-9]"
            error-message="Invalid input"
            invalid="[[_pageSizeInput.invalid]]"
            on-value-changed="_queryServer"
          >
          </paper-input>
        </div>
      </div>
      <div slot="content" class="section download">
        <template is="dom-if" if="[[_sessionGroupsRequest]]">
          Download data as
          <span>
            <a
              id="csvLink"
              download="hparams_table.csv"
              href="[[_csvUrl(_sessionGroupsRequest, configuration)]]"
              >CSV</a
            >
            <a
              id="jsonLink"
              download="hparams_table.json"
              href="[[_jsonUrl(_sessionGroupsRequest, configuration)]]"
              >JSON</a
            >
            <a
              id="latexLink"
              download="hparams_table.tex"
              href="[[_latexUrl(_sessionGroupsRequest, configuration)]]"
              >LaTeX</a
            >
          </span>
        </template>
      </div>
    </hparams-split-layout>
    <style>
      .section {
        padding: 10px;
      }
      .section-title {
        display: block;
        font-weight: bold;
        text-decoration: underline;
        margin-bottom: 7px;
      }
      .discrete-value-checkbox,
      .metric-checkbox,
      .hparam-checkbox {
        display: block;
      }
      .discrete-value-checkbox {
        margin-left: 20px;
      }
      .hparam,
      .metric {
        display: block;
      }
      .inline-element {
        display: inline-block;
        width: 40%;
        margin-left: 10px;
      }
      .page-number-input {
        width: 20%;
      }
      .page-size-input {
        width: 60%;
      }
      vaadin-split-layout {
        height: 100%;
      }
      paper-listbox {
        max-height: 15em;
      }
      .page-suffix {
        white-space: nowrap;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],ti.prototype,"experimentName",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],ti.prototype,"configuration",void 0);E([A({type:Array,notify:!0}),w("design:type",Object)],ti.prototype,"sessionGroups",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],ti.prototype,"dataLoadedWithNonEmptyHparams",void 0);E([A({type:Boolean,notify:!0}),w("design:type",Boolean)],ti.prototype,"dataLoadedWithEmptyHparams",void 0);E([A({type:Object}),w("design:type",Object)],ti.prototype,"_experiment",void 0);E([A({type:Array}),w("design:type",Array)],ti.prototype,"_hparams",void 0);E([A({type:Array}),w("design:type",Array)],ti.prototype,"_metrics",void 0);E([A({type:Array}),w("design:type",Object)],ti.prototype,"_statuses",void 0);E([A({type:Object}),w("design:type",Object)],ti.prototype,"_getExperimentResolved",void 0);E([A({type:Object}),w("design:type",Function)],ti.prototype,"_resolveGetExperiment",void 0);E([A({type:Object}),w("design:type",Object)],ti.prototype,"_listSessionGroupsCanceller",void 0);E([A({type:Number}),w("design:type",Number)],ti.prototype,"_sortByIndex",void 0);E([A({type:Number}),w("design:type",Number)],ti.prototype,"_sortDirection",void 0);E([A({type:Object}),w("design:type",Object)],ti.prototype,"_pageSizeInput",void 0);E([A({type:Object}),w("design:type",Object)],ti.prototype,"_pageNumberInput",void 0);E([A({type:String}),w("design:type",String)],ti.prototype,"_pageCountStr",void 0);E([A({type:String}),w("design:type",String)],ti.prototype,"_totalSessionGroupsCountStr",void 0);E([A({type:Object}),w("design:type",Object)],ti.prototype,"_sessionGroupsRequest",void 0);E([Bt("backend","experimentName"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],ti.prototype,"_computeExperimentAndRelatedProps",null);E([Bt("_hparams.*","_metrics.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],ti.prototype,"_updateConfiguration",null);ti=E([yt("tf-hparams-query-pane")],ti);var qct=Ee(Oe(),1);var gct=typeof window!="undefined"&&window.customElements!=null&&window.customElements.polyfillWrapFlushCallback!==void 0;var iv=(e,t,r=null)=>{for(;t!==r;){let n=t.nextSibling;e.removeChild(t),t=n}};var Yc=`{{lit-${String(Math.random()).slice(2)}}}`,_ct=`<!--${Yc}-->`,pce=new RegExp(`${Yc}|${_ct}`),d3="$lit$",ov=class{constructor(t,r){this.parts=[],this.element=r;let n=[],i=[],o=document.createTreeWalker(r.content,133,null,!1),a=0,s=-1,l=0,{strings:c,values:{length:u}}=t;for(;l<u;){let h=o.nextNode();if(h===null){o.currentNode=i.pop();continue}if(s++,h.nodeType===1){if(h.hasAttributes()){let f=h.attributes,{length:p}=f,d=0;for(let g=0;g<p;g++)dce(f[g].name,d3)&&d++;for(;d-- >0;){let g=c[l],_=BH.exec(g)[2],y=_.toLowerCase()+d3,x=h.getAttribute(y);h.removeAttribute(y);let b=x.split(pce);this.parts.push({type:"attribute",index:s,name:_,strings:b}),l+=b.length-1}}h.tagName==="TEMPLATE"&&(i.push(h),o.currentNode=h.content)}else if(h.nodeType===3){let f=h.data;if(f.indexOf(Yc)>=0){let p=h.parentNode,d=f.split(pce),g=d.length-1;for(let _=0;_<g;_++){let y,x=d[_];if(x==="")y=Yf();else{let b=BH.exec(x);b!==null&&dce(b[2],d3)&&(x=x.slice(0,b.index)+b[1]+b[2].slice(0,-d3.length)+b[3]),y=document.createTextNode(x)}p.insertBefore(y,h),this.parts.push({type:"node",index:++s})}d[g]===""?(p.insertBefore(Yf(),h),n.push(h)):h.data=d[g],l+=g}}else if(h.nodeType===8)if(h.data===Yc){let f=h.parentNode;(h.previousSibling===null||s===a)&&(s++,f.insertBefore(Yf(),h)),a=s,this.parts.push({type:"node",index:s}),h.nextSibling===null?h.data="":(n.push(h),s--),l++}else{let f=-1;for(;(f=h.data.indexOf(Yc,f+1))!==-1;)this.parts.push({type:"node",index:-1}),l++}}for(let h of n)h.parentNode.removeChild(h)}},dce=(e,t)=>{let r=e.length-t.length;return r>=0&&e.slice(r)===t},yP=e=>e.index!==-1,Yf=()=>document.createComment(""),BH=/([ \x09\x0a\x0c\x0d])([^\0-\x1F\x7F-\x9F "'>=/]+)([ \x09\x0a\x0c\x0d]*=[ \x09\x0a\x0c\x0d]*(?:[^ \x09\x0a\x0c\x0d"'`<>=]*|"[^"]*|'[^']*))$/;var yct=133;function vct(e,t){let{element:{content:r},parts:n}=e,i=document.createTreeWalker(r,yct,null,!1),o=vP(n),a=n[o],s=-1,l=0,c=[],u=null;for(;i.nextNode();){s++;let h=i.currentNode;for(h.previousSibling===u&&(u=null),t.has(h)&&(c.push(h),u===null&&(u=h)),u!==null&&l++;a!==void 0&&a.index===s;)a.index=u!==null?-1:a.index-l,o=vP(n,o),a=n[o]}c.forEach(h=>h.parentNode.removeChild(h))}var Eur=e=>{let t=e.nodeType===11?0:1,r=document.createTreeWalker(e,yct,null,!1);for(;r.nextNode();)t++;return t},vP=(e,t=-1)=>{for(let r=t+1;r<e.length;r++){let n=e[r];if(yP(n))return r}return-1};function mce(e,t,r=null){let{element:{content:n},parts:i}=e;if(r==null){n.appendChild(t);return}let o=document.createTreeWalker(n,yct,null,!1),a=vP(i),s=0,l=-1;for(;o.nextNode();)for(l++,o.currentNode===r&&(s=Eur(t),r.parentNode.insertBefore(t,r));a!==-1&&i[a].index===l;){if(s>0){for(;a!==-1;)i[a].index+=s,a=vP(i,a);return}a=vP(i,a)}}var Tur=new WeakMap;var av=e=>typeof e=="function"&&Tur.has(e);var Ll={},HH={};var w0=class{constructor(t,r,n){this.__parts=[],this.template=t,this.processor=r,this.options=n}update(t){let r=0;for(let n of this.__parts)n!==void 0&&n.setValue(t[r]),r++;for(let n of this.__parts)n!==void 0&&n.commit()}_clone(){let t=gct?this.template.element.content.cloneNode(!0):document.importNode(this.template.element.content,!0),r=[],n=this.template.parts,i=document.createTreeWalker(t,133,null,!1),o=0,a=0,s,l=i.nextNode();for(;o<n.length;){if(s=n[o],!yP(s)){this.__parts.push(void 0),o++;continue}for(;a<s.index;)a++,l.nodeName==="TEMPLATE"&&(r.push(l),i.currentNode=l.content),(l=i.nextNode())===null&&(i.currentNode=r.pop(),l=i.nextNode());if(s.type==="node"){let c=this.processor.handleTextExpression(this.options);c.insertAfterNode(l.previousSibling),this.__parts.push(c)}else this.__parts.push(...this.processor.handleAttributeExpressions(l,s.name,s.strings,this.options));o++}return gct&&(document.adoptNode(t),customElements.upgrade(t)),t}};var gce=window.trustedTypes&&trustedTypes.createPolicy("lit-html",{createHTML:e=>e}),Aur=` ${Yc} `,S0=class{constructor(t,r,n,i){this.strings=t,this.values=r,this.type=n,this.processor=i}getHTML(){let t=this.strings.length-1,r="",n=!1;for(let i=0;i<t;i++){let o=this.strings[i],a=o.lastIndexOf("<!--");n=(a>-1||n)&&o.indexOf("-->",a+1)===-1;let s=BH.exec(o);s===null?r+=o+(n?Aur:_ct):r+=o.substr(0,s.index)+s[1]+s[2]+d3+s[3]+Yc}return r+=this.strings[t],r}getTemplateElement(){let t=document.createElement("template"),r=this.getHTML();return gce!==void 0&&(r=gce.createHTML(r)),t.innerHTML=r,t}};var qH=e=>e===null||!(typeof e=="object"||typeof e=="function"),VH=e=>Array.isArray(e)||!!(e&&e[Symbol.iterator]),m3=class{constructor(t,r,n){this.dirty=!0,this.element=t,this.name=r,this.strings=n,this.parts=[];for(let i=0;i<n.length-1;i++)this.parts[i]=this._createPart()}_createPart(){return new xP(this)}_getValue(){let t=this.strings,r=t.length-1,n=this.parts;if(r===1&&t[0]===""&&t[1]===""){let o=n[0].value;if(typeof o=="symbol")return String(o);if(typeof o=="string"||!VH(o))return o}let i="";for(let o=0;o<r;o++){i+=t[o];let a=n[o];if(a!==void 0){let s=a.value;if(qH(s)||!VH(s))i+=typeof s=="string"?s:String(s);else for(let l of s)i+=typeof l=="string"?l:String(l)}}return i+=t[r],i}commit(){this.dirty&&(this.dirty=!1,this.element.setAttribute(this.name,this._getValue()))}},xP=class{constructor(t){this.value=void 0,this.committer=t}setValue(t){t!==Ll&&(!qH(t)||t!==this.value)&&(this.value=t,av(t)||(this.committer.dirty=!0))}commit(){for(;av(this.value);){let t=this.value;this.value=Ll,t(this)}this.value!==Ll&&this.committer.commit()}},Bd=class{constructor(t){this.value=void 0,this.__pendingValue=void 0,this.options=t}appendInto(t){this.startNode=t.appendChild(Yf()),this.endNode=t.appendChild(Yf())}insertAfterNode(t){this.startNode=t,this.endNode=t.nextSibling}appendIntoPart(t){t.__insert(this.startNode=Yf()),t.__insert(this.endNode=Yf())}insertAfterPart(t){t.__insert(this.startNode=Yf()),this.endNode=t.endNode,t.endNode=this.startNode}setValue(t){this.__pendingValue=t}commit(){if(this.startNode.parentNode===null)return;for(;av(this.__pendingValue);){let r=this.__pendingValue;this.__pendingValue=Ll,r(this)}let t=this.__pendingValue;t!==Ll&&(qH(t)?t!==this.value&&this.__commitText(t):t instanceof S0?this.__commitTemplateResult(t):t instanceof Node?this.__commitNode(t):VH(t)?this.__commitIterable(t):t===HH?(this.value=HH,this.clear()):this.__commitText(t))}__insert(t){this.endNode.parentNode.insertBefore(t,this.endNode)}__commitNode(t){this.value!==t&&(this.clear(),this.__insert(t),this.value=t)}__commitText(t){let r=this.startNode.nextSibling;t=t==null?"":t;let n=typeof t=="string"?t:String(t);r===this.endNode.previousSibling&&r.nodeType===3?r.data=n:this.__commitNode(document.createTextNode(n)),this.value=t}__commitTemplateResult(t){let r=this.options.templateFactory(t);if(this.value instanceof w0&&this.value.template===r)this.value.update(t.values);else{let n=new w0(r,t.processor,this.options),i=n._clone();n.update(t.values),this.__commitNode(i),this.value=n}}__commitIterable(t){Array.isArray(this.value)||(this.value=[],this.clear());let r=this.value,n=0,i;for(let o of t)i=r[n],i===void 0&&(i=new Bd(this.options),r.push(i),n===0?i.appendIntoPart(this):i.insertAfterPart(r[n-1])),i.setValue(o),i.commit(),n++;n<r.length&&(r.length=n,this.clear(i&&i.endNode))}clear(t=this.startNode){iv(this.startNode.parentNode,t.nextSibling,this.endNode)}},bP=class{constructor(t,r,n){if(this.value=void 0,this.__pendingValue=void 0,n.length!==2||n[0]!==""||n[1]!=="")throw new Error("Boolean attributes can only contain a single expression");this.element=t,this.name=r,this.strings=n}setValue(t){this.__pendingValue=t}commit(){for(;av(this.__pendingValue);){let r=this.__pendingValue;this.__pendingValue=Ll,r(this)}if(this.__pendingValue===Ll)return;let t=!!this.__pendingValue;this.value!==t&&(t?this.element.setAttribute(this.name,""):this.element.removeAttribute(this.name),this.value=t),this.__pendingValue=Ll}},wP=class extends m3{constructor(t,r,n){super(t,r,n),this.single=n.length===2&&n[0]===""&&n[1]===""}_createPart(){return new UH(this)}_getValue(){return this.single?this.parts[0].value:super._getValue()}commit(){this.dirty&&(this.dirty=!1,this.element[this.name]=this._getValue())}},UH=class extends xP{},_ce=!1;(()=>{try{let e={get capture(){return _ce=!0,!1}};window.addEventListener("test",e,e),window.removeEventListener("test",e,e)}catch(e){}})();var SP=class{constructor(t,r,n){this.value=void 0,this.__pendingValue=void 0,this.element=t,this.eventName=r,this.eventContext=n,this.__boundHandleEvent=i=>this.handleEvent(i)}setValue(t){this.__pendingValue=t}commit(){for(;av(this.__pendingValue);){let o=this.__pendingValue;this.__pendingValue=Ll,o(this)}if(this.__pendingValue===Ll)return;let t=this.__pendingValue,r=this.value,n=t==null||r!=null&&(t.capture!==r.capture||t.once!==r.once||t.passive!==r.passive),i=t!=null&&(r==null||n);n&&this.element.removeEventListener(this.eventName,this.__boundHandleEvent,this.__options),i&&(this.__options=Pur(t),this.element.addEventListener(this.eventName,this.__boundHandleEvent,this.__options)),this.value=t,this.__pendingValue=Ll}handleEvent(t){typeof this.value=="function"?this.value.call(this.eventContext||this.element,t):this.value.handleEvent(t)}},Pur=e=>e&&(_ce?{capture:e.capture,passive:e.passive,once:e.once}:e.capture);function xct(e){let t=sv.get(e.type);t===void 0&&(t={stringsArray:new WeakMap,keyString:new Map},sv.set(e.type,t));let r=t.stringsArray.get(e.strings);if(r!==void 0)return r;let n=e.strings.join(Yc);return r=t.keyString.get(n),r===void 0&&(r=new ov(e,e.getTemplateElement()),t.keyString.set(n,r)),t.stringsArray.set(e.strings,r),r}var sv=new Map;var M0=new WeakMap,bct=(e,t,r)=>{let n=M0.get(t);n===void 0&&(iv(t,t.firstChild),M0.set(t,n=new Bd(Object.assign({templateFactory:xct},r))),n.appendInto(t)),n.setValue(e),n.commit()};var GH=class{handleAttributeExpressions(t,r,n,i){let o=r[0];return o==="."?new wP(t,r.slice(1),n).parts:o==="@"?[new SP(t,r.slice(1),i.eventContext)]:o==="?"?[new bP(t,r.slice(1),n)]:new m3(t,r,n).parts}handleTextExpression(t){return new Bd(t)}},yce=new GH;typeof window!="undefined"&&(window.litHtmlVersions||(window.litHtmlVersions=[])).push("1.4.1");var xce=(e,t)=>`${e}--${t}`,WH=!0;typeof window.ShadyCSS=="undefined"?WH=!1:typeof window.ShadyCSS.prepareTemplateDom=="undefined"&&(console.warn("Incompatible ShadyCSS version detected. Please update to at least @webcomponents/webcomponentsjs@2.0.2 and @webcomponents/shadycss@1.3.1."),WH=!1);var kur=e=>t=>{let r=xce(t.type,e),n=sv.get(r);n===void 0&&(n={stringsArray:new WeakMap,keyString:new Map},sv.set(r,n));let i=n.stringsArray.get(t.strings);if(i!==void 0)return i;let o=t.strings.join(Yc);if(i=n.keyString.get(o),i===void 0){let a=t.getTemplateElement();WH&&window.ShadyCSS.prepareTemplateDom(a,e),i=new ov(t,a),n.keyString.set(o,i)}return n.stringsArray.set(t.strings,i),i},Rur=["html","svg"],Nur=e=>{Rur.forEach(t=>{let r=sv.get(xce(t,e));r!==void 0&&r.keyString.forEach(n=>{let{element:{content:i}}=n,o=new Set;Array.from(i.querySelectorAll("style")).forEach(a=>{o.add(a)}),vct(n,o)})})},bce=new Set,Dur=(e,t,r)=>{bce.add(e);let n=r?r.element:document.createElement("template"),i=t.querySelectorAll("style"),{length:o}=i;if(o===0){window.ShadyCSS.prepareTemplateStyles(n,e);return}let a=document.createElement("style");for(let c=0;c<o;c++){let u=i[c];u.parentNode.removeChild(u),a.textContent+=u.textContent}Nur(e);let s=n.content;r?mce(r,a,s.firstChild):s.insertBefore(a,s.firstChild),window.ShadyCSS.prepareTemplateStyles(n,e);let l=s.querySelector("style");if(window.ShadyCSS.nativeShadow&&l!==null)t.insertBefore(l.cloneNode(!0),t.firstChild);else if(r){s.insertBefore(a,s.firstChild);let c=new Set;c.add(a),vct(r,c)}},wce=(e,t,r)=>{if(!r||typeof r!="object"||!r.scopeName)throw new Error("The `scopeName` option is required.");let n=r.scopeName,i=M0.has(t),o=WH&&t.nodeType===11&&!!t.host,a=o&&!bce.has(n),s=a?document.createDocumentFragment():t;if(bct(e,s,Object.assign({templateFactory:kur(n)},r)),a){let l=M0.get(s);M0.delete(s);let c=l.value instanceof w0?l.value.template:void 0;Dur(n,s,c),iv(t,t.firstChild),t.appendChild(s),M0.set(t,l)}!i&&o&&window.ShadyCSS.styleElement(t.host)};var Sce;window.JSCompiler_renameProperty=(e,t)=>e;var Cct={toAttribute(e,t){switch(t){case Boolean:return e?"":null;case Object:case Array:return e==null?e:JSON.stringify(e)}return e},fromAttribute(e,t){switch(t){case Boolean:return e!==null;case Number:return e===null?null:Number(e);case Object:case Array:return JSON.parse(e)}return e}},Mce=(e,t)=>t!==e&&(t===t||e===e),wct={attribute:!0,type:String,converter:Cct,reflect:!1,hasChanged:Mce},Sct=1,Mct=1<<2,Ect=1<<3,Tct=1<<4,Act="finalized",g3=class extends HTMLElement{constructor(){super(),this.initialize()}static get observedAttributes(){this.finalize();let t=[];return this._classProperties.forEach((r,n)=>{let i=this._attributeNameForProperty(n,r);i!==void 0&&(this._attributeToPropertyMap.set(i,n),t.push(i))}),t}static _ensureClassProperties(){if(!this.hasOwnProperty(JSCompiler_renameProperty("_classProperties",this))){this._classProperties=new Map;let t=Object.getPrototypeOf(this)._classProperties;t!==void 0&&t.forEach((r,n)=>this._classProperties.set(n,r))}}static createProperty(t,r=wct){if(this._ensureClassProperties(),this._classProperties.set(t,r),r.noAccessor||this.prototype.hasOwnProperty(t))return;let n=typeof t=="symbol"?Symbol():`__${t}`,i=this.getPropertyDescriptor(t,n,r);i!==void 0&&Object.defineProperty(this.prototype,t,i)}static getPropertyDescriptor(t,r,n){return{get(){return this[r]},set(i){let o=this[t];this[r]=i,this.requestUpdateInternal(t,o,n)},configurable:!0,enumerable:!0}}static getPropertyOptions(t){return this._classProperties&&this._classProperties.get(t)||wct}static finalize(){let t=Object.getPrototypeOf(this);if(t.hasOwnProperty(Act)||t.finalize(),this[Act]=!0,this._ensureClassProperties(),this._attributeToPropertyMap=new Map,this.hasOwnProperty(JSCompiler_renameProperty("properties",this))){let r=this.properties,n=[...Object.getOwnPropertyNames(r),...typeof Object.getOwnPropertySymbols=="function"?Object.getOwnPropertySymbols(r):[]];for(let i of n)this.createProperty(i,r[i])}}static _attributeNameForProperty(t,r){let n=r.attribute;return n===!1?void 0:typeof n=="string"?n:typeof t=="string"?t.toLowerCase():void 0}static _valueHasChanged(t,r,n=Mce){return n(t,r)}static _propertyValueFromAttribute(t,r){let n=r.type,i=r.converter||Cct,o=typeof i=="function"?i:i.fromAttribute;return o?o(t,n):t}static _propertyValueToAttribute(t,r){if(r.reflect===void 0)return;let n=r.type,i=r.converter;return(i&&i.toAttribute||Cct.toAttribute)(t,n)}initialize(){this._updateState=0,this._updatePromise=new Promise(t=>this._enableUpdatingResolver=t),this._changedProperties=new Map,this._saveInstanceProperties(),this.requestUpdateInternal()}_saveInstanceProperties(){this.constructor._classProperties.forEach((t,r)=>{if(this.hasOwnProperty(r)){let n=this[r];delete this[r],this._instanceProperties||(this._instanceProperties=new Map),this._instanceProperties.set(r,n)}})}_applyInstanceProperties(){this._instanceProperties.forEach((t,r)=>this[r]=t),this._instanceProperties=void 0}connectedCallback(){this.enableUpdating()}enableUpdating(){this._enableUpdatingResolver!==void 0&&(this._enableUpdatingResolver(),this._enableUpdatingResolver=void 0)}disconnectedCallback(){}attributeChangedCallback(t,r,n){r!==n&&this._attributeToProperty(t,n)}_propertyToAttribute(t,r,n=wct){let i=this.constructor,o=i._attributeNameForProperty(t,n);if(o!==void 0){let a=i._propertyValueToAttribute(r,n);if(a===void 0)return;this._updateState=this._updateState|Ect,a==null?this.removeAttribute(o):this.setAttribute(o,a),this._updateState=this._updateState&~Ect}}_attributeToProperty(t,r){if(this._updateState&Ect)return;let n=this.constructor,i=n._attributeToPropertyMap.get(t);if(i!==void 0){let o=n.getPropertyOptions(i);this._updateState=this._updateState|Tct,this[i]=n._propertyValueFromAttribute(r,o),this._updateState=this._updateState&~Tct}}requestUpdateInternal(t,r,n){let i=!0;if(t!==void 0){let o=this.constructor;n=n||o.getPropertyOptions(t),o._valueHasChanged(this[t],r,n.hasChanged)?(this._changedProperties.has(t)||this._changedProperties.set(t,r),n.reflect===!0&&!(this._updateState&Tct)&&(this._reflectingProperties===void 0&&(this._reflectingProperties=new Map),this._reflectingProperties.set(t,n))):i=!1}!this._hasRequestedUpdate&&i&&(this._updatePromise=this._enqueueUpdate())}requestUpdate(t,r){return this.requestUpdateInternal(t,r),this.updateComplete}_enqueueUpdate(){return Ri(this,null,function*(){this._updateState=this._updateState|Mct;try{yield this._updatePromise}catch(r){}let t=this.performUpdate();return t!=null&&(yield t),!this._hasRequestedUpdate})}get _hasRequestedUpdate(){return this._updateState&Mct}get hasUpdated(){return this._updateState&Sct}performUpdate(){if(!this._hasRequestedUpdate)return;this._instanceProperties&&this._applyInstanceProperties();let t=!1,r=this._changedProperties;try{t=this.shouldUpdate(r),t?this.update(r):this._markUpdated()}catch(n){throw t=!1,this._markUpdated(),n}t&&(this._updateState&Sct||(this._updateState=this._updateState|Sct,this.firstUpdated(r)),this.updated(r))}_markUpdated(){this._changedProperties=new Map,this._updateState=this._updateState&~Mct}get updateComplete(){return this._getUpdateComplete()}_getUpdateComplete(){return this.getUpdateComplete()}getUpdateComplete(){return this._updatePromise}shouldUpdate(t){return!0}update(t){this._reflectingProperties!==void 0&&this._reflectingProperties.size>0&&(this._reflectingProperties.forEach((r,n)=>this._propertyToAttribute(n,this[n],r)),this._reflectingProperties=void 0),this._markUpdated()}updated(t){}firstUpdated(t){}};Sce=Act;g3[Sce]=!0;var Ece=Element.prototype,yii=Ece.msMatchesSelector||Ece.webkitMatchesSelector;var YH=window.ShadowRoot&&(window.ShadyCSS===void 0||window.ShadyCSS.nativeShadow)&&"adoptedStyleSheets"in Document.prototype&&"replace"in CSSStyleSheet.prototype,Pct=Symbol(),lv=class{constructor(t,r){if(r!==Pct)throw new Error("CSSResult is not constructable. Use `unsafeCSS` or `css` instead.");this.cssText=t}get styleSheet(){return this._styleSheet===void 0&&(YH?(this._styleSheet=new CSSStyleSheet,this._styleSheet.replaceSync(this.cssText)):this._styleSheet=null),this._styleSheet}toString(){return this.cssText}},Ict=e=>new lv(String(e),Pct),Our=e=>{if(e instanceof lv)return e.cssText;if(typeof e=="number")return e;throw new Error(`Value passed to 'css' function must be a 'css' function result: ${e}. Use 'unsafeCSS' to pass non-literal values, but
            take care to ensure page security.`)},Ci=(e,...t)=>{let r=t.reduce((n,i,o)=>n+Our(i)+e[o+1],e[0]);return new lv(r,Pct)};(window.litElementVersions||(window.litElementVersions=[])).push("2.5.1");var Tce={},MP=class extends g3{static getStyles(){return this.styles}static _getUniqueStyles(){if(this.hasOwnProperty(JSCompiler_renameProperty("_styles",this)))return;let t=this.getStyles();if(Array.isArray(t)){let r=(o,a)=>o.reduceRight((s,l)=>Array.isArray(l)?r(l,s):(s.add(l),s),a),n=r(t,new Set),i=[];n.forEach(o=>i.unshift(o)),this._styles=i}else this._styles=t===void 0?[]:[t];this._styles=this._styles.map(r=>{if(r instanceof CSSStyleSheet&&!YH){let n=Array.prototype.slice.call(r.cssRules).reduce((i,o)=>i+o.cssText,"");return Ict(n)}return r})}initialize(){super.initialize(),this.constructor._getUniqueStyles(),this.renderRoot=this.createRenderRoot(),window.ShadowRoot&&this.renderRoot instanceof window.ShadowRoot&&this.adoptStyles()}createRenderRoot(){return this.attachShadow(this.constructor.shadowRootOptions)}adoptStyles(){let t=this.constructor._styles;t.length!==0&&(window.ShadyCSS!==void 0&&!window.ShadyCSS.nativeShadow?window.ShadyCSS.ScopingShim.prepareAdoptedCssText(t.map(r=>r.cssText),this.localName):YH?this.renderRoot.adoptedStyleSheets=t.map(r=>r instanceof CSSStyleSheet?r:r.styleSheet):this._needsShimAdoptedStyleSheets=!0)}connectedCallback(){super.connectedCallback(),this.hasUpdated&&window.ShadyCSS!==void 0&&window.ShadyCSS.styleElement(this)}update(t){let r=this.render();super.update(t),r!==Tce&&this.constructor.render(r,this.renderRoot,{scopeName:this.localName,eventContext:this}),this._needsShimAdoptedStyleSheets&&(this._needsShimAdoptedStyleSheets=!1,this.constructor._styles.forEach(n=>{let i=document.createElement("style");i.textContent=n.cssText,this.renderRoot.appendChild(i)}))}render(){return Tce}};MP.finalized=!0;MP.render=wce;MP.shadowRootOptions={mode:"open"};var Cce=0,Lct={},jc=(e,t,r)=>{let n=r&&r.moduleId||`custom-style-module-${Cce++}`;Array.isArray(t)||(t=t?[t]:[]),t.forEach(a=>{if(!(a instanceof lv))throw new Error("An item in styles is not of type CSSResult. Use `unsafeCSS` or `css`.");if(!Lct[a]){let s=document.createElement("dom-module");s.innerHTML=`
        <template>
          <style>${a.toString()}</style>
        </template>
      `;let l=`custom-style-module-${Cce++}`;s.register(l),Lct[a]=l}});let i=document.createElement("dom-module");if(e){let a=customElements.get(e);a&&Object.prototype.hasOwnProperty.call(a,"__finalized")&&console.warn(`The custom element definition for "${e}"
      was finalized before a style module was registered.
      Make sure to add component specific style modules before
      importing the corresponding custom element.`),i.setAttribute("theme-for",e)}let o=r&&r.include||[];i.innerHTML=`
    <template>
      ${o.map(a=>`<style include=${a}></style>`)}
      ${t.map(a=>`<style include=${Lct[a]}></style>`)}
    </template>
  `,i.register(n)};var kct=class extends HTMLElement{static get version(){return"20.0.2"}};customElements.define("vaadin-lumo-styles",kct);var zur=Ci`
  :host {
    /* Base (background) */
    --lumo-base-color: #fff;

    /* Tint */
    --lumo-tint-5pct: hsla(0, 0%, 100%, 0.3);
    --lumo-tint-10pct: hsla(0, 0%, 100%, 0.37);
    --lumo-tint-20pct: hsla(0, 0%, 100%, 0.44);
    --lumo-tint-30pct: hsla(0, 0%, 100%, 0.5);
    --lumo-tint-40pct: hsla(0, 0%, 100%, 0.57);
    --lumo-tint-50pct: hsla(0, 0%, 100%, 0.64);
    --lumo-tint-60pct: hsla(0, 0%, 100%, 0.7);
    --lumo-tint-70pct: hsla(0, 0%, 100%, 0.77);
    --lumo-tint-80pct: hsla(0, 0%, 100%, 0.84);
    --lumo-tint-90pct: hsla(0, 0%, 100%, 0.9);
    --lumo-tint: #fff;

    /* Shade */
    --lumo-shade-5pct: hsla(214, 61%, 25%, 0.05);
    --lumo-shade-10pct: hsla(214, 57%, 24%, 0.1);
    --lumo-shade-20pct: hsla(214, 53%, 23%, 0.16);
    --lumo-shade-30pct: hsla(214, 50%, 22%, 0.26);
    --lumo-shade-40pct: hsla(214, 47%, 21%, 0.38);
    --lumo-shade-50pct: hsla(214, 45%, 20%, 0.5);
    --lumo-shade-60pct: hsla(214, 43%, 19%, 0.61);
    --lumo-shade-70pct: hsla(214, 42%, 18%, 0.72);
    --lumo-shade-80pct: hsla(214, 41%, 17%, 0.83);
    --lumo-shade-90pct: hsla(214, 40%, 16%, 0.94);
    --lumo-shade: hsl(214, 35%, 15%);

    /* Contrast */
    --lumo-contrast-5pct: var(--lumo-shade-5pct);
    --lumo-contrast-10pct: var(--lumo-shade-10pct);
    --lumo-contrast-20pct: var(--lumo-shade-20pct);
    --lumo-contrast-30pct: var(--lumo-shade-30pct);
    --lumo-contrast-40pct: var(--lumo-shade-40pct);
    --lumo-contrast-50pct: var(--lumo-shade-50pct);
    --lumo-contrast-60pct: var(--lumo-shade-60pct);
    --lumo-contrast-70pct: var(--lumo-shade-70pct);
    --lumo-contrast-80pct: var(--lumo-shade-80pct);
    --lumo-contrast-90pct: var(--lumo-shade-90pct);
    --lumo-contrast: var(--lumo-shade);

    /* Text */
    --lumo-header-text-color: var(--lumo-contrast);
    --lumo-body-text-color: var(--lumo-contrast-90pct);
    --lumo-secondary-text-color: var(--lumo-contrast-70pct);
    --lumo-tertiary-text-color: var(--lumo-contrast-50pct);
    --lumo-disabled-text-color: var(--lumo-contrast-30pct);

    /* Primary */
    --lumo-primary-color: hsl(214, 90%, 52%);
    --lumo-primary-color-50pct: hsla(214, 90%, 52%, 0.5);
    --lumo-primary-color-10pct: hsla(214, 90%, 52%, 0.1);
    --lumo-primary-text-color: var(--lumo-primary-color);
    --lumo-primary-contrast-color: #fff;

    /* Error */
    --lumo-error-color: hsl(3, 100%, 61%);
    --lumo-error-color-50pct: hsla(3, 100%, 60%, 0.5);
    --lumo-error-color-10pct: hsla(3, 100%, 60%, 0.1);
    --lumo-error-text-color: hsl(3, 92%, 53%);
    --lumo-error-contrast-color: #fff;

    /* Success */
    --lumo-success-color: hsl(145, 80%, 42%); /* hsl(144,82%,37%); */
    --lumo-success-color-50pct: hsla(145, 76%, 44%, 0.55);
    --lumo-success-color-10pct: hsla(145, 76%, 44%, 0.12);
    --lumo-success-text-color: hsl(145, 100%, 32%);
    --lumo-success-contrast-color: #fff;
  }
`,Ace=document.createElement("template");Ace.innerHTML=`<style>${zur.toString().replace(":host","html")}</style>`;document.head.appendChild(Ace.content);var Fur=Ci`
  [theme~='dark'] {
    /* Base (background) */
    --lumo-base-color: hsl(214, 35%, 21%);

    /* Tint */
    --lumo-tint-5pct: hsla(214, 65%, 85%, 0.06);
    --lumo-tint-10pct: hsla(214, 60%, 80%, 0.14);
    --lumo-tint-20pct: hsla(214, 64%, 82%, 0.23);
    --lumo-tint-30pct: hsla(214, 69%, 84%, 0.32);
    --lumo-tint-40pct: hsla(214, 73%, 86%, 0.41);
    --lumo-tint-50pct: hsla(214, 78%, 88%, 0.5);
    --lumo-tint-60pct: hsla(214, 82%, 90%, 0.6);
    --lumo-tint-70pct: hsla(214, 87%, 92%, 0.7);
    --lumo-tint-80pct: hsla(214, 91%, 94%, 0.8);
    --lumo-tint-90pct: hsla(214, 96%, 96%, 0.9);
    --lumo-tint: hsl(214, 100%, 98%);

    /* Shade */
    --lumo-shade-5pct: hsla(214, 0%, 0%, 0.07);
    --lumo-shade-10pct: hsla(214, 4%, 2%, 0.15);
    --lumo-shade-20pct: hsla(214, 8%, 4%, 0.23);
    --lumo-shade-30pct: hsla(214, 12%, 6%, 0.32);
    --lumo-shade-40pct: hsla(214, 16%, 8%, 0.41);
    --lumo-shade-50pct: hsla(214, 20%, 10%, 0.5);
    --lumo-shade-60pct: hsla(214, 24%, 12%, 0.6);
    --lumo-shade-70pct: hsla(214, 28%, 13%, 0.7);
    --lumo-shade-80pct: hsla(214, 32%, 13%, 0.8);
    --lumo-shade-90pct: hsla(214, 33%, 13%, 0.9);
    --lumo-shade: hsl(214, 33%, 13%);

    /* Contrast */
    --lumo-contrast-5pct: var(--lumo-tint-5pct);
    --lumo-contrast-10pct: var(--lumo-tint-10pct);
    --lumo-contrast-20pct: var(--lumo-tint-20pct);
    --lumo-contrast-30pct: var(--lumo-tint-30pct);
    --lumo-contrast-40pct: var(--lumo-tint-40pct);
    --lumo-contrast-50pct: var(--lumo-tint-50pct);
    --lumo-contrast-60pct: var(--lumo-tint-60pct);
    --lumo-contrast-70pct: var(--lumo-tint-70pct);
    --lumo-contrast-80pct: var(--lumo-tint-80pct);
    --lumo-contrast-90pct: var(--lumo-tint-90pct);
    --lumo-contrast: var(--lumo-tint);

    /* Text */
    --lumo-header-text-color: var(--lumo-contrast);
    --lumo-body-text-color: var(--lumo-contrast-90pct);
    --lumo-secondary-text-color: var(--lumo-contrast-70pct);
    --lumo-tertiary-text-color: var(--lumo-contrast-50pct);
    --lumo-disabled-text-color: var(--lumo-contrast-30pct);

    /* Primary */
    --lumo-primary-color: hsl(214, 86%, 55%);
    --lumo-primary-color-50pct: hsla(214, 86%, 55%, 0.5);
    --lumo-primary-color-10pct: hsla(214, 90%, 63%, 0.1);
    --lumo-primary-text-color: hsl(214, 100%, 70%);
    --lumo-primary-contrast-color: #fff;

    /* Error */
    --lumo-error-color: hsl(3, 90%, 63%);
    --lumo-error-color-50pct: hsla(3, 90%, 63%, 0.5);
    --lumo-error-color-10pct: hsla(3, 90%, 63%, 0.1);
    --lumo-error-text-color: hsl(3, 100%, 67%);

    /* Success */
    --lumo-success-color: hsl(145, 65%, 42%);
    --lumo-success-color-50pct: hsla(145, 65%, 42%, 0.5);
    --lumo-success-color-10pct: hsla(145, 65%, 42%, 0.1);
    --lumo-success-text-color: hsl(145, 85%, 47%);
  }

  html {
    color: var(--lumo-body-text-color);
    background-color: var(--lumo-base-color);
  }

  [theme~='dark'] {
    color: var(--lumo-body-text-color);
    background-color: var(--lumo-base-color);
  }

  h1,
  h2,
  h3,
  h4,
  h5,
  h6 {
    color: var(--lumo-header-text-color);
  }

  a {
    color: var(--lumo-primary-text-color);
  }

  blockquote {
    color: var(--lumo-secondary-text-color);
  }

  code,
  pre {
    background-color: var(--lumo-contrast-10pct);
    border-radius: var(--lumo-border-radius-m);
  }
`;jc("",Fur,{moduleId:"lumo-color"});var Bur=Ci`
  :host {
    color: var(--lumo-body-text-color) !important;
    background-color: var(--lumo-base-color) !important;
  }
`;jc("",Bur,{moduleId:"lumo-color-legacy",include:["lumo-color"]});var Pce=document.createElement("template");Pce.innerHTML=`
  <style>
    @font-face {
      font-family: 'lumo-icons';
      src: url(data:application/font-woff;charset=utf-8;base64,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) format('woff');
      font-weight: normal;
      font-style: normal;
    }

    html {
      --lumo-icons-align-center: "\\ea01";
      --lumo-icons-align-left: "\\ea02";
      --lumo-icons-align-right: "\\ea03";
      --lumo-icons-angle-down: "\\ea04";
      --lumo-icons-angle-left: "\\ea05";
      --lumo-icons-angle-right: "\\ea06";
      --lumo-icons-angle-up: "\\ea07";
      --lumo-icons-arrow-down: "\\ea08";
      --lumo-icons-arrow-left: "\\ea09";
      --lumo-icons-arrow-right: "\\ea0a";
      --lumo-icons-arrow-up: "\\ea0b";
      --lumo-icons-bar-chart: "\\ea0c";
      --lumo-icons-bell: "\\ea0d";
      --lumo-icons-calendar: "\\ea0e";
      --lumo-icons-checkmark: "\\ea0f";
      --lumo-icons-chevron-down: "\\ea10";
      --lumo-icons-chevron-left: "\\ea11";
      --lumo-icons-chevron-right: "\\ea12";
      --lumo-icons-chevron-up: "\\ea13";
      --lumo-icons-clock: "\\ea14";
      --lumo-icons-cog: "\\ea15";
      --lumo-icons-cross: "\\ea16";
      --lumo-icons-download: "\\ea17";
      --lumo-icons-dropdown: "\\ea18";
      --lumo-icons-edit: "\\ea19";
      --lumo-icons-error: "\\ea1a";
      --lumo-icons-eye: "\\ea1b";
      --lumo-icons-eye-disabled: "\\ea1c";
      --lumo-icons-menu: "\\ea1d";
      --lumo-icons-minus: "\\ea1e";
      --lumo-icons-ordered-list: "\\ea1f";
      --lumo-icons-phone: "\\ea20";
      --lumo-icons-photo: "\\ea21";
      --lumo-icons-play: "\\ea22";
      --lumo-icons-plus: "\\ea23";
      --lumo-icons-redo: "\\ea24";
      --lumo-icons-reload: "\\ea25";
      --lumo-icons-search: "\\ea26";
      --lumo-icons-undo: "\\ea27";
      --lumo-icons-unordered-list: "\\ea28";
      --lumo-icons-upload: "\\ea29";
      --lumo-icons-user: "\\ea2a";
    }
  </style>
`;document.head.appendChild(Pce.content);var Hur=Ci`
  :host {
    --lumo-size-xs: 1.625rem;
    --lumo-size-s: 1.875rem;
    --lumo-size-m: 2.25rem;
    --lumo-size-l: 2.75rem;
    --lumo-size-xl: 3.5rem;

    /* Icons */
    --lumo-icon-size-s: 1.25em;
    --lumo-icon-size-m: 1.5em;
    --lumo-icon-size-l: 2.25em;
    /* For backwards compatibility */
    --lumo-icon-size: var(--lumo-icon-size-m);
  }
`,Ice=document.createElement("template");Ice.innerHTML=`<style>${Hur.toString().replace(":host","html")}</style>`;document.head.appendChild(Ice.content);var Vur=Ci`
  :host {
    /* Square */
    --lumo-space-xs: 0.25rem;
    --lumo-space-s: 0.5rem;
    --lumo-space-m: 1rem;
    --lumo-space-l: 1.5rem;
    --lumo-space-xl: 2.5rem;

    /* Wide */
    --lumo-space-wide-xs: calc(var(--lumo-space-xs) / 2) var(--lumo-space-xs);
    --lumo-space-wide-s: calc(var(--lumo-space-s) / 2) var(--lumo-space-s);
    --lumo-space-wide-m: calc(var(--lumo-space-m) / 2) var(--lumo-space-m);
    --lumo-space-wide-l: calc(var(--lumo-space-l) / 2) var(--lumo-space-l);
    --lumo-space-wide-xl: calc(var(--lumo-space-xl) / 2) var(--lumo-space-xl);

    /* Tall */
    --lumo-space-tall-xs: var(--lumo-space-xs) calc(var(--lumo-space-xs) / 2);
    --lumo-space-tall-s: var(--lumo-space-s) calc(var(--lumo-space-s) / 2);
    --lumo-space-tall-m: var(--lumo-space-m) calc(var(--lumo-space-m) / 2);
    --lumo-space-tall-l: var(--lumo-space-l) calc(var(--lumo-space-l) / 2);
    --lumo-space-tall-xl: var(--lumo-space-xl) calc(var(--lumo-space-xl) / 2);
  }
`,Lce=document.createElement("template");Lce.innerHTML=`<style>${Vur.toString().replace(":host","html")}</style>`;document.head.appendChild(Lce.content);var Uur=Ci`
  :host {
    /* Border radius */
    --lumo-border-radius-s: 0.25em; /* Checkbox, badge, date-picker year indicator, etc */
    --lumo-border-radius-m: var(--lumo-border-radius, 0.25em); /* Button, text field, menu overlay, etc */
    --lumo-border-radius-l: 0.5em; /* Dialog, notification, etc */
    --lumo-border-radius: 0.25em; /* Deprecated */

    /* Shadow */
    --lumo-box-shadow-xs: 0 1px 4px -1px var(--lumo-shade-50pct);
    --lumo-box-shadow-s: 0 2px 4px -1px var(--lumo-shade-20pct), 0 3px 12px -1px var(--lumo-shade-30pct);
    --lumo-box-shadow-m: 0 2px 6px -1px var(--lumo-shade-20pct), 0 8px 24px -4px var(--lumo-shade-40pct);
    --lumo-box-shadow-l: 0 3px 18px -2px var(--lumo-shade-20pct), 0 12px 48px -6px var(--lumo-shade-40pct);
    --lumo-box-shadow-xl: 0 4px 24px -3px var(--lumo-shade-20pct), 0 18px 64px -8px var(--lumo-shade-40pct);

    /* Clickable element cursor */
    --lumo-clickable-cursor: default;
  }
`,kce=document.createElement("template");kce.innerHTML=`<style>${Uur.toString().replace(":host","html")}</style>`;document.head.appendChild(kce.content);var qur=Ci`
  :host {
    /* prettier-ignore */
    --lumo-font-family: -apple-system, BlinkMacSystemFont, 'Roboto', 'Segoe UI', Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol';

    /* Font sizes */
    --lumo-font-size-xxs: 0.75rem;
    --lumo-font-size-xs: 0.8125rem;
    --lumo-font-size-s: 0.875rem;
    --lumo-font-size-m: 1rem;
    --lumo-font-size-l: 1.125rem;
    --lumo-font-size-xl: 1.375rem;
    --lumo-font-size-xxl: 1.75rem;
    --lumo-font-size-xxxl: 2.5rem;

    /* Line heights */
    --lumo-line-height-xs: 1.25;
    --lumo-line-height-s: 1.375;
    --lumo-line-height-m: 1.625;
  }
`,Rce=document.createElement("template");Rce.innerHTML=`<style>${qur.toString().replace(":host","html")}</style>`;document.head.appendChild(Rce.content);var Gur=Ci`
  html {
    font-family: var(--lumo-font-family);
    font-size: var(--lumo-font-size, var(--lumo-font-size-m));
    line-height: var(--lumo-line-height-m);
    -webkit-text-size-adjust: 100%;
    -webkit-font-smoothing: antialiased;
    -moz-osx-font-smoothing: grayscale;
  }

  /* Can’t combine with the above selector because that doesn’t work in browsers without native shadow dom */
  :host {
    font-family: var(--lumo-font-family);
    font-size: var(--lumo-font-size, var(--lumo-font-size-m));
    line-height: var(--lumo-line-height-m);
    -webkit-text-size-adjust: 100%;
    -webkit-font-smoothing: antialiased;
    -moz-osx-font-smoothing: grayscale;
  }

  small,
  [theme~='font-size-s'] {
    font-size: var(--lumo-font-size-s);
    line-height: var(--lumo-line-height-s);
  }

  [theme~='font-size-xs'] {
    font-size: var(--lumo-font-size-xs);
    line-height: var(--lumo-line-height-xs);
  }

  h1,
  h2,
  h3,
  h4,
  h5,
  h6 {
    font-weight: 600;
    line-height: var(--lumo-line-height-xs);
    margin-top: 1.25em;
  }

  h1 {
    font-size: var(--lumo-font-size-xxxl);
    margin-bottom: 0.75em;
  }

  h2 {
    font-size: var(--lumo-font-size-xxl);
    margin-bottom: 0.5em;
  }

  h3 {
    font-size: var(--lumo-font-size-xl);
    margin-bottom: 0.5em;
  }

  h4 {
    font-size: var(--lumo-font-size-l);
    margin-bottom: 0.5em;
  }

  h5 {
    font-size: var(--lumo-font-size-m);
    margin-bottom: 0.25em;
  }

  h6 {
    font-size: var(--lumo-font-size-xs);
    margin-bottom: 0;
    text-transform: uppercase;
    letter-spacing: 0.03em;
  }

  p,
  blockquote {
    margin-top: 0.5em;
    margin-bottom: 0.75em;
  }

  a {
    text-decoration: none;
  }

  a:hover {
    text-decoration: underline;
  }

  hr {
    display: block;
    align-self: stretch;
    height: 1px;
    border: 0;
    padding: 0;
    margin: var(--lumo-space-s) calc(var(--lumo-border-radius-m) / 2);
    background-color: var(--lumo-contrast-10pct);
  }

  blockquote {
    border-left: 2px solid var(--lumo-contrast-30pct);
  }

  b,
  strong {
    font-weight: 600;
  }

  /* RTL specific styles */

  blockquote[dir='rtl'] {
    border-left: none;
    border-right: 2px solid var(--lumo-contrast-30pct);
  }
`;jc("",Gur,{moduleId:"lumo-typography"});jc("vaadin-checkbox",Ci`
    :host {
      -webkit-tap-highlight-color: transparent;
      -webkit-user-select: none;
      -moz-user-select: none;
      user-select: none;
      cursor: default;
      outline: none;
    }

    [part='label']:not([empty]) {
      margin: 0.1875em 0.875em 0.1875em 0.375em;
    }

    [part='checkbox'] {
      width: calc(1em + 2px);
      height: calc(1em + 2px);
      margin: 0.1875em;
      position: relative;
      border-radius: var(--lumo-border-radius-s);
      background-color: var(--lumo-contrast-20pct);
      transition: transform 0.2s cubic-bezier(0.12, 0.32, 0.54, 2), background-color 0.15s;
      pointer-events: none;
      line-height: 1.2;
    }

    :host([indeterminate]) [part='checkbox'],
    :host([checked]) [part='checkbox'] {
      background-color: var(--lumo-primary-color);
    }

    /* Needed to align the checkbox nicely on the baseline */
    [part='checkbox']::before {
      content: '\\2003';
    }

    /* Checkmark */
    [part='checkbox']::after {
      content: '';
      display: inline-block;
      width: 0;
      height: 0;
      border: 0 solid var(--lumo-primary-contrast-color);
      border-width: 0.1875em 0 0 0.1875em;
      box-sizing: border-box;
      transform-origin: 0 0;
      position: absolute;
      top: 0.8125em;
      left: 0.5em;
      transform: scale(0.55) rotate(-135deg);
      opacity: 0;
    }

    :host([checked]) [part='checkbox']::after {
      opacity: 1;
      width: 0.625em;
      height: 1.0625em;
    }

    /* Indeterminate checkmark */
    :host([indeterminate]) [part='checkbox']::after {
      transform: none;
      opacity: 1;
      top: 45%;
      height: 10%;
      left: 22%;
      right: 22%;
      width: auto;
      border: 0;
      background-color: var(--lumo-primary-contrast-color);
      transition: opacity 0.25s;
    }

    /* Focus ring */
    :host([focus-ring]) [part='checkbox'] {
      box-shadow: 0 0 0 3px var(--lumo-primary-color-50pct);
    }

    /* Disabled */
    :host([disabled]) {
      pointer-events: none;
      color: var(--lumo-disabled-text-color);
    }

    :host([disabled]) [part='label'] ::slotted(*) {
      color: inherit;
    }

    :host([disabled]) [part='checkbox'] {
      background-color: var(--lumo-contrast-10pct);
    }

    :host([disabled]) [part='checkbox']::after {
      border-color: var(--lumo-contrast-30pct);
    }

    :host([indeterminate][disabled]) [part='checkbox']::after {
      background-color: var(--lumo-contrast-30pct);
    }

    /* RTL specific styles */
    :host([dir='rtl']) [part='label']:not([empty]) {
      margin: 0.1875em 0.375em 0.1875em 0.875em;
    }

    /* Transition the checkmark if activated with the mouse (disabled for grid select-all this way) */
    :host(:hover) [part='checkbox']::after {
      transition: width 0.1s, height 0.25s;
    }

    /* Used for activation "halo" */
    [part='checkbox']::before {
      color: transparent;
      display: inline-block;
      width: 100%;
      height: 100%;
      border-radius: inherit;
      background-color: inherit;
      transform: scale(1.4);
      opacity: 0;
      transition: transform 0.1s, opacity 0.8s;
    }

    /* Hover */
    :host(:not([checked]):not([indeterminate]):not([disabled]):hover) [part='checkbox'] {
      background-color: var(--lumo-contrast-30pct);
    }

    /* Disable hover for touch devices */
    @media (pointer: coarse) {
      :host(:not([checked]):not([indeterminate]):not([disabled]):hover) [part='checkbox'] {
        background-color: var(--lumo-contrast-20pct);
      }
    }

    /* Active */
    :host([active]) [part='checkbox'] {
      transform: scale(0.9);
      transition-duration: 0.05s;
    }

    :host([active][checked]) [part='checkbox'] {
      transform: scale(1.1);
    }

    :host([active]:not([checked])) [part='checkbox']::before {
      transition-duration: 0.01s, 0.01s;
      transform: scale(0);
      opacity: 0.4;
    }
  `,{moduleId:"lumo-checkbox"});var Nce=e=>class extends e{static get properties(){return{theme:{type:String,readOnly:!0}}}attributeChangedCallback(r,n,i){super.attributeChangedCallback(r,n,i),r==="theme"&&this._setTheme(i)}};var jH=e=>class extends Nce(e){static finalize(){super.finalize();let r=this.prototype._template,n=Object.getPrototypeOf(this.prototype)._template;n&&Array.from(n.content.querySelectorAll("style[include]")).forEach(i=>{this._includeStyle(i.getAttribute("include"),r)}),this._includeMatchingThemes(r)}static _includeMatchingThemes(r){let i=ou.prototype.modules,o=!1,a=this.is+"-default-theme";Object.keys(i).sort((s,l)=>{let c=s.indexOf("vaadin-")===0,u=l.indexOf("vaadin-")===0,h=["lumo-","material-"],f=h.filter(d=>s.indexOf(d)===0).length>0,p=h.filter(d=>l.indexOf(d)===0).length>0;return c!==u?c?-1:1:f!==p?f?-1:1:0}).forEach(s=>{if(s!==a){let l=i[s].getAttribute("theme-for");l&&l.split(" ").forEach(c=>{new RegExp("^"+c.split("*").join(".*")+"$").test(this.is)&&(o=!0,this._includeStyle(s,r))})}}),!o&&i[a]&&this._includeStyle(a,r)}static _includeStyle(r,n){if(n&&!n.content.querySelector(`style[include="${r}"]`)){let i=document.createElement("style");i.setAttribute("include",r),n.content.appendChild(i)}}};var Rct=!1;window.addEventListener("keydown",()=>{Rct=!0},{capture:!0});window.addEventListener("mousedown",()=>{Rct=!1},{capture:!0});var Wur=e=>class extends e{static get properties(){return{tabindex:{type:Number,value:0,reflectToAttribute:!0,observer:"_tabindexChanged"}}}},Dce=e=>class extends Wur(e){static get properties(){return{autofocus:{type:Boolean},_previousTabIndex:{type:Number},disabled:{type:Boolean,observer:"_disabledChanged",reflectToAttribute:!0},_isShiftTabbing:{type:Boolean}}}ready(){this.addEventListener("focusin",r=>{r.composedPath()[0]===this?this.contains(r.relatedTarget)||this._focus():r.composedPath().indexOf(this.focusElement)!==-1&&!this.disabled&&this._setFocused(!0)}),this.addEventListener("focusout",()=>this._setFocused(!1)),super.ready(),this.addEventListener("keydown",r=>{!r.defaultPrevented&&r.keyCode===9&&r.shiftKey&&(this._isShiftTabbing=!0,HTMLElement.prototype.focus.apply(this),this._setFocused(!1),setTimeout(()=>this._isShiftTabbing=!1,0))}),this.autofocus&&!this.disabled&&window.requestAnimationFrame(()=>{this._focus(),this._setFocused(!0),this.setAttribute("focus-ring","")})}disconnectedCallback(){super.disconnectedCallback(),this.hasAttribute("focused")&&this._setFocused(!1)}_setFocused(r){r?this.setAttribute("focused",""):this.removeAttribute("focused"),r&&Rct?this.setAttribute("focus-ring",""):this.removeAttribute("focus-ring")}get focusElement(){return window.console.warn(`Please implement the 'focusElement' property in <${this.localName}>`),this}_focus(){!this.focusElement||this._isShiftTabbing||(this.focusElement.focus(),this._setFocused(!0))}focus(){!this.focusElement||this.disabled||(this.focusElement.focus(),this._setFocused(!0))}blur(){!this.focusElement||(this.focusElement.blur(),this._setFocused(!1))}_disabledChanged(r){this.focusElement.disabled=r,r?(this.blur(),this._previousTabIndex=this.tabindex,this.tabindex=-1,this.setAttribute("aria-disabled","true")):(typeof this._previousTabIndex!="undefined"&&(this.tabindex=this._previousTabIndex),this.removeAttribute("aria-disabled"))}_tabindexChanged(r){r!==void 0&&(this.focusElement.tabIndex=r),this.disabled&&this.tabindex&&(this.tabindex!==-1&&(this._previousTabIndex=this.tabindex),this.tabindex=r=void 0)}click(){this.disabled||super.click()}};var Yur=/\/\*\*\s+vaadin-dev-mode:start([\s\S]*)vaadin-dev-mode:end\s+\*\*\//i,XH=window.Vaadin&&window.Vaadin.Flow&&window.Vaadin.Flow.clients;function jur(){function e(){return!0}return Oce(e)}function Xur(){try{return $ur()?!0:Kur()?XH?!Zur():!jur():!1}catch(e){return!1}}function $ur(){return localStorage.getItem("vaadin.developmentmode.force")}function Kur(){return["localhost","127.0.0.1"].indexOf(window.location.hostname)>=0}function Zur(){return!!(XH&&Object.keys(XH).map(t=>XH[t]).filter(t=>t.productionMode).length>0)}function Oce(e,t){if(typeof e!="function")return;let r=Yur.exec(e.toString());if(r)try{e=new Function(r[1])}catch(n){console.log("vaadin-development-mode-detector: uncommentAndRun() failed",n)}return e(t)}window.Vaadin=window.Vaadin||{};var Nct=function(e,t){if(window.Vaadin.developmentMode)return Oce(e,t)};window.Vaadin.developmentMode===void 0&&(window.Vaadin.developmentMode=Xur());function Jur(){}var zce=function(){if(typeof Nct=="function")return Nct(Jur)};var _3=class{static detectScrollType(){let t=document.createElement("div");t.textContent="ABCD",t.dir="rtl",t.style.fontSize="14px",t.style.width="4px",t.style.height="1px",t.style.position="absolute",t.style.top="-1000px",t.style.overflow="scroll",document.body.appendChild(t);let r="reverse";return t.scrollLeft>0?r="default":(t.scrollLeft=2,t.scrollLeft<2&&(r="negative")),document.body.removeChild(t),r}static getNormalizedScrollLeft(t,r,n){let{scrollLeft:i}=n;if(r!=="rtl"||!t)return i;switch(t){case"negative":return n.scrollWidth-n.clientWidth+i;case"reverse":return n.scrollWidth-n.clientWidth-i}return i}static setNormalizedScrollLeft(t,r,n,i){if(r!=="rtl"||!t){n.scrollLeft=i;return}switch(t){case"negative":n.scrollLeft=n.clientWidth-n.scrollWidth+i;break;case"reverse":n.scrollLeft=n.scrollWidth-n.clientWidth-i;break;default:n.scrollLeft=i;break}}};var E0=[],Qur=function(){let e=Oct();E0.forEach(t=>{Dct(t,e)})},$H,thr=new MutationObserver(Qur);thr.observe(document.documentElement,{attributes:!0,attributeFilter:["dir"]});var Dct=function(e,t,r=e.getAttribute("dir")){t?e.setAttribute("dir",t):r!=null&&e.removeAttribute("dir")},Oct=function(){return document.documentElement.getAttribute("dir")},KH=e=>class extends e{static get properties(){return{dir:{type:String,value:"",reflectToAttribute:!0}}}static finalize(){super.finalize(),$H||($H=_3.detectScrollType())}connectedCallback(){super.connectedCallback(),this.hasAttribute("dir")||(this.__subscribe(),Dct(this,Oct(),null))}attributeChangedCallback(r,n,i){if(super.attributeChangedCallback(r,n,i),r!=="dir")return;let o=Oct(),a=i===o&&E0.indexOf(this)===-1,s=!i&&n&&E0.indexOf(this)===-1;a||s?(this.__subscribe(),Dct(this,o,i)):i!==o&&n===o&&this.__subscribe(!1)}disconnectedCallback(){super.disconnectedCallback(),this.__subscribe(!1),this.removeAttribute("dir")}_valueToNodeAttribute(r,n,i){i==="dir"&&n===""&&!r.hasAttribute("dir")||super._valueToNodeAttribute(r,n,i)}_attributeToProperty(r,n,i){r==="dir"&&!n?this.dir="":super._attributeToProperty(r,n,i)}__subscribe(r=!0){r?E0.indexOf(this)===-1&&E0.push(this):E0.indexOf(this)>-1&&E0.splice(E0.indexOf(this),1)}__getNormalizedScrollLeft(r){return _3.getNormalizedScrollLeft($H,this.getAttribute("dir")||"ltr",r)}__setNormalizedScrollLeft(r,n){return _3.setNormalizedScrollLeft($H,this.getAttribute("dir")||"ltr",r,n)}};window.Vaadin=window.Vaadin||{};window.Vaadin.registrations=window.Vaadin.registrations||[];window.Vaadin.developmentModeCallback=window.Vaadin.developmentModeCallback||{};window.Vaadin.developmentModeCallback["vaadin-usage-statistics"]=function(){zce()};var zct,Fce=new Set,ZH=e=>class extends KH(e){static finalize(){super.finalize();let{is:r}=this;r&&!Fce.has(r)&&(window.Vaadin.registrations.push(this),Fce.add(r),window.Vaadin.developmentModeCallback&&(zct=sr.debounce(zct,kx,()=>{window.Vaadin.developmentModeCallback["vaadin-usage-statistics"]()}),Jl(zct)))}constructor(){super(),document.doctype===null&&console.warn('Vaadin components require the "standards mode" declaration. Please add <!DOCTYPE html> to the HTML document.')}};var JH=class extends ZH(Dce(jH(yh(mt)))){static get template(){return Q`
      <style>
        :host {
          display: inline-block;
        }

        :host([hidden]) {
          display: none !important;
        }

        label {
          display: inline-flex;
          align-items: baseline;
          outline: none;
        }

        [part='checkbox'] {
          position: relative;
          display: inline-block;
          flex: none;
        }

        input[type='checkbox'] {
          position: absolute;
          top: 0;
          left: 0;
          right: 0;
          width: 100%;
          height: 100%;
          opacity: 0;
          cursor: inherit;
          margin: 0;
        }

        :host([disabled]) {
          -webkit-tap-highlight-color: transparent;
        }
      </style>

      <label>
        <span part="checkbox">
          <input
            type="checkbox"
            checked="{{checked::change}}"
            disabled$="[[disabled]]"
            indeterminate="{{indeterminate::change}}"
            role="presentation"
            tabindex="-1"
          />
        </span>

        <span part="label">
          <slot></slot>
        </span>
      </label>
    `}static get is(){return"vaadin-checkbox"}static get version(){return"20.0.2"}static get properties(){return{checked:{type:Boolean,value:!1,notify:!0,observer:"_checkedChanged",reflectToAttribute:!0},indeterminate:{type:Boolean,notify:!0,observer:"_indeterminateChanged",reflectToAttribute:!0,value:!1},value:{type:String,value:"on"},_nativeCheckbox:{type:Object}}}constructor(){super(),this.name}get name(){return this.checked?this._storedName:""}set name(t){this._storedName=t}ready(){super.ready(),this.setAttribute("role","checkbox"),this._nativeCheckbox=this.shadowRoot.querySelector('input[type="checkbox"]'),this.addEventListener("click",this._handleClick.bind(this)),this._addActiveListeners();let t=this.getAttribute("name");t&&(this.name=t),this.shadowRoot.querySelector('[part~="label"]').querySelector("slot").addEventListener("slotchange",this._updateLabelAttribute.bind(this)),this._updateLabelAttribute()}_updateLabelAttribute(){let t=this.shadowRoot.querySelector('[part~="label"]'),r=t.firstElementChild.assignedNodes();this._isAssignedNodesEmpty(r)?t.setAttribute("empty",""):t.removeAttribute("empty")}_isAssignedNodesEmpty(t){return t.length===0||t.length==1&&t[0].nodeType==Node.TEXT_NODE&&t[0].textContent.trim()===""}_checkedChanged(t){this.indeterminate?this.setAttribute("aria-checked","mixed"):this.setAttribute("aria-checked",Boolean(t))}_indeterminateChanged(t){t?this.setAttribute("aria-checked","mixed"):this.setAttribute("aria-checked",this.checked)}_addActiveListeners(){this._addEventListenerToNode(this,"down",t=>{this.__interactionsAllowed(t)&&this.setAttribute("active","")}),this._addEventListenerToNode(this,"up",()=>this.removeAttribute("active")),this.addEventListener("keydown",t=>{this.__interactionsAllowed(t)&&t.keyCode===32&&(t.preventDefault(),this.setAttribute("active",""))}),this.addEventListener("keyup",t=>{this.__interactionsAllowed(t)&&t.keyCode===32&&(t.preventDefault(),this._toggleChecked(),this.removeAttribute("active"),this.indeterminate&&(this.indeterminate=!1))})}get focusElement(){return this.shadowRoot.querySelector("input")}__interactionsAllowed(t){return!(this.disabled||t.target.localName==="a")}_handleClick(t){this.__interactionsAllowed(t)&&(this.indeterminate?(this.indeterminate=!1,t.preventDefault(),this._toggleChecked()):t.composedPath()[0]!==this._nativeCheckbox&&(t.preventDefault(),this._toggleChecked()))}_toggleChecked(){this.checked=!this.checked,this.dispatchEvent(new CustomEvent("change",{composed:!1,bubbles:!0}))}};customElements.define(JH.is,JH);jc("vaadin-grid",Ci`
    :host {
      font-family: var(--lumo-font-family);
      font-size: var(--lumo-font-size-m);
      line-height: var(--lumo-line-height-s);
      color: var(--lumo-body-text-color);
      background-color: var(--lumo-base-color);
      box-sizing: border-box;
      -webkit-text-size-adjust: 100%;
      -webkit-tap-highlight-color: transparent;
      -webkit-font-smoothing: antialiased;
      -moz-osx-font-smoothing: grayscale;

      /* For internal use only */
      --_lumo-grid-border-color: var(--lumo-contrast-20pct);
      --_lumo-grid-secondary-border-color: var(--lumo-contrast-10pct);
      --_lumo-grid-border-width: 1px;
      --_lumo-grid-selected-row-color: var(--lumo-primary-color-10pct);
    }

    /* No (outer) border */

    :host(:not([theme~='no-border'])) {
      border: var(--_lumo-grid-border-width) solid var(--_lumo-grid-border-color);
    }

    /* Cell styles */

    [part~='cell'] {
      min-height: var(--lumo-size-m);
      background-color: var(--lumo-base-color);
    }

    [part~='cell'] ::slotted(vaadin-grid-cell-content) {
      cursor: default;
      padding: var(--lumo-space-xs) var(--lumo-space-m);
    }

    /* Apply row borders by default and introduce the "no-row-borders" variant */
    :host(:not([theme~='no-row-borders'])) [part~='cell']:not([part~='details-cell']) {
      border-top: var(--_lumo-grid-border-width) solid var(--_lumo-grid-secondary-border-color);
    }

    /* Hide first body row top border */
    :host(:not([theme~='no-row-borders'])) [part='row'][first] [part~='cell']:not([part~='details-cell']) {
      border-top: 0;
      min-height: calc(var(--lumo-size-m) - var(--_lumo-grid-border-width));
    }

    /* Focus-ring */

    [part~='cell']:focus {
      outline: none;
    }

    :host([navigating]) [part~='cell']:focus::before {
      content: '';
      position: absolute;
      top: 0;
      right: 0;
      bottom: 0;
      left: 0;
      pointer-events: none;
      box-shadow: inset 0 0 0 2px var(--lumo-primary-color-50pct);
    }

    /* Drag and Drop styles */
    :host([dragover])::after {
      content: '';
      position: absolute;
      z-index: 100;
      top: 0;
      right: 0;
      bottom: 0;
      left: 0;
      pointer-events: none;
      box-shadow: inset 0 0 0 2px var(--lumo-primary-color-50pct);
    }

    [part~='row'][dragover] {
      z-index: 100 !important;
    }

    [part~='row'][dragover] [part~='cell'] {
      overflow: visible;
    }

    [part~='row'][dragover] [part~='cell']::after {
      content: '';
      position: absolute;
      top: 0;
      right: 0;
      bottom: 0;
      left: 0;
      height: calc(var(--_lumo-grid-border-width) + 2px);
      pointer-events: none;
      background: var(--lumo-primary-color-50pct);
    }

    :host([theme~='no-row-borders']) [dragover] [part~='cell']::after {
      height: 2px;
    }

    [part~='row'][dragover='below'] [part~='cell']::after {
      top: 100%;
      bottom: auto;
      margin-top: -1px;
    }

    [part~='row'][dragover='above'] [part~='cell']::after {
      top: auto;
      bottom: 100%;
      margin-bottom: -1px;
    }

    [part~='row'][details-opened][dragover='below'] [part~='cell']:not([part~='details-cell'])::after,
    [part~='row'][details-opened][dragover='above'] [part~='details-cell']::after {
      display: none;
    }

    [part~='row'][dragover][dragover='on-top'] [part~='cell']::after {
      height: 100%;
    }

    [part~='row'][dragstart] {
      /* Add bottom-space to the row so the drag number doesn't get clipped. Needed for IE/Edge */
      border-bottom: 100px solid transparent;
      z-index: 100 !important;
      opacity: 0.9;
    }

    [part~='row'][dragstart] [part~='cell'] {
      border: none !important;
      box-shadow: none !important;
    }

    [part~='row'][dragstart] [part~='cell'][last-column] {
      border-radius: 0 var(--lumo-border-radius-s) var(--lumo-border-radius-s) 0;
    }

    [part~='row'][dragstart] [part~='cell'][first-column] {
      border-radius: var(--lumo-border-radius-s) 0 0 var(--lumo-border-radius-s);
    }

    [ios] [part~='row'][dragstart] [part~='cell'] {
      background: var(--lumo-primary-color-50pct);
    }

    #scroller:not([ios]) [part~='row'][dragstart]:not([dragstart=''])::after {
      display: block;
      position: absolute;
      left: var(--_grid-drag-start-x);
      top: var(--_grid-drag-start-y);
      z-index: 100;
      content: attr(dragstart);
      align-items: center;
      justify-content: center;
      box-sizing: border-box;
      padding: calc(var(--lumo-space-xs) * 0.8);
      color: var(--lumo-error-contrast-color);
      background-color: var(--lumo-error-color);
      border-radius: var(--lumo-border-radius-m);
      font-family: var(--lumo-font-family);
      font-size: var(--lumo-font-size-xxs);
      line-height: 1;
      font-weight: 500;
      text-transform: initial;
      letter-spacing: initial;
      min-width: calc(var(--lumo-size-s) * 0.7);
      text-align: center;
    }

    /* Headers and footers */

    [part~='header-cell'] ::slotted(vaadin-grid-cell-content),
    [part~='footer-cell'] ::slotted(vaadin-grid-cell-content),
    [part~='reorder-ghost'] {
      font-size: var(--lumo-font-size-s);
      font-weight: 500;
    }

    [part~='footer-cell'] ::slotted(vaadin-grid-cell-content) {
      font-weight: 400;
    }

    [part='row']:only-child [part~='header-cell'] {
      min-height: var(--lumo-size-xl);
    }

    /* Header borders */

    /* Hide first header row top border */
    :host(:not([theme~='no-row-borders'])) [part='row']:first-child [part~='header-cell'] {
      border-top: 0;
    }

    [part='row']:last-child [part~='header-cell'] {
      border-bottom: var(--_lumo-grid-border-width) solid transparent;
    }

    :host(:not([theme~='no-row-borders'])) [part='row']:last-child [part~='header-cell'] {
      border-bottom-color: var(--_lumo-grid-secondary-border-color);
    }

    /* Overflow uses a stronger border color */
    :host([overflow~='top']) [part='row']:last-child [part~='header-cell'] {
      border-bottom-color: var(--_lumo-grid-border-color);
    }

    /* Footer borders */

    [part='row']:first-child [part~='footer-cell'] {
      border-top: var(--_lumo-grid-border-width) solid transparent;
    }

    :host(:not([theme~='no-row-borders'])) [part='row']:first-child [part~='footer-cell'] {
      border-top-color: var(--_lumo-grid-secondary-border-color);
    }

    /* Overflow uses a stronger border color */
    :host([overflow~='bottom']) [part='row']:first-child [part~='footer-cell'] {
      border-top-color: var(--_lumo-grid-border-color);
    }

    /* Column reordering */

    :host([reordering]) [part~='cell'] {
      background: linear-gradient(var(--lumo-shade-20pct), var(--lumo-shade-20pct)) var(--lumo-base-color);
    }

    :host([reordering]) [part~='cell'][reorder-status='allowed'] {
      background: var(--lumo-base-color);
    }

    :host([reordering]) [part~='cell'][reorder-status='dragging'] {
      background: linear-gradient(var(--lumo-contrast-5pct), var(--lumo-contrast-5pct)) var(--lumo-base-color);
    }

    [part~='reorder-ghost'] {
      opacity: 0.85;
      box-shadow: var(--lumo-box-shadow-s);
      /* TODO Use the same styles as for the cell element (reorder-ghost copies styles from the cell element) */
      padding: var(--lumo-space-s) var(--lumo-space-m) !important;
    }

    /* Column resizing */

    [part='resize-handle'] {
      width: 3px;
      background-color: var(--lumo-primary-color-50pct);
      opacity: 0;
      transition: opacity 0.2s;
    }

    :host(:not([reordering])) *:not([column-resizing]) [part~='cell']:hover [part='resize-handle'],
    [part='resize-handle']:active {
      opacity: 1;
      transition-delay: 0.15s;
    }

    /* Column borders */

    :host([theme~='column-borders']) [part~='cell']:not([last-column]):not([part~='details-cell']) {
      border-right: var(--_lumo-grid-border-width) solid var(--_lumo-grid-secondary-border-color);
    }

    /* Frozen columns */

    [last-frozen] {
      border-right: var(--_lumo-grid-border-width) solid transparent;
      overflow: hidden;
    }

    :host([overflow~='left']) [part~='cell'][last-frozen]:not([part~='details-cell']) {
      border-right-color: var(--_lumo-grid-border-color);
    }

    /* Row stripes */

    :host([theme~='row-stripes']) [part~='row']:not([odd]) [part~='body-cell'],
    :host([theme~='row-stripes']) [part~='row']:not([odd]) [part~='details-cell'] {
      background-image: linear-gradient(var(--lumo-contrast-5pct), var(--lumo-contrast-5pct));
      background-repeat: repeat-x;
    }

    /* Selected row */

    /* Raise the selected rows above unselected rows (so that box-shadow can cover unselected rows) */
    :host(:not([reordering])) [part~='row'][selected] {
      z-index: 1;
    }

    :host(:not([reordering])) [part~='row'][selected] [part~='body-cell']:not([part~='details-cell']) {
      background-image: linear-gradient(var(--_lumo-grid-selected-row-color), var(--_lumo-grid-selected-row-color));
      background-repeat: repeat;
    }

    /* Cover the border of an unselected row */
    :host(:not([theme~='no-row-borders'])) [part~='row'][selected] [part~='cell']:not([part~='details-cell']) {
      box-shadow: 0 var(--_lumo-grid-border-width) 0 0 var(--_lumo-grid-selected-row-color);
    }

    /* Compact */

    :host([theme~='compact']) [part='row']:only-child [part~='header-cell'] {
      min-height: var(--lumo-size-m);
    }

    :host([theme~='compact']) [part~='cell'] {
      min-height: var(--lumo-size-s);
    }

    :host([theme~='compact']) [part='row'][first] [part~='cell']:not([part~='details-cell']) {
      min-height: calc(var(--lumo-size-s) - var(--_lumo-grid-border-width));
    }

    :host([theme~='compact']) [part~='cell'] ::slotted(vaadin-grid-cell-content) {
      padding: var(--lumo-space-xs) var(--lumo-space-s);
    }

    /* Wrap cell contents */

    :host([theme~='wrap-cell-content']) [part~='cell'] ::slotted(vaadin-grid-cell-content) {
      white-space: normal;
    }

    /* RTL specific styles */

    :host([dir='rtl']) [part~='row'][dragstart] [part~='cell'][last-column] {
      border-radius: var(--lumo-border-radius-s) 0 0 var(--lumo-border-radius-s);
    }

    :host([dir='rtl']) [part~='row'][dragstart] [part~='cell'][first-column] {
      border-radius: 0 var(--lumo-border-radius-s) var(--lumo-border-radius-s) 0;
    }

    :host([dir='rtl'][theme~='column-borders']) [part~='cell']:not([last-column]):not([part~='details-cell']) {
      border-right: none;
      border-left: var(--_lumo-grid-border-width) solid var(--_lumo-grid-secondary-border-color);
    }

    :host([dir='rtl']) [last-frozen] {
      border-right: none;
      border-left: var(--_lumo-grid-border-width) solid transparent;
    }

    :host([dir='rtl'][overflow~='right']) [part~='cell'][last-frozen]:not([part~='details-cell']) {
      border-left-color: var(--_lumo-grid-border-color);
    }
  `,{moduleId:"lumo-grid"});jc("vaadin-checkbox",Ci`
    :host(.vaadin-grid-select-all-checkbox) {
      font-size: var(--lumo-font-size-m);
    }
  `,{moduleId:"vaadin-grid-select-all-checkbox-lumo"});var Bce=navigator.userAgent.match(/iP(?:hone|ad;(?: U;)? CPU) OS (\d+)/),ehr=Bce&&Bce[1]>=8,Hce=3,Vce=u9({behaviors:[Js,y9],_ratio:.5,_scrollerPaddingTop:0,_scrollPosition:0,_physicalSize:0,_physicalAverage:0,_physicalAverageCount:0,_physicalTop:0,_virtualCount:0,_estScrollHeight:0,_scrollHeight:0,_viewportHeight:0,_viewportWidth:0,_physicalItems:null,_physicalSizes:null,_firstVisibleIndexVal:null,_lastVisibleIndexVal:null,_maxPages:2,_focusedVirtualIndex:-1,_templateCost:0,get _physicalBottom(){return this._physicalTop+this._physicalSize},get _scrollBottom(){return this._scrollPosition+this._viewportHeight},get _virtualEnd(){return this._virtualStart+this._physicalCount-1},get _hiddenContentSize(){return this._physicalSize-this._viewportHeight},get _maxScrollTop(){return this._estScrollHeight-this._viewportHeight+this._scrollOffset},get _maxVirtualStart(){return Math.max(0,this._virtualCount-this._physicalCount)},set _virtualStart(e){e=this._clamp(e,0,this._maxVirtualStart),this._virtualStartVal=e},get _virtualStart(){return this._virtualStartVal||0},set _physicalStart(e){e=e%this._physicalCount,e<0&&(e=this._physicalCount+e),this._physicalStartVal=e},get _physicalStart(){return this._physicalStartVal||0},get _physicalEnd(){return(this._physicalStart+this._physicalCount-1)%this._physicalCount},set _physicalCount(e){this._physicalCountVal=e},get _physicalCount(){return this._physicalCountVal||0},get _optPhysicalSize(){return this._viewportHeight===0?1/0:this._viewportHeight*this._maxPages},get _isVisible(){return Boolean(this.offsetWidth||this.offsetHeight)},get firstVisibleIndex(){let e=this._firstVisibleIndexVal;if(e==null){let t=this._physicalTop+this._scrollOffset;e=this._iterateItems(function(r,n){if(t+=this._physicalSizes[r],t>this._scrollPosition)return n})||0,this._firstVisibleIndexVal=e}return e},get lastVisibleIndex(){let e=this._lastVisibleIndexVal;if(e==null){let t=this._physicalTop+this._scrollOffset;this._iterateItems(function(r,n){t<this._scrollBottom&&(e=n),t+=this._physicalSizes[r]}),this._lastVisibleIndexVal=e}return e},get _scrollOffset(){return this._scrollerPaddingTop},attached:function(){this._debounce("_render",this._render,Ni),this.listen(this,"iron-resize","_resizeHandler")},detached:function(){this.unlisten(this,"iron-resize","_resizeHandler")},updateViewportBoundaries:function(){let e=window.getComputedStyle(this);this._scrollerPaddingTop=this.scrollTarget===this?0:parseInt(e["padding-top"],10),this._isRTL=Boolean(e.direction==="rtl"),this._viewportWidth=this.$.items.offsetWidth,this._viewportHeight=this._scrollTargetHeight},_scrollHandler:function(){let e=Math.max(0,Math.min(this._maxScrollTop,this._scrollTop)),t=e-this._scrollPosition,r=t>=0;if(this._scrollPosition=e,this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,Math.abs(t)>this._physicalSize&&this._physicalSize>0){t=t-this._scrollOffset;let n=Math.round(t/this._physicalAverage);this._virtualStart=this._virtualStart+n,this._physicalStart=this._physicalStart+n,this._physicalTop=Math.floor(this._virtualStart)*this._physicalAverage,this._update()}else if(this._physicalCount>0){let{physicalTop:n,indexes:i}=this._getReusables(r);r?(this._physicalTop=n,this._virtualStart=this._virtualStart+i.length,this._physicalStart=this._physicalStart+i.length):(this._virtualStart=this._virtualStart-i.length,this._physicalStart=this._physicalStart-i.length),this._update(i,r?null:i),this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,0),ci)}},_getReusables:function(e){let t,r,n,i=[],o=this._hiddenContentSize*this._ratio,a=this._virtualStart,s=this._virtualEnd,l=this._physicalCount,c=this._physicalTop+this._scrollOffset,u=this._physicalBottom+this._scrollOffset,h=this._scrollTop,f=this._scrollBottom;for(e?(t=this._physicalStart,r=h-c):(t=this._physicalEnd,r=u-f);n=this._physicalSizes[t],r=r-n,!(i.length>=l||r<=o);)if(e){if(s+i.length+1>=this._virtualCount||c+n>=h-this._scrollOffset)break;i.push(t),c=c+n,t=(t+1)%l}else{if(a-i.length<=0||c+this._physicalSize-n<=f)break;i.push(t),c=c-n,t=t===0?l-1:t-1}return{indexes:i,physicalTop:c-this._scrollOffset}},_update:function(e,t){if(!(e&&e.length===0||this._physicalCount===0)){if(this._assignModels(e),this._updateMetrics(e),t)for(;t.length;){let r=t.pop();this._physicalTop-=this._physicalSizes[r]}this._positionItems(),this._updateScrollerSize()}},_isClientFull:function(){return this._scrollBottom!=0&&this._physicalBottom-1>=this._scrollBottom&&this._physicalTop<=this._scrollPosition},_increasePoolIfNeeded:function(e){let r=this._clamp(this._physicalCount+e,Hce,this._virtualCount-this._virtualStart)-this._physicalCount,n=Math.round(this._physicalCount*.5);if(!(r<0)){if(r>0){let i=window.performance.now();[].push.apply(this._physicalItems,this._createPool(r));for(let o=0;o<r;o++)this._physicalSizes.push(0);this._physicalCount=this._physicalCount+r,this._physicalStart>this._physicalEnd&&this._isIndexRendered(this._focusedVirtualIndex)&&this._getPhysicalIndex(this._focusedVirtualIndex)<this._physicalEnd&&(this._physicalStart=this._physicalStart+r),this._update(),this._templateCost=(window.performance.now()-i)/r,n=Math.round(this._physicalCount*.5)}this._virtualEnd>=this._virtualCount-1||n===0||(this._isClientFull()?this._physicalSize<this._optPhysicalSize&&this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,this._clamp(Math.round(50/this._templateCost),1,n)),kx):this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,n),ci))}},_render:function(){if(!(!this.isAttached||!this._isVisible))if(this._physicalCount!==0){let{physicalTop:e,indexes:t}=this._getReusables(!0);this._physicalTop=e,this._virtualStart=this._virtualStart+t.length,this._physicalStart=this._physicalStart+t.length,this._update(t),this._update(),this._increasePoolIfNeeded(0)}else this._virtualCount>0&&(this.updateViewportBoundaries(),this._increasePoolIfNeeded(Hce))},_itemsChanged:function(e){e.path==="items"&&(this._virtualStart=0,this._physicalTop=0,this._virtualCount=this.items?this.items.length:0,this._physicalIndexForKey={},this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,this._physicalCount=this._physicalCount||0,this._physicalItems=this._physicalItems||[],this._physicalSizes=this._physicalSizes||[],this._physicalStart=0,this._scrollTop>this._scrollOffset&&this._resetScrollPosition(0),this._debounce("_render",this._render,Ni))},_iterateItems:function(e,t){let r,n,i,o;if(arguments.length===2&&t){for(o=0;o<t.length;o++)if(r=t[o],n=this._computeVidx(r),(i=e.call(this,r,n))!=null)return i}else{for(r=this._physicalStart,n=this._virtualStart;r<this._physicalCount;r++,n++)if((i=e.call(this,r,n))!=null)return i;for(r=0;r<this._physicalStart;r++,n++)if((i=e.call(this,r,n))!=null)return i}},_computeVidx:function(e){return e>=this._physicalStart?this._virtualStart+(e-this._physicalStart):this._virtualStart+(this._physicalCount-this._physicalStart)+e},_updateMetrics:function(e){if(!this._isVisible)return;ui();let t=0,r=0,n=this._physicalAverageCount,i=this._physicalAverage;this._iterateItems(function(o){r+=this._physicalSizes[o],this._physicalSizes[o]=this._physicalItems[o].offsetHeight,t+=this._physicalSizes[o],this._physicalAverageCount+=this._physicalSizes[o]?1:0},e),this._physicalSize=this._physicalSize+t-r,this._physicalAverageCount!==n&&(this._physicalAverage=Math.round((i*n+t)/this._physicalAverageCount))},_positionItems:function(){this._adjustScrollPosition();let e=this._physicalTop;this._iterateItems(function(t){this.translate3d(0,e+"px",0,this._physicalItems[t]),e+=this._physicalSizes[t]})},_adjustScrollPosition:function(){let e=this._virtualStart===0?this._physicalTop:Math.min(this._scrollPosition+this._physicalTop,0);if(e!==0){this._physicalTop=this._physicalTop-e;let t=this._scrollTop;!ehr&&t>0&&this._resetScrollPosition(t-e)}},_resetScrollPosition:function(e){this.scrollTarget&&e>=0&&(this._scrollTop=e,this._scrollPosition=this._scrollTop)},_updateScrollerSize:function(e){this._estScrollHeight=this._physicalBottom+Math.max(this._virtualCount-this._physicalCount-this._virtualStart,0)*this._physicalAverage,e=e||this._scrollHeight===0,e=e||this._scrollPosition>=this._estScrollHeight-this._physicalSize,(e||Math.abs(this._estScrollHeight-this._scrollHeight)>=this._viewportHeight)&&(this.$.items.style.height=this._estScrollHeight+"px",this._scrollHeight=this._estScrollHeight)},scrollToIndex:function(e){if(typeof e!="number"||e<0||e>this.items.length-1||(ui(),this._physicalCount===0))return;e=this._clamp(e,0,this._virtualCount-1),(!this._isIndexRendered(e)||e>=this._maxVirtualStart)&&(this._virtualStart=e-1),this._assignModels(),this._updateMetrics(),this._physicalTop=Math.floor(this._virtualStart)*this._physicalAverage;let t=this._physicalStart,r=this._virtualStart,n=0,i=this._hiddenContentSize;for(;r<e&&n<=i;)n=n+this._physicalSizes[t],t=(t+1)%this._physicalCount,r++;this._updateScrollerSize(!0),this._positionItems(),this._resetScrollPosition(this._physicalTop+this._scrollOffset+n),this._increasePoolIfNeeded(0),this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null},_resetAverage:function(){this._physicalAverage=0,this._physicalAverageCount=0},_resizeHandler:function(){this._debounce("_render",function(){this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,this.updateViewportBoundaries(),this._isVisible?(this.toggleScrollListener(!0),this._resetAverage(),this._render()):this.toggleScrollListener(!1)},Ni)},_isIndexRendered:function(e){return e>=this._virtualStart&&e<=this._virtualEnd},_getPhysicalIndex:function(e){return(this._physicalStart+(e-this._virtualStart))%this._physicalCount},_clamp:function(e,t,r){return Math.min(r,Math.max(t,e))},_debounce:function(e,t,r){this._debouncers=this._debouncers||{},this._debouncers[e]=sr.debounce(this._debouncers[e],r,t.bind(this)),Jl(this._debouncers[e])}});var QH=class extends Vce{static get properties(){return{size:{type:Number,notify:!0},_vidxOffset:{type:Number,value:0}}}static get observers(){return["_effectiveSizeChanged(_effectiveSize)"]}connectedCallback(){super.connectedCallback(),this._scrollHandler()}_updateScrollerItem(){}_afterScroll(){}_getRowTarget(){}_createScrollerRows(){}_canPopulate(){}scrollToIndex(t){this._warnPrivateAPIAccess("scrollToIndex"),this._scrollingToIndex=!0,t=Math.min(Math.max(t,0),this._effectiveSize-1),this.$.table.scrollTop=t/this._effectiveSize*(this.$.table.scrollHeight-this.$.table.offsetHeight),this._scrollHandler(),this._accessIronListAPI(()=>this._maxScrollTop)&&this._virtualCount<this._effectiveSize&&this._adjustVirtualIndexOffset(1e6),this._accessIronListAPI(()=>super.scrollToIndex(t-this._vidxOffset)),this._scrollHandler();let r=Array.from(this.$.items.children).filter(n=>n.index===t)[0];if(r){let n=r.getBoundingClientRect().top-this.$.header.getBoundingClientRect().bottom;Math.abs(n)>1&&(this.$.table.scrollTop+=n,this._scrollHandler())}this._scrollingToIndex=!1}_effectiveSizeChanged(t){let r,n=0;this._iterateItems((i,o)=>{if(o===this._firstVisibleIndex){let a=this._physicalItems[i];r=a.index,n=a.getBoundingClientRect().top}}),this.items&&t<this.items.length&&(this._scrollTop=0),Array.isArray(this.items)||(this.items={length:Math.min(t,1e5)}),this._accessIronListAPI(()=>super._itemsChanged({path:"items"})),this._virtualCount=Math.min(this.items.length,t)||0,this._scrollTop===0&&(this._accessIronListAPI(()=>this._scrollToIndex(Math.min(t-1,r))),this._iterateItems(i=>{let o=this._physicalItems[i];if(o.index===r&&(this.$.table.scrollTop+=Math.round(o.getBoundingClientRect().top-n)),o.index===this._focusedItemIndex&&this._itemsFocusable&&this.$.items.contains(this.shadowRoot.activeElement)){let a=Array.from(this._itemsFocusable.parentElement.children).indexOf(this._itemsFocusable);o.children[a].focus()}})),this._assignModels(),requestAnimationFrame(()=>this._update()),this.__updateFooterPositioning()}_positionItems(){this._adjustScrollPosition();let t;isNaN(this._physicalTop)&&(t=!0,this._physicalTop=0);let r=this._physicalTop;this._iterateItems(n=>{this._physicalItems[n].style.transform=`translateY(${r}px)`,r+=this._physicalSizes[n]}),t&&this._scrollToIndex(0)}_increasePoolIfNeeded(t){t===0&&this._scrollingToIndex||!this._canPopulate()||!this._effectiveSize||(this._initialPoolCreated?this._optPhysicalSize!==1/0&&(this._debounceIncreasePool=sr.debounce(this._debounceIncreasePool,Ni,()=>{this._updateMetrics();let r=this._optPhysicalSize-this._physicalSize,n=Math.ceil(r/this._physicalAverage);this._physicalCount+n>this._effectiveSize&&(n=Math.max(0,this._effectiveSize-this._physicalCount)),this._physicalSize&&n>0&&this._optPhysicalSize!==1/0&&(super._increasePoolIfNeeded(n),this.__reorderChildNodes())})):(this._initialPoolCreated=!0,super._increasePoolIfNeeded(25)))}__reorderChildNodes(){let t=Array.from(this.$.items.childNodes);!!t.reduce((n,i,o,a)=>{if(o===0||a[o-1].index===i.index-1)return n},!0)||t.sort((n,i)=>n.index-i.index).forEach(n=>this.$.items.appendChild(n))}_createPool(t){let r=document.createDocumentFragment(),n=this._createScrollerRows(t);n.forEach(o=>r.appendChild(o)),this._getRowTarget().appendChild(r);let i=this.querySelector("[slot]");if(i){let o=i.getAttribute("slot");i.setAttribute("slot","foo-bar"),i.setAttribute("slot",o)}return Tm(this,()=>this.notifyResize()),n}_assignModels(t){this._iterateItems((r,n)=>{let i=this._physicalItems[r];this._toggleAttribute("hidden",n>=this._effectiveSize,i),this._updateScrollerItem(i,n+(this._vidxOffset||0))},t)}_scrollHandler(){let t=this.$.table.scrollTop-this._scrollPosition;this._accessIronListAPI(super._scrollHandler);let r=this._vidxOffset;this._accessIronListAPI(()=>this._maxScrollTop)&&this._virtualCount<this._effectiveSize?this._adjustVirtualIndexOffset(t):this._vidxOffset=0,this._vidxOffset!==r&&this._update(),this._afterScroll()}_adjustVirtualIndexOffset(t){if(Math.abs(t)>1e4){if(this._noScale){this._noScale=!1;return}let r=this.$.table.scrollTop/(this.$.table.scrollHeight-this.$.table.offsetHeight),n=r*this._effectiveSize;this._vidxOffset=Math.round(n-r*this._virtualCount)}else{let r=this._vidxOffset||0,n=1e3,i=100;this._scrollTop===0?(this._vidxOffset=0,r!==this._vidxOffset&&super.scrollToIndex(0)):this.firstVisibleIndex<n&&this._vidxOffset>0&&(this._vidxOffset-=Math.min(this._vidxOffset,i),r!==this._vidxOffset&&super.scrollToIndex(this.firstVisibleIndex+(r-this._vidxOffset)),this._noScale=!0);let o=this._effectiveSize-this._virtualCount;this._scrollTop>=this._maxScrollTop&&this._maxScrollTop>0?(this._vidxOffset=o,r!==this._vidxOffset&&super.scrollToIndex(this._virtualCount)):this.firstVisibleIndex>this._virtualCount-n&&this._vidxOffset<o&&(this._vidxOffset+=Math.min(o-this._vidxOffset,i),r!==this._vidxOffset&&super.scrollToIndex(this.firstVisibleIndex-(this._vidxOffset-r)),this._noScale=!0)}}_accessIronListAPI(t){this._warnPrivateAPIAccessAsyncEnabled=!1;let r=t.apply(this);return this._debouncerWarnPrivateAPIAccess=sr.debounce(this._debouncerWarnPrivateAPIAccess,Ni,()=>this._warnPrivateAPIAccessAsyncEnabled=!0),r}_debounceRender(t,r){super._debounceRender(()=>this._accessIronListAPI(t),r)}_warnPrivateAPIAccess(t){this._warnPrivateAPIAccessAsyncEnabled&&console.warn(`Accessing private API (${t})!`)}_render(){this._accessIronListAPI(super._render)}_itemsChanged(){}get _firstVisibleIndex(){return this._accessIronListAPI(()=>super.firstVisibleIndex)}get _lastVisibleIndex(){return this._accessIronListAPI(()=>super.lastVisibleIndex)}_scrollToIndex(t){this._accessIronListAPI(()=>this.scrollToIndex(t))}get firstVisibleIndex(){return this._warnPrivateAPIAccess("firstVisibleIndex"),super.firstVisibleIndex}set firstVisibleIndex(t){this._warnPrivateAPIAccess("firstVisibleIndex"),super.firstVisibleIndex=t}get lastVisibleIndex(){return this._warnPrivateAPIAccess("lastVisibleIndex"),super.lastVisibleIndex}set lastVisibleIndex(t){this._warnPrivateAPIAccess("lastVisibleIndex"),super.lastVisibleIndex=t}updateViewportBoundaries(){this._warnPrivateAPIAccess("updateViewportBoundaries"),super.updateViewportBoundaries.apply(this,arguments)}_resizeHandler(){super._resizeHandler(),ui()}};var Uce=e=>class extends e{static get observers(){return["_a11yUpdateGridSize(size, _columnTree, _columnTree.*)"]}_a11yGetHeaderRowCount(r){return r.filter(n=>n.some(i=>i._headerTemplate||i.headerRenderer||i.path||i.header)).length}_a11yGetFooterRowCount(r){return r.filter(n=>n.some(i=>i._headerTemplate||i.headerRenderer)).length}_a11yUpdateGridSize(r,n){if(r===void 0||n===void 0)return;let i=n[n.length-1];this.$.table.setAttribute("aria-rowcount",r+this._a11yGetHeaderRowCount(n)+this._a11yGetFooterRowCount(n)),this.$.table.setAttribute("aria-colcount",i&&i.length||0),this._a11yUpdateHeaderRows(),this._a11yUpdateFooterRows()}_a11yUpdateHeaderRows(){Array.from(this.$.header.children).forEach((r,n)=>r.setAttribute("aria-rowindex",n+1))}_a11yUpdateFooterRows(){Array.from(this.$.footer.children).forEach((r,n)=>r.setAttribute("aria-rowindex",this._a11yGetHeaderRowCount(this._columnTree)+this.size+n+1))}_a11yUpdateRowRowindex(r,n){r.setAttribute("aria-rowindex",n+this._a11yGetHeaderRowCount(this._columnTree)+1)}_a11yUpdateRowSelected(r,n){r.setAttribute("aria-selected",Boolean(n)),Array.from(r.children).forEach(i=>i.setAttribute("aria-selected",Boolean(n)))}_a11yUpdateRowLevel(r,n){r.setAttribute("aria-level",n+1)}_a11yUpdateRowDetailsOpened(r,n){Array.from(r.children).forEach(i=>{typeof n=="boolean"?i.setAttribute("aria-expanded",n):i.hasAttribute("aria-expanded")&&i.removeAttribute("aria-expanded")})}_a11ySetRowDetailsCell(r,n){Array.from(r.children).forEach(i=>{i!==n&&i.setAttribute("aria-controls",n.id)})}_a11yUpdateCellColspan(r,n){r.setAttribute("aria-colspan",Number(n))}_a11yUpdateSorters(){Array.from(this.querySelectorAll("vaadin-grid-sorter")).forEach(r=>{let n=r.parentNode;for(;n&&n.localName!=="vaadin-grid-cell-content";)n=n.parentNode;n&&n.assignedSlot&&n.assignedSlot.parentNode.setAttribute("aria-sort",{asc:"ascending",desc:"descending"}[String(r.direction)]||"none")})}};var qce=e=>class extends e{static get properties(){return{activeItem:{type:Object,notify:!0,value:null}}}ready(){super.ready(),this.$.scroller.addEventListener("click",this._onClick.bind(this)),this.addEventListener("cell-activate",this._activateItem.bind(this))}_activateItem(r){let n=r.detail.model,i=n?n.item:null;i&&(this.activeItem=this._itemsEqual(this.activeItem,i)?null:i)}_onClick(r){if(r.defaultPrevented)return;let n=r.composedPath(),i=n[n.indexOf(this.$.table)-3];if(!i||i.getAttribute("part").indexOf("details-cell")>-1)return;let o=i._content,a=this.getRootNode().activeElement;!o.contains(a)&&!this._isFocusable(r.target)&&this.dispatchEvent(new CustomEvent("cell-activate",{detail:{model:this.__getRowModel(i.parentElement)}}))}_isFocusable(r){return rhr(r)}},rhr=e=>{if(!e.parentNode)return!1;let r=Array.from(e.parentNode.querySelectorAll("[tabindex], button, input, select, textarea, object, iframe, label, a[href], area[href]")).filter(n=>n.getAttribute("part")!=="cell body-cell").indexOf(e)!==-1;return!e.disabled&&r};var Gce=e=>class extends e{static get properties(){return{items:Array}}static get observers(){return["_itemsChanged(items, items.*, isAttached)"]}_itemsChanged(r,n,i){if(!!i){if(!Array.isArray(r)){r==null&&(this.size=0),this.dataProvider===this._arrayDataProvider&&(this.dataProvider=void 0);return}this.size=r.length,this.dataProvider=this.dataProvider||this._arrayDataProvider,this.clearCache(),this._ensureFirstPageLoaded()}}_arrayDataProvider(r,n){let i=(Array.isArray(this.items)?this.items:[]).slice(0);this._filters&&this._checkPaths(this._filters,"filtering",i)&&(i=this._filter(i)),this.size=i.length,r.sortOrders.length&&this._checkPaths(this._sorters,"sorting",i)&&(i=i.sort(this._multiSort.bind(this)));let o=r.page*r.pageSize,a=o+r.pageSize,s=i.slice(o,a);n(s,i.length)}_checkPaths(r,n,i){if(!i.length)return!1;let o=!0;for(let a in r){let s=r[a].path;if(!s||s.indexOf(".")===-1)continue;let l=s.replace(/\.[^.]*$/,"");Da.get(l,i[0])===void 0&&(console.warn(`Path "${s}" used for ${n} does not exist in all of the items, ${n} is disabled.`),o=!1)}return o}_multiSort(r,n){return this._sorters.map(i=>i.direction==="asc"?this._compare(Da.get(i.path,r),Da.get(i.path,n)):i.direction==="desc"?this._compare(Da.get(i.path,n),Da.get(i.path,r)):0).reduce((i,o)=>i||o,0)}_normalizeEmptyValue(r){return[void 0,null].indexOf(r)>=0?"":isNaN(r)?r.toString():r}_compare(r,n){return r=this._normalizeEmptyValue(r),n=this._normalizeEmptyValue(n),r<n?-1:r>n?1:0}_filter(r){return r.filter(n=>this._filters.filter(i=>{let o=this._normalizeEmptyValue(Da.get(i.path,n)),a=this._normalizeEmptyValue(i.value).toString().toLowerCase();return o.toString().toLowerCase().indexOf(a)===-1}).length===0)}};var Wce=e=>class extends yh(e){ready(){super.ready();let r=this.$.scroller;Em(r,"track",this._onHeaderTrack.bind(this)),r.addEventListener("touchmove",n=>r.hasAttribute("column-resizing")&&n.preventDefault()),r.addEventListener("contextmenu",n=>n.target.getAttribute("part")=="resize-handle"&&n.preventDefault()),r.addEventListener("mousedown",n=>n.target.getAttribute("part")==="resize-handle"&&n.preventDefault())}_onHeaderTrack(r){let n=r.target;if(n.getAttribute("part")==="resize-handle"){let o=n.parentElement._column;for(this._toggleAttribute("column-resizing",!0,this.$.scroller);o.localName==="vaadin-grid-column-group";)o=Array.prototype.slice.call(o._childColumns,0).sort(function(l,c){return l._order-c._order}).filter(function(l){return!l.hidden}).pop();let a=Array.from(this.$.header.querySelectorAll('[part~="row"]:last-child [part~="cell"]')),s=a.filter(l=>l._column===o)[0];if(s.offsetWidth){let l=window.getComputedStyle(s),c=10+parseInt(l.paddingLeft)+parseInt(l.paddingRight)+parseInt(l.borderLeftWidth)+parseInt(l.borderRightWidth)+parseInt(l.marginLeft)+parseInt(l.marginRight),u=s.offsetWidth+(this.__isRTL?s.getBoundingClientRect().left-r.detail.x:r.detail.x-s.getBoundingClientRect().right);o.width=Math.max(c,u)+"px",o.flexGrow=0}a.sort(function(l,c){return l._column._order-c._column._order}).forEach(function(l,c,u){c<u.indexOf(s)&&(l._column.width=l.offsetWidth+"px",l._column.flexGrow=0)}),r.detail.state==="end"&&(this._toggleAttribute("column-resizing",!1,this.$.scroller),this.dispatchEvent(new CustomEvent("column-resize",{detail:{resizedColumn:o}}))),this._resizeHandler()}}};var Yce=class jce{constructor(t,r,n){this.grid=t,this.parentCache=r,this.parentItem=n,this.itemCaches={},this.items={},this.effectiveSize=0,this.size=0,this.pendingRequests={}}isLoading(){return Boolean(Object.keys(this.pendingRequests).length||Object.keys(this.itemCaches).filter(t=>this.itemCaches[t].isLoading())[0])}getItemForIndex(t){let{cache:r,scaledIndex:n}=this.getCacheAndIndex(t);return r.items[n]}updateSize(){this.effectiveSize=!this.parentItem||this.grid._isExpanded(this.parentItem)?this.size+Object.keys(this.itemCaches).reduce((t,r)=>{let n=this.itemCaches[r];return n.updateSize(),t+n.effectiveSize},0):0}ensureSubCacheForScaledIndex(t){if(!this.itemCaches[t]){let r=new jce(this.grid,this,this.items[t]);this.itemCaches[t]=r,this.grid._loadPage(0,r)}}getCacheAndIndex(t){let r=t,n=Object.keys(this.itemCaches);for(let i=0;i<n.length;i++){let o=Number(n[i]),a=this.itemCaches[o];if(r<=o)return{cache:this,scaledIndex:r};if(r<=o+a.effectiveSize)return a.getCacheAndIndex(r-o-1);r-=a.effectiveSize}return{cache:this,scaledIndex:r}}},Xce=e=>class extends e{static get properties(){return{pageSize:{type:Number,value:50,observer:"_pageSizeChanged"},dataProvider:{type:Object,notify:!0,observer:"_dataProviderChanged"},loading:{type:Boolean,notify:!0,readOnly:!0,reflectToAttribute:!0},_cache:{type:Object,value:function(){return new Yce(this)}},itemIdPath:{type:String,value:null},expandedItems:{type:Object,notify:!0,value:()=>[]}}}static get observers(){return["_sizeChanged(size)","_itemIdPathChanged(itemIdPath)","_expandedItemsChanged(expandedItems.*)"]}_sizeChanged(r){let n=r-this._cache.size;this._cache.size+=n,this._cache.effectiveSize+=n,this._effectiveSize=this._cache.effectiveSize,this._increasePoolIfNeeded(0),this._debounceIncreasePool&&this._debounceIncreasePool.flush()}_getItem(r,n){if(r>=this._effectiveSize)return;n.index=r;let{cache:i,scaledIndex:o}=this._cache.getCacheAndIndex(r),a=i.items[o];a?(this._toggleAttribute("loading",!1,n),this._updateItem(n,a),this._isExpanded(a)&&i.ensureSubCacheForScaledIndex(o)):(this._toggleAttribute("loading",!0,n),this._loadPage(this._getPageForIndex(o),i))}_expandedInstanceChangedCallback(r,n){r.item!==void 0&&(n?this.expandItem(r.item):this.collapseItem(r.item))}getItemId(r){return this.itemIdPath?this.get(this.itemIdPath,r):r}_isExpanded(r){return this.__expandedKeys.has(this.getItemId(r))}_expandedItemsChanged(){this.__cacheExpandedKeys(),this._cache.updateSize(),this._effectiveSize=this._cache.effectiveSize,this._assignModels()}_itemIdPathChanged(){this.__cacheExpandedKeys()}__cacheExpandedKeys(){this.expandedItems&&(this.__expandedKeys=new Set,this.expandedItems.forEach(r=>{this.__expandedKeys.add(this.getItemId(r))}))}expandItem(r){this._isExpanded(r)||(this.expandedItems=[...this.expandedItems,r])}collapseItem(r){this._isExpanded(r)&&(this.expandedItems=this.expandedItems.filter(n=>!this._itemsEqual(n,r)))}_getIndexLevel(r){let{cache:n}=this._cache.getCacheAndIndex(r),i=0;for(;n.parentCache;)n=n.parentCache,i++;return i}_canPopulate(){return Boolean(this._hasData&&this._columnTree)}_loadPage(r,n){if(!n.pendingRequests[r]&&this.dataProvider){this._setLoading(!0),n.pendingRequests[r]=!0;let i={page:r,pageSize:this.pageSize,sortOrders:this._mapSorters(),filters:this._mapFilters(),parentItem:n.parentItem};this._debounceIncreasePool&&this._debounceIncreasePool.flush(),this.dataProvider(i,(o,a)=>{a!==void 0?n.size=a:i.parentItem&&(n.size=o.length);let s=Array.from(this.$.items.children).map(l=>l._item);o.forEach((l,c)=>{let u=r*this.pageSize+c;n.items[u]=l,this._isExpanded(l)&&s.indexOf(l)>-1&&n.ensureSubCacheForScaledIndex(u)}),this._hasData=!0,delete n.pendingRequests[r],this._debouncerApplyCachedData=sr.debounce(this._debouncerApplyCachedData,mo.after(0),()=>{this._setLoading(!1),this._cache.updateSize(),this._effectiveSize=this._cache.effectiveSize,Array.from(this.$.items.children).filter(l=>!l.hidden).forEach(l=>{this._cache.getItemForIndex(l.index)&&this._getItem(l.index,l)}),this._increasePoolIfNeeded(0),this.__scrollToPendingIndex()}),this._cache.isLoading()||this._debouncerApplyCachedData.flush(),this.__itemsReceived()})}}_getPageForIndex(r){return Math.floor(r/this.pageSize)}clearCache(){this._cache=new Yce(this),Array.from(this.$.items.children).forEach(r=>{Array.from(r.children).forEach(n=>{n._instance&&n._instance._setPendingProperty("item",{},!1)})}),this._cache.size=this.size||0,this._cache.updateSize(),this._hasData=!1,this._assignModels(),(!this._effectiveSize||!this._initialPoolCreated)&&this._loadPage(0,this._cache)}_pageSizeChanged(r,n){n!==void 0&&r!==n&&this.clearCache()}_checkSize(){this.size===void 0&&this._effectiveSize===0&&console.warn("The <vaadin-grid> needs the total number of items in order to display rows. Set the total number of items to the `size` property, or provide the total number of items in the second argument of the `dataProvider`\u2019s `callback` call.")}_dataProviderChanged(r,n){n!==void 0&&this.clearCache(),r&&this.items&&this.items.length&&this._scrollToIndex(this._firstVisibleIndex),this._ensureFirstPageLoaded(),this._debouncerCheckSize=sr.debounce(this._debouncerCheckSize,mo.after(2e3),this._checkSize.bind(this)),this._scrollHandler()}_ensureFirstPageLoaded(){this._hasData||this._loadPage(0,this._cache)}_itemsEqual(r,n){return this.getItemId(r)===this.getItemId(n)}_getItemIndexInArray(r,n){let i=-1;return n.forEach((o,a)=>{this._itemsEqual(o,r)&&(i=a)}),i}scrollToIndex(r){super.scrollToIndex(r),!isNaN(r)&&(this._cache.isLoading()||!this.clientHeight)&&(this.__pendingScrollToIndex=r)}__scrollToPendingIndex(){if(this.__pendingScrollToIndex&&this.$.items.children.length){let r=this.__pendingScrollToIndex;delete this.__pendingScrollToIndex,this._debounceIncreasePool&&this._debounceIncreasePool.flush(),this.scrollToIndex(r)}}};var $ce=e=>class extends e{ready(){super.ready(),this._addNodeObserver()}_hasColumnGroups(r){for(let n=0;n<r.length;n++)if(r[n].localName==="vaadin-grid-column-group")return!0;return!1}_getChildColumns(r){return vh.getFlattenedNodes(r).filter(this._isColumnElement)}_flattenColumnGroups(r){return r.map(n=>n.localName==="vaadin-grid-column-group"?this._getChildColumns(n):[n]).reduce((n,i)=>n.concat(i),[])}_getColumnTree(){let r=vh.getFlattenedNodes(this).filter(this._isColumnElement),n=[];for(let i=r;n.push(i),!!this._hasColumnGroups(i);)i=this._flattenColumnGroups(i);return n}_updateColumnTree(){let r=this._getColumnTree();this._arrayEquals(r,this._columnTree)||(this._columnTree=r)}_addNodeObserver(){this._observer=new vh(this,r=>{let n=r.addedNodes.filter(o=>o.localName==="template"&&o.classList.contains("row-details"))[0];n&&this._rowDetailsTemplate!==n&&(this._rowDetailsTemplate=n);let i=o=>o.filter(this._isColumnElement).length>0;if(i(r.addedNodes)||i(r.removedNodes)){let o=r.removedNodes.flatMap(s=>s._allCells),a=s=>o.filter(l=>l._content.contains(s)).length;this.__removeSorters(this._sorters.filter(a)),this.__removeFilters(this._filters.filter(a)),this._updateColumnTree()}this._debouncerCheckImports=sr.debounce(this._debouncerCheckImports,mo.after(2e3),this._checkImports.bind(this)),this._ensureFirstPageLoaded()})}_arrayEquals(r,n){if(!r||!n||r.length!=n.length)return!1;for(let i=0,o=r.length;i<o;i++)if(r[i]instanceof Array&&n[i]instanceof Array){if(!this._arrayEquals(r[i],n[i]))return!1}else if(r[i]!=n[i])return!1;return!0}_checkImports(){["vaadin-grid-column-group","vaadin-grid-filter","vaadin-grid-filter-column","vaadin-grid-tree-toggle","vaadin-grid-selection-column","vaadin-grid-sort-column","vaadin-grid-sorter"].forEach(r=>{let n=this.querySelector(r);n&&!(n instanceof mt)&&console.warn(`Make sure you have imported the required module for <${r}> element.`)})}_updateFirstAndLastColumn(){Array.from(this.shadowRoot.querySelectorAll("tr")).forEach(r=>this._updateFirstAndLastColumnForRow(r))}_updateFirstAndLastColumnForRow(r){Array.from(r.querySelectorAll('[part~="cell"]:not([part~="details-cell"])')).sort((n,i)=>n._column._order-i._column._order).forEach((n,i,o)=>{this._toggleAttribute("first-column",i===0,n),this._toggleAttribute("last-column",i===o.length-1,n)})}_isColumnElement(r){return r.nodeType===Node.ELEMENT_NODE&&/\bcolumn\b/.test(r.localName)}};var Kce=e=>class extends e{getEventContext(r){let n={},i=r.composedPath(),o=i[i.indexOf(this.$.table)-3];return o&&(n.section=["body","header","footer","details"].filter(a=>o.getAttribute("part").indexOf(a)>-1)[0],o._column&&(n.column=o._column),(n.section==="body"||n.section==="details")&&Object.assign(n,this.__getRowModel(o.parentElement))),n}};var Zce=e=>class extends e{static get properties(){return{_filters:{type:Array,value:function(){return[]}}}}ready(){super.ready(),this.addEventListener("filter-changed",this._filterChanged.bind(this))}_filterChanged(r){r.stopPropagation(),this.__addFilter(r.target),this.__applyFilters()}__removeFilters(r){r.length!=0&&(this._filters=this._filters.filter(n=>r.indexOf(n)<0),this.__applyFilters())}__addFilter(r){this._filters.indexOf(r)===-1&&this._filters.push(r)}__applyFilters(){this.dataProvider&&this.isAttached&&this.clearCache()}_mapFilters(){return this._filters.map(r=>({path:r.path,value:r.value}))}};var T0=class extends mt{static get is(){return"vaadin-grid-templatizer"}static get properties(){return{dataHost:Object,template:Object,_templateInstances:{type:Array,value:function(){return[]}},_parentPathValues:{value:function(){return{}}},_grid:Object}}static get observers(){return["_templateInstancesChanged(_templateInstances.*, _parentPathValues.*)"]}constructor(){super(),this._instanceProps={detailsOpened:!0,index:!0,item:!0,selected:!0,expanded:!0,level:!0}}createInstance(){this._ensureTemplatized();let t=new this._TemplateClass({});return this.addInstance(t),t}addInstance(t){this._templateInstances.indexOf(t)===-1&&(this._templateInstances.push(t),requestAnimationFrame(()=>this.notifyPath("_templateInstances.*",this._templateInstances)))}removeInstance(t){let r=this._templateInstances.indexOf(t);this.splice("_templateInstances",r,1)}_ensureTemplatized(){this._TemplateClass||(this._TemplateClass=tc(this.template,this,{instanceProps:this._instanceProps,parentModel:!0,forwardHostProp:function(t,r){this._forwardParentProp(t,r),this._templateInstances&&this._templateInstances.forEach(n=>n.notifyPath(t,r))},notifyInstanceProp:function(t,r,n){if(r==="index"||r==="item")return;let i=`__${r}__`;if(t[i]===n)return;t[i]=n;let o=Array.from(this._grid.$.items.children).filter(l=>this._grid._itemsEqual(l._item,t.item))[0];o&&Array.from(o.children).forEach(l=>{l._instance&&(l._instance[i]=n,l._instance.notifyPath(r,n))});let a="item.";if(Array.isArray(this._grid.items)&&r.indexOf(a)===0){let l=this._grid.items.indexOf(t.item),c=r.slice(a.length);this._grid.notifyPath(`items.${l}.${c}`,n)}let s=`_${r}InstanceChangedCallback`;this._grid&&this._grid[s]&&this._grid[s](t,n)}}))}_forwardParentProp(t,r){this._parentPathValues[t]=r,this._templateInstances.forEach(n=>n.notifyPath(t,r))}_templateInstancesChanged(t){let r,n;if(t.path==="_templateInstances")r=0,n=this._templateInstances.length;else if(t.path==="_templateInstances.splices")r=t.value.index,n=t.value.addedCount;else return;Object.keys(this._parentPathValues||{}).forEach(i=>{for(let o=r;o<r+n;o++)this._templateInstances[o].set(i,this._parentPathValues[i])})}};customElements.define(T0.is,T0);var Jce=e=>class extends e{static get properties(){return{detailsOpenedItems:{type:Array,value:function(){return[]}},_rowDetailsTemplate:Object,rowDetailsRenderer:Function,_detailsCells:{type:Array}}}static get observers(){return["_detailsOpenedItemsChanged(detailsOpenedItems.*, _rowDetailsTemplate, rowDetailsRenderer)","_rowDetailsTemplateOrRendererChanged(_rowDetailsTemplate, rowDetailsRenderer)"]}_rowDetailsTemplateOrRendererChanged(r,n){if(r&&n)throw new Error("You should only use either a renderer or a template for row details");if(r||n){if(r&&!r.templatizer){let i=new T0;i._grid=this,i.dataHost=this.dataHost,i.template=r,r.templatizer=i}this._columnTree&&Array.from(this.$.items.children).forEach(i=>{i.querySelector("[part~=details-cell]")||(this._updateRow(i,this._columnTree[this._columnTree.length-1]),this._a11yUpdateRowDetailsOpened(i,!1)),delete i.querySelector("[part~=details-cell]")._instance}),this.detailsOpenedItems.length&&(Array.from(this.$.items.children).forEach(this._toggleDetailsCell,this),this._update())}}_detailsOpenedItemsChanged(r){r.path==="detailsOpenedItems.length"||!r.value||Array.from(this.$.items.children).forEach(n=>{this._toggleDetailsCell(n,n._item),this._a11yUpdateRowDetailsOpened(n,this._isDetailsOpened(n._item)),this._toggleAttribute("details-opened",this._isDetailsOpened(n._item),n)})}_configureDetailsCell(r){r.setAttribute("part","cell details-cell"),this._toggleAttribute("frozen",!0,r)}_toggleDetailsCell(r,n){let i=r.querySelector('[part~="details-cell"]');if(!i)return;let o=!this._isDetailsOpened(n),a=!!i.hidden!==o;(!i._instance&&!i._renderer||i.hidden!==o)&&(i.hidden=o,o?r.style.removeProperty("padding-bottom"):(this.rowDetailsRenderer?(i._renderer=this.rowDetailsRenderer,i._renderer.call(this,i._content,this,{index:r.index,item:n})):this._rowDetailsTemplate&&!i._instance&&(i._instance=this._rowDetailsTemplate.templatizer.createInstance(),i._content.innerHTML="",i._content.appendChild(i._instance.root),this._updateItem(r,n)),ui(),r.style.setProperty("padding-bottom",`${i.offsetHeight}px`),requestAnimationFrame(()=>this.notifyResize()))),a&&(this._updateMetrics(),this._positionItems())}_updateDetailsCellHeights(){Array.from(this.$.items.querySelectorAll('[part~="details-cell"]:not([hidden])')).forEach(r=>{r.parentElement.style.setProperty("padding-bottom",`${r.offsetHeight}px`)})}_isDetailsOpened(r){return this.detailsOpenedItems&&this._getItemIndexInArray(r,this.detailsOpenedItems)!==-1}openItemDetails(r){this._isDetailsOpened(r)||(this.detailsOpenedItems=[...this.detailsOpenedItems,r])}closeItemDetails(r){this._isDetailsOpened(r)&&(this.detailsOpenedItems=this.detailsOpenedItems.filter(n=>!this._itemsEqual(n,r)))}_detailsOpenedInstanceChangedCallback(r,n){n?this.openItemDetails(r.item):this.closeItemDetails(r.item)}};var Fct={SCROLLING:500,IGNORE_WHEEL:500},Qce=e=>class extends e{static get properties(){return{_frozenCells:{type:Array,value:()=>[]},_rowWithFocusedElement:Element,_deltaYAcc:{type:Number,value:0},_useSticky:{type:Boolean,value:window.CSS&&window.CSS.supports&&(window.CSS.supports("position","sticky")||window.CSS.supports("position","-webkit-sticky"))}}}static get observers(){return["_scrollViewportHeightUpdated(_viewportHeight)"]}set _scrollTop(r){this.$.table.scrollTop=r}get _scrollTop(){return this.$.table.scrollTop}constructor(){super(),this._scrollLineHeight=this._getScrollLineHeight()}_getScrollLineHeight(){let r=document.createElement("div");r.style.fontSize="initial",r.style.display="none",document.body.appendChild(r);let n=window.getComputedStyle(r).fontSize;return document.body.removeChild(r),n?window.parseInt(n):void 0}_scrollViewportHeightUpdated(r){this._scrollPageHeight=r-this.$.header.clientHeight-this.$.footer.clientHeight-this._scrollLineHeight}ready(){super.ready(),this.$.outerscroller=document.createElement("div"),this.scrollTarget=this.$.table,this.addEventListener("wheel",this._onWheel),this.$.items.addEventListener("focusin",r=>{let n=r.composedPath().indexOf(this.$.items);this._rowWithFocusedElement=r.composedPath()[n-1]}),this.$.items.addEventListener("focusout",()=>this._rowWithFocusedElement=void 0),this.scrollTarget.addEventListener("mousedown",()=>this.__mouseDown=!0),this.scrollTarget.addEventListener("mouseup",()=>{this.__mouseDown=!1,this.__pendingReorder&&(this.__pendingReorder=!1,setTimeout(()=>this._reorderRows(),Fct.SCROLLING))})}scrollToIndex(r){this._accessIronListAPI(()=>super.scrollToIndex(r))}_onWheel(r){if(r.ctrlKey||this._hasScrolledAncestor(r.target,r.deltaX,r.deltaY))return;let n=this.$.table,i=r.deltaY;if(r.deltaMode===WheelEvent.DOM_DELTA_LINE?i*=this._scrollLineHeight:r.deltaMode===WheelEvent.DOM_DELTA_PAGE&&(i*=this._scrollPageHeight),this._wheelAnimationFrame){this._deltaYAcc+=i,r.preventDefault();return}i+=this._deltaYAcc,this._deltaYAcc=0,this._wheelAnimationFrame=!0,this._debouncerWheelAnimationFrame=sr.debounce(this._debouncerWheelAnimationFrame,Ni,()=>this._wheelAnimationFrame=!1);let o=Math.abs(r.deltaX)+Math.abs(i);this._canScroll(n,r.deltaX,i)?(r.preventDefault(),n.scrollTop+=i,n.scrollLeft+=r.deltaX,this._scrollHandler(),this._hasResidualMomentum=!0,this._ignoreNewWheel=!0,this._debouncerIgnoreNewWheel=sr.debounce(this._debouncerIgnoreNewWheel,mo.after(Fct.IGNORE_WHEEL),()=>this._ignoreNewWheel=!1)):this._hasResidualMomentum&&o<=this._previousMomentum||this._ignoreNewWheel?r.preventDefault():o>this._previousMomentum&&(this._hasResidualMomentum=!1),this._previousMomentum=o}_hasScrolledAncestor(r,n,i){if(r.localName==="vaadin-grid-cell-content")return!1;if(this._canScroll(r,n,i)&&["auto","scroll"].indexOf(getComputedStyle(r).overflow)!==-1)return!0;if(r!==this&&r.parentElement)return this._hasScrolledAncestor(r.parentElement,n,i)}_canScroll(r,n,i){return i>0&&r.scrollTop<r.scrollHeight-r.offsetHeight||i<0&&r.scrollTop>0||n>0&&r.scrollLeft<r.scrollWidth-r.offsetWidth||n<0&&r.scrollLeft>0}_scheduleScrolling(){this._scrollingFrame||(this._scrollingFrame=requestAnimationFrame(()=>this._toggleAttribute("scrolling",!0,this.$.scroller))),this._debounceScrolling=sr.debounce(this._debounceScrolling,mo.after(Fct.SCROLLING),()=>{cancelAnimationFrame(this._scrollingFrame),delete this._scrollingFrame,this._toggleAttribute("scrolling",!1,this.$.scroller),this._reorderRows()})}_afterScroll(){this._translateStationaryElements(),this.hasAttribute("reordering")||this._scheduleScrolling(),this._updateOverflow()}_updateOverflow(){let r="",n=this.$.table;n.scrollTop<n.scrollHeight-n.clientHeight&&(r+=" bottom"),n.scrollTop>0&&(r+=" top"),n.scrollLeft<n.scrollWidth-n.clientWidth&&(r+=" right"),n.scrollLeft>0&&(r+=" left"),this._debounceOverflow=sr.debounce(this._debounceOverflow,Ni,()=>{let i=r.trim();i.length>0&&this.getAttribute("overflow")!==i?this.setAttribute("overflow",i):i.length==0&&this.hasAttribute("overflow")&&this.removeAttribute("overflow")})}_reorderRows(){if(this.__mouseDown){this.__pendingReorder=!0;return}let r=this.$.items,n=r.querySelectorAll("tr");if(!n.length)return;let i=this._virtualStart+this._vidxOffset,o=this._rowWithFocusedElement||Array.from(n).filter(l=>!l.hidden)[0];if(!o)return;let a=o.index-i,s=Array.from(n).indexOf(o)-a;if(s>0)for(let l=0;l<s;l++)r.appendChild(n[l]);else if(s<0)for(let l=n.length+s;l<n.length;l++)r.insertBefore(n[l],n[0]);if(this._safari){let{transform:l}=this.$.header.style;this.$.header.style.transform="",setTimeout(()=>this.$.header.style.transform=l)}}_frozenCellsChanged(){this._debouncerCacheElements=sr.debounce(this._debouncerCacheElements,ci,()=>{Array.from(this.shadowRoot.querySelectorAll('[part~="cell"]')).forEach(function(r){r.style.transform=""}),this._frozenCells=Array.prototype.slice.call(this.$.table.querySelectorAll("[frozen]")),this._updateScrollerMeasurements(),this._translateStationaryElements()}),this._updateLastFrozen()}_updateScrollerMeasurements(){this._frozenCells.length>0&&this.__isRTL&&(this.__scrollerMetrics={scrollWidth:this.$.table.scrollWidth,clientWidth:this.$.table.clientWidth})}_updateLastFrozen(){if(!this._columnTree)return;let r=this._columnTree[this._columnTree.length-1].slice(0);r.sort((i,o)=>i._order-o._order);let n=r.reduce((i,o,a)=>(o._lastFrozen=!1,o.frozen&&!o.hidden?a:i),void 0);n!==void 0&&(r[n]._lastFrozen=!0)}_translateStationaryElements(){let r=Math.max(0,this._scrollLeft),n=Math.max(0,this._scrollTop),i=0,o=0,a=0;if(this._useSticky||(i=r,o=n,a=this.$.table.clientHeight-this.$.footer.offsetHeight-this.$.footer.offsetTop),this.$.header.style.transform=this._getTranslate(-r+i,o),this.$.footer.style.transform=this._getTranslate(-r+i,o+a),this.$.items.style.transform=this._getTranslate(-r+i,0),this._frozenCells.length>0){let s=this.__isRTL?this.__getNormalizedScrollLeft(this.$.table)+this.__scrollerMetrics.clientWidth-this.__scrollerMetrics.scrollWidth:this._scrollLeft,l=this._getTranslate(s,0);for(let c=0;c<this._frozenCells.length;c++)this._frozenCells[c].style.transform=l}}_getTranslate(r,n){return`translate(${r}px, ${n}px)`}};var tue=e=>class extends e{static get properties(){return{selectedItems:{type:Object,notify:!0,value:()=>[]}}}static get observers(){return["_selectedItemsChanged(selectedItems.*)"]}_isSelected(r){return this.selectedItems&&this._getItemIndexInArray(r,this.selectedItems)>-1}selectItem(r){this._isSelected(r)||(this.selectedItems=[...this.selectedItems,r])}deselectItem(r){this._isSelected(r)&&(this.selectedItems=this.selectedItems.filter(n=>!this._itemsEqual(n,r)))}_toggleItem(r){this._getItemIndexInArray(r,this.selectedItems)===-1?this.selectItem(r):this.deselectItem(r)}_selectedItemsChanged(r){this.$.items.children.length&&(r.path==="selectedItems"||r.path==="selectedItems.splices")&&Array.from(this.$.items.children).forEach(n=>{this._updateItem(n,n._item)})}_selectedInstanceChangedCallback(r,n){n?this.selectItem(r.item):this.deselectItem(r.item)}};var eue=e=>class extends e{static get properties(){return{multiSort:{type:Boolean,value:!1},_sorters:{type:Array,value:function(){return[]}},_previousSorters:{type:Array,value:function(){return[]}}}}ready(){super.ready(),this.addEventListener("sorter-changed",this._onSorterChanged)}_onSorterChanged(r){let n=r.target;r.stopPropagation(),this.__updateSorter(n),this.__applySorters()}__removeSorters(r){r.length!=0&&(this._sorters=this._sorters.filter(n=>r.indexOf(n)<0),this.multiSort&&this.__updateSortOrders(),this.__applySorters())}__updateSortOrders(){this._sorters.forEach((r,n)=>r._order=this._sorters.length>1?n:null,this)}__updateSorter(r){if(!(!r.direction&&this._sorters.indexOf(r)===-1)){if(r._order=null,this.multiSort)this._removeArrayItem(this._sorters,r),r.direction&&this._sorters.unshift(r),this.__updateSortOrders();else if(r.direction){let n=this._sorters.filter(i=>i!=r);this._sorters=[r],n.forEach(i=>{i._order=null,i.direction=null})}}}__applySorters(){this.dataProvider&&this.isAttached&&JSON.stringify(this._previousSorters)!==JSON.stringify(this._mapSorters())&&this.clearCache(),this._a11yUpdateSorters(),this._previousSorters=this._mapSorters()}_mapSorters(){return this._sorters.map(r=>({path:r.path,direction:r.direction}))}_removeArrayItem(r,n){let i=r.indexOf(n);i>-1&&r.splice(i,1)}};var rue=e=>class extends e{static get properties(){return{cellClassNameGenerator:Function}}static get observers(){return["__cellClassNameGeneratorChanged(cellClassNameGenerator)"]}__cellClassNameGeneratorChanged(){this.generateCellClassNames()}generateCellClassNames(){Array.from(this.$.items.children).filter(r=>!r.hidden).forEach(r=>this._generateCellClassNames(r,this.__getRowModel(r)))}_generateCellClassNames(r,n){Array.from(r.children).forEach(i=>{if(i.__generatedClasses&&i.__generatedClasses.forEach(o=>i.classList.remove(o)),this.cellClassNameGenerator){let o=this.cellClassNameGenerator(i._column,n);i.__generatedClasses=o&&o.split(" ").filter(a=>a.length>0),i.__generatedClasses&&i.__generatedClasses.forEach(a=>i.classList.add(a))}})}};var EP={BETWEEN:"between",ON_TOP:"on-top",ON_TOP_OR_BETWEEN:"on-top-or-between",ON_GRID:"on-grid"},C0={ON_TOP:"on-top",ABOVE:"above",BELOW:"below",EMPTY:"empty"},nue=e=>class extends e{static get properties(){return{dropMode:String,rowsDraggable:Boolean,dragFilter:Function,dropFilter:Function,__dndAutoScrollThreshold:{value:50}}}static get observers(){return["_dragDropAccessChanged(rowsDraggable, dropMode, dragFilter, dropFilter)"]}ready(){super.ready(),this.$.table.addEventListener("dragstart",this._onDragStart.bind(this)),this.$.table.addEventListener("dragend",this._onDragEnd.bind(this)),this.$.table.addEventListener("dragover",this._onDragOver.bind(this)),this.$.table.addEventListener("dragleave",this._onDragLeave.bind(this)),this.$.table.addEventListener("drop",this._onDrop.bind(this)),this.$.table.addEventListener("dragenter",r=>{this.dropMode&&(r.preventDefault(),r.stopPropagation())})}_onDragStart(r){if(this.rowsDraggable){let n=r.target;if(n.localName==="vaadin-grid-cell-content"&&(n=n.assignedSlot.parentNode.parentNode),n.parentNode!==this.$.items)return;if(r.stopPropagation(),this._toggleAttribute("dragging-rows",!0,this),this._safari){let s=n.style.transform;n.style.top=/translateY\((.*)\)/.exec(s)[1],n.style.transform="none",requestAnimationFrame(()=>{n.style.top="",n.style.transform=s})}let i=n.getBoundingClientRect();this._ios?r.dataTransfer.setDragImage(n):r.dataTransfer.setDragImage(n,r.clientX-i.left,r.clientY-i.top);let o=[n];this._isSelected(n._item)&&(o=this.__getViewportRows().filter(s=>this._isSelected(s._item)).filter(s=>!this.dragFilter||this.dragFilter(this.__getRowModel(s)))),r.dataTransfer.setData("text",this.__formatDefaultTransferData(o)),n.setAttribute("dragstart",o.length>1?o.length:""),this.updateStyles({"--_grid-drag-start-x":`${r.clientX-i.left+20}px`,"--_grid-drag-start-y":`${r.clientY-i.top+10}px`}),requestAnimationFrame(()=>{n.removeAttribute("dragstart"),this.updateStyles({"--_grid-drag-start-x":"","--_grid-drag-start-y":""})});let a=new CustomEvent("grid-dragstart",{detail:{draggedItems:o.map(s=>s._item),setDragData:(s,l)=>r.dataTransfer.setData(s,l),setDraggedItemsCount:s=>n.setAttribute("dragstart",s)}});a.originalEvent=r,this.dispatchEvent(a)}}_onDragEnd(r){this._toggleAttribute("dragging-rows",!1,this),r.stopPropagation();let n=new CustomEvent("grid-dragend");n.originalEvent=r,this.dispatchEvent(n)}_onDragLeave(r){r.stopPropagation(),this._clearDragStyles()}_onDragOver(r){if(this.dropMode){if(this._dropLocation=void 0,this._dragOverItem=void 0,this.__dndAutoScroll(r.clientY)){this._clearDragStyles();return}let n=r.composedPath().filter(i=>i.localName==="tr")[0];if(!this._effectiveSize||this.dropMode===EP.ON_GRID)this._dropLocation=C0.EMPTY;else if(!n||n.parentNode!==this.$.items){if(n)return;if(this.dropMode===EP.BETWEEN||this.dropMode===EP.ON_TOP_OR_BETWEEN)n=Array.from(this.$.items.children).filter(i=>!i.hidden).pop(),this._dropLocation=C0.BELOW;else return}else{let i=n.getBoundingClientRect();if(this._dropLocation=C0.ON_TOP,this.dropMode===EP.BETWEEN){let o=r.clientY-i.top<i.bottom-r.clientY;this._dropLocation=o?C0.ABOVE:C0.BELOW}else this.dropMode===EP.ON_TOP_OR_BETWEEN&&(r.clientY-i.top<i.height/3?this._dropLocation=C0.ABOVE:r.clientY-i.top>i.height/3*2&&(this._dropLocation=C0.BELOW))}if(n&&n.hasAttribute("drop-disabled")){this._dropLocation=void 0;return}r.stopPropagation(),r.preventDefault(),this._dropLocation===C0.EMPTY?this._toggleAttribute("dragover",!0,this):n?(this._dragOverItem=n._item,n.getAttribute("dragover")!==this._dropLocation&&n.setAttribute("dragover",this._dropLocation)):this._clearDragStyles()}}__dndAutoScroll(r){if(this.__dndAutoScrolling)return!0;let n=this.$.header.getBoundingClientRect().bottom,i=this.$.footer.getBoundingClientRect().top,o=n-r+this.__dndAutoScrollThreshold,a=r-i+this.__dndAutoScrollThreshold,s=0;if(a>0?s=a*2:o>0&&(s=-o*2),s){let l=this.$.table.scrollTop;if(this.$.table.scrollTop+=s,l!==this.$.table.scrollTop)return this.__dndAutoScrolling=!0,setTimeout(()=>this.__dndAutoScrolling=!1,20),this._scrollHandler(),!0}}__getViewportRows(){let r=this.$.header.getBoundingClientRect().bottom,n=this.$.footer.getBoundingClientRect().top;return Array.from(this.$.items.children).filter(i=>{let o=i.getBoundingClientRect();return o.bottom>r&&o.top<n})}_clearDragStyles(){this.removeAttribute("dragover"),Array.from(this.$.items.children).forEach(r=>r.removeAttribute("dragover"))}_onDrop(r){if(this.dropMode){r.stopPropagation(),r.preventDefault();let n=r.dataTransfer.types&&Array.from(r.dataTransfer.types).map(o=>({type:o,data:r.dataTransfer.getData(o)}));this._clearDragStyles();let i=new CustomEvent("grid-drop",{bubbles:r.bubbles,cancelable:r.cancelable,detail:{dropTargetItem:this._dragOverItem,dropLocation:this._dropLocation,dragData:n}});i.originalEvent=r,this.dispatchEvent(i)}}__formatDefaultTransferData(r){return r.map(n=>Array.from(n.children).filter(i=>!i.hidden&&i.getAttribute("part").indexOf("details-cell")===-1).sort((i,o)=>i._column._order>o._column._order?1:-1).map(i=>i._content.textContent.trim()).filter(i=>i).join("	")).join(`
`)}_dragDropAccessChanged(){this.filterDragAndDrop()}filterDragAndDrop(){Array.from(this.$.items.children).filter(r=>!r.hidden).forEach(r=>{this._filterDragAndDrop(r,this.__getRowModel(r))})}_filterDragAndDrop(r,n){let i=!this.rowsDraggable||this.dragFilter&&!this.dragFilter(n),o=!this.dropMode||this.dropFilter&&!this.dropFilter(n);Array.from(r.children).map(s=>s._content).forEach(s=>{i?s.removeAttribute("draggable"):s.setAttribute("draggable",!0)}),this._toggleAttribute("drag-disabled",i,r),this._toggleAttribute("drop-disabled",o,r)}};var iue=e=>class extends e{static get properties(){return{_headerFocusable:{type:Object,observer:"_focusableChanged"},_itemsFocusable:{type:Object,observer:"_focusableChanged"},_footerFocusable:{type:Object,observer:"_focusableChanged"},_navigatingIsHidden:Boolean,_focusedItemIndex:{type:Number,value:0},_focusedColumnOrder:Number,interacting:{type:Boolean,value:!1,reflectToAttribute:!0,readOnly:!0,observer:"_interactingChanged"}}}ready(){super.ready(),!(this._ios||this._android)&&(this.addEventListener("keydown",this._onKeyDown),this.addEventListener("keyup",this._onKeyUp),this.addEventListener("focusin",this._onFocusIn),this.addEventListener("focusout",this._onFocusOut),this.$.table.addEventListener("focusin",this._onCellFocusIn.bind(this)),this.$.table.addEventListener("focusout",this._onCellFocusOut.bind(this)),this.addEventListener("mousedown",()=>{this._toggleAttribute("navigating",!1,this),this._isMousedown=!0}),this.addEventListener("mouseup",()=>this._isMousedown=!1))}_focusableChanged(r,n){n&&n.setAttribute("tabindex","-1"),r&&this._updateGridSectionFocusTarget(r)}_interactingChanged(){this._updateGridSectionFocusTarget(this._headerFocusable),this._updateGridSectionFocusTarget(this._itemsFocusable),this._updateGridSectionFocusTarget(this._footerFocusable)}_onKeyDown(r){let n=r.key,i;switch(n){case"ArrowUp":case"ArrowDown":case"ArrowLeft":case"ArrowRight":case"PageUp":case"PageDown":case"Home":case"End":i="Navigation";break;case"Enter":case"Escape":case"F2":i="Interaction";break;case"Tab":i="Tab";break;case" ":i="Space";break}this._detectInteracting(r),this.interacting&&i!=="Interaction"&&(i=void 0),i&&this[`_on${i}KeyDown`](r,n)}_ensureScrolledToIndex(r){Array.from(this.$.items.children).filter(i=>i.index===r)[0]||this._scrollToIndex(r)}_onNavigationKeyDown(r,n){this._scrollHandler(),r.preventDefault();function i(B){return Array.prototype.indexOf.call(B.parentNode.children,B)}let o=this._lastVisibleIndex-this._firstVisibleIndex-1,a=0,s=0;switch(n){case"ArrowRight":a=this.__isRTL?-1:1;break;case"ArrowLeft":a=this.__isRTL?1:-1;break;case"Home":a=-1/0,r.ctrlKey&&(s=-1/0);break;case"End":a=1/0,r.ctrlKey&&(s=1/0);break;case"ArrowDown":s=1;break;case"ArrowUp":s=-1;break;case"PageDown":s=o;break;case"PageUp":s=-o;break}let l=r.composedPath()[0],c=i(l),u=this._elementMatches(l,'[part~="details-cell"]'),h=l.parentNode,f=h.parentNode,p=(f===this.$.items?this._effectiveSize:f.children.length)-1,d=f===this.$.items?this._focusedItemIndex!==void 0?this._focusedItemIndex:h.index:i(h),g=Math.max(0,Math.min(d+s,p)),_=!1;if(f===this.$.items){let B=h._item,I=this._cache.getItemForIndex(g);u?_=s===0:_=s===1&&this._isDetailsOpened(B)||s===-1&&g!==d&&this._isDetailsOpened(I),_!==u&&(s===1&&_||s===-1&&!_)&&(g=d)}if(f!==this.$.items){if(g>d)for(;g<p&&f.children[g].hidden;)g++;else if(g<d)for(;g>0&&f.children[g].hidden;)g--}this._focusedColumnOrder===void 0&&(u?this._focusedColumnOrder=0:this._focusedColumnOrder=this._getColumns(f,d).filter(B=>!B.hidden)[c]._order);let y=this._getColumns(f,g).filter(B=>!B.hidden),x=y.map(B=>B._order).sort((B,I)=>B-I),b=x.length-1,S=x.indexOf(x.slice(0).sort((B,I)=>Math.abs(B-this._focusedColumnOrder)-Math.abs(I-this._focusedColumnOrder))[0]),C=s===0&&u?S:Math.max(0,Math.min(S+a,b));C!==S&&(this._focusedColumnOrder=void 0),f===this.$.items&&this._ensureScrolledToIndex(g),this._toggleAttribute("navigating",!0,this);let k=y.reduce((B,I,L)=>(B[I._order]=L,B),{})[x[C]],O=f===this.$.items?Array.from(f.children).filter(B=>B.index===g)[0]:f.children[g];if(!O)return;let D=_?Array.from(O.children).filter(B=>this._elementMatches(B,'[part~="details-cell"]'))[0]:O.children[k];if(this._scrollHorizontallyToCell(D),f===this.$.items&&(this._focusedItemIndex=g),f===this.$.items){let B=D.getBoundingClientRect(),I=this.$.footer.getBoundingClientRect().top,L=this.$.header.getBoundingClientRect().bottom;B.bottom>I?(this.$.table.scrollTop+=B.bottom-I,this._scrollHandler()):B.top<L&&(this.$.table.scrollTop-=L-B.top,this._scrollHandler())}D.focus()}_onInteractionKeyDown(r,n){let i=r.composedPath()[0],o=i.localName==="input"&&!/^(button|checkbox|color|file|image|radio|range|reset|submit)$/i.test(i.type),a;switch(n){case"Enter":a=this.interacting?!o:!0;break;case"Escape":a=!1;break;case"F2":a=!this.interacting;break}let{cell:s}=this._getGridEventLocation(r);if(this.interacting!==a&&s!==null)if(a){let l=s._content.querySelector("[focus-target]")||s._content.firstElementChild;l&&(r.preventDefault(),l.focus(),this._setInteracting(!0),this._toggleAttribute("navigating",!1,this))}else r.preventDefault(),this._focusedColumnOrder=void 0,s.focus(),this._setInteracting(!1),this._toggleAttribute("navigating",!0,this)}_predictFocusStepTarget(r,n){let i=[this.$.table,this._headerFocusable,this._itemsFocusable,this._footerFocusable,this.$.focusexit],o=i.indexOf(r);for(o+=n;o>=0&&o<=i.length-1&&(!i[o]||i[o].parentNode.hidden);)o+=n;return i[o]}_onTabKeyDown(r){let n=this._predictFocusStepTarget(r.composedPath()[0],r.shiftKey?-1:1);if(n===this.$.table)this.$.table.focus();else if(n===this.$.focusexit)this.$.focusexit.focus();else if(n===this._itemsFocusable){let i=n,o=this._itemsFocusable.parentNode;if(this._ensureScrolledToIndex(this._focusedItemIndex),o.index!==this._focusedItemIndex){let a=Array.from(o.children).indexOf(this._itemsFocusable),s=Array.from(this.$.items.children).filter(l=>l.index===this._focusedItemIndex)[0];s&&(i=s.children[a])}r.preventDefault(),i.focus()}else r.preventDefault(),n.focus();this._toggleAttribute("navigating",!0,this)}_onSpaceKeyDown(r){r.preventDefault();let n=r.composedPath()[0];(!n._content||!n._content.firstElementChild)&&this.dispatchEvent(new CustomEvent("cell-activate",{detail:{model:this.__getRowModel(n.parentElement)}}))}_onKeyUp(r){if(!/^( |SpaceBar)$/.test(r.key))return;r.preventDefault();let n=r.composedPath()[0];if(n._content&&n._content.firstElementChild){let i=this.hasAttribute("navigating");n._content.firstElementChild.click(),this._toggleAttribute("navigating",i,this)}}_onFocusIn(r){this._isMousedown||this._toggleAttribute("navigating",!0,this);let n=r.composedPath()[0];n===this.$.table||n===this.$.focusexit?(this._predictFocusStepTarget(n,n===this.$.table?1:-1).focus(),this._setInteracting(!1)):this._detectInteracting(r)}_onFocusOut(r){this._toggleAttribute("navigating",!1,this),this._detectInteracting(r)}_onCellFocusIn(r){let{section:n,cell:i}=this._getGridEventLocation(r);this._detectInteracting(r),n&&i&&(this._activeRowGroup=n,this.$.header===n?this._headerFocusable=i:this.$.items===n?this._itemsFocusable=i:this.$.footer===n&&(this._footerFocusable=i),i._content.dispatchEvent(new CustomEvent("cell-focusin",{bubbles:!1})),i.dispatchEvent(new CustomEvent("cell-focus",{bubbles:!0,composed:!0}))),this._detectFocusedItemIndex(r)}_onCellFocusOut(r){r.composedPath().indexOf(this.$.table)===3&&r.composedPath()[0]._content.dispatchEvent(new CustomEvent("cell-focusout",{bubbles:!1}))}_detectInteracting(r){let n=r.composedPath().some(i=>i.localName==="vaadin-grid-cell-content");this._setInteracting(n)}_detectFocusedItemIndex(r){let{section:n,row:i}=this._getGridEventLocation(r);n===this.$.items&&(this._focusedItemIndex=i.index)}_updateGridSectionFocusTarget(r){if(!r)return;let n=this._getGridSectionFromFocusTarget(r),i=this.interacting&&n===this._activeRowGroup;r.tabIndex=i?-1:0}_preventScrollerRotatingCellFocus(r,n){r.index===this._focusedItemIndex&&this.hasAttribute("navigating")&&this._activeRowGroup===this.$.items&&(this._navigatingIsHidden=!0,this._toggleAttribute("navigating",!1,this)),n===this._focusedItemIndex&&this._navigatingIsHidden&&(this._navigatingIsHidden=!1,this._toggleAttribute("navigating",!0,this))}_getColumns(r,n){let i=this._columnTree.length-1;return r===this.$.header?i=n:r===this.$.footer&&(i=this._columnTree.length-1-n),this._columnTree[i]}_resetKeyboardNavigation(){if(this.$.header.firstElementChild&&(this._headerFocusable=Array.from(this.$.header.firstElementChild.children).filter(r=>!r.hidden)[0]),this.$.items.firstElementChild){let r=this._iterateItems((n,i)=>{if(this._firstVisibleIndex===i)return this.$.items.children[n]});r&&(this._itemsFocusable=Array.from(r.children).filter(n=>!n.hidden)[0])}this.$.footer.firstElementChild&&(this._footerFocusable=Array.from(this.$.footer.firstElementChild.children).filter(r=>!r.hidden)[0])}_scrollHorizontallyToCell(r){if(r.hasAttribute("frozen")||this._elementMatches(r,'[part~="details-cell"]'))return;let n=r.getBoundingClientRect(),i=r.parentNode,o=Array.from(i.children).indexOf(r),a=this.$.table.getBoundingClientRect(),s=a.left,l=a.right;for(let c=o-1;c>=0;c--){let u=i.children[c];if(!(u.hasAttribute("hidden")||this._elementMatches(u,'[part~="details-cell"]'))&&u.hasAttribute("frozen")){s=u.getBoundingClientRect().right;break}}for(let c=o+1;c<i.children.length;c++){let u=i.children[c];if(!(u.hasAttribute("hidden")||this._elementMatches(u,'[part~="details-cell"]'))&&u.hasAttribute("frozen")){l=u.getBoundingClientRect().left;break}}n.left<s&&(this.$.table.scrollLeft+=Math.round(n.left-s)),n.right>l&&(this.$.table.scrollLeft+=Math.round(n.right-l))}_elementMatches(r,n){return r.matches?r.matches(n):Array.from(r.parentNode.querySelectorAll(n)).indexOf(r)!==-1}_getGridEventLocation(r){let n=r.composedPath(),i=n.indexOf(this.$.table),o=i>=1?n[i-1]:null,a=i>=2?n[i-2]:null,s=i>=3?n[i-3]:null;return{section:o,row:a,cell:s}}_getGridSectionFromFocusTarget(r){return r===this._headerFocusable?this.$.header:r===this._itemsFocusable?this.$.items:r===this._footerFocusable?this.$.footer:null}};function oue(e,t,r){let n=1;e.forEach(i=>{n%10===0&&n++,i._order=r+n*t,n++})}var aue=e=>class extends yh(e){static get properties(){return{columnReorderingAllowed:{type:Boolean,value:!1},_orderBaseScope:{type:Number,value:1e7}}}static get observers(){return["_updateOrders(_columnTree, _columnTree.*)"]}ready(){super.ready(),Em(this,"track",this._onTrackEvent),this._reorderGhost=this.shadowRoot.querySelector('[part="reorder-ghost"]'),this.addEventListener("touchstart",this._onTouchStart.bind(this)),this.addEventListener("touchmove",this._onTouchMove.bind(this)),this.addEventListener("touchend",this._onTouchEnd.bind(this)),this.addEventListener("contextmenu",this._onContextMenu.bind(this))}_onContextMenu(r){this.hasAttribute("reordering")&&r.preventDefault()}_onTouchStart(r){this._startTouchReorderTimeout=setTimeout(()=>{this._onTrackStart({detail:{x:r.touches[0].clientX,y:r.touches[0].clientY}})},100)}_onTouchMove(r){this._draggedColumn&&r.preventDefault(),clearTimeout(this._startTouchReorderTimeout)}_onTouchEnd(){clearTimeout(this._startTouchReorderTimeout),this._onTrackEnd()}_onTrackEvent(r){if(r.detail.state==="start"){let n=r.composedPath(),i=n[n.indexOf(this.$.header)-2];if(!i||!i._content||i._content.contains(this.getRootNode().activeElement)||this.$.scroller.hasAttribute("column-resizing"))return;this._touchDevice||this._onTrackStart(r)}else r.detail.state==="track"?this._onTrack(r):r.detail.state==="end"&&this._onTrackEnd(r)}_onTrackStart(r){if(!this.columnReorderingAllowed)return;let n=r.composedPath&&r.composedPath();if(n&&n.filter(o=>o.hasAttribute&&o.hasAttribute("draggable"))[0])return;let i=this._cellFromPoint(r.detail.x,r.detail.y);if(!(!i||i.getAttribute("part").indexOf("header-cell")===-1)){for(this._toggleAttribute("reordering",!0,this),this._draggedColumn=i._column;this._draggedColumn.parentElement.childElementCount===1;)this._draggedColumn=this._draggedColumn.parentElement;this._setSiblingsReorderStatus(this._draggedColumn,"allowed"),this._draggedColumn._reorderStatus="dragging",this._updateGhost(i),this._reorderGhost.style.visibility="visible",this._updateGhostPosition(r.detail.x,this._touchDevice?r.detail.y-50:r.detail.y),this._autoScroller()}}_onTrack(r){if(!this._draggedColumn)return;let n=this._cellFromPoint(r.detail.x,r.detail.y);if(!n)return;let i=this._getTargetColumn(n,this._draggedColumn);this._isSwapAllowed(this._draggedColumn,i)&&this._isSwappableByPosition(i,r.detail.x)&&this._swapColumnOrders(this._draggedColumn,i),this._updateGhostPosition(r.detail.x,this._touchDevice?r.detail.y-50:r.detail.y),this._lastDragClientX=r.detail.x}_onTrackEnd(){!this._draggedColumn||(this._toggleAttribute("reordering",!1,this),this._draggedColumn._reorderStatus="",this._setSiblingsReorderStatus(this._draggedColumn,""),this._draggedColumn=null,this._lastDragClientX=null,this._reorderGhost.style.visibility="hidden",this.dispatchEvent(new CustomEvent("column-reorder",{detail:{columns:this._getColumnsInOrder()}})))}_getColumnsInOrder(){return this._columnTree.slice(0).pop().filter(r=>!r.hidden).sort((r,n)=>r._order-n._order)}_cellFromPoint(r,n){r=r||0,n=n||0,this._draggedColumn||this._toggleAttribute("no-content-pointer-events",!0,this.$.scroller);let i=this.shadowRoot.elementFromPoint(r,n);if(this._toggleAttribute("no-content-pointer-events",!1,this.$.scroller),i&&i._column)return i}_updateGhostPosition(r,n){let i=this._reorderGhost.getBoundingClientRect(),o=r-i.width/2,a=n-i.height/2,s=parseInt(this._reorderGhost._left||0),l=parseInt(this._reorderGhost._top||0);this._reorderGhost._left=s-(i.left-o),this._reorderGhost._top=l-(i.top-a),this._reorderGhost.style.transform=`translate(${this._reorderGhost._left}px, ${this._reorderGhost._top}px)`}_updateGhost(r){let n=this._reorderGhost;n.textContent=r._content.innerText;let i=window.getComputedStyle(r);return["boxSizing","display","width","height","background","alignItems","padding","border","flex-direction","overflow"].forEach(o=>n.style[o]=i[o]),n}_updateOrders(r,n){r===void 0||n===void 0||(r[0].forEach(i=>i._order=0),oue(r[0],this._orderBaseScope,0))}_setSiblingsReorderStatus(r,n){Array.from(r.parentNode.children).filter(i=>/column/.test(i.localName)&&this._isSwapAllowed(i,r)).forEach(i=>i._reorderStatus=n)}_autoScroller(){if(this._lastDragClientX){let r=this._lastDragClientX-this.getBoundingClientRect().right+50,n=this.getBoundingClientRect().left-this._lastDragClientX+50;r>0?this.$.table.scrollLeft+=r/10:n>0&&(this.$.table.scrollLeft-=n/10),this._scrollHandler()}this._draggedColumn&&this.async(this._autoScroller,10)}_isSwapAllowed(r,n){if(r&&n){let i=r!==n,o=r.parentElement===n.parentElement,a=r.frozen===n.frozen;return i&&o&&a}}_isSwappableByPosition(r,n){let i=Array.from(this.$.header.querySelectorAll('tr:not([hidden]) [part~="cell"]')).filter(s=>r.contains(s._column))[0],o=this.$.header.querySelector("tr:not([hidden]) [reorder-status=dragging]").getBoundingClientRect(),a=i.getBoundingClientRect();return a.left>o.left?n>a.right-o.width:n<a.left+o.width}_swapColumnOrders(r,n){let i=r._order;r._order=n._order,n._order=i,this._updateLastFrozen(),this._updateFirstAndLastColumn()}_getTargetColumn(r,n){if(r&&n){let i=r._column;for(;i.parentElement!==n.parentElement&&i!==this;)i=i.parentElement;return i.parentElement===n.parentElement?i:r._column}}};var nhr=e=>class extends e{static get properties(){return{resizable:{type:Boolean,value:function(){if(this.localName==="vaadin-grid-column-group")return;let r=this.parentNode;return r&&r.localName==="vaadin-grid-column-group"&&r.resizable||!1}},_headerTemplate:{type:Object},_footerTemplate:{type:Object},frozen:{type:Boolean,value:!1},hidden:{type:Boolean},header:{type:String},textAlign:{type:String},_lastFrozen:{type:Boolean,value:!1},_order:Number,_reorderStatus:Boolean,_emptyCells:Array,_headerCell:Object,_footerCell:Object,_grid:Object,headerRenderer:Function,footerRenderer:Function}}static get observers(){return["_widthChanged(width, _headerCell, _footerCell, _cells.*)","_frozenChanged(frozen, _headerCell, _footerCell, _cells.*)","_flexGrowChanged(flexGrow, _headerCell, _footerCell, _cells.*)","_pathOrHeaderChanged(path, header, _headerCell, _footerCell, _cells.*, renderer, headerRenderer, _bodyTemplate, _headerTemplate)","_textAlignChanged(textAlign, _cells.*, _headerCell, _footerCell)","_orderChanged(_order, _headerCell, _footerCell, _cells.*)","_lastFrozenChanged(_lastFrozen)","_setBodyTemplateOrRenderer(_bodyTemplate, renderer, _cells, _cells.*)","_setHeaderTemplateOrRenderer(_headerTemplate, headerRenderer, _headerCell)","_setFooterTemplateOrRenderer(_footerTemplate, footerRenderer, _footerCell)","_resizableChanged(resizable, _headerCell)","_reorderStatusChanged(_reorderStatus, _headerCell, _footerCell, _cells.*)","_hiddenChanged(hidden, _headerCell, _footerCell, _cells.*)"]}connectedCallback(){super.connectedCallback(),this._bodyTemplate&&(this._bodyTemplate.templatizer._grid=this._grid),this._headerTemplate&&(this._headerTemplate.templatizer._grid=this._grid),this._footerTemplate&&(this._footerTemplate.templatizer._grid=this._grid),this._templateObserver.flush(),this._bodyTemplate||this._templateObserver.callback(),requestAnimationFrame(()=>{this._allCells.forEach(r=>{r._content.parentNode||this._grid&&this._grid.appendChild(r._content)})})}disconnectedCallback(){super.disconnectedCallback(),requestAnimationFrame(()=>{this._findHostGrid()||this._allCells.forEach(r=>{r._content.parentNode&&r._content.parentNode.removeChild(r._content)})}),this._gridValue=void 0}_findHostGrid(){let r=this;for(;r&&!/^vaadin.*grid(-pro)?$/.test(r.localName);)r=r.assignedSlot?r.assignedSlot.parentNode:r.parentNode;return r||void 0}get _grid(){return this._gridValue||(this._gridValue=this._findHostGrid()),this._gridValue}get _allCells(){return[].concat(this._cells||[]).concat(this._emptyCells||[]).concat(this._headerCell).concat(this._footerCell).filter(r=>r)}constructor(){super(),this._templateObserver=new vh(this,()=>{this._headerTemplate=this._prepareHeaderTemplate(),this._footerTemplate=this._prepareFooterTemplate(),this._bodyTemplate=this._prepareBodyTemplate()})}_prepareHeaderTemplate(){return this._prepareTemplatizer(this._findTemplate(!0)||null,{})}_prepareFooterTemplate(){return this._prepareTemplatizer(this._findTemplate(!1,!0)||null,{})}_prepareBodyTemplate(){return this._prepareTemplatizer(this._findTemplate()||null)}_prepareTemplatizer(r,n){if(r&&!r.templatizer){let i=new T0;i._grid=this._grid,i.dataHost=this.dataHost,i._instanceProps=n||i._instanceProps,i.template=r,r.templatizer=i}return r}_renderHeaderAndFooter(){this.headerRenderer&&this._headerCell&&this.__runRenderer(this.headerRenderer,this._headerCell),this.footerRenderer&&this._footerCell&&this.__runRenderer(this.footerRenderer,this._footerCell)}__runRenderer(r,n,i){let o=[n._content,this];i&&i.item&&o.push(i),r.apply(this,o)}__setColumnTemplateOrRenderer(r,n,i){if(!this.hidden){if(r&&n)throw new Error("You should only use either a renderer or a template");i.forEach(o=>{let a=this._grid.__getRowModel(o.parentElement);if(n)o._renderer=n,(a.item||n===this.headerRenderer||n===this.footerRenderer)&&this.__runRenderer(n,o,a);else if(o._template!==r){o._template=r,o._content.innerHTML="",r.templatizer._grid=r.templatizer._grid||this._grid;let s=r.templatizer.createInstance();o._content.appendChild(s.root),o._instance=s,a.item&&o._instance.setProperties(a)}})}}_setBodyTemplateOrRenderer(r,n,i){(r||n)&&i&&this.__setColumnTemplateOrRenderer(r,n,i)}_setHeaderTemplateOrRenderer(r,n,i){(r||n)&&i&&this.__setColumnTemplateOrRenderer(r,n,[i])}_setFooterTemplateOrRenderer(r,n,i){(r||n)&&i&&(this.__setColumnTemplateOrRenderer(r,n,[i]),this._grid.__updateHeaderFooterRowVisibility(i.parentElement))}_selectFirstTemplate(r=!1,n=!1){return vh.getFlattenedNodes(this).filter(i=>i.localName==="template"&&i.classList.contains("header")===r&&i.classList.contains("footer")===n)[0]}_findTemplate(r,n){let i=this._selectFirstTemplate(r,n);return i&&this.dataHost&&(i._rootDataHost=this.dataHost._rootDataHost||this.dataHost),i}_flexGrowChanged(r){this.parentElement&&this.parentElement._columnPropChanged&&this.parentElement._columnPropChanged("flexGrow"),this._allCells.forEach(n=>n.style.flexGrow=r)}_orderChanged(r){this._allCells.forEach(n=>n.style.order=r)}_widthChanged(r){this.parentElement&&this.parentElement._columnPropChanged&&this.parentElement._columnPropChanged("width"),this._allCells.forEach(n=>n.style.width=r),this._grid&&this._grid.__forceReflow&&this._grid.__forceReflow()}_frozenChanged(r){this.parentElement&&this.parentElement._columnPropChanged&&this.parentElement._columnPropChanged("frozen",r),this._allCells.forEach(n=>this._toggleAttribute("frozen",r,n)),this._grid&&this._grid._frozenCellsChanged&&this._grid._frozenCellsChanged()}_lastFrozenChanged(r){this._allCells.forEach(n=>this._toggleAttribute("last-frozen",r,n)),this.parentElement&&this.parentElement._columnPropChanged&&(this.parentElement._lastFrozen=r)}_pathOrHeaderChanged(r,n,i,o,a,s,l,c,u){let h=n!==void 0;if(!l&&!u&&h&&i&&this.__setTextContent(i._content,n),r&&a.value){if(!s&&!c){let f=(p,d,{item:g})=>this.__setTextContent(p,this.get(r,g));this.__setColumnTemplateOrRenderer(void 0,f,a.value)}!l&&!u&&!h&&i&&n!==null&&this.__setTextContent(i._content,this._generateHeader(r))}i&&this._grid.__updateHeaderFooterRowVisibility(i.parentElement)}__setTextContent(r,n){r.textContent!==n&&(r.textContent=n)}_generateHeader(r){return r.substr(r.lastIndexOf(".")+1).replace(/([A-Z])/g,"-$1").toLowerCase().replace(/-/g," ").replace(/^./,n=>n.toUpperCase())}_toggleAttribute(r,n,i){i.hasAttribute(r)===!n&&(n?i.setAttribute(r,""):i.removeAttribute(r))}_reorderStatusChanged(r){this._allCells.forEach(n=>n.setAttribute("reorder-status",r))}_resizableChanged(r,n){r===void 0||n===void 0||n&&[n].concat(this._emptyCells).forEach(i=>{if(i){let o=i.querySelector('[part~="resize-handle"]');if(o&&i.removeChild(o),r){let a=document.createElement("div");a.setAttribute("part","resize-handle"),i.appendChild(a)}}})}_textAlignChanged(r){if(r===void 0)return;if(["start","end","center"].indexOf(r)===-1){console.warn('textAlign can only be set as "start", "end" or "center"');return}let n;getComputedStyle(this._grid).direction==="ltr"?r==="start"?n="left":r==="end"&&(n="right"):r==="start"?n="right":r==="end"&&(n="left"),this._allCells.forEach(i=>{i._content.style.textAlign=r,getComputedStyle(i._content).textAlign!==r&&(i._content.style.textAlign=n)})}_hiddenChanged(r){this.parentElement&&this.parentElement._columnPropChanged&&this.parentElement._columnPropChanged("hidden",r),!!r!=!!this._previousHidden&&this._grid&&(r===!0&&this._allCells.forEach(n=>{n._content.parentNode&&n._content.parentNode.removeChild(n._content)}),this._grid._debouncerHiddenChanged=sr.debounce(this._grid._debouncerHiddenChanged,Ni,()=>{this._grid&&this._grid._renderColumnTree&&this._grid._renderColumnTree(this._grid._columnTree)}),this._grid._updateLastFrozen&&this._grid._updateLastFrozen(),this._grid.notifyResize&&this._grid.notifyResize(),this._grid._resetKeyboardNavigation&&this._grid._resetKeyboardNavigation()),this._previousHidden=r}},tV=class extends nhr(KH(mt)){static get is(){return"vaadin-grid-column"}static get properties(){return{width:{type:String,value:"100px"},flexGrow:{type:Number,value:1},renderer:Function,path:{type:String},autoWidth:{type:Boolean,value:!1},_bodyTemplate:{type:Object},_cells:Array}}};customElements.define(tV.is,tV);jc("vaadin-grid",Ci`
    @keyframes vaadin-grid-appear {
      to {
        opacity: 1;
      }
    }

    :host {
      display: block;
      animation: 1ms vaadin-grid-appear;
      height: 400px;
      flex: 1 1 auto;
      align-self: stretch;
      position: relative;
    }

    :host([hidden]) {
      display: none !important;
    }

    #scroller {
      display: block;
      transform: translateY(0);
      width: auto;
      height: auto;
      position: absolute;
      top: 0;
      right: 0;
      bottom: 0;
      left: 0;
    }

    :host([height-by-rows]) {
      height: auto;
      align-self: flex-start;
      flex-grow: 0;
      width: 100%;
    }

    :host([height-by-rows]) #scroller {
      width: 100%;
      height: 100%;
      position: relative;
    }

    #table {
      display: flex;
      flex-direction: column;
      width: 100%;
      height: 100%;
      overflow: auto;
      position: relative;
      outline: none;
      /* Workaround for a Desktop Safari bug: new stacking context here prevents the scrollbar from getting hidden */
      z-index: 0;
    }

    #header,
    #footer {
      display: block;
      position: -webkit-sticky;
      position: sticky;
      left: 0;
      overflow: visible;
      width: 100%;
      z-index: 1;
    }

    #header {
      top: 0;
    }

    th {
      text-align: inherit;
    }

    /* Safari doesn't work with "inherit" */
    [safari] th {
      text-align: initial;
    }

    #footer {
      bottom: 0;
    }

    #items {
      flex-grow: 1;
      flex-shrink: 0;
      display: block;
      position: -webkit-sticky;
      position: sticky;
      width: 100%;
      left: 0;
      overflow: visible;
    }

    [part~='row'] {
      display: flex;
      width: 100%;
      box-sizing: border-box;
      margin: 0;
    }

    [part~='row'][loading] [part~='body-cell'] ::slotted(vaadin-grid-cell-content) {
      opacity: 0;
    }

    #items [part~='row'] {
      position: absolute;
    }

    #items [part~='row']:empty {
      height: 1em;
    }

    [part~='cell']:not([part~='details-cell']) {
      flex-shrink: 0;
      flex-grow: 1;
      box-sizing: border-box;
      display: flex;
      width: 100%;
      position: relative;
      align-items: center;
      padding: 0;
      white-space: nowrap;
    }

    [part~='details-cell'] {
      position: absolute;
      bottom: 0;
      width: 100%;
      box-sizing: border-box;
      padding: 0;
    }

    [part~='cell'] ::slotted(vaadin-grid-cell-content) {
      display: block;
      width: 100%;
      box-sizing: border-box;
      overflow: hidden;
      text-overflow: ellipsis;
    }

    [hidden] {
      display: none !important;
    }

    [frozen] {
      z-index: 2;
      will-change: transform;
    }

    [no-scrollbars][safari] #table,
    [no-scrollbars][firefox] #table {
      overflow: hidden;
    }

    /* Reordering styles */
    :host([reordering]) [part~='cell'] ::slotted(vaadin-grid-cell-content),
    :host([reordering]) [part~='resize-handle'],
    #scroller[no-content-pointer-events] [part~='cell'] ::slotted(vaadin-grid-cell-content) {
      pointer-events: none;
    }

    [part~='reorder-ghost'] {
      visibility: hidden;
      position: fixed;
      pointer-events: none;
      opacity: 0.5;

      /* Prevent overflowing the grid in Firefox */
      top: 0;
      left: 0;
    }

    :host([reordering]) {
      -moz-user-select: none;
      -webkit-user-select: none;
      user-select: none;
    }

    /* Resizing styles */
    [part~='resize-handle'] {
      position: absolute;
      top: 0;
      right: 0;
      height: 100%;
      cursor: col-resize;
      z-index: 1;
    }

    [part~='resize-handle']::before {
      position: absolute;
      content: '';
      height: 100%;
      width: 35px;
      transform: translateX(-50%);
    }

    [last-column] [part~='resize-handle']::before,
    [last-frozen] [part~='resize-handle']::before {
      width: 18px;
      transform: none;
      right: 0;
    }

    #scroller[column-resizing] {
      -ms-user-select: none;
      -moz-user-select: none;
      -webkit-user-select: none;
      user-select: none;
    }

    /* Sizer styles */
    #sizer {
      display: flex;
      position: absolute;
      visibility: hidden;
    }

    #sizer [part~='details-cell'] {
      display: none !important;
    }

    #sizer [part~='cell'][hidden] {
      display: none !important;
    }

    #sizer [part~='cell'] {
      display: block;
      flex-shrink: 0;
      line-height: 0;
      height: 0 !important;
      min-height: 0 !important;
      max-height: 0 !important;
      padding: 0 !important;
      border: none !important;
    }

    #sizer [part~='cell']::before {
      content: '-';
    }

    #sizer [part~='cell'] ::slotted(vaadin-grid-cell-content) {
      display: none !important;
    }

    /* RTL specific styles */

    :host([dir='rtl']) #items,
    :host([dir='rtl']) #header,
    :host([dir='rtl']) #footer {
      left: auto;
    }

    :host([dir='rtl']) [part~='reorder-ghost'] {
      left: auto;
      right: 0;
    }

    :host([dir='rtl']) [part~='resize-handle'] {
      left: 0;
      right: auto;
    }

    :host([dir='rtl']) [part~='resize-handle']::before {
      transform: translateX(50%);
    }

    :host([dir='rtl']) [last-column] [part~='resize-handle']::before,
    :host([dir='rtl']) [last-frozen] [part~='resize-handle']::before {
      left: 0;
      right: auto;
    }
  `,{moduleId:"vaadin-grid-styles"});var ihr=(()=>{try{return document.createEvent("TouchEvent"),!0}catch(e){return!1}})(),eV=class extends ZH(jH(Xce(Gce($ce(qce(Qce(tue(eue(Jce(iue(Uce(Zce(aue(Wce(Kce(nue(rue(QH)))))))))))))))))){static get template(){return Q`
      <div
        id="scroller"
        safari$="[[_safari]]"
        ios$="[[_ios]]"
        loading$="[[loading]]"
        column-reordering-allowed$="[[columnReorderingAllowed]]"
      >
        <table id="table" role="grid" aria-multiselectable="true" tabindex="0">
          <caption id="sizer" part="row"></caption>
          <thead id="header" role="rowgroup"></thead>
          <tbody id="items" role="rowgroup"></tbody>
          <tfoot id="footer" role="rowgroup"></tfoot>
        </table>

        <div part="reorder-ghost"></div>
      </div>

      <div id="focusexit" tabindex="0"></div>
    `}static get is(){return"vaadin-grid"}static get version(){return"20.0.2"}static get observers(){return["_columnTreeChanged(_columnTree, _columnTree.*)"]}static get properties(){return{_safari:{type:Boolean,value:/^((?!chrome|android).)*safari/i.test(navigator.userAgent)},_ios:{type:Boolean,value:/iPad|iPhone|iPod/.test(navigator.userAgent)&&!window.MSStream||navigator.platform==="MacIntel"&&navigator.maxTouchPoints>1},_firefox:{type:Boolean,value:navigator.userAgent.toLowerCase().indexOf("firefox")>-1},_android:{type:Boolean,value:/android/i.test(navigator.userAgent)},_touchDevice:{type:Boolean,value:ihr},heightByRows:{type:Boolean,value:!1,reflectToAttribute:!0,observer:"_heightByRowsChanged"},_recalculateColumnWidthOnceLoadingFinished:{type:Boolean,value:!0}}}constructor(){super(),this.addEventListener("animationend",this._onAnimationEnd)}connectedCallback(){super.connectedCallback(),this.recalculateColumnWidths()}attributeChangedCallback(t,r,n){super.attributeChangedCallback(t,r,n),t==="dir"&&(this.__isRTL=n==="rtl",this._updateScrollerMeasurements())}__hasRowsWithClientHeight(){return!!Array.from(this.$.items.children).filter(t=>t.clientHeight).length}__itemsReceived(){this._recalculateColumnWidthOnceLoadingFinished&&!this._cache.isLoading()&&this.__hasRowsWithClientHeight()&&(this._recalculateColumnWidthOnceLoadingFinished=!1,this.recalculateColumnWidths())}_recalculateColumnWidths(t){t.forEach(r=>{r.width="auto",r._origFlexGrow=r.flexGrow,r.flexGrow=0}),t.forEach(r=>{r._currentWidth=0,r._allCells.forEach(n=>{let i=n.offsetWidth+1;r._currentWidth=Math.max(r._currentWidth,i)})}),t.forEach(r=>{r.width=`${r._currentWidth}px`,r.flexGrow=r._origFlexGrow,r._currentWidth=void 0,r._origFlexGrow=void 0})}recalculateColumnWidths(){if(!!this._columnTree)if(this._cache.isLoading())this._recalculateColumnWidthOnceLoadingFinished=!0;else{let t=this._getColumns().filter(r=>!r.hidden&&r.autoWidth);this._recalculateColumnWidths(t)}}_createScrollerRows(t){let r=[];for(let n=0;n<t;n++){let i=document.createElement("tr");i.setAttribute("part","row"),i.setAttribute("role","row"),this._columnTree&&this._updateRow(i,this._columnTree[this._columnTree.length-1],"body",!1,!0),r.push(i)}return this._columnTree&&this._columnTree[this._columnTree.length-1].forEach(n=>n.isConnected&&n.notifyPath&&n.notifyPath("_cells.*",n._cells)),mgt(this,()=>{this._updateFirstAndLastColumn(),this._resetKeyboardNavigation()}),r}_getRowTarget(){return this.$.items}_createCell(t){let r=this._contentIndex=this._contentIndex+1||0,n="vaadin-grid-cell-content-"+r,i=document.createElement("vaadin-grid-cell-content");i.setAttribute("slot",n);let o=document.createElement(t);o.id=n.replace("-content-","-"),o.setAttribute("tabindex","-1"),o.setAttribute("role",t==="td"?"gridcell":"columnheader");let a=document.createElement("slot");return a.setAttribute("name",n),o.appendChild(a),o._content=i,i.addEventListener("mousedown",()=>{if(window.chrome){let s=()=>{i.contains(this.getRootNode().activeElement)||o.focus(),document.removeEventListener("mouseup",s,!0)};document.addEventListener("mouseup",s,!0)}else setTimeout(()=>{i.contains(this.getRootNode().activeElement)||o.focus()})}),o}_updateRow(t,r,n,i,o){n=n||"body";let a=document.createDocumentFragment();Array.from(t.children).forEach(s=>s._vacant=!0),t.innerHTML="",t.id!=="sizer"&&(t.hidden=!0),r.filter(s=>!s.hidden).forEach((s,l,c)=>{let u;if(n==="body"){if(s._cells=s._cells||[],u=s._cells.filter(h=>h._vacant)[0],u||(u=this._createCell("td"),s._cells.push(u)),u.setAttribute("part","cell body-cell"),t.appendChild(u),l===c.length-1&&(this._rowDetailsTemplate||this.rowDetailsRenderer)){this._detailsCells=this._detailsCells||[];let h=this._detailsCells.filter(f=>f._vacant)[0]||this._createCell("td");this._detailsCells.indexOf(h)===-1&&this._detailsCells.push(h),h._content.parentElement||a.appendChild(h._content),this._configureDetailsCell(h),t.appendChild(h),this._a11ySetRowDetailsCell(t,h),h._vacant=!1}s.notifyPath&&!o&&s.notifyPath("_cells.*",s._cells)}else{let h=n==="header"?"th":"td";i||s.localName==="vaadin-grid-column-group"?(u=s[`_${n}Cell`]||this._createCell(h),u._column=s,t.appendChild(u),s[`_${n}Cell`]=u):(s._emptyCells=s._emptyCells||[],u=s._emptyCells.filter(f=>f._vacant)[0]||this._createCell(h),u._column=s,t.appendChild(u),s._emptyCells.indexOf(u)===-1&&s._emptyCells.push(u)),u.setAttribute("part",`cell ${n}-cell`),this.__updateHeaderFooterRowVisibility(t)}u._content.parentElement||a.appendChild(u._content),u._vacant=!1,u._column=s}),this.appendChild(a),this._frozenCellsChanged(),this._updateFirstAndLastColumnForRow(t)}__updateHeaderFooterRowVisibility(t){if(!t)return;let r=Array.from(t.children).filter(n=>{let i=n._column;if(i._emptyCells&&i._emptyCells.indexOf(n)>-1)return!1;if(t.parentElement===this.$.header){if(i.headerRenderer||i._headerTemplate)return!0;if(i.header===null)return!1;if(i.path||i.header!==void 0)return!0}else if(i.footerRenderer||i._footerTemplate)return!0});t.hidden!==!r.length&&(t.hidden=!r.length,this.notifyResize())}_updateScrollerItem(t,r){this._preventScrollerRotatingCellFocus(t,r),this._columnTree&&(this._toggleAttribute("first",r===0,t),this._toggleAttribute("odd",r%2,t),this._a11yUpdateRowRowindex(t,r),this._getItem(r,t))}_columnTreeChanged(t){this._renderColumnTree(t),this.recalculateColumnWidths()}_renderColumnTree(t){for(Array.from(this.$.items.children).forEach(r=>this._updateRow(r,t[t.length-1],null,!1,!0));this.$.header.children.length<t.length;){let r=document.createElement("tr");r.setAttribute("part","row"),r.setAttribute("role","row"),this.$.header.appendChild(r);let n=document.createElement("tr");n.setAttribute("part","row"),n.setAttribute("role","row"),this.$.footer.appendChild(n)}for(;this.$.header.children.length>t.length;)this.$.header.removeChild(this.$.header.firstElementChild),this.$.footer.removeChild(this.$.footer.firstElementChild);Array.from(this.$.header.children).forEach((r,n)=>this._updateRow(r,t[n],"header",n===t.length-1)),Array.from(this.$.footer.children).forEach((r,n)=>this._updateRow(r,t[t.length-1-n],"footer",n===0)),this._updateRow(this.$.sizer,t[t.length-1]),this._resizeHandler(),this._frozenCellsChanged(),this._updateFirstAndLastColumn(),this._resetKeyboardNavigation(),this._a11yUpdateHeaderRows(),this._a11yUpdateFooterRows(),this.__updateFooterPositioning()}__updateFooterPositioning(){this._firefox&&(this.$.items.style.paddingBottom=0,this.heightByRows||(this.$.items.style.paddingBottom=`${this.$.footer.offsetHeight}px`)),this._ios&&!window.CSS.supports("position","sticky")&&(this.$.table.style.height="",this.$.table.style.minHeight="100%",this.$.table.style.maxHeight="100%",setTimeout(()=>this.$.table.style.height=`${this.$.scroller.offsetHeight}px`))}_updateItem(t,r){t._item=r;let n=this.__getRowModel(t);this._toggleAttribute("selected",n.selected,t),this._a11yUpdateRowSelected(t,n.selected),this._a11yUpdateRowLevel(t,n.level),this._toggleAttribute("expanded",n.expanded,t),this._toggleAttribute("details-opened",this._isDetailsOpened(r),t),(this._rowDetailsTemplate||this.rowDetailsRenderer)&&this._toggleDetailsCell(t,r),this._generateCellClassNames(t,n),this._filterDragAndDrop(t,n),Array.from(t.children).forEach(i=>{if(i._renderer){let o=i._column||this;i._renderer.call(o,i._content,o,n)}else i._instance&&(i._instance.__detailsOpened__=n.detailsOpened,i._instance.__selected__=n.selected,i._instance.__level__=n.level,i._instance.__expanded__=n.expanded,i._instance.setProperties(n))}),this._debouncerUpdateHeights=sr.debounce(this._debouncerUpdateHeights,mo.after(1),()=>{this._updateMetrics(),this._positionItems(),this._updateScrollerSize()})}_resizeHandler(){this._updateDetailsCellHeights(),this._accessIronListAPI(super._resizeHandler,!0),this._updateScrollerMeasurements(),this.__updateFooterPositioning()}_onAnimationEnd(t){t.animationName.indexOf("vaadin-grid-appear")===0&&(this._render(),t.stopPropagation(),this.notifyResize(),this.__itemsReceived(),requestAnimationFrame(()=>{this.__scrollToPendingIndex(),this.$.table.style.webkitOverflowScrolling="touch"}))}_toggleAttribute(t,r,n){n.hasAttribute(t)===!r&&(r?n.setAttribute(t,""):n.removeAttribute(t))}__getRowModel(t){return{index:t.index,item:t._item,level:this._getIndexLevel(t.index),expanded:this._isExpanded(t._item),selected:this._isSelected(t._item),detailsOpened:!!(this._rowDetailsTemplate||this.rowDetailsRenderer)&&this._isDetailsOpened(t._item)}}render(){this._columnTree&&(this._columnTree.forEach(t=>{t.forEach(r=>r._renderHeaderAndFooter())}),this._update())}notifyResize(){super.notifyResize()}_heightByRowsChanged(t,r){(t||r)&&this.notifyResize()}__forceReflow(){this._debouncerForceReflow=sr.debounce(this._debouncerForceReflow,Ni,()=>{this.$.scroller.style.overflow="hidden",setTimeout(()=>this.$.scroller.style.overflow="")})}};customElements.define(eV.is,eV);function sue(e,t){return Ngt(e,t)}var cv=class extends mt{constructor(){super(...arguments),this._run=""}_csvUrl(t,r,n){return r?Cn(n(t,r),{format:"csv"}):""}_jsonUrl(t,r,n){return r?n(t,r):""}_csvName(t,r){return r?`run-${r}-tag-${t}.csv`:""}_jsonName(t,r){return r?`run-${r}-tag-${t}.json`:""}};cv.template=Q`
    <paper-dropdown-menu
      no-label-float="true"
      label="run to download"
      selected-item-label="{{_run}}"
    >
      <paper-listbox slot="dropdown-content">
        <template is="dom-repeat" items="[[runs]]">
          <paper-item no-label-float="true">[[item]]</paper-item>
        </template>
      </paper-listbox>
    </paper-dropdown-menu>
    <template is="dom-if" if="[[_run]]">
      <a download="[[_csvName(tag, _run)]]" href="[[_csvUrl(tag, _run, urlFn)]]"
        >CSV</a
      ><!--
      --><a
        download="[[_jsonName(tag, _run)]]"
        href="[[_jsonUrl(tag, _run, urlFn)]]"
        >JSON</a
      >
    </template>
    <style>
      :host {
        display: flex;
        align-items: center;
        height: 32px;
      }
      paper-dropdown-menu {
        width: 100px;
        --paper-input-container-label: {
          font-size: 10px;
        }
        --paper-input-container-input: {
          font-size: 10px;
        }
      }
      a {
        font-size: 10px;
        margin: 0 0.2em;
      }
      paper-input {
        font-size: 22px;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],cv.prototype,"_run",void 0);E([A({type:Array}),w("design:type",Array)],cv.prototype,"runs",void 0);E([A({type:String}),w("design:type",String)],cv.prototype,"tag",void 0);E([A({type:Object}),w("design:type",Object)],cv.prototype,"urlFn",void 0);cv=E([yt("tf-downloader")],cv);var ohr=64,pli=new URLSearchParams(window.location.search),Wn=class extends mt{constructor(){super(...arguments),this.colorScale=null,this._loadDataCallback=(t,r,n)=>{if(n==null){console.error("Failed to load data for:",r);return}let i=n.map(a=>({wall_time:new Date(a[0]*1e3),step:a[1],scalar:a[2]})),o=this._getSeriesNameFromDatum(r);t.setSeriesMetadata(o,r),t.setSeriesData(o,i)},this.getDataLoadUrl=({tag:t,run:r})=>ve().pluginRoute("scalars","/scalars",new URLSearchParams({tag:t,run:r})),this._downloadUrlFn=(t,r)=>this.getDataLoadUrl({tag:t,run:r}),this.requestData=(t,r,n)=>this.inColab?this._requestDataGet(t,r,n):this._requestDataPost(t,r,n),this._requestDataGet=(t,r,n)=>{let o=ve().pluginRoute("scalars","/scalars");Promise.all(t.map(a=>{let s=Cn(o,{tag:a.tag,run:a.run});return this.requestManager.request(s).then(l=>void r({item:a,data:l}))})).finally(()=>void n())},this._requestDataPost=(t,r,n)=>{var c;let o=ve().pluginRoute("scalars","/scalars_multirun"),a=new Map;for(let{tag:u,run:h}of t){let f=a.get(u);f==null&&a.set(u,f=[]),f.push(h)}let s=(c=this.batchSize)!=null?c:ohr,l=[];for(let[u,h]of a)for(let f=0;f<h.length;f+=s)l.push({tag:u,runs:h.slice(f,f+s)});Promise.all(l.map(({tag:u,runs:h})=>this.requestManager.request(o,{tag:u,runs:h}).then(f=>{for(let p of h){let d={tag:u,run:p};Object.prototype.hasOwnProperty.call(f,p)?r({item:d,data:f[p]}):r({item:d,data:null})}}))).finally(()=>void n())},this._getDataLoadName=t=>this._getSeriesNameFromDatum(t),this._expanded=!1,this._tooltipColumns=(()=>{let t=ost.slice(),r=t.findIndex(n=>n.title=="Name");return t.splice(r,1,{title:"Name",evaluate:n=>{let i=n.dataset.metadata().meta;return this._getSeriesDisplayNameFromDatum(i)}}),t})()}_getChartDataLoader(){var t;return(t=this.shadowRoot)==null?void 0:t.querySelector("tf-line-chart-data-loader")}reload(){this._getChartDataLoader().reload()}redraw(){this._getChartDataLoader().redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}_toggleLogScale(){this.set("_logScaleActive",!this._logScaleActive)}_resetDomain(){let t=this._getChartDataLoader();t&&t.resetDomain()}_updateDownloadLink(){var n;let t=this._getChartDataLoader().exportAsSvgString(),r=(n=this.shadowRoot)==null?void 0:n.querySelector("#svgLink");r.href=`data:image/svg+xml;base64,${btoa(t)}`}_runsFromData(t){return t.map(r=>r.run)}_getDataSeries(){return this.dataToLoad.map(t=>this._getSeriesNameFromDatum(t))}_getSeriesNameFromDatum({run:t,experiment:r={name:"_default"}}){return JSON.stringify([r.name,t])}_getSeriesDisplayNameFromDatum(t){return t.run}_getColorScale(){return this.colorScale!==null?this.colorScale:{scale:t=>{let[,r]=JSON.parse(t);return fn(r)}}}};Wn.template=Q`
    <tf-card-heading
      tag="[[tag]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
    ></tf-card-heading>
    <div id="tf-line-chart-data-loader-container">
      <tf-line-chart-data-loader
        active="[[active]]"
        color-scale="[[_getColorScale(colorScale)]]"
        data-series="[[_getDataSeries(dataToLoad.*)]]"
        data-to-load="[[dataToLoad]]"
        get-data-load-name="[[_getDataLoadName]]"
        get-data-load-url="[[getDataLoadUrl]]"
        request-data="[[requestData]]"
        ignore-y-outliers="[[ignoreYOutliers]]"
        load-data-callback="[[_loadDataCallback]]"
        load-key="[[tag]]"
        log-scale-active="[[_logScaleActive]]"
        request-manager="[[requestManager]]"
        smoothing-enabled="[[smoothingEnabled]]"
        smoothing-weight="[[smoothingWeight]]"
        tag-metadata="[[tagMetadata]]"
        tooltip-columns="[[_tooltipColumns]]"
        tooltip-position="auto"
        tooltip-sorting-method="[[tooltipSortingMethod]]"
        x-type="[[xType]]"
      >
      </tf-line-chart-data-loader>
    </div>
    <div id="buttons">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
      <paper-icon-button
        selected$="[[_logScaleActive]]"
        icon="line-weight"
        on-tap="_toggleLogScale"
        title="Toggle y-axis log scale"
      ></paper-icon-button>
      <paper-icon-button
        icon="settings-overscan"
        on-tap="_resetDomain"
        title="Fit domain to data"
      ></paper-icon-button>
      <template is="dom-if" if="[[showDownloadLinks]]">
        <paper-menu-button on-paper-dropdown-open="_updateDownloadLink">
          <paper-icon-button
            class="dropdown-trigger"
            slot="dropdown-trigger"
            icon="file-download"
          ></paper-icon-button>
          <paper-listbox class="dropdown-content" slot="dropdown-content">
            <paper-item>
              <a id="svgLink" download="[[tag]].svg">
                Download Current Chart as SVG
              </a>
            </paper-item>
          </paper-listbox>
        </paper-menu-button>
      </template>
      <span style="flex-grow: 1"></span>
      <template is="dom-if" if="[[showDownloadLinks]]">
        <div class="download-links">
          <tf-downloader
            runs="[[_runsFromData(dataToLoad)]]"
            tag="[[tag]]"
            url-fn="[[_downloadUrlFn]]"
          ></tf-downloader>
        </div>
      </template>
    </div>
    <style>
      :host {
        margin: 5px;
        display: block;
        width: 330px;
      }

      :host([_expanded]) {
        width: 100%;
      }

      :host([_expanded]) #tf-line-chart-data-loader-container {
        height: 400px;
      }

      #tf-line-chart-data-loader-container {
        height: 200px;
        width: 100%;
      }

      tf-card-heading {
        display: block;
        margin-bottom: 10px;
      }

      #buttons {
        display: flex;
        flex-direction: row;
      }

      paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }

      paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }

      .download-links {
        display: flex;
        height: 32px;
      }

      .download-links a {
        align-self: center;
        font-size: 10px;
        margin: 2px;
      }

      .download-links paper-dropdown-menu {
        width: 100px;
        --paper-input-container-label: {
          font-size: 10px;
        }
        --paper-input-container-input: {
          font-size: 10px;
        }
      }

      paper-menu-button {
        padding: 0;
      }
      paper-item a {
        color: inherit;
        text-decoration: none;
        white-space: nowrap;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],Wn.prototype,"tag",void 0);E([A({type:Array}),w("design:type",Array)],Wn.prototype,"dataToLoad",void 0);E([A({type:String}),w("design:type",String)],Wn.prototype,"xType",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Wn.prototype,"active",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Wn.prototype,"ignoreYOutliers",void 0);E([A({type:Object}),w("design:type",Ae)],Wn.prototype,"requestManager",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Wn.prototype,"showDownLinks",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Wn.prototype,"smoothingEnabled",void 0);E([A({type:Number}),w("design:type",Number)],Wn.prototype,"smoothingWeight",void 0);E([A({type:Object}),w("design:type",Object)],Wn.prototype,"tagMetadata",void 0);E([A({type:Object}),w("design:type",Object)],Wn.prototype,"colorScale",void 0);E([A({type:String}),w("design:type",String)],Wn.prototype,"tooltipSortingMethod",void 0);E([A({type:Number}),w("design:type",Number)],Wn.prototype,"batchSize",void 0);E([A({type:Boolean}),w("design:type",Number)],Wn.prototype,"inColab",void 0);E([A({type:Object}),w("design:type",Object)],Wn.prototype,"_loadDataCallback",void 0);E([A({type:Object}),w("design:type",Function)],Wn.prototype,"getDataLoadUrl",void 0);E([A({type:Object}),w("design:type",Object)],Wn.prototype,"_downloadUrlFn",void 0);E([A({type:Object}),w("design:type",Function)],Wn.prototype,"requestData",void 0);E([A({type:Object}),w("design:type",Object)],Wn.prototype,"_getDataLoadName",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],Wn.prototype,"_expanded",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Wn.prototype,"_logScaleActive",void 0);E([A({type:Array}),w("design:type",Array)],Wn.prototype,"_tooltipColumns",void 0);Wn=E([yt("tf-scalar-card")],Wn);var Vs=class extends sue([uW],mt){constructor(){super(...arguments),this.sessionGroup=null,this._xType=Ed.STEP,this._noMultiExperiments=!1,this._requestData=(t,r,n)=>{Promise.all(t.map(i=>{let o={experimentName:this.experimentName,sessionName:i.run,metricName:i.tag};return this.backend.listMetricEvals(o).then(a=>void r({item:i,data:a}))})).finally(()=>void n())},this._colorScale={scale:t=>{let r=JSON.parse(t)[1],n=this._indexOfSession.get(r),i=nR;return i[(this._sessionGroupNameHash+n)%i.length]}}}connectedCallback(){super.connectedCallback(),this.addEventListener("iron-resize",this.redraw.bind(this))}redraw(){var t;(t=this.shadowRoot)==null||t.querySelectorAll("tf-scalar-card").forEach(r=>{r.redraw()})}_sessionGroupChanged(){var t;!this.sessionGroup||Object.keys(this.sessionGroup).length==0?(this._indexOfSession=new Map,this._sessionGroupNameHash=0):(this._indexOfSession=new Map(this.sessionGroup.sessions.map((r,n)=>[r.name,n])),this._sessionGroupNameHash=mct(this.sessionGroup.name)),(t=this.shadowRoot)==null||t.querySelectorAll("tf-scalar-card").forEach(r=>{let n=r,i=n.get("tag");n.set("tag",""),n.set("tag",i)})}_haveMetrics(){return this.visibleSchema&&Array.isArray(this.visibleSchema.metricInfos)&&this.visibleSchema.metricInfos.length>0}_haveMetricsAndSessionGroup(){return this.sessionGroup&&this._haveMetrics()}_computeSeriesForSessionGroupMetric(t,r){return t===null||Object.keys(t).length==0||r===null?[]:t.sessions.filter(n=>f3(n.metricValues,r.name)!==void 0).map(n=>({tag:r.name,run:n.name}))}_computeTagMetadata(t){return{displayName:Qu(t),description:t.description||""}}};Vs.template=Q`
    <template is="dom-if" if="[[!sessionGroup]]">
      <div>
        <h3>No session group selected</h3>
        <p>Please select a session group to see its metric-graphs here.</p>
      </div>
    </template>
    <template is="dom-if" if="[[!_haveMetrics(visibleSchema.*)]]">
      <div>
        <h3>No metrics are enabled</h3>
        <p>Please enable some metrics to see content here.</p>
      </div>
    </template>
    <div class="layout horizontal wrap session-group-details">
      <template
        is="dom-if"
        if="[[_haveMetricsAndSessionGroup(visibleSchema.*, sessionGroup)]]"
      >
        <template
          is="dom-repeat"
          items="[[visibleSchema.metricInfos]]"
          as="metricInfo"
        >
          <!-- Note that we do not provide a request-manager attribute since
               we provide a function in request-data for calling the backend
               to get the metrics data.
            -->
          <tf-scalar-card
            class="scalar-card"
            color-scale="[[_colorScale]]"
            data-to-load="[[_computeSeriesForSessionGroupMetric(sessionGroup, metricInfo)]]"
            tag="[[metricInfo.name.tag]]"
            tag-metadata="[[_computeTagMetadata(metricInfo)]]"
            x-type="[[_xType]]"
            multi-experiments="[[_noMultiExperiments]]"
            request-data="[[_requestData]]"
            active
          >
          </tf-scalar-card>
        </template>
      </template>
    </div>
    <!-- "iron-flex" is needed to use the layout classes in the div above -->
    <style include="iron-flex">
      :host {
        display: block;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],Vs.prototype,"backend",void 0);E([A({type:String}),w("design:type",String)],Vs.prototype,"experimentName",void 0);E([A({type:Object}),w("design:type",Object)],Vs.prototype,"visibleSchema",void 0);E([A({type:Object}),w("design:type",Object)],Vs.prototype,"sessionGroup",void 0);E([A({type:String}),w("design:type",String)],Vs.prototype,"_xType",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Vs.prototype,"_noMultiExperiments",void 0);E([A({type:Object}),w("design:type",Object)],Vs.prototype,"_indexOfSession",void 0);E([A({type:Number}),w("design:type",Number)],Vs.prototype,"_sessionGroupNameHash",void 0);E([A({type:Object}),w("design:type",Function)],Vs.prototype,"_requestData",void 0);E([A({type:Object}),w("design:type",Object)],Vs.prototype,"_colorScale",void 0);E([Bt("sessionGroup.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Vs.prototype,"_sessionGroupChanged",null);Vs=E([yt("tf-hparams-session-group-details")],Vs);var Hd=class extends Gt(_o(mt)){constructor(){super(...arguments),this._hparamName=Fd,this._metricName=Qu}_visibleSchemaOrSessionGroupsChanged(){let t=this.$.sessionGroupsTable.get("detailsOpenedItems");this.$.sessionGroupsTable.set("detailsOpenedItems",[]),ui();let r=new Map;this.sessionGroups.forEach(n=>{r.set(n.name,n)}),this.$.sessionGroupsTable.set("detailsOpenedItems",t.map(n=>r.get(n.name)).filter(Boolean))}_sessionGroupHParam(t,r){return t==null||Object.keys(t).length==0||!Object.prototype.hasOwnProperty.call(t.hparams,r)?"":b0(t.hparams[r])}_sessionGroupMetric(t,r){if(t==null||Object.keys(t).length==0)return"";for(let n=0;n<t.metricValues.length;++n){let i=t.metricValues[n];if(i.name.group===r.group&&i.name.tag==r.tag)return b0(i.value)}return""}_rowNumber(t){return t+1}};Hd.template=Q`
    <vaadin-grid
      class="session-group-table"
      id="sessionGroupsTable"
      column-reordering-allowed=""
      items="[[sessionGroups]]"
    >
      <vaadin-grid-column flex-grow="0" width="10em" resizable="">
        <template class="header">
          <div class="table-header table-cell">Trial ID</div>
        </template>
        <template>
          <div class="table-cell">[[item.name]]</div>
        </template>
      </vaadin-grid-column>
      <template is="dom-if" if="[[enableShowMetrics]]">
        <vaadin-grid-column flex-grow="0" autoWidth="" resizable="">
          <template class="header">
            <div class="table-header table-cell">Show Metrics</div>
          </template>
          <template>
            <paper-checkbox class="table-cell" checked="{{detailsOpened}}">
            </paper-checkbox>
          </template>
        </vaadin-grid-column>
      </template>
      <template
        is="dom-repeat"
        items="[[visibleSchema.hparamInfos]]"
        as="hparamInfo"
        index-as="hparamIndex"
      >
        <vaadin-grid-column flex-grow="2" width="10em" resizable="">
          <template class="header">
            <div class="table-header table-cell">
              [[_hparamName(hparamInfo)]]
            </div>
          </template>
          <template>
            <div class="table-cell">
              [[_sessionGroupHParam(item, hparamInfo.name)]]
            </div>
          </template>
        </vaadin-grid-column>
      </template>
      <template
        is="dom-repeat"
        items="{{visibleSchema.metricInfos}}"
        as="metricInfo"
        index-as="metricIndex"
      >
        <vaadin-grid-column flex-grow="2" width="10em" resizable="">
          <template class="header">
            <div class="table-header table-cell">
              [[_metricName(metricInfo)]]
            </div>
          </template>
          <template>
            <div class="table-cell">
              [[_sessionGroupMetric(item, metricInfo.name)]]
            </div>
          </template>
        </vaadin-grid-column>
      </template>
      <template class="row-details">
        <tf-hparams-session-group-details
          backend="[[backend]]"
          experiment-name="[[experimentName]]"
          session-group="[[item]]"
          visible-schema="[[visibleSchema]]"
          class="session-group-details"
        >
        </tf-hparams-session-group-details>
      </template>
    </vaadin-grid>

    <style>
      :host {
        display: inline;
      }

      :host(.dark-mode) {
        --lumo-base-color: #303030;
        --lumo-body-text-color: #fff;
      }

      :host(.dark-mode) vaadin-grid {
        --_lumo-grid-secondary-border-color: #505050;
      }

      .table-cell {
        white-space: nowrap;
        text-overflow: ellipsis;
        overflow: hidden;
      }
      .table-header {
        /* line-break overflowing column headers */
        white-space: normal;
        overflow-wrap: break-word;
      }
      .session-group-table {
        height: 100%;
      }
      .session-group-details {
        height: 360px;
        overflow-y: auto;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],Hd.prototype,"visibleSchema",void 0);E([A({type:Array}),w("design:type",Array)],Hd.prototype,"sessionGroups",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Hd.prototype,"enableShowMetrics",void 0);E([A({type:Object}),w("design:type",Object)],Hd.prototype,"backend",void 0);E([A({type:String}),w("design:type",String)],Hd.prototype,"experimentName",void 0);E([Bt("visibleSchema.*","sessionGroups.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],Hd.prototype,"_visibleSchemaOrSessionGroupsChanged",null);Hd=E([yt("tf-hparams-table-view")],Hd);var TP=class extends mt{constructor(){super(...arguments),this.sessionGroup=null,this.visibleSchema=null}_propertiesArePopulated(t,r){return t!=null&&r!==void 0&&r!==null}_singletonSessionGroups(t){return t==null?[]:[t]}};TP.template=Q`
    <!-- If sessionGroup or visibleSchema are not populated, do not display
         anything.
      -->
    <template
      is="dom-if"
      if="[[_propertiesArePopulated(visibleSchema, sessionGroup)]]"
    >
      <!-- Display one row without a "show-metrics" column -->
      <tf-hparams-table-view
        visible-schema="[[visibleSchema]]"
        session-groups="[[_singletonSessionGroups(sessionGroup)]]"
      >
      </tf-hparams-table-view>
    </template>
    <template
      is="dom-if"
      if="[[!_propertiesArePopulated(visibleSchema, sessionGroup)]]"
    >
      <div>Click or hover over a session group to display its values here.</div>
    </template>

    <style>
      :host {
        display: block;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],TP.prototype,"sessionGroup",void 0);E([A({type:Object}),w("design:type",Object)],TP.prototype,"visibleSchema",void 0);TP=E([yt("tf-hparams-session-group-values")],TP);var CP=Ee(Oe(),1);function lue(e,t,r,n){if(t.length<2)return console.error("Less than two axes in parallel coordinates plot."),null;let i=r[0],o=r[1];if(i<=t[0]||i>=t[t.length-1])return null;let a=CP.sortedIndex(t,i);console.assert(a>0),console.assert(a<t.length);let s=a-1;function l(h,f,p,d){let g=h-p,_=f-d,y=i-p,x=o-d,b=(g*y+_*x)/(g*g+_*_);if(b<=0)return p3(y,x);if(b>=1){let S=h-i,C=f-o;return p3(S,C)}return p3(y-b*g,x-b*_)}let c=null,u=null;return e.forEach(h=>{let f=l(h.controlPoints[s][0],h.controlPoints[s][1],h.controlPoints[a][0],h.controlPoints[a][1]);f>n||(c===null||f<c)&&(c=f,u=h)}),u}function cue(e,t,r){return e.domain().filter(n=>{let i=e(n);return t<=i&&i<=r})}function uue(e,t,r){let n=e.range(),i=n.filter(o=>t<=o&&o<=r).map(o=>{let a=e.invertExtent(o);return o===n[n.length-1]?[a[0],a[1]+1]:a});return i.length==0?[0,0]:aa(Im(i))}function hue(e,t,r){return[e.invert(t),e.invert(r)].sort((n,i)=>n-i)}function Bct(e,t,r){function n(){if(e.length===0)return[1,2];let[i,o]=aa(e);return i!==o?[i,o]:i>0?[i*.5,i*1.5]:i<0?[i*1.5,i*.5]:[-1,1]}if(r==="LINEAR")return zn().domain(n()).range([t,0]);if(r==="LOG"){let i=n();return i[0]<=0&&i[1]>=0?Bct(e,t,"LINEAR"):cc().domain(i).range([t,0])}else if(r==="QUANTILE"){let o=Ir(20).map(a=>t-a*t/19);return e.length===0&&(e=[1]),eg().domain(CP.uniq(e)).range(o)}else{if(r==="NON_NUMERIC")return tg().domain(CP.uniq(e.sort())).range([t,0]).padding(.1);throw RangeError("Unknown scale: "+r)}}var uv;(function(e){e.LINEAR="LINEAR",e.LOG="LOG",e.QUANTILE="QUANTILE",e.NON_NUMERIC="NON_NUMERIC"})(uv||(uv={}));var AP=class{isPassing(t){return!0}},rV=class{constructor(t,r,n,i){this._lower=t,this._upper=r,this._lowerOpen=n,this._upperOpen=i}isPassing(t){let r=t;return this._before(this._lower,r,!this._lowerOpen)&&this._before(r,this._upper,!this._upperOpen)}_before(t,r,n){return n?t<=r:t<r}},Vct=class{constructor(t){this._domainSet=t}isPassing(t){return this._domainSet.findIndex(r=>r===t)!==-1}},Uct=class{constructor(t,r,n,i){this._svgProps=t,this._schema=r,this._interactionManager=n,this._colIndex=i,this._isDisplayed=!1,this._yScale=null,this._scaleType=null,this.setBrushSelection(null)}colIndex(){return this._colIndex}yScale(){return this._yScale}scaleType(){return this._scaleType}brushSelection(){return this._brushSelection}isDisplayed(){return this._isDisplayed}setBrushSelection(t){this._brushSelection=t,this._brushFilter=this._buildBrushFilter(this.brushSelection(),this.scaleType(),this.yScale())}setDomainAndScale(t,r){this._scaleType=r,this._yScale=Bct(t.slice(),this._svgProps.height,this.scaleType()),this._brushFilter=this._buildBrushFilter(this.brushSelection(),this.scaleType(),this.yScale())}brushFilter(){return this._brushFilter}updateDOM(t){let r=lb(this.yScale());this.scaleType()===uv.QUANTILE&&(r=r.tickValues(this.yScale().quantiles()).tickFormat(xn("-.6g")));let n=Ht(t);n.selectAll("g").remove(),n.append("g").classed("axis",!0).call(r).append("text").classed("axis-title",!0).style("cursor","move").style("text-anchor","middle").attr("y",-9).text(a=>uct(this._schema,a)),n.call(pb().on("start",()=>{t.setAttribute("is-dragging",""),this._interactionManager.onDragStart(this.colIndex())}).on("drag",()=>this._interactionManager.onDrag(qt.x)).on("end",()=>{this._interactionManager.onDragEnd(),t.removeAttribute("is-dragging")}));let i=UL().extent([[-8,0],[8,this._svgProps.height+1]]).on("start",()=>{!Hct(qt)||(t.setAttribute("is-brushing",""),this._interactionManager.onBrushChanged(this.colIndex(),qt.selection))}).on("brush",()=>{!Hct(qt)||this._interactionManager.onBrushChanged(this.colIndex(),qt.selection)}).on("end",()=>{!Hct(qt)||(this._interactionManager.onBrushChanged(this.colIndex(),qt.selection),t.removeAttribute("is-brushing"))}),o=Ht(t).append("g").classed("brush",!0);o.call(i),i.move(o,this.brushSelection())}setDisplayed(t){this._isDisplayed=t}_buildBrushFilter(t,r,n){if(t===null)return new AP;if(r===null)return console.error("Scale type is null, but brushSelection isn't: ",t),new AP;switch(r){case uv.LINEAR:case uv.LOG:{let[i,o]=hue(n,t[0],t[1]);return new rV(i,o,!1,!1)}case uv.QUANTILE:{let[i,o]=uue(n,t[0],t[1]);return new rV(i,o,!1,!0)}case uv.NON_NUMERIC:return new Vct(cue(n,t[0],t[1]))}return console.error("Unknown scale type: ",r),new AP}},nV=class{constructor(t,r,n){this._svgProps=t,this._schema=r,this._axes=this._createAxes(n),this._stationaryAxesPositions=tg().range([1,this._svgProps.width-1]).padding(.5),this._draggedAxis=null,this._svgProps.svgG.selectAll("g.axis-parent").remove(),this._parentsSel=this._svgProps.svgG.selectAll(".axis-parent")}updateAxes(t,r){console.assert(!this.isAxisDragging());let n=new Set;t.columns.forEach(o=>{let a=o.absoluteIndex,s=this._axes[a];s.setDisplayed(!0);let l=r.map(c=>x0(this._schema,c,a));s.setDomainAndScale(l,o.scale),n.add(a)}),this._axes.forEach(o=>{n.has(o.colIndex())||o.setDisplayed(!1)}),this._updateStationaryAxesPositions(n),this._parentsSel=this._parentsSel.data(Array.from(n),o=>o),this._parentsSel.exit().remove(),this._parentsSel=this._parentsSel.enter().append("g").classed("axis-parent",!0).merge(this._parentsSel);let i=this;this._parentsSel.call(o=>this._updateAxesPositionsInDOM(o)).each(function(o){i._axes[o].updateDOM(this)})}mapVisibleAxes(t){return this._stationaryAxesPositions.domain().map(r=>t(this.getAxisPosition(r),this._axes[r]))}allVisibleAxesSatisfy(t){return this._stationaryAxesPositions.domain().every(r=>t(this.getAxisPosition(r),this._axes[r]))}getAxisForColIndex(t){return this._axes[t]}dragStart(t){console.assert(!this.isAxisDragging()),console.assert(this._axes[t].isDisplayed()),this._draggedAxis=this._axes[t],this._draggedAxisPosition=this._stationaryAxesPositions(t)}drag(t){t=Math.min(Math.max(t,0),this._svgProps.width),this._draggedAxisPosition=t;let r=this._stationaryAxesPositions.domain();r.sort((n,i)=>this.getAxisPosition(n)-this.getAxisPosition(i)),this._stationaryAxesPositions.domain(r),this._updateAxesPositionsInDOM(this._parentsSel)}dragEnd(t){console.assert(this.isAxisDragging()),this._draggedAxisPosition=null,this._draggedAxis=null,this._updateAxesPositionsInDOM(this._parentsSel.transition().duration(t))}isAxisDragging(){return this._draggedAxis!==null}getAxisPosition(t){return this._draggedAxis!==null&&this._draggedAxis.colIndex()===t?this._draggedAxisPosition:this._stationaryAxesPositions(t)}_updateStationaryAxesPositions(t){let r=this._stationaryAxesPositions.domain().filter(i=>t.has(i)),n=Array.from(new Set([...r,...Array.from(t)]));this._stationaryAxesPositions.domain(n)}_updateAxesPositionsInDOM(t){t.attr("transform",r=>_P(this.getAxisPosition(r)))}_createAxes(t){return Ir(hct(this._schema)).map(r=>new Uct(this._svgProps,this._schema,t,r))}};function Hct(e){return e.sourceEvent!==null}var jf;(function(e){e[e.FOREGROUND=0]="FOREGROUND",e[e.BACKGROUND=1]="BACKGROUND"})(jf||(jf={}));var th=class{constructor(t){t===void 0&&(t=Ep(null)),console.assert(t.size()<=1),this._sessionGroupSel=t}sessionGroup(){return this._sessionGroupSel.size()===1?this._sessionGroupSel.datum():null}isNull(){return this.sessionGroup()===null}selection(){return this._sessionGroupSel}equalsTo(t){var r,n;return this.isNull()?t.isNull():t.isNull()?!1:((r=t.sessionGroup())==null?void 0:r.name)==((n=this.sessionGroup())==null?void 0:n.name)}},iV=class{constructor(t,r,n){this._svgProps=t,this._schema=r,this._axesCollection=n,this._sessionGroups=[],this._svgProps.svgG.selectAll("g.background").remove(),this._svgProps.svgG.selectAll("g.foreground").remove(),this._bgPathsSel=this._svgProps.svgG.append("g").classed("background",!0).selectAll("path"),this._fgPathsSel=this._svgProps.svgG.append("g").classed("foreground",!0).selectAll("path"),this._updateVisibleFgPathsSel(),this._peakedSessionGroupHandle=new th,this._selectedSessionGroupHandle=new th,this._d3line=vu().curve(Yh)}getSessionGroupHandle(t){return t==null?new th:new th(this._fgPathsSel.filter(r=>r.name===t.name))}hideBackgroundLines(){this._bgPathsSel.attr("visibility","hidden")}showBackgroundLines(){this._bgPathsSel.attr("visibility",null)}peakedSessionGroupHandle(){return this._peakedSessionGroupHandle}selectedSessionGroupHandle(){return this._selectedSessionGroupHandle}recomputeControlPoints(t,r=0){(t===jf.FOREGROUND?this._fgPathsSel:this._bgPathsSel).transition().duration(r).attr("d",i=>this._pathDAttribute(i)),t===jf.FOREGROUND&&window.setTimeout(()=>{let i=this;this._fgPathsSel.each(function(o){i._setControlPointsProperty(this,o)})})}recomputeForegroundLinesVisibility(){this._fgPathsSel.classed("invisible-path",t=>!this._axesCollection.allVisibleAxesSatisfy((r,n)=>n.brushFilter().isPassing(x0(this._schema,t,n.colIndex())))),this._updateVisibleFgPathsSel()}setForegroundLinesColor(t,r,n){let i=this._createLineColorFunction(t,r,n);this._fgPathsSel.attr("stroke",i)}redraw(t,r,n,i){let o=this._peakedSessionGroupHandle.sessionGroup(),a=this._selectedSessionGroupHandle.sessionGroup();this._sessionGroups=t,this._fgPathsSel=this._recomputePathSelection(this._fgPathsSel),this._bgPathsSel=this._recomputePathSelection(this._bgPathsSel),this._peakedSessionGroupHandle=this.getSessionGroupHandle(o),this._selectedSessionGroupHandle=this.getSessionGroupHandle(a),this.recomputeControlPoints(jf.FOREGROUND),this.recomputeControlPoints(jf.BACKGROUND),this.recomputeForegroundLinesVisibility(),this.setForegroundLinesColor(r,n,i)}updatePeakedSessionGroup(t){this._peakedSessionGroupHandle.selection().classed("peaked-path",!1),this._peakedSessionGroupHandle=t,this._peakedSessionGroupHandle.selection().classed("peaked-path",!0)}clearPeakedSessionGroup(){this.updatePeakedSessionGroup(new th)}updateSelectedSessionGroup(t){this._selectedSessionGroupHandle.selection().classed("selected-path",!1),this._selectedSessionGroupHandle=t,this._selectedSessionGroupHandle.selection().classed("selected-path",!0)}findClosestSessionGroup(t,r){let n=this._axesCollection.mapVisibleAxes((o,a)=>o),i=lue(this._visibleFgPathsSel.nodes(),n,[t,r],100);return i===null?new th:new th(Ht(i))}_createLineColorFunction(t,r,n){if(t===null)return()=>"red";let i=zn().domain(fct(this._schema,this._sessionGroups,t)).range([r,n]).interpolate(M_);return o=>i(x0(this._schema,o,t))}_recomputePathSelection(t){return t=t.data(this._sessionGroups,r=>r.name),t.exit().remove(),t.enter().append("path").merge(t)}_setControlPointsProperty(t,r){t.controlPoints=this._computeControlPoints(r)}_computeControlPoints(t){return this._axesCollection.mapVisibleAxes((r,n)=>[r,n.yScale()(x0(this._schema,t,n.colIndex()))])}_pathDAttribute(t){return this._d3line(this._computeControlPoints(t))}_updateVisibleFgPathsSel(){this._visibleFgPathsSel=this._fgPathsSel.filter(":not(.invisible-path)")}};var oV=class{constructor(t,r){this.svg=Ht(t);let n={top:30,right:10,bottom:10,left:10},i=100,o=200,a=r*i+n.left+n.right,s=o+n.top+n.bottom;this.svg.attr("viewBox",`0 0 ${a} ${s}`),this.svg.attr("preserveAspectRatio","xMidYMid"),this.svg.style("min-width",a+"px"),this.svg.style("min-height",s+"px"),this.width=a-n.left-n.right,this.height=s-n.top-n.bottom,this.svgG=this.svg.append("g").attr("transform",_P(n.left,n.top))}},aV=class{constructor(t,r,n,i){this._svgProps=t,this._schema=r,this._peakedSessionGroupChangedCB=n,this._selectedSessionGroupChangedCB=i,this._axesCollection=new nV(t,r,this),this._linesCollection=new iV(t,r,this._axesCollection),this._svgProps.svg.on("click",()=>this.onClick()).on("mousemove mouseenter",()=>{let[o,a]=zo(this._svgProps.svgG.node());this.onMouseMoved(o,a)}).on("mouseleave",()=>this.onMouseLeave())}onDragStart(t){this._axesCollection.dragStart(t),this._linesCollection.hideBackgroundLines()}onDrag(t){this._axesCollection.drag(t),this._linesCollection.recomputeControlPoints(jf.FOREGROUND)}onDragEnd(){this._axesCollection.dragEnd(500),this._linesCollection.recomputeControlPoints(jf.FOREGROUND,500),window.setTimeout(()=>{this._linesCollection.recomputeControlPoints(jf.BACKGROUND),this._linesCollection.showBackgroundLines()},500)}onBrushChanged(t,r){this._axesCollection.getAxisForColIndex(t).setBrushSelection(r),this._linesCollection.recomputeForegroundLinesVisibility()}onMouseMoved(t,r){this._linesCollection.updatePeakedSessionGroup(this._linesCollection.findClosestSessionGroup(t,r)),this._peakedSessionGroupChangedCB(this._linesCollection.peakedSessionGroupHandle().sessionGroup())}onMouseLeave(){this._linesCollection.peakedSessionGroupHandle().isNull()||(this._linesCollection.clearPeakedSessionGroup(),this._peakedSessionGroupChangedCB(null))}onClick(){this._linesCollection.peakedSessionGroupHandle().sessionGroup()===this._linesCollection.selectedSessionGroupHandle().sessionGroup()?this._linesCollection.updateSelectedSessionGroup(new th):this._linesCollection.updateSelectedSessionGroup(this._linesCollection.peakedSessionGroupHandle()),this._selectedSessionGroupChangedCB(this._linesCollection.selectedSessionGroupHandle().sessionGroup())}onOptionsOrSessionGroupsChanged(t,r){this._axesCollection.updateAxes(t,r);let n=this._linesCollection.peakedSessionGroupHandle(),i=this._linesCollection.selectedSessionGroupHandle();this._linesCollection.redraw(r,t.colorByColumnIndex!==void 0?t.columns[t.colorByColumnIndex].absoluteIndex:null,t.minColor,t.maxColor),n.equalsTo(this._linesCollection.peakedSessionGroupHandle())||this._peakedSessionGroupChangedCB(this._linesCollection.peakedSessionGroupHandle().sessionGroup()),i.equalsTo(this._linesCollection.selectedSessionGroupHandle())||this._selectedSessionGroupChangedCB(this._linesCollection.selectedSessionGroupHandle().sessionGroup())}schema(){return this._schema}};var eh=class extends Gt(_o(mt)){constructor(){super(...arguments),this.selectedSessionGroup=null,this.closestSessionGroup=null,this.redrawCount=0}_optionsOrSessionGroupsChanged(){var n;if(!this.options)return;let{configuration:t}=(n=this._prevOptions)!=null?n:{},{configuration:r}=this.options;if(this._interactionManager===void 0||!qct.isEqual(t==null?void 0:t.schema,r.schema)||!qct.isEqual(t==null?void 0:t.columnsVisibility,r.columnsVisibility)){Ht(this.$.svg).selectAll("*").remove();let i=new oV(this.$.svg,r.columnsVisibility.filter(Boolean).length);this.scopeSubtree(this.$.svg,!0),this._interactionManager=new aV(i,r.schema,o=>this.closestSessionGroupChanged(o),o=>this.selectedSessionGroupChanged(o))}this._computeValidSessionGroups(),this._interactionManager.onOptionsOrSessionGroupsChanged(this.options,this._validSessionGroups),this.redrawCount++,this._prevOptions=this.options}closestSessionGroupChanged(t){this.closestSessionGroup=t}selectedSessionGroupChanged(t){this.selectedSessionGroup=t}_computeValidSessionGroups(){let t=cs;if(this.sessionGroups===void 0){this._validSessionGroups=void 0;return}let r=this.options.configuration.schema;this._validSessionGroups=this.sessionGroups.filter(n=>{for(let i=0;i<t.numColumns(r);++i)if(!!this.options.configuration.columnsVisibility[i]&&t.columnValueByIndex(r,n,i)===void 0)return!1;return!0})}};eh.template=Q`
    <div id="container">
      <svg id="svg"></svg>
    </div>
    <style>
      :host {
        display: block;
        --tf-hparams-parallel-coords-plot-axis-shadow: 0 1px 0 #fff,
          1px 0 0 #fff, 0 -1px 0 #fff, -1px 0 0 #fff;
      }
      :host(.dark-mode) {
        --tf-hparams-parallel-coords-plot-axis-shadow: 0 1px 0 #000,
          1px 0 0 #000, 0 -1px 0 #000, -1px 0 0 #000;
      }
      svg {
        font: 10px sans-serif;
      }

      .background path {
        fill: none;
        stroke: #ddd;
        shape-rendering: crispEdges;
      }

      .foreground path {
        fill: none;
        stroke-opacity: 0.7;
        stroke-width: 1;
      }

      /* Will be set on foreground paths that are not "contained" in the current
         axes brushes. If no brushes are set, no path will have this class. */
      .foreground .invisible-path {
        display: none;
      }

      /* Style for the path closest to the mouse pointer (typically will become
      the selected path when the user clicks). */
      .foreground .peaked-path {
        stroke-width: 3;
      }

      /* The currently selected path class. We use !important to override the
         inline style that sets the regular color of a path. */
      .foreground .selected-path {
        stroke-width: 3 !important;
        stroke: #0f0 !important;
      }

      #container {
        height: 100%;
        width: 100%;
      }

      svg {
        width: 100%;
        height: 100%;
      }

      .axis text {
        text-shadow: var(--tf-hparams-parallel-coords-plot-axis-shadow);
        fill: currentColor;
        cursor: move;
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],eh.prototype,"sessionGroups",void 0);E([A({type:Object}),w("design:type",Object)],eh.prototype,"options",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],eh.prototype,"selectedSessionGroup",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],eh.prototype,"closestSessionGroup",void 0);E([A({type:Number}),w("design:type",Number)],eh.prototype,"redrawCount",void 0);E([A({type:Array}),w("design:type",Object)],eh.prototype,"_validSessionGroups",void 0);E([A({type:Object}),w("design:type",Object)],eh.prototype,"_interactionManager",void 0);E([Bt("options.*","sessionGroups.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],eh.prototype,"_optionsOrSessionGroupsChanged",null);eh=E([yt("tf-hparams-parallel-coords-plot")],eh);var A0=class extends mt{constructor(){super(...arguments),this.options=null}_configurationChanged(){let t=this.configuration.visibleSchema,r=this.configuration.schema,n=(a,s)=>({name:Fd(a),index:s,absoluteIndex:OH(r,t,s),scale:this._isNumericColumn(s)?"LINEAR":"NON_NUMERIC"}),i=(a,s)=>{let l=s+t.hparamInfos.length;return{scale:"LINEAR",name:Qu(a),index:l,absoluteIndex:OH(r,t,l)}},o={columns:t.hparamInfos.map(n).concat(t.metricInfos.map(i)),minColor:"#0000FF",maxColor:"#FF0000",configuration:this.configuration};this.set("options",o),ui(),this.set("options.colorByColumnIndex",this._defaultColorByColumnIndex())}_unselectDisabledLogScales(){this.options!==null&&this.options.columns.forEach(t=>{let r="options.columns."+t.index;!this._allowLogScale(t)&&t.scale==="LOG"&&this.set(r+".scale","LINEAR")})}_allowLogScale(t){if(!this._isNumericColumn(t.index)||!this.sessionGroups)return!1;let[r,n]=gP(this.configuration.visibleSchema,this.sessionGroups,t.index);return r>0||n<0}_isNumericColumn(t){return t>=this.configuration.visibleSchema.hparamInfos.length||this.configuration.visibleSchema.hparamInfos[t].type==="DATA_TYPE_FLOAT64"}_defaultColorByColumnIndex(){if(this.configuration.visibleSchema.metricInfos.length>0)return this.configuration.visibleSchema.hparamInfos.length;let t=this.configuration.visibleSchema.hparamInfos.findIndex(r=>r.type==="DATA_TYPE_FLOAT64");if(t!==-1)return t}};A0.template=Q`
    <div class="control-panel">
      <!-- 'Color by' drop down menu -->
      <paper-dropdown-menu
        label="Color by"
        id="colorByDropDownMenu"
        horizontal-align="left"
      >
        <paper-listbox
          class="dropdown-content"
          slot="dropdown-content"
          selected="{{options.colorByColumnIndex}}"
          id="colorByListBox"
        >
          <template
            is="dom-repeat"
            items="[[options.columns]]"
            as="column"
            id="colorByColumnTemplate"
          >
            <paper-item disabled="[[!_isNumericColumn(column.index)]]">
              [[column.name]]
            </paper-item>
          </template>
        </paper-listbox>
      </paper-dropdown-menu>

      <!-- Columns scales -->
      <div class="columns-container">
        <!-- Scale options for each numeric feature -->
        <template is="dom-repeat" items="{{options.columns}}" as="column">
          <template is="dom-if" if="[[_isNumericColumn(column.index)]]">
            <div class="column">
              <div class="column-title">[[column.name]]</div>
              <div>
                <paper-radio-group
                  class="scale-radio-group"
                  selected="{{column.scale}}"
                >
                  <paper-radio-button name="LINEAR">
                    Linear
                  </paper-radio-button>
                  <!-- The id here is used to access this button in unit
                       tests.-->
                  <paper-radio-button
                    id="logScaleButton_[[column.name]]"
                    name="LOG"
                    disabled="[[!_allowLogScale(column, sessionGroups.*)]]"
                  >
                    Logarithmic
                  </paper-radio-button>
                  <paper-radio-button name="QUANTILE">
                    Quantile
                  </paper-radio-button>
                </paper-radio-group>
              </div>
            </div>
          </template>
        </template>
      </div>
    </div>

    <style>
      :host {
        display: block;
      }
      .control-panel {
        overflow: auto;
      }
      .column {
        flex-grow: 1;
        flex-shrink: 1;
        margin-right: 5px;
        border: solid 1px darkgray;
        padding: 3px;
      }
      .column-title {
        /* Fit every title in one line so the radio boxes align vertically. */
        white-space: nowrap;
        text-decoration: underline;
      }
      .columns-container {
        display: flex;
        flex-direction: row;
      }
      .scale-radio-group paper-radio-button {
        padding: 2px;
        display: block;
      }
      paper-listbox {
        max-height: 15em;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],A0.prototype,"configuration",void 0);E([A({type:Array}),w("design:type",Array)],A0.prototype,"sessionGroups",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],A0.prototype,"options",void 0);E([Bt("configuration.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],A0.prototype,"_configurationChanged",null);E([Bt("sessionGroups.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],A0.prototype,"_unselectDisabledLogScales",null);A0=E([yt("tf-hparams-scale-and-color-controls")],A0);var hv=class extends mt{_closestOrSelected(t,r){return t!==null?t:r}};hv.template=Q`
    <!-- Controls behavior of parallel coordinates plot
         outputs set options to the _options property.
      -->
    <hparams-split-layout orientation="vertical">
      <!-- The scale and color controls. -->
      <tf-hparams-scale-and-color-controls
        id="controls"
        slot="content"
        class="section"
        configuration="[[configuration]]"
        session-groups="[[sessionGroups]]"
        options="{{_options}}"
      >
      </tf-hparams-scale-and-color-controls>
      <!-- The actual parallel coordinates plot -->
      <tf-hparams-parallel-coords-plot
        id="plot"
        slot="content"
        class="section"
        session-groups="[[sessionGroups]]"
        selected-session-group="{{_selectedGroup}}"
        closest-session-group="{{_closestGroup}}"
        options="[[_options]]"
      >
      </tf-hparams-parallel-coords-plot>
      <tf-hparams-session-group-values
        id="values"
        slot="content"
        class="section"
        visible-schema="[[configuration.visibleSchema]]"
        session-group="[[_closestOrSelected(
                             _closestGroup, _selectedGroup)]]"
      >
      </tf-hparams-session-group-values>
      <tf-hparams-session-group-details
        id="details"
        slot="content"
        class="section"
        backend="[[backend]]"
        experiment-name="[[experimentName]]"
        session-group="[[_selectedGroup]]"
        visible-schema="[[configuration.visibleSchema]]"
      >
      </tf-hparams-session-group-details>
    </hparams-split-layout>

    <style>
      .section {
        padding: 10px;
      }
      #values {
        height: 115px;
      }
      #details {
        flex-grow: 1;
        max-height: fit-content;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],hv.prototype,"backend",void 0);E([A({type:String}),w("design:type",String)],hv.prototype,"experimentName",void 0);E([A({type:Object}),w("design:type",Object)],hv.prototype,"configuration",void 0);E([A({type:Array}),w("design:type",Array)],hv.prototype,"sessionGroups",void 0);hv=E([yt("tf-hparams-parallel-coords-view")],hv);var y3=Ee(Oe(),1);var $o=class extends Gt(mt){constructor(){super(...arguments),this.selectedSessionGroup=null,this.closestSessionGroup=null,this._container=null,this._svg=null,this.width=0,this.height=0,this._brushedCellIndex=null,this._brushSelection=null}ready(){super.ready(),this._container=this.$.container,this._svg=Ht(this.$.svg),this._redraw()}_sessionGroupsChanged(){this.selectedSessionGroup!==null&&(this.selectedSessionGroup=pct(this.sessionGroups,this.selectedSessionGroup.name)||null),this._redraw()}_visibleSchemaChanged(){this._brushedCellIndex=null,this._brushSelection=null,this._redraw()}_redraw(){this.debounce("_redraw",()=>{let t=cs,r=1200,n=.4*r,i=150,o=.75*i;this.width=Math.max(i*t.numVisibleColumns(this.visibleSchema),r),this.height=Math.max(o*t.numVisibleMetrics(this.visibleSchema),n),this._container.style.width=this.width+"px",this._container.style.height=this.height+"px",this._svg.attr("width",this.width).attr("height",this.height),this._svg.selectAll("g").remove(),this._draw()},100)}_draw(){let t=cs,r=this;if(!this.sessionGroups||this.sessionGroups.length==0||!this.visibleSchema||this.visibleSchema.metricInfos.length==0)return;let n=Ir(t.numVisibleColumns(r.visibleSchema)),i=Ir(t.numVisibleMetrics(r.visibleSchema)),o=80,a=50,s=5,l=Qm().domain(n).range([o+s,this.width-1-s]).paddingInner(.1),c=Qm().domain(i).range([this.height-1-s-a,s]).paddingInner(.1),u=l.bandwidth(),h=c.bandwidth(),f=n.map(ct=>r._cellScale(ct,[0,u-1])),p=i.map(ct=>r._cellScale(ct+t.numVisibleHParams(r.visibleSchema),[h-1,0])),d=this._svg.selectAll(".x-axis").data(n).enter().append("g").classed("x-axis",!0).attr("transform",ct=>t.translateStr(l(ct),0));function g(ct){return"x-axis-clip-path-"+ct}function _(ct){return"x-label-clip-path-"+ct}d.append("clipPath").attr("id",g).append("rect").attr("x",-s).attr("y",0).attr("width",u+2*s).attr("height",r.height-a/2),d.append("clipPath").attr("id",_).append("rect").attr("x",0).attr("y",r.height-a/2).attr("width",u).attr("height",a/2),d.append("g").attr("clip-path",ct=>"url(#"+g(ct)+")").each(function(ct){Ht(this).call(S,K9(f[ct]).tickSize(r.height-a),u,40,r.options.columns[ct].scale)}),d.append("g").classed("x-axis-label",!0).attr("clip-path",ct=>"url(#"+_(ct)+")").append("text").attr("text-anchor","middle").attr("x",u/2).attr("y",r.height-1-a/4).text(ct=>t.schemaVisibleColumnName(r.visibleSchema,ct)).append("title").text(ct=>t.schemaVisibleColumnName(r.visibleSchema,ct));let y=this._svg.selectAll(".y-axis").data(i).enter().append("g").classed("y-axis",!0).attr("transform",ct=>t.translateStr(r.width-1,c(ct)));function x(ct){return"y-axis-clip-path-"+ct}function b(ct){return"y-label-clip-path-"+ct}y.append("clipPath").attr("id",x).append("rect").attr("x",-(r.width-o/2-1)).attr("y",-s).attr("width",r.width-o/2).attr("height",h+2*s),y.append("clipPath").attr("id",b).append("rect").attr("x",-(r.width-1)).attr("y",0).attr("width",o/2).attr("height",h),y.append("g").attr("clip-path",ct=>"url(#"+x(ct)+")").each(function(ct){Ht(this).call(S,lb(p[ct]).tickSize(r.width-o),h,20,r.options.columns[ct+t.numVisibleHParams(r.visibleSchema)].scale)}),y.append("g").classed("y-axis-label",!0).attr("clip-path",ct=>"url(#"+b(ct)+")").append("text").attr("text-anchor","middle").attr("x",-(r.width-o/4-1)).attr("y",h/2).attr("transform",t.rotateStr(90,-(r.width-o/4-1),h/2)).text(ct=>t.metricName(r.visibleSchema.metricInfos[ct])).append("title").text(ct=>t.metricName(r.visibleSchema.metricInfos[ct]));function S(ct,X,et,dt,q){let pt=Math.floor(et/dt),ht=X.scale();if(q==="QUANTILE"){let wt=ht.quantiles(),kt=Math.ceil(wt.length/pt);wt=Ir(0,wt.length,kt).map(ie=>wt[ie]),X.tickValues(wt).tickFormat(xn("-.2g"))}(q==="LINEAR"||q==="LOG")&&X.ticks(pt),ct.call(X),ct.selectAll(".domain").remove(),ct.selectAll(".tick line").attr("stroke","#ddd")}let C=this._svg.selectAll(".cell").data(U9(n,i)).enter().append("g").classed("cell",!0).attr("transform",([ct,X])=>t.translateStr(l(ct),c(X))),P=C.append("g").classed("frame",!0).append("rect").attr("x",-s).attr("y",-s).attr("width",u+2*s).attr("height",h+2*s).attr("stroke","#000").attr("fill","none").attr("shape-rendering","crispEdges"),k=null;r.options.colorByColumnIndex!==void 0&&(k=zn().domain(this._colExtent(this.options.colorByColumnIndex)).range([this.options.minColor,this.options.maxColor]).interpolate(M_));let O=r.options.colorByColumnIndex===void 0?()=>"red":({sessionGroup:ct})=>k(this._colValue(ct,r.options.colorByColumnIndex));function D(ct,X){return f[X](r._colValue(ct,X))}function B(ct,X){return p[X](r._metricValue(ct,X))}function I(ct,X){let et=ct.selectAll(".data-marker").data(([pt,ht])=>r.sessionGroups.filter(wt=>r._colValue(wt,pt)!==void 0&&r._metricValue(wt,ht)!==void 0).map(wt=>({col:pt,metric:ht,sessionGroup:wt,x:D(wt,pt),y:B(wt,ht),sessionGroupMarkers:null}))).enter().append("circle").classed("data-marker",!0).attr("cx",({x:pt})=>pt).attr("cy",({y:pt})=>pt).attr("r",2).attr("fill",X),dt=new Map;r.sessionGroups.forEach(pt=>{dt.set(pt,[])}),et.each(function(pt){var ht;(ht=dt.get(pt.sessionGroup))==null||ht.push(this)}),et.each(pt=>{let ht=dt.get(pt.sessionGroup);pt.sessionGroupMarkers=new Set(ht)});let q=n.map(pt=>i.map(ht=>et.filter(wt=>wt.col==pt&&wt.metric==ht)));return[et,q,dt]}let[L,R,F]=I(C.append("g"),O);function z(ct,X){let et=[];return R[ct][X].each(function(){et.push(this)}),zh().x(dt=>Ht(dt).datum().x).y(dt=>Ht(dt).datum().y).addAll(et)}let U=n.map(ct=>i.map(X=>z(ct,X))),W=null;bt()&&(W=C.filter(ct=>y3.isEqual(ct,r._brushedCellIndex)),console.assert(W.size()==1,W));let Z=new Set(L.nodes());rt();function rt(){let ct=new Set(L.nodes());Mt()||(ct=ot(r._brushedCellIndex,r._brushSelection)),Ep(Array.from(t.filterSet(ct,X=>!Z.has(X)))).attr("fill",O),Ep(Array.from(t.filterSet(Z,X=>!ct.has(X)))).attr("fill","#ddd"),Z=ct}function ot(ct,X){console.assert(ct!==null),console.assert(X!==null);let[et,dt]=ct,q=new Set;return t.quadTreeVisitPointsInRect(U[et][dt],X[0][0],X[0][1],X[1][0],X[1][1],pt=>{Ht(pt).datum().sessionGroupMarkers.forEach(wt=>{q.add(wt)})}),q}let st=qL().extent([[-s+1,-s+1],[u-1+s-1,h-1+s-1]]).on("start",function(){bt()&&W.node()!=this&&st.move(W,null),St(this)}).on("brush",function(){St(this)}).on("end",function(){St(this)});function St(ct){let X=VL(ct);!bt()&&X===null||bt()&&ct===W.node()&&y3.isEqual(X,r._brushSelection)||(r._brushSelection=X,X!==null?(W=Ht(ct),r._brushedCellIndex=W.datum()):(W=null,r._brushedCellIndex=null),rt())}function bt(){return r._brushedCellIndex!==null&&r._brushSelection!==null}function Mt(){return!bt()||r._brushSelection[0][0]===r._brushSelection[1][0]||r._brushSelection[0][1]===r._brushSelection[1][1]}C.call(st),bt()&&st.move(W,r._brushSelection);let lt=null,Kt=null;this.selectedSessionGroup!==null&&(Kt=Ep(F.get(this.selectedSessionGroup)).classed("selected-marker",!0)),C.on("click",function(){let ct=lt===Kt?null:lt;if(ct===Kt)return;Kt!==null&&Kt.classed("selected-marker",!1),Kt=ct,Kt!==null&&Kt.classed("selected-marker",!0);let X=Kt===null?null:Kt.datum().sessionGroup;r.selectedSessionGroup=X}).on("mousemove mouseenter",function([ct,X]){let[et,dt]=zo(this),q=_t(ct,X,et,dt,20);lt!==q&&(lt!==null&&lt.classed("closest-marker",!1),lt=q,lt!==null?(lt.classed("closest-marker",!0),r.closestSessionGroup=lt.datum().sessionGroup):r.closestSessionGroup=null)}).on("mouseleave",function([ct,X]){lt!==null&&(lt.classed("closest-marker",!1),lt=null,r.closestSessionGroup=null)});function _t(ct,X,et,dt,q){let pt=1/0,ht=null;return t.quadTreeVisitPointsInDisk(U[ct][X],et,dt,q,(wt,kt)=>{if(Z.has(wt)&&kt<pt){let ie=Ht(wt).datum();pt=kt,ht=ie.sessionGroup}}),ht===null?null:Ep(F.get(ht))}this._svg.selectAll("*").classed("tf-hparams-scatter-plot-matrix-plot",!0)}_cellScale(t,r){let n=this._colExtent(t),i=zn().domain(n).range(r);if(this.options.columns[t].scale==="LINEAR")return i;if(this.options.columns[t].scale==="LOG")return n[0]<=0&&n[1]>=0?i:cc().domain(n).range(r);if(this.options.columns[t].scale==="QUANTILE"){let o=(r[1]-r[0])/19,a=Ir(20).map(s=>r[0]+o*s);return eg().domain(y3.uniq(this.sessionGroups.map(s=>this._colValue(s,t)))).range(a)}else{if(this.options.columns[t].scale==="NON_NUMERIC")return tg().domain(y3.uniq(this.sessionGroups.map(o=>this._colValue(o,t)).sort())).range(r).padding(.1);throw"Unknown scale for column: "+t+". options: "+this.options}}_colValue(t,r){return FH(this.visibleSchema,t,r)}_metricValue(t,r){return zH(this.visibleSchema,t,r)}_colExtent(t){return gP(this.visibleSchema,this.sessionGroups,t)}};$o.template=Q`
    <div id="container">
      <svg id="svg"></svg>
    </div>

    <style>
      :host {
        display: block;
      }
      svg {
        font: 10px sans-serif;
      }

      text {
        fill: currentColor;
      }

      .frame rect {
        stroke: currentColor;
      }

      /* The closest data point marker to the mouse pointer. We use !important
         to override the inline style that sets the regular style of a marker.
      */
      .closest-marker {
        r: 6 !important;
      }

      /* The currently selected data point marker. We use !important to
         override the inline style that sets the regular style of a marker. */
      .selected-marker {
        r: 6 !important;
        fill: #0f0 !important;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],$o.prototype,"visibleSchema",void 0);E([A({type:Array}),w("design:type",Array)],$o.prototype,"sessionGroups",void 0);E([A({type:Object}),w("design:type",Object)],$o.prototype,"options",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],$o.prototype,"selectedSessionGroup",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],$o.prototype,"closestSessionGroup",void 0);E([A({type:Object}),w("design:type",HTMLElement)],$o.prototype,"_container",void 0);E([A({type:Object}),w("design:type",Object)],$o.prototype,"_svg",void 0);E([A({type:Number}),w("design:type",Number)],$o.prototype,"width",void 0);E([A({type:Number}),w("design:type",Number)],$o.prototype,"height",void 0);E([A({type:Object}),w("design:type",Object)],$o.prototype,"_brushedCellIndex",void 0);E([A({type:Object}),w("design:type",Object)],$o.prototype,"_brushSelection",void 0);E([Bt("sessionGroups.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],$o.prototype,"_sessionGroupsChanged",null);E([Bt("visibleSchema.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],$o.prototype,"_visibleSchemaChanged",null);E([Bt("options.*"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],$o.prototype,"_redraw",null);$o=E([yt("tf-hparams-scatter-plot-matrix-plot")],$o);var fv=class extends mt{_closestOrSelected(t,r){return t!==null?t:r}};fv.template=Q`
    <hparams-split-layout orientation="vertical">
      <!-- Controls behavior of the scatter plot matrix
             outputs the configured options to the _options property. -->
      <tf-hparams-scale-and-color-controls
        slot="content"
        class="section"
        id="controls"
        configuration="[[configuration]]"
        session-groups="[[sessionGroups]]"
        options="{{_options}}"
      >
      </tf-hparams-scale-and-color-controls>
      <!-- The actual scatter plot matrix -->
      <tf-hparams-scatter-plot-matrix-plot
        slot="content"
        class="section"
        id="plot"
        visible-schema="[[configuration.visibleSchema]]"
        session-groups="[[sessionGroups]]"
        selected-session-group="{{_selectedGroup}}"
        closest-session-group="{{_closestGroup}}"
        options="[[_options]]"
      >
      </tf-hparams-scatter-plot-matrix-plot>
      <tf-hparams-session-group-values
        slot="content"
        class="section"
        id="values"
        visible-schema="[[configuration.visibleSchema]]"
        session-group="[[_closestOrSelected(
                                 _closestGroup, _selectedGroup)]]"
      >
      </tf-hparams-session-group-values>
      <!-- Shows session group details for the clicked marker. -->
      <tf-hparams-session-group-details
        slot="content"
        class="section"
        id="details"
        backend="[[backend]]"
        experiment-name="[[experimentName]]"
        session-group="[[_selectedGroup]]"
        visible-schema="[[configuration.visibleSchema]]"
      >
      </tf-hparams-session-group-details>
    </hparams-split-layout>
    <style>
      .section {
        padding: 10px;
      }
      #controls {
        flex-grow: 0;
        flex-shrink: 0;
        flex-basis: auto;
        height: auto;
        overflow-y: auto;
        max-height: fit-content;
      }
      #plot {
        flex-grow: 1;
        flex-shrink: 1;
        flex-basis: auto;
        height: auto;
        overflow-y: auto;
        max-height: fit-content;
      }
      #values {
        flex-grow: 0;
        flex-shrink: 0;
        flex-basis: auto;
        height: 115px;
        overflow-y: auto;
        max-height: fit-content;
      }
      #details {
        flex-grow: 0;
        flex-shrink: 1;
        flex-basis: auto;
        height: auto;
        overflow-y: auto;
        max-height: fit-content;
      }
      vaadin-split-layout {
        height: 100%;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],fv.prototype,"backend",void 0);E([A({type:String}),w("design:type",String)],fv.prototype,"experimentName",void 0);E([A({type:Object}),w("design:type",Object)],fv.prototype,"configuration",void 0);E([A({type:Array}),w("design:type",Array)],fv.prototype,"sessionGroups",void 0);fv=E([yt("tf-hparams-scatter-plot-matrix-view")],fv);var Xf=class extends mt{constructor(){super(...arguments),this._selectedTab=0}};Xf.template=Q`
    <paper-header-panel>
      <paper-toolbar slot="header" class="tab-bar">
        <paper-tabs selected="{{_selectedTab}}" slot="top">
          <!-- view-id can be used by integration tests to locate a tab.
               It should be the name of the root element implementing the view
               without the 'tf-hparams-' prefix. -->
          <paper-tab view-id="table-view"> TABLE VIEW </paper-tab>
          <paper-tab view-id="parallel-coords-view">
            PARALLEL COORDINATES VIEW
          </paper-tab>
          <paper-tab view-id="scatter-plot-matrix-view">
            SCATTER PLOT MATRIX VIEW
          </paper-tab>
          <div class="help-and-feedback">
            <template is="dom-if" if="[[bugReportUrl]]">
              <a
                href$="[[bugReportUrl]]"
                target="_blank"
                rel="noopener noreferrer"
              >
                <paper-button
                  id="bug-report"
                  raised
                  title="Send a bug report or feature request"
                >
                  Bug Report / Feature Request
                </paper-button>
              </a>
            </template>
            <template is="dom-if" if="[[helpUrl]]">
              <a href$="[[helpUrl]]" target="_blank" rel="noopener noreferrer">
                <paper-icon-button
                  icon="help-outline"
                  title="View documentation"
                >
                </paper-icon-button>
              </a>
            </template>
          </div>
        </paper-tabs>
      </paper-toolbar>
      <iron-pages selected="[[_selectedTab]]" class="fit tab-view">
        <div id="0" class="tab">
          <tf-hparams-table-view
            backend="[[backend]]"
            experiment-name="[[experimentName]]"
            visible-schema="[[configuration.visibleSchema]]"
            session-groups="[[sessionGroups]]"
            enable-show-metrics
          >
          </tf-hparams-table-view>
        </div>
        <div id="1" class="tab">
          <tf-hparams-parallel-coords-view
            backend="[[backend]]"
            experiment-name="[[experimentName]]"
            configuration="[[configuration]]"
            session-groups="[[sessionGroups]]"
          >
          </tf-hparams-parallel-coords-view>
        </div>
        <div id="2" class="tab">
          <tf-hparams-scatter-plot-matrix-view
            backend="[[backend]]"
            experiment-name="[[experimentName]]"
            configuration="[[configuration]]"
            session-groups="[[sessionGroups]]"
          >
          </tf-hparams-scatter-plot-matrix-view>
        </div>
      </iron-pages>
    </paper-header-panel>

    <style>
      .tab-view {
        height: 100%;
      }
      .tab-bar {
        overflow-y: auto;
        color: white;
        background-color: var(
          --tb-toolbar-background-color,
          var(--tb-orange-strong)
        );
      }
      .tab {
        height: 100%;
      }
      paper-tabs {
        flex-grow: 1;
        width: 100%;
        height: 100%;
        --paper-tabs-selection-bar-color: white;
        --paper-tabs-content: {
          -webkit-font-smoothing: antialiased;
        }
      }
      tf-hparams-table-view {
        width: 100%;
        height: 100%;
      }
      .help-and-feedback {
        display: inline-flex; /* Ensure that icons stay aligned */
        justify-content: flex-end;
        align-items: center;
        text-align: right;
        color: white;
      }
      #bug-report {
        border: solid black;
        background: red;
        white-space: normal;
        word-break: break-words;
        font-size: 12px;
        max-width: 150px;
        text-align: left;
      }
      .help-and-feedback a {
        color: white;
        text-decoration: none;
      }
    </style>
  `;E([A({type:Object}),w("design:type",Object)],Xf.prototype,"backend",void 0);E([A({type:String}),w("design:type",String)],Xf.prototype,"helpUrl",void 0);E([A({type:String}),w("design:type",String)],Xf.prototype,"bugReportUrl",void 0);E([A({type:String}),w("design:type",String)],Xf.prototype,"experimentName",void 0);E([A({type:Object}),w("design:type",Object)],Xf.prototype,"configuration",void 0);E([A({type:Array}),w("design:type",Array)],Xf.prototype,"sessionGroups",void 0);E([A({type:Number}),w("design:type",Number)],Xf.prototype,"_selectedTab",void 0);Xf=E([yt("tf-hparams-sessions-pane")],Xf);var rh=class extends Gt(mt){reload(){this.$["query-pane"].reload()}};rh.template=Q`
    <hparams-split-layout>
      <div slot="content" class="sidebar">
        <tf-hparams-query-pane
          id="query-pane"
          backend="[[backend]]"
          experiment-name="[[experimentName]]"
          configuration="{{_configuration}}"
          session-groups="{{_sessionGroups}}"
          data-loaded-with-non-empty-hparams="{{_dataLoadedWithNonEmptyHparams}}"
          data-loaded-with-empty-hparams="{{_dataLoadedWithEmptyHparams}}"
        >
        </tf-hparams-query-pane>
      </div>
      <div slot="content" class="center">
        <template is="dom-if" if="[[_dataLoadedWithEmptyHparams]]">
          <div class="no-data-warning">
            <h3>No hparams data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any hparams data to your event files.</li>
              <li>
                Event files are still being loaded (try reloading this page).
              </li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>

        <template is="dom-if" if="[[_dataLoadedWithNonEmptyHparams]]">
          <tf-hparams-sessions-pane
            id="sessions-pane"
            backend="[[backend]]"
            help-url="[[helpUrl]]"
            bug-report-url="[[bugReportUrl]]"
            experiment-name="[[experimentName]]"
            configuration="[[_configuration]]"
            session-groups="[[_sessionGroups]]"
          >
          </tf-hparams-sessions-pane>
        </template>
      </div>
    </hparams-split-layout>
    <style>
      hparams-split-layout {
        width: 100%;
      }

      .sidebar {
        width: 20%;
        height: 100%;
        overflow: auto;
        flex-grow: 0;
        flex-shrink: 0;
        min-width: 10%;
      }

      .center {
        height: 100%;
        overflow-y: auto;
        flex-grow: 1;
        flex-shrink: 1;
        width: 80%;
      }

      :host {
        display: flex;
        flex-direction: row;
        height: 100%;
        width: 100%;
      }

      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }

      a {
        color: var(--tb-link);
      }

      a:visited {
        color: var(--tb-link-visited);
      }
    </style>
  `;E([A({type:Object}),w("design:type",u3)],rh.prototype,"backend",void 0);E([A({type:String}),w("design:type",String)],rh.prototype,"experimentName",void 0);E([A({type:String}),w("design:type",String)],rh.prototype,"helpUrl",void 0);E([A({type:String}),w("design:type",String)],rh.prototype,"bugReportUrl",void 0);E([A({type:Object}),w("design:type",Object)],rh.prototype,"_configuration",void 0);E([A({type:Array}),w("design:type",Array)],rh.prototype,"_sessionGroups",void 0);E([A({type:Boolean}),w("design:type",Boolean)],rh.prototype,"_dataLoadedWithNonEmptyHparams",void 0);E([A({type:Boolean}),w("design:type",Boolean)],rh.prototype,"_dataLoadedWithEmptyHparams",void 0);rh=E([yt("tf-hparams-main")],rh);var shr=new URLSearchParams(window.location.search).get("tensorboardColab")==="true",lhr="hparams",sV=class extends Gt(mt){constructor(){super(...arguments),this._backend=new u3(ve().pluginRoute(lhr,""),new Ae,shr)}reload(){this.$["hparams-main"].reload()}};sV.template=Q`
    <!-- TensorBoard does not specify an experimentName. Currently it only
         supports one experiment per invocation. -->
    <tf-hparams-main
      id="hparams-main"
      backend="[[_backend]]"
      experiment-name=""
    >
    </tf-hparams-main>
  `;E([A({type:Object}),w("design:type",Object)],sV.prototype,"_backend",void 0);sV=E([yt("tf-hparams-dashboard")],sV);var pv=Ee(Oe(),1);var _n=class extends Gt(mt){constructor(){super(...arguments),this.actualSize=!1,this.brightnessAdjustment=.5,this.contrastPercentage=0,this._metadataCanceller=new an,this._imageCanceller=new an,this._steps=[],this._isImageLoading=!1}get _runColor(){var t=this.run;return fn(t)}get _hasAtLeastOneStep(){var t=this._steps;return!!t&&t.length>0}get _hasMultipleSteps(){var t=this._steps;return!!t&&t.length>1}get _currentStep(){var t=this._steps,r=this._stepIndex;return t[r]||null}get _stepValue(){var t=this._currentStep;return t?t.step:0}get _currentWallTime(){var t=this._currentStep;return t?s2(t.wall_time):""}get _maxStepIndex(){var t=this._steps;return t.length-1}get _sampleText(){var t=this.sample;return`${t+1}`}get _hasMultipleSamples(){var t=this.ofSamples;return t>1}_getAriaExpanded(){return this.actualSize?"true":"false"}attached(){this.reload()}reload(){if(!this.isAttached)return;this._metadataCanceller.cancelAll();let t=ve(),r=Cn(t.pluginRoute("images","/images"),{tag:this.tag,run:this.run,sample:this.sample}),n=this._metadataCanceller.cancellable(i=>{if(i.cancelled)return;let a=i.value.map(this._createStepDatum.bind(this));this.set("_steps",a),this.set("_stepIndex",a.length-1)});this.requestManager.request(r).then(n)}_createStepDatum(t){let r=ve().pluginRoute("images","/individualImage");return r=Cn(r,{ts:t.wall_time}),r+="&"+t.query,{wall_time:new Date(t.wall_time*1e3),step:t.step,url:r}}_updateImageUrl(){var t=this._currentStep,r=this.brightnessAdjustment,n=this.contrastPercentage;if(!t)return;let i=new Image;this._imageCanceller.cancelAll(),i.onload=i.onerror=this._imageCanceller.cancellable(o=>{if(o.cancelled)return;let a=this.$$("#main-image-container");a&&(a.textContent="",zt(a).appendChild(i)),this.set("_isImageLoading",!1)}).bind(this),i.style.filter=`contrast(${n}%) `,i.style.filter+=`brightness(${r})`,this.set("_isImageLoading",!0),i.src=t.url}_handleTap(t){this.set("actualSize",!this.actualSize)}_toLocaleString(t){return t.toLocaleString()}};_n.template=Q`
    <tf-card-heading
      tag="[[tag]]"
      run="[[run]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
      color="[[_runColor]]"
    >
      <template is="dom-if" if="[[_hasMultipleSamples]]">
        <div>sample: [[_sampleText]] of [[ofSamples]]</div>
      </template>
      <template is="dom-if" if="[[_hasAtLeastOneStep]]">
        <div class="heading-row">
          <div class="heading-label">
            step
            <span style="font-weight: bold"
              >[[_toLocaleString(_stepValue)]]</span
            >
          </div>
          <div class="heading-label heading-right datetime">
            <template is="dom-if" if="[[_currentWallTime]]">
              [[_currentWallTime]]
            </template>
          </div>
          <div class="label right">
            <paper-spinner-lite active hidden$="[[!_isImageLoading]]">
            </paper-spinner-lite>
          </div>
        </div>
      </template>
      <template is="dom-if" if="[[_hasMultipleSteps]]">
        <div>
          <paper-slider
            id="steps"
            immediate-value="{{_stepIndex}}"
            max="[[_maxStepIndex]]"
            max-markers="[[_maxStepIndex]]"
            snaps
            step="1"
            value="{{_stepIndex}}"
          ></paper-slider>
        </div>
      </template>
    </tf-card-heading>

    <!-- Semantically a button but <img> inside a <button> disallows user to do
    an interesting operation like "Copy Image" in non-Chromium browsers. -->
    <a
      id="main-image-container"
      role="button"
      aria-label="Toggle actual size"
      aria-expanded$="[[_getAriaExpanded(actualSize)]]"
      on-tap="_handleTap"
    ></a>

    <style include="tf-card-heading-style">
      /** Make button a div. */
      button {
        width: 100%;
        display: block;
        background: none;
        border: 0;
        padding: 0;
      }

      /** Firefox: Get rid of dotted line inside button. */
      button::-moz-focus-inner {
        border: 0;
        padding: 0;
      }

      /** Firefox: Simulate Chrome's outer glow on button when focused. */
      button:-moz-focusring {
        outline: none;
        box-shadow: 0px 0px 1px 2px Highlight;
      }

      :host {
        display: block;
        width: 350px;
        height: auto;
        position: relative;
        margin: 0 15px 40px 0;
        overflow-x: auto;
      }

      /** When actual size shown is on, use the actual image width. */
      :host([actual-size]) {
        max-width: 100%;
        width: auto;
      }

      :host([actual-size]) #main-image-container {
        max-height: none;
        width: auto;
      }

      :host([actual-size]) #main-image-container img {
        width: auto;
      }

      paper-spinner-lite {
        width: 14px;
        height: 14px;
        vertical-align: text-bottom;
        --paper-spinner-color: var(--tb-orange-strong);
      }

      #steps {
        height: 15px;
        margin: 0 0 0 -15px;
        /*
         * 31 comes from adding a padding of 15px from both sides of the
         * paper-slider, subtracting 1px so that the slider width aligns
         * with the image (the last slider marker takes up 1px), and
         * adding 2px to account for a border of 1px on both sides of
         * the image. 30 - 1 + 2.
         */
        width: calc(100% + 31px);
        --paper-slider-active-color: var(--tb-orange-strong);
        --paper-slider-knob-color: var(--tb-orange-strong);
        --paper-slider-knob-start-border-color: var(--tb-orange-strong);
        --paper-slider-knob-start-color: var(--tb-orange-strong);
        --paper-slider-markers-color: var(--tb-orange-strong);
        --paper-slider-pin-color: var(--tb-orange-strong);
        --paper-slider-pin-start-color: var(--tb-orange-strong);
      }

      #main-image-container {
        max-height: 1024px;
        overflow: auto;
      }

      #main-image-container img {
        cursor: pointer;
        display: block;
        image-rendering: -moz-crisp-edges;
        image-rendering: pixelated;
        width: 100%;
        height: auto;
      }

      paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }
      paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }
      [hidden] {
        display: none;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],_n.prototype,"run",void 0);E([A({type:String}),w("design:type",String)],_n.prototype,"tag",void 0);E([A({type:Number}),w("design:type",Number)],_n.prototype,"sample",void 0);E([A({type:Number}),w("design:type",Number)],_n.prototype,"ofSamples",void 0);E([A({type:Object}),w("design:type",Object)],_n.prototype,"tagMetadata",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],_n.prototype,"actualSize",void 0);E([A({type:Number}),w("design:type",Number)],_n.prototype,"brightnessAdjustment",void 0);E([A({type:Number}),w("design:type",Number)],_n.prototype,"contrastPercentage",void 0);E([A({type:Object}),w("design:type",Ae)],_n.prototype,"requestManager",void 0);E([A({type:Object}),w("design:type",Object)],_n.prototype,"_metadataCanceller",void 0);E([A({type:Object}),w("design:type",Object)],_n.prototype,"_imageCanceller",void 0);E([A({type:Array,notify:!0}),w("design:type",Array)],_n.prototype,"_steps",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],_n.prototype,"_stepIndex",void 0);E([A({type:Boolean}),w("design:type",Boolean)],_n.prototype,"_isImageLoading",void 0);E([Rt("run"),w("design:type",String),w("design:paramtypes",[])],_n.prototype,"_runColor",null);E([Rt("_steps"),w("design:type",Boolean),w("design:paramtypes",[])],_n.prototype,"_hasAtLeastOneStep",null);E([Rt("_steps"),w("design:type",Boolean),w("design:paramtypes",[])],_n.prototype,"_hasMultipleSteps",null);E([Rt("_steps","_stepIndex"),w("design:type",Object),w("design:paramtypes",[])],_n.prototype,"_currentStep",null);E([Rt("_currentStep"),w("design:type",Number),w("design:paramtypes",[])],_n.prototype,"_stepValue",null);E([Rt("_currentStep"),w("design:type",String),w("design:paramtypes",[])],_n.prototype,"_currentWallTime",null);E([Rt("_steps"),w("design:type",Number),w("design:paramtypes",[])],_n.prototype,"_maxStepIndex",null);E([Rt("sample"),w("design:type",String),w("design:paramtypes",[])],_n.prototype,"_sampleText",null);E([Rt("ofSamples"),w("design:type",Boolean),w("design:paramtypes",[])],_n.prototype,"_hasMultipleSamples",null);E([Bt("run","tag"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],_n.prototype,"reload",null);E([Bt("_currentStep","brightnessAdjustment","contrastPercentage"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],_n.prototype,"_updateImageUrl",null);_n=E([yt("tf-image-loader")],_n);var Io=class extends Gt(mt){constructor(){super(...arguments),this.reloadOnReady=!0,this._defaultBrightnessAdjustment=1,this._defaultContrastPercentage=100,this._brightnessAdjustment=1,this._contrastPercentage=100,this._requestManager=new Ae}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then(()=>{this._reloadImages()})}_fetchTags(){let t=ve().pluginRoute("images","/tags");return this._requestManager.request(t).then(r=>{if(pv.isEqual(r,this._runToTagInfo))return;let n=pv.mapValues(r,o=>Object.keys(o)),i=$i(n);this.set("_dataNotFound",i.length===0),this.set("_runToTagInfo",r),this.async(()=>{this.set("_categoriesDomReady",!0)})})}_reloadImages(){var t;(t=this.root)==null||t.querySelectorAll("tf-image-loader").forEach(r=>{r.reload()})}_shouldOpen(t){return t<=2}_resetBrightness(){this._brightnessAdjustment=this._defaultBrightnessAdjustment}_resetContrast(){this._contrastPercentage=this._defaultContrastPercentage}get _brightnessIsDefault(){var t=this._brightnessAdjustment;return t===this._defaultBrightnessAdjustment}get _contrastIsDefault(){var t=this._contrastPercentage;return t===this._defaultContrastPercentage}get _categories(){var t=this._runToTagInfo,r=this._selectedRuns,n=this._tagFilter,i=this._categoriesDomReady;let o=pv.mapValues(t,c=>Object.keys(c)),a=Ql(o,r,n);function s(c){let u=t[c.run][c.tag].samples;return pv.range(u).map(h=>Object.assign({},c,{sample:h,ofSamples:u}))}return a.map(c=>Object.assign({},c,{items:[].concat.apply([],c.items.map(s))}))}_tagMetadata(t,r,n){return t[r][n]}};Io.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <div class="line-item">
              <paper-checkbox checked="{{_actualSize}}"
                >Show actual image size</paper-checkbox
              >
            </div>
          </div>
          <div class="sidebar-section">
            <h3 class="tooltip-container">Brightness adjustment</h3>
            <div class="resettable-slider-container">
              <paper-slider
                min="0"
                max="2"
                snaps
                pin
                step="0.01"
                value="{{_brightnessAdjustment}}"
                immediate-value="{{_brightnessAdjustment}}"
              ></paper-slider>
              <paper-button
                class="x-button"
                on-tap="_resetBrightness"
                disabled="[[_brightnessIsDefault]]"
                >Reset</paper-button
              >
            </div>
          </div>
          <div class="sidebar-section">
            <h3 class="tooltip-container">Contrast adjustment</h3>
            <div class="resettable-slider-container">
              <paper-slider
                min="0"
                max="500"
                snaps
                pin
                step="1"
                value="{{_contrastPercentage}}"
                immediate-value="{{_contrastPercentage}}"
              ></paper-slider>
              <paper-button
                class="x-button"
                on-tap="_resetContrast"
                disabled="[[_contrastIsDefault]]"
                >Reset</paper-button
              >
            </div>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector
            id="runs-selector"
            selected-runs="{{_selectedRuns}}"
          ></tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No image data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any image data to your event files.</li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-image-loader
                  active="[[active]]"
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  sample="[[item.sample]]"
                  of-samples="[[item.ofSamples]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.run, item.tag)]]"
                  request-manager="[[_requestManager]]"
                  actual-size="[[_actualSize]]"
                  brightness-adjustment="[[_brightnessAdjustment]]"
                  contrast-percentage="[[_contrastPercentage]]"
                ></tf-image-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>
    <style include="dashboard-style"></style>
    <style>
      .resettable-slider-container {
        display: flex;
      }
      .resettable-slider-container paper-slider {
        flex-grow: 1;
      }
      .resettable-slider-container paper-button {
        flex-grow: 0;
      }
      .resettable-slider-container paper-button[disabled] {
        background-color: unset;
      }
      .x-button {
        font-size: 13px;
        background-color: var(--tb-ui-light-accent);
        color: var(--tb-ui-dark-accent);
      }
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
      paper-slider {
        --paper-slider-active-color: var(--tb-orange-strong);
        --paper-slider-knob-color: var(--tb-orange-strong);
        --paper-slider-knob-start-border-color: var(--tb-orange-strong);
        --paper-slider-knob-start-color: var(--tb-orange-strong);
        --paper-slider-markers-color: var(--tb-orange-strong);
        --paper-slider-pin-color: var(--tb-orange-strong);
        --paper-slider-pin-start-color: var(--tb-orange-strong);
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],Io.prototype,"reloadOnReady",void 0);E([A({type:Array}),w("design:type",Array)],Io.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],Io.prototype,"_runToTagInfo",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Io.prototype,"_dataNotFound",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Io.prototype,"_actualSize",void 0);E([A({type:Number}),w("design:type",Number)],Io.prototype,"_defaultBrightnessAdjustment",void 0);E([A({type:Number}),w("design:type",Number)],Io.prototype,"_defaultContrastPercentage",void 0);E([A({type:Number}),w("design:type",Number)],Io.prototype,"_brightnessAdjustment",void 0);E([A({type:Number}),w("design:type",Number)],Io.prototype,"_contrastPercentage",void 0);E([A({type:String}),w("design:type",String)],Io.prototype,"_tagFilter",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Io.prototype,"_categoriesDomReady",void 0);E([A({type:Object}),w("design:type",Object)],Io.prototype,"_requestManager",void 0);E([Rt("_brightnessAdjustment"),w("design:type",Boolean),w("design:paramtypes",[])],Io.prototype,"_brightnessIsDefault",null);E([Rt("_contrastPercentage"),w("design:type",Boolean),w("design:paramtypes",[])],Io.prototype,"_contrastIsDefault",null);E([Rt("_runToTagInfo","_selectedRuns","_tagFilter","_categoriesDomReady"),w("design:type",Array),w("design:paramtypes",[])],Io.prototype,"_categories",null);Io=E([yt("tf-image-dashboard")],Io);var sx=Ee(Oe(),1);var dv;(function(e){e[e.CANCELLED=1]="CANCELLED"})(dv||(dv={}));var lV;(function(e){e[e.VERTEX=1]="VERTEX",e[e.FACE=2]="FACE",e[e.COLOR=3]="COLOR"})(lV||(lV={}));var Gct;(function(e){e.VERTEX="float32",e.FACE="int32",e.COLOR="uint8"})(Gct||(Gct={}));var PP=class{constructor(t){this._canceller=new an,this._requestManager=t}reload(t,r,n){return this._canceller.cancelAll(),this._fetchMetadata(t,r,n)}_fetchDataByStep(t,r,n,i,o,a){let s=ve().pluginRoute("mesh","/data",new URLSearchParams({tag:r,run:t,content_type:n,sample:String(i),step:String(o)})),l=function(u){let f=[];for(let p=0;p<u.length/3;p++){let d=[];for(let g=0;g<3;g++)d.push(u[p*3+g]);f.push(d)}return f},c=this._canceller.cancellable(u=>{if(u.cancelled)return Promise.reject({code:dv.CANCELLED,message:"Response was invalidated."});let h=u.value;switch(n){case"VERTEX":a.vertices=l(new Float32Array(h));break;case"FACE":a.faces=l(new Int32Array(h));break;case"COLOR":a.colors=l(new Uint8Array(h));break}return a});return this._requestManager.fetch(s,{method:"GET",headers:{responseType:"arraybuffer",contentType:Gct[n]}}).then(u=>u.arrayBuffer()).then(c)}fetchData(t,r,n,i){let o=[],a=new Map;return Object.keys(lV).forEach(s=>{let l=1<<lV[s];t.components&l&&o.push(this._fetchDataByStep(r,n,s,i,t.step,a))}),Promise.all(o)}_fetchMetadata(t,r,n){this._canceller.cancelAll();let i=ve().pluginRoute("mesh","/meshes",new URLSearchParams({tag:r,run:t,sample:n})),o=this._canceller.cancellable(a=>a.cancelled?Promise.reject({code:dv.CANCELLED,message:"Response was invalidated."}):a.value);return this._requestManager.fetch(i).then(a=>a.json()).then(o).then(this._processMetadata.bind(this))}_processMetadata(t){if(!t)return;let r=new Map;for(let i=0;i<t.length;i++){let o=t[i];r.has(o.step)||r.set(o.step,[]),r.get(o.step).push(o)}let n=[];return r.forEach(i=>{let o=this._createStepDatum(i[0]);n.push(o)}),n}_createStepDatum(t){return{wall_time:new Date(t.wall_time*1e3),step:t.step,config:t.config,content_type:t.content_type,components:t.components}}};var wM={};Ks(wM,{ACESFilmicToneMapping:()=>lfe,AddEquation:()=>Mv,AddOperation:()=>ife,AdditiveAnimationBlendMode:()=>Rht,AdditiveBlending:()=>Eut,AlphaFormat:()=>mfe,AlwaysDepth:()=>Zhe,AlwaysStencilFunc:()=>Lfe,AmbientLight:()=>I6,AmbientLightProbe:()=>OU,AnimationClip:()=>Qv,AnimationLoader:()=>aht,AnimationMixer:()=>HU,AnimationObjectGroup:()=>BU,AnimationUtils:()=>jn,ArcCurve:()=>s6,ArrayCamera:()=>r6,ArrowHelper:()=>Eht,Audio:()=>N6,AudioAnalyser:()=>zU,AudioContext:()=>Fht,AudioListener:()=>uht,AudioLoader:()=>NU,AxesHelper:()=>vM,AxisHelper:()=>W0r,BackSide:()=>Ii,BasicDepthPacking:()=>Afe,BasicShadowMap:()=>uhr,BinaryTextureLoader:()=>K0r,Bone:()=>sM,BooleanKeyframeTrack:()=>am,BoundingBoxHelper:()=>Y0r,Box2:()=>$0,Box3:()=>ta,Box3Helper:()=>Sht,BoxBufferGeometry:()=>Qf,BoxGeometry:()=>Qf,BoxHelper:()=>yM,BufferAttribute:()=>Je,BufferGeometry:()=>Pe,BufferGeometryLoader:()=>kU,ByteType:()=>ufe,Cache:()=>tx,Camera:()=>Rv,CameraHelper:()=>wht,CanvasRenderer:()=>J0r,CanvasTexture:()=>vU,CatmullRomCurve3:()=>l6,CineonToneMapping:()=>sfe,CircleBufferGeometry:()=>Fv,CircleGeometry:()=>Fv,ClampToEdgeWrapping:()=>Jo,Clock:()=>mM,Color:()=>ne,ColorKeyframeTrack:()=>S6,CompressedTexture:()=>o6,CompressedTextureLoader:()=>sht,ConeBufferGeometry:()=>Bv,ConeGeometry:()=>Bv,CubeCamera:()=>J3,CubeReflectionMapping:()=>nx,CubeRefractionMapping:()=>ix,CubeTexture:()=>H0,CubeTextureLoader:()=>EU,CubeUVReflectionMapping:()=>xM,CubeUVRefractionMapping:()=>O6,CubicBezierCurve:()=>cM,CubicBezierCurve3:()=>c6,CubicInterpolant:()=>wU,CullFaceBack:()=>Mut,CullFaceFront:()=>Ohe,CullFaceFrontBack:()=>chr,CullFaceNone:()=>Dhe,Curve:()=>fs,CurvePath:()=>bU,CustomBlending:()=>Fhe,CustomToneMapping:()=>cfe,CylinderBufferGeometry:()=>om,CylinderGeometry:()=>om,Cylindrical:()=>ght,DataTexture:()=>Jd,DataTexture2DArray:()=>tM,DataTexture3D:()=>e6,DataTextureLoader:()=>TU,DataUtils:()=>Cht,DecrementStencilOp:()=>bhr,DecrementWrapStencilOp:()=>Shr,DefaultLoadingManager:()=>Qfe,DepthFormat:()=>z0,DepthStencilFormat:()=>kv,DepthTexture:()=>nM,DirectionalLight:()=>P6,DirectionalLightHelper:()=>bht,DiscreteInterpolant:()=>SU,DodecahedronBufferGeometry:()=>Hv,DodecahedronGeometry:()=>Hv,DoubleSide:()=>Lv,DstAlphaFactor:()=>Whe,DstColorFactor:()=>jhe,DynamicBufferAttribute:()=>D0r,DynamicCopyUsage:()=>zhr,DynamicDrawUsage:()=>Y3,DynamicReadUsage:()=>Nhr,EdgesGeometry:()=>a6,EdgesHelper:()=>j0r,EllipseCurve:()=>Vv,EqualDepth:()=>Qhe,EqualStencilFunc:()=>Chr,EquirectangularReflectionMapping:()=>WP,EquirectangularRefractionMapping:()=>YP,Euler:()=>tm,EventDispatcher:()=>Us,ExtrudeBufferGeometry:()=>hh,ExtrudeGeometry:()=>hh,FaceColors:()=>M0r,FileLoader:()=>Jc,FlatShading:()=>Pht,Float16BufferAttribute:()=>pU,Float32Attribute:()=>q0r,Float32BufferAttribute:()=>xe,Float64Attribute:()=>G0r,Float64BufferAttribute:()=>dU,FloatType:()=>jd,Fog:()=>zv,FogExp2:()=>Ov,Font:()=>o_r,FontLoader:()=>i_r,FramebufferTexture:()=>yU,FrontSide:()=>Iv,Frustum:()=>Nv,GLBufferAttribute:()=>UU,GLSL1:()=>Bhr,GLSL3:()=>Zut,GreaterDepth:()=>efe,GreaterEqualDepth:()=>tfe,GreaterEqualStencilFunc:()=>Lhr,GreaterStencilFunc:()=>Phr,GridHelper:()=>WU,Group:()=>Xd,HalfFloatType:()=>Cv,HemisphereLight:()=>E6,HemisphereLightHelper:()=>vht,HemisphereLightProbe:()=>DU,IcosahedronBufferGeometry:()=>Gv,IcosahedronGeometry:()=>Gv,ImageBitmapLoader:()=>RU,ImageLoader:()=>ex,ImageUtils:()=>Kf,ImmediateRenderObject:()=>a_r,IncrementStencilOp:()=>xhr,IncrementWrapStencilOp:()=>whr,InstancedBufferAttribute:()=>rm,InstancedBufferGeometry:()=>R6,InstancedInterleavedBuffer:()=>VU,InstancedMesh:()=>n6,Int16Attribute:()=>B0r,Int16BufferAttribute:()=>hU,Int32Attribute:()=>V0r,Int32BufferAttribute:()=>fU,Int8Attribute:()=>O0r,Int8BufferAttribute:()=>lU,IntType:()=>ffe,InterleavedBuffer:()=>em,InterleavedBufferAttribute:()=>tp,Interpolant:()=>fh,InterpolateDiscrete:()=>$P,InterpolateLinear:()=>KP,InterpolateSmooth:()=>eU,InvertStencilOp:()=>Mhr,JSONLoader:()=>Q0r,KeepStencilOp:()=>rU,KeyframeTrack:()=>Dl,LOD:()=>gU,LatheBufferGeometry:()=>Wv,LatheGeometry:()=>Wv,Layers:()=>X3,LensFlare:()=>e_r,LessDepth:()=>Jhe,LessEqualDepth:()=>nU,LessEqualStencilFunc:()=>Ahr,LessStencilFunc:()=>Thr,Light:()=>Ol,LightProbe:()=>rx,Line:()=>ch,Line3:()=>qU,LineBasicMaterial:()=>Gi,LineCurve:()=>Uv,LineCurve3:()=>xU,LineDashedMaterial:()=>b6,LineLoop:()=>i6,LinePieces:()=>w0r,LineSegments:()=>Aa,LineStrip:()=>b0r,LinearEncoding:()=>Qd,LinearFilter:()=>oi,LinearInterpolant:()=>w6,LinearMipMapLinearFilter:()=>mhr,LinearMipMapNearestFilter:()=>dhr,LinearMipmapLinearFilter:()=>ox,LinearMipmapNearestFilter:()=>kht,LinearToneMapping:()=>ofe,Loader:()=>ea,LoaderUtils:()=>dM,LoadingManager:()=>M6,LoopOnce:()=>Mfe,LoopPingPong:()=>Tfe,LoopRepeat:()=>Efe,LuminanceAlphaFormat:()=>_fe,LuminanceFormat:()=>gfe,MOUSE:()=>K0,Material:()=>qi,MaterialLoader:()=>LU,Math:()=>Qhr,MathUtils:()=>Qhr,Matrix3:()=>ki,Matrix4:()=>Me,MaxEquation:()=>Put,Mesh:()=>ei,MeshBasicMaterial:()=>sh,MeshDepthMaterial:()=>eM,MeshDistanceMaterial:()=>rM,MeshFaceMaterial:()=>T0r,MeshLambertMaterial:()=>v6,MeshMatcapMaterial:()=>x6,MeshNormalMaterial:()=>y6,MeshPhongMaterial:()=>g6,MeshPhysicalMaterial:()=>m6,MeshStandardMaterial:()=>pM,MeshToonMaterial:()=>_6,MinEquation:()=>Aut,MirroredRepeatWrapping:()=>XP,MixOperation:()=>nfe,MultiMaterial:()=>C0r,MultiplyBlending:()=>Cut,MultiplyOperation:()=>D6,NearestFilter:()=>Li,NearestMipMapLinearFilter:()=>phr,NearestMipMapNearestFilter:()=>fhr,NearestMipmapLinearFilter:()=>oU,NearestMipmapNearestFilter:()=>iU,NeverDepth:()=>Khe,NeverStencilFunc:()=>Ehr,NoBlending:()=>$d,NoColors:()=>S0r,NoToneMapping:()=>Kd,NormalAnimationBlendMode:()=>XU,NormalBlending:()=>V3,NotEqualDepth:()=>rfe,NotEqualStencilFunc:()=>Ihr,NumberKeyframeTrack:()=>Zv,Object3D:()=>or,ObjectLoader:()=>lht,ObjectSpaceNormalMap:()=>Ife,OctahedronBufferGeometry:()=>W0,OctahedronGeometry:()=>W0,OneFactor:()=>Uhe,OneMinusDstAlphaFactor:()=>Yhe,OneMinusDstColorFactor:()=>Xhe,OneMinusSrcAlphaFactor:()=>Lht,OneMinusSrcColorFactor:()=>Ghe,OrthographicCamera:()=>Dv,PCFShadowMap:()=>Aht,PCFSoftShadowMap:()=>zhe,PMREMGenerator:()=>t6,ParametricGeometry:()=>r_r,Particle:()=>P0r,ParticleBasicMaterial:()=>k0r,ParticleSystem:()=>I0r,ParticleSystemMaterial:()=>R0r,Path:()=>qv,PerspectiveCamera:()=>Ui,Plane:()=>$c,PlaneBufferGeometry:()=>V0,PlaneGeometry:()=>V0,PlaneHelper:()=>Mht,PointCloud:()=>A0r,PointCloudMaterial:()=>L0r,PointLight:()=>A6,PointLightHelper:()=>yht,Points:()=>im,PointsMaterial:()=>nm,PolarGridHelper:()=>xht,PolyhedronBufferGeometry:()=>uh,PolyhedronGeometry:()=>uh,PositionalAudio:()=>hht,PropertyBinding:()=>Cr,PropertyMixer:()=>FU,QuadraticBezierCurve:()=>uM,QuadraticBezierCurve3:()=>hM,Quaternion:()=>vi,QuaternionKeyframeTrack:()=>X0,QuaternionLinearInterpolant:()=>MU,REVISION:()=>YU,RGBADepthPacking:()=>Pfe,RGBAFormat:()=>Qo,RGBAIntegerFormat:()=>wfe,RGBA_ASTC_10x10_Format:()=>jut,RGBA_ASTC_10x5_Format:()=>Gut,RGBA_ASTC_10x6_Format:()=>Wut,RGBA_ASTC_10x8_Format:()=>Yut,RGBA_ASTC_12x10_Format:()=>Xut,RGBA_ASTC_12x12_Format:()=>$ut,RGBA_ASTC_4x4_Format:()=>Out,RGBA_ASTC_5x4_Format:()=>zut,RGBA_ASTC_5x5_Format:()=>Fut,RGBA_ASTC_6x5_Format:()=>But,RGBA_ASTC_6x6_Format:()=>Hut,RGBA_ASTC_8x5_Format:()=>Vut,RGBA_ASTC_8x6_Format:()=>Uut,RGBA_ASTC_8x8_Format:()=>qut,RGBA_BPTC_Format:()=>Kut,RGBA_ETC2_EAC_Format:()=>Dut,RGBA_PVRTC_2BPPV1_Format:()=>Rut,RGBA_PVRTC_4BPPV1_Format:()=>kut,RGBA_S3TC_DXT1_Format:()=>JV,RGBA_S3TC_DXT3_Format:()=>QV,RGBA_S3TC_DXT5_Format:()=>tU,RGB_ETC1_Format:()=>Sfe,RGB_ETC2_Format:()=>Nut,RGB_PVRTC_2BPPV1_Format:()=>Lut,RGB_PVRTC_4BPPV1_Format:()=>Iut,RGB_S3TC_DXT1_Format:()=>ZV,RGFormat:()=>xfe,RGIntegerFormat:()=>bfe,RawShaderMaterial:()=>U0,Ray:()=>Jf,Raycaster:()=>dht,RectAreaLight:()=>L6,RedFormat:()=>yfe,RedIntegerFormat:()=>vfe,ReinhardToneMapping:()=>afe,RepeatWrapping:()=>jP,ReplaceStencilOp:()=>vhr,ReverseSubtractEquation:()=>Hhe,RingBufferGeometry:()=>Yv,RingGeometry:()=>Yv,Scene:()=>q0,SceneUtils:()=>t_r,ShaderChunk:()=>hr,ShaderLib:()=>ah,ShaderMaterial:()=>lh,ShadowMaterial:()=>d6,Shape:()=>Kc,ShapeBufferGeometry:()=>Y0,ShapeGeometry:()=>Y0,ShapePath:()=>Tht,ShapeUtils:()=>Zc,ShortType:()=>hfe,Skeleton:()=>lM,SkeletonHelper:()=>GU,SkinnedMesh:()=>aM,SmoothShading:()=>hhr,Sphere:()=>Zf,SphereBufferGeometry:()=>j0,SphereGeometry:()=>j0,Spherical:()=>_M,SphericalHarmonics3:()=>k6,SplineCurve:()=>fM,SpotLight:()=>C6,SpotLightHelper:()=>_ht,Sprite:()=>oM,SpriteMaterial:()=>iM,SrcAlphaFactor:()=>Iht,SrcAlphaSaturateFactor:()=>$he,SrcColorFactor:()=>qhe,StaticCopyUsage:()=>Ohr,StaticDrawUsage:()=>W3,StaticReadUsage:()=>Rhr,StereoCamera:()=>cht,StreamCopyUsage:()=>Fhr,StreamDrawUsage:()=>khr,StreamReadUsage:()=>Dhr,StringKeyframeTrack:()=>sm,SubtractEquation:()=>Bhe,SubtractiveBlending:()=>Tut,TOUCH:()=>Z0,TangentSpaceNormalMap:()=>ax,TetrahedronBufferGeometry:()=>jv,TetrahedronGeometry:()=>jv,TextGeometry:()=>n_r,Texture:()=>xi,TextureLoader:()=>CU,TorusBufferGeometry:()=>Xv,TorusGeometry:()=>Xv,TorusKnotBufferGeometry:()=>$v,TorusKnotGeometry:()=>$v,Triangle:()=>ai,TriangleFanDrawMode:()=>_hr,TriangleStripDrawMode:()=>ghr,TrianglesDrawMode:()=>Cfe,TubeBufferGeometry:()=>Kv,TubeGeometry:()=>Kv,UVMapping:()=>jU,Uint16Attribute:()=>H0r,Uint16BufferAttribute:()=>$3,Uint32Attribute:()=>U0r,Uint32BufferAttribute:()=>K3,Uint8Attribute:()=>z0r,Uint8BufferAttribute:()=>cU,Uint8ClampedAttribute:()=>F0r,Uint8ClampedBufferAttribute:()=>uU,Uniform:()=>gM,UniformsLib:()=>re,UniformsUtils:()=>Ofe,UnsignedByteType:()=>Zd,UnsignedInt248Type:()=>Av,UnsignedIntType:()=>HP,UnsignedShort4444Type:()=>pfe,UnsignedShort5551Type:()=>dfe,UnsignedShortType:()=>G3,VSMShadowMap:()=>F3,Vector2:()=>Lt,Vector3:()=>j,Vector4:()=>en,VectorKeyframeTrack:()=>Jv,Vertex:()=>N0r,VertexColors:()=>E0r,VideoTexture:()=>_U,WebGL1Renderer:()=>mU,WebGLCubeRenderTarget:()=>Q3,WebGLMultipleRenderTargets:()=>sU,WebGLMultisampleRenderTarget:()=>j3,WebGLRenderTarget:()=>us,WebGLRenderTargetCube:()=>Z0r,WebGLRenderer:()=>rn,WebGLUtils:()=>Xfe,WireframeGeometry:()=>p6,WireframeHelper:()=>X0r,WrapAroundEnding:()=>ZP,XHRLoader:()=>$0r,ZeroCurvatureEnding:()=>Ev,ZeroFactor:()=>Vhe,ZeroSlopeEnding:()=>Tv,ZeroStencilOp:()=>yhr,_SRGBAFormat:()=>aU,sRGBEncoding:()=>Yn});var YU="137",K0={LEFT:0,MIDDLE:1,RIGHT:2,ROTATE:0,DOLLY:1,PAN:2},Z0={ROTATE:0,PAN:1,DOLLY_PAN:2,DOLLY_ROTATE:3},Dhe=0,Mut=1,Ohe=2,chr=3,uhr=0,Aht=1,zhe=2,F3=3,Iv=0,Ii=1,Lv=2,Pht=1,hhr=2,$d=0,V3=1,Eut=2,Tut=3,Cut=4,Fhe=5,Mv=100,Bhe=101,Hhe=102,Aut=103,Put=104,Vhe=200,Uhe=201,qhe=202,Ghe=203,Iht=204,Lht=205,Whe=206,Yhe=207,jhe=208,Xhe=209,$he=210,Khe=0,Zhe=1,Jhe=2,nU=3,Qhe=4,tfe=5,efe=6,rfe=7,D6=0,nfe=1,ife=2,Kd=0,ofe=1,afe=2,sfe=3,lfe=4,cfe=5,jU=300,nx=301,ix=302,WP=303,YP=304,xM=306,O6=307,jP=1e3,Jo=1001,XP=1002,Li=1003,iU=1004,fhr=1004,oU=1005,phr=1005,oi=1006,kht=1007,dhr=1007,ox=1008,mhr=1008,Zd=1009,ufe=1010,hfe=1011,G3=1012,ffe=1013,HP=1014,jd=1015,Cv=1016,pfe=1017,dfe=1018,Av=1020,mfe=1021,Qo=1023,gfe=1024,_fe=1025,z0=1026,kv=1027,yfe=1028,vfe=1029,xfe=1030,bfe=1031,wfe=1033,ZV=33776,JV=33777,QV=33778,tU=33779,Iut=35840,Lut=35841,kut=35842,Rut=35843,Sfe=36196,Nut=37492,Dut=37496,Out=37808,zut=37809,Fut=37810,But=37811,Hut=37812,Vut=37813,Uut=37814,qut=37815,Gut=37816,Wut=37817,Yut=37818,jut=37819,Xut=37820,$ut=37821,Kut=36492,Mfe=2200,Efe=2201,Tfe=2202,$P=2300,KP=2301,eU=2302,Ev=2400,Tv=2401,ZP=2402,XU=2500,Rht=2501,Cfe=0,ghr=1,_hr=2,Qd=3e3,Yn=3001,Afe=3200,Pfe=3201,ax=0,Ife=1,yhr=0,rU=7680,vhr=7681,xhr=7682,bhr=7683,whr=34055,Shr=34056,Mhr=5386,Ehr=512,Thr=513,Chr=514,Ahr=515,Phr=516,Ihr=517,Lhr=518,Lfe=519,W3=35044,Y3=35048,khr=35040,Rhr=35045,Nhr=35049,Dhr=35041,Ohr=35046,zhr=35050,Fhr=35042,Bhr="100",Zut="300 es",aU=1035,Us=class{addEventListener(t,r){this._listeners===void 0&&(this._listeners={});let n=this._listeners;n[t]===void 0&&(n[t]=[]),n[t].indexOf(r)===-1&&n[t].push(r)}hasEventListener(t,r){if(this._listeners===void 0)return!1;let n=this._listeners;return n[t]!==void 0&&n[t].indexOf(r)!==-1}removeEventListener(t,r){if(this._listeners===void 0)return;let i=this._listeners[t];if(i!==void 0){let o=i.indexOf(r);o!==-1&&i.splice(o,1)}}dispatchEvent(t){if(this._listeners===void 0)return;let n=this._listeners[t.type];if(n!==void 0){t.target=this;let i=n.slice(0);for(let o=0,a=i.length;o<a;o++)i[o].call(this,t);t.target=null}}},Ko=[];for(let e=0;e<256;e++)Ko[e]=(e<16?"0":"")+e.toString(16);var cV=1234567,Pv=Math.PI/180,JP=180/Math.PI;function Nl(){let e=Math.random()*4294967295|0,t=Math.random()*4294967295|0,r=Math.random()*4294967295|0,n=Math.random()*4294967295|0;return(Ko[e&255]+Ko[e>>8&255]+Ko[e>>16&255]+Ko[e>>24&255]+"-"+Ko[t&255]+Ko[t>>8&255]+"-"+Ko[t>>16&15|64]+Ko[t>>24&255]+"-"+Ko[r&63|128]+Ko[r>>8&255]+"-"+Ko[r>>16&255]+Ko[r>>24&255]+Ko[n&255]+Ko[n>>8&255]+Ko[n>>16&255]+Ko[n>>24&255]).toUpperCase()}function Zo(e,t,r){return Math.max(t,Math.min(r,e))}function Nht(e,t){return(e%t+t)%t}function Hhr(e,t,r,n,i){return n+(e-t)*(i-n)/(r-t)}function Vhr(e,t,r){return e!==t?(r-e)/(t-e):0}function VP(e,t,r){return(1-r)*e+r*t}function Uhr(e,t,r,n){return VP(e,t,1-Math.exp(-r*n))}function qhr(e,t=1){return t-Math.abs(Nht(e,t*2)-t)}function Ghr(e,t,r){return e<=t?0:e>=r?1:(e=(e-t)/(r-t),e*e*(3-2*e))}function Whr(e,t,r){return e<=t?0:e>=r?1:(e=(e-t)/(r-t),e*e*e*(e*(e*6-15)+10))}function Yhr(e,t){return e+Math.floor(Math.random()*(t-e+1))}function jhr(e,t){return e+Math.random()*(t-e)}function Xhr(e){return e*(.5-Math.random())}function $hr(e){return e!==void 0&&(cV=e%2147483647),cV=cV*16807%2147483647,(cV-1)/2147483646}function Khr(e){return e*Pv}function Zhr(e){return e*JP}function Jut(e){return(e&e-1)===0&&e!==0}function kfe(e){return Math.pow(2,Math.ceil(Math.log(e)/Math.LN2))}function Rfe(e){return Math.pow(2,Math.floor(Math.log(e)/Math.LN2))}function Jhr(e,t,r,n,i){let o=Math.cos,a=Math.sin,s=o(r/2),l=a(r/2),c=o((t+n)/2),u=a((t+n)/2),h=o((t-n)/2),f=a((t-n)/2),p=o((n-t)/2),d=a((n-t)/2);switch(i){case"XYX":e.set(s*u,l*h,l*f,s*c);break;case"YZY":e.set(l*f,s*u,l*h,s*c);break;case"ZXZ":e.set(l*h,l*f,s*u,s*c);break;case"XZX":e.set(s*u,l*d,l*p,s*c);break;case"YXY":e.set(l*p,s*u,l*d,s*c);break;case"ZYZ":e.set(l*d,l*p,s*u,s*c);break;default:console.warn("THREE.MathUtils: .setQuaternionFromProperEuler() encountered an unknown order: "+i)}}var Qhr=Object.freeze({__proto__:null,DEG2RAD:Pv,RAD2DEG:JP,generateUUID:Nl,clamp:Zo,euclideanModulo:Nht,mapLinear:Hhr,inverseLerp:Vhr,lerp:VP,damp:Uhr,pingpong:qhr,smoothstep:Ghr,smootherstep:Whr,randInt:Yhr,randFloat:jhr,randFloatSpread:Xhr,seededRandom:$hr,degToRad:Khr,radToDeg:Zhr,isPowerOfTwo:Jut,ceilPowerOfTwo:kfe,floorPowerOfTwo:Rfe,setQuaternionFromProperEuler:Jhr}),Lt=class{constructor(t=0,r=0){this.x=t,this.y=r}get width(){return this.x}set width(t){this.x=t}get height(){return this.y}set height(t){this.y=t}set(t,r){return this.x=t,this.y=r,this}setScalar(t){return this.x=t,this.y=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setComponent(t,r){switch(t){case 0:this.x=r;break;case 1:this.y=r;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y)}copy(t){return this.x=t.x,this.y=t.y,this}add(t,r){return r!==void 0?(console.warn("THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,r)):(this.x+=t.x,this.y+=t.y,this)}addScalar(t){return this.x+=t,this.y+=t,this}addVectors(t,r){return this.x=t.x+r.x,this.y=t.y+r.y,this}addScaledVector(t,r){return this.x+=t.x*r,this.y+=t.y*r,this}sub(t,r){return r!==void 0?(console.warn("THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,r)):(this.x-=t.x,this.y-=t.y,this)}subScalar(t){return this.x-=t,this.y-=t,this}subVectors(t,r){return this.x=t.x-r.x,this.y=t.y-r.y,this}multiply(t){return this.x*=t.x,this.y*=t.y,this}multiplyScalar(t){return this.x*=t,this.y*=t,this}divide(t){return this.x/=t.x,this.y/=t.y,this}divideScalar(t){return this.multiplyScalar(1/t)}applyMatrix3(t){let r=this.x,n=this.y,i=t.elements;return this.x=i[0]*r+i[3]*n+i[6],this.y=i[1]*r+i[4]*n+i[7],this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this}clamp(t,r){return this.x=Math.max(t.x,Math.min(r.x,this.x)),this.y=Math.max(t.y,Math.min(r.y,this.y)),this}clampScalar(t,r){return this.x=Math.max(t,Math.min(r,this.x)),this.y=Math.max(t,Math.min(r,this.y)),this}clampLength(t,r){let n=this.length();return this.divideScalar(n||1).multiplyScalar(Math.max(t,Math.min(r,n)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this}negate(){return this.x=-this.x,this.y=-this.y,this}dot(t){return this.x*t.x+this.y*t.y}cross(t){return this.x*t.y-this.y*t.x}lengthSq(){return this.x*this.x+this.y*this.y}length(){return Math.sqrt(this.x*this.x+this.y*this.y)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)}normalize(){return this.divideScalar(this.length()||1)}angle(){return Math.atan2(-this.y,-this.x)+Math.PI}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){let r=this.x-t.x,n=this.y-t.y;return r*r+n*n}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,r){return this.x+=(t.x-this.x)*r,this.y+=(t.y-this.y)*r,this}lerpVectors(t,r,n){return this.x=t.x+(r.x-t.x)*n,this.y=t.y+(r.y-t.y)*n,this}equals(t){return t.x===this.x&&t.y===this.y}fromArray(t,r=0){return this.x=t[r],this.y=t[r+1],this}toArray(t=[],r=0){return t[r]=this.x,t[r+1]=this.y,t}fromBufferAttribute(t,r,n){return n!==void 0&&console.warn("THREE.Vector2: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(r),this.y=t.getY(r),this}rotateAround(t,r){let n=Math.cos(r),i=Math.sin(r),o=this.x-t.x,a=this.y-t.y;return this.x=o*n-a*i+t.x,this.y=o*i+a*n+t.y,this}random(){return this.x=Math.random(),this.y=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y}};Lt.prototype.isVector2=!0;var ki=class{constructor(){this.elements=[1,0,0,0,1,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.")}set(t,r,n,i,o,a,s,l,c){let u=this.elements;return u[0]=t,u[1]=i,u[2]=s,u[3]=r,u[4]=o,u[5]=l,u[6]=n,u[7]=a,u[8]=c,this}identity(){return this.set(1,0,0,0,1,0,0,0,1),this}copy(t){let r=this.elements,n=t.elements;return r[0]=n[0],r[1]=n[1],r[2]=n[2],r[3]=n[3],r[4]=n[4],r[5]=n[5],r[6]=n[6],r[7]=n[7],r[8]=n[8],this}extractBasis(t,r,n){return t.setFromMatrix3Column(this,0),r.setFromMatrix3Column(this,1),n.setFromMatrix3Column(this,2),this}setFromMatrix4(t){let r=t.elements;return this.set(r[0],r[4],r[8],r[1],r[5],r[9],r[2],r[6],r[10]),this}multiply(t){return this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,r){let n=t.elements,i=r.elements,o=this.elements,a=n[0],s=n[3],l=n[6],c=n[1],u=n[4],h=n[7],f=n[2],p=n[5],d=n[8],g=i[0],_=i[3],y=i[6],x=i[1],b=i[4],S=i[7],C=i[2],P=i[5],k=i[8];return o[0]=a*g+s*x+l*C,o[3]=a*_+s*b+l*P,o[6]=a*y+s*S+l*k,o[1]=c*g+u*x+h*C,o[4]=c*_+u*b+h*P,o[7]=c*y+u*S+h*k,o[2]=f*g+p*x+d*C,o[5]=f*_+p*b+d*P,o[8]=f*y+p*S+d*k,this}multiplyScalar(t){let r=this.elements;return r[0]*=t,r[3]*=t,r[6]*=t,r[1]*=t,r[4]*=t,r[7]*=t,r[2]*=t,r[5]*=t,r[8]*=t,this}determinant(){let t=this.elements,r=t[0],n=t[1],i=t[2],o=t[3],a=t[4],s=t[5],l=t[6],c=t[7],u=t[8];return r*a*u-r*s*c-n*o*u+n*s*l+i*o*c-i*a*l}invert(){let t=this.elements,r=t[0],n=t[1],i=t[2],o=t[3],a=t[4],s=t[5],l=t[6],c=t[7],u=t[8],h=u*a-s*c,f=s*l-u*o,p=c*o-a*l,d=r*h+n*f+i*p;if(d===0)return this.set(0,0,0,0,0,0,0,0,0);let g=1/d;return t[0]=h*g,t[1]=(i*c-u*n)*g,t[2]=(s*n-i*a)*g,t[3]=f*g,t[4]=(u*r-i*l)*g,t[5]=(i*o-s*r)*g,t[6]=p*g,t[7]=(n*l-c*r)*g,t[8]=(a*r-n*o)*g,this}transpose(){let t,r=this.elements;return t=r[1],r[1]=r[3],r[3]=t,t=r[2],r[2]=r[6],r[6]=t,t=r[5],r[5]=r[7],r[7]=t,this}getNormalMatrix(t){return this.setFromMatrix4(t).invert().transpose()}transposeIntoArray(t){let r=this.elements;return t[0]=r[0],t[1]=r[3],t[2]=r[6],t[3]=r[1],t[4]=r[4],t[5]=r[7],t[6]=r[2],t[7]=r[5],t[8]=r[8],this}setUvTransform(t,r,n,i,o,a,s){let l=Math.cos(o),c=Math.sin(o);return this.set(n*l,n*c,-n*(l*a+c*s)+a+t,-i*c,i*l,-i*(-c*a+l*s)+s+r,0,0,1),this}scale(t,r){let n=this.elements;return n[0]*=t,n[3]*=t,n[6]*=t,n[1]*=r,n[4]*=r,n[7]*=r,this}rotate(t){let r=Math.cos(t),n=Math.sin(t),i=this.elements,o=i[0],a=i[3],s=i[6],l=i[1],c=i[4],u=i[7];return i[0]=r*o+n*l,i[3]=r*a+n*c,i[6]=r*s+n*u,i[1]=-n*o+r*l,i[4]=-n*a+r*c,i[7]=-n*s+r*u,this}translate(t,r){let n=this.elements;return n[0]+=t*n[2],n[3]+=t*n[5],n[6]+=t*n[8],n[1]+=r*n[2],n[4]+=r*n[5],n[7]+=r*n[8],this}equals(t){let r=this.elements,n=t.elements;for(let i=0;i<9;i++)if(r[i]!==n[i])return!1;return!0}fromArray(t,r=0){for(let n=0;n<9;n++)this.elements[n]=t[n+r];return this}toArray(t=[],r=0){let n=this.elements;return t[r]=n[0],t[r+1]=n[1],t[r+2]=n[2],t[r+3]=n[3],t[r+4]=n[4],t[r+5]=n[5],t[r+6]=n[6],t[r+7]=n[7],t[r+8]=n[8],t}clone(){return new this.constructor().fromArray(this.elements)}};ki.prototype.isMatrix3=!0;function Nfe(e){for(let t=e.length-1;t>=0;--t)if(e[t]>65535)return!0;return!1}var tfr={Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array};function B3(e,t){return new tfr[e](t)}function QP(e){return document.createElementNS("http://www.w3.org/1999/xhtml",e)}var Dfe={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074},nh={h:0,s:0,l:0},uV={h:0,s:0,l:0};function Wct(e,t,r){return r<0&&(r+=1),r>1&&(r-=1),r<1/6?e+(t-e)*6*r:r<1/2?t:r<2/3?e+(t-e)*6*(2/3-r):e}function U3(e){return e<.04045?e*.0773993808:Math.pow(e*.9478672986+.0521327014,2.4)}function Yct(e){return e<.0031308?e*12.92:1.055*Math.pow(e,.41666)-.055}var ne=class{constructor(t,r,n){return r===void 0&&n===void 0?this.set(t):this.setRGB(t,r,n)}set(t){return t&&t.isColor?this.copy(t):typeof t=="number"?this.setHex(t):typeof t=="string"&&this.setStyle(t),this}setScalar(t){return this.r=t,this.g=t,this.b=t,this}setHex(t){return t=Math.floor(t),this.r=(t>>16&255)/255,this.g=(t>>8&255)/255,this.b=(t&255)/255,this}setRGB(t,r,n){return this.r=t,this.g=r,this.b=n,this}setHSL(t,r,n){if(t=Nht(t,1),r=Zo(r,0,1),n=Zo(n,0,1),r===0)this.r=this.g=this.b=n;else{let i=n<=.5?n*(1+r):n+r-n*r,o=2*n-i;this.r=Wct(o,i,t+1/3),this.g=Wct(o,i,t),this.b=Wct(o,i,t-1/3)}return this}setStyle(t){function r(i){i!==void 0&&parseFloat(i)<1&&console.warn("THREE.Color: Alpha component of "+t+" will be ignored.")}let n;if(n=/^((?:rgb|hsl)a?)\(([^\)]*)\)/.exec(t)){let i,o=n[1],a=n[2];switch(o){case"rgb":case"rgba":if(i=/^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a))return this.r=Math.min(255,parseInt(i[1],10))/255,this.g=Math.min(255,parseInt(i[2],10))/255,this.b=Math.min(255,parseInt(i[3],10))/255,r(i[4]),this;if(i=/^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a))return this.r=Math.min(100,parseInt(i[1],10))/100,this.g=Math.min(100,parseInt(i[2],10))/100,this.b=Math.min(100,parseInt(i[3],10))/100,r(i[4]),this;break;case"hsl":case"hsla":if(i=/^\s*(\d*\.?\d+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a)){let s=parseFloat(i[1])/360,l=parseInt(i[2],10)/100,c=parseInt(i[3],10)/100;return r(i[4]),this.setHSL(s,l,c)}break}}else if(n=/^\#([A-Fa-f\d]+)$/.exec(t)){let i=n[1],o=i.length;if(o===3)return this.r=parseInt(i.charAt(0)+i.charAt(0),16)/255,this.g=parseInt(i.charAt(1)+i.charAt(1),16)/255,this.b=parseInt(i.charAt(2)+i.charAt(2),16)/255,this;if(o===6)return this.r=parseInt(i.charAt(0)+i.charAt(1),16)/255,this.g=parseInt(i.charAt(2)+i.charAt(3),16)/255,this.b=parseInt(i.charAt(4)+i.charAt(5),16)/255,this}return t&&t.length>0?this.setColorName(t):this}setColorName(t){let r=Dfe[t.toLowerCase()];return r!==void 0?this.setHex(r):console.warn("THREE.Color: Unknown color "+t),this}clone(){return new this.constructor(this.r,this.g,this.b)}copy(t){return this.r=t.r,this.g=t.g,this.b=t.b,this}copySRGBToLinear(t){return this.r=U3(t.r),this.g=U3(t.g),this.b=U3(t.b),this}copyLinearToSRGB(t){return this.r=Yct(t.r),this.g=Yct(t.g),this.b=Yct(t.b),this}convertSRGBToLinear(){return this.copySRGBToLinear(this),this}convertLinearToSRGB(){return this.copyLinearToSRGB(this),this}getHex(){return this.r*255<<16^this.g*255<<8^this.b*255<<0}getHexString(){return("000000"+this.getHex().toString(16)).slice(-6)}getHSL(t){let r=this.r,n=this.g,i=this.b,o=Math.max(r,n,i),a=Math.min(r,n,i),s,l,c=(a+o)/2;if(a===o)s=0,l=0;else{let u=o-a;switch(l=c<=.5?u/(o+a):u/(2-o-a),o){case r:s=(n-i)/u+(n<i?6:0);break;case n:s=(i-r)/u+2;break;case i:s=(r-n)/u+4;break}s/=6}return t.h=s,t.s=l,t.l=c,t}getStyle(){return"rgb("+(this.r*255|0)+","+(this.g*255|0)+","+(this.b*255|0)+")"}offsetHSL(t,r,n){return this.getHSL(nh),nh.h+=t,nh.s+=r,nh.l+=n,this.setHSL(nh.h,nh.s,nh.l),this}add(t){return this.r+=t.r,this.g+=t.g,this.b+=t.b,this}addColors(t,r){return this.r=t.r+r.r,this.g=t.g+r.g,this.b=t.b+r.b,this}addScalar(t){return this.r+=t,this.g+=t,this.b+=t,this}sub(t){return this.r=Math.max(0,this.r-t.r),this.g=Math.max(0,this.g-t.g),this.b=Math.max(0,this.b-t.b),this}multiply(t){return this.r*=t.r,this.g*=t.g,this.b*=t.b,this}multiplyScalar(t){return this.r*=t,this.g*=t,this.b*=t,this}lerp(t,r){return this.r+=(t.r-this.r)*r,this.g+=(t.g-this.g)*r,this.b+=(t.b-this.b)*r,this}lerpColors(t,r,n){return this.r=t.r+(r.r-t.r)*n,this.g=t.g+(r.g-t.g)*n,this.b=t.b+(r.b-t.b)*n,this}lerpHSL(t,r){this.getHSL(nh),t.getHSL(uV);let n=VP(nh.h,uV.h,r),i=VP(nh.s,uV.s,r),o=VP(nh.l,uV.l,r);return this.setHSL(n,i,o),this}equals(t){return t.r===this.r&&t.g===this.g&&t.b===this.b}fromArray(t,r=0){return this.r=t[r],this.g=t[r+1],this.b=t[r+2],this}toArray(t=[],r=0){return t[r]=this.r,t[r+1]=this.g,t[r+2]=this.b,t}fromBufferAttribute(t,r){return this.r=t.getX(r),this.g=t.getY(r),this.b=t.getZ(r),t.normalized===!0&&(this.r/=255,this.g/=255,this.b/=255),this}toJSON(){return this.getHex()}};ne.NAMES=Dfe;ne.prototype.isColor=!0;ne.prototype.r=1;ne.prototype.g=1;ne.prototype.b=1;var v3,Kf=class{static getDataURL(t){if(/^data:/i.test(t.src)||typeof HTMLCanvasElement=="undefined")return t.src;let r;if(t instanceof HTMLCanvasElement)r=t;else{v3===void 0&&(v3=QP("canvas")),v3.width=t.width,v3.height=t.height;let n=v3.getContext("2d");t instanceof ImageData?n.putImageData(t,0,0):n.drawImage(t,0,0,t.width,t.height),r=v3}return r.width>2048||r.height>2048?(console.warn("THREE.ImageUtils.getDataURL: Image converted to jpg for performance reasons",t),r.toDataURL("image/jpeg",.6)):r.toDataURL("image/png")}static sRGBToLinear(t){if(typeof HTMLImageElement!="undefined"&&t instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&t instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&t instanceof ImageBitmap){let r=QP("canvas");r.width=t.width,r.height=t.height;let n=r.getContext("2d");n.drawImage(t,0,0,t.width,t.height);let i=n.getImageData(0,0,t.width,t.height),o=i.data;for(let a=0;a<o.length;a++)o[a]=U3(o[a]/255)*255;return n.putImageData(i,0,0),r}else if(t.data){let r=t.data.slice(0);for(let n=0;n<r.length;n++)r instanceof Uint8Array||r instanceof Uint8ClampedArray?r[n]=Math.floor(U3(r[n]/255)*255):r[n]=U3(r[n]);return{data:r,width:t.width,height:t.height}}else return console.warn("THREE.ImageUtils.sRGBToLinear(): Unsupported image type. No color space conversion applied."),t}},efr=0,xi=class extends Us{constructor(t=xi.DEFAULT_IMAGE,r=xi.DEFAULT_MAPPING,n=Jo,i=Jo,o=oi,a=ox,s=Qo,l=Zd,c=1,u=Qd){super(),Object.defineProperty(this,"id",{value:efr++}),this.uuid=Nl(),this.name="",this.image=t,this.mipmaps=[],this.mapping=r,this.wrapS=n,this.wrapT=i,this.magFilter=o,this.minFilter=a,this.anisotropy=c,this.format=s,this.internalFormat=null,this.type=l,this.offset=new Lt(0,0),this.repeat=new Lt(1,1),this.center=new Lt(0,0),this.rotation=0,this.matrixAutoUpdate=!0,this.matrix=new ki,this.generateMipmaps=!0,this.premultiplyAlpha=!1,this.flipY=!0,this.unpackAlignment=4,this.encoding=u,this.userData={},this.version=0,this.onUpdate=null,this.isRenderTargetTexture=!1,this.needsPMREMUpdate=!1}updateMatrix(){this.matrix.setUvTransform(this.offset.x,this.offset.y,this.repeat.x,this.repeat.y,this.rotation,this.center.x,this.center.y)}clone(){return new this.constructor().copy(this)}copy(t){return this.name=t.name,this.image=t.image,this.mipmaps=t.mipmaps.slice(0),this.mapping=t.mapping,this.wrapS=t.wrapS,this.wrapT=t.wrapT,this.magFilter=t.magFilter,this.minFilter=t.minFilter,this.anisotropy=t.anisotropy,this.format=t.format,this.internalFormat=t.internalFormat,this.type=t.type,this.offset.copy(t.offset),this.repeat.copy(t.repeat),this.center.copy(t.center),this.rotation=t.rotation,this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrix.copy(t.matrix),this.generateMipmaps=t.generateMipmaps,this.premultiplyAlpha=t.premultiplyAlpha,this.flipY=t.flipY,this.unpackAlignment=t.unpackAlignment,this.encoding=t.encoding,this.userData=JSON.parse(JSON.stringify(t.userData)),this}toJSON(t){let r=t===void 0||typeof t=="string";if(!r&&t.textures[this.uuid]!==void 0)return t.textures[this.uuid];let n={metadata:{version:4.5,type:"Texture",generator:"Texture.toJSON"},uuid:this.uuid,name:this.name,mapping:this.mapping,repeat:[this.repeat.x,this.repeat.y],offset:[this.offset.x,this.offset.y],center:[this.center.x,this.center.y],rotation:this.rotation,wrap:[this.wrapS,this.wrapT],format:this.format,type:this.type,encoding:this.encoding,minFilter:this.minFilter,magFilter:this.magFilter,anisotropy:this.anisotropy,flipY:this.flipY,premultiplyAlpha:this.premultiplyAlpha,unpackAlignment:this.unpackAlignment};if(this.image!==void 0){let i=this.image;if(i.uuid===void 0&&(i.uuid=Nl()),!r&&t.images[i.uuid]===void 0){let o;if(Array.isArray(i)){o=[];for(let a=0,s=i.length;a<s;a++)i[a].isDataTexture?o.push(jct(i[a].image)):o.push(jct(i[a]))}else o=jct(i);t.images[i.uuid]={uuid:i.uuid,url:o}}n.image=i.uuid}return JSON.stringify(this.userData)!=="{}"&&(n.userData=this.userData),r||(t.textures[this.uuid]=n),n}dispose(){this.dispatchEvent({type:"dispose"})}transformUv(t){if(this.mapping!==jU)return t;if(t.applyMatrix3(this.matrix),t.x<0||t.x>1)switch(this.wrapS){case jP:t.x=t.x-Math.floor(t.x);break;case Jo:t.x=t.x<0?0:1;break;case XP:Math.abs(Math.floor(t.x)%2)===1?t.x=Math.ceil(t.x)-t.x:t.x=t.x-Math.floor(t.x);break}if(t.y<0||t.y>1)switch(this.wrapT){case jP:t.y=t.y-Math.floor(t.y);break;case Jo:t.y=t.y<0?0:1;break;case XP:Math.abs(Math.floor(t.y)%2)===1?t.y=Math.ceil(t.y)-t.y:t.y=t.y-Math.floor(t.y);break}return this.flipY&&(t.y=1-t.y),t}set needsUpdate(t){t===!0&&this.version++}};xi.DEFAULT_IMAGE=void 0;xi.DEFAULT_MAPPING=jU;xi.prototype.isTexture=!0;function jct(e){return typeof HTMLImageElement!="undefined"&&e instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&e instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&e instanceof ImageBitmap?Kf.getDataURL(e):e.data?{data:Array.prototype.slice.call(e.data),width:e.width,height:e.height,type:e.data.constructor.name}:(console.warn("THREE.Texture: Unable to serialize Texture."),{})}var en=class{constructor(t=0,r=0,n=0,i=1){this.x=t,this.y=r,this.z=n,this.w=i}get width(){return this.z}set width(t){this.z=t}get height(){return this.w}set height(t){this.w=t}set(t,r,n,i){return this.x=t,this.y=r,this.z=n,this.w=i,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this.w=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setW(t){return this.w=t,this}setComponent(t,r){switch(t){case 0:this.x=r;break;case 1:this.y=r;break;case 2:this.z=r;break;case 3:this.w=r;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;case 3:return this.w;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z,this.w)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this.w=t.w!==void 0?t.w:1,this}add(t,r){return r!==void 0?(console.warn("THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,r)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this.w+=t.w,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this.w+=t,this}addVectors(t,r){return this.x=t.x+r.x,this.y=t.y+r.y,this.z=t.z+r.z,this.w=t.w+r.w,this}addScaledVector(t,r){return this.x+=t.x*r,this.y+=t.y*r,this.z+=t.z*r,this.w+=t.w*r,this}sub(t,r){return r!==void 0?(console.warn("THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,r)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this.w-=t.w,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this.w-=t,this}subVectors(t,r){return this.x=t.x-r.x,this.y=t.y-r.y,this.z=t.z-r.z,this.w=t.w-r.w,this}multiply(t){return this.x*=t.x,this.y*=t.y,this.z*=t.z,this.w*=t.w,this}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this.w*=t,this}applyMatrix4(t){let r=this.x,n=this.y,i=this.z,o=this.w,a=t.elements;return this.x=a[0]*r+a[4]*n+a[8]*i+a[12]*o,this.y=a[1]*r+a[5]*n+a[9]*i+a[13]*o,this.z=a[2]*r+a[6]*n+a[10]*i+a[14]*o,this.w=a[3]*r+a[7]*n+a[11]*i+a[15]*o,this}divideScalar(t){return this.multiplyScalar(1/t)}setAxisAngleFromQuaternion(t){this.w=2*Math.acos(t.w);let r=Math.sqrt(1-t.w*t.w);return r<1e-4?(this.x=1,this.y=0,this.z=0):(this.x=t.x/r,this.y=t.y/r,this.z=t.z/r),this}setAxisAngleFromRotationMatrix(t){let r,n,i,o,l=t.elements,c=l[0],u=l[4],h=l[8],f=l[1],p=l[5],d=l[9],g=l[2],_=l[6],y=l[10];if(Math.abs(u-f)<.01&&Math.abs(h-g)<.01&&Math.abs(d-_)<.01){if(Math.abs(u+f)<.1&&Math.abs(h+g)<.1&&Math.abs(d+_)<.1&&Math.abs(c+p+y-3)<.1)return this.set(1,0,0,0),this;r=Math.PI;let b=(c+1)/2,S=(p+1)/2,C=(y+1)/2,P=(u+f)/4,k=(h+g)/4,O=(d+_)/4;return b>S&&b>C?b<.01?(n=0,i=.707106781,o=.707106781):(n=Math.sqrt(b),i=P/n,o=k/n):S>C?S<.01?(n=.707106781,i=0,o=.707106781):(i=Math.sqrt(S),n=P/i,o=O/i):C<.01?(n=.707106781,i=.707106781,o=0):(o=Math.sqrt(C),n=k/o,i=O/o),this.set(n,i,o,r),this}let x=Math.sqrt((_-d)*(_-d)+(h-g)*(h-g)+(f-u)*(f-u));return Math.abs(x)<.001&&(x=1),this.x=(_-d)/x,this.y=(h-g)/x,this.z=(f-u)/x,this.w=Math.acos((c+p+y-1)/2),this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this.w=Math.min(this.w,t.w),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this.w=Math.max(this.w,t.w),this}clamp(t,r){return this.x=Math.max(t.x,Math.min(r.x,this.x)),this.y=Math.max(t.y,Math.min(r.y,this.y)),this.z=Math.max(t.z,Math.min(r.z,this.z)),this.w=Math.max(t.w,Math.min(r.w,this.w)),this}clampScalar(t,r){return this.x=Math.max(t,Math.min(r,this.x)),this.y=Math.max(t,Math.min(r,this.y)),this.z=Math.max(t,Math.min(r,this.z)),this.w=Math.max(t,Math.min(r,this.w)),this}clampLength(t,r){let n=this.length();return this.divideScalar(n||1).multiplyScalar(Math.max(t,Math.min(r,n)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this.w=Math.floor(this.w),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this.w=Math.ceil(this.w),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this.w=Math.round(this.w),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this.w=this.w<0?Math.ceil(this.w):Math.floor(this.w),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this.w=-this.w,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z+this.w*t.w}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)+Math.abs(this.w)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,r){return this.x+=(t.x-this.x)*r,this.y+=(t.y-this.y)*r,this.z+=(t.z-this.z)*r,this.w+=(t.w-this.w)*r,this}lerpVectors(t,r,n){return this.x=t.x+(r.x-t.x)*n,this.y=t.y+(r.y-t.y)*n,this.z=t.z+(r.z-t.z)*n,this.w=t.w+(r.w-t.w)*n,this}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z&&t.w===this.w}fromArray(t,r=0){return this.x=t[r],this.y=t[r+1],this.z=t[r+2],this.w=t[r+3],this}toArray(t=[],r=0){return t[r]=this.x,t[r+1]=this.y,t[r+2]=this.z,t[r+3]=this.w,t}fromBufferAttribute(t,r,n){return n!==void 0&&console.warn("THREE.Vector4: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(r),this.y=t.getY(r),this.z=t.getZ(r),this.w=t.getW(r),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this.w=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z,yield this.w}};en.prototype.isVector4=!0;var us=class extends Us{constructor(t,r,n={}){super(),this.width=t,this.height=r,this.depth=1,this.scissor=new en(0,0,t,r),this.scissorTest=!1,this.viewport=new en(0,0,t,r),this.texture=new xi(void 0,n.mapping,n.wrapS,n.wrapT,n.magFilter,n.minFilter,n.format,n.type,n.anisotropy,n.encoding),this.texture.isRenderTargetTexture=!0,this.texture.image={width:t,height:r,depth:1},this.texture.generateMipmaps=n.generateMipmaps!==void 0?n.generateMipmaps:!1,this.texture.internalFormat=n.internalFormat!==void 0?n.internalFormat:null,this.texture.minFilter=n.minFilter!==void 0?n.minFilter:oi,this.depthBuffer=n.depthBuffer!==void 0?n.depthBuffer:!0,this.stencilBuffer=n.stencilBuffer!==void 0?n.stencilBuffer:!1,this.depthTexture=n.depthTexture!==void 0?n.depthTexture:null}setTexture(t){t.image={width:this.width,height:this.height,depth:this.depth},this.texture=t}setSize(t,r,n=1){(this.width!==t||this.height!==r||this.depth!==n)&&(this.width=t,this.height=r,this.depth=n,this.texture.image.width=t,this.texture.image.height=r,this.texture.image.depth=n,this.dispose()),this.viewport.set(0,0,t,r),this.scissor.set(0,0,t,r)}clone(){return new this.constructor().copy(this)}copy(t){return this.width=t.width,this.height=t.height,this.depth=t.depth,this.viewport.copy(t.viewport),this.texture=t.texture.clone(),this.texture.image=Object.assign({},t.texture.image),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this}dispose(){this.dispatchEvent({type:"dispose"})}};us.prototype.isWebGLRenderTarget=!0;var sU=class extends us{constructor(t,r,n){super(t,r);let i=this.texture;this.texture=[];for(let o=0;o<n;o++)this.texture[o]=i.clone()}setSize(t,r,n=1){if(this.width!==t||this.height!==r||this.depth!==n){this.width=t,this.height=r,this.depth=n;for(let i=0,o=this.texture.length;i<o;i++)this.texture[i].image.width=t,this.texture[i].image.height=r,this.texture[i].image.depth=n;this.dispose()}return this.viewport.set(0,0,t,r),this.scissor.set(0,0,t,r),this}copy(t){this.dispose(),this.width=t.width,this.height=t.height,this.depth=t.depth,this.viewport.set(0,0,this.width,this.height),this.scissor.set(0,0,this.width,this.height),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this.texture.length=0;for(let r=0,n=t.texture.length;r<n;r++)this.texture[r]=t.texture[r].clone();return this}};sU.prototype.isWebGLMultipleRenderTargets=!0;var j3=class extends us{constructor(t,r,n={}){super(t,r,n),this.samples=4,this.ignoreDepthForMultisampleCopy=n.ignoreDepth!==void 0?n.ignoreDepth:!0,this.useRenderToTexture=n.useRenderToTexture!==void 0?n.useRenderToTexture:!1,this.useRenderbuffer=this.useRenderToTexture===!1}copy(t){return super.copy.call(this,t),this.samples=t.samples,this.useRenderToTexture=t.useRenderToTexture,this.useRenderbuffer=t.useRenderbuffer,this}};j3.prototype.isWebGLMultisampleRenderTarget=!0;var vi=class{constructor(t=0,r=0,n=0,i=1){this._x=t,this._y=r,this._z=n,this._w=i}static slerp(t,r,n,i){return console.warn("THREE.Quaternion: Static .slerp() has been deprecated. Use qm.slerpQuaternions( qa, qb, t ) instead."),n.slerpQuaternions(t,r,i)}static slerpFlat(t,r,n,i,o,a,s){let l=n[i+0],c=n[i+1],u=n[i+2],h=n[i+3],f=o[a+0],p=o[a+1],d=o[a+2],g=o[a+3];if(s===0){t[r+0]=l,t[r+1]=c,t[r+2]=u,t[r+3]=h;return}if(s===1){t[r+0]=f,t[r+1]=p,t[r+2]=d,t[r+3]=g;return}if(h!==g||l!==f||c!==p||u!==d){let _=1-s,y=l*f+c*p+u*d+h*g,x=y>=0?1:-1,b=1-y*y;if(b>Number.EPSILON){let C=Math.sqrt(b),P=Math.atan2(C,y*x);_=Math.sin(_*P)/C,s=Math.sin(s*P)/C}let S=s*x;if(l=l*_+f*S,c=c*_+p*S,u=u*_+d*S,h=h*_+g*S,_===1-s){let C=1/Math.sqrt(l*l+c*c+u*u+h*h);l*=C,c*=C,u*=C,h*=C}}t[r]=l,t[r+1]=c,t[r+2]=u,t[r+3]=h}static multiplyQuaternionsFlat(t,r,n,i,o,a){let s=n[i],l=n[i+1],c=n[i+2],u=n[i+3],h=o[a],f=o[a+1],p=o[a+2],d=o[a+3];return t[r]=s*d+u*h+l*p-c*f,t[r+1]=l*d+u*f+c*h-s*p,t[r+2]=c*d+u*p+s*f-l*h,t[r+3]=u*d-s*h-l*f-c*p,t}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get w(){return this._w}set w(t){this._w=t,this._onChangeCallback()}set(t,r,n,i){return this._x=t,this._y=r,this._z=n,this._w=i,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._w)}copy(t){return this._x=t.x,this._y=t.y,this._z=t.z,this._w=t.w,this._onChangeCallback(),this}setFromEuler(t,r){if(!(t&&t.isEuler))throw new Error("THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.");let n=t._x,i=t._y,o=t._z,a=t._order,s=Math.cos,l=Math.sin,c=s(n/2),u=s(i/2),h=s(o/2),f=l(n/2),p=l(i/2),d=l(o/2);switch(a){case"XYZ":this._x=f*u*h+c*p*d,this._y=c*p*h-f*u*d,this._z=c*u*d+f*p*h,this._w=c*u*h-f*p*d;break;case"YXZ":this._x=f*u*h+c*p*d,this._y=c*p*h-f*u*d,this._z=c*u*d-f*p*h,this._w=c*u*h+f*p*d;break;case"ZXY":this._x=f*u*h-c*p*d,this._y=c*p*h+f*u*d,this._z=c*u*d+f*p*h,this._w=c*u*h-f*p*d;break;case"ZYX":this._x=f*u*h-c*p*d,this._y=c*p*h+f*u*d,this._z=c*u*d-f*p*h,this._w=c*u*h+f*p*d;break;case"YZX":this._x=f*u*h+c*p*d,this._y=c*p*h+f*u*d,this._z=c*u*d-f*p*h,this._w=c*u*h-f*p*d;break;case"XZY":this._x=f*u*h-c*p*d,this._y=c*p*h-f*u*d,this._z=c*u*d+f*p*h,this._w=c*u*h+f*p*d;break;default:console.warn("THREE.Quaternion: .setFromEuler() encountered an unknown order: "+a)}return r!==!1&&this._onChangeCallback(),this}setFromAxisAngle(t,r){let n=r/2,i=Math.sin(n);return this._x=t.x*i,this._y=t.y*i,this._z=t.z*i,this._w=Math.cos(n),this._onChangeCallback(),this}setFromRotationMatrix(t){let r=t.elements,n=r[0],i=r[4],o=r[8],a=r[1],s=r[5],l=r[9],c=r[2],u=r[6],h=r[10],f=n+s+h;if(f>0){let p=.5/Math.sqrt(f+1);this._w=.25/p,this._x=(u-l)*p,this._y=(o-c)*p,this._z=(a-i)*p}else if(n>s&&n>h){let p=2*Math.sqrt(1+n-s-h);this._w=(u-l)/p,this._x=.25*p,this._y=(i+a)/p,this._z=(o+c)/p}else if(s>h){let p=2*Math.sqrt(1+s-n-h);this._w=(o-c)/p,this._x=(i+a)/p,this._y=.25*p,this._z=(l+u)/p}else{let p=2*Math.sqrt(1+h-n-s);this._w=(a-i)/p,this._x=(o+c)/p,this._y=(l+u)/p,this._z=.25*p}return this._onChangeCallback(),this}setFromUnitVectors(t,r){let n=t.dot(r)+1;return n<Number.EPSILON?(n=0,Math.abs(t.x)>Math.abs(t.z)?(this._x=-t.y,this._y=t.x,this._z=0,this._w=n):(this._x=0,this._y=-t.z,this._z=t.y,this._w=n)):(this._x=t.y*r.z-t.z*r.y,this._y=t.z*r.x-t.x*r.z,this._z=t.x*r.y-t.y*r.x,this._w=n),this.normalize()}angleTo(t){return 2*Math.acos(Math.abs(Zo(this.dot(t),-1,1)))}rotateTowards(t,r){let n=this.angleTo(t);if(n===0)return this;let i=Math.min(1,r/n);return this.slerp(t,i),this}identity(){return this.set(0,0,0,1)}invert(){return this.conjugate()}conjugate(){return this._x*=-1,this._y*=-1,this._z*=-1,this._onChangeCallback(),this}dot(t){return this._x*t._x+this._y*t._y+this._z*t._z+this._w*t._w}lengthSq(){return this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w}length(){return Math.sqrt(this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w)}normalize(){let t=this.length();return t===0?(this._x=0,this._y=0,this._z=0,this._w=1):(t=1/t,this._x=this._x*t,this._y=this._y*t,this._z=this._z*t,this._w=this._w*t),this._onChangeCallback(),this}multiply(t,r){return r!==void 0?(console.warn("THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead."),this.multiplyQuaternions(t,r)):this.multiplyQuaternions(this,t)}premultiply(t){return this.multiplyQuaternions(t,this)}multiplyQuaternions(t,r){let n=t._x,i=t._y,o=t._z,a=t._w,s=r._x,l=r._y,c=r._z,u=r._w;return this._x=n*u+a*s+i*c-o*l,this._y=i*u+a*l+o*s-n*c,this._z=o*u+a*c+n*l-i*s,this._w=a*u-n*s-i*l-o*c,this._onChangeCallback(),this}slerp(t,r){if(r===0)return this;if(r===1)return this.copy(t);let n=this._x,i=this._y,o=this._z,a=this._w,s=a*t._w+n*t._x+i*t._y+o*t._z;if(s<0?(this._w=-t._w,this._x=-t._x,this._y=-t._y,this._z=-t._z,s=-s):this.copy(t),s>=1)return this._w=a,this._x=n,this._y=i,this._z=o,this;let l=1-s*s;if(l<=Number.EPSILON){let p=1-r;return this._w=p*a+r*this._w,this._x=p*n+r*this._x,this._y=p*i+r*this._y,this._z=p*o+r*this._z,this.normalize(),this._onChangeCallback(),this}let c=Math.sqrt(l),u=Math.atan2(c,s),h=Math.sin((1-r)*u)/c,f=Math.sin(r*u)/c;return this._w=a*h+this._w*f,this._x=n*h+this._x*f,this._y=i*h+this._y*f,this._z=o*h+this._z*f,this._onChangeCallback(),this}slerpQuaternions(t,r,n){return this.copy(t).slerp(r,n)}random(){let t=Math.random(),r=Math.sqrt(1-t),n=Math.sqrt(t),i=2*Math.PI*Math.random(),o=2*Math.PI*Math.random();return this.set(r*Math.cos(i),n*Math.sin(o),n*Math.cos(o),r*Math.sin(i))}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._w===this._w}fromArray(t,r=0){return this._x=t[r],this._y=t[r+1],this._z=t[r+2],this._w=t[r+3],this._onChangeCallback(),this}toArray(t=[],r=0){return t[r]=this._x,t[r+1]=this._y,t[r+2]=this._z,t[r+3]=this._w,t}fromBufferAttribute(t,r){return this._x=t.getX(r),this._y=t.getY(r),this._z=t.getZ(r),this._w=t.getW(r),this}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}};vi.prototype.isQuaternion=!0;var j=class{constructor(t=0,r=0,n=0){this.x=t,this.y=r,this.z=n}set(t,r,n){return n===void 0&&(n=this.z),this.x=t,this.y=r,this.z=n,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setComponent(t,r){switch(t){case 0:this.x=r;break;case 1:this.y=r;break;case 2:this.z=r;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this}add(t,r){return r!==void 0?(console.warn("THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,r)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this}addVectors(t,r){return this.x=t.x+r.x,this.y=t.y+r.y,this.z=t.z+r.z,this}addScaledVector(t,r){return this.x+=t.x*r,this.y+=t.y*r,this.z+=t.z*r,this}sub(t,r){return r!==void 0?(console.warn("THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,r)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this}subVectors(t,r){return this.x=t.x-r.x,this.y=t.y-r.y,this.z=t.z-r.z,this}multiply(t,r){return r!==void 0?(console.warn("THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead."),this.multiplyVectors(t,r)):(this.x*=t.x,this.y*=t.y,this.z*=t.z,this)}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this}multiplyVectors(t,r){return this.x=t.x*r.x,this.y=t.y*r.y,this.z=t.z*r.z,this}applyEuler(t){return t&&t.isEuler||console.error("THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order."),this.applyQuaternion(pue.setFromEuler(t))}applyAxisAngle(t,r){return this.applyQuaternion(pue.setFromAxisAngle(t,r))}applyMatrix3(t){let r=this.x,n=this.y,i=this.z,o=t.elements;return this.x=o[0]*r+o[3]*n+o[6]*i,this.y=o[1]*r+o[4]*n+o[7]*i,this.z=o[2]*r+o[5]*n+o[8]*i,this}applyNormalMatrix(t){return this.applyMatrix3(t).normalize()}applyMatrix4(t){let r=this.x,n=this.y,i=this.z,o=t.elements,a=1/(o[3]*r+o[7]*n+o[11]*i+o[15]);return this.x=(o[0]*r+o[4]*n+o[8]*i+o[12])*a,this.y=(o[1]*r+o[5]*n+o[9]*i+o[13])*a,this.z=(o[2]*r+o[6]*n+o[10]*i+o[14])*a,this}applyQuaternion(t){let r=this.x,n=this.y,i=this.z,o=t.x,a=t.y,s=t.z,l=t.w,c=l*r+a*i-s*n,u=l*n+s*r-o*i,h=l*i+o*n-a*r,f=-o*r-a*n-s*i;return this.x=c*l+f*-o+u*-s-h*-a,this.y=u*l+f*-a+h*-o-c*-s,this.z=h*l+f*-s+c*-a-u*-o,this}project(t){return this.applyMatrix4(t.matrixWorldInverse).applyMatrix4(t.projectionMatrix)}unproject(t){return this.applyMatrix4(t.projectionMatrixInverse).applyMatrix4(t.matrixWorld)}transformDirection(t){let r=this.x,n=this.y,i=this.z,o=t.elements;return this.x=o[0]*r+o[4]*n+o[8]*i,this.y=o[1]*r+o[5]*n+o[9]*i,this.z=o[2]*r+o[6]*n+o[10]*i,this.normalize()}divide(t){return this.x/=t.x,this.y/=t.y,this.z/=t.z,this}divideScalar(t){return this.multiplyScalar(1/t)}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this}clamp(t,r){return this.x=Math.max(t.x,Math.min(r.x,this.x)),this.y=Math.max(t.y,Math.min(r.y,this.y)),this.z=Math.max(t.z,Math.min(r.z,this.z)),this}clampScalar(t,r){return this.x=Math.max(t,Math.min(r,this.x)),this.y=Math.max(t,Math.min(r,this.y)),this.z=Math.max(t,Math.min(r,this.z)),this}clampLength(t,r){let n=this.length();return this.divideScalar(n||1).multiplyScalar(Math.max(t,Math.min(r,n)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,r){return this.x+=(t.x-this.x)*r,this.y+=(t.y-this.y)*r,this.z+=(t.z-this.z)*r,this}lerpVectors(t,r,n){return this.x=t.x+(r.x-t.x)*n,this.y=t.y+(r.y-t.y)*n,this.z=t.z+(r.z-t.z)*n,this}cross(t,r){return r!==void 0?(console.warn("THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead."),this.crossVectors(t,r)):this.crossVectors(this,t)}crossVectors(t,r){let n=t.x,i=t.y,o=t.z,a=r.x,s=r.y,l=r.z;return this.x=i*l-o*s,this.y=o*a-n*l,this.z=n*s-i*a,this}projectOnVector(t){let r=t.lengthSq();if(r===0)return this.set(0,0,0);let n=t.dot(this)/r;return this.copy(t).multiplyScalar(n)}projectOnPlane(t){return Xct.copy(this).projectOnVector(t),this.sub(Xct)}reflect(t){return this.sub(Xct.copy(t).multiplyScalar(2*this.dot(t)))}angleTo(t){let r=Math.sqrt(this.lengthSq()*t.lengthSq());if(r===0)return Math.PI/2;let n=this.dot(t)/r;return Math.acos(Zo(n,-1,1))}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){let r=this.x-t.x,n=this.y-t.y,i=this.z-t.z;return r*r+n*n+i*i}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)+Math.abs(this.z-t.z)}setFromSpherical(t){return this.setFromSphericalCoords(t.radius,t.phi,t.theta)}setFromSphericalCoords(t,r,n){let i=Math.sin(r)*t;return this.x=i*Math.sin(n),this.y=Math.cos(r)*t,this.z=i*Math.cos(n),this}setFromCylindrical(t){return this.setFromCylindricalCoords(t.radius,t.theta,t.y)}setFromCylindricalCoords(t,r,n){return this.x=t*Math.sin(r),this.y=n,this.z=t*Math.cos(r),this}setFromMatrixPosition(t){let r=t.elements;return this.x=r[12],this.y=r[13],this.z=r[14],this}setFromMatrixScale(t){let r=this.setFromMatrixColumn(t,0).length(),n=this.setFromMatrixColumn(t,1).length(),i=this.setFromMatrixColumn(t,2).length();return this.x=r,this.y=n,this.z=i,this}setFromMatrixColumn(t,r){return this.fromArray(t.elements,r*4)}setFromMatrix3Column(t,r){return this.fromArray(t.elements,r*3)}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z}fromArray(t,r=0){return this.x=t[r],this.y=t[r+1],this.z=t[r+2],this}toArray(t=[],r=0){return t[r]=this.x,t[r+1]=this.y,t[r+2]=this.z,t}fromBufferAttribute(t,r,n){return n!==void 0&&console.warn("THREE.Vector3: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(r),this.y=t.getY(r),this.z=t.getZ(r),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this}randomDirection(){let t=(Math.random()-.5)*2,r=Math.random()*Math.PI*2,n=Math.sqrt(1-EI(t,2));return this.x=n*Math.cos(r),this.y=n*Math.sin(r),this.z=t,this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z}};j.prototype.isVector3=!0;var Xct=new j,pue=new vi,ta=class{constructor(t=new j(1/0,1/0,1/0),r=new j(-1/0,-1/0,-1/0)){this.min=t,this.max=r}set(t,r){return this.min.copy(t),this.max.copy(r),this}setFromArray(t){let r=1/0,n=1/0,i=1/0,o=-1/0,a=-1/0,s=-1/0;for(let l=0,c=t.length;l<c;l+=3){let u=t[l],h=t[l+1],f=t[l+2];u<r&&(r=u),h<n&&(n=h),f<i&&(i=f),u>o&&(o=u),h>a&&(a=h),f>s&&(s=f)}return this.min.set(r,n,i),this.max.set(o,a,s),this}setFromBufferAttribute(t){let r=1/0,n=1/0,i=1/0,o=-1/0,a=-1/0,s=-1/0;for(let l=0,c=t.count;l<c;l++){let u=t.getX(l),h=t.getY(l),f=t.getZ(l);u<r&&(r=u),h<n&&(n=h),f<i&&(i=f),u>o&&(o=u),h>a&&(a=h),f>s&&(s=f)}return this.min.set(r,n,i),this.max.set(o,a,s),this}setFromPoints(t){this.makeEmpty();for(let r=0,n=t.length;r<n;r++)this.expandByPoint(t[r]);return this}setFromCenterAndSize(t,r){let n=mv.copy(r).multiplyScalar(.5);return this.min.copy(t).sub(n),this.max.copy(t).add(n),this}setFromObject(t,r=!1){return this.makeEmpty(),this.expandByObject(t,r)}clone(){return new this.constructor().copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=this.min.z=1/0,this.max.x=this.max.y=this.max.z=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y||this.max.z<this.min.z}getCenter(t){return this.isEmpty()?t.set(0,0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return this.isEmpty()?t.set(0,0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}expandByObject(t,r=!1){t.updateWorldMatrix(!1,!1);let n=t.geometry;if(n!==void 0)if(r&&n.attributes!=null&&n.attributes.position!==void 0){let o=n.attributes.position;for(let a=0,s=o.count;a<s;a++)mv.fromBufferAttribute(o,a).applyMatrix4(t.matrixWorld),this.expandByPoint(mv)}else n.boundingBox===null&&n.computeBoundingBox(),$ct.copy(n.boundingBox),$ct.applyMatrix4(t.matrixWorld),this.union($ct);let i=t.children;for(let o=0,a=i.length;o<a;o++)this.expandByObject(i[o],r);return this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y||t.z<this.min.z||t.z>this.max.z)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y&&this.min.z<=t.min.z&&t.max.z<=this.max.z}getParameter(t,r){return r.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y),(t.z-this.min.z)/(this.max.z-this.min.z))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y||t.max.z<this.min.z||t.min.z>this.max.z)}intersectsSphere(t){return this.clampPoint(t.center,mv),mv.distanceToSquared(t.center)<=t.radius*t.radius}intersectsPlane(t){let r,n;return t.normal.x>0?(r=t.normal.x*this.min.x,n=t.normal.x*this.max.x):(r=t.normal.x*this.max.x,n=t.normal.x*this.min.x),t.normal.y>0?(r+=t.normal.y*this.min.y,n+=t.normal.y*this.max.y):(r+=t.normal.y*this.max.y,n+=t.normal.y*this.min.y),t.normal.z>0?(r+=t.normal.z*this.min.z,n+=t.normal.z*this.max.z):(r+=t.normal.z*this.max.z,n+=t.normal.z*this.min.z),r<=-t.constant&&n>=-t.constant}intersectsTriangle(t){if(this.isEmpty())return!1;this.getCenter(IP),hV.subVectors(this.max,IP),x3.subVectors(t.a,IP),b3.subVectors(t.b,IP),w3.subVectors(t.c,IP),P0.subVectors(b3,x3),I0.subVectors(w3,b3),gv.subVectors(x3,w3);let r=[0,-P0.z,P0.y,0,-I0.z,I0.y,0,-gv.z,gv.y,P0.z,0,-P0.x,I0.z,0,-I0.x,gv.z,0,-gv.x,-P0.y,P0.x,0,-I0.y,I0.x,0,-gv.y,gv.x,0];return!Kct(r,x3,b3,w3,hV)||(r=[1,0,0,0,1,0,0,0,1],!Kct(r,x3,b3,w3,hV))?!1:(fV.crossVectors(P0,I0),r=[fV.x,fV.y,fV.z],Kct(r,x3,b3,w3,hV))}clampPoint(t,r){return r.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return mv.copy(t).clamp(this.min,this.max).sub(t).length()}getBoundingSphere(t){return this.getCenter(t.center),t.radius=this.getSize(mv).length()*.5,t}intersect(t){return this.min.max(t.min),this.max.min(t.max),this.isEmpty()&&this.makeEmpty(),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}applyMatrix4(t){return this.isEmpty()?this:(Vd[0].set(this.min.x,this.min.y,this.min.z).applyMatrix4(t),Vd[1].set(this.min.x,this.min.y,this.max.z).applyMatrix4(t),Vd[2].set(this.min.x,this.max.y,this.min.z).applyMatrix4(t),Vd[3].set(this.min.x,this.max.y,this.max.z).applyMatrix4(t),Vd[4].set(this.max.x,this.min.y,this.min.z).applyMatrix4(t),Vd[5].set(this.max.x,this.min.y,this.max.z).applyMatrix4(t),Vd[6].set(this.max.x,this.max.y,this.min.z).applyMatrix4(t),Vd[7].set(this.max.x,this.max.y,this.max.z).applyMatrix4(t),this.setFromPoints(Vd),this)}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}};ta.prototype.isBox3=!0;var Vd=[new j,new j,new j,new j,new j,new j,new j,new j],mv=new j,$ct=new ta,x3=new j,b3=new j,w3=new j,P0=new j,I0=new j,gv=new j,IP=new j,hV=new j,fV=new j,_v=new j;function Kct(e,t,r,n,i){for(let o=0,a=e.length-3;o<=a;o+=3){_v.fromArray(e,o);let s=i.x*Math.abs(_v.x)+i.y*Math.abs(_v.y)+i.z*Math.abs(_v.z),l=t.dot(_v),c=r.dot(_v),u=n.dot(_v);if(Math.max(-Math.max(l,c,u),Math.min(l,c,u))>s)return!1}return!0}var rfr=new ta,due=new j,pV=new j,Zct=new j,Zf=class{constructor(t=new j,r=-1){this.center=t,this.radius=r}set(t,r){return this.center.copy(t),this.radius=r,this}setFromPoints(t,r){let n=this.center;r!==void 0?n.copy(r):rfr.setFromPoints(t).getCenter(n);let i=0;for(let o=0,a=t.length;o<a;o++)i=Math.max(i,n.distanceToSquared(t[o]));return this.radius=Math.sqrt(i),this}copy(t){return this.center.copy(t.center),this.radius=t.radius,this}isEmpty(){return this.radius<0}makeEmpty(){return this.center.set(0,0,0),this.radius=-1,this}containsPoint(t){return t.distanceToSquared(this.center)<=this.radius*this.radius}distanceToPoint(t){return t.distanceTo(this.center)-this.radius}intersectsSphere(t){let r=this.radius+t.radius;return t.center.distanceToSquared(this.center)<=r*r}intersectsBox(t){return t.intersectsSphere(this)}intersectsPlane(t){return Math.abs(t.distanceToPoint(this.center))<=this.radius}clampPoint(t,r){let n=this.center.distanceToSquared(t);return r.copy(t),n>this.radius*this.radius&&(r.sub(this.center).normalize(),r.multiplyScalar(this.radius).add(this.center)),r}getBoundingBox(t){return this.isEmpty()?(t.makeEmpty(),t):(t.set(this.center,this.center),t.expandByScalar(this.radius),t)}applyMatrix4(t){return this.center.applyMatrix4(t),this.radius=this.radius*t.getMaxScaleOnAxis(),this}translate(t){return this.center.add(t),this}expandByPoint(t){Zct.subVectors(t,this.center);let r=Zct.lengthSq();if(r>this.radius*this.radius){let n=Math.sqrt(r),i=(n-this.radius)*.5;this.center.add(Zct.multiplyScalar(i/n)),this.radius+=i}return this}union(t){return this.center.equals(t.center)===!0?pV.set(0,0,1).multiplyScalar(t.radius):pV.subVectors(t.center,this.center).normalize().multiplyScalar(t.radius),this.expandByPoint(due.copy(t.center).add(pV)),this.expandByPoint(due.copy(t.center).sub(pV)),this}equals(t){return t.center.equals(this.center)&&t.radius===this.radius}clone(){return new this.constructor().copy(this)}},Ud=new j,Jct=new j,dV=new j,L0=new j,Qct=new j,mV=new j,tut=new j,Jf=class{constructor(t=new j,r=new j(0,0,-1)){this.origin=t,this.direction=r}set(t,r){return this.origin.copy(t),this.direction.copy(r),this}copy(t){return this.origin.copy(t.origin),this.direction.copy(t.direction),this}at(t,r){return r.copy(this.direction).multiplyScalar(t).add(this.origin)}lookAt(t){return this.direction.copy(t).sub(this.origin).normalize(),this}recast(t){return this.origin.copy(this.at(t,Ud)),this}closestPointToPoint(t,r){r.subVectors(t,this.origin);let n=r.dot(this.direction);return n<0?r.copy(this.origin):r.copy(this.direction).multiplyScalar(n).add(this.origin)}distanceToPoint(t){return Math.sqrt(this.distanceSqToPoint(t))}distanceSqToPoint(t){let r=Ud.subVectors(t,this.origin).dot(this.direction);return r<0?this.origin.distanceToSquared(t):(Ud.copy(this.direction).multiplyScalar(r).add(this.origin),Ud.distanceToSquared(t))}distanceSqToSegment(t,r,n,i){Jct.copy(t).add(r).multiplyScalar(.5),dV.copy(r).sub(t).normalize(),L0.copy(this.origin).sub(Jct);let o=t.distanceTo(r)*.5,a=-this.direction.dot(dV),s=L0.dot(this.direction),l=-L0.dot(dV),c=L0.lengthSq(),u=Math.abs(1-a*a),h,f,p,d;if(u>0)if(h=a*l-s,f=a*s-l,d=o*u,h>=0)if(f>=-d)if(f<=d){let g=1/u;h*=g,f*=g,p=h*(h+a*f+2*s)+f*(a*h+f+2*l)+c}else f=o,h=Math.max(0,-(a*f+s)),p=-h*h+f*(f+2*l)+c;else f=-o,h=Math.max(0,-(a*f+s)),p=-h*h+f*(f+2*l)+c;else f<=-d?(h=Math.max(0,-(-a*o+s)),f=h>0?-o:Math.min(Math.max(-o,-l),o),p=-h*h+f*(f+2*l)+c):f<=d?(h=0,f=Math.min(Math.max(-o,-l),o),p=f*(f+2*l)+c):(h=Math.max(0,-(a*o+s)),f=h>0?o:Math.min(Math.max(-o,-l),o),p=-h*h+f*(f+2*l)+c);else f=a>0?-o:o,h=Math.max(0,-(a*f+s)),p=-h*h+f*(f+2*l)+c;return n&&n.copy(this.direction).multiplyScalar(h).add(this.origin),i&&i.copy(dV).multiplyScalar(f).add(Jct),p}intersectSphere(t,r){Ud.subVectors(t.center,this.origin);let n=Ud.dot(this.direction),i=Ud.dot(Ud)-n*n,o=t.radius*t.radius;if(i>o)return null;let a=Math.sqrt(o-i),s=n-a,l=n+a;return s<0&&l<0?null:s<0?this.at(l,r):this.at(s,r)}intersectsSphere(t){return this.distanceSqToPoint(t.center)<=t.radius*t.radius}distanceToPlane(t){let r=t.normal.dot(this.direction);if(r===0)return t.distanceToPoint(this.origin)===0?0:null;let n=-(this.origin.dot(t.normal)+t.constant)/r;return n>=0?n:null}intersectPlane(t,r){let n=this.distanceToPlane(t);return n===null?null:this.at(n,r)}intersectsPlane(t){let r=t.distanceToPoint(this.origin);return r===0||t.normal.dot(this.direction)*r<0}intersectBox(t,r){let n,i,o,a,s,l,c=1/this.direction.x,u=1/this.direction.y,h=1/this.direction.z,f=this.origin;return c>=0?(n=(t.min.x-f.x)*c,i=(t.max.x-f.x)*c):(n=(t.max.x-f.x)*c,i=(t.min.x-f.x)*c),u>=0?(o=(t.min.y-f.y)*u,a=(t.max.y-f.y)*u):(o=(t.max.y-f.y)*u,a=(t.min.y-f.y)*u),n>a||o>i||((o>n||n!==n)&&(n=o),(a<i||i!==i)&&(i=a),h>=0?(s=(t.min.z-f.z)*h,l=(t.max.z-f.z)*h):(s=(t.max.z-f.z)*h,l=(t.min.z-f.z)*h),n>l||s>i)||((s>n||n!==n)&&(n=s),(l<i||i!==i)&&(i=l),i<0)?null:this.at(n>=0?n:i,r)}intersectsBox(t){return this.intersectBox(t,Ud)!==null}intersectTriangle(t,r,n,i,o){Qct.subVectors(r,t),mV.subVectors(n,t),tut.crossVectors(Qct,mV);let a=this.direction.dot(tut),s;if(a>0){if(i)return null;s=1}else if(a<0)s=-1,a=-a;else return null;L0.subVectors(this.origin,t);let l=s*this.direction.dot(mV.crossVectors(L0,mV));if(l<0)return null;let c=s*this.direction.dot(Qct.cross(L0));if(c<0||l+c>a)return null;let u=-s*L0.dot(tut);return u<0?null:this.at(u/a,o)}applyMatrix4(t){return this.origin.applyMatrix4(t),this.direction.transformDirection(t),this}equals(t){return t.origin.equals(this.origin)&&t.direction.equals(this.direction)}clone(){return new this.constructor().copy(this)}},Me=class{constructor(){this.elements=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.")}set(t,r,n,i,o,a,s,l,c,u,h,f,p,d,g,_){let y=this.elements;return y[0]=t,y[4]=r,y[8]=n,y[12]=i,y[1]=o,y[5]=a,y[9]=s,y[13]=l,y[2]=c,y[6]=u,y[10]=h,y[14]=f,y[3]=p,y[7]=d,y[11]=g,y[15]=_,this}identity(){return this.set(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1),this}clone(){return new Me().fromArray(this.elements)}copy(t){let r=this.elements,n=t.elements;return r[0]=n[0],r[1]=n[1],r[2]=n[2],r[3]=n[3],r[4]=n[4],r[5]=n[5],r[6]=n[6],r[7]=n[7],r[8]=n[8],r[9]=n[9],r[10]=n[10],r[11]=n[11],r[12]=n[12],r[13]=n[13],r[14]=n[14],r[15]=n[15],this}copyPosition(t){let r=this.elements,n=t.elements;return r[12]=n[12],r[13]=n[13],r[14]=n[14],this}setFromMatrix3(t){let r=t.elements;return this.set(r[0],r[3],r[6],0,r[1],r[4],r[7],0,r[2],r[5],r[8],0,0,0,0,1),this}extractBasis(t,r,n){return t.setFromMatrixColumn(this,0),r.setFromMatrixColumn(this,1),n.setFromMatrixColumn(this,2),this}makeBasis(t,r,n){return this.set(t.x,r.x,n.x,0,t.y,r.y,n.y,0,t.z,r.z,n.z,0,0,0,0,1),this}extractRotation(t){let r=this.elements,n=t.elements,i=1/S3.setFromMatrixColumn(t,0).length(),o=1/S3.setFromMatrixColumn(t,1).length(),a=1/S3.setFromMatrixColumn(t,2).length();return r[0]=n[0]*i,r[1]=n[1]*i,r[2]=n[2]*i,r[3]=0,r[4]=n[4]*o,r[5]=n[5]*o,r[6]=n[6]*o,r[7]=0,r[8]=n[8]*a,r[9]=n[9]*a,r[10]=n[10]*a,r[11]=0,r[12]=0,r[13]=0,r[14]=0,r[15]=1,this}makeRotationFromEuler(t){t&&t.isEuler||console.error("THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.");let r=this.elements,n=t.x,i=t.y,o=t.z,a=Math.cos(n),s=Math.sin(n),l=Math.cos(i),c=Math.sin(i),u=Math.cos(o),h=Math.sin(o);if(t.order==="XYZ"){let f=a*u,p=a*h,d=s*u,g=s*h;r[0]=l*u,r[4]=-l*h,r[8]=c,r[1]=p+d*c,r[5]=f-g*c,r[9]=-s*l,r[2]=g-f*c,r[6]=d+p*c,r[10]=a*l}else if(t.order==="YXZ"){let f=l*u,p=l*h,d=c*u,g=c*h;r[0]=f+g*s,r[4]=d*s-p,r[8]=a*c,r[1]=a*h,r[5]=a*u,r[9]=-s,r[2]=p*s-d,r[6]=g+f*s,r[10]=a*l}else if(t.order==="ZXY"){let f=l*u,p=l*h,d=c*u,g=c*h;r[0]=f-g*s,r[4]=-a*h,r[8]=d+p*s,r[1]=p+d*s,r[5]=a*u,r[9]=g-f*s,r[2]=-a*c,r[6]=s,r[10]=a*l}else if(t.order==="ZYX"){let f=a*u,p=a*h,d=s*u,g=s*h;r[0]=l*u,r[4]=d*c-p,r[8]=f*c+g,r[1]=l*h,r[5]=g*c+f,r[9]=p*c-d,r[2]=-c,r[6]=s*l,r[10]=a*l}else if(t.order==="YZX"){let f=a*l,p=a*c,d=s*l,g=s*c;r[0]=l*u,r[4]=g-f*h,r[8]=d*h+p,r[1]=h,r[5]=a*u,r[9]=-s*u,r[2]=-c*u,r[6]=p*h+d,r[10]=f-g*h}else if(t.order==="XZY"){let f=a*l,p=a*c,d=s*l,g=s*c;r[0]=l*u,r[4]=-h,r[8]=c*u,r[1]=f*h+g,r[5]=a*u,r[9]=p*h-d,r[2]=d*h-p,r[6]=s*u,r[10]=g*h+f}return r[3]=0,r[7]=0,r[11]=0,r[12]=0,r[13]=0,r[14]=0,r[15]=1,this}makeRotationFromQuaternion(t){return this.compose(nfr,t,ifr)}lookAt(t,r,n){let i=this.elements;return kl.subVectors(t,r),kl.lengthSq()===0&&(kl.z=1),kl.normalize(),k0.crossVectors(n,kl),k0.lengthSq()===0&&(Math.abs(n.z)===1?kl.x+=1e-4:kl.z+=1e-4,kl.normalize(),k0.crossVectors(n,kl)),k0.normalize(),gV.crossVectors(kl,k0),i[0]=k0.x,i[4]=gV.x,i[8]=kl.x,i[1]=k0.y,i[5]=gV.y,i[9]=kl.y,i[2]=k0.z,i[6]=gV.z,i[10]=kl.z,this}multiply(t,r){return r!==void 0?(console.warn("THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead."),this.multiplyMatrices(t,r)):this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,r){let n=t.elements,i=r.elements,o=this.elements,a=n[0],s=n[4],l=n[8],c=n[12],u=n[1],h=n[5],f=n[9],p=n[13],d=n[2],g=n[6],_=n[10],y=n[14],x=n[3],b=n[7],S=n[11],C=n[15],P=i[0],k=i[4],O=i[8],D=i[12],B=i[1],I=i[5],L=i[9],R=i[13],F=i[2],z=i[6],U=i[10],W=i[14],Z=i[3],rt=i[7],ot=i[11],st=i[15];return o[0]=a*P+s*B+l*F+c*Z,o[4]=a*k+s*I+l*z+c*rt,o[8]=a*O+s*L+l*U+c*ot,o[12]=a*D+s*R+l*W+c*st,o[1]=u*P+h*B+f*F+p*Z,o[5]=u*k+h*I+f*z+p*rt,o[9]=u*O+h*L+f*U+p*ot,o[13]=u*D+h*R+f*W+p*st,o[2]=d*P+g*B+_*F+y*Z,o[6]=d*k+g*I+_*z+y*rt,o[10]=d*O+g*L+_*U+y*ot,o[14]=d*D+g*R+_*W+y*st,o[3]=x*P+b*B+S*F+C*Z,o[7]=x*k+b*I+S*z+C*rt,o[11]=x*O+b*L+S*U+C*ot,o[15]=x*D+b*R+S*W+C*st,this}multiplyScalar(t){let r=this.elements;return r[0]*=t,r[4]*=t,r[8]*=t,r[12]*=t,r[1]*=t,r[5]*=t,r[9]*=t,r[13]*=t,r[2]*=t,r[6]*=t,r[10]*=t,r[14]*=t,r[3]*=t,r[7]*=t,r[11]*=t,r[15]*=t,this}determinant(){let t=this.elements,r=t[0],n=t[4],i=t[8],o=t[12],a=t[1],s=t[5],l=t[9],c=t[13],u=t[2],h=t[6],f=t[10],p=t[14],d=t[3],g=t[7],_=t[11],y=t[15];return d*(+o*l*h-i*c*h-o*s*f+n*c*f+i*s*p-n*l*p)+g*(+r*l*p-r*c*f+o*a*f-i*a*p+i*c*u-o*l*u)+_*(+r*c*h-r*s*p-o*a*h+n*a*p+o*s*u-n*c*u)+y*(-i*s*u-r*l*h+r*s*f+i*a*h-n*a*f+n*l*u)}transpose(){let t=this.elements,r;return r=t[1],t[1]=t[4],t[4]=r,r=t[2],t[2]=t[8],t[8]=r,r=t[6],t[6]=t[9],t[9]=r,r=t[3],t[3]=t[12],t[12]=r,r=t[7],t[7]=t[13],t[13]=r,r=t[11],t[11]=t[14],t[14]=r,this}setPosition(t,r,n){let i=this.elements;return t.isVector3?(i[12]=t.x,i[13]=t.y,i[14]=t.z):(i[12]=t,i[13]=r,i[14]=n),this}invert(){let t=this.elements,r=t[0],n=t[1],i=t[2],o=t[3],a=t[4],s=t[5],l=t[6],c=t[7],u=t[8],h=t[9],f=t[10],p=t[11],d=t[12],g=t[13],_=t[14],y=t[15],x=h*_*c-g*f*c+g*l*p-s*_*p-h*l*y+s*f*y,b=d*f*c-u*_*c-d*l*p+a*_*p+u*l*y-a*f*y,S=u*g*c-d*h*c+d*s*p-a*g*p-u*s*y+a*h*y,C=d*h*l-u*g*l-d*s*f+a*g*f+u*s*_-a*h*_,P=r*x+n*b+i*S+o*C;if(P===0)return this.set(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);let k=1/P;return t[0]=x*k,t[1]=(g*f*o-h*_*o-g*i*p+n*_*p+h*i*y-n*f*y)*k,t[2]=(s*_*o-g*l*o+g*i*c-n*_*c-s*i*y+n*l*y)*k,t[3]=(h*l*o-s*f*o-h*i*c+n*f*c+s*i*p-n*l*p)*k,t[4]=b*k,t[5]=(u*_*o-d*f*o+d*i*p-r*_*p-u*i*y+r*f*y)*k,t[6]=(d*l*o-a*_*o-d*i*c+r*_*c+a*i*y-r*l*y)*k,t[7]=(a*f*o-u*l*o+u*i*c-r*f*c-a*i*p+r*l*p)*k,t[8]=S*k,t[9]=(d*h*o-u*g*o-d*n*p+r*g*p+u*n*y-r*h*y)*k,t[10]=(a*g*o-d*s*o+d*n*c-r*g*c-a*n*y+r*s*y)*k,t[11]=(u*s*o-a*h*o-u*n*c+r*h*c+a*n*p-r*s*p)*k,t[12]=C*k,t[13]=(u*g*i-d*h*i+d*n*f-r*g*f-u*n*_+r*h*_)*k,t[14]=(d*s*i-a*g*i-d*n*l+r*g*l+a*n*_-r*s*_)*k,t[15]=(a*h*i-u*s*i+u*n*l-r*h*l-a*n*f+r*s*f)*k,this}scale(t){let r=this.elements,n=t.x,i=t.y,o=t.z;return r[0]*=n,r[4]*=i,r[8]*=o,r[1]*=n,r[5]*=i,r[9]*=o,r[2]*=n,r[6]*=i,r[10]*=o,r[3]*=n,r[7]*=i,r[11]*=o,this}getMaxScaleOnAxis(){let t=this.elements,r=t[0]*t[0]+t[1]*t[1]+t[2]*t[2],n=t[4]*t[4]+t[5]*t[5]+t[6]*t[6],i=t[8]*t[8]+t[9]*t[9]+t[10]*t[10];return Math.sqrt(Math.max(r,n,i))}makeTranslation(t,r,n){return this.set(1,0,0,t,0,1,0,r,0,0,1,n,0,0,0,1),this}makeRotationX(t){let r=Math.cos(t),n=Math.sin(t);return this.set(1,0,0,0,0,r,-n,0,0,n,r,0,0,0,0,1),this}makeRotationY(t){let r=Math.cos(t),n=Math.sin(t);return this.set(r,0,n,0,0,1,0,0,-n,0,r,0,0,0,0,1),this}makeRotationZ(t){let r=Math.cos(t),n=Math.sin(t);return this.set(r,-n,0,0,n,r,0,0,0,0,1,0,0,0,0,1),this}makeRotationAxis(t,r){let n=Math.cos(r),i=Math.sin(r),o=1-n,a=t.x,s=t.y,l=t.z,c=o*a,u=o*s;return this.set(c*a+n,c*s-i*l,c*l+i*s,0,c*s+i*l,u*s+n,u*l-i*a,0,c*l-i*s,u*l+i*a,o*l*l+n,0,0,0,0,1),this}makeScale(t,r,n){return this.set(t,0,0,0,0,r,0,0,0,0,n,0,0,0,0,1),this}makeShear(t,r,n,i,o,a){return this.set(1,n,o,0,t,1,a,0,r,i,1,0,0,0,0,1),this}compose(t,r,n){let i=this.elements,o=r._x,a=r._y,s=r._z,l=r._w,c=o+o,u=a+a,h=s+s,f=o*c,p=o*u,d=o*h,g=a*u,_=a*h,y=s*h,x=l*c,b=l*u,S=l*h,C=n.x,P=n.y,k=n.z;return i[0]=(1-(g+y))*C,i[1]=(p+S)*C,i[2]=(d-b)*C,i[3]=0,i[4]=(p-S)*P,i[5]=(1-(f+y))*P,i[6]=(_+x)*P,i[7]=0,i[8]=(d+b)*k,i[9]=(_-x)*k,i[10]=(1-(f+g))*k,i[11]=0,i[12]=t.x,i[13]=t.y,i[14]=t.z,i[15]=1,this}decompose(t,r,n){let i=this.elements,o=S3.set(i[0],i[1],i[2]).length(),a=S3.set(i[4],i[5],i[6]).length(),s=S3.set(i[8],i[9],i[10]).length();this.determinant()<0&&(o=-o),t.x=i[12],t.y=i[13],t.z=i[14],ih.copy(this);let c=1/o,u=1/a,h=1/s;return ih.elements[0]*=c,ih.elements[1]*=c,ih.elements[2]*=c,ih.elements[4]*=u,ih.elements[5]*=u,ih.elements[6]*=u,ih.elements[8]*=h,ih.elements[9]*=h,ih.elements[10]*=h,r.setFromRotationMatrix(ih),n.x=o,n.y=a,n.z=s,this}makePerspective(t,r,n,i,o,a){a===void 0&&console.warn("THREE.Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.");let s=this.elements,l=2*o/(r-t),c=2*o/(n-i),u=(r+t)/(r-t),h=(n+i)/(n-i),f=-(a+o)/(a-o),p=-2*a*o/(a-o);return s[0]=l,s[4]=0,s[8]=u,s[12]=0,s[1]=0,s[5]=c,s[9]=h,s[13]=0,s[2]=0,s[6]=0,s[10]=f,s[14]=p,s[3]=0,s[7]=0,s[11]=-1,s[15]=0,this}makeOrthographic(t,r,n,i,o,a){let s=this.elements,l=1/(r-t),c=1/(n-i),u=1/(a-o),h=(r+t)*l,f=(n+i)*c,p=(a+o)*u;return s[0]=2*l,s[4]=0,s[8]=0,s[12]=-h,s[1]=0,s[5]=2*c,s[9]=0,s[13]=-f,s[2]=0,s[6]=0,s[10]=-2*u,s[14]=-p,s[3]=0,s[7]=0,s[11]=0,s[15]=1,this}equals(t){let r=this.elements,n=t.elements;for(let i=0;i<16;i++)if(r[i]!==n[i])return!1;return!0}fromArray(t,r=0){for(let n=0;n<16;n++)this.elements[n]=t[n+r];return this}toArray(t=[],r=0){let n=this.elements;return t[r]=n[0],t[r+1]=n[1],t[r+2]=n[2],t[r+3]=n[3],t[r+4]=n[4],t[r+5]=n[5],t[r+6]=n[6],t[r+7]=n[7],t[r+8]=n[8],t[r+9]=n[9],t[r+10]=n[10],t[r+11]=n[11],t[r+12]=n[12],t[r+13]=n[13],t[r+14]=n[14],t[r+15]=n[15],t}};Me.prototype.isMatrix4=!0;var S3=new j,ih=new Me,nfr=new j(0,0,0),ifr=new j(1,1,1),k0=new j,gV=new j,kl=new j,mue=new Me,gue=new vi,tm=class{constructor(t=0,r=0,n=0,i=tm.DefaultOrder){this._x=t,this._y=r,this._z=n,this._order=i}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get order(){return this._order}set order(t){this._order=t,this._onChangeCallback()}set(t,r,n,i=this._order){return this._x=t,this._y=r,this._z=n,this._order=i,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._order)}copy(t){return this._x=t._x,this._y=t._y,this._z=t._z,this._order=t._order,this._onChangeCallback(),this}setFromRotationMatrix(t,r=this._order,n=!0){let i=t.elements,o=i[0],a=i[4],s=i[8],l=i[1],c=i[5],u=i[9],h=i[2],f=i[6],p=i[10];switch(r){case"XYZ":this._y=Math.asin(Zo(s,-1,1)),Math.abs(s)<.9999999?(this._x=Math.atan2(-u,p),this._z=Math.atan2(-a,o)):(this._x=Math.atan2(f,c),this._z=0);break;case"YXZ":this._x=Math.asin(-Zo(u,-1,1)),Math.abs(u)<.9999999?(this._y=Math.atan2(s,p),this._z=Math.atan2(l,c)):(this._y=Math.atan2(-h,o),this._z=0);break;case"ZXY":this._x=Math.asin(Zo(f,-1,1)),Math.abs(f)<.9999999?(this._y=Math.atan2(-h,p),this._z=Math.atan2(-a,c)):(this._y=0,this._z=Math.atan2(l,o));break;case"ZYX":this._y=Math.asin(-Zo(h,-1,1)),Math.abs(h)<.9999999?(this._x=Math.atan2(f,p),this._z=Math.atan2(l,o)):(this._x=0,this._z=Math.atan2(-a,c));break;case"YZX":this._z=Math.asin(Zo(l,-1,1)),Math.abs(l)<.9999999?(this._x=Math.atan2(-u,c),this._y=Math.atan2(-h,o)):(this._x=0,this._y=Math.atan2(s,p));break;case"XZY":this._z=Math.asin(-Zo(a,-1,1)),Math.abs(a)<.9999999?(this._x=Math.atan2(f,c),this._y=Math.atan2(s,o)):(this._x=Math.atan2(-u,p),this._y=0);break;default:console.warn("THREE.Euler: .setFromRotationMatrix() encountered an unknown order: "+r)}return this._order=r,n===!0&&this._onChangeCallback(),this}setFromQuaternion(t,r,n){return mue.makeRotationFromQuaternion(t),this.setFromRotationMatrix(mue,r,n)}setFromVector3(t,r=this._order){return this.set(t.x,t.y,t.z,r)}reorder(t){return gue.setFromEuler(this),this.setFromQuaternion(gue,t)}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._order===this._order}fromArray(t){return this._x=t[0],this._y=t[1],this._z=t[2],t[3]!==void 0&&(this._order=t[3]),this._onChangeCallback(),this}toArray(t=[],r=0){return t[r]=this._x,t[r+1]=this._y,t[r+2]=this._z,t[r+3]=this._order,t}toVector3(t){return t?t.set(this._x,this._y,this._z):new j(this._x,this._y,this._z)}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}};tm.prototype.isEuler=!0;tm.DefaultOrder="XYZ";tm.RotationOrders=["XYZ","YZX","ZXY","XZY","YXZ","ZYX"];var X3=class{constructor(){this.mask=1}set(t){this.mask=(1<<t|0)>>>0}enable(t){this.mask|=1<<t|0}enableAll(){this.mask=-1}toggle(t){this.mask^=1<<t|0}disable(t){this.mask&=~(1<<t|0)}disableAll(){this.mask=0}test(t){return(this.mask&t.mask)!==0}isEnabled(t){return(this.mask&(1<<t|0))!==0}},ofr=0,_ue=new j,M3=new vi,qd=new Me,_V=new j,LP=new j,afr=new j,sfr=new vi,yue=new j(1,0,0),vue=new j(0,1,0),xue=new j(0,0,1),lfr={type:"added"},bue={type:"removed"},or=class extends Us{constructor(){super(),Object.defineProperty(this,"id",{value:ofr++}),this.uuid=Nl(),this.name="",this.type="Object3D",this.parent=null,this.children=[],this.up=or.DefaultUp.clone();let t=new j,r=new tm,n=new vi,i=new j(1,1,1);function o(){n.setFromEuler(r,!1)}function a(){r.setFromQuaternion(n,void 0,!1)}r._onChange(o),n._onChange(a),Object.defineProperties(this,{position:{configurable:!0,enumerable:!0,value:t},rotation:{configurable:!0,enumerable:!0,value:r},quaternion:{configurable:!0,enumerable:!0,value:n},scale:{configurable:!0,enumerable:!0,value:i},modelViewMatrix:{value:new Me},normalMatrix:{value:new ki}}),this.matrix=new Me,this.matrixWorld=new Me,this.matrixAutoUpdate=or.DefaultMatrixAutoUpdate,this.matrixWorldNeedsUpdate=!1,this.layers=new X3,this.visible=!0,this.castShadow=!1,this.receiveShadow=!1,this.frustumCulled=!0,this.renderOrder=0,this.animations=[],this.userData={}}onBeforeRender(){}onAfterRender(){}applyMatrix4(t){this.matrixAutoUpdate&&this.updateMatrix(),this.matrix.premultiply(t),this.matrix.decompose(this.position,this.quaternion,this.scale)}applyQuaternion(t){return this.quaternion.premultiply(t),this}setRotationFromAxisAngle(t,r){this.quaternion.setFromAxisAngle(t,r)}setRotationFromEuler(t){this.quaternion.setFromEuler(t,!0)}setRotationFromMatrix(t){this.quaternion.setFromRotationMatrix(t)}setRotationFromQuaternion(t){this.quaternion.copy(t)}rotateOnAxis(t,r){return M3.setFromAxisAngle(t,r),this.quaternion.multiply(M3),this}rotateOnWorldAxis(t,r){return M3.setFromAxisAngle(t,r),this.quaternion.premultiply(M3),this}rotateX(t){return this.rotateOnAxis(yue,t)}rotateY(t){return this.rotateOnAxis(vue,t)}rotateZ(t){return this.rotateOnAxis(xue,t)}translateOnAxis(t,r){return _ue.copy(t).applyQuaternion(this.quaternion),this.position.add(_ue.multiplyScalar(r)),this}translateX(t){return this.translateOnAxis(yue,t)}translateY(t){return this.translateOnAxis(vue,t)}translateZ(t){return this.translateOnAxis(xue,t)}localToWorld(t){return t.applyMatrix4(this.matrixWorld)}worldToLocal(t){return t.applyMatrix4(qd.copy(this.matrixWorld).invert())}lookAt(t,r,n){t.isVector3?_V.copy(t):_V.set(t,r,n);let i=this.parent;this.updateWorldMatrix(!0,!1),LP.setFromMatrixPosition(this.matrixWorld),this.isCamera||this.isLight?qd.lookAt(LP,_V,this.up):qd.lookAt(_V,LP,this.up),this.quaternion.setFromRotationMatrix(qd),i&&(qd.extractRotation(i.matrixWorld),M3.setFromRotationMatrix(qd),this.quaternion.premultiply(M3.invert()))}add(t){if(arguments.length>1){for(let r=0;r<arguments.length;r++)this.add(arguments[r]);return this}return t===this?(console.error("THREE.Object3D.add: object can't be added as a child of itself.",t),this):(t&&t.isObject3D?(t.parent!==null&&t.parent.remove(t),t.parent=this,this.children.push(t),t.dispatchEvent(lfr)):console.error("THREE.Object3D.add: object not an instance of THREE.Object3D.",t),this)}remove(t){if(arguments.length>1){for(let n=0;n<arguments.length;n++)this.remove(arguments[n]);return this}let r=this.children.indexOf(t);return r!==-1&&(t.parent=null,this.children.splice(r,1),t.dispatchEvent(bue)),this}removeFromParent(){let t=this.parent;return t!==null&&t.remove(this),this}clear(){for(let t=0;t<this.children.length;t++){let r=this.children[t];r.parent=null,r.dispatchEvent(bue)}return this.children.length=0,this}attach(t){return this.updateWorldMatrix(!0,!1),qd.copy(this.matrixWorld).invert(),t.parent!==null&&(t.parent.updateWorldMatrix(!0,!1),qd.multiply(t.parent.matrixWorld)),t.applyMatrix4(qd),this.add(t),t.updateWorldMatrix(!1,!0),this}getObjectById(t){return this.getObjectByProperty("id",t)}getObjectByName(t){return this.getObjectByProperty("name",t)}getObjectByProperty(t,r){if(this[t]===r)return this;for(let n=0,i=this.children.length;n<i;n++){let a=this.children[n].getObjectByProperty(t,r);if(a!==void 0)return a}}getWorldPosition(t){return this.updateWorldMatrix(!0,!1),t.setFromMatrixPosition(this.matrixWorld)}getWorldQuaternion(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(LP,t,afr),t}getWorldScale(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(LP,sfr,t),t}getWorldDirection(t){this.updateWorldMatrix(!0,!1);let r=this.matrixWorld.elements;return t.set(r[8],r[9],r[10]).normalize()}raycast(){}traverse(t){t(this);let r=this.children;for(let n=0,i=r.length;n<i;n++)r[n].traverse(t)}traverseVisible(t){if(this.visible===!1)return;t(this);let r=this.children;for(let n=0,i=r.length;n<i;n++)r[n].traverseVisible(t)}traverseAncestors(t){let r=this.parent;r!==null&&(t(r),r.traverseAncestors(t))}updateMatrix(){this.matrix.compose(this.position,this.quaternion,this.scale),this.matrixWorldNeedsUpdate=!0}updateMatrixWorld(t){this.matrixAutoUpdate&&this.updateMatrix(),(this.matrixWorldNeedsUpdate||t)&&(this.parent===null?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),this.matrixWorldNeedsUpdate=!1,t=!0);let r=this.children;for(let n=0,i=r.length;n<i;n++)r[n].updateMatrixWorld(t)}updateWorldMatrix(t,r){let n=this.parent;if(t===!0&&n!==null&&n.updateWorldMatrix(!0,!1),this.matrixAutoUpdate&&this.updateMatrix(),this.parent===null?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),r===!0){let i=this.children;for(let o=0,a=i.length;o<a;o++)i[o].updateWorldMatrix(!1,!0)}}toJSON(t){let r=t===void 0||typeof t=="string",n={};r&&(t={geometries:{},materials:{},textures:{},images:{},shapes:{},skeletons:{},animations:{}},n.metadata={version:4.5,type:"Object",generator:"Object3D.toJSON"});let i={};i.uuid=this.uuid,i.type=this.type,this.name!==""&&(i.name=this.name),this.castShadow===!0&&(i.castShadow=!0),this.receiveShadow===!0&&(i.receiveShadow=!0),this.visible===!1&&(i.visible=!1),this.frustumCulled===!1&&(i.frustumCulled=!1),this.renderOrder!==0&&(i.renderOrder=this.renderOrder),JSON.stringify(this.userData)!=="{}"&&(i.userData=this.userData),i.layers=this.layers.mask,i.matrix=this.matrix.toArray(),this.matrixAutoUpdate===!1&&(i.matrixAutoUpdate=!1),this.isInstancedMesh&&(i.type="InstancedMesh",i.count=this.count,i.instanceMatrix=this.instanceMatrix.toJSON(),this.instanceColor!==null&&(i.instanceColor=this.instanceColor.toJSON()));function o(s,l){return s[l.uuid]===void 0&&(s[l.uuid]=l.toJSON(t)),l.uuid}if(this.isScene)this.background&&(this.background.isColor?i.background=this.background.toJSON():this.background.isTexture&&(i.background=this.background.toJSON(t).uuid)),this.environment&&this.environment.isTexture&&(i.environment=this.environment.toJSON(t).uuid);else if(this.isMesh||this.isLine||this.isPoints){i.geometry=o(t.geometries,this.geometry);let s=this.geometry.parameters;if(s!==void 0&&s.shapes!==void 0){let l=s.shapes;if(Array.isArray(l))for(let c=0,u=l.length;c<u;c++){let h=l[c];o(t.shapes,h)}else o(t.shapes,l)}}if(this.isSkinnedMesh&&(i.bindMode=this.bindMode,i.bindMatrix=this.bindMatrix.toArray(),this.skeleton!==void 0&&(o(t.skeletons,this.skeleton),i.skeleton=this.skeleton.uuid)),this.material!==void 0)if(Array.isArray(this.material)){let s=[];for(let l=0,c=this.material.length;l<c;l++)s.push(o(t.materials,this.material[l]));i.material=s}else i.material=o(t.materials,this.material);if(this.children.length>0){i.children=[];for(let s=0;s<this.children.length;s++)i.children.push(this.children[s].toJSON(t).object)}if(this.animations.length>0){i.animations=[];for(let s=0;s<this.animations.length;s++){let l=this.animations[s];i.animations.push(o(t.animations,l))}}if(r){let s=a(t.geometries),l=a(t.materials),c=a(t.textures),u=a(t.images),h=a(t.shapes),f=a(t.skeletons),p=a(t.animations);s.length>0&&(n.geometries=s),l.length>0&&(n.materials=l),c.length>0&&(n.textures=c),u.length>0&&(n.images=u),h.length>0&&(n.shapes=h),f.length>0&&(n.skeletons=f),p.length>0&&(n.animations=p)}return n.object=i,n;function a(s){let l=[];for(let c in s){let u=s[c];delete u.metadata,l.push(u)}return l}}clone(t){return new this.constructor().copy(this,t)}copy(t,r=!0){if(this.name=t.name,this.up.copy(t.up),this.position.copy(t.position),this.rotation.order=t.rotation.order,this.quaternion.copy(t.quaternion),this.scale.copy(t.scale),this.matrix.copy(t.matrix),this.matrixWorld.copy(t.matrixWorld),this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrixWorldNeedsUpdate=t.matrixWorldNeedsUpdate,this.layers.mask=t.layers.mask,this.visible=t.visible,this.castShadow=t.castShadow,this.receiveShadow=t.receiveShadow,this.frustumCulled=t.frustumCulled,this.renderOrder=t.renderOrder,this.userData=JSON.parse(JSON.stringify(t.userData)),r===!0)for(let n=0;n<t.children.length;n++){let i=t.children[n];this.add(i.clone())}return this}};or.DefaultUp=new j(0,1,0);or.DefaultMatrixAutoUpdate=!0;or.prototype.isObject3D=!0;var oh=new j,Gd=new j,eut=new j,Wd=new j,E3=new j,T3=new j,wue=new j,rut=new j,nut=new j,iut=new j,ai=class{constructor(t=new j,r=new j,n=new j){this.a=t,this.b=r,this.c=n}static getNormal(t,r,n,i){i.subVectors(n,r),oh.subVectors(t,r),i.cross(oh);let o=i.lengthSq();return o>0?i.multiplyScalar(1/Math.sqrt(o)):i.set(0,0,0)}static getBarycoord(t,r,n,i,o){oh.subVectors(i,r),Gd.subVectors(n,r),eut.subVectors(t,r);let a=oh.dot(oh),s=oh.dot(Gd),l=oh.dot(eut),c=Gd.dot(Gd),u=Gd.dot(eut),h=a*c-s*s;if(h===0)return o.set(-2,-1,-1);let f=1/h,p=(c*l-s*u)*f,d=(a*u-s*l)*f;return o.set(1-p-d,d,p)}static containsPoint(t,r,n,i){return this.getBarycoord(t,r,n,i,Wd),Wd.x>=0&&Wd.y>=0&&Wd.x+Wd.y<=1}static getUV(t,r,n,i,o,a,s,l){return this.getBarycoord(t,r,n,i,Wd),l.set(0,0),l.addScaledVector(o,Wd.x),l.addScaledVector(a,Wd.y),l.addScaledVector(s,Wd.z),l}static isFrontFacing(t,r,n,i){return oh.subVectors(n,r),Gd.subVectors(t,r),oh.cross(Gd).dot(i)<0}set(t,r,n){return this.a.copy(t),this.b.copy(r),this.c.copy(n),this}setFromPointsAndIndices(t,r,n,i){return this.a.copy(t[r]),this.b.copy(t[n]),this.c.copy(t[i]),this}setFromAttributeAndIndices(t,r,n,i){return this.a.fromBufferAttribute(t,r),this.b.fromBufferAttribute(t,n),this.c.fromBufferAttribute(t,i),this}clone(){return new this.constructor().copy(this)}copy(t){return this.a.copy(t.a),this.b.copy(t.b),this.c.copy(t.c),this}getArea(){return oh.subVectors(this.c,this.b),Gd.subVectors(this.a,this.b),oh.cross(Gd).length()*.5}getMidpoint(t){return t.addVectors(this.a,this.b).add(this.c).multiplyScalar(1/3)}getNormal(t){return ai.getNormal(this.a,this.b,this.c,t)}getPlane(t){return t.setFromCoplanarPoints(this.a,this.b,this.c)}getBarycoord(t,r){return ai.getBarycoord(t,this.a,this.b,this.c,r)}getUV(t,r,n,i,o){return ai.getUV(t,this.a,this.b,this.c,r,n,i,o)}containsPoint(t){return ai.containsPoint(t,this.a,this.b,this.c)}isFrontFacing(t){return ai.isFrontFacing(this.a,this.b,this.c,t)}intersectsBox(t){return t.intersectsTriangle(this)}closestPointToPoint(t,r){let n=this.a,i=this.b,o=this.c,a,s;E3.subVectors(i,n),T3.subVectors(o,n),rut.subVectors(t,n);let l=E3.dot(rut),c=T3.dot(rut);if(l<=0&&c<=0)return r.copy(n);nut.subVectors(t,i);let u=E3.dot(nut),h=T3.dot(nut);if(u>=0&&h<=u)return r.copy(i);let f=l*h-u*c;if(f<=0&&l>=0&&u<=0)return a=l/(l-u),r.copy(n).addScaledVector(E3,a);iut.subVectors(t,o);let p=E3.dot(iut),d=T3.dot(iut);if(d>=0&&p<=d)return r.copy(o);let g=p*c-l*d;if(g<=0&&c>=0&&d<=0)return s=c/(c-d),r.copy(n).addScaledVector(T3,s);let _=u*d-p*h;if(_<=0&&h-u>=0&&p-d>=0)return wue.subVectors(o,i),s=(h-u)/(h-u+(p-d)),r.copy(i).addScaledVector(wue,s);let y=1/(_+g+f);return a=g*y,s=f*y,r.copy(n).addScaledVector(E3,a).addScaledVector(T3,s)}equals(t){return t.a.equals(this.a)&&t.b.equals(this.b)&&t.c.equals(this.c)}},cfr=0,qi=class extends Us{constructor(){super(),Object.defineProperty(this,"id",{value:cfr++}),this.uuid=Nl(),this.name="",this.type="Material",this.fog=!0,this.blending=V3,this.side=Iv,this.vertexColors=!1,this.opacity=1,this.transparent=!1,this.blendSrc=Iht,this.blendDst=Lht,this.blendEquation=Mv,this.blendSrcAlpha=null,this.blendDstAlpha=null,this.blendEquationAlpha=null,this.depthFunc=nU,this.depthTest=!0,this.depthWrite=!0,this.stencilWriteMask=255,this.stencilFunc=Lfe,this.stencilRef=0,this.stencilFuncMask=255,this.stencilFail=rU,this.stencilZFail=rU,this.stencilZPass=rU,this.stencilWrite=!1,this.clippingPlanes=null,this.clipIntersection=!1,this.clipShadows=!1,this.shadowSide=null,this.colorWrite=!0,this.alphaWrite=!0,this.precision=null,this.polygonOffset=!1,this.polygonOffsetFactor=0,this.polygonOffsetUnits=0,this.dithering=!1,this.alphaToCoverage=!1,this.premultipliedAlpha=!1,this.visible=!0,this.toneMapped=!0,this.userData={},this.version=0,this._alphaTest=0}get alphaTest(){return this._alphaTest}set alphaTest(t){this._alphaTest>0!=t>0&&this.version++,this._alphaTest=t}onBuild(){}onBeforeRender(){}onBeforeCompile(){}customProgramCacheKey(){return this.onBeforeCompile.toString()}setValues(t){if(t!==void 0)for(let r in t){let n=t[r];if(n===void 0){console.warn("THREE.Material: '"+r+"' parameter is undefined.");continue}if(r==="shading"){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=n===Pht;continue}let i=this[r];if(i===void 0){console.warn("THREE."+this.type+": '"+r+"' is not a property of this material.");continue}i&&i.isColor?i.set(n):i&&i.isVector3&&n&&n.isVector3?i.copy(n):this[r]=n}}toJSON(t){let r=t===void 0||typeof t=="string";r&&(t={textures:{},images:{}});let n={metadata:{version:4.5,type:"Material",generator:"Material.toJSON"}};n.uuid=this.uuid,n.type=this.type,this.name!==""&&(n.name=this.name),this.color&&this.color.isColor&&(n.color=this.color.getHex()),this.roughness!==void 0&&(n.roughness=this.roughness),this.metalness!==void 0&&(n.metalness=this.metalness),this.sheen!==void 0&&(n.sheen=this.sheen),this.sheenColor&&this.sheenColor.isColor&&(n.sheenColor=this.sheenColor.getHex()),this.sheenRoughness!==void 0&&(n.sheenRoughness=this.sheenRoughness),this.emissive&&this.emissive.isColor&&(n.emissive=this.emissive.getHex()),this.emissiveIntensity&&this.emissiveIntensity!==1&&(n.emissiveIntensity=this.emissiveIntensity),this.specular&&this.specular.isColor&&(n.specular=this.specular.getHex()),this.specularIntensity!==void 0&&(n.specularIntensity=this.specularIntensity),this.specularColor&&this.specularColor.isColor&&(n.specularColor=this.specularColor.getHex()),this.shininess!==void 0&&(n.shininess=this.shininess),this.clearcoat!==void 0&&(n.clearcoat=this.clearcoat),this.clearcoatRoughness!==void 0&&(n.clearcoatRoughness=this.clearcoatRoughness),this.clearcoatMap&&this.clearcoatMap.isTexture&&(n.clearcoatMap=this.clearcoatMap.toJSON(t).uuid),this.clearcoatRoughnessMap&&this.clearcoatRoughnessMap.isTexture&&(n.clearcoatRoughnessMap=this.clearcoatRoughnessMap.toJSON(t).uuid),this.clearcoatNormalMap&&this.clearcoatNormalMap.isTexture&&(n.clearcoatNormalMap=this.clearcoatNormalMap.toJSON(t).uuid,n.clearcoatNormalScale=this.clearcoatNormalScale.toArray()),this.map&&this.map.isTexture&&(n.map=this.map.toJSON(t).uuid),this.matcap&&this.matcap.isTexture&&(n.matcap=this.matcap.toJSON(t).uuid),this.alphaMap&&this.alphaMap.isTexture&&(n.alphaMap=this.alphaMap.toJSON(t).uuid),this.lightMap&&this.lightMap.isTexture&&(n.lightMap=this.lightMap.toJSON(t).uuid,n.lightMapIntensity=this.lightMapIntensity),this.aoMap&&this.aoMap.isTexture&&(n.aoMap=this.aoMap.toJSON(t).uuid,n.aoMapIntensity=this.aoMapIntensity),this.bumpMap&&this.bumpMap.isTexture&&(n.bumpMap=this.bumpMap.toJSON(t).uuid,n.bumpScale=this.bumpScale),this.normalMap&&this.normalMap.isTexture&&(n.normalMap=this.normalMap.toJSON(t).uuid,n.normalMapType=this.normalMapType,n.normalScale=this.normalScale.toArray()),this.displacementMap&&this.displacementMap.isTexture&&(n.displacementMap=this.displacementMap.toJSON(t).uuid,n.displacementScale=this.displacementScale,n.displacementBias=this.displacementBias),this.roughnessMap&&this.roughnessMap.isTexture&&(n.roughnessMap=this.roughnessMap.toJSON(t).uuid),this.metalnessMap&&this.metalnessMap.isTexture&&(n.metalnessMap=this.metalnessMap.toJSON(t).uuid),this.emissiveMap&&this.emissiveMap.isTexture&&(n.emissiveMap=this.emissiveMap.toJSON(t).uuid),this.specularMap&&this.specularMap.isTexture&&(n.specularMap=this.specularMap.toJSON(t).uuid),this.specularIntensityMap&&this.specularIntensityMap.isTexture&&(n.specularIntensityMap=this.specularIntensityMap.toJSON(t).uuid),this.specularColorMap&&this.specularColorMap.isTexture&&(n.specularColorMap=this.specularColorMap.toJSON(t).uuid),this.envMap&&this.envMap.isTexture&&(n.envMap=this.envMap.toJSON(t).uuid,this.combine!==void 0&&(n.combine=this.combine)),this.envMapIntensity!==void 0&&(n.envMapIntensity=this.envMapIntensity),this.reflectivity!==void 0&&(n.reflectivity=this.reflectivity),this.refractionRatio!==void 0&&(n.refractionRatio=this.refractionRatio),this.gradientMap&&this.gradientMap.isTexture&&(n.gradientMap=this.gradientMap.toJSON(t).uuid),this.transmission!==void 0&&(n.transmission=this.transmission),this.transmissionMap&&this.transmissionMap.isTexture&&(n.transmissionMap=this.transmissionMap.toJSON(t).uuid),this.thickness!==void 0&&(n.thickness=this.thickness),this.thicknessMap&&this.thicknessMap.isTexture&&(n.thicknessMap=this.thicknessMap.toJSON(t).uuid),this.attenuationDistance!==void 0&&(n.attenuationDistance=this.attenuationDistance),this.attenuationColor!==void 0&&(n.attenuationColor=this.attenuationColor.getHex()),this.size!==void 0&&(n.size=this.size),this.shadowSide!==null&&(n.shadowSide=this.shadowSide),this.sizeAttenuation!==void 0&&(n.sizeAttenuation=this.sizeAttenuation),this.blending!==V3&&(n.blending=this.blending),this.side!==Iv&&(n.side=this.side),this.vertexColors&&(n.vertexColors=!0),this.opacity<1&&(n.opacity=this.opacity),this.transparent===!0&&(n.transparent=this.transparent),n.depthFunc=this.depthFunc,n.depthTest=this.depthTest,n.depthWrite=this.depthWrite,n.colorWrite=this.colorWrite,n.alphaWrite=this.alphaWrite,n.stencilWrite=this.stencilWrite,n.stencilWriteMask=this.stencilWriteMask,n.stencilFunc=this.stencilFunc,n.stencilRef=this.stencilRef,n.stencilFuncMask=this.stencilFuncMask,n.stencilFail=this.stencilFail,n.stencilZFail=this.stencilZFail,n.stencilZPass=this.stencilZPass,this.rotation&&this.rotation!==0&&(n.rotation=this.rotation),this.polygonOffset===!0&&(n.polygonOffset=!0),this.polygonOffsetFactor!==0&&(n.polygonOffsetFactor=this.polygonOffsetFactor),this.polygonOffsetUnits!==0&&(n.polygonOffsetUnits=this.polygonOffsetUnits),this.linewidth&&this.linewidth!==1&&(n.linewidth=this.linewidth),this.dashSize!==void 0&&(n.dashSize=this.dashSize),this.gapSize!==void 0&&(n.gapSize=this.gapSize),this.scale!==void 0&&(n.scale=this.scale),this.dithering===!0&&(n.dithering=!0),this.alphaTest>0&&(n.alphaTest=this.alphaTest),this.alphaToCoverage===!0&&(n.alphaToCoverage=this.alphaToCoverage),this.premultipliedAlpha===!0&&(n.premultipliedAlpha=this.premultipliedAlpha),this.wireframe===!0&&(n.wireframe=this.wireframe),this.wireframeLinewidth>1&&(n.wireframeLinewidth=this.wireframeLinewidth),this.wireframeLinecap!=="round"&&(n.wireframeLinecap=this.wireframeLinecap),this.wireframeLinejoin!=="round"&&(n.wireframeLinejoin=this.wireframeLinejoin),this.flatShading===!0&&(n.flatShading=this.flatShading),this.visible===!1&&(n.visible=!1),this.toneMapped===!1&&(n.toneMapped=!1),JSON.stringify(this.userData)!=="{}"&&(n.userData=this.userData);function i(o){let a=[];for(let s in o){let l=o[s];delete l.metadata,a.push(l)}return a}if(r){let o=i(t.textures),a=i(t.images);o.length>0&&(n.textures=o),a.length>0&&(n.images=a)}return n}clone(){return new this.constructor().copy(this)}copy(t){this.name=t.name,this.fog=t.fog,this.blending=t.blending,this.side=t.side,this.vertexColors=t.vertexColors,this.opacity=t.opacity,this.transparent=t.transparent,this.blendSrc=t.blendSrc,this.blendDst=t.blendDst,this.blendEquation=t.blendEquation,this.blendSrcAlpha=t.blendSrcAlpha,this.blendDstAlpha=t.blendDstAlpha,this.blendEquationAlpha=t.blendEquationAlpha,this.depthFunc=t.depthFunc,this.depthTest=t.depthTest,this.depthWrite=t.depthWrite,this.stencilWriteMask=t.stencilWriteMask,this.stencilFunc=t.stencilFunc,this.stencilRef=t.stencilRef,this.stencilFuncMask=t.stencilFuncMask,this.stencilFail=t.stencilFail,this.stencilZFail=t.stencilZFail,this.stencilZPass=t.stencilZPass,this.stencilWrite=t.stencilWrite;let r=t.clippingPlanes,n=null;if(r!==null){let i=r.length;n=new Array(i);for(let o=0;o!==i;++o)n[o]=r[o].clone()}return this.clippingPlanes=n,this.clipIntersection=t.clipIntersection,this.clipShadows=t.clipShadows,this.shadowSide=t.shadowSide,this.colorWrite=t.colorWrite,this.alphaWrite=t.alphaWrite,this.precision=t.precision,this.polygonOffset=t.polygonOffset,this.polygonOffsetFactor=t.polygonOffsetFactor,this.polygonOffsetUnits=t.polygonOffsetUnits,this.dithering=t.dithering,this.alphaTest=t.alphaTest,this.alphaToCoverage=t.alphaToCoverage,this.premultipliedAlpha=t.premultipliedAlpha,this.visible=t.visible,this.toneMapped=t.toneMapped,this.userData=JSON.parse(JSON.stringify(t.userData)),this}dispose(){this.dispatchEvent({type:"dispose"})}set needsUpdate(t){t===!0&&this.version++}};qi.prototype.isMaterial=!0;var sh=class extends qi{constructor(t){super(),this.type="MeshBasicMaterial",this.color=new ne(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=D6,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};sh.prototype.isMeshBasicMaterial=!0;var Ln=new j,yV=new Lt,Je=class{constructor(t,r,n){if(Array.isArray(t))throw new TypeError("THREE.BufferAttribute: array should be a Typed Array.");this.name="",this.array=t,this.itemSize=r,this.count=t!==void 0?t.length/r:0,this.normalized=n===!0,this.usage=W3,this.updateRange={offset:0,count:-1},this.version=0}onUploadCallback(){}set needsUpdate(t){t===!0&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.name=t.name,this.array=new t.array.constructor(t.array),this.itemSize=t.itemSize,this.count=t.count,this.normalized=t.normalized,this.usage=t.usage,this}copyAt(t,r,n){t*=this.itemSize,n*=r.itemSize;for(let i=0,o=this.itemSize;i<o;i++)this.array[t+i]=r.array[n+i];return this}copyArray(t){return this.array.set(t),this}copyColorsArray(t){let r=this.array,n=0;for(let i=0,o=t.length;i<o;i++){let a=t[i];a===void 0&&(console.warn("THREE.BufferAttribute.copyColorsArray(): color is undefined",i),a=new ne),r[n++]=a.r,r[n++]=a.g,r[n++]=a.b}return this}copyVector2sArray(t){let r=this.array,n=0;for(let i=0,o=t.length;i<o;i++){let a=t[i];a===void 0&&(console.warn("THREE.BufferAttribute.copyVector2sArray(): vector is undefined",i),a=new Lt),r[n++]=a.x,r[n++]=a.y}return this}copyVector3sArray(t){let r=this.array,n=0;for(let i=0,o=t.length;i<o;i++){let a=t[i];a===void 0&&(console.warn("THREE.BufferAttribute.copyVector3sArray(): vector is undefined",i),a=new j),r[n++]=a.x,r[n++]=a.y,r[n++]=a.z}return this}copyVector4sArray(t){let r=this.array,n=0;for(let i=0,o=t.length;i<o;i++){let a=t[i];a===void 0&&(console.warn("THREE.BufferAttribute.copyVector4sArray(): vector is undefined",i),a=new en),r[n++]=a.x,r[n++]=a.y,r[n++]=a.z,r[n++]=a.w}return this}applyMatrix3(t){if(this.itemSize===2)for(let r=0,n=this.count;r<n;r++)yV.fromBufferAttribute(this,r),yV.applyMatrix3(t),this.setXY(r,yV.x,yV.y);else if(this.itemSize===3)for(let r=0,n=this.count;r<n;r++)Ln.fromBufferAttribute(this,r),Ln.applyMatrix3(t),this.setXYZ(r,Ln.x,Ln.y,Ln.z);return this}applyMatrix4(t){for(let r=0,n=this.count;r<n;r++)Ln.x=this.getX(r),Ln.y=this.getY(r),Ln.z=this.getZ(r),Ln.applyMatrix4(t),this.setXYZ(r,Ln.x,Ln.y,Ln.z);return this}applyNormalMatrix(t){for(let r=0,n=this.count;r<n;r++)Ln.x=this.getX(r),Ln.y=this.getY(r),Ln.z=this.getZ(r),Ln.applyNormalMatrix(t),this.setXYZ(r,Ln.x,Ln.y,Ln.z);return this}transformDirection(t){for(let r=0,n=this.count;r<n;r++)Ln.x=this.getX(r),Ln.y=this.getY(r),Ln.z=this.getZ(r),Ln.transformDirection(t),this.setXYZ(r,Ln.x,Ln.y,Ln.z);return this}set(t,r=0){return this.array.set(t,r),this}getX(t){return this.array[t*this.itemSize]}setX(t,r){return this.array[t*this.itemSize]=r,this}getY(t){return this.array[t*this.itemSize+1]}setY(t,r){return this.array[t*this.itemSize+1]=r,this}getZ(t){return this.array[t*this.itemSize+2]}setZ(t,r){return this.array[t*this.itemSize+2]=r,this}getW(t){return this.array[t*this.itemSize+3]}setW(t,r){return this.array[t*this.itemSize+3]=r,this}setXY(t,r,n){return t*=this.itemSize,this.array[t+0]=r,this.array[t+1]=n,this}setXYZ(t,r,n,i){return t*=this.itemSize,this.array[t+0]=r,this.array[t+1]=n,this.array[t+2]=i,this}setXYZW(t,r,n,i,o){return t*=this.itemSize,this.array[t+0]=r,this.array[t+1]=n,this.array[t+2]=i,this.array[t+3]=o,this}onUpload(t){return this.onUploadCallback=t,this}clone(){return new this.constructor(this.array,this.itemSize).copy(this)}toJSON(){let t={itemSize:this.itemSize,type:this.array.constructor.name,array:Array.prototype.slice.call(this.array),normalized:this.normalized};return this.name!==""&&(t.name=this.name),this.usage!==W3&&(t.usage=this.usage),(this.updateRange.offset!==0||this.updateRange.count!==-1)&&(t.updateRange=this.updateRange),t}};Je.prototype.isBufferAttribute=!0;var lU=class extends Je{constructor(t,r,n){super(new Int8Array(t),r,n)}},cU=class extends Je{constructor(t,r,n){super(new Uint8Array(t),r,n)}},uU=class extends Je{constructor(t,r,n){super(new Uint8ClampedArray(t),r,n)}},hU=class extends Je{constructor(t,r,n){super(new Int16Array(t),r,n)}},$3=class extends Je{constructor(t,r,n){super(new Uint16Array(t),r,n)}},fU=class extends Je{constructor(t,r,n){super(new Int32Array(t),r,n)}},K3=class extends Je{constructor(t,r,n){super(new Uint32Array(t),r,n)}},pU=class extends Je{constructor(t,r,n){super(new Uint16Array(t),r,n)}};pU.prototype.isFloat16BufferAttribute=!0;var xe=class extends Je{constructor(t,r,n){super(new Float32Array(t),r,n)}},dU=class extends Je{constructor(t,r,n){super(new Float64Array(t),r,n)}},ufr=0,Xc=new Me,out=new or,C3=new j,Rl=new ta,kP=new ta,Lo=new j,Pe=class extends Us{constructor(){super(),Object.defineProperty(this,"id",{value:ufr++}),this.uuid=Nl(),this.name="",this.type="BufferGeometry",this.index=null,this.attributes={},this.morphAttributes={},this.morphTargetsRelative=!1,this.groups=[],this.boundingBox=null,this.boundingSphere=null,this.drawRange={start:0,count:1/0},this.userData={}}getIndex(){return this.index}setIndex(t){return Array.isArray(t)?this.index=new(Nfe(t)?K3:$3)(t,1):this.index=t,this}getAttribute(t){return this.attributes[t]}setAttribute(t,r){return this.attributes[t]=r,this}deleteAttribute(t){return delete this.attributes[t],this}hasAttribute(t){return this.attributes[t]!==void 0}addGroup(t,r,n=0){this.groups.push({start:t,count:r,materialIndex:n})}clearGroups(){this.groups=[]}setDrawRange(t,r){this.drawRange.start=t,this.drawRange.count=r}applyMatrix4(t){let r=this.attributes.position;r!==void 0&&(r.applyMatrix4(t),r.needsUpdate=!0);let n=this.attributes.normal;if(n!==void 0){let o=new ki().getNormalMatrix(t);n.applyNormalMatrix(o),n.needsUpdate=!0}let i=this.attributes.tangent;return i!==void 0&&(i.transformDirection(t),i.needsUpdate=!0),this.boundingBox!==null&&this.computeBoundingBox(),this.boundingSphere!==null&&this.computeBoundingSphere(),this}applyQuaternion(t){return Xc.makeRotationFromQuaternion(t),this.applyMatrix4(Xc),this}rotateX(t){return Xc.makeRotationX(t),this.applyMatrix4(Xc),this}rotateY(t){return Xc.makeRotationY(t),this.applyMatrix4(Xc),this}rotateZ(t){return Xc.makeRotationZ(t),this.applyMatrix4(Xc),this}translate(t,r,n){return Xc.makeTranslation(t,r,n),this.applyMatrix4(Xc),this}scale(t,r,n){return Xc.makeScale(t,r,n),this.applyMatrix4(Xc),this}lookAt(t){return out.lookAt(t),out.updateMatrix(),this.applyMatrix4(out.matrix),this}center(){return this.computeBoundingBox(),this.boundingBox.getCenter(C3).negate(),this.translate(C3.x,C3.y,C3.z),this}setFromPoints(t){let r=[];for(let n=0,i=t.length;n<i;n++){let o=t[n];r.push(o.x,o.y,o.z||0)}return this.setAttribute("position",new xe(r,3)),this}computeBoundingBox(){this.boundingBox===null&&(this.boundingBox=new ta);let t=this.attributes.position,r=this.morphAttributes.position;if(t&&t.isGLBufferAttribute){console.error('THREE.BufferGeometry.computeBoundingBox(): GLBufferAttribute requires a manual bounding box. Alternatively set "mesh.frustumCulled" to "false".',this),this.boundingBox.set(new j(-1/0,-1/0,-1/0),new j(1/0,1/0,1/0));return}if(t!==void 0){if(this.boundingBox.setFromBufferAttribute(t),r)for(let n=0,i=r.length;n<i;n++){let o=r[n];Rl.setFromBufferAttribute(o),this.morphTargetsRelative?(Lo.addVectors(this.boundingBox.min,Rl.min),this.boundingBox.expandByPoint(Lo),Lo.addVectors(this.boundingBox.max,Rl.max),this.boundingBox.expandByPoint(Lo)):(this.boundingBox.expandByPoint(Rl.min),this.boundingBox.expandByPoint(Rl.max))}}else this.boundingBox.makeEmpty();(isNaN(this.boundingBox.min.x)||isNaN(this.boundingBox.min.y)||isNaN(this.boundingBox.min.z))&&console.error('THREE.BufferGeometry.computeBoundingBox(): Computed min/max have NaN values. The "position" attribute is likely to have NaN values.',this)}computeBoundingSphere(){this.boundingSphere===null&&(this.boundingSphere=new Zf);let t=this.attributes.position,r=this.morphAttributes.position;if(t&&t.isGLBufferAttribute){console.error('THREE.BufferGeometry.computeBoundingSphere(): GLBufferAttribute requires a manual bounding sphere. Alternatively set "mesh.frustumCulled" to "false".',this),this.boundingSphere.set(new j,1/0);return}if(t){let n=this.boundingSphere.center;if(Rl.setFromBufferAttribute(t),r)for(let o=0,a=r.length;o<a;o++){let s=r[o];kP.setFromBufferAttribute(s),this.morphTargetsRelative?(Lo.addVectors(Rl.min,kP.min),Rl.expandByPoint(Lo),Lo.addVectors(Rl.max,kP.max),Rl.expandByPoint(Lo)):(Rl.expandByPoint(kP.min),Rl.expandByPoint(kP.max))}Rl.getCenter(n);let i=0;for(let o=0,a=t.count;o<a;o++)Lo.fromBufferAttribute(t,o),i=Math.max(i,n.distanceToSquared(Lo));if(r)for(let o=0,a=r.length;o<a;o++){let s=r[o],l=this.morphTargetsRelative;for(let c=0,u=s.count;c<u;c++)Lo.fromBufferAttribute(s,c),l&&(C3.fromBufferAttribute(t,c),Lo.add(C3)),i=Math.max(i,n.distanceToSquared(Lo))}this.boundingSphere.radius=Math.sqrt(i),isNaN(this.boundingSphere.radius)&&console.error('THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.',this)}}computeTangents(){let t=this.index,r=this.attributes;if(t===null||r.position===void 0||r.normal===void 0||r.uv===void 0){console.error("THREE.BufferGeometry: .computeTangents() failed. Missing required attributes (index, position, normal or uv)");return}let n=t.array,i=r.position.array,o=r.normal.array,a=r.uv.array,s=i.length/3;r.tangent===void 0&&this.setAttribute("tangent",new Je(new Float32Array(4*s),4));let l=r.tangent.array,c=[],u=[];for(let B=0;B<s;B++)c[B]=new j,u[B]=new j;let h=new j,f=new j,p=new j,d=new Lt,g=new Lt,_=new Lt,y=new j,x=new j;function b(B,I,L){h.fromArray(i,B*3),f.fromArray(i,I*3),p.fromArray(i,L*3),d.fromArray(a,B*2),g.fromArray(a,I*2),_.fromArray(a,L*2),f.sub(h),p.sub(h),g.sub(d),_.sub(d);let R=1/(g.x*_.y-_.x*g.y);!isFinite(R)||(y.copy(f).multiplyScalar(_.y).addScaledVector(p,-g.y).multiplyScalar(R),x.copy(p).multiplyScalar(g.x).addScaledVector(f,-_.x).multiplyScalar(R),c[B].add(y),c[I].add(y),c[L].add(y),u[B].add(x),u[I].add(x),u[L].add(x))}let S=this.groups;S.length===0&&(S=[{start:0,count:n.length}]);for(let B=0,I=S.length;B<I;++B){let L=S[B],R=L.start,F=L.count;for(let z=R,U=R+F;z<U;z+=3)b(n[z+0],n[z+1],n[z+2])}let C=new j,P=new j,k=new j,O=new j;function D(B){k.fromArray(o,B*3),O.copy(k);let I=c[B];C.copy(I),C.sub(k.multiplyScalar(k.dot(I))).normalize(),P.crossVectors(O,I);let R=P.dot(u[B])<0?-1:1;l[B*4]=C.x,l[B*4+1]=C.y,l[B*4+2]=C.z,l[B*4+3]=R}for(let B=0,I=S.length;B<I;++B){let L=S[B],R=L.start,F=L.count;for(let z=R,U=R+F;z<U;z+=3)D(n[z+0]),D(n[z+1]),D(n[z+2])}}computeVertexNormals(){let t=this.index,r=this.getAttribute("position");if(r!==void 0){let n=this.getAttribute("normal");if(n===void 0)n=new Je(new Float32Array(r.count*3),3),this.setAttribute("normal",n);else for(let f=0,p=n.count;f<p;f++)n.setXYZ(f,0,0,0);let i=new j,o=new j,a=new j,s=new j,l=new j,c=new j,u=new j,h=new j;if(t)for(let f=0,p=t.count;f<p;f+=3){let d=t.getX(f+0),g=t.getX(f+1),_=t.getX(f+2);i.fromBufferAttribute(r,d),o.fromBufferAttribute(r,g),a.fromBufferAttribute(r,_),u.subVectors(a,o),h.subVectors(i,o),u.cross(h),s.fromBufferAttribute(n,d),l.fromBufferAttribute(n,g),c.fromBufferAttribute(n,_),s.add(u),l.add(u),c.add(u),n.setXYZ(d,s.x,s.y,s.z),n.setXYZ(g,l.x,l.y,l.z),n.setXYZ(_,c.x,c.y,c.z)}else for(let f=0,p=r.count;f<p;f+=3)i.fromBufferAttribute(r,f+0),o.fromBufferAttribute(r,f+1),a.fromBufferAttribute(r,f+2),u.subVectors(a,o),h.subVectors(i,o),u.cross(h),n.setXYZ(f+0,u.x,u.y,u.z),n.setXYZ(f+1,u.x,u.y,u.z),n.setXYZ(f+2,u.x,u.y,u.z);this.normalizeNormals(),n.needsUpdate=!0}}merge(t,r){if(!(t&&t.isBufferGeometry)){console.error("THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.",t);return}r===void 0&&(r=0,console.warn("THREE.BufferGeometry.merge(): Overwriting original geometry, starting at offset=0. Use BufferGeometryUtils.mergeBufferGeometries() for lossless merge."));let n=this.attributes;for(let i in n){if(t.attributes[i]===void 0)continue;let a=n[i].array,s=t.attributes[i],l=s.array,c=s.itemSize*r,u=Math.min(l.length,a.length-c);for(let h=0,f=c;h<u;h++,f++)a[f]=l[h]}return this}normalizeNormals(){let t=this.attributes.normal;for(let r=0,n=t.count;r<n;r++)Lo.fromBufferAttribute(t,r),Lo.normalize(),t.setXYZ(r,Lo.x,Lo.y,Lo.z)}toNonIndexed(){function t(s,l){let c=s.array,u=s.itemSize,h=s.normalized,f=new c.constructor(l.length*u),p=0,d=0;for(let g=0,_=l.length;g<_;g++){s.isInterleavedBufferAttribute?p=l[g]*s.data.stride+s.offset:p=l[g]*u;for(let y=0;y<u;y++)f[d++]=c[p++]}return new Je(f,u,h)}if(this.index===null)return console.warn("THREE.BufferGeometry.toNonIndexed(): BufferGeometry is already non-indexed."),this;let r=new Pe,n=this.index.array,i=this.attributes;for(let s in i){let l=i[s],c=t(l,n);r.setAttribute(s,c)}let o=this.morphAttributes;for(let s in o){let l=[],c=o[s];for(let u=0,h=c.length;u<h;u++){let f=c[u],p=t(f,n);l.push(p)}r.morphAttributes[s]=l}r.morphTargetsRelative=this.morphTargetsRelative;let a=this.groups;for(let s=0,l=a.length;s<l;s++){let c=a[s];r.addGroup(c.start,c.count,c.materialIndex)}return r}toJSON(){let t={metadata:{version:4.5,type:"BufferGeometry",generator:"BufferGeometry.toJSON"}};if(t.uuid=this.uuid,t.type=this.type,this.name!==""&&(t.name=this.name),Object.keys(this.userData).length>0&&(t.userData=this.userData),this.parameters!==void 0){let l=this.parameters;for(let c in l)l[c]!==void 0&&(t[c]=l[c]);return t}t.data={attributes:{}};let r=this.index;r!==null&&(t.data.index={type:r.array.constructor.name,array:Array.prototype.slice.call(r.array)});let n=this.attributes;for(let l in n){let c=n[l];t.data.attributes[l]=c.toJSON(t.data)}let i={},o=!1;for(let l in this.morphAttributes){let c=this.morphAttributes[l],u=[];for(let h=0,f=c.length;h<f;h++){let p=c[h];u.push(p.toJSON(t.data))}u.length>0&&(i[l]=u,o=!0)}o&&(t.data.morphAttributes=i,t.data.morphTargetsRelative=this.morphTargetsRelative);let a=this.groups;a.length>0&&(t.data.groups=JSON.parse(JSON.stringify(a)));let s=this.boundingSphere;return s!==null&&(t.data.boundingSphere={center:s.center.toArray(),radius:s.radius}),t}clone(){return new this.constructor().copy(this)}copy(t){this.index=null,this.attributes={},this.morphAttributes={},this.groups=[],this.boundingBox=null,this.boundingSphere=null;let r={};this.name=t.name;let n=t.index;n!==null&&this.setIndex(n.clone(r));let i=t.attributes;for(let c in i){let u=i[c];this.setAttribute(c,u.clone(r))}let o=t.morphAttributes;for(let c in o){let u=[],h=o[c];for(let f=0,p=h.length;f<p;f++)u.push(h[f].clone(r));this.morphAttributes[c]=u}this.morphTargetsRelative=t.morphTargetsRelative;let a=t.groups;for(let c=0,u=a.length;c<u;c++){let h=a[c];this.addGroup(h.start,h.count,h.materialIndex)}let s=t.boundingBox;s!==null&&(this.boundingBox=s.clone());let l=t.boundingSphere;return l!==null&&(this.boundingSphere=l.clone()),this.drawRange.start=t.drawRange.start,this.drawRange.count=t.drawRange.count,this.userData=t.userData,t.parameters!==void 0&&(this.parameters=Object.assign({},t.parameters)),this}dispose(){this.dispatchEvent({type:"dispose"})}};Pe.prototype.isBufferGeometry=!0;var Sue=new Me,A3=new Jf,aut=new Zf,R0=new j,N0=new j,D0=new j,sut=new j,lut=new j,cut=new j,vV=new j,xV=new j,bV=new j,wV=new Lt,SV=new Lt,MV=new Lt,uut=new j,EV=new j,ei=class extends or{constructor(t=new Pe,r=new sh){super(),this.type="Mesh",this.geometry=t,this.material=r,this.updateMorphTargets()}copy(t){return super.copy(t),t.morphTargetInfluences!==void 0&&(this.morphTargetInfluences=t.morphTargetInfluences.slice()),t.morphTargetDictionary!==void 0&&(this.morphTargetDictionary=Object.assign({},t.morphTargetDictionary)),this.material=t.material,this.geometry=t.geometry,this}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let r=t.morphAttributes,n=Object.keys(r);if(n.length>0){let i=r[n[0]];if(i!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let o=0,a=i.length;o<a;o++){let s=i[o].name||String(o);this.morphTargetInfluences.push(0),this.morphTargetDictionary[s]=o}}}}else{let r=t.morphTargets;r!==void 0&&r.length>0&&console.error("THREE.Mesh.updateMorphTargets() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}}raycast(t,r){let n=this.geometry,i=this.material,o=this.matrixWorld;if(i===void 0||(n.boundingSphere===null&&n.computeBoundingSphere(),aut.copy(n.boundingSphere),aut.applyMatrix4(o),t.ray.intersectsSphere(aut)===!1)||(Sue.copy(o).invert(),A3.copy(t.ray).applyMatrix4(Sue),n.boundingBox!==null&&A3.intersectsBox(n.boundingBox)===!1))return;let a;if(n.isBufferGeometry){let s=n.index,l=n.attributes.position,c=n.morphAttributes.position,u=n.morphTargetsRelative,h=n.attributes.uv,f=n.attributes.uv2,p=n.groups,d=n.drawRange;if(s!==null)if(Array.isArray(i))for(let g=0,_=p.length;g<_;g++){let y=p[g],x=i[y.materialIndex],b=Math.max(y.start,d.start),S=Math.min(s.count,Math.min(y.start+y.count,d.start+d.count));for(let C=b,P=S;C<P;C+=3){let k=s.getX(C),O=s.getX(C+1),D=s.getX(C+2);a=TV(this,x,t,A3,l,c,u,h,f,k,O,D),a&&(a.faceIndex=Math.floor(C/3),a.face.materialIndex=y.materialIndex,r.push(a))}}else{let g=Math.max(0,d.start),_=Math.min(s.count,d.start+d.count);for(let y=g,x=_;y<x;y+=3){let b=s.getX(y),S=s.getX(y+1),C=s.getX(y+2);a=TV(this,i,t,A3,l,c,u,h,f,b,S,C),a&&(a.faceIndex=Math.floor(y/3),r.push(a))}}else if(l!==void 0)if(Array.isArray(i))for(let g=0,_=p.length;g<_;g++){let y=p[g],x=i[y.materialIndex],b=Math.max(y.start,d.start),S=Math.min(l.count,Math.min(y.start+y.count,d.start+d.count));for(let C=b,P=S;C<P;C+=3){let k=C,O=C+1,D=C+2;a=TV(this,x,t,A3,l,c,u,h,f,k,O,D),a&&(a.faceIndex=Math.floor(C/3),a.face.materialIndex=y.materialIndex,r.push(a))}}else{let g=Math.max(0,d.start),_=Math.min(l.count,d.start+d.count);for(let y=g,x=_;y<x;y+=3){let b=y,S=y+1,C=y+2;a=TV(this,i,t,A3,l,c,u,h,f,b,S,C),a&&(a.faceIndex=Math.floor(y/3),r.push(a))}}}else n.isGeometry&&console.error("THREE.Mesh.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}};ei.prototype.isMesh=!0;function hfr(e,t,r,n,i,o,a,s){let l;if(t.side===Ii?l=n.intersectTriangle(a,o,i,!0,s):l=n.intersectTriangle(i,o,a,t.side!==Lv,s),l===null)return null;EV.copy(s),EV.applyMatrix4(e.matrixWorld);let c=r.ray.origin.distanceTo(EV);return c<r.near||c>r.far?null:{distance:c,point:EV.clone(),object:e}}function TV(e,t,r,n,i,o,a,s,l,c,u,h){R0.fromBufferAttribute(i,c),N0.fromBufferAttribute(i,u),D0.fromBufferAttribute(i,h);let f=e.morphTargetInfluences;if(o&&f){vV.set(0,0,0),xV.set(0,0,0),bV.set(0,0,0);for(let d=0,g=o.length;d<g;d++){let _=f[d],y=o[d];_!==0&&(sut.fromBufferAttribute(y,c),lut.fromBufferAttribute(y,u),cut.fromBufferAttribute(y,h),a?(vV.addScaledVector(sut,_),xV.addScaledVector(lut,_),bV.addScaledVector(cut,_)):(vV.addScaledVector(sut.sub(R0),_),xV.addScaledVector(lut.sub(N0),_),bV.addScaledVector(cut.sub(D0),_)))}R0.add(vV),N0.add(xV),D0.add(bV)}e.isSkinnedMesh&&(e.boneTransform(c,R0),e.boneTransform(u,N0),e.boneTransform(h,D0));let p=hfr(e,t,r,n,R0,N0,D0,uut);if(p){s&&(wV.fromBufferAttribute(s,c),SV.fromBufferAttribute(s,u),MV.fromBufferAttribute(s,h),p.uv=ai.getUV(uut,R0,N0,D0,wV,SV,MV,new Lt)),l&&(wV.fromBufferAttribute(l,c),SV.fromBufferAttribute(l,u),MV.fromBufferAttribute(l,h),p.uv2=ai.getUV(uut,R0,N0,D0,wV,SV,MV,new Lt));let d={a:c,b:u,c:h,normal:new j,materialIndex:0};ai.getNormal(R0,N0,D0,d.normal),p.face=d}return p}var Qf=class extends Pe{constructor(t=1,r=1,n=1,i=1,o=1,a=1){super(),this.type="BoxGeometry",this.parameters={width:t,height:r,depth:n,widthSegments:i,heightSegments:o,depthSegments:a};let s=this;i=Math.floor(i),o=Math.floor(o),a=Math.floor(a);let l=[],c=[],u=[],h=[],f=0,p=0;d("z","y","x",-1,-1,n,r,t,a,o,0),d("z","y","x",1,-1,n,r,-t,a,o,1),d("x","z","y",1,1,t,n,r,i,a,2),d("x","z","y",1,-1,t,n,-r,i,a,3),d("x","y","z",1,-1,t,r,n,i,o,4),d("x","y","z",-1,-1,t,r,-n,i,o,5),this.setIndex(l),this.setAttribute("position",new xe(c,3)),this.setAttribute("normal",new xe(u,3)),this.setAttribute("uv",new xe(h,2));function d(g,_,y,x,b,S,C,P,k,O,D){let B=S/k,I=C/O,L=S/2,R=C/2,F=P/2,z=k+1,U=O+1,W=0,Z=0,rt=new j;for(let ot=0;ot<U;ot++){let st=ot*I-R;for(let St=0;St<z;St++){let bt=St*B-L;rt[g]=bt*x,rt[_]=st*b,rt[y]=F,c.push(rt.x,rt.y,rt.z),rt[g]=0,rt[_]=0,rt[y]=P>0?1:-1,u.push(rt.x,rt.y,rt.z),h.push(St/k),h.push(1-ot/O),W+=1}}for(let ot=0;ot<O;ot++)for(let st=0;st<k;st++){let St=f+st+z*ot,bt=f+st+z*(ot+1),Mt=f+(st+1)+z*(ot+1),lt=f+(st+1)+z*ot;l.push(St,bt,lt),l.push(bt,Mt,lt),Z+=6}s.addGroup(p,Z,D),p+=Z,f+=W}}static fromJSON(t){return new Qf(t.width,t.height,t.depth,t.widthSegments,t.heightSegments,t.depthSegments)}};function Z3(e){let t={};for(let r in e){t[r]={};for(let n in e[r]){let i=e[r][n];i&&(i.isColor||i.isMatrix3||i.isMatrix4||i.isVector2||i.isVector3||i.isVector4||i.isTexture||i.isQuaternion)?t[r][n]=i.clone():Array.isArray(i)?t[r][n]=i.slice():t[r][n]=i}}return t}function Ta(e){let t={};for(let r=0;r<e.length;r++){let n=Z3(e[r]);for(let i in n)t[i]=n[i]}return t}var Ofe={clone:Z3,merge:Ta},ffr=`void main() {
	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
}`,pfr=`void main() {
	gl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );
}`,lh=class extends qi{constructor(t){super(),this.type="ShaderMaterial",this.defines={},this.uniforms={},this.vertexShader=ffr,this.fragmentShader=pfr,this.linewidth=1,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.lights=!1,this.clipping=!1,this.extensions={derivatives:!1,fragDepth:!1,drawBuffers:!1,shaderTextureLOD:!1},this.defaultAttributeValues={color:[1,1,1],uv:[0,0],uv2:[0,0]},this.index0AttributeName=void 0,this.uniformsNeedUpdate=!1,this.glslVersion=null,t!==void 0&&(t.attributes!==void 0&&console.error("THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead."),this.setValues(t))}copy(t){return super.copy(t),this.fragmentShader=t.fragmentShader,this.vertexShader=t.vertexShader,this.uniforms=Z3(t.uniforms),this.defines=Object.assign({},t.defines),this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.lights=t.lights,this.clipping=t.clipping,this.extensions=Object.assign({},t.extensions),this.glslVersion=t.glslVersion,this}toJSON(t){let r=super.toJSON(t);r.glslVersion=this.glslVersion,r.uniforms={};for(let i in this.uniforms){let a=this.uniforms[i].value;a&&a.isTexture?r.uniforms[i]={type:"t",value:a.toJSON(t).uuid}:a&&a.isColor?r.uniforms[i]={type:"c",value:a.getHex()}:a&&a.isVector2?r.uniforms[i]={type:"v2",value:a.toArray()}:a&&a.isVector3?r.uniforms[i]={type:"v3",value:a.toArray()}:a&&a.isVector4?r.uniforms[i]={type:"v4",value:a.toArray()}:a&&a.isMatrix3?r.uniforms[i]={type:"m3",value:a.toArray()}:a&&a.isMatrix4?r.uniforms[i]={type:"m4",value:a.toArray()}:r.uniforms[i]={value:a}}Object.keys(this.defines).length>0&&(r.defines=this.defines),r.vertexShader=this.vertexShader,r.fragmentShader=this.fragmentShader;let n={};for(let i in this.extensions)this.extensions[i]===!0&&(n[i]=!0);return Object.keys(n).length>0&&(r.extensions=n),r}};lh.prototype.isShaderMaterial=!0;var Rv=class extends or{constructor(){super(),this.type="Camera",this.matrixWorldInverse=new Me,this.projectionMatrix=new Me,this.projectionMatrixInverse=new Me}copy(t,r){return super.copy(t,r),this.matrixWorldInverse.copy(t.matrixWorldInverse),this.projectionMatrix.copy(t.projectionMatrix),this.projectionMatrixInverse.copy(t.projectionMatrixInverse),this}getWorldDirection(t){this.updateWorldMatrix(!0,!1);let r=this.matrixWorld.elements;return t.set(-r[8],-r[9],-r[10]).normalize()}updateMatrixWorld(t){super.updateMatrixWorld(t),this.matrixWorldInverse.copy(this.matrixWorld).invert()}updateWorldMatrix(t,r){super.updateWorldMatrix(t,r),this.matrixWorldInverse.copy(this.matrixWorld).invert()}clone(){return new this.constructor().copy(this)}};Rv.prototype.isCamera=!0;var Ui=class extends Rv{constructor(t=50,r=1,n=.1,i=2e3){super(),this.type="PerspectiveCamera",this.fov=t,this.zoom=1,this.near=n,this.far=i,this.focus=10,this.aspect=r,this.view=null,this.filmGauge=35,this.filmOffset=0,this.updateProjectionMatrix()}copy(t,r){return super.copy(t,r),this.fov=t.fov,this.zoom=t.zoom,this.near=t.near,this.far=t.far,this.focus=t.focus,this.aspect=t.aspect,this.view=t.view===null?null:Object.assign({},t.view),this.filmGauge=t.filmGauge,this.filmOffset=t.filmOffset,this}setFocalLength(t){let r=.5*this.getFilmHeight()/t;this.fov=JP*2*Math.atan(r),this.updateProjectionMatrix()}getFocalLength(){let t=Math.tan(Pv*.5*this.fov);return .5*this.getFilmHeight()/t}getEffectiveFOV(){return JP*2*Math.atan(Math.tan(Pv*.5*this.fov)/this.zoom)}getFilmWidth(){return this.filmGauge*Math.min(this.aspect,1)}getFilmHeight(){return this.filmGauge/Math.max(this.aspect,1)}setViewOffset(t,r,n,i,o,a){this.aspect=t/r,this.view===null&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=r,this.view.offsetX=n,this.view.offsetY=i,this.view.width=o,this.view.height=a,this.updateProjectionMatrix()}clearViewOffset(){this.view!==null&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let t=this.near,r=t*Math.tan(Pv*.5*this.fov)/this.zoom,n=2*r,i=this.aspect*n,o=-.5*i,a=this.view;if(this.view!==null&&this.view.enabled){let l=a.fullWidth,c=a.fullHeight;o+=a.offsetX*i/l,r-=a.offsetY*n/c,i*=a.width/l,n*=a.height/c}let s=this.filmOffset;s!==0&&(o+=t*s/this.getFilmWidth()),this.projectionMatrix.makePerspective(o,o+i,r,r-n,t,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){let r=super.toJSON(t);return r.object.fov=this.fov,r.object.zoom=this.zoom,r.object.near=this.near,r.object.far=this.far,r.object.focus=this.focus,r.object.aspect=this.aspect,this.view!==null&&(r.object.view=Object.assign({},this.view)),r.object.filmGauge=this.filmGauge,r.object.filmOffset=this.filmOffset,r}};Ui.prototype.isPerspectiveCamera=!0;var P3=90,I3=1,J3=class extends or{constructor(t,r,n){if(super(),this.type="CubeCamera",n.isWebGLCubeRenderTarget!==!0){console.error("THREE.CubeCamera: The constructor now expects an instance of WebGLCubeRenderTarget as third parameter.");return}this.renderTarget=n;let i=new Ui(P3,I3,t,r);i.layers=this.layers,i.up.set(0,-1,0),i.lookAt(new j(1,0,0)),this.add(i);let o=new Ui(P3,I3,t,r);o.layers=this.layers,o.up.set(0,-1,0),o.lookAt(new j(-1,0,0)),this.add(o);let a=new Ui(P3,I3,t,r);a.layers=this.layers,a.up.set(0,0,1),a.lookAt(new j(0,1,0)),this.add(a);let s=new Ui(P3,I3,t,r);s.layers=this.layers,s.up.set(0,0,-1),s.lookAt(new j(0,-1,0)),this.add(s);let l=new Ui(P3,I3,t,r);l.layers=this.layers,l.up.set(0,-1,0),l.lookAt(new j(0,0,1)),this.add(l);let c=new Ui(P3,I3,t,r);c.layers=this.layers,c.up.set(0,-1,0),c.lookAt(new j(0,0,-1)),this.add(c)}update(t,r){this.parent===null&&this.updateMatrixWorld();let n=this.renderTarget,[i,o,a,s,l,c]=this.children,u=t.xr.enabled,h=t.getRenderTarget();t.xr.enabled=!1;let f=n.texture.generateMipmaps;n.texture.generateMipmaps=!1,t.setRenderTarget(n,0),t.render(r,i),t.setRenderTarget(n,1),t.render(r,o),t.setRenderTarget(n,2),t.render(r,a),t.setRenderTarget(n,3),t.render(r,s),t.setRenderTarget(n,4),t.render(r,l),n.texture.generateMipmaps=f,t.setRenderTarget(n,5),t.render(r,c),t.setRenderTarget(h),t.xr.enabled=u,n.texture.needsPMREMUpdate=!0}},H0=class extends xi{constructor(t,r,n,i,o,a,s,l,c,u){t=t!==void 0?t:[],r=r!==void 0?r:nx,super(t,r,n,i,o,a,s,l,c,u),this.flipY=!1}get images(){return this.image}set images(t){this.image=t}};H0.prototype.isCubeTexture=!0;var Q3=class extends us{constructor(t,r,n){Number.isInteger(r)&&(console.warn("THREE.WebGLCubeRenderTarget: constructor signature is now WebGLCubeRenderTarget( size, options )"),r=n),super(t,t,r),r=r||{},this.texture=new H0(void 0,r.mapping,r.wrapS,r.wrapT,r.magFilter,r.minFilter,r.format,r.type,r.anisotropy,r.encoding),this.texture.isRenderTargetTexture=!0,this.texture.generateMipmaps=r.generateMipmaps!==void 0?r.generateMipmaps:!1,this.texture.minFilter=r.minFilter!==void 0?r.minFilter:oi}fromEquirectangularTexture(t,r){this.texture.type=r.type,this.texture.format=Qo,this.texture.encoding=r.encoding,this.texture.generateMipmaps=r.generateMipmaps,this.texture.minFilter=r.minFilter,this.texture.magFilter=r.magFilter;let n={uniforms:{tEquirect:{value:null}},vertexShader:`

				varying vec3 vWorldDirection;

				vec3 transformDirection( in vec3 dir, in mat4 matrix ) {

					return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );

				}

				void main() {

					vWorldDirection = transformDirection( position, modelMatrix );

					#include <begin_vertex>
					#include <project_vertex>

				}
			`,fragmentShader:`

				uniform sampler2D tEquirect;

				varying vec3 vWorldDirection;

				#include <common>

				void main() {

					vec3 direction = normalize( vWorldDirection );

					vec2 sampleUV = equirectUv( direction );

					gl_FragColor = texture2D( tEquirect, sampleUV );

				}
			`},i=new Qf(5,5,5),o=new lh({name:"CubemapFromEquirect",uniforms:Z3(n.uniforms),vertexShader:n.vertexShader,fragmentShader:n.fragmentShader,side:Ii,blending:$d});o.uniforms.tEquirect.value=r;let a=new ei(i,o),s=r.minFilter;return r.minFilter===ox&&(r.minFilter=oi),new J3(1,10,this).update(t,a),r.minFilter=s,a.geometry.dispose(),a.material.dispose(),this}clear(t,r,n,i){let o=t.getRenderTarget();for(let a=0;a<6;a++)t.setRenderTarget(this,a),t.clear(r,n,i);t.setRenderTarget(o)}};Q3.prototype.isWebGLCubeRenderTarget=!0;var hut=new j,dfr=new j,mfr=new ki,$c=class{constructor(t=new j(1,0,0),r=0){this.normal=t,this.constant=r}set(t,r){return this.normal.copy(t),this.constant=r,this}setComponents(t,r,n,i){return this.normal.set(t,r,n),this.constant=i,this}setFromNormalAndCoplanarPoint(t,r){return this.normal.copy(t),this.constant=-r.dot(this.normal),this}setFromCoplanarPoints(t,r,n){let i=hut.subVectors(n,r).cross(dfr.subVectors(t,r)).normalize();return this.setFromNormalAndCoplanarPoint(i,t),this}copy(t){return this.normal.copy(t.normal),this.constant=t.constant,this}normalize(){let t=1/this.normal.length();return this.normal.multiplyScalar(t),this.constant*=t,this}negate(){return this.constant*=-1,this.normal.negate(),this}distanceToPoint(t){return this.normal.dot(t)+this.constant}distanceToSphere(t){return this.distanceToPoint(t.center)-t.radius}projectPoint(t,r){return r.copy(this.normal).multiplyScalar(-this.distanceToPoint(t)).add(t)}intersectLine(t,r){let n=t.delta(hut),i=this.normal.dot(n);if(i===0)return this.distanceToPoint(t.start)===0?r.copy(t.start):null;let o=-(t.start.dot(this.normal)+this.constant)/i;return o<0||o>1?null:r.copy(n).multiplyScalar(o).add(t.start)}intersectsLine(t){let r=this.distanceToPoint(t.start),n=this.distanceToPoint(t.end);return r<0&&n>0||n<0&&r>0}intersectsBox(t){return t.intersectsPlane(this)}intersectsSphere(t){return t.intersectsPlane(this)}coplanarPoint(t){return t.copy(this.normal).multiplyScalar(-this.constant)}applyMatrix4(t,r){let n=r||mfr.getNormalMatrix(t),i=this.coplanarPoint(hut).applyMatrix4(t),o=this.normal.applyMatrix3(n).normalize();return this.constant=-i.dot(o),this}translate(t){return this.constant-=t.dot(this.normal),this}equals(t){return t.normal.equals(this.normal)&&t.constant===this.constant}clone(){return new this.constructor().copy(this)}};$c.prototype.isPlane=!0;var L3=new Zf,CV=new j,Nv=class{constructor(t=new $c,r=new $c,n=new $c,i=new $c,o=new $c,a=new $c){this.planes=[t,r,n,i,o,a]}set(t,r,n,i,o,a){let s=this.planes;return s[0].copy(t),s[1].copy(r),s[2].copy(n),s[3].copy(i),s[4].copy(o),s[5].copy(a),this}copy(t){let r=this.planes;for(let n=0;n<6;n++)r[n].copy(t.planes[n]);return this}setFromProjectionMatrix(t){let r=this.planes,n=t.elements,i=n[0],o=n[1],a=n[2],s=n[3],l=n[4],c=n[5],u=n[6],h=n[7],f=n[8],p=n[9],d=n[10],g=n[11],_=n[12],y=n[13],x=n[14],b=n[15];return r[0].setComponents(s-i,h-l,g-f,b-_).normalize(),r[1].setComponents(s+i,h+l,g+f,b+_).normalize(),r[2].setComponents(s+o,h+c,g+p,b+y).normalize(),r[3].setComponents(s-o,h-c,g-p,b-y).normalize(),r[4].setComponents(s-a,h-u,g-d,b-x).normalize(),r[5].setComponents(s+a,h+u,g+d,b+x).normalize(),this}intersectsObject(t){let r=t.geometry;return r.boundingSphere===null&&r.computeBoundingSphere(),L3.copy(r.boundingSphere).applyMatrix4(t.matrixWorld),this.intersectsSphere(L3)}intersectsSprite(t){return L3.center.set(0,0,0),L3.radius=.7071067811865476,L3.applyMatrix4(t.matrixWorld),this.intersectsSphere(L3)}intersectsSphere(t){let r=this.planes,n=t.center,i=-t.radius;for(let o=0;o<6;o++)if(r[o].distanceToPoint(n)<i)return!1;return!0}intersectsBox(t){let r=this.planes;for(let n=0;n<6;n++){let i=r[n];if(CV.x=i.normal.x>0?t.max.x:t.min.x,CV.y=i.normal.y>0?t.max.y:t.min.y,CV.z=i.normal.z>0?t.max.z:t.min.z,i.distanceToPoint(CV)<0)return!1}return!0}containsPoint(t){let r=this.planes;for(let n=0;n<6;n++)if(r[n].distanceToPoint(t)<0)return!1;return!0}clone(){return new this.constructor().copy(this)}};function zfe(){let e=null,t=!1,r=null,n=null;function i(o,a){r(o,a),n=e.requestAnimationFrame(i)}return{start:function(){t!==!0&&r!==null&&(n=e.requestAnimationFrame(i),t=!0)},stop:function(){e.cancelAnimationFrame(n),t=!1},setAnimationLoop:function(o){r=o},setContext:function(o){e=o}}}function gfr(e,t){let r=t.isWebGL2,n=new WeakMap;function i(c,u){let h=c.array,f=c.usage,p=e.createBuffer();e.bindBuffer(u,p),e.bufferData(u,h,f),c.onUploadCallback();let d=5126;return h instanceof Float32Array?d=5126:h instanceof Float64Array?console.warn("THREE.WebGLAttributes: Unsupported data buffer format: Float64Array."):h instanceof Uint16Array?c.isFloat16BufferAttribute?r?d=5131:console.warn("THREE.WebGLAttributes: Usage of Float16BufferAttribute requires WebGL2."):d=5123:h instanceof Int16Array?d=5122:h instanceof Uint32Array?d=5125:h instanceof Int32Array?d=5124:h instanceof Int8Array?d=5120:(h instanceof Uint8Array||h instanceof Uint8ClampedArray)&&(d=5121),{buffer:p,type:d,bytesPerElement:h.BYTES_PER_ELEMENT,version:c.version}}function o(c,u,h){let f=u.array,p=u.updateRange;e.bindBuffer(h,c),p.count===-1?e.bufferSubData(h,0,f):(r?e.bufferSubData(h,p.offset*f.BYTES_PER_ELEMENT,f,p.offset,p.count):e.bufferSubData(h,p.offset*f.BYTES_PER_ELEMENT,f.subarray(p.offset,p.offset+p.count)),p.count=-1)}function a(c){return c.isInterleavedBufferAttribute&&(c=c.data),n.get(c)}function s(c){c.isInterleavedBufferAttribute&&(c=c.data);let u=n.get(c);u&&(e.deleteBuffer(u.buffer),n.delete(c))}function l(c,u){if(c.isGLBufferAttribute){let f=n.get(c);(!f||f.version<c.version)&&n.set(c,{buffer:c.buffer,type:c.type,bytesPerElement:c.elementSize,version:c.version});return}c.isInterleavedBufferAttribute&&(c=c.data);let h=n.get(c);h===void 0?n.set(c,i(c,u)):h.version<c.version&&(o(h.buffer,c,u),h.version=c.version)}return{get:a,remove:s,update:l}}var V0=class extends Pe{constructor(t=1,r=1,n=1,i=1){super(),this.type="PlaneGeometry",this.parameters={width:t,height:r,widthSegments:n,heightSegments:i};let o=t/2,a=r/2,s=Math.floor(n),l=Math.floor(i),c=s+1,u=l+1,h=t/s,f=r/l,p=[],d=[],g=[],_=[];for(let y=0;y<u;y++){let x=y*f-a;for(let b=0;b<c;b++){let S=b*h-o;d.push(S,-x,0),g.push(0,0,1),_.push(b/s),_.push(1-y/l)}}for(let y=0;y<l;y++)for(let x=0;x<s;x++){let b=x+c*y,S=x+c*(y+1),C=x+1+c*(y+1),P=x+1+c*y;p.push(b,S,P),p.push(S,C,P)}this.setIndex(p),this.setAttribute("position",new xe(d,3)),this.setAttribute("normal",new xe(g,3)),this.setAttribute("uv",new xe(_,2))}static fromJSON(t){return new V0(t.width,t.height,t.widthSegments,t.heightSegments)}},_fr=`#ifdef USE_ALPHAMAP
	diffuseColor.a *= texture2D( alphaMap, vUv ).g;
#endif`,yfr=`#ifdef USE_ALPHAMAP
	uniform sampler2D alphaMap;
#endif`,vfr=`#ifdef USE_ALPHATEST
	if ( diffuseColor.a < alphaTest ) discard;
#endif`,xfr=`#ifdef USE_ALPHATEST
	uniform float alphaTest;
#endif`,bfr=`#ifdef USE_AOMAP
	float ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;
	reflectedLight.indirectDiffuse *= ambientOcclusion;
	#if defined( USE_ENVMAP ) && defined( STANDARD )
		float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );
		reflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.roughness );
	#endif
#endif`,wfr=`#ifdef USE_AOMAP
	uniform sampler2D aoMap;
	uniform float aoMapIntensity;
#endif`,Sfr="vec3 transformed = vec3( position );",Mfr=`vec3 objectNormal = vec3( normal );
#ifdef USE_TANGENT
	vec3 objectTangent = vec3( tangent.xyz );
#endif`,Efr=`vec3 BRDF_Lambert( const in vec3 diffuseColor ) {
	return RECIPROCAL_PI * diffuseColor;
}
vec3 F_Schlick( const in vec3 f0, const in float f90, const in float dotVH ) {
	float fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );
	return f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );
}
float V_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {
	float a2 = pow2( alpha );
	float gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );
	float gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );
	return 0.5 / max( gv + gl, EPSILON );
}
float D_GGX( const in float alpha, const in float dotNH ) {
	float a2 = pow2( alpha );
	float denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;
	return RECIPROCAL_PI * a2 / pow2( denom );
}
vec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 f0, const in float f90, const in float roughness ) {
	float alpha = pow2( roughness );
	vec3 halfDir = normalize( lightDir + viewDir );
	float dotNL = saturate( dot( normal, lightDir ) );
	float dotNV = saturate( dot( normal, viewDir ) );
	float dotNH = saturate( dot( normal, halfDir ) );
	float dotVH = saturate( dot( viewDir, halfDir ) );
	vec3 F = F_Schlick( f0, f90, dotVH );
	float V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );
	float D = D_GGX( alpha, dotNH );
	return F * ( V * D );
}
vec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {
	const float LUT_SIZE = 64.0;
	const float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;
	const float LUT_BIAS = 0.5 / LUT_SIZE;
	float dotNV = saturate( dot( N, V ) );
	vec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );
	uv = uv * LUT_SCALE + LUT_BIAS;
	return uv;
}
float LTC_ClippedSphereFormFactor( const in vec3 f ) {
	float l = length( f );
	return max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );
}
vec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {
	float x = dot( v1, v2 );
	float y = abs( x );
	float a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;
	float b = 3.4175940 + ( 4.1616724 + y ) * y;
	float v = a / b;
	float theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;
	return cross( v1, v2 ) * theta_sintheta;
}
vec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {
	vec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];
	vec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];
	vec3 lightNormal = cross( v1, v2 );
	if( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );
	vec3 T1, T2;
	T1 = normalize( V - N * dot( V, N ) );
	T2 = - cross( N, T1 );
	mat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );
	vec3 coords[ 4 ];
	coords[ 0 ] = mat * ( rectCoords[ 0 ] - P );
	coords[ 1 ] = mat * ( rectCoords[ 1 ] - P );
	coords[ 2 ] = mat * ( rectCoords[ 2 ] - P );
	coords[ 3 ] = mat * ( rectCoords[ 3 ] - P );
	coords[ 0 ] = normalize( coords[ 0 ] );
	coords[ 1 ] = normalize( coords[ 1 ] );
	coords[ 2 ] = normalize( coords[ 2 ] );
	coords[ 3 ] = normalize( coords[ 3 ] );
	vec3 vectorFormFactor = vec3( 0.0 );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );
	vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );
	float result = LTC_ClippedSphereFormFactor( vectorFormFactor );
	return vec3( result );
}
float G_BlinnPhong_Implicit( ) {
	return 0.25;
}
float D_BlinnPhong( const in float shininess, const in float dotNH ) {
	return RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );
}
vec3 BRDF_BlinnPhong( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float shininess ) {
	vec3 halfDir = normalize( lightDir + viewDir );
	float dotNH = saturate( dot( normal, halfDir ) );
	float dotVH = saturate( dot( viewDir, halfDir ) );
	vec3 F = F_Schlick( specularColor, 1.0, dotVH );
	float G = G_BlinnPhong_Implicit( );
	float D = D_BlinnPhong( shininess, dotNH );
	return F * ( G * D );
}
#if defined( USE_SHEEN )
float D_Charlie( float roughness, float dotNH ) {
	float alpha = pow2( roughness );
	float invAlpha = 1.0 / alpha;
	float cos2h = dotNH * dotNH;
	float sin2h = max( 1.0 - cos2h, 0.0078125 );
	return ( 2.0 + invAlpha ) * pow( sin2h, invAlpha * 0.5 ) / ( 2.0 * PI );
}
float V_Neubelt( float dotNV, float dotNL ) {
	return saturate( 1.0 / ( 4.0 * ( dotNL + dotNV - dotNL * dotNV ) ) );
}
vec3 BRDF_Sheen( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, vec3 sheenColor, const in float sheenRoughness ) {
	vec3 halfDir = normalize( lightDir + viewDir );
	float dotNL = saturate( dot( normal, lightDir ) );
	float dotNV = saturate( dot( normal, viewDir ) );
	float dotNH = saturate( dot( normal, halfDir ) );
	float D = D_Charlie( sheenRoughness, dotNH );
	float V = V_Neubelt( dotNV, dotNL );
	return sheenColor * ( D * V );
}
#endif`,Tfr=`#ifdef USE_BUMPMAP
	uniform sampler2D bumpMap;
	uniform float bumpScale;
	vec2 dHdxy_fwd() {
		vec2 dSTdx = dFdx( vUv );
		vec2 dSTdy = dFdy( vUv );
		float Hll = bumpScale * texture2D( bumpMap, vUv ).x;
		float dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;
		float dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;
		return vec2( dBx, dBy );
	}
	vec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy, float faceDirection ) {
		vec3 vSigmaX = vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );
		vec3 vSigmaY = vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );
		vec3 vN = surf_norm;
		vec3 R1 = cross( vSigmaY, vN );
		vec3 R2 = cross( vN, vSigmaX );
		float fDet = dot( vSigmaX, R1 ) * faceDirection;
		vec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );
		return normalize( abs( fDet ) * surf_norm - vGrad );
	}
#endif`,Cfr=`#if NUM_CLIPPING_PLANES > 0
	vec4 plane;
	#pragma unroll_loop_start
	for ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {
		plane = clippingPlanes[ i ];
		if ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;
	}
	#pragma unroll_loop_end
	#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES
		bool clipped = true;
		#pragma unroll_loop_start
		for ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {
			plane = clippingPlanes[ i ];
			clipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;
		}
		#pragma unroll_loop_end
		if ( clipped ) discard;
	#endif
#endif`,Afr=`#if NUM_CLIPPING_PLANES > 0
	varying vec3 vClipPosition;
	uniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];
#endif`,Pfr=`#if NUM_CLIPPING_PLANES > 0
	varying vec3 vClipPosition;
#endif`,Ifr=`#if NUM_CLIPPING_PLANES > 0
	vClipPosition = - mvPosition.xyz;
#endif`,Lfr=`#if defined( USE_COLOR_ALPHA )
	diffuseColor *= vColor;
#elif defined( USE_COLOR )
	diffuseColor.rgb *= vColor;
#endif`,kfr=`#if defined( USE_COLOR_ALPHA )
	varying vec4 vColor;
#elif defined( USE_COLOR )
	varying vec3 vColor;
#endif`,Rfr=`#if defined( USE_COLOR_ALPHA )
	varying vec4 vColor;
#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
	varying vec3 vColor;
#endif`,Nfr=`#if defined( USE_COLOR_ALPHA )
	vColor = vec4( 1.0 );
#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
	vColor = vec3( 1.0 );
#endif
#ifdef USE_COLOR
	vColor *= color;
#endif
#ifdef USE_INSTANCING_COLOR
	vColor.xyz *= instanceColor.xyz;
#endif`,Dfr=`#define PI 3.141592653589793
#define PI2 6.283185307179586
#define PI_HALF 1.5707963267948966
#define RECIPROCAL_PI 0.3183098861837907
#define RECIPROCAL_PI2 0.15915494309189535
#define EPSILON 1e-6
#ifndef saturate
#define saturate( a ) clamp( a, 0.0, 1.0 )
#endif
#define whiteComplement( a ) ( 1.0 - saturate( a ) )
float pow2( const in float x ) { return x*x; }
float pow3( const in float x ) { return x*x*x; }
float pow4( const in float x ) { float x2 = x*x; return x2*x2; }
float max3( const in vec3 v ) { return max( max( v.x, v.y ), v.z ); }
float average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }
highp float rand( const in vec2 uv ) {
	const highp float a = 12.9898, b = 78.233, c = 43758.5453;
	highp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );
	return fract( sin( sn ) * c );
}
#ifdef HIGH_PRECISION
	float precisionSafeLength( vec3 v ) { return length( v ); }
#else
	float precisionSafeLength( vec3 v ) {
		float maxComponent = max3( abs( v ) );
		return length( v / maxComponent ) * maxComponent;
	}
#endif
struct IncidentLight {
	vec3 color;
	vec3 direction;
	bool visible;
};
struct ReflectedLight {
	vec3 directDiffuse;
	vec3 directSpecular;
	vec3 indirectDiffuse;
	vec3 indirectSpecular;
};
struct GeometricContext {
	vec3 position;
	vec3 normal;
	vec3 viewDir;
#ifdef USE_CLEARCOAT
	vec3 clearcoatNormal;
#endif
};
vec3 transformDirection( in vec3 dir, in mat4 matrix ) {
	return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );
}
vec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {
	return normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );
}
mat3 transposeMat3( const in mat3 m ) {
	mat3 tmp;
	tmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );
	tmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );
	tmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );
	return tmp;
}
float linearToRelativeLuminance( const in vec3 color ) {
	vec3 weights = vec3( 0.2126, 0.7152, 0.0722 );
	return dot( weights, color.rgb );
}
bool isPerspectiveMatrix( mat4 m ) {
	return m[ 2 ][ 3 ] == - 1.0;
}
vec2 equirectUv( in vec3 dir ) {
	float u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;
	float v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;
	return vec2( u, v );
}`,Ofr=`#ifdef ENVMAP_TYPE_CUBE_UV
	#define cubeUV_maxMipLevel 8.0
	#define cubeUV_minMipLevel 4.0
	#define cubeUV_maxTileSize 256.0
	#define cubeUV_minTileSize 16.0
	float getFace( vec3 direction ) {
		vec3 absDirection = abs( direction );
		float face = - 1.0;
		if ( absDirection.x > absDirection.z ) {
			if ( absDirection.x > absDirection.y )
				face = direction.x > 0.0 ? 0.0 : 3.0;
			else
				face = direction.y > 0.0 ? 1.0 : 4.0;
		} else {
			if ( absDirection.z > absDirection.y )
				face = direction.z > 0.0 ? 2.0 : 5.0;
			else
				face = direction.y > 0.0 ? 1.0 : 4.0;
		}
		return face;
	}
	vec2 getUV( vec3 direction, float face ) {
		vec2 uv;
		if ( face == 0.0 ) {
			uv = vec2( direction.z, direction.y ) / abs( direction.x );
		} else if ( face == 1.0 ) {
			uv = vec2( - direction.x, - direction.z ) / abs( direction.y );
		} else if ( face == 2.0 ) {
			uv = vec2( - direction.x, direction.y ) / abs( direction.z );
		} else if ( face == 3.0 ) {
			uv = vec2( - direction.z, direction.y ) / abs( direction.x );
		} else if ( face == 4.0 ) {
			uv = vec2( - direction.x, direction.z ) / abs( direction.y );
		} else {
			uv = vec2( direction.x, direction.y ) / abs( direction.z );
		}
		return 0.5 * ( uv + 1.0 );
	}
	vec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {
		float face = getFace( direction );
		float filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );
		mipInt = max( mipInt, cubeUV_minMipLevel );
		float faceSize = exp2( mipInt );
		float texelSize = 1.0 / ( 3.0 * cubeUV_maxTileSize );
		vec2 uv = getUV( direction, face ) * ( faceSize - 1.0 ) + 0.5;
		if ( face > 2.0 ) {
			uv.y += faceSize;
			face -= 3.0;
		}
		uv.x += face * faceSize;
		if ( mipInt < cubeUV_maxMipLevel ) {
			uv.y += 2.0 * cubeUV_maxTileSize;
		}
		uv.y += filterInt * 2.0 * cubeUV_minTileSize;
		uv.x += 3.0 * max( 0.0, cubeUV_maxTileSize - 2.0 * faceSize );
		uv *= texelSize;
		return texture2D( envMap, uv ).rgb;
	}
	#define r0 1.0
	#define v0 0.339
	#define m0 - 2.0
	#define r1 0.8
	#define v1 0.276
	#define m1 - 1.0
	#define r4 0.4
	#define v4 0.046
	#define m4 2.0
	#define r5 0.305
	#define v5 0.016
	#define m5 3.0
	#define r6 0.21
	#define v6 0.0038
	#define m6 4.0
	float roughnessToMip( float roughness ) {
		float mip = 0.0;
		if ( roughness >= r1 ) {
			mip = ( r0 - roughness ) * ( m1 - m0 ) / ( r0 - r1 ) + m0;
		} else if ( roughness >= r4 ) {
			mip = ( r1 - roughness ) * ( m4 - m1 ) / ( r1 - r4 ) + m1;
		} else if ( roughness >= r5 ) {
			mip = ( r4 - roughness ) * ( m5 - m4 ) / ( r4 - r5 ) + m4;
		} else if ( roughness >= r6 ) {
			mip = ( r5 - roughness ) * ( m6 - m5 ) / ( r5 - r6 ) + m5;
		} else {
			mip = - 2.0 * log2( 1.16 * roughness );		}
		return mip;
	}
	vec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {
		float mip = clamp( roughnessToMip( roughness ), m0, cubeUV_maxMipLevel );
		float mipF = fract( mip );
		float mipInt = floor( mip );
		vec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );
		if ( mipF == 0.0 ) {
			return vec4( color0, 1.0 );
		} else {
			vec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );
			return vec4( mix( color0, color1, mipF ), 1.0 );
		}
	}
#endif`,zfr=`vec3 transformedNormal = objectNormal;
#ifdef USE_INSTANCING
	mat3 m = mat3( instanceMatrix );
	transformedNormal /= vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) );
	transformedNormal = m * transformedNormal;
#endif
transformedNormal = normalMatrix * transformedNormal;
#ifdef FLIP_SIDED
	transformedNormal = - transformedNormal;
#endif
#ifdef USE_TANGENT
	vec3 transformedTangent = ( modelViewMatrix * vec4( objectTangent, 0.0 ) ).xyz;
	#ifdef FLIP_SIDED
		transformedTangent = - transformedTangent;
	#endif
#endif`,Ffr=`#ifdef USE_DISPLACEMENTMAP
	uniform sampler2D displacementMap;
	uniform float displacementScale;
	uniform float displacementBias;
#endif`,Bfr=`#ifdef USE_DISPLACEMENTMAP
	transformed += normalize( objectNormal ) * ( texture2D( displacementMap, vUv ).x * displacementScale + displacementBias );
#endif`,Hfr=`#ifdef USE_EMISSIVEMAP
	vec4 emissiveColor = texture2D( emissiveMap, vUv );
	totalEmissiveRadiance *= emissiveColor.rgb;
#endif`,Vfr=`#ifdef USE_EMISSIVEMAP
	uniform sampler2D emissiveMap;
#endif`,Ufr="gl_FragColor = linearToOutputTexel( gl_FragColor );",qfr=`vec4 LinearToLinear( in vec4 value ) {
	return value;
}
vec4 LinearTosRGB( in vec4 value ) {
	return vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );
}`,Gfr=`#ifdef USE_ENVMAP
	#ifdef ENV_WORLDPOS
		vec3 cameraToFrag;
		if ( isOrthographic ) {
			cameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );
		} else {
			cameraToFrag = normalize( vWorldPosition - cameraPosition );
		}
		vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
		#ifdef ENVMAP_MODE_REFLECTION
			vec3 reflectVec = reflect( cameraToFrag, worldNormal );
		#else
			vec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );
		#endif
	#else
		vec3 reflectVec = vReflect;
	#endif
	#ifdef ENVMAP_TYPE_CUBE
		vec4 envColor = textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );
	#elif defined( ENVMAP_TYPE_CUBE_UV )
		vec4 envColor = textureCubeUV( envMap, reflectVec, 0.0 );
	#else
		vec4 envColor = vec4( 0.0 );
	#endif
	#ifdef ENVMAP_BLENDING_MULTIPLY
		outgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );
	#elif defined( ENVMAP_BLENDING_MIX )
		outgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );
	#elif defined( ENVMAP_BLENDING_ADD )
		outgoingLight += envColor.xyz * specularStrength * reflectivity;
	#endif
#endif`,Wfr=`#ifdef USE_ENVMAP
	uniform float envMapIntensity;
	uniform float flipEnvMap;
	#ifdef ENVMAP_TYPE_CUBE
		uniform samplerCube envMap;
	#else
		uniform sampler2D envMap;
	#endif
	
#endif`,Yfr=`#ifdef USE_ENVMAP
	uniform float reflectivity;
	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )
		#define ENV_WORLDPOS
	#endif
	#ifdef ENV_WORLDPOS
		varying vec3 vWorldPosition;
		uniform float refractionRatio;
	#else
		varying vec3 vReflect;
	#endif
#endif`,jfr=`#ifdef USE_ENVMAP
	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) ||defined( PHONG )
		#define ENV_WORLDPOS
	#endif
	#ifdef ENV_WORLDPOS
		
		varying vec3 vWorldPosition;
	#else
		varying vec3 vReflect;
		uniform float refractionRatio;
	#endif
#endif`,Xfr=`#ifdef USE_ENVMAP
	#ifdef ENV_WORLDPOS
		vWorldPosition = worldPosition.xyz;
	#else
		vec3 cameraToVertex;
		if ( isOrthographic ) {
			cameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );
		} else {
			cameraToVertex = normalize( worldPosition.xyz - cameraPosition );
		}
		vec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
		#ifdef ENVMAP_MODE_REFLECTION
			vReflect = reflect( cameraToVertex, worldNormal );
		#else
			vReflect = refract( cameraToVertex, worldNormal, refractionRatio );
		#endif
	#endif
#endif`,$fr=`#ifdef USE_FOG
	vFogDepth = - mvPosition.z;
#endif`,Kfr=`#ifdef USE_FOG
	varying float vFogDepth;
#endif`,Zfr=`#ifdef USE_FOG
	#ifdef FOG_EXP2
		float fogFactor = 1.0 - exp( - fogDensity * fogDensity * vFogDepth * vFogDepth );
	#else
		float fogFactor = smoothstep( fogNear, fogFar, vFogDepth );
	#endif
	gl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );
#endif`,Jfr=`#ifdef USE_FOG
	uniform vec3 fogColor;
	varying float vFogDepth;
	#ifdef FOG_EXP2
		uniform float fogDensity;
	#else
		uniform float fogNear;
		uniform float fogFar;
	#endif
#endif`,Qfr=`#ifdef USE_GRADIENTMAP
	uniform sampler2D gradientMap;
#endif
vec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {
	float dotNL = dot( normal, lightDirection );
	vec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );
	#ifdef USE_GRADIENTMAP
		return vec3( texture2D( gradientMap, coord ).r );
	#else
		return ( coord.x < 0.7 ) ? vec3( 0.7 ) : vec3( 1.0 );
	#endif
}`,tpr=`#ifdef USE_LIGHTMAP
	vec4 lightMapTexel = texture2D( lightMap, vUv2 );
	vec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;
	#ifndef PHYSICALLY_CORRECT_LIGHTS
		lightMapIrradiance *= PI;
	#endif
	reflectedLight.indirectDiffuse += lightMapIrradiance;
#endif`,epr=`#ifdef USE_LIGHTMAP
	uniform sampler2D lightMap;
	uniform float lightMapIntensity;
#endif`,rpr=`vec3 diffuse = vec3( 1.0 );
GeometricContext geometry;
geometry.position = mvPosition.xyz;
geometry.normal = normalize( transformedNormal );
geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -mvPosition.xyz );
GeometricContext backGeometry;
backGeometry.position = geometry.position;
backGeometry.normal = -geometry.normal;
backGeometry.viewDir = geometry.viewDir;
vLightFront = vec3( 0.0 );
vIndirectFront = vec3( 0.0 );
#ifdef DOUBLE_SIDED
	vLightBack = vec3( 0.0 );
	vIndirectBack = vec3( 0.0 );
#endif
IncidentLight directLight;
float dotNL;
vec3 directLightColor_Diffuse;
vIndirectFront += getAmbientLightIrradiance( ambientLightColor );
vIndirectFront += getLightProbeIrradiance( lightProbe, geometry.normal );
#ifdef DOUBLE_SIDED
	vIndirectBack += getAmbientLightIrradiance( ambientLightColor );
	vIndirectBack += getLightProbeIrradiance( lightProbe, backGeometry.normal );
#endif
#if NUM_POINT_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {
		getPointLightInfo( pointLights[ i ], geometry, directLight );
		dotNL = dot( geometry.normal, directLight.direction );
		directLightColor_Diffuse = directLight.color;
		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
		#ifdef DOUBLE_SIDED
			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
		#endif
	}
	#pragma unroll_loop_end
#endif
#if NUM_SPOT_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {
		getSpotLightInfo( spotLights[ i ], geometry, directLight );
		dotNL = dot( geometry.normal, directLight.direction );
		directLightColor_Diffuse = directLight.color;
		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
		#ifdef DOUBLE_SIDED
			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
		#endif
	}
	#pragma unroll_loop_end
#endif
#if NUM_DIR_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
		getDirectionalLightInfo( directionalLights[ i ], geometry, directLight );
		dotNL = dot( geometry.normal, directLight.direction );
		directLightColor_Diffuse = directLight.color;
		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
		#ifdef DOUBLE_SIDED
			vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
		#endif
	}
	#pragma unroll_loop_end
#endif
#if NUM_HEMI_LIGHTS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
		vIndirectFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );
		#ifdef DOUBLE_SIDED
			vIndirectBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry.normal );
		#endif
	}
	#pragma unroll_loop_end
#endif`,npr=`uniform bool receiveShadow;
uniform vec3 ambientLightColor;
uniform vec3 lightProbe[ 9 ];
vec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {
	float x = normal.x, y = normal.y, z = normal.z;
	vec3 result = shCoefficients[ 0 ] * 0.886227;
	result += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;
	result += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;
	result += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;
	result += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;
	result += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;
	result += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );
	result += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;
	result += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );
	return result;
}
vec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in vec3 normal ) {
	vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
	vec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );
	return irradiance;
}
vec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {
	vec3 irradiance = ambientLightColor;
	return irradiance;
}
float getDistanceAttenuation( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {
	#if defined ( PHYSICALLY_CORRECT_LIGHTS )
		float distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );
		if ( cutoffDistance > 0.0 ) {
			distanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );
		}
		return distanceFalloff;
	#else
		if ( cutoffDistance > 0.0 && decayExponent > 0.0 ) {
			return pow( saturate( - lightDistance / cutoffDistance + 1.0 ), decayExponent );
		}
		return 1.0;
	#endif
}
float getSpotAttenuation( const in float coneCosine, const in float penumbraCosine, const in float angleCosine ) {
	return smoothstep( coneCosine, penumbraCosine, angleCosine );
}
#if NUM_DIR_LIGHTS > 0
	struct DirectionalLight {
		vec3 direction;
		vec3 color;
	};
	uniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];
	void getDirectionalLightInfo( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight light ) {
		light.color = directionalLight.color;
		light.direction = directionalLight.direction;
		light.visible = true;
	}
#endif
#if NUM_POINT_LIGHTS > 0
	struct PointLight {
		vec3 position;
		vec3 color;
		float distance;
		float decay;
	};
	uniform PointLight pointLights[ NUM_POINT_LIGHTS ];
	void getPointLightInfo( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight light ) {
		vec3 lVector = pointLight.position - geometry.position;
		light.direction = normalize( lVector );
		float lightDistance = length( lVector );
		light.color = pointLight.color;
		light.color *= getDistanceAttenuation( lightDistance, pointLight.distance, pointLight.decay );
		light.visible = ( light.color != vec3( 0.0 ) );
	}
#endif
#if NUM_SPOT_LIGHTS > 0
	struct SpotLight {
		vec3 position;
		vec3 direction;
		vec3 color;
		float distance;
		float decay;
		float coneCos;
		float penumbraCos;
	};
	uniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];
	void getSpotLightInfo( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight light ) {
		vec3 lVector = spotLight.position - geometry.position;
		light.direction = normalize( lVector );
		float angleCos = dot( light.direction, spotLight.direction );
		float spotAttenuation = getSpotAttenuation( spotLight.coneCos, spotLight.penumbraCos, angleCos );
		if ( spotAttenuation > 0.0 ) {
			float lightDistance = length( lVector );
			light.color = spotLight.color * spotAttenuation;
			light.color *= getDistanceAttenuation( lightDistance, spotLight.distance, spotLight.decay );
			light.visible = ( light.color != vec3( 0.0 ) );
		} else {
			light.color = vec3( 0.0 );
			light.visible = false;
		}
	}
#endif
#if NUM_RECT_AREA_LIGHTS > 0
	struct RectAreaLight {
		vec3 color;
		vec3 position;
		vec3 halfWidth;
		vec3 halfHeight;
	};
	uniform sampler2D ltc_1;	uniform sampler2D ltc_2;
	uniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];
#endif
#if NUM_HEMI_LIGHTS > 0
	struct HemisphereLight {
		vec3 direction;
		vec3 skyColor;
		vec3 groundColor;
	};
	uniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];
	vec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in vec3 normal ) {
		float dotNL = dot( normal, hemiLight.direction );
		float hemiDiffuseWeight = 0.5 * dotNL + 0.5;
		vec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );
		return irradiance;
	}
#endif`,ipr=`#if defined( USE_ENVMAP )
	#ifdef ENVMAP_MODE_REFRACTION
		uniform float refractionRatio;
	#endif
	vec3 getIBLIrradiance( const in vec3 normal ) {
		#if defined( ENVMAP_TYPE_CUBE_UV )
			vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
			vec4 envMapColor = textureCubeUV( envMap, worldNormal, 1.0 );
			return PI * envMapColor.rgb * envMapIntensity;
		#else
			return vec3( 0.0 );
		#endif
	}
	vec3 getIBLRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {
		#if defined( ENVMAP_TYPE_CUBE_UV )
			vec3 reflectVec;
			#ifdef ENVMAP_MODE_REFLECTION
				reflectVec = reflect( - viewDir, normal );
				reflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );
			#else
				reflectVec = refract( - viewDir, normal, refractionRatio );
			#endif
			reflectVec = inverseTransformDirection( reflectVec, viewMatrix );
			vec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness );
			return envMapColor.rgb * envMapIntensity;
		#else
			return vec3( 0.0 );
		#endif
	}
#endif`,opr=`ToonMaterial material;
material.diffuseColor = diffuseColor.rgb;`,apr=`varying vec3 vViewPosition;
struct ToonMaterial {
	vec3 diffuseColor;
};
void RE_Direct_Toon( const in IncidentLight directLight, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {
	vec3 irradiance = getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;
	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
void RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {
	reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
#define RE_Direct				RE_Direct_Toon
#define RE_IndirectDiffuse		RE_IndirectDiffuse_Toon
#define Material_LightProbeLOD( material )	(0)`,spr=`BlinnPhongMaterial material;
material.diffuseColor = diffuseColor.rgb;
material.specularColor = specular;
material.specularShininess = shininess;
material.specularStrength = specularStrength;`,lpr=`varying vec3 vViewPosition;
struct BlinnPhongMaterial {
	vec3 diffuseColor;
	vec3 specularColor;
	float specularShininess;
	float specularStrength;
};
void RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {
	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
	vec3 irradiance = dotNL * directLight.color;
	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
	reflectedLight.directSpecular += irradiance * BRDF_BlinnPhong( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularShininess ) * material.specularStrength;
}
void RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {
	reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
#define RE_Direct				RE_Direct_BlinnPhong
#define RE_IndirectDiffuse		RE_IndirectDiffuse_BlinnPhong
#define Material_LightProbeLOD( material )	(0)`,cpr=`PhysicalMaterial material;
material.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );
vec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );
float geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );
material.roughness = max( roughnessFactor, 0.0525 );material.roughness += geometryRoughness;
material.roughness = min( material.roughness, 1.0 );
#ifdef IOR
	#ifdef SPECULAR
		float specularIntensityFactor = specularIntensity;
		vec3 specularColorFactor = specularColor;
		#ifdef USE_SPECULARINTENSITYMAP
			specularIntensityFactor *= texture2D( specularIntensityMap, vUv ).a;
		#endif
		#ifdef USE_SPECULARCOLORMAP
			specularColorFactor *= texture2D( specularColorMap, vUv ).rgb;
		#endif
		material.specularF90 = mix( specularIntensityFactor, 1.0, metalnessFactor );
	#else
		float specularIntensityFactor = 1.0;
		vec3 specularColorFactor = vec3( 1.0 );
		material.specularF90 = 1.0;
	#endif
	material.specularColor = mix( min( pow2( ( ior - 1.0 ) / ( ior + 1.0 ) ) * specularColorFactor, vec3( 1.0 ) ) * specularIntensityFactor, diffuseColor.rgb, metalnessFactor );
#else
	material.specularColor = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessFactor );
	material.specularF90 = 1.0;
#endif
#ifdef USE_CLEARCOAT
	material.clearcoat = clearcoat;
	material.clearcoatRoughness = clearcoatRoughness;
	material.clearcoatF0 = vec3( 0.04 );
	material.clearcoatF90 = 1.0;
	#ifdef USE_CLEARCOATMAP
		material.clearcoat *= texture2D( clearcoatMap, vUv ).x;
	#endif
	#ifdef USE_CLEARCOAT_ROUGHNESSMAP
		material.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vUv ).y;
	#endif
	material.clearcoat = saturate( material.clearcoat );	material.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );
	material.clearcoatRoughness += geometryRoughness;
	material.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );
#endif
#ifdef USE_SHEEN
	material.sheenColor = sheenColor;
	#ifdef USE_SHEENCOLORMAP
		material.sheenColor *= texture2D( sheenColorMap, vUv ).rgb;
	#endif
	material.sheenRoughness = clamp( sheenRoughness, 0.07, 1.0 );
	#ifdef USE_SHEENROUGHNESSMAP
		material.sheenRoughness *= texture2D( sheenRoughnessMap, vUv ).a;
	#endif
#endif`,upr=`struct PhysicalMaterial {
	vec3 diffuseColor;
	float roughness;
	vec3 specularColor;
	float specularF90;
	#ifdef USE_CLEARCOAT
		float clearcoat;
		float clearcoatRoughness;
		vec3 clearcoatF0;
		float clearcoatF90;
	#endif
	#ifdef USE_SHEEN
		vec3 sheenColor;
		float sheenRoughness;
	#endif
};
vec3 clearcoatSpecular = vec3( 0.0 );
vec3 sheenSpecular = vec3( 0.0 );
float IBLSheenBRDF( const in vec3 normal, const in vec3 viewDir, const in float roughness) {
	float dotNV = saturate( dot( normal, viewDir ) );
	float r2 = roughness * roughness;
	float a = roughness < 0.25 ? -339.2 * r2 + 161.4 * roughness - 25.9 : -8.48 * r2 + 14.3 * roughness - 9.95;
	float b = roughness < 0.25 ? 44.0 * r2 - 23.7 * roughness + 3.26 : 1.97 * r2 - 3.27 * roughness + 0.72;
	float DG = exp( a * dotNV + b ) + ( roughness < 0.25 ? 0.0 : 0.1 * ( roughness - 0.25 ) );
	return saturate( DG * RECIPROCAL_PI );
}
vec2 DFGApprox( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {
	float dotNV = saturate( dot( normal, viewDir ) );
	const vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );
	const vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );
	vec4 r = roughness * c0 + c1;
	float a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;
	vec2 fab = vec2( - 1.04, 1.04 ) * a004 + r.zw;
	return fab;
}
vec3 EnvironmentBRDF( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness ) {
	vec2 fab = DFGApprox( normal, viewDir, roughness );
	return specularColor * fab.x + specularF90 * fab.y;
}
void computeMultiscattering( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {
	vec2 fab = DFGApprox( normal, viewDir, roughness );
	vec3 FssEss = specularColor * fab.x + specularF90 * fab.y;
	float Ess = fab.x + fab.y;
	float Ems = 1.0 - Ess;
	vec3 Favg = specularColor + ( 1.0 - specularColor ) * 0.047619;	vec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );
	singleScatter += FssEss;
	multiScatter += Fms * Ems;
}
#if NUM_RECT_AREA_LIGHTS > 0
	void RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
		vec3 normal = geometry.normal;
		vec3 viewDir = geometry.viewDir;
		vec3 position = geometry.position;
		vec3 lightPos = rectAreaLight.position;
		vec3 halfWidth = rectAreaLight.halfWidth;
		vec3 halfHeight = rectAreaLight.halfHeight;
		vec3 lightColor = rectAreaLight.color;
		float roughness = material.roughness;
		vec3 rectCoords[ 4 ];
		rectCoords[ 0 ] = lightPos + halfWidth - halfHeight;		rectCoords[ 1 ] = lightPos - halfWidth - halfHeight;
		rectCoords[ 2 ] = lightPos - halfWidth + halfHeight;
		rectCoords[ 3 ] = lightPos + halfWidth + halfHeight;
		vec2 uv = LTC_Uv( normal, viewDir, roughness );
		vec4 t1 = texture2D( ltc_1, uv );
		vec4 t2 = texture2D( ltc_2, uv );
		mat3 mInv = mat3(
			vec3( t1.x, 0, t1.y ),
			vec3(    0, 1,    0 ),
			vec3( t1.z, 0, t1.w )
		);
		vec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );
		reflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );
		reflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );
	}
#endif
void RE_Direct_Physical( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
	vec3 irradiance = dotNL * directLight.color;
	#ifdef USE_CLEARCOAT
		float dotNLcc = saturate( dot( geometry.clearcoatNormal, directLight.direction ) );
		vec3 ccIrradiance = dotNLcc * directLight.color;
		clearcoatSpecular += ccIrradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.clearcoatNormal, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );
	#endif
	#ifdef USE_SHEEN
		sheenSpecular += irradiance * BRDF_Sheen( directLight.direction, geometry.viewDir, geometry.normal, material.sheenColor, material.sheenRoughness );
	#endif
	reflectedLight.directSpecular += irradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularF90, material.roughness );
	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
void RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
	reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
}
void RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {
	#ifdef USE_CLEARCOAT
		clearcoatSpecular += clearcoatRadiance * EnvironmentBRDF( geometry.clearcoatNormal, geometry.viewDir, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );
	#endif
	#ifdef USE_SHEEN
		sheenSpecular += irradiance * material.sheenColor * IBLSheenBRDF( geometry.normal, geometry.viewDir, material.sheenRoughness );
	#endif
	vec3 singleScattering = vec3( 0.0 );
	vec3 multiScattering = vec3( 0.0 );
	vec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;
	computeMultiscattering( geometry.normal, geometry.viewDir, material.specularColor, material.specularF90, material.roughness, singleScattering, multiScattering );
	vec3 diffuse = material.diffuseColor * ( 1.0 - ( singleScattering + multiScattering ) );
	reflectedLight.indirectSpecular += radiance * singleScattering;
	reflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;
	reflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;
}
#define RE_Direct				RE_Direct_Physical
#define RE_Direct_RectArea		RE_Direct_RectArea_Physical
#define RE_IndirectDiffuse		RE_IndirectDiffuse_Physical
#define RE_IndirectSpecular		RE_IndirectSpecular_Physical
float computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {
	return saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );
}`,hpr=`
GeometricContext geometry;
geometry.position = - vViewPosition;
geometry.normal = normal;
geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );
#ifdef USE_CLEARCOAT
	geometry.clearcoatNormal = clearcoatNormal;
#endif
IncidentLight directLight;
#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )
	PointLight pointLight;
	#if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0
	PointLightShadow pointLightShadow;
	#endif
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {
		pointLight = pointLights[ i ];
		getPointLightInfo( pointLight, geometry, directLight );
		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )
		pointLightShadow = pointLightShadows[ i ];
		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;
		#endif
		RE_Direct( directLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )
	SpotLight spotLight;
	#if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0
	SpotLightShadow spotLightShadow;
	#endif
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {
		spotLight = spotLights[ i ];
		getSpotLightInfo( spotLight, geometry, directLight );
		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )
		spotLightShadow = spotLightShadows[ i ];
		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;
		#endif
		RE_Direct( directLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )
	DirectionalLight directionalLight;
	#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0
	DirectionalLightShadow directionalLightShadow;
	#endif
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
		directionalLight = directionalLights[ i ];
		getDirectionalLightInfo( directionalLight, geometry, directLight );
		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )
		directionalLightShadow = directionalLightShadows[ i ];
		directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
		#endif
		RE_Direct( directLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )
	RectAreaLight rectAreaLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {
		rectAreaLight = rectAreaLights[ i ];
		RE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );
	}
	#pragma unroll_loop_end
#endif
#if defined( RE_IndirectDiffuse )
	vec3 iblIrradiance = vec3( 0.0 );
	vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );
	irradiance += getLightProbeIrradiance( lightProbe, geometry.normal );
	#if ( NUM_HEMI_LIGHTS > 0 )
		#pragma unroll_loop_start
		for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
			irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );
		}
		#pragma unroll_loop_end
	#endif
#endif
#if defined( RE_IndirectSpecular )
	vec3 radiance = vec3( 0.0 );
	vec3 clearcoatRadiance = vec3( 0.0 );
#endif`,fpr=`#if defined( RE_IndirectDiffuse )
	#ifdef USE_LIGHTMAP
		vec4 lightMapTexel = texture2D( lightMap, vUv2 );
		vec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;
		#ifndef PHYSICALLY_CORRECT_LIGHTS
			lightMapIrradiance *= PI;
		#endif
		irradiance += lightMapIrradiance;
	#endif
	#if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )
		iblIrradiance += getIBLIrradiance( geometry.normal );
	#endif
#endif
#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )
	radiance += getIBLRadiance( geometry.viewDir, geometry.normal, material.roughness );
	#ifdef USE_CLEARCOAT
		clearcoatRadiance += getIBLRadiance( geometry.viewDir, geometry.clearcoatNormal, material.clearcoatRoughness );
	#endif
#endif`,ppr=`#if defined( RE_IndirectDiffuse )
	RE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );
#endif
#if defined( RE_IndirectSpecular )
	RE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometry, material, reflectedLight );
#endif`,dpr=`#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )
	gl_FragDepthEXT = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;
#endif`,mpr=`#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )
	uniform float logDepthBufFC;
	varying float vFragDepth;
	varying float vIsPerspective;
#endif`,gpr=`#ifdef USE_LOGDEPTHBUF
	#ifdef USE_LOGDEPTHBUF_EXT
		varying float vFragDepth;
		varying float vIsPerspective;
	#else
		uniform float logDepthBufFC;
	#endif
#endif`,_pr=`#ifdef USE_LOGDEPTHBUF
	#ifdef USE_LOGDEPTHBUF_EXT
		vFragDepth = 1.0 + gl_Position.w;
		vIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );
	#else
		if ( isPerspectiveMatrix( projectionMatrix ) ) {
			gl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;
			gl_Position.z *= gl_Position.w;
		}
	#endif
#endif`,ypr=`#ifdef USE_MAP
	vec4 sampledDiffuseColor = texture2D( map, vUv );
	#ifdef DECODE_VIDEO_TEXTURE
		sampledDiffuseColor = vec4( mix( pow( sampledDiffuseColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), sampledDiffuseColor.rgb * 0.0773993808, vec3( lessThanEqual( sampledDiffuseColor.rgb, vec3( 0.04045 ) ) ) ), sampledDiffuseColor.w );
	#endif
	diffuseColor *= sampledDiffuseColor;
#endif`,vpr=`#ifdef USE_MAP
	uniform sampler2D map;
#endif`,xpr=`#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
	vec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;
#endif
#ifdef USE_MAP
	diffuseColor *= texture2D( map, uv );
#endif
#ifdef USE_ALPHAMAP
	diffuseColor.a *= texture2D( alphaMap, uv ).g;
#endif`,bpr=`#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
	uniform mat3 uvTransform;
#endif
#ifdef USE_MAP
	uniform sampler2D map;
#endif
#ifdef USE_ALPHAMAP
	uniform sampler2D alphaMap;
#endif`,wpr=`float metalnessFactor = metalness;
#ifdef USE_METALNESSMAP
	vec4 texelMetalness = texture2D( metalnessMap, vUv );
	metalnessFactor *= texelMetalness.b;
#endif`,Spr=`#ifdef USE_METALNESSMAP
	uniform sampler2D metalnessMap;
#endif`,Mpr=`#ifdef USE_MORPHNORMALS
	objectNormal *= morphTargetBaseInfluence;
	#ifdef MORPHTARGETS_TEXTURE
		for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
			if ( morphTargetInfluences[ i ] != 0.0 ) objectNormal += getMorph( gl_VertexID, i, 1, 2 ) * morphTargetInfluences[ i ];
		}
	#else
		objectNormal += morphNormal0 * morphTargetInfluences[ 0 ];
		objectNormal += morphNormal1 * morphTargetInfluences[ 1 ];
		objectNormal += morphNormal2 * morphTargetInfluences[ 2 ];
		objectNormal += morphNormal3 * morphTargetInfluences[ 3 ];
	#endif
#endif`,Epr=`#ifdef USE_MORPHTARGETS
	uniform float morphTargetBaseInfluence;
	#ifdef MORPHTARGETS_TEXTURE
		uniform float morphTargetInfluences[ MORPHTARGETS_COUNT ];
		uniform sampler2DArray morphTargetsTexture;
		uniform vec2 morphTargetsTextureSize;
		vec3 getMorph( const in int vertexIndex, const in int morphTargetIndex, const in int offset, const in int stride ) {
			float texelIndex = float( vertexIndex * stride + offset );
			float y = floor( texelIndex / morphTargetsTextureSize.x );
			float x = texelIndex - y * morphTargetsTextureSize.x;
			vec3 morphUV = vec3( ( x + 0.5 ) / morphTargetsTextureSize.x, y / morphTargetsTextureSize.y, morphTargetIndex );
			return texture( morphTargetsTexture, morphUV ).xyz;
		}
	#else
		#ifndef USE_MORPHNORMALS
			uniform float morphTargetInfluences[ 8 ];
		#else
			uniform float morphTargetInfluences[ 4 ];
		#endif
	#endif
#endif`,Tpr=`#ifdef USE_MORPHTARGETS
	transformed *= morphTargetBaseInfluence;
	#ifdef MORPHTARGETS_TEXTURE
		for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
			#ifndef USE_MORPHNORMALS
				if ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0, 1 ) * morphTargetInfluences[ i ];
			#else
				if ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0, 2 ) * morphTargetInfluences[ i ];
			#endif
		}
	#else
		transformed += morphTarget0 * morphTargetInfluences[ 0 ];
		transformed += morphTarget1 * morphTargetInfluences[ 1 ];
		transformed += morphTarget2 * morphTargetInfluences[ 2 ];
		transformed += morphTarget3 * morphTargetInfluences[ 3 ];
		#ifndef USE_MORPHNORMALS
			transformed += morphTarget4 * morphTargetInfluences[ 4 ];
			transformed += morphTarget5 * morphTargetInfluences[ 5 ];
			transformed += morphTarget6 * morphTargetInfluences[ 6 ];
			transformed += morphTarget7 * morphTargetInfluences[ 7 ];
		#endif
	#endif
#endif`,Cpr=`float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;
#ifdef FLAT_SHADED
	vec3 fdx = vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );
	vec3 fdy = vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );
	vec3 normal = normalize( cross( fdx, fdy ) );
#else
	vec3 normal = normalize( vNormal );
	#ifdef DOUBLE_SIDED
		normal = normal * faceDirection;
	#endif
	#ifdef USE_TANGENT
		vec3 tangent = normalize( vTangent );
		vec3 bitangent = normalize( vBitangent );
		#ifdef DOUBLE_SIDED
			tangent = tangent * faceDirection;
			bitangent = bitangent * faceDirection;
		#endif
		#if defined( TANGENTSPACE_NORMALMAP ) || defined( USE_CLEARCOAT_NORMALMAP )
			mat3 vTBN = mat3( tangent, bitangent, normal );
		#endif
	#endif
#endif
vec3 geometryNormal = normal;`,Apr=`#ifdef OBJECTSPACE_NORMALMAP
	normal = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;
	#ifdef FLIP_SIDED
		normal = - normal;
	#endif
	#ifdef DOUBLE_SIDED
		normal = normal * faceDirection;
	#endif
	normal = normalize( normalMatrix * normal );
#elif defined( TANGENTSPACE_NORMALMAP )
	vec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;
	mapN.xy *= normalScale;
	#ifdef USE_TANGENT
		normal = normalize( vTBN * mapN );
	#else
		normal = perturbNormal2Arb( - vViewPosition, normal, mapN, faceDirection );
	#endif
#elif defined( USE_BUMPMAP )
	normal = perturbNormalArb( - vViewPosition, normal, dHdxy_fwd(), faceDirection );
#endif`,Ppr=`#ifndef FLAT_SHADED
	varying vec3 vNormal;
	#ifdef USE_TANGENT
		varying vec3 vTangent;
		varying vec3 vBitangent;
	#endif
#endif`,Ipr=`#ifndef FLAT_SHADED
	varying vec3 vNormal;
	#ifdef USE_TANGENT
		varying vec3 vTangent;
		varying vec3 vBitangent;
	#endif
#endif`,Lpr=`#ifndef FLAT_SHADED
	vNormal = normalize( transformedNormal );
	#ifdef USE_TANGENT
		vTangent = normalize( transformedTangent );
		vBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );
	#endif
#endif`,kpr=`#ifdef USE_NORMALMAP
	uniform sampler2D normalMap;
	uniform vec2 normalScale;
#endif
#ifdef OBJECTSPACE_NORMALMAP
	uniform mat3 normalMatrix;
#endif
#if ! defined ( USE_TANGENT ) && ( defined ( TANGENTSPACE_NORMALMAP ) || defined ( USE_CLEARCOAT_NORMALMAP ) )
	vec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm, vec3 mapN, float faceDirection ) {
		vec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );
		vec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );
		vec2 st0 = dFdx( vUv.st );
		vec2 st1 = dFdy( vUv.st );
		vec3 N = surf_norm;
		vec3 q1perp = cross( q1, N );
		vec3 q0perp = cross( N, q0 );
		vec3 T = q1perp * st0.x + q0perp * st1.x;
		vec3 B = q1perp * st0.y + q0perp * st1.y;
		float det = max( dot( T, T ), dot( B, B ) );
		float scale = ( det == 0.0 ) ? 0.0 : faceDirection * inversesqrt( det );
		return normalize( T * ( mapN.x * scale ) + B * ( mapN.y * scale ) + N * mapN.z );
	}
#endif`,Rpr=`#ifdef USE_CLEARCOAT
	vec3 clearcoatNormal = geometryNormal;
#endif`,Npr=`#ifdef USE_CLEARCOAT_NORMALMAP
	vec3 clearcoatMapN = texture2D( clearcoatNormalMap, vUv ).xyz * 2.0 - 1.0;
	clearcoatMapN.xy *= clearcoatNormalScale;
	#ifdef USE_TANGENT
		clearcoatNormal = normalize( vTBN * clearcoatMapN );
	#else
		clearcoatNormal = perturbNormal2Arb( - vViewPosition, clearcoatNormal, clearcoatMapN, faceDirection );
	#endif
#endif`,Dpr=`#ifdef USE_CLEARCOATMAP
	uniform sampler2D clearcoatMap;
#endif
#ifdef USE_CLEARCOAT_ROUGHNESSMAP
	uniform sampler2D clearcoatRoughnessMap;
#endif
#ifdef USE_CLEARCOAT_NORMALMAP
	uniform sampler2D clearcoatNormalMap;
	uniform vec2 clearcoatNormalScale;
#endif`,Opr=`#ifdef OPAQUE
diffuseColor.a = 1.0;
#endif
#ifdef USE_TRANSMISSION
diffuseColor.a *= transmissionAlpha + 0.1;
#endif
gl_FragColor = vec4( outgoingLight, diffuseColor.a );`,zpr=`vec3 packNormalToRGB( const in vec3 normal ) {
	return normalize( normal ) * 0.5 + 0.5;
}
vec3 unpackRGBToNormal( const in vec3 rgb ) {
	return 2.0 * rgb.xyz - 1.0;
}
const float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;
const vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );
const vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );
const float ShiftRight8 = 1. / 256.;
vec4 packDepthToRGBA( const in float v ) {
	vec4 r = vec4( fract( v * PackFactors ), v );
	r.yzw -= r.xyz * ShiftRight8;	return r * PackUpscale;
}
float unpackRGBAToDepth( const in vec4 v ) {
	return dot( v, UnpackFactors );
}
vec4 pack2HalfToRGBA( vec2 v ) {
	vec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ) );
	return vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w );
}
vec2 unpackRGBATo2Half( vec4 v ) {
	return vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );
}
float viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {
	return ( viewZ + near ) / ( near - far );
}
float orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {
	return linearClipZ * ( near - far ) - near;
}
float viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {
	return ( ( near + viewZ ) * far ) / ( ( far - near ) * viewZ );
}
float perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {
	return ( near * far ) / ( ( far - near ) * invClipZ - far );
}`,Fpr=`#ifdef PREMULTIPLIED_ALPHA
	gl_FragColor.rgb *= gl_FragColor.a;
#endif`,Bpr=`vec4 mvPosition = vec4( transformed, 1.0 );
#ifdef USE_INSTANCING
	mvPosition = instanceMatrix * mvPosition;
#endif
mvPosition = modelViewMatrix * mvPosition;
gl_Position = projectionMatrix * mvPosition;`,Hpr=`#ifdef DITHERING
	gl_FragColor.rgb = dithering( gl_FragColor.rgb );
#endif`,Vpr=`#ifdef DITHERING
	vec3 dithering( vec3 color ) {
		float grid_position = rand( gl_FragCoord.xy );
		vec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );
		dither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );
		return color + dither_shift_RGB;
	}
#endif`,Upr=`float roughnessFactor = roughness;
#ifdef USE_ROUGHNESSMAP
	vec4 texelRoughness = texture2D( roughnessMap, vUv );
	roughnessFactor *= texelRoughness.g;
#endif`,qpr=`#ifdef USE_ROUGHNESSMAP
	uniform sampler2D roughnessMap;
#endif`,Gpr=`#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0
		uniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];
		varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];
		struct DirectionalLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
		uniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];
		varying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];
		struct SpotLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
		uniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];
		varying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];
		struct PointLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
			float shadowCameraNear;
			float shadowCameraFar;
		};
		uniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];
	#endif
	float texture2DCompare( sampler2D depths, vec2 uv, float compare ) {
		return step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );
	}
	vec2 texture2DDistribution( sampler2D shadow, vec2 uv ) {
		return unpackRGBATo2Half( texture2D( shadow, uv ) );
	}
	float VSMShadow (sampler2D shadow, vec2 uv, float compare ){
		float occlusion = 1.0;
		vec2 distribution = texture2DDistribution( shadow, uv );
		float hard_shadow = step( compare , distribution.x );
		if (hard_shadow != 1.0 ) {
			float distance = compare - distribution.x ;
			float variance = max( 0.00000, distribution.y * distribution.y );
			float softness_probability = variance / (variance + distance * distance );			softness_probability = clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 );			occlusion = clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );
		}
		return occlusion;
	}
	float getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {
		float shadow = 1.0;
		shadowCoord.xyz /= shadowCoord.w;
		shadowCoord.z += shadowBias;
		bvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );
		bool inFrustum = all( inFrustumVec );
		bvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );
		bool frustumTest = all( frustumTestVec );
		if ( frustumTest ) {
		#if defined( SHADOWMAP_TYPE_PCF )
			vec2 texelSize = vec2( 1.0 ) / shadowMapSize;
			float dx0 = - texelSize.x * shadowRadius;
			float dy0 = - texelSize.y * shadowRadius;
			float dx1 = + texelSize.x * shadowRadius;
			float dy1 = + texelSize.y * shadowRadius;
			float dx2 = dx0 / 2.0;
			float dy2 = dy0 / 2.0;
			float dx3 = dx1 / 2.0;
			float dy3 = dy1 / 2.0;
			shadow = (
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )
			) * ( 1.0 / 17.0 );
		#elif defined( SHADOWMAP_TYPE_PCF_SOFT )
			vec2 texelSize = vec2( 1.0 ) / shadowMapSize;
			float dx = texelSize.x;
			float dy = texelSize.y;
			vec2 uv = shadowCoord.xy;
			vec2 f = fract( uv * shadowMapSize + 0.5 );
			uv -= f * texelSize;
			shadow = (
				texture2DCompare( shadowMap, uv, shadowCoord.z ) +
				texture2DCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +
				texture2DCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +
				texture2DCompare( shadowMap, uv + texelSize, shadowCoord.z ) +
				mix( texture2DCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),
					 f.x ) +
				mix( texture2DCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),
					 f.x ) +
				mix( texture2DCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),
					 f.y ) +
				mix( texture2DCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ), 
					 texture2DCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),
					 f.y ) +
				mix( mix( texture2DCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ), 
						  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),
						  f.x ),
					 mix( texture2DCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ), 
						  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),
						  f.x ),
					 f.y )
			) * ( 1.0 / 9.0 );
		#elif defined( SHADOWMAP_TYPE_VSM )
			shadow = VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );
		#else
			shadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );
		#endif
		}
		return shadow;
	}
	vec2 cubeToUV( vec3 v, float texelSizeY ) {
		vec3 absV = abs( v );
		float scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );
		absV *= scaleToCube;
		v *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );
		vec2 planar = v.xy;
		float almostATexel = 1.5 * texelSizeY;
		float almostOne = 1.0 - almostATexel;
		if ( absV.z >= almostOne ) {
			if ( v.z > 0.0 )
				planar.x = 4.0 - v.x;
		} else if ( absV.x >= almostOne ) {
			float signX = sign( v.x );
			planar.x = v.z * signX + 2.0 * signX;
		} else if ( absV.y >= almostOne ) {
			float signY = sign( v.y );
			planar.x = v.x + 2.0 * signY + 2.0;
			planar.y = v.z * signY - 2.0;
		}
		return vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );
	}
	float getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {
		vec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );
		vec3 lightToPosition = shadowCoord.xyz;
		float dp = ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );		dp += shadowBias;
		vec3 bd3D = normalize( lightToPosition );
		#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )
			vec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;
			return (
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +
				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )
			) * ( 1.0 / 9.0 );
		#else
			return texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );
		#endif
	}
#endif`,Wpr=`#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0
		uniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];
		varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];
		struct DirectionalLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
		uniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHT_SHADOWS ];
		varying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];
		struct SpotLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
		};
		uniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
		uniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];
		varying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];
		struct PointLightShadow {
			float shadowBias;
			float shadowNormalBias;
			float shadowRadius;
			vec2 shadowMapSize;
			float shadowCameraNear;
			float shadowCameraFar;
		};
		uniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];
	#endif
#endif`,Ypr=`#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0 || NUM_SPOT_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0
		vec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
		vec4 shadowWorldPosition;
	#endif
	#if NUM_DIR_LIGHT_SHADOWS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {
		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );
		vDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {
		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias, 0 );
		vSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * shadowWorldPosition;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {
		shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );
		vPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;
	}
	#pragma unroll_loop_end
	#endif
#endif`,jpr=`float getShadowMask() {
	float shadow = 1.0;
	#ifdef USE_SHADOWMAP
	#if NUM_DIR_LIGHT_SHADOWS > 0
	DirectionalLightShadow directionalLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {
		directionalLight = directionalLightShadows[ i ];
		shadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_SPOT_LIGHT_SHADOWS > 0
	SpotLightShadow spotLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {
		spotLight = spotLightShadows[ i ];
		shadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;
	}
	#pragma unroll_loop_end
	#endif
	#if NUM_POINT_LIGHT_SHADOWS > 0
	PointLightShadow pointLight;
	#pragma unroll_loop_start
	for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {
		pointLight = pointLightShadows[ i ];
		shadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;
	}
	#pragma unroll_loop_end
	#endif
	#endif
	return shadow;
}`,Xpr=`#ifdef USE_SKINNING
	mat4 boneMatX = getBoneMatrix( skinIndex.x );
	mat4 boneMatY = getBoneMatrix( skinIndex.y );
	mat4 boneMatZ = getBoneMatrix( skinIndex.z );
	mat4 boneMatW = getBoneMatrix( skinIndex.w );
#endif`,$pr=`#ifdef USE_SKINNING
	uniform mat4 bindMatrix;
	uniform mat4 bindMatrixInverse;
	#ifdef BONE_TEXTURE
		uniform highp sampler2D boneTexture;
		uniform int boneTextureSize;
		mat4 getBoneMatrix( const in float i ) {
			float j = i * 4.0;
			float x = mod( j, float( boneTextureSize ) );
			float y = floor( j / float( boneTextureSize ) );
			float dx = 1.0 / float( boneTextureSize );
			float dy = 1.0 / float( boneTextureSize );
			y = dy * ( y + 0.5 );
			vec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );
			vec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );
			vec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );
			vec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );
			mat4 bone = mat4( v1, v2, v3, v4 );
			return bone;
		}
	#else
		uniform mat4 boneMatrices[ MAX_BONES ];
		mat4 getBoneMatrix( const in float i ) {
			mat4 bone = boneMatrices[ int(i) ];
			return bone;
		}
	#endif
#endif`,Kpr=`#ifdef USE_SKINNING
	vec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );
	vec4 skinned = vec4( 0.0 );
	skinned += boneMatX * skinVertex * skinWeight.x;
	skinned += boneMatY * skinVertex * skinWeight.y;
	skinned += boneMatZ * skinVertex * skinWeight.z;
	skinned += boneMatW * skinVertex * skinWeight.w;
	transformed = ( bindMatrixInverse * skinned ).xyz;
#endif`,Zpr=`#ifdef USE_SKINNING
	mat4 skinMatrix = mat4( 0.0 );
	skinMatrix += skinWeight.x * boneMatX;
	skinMatrix += skinWeight.y * boneMatY;
	skinMatrix += skinWeight.z * boneMatZ;
	skinMatrix += skinWeight.w * boneMatW;
	skinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;
	objectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;
	#ifdef USE_TANGENT
		objectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;
	#endif
#endif`,Jpr=`float specularStrength;
#ifdef USE_SPECULARMAP
	vec4 texelSpecular = texture2D( specularMap, vUv );
	specularStrength = texelSpecular.r;
#else
	specularStrength = 1.0;
#endif`,Qpr=`#ifdef USE_SPECULARMAP
	uniform sampler2D specularMap;
#endif`,tdr=`#if defined( TONE_MAPPING )
	gl_FragColor.rgb = toneMapping( gl_FragColor.rgb );
#endif`,edr=`#ifndef saturate
#define saturate( a ) clamp( a, 0.0, 1.0 )
#endif
uniform float toneMappingExposure;
vec3 LinearToneMapping( vec3 color ) {
	return toneMappingExposure * color;
}
vec3 ReinhardToneMapping( vec3 color ) {
	color *= toneMappingExposure;
	return saturate( color / ( vec3( 1.0 ) + color ) );
}
vec3 OptimizedCineonToneMapping( vec3 color ) {
	color *= toneMappingExposure;
	color = max( vec3( 0.0 ), color - 0.004 );
	return pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );
}
vec3 RRTAndODTFit( vec3 v ) {
	vec3 a = v * ( v + 0.0245786 ) - 0.000090537;
	vec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;
	return a / b;
}
vec3 ACESFilmicToneMapping( vec3 color ) {
	const mat3 ACESInputMat = mat3(
		vec3( 0.59719, 0.07600, 0.02840 ),		vec3( 0.35458, 0.90834, 0.13383 ),
		vec3( 0.04823, 0.01566, 0.83777 )
	);
	const mat3 ACESOutputMat = mat3(
		vec3(  1.60475, -0.10208, -0.00327 ),		vec3( -0.53108,  1.10813, -0.07276 ),
		vec3( -0.07367, -0.00605,  1.07602 )
	);
	color *= toneMappingExposure / 0.6;
	color = ACESInputMat * color;
	color = RRTAndODTFit( color );
	color = ACESOutputMat * color;
	return saturate( color );
}
vec3 CustomToneMapping( vec3 color ) { return color; }`,rdr=`#ifdef USE_TRANSMISSION
	float transmissionAlpha = 1.0;
	float transmissionFactor = transmission;
	float thicknessFactor = thickness;
	#ifdef USE_TRANSMISSIONMAP
		transmissionFactor *= texture2D( transmissionMap, vUv ).r;
	#endif
	#ifdef USE_THICKNESSMAP
		thicknessFactor *= texture2D( thicknessMap, vUv ).g;
	#endif
	vec3 pos = vWorldPosition;
	vec3 v = normalize( cameraPosition - pos );
	vec3 n = inverseTransformDirection( normal, viewMatrix );
	vec4 transmission = getIBLVolumeRefraction(
		n, v, roughnessFactor, material.diffuseColor, material.specularColor, material.specularF90,
		pos, modelMatrix, viewMatrix, projectionMatrix, ior, thicknessFactor,
		attenuationColor, attenuationDistance );
	totalDiffuse = mix( totalDiffuse, transmission.rgb, transmissionFactor );
	transmissionAlpha = mix( transmissionAlpha, transmission.a, transmissionFactor );
#endif`,ndr=`#ifdef USE_TRANSMISSION
	uniform float transmission;
	uniform float thickness;
	uniform float attenuationDistance;
	uniform vec3 attenuationColor;
	#ifdef USE_TRANSMISSIONMAP
		uniform sampler2D transmissionMap;
	#endif
	#ifdef USE_THICKNESSMAP
		uniform sampler2D thicknessMap;
	#endif
	uniform vec2 transmissionSamplerSize;
	uniform sampler2D transmissionSamplerMap;
	uniform mat4 modelMatrix;
	uniform mat4 projectionMatrix;
	varying vec3 vWorldPosition;
	vec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {
		vec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );
		vec3 modelScale;
		modelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );
		modelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );
		modelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );
		return normalize( refractionVector ) * thickness * modelScale;
	}
	float applyIorToRoughness( const in float roughness, const in float ior ) {
		return roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );
	}
	vec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {
		float framebufferLod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );
		#ifdef TEXTURE_LOD_EXT
			return texture2DLodEXT( transmissionSamplerMap, fragCoord.xy, framebufferLod );
		#else
			return texture2D( transmissionSamplerMap, fragCoord.xy, framebufferLod );
		#endif
	}
	vec3 applyVolumeAttenuation( const in vec3 radiance, const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {
		if ( attenuationDistance == 0.0 ) {
			return radiance;
		} else {
			vec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;
			vec3 transmittance = exp( - attenuationCoefficient * transmissionDistance );			return transmittance * radiance;
		}
	}
	vec4 getIBLVolumeRefraction( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor,
		const in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix,
		const in mat4 viewMatrix, const in mat4 projMatrix, const in float ior, const in float thickness,
		const in vec3 attenuationColor, const in float attenuationDistance ) {
		vec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );
		vec3 refractedRayExit = position + transmissionRay;
		vec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );
		vec2 refractionCoords = ndcPos.xy / ndcPos.w;
		refractionCoords += 1.0;
		refractionCoords /= 2.0;
		vec4 transmittedLight = getTransmissionSample( refractionCoords, roughness, ior );
		vec3 attenuatedColor = applyVolumeAttenuation( transmittedLight.rgb, length( transmissionRay ), attenuationColor, attenuationDistance );
		vec3 F = EnvironmentBRDF( n, v, specularColor, specularF90, roughness );
		return vec4( ( 1.0 - F ) * attenuatedColor * diffuseColor, transmittedLight.a );
	}
#endif`,idr=`#if ( defined( USE_UV ) && ! defined( UVS_VERTEX_ONLY ) )
	varying vec2 vUv;
#endif`,odr=`#ifdef USE_UV
	#ifdef UVS_VERTEX_ONLY
		vec2 vUv;
	#else
		varying vec2 vUv;
	#endif
	uniform mat3 uvTransform;
#endif`,adr=`#ifdef USE_UV
	vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
#endif`,sdr=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
	varying vec2 vUv2;
#endif`,ldr=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
	attribute vec2 uv2;
	varying vec2 vUv2;
	uniform mat3 uv2Transform;
#endif`,cdr=`#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
	vUv2 = ( uv2Transform * vec3( uv2, 1 ) ).xy;
#endif`,udr=`#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP ) || defined ( USE_TRANSMISSION )
	vec4 worldPosition = vec4( transformed, 1.0 );
	#ifdef USE_INSTANCING
		worldPosition = instanceMatrix * worldPosition;
	#endif
	worldPosition = modelMatrix * worldPosition;
#endif`,hdr=`varying vec2 vUv;
uniform mat3 uvTransform;
void main() {
	vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
	gl_Position = vec4( position.xy, 1.0, 1.0 );
}`,fdr=`uniform sampler2D t2D;
varying vec2 vUv;
void main() {
	gl_FragColor = texture2D( t2D, vUv );
	#include <tonemapping_fragment>
	#include <encodings_fragment>
}`,pdr=`varying vec3 vWorldDirection;
#include <common>
void main() {
	vWorldDirection = transformDirection( position, modelMatrix );
	#include <begin_vertex>
	#include <project_vertex>
	gl_Position.z = gl_Position.w;
}`,ddr=`#include <envmap_common_pars_fragment>
uniform float opacity;
varying vec3 vWorldDirection;
#include <cube_uv_reflection_fragment>
void main() {
	vec3 vReflect = vWorldDirection;
	#include <envmap_fragment>
	gl_FragColor = envColor;
	gl_FragColor.a *= opacity;
	#include <tonemapping_fragment>
	#include <encodings_fragment>
}`,mdr=`#include <common>
#include <uv_pars_vertex>
#include <displacementmap_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
varying vec2 vHighPrecisionZW;
void main() {
	#include <uv_vertex>
	#include <skinbase_vertex>
	#ifdef USE_DISPLACEMENTMAP
		#include <beginnormal_vertex>
		#include <morphnormal_vertex>
		#include <skinnormal_vertex>
	#endif
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vHighPrecisionZW = gl_Position.zw;
}`,gdr=`#if DEPTH_PACKING == 3200
	uniform float opacity;
#endif
#include <common>
#include <packing>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
varying vec2 vHighPrecisionZW;
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( 1.0 );
	#if DEPTH_PACKING == 3200
		diffuseColor.a = opacity;
	#endif
	#include <map_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <logdepthbuf_fragment>
	float fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;
	#if DEPTH_PACKING == 3200
		gl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );
	#elif DEPTH_PACKING == 3201
		gl_FragColor = packDepthToRGBA( fragCoordZ );
	#endif
}`,_dr=`#define DISTANCE
varying vec3 vWorldPosition;
#include <common>
#include <uv_pars_vertex>
#include <displacementmap_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <skinbase_vertex>
	#ifdef USE_DISPLACEMENTMAP
		#include <beginnormal_vertex>
		#include <morphnormal_vertex>
		#include <skinnormal_vertex>
	#endif
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <worldpos_vertex>
	#include <clipping_planes_vertex>
	vWorldPosition = worldPosition.xyz;
}`,ydr=`#define DISTANCE
uniform vec3 referencePosition;
uniform float nearDistance;
uniform float farDistance;
varying vec3 vWorldPosition;
#include <common>
#include <packing>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <clipping_planes_pars_fragment>
void main () {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( 1.0 );
	#include <map_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	float dist = length( vWorldPosition - referencePosition );
	dist = ( dist - nearDistance ) / ( farDistance - nearDistance );
	dist = saturate( dist );
	gl_FragColor = packDepthToRGBA( dist );
}`,vdr=`varying vec3 vWorldDirection;
#include <common>
void main() {
	vWorldDirection = transformDirection( position, modelMatrix );
	#include <begin_vertex>
	#include <project_vertex>
}`,xdr=`uniform sampler2D tEquirect;
varying vec3 vWorldDirection;
#include <common>
void main() {
	vec3 direction = normalize( vWorldDirection );
	vec2 sampleUV = equirectUv( direction );
	gl_FragColor = texture2D( tEquirect, sampleUV );
	#include <tonemapping_fragment>
	#include <encodings_fragment>
}`,bdr=`uniform float scale;
attribute float lineDistance;
varying float vLineDistance;
#include <common>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	vLineDistance = scale * lineDistance;
	#include <color_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <fog_vertex>
}`,wdr=`uniform vec3 diffuse;
uniform float opacity;
uniform float dashSize;
uniform float totalSize;
varying float vLineDistance;
#include <common>
#include <color_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	if ( mod( vLineDistance, totalSize ) > dashSize ) {
		discard;
	}
	vec3 outgoingLight = vec3( 0.0 );
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <color_fragment>
	outgoingLight = diffuseColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
}`,Sdr=`#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <envmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )
		#include <beginnormal_vertex>
		#include <morphnormal_vertex>
		#include <skinbase_vertex>
		#include <skinnormal_vertex>
		#include <defaultnormal_vertex>
	#endif
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <worldpos_vertex>
	#include <envmap_vertex>
	#include <fog_vertex>
}`,Mdr=`uniform vec3 diffuse;
uniform float opacity;
#ifndef FLAT_SHADED
	varying vec3 vNormal;
#endif
#include <common>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_pars_fragment>
#include <cube_uv_reflection_fragment>
#include <fog_pars_fragment>
#include <specularmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <specularmap_fragment>
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	#ifdef USE_LIGHTMAP
		vec4 lightMapTexel= texture2D( lightMap, vUv2 );
		reflectedLight.indirectDiffuse += lightMapTexel.rgb * lightMapIntensity;
	#else
		reflectedLight.indirectDiffuse += vec3( 1.0 );
	#endif
	#include <aomap_fragment>
	reflectedLight.indirectDiffuse *= diffuseColor.rgb;
	vec3 outgoingLight = reflectedLight.indirectDiffuse;
	#include <envmap_fragment>
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,Edr=`#define LAMBERT
varying vec3 vLightFront;
varying vec3 vIndirectFront;
#ifdef DOUBLE_SIDED
	varying vec3 vLightBack;
	varying vec3 vIndirectBack;
#endif
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <envmap_pars_vertex>
#include <bsdfs>
#include <lights_pars_begin>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <worldpos_vertex>
	#include <envmap_vertex>
	#include <lights_lambert_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,Tdr=`uniform vec3 diffuse;
uniform vec3 emissive;
uniform float opacity;
varying vec3 vLightFront;
varying vec3 vIndirectFront;
#ifdef DOUBLE_SIDED
	varying vec3 vLightBack;
	varying vec3 vIndirectBack;
#endif
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_pars_fragment>
#include <cube_uv_reflection_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <fog_pars_fragment>
#include <shadowmap_pars_fragment>
#include <shadowmask_pars_fragment>
#include <specularmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <specularmap_fragment>
	#include <emissivemap_fragment>
	#ifdef DOUBLE_SIDED
		reflectedLight.indirectDiffuse += ( gl_FrontFacing ) ? vIndirectFront : vIndirectBack;
	#else
		reflectedLight.indirectDiffuse += vIndirectFront;
	#endif
	#include <lightmap_fragment>
	reflectedLight.indirectDiffuse *= BRDF_Lambert( diffuseColor.rgb );
	#ifdef DOUBLE_SIDED
		reflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;
	#else
		reflectedLight.directDiffuse = vLightFront;
	#endif
	reflectedLight.directDiffuse *= BRDF_Lambert( diffuseColor.rgb ) * getShadowMask();
	#include <aomap_fragment>
	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
	#include <envmap_fragment>
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,Cdr=`#define MATCAP
varying vec3 vViewPosition;
#include <common>
#include <uv_pars_vertex>
#include <color_pars_vertex>
#include <displacementmap_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <fog_vertex>
	vViewPosition = - mvPosition.xyz;
}`,Adr=`#define MATCAP
uniform vec3 diffuse;
uniform float opacity;
uniform sampler2D matcap;
varying vec3 vViewPosition;
#include <common>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <fog_pars_fragment>
#include <normal_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	vec3 viewDir = normalize( vViewPosition );
	vec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );
	vec3 y = cross( viewDir, x );
	vec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;
	#ifdef USE_MATCAP
		vec4 matcapColor = texture2D( matcap, uv );
	#else
		vec4 matcapColor = vec4( vec3( mix( 0.2, 0.8, uv.y ) ), 1.0 );
	#endif
	vec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,Pdr=`#define NORMAL
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
	varying vec3 vViewPosition;
#endif
#include <common>
#include <uv_pars_vertex>
#include <displacementmap_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
	vViewPosition = - mvPosition.xyz;
#endif
}`,Idr=`#define NORMAL
uniform float opacity;
#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
	varying vec3 vViewPosition;
#endif
#include <packing>
#include <uv_pars_fragment>
#include <normal_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	#include <logdepthbuf_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	gl_FragColor = vec4( packNormalToRGB( normal ), opacity );
}`,Ldr=`#define PHONG
varying vec3 vViewPosition;
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <displacementmap_pars_vertex>
#include <envmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vViewPosition = - mvPosition.xyz;
	#include <worldpos_vertex>
	#include <envmap_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,kdr=`#define PHONG
uniform vec3 diffuse;
uniform vec3 emissive;
uniform vec3 specular;
uniform float shininess;
uniform float opacity;
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_pars_fragment>
#include <cube_uv_reflection_fragment>
#include <fog_pars_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <normal_pars_fragment>
#include <lights_phong_pars_fragment>
#include <shadowmap_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <specularmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <specularmap_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	#include <emissivemap_fragment>
	#include <lights_phong_fragment>
	#include <lights_fragment_begin>
	#include <lights_fragment_maps>
	#include <lights_fragment_end>
	#include <aomap_fragment>
	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;
	#include <envmap_fragment>
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,Rdr=`#define STANDARD
varying vec3 vViewPosition;
#ifdef USE_TRANSMISSION
	varying vec3 vWorldPosition;
#endif
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <displacementmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vViewPosition = - mvPosition.xyz;
	#include <worldpos_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
#ifdef USE_TRANSMISSION
	vWorldPosition = worldPosition.xyz;
#endif
}`,Ndr=`#define STANDARD
#ifdef PHYSICAL
	#define IOR
	#define SPECULAR
#endif
uniform vec3 diffuse;
uniform vec3 emissive;
uniform float roughness;
uniform float metalness;
uniform float opacity;
#ifdef IOR
	uniform float ior;
#endif
#ifdef SPECULAR
	uniform float specularIntensity;
	uniform vec3 specularColor;
	#ifdef USE_SPECULARINTENSITYMAP
		uniform sampler2D specularIntensityMap;
	#endif
	#ifdef USE_SPECULARCOLORMAP
		uniform sampler2D specularColorMap;
	#endif
#endif
#ifdef USE_CLEARCOAT
	uniform float clearcoat;
	uniform float clearcoatRoughness;
#endif
#ifdef USE_SHEEN
	uniform vec3 sheenColor;
	uniform float sheenRoughness;
	#ifdef USE_SHEENCOLORMAP
		uniform sampler2D sheenColorMap;
	#endif
	#ifdef USE_SHEENROUGHNESSMAP
		uniform sampler2D sheenRoughnessMap;
	#endif
#endif
varying vec3 vViewPosition;
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <bsdfs>
#include <cube_uv_reflection_fragment>
#include <envmap_common_pars_fragment>
#include <envmap_physical_pars_fragment>
#include <fog_pars_fragment>
#include <lights_pars_begin>
#include <normal_pars_fragment>
#include <lights_physical_pars_fragment>
#include <transmission_pars_fragment>
#include <shadowmap_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <clearcoat_pars_fragment>
#include <roughnessmap_pars_fragment>
#include <metalnessmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <roughnessmap_fragment>
	#include <metalnessmap_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	#include <clearcoat_normal_fragment_begin>
	#include <clearcoat_normal_fragment_maps>
	#include <emissivemap_fragment>
	#include <lights_physical_fragment>
	#include <lights_fragment_begin>
	#include <lights_fragment_maps>
	#include <lights_fragment_end>
	#include <aomap_fragment>
	vec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;
	vec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;
	#include <transmission_fragment>
	vec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;
	#ifdef USE_SHEEN
		float sheenEnergyComp = 1.0 - 0.157 * max3( material.sheenColor );
		outgoingLight = outgoingLight * sheenEnergyComp + sheenSpecular;
	#endif
	#ifdef USE_CLEARCOAT
		float dotNVcc = saturate( dot( geometry.clearcoatNormal, geometry.viewDir ) );
		vec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );
		outgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + clearcoatSpecular * material.clearcoat;
	#endif
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,Ddr=`#define TOON
varying vec3 vViewPosition;
#include <common>
#include <uv_pars_vertex>
#include <uv2_pars_vertex>
#include <displacementmap_pars_vertex>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <normal_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	#include <uv2_vertex>
	#include <color_vertex>
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <normal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <displacementmap_vertex>
	#include <project_vertex>
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	vViewPosition = - mvPosition.xyz;
	#include <worldpos_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,Odr=`#define TOON
uniform vec3 diffuse;
uniform vec3 emissive;
uniform float opacity;
#include <common>
#include <packing>
#include <dithering_pars_fragment>
#include <color_pars_fragment>
#include <uv_pars_fragment>
#include <uv2_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <aomap_pars_fragment>
#include <lightmap_pars_fragment>
#include <emissivemap_pars_fragment>
#include <gradientmap_pars_fragment>
#include <fog_pars_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <normal_pars_fragment>
#include <lights_toon_pars_fragment>
#include <shadowmap_pars_fragment>
#include <bumpmap_pars_fragment>
#include <normalmap_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec4 diffuseColor = vec4( diffuse, opacity );
	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
	vec3 totalEmissiveRadiance = emissive;
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <color_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	#include <normal_fragment_begin>
	#include <normal_fragment_maps>
	#include <emissivemap_fragment>
	#include <lights_toon_fragment>
	#include <lights_fragment_begin>
	#include <lights_fragment_maps>
	#include <lights_fragment_end>
	#include <aomap_fragment>
	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
	#include <dithering_fragment>
}`,zdr=`uniform float size;
uniform float scale;
#include <common>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <color_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <project_vertex>
	gl_PointSize = size;
	#ifdef USE_SIZEATTENUATION
		bool isPerspective = isPerspectiveMatrix( projectionMatrix );
		if ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );
	#endif
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <worldpos_vertex>
	#include <fog_vertex>
}`,Fdr=`uniform vec3 diffuse;
uniform float opacity;
#include <common>
#include <color_pars_fragment>
#include <map_particle_pars_fragment>
#include <alphatest_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec3 outgoingLight = vec3( 0.0 );
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_particle_fragment>
	#include <color_fragment>
	#include <alphatest_fragment>
	outgoingLight = diffuseColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
	#include <premultiplied_alpha_fragment>
}`,Bdr=`#include <common>
#include <fog_pars_vertex>
#include <morphtarget_pars_vertex>
#include <skinning_pars_vertex>
#include <shadowmap_pars_vertex>
void main() {
	#include <beginnormal_vertex>
	#include <morphnormal_vertex>
	#include <skinbase_vertex>
	#include <skinnormal_vertex>
	#include <defaultnormal_vertex>
	#include <begin_vertex>
	#include <morphtarget_vertex>
	#include <skinning_vertex>
	#include <project_vertex>
	#include <worldpos_vertex>
	#include <shadowmap_vertex>
	#include <fog_vertex>
}`,Hdr=`uniform vec3 color;
uniform float opacity;
#include <common>
#include <packing>
#include <fog_pars_fragment>
#include <bsdfs>
#include <lights_pars_begin>
#include <shadowmap_pars_fragment>
#include <shadowmask_pars_fragment>
void main() {
	gl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
}`,Vdr=`uniform float rotation;
uniform vec2 center;
#include <common>
#include <uv_pars_vertex>
#include <fog_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
	#include <uv_vertex>
	vec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );
	vec2 scale;
	scale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );
	scale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );
	#ifndef USE_SIZEATTENUATION
		bool isPerspective = isPerspectiveMatrix( projectionMatrix );
		if ( isPerspective ) scale *= - mvPosition.z;
	#endif
	vec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;
	vec2 rotatedPosition;
	rotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;
	rotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;
	mvPosition.xy += rotatedPosition;
	gl_Position = projectionMatrix * mvPosition;
	#include <logdepthbuf_vertex>
	#include <clipping_planes_vertex>
	#include <fog_vertex>
}`,Udr=`uniform vec3 diffuse;
uniform float opacity;
#include <common>
#include <uv_pars_fragment>
#include <map_pars_fragment>
#include <alphamap_pars_fragment>
#include <alphatest_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
	#include <clipping_planes_fragment>
	vec3 outgoingLight = vec3( 0.0 );
	vec4 diffuseColor = vec4( diffuse, opacity );
	#include <logdepthbuf_fragment>
	#include <map_fragment>
	#include <alphamap_fragment>
	#include <alphatest_fragment>
	outgoingLight = diffuseColor.rgb;
	#include <output_fragment>
	#include <tonemapping_fragment>
	#include <encodings_fragment>
	#include <fog_fragment>
}`,hr={alphamap_fragment:_fr,alphamap_pars_fragment:yfr,alphatest_fragment:vfr,alphatest_pars_fragment:xfr,aomap_fragment:bfr,aomap_pars_fragment:wfr,begin_vertex:Sfr,beginnormal_vertex:Mfr,bsdfs:Efr,bumpmap_pars_fragment:Tfr,clipping_planes_fragment:Cfr,clipping_planes_pars_fragment:Afr,clipping_planes_pars_vertex:Pfr,clipping_planes_vertex:Ifr,color_fragment:Lfr,color_pars_fragment:kfr,color_pars_vertex:Rfr,color_vertex:Nfr,common:Dfr,cube_uv_reflection_fragment:Ofr,defaultnormal_vertex:zfr,displacementmap_pars_vertex:Ffr,displacementmap_vertex:Bfr,emissivemap_fragment:Hfr,emissivemap_pars_fragment:Vfr,encodings_fragment:Ufr,encodings_pars_fragment:qfr,envmap_fragment:Gfr,envmap_common_pars_fragment:Wfr,envmap_pars_fragment:Yfr,envmap_pars_vertex:jfr,envmap_physical_pars_fragment:ipr,envmap_vertex:Xfr,fog_vertex:$fr,fog_pars_vertex:Kfr,fog_fragment:Zfr,fog_pars_fragment:Jfr,gradientmap_pars_fragment:Qfr,lightmap_fragment:tpr,lightmap_pars_fragment:epr,lights_lambert_vertex:rpr,lights_pars_begin:npr,lights_toon_fragment:opr,lights_toon_pars_fragment:apr,lights_phong_fragment:spr,lights_phong_pars_fragment:lpr,lights_physical_fragment:cpr,lights_physical_pars_fragment:upr,lights_fragment_begin:hpr,lights_fragment_maps:fpr,lights_fragment_end:ppr,logdepthbuf_fragment:dpr,logdepthbuf_pars_fragment:mpr,logdepthbuf_pars_vertex:gpr,logdepthbuf_vertex:_pr,map_fragment:ypr,map_pars_fragment:vpr,map_particle_fragment:xpr,map_particle_pars_fragment:bpr,metalnessmap_fragment:wpr,metalnessmap_pars_fragment:Spr,morphnormal_vertex:Mpr,morphtarget_pars_vertex:Epr,morphtarget_vertex:Tpr,normal_fragment_begin:Cpr,normal_fragment_maps:Apr,normal_pars_fragment:Ppr,normal_pars_vertex:Ipr,normal_vertex:Lpr,normalmap_pars_fragment:kpr,clearcoat_normal_fragment_begin:Rpr,clearcoat_normal_fragment_maps:Npr,clearcoat_pars_fragment:Dpr,output_fragment:Opr,packing:zpr,premultiplied_alpha_fragment:Fpr,project_vertex:Bpr,dithering_fragment:Hpr,dithering_pars_fragment:Vpr,roughnessmap_fragment:Upr,roughnessmap_pars_fragment:qpr,shadowmap_pars_fragment:Gpr,shadowmap_pars_vertex:Wpr,shadowmap_vertex:Ypr,shadowmask_pars_fragment:jpr,skinbase_vertex:Xpr,skinning_pars_vertex:$pr,skinning_vertex:Kpr,skinnormal_vertex:Zpr,specularmap_fragment:Jpr,specularmap_pars_fragment:Qpr,tonemapping_fragment:tdr,tonemapping_pars_fragment:edr,transmission_fragment:rdr,transmission_pars_fragment:ndr,uv_pars_fragment:idr,uv_pars_vertex:odr,uv_vertex:adr,uv2_pars_fragment:sdr,uv2_pars_vertex:ldr,uv2_vertex:cdr,worldpos_vertex:udr,background_vert:hdr,background_frag:fdr,cube_vert:pdr,cube_frag:ddr,depth_vert:mdr,depth_frag:gdr,distanceRGBA_vert:_dr,distanceRGBA_frag:ydr,equirect_vert:vdr,equirect_frag:xdr,linedashed_vert:bdr,linedashed_frag:wdr,meshbasic_vert:Sdr,meshbasic_frag:Mdr,meshlambert_vert:Edr,meshlambert_frag:Tdr,meshmatcap_vert:Cdr,meshmatcap_frag:Adr,meshnormal_vert:Pdr,meshnormal_frag:Idr,meshphong_vert:Ldr,meshphong_frag:kdr,meshphysical_vert:Rdr,meshphysical_frag:Ndr,meshtoon_vert:Ddr,meshtoon_frag:Odr,points_vert:zdr,points_frag:Fdr,shadow_vert:Bdr,shadow_frag:Hdr,sprite_vert:Vdr,sprite_frag:Udr},re={common:{diffuse:{value:new ne(16777215)},opacity:{value:1},map:{value:null},uvTransform:{value:new ki},uv2Transform:{value:new ki},alphaMap:{value:null},alphaTest:{value:0}},specularmap:{specularMap:{value:null}},envmap:{envMap:{value:null},flipEnvMap:{value:-1},reflectivity:{value:1},ior:{value:1.5},refractionRatio:{value:.98}},aomap:{aoMap:{value:null},aoMapIntensity:{value:1}},lightmap:{lightMap:{value:null},lightMapIntensity:{value:1}},emissivemap:{emissiveMap:{value:null}},bumpmap:{bumpMap:{value:null},bumpScale:{value:1}},normalmap:{normalMap:{value:null},normalScale:{value:new Lt(1,1)}},displacementmap:{displacementMap:{value:null},displacementScale:{value:1},displacementBias:{value:0}},roughnessmap:{roughnessMap:{value:null}},metalnessmap:{metalnessMap:{value:null}},gradientmap:{gradientMap:{value:null}},fog:{fogDensity:{value:25e-5},fogNear:{value:1},fogFar:{value:2e3},fogColor:{value:new ne(16777215)}},lights:{ambientLightColor:{value:[]},lightProbe:{value:[]},directionalLights:{value:[],properties:{direction:{},color:{}}},directionalLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},directionalShadowMap:{value:[]},directionalShadowMatrix:{value:[]},spotLights:{value:[],properties:{color:{},position:{},direction:{},distance:{},coneCos:{},penumbraCos:{},decay:{}}},spotLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},spotShadowMap:{value:[]},spotShadowMatrix:{value:[]},pointLights:{value:[],properties:{color:{},position:{},decay:{},distance:{}}},pointLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{},shadowCameraNear:{},shadowCameraFar:{}}},pointShadowMap:{value:[]},pointShadowMatrix:{value:[]},hemisphereLights:{value:[],properties:{direction:{},skyColor:{},groundColor:{}}},rectAreaLights:{value:[],properties:{color:{},position:{},width:{},height:{}}},ltc_1:{value:null},ltc_2:{value:null}},points:{diffuse:{value:new ne(16777215)},opacity:{value:1},size:{value:1},scale:{value:1},map:{value:null},alphaMap:{value:null},alphaTest:{value:0},uvTransform:{value:new ki}},sprite:{diffuse:{value:new ne(16777215)},opacity:{value:1},center:{value:new Lt(.5,.5)},rotation:{value:0},map:{value:null},alphaMap:{value:null},alphaTest:{value:0},uvTransform:{value:new ki}}},ah={basic:{uniforms:Ta([re.common,re.specularmap,re.envmap,re.aomap,re.lightmap,re.fog]),vertexShader:hr.meshbasic_vert,fragmentShader:hr.meshbasic_frag},lambert:{uniforms:Ta([re.common,re.specularmap,re.envmap,re.aomap,re.lightmap,re.emissivemap,re.fog,re.lights,{emissive:{value:new ne(0)}}]),vertexShader:hr.meshlambert_vert,fragmentShader:hr.meshlambert_frag},phong:{uniforms:Ta([re.common,re.specularmap,re.envmap,re.aomap,re.lightmap,re.emissivemap,re.bumpmap,re.normalmap,re.displacementmap,re.fog,re.lights,{emissive:{value:new ne(0)},specular:{value:new ne(1118481)},shininess:{value:30}}]),vertexShader:hr.meshphong_vert,fragmentShader:hr.meshphong_frag},standard:{uniforms:Ta([re.common,re.envmap,re.aomap,re.lightmap,re.emissivemap,re.bumpmap,re.normalmap,re.displacementmap,re.roughnessmap,re.metalnessmap,re.fog,re.lights,{emissive:{value:new ne(0)},roughness:{value:1},metalness:{value:0},envMapIntensity:{value:1}}]),vertexShader:hr.meshphysical_vert,fragmentShader:hr.meshphysical_frag},toon:{uniforms:Ta([re.common,re.aomap,re.lightmap,re.emissivemap,re.bumpmap,re.normalmap,re.displacementmap,re.gradientmap,re.fog,re.lights,{emissive:{value:new ne(0)}}]),vertexShader:hr.meshtoon_vert,fragmentShader:hr.meshtoon_frag},matcap:{uniforms:Ta([re.common,re.bumpmap,re.normalmap,re.displacementmap,re.fog,{matcap:{value:null}}]),vertexShader:hr.meshmatcap_vert,fragmentShader:hr.meshmatcap_frag},points:{uniforms:Ta([re.points,re.fog]),vertexShader:hr.points_vert,fragmentShader:hr.points_frag},dashed:{uniforms:Ta([re.common,re.fog,{scale:{value:1},dashSize:{value:1},totalSize:{value:2}}]),vertexShader:hr.linedashed_vert,fragmentShader:hr.linedashed_frag},depth:{uniforms:Ta([re.common,re.displacementmap]),vertexShader:hr.depth_vert,fragmentShader:hr.depth_frag},normal:{uniforms:Ta([re.common,re.bumpmap,re.normalmap,re.displacementmap,{opacity:{value:1}}]),vertexShader:hr.meshnormal_vert,fragmentShader:hr.meshnormal_frag},sprite:{uniforms:Ta([re.sprite,re.fog]),vertexShader:hr.sprite_vert,fragmentShader:hr.sprite_frag},background:{uniforms:{uvTransform:{value:new ki},t2D:{value:null}},vertexShader:hr.background_vert,fragmentShader:hr.background_frag},cube:{uniforms:Ta([re.envmap,{opacity:{value:1}}]),vertexShader:hr.cube_vert,fragmentShader:hr.cube_frag},equirect:{uniforms:{tEquirect:{value:null}},vertexShader:hr.equirect_vert,fragmentShader:hr.equirect_frag},distanceRGBA:{uniforms:Ta([re.common,re.displacementmap,{referencePosition:{value:new j},nearDistance:{value:1},farDistance:{value:1e3}}]),vertexShader:hr.distanceRGBA_vert,fragmentShader:hr.distanceRGBA_frag},shadow:{uniforms:Ta([re.lights,re.fog,{color:{value:new ne(0)},opacity:{value:1}}]),vertexShader:hr.shadow_vert,fragmentShader:hr.shadow_frag}};ah.physical={uniforms:Ta([ah.standard.uniforms,{clearcoat:{value:0},clearcoatMap:{value:null},clearcoatRoughness:{value:0},clearcoatRoughnessMap:{value:null},clearcoatNormalScale:{value:new Lt(1,1)},clearcoatNormalMap:{value:null},sheen:{value:0},sheenColor:{value:new ne(0)},sheenColorMap:{value:null},sheenRoughness:{value:1},sheenRoughnessMap:{value:null},transmission:{value:0},transmissionMap:{value:null},transmissionSamplerSize:{value:new Lt},transmissionSamplerMap:{value:null},thickness:{value:0},thicknessMap:{value:null},attenuationDistance:{value:0},attenuationColor:{value:new ne(0)},specularIntensity:{value:1},specularIntensityMap:{value:null},specularColor:{value:new ne(1,1,1)},specularColorMap:{value:null}}]),vertexShader:hr.meshphysical_vert,fragmentShader:hr.meshphysical_frag};function qdr(e,t,r,n,i,o){let a=new ne(0),s=i===!0?0:1,l,c,u=null,h=0,f=null;function p(g,_){let y=!1,x=_.isScene===!0?_.background:null;x&&x.isTexture&&(x=t.get(x));let b=e.xr,S=b.getSession&&b.getSession();S&&S.environmentBlendMode==="additive"&&(x=null),x===null?d(a,s):x&&x.isColor&&(d(x,1),y=!0),(e.autoClear||y)&&e.clear(e.autoClearColor,e.autoClearDepth,e.autoClearStencil),x&&(x.isCubeTexture||x.mapping===xM)?(c===void 0&&(c=new ei(new Qf(1,1,1),new lh({name:"BackgroundCubeMaterial",uniforms:Z3(ah.cube.uniforms),vertexShader:ah.cube.vertexShader,fragmentShader:ah.cube.fragmentShader,side:Ii,depthTest:!1,depthWrite:!1,fog:!1})),c.geometry.deleteAttribute("normal"),c.geometry.deleteAttribute("uv"),c.onBeforeRender=function(C,P,k){this.matrixWorld.copyPosition(k.matrixWorld)},Object.defineProperty(c.material,"envMap",{get:function(){return this.uniforms.envMap.value}}),n.update(c)),c.material.uniforms.envMap.value=x,c.material.uniforms.flipEnvMap.value=x.isCubeTexture&&x.isRenderTargetTexture===!1?-1:1,(u!==x||h!==x.version||f!==e.toneMapping)&&(c.material.needsUpdate=!0,u=x,h=x.version,f=e.toneMapping),g.unshift(c,c.geometry,c.material,0,0,null)):x&&x.isTexture&&(l===void 0&&(l=new ei(new V0(2,2),new lh({name:"BackgroundMaterial",uniforms:Z3(ah.background.uniforms),vertexShader:ah.background.vertexShader,fragmentShader:ah.background.fragmentShader,side:Iv,depthTest:!1,depthWrite:!1,fog:!1})),l.geometry.deleteAttribute("normal"),Object.defineProperty(l.material,"map",{get:function(){return this.uniforms.t2D.value}}),n.update(l)),l.material.uniforms.t2D.value=x,x.matrixAutoUpdate===!0&&x.updateMatrix(),l.material.uniforms.uvTransform.value.copy(x.matrix),(u!==x||h!==x.version||f!==e.toneMapping)&&(l.material.needsUpdate=!0,u=x,h=x.version,f=e.toneMapping),g.unshift(l,l.geometry,l.material,0,0,null))}function d(g,_){r.buffers.color.setClear(g.r,g.g,g.b,_,o)}return{getClearColor:function(){return a},setClearColor:function(g,_=1){a.set(g),s=_,d(a,s)},getClearAlpha:function(){return s},setClearAlpha:function(g){s=g,d(a,s)},render:p}}function Gdr(e,t,r,n){let i=e.getParameter(34921),o=n.isWebGL2?null:t.get("OES_vertex_array_object"),a=n.isWebGL2||o!==null,s={},l=g(null),c=l;function u(R,F,z,U,W){let Z=!1;if(a){let rt=d(U,z,F);c!==rt&&(c=rt,f(c.object)),Z=_(U,W),Z&&y(U,W)}else{let rt=F.wireframe===!0;(c.geometry!==U.id||c.program!==z.id||c.wireframe!==rt)&&(c.geometry=U.id,c.program=z.id,c.wireframe=rt,Z=!0)}R.isInstancedMesh===!0&&(Z=!0),W!==null&&r.update(W,34963),Z&&(k(R,F,z,U),W!==null&&e.bindBuffer(34963,r.get(W).buffer))}function h(){return n.isWebGL2?e.createVertexArray():o.createVertexArrayOES()}function f(R){return n.isWebGL2?e.bindVertexArray(R):o.bindVertexArrayOES(R)}function p(R){return n.isWebGL2?e.deleteVertexArray(R):o.deleteVertexArrayOES(R)}function d(R,F,z){let U=z.wireframe===!0,W=s[R.id];W===void 0&&(W={},s[R.id]=W);let Z=W[F.id];Z===void 0&&(Z={},W[F.id]=Z);let rt=Z[U];return rt===void 0&&(rt=g(h()),Z[U]=rt),rt}function g(R){let F=[],z=[],U=[];for(let W=0;W<i;W++)F[W]=0,z[W]=0,U[W]=0;return{geometry:null,program:null,wireframe:!1,newAttributes:F,enabledAttributes:z,attributeDivisors:U,object:R,attributes:{},index:null}}function _(R,F){let z=c.attributes,U=R.attributes,W=0;for(let Z in U){let rt=z[Z],ot=U[Z];if(rt===void 0||rt.attribute!==ot||rt.data!==ot.data)return!0;W++}return c.attributesNum!==W||c.index!==F}function y(R,F){let z={},U=R.attributes,W=0;for(let Z in U){let rt=U[Z],ot={};ot.attribute=rt,rt.data&&(ot.data=rt.data),z[Z]=ot,W++}c.attributes=z,c.attributesNum=W,c.index=F}function x(){let R=c.newAttributes;for(let F=0,z=R.length;F<z;F++)R[F]=0}function b(R){S(R,0)}function S(R,F){let z=c.newAttributes,U=c.enabledAttributes,W=c.attributeDivisors;z[R]=1,U[R]===0&&(e.enableVertexAttribArray(R),U[R]=1),W[R]!==F&&((n.isWebGL2?e:t.get("ANGLE_instanced_arrays"))[n.isWebGL2?"vertexAttribDivisor":"vertexAttribDivisorANGLE"](R,F),W[R]=F)}function C(){let R=c.newAttributes,F=c.enabledAttributes;for(let z=0,U=F.length;z<U;z++)F[z]!==R[z]&&(e.disableVertexAttribArray(z),F[z]=0)}function P(R,F,z,U,W,Z){n.isWebGL2===!0&&(z===5124||z===5125)?e.vertexAttribIPointer(R,F,z,W,Z):e.vertexAttribPointer(R,F,z,U,W,Z)}function k(R,F,z,U){if(n.isWebGL2===!1&&(R.isInstancedMesh||U.isInstancedBufferGeometry)&&t.get("ANGLE_instanced_arrays")===null)return;x();let W=U.attributes,Z=z.getAttributes(),rt=F.defaultAttributeValues;for(let ot in Z){let st=Z[ot];if(st.location>=0){let St=W[ot];if(St===void 0&&(ot==="instanceMatrix"&&R.instanceMatrix&&(St=R.instanceMatrix),ot==="instanceColor"&&R.instanceColor&&(St=R.instanceColor)),St!==void 0){let bt=St.normalized,Mt=St.itemSize,lt=r.get(St);if(lt===void 0)continue;let Kt=lt.buffer,_t=lt.type,ct=lt.bytesPerElement;if(St.isInterleavedBufferAttribute){let X=St.data,et=X.stride,dt=St.offset;if(X&&X.isInstancedInterleavedBuffer){for(let q=0;q<st.locationSize;q++)S(st.location+q,X.meshPerAttribute);R.isInstancedMesh!==!0&&U._maxInstanceCount===void 0&&(U._maxInstanceCount=X.meshPerAttribute*X.count)}else for(let q=0;q<st.locationSize;q++)b(st.location+q);e.bindBuffer(34962,Kt);for(let q=0;q<st.locationSize;q++)P(st.location+q,Mt/st.locationSize,_t,bt,et*ct,(dt+Mt/st.locationSize*q)*ct)}else{if(St.isInstancedBufferAttribute){for(let X=0;X<st.locationSize;X++)S(st.location+X,St.meshPerAttribute);R.isInstancedMesh!==!0&&U._maxInstanceCount===void 0&&(U._maxInstanceCount=St.meshPerAttribute*St.count)}else for(let X=0;X<st.locationSize;X++)b(st.location+X);e.bindBuffer(34962,Kt);for(let X=0;X<st.locationSize;X++)P(st.location+X,Mt/st.locationSize,_t,bt,Mt*ct,Mt/st.locationSize*X*ct)}}else if(rt!==void 0){let bt=rt[ot];if(bt!==void 0)switch(bt.length){case 2:e.vertexAttrib2fv(st.location,bt);break;case 3:e.vertexAttrib3fv(st.location,bt);break;case 4:e.vertexAttrib4fv(st.location,bt);break;default:e.vertexAttrib1fv(st.location,bt)}}}}C()}function O(){I();for(let R in s){let F=s[R];for(let z in F){let U=F[z];for(let W in U)p(U[W].object),delete U[W];delete F[z]}delete s[R]}}function D(R){if(s[R.id]===void 0)return;let F=s[R.id];for(let z in F){let U=F[z];for(let W in U)p(U[W].object),delete U[W];delete F[z]}delete s[R.id]}function B(R){for(let F in s){let z=s[F];if(z[R.id]===void 0)continue;let U=z[R.id];for(let W in U)p(U[W].object),delete U[W];delete z[R.id]}}function I(){L(),c!==l&&(c=l,f(c.object))}function L(){l.geometry=null,l.program=null,l.wireframe=!1}return{setup:u,reset:I,resetDefaultState:L,dispose:O,releaseStatesOfGeometry:D,releaseStatesOfProgram:B,initAttributes:x,enableAttribute:b,disableUnusedAttributes:C}}function Wdr(e,t,r,n){let i=n.isWebGL2,o;function a(c){o=c}function s(c,u){e.drawArrays(o,c,u),r.update(u,o,1)}function l(c,u,h){if(h===0)return;let f,p;if(i)f=e,p="drawArraysInstanced";else if(f=t.get("ANGLE_instanced_arrays"),p="drawArraysInstancedANGLE",f===null){console.error("THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");return}f[p](o,c,u,h),r.update(u,o,h)}this.setMode=a,this.render=s,this.renderInstances=l}function Ydr(e,t,r){let n;function i(){if(n!==void 0)return n;if(t.has("EXT_texture_filter_anisotropic")===!0){let k=t.get("EXT_texture_filter_anisotropic");n=e.getParameter(k.MAX_TEXTURE_MAX_ANISOTROPY_EXT)}else n=0;return n}function o(k){if(k==="highp"){if(e.getShaderPrecisionFormat(35633,36338).precision>0&&e.getShaderPrecisionFormat(35632,36338).precision>0)return"highp";k="mediump"}return k==="mediump"&&e.getShaderPrecisionFormat(35633,36337).precision>0&&e.getShaderPrecisionFormat(35632,36337).precision>0?"mediump":"lowp"}let a=typeof WebGL2RenderingContext!="undefined"&&e instanceof WebGL2RenderingContext||typeof WebGL2ComputeRenderingContext!="undefined"&&e instanceof WebGL2ComputeRenderingContext,s=r.precision!==void 0?r.precision:"highp",l=o(s);l!==s&&(console.warn("THREE.WebGLRenderer:",s,"not supported, using",l,"instead."),s=l);let c=a||t.has("WEBGL_draw_buffers"),u=r.logarithmicDepthBuffer===!0,h=e.getParameter(34930),f=e.getParameter(35660),p=e.getParameter(3379),d=e.getParameter(34076),g=e.getParameter(34921),_=e.getParameter(36347),y=e.getParameter(36348),x=e.getParameter(36349),b=f>0,S=a||t.has("OES_texture_float"),C=b&&S,P=a?e.getParameter(36183):0;return{isWebGL2:a,drawBuffers:c,getMaxAnisotropy:i,getMaxPrecision:o,precision:s,logarithmicDepthBuffer:u,maxTextures:h,maxVertexTextures:f,maxTextureSize:p,maxCubemapSize:d,maxAttributes:g,maxVertexUniforms:_,maxVaryings:y,maxFragmentUniforms:x,vertexTextures:b,floatFragmentTextures:S,floatVertexTextures:C,maxSamples:P}}function jdr(e){let t=this,r=null,n=0,i=!1,o=!1,a=new $c,s=new ki,l={value:null,needsUpdate:!1};this.uniform=l,this.numPlanes=0,this.numIntersection=0,this.init=function(h,f,p){let d=h.length!==0||f||n!==0||i;return i=f,r=u(h,p,0),n=h.length,d},this.beginShadows=function(){o=!0,u(null)},this.endShadows=function(){o=!1,c()},this.setState=function(h,f,p){let d=h.clippingPlanes,g=h.clipIntersection,_=h.clipShadows,y=e.get(h);if(!i||d===null||d.length===0||o&&!_)o?u(null):c();else{let x=o?0:n,b=x*4,S=y.clippingState||null;l.value=S,S=u(d,f,b,p);for(let C=0;C!==b;++C)S[C]=r[C];y.clippingState=S,this.numIntersection=g?this.numPlanes:0,this.numPlanes+=x}};function c(){l.value!==r&&(l.value=r,l.needsUpdate=n>0),t.numPlanes=n,t.numIntersection=0}function u(h,f,p,d){let g=h!==null?h.length:0,_=null;if(g!==0){if(_=l.value,d!==!0||_===null){let y=p+g*4,x=f.matrixWorldInverse;s.getNormalMatrix(x),(_===null||_.length<y)&&(_=new Float32Array(y));for(let b=0,S=p;b!==g;++b,S+=4)a.copy(h[b]).applyMatrix4(x,s),a.normal.toArray(_,S),_[S+3]=a.constant}l.value=_,l.needsUpdate=!0}return t.numPlanes=g,t.numIntersection=0,_}}function Xdr(e){let t=new WeakMap;function r(a,s){return s===WP?a.mapping=nx:s===YP&&(a.mapping=ix),a}function n(a){if(a&&a.isTexture&&a.isRenderTargetTexture===!1){let s=a.mapping;if(s===WP||s===YP)if(t.has(a)){let l=t.get(a).texture;return r(l,a.mapping)}else{let l=a.image;if(l&&l.height>0){let c=new Q3(l.height/2);return c.fromEquirectangularTexture(e,a),t.set(a,c),a.addEventListener("dispose",i),r(c.texture,a.mapping)}else return null}}return a}function i(a){let s=a.target;s.removeEventListener("dispose",i);let l=t.get(s);l!==void 0&&(t.delete(s),l.dispose())}function o(){t=new WeakMap}return{get:n,dispose:o}}var Dv=class extends Rv{constructor(t=-1,r=1,n=1,i=-1,o=.1,a=2e3){super(),this.type="OrthographicCamera",this.zoom=1,this.view=null,this.left=t,this.right=r,this.top=n,this.bottom=i,this.near=o,this.far=a,this.updateProjectionMatrix()}copy(t,r){return super.copy(t,r),this.left=t.left,this.right=t.right,this.top=t.top,this.bottom=t.bottom,this.near=t.near,this.far=t.far,this.zoom=t.zoom,this.view=t.view===null?null:Object.assign({},t.view),this}setViewOffset(t,r,n,i,o,a){this.view===null&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=r,this.view.offsetX=n,this.view.offsetY=i,this.view.width=o,this.view.height=a,this.updateProjectionMatrix()}clearViewOffset(){this.view!==null&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let t=(this.right-this.left)/(2*this.zoom),r=(this.top-this.bottom)/(2*this.zoom),n=(this.right+this.left)/2,i=(this.top+this.bottom)/2,o=n-t,a=n+t,s=i+r,l=i-r;if(this.view!==null&&this.view.enabled){let c=(this.right-this.left)/this.view.fullWidth/this.zoom,u=(this.top-this.bottom)/this.view.fullHeight/this.zoom;o+=c*this.view.offsetX,a=o+c*this.view.width,s-=u*this.view.offsetY,l=s-u*this.view.height}this.projectionMatrix.makeOrthographic(o,a,s,l,this.near,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){let r=super.toJSON(t);return r.object.zoom=this.zoom,r.object.left=this.left,r.object.right=this.right,r.object.top=this.top,r.object.bottom=this.bottom,r.object.near=this.near,r.object.far=this.far,this.view!==null&&(r.object.view=Object.assign({},this.view)),r}};Dv.prototype.isOrthographicCamera=!0;var U0=class extends lh{constructor(t){super(t),this.type="RawShaderMaterial"}};U0.prototype.isRawShaderMaterial=!0;var q3=4,F0=8,$f=Math.pow(2,F0),Ffe=[.125,.215,.35,.446,.526,.582],Bfe=F0-q3+1+Ffe.length,k3=20,fut=new Dv,{_lodPlanes:RP,_sizeLods:Mue,_sigmas:AV}=$dr(),Eue=new ne,put=null,Sv=(1+Math.sqrt(5))/2,R3=1/Sv,Tue=[new j(1,1,1),new j(-1,1,1),new j(1,1,-1),new j(-1,1,-1),new j(0,Sv,R3),new j(0,Sv,-R3),new j(R3,0,Sv),new j(-R3,0,Sv),new j(Sv,R3,0),new j(-Sv,R3,0)],t6=class{constructor(t){this._renderer=t,this._pingPongRenderTarget=null,this._blurMaterial=Kdr(k3),this._equirectShader=null,this._cubemapShader=null,this._compileMaterial(this._blurMaterial)}fromScene(t,r=0,n=.1,i=100){put=this._renderer.getRenderTarget();let o=this._allocateTargets();return this._sceneToCubeUV(t,n,i,o),r>0&&this._blur(o,0,0,r),this._applyPMREM(o),this._cleanup(o),o}fromEquirectangular(t,r=null){return this._fromTexture(t,r)}fromCubemap(t,r=null){return this._fromTexture(t,r)}compileCubemapShader(){this._cubemapShader===null&&(this._cubemapShader=Pue(),this._compileMaterial(this._cubemapShader))}compileEquirectangularShader(){this._equirectShader===null&&(this._equirectShader=Aue(),this._compileMaterial(this._equirectShader))}dispose(){this._blurMaterial.dispose(),this._pingPongRenderTarget!==null&&this._pingPongRenderTarget.dispose(),this._cubemapShader!==null&&this._cubemapShader.dispose(),this._equirectShader!==null&&this._equirectShader.dispose();for(let t=0;t<RP.length;t++)RP[t].dispose()}_cleanup(t){this._renderer.setRenderTarget(put),t.scissorTest=!1,PV(t,0,0,t.width,t.height)}_fromTexture(t,r){put=this._renderer.getRenderTarget();let n=r||this._allocateTargets(t);return this._textureToCubeUV(t,n),this._applyPMREM(n),this._cleanup(n),n}_allocateTargets(t){let r={magFilter:oi,minFilter:oi,generateMipmaps:!1,type:Cv,format:Qo,encoding:Qd,depthBuffer:!1},n=Cue(r);return n.depthBuffer=!t,this._pingPongRenderTarget===null&&(this._pingPongRenderTarget=Cue(r)),n}_compileMaterial(t){let r=new ei(RP[0],t);this._renderer.compile(r,fut)}_sceneToCubeUV(t,r,n,i){let s=new Ui(90,1,r,n),l=[1,-1,1,1,1,1],c=[1,1,1,-1,-1,-1],u=this._renderer,h=u.autoClear,f=u.toneMapping;u.getClearColor(Eue),u.toneMapping=Kd,u.autoClear=!1;let p=new sh({name:"PMREM.Background",side:Ii,depthWrite:!1,depthTest:!1}),d=new ei(new Qf,p),g=!1,_=t.background;_?_.isColor&&(p.color.copy(_),t.background=null,g=!0):(p.color.copy(Eue),g=!0);for(let y=0;y<6;y++){let x=y%3;x===0?(s.up.set(0,l[y],0),s.lookAt(c[y],0,0)):x===1?(s.up.set(0,0,l[y]),s.lookAt(0,c[y],0)):(s.up.set(0,l[y],0),s.lookAt(0,0,c[y])),PV(i,x*$f,y>2?$f:0,$f,$f),u.setRenderTarget(i),g&&u.render(d,s),u.render(t,s)}d.geometry.dispose(),d.material.dispose(),u.toneMapping=f,u.autoClear=h,t.background=_}_textureToCubeUV(t,r){let n=this._renderer,i=t.mapping===nx||t.mapping===ix;i?(this._cubemapShader===null&&(this._cubemapShader=Pue()),this._cubemapShader.uniforms.flipEnvMap.value=t.isRenderTargetTexture===!1?-1:1):this._equirectShader===null&&(this._equirectShader=Aue());let o=i?this._cubemapShader:this._equirectShader,a=new ei(RP[0],o),s=o.uniforms;s.envMap.value=t,i||s.texelSize.value.set(1/t.image.width,1/t.image.height),PV(r,0,0,3*$f,2*$f),n.setRenderTarget(r),n.render(a,fut)}_applyPMREM(t){let r=this._renderer,n=r.autoClear;r.autoClear=!1;for(let i=1;i<Bfe;i++){let o=Math.sqrt(AV[i]*AV[i]-AV[i-1]*AV[i-1]),a=Tue[(i-1)%Tue.length];this._blur(t,i-1,i,o,a)}r.autoClear=n}_blur(t,r,n,i,o){let a=this._pingPongRenderTarget;this._halfBlur(t,a,r,n,i,"latitudinal",o),this._halfBlur(a,t,n,n,i,"longitudinal",o)}_halfBlur(t,r,n,i,o,a,s){let l=this._renderer,c=this._blurMaterial;a!=="latitudinal"&&a!=="longitudinal"&&console.error("blur direction must be either latitudinal or longitudinal!");let u=3,h=new ei(RP[i],c),f=c.uniforms,p=Mue[n]-1,d=isFinite(o)?Math.PI/(2*p):2*Math.PI/(2*k3-1),g=o/d,_=isFinite(o)?1+Math.floor(u*g):k3;_>k3&&console.warn(`sigmaRadians, ${o}, is too large and will clip, as it requested ${_} samples when the maximum is set to ${k3}`);let y=[],x=0;for(let P=0;P<k3;++P){let k=P/g,O=Math.exp(-k*k/2);y.push(O),P===0?x+=O:P<_&&(x+=2*O)}for(let P=0;P<y.length;P++)y[P]=y[P]/x;f.envMap.value=t.texture,f.samples.value=_,f.weights.value=y,f.latitudinal.value=a==="latitudinal",s&&(f.poleAxis.value=s),f.dTheta.value=d,f.mipInt.value=F0-n;let b=Mue[i],S=3*Math.max(0,$f-2*b),C=(i===0?0:2*$f)+2*b*(i>F0-q3?i-F0+q3:0);PV(r,S,C,3*b,2*b),l.setRenderTarget(r),l.render(h,fut)}};function $dr(){let e=[],t=[],r=[],n=F0;for(let i=0;i<Bfe;i++){let o=Math.pow(2,n);t.push(o);let a=1/o;i>F0-q3?a=Ffe[i-F0+q3-1]:i===0&&(a=0),r.push(a);let s=1/(o-1),l=-s/2,c=1+s/2,u=[l,l,c,l,c,c,l,l,c,c,l,c],h=6,f=6,p=3,d=2,g=1,_=new Float32Array(p*f*h),y=new Float32Array(d*f*h),x=new Float32Array(g*f*h);for(let S=0;S<h;S++){let C=S%3*2/3-1,P=S>2?0:-1,k=[C,P,0,C+2/3,P,0,C+2/3,P+1,0,C,P,0,C+2/3,P+1,0,C,P+1,0];_.set(k,p*f*S),y.set(u,d*f*S);let O=[S,S,S,S,S,S];x.set(O,g*f*S)}let b=new Pe;b.setAttribute("position",new Je(_,p)),b.setAttribute("uv",new Je(y,d)),b.setAttribute("faceIndex",new Je(x,g)),e.push(b),n>q3&&n--}return{_lodPlanes:e,_sizeLods:t,_sigmas:r}}function Cue(e){let t=new us(3*$f,3*$f,e);return t.texture.mapping=xM,t.texture.name="PMREM.cubeUv",t.scissorTest=!0,t}function PV(e,t,r,n,i){e.viewport.set(t,r,n,i),e.scissor.set(t,r,n,i)}function Kdr(e){let t=new Float32Array(e),r=new j(0,1,0);return new U0({name:"SphericalGaussianBlur",defines:{n:e},uniforms:{envMap:{value:null},samples:{value:1},weights:{value:t},latitudinal:{value:!1},dTheta:{value:0},mipInt:{value:0},poleAxis:{value:r}},vertexShader:Dht(),fragmentShader:`

			precision mediump float;
			precision mediump int;

			varying vec3 vOutputDirection;

			uniform sampler2D envMap;
			uniform int samples;
			uniform float weights[ n ];
			uniform bool latitudinal;
			uniform float dTheta;
			uniform float mipInt;
			uniform vec3 poleAxis;

			#define ENVMAP_TYPE_CUBE_UV
			#include <cube_uv_reflection_fragment>

			vec3 getSample( float theta, vec3 axis ) {

				float cosTheta = cos( theta );
				// Rodrigues' axis-angle rotation
				vec3 sampleDirection = vOutputDirection * cosTheta
					+ cross( axis, vOutputDirection ) * sin( theta )
					+ axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );

				return bilinearCubeUV( envMap, sampleDirection, mipInt );

			}

			void main() {

				vec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );

				if ( all( equal( axis, vec3( 0.0 ) ) ) ) {

					axis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );

				}

				axis = normalize( axis );

				gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );
				gl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );

				for ( int i = 1; i < n; i++ ) {

					if ( i >= samples ) {

						break;

					}

					float theta = dTheta * float( i );
					gl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );
					gl_FragColor.rgb += weights[ i ] * getSample( theta, axis );

				}

			}
		`,blending:$d,depthTest:!1,depthWrite:!1})}function Aue(){let e=new Lt(1,1);return new U0({name:"EquirectangularToCubeUV",uniforms:{envMap:{value:null},texelSize:{value:e}},vertexShader:Dht(),fragmentShader:`

			precision mediump float;
			precision mediump int;

			varying vec3 vOutputDirection;

			uniform sampler2D envMap;
			uniform vec2 texelSize;

			#include <common>

			void main() {

				gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );

				vec3 outputDirection = normalize( vOutputDirection );
				vec2 uv = equirectUv( outputDirection );

				vec2 f = fract( uv / texelSize - 0.5 );
				uv -= f * texelSize;
				vec3 tl = texture2D ( envMap, uv ).rgb;
				uv.x += texelSize.x;
				vec3 tr = texture2D ( envMap, uv ).rgb;
				uv.y += texelSize.y;
				vec3 br = texture2D ( envMap, uv ).rgb;
				uv.x -= texelSize.x;
				vec3 bl = texture2D ( envMap, uv ).rgb;

				vec3 tm = mix( tl, tr, f.x );
				vec3 bm = mix( bl, br, f.x );
				gl_FragColor.rgb = mix( tm, bm, f.y );

			}
		`,blending:$d,depthTest:!1,depthWrite:!1})}function Pue(){return new U0({name:"CubemapToCubeUV",uniforms:{envMap:{value:null},flipEnvMap:{value:-1}},vertexShader:Dht(),fragmentShader:`

			precision mediump float;
			precision mediump int;

			uniform float flipEnvMap;

			varying vec3 vOutputDirection;

			uniform samplerCube envMap;

			void main() {

				gl_FragColor = textureCube( envMap, vec3( flipEnvMap * vOutputDirection.x, vOutputDirection.yz ) );

			}
		`,blending:$d,depthTest:!1,depthWrite:!1})}function Dht(){return`

		precision mediump float;
		precision mediump int;

		attribute vec3 position;
		attribute vec2 uv;
		attribute float faceIndex;

		varying vec3 vOutputDirection;

		// RH coordinate system; PMREM face-indexing convention
		vec3 getDirection( vec2 uv, float face ) {

			uv = 2.0 * uv - 1.0;

			vec3 direction = vec3( uv, 1.0 );

			if ( face == 0.0 ) {

				direction = direction.zyx; // ( 1, v, u ) pos x

			} else if ( face == 1.0 ) {

				direction = direction.xzy;
				direction.xz *= -1.0; // ( -u, 1, -v ) pos y

			} else if ( face == 2.0 ) {

				direction.x *= -1.0; // ( -u, v, 1 ) pos z

			} else if ( face == 3.0 ) {

				direction = direction.zyx;
				direction.xz *= -1.0; // ( -1, v, -u ) neg x

			} else if ( face == 4.0 ) {

				direction = direction.xzy;
				direction.xy *= -1.0; // ( -u, -1, v ) neg y

			} else if ( face == 5.0 ) {

				direction.z *= -1.0; // ( u, v, -1 ) neg z

			}

			return direction;

		}

		void main() {

			vOutputDirection = getDirection( uv, faceIndex );
			gl_Position = vec4( position, 1.0 );

		}
	`}function Zdr(e){let t=new WeakMap,r=null;function n(s){if(s&&s.isTexture){let l=s.mapping,c=l===WP||l===YP,u=l===nx||l===ix;if(c||u)if(s.isRenderTargetTexture&&s.needsPMREMUpdate===!0){s.needsPMREMUpdate=!1;let h=t.get(s);return r===null&&(r=new t6(e)),h=c?r.fromEquirectangular(s,h):r.fromCubemap(s,h),t.set(s,h),h.texture}else{if(t.has(s))return t.get(s).texture;{let h=s.image;if(c&&h&&h.height>0||u&&h&&i(h)){r===null&&(r=new t6(e));let f=c?r.fromEquirectangular(s):r.fromCubemap(s);return t.set(s,f),s.addEventListener("dispose",o),f.texture}else return null}}}return s}function i(s){let l=0,c=6;for(let u=0;u<c;u++)s[u]!==void 0&&l++;return l===c}function o(s){let l=s.target;l.removeEventListener("dispose",o);let c=t.get(l);c!==void 0&&(t.delete(l),c.dispose())}function a(){t=new WeakMap,r!==null&&(r.dispose(),r=null)}return{get:n,dispose:a}}function Jdr(e){let t={};function r(n){if(t[n]!==void 0)return t[n];let i;switch(n){case"WEBGL_depth_texture":i=e.getExtension("WEBGL_depth_texture")||e.getExtension("MOZ_WEBGL_depth_texture")||e.getExtension("WEBKIT_WEBGL_depth_texture");break;case"EXT_texture_filter_anisotropic":i=e.getExtension("EXT_texture_filter_anisotropic")||e.getExtension("MOZ_EXT_texture_filter_anisotropic")||e.getExtension("WEBKIT_EXT_texture_filter_anisotropic");break;case"WEBGL_compressed_texture_s3tc":i=e.getExtension("WEBGL_compressed_texture_s3tc")||e.getExtension("MOZ_WEBGL_compressed_texture_s3tc")||e.getExtension("WEBKIT_WEBGL_compressed_texture_s3tc");break;case"WEBGL_compressed_texture_pvrtc":i=e.getExtension("WEBGL_compressed_texture_pvrtc")||e.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc");break;default:i=e.getExtension(n)}return t[n]=i,i}return{has:function(n){return r(n)!==null},init:function(n){n.isWebGL2?r("EXT_color_buffer_float"):(r("WEBGL_depth_texture"),r("OES_texture_float"),r("OES_texture_half_float"),r("OES_texture_half_float_linear"),r("OES_standard_derivatives"),r("OES_element_index_uint"),r("OES_vertex_array_object"),r("ANGLE_instanced_arrays")),r("OES_texture_float_linear"),r("EXT_color_buffer_half_float"),r("WEBGL_multisampled_render_to_texture")},get:function(n){let i=r(n);return i===null&&console.warn("THREE.WebGLRenderer: "+n+" extension not supported."),i}}}function Qdr(e,t,r,n){let i={},o=new WeakMap;function a(h){let f=h.target;f.index!==null&&t.remove(f.index);for(let d in f.attributes)t.remove(f.attributes[d]);f.removeEventListener("dispose",a),delete i[f.id];let p=o.get(f);p&&(t.remove(p),o.delete(f)),n.releaseStatesOfGeometry(f),f.isInstancedBufferGeometry===!0&&delete f._maxInstanceCount,r.memory.geometries--}function s(h,f){return i[f.id]===!0||(f.addEventListener("dispose",a),i[f.id]=!0,r.memory.geometries++),f}function l(h){let f=h.attributes;for(let d in f)t.update(f[d],34962);let p=h.morphAttributes;for(let d in p){let g=p[d];for(let _=0,y=g.length;_<y;_++)t.update(g[_],34962)}}function c(h){let f=[],p=h.index,d=h.attributes.position,g=0;if(p!==null){let x=p.array;g=p.version;for(let b=0,S=x.length;b<S;b+=3){let C=x[b+0],P=x[b+1],k=x[b+2];f.push(C,P,P,k,k,C)}}else{let x=d.array;g=d.version;for(let b=0,S=x.length/3-1;b<S;b+=3){let C=b+0,P=b+1,k=b+2;f.push(C,P,P,k,k,C)}}let _=new(Nfe(f)?K3:$3)(f,1);_.version=g;let y=o.get(h);y&&t.remove(y),o.set(h,_)}function u(h){let f=o.get(h);if(f){let p=h.index;p!==null&&f.version<p.version&&c(h)}else c(h);return o.get(h)}return{get:s,update:l,getWireframeAttribute:u}}function tmr(e,t,r,n){let i=n.isWebGL2,o;function a(f){o=f}let s,l;function c(f){s=f.type,l=f.bytesPerElement}function u(f,p){e.drawElements(o,p,s,f*l),r.update(p,o,1)}function h(f,p,d){if(d===0)return;let g,_;if(i)g=e,_="drawElementsInstanced";else if(g=t.get("ANGLE_instanced_arrays"),_="drawElementsInstancedANGLE",g===null){console.error("THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");return}g[_](o,p,s,f*l,d),r.update(p,o,d)}this.setMode=a,this.setIndex=c,this.render=u,this.renderInstances=h}function emr(e){let t={geometries:0,textures:0},r={frame:0,calls:0,triangles:0,points:0,lines:0};function n(o,a,s){switch(r.calls++,a){case 4:r.triangles+=s*(o/3);break;case 1:r.lines+=s*(o/2);break;case 3:r.lines+=s*(o-1);break;case 2:r.lines+=s*o;break;case 0:r.points+=s*o;break;default:console.error("THREE.WebGLInfo: Unknown draw mode:",a);break}}function i(){r.frame++,r.calls=0,r.triangles=0,r.points=0,r.lines=0}return{memory:t,render:r,programs:null,autoReset:!0,reset:i,update:n}}var tM=class extends xi{constructor(t=null,r=1,n=1,i=1){super(null),this.image={data:t,width:r,height:n,depth:i},this.magFilter=Li,this.minFilter=Li,this.wrapR=Jo,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};tM.prototype.isDataTexture2DArray=!0;function rmr(e,t){return e[0]-t[0]}function nmr(e,t){return Math.abs(t[1])-Math.abs(e[1])}function Iue(e,t){let r=1,n=t.isInterleavedBufferAttribute?t.data.array:t.array;n instanceof Int8Array?r=127:n instanceof Int16Array?r=32767:n instanceof Int32Array?r=2147483647:console.error("THREE.WebGLMorphtargets: Unsupported morph attribute data type: ",n),e.divideScalar(r)}function imr(e,t,r){let n={},i=new Float32Array(8),o=new WeakMap,a=new j,s=[];for(let c=0;c<8;c++)s[c]=[c,0];function l(c,u,h,f){let p=c.morphTargetInfluences;if(t.isWebGL2===!0){let d=u.morphAttributes.position.length,g=o.get(u);if(g===void 0||g.count!==d){let L=function(){B.dispose(),o.delete(u),u.removeEventListener("dispose",L)};g!==void 0&&g.texture.dispose();let x=u.morphAttributes.normal!==void 0,b=u.morphAttributes.position,S=u.morphAttributes.normal||[],C=u.attributes.position.count,P=x===!0?2:1,k=C*P,O=1;k>t.maxTextureSize&&(O=Math.ceil(k/t.maxTextureSize),k=t.maxTextureSize);let D=new Float32Array(k*O*4*d),B=new tM(D,k,O,d);B.format=Qo,B.type=jd,B.needsUpdate=!0;let I=P*4;for(let R=0;R<d;R++){let F=b[R],z=S[R],U=k*O*4*R;for(let W=0;W<F.count;W++){a.fromBufferAttribute(F,W),F.normalized===!0&&Iue(a,F);let Z=W*I;D[U+Z+0]=a.x,D[U+Z+1]=a.y,D[U+Z+2]=a.z,D[U+Z+3]=0,x===!0&&(a.fromBufferAttribute(z,W),z.normalized===!0&&Iue(a,z),D[U+Z+4]=a.x,D[U+Z+5]=a.y,D[U+Z+6]=a.z,D[U+Z+7]=0)}}g={count:d,texture:B,size:new Lt(k,O)},o.set(u,g),u.addEventListener("dispose",L)}let _=0;for(let x=0;x<p.length;x++)_+=p[x];let y=u.morphTargetsRelative?1:1-_;f.getUniforms().setValue(e,"morphTargetBaseInfluence",y),f.getUniforms().setValue(e,"morphTargetInfluences",p),f.getUniforms().setValue(e,"morphTargetsTexture",g.texture,r),f.getUniforms().setValue(e,"morphTargetsTextureSize",g.size)}else{let d=p===void 0?0:p.length,g=n[u.id];if(g===void 0||g.length!==d){g=[];for(let S=0;S<d;S++)g[S]=[S,0];n[u.id]=g}for(let S=0;S<d;S++){let C=g[S];C[0]=S,C[1]=p[S]}g.sort(nmr);for(let S=0;S<8;S++)S<d&&g[S][1]?(s[S][0]=g[S][0],s[S][1]=g[S][1]):(s[S][0]=Number.MAX_SAFE_INTEGER,s[S][1]=0);s.sort(rmr);let _=u.morphAttributes.position,y=u.morphAttributes.normal,x=0;for(let S=0;S<8;S++){let C=s[S],P=C[0],k=C[1];P!==Number.MAX_SAFE_INTEGER&&k?(_&&u.getAttribute("morphTarget"+S)!==_[P]&&u.setAttribute("morphTarget"+S,_[P]),y&&u.getAttribute("morphNormal"+S)!==y[P]&&u.setAttribute("morphNormal"+S,y[P]),i[S]=k,x+=k):(_&&u.hasAttribute("morphTarget"+S)===!0&&u.deleteAttribute("morphTarget"+S),y&&u.hasAttribute("morphNormal"+S)===!0&&u.deleteAttribute("morphNormal"+S),i[S]=0)}let b=u.morphTargetsRelative?1:1-x;f.getUniforms().setValue(e,"morphTargetBaseInfluence",b),f.getUniforms().setValue(e,"morphTargetInfluences",i)}}return{update:l}}function omr(e,t,r,n){let i=new WeakMap;function o(l){let c=n.render.frame,u=l.geometry,h=t.get(l,u);return i.get(h)!==c&&(t.update(h),i.set(h,c)),l.isInstancedMesh&&(l.hasEventListener("dispose",s)===!1&&l.addEventListener("dispose",s),r.update(l.instanceMatrix,34962),l.instanceColor!==null&&r.update(l.instanceColor,34962)),h}function a(){i=new WeakMap}function s(l){let c=l.target;c.removeEventListener("dispose",s),r.remove(c.instanceMatrix),c.instanceColor!==null&&r.remove(c.instanceColor)}return{update:o,dispose:a}}var e6=class extends xi{constructor(t=null,r=1,n=1,i=1){super(null),this.image={data:t,width:r,height:n,depth:i},this.magFilter=Li,this.minFilter=Li,this.wrapR=Jo,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};e6.prototype.isDataTexture3D=!0;var Hfe=new xi,Vfe=new tM,Ufe=new e6,qfe=new H0,Lue=[],kue=[],Rue=new Float32Array(16),Nue=new Float32Array(9),Due=new Float32Array(4);function bM(e,t,r){let n=e[0];if(n<=0||n>0)return e;let i=t*r,o=Lue[i];if(o===void 0&&(o=new Float32Array(i),Lue[i]=o),t!==0){n.toArray(o,0);for(let a=1,s=0;a!==t;++a)s+=r,e[a].toArray(o,s)}return o}function hs(e,t){if(e.length!==t.length)return!1;for(let r=0,n=e.length;r<n;r++)if(e[r]!==t[r])return!1;return!0}function Ca(e,t){for(let r=0,n=t.length;r<n;r++)e[r]=t[r]}function $U(e,t){let r=kue[t];r===void 0&&(r=new Int32Array(t),kue[t]=r);for(let n=0;n!==t;++n)r[n]=e.allocateTextureUnit();return r}function amr(e,t){let r=this.cache;r[0]!==t&&(e.uniform1f(this.addr,t),r[0]=t)}function smr(e,t){let r=this.cache;if(t.x!==void 0)(r[0]!==t.x||r[1]!==t.y)&&(e.uniform2f(this.addr,t.x,t.y),r[0]=t.x,r[1]=t.y);else{if(hs(r,t))return;e.uniform2fv(this.addr,t),Ca(r,t)}}function lmr(e,t){let r=this.cache;if(t.x!==void 0)(r[0]!==t.x||r[1]!==t.y||r[2]!==t.z)&&(e.uniform3f(this.addr,t.x,t.y,t.z),r[0]=t.x,r[1]=t.y,r[2]=t.z);else if(t.r!==void 0)(r[0]!==t.r||r[1]!==t.g||r[2]!==t.b)&&(e.uniform3f(this.addr,t.r,t.g,t.b),r[0]=t.r,r[1]=t.g,r[2]=t.b);else{if(hs(r,t))return;e.uniform3fv(this.addr,t),Ca(r,t)}}function cmr(e,t){let r=this.cache;if(t.x!==void 0)(r[0]!==t.x||r[1]!==t.y||r[2]!==t.z||r[3]!==t.w)&&(e.uniform4f(this.addr,t.x,t.y,t.z,t.w),r[0]=t.x,r[1]=t.y,r[2]=t.z,r[3]=t.w);else{if(hs(r,t))return;e.uniform4fv(this.addr,t),Ca(r,t)}}function umr(e,t){let r=this.cache,n=t.elements;if(n===void 0){if(hs(r,t))return;e.uniformMatrix2fv(this.addr,!1,t),Ca(r,t)}else{if(hs(r,n))return;Due.set(n),e.uniformMatrix2fv(this.addr,!1,Due),Ca(r,n)}}function hmr(e,t){let r=this.cache,n=t.elements;if(n===void 0){if(hs(r,t))return;e.uniformMatrix3fv(this.addr,!1,t),Ca(r,t)}else{if(hs(r,n))return;Nue.set(n),e.uniformMatrix3fv(this.addr,!1,Nue),Ca(r,n)}}function fmr(e,t){let r=this.cache,n=t.elements;if(n===void 0){if(hs(r,t))return;e.uniformMatrix4fv(this.addr,!1,t),Ca(r,t)}else{if(hs(r,n))return;Rue.set(n),e.uniformMatrix4fv(this.addr,!1,Rue),Ca(r,n)}}function pmr(e,t){let r=this.cache;r[0]!==t&&(e.uniform1i(this.addr,t),r[0]=t)}function dmr(e,t){let r=this.cache;hs(r,t)||(e.uniform2iv(this.addr,t),Ca(r,t))}function mmr(e,t){let r=this.cache;hs(r,t)||(e.uniform3iv(this.addr,t),Ca(r,t))}function gmr(e,t){let r=this.cache;hs(r,t)||(e.uniform4iv(this.addr,t),Ca(r,t))}function _mr(e,t){let r=this.cache;r[0]!==t&&(e.uniform1ui(this.addr,t),r[0]=t)}function ymr(e,t){let r=this.cache;hs(r,t)||(e.uniform2uiv(this.addr,t),Ca(r,t))}function vmr(e,t){let r=this.cache;hs(r,t)||(e.uniform3uiv(this.addr,t),Ca(r,t))}function xmr(e,t){let r=this.cache;hs(r,t)||(e.uniform4uiv(this.addr,t),Ca(r,t))}function bmr(e,t,r){let n=this.cache,i=r.allocateTextureUnit();n[0]!==i&&(e.uniform1i(this.addr,i),n[0]=i),r.safeSetTexture2D(t||Hfe,i)}function wmr(e,t,r){let n=this.cache,i=r.allocateTextureUnit();n[0]!==i&&(e.uniform1i(this.addr,i),n[0]=i),r.setTexture3D(t||Ufe,i)}function Smr(e,t,r){let n=this.cache,i=r.allocateTextureUnit();n[0]!==i&&(e.uniform1i(this.addr,i),n[0]=i),r.safeSetTextureCube(t||qfe,i)}function Mmr(e,t,r){let n=this.cache,i=r.allocateTextureUnit();n[0]!==i&&(e.uniform1i(this.addr,i),n[0]=i),r.setTexture2DArray(t||Vfe,i)}function Emr(e){switch(e){case 5126:return amr;case 35664:return smr;case 35665:return lmr;case 35666:return cmr;case 35674:return umr;case 35675:return hmr;case 35676:return fmr;case 5124:case 35670:return pmr;case 35667:case 35671:return dmr;case 35668:case 35672:return mmr;case 35669:case 35673:return gmr;case 5125:return _mr;case 36294:return ymr;case 36295:return vmr;case 36296:return xmr;case 35678:case 36198:case 36298:case 36306:case 35682:return bmr;case 35679:case 36299:case 36307:return wmr;case 35680:case 36300:case 36308:case 36293:return Smr;case 36289:case 36303:case 36311:case 36292:return Mmr}}function Tmr(e,t){e.uniform1fv(this.addr,t)}function Cmr(e,t){let r=bM(t,this.size,2);e.uniform2fv(this.addr,r)}function Amr(e,t){let r=bM(t,this.size,3);e.uniform3fv(this.addr,r)}function Pmr(e,t){let r=bM(t,this.size,4);e.uniform4fv(this.addr,r)}function Imr(e,t){let r=bM(t,this.size,4);e.uniformMatrix2fv(this.addr,!1,r)}function Lmr(e,t){let r=bM(t,this.size,9);e.uniformMatrix3fv(this.addr,!1,r)}function kmr(e,t){let r=bM(t,this.size,16);e.uniformMatrix4fv(this.addr,!1,r)}function Rmr(e,t){e.uniform1iv(this.addr,t)}function Nmr(e,t){e.uniform2iv(this.addr,t)}function Dmr(e,t){e.uniform3iv(this.addr,t)}function Omr(e,t){e.uniform4iv(this.addr,t)}function zmr(e,t){e.uniform1uiv(this.addr,t)}function Fmr(e,t){e.uniform2uiv(this.addr,t)}function Bmr(e,t){e.uniform3uiv(this.addr,t)}function Hmr(e,t){e.uniform4uiv(this.addr,t)}function Vmr(e,t,r){let n=t.length,i=$U(r,n);e.uniform1iv(this.addr,i);for(let o=0;o!==n;++o)r.safeSetTexture2D(t[o]||Hfe,i[o])}function Umr(e,t,r){let n=t.length,i=$U(r,n);e.uniform1iv(this.addr,i);for(let o=0;o!==n;++o)r.setTexture3D(t[o]||Ufe,i[o])}function qmr(e,t,r){let n=t.length,i=$U(r,n);e.uniform1iv(this.addr,i);for(let o=0;o!==n;++o)r.safeSetTextureCube(t[o]||qfe,i[o])}function Gmr(e,t,r){let n=t.length,i=$U(r,n);e.uniform1iv(this.addr,i);for(let o=0;o!==n;++o)r.setTexture2DArray(t[o]||Vfe,i[o])}function Wmr(e){switch(e){case 5126:return Tmr;case 35664:return Cmr;case 35665:return Amr;case 35666:return Pmr;case 35674:return Imr;case 35675:return Lmr;case 35676:return kmr;case 5124:case 35670:return Rmr;case 35667:case 35671:return Nmr;case 35668:case 35672:return Dmr;case 35669:case 35673:return Omr;case 5125:return zmr;case 36294:return Fmr;case 36295:return Bmr;case 36296:return Hmr;case 35678:case 36198:case 36298:case 36306:case 35682:return Vmr;case 35679:case 36299:case 36307:return Umr;case 35680:case 36300:case 36308:case 36293:return qmr;case 36289:case 36303:case 36311:case 36292:return Gmr}}function Ymr(e,t,r){this.id=e,this.addr=r,this.cache=[],this.setValue=Emr(t.type)}function Gfe(e,t,r){this.id=e,this.addr=r,this.cache=[],this.size=t.size,this.setValue=Wmr(t.type)}Gfe.prototype.updateCache=function(e){let t=this.cache;e instanceof Float32Array&&t.length!==e.length&&(this.cache=new Float32Array(e.length)),Ca(t,e)};function Wfe(e){this.id=e,this.seq=[],this.map={}}Wfe.prototype.setValue=function(e,t,r){let n=this.seq;for(let i=0,o=n.length;i!==o;++i){let a=n[i];a.setValue(e,t[a.id],r)}};var dut=/(\w+)(\])?(\[|\.)?/g;function Oue(e,t){e.seq.push(t),e.map[t.id]=t}function jmr(e,t,r){let n=e.name,i=n.length;for(dut.lastIndex=0;;){let o=dut.exec(n),a=dut.lastIndex,s=o[1],l=o[2]==="]",c=o[3];if(l&&(s=s|0),c===void 0||c==="["&&a+2===i){Oue(r,c===void 0?new Ymr(s,e,t):new Gfe(s,e,t));break}else{let h=r.map[s];h===void 0&&(h=new Wfe(s),Oue(r,h)),r=h}}}function B0(e,t){this.seq=[],this.map={};let r=e.getProgramParameter(t,35718);for(let n=0;n<r;++n){let i=e.getActiveUniform(t,n),o=e.getUniformLocation(t,i.name);jmr(i,o,this)}}B0.prototype.setValue=function(e,t,r,n){let i=this.map[t];i!==void 0&&i.setValue(e,r,n)};B0.prototype.setOptional=function(e,t,r){let n=t[r];n!==void 0&&this.setValue(e,r,n)};B0.upload=function(e,t,r,n){for(let i=0,o=t.length;i!==o;++i){let a=t[i],s=r[a.id];s.needsUpdate!==!1&&a.setValue(e,s.value,n)}};B0.seqWithValue=function(e,t){let r=[];for(let n=0,i=e.length;n!==i;++n){let o=e[n];o.id in t&&r.push(o)}return r};function zue(e,t,r){let n=e.createShader(t);return e.shaderSource(n,r),e.compileShader(n),n}var Xmr=0;function $mr(e){let t=e.split(`
`);for(let r=0;r<t.length;r++)t[r]=r+1+": "+t[r];return t.join(`
`)}function Kmr(e){switch(e){case Qd:return["Linear","( value )"];case Yn:return["sRGB","( value )"];default:return console.warn("THREE.WebGLProgram: Unsupported encoding:",e),["Linear","( value )"]}}function Fue(e,t,r){let n=e.getShaderParameter(t,35713),i=e.getShaderInfoLog(t).trim();return n&&i===""?"":r.toUpperCase()+`

`+i+`

`+$mr(e.getShaderSource(t))}function Zmr(e,t){let r=Kmr(t);return"vec4 "+e+"( vec4 value ) { return LinearTo"+r[0]+r[1]+"; }"}function Jmr(e,t){let r;switch(t){case ofe:r="Linear";break;case afe:r="Reinhard";break;case sfe:r="OptimizedCineon";break;case lfe:r="ACESFilmic";break;case cfe:r="Custom";break;default:console.warn("THREE.WebGLProgram: Unsupported toneMapping:",t),r="Linear"}return"vec3 "+e+"( vec3 color ) { return "+r+"ToneMapping( color ); }"}function Qmr(e){return[e.extensionDerivatives||e.envMapCubeUV||e.bumpMap||e.tangentSpaceNormalMap||e.clearcoatNormalMap||e.flatShading||e.shaderID==="physical"?"#extension GL_OES_standard_derivatives : enable":"",(e.extensionFragDepth||e.logarithmicDepthBuffer)&&e.rendererExtensionFragDepth?"#extension GL_EXT_frag_depth : enable":"",e.extensionDrawBuffers&&e.rendererExtensionDrawBuffers?"#extension GL_EXT_draw_buffers : require":"",(e.extensionShaderTextureLOD||e.envMap||e.transmission)&&e.rendererExtensionShaderTextureLod?"#extension GL_EXT_shader_texture_lod : enable":""].filter(BP).join(`
`)}function tgr(e){let t=[];for(let r in e){let n=e[r];n!==!1&&t.push("#define "+r+" "+n)}return t.join(`
`)}function egr(e,t){let r={},n=e.getProgramParameter(t,35721);for(let i=0;i<n;i++){let o=e.getActiveAttrib(t,i),a=o.name,s=1;o.type===35674&&(s=2),o.type===35675&&(s=3),o.type===35676&&(s=4),r[a]={type:o.type,location:e.getAttribLocation(t,a),locationSize:s}}return r}function BP(e){return e!==""}function Bue(e,t){return e.replace(/NUM_DIR_LIGHTS/g,t.numDirLights).replace(/NUM_SPOT_LIGHTS/g,t.numSpotLights).replace(/NUM_RECT_AREA_LIGHTS/g,t.numRectAreaLights).replace(/NUM_POINT_LIGHTS/g,t.numPointLights).replace(/NUM_HEMI_LIGHTS/g,t.numHemiLights).replace(/NUM_DIR_LIGHT_SHADOWS/g,t.numDirLightShadows).replace(/NUM_SPOT_LIGHT_SHADOWS/g,t.numSpotLightShadows).replace(/NUM_POINT_LIGHT_SHADOWS/g,t.numPointLightShadows)}function Hue(e,t){return e.replace(/NUM_CLIPPING_PLANES/g,t.numClippingPlanes).replace(/UNION_CLIPPING_PLANES/g,t.numClippingPlanes-t.numClipIntersection)}var rgr=/^[ \t]*#include +<([\w\d./]+)>/gm;function Qut(e){return e.replace(rgr,ngr)}function ngr(e,t){let r=hr[t];if(r===void 0)throw new Error("Can not resolve #include <"+t+">");return Qut(r)}var igr=/#pragma unroll_loop[\s]+?for \( int i \= (\d+)\; i < (\d+)\; i \+\+ \) \{([\s\S]+?)(?=\})\}/g,ogr=/#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*i\s*\+\+\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;function Vue(e){return e.replace(ogr,Yfe).replace(igr,agr)}function agr(e,t,r,n){return console.warn("WebGLProgram: #pragma unroll_loop shader syntax is deprecated. Please use #pragma unroll_loop_start syntax instead."),Yfe(e,t,r,n)}function Yfe(e,t,r,n){let i="";for(let o=parseInt(t);o<parseInt(r);o++)i+=n.replace(/\[\s*i\s*\]/g,"[ "+o+" ]").replace(/UNROLLED_LOOP_INDEX/g,o);return i}function Uue(e){let t="precision "+e.precision+` float;
precision `+e.precision+" int;";return e.precision==="highp"?t+=`
#define HIGH_PRECISION`:e.precision==="mediump"?t+=`
#define MEDIUM_PRECISION`:e.precision==="lowp"&&(t+=`
#define LOW_PRECISION`),t}function sgr(e){let t="SHADOWMAP_TYPE_BASIC";return e.shadowMapType===Aht?t="SHADOWMAP_TYPE_PCF":e.shadowMapType===zhe?t="SHADOWMAP_TYPE_PCF_SOFT":e.shadowMapType===F3&&(t="SHADOWMAP_TYPE_VSM"),t}function lgr(e){let t="ENVMAP_TYPE_CUBE";if(e.envMap)switch(e.envMapMode){case nx:case ix:t="ENVMAP_TYPE_CUBE";break;case xM:case O6:t="ENVMAP_TYPE_CUBE_UV";break}return t}function cgr(e){let t="ENVMAP_MODE_REFLECTION";if(e.envMap)switch(e.envMapMode){case ix:case O6:t="ENVMAP_MODE_REFRACTION";break}return t}function ugr(e){let t="ENVMAP_BLENDING_NONE";if(e.envMap)switch(e.combine){case D6:t="ENVMAP_BLENDING_MULTIPLY";break;case nfe:t="ENVMAP_BLENDING_MIX";break;case ife:t="ENVMAP_BLENDING_ADD";break}return t}function hgr(e,t,r,n){let i=e.getContext(),o=r.defines,a=r.vertexShader,s=r.fragmentShader,l=sgr(r),c=lgr(r),u=cgr(r),h=ugr(r),f=r.isWebGL2?"":Qmr(r),p=tgr(o),d=i.createProgram(),g,_,y=r.glslVersion?"#version "+r.glslVersion+`
`:"";r.isRawShaderMaterial?(g=[p].filter(BP).join(`
`),g.length>0&&(g+=`
`),_=[f,p].filter(BP).join(`
`),_.length>0&&(_+=`
`)):(g=[Uue(r),"#define SHADER_NAME "+r.shaderName,p,r.instancing?"#define USE_INSTANCING":"",r.instancingColor?"#define USE_INSTANCING_COLOR":"",r.supportsVertexTextures?"#define VERTEX_TEXTURES":"","#define MAX_BONES "+r.maxBones,r.useFog&&r.fog?"#define USE_FOG":"",r.useFog&&r.fogExp2?"#define FOG_EXP2":"",r.map?"#define USE_MAP":"",r.envMap?"#define USE_ENVMAP":"",r.envMap?"#define "+u:"",r.lightMap?"#define USE_LIGHTMAP":"",r.aoMap?"#define USE_AOMAP":"",r.emissiveMap?"#define USE_EMISSIVEMAP":"",r.bumpMap?"#define USE_BUMPMAP":"",r.normalMap?"#define USE_NORMALMAP":"",r.normalMap&&r.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",r.normalMap&&r.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",r.clearcoatMap?"#define USE_CLEARCOATMAP":"",r.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",r.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",r.displacementMap&&r.supportsVertexTextures?"#define USE_DISPLACEMENTMAP":"",r.specularMap?"#define USE_SPECULARMAP":"",r.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",r.specularColorMap?"#define USE_SPECULARCOLORMAP":"",r.roughnessMap?"#define USE_ROUGHNESSMAP":"",r.metalnessMap?"#define USE_METALNESSMAP":"",r.alphaMap?"#define USE_ALPHAMAP":"",r.transmission?"#define USE_TRANSMISSION":"",r.transmissionMap?"#define USE_TRANSMISSIONMAP":"",r.thicknessMap?"#define USE_THICKNESSMAP":"",r.sheenColorMap?"#define USE_SHEENCOLORMAP":"",r.sheenRoughnessMap?"#define USE_SHEENROUGHNESSMAP":"",r.vertexTangents?"#define USE_TANGENT":"",r.vertexColors?"#define USE_COLOR":"",r.vertexAlphas?"#define USE_COLOR_ALPHA":"",r.vertexUvs?"#define USE_UV":"",r.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",r.flatShading?"#define FLAT_SHADED":"",r.skinning?"#define USE_SKINNING":"",r.useVertexTexture?"#define BONE_TEXTURE":"",r.morphTargets?"#define USE_MORPHTARGETS":"",r.morphNormals&&r.flatShading===!1?"#define USE_MORPHNORMALS":"",r.morphTargets&&r.isWebGL2?"#define MORPHTARGETS_TEXTURE":"",r.morphTargets&&r.isWebGL2?"#define MORPHTARGETS_COUNT "+r.morphTargetsCount:"",r.doubleSided?"#define DOUBLE_SIDED":"",r.flipSided?"#define FLIP_SIDED":"",r.shadowMapEnabled?"#define USE_SHADOWMAP":"",r.shadowMapEnabled?"#define "+l:"",r.sizeAttenuation?"#define USE_SIZEATTENUATION":"",r.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",r.logarithmicDepthBuffer&&r.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"","uniform mat4 modelMatrix;","uniform mat4 modelViewMatrix;","uniform mat4 projectionMatrix;","uniform mat4 viewMatrix;","uniform mat3 normalMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;","#ifdef USE_INSTANCING","	attribute mat4 instanceMatrix;","#endif","#ifdef USE_INSTANCING_COLOR","	attribute vec3 instanceColor;","#endif","attribute vec3 position;","attribute vec3 normal;","attribute vec2 uv;","#ifdef USE_TANGENT","	attribute vec4 tangent;","#endif","#if defined( USE_COLOR_ALPHA )","	attribute vec4 color;","#elif defined( USE_COLOR )","	attribute vec3 color;","#endif","#if ( defined( USE_MORPHTARGETS ) && ! defined( MORPHTARGETS_TEXTURE ) )","	attribute vec3 morphTarget0;","	attribute vec3 morphTarget1;","	attribute vec3 morphTarget2;","	attribute vec3 morphTarget3;","	#ifdef USE_MORPHNORMALS","		attribute vec3 morphNormal0;","		attribute vec3 morphNormal1;","		attribute vec3 morphNormal2;","		attribute vec3 morphNormal3;","	#else","		attribute vec3 morphTarget4;","		attribute vec3 morphTarget5;","		attribute vec3 morphTarget6;","		attribute vec3 morphTarget7;","	#endif","#endif","#ifdef USE_SKINNING","	attribute vec4 skinIndex;","	attribute vec4 skinWeight;","#endif",`
`].filter(BP).join(`
`),_=[f,Uue(r),"#define SHADER_NAME "+r.shaderName,p,r.useFog&&r.fog?"#define USE_FOG":"",r.useFog&&r.fogExp2?"#define FOG_EXP2":"",r.map?"#define USE_MAP":"",r.matcap?"#define USE_MATCAP":"",r.envMap?"#define USE_ENVMAP":"",r.envMap?"#define "+c:"",r.envMap?"#define "+u:"",r.envMap?"#define "+h:"",r.lightMap?"#define USE_LIGHTMAP":"",r.aoMap?"#define USE_AOMAP":"",r.emissiveMap?"#define USE_EMISSIVEMAP":"",r.bumpMap?"#define USE_BUMPMAP":"",r.normalMap?"#define USE_NORMALMAP":"",r.normalMap&&r.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",r.normalMap&&r.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",r.clearcoat?"#define USE_CLEARCOAT":"",r.clearcoatMap?"#define USE_CLEARCOATMAP":"",r.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",r.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",r.specularMap?"#define USE_SPECULARMAP":"",r.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",r.specularColorMap?"#define USE_SPECULARCOLORMAP":"",r.roughnessMap?"#define USE_ROUGHNESSMAP":"",r.metalnessMap?"#define USE_METALNESSMAP":"",r.alphaMap?"#define USE_ALPHAMAP":"",r.alphaTest?"#define USE_ALPHATEST":"",r.sheen?"#define USE_SHEEN":"",r.sheenColorMap?"#define USE_SHEENCOLORMAP":"",r.sheenRoughnessMap?"#define USE_SHEENROUGHNESSMAP":"",r.transmission?"#define USE_TRANSMISSION":"",r.transmissionMap?"#define USE_TRANSMISSIONMAP":"",r.thicknessMap?"#define USE_THICKNESSMAP":"",r.decodeVideoTexture?"#define DECODE_VIDEO_TEXTURE":"",r.vertexTangents?"#define USE_TANGENT":"",r.vertexColors||r.instancingColor?"#define USE_COLOR":"",r.vertexAlphas?"#define USE_COLOR_ALPHA":"",r.vertexUvs?"#define USE_UV":"",r.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",r.gradientMap?"#define USE_GRADIENTMAP":"",r.flatShading?"#define FLAT_SHADED":"",r.doubleSided?"#define DOUBLE_SIDED":"",r.flipSided?"#define FLIP_SIDED":"",r.shadowMapEnabled?"#define USE_SHADOWMAP":"",r.shadowMapEnabled?"#define "+l:"",r.premultipliedAlpha?"#define PREMULTIPLIED_ALPHA":"",r.physicallyCorrectLights?"#define PHYSICALLY_CORRECT_LIGHTS":"",r.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",r.logarithmicDepthBuffer&&r.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"",(r.extensionShaderTextureLOD||r.envMap)&&r.rendererExtensionShaderTextureLod?"#define TEXTURE_LOD_EXT":"","uniform mat4 viewMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;",r.toneMapping!==Kd?"#define TONE_MAPPING":"",r.toneMapping!==Kd?hr.tonemapping_pars_fragment:"",r.toneMapping!==Kd?Jmr("toneMapping",r.toneMapping):"",r.dithering?"#define DITHERING":"",r.alphaWrite?"":"#define OPAQUE",hr.encodings_pars_fragment,Zmr("linearToOutputTexel",r.outputEncoding),r.depthPacking?"#define DEPTH_PACKING "+r.depthPacking:"",`
`].filter(BP).join(`
`)),a=Qut(a),a=Bue(a,r),a=Hue(a,r),s=Qut(s),s=Bue(s,r),s=Hue(s,r),a=Vue(a),s=Vue(s),r.isWebGL2&&r.isRawShaderMaterial!==!0&&(y=`#version 300 es
`,g=["precision mediump sampler2DArray;","#define attribute in","#define varying out","#define texture2D texture"].join(`
`)+`
`+g,_=["#define varying in",r.glslVersion===Zut?"":"layout(location = 0) out highp vec4 pc_fragColor;",r.glslVersion===Zut?"":"#define gl_FragColor pc_fragColor","#define gl_FragDepthEXT gl_FragDepth","#define texture2D texture","#define textureCube texture","#define texture2DProj textureProj","#define texture2DLodEXT textureLod","#define texture2DProjLodEXT textureProjLod","#define textureCubeLodEXT textureLod","#define texture2DGradEXT textureGrad","#define texture2DProjGradEXT textureProjGrad","#define textureCubeGradEXT textureGrad"].join(`
`)+`
`+_);let x=y+g+a,b=y+_+s,S=zue(i,35633,x),C=zue(i,35632,b);if(i.attachShader(d,S),i.attachShader(d,C),r.index0AttributeName!==void 0?i.bindAttribLocation(d,0,r.index0AttributeName):r.morphTargets===!0&&i.bindAttribLocation(d,0,"position"),i.linkProgram(d),e.debug.checkShaderErrors){let O=i.getProgramInfoLog(d).trim(),D=i.getShaderInfoLog(S).trim(),B=i.getShaderInfoLog(C).trim(),I=!0,L=!0;if(i.getProgramParameter(d,35714)===!1){I=!1;let R=Fue(i,S,"vertex"),F=Fue(i,C,"fragment");console.error("THREE.WebGLProgram: Shader Error "+i.getError()+" - VALIDATE_STATUS "+i.getProgramParameter(d,35715)+`

Program Info Log: `+O+`
`+R+`
`+F)}else O!==""?console.warn("THREE.WebGLProgram: Program Info Log:",O):(D===""||B==="")&&(L=!1);L&&(this.diagnostics={runnable:I,programLog:O,vertexShader:{log:D,prefix:g},fragmentShader:{log:B,prefix:_}})}i.deleteShader(S),i.deleteShader(C);let P;this.getUniforms=function(){return P===void 0&&(P=new B0(i,d)),P};let k;return this.getAttributes=function(){return k===void 0&&(k=egr(i,d)),k},this.destroy=function(){n.releaseStatesOfProgram(this),i.deleteProgram(d),this.program=void 0},this.name=r.shaderName,this.id=Xmr++,this.cacheKey=t,this.usedTimes=1,this.program=d,this.vertexShader=S,this.fragmentShader=C,this}var fgr=0,tht=class{constructor(){this.shaderCache=new Map,this.materialCache=new Map}update(t){let r=t.vertexShader,n=t.fragmentShader,i=this._getShaderStage(r),o=this._getShaderStage(n),a=this._getShaderCacheForMaterial(t);return a.has(i)===!1&&(a.add(i),i.usedTimes++),a.has(o)===!1&&(a.add(o),o.usedTimes++),this}remove(t){let r=this.materialCache.get(t);for(let n of r)n.usedTimes--,n.usedTimes===0&&this.shaderCache.delete(n);return this.materialCache.delete(t),this}getVertexShaderID(t){return this._getShaderStage(t.vertexShader).id}getFragmentShaderID(t){return this._getShaderStage(t.fragmentShader).id}dispose(){this.shaderCache.clear(),this.materialCache.clear()}_getShaderCacheForMaterial(t){let r=this.materialCache;return r.has(t)===!1&&r.set(t,new Set),r.get(t)}_getShaderStage(t){let r=this.shaderCache;if(r.has(t)===!1){let n=new eht;r.set(t,n)}return r.get(t)}},eht=class{constructor(){this.id=fgr++,this.usedTimes=0}};function pgr(e,t,r,n,i,o,a){let s=new X3,l=new tht,c=[],u=i.isWebGL2,h=i.logarithmicDepthBuffer,f=i.floatVertexTextures,p=i.maxVertexUniforms,d=i.vertexTextures,g=i.precision,_={MeshDepthMaterial:"depth",MeshDistanceMaterial:"distanceRGBA",MeshNormalMaterial:"normal",MeshBasicMaterial:"basic",MeshLambertMaterial:"lambert",MeshPhongMaterial:"phong",MeshToonMaterial:"toon",MeshStandardMaterial:"physical",MeshPhysicalMaterial:"physical",MeshMatcapMaterial:"matcap",LineBasicMaterial:"basic",LineDashedMaterial:"dashed",PointsMaterial:"points",ShadowMaterial:"shadow",SpriteMaterial:"sprite"};function y(I){let R=I.skeleton.bones;if(f)return 1024;{let z=Math.floor((p-20)/4),U=Math.min(z,R.length);return U<R.length?(console.warn("THREE.WebGLRenderer: Skeleton has "+R.length+" bones. This GPU supports "+U+"."),0):U}}function x(I,L,R,F,z){let U=F.fog,W=I.isMeshStandardMaterial?F.environment:null,Z=(I.isMeshStandardMaterial?r:t).get(I.envMap||W),rt=_[I.type],ot=z.isSkinnedMesh?y(z):0;I.precision!==null&&(g=i.getMaxPrecision(I.precision),g!==I.precision&&console.warn("THREE.WebGLProgram.getParameters:",I.precision,"not supported, using",g,"instead."));let st,St,bt,Mt;if(rt){let X=ah[rt];st=X.vertexShader,St=X.fragmentShader}else st=I.vertexShader,St=I.fragmentShader,l.update(I),bt=l.getVertexShaderID(I),Mt=l.getFragmentShaderID(I);let lt=e.getRenderTarget(),Kt=I.alphaTest>0,_t=I.clearcoat>0;return{isWebGL2:u,shaderID:rt,shaderName:I.type,vertexShader:st,fragmentShader:St,defines:I.defines,customVertexShaderID:bt,customFragmentShaderID:Mt,isRawShaderMaterial:I.isRawShaderMaterial===!0,glslVersion:I.glslVersion,precision:g,instancing:z.isInstancedMesh===!0,instancingColor:z.isInstancedMesh===!0&&z.instanceColor!==null,supportsVertexTextures:d,outputEncoding:lt===null?e.outputEncoding:lt.isXRRenderTarget===!0?lt.texture.encoding:Qd,map:!!I.map,matcap:!!I.matcap,envMap:!!Z,envMapMode:Z&&Z.mapping,envMapCubeUV:!!Z&&(Z.mapping===xM||Z.mapping===O6),lightMap:!!I.lightMap,aoMap:!!I.aoMap,emissiveMap:!!I.emissiveMap,bumpMap:!!I.bumpMap,normalMap:!!I.normalMap,objectSpaceNormalMap:I.normalMapType===Ife,tangentSpaceNormalMap:I.normalMapType===ax,decodeVideoTexture:!!I.map&&I.map.isVideoTexture===!0&&I.map.encoding===Yn,clearcoat:_t,clearcoatMap:_t&&!!I.clearcoatMap,clearcoatRoughnessMap:_t&&!!I.clearcoatRoughnessMap,clearcoatNormalMap:_t&&!!I.clearcoatNormalMap,displacementMap:!!I.displacementMap,roughnessMap:!!I.roughnessMap,metalnessMap:!!I.metalnessMap,specularMap:!!I.specularMap,specularIntensityMap:!!I.specularIntensityMap,specularColorMap:!!I.specularColorMap,alphaMap:!!I.alphaMap,alphaTest:Kt,alphaWrite:I.alphaWrite||I.transparent,gradientMap:!!I.gradientMap,sheen:I.sheen>0,sheenColorMap:!!I.sheenColorMap,sheenRoughnessMap:!!I.sheenRoughnessMap,transmission:I.transmission>0,transmissionMap:!!I.transmissionMap,thicknessMap:!!I.thicknessMap,combine:I.combine,vertexTangents:!!I.normalMap&&!!z.geometry&&!!z.geometry.attributes.tangent,vertexColors:I.vertexColors,vertexAlphas:I.vertexColors===!0&&!!z.geometry&&!!z.geometry.attributes.color&&z.geometry.attributes.color.itemSize===4,vertexUvs:!!I.map||!!I.bumpMap||!!I.normalMap||!!I.specularMap||!!I.alphaMap||!!I.emissiveMap||!!I.roughnessMap||!!I.metalnessMap||!!I.clearcoatMap||!!I.clearcoatRoughnessMap||!!I.clearcoatNormalMap||!!I.displacementMap||!!I.transmissionMap||!!I.thicknessMap||!!I.specularIntensityMap||!!I.specularColorMap||!!I.sheenColorMap||!!I.sheenRoughnessMap,uvsVertexOnly:!(!!I.map||!!I.bumpMap||!!I.normalMap||!!I.specularMap||!!I.alphaMap||!!I.emissiveMap||!!I.roughnessMap||!!I.metalnessMap||!!I.clearcoatNormalMap||I.transmission>0||!!I.transmissionMap||!!I.thicknessMap||!!I.specularIntensityMap||!!I.specularColorMap||I.sheen>0||!!I.sheenColorMap||!!I.sheenRoughnessMap)&&!!I.displacementMap,fog:!!U,useFog:I.fog,fogExp2:U&&U.isFogExp2,flatShading:!!I.flatShading,sizeAttenuation:I.sizeAttenuation,logarithmicDepthBuffer:h,skinning:z.isSkinnedMesh===!0&&ot>0,maxBones:ot,useVertexTexture:f,morphTargets:!!z.geometry&&!!z.geometry.morphAttributes.position,morphNormals:!!z.geometry&&!!z.geometry.morphAttributes.normal,morphTargetsCount:!!z.geometry&&!!z.geometry.morphAttributes.position?z.geometry.morphAttributes.position.length:0,numDirLights:L.directional.length,numPointLights:L.point.length,numSpotLights:L.spot.length,numRectAreaLights:L.rectArea.length,numHemiLights:L.hemi.length,numDirLightShadows:L.directionalShadowMap.length,numPointLightShadows:L.pointShadowMap.length,numSpotLightShadows:L.spotShadowMap.length,numClippingPlanes:a.numPlanes,numClipIntersection:a.numIntersection,dithering:I.dithering,shadowMapEnabled:e.shadowMap.enabled&&R.length>0,shadowMapType:e.shadowMap.type,toneMapping:I.toneMapped?e.toneMapping:Kd,physicallyCorrectLights:e.physicallyCorrectLights,premultipliedAlpha:I.premultipliedAlpha,doubleSided:I.side===Lv,flipSided:I.side===Ii,depthPacking:I.depthPacking!==void 0?I.depthPacking:!1,index0AttributeName:I.index0AttributeName,extensionDerivatives:I.extensions&&I.extensions.derivatives,extensionFragDepth:I.extensions&&I.extensions.fragDepth,extensionDrawBuffers:I.extensions&&I.extensions.drawBuffers,extensionShaderTextureLOD:I.extensions&&I.extensions.shaderTextureLOD,rendererExtensionFragDepth:u||n.has("EXT_frag_depth"),rendererExtensionDrawBuffers:u||n.has("WEBGL_draw_buffers"),rendererExtensionShaderTextureLod:u||n.has("EXT_shader_texture_lod"),customProgramCacheKey:I.customProgramCacheKey()}}function b(I){let L=[];if(I.shaderID?L.push(I.shaderID):(L.push(I.customVertexShaderID),L.push(I.customFragmentShaderID)),I.defines!==void 0)for(let R in I.defines)L.push(R),L.push(I.defines[R]);return I.isRawShaderMaterial===!1&&(S(L,I),C(L,I),L.push(e.outputEncoding)),L.push(I.customProgramCacheKey),L.join()}function S(I,L){I.push(L.precision),I.push(L.outputEncoding),I.push(L.envMapMode),I.push(L.combine),I.push(L.vertexUvs),I.push(L.fogExp2),I.push(L.sizeAttenuation),I.push(L.maxBones),I.push(L.morphTargetsCount),I.push(L.numDirLights),I.push(L.numPointLights),I.push(L.numSpotLights),I.push(L.numHemiLights),I.push(L.numRectAreaLights),I.push(L.numDirLightShadows),I.push(L.numPointLightShadows),I.push(L.numSpotLightShadows),I.push(L.shadowMapType),I.push(L.toneMapping),I.push(L.numClippingPlanes),I.push(L.numClipIntersection),I.push(L.alphaWrite)}function C(I,L){s.disableAll(),L.isWebGL2&&s.enable(0),L.supportsVertexTextures&&s.enable(1),L.instancing&&s.enable(2),L.instancingColor&&s.enable(3),L.map&&s.enable(4),L.matcap&&s.enable(5),L.envMap&&s.enable(6),L.envMapCubeUV&&s.enable(7),L.lightMap&&s.enable(8),L.aoMap&&s.enable(9),L.emissiveMap&&s.enable(10),L.bumpMap&&s.enable(11),L.normalMap&&s.enable(12),L.objectSpaceNormalMap&&s.enable(13),L.tangentSpaceNormalMap&&s.enable(14),L.clearcoat&&s.enable(15),L.clearcoatMap&&s.enable(16),L.clearcoatRoughnessMap&&s.enable(17),L.clearcoatNormalMap&&s.enable(18),L.displacementMap&&s.enable(19),L.specularMap&&s.enable(20),L.roughnessMap&&s.enable(21),L.metalnessMap&&s.enable(22),L.gradientMap&&s.enable(23),L.alphaMap&&s.enable(24),L.alphaTest&&s.enable(25),L.vertexColors&&s.enable(26),L.vertexAlphas&&s.enable(27),L.vertexUvs&&s.enable(28),L.vertexTangents&&s.enable(29),L.uvsVertexOnly&&s.enable(30),L.fog&&s.enable(31),I.push(s.mask),s.disableAll(),L.useFog&&s.enable(0),L.flatShading&&s.enable(1),L.logarithmicDepthBuffer&&s.enable(2),L.skinning&&s.enable(3),L.useVertexTexture&&s.enable(4),L.morphTargets&&s.enable(5),L.morphNormals&&s.enable(6),L.premultipliedAlpha&&s.enable(7),L.shadowMapEnabled&&s.enable(8),L.physicallyCorrectLights&&s.enable(9),L.doubleSided&&s.enable(10),L.flipSided&&s.enable(11),L.depthPacking&&s.enable(12),L.dithering&&s.enable(13),L.specularIntensityMap&&s.enable(14),L.specularColorMap&&s.enable(15),L.transmission&&s.enable(16),L.transmissionMap&&s.enable(17),L.thicknessMap&&s.enable(18),L.sheen&&s.enable(19),L.sheenColorMap&&s.enable(20),L.sheenRoughnessMap&&s.enable(21),L.decodeVideoTexture&&s.enable(22),I.push(s.mask)}function P(I){let L=_[I.type],R;if(L){let F=ah[L];R=Ofe.clone(F.uniforms)}else R=I.uniforms;return R}function k(I,L){let R;for(let F=0,z=c.length;F<z;F++){let U=c[F];if(U.cacheKey===L){R=U,++R.usedTimes;break}}return R===void 0&&(R=new hgr(e,L,I,o),c.push(R)),R}function O(I){if(--I.usedTimes===0){let L=c.indexOf(I);c[L]=c[c.length-1],c.pop(),I.destroy()}}function D(I){l.remove(I)}function B(){l.dispose()}return{getParameters:x,getProgramCacheKey:b,getUniforms:P,acquireProgram:k,releaseProgram:O,releaseShaderCache:D,programs:c,dispose:B}}function dgr(){let e=new WeakMap;function t(o){let a=e.get(o);return a===void 0&&(a={},e.set(o,a)),a}function r(o){e.delete(o)}function n(o,a,s){e.get(o)[a]=s}function i(){e=new WeakMap}return{get:t,remove:r,update:n,dispose:i}}function mgr(e,t){return e.groupOrder!==t.groupOrder?e.groupOrder-t.groupOrder:e.renderOrder!==t.renderOrder?e.renderOrder-t.renderOrder:e.material.id!==t.material.id?e.material.id-t.material.id:e.z!==t.z?e.z-t.z:e.id-t.id}function que(e,t){return e.groupOrder!==t.groupOrder?e.groupOrder-t.groupOrder:e.renderOrder!==t.renderOrder?e.renderOrder-t.renderOrder:e.z!==t.z?t.z-e.z:e.id-t.id}function Gue(){let e=[],t=0,r=[],n=[],i=[];function o(){t=0,r.length=0,n.length=0,i.length=0}function a(h,f,p,d,g,_){let y=e[t];return y===void 0?(y={id:h.id,object:h,geometry:f,material:p,groupOrder:d,renderOrder:h.renderOrder,z:g,group:_},e[t]=y):(y.id=h.id,y.object=h,y.geometry=f,y.material=p,y.groupOrder=d,y.renderOrder=h.renderOrder,y.z=g,y.group=_),t++,y}function s(h,f,p,d,g,_){let y=a(h,f,p,d,g,_);p.transmission>0?n.push(y):p.transparent===!0?i.push(y):r.push(y)}function l(h,f,p,d,g,_){let y=a(h,f,p,d,g,_);p.transmission>0?n.unshift(y):p.transparent===!0?i.unshift(y):r.unshift(y)}function c(h,f){r.length>1&&r.sort(h||mgr),n.length>1&&n.sort(f||que),i.length>1&&i.sort(f||que)}function u(){for(let h=t,f=e.length;h<f;h++){let p=e[h];if(p.id===null)break;p.id=null,p.object=null,p.geometry=null,p.material=null,p.group=null}}return{opaque:r,transmissive:n,transparent:i,init:o,push:s,unshift:l,finish:u,sort:c}}function ggr(){let e=new WeakMap;function t(n,i){let o;return e.has(n)===!1?(o=new Gue,e.set(n,[o])):i>=e.get(n).length?(o=new Gue,e.get(n).push(o)):o=e.get(n)[i],o}function r(){e=new WeakMap}return{get:t,dispose:r}}function _gr(){let e={};return{get:function(t){if(e[t.id]!==void 0)return e[t.id];let r;switch(t.type){case"DirectionalLight":r={direction:new j,color:new ne};break;case"SpotLight":r={position:new j,direction:new j,color:new ne,distance:0,coneCos:0,penumbraCos:0,decay:0};break;case"PointLight":r={position:new j,color:new ne,distance:0,decay:0};break;case"HemisphereLight":r={direction:new j,skyColor:new ne,groundColor:new ne};break;case"RectAreaLight":r={color:new ne,position:new j,halfWidth:new j,halfHeight:new j};break}return e[t.id]=r,r}}}function ygr(){let e={};return{get:function(t){if(e[t.id]!==void 0)return e[t.id];let r;switch(t.type){case"DirectionalLight":r={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new Lt};break;case"SpotLight":r={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new Lt};break;case"PointLight":r={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new Lt,shadowCameraNear:1,shadowCameraFar:1e3};break}return e[t.id]=r,r}}}var vgr=0;function xgr(e,t){return(t.castShadow?1:0)-(e.castShadow?1:0)}function bgr(e,t){let r=new _gr,n=ygr(),i={version:0,hash:{directionalLength:-1,pointLength:-1,spotLength:-1,rectAreaLength:-1,hemiLength:-1,numDirectionalShadows:-1,numPointShadows:-1,numSpotShadows:-1},ambient:[0,0,0],probe:[],directional:[],directionalShadow:[],directionalShadowMap:[],directionalShadowMatrix:[],spot:[],spotShadow:[],spotShadowMap:[],spotShadowMatrix:[],rectArea:[],rectAreaLTC1:null,rectAreaLTC2:null,point:[],pointShadow:[],pointShadowMap:[],pointShadowMatrix:[],hemi:[]};for(let u=0;u<9;u++)i.probe.push(new j);let o=new j,a=new Me,s=new Me;function l(u,h){let f=0,p=0,d=0;for(let D=0;D<9;D++)i.probe[D].set(0,0,0);let g=0,_=0,y=0,x=0,b=0,S=0,C=0,P=0;u.sort(xgr);let k=h!==!0?Math.PI:1;for(let D=0,B=u.length;D<B;D++){let I=u[D],L=I.color,R=I.intensity,F=I.distance,z=I.shadow&&I.shadow.map?I.shadow.map.texture:null;if(I.isAmbientLight)f+=L.r*R*k,p+=L.g*R*k,d+=L.b*R*k;else if(I.isLightProbe)for(let U=0;U<9;U++)i.probe[U].addScaledVector(I.sh.coefficients[U],R);else if(I.isDirectionalLight){let U=r.get(I);if(U.color.copy(I.color).multiplyScalar(I.intensity*k),I.castShadow){let W=I.shadow,Z=n.get(I);Z.shadowBias=W.bias,Z.shadowNormalBias=W.normalBias,Z.shadowRadius=W.radius,Z.shadowMapSize=W.mapSize,i.directionalShadow[g]=Z,i.directionalShadowMap[g]=z,i.directionalShadowMatrix[g]=I.shadow.matrix,S++}i.directional[g]=U,g++}else if(I.isSpotLight){let U=r.get(I);if(U.position.setFromMatrixPosition(I.matrixWorld),U.color.copy(L).multiplyScalar(R*k),U.distance=F,U.coneCos=Math.cos(I.angle),U.penumbraCos=Math.cos(I.angle*(1-I.penumbra)),U.decay=I.decay,I.castShadow){let W=I.shadow,Z=n.get(I);Z.shadowBias=W.bias,Z.shadowNormalBias=W.normalBias,Z.shadowRadius=W.radius,Z.shadowMapSize=W.mapSize,i.spotShadow[y]=Z,i.spotShadowMap[y]=z,i.spotShadowMatrix[y]=I.shadow.matrix,P++}i.spot[y]=U,y++}else if(I.isRectAreaLight){let U=r.get(I);U.color.copy(L).multiplyScalar(R),U.halfWidth.set(I.width*.5,0,0),U.halfHeight.set(0,I.height*.5,0),i.rectArea[x]=U,x++}else if(I.isPointLight){let U=r.get(I);if(U.color.copy(I.color).multiplyScalar(I.intensity*k),U.distance=I.distance,U.decay=I.decay,I.castShadow){let W=I.shadow,Z=n.get(I);Z.shadowBias=W.bias,Z.shadowNormalBias=W.normalBias,Z.shadowRadius=W.radius,Z.shadowMapSize=W.mapSize,Z.shadowCameraNear=W.camera.near,Z.shadowCameraFar=W.camera.far,i.pointShadow[_]=Z,i.pointShadowMap[_]=z,i.pointShadowMatrix[_]=I.shadow.matrix,C++}i.point[_]=U,_++}else if(I.isHemisphereLight){let U=r.get(I);U.skyColor.copy(I.color).multiplyScalar(R*k),U.groundColor.copy(I.groundColor).multiplyScalar(R*k),i.hemi[b]=U,b++}}x>0&&(t.isWebGL2||e.has("OES_texture_float_linear")===!0?(i.rectAreaLTC1=re.LTC_FLOAT_1,i.rectAreaLTC2=re.LTC_FLOAT_2):e.has("OES_texture_half_float_linear")===!0?(i.rectAreaLTC1=re.LTC_HALF_1,i.rectAreaLTC2=re.LTC_HALF_2):console.error("THREE.WebGLRenderer: Unable to use RectAreaLight. Missing WebGL extensions.")),i.ambient[0]=f,i.ambient[1]=p,i.ambient[2]=d;let O=i.hash;(O.directionalLength!==g||O.pointLength!==_||O.spotLength!==y||O.rectAreaLength!==x||O.hemiLength!==b||O.numDirectionalShadows!==S||O.numPointShadows!==C||O.numSpotShadows!==P)&&(i.directional.length=g,i.spot.length=y,i.rectArea.length=x,i.point.length=_,i.hemi.length=b,i.directionalShadow.length=S,i.directionalShadowMap.length=S,i.pointShadow.length=C,i.pointShadowMap.length=C,i.spotShadow.length=P,i.spotShadowMap.length=P,i.directionalShadowMatrix.length=S,i.pointShadowMatrix.length=C,i.spotShadowMatrix.length=P,O.directionalLength=g,O.pointLength=_,O.spotLength=y,O.rectAreaLength=x,O.hemiLength=b,O.numDirectionalShadows=S,O.numPointShadows=C,O.numSpotShadows=P,i.version=vgr++)}function c(u,h){let f=0,p=0,d=0,g=0,_=0,y=h.matrixWorldInverse;for(let x=0,b=u.length;x<b;x++){let S=u[x];if(S.isDirectionalLight){let C=i.directional[f];C.direction.setFromMatrixPosition(S.matrixWorld),o.setFromMatrixPosition(S.target.matrixWorld),C.direction.sub(o),C.direction.transformDirection(y),f++}else if(S.isSpotLight){let C=i.spot[d];C.position.setFromMatrixPosition(S.matrixWorld),C.position.applyMatrix4(y),C.direction.setFromMatrixPosition(S.matrixWorld),o.setFromMatrixPosition(S.target.matrixWorld),C.direction.sub(o),C.direction.transformDirection(y),d++}else if(S.isRectAreaLight){let C=i.rectArea[g];C.position.setFromMatrixPosition(S.matrixWorld),C.position.applyMatrix4(y),s.identity(),a.copy(S.matrixWorld),a.premultiply(y),s.extractRotation(a),C.halfWidth.set(S.width*.5,0,0),C.halfHeight.set(0,S.height*.5,0),C.halfWidth.applyMatrix4(s),C.halfHeight.applyMatrix4(s),g++}else if(S.isPointLight){let C=i.point[p];C.position.setFromMatrixPosition(S.matrixWorld),C.position.applyMatrix4(y),p++}else if(S.isHemisphereLight){let C=i.hemi[_];C.direction.setFromMatrixPosition(S.matrixWorld),C.direction.transformDirection(y),C.direction.normalize(),_++}}}return{setup:l,setupView:c,state:i}}function Wue(e,t){let r=new bgr(e,t),n=[],i=[];function o(){n.length=0,i.length=0}function a(h){n.push(h)}function s(h){i.push(h)}function l(h){r.setup(n,h)}function c(h){r.setupView(n,h)}return{init:o,state:{lightsArray:n,shadowsArray:i,lights:r},setupLights:l,setupLightsView:c,pushLight:a,pushShadow:s}}function wgr(e,t){let r=new WeakMap;function n(o,a=0){let s;return r.has(o)===!1?(s=new Wue(e,t),r.set(o,[s])):a>=r.get(o).length?(s=new Wue(e,t),r.get(o).push(s)):s=r.get(o)[a],s}function i(){r=new WeakMap}return{get:n,dispose:i}}var eM=class extends qi{constructor(t){super(),this.type="MeshDepthMaterial",this.depthPacking=Afe,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.setValues(t)}copy(t){return super.copy(t),this.depthPacking=t.depthPacking,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this}};eM.prototype.isMeshDepthMaterial=!0;var rM=class extends qi{constructor(t){super(),this.type="MeshDistanceMaterial",this.referencePosition=new j,this.nearDistance=1,this.farDistance=1e3,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.fog=!1,this.setValues(t)}copy(t){return super.copy(t),this.referencePosition.copy(t.referencePosition),this.nearDistance=t.nearDistance,this.farDistance=t.farDistance,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this}};rM.prototype.isMeshDistanceMaterial=!0;var Sgr=`void main() {
	gl_Position = vec4( position, 1.0 );
}`,Mgr=`uniform sampler2D shadow_pass;
uniform vec2 resolution;
uniform float radius;
#include <packing>
void main() {
	const float samples = float( VSM_SAMPLES );
	float mean = 0.0;
	float squared_mean = 0.0;
	float uvStride = samples <= 1.0 ? 0.0 : 2.0 / ( samples - 1.0 );
	float uvStart = samples <= 1.0 ? 0.0 : - 1.0;
	for ( float i = 0.0; i < samples; i ++ ) {
		float uvOffset = uvStart + i * uvStride;
		#ifdef HORIZONTAL_PASS
			vec2 distribution = unpackRGBATo2Half( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( uvOffset, 0.0 ) * radius ) / resolution ) );
			mean += distribution.x;
			squared_mean += distribution.y * distribution.y + distribution.x * distribution.x;
		#else
			float depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0, uvOffset ) * radius ) / resolution ) );
			mean += depth;
			squared_mean += depth * depth;
		#endif
	}
	mean = mean / samples;
	squared_mean = squared_mean / samples;
	float std_dev = sqrt( squared_mean - mean * mean );
	gl_FragColor = pack2HalfToRGBA( vec2( mean, std_dev ) );
}`;function jfe(e,t,r){let n=new Nv,i=new Lt,o=new Lt,a=new en,s=new eM({depthPacking:Pfe}),l=new rM,c={},u=r.maxTextureSize,h={0:Ii,1:Iv,2:Lv},f=new lh({defines:{VSM_SAMPLES:8},uniforms:{shadow_pass:{value:null},resolution:{value:new Lt},radius:{value:4}},vertexShader:Sgr,fragmentShader:Mgr}),p=f.clone();p.defines.HORIZONTAL_PASS=1;let d=new Pe;d.setAttribute("position",new Je(new Float32Array([-1,-1,.5,3,-1,.5,-1,3,.5]),3));let g=new ei(d,f),_=this;this.enabled=!1,this.autoUpdate=!0,this.needsUpdate=!1,this.type=Aht,this.render=function(S,C,P){if(_.enabled===!1||_.autoUpdate===!1&&_.needsUpdate===!1||S.length===0)return;let k=e.getRenderTarget(),O=e.getActiveCubeFace(),D=e.getActiveMipmapLevel(),B=e.state;B.setBlending($d),B.buffers.color.setClear(1,1,1,1),B.buffers.depth.setTest(!0),B.setScissorTest(!1);for(let I=0,L=S.length;I<L;I++){let R=S[I],F=R.shadow;if(F===void 0){console.warn("THREE.WebGLShadowMap:",R,"has no shadow.");continue}if(F.autoUpdate===!1&&F.needsUpdate===!1)continue;i.copy(F.mapSize);let z=F.getFrameExtents();if(i.multiply(z),o.copy(F.mapSize),(i.x>u||i.y>u)&&(i.x>u&&(o.x=Math.floor(u/z.x),i.x=o.x*z.x,F.mapSize.x=o.x),i.y>u&&(o.y=Math.floor(u/z.y),i.y=o.y*z.y,F.mapSize.y=o.y)),F.map===null&&!F.isPointLightShadow&&this.type===F3){let W={minFilter:oi,magFilter:oi,format:Qo};F.map=new us(i.x,i.y,W),F.map.texture.name=R.name+".shadowMap",F.mapPass=new us(i.x,i.y,W),F.camera.updateProjectionMatrix()}if(F.map===null){let W={minFilter:Li,magFilter:Li,format:Qo};F.map=new us(i.x,i.y,W),F.map.texture.name=R.name+".shadowMap",F.camera.updateProjectionMatrix()}e.setRenderTarget(F.map),e.clear();let U=F.getViewportCount();for(let W=0;W<U;W++){let Z=F.getViewport(W);a.set(o.x*Z.x,o.y*Z.y,o.x*Z.z,o.y*Z.w),B.viewport(a),F.updateMatrices(R,W),n=F.getFrustum(),b(C,P,F.camera,R,this.type)}!F.isPointLightShadow&&this.type===F3&&y(F,P),F.needsUpdate=!1}_.needsUpdate=!1,e.setRenderTarget(k,O,D)};function y(S,C){let P=t.update(g);f.defines.VSM_SAMPLES!==S.blurSamples&&(f.defines.VSM_SAMPLES=S.blurSamples,p.defines.VSM_SAMPLES=S.blurSamples,f.needsUpdate=!0,p.needsUpdate=!0),f.uniforms.shadow_pass.value=S.map.texture,f.uniforms.resolution.value=S.mapSize,f.uniforms.radius.value=S.radius,e.setRenderTarget(S.mapPass),e.clear(),e.renderBufferDirect(C,null,P,f,g,null),p.uniforms.shadow_pass.value=S.mapPass.texture,p.uniforms.resolution.value=S.mapSize,p.uniforms.radius.value=S.radius,e.setRenderTarget(S.map),e.clear(),e.renderBufferDirect(C,null,P,p,g,null)}function x(S,C,P,k,O,D,B){let I=null,L=k.isPointLight===!0?S.customDistanceMaterial:S.customDepthMaterial;if(L!==void 0?I=L:I=k.isPointLight===!0?l:s,e.localClippingEnabled&&P.clipShadows===!0&&P.clippingPlanes.length!==0||P.displacementMap&&P.displacementScale!==0||P.alphaMap&&P.alphaTest>0){let R=I.uuid,F=P.uuid,z=c[R];z===void 0&&(z={},c[R]=z);let U=z[F];U===void 0&&(U=I.clone(),z[F]=U),I=U}return I.visible=P.visible,I.wireframe=P.wireframe,B===F3?I.side=P.shadowSide!==null?P.shadowSide:P.side:I.side=P.shadowSide!==null?P.shadowSide:h[P.side],I.alphaMap=P.alphaMap,I.alphaTest=P.alphaTest,I.clipShadows=P.clipShadows,I.clippingPlanes=P.clippingPlanes,I.clipIntersection=P.clipIntersection,I.displacementMap=P.displacementMap,I.displacementScale=P.displacementScale,I.displacementBias=P.displacementBias,I.wireframeLinewidth=P.wireframeLinewidth,I.linewidth=P.linewidth,k.isPointLight===!0&&I.isMeshDistanceMaterial===!0&&(I.referencePosition.setFromMatrixPosition(k.matrixWorld),I.nearDistance=O,I.farDistance=D),I}function b(S,C,P,k,O){if(S.visible===!1)return;if(S.layers.test(C.layers)&&(S.isMesh||S.isLine||S.isPoints)&&(S.castShadow||S.receiveShadow&&O===F3)&&(!S.frustumCulled||n.intersectsObject(S))){S.modelViewMatrix.multiplyMatrices(P.matrixWorldInverse,S.matrixWorld);let I=t.update(S),L=S.material;if(Array.isArray(L)){let R=I.groups;for(let F=0,z=R.length;F<z;F++){let U=R[F],W=L[U.materialIndex];if(W&&W.visible){let Z=x(S,I,W,k,P.near,P.far,O);e.renderBufferDirect(P,null,I,Z,S,U)}}}else if(L.visible){let R=x(S,I,L,k,P.near,P.far,O);e.renderBufferDirect(P,null,I,R,S,null)}}let B=S.children;for(let I=0,L=B.length;I<L;I++)b(B[I],C,P,k,O)}}function Egr(e,t,r){let n=r.isWebGL2;function i(){let at=!1,se=new en,Qt=null,Ce=new en(0,0,0,0);return{setMask:function(Pt){Qt!==Pt&&!at&&(e.colorMask(Pt,Pt,Pt,Pt),Qt=Pt)},setLocked:function(Pt){at=Pt},setClear:function(Pt,Nt,ze,yn,Wi){Wi===!0&&(Pt*=yn,Nt*=yn,ze*=yn),se.set(Pt,Nt,ze,yn),Ce.equals(se)===!1&&(e.clearColor(Pt,Nt,ze,yn),Ce.copy(se))},reset:function(){at=!1,Qt=null,Ce.set(-1,0,0,0)}}}function o(){let at=!1,se=null,Qt=null,Ce=null;return{setTest:function(Pt){Pt?lt(2929):Kt(2929)},setMask:function(Pt){se!==Pt&&!at&&(e.depthMask(Pt),se=Pt)},setFunc:function(Pt){if(Qt!==Pt){if(Pt)switch(Pt){case Khe:e.depthFunc(512);break;case Zhe:e.depthFunc(519);break;case Jhe:e.depthFunc(513);break;case nU:e.depthFunc(515);break;case Qhe:e.depthFunc(514);break;case tfe:e.depthFunc(518);break;case efe:e.depthFunc(516);break;case rfe:e.depthFunc(517);break;default:e.depthFunc(515)}else e.depthFunc(515);Qt=Pt}},setLocked:function(Pt){at=Pt},setClear:function(Pt){Ce!==Pt&&(e.clearDepth(Pt),Ce=Pt)},reset:function(){at=!1,se=null,Qt=null,Ce=null}}}function a(){let at=!1,se=null,Qt=null,Ce=null,Pt=null,Nt=null,ze=null,yn=null,Wi=null;return{setTest:function(Ar){at||(Ar?lt(2960):Kt(2960))},setMask:function(Ar){se!==Ar&&!at&&(e.stencilMask(Ar),se=Ar)},setFunc:function(Ar,Pa,ho){(Qt!==Ar||Ce!==Pa||Pt!==ho)&&(e.stencilFunc(Ar,Pa,ho),Qt=Ar,Ce=Pa,Pt=ho)},setOp:function(Ar,Pa,ho){(Nt!==Ar||ze!==Pa||yn!==ho)&&(e.stencilOp(Ar,Pa,ho),Nt=Ar,ze=Pa,yn=ho)},setLocked:function(Ar){at=Ar},setClear:function(Ar){Wi!==Ar&&(e.clearStencil(Ar),Wi=Ar)},reset:function(){at=!1,se=null,Qt=null,Ce=null,Pt=null,Nt=null,ze=null,yn=null,Wi=null}}}let s=new i,l=new o,c=new a,u={},h={},f=new WeakMap,p=[],d=null,g=!1,_=null,y=null,x=null,b=null,S=null,C=null,P=null,k=!1,O=null,D=null,B=null,I=null,L=null,R=e.getParameter(35661),F=!1,z=0,U=e.getParameter(7938);U.indexOf("WebGL")!==-1?(z=parseFloat(/^WebGL (\d)/.exec(U)[1]),F=z>=1):U.indexOf("OpenGL ES")!==-1&&(z=parseFloat(/^OpenGL ES (\d)/.exec(U)[1]),F=z>=2);let W=null,Z={},rt=e.getParameter(3088),ot=e.getParameter(2978),st=new en().fromArray(rt),St=new en().fromArray(ot);function bt(at,se,Qt){let Ce=new Uint8Array(4),Pt=e.createTexture();e.bindTexture(at,Pt),e.texParameteri(at,10241,9728),e.texParameteri(at,10240,9728);for(let Nt=0;Nt<Qt;Nt++)e.texImage2D(se+Nt,0,6408,1,1,0,6408,5121,Ce);return Pt}let Mt={};Mt[3553]=bt(3553,3553,1),Mt[34067]=bt(34067,34069,6),s.setClear(0,0,0,1),l.setClear(1),c.setClear(0),lt(2929),l.setFunc(nU),ht(!1),wt(Mut),lt(2884),q($d);function lt(at){u[at]!==!0&&(e.enable(at),u[at]=!0)}function Kt(at){u[at]!==!1&&(e.disable(at),u[at]=!1)}function _t(at,se){return h[at]!==se?(e.bindFramebuffer(at,se),h[at]=se,n&&(at===36009&&(h[36160]=se),at===36160&&(h[36009]=se)),!0):!1}function ct(at,se){let Qt=p,Ce=!1;if(at)if(Qt=f.get(se),Qt===void 0&&(Qt=[],f.set(se,Qt)),at.isWebGLMultipleRenderTargets){let Pt=at.texture;if(Qt.length!==Pt.length||Qt[0]!==36064){for(let Nt=0,ze=Pt.length;Nt<ze;Nt++)Qt[Nt]=36064+Nt;Qt.length=Pt.length,Ce=!0}}else Qt[0]!==36064&&(Qt[0]=36064,Ce=!0);else Qt[0]!==1029&&(Qt[0]=1029,Ce=!0);Ce&&(r.isWebGL2?e.drawBuffers(Qt):t.get("WEBGL_draw_buffers").drawBuffersWEBGL(Qt))}function X(at){return d!==at?(e.useProgram(at),d=at,!0):!1}let et={[Mv]:32774,[Bhe]:32778,[Hhe]:32779};if(n)et[Aut]=32775,et[Put]=32776;else{let at=t.get("EXT_blend_minmax");at!==null&&(et[Aut]=at.MIN_EXT,et[Put]=at.MAX_EXT)}let dt={[Vhe]:0,[Uhe]:1,[qhe]:768,[Iht]:770,[$he]:776,[jhe]:774,[Whe]:772,[Ghe]:769,[Lht]:771,[Xhe]:775,[Yhe]:773};function q(at,se,Qt,Ce,Pt,Nt,ze,yn){if(at===$d){g===!0&&(Kt(3042),g=!1);return}if(g===!1&&(lt(3042),g=!0),at!==Fhe){if(at!==_||yn!==k){if((y!==Mv||S!==Mv)&&(e.blendEquation(32774),y=Mv,S=Mv),yn)switch(at){case V3:e.blendFuncSeparate(1,771,1,771);break;case Eut:e.blendFunc(1,1);break;case Tut:e.blendFuncSeparate(0,769,0,1);break;case Cut:e.blendFuncSeparate(0,768,0,770);break;default:console.error("THREE.WebGLState: Invalid blending: ",at);break}else switch(at){case V3:e.blendFuncSeparate(770,771,1,771);break;case Eut:e.blendFunc(770,1);break;case Tut:e.blendFuncSeparate(0,769,0,1);break;case Cut:e.blendFunc(0,768);break;default:console.error("THREE.WebGLState: Invalid blending: ",at);break}x=null,b=null,C=null,P=null,_=at,k=yn}return}Pt=Pt||se,Nt=Nt||Qt,ze=ze||Ce,(se!==y||Pt!==S)&&(e.blendEquationSeparate(et[se],et[Pt]),y=se,S=Pt),(Qt!==x||Ce!==b||Nt!==C||ze!==P)&&(e.blendFuncSeparate(dt[Qt],dt[Ce],dt[Nt],dt[ze]),x=Qt,b=Ce,C=Nt,P=ze),_=at,k=null}function pt(at,se){at.side===Lv?Kt(2884):lt(2884);let Qt=at.side===Ii;se&&(Qt=!Qt),ht(Qt),at.blending===V3&&at.transparent===!1?q($d):q(at.blending,at.blendEquation,at.blendSrc,at.blendDst,at.blendEquationAlpha,at.blendSrcAlpha,at.blendDstAlpha,at.premultipliedAlpha),l.setFunc(at.depthFunc),l.setTest(at.depthTest),l.setMask(at.depthWrite),s.setMask(at.colorWrite);let Ce=at.stencilWrite;c.setTest(Ce),Ce&&(c.setMask(at.stencilWriteMask),c.setFunc(at.stencilFunc,at.stencilRef,at.stencilFuncMask),c.setOp(at.stencilFail,at.stencilZFail,at.stencilZPass)),ie(at.polygonOffset,at.polygonOffsetFactor,at.polygonOffsetUnits),at.alphaToCoverage===!0?lt(32926):Kt(32926)}function ht(at){O!==at&&(at?e.frontFace(2304):e.frontFace(2305),O=at)}function wt(at){at!==Dhe?(lt(2884),at!==D&&(at===Mut?e.cullFace(1029):at===Ohe?e.cullFace(1028):e.cullFace(1032))):Kt(2884),D=at}function kt(at){at!==B&&(F&&e.lineWidth(at),B=at)}function ie(at,se,Qt){at?(lt(32823),(I!==se||L!==Qt)&&(e.polygonOffset(se,Qt),I=se,L=Qt)):Kt(32823)}function ee(at){at?lt(3089):Kt(3089)}function Le(at){at===void 0&&(at=33984+R-1),W!==at&&(e.activeTexture(at),W=at)}function ar(at,se){W===null&&Le();let Qt=Z[W];Qt===void 0&&(Qt={type:void 0,texture:void 0},Z[W]=Qt),(Qt.type!==at||Qt.texture!==se)&&(e.bindTexture(at,se||Mt[at]),Qt.type=at,Qt.texture=se)}function fr(){let at=Z[W];at!==void 0&&at.type!==void 0&&(e.bindTexture(at.type,null),at.type=void 0,at.texture=void 0)}function tt(){try{e.compressedTexImage2D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function $(){try{e.texSubImage2D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function It(){try{e.texSubImage3D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function $t(){try{e.compressedTexSubImage2D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function he(){try{e.texStorage2D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function Tt(){try{e.texStorage3D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function be(){try{e.texImage2D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function nt(){try{e.texImage3D.apply(e,arguments)}catch(at){console.error("THREE.WebGLState:",at)}}function Ct(at){st.equals(at)===!1&&(e.scissor(at.x,at.y,at.z,at.w),st.copy(at))}function Wt(at){St.equals(at)===!1&&(e.viewport(at.x,at.y,at.z,at.w),St.copy(at))}function fe(){e.disable(3042),e.disable(2884),e.disable(2929),e.disable(32823),e.disable(3089),e.disable(2960),e.disable(32926),e.blendEquation(32774),e.blendFunc(1,0),e.blendFuncSeparate(1,0,1,0),e.colorMask(!0,!0,!0,!0),e.clearColor(0,0,0,0),e.depthMask(!0),e.depthFunc(513),e.clearDepth(1),e.stencilMask(4294967295),e.stencilFunc(519,0,4294967295),e.stencilOp(7680,7680,7680),e.clearStencil(0),e.cullFace(1029),e.frontFace(2305),e.polygonOffset(0,0),e.activeTexture(33984),e.bindFramebuffer(36160,null),n===!0&&(e.bindFramebuffer(36009,null),e.bindFramebuffer(36008,null)),e.useProgram(null),e.lineWidth(1),e.scissor(0,0,e.canvas.width,e.canvas.height),e.viewport(0,0,e.canvas.width,e.canvas.height),u={},W=null,Z={},h={},f=new WeakMap,p=[],d=null,g=!1,_=null,y=null,x=null,b=null,S=null,C=null,P=null,k=!1,O=null,D=null,B=null,I=null,L=null,st.set(0,0,e.canvas.width,e.canvas.height),St.set(0,0,e.canvas.width,e.canvas.height),s.reset(),l.reset(),c.reset()}return{buffers:{color:s,depth:l,stencil:c},enable:lt,disable:Kt,bindFramebuffer:_t,drawBuffers:ct,useProgram:X,setBlending:q,setMaterial:pt,setFlipSided:ht,setCullFace:wt,setLineWidth:kt,setPolygonOffset:ie,setScissorTest:ee,activeTexture:Le,bindTexture:ar,unbindTexture:fr,compressedTexImage2D:tt,texImage2D:be,texImage3D:nt,texStorage2D:he,texStorage3D:Tt,texSubImage2D:$,texSubImage3D:It,compressedTexSubImage2D:$t,scissor:Ct,viewport:Wt,reset:fe}}function Tgr(e,t,r,n,i,o,a){let s=i.isWebGL2,l=i.maxTextures,c=i.maxCubemapSize,u=i.maxTextureSize,h=i.maxSamples,p=t.has("WEBGL_multisampled_render_to_texture")?t.get("WEBGL_multisampled_render_to_texture"):void 0,d=new WeakMap,g,_=!1;try{_=typeof OffscreenCanvas!="undefined"&&new OffscreenCanvas(1,1).getContext("2d")!==null}catch(tt){}function y(tt,$){return _?new OffscreenCanvas(tt,$):QP("canvas")}function x(tt,$,It,$t){let he=1;if((tt.width>$t||tt.height>$t)&&(he=$t/Math.max(tt.width,tt.height)),he<1||$===!0)if(typeof HTMLImageElement!="undefined"&&tt instanceof HTMLImageElement||typeof HTMLCanvasElement!="undefined"&&tt instanceof HTMLCanvasElement||typeof ImageBitmap!="undefined"&&tt instanceof ImageBitmap){let Tt=$?Rfe:Math.floor,be=Tt(he*tt.width),nt=Tt(he*tt.height);g===void 0&&(g=y(be,nt));let Ct=It?y(be,nt):g;return Ct.width=be,Ct.height=nt,Ct.getContext("2d").drawImage(tt,0,0,be,nt),console.warn("THREE.WebGLRenderer: Texture has been resized from ("+tt.width+"x"+tt.height+") to ("+be+"x"+nt+")."),Ct}else return"data"in tt&&console.warn("THREE.WebGLRenderer: Image in DataTexture is too big ("+tt.width+"x"+tt.height+")."),tt;return tt}function b(tt){return Jut(tt.width)&&Jut(tt.height)}function S(tt){return s?!1:tt.wrapS!==Jo||tt.wrapT!==Jo||tt.minFilter!==Li&&tt.minFilter!==oi}function C(tt,$){return tt.generateMipmaps&&$&&tt.minFilter!==Li&&tt.minFilter!==oi}function P(tt){e.generateMipmap(tt)}function k(tt,$,It,$t,he=!1){if(s===!1)return $;if(tt!==null){if(e[tt]!==void 0)return e[tt];console.warn("THREE.WebGLRenderer: Attempt to use non-existing WebGL internal format '"+tt+"'")}let Tt=$;return $===6403&&(It===5126&&(Tt=33326),It===5131&&(Tt=33325),It===5121&&(Tt=33321)),$===33319&&(It===5126&&(Tt=33328),It===5131&&(Tt=33327),It===5121&&(Tt=33323)),$===6408&&(It===5126&&(Tt=34836),It===5131&&(Tt=34842),It===5121&&(Tt=$t===Yn&&he===!1?35907:32856),It===32819&&(Tt=32854),It===32820&&(Tt=32855)),(Tt===33325||Tt===33326||Tt===33327||Tt===33328||Tt===34842||Tt===34836)&&t.get("EXT_color_buffer_float"),Tt}function O(tt,$,It){return C(tt,It)===!0||tt.isFramebufferTexture&&tt.minFilter!==Li&&tt.minFilter!==oi?Math.log2(Math.max($.width,$.height))+1:tt.mipmaps!==void 0&&tt.mipmaps.length>0?tt.mipmaps.length:tt.isCompressedTexture&&Array.isArray(tt.image)?$.mipmaps.length:1}function D(tt){return tt===Li||tt===iU||tt===oU?9728:9729}function B(tt){let $=tt.target;$.removeEventListener("dispose",B),L($),$.isVideoTexture&&d.delete($),a.memory.textures--}function I(tt){let $=tt.target;$.removeEventListener("dispose",I),R($)}function L(tt){let $=n.get(tt);$.__webglInit!==void 0&&(e.deleteTexture($.__webglTexture),n.remove(tt))}function R(tt){let $=tt.texture,It=n.get(tt),$t=n.get($);if(!!tt){if($t.__webglTexture!==void 0&&(e.deleteTexture($t.__webglTexture),a.memory.textures--),tt.depthTexture&&tt.depthTexture.dispose(),tt.isWebGLCubeRenderTarget)for(let he=0;he<6;he++)e.deleteFramebuffer(It.__webglFramebuffer[he]),It.__webglDepthbuffer&&e.deleteRenderbuffer(It.__webglDepthbuffer[he]);else e.deleteFramebuffer(It.__webglFramebuffer),It.__webglDepthbuffer&&e.deleteRenderbuffer(It.__webglDepthbuffer),It.__webglMultisampledFramebuffer&&e.deleteFramebuffer(It.__webglMultisampledFramebuffer),It.__webglColorRenderbuffer&&e.deleteRenderbuffer(It.__webglColorRenderbuffer),It.__webglDepthRenderbuffer&&e.deleteRenderbuffer(It.__webglDepthRenderbuffer);if(tt.isWebGLMultipleRenderTargets)for(let he=0,Tt=$.length;he<Tt;he++){let be=n.get($[he]);be.__webglTexture&&(e.deleteTexture(be.__webglTexture),a.memory.textures--),n.remove($[he])}n.remove($),n.remove(tt)}}let F=0;function z(){F=0}function U(){let tt=F;return tt>=l&&console.warn("THREE.WebGLTextures: Trying to use "+tt+" texture units while this GPU supports only "+l),F+=1,tt}function W(tt,$){let It=n.get(tt);if(tt.isVideoTexture&&kt(tt),tt.version>0&&It.__version!==tt.version){let $t=tt.image;if($t===void 0)console.warn("THREE.WebGLRenderer: Texture marked for update but image is undefined");else if($t.complete===!1)console.warn("THREE.WebGLRenderer: Texture marked for update but image is incomplete");else{lt(It,tt,$);return}}r.activeTexture(33984+$),r.bindTexture(3553,It.__webglTexture)}function Z(tt,$){let It=n.get(tt);if(tt.version>0&&It.__version!==tt.version){lt(It,tt,$);return}r.activeTexture(33984+$),r.bindTexture(35866,It.__webglTexture)}function rt(tt,$){let It=n.get(tt);if(tt.version>0&&It.__version!==tt.version){lt(It,tt,$);return}r.activeTexture(33984+$),r.bindTexture(32879,It.__webglTexture)}function ot(tt,$){let It=n.get(tt);if(tt.version>0&&It.__version!==tt.version){Kt(It,tt,$);return}r.activeTexture(33984+$),r.bindTexture(34067,It.__webglTexture)}let st={[jP]:10497,[Jo]:33071,[XP]:33648},St={[Li]:9728,[iU]:9984,[oU]:9986,[oi]:9729,[kht]:9985,[ox]:9987};function bt(tt,$,It){if(It?(e.texParameteri(tt,10242,st[$.wrapS]),e.texParameteri(tt,10243,st[$.wrapT]),(tt===32879||tt===35866)&&e.texParameteri(tt,32882,st[$.wrapR]),e.texParameteri(tt,10240,St[$.magFilter]),e.texParameteri(tt,10241,St[$.minFilter])):(e.texParameteri(tt,10242,33071),e.texParameteri(tt,10243,33071),(tt===32879||tt===35866)&&e.texParameteri(tt,32882,33071),($.wrapS!==Jo||$.wrapT!==Jo)&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping."),e.texParameteri(tt,10240,D($.magFilter)),e.texParameteri(tt,10241,D($.minFilter)),$.minFilter!==Li&&$.minFilter!==oi&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter.")),t.has("EXT_texture_filter_anisotropic")===!0){let $t=t.get("EXT_texture_filter_anisotropic");if($.type===jd&&t.has("OES_texture_float_linear")===!1||s===!1&&$.type===Cv&&t.has("OES_texture_half_float_linear")===!1)return;($.anisotropy>1||n.get($).__currentAnisotropy)&&(e.texParameterf(tt,$t.TEXTURE_MAX_ANISOTROPY_EXT,Math.min($.anisotropy,i.getMaxAnisotropy())),n.get($).__currentAnisotropy=$.anisotropy)}}function Mt(tt,$){tt.__webglInit===void 0&&(tt.__webglInit=!0,$.addEventListener("dispose",B),tt.__webglTexture=e.createTexture(),a.memory.textures++)}function lt(tt,$,It){let $t=3553;$.isDataTexture2DArray&&($t=35866),$.isDataTexture3D&&($t=32879),Mt(tt,$),r.activeTexture(33984+It),r.bindTexture($t,tt.__webglTexture),e.pixelStorei(37440,$.flipY),e.pixelStorei(37441,$.premultiplyAlpha),e.pixelStorei(3317,$.unpackAlignment),e.pixelStorei(37443,0);let he=S($)&&b($.image)===!1,Tt=x($.image,he,!1,u);Tt=ie($,Tt);let be=b(Tt)||s,nt=o.convert($.format,$.encoding),Ct=o.convert($.type),Wt=k($.internalFormat,nt,Ct,$.encoding,$.isVideoTexture);bt($t,$,be);let fe,at=$.mipmaps,se=s&&$.isVideoTexture!==!0,Qt=tt.__version===void 0,Ce=O($,Tt,be);if($.isDepthTexture)Wt=6402,s?$.type===jd?Wt=36012:$.type===HP?Wt=33190:$.type===Av?Wt=35056:Wt=33189:$.type===jd&&console.error("WebGLRenderer: Floating point depth texture requires WebGL2."),$.format===z0&&Wt===6402&&$.type!==G3&&$.type!==HP&&(console.warn("THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture."),$.type=G3,Ct=o.convert($.type)),$.format===kv&&Wt===6402&&(Wt=34041,$.type!==Av&&(console.warn("THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture."),$.type=Av,Ct=o.convert($.type))),se&&Qt?r.texStorage2D(3553,1,Wt,Tt.width,Tt.height):r.texImage2D(3553,0,Wt,Tt.width,Tt.height,0,nt,Ct,null);else if($.isDataTexture)if(at.length>0&&be){se&&Qt&&r.texStorage2D(3553,Ce,Wt,at[0].width,at[0].height);for(let Pt=0,Nt=at.length;Pt<Nt;Pt++)fe=at[Pt],se?r.texSubImage2D(3553,0,0,0,fe.width,fe.height,nt,Ct,fe.data):r.texImage2D(3553,Pt,Wt,fe.width,fe.height,0,nt,Ct,fe.data);$.generateMipmaps=!1}else se?(Qt&&r.texStorage2D(3553,Ce,Wt,Tt.width,Tt.height),r.texSubImage2D(3553,0,0,0,Tt.width,Tt.height,nt,Ct,Tt.data)):r.texImage2D(3553,0,Wt,Tt.width,Tt.height,0,nt,Ct,Tt.data);else if($.isCompressedTexture){se&&Qt&&r.texStorage2D(3553,Ce,Wt,at[0].width,at[0].height);for(let Pt=0,Nt=at.length;Pt<Nt;Pt++)fe=at[Pt],$.format!==Qo?nt!==null?se?r.compressedTexSubImage2D(3553,Pt,0,0,fe.width,fe.height,nt,fe.data):r.compressedTexImage2D(3553,Pt,Wt,fe.width,fe.height,0,fe.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()"):se?r.texSubImage2D(3553,Pt,0,0,fe.width,fe.height,nt,Ct,fe.data):r.texImage2D(3553,Pt,Wt,fe.width,fe.height,0,nt,Ct,fe.data)}else if($.isDataTexture2DArray)se?(Qt&&r.texStorage3D(35866,Ce,Wt,Tt.width,Tt.height,Tt.depth),r.texSubImage3D(35866,0,0,0,0,Tt.width,Tt.height,Tt.depth,nt,Ct,Tt.data)):r.texImage3D(35866,0,Wt,Tt.width,Tt.height,Tt.depth,0,nt,Ct,Tt.data);else if($.isDataTexture3D)se?(Qt&&r.texStorage3D(32879,Ce,Wt,Tt.width,Tt.height,Tt.depth),r.texSubImage3D(32879,0,0,0,0,Tt.width,Tt.height,Tt.depth,nt,Ct,Tt.data)):r.texImage3D(32879,0,Wt,Tt.width,Tt.height,Tt.depth,0,nt,Ct,Tt.data);else if($.isFramebufferTexture)se&&Qt?r.texStorage2D(3553,Ce,Wt,Tt.width,Tt.height):r.texImage2D(3553,0,Wt,Tt.width,Tt.height,0,nt,Ct,null);else if(at.length>0&&be){se&&Qt&&r.texStorage2D(3553,Ce,Wt,at[0].width,at[0].height);for(let Pt=0,Nt=at.length;Pt<Nt;Pt++)fe=at[Pt],se?r.texSubImage2D(3553,Pt,0,0,nt,Ct,fe):r.texImage2D(3553,Pt,Wt,nt,Ct,fe);$.generateMipmaps=!1}else se?(Qt&&r.texStorage2D(3553,Ce,Wt,Tt.width,Tt.height),r.texSubImage2D(3553,0,0,0,nt,Ct,Tt)):r.texImage2D(3553,0,Wt,nt,Ct,Tt);C($,be)&&P($t),tt.__version=$.version,$.onUpdate&&$.onUpdate($)}function Kt(tt,$,It){if($.image.length!==6)return;Mt(tt,$),r.activeTexture(33984+It),r.bindTexture(34067,tt.__webglTexture),e.pixelStorei(37440,$.flipY),e.pixelStorei(37441,$.premultiplyAlpha),e.pixelStorei(3317,$.unpackAlignment),e.pixelStorei(37443,0);let $t=$&&($.isCompressedTexture||$.image[0].isCompressedTexture),he=$.image[0]&&$.image[0].isDataTexture,Tt=[];for(let Pt=0;Pt<6;Pt++)!$t&&!he?Tt[Pt]=x($.image[Pt],!1,!0,c):Tt[Pt]=he?$.image[Pt].image:$.image[Pt],Tt[Pt]=ie($,Tt[Pt]);let be=Tt[0],nt=b(be)||s,Ct=o.convert($.format,$.encoding),Wt=o.convert($.type),fe=k($.internalFormat,Ct,Wt,$.encoding),at=s&&$.isVideoTexture!==!0,se=tt.__version===void 0,Qt=O($,be,nt);bt(34067,$,nt);let Ce;if($t){at&&se&&r.texStorage2D(34067,Qt,fe,be.width,be.height);for(let Pt=0;Pt<6;Pt++){Ce=Tt[Pt].mipmaps;for(let Nt=0;Nt<Ce.length;Nt++){let ze=Ce[Nt];$.format!==Qo?Ct!==null?at?r.compressedTexSubImage2D(34069+Pt,Nt,0,0,ze.width,ze.height,Ct,ze.data):r.compressedTexImage2D(34069+Pt,Nt,fe,ze.width,ze.height,0,ze.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()"):at?r.texSubImage2D(34069+Pt,Nt,0,0,ze.width,ze.height,Ct,Wt,ze.data):r.texImage2D(34069+Pt,Nt,fe,ze.width,ze.height,0,Ct,Wt,ze.data)}}}else{Ce=$.mipmaps,at&&se&&(Ce.length>0&&Qt++,r.texStorage2D(34067,Qt,fe,Tt[0].width,Tt[0].height));for(let Pt=0;Pt<6;Pt++)if(he){at?r.texSubImage2D(34069+Pt,0,0,0,Tt[Pt].width,Tt[Pt].height,Ct,Wt,Tt[Pt].data):r.texImage2D(34069+Pt,0,fe,Tt[Pt].width,Tt[Pt].height,0,Ct,Wt,Tt[Pt].data);for(let Nt=0;Nt<Ce.length;Nt++){let yn=Ce[Nt].image[Pt].image;at?r.texSubImage2D(34069+Pt,Nt+1,0,0,yn.width,yn.height,Ct,Wt,yn.data):r.texImage2D(34069+Pt,Nt+1,fe,yn.width,yn.height,0,Ct,Wt,yn.data)}}else{at?r.texSubImage2D(34069+Pt,0,0,0,Ct,Wt,Tt[Pt]):r.texImage2D(34069+Pt,0,fe,Ct,Wt,Tt[Pt]);for(let Nt=0;Nt<Ce.length;Nt++){let ze=Ce[Nt];at?r.texSubImage2D(34069+Pt,Nt+1,0,0,Ct,Wt,ze.image[Pt]):r.texImage2D(34069+Pt,Nt+1,fe,Ct,Wt,ze.image[Pt])}}}C($,nt)&&P(34067),tt.__version=$.version,$.onUpdate&&$.onUpdate($)}function _t(tt,$,It,$t,he){let Tt=o.convert(It.format,It.encoding),be=o.convert(It.type),nt=k(It.internalFormat,Tt,be,It.encoding);n.get($).__hasExternalTextures||(he===32879||he===35866?r.texImage3D(he,0,nt,$.width,$.height,$.depth,0,Tt,be,null):r.texImage2D(he,0,nt,$.width,$.height,0,Tt,be,null)),r.bindFramebuffer(36160,tt),$.useRenderToTexture?p.framebufferTexture2DMultisampleEXT(36160,$t,he,n.get(It).__webglTexture,0,wt($)):e.framebufferTexture2D(36160,$t,he,n.get(It).__webglTexture,0),r.bindFramebuffer(36160,null)}function ct(tt,$,It){if(e.bindRenderbuffer(36161,tt),$.depthBuffer&&!$.stencilBuffer){let $t=33189;if(It||$.useRenderToTexture){let he=$.depthTexture;he&&he.isDepthTexture&&(he.type===jd?$t=36012:he.type===HP&&($t=33190));let Tt=wt($);$.useRenderToTexture?p.renderbufferStorageMultisampleEXT(36161,Tt,$t,$.width,$.height):e.renderbufferStorageMultisample(36161,Tt,$t,$.width,$.height)}else e.renderbufferStorage(36161,$t,$.width,$.height);e.framebufferRenderbuffer(36160,36096,36161,tt)}else if($.depthBuffer&&$.stencilBuffer){let $t=wt($);It&&$.useRenderbuffer?e.renderbufferStorageMultisample(36161,$t,35056,$.width,$.height):$.useRenderToTexture?p.renderbufferStorageMultisampleEXT(36161,$t,35056,$.width,$.height):e.renderbufferStorage(36161,34041,$.width,$.height),e.framebufferRenderbuffer(36160,33306,36161,tt)}else{let $t=$.isWebGLMultipleRenderTargets===!0?$.texture[0]:$.texture,he=o.convert($t.format,$t.encoding),Tt=o.convert($t.type),be=k($t.internalFormat,he,Tt,$t.encoding),nt=wt($);It&&$.useRenderbuffer?e.renderbufferStorageMultisample(36161,nt,be,$.width,$.height):$.useRenderToTexture?p.renderbufferStorageMultisampleEXT(36161,nt,be,$.width,$.height):e.renderbufferStorage(36161,be,$.width,$.height)}e.bindRenderbuffer(36161,null)}function X(tt,$){if($&&$.isWebGLCubeRenderTarget)throw new Error("Depth Texture with cube render targets is not supported");if(r.bindFramebuffer(36160,tt),!($.depthTexture&&$.depthTexture.isDepthTexture))throw new Error("renderTarget.depthTexture must be an instance of THREE.DepthTexture");(!n.get($.depthTexture).__webglTexture||$.depthTexture.image.width!==$.width||$.depthTexture.image.height!==$.height)&&($.depthTexture.image.width=$.width,$.depthTexture.image.height=$.height,$.depthTexture.needsUpdate=!0),W($.depthTexture,0);let $t=n.get($.depthTexture).__webglTexture,he=wt($);if($.depthTexture.format===z0)$.useRenderToTexture?p.framebufferTexture2DMultisampleEXT(36160,36096,3553,$t,0,he):e.framebufferTexture2D(36160,36096,3553,$t,0);else if($.depthTexture.format===kv)$.useRenderToTexture?p.framebufferTexture2DMultisampleEXT(36160,33306,3553,$t,0,he):e.framebufferTexture2D(36160,33306,3553,$t,0);else throw new Error("Unknown depthTexture format")}function et(tt){let $=n.get(tt),It=tt.isWebGLCubeRenderTarget===!0;if(tt.depthTexture&&!$.__autoAllocateDepthBuffer){if(It)throw new Error("target.depthTexture not supported in Cube render targets");X($.__webglFramebuffer,tt)}else if(It){$.__webglDepthbuffer=[];for(let $t=0;$t<6;$t++)r.bindFramebuffer(36160,$.__webglFramebuffer[$t]),$.__webglDepthbuffer[$t]=e.createRenderbuffer(),ct($.__webglDepthbuffer[$t],tt,!1)}else r.bindFramebuffer(36160,$.__webglFramebuffer),$.__webglDepthbuffer=e.createRenderbuffer(),ct($.__webglDepthbuffer,tt,!1);r.bindFramebuffer(36160,null)}function dt(tt,$,It){let $t=n.get(tt);$!==void 0&&_t($t.__webglFramebuffer,tt,tt.texture,36064,3553),It!==void 0&&et(tt)}function q(tt){let $=tt.texture,It=n.get(tt),$t=n.get($);tt.addEventListener("dispose",I),tt.isWebGLMultipleRenderTargets!==!0&&($t.__webglTexture===void 0&&($t.__webglTexture=e.createTexture()),$t.__version=$.version,a.memory.textures++);let he=tt.isWebGLCubeRenderTarget===!0,Tt=tt.isWebGLMultipleRenderTargets===!0,be=$.isDataTexture3D||$.isDataTexture2DArray,nt=b(tt)||s;if(he){It.__webglFramebuffer=[];for(let Ct=0;Ct<6;Ct++)It.__webglFramebuffer[Ct]=e.createFramebuffer()}else if(It.__webglFramebuffer=e.createFramebuffer(),Tt)if(i.drawBuffers){let Ct=tt.texture;for(let Wt=0,fe=Ct.length;Wt<fe;Wt++){let at=n.get(Ct[Wt]);at.__webglTexture===void 0&&(at.__webglTexture=e.createTexture(),a.memory.textures++)}}else console.warn("THREE.WebGLRenderer: WebGLMultipleRenderTargets can only be used with WebGL2 or WEBGL_draw_buffers extension.");else if(tt.useRenderbuffer)if(s){It.__webglMultisampledFramebuffer=e.createFramebuffer(),It.__webglColorRenderbuffer=e.createRenderbuffer(),e.bindRenderbuffer(36161,It.__webglColorRenderbuffer);let Ct=o.convert($.format,$.encoding),Wt=o.convert($.type),fe=k($.internalFormat,Ct,Wt,$.encoding),at=wt(tt);e.renderbufferStorageMultisample(36161,at,fe,tt.width,tt.height),r.bindFramebuffer(36160,It.__webglMultisampledFramebuffer),e.framebufferRenderbuffer(36160,36064,36161,It.__webglColorRenderbuffer),e.bindRenderbuffer(36161,null),tt.depthBuffer&&(It.__webglDepthRenderbuffer=e.createRenderbuffer(),ct(It.__webglDepthRenderbuffer,tt,!0)),r.bindFramebuffer(36160,null)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.");if(he){r.bindTexture(34067,$t.__webglTexture),bt(34067,$,nt);for(let Ct=0;Ct<6;Ct++)_t(It.__webglFramebuffer[Ct],tt,$,36064,34069+Ct);C($,nt)&&P(34067),r.unbindTexture()}else if(Tt){let Ct=tt.texture;for(let Wt=0,fe=Ct.length;Wt<fe;Wt++){let at=Ct[Wt],se=n.get(at);r.bindTexture(3553,se.__webglTexture),bt(3553,at,nt),_t(It.__webglFramebuffer,tt,at,36064+Wt,3553),C(at,nt)&&P(3553)}r.unbindTexture()}else{let Ct=3553;be&&(s?Ct=$.isDataTexture3D?32879:35866:console.warn("THREE.DataTexture3D and THREE.DataTexture2DArray only supported with WebGL2.")),r.bindTexture(Ct,$t.__webglTexture),bt(Ct,$,nt),_t(It.__webglFramebuffer,tt,$,36064,Ct),C($,nt)&&P(Ct),r.unbindTexture()}tt.depthBuffer&&et(tt)}function pt(tt){let $=b(tt)||s,It=tt.isWebGLMultipleRenderTargets===!0?tt.texture:[tt.texture];for(let $t=0,he=It.length;$t<he;$t++){let Tt=It[$t];if(C(Tt,$)){let be=tt.isWebGLCubeRenderTarget?34067:3553,nt=n.get(Tt).__webglTexture;r.bindTexture(be,nt),P(be),r.unbindTexture()}}}function ht(tt){if(tt.useRenderbuffer)if(s){let $=tt.width,It=tt.height,$t=16384,he=[36064],Tt=tt.stencilBuffer?33306:36096;tt.depthBuffer&&he.push(Tt),tt.ignoreDepthForMultisampleCopy||(tt.depthBuffer&&($t|=256),tt.stencilBuffer&&($t|=1024));let be=n.get(tt);r.bindFramebuffer(36008,be.__webglMultisampledFramebuffer),r.bindFramebuffer(36009,be.__webglFramebuffer),tt.ignoreDepthForMultisampleCopy&&(e.invalidateFramebuffer(36008,[Tt]),e.invalidateFramebuffer(36009,[Tt])),e.blitFramebuffer(0,0,$,It,0,0,$,It,$t,9728),e.invalidateFramebuffer(36008,he),r.bindFramebuffer(36008,null),r.bindFramebuffer(36009,be.__webglMultisampledFramebuffer)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.")}function wt(tt){return s&&(tt.useRenderbuffer||tt.useRenderToTexture)?Math.min(h,tt.samples):0}function kt(tt){let $=a.render.frame;d.get(tt)!==$&&(d.set(tt,$),tt.update())}function ie(tt,$){let It=tt.encoding,$t=tt.format,he=tt.type;return tt.isCompressedTexture===!0||tt.isVideoTexture===!0||tt.format===aU||It!==Qd&&(It===Yn?s===!1?t.has("EXT_sRGB")===!0&&$t===Qo?(tt.format=aU,tt.minFilter=oi,tt.generateMipmaps=!1):$=Kf.sRGBToLinear($):($t!==Qo||he!==Zd)&&console.warn("THREE.WebGLTextures: sRGB encoded textures have to use RGBAFormat and UnsignedByteType."):console.error("THREE.WebGLTextures: Unsupported texture encoding:",It)),$}let ee=!1,Le=!1;function ar(tt,$){tt&&tt.isWebGLRenderTarget&&(ee===!1&&(console.warn("THREE.WebGLTextures.safeSetTexture2D: don't use render targets as textures. Use their .texture property instead."),ee=!0),tt=tt.texture),W(tt,$)}function fr(tt,$){tt&&tt.isWebGLCubeRenderTarget&&(Le===!1&&(console.warn("THREE.WebGLTextures.safeSetTextureCube: don't use cube render targets as textures. Use their .texture property instead."),Le=!0),tt=tt.texture),ot(tt,$)}this.allocateTextureUnit=U,this.resetTextureUnits=z,this.setTexture2D=W,this.setTexture2DArray=Z,this.setTexture3D=rt,this.setTextureCube=ot,this.rebindTextures=dt,this.setupRenderTarget=q,this.updateRenderTargetMipmap=pt,this.updateMultisampleRenderTarget=ht,this.setupDepthRenderbuffer=et,this.setupFrameBufferTexture=_t,this.safeSetTexture2D=ar,this.safeSetTextureCube=fr}function Xfe(e,t,r){let n=r.isWebGL2;function i(o,a=null){let s;if(o===Zd)return 5121;if(o===pfe)return 32819;if(o===dfe)return 32820;if(o===ufe)return 5120;if(o===hfe)return 5122;if(o===G3)return 5123;if(o===ffe)return 5124;if(o===HP)return 5125;if(o===jd)return 5126;if(o===Cv)return n?5131:(s=t.get("OES_texture_half_float"),s!==null?s.HALF_FLOAT_OES:null);if(o===mfe)return 6406;if(o===Qo)return 6408;if(o===gfe)return 6409;if(o===_fe)return 6410;if(o===z0)return 6402;if(o===kv)return 34041;if(o===yfe)return 6403;if(o===aU)return s=t.get("EXT_sRGB"),s!==null?s.SRGB_ALPHA_EXT:null;if(o===vfe)return 36244;if(o===xfe)return 33319;if(o===bfe)return 33320;if(o===wfe)return 36249;if(o===ZV||o===JV||o===QV||o===tU)if(a===Yn)if(s=t.get("WEBGL_compressed_texture_s3tc_srgb"),s!==null){if(o===ZV)return s.COMPRESSED_SRGB_S3TC_DXT1_EXT;if(o===JV)return s.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;if(o===QV)return s.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;if(o===tU)return s.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT}else return null;else if(s=t.get("WEBGL_compressed_texture_s3tc"),s!==null){if(o===ZV)return s.COMPRESSED_RGB_S3TC_DXT1_EXT;if(o===JV)return s.COMPRESSED_RGBA_S3TC_DXT1_EXT;if(o===QV)return s.COMPRESSED_RGBA_S3TC_DXT3_EXT;if(o===tU)return s.COMPRESSED_RGBA_S3TC_DXT5_EXT}else return null;if(o===Iut||o===Lut||o===kut||o===Rut)if(s=t.get("WEBGL_compressed_texture_pvrtc"),s!==null){if(o===Iut)return s.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;if(o===Lut)return s.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;if(o===kut)return s.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;if(o===Rut)return s.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG}else return null;if(o===Sfe)return s=t.get("WEBGL_compressed_texture_etc1"),s!==null?s.COMPRESSED_RGB_ETC1_WEBGL:null;if(o===Nut||o===Dut)if(s=t.get("WEBGL_compressed_texture_etc"),s!==null){if(o===Nut)return a===Yn?s.COMPRESSED_SRGB8_ETC2:s.COMPRESSED_RGB8_ETC2;if(o===Dut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:s.COMPRESSED_RGBA8_ETC2_EAC}else return null;if(o===Out||o===zut||o===Fut||o===But||o===Hut||o===Vut||o===Uut||o===qut||o===Gut||o===Wut||o===Yut||o===jut||o===Xut||o===$ut)if(s=t.get("WEBGL_compressed_texture_astc"),s!==null){if(o===Out)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:s.COMPRESSED_RGBA_ASTC_4x4_KHR;if(o===zut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:s.COMPRESSED_RGBA_ASTC_5x4_KHR;if(o===Fut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:s.COMPRESSED_RGBA_ASTC_5x5_KHR;if(o===But)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:s.COMPRESSED_RGBA_ASTC_6x5_KHR;if(o===Hut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:s.COMPRESSED_RGBA_ASTC_6x6_KHR;if(o===Vut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:s.COMPRESSED_RGBA_ASTC_8x5_KHR;if(o===Uut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:s.COMPRESSED_RGBA_ASTC_8x6_KHR;if(o===qut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:s.COMPRESSED_RGBA_ASTC_8x8_KHR;if(o===Gut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:s.COMPRESSED_RGBA_ASTC_10x5_KHR;if(o===Wut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:s.COMPRESSED_RGBA_ASTC_10x6_KHR;if(o===Yut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:s.COMPRESSED_RGBA_ASTC_10x8_KHR;if(o===jut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:s.COMPRESSED_RGBA_ASTC_10x10_KHR;if(o===Xut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:s.COMPRESSED_RGBA_ASTC_12x10_KHR;if(o===$ut)return a===Yn?s.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:s.COMPRESSED_RGBA_ASTC_12x12_KHR}else return null;if(o===Kut)if(s=t.get("EXT_texture_compression_bptc"),s!==null){if(o===Kut)return a===Yn?s.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT:s.COMPRESSED_RGBA_BPTC_UNORM_EXT}else return null;if(o===Av)return n?34042:(s=t.get("WEBGL_depth_texture"),s!==null?s.UNSIGNED_INT_24_8_WEBGL:null)}return{convert:i}}var r6=class extends Ui{constructor(t=[]){super(),this.cameras=t}};r6.prototype.isArrayCamera=!0;var Xd=class extends or{constructor(){super(),this.type="Group"}};Xd.prototype.isGroup=!0;var Cgr={type:"move"},UP=class{constructor(){this._targetRay=null,this._grip=null,this._hand=null}getHandSpace(){return this._hand===null&&(this._hand=new Xd,this._hand.matrixAutoUpdate=!1,this._hand.visible=!1,this._hand.joints={},this._hand.inputState={pinching:!1}),this._hand}getTargetRaySpace(){return this._targetRay===null&&(this._targetRay=new Xd,this._targetRay.matrixAutoUpdate=!1,this._targetRay.visible=!1,this._targetRay.hasLinearVelocity=!1,this._targetRay.linearVelocity=new j,this._targetRay.hasAngularVelocity=!1,this._targetRay.angularVelocity=new j),this._targetRay}getGripSpace(){return this._grip===null&&(this._grip=new Xd,this._grip.matrixAutoUpdate=!1,this._grip.visible=!1,this._grip.hasLinearVelocity=!1,this._grip.linearVelocity=new j,this._grip.hasAngularVelocity=!1,this._grip.angularVelocity=new j),this._grip}dispatchEvent(t){return this._targetRay!==null&&this._targetRay.dispatchEvent(t),this._grip!==null&&this._grip.dispatchEvent(t),this._hand!==null&&this._hand.dispatchEvent(t),this}disconnect(t){return this.dispatchEvent({type:"disconnected",data:t}),this._targetRay!==null&&(this._targetRay.visible=!1),this._grip!==null&&(this._grip.visible=!1),this._hand!==null&&(this._hand.visible=!1),this}update(t,r,n){let i=null,o=null,a=null,s=this._targetRay,l=this._grip,c=this._hand;if(t&&r.session.visibilityState!=="visible-blurred")if(s!==null&&(i=r.getPose(t.targetRaySpace,n),i!==null&&(s.matrix.fromArray(i.transform.matrix),s.matrix.decompose(s.position,s.rotation,s.scale),i.linearVelocity?(s.hasLinearVelocity=!0,s.linearVelocity.copy(i.linearVelocity)):s.hasLinearVelocity=!1,i.angularVelocity?(s.hasAngularVelocity=!0,s.angularVelocity.copy(i.angularVelocity)):s.hasAngularVelocity=!1,this.dispatchEvent(Cgr))),c&&t.hand){a=!0;for(let g of t.hand.values()){let _=r.getJointPose(g,n);if(c.joints[g.jointName]===void 0){let x=new Xd;x.matrixAutoUpdate=!1,x.visible=!1,c.joints[g.jointName]=x,c.add(x)}let y=c.joints[g.jointName];_!==null&&(y.matrix.fromArray(_.transform.matrix),y.matrix.decompose(y.position,y.rotation,y.scale),y.jointRadius=_.radius),y.visible=_!==null}let u=c.joints["index-finger-tip"],h=c.joints["thumb-tip"],f=u.position.distanceTo(h.position),p=.02,d=.005;c.inputState.pinching&&f>p+d?(c.inputState.pinching=!1,this.dispatchEvent({type:"pinchend",handedness:t.handedness,target:this})):!c.inputState.pinching&&f<=p-d&&(c.inputState.pinching=!0,this.dispatchEvent({type:"pinchstart",handedness:t.handedness,target:this}))}else l!==null&&t.gripSpace&&(o=r.getPose(t.gripSpace,n),o!==null&&(l.matrix.fromArray(o.transform.matrix),l.matrix.decompose(l.position,l.rotation,l.scale),o.linearVelocity?(l.hasLinearVelocity=!0,l.linearVelocity.copy(o.linearVelocity)):l.hasLinearVelocity=!1,o.angularVelocity?(l.hasAngularVelocity=!0,l.angularVelocity.copy(o.angularVelocity)):l.hasAngularVelocity=!1));return s!==null&&(s.visible=i!==null),l!==null&&(l.visible=o!==null),c!==null&&(c.visible=a!==null),this}},nM=class extends xi{constructor(t,r,n,i,o,a,s,l,c,u){if(u=u!==void 0?u:z0,u!==z0&&u!==kv)throw new Error("DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat");n===void 0&&u===z0&&(n=G3),n===void 0&&u===kv&&(n=Av),super(null,i,o,a,s,l,u,n,c),this.image={width:t,height:r},this.magFilter=s!==void 0?s:Li,this.minFilter=l!==void 0?l:Li,this.flipY=!1,this.generateMipmaps=!1}};nM.prototype.isDepthTexture=!0;var rht=class extends Us{constructor(t,r){super();let n=this,i=null,o=1,a=null,s="local-floor",l=t.extensions.has("WEBGL_multisampled_render_to_texture"),c=null,u=null,h=null,f=null,p=!1,d=null,g=r.getContextAttributes(),_=null,y=null,x=[],b=new Map,S=new Ui;S.layers.enable(1),S.viewport=new en;let C=new Ui;C.layers.enable(2),C.viewport=new en;let P=[S,C],k=new r6;k.layers.enable(1),k.layers.enable(2);let O=null,D=null;this.cameraAutoUpdate=!0,this.enabled=!1,this.isPresenting=!1,this.getController=function(ot){let st=x[ot];return st===void 0&&(st=new UP,x[ot]=st),st.getTargetRaySpace()},this.getControllerGrip=function(ot){let st=x[ot];return st===void 0&&(st=new UP,x[ot]=st),st.getGripSpace()},this.getHand=function(ot){let st=x[ot];return st===void 0&&(st=new UP,x[ot]=st),st.getHandSpace()};function B(ot){let st=b.get(ot.inputSource);st&&st.dispatchEvent({type:ot.type,data:ot.inputSource})}function I(){b.forEach(function(ot,st){ot.disconnect(st)}),b.clear(),O=null,D=null,t.setRenderTarget(_),f=null,h=null,u=null,i=null,y=null,rt.stop(),n.isPresenting=!1,n.dispatchEvent({type:"sessionend"})}this.setFramebufferScaleFactor=function(ot){o=ot,n.isPresenting===!0&&console.warn("THREE.WebXRManager: Cannot change framebuffer scale while presenting.")},this.setReferenceSpaceType=function(ot){s=ot,n.isPresenting===!0&&console.warn("THREE.WebXRManager: Cannot change reference space type while presenting.")},this.getReferenceSpace=function(){return a},this.getBaseLayer=function(){return h!==null?h:f},this.getBinding=function(){return u},this.getFrame=function(){return d},this.getSession=function(){return i},this.setSession=function(ot){return Ri(this,null,function*(){if(i=ot,i!==null){if(_=t.getRenderTarget(),i.addEventListener("select",B),i.addEventListener("selectstart",B),i.addEventListener("selectend",B),i.addEventListener("squeeze",B),i.addEventListener("squeezestart",B),i.addEventListener("squeezeend",B),i.addEventListener("end",I),i.addEventListener("inputsourceschange",L),g.xrCompatible!==!0&&(yield r.makeXRCompatible()),i.renderState.layers===void 0||t.capabilities.isWebGL2===!1){let st={antialias:i.renderState.layers===void 0?g.antialias:!0,alpha:g.alpha,depth:g.depth,stencil:g.stencil,framebufferScaleFactor:o};f=new XRWebGLLayer(i,r,st),i.updateRenderState({baseLayer:f}),y=new us(f.framebufferWidth,f.framebufferHeight,{format:Qo,type:Zd,encoding:t.outputEncoding})}else{p=g.antialias;let st=null,St=null,bt=null;g.depth&&(bt=g.stencil?35056:33190,st=g.stencil?kv:z0,St=g.stencil?Av:G3);let Mt={colorFormat:t.outputEncoding===Yn?35907:32856,depthFormat:bt,scaleFactor:o};u=new XRWebGLBinding(i,r),h=u.createProjectionLayer(Mt),i.updateRenderState({layers:[h]}),p?y=new j3(h.textureWidth,h.textureHeight,{format:Qo,type:Zd,depthTexture:new nM(h.textureWidth,h.textureHeight,St,void 0,void 0,void 0,void 0,void 0,void 0,st),stencilBuffer:g.stencil,ignoreDepth:h.ignoreDepthValues,useRenderToTexture:l,encoding:t.outputEncoding}):y=new us(h.textureWidth,h.textureHeight,{format:Qo,type:Zd,depthTexture:new nM(h.textureWidth,h.textureHeight,St,void 0,void 0,void 0,void 0,void 0,void 0,st),stencilBuffer:g.stencil,ignoreDepth:h.ignoreDepthValues,encoding:t.outputEncoding})}y.isXRRenderTarget=!0,this.setFoveation(1),a=yield i.requestReferenceSpace(s),rt.setContext(i),rt.start(),n.isPresenting=!0,n.dispatchEvent({type:"sessionstart"})}})};function L(ot){let st=i.inputSources;for(let St=0;St<x.length;St++)b.set(st[St],x[St]);for(let St=0;St<ot.removed.length;St++){let bt=ot.removed[St],Mt=b.get(bt);Mt&&(Mt.dispatchEvent({type:"disconnected",data:bt}),b.delete(bt))}for(let St=0;St<ot.added.length;St++){let bt=ot.added[St],Mt=b.get(bt);Mt&&Mt.dispatchEvent({type:"connected",data:bt})}}let R=new j,F=new j;function z(ot,st,St){R.setFromMatrixPosition(st.matrixWorld),F.setFromMatrixPosition(St.matrixWorld);let bt=R.distanceTo(F),Mt=st.projectionMatrix.elements,lt=St.projectionMatrix.elements,Kt=Mt[14]/(Mt[10]-1),_t=Mt[14]/(Mt[10]+1),ct=(Mt[9]+1)/Mt[5],X=(Mt[9]-1)/Mt[5],et=(Mt[8]-1)/Mt[0],dt=(lt[8]+1)/lt[0],q=Kt*et,pt=Kt*dt,ht=bt/(-et+dt),wt=ht*-et;st.matrixWorld.decompose(ot.position,ot.quaternion,ot.scale),ot.translateX(wt),ot.translateZ(ht),ot.matrixWorld.compose(ot.position,ot.quaternion,ot.scale),ot.matrixWorldInverse.copy(ot.matrixWorld).invert();let kt=Kt+ht,ie=_t+ht,ee=q-wt,Le=pt+(bt-wt),ar=ct*_t/ie*kt,fr=X*_t/ie*kt;ot.projectionMatrix.makePerspective(ee,Le,ar,fr,kt,ie)}function U(ot,st){st===null?ot.matrixWorld.copy(ot.matrix):ot.matrixWorld.multiplyMatrices(st.matrixWorld,ot.matrix),ot.matrixWorldInverse.copy(ot.matrixWorld).invert()}this.updateCamera=function(ot){if(i===null)return;k.near=C.near=S.near=ot.near,k.far=C.far=S.far=ot.far,(O!==k.near||D!==k.far)&&(i.updateRenderState({depthNear:k.near,depthFar:k.far}),O=k.near,D=k.far);let st=ot.parent,St=k.cameras;U(k,st);for(let Mt=0;Mt<St.length;Mt++)U(St[Mt],st);k.matrixWorld.decompose(k.position,k.quaternion,k.scale),ot.position.copy(k.position),ot.quaternion.copy(k.quaternion),ot.scale.copy(k.scale),ot.matrix.copy(k.matrix),ot.matrixWorld.copy(k.matrixWorld);let bt=ot.children;for(let Mt=0,lt=bt.length;Mt<lt;Mt++)bt[Mt].updateMatrixWorld(!0);St.length===2?z(k,S,C):k.projectionMatrix.copy(S.projectionMatrix)},this.getCamera=function(){return k},this.getFoveation=function(){if(h!==null)return h.fixedFoveation;if(f!==null)return f.fixedFoveation},this.setFoveation=function(ot){h!==null&&(h.fixedFoveation=ot),f!==null&&f.fixedFoveation!==void 0&&(f.fixedFoveation=ot)};let W=null;function Z(ot,st){if(c=st.getViewerPose(a),d=st,c!==null){let bt=c.views;f!==null&&(t.setRenderTargetFramebuffer(y,f.framebuffer),t.setRenderTarget(y));let Mt=!1;bt.length!==k.cameras.length&&(k.cameras.length=0,Mt=!0);for(let lt=0;lt<bt.length;lt++){let Kt=bt[lt],_t=null;if(f!==null)_t=f.getViewport(Kt);else{let X=u.getViewSubImage(h,Kt);_t=X.viewport,lt===0&&(t.setRenderTargetTextures(y,X.colorTexture,h.ignoreDepthValues?void 0:X.depthStencilTexture),t.setRenderTarget(y))}let ct=P[lt];ct.matrix.fromArray(Kt.transform.matrix),ct.projectionMatrix.fromArray(Kt.projectionMatrix),ct.viewport.set(_t.x,_t.y,_t.width,_t.height),lt===0&&k.matrix.copy(ct.matrix),Mt===!0&&k.cameras.push(ct)}}let St=i.inputSources;for(let bt=0;bt<x.length;bt++){let Mt=x[bt],lt=St[bt];Mt.update(lt,st,a)}W&&W(ot,st),d=null}let rt=new zfe;rt.setAnimationLoop(Z),this.setAnimationLoop=function(ot){W=ot},this.dispose=function(){}}};function Agr(e){function t(y,x){y.fogColor.value.copy(x.color),x.isFog?(y.fogNear.value=x.near,y.fogFar.value=x.far):x.isFogExp2&&(y.fogDensity.value=x.density)}function r(y,x,b,S,C){x.isMeshBasicMaterial?n(y,x):x.isMeshLambertMaterial?(n(y,x),l(y,x)):x.isMeshToonMaterial?(n(y,x),u(y,x)):x.isMeshPhongMaterial?(n(y,x),c(y,x)):x.isMeshStandardMaterial?(n(y,x),x.isMeshPhysicalMaterial?f(y,x,C):h(y,x)):x.isMeshMatcapMaterial?(n(y,x),p(y,x)):x.isMeshDepthMaterial?(n(y,x),d(y,x)):x.isMeshDistanceMaterial?(n(y,x),g(y,x)):x.isMeshNormalMaterial?(n(y,x),_(y,x)):x.isLineBasicMaterial?(i(y,x),x.isLineDashedMaterial&&o(y,x)):x.isPointsMaterial?a(y,x,b,S):x.isSpriteMaterial?s(y,x):x.isShadowMaterial?(y.color.value.copy(x.color),y.opacity.value=x.opacity):x.isShaderMaterial&&(x.uniformsNeedUpdate=!1)}function n(y,x){y.opacity.value=x.opacity,x.color&&y.diffuse.value.copy(x.color),x.emissive&&y.emissive.value.copy(x.emissive).multiplyScalar(x.emissiveIntensity),x.map&&(y.map.value=x.map),x.alphaMap&&(y.alphaMap.value=x.alphaMap),x.specularMap&&(y.specularMap.value=x.specularMap),x.alphaTest>0&&(y.alphaTest.value=x.alphaTest);let b=e.get(x).envMap;b&&(y.envMap.value=b,y.flipEnvMap.value=b.isCubeTexture&&b.isRenderTargetTexture===!1?-1:1,y.reflectivity.value=x.reflectivity,y.ior.value=x.ior,y.refractionRatio.value=x.refractionRatio),x.lightMap&&(y.lightMap.value=x.lightMap,y.lightMapIntensity.value=x.lightMapIntensity),x.aoMap&&(y.aoMap.value=x.aoMap,y.aoMapIntensity.value=x.aoMapIntensity);let S;x.map?S=x.map:x.specularMap?S=x.specularMap:x.displacementMap?S=x.displacementMap:x.normalMap?S=x.normalMap:x.bumpMap?S=x.bumpMap:x.roughnessMap?S=x.roughnessMap:x.metalnessMap?S=x.metalnessMap:x.alphaMap?S=x.alphaMap:x.emissiveMap?S=x.emissiveMap:x.clearcoatMap?S=x.clearcoatMap:x.clearcoatNormalMap?S=x.clearcoatNormalMap:x.clearcoatRoughnessMap?S=x.clearcoatRoughnessMap:x.specularIntensityMap?S=x.specularIntensityMap:x.specularColorMap?S=x.specularColorMap:x.transmissionMap?S=x.transmissionMap:x.thicknessMap?S=x.thicknessMap:x.sheenColorMap?S=x.sheenColorMap:x.sheenRoughnessMap&&(S=x.sheenRoughnessMap),S!==void 0&&(S.isWebGLRenderTarget&&(S=S.texture),S.matrixAutoUpdate===!0&&S.updateMatrix(),y.uvTransform.value.copy(S.matrix));let C;x.aoMap?C=x.aoMap:x.lightMap&&(C=x.lightMap),C!==void 0&&(C.isWebGLRenderTarget&&(C=C.texture),C.matrixAutoUpdate===!0&&C.updateMatrix(),y.uv2Transform.value.copy(C.matrix))}function i(y,x){y.diffuse.value.copy(x.color),y.opacity.value=x.opacity}function o(y,x){y.dashSize.value=x.dashSize,y.totalSize.value=x.dashSize+x.gapSize,y.scale.value=x.scale}function a(y,x,b,S){y.diffuse.value.copy(x.color),y.opacity.value=x.opacity,y.size.value=x.size*b,y.scale.value=S*.5,x.map&&(y.map.value=x.map),x.alphaMap&&(y.alphaMap.value=x.alphaMap),x.alphaTest>0&&(y.alphaTest.value=x.alphaTest);let C;x.map?C=x.map:x.alphaMap&&(C=x.alphaMap),C!==void 0&&(C.matrixAutoUpdate===!0&&C.updateMatrix(),y.uvTransform.value.copy(C.matrix))}function s(y,x){y.diffuse.value.copy(x.color),y.opacity.value=x.opacity,y.rotation.value=x.rotation,x.map&&(y.map.value=x.map),x.alphaMap&&(y.alphaMap.value=x.alphaMap),x.alphaTest>0&&(y.alphaTest.value=x.alphaTest);let b;x.map?b=x.map:x.alphaMap&&(b=x.alphaMap),b!==void 0&&(b.matrixAutoUpdate===!0&&b.updateMatrix(),y.uvTransform.value.copy(b.matrix))}function l(y,x){x.emissiveMap&&(y.emissiveMap.value=x.emissiveMap)}function c(y,x){y.specular.value.copy(x.specular),y.shininess.value=Math.max(x.shininess,1e-4),x.emissiveMap&&(y.emissiveMap.value=x.emissiveMap),x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===Ii&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===Ii&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}function u(y,x){x.gradientMap&&(y.gradientMap.value=x.gradientMap),x.emissiveMap&&(y.emissiveMap.value=x.emissiveMap),x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===Ii&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===Ii&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}function h(y,x){y.roughness.value=x.roughness,y.metalness.value=x.metalness,x.roughnessMap&&(y.roughnessMap.value=x.roughnessMap),x.metalnessMap&&(y.metalnessMap.value=x.metalnessMap),x.emissiveMap&&(y.emissiveMap.value=x.emissiveMap),x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===Ii&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===Ii&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias),e.get(x).envMap&&(y.envMapIntensity.value=x.envMapIntensity)}function f(y,x,b){h(y,x),y.ior.value=x.ior,x.sheen>0&&(y.sheenColor.value.copy(x.sheenColor).multiplyScalar(x.sheen),y.sheenRoughness.value=x.sheenRoughness,x.sheenColorMap&&(y.sheenColorMap.value=x.sheenColorMap),x.sheenRoughnessMap&&(y.sheenRoughnessMap.value=x.sheenRoughnessMap)),x.clearcoat>0&&(y.clearcoat.value=x.clearcoat,y.clearcoatRoughness.value=x.clearcoatRoughness,x.clearcoatMap&&(y.clearcoatMap.value=x.clearcoatMap),x.clearcoatRoughnessMap&&(y.clearcoatRoughnessMap.value=x.clearcoatRoughnessMap),x.clearcoatNormalMap&&(y.clearcoatNormalScale.value.copy(x.clearcoatNormalScale),y.clearcoatNormalMap.value=x.clearcoatNormalMap,x.side===Ii&&y.clearcoatNormalScale.value.negate())),x.transmission>0&&(y.transmission.value=x.transmission,y.transmissionSamplerMap.value=b.texture,y.transmissionSamplerSize.value.set(b.width,b.height),x.transmissionMap&&(y.transmissionMap.value=x.transmissionMap),y.thickness.value=x.thickness,x.thicknessMap&&(y.thicknessMap.value=x.thicknessMap),y.attenuationDistance.value=x.attenuationDistance,y.attenuationColor.value.copy(x.attenuationColor)),y.specularIntensity.value=x.specularIntensity,y.specularColor.value.copy(x.specularColor),x.specularIntensityMap&&(y.specularIntensityMap.value=x.specularIntensityMap),x.specularColorMap&&(y.specularColorMap.value=x.specularColorMap)}function p(y,x){x.matcap&&(y.matcap.value=x.matcap),x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===Ii&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===Ii&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}function d(y,x){x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}function g(y,x){x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias),y.referencePosition.value.copy(x.referencePosition),y.nearDistance.value=x.nearDistance,y.farDistance.value=x.farDistance}function _(y,x){x.bumpMap&&(y.bumpMap.value=x.bumpMap,y.bumpScale.value=x.bumpScale,x.side===Ii&&(y.bumpScale.value*=-1)),x.normalMap&&(y.normalMap.value=x.normalMap,y.normalScale.value.copy(x.normalScale),x.side===Ii&&y.normalScale.value.negate()),x.displacementMap&&(y.displacementMap.value=x.displacementMap,y.displacementScale.value=x.displacementScale,y.displacementBias.value=x.displacementBias)}return{refreshFogUniforms:t,refreshMaterialUniforms:r}}function Pgr(){let e=QP("canvas");return e.style.display="block",e}function rn(e={}){let t=e.canvas!==void 0?e.canvas:Pgr(),r=e.context!==void 0?e.context:null,n=e.alpha!==void 0?e.alpha:!1,i=e.depth!==void 0?e.depth:!0,o=e.stencil!==void 0?e.stencil:!0,a=e.antialias!==void 0?e.antialias:!1,s=e.premultipliedAlpha!==void 0?e.premultipliedAlpha:!0,l=e.preserveDrawingBuffer!==void 0?e.preserveDrawingBuffer:!1,c=e.powerPreference!==void 0?e.powerPreference:"default",u=e.failIfMajorPerformanceCaveat!==void 0?e.failIfMajorPerformanceCaveat:!1,h=null,f=null,p=[],d=[];this.domElement=t,this.debug={checkShaderErrors:!0},this.autoClear=!0,this.autoClearColor=!0,this.autoClearDepth=!0,this.autoClearStencil=!0,this.sortObjects=!0,this.clippingPlanes=[],this.localClippingEnabled=!1,this.outputEncoding=Qd,this.physicallyCorrectLights=!1,this.toneMapping=Kd,this.toneMappingExposure=1;let g=this,_=!1,y=0,x=0,b=null,S=-1,C=null,P=new en,k=new en,O=null,D=t.width,B=t.height,I=1,L=null,R=null,F=new en(0,0,D,B),z=new en(0,0,D,B),U=!1,W=new Nv,Z=!1,rt=!1,ot=null,st=new Me,St=new j,bt={background:null,fog:null,environment:null,overrideMaterial:null,isScene:!0};function Mt(){return b===null?I:1}let lt=r;function Kt(K,gt){for(let Et=0;Et<K.length;Et++){let xt=K[Et],Ft=t.getContext(xt,gt);if(Ft!==null)return Ft}return null}try{let K={alpha:!0,depth:i,stencil:o,antialias:a,premultipliedAlpha:s,preserveDrawingBuffer:l,powerPreference:c,failIfMajorPerformanceCaveat:u};if("setAttribute"in t&&t.setAttribute("data-engine",`three.js r${YU}`),t.addEventListener("webglcontextlost",fe,!1),t.addEventListener("webglcontextrestored",at,!1),lt===null){let gt=["webgl2","webgl","experimental-webgl"];if(g.isWebGL1Renderer===!0&&gt.shift(),lt=Kt(gt,K),lt===null)throw Kt(gt)?new Error("Error creating WebGL context with your selected attributes."):new Error("Error creating WebGL context.")}lt.getShaderPrecisionFormat===void 0&&(lt.getShaderPrecisionFormat=function(){return{rangeMin:1,rangeMax:1,precision:1}})}catch(K){throw console.error("THREE.WebGLRenderer: "+K.message),K}let _t,ct,X,et,dt,q,pt,ht,wt,kt,ie,ee,Le,ar,fr,tt,$,It,$t,he,Tt,be,nt;function Ct(){_t=new Jdr(lt),ct=new Ydr(lt,_t,e),_t.init(ct),be=new Xfe(lt,_t,ct),X=new Egr(lt,_t,ct),et=new emr(lt),dt=new dgr,q=new Tgr(lt,_t,X,dt,ct,be,et),pt=new Xdr(g),ht=new Zdr(g),wt=new gfr(lt,ct),nt=new Gdr(lt,_t,wt,ct),kt=new Qdr(lt,wt,et,nt),ie=new omr(lt,kt,wt,et),$t=new imr(lt,ct,q),tt=new jdr(dt),ee=new pgr(g,pt,ht,_t,ct,nt,tt),Le=new Agr(dt),ar=new ggr,fr=new wgr(_t,ct),It=new qdr(g,pt,X,ie,n,s),$=new jfe(g,ie,ct),he=new Wdr(lt,_t,et,ct),Tt=new tmr(lt,_t,et,ct),et.programs=ee.programs,g.capabilities=ct,g.extensions=_t,g.properties=dt,g.renderLists=ar,g.shadowMap=$,g.state=X,g.info=et}Ct();let Wt=new rht(g,lt);this.xr=Wt,this.getContext=function(){return lt},this.getContextAttributes=function(){return lt.getContextAttributes()},this.forceContextLoss=function(){let K=_t.get("WEBGL_lose_context");K&&K.loseContext()},this.forceContextRestore=function(){let K=_t.get("WEBGL_lose_context");K&&K.restoreContext()},this.getPixelRatio=function(){return I},this.setPixelRatio=function(K){K!==void 0&&(I=K,this.setSize(D,B,!1))},this.getSize=function(K){return K.set(D,B)},this.setSize=function(K,gt,Et){if(Wt.isPresenting){console.warn("THREE.WebGLRenderer: Can't change size while VR device is presenting.");return}D=K,B=gt,t.width=Math.floor(K*I),t.height=Math.floor(gt*I),Et!==!1&&(t.style.width=K+"px",t.style.height=gt+"px"),this.setViewport(0,0,K,gt)},this.getDrawingBufferSize=function(K){return K.set(D*I,B*I).floor()},this.setDrawingBufferSize=function(K,gt,Et){D=K,B=gt,I=Et,t.width=Math.floor(K*Et),t.height=Math.floor(gt*Et),this.setViewport(0,0,K,gt)},this.getCurrentViewport=function(K){return K.copy(P)},this.getViewport=function(K){return K.copy(F)},this.setViewport=function(K,gt,Et,xt){K.isVector4?F.set(K.x,K.y,K.z,K.w):F.set(K,gt,Et,xt),X.viewport(P.copy(F).multiplyScalar(I).floor())},this.getScissor=function(K){return K.copy(z)},this.setScissor=function(K,gt,Et,xt){K.isVector4?z.set(K.x,K.y,K.z,K.w):z.set(K,gt,Et,xt),X.scissor(k.copy(z).multiplyScalar(I).floor())},this.getScissorTest=function(){return U},this.setScissorTest=function(K){X.setScissorTest(U=K)},this.setOpaqueSort=function(K){L=K},this.setTransparentSort=function(K){R=K},this.getClearColor=function(K){return K.copy(It.getClearColor())},this.setClearColor=function(){It.setClearColor.apply(It,arguments)},this.getClearAlpha=function(){return It.getClearAlpha()},this.setClearAlpha=function(){It.setClearAlpha.apply(It,arguments)},this.clear=function(K,gt,Et){let xt=0;(K===void 0||K)&&(xt|=16384),(gt===void 0||gt)&&(xt|=256),(Et===void 0||Et)&&(xt|=1024),lt.clear(xt)},this.clearColor=function(){this.clear(!0,!1,!1)},this.clearDepth=function(){this.clear(!1,!0,!1)},this.clearStencil=function(){this.clear(!1,!1,!0)},this.dispose=function(){t.removeEventListener("webglcontextlost",fe,!1),t.removeEventListener("webglcontextrestored",at,!1),ar.dispose(),fr.dispose(),dt.dispose(),pt.dispose(),ht.dispose(),ie.dispose(),nt.dispose(),ee.dispose(),Wt.dispose(),Wt.removeEventListener("sessionstart",ze),Wt.removeEventListener("sessionend",yn),ot&&(ot.dispose(),ot=null),Wi.stop()};function fe(K){K.preventDefault(),console.log("THREE.WebGLRenderer: Context Lost."),_=!0}function at(){console.log("THREE.WebGLRenderer: Context Restored."),_=!1;let K=et.autoReset,gt=$.enabled,Et=$.autoUpdate,xt=$.needsUpdate,Ft=$.type;Ct(),et.autoReset=K,$.enabled=gt,$.autoUpdate=Et,$.needsUpdate=xt,$.type=Ft}function se(K){let gt=K.target;gt.removeEventListener("dispose",se),Qt(gt)}function Qt(K){Ce(K),dt.remove(K)}function Ce(K){let gt=dt.get(K).programs;gt!==void 0&&(gt.forEach(function(Et){ee.releaseProgram(Et)}),K.isShaderMaterial&&ee.releaseShaderCache(K))}this.renderBufferDirect=function(K,gt,Et,xt,Ft,Ve){gt===null&&(gt=bt);let Ue=Ft.isMesh&&Ft.matrixWorld.determinant()<0,tr=cn(K,gt,Et,xt,Ft);X.setMaterial(xt,Ue);let Ke=Et.index,Xr=Et.attributes.position;if(Ke===null){if(Xr===void 0||Xr.count===0)return}else if(Ke.count===0)return;let _r=1;xt.wireframe===!0&&(Ke=kt.getWireframeAttribute(Et),_r=2),nt.setup(Ft,xt,tr,Et,Ke);let Pr,Xn=he;Ke!==null&&(Pr=wt.get(Ke),Xn=Tt,Xn.setIndex(Pr));let np=Ke!==null?Ke.count:Xr.count,um=Et.drawRange.start*_r,mr=Et.drawRange.count*_r,Fl=Ve!==null?Ve.start*_r:0,$n=Ve!==null?Ve.count*_r:1/0,Bl=Math.max(um,Fl),ux=Math.min(np,um+mr,Fl+$n)-1,Hl=Math.max(0,ux-Bl+1);if(Hl!==0){if(Ft.isMesh)xt.wireframe===!0?(X.setLineWidth(xt.wireframeLinewidth*Mt()),Xn.setMode(1)):Xn.setMode(4);else if(Ft.isLine){let Vl=xt.linewidth;Vl===void 0&&(Vl=1),X.setLineWidth(Vl*Mt()),Ft.isLineSegments?Xn.setMode(1):Ft.isLineLoop?Xn.setMode(2):Xn.setMode(3)}else Ft.isPoints?Xn.setMode(0):Ft.isSprite&&Xn.setMode(4);if(Ft.isInstancedMesh)Xn.renderInstances(Bl,Hl,Ft.count);else if(Et.isInstancedBufferGeometry){let Vl=Math.min(Et.instanceCount,Et._maxInstanceCount);Xn.renderInstances(Bl,Hl,Vl)}else Xn.render(Bl,Hl)}},this.compile=function(K,gt){f=fr.get(K),f.init(),d.push(f),K.traverseVisible(function(Et){Et.isLight&&Et.layers.test(gt.layers)&&(f.pushLight(Et),Et.castShadow&&f.pushShadow(Et))}),f.setupLights(g.physicallyCorrectLights),K.traverse(function(Et){let xt=Et.material;if(xt)if(Array.isArray(xt))for(let Ft=0;Ft<xt.length;Ft++){let Ve=xt[Ft];cm(Ve,K,Et)}else cm(xt,K,Et)}),d.pop(),f=null};let Pt=null;function Nt(K){Pt&&Pt(K)}function ze(){Wi.stop()}function yn(){Wi.start()}let Wi=new zfe;Wi.setAnimationLoop(Nt),typeof window!="undefined"&&Wi.setContext(window),this.setAnimationLoop=function(K){Pt=K,Wt.setAnimationLoop(K),K===null?Wi.stop():Wi.start()},Wt.addEventListener("sessionstart",ze),Wt.addEventListener("sessionend",yn),this.render=function(K,gt){if(gt!==void 0&&gt.isCamera!==!0){console.error("THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.");return}if(_===!0)return;K.autoUpdate===!0&&K.updateMatrixWorld(),gt.parent===null&&gt.updateMatrixWorld(),Wt.enabled===!0&&Wt.isPresenting===!0&&(Wt.cameraAutoUpdate===!0&&Wt.updateCamera(gt),gt=Wt.getCamera()),K.isScene===!0&&K.onBeforeRender(g,K,gt,b),f=fr.get(K,d.length),f.init(),d.push(f),st.multiplyMatrices(gt.projectionMatrix,gt.matrixWorldInverse),W.setFromProjectionMatrix(st),rt=this.localClippingEnabled,Z=tt.init(this.clippingPlanes,rt,gt),h=ar.get(K,p.length),h.init(),p.push(h),Ar(K,gt,0,g.sortObjects),h.finish(),g.sortObjects===!0&&h.sort(L,R),Z===!0&&tt.beginShadows();let Et=f.state.shadowsArray;if($.render(Et,K,gt),Z===!0&&tt.endShadows(),this.info.autoReset===!0&&this.info.reset(),It.render(h,K),f.setupLights(g.physicallyCorrectLights),gt.isArrayCamera){let xt=gt.cameras;for(let Ft=0,Ve=xt.length;Ft<Ve;Ft++){let Ue=xt[Ft];Pa(h,K,Ue,Ue.viewport)}}else Pa(h,K,gt);b!==null&&(q.updateMultisampleRenderTarget(b),q.updateRenderTargetMipmap(b)),K.isScene===!0&&K.onAfterRender(g,K,gt),X.buffers.depth.setTest(!0),X.buffers.depth.setMask(!0),X.buffers.color.setMask(!0),X.setPolygonOffset(!1),nt.resetDefaultState(),S=-1,C=null,d.pop(),d.length>0?f=d[d.length-1]:f=null,p.pop(),p.length>0?h=p[p.length-1]:h=null};function Ar(K,gt,Et,xt){if(K.visible===!1)return;if(K.layers.test(gt.layers)){if(K.isGroup)Et=K.renderOrder;else if(K.isLOD)K.autoUpdate===!0&&K.update(gt);else if(K.isLight)f.pushLight(K),K.castShadow&&f.pushShadow(K);else if(K.isSprite){if(!K.frustumCulled||W.intersectsSprite(K)){xt&&St.setFromMatrixPosition(K.matrixWorld).applyMatrix4(st);let Ue=ie.update(K),tr=K.material;tr.visible&&h.push(K,Ue,tr,Et,St.z,null)}}else if((K.isMesh||K.isLine||K.isPoints)&&(K.isSkinnedMesh&&K.skeleton.frame!==et.render.frame&&(K.skeleton.update(),K.skeleton.frame=et.render.frame),!K.frustumCulled||W.intersectsObject(K))){xt&&St.setFromMatrixPosition(K.matrixWorld).applyMatrix4(st);let Ue=ie.update(K),tr=K.material;if(Array.isArray(tr)){let Ke=Ue.groups;for(let Xr=0,_r=Ke.length;Xr<_r;Xr++){let Pr=Ke[Xr],Xn=tr[Pr.materialIndex];Xn&&Xn.visible&&h.push(K,Ue,Xn,Et,St.z,Pr)}}else tr.visible&&h.push(K,Ue,tr,Et,St.z,null)}}let Ve=K.children;for(let Ue=0,tr=Ve.length;Ue<tr;Ue++)Ar(Ve[Ue],gt,Et,xt)}function Pa(K,gt,Et,xt){let Ft=K.opaque,Ve=K.transmissive,Ue=K.transparent;f.setupLightsView(Et),Ve.length>0&&ho(Ft,gt,Et),xt&&X.viewport(P.copy(xt)),Ft.length>0&&Ia(Ft,gt,Et),Ve.length>0&&Ia(Ve,gt,Et),Ue.length>0&&Ia(Ue,gt,Et)}function ho(K,gt,Et){if(ot===null){let Ue=a===!0&&ct.isWebGL2===!0?j3:us;ot=new Ue(1024,1024,{generateMipmaps:!0,type:be.convert(Cv)!==null?Cv:Zd,minFilter:ox,magFilter:Li,wrapS:Jo,wrapT:Jo,useRenderToTexture:_t.has("WEBGL_multisampled_render_to_texture")})}let xt=g.getRenderTarget();g.setRenderTarget(ot),g.clear();let Ft=g.toneMapping;g.toneMapping=Kd,Ia(K,gt,Et),g.toneMapping=Ft,q.updateMultisampleRenderTarget(ot),q.updateRenderTargetMipmap(ot),g.setRenderTarget(xt)}function Ia(K,gt,Et){let xt=gt.isScene===!0?gt.overrideMaterial:null;for(let Ft=0,Ve=K.length;Ft<Ve;Ft++){let Ue=K[Ft],tr=Ue.object,Ke=Ue.geometry,Xr=xt===null?Ue.material:xt,_r=Ue.group;tr.layers.test(Et.layers)&&lx(tr,gt,Et,Ke,Xr,_r)}}function lx(K,gt,Et,xt,Ft,Ve){K.onBeforeRender(g,gt,Et,xt,Ft,Ve),K.modelViewMatrix.multiplyMatrices(Et.matrixWorldInverse,K.matrixWorld),K.normalMatrix.getNormalMatrix(K.modelViewMatrix),Ft.onBeforeRender(g,gt,Et,xt,K,Ve),Ft.transparent===!0&&Ft.side===Lv?(Ft.side=Ii,Ft.needsUpdate=!0,g.renderBufferDirect(Et,gt,xt,Ft,K,Ve),Ft.side=Iv,Ft.needsUpdate=!0,g.renderBufferDirect(Et,gt,xt,Ft,K,Ve),Ft.side=Lv):g.renderBufferDirect(Et,gt,xt,Ft,K,Ve),K.onAfterRender(g,gt,Et,xt,Ft,Ve)}function cm(K,gt,Et){gt.isScene!==!0&&(gt=bt);let xt=dt.get(K),Ft=f.state.lights,Ve=f.state.shadowsArray,Ue=Ft.state.version,tr=ee.getParameters(K,Ft.state,Ve,gt,Et),Ke=ee.getProgramCacheKey(tr),Xr=xt.programs;xt.environment=K.isMeshStandardMaterial?gt.environment:null,xt.fog=gt.fog,xt.envMap=(K.isMeshStandardMaterial?ht:pt).get(K.envMap||xt.environment),Xr===void 0&&(K.addEventListener("dispose",se),Xr=new Map,xt.programs=Xr);let _r=Xr.get(Ke);if(_r!==void 0){if(xt.currentProgram===_r&&xt.lightsStateVersion===Ue)return J0(K,tr),_r}else tr.uniforms=ee.getUniforms(K),K.onBuild(Et,tr,g),K.onBeforeCompile(tr,g),_r=ee.acquireProgram(tr,Ke),Xr.set(Ke,_r),xt.uniforms=tr.uniforms;let Pr=xt.uniforms;(!K.isShaderMaterial&&!K.isRawShaderMaterial||K.clipping===!0)&&(Pr.clippingPlanes=tt.uniform),J0(K,tr),xt.needsLights=rp(K),xt.lightsStateVersion=Ue,xt.needsLights&&(Pr.ambientLightColor.value=Ft.state.ambient,Pr.lightProbe.value=Ft.state.probe,Pr.directionalLights.value=Ft.state.directional,Pr.directionalLightShadows.value=Ft.state.directionalShadow,Pr.spotLights.value=Ft.state.spot,Pr.spotLightShadows.value=Ft.state.spotShadow,Pr.rectAreaLights.value=Ft.state.rectArea,Pr.ltc_1.value=Ft.state.rectAreaLTC1,Pr.ltc_2.value=Ft.state.rectAreaLTC2,Pr.pointLights.value=Ft.state.point,Pr.pointLightShadows.value=Ft.state.pointShadow,Pr.hemisphereLights.value=Ft.state.hemi,Pr.directionalShadowMap.value=Ft.state.directionalShadowMap,Pr.directionalShadowMatrix.value=Ft.state.directionalShadowMatrix,Pr.spotShadowMap.value=Ft.state.spotShadowMap,Pr.spotShadowMatrix.value=Ft.state.spotShadowMatrix,Pr.pointShadowMap.value=Ft.state.pointShadowMap,Pr.pointShadowMatrix.value=Ft.state.pointShadowMatrix);let Xn=_r.getUniforms(),np=B0.seqWithValue(Xn.seq,Pr);return xt.currentProgram=_r,xt.uniformsList=np,_r}function J0(K,gt){let Et=dt.get(K);Et.outputEncoding=gt.outputEncoding,Et.instancing=gt.instancing,Et.skinning=gt.skinning,Et.morphTargets=gt.morphTargets,Et.morphNormals=gt.morphNormals,Et.morphTargetsCount=gt.morphTargetsCount,Et.numClippingPlanes=gt.numClippingPlanes,Et.numIntersection=gt.numClipIntersection,Et.vertexAlphas=gt.vertexAlphas,Et.vertexTangents=gt.vertexTangents,Et.toneMapping=gt.toneMapping}function cn(K,gt,Et,xt,Ft){gt.isScene!==!0&&(gt=bt),q.resetTextureUnits();let Ve=gt.fog,Ue=xt.isMeshStandardMaterial?gt.environment:null,tr=b===null?g.outputEncoding:b.isXRRenderTarget===!0?b.texture.encoding:Qd,Ke=(xt.isMeshStandardMaterial?ht:pt).get(xt.envMap||Ue),Xr=xt.vertexColors===!0&&!!Et.attributes.color&&Et.attributes.color.itemSize===4,_r=!!xt.normalMap&&!!Et.attributes.tangent,Pr=!!Et.morphAttributes.position,Xn=!!Et.morphAttributes.normal,np=Et.morphAttributes.position?Et.morphAttributes.position.length:0,um=xt.toneMapped?g.toneMapping:Kd,mr=dt.get(xt),Fl=f.state.lights;if(Z===!0&&(rt===!0||K!==C)){let qs=K===C&&xt.id===S;tt.setState(xt,K,qs)}let $n=!1;xt.version===mr.__version?(mr.needsLights&&mr.lightsStateVersion!==Fl.state.version||mr.outputEncoding!==tr||Ft.isInstancedMesh&&mr.instancing===!1||!Ft.isInstancedMesh&&mr.instancing===!0||Ft.isSkinnedMesh&&mr.skinning===!1||!Ft.isSkinnedMesh&&mr.skinning===!0||mr.envMap!==Ke||xt.fog&&mr.fog!==Ve||mr.numClippingPlanes!==void 0&&(mr.numClippingPlanes!==tt.numPlanes||mr.numIntersection!==tt.numIntersection)||mr.vertexAlphas!==Xr||mr.vertexTangents!==_r||mr.morphTargets!==Pr||mr.morphNormals!==Xn||mr.toneMapping!==um||ct.isWebGL2===!0&&mr.morphTargetsCount!==np)&&($n=!0):($n=!0,mr.__version=xt.version);let Bl=mr.currentProgram;$n===!0&&(Bl=cm(xt,gt,Ft));let ux=!1,Hl=!1,Vl=!1,Yi=Bl.getUniforms(),hm=mr.uniforms;if(X.useProgram(Bl.program)&&(ux=!0,Hl=!0,Vl=!0),xt.id!==S&&(S=xt.id,Hl=!0),ux||C!==K){if(Yi.setValue(lt,"projectionMatrix",K.projectionMatrix),ct.logarithmicDepthBuffer&&Yi.setValue(lt,"logDepthBufFC",2/(Math.log(K.far+1)/Math.LN2)),C!==K&&(C=K,Hl=!0,Vl=!0),xt.isShaderMaterial||xt.isMeshPhongMaterial||xt.isMeshToonMaterial||xt.isMeshStandardMaterial||xt.envMap){let qs=Yi.map.cameraPosition;qs!==void 0&&qs.setValue(lt,St.setFromMatrixPosition(K.matrixWorld))}(xt.isMeshPhongMaterial||xt.isMeshToonMaterial||xt.isMeshLambertMaterial||xt.isMeshBasicMaterial||xt.isMeshStandardMaterial||xt.isShaderMaterial)&&Yi.setValue(lt,"isOrthographic",K.isOrthographicCamera===!0),(xt.isMeshPhongMaterial||xt.isMeshToonMaterial||xt.isMeshLambertMaterial||xt.isMeshBasicMaterial||xt.isMeshStandardMaterial||xt.isShaderMaterial||xt.isShadowMaterial||Ft.isSkinnedMesh)&&Yi.setValue(lt,"viewMatrix",K.matrixWorldInverse)}if(Ft.isSkinnedMesh){Yi.setOptional(lt,Ft,"bindMatrix"),Yi.setOptional(lt,Ft,"bindMatrixInverse");let qs=Ft.skeleton;qs&&(ct.floatVertexTextures?(qs.boneTexture===null&&qs.computeBoneTexture(),Yi.setValue(lt,"boneTexture",qs.boneTexture,q),Yi.setValue(lt,"boneTextureSize",qs.boneTextureSize)):Yi.setOptional(lt,qs,"boneMatrices"))}return!!Et&&(Et.morphAttributes.position!==void 0||Et.morphAttributes.normal!==void 0)&&$t.update(Ft,Et,xt,Bl),(Hl||mr.receiveShadow!==Ft.receiveShadow)&&(mr.receiveShadow=Ft.receiveShadow,Yi.setValue(lt,"receiveShadow",Ft.receiveShadow)),Hl&&(Yi.setValue(lt,"toneMappingExposure",g.toneMappingExposure),mr.needsLights&&cx(hm,Vl),Ve&&xt.fog&&Le.refreshFogUniforms(hm,Ve),Le.refreshMaterialUniforms(hm,xt,I,B,ot),B0.upload(lt,mr.uniformsList,hm,q)),xt.isShaderMaterial&&xt.uniformsNeedUpdate===!0&&(B0.upload(lt,mr.uniformsList,hm,q),xt.uniformsNeedUpdate=!1),xt.isSpriteMaterial&&Yi.setValue(lt,"center",Ft.center),Yi.setValue(lt,"modelViewMatrix",Ft.modelViewMatrix),Yi.setValue(lt,"normalMatrix",Ft.normalMatrix),Yi.setValue(lt,"modelMatrix",Ft.matrixWorld),Bl}function cx(K,gt){K.ambientLightColor.needsUpdate=gt,K.lightProbe.needsUpdate=gt,K.directionalLights.needsUpdate=gt,K.directionalLightShadows.needsUpdate=gt,K.pointLights.needsUpdate=gt,K.pointLightShadows.needsUpdate=gt,K.spotLights.needsUpdate=gt,K.spotLightShadows.needsUpdate=gt,K.rectAreaLights.needsUpdate=gt,K.hemisphereLights.needsUpdate=gt}function rp(K){return K.isMeshLambertMaterial||K.isMeshToonMaterial||K.isMeshPhongMaterial||K.isMeshStandardMaterial||K.isShadowMaterial||K.isShaderMaterial&&K.lights===!0}this.getActiveCubeFace=function(){return y},this.getActiveMipmapLevel=function(){return x},this.getRenderTarget=function(){return b},this.setRenderTargetTextures=function(K,gt,Et){dt.get(K.texture).__webglTexture=gt,dt.get(K.depthTexture).__webglTexture=Et;let xt=dt.get(K);xt.__hasExternalTextures=!0,xt.__hasExternalTextures&&(xt.__autoAllocateDepthBuffer=Et===void 0,xt.__autoAllocateDepthBuffer||K.useRenderToTexture&&(console.warn("render-to-texture extension was disabled because an external texture was provided"),K.useRenderToTexture=!1,K.useRenderbuffer=!0))},this.setRenderTargetFramebuffer=function(K,gt){let Et=dt.get(K);Et.__webglFramebuffer=gt,Et.__useDefaultFramebuffer=gt===void 0},this.setRenderTarget=function(K,gt=0,Et=0){b=K,y=gt,x=Et;let xt=!0;if(K){let Ke=dt.get(K);Ke.__useDefaultFramebuffer!==void 0?(X.bindFramebuffer(36160,null),xt=!1):Ke.__webglFramebuffer===void 0?q.setupRenderTarget(K):Ke.__hasExternalTextures&&q.rebindTextures(K,dt.get(K.texture).__webglTexture,dt.get(K.depthTexture).__webglTexture)}let Ft=null,Ve=!1,Ue=!1;if(K){let Ke=K.texture;(Ke.isDataTexture3D||Ke.isDataTexture2DArray)&&(Ue=!0);let Xr=dt.get(K).__webglFramebuffer;K.isWebGLCubeRenderTarget?(Ft=Xr[gt],Ve=!0):K.useRenderbuffer?Ft=dt.get(K).__webglMultisampledFramebuffer:Ft=Xr,P.copy(K.viewport),k.copy(K.scissor),O=K.scissorTest}else P.copy(F).multiplyScalar(I).floor(),k.copy(z).multiplyScalar(I).floor(),O=U;if(X.bindFramebuffer(36160,Ft)&&ct.drawBuffers&&xt&&X.drawBuffers(K,Ft),X.viewport(P),X.scissor(k),X.setScissorTest(O),Ve){let Ke=dt.get(K.texture);lt.framebufferTexture2D(36160,36064,34069+gt,Ke.__webglTexture,Et)}else if(Ue){let Ke=dt.get(K.texture),Xr=gt||0;lt.framebufferTextureLayer(36160,36064,Ke.__webglTexture,Et||0,Xr)}S=-1},this.readRenderTargetPixels=function(K,gt,Et,xt,Ft,Ve,Ue){if(!(K&&K.isWebGLRenderTarget)){console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.");return}let tr=dt.get(K).__webglFramebuffer;if(K.isWebGLCubeRenderTarget&&Ue!==void 0&&(tr=tr[Ue]),tr){X.bindFramebuffer(36160,tr);try{let Ke=K.texture,Xr=Ke.format,_r=Ke.type;if(Xr!==Qo&&be.convert(Xr)!==lt.getParameter(35739)){console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.");return}let Pr=_r===Cv&&(_t.has("EXT_color_buffer_half_float")||ct.isWebGL2&&_t.has("EXT_color_buffer_float"));if(_r!==Zd&&be.convert(_r)!==lt.getParameter(35738)&&!(_r===jd&&(ct.isWebGL2||_t.has("OES_texture_float")||_t.has("WEBGL_color_buffer_float")))&&!Pr){console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.");return}lt.checkFramebufferStatus(36160)===36053?gt>=0&&gt<=K.width-xt&&Et>=0&&Et<=K.height-Ft&&lt.readPixels(gt,Et,xt,Ft,be.convert(Xr),be.convert(_r),Ve):console.error("THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete.")}finally{let Ke=b!==null?dt.get(b).__webglFramebuffer:null;X.bindFramebuffer(36160,Ke)}}},this.copyFramebufferToTexture=function(K,gt,Et=0){if(gt.isFramebufferTexture!==!0){console.error("THREE.WebGLRenderer: copyFramebufferToTexture() can only be used with FramebufferTexture.");return}let xt=Math.pow(2,-Et),Ft=Math.floor(gt.image.width*xt),Ve=Math.floor(gt.image.height*xt);q.setTexture2D(gt,0),lt.copyTexSubImage2D(3553,Et,0,0,K.x,K.y,Ft,Ve),X.unbindTexture()},this.copyTextureToTexture=function(K,gt,Et,xt=0){let Ft=gt.image.width,Ve=gt.image.height,Ue=be.convert(Et.format),tr=be.convert(Et.type);q.setTexture2D(Et,0),lt.pixelStorei(37440,Et.flipY),lt.pixelStorei(37441,Et.premultiplyAlpha),lt.pixelStorei(3317,Et.unpackAlignment),gt.isDataTexture?lt.texSubImage2D(3553,xt,K.x,K.y,Ft,Ve,Ue,tr,gt.image.data):gt.isCompressedTexture?lt.compressedTexSubImage2D(3553,xt,K.x,K.y,gt.mipmaps[0].width,gt.mipmaps[0].height,Ue,gt.mipmaps[0].data):lt.texSubImage2D(3553,xt,K.x,K.y,Ue,tr,gt.image),xt===0&&Et.generateMipmaps&&lt.generateMipmap(3553),X.unbindTexture()},this.copyTextureToTexture3D=function(K,gt,Et,xt,Ft=0){if(g.isWebGL1Renderer){console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: can only be used with WebGL2.");return}let Ve=K.max.x-K.min.x+1,Ue=K.max.y-K.min.y+1,tr=K.max.z-K.min.z+1,Ke=be.convert(xt.format),Xr=be.convert(xt.type),_r;if(xt.isDataTexture3D)q.setTexture3D(xt,0),_r=32879;else if(xt.isDataTexture2DArray)q.setTexture2DArray(xt,0),_r=35866;else{console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: only supports THREE.DataTexture3D and THREE.DataTexture2DArray.");return}lt.pixelStorei(37440,xt.flipY),lt.pixelStorei(37441,xt.premultiplyAlpha),lt.pixelStorei(3317,xt.unpackAlignment);let Pr=lt.getParameter(3314),Xn=lt.getParameter(32878),np=lt.getParameter(3316),um=lt.getParameter(3315),mr=lt.getParameter(32877),Fl=Et.isCompressedTexture?Et.mipmaps[0]:Et.image;lt.pixelStorei(3314,Fl.width),lt.pixelStorei(32878,Fl.height),lt.pixelStorei(3316,K.min.x),lt.pixelStorei(3315,K.min.y),lt.pixelStorei(32877,K.min.z),Et.isDataTexture||Et.isDataTexture3D?lt.texSubImage3D(_r,Ft,gt.x,gt.y,gt.z,Ve,Ue,tr,Ke,Xr,Fl.data):Et.isCompressedTexture?(console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: untested support for compressed srcTexture."),lt.compressedTexSubImage3D(_r,Ft,gt.x,gt.y,gt.z,Ve,Ue,tr,Ke,Fl.data)):lt.texSubImage3D(_r,Ft,gt.x,gt.y,gt.z,Ve,Ue,tr,Ke,Xr,Fl),lt.pixelStorei(3314,Pr),lt.pixelStorei(32878,Xn),lt.pixelStorei(3316,np),lt.pixelStorei(3315,um),lt.pixelStorei(32877,mr),Ft===0&&xt.generateMipmaps&&lt.generateMipmap(_r),X.unbindTexture()},this.initTexture=function(K){q.setTexture2D(K,0),X.unbindTexture()},this.resetState=function(){y=0,x=0,b=null,X.reset(),nt.reset()},typeof __THREE_DEVTOOLS__!="undefined"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}rn.prototype.isWebGLRenderer=!0;var mU=class extends rn{};mU.prototype.isWebGL1Renderer=!0;var Ov=class{constructor(t,r=25e-5){this.name="",this.color=new ne(t),this.density=r}clone(){return new Ov(this.color,this.density)}toJSON(){return{type:"FogExp2",color:this.color.getHex(),density:this.density}}};Ov.prototype.isFogExp2=!0;var zv=class{constructor(t,r=1,n=1e3){this.name="",this.color=new ne(t),this.near=r,this.far=n}clone(){return new zv(this.color,this.near,this.far)}toJSON(){return{type:"Fog",color:this.color.getHex(),near:this.near,far:this.far}}};zv.prototype.isFog=!0;var q0=class extends or{constructor(){super(),this.type="Scene",this.background=null,this.environment=null,this.fog=null,this.overrideMaterial=null,this.autoUpdate=!0,typeof __THREE_DEVTOOLS__!="undefined"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}copy(t,r){return super.copy(t,r),t.background!==null&&(this.background=t.background.clone()),t.environment!==null&&(this.environment=t.environment.clone()),t.fog!==null&&(this.fog=t.fog.clone()),t.overrideMaterial!==null&&(this.overrideMaterial=t.overrideMaterial.clone()),this.autoUpdate=t.autoUpdate,this.matrixAutoUpdate=t.matrixAutoUpdate,this}toJSON(t){let r=super.toJSON(t);return this.fog!==null&&(r.object.fog=this.fog.toJSON()),r}};q0.prototype.isScene=!0;var em=class{constructor(t,r){this.array=t,this.stride=r,this.count=t!==void 0?t.length/r:0,this.usage=W3,this.updateRange={offset:0,count:-1},this.version=0,this.uuid=Nl()}onUploadCallback(){}set needsUpdate(t){t===!0&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.array=new t.array.constructor(t.array),this.count=t.count,this.stride=t.stride,this.usage=t.usage,this}copyAt(t,r,n){t*=this.stride,n*=r.stride;for(let i=0,o=this.stride;i<o;i++)this.array[t+i]=r.array[n+i];return this}set(t,r=0){return this.array.set(t,r),this}clone(t){t.arrayBuffers===void 0&&(t.arrayBuffers={}),this.array.buffer._uuid===void 0&&(this.array.buffer._uuid=Nl()),t.arrayBuffers[this.array.buffer._uuid]===void 0&&(t.arrayBuffers[this.array.buffer._uuid]=this.array.slice(0).buffer);let r=new this.array.constructor(t.arrayBuffers[this.array.buffer._uuid]),n=new this.constructor(r,this.stride);return n.setUsage(this.usage),n}onUpload(t){return this.onUploadCallback=t,this}toJSON(t){return t.arrayBuffers===void 0&&(t.arrayBuffers={}),this.array.buffer._uuid===void 0&&(this.array.buffer._uuid=Nl()),t.arrayBuffers[this.array.buffer._uuid]===void 0&&(t.arrayBuffers[this.array.buffer._uuid]=Array.prototype.slice.call(new Uint32Array(this.array.buffer))),{uuid:this.uuid,buffer:this.array.buffer._uuid,type:this.array.constructor.name,stride:this.stride}}};em.prototype.isInterleavedBuffer=!0;var Ai=new j,tp=class{constructor(t,r,n,i=!1){this.name="",this.data=t,this.itemSize=r,this.offset=n,this.normalized=i===!0}get count(){return this.data.count}get array(){return this.data.array}set needsUpdate(t){this.data.needsUpdate=t}applyMatrix4(t){for(let r=0,n=this.data.count;r<n;r++)Ai.x=this.getX(r),Ai.y=this.getY(r),Ai.z=this.getZ(r),Ai.applyMatrix4(t),this.setXYZ(r,Ai.x,Ai.y,Ai.z);return this}applyNormalMatrix(t){for(let r=0,n=this.count;r<n;r++)Ai.x=this.getX(r),Ai.y=this.getY(r),Ai.z=this.getZ(r),Ai.applyNormalMatrix(t),this.setXYZ(r,Ai.x,Ai.y,Ai.z);return this}transformDirection(t){for(let r=0,n=this.count;r<n;r++)Ai.x=this.getX(r),Ai.y=this.getY(r),Ai.z=this.getZ(r),Ai.transformDirection(t),this.setXYZ(r,Ai.x,Ai.y,Ai.z);return this}setX(t,r){return this.data.array[t*this.data.stride+this.offset]=r,this}setY(t,r){return this.data.array[t*this.data.stride+this.offset+1]=r,this}setZ(t,r){return this.data.array[t*this.data.stride+this.offset+2]=r,this}setW(t,r){return this.data.array[t*this.data.stride+this.offset+3]=r,this}getX(t){return this.data.array[t*this.data.stride+this.offset]}getY(t){return this.data.array[t*this.data.stride+this.offset+1]}getZ(t){return this.data.array[t*this.data.stride+this.offset+2]}getW(t){return this.data.array[t*this.data.stride+this.offset+3]}setXY(t,r,n){return t=t*this.data.stride+this.offset,this.data.array[t+0]=r,this.data.array[t+1]=n,this}setXYZ(t,r,n,i){return t=t*this.data.stride+this.offset,this.data.array[t+0]=r,this.data.array[t+1]=n,this.data.array[t+2]=i,this}setXYZW(t,r,n,i,o){return t=t*this.data.stride+this.offset,this.data.array[t+0]=r,this.data.array[t+1]=n,this.data.array[t+2]=i,this.data.array[t+3]=o,this}clone(t){if(t===void 0){console.log("THREE.InterleavedBufferAttribute.clone(): Cloning an interlaved buffer attribute will deinterleave buffer data.");let r=[];for(let n=0;n<this.count;n++){let i=n*this.data.stride+this.offset;for(let o=0;o<this.itemSize;o++)r.push(this.data.array[i+o])}return new Je(new this.array.constructor(r),this.itemSize,this.normalized)}else return t.interleavedBuffers===void 0&&(t.interleavedBuffers={}),t.interleavedBuffers[this.data.uuid]===void 0&&(t.interleavedBuffers[this.data.uuid]=this.data.clone(t)),new tp(t.interleavedBuffers[this.data.uuid],this.itemSize,this.offset,this.normalized)}toJSON(t){if(t===void 0){console.log("THREE.InterleavedBufferAttribute.toJSON(): Serializing an interlaved buffer attribute will deinterleave buffer data.");let r=[];for(let n=0;n<this.count;n++){let i=n*this.data.stride+this.offset;for(let o=0;o<this.itemSize;o++)r.push(this.data.array[i+o])}return{itemSize:this.itemSize,type:this.array.constructor.name,array:r,normalized:this.normalized}}else return t.interleavedBuffers===void 0&&(t.interleavedBuffers={}),t.interleavedBuffers[this.data.uuid]===void 0&&(t.interleavedBuffers[this.data.uuid]=this.data.toJSON(t)),{isInterleavedBufferAttribute:!0,itemSize:this.itemSize,data:this.data.uuid,offset:this.offset,normalized:this.normalized}}};tp.prototype.isInterleavedBufferAttribute=!0;var iM=class extends qi{constructor(t){super(),this.type="SpriteMaterial",this.color=new ne(16777215),this.map=null,this.alphaMap=null,this.rotation=0,this.sizeAttenuation=!0,this.transparent=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.rotation=t.rotation,this.sizeAttenuation=t.sizeAttenuation,this}};iM.prototype.isSpriteMaterial=!0;var N3,NP=new j,D3=new j,O3=new j,z3=new Lt,DP=new Lt,$fe=new Me,IV=new j,OP=new j,LV=new j,Yue=new Lt,mut=new Lt,jue=new Lt,oM=class extends or{constructor(t){if(super(),this.type="Sprite",N3===void 0){N3=new Pe;let r=new Float32Array([-.5,-.5,0,0,0,.5,-.5,0,1,0,.5,.5,0,1,1,-.5,.5,0,0,1]),n=new em(r,5);N3.setIndex([0,1,2,0,2,3]),N3.setAttribute("position",new tp(n,3,0,!1)),N3.setAttribute("uv",new tp(n,2,3,!1))}this.geometry=N3,this.material=t!==void 0?t:new iM,this.center=new Lt(.5,.5)}raycast(t,r){t.camera===null&&console.error('THREE.Sprite: "Raycaster.camera" needs to be set in order to raycast against sprites.'),D3.setFromMatrixScale(this.matrixWorld),$fe.copy(t.camera.matrixWorld),this.modelViewMatrix.multiplyMatrices(t.camera.matrixWorldInverse,this.matrixWorld),O3.setFromMatrixPosition(this.modelViewMatrix),t.camera.isPerspectiveCamera&&this.material.sizeAttenuation===!1&&D3.multiplyScalar(-O3.z);let n=this.material.rotation,i,o;n!==0&&(o=Math.cos(n),i=Math.sin(n));let a=this.center;kV(IV.set(-.5,-.5,0),O3,a,D3,i,o),kV(OP.set(.5,-.5,0),O3,a,D3,i,o),kV(LV.set(.5,.5,0),O3,a,D3,i,o),Yue.set(0,0),mut.set(1,0),jue.set(1,1);let s=t.ray.intersectTriangle(IV,OP,LV,!1,NP);if(s===null&&(kV(OP.set(-.5,.5,0),O3,a,D3,i,o),mut.set(0,1),s=t.ray.intersectTriangle(IV,LV,OP,!1,NP),s===null))return;let l=t.ray.origin.distanceTo(NP);l<t.near||l>t.far||r.push({distance:l,point:NP.clone(),uv:ai.getUV(NP,IV,OP,LV,Yue,mut,jue,new Lt),face:null,object:this})}copy(t){return super.copy(t),t.center!==void 0&&this.center.copy(t.center),this.material=t.material,this}};oM.prototype.isSprite=!0;function kV(e,t,r,n,i,o){z3.subVectors(e,r).addScalar(.5).multiply(n),i!==void 0?(DP.x=o*z3.x-i*z3.y,DP.y=i*z3.x+o*z3.y):DP.copy(z3),e.copy(t),e.x+=DP.x,e.y+=DP.y,e.applyMatrix4($fe)}var RV=new j,Xue=new j,gU=class extends or{constructor(){super(),this._currentLevel=0,this.type="LOD",Object.defineProperties(this,{levels:{enumerable:!0,value:[]},isLOD:{value:!0}}),this.autoUpdate=!0}copy(t){super.copy(t,!1);let r=t.levels;for(let n=0,i=r.length;n<i;n++){let o=r[n];this.addLevel(o.object.clone(),o.distance)}return this.autoUpdate=t.autoUpdate,this}addLevel(t,r=0){r=Math.abs(r);let n=this.levels,i;for(i=0;i<n.length&&!(r<n[i].distance);i++);return n.splice(i,0,{distance:r,object:t}),this.add(t),this}getCurrentLevel(){return this._currentLevel}getObjectForDistance(t){let r=this.levels;if(r.length>0){let n,i;for(n=1,i=r.length;n<i&&!(t<r[n].distance);n++);return r[n-1].object}return null}raycast(t,r){if(this.levels.length>0){RV.setFromMatrixPosition(this.matrixWorld);let i=t.ray.origin.distanceTo(RV);this.getObjectForDistance(i).raycast(t,r)}}update(t){let r=this.levels;if(r.length>1){RV.setFromMatrixPosition(t.matrixWorld),Xue.setFromMatrixPosition(this.matrixWorld);let n=RV.distanceTo(Xue)/t.zoom;r[0].object.visible=!0;let i,o;for(i=1,o=r.length;i<o&&n>=r[i].distance;i++)r[i-1].object.visible=!1,r[i].object.visible=!0;for(this._currentLevel=i-1;i<o;i++)r[i].object.visible=!1}}toJSON(t){let r=super.toJSON(t);this.autoUpdate===!1&&(r.object.autoUpdate=!1),r.object.levels=[];let n=this.levels;for(let i=0,o=n.length;i<o;i++){let a=n[i];r.object.levels.push({object:a.object.uuid,distance:a.distance})}return r}},$ue=new j,Kue=new en,Zue=new en,Igr=new j,Jue=new Me,aM=class extends ei{constructor(t,r){super(t,r),this.type="SkinnedMesh",this.bindMode="attached",this.bindMatrix=new Me,this.bindMatrixInverse=new Me}copy(t){return super.copy(t),this.bindMode=t.bindMode,this.bindMatrix.copy(t.bindMatrix),this.bindMatrixInverse.copy(t.bindMatrixInverse),this.skeleton=t.skeleton,this}bind(t,r){this.skeleton=t,r===void 0&&(this.updateMatrixWorld(!0),this.skeleton.calculateInverses(),r=this.matrixWorld),this.bindMatrix.copy(r),this.bindMatrixInverse.copy(r).invert()}pose(){this.skeleton.pose()}normalizeSkinWeights(){let t=new en,r=this.geometry.attributes.skinWeight;for(let n=0,i=r.count;n<i;n++){t.x=r.getX(n),t.y=r.getY(n),t.z=r.getZ(n),t.w=r.getW(n);let o=1/t.manhattanLength();o!==1/0?t.multiplyScalar(o):t.set(1,0,0,0),r.setXYZW(n,t.x,t.y,t.z,t.w)}}updateMatrixWorld(t){super.updateMatrixWorld(t),this.bindMode==="attached"?this.bindMatrixInverse.copy(this.matrixWorld).invert():this.bindMode==="detached"?this.bindMatrixInverse.copy(this.bindMatrix).invert():console.warn("THREE.SkinnedMesh: Unrecognized bindMode: "+this.bindMode)}boneTransform(t,r){let n=this.skeleton,i=this.geometry;Kue.fromBufferAttribute(i.attributes.skinIndex,t),Zue.fromBufferAttribute(i.attributes.skinWeight,t),$ue.copy(r).applyMatrix4(this.bindMatrix),r.set(0,0,0);for(let o=0;o<4;o++){let a=Zue.getComponent(o);if(a!==0){let s=Kue.getComponent(o);Jue.multiplyMatrices(n.bones[s].matrixWorld,n.boneInverses[s]),r.addScaledVector(Igr.copy($ue).applyMatrix4(Jue),a)}}return r.applyMatrix4(this.bindMatrixInverse)}};aM.prototype.isSkinnedMesh=!0;var sM=class extends or{constructor(){super(),this.type="Bone"}};sM.prototype.isBone=!0;var Jd=class extends xi{constructor(t=null,r=1,n=1,i,o,a,s,l,c=Li,u=Li,h,f){super(null,a,s,l,c,u,i,o,h,f),this.image={data:t,width:r,height:n},this.magFilter=c,this.minFilter=u,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};Jd.prototype.isDataTexture=!0;var Que=new Me,Lgr=new Me,lM=class{constructor(t=[],r=[]){this.uuid=Nl(),this.bones=t.slice(0),this.boneInverses=r,this.boneMatrices=null,this.boneTexture=null,this.boneTextureSize=0,this.frame=-1,this.init()}init(){let t=this.bones,r=this.boneInverses;if(this.boneMatrices=new Float32Array(t.length*16),r.length===0)this.calculateInverses();else if(t.length!==r.length){console.warn("THREE.Skeleton: Number of inverse bone matrices does not match amount of bones."),this.boneInverses=[];for(let n=0,i=this.bones.length;n<i;n++)this.boneInverses.push(new Me)}}calculateInverses(){this.boneInverses.length=0;for(let t=0,r=this.bones.length;t<r;t++){let n=new Me;this.bones[t]&&n.copy(this.bones[t].matrixWorld).invert(),this.boneInverses.push(n)}}pose(){for(let t=0,r=this.bones.length;t<r;t++){let n=this.bones[t];n&&n.matrixWorld.copy(this.boneInverses[t]).invert()}for(let t=0,r=this.bones.length;t<r;t++){let n=this.bones[t];n&&(n.parent&&n.parent.isBone?(n.matrix.copy(n.parent.matrixWorld).invert(),n.matrix.multiply(n.matrixWorld)):n.matrix.copy(n.matrixWorld),n.matrix.decompose(n.position,n.quaternion,n.scale))}}update(){let t=this.bones,r=this.boneInverses,n=this.boneMatrices,i=this.boneTexture;for(let o=0,a=t.length;o<a;o++){let s=t[o]?t[o].matrixWorld:Lgr;Que.multiplyMatrices(s,r[o]),Que.toArray(n,o*16)}i!==null&&(i.needsUpdate=!0)}clone(){return new lM(this.bones,this.boneInverses)}computeBoneTexture(){let t=Math.sqrt(this.bones.length*4);t=kfe(t),t=Math.max(t,4);let r=new Float32Array(t*t*4);r.set(this.boneMatrices);let n=new Jd(r,t,t,Qo,jd);return n.needsUpdate=!0,this.boneMatrices=r,this.boneTexture=n,this.boneTextureSize=t,this}getBoneByName(t){for(let r=0,n=this.bones.length;r<n;r++){let i=this.bones[r];if(i.name===t)return i}}dispose(){this.boneTexture!==null&&(this.boneTexture.dispose(),this.boneTexture=null)}fromJSON(t,r){this.uuid=t.uuid;for(let n=0,i=t.bones.length;n<i;n++){let o=t.bones[n],a=r[o];a===void 0&&(console.warn("THREE.Skeleton: No bone found with UUID:",o),a=new sM),this.bones.push(a),this.boneInverses.push(new Me().fromArray(t.boneInverses[n]))}return this.init(),this}toJSON(){let t={metadata:{version:4.5,type:"Skeleton",generator:"Skeleton.toJSON"},bones:[],boneInverses:[]};t.uuid=this.uuid;let r=this.bones,n=this.boneInverses;for(let i=0,o=r.length;i<o;i++){let a=r[i];t.bones.push(a.uuid);let s=n[i];t.boneInverses.push(s.toArray())}return t}},rm=class extends Je{constructor(t,r,n,i=1){typeof n=="number"&&(i=n,n=!1,console.error("THREE.InstancedBufferAttribute: The constructor now expects normalized as the third argument.")),super(t,r,n),this.meshPerAttribute=i}copy(t){return super.copy(t),this.meshPerAttribute=t.meshPerAttribute,this}toJSON(){let t=super.toJSON();return t.meshPerAttribute=this.meshPerAttribute,t.isInstancedBufferAttribute=!0,t}};rm.prototype.isInstancedBufferAttribute=!0;var the=new Me,ehe=new Me,NV=[],zP=new ei,n6=class extends ei{constructor(t,r,n){super(t,r),this.instanceMatrix=new rm(new Float32Array(n*16),16),this.instanceColor=null,this.count=n,this.frustumCulled=!1}copy(t){return super.copy(t),this.instanceMatrix.copy(t.instanceMatrix),t.instanceColor!==null&&(this.instanceColor=t.instanceColor.clone()),this.count=t.count,this}getColorAt(t,r){r.fromArray(this.instanceColor.array,t*3)}getMatrixAt(t,r){r.fromArray(this.instanceMatrix.array,t*16)}raycast(t,r){let n=this.matrixWorld,i=this.count;if(zP.geometry=this.geometry,zP.material=this.material,zP.material!==void 0)for(let o=0;o<i;o++){this.getMatrixAt(o,the),ehe.multiplyMatrices(n,the),zP.matrixWorld=ehe,zP.raycast(t,NV);for(let a=0,s=NV.length;a<s;a++){let l=NV[a];l.instanceId=o,l.object=this,r.push(l)}NV.length=0}}setColorAt(t,r){this.instanceColor===null&&(this.instanceColor=new rm(new Float32Array(this.instanceMatrix.count*3),3)),r.toArray(this.instanceColor.array,t*3)}setMatrixAt(t,r){r.toArray(this.instanceMatrix.array,t*16)}updateMorphTargets(){}dispose(){this.dispatchEvent({type:"dispose"})}};n6.prototype.isInstancedMesh=!0;var Gi=class extends qi{constructor(t){super(),this.type="LineBasicMaterial",this.color=new ne(16777215),this.linewidth=1,this.linecap="round",this.linejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.linewidth=t.linewidth,this.linecap=t.linecap,this.linejoin=t.linejoin,this}};Gi.prototype.isLineBasicMaterial=!0;var rhe=new j,nhe=new j,ihe=new Me,gut=new Jf,DV=new Zf,ch=class extends or{constructor(t=new Pe,r=new Gi){super(),this.type="Line",this.geometry=t,this.material=r,this.updateMorphTargets()}copy(t){return super.copy(t),this.material=t.material,this.geometry=t.geometry,this}computeLineDistances(){let t=this.geometry;if(t.isBufferGeometry)if(t.index===null){let r=t.attributes.position,n=[0];for(let i=1,o=r.count;i<o;i++)rhe.fromBufferAttribute(r,i-1),nhe.fromBufferAttribute(r,i),n[i]=n[i-1],n[i]+=rhe.distanceTo(nhe);t.setAttribute("lineDistance",new xe(n,1))}else console.warn("THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.Line.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}raycast(t,r){let n=this.geometry,i=this.matrixWorld,o=t.params.Line.threshold,a=n.drawRange;if(n.boundingSphere===null&&n.computeBoundingSphere(),DV.copy(n.boundingSphere),DV.applyMatrix4(i),DV.radius+=o,t.ray.intersectsSphere(DV)===!1)return;ihe.copy(i).invert(),gut.copy(t.ray).applyMatrix4(ihe);let s=o/((this.scale.x+this.scale.y+this.scale.z)/3),l=s*s,c=new j,u=new j,h=new j,f=new j,p=this.isLineSegments?2:1;if(n.isBufferGeometry){let d=n.index,_=n.attributes.position;if(d!==null){let y=Math.max(0,a.start),x=Math.min(d.count,a.start+a.count);for(let b=y,S=x-1;b<S;b+=p){let C=d.getX(b),P=d.getX(b+1);if(c.fromBufferAttribute(_,C),u.fromBufferAttribute(_,P),gut.distanceSqToSegment(c,u,f,h)>l)continue;f.applyMatrix4(this.matrixWorld);let O=t.ray.origin.distanceTo(f);O<t.near||O>t.far||r.push({distance:O,point:h.clone().applyMatrix4(this.matrixWorld),index:b,face:null,faceIndex:null,object:this})}}else{let y=Math.max(0,a.start),x=Math.min(_.count,a.start+a.count);for(let b=y,S=x-1;b<S;b+=p){if(c.fromBufferAttribute(_,b),u.fromBufferAttribute(_,b+1),gut.distanceSqToSegment(c,u,f,h)>l)continue;f.applyMatrix4(this.matrixWorld);let P=t.ray.origin.distanceTo(f);P<t.near||P>t.far||r.push({distance:P,point:h.clone().applyMatrix4(this.matrixWorld),index:b,face:null,faceIndex:null,object:this})}}}else n.isGeometry&&console.error("THREE.Line.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let r=t.morphAttributes,n=Object.keys(r);if(n.length>0){let i=r[n[0]];if(i!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let o=0,a=i.length;o<a;o++){let s=i[o].name||String(o);this.morphTargetInfluences.push(0),this.morphTargetDictionary[s]=o}}}}else{let r=t.morphTargets;r!==void 0&&r.length>0&&console.error("THREE.Line.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}};ch.prototype.isLine=!0;var ohe=new j,ahe=new j,Aa=class extends ch{constructor(t,r){super(t,r),this.type="LineSegments"}computeLineDistances(){let t=this.geometry;if(t.isBufferGeometry)if(t.index===null){let r=t.attributes.position,n=[];for(let i=0,o=r.count;i<o;i+=2)ohe.fromBufferAttribute(r,i),ahe.fromBufferAttribute(r,i+1),n[i]=i===0?0:n[i-1],n[i+1]=n[i]+ohe.distanceTo(ahe);t.setAttribute("lineDistance",new xe(n,1))}else console.warn("THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.LineSegments.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}};Aa.prototype.isLineSegments=!0;var i6=class extends ch{constructor(t,r){super(t,r),this.type="LineLoop"}};i6.prototype.isLineLoop=!0;var nm=class extends qi{constructor(t){super(),this.type="PointsMaterial",this.color=new ne(16777215),this.map=null,this.alphaMap=null,this.size=1,this.sizeAttenuation=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.size=t.size,this.sizeAttenuation=t.sizeAttenuation,this}};nm.prototype.isPointsMaterial=!0;var she=new Me,nht=new Jf,OV=new Zf,zV=new j,im=class extends or{constructor(t=new Pe,r=new nm){super(),this.type="Points",this.geometry=t,this.material=r,this.updateMorphTargets()}copy(t){return super.copy(t),this.material=t.material,this.geometry=t.geometry,this}raycast(t,r){let n=this.geometry,i=this.matrixWorld,o=t.params.Points.threshold,a=n.drawRange;if(n.boundingSphere===null&&n.computeBoundingSphere(),OV.copy(n.boundingSphere),OV.applyMatrix4(i),OV.radius+=o,t.ray.intersectsSphere(OV)===!1)return;she.copy(i).invert(),nht.copy(t.ray).applyMatrix4(she);let s=o/((this.scale.x+this.scale.y+this.scale.z)/3),l=s*s;if(n.isBufferGeometry){let c=n.index,h=n.attributes.position;if(c!==null){let f=Math.max(0,a.start),p=Math.min(c.count,a.start+a.count);for(let d=f,g=p;d<g;d++){let _=c.getX(d);zV.fromBufferAttribute(h,_),lhe(zV,_,l,i,t,r,this)}}else{let f=Math.max(0,a.start),p=Math.min(h.count,a.start+a.count);for(let d=f,g=p;d<g;d++)zV.fromBufferAttribute(h,d),lhe(zV,d,l,i,t,r,this)}}else console.error("THREE.Points.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let r=t.morphAttributes,n=Object.keys(r);if(n.length>0){let i=r[n[0]];if(i!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let o=0,a=i.length;o<a;o++){let s=i[o].name||String(o);this.morphTargetInfluences.push(0),this.morphTargetDictionary[s]=o}}}}else{let r=t.morphTargets;r!==void 0&&r.length>0&&console.error("THREE.Points.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}};im.prototype.isPoints=!0;function lhe(e,t,r,n,i,o,a){let s=nht.distanceSqToPoint(e);if(s<r){let l=new j;nht.closestPointToPoint(e,l),l.applyMatrix4(n);let c=i.ray.origin.distanceTo(l);if(c<i.near||c>i.far)return;o.push({distance:c,distanceToRay:Math.sqrt(s),point:l,index:t,face:null,object:a})}}var _U=class extends xi{constructor(t,r,n,i,o,a,s,l,c){super(t,r,n,i,o,a,s,l,c),this.minFilter=a!==void 0?a:oi,this.magFilter=o!==void 0?o:oi,this.generateMipmaps=!1;let u=this;function h(){u.needsUpdate=!0,t.requestVideoFrameCallback(h)}"requestVideoFrameCallback"in t&&t.requestVideoFrameCallback(h)}clone(){return new this.constructor(this.image).copy(this)}update(){let t=this.image;"requestVideoFrameCallback"in t===!1&&t.readyState>=t.HAVE_CURRENT_DATA&&(this.needsUpdate=!0)}};_U.prototype.isVideoTexture=!0;var yU=class extends xi{constructor(t,r,n){super({width:t,height:r}),this.format=n,this.magFilter=Li,this.minFilter=Li,this.generateMipmaps=!1,this.needsUpdate=!0}};yU.prototype.isFramebufferTexture=!0;var o6=class extends xi{constructor(t,r,n,i,o,a,s,l,c,u,h,f){super(null,a,s,l,c,u,i,o,h,f),this.image={width:r,height:n},this.mipmaps=t,this.flipY=!1,this.generateMipmaps=!1}};o6.prototype.isCompressedTexture=!0;var vU=class extends xi{constructor(t,r,n,i,o,a,s,l,c){super(t,r,n,i,o,a,s,l,c),this.needsUpdate=!0}};vU.prototype.isCanvasTexture=!0;var Fv=class extends Pe{constructor(t=1,r=8,n=0,i=Math.PI*2){super(),this.type="CircleGeometry",this.parameters={radius:t,segments:r,thetaStart:n,thetaLength:i},r=Math.max(3,r);let o=[],a=[],s=[],l=[],c=new j,u=new Lt;a.push(0,0,0),s.push(0,0,1),l.push(.5,.5);for(let h=0,f=3;h<=r;h++,f+=3){let p=n+h/r*i;c.x=t*Math.cos(p),c.y=t*Math.sin(p),a.push(c.x,c.y,c.z),s.push(0,0,1),u.x=(a[f]/t+1)/2,u.y=(a[f+1]/t+1)/2,l.push(u.x,u.y)}for(let h=1;h<=r;h++)o.push(h,h+1,0);this.setIndex(o),this.setAttribute("position",new xe(a,3)),this.setAttribute("normal",new xe(s,3)),this.setAttribute("uv",new xe(l,2))}static fromJSON(t){return new Fv(t.radius,t.segments,t.thetaStart,t.thetaLength)}},om=class extends Pe{constructor(t=1,r=1,n=1,i=8,o=1,a=!1,s=0,l=Math.PI*2){super(),this.type="CylinderGeometry",this.parameters={radiusTop:t,radiusBottom:r,height:n,radialSegments:i,heightSegments:o,openEnded:a,thetaStart:s,thetaLength:l};let c=this;i=Math.floor(i),o=Math.floor(o);let u=[],h=[],f=[],p=[],d=0,g=[],_=n/2,y=0;x(),a===!1&&(t>0&&b(!0),r>0&&b(!1)),this.setIndex(u),this.setAttribute("position",new xe(h,3)),this.setAttribute("normal",new xe(f,3)),this.setAttribute("uv",new xe(p,2));function x(){let S=new j,C=new j,P=0,k=(r-t)/n;for(let O=0;O<=o;O++){let D=[],B=O/o,I=B*(r-t)+t;for(let L=0;L<=i;L++){let R=L/i,F=R*l+s,z=Math.sin(F),U=Math.cos(F);C.x=I*z,C.y=-B*n+_,C.z=I*U,h.push(C.x,C.y,C.z),S.set(z,k,U).normalize(),f.push(S.x,S.y,S.z),p.push(R,1-B),D.push(d++)}g.push(D)}for(let O=0;O<i;O++)for(let D=0;D<o;D++){let B=g[D][O],I=g[D+1][O],L=g[D+1][O+1],R=g[D][O+1];u.push(B,I,R),u.push(I,L,R),P+=6}c.addGroup(y,P,0),y+=P}function b(S){let C=d,P=new Lt,k=new j,O=0,D=S===!0?t:r,B=S===!0?1:-1;for(let L=1;L<=i;L++)h.push(0,_*B,0),f.push(0,B,0),p.push(.5,.5),d++;let I=d;for(let L=0;L<=i;L++){let F=L/i*l+s,z=Math.cos(F),U=Math.sin(F);k.x=D*U,k.y=_*B,k.z=D*z,h.push(k.x,k.y,k.z),f.push(0,B,0),P.x=z*.5+.5,P.y=U*.5*B+.5,p.push(P.x,P.y),d++}for(let L=0;L<i;L++){let R=C+L,F=I+L;S===!0?u.push(F,F+1,R):u.push(F+1,F,R),O+=3}c.addGroup(y,O,S===!0?1:2),y+=O}}static fromJSON(t){return new om(t.radiusTop,t.radiusBottom,t.height,t.radialSegments,t.heightSegments,t.openEnded,t.thetaStart,t.thetaLength)}},Bv=class extends om{constructor(t=1,r=1,n=8,i=1,o=!1,a=0,s=Math.PI*2){super(0,t,r,n,i,o,a,s),this.type="ConeGeometry",this.parameters={radius:t,height:r,radialSegments:n,heightSegments:i,openEnded:o,thetaStart:a,thetaLength:s}}static fromJSON(t){return new Bv(t.radius,t.height,t.radialSegments,t.heightSegments,t.openEnded,t.thetaStart,t.thetaLength)}},uh=class extends Pe{constructor(t=[],r=[],n=1,i=0){super(),this.type="PolyhedronGeometry",this.parameters={vertices:t,indices:r,radius:n,detail:i};let o=[],a=[];s(i),c(n),u(),this.setAttribute("position",new xe(o,3)),this.setAttribute("normal",new xe(o.slice(),3)),this.setAttribute("uv",new xe(a,2)),i===0?this.computeVertexNormals():this.normalizeNormals();function s(x){let b=new j,S=new j,C=new j;for(let P=0;P<r.length;P+=3)p(r[P+0],b),p(r[P+1],S),p(r[P+2],C),l(b,S,C,x)}function l(x,b,S,C){let P=C+1,k=[];for(let O=0;O<=P;O++){k[O]=[];let D=x.clone().lerp(S,O/P),B=b.clone().lerp(S,O/P),I=P-O;for(let L=0;L<=I;L++)L===0&&O===P?k[O][L]=D:k[O][L]=D.clone().lerp(B,L/I)}for(let O=0;O<P;O++)for(let D=0;D<2*(P-O)-1;D++){let B=Math.floor(D/2);D%2===0?(f(k[O][B+1]),f(k[O+1][B]),f(k[O][B])):(f(k[O][B+1]),f(k[O+1][B+1]),f(k[O+1][B]))}}function c(x){let b=new j;for(let S=0;S<o.length;S+=3)b.x=o[S+0],b.y=o[S+1],b.z=o[S+2],b.normalize().multiplyScalar(x),o[S+0]=b.x,o[S+1]=b.y,o[S+2]=b.z}function u(){let x=new j;for(let b=0;b<o.length;b+=3){x.x=o[b+0],x.y=o[b+1],x.z=o[b+2];let S=_(x)/2/Math.PI+.5,C=y(x)/Math.PI+.5;a.push(S,1-C)}d(),h()}function h(){for(let x=0;x<a.length;x+=6){let b=a[x+0],S=a[x+2],C=a[x+4],P=Math.max(b,S,C),k=Math.min(b,S,C);P>.9&&k<.1&&(b<.2&&(a[x+0]+=1),S<.2&&(a[x+2]+=1),C<.2&&(a[x+4]+=1))}}function f(x){o.push(x.x,x.y,x.z)}function p(x,b){let S=x*3;b.x=t[S+0],b.y=t[S+1],b.z=t[S+2]}function d(){let x=new j,b=new j,S=new j,C=new j,P=new Lt,k=new Lt,O=new Lt;for(let D=0,B=0;D<o.length;D+=9,B+=6){x.set(o[D+0],o[D+1],o[D+2]),b.set(o[D+3],o[D+4],o[D+5]),S.set(o[D+6],o[D+7],o[D+8]),P.set(a[B+0],a[B+1]),k.set(a[B+2],a[B+3]),O.set(a[B+4],a[B+5]),C.copy(x).add(b).add(S).divideScalar(3);let I=_(C);g(P,B+0,x,I),g(k,B+2,b,I),g(O,B+4,S,I)}}function g(x,b,S,C){C<0&&x.x===1&&(a[b]=x.x-1),S.x===0&&S.z===0&&(a[b]=C/2/Math.PI+.5)}function _(x){return Math.atan2(x.z,-x.x)}function y(x){return Math.atan2(-x.y,Math.sqrt(x.x*x.x+x.z*x.z))}}static fromJSON(t){return new uh(t.vertices,t.indices,t.radius,t.details)}},Hv=class extends uh{constructor(t=1,r=0){let n=(1+Math.sqrt(5))/2,i=1/n,o=[-1,-1,-1,-1,-1,1,-1,1,-1,-1,1,1,1,-1,-1,1,-1,1,1,1,-1,1,1,1,0,-i,-n,0,-i,n,0,i,-n,0,i,n,-i,-n,0,-i,n,0,i,-n,0,i,n,0,-n,0,-i,n,0,-i,-n,0,i,n,0,i],a=[3,11,7,3,7,15,3,15,13,7,19,17,7,17,6,7,6,15,17,4,8,17,8,10,17,10,6,8,0,16,8,16,2,8,2,10,0,12,1,0,1,18,0,18,16,6,10,2,6,2,13,6,13,15,2,16,18,2,18,3,2,3,13,18,1,9,18,9,11,18,11,3,4,14,12,4,12,0,4,0,8,11,9,5,11,5,19,11,19,7,19,5,14,19,14,4,19,4,17,1,12,14,1,14,5,1,5,9];super(o,a,t,r),this.type="DodecahedronGeometry",this.parameters={radius:t,detail:r}}static fromJSON(t){return new Hv(t.radius,t.detail)}},FV=new j,BV=new j,_ut=new j,HV=new ai,a6=class extends Pe{constructor(t=null,r=1){if(super(),this.type="EdgesGeometry",this.parameters={geometry:t,thresholdAngle:r},t!==null){let i=Math.pow(10,4),o=Math.cos(Pv*r),a=t.getIndex(),s=t.getAttribute("position"),l=a?a.count:s.count,c=[0,0,0],u=["a","b","c"],h=new Array(3),f={},p=[];for(let d=0;d<l;d+=3){a?(c[0]=a.getX(d),c[1]=a.getX(d+1),c[2]=a.getX(d+2)):(c[0]=d,c[1]=d+1,c[2]=d+2);let{a:g,b:_,c:y}=HV;if(g.fromBufferAttribute(s,c[0]),_.fromBufferAttribute(s,c[1]),y.fromBufferAttribute(s,c[2]),HV.getNormal(_ut),h[0]=`${Math.round(g.x*i)},${Math.round(g.y*i)},${Math.round(g.z*i)}`,h[1]=`${Math.round(_.x*i)},${Math.round(_.y*i)},${Math.round(_.z*i)}`,h[2]=`${Math.round(y.x*i)},${Math.round(y.y*i)},${Math.round(y.z*i)}`,!(h[0]===h[1]||h[1]===h[2]||h[2]===h[0]))for(let x=0;x<3;x++){let b=(x+1)%3,S=h[x],C=h[b],P=HV[u[x]],k=HV[u[b]],O=`${S}_${C}`,D=`${C}_${S}`;D in f&&f[D]?(_ut.dot(f[D].normal)<=o&&(p.push(P.x,P.y,P.z),p.push(k.x,k.y,k.z)),f[D]=null):O in f||(f[O]={index0:c[x],index1:c[b],normal:_ut.clone()})}}for(let d in f)if(f[d]){let{index0:g,index1:_}=f[d];FV.fromBufferAttribute(s,g),BV.fromBufferAttribute(s,_),p.push(FV.x,FV.y,FV.z),p.push(BV.x,BV.y,BV.z)}this.setAttribute("position",new xe(p,3))}}},fs=class{constructor(){this.type="Curve",this.arcLengthDivisions=200}getPoint(){return console.warn("THREE.Curve: .getPoint() not implemented."),null}getPointAt(t,r){let n=this.getUtoTmapping(t);return this.getPoint(n,r)}getPoints(t=5){let r=[];for(let n=0;n<=t;n++)r.push(this.getPoint(n/t));return r}getSpacedPoints(t=5){let r=[];for(let n=0;n<=t;n++)r.push(this.getPointAt(n/t));return r}getLength(){let t=this.getLengths();return t[t.length-1]}getLengths(t=this.arcLengthDivisions){if(this.cacheArcLengths&&this.cacheArcLengths.length===t+1&&!this.needsUpdate)return this.cacheArcLengths;this.needsUpdate=!1;let r=[],n,i=this.getPoint(0),o=0;r.push(0);for(let a=1;a<=t;a++)n=this.getPoint(a/t),o+=n.distanceTo(i),r.push(o),i=n;return this.cacheArcLengths=r,r}updateArcLengths(){this.needsUpdate=!0,this.getLengths()}getUtoTmapping(t,r){let n=this.getLengths(),i=0,o=n.length,a;r?a=r:a=t*n[o-1];let s=0,l=o-1,c;for(;s<=l;)if(i=Math.floor(s+(l-s)/2),c=n[i]-a,c<0)s=i+1;else if(c>0)l=i-1;else{l=i;break}if(i=l,n[i]===a)return i/(o-1);let u=n[i],f=n[i+1]-u,p=(a-u)/f;return(i+p)/(o-1)}getTangent(t,r){let i=t-1e-4,o=t+1e-4;i<0&&(i=0),o>1&&(o=1);let a=this.getPoint(i),s=this.getPoint(o),l=r||(a.isVector2?new Lt:new j);return l.copy(s).sub(a).normalize(),l}getTangentAt(t,r){let n=this.getUtoTmapping(t);return this.getTangent(n,r)}computeFrenetFrames(t,r){let n=new j,i=[],o=[],a=[],s=new j,l=new Me;for(let p=0;p<=t;p++){let d=p/t;i[p]=this.getTangentAt(d,new j)}o[0]=new j,a[0]=new j;let c=Number.MAX_VALUE,u=Math.abs(i[0].x),h=Math.abs(i[0].y),f=Math.abs(i[0].z);u<=c&&(c=u,n.set(1,0,0)),h<=c&&(c=h,n.set(0,1,0)),f<=c&&n.set(0,0,1),s.crossVectors(i[0],n).normalize(),o[0].crossVectors(i[0],s),a[0].crossVectors(i[0],o[0]);for(let p=1;p<=t;p++){if(o[p]=o[p-1].clone(),a[p]=a[p-1].clone(),s.crossVectors(i[p-1],i[p]),s.length()>Number.EPSILON){s.normalize();let d=Math.acos(Zo(i[p-1].dot(i[p]),-1,1));o[p].applyMatrix4(l.makeRotationAxis(s,d))}a[p].crossVectors(i[p],o[p])}if(r===!0){let p=Math.acos(Zo(o[0].dot(o[t]),-1,1));p/=t,i[0].dot(s.crossVectors(o[0],o[t]))>0&&(p=-p);for(let d=1;d<=t;d++)o[d].applyMatrix4(l.makeRotationAxis(i[d],p*d)),a[d].crossVectors(i[d],o[d])}return{tangents:i,normals:o,binormals:a}}clone(){return new this.constructor().copy(this)}copy(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}toJSON(){let t={metadata:{version:4.5,type:"Curve",generator:"Curve.toJSON"}};return t.arcLengthDivisions=this.arcLengthDivisions,t.type=this.type,t}fromJSON(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}},Vv=class extends fs{constructor(t=0,r=0,n=1,i=1,o=0,a=Math.PI*2,s=!1,l=0){super(),this.type="EllipseCurve",this.aX=t,this.aY=r,this.xRadius=n,this.yRadius=i,this.aStartAngle=o,this.aEndAngle=a,this.aClockwise=s,this.aRotation=l}getPoint(t,r){let n=r||new Lt,i=Math.PI*2,o=this.aEndAngle-this.aStartAngle,a=Math.abs(o)<Number.EPSILON;for(;o<0;)o+=i;for(;o>i;)o-=i;o<Number.EPSILON&&(a?o=0:o=i),this.aClockwise===!0&&!a&&(o===i?o=-i:o=o-i);let s=this.aStartAngle+t*o,l=this.aX+this.xRadius*Math.cos(s),c=this.aY+this.yRadius*Math.sin(s);if(this.aRotation!==0){let u=Math.cos(this.aRotation),h=Math.sin(this.aRotation),f=l-this.aX,p=c-this.aY;l=f*u-p*h+this.aX,c=f*h+p*u+this.aY}return n.set(l,c)}copy(t){return super.copy(t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this}toJSON(){let t=super.toJSON();return t.aX=this.aX,t.aY=this.aY,t.xRadius=this.xRadius,t.yRadius=this.yRadius,t.aStartAngle=this.aStartAngle,t.aEndAngle=this.aEndAngle,t.aClockwise=this.aClockwise,t.aRotation=this.aRotation,t}fromJSON(t){return super.fromJSON(t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this}};Vv.prototype.isEllipseCurve=!0;var s6=class extends Vv{constructor(t,r,n,i,o,a){super(t,r,n,n,i,o,a),this.type="ArcCurve"}};s6.prototype.isArcCurve=!0;function Oht(){let e=0,t=0,r=0,n=0;function i(o,a,s,l){e=o,t=s,r=-3*o+3*a-2*s-l,n=2*o-2*a+s+l}return{initCatmullRom:function(o,a,s,l,c){i(a,s,c*(s-o),c*(l-a))},initNonuniformCatmullRom:function(o,a,s,l,c,u,h){let f=(a-o)/c-(s-o)/(c+u)+(s-a)/u,p=(s-a)/u-(l-a)/(u+h)+(l-s)/h;f*=u,p*=u,i(a,s,f,p)},calc:function(o){let a=o*o,s=a*o;return e+t*o+r*a+n*s}}}var VV=new j,yut=new Oht,vut=new Oht,xut=new Oht,l6=class extends fs{constructor(t=[],r=!1,n="centripetal",i=.5){super(),this.type="CatmullRomCurve3",this.points=t,this.closed=r,this.curveType=n,this.tension=i}getPoint(t,r=new j){let n=r,i=this.points,o=i.length,a=(o-(this.closed?0:1))*t,s=Math.floor(a),l=a-s;this.closed?s+=s>0?0:(Math.floor(Math.abs(s)/o)+1)*o:l===0&&s===o-1&&(s=o-2,l=1);let c,u;this.closed||s>0?c=i[(s-1)%o]:(VV.subVectors(i[0],i[1]).add(i[0]),c=VV);let h=i[s%o],f=i[(s+1)%o];if(this.closed||s+2<o?u=i[(s+2)%o]:(VV.subVectors(i[o-1],i[o-2]).add(i[o-1]),u=VV),this.curveType==="centripetal"||this.curveType==="chordal"){let p=this.curveType==="chordal"?.5:.25,d=Math.pow(c.distanceToSquared(h),p),g=Math.pow(h.distanceToSquared(f),p),_=Math.pow(f.distanceToSquared(u),p);g<1e-4&&(g=1),d<1e-4&&(d=g),_<1e-4&&(_=g),yut.initNonuniformCatmullRom(c.x,h.x,f.x,u.x,d,g,_),vut.initNonuniformCatmullRom(c.y,h.y,f.y,u.y,d,g,_),xut.initNonuniformCatmullRom(c.z,h.z,f.z,u.z,d,g,_)}else this.curveType==="catmullrom"&&(yut.initCatmullRom(c.x,h.x,f.x,u.x,this.tension),vut.initCatmullRom(c.y,h.y,f.y,u.y,this.tension),xut.initCatmullRom(c.z,h.z,f.z,u.z,this.tension));return n.set(yut.calc(l),vut.calc(l),xut.calc(l)),n}copy(t){super.copy(t),this.points=[];for(let r=0,n=t.points.length;r<n;r++){let i=t.points[r];this.points.push(i.clone())}return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this}toJSON(){let t=super.toJSON();t.points=[];for(let r=0,n=this.points.length;r<n;r++){let i=this.points[r];t.points.push(i.toArray())}return t.closed=this.closed,t.curveType=this.curveType,t.tension=this.tension,t}fromJSON(t){super.fromJSON(t),this.points=[];for(let r=0,n=t.points.length;r<n;r++){let i=t.points[r];this.points.push(new j().fromArray(i))}return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this}};l6.prototype.isCatmullRomCurve3=!0;function che(e,t,r,n,i){let o=(n-t)*.5,a=(i-r)*.5,s=e*e,l=e*s;return(2*r-2*n+o+a)*l+(-3*r+3*n-2*o-a)*s+o*e+r}function kgr(e,t){let r=1-e;return r*r*t}function Rgr(e,t){return 2*(1-e)*e*t}function Ngr(e,t){return e*e*t}function qP(e,t,r,n){return kgr(e,t)+Rgr(e,r)+Ngr(e,n)}function Dgr(e,t){let r=1-e;return r*r*r*t}function Ogr(e,t){let r=1-e;return 3*r*r*e*t}function zgr(e,t){return 3*(1-e)*e*e*t}function Fgr(e,t){return e*e*e*t}function GP(e,t,r,n,i){return Dgr(e,t)+Ogr(e,r)+zgr(e,n)+Fgr(e,i)}var cM=class extends fs{constructor(t=new Lt,r=new Lt,n=new Lt,i=new Lt){super(),this.type="CubicBezierCurve",this.v0=t,this.v1=r,this.v2=n,this.v3=i}getPoint(t,r=new Lt){let n=r,i=this.v0,o=this.v1,a=this.v2,s=this.v3;return n.set(GP(t,i.x,o.x,a.x,s.x),GP(t,i.y,o.y,a.y,s.y)),n}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this}};cM.prototype.isCubicBezierCurve=!0;var c6=class extends fs{constructor(t=new j,r=new j,n=new j,i=new j){super(),this.type="CubicBezierCurve3",this.v0=t,this.v1=r,this.v2=n,this.v3=i}getPoint(t,r=new j){let n=r,i=this.v0,o=this.v1,a=this.v2,s=this.v3;return n.set(GP(t,i.x,o.x,a.x,s.x),GP(t,i.y,o.y,a.y,s.y),GP(t,i.z,o.z,a.z,s.z)),n}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this}};c6.prototype.isCubicBezierCurve3=!0;var Uv=class extends fs{constructor(t=new Lt,r=new Lt){super(),this.type="LineCurve",this.v1=t,this.v2=r}getPoint(t,r=new Lt){let n=r;return t===1?n.copy(this.v2):(n.copy(this.v2).sub(this.v1),n.multiplyScalar(t).add(this.v1)),n}getPointAt(t,r){return this.getPoint(t,r)}getTangent(t,r){let n=r||new Lt;return n.copy(this.v2).sub(this.v1).normalize(),n}copy(t){return super.copy(t),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};Uv.prototype.isLineCurve=!0;var xU=class extends fs{constructor(t=new j,r=new j){super(),this.type="LineCurve3",this.isLineCurve3=!0,this.v1=t,this.v2=r}getPoint(t,r=new j){let n=r;return t===1?n.copy(this.v2):(n.copy(this.v2).sub(this.v1),n.multiplyScalar(t).add(this.v1)),n}getPointAt(t,r){return this.getPoint(t,r)}copy(t){return super.copy(t),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}},uM=class extends fs{constructor(t=new Lt,r=new Lt,n=new Lt){super(),this.type="QuadraticBezierCurve",this.v0=t,this.v1=r,this.v2=n}getPoint(t,r=new Lt){let n=r,i=this.v0,o=this.v1,a=this.v2;return n.set(qP(t,i.x,o.x,a.x),qP(t,i.y,o.y,a.y)),n}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};uM.prototype.isQuadraticBezierCurve=!0;var hM=class extends fs{constructor(t=new j,r=new j,n=new j){super(),this.type="QuadraticBezierCurve3",this.v0=t,this.v1=r,this.v2=n}getPoint(t,r=new j){let n=r,i=this.v0,o=this.v1,a=this.v2;return n.set(qP(t,i.x,o.x,a.x),qP(t,i.y,o.y,a.y),qP(t,i.z,o.z,a.z)),n}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};hM.prototype.isQuadraticBezierCurve3=!0;var fM=class extends fs{constructor(t=[]){super(),this.type="SplineCurve",this.points=t}getPoint(t,r=new Lt){let n=r,i=this.points,o=(i.length-1)*t,a=Math.floor(o),s=o-a,l=i[a===0?a:a-1],c=i[a],u=i[a>i.length-2?i.length-1:a+1],h=i[a>i.length-3?i.length-1:a+2];return n.set(che(s,l.x,c.x,u.x,h.x),che(s,l.y,c.y,u.y,h.y)),n}copy(t){super.copy(t),this.points=[];for(let r=0,n=t.points.length;r<n;r++){let i=t.points[r];this.points.push(i.clone())}return this}toJSON(){let t=super.toJSON();t.points=[];for(let r=0,n=this.points.length;r<n;r++){let i=this.points[r];t.points.push(i.toArray())}return t}fromJSON(t){super.fromJSON(t),this.points=[];for(let r=0,n=t.points.length;r<n;r++){let i=t.points[r];this.points.push(new Lt().fromArray(i))}return this}};fM.prototype.isSplineCurve=!0;var zht=Object.freeze({__proto__:null,ArcCurve:s6,CatmullRomCurve3:l6,CubicBezierCurve:cM,CubicBezierCurve3:c6,EllipseCurve:Vv,LineCurve:Uv,LineCurve3:xU,QuadraticBezierCurve:uM,QuadraticBezierCurve3:hM,SplineCurve:fM}),bU=class extends fs{constructor(){super(),this.type="CurvePath",this.curves=[],this.autoClose=!1}add(t){this.curves.push(t)}closePath(){let t=this.curves[0].getPoint(0),r=this.curves[this.curves.length-1].getPoint(1);t.equals(r)||this.curves.push(new Uv(r,t))}getPoint(t,r){let n=t*this.getLength(),i=this.getCurveLengths(),o=0;for(;o<i.length;){if(i[o]>=n){let a=i[o]-n,s=this.curves[o],l=s.getLength(),c=l===0?0:1-a/l;return s.getPointAt(c,r)}o++}return null}getLength(){let t=this.getCurveLengths();return t[t.length-1]}updateArcLengths(){this.needsUpdate=!0,this.cacheLengths=null,this.getCurveLengths()}getCurveLengths(){if(this.cacheLengths&&this.cacheLengths.length===this.curves.length)return this.cacheLengths;let t=[],r=0;for(let n=0,i=this.curves.length;n<i;n++)r+=this.curves[n].getLength(),t.push(r);return this.cacheLengths=t,t}getSpacedPoints(t=40){let r=[];for(let n=0;n<=t;n++)r.push(this.getPoint(n/t));return this.autoClose&&r.push(r[0]),r}getPoints(t=12){let r=[],n;for(let i=0,o=this.curves;i<o.length;i++){let a=o[i],s=a&&a.isEllipseCurve?t*2:a&&(a.isLineCurve||a.isLineCurve3)?1:a&&a.isSplineCurve?t*a.points.length:t,l=a.getPoints(s);for(let c=0;c<l.length;c++){let u=l[c];n&&n.equals(u)||(r.push(u),n=u)}}return this.autoClose&&r.length>1&&!r[r.length-1].equals(r[0])&&r.push(r[0]),r}copy(t){super.copy(t),this.curves=[];for(let r=0,n=t.curves.length;r<n;r++){let i=t.curves[r];this.curves.push(i.clone())}return this.autoClose=t.autoClose,this}toJSON(){let t=super.toJSON();t.autoClose=this.autoClose,t.curves=[];for(let r=0,n=this.curves.length;r<n;r++){let i=this.curves[r];t.curves.push(i.toJSON())}return t}fromJSON(t){super.fromJSON(t),this.autoClose=t.autoClose,this.curves=[];for(let r=0,n=t.curves.length;r<n;r++){let i=t.curves[r];this.curves.push(new zht[i.type]().fromJSON(i))}return this}},qv=class extends bU{constructor(t){super(),this.type="Path",this.currentPoint=new Lt,t&&this.setFromPoints(t)}setFromPoints(t){this.moveTo(t[0].x,t[0].y);for(let r=1,n=t.length;r<n;r++)this.lineTo(t[r].x,t[r].y);return this}moveTo(t,r){return this.currentPoint.set(t,r),this}lineTo(t,r){let n=new Uv(this.currentPoint.clone(),new Lt(t,r));return this.curves.push(n),this.currentPoint.set(t,r),this}quadraticCurveTo(t,r,n,i){let o=new uM(this.currentPoint.clone(),new Lt(t,r),new Lt(n,i));return this.curves.push(o),this.currentPoint.set(n,i),this}bezierCurveTo(t,r,n,i,o,a){let s=new cM(this.currentPoint.clone(),new Lt(t,r),new Lt(n,i),new Lt(o,a));return this.curves.push(s),this.currentPoint.set(o,a),this}splineThru(t){let r=[this.currentPoint.clone()].concat(t),n=new fM(r);return this.curves.push(n),this.currentPoint.copy(t[t.length-1]),this}arc(t,r,n,i,o,a){let s=this.currentPoint.x,l=this.currentPoint.y;return this.absarc(t+s,r+l,n,i,o,a),this}absarc(t,r,n,i,o,a){return this.absellipse(t,r,n,n,i,o,a),this}ellipse(t,r,n,i,o,a,s,l){let c=this.currentPoint.x,u=this.currentPoint.y;return this.absellipse(t+c,r+u,n,i,o,a,s,l),this}absellipse(t,r,n,i,o,a,s,l){let c=new Vv(t,r,n,i,o,a,s,l);if(this.curves.length>0){let h=c.getPoint(0);h.equals(this.currentPoint)||this.lineTo(h.x,h.y)}this.curves.push(c);let u=c.getPoint(1);return this.currentPoint.copy(u),this}copy(t){return super.copy(t),this.currentPoint.copy(t.currentPoint),this}toJSON(){let t=super.toJSON();return t.currentPoint=this.currentPoint.toArray(),t}fromJSON(t){return super.fromJSON(t),this.currentPoint.fromArray(t.currentPoint),this}},Kc=class extends qv{constructor(t){super(t),this.uuid=Nl(),this.type="Shape",this.holes=[]}getPointsHoles(t){let r=[];for(let n=0,i=this.holes.length;n<i;n++)r[n]=this.holes[n].getPoints(t);return r}extractPoints(t){return{shape:this.getPoints(t),holes:this.getPointsHoles(t)}}copy(t){super.copy(t),this.holes=[];for(let r=0,n=t.holes.length;r<n;r++){let i=t.holes[r];this.holes.push(i.clone())}return this}toJSON(){let t=super.toJSON();t.uuid=this.uuid,t.holes=[];for(let r=0,n=this.holes.length;r<n;r++){let i=this.holes[r];t.holes.push(i.toJSON())}return t}fromJSON(t){super.fromJSON(t),this.uuid=t.uuid,this.holes=[];for(let r=0,n=t.holes.length;r<n;r++){let i=t.holes[r];this.holes.push(new qv().fromJSON(i))}return this}},Bgr={triangulate:function(e,t,r=2){let n=t&&t.length,i=n?t[0]*r:e.length,o=Kfe(e,0,i,r,!0),a=[];if(!o||o.next===o.prev)return a;let s,l,c,u,h,f,p;if(n&&(o=Ggr(e,t,o,r)),e.length>80*r){s=c=e[0],l=u=e[1];for(let d=r;d<i;d+=r)h=e[d],f=e[d+1],h<s&&(s=h),f<l&&(l=f),h>c&&(c=h),f>u&&(u=f);p=Math.max(c-s,u-l),p=p!==0?1/p:0}return u6(o,a,r,s,l,p),a}};function Kfe(e,t,r,n,i){let o,a;if(i===e0r(e,t,r,n)>0)for(o=t;o<r;o+=n)a=uhe(o,e[o],e[o+1],a);else for(o=r-n;o>=t;o-=n)a=uhe(o,e[o],e[o+1],a);return a&&KU(a,a.next)&&(f6(a),a=a.next),a}function G0(e,t){if(!e)return e;t||(t=e);let r=e,n;do if(n=!1,!r.steiner&&(KU(r,r.next)||si(r.prev,r,r.next)===0)){if(f6(r),r=t=r.prev,r===r.next)break;n=!0}else r=r.next;while(n||r!==t);return t}function u6(e,t,r,n,i,o,a){if(!e)return;!a&&o&&$gr(e,n,i,o);let s=e,l,c;for(;e.prev!==e.next;){if(l=e.prev,c=e.next,o?Vgr(e,n,i,o):Hgr(e)){t.push(l.i/r),t.push(e.i/r),t.push(c.i/r),f6(e),e=c.next,s=c.next;continue}if(e=c,e===s){a?a===1?(e=Ugr(G0(e),t,r),u6(e,t,r,n,i,o,2)):a===2&&qgr(e,t,r,n,i,o):u6(G0(e),t,r,n,i,o,1);break}}}function Hgr(e){let t=e.prev,r=e,n=e.next;if(si(t,r,n)>=0)return!1;let i=e.next.next;for(;i!==e.prev;){if(H3(t.x,t.y,r.x,r.y,n.x,n.y,i.x,i.y)&&si(i.prev,i,i.next)>=0)return!1;i=i.next}return!0}function Vgr(e,t,r,n){let i=e.prev,o=e,a=e.next;if(si(i,o,a)>=0)return!1;let s=i.x<o.x?i.x<a.x?i.x:a.x:o.x<a.x?o.x:a.x,l=i.y<o.y?i.y<a.y?i.y:a.y:o.y<a.y?o.y:a.y,c=i.x>o.x?i.x>a.x?i.x:a.x:o.x>a.x?o.x:a.x,u=i.y>o.y?i.y>a.y?i.y:a.y:o.y>a.y?o.y:a.y,h=iht(s,l,t,r,n),f=iht(c,u,t,r,n),p=e.prevZ,d=e.nextZ;for(;p&&p.z>=h&&d&&d.z<=f;){if(p!==e.prev&&p!==e.next&&H3(i.x,i.y,o.x,o.y,a.x,a.y,p.x,p.y)&&si(p.prev,p,p.next)>=0||(p=p.prevZ,d!==e.prev&&d!==e.next&&H3(i.x,i.y,o.x,o.y,a.x,a.y,d.x,d.y)&&si(d.prev,d,d.next)>=0))return!1;d=d.nextZ}for(;p&&p.z>=h;){if(p!==e.prev&&p!==e.next&&H3(i.x,i.y,o.x,o.y,a.x,a.y,p.x,p.y)&&si(p.prev,p,p.next)>=0)return!1;p=p.prevZ}for(;d&&d.z<=f;){if(d!==e.prev&&d!==e.next&&H3(i.x,i.y,o.x,o.y,a.x,a.y,d.x,d.y)&&si(d.prev,d,d.next)>=0)return!1;d=d.nextZ}return!0}function Ugr(e,t,r){let n=e;do{let i=n.prev,o=n.next.next;!KU(i,o)&&Zfe(i,n,n.next,o)&&h6(i,o)&&h6(o,i)&&(t.push(i.i/r),t.push(n.i/r),t.push(o.i/r),f6(n),f6(n.next),n=e=o),n=n.next}while(n!==e);return G0(n)}function qgr(e,t,r,n,i,o){let a=e;do{let s=a.next.next;for(;s!==a.prev;){if(a.i!==s.i&&Jgr(a,s)){let l=Jfe(a,s);a=G0(a,a.next),l=G0(l,l.next),u6(a,t,r,n,i,o),u6(l,t,r,n,i,o);return}s=s.next}a=a.next}while(a!==e)}function Ggr(e,t,r,n){let i=[],o,a,s,l,c;for(o=0,a=t.length;o<a;o++)s=t[o]*n,l=o<a-1?t[o+1]*n:e.length,c=Kfe(e,s,l,n,!1),c===c.next&&(c.steiner=!0),i.push(Zgr(c));for(i.sort(Wgr),o=0;o<i.length;o++)Ygr(i[o],r),r=G0(r,r.next);return r}function Wgr(e,t){return e.x-t.x}function Ygr(e,t){if(t=jgr(e,t),t){let r=Jfe(t,e);G0(t,t.next),G0(r,r.next)}}function jgr(e,t){let r=t,n=e.x,i=e.y,o=-1/0,a;do{if(i<=r.y&&i>=r.next.y&&r.next.y!==r.y){let f=r.x+(i-r.y)*(r.next.x-r.x)/(r.next.y-r.y);if(f<=n&&f>o){if(o=f,f===n){if(i===r.y)return r;if(i===r.next.y)return r.next}a=r.x<r.next.x?r:r.next}}r=r.next}while(r!==t);if(!a)return null;if(n===o)return a;let s=a,l=a.x,c=a.y,u=1/0,h;r=a;do n>=r.x&&r.x>=l&&n!==r.x&&H3(i<c?n:o,i,l,c,i<c?o:n,i,r.x,r.y)&&(h=Math.abs(i-r.y)/(n-r.x),h6(r,e)&&(h<u||h===u&&(r.x>a.x||r.x===a.x&&Xgr(a,r)))&&(a=r,u=h)),r=r.next;while(r!==s);return a}function Xgr(e,t){return si(e.prev,e,t.prev)<0&&si(t.next,e,e.next)<0}function $gr(e,t,r,n){let i=e;do i.z===null&&(i.z=iht(i.x,i.y,t,r,n)),i.prevZ=i.prev,i.nextZ=i.next,i=i.next;while(i!==e);i.prevZ.nextZ=null,i.prevZ=null,Kgr(i)}function Kgr(e){let t,r,n,i,o,a,s,l,c=1;do{for(r=e,e=null,o=null,a=0;r;){for(a++,n=r,s=0,t=0;t<c&&(s++,n=n.nextZ,!!n);t++);for(l=c;s>0||l>0&&n;)s!==0&&(l===0||!n||r.z<=n.z)?(i=r,r=r.nextZ,s--):(i=n,n=n.nextZ,l--),o?o.nextZ=i:e=i,i.prevZ=o,o=i;r=n}o.nextZ=null,c*=2}while(a>1);return e}function iht(e,t,r,n,i){return e=32767*(e-r)*i,t=32767*(t-n)*i,e=(e|e<<8)&16711935,e=(e|e<<4)&252645135,e=(e|e<<2)&858993459,e=(e|e<<1)&1431655765,t=(t|t<<8)&16711935,t=(t|t<<4)&252645135,t=(t|t<<2)&858993459,t=(t|t<<1)&1431655765,e|t<<1}function Zgr(e){let t=e,r=e;do(t.x<r.x||t.x===r.x&&t.y<r.y)&&(r=t),t=t.next;while(t!==e);return r}function H3(e,t,r,n,i,o,a,s){return(i-a)*(t-s)-(e-a)*(o-s)>=0&&(e-a)*(n-s)-(r-a)*(t-s)>=0&&(r-a)*(o-s)-(i-a)*(n-s)>=0}function Jgr(e,t){return e.next.i!==t.i&&e.prev.i!==t.i&&!Qgr(e,t)&&(h6(e,t)&&h6(t,e)&&t0r(e,t)&&(si(e.prev,e,t.prev)||si(e,t.prev,t))||KU(e,t)&&si(e.prev,e,e.next)>0&&si(t.prev,t,t.next)>0)}function si(e,t,r){return(t.y-e.y)*(r.x-t.x)-(t.x-e.x)*(r.y-t.y)}function KU(e,t){return e.x===t.x&&e.y===t.y}function Zfe(e,t,r,n){let i=qV(si(e,t,r)),o=qV(si(e,t,n)),a=qV(si(r,n,e)),s=qV(si(r,n,t));return!!(i!==o&&a!==s||i===0&&UV(e,r,t)||o===0&&UV(e,n,t)||a===0&&UV(r,e,n)||s===0&&UV(r,t,n))}function UV(e,t,r){return t.x<=Math.max(e.x,r.x)&&t.x>=Math.min(e.x,r.x)&&t.y<=Math.max(e.y,r.y)&&t.y>=Math.min(e.y,r.y)}function qV(e){return e>0?1:e<0?-1:0}function Qgr(e,t){let r=e;do{if(r.i!==e.i&&r.next.i!==e.i&&r.i!==t.i&&r.next.i!==t.i&&Zfe(r,r.next,e,t))return!0;r=r.next}while(r!==e);return!1}function h6(e,t){return si(e.prev,e,e.next)<0?si(e,t,e.next)>=0&&si(e,e.prev,t)>=0:si(e,t,e.prev)<0||si(e,e.next,t)<0}function t0r(e,t){let r=e,n=!1,i=(e.x+t.x)/2,o=(e.y+t.y)/2;do r.y>o!=r.next.y>o&&r.next.y!==r.y&&i<(r.next.x-r.x)*(o-r.y)/(r.next.y-r.y)+r.x&&(n=!n),r=r.next;while(r!==e);return n}function Jfe(e,t){let r=new oht(e.i,e.x,e.y),n=new oht(t.i,t.x,t.y),i=e.next,o=t.prev;return e.next=t,t.prev=e,r.next=i,i.prev=r,n.next=r,r.prev=n,o.next=n,n.prev=o,n}function uhe(e,t,r,n){let i=new oht(e,t,r);return n?(i.next=n.next,i.prev=n,n.next.prev=i,n.next=i):(i.prev=i,i.next=i),i}function f6(e){e.next.prev=e.prev,e.prev.next=e.next,e.prevZ&&(e.prevZ.nextZ=e.nextZ),e.nextZ&&(e.nextZ.prevZ=e.prevZ)}function oht(e,t,r){this.i=e,this.x=t,this.y=r,this.prev=null,this.next=null,this.z=null,this.prevZ=null,this.nextZ=null,this.steiner=!1}function e0r(e,t,r,n){let i=0;for(let o=t,a=r-n;o<r;o+=n)i+=(e[a]-e[o])*(e[o+1]+e[a+1]),a=o;return i}var Zc=class{static area(t){let r=t.length,n=0;for(let i=r-1,o=0;o<r;i=o++)n+=t[i].x*t[o].y-t[o].x*t[i].y;return n*.5}static isClockWise(t){return Zc.area(t)<0}static triangulateShape(t,r){let n=[],i=[],o=[];hhe(t),fhe(n,t);let a=t.length;r.forEach(hhe);for(let l=0;l<r.length;l++)i.push(a),a+=r[l].length,fhe(n,r[l]);let s=Bgr.triangulate(n,i);for(let l=0;l<s.length;l+=3)o.push(s.slice(l,l+3));return o}};function hhe(e){let t=e.length;t>2&&e[t-1].equals(e[0])&&e.pop()}function fhe(e,t){for(let r=0;r<t.length;r++)e.push(t[r].x),e.push(t[r].y)}var hh=class extends Pe{constructor(t=new Kc([new Lt(.5,.5),new Lt(-.5,.5),new Lt(-.5,-.5),new Lt(.5,-.5)]),r={}){super(),this.type="ExtrudeGeometry",this.parameters={shapes:t,options:r},t=Array.isArray(t)?t:[t];let n=this,i=[],o=[];for(let s=0,l=t.length;s<l;s++){let c=t[s];a(c)}this.setAttribute("position",new xe(i,3)),this.setAttribute("uv",new xe(o,2)),this.computeVertexNormals();function a(s){let l=[],c=r.curveSegments!==void 0?r.curveSegments:12,u=r.steps!==void 0?r.steps:1,h=r.depth!==void 0?r.depth:1,f=r.bevelEnabled!==void 0?r.bevelEnabled:!0,p=r.bevelThickness!==void 0?r.bevelThickness:.2,d=r.bevelSize!==void 0?r.bevelSize:p-.1,g=r.bevelOffset!==void 0?r.bevelOffset:0,_=r.bevelSegments!==void 0?r.bevelSegments:3,y=r.extrudePath,x=r.UVGenerator!==void 0?r.UVGenerator:r0r;r.amount!==void 0&&(console.warn("THREE.ExtrudeBufferGeometry: amount has been renamed to depth."),h=r.amount);let b,S=!1,C,P,k,O;y&&(b=y.getSpacedPoints(u),S=!0,f=!1,C=y.computeFrenetFrames(u,!1),P=new j,k=new j,O=new j),f||(_=0,p=0,d=0,g=0);let D=s.extractPoints(c),B=D.shape,I=D.holes;if(!Zc.isClockWise(B)){B=B.reverse();for(let q=0,pt=I.length;q<pt;q++){let ht=I[q];Zc.isClockWise(ht)&&(I[q]=ht.reverse())}}let R=Zc.triangulateShape(B,I),F=B;for(let q=0,pt=I.length;q<pt;q++){let ht=I[q];B=B.concat(ht)}function z(q,pt,ht){return pt||console.error("THREE.ExtrudeGeometry: vec does not exist"),pt.clone().multiplyScalar(ht).add(q)}let U=B.length,W=R.length;function Z(q,pt,ht){let wt,kt,ie,ee=q.x-pt.x,Le=q.y-pt.y,ar=ht.x-q.x,fr=ht.y-q.y,tt=ee*ee+Le*Le,$=ee*fr-Le*ar;if(Math.abs($)>Number.EPSILON){let It=Math.sqrt(tt),$t=Math.sqrt(ar*ar+fr*fr),he=pt.x-Le/It,Tt=pt.y+ee/It,be=ht.x-fr/$t,nt=ht.y+ar/$t,Ct=((be-he)*fr-(nt-Tt)*ar)/(ee*fr-Le*ar);wt=he+ee*Ct-q.x,kt=Tt+Le*Ct-q.y;let Wt=wt*wt+kt*kt;if(Wt<=2)return new Lt(wt,kt);ie=Math.sqrt(Wt/2)}else{let It=!1;ee>Number.EPSILON?ar>Number.EPSILON&&(It=!0):ee<-Number.EPSILON?ar<-Number.EPSILON&&(It=!0):Math.sign(Le)===Math.sign(fr)&&(It=!0),It?(wt=-Le,kt=ee,ie=Math.sqrt(tt)):(wt=ee,kt=Le,ie=Math.sqrt(tt/2))}return new Lt(wt/ie,kt/ie)}let rt=[];for(let q=0,pt=F.length,ht=pt-1,wt=q+1;q<pt;q++,ht++,wt++)ht===pt&&(ht=0),wt===pt&&(wt=0),rt[q]=Z(F[q],F[ht],F[wt]);let ot=[],st,St=rt.concat();for(let q=0,pt=I.length;q<pt;q++){let ht=I[q];st=[];for(let wt=0,kt=ht.length,ie=kt-1,ee=wt+1;wt<kt;wt++,ie++,ee++)ie===kt&&(ie=0),ee===kt&&(ee=0),st[wt]=Z(ht[wt],ht[ie],ht[ee]);ot.push(st),St=St.concat(st)}for(let q=0;q<_;q++){let pt=q/_,ht=p*Math.cos(pt*Math.PI/2),wt=d*Math.sin(pt*Math.PI/2)+g;for(let kt=0,ie=F.length;kt<ie;kt++){let ee=z(F[kt],rt[kt],wt);_t(ee.x,ee.y,-ht)}for(let kt=0,ie=I.length;kt<ie;kt++){let ee=I[kt];st=ot[kt];for(let Le=0,ar=ee.length;Le<ar;Le++){let fr=z(ee[Le],st[Le],wt);_t(fr.x,fr.y,-ht)}}}let bt=d+g;for(let q=0;q<U;q++){let pt=f?z(B[q],St[q],bt):B[q];S?(k.copy(C.normals[0]).multiplyScalar(pt.x),P.copy(C.binormals[0]).multiplyScalar(pt.y),O.copy(b[0]).add(k).add(P),_t(O.x,O.y,O.z)):_t(pt.x,pt.y,0)}for(let q=1;q<=u;q++)for(let pt=0;pt<U;pt++){let ht=f?z(B[pt],St[pt],bt):B[pt];S?(k.copy(C.normals[q]).multiplyScalar(ht.x),P.copy(C.binormals[q]).multiplyScalar(ht.y),O.copy(b[q]).add(k).add(P),_t(O.x,O.y,O.z)):_t(ht.x,ht.y,h/u*q)}for(let q=_-1;q>=0;q--){let pt=q/_,ht=p*Math.cos(pt*Math.PI/2),wt=d*Math.sin(pt*Math.PI/2)+g;for(let kt=0,ie=F.length;kt<ie;kt++){let ee=z(F[kt],rt[kt],wt);_t(ee.x,ee.y,h+ht)}for(let kt=0,ie=I.length;kt<ie;kt++){let ee=I[kt];st=ot[kt];for(let Le=0,ar=ee.length;Le<ar;Le++){let fr=z(ee[Le],st[Le],wt);S?_t(fr.x,fr.y+b[u-1].y,b[u-1].x+ht):_t(fr.x,fr.y,h+ht)}}}Mt(),lt();function Mt(){let q=i.length/3;if(f){let pt=0,ht=U*pt;for(let wt=0;wt<W;wt++){let kt=R[wt];ct(kt[2]+ht,kt[1]+ht,kt[0]+ht)}pt=u+_*2,ht=U*pt;for(let wt=0;wt<W;wt++){let kt=R[wt];ct(kt[0]+ht,kt[1]+ht,kt[2]+ht)}}else{for(let pt=0;pt<W;pt++){let ht=R[pt];ct(ht[2],ht[1],ht[0])}for(let pt=0;pt<W;pt++){let ht=R[pt];ct(ht[0]+U*u,ht[1]+U*u,ht[2]+U*u)}}n.addGroup(q,i.length/3-q,0)}function lt(){let q=i.length/3,pt=0;Kt(F,pt),pt+=F.length;for(let ht=0,wt=I.length;ht<wt;ht++){let kt=I[ht];Kt(kt,pt),pt+=kt.length}n.addGroup(q,i.length/3-q,1)}function Kt(q,pt){let ht=q.length;for(;--ht>=0;){let wt=ht,kt=ht-1;kt<0&&(kt=q.length-1);for(let ie=0,ee=u+_*2;ie<ee;ie++){let Le=U*ie,ar=U*(ie+1),fr=pt+wt+Le,tt=pt+kt+Le,$=pt+kt+ar,It=pt+wt+ar;X(fr,tt,$,It)}}}function _t(q,pt,ht){l.push(q),l.push(pt),l.push(ht)}function ct(q,pt,ht){et(q),et(pt),et(ht);let wt=i.length/3,kt=x.generateTopUV(n,i,wt-3,wt-2,wt-1);dt(kt[0]),dt(kt[1]),dt(kt[2])}function X(q,pt,ht,wt){et(q),et(pt),et(wt),et(pt),et(ht),et(wt);let kt=i.length/3,ie=x.generateSideWallUV(n,i,kt-6,kt-3,kt-2,kt-1);dt(ie[0]),dt(ie[1]),dt(ie[3]),dt(ie[1]),dt(ie[2]),dt(ie[3])}function et(q){i.push(l[q*3+0]),i.push(l[q*3+1]),i.push(l[q*3+2])}function dt(q){o.push(q.x),o.push(q.y)}}}toJSON(){let t=super.toJSON(),r=this.parameters.shapes,n=this.parameters.options;return n0r(r,n,t)}static fromJSON(t,r){let n=[];for(let o=0,a=t.shapes.length;o<a;o++){let s=r[t.shapes[o]];n.push(s)}let i=t.options.extrudePath;return i!==void 0&&(t.options.extrudePath=new zht[i.type]().fromJSON(i)),new hh(n,t.options)}},r0r={generateTopUV:function(e,t,r,n,i){let o=t[r*3],a=t[r*3+1],s=t[n*3],l=t[n*3+1],c=t[i*3],u=t[i*3+1];return[new Lt(o,a),new Lt(s,l),new Lt(c,u)]},generateSideWallUV:function(e,t,r,n,i,o){let a=t[r*3],s=t[r*3+1],l=t[r*3+2],c=t[n*3],u=t[n*3+1],h=t[n*3+2],f=t[i*3],p=t[i*3+1],d=t[i*3+2],g=t[o*3],_=t[o*3+1],y=t[o*3+2];return Math.abs(s-u)<Math.abs(a-c)?[new Lt(a,1-l),new Lt(c,1-h),new Lt(f,1-d),new Lt(g,1-y)]:[new Lt(s,1-l),new Lt(u,1-h),new Lt(p,1-d),new Lt(_,1-y)]}};function n0r(e,t,r){if(r.shapes=[],Array.isArray(e))for(let n=0,i=e.length;n<i;n++){let o=e[n];r.shapes.push(o.uuid)}else r.shapes.push(e.uuid);return t.extrudePath!==void 0&&(r.options.extrudePath=t.extrudePath.toJSON()),r}var Gv=class extends uh{constructor(t=1,r=0){let n=(1+Math.sqrt(5))/2,i=[-1,n,0,1,n,0,-1,-n,0,1,-n,0,0,-1,n,0,1,n,0,-1,-n,0,1,-n,n,0,-1,n,0,1,-n,0,-1,-n,0,1],o=[0,11,5,0,5,1,0,1,7,0,7,10,0,10,11,1,5,9,5,11,4,11,10,2,10,7,6,7,1,8,3,9,4,3,4,2,3,2,6,3,6,8,3,8,9,4,9,5,2,4,11,6,2,10,8,6,7,9,8,1];super(i,o,t,r),this.type="IcosahedronGeometry",this.parameters={radius:t,detail:r}}static fromJSON(t){return new Gv(t.radius,t.detail)}},Wv=class extends Pe{constructor(t=[new Lt(0,.5),new Lt(.5,0),new Lt(0,-.5)],r=12,n=0,i=Math.PI*2){super(),this.type="LatheGeometry",this.parameters={points:t,segments:r,phiStart:n,phiLength:i},r=Math.floor(r),i=Zo(i,0,Math.PI*2);let o=[],a=[],s=[],l=[],c=[],u=1/r,h=new j,f=new Lt,p=new j,d=new j,g=new j,_=0,y=0;for(let x=0;x<=t.length-1;x++)switch(x){case 0:_=t[x+1].x-t[x].x,y=t[x+1].y-t[x].y,p.x=y*1,p.y=-_,p.z=y*0,g.copy(p),p.normalize(),l.push(p.x,p.y,p.z);break;case t.length-1:l.push(g.x,g.y,g.z);break;default:_=t[x+1].x-t[x].x,y=t[x+1].y-t[x].y,p.x=y*1,p.y=-_,p.z=y*0,d.copy(p),p.x+=g.x,p.y+=g.y,p.z+=g.z,p.normalize(),l.push(p.x,p.y,p.z),g.copy(d)}for(let x=0;x<=r;x++){let b=n+x*u*i,S=Math.sin(b),C=Math.cos(b);for(let P=0;P<=t.length-1;P++){h.x=t[P].x*S,h.y=t[P].y,h.z=t[P].x*C,a.push(h.x,h.y,h.z),f.x=x/r,f.y=P/(t.length-1),s.push(f.x,f.y);let k=l[3*P+0]*S,O=l[3*P+1],D=l[3*P+0]*C;c.push(k,O,D)}}for(let x=0;x<r;x++)for(let b=0;b<t.length-1;b++){let S=b+x*t.length,C=S,P=S+t.length,k=S+t.length+1,O=S+1;o.push(C,P,O),o.push(k,O,P)}this.setIndex(o),this.setAttribute("position",new xe(a,3)),this.setAttribute("uv",new xe(s,2)),this.setAttribute("normal",new xe(c,3))}static fromJSON(t){return new Wv(t.points,t.segments,t.phiStart,t.phiLength)}},W0=class extends uh{constructor(t=1,r=0){let n=[1,0,0,-1,0,0,0,1,0,0,-1,0,0,0,1,0,0,-1],i=[0,2,4,0,4,3,0,3,5,0,5,2,1,2,5,1,5,3,1,3,4,1,4,2];super(n,i,t,r),this.type="OctahedronGeometry",this.parameters={radius:t,detail:r}}static fromJSON(t){return new W0(t.radius,t.detail)}},Yv=class extends Pe{constructor(t=.5,r=1,n=8,i=1,o=0,a=Math.PI*2){super(),this.type="RingGeometry",this.parameters={innerRadius:t,outerRadius:r,thetaSegments:n,phiSegments:i,thetaStart:o,thetaLength:a},n=Math.max(3,n),i=Math.max(1,i);let s=[],l=[],c=[],u=[],h=t,f=(r-t)/i,p=new j,d=new Lt;for(let g=0;g<=i;g++){for(let _=0;_<=n;_++){let y=o+_/n*a;p.x=h*Math.cos(y),p.y=h*Math.sin(y),l.push(p.x,p.y,p.z),c.push(0,0,1),d.x=(p.x/r+1)/2,d.y=(p.y/r+1)/2,u.push(d.x,d.y)}h+=f}for(let g=0;g<i;g++){let _=g*(n+1);for(let y=0;y<n;y++){let x=y+_,b=x,S=x+n+1,C=x+n+2,P=x+1;s.push(b,S,P),s.push(S,C,P)}}this.setIndex(s),this.setAttribute("position",new xe(l,3)),this.setAttribute("normal",new xe(c,3)),this.setAttribute("uv",new xe(u,2))}static fromJSON(t){return new Yv(t.innerRadius,t.outerRadius,t.thetaSegments,t.phiSegments,t.thetaStart,t.thetaLength)}},Y0=class extends Pe{constructor(t=new Kc([new Lt(0,.5),new Lt(-.5,-.5),new Lt(.5,-.5)]),r=12){super(),this.type="ShapeGeometry",this.parameters={shapes:t,curveSegments:r};let n=[],i=[],o=[],a=[],s=0,l=0;if(Array.isArray(t)===!1)c(t);else for(let u=0;u<t.length;u++)c(t[u]),this.addGroup(s,l,u),s+=l,l=0;this.setIndex(n),this.setAttribute("position",new xe(i,3)),this.setAttribute("normal",new xe(o,3)),this.setAttribute("uv",new xe(a,2));function c(u){let h=i.length/3,f=u.extractPoints(r),p=f.shape,d=f.holes;Zc.isClockWise(p)===!1&&(p=p.reverse());for(let _=0,y=d.length;_<y;_++){let x=d[_];Zc.isClockWise(x)===!0&&(d[_]=x.reverse())}let g=Zc.triangulateShape(p,d);for(let _=0,y=d.length;_<y;_++){let x=d[_];p=p.concat(x)}for(let _=0,y=p.length;_<y;_++){let x=p[_];i.push(x.x,x.y,0),o.push(0,0,1),a.push(x.x,x.y)}for(let _=0,y=g.length;_<y;_++){let x=g[_],b=x[0]+h,S=x[1]+h,C=x[2]+h;n.push(b,S,C),l+=3}}}toJSON(){let t=super.toJSON(),r=this.parameters.shapes;return i0r(r,t)}static fromJSON(t,r){let n=[];for(let i=0,o=t.shapes.length;i<o;i++){let a=r[t.shapes[i]];n.push(a)}return new Y0(n,t.curveSegments)}};function i0r(e,t){if(t.shapes=[],Array.isArray(e))for(let r=0,n=e.length;r<n;r++){let i=e[r];t.shapes.push(i.uuid)}else t.shapes.push(e.uuid);return t}var j0=class extends Pe{constructor(t=1,r=32,n=16,i=0,o=Math.PI*2,a=0,s=Math.PI){super(),this.type="SphereGeometry",this.parameters={radius:t,widthSegments:r,heightSegments:n,phiStart:i,phiLength:o,thetaStart:a,thetaLength:s},r=Math.max(3,Math.floor(r)),n=Math.max(2,Math.floor(n));let l=Math.min(a+s,Math.PI),c=0,u=[],h=new j,f=new j,p=[],d=[],g=[],_=[];for(let y=0;y<=n;y++){let x=[],b=y/n,S=0;y==0&&a==0?S=.5/r:y==n&&l==Math.PI&&(S=-.5/r);for(let C=0;C<=r;C++){let P=C/r;h.x=-t*Math.cos(i+P*o)*Math.sin(a+b*s),h.y=t*Math.cos(a+b*s),h.z=t*Math.sin(i+P*o)*Math.sin(a+b*s),d.push(h.x,h.y,h.z),f.copy(h).normalize(),g.push(f.x,f.y,f.z),_.push(P+S,1-b),x.push(c++)}u.push(x)}for(let y=0;y<n;y++)for(let x=0;x<r;x++){let b=u[y][x+1],S=u[y][x],C=u[y+1][x],P=u[y+1][x+1];(y!==0||a>0)&&p.push(b,S,P),(y!==n-1||l<Math.PI)&&p.push(S,C,P)}this.setIndex(p),this.setAttribute("position",new xe(d,3)),this.setAttribute("normal",new xe(g,3)),this.setAttribute("uv",new xe(_,2))}static fromJSON(t){return new j0(t.radius,t.widthSegments,t.heightSegments,t.phiStart,t.phiLength,t.thetaStart,t.thetaLength)}},jv=class extends uh{constructor(t=1,r=0){let n=[1,1,1,-1,-1,1,-1,1,-1,1,-1,-1],i=[2,1,0,0,3,2,1,3,0,2,3,1];super(n,i,t,r),this.type="TetrahedronGeometry",this.parameters={radius:t,detail:r}}static fromJSON(t){return new jv(t.radius,t.detail)}},Xv=class extends Pe{constructor(t=1,r=.4,n=8,i=6,o=Math.PI*2){super(),this.type="TorusGeometry",this.parameters={radius:t,tube:r,radialSegments:n,tubularSegments:i,arc:o},n=Math.floor(n),i=Math.floor(i);let a=[],s=[],l=[],c=[],u=new j,h=new j,f=new j;for(let p=0;p<=n;p++)for(let d=0;d<=i;d++){let g=d/i*o,_=p/n*Math.PI*2;h.x=(t+r*Math.cos(_))*Math.cos(g),h.y=(t+r*Math.cos(_))*Math.sin(g),h.z=r*Math.sin(_),s.push(h.x,h.y,h.z),u.x=t*Math.cos(g),u.y=t*Math.sin(g),f.subVectors(h,u).normalize(),l.push(f.x,f.y,f.z),c.push(d/i),c.push(p/n)}for(let p=1;p<=n;p++)for(let d=1;d<=i;d++){let g=(i+1)*p+d-1,_=(i+1)*(p-1)+d-1,y=(i+1)*(p-1)+d,x=(i+1)*p+d;a.push(g,_,x),a.push(_,y,x)}this.setIndex(a),this.setAttribute("position",new xe(s,3)),this.setAttribute("normal",new xe(l,3)),this.setAttribute("uv",new xe(c,2))}static fromJSON(t){return new Xv(t.radius,t.tube,t.radialSegments,t.tubularSegments,t.arc)}},$v=class extends Pe{constructor(t=1,r=.4,n=64,i=8,o=2,a=3){super(),this.type="TorusKnotGeometry",this.parameters={radius:t,tube:r,tubularSegments:n,radialSegments:i,p:o,q:a},n=Math.floor(n),i=Math.floor(i);let s=[],l=[],c=[],u=[],h=new j,f=new j,p=new j,d=new j,g=new j,_=new j,y=new j;for(let b=0;b<=n;++b){let S=b/n*o*Math.PI*2;x(S,o,a,t,p),x(S+.01,o,a,t,d),_.subVectors(d,p),y.addVectors(d,p),g.crossVectors(_,y),y.crossVectors(g,_),g.normalize(),y.normalize();for(let C=0;C<=i;++C){let P=C/i*Math.PI*2,k=-r*Math.cos(P),O=r*Math.sin(P);h.x=p.x+(k*y.x+O*g.x),h.y=p.y+(k*y.y+O*g.y),h.z=p.z+(k*y.z+O*g.z),l.push(h.x,h.y,h.z),f.subVectors(h,p).normalize(),c.push(f.x,f.y,f.z),u.push(b/n),u.push(C/i)}}for(let b=1;b<=n;b++)for(let S=1;S<=i;S++){let C=(i+1)*(b-1)+(S-1),P=(i+1)*b+(S-1),k=(i+1)*b+S,O=(i+1)*(b-1)+S;s.push(C,P,O),s.push(P,k,O)}this.setIndex(s),this.setAttribute("position",new xe(l,3)),this.setAttribute("normal",new xe(c,3)),this.setAttribute("uv",new xe(u,2));function x(b,S,C,P,k){let O=Math.cos(b),D=Math.sin(b),B=C/S*b,I=Math.cos(B);k.x=P*(2+I)*.5*O,k.y=P*(2+I)*D*.5,k.z=P*Math.sin(B)*.5}}static fromJSON(t){return new $v(t.radius,t.tube,t.tubularSegments,t.radialSegments,t.p,t.q)}},Kv=class extends Pe{constructor(t=new hM(new j(-1,-1,0),new j(-1,1,0),new j(1,1,0)),r=64,n=1,i=8,o=!1){super(),this.type="TubeGeometry",this.parameters={path:t,tubularSegments:r,radius:n,radialSegments:i,closed:o};let a=t.computeFrenetFrames(r,o);this.tangents=a.tangents,this.normals=a.normals,this.binormals=a.binormals;let s=new j,l=new j,c=new Lt,u=new j,h=[],f=[],p=[],d=[];g(),this.setIndex(d),this.setAttribute("position",new xe(h,3)),this.setAttribute("normal",new xe(f,3)),this.setAttribute("uv",new xe(p,2));function g(){for(let b=0;b<r;b++)_(b);_(o===!1?r:0),x(),y()}function _(b){u=t.getPointAt(b/r,u);let S=a.normals[b],C=a.binormals[b];for(let P=0;P<=i;P++){let k=P/i*Math.PI*2,O=Math.sin(k),D=-Math.cos(k);l.x=D*S.x+O*C.x,l.y=D*S.y+O*C.y,l.z=D*S.z+O*C.z,l.normalize(),f.push(l.x,l.y,l.z),s.x=u.x+n*l.x,s.y=u.y+n*l.y,s.z=u.z+n*l.z,h.push(s.x,s.y,s.z)}}function y(){for(let b=1;b<=r;b++)for(let S=1;S<=i;S++){let C=(i+1)*(b-1)+(S-1),P=(i+1)*b+(S-1),k=(i+1)*b+S,O=(i+1)*(b-1)+S;d.push(C,P,O),d.push(P,k,O)}}function x(){for(let b=0;b<=r;b++)for(let S=0;S<=i;S++)c.x=b/r,c.y=S/i,p.push(c.x,c.y)}}toJSON(){let t=super.toJSON();return t.path=this.parameters.path.toJSON(),t}static fromJSON(t){return new Kv(new zht[t.path.type]().fromJSON(t.path),t.tubularSegments,t.radius,t.radialSegments,t.closed)}},p6=class extends Pe{constructor(t=null){if(super(),this.type="WireframeGeometry",this.parameters={geometry:t},t!==null){let r=[],n=new Set,i=new j,o=new j;if(t.index!==null){let a=t.attributes.position,s=t.index,l=t.groups;l.length===0&&(l=[{start:0,count:s.count,materialIndex:0}]);for(let c=0,u=l.length;c<u;++c){let h=l[c],f=h.start,p=h.count;for(let d=f,g=f+p;d<g;d+=3)for(let _=0;_<3;_++){let y=s.getX(d+_),x=s.getX(d+(_+1)%3);i.fromBufferAttribute(a,y),o.fromBufferAttribute(a,x),phe(i,o,n)===!0&&(r.push(i.x,i.y,i.z),r.push(o.x,o.y,o.z))}}}else{let a=t.attributes.position;for(let s=0,l=a.count/3;s<l;s++)for(let c=0;c<3;c++){let u=3*s+c,h=3*s+(c+1)%3;i.fromBufferAttribute(a,u),o.fromBufferAttribute(a,h),phe(i,o,n)===!0&&(r.push(i.x,i.y,i.z),r.push(o.x,o.y,o.z))}}this.setAttribute("position",new xe(r,3))}}};function phe(e,t,r){let n=`${e.x},${e.y},${e.z}-${t.x},${t.y},${t.z}`,i=`${t.x},${t.y},${t.z}-${e.x},${e.y},${e.z}`;return r.has(n)===!0||r.has(i)===!0?!1:(r.add(n,i),!0)}var dhe=Object.freeze({__proto__:null,BoxGeometry:Qf,BoxBufferGeometry:Qf,CircleGeometry:Fv,CircleBufferGeometry:Fv,ConeGeometry:Bv,ConeBufferGeometry:Bv,CylinderGeometry:om,CylinderBufferGeometry:om,DodecahedronGeometry:Hv,DodecahedronBufferGeometry:Hv,EdgesGeometry:a6,ExtrudeGeometry:hh,ExtrudeBufferGeometry:hh,IcosahedronGeometry:Gv,IcosahedronBufferGeometry:Gv,LatheGeometry:Wv,LatheBufferGeometry:Wv,OctahedronGeometry:W0,OctahedronBufferGeometry:W0,PlaneGeometry:V0,PlaneBufferGeometry:V0,PolyhedronGeometry:uh,PolyhedronBufferGeometry:uh,RingGeometry:Yv,RingBufferGeometry:Yv,ShapeGeometry:Y0,ShapeBufferGeometry:Y0,SphereGeometry:j0,SphereBufferGeometry:j0,TetrahedronGeometry:jv,TetrahedronBufferGeometry:jv,TorusGeometry:Xv,TorusBufferGeometry:Xv,TorusKnotGeometry:$v,TorusKnotBufferGeometry:$v,TubeGeometry:Kv,TubeBufferGeometry:Kv,WireframeGeometry:p6}),d6=class extends qi{constructor(t){super(),this.type="ShadowMaterial",this.color=new ne(0),this.transparent=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this}};d6.prototype.isShadowMaterial=!0;var pM=class extends qi{constructor(t){super(),this.defines={STANDARD:""},this.type="MeshStandardMaterial",this.color=new ne(16777215),this.roughness=1,this.metalness=0,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ne(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ax,this.normalScale=new Lt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.roughnessMap=null,this.metalnessMap=null,this.alphaMap=null,this.envMap=null,this.envMapIntensity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.defines={STANDARD:""},this.color.copy(t.color),this.roughness=t.roughness,this.metalness=t.metalness,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.roughnessMap=t.roughnessMap,this.metalnessMap=t.metalnessMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.envMapIntensity=t.envMapIntensity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this}};pM.prototype.isMeshStandardMaterial=!0;var m6=class extends pM{constructor(t){super(),this.defines={STANDARD:"",PHYSICAL:""},this.type="MeshPhysicalMaterial",this.clearcoatMap=null,this.clearcoatRoughness=0,this.clearcoatRoughnessMap=null,this.clearcoatNormalScale=new Lt(1,1),this.clearcoatNormalMap=null,this.ior=1.5,Object.defineProperty(this,"reflectivity",{get:function(){return Zo(2.5*(this.ior-1)/(this.ior+1),0,1)},set:function(r){this.ior=(1+.4*r)/(1-.4*r)}}),this.sheenColor=new ne(0),this.sheenColorMap=null,this.sheenRoughness=1,this.sheenRoughnessMap=null,this.transmissionMap=null,this.thickness=0,this.thicknessMap=null,this.attenuationDistance=0,this.attenuationColor=new ne(1,1,1),this.specularIntensity=1,this.specularIntensityMap=null,this.specularColor=new ne(1,1,1),this.specularColorMap=null,this._sheen=0,this._clearcoat=0,this._transmission=0,this.setValues(t)}get sheen(){return this._sheen}set sheen(t){this._sheen>0!=t>0&&this.version++,this._sheen=t}get clearcoat(){return this._clearcoat}set clearcoat(t){this._clearcoat>0!=t>0&&this.version++,this._clearcoat=t}get transmission(){return this._transmission}set transmission(t){this._transmission>0!=t>0&&this.version++,this._transmission=t}copy(t){return super.copy(t),this.defines={STANDARD:"",PHYSICAL:""},this.clearcoat=t.clearcoat,this.clearcoatMap=t.clearcoatMap,this.clearcoatRoughness=t.clearcoatRoughness,this.clearcoatRoughnessMap=t.clearcoatRoughnessMap,this.clearcoatNormalMap=t.clearcoatNormalMap,this.clearcoatNormalScale.copy(t.clearcoatNormalScale),this.ior=t.ior,this.sheen=t.sheen,this.sheenColor.copy(t.sheenColor),this.sheenColorMap=t.sheenColorMap,this.sheenRoughness=t.sheenRoughness,this.sheenRoughnessMap=t.sheenRoughnessMap,this.transmission=t.transmission,this.transmissionMap=t.transmissionMap,this.thickness=t.thickness,this.thicknessMap=t.thicknessMap,this.attenuationDistance=t.attenuationDistance,this.attenuationColor.copy(t.attenuationColor),this.specularIntensity=t.specularIntensity,this.specularIntensityMap=t.specularIntensityMap,this.specularColor.copy(t.specularColor),this.specularColorMap=t.specularColorMap,this}};m6.prototype.isMeshPhysicalMaterial=!0;var g6=class extends qi{constructor(t){super(),this.type="MeshPhongMaterial",this.color=new ne(16777215),this.specular=new ne(1118481),this.shininess=30,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ne(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ax,this.normalScale=new Lt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=D6,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.specular.copy(t.specular),this.shininess=t.shininess,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this}};g6.prototype.isMeshPhongMaterial=!0;var _6=class extends qi{constructor(t){super(),this.defines={TOON:""},this.type="MeshToonMaterial",this.color=new ne(16777215),this.map=null,this.gradientMap=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ne(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ax,this.normalScale=new Lt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.gradientMap=t.gradientMap,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};_6.prototype.isMeshToonMaterial=!0;var y6=class extends qi{constructor(t){super(),this.type="MeshNormalMaterial",this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ax,this.normalScale=new Lt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.flatShading=t.flatShading,this}};y6.prototype.isMeshNormalMaterial=!0;var v6=class extends qi{constructor(t){super(),this.type="MeshLambertMaterial",this.color=new ne(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new ne(0),this.emissiveIntensity=1,this.emissiveMap=null,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=D6,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};v6.prototype.isMeshLambertMaterial=!0;var x6=class extends qi{constructor(t){super(),this.defines={MATCAP:""},this.type="MeshMatcapMaterial",this.color=new ne(16777215),this.matcap=null,this.map=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=ax,this.normalScale=new Lt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.defines={MATCAP:""},this.color.copy(t.color),this.matcap=t.matcap,this.map=t.map,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.flatShading=t.flatShading,this}};x6.prototype.isMeshMatcapMaterial=!0;var b6=class extends Gi{constructor(t){super(),this.type="LineDashedMaterial",this.scale=1,this.dashSize=3,this.gapSize=1,this.setValues(t)}copy(t){return super.copy(t),this.scale=t.scale,this.dashSize=t.dashSize,this.gapSize=t.gapSize,this}};b6.prototype.isLineDashedMaterial=!0;var o0r=Object.freeze({__proto__:null,ShadowMaterial:d6,SpriteMaterial:iM,RawShaderMaterial:U0,ShaderMaterial:lh,PointsMaterial:nm,MeshPhysicalMaterial:m6,MeshStandardMaterial:pM,MeshPhongMaterial:g6,MeshToonMaterial:_6,MeshNormalMaterial:y6,MeshLambertMaterial:v6,MeshDepthMaterial:eM,MeshDistanceMaterial:rM,MeshBasicMaterial:sh,MeshMatcapMaterial:x6,LineDashedMaterial:b6,LineBasicMaterial:Gi,Material:qi}),jn={arraySlice:function(e,t,r){return jn.isTypedArray(e)?new e.constructor(e.subarray(t,r!==void 0?r:e.length)):e.slice(t,r)},convertArray:function(e,t,r){return!e||!r&&e.constructor===t?e:typeof t.BYTES_PER_ELEMENT=="number"?new t(e):Array.prototype.slice.call(e)},isTypedArray:function(e){return ArrayBuffer.isView(e)&&!(e instanceof DataView)},getKeyframeOrder:function(e){function t(i,o){return e[i]-e[o]}let r=e.length,n=new Array(r);for(let i=0;i!==r;++i)n[i]=i;return n.sort(t),n},sortedArray:function(e,t,r){let n=e.length,i=new e.constructor(n);for(let o=0,a=0;a!==n;++o){let s=r[o]*t;for(let l=0;l!==t;++l)i[a++]=e[s+l]}return i},flattenJSON:function(e,t,r,n){let i=1,o=e[0];for(;o!==void 0&&o[n]===void 0;)o=e[i++];if(o===void 0)return;let a=o[n];if(a!==void 0)if(Array.isArray(a))do a=o[n],a!==void 0&&(t.push(o.time),r.push.apply(r,a)),o=e[i++];while(o!==void 0);else if(a.toArray!==void 0)do a=o[n],a!==void 0&&(t.push(o.time),a.toArray(r,r.length)),o=e[i++];while(o!==void 0);else do a=o[n],a!==void 0&&(t.push(o.time),r.push(a)),o=e[i++];while(o!==void 0)},subclip:function(e,t,r,n,i=30){let o=e.clone();o.name=t;let a=[];for(let l=0;l<o.tracks.length;++l){let c=o.tracks[l],u=c.getValueSize(),h=[],f=[];for(let p=0;p<c.times.length;++p){let d=c.times[p]*i;if(!(d<r||d>=n)){h.push(c.times[p]);for(let g=0;g<u;++g)f.push(c.values[p*u+g])}}h.length!==0&&(c.times=jn.convertArray(h,c.times.constructor),c.values=jn.convertArray(f,c.values.constructor),a.push(c))}o.tracks=a;let s=1/0;for(let l=0;l<o.tracks.length;++l)s>o.tracks[l].times[0]&&(s=o.tracks[l].times[0]);for(let l=0;l<o.tracks.length;++l)o.tracks[l].shift(-1*s);return o.resetDuration(),o},makeClipAdditive:function(e,t=0,r=e,n=30){n<=0&&(n=30);let i=r.tracks.length,o=t/n;for(let a=0;a<i;++a){let s=r.tracks[a],l=s.ValueTypeName;if(l==="bool"||l==="string")continue;let c=e.tracks.find(function(y){return y.name===s.name&&y.ValueTypeName===l});if(c===void 0)continue;let u=0,h=s.getValueSize();s.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(u=h/3);let f=0,p=c.getValueSize();c.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(f=p/3);let d=s.times.length-1,g;if(o<=s.times[0]){let y=u,x=h-u;g=jn.arraySlice(s.values,y,x)}else if(o>=s.times[d]){let y=d*h+u,x=y+h-u;g=jn.arraySlice(s.values,y,x)}else{let y=s.createInterpolant(),x=u,b=h-u;y.evaluate(o),g=jn.arraySlice(y.resultBuffer,x,b)}l==="quaternion"&&new vi().fromArray(g).normalize().conjugate().toArray(g);let _=c.times.length;for(let y=0;y<_;++y){let x=y*p+f;if(l==="quaternion")vi.multiplyQuaternionsFlat(c.values,x,g,0,c.values,x);else{let b=p-f*2;for(let S=0;S<b;++S)c.values[x+S]-=g[S]}}}return e.blendMode=Rht,e}},fh=class{constructor(t,r,n,i){this.parameterPositions=t,this._cachedIndex=0,this.resultBuffer=i!==void 0?i:new r.constructor(n),this.sampleValues=r,this.valueSize=n,this.settings=null,this.DefaultSettings_={}}evaluate(t){let r=this.parameterPositions,n=this._cachedIndex,i=r[n],o=r[n-1];t:{e:{let a;r:{n:if(!(t<i)){for(let s=n+2;;){if(i===void 0){if(t<o)break n;return n=r.length,this._cachedIndex=n,this.afterEnd_(n-1,t,o)}if(n===s)break;if(o=i,i=r[++n],t<i)break e}a=r.length;break r}if(!(t>=o)){let s=r[1];t<s&&(n=2,o=s);for(let l=n-2;;){if(o===void 0)return this._cachedIndex=0,this.beforeStart_(0,t,i);if(n===l)break;if(i=o,o=r[--n-1],t>=o)break e}a=n,n=0;break r}break t}for(;n<a;){let s=n+a>>>1;t<r[s]?a=s:n=s+1}if(i=r[n],o=r[n-1],o===void 0)return this._cachedIndex=0,this.beforeStart_(0,t,i);if(i===void 0)return n=r.length,this._cachedIndex=n,this.afterEnd_(n-1,o,t)}this._cachedIndex=n,this.intervalChanged_(n,o,i)}return this.interpolate_(n,o,t,i)}getSettings_(){return this.settings||this.DefaultSettings_}copySampleValue_(t){let r=this.resultBuffer,n=this.sampleValues,i=this.valueSize,o=t*i;for(let a=0;a!==i;++a)r[a]=n[o+a];return r}interpolate_(){throw new Error("call to abstract method")}intervalChanged_(){}};fh.prototype.beforeStart_=fh.prototype.copySampleValue_;fh.prototype.afterEnd_=fh.prototype.copySampleValue_;var wU=class extends fh{constructor(t,r,n,i){super(t,r,n,i),this._weightPrev=-0,this._offsetPrev=-0,this._weightNext=-0,this._offsetNext=-0,this.DefaultSettings_={endingStart:Ev,endingEnd:Ev}}intervalChanged_(t,r,n){let i=this.parameterPositions,o=t-2,a=t+1,s=i[o],l=i[a];if(s===void 0)switch(this.getSettings_().endingStart){case Tv:o=t,s=2*r-n;break;case ZP:o=i.length-2,s=r+i[o]-i[o+1];break;default:o=t,s=n}if(l===void 0)switch(this.getSettings_().endingEnd){case Tv:a=t,l=2*n-r;break;case ZP:a=1,l=n+i[1]-i[0];break;default:a=t-1,l=r}let c=(n-r)*.5,u=this.valueSize;this._weightPrev=c/(r-s),this._weightNext=c/(l-n),this._offsetPrev=o*u,this._offsetNext=a*u}interpolate_(t,r,n,i){let o=this.resultBuffer,a=this.sampleValues,s=this.valueSize,l=t*s,c=l-s,u=this._offsetPrev,h=this._offsetNext,f=this._weightPrev,p=this._weightNext,d=(n-r)/(i-r),g=d*d,_=g*d,y=-f*_+2*f*g-f*d,x=(1+f)*_+(-1.5-2*f)*g+(-.5+f)*d+1,b=(-1-p)*_+(1.5+p)*g+.5*d,S=p*_-p*g;for(let C=0;C!==s;++C)o[C]=y*a[u+C]+x*a[c+C]+b*a[l+C]+S*a[h+C];return o}},w6=class extends fh{constructor(t,r,n,i){super(t,r,n,i)}interpolate_(t,r,n,i){let o=this.resultBuffer,a=this.sampleValues,s=this.valueSize,l=t*s,c=l-s,u=(n-r)/(i-r),h=1-u;for(let f=0;f!==s;++f)o[f]=a[c+f]*h+a[l+f]*u;return o}},SU=class extends fh{constructor(t,r,n,i){super(t,r,n,i)}interpolate_(t){return this.copySampleValue_(t-1)}},Dl=class{constructor(t,r,n,i){if(t===void 0)throw new Error("THREE.KeyframeTrack: track name is undefined");if(r===void 0||r.length===0)throw new Error("THREE.KeyframeTrack: no keyframes in track named "+t);this.name=t,this.times=jn.convertArray(r,this.TimeBufferType),this.values=jn.convertArray(n,this.ValueBufferType),this.setInterpolation(i||this.DefaultInterpolation)}static toJSON(t){let r=t.constructor,n;if(r.toJSON!==this.toJSON)n=r.toJSON(t);else{n={name:t.name,times:jn.convertArray(t.times,Array),values:jn.convertArray(t.values,Array)};let i=t.getInterpolation();i!==t.DefaultInterpolation&&(n.interpolation=i)}return n.type=t.ValueTypeName,n}InterpolantFactoryMethodDiscrete(t){return new SU(this.times,this.values,this.getValueSize(),t)}InterpolantFactoryMethodLinear(t){return new w6(this.times,this.values,this.getValueSize(),t)}InterpolantFactoryMethodSmooth(t){return new wU(this.times,this.values,this.getValueSize(),t)}setInterpolation(t){let r;switch(t){case $P:r=this.InterpolantFactoryMethodDiscrete;break;case KP:r=this.InterpolantFactoryMethodLinear;break;case eU:r=this.InterpolantFactoryMethodSmooth;break}if(r===void 0){let n="unsupported interpolation for "+this.ValueTypeName+" keyframe track named "+this.name;if(this.createInterpolant===void 0)if(t!==this.DefaultInterpolation)this.setInterpolation(this.DefaultInterpolation);else throw new Error(n);return console.warn("THREE.KeyframeTrack:",n),this}return this.createInterpolant=r,this}getInterpolation(){switch(this.createInterpolant){case this.InterpolantFactoryMethodDiscrete:return $P;case this.InterpolantFactoryMethodLinear:return KP;case this.InterpolantFactoryMethodSmooth:return eU}}getValueSize(){return this.values.length/this.times.length}shift(t){if(t!==0){let r=this.times;for(let n=0,i=r.length;n!==i;++n)r[n]+=t}return this}scale(t){if(t!==1){let r=this.times;for(let n=0,i=r.length;n!==i;++n)r[n]*=t}return this}trim(t,r){let n=this.times,i=n.length,o=0,a=i-1;for(;o!==i&&n[o]<t;)++o;for(;a!==-1&&n[a]>r;)--a;if(++a,o!==0||a!==i){o>=a&&(a=Math.max(a,1),o=a-1);let s=this.getValueSize();this.times=jn.arraySlice(n,o,a),this.values=jn.arraySlice(this.values,o*s,a*s)}return this}validate(){let t=!0,r=this.getValueSize();r-Math.floor(r)!==0&&(console.error("THREE.KeyframeTrack: Invalid value size in track.",this),t=!1);let n=this.times,i=this.values,o=n.length;o===0&&(console.error("THREE.KeyframeTrack: Track is empty.",this),t=!1);let a=null;for(let s=0;s!==o;s++){let l=n[s];if(typeof l=="number"&&isNaN(l)){console.error("THREE.KeyframeTrack: Time is not a valid number.",this,s,l),t=!1;break}if(a!==null&&a>l){console.error("THREE.KeyframeTrack: Out of order keys.",this,s,l,a),t=!1;break}a=l}if(i!==void 0&&jn.isTypedArray(i))for(let s=0,l=i.length;s!==l;++s){let c=i[s];if(isNaN(c)){console.error("THREE.KeyframeTrack: Value is not a valid number.",this,s,c),t=!1;break}}return t}optimize(){let t=jn.arraySlice(this.times),r=jn.arraySlice(this.values),n=this.getValueSize(),i=this.getInterpolation()===eU,o=t.length-1,a=1;for(let s=1;s<o;++s){let l=!1,c=t[s],u=t[s+1];if(c!==u&&(s!==1||c!==t[0]))if(i)l=!0;else{let h=s*n,f=h-n,p=h+n;for(let d=0;d!==n;++d){let g=r[h+d];if(g!==r[f+d]||g!==r[p+d]){l=!0;break}}}if(l){if(s!==a){t[a]=t[s];let h=s*n,f=a*n;for(let p=0;p!==n;++p)r[f+p]=r[h+p]}++a}}if(o>0){t[a]=t[o];for(let s=o*n,l=a*n,c=0;c!==n;++c)r[l+c]=r[s+c];++a}return a!==t.length?(this.times=jn.arraySlice(t,0,a),this.values=jn.arraySlice(r,0,a*n)):(this.times=t,this.values=r),this}clone(){let t=jn.arraySlice(this.times,0),r=jn.arraySlice(this.values,0),n=this.constructor,i=new n(this.name,t,r);return i.createInterpolant=this.createInterpolant,i}};Dl.prototype.TimeBufferType=Float32Array;Dl.prototype.ValueBufferType=Float32Array;Dl.prototype.DefaultInterpolation=KP;var am=class extends Dl{};am.prototype.ValueTypeName="bool";am.prototype.ValueBufferType=Array;am.prototype.DefaultInterpolation=$P;am.prototype.InterpolantFactoryMethodLinear=void 0;am.prototype.InterpolantFactoryMethodSmooth=void 0;var S6=class extends Dl{};S6.prototype.ValueTypeName="color";var Zv=class extends Dl{};Zv.prototype.ValueTypeName="number";var MU=class extends fh{constructor(t,r,n,i){super(t,r,n,i)}interpolate_(t,r,n,i){let o=this.resultBuffer,a=this.sampleValues,s=this.valueSize,l=(n-r)/(i-r),c=t*s;for(let u=c+s;c!==u;c+=4)vi.slerpFlat(o,0,a,c-s,a,c,l);return o}},X0=class extends Dl{InterpolantFactoryMethodLinear(t){return new MU(this.times,this.values,this.getValueSize(),t)}};X0.prototype.ValueTypeName="quaternion";X0.prototype.DefaultInterpolation=KP;X0.prototype.InterpolantFactoryMethodSmooth=void 0;var sm=class extends Dl{};sm.prototype.ValueTypeName="string";sm.prototype.ValueBufferType=Array;sm.prototype.DefaultInterpolation=$P;sm.prototype.InterpolantFactoryMethodLinear=void 0;sm.prototype.InterpolantFactoryMethodSmooth=void 0;var Jv=class extends Dl{};Jv.prototype.ValueTypeName="vector";var Qv=class{constructor(t,r=-1,n,i=XU){this.name=t,this.tracks=n,this.duration=r,this.blendMode=i,this.uuid=Nl(),this.duration<0&&this.resetDuration()}static parse(t){let r=[],n=t.tracks,i=1/(t.fps||1);for(let a=0,s=n.length;a!==s;++a)r.push(s0r(n[a]).scale(i));let o=new this(t.name,t.duration,r,t.blendMode);return o.uuid=t.uuid,o}static toJSON(t){let r=[],n=t.tracks,i={name:t.name,duration:t.duration,tracks:r,uuid:t.uuid,blendMode:t.blendMode};for(let o=0,a=n.length;o!==a;++o)r.push(Dl.toJSON(n[o]));return i}static CreateFromMorphTargetSequence(t,r,n,i){let o=r.length,a=[];for(let s=0;s<o;s++){let l=[],c=[];l.push((s+o-1)%o,s,(s+1)%o),c.push(0,1,0);let u=jn.getKeyframeOrder(l);l=jn.sortedArray(l,1,u),c=jn.sortedArray(c,1,u),!i&&l[0]===0&&(l.push(o),c.push(c[0])),a.push(new Zv(".morphTargetInfluences["+r[s].name+"]",l,c).scale(1/n))}return new this(t,-1,a)}static findByName(t,r){let n=t;if(!Array.isArray(t)){let i=t;n=i.geometry&&i.geometry.animations||i.animations}for(let i=0;i<n.length;i++)if(n[i].name===r)return n[i];return null}static CreateClipsFromMorphTargetSequences(t,r,n){let i={},o=/^([\w-]*?)([\d]+)$/;for(let s=0,l=t.length;s<l;s++){let c=t[s],u=c.name.match(o);if(u&&u.length>1){let h=u[1],f=i[h];f||(i[h]=f=[]),f.push(c)}}let a=[];for(let s in i)a.push(this.CreateFromMorphTargetSequence(s,i[s],r,n));return a}static parseAnimation(t,r){if(!t)return console.error("THREE.AnimationClip: No animation in JSONLoader data."),null;let n=function(h,f,p,d,g){if(p.length!==0){let _=[],y=[];jn.flattenJSON(p,_,y,d),_.length!==0&&g.push(new h(f,_,y))}},i=[],o=t.name||"default",a=t.fps||30,s=t.blendMode,l=t.length||-1,c=t.hierarchy||[];for(let h=0;h<c.length;h++){let f=c[h].keys;if(!(!f||f.length===0))if(f[0].morphTargets){let p={},d;for(d=0;d<f.length;d++)if(f[d].morphTargets)for(let g=0;g<f[d].morphTargets.length;g++)p[f[d].morphTargets[g]]=-1;for(let g in p){let _=[],y=[];for(let x=0;x!==f[d].morphTargets.length;++x){let b=f[d];_.push(b.time),y.push(b.morphTarget===g?1:0)}i.push(new Zv(".morphTargetInfluence["+g+"]",_,y))}l=p.length*(a||1)}else{let p=".bones["+r[h].name+"]";n(Jv,p+".position",f,"pos",i),n(X0,p+".quaternion",f,"rot",i),n(Jv,p+".scale",f,"scl",i)}}return i.length===0?null:new this(o,l,i,s)}resetDuration(){let t=this.tracks,r=0;for(let n=0,i=t.length;n!==i;++n){let o=this.tracks[n];r=Math.max(r,o.times[o.times.length-1])}return this.duration=r,this}trim(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].trim(0,this.duration);return this}validate(){let t=!0;for(let r=0;r<this.tracks.length;r++)t=t&&this.tracks[r].validate();return t}optimize(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].optimize();return this}clone(){let t=[];for(let r=0;r<this.tracks.length;r++)t.push(this.tracks[r].clone());return new this.constructor(this.name,this.duration,t,this.blendMode)}toJSON(){return this.constructor.toJSON(this)}};function a0r(e){switch(e.toLowerCase()){case"scalar":case"double":case"float":case"number":case"integer":return Zv;case"vector":case"vector2":case"vector3":case"vector4":return Jv;case"color":return S6;case"quaternion":return X0;case"bool":case"boolean":return am;case"string":return sm}throw new Error("THREE.KeyframeTrack: Unsupported typeName: "+e)}function s0r(e){if(e.type===void 0)throw new Error("THREE.KeyframeTrack: track type undefined, can not parse");let t=a0r(e.type);if(e.times===void 0){let r=[],n=[];jn.flattenJSON(e.keys,r,n,"value"),e.times=r,e.values=n}return t.parse!==void 0?t.parse(e):new t(e.name,e.times,e.values,e.interpolation)}var tx={enabled:!1,files:{},add:function(e,t){this.enabled!==!1&&(this.files[e]=t)},get:function(e){if(this.enabled!==!1)return this.files[e]},remove:function(e){delete this.files[e]},clear:function(){this.files={}}},M6=class{constructor(t,r,n){let i=this,o=!1,a=0,s=0,l,c=[];this.onStart=void 0,this.onLoad=t,this.onProgress=r,this.onError=n,this.itemStart=function(u){s++,o===!1&&i.onStart!==void 0&&i.onStart(u,a,s),o=!0},this.itemEnd=function(u){a++,i.onProgress!==void 0&&i.onProgress(u,a,s),a===s&&(o=!1,i.onLoad!==void 0&&i.onLoad())},this.itemError=function(u){i.onError!==void 0&&i.onError(u)},this.resolveURL=function(u){return l?l(u):u},this.setURLModifier=function(u){return l=u,this},this.addHandler=function(u,h){return c.push(u,h),this},this.removeHandler=function(u){let h=c.indexOf(u);return h!==-1&&c.splice(h,2),this},this.getHandler=function(u){for(let h=0,f=c.length;h<f;h+=2){let p=c[h],d=c[h+1];if(p.global&&(p.lastIndex=0),p.test(u))return d}return null}}},Qfe=new M6,ea=class{constructor(t){this.manager=t!==void 0?t:Qfe,this.crossOrigin="anonymous",this.withCredentials=!1,this.path="",this.resourcePath="",this.requestHeader={}}load(){}loadAsync(t,r){let n=this;return new Promise(function(i,o){n.load(t,i,r,o)})}parse(){}setCrossOrigin(t){return this.crossOrigin=t,this}setWithCredentials(t){return this.withCredentials=t,this}setPath(t){return this.path=t,this}setResourcePath(t){return this.resourcePath=t,this}setRequestHeader(t){return this.requestHeader=t,this}},Yd={},Jc=class extends ea{constructor(t){super(t)}load(t,r,n,i){t===void 0&&(t=""),this.path!==void 0&&(t=this.path+t),t=this.manager.resolveURL(t);let o=tx.get(t);if(o!==void 0)return this.manager.itemStart(t),setTimeout(()=>{r&&r(o),this.manager.itemEnd(t)},0),o;if(Yd[t]!==void 0){Yd[t].push({onLoad:r,onProgress:n,onError:i});return}Yd[t]=[],Yd[t].push({onLoad:r,onProgress:n,onError:i});let a=new Request(t,{headers:new Headers(this.requestHeader),credentials:this.withCredentials?"include":"same-origin"}),s=this.mimeType,l=this.responseType;fetch(a).then(c=>{if(c.status===200||c.status===0){if(c.status===0&&console.warn("THREE.FileLoader: HTTP Status 0 received."),typeof ReadableStream=="undefined"||c.body.getReader===void 0)return c;let u=Yd[t],h=c.body.getReader(),f=c.headers.get("Content-Length"),p=f?parseInt(f):0,d=p!==0,g=0,_=new ReadableStream({start(y){x();function x(){h.read().then(({done:b,value:S})=>{if(b)y.close();else{g+=S.byteLength;let C=new ProgressEvent("progress",{lengthComputable:d,loaded:g,total:p});for(let P=0,k=u.length;P<k;P++){let O=u[P];O.onProgress&&O.onProgress(C)}y.enqueue(S),x()}})}}});return new Response(_)}else throw Error(`fetch for "${c.url}" responded with ${c.status}: ${c.statusText}`)}).then(c=>{switch(l){case"arraybuffer":return c.arrayBuffer();case"blob":return c.blob();case"document":return c.text().then(u=>new DOMParser().parseFromString(u,s));case"json":return c.json();default:if(s===void 0)return c.text();{let h=/charset="?([^;"\s]*)"?/i.exec(s),f=h&&h[1]?h[1].toLowerCase():void 0,p=new TextDecoder(f);return c.arrayBuffer().then(d=>p.decode(d))}}}).then(c=>{tx.add(t,c);let u=Yd[t];delete Yd[t];for(let h=0,f=u.length;h<f;h++){let p=u[h];p.onLoad&&p.onLoad(c)}}).catch(c=>{let u=Yd[t];if(u===void 0)throw this.manager.itemError(t),c;delete Yd[t];for(let h=0,f=u.length;h<f;h++){let p=u[h];p.onError&&p.onError(c)}this.manager.itemError(t)}).finally(()=>{this.manager.itemEnd(t)}),this.manager.itemStart(t)}setResponseType(t){return this.responseType=t,this}setMimeType(t){return this.mimeType=t,this}},aht=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=this,a=new Jc(this.manager);a.setPath(this.path),a.setRequestHeader(this.requestHeader),a.setWithCredentials(this.withCredentials),a.load(t,function(s){try{r(o.parse(JSON.parse(s)))}catch(l){i?i(l):console.error(l),o.manager.itemError(t)}},n,i)}parse(t){let r=[];for(let n=0;n<t.length;n++){let i=Qv.parse(t[n]);r.push(i)}return r}},sht=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=this,a=[],s=new o6,l=new Jc(this.manager);l.setPath(this.path),l.setResponseType("arraybuffer"),l.setRequestHeader(this.requestHeader),l.setWithCredentials(o.withCredentials);let c=0;function u(h){l.load(t[h],function(f){let p=o.parse(f,!0);a[h]={width:p.width,height:p.height,format:p.format,mipmaps:p.mipmaps},c+=1,c===6&&(p.mipmapCount===1&&(s.minFilter=oi),s.image=a,s.format=p.format,s.needsUpdate=!0,r&&r(s))},n,i)}if(Array.isArray(t))for(let h=0,f=t.length;h<f;++h)u(h);else l.load(t,function(h){let f=o.parse(h,!0);if(f.isCubemap){let p=f.mipmaps.length/f.mipmapCount;for(let d=0;d<p;d++){a[d]={mipmaps:[]};for(let g=0;g<f.mipmapCount;g++)a[d].mipmaps.push(f.mipmaps[d*f.mipmapCount+g]),a[d].format=f.format,a[d].width=f.width,a[d].height=f.height}s.image=a}else s.image.width=f.width,s.image.height=f.height,s.mipmaps=f.mipmaps;f.mipmapCount===1&&(s.minFilter=oi),s.format=f.format,s.needsUpdate=!0,r&&r(s)},n,i);return s}},ex=class extends ea{constructor(t){super(t)}load(t,r,n,i){this.path!==void 0&&(t=this.path+t),t=this.manager.resolveURL(t);let o=this,a=tx.get(t);if(a!==void 0)return o.manager.itemStart(t),setTimeout(function(){r&&r(a),o.manager.itemEnd(t)},0),a;let s=QP("img");function l(){u(),tx.add(t,this),r&&r(this),o.manager.itemEnd(t)}function c(h){u(),i&&i(h),o.manager.itemError(t),o.manager.itemEnd(t)}function u(){s.removeEventListener("load",l,!1),s.removeEventListener("error",c,!1)}return s.addEventListener("load",l,!1),s.addEventListener("error",c,!1),t.substr(0,5)!=="data:"&&this.crossOrigin!==void 0&&(s.crossOrigin=this.crossOrigin),o.manager.itemStart(t),s.src=t,s}},EU=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=new H0,a=new ex(this.manager);a.setCrossOrigin(this.crossOrigin),a.setPath(this.path);let s=0;function l(c){a.load(t[c],function(u){o.images[c]=u,s++,s===6&&(o.needsUpdate=!0,r&&r(o))},void 0,i)}for(let c=0;c<t.length;++c)l(c);return o}},TU=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=this,a=new Jd,s=new Jc(this.manager);return s.setResponseType("arraybuffer"),s.setRequestHeader(this.requestHeader),s.setPath(this.path),s.setWithCredentials(o.withCredentials),s.load(t,function(l){let c=o.parse(l);!c||(c.image!==void 0?a.image=c.image:c.data!==void 0&&(a.image.width=c.width,a.image.height=c.height,a.image.data=c.data),a.wrapS=c.wrapS!==void 0?c.wrapS:Jo,a.wrapT=c.wrapT!==void 0?c.wrapT:Jo,a.magFilter=c.magFilter!==void 0?c.magFilter:oi,a.minFilter=c.minFilter!==void 0?c.minFilter:oi,a.anisotropy=c.anisotropy!==void 0?c.anisotropy:1,c.encoding!==void 0&&(a.encoding=c.encoding),c.flipY!==void 0&&(a.flipY=c.flipY),c.format!==void 0&&(a.format=c.format),c.type!==void 0&&(a.type=c.type),c.mipmaps!==void 0&&(a.mipmaps=c.mipmaps,a.minFilter=ox),c.mipmapCount===1&&(a.minFilter=oi),c.generateMipmaps!==void 0&&(a.generateMipmaps=c.generateMipmaps),a.needsUpdate=!0,r&&r(a,c))},n,i),a}},CU=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=new xi,a=new ex(this.manager);return a.setCrossOrigin(this.crossOrigin),a.setPath(this.path),a.load(t,function(s){o.image=s,o.needsUpdate=!0,r!==void 0&&r(o)},n,i),o}},Ol=class extends or{constructor(t,r=1){super(),this.type="Light",this.color=new ne(t),this.intensity=r}dispose(){}copy(t){return super.copy(t),this.color.copy(t.color),this.intensity=t.intensity,this}toJSON(t){let r=super.toJSON(t);return r.object.color=this.color.getHex(),r.object.intensity=this.intensity,this.groundColor!==void 0&&(r.object.groundColor=this.groundColor.getHex()),this.distance!==void 0&&(r.object.distance=this.distance),this.angle!==void 0&&(r.object.angle=this.angle),this.decay!==void 0&&(r.object.decay=this.decay),this.penumbra!==void 0&&(r.object.penumbra=this.penumbra),this.shadow!==void 0&&(r.object.shadow=this.shadow.toJSON()),r}};Ol.prototype.isLight=!0;var E6=class extends Ol{constructor(t,r,n){super(t,n),this.type="HemisphereLight",this.position.copy(or.DefaultUp),this.updateMatrix(),this.groundColor=new ne(r)}copy(t){return Ol.prototype.copy.call(this,t),this.groundColor.copy(t.groundColor),this}};E6.prototype.isHemisphereLight=!0;var mhe=new Me,ghe=new j,_he=new j,T6=class{constructor(t){this.camera=t,this.bias=0,this.normalBias=0,this.radius=1,this.blurSamples=8,this.mapSize=new Lt(512,512),this.map=null,this.mapPass=null,this.matrix=new Me,this.autoUpdate=!0,this.needsUpdate=!1,this._frustum=new Nv,this._frameExtents=new Lt(1,1),this._viewportCount=1,this._viewports=[new en(0,0,1,1)]}getViewportCount(){return this._viewportCount}getFrustum(){return this._frustum}updateMatrices(t){let r=this.camera,n=this.matrix;ghe.setFromMatrixPosition(t.matrixWorld),r.position.copy(ghe),_he.setFromMatrixPosition(t.target.matrixWorld),r.lookAt(_he),r.updateMatrixWorld(),mhe.multiplyMatrices(r.projectionMatrix,r.matrixWorldInverse),this._frustum.setFromProjectionMatrix(mhe),n.set(.5,0,0,.5,0,.5,0,.5,0,0,.5,.5,0,0,0,1),n.multiply(r.projectionMatrix),n.multiply(r.matrixWorldInverse)}getViewport(t){return this._viewports[t]}getFrameExtents(){return this._frameExtents}dispose(){this.map&&this.map.dispose(),this.mapPass&&this.mapPass.dispose()}copy(t){return this.camera=t.camera.clone(),this.bias=t.bias,this.radius=t.radius,this.mapSize.copy(t.mapSize),this}clone(){return new this.constructor().copy(this)}toJSON(){let t={};return this.bias!==0&&(t.bias=this.bias),this.normalBias!==0&&(t.normalBias=this.normalBias),this.radius!==1&&(t.radius=this.radius),(this.mapSize.x!==512||this.mapSize.y!==512)&&(t.mapSize=this.mapSize.toArray()),t.camera=this.camera.toJSON(!1).object,delete t.camera.matrix,t}},AU=class extends T6{constructor(){super(new Ui(50,1,.5,500)),this.focus=1}updateMatrices(t){let r=this.camera,n=JP*2*t.angle*this.focus,i=this.mapSize.width/this.mapSize.height,o=t.distance||r.far;(n!==r.fov||i!==r.aspect||o!==r.far)&&(r.fov=n,r.aspect=i,r.far=o,r.updateProjectionMatrix()),super.updateMatrices(t)}copy(t){return super.copy(t),this.focus=t.focus,this}};AU.prototype.isSpotLightShadow=!0;var C6=class extends Ol{constructor(t,r,n=0,i=Math.PI/3,o=0,a=1){super(t,r),this.type="SpotLight",this.position.copy(or.DefaultUp),this.updateMatrix(),this.target=new or,this.distance=n,this.angle=i,this.penumbra=o,this.decay=a,this.shadow=new AU}get power(){return this.intensity*Math.PI}set power(t){this.intensity=t/Math.PI}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.distance=t.distance,this.angle=t.angle,this.penumbra=t.penumbra,this.decay=t.decay,this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}};C6.prototype.isSpotLight=!0;var yhe=new Me,FP=new j,but=new j,PU=class extends T6{constructor(){super(new Ui(90,1,.5,500)),this._frameExtents=new Lt(4,2),this._viewportCount=6,this._viewports=[new en(2,1,1,1),new en(0,1,1,1),new en(3,1,1,1),new en(1,1,1,1),new en(3,0,1,1),new en(1,0,1,1)],this._cubeDirections=[new j(1,0,0),new j(-1,0,0),new j(0,0,1),new j(0,0,-1),new j(0,1,0),new j(0,-1,0)],this._cubeUps=[new j(0,1,0),new j(0,1,0),new j(0,1,0),new j(0,1,0),new j(0,0,1),new j(0,0,-1)]}updateMatrices(t,r=0){let n=this.camera,i=this.matrix,o=t.distance||n.far;o!==n.far&&(n.far=o,n.updateProjectionMatrix()),FP.setFromMatrixPosition(t.matrixWorld),n.position.copy(FP),but.copy(n.position),but.add(this._cubeDirections[r]),n.up.copy(this._cubeUps[r]),n.lookAt(but),n.updateMatrixWorld(),i.makeTranslation(-FP.x,-FP.y,-FP.z),yhe.multiplyMatrices(n.projectionMatrix,n.matrixWorldInverse),this._frustum.setFromProjectionMatrix(yhe)}};PU.prototype.isPointLightShadow=!0;var A6=class extends Ol{constructor(t,r,n=0,i=1){super(t,r),this.type="PointLight",this.distance=n,this.decay=i,this.shadow=new PU}get power(){return this.intensity*4*Math.PI}set power(t){this.intensity=t/(4*Math.PI)}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.distance=t.distance,this.decay=t.decay,this.shadow=t.shadow.clone(),this}};A6.prototype.isPointLight=!0;var IU=class extends T6{constructor(){super(new Dv(-5,5,5,-5,.5,500))}};IU.prototype.isDirectionalLightShadow=!0;var P6=class extends Ol{constructor(t,r){super(t,r),this.type="DirectionalLight",this.position.copy(or.DefaultUp),this.updateMatrix(),this.target=new or,this.shadow=new IU}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}};P6.prototype.isDirectionalLight=!0;var I6=class extends Ol{constructor(t,r){super(t,r),this.type="AmbientLight"}};I6.prototype.isAmbientLight=!0;var L6=class extends Ol{constructor(t,r,n=10,i=10){super(t,r),this.type="RectAreaLight",this.width=n,this.height=i}get power(){return this.intensity*this.width*this.height*Math.PI}set power(t){this.intensity=t/(this.width*this.height*Math.PI)}copy(t){return super.copy(t),this.width=t.width,this.height=t.height,this}toJSON(t){let r=super.toJSON(t);return r.object.width=this.width,r.object.height=this.height,r}};L6.prototype.isRectAreaLight=!0;var k6=class{constructor(){this.coefficients=[];for(let t=0;t<9;t++)this.coefficients.push(new j)}set(t){for(let r=0;r<9;r++)this.coefficients[r].copy(t[r]);return this}zero(){for(let t=0;t<9;t++)this.coefficients[t].set(0,0,0);return this}getAt(t,r){let n=t.x,i=t.y,o=t.z,a=this.coefficients;return r.copy(a[0]).multiplyScalar(.282095),r.addScaledVector(a[1],.488603*i),r.addScaledVector(a[2],.488603*o),r.addScaledVector(a[3],.488603*n),r.addScaledVector(a[4],1.092548*(n*i)),r.addScaledVector(a[5],1.092548*(i*o)),r.addScaledVector(a[6],.315392*(3*o*o-1)),r.addScaledVector(a[7],1.092548*(n*o)),r.addScaledVector(a[8],.546274*(n*n-i*i)),r}getIrradianceAt(t,r){let n=t.x,i=t.y,o=t.z,a=this.coefficients;return r.copy(a[0]).multiplyScalar(.886227),r.addScaledVector(a[1],2*.511664*i),r.addScaledVector(a[2],2*.511664*o),r.addScaledVector(a[3],2*.511664*n),r.addScaledVector(a[4],2*.429043*n*i),r.addScaledVector(a[5],2*.429043*i*o),r.addScaledVector(a[6],.743125*o*o-.247708),r.addScaledVector(a[7],2*.429043*n*o),r.addScaledVector(a[8],.429043*(n*n-i*i)),r}add(t){for(let r=0;r<9;r++)this.coefficients[r].add(t.coefficients[r]);return this}addScaledSH(t,r){for(let n=0;n<9;n++)this.coefficients[n].addScaledVector(t.coefficients[n],r);return this}scale(t){for(let r=0;r<9;r++)this.coefficients[r].multiplyScalar(t);return this}lerp(t,r){for(let n=0;n<9;n++)this.coefficients[n].lerp(t.coefficients[n],r);return this}equals(t){for(let r=0;r<9;r++)if(!this.coefficients[r].equals(t.coefficients[r]))return!1;return!0}copy(t){return this.set(t.coefficients)}clone(){return new this.constructor().copy(this)}fromArray(t,r=0){let n=this.coefficients;for(let i=0;i<9;i++)n[i].fromArray(t,r+i*3);return this}toArray(t=[],r=0){let n=this.coefficients;for(let i=0;i<9;i++)n[i].toArray(t,r+i*3);return t}static getBasisAt(t,r){let n=t.x,i=t.y,o=t.z;r[0]=.282095,r[1]=.488603*i,r[2]=.488603*o,r[3]=.488603*n,r[4]=1.092548*n*i,r[5]=1.092548*i*o,r[6]=.315392*(3*o*o-1),r[7]=1.092548*n*o,r[8]=.546274*(n*n-i*i)}};k6.prototype.isSphericalHarmonics3=!0;var rx=class extends Ol{constructor(t=new k6,r=1){super(void 0,r),this.sh=t}copy(t){return super.copy(t),this.sh.copy(t.sh),this}fromJSON(t){return this.intensity=t.intensity,this.sh.fromArray(t.sh),this}toJSON(t){let r=super.toJSON(t);return r.object.sh=this.sh.toArray(),r}};rx.prototype.isLightProbe=!0;var LU=class extends ea{constructor(t){super(t),this.textures={}}load(t,r,n,i){let o=this,a=new Jc(o.manager);a.setPath(o.path),a.setRequestHeader(o.requestHeader),a.setWithCredentials(o.withCredentials),a.load(t,function(s){try{r(o.parse(JSON.parse(s)))}catch(l){i?i(l):console.error(l),o.manager.itemError(t)}},n,i)}parse(t){let r=this.textures;function n(o){return r[o]===void 0&&console.warn("THREE.MaterialLoader: Undefined texture",o),r[o]}let i=new o0r[t.type];if(t.uuid!==void 0&&(i.uuid=t.uuid),t.name!==void 0&&(i.name=t.name),t.color!==void 0&&i.color!==void 0&&i.color.setHex(t.color),t.roughness!==void 0&&(i.roughness=t.roughness),t.metalness!==void 0&&(i.metalness=t.metalness),t.sheen!==void 0&&(i.sheen=t.sheen),t.sheenColor!==void 0&&(i.sheenColor=new ne().setHex(t.sheenColor)),t.sheenRoughness!==void 0&&(i.sheenRoughness=t.sheenRoughness),t.emissive!==void 0&&i.emissive!==void 0&&i.emissive.setHex(t.emissive),t.specular!==void 0&&i.specular!==void 0&&i.specular.setHex(t.specular),t.specularIntensity!==void 0&&(i.specularIntensity=t.specularIntensity),t.specularColor!==void 0&&i.specularColor!==void 0&&i.specularColor.setHex(t.specularColor),t.shininess!==void 0&&(i.shininess=t.shininess),t.clearcoat!==void 0&&(i.clearcoat=t.clearcoat),t.clearcoatRoughness!==void 0&&(i.clearcoatRoughness=t.clearcoatRoughness),t.transmission!==void 0&&(i.transmission=t.transmission),t.thickness!==void 0&&(i.thickness=t.thickness),t.attenuationDistance!==void 0&&(i.attenuationDistance=t.attenuationDistance),t.attenuationColor!==void 0&&i.attenuationColor!==void 0&&i.attenuationColor.setHex(t.attenuationColor),t.fog!==void 0&&(i.fog=t.fog),t.flatShading!==void 0&&(i.flatShading=t.flatShading),t.blending!==void 0&&(i.blending=t.blending),t.combine!==void 0&&(i.combine=t.combine),t.side!==void 0&&(i.side=t.side),t.shadowSide!==void 0&&(i.shadowSide=t.shadowSide),t.opacity!==void 0&&(i.opacity=t.opacity),t.transparent!==void 0&&(i.transparent=t.transparent),t.alphaTest!==void 0&&(i.alphaTest=t.alphaTest),t.depthTest!==void 0&&(i.depthTest=t.depthTest),t.depthWrite!==void 0&&(i.depthWrite=t.depthWrite),t.colorWrite!==void 0&&(i.colorWrite=t.colorWrite),t.alphaWrite!==void 0&&(i.alphaWrite=t.alphaWrite),t.stencilWrite!==void 0&&(i.stencilWrite=t.stencilWrite),t.stencilWriteMask!==void 0&&(i.stencilWriteMask=t.stencilWriteMask),t.stencilFunc!==void 0&&(i.stencilFunc=t.stencilFunc),t.stencilRef!==void 0&&(i.stencilRef=t.stencilRef),t.stencilFuncMask!==void 0&&(i.stencilFuncMask=t.stencilFuncMask),t.stencilFail!==void 0&&(i.stencilFail=t.stencilFail),t.stencilZFail!==void 0&&(i.stencilZFail=t.stencilZFail),t.stencilZPass!==void 0&&(i.stencilZPass=t.stencilZPass),t.wireframe!==void 0&&(i.wireframe=t.wireframe),t.wireframeLinewidth!==void 0&&(i.wireframeLinewidth=t.wireframeLinewidth),t.wireframeLinecap!==void 0&&(i.wireframeLinecap=t.wireframeLinecap),t.wireframeLinejoin!==void 0&&(i.wireframeLinejoin=t.wireframeLinejoin),t.rotation!==void 0&&(i.rotation=t.rotation),t.linewidth!==1&&(i.linewidth=t.linewidth),t.dashSize!==void 0&&(i.dashSize=t.dashSize),t.gapSize!==void 0&&(i.gapSize=t.gapSize),t.scale!==void 0&&(i.scale=t.scale),t.polygonOffset!==void 0&&(i.polygonOffset=t.polygonOffset),t.polygonOffsetFactor!==void 0&&(i.polygonOffsetFactor=t.polygonOffsetFactor),t.polygonOffsetUnits!==void 0&&(i.polygonOffsetUnits=t.polygonOffsetUnits),t.dithering!==void 0&&(i.dithering=t.dithering),t.alphaToCoverage!==void 0&&(i.alphaToCoverage=t.alphaToCoverage),t.premultipliedAlpha!==void 0&&(i.premultipliedAlpha=t.premultipliedAlpha),t.visible!==void 0&&(i.visible=t.visible),t.toneMapped!==void 0&&(i.toneMapped=t.toneMapped),t.userData!==void 0&&(i.userData=t.userData),t.vertexColors!==void 0&&(typeof t.vertexColors=="number"?i.vertexColors=t.vertexColors>0:i.vertexColors=t.vertexColors),t.uniforms!==void 0)for(let o in t.uniforms){let a=t.uniforms[o];switch(i.uniforms[o]={},a.type){case"t":i.uniforms[o].value=n(a.value);break;case"c":i.uniforms[o].value=new ne().setHex(a.value);break;case"v2":i.uniforms[o].value=new Lt().fromArray(a.value);break;case"v3":i.uniforms[o].value=new j().fromArray(a.value);break;case"v4":i.uniforms[o].value=new en().fromArray(a.value);break;case"m3":i.uniforms[o].value=new ki().fromArray(a.value);break;case"m4":i.uniforms[o].value=new Me().fromArray(a.value);break;default:i.uniforms[o].value=a.value}}if(t.defines!==void 0&&(i.defines=t.defines),t.vertexShader!==void 0&&(i.vertexShader=t.vertexShader),t.fragmentShader!==void 0&&(i.fragmentShader=t.fragmentShader),t.extensions!==void 0)for(let o in t.extensions)i.extensions[o]=t.extensions[o];if(t.shading!==void 0&&(i.flatShading=t.shading===1),t.size!==void 0&&(i.size=t.size),t.sizeAttenuation!==void 0&&(i.sizeAttenuation=t.sizeAttenuation),t.map!==void 0&&(i.map=n(t.map)),t.matcap!==void 0&&(i.matcap=n(t.matcap)),t.alphaMap!==void 0&&(i.alphaMap=n(t.alphaMap)),t.bumpMap!==void 0&&(i.bumpMap=n(t.bumpMap)),t.bumpScale!==void 0&&(i.bumpScale=t.bumpScale),t.normalMap!==void 0&&(i.normalMap=n(t.normalMap)),t.normalMapType!==void 0&&(i.normalMapType=t.normalMapType),t.normalScale!==void 0){let o=t.normalScale;Array.isArray(o)===!1&&(o=[o,o]),i.normalScale=new Lt().fromArray(o)}return t.displacementMap!==void 0&&(i.displacementMap=n(t.displacementMap)),t.displacementScale!==void 0&&(i.displacementScale=t.displacementScale),t.displacementBias!==void 0&&(i.displacementBias=t.displacementBias),t.roughnessMap!==void 0&&(i.roughnessMap=n(t.roughnessMap)),t.metalnessMap!==void 0&&(i.metalnessMap=n(t.metalnessMap)),t.emissiveMap!==void 0&&(i.emissiveMap=n(t.emissiveMap)),t.emissiveIntensity!==void 0&&(i.emissiveIntensity=t.emissiveIntensity),t.specularMap!==void 0&&(i.specularMap=n(t.specularMap)),t.specularIntensityMap!==void 0&&(i.specularIntensityMap=n(t.specularIntensityMap)),t.specularColorMap!==void 0&&(i.specularColorMap=n(t.specularColorMap)),t.envMap!==void 0&&(i.envMap=n(t.envMap)),t.envMapIntensity!==void 0&&(i.envMapIntensity=t.envMapIntensity),t.reflectivity!==void 0&&(i.reflectivity=t.reflectivity),t.refractionRatio!==void 0&&(i.refractionRatio=t.refractionRatio),t.lightMap!==void 0&&(i.lightMap=n(t.lightMap)),t.lightMapIntensity!==void 0&&(i.lightMapIntensity=t.lightMapIntensity),t.aoMap!==void 0&&(i.aoMap=n(t.aoMap)),t.aoMapIntensity!==void 0&&(i.aoMapIntensity=t.aoMapIntensity),t.gradientMap!==void 0&&(i.gradientMap=n(t.gradientMap)),t.clearcoatMap!==void 0&&(i.clearcoatMap=n(t.clearcoatMap)),t.clearcoatRoughnessMap!==void 0&&(i.clearcoatRoughnessMap=n(t.clearcoatRoughnessMap)),t.clearcoatNormalMap!==void 0&&(i.clearcoatNormalMap=n(t.clearcoatNormalMap)),t.clearcoatNormalScale!==void 0&&(i.clearcoatNormalScale=new Lt().fromArray(t.clearcoatNormalScale)),t.transmissionMap!==void 0&&(i.transmissionMap=n(t.transmissionMap)),t.thicknessMap!==void 0&&(i.thicknessMap=n(t.thicknessMap)),t.sheenColorMap!==void 0&&(i.sheenColorMap=n(t.sheenColorMap)),t.sheenRoughnessMap!==void 0&&(i.sheenRoughnessMap=n(t.sheenRoughnessMap)),i}setTextures(t){return this.textures=t,this}},dM=class{static decodeText(t){if(typeof TextDecoder!="undefined")return new TextDecoder().decode(t);let r="";for(let n=0,i=t.length;n<i;n++)r+=String.fromCharCode(t[n]);try{return decodeURIComponent(escape(r))}catch(n){return r}}static extractUrlBase(t){let r=t.lastIndexOf("/");return r===-1?"./":t.substr(0,r+1)}static resolveURL(t,r){return typeof t!="string"||t===""?"":(/^https?:\/\//i.test(r)&&/^\//.test(t)&&(r=r.replace(/(^https?:\/\/[^\/]+).*/i,"$1")),/^(https?:)?\/\//i.test(t)||/^data:.*,.*$/i.test(t)||/^blob:.*$/i.test(t)?t:r+t)}},R6=class extends Pe{constructor(){super(),this.type="InstancedBufferGeometry",this.instanceCount=1/0}copy(t){return super.copy(t),this.instanceCount=t.instanceCount,this}clone(){return new this.constructor().copy(this)}toJSON(){let t=super.toJSON(this);return t.instanceCount=this.instanceCount,t.isInstancedBufferGeometry=!0,t}};R6.prototype.isInstancedBufferGeometry=!0;var kU=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=this,a=new Jc(o.manager);a.setPath(o.path),a.setRequestHeader(o.requestHeader),a.setWithCredentials(o.withCredentials),a.load(t,function(s){try{r(o.parse(JSON.parse(s)))}catch(l){i?i(l):console.error(l),o.manager.itemError(t)}},n,i)}parse(t){let r={},n={};function i(p,d){if(r[d]!==void 0)return r[d];let _=p.interleavedBuffers[d],y=o(p,_.buffer),x=B3(_.type,y),b=new em(x,_.stride);return b.uuid=_.uuid,r[d]=b,b}function o(p,d){if(n[d]!==void 0)return n[d];let _=p.arrayBuffers[d],y=new Uint32Array(_).buffer;return n[d]=y,y}let a=t.isInstancedBufferGeometry?new R6:new Pe,s=t.data.index;if(s!==void 0){let p=B3(s.type,s.array);a.setIndex(new Je(p,1))}let l=t.data.attributes;for(let p in l){let d=l[p],g;if(d.isInterleavedBufferAttribute){let _=i(t.data,d.data);g=new tp(_,d.itemSize,d.offset,d.normalized)}else{let _=B3(d.type,d.array),y=d.isInstancedBufferAttribute?rm:Je;g=new y(_,d.itemSize,d.normalized)}d.name!==void 0&&(g.name=d.name),d.usage!==void 0&&g.setUsage(d.usage),d.updateRange!==void 0&&(g.updateRange.offset=d.updateRange.offset,g.updateRange.count=d.updateRange.count),a.setAttribute(p,g)}let c=t.data.morphAttributes;if(c)for(let p in c){let d=c[p],g=[];for(let _=0,y=d.length;_<y;_++){let x=d[_],b;if(x.isInterleavedBufferAttribute){let S=i(t.data,x.data);b=new tp(S,x.itemSize,x.offset,x.normalized)}else{let S=B3(x.type,x.array);b=new Je(S,x.itemSize,x.normalized)}x.name!==void 0&&(b.name=x.name),g.push(b)}a.morphAttributes[p]=g}t.data.morphTargetsRelative&&(a.morphTargetsRelative=!0);let h=t.data.groups||t.data.drawcalls||t.data.offsets;if(h!==void 0)for(let p=0,d=h.length;p!==d;++p){let g=h[p];a.addGroup(g.start,g.count,g.materialIndex)}let f=t.data.boundingSphere;if(f!==void 0){let p=new j;f.center!==void 0&&p.fromArray(f.center),a.boundingSphere=new Zf(p,f.radius)}return t.name&&(a.name=t.name),t.userData&&(a.userData=t.userData),a}},lht=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=this,a=this.path===""?dM.extractUrlBase(t):this.path;this.resourcePath=this.resourcePath||a;let s=new Jc(this.manager);s.setPath(this.path),s.setRequestHeader(this.requestHeader),s.setWithCredentials(this.withCredentials),s.load(t,function(l){let c=null;try{c=JSON.parse(l)}catch(h){i!==void 0&&i(h),console.error("THREE:ObjectLoader: Can't parse "+t+".",h.message);return}let u=c.metadata;if(u===void 0||u.type===void 0||u.type.toLowerCase()==="geometry"){console.error("THREE.ObjectLoader: Can't load "+t);return}o.parse(c,r)},n,i)}loadAsync(t,r){return Ri(this,null,function*(){let n=this,i=this.path===""?dM.extractUrlBase(t):this.path;this.resourcePath=this.resourcePath||i;let o=new Jc(this.manager);o.setPath(this.path),o.setRequestHeader(this.requestHeader),o.setWithCredentials(this.withCredentials);let a=yield o.loadAsync(t,r),s=JSON.parse(a),l=s.metadata;if(l===void 0||l.type===void 0||l.type.toLowerCase()==="geometry")throw new Error("THREE.ObjectLoader: Can't load "+t);return yield n.parseAsync(s)})}parse(t,r){let n=this.parseAnimations(t.animations),i=this.parseShapes(t.shapes),o=this.parseGeometries(t.geometries,i),a=this.parseImages(t.images,function(){r!==void 0&&r(c)}),s=this.parseTextures(t.textures,a),l=this.parseMaterials(t.materials,s),c=this.parseObject(t.object,o,l,s,n),u=this.parseSkeletons(t.skeletons,c);if(this.bindSkeletons(c,u),r!==void 0){let h=!1;for(let f in a)if(a[f]instanceof HTMLImageElement){h=!0;break}h===!1&&r(c)}return c}parseAsync(t){return Ri(this,null,function*(){let r=this.parseAnimations(t.animations),n=this.parseShapes(t.shapes),i=this.parseGeometries(t.geometries,n),o=yield this.parseImagesAsync(t.images),a=this.parseTextures(t.textures,o),s=this.parseMaterials(t.materials,a),l=this.parseObject(t.object,i,s,a,r),c=this.parseSkeletons(t.skeletons,l);return this.bindSkeletons(l,c),l})}parseShapes(t){let r={};if(t!==void 0)for(let n=0,i=t.length;n<i;n++){let o=new Kc().fromJSON(t[n]);r[o.uuid]=o}return r}parseSkeletons(t,r){let n={},i={};if(r.traverse(function(o){o.isBone&&(i[o.uuid]=o)}),t!==void 0)for(let o=0,a=t.length;o<a;o++){let s=new lM().fromJSON(t[o],i);n[s.uuid]=s}return n}parseGeometries(t,r){let n={};if(t!==void 0){let i=new kU;for(let o=0,a=t.length;o<a;o++){let s,l=t[o];switch(l.type){case"BufferGeometry":case"InstancedBufferGeometry":s=i.parse(l);break;case"Geometry":console.error("THREE.ObjectLoader: The legacy Geometry type is no longer supported.");break;default:l.type in dhe?s=dhe[l.type].fromJSON(l,r):console.warn(`THREE.ObjectLoader: Unsupported geometry type "${l.type}"`)}s.uuid=l.uuid,l.name!==void 0&&(s.name=l.name),s.isBufferGeometry===!0&&l.userData!==void 0&&(s.userData=l.userData),n[l.uuid]=s}}return n}parseMaterials(t,r){let n={},i={};if(t!==void 0){let o=new LU;o.setTextures(r);for(let a=0,s=t.length;a<s;a++){let l=t[a];if(l.type==="MultiMaterial"){let c=[];for(let u=0;u<l.materials.length;u++){let h=l.materials[u];n[h.uuid]===void 0&&(n[h.uuid]=o.parse(h)),c.push(n[h.uuid])}i[l.uuid]=c}else n[l.uuid]===void 0&&(n[l.uuid]=o.parse(l)),i[l.uuid]=n[l.uuid]}}return i}parseAnimations(t){let r={};if(t!==void 0)for(let n=0;n<t.length;n++){let i=t[n],o=Qv.parse(i);r[o.uuid]=o}return r}parseImages(t,r){let n=this,i={},o;function a(l){return n.manager.itemStart(l),o.load(l,function(){n.manager.itemEnd(l)},void 0,function(){n.manager.itemError(l),n.manager.itemEnd(l)})}function s(l){if(typeof l=="string"){let c=l,u=/^(\/\/)|([a-z]+:(\/\/)?)/i.test(c)?c:n.resourcePath+c;return a(u)}else return l.data?{data:B3(l.type,l.data),width:l.width,height:l.height}:null}if(t!==void 0&&t.length>0){let l=new M6(r);o=new ex(l),o.setCrossOrigin(this.crossOrigin);for(let c=0,u=t.length;c<u;c++){let h=t[c],f=h.url;if(Array.isArray(f)){i[h.uuid]=[];for(let p=0,d=f.length;p<d;p++){let g=f[p],_=s(g);_!==null&&(_ instanceof HTMLImageElement?i[h.uuid].push(_):i[h.uuid].push(new Jd(_.data,_.width,_.height)))}}else{let p=s(h.url);p!==null&&(i[h.uuid]=p)}}}return i}parseImagesAsync(t){return Ri(this,null,function*(){let r=this,n={},i;function o(a){return Ri(this,null,function*(){if(typeof a=="string"){let s=a,l=/^(\/\/)|([a-z]+:(\/\/)?)/i.test(s)?s:r.resourcePath+s;return yield i.loadAsync(l)}else return a.data?{data:B3(a.type,a.data),width:a.width,height:a.height}:null})}if(t!==void 0&&t.length>0){i=new ex(this.manager),i.setCrossOrigin(this.crossOrigin);for(let a=0,s=t.length;a<s;a++){let l=t[a],c=l.url;if(Array.isArray(c)){n[l.uuid]=[];for(let u=0,h=c.length;u<h;u++){let f=c[u],p=yield o(f);p!==null&&(p instanceof HTMLImageElement?n[l.uuid].push(p):n[l.uuid].push(new Jd(p.data,p.width,p.height)))}}else{let u=yield o(l.url);u!==null&&(n[l.uuid]=u)}}}return n})}parseTextures(t,r){function n(o,a){return typeof o=="number"?o:(console.warn("THREE.ObjectLoader.parseTexture: Constant should be in numeric form.",o),a[o])}let i={};if(t!==void 0)for(let o=0,a=t.length;o<a;o++){let s=t[o];s.image===void 0&&console.warn('THREE.ObjectLoader: No "image" specified for',s.uuid),r[s.image]===void 0&&console.warn("THREE.ObjectLoader: Undefined image",s.image);let l,c=r[s.image];Array.isArray(c)?(l=new H0(c),c.length===6&&(l.needsUpdate=!0)):(c&&c.data?l=new Jd(c.data,c.width,c.height):l=new xi(c),c&&(l.needsUpdate=!0)),l.uuid=s.uuid,s.name!==void 0&&(l.name=s.name),s.mapping!==void 0&&(l.mapping=n(s.mapping,l0r)),s.offset!==void 0&&l.offset.fromArray(s.offset),s.repeat!==void 0&&l.repeat.fromArray(s.repeat),s.center!==void 0&&l.center.fromArray(s.center),s.rotation!==void 0&&(l.rotation=s.rotation),s.wrap!==void 0&&(l.wrapS=n(s.wrap[0],vhe),l.wrapT=n(s.wrap[1],vhe)),s.format!==void 0&&(l.format=s.format),s.type!==void 0&&(l.type=s.type),s.encoding!==void 0&&(l.encoding=s.encoding),s.minFilter!==void 0&&(l.minFilter=n(s.minFilter,xhe)),s.magFilter!==void 0&&(l.magFilter=n(s.magFilter,xhe)),s.anisotropy!==void 0&&(l.anisotropy=s.anisotropy),s.flipY!==void 0&&(l.flipY=s.flipY),s.premultiplyAlpha!==void 0&&(l.premultiplyAlpha=s.premultiplyAlpha),s.unpackAlignment!==void 0&&(l.unpackAlignment=s.unpackAlignment),s.userData!==void 0&&(l.userData=s.userData),i[s.uuid]=l}return i}parseObject(t,r,n,i,o){let a;function s(f){return r[f]===void 0&&console.warn("THREE.ObjectLoader: Undefined geometry",f),r[f]}function l(f){if(f!==void 0){if(Array.isArray(f)){let p=[];for(let d=0,g=f.length;d<g;d++){let _=f[d];n[_]===void 0&&console.warn("THREE.ObjectLoader: Undefined material",_),p.push(n[_])}return p}return n[f]===void 0&&console.warn("THREE.ObjectLoader: Undefined material",f),n[f]}}function c(f){return i[f]===void 0&&console.warn("THREE.ObjectLoader: Undefined texture",f),i[f]}let u,h;switch(t.type){case"Scene":a=new q0,t.background!==void 0&&(Number.isInteger(t.background)?a.background=new ne(t.background):a.background=c(t.background)),t.environment!==void 0&&(a.environment=c(t.environment)),t.fog!==void 0&&(t.fog.type==="Fog"?a.fog=new zv(t.fog.color,t.fog.near,t.fog.far):t.fog.type==="FogExp2"&&(a.fog=new Ov(t.fog.color,t.fog.density)));break;case"PerspectiveCamera":a=new Ui(t.fov,t.aspect,t.near,t.far),t.focus!==void 0&&(a.focus=t.focus),t.zoom!==void 0&&(a.zoom=t.zoom),t.filmGauge!==void 0&&(a.filmGauge=t.filmGauge),t.filmOffset!==void 0&&(a.filmOffset=t.filmOffset),t.view!==void 0&&(a.view=Object.assign({},t.view));break;case"OrthographicCamera":a=new Dv(t.left,t.right,t.top,t.bottom,t.near,t.far),t.zoom!==void 0&&(a.zoom=t.zoom),t.view!==void 0&&(a.view=Object.assign({},t.view));break;case"AmbientLight":a=new I6(t.color,t.intensity);break;case"DirectionalLight":a=new P6(t.color,t.intensity);break;case"PointLight":a=new A6(t.color,t.intensity,t.distance,t.decay);break;case"RectAreaLight":a=new L6(t.color,t.intensity,t.width,t.height);break;case"SpotLight":a=new C6(t.color,t.intensity,t.distance,t.angle,t.penumbra,t.decay);break;case"HemisphereLight":a=new E6(t.color,t.groundColor,t.intensity);break;case"LightProbe":a=new rx().fromJSON(t);break;case"SkinnedMesh":u=s(t.geometry),h=l(t.material),a=new aM(u,h),t.bindMode!==void 0&&(a.bindMode=t.bindMode),t.bindMatrix!==void 0&&a.bindMatrix.fromArray(t.bindMatrix),t.skeleton!==void 0&&(a.skeleton=t.skeleton);break;case"Mesh":u=s(t.geometry),h=l(t.material),a=new ei(u,h);break;case"InstancedMesh":u=s(t.geometry),h=l(t.material);let f=t.count,p=t.instanceMatrix,d=t.instanceColor;a=new n6(u,h,f),a.instanceMatrix=new rm(new Float32Array(p.array),16),d!==void 0&&(a.instanceColor=new rm(new Float32Array(d.array),d.itemSize));break;case"LOD":a=new gU;break;case"Line":a=new ch(s(t.geometry),l(t.material));break;case"LineLoop":a=new i6(s(t.geometry),l(t.material));break;case"LineSegments":a=new Aa(s(t.geometry),l(t.material));break;case"PointCloud":case"Points":a=new im(s(t.geometry),l(t.material));break;case"Sprite":a=new oM(l(t.material));break;case"Group":a=new Xd;break;case"Bone":a=new sM;break;default:a=new or}if(a.uuid=t.uuid,t.name!==void 0&&(a.name=t.name),t.matrix!==void 0?(a.matrix.fromArray(t.matrix),t.matrixAutoUpdate!==void 0&&(a.matrixAutoUpdate=t.matrixAutoUpdate),a.matrixAutoUpdate&&a.matrix.decompose(a.position,a.quaternion,a.scale)):(t.position!==void 0&&a.position.fromArray(t.position),t.rotation!==void 0&&a.rotation.fromArray(t.rotation),t.quaternion!==void 0&&a.quaternion.fromArray(t.quaternion),t.scale!==void 0&&a.scale.fromArray(t.scale)),t.castShadow!==void 0&&(a.castShadow=t.castShadow),t.receiveShadow!==void 0&&(a.receiveShadow=t.receiveShadow),t.shadow&&(t.shadow.bias!==void 0&&(a.shadow.bias=t.shadow.bias),t.shadow.normalBias!==void 0&&(a.shadow.normalBias=t.shadow.normalBias),t.shadow.radius!==void 0&&(a.shadow.radius=t.shadow.radius),t.shadow.mapSize!==void 0&&a.shadow.mapSize.fromArray(t.shadow.mapSize),t.shadow.camera!==void 0&&(a.shadow.camera=this.parseObject(t.shadow.camera))),t.visible!==void 0&&(a.visible=t.visible),t.frustumCulled!==void 0&&(a.frustumCulled=t.frustumCulled),t.renderOrder!==void 0&&(a.renderOrder=t.renderOrder),t.userData!==void 0&&(a.userData=t.userData),t.layers!==void 0&&(a.layers.mask=t.layers),t.children!==void 0){let f=t.children;for(let p=0;p<f.length;p++)a.add(this.parseObject(f[p],r,n,i,o))}if(t.animations!==void 0){let f=t.animations;for(let p=0;p<f.length;p++){let d=f[p];a.animations.push(o[d])}}if(t.type==="LOD"){t.autoUpdate!==void 0&&(a.autoUpdate=t.autoUpdate);let f=t.levels;for(let p=0;p<f.length;p++){let d=f[p],g=a.getObjectByProperty("uuid",d.object);g!==void 0&&a.addLevel(g,d.distance)}}return a}bindSkeletons(t,r){Object.keys(r).length!==0&&t.traverse(function(n){if(n.isSkinnedMesh===!0&&n.skeleton!==void 0){let i=r[n.skeleton];i===void 0?console.warn("THREE.ObjectLoader: No skeleton found with UUID:",n.skeleton):n.bind(i,n.bindMatrix)}})}setTexturePath(t){return console.warn("THREE.ObjectLoader: .setTexturePath() has been renamed to .setResourcePath()."),this.setResourcePath(t)}},l0r={UVMapping:jU,CubeReflectionMapping:nx,CubeRefractionMapping:ix,EquirectangularReflectionMapping:WP,EquirectangularRefractionMapping:YP,CubeUVReflectionMapping:xM,CubeUVRefractionMapping:O6},vhe={RepeatWrapping:jP,ClampToEdgeWrapping:Jo,MirroredRepeatWrapping:XP},xhe={NearestFilter:Li,NearestMipmapNearestFilter:iU,NearestMipmapLinearFilter:oU,LinearFilter:oi,LinearMipmapNearestFilter:kht,LinearMipmapLinearFilter:ox},RU=class extends ea{constructor(t){super(t),typeof createImageBitmap=="undefined"&&console.warn("THREE.ImageBitmapLoader: createImageBitmap() not supported."),typeof fetch=="undefined"&&console.warn("THREE.ImageBitmapLoader: fetch() not supported."),this.options={premultiplyAlpha:"none"}}setOptions(t){return this.options=t,this}load(t,r,n,i){t===void 0&&(t=""),this.path!==void 0&&(t=this.path+t),t=this.manager.resolveURL(t);let o=this,a=tx.get(t);if(a!==void 0)return o.manager.itemStart(t),setTimeout(function(){r&&r(a),o.manager.itemEnd(t)},0),a;let s={};s.credentials=this.crossOrigin==="anonymous"?"same-origin":"include",s.headers=this.requestHeader,fetch(t,s).then(function(l){return l.blob()}).then(function(l){return createImageBitmap(l,Object.assign(o.options,{colorSpaceConversion:"none"}))}).then(function(l){tx.add(t,l),r&&r(l),o.manager.itemEnd(t)}).catch(function(l){i&&i(l),o.manager.itemError(t),o.manager.itemEnd(t)}),o.manager.itemStart(t)}};RU.prototype.isImageBitmapLoader=!0;var GV,Fht={getContext:function(){return GV===void 0&&(GV=new(window.AudioContext||window.webkitAudioContext)),GV},setContext:function(e){GV=e}},NU=class extends ea{constructor(t){super(t)}load(t,r,n,i){let o=this,a=new Jc(this.manager);a.setResponseType("arraybuffer"),a.setPath(this.path),a.setRequestHeader(this.requestHeader),a.setWithCredentials(this.withCredentials),a.load(t,function(s){try{let l=s.slice(0);Fht.getContext().decodeAudioData(l,function(u){r(u)})}catch(l){i?i(l):console.error(l),o.manager.itemError(t)}},n,i)}},DU=class extends rx{constructor(t,r,n=1){super(void 0,n);let i=new ne().set(t),o=new ne().set(r),a=new j(i.r,i.g,i.b),s=new j(o.r,o.g,o.b),l=Math.sqrt(Math.PI),c=l*Math.sqrt(.75);this.sh.coefficients[0].copy(a).add(s).multiplyScalar(l),this.sh.coefficients[1].copy(a).sub(s).multiplyScalar(c)}};DU.prototype.isHemisphereLightProbe=!0;var OU=class extends rx{constructor(t,r=1){super(void 0,r);let n=new ne().set(t);this.sh.coefficients[0].set(n.r,n.g,n.b).multiplyScalar(2*Math.sqrt(Math.PI))}};OU.prototype.isAmbientLightProbe=!0;var bhe=new Me,whe=new Me,yv=new Me,cht=class{constructor(){this.type="StereoCamera",this.aspect=1,this.eyeSep=.064,this.cameraL=new Ui,this.cameraL.layers.enable(1),this.cameraL.matrixAutoUpdate=!1,this.cameraR=new Ui,this.cameraR.layers.enable(2),this.cameraR.matrixAutoUpdate=!1,this._cache={focus:null,fov:null,aspect:null,near:null,far:null,zoom:null,eyeSep:null}}update(t){let r=this._cache;if(r.focus!==t.focus||r.fov!==t.fov||r.aspect!==t.aspect*this.aspect||r.near!==t.near||r.far!==t.far||r.zoom!==t.zoom||r.eyeSep!==this.eyeSep){r.focus=t.focus,r.fov=t.fov,r.aspect=t.aspect*this.aspect,r.near=t.near,r.far=t.far,r.zoom=t.zoom,r.eyeSep=this.eyeSep,yv.copy(t.projectionMatrix);let i=r.eyeSep/2,o=i*r.near/r.focus,a=r.near*Math.tan(Pv*r.fov*.5)/r.zoom,s,l;whe.elements[12]=-i,bhe.elements[12]=i,s=-a*r.aspect+o,l=a*r.aspect+o,yv.elements[0]=2*r.near/(l-s),yv.elements[8]=(l+s)/(l-s),this.cameraL.projectionMatrix.copy(yv),s=-a*r.aspect-o,l=a*r.aspect-o,yv.elements[0]=2*r.near/(l-s),yv.elements[8]=(l+s)/(l-s),this.cameraR.projectionMatrix.copy(yv)}this.cameraL.matrixWorld.copy(t.matrixWorld).multiply(whe),this.cameraR.matrixWorld.copy(t.matrixWorld).multiply(bhe)}},mM=class{constructor(t=!0){this.autoStart=t,this.startTime=0,this.oldTime=0,this.elapsedTime=0,this.running=!1}start(){this.startTime=She(),this.oldTime=this.startTime,this.elapsedTime=0,this.running=!0}stop(){this.getElapsedTime(),this.running=!1,this.autoStart=!1}getElapsedTime(){return this.getDelta(),this.elapsedTime}getDelta(){let t=0;if(this.autoStart&&!this.running)return this.start(),0;if(this.running){let r=She();t=(r-this.oldTime)/1e3,this.oldTime=r,this.elapsedTime+=t}return t}};function She(){return(typeof performance=="undefined"?Date:performance).now()}var vv=new j,Mhe=new vi,c0r=new j,xv=new j,uht=class extends or{constructor(){super(),this.type="AudioListener",this.context=Fht.getContext(),this.gain=this.context.createGain(),this.gain.connect(this.context.destination),this.filter=null,this.timeDelta=0,this._clock=new mM}getInput(){return this.gain}removeFilter(){return this.filter!==null&&(this.gain.disconnect(this.filter),this.filter.disconnect(this.context.destination),this.gain.connect(this.context.destination),this.filter=null),this}getFilter(){return this.filter}setFilter(t){return this.filter!==null?(this.gain.disconnect(this.filter),this.filter.disconnect(this.context.destination)):this.gain.disconnect(this.context.destination),this.filter=t,this.gain.connect(this.filter),this.filter.connect(this.context.destination),this}getMasterVolume(){return this.gain.gain.value}setMasterVolume(t){return this.gain.gain.setTargetAtTime(t,this.context.currentTime,.01),this}updateMatrixWorld(t){super.updateMatrixWorld(t);let r=this.context.listener,n=this.up;if(this.timeDelta=this._clock.getDelta(),this.matrixWorld.decompose(vv,Mhe,c0r),xv.set(0,0,-1).applyQuaternion(Mhe),r.positionX){let i=this.context.currentTime+this.timeDelta;r.positionX.linearRampToValueAtTime(vv.x,i),r.positionY.linearRampToValueAtTime(vv.y,i),r.positionZ.linearRampToValueAtTime(vv.z,i),r.forwardX.linearRampToValueAtTime(xv.x,i),r.forwardY.linearRampToValueAtTime(xv.y,i),r.forwardZ.linearRampToValueAtTime(xv.z,i),r.upX.linearRampToValueAtTime(n.x,i),r.upY.linearRampToValueAtTime(n.y,i),r.upZ.linearRampToValueAtTime(n.z,i)}else r.setPosition(vv.x,vv.y,vv.z),r.setOrientation(xv.x,xv.y,xv.z,n.x,n.y,n.z)}},N6=class extends or{constructor(t){super(),this.type="Audio",this.listener=t,this.context=t.context,this.gain=this.context.createGain(),this.gain.connect(t.getInput()),this.autoplay=!1,this.buffer=null,this.detune=0,this.loop=!1,this.loopStart=0,this.loopEnd=0,this.offset=0,this.duration=void 0,this.playbackRate=1,this.isPlaying=!1,this.hasPlaybackControl=!0,this.source=null,this.sourceType="empty",this._startedAt=0,this._progress=0,this._connected=!1,this.filters=[]}getOutput(){return this.gain}setNodeSource(t){return this.hasPlaybackControl=!1,this.sourceType="audioNode",this.source=t,this.connect(),this}setMediaElementSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaNode",this.source=this.context.createMediaElementSource(t),this.connect(),this}setMediaStreamSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaStreamNode",this.source=this.context.createMediaStreamSource(t),this.connect(),this}setBuffer(t){return this.buffer=t,this.sourceType="buffer",this.autoplay&&this.play(),this}play(t=0){if(this.isPlaying===!0){console.warn("THREE.Audio: Audio is already playing.");return}if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}this._startedAt=this.context.currentTime+t;let r=this.context.createBufferSource();return r.buffer=this.buffer,r.loop=this.loop,r.loopStart=this.loopStart,r.loopEnd=this.loopEnd,r.onended=this.onEnded.bind(this),r.start(this._startedAt,this._progress+this.offset,this.duration),this.isPlaying=!0,this.source=r,this.setDetune(this.detune),this.setPlaybackRate(this.playbackRate),this.connect()}pause(){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this.isPlaying===!0&&(this._progress+=Math.max(this.context.currentTime-this._startedAt,0)*this.playbackRate,this.loop===!0&&(this._progress=this._progress%(this.duration||this.buffer.duration)),this.source.stop(),this.source.onended=null,this.isPlaying=!1),this}stop(){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this._progress=0,this.source.stop(),this.source.onended=null,this.isPlaying=!1,this}connect(){if(this.filters.length>0){this.source.connect(this.filters[0]);for(let t=1,r=this.filters.length;t<r;t++)this.filters[t-1].connect(this.filters[t]);this.filters[this.filters.length-1].connect(this.getOutput())}else this.source.connect(this.getOutput());return this._connected=!0,this}disconnect(){if(this.filters.length>0){this.source.disconnect(this.filters[0]);for(let t=1,r=this.filters.length;t<r;t++)this.filters[t-1].disconnect(this.filters[t]);this.filters[this.filters.length-1].disconnect(this.getOutput())}else this.source.disconnect(this.getOutput());return this._connected=!1,this}getFilters(){return this.filters}setFilters(t){return t||(t=[]),this._connected===!0?(this.disconnect(),this.filters=t.slice(),this.connect()):this.filters=t.slice(),this}setDetune(t){if(this.detune=t,this.source.detune!==void 0)return this.isPlaying===!0&&this.source.detune.setTargetAtTime(this.detune,this.context.currentTime,.01),this}getDetune(){return this.detune}getFilter(){return this.getFilters()[0]}setFilter(t){return this.setFilters(t?[t]:[])}setPlaybackRate(t){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this.playbackRate=t,this.isPlaying===!0&&this.source.playbackRate.setTargetAtTime(this.playbackRate,this.context.currentTime,.01),this}getPlaybackRate(){return this.playbackRate}onEnded(){this.isPlaying=!1}getLoop(){return this.hasPlaybackControl===!1?(console.warn("THREE.Audio: this Audio has no playback control."),!1):this.loop}setLoop(t){if(this.hasPlaybackControl===!1){console.warn("THREE.Audio: this Audio has no playback control.");return}return this.loop=t,this.isPlaying===!0&&(this.source.loop=this.loop),this}setLoopStart(t){return this.loopStart=t,this}setLoopEnd(t){return this.loopEnd=t,this}getVolume(){return this.gain.gain.value}setVolume(t){return this.gain.gain.setTargetAtTime(t,this.context.currentTime,.01),this}},bv=new j,Ehe=new vi,u0r=new j,wv=new j,hht=class extends N6{constructor(t){super(t),this.panner=this.context.createPanner(),this.panner.panningModel="HRTF",this.panner.connect(this.gain)}getOutput(){return this.panner}getRefDistance(){return this.panner.refDistance}setRefDistance(t){return this.panner.refDistance=t,this}getRolloffFactor(){return this.panner.rolloffFactor}setRolloffFactor(t){return this.panner.rolloffFactor=t,this}getDistanceModel(){return this.panner.distanceModel}setDistanceModel(t){return this.panner.distanceModel=t,this}getMaxDistance(){return this.panner.maxDistance}setMaxDistance(t){return this.panner.maxDistance=t,this}setDirectionalCone(t,r,n){return this.panner.coneInnerAngle=t,this.panner.coneOuterAngle=r,this.panner.coneOuterGain=n,this}updateMatrixWorld(t){if(super.updateMatrixWorld(t),this.hasPlaybackControl===!0&&this.isPlaying===!1)return;this.matrixWorld.decompose(bv,Ehe,u0r),wv.set(0,0,1).applyQuaternion(Ehe);let r=this.panner;if(r.positionX){let n=this.context.currentTime+this.listener.timeDelta;r.positionX.linearRampToValueAtTime(bv.x,n),r.positionY.linearRampToValueAtTime(bv.y,n),r.positionZ.linearRampToValueAtTime(bv.z,n),r.orientationX.linearRampToValueAtTime(wv.x,n),r.orientationY.linearRampToValueAtTime(wv.y,n),r.orientationZ.linearRampToValueAtTime(wv.z,n)}else r.setPosition(bv.x,bv.y,bv.z),r.setOrientation(wv.x,wv.y,wv.z)}},zU=class{constructor(t,r=2048){this.analyser=t.context.createAnalyser(),this.analyser.fftSize=r,this.data=new Uint8Array(this.analyser.frequencyBinCount),t.getOutput().connect(this.analyser)}getFrequencyData(){return this.analyser.getByteFrequencyData(this.data),this.data}getAverageFrequency(){let t=0,r=this.getFrequencyData();for(let n=0;n<r.length;n++)t+=r[n];return t/r.length}},FU=class{constructor(t,r,n){this.binding=t,this.valueSize=n;let i,o,a;switch(r){case"quaternion":i=this._slerp,o=this._slerpAdditive,a=this._setAdditiveIdentityQuaternion,this.buffer=new Float64Array(n*6),this._workIndex=5;break;case"string":case"bool":i=this._select,o=this._select,a=this._setAdditiveIdentityOther,this.buffer=new Array(n*5);break;default:i=this._lerp,o=this._lerpAdditive,a=this._setAdditiveIdentityNumeric,this.buffer=new Float64Array(n*5)}this._mixBufferRegion=i,this._mixBufferRegionAdditive=o,this._setIdentity=a,this._origIndex=3,this._addIndex=4,this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,this.useCount=0,this.referenceCount=0}accumulate(t,r){let n=this.buffer,i=this.valueSize,o=t*i+i,a=this.cumulativeWeight;if(a===0){for(let s=0;s!==i;++s)n[o+s]=n[s];a=r}else{a+=r;let s=r/a;this._mixBufferRegion(n,o,0,s,i)}this.cumulativeWeight=a}accumulateAdditive(t){let r=this.buffer,n=this.valueSize,i=n*this._addIndex;this.cumulativeWeightAdditive===0&&this._setIdentity(),this._mixBufferRegionAdditive(r,i,0,t,n),this.cumulativeWeightAdditive+=t}apply(t){let r=this.valueSize,n=this.buffer,i=t*r+r,o=this.cumulativeWeight,a=this.cumulativeWeightAdditive,s=this.binding;if(this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,o<1){let l=r*this._origIndex;this._mixBufferRegion(n,i,l,1-o,r)}a>0&&this._mixBufferRegionAdditive(n,i,this._addIndex*r,1,r);for(let l=r,c=r+r;l!==c;++l)if(n[l]!==n[l+r]){s.setValue(n,i);break}}saveOriginalState(){let t=this.binding,r=this.buffer,n=this.valueSize,i=n*this._origIndex;t.getValue(r,i);for(let o=n,a=i;o!==a;++o)r[o]=r[i+o%n];this._setIdentity(),this.cumulativeWeight=0,this.cumulativeWeightAdditive=0}restoreOriginalState(){let t=this.valueSize*3;this.binding.setValue(this.buffer,t)}_setAdditiveIdentityNumeric(){let t=this._addIndex*this.valueSize,r=t+this.valueSize;for(let n=t;n<r;n++)this.buffer[n]=0}_setAdditiveIdentityQuaternion(){this._setAdditiveIdentityNumeric(),this.buffer[this._addIndex*this.valueSize+3]=1}_setAdditiveIdentityOther(){let t=this._origIndex*this.valueSize,r=this._addIndex*this.valueSize;for(let n=0;n<this.valueSize;n++)this.buffer[r+n]=this.buffer[t+n]}_select(t,r,n,i,o){if(i>=.5)for(let a=0;a!==o;++a)t[r+a]=t[n+a]}_slerp(t,r,n,i){vi.slerpFlat(t,r,t,r,t,n,i)}_slerpAdditive(t,r,n,i,o){let a=this._workIndex*o;vi.multiplyQuaternionsFlat(t,a,t,r,t,n),vi.slerpFlat(t,r,t,r,t,a,i)}_lerp(t,r,n,i,o){let a=1-i;for(let s=0;s!==o;++s){let l=r+s;t[l]=t[l]*a+t[n+s]*i}}_lerpAdditive(t,r,n,i,o){for(let a=0;a!==o;++a){let s=r+a;t[s]=t[s]+t[n+a]*i}}},Bht="\\[\\]\\.:\\/",h0r=new RegExp("["+Bht+"]","g"),Hht="[^"+Bht+"]",f0r="[^"+Bht.replace("\\.","")+"]",p0r=/((?:WC+[\/:])*)/.source.replace("WC",Hht),d0r=/(WCOD+)?/.source.replace("WCOD",f0r),m0r=/(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace("WC",Hht),g0r=/\.(WC+)(?:\[(.+)\])?/.source.replace("WC",Hht),_0r=new RegExp("^"+p0r+d0r+m0r+g0r+"$"),y0r=["material","materials","bones"],fht=class{constructor(t,r,n){let i=n||Cr.parseTrackName(r);this._targetGroup=t,this._bindings=t.subscribe_(r,i)}getValue(t,r){this.bind();let n=this._targetGroup.nCachedObjects_,i=this._bindings[n];i!==void 0&&i.getValue(t,r)}setValue(t,r){let n=this._bindings;for(let i=this._targetGroup.nCachedObjects_,o=n.length;i!==o;++i)n[i].setValue(t,r)}bind(){let t=this._bindings;for(let r=this._targetGroup.nCachedObjects_,n=t.length;r!==n;++r)t[r].bind()}unbind(){let t=this._bindings;for(let r=this._targetGroup.nCachedObjects_,n=t.length;r!==n;++r)t[r].unbind()}},Cr=class{constructor(t,r,n){this.path=r,this.parsedPath=n||Cr.parseTrackName(r),this.node=Cr.findNode(t,this.parsedPath.nodeName)||t,this.rootNode=t,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}static create(t,r,n){return t&&t.isAnimationObjectGroup?new Cr.Composite(t,r,n):new Cr(t,r,n)}static sanitizeNodeName(t){return t.replace(/\s/g,"_").replace(h0r,"")}static parseTrackName(t){let r=_0r.exec(t);if(!r)throw new Error("PropertyBinding: Cannot parse trackName: "+t);let n={nodeName:r[2],objectName:r[3],objectIndex:r[4],propertyName:r[5],propertyIndex:r[6]},i=n.nodeName&&n.nodeName.lastIndexOf(".");if(i!==void 0&&i!==-1){let o=n.nodeName.substring(i+1);y0r.indexOf(o)!==-1&&(n.nodeName=n.nodeName.substring(0,i),n.objectName=o)}if(n.propertyName===null||n.propertyName.length===0)throw new Error("PropertyBinding: can not parse propertyName from trackName: "+t);return n}static findNode(t,r){if(!r||r===""||r==="."||r===-1||r===t.name||r===t.uuid)return t;if(t.skeleton){let n=t.skeleton.getBoneByName(r);if(n!==void 0)return n}if(t.children){let n=function(o){for(let a=0;a<o.length;a++){let s=o[a];if(s.name===r||s.uuid===r)return s;let l=n(s.children);if(l)return l}return null},i=n(t.children);if(i)return i}return null}_getValue_unavailable(){}_setValue_unavailable(){}_getValue_direct(t,r){t[r]=this.targetObject[this.propertyName]}_getValue_array(t,r){let n=this.resolvedProperty;for(let i=0,o=n.length;i!==o;++i)t[r++]=n[i]}_getValue_arrayElement(t,r){t[r]=this.resolvedProperty[this.propertyIndex]}_getValue_toArray(t,r){this.resolvedProperty.toArray(t,r)}_setValue_direct(t,r){this.targetObject[this.propertyName]=t[r]}_setValue_direct_setNeedsUpdate(t,r){this.targetObject[this.propertyName]=t[r],this.targetObject.needsUpdate=!0}_setValue_direct_setMatrixWorldNeedsUpdate(t,r){this.targetObject[this.propertyName]=t[r],this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_array(t,r){let n=this.resolvedProperty;for(let i=0,o=n.length;i!==o;++i)n[i]=t[r++]}_setValue_array_setNeedsUpdate(t,r){let n=this.resolvedProperty;for(let i=0,o=n.length;i!==o;++i)n[i]=t[r++];this.targetObject.needsUpdate=!0}_setValue_array_setMatrixWorldNeedsUpdate(t,r){let n=this.resolvedProperty;for(let i=0,o=n.length;i!==o;++i)n[i]=t[r++];this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_arrayElement(t,r){this.resolvedProperty[this.propertyIndex]=t[r]}_setValue_arrayElement_setNeedsUpdate(t,r){this.resolvedProperty[this.propertyIndex]=t[r],this.targetObject.needsUpdate=!0}_setValue_arrayElement_setMatrixWorldNeedsUpdate(t,r){this.resolvedProperty[this.propertyIndex]=t[r],this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_fromArray(t,r){this.resolvedProperty.fromArray(t,r)}_setValue_fromArray_setNeedsUpdate(t,r){this.resolvedProperty.fromArray(t,r),this.targetObject.needsUpdate=!0}_setValue_fromArray_setMatrixWorldNeedsUpdate(t,r){this.resolvedProperty.fromArray(t,r),this.targetObject.matrixWorldNeedsUpdate=!0}_getValue_unbound(t,r){this.bind(),this.getValue(t,r)}_setValue_unbound(t,r){this.bind(),this.setValue(t,r)}bind(){let t=this.node,r=this.parsedPath,n=r.objectName,i=r.propertyName,o=r.propertyIndex;if(t||(t=Cr.findNode(this.rootNode,r.nodeName)||this.rootNode,this.node=t),this.getValue=this._getValue_unavailable,this.setValue=this._setValue_unavailable,!t){console.error("THREE.PropertyBinding: Trying to update node for track: "+this.path+" but it wasn't found.");return}if(n){let c=r.objectIndex;switch(n){case"materials":if(!t.material){console.error("THREE.PropertyBinding: Can not bind to material as node does not have a material.",this);return}if(!t.material.materials){console.error("THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.",this);return}t=t.material.materials;break;case"bones":if(!t.skeleton){console.error("THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.",this);return}t=t.skeleton.bones;for(let u=0;u<t.length;u++)if(t[u].name===c){c=u;break}break;default:if(t[n]===void 0){console.error("THREE.PropertyBinding: Can not bind to objectName of node undefined.",this);return}t=t[n]}if(c!==void 0){if(t[c]===void 0){console.error("THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.",this,t);return}t=t[c]}}let a=t[i];if(a===void 0){let c=r.nodeName;console.error("THREE.PropertyBinding: Trying to update property for track: "+c+"."+i+" but it wasn't found.",t);return}let s=this.Versioning.None;this.targetObject=t,t.needsUpdate!==void 0?s=this.Versioning.NeedsUpdate:t.matrixWorldNeedsUpdate!==void 0&&(s=this.Versioning.MatrixWorldNeedsUpdate);let l=this.BindingType.Direct;if(o!==void 0){if(i==="morphTargetInfluences"){if(!t.geometry){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.",this);return}if(t.geometry.isBufferGeometry){if(!t.geometry.morphAttributes){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.",this);return}t.morphTargetDictionary[o]!==void 0&&(o=t.morphTargetDictionary[o])}else{console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences on THREE.Geometry. Use THREE.BufferGeometry instead.",this);return}}l=this.BindingType.ArrayElement,this.resolvedProperty=a,this.propertyIndex=o}else a.fromArray!==void 0&&a.toArray!==void 0?(l=this.BindingType.HasFromToArray,this.resolvedProperty=a):Array.isArray(a)?(l=this.BindingType.EntireArray,this.resolvedProperty=a):this.propertyName=i;this.getValue=this.GetterByBindingType[l],this.setValue=this.SetterByBindingTypeAndVersioning[l][s]}unbind(){this.node=null,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}};Cr.Composite=fht;Cr.prototype.BindingType={Direct:0,EntireArray:1,ArrayElement:2,HasFromToArray:3};Cr.prototype.Versioning={None:0,NeedsUpdate:1,MatrixWorldNeedsUpdate:2};Cr.prototype.GetterByBindingType=[Cr.prototype._getValue_direct,Cr.prototype._getValue_array,Cr.prototype._getValue_arrayElement,Cr.prototype._getValue_toArray];Cr.prototype.SetterByBindingTypeAndVersioning=[[Cr.prototype._setValue_direct,Cr.prototype._setValue_direct_setNeedsUpdate,Cr.prototype._setValue_direct_setMatrixWorldNeedsUpdate],[Cr.prototype._setValue_array,Cr.prototype._setValue_array_setNeedsUpdate,Cr.prototype._setValue_array_setMatrixWorldNeedsUpdate],[Cr.prototype._setValue_arrayElement,Cr.prototype._setValue_arrayElement_setNeedsUpdate,Cr.prototype._setValue_arrayElement_setMatrixWorldNeedsUpdate],[Cr.prototype._setValue_fromArray,Cr.prototype._setValue_fromArray_setNeedsUpdate,Cr.prototype._setValue_fromArray_setMatrixWorldNeedsUpdate]];var BU=class{constructor(){this.uuid=Nl(),this._objects=Array.prototype.slice.call(arguments),this.nCachedObjects_=0;let t={};this._indicesByUUID=t;for(let n=0,i=arguments.length;n!==i;++n)t[arguments[n].uuid]=n;this._paths=[],this._parsedPaths=[],this._bindings=[],this._bindingsIndicesByPath={};let r=this;this.stats={objects:{get total(){return r._objects.length},get inUse(){return this.total-r.nCachedObjects_}},get bindingsPerObject(){return r._bindings.length}}}add(){let t=this._objects,r=this._indicesByUUID,n=this._paths,i=this._parsedPaths,o=this._bindings,a=o.length,s,l=t.length,c=this.nCachedObjects_;for(let u=0,h=arguments.length;u!==h;++u){let f=arguments[u],p=f.uuid,d=r[p];if(d===void 0){d=l++,r[p]=d,t.push(f);for(let g=0,_=a;g!==_;++g)o[g].push(new Cr(f,n[g],i[g]))}else if(d<c){s=t[d];let g=--c,_=t[g];r[_.uuid]=d,t[d]=_,r[p]=g,t[g]=f;for(let y=0,x=a;y!==x;++y){let b=o[y],S=b[g],C=b[d];b[d]=S,C===void 0&&(C=new Cr(f,n[y],i[y])),b[g]=C}}else t[d]!==s&&console.error("THREE.AnimationObjectGroup: Different objects with the same UUID detected. Clean the caches or recreate your infrastructure when reloading scenes.")}this.nCachedObjects_=c}remove(){let t=this._objects,r=this._indicesByUUID,n=this._bindings,i=n.length,o=this.nCachedObjects_;for(let a=0,s=arguments.length;a!==s;++a){let l=arguments[a],c=l.uuid,u=r[c];if(u!==void 0&&u>=o){let h=o++,f=t[h];r[f.uuid]=u,t[u]=f,r[c]=h,t[h]=l;for(let p=0,d=i;p!==d;++p){let g=n[p],_=g[h],y=g[u];g[u]=_,g[h]=y}}}this.nCachedObjects_=o}uncache(){let t=this._objects,r=this._indicesByUUID,n=this._bindings,i=n.length,o=this.nCachedObjects_,a=t.length;for(let s=0,l=arguments.length;s!==l;++s){let c=arguments[s],u=c.uuid,h=r[u];if(h!==void 0)if(delete r[u],h<o){let f=--o,p=t[f],d=--a,g=t[d];r[p.uuid]=h,t[h]=p,r[g.uuid]=f,t[f]=g,t.pop();for(let _=0,y=i;_!==y;++_){let x=n[_],b=x[f],S=x[d];x[h]=b,x[f]=S,x.pop()}}else{let f=--a,p=t[f];f>0&&(r[p.uuid]=h),t[h]=p,t.pop();for(let d=0,g=i;d!==g;++d){let _=n[d];_[h]=_[f],_.pop()}}}this.nCachedObjects_=o}subscribe_(t,r){let n=this._bindingsIndicesByPath,i=n[t],o=this._bindings;if(i!==void 0)return o[i];let a=this._paths,s=this._parsedPaths,l=this._objects,c=l.length,u=this.nCachedObjects_,h=new Array(c);i=o.length,n[t]=i,a.push(t),s.push(r),o.push(h);for(let f=u,p=l.length;f!==p;++f){let d=l[f];h[f]=new Cr(d,t,r)}return h}unsubscribe_(t){let r=this._bindingsIndicesByPath,n=r[t];if(n!==void 0){let i=this._paths,o=this._parsedPaths,a=this._bindings,s=a.length-1,l=a[s],c=t[s];r[c]=n,a[n]=l,a.pop(),o[n]=o[s],o.pop(),i[n]=i[s],i.pop()}}};BU.prototype.isAnimationObjectGroup=!0;var pht=class{constructor(t,r,n=null,i=r.blendMode){this._mixer=t,this._clip=r,this._localRoot=n,this.blendMode=i;let o=r.tracks,a=o.length,s=new Array(a),l={endingStart:Ev,endingEnd:Ev};for(let c=0;c!==a;++c){let u=o[c].createInterpolant(null);s[c]=u,u.settings=l}this._interpolantSettings=l,this._interpolants=s,this._propertyBindings=new Array(a),this._cacheIndex=null,this._byClipCacheIndex=null,this._timeScaleInterpolant=null,this._weightInterpolant=null,this.loop=Efe,this._loopCount=-1,this._startTime=null,this.time=0,this.timeScale=1,this._effectiveTimeScale=1,this.weight=1,this._effectiveWeight=1,this.repetitions=1/0,this.paused=!1,this.enabled=!0,this.clampWhenFinished=!1,this.zeroSlopeAtStart=!0,this.zeroSlopeAtEnd=!0}play(){return this._mixer._activateAction(this),this}stop(){return this._mixer._deactivateAction(this),this.reset()}reset(){return this.paused=!1,this.enabled=!0,this.time=0,this._loopCount=-1,this._startTime=null,this.stopFading().stopWarping()}isRunning(){return this.enabled&&!this.paused&&this.timeScale!==0&&this._startTime===null&&this._mixer._isActiveAction(this)}isScheduled(){return this._mixer._isActiveAction(this)}startAt(t){return this._startTime=t,this}setLoop(t,r){return this.loop=t,this.repetitions=r,this}setEffectiveWeight(t){return this.weight=t,this._effectiveWeight=this.enabled?t:0,this.stopFading()}getEffectiveWeight(){return this._effectiveWeight}fadeIn(t){return this._scheduleFading(t,0,1)}fadeOut(t){return this._scheduleFading(t,1,0)}crossFadeFrom(t,r,n){if(t.fadeOut(r),this.fadeIn(r),n){let i=this._clip.duration,o=t._clip.duration,a=o/i,s=i/o;t.warp(1,a,r),this.warp(s,1,r)}return this}crossFadeTo(t,r,n){return t.crossFadeFrom(this,r,n)}stopFading(){let t=this._weightInterpolant;return t!==null&&(this._weightInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}setEffectiveTimeScale(t){return this.timeScale=t,this._effectiveTimeScale=this.paused?0:t,this.stopWarping()}getEffectiveTimeScale(){return this._effectiveTimeScale}setDuration(t){return this.timeScale=this._clip.duration/t,this.stopWarping()}syncWith(t){return this.time=t.time,this.timeScale=t.timeScale,this.stopWarping()}halt(t){return this.warp(this._effectiveTimeScale,0,t)}warp(t,r,n){let i=this._mixer,o=i.time,a=this.timeScale,s=this._timeScaleInterpolant;s===null&&(s=i._lendControlInterpolant(),this._timeScaleInterpolant=s);let l=s.parameterPositions,c=s.sampleValues;return l[0]=o,l[1]=o+n,c[0]=t/a,c[1]=r/a,this}stopWarping(){let t=this._timeScaleInterpolant;return t!==null&&(this._timeScaleInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}getMixer(){return this._mixer}getClip(){return this._clip}getRoot(){return this._localRoot||this._mixer._root}_update(t,r,n,i){if(!this.enabled){this._updateWeight(t);return}let o=this._startTime;if(o!==null){let l=(t-o)*n;if(l<0||n===0)return;this._startTime=null,r=n*l}r*=this._updateTimeScale(t);let a=this._updateTime(r),s=this._updateWeight(t);if(s>0){let l=this._interpolants,c=this._propertyBindings;switch(this.blendMode){case Rht:for(let u=0,h=l.length;u!==h;++u)l[u].evaluate(a),c[u].accumulateAdditive(s);break;case XU:default:for(let u=0,h=l.length;u!==h;++u)l[u].evaluate(a),c[u].accumulate(i,s)}}}_updateWeight(t){let r=0;if(this.enabled){r=this.weight;let n=this._weightInterpolant;if(n!==null){let i=n.evaluate(t)[0];r*=i,t>n.parameterPositions[1]&&(this.stopFading(),i===0&&(this.enabled=!1))}}return this._effectiveWeight=r,r}_updateTimeScale(t){let r=0;if(!this.paused){r=this.timeScale;let n=this._timeScaleInterpolant;n!==null&&(r*=n.evaluate(t)[0],t>n.parameterPositions[1]&&(this.stopWarping(),r===0?this.paused=!0:this.timeScale=r))}return this._effectiveTimeScale=r,r}_updateTime(t){let r=this._clip.duration,n=this.loop,i=this.time+t,o=this._loopCount,a=n===Tfe;if(t===0)return o===-1?i:a&&(o&1)===1?r-i:i;if(n===Mfe){o===-1&&(this._loopCount=0,this._setEndings(!0,!0,!1));t:{if(i>=r)i=r;else if(i<0)i=0;else{this.time=i;break t}this.clampWhenFinished?this.paused=!0:this.enabled=!1,this.time=i,this._mixer.dispatchEvent({type:"finished",action:this,direction:t<0?-1:1})}}else{if(o===-1&&(t>=0?(o=0,this._setEndings(!0,this.repetitions===0,a)):this._setEndings(this.repetitions===0,!0,a)),i>=r||i<0){let s=Math.floor(i/r);i-=r*s,o+=Math.abs(s);let l=this.repetitions-o;if(l<=0)this.clampWhenFinished?this.paused=!0:this.enabled=!1,i=t>0?r:0,this.time=i,this._mixer.dispatchEvent({type:"finished",action:this,direction:t>0?1:-1});else{if(l===1){let c=t<0;this._setEndings(c,!c,a)}else this._setEndings(!1,!1,a);this._loopCount=o,this.time=i,this._mixer.dispatchEvent({type:"loop",action:this,loopDelta:s})}}else this.time=i;if(a&&(o&1)===1)return r-i}return i}_setEndings(t,r,n){let i=this._interpolantSettings;n?(i.endingStart=Tv,i.endingEnd=Tv):(t?i.endingStart=this.zeroSlopeAtStart?Tv:Ev:i.endingStart=ZP,r?i.endingEnd=this.zeroSlopeAtEnd?Tv:Ev:i.endingEnd=ZP)}_scheduleFading(t,r,n){let i=this._mixer,o=i.time,a=this._weightInterpolant;a===null&&(a=i._lendControlInterpolant(),this._weightInterpolant=a);let s=a.parameterPositions,l=a.sampleValues;return s[0]=o,l[0]=r,s[1]=o+t,l[1]=n,this}},HU=class extends Us{constructor(t){super(),this._root=t,this._initMemoryManager(),this._accuIndex=0,this.time=0,this.timeScale=1}_bindAction(t,r){let n=t._localRoot||this._root,i=t._clip.tracks,o=i.length,a=t._propertyBindings,s=t._interpolants,l=n.uuid,c=this._bindingsByRootAndName,u=c[l];u===void 0&&(u={},c[l]=u);for(let h=0;h!==o;++h){let f=i[h],p=f.name,d=u[p];if(d!==void 0)++d.referenceCount,a[h]=d;else{if(d=a[h],d!==void 0){d._cacheIndex===null&&(++d.referenceCount,this._addInactiveBinding(d,l,p));continue}let g=r&&r._propertyBindings[h].binding.parsedPath;d=new FU(Cr.create(n,p,g),f.ValueTypeName,f.getValueSize()),++d.referenceCount,this._addInactiveBinding(d,l,p),a[h]=d}s[h].resultBuffer=d.buffer}}_activateAction(t){if(!this._isActiveAction(t)){if(t._cacheIndex===null){let n=(t._localRoot||this._root).uuid,i=t._clip.uuid,o=this._actionsByClip[i];this._bindAction(t,o&&o.knownActions[0]),this._addInactiveAction(t,i,n)}let r=t._propertyBindings;for(let n=0,i=r.length;n!==i;++n){let o=r[n];o.useCount++===0&&(this._lendBinding(o),o.saveOriginalState())}this._lendAction(t)}}_deactivateAction(t){if(this._isActiveAction(t)){let r=t._propertyBindings;for(let n=0,i=r.length;n!==i;++n){let o=r[n];--o.useCount===0&&(o.restoreOriginalState(),this._takeBackBinding(o))}this._takeBackAction(t)}}_initMemoryManager(){this._actions=[],this._nActiveActions=0,this._actionsByClip={},this._bindings=[],this._nActiveBindings=0,this._bindingsByRootAndName={},this._controlInterpolants=[],this._nActiveControlInterpolants=0;let t=this;this.stats={actions:{get total(){return t._actions.length},get inUse(){return t._nActiveActions}},bindings:{get total(){return t._bindings.length},get inUse(){return t._nActiveBindings}},controlInterpolants:{get total(){return t._controlInterpolants.length},get inUse(){return t._nActiveControlInterpolants}}}}_isActiveAction(t){let r=t._cacheIndex;return r!==null&&r<this._nActiveActions}_addInactiveAction(t,r,n){let i=this._actions,o=this._actionsByClip,a=o[r];if(a===void 0)a={knownActions:[t],actionByRoot:{}},t._byClipCacheIndex=0,o[r]=a;else{let s=a.knownActions;t._byClipCacheIndex=s.length,s.push(t)}t._cacheIndex=i.length,i.push(t),a.actionByRoot[n]=t}_removeInactiveAction(t){let r=this._actions,n=r[r.length-1],i=t._cacheIndex;n._cacheIndex=i,r[i]=n,r.pop(),t._cacheIndex=null;let o=t._clip.uuid,a=this._actionsByClip,s=a[o],l=s.knownActions,c=l[l.length-1],u=t._byClipCacheIndex;c._byClipCacheIndex=u,l[u]=c,l.pop(),t._byClipCacheIndex=null;let h=s.actionByRoot,f=(t._localRoot||this._root).uuid;delete h[f],l.length===0&&delete a[o],this._removeInactiveBindingsForAction(t)}_removeInactiveBindingsForAction(t){let r=t._propertyBindings;for(let n=0,i=r.length;n!==i;++n){let o=r[n];--o.referenceCount===0&&this._removeInactiveBinding(o)}}_lendAction(t){let r=this._actions,n=t._cacheIndex,i=this._nActiveActions++,o=r[i];t._cacheIndex=i,r[i]=t,o._cacheIndex=n,r[n]=o}_takeBackAction(t){let r=this._actions,n=t._cacheIndex,i=--this._nActiveActions,o=r[i];t._cacheIndex=i,r[i]=t,o._cacheIndex=n,r[n]=o}_addInactiveBinding(t,r,n){let i=this._bindingsByRootAndName,o=this._bindings,a=i[r];a===void 0&&(a={},i[r]=a),a[n]=t,t._cacheIndex=o.length,o.push(t)}_removeInactiveBinding(t){let r=this._bindings,n=t.binding,i=n.rootNode.uuid,o=n.path,a=this._bindingsByRootAndName,s=a[i],l=r[r.length-1],c=t._cacheIndex;l._cacheIndex=c,r[c]=l,r.pop(),delete s[o],Object.keys(s).length===0&&delete a[i]}_lendBinding(t){let r=this._bindings,n=t._cacheIndex,i=this._nActiveBindings++,o=r[i];t._cacheIndex=i,r[i]=t,o._cacheIndex=n,r[n]=o}_takeBackBinding(t){let r=this._bindings,n=t._cacheIndex,i=--this._nActiveBindings,o=r[i];t._cacheIndex=i,r[i]=t,o._cacheIndex=n,r[n]=o}_lendControlInterpolant(){let t=this._controlInterpolants,r=this._nActiveControlInterpolants++,n=t[r];return n===void 0&&(n=new w6(new Float32Array(2),new Float32Array(2),1,this._controlInterpolantsResultBuffer),n.__cacheIndex=r,t[r]=n),n}_takeBackControlInterpolant(t){let r=this._controlInterpolants,n=t.__cacheIndex,i=--this._nActiveControlInterpolants,o=r[i];t.__cacheIndex=i,r[i]=t,o.__cacheIndex=n,r[n]=o}clipAction(t,r,n){let i=r||this._root,o=i.uuid,a=typeof t=="string"?Qv.findByName(i,t):t,s=a!==null?a.uuid:t,l=this._actionsByClip[s],c=null;if(n===void 0&&(a!==null?n=a.blendMode:n=XU),l!==void 0){let h=l.actionByRoot[o];if(h!==void 0&&h.blendMode===n)return h;c=l.knownActions[0],a===null&&(a=c._clip)}if(a===null)return null;let u=new pht(this,a,r,n);return this._bindAction(u,c),this._addInactiveAction(u,s,o),u}existingAction(t,r){let n=r||this._root,i=n.uuid,o=typeof t=="string"?Qv.findByName(n,t):t,a=o?o.uuid:t,s=this._actionsByClip[a];return s!==void 0&&s.actionByRoot[i]||null}stopAllAction(){let t=this._actions,r=this._nActiveActions;for(let n=r-1;n>=0;--n)t[n].stop();return this}update(t){t*=this.timeScale;let r=this._actions,n=this._nActiveActions,i=this.time+=t,o=Math.sign(t),a=this._accuIndex^=1;for(let c=0;c!==n;++c)r[c]._update(i,t,o,a);let s=this._bindings,l=this._nActiveBindings;for(let c=0;c!==l;++c)s[c].apply(a);return this}setTime(t){this.time=0;for(let r=0;r<this._actions.length;r++)this._actions[r].time=0;return this.update(t)}getRoot(){return this._root}uncacheClip(t){let r=this._actions,n=t.uuid,i=this._actionsByClip,o=i[n];if(o!==void 0){let a=o.knownActions;for(let s=0,l=a.length;s!==l;++s){let c=a[s];this._deactivateAction(c);let u=c._cacheIndex,h=r[r.length-1];c._cacheIndex=null,c._byClipCacheIndex=null,h._cacheIndex=u,r[u]=h,r.pop(),this._removeInactiveBindingsForAction(c)}delete i[n]}}uncacheRoot(t){let r=t.uuid,n=this._actionsByClip;for(let a in n){let s=n[a].actionByRoot,l=s[r];l!==void 0&&(this._deactivateAction(l),this._removeInactiveAction(l))}let i=this._bindingsByRootAndName,o=i[r];if(o!==void 0)for(let a in o){let s=o[a];s.restoreOriginalState(),this._removeInactiveBinding(s)}}uncacheAction(t,r){let n=this.existingAction(t,r);n!==null&&(this._deactivateAction(n),this._removeInactiveAction(n))}};HU.prototype._controlInterpolantsResultBuffer=new Float32Array(1);var gM=class{constructor(t){typeof t=="string"&&(console.warn("THREE.Uniform: Type parameter is no longer needed."),t=arguments[1]),this.value=t}clone(){return new gM(this.value.clone===void 0?this.value:this.value.clone())}},VU=class extends em{constructor(t,r,n=1){super(t,r),this.meshPerAttribute=n}copy(t){return super.copy(t),this.meshPerAttribute=t.meshPerAttribute,this}clone(t){let r=super.clone(t);return r.meshPerAttribute=this.meshPerAttribute,r}toJSON(t){let r=super.toJSON(t);return r.isInstancedInterleavedBuffer=!0,r.meshPerAttribute=this.meshPerAttribute,r}};VU.prototype.isInstancedInterleavedBuffer=!0;var UU=class{constructor(t,r,n,i,o){this.buffer=t,this.type=r,this.itemSize=n,this.elementSize=i,this.count=o,this.version=0}set needsUpdate(t){t===!0&&this.version++}setBuffer(t){return this.buffer=t,this}setType(t,r){return this.type=t,this.elementSize=r,this}setItemSize(t){return this.itemSize=t,this}setCount(t){return this.count=t,this}};UU.prototype.isGLBufferAttribute=!0;var dht=class{constructor(t,r,n=0,i=1/0){this.ray=new Jf(t,r),this.near=n,this.far=i,this.camera=null,this.layers=new X3,this.params={Mesh:{},Line:{threshold:1},LOD:{},Points:{threshold:1},Sprite:{}}}set(t,r){this.ray.set(t,r)}setFromCamera(t,r){r&&r.isPerspectiveCamera?(this.ray.origin.setFromMatrixPosition(r.matrixWorld),this.ray.direction.set(t.x,t.y,.5).unproject(r).sub(this.ray.origin).normalize(),this.camera=r):r&&r.isOrthographicCamera?(this.ray.origin.set(t.x,t.y,(r.near+r.far)/(r.near-r.far)).unproject(r),this.ray.direction.set(0,0,-1).transformDirection(r.matrixWorld),this.camera=r):console.error("THREE.Raycaster: Unsupported camera type: "+r.type)}intersectObject(t,r=!0,n=[]){return mht(t,this,n,r),n.sort(The),n}intersectObjects(t,r=!0,n=[]){for(let i=0,o=t.length;i<o;i++)mht(t[i],this,n,r);return n.sort(The),n}};function The(e,t){return e.distance-t.distance}function mht(e,t,r,n){if(e.layers.test(t.layers)&&e.raycast(t,r),n===!0){let i=e.children;for(let o=0,a=i.length;o<a;o++)mht(i[o],t,r,!0)}}var _M=class{constructor(t=1,r=0,n=0){return this.radius=t,this.phi=r,this.theta=n,this}set(t,r,n){return this.radius=t,this.phi=r,this.theta=n,this}copy(t){return this.radius=t.radius,this.phi=t.phi,this.theta=t.theta,this}makeSafe(){return this.phi=Math.max(1e-6,Math.min(Math.PI-1e-6,this.phi)),this}setFromVector3(t){return this.setFromCartesianCoords(t.x,t.y,t.z)}setFromCartesianCoords(t,r,n){return this.radius=Math.sqrt(t*t+r*r+n*n),this.radius===0?(this.theta=0,this.phi=0):(this.theta=Math.atan2(t,n),this.phi=Math.acos(Zo(r/this.radius,-1,1))),this}clone(){return new this.constructor().copy(this)}},ght=class{constructor(t=1,r=0,n=0){return this.radius=t,this.theta=r,this.y=n,this}set(t,r,n){return this.radius=t,this.theta=r,this.y=n,this}copy(t){return this.radius=t.radius,this.theta=t.theta,this.y=t.y,this}setFromVector3(t){return this.setFromCartesianCoords(t.x,t.y,t.z)}setFromCartesianCoords(t,r,n){return this.radius=Math.sqrt(t*t+n*n),this.theta=Math.atan2(t,n),this.y=r,this}clone(){return new this.constructor().copy(this)}},Che=new Lt,$0=class{constructor(t=new Lt(1/0,1/0),r=new Lt(-1/0,-1/0)){this.min=t,this.max=r}set(t,r){return this.min.copy(t),this.max.copy(r),this}setFromPoints(t){this.makeEmpty();for(let r=0,n=t.length;r<n;r++)this.expandByPoint(t[r]);return this}setFromCenterAndSize(t,r){let n=Che.copy(r).multiplyScalar(.5);return this.min.copy(t).sub(n),this.max.copy(t).add(n),this}clone(){return new this.constructor().copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=1/0,this.max.x=this.max.y=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y}getCenter(t){return this.isEmpty()?t.set(0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return this.isEmpty()?t.set(0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y}getParameter(t,r){return r.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y)}clampPoint(t,r){return r.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return Che.copy(t).clamp(this.min,this.max).sub(t).length()}intersect(t){return this.min.max(t.min),this.max.min(t.max),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}};$0.prototype.isBox2=!0;var Ahe=new j,WV=new j,qU=class{constructor(t=new j,r=new j){this.start=t,this.end=r}set(t,r){return this.start.copy(t),this.end.copy(r),this}copy(t){return this.start.copy(t.start),this.end.copy(t.end),this}getCenter(t){return t.addVectors(this.start,this.end).multiplyScalar(.5)}delta(t){return t.subVectors(this.end,this.start)}distanceSq(){return this.start.distanceToSquared(this.end)}distance(){return this.start.distanceTo(this.end)}at(t,r){return this.delta(r).multiplyScalar(t).add(this.start)}closestPointToPointParameter(t,r){Ahe.subVectors(t,this.start),WV.subVectors(this.end,this.start);let n=WV.dot(WV),o=WV.dot(Ahe)/n;return r&&(o=Zo(o,0,1)),o}closestPointToPoint(t,r,n){let i=this.closestPointToPointParameter(t,r);return this.delta(n).multiplyScalar(i).add(this.start)}applyMatrix4(t){return this.start.applyMatrix4(t),this.end.applyMatrix4(t),this}equals(t){return t.start.equals(this.start)&&t.end.equals(this.end)}clone(){return new this.constructor().copy(this)}},Phe=new j,_ht=class extends or{constructor(t,r){super(),this.light=t,this.light.updateMatrixWorld(),this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1,this.color=r;let n=new Pe,i=[0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,-1,0,1,0,0,0,0,1,1,0,0,0,0,-1,1];for(let a=0,s=1,l=32;a<l;a++,s++){let c=a/l*Math.PI*2,u=s/l*Math.PI*2;i.push(Math.cos(c),Math.sin(c),1,Math.cos(u),Math.sin(u),1)}n.setAttribute("position",new xe(i,3));let o=new Gi({fog:!1,toneMapped:!1});this.cone=new Aa(n,o),this.add(this.cone),this.update()}dispose(){this.cone.geometry.dispose(),this.cone.material.dispose()}update(){this.light.updateMatrixWorld();let t=this.light.distance?this.light.distance:1e3,r=t*Math.tan(this.light.angle);this.cone.scale.set(r,r,t),Phe.setFromMatrixPosition(this.light.target.matrixWorld),this.cone.lookAt(Phe),this.color!==void 0?this.cone.material.color.set(this.color):this.cone.material.color.copy(this.light.color)}},O0=new j,YV=new Me,wut=new Me,GU=class extends Aa{constructor(t){let r=tpe(t),n=new Pe,i=[],o=[],a=new ne(0,0,1),s=new ne(0,1,0);for(let c=0;c<r.length;c++){let u=r[c];u.parent&&u.parent.isBone&&(i.push(0,0,0),i.push(0,0,0),o.push(a.r,a.g,a.b),o.push(s.r,s.g,s.b))}n.setAttribute("position",new xe(i,3)),n.setAttribute("color",new xe(o,3));let l=new Gi({vertexColors:!0,depthTest:!1,depthWrite:!1,toneMapped:!1,transparent:!0});super(n,l),this.type="SkeletonHelper",this.isSkeletonHelper=!0,this.root=t,this.bones=r,this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1}updateMatrixWorld(t){let r=this.bones,n=this.geometry,i=n.getAttribute("position");wut.copy(this.root.matrixWorld).invert();for(let o=0,a=0;o<r.length;o++){let s=r[o];s.parent&&s.parent.isBone&&(YV.multiplyMatrices(wut,s.matrixWorld),O0.setFromMatrixPosition(YV),i.setXYZ(a,O0.x,O0.y,O0.z),YV.multiplyMatrices(wut,s.parent.matrixWorld),O0.setFromMatrixPosition(YV),i.setXYZ(a+1,O0.x,O0.y,O0.z),a+=2)}n.getAttribute("position").needsUpdate=!0,super.updateMatrixWorld(t)}};function tpe(e){let t=[];e&&e.isBone&&t.push(e);for(let r=0;r<e.children.length;r++)t.push.apply(t,tpe(e.children[r]));return t}var yht=class extends ei{constructor(t,r,n){let i=new j0(r,4,2),o=new sh({wireframe:!0,fog:!1,toneMapped:!1});super(i,o),this.light=t,this.light.updateMatrixWorld(),this.color=n,this.type="PointLightHelper",this.matrix=this.light.matrixWorld,this.matrixAutoUpdate=!1,this.update()}dispose(){this.geometry.dispose(),this.material.dispose()}update(){this.color!==void 0?this.material.color.set(this.color):this.material.color.copy(this.light.color)}},v0r=new j,Ihe=new ne,Lhe=new ne,vht=class extends or{constructor(t,r,n){super(),this.light=t,this.light.updateMatrixWorld(),this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1,this.color=n;let i=new W0(r);i.rotateY(Math.PI*.5),this.material=new sh({wireframe:!0,fog:!1,toneMapped:!1}),this.color===void 0&&(this.material.vertexColors=!0);let o=i.getAttribute("position"),a=new Float32Array(o.count*3);i.setAttribute("color",new Je(a,3)),this.add(new ei(i,this.material)),this.update()}dispose(){this.children[0].geometry.dispose(),this.children[0].material.dispose()}update(){let t=this.children[0];if(this.color!==void 0)this.material.color.set(this.color);else{let r=t.geometry.getAttribute("color");Ihe.copy(this.light.color),Lhe.copy(this.light.groundColor);for(let n=0,i=r.count;n<i;n++){let o=n<i/2?Ihe:Lhe;r.setXYZ(n,o.r,o.g,o.b)}r.needsUpdate=!0}t.lookAt(v0r.setFromMatrixPosition(this.light.matrixWorld).negate())}},WU=class extends Aa{constructor(t=10,r=10,n=4473924,i=8947848){n=new ne(n),i=new ne(i);let o=r/2,a=t/r,s=t/2,l=[],c=[];for(let f=0,p=0,d=-s;f<=r;f++,d+=a){l.push(-s,0,d,s,0,d),l.push(d,0,-s,d,0,s);let g=f===o?n:i;g.toArray(c,p),p+=3,g.toArray(c,p),p+=3,g.toArray(c,p),p+=3,g.toArray(c,p),p+=3}let u=new Pe;u.setAttribute("position",new xe(l,3)),u.setAttribute("color",new xe(c,3));let h=new Gi({vertexColors:!0,toneMapped:!1});super(u,h),this.type="GridHelper"}},xht=class extends Aa{constructor(t=10,r=16,n=8,i=64,o=4473924,a=8947848){o=new ne(o),a=new ne(a);let s=[],l=[];for(let h=0;h<=r;h++){let f=h/r*(Math.PI*2),p=Math.sin(f)*t,d=Math.cos(f)*t;s.push(0,0,0),s.push(p,0,d);let g=h&1?o:a;l.push(g.r,g.g,g.b),l.push(g.r,g.g,g.b)}for(let h=0;h<=n;h++){let f=h&1?o:a,p=t-t/n*h;for(let d=0;d<i;d++){let g=d/i*(Math.PI*2),_=Math.sin(g)*p,y=Math.cos(g)*p;s.push(_,0,y),l.push(f.r,f.g,f.b),g=(d+1)/i*(Math.PI*2),_=Math.sin(g)*p,y=Math.cos(g)*p,s.push(_,0,y),l.push(f.r,f.g,f.b)}}let c=new Pe;c.setAttribute("position",new xe(s,3)),c.setAttribute("color",new xe(l,3));let u=new Gi({vertexColors:!0,toneMapped:!1});super(c,u),this.type="PolarGridHelper"}},khe=new j,jV=new j,Rhe=new j,bht=class extends or{constructor(t,r,n){super(),this.light=t,this.light.updateMatrixWorld(),this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1,this.color=n,r===void 0&&(r=1);let i=new Pe;i.setAttribute("position",new xe([-r,r,0,r,r,0,r,-r,0,-r,-r,0,-r,r,0],3));let o=new Gi({fog:!1,toneMapped:!1});this.lightPlane=new ch(i,o),this.add(this.lightPlane),i=new Pe,i.setAttribute("position",new xe([0,0,0,0,0,1],3)),this.targetLine=new ch(i,o),this.add(this.targetLine),this.update()}dispose(){this.lightPlane.geometry.dispose(),this.lightPlane.material.dispose(),this.targetLine.geometry.dispose(),this.targetLine.material.dispose()}update(){khe.setFromMatrixPosition(this.light.matrixWorld),jV.setFromMatrixPosition(this.light.target.matrixWorld),Rhe.subVectors(jV,khe),this.lightPlane.lookAt(jV),this.color!==void 0?(this.lightPlane.material.color.set(this.color),this.targetLine.material.color.set(this.color)):(this.lightPlane.material.color.copy(this.light.color),this.targetLine.material.color.copy(this.light.color)),this.targetLine.lookAt(jV),this.targetLine.scale.z=Rhe.length()}},XV=new j,yi=new Rv,wht=class extends Aa{constructor(t){let r=new Pe,n=new Gi({color:16777215,vertexColors:!0,toneMapped:!1}),i=[],o=[],a={},s=new ne(16755200),l=new ne(16711680),c=new ne(43775),u=new ne(16777215),h=new ne(3355443);f("n1","n2",s),f("n2","n4",s),f("n4","n3",s),f("n3","n1",s),f("f1","f2",s),f("f2","f4",s),f("f4","f3",s),f("f3","f1",s),f("n1","f1",s),f("n2","f2",s),f("n3","f3",s),f("n4","f4",s),f("p","n1",l),f("p","n2",l),f("p","n3",l),f("p","n4",l),f("u1","u2",c),f("u2","u3",c),f("u3","u1",c),f("c","t",u),f("p","c",h),f("cn1","cn2",h),f("cn3","cn4",h),f("cf1","cf2",h),f("cf3","cf4",h);function f(d,g,_){p(d,_),p(g,_)}function p(d,g){i.push(0,0,0),o.push(g.r,g.g,g.b),a[d]===void 0&&(a[d]=[]),a[d].push(i.length/3-1)}r.setAttribute("position",new xe(i,3)),r.setAttribute("color",new xe(o,3)),super(r,n),this.type="CameraHelper",this.camera=t,this.camera.updateProjectionMatrix&&this.camera.updateProjectionMatrix(),this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1,this.pointMap=a,this.update()}update(){let t=this.geometry,r=this.pointMap,n=1,i=1;yi.projectionMatrixInverse.copy(this.camera.projectionMatrixInverse),Pi("c",r,t,yi,0,0,-1),Pi("t",r,t,yi,0,0,1),Pi("n1",r,t,yi,-n,-i,-1),Pi("n2",r,t,yi,n,-i,-1),Pi("n3",r,t,yi,-n,i,-1),Pi("n4",r,t,yi,n,i,-1),Pi("f1",r,t,yi,-n,-i,1),Pi("f2",r,t,yi,n,-i,1),Pi("f3",r,t,yi,-n,i,1),Pi("f4",r,t,yi,n,i,1),Pi("u1",r,t,yi,n*.7,i*1.1,-1),Pi("u2",r,t,yi,-n*.7,i*1.1,-1),Pi("u3",r,t,yi,0,i*2,-1),Pi("cf1",r,t,yi,-n,0,1),Pi("cf2",r,t,yi,n,0,1),Pi("cf3",r,t,yi,0,-i,1),Pi("cf4",r,t,yi,0,i,1),Pi("cn1",r,t,yi,-n,0,-1),Pi("cn2",r,t,yi,n,0,-1),Pi("cn3",r,t,yi,0,-i,-1),Pi("cn4",r,t,yi,0,i,-1),t.getAttribute("position").needsUpdate=!0}dispose(){this.geometry.dispose(),this.material.dispose()}};function Pi(e,t,r,n,i,o,a){XV.set(i,o,a).unproject(n);let s=t[e];if(s!==void 0){let l=r.getAttribute("position");for(let c=0,u=s.length;c<u;c++)l.setXYZ(s[c],XV.x,XV.y,XV.z)}}var $V=new ta,yM=class extends Aa{constructor(t,r=16776960){let n=new Uint16Array([0,1,1,2,2,3,3,0,4,5,5,6,6,7,7,4,0,4,1,5,2,6,3,7]),i=new Float32Array(8*3),o=new Pe;o.setIndex(new Je(n,1)),o.setAttribute("position",new Je(i,3)),super(o,new Gi({color:r,toneMapped:!1})),this.object=t,this.type="BoxHelper",this.matrixAutoUpdate=!1,this.update()}update(t){if(t!==void 0&&console.warn("THREE.BoxHelper: .update() has no longer arguments."),this.object!==void 0&&$V.setFromObject(this.object),$V.isEmpty())return;let r=$V.min,n=$V.max,i=this.geometry.attributes.position,o=i.array;o[0]=n.x,o[1]=n.y,o[2]=n.z,o[3]=r.x,o[4]=n.y,o[5]=n.z,o[6]=r.x,o[7]=r.y,o[8]=n.z,o[9]=n.x,o[10]=r.y,o[11]=n.z,o[12]=n.x,o[13]=n.y,o[14]=r.z,o[15]=r.x,o[16]=n.y,o[17]=r.z,o[18]=r.x,o[19]=r.y,o[20]=r.z,o[21]=n.x,o[22]=r.y,o[23]=r.z,i.needsUpdate=!0,this.geometry.computeBoundingSphere()}setFromObject(t){return this.object=t,this.update(),this}copy(t){return Aa.prototype.copy.call(this,t),this.object=t.object,this}},Sht=class extends Aa{constructor(t,r=16776960){let n=new Uint16Array([0,1,1,2,2,3,3,0,4,5,5,6,6,7,7,4,0,4,1,5,2,6,3,7]),i=[1,1,1,-1,1,1,-1,-1,1,1,-1,1,1,1,-1,-1,1,-1,-1,-1,-1,1,-1,-1],o=new Pe;o.setIndex(new Je(n,1)),o.setAttribute("position",new xe(i,3)),super(o,new Gi({color:r,toneMapped:!1})),this.box=t,this.type="Box3Helper",this.geometry.computeBoundingSphere()}updateMatrixWorld(t){let r=this.box;r.isEmpty()||(r.getCenter(this.position),r.getSize(this.scale),this.scale.multiplyScalar(.5),super.updateMatrixWorld(t))}},Mht=class extends ch{constructor(t,r=1,n=16776960){let i=n,o=[1,-1,1,-1,1,1,-1,-1,1,1,1,1,-1,1,1,-1,-1,1,1,-1,1,1,1,1,0,0,1,0,0,0],a=new Pe;a.setAttribute("position",new xe(o,3)),a.computeBoundingSphere(),super(a,new Gi({color:i,toneMapped:!1})),this.type="PlaneHelper",this.plane=t,this.size=r;let s=[1,1,1,-1,1,1,-1,-1,1,1,1,1,-1,-1,1,1,-1,1],l=new Pe;l.setAttribute("position",new xe(s,3)),l.computeBoundingSphere(),this.add(new ei(l,new sh({color:i,opacity:.2,transparent:!0,depthWrite:!1,toneMapped:!1})))}updateMatrixWorld(t){let r=-this.plane.constant;Math.abs(r)<1e-8&&(r=1e-8),this.scale.set(.5*this.size,.5*this.size,r),this.children[0].material.side=r<0?Ii:Iv,this.lookAt(this.plane.normal),super.updateMatrixWorld(t)}},Nhe=new j,KV,Sut,Eht=class extends or{constructor(t=new j(0,0,1),r=new j(0,0,0),n=1,i=16776960,o=n*.2,a=o*.2){super(),this.type="ArrowHelper",KV===void 0&&(KV=new Pe,KV.setAttribute("position",new xe([0,0,0,0,1,0],3)),Sut=new om(0,.5,1,5,1),Sut.translate(0,-.5,0)),this.position.copy(r),this.line=new ch(KV,new Gi({color:i,toneMapped:!1})),this.line.matrixAutoUpdate=!1,this.add(this.line),this.cone=new ei(Sut,new sh({color:i,toneMapped:!1})),this.cone.matrixAutoUpdate=!1,this.add(this.cone),this.setDirection(t),this.setLength(n,o,a)}setDirection(t){if(t.y>.99999)this.quaternion.set(0,0,0,1);else if(t.y<-.99999)this.quaternion.set(1,0,0,0);else{Nhe.set(t.z,0,-t.x).normalize();let r=Math.acos(t.y);this.quaternion.setFromAxisAngle(Nhe,r)}}setLength(t,r=t*.2,n=r*.2){this.line.scale.set(1,Math.max(1e-4,t-r),1),this.line.updateMatrix(),this.cone.scale.set(n,r,n),this.cone.position.y=t,this.cone.updateMatrix()}setColor(t){this.line.material.color.set(t),this.cone.material.color.set(t)}copy(t){return super.copy(t,!1),this.line.copy(t.line),this.cone.copy(t.cone),this}},vM=class extends Aa{constructor(t=1){let r=[0,0,0,t,0,0,0,0,0,0,t,0,0,0,0,0,0,t],n=[1,0,0,1,.6,0,0,1,0,.6,1,0,0,0,1,0,.6,1],i=new Pe;i.setAttribute("position",new xe(r,3)),i.setAttribute("color",new xe(n,3));let o=new Gi({vertexColors:!0,toneMapped:!1});super(i,o),this.type="AxesHelper"}setColors(t,r,n){let i=new ne,o=this.geometry.attributes.color.array;return i.set(t),i.toArray(o,0),i.toArray(o,3),i.set(r),i.toArray(o,6),i.toArray(o,9),i.set(n),i.toArray(o,12),i.toArray(o,15),this.geometry.attributes.color.needsUpdate=!0,this}dispose(){this.geometry.dispose(),this.material.dispose()}},Tht=class{constructor(){this.type="ShapePath",this.color=new ne,this.subPaths=[],this.currentPath=null}moveTo(t,r){return this.currentPath=new qv,this.subPaths.push(this.currentPath),this.currentPath.moveTo(t,r),this}lineTo(t,r){return this.currentPath.lineTo(t,r),this}quadraticCurveTo(t,r,n,i){return this.currentPath.quadraticCurveTo(t,r,n,i),this}bezierCurveTo(t,r,n,i,o,a){return this.currentPath.bezierCurveTo(t,r,n,i,o,a),this}splineThru(t){return this.currentPath.splineThru(t),this}toShapes(t,r){function n(x){let b=[];for(let S=0,C=x.length;S<C;S++){let P=x[S],k=new Kc;k.curves=P.curves,b.push(k)}return b}function i(x,b){let S=b.length,C=!1;for(let P=S-1,k=0;k<S;P=k++){let O=b[P],D=b[k],B=D.x-O.x,I=D.y-O.y;if(Math.abs(I)>Number.EPSILON){if(I<0&&(O=b[k],B=-B,D=b[P],I=-I),x.y<O.y||x.y>D.y)continue;if(x.y===O.y){if(x.x===O.x)return!0}else{let L=I*(x.x-O.x)-B*(x.y-O.y);if(L===0)return!0;if(L<0)continue;C=!C}}else{if(x.y!==O.y)continue;if(D.x<=x.x&&x.x<=O.x||O.x<=x.x&&x.x<=D.x)return!0}}return C}let o=Zc.isClockWise,a=this.subPaths;if(a.length===0)return[];if(r===!0)return n(a);let s,l,c,u=[];if(a.length===1)return l=a[0],c=new Kc,c.curves=l.curves,u.push(c),u;let h=!o(a[0].getPoints());h=t?!h:h;let f=[],p=[],d=[],g=0,_;p[g]=void 0,d[g]=[];for(let x=0,b=a.length;x<b;x++)l=a[x],_=l.getPoints(),s=o(_),s=t?!s:s,s?(!h&&p[g]&&g++,p[g]={s:new Kc,p:_},p[g].s.curves=l.curves,h&&g++,d[g]=[]):d[g].push({h:l,p:_[0]});if(!p[0])return n(a);if(p.length>1){let x=!1,b=[];for(let S=0,C=p.length;S<C;S++)f[S]=[];for(let S=0,C=p.length;S<C;S++){let P=d[S];for(let k=0;k<P.length;k++){let O=P[k],D=!0;for(let B=0;B<p.length;B++)i(O.p,p[B].p)&&(S!==B&&b.push({froms:S,tos:B,hole:k}),D?(D=!1,f[B].push(O)):x=!0);D&&f[S].push(O)}}b.length>0&&(x||(d=f))}let y;for(let x=0,b=p.length;x<b;x++){c=p[x].s,u.push(c),y=d[x];for(let S=0,C=y.length;S<C;S++)c.holes.push(y[S].h)}return u}},epe=new Float32Array(1),x0r=new Int32Array(epe.buffer),Cht=class{static toHalfFloat(t){t>65504&&(console.warn("THREE.DataUtils.toHalfFloat(): value exceeds 65504."),t=65504),epe[0]=t;let r=x0r[0],n=r>>16&32768,i=r>>12&2047,o=r>>23&255;return o<103?n:o>142?(n|=31744,n|=(o==255?0:1)&&r&8388607,n):o<113?(i|=2048,n|=(i>>114-o)+(i>>113-o&1),n):(n|=o-112<<10|i>>1,n+=i&1,n)}},b0r=0,w0r=1,S0r=0,M0r=1,E0r=2;function T0r(e){return console.warn("THREE.MeshFaceMaterial has been removed. Use an Array instead."),e}function C0r(e=[]){return console.warn("THREE.MultiMaterial has been removed. Use an Array instead."),e.isMultiMaterial=!0,e.materials=e,e.clone=function(){return e.slice()},e}function A0r(e,t){return console.warn("THREE.PointCloud has been renamed to THREE.Points."),new im(e,t)}function P0r(e){return console.warn("THREE.Particle has been renamed to THREE.Sprite."),new oM(e)}function I0r(e,t){return console.warn("THREE.ParticleSystem has been renamed to THREE.Points."),new im(e,t)}function L0r(e){return console.warn("THREE.PointCloudMaterial has been renamed to THREE.PointsMaterial."),new nm(e)}function k0r(e){return console.warn("THREE.ParticleBasicMaterial has been renamed to THREE.PointsMaterial."),new nm(e)}function R0r(e){return console.warn("THREE.ParticleSystemMaterial has been renamed to THREE.PointsMaterial."),new nm(e)}function N0r(e,t,r){return console.warn("THREE.Vertex has been removed. Use THREE.Vector3 instead."),new j(e,t,r)}function D0r(e,t){return console.warn("THREE.DynamicBufferAttribute has been removed. Use new THREE.BufferAttribute().setUsage( THREE.DynamicDrawUsage ) instead."),new Je(e,t).setUsage(Y3)}function O0r(e,t){return console.warn("THREE.Int8Attribute has been removed. Use new THREE.Int8BufferAttribute() instead."),new lU(e,t)}function z0r(e,t){return console.warn("THREE.Uint8Attribute has been removed. Use new THREE.Uint8BufferAttribute() instead."),new cU(e,t)}function F0r(e,t){return console.warn("THREE.Uint8ClampedAttribute has been removed. Use new THREE.Uint8ClampedBufferAttribute() instead."),new uU(e,t)}function B0r(e,t){return console.warn("THREE.Int16Attribute has been removed. Use new THREE.Int16BufferAttribute() instead."),new hU(e,t)}function H0r(e,t){return console.warn("THREE.Uint16Attribute has been removed. Use new THREE.Uint16BufferAttribute() instead."),new $3(e,t)}function V0r(e,t){return console.warn("THREE.Int32Attribute has been removed. Use new THREE.Int32BufferAttribute() instead."),new fU(e,t)}function U0r(e,t){return console.warn("THREE.Uint32Attribute has been removed. Use new THREE.Uint32BufferAttribute() instead."),new K3(e,t)}function q0r(e,t){return console.warn("THREE.Float32Attribute has been removed. Use new THREE.Float32BufferAttribute() instead."),new xe(e,t)}function G0r(e,t){return console.warn("THREE.Float64Attribute has been removed. Use new THREE.Float64BufferAttribute() instead."),new dU(e,t)}fs.create=function(e,t){return console.log("THREE.Curve.create() has been deprecated"),e.prototype=Object.create(fs.prototype),e.prototype.constructor=e,e.prototype.getPoint=t,e};qv.prototype.fromPoints=function(e){return console.warn("THREE.Path: .fromPoints() has been renamed to .setFromPoints()."),this.setFromPoints(e)};function W0r(e){return console.warn("THREE.AxisHelper has been renamed to THREE.AxesHelper."),new vM(e)}function Y0r(e,t){return console.warn("THREE.BoundingBoxHelper has been deprecated. Creating a THREE.BoxHelper instead."),new yM(e,t)}function j0r(e,t){return console.warn("THREE.EdgesHelper has been removed. Use THREE.EdgesGeometry instead."),new Aa(new a6(e.geometry),new Gi({color:t!==void 0?t:16777215}))}WU.prototype.setColors=function(){console.error("THREE.GridHelper: setColors() has been deprecated, pass them in the constructor instead.")};GU.prototype.update=function(){console.error("THREE.SkeletonHelper: update() no longer needs to be called.")};function X0r(e,t){return console.warn("THREE.WireframeHelper has been removed. Use THREE.WireframeGeometry instead."),new Aa(new p6(e.geometry),new Gi({color:t!==void 0?t:16777215}))}ea.prototype.extractUrlBase=function(e){return console.warn("THREE.Loader: .extractUrlBase() has been deprecated. Use THREE.LoaderUtils.extractUrlBase() instead."),dM.extractUrlBase(e)};ea.Handlers={add:function(){console.error("THREE.Loader: Handlers.add() has been removed. Use LoadingManager.addHandler() instead.")},get:function(){console.error("THREE.Loader: Handlers.get() has been removed. Use LoadingManager.getHandler() instead.")}};function $0r(e){return console.warn("THREE.XHRLoader has been renamed to THREE.FileLoader."),new Jc(e)}function K0r(e){return console.warn("THREE.BinaryTextureLoader has been renamed to THREE.DataTextureLoader."),new TU(e)}$0.prototype.center=function(e){return console.warn("THREE.Box2: .center() has been renamed to .getCenter()."),this.getCenter(e)};$0.prototype.empty=function(){return console.warn("THREE.Box2: .empty() has been renamed to .isEmpty()."),this.isEmpty()};$0.prototype.isIntersectionBox=function(e){return console.warn("THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(e)};$0.prototype.size=function(e){return console.warn("THREE.Box2: .size() has been renamed to .getSize()."),this.getSize(e)};ta.prototype.center=function(e){return console.warn("THREE.Box3: .center() has been renamed to .getCenter()."),this.getCenter(e)};ta.prototype.empty=function(){return console.warn("THREE.Box3: .empty() has been renamed to .isEmpty()."),this.isEmpty()};ta.prototype.isIntersectionBox=function(e){return console.warn("THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(e)};ta.prototype.isIntersectionSphere=function(e){return console.warn("THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(e)};ta.prototype.size=function(e){return console.warn("THREE.Box3: .size() has been renamed to .getSize()."),this.getSize(e)};Zf.prototype.empty=function(){return console.warn("THREE.Sphere: .empty() has been renamed to .isEmpty()."),this.isEmpty()};Nv.prototype.setFromMatrix=function(e){return console.warn("THREE.Frustum: .setFromMatrix() has been renamed to .setFromProjectionMatrix()."),this.setFromProjectionMatrix(e)};qU.prototype.center=function(e){return console.warn("THREE.Line3: .center() has been renamed to .getCenter()."),this.getCenter(e)};ki.prototype.flattenToArrayOffset=function(e,t){return console.warn("THREE.Matrix3: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(e,t)};ki.prototype.multiplyVector3=function(e){return console.warn("THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead."),e.applyMatrix3(this)};ki.prototype.multiplyVector3Array=function(){console.error("THREE.Matrix3: .multiplyVector3Array() has been removed.")};ki.prototype.applyToBufferAttribute=function(e){return console.warn("THREE.Matrix3: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix3( matrix ) instead."),e.applyMatrix3(this)};ki.prototype.applyToVector3Array=function(){console.error("THREE.Matrix3: .applyToVector3Array() has been removed.")};ki.prototype.getInverse=function(e){return console.warn("THREE.Matrix3: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(e).invert()};Me.prototype.extractPosition=function(e){return console.warn("THREE.Matrix4: .extractPosition() has been renamed to .copyPosition()."),this.copyPosition(e)};Me.prototype.flattenToArrayOffset=function(e,t){return console.warn("THREE.Matrix4: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(e,t)};Me.prototype.getPosition=function(){return console.warn("THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead."),new j().setFromMatrixColumn(this,3)};Me.prototype.setRotationFromQuaternion=function(e){return console.warn("THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion()."),this.makeRotationFromQuaternion(e)};Me.prototype.multiplyToArray=function(){console.warn("THREE.Matrix4: .multiplyToArray() has been removed.")};Me.prototype.multiplyVector3=function(e){return console.warn("THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) instead."),e.applyMatrix4(this)};Me.prototype.multiplyVector4=function(e){return console.warn("THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead."),e.applyMatrix4(this)};Me.prototype.multiplyVector3Array=function(){console.error("THREE.Matrix4: .multiplyVector3Array() has been removed.")};Me.prototype.rotateAxis=function(e){console.warn("THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead."),e.transformDirection(this)};Me.prototype.crossVector=function(e){return console.warn("THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead."),e.applyMatrix4(this)};Me.prototype.translate=function(){console.error("THREE.Matrix4: .translate() has been removed.")};Me.prototype.rotateX=function(){console.error("THREE.Matrix4: .rotateX() has been removed.")};Me.prototype.rotateY=function(){console.error("THREE.Matrix4: .rotateY() has been removed.")};Me.prototype.rotateZ=function(){console.error("THREE.Matrix4: .rotateZ() has been removed.")};Me.prototype.rotateByAxis=function(){console.error("THREE.Matrix4: .rotateByAxis() has been removed.")};Me.prototype.applyToBufferAttribute=function(e){return console.warn("THREE.Matrix4: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix4( matrix ) instead."),e.applyMatrix4(this)};Me.prototype.applyToVector3Array=function(){console.error("THREE.Matrix4: .applyToVector3Array() has been removed.")};Me.prototype.makeFrustum=function(e,t,r,n,i,o){return console.warn("THREE.Matrix4: .makeFrustum() has been removed. Use .makePerspective( left, right, top, bottom, near, far ) instead."),this.makePerspective(e,t,n,r,i,o)};Me.prototype.getInverse=function(e){return console.warn("THREE.Matrix4: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(e).invert()};$c.prototype.isIntersectionLine=function(e){return console.warn("THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine()."),this.intersectsLine(e)};vi.prototype.multiplyVector3=function(e){return console.warn("THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead."),e.applyQuaternion(this)};vi.prototype.inverse=function(){return console.warn("THREE.Quaternion: .inverse() has been renamed to invert()."),this.invert()};Jf.prototype.isIntersectionBox=function(e){return console.warn("THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(e)};Jf.prototype.isIntersectionPlane=function(e){return console.warn("THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane()."),this.intersectsPlane(e)};Jf.prototype.isIntersectionSphere=function(e){return console.warn("THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(e)};ai.prototype.area=function(){return console.warn("THREE.Triangle: .area() has been renamed to .getArea()."),this.getArea()};ai.prototype.barycoordFromPoint=function(e,t){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),this.getBarycoord(e,t)};ai.prototype.midpoint=function(e){return console.warn("THREE.Triangle: .midpoint() has been renamed to .getMidpoint()."),this.getMidpoint(e)};ai.prototypenormal=function(e){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),this.getNormal(e)};ai.prototype.plane=function(e){return console.warn("THREE.Triangle: .plane() has been renamed to .getPlane()."),this.getPlane(e)};ai.barycoordFromPoint=function(e,t,r,n,i){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),ai.getBarycoord(e,t,r,n,i)};ai.normal=function(e,t,r,n){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),ai.getNormal(e,t,r,n)};Kc.prototype.extractAllPoints=function(e){return console.warn("THREE.Shape: .extractAllPoints() has been removed. Use .extractPoints() instead."),this.extractPoints(e)};Kc.prototype.extrude=function(e){return console.warn("THREE.Shape: .extrude() has been removed. Use ExtrudeGeometry() instead."),new hh(this,e)};Kc.prototype.makeGeometry=function(e){return console.warn("THREE.Shape: .makeGeometry() has been removed. Use ShapeGeometry() instead."),new Y0(this,e)};Lt.prototype.fromAttribute=function(e,t,r){return console.warn("THREE.Vector2: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(e,t,r)};Lt.prototype.distanceToManhattan=function(e){return console.warn("THREE.Vector2: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(e)};Lt.prototype.lengthManhattan=function(){return console.warn("THREE.Vector2: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()};j.prototype.setEulerFromRotationMatrix=function(){console.error("THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.")};j.prototype.setEulerFromQuaternion=function(){console.error("THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.")};j.prototype.getPositionFromMatrix=function(e){return console.warn("THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition()."),this.setFromMatrixPosition(e)};j.prototype.getScaleFromMatrix=function(e){return console.warn("THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale()."),this.setFromMatrixScale(e)};j.prototype.getColumnFromMatrix=function(e,t){return console.warn("THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn()."),this.setFromMatrixColumn(t,e)};j.prototype.applyProjection=function(e){return console.warn("THREE.Vector3: .applyProjection() has been removed. Use .applyMatrix4( m ) instead."),this.applyMatrix4(e)};j.prototype.fromAttribute=function(e,t,r){return console.warn("THREE.Vector3: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(e,t,r)};j.prototype.distanceToManhattan=function(e){return console.warn("THREE.Vector3: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(e)};j.prototype.lengthManhattan=function(){return console.warn("THREE.Vector3: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()};en.prototype.fromAttribute=function(e,t,r){return console.warn("THREE.Vector4: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(e,t,r)};en.prototype.lengthManhattan=function(){return console.warn("THREE.Vector4: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()};or.prototype.getChildByName=function(e){return console.warn("THREE.Object3D: .getChildByName() has been renamed to .getObjectByName()."),this.getObjectByName(e)};or.prototype.renderDepth=function(){console.warn("THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.")};or.prototype.translate=function(e,t){return console.warn("THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead."),this.translateOnAxis(t,e)};or.prototype.getWorldRotation=function(){console.error("THREE.Object3D: .getWorldRotation() has been removed. Use THREE.Object3D.getWorldQuaternion( target ) instead.")};or.prototype.applyMatrix=function(e){return console.warn("THREE.Object3D: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(e)};Object.defineProperties(or.prototype,{eulerOrder:{get:function(){return console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order},set:function(e){console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order=e}},useQuaternion:{get:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")},set:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")}}});ei.prototype.setDrawMode=function(){console.error("THREE.Mesh: .setDrawMode() has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")};Object.defineProperties(ei.prototype,{drawMode:{get:function(){return console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode."),Cfe},set:function(){console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")}}});aM.prototype.initBones=function(){console.error("THREE.SkinnedMesh: initBones() has been removed.")};Ui.prototype.setLens=function(e,t){console.warn("THREE.PerspectiveCamera.setLens is deprecated. Use .setFocalLength and .filmGauge for a photographic setup."),t!==void 0&&(this.filmGauge=t),this.setFocalLength(e)};Object.defineProperties(Ol.prototype,{onlyShadow:{set:function(){console.warn("THREE.Light: .onlyShadow has been removed.")}},shadowCameraFov:{set:function(e){console.warn("THREE.Light: .shadowCameraFov is now .shadow.camera.fov."),this.shadow.camera.fov=e}},shadowCameraLeft:{set:function(e){console.warn("THREE.Light: .shadowCameraLeft is now .shadow.camera.left."),this.shadow.camera.left=e}},shadowCameraRight:{set:function(e){console.warn("THREE.Light: .shadowCameraRight is now .shadow.camera.right."),this.shadow.camera.right=e}},shadowCameraTop:{set:function(e){console.warn("THREE.Light: .shadowCameraTop is now .shadow.camera.top."),this.shadow.camera.top=e}},shadowCameraBottom:{set:function(e){console.warn("THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom."),this.shadow.camera.bottom=e}},shadowCameraNear:{set:function(e){console.warn("THREE.Light: .shadowCameraNear is now .shadow.camera.near."),this.shadow.camera.near=e}},shadowCameraFar:{set:function(e){console.warn("THREE.Light: .shadowCameraFar is now .shadow.camera.far."),this.shadow.camera.far=e}},shadowCameraVisible:{set:function(){console.warn("THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.")}},shadowBias:{set:function(e){console.warn("THREE.Light: .shadowBias is now .shadow.bias."),this.shadow.bias=e}},shadowDarkness:{set:function(){console.warn("THREE.Light: .shadowDarkness has been removed.")}},shadowMapWidth:{set:function(e){console.warn("THREE.Light: .shadowMapWidth is now .shadow.mapSize.width."),this.shadow.mapSize.width=e}},shadowMapHeight:{set:function(e){console.warn("THREE.Light: .shadowMapHeight is now .shadow.mapSize.height."),this.shadow.mapSize.height=e}}});Object.defineProperties(Je.prototype,{length:{get:function(){return console.warn("THREE.BufferAttribute: .length has been deprecated. Use .count instead."),this.array.length}},dynamic:{get:function(){return console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.usage===Y3},set:function(){console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.setUsage(Y3)}}});Je.prototype.setDynamic=function(e){return console.warn("THREE.BufferAttribute: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(e===!0?Y3:W3),this};Je.prototype.copyIndicesArray=function(){console.error("THREE.BufferAttribute: .copyIndicesArray() has been removed.")},Je.prototype.setArray=function(){console.error("THREE.BufferAttribute: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")};Pe.prototype.addIndex=function(e){console.warn("THREE.BufferGeometry: .addIndex() has been renamed to .setIndex()."),this.setIndex(e)};Pe.prototype.addAttribute=function(e,t){return console.warn("THREE.BufferGeometry: .addAttribute() has been renamed to .setAttribute()."),!(t&&t.isBufferAttribute)&&!(t&&t.isInterleavedBufferAttribute)?(console.warn("THREE.BufferGeometry: .addAttribute() now expects ( name, attribute )."),this.setAttribute(e,new Je(arguments[1],arguments[2]))):e==="index"?(console.warn("THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute."),this.setIndex(t),this):this.setAttribute(e,t)};Pe.prototype.addDrawCall=function(e,t,r){r!==void 0&&console.warn("THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset."),console.warn("THREE.BufferGeometry: .addDrawCall() is now .addGroup()."),this.addGroup(e,t)};Pe.prototype.clearDrawCalls=function(){console.warn("THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups()."),this.clearGroups()};Pe.prototype.computeOffsets=function(){console.warn("THREE.BufferGeometry: .computeOffsets() has been removed.")};Pe.prototype.removeAttribute=function(e){return console.warn("THREE.BufferGeometry: .removeAttribute() has been renamed to .deleteAttribute()."),this.deleteAttribute(e)};Pe.prototype.applyMatrix=function(e){return console.warn("THREE.BufferGeometry: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(e)};Object.defineProperties(Pe.prototype,{drawcalls:{get:function(){return console.error("THREE.BufferGeometry: .drawcalls has been renamed to .groups."),this.groups}},offsets:{get:function(){return console.warn("THREE.BufferGeometry: .offsets has been renamed to .groups."),this.groups}}});em.prototype.setDynamic=function(e){return console.warn("THREE.InterleavedBuffer: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(e===!0?Y3:W3),this};em.prototype.setArray=function(){console.error("THREE.InterleavedBuffer: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")};hh.prototype.getArrays=function(){console.error("THREE.ExtrudeGeometry: .getArrays() has been removed.")};hh.prototype.addShapeList=function(){console.error("THREE.ExtrudeGeometry: .addShapeList() has been removed.")};hh.prototype.addShape=function(){console.error("THREE.ExtrudeGeometry: .addShape() has been removed.")};q0.prototype.dispose=function(){console.error("THREE.Scene: .dispose() has been removed.")};gM.prototype.onUpdate=function(){return console.warn("THREE.Uniform: .onUpdate() has been removed. Use object.onBeforeRender() instead."),this};Object.defineProperties(qi.prototype,{wrapAround:{get:function(){console.warn("THREE.Material: .wrapAround has been removed.")},set:function(){console.warn("THREE.Material: .wrapAround has been removed.")}},overdraw:{get:function(){console.warn("THREE.Material: .overdraw has been removed.")},set:function(){console.warn("THREE.Material: .overdraw has been removed.")}},wrapRGB:{get:function(){return console.warn("THREE.Material: .wrapRGB has been removed."),new ne}},shading:{get:function(){console.error("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead.")},set:function(e){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=e===Pht}},stencilMask:{get:function(){return console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask},set:function(e){console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask=e}},vertexTangents:{get:function(){console.warn("THREE."+this.type+": .vertexTangents has been removed.")},set:function(){console.warn("THREE."+this.type+": .vertexTangents has been removed.")}}});Object.defineProperties(lh.prototype,{derivatives:{get:function(){return console.warn("THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives},set:function(e){console.warn("THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives=e}}});rn.prototype.clearTarget=function(e,t,r,n){console.warn("THREE.WebGLRenderer: .clearTarget() has been deprecated. Use .setRenderTarget() and .clear() instead."),this.setRenderTarget(e),this.clear(t,r,n)};rn.prototype.animate=function(e){console.warn("THREE.WebGLRenderer: .animate() is now .setAnimationLoop()."),this.setAnimationLoop(e)};rn.prototype.getCurrentRenderTarget=function(){return console.warn("THREE.WebGLRenderer: .getCurrentRenderTarget() is now .getRenderTarget()."),this.getRenderTarget()};rn.prototype.getMaxAnisotropy=function(){return console.warn("THREE.WebGLRenderer: .getMaxAnisotropy() is now .capabilities.getMaxAnisotropy()."),this.capabilities.getMaxAnisotropy()};rn.prototype.getPrecision=function(){return console.warn("THREE.WebGLRenderer: .getPrecision() is now .capabilities.precision."),this.capabilities.precision};rn.prototype.resetGLState=function(){return console.warn("THREE.WebGLRenderer: .resetGLState() is now .state.reset()."),this.state.reset()};rn.prototype.supportsFloatTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( 'OES_texture_float' )."),this.extensions.get("OES_texture_float")};rn.prototype.supportsHalfFloatTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( 'OES_texture_half_float' )."),this.extensions.get("OES_texture_half_float")};rn.prototype.supportsStandardDerivatives=function(){return console.warn("THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( 'OES_standard_derivatives' )."),this.extensions.get("OES_standard_derivatives")};rn.prototype.supportsCompressedTextureS3TC=function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( 'WEBGL_compressed_texture_s3tc' )."),this.extensions.get("WEBGL_compressed_texture_s3tc")};rn.prototype.supportsCompressedTexturePVRTC=function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( 'WEBGL_compressed_texture_pvrtc' )."),this.extensions.get("WEBGL_compressed_texture_pvrtc")};rn.prototype.supportsBlendMinMax=function(){return console.warn("THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( 'EXT_blend_minmax' )."),this.extensions.get("EXT_blend_minmax")};rn.prototype.supportsVertexTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsVertexTextures() is now .capabilities.vertexTextures."),this.capabilities.vertexTextures};rn.prototype.supportsInstancedArrays=function(){return console.warn("THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( 'ANGLE_instanced_arrays' )."),this.extensions.get("ANGLE_instanced_arrays")};rn.prototype.enableScissorTest=function(e){console.warn("THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest()."),this.setScissorTest(e)};rn.prototype.initMaterial=function(){console.warn("THREE.WebGLRenderer: .initMaterial() has been removed.")};rn.prototype.addPrePlugin=function(){console.warn("THREE.WebGLRenderer: .addPrePlugin() has been removed.")};rn.prototype.addPostPlugin=function(){console.warn("THREE.WebGLRenderer: .addPostPlugin() has been removed.")};rn.prototype.updateShadowMap=function(){console.warn("THREE.WebGLRenderer: .updateShadowMap() has been removed.")};rn.prototype.setFaceCulling=function(){console.warn("THREE.WebGLRenderer: .setFaceCulling() has been removed.")};rn.prototype.allocTextureUnit=function(){console.warn("THREE.WebGLRenderer: .allocTextureUnit() has been removed.")};rn.prototype.setTexture=function(){console.warn("THREE.WebGLRenderer: .setTexture() has been removed.")};rn.prototype.setTexture2D=function(){console.warn("THREE.WebGLRenderer: .setTexture2D() has been removed.")};rn.prototype.setTextureCube=function(){console.warn("THREE.WebGLRenderer: .setTextureCube() has been removed.")};rn.prototype.getActiveMipMapLevel=function(){return console.warn("THREE.WebGLRenderer: .getActiveMipMapLevel() is now .getActiveMipmapLevel()."),this.getActiveMipmapLevel()};Object.defineProperties(rn.prototype,{shadowMapEnabled:{get:function(){return this.shadowMap.enabled},set:function(e){console.warn("THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled."),this.shadowMap.enabled=e}},shadowMapType:{get:function(){return this.shadowMap.type},set:function(e){console.warn("THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type."),this.shadowMap.type=e}},shadowMapCullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")}},context:{get:function(){return console.warn("THREE.WebGLRenderer: .context has been removed. Use .getContext() instead."),this.getContext()}},vr:{get:function(){return console.warn("THREE.WebGLRenderer: .vr has been renamed to .xr"),this.xr}},gammaInput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead."),!1},set:function(){console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead.")}},gammaOutput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),!1},set:function(e){console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),this.outputEncoding=e===!0?Yn:Qd}},toneMappingWhitePoint:{get:function(){return console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed."),1},set:function(){console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed.")}},gammaFactor:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaFactor has been removed."),2},set:function(){console.warn("THREE.WebGLRenderer: .gammaFactor has been removed.")}}});Object.defineProperties(jfe.prototype,{cullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")}},renderReverseSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")}},renderSingleSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")}}});function Z0r(e,t,r){return console.warn("THREE.WebGLRenderTargetCube( width, height, options ) is now WebGLCubeRenderTarget( size, options )."),new Q3(e,r)}Object.defineProperties(us.prototype,{wrapS:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS},set:function(e){console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS=e}},wrapT:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT},set:function(e){console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT=e}},magFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter},set:function(e){console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter=e}},minFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter},set:function(e){console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter=e}},anisotropy:{get:function(){return console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy},set:function(e){console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy=e}},offset:{get:function(){return console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset},set:function(e){console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset=e}},repeat:{get:function(){return console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat},set:function(e){console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat=e}},format:{get:function(){return console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format},set:function(e){console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format=e}},type:{get:function(){return console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type},set:function(e){console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type=e}},generateMipmaps:{get:function(){return console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps},set:function(e){console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps=e}}});N6.prototype.load=function(e){console.warn("THREE.Audio: .load has been deprecated. Use THREE.AudioLoader instead.");let t=this;return new NU().load(e,function(n){t.setBuffer(n)}),this};zU.prototype.getData=function(){return console.warn("THREE.AudioAnalyser: .getData() is now .getFrequencyData()."),this.getFrequencyData()};J3.prototype.updateCubeMap=function(e,t){return console.warn("THREE.CubeCamera: .updateCubeMap() is now .update()."),this.update(e,t)};J3.prototype.clear=function(e,t,r,n){return console.warn("THREE.CubeCamera: .clear() is now .renderTarget.clear()."),this.renderTarget.clear(e,t,r,n)};Kf.crossOrigin=void 0;Kf.loadTexture=function(e,t,r,n){console.warn("THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.");let i=new CU;i.setCrossOrigin(this.crossOrigin);let o=i.load(e,r,void 0,n);return t&&(o.mapping=t),o};Kf.loadTextureCube=function(e,t,r,n){console.warn("THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.");let i=new EU;i.setCrossOrigin(this.crossOrigin);let o=i.load(e,r,void 0,n);return t&&(o.mapping=t),o};Kf.loadCompressedTexture=function(){console.error("THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.")};Kf.loadCompressedTextureCube=function(){console.error("THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.")};function J0r(){console.error("THREE.CanvasRenderer has been removed")}function Q0r(){console.error("THREE.JSONLoader has been removed.")}var t_r={createMultiMaterialObject:function(){console.error("THREE.SceneUtils has been moved to /examples/jsm/utils/SceneUtils.js")},detach:function(){console.error("THREE.SceneUtils has been moved to /examples/jsm/utils/SceneUtils.js")},attach:function(){console.error("THREE.SceneUtils has been moved to /examples/jsm/utils/SceneUtils.js")}};function e_r(){console.error("THREE.LensFlare has been moved to /examples/jsm/objects/Lensflare.js")}function r_r(){return console.error("THREE.ParametricGeometry has been moved to /examples/jsm/geometries/ParametricGeometry.js"),new Pe}function n_r(){return console.error("THREE.TextGeometry has been moved to /examples/jsm/geometries/TextGeometry.js"),new Pe}function i_r(){console.error("THREE.FontLoader has been moved to /examples/jsm/loaders/FontLoader.js")}function o_r(){console.error("THREE.Font has been moved to /examples/jsm/loaders/FontLoader.js")}function a_r(){console.error("THREE.ImmediateRenderObject has been removed.")}typeof __THREE_DEVTOOLS__!="undefined"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("register",{detail:{revision:YU}}));typeof window!="undefined"&&(window.__THREE__?console.warn("WARNING: Multiple instances of Three.js being imported."):window.__THREE__=YU);var rpe={type:"change"},Vht={type:"start"},npe={type:"end"},ZU=class extends Us{constructor(t,r){super(),r===void 0&&console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.'),r===document&&console.error('THREE.OrbitControls: "document" should not be used as the target "domElement". Please use "renderer.domElement" instead.'),this.object=t,this.domElement=r,this.domElement.style.touchAction="none",this.enabled=!0,this.target=new j,this.minDistance=0,this.maxDistance=1/0,this.minZoom=0,this.maxZoom=1/0,this.minPolarAngle=0,this.maxPolarAngle=Math.PI,this.minAzimuthAngle=-1/0,this.maxAzimuthAngle=1/0,this.enableDamping=!1,this.dampingFactor=.05,this.enableZoom=!0,this.zoomSpeed=1,this.enableRotate=!0,this.rotateSpeed=1,this.enablePan=!0,this.panSpeed=1,this.screenSpacePanning=!0,this.keyPanSpeed=7,this.autoRotate=!1,this.autoRotateSpeed=2,this.keys={LEFT:"ArrowLeft",UP:"ArrowUp",RIGHT:"ArrowRight",BOTTOM:"ArrowDown"},this.mouseButtons={LEFT:K0.ROTATE,MIDDLE:K0.DOLLY,RIGHT:K0.PAN},this.touches={ONE:Z0.ROTATE,TWO:Z0.DOLLY_PAN},this.target0=this.target.clone(),this.position0=this.object.position.clone(),this.zoom0=this.object.zoom,this._domElementKeyEvents=null,this.getPolarAngle=function(){return s.phi},this.getAzimuthalAngle=function(){return s.theta},this.getDistance=function(){return this.object.position.distanceTo(this.target)},this.listenToKeyEvents=function(nt){nt.addEventListener("keydown",fr),this._domElementKeyEvents=nt},this.saveState=function(){n.target0.copy(n.target),n.position0.copy(n.object.position),n.zoom0=n.object.zoom},this.reset=function(){n.target.copy(n.target0),n.object.position.copy(n.position0),n.object.zoom=n.zoom0,n.object.updateProjectionMatrix(),n.dispatchEvent(rpe),n.update(),o=i.NONE},this.update=function(){let nt=new j,Ct=new vi().setFromUnitVectors(t.up,new j(0,1,0)),Wt=Ct.clone().invert(),fe=new j,at=new vi,se=2*Math.PI;return function(){let Ce=n.object.position;nt.copy(Ce).sub(n.target),nt.applyQuaternion(Ct),s.setFromVector3(nt),n.autoRotate&&o===i.NONE&&D(k()),n.enableDamping?(s.theta+=l.theta*n.dampingFactor,s.phi+=l.phi*n.dampingFactor):(s.theta+=l.theta,s.phi+=l.phi);let Pt=n.minAzimuthAngle,Nt=n.maxAzimuthAngle;return isFinite(Pt)&&isFinite(Nt)&&(Pt<-Math.PI?Pt+=se:Pt>Math.PI&&(Pt-=se),Nt<-Math.PI?Nt+=se:Nt>Math.PI&&(Nt-=se),Pt<=Nt?s.theta=Math.max(Pt,Math.min(Nt,s.theta)):s.theta=s.theta>(Pt+Nt)/2?Math.max(Pt,s.theta):Math.min(Nt,s.theta)),s.phi=Math.max(n.minPolarAngle,Math.min(n.maxPolarAngle,s.phi)),s.makeSafe(),s.radius*=c,s.radius=Math.max(n.minDistance,Math.min(n.maxDistance,s.radius)),n.enableDamping===!0?n.target.addScaledVector(u,n.dampingFactor):n.target.add(u),nt.setFromSpherical(s),nt.applyQuaternion(Wt),Ce.copy(n.target).add(nt),n.object.lookAt(n.target),n.enableDamping===!0?(l.theta*=1-n.dampingFactor,l.phi*=1-n.dampingFactor,u.multiplyScalar(1-n.dampingFactor)):(l.set(0,0,0),u.set(0,0,0)),c=1,h||fe.distanceToSquared(n.object.position)>a||8*(1-at.dot(n.object.quaternion))>a?(n.dispatchEvent(rpe),fe.copy(n.object.position),at.copy(n.object.quaternion),h=!1,!0):!1}}(),this.dispose=function(){n.domElement.removeEventListener("contextmenu",It),n.domElement.removeEventListener("pointerdown",ht),n.domElement.removeEventListener("pointercancel",ie),n.domElement.removeEventListener("wheel",ar),n.domElement.removeEventListener("pointermove",wt),n.domElement.removeEventListener("pointerup",kt),n._domElementKeyEvents!==null&&n._domElementKeyEvents.removeEventListener("keydown",fr)};let n=this,i={NONE:-1,ROTATE:0,DOLLY:1,PAN:2,TOUCH_ROTATE:3,TOUCH_PAN:4,TOUCH_DOLLY_PAN:5,TOUCH_DOLLY_ROTATE:6},o=i.NONE,a=1e-6,s=new _M,l=new _M,c=1,u=new j,h=!1,f=new Lt,p=new Lt,d=new Lt,g=new Lt,_=new Lt,y=new Lt,x=new Lt,b=new Lt,S=new Lt,C=[],P={};function k(){return 2*Math.PI/60/60*n.autoRotateSpeed}function O(){return Math.pow(.95,n.zoomSpeed)}function D(nt){l.theta-=nt}function B(nt){l.phi-=nt}let I=function(){let nt=new j;return function(Wt,fe){nt.setFromMatrixColumn(fe,0),nt.multiplyScalar(-Wt),u.add(nt)}}(),L=function(){let nt=new j;return function(Wt,fe){n.screenSpacePanning===!0?nt.setFromMatrixColumn(fe,1):(nt.setFromMatrixColumn(fe,0),nt.crossVectors(n.object.up,nt)),nt.multiplyScalar(Wt),u.add(nt)}}(),R=function(){let nt=new j;return function(Wt,fe){let at=n.domElement;if(n.object.isPerspectiveCamera){let se=n.object.position;nt.copy(se).sub(n.target);let Qt=nt.length();Qt*=Math.tan(n.object.fov/2*Math.PI/180),I(2*Wt*Qt/at.clientHeight,n.object.matrix),L(2*fe*Qt/at.clientHeight,n.object.matrix)}else n.object.isOrthographicCamera?(I(Wt*(n.object.right-n.object.left)/n.object.zoom/at.clientWidth,n.object.matrix),L(fe*(n.object.top-n.object.bottom)/n.object.zoom/at.clientHeight,n.object.matrix)):(console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled."),n.enablePan=!1)}}();function F(nt){n.object.isPerspectiveCamera?c/=nt:n.object.isOrthographicCamera?(n.object.zoom=Math.max(n.minZoom,Math.min(n.maxZoom,n.object.zoom*nt)),n.object.updateProjectionMatrix(),h=!0):(console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."),n.enableZoom=!1)}function z(nt){n.object.isPerspectiveCamera?c*=nt:n.object.isOrthographicCamera?(n.object.zoom=Math.max(n.minZoom,Math.min(n.maxZoom,n.object.zoom/nt)),n.object.updateProjectionMatrix(),h=!0):(console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."),n.enableZoom=!1)}function U(nt){f.set(nt.clientX,nt.clientY)}function W(nt){x.set(nt.clientX,nt.clientY)}function Z(nt){g.set(nt.clientX,nt.clientY)}function rt(nt){p.set(nt.clientX,nt.clientY),d.subVectors(p,f).multiplyScalar(n.rotateSpeed);let Ct=n.domElement;D(2*Math.PI*d.x/Ct.clientHeight),B(2*Math.PI*d.y/Ct.clientHeight),f.copy(p),n.update()}function ot(nt){b.set(nt.clientX,nt.clientY),S.subVectors(b,x),S.y>0?F(O()):S.y<0&&z(O()),x.copy(b),n.update()}function st(nt){_.set(nt.clientX,nt.clientY),y.subVectors(_,g).multiplyScalar(n.panSpeed),R(y.x,y.y),g.copy(_),n.update()}function St(nt){nt.deltaY<0?z(O()):nt.deltaY>0&&F(O()),n.update()}function bt(nt){let Ct=!1;switch(nt.code){case n.keys.UP:R(0,n.keyPanSpeed),Ct=!0;break;case n.keys.BOTTOM:R(0,-n.keyPanSpeed),Ct=!0;break;case n.keys.LEFT:R(n.keyPanSpeed,0),Ct=!0;break;case n.keys.RIGHT:R(-n.keyPanSpeed,0),Ct=!0;break}Ct&&(nt.preventDefault(),n.update())}function Mt(){if(C.length===1)f.set(C[0].pageX,C[0].pageY);else{let nt=.5*(C[0].pageX+C[1].pageX),Ct=.5*(C[0].pageY+C[1].pageY);f.set(nt,Ct)}}function lt(){if(C.length===1)g.set(C[0].pageX,C[0].pageY);else{let nt=.5*(C[0].pageX+C[1].pageX),Ct=.5*(C[0].pageY+C[1].pageY);g.set(nt,Ct)}}function Kt(){let nt=C[0].pageX-C[1].pageX,Ct=C[0].pageY-C[1].pageY,Wt=Math.sqrt(nt*nt+Ct*Ct);x.set(0,Wt)}function _t(){n.enableZoom&&Kt(),n.enablePan&&lt()}function ct(){n.enableZoom&&Kt(),n.enableRotate&&Mt()}function X(nt){if(C.length==1)p.set(nt.pageX,nt.pageY);else{let Wt=be(nt),fe=.5*(nt.pageX+Wt.x),at=.5*(nt.pageY+Wt.y);p.set(fe,at)}d.subVectors(p,f).multiplyScalar(n.rotateSpeed);let Ct=n.domElement;D(2*Math.PI*d.x/Ct.clientHeight),B(2*Math.PI*d.y/Ct.clientHeight),f.copy(p)}function et(nt){if(C.length===1)_.set(nt.pageX,nt.pageY);else{let Ct=be(nt),Wt=.5*(nt.pageX+Ct.x),fe=.5*(nt.pageY+Ct.y);_.set(Wt,fe)}y.subVectors(_,g).multiplyScalar(n.panSpeed),R(y.x,y.y),g.copy(_)}function dt(nt){let Ct=be(nt),Wt=nt.pageX-Ct.x,fe=nt.pageY-Ct.y,at=Math.sqrt(Wt*Wt+fe*fe);b.set(0,at),S.set(0,Math.pow(b.y/x.y,n.zoomSpeed)),F(S.y),x.copy(b)}function q(nt){n.enableZoom&&dt(nt),n.enablePan&&et(nt)}function pt(nt){n.enableZoom&&dt(nt),n.enableRotate&&X(nt)}function ht(nt){n.enabled!==!1&&(C.length===0&&(n.domElement.setPointerCapture(nt.pointerId),n.domElement.addEventListener("pointermove",wt),n.domElement.addEventListener("pointerup",kt)),$t(nt),nt.pointerType==="touch"?tt(nt):ee(nt))}function wt(nt){n.enabled!==!1&&(nt.pointerType==="touch"?$(nt):Le(nt))}function kt(nt){he(nt),C.length===0&&(n.domElement.releasePointerCapture(nt.pointerId),n.domElement.removeEventListener("pointermove",wt),n.domElement.removeEventListener("pointerup",kt)),n.dispatchEvent(npe),o=i.NONE}function ie(nt){he(nt)}function ee(nt){let Ct;switch(nt.button){case 0:Ct=n.mouseButtons.LEFT;break;case 1:Ct=n.mouseButtons.MIDDLE;break;case 2:Ct=n.mouseButtons.RIGHT;break;default:Ct=-1}switch(Ct){case K0.DOLLY:if(n.enableZoom===!1)return;W(nt),o=i.DOLLY;break;case K0.ROTATE:if(nt.ctrlKey||nt.metaKey||nt.shiftKey){if(n.enablePan===!1)return;Z(nt),o=i.PAN}else{if(n.enableRotate===!1)return;U(nt),o=i.ROTATE}break;case K0.PAN:if(nt.ctrlKey||nt.metaKey||nt.shiftKey){if(n.enableRotate===!1)return;U(nt),o=i.ROTATE}else{if(n.enablePan===!1)return;Z(nt),o=i.PAN}break;default:o=i.NONE}o!==i.NONE&&n.dispatchEvent(Vht)}function Le(nt){if(n.enabled!==!1)switch(o){case i.ROTATE:if(n.enableRotate===!1)return;rt(nt);break;case i.DOLLY:if(n.enableZoom===!1)return;ot(nt);break;case i.PAN:if(n.enablePan===!1)return;st(nt);break}}function ar(nt){n.enabled===!1||n.enableZoom===!1||o!==i.NONE||(nt.preventDefault(),n.dispatchEvent(Vht),St(nt),n.dispatchEvent(npe))}function fr(nt){n.enabled===!1||n.enablePan===!1||bt(nt)}function tt(nt){switch(Tt(nt),C.length){case 1:switch(n.touches.ONE){case Z0.ROTATE:if(n.enableRotate===!1)return;Mt(),o=i.TOUCH_ROTATE;break;case Z0.PAN:if(n.enablePan===!1)return;lt(),o=i.TOUCH_PAN;break;default:o=i.NONE}break;case 2:switch(n.touches.TWO){case Z0.DOLLY_PAN:if(n.enableZoom===!1&&n.enablePan===!1)return;_t(),o=i.TOUCH_DOLLY_PAN;break;case Z0.DOLLY_ROTATE:if(n.enableZoom===!1&&n.enableRotate===!1)return;ct(),o=i.TOUCH_DOLLY_ROTATE;break;default:o=i.NONE}break;default:o=i.NONE}o!==i.NONE&&n.dispatchEvent(Vht)}function $(nt){switch(Tt(nt),o){case i.TOUCH_ROTATE:if(n.enableRotate===!1)return;X(nt),n.update();break;case i.TOUCH_PAN:if(n.enablePan===!1)return;et(nt),n.update();break;case i.TOUCH_DOLLY_PAN:if(n.enableZoom===!1&&n.enablePan===!1)return;q(nt),n.update();break;case i.TOUCH_DOLLY_ROTATE:if(n.enableZoom===!1&&n.enableRotate===!1)return;pt(nt),n.update();break;default:o=i.NONE}}function It(nt){n.enabled!==!1&&nt.preventDefault()}function $t(nt){C.push(nt)}function he(nt){delete P[nt.pointerId];for(let Ct=0;Ct<C.length;Ct++)if(C[Ct].pointerId==nt.pointerId){C.splice(Ct,1);return}}function Tt(nt){let Ct=P[nt.pointerId];Ct===void 0&&(Ct=new Lt,P[nt.pointerId]=Ct),Ct.set(nt.pageX,nt.pageY)}function be(nt){let Ct=nt.pointerId===C[0].pointerId?C[1]:C[0];return P[Ct.pointerId]}n.domElement.addEventListener("contextmenu",It),n.domElement.addEventListener("pointerdown",ht),n.domElement.addEventListener("pointercancel",ie),n.domElement.addEventListener("wheel",ar,{passive:!1}),this.update()}};var z6=class extends Us{constructor(t){super(),this._lastMesh=null,this._clock=new mM,this._canvasSize=null,this._layersConfig=null,this._runColor=t}_isObject(t){var r=typeof t;return r=="object"&&t!=null&&!Array.isArray(t)}_applyDefaults(t,r){let n={},i=[t,r];for(let o=0;o<i.length;o++){let a=i[o];for(let s in a){let l=s in n;this._isObject(a[s])?n[s]=this._applyDefaults(n[s]||{},a[s]):l||(n[s]=a[s])}}return n}_createLayers(){if(!(!this._layersConfig||!this._scene||!this._lastMesh)){if(this._layersConfig.showBoundingBox){var t=new yM(this._lastMesh,new ne("rgb(0, 0, 255)"));this._scene.add(t)}if(this._layersConfig.showAxes){var r=new vM(5);this._scene.add(r)}}}setLayersConfig(t){this._layersConfig=this._applyDefaults(t,this._layersConfig||{})}_createWorld(t,r){var a,s,l,c;if(this.isReady())return;this._scene=new q0;var n=new wM[t.camera.cls](t.camera.fov,((a=this._canvasSize)==null?void 0:a.width)/((s=this._canvasSize)==null?void 0:s.height),t.camera.near,t.camera.far);this._camera=n,this.initCameraPosition=void 0,t.camera.position&&(this.initCameraPosition=new j().fromArray(t.camera.position)),this.initCameraLookAt=void 0,t.camera.lookAt&&(this.initCameraLookAt=new j().fromArray(t.camera.lookAt));var i=new ZU(n,r);let o=i;o.lookSpeed=.4,o.movementSpeed=20,o.noFly=!0,o.lookVertical=!0,o.constrainVertical=!0,o.verticalMin=1,o.verticalMax=2,o.addEventListener("change",this._onCameraPositionChange.bind(this)),this._cameraControls=i,this._renderer=new rn({antialias:!0}),this._renderer.setPixelRatio(window.devicePixelRatio),this._renderer.setSize((l=this._canvasSize)==null?void 0:l.width,(c=this._canvasSize)==null?void 0:c.height),this._renderer.setClearColor(16777215,1)}_clearScene(){var t;if(this._scene)for(;this._scene.children.length>0;)this._scene.remove((t=this._scene)==null?void 0:t.children[0])}getRenderer(){return this._renderer}getCameraControls(){return this._cameraControls}isReady(){return!!this._camera&&!!this._cameraControls}getCameraPosition(){var t,r,n;return{far:(t=this._camera)==null?void 0:t.far,position:(r=this._camera)==null?void 0:r.position.clone(),target:(n=this._cameraControls)==null?void 0:n.target.clone()}}setCanvasSize(t){this._canvasSize=t}draw(){var r,n,i,o;this._animationFrameIndex&&cancelAnimationFrame(this._animationFrameIndex),this._camera&&(this._camera.aspect=((r=this._canvasSize)==null?void 0:r.width)/((n=this._canvasSize)==null?void 0:n.height),this._camera.updateProjectionMatrix()),this._renderer.setSize((i=this._canvasSize)==null?void 0:i.width,(o=this._canvasSize)==null?void 0:o.height);let t=function(){var a=this._clock.getDelta();this._cameraControls.update(a),this._animationFrameIndex=requestAnimationFrame(t),this._renderer.render(this._scene,this._camera)}.bind(this);t()}updateScene(t,r){let n={};"config"in t&&t.config&&(n=JSON.parse(t.config)),this.dispatchEvent({type:"beforeUpdateScene"});let i={camera:{cls:"PerspectiveCamera",fov:75,near:.1,far:1e3},lights:[{cls:"AmbientLight",color:"#ffffff",intensity:.75},{cls:"DirectionalLight",color:"#ffffff",intensity:.75,position:[0,-1,2]}]};n=this._applyDefaults(n,i),this._createWorld(n,r),this._clearScene(),this._createLights(this._scene,n),this._createGeometry(t,n),this._createLayers(),this.draw()}resetView(t){var n,i;if(!this.isReady())return;(n=this._cameraControls)==null||n.reset();let r;!t&&this._lastMesh&&(r=this._lastMesh),r&&(this._fitObjectToViewport(r),this._lastMesh=r),(i=this._cameraControls)==null||i.update()}_createGeometry(t,r){let n=t.mesh;n.vertices&&n.faces&&n.faces.length?this._createMesh(n,r):this._createPointCloud(n,r)}_createPointCloud(t,r){var h;let n=t.vertices,i=t.colors,o={material:{cls:"PointsMaterial",size:.005}};i&&i.length==n.length?o.material.vertexColors=!0:o.material.color=this._runColor;let a=this._applyDefaults(r,o),s=new Pe,l=new Float32Array(n.flat());if(s.setAttribute("position",new Je(l,3)),i&&i.length==n.length){let f=new Float32Array(i.flat());for(let p=0;p<f.length;p++)f[p]=f[p]/255;s.setAttribute("color",new Je(f,3))}var c=new wM[a.material.cls](a.material),u=new im(s,c);(h=this._scene)==null||h.add(u),this._lastMesh=u}setCameraViewpoint(t,r,n){this._silent=!0,this._camera&&(this._camera.far=r,this._camera.position.set(t.x,t.y,t.z),this._camera.lookAt(n.clone()),this._camera.updateProjectionMatrix()),this._cameraControls&&(this._cameraControls.target=n.clone(),this._cameraControls.update()),this._silent=!1}_onCameraPositionChange(t){this._silent||this.dispatchEvent({type:"cameraPositionChange",event:t})}_fitObjectToViewport(t){var p,d,g;let n=new ta,i=new j,o=new j;n.setFromObject(t),n.getCenter(i),n.getSize(o);let a=Math.max(o.x,o.y,o.z),s=((p=this._camera)==null?void 0:p.fov)*(Math.PI/180),l=Math.abs(a/(2*Math.tan(s/2)))*1.25,c=n.min.z,u=c<0?-c+l:l-c,h=(d=this.initCameraPosition)!=null?d:new j(i.x,i.y,l),f=(g=this.initCameraLookAt)!=null?g:i;this.setCameraViewpoint(h,u*3,f)}_createMesh(t,r){var f;let n=t.vertices,i=t.faces,o=t.colors,a=this._applyDefaults(r,{material:{cls:"MeshStandardMaterial",color:"#a0a0a0",roughness:1,metalness:0}}),s=new Pe,l=new Float32Array(n.flat());s.setAttribute("position",new Je(l,3));let c=new Uint16Array(i.flat());if(o&&o.length){let p=o.flat();for(let d=0;d<p.length;d++)p[d]=p[d]/255;s.setAttribute("color",new Je(new Float32Array(p),3)),a.material=a.material||{},a.material.vertexColors=!0}s.center(),s.computeBoundingSphere(),s.setIndex(new Je(c,1)),s.computeVertexNormals();let u=new wM[a.material.cls](a.material),h=new ei(s,u);h.castShadow=!0,h.receiveShadow=!0,(f=this._scene)==null||f.add(h),this._lastMesh=h}_createLights(t,r){for(let n=0;n<r.lights.length;n++){let i=r.lights[n],o=new wM[i.cls](i.color,i.intensity);i.position&&o.position.set(i.position[0],i.position[1],i.position[2]),t.add(o)}}};var kn=class extends Gt(mt){constructor(){super(...arguments),this.selectedView="all",this.active=!1,this._colorScaleFunction=fn,this._steps=[],this._meshViewerAttached=!1,this._cameraPositionInitialized=!1,this._isMeshLoading=!1}get _runColor(){var t=this.run;return this._colorScaleFunction(t)}connectedCallback(){super.connectedCallback(),this._dataProvider=new PP(this.requestManager);let t=new z6(this._runColor);t.addEventListener("beforeUpdateScene",this._updateCanvasSize.bind(this)),t.addEventListener("cameraPositionChange",this._onCameraPositionChange.bind(this)),this._meshViewer=t}reload(){!this.active||!this._dataProvider||(this._isMeshLoading=!0,this._dataProvider.reload(this.run,this.tag,this.sample).then(t=>{!t||(this._steps=t,this._stepIndex=t.length-1)}).catch(t=>{if(!t||!t.code||t.code!=dv.CANCELLED)throw t=t||"Response processing failed.",new Error(t)}))}_updateScene(){var r;let t=this._currentStep;!t||!t.mesh||(this._meshViewer.updateScene(t,this),this._cameraPositionInitialized||(this._meshViewer.resetView(),this._cameraPositionInitialized=!0),this._meshViewerAttached||((r=this.shadowRoot)==null||r.appendChild(this._meshViewer.getRenderer().domElement),this._meshViewerAttached=!0))}_debouncedFetchMesh(){this.debounce("fetchMesh",()=>this._maybeFetchMesh(),100)}_maybeFetchMesh(){return Ri(this,null,function*(){let t=this._currentStep;if(!(!t||t.mesh||t.meshFetching)){t.meshFetching=!0,this._isMeshLoading=!0;try{let r=yield this._dataProvider.fetchData(t,this.run,this.tag,this.sample);t.mesh=r[0],this.notifyPath("_currentStep.mesh")}catch(r){if(!r||!r.code||r.code!=dv.CANCELLED)throw r=r||"Response processing failed.",new Error(r)}finally{this._isMeshLoading=!1,t.meshFetching=!1}}})}_onCameraPositionChange(){if(!this._meshViewer.isReady())return;let t=new CustomEvent("camera-position-change",{detail:this._meshViewer.getCameraPosition()});this.dispatchEvent(t)}setCameraViewpoint(t,r,n){this._meshViewer.setCameraViewpoint(t,r,n)}_updateCanvasSize(){let t=this.offsetWidth,r=t,n=this.$$(".tf-mesh-loader-header").offsetHeight,i={width:t,height:r-n};this._meshViewer.setCanvasSize(i)}redraw(){this._updateCanvasSize(),this.isConnected&&this._meshViewer.draw()}_hasAtLeastOneStep(t){return!!t&&t.length>0}_hasMultipleSteps(t){return!!t&&t.length>1}get _currentStep(){var t=this._steps,r=this._stepIndex;return t[r]||null}get _stepValue(){let t=this._currentStep;return t?t.step:0}get _currentWallTime(){let t=this._currentStep;return t?s2(t.wall_time):""}_getMaxStepIndex(t){return t.length-1}_getSampleText(t){return String(t+1)}_hasMultipleSamples(t){return t>1}_updateView(){var t=this.selectedView;this._meshViewer&&t=="all"&&this._meshViewer.resetView()}toLocaleString_(t){return t.toLocaleString()}};kn.template=Q`
    <tf-card-heading color="[[_runColor]]" class="tf-mesh-loader-header">
      <template is="dom-if" if="[[_hasMultipleSamples(ofSamples)]]">
        <div>sample: [[_getSampleText(sample)]] of [[ofSamples]]</div>
      </template>
      <template is="dom-if" if="[[_hasAtLeastOneStep(_steps)]]">
        <div class="heading-row">
          <div class="heading-label">
            step
            <span style="font-weight: bold"
              >[[toLocaleString_(_stepValue)]]</span
            >
          </div>
          <div class="heading-label heading-right">
            <template is="dom-if" if="[[_currentWallTime]]">
              [[_currentWallTime]]
            </template>
          </div>
          <div class="label right">
            <paper-spinner-lite active hidden$="[[!_isMeshLoading]]">
            </paper-spinner-lite>
          </div>
        </div>
      </template>
      <template is="dom-if" if="[[_hasMultipleSteps(_steps)]]">
        <div>
          <paper-slider
            id="steps"
            immediate-value="{{_stepIndex}}"
            max="[[_getMaxStepIndex(_steps)]]"
            max-markers="[[_getMaxStepIndex(_steps)]]"
            snaps
            step="1"
            value="{{_stepIndex}}"
          ></paper-slider>
        </div>
      </template>
    </tf-card-heading>
    <style>
      paper-slider {
        width: 100%;
        margin-left: 1px;
        margin-right: 1px;
      }
      .tf-mesh-loader-header {
        display: block;
        height: 105px;
      }
      [hidden] {
        display: none;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],kn.prototype,"run",void 0);E([A({type:String}),w("design:type",String)],kn.prototype,"tag",void 0);E([A({type:Number}),w("design:type",Number)],kn.prototype,"sample",void 0);E([A({type:Number}),w("design:type",Number)],kn.prototype,"ofSamples",void 0);E([A({type:String}),w("design:type",String)],kn.prototype,"selectedView",void 0);E([A({type:Boolean}),w("design:type",Boolean)],kn.prototype,"active",void 0);E([A({type:Object}),w("design:type",Ae)],kn.prototype,"requestManager",void 0);E([A({type:Object}),w("design:type",z6)],kn.prototype,"_meshViewer",void 0);E([A({type:Object}),w("design:type",PP)],kn.prototype,"_dataProvider",void 0);E([A({type:Object}),w("design:type",Object)],kn.prototype,"_colorScaleFunction",void 0);E([A({type:Array,notify:!0}),w("design:type",Array)],kn.prototype,"_steps",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],kn.prototype,"_stepIndex",void 0);E([A({type:Boolean}),w("design:type",Boolean)],kn.prototype,"_meshViewerAttached",void 0);E([A({type:Boolean}),w("design:type",Boolean)],kn.prototype,"_cameraPositionInitialized",void 0);E([A({type:Boolean}),w("design:type",Boolean)],kn.prototype,"_isMeshLoading",void 0);E([Rt("run"),w("design:type",String),w("design:paramtypes",[])],kn.prototype,"_runColor",null);E([Bt("run","tag","active","_dataProvider","_meshViewer"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],kn.prototype,"reload",null);E([Bt("_currentStep.*","_meshViewer"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],kn.prototype,"_updateScene",null);E([Bt("_currentStep"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],kn.prototype,"_debouncedFetchMesh",null);E([Rt("_steps","_stepIndex"),w("design:type",Object),w("design:paramtypes",[])],kn.prototype,"_currentStep",null);E([Rt("_currentStep"),w("design:type",Number),w("design:paramtypes",[])],kn.prototype,"_stepValue",null);E([Rt("_currentStep"),w("design:type",String),w("design:paramtypes",[])],kn.prototype,"_currentWallTime",null);E([Bt("selectedView"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],kn.prototype,"_updateView",null);kn=E([yt("tf-mesh-loader")],kn);var ph=class extends mt{constructor(){super(),this.reloadOnReady=!0,this._tagFilter=".*",this._selectedView="all",this._requestManager=new Ae,window.addEventListener("resize",()=>{this._handleWindowResize()},!1),this.reloadOnReady&&this.reload()}_getAllChildren(){var t;return Array.from((t=this.shadowRoot)==null?void 0:t.querySelectorAll("tf-mesh-loader"))}_onCameraPositionChanged(t){this._selectedView=="share"&&this._getAllChildren().forEach(r=>{t.target!=r&&r.setCameraViewpoint(t.detail.position,t.detail.far,t.detail.target)})}_shouldOpen(t){return t<=2}reload(){this._fetchTags().then(this._reloadMeshes.bind(this))}_handleWindowResize(){this._getAllChildren().forEach(t=>{t.redraw()})}_fetchTags(){let t=ve().pluginRoute("mesh","/tags");return this._requestManager.request(t).then(r=>{if(sx.isEqual(r,this._runToTagInfo))return;let n=sx.mapValues(r,o=>Object.keys(o)),i=$i(n);this._dataNotFound=i.length===0,this._runToTagInfo=r})}_reloadMeshes(){this._getAllChildren().forEach(t=>{t.reload()})}get _categories(){var t=this._runToTagInfo,r=this._selectedRuns,n=this._tagFilter;let i=sx.mapValues(t,l=>Object.keys(l)),o=Ql(i,r,n);function a(l){let c=t[l.run][l.tag].samples;return sx.range(c).map(u=>Object.assign({},l,{sample:u,ofSamples:c}))}return o.map(l=>Object.assign({},l,{items:[].concat.apply([],l.items.map(a))}))}};ph.template=Q`
    <tf-dashboard-layout>
      <div slot="sidebar" class="all-controls">
        <div class="settings">
          <div class="sidebar-section view-control">
            <h3 class="title">Point of view</h3>
            <div>
              <paper-radio-group
                id="view-radio-group"
                selected="{{_selectedView}}"
              >
                <paper-radio-button id="all-radio-button" name="all">
                  Display all points
                </paper-radio-button>
                <paper-tooltip
                  animation-delay="0"
                  for="all-radio-button"
                  position="right"
                  offset="0"
                >
                  Zoom and center camera to display all points at once. Note,
                  that some points could be too far (i.e. too small) to be
                  visible.
                </paper-tooltip>
                <paper-radio-button id="user-radio-button" name="user">
                  Current view
                </paper-radio-button>
                <paper-tooltip
                  animation-delay="0"
                  for="user-radio-button"
                  position="right"
                  offset="0"
                >
                  Keep current camera position and zoom level.
                </paper-tooltip>
                <paper-radio-button id="share-radio-button" name="share">
                  Share viewpoint
                </paper-radio-button>
                <paper-tooltip
                  animation-delay="0"
                  for="share-radio-button"
                  position="right"
                  offset="0"
                >
                  Share viewpoint among all cameras.
                </paper-tooltip>
              </paper-radio-group>
            </div>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No point cloud data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>
                You haven’t written any point cloud data to your event files.
              </li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-mesh-loader
                  active="[[active]]"
                  selected-view="[[_selectedView]]"
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  sample="[[item.sample]]"
                  of-samples="[[item.ofSamples]]"
                  request-manager="[[_requestManager]]"
                  class="tf-mesh-loader-container"
                  on-camera-position-change="_onCameraPositionChanged"
                >
                </tf-mesh-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
      paper-radio-button {
        display: block;
        padding: 5px;
      }
      .sidebar-section h3 {
        margin: 0;
        font-weight: normal;
        font-size: 14px;
        margin-bottom: 5px;
      }

      .runs-selector {
        flex-grow: 1;
      }

      tf-runs-selector {
        display: flex;
      }

      .view-control {
        display: block !important;
      }

      .view-control h3.title {
        padding-top: 16px;
        padding-bottom: 16px;
      }

      .allcontrols .view-control paper-radio-group {
        margin-top: 5px;
      }
      /* Layout must be horizontal, i.e. items arranged in a row. If items cannot fit in a row,
       * they should be moved to next line. All items must be square at all times. Minimum size of
       * the item is 480px. This means that maximum size of the item must be 480px + 479px = 959px.
       * */
      .horizontal {
        display: flex;
        flex-direction: row;
        flex-wrap: wrap;
      }
      tf-mesh-loader {
        width: 480px;
        flex-basis: 480px;
        flex-grow: 1;
        display: block;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],ph.prototype,"reloadOnReady",void 0);E([A({type:Array}),w("design:type",Array)],ph.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],ph.prototype,"_runToTagInfo",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ph.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],ph.prototype,"_tagFilter",void 0);E([A({type:String,notify:!0}),w("design:type",String)],ph.prototype,"_selectedView",void 0);E([A({type:Object}),w("design:type",Object)],ph.prototype,"_requestManager",void 0);E([Rt("_runToTagInfo","_selectedRuns","_tagFilter"),w("design:type",Array),w("design:paramtypes",[])],ph.prototype,"_categories",null);ph=E([yt("mesh-dashboard"),w("design:paramtypes",[])],ph);var JU=class extends Gt(mt){constructor(){super(...arguments),this._installCommand="pip install -U tensorboard-plugin-profile"}_copyInstallCommand(){return Ri(this,null,function*(){let t=()=>Ri(this,null,function*(){this.$.commandTextarea.select();try{yield navigator.clipboard.writeText(this._installCommand)}catch(i){if(!document.execCommand("copy"))return Promise.reject()}}),r=this.$.copiedMessage;try{yield t(),r.innerText="Copied."}catch(n){r.innerText="Failed to copy to clipboard."}})}_removeCopiedMessage(){let t=this.$.copiedMessage;t.innerText=""}};JU.template=Q`
    <div class="message">
      <h3>The profile plugin has moved.</h3>
      <p>
        Please install the new version of the profile plugin from PyPI by
        running the following command from the machine running TensorBoard:
      </p>
      <textarea
        id="commandTextarea"
        readonly=""
        rows="1"
        on-blur="_removeCopiedMessage"
      >
[[_installCommand]]</textarea
      >
      <div id="copyContainer">
        <span id="copiedMessage"></span>
        <paper-button raised="" on-tap="_copyInstallCommand"
          >Copy to clipboard</paper-button
        >
      </div>
    </div>

    <style>
      :host {
        display: flex;
      }

      .message {
        margin: 80px auto 0 auto;
        max-width: 540px;
      }
      #commandTextarea {
        margin-top: 1ex;
        padding: 1ex 1em;
        resize: vertical;
        width: 100%;
      }
      #copyContainer {
        display: flex;
      }
      #copiedMessage {
        align-self: center;
        flex-grow: 1;
        font-style: italic;
        padding-right: 1em;
        text-align: right;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],JU.prototype,"_installCommand",void 0);JU=E([yt("tf-profile-redirect-dashboard")],JU);var lm=Ee(Oe(),1);var zl=Ee(Oe(),1),QU=Ee(wl(),1);var nn=class extends mt{constructor(){super(...arguments),this._expanded=!1,this._runToPrCurveEntry={},this._previousRunToPrCurveEntry={},this._colorScaleFunction={scale:fn},this._canceller=new an,this._xComponentsCreationMethod=()=>{let t=new QU.Scales.Linear;return{scale:t,axis:new QU.Axes.Numeric(t,"bottom"),accessor:r=>r.recall}},this._yValueAccessor=t=>t.precision,this._tooltipColumns=(()=>{let t=Wu(e0),r=n=>isNaN(n)?"NaN":t(n);return[{title:"Run",evaluate:n=>n.dataset.metadata().name},{title:"Threshold",evaluate:n=>r(n.datum.thresholds)},{title:"Precision",evaluate:n=>r(n.datum.precision)},{title:"Recall",evaluate:n=>r(n.datum.recall)},{title:"TP",evaluate:n=>n.datum.true_positives},{title:"FP",evaluate:n=>n.datum.false_positives},{title:"TN",evaluate:n=>n.datum.true_negatives},{title:"FN",evaluate:n=>n.datum.false_negatives}]})(),this._seriesDataFields=["thresholds","precision","recall","true_positives","false_positives","true_negatives","false_negatives"],this._defaultXRange=[-.05,1.05],this._defaultYRange=[-.05,1.05],this._requestData=(t,r,n)=>{let o=ve().pluginRoute("pr_curves","/pr_curves");Promise.all(t.map(a=>{let s=a,l=this.tag,c=Cn(o,{tag:l,run:s});return this.requestManager.request(c).then(u=>void r({item:a,data:u}))})).finally(()=>void n())},this._smoothingEnabled=!1}_createProcessDataFunction(){return(t,r,n)=>{this.set("_runToDataOverTime",Object.assign({},this._runToDataOverTime,n))}}_computeRunColor(t){return fn(t)}connectedCallback(){super.connectedCallback(),this._attached=!0,this.reload()}_getChartDataLoader(){var t;return(t=this.shadowRoot)==null?void 0:t.querySelector("tf-line-chart-data-loader")}reload(){if(!!this._attached){if(this.runs.length===0){this.set("_runToDataOverTime",{});return}this._getChartDataLoader().reload()}}_setChartData(){var t=this._runToPrCurveEntry,r=this._previousRunToPrCurveEntry,n=this._setOfRelevantRuns;zl.forOwn(t,(i,o)=>{let a=r[o];if(!(a&&t[o].step===a.step)){if(!n[o]){this._clearSeriesData(o);return}this._updateSeriesDataForRun(o,i)}})}_updateSeriesDataForRun(t,r){let n=zl.reduce(this._seriesDataFields,(a,s)=>(a[s]=r[s].slice().reverse(),a),{}),i=new Array(n[this._seriesDataFields[0]].length);for(let a=0;a<i.length;a++)i[a]=zl.mapValues(n,s=>s[a]);let o=this._getChartDataLoader();o.setSeriesData(t,i),o.commitChanges()}_clearSeriesData(t){let r=this._getChartDataLoader();r.setSeriesData(t,[]),r.commitChanges()}_updateRunToPrCurveEntry(){var t=this._runToDataOverTime,r=this.runToStepCap;let n={};zl.forOwn(t,(i,o)=>{!i||!i.length||(n[o]=this._computeEntryClosestOrEqualToStepCap(r[o],i))}),this.set("_previousRunToPrCurveEntry",this._runToPrCurveEntry),this.set("_runToPrCurveEntry",n)}_notifyDataChange(){var t=this._runToDataOverTime;this.onDataChange&&this.onDataChange(t)}_computeEntryClosestOrEqualToStepCap(t,r){let n=Math.min(zl.sortedIndex(r.map(i=>i.step),t),r.length-1);return r[n]}get _runsWithStepAvailable(){var t=this.runs,r=this._runToPrCurveEntry;return zl.filter(t,n=>r[n]).sort()}get _setOfRelevantRuns(){var t=this._runsWithStepAvailable;let r={};return zl.forEach(t,n=>{r[n]=!0}),r}_computeCurrentStepForRun(t,r){let n=t[r];return n?n.step:null}_computeCurrentWallTimeForRun(t,r){let n=t[r];return n?new Date(n.wall_time*1e3).toString():null}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}_resetDomain(){this._getChartDataLoader().resetDomain()}redraw(){this._getChartDataLoader().redraw()}};nn.template=Q`
    <tf-card-heading
      tag="[[tag]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
    ></tf-card-heading>

    <tf-line-chart-data-loader
      x-components-creation-method="[[_xComponentsCreationMethod]]"
      y-value-accessor="[[_yValueAccessor]]"
      tooltip-columns="[[_tooltipColumns]]"
      color-scale="[[_colorScaleFunction]]"
      default-x-range="[[_defaultXRange]]"
      default-y-range="[[_defaultYRange]]"
      smoothing-enabled="[[_smoothingEnabled]]"
      request-manager="[[requestManager]]"
      data-to-load="[[runs]]"
      data-series="[[runs]]"
      load-key="[[tag]]"
      request-data="[[_requestData]]"
      load-data-callback="[[_createProcessDataFunction()]]"
      active="[[active]]"
    ></tf-line-chart-data-loader>

    <div id="buttons-row">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
      <paper-icon-button
        icon="settings-overscan"
        on-tap="_resetDomain"
        title="Reset axes to [0, 1]."
      ></paper-icon-button>
    </div>

    <div id="step-legend">
      <template is="dom-repeat" items="[[_runsWithStepAvailable]]" as="run">
        <div class="legend-row">
          <div
            class="color-box"
            style="background: [[_computeRunColor(run)]];"
          ></div>
          [[run]] is at
          <span class="step-label-text">
            step [[_computeCurrentStepForRun(_runToPrCurveEntry, run)]] </span
          ><br />
          <span class="wall-time-label-text">
            ([[_computeCurrentWallTimeForRun(_runToPrCurveEntry, run)]])
          </span>
        </div>
      </template>
    </div>

    <style>
      :host {
        display: flex;
        flex-direction: column;
        width: 500px;
        margin-right: 10px;
        margin-bottom: 25px;
      }
      :host([_expanded]) {
        width: 100%;
      }
      tf-line-chart-data-loader {
        height: 300px;
        position: relative;
      }
      :host([_expanded]) tf-line-chart-data-loader {
        height: 600px;
      }
      #buttons-row {
        display: flex;
        flex-direction: row;
      }
      #buttons-row paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }
      #buttons-row paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }
      #step-legend {
        box-sizing: border-box;
        font-size: 0.8em;
        max-height: 200px;
        overflow-y: auto;
        padding: 0 0 0 10px;
        width: 100%;
      }
      .legend-row {
        margin: 5px 0 5px 0;
        width: 100%;
      }
      .color-box {
        display: inline-block;
        border-radius: 1px;
        width: 10px;
        height: 10px;
      }
      .step-label-text {
        font-weight: bold;
      }
      .wall-time-label-text {
        color: #888;
        font-size: 0.8em;
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],nn.prototype,"runs",void 0);E([A({type:String}),w("design:type",String)],nn.prototype,"tag",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"tagMetadata",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"runToStepCap",void 0);E([A({type:Object}),w("design:type",Ae)],nn.prototype,"requestManager",void 0);E([A({type:Boolean}),w("design:type",Boolean)],nn.prototype,"active",void 0);E([A({type:Boolean,reflectToAttribute:!0}),w("design:type",Boolean)],nn.prototype,"_expanded",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"_runToPrCurveEntry",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"_previousRunToPrCurveEntry",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"_runToDataOverTime",void 0);E([A({type:Object}),w("design:type",Function)],nn.prototype,"onDataChange",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"_colorScaleFunction",void 0);E([A({type:Object}),w("design:type",an)],nn.prototype,"_canceller",void 0);E([A({type:Boolean}),w("design:type",Boolean)],nn.prototype,"_attached",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"_xComponentsCreationMethod",void 0);E([A({type:Object}),w("design:type",Object)],nn.prototype,"_yValueAccessor",void 0);E([A({type:Array}),w("design:type",Array)],nn.prototype,"_tooltipColumns",void 0);E([A({type:Array}),w("design:type",Array)],nn.prototype,"_seriesDataFields",void 0);E([A({type:Array}),w("design:type",Array)],nn.prototype,"_defaultXRange",void 0);E([A({type:Array}),w("design:type",Array)],nn.prototype,"_defaultYRange",void 0);E([A({type:Object}),w("design:type",Function)],nn.prototype,"_requestData",void 0);E([A({type:Boolean}),w("design:type",Boolean)],nn.prototype,"_smoothingEnabled",void 0);E([Bt("runs","tag"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],nn.prototype,"reload",null);E([Bt("_runToPrCurveEntry","_previousRunToPrCurveEntry","_setOfRelevantRuns"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],nn.prototype,"_setChartData",null);E([Bt("_runToDataOverTime","runToStepCap"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],nn.prototype,"_updateRunToPrCurveEntry",null);E([Bt("_runToDataOverTime"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],nn.prototype,"_notifyDataChange",null);E([Rt("runs","_runToPrCurveEntry"),w("design:type",Array),w("design:paramtypes",[])],nn.prototype,"_runsWithStepAvailable",null);E([Rt("_runsWithStepAvailable"),w("design:type",Object),w("design:paramtypes",[])],nn.prototype,"_setOfRelevantRuns",null);nn=E([yt("tf-pr-curve-card")],nn);var SM=Ee(Oe(),1);var ep=class extends mt{constructor(){super(...arguments),this._runToStepIndex={}}_computeColorForRun(t){return fn(t)}_computeTimeTextForRun(t,r,n,i){let o=r[n];if(!SM.isNumber(o))return"";let a=t[n];if(!a)return"";let s=a[o][i];if(i==="step")return`step ${s}`;if(i==="relative")return s<1?`${(s*1e3).toFixed(2)} ms`:`${s.toFixed(2)} s`;if(i==="wall_time")return new Date(s*1e3).toString();throw new Error(`The display type of ${i} is not recognized.`)}_sliderValueChanged(t){let r=t.target.dataset.run,n=t.target.immediateValue,i=Object.assign({},this._runToStepIndex);isNaN(n)?delete i[r]:i[r]=t.target.immediateValue,this._runToStepIndex=i}_computeMaxStepIndexForRun(t,r){let n=t[r];return n&&n.length?n.length-1:0}_updateStepsForNewRuns(){var t=this.runToAvailableTimeEntries;let r=Object.assign({},this._runToStepIndex);SM.forOwn(t,(n,i)=>{SM.isNumber(r[i])||(r[i]=n.length-1)}),this._runToStepIndex=r}_getStep(t,r){return this._runToStepIndex?this._runToStepIndex[r]:0}_computeRunToStep(t,r){let n={};return SM.forOwn(r,(i,o)=>{let a=t[o];!a||(n[o]=a[i].step)}),n}get _runsWithSliders(){var t=this.runs,r=this.runToAvailableTimeEntries;return t.filter(n=>r[n])}};ep.template=Q`
    <template is="dom-repeat" items="[[_runsWithSliders]]" as="run">
      <div class="run-widget">
        <div class="run-display-container">
          <div
            class="run-color-box"
            style="background:[[_computeColorForRun(run)]];"
          ></div>
          <div class="run-text">[[run]]</div>
        </div>
        <div class="step-display-container">
          [[_computeTimeTextForRun(runToAvailableTimeEntries, _runToStepIndex,
          run, timeDisplayType)]]
        </div>
        <paper-slider
          data-run$="[[run]]"
          step="1"
          type="number"
          min="0"
          max="[[_computeMaxStepIndexForRun(runToAvailableTimeEntries, run)]]"
          value="[[_getStep(_runToStepIndex, run)]]"
          on-immediate-value-changed="_sliderValueChanged"
        ></paper-slider>
      </div>
    </template>
    <style>
      .run-widget {
        margin: 10px 0 0 0;
      }
      paper-slider {
        margin: -8px 0 0 -15px;
        width: 100%;
      }
      .step-display-container {
        font-size: 0.9em;
        margin: 0 15px 0 0;
      }
      .run-text {
        display: inline-block;
      }
      .run-color-box {
        width: 12px;
        height: 12px;
        border-radius: 3px;
        display: inline-block;
      }
    </style>
  `;E([A({type:Array}),w("design:type",Array)],ep.prototype,"runs",void 0);E([A({type:Object}),w("design:type",Object)],ep.prototype,"runToAvailableTimeEntries",void 0);E([A({type:Object,notify:!0,computed:"_computeRunToStep(runToAvailableTimeEntries, _runToStepIndex)"}),w("design:type",Object)],ep.prototype,"runToStep",void 0);E([A({type:String}),w("design:type",String)],ep.prototype,"timeDisplayType",void 0);E([A({type:Object}),w("design:type",Object)],ep.prototype,"_runToStepIndex",void 0);E([Bt("runToAvailableTimeEntries"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],ep.prototype,"_updateStepsForNewRuns",null);E([Rt("runs","runToAvailableTimeEntries"),w("design:type",Array),w("design:paramtypes",[])],ep.prototype,"_runsWithSliders",null);ep=E([yt("tf-pr-curve-steps-selector")],ep);var ko=class extends Gt(mt){constructor(){super(...arguments),this.reloadOnReady=!0,this._timeDisplayType="step",this._selectedRuns=[],this._runToTagInfo={},this._tagToRunToData={},this._getCategoryItemKey=t=>t.tag,this._requestManager=new Ae,this._step=0}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){Promise.all([this._fetchTags()]).then(()=>{this._reloadCards()})}_shouldOpen(t){return t<=2}_fetchTags(){let t=ve().pluginRoute("pr_curves","/tags");return this._requestManager.request(t).then(r=>{if(lm.isEqual(r,this._runToTagInfo))return;let n=lm.mapValues(r,o=>lm.keys(o)),i=$i(n);this.set("_dataNotFound",i.length===0),this.set("_runToTagInfo",r),this.async(()=>{this.set("_categoriesDomReady",!0)})})}_reloadCards(){var t;lm.forEach((t=this.root)==null?void 0:t.querySelectorAll("tf-pr-curve-card"),r=>{r.reload()})}get _categories(){var t=this._runToTagInfo,r=this._selectedRuns,n=this._tagFilter;let i=lm.mapValues(t,o=>Object.keys(o));return uE(i,r,n)}get _relevantSelectedRuns(){var t=this._selectedRuns,r=this._runToTagInfo;return t.filter(n=>r[n])}_tagMetadata(t,r,n){let i={};r.forEach(a=>{i[a]=t[a][n]});let o=n.replace(/\/pr_curves$/,"");return iR(i,o)}_createDataChangeCallback(t){return r=>{this.set("_tagToRunToData",Mx(Kl({},this._tagToRunToData),{[t]:r}))}}get _runToAvailableTimeEntries(){var t=this._tagToRunToData;let r={};for(let[i,o]of Object.entries(t))for(let[a]of Object.entries(o))(r[a]==null||i<r[a])&&(r[a]=i);let n={};for(let[i,o]of Object.entries(r)){let a=t[o][i];n[i]=a.map(s=>({step:s.step,wall_time:s.wall_time,relative:s.wall_time-a[0].wall_time}))}return n}};ko.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <tf-option-selector
              id="time-type-selector"
              name="Time Display Type"
              selected-id="{{_timeDisplayType}}"
            >
              <paper-button id="step">step</paper-button>
              <!--
            -->
              <paper-button id="relative">relative</paper-button>
              <!--
            -->
              <paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
          <template is="dom-if" if="[[_runToAvailableTimeEntries]]">
            <div class="sidebar-section" id="steps-selector-container">
              <tf-pr-curve-steps-selector
                runs="[[_relevantSelectedRuns]]"
                run-to-step="{{_runToStep}}"
                run-to-available-time-entries="[[_runToAvailableTimeEntries]]"
                time-display-type="[[_timeDisplayType]]"
              >
              </tf-pr-curve-steps-selector>
            </div>
          </template>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No precision–recall curve data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>
                You haven’t written any precision–recall data to your event
                files.
              </li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>
            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
              get-category-item-key="[[_getCategoryItemKey]]"
            >
              <template>
                <tf-pr-curve-card
                  active="[[active]]"
                  runs="[[item.runs]]"
                  tag="[[item.tag]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.runs, item.tag)]]"
                  request-manager="[[_requestManager]]"
                  run-to-step-cap="[[_runToStep]]"
                  on-data-change="[[_createDataChangeCallback(item.tag)]]"
                ></tf-pr-curve-card>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }

      /** Do not let the steps selector occlude the run selector. */
      #steps-selector-container {
        max-height: 60%;
        overflow-y: auto;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],ko.prototype,"reloadOnReady",void 0);E([A({type:String}),w("design:type",String)],ko.prototype,"_timeDisplayType",void 0);E([A({type:Array}),w("design:type",Array)],ko.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],ko.prototype,"_runToTagInfo",void 0);E([A({type:Object}),w("design:type",Object)],ko.prototype,"_tagToRunToData",void 0);E([A({type:Object,notify:!0}),w("design:type",Object)],ko.prototype,"_runToStep",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ko.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],ko.prototype,"_tagFilter",void 0);E([A({type:Boolean}),w("design:type",Boolean)],ko.prototype,"_categoriesDomReady",void 0);E([A({type:Object}),w("design:type",Object)],ko.prototype,"_getCategoryItemKey",void 0);E([A({type:Object}),w("design:type",Ae)],ko.prototype,"_requestManager",void 0);E([A({type:Number,notify:!0}),w("design:type",Number)],ko.prototype,"_step",void 0);E([Rt("_runToTagInfo","_selectedRuns","_tagFilter","_categoriesDomReady"),w("design:type",Array),w("design:paramtypes",[])],ko.prototype,"_categories",null);E([Rt("_selectedRuns","_runToTagInfo"),w("design:type",Array),w("design:paramtypes",[])],ko.prototype,"_relevantSelectedRuns",null);E([Rt("_tagToRunToData"),w("design:type",Object),w("design:paramtypes",[])],ko.prototype,"_runToAvailableTimeEntries",null);ko=E([yt("tf-pr-curve-dashboard")],ko);var F6=Ee(Oe(),1);var uo=class extends Gt(nb){constructor(){super(...arguments),this.reloadOnReady=!0,this._showDownloadLinks=vp("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}).call(this),this._smoothingWeight=gE("_smoothingWeight",{defaultValue:.6}).call(this),this._ignoreYOutliers=vp("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0}).call(this),this._xType=Ed.STEP,this._selectedRuns=[],this._tagFilter="",this._categories=[],this._getCategoryItemKey=t=>t.tag,this._requestManager=new Ae(50),this._showDownloadLinksObserver=xp("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}),this._smoothingWeightObserver=_E("_smoothingWeight",{defaultValue:.6}),this._ignoreYOutliersObserver=xp("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0})}get _smoothingEnabled(){var t=this._smoothingWeight;return t>0}_getCategoryKey(t){return t.metadata.type==Na.SEARCH_RESULTS?"":t.name}_shouldOpen(t){return t<=2}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then(()=>{this._reloadCharts()})}_fetchTags(){let t=ve().pluginRoute("scalars","/tags");return this._requestManager.request(t).then(r=>{if(F6.isEqual(r,this._runToTagInfo))return;let n=F6.mapValues(r,o=>Object.keys(o)),i=$i(n);this.set("_dataNotFound",i.length===0),this.set("_runToTagInfo",r),this.async(()=>{this.set("_categoriesDomReady",!0)})})}_reloadCharts(){var t;(t=this.root)==null||t.querySelectorAll("tf-scalar-card").forEach(r=>{r.reload()})}_updateCategories(){var t=this._runToTagInfo,r=this._selectedRuns,n=this._tagFilter;let i,o=n,a=F6.mapValues(t,s=>Object.keys(s));i=uE(a,r,o),i.forEach(s=>{s.items=s.items.map(l=>({tag:l.tag,series:l.runs.map(c=>({run:c,tag:l.tag}))}))}),this.updateArrayProp("_categories",i,this._getCategoryKey)}_tagMetadata(t,r,n){let i=t.name,o=n.tag,a={};n.series.forEach(({run:u})=>{a[u]=r[u][o]});let s=o.replace(/\/scalar_summary$/,""),{description:l,displayName:c}=iR(a,s);return t.metadata.type==Na.PREFIX_GROUP&&c.startsWith(i+"/")&&(c=c.slice(i.length+1)),{description:l,displayName:c}}};uo.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <div class="line-item">
              <paper-checkbox
                id="show-download-links"
                checked="{{_showDownloadLinks}}"
                >Show data download links</paper-checkbox
              >
            </div>
            <div class="line-item">
              <paper-checkbox
                id="ignore-y-outlier"
                checked="{{_ignoreYOutliers}}"
                >Ignore outliers in chart scaling</paper-checkbox
              >
            </div>
            <div id="tooltip-sorting">
              <div>Tooltip sorting method:</div>
              <paper-dropdown-menu
                no-label-float
                selected-item-label="{{_tooltipSortingMethod}}"
              >
                <paper-listbox
                  class="dropdown-content"
                  selected="0"
                  slot="dropdown-content"
                >
                  <paper-item>default</paper-item>
                  <paper-item>descending</paper-item>
                  <paper-item>ascending</paper-item>
                  <paper-item>nearest</paper-item>
                </paper-listbox>
              </paper-dropdown-menu>
            </div>
          </div>
          <div class="sidebar-section">
            <tf-smoothing-input
              weight="{{_smoothingWeight}}"
              step="0.001"
              min="0"
              max="0.999"
            ></tf-smoothing-input>
          </div>
          <div class="sidebar-section">
            <tf-option-selector
              id="x-type-selector"
              name="Horizontal Axis"
              selected-id="{{_xType}}"
            >
              <paper-button id="step">step</paper-button
              ><!--
            --><paper-button id="relative">relative</paper-button
              ><!--
            --><paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No scalar data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any scalar data to your event files.</li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
              get-category-item-key="[[_getCategoryItemKey]]"
            >
              <template>
                <tf-scalar-card
                  active="[[active]]"
                  data-to-load="[[item.series]]"
                  ignore-y-outliers="[[_ignoreYOutliers]]"
                  multi-experiments="[[_getMultiExperiments(dataSelection)]]"
                  request-manager="[[_requestManager]]"
                  show-download-links="[[_showDownloadLinks]]"
                  smoothing-enabled="[[_smoothingEnabled]]"
                  smoothing-weight="[[_smoothingWeight]]"
                  tag-metadata="[[_tagMetadata(category, _runToTagInfo, item)]]"
                  tag="[[item.tag]]"
                  tooltip-sorting-method="[[_tooltipSortingMethod]]"
                  x-type="[[_xType]]"
                  batch-size="[[featureFlags.scalarsBatchSize]]"
                  in-colab="[[featureFlags.inColab]]"
                ></tf-scalar-card>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      #tooltip-sorting {
        align-items: center;
        display: flex;
        font-size: 14px;
        margin-top: 15px;
      }

      #tooltip-sorting paper-dropdown-menu {
        margin-left: 10px;
        --paper-input-container-focus-color: var(--tb-orange-strong);
        width: 105px;
      }

      .line-item {
        display: block;
        padding-top: 5px;
      }
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
      .center {
        overflow-x: hidden;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],uo.prototype,"reloadOnReady",void 0);E([A({type:Object}),w("design:type",Object)],uo.prototype,"featureFlags",void 0);E([A({type:Boolean,notify:!0,observer:"_showDownloadLinksObserver"}),w("design:type",Boolean)],uo.prototype,"_showDownloadLinks",void 0);E([A({type:Number,notify:!0,observer:"_smoothingWeightObserver"}),w("design:type",Number)],uo.prototype,"_smoothingWeight",void 0);E([A({type:Boolean,observer:"_ignoreYOutliersObserver"}),w("design:type",Boolean)],uo.prototype,"_ignoreYOutliers",void 0);E([A({type:String}),w("design:type",String)],uo.prototype,"_xType",void 0);E([A({type:Array}),w("design:type",Array)],uo.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],uo.prototype,"_runToTagInfo",void 0);E([A({type:Boolean}),w("design:type",Boolean)],uo.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],uo.prototype,"_tagFilter",void 0);E([A({type:Boolean}),w("design:type",Boolean)],uo.prototype,"_categoriesDomReady",void 0);E([A({type:Array}),w("design:type",Array)],uo.prototype,"_categories",void 0);E([A({type:Object}),w("design:type",Object)],uo.prototype,"_getCategoryItemKey",void 0);E([A({type:Object}),w("design:type",Ae)],uo.prototype,"_requestManager",void 0);E([Rt("_smoothingWeight"),w("design:type",Boolean),w("design:paramtypes",[])],uo.prototype,"_smoothingEnabled",null);E([Bt("_runToTagInfo","_selectedRuns","_tagFilter","_categoriesDomReady"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],uo.prototype,"_updateCategories",null);uo=E([yt("tf-scalar-dashboard")],uo);var ipe=Ee(Oe(),1);var dh=class extends Gt(mt){constructor(){super(...arguments),this._texts=[],this._canceller=new an}get _runColor(){var t=this.run;return fn(t)}_changeRunColor(){var t=this._runColor;this.updateStyles({"--tb-text-loader-outline":t})}attached(){this.reload()}reload(){if(!this.isAttached)return;this._canceller.cancelAll();let t=ve(),r=Cn(t.pluginRoute("text","/text"),{tag:this.tag,run:this.run,markdown:this.markdownEnabled?"true":"false"}),n=this._canceller.cancellable(i=>{if(i.cancelled)return;let o=i.value.map(a=>({wall_time:new Date(a.wall_time*1e3),step:a.step,text:a.text}));this.set("_texts",o.slice().reverse())});this.requestManager.request(r).then(n)}_formatStep(t){return xn(",")(t)}};dh.template=Q`
    <tf-card-heading run="[[run]]" tag="[[tag]]" color="[[_runColor]]">
    </tf-card-heading>
    <paper-material
      elevation="1"
      id="steps-container"
      class="container scrollbar"
    >
      <template is="dom-repeat" items="[[_texts]]">
        <paper-material elevation="1" class="step-container">
          step <span class="step-value">[[_formatStep(item.step)]]</span>
        </paper-material>
        <paper-material elevation="1" class="text">
          <tf-markdown-view html="[[item.text]]"></tf-markdown-view>
        </paper-material>
      </template>
    </paper-material>
    <style include="scrollbar-style"></style>
    <style>
      :host {
        display: flex;
        flex-direction: column;
        width: 100%;
        height: auto;
        margin-right: 10px;
        margin-bottom: 15px;
      }
      .scrollbar {
        will-change: transform;
      }
      #steps-container {
        border-radius: 3px;
        border: 2px solid /* color computed and set as inline style */;
        display: block;
        max-height: 500px;
        overflow: auto;
        padding: 10px;
        border-color: var(--tb-text-loader-outline);
      }
      .text {
        background-color: inherit;
        border-radius: 0 3px 3px 3px;
        padding: 5px;
        word-break: break-word;
      }
      .step-container {
        background-color: var(--tb-ui-light-accent);
        border-bottom: none;
        border-radius: 3px 3px 0 0;
        border: 1px solid var(--tb-ui-border);
        display: inline-block;
        font-size: 12px;
        font-style: italic;
        margin-left: -1px; /* to correct for border */
        padding: 3px;
      }
      .step-container:not(:first-child) {
        margin-top: 15px;
      }

      tf-card-heading {
        margin-bottom: 10px;
      }
    </style>
  `;E([A({type:String}),w("design:type",String)],dh.prototype,"run",void 0);E([A({type:String}),w("design:type",String)],dh.prototype,"tag",void 0);E([A({type:Boolean}),w("design:type",Boolean)],dh.prototype,"markdownEnabled",void 0);E([A({type:Array}),w("design:type",Array)],dh.prototype,"_texts",void 0);E([A({type:Object}),w("design:type",Ae)],dh.prototype,"requestManager",void 0);E([A({type:Object}),w("design:type",an)],dh.prototype,"_canceller",void 0);E([Rt("run"),w("design:type",String),w("design:paramtypes",[])],dh.prototype,"_runColor",null);E([Bt("_runColor"),w("design:type",Function),w("design:paramtypes",[]),w("design:returntype",void 0)],dh.prototype,"_changeRunColor",null);dh=E([yt("tf-text-loader")],dh);var Qc=class extends Gt(mt){constructor(){super(...arguments),this.reloadOnReady=!0,this._markdownEnabled=vp("_markdownEnabled",{defaultValue:!0,useLocalStorage:!0}).call(this),this._requestManager=new Ae,this._markdownEnabledStorageObserver=xp("_markdownEnabled",{defaultValue:!0,useLocalStorage:!0})}static get observers(){return["_markdownEnabledObserver(_markdownEnabled)"]}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then(()=>{this._reloadTexts()})}_shouldOpen(t){return t<=2}_fetchTags(){let t=ve().pluginRoute("text","/tags");return this._requestManager.request(t).then(r=>{if(ipe.isEqual(r,this._runToTag))return;let n=$i(r);this.set("_dataNotFound",n.length===0),this.set("_runToTag",r),this.async(()=>{this.set("_categoriesDomReady",!0)})})}_reloadTexts(){var t;(t=this.root)==null||t.querySelectorAll("tf-text-loader").forEach(r=>{r.reload()})}get _categories(){var t=this._runToTag,r=this._selectedRuns,n=this._tagFilter;return Ql(t,r,n)}_markdownEnabledObserver(){this._reloadTexts()}};Qc.template=Q`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="sidebar-section">
          <div class="line-item">
            <paper-checkbox checked="{{_markdownEnabled}}"
              >Enable Markdown</paper-checkbox
            >
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No text data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any text data to your event files.</li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-text-loader
                  active="[[active]]"
                  tag="[[item.tag]]"
                  run="[[item.run]]"
                  request-manager="[[_requestManager]]"
                  markdown-enabled="[[_markdownEnabled]]"
                ></tf-text-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>
    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `;E([A({type:Boolean}),w("design:type",Boolean)],Qc.prototype,"reloadOnReady",void 0);E([A({type:Boolean,notify:!0,observer:"_markdownEnabledStorageObserver"}),w("design:type",Boolean)],Qc.prototype,"_markdownEnabled",void 0);E([A({type:Array}),w("design:type",Array)],Qc.prototype,"_selectedRuns",void 0);E([A({type:Object}),w("design:type",Object)],Qc.prototype,"_runToTag",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Qc.prototype,"_dataNotFound",void 0);E([A({type:String}),w("design:type",String)],Qc.prototype,"_tagFilter",void 0);E([A({type:Boolean}),w("design:type",Boolean)],Qc.prototype,"_categoriesDomReady",void 0);E([A({type:Object}),w("design:type",Object)],Qc.prototype,"_requestManager",void 0);E([Rt("_runToTag","_selectedRuns","_tagFilter","_categoriesDomReady"),w("design:type",Array),w("design:paramtypes",[])],Qc.prototype,"_categories",null);Qc=E([yt("tf-text-dashboard")],Qc);var ope=class extends mt{constructor(){super(...arguments),this._template=null,this.tf_backend=kB}};ope=E([yt("tf-backend")],ope);var ape=class extends mt{constructor(){super(...arguments),this._template=null,this.runsColorScale=fn}};ape=E([yt("tf-color-scale")],ape);var spe=class extends mt{constructor(){super(...arguments),this._template=null,this.tf_feature_flags=tW}};spe=E([yt("tf-feature-flags")],spe);var lpe=class extends mt{constructor(){super(...arguments),this._template=null,this.tf_globals=RW}};lpe=E([yt("tf-globals")],lpe);var Uht={};Ks(Uht,{TfDomRepeat:()=>Oi,addLimitListener:()=>qW,getLimit:()=>WW,removeLimitListener:()=>GW,setLimit:()=>r2e});var cpe=class extends mt{constructor(){super(...arguments),this._template=null,this.tf_paginated_view=Uht}};cpe=E([yt("tf-paginated-view-store")],cpe);var upe=class extends mt{constructor(){super(...arguments),this._template=null,this.tf_storage=DB}};upe=E([yt("tf-storage")],upe);})();
/*!
 * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
 *
 * Copyright (c) 2014-2017, Jon Schlinkert.
 * Released under the MIT License.
 */
/*!
 * isobject <https://github.com/jonschlinkert/isobject>
 *
 * Copyright (c) 2014-2017, Jon Schlinkert.
 * Released under the MIT License.
 */
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0

THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.

See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
/**
 * @fileoverview
 * @suppress {checkPrototypalTypes}
 * @license Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
 * This code may only be used under the BSD style license found at
 * http://polymer.github.io/LICENSE.txt The complete set of authors may be found
 * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may
 * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by
 * Google as part of the polymer project is also subject to an additional IP
 * rights grant found at http://polymer.github.io/PATENTS.txt
 */
/**
 * @license
 * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
 * This code may only be used under the BSD style license found at
 * http://polymer.github.io/LICENSE.txt The complete set of authors may be found
 * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may
 * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by
 * Google as part of the polymer project is also subject to an additional IP
 * rights grant found at http://polymer.github.io/PATENTS.txt
 */
/**
 * @license
 * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
 * This code may only be used under the BSD style license found at
 * http://polymer.github.io/LICENSE.txt
 * The complete set of authors may be found at
 * http://polymer.github.io/AUTHORS.txt
 * The complete set of contributors may be found at
 * http://polymer.github.io/CONTRIBUTORS.txt
 * Code distributed by Google as part of the polymer project is also
 * subject to an additional IP rights grant found at
 * http://polymer.github.io/PATENTS.txt
 */
/**
 * @license
 * Copyright (c) 2018 The Polymer Project Authors. All rights reserved.
 * This code may only be used under the BSD style license found at
 * http://polymer.github.io/LICENSE.txt
 * The complete set of authors may be found at
 * http://polymer.github.io/AUTHORS.txt
 * The complete set of contributors may be found at
 * http://polymer.github.io/CONTRIBUTORS.txt
 * Code distributed by Google as part of the polymer project is also
 * subject to an additional IP rights grant found at
 * http://polymer.github.io/PATENTS.txt
 */
/**
 * @license
 * Copyright (c) 2021 Vaadin Ltd.
 * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
 */
/**
 * @license
 * Copyright 2010-2022 Three.js Authors
 * SPDX-License-Identifier: MIT
 */
/**
 * @license
 * Lodash <https://lodash.com/>
 * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
 * Released under MIT license <https://lodash.com/license>
 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
 */
/**
 * Copyright 2014-present Palantir Technologies
 * @license MIT
 *
 * @fileoverview manually add d3-selection-multi to d3 default bundle. Most of this code is
 * copied from d3-selection-multi@1.0.0.
 * See https://github.com/d3/d3-selection-multi/issues/11 for why we have to do this
 */
/**
 * Copyright 2014-present Palantir Technologies
 * @license MIT
 * @fileoverview Implements a convenient thunk function to handle the common case
 * of creating a memoized function that takes its inputs from mutable class properties.
 */
/**
 * Copyright 2014-present Palantir Technologies
 * @license MIT
 * @fileoverview Implements a function memoizer using the Signature API.
 */
/**
 * Copyright 2014-present Palantir Technologies
 * @license MIT
 * @fileoverview Implements the Signature API to help in comparing when two
 * Plottable objects have "changed".
 *
 * Memoization in Plottable is complicated by mutable scales and datasets. We cannot simply
 * reference compare two e.g. scales since it may have internally mutated. To resolve this,
 * we write a recursive Signature interface that holds an immutable snapshot of whatever
 * state the scale/data was in at the time. Then on memoized function invocation we sign the
 * new inputs and compare the signatures to decide if we should recompute.
 *
 * We must hand-write a signature for each custom class we wish to support.
 */
/**
 * Copyright 2014-present Palantir Technologies
 * @license MIT
 */
/**
 * Copyright 2017-present Palantir Technologies
 * @license MIT
 */
/**
@license
Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at
http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
part of the polymer project is also subject to an additional IP rights grant
found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at
http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
part of the polymer project is also subject to an additional IP rights grant
found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
Code distributed by Google as part of the polymer project is also
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at
http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
part of the polymer project is also subject to an additional IP rights grant
found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
Code distributed by Google as part of the polymer project is also
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at
http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
part of the polymer project is also subject to an additional IP rights grant
found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
Code distributed by Google as part of the polymer project is also
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2019 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at
http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
part of the polymer project is also subject to an additional IP rights grant
found at http://polymer.github.io/PATENTS.txt
*/
/**
@license
Copyright (c) 2019 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
Code distributed by Google as part of the polymer project is also
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
*/

(()=>{var Jge=Object.create,LE=Object.defineProperty,$ge=Object.getOwnPropertyDescriptor,e0e=Object.getOwnPropertyNames,t0e=Object.getPrototypeOf,n0e=Object.prototype.hasOwnProperty,ho=(n,t)=>()=>(n&&(t=n(n=0)),t),Rd=(n,t)=>()=>(t||n((t={exports:{}}).exports,t),t.exports),BE=(n,t)=>{for(var e in t)LE(n,e,{get:t[e],enumerable:!0})},I6=(n,t,e,i)=>{if(t&&"object"==typeof t||"function"==typeof t)for(let r of e0e(t))!n0e.call(n,r)&&r!==e&&LE(n,r,{get:()=>t[r],enumerable:!(i=$ge(t,r))||i.enumerable});return n},oN=(n,t,e)=>(e=null!=n?Jge(t0e(n)):{},I6(!t&&n&&n.__esModule?e:LE(e,"default",{value:n,enumerable:!0}),n)),uW=Rd((Drt,e1)=>{var j6,G6,W6,q6,Y6,X6,Q6,K6,Z6,JE,yN,J6,$6,eW,m0,tW,nW,iW,rW,oW,sW,aW,lW,cW,$E;!function(n){var t="object"==typeof global?global:"object"==typeof self?self:"object"==typeof this?this:{};function e(i,r){return i!==t&&("function"==typeof Object.create?Object.defineProperty(i,"__esModule",{value:!0}):i.__esModule=!0),function(o,s){return i[o]=r?r(o,s):s}}"function"==typeof define&&define.amd?define("tslib",["exports"],function(i){n(e(t,e(i)))}):n("object"==typeof e1&&"object"==typeof e1.exports?e(t,e(e1.exports)):e(t))}(function(n){var t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(i,r){i.__proto__=r}||function(i,r){for(var o in r)Object.prototype.hasOwnProperty.call(r,o)&&(i[o]=r[o])};j6=function(i,r){if("function"!=typeof r&&null!==r)throw new TypeError("Class extends value "+String(r)+" is not a constructor or null");function o(){this.constructor=i}t(i,r),i.prototype=null===r?Object.create(r):(o.prototype=r.prototype,new o)},G6=Object.assign||function(i){for(var r,o=1,s=arguments.length;o<s;o++)for(var a in r=arguments[o])Object.prototype.hasOwnProperty.call(r,a)&&(i[a]=r[a]);return i},W6=function(i,r){var o={};for(var s in i)Object.prototype.hasOwnProperty.call(i,s)&&r.indexOf(s)<0&&(o[s]=i[s]);if(null!=i&&"function"==typeof Object.getOwnPropertySymbols){var a=0;for(s=Object.getOwnPropertySymbols(i);a<s.length;a++)r.indexOf(s[a])<0&&Object.prototype.propertyIsEnumerable.call(i,s[a])&&(o[s[a]]=i[s[a]])}return o},q6=function(i,r,o,s){var c,a=arguments.length,l=a<3?r:null===s?s=Object.getOwnPropertyDescriptor(r,o):s;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)l=Reflect.decorate(i,r,o,s);else for(var u=i.length-1;u>=0;u--)(c=i[u])&&(l=(a<3?c(l):a>3?c(r,o,l):c(r,o))||l);return a>3&&l&&Object.defineProperty(r,o,l),l},Y6=function(i,r){return function(o,s){r(o,s,i)}},X6=function(i,r){if("object"==typeof Reflect&&"function"==typeof Reflect.metadata)return Reflect.metadata(i,r)},Q6=function(i,r,o,s){return new(o||(o=Promise))(function(l,c){function u(h){try{p(s.next(h))}catch(f){c(f)}}function d(h){try{p(s.throw(h))}catch(f){c(f)}}function p(h){h.done?l(h.value):function(l){return l instanceof o?l:new o(function(c){c(l)})}(h.value).then(u,d)}p((s=s.apply(i,r||[])).next())})},K6=function(i,r){var s,a,l,c,o={label:0,sent:function(){if(1&l[0])throw l[1];return l[1]},trys:[],ops:[]};return c={next:u(0),throw:u(1),return:u(2)},"function"==typeof Symbol&&(c[Symbol.iterator]=function(){return this}),c;function u(p){return function(h){return function(p){if(s)throw new TypeError("Generator is already executing.");for(;c&&(c=0,p[0]&&(o=0)),o;)try{if(s=1,a&&(l=2&p[0]?a.return:p[0]?a.throw||((l=a.return)&&l.call(a),0):a.next)&&!(l=l.call(a,p[1])).done)return l;switch(a=0,l&&(p=[2&p[0],l.value]),p[0]){case 0:case 1:l=p;break;case 4:return o.label++,{value:p[1],done:!1};case 5:o.label++,a=p[1],p=[0];continue;case 7:p=o.ops.pop(),o.trys.pop();continue;default:if(!(l=(l=o.trys).length>0&&l[l.length-1])&&(6===p[0]||2===p[0])){o=0;continue}if(3===p[0]&&(!l||p[1]>l[0]&&p[1]<l[3])){o.label=p[1];break}if(6===p[0]&&o.label<l[1]){o.label=l[1],l=p;break}if(l&&o.label<l[2]){o.label=l[2],o.ops.push(p);break}l[2]&&o.ops.pop(),o.trys.pop();continue}p=r.call(i,o)}catch(h){p=[6,h],a=0}finally{s=l=0}if(5&p[0])throw p[1];return{value:p[0]?p[1]:void 0,done:!0}}([p,h])}}},Z6=function(i,r){for(var o in i)"default"!==o&&!Object.prototype.hasOwnProperty.call(r,o)&&$E(r,i,o)},$E=Object.create?function(i,r,o,s){void 0===s&&(s=o);var a=Object.getOwnPropertyDescriptor(r,o);(!a||("get"in a?!r.__esModule:a.writable||a.configurable))&&(a={enumerable:!0,get:function(){return r[o]}}),Object.defineProperty(i,s,a)}:function(i,r,o,s){void 0===s&&(s=o),i[s]=r[o]},JE=function(i){var r="function"==typeof Symbol&&Symbol.iterator,o=r&&i[r],s=0;if(o)return o.call(i);if(i&&"number"==typeof i.length)return{next:function(){return i&&s>=i.length&&(i=void 0),{value:i&&i[s++],done:!i}}};throw new TypeError(r?"Object is not iterable.":"Symbol.iterator is not defined.")},yN=function(i,r){var o="function"==typeof Symbol&&i[Symbol.iterator];if(!o)return i;var a,c,s=o.call(i),l=[];try{for(;(void 0===r||r-- >0)&&!(a=s.next()).done;)l.push(a.value)}catch(u){c={error:u}}finally{try{a&&!a.done&&(o=s.return)&&o.call(s)}finally{if(c)throw c.error}}return l},J6=function(){for(var i=[],r=0;r<arguments.length;r++)i=i.concat(yN(arguments[r]));return i},$6=function(){for(var i=0,r=0,o=arguments.length;r<o;r++)i+=arguments[r].length;var s=Array(i),a=0;for(r=0;r<o;r++)for(var l=arguments[r],c=0,u=l.length;c<u;c++,a++)s[a]=l[c];return s},eW=function(i,r,o){if(o||2===arguments.length)for(var l,s=0,a=r.length;s<a;s++)(l||!(s in r))&&(l||(l=Array.prototype.slice.call(r,0,s)),l[s]=r[s]);return i.concat(l||Array.prototype.slice.call(r))},m0=function(i){return this instanceof m0?(this.v=i,this):new m0(i)},tW=function(i,r,o){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var a,s=o.apply(i,r||[]),l=[];return a={},c("next"),c("throw"),c("return"),a[Symbol.asyncIterator]=function(){return this},a;function c(m){s[m]&&(a[m]=function(x){return new Promise(function(g,b){l.push([m,x,g,b])>1||u(m,x)})})}function u(m,x){try{!function(m){m.value instanceof m0?Promise.resolve(m.value.v).then(p,h):f(l[0][2],m)}(s[m](x))}catch(g){f(l[0][3],g)}}function p(m){u("next",m)}function h(m){u("throw",m)}function f(m,x){m(x),l.shift(),l.length&&u(l[0][0],l[0][1])}},nW=function(i){var r,o;return r={},s("next"),s("throw",function(a){throw a}),s("return"),r[Symbol.iterator]=function(){return this},r;function s(a,l){r[a]=i[a]?function(c){return(o=!o)?{value:m0(i[a](c)),done:"return"===a}:l?l(c):c}:l}},iW=function(i){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var o,r=i[Symbol.asyncIterator];return r?r.call(i):(i=JE(i),o={},s("next"),s("throw"),s("return"),o[Symbol.asyncIterator]=function(){return this},o);function s(l){o[l]=i[l]&&function(c){return new Promise(function(u,d){!function(l,c,u,d){Promise.resolve(d).then(function(p){l({value:p,done:u})},c)}(u,d,(c=i[l](c)).done,c.value)})}}},rW=function(i,r){return Object.defineProperty?Object.defineProperty(i,"raw",{value:r}):i.raw=r,i};var e=Object.create?function(i,r){Object.defineProperty(i,"default",{enumerable:!0,value:r})}:function(i,r){i.default=r};oW=function(i){if(i&&i.__esModule)return i;var r={};if(null!=i)for(var o in i)"default"!==o&&Object.prototype.hasOwnProperty.call(i,o)&&$E(r,i,o);return e(r,i),r},sW=function(i){return i&&i.__esModule?i:{default:i}},aW=function(i,r,o,s){if("a"===o&&!s)throw new TypeError("Private accessor was defined without a getter");if("function"==typeof r?i!==r||!s:!r.has(i))throw new TypeError("Cannot read private member from an object whose class did not declare it");return"m"===o?s:"a"===o?s.call(i):s?s.value:r.get(i)},lW=function(i,r,o,s,a){if("m"===s)throw new TypeError("Private method is not writable");if("a"===s&&!a)throw new TypeError("Private accessor was defined without a setter");if("function"==typeof r?i!==r||!a:!r.has(i))throw new TypeError("Cannot write private member to an object whose class did not declare it");return"a"===s?a.call(i,o):a?a.value=o:r.set(i,o),o},cW=function(i,r){if(null===r||"object"!=typeof r&&"function"!=typeof r)throw new TypeError("Cannot use 'in' operator on non-object");return"function"==typeof i?r===i:i.has(r)},n("__extends",j6),n("__assign",G6),n("__rest",W6),n("__decorate",q6),n("__param",Y6),n("__metadata",X6),n("__awaiter",Q6),n("__generator",K6),n("__exportStar",Z6),n("__createBinding",$E),n("__values",JE),n("__read",yN),n("__spread",J6),n("__spreadArrays",$6),n("__spreadArray",eW),n("__await",m0),n("__asyncGenerator",tW),n("__asyncDelegator",nW),n("__asyncValues",iW),n("__makeTemplateObject",rW),n("__importStar",oW),n("__importDefault",sW),n("__classPrivateFieldGet",aW),n("__classPrivateFieldSet",lW),n("__classPrivateFieldIn",cW)})}),mZ=Rd(b5=>{"use strict";var n,uh=b5&&b5.__spreadArray||function(n,t,e){if(e||2===arguments.length)for(var o,i=0,r=t.length;i<r;i++)(o||!(i in t))&&(o||(o=Array.prototype.slice.call(t,0,i)),o[i]=t[i]);return n.concat(o||Array.prototype.slice.call(t))};n=function(){!function(Q){var re=Q.performance;function _e(St){re&&re.mark&&re.mark(St)}function I(St,we){re&&re.measure&&re.measure(St,we)}_e("Zone");var X=Q.__Zone_symbol_prefix||"__zone_symbol__";function $(St){return X+St}var ne=!0===Q[$("forceDuplicateZoneCheck")];if(Q.Zone){if(ne||"function"!=typeof Q.Zone.__symbol__)throw new Error("Zone already loaded.");return Q.Zone}var me=function(){function St(we,Ee){this._parent=we,this._name=Ee?Ee.name||"unnamed":"<root>",this._properties=Ee&&Ee.properties||{},this._zoneDelegate=new lt(this,this._parent&&this._parent._zoneDelegate,Ee)}return St.assertZonePatched=function(){if(Q.Promise!==jn.ZoneAwarePromise)throw new Error("Zone.js has detected that ZoneAwarePromise `(window|global).Promise` has been overwritten.\nMost likely cause is that a Promise polyfill has been loaded after Zone.js (Polyfilling Promise api is not necessary when zone.js is loaded. If you must load one, do so before loading zone.js.)")},Object.defineProperty(St,"root",{get:function(){for(var we=St.current;we.parent;)we=we.parent;return we},enumerable:!1,configurable:!0}),Object.defineProperty(St,"current",{get:function(){return br.zone},enumerable:!1,configurable:!0}),Object.defineProperty(St,"currentTask",{get:function(){return xa},enumerable:!1,configurable:!0}),St.__load_patch=function(we,Ee,Ve){if(void 0===Ve&&(Ve=!1),jn.hasOwnProperty(we)){if(!Ve&&ne)throw Error("Already loaded patch: "+we)}else if(!Q["__Zone_disable_"+we]){var kn="Zone:"+we;_e(kn),jn[we]=Ee(Q,St,Dr),I(kn,kn)}},Object.defineProperty(St.prototype,"parent",{get:function(){return this._parent},enumerable:!1,configurable:!0}),Object.defineProperty(St.prototype,"name",{get:function(){return this._name},enumerable:!1,configurable:!0}),St.prototype.get=function(we){var Ee=this.getZoneWith(we);if(Ee)return Ee._properties[we]},St.prototype.getZoneWith=function(we){for(var Ee=this;Ee;){if(Ee._properties.hasOwnProperty(we))return Ee;Ee=Ee._parent}return null},St.prototype.fork=function(we){if(!we)throw new Error("ZoneSpec required!");return this._zoneDelegate.fork(this,we)},St.prototype.wrap=function(we,Ee){if("function"!=typeof we)throw new Error("Expecting function got: "+we);var Ve=this._zoneDelegate.intercept(this,we,Ee),kn=this;return function(){return kn.runGuarded(Ve,this,arguments,Ee)}},St.prototype.run=function(we,Ee,Ve,kn){br={parent:br,zone:this};try{return this._zoneDelegate.invoke(this,we,Ee,Ve,kn)}finally{br=br.parent}},St.prototype.runGuarded=function(we,Ee,Ve,kn){void 0===Ee&&(Ee=null),br={parent:br,zone:this};try{try{return this._zoneDelegate.invoke(this,we,Ee,Ve,kn)}catch(Ir){if(this._zoneDelegate.handleError(this,Ir))throw Ir}}finally{br=br.parent}},St.prototype.runTask=function(we,Ee,Ve){if(we.zone!=this)throw new Error("A task can only be run in the zone of creation! (Creation: "+(we.zone||Ot).name+"; Execution: "+this.name+")");if(we.state!==wi||we.type!==Si&&we.type!==Un){var kn=we.state!=$n;kn&&we._transitionTo($n,Yn),we.runCount++;var Ir=xa;xa=we,br={parent:br,zone:this};try{we.type==Un&&we.data&&!we.data.isPeriodic&&(we.cancelFn=void 0);try{return this._zoneDelegate.invokeTask(this,we,Ee,Ve)}catch(xc){if(this._zoneDelegate.handleError(this,xc))throw xc}}finally{we.state!==wi&&we.state!==Yi&&(we.type==Si||we.data&&we.data.isPeriodic?kn&&we._transitionTo(Yn,$n):(we.runCount=0,this._updateTaskCount(we,-1),kn&&we._transitionTo(wi,$n,wi))),br=br.parent,xa=Ir}}},St.prototype.scheduleTask=function(we){if(we.zone&&we.zone!==this)for(var Ee=this;Ee;){if(Ee===we.zone)throw Error("can not reschedule task to ".concat(this.name," which is descendants of the original zone ").concat(we.zone.name));Ee=Ee.parent}we._transitionTo(ai,wi);var Ve=[];we._zoneDelegates=Ve,we._zone=this;try{we=this._zoneDelegate.scheduleTask(this,we)}catch(kn){throw we._transitionTo(Yi,ai,wi),this._zoneDelegate.handleError(this,kn),kn}return we._zoneDelegates===Ve&&this._updateTaskCount(we,1),we.state==ai&&we._transitionTo(Yn,ai),we},St.prototype.scheduleMicroTask=function(we,Ee,Ve,kn){return this.scheduleTask(new Je(An,we,Ee,Ve,kn,void 0))},St.prototype.scheduleMacroTask=function(we,Ee,Ve,kn,Ir){return this.scheduleTask(new Je(Un,we,Ee,Ve,kn,Ir))},St.prototype.scheduleEventTask=function(we,Ee,Ve,kn,Ir){return this.scheduleTask(new Je(Si,we,Ee,Ve,kn,Ir))},St.prototype.cancelTask=function(we){if(we.zone!=this)throw new Error("A task can only be cancelled in the zone of creation! (Creation: "+(we.zone||Ot).name+"; Execution: "+this.name+")");if(we.state===Yn||we.state===$n){we._transitionTo(Yt,Yn,$n);try{this._zoneDelegate.cancelTask(this,we)}catch(Ee){throw we._transitionTo(Yi,Yt),this._zoneDelegate.handleError(this,Ee),Ee}return this._updateTaskCount(we,-1),we._transitionTo(wi,Yt),we.runCount=0,we}},St.prototype._updateTaskCount=function(we,Ee){var Ve=we._zoneDelegates;-1==Ee&&(we._zoneDelegates=null);for(var kn=0;kn<Ve.length;kn++)Ve[kn]._updateTaskCount(we.type,Ee)},St}();me.__symbol__=$;var rr,Ke={name:"",onHasTask:function(St,we,Ee,Ve){return St.hasTask(Ee,Ve)},onScheduleTask:function(St,we,Ee,Ve){return St.scheduleTask(Ee,Ve)},onInvokeTask:function(St,we,Ee,Ve,kn,Ir){return St.invokeTask(Ee,Ve,kn,Ir)},onCancelTask:function(St,we,Ee,Ve){return St.cancelTask(Ee,Ve)}},lt=function(){function St(we,Ee,Ve){this._taskCounts={microTask:0,macroTask:0,eventTask:0},this.zone=we,this._parentDelegate=Ee,this._forkZS=Ve&&(Ve&&Ve.onFork?Ve:Ee._forkZS),this._forkDlgt=Ve&&(Ve.onFork?Ee:Ee._forkDlgt),this._forkCurrZone=Ve&&(Ve.onFork?this.zone:Ee._forkCurrZone),this._interceptZS=Ve&&(Ve.onIntercept?Ve:Ee._interceptZS),this._interceptDlgt=Ve&&(Ve.onIntercept?Ee:Ee._interceptDlgt),this._interceptCurrZone=Ve&&(Ve.onIntercept?this.zone:Ee._interceptCurrZone),this._invokeZS=Ve&&(Ve.onInvoke?Ve:Ee._invokeZS),this._invokeDlgt=Ve&&(Ve.onInvoke?Ee:Ee._invokeDlgt),this._invokeCurrZone=Ve&&(Ve.onInvoke?this.zone:Ee._invokeCurrZone),this._handleErrorZS=Ve&&(Ve.onHandleError?Ve:Ee._handleErrorZS),this._handleErrorDlgt=Ve&&(Ve.onHandleError?Ee:Ee._handleErrorDlgt),this._handleErrorCurrZone=Ve&&(Ve.onHandleError?this.zone:Ee._handleErrorCurrZone),this._scheduleTaskZS=Ve&&(Ve.onScheduleTask?Ve:Ee._scheduleTaskZS),this._scheduleTaskDlgt=Ve&&(Ve.onScheduleTask?Ee:Ee._scheduleTaskDlgt),this._scheduleTaskCurrZone=Ve&&(Ve.onScheduleTask?this.zone:Ee._scheduleTaskCurrZone),this._invokeTaskZS=Ve&&(Ve.onInvokeTask?Ve:Ee._invokeTaskZS),this._invokeTaskDlgt=Ve&&(Ve.onInvokeTask?Ee:Ee._invokeTaskDlgt),this._invokeTaskCurrZone=Ve&&(Ve.onInvokeTask?this.zone:Ee._invokeTaskCurrZone),this._cancelTaskZS=Ve&&(Ve.onCancelTask?Ve:Ee._cancelTaskZS),this._cancelTaskDlgt=Ve&&(Ve.onCancelTask?Ee:Ee._cancelTaskDlgt),this._cancelTaskCurrZone=Ve&&(Ve.onCancelTask?this.zone:Ee._cancelTaskCurrZone),this._hasTaskZS=null,this._hasTaskDlgt=null,this._hasTaskDlgtOwner=null,this._hasTaskCurrZone=null;var kn=Ve&&Ve.onHasTask;(kn||Ee&&Ee._hasTaskZS)&&(this._hasTaskZS=kn?Ve:Ke,this._hasTaskDlgt=Ee,this._hasTaskDlgtOwner=this,this._hasTaskCurrZone=we,Ve.onScheduleTask||(this._scheduleTaskZS=Ke,this._scheduleTaskDlgt=Ee,this._scheduleTaskCurrZone=this.zone),Ve.onInvokeTask||(this._invokeTaskZS=Ke,this._invokeTaskDlgt=Ee,this._invokeTaskCurrZone=this.zone),Ve.onCancelTask||(this._cancelTaskZS=Ke,this._cancelTaskDlgt=Ee,this._cancelTaskCurrZone=this.zone))}return St.prototype.fork=function(we,Ee){return this._forkZS?this._forkZS.onFork(this._forkDlgt,this.zone,we,Ee):new me(we,Ee)},St.prototype.intercept=function(we,Ee,Ve){return this._interceptZS?this._interceptZS.onIntercept(this._interceptDlgt,this._interceptCurrZone,we,Ee,Ve):Ee},St.prototype.invoke=function(we,Ee,Ve,kn,Ir){return this._invokeZS?this._invokeZS.onInvoke(this._invokeDlgt,this._invokeCurrZone,we,Ee,Ve,kn,Ir):Ee.apply(Ve,kn)},St.prototype.handleError=function(we,Ee){return!this._handleErrorZS||this._handleErrorZS.onHandleError(this._handleErrorDlgt,this._handleErrorCurrZone,we,Ee)},St.prototype.scheduleTask=function(we,Ee){var Ve=Ee;if(this._scheduleTaskZS)this._hasTaskZS&&Ve._zoneDelegates.push(this._hasTaskDlgtOwner),(Ve=this._scheduleTaskZS.onScheduleTask(this._scheduleTaskDlgt,this._scheduleTaskCurrZone,we,Ee))||(Ve=Ee);else if(Ee.scheduleFn)Ee.scheduleFn(Ee);else{if(Ee.type!=An)throw new Error("Task is missing scheduleFn.");Mn(Ee)}return Ve},St.prototype.invokeTask=function(we,Ee,Ve,kn){return this._invokeTaskZS?this._invokeTaskZS.onInvokeTask(this._invokeTaskDlgt,this._invokeTaskCurrZone,we,Ee,Ve,kn):Ee.callback.apply(Ve,kn)},St.prototype.cancelTask=function(we,Ee){var Ve;if(this._cancelTaskZS)Ve=this._cancelTaskZS.onCancelTask(this._cancelTaskDlgt,this._cancelTaskCurrZone,we,Ee);else{if(!Ee.cancelFn)throw Error("Task is not cancelable");Ve=Ee.cancelFn(Ee)}return Ve},St.prototype.hasTask=function(we,Ee){try{this._hasTaskZS&&this._hasTaskZS.onHasTask(this._hasTaskDlgt,this._hasTaskCurrZone,we,Ee)}catch(Ve){this.handleError(we,Ve)}},St.prototype._updateTaskCount=function(we,Ee){var Ve=this._taskCounts,kn=Ve[we],Ir=Ve[we]=kn+Ee;if(Ir<0)throw new Error("More tasks executed then were scheduled.");0!=kn&&0!=Ir||this.hasTask(this.zone,{microTask:Ve.microTask>0,macroTask:Ve.macroTask>0,eventTask:Ve.eventTask>0,change:we})},St}(),Je=function(){function St(we,Ee,Ve,kn,Ir,xc){if(this._zone=null,this.runCount=0,this._zoneDelegates=null,this._state="notScheduled",this.type=we,this.source=Ee,this.data=kn,this.scheduleFn=Ir,this.cancelFn=xc,!Ve)throw new Error("callback is not defined");this.callback=Ve;var ct=this;this.invoke=we===Si&&kn&&kn.useG?St.invokeTask:function(){return St.invokeTask.call(Q,ct,this,arguments)}}return St.invokeTask=function(we,Ee,Ve){we||(we=this),Vr++;try{return we.runCount++,we.zone.runTask(we,Ee,Ve)}finally{1==Vr&&Hn(),Vr--}},Object.defineProperty(St.prototype,"zone",{get:function(){return this._zone},enumerable:!1,configurable:!0}),Object.defineProperty(St.prototype,"state",{get:function(){return this._state},enumerable:!1,configurable:!0}),St.prototype.cancelScheduleRequest=function(){this._transitionTo(wi,ai)},St.prototype._transitionTo=function(we,Ee,Ve){if(this._state!==Ee&&this._state!==Ve)throw new Error("".concat(this.type," '").concat(this.source,"': can not transition to '").concat(we,"', expecting state '").concat(Ee,"'").concat(Ve?" or '"+Ve+"'":"",", was '").concat(this._state,"'."));this._state=we,we==wi&&(this._zoneDelegates=null)},St.prototype.toString=function(){return this.data&&typeof this.data.handleId<"u"?this.data.handleId.toString():Object.prototype.toString.call(this)},St.prototype.toJSON=function(){return{type:this.type,state:this.state,source:this.source,zone:this.zone.name,runCount:this.runCount}},St}(),ft=$("setTimeout"),Ct=$("Promise"),It=$("then"),Nt=[],bn=!1;function Ai(St){if(rr||Q[Ct]&&(rr=Q[Ct].resolve(0)),rr){var we=rr[It];we||(we=rr.then),we.call(rr,St)}else Q[ft](St,0)}function Mn(St){0===Vr&&0===Nt.length&&Ai(Hn),St&&Nt.push(St)}function Hn(){if(!bn){for(bn=!0;Nt.length;){var St=Nt;Nt=[];for(var we=0;we<St.length;we++){var Ee=St[we];try{Ee.zone.runTask(Ee,null,null)}catch(Ve){Dr.onUnhandledError(Ve)}}}Dr.microtaskDrainDone(),bn=!1}}var Ot={name:"NO ZONE"},wi="notScheduled",ai="scheduling",Yn="scheduled",$n="running",Yt="canceling",Yi="unknown",An="microTask",Un="macroTask",Si="eventTask",jn={},Dr={symbol:$,currentZoneFrame:function(){return br},onUnhandledError:Ar,microtaskDrainDone:Ar,scheduleMicroTask:Mn,showUncaughtError:function(){return!me[$("ignoreConsoleErrorUncaughtError")]},patchEventTarget:function(){return[]},patchOnProperties:Ar,patchMethod:function(){return Ar},bindArguments:function(){return[]},patchThen:function(){return Ar},patchMacroTask:function(){return Ar},patchEventPrototype:function(){return Ar},isIEOrEdge:function(){return!1},getGlobalObjects:function(){},ObjectDefineProperty:function(){return Ar},ObjectGetOwnPropertyDescriptor:function(){},ObjectCreate:function(){},ArraySlice:function(){return[]},patchClass:function(){return Ar},wrapWithCurrentZone:function(){return Ar},filterProperties:function(){return[]},attachOriginToPatched:function(){return Ar},_redefineProperty:function(){return Ar},patchCallbacks:function(){return Ar},nativeScheduleMicroTask:Ai},br={parent:null,zone:new me(null,null)},xa=null,Vr=0;function Ar(){}I("Zone","Zone"),Q.Zone=me}(typeof window<"u"&&window||typeof self<"u"&&self||global);var n=Object.getOwnPropertyDescriptor,t=Object.defineProperty,e=Object.getPrototypeOf,i=Object.create,r=Array.prototype.slice,o="addEventListener",s="removeEventListener",a=Zone.__symbol__(o),l=Zone.__symbol__(s),c="true",u="false",d=Zone.__symbol__("");function p(Q,re){return Zone.current.wrap(Q,re)}function h(Q,re,_e,I,X){return Zone.current.scheduleMacroTask(Q,re,_e,I,X)}var f=Zone.__symbol__,m=typeof window<"u",x=m?window:void 0,g=m&&x||"object"==typeof self&&self||global;function D(Q,re){for(var _e=Q.length-1;_e>=0;_e--)"function"==typeof Q[_e]&&(Q[_e]=p(Q[_e],re+"_"+_e));return Q}function k(Q){return!Q||!1!==Q.writable&&!("function"==typeof Q.get&&typeof Q.set>"u")}var Z=typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope,z=!("nw"in g)&&typeof g.process<"u"&&"[object process]"==={}.toString.call(g.process),fe=!z&&!Z&&!(!m||!x.HTMLElement),ue=typeof g.process<"u"&&"[object process]"==={}.toString.call(g.process)&&!Z&&!(!m||!x.HTMLElement),he={},w=function(Q){if(Q=Q||g.event){var re=he[Q.type];re||(re=he[Q.type]=f("ON_PROPERTY"+Q.type));var X,_e=this||Q.target||g,I=_e[re];if(fe&&_e===x&&"error"===Q.type){var $=Q;!0===(X=I&&I.call(this,$.message,$.filename,$.lineno,$.colno,$.error))&&Q.preventDefault()}else null!=(X=I&&I.apply(this,arguments))&&!X&&Q.preventDefault();return X}};function F(Q,re,_e){var I=n(Q,re);if(!I&&_e&&n(_e,re)&&(I={enumerable:!0,configurable:!0}),I&&I.configurable){var $=f("on"+re+"patched");if(!Q.hasOwnProperty($)||!Q[$]){delete I.writable,delete I.value;var ne=I.get,me=I.set,Ke=re.slice(2),lt=he[Ke];lt||(lt=he[Ke]=f("ON_PROPERTY"+Ke)),I.set=function(Je){var ft=this;!ft&&Q===g&&(ft=g),ft&&("function"==typeof ft[lt]&&ft.removeEventListener(Ke,w),me&&me.call(ft,null),ft[lt]=Je,"function"==typeof Je&&ft.addEventListener(Ke,w,!1))},I.get=function(){var Je=this;if(!Je&&Q===g&&(Je=g),!Je)return null;var ft=Je[lt];if(ft)return ft;if(ne){var Ct=ne.call(this);if(Ct)return I.set.call(this,Ct),"function"==typeof Je.removeAttribute&&Je.removeAttribute(re),Ct}return null},t(Q,re,I),Q[$]=!0}}}function q(Q,re,_e){if(re)for(var I=0;I<re.length;I++)F(Q,"on"+re[I],_e);else{var X=[];for(var $ in Q)"on"==$.slice(0,2)&&X.push($);for(var ne=0;ne<X.length;ne++)F(Q,X[ne],_e)}}var K=f("originalInstance");function de(Q){var re=g[Q];if(re){g[f(Q)]=re,g[Q]=function(){var X=D(arguments,Q);switch(X.length){case 0:this[K]=new re;break;case 1:this[K]=new re(X[0]);break;case 2:this[K]=new re(X[0],X[1]);break;case 3:this[K]=new re(X[0],X[1],X[2]);break;case 4:this[K]=new re(X[0],X[1],X[2],X[3]);break;default:throw new Error("Arg list too long.")}},le(g[Q],re);var I,_e=new re(function(){});for(I in _e)"XMLHttpRequest"===Q&&"responseBlob"===I||function(X){"function"==typeof _e[X]?g[Q].prototype[X]=function(){return this[K][X].apply(this[K],arguments)}:t(g[Q].prototype,X,{set:function($){"function"==typeof $?(this[K][X]=p($,Q+"."+X),le(this[K][X],$)):this[K][X]=$},get:function(){return this[K][X]}})}(I);for(I in re)"prototype"!==I&&re.hasOwnProperty(I)&&(g[Q][I]=re[I])}}function Y(Q,re,_e){for(var I=Q;I&&!I.hasOwnProperty(re);)I=e(I);!I&&Q[re]&&(I=Q);var X=f(re),$=null;if(I&&(!($=I[X])||!I.hasOwnProperty(X))&&($=I[X]=I[re],k(I&&n(I,re)))){var me=_e($,X,re);I[re]=function(){return me(this,arguments)},le(I[re],$)}return $}function ae(Q,re,_e){var I=null;function X($){var ne=$.data;return ne.args[ne.cbIdx]=function(){$.invoke.apply(this,arguments)},I.apply(ne.target,ne.args),$}I=Y(Q,re,function($){return function(ne,me){var Ke=_e(ne,me);return Ke.cbIdx>=0&&"function"==typeof me[Ke.cbIdx]?h(Ke.name,me[Ke.cbIdx],Ke,X):$.apply(ne,me)}})}function le(Q,re){Q[f("OriginalDelegate")]=re}var Ie=!1,ve=!1;function nt(){if(Ie)return ve;Ie=!0;try{var Q=x.navigator.userAgent;(-1!==Q.indexOf("MSIE ")||-1!==Q.indexOf("Trident/")||-1!==Q.indexOf("Edge/"))&&(ve=!0)}catch{}return ve}Zone.__load_patch("ZoneAwarePromise",function(Q,re,_e){var I=Object.getOwnPropertyDescriptor,X=Object.defineProperty,ne=_e.symbol,me=[],Ke=!0===Q[ne("DISABLE_WRAPPING_UNCAUGHT_PROMISE_REJECTION")],lt=ne("Promise"),Je=ne("then");_e.onUnhandledError=function(ct){if(_e.showUncaughtError()){var Vt=ct&&ct.rejection;Vt?console.error("Unhandled Promise rejection:",Vt instanceof Error?Vt.message:Vt,"; Zone:",ct.zone.name,"; Task:",ct.task&&ct.task.source,"; Value:",Vt,Vt instanceof Error?Vt.stack:void 0):console.error(ct)}},_e.microtaskDrainDone=function(){for(var ct=function(){var Vt=me.shift();try{Vt.zone.runGuarded(function(){throw Vt.throwOriginal?Vt.rejection:Vt})}catch(Dt){!function(ct){_e.onUnhandledError(ct);try{var Vt=re[Ct];"function"==typeof Vt&&Vt.call(this,ct)}catch{}}(Dt)}};me.length;)ct()};var Ct=ne("unhandledPromiseRejectionHandler");function Nt(ct){return ct&&ct.then}function bn(ct){return ct}function rr(ct){return Ee.reject(ct)}var Ai=ne("state"),Mn=ne("value"),Hn=ne("finally"),Ot=ne("parentPromiseValue"),wi=ne("parentPromiseState"),Yn=null,Yt=!1;function An(ct,Vt){return function(Dt){try{Dr(ct,Vt,Dt)}catch(it){Dr(ct,!1,it)}}}var Un=function(){var ct=!1;return function(Dt){return function(){ct||(ct=!0,Dt.apply(null,arguments))}}},jn=ne("currentTaskTrace");function Dr(ct,Vt,Dt){var it=Un();if(ct===Dt)throw new TypeError("Promise resolved with itself");if(ct[Ai]===Yn){var cn=null;try{("object"==typeof Dt||"function"==typeof Dt)&&(cn=Dt&&Dt.then)}catch(mi){return it(function(){Dr(ct,!1,mi)})(),ct}if(Vt!==Yt&&Dt instanceof Ee&&Dt.hasOwnProperty(Ai)&&Dt.hasOwnProperty(Mn)&&Dt[Ai]!==Yn)xa(Dt),Dr(ct,Dt[Ai],Dt[Mn]);else if(Vt!==Yt&&"function"==typeof cn)try{cn.call(Dt,it(An(ct,Vt)),it(An(ct,!1)))}catch(mi){it(function(){Dr(ct,!1,mi)})()}else{ct[Ai]=Vt;var qn=ct[Mn];if(ct[Mn]=Dt,ct[Hn]===Hn&&!0===Vt&&(ct[Ai]=ct[wi],ct[Mn]=ct[Ot]),Vt===Yt&&Dt instanceof Error){var Bn=re.currentTask&&re.currentTask.data&&re.currentTask.data.__creationTrace__;Bn&&X(Dt,jn,{configurable:!0,enumerable:!1,writable:!0,value:Bn})}for(var li=0;li<qn.length;)Vr(ct,qn[li++],qn[li++],qn[li++],qn[li++]);if(0==qn.length&&Vt==Yt){ct[Ai]=0;var ci=Dt;try{throw new Error("Uncaught (in promise): "+function(ct){return ct&&ct.toString===Object.prototype.toString?(ct.constructor&&ct.constructor.name||"")+": "+JSON.stringify(ct):ct?ct.toString():Object.prototype.toString.call(ct)}(Dt)+(Dt&&Dt.stack?"\n"+Dt.stack:""))}catch(mi){ci=mi}Ke&&(ci.throwOriginal=!0),ci.rejection=Dt,ci.promise=ct,ci.zone=re.current,ci.task=re.currentTask,me.push(ci),_e.scheduleMicroTask()}}}return ct}var br=ne("rejectionHandledHandler");function xa(ct){if(0===ct[Ai]){try{var Vt=re[br];Vt&&"function"==typeof Vt&&Vt.call(this,{rejection:ct[Mn],promise:ct})}catch{}ct[Ai]=Yt;for(var Dt=0;Dt<me.length;Dt++)ct===me[Dt].promise&&me.splice(Dt,1)}}function Vr(ct,Vt,Dt,it,cn){xa(ct);var qn=ct[Ai],Bn=qn?"function"==typeof it?it:bn:"function"==typeof cn?cn:rr;Vt.scheduleMicroTask("Promise.then",function(){try{var li=ct[Mn],ci=!!Dt&&Hn===Dt[Hn];ci&&(Dt[Ot]=li,Dt[wi]=qn);var mi=Vt.run(Bn,void 0,ci&&Bn!==rr&&Bn!==bn?[]:[li]);Dr(Dt,!0,mi)}catch(Ii){Dr(Dt,!1,Ii)}},Dt)}var St=function(){},we=Q.AggregateError,Ee=function(){function ct(Vt){var Dt=this;if(!(Dt instanceof ct))throw new Error("Must be an instanceof Promise.");Dt[Ai]=Yn,Dt[Mn]=[];try{var it=Un();Vt&&Vt(it(An(Dt,!0)),it(An(Dt,Yt)))}catch(cn){Dr(Dt,!1,cn)}}return ct.toString=function(){return"function ZoneAwarePromise() { [native code] }"},ct.resolve=function(Vt){return Dr(new this(null),!0,Vt)},ct.reject=function(Vt){return Dr(new this(null),Yt,Vt)},ct.any=function(Vt){if(!Vt||"function"!=typeof Vt[Symbol.iterator])return Promise.reject(new we([],"All promises were rejected"));var Dt=[],it=0;try{for(var cn=0,qn=Vt;cn<qn.length;cn++)it++,Dt.push(ct.resolve(qn[cn]))}catch{return Promise.reject(new we([],"All promises were rejected"))}if(0===it)return Promise.reject(new we([],"All promises were rejected"));var li=!1,ci=[];return new ct(function(mi,Ii){for(var Pr=0;Pr<Dt.length;Pr++)Dt[Pr].then(function(fs){li||(li=!0,mi(fs))},function(fs){ci.push(fs),0==--it&&(li=!0,Ii(new we(ci,"All promises were rejected")))})})},ct.race=function(Vt){var Dt,it,cn=new this(function(Ii,Pr){Dt=Ii,it=Pr});function qn(Ii){Dt(Ii)}function Bn(Ii){it(Ii)}for(var li=0,ci=Vt;li<ci.length;li++){var mi=ci[li];Nt(mi)||(mi=this.resolve(mi)),mi.then(qn,Bn)}return cn},ct.all=function(Vt){return ct.allWithCallback(Vt)},ct.allSettled=function(Vt){return(this&&this.prototype instanceof ct?this:ct).allWithCallback(Vt,{thenCallback:function(it){return{status:"fulfilled",value:it}},errorCallback:function(it){return{status:"rejected",reason:it}}})},ct.allWithCallback=function(Vt,Dt){for(var it,cn,qn=new this(function(So,ts){it=So,cn=ts}),Bn=2,li=0,ci=[],mi=function(So){Nt(So)||(So=Ii.resolve(So));var ts=li;try{So.then(function(po){ci[ts]=Dt?Dt.thenCallback(po):po,0==--Bn&&it(ci)},function(po){Dt?(ci[ts]=Dt.errorCallback(po),0==--Bn&&it(ci)):cn(po)})}catch(po){cn(po)}Bn++,li++},Ii=this,Pr=0,fs=Vt;Pr<fs.length;Pr++)mi(fs[Pr]);return 0==(Bn-=2)&&it(ci),qn},Object.defineProperty(ct.prototype,Symbol.toStringTag,{get:function(){return"Promise"},enumerable:!1,configurable:!0}),Object.defineProperty(ct.prototype,Symbol.species,{get:function(){return ct},enumerable:!1,configurable:!0}),ct.prototype.then=function(Vt,Dt){var it,cn=null===(it=this.constructor)||void 0===it?void 0:it[Symbol.species];(!cn||"function"!=typeof cn)&&(cn=this.constructor||ct);var qn=new cn(St),Bn=re.current;return this[Ai]==Yn?this[Mn].push(Bn,qn,Vt,Dt):Vr(this,Bn,qn,Vt,Dt),qn},ct.prototype.catch=function(Vt){return this.then(null,Vt)},ct.prototype.finally=function(Vt){var Dt,it=null===(Dt=this.constructor)||void 0===Dt?void 0:Dt[Symbol.species];(!it||"function"!=typeof it)&&(it=ct);var cn=new it(St);cn[Hn]=Hn;var qn=re.current;return this[Ai]==Yn?this[Mn].push(qn,cn,Vt,Vt):Vr(this,qn,cn,Vt,Vt),cn},ct}();Ee.resolve=Ee.resolve,Ee.reject=Ee.reject,Ee.race=Ee.race,Ee.all=Ee.all;var Ve=Q[lt]=Q.Promise;Q.Promise=Ee;var kn=ne("thenPatched");function Ir(ct){var Vt=ct.prototype,Dt=I(Vt,"then");if(!Dt||!1!==Dt.writable&&Dt.configurable){var it=Vt.then;Vt[Je]=it,ct.prototype.then=function(cn,qn){var Bn=this;return new Ee(function(ci,mi){it.call(Bn,ci,mi)}).then(cn,qn)},ct[kn]=!0}}return _e.patchThen=Ir,Ve&&(Ir(Ve),Y(Q,"fetch",function(ct){return function(ct){return function(Vt,Dt){var it=ct.apply(Vt,Dt);if(it instanceof Ee)return it;var cn=it.constructor;return cn[kn]||Ir(cn),it}}(ct)})),Promise[re.__symbol__("uncaughtPromiseErrors")]=me,Ee}),Zone.__load_patch("toString",function(Q){var re=Function.prototype.toString,_e=f("OriginalDelegate"),I=f("Promise"),X=f("Error"),$=function(){if("function"==typeof this){var lt=this[_e];if(lt)return"function"==typeof lt?re.call(lt):Object.prototype.toString.call(lt);if(this===Promise){var Je=Q[I];if(Je)return re.call(Je)}if(this===Error){var ft=Q[X];if(ft)return re.call(ft)}}return re.call(this)};$[_e]=re,Function.prototype.toString=$;var ne=Object.prototype.toString;Object.prototype.toString=function(){return"function"==typeof Promise&&this instanceof Promise?"[object Promise]":ne.call(this)}});var gt=!1;if(typeof window<"u")try{var Ue=Object.defineProperty({},"passive",{get:function(){gt=!0}});window.addEventListener("test",Ue,Ue),window.removeEventListener("test",Ue,Ue)}catch{gt=!1}var fi,Wi,qi,ee,W,Ae={useG:!0},tn={},pt={},wt=new RegExp("^"+d+"(\\w+)(true|false)$"),Te=f("propagationStopped");function xt(Q,re){var _e=(re?re(Q):Q)+u,I=(re?re(Q):Q)+c,X=d+_e,$=d+I;tn[Q]={},tn[Q][u]=X,tn[Q][c]=$}function mt(Q,re,_e,I){var X=I&&I.add||o,$=I&&I.rm||s,ne=I&&I.listeners||"eventListeners",me=I&&I.rmAll||"removeAllListeners",Ke=f(X),lt="."+X+":",Ct=function(Hn,Ot,wi){if(!Hn.isRemoved){var Yn,ai=Hn.callback;"object"==typeof ai&&ai.handleEvent&&(Hn.callback=function(Yi){return ai.handleEvent(Yi)},Hn.originalDelegate=ai);try{Hn.invoke(Hn,Ot,[wi])}catch(Yi){Yn=Yi}var $n=Hn.options;return $n&&"object"==typeof $n&&$n.once&&Ot[$].call(Ot,wi.type,Hn.originalDelegate?Hn.originalDelegate:Hn.callback,$n),Yn}};function It(Hn,Ot,wi){if(Ot=Ot||Q.event){var ai=Hn||Ot.target||Q,Yn=ai[tn[Ot.type][wi?c:u]];if(Yn){var $n=[];if(1===Yn.length)(Yt=Ct(Yn[0],ai,Ot))&&$n.push(Yt);else for(var Yi=Yn.slice(),An=0;An<Yi.length&&(!Ot||!0!==Ot[Te]);An++){var Yt;(Yt=Ct(Yi[An],ai,Ot))&&$n.push(Yt)}if(1===$n.length)throw $n[0];var Un=function(Si){var jn=$n[Si];re.nativeScheduleMicroTask(function(){throw jn})};for(An=0;An<$n.length;An++)Un(An)}}}var Nt=function(Hn){return It(this,Hn,!1)},bn=function(Hn){return It(this,Hn,!0)};function rr(Hn,Ot){if(!Hn)return!1;var wi=!0;Ot&&void 0!==Ot.useG&&(wi=Ot.useG);var ai=Ot&&Ot.vh,Yn=!0;Ot&&void 0!==Ot.chkDup&&(Yn=Ot.chkDup);var $n=!1;Ot&&void 0!==Ot.rt&&($n=Ot.rt);for(var Yt=Hn;Yt&&!Yt.hasOwnProperty(X);)Yt=e(Yt);if(!Yt&&Hn[X]&&(Yt=Hn),!Yt||Yt[Ke])return!1;var br,Yi=Ot&&Ot.eventNameToString,An={},Un=Yt[Ke]=Yt[X],Si=Yt[f($)]=Yt[$],jn=Yt[f(ne)]=Yt[ne],Dr=Yt[f(me)]=Yt[me];function xa(it,cn){return!gt&&"object"==typeof it&&it?!!it.capture:gt&&cn?"boolean"==typeof it?{capture:it,passive:!0}:it?"object"==typeof it&&!1!==it.passive?Object.assign(Object.assign({},it),{passive:!0}):it:{passive:!0}:it}Ot&&Ot.prepend&&(br=Yt[f(Ot.prepend)]=Yt[Ot.prepend]);var Ve=wi?function(it){if(!An.isExisting)return Un.call(An.target,An.eventName,An.capture?bn:Nt,An.options)}:function(it){return Un.call(An.target,An.eventName,it.invoke,An.options)},kn=wi?function(it){if(!it.isRemoved){var cn=tn[it.eventName],qn=void 0;cn&&(qn=cn[it.capture?c:u]);var Bn=qn&&it.target[qn];if(Bn)for(var li=0;li<Bn.length;li++)if(Bn[li]===it){Bn.splice(li,1),it.isRemoved=!0,0===Bn.length&&(it.allRemoved=!0,it.target[qn]=null);break}}if(it.allRemoved)return Si.call(it.target,it.eventName,it.capture?bn:Nt,it.options)}:function(it){return Si.call(it.target,it.eventName,it.invoke,it.options)},xc=Ot&&Ot.diff?Ot.diff:function(it,cn){var qn=typeof cn;return"function"===qn&&it.callback===cn||"object"===qn&&it.originalDelegate===cn},ct=Zone[f("UNPATCHED_EVENTS")],Vt=Q[f("PASSIVE_EVENTS")],Dt=function(it,cn,qn,Bn,li,ci){return void 0===li&&(li=!1),void 0===ci&&(ci=!1),function(){var mi=this||Q,Ii=arguments[0];Ot&&Ot.transferEventName&&(Ii=Ot.transferEventName(Ii));var Pr=arguments[1];if(!Pr)return it.apply(this,arguments);if(z&&"uncaughtException"===Ii)return it.apply(this,arguments);var fs=!1;if("function"!=typeof Pr){if(!Pr.handleEvent)return it.apply(this,arguments);fs=!0}if(!ai||ai(it,Pr,mi,arguments)){var Pd=gt&&!!Vt&&-1!==Vt.indexOf(Ii),So=xa(arguments[2],Pd);if(ct)for(var ts=0;ts<ct.length;ts++)if(Ii===ct[ts])return Pd?it.call(mi,Ii,Pr,So):it.apply(this,arguments);var po=!!So&&("boolean"==typeof So||So.capture),a0=!(!So||"object"!=typeof So)&&So.once,Zge=Zone.current,rN=tn[Ii];rN||(xt(Ii,Yi),rN=tn[Ii]);var E6=rN[po?c:u],l0=mi[E6],T6=!1;if(l0){if(T6=!0,Yn)for(ts=0;ts<l0.length;ts++)if(xc(l0[ts],Pr))return}else l0=mi[E6]=[];var NE,D6=mi.constructor.name,A6=pt[D6];A6&&(NE=A6[Ii]),NE||(NE=D6+cn+(Yi?Yi(Ii):Ii)),An.options=So,a0&&(An.options.once=!1),An.target=mi,An.capture=po,An.eventName=Ii,An.isExisting=T6;var tx=wi?Ae:void 0;tx&&(tx.taskData=An);var Np=Zge.scheduleEventTask(NE,Pr,tx,qn,Bn);if(An.target=null,tx&&(tx.taskData=null),a0&&(So.once=!0),!gt&&"boolean"==typeof Np.options||(Np.options=So),Np.target=mi,Np.capture=po,Np.eventName=Ii,fs&&(Np.originalDelegate=Pr),ci?l0.unshift(Np):l0.push(Np),li)return mi}}};return Yt[X]=Dt(Un,lt,Ve,kn,$n),br&&(Yt.prependListener=Dt(br,".prependListener:",function(it){return br.call(An.target,An.eventName,it.invoke,An.options)},kn,$n,!0)),Yt[$]=function(){var it=this||Q,cn=arguments[0];Ot&&Ot.transferEventName&&(cn=Ot.transferEventName(cn));var qn=arguments[2],Bn=!!qn&&("boolean"==typeof qn||qn.capture),li=arguments[1];if(!li)return Si.apply(this,arguments);if(!ai||ai(Si,li,it,arguments)){var mi,ci=tn[cn];ci&&(mi=ci[Bn?c:u]);var Ii=mi&&it[mi];if(Ii)for(var Pr=0;Pr<Ii.length;Pr++){var fs=Ii[Pr];if(xc(fs,li)){if(Ii.splice(Pr,1),fs.isRemoved=!0,0===Ii.length&&(fs.allRemoved=!0,it[mi]=null,"string"==typeof cn)){var Pd=d+"ON_PROPERTY"+cn;it[Pd]=null}return fs.zone.cancelTask(fs),$n?it:void 0}}return Si.apply(this,arguments)}},Yt[ne]=function(){var it=this||Q,cn=arguments[0];Ot&&Ot.transferEventName&&(cn=Ot.transferEventName(cn));for(var qn=[],Bn=ce(it,Yi?Yi(cn):cn),li=0;li<Bn.length;li++){var ci=Bn[li],mi=ci.originalDelegate?ci.originalDelegate:ci.callback;qn.push(mi)}return qn},Yt[me]=function(){var it=this||Q,cn=arguments[0];if(cn){Ot&&Ot.transferEventName&&(cn=Ot.transferEventName(cn));var Ii=tn[cn];if(Ii){var Pr=Ii[u],fs=Ii[c],Pd=it[Pr],So=it[fs];if(Pd)for(var ts=Pd.slice(),Bn=0;Bn<ts.length;Bn++)this[$].call(this,cn,(po=ts[Bn]).originalDelegate?po.originalDelegate:po.callback,po.options);if(So)for(ts=So.slice(),Bn=0;Bn<ts.length;Bn++){var po;this[$].call(this,cn,(po=ts[Bn]).originalDelegate?po.originalDelegate:po.callback,po.options)}}}else{var qn=Object.keys(it);for(Bn=0;Bn<qn.length;Bn++){var li=qn[Bn],ci=wt.exec(li),mi=ci&&ci[1];mi&&"removeListener"!==mi&&this[me].call(this,mi)}this[me].call(this,"removeListener")}if($n)return this},le(Yt[X],Un),le(Yt[$],Si),Dr&&le(Yt[me],Dr),jn&&le(Yt[ne],jn),!0}for(var Ai=[],Mn=0;Mn<_e.length;Mn++)Ai[Mn]=rr(_e[Mn],I);return Ai}function ce(Q,re){if(!re){var _e=[];for(var I in Q){var X=wt.exec(I),$=X&&X[1];if($&&(!re||$===re)){var ne=Q[I];if(ne)for(var me=0;me<ne.length;me++)_e.push(ne[me])}}return _e}var Ke=tn[re];Ke||(xt(re),Ke=tn[re]);var lt=Q[Ke[u]],Je=Q[Ke[c]];return lt?Je?lt.concat(Je):lt.slice():Je?Je.slice():[]}function dt(Q,re){var _e=Q.Event;_e&&_e.prototype&&re.patchMethod(_e.prototype,"stopImmediatePropagation",function(I){return function(X,$){X[Te]=!0,I&&I.apply(X,$)}})}function We(Q,re,_e,I,X){var $=Zone.__symbol__(I);if(!re[$]){var ne=re[$]=re[I];re[I]=function(me,Ke,lt){return Ke&&Ke.prototype&&X.forEach(function(Je){var ft="".concat(_e,".").concat(I,"::")+Je,Ct=Ke.prototype;try{if(Ct.hasOwnProperty(Je)){var It=Q.ObjectGetOwnPropertyDescriptor(Ct,Je);It&&It.value?(It.value=Q.wrapWithCurrentZone(It.value,ft),Q._redefineProperty(Ke.prototype,Je,It)):Ct[Je]&&(Ct[Je]=Q.wrapWithCurrentZone(Ct[Je],ft))}else Ct[Je]&&(Ct[Je]=Q.wrapWithCurrentZone(Ct[Je],ft))}catch{}}),ne.call(re,me,Ke,lt)},Q.attachOriginToPatched(re[I],ne)}}function Mt(Q,re,_e){if(!_e||0===_e.length)return re;var I=_e.filter(function($){return $.target===Q});if(!I||0===I.length)return re;var X=I[0].ignoreProperties;return re.filter(function($){return-1===X.indexOf($)})}function bt(Q,re,_e,I){Q&&q(Q,Mt(Q,re,_e),I)}function hn(Q){return Object.getOwnPropertyNames(Q).filter(function(re){return re.startsWith("on")&&re.length>2}).map(function(re){return re.substring(2)})}function Tt(Q,re,_e){var I=_e.configurable;return wn(Q,re,_e=qe(Q,re,_e),I)}function mn(Q,re){return Q&&Q[W]&&Q[W][re]}function qe(Q,re,_e){return Object.isFrozen(_e)||(_e.configurable=!0),_e.configurable||(!Q[W]&&!Object.isFrozen(Q)&&Wi(Q,W,{writable:!0,value:{}}),Q[W]&&(Q[W][re]=!0)),_e}function wn(Q,re,_e,I){try{return Wi(Q,re,_e)}catch(ne){if(!_e.configurable)throw ne;typeof I>"u"?delete _e.configurable:_e.configurable=I;try{return Wi(Q,re,_e)}catch(me){var X=!1;if(("createdCallback"===re||"attachedCallback"===re||"detachedCallback"===re||"attributeChangedCallback"===re)&&(X=!0),!X)throw me;var $=null;try{$=JSON.stringify(_e)}catch{$=_e.toString()}console.log("Attempting to configure '".concat(re,"' with descriptor '").concat($,"' on object '").concat(Q,"' and got error, giving up: ").concat(me))}}}Zone.__load_patch("util",function(Q,re,_e){var I=hn(Q);_e.patchOnProperties=q,_e.patchMethod=Y,_e.bindArguments=D,_e.patchMacroTask=ae;var X=re.__symbol__("BLACK_LISTED_EVENTS"),$=re.__symbol__("UNPATCHED_EVENTS");Q[$]&&(Q[X]=Q[$]),Q[X]&&(re[X]=re[$]=Q[X]),_e.patchEventPrototype=dt,_e.patchEventTarget=mt,_e.isIEOrEdge=nt,_e.ObjectDefineProperty=t,_e.ObjectGetOwnPropertyDescriptor=n,_e.ObjectCreate=i,_e.ArraySlice=r,_e.patchClass=de,_e.wrapWithCurrentZone=p,_e.filterProperties=Mt,_e.attachOriginToPatched=le,_e._redefineProperty=Object.defineProperty,_e.patchCallbacks=We,_e.getGlobalObjects=function(){return{globalSources:pt,zoneSymbolEventNames:tn,eventNames:I,isBrowser:fe,isMix:ue,isNode:z,TRUE_STR:c,FALSE_STR:u,ZONE_SYMBOL_PREFIX:d,ADD_EVENT_LISTENER_STR:o,REMOVE_EVENT_LISTENER_STR:s}}});var Q,Es=uh(uh(uh(uh(uh(uh(uh(uh([],["abort","animationcancel","animationend","animationiteration","auxclick","beforeinput","blur","cancel","canplay","canplaythrough","change","compositionstart","compositionupdate","compositionend","cuechange","click","close","contextmenu","curechange","dblclick","drag","dragend","dragenter","dragexit","dragleave","dragover","drop","durationchange","emptied","ended","error","focus","focusin","focusout","gotpointercapture","input","invalid","keydown","keypress","keyup","load","loadstart","loadeddata","loadedmetadata","lostpointercapture","mousedown","mouseenter","mouseleave","mousemove","mouseout","mouseover","mouseup","mousewheel","orientationchange","pause","play","playing","pointercancel","pointerdown","pointerenter","pointerleave","pointerlockchange","mozpointerlockchange","webkitpointerlockerchange","pointerlockerror","mozpointerlockerror","webkitpointerlockerror","pointermove","pointout","pointerover","pointerup","progress","ratechange","reset","resize","scroll","seeked","seeking","select","selectionchange","selectstart","show","sort","stalled","submit","suspend","timeupdate","volumechange","touchcancel","touchmove","touchstart","touchend","transitioncancel","transitionend","waiting","wheel"],!0),["webglcontextrestored","webglcontextlost","webglcontextcreationerror"],!0),["autocomplete","autocompleteerror"],!0),["toggle"],!0),["afterscriptexecute","beforescriptexecute","DOMContentLoaded","freeze","fullscreenchange","mozfullscreenchange","webkitfullscreenchange","msfullscreenchange","fullscreenerror","mozfullscreenerror","webkitfullscreenerror","msfullscreenerror","readystatechange","visibilitychange","resume"],!0),["absolutedeviceorientation","afterinput","afterprint","appinstalled","beforeinstallprompt","beforeprint","beforeunload","devicelight","devicemotion","deviceorientation","deviceorientationabsolute","deviceproximity","hashchange","languagechange","message","mozbeforepaint","offline","online","paint","pageshow","pagehide","popstate","rejectionhandled","storage","unhandledrejection","unload","userproximity","vrdisplayconnected","vrdisplaydisconnected","vrdisplaypresentchange"],!0),["beforecopy","beforecut","beforepaste","copy","cut","paste","dragstart","loadend","animationstart","search","transitionrun","transitionstart","webkitanimationend","webkitanimationiteration","webkitanimationstart","webkittransitionend"],!0),["activate","afterupdate","ariarequest","beforeactivate","beforedeactivate","beforeeditfocus","beforeupdate","cellchange","controlselect","dataavailable","datasetchanged","datasetcomplete","errorupdate","filterchange","layoutcomplete","losecapture","move","moveend","movestart","propertychange","resizeend","resizestart","rowenter","rowexit","rowsdelete","rowsinserted","command","compassneedscalibration","deactivate","help","mscontentzoom","msmanipulationstatechanged","msgesturechange","msgesturedoubletap","msgestureend","msgesturehold","msgesturestart","msgesturetap","msgotpointercapture","msinertiastart","mslostpointercapture","mspointercancel","mspointerdown","mspointerenter","mspointerhover","mspointerleave","mspointermove","mspointerout","mspointerover","mspointerup","pointerout","mssitemodejumplistitemremoved","msthumbnailclick","stop","storagecommit"],!0);(Q=typeof window<"u"?window:typeof global<"u"?global:typeof self<"u"?self:{})[("legacyPatch",(Q.__Zone_symbol_prefix||"__zone_symbol__")+"legacyPatch")]=function(){var I=Q.Zone;I.__load_patch("defineProperty",function(X,$,ne){ne._redefineProperty=Tt,fi=Zone.__symbol__,Wi=Object[fi("defineProperty")]=Object.defineProperty,qi=Object[fi("getOwnPropertyDescriptor")]=Object.getOwnPropertyDescriptor,ee=Object.create,W=fi("unconfigurables"),Object.defineProperty=function(Q,re,_e){if(mn(Q,re))throw new TypeError("Cannot assign to read only property '"+re+"' of "+Q);var I=_e.configurable;return"prototype"!==re&&(_e=qe(Q,re,_e)),wn(Q,re,_e,I)},Object.defineProperties=function(Q,re){Object.keys(re).forEach(function(ne){Object.defineProperty(Q,ne,re[ne])});for(var _e=0,I=Object.getOwnPropertySymbols(re);_e<I.length;_e++){var X=I[_e];Object.getOwnPropertyDescriptor(re,X)?.enumerable&&Object.defineProperty(Q,X,re[X])}return Q},Object.create=function(Q,re){return"object"==typeof re&&!Object.isFrozen(re)&&Object.keys(re).forEach(function(_e){re[_e]=qe(Q,_e,re[_e])}),ee(Q,re)},Object.getOwnPropertyDescriptor=function(Q,re){var _e=qi(Q,re);return _e&&mn(Q,re)&&(_e.configurable=!1),_e}}),I.__load_patch("registerElement",function(X,$,ne){!function(Q,re){var _e=re.getGlobalObjects();(_e.isBrowser||_e.isMix)&&"registerElement"in Q.document&&re.patchCallbacks(re,document,"Document","registerElement",["createdCallback","attachedCallback","detachedCallback","attributeChangedCallback"])}(X,ne)}),I.__load_patch("EventTargetLegacy",function(X,$,ne){(function(Q,re){var _e=re.getGlobalObjects(),I=_e.eventNames,X=_e.globalSources,$=_e.zoneSymbolEventNames,ne=_e.TRUE_STR,me=_e.FALSE_STR,Ke=_e.ZONE_SYMBOL_PREFIX,Je="ApplicationCache,EventSource,FileReader,InputMethodContext,MediaController,MessagePort,Node,Performance,SVGElementInstance,SharedWorker,TextTrack,TextTrackCue,TextTrackList,WebKitNamedFlow,Window,Worker,WorkerGlobalScope,XMLHttpRequest,XMLHttpRequestEventTarget,XMLHttpRequestUpload,IDBRequest,IDBOpenDBRequest,IDBDatabase,IDBTransaction,IDBCursor,DBIndex,WebSocket".split(","),ft="EventTarget",Ct=[],It=Q.wtf,Nt="Anchor,Area,Audio,BR,Base,BaseFont,Body,Button,Canvas,Content,DList,Directory,Div,Embed,FieldSet,Font,Form,Frame,FrameSet,HR,Head,Heading,Html,IFrame,Image,Input,Keygen,LI,Label,Legend,Link,Map,Marquee,Media,Menu,Meta,Meter,Mod,OList,Object,OptGroup,Option,Output,Paragraph,Pre,Progress,Quote,Script,Select,Source,Span,Style,TableCaption,TableCell,TableCol,Table,TableRow,TableSection,TextArea,Title,Track,UList,Unknown,Video".split(",");It?Ct=Nt.map(function(Vr){return"HTML"+Vr+"Element"}).concat(Je):Q[ft]?Ct.push(ft):Ct=Je;for(var bn=Q.__Zone_disable_IE_check||!1,rr=Q.__Zone_enable_cross_context_check||!1,Ai=re.isIEOrEdge(),Hn="[object FunctionWrapper]",Ot="function __BROWSERTOOLS_CONSOLE_SAFEFUNC() { [native code] }",wi={MSPointerCancel:"pointercancel",MSPointerDown:"pointerdown",MSPointerEnter:"pointerenter",MSPointerHover:"pointerhover",MSPointerLeave:"pointerleave",MSPointerMove:"pointermove",MSPointerOut:"pointerout",MSPointerOver:"pointerover",MSPointerUp:"pointerup"},ai=0;ai<I.length;ai++){var Yi=Ke+((Yn=I[ai])+me),An=Ke+(Yn+ne);$[Yn]={},$[Yn][me]=Yi,$[Yn][ne]=An}for(ai=0;ai<Nt.length;ai++)for(var Un=Nt[ai],Si=X[Un]={},jn=0;jn<I.length;jn++){var Yn;Si[Yn=I[jn]]=Un+".addEventListener:"+Yn}var br=[];for(ai=0;ai<Ct.length;ai++){var xa=Q[Ct[ai]];br.push(xa&&xa.prototype)}re.patchEventTarget(Q,re,br,{vh:function(Vr,Ar,St,we){if(!bn&&Ai)if(rr)try{if((Ee=Ar.toString())===Hn||Ee==Ot)return Vr.apply(St,we),!1}catch{return Vr.apply(St,we),!1}else{var Ee;if((Ee=Ar.toString())===Hn||Ee==Ot)return Vr.apply(St,we),!1}else if(rr)try{Ar.toString()}catch{return Vr.apply(St,we),!1}return!0},transferEventName:function(Vr){return wi[Vr]||Vr}}),Zone[re.symbol("patchEventTarget")]=!!Q[ft]})(X,ne),function(Q,re){var _e=Q.getGlobalObjects();if((!_e.isNode||_e.isMix)&&!function(Q,re){var _e=Q.getGlobalObjects();if((_e.isBrowser||_e.isMix)&&!Q.ObjectGetOwnPropertyDescriptor(HTMLElement.prototype,"onclick")&&typeof Element<"u"){var $=Q.ObjectGetOwnPropertyDescriptor(Element.prototype,"onclick");if($&&!$.configurable)return!1;if($){Q.ObjectDefineProperty(Element.prototype,"onclick",{enumerable:!0,configurable:!0,get:function(){return!0}});var me=!!document.createElement("div").onclick;return Q.ObjectDefineProperty(Element.prototype,"onclick",$),me}}var Ke=re.XMLHttpRequest;if(!Ke)return!1;var lt="onreadystatechange",Je=Ke.prototype,ft=Q.ObjectGetOwnPropertyDescriptor(Je,lt);if(ft)return Q.ObjectDefineProperty(Je,lt,{enumerable:!0,configurable:!0,get:function(){return!0}}),me=!!(Ct=new Ke).onreadystatechange,Q.ObjectDefineProperty(Je,lt,ft||{}),me;var It=Q.symbol("fake");Q.ObjectDefineProperty(Je,lt,{enumerable:!0,configurable:!0,get:function(){return this[It]},set:function(Ai){this[It]=Ai}});var Ct,Nt=function(){};return(Ct=new Ke).onreadystatechange=Nt,me=Ct[It]===Nt,Ct.onreadystatechange=null,me}(Q,re)){var $=typeof WebSocket<"u";(function(Q){for(var re=Q.symbol("unbound"),_e=function(X){var $=Es[X],ne="on"+$;self.addEventListener($,function(me){var lt,Je,Ke=me.target;for(Je=Ke?Ke.constructor.name+"."+ne:"unknown."+ne;Ke;)Ke[ne]&&!Ke[ne][re]&&((lt=Q.wrapWithCurrentZone(Ke[ne],Je))[re]=Ke[ne],Ke[ne]=lt),Ke=Ke.parentElement},!0)},I=0;I<Es.length;I++)_e(I)})(Q),Q.patchClass("XMLHttpRequest"),$&&function(Q,re){var _e=Q.getGlobalObjects(),I=_e.ADD_EVENT_LISTENER_STR,X=_e.REMOVE_EVENT_LISTENER_STR,$=re.WebSocket;re.EventTarget||Q.patchEventTarget(re,Q,[$.prototype]),re.WebSocket=function(Ke,lt){var ft,Ct,Je=arguments.length>1?new $(Ke,lt):new $(Ke),It=Q.ObjectGetOwnPropertyDescriptor(Je,"onmessage");return It&&!1===It.configurable?(ft=Q.ObjectCreate(Je),Ct=Je,[I,X,"send","close"].forEach(function(Nt){ft[Nt]=function(){var bn=Q.ArraySlice.call(arguments);if(Nt===I||Nt===X){var rr=bn.length>0?bn[0]:void 0;if(rr){var Ai=Zone.__symbol__("ON_PROPERTY"+rr);Je[Ai]=ft[Ai]}}return Je[Nt].apply(Je,bn)}})):ft=Je,Q.patchOnProperties(ft,["close","error","message","open"],Ct),ft};var ne=re.WebSocket;for(var me in $)ne[me]=$[me]}(Q,re),Zone[Q.symbol("patchEvents")]=!0}}(ne,X)})};var ba=f("zoneTask");function bc(Q,re,_e,I){var X=null,$=null;_e+=I;var ne={};function me(lt){var Je=lt.data;return Je.args[0]=function(){return lt.invoke.apply(this,arguments)},Je.handleId=X.apply(Q,Je.args),lt}function Ke(lt){return $.call(Q,lt.data.handleId)}X=Y(Q,re+=I,function(lt){return function(Je,ft){if("function"==typeof ft[0]){var Ct={isPeriodic:"Interval"===I,delay:"Timeout"===I||"Interval"===I?ft[1]||0:void 0,args:ft},It=ft[0];ft[0]=function(){try{return It.apply(this,arguments)}finally{Ct.isPeriodic||("number"==typeof Ct.handleId?delete ne[Ct.handleId]:Ct.handleId&&(Ct.handleId[ba]=null))}};var Nt=h(re,ft[0],Ct,me,Ke);if(!Nt)return Nt;var bn=Nt.data.handleId;return"number"==typeof bn?ne[bn]=Nt:bn&&(bn[ba]=Nt),bn&&bn.ref&&bn.unref&&"function"==typeof bn.ref&&"function"==typeof bn.unref&&(Nt.ref=bn.ref.bind(bn),Nt.unref=bn.unref.bind(bn)),"number"==typeof bn||bn?bn:Nt}return lt.apply(Q,ft)}}),$=Y(Q,_e,function(lt){return function(Je,ft){var It,Ct=ft[0];"number"==typeof Ct?It=ne[Ct]:(It=Ct&&Ct[ba])||(It=Ct),It&&"string"==typeof It.type?"notScheduled"!==It.state&&(It.cancelFn&&It.data.isPeriodic||0===It.runCount)&&("number"==typeof Ct?delete ne[Ct]:Ct&&(Ct[ba]=null),It.zone.cancelTask(It)):lt.apply(Q,ft)}})}Zone.__load_patch("legacy",function(Q){var re=Q[Zone.__symbol__("legacyPatch")];re&&re()}),Zone.__load_patch("queueMicrotask",function(Q,re,_e){_e.patchMethod(Q,"queueMicrotask",function(I){return function(X,$){re.current.scheduleMicroTask("queueMicrotask",$[0])}})}),Zone.__load_patch("timers",function(Q){var _e="clear";bc(Q,"set",_e,"Timeout"),bc(Q,"set",_e,"Interval"),bc(Q,"set",_e,"Immediate")}),Zone.__load_patch("requestAnimationFrame",function(Q){bc(Q,"request","cancel","AnimationFrame"),bc(Q,"mozRequest","mozCancel","AnimationFrame"),bc(Q,"webkitRequest","webkitCancel","AnimationFrame")}),Zone.__load_patch("blocking",function(Q,re){for(var _e=["alert","prompt","confirm"],I=0;I<_e.length;I++)Y(Q,_e[I],function($,ne,me){return function(Ke,lt){return re.current.run($,Q,lt,me)}})}),Zone.__load_patch("EventTarget",function(Q,re,_e){(function(Q,re){re.patchEventPrototype(Q,re)})(Q,_e),function(Q,re){if(!Zone[re.symbol("patchEventTarget")]){for(var _e=re.getGlobalObjects(),I=_e.eventNames,X=_e.zoneSymbolEventNames,$=_e.TRUE_STR,ne=_e.FALSE_STR,me=_e.ZONE_SYMBOL_PREFIX,Ke=0;Ke<I.length;Ke++){var lt=I[Ke],Ct=me+(lt+ne),It=me+(lt+$);X[lt]={},X[lt][ne]=Ct,X[lt][$]=It}var Nt=Q.EventTarget;Nt&&Nt.prototype&&re.patchEventTarget(Q,re,[Nt&&Nt.prototype])}}(Q,_e);var I=Q.XMLHttpRequestEventTarget;I&&I.prototype&&_e.patchEventTarget(Q,_e,[I.prototype])}),Zone.__load_patch("MutationObserver",function(Q,re,_e){de("MutationObserver"),de("WebKitMutationObserver")}),Zone.__load_patch("IntersectionObserver",function(Q,re,_e){de("IntersectionObserver")}),Zone.__load_patch("FileReader",function(Q,re,_e){de("FileReader")}),Zone.__load_patch("on_property",function(Q,re,_e){!function(Q,re){if((!z||ue)&&!Zone[Q.symbol("patchEvents")]){var _e=re.__Zone_ignore_on_properties,I=[];if(fe){var X=window;I=I.concat(["Document","SVGElement","Element","HTMLElement","HTMLBodyElement","HTMLMediaElement","HTMLFrameSetElement","HTMLFrameElement","HTMLIFrameElement","HTMLMarqueeElement","Worker"]);var $=function(){try{var Q=x.navigator.userAgent;if(-1!==Q.indexOf("MSIE ")||-1!==Q.indexOf("Trident/"))return!0}catch{}return!1}()?[{target:X,ignoreProperties:["error"]}]:[];bt(X,hn(X),_e&&_e.concat($),e(X))}I=I.concat(["XMLHttpRequest","XMLHttpRequestEventTarget","IDBIndex","IDBRequest","IDBOpenDBRequest","IDBDatabase","IDBTransaction","IDBCursor","WebSocket"]);for(var ne=0;ne<I.length;ne++){var me=re[I[ne]];me&&me.prototype&&bt(me.prototype,hn(me.prototype),_e)}}}(_e,Q)}),Zone.__load_patch("customElements",function(Q,re,_e){!function(Q,re){var _e=re.getGlobalObjects();(_e.isBrowser||_e.isMix)&&Q.customElements&&"customElements"in Q&&re.patchCallbacks(re,Q.customElements,"customElements","define",["connectedCallback","disconnectedCallback","adoptedCallback","attributeChangedCallback"])}(Q,_e)}),Zone.__load_patch("XHR",function(Q,re){!function(lt){var Je=lt.XMLHttpRequest;if(Je){var ft=Je.prototype,It=ft[a],Nt=ft[l];if(!It){var bn=lt.XMLHttpRequestEventTarget;if(bn){var rr=bn.prototype;It=rr[a],Nt=rr[l]}}var Ai="readystatechange",Mn="scheduled",ai=Y(ft,"open",function(){return function(Un,Si){return Un[I]=0==Si[2],Un[ne]=Si[1],ai.apply(Un,Si)}}),$n=f("fetchTaskAborting"),Yt=f("fetchTaskScheduling"),Yi=Y(ft,"send",function(){return function(Un,Si){if(!0===re.current[Yt]||Un[I])return Yi.apply(Un,Si);var jn={target:Un,url:Un[ne],isPeriodic:!1,args:Si,aborted:!1},Dr=h("XMLHttpRequest.send",Ot,jn,Hn,wi);Un&&!0===Un[me]&&!jn.aborted&&Dr.state===Mn&&Dr.invoke()}}),An=Y(ft,"abort",function(){return function(Un,Si){var jn=function(Un){return Un[_e]}(Un);if(jn&&"string"==typeof jn.type){if(null==jn.cancelFn||jn.data&&jn.data.aborted)return;jn.zone.cancelTask(jn)}else if(!0===re.current[$n])return An.apply(Un,Si)}})}function Hn(Un){var Si=Un.data,jn=Si.target;jn[$]=!1,jn[me]=!1;var Dr=jn[X];It||(It=jn[a],Nt=jn[l]),Dr&&Nt.call(jn,Ai,Dr);var br=jn[X]=function(){if(jn.readyState===jn.DONE)if(!Si.aborted&&jn[$]&&Un.state===Mn){var Vr=jn[re.__symbol__("loadfalse")];if(0!==jn.status&&Vr&&Vr.length>0){var Ar=Un.invoke;Un.invoke=function(){for(var St=jn[re.__symbol__("loadfalse")],we=0;we<St.length;we++)St[we]===Un&&St.splice(we,1);!Si.aborted&&Un.state===Mn&&Ar.call(Un)},Vr.push(Un)}else Un.invoke()}else!Si.aborted&&!1===jn[$]&&(jn[me]=!0)};return It.call(jn,Ai,br),jn[_e]||(jn[_e]=Un),Yi.apply(jn,Si.args),jn[$]=!0,Un}function Ot(){}function wi(Un){var Si=Un.data;return Si.aborted=!0,An.apply(Si.target,Si.args)}}(Q);var _e=f("xhrTask"),I=f("xhrSync"),X=f("xhrListener"),$=f("xhrScheduled"),ne=f("xhrURL"),me=f("xhrErrorBeforeScheduled")}),Zone.__load_patch("geolocation",function(Q){Q.navigator&&Q.navigator.geolocation&&function(Q,re){for(var _e=Q.constructor.name,I=function($){var lt,Je,ne=re[$],me=Q[ne];if(me){if(!k(n(Q,ne)))return"continue";Q[ne]=(Je=function(){return lt.apply(this,D(arguments,_e+"."+ne))},le(Je,lt=me),Je)}},X=0;X<re.length;X++)I(X)}(Q.navigator.geolocation,["getCurrentPosition","watchPosition"])}),Zone.__load_patch("PromiseRejectionEvent",function(Q,re){function _e(I){return function(X){ce(Q,I).forEach(function(ne){var me=Q.PromiseRejectionEvent;if(me){var Ke=new me(I,{promise:X.promise,reason:X.rejection});ne.invoke(Ke)}})}}Q.PromiseRejectionEvent&&(re[f("unhandledPromiseRejectionHandler")]=_e("unhandledrejection"),re[f("rejectionHandledHandler")]=_e("rejectionhandled"))})},"function"==typeof define&&define.amd?define(n):n()}),Hb=Rd($o=>{"use strict";var FJe=$o&&$o.__values||function(n){var t="function"==typeof Symbol&&n[Symbol.iterator],e=0;return t?t.call(n):{next:function(){return n&&e>=n.length&&(n=void 0),{value:n&&n[e++],done:!n}}}};function Vhe(n,t){return Math.floor(t()*n)}function lF(n){for(var t=[],e=0;e<n;e++)t.push(void 0);return t}function QG(n,t){return lF(n).map(function(){return t})}function Hhe(n){return QG(n,0)}function Uhe(n){return n.reduce(function(t,e){return t+e})}Object.defineProperty($o,"__esModule",{value:!0}),$o.tauRandInt=Vhe,$o.tauRand=function(n){return n()},$o.norm=function(n){var t,e,i=0;try{for(var r=FJe(n),o=r.next();!o.done;o=r.next())i+=Math.pow(o.value,2)}catch(a){t={error:a}}finally{try{o&&!o.done&&(e=r.return)&&e.call(r)}finally{if(t)throw t.error}}return Math.sqrt(i)},$o.empty=lF,$o.range=function(n){return lF(n).map(function(t,e){return e})},$o.filled=QG,$o.zeros=Hhe,$o.ones=function(n){return QG(n,1)},$o.linear=function(n,t,e){return lF(e).map(function(i,r){return n+r*((t-n)/(e-1))})},$o.sum=Uhe,$o.mean=function(n){return Uhe(n)/n.length},$o.max=function(n){for(var t=0,e=0;e<n.length;e++)t=n[e]>t?n[e]:t;return t},$o.max2d=function(n){for(var t=0,e=0;e<n.length;e++)for(var i=0;i<n[e].length;i++)t=n[e][i]>t?n[e][i]:t;return t},$o.rejectionSample=function(n,t,e){for(var i=Hhe(n),r=0;r<n;r++)for(var o=!0;o;){for(var s=Vhe(t,e),a=!1,l=0;l<r;l++)if(s===i[l]){a=!0;break}a||(o=!1),i[r]=s}return i},$o.reshape2d=function(n,t,e){var i=[],o=0;if(n.length!==t*e)throw new Error("Array dimensions must match input length.");for(var s=0;s<t;s++){for(var a=[],l=0;l<e;l++)a.push(n[o]),o+=1;i.push(a)}return i}}),ZG=Rd(fu=>{"use strict";var qJe=fu&&fu.__importStar||function(n){if(n&&n.__esModule)return n;var t={};if(null!=n)for(var e in n)Object.hasOwnProperty.call(n,e)&&(t[e]=n[e]);return t.default=n,t};Object.defineProperty(fu,"__esModule",{value:!0});var wE=qJe(Hb());function zhe(n,t){var e=function(r){return wE.empty(n).map(function(){return wE.filled(t,r)})},i=[];return i.push(e(-1)),i.push(e(1/0)),i.push(e(0)),i}function KG(n,t,e,i,r){t=Math.floor(t);var o=n[0][t];if(e>=n[1][t][0])return 0;for(var l=0;l<o.length;l++)if(i===o[l])return 0;return jhe(n,t,e,i,r)}function jhe(n,t,e,i,r){var o=n[0][t],s=n[1][t],a=n[2][t];if(e>=s[0])return 0;s[0]=e,o[0]=i,a[0]=r;for(var l=0,c=0;;){var u=2*l+1,d=u+1,p=n[0][0].length;if(u>=p)break;if(d>=p){if(!(s[u]>e))break;c=u}else if(s[u]>=s[d]){if(!(e<s[u]))break;c=u}else{if(!(e<s[d]))break;c=d}s[l]=s[c],o[l]=o[c],a[l]=a[c],l=c}return s[l]=e,o[l]=i,a[l]=r,1}function KJe(n,t,e,i){for(;2*i+1<e;){var r=2*i+1,o=r+1,s=i;if(n[s]<n[r]&&(s=r),o<e&&n[s]<n[o]&&(s=o),s===i)break;var a=n[i];n[i]=n[s],n[s]=a;var l=t[i];t[i]=t[s],t[s]=l,i=s}}fu.makeHeap=zhe,fu.rejectionSample=function(n,t,e){for(var i=wE.zeros(n),r=0;r<n;r++){for(var o=!0,s=0;o;){s=wE.tauRandInt(t,e);for(var a=!1,l=0;l<r;l++)if(s===i[l]){a=!0;break}a||(o=!1)}i[r]=s}return i},fu.heapPush=KG,fu.uncheckedHeapPush=jhe,fu.buildCandidates=function(n,t,e,i,r){for(var o=zhe(t,i),s=0;s<t;s++)for(var a=0;a<e;a++)if(!(n[0][s][a]<0)){var l=n[0][s][a],c=n[2][s][a],u=wE.tauRand(r);KG(o,s,u,l,c),KG(o,l,u,s,c),n[2][s][a]=0}return o},fu.deheapSort=function(n){for(var t=n[0],e=n[1],i=0;i<t.length;i++)for(var r=t[i],o=e[i],s=0;s<r.length-1;s++){var a=r.length-s-1,l=o.length-s-1,c=r[0];r[0]=r[a],r[a]=c;var u=o[0];o[0]=o[l],o[l]=u,KJe(o,r,l,0)}return{indices:t,weights:e}},fu.smallestFlagged=function(n,t){for(var e=n[0][t],i=n[1][t],r=n[2][t],o=1/0,s=-1,a=0;a>e.length;a++)1===r[a]&&i[a]<o&&(o=i[a],s=a);return s>=0?(r[s]=0,Math.floor(e[s])):-1}}),JG=Rd(es=>{"use strict";var cF=es&&es.__read||function(n,t){var e="function"==typeof Symbol&&n[Symbol.iterator];if(!e)return n;var r,s,i=e.call(n),o=[];try{for(;(void 0===t||t-- >0)&&!(r=i.next()).done;)o.push(r.value)}catch(a){s={error:a}}finally{try{r&&!r.done&&(e=i.return)&&e.call(i)}finally{if(s)throw s.error}}return o},JJe=es&&es.__values||function(n){var t="function"==typeof Symbol&&n[Symbol.iterator],e=0;return t?t.call(n):{next:function(){return n&&e>=n.length&&(n=void 0),{value:n&&n[e++],done:!n}}}},$Je=es&&es.__importStar||function(n){if(n&&n.__esModule)return n;var t={};if(null!=n)for(var e in n)Object.hasOwnProperty.call(n,e)&&(t[e]=n[e]);return t.default=n,t};Object.defineProperty(es,"__esModule",{value:!0});var SE,Ghe=$Je(Hb()),Ub=function(){function n(t,e,i,r){if(this.entries=new Map,this.nRows=0,this.nCols=0,t.length!==e.length||t.length!==i.length)throw new Error("rows, cols and values arrays must all have the same length");this.nRows=r[0],this.nCols=r[1];for(var o=0;o<i.length;o++){var s=t[o],a=e[o];this.checkDims(s,a);var l=this.makeKey(s,a);this.entries.set(l,{value:i[o],row:s,col:a})}}return n.prototype.makeKey=function(t,e){return t+":"+e},n.prototype.checkDims=function(t,e){if(!(t<this.nRows&&e<this.nCols))throw new Error("row and/or col specified outside of matrix dimensions")},n.prototype.set=function(t,e,i){this.checkDims(t,e);var r=this.makeKey(t,e);this.entries.has(r)?this.entries.get(r).value=i:this.entries.set(r,{value:i,row:t,col:e})},n.prototype.get=function(t,e,i){void 0===i&&(i=0),this.checkDims(t,e);var r=this.makeKey(t,e);return this.entries.has(r)?this.entries.get(r).value:i},n.prototype.getAll=function(t){void 0===t&&(t=!0);var e=[];return this.entries.forEach(function(i){e.push(i)}),t&&e.sort(function(i,r){return i.row===r.row?i.col-r.col:i.row-r.row}),e},n.prototype.getDims=function(){return[this.nRows,this.nCols]},n.prototype.getRows=function(){return Array.from(this.entries,function(t){return cF(t,2)[1].row})},n.prototype.getCols=function(){return Array.from(this.entries,function(t){return cF(t,2)[1].col})},n.prototype.getValues=function(){return Array.from(this.entries,function(t){return cF(t,2)[1].value})},n.prototype.forEach=function(t){this.entries.forEach(function(e){return t(e.value,e.row,e.col)})},n.prototype.map=function(t){var e=[];this.entries.forEach(function(r){e.push(t(r.value,r.row,r.col))});var i=[this.nRows,this.nCols];return new n(this.getRows(),this.getCols(),e,i)},n.prototype.toArray=function(){var t=this,i=Ghe.empty(this.nRows).map(function(){return Ghe.zeros(t.nCols)});return this.entries.forEach(function(r){i[r.row][r.col]=r.value}),i},n}();es.SparseMatrix=Ub,es.transpose=function(n){var t=[],e=[],i=[];return n.forEach(function(o,s,a){t.push(s),e.push(a),i.push(o)}),new Ub(e,t,i,[n.nCols,n.nRows])},es.identity=function(n){for(var e=cF(n,1)[0],i=new Ub([],[],[],n),r=0;r<e;r++)i.set(r,r,1);return i},es.pairwiseMultiply=function(n,t){return uF(n,t,function(e,i){return e*i})},es.add=function(n,t){return uF(n,t,function(e,i){return e+i})},es.subtract=function(n,t){return uF(n,t,function(e,i){return e-i})},es.maximum=function(n,t){return uF(n,t,function(e,i){return e>i?e:i})},es.multiplyScalar=function(n,t){return n.map(function(e){return e*t})},es.eliminateZeros=function(n){for(var t=new Set,e=n.getValues(),i=n.getRows(),r=n.getCols(),o=0;o<e.length;o++)0===e[o]&&t.add(o);var s=function(u,d){return!t.has(d)},a=e.filter(s),l=i.filter(s),c=r.filter(s);return new Ub(l,c,a,n.getDims())},es.normalize=function(n,t){void 0===t&&(t="l2");var e,i,r=c$e[t],o=new Map;n.forEach(function(d,p,h){var f=o.get(p)||[];f.push(h),o.set(p,f)});var s=new Ub([],[],[],n.getDims()),a=function(d){for(var p=o.get(d).sort(),h=p.map(function(x){return n.get(d,x)}),f=r(h),m=0;m<f.length;m++)s.set(d,p[m],f[m])};try{for(var l=JJe(o.keys()),c=l.next();!c.done;c=l.next())a(c.value)}catch(d){e={error:d}}finally{try{c&&!c.done&&(i=l.return)&&i.call(l)}finally{if(e)throw e.error}}return s};var c$e=((SE={}).max=function(n){for(var t=-1/0,e=0;e<n.length;e++)t=n[e]>t?n[e]:t;return n.map(function(i){return i/t})},SE.l1=function(n){for(var t=0,e=0;e<n.length;e++)t+=n[e];return n.map(function(i){return i/t})},SE.l2=function(n){for(var t=0,e=0;e<n.length;e++)t+=Math.pow(n[e],2);return n.map(function(i){return Math.sqrt(Math.pow(i,2)/t)})},SE);function uF(n,t,e){for(var i=new Set,r=[],o=[],s=[],a=function(D,T){r.push(D),o.push(T);var k=e(n.get(D,T),t.get(D,T));s.push(k)},l=n.getValues(),c=n.getRows(),u=n.getCols(),d=0;d<l.length;d++)i.add((p=c[d])+":"+(h=u[d])),a(p,h);var m=t.getValues(),x=t.getRows(),g=t.getCols();for(d=0;d<m.length;d++){var p,h;i.has((p=x[d])+":"+(h=g[d]))||a(p,h)}return new Ub(r,o,s,[n.nRows,n.nCols])}es.getCSR=function(n){var t=[];n.forEach(function(d,p,h){t.push({value:d,row:p,col:h})}),t.sort(function(d,p){return d.row===p.row?d.col-p.col:d.row-p.row});for(var e=[],i=[],r=[],o=-1,s=0;s<t.length;s++){var a=t[s],l=a.row,c=a.col,u=a.value;l!==o&&(o=l,r.push(s)),e.push(c),i.push(u)}return{indices:e,values:i,indptr:r}}}),i6=Rd(Ya=>{"use strict";var d$e=Ya&&Ya.__read||function(n,t){var e="function"==typeof Symbol&&n[Symbol.iterator];if(!e)return n;var r,s,i=e.call(n),o=[];try{for(;(void 0===t||t-- >0)&&!(r=i.next()).done;)o.push(r.value)}catch(a){s={error:a}}finally{try{r&&!r.done&&(e=i.return)&&e.call(i)}finally{if(s)throw s.error}}return o},Whe=Ya&&Ya.__spread||function(){for(var n=[],t=0;t<arguments.length;t++)n=n.concat(d$e(arguments[t]));return n},p$e=Ya&&Ya.__values||function(n){var t="function"==typeof Symbol&&n[Symbol.iterator],e=0;return t?t.call(n):{next:function(){return n&&e>=n.length&&(n=void 0),{value:n&&n[e++],done:!n}}}},h$e=Ya&&Ya.__importStar||function(n){if(n&&n.__esModule)return n;var t={};if(null!=n)for(var e in n)Object.hasOwnProperty.call(n,e)&&(t[e]=n[e]);return t.default=n,t};Object.defineProperty(Ya,"__esModule",{value:!0});var Xs=h$e(Hb()),qhe=function(t,e,i,r){this.hyperplanes=t,this.offsets=e,this.children=i,this.indices=r};function $G(n,t,e,i,r){if(void 0===e&&(e=30),t.length>e){var o=function(n,t,e){for(var i=n[0].length,r=Xs.tauRandInt(t.length,e),o=Xs.tauRandInt(t.length,e),s=t[r],a=t[o=(o+=r===o?1:0)%t.length],l=0,c=Xs.zeros(i),u=0;u<c.length;u++)c[u]=n[s][u]-n[a][u],l-=c[u]*(n[s][u]+n[a][u])/2;var d=0,p=0,h=Xs.zeros(t.length);for(u=0;u<t.length;u++){for(var f=l,m=0;m<i;m++)f+=c[m]*n[t[u]][m];0===f?(h[u]=Xs.tauRandInt(2,e),0===h[u]?d+=1:p+=1):f>0?(h[u]=0,d+=1):(h[u]=1,p+=1)}var x=Xs.zeros(d),g=Xs.zeros(p);for(d=0,p=0,u=0;u<h.length;u++)0===h[u]?(x[d]=t[u],d+=1):(g[p]=t[u],p+=1);return{indicesLeft:x,indicesRight:g,hyperplane:c,offset:l}}(n,t,r),a=o.indicesRight,l=o.hyperplane,c=o.offset;return{leftChild:$G(n,o.indicesLeft,e,i+1,r),rightChild:$G(n,a,e,i+1,r),isLeaf:!1,hyperplane:l,offset:c}}return{indices:t,isLeaf:!0}}function e6(n,t,e,i,r,o,s){var a;if(n.isLeaf)return i[o][0]=-s,(a=r[s]).splice.apply(a,Whe([0,n.indices.length],n.indices)),{nodeNum:o,leafNum:s+=1};t[o]=n.hyperplane,e[o]=n.offset,i[o][0]=o+1;var l=o,c=e6(n.leftChild,t,e,i,r,o+1,s);return s=c.leafNum,i[l][1]=(o=c.nodeNum)+1,{nodeNum:(c=e6(n.rightChild,t,e,i,r,o+1,s)).nodeNum,leafNum:c.leafNum}}function t6(n){return n.isLeaf?1:1+t6(n.leftChild)+t6(n.rightChild)}function n6(n){return n.isLeaf?1:n6(n.leftChild)+n6(n.rightChild)}function y$e(n,t,e,i){for(var r=t,o=0;o<e.length;o++)r+=n[o]*e[o];return 0===r?Xs.tauRandInt(2,i):r>0?0:1}Ya.FlatTree=qhe,Ya.makeForest=function(n,t,e,i){var r=Math.max(10,t),o=Xs.range(e).map(function(a,l){return function(n,t,e,i){return void 0===t&&(t=30),$G(n,Xs.range(n.length),t,e,i)}(n,r,l,i)}),s=o.map(function(a){return function(n,t){var e=t6(n),i=n6(n),r=Xs.range(e).map(function(){return Xs.zeros(n.hyperplane?n.hyperplane.length:0)}),o=Xs.zeros(e),s=Xs.range(e).map(function(){return[-1,-1]}),a=Xs.range(i).map(function(){return Xs.range(t).map(function(){return-1})});return e6(n,r,o,s,a,0,0),new qhe(r,o,s,a)}(a,r)});return s},Ya.makeLeafArray=function(n){var t,e;if(n.length>0){var i=[];try{for(var r=p$e(n),o=r.next();!o.done;o=r.next())i.push.apply(i,Whe(o.value.indices))}catch(a){t={error:a}}finally{try{o&&!o.done&&(e=r.return)&&e.call(r)}finally{if(t)throw t.error}}return i}return[[-1]]},Ya.searchFlatTree=function(n,t,e){for(var i=0;t.children[i][0]>0;)i=0===y$e(t.hyperplanes[i],t.offsets[i],n,e)?t.children[i][0]:t.children[i][1];return t.indices[-1*t.children[i][0]]}}),Qhe=Rd(Id=>{"use strict";var Yhe=Id&&Id.__values||function(n){var t="function"==typeof Symbol&&n[Symbol.iterator],e=0;return t?t.call(n):{next:function(){return n&&e>=n.length&&(n=void 0),{value:n&&n[e++],done:!n}}}},dF=Id&&Id.__importStar||function(n){if(n&&n.__esModule)return n;var t={};if(null!=n)for(var e in n)Object.hasOwnProperty.call(n,e)&&(t[e]=n[e]);return t.default=n,t};Object.defineProperty(Id,"__esModule",{value:!0});var ya=dF(ZG()),x$e=dF(JG()),C$e=dF(i6()),Xhe=dF(Hb());Id.makeNNDescent=function(n,t){return function(i,r,o,s,a,l,c,u){void 0===s&&(s=10),void 0===a&&(a=50),void 0===l&&(l=.001),void 0===c&&(c=.5),void 0===u&&(u=!0);for(var d=i.length,p=ya.makeHeap(i.length,o),h=0;h<i.length;h++)for(var f=ya.rejectionSample(o,i.length,t),m=0;m<f.length;m++){var x=n(i[h],i[f[m]]);ya.heapPush(p,h,x,f[m],1),ya.heapPush(p,f[m],x,h,1)}if(u)for(var g=0;g<r.length;g++)for(h=0;h<r[g].length&&!(r[g][h]<0);h++)for(m=h+1;m<r[g].length&&!(r[g][m]<0);m++)x=n(i[r[g][h]],i[r[g][m]]),ya.heapPush(p,r[g][h],x,r[g][m],1),ya.heapPush(p,r[g][m],x,r[g][h],1);for(g=0;g<s;g++){var b=ya.buildCandidates(p,d,o,a,t),D=0;for(h=0;h<d;h++)for(m=0;m<a;m++){var T=Math.floor(b[0][h][m]);if(!(T<0||Xhe.tauRand(t)<c))for(var k=0;k<a;k++){var Z=Math.floor(b[0][h][k]);Z<0||!b[2][h][m]&&!b[2][h][k]||(x=n(i[T],i[Z]),D+=ya.heapPush(p,T,x,Z,1),D+=ya.heapPush(p,Z,x,T,1))}}if(D<=l*o*i.length)break}return ya.deheapSort(p)}},Id.makeInitializations=function(n){return{initFromRandom:function(i,r,o,s,a){for(var l=0;l<o.length;l++)for(var c=Xhe.rejectionSample(i,r.length,a),u=0;u<c.length;u++)if(!(c[u]<0)){var d=n(r[c[u]],o[l]);ya.heapPush(s,l,d,c[u],1)}},initFromTree:function(i,r,o,s,a){for(var l=0;l<o.length;l++)for(var c=C$e.searchFlatTree(o[l],i,a),u=0;u<c.length;u++){if(c[u]<0)return;var d=n(r[c[u]],o[l]);ya.heapPush(s,l,d,c[u],1)}}}},Id.makeInitializedNNSearch=function(n){return function(e,i,r,o){for(var s,a,l=x$e.getCSR(i),c=l.indices,u=l.indptr,d=0;d<o.length;d++)for(var p=new Set(r[0][d]);;){var h=ya.smallestFlagged(r,d);if(-1===h)break;var f=c.slice(u[h],u[h+1]);try{for(var m=Yhe(f),x=m.next();!x.done;x=m.next()){var g=x.value;if(g!==h&&-1!==g&&!p.has(g)){var b=n(e[g],o[d]);ya.uncheckedHeapPush(r,d,b,g,1),p.add(g)}}}catch(D){s={error:D}}finally{try{x&&!x.done&&(a=m.return)&&a.call(m)}finally{if(s)throw s.error}}}return r}},Id.initializeSearch=function(n,t,e,i,r,o,s){var a,l,c=ya.makeHeap(e.length,i);if(r(i,t,e,c,s),n)try{for(var u=Yhe(n),d=u.next();!d.done;d=u.next())o(d.value,t,e,c,s)}catch(h){a={error:h}}finally{try{d&&!d.done&&(l=u.return)&&l.call(u)}finally{if(a)throw a.error}}return c}});function EE(n){return T$e.call(n).endsWith("Array]")}var T$e,Khe=ho(()=>{T$e=Object.prototype.toString});function pF(n,t,e){let i=0,r=e(t);for(let o=0;o<n.x.length;o++)i+=Math.abs(n.y[o]-r(n.x[o]));return i}var Zhe=ho(()=>{});function If(n){return D$e.call(n).endsWith("Array]")}var D$e,hF=ho(()=>{D$e=Object.prototype.toString});function A$e(n){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};if(!If(n))throw new TypeError("input must be an array");if(0===n.length)throw new TypeError("input must not be empty");var e=t.fromIndex,i=void 0===e?0:e,r=t.toIndex,o=void 0===r?n.length:r;if(i<0||i>=n.length||!Number.isInteger(i))throw new Error("fromIndex must be a positive integer smaller than length");if(o<=i||o>n.length||!Number.isInteger(o))throw new Error("toIndex must be an integer greater than fromIndex and at most equal to length");for(var s=n[i],a=i+1;a<o;a++)n[a]>s&&(s=n[a]);return s}var Jhe,$he=ho(()=>{hF(),Jhe=A$e});function I$e(n){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};if(!If(n))throw new TypeError("input must be an array");if(0===n.length)throw new TypeError("input must not be empty");var e=t.fromIndex,i=void 0===e?0:e,r=t.toIndex,o=void 0===r?n.length:r;if(i<0||i>=n.length||!Number.isInteger(i))throw new Error("fromIndex must be a positive integer smaller than length");if(o<=i||o>n.length||!Number.isInteger(o))throw new Error("toIndex must be an integer greater than fromIndex and at most equal to length");for(var s=n[i],a=i+1;a<o;a++)n[a]<s&&(s=n[a]);return s}var efe,tfe=ho(()=>{hF(),efe=I$e});function P$e(n){var e,t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};if(!If(n))throw new TypeError("input must be an array");if(0===n.length)throw new TypeError("input must not be empty");if(void 0!==t.output){if(!If(t.output))throw new TypeError("output option must be an array if specified");e=t.output}else e=new Array(n.length);var i=efe(n),r=Jhe(n);if(i===r)throw new RangeError("minimum and maximum input values are equal. Cannot rescale a constant array");var o=t.min,s=void 0===o?t.autoMinMax?i:0:o,a=t.max,l=void 0===a?t.autoMinMax?r:1:a;if(s>=l)throw new RangeError("min option must be smaller than max option");for(var c=(l-s)/(r-i),u=0;u<n.length;u++)e[u]=(n[u]-i)*c+s;return e}var r6,nfe=ho(()=>{hF(),$he(),tfe(),r6=P$e});function rfe(){return o6(this)}function o6(n,t={}){let{maxRows:e=15,maxColumns:i=10,maxNumSize:r=8}=t;return`${n.constructor.name} {\n${fF}[\n${ife}${function(n,t,e,i){let{rows:r,columns:o}=n,s=Math.min(r,t),a=Math.min(o,e),l=[];for(let c=0;c<s;c++){let u=[];for(let d=0;d<a;d++)u.push(O$e(n.get(c,d),i));l.push(`${u.join(" ")}`)}return a!==o&&(l[l.length-1]+=` ... ${o-e} more columns`),s!==r&&l.push(`... ${r-t} more rows`),l.join(`\n${ife}`)}(n,e,i,r)}\n${fF}]\n${fF}rows: ${n.rows}\n${fF}columns: ${n.columns}\n}`}function O$e(n,t){let e=String(n);if(e.length<=t)return e.padEnd(t," ");let i=n.toPrecision(t-2);if(i.length<=t)return i;let r=n.toExponential(t-2),o=r.indexOf("e"),s=r.slice(o);return r.slice(0,t-s.length)+s}var fF,ife,ofe=ho(()=>{fF=" ".repeat(2),ife=" ".repeat(4)}),afe=ho(()=>{});function gc(n,t,e){if(t<0||t>(e?n.rows:n.rows-1))throw new RangeError("Row index out of range")}function _c(n,t,e){if(t<0||t>(e?n.columns:n.columns-1))throw new RangeError("Column index out of range")}function n0(n,t){if(t.to1DArray&&(t=t.to1DArray()),t.length!==n.columns)throw new RangeError("vector size must be the same as the number of columns");return t}function i0(n,t){if(t.to1DArray&&(t=t.to1DArray()),t.length!==n.rows)throw new RangeError("vector size must be the same as the number of rows");return t}function k$e(n,t){if("object"!=typeof t)throw new TypeError("unexpected type for row indices");if(t.some(i=>i<0||i>=n.rows))throw new RangeError("row indices are out of range");return Array.isArray(t)||(t=Array.from(t)),t}function F$e(n,t){if("object"!=typeof t)throw new TypeError("unexpected type for column indices");if(t.some(i=>i<0||i>=n.columns))throw new RangeError("column indices are out of range");return Array.isArray(t)||(t=Array.from(t)),t}function s6(n,t,e,i,r){if(5!==arguments.length)throw new RangeError("expected 4 arguments");if(mF("startRow",t),mF("endRow",e),mF("startColumn",i),mF("endColumn",r),t>e||i>r||t<0||t>=n.rows||e<0||e>=n.rows||i<0||i>=n.columns||r<0||r>=n.columns)throw new RangeError("Submatrix indices are out of range")}function TE(n,t=0){let e=[];for(let i=0;i<n;i++)e.push(t);return e}function mF(n,t){if("number"!=typeof t)throw new TypeError(`${n} must be a number`)}function r0(n){if(n.isEmpty())throw new Error("Empty matrix has no elements to index")}var a6=ho(()=>{}),Tfe=ho(()=>{a6()});function Dfe(n,t){return n-t}var ti,rn,Al,AE,o0=ho(()=>{var n,t;nfe(),ofe(),afe(),Tfe(),a6(),ti=class{static from1DArray(t,e,i){if(t*e!==i.length)throw new RangeError("data length does not match given dimensions");let o=new rn(t,e);for(let s=0;s<t;s++)for(let a=0;a<e;a++)o.set(s,a,i[s*e+a]);return o}static rowVector(t){let e=new rn(1,t.length);for(let i=0;i<t.length;i++)e.set(0,i,t[i]);return e}static columnVector(t){let e=new rn(t.length,1);for(let i=0;i<t.length;i++)e.set(i,0,t[i]);return e}static zeros(t,e){return new rn(t,e)}static ones(t,e){return new rn(t,e).fill(1)}static rand(t,e,i={}){if("object"!=typeof i)throw new TypeError("options must be an object");let{random:r=Math.random}=i,o=new rn(t,e);for(let s=0;s<t;s++)for(let a=0;a<e;a++)o.set(s,a,r());return o}static randInt(t,e,i={}){if("object"!=typeof i)throw new TypeError("options must be an object");let{min:r=0,max:o=1e3,random:s=Math.random}=i;if(!Number.isInteger(r))throw new TypeError("min must be an integer");if(!Number.isInteger(o))throw new TypeError("max must be an integer");if(r>=o)throw new RangeError("min must be smaller than max");let a=o-r,l=new rn(t,e);for(let c=0;c<t;c++)for(let u=0;u<e;u++){let d=r+Math.round(s()*a);l.set(c,u,d)}return l}static eye(t,e,i){void 0===e&&(e=t),void 0===i&&(i=1);let r=Math.min(t,e),o=this.zeros(t,e);for(let s=0;s<r;s++)o.set(s,s,i);return o}static diag(t,e,i){let r=t.length;void 0===e&&(e=r),void 0===i&&(i=e);let o=Math.min(r,e,i),s=this.zeros(e,i);for(let a=0;a<o;a++)s.set(a,a,t[a]);return s}static min(t,e){t=this.checkMatrix(t),e=this.checkMatrix(e);let i=t.rows,r=t.columns,o=new rn(i,r);for(let s=0;s<i;s++)for(let a=0;a<r;a++)o.set(s,a,Math.min(t.get(s,a),e.get(s,a)));return o}static max(t,e){t=this.checkMatrix(t),e=this.checkMatrix(e);let i=t.rows,r=t.columns,o=new this(i,r);for(let s=0;s<i;s++)for(let a=0;a<r;a++)o.set(s,a,Math.max(t.get(s,a),e.get(s,a)));return o}static checkMatrix(t){return ti.isMatrix(t)?t:new rn(t)}static isMatrix(t){return null!=t&&"Matrix"===t.klass}get size(){return this.rows*this.columns}apply(t){if("function"!=typeof t)throw new TypeError("callback must be a function");for(let e=0;e<this.rows;e++)for(let i=0;i<this.columns;i++)t.call(this,e,i);return this}to1DArray(){let t=[];for(let e=0;e<this.rows;e++)for(let i=0;i<this.columns;i++)t.push(this.get(e,i));return t}to2DArray(){let t=[];for(let e=0;e<this.rows;e++){t.push([]);for(let i=0;i<this.columns;i++)t[e].push(this.get(e,i))}return t}toJSON(){return this.to2DArray()}isRowVector(){return 1===this.rows}isColumnVector(){return 1===this.columns}isVector(){return 1===this.rows||1===this.columns}isSquare(){return this.rows===this.columns}isEmpty(){return 0===this.rows||0===this.columns}isSymmetric(){if(this.isSquare()){for(let t=0;t<this.rows;t++)for(let e=0;e<=t;e++)if(this.get(t,e)!==this.get(e,t))return!1;return!0}return!1}isEchelonForm(){let t=0,e=0,i=-1,r=!0,o=!1;for(;t<this.rows&&r;){for(e=0,o=!1;e<this.columns&&!1===o;)0===this.get(t,e)?e++:1===this.get(t,e)&&e>i?(o=!0,i=e):(r=!1,o=!0);t++}return r}isReducedEchelonForm(){let t=0,e=0,i=-1,r=!0,o=!1;for(;t<this.rows&&r;){for(e=0,o=!1;e<this.columns&&!1===o;)0===this.get(t,e)?e++:1===this.get(t,e)&&e>i?(o=!0,i=e):(r=!1,o=!0);for(let s=e+1;s<this.rows;s++)0!==this.get(t,s)&&(r=!1);t++}return r}echelonForm(){let t=this.clone(),e=0,i=0;for(;e<t.rows&&i<t.columns;){let r=e;for(let o=e;o<t.rows;o++)t.get(o,i)>t.get(r,i)&&(r=o);if(0===t.get(r,i))i++;else{t.swapRows(e,r);let o=t.get(e,i);for(let s=i;s<t.columns;s++)t.set(e,s,t.get(e,s)/o);for(let s=e+1;s<t.rows;s++){let a=t.get(s,i)/t.get(e,i);t.set(s,i,0);for(let l=i+1;l<t.columns;l++)t.set(s,l,t.get(s,l)-t.get(e,l)*a)}e++,i++}}return t}reducedEchelonForm(){let t=this.echelonForm(),e=t.columns,i=t.rows,r=i-1;for(;r>=0;)if(0===t.maxRow(r))r--;else{let o=0,s=!1;for(;o<i&&!1===s;)1===t.get(r,o)?s=!0:o++;for(let a=0;a<r;a++){let l=t.get(a,o);for(let c=o;c<e;c++){let u=t.get(a,c)-l*t.get(r,c);t.set(a,c,u)}}r--}return t}set(){throw new Error("set method is unimplemented")}get(){throw new Error("get method is unimplemented")}repeat(t={}){if("object"!=typeof t)throw new TypeError("options must be an object");let{rows:e=1,columns:i=1}=t;if(!Number.isInteger(e)||e<=0)throw new TypeError("rows must be a positive integer");if(!Number.isInteger(i)||i<=0)throw new TypeError("columns must be a positive integer");let r=new rn(this.rows*e,this.columns*i);for(let o=0;o<e;o++)for(let s=0;s<i;s++)r.setSubMatrix(this,this.rows*o,this.columns*s);return r}fill(t){for(let e=0;e<this.rows;e++)for(let i=0;i<this.columns;i++)this.set(e,i,t);return this}neg(){return this.mulS(-1)}getRow(t){gc(this,t);let e=[];for(let i=0;i<this.columns;i++)e.push(this.get(t,i));return e}getRowVector(t){return rn.rowVector(this.getRow(t))}setRow(t,e){gc(this,t),e=n0(this,e);for(let i=0;i<this.columns;i++)this.set(t,i,e[i]);return this}swapRows(t,e){gc(this,t),gc(this,e);for(let i=0;i<this.columns;i++){let r=this.get(t,i);this.set(t,i,this.get(e,i)),this.set(e,i,r)}return this}getColumn(t){_c(this,t);let e=[];for(let i=0;i<this.rows;i++)e.push(this.get(i,t));return e}getColumnVector(t){return rn.columnVector(this.getColumn(t))}setColumn(t,e){_c(this,t),e=i0(this,e);for(let i=0;i<this.rows;i++)this.set(i,t,e[i]);return this}swapColumns(t,e){_c(this,t),_c(this,e);for(let i=0;i<this.rows;i++){let r=this.get(i,t);this.set(i,t,this.get(i,e)),this.set(i,e,r)}return this}addRowVector(t){t=n0(this,t);for(let e=0;e<this.rows;e++)for(let i=0;i<this.columns;i++)this.set(e,i,this.get(e,i)+t[i]);return this}subRowVector(t){t=n0(this,t);for(let e=0;e<this.rows;e++)for(let i=0;i<this.columns;i++)this.set(e,i,this.get(e,i)-t[i]);return this}mulRowVector(t){t=n0(this,t);for(let e=0;e<this.rows;e++)for(let i=0;i<this.columns;i++)this.set(e,i,this.get(e,i)*t[i]);return this}divRowVector(t){t=n0(this,t);for(let e=0;e<this.rows;e++)for(let i=0;i<this.columns;i++)this.set(e,i,this.get(e,i)/t[i]);return this}addColumnVector(t){t=i0(this,t);for(let e=0;e<this.rows;e++)for(let i=0;i<this.columns;i++)this.set(e,i,this.get(e,i)+t[e]);return this}subColumnVector(t){t=i0(this,t);for(let e=0;e<this.rows;e++)for(let i=0;i<this.columns;i++)this.set(e,i,this.get(e,i)-t[e]);return this}mulColumnVector(t){t=i0(this,t);for(let e=0;e<this.rows;e++)for(let i=0;i<this.columns;i++)this.set(e,i,this.get(e,i)*t[e]);return this}divColumnVector(t){t=i0(this,t);for(let e=0;e<this.rows;e++)for(let i=0;i<this.columns;i++)this.set(e,i,this.get(e,i)/t[e]);return this}mulRow(t,e){gc(this,t);for(let i=0;i<this.columns;i++)this.set(t,i,this.get(t,i)*e);return this}mulColumn(t,e){_c(this,t);for(let i=0;i<this.rows;i++)this.set(i,t,this.get(i,t)*e);return this}max(){if(this.isEmpty())return NaN;let t=this.get(0,0);for(let e=0;e<this.rows;e++)for(let i=0;i<this.columns;i++)this.get(e,i)>t&&(t=this.get(e,i));return t}maxIndex(){r0(this);let t=this.get(0,0),e=[0,0];for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.get(i,r)>t&&(t=this.get(i,r),e[0]=i,e[1]=r);return e}min(){if(this.isEmpty())return NaN;let t=this.get(0,0);for(let e=0;e<this.rows;e++)for(let i=0;i<this.columns;i++)this.get(e,i)<t&&(t=this.get(e,i));return t}minIndex(){r0(this);let t=this.get(0,0),e=[0,0];for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.get(i,r)<t&&(t=this.get(i,r),e[0]=i,e[1]=r);return e}maxRow(t){if(gc(this,t),this.isEmpty())return NaN;let e=this.get(t,0);for(let i=1;i<this.columns;i++)this.get(t,i)>e&&(e=this.get(t,i));return e}maxRowIndex(t){gc(this,t),r0(this);let e=this.get(t,0),i=[t,0];for(let r=1;r<this.columns;r++)this.get(t,r)>e&&(e=this.get(t,r),i[1]=r);return i}minRow(t){if(gc(this,t),this.isEmpty())return NaN;let e=this.get(t,0);for(let i=1;i<this.columns;i++)this.get(t,i)<e&&(e=this.get(t,i));return e}minRowIndex(t){gc(this,t),r0(this);let e=this.get(t,0),i=[t,0];for(let r=1;r<this.columns;r++)this.get(t,r)<e&&(e=this.get(t,r),i[1]=r);return i}maxColumn(t){if(_c(this,t),this.isEmpty())return NaN;let e=this.get(0,t);for(let i=1;i<this.rows;i++)this.get(i,t)>e&&(e=this.get(i,t));return e}maxColumnIndex(t){_c(this,t),r0(this);let e=this.get(0,t),i=[0,t];for(let r=1;r<this.rows;r++)this.get(r,t)>e&&(e=this.get(r,t),i[0]=r);return i}minColumn(t){if(_c(this,t),this.isEmpty())return NaN;let e=this.get(0,t);for(let i=1;i<this.rows;i++)this.get(i,t)<e&&(e=this.get(i,t));return e}minColumnIndex(t){_c(this,t),r0(this);let e=this.get(0,t),i=[0,t];for(let r=1;r<this.rows;r++)this.get(r,t)<e&&(e=this.get(r,t),i[0]=r);return i}diag(){let t=Math.min(this.rows,this.columns),e=[];for(let i=0;i<t;i++)e.push(this.get(i,i));return e}norm(t="frobenius"){let e=0;if("max"===t)return this.max();if("frobenius"===t){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)e+=this.get(i,r)*this.get(i,r);return Math.sqrt(e)}throw new RangeError(`unknown norm type: ${t}`)}cumulativeSum(){let t=0;for(let e=0;e<this.rows;e++)for(let i=0;i<this.columns;i++)t+=this.get(e,i),this.set(e,i,t);return this}dot(t){ti.isMatrix(t)&&(t=t.to1DArray());let e=this.to1DArray();if(e.length!==t.length)throw new RangeError("vectors do not have the same size");let i=0;for(let r=0;r<e.length;r++)i+=e[r]*t[r];return i}mmul(t){t=rn.checkMatrix(t);let e=this.rows,i=this.columns,r=t.columns,o=new rn(e,r),s=new Float64Array(i);for(let a=0;a<r;a++){for(let l=0;l<i;l++)s[l]=t.get(l,a);for(let l=0;l<e;l++){let c=0;for(let u=0;u<i;u++)c+=this.get(l,u)*s[u];o.set(l,a,c)}}return o}strassen2x2(t){t=rn.checkMatrix(t);let e=new rn(2,2),i=this.get(0,0),r=t.get(0,0),o=this.get(0,1),s=t.get(0,1),a=this.get(1,0),l=t.get(1,0),c=this.get(1,1),u=t.get(1,1),d=(i+c)*(r+u),p=(a+c)*r,h=i*(s-u),f=c*(l-r),m=(i+o)*u,D=h+m,T=p+f,k=d-p+h+(a-i)*(r+s);return e.set(0,0,d+f-m+(o-c)*(l+u)),e.set(0,1,D),e.set(1,0,T),e.set(1,1,k),e}strassen3x3(t){t=rn.checkMatrix(t);let e=new rn(3,3),i=this.get(0,0),r=this.get(0,1),o=this.get(0,2),s=this.get(1,0),a=this.get(1,1),l=this.get(1,2),c=this.get(2,0),u=this.get(2,1),d=this.get(2,2),p=t.get(0,0),h=t.get(0,1),f=t.get(0,2),m=t.get(1,0),x=t.get(1,1),g=t.get(1,2),b=t.get(2,0),D=t.get(2,1),T=t.get(2,2),Z=(i-s)*(-h+x),fe=(-i+s+a)*(p-h+x),ue=(s+a)*(-p+h),he=i*p,w=(-i+c+u)*(p-f+g),F=(-i+c)*(f-g),q=(c+u)*(-p+f),Y=(-o+u+d)*(x+b-D),ae=(o-d)*(x-D),le=o*b,Ie=(u+d)*(-b+D),ve=(-o+a+l)*(g+b-T),De=(o-l)*(g-T),nt=(a+l)*(-b+T),Te=(i+r+o-s-a-u-d)*x+fe+ue+he+Y+le+Ie,xt=he+w+q+(i+r+o-a-l-c-u)*g+le+ve+nt,mt=Z+a*(-p+h+m-x-g-b+T)+fe+he+le+ve+De,ce=Z+fe+ue+he+l*D,dt=le+ve+De+nt+s*f,We=he+w+F+u*(-p+f+m-x-g-b+D)+Y+ae+le,Mt=Y+ae+le+Ie+c*h,bt=he+w+F+q+d*T;return e.set(0,0,he+le+r*m),e.set(0,1,Te),e.set(0,2,xt),e.set(1,0,mt),e.set(1,1,ce),e.set(1,2,dt),e.set(2,0,We),e.set(2,1,Mt),e.set(2,2,bt),e}mmulStrassen(t){t=rn.checkMatrix(t);let e=this.clone(),i=e.rows,r=e.columns,o=t.rows,s=t.columns;function a(d,p,h){if(d.rows===p&&d.columns===h)return d;{let x=ti.zeros(p,h);return x=x.setSubMatrix(d,0,0),x}}r!==o&&console.warn(`Multiplying ${i} x ${r} and ${o} x ${s} matrix: dimensions do not match.`);let l=Math.max(i,o),c=Math.max(r,s);return e=a(e,l,c),function u(d,p,h,f){if(h<=512||f<=512)return d.mmul(p);h%2==1&&f%2==1?(d=a(d,h+1,f+1),p=a(p,h+1,f+1)):h%2==1?(d=a(d,h+1,f),p=a(p,h+1,f)):f%2==1&&(d=a(d,h,f+1),p=a(p,h,f+1));let m=parseInt(d.rows/2,10),x=parseInt(d.columns/2,10),g=d.subMatrix(0,m-1,0,x-1),b=p.subMatrix(0,m-1,0,x-1),D=d.subMatrix(0,m-1,x,d.columns-1),T=p.subMatrix(0,m-1,x,p.columns-1),k=d.subMatrix(m,d.rows-1,0,x-1),Z=p.subMatrix(m,p.rows-1,0,x-1),z=d.subMatrix(m,d.rows-1,x,d.columns-1),fe=p.subMatrix(m,p.rows-1,x,p.columns-1),ue=u(ti.add(g,z),ti.add(b,fe),m,x),he=u(ti.add(k,z),b,m,x),w=u(g,ti.sub(T,fe),m,x),F=u(z,ti.sub(Z,b),m,x),q=u(ti.add(g,D),fe,m,x),K=u(ti.sub(k,g),ti.add(b,T),m,x),de=u(ti.sub(D,z),ti.add(Z,fe),m,x),Y=ti.add(ue,F);Y.sub(q),Y.add(de);let ae=ti.add(w,q),le=ti.add(he,F),Ie=ti.sub(ue,he);Ie.add(w),Ie.add(K);let ve=ti.zeros(2*Y.rows,2*Y.columns);return ve=ve.setSubMatrix(Y,0,0),ve=ve.setSubMatrix(ae,Y.rows,0),ve=ve.setSubMatrix(le,0,Y.columns),ve=ve.setSubMatrix(Ie,Y.rows,Y.columns),ve.subMatrix(0,h-1,0,f-1)}(e,t=a(t,l,c),l,c)}scaleRows(t={}){if("object"!=typeof t)throw new TypeError("options must be an object");let{min:e=0,max:i=1}=t;if(!Number.isFinite(e))throw new TypeError("min must be a number");if(!Number.isFinite(i))throw new TypeError("max must be a number");if(e>=i)throw new RangeError("min must be smaller than max");let r=new rn(this.rows,this.columns);for(let o=0;o<this.rows;o++){let s=this.getRow(o);s.length>0&&r6(s,{min:e,max:i,output:s}),r.setRow(o,s)}return r}scaleColumns(t={}){if("object"!=typeof t)throw new TypeError("options must be an object");let{min:e=0,max:i=1}=t;if(!Number.isFinite(e))throw new TypeError("min must be a number");if(!Number.isFinite(i))throw new TypeError("max must be a number");if(e>=i)throw new RangeError("min must be smaller than max");let r=new rn(this.rows,this.columns);for(let o=0;o<this.columns;o++){let s=this.getColumn(o);s.length&&r6(s,{min:e,max:i,output:s}),r.setColumn(o,s)}return r}flipRows(){let t=Math.ceil(this.columns/2);for(let e=0;e<this.rows;e++)for(let i=0;i<t;i++){let r=this.get(e,i),o=this.get(e,this.columns-1-i);this.set(e,i,o),this.set(e,this.columns-1-i,r)}return this}flipColumns(){let t=Math.ceil(this.rows/2);for(let e=0;e<this.columns;e++)for(let i=0;i<t;i++){let r=this.get(i,e),o=this.get(this.rows-1-i,e);this.set(i,e,o),this.set(this.rows-1-i,e,r)}return this}kroneckerProduct(t){t=rn.checkMatrix(t);let e=this.rows,i=this.columns,r=t.rows,o=t.columns,s=new rn(e*r,i*o);for(let a=0;a<e;a++)for(let l=0;l<i;l++)for(let c=0;c<r;c++)for(let u=0;u<o;u++)s.set(r*a+c,o*l+u,this.get(a,l)*t.get(c,u));return s}kroneckerSum(t){if(t=rn.checkMatrix(t),!this.isSquare()||!t.isSquare())throw new Error("Kronecker Sum needs two Square Matrices");let e=this.rows,i=t.rows,r=this.kroneckerProduct(rn.eye(i,i)),o=rn.eye(e,e).kroneckerProduct(t);return r.add(o)}transpose(){let t=new rn(this.columns,this.rows);for(let e=0;e<this.rows;e++)for(let i=0;i<this.columns;i++)t.set(i,e,this.get(e,i));return t}sortRows(t=Dfe){for(let e=0;e<this.rows;e++)this.setRow(e,this.getRow(e).sort(t));return this}sortColumns(t=Dfe){for(let e=0;e<this.columns;e++)this.setColumn(e,this.getColumn(e).sort(t));return this}subMatrix(t,e,i,r){s6(this,t,e,i,r);let o=new rn(e-t+1,r-i+1);for(let s=t;s<=e;s++)for(let a=i;a<=r;a++)o.set(s-t,a-i,this.get(s,a));return o}subMatrixRow(t,e,i){if(void 0===e&&(e=0),void 0===i&&(i=this.columns-1),e>i||e<0||e>=this.columns||i<0||i>=this.columns)throw new RangeError("Argument out of range");let r=new rn(t.length,i-e+1);for(let o=0;o<t.length;o++)for(let s=e;s<=i;s++){if(t[o]<0||t[o]>=this.rows)throw new RangeError(`Row index out of range: ${t[o]}`);r.set(o,s-e,this.get(t[o],s))}return r}subMatrixColumn(t,e,i){if(void 0===e&&(e=0),void 0===i&&(i=this.rows-1),e>i||e<0||e>=this.rows||i<0||i>=this.rows)throw new RangeError("Argument out of range");let r=new rn(i-e+1,t.length);for(let o=0;o<t.length;o++)for(let s=e;s<=i;s++){if(t[o]<0||t[o]>=this.columns)throw new RangeError(`Column index out of range: ${t[o]}`);r.set(s-e,o,this.get(s,t[o]))}return r}setSubMatrix(t,e,i){if((t=rn.checkMatrix(t)).isEmpty())return this;s6(this,e,e+t.rows-1,i,i+t.columns-1);for(let s=0;s<t.rows;s++)for(let a=0;a<t.columns;a++)this.set(e+s,i+a,t.get(s,a));return this}selection(t,e){let i=function(n,t,e){return{row:k$e(n,t),column:F$e(n,e)}}(this,t,e),r=new rn(t.length,e.length);for(let o=0;o<i.row.length;o++){let s=i.row[o];for(let a=0;a<i.column.length;a++)r.set(o,a,this.get(s,i.column[a]))}return r}trace(){let t=Math.min(this.rows,this.columns),e=0;for(let i=0;i<t;i++)e+=this.get(i,i);return e}clone(){let t=new rn(this.rows,this.columns);for(let e=0;e<this.rows;e++)for(let i=0;i<this.columns;i++)t.set(e,i,this.get(e,i));return t}sum(t){switch(t){case"row":return function(n){let t=TE(n.rows);for(let e=0;e<n.rows;++e)for(let i=0;i<n.columns;++i)t[e]+=n.get(e,i);return t}(this);case"column":return function(n){let t=TE(n.columns);for(let e=0;e<n.rows;++e)for(let i=0;i<n.columns;++i)t[i]+=n.get(e,i);return t}(this);case void 0:return function(n){let t=0;for(let e=0;e<n.rows;e++)for(let i=0;i<n.columns;i++)t+=n.get(e,i);return t}(this);default:throw new Error(`invalid option: ${t}`)}}product(t){switch(t){case"row":return function(n){let t=TE(n.rows,1);for(let e=0;e<n.rows;++e)for(let i=0;i<n.columns;++i)t[e]*=n.get(e,i);return t}(this);case"column":return function(n){let t=TE(n.columns,1);for(let e=0;e<n.rows;++e)for(let i=0;i<n.columns;++i)t[i]*=n.get(e,i);return t}(this);case void 0:return function(n){let t=1;for(let e=0;e<n.rows;e++)for(let i=0;i<n.columns;i++)t*=n.get(e,i);return t}(this);default:throw new Error(`invalid option: ${t}`)}}mean(t){let e=this.sum(t);switch(t){case"row":for(let i=0;i<this.rows;i++)e[i]/=this.columns;return e;case"column":for(let i=0;i<this.columns;i++)e[i]/=this.rows;return e;case void 0:return e/this.size;default:throw new Error(`invalid option: ${t}`)}}variance(t,e={}){if("object"==typeof t&&(e=t,t=void 0),"object"!=typeof e)throw new TypeError("options must be an object");let{unbiased:i=!0,mean:r=this.mean(t)}=e;if("boolean"!=typeof i)throw new TypeError("unbiased must be a boolean");switch(t){case"row":if(!Array.isArray(r))throw new TypeError("mean must be an array");return function(n,t,e){let i=n.rows,r=n.columns,o=[];for(let s=0;s<i;s++){let a=0,l=0,c=0;for(let u=0;u<r;u++)c=n.get(s,u)-e[s],a+=c,l+=c*c;o.push(t?(l-a*a/r)/(r-1):(l-a*a/r)/r)}return o}(this,i,r);case"column":if(!Array.isArray(r))throw new TypeError("mean must be an array");return function(n,t,e){let i=n.rows,r=n.columns,o=[];for(let s=0;s<r;s++){let a=0,l=0,c=0;for(let u=0;u<i;u++)c=n.get(u,s)-e[s],a+=c,l+=c*c;o.push(t?(l-a*a/i)/(i-1):(l-a*a/i)/i)}return o}(this,i,r);case void 0:if("number"!=typeof r)throw new TypeError("mean must be a number");return function(n,t,e){let i=n.rows,r=n.columns,o=i*r,s=0,a=0,l=0;for(let c=0;c<i;c++)for(let u=0;u<r;u++)l=n.get(c,u)-e,s+=l,a+=l*l;return t?(a-s*s/o)/(o-1):(a-s*s/o)/o}(this,i,r);default:throw new Error(`invalid option: ${t}`)}}standardDeviation(t,e){"object"==typeof t&&(e=t,t=void 0);let i=this.variance(t,e);if(void 0===t)return Math.sqrt(i);for(let r=0;r<i.length;r++)i[r]=Math.sqrt(i[r]);return i}center(t,e={}){if("object"==typeof t&&(e=t,t=void 0),"object"!=typeof e)throw new TypeError("options must be an object");let{center:i=this.mean(t)}=e;switch(t){case"row":if(!Array.isArray(i))throw new TypeError("center must be an array");return function(n,t){for(let e=0;e<n.rows;e++)for(let i=0;i<n.columns;i++)n.set(e,i,n.get(e,i)-t[e])}(this,i),this;case"column":if(!Array.isArray(i))throw new TypeError("center must be an array");return function(n,t){for(let e=0;e<n.rows;e++)for(let i=0;i<n.columns;i++)n.set(e,i,n.get(e,i)-t[i])}(this,i),this;case void 0:if("number"!=typeof i)throw new TypeError("center must be a number");return function(n,t){for(let e=0;e<n.rows;e++)for(let i=0;i<n.columns;i++)n.set(e,i,n.get(e,i)-t)}(this,i),this;default:throw new Error(`invalid option: ${t}`)}}scale(t,e={}){if("object"==typeof t&&(e=t,t=void 0),"object"!=typeof e)throw new TypeError("options must be an object");let i=e.scale;switch(t){case"row":if(void 0===i)i=function(n){let t=[];for(let e=0;e<n.rows;e++){let i=0;for(let r=0;r<n.columns;r++)i+=Math.pow(n.get(e,r),2)/(n.columns-1);t.push(Math.sqrt(i))}return t}(this);else if(!Array.isArray(i))throw new TypeError("scale must be an array");return function(n,t){for(let e=0;e<n.rows;e++)for(let i=0;i<n.columns;i++)n.set(e,i,n.get(e,i)/t[e])}(this,i),this;case"column":if(void 0===i)i=function(n){let t=[];for(let e=0;e<n.columns;e++){let i=0;for(let r=0;r<n.rows;r++)i+=Math.pow(n.get(r,e),2)/(n.rows-1);t.push(Math.sqrt(i))}return t}(this);else if(!Array.isArray(i))throw new TypeError("scale must be an array");return function(n,t){for(let e=0;e<n.rows;e++)for(let i=0;i<n.columns;i++)n.set(e,i,n.get(e,i)/t[i])}(this,i),this;case void 0:if(void 0===i)i=function(n){let t=n.size-1,e=0;for(let i=0;i<n.columns;i++)for(let r=0;r<n.rows;r++)e+=Math.pow(n.get(r,i),2)/t;return Math.sqrt(e)}(this);else if("number"!=typeof i)throw new TypeError("scale must be a number");return function(n,t){for(let e=0;e<n.rows;e++)for(let i=0;i<n.columns;i++)n.set(e,i,n.get(e,i)/t)}(this,i),this;default:throw new Error(`invalid option: ${t}`)}}toString(t){return o6(this,t)}},ti.prototype.klass="Matrix",typeof Symbol<"u"&&(ti.prototype[Symbol.for("nodejs.util.inspect.custom")]=rfe),ti.random=ti.rand,ti.randomInt=ti.randInt,ti.diagonal=ti.diag,ti.prototype.diagonal=ti.prototype.diag,ti.identity=ti.eye,ti.prototype.negate=ti.prototype.neg,ti.prototype.tensorProduct=ti.prototype.kroneckerProduct,rn=class extends ti{constructor(t,e){if(super(),rn.isMatrix(t))return t.clone();if(Number.isInteger(t)&&t>=0){if(this.data=[],!(Number.isInteger(e)&&e>=0))throw new TypeError("nColumns must be a positive integer");for(let i=0;i<t;i++)this.data.push(new Float64Array(e))}else{if(!Array.isArray(t))throw new TypeError("First argument must be a positive number or an array");{let i=t;if("number"!=typeof(e=(t=i.length)?i[0].length:0))throw new TypeError("Data must be a 2D array with at least one element");this.data=[];for(let r=0;r<t;r++){if(i[r].length!==e)throw new RangeError("Inconsistent array dimensions");this.data.push(Float64Array.from(i[r]))}}}this.rows=t,this.columns=e}set(t,e,i){return this.data[t][e]=i,this}get(t,e){return this.data[t][e]}removeRow(t){return gc(this,t),this.data.splice(t,1),this.rows-=1,this}addRow(t,e){return void 0===e&&(e=t,t=this.rows),gc(this,t,!0),e=Float64Array.from(n0(this,e)),this.data.splice(t,0,e),this.rows+=1,this}removeColumn(t){_c(this,t);for(let e=0;e<this.rows;e++){let i=new Float64Array(this.columns-1);for(let r=0;r<t;r++)i[r]=this.data[e][r];for(let r=t+1;r<this.columns;r++)i[r-1]=this.data[e][r];this.data[e]=i}return this.columns-=1,this}addColumn(t,e){typeof e>"u"&&(e=t,t=this.columns),_c(this,t,!0),e=i0(this,e);for(let i=0;i<this.rows;i++){let r=new Float64Array(this.columns+1),o=0;for(;o<t;o++)r[o]=this.data[i][o];for(r[o++]=e[i];o<this.columns+1;o++)r[o]=this.data[i][o-1];this.data[i]=r}return this.columns+=1,this}},t=rn,(n=ti).prototype.add=function(i){return"number"==typeof i?this.addS(i):this.addM(i)},n.prototype.addS=function(i){for(let r=0;r<this.rows;r++)for(let o=0;o<this.columns;o++)this.set(r,o,this.get(r,o)+i);return this},n.prototype.addM=function(i){if(i=t.checkMatrix(i),this.rows!==i.rows||this.columns!==i.columns)throw new RangeError("Matrices dimensions must be equal");for(let r=0;r<this.rows;r++)for(let o=0;o<this.columns;o++)this.set(r,o,this.get(r,o)+i.get(r,o));return this},n.add=function(i,r){return new t(i).add(r)},n.prototype.sub=function(i){return"number"==typeof i?this.subS(i):this.subM(i)},n.prototype.subS=function(i){for(let r=0;r<this.rows;r++)for(let o=0;o<this.columns;o++)this.set(r,o,this.get(r,o)-i);return this},n.prototype.subM=function(i){if(i=t.checkMatrix(i),this.rows!==i.rows||this.columns!==i.columns)throw new RangeError("Matrices dimensions must be equal");for(let r=0;r<this.rows;r++)for(let o=0;o<this.columns;o++)this.set(r,o,this.get(r,o)-i.get(r,o));return this},n.sub=function(i,r){return new t(i).sub(r)},n.prototype.subtract=n.prototype.sub,n.prototype.subtractS=n.prototype.subS,n.prototype.subtractM=n.prototype.subM,n.subtract=n.sub,n.prototype.mul=function(i){return"number"==typeof i?this.mulS(i):this.mulM(i)},n.prototype.mulS=function(i){for(let r=0;r<this.rows;r++)for(let o=0;o<this.columns;o++)this.set(r,o,this.get(r,o)*i);return this},n.prototype.mulM=function(i){if(i=t.checkMatrix(i),this.rows!==i.rows||this.columns!==i.columns)throw new RangeError("Matrices dimensions must be equal");for(let r=0;r<this.rows;r++)for(let o=0;o<this.columns;o++)this.set(r,o,this.get(r,o)*i.get(r,o));return this},n.mul=function(i,r){return new t(i).mul(r)},n.prototype.multiply=n.prototype.mul,n.prototype.multiplyS=n.prototype.mulS,n.prototype.multiplyM=n.prototype.mulM,n.multiply=n.mul,n.prototype.div=function(i){return"number"==typeof i?this.divS(i):this.divM(i)},n.prototype.divS=function(i){for(let r=0;r<this.rows;r++)for(let o=0;o<this.columns;o++)this.set(r,o,this.get(r,o)/i);return this},n.prototype.divM=function(i){if(i=t.checkMatrix(i),this.rows!==i.rows||this.columns!==i.columns)throw new RangeError("Matrices dimensions must be equal");for(let r=0;r<this.rows;r++)for(let o=0;o<this.columns;o++)this.set(r,o,this.get(r,o)/i.get(r,o));return this},n.div=function(i,r){return new t(i).div(r)},n.prototype.divide=n.prototype.div,n.prototype.divideS=n.prototype.divS,n.prototype.divideM=n.prototype.divM,n.divide=n.div,n.prototype.mod=function(i){return"number"==typeof i?this.modS(i):this.modM(i)},n.prototype.modS=function(i){for(let r=0;r<this.rows;r++)for(let o=0;o<this.columns;o++)this.set(r,o,this.get(r,o)%i);return this},n.prototype.modM=function(i){if(i=t.checkMatrix(i),this.rows!==i.rows||this.columns!==i.columns)throw new RangeError("Matrices dimensions must be equal");for(let r=0;r<this.rows;r++)for(let o=0;o<this.columns;o++)this.set(r,o,this.get(r,o)%i.get(r,o));return this},n.mod=function(i,r){return new t(i).mod(r)},n.prototype.modulus=n.prototype.mod,n.prototype.modulusS=n.prototype.modS,n.prototype.modulusM=n.prototype.modM,n.modulus=n.mod,n.prototype.and=function(i){return"number"==typeof i?this.andS(i):this.andM(i)},n.prototype.andS=function(i){for(let r=0;r<this.rows;r++)for(let o=0;o<this.columns;o++)this.set(r,o,this.get(r,o)&i);return this},n.prototype.andM=function(i){if(i=t.checkMatrix(i),this.rows!==i.rows||this.columns!==i.columns)throw new RangeError("Matrices dimensions must be equal");for(let r=0;r<this.rows;r++)for(let o=0;o<this.columns;o++)this.set(r,o,this.get(r,o)&i.get(r,o));return this},n.and=function(i,r){return new t(i).and(r)},n.prototype.or=function(i){return"number"==typeof i?this.orS(i):this.orM(i)},n.prototype.orS=function(i){for(let r=0;r<this.rows;r++)for(let o=0;o<this.columns;o++)this.set(r,o,this.get(r,o)|i);return this},n.prototype.orM=function(i){if(i=t.checkMatrix(i),this.rows!==i.rows||this.columns!==i.columns)throw new RangeError("Matrices dimensions must be equal");for(let r=0;r<this.rows;r++)for(let o=0;o<this.columns;o++)this.set(r,o,this.get(r,o)|i.get(r,o));return this},n.or=function(i,r){return new t(i).or(r)},n.prototype.xor=function(i){return"number"==typeof i?this.xorS(i):this.xorM(i)},n.prototype.xorS=function(i){for(let r=0;r<this.rows;r++)for(let o=0;o<this.columns;o++)this.set(r,o,this.get(r,o)^i);return this},n.prototype.xorM=function(i){if(i=t.checkMatrix(i),this.rows!==i.rows||this.columns!==i.columns)throw new RangeError("Matrices dimensions must be equal");for(let r=0;r<this.rows;r++)for(let o=0;o<this.columns;o++)this.set(r,o,this.get(r,o)^i.get(r,o));return this},n.xor=function(i,r){return new t(i).xor(r)},n.prototype.leftShift=function(i){return"number"==typeof i?this.leftShiftS(i):this.leftShiftM(i)},n.prototype.leftShiftS=function(i){for(let r=0;r<this.rows;r++)for(let o=0;o<this.columns;o++)this.set(r,o,this.get(r,o)<<i);return this},n.prototype.leftShiftM=function(i){if(i=t.checkMatrix(i),this.rows!==i.rows||this.columns!==i.columns)throw new RangeError("Matrices dimensions must be equal");for(let r=0;r<this.rows;r++)for(let o=0;o<this.columns;o++)this.set(r,o,this.get(r,o)<<i.get(r,o));return this},n.leftShift=function(i,r){return new t(i).leftShift(r)},n.prototype.signPropagatingRightShift=function(i){return"number"==typeof i?this.signPropagatingRightShiftS(i):this.signPropagatingRightShiftM(i)},n.prototype.signPropagatingRightShiftS=function(i){for(let r=0;r<this.rows;r++)for(let o=0;o<this.columns;o++)this.set(r,o,this.get(r,o)>>i);return this},n.prototype.signPropagatingRightShiftM=function(i){if(i=t.checkMatrix(i),this.rows!==i.rows||this.columns!==i.columns)throw new RangeError("Matrices dimensions must be equal");for(let r=0;r<this.rows;r++)for(let o=0;o<this.columns;o++)this.set(r,o,this.get(r,o)>>i.get(r,o));return this},n.signPropagatingRightShift=function(i,r){return new t(i).signPropagatingRightShift(r)},n.prototype.rightShift=function(i){return"number"==typeof i?this.rightShiftS(i):this.rightShiftM(i)},n.prototype.rightShiftS=function(i){for(let r=0;r<this.rows;r++)for(let o=0;o<this.columns;o++)this.set(r,o,this.get(r,o)>>>i);return this},n.prototype.rightShiftM=function(i){if(i=t.checkMatrix(i),this.rows!==i.rows||this.columns!==i.columns)throw new RangeError("Matrices dimensions must be equal");for(let r=0;r<this.rows;r++)for(let o=0;o<this.columns;o++)this.set(r,o,this.get(r,o)>>>i.get(r,o));return this},n.rightShift=function(i,r){return new t(i).rightShift(r)},n.prototype.zeroFillRightShift=n.prototype.rightShift,n.prototype.zeroFillRightShiftS=n.prototype.rightShiftS,n.prototype.zeroFillRightShiftM=n.prototype.rightShiftM,n.zeroFillRightShift=n.rightShift,n.prototype.not=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,~this.get(i,r));return this},n.not=function(i){return new t(i).not()},n.prototype.abs=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.abs(this.get(i,r)));return this},n.abs=function(i){return new t(i).abs()},n.prototype.acos=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.acos(this.get(i,r)));return this},n.acos=function(i){return new t(i).acos()},n.prototype.acosh=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.acosh(this.get(i,r)));return this},n.acosh=function(i){return new t(i).acosh()},n.prototype.asin=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.asin(this.get(i,r)));return this},n.asin=function(i){return new t(i).asin()},n.prototype.asinh=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.asinh(this.get(i,r)));return this},n.asinh=function(i){return new t(i).asinh()},n.prototype.atan=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.atan(this.get(i,r)));return this},n.atan=function(i){return new t(i).atan()},n.prototype.atanh=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.atanh(this.get(i,r)));return this},n.atanh=function(i){return new t(i).atanh()},n.prototype.cbrt=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.cbrt(this.get(i,r)));return this},n.cbrt=function(i){return new t(i).cbrt()},n.prototype.ceil=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.ceil(this.get(i,r)));return this},n.ceil=function(i){return new t(i).ceil()},n.prototype.clz32=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.clz32(this.get(i,r)));return this},n.clz32=function(i){return new t(i).clz32()},n.prototype.cos=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.cos(this.get(i,r)));return this},n.cos=function(i){return new t(i).cos()},n.prototype.cosh=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.cosh(this.get(i,r)));return this},n.cosh=function(i){return new t(i).cosh()},n.prototype.exp=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.exp(this.get(i,r)));return this},n.exp=function(i){return new t(i).exp()},n.prototype.expm1=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.expm1(this.get(i,r)));return this},n.expm1=function(i){return new t(i).expm1()},n.prototype.floor=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.floor(this.get(i,r)));return this},n.floor=function(i){return new t(i).floor()},n.prototype.fround=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.fround(this.get(i,r)));return this},n.fround=function(i){return new t(i).fround()},n.prototype.log=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.log(this.get(i,r)));return this},n.log=function(i){return new t(i).log()},n.prototype.log1p=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.log1p(this.get(i,r)));return this},n.log1p=function(i){return new t(i).log1p()},n.prototype.log10=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.log10(this.get(i,r)));return this},n.log10=function(i){return new t(i).log10()},n.prototype.log2=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.log2(this.get(i,r)));return this},n.log2=function(i){return new t(i).log2()},n.prototype.round=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.round(this.get(i,r)));return this},n.round=function(i){return new t(i).round()},n.prototype.sign=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.sign(this.get(i,r)));return this},n.sign=function(i){return new t(i).sign()},n.prototype.sin=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.sin(this.get(i,r)));return this},n.sin=function(i){return new t(i).sin()},n.prototype.sinh=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.sinh(this.get(i,r)));return this},n.sinh=function(i){return new t(i).sinh()},n.prototype.sqrt=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.sqrt(this.get(i,r)));return this},n.sqrt=function(i){return new t(i).sqrt()},n.prototype.tan=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.tan(this.get(i,r)));return this},n.tan=function(i){return new t(i).tan()},n.prototype.tanh=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.tanh(this.get(i,r)));return this},n.tanh=function(i){return new t(i).tanh()},n.prototype.trunc=function(){for(let i=0;i<this.rows;i++)for(let r=0;r<this.columns;r++)this.set(i,r,Math.trunc(this.get(i,r)));return this},n.trunc=function(i){return new t(i).trunc()},n.pow=function(i,r){return new t(i).pow(r)},n.prototype.pow=function(i){return"number"==typeof i?this.powS(i):this.powM(i)},n.prototype.powS=function(i){for(let r=0;r<this.rows;r++)for(let o=0;o<this.columns;o++)this.set(r,o,Math.pow(this.get(r,o),i));return this},n.prototype.powM=function(i){if(i=t.checkMatrix(i),this.rows!==i.rows||this.columns!==i.columns)throw new RangeError("Matrices dimensions must be equal");for(let r=0;r<this.rows;r++)for(let o=0;o<this.columns;o++)this.set(r,o,Math.pow(this.get(r,o),i.get(r,o)));return this}}),Afe=ho(()=>{}),DE=ho(()=>{o0(),Al=class extends ti{constructor(t){super(),this.data=t,this.rows=t.length,this.columns=t[0].length}set(t,e,i){return this.data[t][e]=i,this}get(t,e){return this.data[t][e]}}}),Ife=ho(()=>{o0(),DE(),AE=class{constructor(t){let a,l,c,u,d,p,h,f,m,e=(t=Al.checkMatrix(t)).clone(),i=e.rows,r=e.columns,o=new Float64Array(i),s=1;for(a=0;a<i;a++)o[a]=a;for(f=new Float64Array(i),l=0;l<r;l++){for(a=0;a<i;a++)f[a]=e.get(a,l);for(a=0;a<i;a++){for(m=Math.min(a,l),d=0,c=0;c<m;c++)d+=e.get(a,c)*f[c];f[a]-=d,e.set(a,l,f[a])}for(u=l,a=l+1;a<i;a++)Math.abs(f[a])>Math.abs(f[u])&&(u=a);if(u!==l){for(c=0;c<r;c++)p=e.get(u,c),e.set(u,c,e.get(l,c)),e.set(l,c,p);h=o[u],o[u]=o[l],o[l]=h,s=-s}if(l<i&&0!==e.get(l,l))for(a=l+1;a<i;a++)e.set(a,l,e.get(a,l)/e.get(l,l))}this.LU=e,this.pivotVector=o,this.pivotSign=s}isSingular(){let t=this.LU,e=t.columns;for(let i=0;i<e;i++)if(0===t.get(i,i))return!0;return!1}solve(t){t=rn.checkMatrix(t);let e=this.LU;if(e.rows!==t.rows)throw new Error("Invalid matrix dimensions");if(this.isSingular())throw new Error("LU matrix is singular");let a,l,c,r=t.columns,o=t.subMatrixRow(this.pivotVector,0,r-1),s=e.columns;for(c=0;c<s;c++)for(a=c+1;a<s;a++)for(l=0;l<r;l++)o.set(a,l,o.get(a,l)-o.get(c,l)*e.get(a,c));for(c=s-1;c>=0;c--){for(l=0;l<r;l++)o.set(c,l,o.get(c,l)/e.get(c,c));for(a=0;a<c;a++)for(l=0;l<r;l++)o.set(a,l,o.get(a,l)-o.get(c,l)*e.get(a,c))}return o}get determinant(){let t=this.LU;if(!t.isSquare())throw new Error("Matrix must be square");let e=this.pivotSign,i=t.columns;for(let r=0;r<i;r++)e*=t.get(r,r);return e}get lowerTriangularMatrix(){let t=this.LU,e=t.rows,i=t.columns,r=new rn(e,i);for(let o=0;o<e;o++)for(let s=0;s<i;s++)r.set(o,s,o>s?t.get(o,s):o===s?1:0);return r}get upperTriangularMatrix(){let t=this.LU,e=t.rows,i=t.columns,r=new rn(e,i);for(let o=0;o<e;o++)for(let s=0;s<i;s++)r.set(o,s,o<=s?t.get(o,s):0);return r}get pivotPermutationVector(){return Array.from(this.pivotVector)}}});function Op(n,t){let e=0;return Math.abs(n)>Math.abs(t)?(e=t/n,Math.abs(n)*Math.sqrt(1+e*e)):0!==t?(e=n/t,Math.abs(t)*Math.sqrt(1+e*e)):0}var IE,zb,l6=ho(()=>{}),Pfe=ho(()=>{o0(),DE(),l6(),IE=class{constructor(t){let s,a,l,c,e=(t=Al.checkMatrix(t)).clone(),i=t.rows,r=t.columns,o=new Float64Array(r);for(l=0;l<r;l++){let u=0;for(s=l;s<i;s++)u=Op(u,e.get(s,l));if(0!==u){for(e.get(l,l)<0&&(u=-u),s=l;s<i;s++)e.set(s,l,e.get(s,l)/u);for(e.set(l,l,e.get(l,l)+1),a=l+1;a<r;a++){for(c=0,s=l;s<i;s++)c+=e.get(s,l)*e.get(s,a);for(c=-c/e.get(l,l),s=l;s<i;s++)e.set(s,a,e.get(s,a)+c*e.get(s,l))}}o[l]=-u}this.QR=e,this.Rdiag=o}solve(t){t=rn.checkMatrix(t);let e=this.QR,i=e.rows;if(t.rows!==i)throw new Error("Matrix row dimensions must agree");if(!this.isFullRank())throw new Error("Matrix is rank deficient");let a,l,c,u,r=t.columns,o=t.clone(),s=e.columns;for(c=0;c<s;c++)for(l=0;l<r;l++){for(u=0,a=c;a<i;a++)u+=e.get(a,c)*o.get(a,l);for(u=-u/e.get(c,c),a=c;a<i;a++)o.set(a,l,o.get(a,l)+u*e.get(a,c))}for(c=s-1;c>=0;c--){for(l=0;l<r;l++)o.set(c,l,o.get(c,l)/this.Rdiag[c]);for(a=0;a<c;a++)for(l=0;l<r;l++)o.set(a,l,o.get(a,l)-o.get(c,l)*e.get(a,c))}return o.subMatrix(0,s-1,0,r-1)}isFullRank(){let t=this.QR.columns;for(let e=0;e<t;e++)if(0===this.Rdiag[e])return!1;return!0}get upperTriangularMatrix(){let r,o,t=this.QR,e=t.columns,i=new rn(e,e);for(r=0;r<e;r++)for(o=0;o<e;o++)i.set(r,o,r<o?t.get(r,o):r===o?this.Rdiag[r]:0);return i}get orthogonalMatrix(){let o,s,a,l,t=this.QR,e=t.rows,i=t.columns,r=new rn(e,i);for(a=i-1;a>=0;a--){for(o=0;o<e;o++)r.set(o,a,0);for(r.set(a,a,1),s=a;s<i;s++)if(0!==t.get(a,a)){for(l=0,o=a;o<e;o++)l+=t.get(o,a)*r.get(o,s);for(l=-l/t.get(a,a),o=a;o<e;o++)r.set(o,s,r.get(o,s)+l*t.get(o,a))}}return r}}}),Rfe=ho(()=>{o0(),DE(),l6(),zb=class{constructor(t,e={}){if((t=Al.checkMatrix(t)).isEmpty())throw new Error("Matrix must be non-empty");let d,i=t.rows,r=t.columns,{computeLeftSingularVectors:o=!0,computeRightSingularVectors:s=!0,autoTranspose:a=!1}=e,l=Boolean(o),c=Boolean(s),u=!1;if(i<r)if(a){d=t.transpose(),i=d.rows,r=d.columns,u=!0;let w=l;l=c,c=w}else d=t.clone(),console.warn("Computing SVD on a matrix with more columns than rows. Consider enabling autoTranspose");else d=t.clone();let p=Math.min(i,r),h=Math.min(i+1,r),f=new Float64Array(h),m=new rn(i,p),x=new rn(r,r),g=new Float64Array(r),b=new Float64Array(i),D=new Float64Array(h);for(let w=0;w<h;w++)D[w]=w;let T=Math.min(i-1,r),k=Math.max(0,Math.min(r-2,i)),Z=Math.max(T,k);for(let w=0;w<Z;w++){if(w<T){f[w]=0;for(let F=w;F<i;F++)f[w]=Op(f[w],d.get(F,w));if(0!==f[w]){d.get(w,w)<0&&(f[w]=-f[w]);for(let F=w;F<i;F++)d.set(F,w,d.get(F,w)/f[w]);d.set(w,w,d.get(w,w)+1)}f[w]=-f[w]}for(let F=w+1;F<r;F++){if(w<T&&0!==f[w]){let q=0;for(let K=w;K<i;K++)q+=d.get(K,w)*d.get(K,F);q=-q/d.get(w,w);for(let K=w;K<i;K++)d.set(K,F,d.get(K,F)+q*d.get(K,w))}g[F]=d.get(w,F)}if(l&&w<T)for(let F=w;F<i;F++)m.set(F,w,d.get(F,w));if(w<k){g[w]=0;for(let F=w+1;F<r;F++)g[w]=Op(g[w],g[F]);if(0!==g[w]){g[w+1]<0&&(g[w]=0-g[w]);for(let F=w+1;F<r;F++)g[F]/=g[w];g[w+1]+=1}if(g[w]=-g[w],w+1<i&&0!==g[w]){for(let F=w+1;F<i;F++)b[F]=0;for(let F=w+1;F<i;F++)for(let q=w+1;q<r;q++)b[F]+=g[q]*d.get(F,q);for(let F=w+1;F<r;F++){let q=-g[F]/g[w+1];for(let K=w+1;K<i;K++)d.set(K,F,d.get(K,F)+q*b[K])}}if(c)for(let F=w+1;F<r;F++)x.set(F,w,g[F])}}let z=Math.min(r,i+1);if(T<r&&(f[T]=d.get(T,T)),i<z&&(f[z-1]=0),k+1<z&&(g[k]=d.get(k,z-1)),g[z-1]=0,l){for(let w=T;w<p;w++){for(let F=0;F<i;F++)m.set(F,w,0);m.set(w,w,1)}for(let w=T-1;w>=0;w--)if(0!==f[w]){for(let F=w+1;F<p;F++){let q=0;for(let K=w;K<i;K++)q+=m.get(K,w)*m.get(K,F);q=-q/m.get(w,w);for(let K=w;K<i;K++)m.set(K,F,m.get(K,F)+q*m.get(K,w))}for(let F=w;F<i;F++)m.set(F,w,-m.get(F,w));m.set(w,w,1+m.get(w,w));for(let F=0;F<w-1;F++)m.set(F,w,0)}else{for(let F=0;F<i;F++)m.set(F,w,0);m.set(w,w,1)}}if(c)for(let w=r-1;w>=0;w--){if(w<k&&0!==g[w])for(let F=w+1;F<r;F++){let q=0;for(let K=w+1;K<r;K++)q+=x.get(K,w)*x.get(K,F);q=-q/x.get(w+1,w);for(let K=w+1;K<r;K++)x.set(K,F,x.get(K,F)+q*x.get(K,w))}for(let F=0;F<r;F++)x.set(F,w,0);x.set(w,w,1)}let fe=z-1,ue=0,he=Number.EPSILON;for(;z>0;){let w,F;for(w=z-2;w>=-1&&-1!==w;w--){let q=Number.MIN_VALUE+he*Math.abs(f[w]+Math.abs(f[w+1]));if(Math.abs(g[w])<=q||Number.isNaN(g[w])){g[w]=0;break}}if(w===z-2)F=4;else{let q;for(q=z-1;q>=w&&q!==w;q--){let K=(q!==z?Math.abs(g[q]):0)+(q!==w+1?Math.abs(g[q-1]):0);if(Math.abs(f[q])<=he*K){f[q]=0;break}}q===w?F=3:q===z-1?F=1:(F=2,w=q)}switch(w++,F){case 1:{let q=g[z-2];g[z-2]=0;for(let K=z-2;K>=w;K--){let de=Op(f[K],q),Y=f[K]/de,ae=q/de;if(f[K]=de,K!==w&&(q=-ae*g[K-1],g[K-1]=Y*g[K-1]),c)for(let le=0;le<r;le++)de=Y*x.get(le,K)+ae*x.get(le,z-1),x.set(le,z-1,-ae*x.get(le,K)+Y*x.get(le,z-1)),x.set(le,K,de)}break}case 2:{let q=g[w-1];g[w-1]=0;for(let K=w;K<z;K++){let de=Op(f[K],q),Y=f[K]/de,ae=q/de;if(f[K]=de,q=-ae*g[K],g[K]=Y*g[K],l)for(let le=0;le<i;le++)de=Y*m.get(le,K)+ae*m.get(le,w-1),m.set(le,w-1,-ae*m.get(le,K)+Y*m.get(le,w-1)),m.set(le,K,de)}break}case 3:{let q=Math.max(Math.abs(f[z-1]),Math.abs(f[z-2]),Math.abs(g[z-2]),Math.abs(f[w]),Math.abs(g[w])),K=f[z-1]/q,de=f[z-2]/q,Y=g[z-2]/q,ae=f[w]/q,le=g[w]/q,Ie=((de+K)*(de-K)+Y*Y)/2,ve=K*Y*(K*Y),De=0;(0!==Ie||0!==ve)&&(De=Ie<0?0-Math.sqrt(Ie*Ie+ve):Math.sqrt(Ie*Ie+ve),De=ve/(Ie+De));let nt=(ae+K)*(ae-K)+De,gt=ae*le;for(let Ue=w;Ue<z-1;Ue++){let Ae=Op(nt,gt);0===Ae&&(Ae=Number.MIN_VALUE);let tn=nt/Ae,pt=gt/Ae;if(Ue!==w&&(g[Ue-1]=Ae),nt=tn*f[Ue]+pt*g[Ue],g[Ue]=tn*g[Ue]-pt*f[Ue],gt=pt*f[Ue+1],f[Ue+1]=tn*f[Ue+1],c)for(let wt=0;wt<r;wt++)Ae=tn*x.get(wt,Ue)+pt*x.get(wt,Ue+1),x.set(wt,Ue+1,-pt*x.get(wt,Ue)+tn*x.get(wt,Ue+1)),x.set(wt,Ue,Ae);if(Ae=Op(nt,gt),0===Ae&&(Ae=Number.MIN_VALUE),tn=nt/Ae,pt=gt/Ae,f[Ue]=Ae,nt=tn*g[Ue]+pt*f[Ue+1],f[Ue+1]=-pt*g[Ue]+tn*f[Ue+1],gt=pt*g[Ue+1],g[Ue+1]=tn*g[Ue+1],l&&Ue<i-1)for(let wt=0;wt<i;wt++)Ae=tn*m.get(wt,Ue)+pt*m.get(wt,Ue+1),m.set(wt,Ue+1,-pt*m.get(wt,Ue)+tn*m.get(wt,Ue+1)),m.set(wt,Ue,Ae)}g[z-2]=nt,ue+=1;break}case 4:if(f[w]<=0&&(f[w]=f[w]<0?-f[w]:0,c))for(let q=0;q<=fe;q++)x.set(q,w,-x.get(q,w));for(;w<fe&&!(f[w]>=f[w+1]);){let q=f[w];if(f[w]=f[w+1],f[w+1]=q,c&&w<r-1)for(let K=0;K<r;K++)q=x.get(K,w+1),x.set(K,w+1,x.get(K,w)),x.set(K,w,q);if(l&&w<i-1)for(let K=0;K<i;K++)q=m.get(K,w+1),m.set(K,w+1,m.get(K,w)),m.set(K,w,q);w++}ue=0,z--}}if(u){let w=x;x=m,m=w}this.m=i,this.n=r,this.s=f,this.U=m,this.V=x}solve(t){let e=t,i=this.threshold,r=this.s.length,o=rn.zeros(r,r);for(let p=0;p<r;p++)Math.abs(this.s[p])<=i?o.set(p,p,0):o.set(p,p,1/this.s[p]);let s=this.U,a=this.rightSingularVectors,l=a.mmul(o),c=a.rows,u=s.rows,d=rn.zeros(c,u);for(let p=0;p<c;p++)for(let h=0;h<u;h++){let f=0;for(let m=0;m<r;m++)f+=l.get(p,m)*s.get(h,m);d.set(p,h,f)}return d.mmul(e)}solveForDiagonal(t){return this.solve(rn.diag(t))}inverse(){let t=this.V,e=this.threshold,i=t.rows,r=t.columns,o=new rn(i,this.s.length);for(let u=0;u<i;u++)for(let d=0;d<r;d++)Math.abs(this.s[d])>e&&o.set(u,d,t.get(u,d)/this.s[d]);let s=this.U,a=s.rows,l=s.columns,c=new rn(i,a);for(let u=0;u<i;u++)for(let d=0;d<a;d++){let p=0;for(let h=0;h<l;h++)p+=o.get(u,h)*s.get(d,h);c.set(u,d,p)}return c}get condition(){return this.s[0]/this.s[Math.min(this.m,this.n)-1]}get norm2(){return this.s[0]}get rank(){let t=Math.max(this.m,this.n)*this.s[0]*Number.EPSILON,e=0,i=this.s;for(let r=0,o=i.length;r<o;r++)i[r]>t&&e++;return e}get diagonal(){return Array.from(this.s)}get threshold(){return Number.EPSILON/2*Math.max(this.m,this.n)*this.s[0]}get leftSingularVectors(){return this.U}get rightSingularVectors(){return this.V}get diagonalMatrix(){return rn.diag(this.s)}}});var kfe=ho(()=>{Ife(),Pfe(),Rfe(),o0(),DE()}),Ffe=ho(()=>{o0(),Afe(),kfe()});function u6(n,t,e,i,r){let s=rn.eye(t.length,t.length,e*i*i),a=r(t),l=new Float64Array(n.x.length);for(let p=0;p<n.x.length;p++)l[p]=a(n.x[p]);let c=function(n,t,e,i,r){let o=e.length,s=n.x.length,a=new Array(o);for(let l=0;l<o;l++){a[l]=new Array(s);let c=e.slice();c[l]+=i;let u=r(c);for(let d=0;d<s;d++)a[l][d]=t[d]-u(n.x[d])}return new rn(a)}(n,l,t,i,r),u=function(n,t){let e=n.x.length,i=new Array(e);for(let r=0;r<e;r++)i[r]=[n.y[r]-t[r]];return new rn(i)}(n,l),d=function(n,t=!1){return n=Al.checkMatrix(n),t?new zb(n).inverse():function(n,t,e=!1){return n=Al.checkMatrix(n),t=Al.checkMatrix(t),e?new zb(n).solve(t):n.isSquare()?new AE(n).solve(t):new IE(n).solve(t)}(n,rn.eye(n.rows))}(s.add(c.mmul(c.transpose())));return(t=(t=new rn([t])).sub(d.mmul(c).mmul(u).mul(i).transpose())).to1DArray()}var Nfe=ho(()=>{Ffe()}),Bfe={};function Lfe(n,t,e={}){let{maxIterations:i=100,gradientDifference:r=.1,damping:o=0,errorTolerance:s=.01,minValues:a,maxValues:l,initialValues:c}=e;if(o<=0)throw new Error("The damping option must be a positive number");if(!n.x||!n.y)throw new Error("The data parameter must have x and y elements");if(!EE(n.x)||n.x.length<2||!EE(n.y)||n.y.length<2)throw new Error("The data parameter elements must be an array with more than 2 points");if(n.x.length!==n.y.length)throw new Error("The data parameter elements must have the same size");let u=c||new Array(t.length).fill(1),d=u.length;if(l=l||new Array(d).fill(Number.MAX_SAFE_INTEGER),a=a||new Array(d).fill(Number.MIN_SAFE_INTEGER),l.length!==a.length)throw new Error("minValues and maxValues must be the same size");if(!EE(u))throw new Error("initialValues must be an array");let f,p=pF(n,u,t),h=p<=s;for(f=0;f<i&&!h;f++){u=u6(n,u,o,r,t);for(let m=0;m<d;m++)u[m]=Math.min(Math.max(a[m],u[m]),l[m]);if(p=pF(n,u,t),isNaN(p))break;h=p<=s}return{parameterValues:u,parameterError:p,iterations:f}}BE(Bfe,{default:()=>Lfe});var Vfe=ho(()=>{Khe(),Zhe(),Nfe()}),Jfe=Rd(wo=>{"use strict";var Hfe=wo&&wo.__awaiter||function(n,t,e,i){return new(e||(e=Promise))(function(r,o){function s(c){try{l(i.next(c))}catch(u){o(u)}}function a(c){try{l(i.throw(c))}catch(u){o(u)}}function l(c){c.done?r(c.value):new e(function(u){u(c.value)}).then(s,a)}l((i=i.apply(n,t||[])).next())})},Ufe=wo&&wo.__generator||function(n,t){var i,r,o,s,e={label:0,sent:function(){if(1&o[0])throw o[1];return o[1]},trys:[],ops:[]};return s={next:a(0),throw:a(1),return:a(2)},"function"==typeof Symbol&&(s[Symbol.iterator]=function(){return this}),s;function a(c){return function(u){return function(c){if(i)throw new TypeError("Generator is already executing.");for(;e;)try{if(i=1,r&&(o=2&c[0]?r.return:c[0]?r.throw||((o=r.return)&&o.call(r),0):r.next)&&!(o=o.call(r,c[1])).done)return o;switch(r=0,o&&(c=[2&c[0],o.value]),c[0]){case 0:case 1:o=c;break;case 4:return e.label++,{value:c[1],done:!1};case 5:e.label++,r=c[1],c=[0];continue;case 7:c=e.ops.pop(),e.trys.pop();continue;default:if(!(o=(o=e.trys).length>0&&o[o.length-1])&&(6===c[0]||2===c[0])){e=0;continue}if(3===c[0]&&(!o||c[1]>o[0]&&c[1]<o[3])){e.label=c[1];break}if(6===c[0]&&e.label<o[1]){e.label=o[1],o=c;break}if(o&&e.label<o[2]){e.label=o[2],e.ops.push(c);break}o[2]&&e.ops.pop(),e.trys.pop();continue}c=t.call(n,e)}catch(u){c=[6,u],r=0}finally{i=o=0}if(5&c[0])throw c[1];return{value:c[0]?c[1]:void 0,done:!0}}([c,u])}}},d6=wo&&wo.__read||function(n,t){var e="function"==typeof Symbol&&n[Symbol.iterator];if(!e)return n;var r,s,i=e.call(n),o=[];try{for(;(void 0===t||t-- >0)&&!(r=i.next()).done;)o.push(r.value)}catch(a){s={error:a}}finally{try{r&&!r.done&&(e=i.return)&&e.call(i)}finally{if(s)throw s.error}}return o},zfe=wo&&wo.__spread||function(){for(var n=[],t=0;t<arguments.length;t++)n=n.concat(d6(arguments[t]));return n},PE=wo&&wo.__importStar||function(n){if(n&&n.__esModule)return n;var t={};if(null!=n)for(var e in n)Object.hasOwnProperty.call(n,e)&&(t[e]=n[e]);return t.default=n,t},B$e=wo&&wo.__importDefault||function(n){return n&&n.__esModule?n:{default:n}};Object.defineProperty(wo,"__esModule",{value:!0});var n,V$e=PE(ZG()),co=PE(JG()),gF=PE(Qhe()),jfe=PE(i6()),Mo=PE(Hb()),H$e=B$e((Vfe(),n=Bfe,I6(LE({},"__esModule",{value:!0}),n))),_F=.001,U$e=function(){function n(t){void 0===t&&(t={});var e=this;this.learningRate=1,this.localConnectivity=1,this.minDist=.1,this.nComponents=2,this.nEpochs=0,this.nNeighbors=15,this.negativeSampleRate=5,this.random=Math.random,this.repulsionStrength=1,this.setOpMixRatio=1,this.spread=1,this.transformQueueSize=4,this.targetMetric="categorical",this.targetWeight=.5,this.targetNNeighbors=this.nNeighbors,this.distanceFn=Yfe,this.isInitialized=!1,this.rpForest=[],this.embedding=[],this.optimizationState=new j$e;var i=function(r){void 0!==t[r]&&(e[r]=t[r])};i("distanceFn"),i("learningRate"),i("localConnectivity"),i("minDist"),i("nComponents"),i("nEpochs"),i("nNeighbors"),i("negativeSampleRate"),i("random"),i("repulsionStrength"),i("setOpMixRatio"),i("spread"),i("transformQueueSize")}return n.prototype.fit=function(t){return this.initializeFit(t),this.optimizeLayout(),this.embedding},n.prototype.fitAsync=function(t,e){return void 0===e&&(e=function(){return!0}),Hfe(this,void 0,void 0,function(){return Ufe(this,function(i){switch(i.label){case 0:return this.initializeFit(t),[4,this.optimizeLayoutAsync(e)];case 1:return i.sent(),[2,this.embedding]}})})},n.prototype.setSupervisedProjection=function(t,e){void 0===e&&(e={}),this.Y=t,this.targetMetric=e.targetMetric||this.targetMetric,this.targetWeight=e.targetWeight||this.targetWeight,this.targetNNeighbors=e.targetNNeighbors||this.targetNNeighbors},n.prototype.setPrecomputedKNN=function(t,e){this.knnIndices=t,this.knnDistances=e},n.prototype.initializeFit=function(t){if(t.length<=this.nNeighbors)throw new Error("Not enough data points ("+t.length+") to create nNeighbors: "+this.nNeighbors+".  Add more data points or adjust the configuration.");if(this.X===t&&this.isInitialized)return this.getNEpochs();if(this.X=t,!this.knnIndices&&!this.knnDistances){var e=this.nearestNeighbors(t);this.knnIndices=e.knnIndices,this.knnDistances=e.knnDistances}this.graph=this.fuzzySimplicialSet(t,this.nNeighbors,this.setOpMixRatio),this.makeSearchFns(),this.searchGraph=this.makeSearchGraph(t),this.processGraphForSupervisedProjection();var i=this.initializeSimplicialSetEmbedding(),o=i.tail,s=i.epochsPerSample;return this.optimizationState.head=i.head,this.optimizationState.tail=o,this.optimizationState.epochsPerSample=s,this.initializeOptimization(),this.prepareForOptimizationLoop(),this.isInitialized=!0,this.getNEpochs()},n.prototype.makeSearchFns=function(){var t=gF.makeInitializations(this.distanceFn),i=t.initFromRandom;this.initFromTree=t.initFromTree,this.initFromRandom=i,this.search=gF.makeInitializedNNSearch(this.distanceFn)},n.prototype.makeSearchGraph=function(t){for(var e=this.knnIndices,i=this.knnDistances,o=new co.SparseMatrix([],[],[],[t.length,t.length]),s=0;s<e.length;s++)for(var a=e[s],l=i[s],c=0;c<a.length;c++){var d=l[c];d>0&&o.set(s,a[c],d)}var p=co.transpose(o);return co.maximum(o,p)},n.prototype.transform=function(t){var e=this,i=this.X;if(void 0===i||0===i.length)throw new Error("No data has been fit.");var r=Math.floor(this.nNeighbors*this.transformQueueSize);r=Math.min(i.length,r);var o=gF.initializeSearch(this.rpForest,i,t,r,this.initFromRandom,this.initFromTree,this.random),s=this.search(i,this.searchGraph,o,t),a=V$e.deheapSort(s),l=a.indices,c=a.weights;l=l.map(function(de){return de.slice(0,e.nNeighbors)}),c=c.map(function(de){return de.slice(0,e.nNeighbors)});var u=Math.max(0,this.localConnectivity-1),d=this.smoothKNNDistance(c,this.nNeighbors,u),f=this.computeMembershipStrengths(l,c,d.sigmas,d.rhos),D=new co.SparseMatrix(f.rows,f.cols,f.vals,[t.length,i.length]),T=co.normalize(D,"l1"),k=co.getCSR(T),Z=t.length,ue=Zfe(Mo.reshape2d(k.indices,Z,this.nNeighbors),Mo.reshape2d(k.values,Z,this.nNeighbors),this.embedding),he=this.nEpochs?this.nEpochs/3:D.nRows<=1e4?100:30,w=D.getValues().reduce(function(de,Y){return Y>de?Y:de},0);D=D.map(function(de){return de<w/he?0:de}),D=co.eliminateZeros(D);var F=this.makeEpochsPerSample(D.getValues(),he),q=D.getRows(),K=D.getCols();return this.assignOptimizationStateParameters({headEmbedding:ue,tailEmbedding:this.embedding,head:q,tail:K,currentEpoch:0,nEpochs:he,nVertices:D.getDims()[1],epochsPerSample:F}),this.prepareForOptimizationLoop(),this.optimizeLayout()},n.prototype.processGraphForSupervisedProjection=function(){var e=this.Y;if(e){if(e.length!==this.X.length)throw new Error("Length of X and y must be equal");"categorical"===this.targetMetric&&(this.graph=this.categoricalSimplicialSetIntersection(this.graph,e,this.targetWeight<1?1/(1-this.targetWeight)*2.5:1e12))}},n.prototype.step=function(){var t=this.optimizationState.currentEpoch;return t<this.getNEpochs()&&this.optimizeLayoutStep(t),this.optimizationState.currentEpoch},n.prototype.getEmbedding=function(){return this.embedding},n.prototype.nearestNeighbors=function(t){var f,r=this.nNeighbors,s=gF.makeNNDescent(this.distanceFn,this.random),l=5+Math.floor(.5==(f=Math.pow(t.length,.5)/20)?0:Math.round(f)),c=Math.max(5,Math.floor(Math.round(function(f){return Math.log(f)/Math.log(2)}(t.length))));this.rpForest=jfe.makeForest(t,r,l,this.random);var d=s(t,jfe.makeLeafArray(this.rpForest),r,c);return{knnIndices:d.indices,knnDistances:d.weights}},n.prototype.fuzzySimplicialSet=function(t,e,i){void 0===i&&(i=1);var r=this,o=r.knnIndices,s=void 0===o?[]:o,a=r.knnDistances,l=void 0===a?[]:a,u=this.smoothKNNDistance(l,e,r.localConnectivity),h=this.computeMembershipStrengths(s,l,u.sigmas,u.rhos),b=new co.SparseMatrix(h.rows,h.cols,h.vals,[t.length,t.length]),D=co.transpose(b),T=co.pairwiseMultiply(b,D),k=co.subtract(co.add(b,D),T),Z=co.multiplyScalar(k,i),z=co.multiplyScalar(T,1-i);return co.add(Z,z)},n.prototype.categoricalSimplicialSetIntersection=function(t,e,i,r){void 0===r&&(r=1);var o=Qfe(t,e,r,i);return Kfe(o=co.eliminateZeros(o))},n.prototype.smoothKNNDistance=function(t,e,i,r,o){void 0===i&&(i=1),void 0===r&&(r=64),void 0===o&&(o=1);for(var s=Math.log(e)/Math.log(2)*o,a=Mo.zeros(t.length),l=Mo.zeros(t.length),c=0;c<t.length;c++){var u=0,d=1/0,p=1,h=t[c],f=h.filter(function(z){return z>0});if(f.length>=i){var m=Math.floor(i),x=i-m;m>0?(a[c]=f[m-1],x>1e-5&&(a[c]+=x*(f[m]-f[m-1]))):a[c]=x*f[0]}else f.length>0&&(a[c]=Mo.max(f));for(var g=0;g<r;g++){for(var b=0,D=1;D<t[c].length;D++){var T=t[c][D]-a[c];b+=T>0?Math.exp(-T/p):1}if(Math.abs(b-s)<1e-5)break;b>s?p=(u+(d=p))/2:(u=p,d===1/0?p*=2:p=(u+d)/2)}if(l[c]=p,a[c]>0){var k=Mo.mean(h);l[c]<_F*k&&(l[c]=_F*k)}else{var Z=Mo.mean(t.map(Mo.mean));l[c]<_F*Z&&(l[c]=_F*Z)}}return{sigmas:l,rhos:a}},n.prototype.computeMembershipStrengths=function(t,e,i,r){for(var o=t.length,s=t[0].length,a=Mo.zeros(o*s),l=Mo.zeros(o*s),c=Mo.zeros(o*s),u=0;u<o;u++)for(var d=0;d<s;d++){var p=0;-1!==t[u][d]&&(p=t[u][d]===u?0:e[u][d]-r[u]<=0?1:Math.exp(-(e[u][d]-r[u])/i[u]),a[u*s+d]=u,l[u*s+d]=t[u][d],c[u*s+d]=p)}return{rows:a,cols:l,vals:c}},n.prototype.initializeSimplicialSetEmbedding=function(){for(var t=this,e=this.getNEpochs(),i=this.nComponents,r=this.graph.getValues(),o=0,s=0;s<r.length;s++)o<r[s]&&(o=r[s]);var l=this.graph.map(function(m){return m<o/e?0:m});this.embedding=Mo.zeros(l.nRows).map(function(){return Mo.zeros(i).map(function(){return 20*Mo.tauRand(t.random)-10})});var c=[],u=[],d=[],p=l.getAll();for(s=0;s<p.length;s++){var h=p[s];h.value&&(c.push(h.value),d.push(h.row),u.push(h.col))}return{head:u,tail:d,epochsPerSample:this.makeEpochsPerSample(c,e)}},n.prototype.makeEpochsPerSample=function(t,e){var i=Mo.filled(t.length,-1),r=Mo.max(t),o=t.map(function(s){return s/r*e});return o.forEach(function(s,a){s>0&&(i[a]=e/o[a])}),i},n.prototype.assignOptimizationStateParameters=function(t){Object.assign(this.optimizationState,t)},n.prototype.prepareForOptimizationLoop=function(){var t=this,e=t.repulsionStrength,i=t.learningRate,r=t.negativeSampleRate,o=this.optimizationState,s=o.epochsPerSample,a=o.headEmbedding,c=a[0].length,u=a.length===o.tailEmbedding.length,d=s.map(function(f){return f/r}),p=zfe(d),h=zfe(s);this.assignOptimizationStateParameters({epochOfNextSample:h,epochOfNextNegativeSample:p,epochsPerNegativeSample:d,moveOther:u,initialAlpha:i,alpha:i,gamma:e,dim:c})},n.prototype.initializeOptimization=function(){var t=this.embedding,e=this.embedding,i=this.optimizationState,r=i.head,o=i.tail,s=i.epochsPerSample,a=this.getNEpochs(),l=this.graph.nCols,c=Xfe(this.spread,this.minDist);this.assignOptimizationStateParameters({headEmbedding:t,tailEmbedding:e,head:r,tail:o,epochsPerSample:s,a:c.a,b:c.b,nEpochs:a,nVertices:l})},n.prototype.optimizeLayoutStep=function(t){for(var e=this.optimizationState,i=e.head,r=e.tail,o=e.headEmbedding,s=e.tailEmbedding,a=e.epochsPerSample,l=e.epochOfNextSample,c=e.epochOfNextNegativeSample,u=e.epochsPerNegativeSample,d=e.moveOther,p=e.initialAlpha,h=e.alpha,f=e.gamma,m=e.a,x=e.b,g=e.dim,b=e.nEpochs,D=e.nVertices,k=0;k<a.length;k++)if(!(l[k]>t)){var Z=i[k],fe=o[Z],ue=s[r[k]],he=qfe(fe,ue),w=0;he>0&&(w=-2*m*x*Math.pow(he,x-1),w/=m*Math.pow(he,x)+1);for(var F=0;F<g;F++){var q=Wfe(w*(fe[F]-ue[F]),4);fe[F]+=q*h,d&&(ue[F]+=-q*h)}l[k]+=a[k];for(var K=Math.floor((t-c[k])/u[k]),de=0;de<K;de++){var Y=Mo.tauRandInt(D,this.random),ae=s[Y],le=qfe(fe,ae),Ie=0;if(le>0)Ie=2*f*x,Ie/=(.001+le)*(m*Math.pow(le,x)+1);else if(Z===Y)continue;for(F=0;F<g;F++)q=4,Ie>0&&(q=Wfe(Ie*(fe[F]-ae[F]),4)),fe[F]+=q*h}c[k]+=K*u[k]}return e.alpha=p*(1-t/b),e.currentEpoch+=1,o},n.prototype.optimizeLayoutAsync=function(t){var e=this;return void 0===t&&(t=function(){return!0}),new Promise(function(i,r){var o=function(){return Hfe(e,void 0,void 0,function(){var s,a,c,u,d;return Ufe(this,function(p){try{if(a=(s=this.optimizationState).nEpochs,this.embedding=this.optimizeLayoutStep(s.currentEpoch),u=!1===t(c=this.optimizationState.currentEpoch),d=c===a,u||d)return[2,i(d)];setTimeout(function(){return o()},0)}catch(h){r(h)}return[2]})})};setTimeout(function(){return o()},0)})},n.prototype.optimizeLayout=function(t){void 0===t&&(t=function(){return!0});for(var e=!1,i=[];!e;){var r=this.optimizationState,o=r.nEpochs;i=this.optimizeLayoutStep(r.currentEpoch);var a=this.optimizationState.currentEpoch,l=!1===t(a);e=a===o||l}return i},n.prototype.getNEpochs=function(){if(this.nEpochs>0)return this.nEpochs;var e=this.graph.nRows;return e<=2500?500:e<=5e3?400:e<=7500?300:200},n}();function Yfe(n,t){for(var e=0,i=0;i<n.length;i++)e+=Math.pow(n[i]-t[i],2);return Math.sqrt(e)}wo.UMAP=U$e,wo.euclidean=Yfe,wo.cosine=function(n,t){for(var e=0,i=0,r=0,o=0;o<n.length;o++)e+=n[o]*t[o],i+=Math.pow(n[o],2),r+=Math.pow(t[o],2);return 0===i&&0===r?0:0===i||0===r?1:1-e/Math.sqrt(i*r)};var j$e=function(){this.currentEpoch=0,this.headEmbedding=[],this.tailEmbedding=[],this.head=[],this.tail=[],this.epochsPerSample=[],this.epochOfNextSample=[],this.epochOfNextNegativeSample=[],this.epochsPerNegativeSample=[],this.moveOther=!0,this.initialAlpha=1,this.alpha=1,this.gamma=1,this.a=1.5769434603113077,this.b=.8950608779109733,this.dim=2,this.nEpochs=500,this.nVertices=0};function Wfe(n,t){return n>t?t:n<-t?-t:n}function qfe(n,t){for(var e=0,i=0;i<n.length;i++)e+=Math.pow(n[i]-t[i],2);return e}function Xfe(n,t){var i=Mo.linear(0,3*n,300).map(function(p){return p<t?1:p}),r=Mo.zeros(i.length).map(function(p,h){return i[h]>=t?Math.exp(-(i[h]-t)/n):p}),l=H$e.default({x:i,y:r},function(p){var h=d6(p,2),f=h[0],m=h[1];return function(x){return 1/(1+f*Math.pow(x,2*m))}},{damping:1.5,initialValues:[.5,.5],gradientDifference:.1,maxIterations:100,errorTolerance:.01}).parameterValues,c=d6(l,2);return{a:c[0],b:c[1]}}function Qfe(n,t,e,i){return void 0===e&&(e=1),void 0===i&&(i=5),n.map(function(r,o,s){return-1===t[o]||-1===t[s]?r*Math.exp(-e):t[o]!==t[s]?r*Math.exp(-i):r})}function Kfe(n){n=co.normalize(n,"max");var t=co.transpose(n),e=co.pairwiseMultiply(t,n);return n=co.add(n,co.subtract(t,e)),co.eliminateZeros(n)}function Zfe(n,t,e){for(var i=Mo.zeros(n.length).map(function(l){return Mo.zeros(e[0].length)}),r=0;r<n.length;r++)for(var o=0;o<n[0].length;o++)for(var s=0;s<e[0].length;s++)i[r][s]+=t[r][o]*e[n[r][o]][s];return i}wo.findABParams=Xfe,wo.fastIntersection=Qfe,wo.resetLocalConnectivity=Kfe,wo.initTransform=Zfe}),$fe=Rd(p6=>{"use strict";Object.defineProperty(p6,"__esModule",{value:!0});var G$e=Jfe();p6.UMAP=G$e.UMAP});function En(n){return"function"==typeof n}function c0(n){let e=n(i=>{Error.call(i),i.stack=(new Error).stack});return e.prototype=Object.create(Error.prototype),e.prototype.constructor=e,e}var VE=c0(n=>function(e){n(this),this.message=e?`${e.length} errors occurred during unsubscription:\n${e.map((i,r)=>`${r+1}) ${i.toString()}`).join("\n  ")}`:"",this.name="UnsubscriptionError",this.errors=e});function kf(n,t){if(n){let e=n.indexOf(t);0<=e&&n.splice(e,1)}}var Sn=class{constructor(t){this.initialTeardown=t,this.closed=!1,this._parentage=null,this._finalizers=null}unsubscribe(){let t;if(!this.closed){this.closed=!0;let{_parentage:e}=this;if(e)if(this._parentage=null,Array.isArray(e))for(let o of e)o.remove(this);else e.remove(this);let{initialTeardown:i}=this;if(En(i))try{i()}catch(o){t=o instanceof VE?o.errors:[o]}let{_finalizers:r}=this;if(r){this._finalizers=null;for(let o of r)try{P6(o)}catch(s){t=t??[],s instanceof VE?t=[...t,...s.errors]:t.push(s)}}if(t)throw new VE(t)}}add(t){var e;if(t&&t!==this)if(this.closed)P6(t);else{if(t instanceof Sn){if(t.closed||t._hasParent(this))return;t._addParent(this)}(this._finalizers=null!==(e=this._finalizers)&&void 0!==e?e:[]).push(t)}}_hasParent(t){let{_parentage:e}=this;return e===t||Array.isArray(e)&&e.includes(t)}_addParent(t){let{_parentage:e}=this;this._parentage=Array.isArray(e)?(e.push(t),e):e?[e,t]:t}_removeParent(t){let{_parentage:e}=this;e===t?this._parentage=null:Array.isArray(e)&&kf(e,t)}remove(t){let{_finalizers:e}=this;e&&kf(e,t),t instanceof Sn&&t._removeParent(this)}};Sn.EMPTY=(()=>{let n=new Sn;return n.closed=!0,n})();var sN=Sn.EMPTY;function HE(n){return n instanceof Sn||n&&"closed"in n&&En(n.remove)&&En(n.add)&&En(n.unsubscribe)}function P6(n){En(n)?n():n.unsubscribe()}var Cc={onUnhandledError:null,onStoppedNotification:null,Promise:void 0,useDeprecatedSynchronousErrorHandling:!1,useDeprecatedNextContext:!1},u0={setTimeout(n,t,...e){let{delegate:i}=u0;return i?.setTimeout?i.setTimeout(n,t,...e):setTimeout(n,t,...e)},clearTimeout(n){let{delegate:t}=u0;return(t?.clearTimeout||clearTimeout)(n)},delegate:void 0};function UE(n){u0.setTimeout(()=>{let{onUnhandledError:t}=Cc;if(!t)throw n;t(n)})}function Mc(){}var R6=aN("C",void 0,void 0);function aN(n,t,e){return{kind:n,value:t,error:e}}var Ff=null;function d0(n){if(Cc.useDeprecatedSynchronousErrorHandling){let t=!Ff;if(t&&(Ff={errorThrown:!1,error:null}),n(),t){let{errorThrown:e,error:i}=Ff;if(Ff=null,e)throw i}}else n()}var Nf=class extends Sn{constructor(t){super(),this.isStopped=!1,t?(this.destination=t,HE(t)&&t.add(this)):this.destination=s0e}static create(t,e,i){return new Od(t,e,i)}next(t){this.isStopped?cN(aN("N",t,void 0),this):this._next(t)}error(t){this.isStopped?cN(aN("E",void 0,t),this):(this.isStopped=!0,this._error(t))}complete(){this.isStopped?cN(R6,this):(this.isStopped=!0,this._complete())}unsubscribe(){this.closed||(this.isStopped=!0,super.unsubscribe(),this.destination=null)}_next(t){this.destination.next(t)}_error(t){try{this.destination.error(t)}finally{this.unsubscribe()}}_complete(){try{this.destination.complete()}finally{this.unsubscribe()}}},r0e=Function.prototype.bind;function lN(n,t){return r0e.call(n,t)}var Od=class extends Nf{constructor(t,e,i){let r;if(super(),En(t)||!t)r={next:t??void 0,error:e??void 0,complete:i??void 0};else{let o;this&&Cc.useDeprecatedNextContext?(o=Object.create(t),o.unsubscribe=()=>this.unsubscribe(),r={next:t.next&&lN(t.next,o),error:t.error&&lN(t.error,o),complete:t.complete&&lN(t.complete,o)}):r=t}this.destination=new class{constructor(t){this.partialObserver=t}next(t){let{partialObserver:e}=this;if(e.next)try{e.next(t)}catch(i){zE(i)}}error(t){let{partialObserver:e}=this;if(e.error)try{e.error(t)}catch(i){zE(i)}else zE(t)}complete(){let{partialObserver:t}=this;if(t.complete)try{t.complete()}catch(e){zE(e)}}}(r)}};function zE(n){Cc.useDeprecatedSynchronousErrorHandling?function(n){Cc.useDeprecatedSynchronousErrorHandling&&Ff&&(Ff.errorThrown=!0,Ff.error=n)}(n):UE(n)}function cN(n,t){let{onStoppedNotification:e}=Cc;e&&u0.setTimeout(()=>e(n,t))}var s0e={closed:!0,next:Mc,error:function(n){throw n},complete:Mc},p0="function"==typeof Symbol&&Symbol.observable||"@@observable";function ms(n){return n}function pN(n){return 0===n.length?ms:1===n.length?n[0]:function(e){return n.reduce((i,r)=>r(i),e)}}var un=(()=>{class n{constructor(e){e&&(this._subscribe=e)}lift(e){let i=new n;return i.source=this,i.operator=e,i}subscribe(e,i,r){let o=function(n){return n&&n instanceof Nf||function(n){return n&&En(n.next)&&En(n.error)&&En(n.complete)}(n)&&HE(n)}(e)?e:new Od(e,i,r);return d0(()=>{let{operator:s,source:a}=this;o.add(s?s.call(o,a):a?this._subscribe(o):this._trySubscribe(o))}),o}_trySubscribe(e){try{return this._subscribe(e)}catch(i){e.error(i)}}forEach(e,i){return new(i=N6(i))((r,o)=>{let s=new Od({next:a=>{try{e(a)}catch(l){o(l),s.unsubscribe()}},error:o,complete:r});this.subscribe(s)})}_subscribe(e){var i;return null===(i=this.source)||void 0===i?void 0:i.subscribe(e)}[p0](){return this}pipe(...e){return pN(e)(this)}toPromise(e){return new(e=N6(e))((i,r)=>{let o;this.subscribe(s=>o=s,s=>r(s),()=>i(o))})}}return n.create=t=>new n(t),n})();function N6(n){var t;return null!==(t=n??Cc.Promise)&&void 0!==t?t:Promise}function hN(n){return En(n?.lift)}function en(n){return t=>{if(hN(t))return t.lift(function(e){try{return n(e,this)}catch(i){this.error(i)}});throw new TypeError("Unable to lift unknown Observable type")}}function jt(n,t,e,i,r){return new nx(n,t,e,i,r)}var fN,nx=class extends Nf{constructor(t,e,i,r,o,s){super(t),this.onFinalize=o,this.shouldUnsubscribe=s,this._next=e?function(a){try{e(a)}catch(l){t.error(l)}}:super._next,this._error=r?function(a){try{r(a)}catch(l){t.error(l)}finally{this.unsubscribe()}}:super._error,this._complete=i?function(){try{i()}catch(a){t.error(a)}finally{this.unsubscribe()}}:super._complete}unsubscribe(){var t;if(!this.shouldUnsubscribe||this.shouldUnsubscribe()){let{closed:e}=this;super.unsubscribe(),!e&&(null===(t=this.onFinalize)||void 0===t||t.call(this))}}},ix=class extends un{constructor(t,e){super(),this.source=t,this.subjectFactory=e,this._subject=null,this._refCount=0,this._connection=null,hN(t)&&(this.lift=t.lift)}_subscribe(t){return this.getSubject().subscribe(t)}getSubject(){let t=this._subject;return(!t||t.isStopped)&&(this._subject=this.subjectFactory()),this._subject}_teardown(){this._refCount=0;let{_connection:t}=this;this._subject=this._connection=null,t?.unsubscribe()}connect(){let t=this._connection;if(!t){t=this._connection=new Sn;let e=this.getSubject();t.add(this.source.subscribe(jt(e,void 0,()=>{this._teardown(),e.complete()},i=>{this._teardown(),e.error(i)},()=>this._teardown()))),t.closed&&(this._connection=null,t=Sn.EMPTY)}return t}refCount(){return en((n,t)=>{let e=null;n._refCount++;let i=jt(t,void 0,void 0,void 0,()=>{if(!n||n._refCount<=0||0<--n._refCount)return void(e=null);let r=n._connection,o=e;e=null,r&&(!o||r===o)&&r.unsubscribe(),t.unsubscribe()});n.subscribe(i),i.closed||(e=n.connect())})(this)}},h0={schedule(n){let t=requestAnimationFrame,e=cancelAnimationFrame,{delegate:i}=h0;i&&(t=i.requestAnimationFrame,e=i.cancelAnimationFrame);let r=t(o=>{e=void 0,n(o)});return new Sn(()=>e?.(r))},requestAnimationFrame(...n){let{delegate:t}=h0;return(t?.requestAnimationFrame||requestAnimationFrame)(...n)},cancelAnimationFrame(...n){let{delegate:t}=h0;return(t?.cancelAnimationFrame||cancelAnimationFrame)(...n)},delegate:void 0},B6=c0(n=>function(){n(this),this.name="ObjectUnsubscribedError",this.message="object unsubscribed"}),ke=(()=>{class n extends un{constructor(){super(),this.closed=!1,this.currentObservers=null,this.observers=[],this.isStopped=!1,this.hasError=!1,this.thrownError=null}lift(e){let i=new jE(this,this);return i.operator=e,i}_throwIfClosed(){if(this.closed)throw new B6}next(e){d0(()=>{if(this._throwIfClosed(),!this.isStopped){this.currentObservers||(this.currentObservers=Array.from(this.observers));for(let i of this.currentObservers)i.next(e)}})}error(e){d0(()=>{if(this._throwIfClosed(),!this.isStopped){this.hasError=this.isStopped=!0,this.thrownError=e;let{observers:i}=this;for(;i.length;)i.shift().error(e)}})}complete(){d0(()=>{if(this._throwIfClosed(),!this.isStopped){this.isStopped=!0;let{observers:e}=this;for(;e.length;)e.shift().complete()}})}unsubscribe(){this.isStopped=this.closed=!0,this.observers=this.currentObservers=null}get observed(){var e;return(null===(e=this.observers)||void 0===e?void 0:e.length)>0}_trySubscribe(e){return this._throwIfClosed(),super._trySubscribe(e)}_subscribe(e){return this._throwIfClosed(),this._checkFinalizedStatuses(e),this._innerSubscribe(e)}_innerSubscribe(e){let{hasError:i,isStopped:r,observers:o}=this;return i||r?sN:(this.currentObservers=null,o.push(e),new Sn(()=>{this.currentObservers=null,kf(o,e)}))}_checkFinalizedStatuses(e){let{hasError:i,thrownError:r,isStopped:o}=this;i?e.error(r):o&&e.complete()}asObservable(){let e=new un;return e.source=this,e}}return n.create=(t,e)=>new jE(t,e),n})(),jE=class extends ke{constructor(t,e){super(),this.destination=t,this.source=e}next(t){var e,i;null===(i=null===(e=this.destination)||void 0===e?void 0:e.next)||void 0===i||i.call(e,t)}error(t){var e,i;null===(i=null===(e=this.destination)||void 0===e?void 0:e.error)||void 0===i||i.call(e,t)}complete(){var t,e;null===(e=null===(t=this.destination)||void 0===t?void 0:t.complete)||void 0===e||e.call(t)}_subscribe(t){var e,i;return null!==(i=null===(e=this.source)||void 0===e?void 0:e.subscribe(t))&&void 0!==i?i:sN}},hr=class extends ke{constructor(t){super(),this._value=t}get value(){return this.getValue()}_subscribe(t){let e=super._subscribe(t);return!e.closed&&t.next(this._value),e}getValue(){let{hasError:t,thrownError:e,_value:i}=this;if(t)throw e;return this._throwIfClosed(),i}next(t){super.next(this._value=t)}},rx={now:()=>(rx.delegate||Date).now(),delegate:void 0},Lf=class extends ke{constructor(t=1/0,e=1/0,i=rx){super(),this._bufferSize=t,this._windowTime=e,this._timestampProvider=i,this._buffer=[],this._infiniteTimeWindow=!0,this._infiniteTimeWindow=e===1/0,this._bufferSize=Math.max(1,t),this._windowTime=Math.max(1,e)}next(t){let{isStopped:e,_buffer:i,_infiniteTimeWindow:r,_timestampProvider:o,_windowTime:s}=this;e||(i.push(t),!r&&i.push(o.now()+s)),this._trimBuffer(),super.next(t)}_subscribe(t){this._throwIfClosed(),this._trimBuffer();let e=this._innerSubscribe(t),{_infiniteTimeWindow:i,_buffer:r}=this,o=r.slice();for(let s=0;s<o.length&&!t.closed;s+=i?1:2)t.next(o[s]);return this._checkFinalizedStatuses(t),e}_trimBuffer(){let{_bufferSize:t,_timestampProvider:e,_buffer:i,_infiniteTimeWindow:r}=this,o=(r?1:2)*t;if(t<1/0&&o<i.length&&i.splice(0,i.length-o),!r){let s=e.now(),a=0;for(let l=1;l<i.length&&i[l]<=s;l+=2)a=l;a&&i.splice(0,a+1)}}},GE=class extends Sn{constructor(t,e){super()}schedule(t,e=0){return this}},ox={setInterval(n,t,...e){let{delegate:i}=ox;return i?.setInterval?i.setInterval(n,t,...e):setInterval(n,t,...e)},clearInterval(n){let{delegate:t}=ox;return(t?.clearInterval||clearInterval)(n)},delegate:void 0},gu=class extends GE{constructor(t,e){super(t,e),this.scheduler=t,this.work=e,this.pending=!1}schedule(t,e=0){var i;if(this.closed)return this;this.state=t;let r=this.id,o=this.scheduler;return null!=r&&(this.id=this.recycleAsyncId(o,r,e)),this.pending=!0,this.delay=e,this.id=null!==(i=this.id)&&void 0!==i?i:this.requestAsyncId(o,this.id,e),this}requestAsyncId(t,e,i=0){return ox.setInterval(t.flush.bind(t,this),i)}recycleAsyncId(t,e,i=0){if(null!=i&&this.delay===i&&!1===this.pending)return e;null!=e&&ox.clearInterval(e)}execute(t,e){if(this.closed)return new Error("executing a cancelled action");this.pending=!1;let i=this._execute(t,e);if(i)return i;!1===this.pending&&null!=this.id&&(this.id=this.recycleAsyncId(this.scheduler,this.id,null))}_execute(t,e){let r,i=!1;try{this.work(t)}catch(o){i=!0,r=o||new Error("Scheduled action threw falsy error")}if(i)return this.unsubscribe(),r}unsubscribe(){if(!this.closed){let{id:t,scheduler:e}=this,{actions:i}=e;this.work=this.state=this.scheduler=null,this.pending=!1,kf(i,this),null!=t&&(this.id=this.recycleAsyncId(e,t,null)),this.delay=null,super.unsubscribe()}}},c0e=1,mN={};function V6(n){return n in mN&&(delete mN[n],!0)}var H6={setImmediate(n){let t=c0e++;return mN[t]=!0,fN||(fN=Promise.resolve()),fN.then(()=>V6(t)&&n()),t},clearImmediate(n){V6(n)}},{setImmediate:u0e,clearImmediate:d0e}=H6,sx={setImmediate(...n){let{delegate:t}=sx;return(t?.setImmediate||u0e)(...n)},clearImmediate(n){let{delegate:t}=sx;return(t?.clearImmediate||d0e)(n)},delegate:void 0},Lp=class{constructor(t,e=Lp.now){this.schedulerActionCtor=t,this.now=e}schedule(t,e=0,i){return new this.schedulerActionCtor(this,t).schedule(i,e)}};Lp.now=rx.now;var _u=class extends Lp{constructor(t,e=Lp.now){super(t,e),this.actions=[],this._active=!1}flush(t){let i,{actions:e}=this;if(this._active)e.push(t);else{this._active=!0;do{if(i=t.execute(t.state,t.delay))break}while(t=e.shift());if(this._active=!1,i){for(;t=e.shift();)t.unsubscribe();throw i}}}},f0=new class extends _u{flush(t){this._active=!0;let e=this._scheduled;this._scheduled=void 0;let r,{actions:i}=this;t=t||i.shift();do{if(r=t.execute(t.state,t.delay))break}while((t=i[0])&&t.id===e&&i.shift());if(this._active=!1,r){for(;(t=i[0])&&t.id===e&&i.shift();)t.unsubscribe();throw r}}}(class extends gu{constructor(t,e){super(t,e),this.scheduler=t,this.work=e}requestAsyncId(t,e,i=0){return null!==i&&i>0?super.requestAsyncId(t,e,i):(t.actions.push(this),t._scheduled||(t._scheduled=sx.setImmediate(t.flush.bind(t,void 0))))}recycleAsyncId(t,e,i=0){var r;if(null!=i?i>0:this.delay>0)return super.recycleAsyncId(t,e,i);let{actions:o}=t;null!=e&&(null===(r=o[o.length-1])||void 0===r?void 0:r.id)!==e&&(sx.clearImmediate(e),t._scheduled=void 0)}}),kd=new _u(gu),U6=kd,gN=new class extends _u{}(class extends gu{constructor(t,e){super(t,e),this.scheduler=t,this.work=e}schedule(t,e=0){return e>0?super.schedule(t,e):(this.delay=e,this.state=t,this.scheduler.flush(this),this)}execute(t,e){return e>0||this.closed?super.execute(t,e):this._execute(t,e)}requestAsyncId(t,e,i=0){return null!=i&&i>0||null==i&&this.delay>0?super.requestAsyncId(t,e,i):(t.flush(this),0)}}),_N=new class extends _u{flush(t){this._active=!0;let e=this._scheduled;this._scheduled=void 0;let r,{actions:i}=this;t=t||i.shift();do{if(r=t.execute(t.state,t.delay))break}while((t=i[0])&&t.id===e&&i.shift());if(this._active=!1,r){for(;(t=i[0])&&t.id===e&&i.shift();)t.unsubscribe();throw r}}}(class extends gu{constructor(t,e){super(t,e),this.scheduler=t,this.work=e}requestAsyncId(t,e,i=0){return null!==i&&i>0?super.requestAsyncId(t,e,i):(t.actions.push(this),t._scheduled||(t._scheduled=h0.requestAnimationFrame(()=>t.flush(void 0))))}recycleAsyncId(t,e,i=0){var r;if(null!=i?i>0:this.delay>0)return super.recycleAsyncId(t,e,i);let{actions:o}=t;null!=e&&(null===(r=o[o.length-1])||void 0===r?void 0:r.id)!==e&&(h0.cancelAnimationFrame(e),t._scheduled=void 0)}}),eo=new un(n=>n.complete());function ZE(n){return n&&En(n.schedule)}function vN(n){return n[n.length-1]}function vu(n){return En(vN(n))?n.pop():void 0}function yu(n){return ZE(vN(n))?n.pop():void 0}var dW=oN(uW(),1),{__decorate:pW,__awaiter:hW,__await:t1,__asyncGenerator:fW,__asyncValues:mW}=dW.default,g0=n=>n&&"number"==typeof n.length&&"function"!=typeof n;function n1(n){return En(n?.then)}function i1(n){return En(n[p0])}function r1(n){return Symbol.asyncIterator&&En(n?.[Symbol.asyncIterator])}function o1(n){return new TypeError(`You provided ${null!==n&&"object"==typeof n?"an invalid object":`'${n}'`} where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.`)}var s1="function"==typeof Symbol&&Symbol.iterator?Symbol.iterator:"@@iterator";function a1(n){return En(n?.[s1])}function l1(n){return fW(this,arguments,function*(){let e=n.getReader();try{for(;;){let{value:i,done:r}=yield t1(e.read());if(r)return yield t1(void 0);yield yield t1(i)}}finally{e.releaseLock()}})}function c1(n){return En(n?.getReader)}function gi(n){if(n instanceof un)return n;if(null!=n){if(i1(n))return function(n){return new un(t=>{let e=n[p0]();if(En(e.subscribe))return e.subscribe(t);throw new TypeError("Provided object does not correctly implement Symbol.observable")})}(n);if(g0(n))return function(n){return new un(t=>{for(let e=0;e<n.length&&!t.closed;e++)t.next(n[e]);t.complete()})}(n);if(n1(n))return function(n){return new un(t=>{n.then(e=>{t.closed||(t.next(e),t.complete())},e=>t.error(e)).then(null,UE)})}(n);if(r1(n))return gW(n);if(a1(n))return function(n){return new un(t=>{for(let e of n)if(t.next(e),t.closed)return;t.complete()})}(n);if(c1(n))return function(n){return gW(l1(n))}(n)}throw o1(n)}function gW(n){return new un(t=>{(function(n,t){var e,i,r,o;return hW(this,void 0,void 0,function*(){try{for(e=mW(n);!(i=yield e.next()).done;)if(t.next(i.value),t.closed)return}catch(s){r={error:s}}finally{try{i&&!i.done&&(o=e.return)&&(yield o.call(e))}finally{if(r)throw r.error}}t.complete()})})(n,t).catch(e=>t.error(e))})}function Ca(n,t,e,i=0,r=!1){let o=t.schedule(function(){e(),r?n.add(this.schedule(null,i)):this.unsubscribe()},i);if(n.add(o),!r)return o}function Bf(n,t=0){return en((e,i)=>{e.subscribe(jt(i,r=>Ca(i,n,()=>i.next(r),t),()=>Ca(i,n,()=>i.complete(),t),r=>Ca(i,n,()=>i.error(r),t)))})}function u1(n,t=0){return en((e,i)=>{i.add(n.schedule(()=>e.subscribe(i),t))})}function d1(n,t){if(!n)throw new Error("Iterable cannot be null");return new un(e=>{Ca(e,t,()=>{let i=n[Symbol.asyncIterator]();Ca(e,t,()=>{i.next().then(r=>{r.done?e.complete():e.next(r.value)})},0,!0)})})}function Eo(n,t){return t?function(n,t){if(null!=n){if(i1(n))return function(n,t){return gi(n).pipe(u1(t),Bf(t))}(n,t);if(g0(n))return function(n,t){return new un(e=>{let i=0;return t.schedule(function(){i===n.length?e.complete():(e.next(n[i++]),e.closed||this.schedule())})})}(n,t);if(n1(n))return function(n,t){return gi(n).pipe(u1(t),Bf(t))}(n,t);if(r1(n))return d1(n,t);if(a1(n))return function(n,t){return new un(e=>{let i;return Ca(e,t,()=>{i=n[s1](),Ca(e,t,()=>{let r,o;try{({value:r,done:o}=i.next())}catch(s){return void e.error(s)}o?e.complete():e.next(r)},0,!0)}),()=>En(i?.return)&&i.return()})}(n,t);if(c1(n))return function(n,t){return d1(l1(n),t)}(n,t)}throw o1(n)}(n,t):gi(n)}function Xt(...n){return Eo(n,yu(n))}function wc(n,t){let e=En(n)?n:()=>n,i=r=>r.error(e());return new un(t?r=>t.schedule(i,0,r):i)}var Rl=class{constructor(t,e,i){this.kind=t,this.value=e,this.error=i,this.hasValue="N"===t}observe(t){return bN(this,t)}do(t,e,i){let{kind:r,value:o,error:s}=this;return"N"===r?t?.(o):"E"===r?e?.(s):i?.()}accept(t,e,i){var r;return En(null===(r=t)||void 0===r?void 0:r.next)?this.observe(t):this.do(t,e,i)}toObservable(){let{kind:t,value:e,error:i}=this,r="N"===t?Xt(e):"E"===t?wc(()=>i):"C"===t?eo:0;if(!r)throw new TypeError(`Unexpected notification kind ${t}`);return r}static createNext(t){return new Rl("N",t)}static createError(t){return new Rl("E",void 0,t)}static createComplete(){return Rl.completeNotification}};function bN(n,t){var e,i,r;let{kind:o,value:s,error:a}=n;if("string"!=typeof o)throw new TypeError('Invalid notification, missing "kind"');"N"===o?null===(e=t.next)||void 0===e||e.call(t,s):"E"===o?null===(i=t.error)||void 0===i||i.call(t,a):null===(r=t.complete)||void 0===r||r.call(t)}function ax(n){return!!n&&(n instanceof un||En(n.lift)&&En(n.subscribe))}Rl.completeNotification=new Rl("C");var _0=c0(n=>function(){n(this),this.name="EmptyError",this.message="no elements in sequence"});function L(n,t){return en((e,i)=>{let r=0;e.subscribe(jt(i,o=>{i.next(n.call(t,o,r++))}))})}var{isArray:y0e}=Array;function Bp(n){return L(t=>function(n,t){return y0e(t)?n(...t):n(t)}(n,t))}var{isArray:x0e}=Array,{getPrototypeOf:C0e,prototype:M0e,keys:w0e}=Object;function p1(n){if(1===n.length){let t=n[0];if(x0e(t))return{args:t,keys:null};if(function(n){return n&&"object"==typeof n&&C0e(n)===M0e}(t)){let e=w0e(t);return{args:e.map(i=>t[i]),keys:e}}}return{args:n,keys:null}}function h1(n,t){return n.reduce((e,i,r)=>(e[i]=t[r],e),{})}function Lt(...n){let t=yu(n),e=vu(n),{args:i,keys:r}=p1(n);if(0===i.length)return Eo([],t);let o=new un(xN(i,t,r?s=>h1(r,s):ms));return e?o.pipe(Bp(e)):o}function xN(n,t,e=ms){return i=>{wW(t,()=>{let{length:r}=n,o=new Array(r),s=r,a=r;for(let l=0;l<r;l++)wW(t,()=>{let c=Eo(n[l],t),u=!1;c.subscribe(jt(i,d=>{o[l]=d,u||(u=!0,a--),a||i.next(e(o.slice()))},()=>{--s||i.complete()}))},i)},i)}}function wW(n,t,e){n?Ca(e,n,t):t()}function xn(n,t,e=1/0){return En(t)?xn((i,r)=>L((o,s)=>t(i,o,r,s))(gi(n(i,r))),e):("number"==typeof t&&(e=t),en((i,r)=>function(n,t,e,i,r,o,s,a){let l=[],c=0,u=0,d=!1,p=()=>{d&&!l.length&&!c&&t.complete()},h=m=>c<i?f(m):l.push(m),f=m=>{c++;let x=!1;gi(e(m,u++)).subscribe(jt(t,g=>{t.next(g)},()=>{x=!0},void 0,()=>{if(x)try{for(c--;l.length&&c<i;){let g=l.shift();f(g)}p()}catch(g){t.error(g)}}))};return n.subscribe(jt(t,h,()=>{d=!0,p()})),()=>{}}(i,r,n,e)))}function f1(n=1/0){return xn(ms,n)}function Vp(...n){return f1(1)(Eo(n,yu(n)))}function Qa(n){return new un(t=>{gi(n()).subscribe(t)})}function lr(...n){let t=vu(n),{args:e,keys:i}=p1(n),r=new un(o=>{let{length:s}=e;if(!s)return void o.complete();let a=new Array(s),l=s,c=s;for(let u=0;u<s;u++){let d=!1;gi(e[u]).subscribe(jt(o,p=>{d||(d=!0,c--),a[u]=p},()=>l--,void 0,()=>{(!l||!d)&&(c||o.next(i?h1(i,a):a),o.complete())}))}});return t?r.pipe(Bp(t)):r}var E0e=["addListener","removeListener"],T0e=["addEventListener","removeEventListener"],D0e=["on","off"];function _i(n,t,e,i){if(En(e)&&(i=e,e=void 0),i)return _i(n,t,e).pipe(Bp(i));let[r,o]=function(n){return En(n.addEventListener)&&En(n.removeEventListener)}(n)?T0e.map(s=>a=>n[s](t,a,e)):function(n){return En(n.addListener)&&En(n.removeListener)}(n)?E0e.map(TW(n,t)):function(n){return En(n.on)&&En(n.off)}(n)?D0e.map(TW(n,t)):[];if(!r&&g0(n))return xn(s=>_i(s,t,e))(gi(n));if(!r)throw new TypeError("Invalid event target");return new un(s=>{let a=(...l)=>s.next(1<l.length?l:l[0]);return r(a),()=>o(a)})}function TW(n,t){return e=>i=>n[e](t,i)}function Ka(n=0,t,e=U6){let i=-1;return null!=t&&(ZE(t)?e=t:i=t),new un(r=>{let o=function(n){return n instanceof Date&&!isNaN(n)}(n)?+n-e.now():n;o<0&&(o=0);let s=0;return e.schedule(function(){r.closed||(r.next(s++),0<=i?this.schedule(void 0,i):r.complete())},o)})}function Jt(...n){let t=yu(n),e=function(n,t){return"number"==typeof vN(n)?n.pop():1/0}(n),i=n;return i.length?1===i.length?gi(i[0]):f1(e)(Eo(i,t)):eo}var{isArray:R0e}=Array;function m1(n){return 1===n.length&&R0e(n[0])?n[0]:n}function Ye(n,t){return en((e,i)=>{let r=0;e.subscribe(jt(i,o=>n.call(t,o,r++)&&i.next(o)))})}function bu(n,t=kd){return function(n){return en((t,e)=>{let i=!1,r=null,o=null,s=!1,a=()=>{if(o?.unsubscribe(),o=null,i){i=!1;let c=r;r=null,e.next(c)}s&&e.complete()},l=()=>{o=null,s&&e.complete()};t.subscribe(jt(e,c=>{i=!0,r=c,o||gi(n()).subscribe(o=jt(e,a,l))},()=>{s=!0,(!i||!o||o.closed)&&e.complete()}))})}(()=>Ka(n,t))}function fo(n){return en((t,e)=>{let o,i=null,r=!1;i=t.subscribe(jt(e,void 0,void 0,s=>{o=gi(n(s,fo(n)(t))),i?(i.unsubscribe(),i=null,o.subscribe(e)):r=!0})),r&&(i.unsubscribe(),i=null,o.subscribe(e))})}function AW(n,t,e,i,r){return(o,s)=>{let a=e,l=t,c=0;o.subscribe(jt(s,u=>{let d=c++;l=a?n(l,u,d):(a=!0,u),i&&s.next(l)},r&&(()=>{a&&s.next(l),s.complete()})))}}function wN(...n){let t=vu(n);return t?function(...n){return pN(n)}(wN(...n),Bp(t)):en((e,i)=>{xN([e,...m1(n)])(i)})}function fr(...n){return wN(...n)}function Hr(n,t=kd){return en((e,i)=>{let r=null,o=null,s=null,a=()=>{if(r){r.unsubscribe(),r=null;let c=o;o=null,i.next(c)}};function l(){let c=s+n,u=t.now();if(u<c)return r=this.schedule(void 0,c-u),void i.add(r);a()}e.subscribe(jt(i,c=>{o=c,s=t.now(),r||(r=t.schedule(l,n),i.add(r))},()=>{a(),i.complete()},void 0,()=>{o=r=null}))})}function _1(n){return en((t,e)=>{let i=!1;t.subscribe(jt(e,r=>{i=!0,e.next(r)},()=>{i||e.next(n),e.complete()}))})}function Qt(n){return n<=0?()=>eo:en((t,e)=>{let i=0;t.subscribe(jt(e,r=>{++i<=n&&(e.next(r),n<=i&&e.complete())}))})}function lx(){return en((n,t)=>{n.subscribe(jt(t,Mc))})}function v0(n,t){return t?e=>Vp(t.pipe(Qt(1),lx()),e.pipe(v0(n))):xn((e,i)=>n(e,i).pipe(Qt(1),function(n){return L(()=>n)}(e)))}function Ol(n,t=kd){let e=Ka(n,t);return v0(()=>e)}function yi(n,t=ms){return n=n??O0e,en((e,i)=>{let r,o=!0;e.subscribe(jt(i,s=>{let a=t(s);(o||!n(r,a))&&(o=!1,r=a,i.next(s))}))})}function O0e(n,t){return n===t}function v1(n=k0e){return en((t,e)=>{let i=!1;t.subscribe(jt(e,r=>{i=!0,e.next(r)},()=>i?e.complete():e.error(n())))})}function k0e(){return new _0}function y1(n,t){return t?e=>e.pipe(y1((i,r)=>gi(n(i,r)).pipe(L((o,s)=>t(i,o,r,s))))):en((e,i)=>{let r=0,o=null,s=!1;e.subscribe(jt(i,a=>{o||(o=jt(i,void 0,()=>{o=null,s&&i.complete()}),gi(n(a,r++)).subscribe(o))},()=>{s=!0,!o&&i.complete()}))})}function x1(n,t,e,i){return en((r,o)=>{let s;t&&"function"!=typeof t?({duration:e,element:s,connector:i}=t):s=t;let a=new Map,l=f=>{a.forEach(f),f(o)},c=f=>l(m=>m.error(f)),u=0,d=!1,p=new nx(o,f=>{try{let m=n(f),x=a.get(m);if(!x){a.set(m,x=i?i():new ke);let g=function(f,m){let x=new un(g=>{u++;let b=m.subscribe(g);return()=>{b.unsubscribe(),0==--u&&d&&p.unsubscribe()}});return x.key=f,x}(m,x);if(o.next(g),e){let b=jt(x,()=>{x.complete(),b?.unsubscribe()},void 0,void 0,()=>a.delete(m));p.add(gi(e(g)).subscribe(b))}}x.next(s?s(f):f)}catch(m){c(m)}},()=>l(f=>f.complete()),c,()=>a.clear(),()=>(d=!0,0===u));r.subscribe(p)})}function PW(n){return n<=0?()=>eo:en((t,e)=>{let i=[];t.subscribe(jt(e,r=>{i.push(r),n<i.length&&i.shift()},()=>{for(let r of i)e.next(r);e.complete()},void 0,()=>{i=null}))})}function y0(){return en((n,t)=>{let e,i=!1;n.subscribe(jt(t,r=>{let o=e;e=r,i&&t.next([o,r]),i=!0}))})}function Ts(n={}){let{connector:t=(()=>new ke),resetOnError:e=!0,resetOnComplete:i=!0,resetOnRefCountZero:r=!0}=n;return o=>{let s,a,l,c=0,u=!1,d=!1,p=()=>{a?.unsubscribe(),a=void 0},h=()=>{p(),s=l=void 0,u=d=!1},f=()=>{let m=s;h(),m?.unsubscribe()};return en((m,x)=>{c++,!d&&!u&&p();let g=l=l??t();x.add(()=>{c--,0===c&&!d&&!u&&(a=RN(f,r))}),g.subscribe(x),!s&&c>0&&(s=new Od({next:b=>g.next(b),error:b=>{d=!0,p(),a=RN(h,e,b),g.error(b)},complete:()=>{u=!0,p(),a=RN(h,i),g.complete()}}),gi(m).subscribe(s))})(o)}}function RN(n,t,...e){if(!0===t)return void n();if(!1===t)return;let i=new Od({next:()=>{i.unsubscribe(),n()}});return t(...e).subscribe(i)}function Ma(n,t,e){let i,r=!1;return n&&"object"==typeof n?({bufferSize:i=1/0,windowTime:t=1/0,refCount:r=!1,scheduler:e}=n):i=n??1/0,Ts({connector:()=>new Lf(i,t,e),resetOnError:!0,resetOnComplete:!1,resetOnRefCountZero:r})}function Za(n){return Ye((t,e)=>n<=e)}function zn(...n){let t=yu(n);return en((e,i)=>{(t?Vp(n,e,t):Vp(n,e)).subscribe(i)})}function ui(n,t){return en((e,i)=>{let r=null,o=0,s=!1,a=()=>s&&!r&&i.complete();e.subscribe(jt(i,l=>{r?.unsubscribe();let c=0,u=o++;gi(n(l,u)).subscribe(r=jt(i,d=>i.next(t?t(l,d,u,c++):d),()=>{r=null,a()}))},()=>{s=!0,a()}))})}function st(n){return en((t,e)=>{gi(n).subscribe(jt(e,()=>e.complete(),Mc)),!e.closed&&t.subscribe(e)})}function cx(n,t=!1){return en((e,i)=>{let r=0;e.subscribe(jt(i,o=>{let s=n(o,r++);(s||t)&&i.next(o),!s&&i.complete()}))})}function kt(n,t,e){let i=En(n)||t||e?{next:n,error:t,complete:e}:n;return i?en((r,o)=>{var s;null===(s=i.subscribe)||void 0===s||s.call(i);let a=!0;r.subscribe(jt(o,l=>{var c;null===(c=i.next)||void 0===c||c.call(i,l),o.next(l)},()=>{var l;a=!1,null===(l=i.complete)||void 0===l||l.call(i),o.complete()},l=>{var c;a=!1,null===(c=i.error)||void 0===c||c.call(i,l),o.error(l)},()=>{var l,c;a&&(null===(l=i.unsubscribe)||void 0===l||l.call(i)),null===(c=i.finalize)||void 0===c||c.call(i)}))}):ms}var ON={leading:!0,trailing:!1};function b0(n,t=kd,e=ON){let i=Ka(n,t);return function(n,t=ON){return en((e,i)=>{let{leading:r,trailing:o}=t,s=!1,a=null,l=null,c=!1,u=()=>{l?.unsubscribe(),l=null,o&&(h(),c&&i.complete())},d=()=>{l=null,c&&i.complete()},p=f=>l=gi(n(f)).subscribe(jt(i,u,d)),h=()=>{if(s){s=!1;let f=a;a=null,i.next(f),!c&&p(f)}};e.subscribe(jt(i,f=>{s=!0,a=f,(!l||l.closed)&&(r?h():p(f))},()=>{c=!0,(!(o&&s&&l)||l.closed)&&i.complete()}))})}(()=>i,e)}function Wt(...n){let t=vu(n);return en((e,i)=>{let r=n.length,o=new Array(r),s=n.map(()=>!1),a=!1;for(let l=0;l<r;l++)gi(n[l]).subscribe(jt(i,c=>{o[l]=c,!a&&!s[l]&&(s[l]=!0,(a=s.every(ms))&&(s=null))},Mc));e.subscribe(jt(i,l=>{if(a){let c=[l,...o];i.next(t?t(...c):c)}}))})}function mr(n){for(let t in n)if(n[t]===mr)return t;throw Error("Could not find renamed property on target object.")}function kN(n,t){for(let e in t)t.hasOwnProperty(e)&&!n.hasOwnProperty(e)&&(n[e]=t[e])}function To(n){if("string"==typeof n)return n;if(Array.isArray(n))return"["+n.map(To).join(", ")+"]";if(null==n)return""+n;if(n.overriddenName)return`${n.overriddenName}`;if(n.name)return`${n.name}`;let t=n.toString();if(null==t)return""+t;let e=t.indexOf("\n");return-1===e?t:t.substring(0,e)}function tL(n,t){return null==n||""===n?null===t?"":t:null==t||""===t?n:n+" "+t}var F0e=mr({__forward_ref__:mr});function Jn(n){return n.__forward_ref__=Jn,n.toString=function(){return To(this())},n}function Ki(n){return E7(n)?n():n}function E7(n){return"function"==typeof n&&n.hasOwnProperty(F0e)&&n.__forward_ref__===Jn}var At=class extends Error{constructor(t,e){super(function(n,t){return`NG0${Math.abs(n)}${t?": "+t.trim():""}`}(t,e)),this.code=t}};function Kn(n){return"string"==typeof n?n:null==n?"":String(n)}function o3(n){return"function"==typeof n?n.name||n.toString():"object"==typeof n&&null!=n&&"function"==typeof n.type?n.type.name||n.type.toString():Kn(n)}function s3(n,t){throw new At(-201,!1)}function T7(n,t,e,i){throw new Error(`ASSERTION ERROR: ${n}`+(null==i?"":` [Expected=> ${e} ${i} ${t} <=Actual]`))}function ye(n){return{token:n.token,providedIn:n.providedIn||null,factory:n.factory,value:void 0}}function V(n){return{providers:n.providers||[],imports:n.imports||[]}}function a3(n){return OW(n,L1)||OW(n,D7)}function OW(n,t){return n.hasOwnProperty(t)?n[t]:null}function kW(n){return n&&(n.hasOwnProperty(nL)||n.hasOwnProperty(U0e))?n[nL]:null}var iL,L1=mr({"\u0275prov":mr}),nL=mr({"\u0275inj":mr}),D7=mr({ngInjectableDef:mr}),U0e=mr({ngInjectorDef:mr}),di=(()=>{return(n=di||(di={}))[n.Default=0]="Default",n[n.Host=1]="Host",n[n.Self=2]="Self",n[n.SkipSelf=4]="SkipSelf",n[n.Optional=8]="Optional",di;var n})();function kl(n){let t=iL;return iL=n,t}function A7(n,t,e){let i=a3(n);return i&&"root"==i.providedIn?void 0===i.value?i.value=i.factory():i.value:e&di.Optional?null:void 0!==t?t:void s3(To(n))}function Zf(n){return{toString:n}.toString()}var px=(()=>{return(n=px||(px={}))[n.OnPush=0]="OnPush",n[n.Default=1]="Default",px;var n})(),Ja=(()=>{return(n=Ja||(Ja={}))[n.Emulated=0]="Emulated",n[n.None=2]="None",n[n.ShadowDom=3]="ShadowDom",Ja;var n})(),to=(()=>typeof globalThis<"u"&&globalThis||typeof global<"u"&&global||typeof window<"u"&&window||typeof self<"u"&&typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope&&self)(),A0={},Qi=[],cT=mr({"\u0275cmp":mr}),l3=mr({"\u0275dir":mr}),c3=mr({"\u0275pipe":mr}),I7=mr({"\u0275mod":mr}),Nd=mr({"\u0275fac":mr}),hx=mr({__NG_ELEMENT_ID__:mr}),j0e=0;function R(n){return Zf(()=>{let e=!0===n.standalone,i={},r={type:n.type,providersResolver:null,decls:n.decls,vars:n.vars,factory:null,template:n.template||null,consts:n.consts||null,ngContentSelectors:n.ngContentSelectors,hostBindings:n.hostBindings||null,hostVars:n.hostVars||0,hostAttrs:n.hostAttrs||null,contentQueries:n.contentQueries||null,declaredInputs:i,inputs:null,outputs:null,exportAs:n.exportAs||null,onPush:n.changeDetection===px.OnPush,directiveDefs:null,pipeDefs:null,standalone:e,dependencies:e&&n.dependencies||null,getStandaloneInjector:null,selectors:n.selectors||Qi,viewQuery:n.viewQuery||null,features:n.features||null,data:n.data||{},encapsulation:n.encapsulation||Ja.Emulated,id:"c"+j0e++,styles:n.styles||Qi,_:null,setInput:null,schemas:n.schemas||null,tView:null},o=n.dependencies,s=n.features;return r.inputs=NW(n.inputs,i),r.outputs=NW(n.outputs),s&&s.forEach(a=>a(r)),r.directiveDefs=o?()=>("function"==typeof o?o():o).map(P7).filter(FW):null,r.pipeDefs=o?()=>("function"==typeof o?o():o).map(Ld).filter(FW):null,r})}function Nx(n,t,e){let i=n.\u0275cmp;i.directiveDefs=()=>("function"==typeof t?t():t).map(P7),i.pipeDefs=()=>("function"==typeof e?e():e).map(Ld)}function P7(n){return Nl(n)||Gf(n)}function FW(n){return null!==n}function H(n){return Zf(()=>({type:n.type,bootstrap:n.bootstrap||Qi,declarations:n.declarations||Qi,imports:n.imports||Qi,exports:n.exports||Qi,transitiveCompileScopes:null,schemas:n.schemas||null,id:n.id||null}))}function NW(n,t){if(null==n)return A0;let e={};for(let i in n)if(n.hasOwnProperty(i)){let r=n[i],o=r;Array.isArray(r)&&(o=r[1],r=r[0]),e[r]=i,t&&(t[r]=o)}return e}var He=R;function B0(n){return{type:n.type,name:n.name,factory:null,pure:!1!==n.pure,standalone:!0===n.standalone,onDestroy:n.type.prototype.ngOnDestroy||null}}function Nl(n){return n[cT]||null}function Gf(n){return n[l3]||null}function Ld(n){return n[c3]||null}function R7(n){let t=Nl(n)||Gf(n)||Ld(n);return null!==t&&t.standalone}function I0(n,t){let e=n[I7]||null;if(!e&&!0===t)throw new Error(`Type ${To(n)} does not have '\u0275mod' property.`);return e}function zf(n){return Array.isArray(n)&&"object"==typeof n[1]}function Vd(n){return Array.isArray(n)&&!0===n[1]}function p3(n){return 0!=(8&n.flags)}function h3(n){return 2==(2&n.flags)}function dT(n){return 1==(1&n.flags)}function Ac(n){return null!==n.template}function q0e(n){return 0!=(256&n[2])}function Wf(n,t){return n.hasOwnProperty(Nd)?n[Nd]:null}function Ft(){return F7}function F7(n){return n.type.prototype.ngOnChanges&&(n.setInput=X0e),Y0e}function Y0e(){let n=L7(this),t=n?.current;if(t){let e=n.previous;if(e===A0)n.previous=t;else for(let i in t)e[i]=t[i];n.current=null,this.ngOnChanges(t)}}function X0e(n,t,e,i){let r=L7(n)||function(n,t){return n[N7]=t}(n,{previous:A0,current:null}),o=r.current||(r.current={}),s=r.previous,a=this.declaredInputs[e],l=s[a];o[a]=new class{constructor(t,e,i){this.previousValue=t,this.currentValue=e,this.firstChange=i}isFirstChange(){return this.firstChange}}(l&&l.currentValue,t,s===A0),n[i]=t}Ft.ngInherit=!0;var N7="__ngSimpleChanges__";function L7(n){return n[N7]||null}function $a(n){for(;Array.isArray(n);)n=n[0];return n}function pT(n,t){return $a(t[n])}function Ul(n,t){return $a(t[n.index])}function H7(n,t){return n.data[t]}function H0(n,t){return n[t]}function qp(n,t){let e=t[n];return zf(e)?e:e[0]}function U1(n){return 64==(64&n[2])}function Up(n,t){return null==t?null:n[t]}function U7(n){n[18]=0}function f3(n,t){n[5]+=t;let e=n,i=n[3];for(;null!==i&&(1===t&&1===e[5]||-1===t&&0===e[5]);)i[5]+=t,e=i,i=i[3]}var Zn={lFrame:Q7(null),bindingsEnabled:!0};function z7(){return Zn.bindingsEnabled}function rt(){return Zn.lFrame.lView}function Fi(){return Zn.lFrame.tView}function oe(n){return Zn.lFrame.contextLView=n,n[8]}function se(n){return Zn.lFrame.contextLView=null,n}function zo(){let n=j7();for(;null!==n&&64===n.type;)n=n.parent;return n}function j7(){return Zn.lFrame.currentTNode}function wx(){let n=Zn.lFrame,t=n.currentTNode;return n.isParent?t:t.parent}function Mu(n,t){let e=Zn.lFrame;e.currentTNode=n,e.isParent=t}function m3(){return Zn.lFrame.isParent}function g3(){Zn.lFrame.isParent=!1}function Ks(){let n=Zn.lFrame,t=n.bindingRootIndex;return-1===t&&(t=n.bindingRootIndex=n.tView.bindingStartIndex),t}function Hd(){return Zn.lFrame.bindingIndex}function G7(n){return Zn.lFrame.bindingIndex=n}function U0(){return Zn.lFrame.bindingIndex++}function Ud(n){let t=Zn.lFrame,e=t.bindingIndex;return t.bindingIndex=t.bindingIndex+n,e}function W7(n){Zn.lFrame.inI18n=n}function s_e(n,t){let e=Zn.lFrame;e.bindingIndex=e.bindingRootIndex=n,sL(t)}function sL(n){Zn.lFrame.currentDirectiveIndex=n}function _3(n){let t=Zn.lFrame.currentDirectiveIndex;return-1===t?null:n[t]}function q7(){return Zn.lFrame.currentQueryIndex}function v3(n){Zn.lFrame.currentQueryIndex=n}function l_e(n){let t=n[1];return 2===t.type?t.declTNode:1===t.type?n[6]:null}function Y7(n,t,e){if(e&di.SkipSelf){let r=t,o=n;for(;!(r=r.parent,null!==r||e&di.Host||(r=l_e(o),null===r||(o=o[15],10&r.type))););if(null===r)return!1;t=r,n=o}let i=Zn.lFrame=X7();return i.currentTNode=t,i.lView=n,!0}function y3(n){let t=X7(),e=n[1];Zn.lFrame=t,t.currentTNode=e.firstChild,t.lView=n,t.tView=e,t.contextLView=n,t.bindingIndex=e.bindingStartIndex,t.inI18n=!1}function X7(){let n=Zn.lFrame,t=null===n?null:n.child;return null===t?Q7(n):t}function Q7(n){let t={currentTNode:null,isParent:!0,lView:null,tView:null,selectedIndex:-1,contextLView:null,elementDepthCount:0,currentNamespace:null,currentDirectiveIndex:-1,bindingRootIndex:-1,bindingIndex:-1,currentQueryIndex:0,parent:n,child:null,inI18n:!1};return null!==n&&(n.child=t),t}function K7(){let n=Zn.lFrame;return Zn.lFrame=n.parent,n.currentTNode=null,n.lView=null,n}var Z7=K7;function b3(){let n=K7();n.isParent=!0,n.tView=null,n.selectedIndex=-1,n.contextLView=null,n.elementDepthCount=0,n.currentDirectiveIndex=-1,n.currentNamespace=null,n.bindingRootIndex=-1,n.bindingIndex=-1,n.currentQueryIndex=0}function Zs(){return Zn.lFrame.selectedIndex}function zp(n){Zn.lFrame.selectedIndex=n}function no(){let n=Zn.lFrame;return H7(n.tView,n.selectedIndex)}function In(){Zn.lFrame.currentNamespace="svg"}function Js(){Zn.lFrame.currentNamespace=null}function hT(n,t){for(let e=t.directiveStart,i=t.directiveEnd;e<i;e++){let o=n.data[e].type.prototype,{ngAfterContentInit:s,ngAfterContentChecked:a,ngAfterViewInit:l,ngAfterViewChecked:c,ngOnDestroy:u}=o;s&&(n.contentHooks||(n.contentHooks=[])).push(-e,s),a&&((n.contentHooks||(n.contentHooks=[])).push(e,a),(n.contentCheckHooks||(n.contentCheckHooks=[])).push(e,a)),l&&(n.viewHooks||(n.viewHooks=[])).push(-e,l),c&&((n.viewHooks||(n.viewHooks=[])).push(e,c),(n.viewCheckHooks||(n.viewCheckHooks=[])).push(e,c)),null!=u&&(n.destroyHooks||(n.destroyHooks=[])).push(e,u)}}function D1(n,t,e){J7(n,t,3,e)}function A1(n,t,e,i){(3&n[2])===e&&J7(n,t,e,i)}function FN(n,t){let e=n[2];(3&e)===t&&(e&=2047,e+=1,n[2]=e)}function J7(n,t,e,i){let o=i??-1,s=t.length-1,a=0;for(let l=void 0!==i?65535&n[18]:0;l<s;l++)if("number"==typeof t[l+1]){if(a=t[l],null!=i&&a>=i)break}else t[l]<0&&(n[18]+=65536),(a<o||-1==o)&&(m_e(n,e,t,l),n[18]=(4294901760&n[18])+l+2),l++}function m_e(n,t,e,i){let r=e[i]<0,o=e[i+1],a=n[r?-e[i]:e[i]];if(r){if(n[2]>>11<n[18]>>16&&(3&n[2])===t){n[2]+=2048;try{o.call(a)}finally{}}}else try{o.call(a)}finally{}}var qf=class{constructor(t,e,i){this.factory=t,this.resolving=!1,this.canSeeViewProviders=e,this.injectImpl=i}};function z1(n,t,e){let i=0;for(;i<e.length;){let r=e[i];if("number"==typeof r){if(0!==r)break;i++;let o=e[i++],s=e[i++],a=e[i++];n.setAttribute(t,s,a,o)}else{let o=r,s=e[++i];b_e(o)?n.setProperty(t,o,s):n.setAttribute(t,o,s),i++}}return i}function $7(n){return 3===n||4===n||6===n}function b_e(n){return 64===n.charCodeAt(0)}function j1(n,t){if(null!==t&&0!==t.length)if(null===n||0===n.length)n=t.slice();else{let e=-1;for(let i=0;i<t.length;i++){let r=t[i];"number"==typeof r?e=r:0===e||VW(n,e,r,null,-1===e||2===e?t[++i]:null)}}return n}function VW(n,t,e,i,r){let o=0,s=n.length;if(-1===t)s=-1;else for(;o<n.length;){let a=n[o++];if("number"==typeof a){if(a===t){s=-1;break}if(a>t){s=o-1;break}}}for(;o<n.length;){let a=n[o];if("number"==typeof a)break;if(a===e){if(null===i)return void(null!==r&&(n[o+1]=r));if(i===n[o+1])return void(n[o+2]=r)}o++,null!==i&&o++,null!==r&&o++}-1!==s&&(n.splice(s,0,t),o=s+1),n.splice(o++,0,e),null!==i&&n.splice(o++,0,i),null!==r&&n.splice(o++,0,r)}function e9(n){return-1!==n}function G1(n){return 32767&n}function W1(n,t){let e=function(n){return n>>16}(n),i=t;for(;e>0;)i=i[15],e--;return i}var aL=!0;function q1(n){let t=aL;return aL=n,t}var M_e=0,xu={};function Sx(n,t){let e=i9(n,t);if(-1!==e)return e;let i=t[1];i.firstCreatePass&&(n.injectorIndex=t.length,NN(i.data,n),NN(t,null),NN(i.blueprint,null));let r=C3(n,t),o=n.injectorIndex;if(e9(r)){let s=G1(r),a=W1(r,t),l=a[1].data;for(let c=0;c<8;c++)t[o+c]=a[s+c]|l[s+c]}return t[o+8]=r,o}function NN(n,t){n.push(0,0,0,0,0,0,0,0,t)}function i9(n,t){return-1===n.injectorIndex||n.parent&&n.parent.injectorIndex===n.injectorIndex||null===t[n.injectorIndex+8]?-1:n.injectorIndex}function C3(n,t){if(n.parent&&-1!==n.parent.injectorIndex)return n.parent.injectorIndex;let e=0,i=null,r=t;for(;null!==r;){if(i=l9(r),null===i)return-1;if(e++,r=r[15],-1!==i.injectorIndex)return i.injectorIndex|e<<16}return-1}function Y1(n,t,e){!function(n,t,e){let i;"string"==typeof e?i=e.charCodeAt(0)||0:e.hasOwnProperty(hx)&&(i=e[hx]),null==i&&(i=e[hx]=M_e++);let r=255&i;t.data[n+(r>>5)]|=1<<r}(n,t,e)}function r9(n,t,e){if(e&di.Optional||void 0!==n)return n;s3()}function o9(n,t,e,i){if(e&di.Optional&&void 0===i&&(i=null),0==(e&(di.Self|di.Host))){let r=n[9],o=kl(void 0);try{return r?r.get(t,i,e&di.Optional):A7(t,i,e&di.Optional)}finally{kl(o)}}return r9(i,0,e)}function s9(n,t,e,i=di.Default,r){if(null!==n){if(1024&t[2]){let s=function(n,t,e,i,r){let o=n,s=t;for(;null!==o&&null!==s&&1024&s[2]&&!(256&s[2]);){let a=a9(o,s,e,i|di.Self,xu);if(a!==xu)return a;let l=o.parent;if(!l){let c=s[21];if(c){let u=c.get(e,xu,i);if(u!==xu)return u}l=l9(s),s=s[15]}o=l}return r}(n,t,e,i,xu);if(s!==xu)return s}let o=a9(n,t,e,i,xu);if(o!==xu)return o}return o9(t,e,i,r)}function a9(n,t,e,i,r){let o=function(n){if("string"==typeof n)return n.charCodeAt(0)||0;let t=n.hasOwnProperty(hx)?n[hx]:void 0;return"number"==typeof t?t>=0?255&t:D_e:t}(e);if("function"==typeof o){if(!Y7(t,n,i))return i&di.Host?r9(r,0,i):o9(t,e,i,r);try{let s=o(i);if(null!=s||i&di.Optional)return s;s3()}finally{Z7()}}else if("number"==typeof o){let s=null,a=i9(n,t),l=-1,c=i&di.Host?t[16][6]:null;for((-1===a||i&di.SkipSelf)&&(l=-1===a?C3(n,t):t[a+8],-1!==l&&UW(i,!1)?(s=t[1],a=G1(l),t=W1(l,t)):a=-1);-1!==a;){let u=t[1];if(HW(o,a,u.data)){let d=E_e(a,t,e,s,i,c);if(d!==xu)return d}l=t[a+8],-1!==l&&UW(i,t[1].data[a+8]===c)&&HW(o,a,t)?(s=u,a=G1(l),t=W1(l,t)):a=-1}}return r}function E_e(n,t,e,i,r,o){let s=t[1],a=s.data[n+8],u=I1(a,s,e,null==i?h3(a)&&aL:i!=s&&0!=(3&a.type),r&di.Host&&o===a);return null!==u?Bx(t,s,u,a):xu}function I1(n,t,e,i,r){let o=n.providerIndexes,s=t.data,a=1048575&o,l=n.directiveStart,u=o>>20,p=r?a+u:n.directiveEnd;for(let h=i?a:a+u;h<p;h++){let f=s[h];if(h<l&&e===f||h>=l&&f.type===e)return h}if(r){let h=s[l];if(h&&Ac(h)&&h.type===e)return l}return null}function Bx(n,t,e,i){let r=n[e],o=t.data;if(function(n){return n instanceof qf}(r)){let s=r;s.resolving&&function(n,t){throw new At(-200,`Circular dependency in DI detected for ${n}`)}(o3(o[e]));let a=q1(s.canSeeViewProviders);s.resolving=!0;let l=s.injectImpl?kl(s.injectImpl):null;Y7(n,i,di.Default);try{r=n[e]=s.factory(void 0,o,n,i),t.firstCreatePass&&e>=i.directiveStart&&function(n,t,e){let{ngOnChanges:i,ngOnInit:r,ngDoCheck:o}=t.type.prototype;if(i){let s=F7(t);(e.preOrderHooks||(e.preOrderHooks=[])).push(n,s),(e.preOrderCheckHooks||(e.preOrderCheckHooks=[])).push(n,s)}r&&(e.preOrderHooks||(e.preOrderHooks=[])).push(0-n,r),o&&((e.preOrderHooks||(e.preOrderHooks=[])).push(n,o),(e.preOrderCheckHooks||(e.preOrderCheckHooks=[])).push(n,o))}(e,o[e],t)}finally{null!==l&&kl(l),q1(a),s.resolving=!1,Z7()}}return r}function HW(n,t,e){return!!(e[t+(n>>5)]&1<<n)}function UW(n,t){return!(n&di.Self||n&di.Host&&t)}var jf=class{constructor(t,e){this._tNode=t,this._lView=e}get(t,e,i){return s9(this._tNode,this._lView,t,i,e)}};function D_e(){return new jf(zo(),rt())}function pi(n){return Zf(()=>{let t=n.prototype.constructor,e=t[Nd]||lL(t),i=Object.prototype,r=Object.getPrototypeOf(n.prototype).constructor;for(;r&&r!==i;){let o=r[Nd]||lL(r);if(o&&o!==e)return o;r=Object.getPrototypeOf(r)}return o=>new o})}function lL(n){return E7(n)?()=>{let t=lL(Ki(n));return t&&t()}:Wf(n)}function l9(n){let t=n[1],e=t.type;return 2===e?t.declTNode:1===e?n[6]:null}function vo(n){return function(n,t){if("class"===t)return n.classes;if("style"===t)return n.styles;let e=n.attrs;if(e){let i=e.length,r=0;for(;r<i;){let o=e[r];if($7(o))break;if(0===o)r+=2;else if("number"==typeof o)for(r++;r<i&&"string"==typeof e[r];)r++;else{if(o===t)return e[r+1];r+=2}}}return null}(zo(),n)}var M0="__annotations__",w0="__parameters__",S0="__prop__metadata__";function Vx(n,t,e,i,r){return Zf(()=>{let o=M3(t);function s(...a){if(this instanceof s)return o.call(this,...a),this;let l=new s(...a);return function(u){return r&&r(u,...a),(u.hasOwnProperty(M0)?u[M0]:Object.defineProperty(u,M0,{value:[]})[M0]).push(l),i&&i(u),u}}return e&&(s.prototype=Object.create(e.prototype)),s.prototype.ngMetadataName=n,s.annotationCls=s,s})}function M3(n){return function(...e){if(n){let i=n(...e);for(let r in i)this[r]=i[r]}}}function z0(n,t,e){return Zf(()=>{let i=M3(t);function r(...o){if(this instanceof r)return i.apply(this,o),this;let s=new r(...o);return a.annotation=s,a;function a(l,c,u){let d=l.hasOwnProperty(w0)?l[w0]:Object.defineProperty(l,w0,{value:[]})[w0];for(;d.length<=u;)d.push(null);return(d[u]=d[u]||[]).push(s),l}}return e&&(r.prototype=Object.create(e.prototype)),r.prototype.ngMetadataName=n,r.annotationCls=r,r})}function Yp(n,t,e,i){return Zf(()=>{let r=M3(t);function o(...s){if(this instanceof o)return r.apply(this,s),this;let a=new o(...s);return function(c,u){let d=c.constructor,p=d.hasOwnProperty(S0)?d[S0]:Object.defineProperty(d,S0,{value:{}})[S0];p[u]=p.hasOwnProperty(u)&&p[u]||[],p[u].unshift(a),i&&i(c,u,...s)}}return e&&(o.prototype=Object.create(e.prototype)),o.prototype.ngMetadataName=n,o.annotationCls=o,o})}var I_e=z0("Attribute",n=>({attributeName:n,__NG_ELEMENT_ID__:()=>vo(n)})),pe=class{constructor(t,e){this._desc=t,this.ngMetadataName="InjectionToken",this.\u0275prov=void 0,"number"==typeof e?this.__NG_ELEMENT_ID__=e:void 0!==e&&(this.\u0275prov=ye({token:this,providedIn:e.providedIn||"root",factory:e.factory}))}get multi(){return this}toString(){return`InjectionToken ${this._desc}`}},R0=(new pe("AnalyzeForEntryComponents"),class{});function Ll(n){let t=to.ng;if(t&&t.\u0275compilerFacade)return t.\u0275compilerFacade;throw new Error("JIT compiler unavailable")}Yp("ContentChildren",(n,t={})=>({selector:n,first:!1,isViewQuery:!1,descendants:!1,emitDistinctChangesOnly:!0,...t}),R0),Yp("ContentChild",(n,t={})=>({selector:n,first:!0,isViewQuery:!1,descendants:!0,...t}),R0),Yp("ViewChildren",(n,t={})=>({selector:n,first:!1,isViewQuery:!0,descendants:!0,emitDistinctChangesOnly:!0,...t}),R0),Yp("ViewChild",(n,t)=>({selector:n,first:!0,isViewQuery:!0,descendants:!0,...t}),R0);var P_e=Function;function ux(n){return"function"==typeof n}function Fd(n,t){void 0===t&&(t=n);for(let e=0;e<n.length;e++){let i=n[e];Array.isArray(i)?(t===n&&(t=n.slice(0,e)),Fd(i,t)):t!==n&&t.push(i)}return t}function Ex(n,t){n.forEach(e=>Array.isArray(e)?Ex(e,t):t(e))}function u9(n,t,e){t>=n.length?n.push(e):n.splice(t,0,e)}function X1(n,t){return t>=n.length-1?n.pop():n.splice(t,1)[0]}function fx(n,t){let e=[];for(let i=0;i<n;i++)e.push(t);return e}function el(n,t,e){let i=Hx(n,t);return i>=0?n[1|i]=e:(i=~i,function(n,t,e,i){let r=n.length;if(r==t)n.push(e,i);else if(1===r)n.push(i,n[0]),n[0]=e;else{for(r--,n.push(n[r-1],n[r]);r>t;)n[r]=n[r-2],r--;n[t]=e,n[t+1]=i}}(n,i,t,e)),i}function LN(n,t){let e=Hx(n,t);if(e>=0)return n[1|e]}function Hx(n,t){return function(n,t,e){let i=0,r=n.length>>1;for(;r!==i;){let o=i+(r-i>>1),s=n[o<<1];if(t===s)return o<<1;s>t?r=o:i=o+1}return~(r<<1)}(n,t)}var F_e=/^function\s+\S+\(\)\s*{[\s\S]+\.apply\(this,\s*(arguments|(?:[^()]+\(\[\],)?[^()]+\(arguments\).*)\)/,N_e=/^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{/,L_e=/^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(/,B_e=/^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(\)\s*{[^}]*super\(\.\.\.arguments\)/;function BN(n){return n?n.map(t=>new(0,t.type.annotationCls)(...t.args?t.args:[])):[]}function C1(n){let t=n.prototype?Object.getPrototypeOf(n.prototype):null;return(t?t.constructor:null)||Object}var mx,Tx={},uL="__NG_DI_FLAG__",Q1="ngTempTokenPath",z_e=/\n/gm,zW="__source";function x0(n){let t=mx;return mx=n,t}function G_e(n,t=di.Default){if(void 0===mx)throw new At(-203,!1);return null===mx?A7(n,void 0,t):mx.get(n,t&di.Optional?null:void 0,t)}function j(n,t=di.Default){return(iL||G_e)(Ki(n),t)}function d9(n){throw new At(202,!1)}function jo(n,t=di.Default){return"number"!=typeof t&&(t=0|(t.optional&&8)|(t.host&&1)|(t.self&&2)|(t.skipSelf&&4)),j(n,t)}function dL(n){let t=[];for(let e=0;e<n.length;e++){let i=Ki(n[e]);if(Array.isArray(i)){if(0===i.length)throw new At(900,!1);let r,o=di.Default;for(let s=0;s<i.length;s++){let a=i[s],l=W_e(a);"number"==typeof l?-1===l?r=a.token:o|=l:r=a}t.push(j(r,o))}else t.push(j(i))}return t}function Ux(n,t){return n[uL]=t,n.prototype[uL]=t,n}function W_e(n){return n[uL]}var j0=Ux(z0("Inject",n=>({token:n})),-1),ns=Ux(z0("Optional"),8),w3=Ux(z0("Self"),2),tl=Ux(z0("SkipSelf"),4),X_e=Ux(z0("Host"),1),jW=null;function S3(){return jW=jW||new class{constructor(t){this._reflect=t||to.Reflect}factory(t){return(...e)=>new t(...e)}_zipTypesAndAnnotations(t,e){let i;i=fx(typeof t>"u"?e.length:t.length);for(let r=0;r<i.length;r++)i[r]=typeof t>"u"?[]:t[r]&&t[r]!=Object?[t[r]]:[],e&&null!=e[r]&&(i[r]=i[r].concat(e[r]));return i}_ownParameters(t,e){let i=t.toString();if(F_e.test(n=i)||B_e.test(n)||N_e.test(n)&&!L_e.test(n))return null;var n;if(t.parameters&&t.parameters!==e.parameters)return t.parameters;let r=t.ctorParameters;if(r&&r!==e.ctorParameters){let a="function"==typeof r?r():r,l=a.map(u=>u&&u.type),c=a.map(u=>u&&BN(u.decorators));return this._zipTypesAndAnnotations(l,c)}let o=t.hasOwnProperty(w0)&&t[w0],s=this._reflect&&this._reflect.getOwnMetadata&&this._reflect.getOwnMetadata("design:paramtypes",t);return s||o?this._zipTypesAndAnnotations(s,o):fx(t.length)}parameters(t){if(!ux(t))return[];let e=C1(t),i=this._ownParameters(t,e);return!i&&e!==Object&&(i=this.parameters(e)),i||[]}_ownAnnotations(t,e){if(t.annotations&&t.annotations!==e.annotations){let i=t.annotations;return"function"==typeof i&&i.annotations&&(i=i.annotations),i}return t.decorators&&t.decorators!==e.decorators?BN(t.decorators):t.hasOwnProperty(M0)?t[M0]:null}annotations(t){if(!ux(t))return[];let e=C1(t),i=this._ownAnnotations(t,e)||[];return(e!==Object?this.annotations(e):[]).concat(i)}_ownPropMetadata(t,e){if(t.propMetadata&&t.propMetadata!==e.propMetadata){let i=t.propMetadata;return"function"==typeof i&&i.propMetadata&&(i=i.propMetadata),i}if(t.propDecorators&&t.propDecorators!==e.propDecorators){let i=t.propDecorators,r={};return Object.keys(i).forEach(o=>{r[o]=BN(i[o])}),r}return t.hasOwnProperty(S0)?t[S0]:null}propMetadata(t){if(!ux(t))return{};let e=C1(t),i={};if(e!==Object){let o=this.propMetadata(e);Object.keys(o).forEach(s=>{i[s]=o[s]})}let r=this._ownPropMetadata(t,e);return r&&Object.keys(r).forEach(o=>{let s=[];i.hasOwnProperty(o)&&s.push(...i[o]),s.push(...r[o]),i[o]=s}),i}ownPropMetadata(t){return ux(t)&&this._ownPropMetadata(t,C1(t))||{}}hasLifecycleHook(t,e){return t instanceof P_e&&e in t.prototype}}}function fT(n){return p9(S3().parameters(n))}function p9(n){return n.map(t=>function(n){let t={token:null,attribute:null,host:!1,optional:!1,self:!1,skipSelf:!1};if(Array.isArray(n)&&n.length>0)for(let e=0;e<n.length;e++){let i=n[e];if(void 0===i)continue;let r=Object.getPrototypeOf(i);if(i instanceof ns||"Optional"===r.ngMetadataName)t.optional=!0;else if(i instanceof tl||"SkipSelf"===r.ngMetadataName)t.skipSelf=!0;else if(i instanceof w3||"Self"===r.ngMetadataName)t.self=!0;else if(i instanceof X_e||"Host"===r.ngMetadataName)t.host=!0;else if(i instanceof j0)t.token=i.token;else if(i instanceof I_e){if(void 0===i.attributeName)throw new At(204,!1);t.attribute=i.attributeName}else t.token=i}else t.token=void 0===n||Array.isArray(n)&&0===n.length?null:n;return t}(t))}var Dx=new Map,h9=new Set;function f9(n){return!!(n.templateUrl&&!n.hasOwnProperty("template")||n.styleUrls&&n.styleUrls.length)}var pL,M1,w1,GW=new Map;function m9(n,t){(function(n,t,e){if(t&&t!==e)throw new Error(`Duplicate module registered for ${n} - ${To(t)} vs ${To(t.name)}`)})(t,GW.get(t)||null,n),GW.set(t,n)}function _9(){return void 0!==pL?pL:typeof document<"u"?document:void 0}function v9(){if(void 0===M1&&(M1=null,to.trustedTypes))try{M1=to.trustedTypes.createPolicy("angular",{createHTML:n=>n,createScript:n=>n,createScriptURL:n=>n})}catch{}return M1}function O0(n){return v9()?.createHTML(n)||n}function E3(){if(void 0===w1&&(w1=null,to.trustedTypes))try{w1=to.trustedTypes.createPolicy("angular#unsafe-bypass",{createHTML:n=>n,createScript:n=>n,createScriptURL:n=>n})}catch{}return w1}function WW(n){return E3()?.createHTML(n)||n}function qW(n){return E3()?.createScript(n)||n}function YW(n){return E3()?.createScriptURL(n)||n}var Bd=class{constructor(t){this.changingThisBreaksApplicationSecurity=t}toString(){return`SafeValue must use [property]=binding: ${this.changingThisBreaksApplicationSecurity} (see https://g.co/ng/security#xss)`}},hL=class extends Bd{getTypeName(){return"HTML"}},fL=class extends Bd{getTypeName(){return"Style"}},mL=class extends Bd{getTypeName(){return"Script"}},gL=class extends Bd{getTypeName(){return"URL"}},_L=class extends Bd{getTypeName(){return"ResourceURL"}};function Ta(n){return n instanceof Bd?n.changingThisBreaksApplicationSecurity:n}function Pc(n,t){let e=function(n){return n instanceof Bd&&n.getTypeName()||null}(n);if(null!=e&&e!==t){if("ResourceURL"===e&&"URL"===t)return!0;throw new Error(`Required a safe ${t}, got a ${e} (see https://g.co/ng/security#xss)`)}return e===t}function w9(n){let t=new yL(n);return function(){try{return!!(new window.DOMParser).parseFromString(O0(""),"text/html")}catch{return!1}}()?new vL(t):t}var vL=class{constructor(t){this.inertDocumentHelper=t}getInertBodyElement(t){t="<body><remove></remove>"+t;try{let e=(new window.DOMParser).parseFromString(O0(t),"text/html").body;return null===e?this.inertDocumentHelper.getInertBodyElement(t):(e.removeChild(e.firstChild),e)}catch{return null}}},yL=class{constructor(t){if(this.defaultDoc=t,this.inertDocument=this.defaultDoc.implementation.createHTMLDocument("sanitization-inert"),null==this.inertDocument.body){let e=this.inertDocument.createElement("html");this.inertDocument.appendChild(e);let i=this.inertDocument.createElement("body");e.appendChild(i)}}getInertBodyElement(t){let e=this.inertDocument.createElement("template");if("content"in e)return e.innerHTML=O0(t),e;let i=this.inertDocument.createElement("body");return i.innerHTML=O0(t),this.defaultDoc.documentMode&&this.stripCustomNsAttrs(i),i}stripCustomNsAttrs(t){let e=t.attributes;for(let r=e.length-1;0<r;r--){let s=e.item(r).name;("xmlns:ns1"===s||0===s.indexOf("ns1:"))&&t.removeAttribute(s)}let i=t.firstChild;for(;i;)i.nodeType===Node.ELEMENT_NODE&&this.stripCustomNsAttrs(i),i=i.nextSibling}},ave=/^(?:(?:https?|mailto|data|ftp|tel|file|sms):|[^&:/?#]*(?:[/?#]|$))/gi;function zx(n){return(n=String(n)).match(ave)?n:"unsafe:"+n}function zd(n){let t={};for(let e of n.split(","))t[e]=!0;return t}function jx(...n){let t={};for(let e of n)for(let i in e)e.hasOwnProperty(i)&&(t[i]=!0);return t}var S1,S9=zd("area,br,col,hr,img,wbr"),E9=zd("colgroup,dd,dt,li,p,tbody,td,tfoot,th,thead,tr"),T9=zd("rp,rt"),lve=jx(T9,E9),cve=jx(E9,zd("address,article,aside,blockquote,caption,center,del,details,dialog,dir,div,dl,figure,figcaption,footer,h1,h2,h3,h4,h5,h6,header,hgroup,hr,ins,main,map,menu,nav,ol,pre,section,summary,table,ul")),uve=jx(T9,zd("a,abbr,acronym,audio,b,bdi,bdo,big,br,cite,code,del,dfn,em,font,i,img,ins,kbd,label,map,mark,picture,q,ruby,rp,rt,s,samp,small,source,span,strike,strong,sub,sup,time,track,tt,u,var,video")),bL=jx(S9,cve,uve,lve),T3=zd("background,cite,href,itemtype,longdesc,poster,src,xlink:href"),dve=zd("abbr,accesskey,align,alt,autoplay,axis,bgcolor,border,cellpadding,cellspacing,class,clear,color,cols,colspan,compact,controls,coords,datetime,default,dir,download,face,headers,height,hidden,hreflang,hspace,ismap,itemscope,itemprop,kind,label,lang,language,loop,media,muted,nohref,nowrap,open,preload,rel,rev,role,rows,rowspan,rules,scope,scrolling,shape,size,sizes,span,srclang,srcset,start,summary,tabindex,target,title,translate,type,usemap,valign,value,vspace,width"),pve=zd("aria-activedescendant,aria-atomic,aria-autocomplete,aria-busy,aria-checked,aria-colcount,aria-colindex,aria-colspan,aria-controls,aria-current,aria-describedby,aria-details,aria-disabled,aria-dropeffect,aria-errormessage,aria-expanded,aria-flowto,aria-grabbed,aria-haspopup,aria-hidden,aria-invalid,aria-keyshortcuts,aria-label,aria-labelledby,aria-level,aria-live,aria-modal,aria-multiline,aria-multiselectable,aria-orientation,aria-owns,aria-placeholder,aria-posinset,aria-pressed,aria-readonly,aria-relevant,aria-required,aria-roledescription,aria-rowcount,aria-rowindex,aria-rowspan,aria-selected,aria-setsize,aria-sort,aria-valuemax,aria-valuemin,aria-valuenow,aria-valuetext"),D9=jx(T3,dve,pve),hve=zd("script,style,template"),fve=/[\uD800-\uDBFF][\uDC00-\uDFFF]/g,mve=/([^\#-~ |!])/g;function XW(n){return n.replace(/&/g,"&amp;").replace(fve,function(t){return"&#"+(1024*(t.charCodeAt(0)-55296)+(t.charCodeAt(1)-56320)+65536)+";"}).replace(mve,function(t){return"&#"+t.charCodeAt(0)+";"}).replace(/</g,"&lt;").replace(/>/g,"&gt;")}function D3(n,t){let e=null;try{S1=S1||w9(n);let i=t?String(t):"";e=S1.getInertBodyElement(i);let r=5,o=i;do{if(0===r)throw new Error("Failed to sanitize html because the input is unstable");r--,i=o,o=e.innerHTML,e=S1.getInertBodyElement(i)}while(i!==o);let a=(new class{constructor(){this.sanitizedSomething=!1,this.buf=[]}sanitizeChildren(t){let e=t.firstChild,i=!0;for(;e;)if(e.nodeType===Node.ELEMENT_NODE?i=this.startElement(e):e.nodeType===Node.TEXT_NODE?this.chars(e.nodeValue):this.sanitizedSomething=!0,i&&e.firstChild)e=e.firstChild;else for(;e;){e.nodeType===Node.ELEMENT_NODE&&this.endElement(e);let r=this.checkClobberedElement(e,e.nextSibling);if(r){e=r;break}e=this.checkClobberedElement(e,e.parentNode)}return this.buf.join("")}startElement(t){let e=t.nodeName.toLowerCase();if(!bL.hasOwnProperty(e))return this.sanitizedSomething=!0,!hve.hasOwnProperty(e);this.buf.push("<"),this.buf.push(e);let i=t.attributes;for(let r=0;r<i.length;r++){let o=i.item(r),s=o.name,a=s.toLowerCase();if(!D9.hasOwnProperty(a)){this.sanitizedSomething=!0;continue}let l=o.value;T3[a]&&(l=zx(l)),this.buf.push(" ",s,'="',XW(l),'"')}return this.buf.push(">"),!0}endElement(t){let e=t.nodeName.toLowerCase();bL.hasOwnProperty(e)&&!S9.hasOwnProperty(e)&&(this.buf.push("</"),this.buf.push(e),this.buf.push(">"))}chars(t){this.buf.push(XW(t))}checkClobberedElement(t,e){if(e&&(t.compareDocumentPosition(e)&Node.DOCUMENT_POSITION_CONTAINED_BY)===Node.DOCUMENT_POSITION_CONTAINED_BY)throw new Error(`Failed to sanitize html because the element is clobbered: ${t.outerHTML}`);return e}}).sanitizeChildren(CL(e)||e);return O0(a)}finally{if(e){let i=CL(e)||e;for(;i.firstChild;)i.removeChild(i.firstChild)}}}function CL(n){return"content"in n&&function(n){return n.nodeType===Node.ELEMENT_NODE&&"TEMPLATE"===n.nodeName}(n)?n.content:null}var mo=(()=>{return(n=mo||(mo={}))[n.NONE=0]="NONE",n[n.HTML=1]="HTML",n[n.STYLE=2]="STYLE",n[n.SCRIPT=3]="SCRIPT",n[n.URL=4]="URL",n[n.RESOURCE_URL=5]="RESOURCE_URL",mo;var n})();function A3(n){let t=Gx();return t?WW(t.sanitize(mo.HTML,n)||""):Pc(n,"HTML")?WW(Ta(n)):D3(_9(),Kn(n))}function zl(n){let t=Gx();return t?t.sanitize(mo.URL,n)||"":Pc(n,"URL")?Ta(n):zx(Kn(n))}function A9(n){let t=Gx();if(t)return YW(t.sanitize(mo.RESOURCE_URL,n)||"");if(Pc(n,"ResourceURL"))return YW(Ta(n));throw new At(904,!1)}function Gx(){let n=rt();return n&&n[12]}var mT=new pe("ENVIRONMENT_INITIALIZER"),I9=new pe("INJECTOR",-1),P9=new pe("INJECTOR_DEF_TYPES"),K1=class{get(t,e=Tx){if(e===Tx){let i=new Error(`NullInjectorError: No provider for ${To(t)}!`);throw i.name="NullInjectorError",i}return e}};function Mve(...n){return{"\u0275providers":R9(0,n)}}function R9(n,...t){let r,e=[],i=new Set;return Ex(t,o=>{let s=o;ML(s,e,[],i)&&(r||(r=[]),r.push(s))}),void 0!==r&&O9(r,e),e}function O9(n,t){for(let e=0;e<n.length;e++){let{providers:r}=n[e];Ex(r,o=>{t.push(o)})}}function ML(n,t,e,i){if(!(n=Ki(n)))return!1;let r=null,o=kW(n),s=!o&&Nl(n);if(o||s){if(s&&!s.standalone)return!1;r=n}else{let l=n.ngModule;if(o=kW(l),!o)return!1;r=l}let a=i.has(r);if(s){if(a)return!1;if(i.add(r),s.dependencies){let l="function"==typeof s.dependencies?s.dependencies():s.dependencies;for(let c of l)ML(c,t,e,i)}}else{if(!o)return!1;{if(null!=o.imports&&!a){let c;i.add(r);try{Ex(o.imports,u=>{ML(u,t,e,i)&&(c||(c=[]),c.push(u))})}finally{}void 0!==c&&O9(c,t)}if(!a){let c=Wf(r)||(()=>new r);t.push({provide:r,useFactory:c,deps:Qi},{provide:P9,useValue:r,multi:!0},{provide:mT,useValue:()=>j(r),multi:!0})}let l=o.providers;null==l||a||Ex(l,u=>{t.push(u)})}}return r!==n&&void 0!==n.providers}var wve=mr({provide:String,useValue:mr});function k9(n){return null!==n&&"object"==typeof n&&wve in n}function k0(n){return"function"==typeof n}var VN,gT=new pe("Set Injector scope."),P1={},Dve={};function I3(){return void 0===VN&&(VN=new K1),VN}var jp=class{},Z1=class extends jp{constructor(t,e,i,r){super(),this.parent=e,this.source=i,this.scopes=r,this.records=new Map,this._ngOnDestroyHooks=new Set,this._onDestroyHooks=[],this._destroyed=!1,SL(t,s=>this.processProvider(s)),this.records.set(I9,E0(void 0,this)),r.has("environment")&&this.records.set(jp,E0(void 0,this));let o=this.records.get(gT);null!=o&&"string"==typeof o.value&&this.scopes.add(o.value),this.injectorDefTypes=new Set(this.get(P9.multi,Qi,di.Self))}get destroyed(){return this._destroyed}destroy(){this.assertNotDestroyed(),this._destroyed=!0;try{for(let t of this._ngOnDestroyHooks)t.ngOnDestroy();for(let t of this._onDestroyHooks)t()}finally{this.records.clear(),this._ngOnDestroyHooks.clear(),this.injectorDefTypes.clear(),this._onDestroyHooks.length=0}}onDestroy(t){this._onDestroyHooks.push(t)}runInContext(t){this.assertNotDestroyed();let e=x0(this),i=kl(void 0);try{return t()}finally{x0(e),kl(i)}}get(t,e=Tx,i=di.Default){this.assertNotDestroyed();let r=x0(this),o=kl(void 0);try{if(!(i&di.SkipSelf)){let a=this.records.get(t);if(void 0===a){let l=("function"==typeof(n=t)||"object"==typeof n&&n instanceof pe)&&a3(t);a=l&&this.injectableDefInScope(l)?E0(wL(t),P1):null,this.records.set(t,a)}if(null!=a)return this.hydrate(t,a)}return(i&di.Self?I3():this.parent).get(t,e=i&di.Optional&&e===Tx?null:e)}catch(s){if("NullInjectorError"===s.name){if((s[Q1]=s[Q1]||[]).unshift(To(t)),r)throw s;return function(n,t,e,i){let r=n[Q1];throw t[zW]&&r.unshift(t[zW]),n.message=function(n,t,e,i=null){n=n&&"\n"===n.charAt(0)&&"\u0275"==n.charAt(1)?n.slice(2):n;let r=To(t);if(Array.isArray(t))r=t.map(To).join(" -> ");else if("object"==typeof t){let o=[];for(let s in t)if(t.hasOwnProperty(s)){let a=t[s];o.push(s+":"+("string"==typeof a?JSON.stringify(a):To(a)))}r=`{${o.join(", ")}}`}return`${e}${i?"("+i+")":""}[${r}]: ${n.replace(z_e,"\n  ")}`}("\n"+n.message,r,e,i),n.ngTokenPath=r,n[Q1]=null,n}(s,t,"R3InjectorError",this.source)}throw s}finally{kl(o),x0(r)}var n}resolveInjectorInitializers(){let t=x0(this),e=kl(void 0);try{let i=this.get(mT.multi,Qi,di.Self);for(let r of i)r()}finally{x0(t),kl(e)}}toString(){let t=[],e=this.records;for(let i of e.keys())t.push(To(i));return`R3Injector[${t.join(", ")}]`}assertNotDestroyed(){if(this._destroyed)throw new At(205,!1)}processProvider(t){let e=k0(t=Ki(t))?t:Ki(t&&t.provide),i=function(n){return k9(n)?E0(void 0,n.useValue):E0(F9(n),P1)}(t);if(k0(t)||!0!==t.multi)this.records.get(e);else{let r=this.records.get(e);r||(r=E0(void 0,P1,!0),r.factory=()=>dL(r.multi),this.records.set(e,r)),e=t,r.multi.push(t)}this.records.set(e,i)}hydrate(t,e){return e.value===P1&&(e.value=Dve,e.value=e.factory()),"object"==typeof e.value&&e.value&&null!==(n=e.value)&&"object"==typeof n&&"function"==typeof n.ngOnDestroy&&this._ngOnDestroyHooks.add(e.value),e.value;var n}injectableDefInScope(t){if(!t.providedIn)return!1;let e=Ki(t.providedIn);return"string"==typeof e?"any"===e||this.scopes.has(e):this.injectorDefTypes.has(e)}};function wL(n){let t=a3(n),e=null!==t?t.factory:Wf(n);if(null!==e)return e;if(n instanceof pe)throw new At(204,!1);if(n instanceof Function)return function(n){let t=n.length;if(t>0)throw fx(t,"?"),new At(204,!1);let e=function(n){let t=n&&(n[L1]||n[D7]);if(t){let e=function(n){if(n.hasOwnProperty("name"))return n.name;let t=(""+n).match(/^function\s*([^\s(]+)/);return null===t?"":t[1]}(n);return console.warn(`DEPRECATED: DI is instantiating a token "${e}" that inherits its @Injectable decorator but does not provide one itself.\nThis will become an error in a future version of Angular. Please add @Injectable() to the "${e}" class.`),t}return null}(n);return null!==e?()=>e.factory(n):()=>new n}(n);throw new At(204,!1)}function F9(n,t,e){let i;if(k0(n)){let r=Ki(n);return Wf(r)||wL(r)}if(k9(n))i=()=>Ki(n.useValue);else if(function(n){return!(!n||!n.useFactory)}(n))i=()=>n.useFactory(...dL(n.deps||[]));else if(function(n){return!(!n||!n.useExisting)}(n))i=()=>j(Ki(n.useExisting));else{let r=Ki(n&&(n.useClass||n.provide));if(!function(n){return!!n.deps}(n))return Wf(r)||wL(r);i=()=>new r(...dL(n.deps))}return i}function E0(n,t,e=!1){return{factory:n,value:t,multi:e?[]:void 0}}function kve(n){return!!n.\u0275providers}function SL(n,t){for(let e of n)Array.isArray(e)?SL(e,t):kve(e)?SL(e.\u0275providers,t):t(e)}var EL=class{},J1=class{},TL=class{resolveComponentFactory(t){throw function(n){let t=Error(`No component factory found for ${To(n)}. Did you add it to @NgModule.entryComponents?`);return t.ngComponent=n,t}(t)}},gs=(()=>{class n{}return n.NULL=new TL,n})();function Lve(){return G0(zo(),rt())}function G0(n,t){return new Re(Ul(n,t))}var Re=(()=>{class n{constructor(e){this.nativeElement=e}}return n.__NG_ELEMENT_ID__=Lve,n})();function Bve(n){return n instanceof Re?n.nativeElement:n}new pe("Renderer2Interceptor");var wu=class{},Eu=(()=>{class n{}return n.__NG_ELEMENT_ID__=()=>function(){let n=rt(),e=qp(zo().index,n);return(zf(e)?e:n)[11]}(),n})(),Hve=(()=>{class n{}return n.\u0275prov=ye({token:n,providedIn:"root",factory:()=>null}),n})(),Ic=class{constructor(t){this.full=t,this.major=t.split(".")[0],this.minor=t.split(".")[1],this.patch=t.split(".").slice(2).join(".")}},Uve=new Ic("14.2.11"),HN={};function UN(n){return n.ngOriginalError}var Qs=class{constructor(){this._console=console}handleError(t){let e=this._findOriginalError(t);this._console.error("ERROR",t),e&&this._console.error("ORIGINAL ERROR",e)}_findOriginalError(t){let e=t&&UN(t);for(;e&&UN(e);)e=UN(e);return e||null}},jve=/^>|^->|<!--|-->|--!>|<!-$/g,Gve=/(<|>)/,N9=new Map,Yve=0,QW="__ngContext__";function Su(n,t){zf(t)?(n[QW]=t[20],function(n){N9.set(n[20],n)}(t)):n[QW]=t}function Wx(n){return n.ownerDocument.defaultView}function _T(n){return n.ownerDocument}function R1(n){return n instanceof Function?n():n}var DL,Bl=(()=>{return(n=Bl||(Bl={}))[n.Important=1]="Important",n[n.DashCase=2]="DashCase",Bl;var n})();function P3(n,t){return DL(n,t)}function R3(n){let t=n[3];return Vd(t)?t[3]:t}function O3(n){return B9(n[13])}function k3(n){return B9(n[4])}function B9(n){for(;null!==n&&!Vd(n);)n=n[4];return n}function T0(n,t,e,i,r){if(null!=i){let o,s=!1;Vd(i)?o=i:zf(i)&&(s=!0,i=i[0]);let a=$a(i);0===n&&null!==e?null==r?G9(t,e,a):Yf(t,e,a,r||null,!0):1===n&&null!==e?Yf(t,e,a,r||null,!0):2===n?K9(t,a,s):3===n&&t.destroyNode(a),null!=o&&function(n,t,e,i,r){let o=e[7];o!==$a(e)&&T0(t,n,i,o,r);for(let a=10;a<e.length;a++){let l=e[a];qx(l[1],l,n,t,i,o)}}(t,n,o,e,r)}}function F3(n,t){return n.createText(t)}function V9(n,t,e){n.setValue(t,e)}function eye(n,t){return n.createComment(function(n){return n.replace(jve,t=>t.replace(Gve,"\u200b$1\u200b"))}(t))}function N3(n,t,e){return n.createElement(t,e)}function H9(n,t){let e=n[9],i=e.indexOf(t),r=t[3];512&t[2]&&(t[2]&=-513,f3(r,-1)),e.splice(i,1)}function AL(n,t){if(n.length<=10)return;let e=10+t,i=n[e];if(i){let r=i[17];null!==r&&r!==n&&H9(r,i),t>0&&(n[e-1][4]=i[4]);let o=X1(n,10+t);!function(n,t){qx(n,t,t[11],2,null,null),t[0]=null,t[6]=null}(i[1],i);let s=o[19];null!==s&&s.detachView(o[1]),i[3]=null,i[4]=null,i[2]&=-65}return i}function U9(n,t){if(!(128&t[2])){let e=t[11];e.destroyNode&&qx(n,t,e,3,null,null),function(n){let t=n[13];if(!t)return zN(n[1],n);for(;t;){let e=null;if(zf(t))e=t[13];else{let i=t[10];i&&(e=i)}if(!e){for(;t&&!t[4]&&t!==n;)zf(t)&&zN(t[1],t),t=t[3];null===t&&(t=n),zf(t)&&zN(t[1],t),e=t&&t[4]}t=e}}(t)}}function zN(n,t){if(!(128&t[2])){t[2]&=-65,t[2]|=128,function(n,t){let e;if(null!=n&&null!=(e=n.destroyHooks))for(let i=0;i<e.length;i+=2){let r=t[e[i]];if(!(r instanceof qf)){let o=e[i+1];if(Array.isArray(o))for(let s=0;s<o.length;s+=2){let a=r[o[s]],l=o[s+1];try{l.call(a)}finally{}}else try{o.call(r)}finally{}}}}(n,t),function(n,t){let e=n.cleanup,i=t[7],r=-1;if(null!==e)for(let o=0;o<e.length-1;o+=2)if("string"==typeof e[o]){let s=e[o+1],a="function"==typeof s?s(t):$a(t[s]),l=i[r=e[o+2]],c=e[o+3];"boolean"==typeof c?a.removeEventListener(e[o],l,c):c>=0?i[r=c]():i[r=-c].unsubscribe(),o+=2}else{let s=i[r=e[o+1]];e[o].call(s)}if(null!==i){for(let o=r+1;o<i.length;o++)(0,i[o])();t[7]=null}}(n,t),1===t[1].type&&t[11].destroy();let e=t[17];if(null!==e&&Vd(t[3])){e!==t[3]&&H9(e,t);let i=t[19];null!==i&&i.detachView(n)}!function(n){N9.delete(n[20])}(t)}}function z9(n,t,e){return j9(n,t.parent,e)}function j9(n,t,e){let i=t;for(;null!==i&&40&i.type;)i=(t=i).parent;if(null===i)return e[0];if(2&i.flags){let r=n.data[i.directiveStart].encapsulation;if(r===Ja.None||r===Ja.Emulated)return null}return Ul(i,e)}function Yf(n,t,e,i,r){n.insertBefore(t,e,i,r)}function G9(n,t,e){n.appendChild(t,e)}function KW(n,t,e,i,r){null!==i?Yf(n,t,e,i,r):G9(n,t,e)}function vT(n,t){return n.parentNode(t)}function W9(n,t,e){return Y9(n,t,e)}function q9(n,t,e){return 40&n.type?Ul(n,e):null}var IL,Y9=q9;function X9(n,t){Y9=n,IL=t}function yT(n,t,e,i){let r=z9(n,i,t),o=t[11],a=W9(i.parent||t[6],i,t);if(null!=r)if(Array.isArray(e))for(let l=0;l<e.length;l++)KW(o,r,e[l],a,!1);else KW(o,r,e,a,!1);void 0!==IL&&IL(o,i,t,e,r)}function O1(n,t){if(null!==t){let e=t.type;if(3&e)return Ul(t,n);if(4&e)return PL(-1,n[t.index]);if(8&e){let i=t.child;if(null!==i)return O1(n,i);{let r=n[t.index];return Vd(r)?PL(-1,r):$a(r)}}if(32&e)return P3(t,n)()||$a(n[t.index]);{let i=Q9(n,t);return null!==i?Array.isArray(i)?i[0]:O1(R3(n[16]),i):O1(n,t.next)}}return null}function Q9(n,t){return null!==t?n[16][6].projection[t.projection]:null}function PL(n,t){let e=10+n+1;if(e<t.length){let i=t[e],r=i[1].firstChild;if(null!==r)return O1(i,r)}return t[7]}function K9(n,t,e){let i=vT(n,t);i&&function(n,t,e,i){n.removeChild(t,e,i)}(n,i,t,e)}function L3(n,t,e,i,r,o,s){for(;null!=e;){let a=i[e.index],l=e.type;if(s&&0===t&&(a&&Su($a(a),i),e.flags|=4),64!=(64&e.flags))if(8&l)L3(n,t,e.child,i,r,o,!1),T0(t,n,r,a,o);else if(32&l){let u,c=P3(e,i);for(;u=c();)T0(t,n,r,u,o);T0(t,n,r,a,o)}else 16&l?Z9(n,t,i,e,r,o):T0(t,n,r,a,o);e=s?e.projectionNext:e.next}}function qx(n,t,e,i,r,o){L3(e,i,n.firstChild,t,r,o,!1)}function Z9(n,t,e,i,r,o){let s=e[16],l=s[6].projection[i.projection];if(Array.isArray(l))for(let c=0;c<l.length;c++)T0(t,n,r,l[c],o);else L3(n,t,l,s[3],r,o,!0)}function J9(n,t,e){n.setAttribute(t,"style",e)}function B3(n,t,e){""===e?n.removeAttribute(t,"class"):n.setAttribute(t,"class",e)}function $9(n,t,e){let i=n.length;for(;;){let r=n.indexOf(t,e);if(-1===r)return r;if(0===r||n.charCodeAt(r-1)<=32){let o=t.length;if(r+o===i||n.charCodeAt(r+o)<=32)return r}e=r+1}}var eq="ng-template";function fye(n,t,e){let i=0;for(;i<n.length;){let r=n[i++];if(e&&"class"===r){if(r=n[i],-1!==$9(r.toLowerCase(),t,0))return!0}else if(1===r){for(;i<n.length&&"string"==typeof(r=n[i++]);)if(r.toLowerCase()===t)return!0;return!1}}return!1}function tq(n){return 4===n.type&&n.value!==eq}function mye(n,t,e){return t===(4!==n.type||e?n.value:eq)}function gye(n,t,e){let i=4,r=n.attrs||[],o=function(n){for(let t=0;t<n.length;t++)if($7(n[t]))return t;return n.length}(r),s=!1;for(let a=0;a<t.length;a++){let l=t[a];if("number"!=typeof l){if(!s)if(4&i){if(i=2|1&i,""!==l&&!mye(n,l,e)||""===l&&1===t.length){if(Sc(i))return!1;s=!0}}else{let c=8&i?l:t[++a];if(8&i&&null!==n.attrs){if(!fye(n.attrs,c,e)){if(Sc(i))return!1;s=!0}continue}let d=_ye(8&i?"class":l,r,tq(n),e);if(-1===d){if(Sc(i))return!1;s=!0;continue}if(""!==c){let p;p=d>o?"":r[d+1].toLowerCase();let h=8&i?p:null;if(h&&-1!==$9(h,c,0)||2&i&&c!==p){if(Sc(i))return!1;s=!0}}}}else{if(!s&&!Sc(i)&&!Sc(l))return!1;if(s&&Sc(l))continue;s=!1,i=l|1&i}}return Sc(i)||s}function Sc(n){return 0==(1&n)}function _ye(n,t,e,i){if(null===t)return-1;let r=0;if(i||!e){let o=!1;for(;r<t.length;){let s=t[r];if(s===n)return r;if(3===s||6===s)o=!0;else{if(1===s||2===s){let a=t[++r];for(;"string"==typeof a;)a=t[++r];continue}if(4===s)break;if(0===s){r+=4;continue}}r+=o?1:2}return-1}return function(n,t){let e=n.indexOf(4);if(e>-1)for(e++;e<n.length;){let i=n[e];if("number"==typeof i)return-1;if(i===t)return e;e++}return-1}(t,n)}function nq(n,t,e=!1){for(let i=0;i<t.length;i++)if(gye(n,t[i],e))return!0;return!1}function xye(n,t){e:for(let e=0;e<t.length;e++){let i=t[e];if(n.length===i.length){for(let r=0;r<n.length;r++)if(n[r]!==i[r])continue e;return!0}}return!1}function ZW(n,t){return n?":not("+t.trim()+")":t}function Cye(n){let t=n[0],e=1,i=2,r="",o=!1;for(;e<n.length;){let s=n[e];if("string"==typeof s)if(2&i){let a=n[++e];r+="["+s+(a.length>0?'="'+a+'"':"")+"]"}else 8&i?r+="."+s:4&i&&(r+=" "+s);else""!==r&&!Sc(s)&&(t+=ZW(o,r),r=""),i=s,o=o||!Sc(i);e++}return""!==r&&(t+=ZW(o,r)),t}var Qn={};function C(n){iq(Fi(),rt(),Zs()+n,!1)}function iq(n,t,e,i){if(!i)if(3==(3&t[2])){let o=n.preOrderCheckHooks;null!==o&&D1(t,o,e)}else{let o=n.preOrderHooks;null!==o&&A1(t,o,0,e)}zp(e)}var JW={"\u0275\u0275defineInjectable":ye,"\u0275\u0275defineInjector":V,"\u0275\u0275inject":j,"\u0275\u0275invalidFactoryDep":d9,resolveForwardRef:Ki};var Eye=mr({provide:String,useValue:mr});function $W(n){return void 0!==n.useClass}function e7(n){return void 0!==n.useFactory}var rq=Vx("Injectable",void 0,void 0,void 0,(n,t)=>function(n,t){let e=null,i=null;n.hasOwnProperty(L1)||Object.defineProperty(n,L1,{get:()=>(null===e&&(e=Ll().compileInjectable(JW,`ng:///${n.name}/\u0275prov.js`,function(n,t){let e=t||{providedIn:null},i={name:n.name,type:n,typeArgumentCount:0,providedIn:e.providedIn};return($W(e)||e7(e))&&void 0!==e.deps&&(i.deps=p9(e.deps)),$W(e)?i.useClass=e.useClass:function(n){return Eye in n}(e)?i.useValue=e.useValue:e7(e)?i.useFactory=e.useFactory:function(n){return void 0!==n.useExisting}(e)&&(i.useExisting=e.useExisting),i}(n,t))),e)}),n.hasOwnProperty(Nd)||Object.defineProperty(n,Nd,{get:()=>{if(null===i){let r=Ll();i=r.compileFactory(JW,`ng:///${n.name}/\u0275fac.js`,{name:n.name,type:n,typeArgumentCount:0,deps:fT(n),target:r.FactoryTarget.Injectable})}return i},configurable:!0})}(n,t));function t7(n,t=null,e=null,i){let r=oq(n,t,e,i);return r.resolveInjectorInitializers(),r}function oq(n,t=null,e=null,i,r=new Set){let o=[e||Qi,Mve(n)];return i=i||("object"==typeof n?void 0:To(n)),new Z1(o,t||I3(),i||null,r)}var Xn=(()=>{class n{static create(e,i){if(Array.isArray(e))return t7({name:""},i,e,"");{let r=e.name??"";return t7({name:r},e.parent,e.providers,r)}}}return n.THROW_IF_NOT_FOUND=Tx,n.NULL=new K1,n.\u0275prov=ye({token:n,providedIn:"any",factory:()=>j(I9)}),n.__NG_ELEMENT_ID__=-1,n})(),gx=class{constructor(t,e){if(this.token=t,this.id=e,!t)throw new At(208,!1);this.displayName=To(this.token)}static get(t){return n7.get(Ki(t))}static get numberOfKeys(){return n7.numberOfKeys}},n7=new class{constructor(){this._allKeys=new Map}get(t){if(t instanceof gx)return t;if(this._allKeys.has(t))return this._allKeys.get(t);let e=new gx(t,gx.numberOfKeys);return this._allKeys.set(t,e),e}get numberOfKeys(){return this._allKeys.size}};function M(n,t=di.Default){let e=rt();return null===e?j(n,t):s9(zo(),e,Ki(n),t)}function nl(){throw new Error("invalid")}function E1(n,t){return n<<17|t<<2}function Xf(n){return n>>17&32767}function OL(n){return 2|n}function F0(n){return(131068&n)>>2}function jN(n,t){return-131069&n|t<<2}function kL(n){return 1|n}function sq(n,t){let e=n.contentQueries;if(null!==e)for(let i=0;i<e.length;i+=2){let r=e[i],o=e[i+1];if(-1!==o){let s=n.data[o];v3(r),s.contentQueries(2,t[o],o)}}}function bT(n,t,e,i,r,o,s,a,l,c,u){let d=t.blueprint.slice();return d[0]=r,d[2]=76|i,(null!==u||n&&1024&n[2])&&(d[2]|=1024),U7(d),d[3]=d[15]=n,d[8]=e,d[10]=s||n&&n[10],d[11]=a||n&&n[11],d[12]=l||n&&n[12]||null,d[9]=c||n&&n[9]||null,d[6]=o,d[20]=Yve++,d[21]=u,d[16]=2==t.type?n[16]:d,d}function W0(n,t,e,i,r){let o=n.data[t];if(null===o)o=V3(n,t,e,i,r),Zn.lFrame.inI18n&&(o.flags|=64);else if(64&o.type){o.type=e,o.value=i,o.attrs=r;let s=wx();o.injectorIndex=null===s?-1:s.injectorIndex}return Mu(o,!0),o}function V3(n,t,e,i,r){let o=j7(),s=m3(),l=n.data[t]=function(n,t,e,i,r,o){return{type:e,index:i,insertBeforeIndex:null,injectorIndex:t?t.injectorIndex:-1,directiveStart:-1,directiveEnd:-1,directiveStylingLast:-1,propertyBindings:null,flags:0,providerIndexes:0,value:r,attrs:o,mergedAttrs:null,localNames:null,initialInputs:void 0,inputs:null,outputs:null,tViews:null,next:null,projectionNext:null,child:null,parent:t,projection:null,styles:null,stylesWithoutHost:null,residualStyles:void 0,classes:null,classesWithoutHost:null,residualClasses:void 0,classBindings:0,styleBindings:0}}(0,s?o:o&&o.parent,e,t,i,r);return null===n.firstChild&&(n.firstChild=l),null!==o&&(s?null==o.child&&null!==l.parent&&(o.child=l):null===o.next&&(o.next=l)),l}function q0(n,t,e,i){if(0===e)return-1;let r=t.length;for(let o=0;o<e;o++)t.push(i),n.blueprint.push(i),n.data.push(null);return r}function H3(n,t,e){y3(t);try{let i=n.viewQuery;null!==i&&NL(1,i,e);let r=n.template;null!==r&&aq(n,t,r,1,e),n.firstCreatePass&&(n.firstCreatePass=!1),n.staticContentQueries&&sq(n,t),n.staticViewQueries&&NL(2,n.viewQuery,e);let o=n.components;null!==o&&function(n,t){for(let e=0;e<t.length;e++)$ye(n,t[e])}(t,o)}catch(i){throw n.firstCreatePass&&(n.incompleteFirstPass=!0,n.firstCreatePass=!1),i}finally{t[2]&=-5,b3()}}function xT(n,t,e,i){let r=t[2];if(128!=(128&r)){y3(t);try{U7(t),G7(n.bindingStartIndex),null!==e&&aq(n,t,e,2,i);let s=3==(3&r);if(s){let c=n.preOrderCheckHooks;null!==c&&D1(t,c,null)}else{let c=n.preOrderHooks;null!==c&&A1(t,c,0,null),FN(t,0)}if(function(n){for(let t=O3(n);null!==t;t=k3(t)){if(!t[2])continue;let e=t[9];for(let i=0;i<e.length;i++){let r=e[i],o=r[3];0==(512&r[2])&&f3(o,1),r[2]|=512}}}(t),function(n){for(let t=O3(n);null!==t;t=k3(t))for(let e=10;e<t.length;e++){let i=t[e],r=i[1];U1(i)&&xT(r,i,r.template,i[8])}}(t),null!==n.contentQueries&&sq(n,t),s){let c=n.contentCheckHooks;null!==c&&D1(t,c)}else{let c=n.contentHooks;null!==c&&A1(t,c,1),FN(t,1)}!function(n,t){let e=n.hostBindingOpCodes;if(null!==e)try{for(let i=0;i<e.length;i++){let r=e[i];if(r<0)zp(~r);else{let o=r,s=e[++i],a=e[++i];s_e(s,o),a(2,t[o])}}}finally{zp(-1)}}(n,t);let a=n.components;null!==a&&function(n,t){for(let e=0;e<t.length;e++)Jye(n,t[e])}(t,a);let l=n.viewQuery;if(null!==l&&NL(2,l,i),s){let c=n.viewCheckHooks;null!==c&&D1(t,c)}else{let c=n.viewHooks;null!==c&&A1(t,c,2),FN(t,2)}!0===n.firstUpdatePass&&(n.firstUpdatePass=!1),t[2]&=-41,512&t[2]&&(t[2]&=-513,f3(t[3],-1))}finally{b3()}}}function aq(n,t,e,i,r){let o=Zs(),s=2&i;try{zp(-1),s&&t.length>22&&iq(n,t,22,!1),e(i,r)}finally{zp(o)}}function lq(n,t,e){if(p3(t)){let r=t.directiveEnd;for(let o=t.directiveStart;o<r;o++){let s=n.data[o];s.contentQueries&&s.contentQueries(1,e[o],o)}}}function U3(n,t,e){!z7()||(function(n,t,e,i){let r=e.directiveStart,o=e.directiveEnd;n.firstCreatePass||Sx(e,t),Su(i,t);let s=e.initialInputs;for(let a=r;a<o;a++){let l=n.data[a],c=Ac(l);c&&Yye(t,e,l);let u=Bx(t,n,a,e);Su(u,t),null!==s&&Xye(0,a-r,u,l,0,s),c&&(qp(e.index,t)[8]=u)}}(n,t,e,Ul(e,t)),128==(128&e.flags)&&function(n,t,e){let i=e.directiveStart,r=e.directiveEnd,o=e.index,s=Zn.lFrame.currentDirectiveIndex;try{zp(o);for(let a=i;a<r;a++){let l=n.data[a],c=t[a];sL(a),(null!==l.hostBindings||0!==l.hostVars||null!==l.hostAttrs)&&fq(l,c)}}finally{zp(-1),sL(s)}}(n,t,e))}function z3(n,t,e=Ul){let i=t.localNames;if(null!==i){let r=t.index+1;for(let o=0;o<i.length;o+=2){let s=i[o+1],a=-1===s?e(t,n):n[s];n[r++]=a}}}function cq(n){let t=n.tView;return null===t||t.incompleteFirstPass?n.tView=j3(1,null,n.template,n.decls,n.vars,n.directiveDefs,n.pipeDefs,n.viewQuery,n.schemas,n.consts):t}function j3(n,t,e,i,r,o,s,a,l,c){let u=22+i,d=u+r,p=function(n,t){let e=[];for(let i=0;i<t;i++)e.push(i<n?null:Qn);return e}(u,d),h="function"==typeof c?c():c;return p[1]={type:n,blueprint:p,template:e,queries:null,viewQuery:a,declTNode:t,data:p.slice().fill(null,u),bindingStartIndex:u,expandoStartIndex:d,hostBindingOpCodes:null,firstCreatePass:!0,firstUpdatePass:!0,staticViewQueries:!1,staticContentQueries:!1,preOrderHooks:null,preOrderCheckHooks:null,contentHooks:null,contentCheckHooks:null,viewHooks:null,viewCheckHooks:null,destroyHooks:null,cleanup:null,contentQueries:null,components:null,directiveRegistry:"function"==typeof o?o():o,pipeRegistry:"function"==typeof s?s():s,firstChild:null,schemas:l,consts:h,incompleteFirstPass:!1}}function uq(n,t,e,i){let r=xq(t);null===e?r.push(i):(r.push(e),n.firstCreatePass&&Cq(n).push(i,r.length-1))}function i7(n,t,e){for(let i in n)if(n.hasOwnProperty(i)){let r=n[i];(e=null===e?{}:e).hasOwnProperty(i)?e[i].push(t,r):e[i]=[t,r]}return e}function dq(n,t){let i=t.directiveEnd,r=n.data,o=t.attrs,s=[],a=null,l=null;for(let c=t.directiveStart;c<i;c++){let u=r[c],d=u.inputs,p=null===o||tq(t)?null:Qye(d,o);s.push(p),a=i7(d,c,a),l=i7(u.outputs,c,l)}null!==a&&(a.hasOwnProperty("class")&&(t.flags|=16),a.hasOwnProperty("style")&&(t.flags|=32)),t.initialInputs=s,t.inputs=a,t.outputs=l}function il(n,t,e,i,r,o,s,a){let u,l=Ul(t,e),c=t.inputs;!a&&null!=c&&(u=c[i])?(q3(n,e,u,i,r),h3(t)&&pq(e,t.index)):3&t.type&&(i=function(n){return"class"===n?"className":"for"===n?"htmlFor":"formaction"===n?"formAction":"innerHtml"===n?"innerHTML":"readonly"===n?"readOnly":"tabindex"===n?"tabIndex":n}(i),r=null!=s?s(r,t.value||"",i):r,o.setProperty(l,i,r))}function pq(n,t){let e=qp(t,n);16&e[2]||(e[2]|=32)}function G3(n,t,e,i){let r=!1;if(z7()){let o=function(n,t,e){let i=n.directiveRegistry,r=null;if(i)for(let o=0;o<i.length;o++){let s=i[o];nq(e,s.selectors,!1)&&(r||(r=[]),Y1(Sx(e,t),n,s.type),Ac(s)?(mq(n,e),r.unshift(s)):r.push(s))}return r}(n,t,e),s=null===i?null:{"":-1};if(null!==o){r=!0,gq(e,n.data.length,o.length);for(let u=0;u<o.length;u++){let d=o[u];d.providersResolver&&d.providersResolver(d)}let a=!1,l=!1,c=q0(n,t,o.length,null);for(let u=0;u<o.length;u++){let d=o[u];e.mergedAttrs=j1(e.mergedAttrs,d.hostAttrs),_q(n,e,t,c,d),qye(c,d,s),null!==d.contentQueries&&(e.flags|=8),(null!==d.hostBindings||null!==d.hostAttrs||0!==d.hostVars)&&(e.flags|=128);let p=d.type.prototype;!a&&(p.ngOnChanges||p.ngOnInit||p.ngDoCheck)&&((n.preOrderHooks||(n.preOrderHooks=[])).push(e.index),a=!0),!l&&(p.ngOnChanges||p.ngDoCheck)&&((n.preOrderCheckHooks||(n.preOrderCheckHooks=[])).push(e.index),l=!0),c++}dq(n,e)}s&&function(n,t,e){if(t){let i=n.localNames=[];for(let r=0;r<t.length;r+=2){let o=e[t[r+1]];if(null==o)throw new At(-301,!1);i.push(t[r],o)}}}(e,i,s)}return e.mergedAttrs=j1(e.mergedAttrs,e.attrs),r}function hq(n,t,e,i,r,o){let s=o.hostBindings;if(s){let a=n.hostBindingOpCodes;null===a&&(a=n.hostBindingOpCodes=[]);let l=~t.index;(function(n){let t=n.length;for(;t>0;){let e=n[--t];if("number"==typeof e&&e<0)return e}return 0})(a)!=l&&a.push(l),a.push(i,r,s)}}function fq(n,t){null!==n.hostBindings&&n.hostBindings(1,t)}function mq(n,t){t.flags|=2,(n.components||(n.components=[])).push(t.index)}function qye(n,t,e){if(e){if(t.exportAs)for(let i=0;i<t.exportAs.length;i++)e[t.exportAs[i]]=n;Ac(t)&&(e[""]=n)}}function gq(n,t,e){n.flags|=1,n.directiveStart=t,n.directiveEnd=t+e,n.providerIndexes=t}function _q(n,t,e,i,r){n.data[i]=r;let o=r.factory||(r.factory=Wf(r.type)),s=new qf(o,Ac(r),M);n.blueprint[i]=s,e[i]=s,hq(n,t,0,i,q0(n,e,r.hostVars,Qn),r)}function Yye(n,t,e){let i=Ul(t,n),r=cq(e),o=n[10],s=CT(n,bT(n,r,null,e.onPush?32:16,i,t,o,o.createRenderer(i,e),null,null,null));n[t.index]=s}function Tu(n,t,e,i,r,o){let s=Ul(n,t);W3(t[11],s,o,n.value,e,i,r)}function W3(n,t,e,i,r,o,s){if(null==o)n.removeAttribute(t,r,e);else{let a=null==s?Kn(o):s(o,i||"",r);n.setAttribute(t,r,a,e)}}function Xye(n,t,e,i,r,o){let s=o[t];if(null!==s){let a=i.setInput;for(let l=0;l<s.length;){let c=s[l++],u=s[l++],d=s[l++];null!==a?i.setInput(e,d,c,u):e[u]=d}}}function Qye(n,t){let e=null,i=0;for(;i<t.length;){let r=t[i];if(0!==r)if(5!==r){if("number"==typeof r)break;n.hasOwnProperty(r)&&(null===e&&(e=[]),e.push(r,n[r],t[i+1])),i+=2}else i+=2;else i+=4}return e}function vq(n,t,e,i){return new Array(n,!0,!1,t,null,0,i,e,null,null)}function Jye(n,t){let e=qp(t,n);if(U1(e)){let i=e[1];48&e[2]?xT(i,e,i.template,e[8]):e[5]>0&&FL(e)}}function FL(n){for(let i=O3(n);null!==i;i=k3(i))for(let r=10;r<i.length;r++){let o=i[r];if(U1(o))if(512&o[2]){let s=o[1];xT(s,o,s.template,o[8])}else o[5]>0&&FL(o)}let e=n[1].components;if(null!==e)for(let i=0;i<e.length;i++){let r=qp(e[i],n);U1(r)&&r[5]>0&&FL(r)}}function $ye(n,t){let e=qp(t,n),i=e[1];(function(n,t){for(let e=t.length;e<n.blueprint.length;e++)t.push(n.blueprint[e])})(i,e),H3(i,e,e[8])}function CT(n,t){return n[13]?n[14][4]=t:n[13]=t,n[14]=t,t}function yq(n){for(;n;){n[2]|=32;let t=R3(n);if(q0e(n)&&!t)return n;n=t}return null}function bq(n,t,e,i=!0){let r=t[10];r.begin&&r.begin();try{xT(n,t,n.template,e)}catch(s){throw i&&wq(t,s),s}finally{r.end&&r.end()}}function NL(n,t,e){v3(0),t(n,e)}function xq(n){return n[7]||(n[7]=[])}function Cq(n){return n.cleanup||(n.cleanup=[])}function Mq(n,t,e){return(null===n||Ac(n))&&(e=function(n){for(;Array.isArray(n);){if("object"==typeof n[1])return n;n=n[0]}return null}(e[t.index])),e[11]}function wq(n,t){let e=n[9],i=e?e.get(Qs,null):null;i&&i.handleError(t)}function q3(n,t,e,i,r){for(let o=0;o<e.length;){let s=e[o++],a=e[o++],l=t[s],c=n.data[s];null!==c.setInput?c.setInput(l,r,i,a):l[a]=r}}function jd(n,t,e){let i=pT(t,n);V9(n[11],i,e)}function $1(n,t,e){let i=e?n.styles:null,r=e?n.classes:null,o=0;if(null!==t)for(let s=0;s<t.length;s++){let a=t[s];"number"==typeof a?o=a:1==o?r=tL(r,a):2==o&&(i=tL(i,a+": "+t[++s]+";"))}e?n.styles=i:n.stylesWithoutHost=i,e?n.classes=r:n.classesWithoutHost=r}function k1(n,t,e,i,r=!1){for(;null!==e;){let o=t[e.index];if(null!==o&&i.push($a(o)),Vd(o))for(let a=10;a<o.length;a++){let l=o[a],c=l[1].firstChild;null!==c&&k1(l[1],l,c,i)}let s=e.type;if(8&s)k1(n,t,e.child,i);else if(32&s){let l,a=P3(e,t);for(;l=a();)i.push(l)}else if(16&s){let a=Q9(t,e);if(Array.isArray(a))i.push(...a);else{let l=R3(t[16]);k1(l[1],l,a,i,!0)}}e=r?e.projectionNext:e.next}return i}var Qf=class{constructor(t,e){this._lView=t,this._cdRefInjectingView=e,this._appRef=null,this._attachedToViewContainer=!1}get rootNodes(){let t=this._lView,e=t[1];return k1(e,t,e.firstChild,[])}get context(){return this._lView[8]}set context(t){this._lView[8]=t}get destroyed(){return 128==(128&this._lView[2])}destroy(){if(this._appRef)this._appRef.detachView(this);else if(this._attachedToViewContainer){let t=this._lView[3];if(Vd(t)){let e=t[8],i=e?e.indexOf(this):-1;i>-1&&(AL(t,i),X1(e,i))}this._attachedToViewContainer=!1}U9(this._lView[1],this._lView)}onDestroy(t){uq(this._lView[1],this._lView,null,t)}markForCheck(){yq(this._cdRefInjectingView||this._lView)}detach(){this._lView[2]&=-65}reattach(){this._lView[2]|=64}detectChanges(){bq(this._lView[1],this._lView,this.context)}checkNoChanges(){}attachToViewContainerRef(){if(this._appRef)throw new At(902,!1);this._attachedToViewContainer=!0}detachFromAppRef(){var t;this._appRef=null,qx(this._lView[1],t=this._lView,t[11],2,null,null)}attachToAppRef(t){if(this._attachedToViewContainer)throw new At(902,!1);this._appRef=t}},LL=class extends Qf{constructor(t){super(t),this._view=t}detectChanges(){let t=this._view;bq(t[1],t,t[8],!1)}checkNoChanges(){}get context(){return null}},Ax=class extends gs{constructor(t){super(),this.ngModule=t}resolveComponentFactory(t){let e=Nl(t);return new eT(e,this.ngModule)}};function r7(n){let t=[];for(let e in n)n.hasOwnProperty(e)&&t.push({propName:n[e],templateName:e});return t}var eT=class extends J1{constructor(t,e){super(),this.componentDef=t,this.ngModule=e,this.componentType=t.type,this.selector=t.selectors.map(Cye).join(","),this.ngContentSelectors=t.ngContentSelectors?t.ngContentSelectors:[],this.isBoundToModule=!!e}get inputs(){return r7(this.componentDef.inputs)}get outputs(){return r7(this.componentDef.outputs)}create(t,e,i,r){let o=(r=r||this.ngModule)instanceof jp?r:r?.injector;o&&null!==this.componentDef.getStandaloneInjector&&(o=this.componentDef.getStandaloneInjector(o)||o);let s=o?new class{constructor(t,e){this.injector=t,this.parentInjector=e}get(t,e,i){let r=this.injector.get(t,HN,i);return r!==HN||e===HN?r:this.parentInjector.get(t,e,i)}}(t,o):t,a=s.get(wu,null);if(null===a)throw new At(407,!1);let m,x,l=s.get(Hve,null),c=a.createRenderer(null,this.componentDef),u=this.componentDef.selectors[0][0]||"div",d=i?function(n,t,e){return n.selectRootElement(t,e===Ja.ShadowDom)}(c,i,this.componentDef.encapsulation):N3(c,u,function(n){let t=n.toLowerCase();return"svg"===t?"svg":"math"===t?"math":null}(u)),p=this.componentDef.onPush?288:272,h=j3(0,null,null,1,0,null,null,null,null,null),f=bT(null,h,null,p,null,null,a,c,l,s,null);y3(f);try{let g=function(n,t,e,i,r,o){let s=e[1];e[22]=n;let l=W0(s,22,2,"#host",null),c=l.mergedAttrs=t.hostAttrs;null!==c&&($1(l,c,!0),null!==n&&(z1(r,n,c),null!==l.classes&&B3(r,n,l.classes),null!==l.styles&&J9(r,n,l.styles)));let u=i.createRenderer(n,t),d=bT(e,cq(t),null,t.onPush?32:16,e[22],l,i,u,null,null,null);return s.firstCreatePass&&(Y1(Sx(l,e),s,t.type),mq(s,l),gq(l,e.length,1)),CT(e,d),e[22]=d}(d,this.componentDef,f,a,c);if(d)if(i)z1(c,d,["ng-version",Uve.full]);else{let{attrs:b,classes:D}=function(n){let t=[],e=[],i=1,r=2;for(;i<n.length;){let o=n[i];if("string"==typeof o)2===r?""!==o&&t.push(o,n[++i]):8===r&&e.push(o);else{if(!Sc(r))break;r=o}i++}return{attrs:t,classes:e}}(this.componentDef.selectors[0]);b&&z1(c,d,b),D&&D.length>0&&B3(c,d,D.join(" "))}if(x=H7(h,22),void 0!==e){let b=x.projection=[];for(let D=0;D<this.ngContentSelectors.length;D++){let T=e[D];b.push(null!=T?Array.from(T):null)}}m=function(n,t,e,i){let r=e[1],o=function(n,t,e){let i=zo();n.firstCreatePass&&(e.providersResolver&&e.providersResolver(e),_q(n,i,t,q0(n,t,1,null),e),dq(n,i));let r=Bx(t,n,i.directiveStart,i);Su(r,t);let o=Ul(i,t);return o&&Su(o,t),r}(r,e,t);if(n[8]=e[8]=o,null!==i)for(let a of i)a(o,t);if(t.contentQueries){let a=zo();t.contentQueries(1,o,a.directiveStart)}let s=zo();return!r.firstCreatePass||null===t.hostBindings&&null===t.hostAttrs||(zp(s.index),hq(e[1],s,0,s.directiveStart,s.directiveEnd,t),fq(t,o)),o}(g,this.componentDef,f,[rbe]),H3(h,f,null)}finally{b3()}return new VL(this.componentType,m,G0(x,f),f,x)}},VL=(new Ax,class extends EL{constructor(t,e,i,r,o){super(),this.location=i,this._rootLView=r,this._tNode=o,this.instance=e,this.hostView=this.changeDetectorRef=new LL(r),this.componentType=t}setInput(t,e){let r,i=this._tNode.inputs;if(null!==i&&(r=i[t])){let o=this._rootLView;q3(o[1],o,r,t,e),pq(o,this._tNode.index)}}get injector(){return new jf(this._tNode,this._rootLView)}destroy(){this.hostView.destroy()}onDestroy(t){this.hostView.onDestroy(t)}});function rbe(){let n=zo();hT(rt()[1],n)}function Sq(n){return Object.getPrototypeOf(n.prototype).constructor}function tt(n){let t=Sq(n.type),e=!0,i=[n];for(;t;){let r;if(Ac(n))r=t.\u0275cmp||t.\u0275dir;else{if(t.\u0275cmp)throw new At(903,!1);r=t.\u0275dir}if(r){if(e){i.push(r);let s=n;s.inputs=GN(n.inputs),s.declaredInputs=GN(n.declaredInputs),s.outputs=GN(n.outputs);let a=r.hostBindings;a&&lbe(n,a);let l=r.viewQuery,c=r.contentQueries;if(l&&sbe(n,l),c&&abe(n,c),kN(n.inputs,r.inputs),kN(n.declaredInputs,r.declaredInputs),kN(n.outputs,r.outputs),Ac(r)&&r.data.animation){let u=n.data;u.animation=(u.animation||[]).concat(r.data.animation)}}let o=r.features;if(o)for(let s=0;s<o.length;s++){let a=o[s];a&&a.ngInherit&&a(n),a===tt&&(e=!1)}}t=Object.getPrototypeOf(t)}!function(n){let t=0,e=null;for(let i=n.length-1;i>=0;i--){let r=n[i];r.hostVars=t+=r.hostVars,r.hostAttrs=j1(r.hostAttrs,e=j1(e,r.hostAttrs))}}(i)}function GN(n){return n===A0?{}:n===Qi?[]:n}function sbe(n,t){let e=n.viewQuery;n.viewQuery=e?(i,r)=>{t(i,r),e(i,r)}:t}function abe(n,t){let e=n.contentQueries;n.contentQueries=e?(i,r,o)=>{t(i,r,o),e(i,r,o)}:t}function lbe(n,t){let e=n.hostBindings;n.hostBindings=e?(i,r)=>{t(i,r),e(i,r)}:t}var cbe=["providersResolver"],ube=["template","decls","consts","vars","onPush","ngContentSelectors","styles","encapsulation","schemas"];var T1=null;function MT(){if(!T1){let n=to.Symbol;if(n&&n.iterator)T1=n.iterator;else{let t=Object.getOwnPropertyNames(Map.prototype);for(let e=0;e<t.length;++e){let i=t[e];"entries"!==i&&"size"!==i&&Map.prototype[i]===Map.prototype.entries&&(T1=i)}}}return T1}function wT(n){return!!Y3(n)&&(Array.isArray(n)||!(n instanceof Map)&&MT()in n)}function Y3(n){return null!==n&&("function"==typeof n||"object"==typeof n)}function Du(n,t,e){return n[t]=e}function Yx(n,t){return n[t]}function Ds(n,t,e){return!Object.is(n[t],e)&&(n[t]=e,!0)}function Kf(n,t,e,i){let r=Ds(n,t,e);return Ds(n,t+1,i)||r}function ST(n,t,e,i,r){let o=Kf(n,t,e,i);return Ds(n,t+2,r)||o}function Vl(n,t,e,i,r,o){let s=Kf(n,t,e,i);return Kf(n,t+2,r,o)||s}function ze(n,t,e,i){let r=rt();return Ds(r,U0(),t)&&(Fi(),Tu(no(),r,n,t,e,i)),ze}function Y0(n,t){let e=!1,i=Hd();for(let o=1;o<t.length;o+=2)e=Ds(n,i++,t[o])||e;if(G7(i),!e)return Qn;let r=t[0];for(let o=1;o<t.length;o+=2)r+=Kn(t[o])+t[o+1];return r}function X0(n,t,e,i){return Ds(n,U0(),e)?t+Kn(e)+i:Qn}function Q0(n,t,e,i,r,o){let a=Kf(n,Hd(),e,r);return Ud(2),a?t+Kn(e)+i+Kn(r)+o:Qn}function K0(n,t,e,i,r,o,s,a){let c=ST(n,Hd(),e,r,s);return Ud(3),c?t+Kn(e)+i+Kn(r)+o+Kn(s)+a:Qn}function Z0(n,t,e,i,r,o,s,a,l,c){let d=Vl(n,Hd(),e,r,s,l);return Ud(4),d?t+Kn(e)+i+Kn(r)+o+Kn(s)+a+Kn(l)+c:Qn}function J0(n,t,e,i,r,o,s,a,l,c,u,d){let p=Hd(),h=Vl(n,p,e,r,s,l);return h=Ds(n,p+4,u)||h,Ud(5),h?t+Kn(e)+i+Kn(r)+o+Kn(s)+a+Kn(l)+c+Kn(u)+d:Qn}function $0(n,t,e,i,r,o,s,a,l,c,u,d,p,h){let f=Hd(),m=Vl(n,f,e,r,s,l);return m=Kf(n,f+4,u,p)||m,Ud(6),m?t+Kn(e)+i+Kn(r)+o+Kn(s)+a+Kn(l)+c+Kn(u)+d+Kn(p)+h:Qn}function e_(n,t,e,i,r,o,s,a,l,c,u,d,p,h,f,m){let x=Hd(),g=Vl(n,x,e,r,s,l);return g=ST(n,x+4,u,p,f)||g,Ud(7),g?t+Kn(e)+i+Kn(r)+o+Kn(s)+a+Kn(l)+c+Kn(u)+d+Kn(p)+h+Kn(f)+m:Qn}function t_(n,t,e,i,r,o,s,a,l,c,u,d,p,h,f,m,x,g){let b=Hd(),D=Vl(n,b,e,r,s,l);return D=Vl(n,b+4,u,p,f,x)||D,Ud(8),D?t+Kn(e)+i+Kn(r)+o+Kn(s)+a+Kn(l)+c+Kn(u)+d+Kn(p)+h+Kn(f)+m+Kn(x)+g:Qn}function E(n,t,e,i,r,o,s,a){let l=rt(),c=Fi(),u=n+22,d=c.firstCreatePass?function(n,t,e,i,r,o,s,a,l){let c=t.consts,u=W0(t,n,4,s||null,Up(c,a));G3(t,e,u,Up(c,l)),hT(t,u);let d=u.tViews=j3(2,u,i,r,o,t.directiveRegistry,t.pipeRegistry,null,t.schemas,c);return null!==t.queries&&(t.queries.template(t,u),d.queries=t.queries.embeddedTView(u)),u}(u,c,l,t,e,i,r,o,s):c.data[u];Mu(d,!1);let p=l[11].createComment("");yT(c,l,p,d),Su(p,l),CT(l,l[u]=vq(p,l,p,d)),dT(d)&&U3(c,l,d),null!=s&&z3(l,d,a)}function $e(n){return H0(Zn.lFrame.contextLView,22+n)}function y(n,t,e){let i=rt();return Ds(i,U0(),t)&&il(Fi(),no(),i,n,t,i[11],e,!1),y}function HL(n,t,e,i,r){let s=r?"class":"style";q3(n,e,t.inputs[s],s,i)}function _(n,t,e,i){let r=rt(),o=Fi(),s=22+n,a=r[11],l=r[s]=N3(a,t,Zn.lFrame.currentNamespace),c=o.firstCreatePass?function(n,t,e,i,r,o,s){let a=t.consts,c=W0(t,n,2,r,Up(a,o));return G3(t,e,c,Up(a,s)),null!==c.attrs&&$1(c,c.attrs,!1),null!==c.mergedAttrs&&$1(c,c.mergedAttrs,!0),null!==t.queries&&t.queries.elementStart(t,c),c}(s,o,r,0,t,e,i):o.data[s];Mu(c,!0);let u=c.mergedAttrs;null!==u&&z1(a,l,u);let d=c.classes;null!==d&&B3(a,l,d);let p=c.styles;return null!==p&&J9(a,l,p),64!=(64&c.flags)&&yT(o,r,l,c),0===Zn.lFrame.elementDepthCount&&Su(l,r),Zn.lFrame.elementDepthCount++,dT(c)&&(U3(o,r,c),lq(o,c,r)),null!==i&&z3(r,c),_}function v(){let n=zo();m3()?g3():(n=n.parent,Mu(n,!1));let t=n;Zn.lFrame.elementDepthCount--;let e=Fi();return e.firstCreatePass&&(hT(e,n),p3(n)&&e.queries.elementEnd(n)),null!=t.classesWithoutHost&&function(n){return 0!=(16&n.flags)}(t)&&HL(e,t,rt(),t.classesWithoutHost,!0),null!=t.stylesWithoutHost&&function(n){return 0!=(32&n.flags)}(t)&&HL(e,t,rt(),t.stylesWithoutHost,!1),v}function O(n,t,e,i){return _(n,t,e,i),v(),O}function sn(n,t,e){let i=rt(),r=Fi(),o=n+22,s=r.firstCreatePass?function(n,t,e,i,r){let o=t.consts,s=Up(o,i),a=W0(t,n,8,"ng-container",s);return null!==s&&$1(a,s,!0),G3(t,e,a,Up(o,r)),null!==t.queries&&t.queries.elementStart(t,a),a}(o,r,i,t,e):r.data[o];Mu(s,!0);let a=i[o]=i[11].createComment("");return yT(r,i,a,s),Su(a,i),dT(s)&&(U3(r,i,s),lq(r,s,i)),null!=e&&z3(i,s),sn}function an(){let n=zo(),t=Fi();return m3()?g3():(n=n.parent,Mu(n,!1)),t.firstCreatePass&&(hT(t,n),p3(n)&&t.queries.elementEnd(n)),an}function Ni(n,t,e){return sn(n,t,e),an(),Ni}function Pe(){return rt()}function n_(n){return!!n&&"function"==typeof n.then}function X3(n){return!!n&&"function"==typeof n.subscribe}var Q3=X3;function P(n,t,e,i){let r=rt(),o=Fi(),s=zo();return Fq(o,r,r[11],s,n,t,0,i),P}function i_(n,t){let e=zo(),i=rt(),r=Fi();return Fq(r,i,Mq(_3(r.data),e,i),e,n,t),i_}function Fq(n,t,e,i,r,o,s,a){let l=dT(i),u=n.firstCreatePass&&Cq(n),p=xq(t),h=!0;if(3&i.type||a){let x=Ul(i,t),g=a?a(x):x,b=p.length,D=a?k=>a($a(k[i.index])):i.index,T=null;if(!a&&l&&(T=function(n,t,e,i){let r=n.cleanup;if(null!=r)for(let o=0;o<r.length-1;o+=2){let s=r[o];if(s===e&&r[o+1]===i){let a=t[7],l=r[o+2];return a.length>l?a[l]:null}"string"==typeof s&&(o+=2)}return null}(n,t,r,i.index)),null!==T)(T.__ngLastListenerFn__||T).__ngNextListenerFn__=o,T.__ngLastListenerFn__=o,h=!1;else{o=s7(i,t,0,o,!1);let k=e.listen(g,r,o);p.push(o,k),u&&u.push(r,D,b,b+1)}}else o=s7(i,t,0,o,!1);let m,f=i.outputs;if(h&&null!==f&&(m=f[r])){let x=m.length;if(x)for(let g=0;g<x;g+=2){let Z=t[m[g]][m[g+1]].subscribe(o),z=p.length;p.push(o,Z),u&&u.push(r,i.index,z,-(z+1))}}}function o7(n,t,e,i){try{return!1!==e(i)}catch(r){return wq(n,r),!1}}function s7(n,t,e,i,r){return function o(s){if(s===Function)return i;yq(2&n.flags?qp(n.index,t):t);let l=o7(t,0,i,s),c=o.__ngNextListenerFn__;for(;c;)l=o7(t,0,c,s)&&l,c=c.__ngNextListenerFn__;return r&&!1===l&&(s.preventDefault(),s.returnValue=!1),l}}function S(n=1){return function(n){return(Zn.lFrame.contextLView=function(n,t){for(;n>0;)t=t[15],n--;return t}(n,Zn.lFrame.contextLView))[8]}(n)}function vbe(n,t){let e=null,i=function(n){let t=n.attrs;if(null!=t){let e=t.indexOf(5);if(0==(1&e))return t[e+1]}return null}(n);for(let r=0;r<t.length;r++){let o=t[r];if("*"!==o){if(null===i?nq(n,o,!0):xye(i,o))return r}else e=r}return e}function xi(n){let t=rt()[16][6];if(!t.projection){let i=t.projection=fx(n?n.length:1,null),r=i.slice(),o=t.child;for(;null!==o;){let s=n?vbe(o,n):0;null!==s&&(r[s]?r[s].projectionNext=o:i[s]=o,r[s]=o),o=o.next}}}function Vn(n,t=0,e){let i=rt(),r=Fi(),o=W0(r,22+n,16,null,e||null);null===o.projection&&(o.projection=t),g3(),64!=(64&o.flags)&&function(n,t,e){Z9(t[11],0,t,e,z9(n,e,t),W9(e.parent||t[6],e,t))}(r,i,o)}function Zi(n,t,e){return Xx(n,"",t,"",e),Zi}function Xx(n,t,e,i,r){let o=rt(),s=X0(o,t,e,i);return s!==Qn&&il(Fi(),no(),o,n,s,o[11],r,!1),Xx}function ET(n,t,e,i,r,o,s){let a=rt(),l=Q0(a,t,e,i,r,o);return l!==Qn&&il(Fi(),no(),a,n,l,a[11],s,!1),ET}function a7(n,t,e,i,r){let o=n[e+1],s=null===t,a=i?Xf(o):F0(o),l=!1;for(;0!==a&&(!1===l||s);){let u=n[a+1];xbe(n[a],t)&&(l=!0,n[a+1]=i?kL(u):OL(u)),a=i?Xf(u):F0(u)}l&&(n[e+1]=i?OL(o):kL(o))}function xbe(n,t){return null===n||null==t||(Array.isArray(n)?n[1]:n)===t||!(!Array.isArray(n)||"string"!=typeof t)&&Hx(n,t)>=0}var Uo={textEnd:0,key:0,keyEnd:0,value:0,valueEnd:0};function jq(n){return n.substring(Uo.key,Uo.keyEnd)}function Cbe(n){return n.substring(Uo.value,Uo.valueEnd)}function Gq(n,t){let e=Uo.textEnd;return e===t?-1:(t=Uo.keyEnd=function(n,t,e){for(;t<e&&n.charCodeAt(t)>32;)t++;return t}(n,Uo.key=t,e),N0(n,t,e))}function Wq(n,t){let e=Uo.textEnd,i=Uo.key=N0(n,t,e);return e===i?-1:(i=Uo.keyEnd=function(n,t,e){let i;for(;t<e&&(45===(i=n.charCodeAt(t))||95===i||(-33&i)>=65&&(-33&i)<=90||i>=48&&i<=57);)t++;return t}(n,i,e),i=l7(n,i,e),i=Uo.value=N0(n,i,e),i=Uo.valueEnd=function(n,t,e){let i=-1,r=-1,o=-1,s=t,a=s;for(;s<e;){let l=n.charCodeAt(s++);if(59===l)return a;34===l||39===l?a=s=c7(n,l,s,e):t===s-4&&85===o&&82===r&&76===i&&40===l?a=s=c7(n,41,s,e):l>32&&(a=s),o=r,r=i,i=-33&l}return a}(n,i,e),l7(n,i,e))}function qq(n){Uo.key=0,Uo.keyEnd=0,Uo.value=0,Uo.valueEnd=0,Uo.textEnd=n.length}function N0(n,t,e){for(;t<e&&n.charCodeAt(t)<=32;)t++;return t}function l7(n,t,e,i){return(t=N0(n,t,e))<e&&t++,t}function c7(n,t,e,i){let r=-1,o=e;for(;o<i;){let s=n.charCodeAt(o++);if(s==t&&92!==r)return o;r=92==s&&92===r?0:s}throw new Error}function Pt(n,t,e){return Rc(n,t,e,!1),Pt}function et(n,t){return Rc(n,t,null,!0),et}function jl(n){Oc(Qq,Dbe,n,!1)}function Dbe(n,t){for(let e=function(n){return qq(n),Wq(n,N0(n,0,Uo.textEnd))}(t);e>=0;e=Wq(t,e))Qq(n,jq(t),Cbe(t))}function Da(n){Oc(el,Au,n,!0)}function Au(n,t){for(let e=function(n){return qq(n),Gq(n,N0(n,0,Uo.textEnd))}(t);e>=0;e=Gq(t,e))el(n,jq(t),!0)}function Rc(n,t,e,i){let r=rt(),o=Fi(),s=Ud(2);o.firstUpdatePass&&Xq(o,n,s,i),t!==Qn&&Ds(r,s,t)&&Kq(o,o.data[Zs()],r,r[11],n,r[s+1]=function(n,t){return null==n||("string"==typeof t?n+=t:"object"==typeof n&&(n=To(Ta(n)))),n}(t,e),i,s)}function Oc(n,t,e,i){let r=Fi(),o=Ud(2);r.firstUpdatePass&&Xq(r,null,o,i);let s=rt();if(e!==Qn&&Ds(s,o,e)){let a=r.data[Zs()];if(Zq(a,i)&&!Yq(r,o)){let l=i?a.classesWithoutHost:a.stylesWithoutHost;null!==l&&(e=tL(l,e||"")),HL(r,a,s,e,i)}else!function(n,t,e,i,r,o,s,a){r===Qn&&(r=Qi);let l=0,c=0,u=0<r.length?r[0]:null,d=0<o.length?o[0]:null;for(;null!==u||null!==d;){let m,p=l<r.length?r[l+1]:void 0,h=c<o.length?o[c+1]:void 0,f=null;u===d?(l+=2,c+=2,p!==h&&(f=d,m=h)):null===d||null!==u&&u<d?(l+=2,f=u):(c+=2,f=d,m=h),null!==f&&Kq(n,t,e,i,f,m,s,a),u=l<r.length?r[l]:null,d=c<o.length?o[c]:null}}(r,a,s,s[11],s[o+1],s[o+1]=function(n,t,e){if(null==e||""===e)return Qi;let i=[],r=Ta(e);if(Array.isArray(r))for(let o=0;o<r.length;o++)n(i,r[o],!0);else if("object"==typeof r)for(let o in r)r.hasOwnProperty(o)&&n(i,o,r[o]);else"string"==typeof r&&t(i,r);return i}(n,t,e),i,o)}}function Yq(n,t){return t>=n.expandoStartIndex}function Xq(n,t,e,i){let r=n.data;if(null===r[e+1]){let o=r[Zs()],s=Yq(n,e);Zq(o,i)&&null===t&&!s&&(t=!1),t=function(n,t,e,i){let r=_3(n),o=i?t.residualClasses:t.residualStyles;if(null===r)0===(i?t.classBindings:t.styleBindings)&&(e=Ix(e=WN(null,n,t,e,i),t.attrs,i),o=null);else{let s=t.directiveStylingLast;if(-1===s||n[s]!==r)if(e=WN(r,n,t,e,i),null===o){let l=function(n,t,e){let i=e?t.classBindings:t.styleBindings;if(0!==F0(i))return n[Xf(i)]}(n,t,i);void 0!==l&&Array.isArray(l)&&(l=WN(null,n,t,l[1],i),l=Ix(l,t.attrs,i),function(n,t,e,i){n[Xf(e?t.classBindings:t.styleBindings)]=i}(n,t,i,l))}else o=function(n,t,e){let i,r=t.directiveEnd;for(let o=1+t.directiveStylingLast;o<r;o++)i=Ix(i,n[o].hostAttrs,e);return Ix(i,t.attrs,e)}(n,t,i)}return void 0!==o&&(i?t.residualClasses=o:t.residualStyles=o),e}(r,o,t,i),function(n,t,e,i,r,o){let s=o?t.classBindings:t.styleBindings,a=Xf(s),l=F0(s);n[i]=e;let u,c=!1;if(Array.isArray(e)){let d=e;u=d[1],(null===u||Hx(d,u)>0)&&(c=!0)}else u=e;if(r)if(0!==l){let p=Xf(n[a+1]);n[i+1]=E1(p,a),0!==p&&(n[p+1]=jN(n[p+1],i)),n[a+1]=function(n,t){return 131071&n|t<<17}(n[a+1],i)}else n[i+1]=E1(a,0),0!==a&&(n[a+1]=jN(n[a+1],i)),a=i;else n[i+1]=E1(l,0),0===a?a=i:n[l+1]=jN(n[l+1],i),l=i;c&&(n[i+1]=OL(n[i+1])),a7(n,u,i,!0),a7(n,u,i,!1),function(n,t,e,i,r){let o=r?n.residualClasses:n.residualStyles;null!=o&&"string"==typeof t&&Hx(o,t)>=0&&(e[i+1]=kL(e[i+1]))}(t,u,n,i,o),s=E1(a,l),o?t.classBindings=s:t.styleBindings=s}(r,o,t,e,s,i)}}function WN(n,t,e,i,r){let o=null,s=e.directiveEnd,a=e.directiveStylingLast;for(-1===a?a=e.directiveStart:a++;a<s&&(o=t[a],i=Ix(i,o.hostAttrs,r),o!==n);)a++;return null!==n&&(e.directiveStylingLast=a),i}function Ix(n,t,e){let i=e?1:2,r=-1;if(null!==t)for(let o=0;o<t.length;o++){let s=t[o];"number"==typeof s?r=s:r===i&&(Array.isArray(n)||(n=void 0===n?[]:["",n]),el(n,s,!!e||t[++o]))}return void 0===n?null:n}function Qq(n,t,e){el(n,t,Ta(e))}function Kq(n,t,e,i,r,o,s,a){if(!(3&t.type))return;let l=n.data,c=l[a+1],u=function(n){return 1==(1&n)}(c)?u7(l,t,e,r,F0(c),s):void 0;tT(u)||(tT(o)||function(n){return 2==(2&n)}(c)&&(o=u7(l,null,e,r,a,s)),function(n,t,e,i,r){if(t)r?n.addClass(e,i):n.removeClass(e,i);else{let o=-1===i.indexOf("-")?void 0:Bl.DashCase;null==r?n.removeStyle(e,i,o):("string"==typeof r&&r.endsWith("!important")&&(r=r.slice(0,-10),o|=Bl.Important),n.setStyle(e,i,r,o))}}(i,s,pT(Zs(),e),r,o))}function u7(n,t,e,i,r,o){let a,s=null===t;for(;r>0;){let l=n[r],c=Array.isArray(l),u=c?l[1]:l,d=null===u,p=e[r+1];p===Qn&&(p=d?Qi:void 0);let h=d?LN(p,i):u===i?p:void 0;if(c&&!tT(h)&&(h=LN(l,i)),tT(h)&&(a=h,s))return a;let f=n[r+1];r=s?Xf(f):F0(f)}if(null!==t){let l=o?t.residualClasses:t.residualStyles;null!=l&&(a=LN(l,i))}return a}function tT(n){return void 0!==n}function Zq(n,t){return 0!=(n.flags&(t?16:32))}function A(n,t=""){let e=rt(),i=Fi(),r=n+22,o=i.firstCreatePass?W0(i,r,1,t,null):i.data[r],s=e[r]=F3(e[11],t);yT(i,e,s,o),Mu(o,!1)}function yt(n){return je("",n,""),yt}function je(n,t,e){let i=rt(),r=X0(i,n,t,e);return r!==Qn&&jd(i,Zs(),r),je}function Xp(n,t,e,i,r){let o=rt(),s=Q0(o,n,t,e,i,r);return s!==Qn&&jd(o,Zs(),s),Xp}function TT(n,t,e,i,r,o,s){let a=rt(),l=K0(a,n,t,e,i,r,o,s);return l!==Qn&&jd(a,Zs(),l),TT}function Qx(n,t,e){Oc(el,Au,X0(rt(),n,t,e),!0)}function _s(n,t,e){let i=rt();return Ds(i,U0(),t)&&il(Fi(),no(),i,n,t,i[11],e,!0),_s}function r_(n,t,e){let i=rt();if(Ds(i,U0(),t)){let o=Fi(),s=no();il(o,s,i,n,t,Mq(_3(o.data),s,i),e,!0)}return r_}var Vf=void 0,exe=["en",[["a","p"],["AM","PM"],Vf],[["AM","PM"],Vf,Vf],[["S","M","T","W","T","F","S"],["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],["Su","Mo","Tu","We","Th","Fr","Sa"]],Vf,[["J","F","M","A","M","J","J","A","S","O","N","D"],["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],["January","February","March","April","May","June","July","August","September","October","November","December"]],Vf,[["B","A"],["BC","AD"],["Before Christ","Anno Domini"]],0,[6,0],["M/d/yy","MMM d, y","MMMM d, y","EEEE, MMMM d, y"],["h:mm a","h:mm:ss a","h:mm:ss a z","h:mm:ss a zzzz"],["{1}, {0}",Vf,"{1} 'at' {0}",Vf],[".",",",";","%","+","-","E","\xd7","\u2030","\u221e","NaN",":"],["#,##0.###","#,##0%","\xa4#,##0.00","#E0"],"USD","$","US Dollar",{},"ltr",function(n){let e=Math.floor(Math.abs(n)),i=n.toString().replace(/^[^.]*\.?/,"").length;return 1===e&&0===i?1:5}],qN={};function Aa(n){let t=function(n){return n.toLowerCase().replace(/_/g,"-")}(n),e=d7(t);if(e)return e;let i=t.split("-")[0];if(e=d7(i),e)return e;if("en"===i)return exe;throw new At(701,!1)}function d7(n){return n in qN||(qN[n]=to.ng&&to.ng.common&&to.ng.common.locales&&to.ng.common.locales[n]),qN[n]}var Rr=(()=>{return(n=Rr||(Rr={}))[n.LocaleId=0]="LocaleId",n[n.DayPeriodsFormat=1]="DayPeriodsFormat",n[n.DayPeriodsStandalone=2]="DayPeriodsStandalone",n[n.DaysFormat=3]="DaysFormat",n[n.DaysStandalone=4]="DaysStandalone",n[n.MonthsFormat=5]="MonthsFormat",n[n.MonthsStandalone=6]="MonthsStandalone",n[n.Eras=7]="Eras",n[n.FirstDayOfWeek=8]="FirstDayOfWeek",n[n.WeekendRange=9]="WeekendRange",n[n.DateFormat=10]="DateFormat",n[n.TimeFormat=11]="TimeFormat",n[n.DateTimeFormat=12]="DateTimeFormat",n[n.NumberSymbols=13]="NumberSymbols",n[n.NumberFormats=14]="NumberFormats",n[n.CurrencyCode=15]="CurrencyCode",n[n.CurrencySymbol=16]="CurrencySymbol",n[n.CurrencyName=17]="CurrencyName",n[n.Currencies=18]="Currencies",n[n.Directionality=19]="Directionality",n[n.PluralCase=20]="PluralCase",n[n.ExtraData=21]="ExtraData",Rr;var n})(),nxe=["zero","one","two","few","many"];var nT="en-US",fY={marker:"element"},mY={marker:"ICU"},Ec=(()=>{return(n=Ec||(Ec={}))[n.SHIFT=2]="SHIFT",n[n.APPEND_EAGERLY=1]="APPEND_EAGERLY",n[n.COMMENT=2]="COMMENT",Ec;var n})(),gY=nT;function _Y(n,t,e){let i=t.insertBeforeIndex,r=Array.isArray(i)?i[0]:i;return null===r?q9(n,0,e):$a(e[r])}function vY(n,t,e,i,r){let o=t.insertBeforeIndex;if(Array.isArray(o)){let s=i,a=null;if(3&t.type||(a=s,s=r),null!==s&&0==(2&t.flags))for(let l=1;l<o.length;l++)Yf(n,s,e[o[l]],a,!1)}}function yY(n,t){if(n.push(t),n.length>1)for(let e=n.length-2;e>=0;e--){let i=n[e];bY(i)||axe(i,t)&&null===lxe(i)&&cxe(i,t.index)}}function bY(n){return!(64&n.type)}function axe(n,t){return bY(t)||n.index>t.index}function lxe(n){let t=n.insertBeforeIndex;return Array.isArray(t)?t[0]:t}function cxe(n,t){let e=n.insertBeforeIndex;Array.isArray(e)?e[0]=t:(X9(_Y,vY),n.insertBeforeIndex=t)}function _x(n,t){let e=n.data[t];return null===e||"string"==typeof e?null:e.hasOwnProperty("currentCaseLViewIndex")?e:e.value}function pxe(n,t,e){let i=V3(n,e,64,null,null);return yY(t,i),i}function DT(n,t){let e=t[n.currentCaseLViewIndex];return null===e?e:e<0?~e:e}function hxe(n){return n>>>17}function fxe(n){return(131070&n)>>>1}var Px=0,vx=0;function xY(n,t,e,i){let s,r=e[11],o=null;for(let a=0;a<t.length;a++){let l=t[a];if("string"==typeof l){let c=t[++a];null===e[c]&&(e[c]=F3(r,l))}else if("number"==typeof l)switch(1&l){case 0:let u,d,c=hxe(l);if(null===o&&(o=c,s=vT(r,i)),c===o?(u=i,d=s):(u=null,d=$a(e[c])),null!==d){let m=fxe(l);Yf(r,d,e[m],u,!1);let g=_x(n,m);if(null!==g&&"object"==typeof g){let b=DT(g,e);null!==b&&xY(n,g.create[b],e,e[g.anchorIdx])}}break;case 1:let h=t[++a],f=t[++a];W3(r,pT(l>>>1,e),null,null,h,f,null)}else switch(l){case mY:let c=t[++a],u=t[++a];null===e[u]&&Su(e[u]=eye(r,c),e);break;case fY:let d=t[++a],p=t[++a];null===e[p]&&Su(e[p]=N3(r,d,null),e)}}}function CY(n,t,e,i,r){for(let o=0;o<e.length;o++){let s=e[o],a=e[++o];if(s&r){let l="";for(let c=o+1;c<=o+a;c++){let u=e[c];if("string"==typeof u)l+=u;else if("number"==typeof u)if(u<0)l+=Kn(t[i-u]);else{let d=u>>>2;switch(3&u){case 1:let p=e[++c],h=e[++c],f=n.data[d];"string"==typeof f?W3(t[11],t[d],null,f,p,l,h):il(n,f,t,p,l,t[11],h,!1);break;case 0:let m=t[d];null!==m&&V9(t[11],m,l);break;case 2:yxe(n,_x(n,d),t,l);break;case 3:p7(n,_x(n,d),i,t)}}}}else{let l=e[o+1];if(l>0&&3==(3&l)){let u=_x(n,l>>>2);t[u.currentCaseLViewIndex]<0&&p7(n,u,i,t)}}o+=a}}function p7(n,t,e,i){let r=i[t.currentCaseLViewIndex];if(null!==r){let o=Px;r<0&&(r=i[t.currentCaseLViewIndex]=~r,o=-1),CY(n,i,t.update[r],e,o)}}function yxe(n,t,e,i){let r=function(n,t){let e=n.cases.indexOf(t);if(-1===e)switch(n.type){case 1:{let i=function(n,t){let e=function(n){return Aa(n)[Rr.PluralCase]}(t)(parseInt(n,10)),i=nxe[e];return void 0!==i?i:"other"}(t,gY);e=n.cases.indexOf(i),-1===e&&"other"!==i&&(e=n.cases.indexOf("other"));break}case 0:e=n.cases.indexOf("other")}return-1===e?null:e}(t,i);if(DT(t,e)!==r&&(MY(n,t,e),e[t.currentCaseLViewIndex]=null===r?null:~r,null!==r)){let s=e[t.anchorIdx];s&&xY(n,t.create[r],e,s)}}function MY(n,t,e){let i=DT(t,e);if(null!==i){let r=t.remove[i];for(let o=0;o<r.length;o++){let s=r[o];if(s>0){let a=pT(s,e);null!==a&&K9(e[11],a)}else MY(n,_x(n,~s),e)}}}function xxe(){let e,i,n=[],t=-1;function o(a,l){t=0;let c=DT(a,l);i=null!==c?a.remove[c]:Qi}function s(){if(t<i.length){let a=i[t++];return a>0?e[a]:(n.push(t,i),o(e[1].data[~a],e),s())}return 0===n.length?null:(i=n.pop(),t=n.pop(),s())}return function(a,l){for(e=l;n.length;)n.pop();return o(a.value,l),s}}var iT=/\ufffd(\d+):?\d*\ufffd/gi,Cxe=/({\s*\ufffd\d+:?\d*\ufffd\s*,\s*\S{6}\s*,[\s\S]*})/gi,Mxe=/\ufffd(\d+)\ufffd/,wY=/^\s*(\ufffd\d+:?\d*\ufffd)\s*,\s*(select|plural)\s*,/,wxe=/\ufffd\/?\*(\d+:\d+)\ufffd/gi,Sxe=/\ufffd(\/?[#*]\d+):?\d*\ufffd/gi,Exe=/\uE500/g;function SY(n,t,e,i,r,o,s){let a=q0(n,i,1,null),l=a<<Ec.SHIFT,c=wx();t===c&&(c=null),null===c&&(l|=Ec.APPEND_EAGERLY),s&&(l|=Ec.COMMENT,function(n){void 0===DL&&(DL=n())}(xxe)),r.push(l,null===o?"":o);let u=V3(n,a,s?32:1,null===o?"":o,null);yY(e,u);let d=u.index;return Mu(u,!1),null!==c&&t!==c&&function(n,t){let e=n.insertBeforeIndex;null===e?(X9(_Y,vY),e=n.insertBeforeIndex=[null,t]):(function(n,t,e){1!=n&&T7("Expecting array here",n,!0,"==")}(Array.isArray(e)),e.push(t))}(c,d),u}function Axe(n,t,e,i,r,o,s){let a=s.match(iT),l=SY(n,t,e,o,i,a?null:s,!1);a&&bx(r,s,l.index,null,0,null)}function bx(n,t,e,i,r,o){let s=n.length,a=s+1;n.push(null,null);let l=s+2,c=t.split(iT),u=0;for(let d=0;d<c.length;d++){let p=c[d];if(1&d){let h=r+parseInt(p,10);n.push(-1-h),u|=EY(h)}else""!==p&&n.push(p)}return n.push(e<<2|(i?1:0)),i&&n.push(i,o),n[s]=u,n[a]=n.length-l,u}function Pxe(n){let t=0;for(let e=0;e<n.length;e++){let i=n[e];"number"==typeof i&&i<0&&t++}return t}function EY(n){return 1<<Math.min(n,31)}function h7(n){let t,o,e="",i=0,r=!1;for(;null!==(t=wxe.exec(n));)r?t[0]===`\ufffd/*${o}\ufffd`&&(i=t.index,r=!1):(e+=n.substring(i,t.index+t[0].length),o=t[1],r=!0);return e+=n.slice(i),e}function TY(n,t,e,i,r,o){let s=0,a={type:r.type,currentCaseLViewIndex:q0(n,t,1,null),anchorIdx:o,cases:[],create:[],remove:[],update:[]};(function(n,t,e){n.push(EY(t.mainBinding),2,-1-t.mainBinding,e<<2|2)})(e,r,o),function(n,t,e){let i=n.data[t];null===i?n.data[t]=e:i.value=e}(n,o,a);let l=r.values;for(let c=0;c<l.length;c++){let u=l[c],d=[];for(let p=0;p<u.length;p++){let h=u[p];if("string"!=typeof h){let f=d.push(h)-1;u[p]=`\x3c!--\ufffd${f}\ufffd--\x3e`}}s=Fxe(n,a,t,e,i,r.cases[c],u.join(""),d)|s}s&&function(n,t,e){n.push(t,1,e<<2|3)}(e,s,o)}function kxe(n){let t=[],e=[],i=1,r=0,o=UL(n=n.replace(wY,function(s,a,l){return i="select"===l?0:1,r=parseInt(a.slice(1),10),""}));for(let s=0;s<o.length;){let a=o[s++].trim();1===i&&(a=a.replace(/\s*(?:=)?(\w+)\s*/,"$1")),a.length&&t.push(a);let l=UL(o[s++]);t.length>e.length&&e.push(l)}return{type:i,mainBinding:r,cases:t,values:e}}function UL(n){if(!n)return[];let o,t=0,e=[],i=[],r=/[{}]/g;for(r.lastIndex=0;o=r.exec(n);){let a=o.index;if("}"==o[0]){if(e.pop(),0==e.length){let l=n.substring(t,a);wY.test(l)?i.push(kxe(l)):i.push(l),t=a+1}}else{if(0==e.length){let l=n.substring(t,a);i.push(l),t=a+1}e.push("{")}}let s=n.substring(t);return i.push(s),i}function Fxe(n,t,e,i,r,o,s,a){let l=[],c=[],u=[];t.cases.push(o),t.create.push(l),t.remove.push(c),t.update.push(u);let p=w9(_9()).getInertBodyElement(s),h=CL(p)||p;return h?DY(n,t,e,i,l,c,u,h,r,a,0):0}function DY(n,t,e,i,r,o,s,a,l,c,u){let d=0,p=a.firstChild;for(;p;){let h=q0(n,e,1,null);switch(p.nodeType){case Node.ELEMENT_NODE:let f=p,m=f.tagName.toLowerCase();if(bL.hasOwnProperty(m)){YN(r,fY,m,l,h),n.data[h]=m;let D=f.attributes;for(let T=0;T<D.length;T++){let k=D.item(T),Z=k.name.toLowerCase();k.value.match(iT)?D9.hasOwnProperty(Z)&&bx(s,k.value,h,k.name,0,T3[Z]?zx:null):Vxe(r,h,k)}d=DY(n,t,e,i,r,o,s,p,h,c,u+1)|d,f7(o,h,u)}break;case Node.TEXT_NODE:let x=p.textContent||"",g=x.match(iT);YN(r,null,g?"":x,l,h),f7(o,h,u),g&&(d=bx(s,x,h,null,0,null)|d);break;case Node.COMMENT_NODE:let b=Mxe.exec(p.textContent||"");if(b){let T=c[parseInt(b[1],10)];YN(r,mY,"",l,h),TY(n,e,i,l,T,h),Nxe(o,h,u)}}p=p.nextSibling}return d}function f7(n,t,e){0===e&&n.push(t)}function Nxe(n,t,e){0===e&&(n.push(~t),n.push(t))}function YN(n,t,e,i,r){null!==t&&n.push(t),n.push(e,r,function(n,t,e){return 0|t<<17|e<<1}(0,i,r))}function Vxe(n,t,e){n.push(t<<1|1,e.name,e.value)}var Hxe=/\[(\ufffd.+?\ufffd?)\]/,Uxe=/\[(\ufffd.+?\ufffd?)\]|(\ufffd\/?\*\d+:\d+\ufffd)/g,zxe=/({\s*)(VAR_(PLURAL|SELECT)(_\d+)?)(\s*,)/g,jxe=/{([A-Z0-9_]+)}/g,Gxe=/\ufffdI18N_EXP_(ICU(_\d+)?)\ufffd/g,Wxe=/\/\*/,qxe=/\d+\:(\d+)/;function AY(n,t,e=-1){let i=Fi(),r=rt(),o=22+n,s=Up(i.consts,t),a=wx();i.firstCreatePass&&function(n,t,e,i,r,o){let s=wx(),a=[],l=[],c=[[]];r=function(n,t){if(function(n){return-1===n}(t))return h7(n);{let e=n.indexOf(`:${t}\ufffd`)+2+t.toString().length,i=n.search(new RegExp(`\ufffd\\/\\*\\d+:${t}\ufffd`));return h7(n.substring(e,i))}}(r,o);let u=function(n){return n.replace(Exe," ")}(r).split(Sxe);for(let d=0;d<u.length;d++){let p=u[d];if(0==(1&d)){let h=UL(p);for(let f=0;f<h.length;f++){let m=h[f];if(0==(1&f)){let x=m;""!==x&&Axe(n,s,c[0],a,l,e,x)}else{let x=m;if("object"!=typeof x)throw new Error(`Unable to parse ICU expression in "${r}" message.`);TY(n,e,l,t,x,SY(n,s,c[0],e,a,"",!0).index)}}}else{let h=47===p.charCodeAt(0),m=(p.charCodeAt(h?1:0),22+Number.parseInt(p.substring(h?2:1)));if(h)c.shift(),Mu(wx(),!1);else{let x=pxe(n,c[0],m);c.unshift([]),Mu(x,!0)}}}n.data[i]={create:a,update:l}}(i,null===a?0:a.index,r,o,s,e);let l=i.data[o],u=j9(i,a===r[6]?null:a,r);(function(n,t,e,i){let r=n[11];for(let o=0;o<t.length;o++){let s=t[o++],a=t[o],l=(s&Ec.COMMENT)===Ec.COMMENT,c=(s&Ec.APPEND_EAGERLY)===Ec.APPEND_EAGERLY,u=s>>>Ec.SHIFT,d=n[u];null===d&&(d=n[u]=l?r.createComment(a):F3(r,a)),c&&null!==e&&Yf(r,e,d,i,!1)}})(r,l.create,u,a&&8&a.type?r[a.index]:null),W7(!0)}function IY(){W7(!1)}function AT(n,t,e){AY(n,t,e),IY()}function Kx(n){return function(n){n&&(Px|=1<<Math.min(vx,31)),vx++}(Ds(rt(),U0(),n)),Kx}function IT(n){!function(n,t,e){if(vx>0){let i=n.data[e];CY(n,t,Array.isArray(i)?i:i.update,Hd()-vx-1,Px)}Px=0,vx=0}(Fi(),rt(),n+22)}function PT(n,t={}){return function(n,t={}){let e=n;if(Hxe.test(n)){let i={},r=[0];e=e.replace(Uxe,(o,s,a)=>{let l=s||a,c=i[l]||[];if(c.length||(l.split("|").forEach(m=>{let x=m.match(qxe),g=x?parseInt(x[1],10):0,b=Wxe.test(m);c.push([g,b,m])}),i[l]=c),!c.length)throw new Error(`i18n postprocess: unmatched placeholder - ${l}`);let u=r[r.length-1],d=0;for(let m=0;m<c.length;m++)if(c[m][0]===u){d=m;break}let[p,h,f]=c[d];return h?r.pop():u!==p&&r.push(p),c.splice(d,1),f})}return Object.keys(t).length&&(e=e.replace(zxe,(i,r,o,s,a,l)=>t.hasOwnProperty(o)?`${r}${t[o]}${l}`:i),e=e.replace(jxe,(i,r)=>t.hasOwnProperty(r)?t[r]:i),e=e.replace(Gxe,(i,r)=>{if(t.hasOwnProperty(r)){let o=t[r];if(!o.length)throw new Error(`i18n postprocess: unmatched ICU - ${i} with key: ${r}`);return o.shift()}return i})),e}(n,t)}function zL(n,t,e,i,r){if(n=Ki(n),Array.isArray(n))for(let o=0;o<n.length;o++)zL(n[o],t,e,i,r);else{let o=Fi(),s=rt(),a=k0(n)?n:Ki(n.provide),l=F9(n),c=zo(),u=1048575&c.providerIndexes,d=c.directiveStart,p=c.providerIndexes>>20;if(k0(n)||!n.multi){let h=new qf(l,r,M),f=QN(a,t,r?u:u+p,d);-1===f?(Y1(Sx(c,s),o,a),XN(o,n,t.length),t.push(a),c.directiveStart++,c.directiveEnd++,r&&(c.providerIndexes+=1048576),e.push(h),s.push(h)):(e[f]=h,s[f]=h)}else{let h=QN(a,t,u+p,d),f=QN(a,t,u,u+p),m=h>=0&&e[h],x=f>=0&&e[f];if(r&&!x||!r&&!m){Y1(Sx(c,s),o,a);let g=function(n,t,e,i,r){let o=new qf(n,e,M);return o.multi=[],o.index=t,o.componentProviders=0,PY(o,r,i&&!e),o}(r?Zxe:Kxe,e.length,r,i,l);!r&&x&&(e[f].providerFactory=g),XN(o,n,t.length,0),t.push(a),c.directiveStart++,c.directiveEnd++,r&&(c.providerIndexes+=1048576),e.push(g),s.push(g)}else XN(o,n,h>-1?h:f,PY(e[r?f:h],l,!r&&i));!r&&i&&x&&e[f].componentProviders++}}}function XN(n,t,e,i){let r=k0(t),o=function(n){return!!n.useClass}(t);if(r||o){let l=(o?Ki(t.useClass):t).prototype.ngOnDestroy;if(l){let c=n.destroyHooks||(n.destroyHooks=[]);if(!r&&t.multi){let u=c.indexOf(e);-1===u?c.push(e,[i,l]):c[u+1].push(i,l)}else c.push(e,l)}}}function PY(n,t,e){return e&&n.componentProviders++,n.multi.push(t)-1}function QN(n,t,e,i){for(let r=e;r<i;r++)if(t[r]===n)return r;return-1}function Kxe(n,t,e,i){return jL(this.multi,[])}function Zxe(n,t,e,i){let o,r=this.multi;if(this.providerFactory){let s=this.providerFactory.componentProviders,a=Bx(e,e[1],this.providerFactory.index,i);o=a.slice(0,s),jL(r,o);for(let l=s;l<a.length;l++)o.push(a[l])}else o=[],jL(r,o);return o}function jL(n,t){for(let e=0;e<n.length;e++)t.push((0,n[e])());return t}function $t(n,t=[]){return e=>{e.providersResolver=(i,r)=>function(n,t,e){let i=Fi();if(i.firstCreatePass){let r=Ac(n);zL(e,i.data,i.blueprint,r,!0),zL(t,i.data,i.blueprint,r,!1)}}(i,r?r(n):n,t)}}var Gp=class{},GL=class{},WL=class extends Gp{constructor(t,e){super(),this._parent=e,this._bootstrapComponents=[],this.destroyCbs=[],this.componentFactoryResolver=new Ax(this);let i=I0(t);this._bootstrapComponents=R1(i.bootstrap),this._r3Injector=oq(t,e,[{provide:Gp,useValue:this},{provide:gs,useValue:this.componentFactoryResolver}],To(t),new Set(["environment"])),this._r3Injector.resolveInjectorInitializers(),this.instance=this._r3Injector.get(t)}get injector(){return this._r3Injector}destroy(){let t=this._r3Injector;!t.destroyed&&t.destroy(),this.destroyCbs.forEach(e=>e()),this.destroyCbs=null}onDestroy(t){this.destroyCbs.push(t)}},qL=class extends GL{constructor(t){super(),this.moduleType=t}create(t){return new WL(this.moduleType,t)}},YL=class extends Gp{constructor(t,e,i){super(),this.componentFactoryResolver=new Ax(this),this.instance=null;let r=new Z1([...t,{provide:Gp,useValue:this},{provide:gs,useValue:this.componentFactoryResolver}],e||I3(),i,new Set(["environment"]));this.injector=r,r.resolveInjectorInitializers()}destroy(){this.injector.destroy()}onDestroy(t){this.injector.onDestroy(t)}},eCe=(()=>{class n{constructor(e){this._injector=e,this.cachedInjectors=new Map}getOrCreateStandaloneInjector(e){if(!e.standalone)return null;if(!this.cachedInjectors.has(e.id)){let i=R9(0,e.type),r=i.length>0?function(n,t,e=null){return new YL(n,t,e).injector}([i],this._injector,`Standalone[${e.type.name}]`):null;this.cachedInjectors.set(e.id,r)}return this.cachedInjectors.get(e.id)}ngOnDestroy(){try{for(let e of this.cachedInjectors.values())null!==e&&e.destroy()}finally{this.cachedInjectors.clear()}}}return n.\u0275prov=ye({token:n,providedIn:"environment",factory:()=>new n(j(jp))}),n})();function Qp(n,t,e){let i=Ks()+n,r=rt();return r[i]===Qn?Du(r,i,e?t.call(e):t()):Yx(r,i)}function On(n,t,e,i){return RY(rt(),Ks(),n,t,e,i)}function Qr(n,t,e,i,r){return OY(rt(),Ks(),n,t,e,i,r)}function Zx(n,t,e,i,r,o){return kY(rt(),Ks(),n,t,e,i,r,o)}function K3(n,t,e,i,r,o,s){return FY(rt(),Ks(),n,t,e,i,r,o,s)}function Z3(n,t,e,i,r,o,s,a){let l=Ks()+n,c=rt(),u=Vl(c,l,e,i,r,o);return Ds(c,l+4,s)||u?Du(c,l+5,a?t.call(a,e,i,r,o,s):t(e,i,r,o,s)):Yx(c,l+5)}function Jx(n,t){let e=n[t];return e===Qn?void 0:e}function RY(n,t,e,i,r,o){let s=t+e;return Ds(n,s,r)?Du(n,s+1,o?i.call(o,r):i(r)):Jx(n,s+1)}function OY(n,t,e,i,r,o,s){let a=t+e;return Kf(n,a,r,o)?Du(n,a+2,s?i.call(s,r,o):i(r,o)):Jx(n,a+2)}function kY(n,t,e,i,r,o,s,a){let l=t+e;return ST(n,l,r,o,s)?Du(n,l+3,a?i.call(a,r,o,s):i(r,o,s)):Jx(n,l+3)}function FY(n,t,e,i,r,o,s,a,l){let c=t+e;return Vl(n,c,r,o,s,a)?Du(n,c+4,l?i.call(l,r,o,s,a):i(r,o,s,a)):Jx(n,c+4)}function NY(n,t,e,i,r,o){let s=t+e,a=!1;for(let l=0;l<r.length;l++)Ds(n,s++,r[l])&&(a=!0);return a?Du(n,s,i.apply(o,r)):Jx(n,s)}function B(n,t){let i,e=Fi(),r=n+22;e.firstCreatePass?(i=function(n,t){if(t)for(let e=t.length-1;e>=0;e--){let i=t[e];if(n===i.name)return i}}(t,e.pipeRegistry),e.data[r]=i,i.onDestroy&&(e.destroyHooks||(e.destroyHooks=[])).push(r,i.onDestroy)):i=e.data[r];let o=i.factory||(i.factory=Wf(i.type)),s=kl(M);try{let a=q1(!1),l=o();return q1(a),function(n,t,e,i){e>=n.data.length&&(n.data[e]=null,n.blueprint[e]=null),t[e]=i}(e,rt(),r,l),l}finally{kl(s)}}function U(n,t,e){let i=n+22,r=rt(),o=H0(r,i);return $x(r,i)?RY(r,Ks(),t,o.transform,e,o):o.transform(e)}function Jf(n,t,e,i){let r=n+22,o=rt(),s=H0(o,r);return $x(o,r)?OY(o,Ks(),t,s.transform,e,i,s):s.transform(e,i)}function J3(n,t,e,i,r){let o=n+22,s=rt(),a=H0(s,o);return $x(s,o)?kY(s,Ks(),t,a.transform,e,i,r,a):a.transform(e,i,r)}function $x(n,t){return n[1].data[t].pure}function KN(n){return t=>{setTimeout(n,void 0,t)}}var G=class extends ke{constructor(t=!1){super(),this.__isAsync=t}emit(t){super.next(t)}subscribe(t,e,i){let r=t,o=e||(()=>null),s=i;if(t&&"object"==typeof t){let l=t;r=l.next?.bind(l),o=l.error?.bind(l),s=l.complete?.bind(l)}this.__isAsync&&(o=KN(o),r&&(r=KN(r)),s&&(s=KN(s)));let a=super.subscribe({next:r,error:o,complete:s});return t instanceof Sn&&t.add(a),a}};function cCe(){return this._results[MT()]()}var Hl=class{constructor(t=!1){this._emitDistinctChangesOnly=t,this.dirty=!0,this._results=[],this._changesDetected=!1,this._changes=null,this.length=0,this.first=void 0,this.last=void 0;let e=MT(),i=Hl.prototype;i[e]||(i[e]=cCe)}get changes(){return this._changes||(this._changes=new G)}get(t){return this._results[t]}map(t){return this._results.map(t)}filter(t){return this._results.filter(t)}find(t){return this._results.find(t)}reduce(t,e){return this._results.reduce(t,e)}forEach(t){this._results.forEach(t)}some(t){return this._results.some(t)}toArray(){return this._results.slice()}toString(){return this._results.toString()}reset(t,e){let i=this;i.dirty=!1;let r=Fd(t);(this._changesDetected=!function(n,t,e){if(n.length!==t.length)return!1;for(let i=0;i<n.length;i++){let r=n[i],o=t[i];if(e&&(r=e(r),o=e(o)),o!==r)return!1}return!0}(i._results,r,e))&&(i._results=r,i.length=r.length,i.last=r[this.length-1],i.first=r[0])}notifyOnChanges(){this._changes&&(this._changesDetected||!this._emitDistinctChangesOnly)&&this._changes.emit(this)}setDirty(){this.dirty=!0}destroy(){this.changes.complete(),this.changes.unsubscribe()}},Vi=(()=>{class n{}return n.__NG_ELEMENT_ID__=pCe,n})(),uCe=Vi,dCe=class extends uCe{constructor(t,e,i){super(),this._declarationLView=t,this._declarationTContainer=e,this.elementRef=i}createEmbeddedView(t,e){let i=this._declarationTContainer.tViews,r=bT(this._declarationLView,i,t,16,null,i.declTNode,null,null,null,null,e||null);r[17]=this._declarationLView[this._declarationTContainer.index];let s=this._declarationLView[19];return null!==s&&(r[19]=s.createEmbeddedView(i)),H3(i,r,t),new Qf(r)}};function pCe(){return RT(zo(),rt())}function RT(n,t){return 4&n.type?new dCe(t,n,G0(n,t)):null}var Oi=(()=>{class n{}return n.__NG_ELEMENT_ID__=hCe,n})();function hCe(){return BY(zo(),rt())}var fCe=Oi,LY=class extends fCe{constructor(t,e,i){super(),this._lContainer=t,this._hostTNode=e,this._hostLView=i}get element(){return G0(this._hostTNode,this._hostLView)}get injector(){return new jf(this._hostTNode,this._hostLView)}get parentInjector(){let t=C3(this._hostTNode,this._hostLView);if(e9(t)){let e=W1(t,this._hostLView),i=G1(t);return new jf(e[1].data[i+8],e)}return new jf(null,this._hostLView)}clear(){for(;this.length>0;)this.remove(this.length-1)}get(t){let e=g7(this._lContainer);return null!==e&&e[t]||null}get length(){return this._lContainer.length-10}createEmbeddedView(t,e,i){let r,o;"number"==typeof i?r=i:null!=i&&(r=i.index,o=i.injector);let s=t.createEmbeddedView(e||{},o);return this.insert(s,r),s}createComponent(t,e,i,r,o){let a,s=t&&!ux(t);if(s)a=e;else{let d=e||{};a=d.index,i=d.injector,r=d.projectableNodes,o=d.environmentInjector||d.ngModuleRef}let l=s?t:new eT(Nl(t)),c=i||this.parentInjector;if(!o&&null==l.ngModule){let p=(s?c:this.parentInjector).get(jp,null);p&&(o=p)}let u=l.create(c,r,void 0,o);return this.insert(u.hostView,a),u}insert(t,e){let i=t._lView,r=i[1];if(Vd(i[3])){let u=this.indexOf(t);if(-1!==u)this.detach(u);else{let d=i[3],p=new LY(d,d[6],d[3]);p.detach(p.indexOf(t))}}let o=this._adjustIndex(e),s=this._lContainer;!function(n,t,e,i){let r=10+i,o=e.length;i>0&&(e[r-1][4]=t),i<o-10?(t[4]=e[r],u9(e,10+i,t)):(e.push(t),t[4]=null),t[3]=e;let s=t[17];null!==s&&e!==s&&function(n,t){let e=n[9];t[16]!==t[3][3][16]&&(n[2]=!0),null===e?n[9]=[t]:e.push(t)}(s,t);let a=t[19];null!==a&&a.insertView(n),t[2]|=64}(r,i,s,o);let a=PL(o,s),l=i[11],c=vT(l,s[7]);return null!==c&&function(n,t,e,i,r,o){i[0]=r,i[6]=t,qx(n,i,e,1,r,o)}(r,s[6],l,i,c,a),t.attachToViewContainerRef(),u9(ZN(s),o,t),t}move(t,e){return this.insert(t,e)}indexOf(t){let e=g7(this._lContainer);return null!==e?e.indexOf(t):-1}remove(t){let e=this._adjustIndex(t,-1),i=AL(this._lContainer,e);i&&(X1(ZN(this._lContainer),e),U9(i[1],i))}detach(t){let e=this._adjustIndex(t,-1),i=AL(this._lContainer,e);return i&&null!=X1(ZN(this._lContainer),e)?new Qf(i):null}_adjustIndex(t,e=0){return t??this.length+e}};function g7(n){return n[8]}function ZN(n){return n[8]||(n[8]=[])}function BY(n,t){let e,i=t[n.index];if(Vd(i))e=i;else{let r;if(8&n.type)r=$a(i);else{let o=t[11];r=o.createComment("");let s=Ul(n,t);Yf(o,vT(o,s),r,function(n,t){return n.nextSibling(t)}(o,s),!1)}t[n.index]=e=vq(i,t,r,n),CT(t,e)}return new LY(e,n,t)}var Rx=class{constructor(t){this.queryList=t,this.matches=null}clone(){return new Rx(this.queryList)}setDirty(){this.queryList.setDirty()}},Ox=class{constructor(t=[]){this.queries=t}createEmbeddedView(t){let e=t.queries;if(null!==e){let i=null!==t.contentQueries?t.contentQueries[0]:e.length,r=[];for(let o=0;o<i;o++){let s=e.getByIndex(o);r.push(this.queries[s.indexInDeclarationView].clone())}return new Ox(r)}return null}insertView(t){this.dirtyQueriesWithMatches(t)}detachView(t){this.dirtyQueriesWithMatches(t)}dirtyQueriesWithMatches(t){for(let e=0;e<this.queries.length;e++)null!==zY(t,e).matches&&this.queries[e].setDirty()}},rT=class{constructor(t,e,i=null){this.predicate=t,this.flags=e,this.read=i}},kx=class{constructor(t=[]){this.queries=t}elementStart(t,e){for(let i=0;i<this.queries.length;i++)this.queries[i].elementStart(t,e)}elementEnd(t){for(let e=0;e<this.queries.length;e++)this.queries[e].elementEnd(t)}embeddedTView(t){let e=null;for(let i=0;i<this.length;i++){let r=null!==e?e.length:0,o=this.getByIndex(i).embeddedTView(t,r);o&&(o.indexInDeclarationView=i,null!==e?e.push(o):e=[o])}return null!==e?new kx(e):null}template(t,e){for(let i=0;i<this.queries.length;i++)this.queries[i].template(t,e)}getByIndex(t){return this.queries[t]}get length(){return this.queries.length}track(t){this.queries.push(t)}},Fx=class{constructor(t,e=-1){this.metadata=t,this.matches=null,this.indexInDeclarationView=-1,this.crossesNgTemplate=!1,this._appliesToNextNode=!0,this._declarationNodeIndex=e}elementStart(t,e){this.isApplyingToNode(e)&&this.matchTNode(t,e)}elementEnd(t){this._declarationNodeIndex===t.index&&(this._appliesToNextNode=!1)}template(t,e){this.elementStart(t,e)}embeddedTView(t,e){return this.isApplyingToNode(t)?(this.crossesNgTemplate=!0,this.addMatch(-t.index,e),new Fx(this.metadata)):null}isApplyingToNode(t){if(this._appliesToNextNode&&1!=(1&this.metadata.flags)){let e=this._declarationNodeIndex,i=t.parent;for(;null!==i&&8&i.type&&i.index!==e;)i=i.parent;return e===(null!==i?i.index:-1)}return this._appliesToNextNode}matchTNode(t,e){let i=this.metadata.predicate;if(Array.isArray(i))for(let r=0;r<i.length;r++){let o=i[r];this.matchTNodeWithReadOption(t,e,_Ce(e,o)),this.matchTNodeWithReadOption(t,e,I1(e,t,o,!1,!1))}else i===Vi?4&e.type&&this.matchTNodeWithReadOption(t,e,-1):this.matchTNodeWithReadOption(t,e,I1(e,t,i,!1,!1))}matchTNodeWithReadOption(t,e,i){if(null!==i){let r=this.metadata.read;if(null!==r)if(r===Re||r===Oi||r===Vi&&4&e.type)this.addMatch(e.index,-2);else{let o=I1(e,t,r,!1,!1);null!==o&&this.addMatch(e.index,o)}else this.addMatch(e.index,i)}}addMatch(t,e){null===this.matches?this.matches=[t,e]:this.matches.push(t,e)}};function _Ce(n,t){let e=n.localNames;if(null!==e)for(let i=0;i<e.length;i+=2)if(e[i]===t)return e[i+1];return null}function yCe(n,t,e,i){return-1===e?function(n,t){return 11&n.type?G0(n,t):4&n.type?RT(n,t):null}(t,n):-2===e?function(n,t,e){return e===Re?G0(t,n):e===Vi?RT(t,n):e===Oi?BY(t,n):void 0}(n,t,i):Bx(n,n[1],e,t)}function VY(n,t,e,i){let r=t[19].queries[i];if(null===r.matches){let o=n.data,s=e.matches,a=[];for(let l=0;l<s.length;l+=2){let c=s[l];a.push(c<0?null:yCe(t,o[c],s[l+1],e.metadata.read))}r.matches=a}return r.matches}function QL(n,t,e,i){let r=n.queries.getByIndex(e),o=r.matches;if(null!==o){let s=VY(n,t,r,e);for(let a=0;a<o.length;a+=2){let l=o[a];if(l>0)i.push(s[a/2]);else{let c=o[a+1],u=t[-l];for(let d=10;d<u.length;d++){let p=u[d];p[17]===p[3]&&QL(p[1],p,c,i)}if(null!==u[9]){let d=u[9];for(let p=0;p<d.length;p++){let h=d[p];QL(h[1],h,c,i)}}}}}return i}function Ne(n){let t=rt(),e=Fi(),i=q7();v3(i+1);let r=zY(e,i);if(n.dirty&&function(n){return 4==(4&n[2])}(t)===(2==(2&r.metadata.flags))){if(null===r.matches)n.reset([]);else{let o=r.crossesNgTemplate?QL(e,t,i,[]):VY(e,t,r,i);n.reset(o,Bve),n.notifyOnChanges()}return!0}return!1}function ot(n,t,e){let i=Fi();i.firstCreatePass&&(UY(i,new rT(n,t,e),-1),2==(2&t)&&(i.staticViewQueries=!0)),HY(i,rt(),t)}function Ei(n,t,e,i){let r=Fi();if(r.firstCreatePass){let o=zo();UY(r,new rT(t,e,i),o.index),function(n,t){let e=n.contentQueries||(n.contentQueries=[]);t!==(e.length?e[e.length-1]:-1)&&e.push(n.queries.length-1,t)}(r,n),2==(2&e)&&(r.staticContentQueries=!0)}HY(r,rt(),e)}function Le(){return n=rt(),t=q7(),n[19].queries[t].queryList;var n,t}function HY(n,t,e){let i=new Hl(4==(4&e));uq(n,t,i,i.destroy),null===t[19]&&(t[19]=new Ox),t[19].queries.push(new Rx(i))}function UY(n,t,e){null===n.queries&&(n.queries=new kx),n.queries.track(new Fx(t,e))}function zY(n,t){return n.queries.getByIndex(t)}function qt(n,t){return RT(n,t)}var Hp={"\u0275\u0275attribute":ze,"\u0275\u0275attributeInterpolate1":function Eq(n,t,e,i,r,o){let s=rt(),a=X0(s,t,e,i);return a!==Qn&&Tu(no(),s,n,a,r,o),Eq},"\u0275\u0275attributeInterpolate2":function Tq(n,t,e,i,r,o,s,a){let l=rt(),c=Q0(l,t,e,i,r,o);return c!==Qn&&Tu(no(),l,n,c,s,a),Tq},"\u0275\u0275attributeInterpolate3":function Dq(n,t,e,i,r,o,s,a,l,c){let u=rt(),d=K0(u,t,e,i,r,o,s,a);return d!==Qn&&Tu(no(),u,n,d,l,c),Dq},"\u0275\u0275attributeInterpolate4":function Aq(n,t,e,i,r,o,s,a,l,c,u,d){let p=rt(),h=Z0(p,t,e,i,r,o,s,a,l,c);return h!==Qn&&Tu(no(),p,n,h,u,d),Aq},"\u0275\u0275attributeInterpolate5":function Iq(n,t,e,i,r,o,s,a,l,c,u,d,p,h){let f=rt(),m=J0(f,t,e,i,r,o,s,a,l,c,u,d);return m!==Qn&&Tu(no(),f,n,m,p,h),Iq},"\u0275\u0275attributeInterpolate6":function Pq(n,t,e,i,r,o,s,a,l,c,u,d,p,h,f,m){let x=rt(),g=$0(x,t,e,i,r,o,s,a,l,c,u,d,p,h);return g!==Qn&&Tu(no(),x,n,g,f,m),Pq},"\u0275\u0275attributeInterpolate7":function Rq(n,t,e,i,r,o,s,a,l,c,u,d,p,h,f,m,x,g){let b=rt(),D=e_(b,t,e,i,r,o,s,a,l,c,u,d,p,h,f,m);return D!==Qn&&Tu(no(),b,n,D,x,g),Rq},"\u0275\u0275attributeInterpolate8":function Oq(n,t,e,i,r,o,s,a,l,c,u,d,p,h,f,m,x,g,b,D){let T=rt(),k=t_(T,t,e,i,r,o,s,a,l,c,u,d,p,h,f,m,x,g);return k!==Qn&&Tu(no(),T,n,k,b,D),Oq},"\u0275\u0275attributeInterpolateV":function kq(n,t,e,i){let r=rt(),o=Y0(r,t);return o!==Qn&&Tu(no(),r,n,o,e,i),kq},"\u0275\u0275defineComponent":R,"\u0275\u0275defineDirective":He,"\u0275\u0275defineInjectable":ye,"\u0275\u0275defineInjector":V,"\u0275\u0275defineNgModule":H,"\u0275\u0275definePipe":B0,"\u0275\u0275directiveInject":M,"\u0275\u0275getInheritedFactory":pi,"\u0275\u0275inject":j,"\u0275\u0275injectAttribute":vo,"\u0275\u0275invalidFactory":nl,"\u0275\u0275invalidFactoryDep":d9,"\u0275\u0275templateRefExtractor":qt,"\u0275\u0275resetView":se,"\u0275\u0275NgOnChangesFeature":Ft,"\u0275\u0275ProvidersFeature":$t,"\u0275\u0275CopyDefinitionFeature":function(n){let e,t=Sq(n.type);e=Ac(n)?t.\u0275cmp:t.\u0275dir;let i=n;for(let r of cbe)i[r]=e[r];if(Ac(e))for(let r of ube)i[r]=e[r]},"\u0275\u0275InheritDefinitionFeature":tt,"\u0275\u0275StandaloneFeature":function(n){n.getStandaloneInjector=t=>t.get(eCe).getOrCreateStandaloneInjector(n)},"\u0275\u0275nextContext":S,"\u0275\u0275namespaceHTML":Js,"\u0275\u0275namespaceMathML":function(){Zn.lFrame.currentNamespace="math"},"\u0275\u0275namespaceSVG":In,"\u0275\u0275enableBindings":function(){Zn.bindingsEnabled=!0},"\u0275\u0275disableBindings":function(){Zn.bindingsEnabled=!1},"\u0275\u0275elementStart":_,"\u0275\u0275elementEnd":v,"\u0275\u0275element":O,"\u0275\u0275elementContainerStart":sn,"\u0275\u0275elementContainerEnd":an,"\u0275\u0275elementContainer":Ni,"\u0275\u0275pureFunction0":Qp,"\u0275\u0275pureFunction1":On,"\u0275\u0275pureFunction2":Qr,"\u0275\u0275pureFunction3":Zx,"\u0275\u0275pureFunction4":K3,"\u0275\u0275pureFunction5":Z3,"\u0275\u0275pureFunction6":function(n,t,e,i,r,o,s,a,l){let c=Ks()+n,u=rt(),d=Vl(u,c,e,i,r,o);return Kf(u,c+4,s,a)||d?Du(u,c+6,l?t.call(l,e,i,r,o,s,a):t(e,i,r,o,s,a)):Yx(u,c+6)},"\u0275\u0275pureFunction7":function(n,t,e,i,r,o,s,a,l,c){let u=Ks()+n,d=rt(),p=Vl(d,u,e,i,r,o);return ST(d,u+4,s,a,l)||p?Du(d,u+7,c?t.call(c,e,i,r,o,s,a,l):t(e,i,r,o,s,a,l)):Yx(d,u+7)},"\u0275\u0275pureFunction8":function(n,t,e,i,r,o,s,a,l,c,u){let d=Ks()+n,p=rt(),h=Vl(p,d,e,i,r,o);return Vl(p,d+4,s,a,l,c)||h?Du(p,d+8,u?t.call(u,e,i,r,o,s,a,l,c):t(e,i,r,o,s,a,l,c)):Yx(p,d+8)},"\u0275\u0275pureFunctionV":function(n,t,e,i){return NY(rt(),Ks(),n,t,e,i)},"\u0275\u0275getCurrentView":Pe,"\u0275\u0275restoreView":oe,"\u0275\u0275listener":P,"\u0275\u0275projection":Vn,"\u0275\u0275syntheticHostProperty":r_,"\u0275\u0275syntheticHostListener":i_,"\u0275\u0275pipeBind1":U,"\u0275\u0275pipeBind2":Jf,"\u0275\u0275pipeBind3":J3,"\u0275\u0275pipeBind4":function(n,t,e,i,r,o){let s=n+22,a=rt(),l=H0(a,s);return $x(a,s)?FY(a,Ks(),t,l.transform,e,i,r,o,l):l.transform(e,i,r,o)},"\u0275\u0275pipeBindV":function(n,t,e){let i=n+22,r=rt(),o=H0(r,i);return $x(r,i)?NY(r,Ks(),t,o.transform,e,o):o.transform.apply(o,e)},"\u0275\u0275projectionDef":xi,"\u0275\u0275hostProperty":_s,"\u0275\u0275property":y,"\u0275\u0275propertyInterpolate":Zi,"\u0275\u0275propertyInterpolate1":Xx,"\u0275\u0275propertyInterpolate2":ET,"\u0275\u0275propertyInterpolate3":function Nq(n,t,e,i,r,o,s,a,l){let c=rt(),u=K0(c,t,e,i,r,o,s,a);return u!==Qn&&il(Fi(),no(),c,n,u,c[11],l,!1),Nq},"\u0275\u0275propertyInterpolate4":function Lq(n,t,e,i,r,o,s,a,l,c,u){let d=rt(),p=Z0(d,t,e,i,r,o,s,a,l,c);return p!==Qn&&il(Fi(),no(),d,n,p,d[11],u,!1),Lq},"\u0275\u0275propertyInterpolate5":function Bq(n,t,e,i,r,o,s,a,l,c,u,d,p){let h=rt(),f=J0(h,t,e,i,r,o,s,a,l,c,u,d);return f!==Qn&&il(Fi(),no(),h,n,f,h[11],p,!1),Bq},"\u0275\u0275propertyInterpolate6":function Vq(n,t,e,i,r,o,s,a,l,c,u,d,p,h,f){let m=rt(),x=$0(m,t,e,i,r,o,s,a,l,c,u,d,p,h);return x!==Qn&&il(Fi(),no(),m,n,x,m[11],f,!1),Vq},"\u0275\u0275propertyInterpolate7":function Hq(n,t,e,i,r,o,s,a,l,c,u,d,p,h,f,m,x){let g=rt(),b=e_(g,t,e,i,r,o,s,a,l,c,u,d,p,h,f,m);return b!==Qn&&il(Fi(),no(),g,n,b,g[11],x,!1),Hq},"\u0275\u0275propertyInterpolate8":function Uq(n,t,e,i,r,o,s,a,l,c,u,d,p,h,f,m,x,g,b){let D=rt(),T=t_(D,t,e,i,r,o,s,a,l,c,u,d,p,h,f,m,x,g);return T!==Qn&&il(Fi(),no(),D,n,T,D[11],b,!1),Uq},"\u0275\u0275propertyInterpolateV":function zq(n,t,e){let i=rt(),r=Y0(i,t);return r!==Qn&&il(Fi(),no(),i,n,r,i[11],e,!1),zq},"\u0275\u0275pipe":B,"\u0275\u0275queryRefresh":Ne,"\u0275\u0275viewQuery":ot,"\u0275\u0275loadQuery":Le,"\u0275\u0275contentQuery":Ei,"\u0275\u0275reference":$e,"\u0275\u0275classMap":Da,"\u0275\u0275classMapInterpolate1":Qx,"\u0275\u0275classMapInterpolate2":function(n,t,e,i,r){Oc(el,Au,Q0(rt(),n,t,e,i,r),!0)},"\u0275\u0275classMapInterpolate3":function(n,t,e,i,r,o,s){Oc(el,Au,K0(rt(),n,t,e,i,r,o,s),!0)},"\u0275\u0275classMapInterpolate4":function(n,t,e,i,r,o,s,a,l){Oc(el,Au,Z0(rt(),n,t,e,i,r,o,s,a,l),!0)},"\u0275\u0275classMapInterpolate5":function(n,t,e,i,r,o,s,a,l,c,u){Oc(el,Au,J0(rt(),n,t,e,i,r,o,s,a,l,c,u),!0)},"\u0275\u0275classMapInterpolate6":function(n,t,e,i,r,o,s,a,l,c,u,d,p){Oc(el,Au,$0(rt(),n,t,e,i,r,o,s,a,l,c,u,d,p),!0)},"\u0275\u0275classMapInterpolate7":function(n,t,e,i,r,o,s,a,l,c,u,d,p,h,f){Oc(el,Au,e_(rt(),n,t,e,i,r,o,s,a,l,c,u,d,p,h,f),!0)},"\u0275\u0275classMapInterpolate8":function(n,t,e,i,r,o,s,a,l,c,u,d,p,h,f,m,x){Oc(el,Au,t_(rt(),n,t,e,i,r,o,s,a,l,c,u,d,p,h,f,m,x),!0)},"\u0275\u0275classMapInterpolateV":function(n){Oc(el,Au,Y0(rt(),n),!0)},"\u0275\u0275styleMap":jl,"\u0275\u0275styleMapInterpolate1":function(n,t,e){jl(X0(rt(),n,t,e))},"\u0275\u0275styleMapInterpolate2":function(n,t,e,i,r){jl(Q0(rt(),n,t,e,i,r))},"\u0275\u0275styleMapInterpolate3":function(n,t,e,i,r,o,s){jl(K0(rt(),n,t,e,i,r,o,s))},"\u0275\u0275styleMapInterpolate4":function(n,t,e,i,r,o,s,a,l){jl(Z0(rt(),n,t,e,i,r,o,s,a,l))},"\u0275\u0275styleMapInterpolate5":function(n,t,e,i,r,o,s,a,l,c,u){jl(J0(rt(),n,t,e,i,r,o,s,a,l,c,u))},"\u0275\u0275styleMapInterpolate6":function(n,t,e,i,r,o,s,a,l,c,u,d,p){jl($0(rt(),n,t,e,i,r,o,s,a,l,c,u,d,p))},"\u0275\u0275styleMapInterpolate7":function(n,t,e,i,r,o,s,a,l,c,u,d,p,h,f){jl(e_(rt(),n,t,e,i,r,o,s,a,l,c,u,d,p,h,f))},"\u0275\u0275styleMapInterpolate8":function(n,t,e,i,r,o,s,a,l,c,u,d,p,h,f,m,x){jl(t_(rt(),n,t,e,i,r,o,s,a,l,c,u,d,p,h,f,m,x))},"\u0275\u0275styleMapInterpolateV":function(n){jl(Y0(rt(),n))},"\u0275\u0275styleProp":Pt,"\u0275\u0275stylePropInterpolate1":function rY(n,t,e,i,r){return Rc(n,X0(rt(),t,e,i),r,!1),rY},"\u0275\u0275stylePropInterpolate2":function oY(n,t,e,i,r,o,s){return Rc(n,Q0(rt(),t,e,i,r,o),s,!1),oY},"\u0275\u0275stylePropInterpolate3":function sY(n,t,e,i,r,o,s,a,l){return Rc(n,K0(rt(),t,e,i,r,o,s,a),l,!1),sY},"\u0275\u0275stylePropInterpolate4":function aY(n,t,e,i,r,o,s,a,l,c,u){return Rc(n,Z0(rt(),t,e,i,r,o,s,a,l,c),u,!1),aY},"\u0275\u0275stylePropInterpolate5":function lY(n,t,e,i,r,o,s,a,l,c,u,d,p){return Rc(n,J0(rt(),t,e,i,r,o,s,a,l,c,u,d),p,!1),lY},"\u0275\u0275stylePropInterpolate6":function cY(n,t,e,i,r,o,s,a,l,c,u,d,p,h,f){return Rc(n,$0(rt(),t,e,i,r,o,s,a,l,c,u,d,p,h),f,!1),cY},"\u0275\u0275stylePropInterpolate7":function uY(n,t,e,i,r,o,s,a,l,c,u,d,p,h,f,m,x){return Rc(n,e_(rt(),t,e,i,r,o,s,a,l,c,u,d,p,h,f,m),x,!1),uY},"\u0275\u0275stylePropInterpolate8":function dY(n,t,e,i,r,o,s,a,l,c,u,d,p,h,f,m,x,g,b){return Rc(n,t_(rt(),t,e,i,r,o,s,a,l,c,u,d,p,h,f,m,x,g),b,!1),dY},"\u0275\u0275stylePropInterpolateV":function pY(n,t,e){return Rc(n,Y0(rt(),t),e,!1),pY},"\u0275\u0275classProp":et,"\u0275\u0275advance":C,"\u0275\u0275template":E,"\u0275\u0275text":A,"\u0275\u0275textInterpolate":yt,"\u0275\u0275textInterpolate1":je,"\u0275\u0275textInterpolate2":Xp,"\u0275\u0275textInterpolate3":TT,"\u0275\u0275textInterpolate4":function Jq(n,t,e,i,r,o,s,a,l){let c=rt(),u=Z0(c,n,t,e,i,r,o,s,a,l);return u!==Qn&&jd(c,Zs(),u),Jq},"\u0275\u0275textInterpolate5":function $q(n,t,e,i,r,o,s,a,l,c,u){let d=rt(),p=J0(d,n,t,e,i,r,o,s,a,l,c,u);return p!==Qn&&jd(d,Zs(),p),$q},"\u0275\u0275textInterpolate6":function eY(n,t,e,i,r,o,s,a,l,c,u,d,p){let h=rt(),f=$0(h,n,t,e,i,r,o,s,a,l,c,u,d,p);return f!==Qn&&jd(h,Zs(),f),eY},"\u0275\u0275textInterpolate7":function tY(n,t,e,i,r,o,s,a,l,c,u,d,p,h,f){let m=rt(),x=e_(m,n,t,e,i,r,o,s,a,l,c,u,d,p,h,f);return x!==Qn&&jd(m,Zs(),x),tY},"\u0275\u0275textInterpolate8":function nY(n,t,e,i,r,o,s,a,l,c,u,d,p,h,f,m,x){let g=rt(),b=t_(g,n,t,e,i,r,o,s,a,l,c,u,d,p,h,f,m,x);return b!==Qn&&jd(g,Zs(),b),nY},"\u0275\u0275textInterpolateV":function iY(n){let t=rt(),e=Y0(t,n);return e!==Qn&&jd(t,Zs(),e),iY},"\u0275\u0275i18n":AT,"\u0275\u0275i18nAttributes":function(n,t){let e=Fi();!function(n,t,e){let r=zo().index,o=[];if(n.firstCreatePass&&null===n.data[t]){for(let s=0;s<e.length;s+=2){let a=e[s],l=e[s+1];if(""!==l){if(Cxe.test(l))throw new Error(`ICU expressions are not supported in attributes. Message: "${l}".`);bx(o,l,r,a,Pxe(o),null)}}n.data[t]=o}}(e,n+22,Up(e.consts,t))},"\u0275\u0275i18nExp":Kx,"\u0275\u0275i18nStart":AY,"\u0275\u0275i18nEnd":IY,"\u0275\u0275i18nApply":IT,"\u0275\u0275i18nPostprocess":PT,"\u0275\u0275resolveWindow":Wx,"\u0275\u0275resolveDocument":_T,"\u0275\u0275resolveBody":function(n){return n.ownerDocument.body},"\u0275\u0275setComponentScope":Nx,"\u0275\u0275setNgModuleScope":function(n,t){return Zf(()=>{let e=I0(n,!0);e.declarations=t.declarations||Qi,e.imports=t.imports||Qi,e.exports=t.exports||Qi})},"\u0275\u0275registerNgModuleType":m9,"\u0275\u0275sanitizeHtml":A3,"\u0275\u0275sanitizeStyle":function(n){let t=Gx();return t?t.sanitize(mo.STYLE,n)||"":Pc(n,"Style")?Ta(n):Kn(n)},"\u0275\u0275sanitizeResourceUrl":A9,"\u0275\u0275sanitizeScript":function(n){let t=Gx();if(t)return qW(t.sanitize(mo.SCRIPT,n)||"");if(Pc(n,"Script"))return qW(Ta(n));throw new At(905,!1)},"\u0275\u0275sanitizeUrl":zl,"\u0275\u0275sanitizeUrlOrResourceUrl":function(n,t,e){return function(n,t){return"src"===t&&("embed"===n||"frame"===n||"iframe"===n||"media"===n||"script"===n)||"href"===t&&("base"===n||"link"===n)?A9:zl}(t,e)(n)},"\u0275\u0275trustConstantHtml":function(n){return O0(n[0])},"\u0275\u0275trustConstantResourceUrl":function(n){return function(n){return v9()?.createScriptURL(n)||n}(n[0])},forwardRef:Jn,resolveForwardRef:Ki};function jY(n){return!!I0(n)}var F1=[],JN=!1;function GY(n){return Array.isArray(n)?n.every(GY):!!Ki(n)}function ICe(n,t){let e=Fd(t.declarations||Qi),i=L0(n);e.forEach(r=>{(r=Ki(r)).hasOwnProperty(cT)?WY(Nl(r),i):!r.hasOwnProperty(l3)&&!r.hasOwnProperty(c3)&&(r.ngSelectorScope=n)})}function WY(n,t){n.directiveDefs=()=>Array.from(t.compilation.directives).map(e=>e.hasOwnProperty(cT)?Nl(e):Gf(e)).filter(e=>!!e),n.pipeDefs=()=>Array.from(t.compilation.pipes).map(e=>Ld(e)),n.schemas=t.schemas,n.tView=null}function L0(n){if(jY(n))return function(n){let t=I0(n,!0);if(null!==t.transitiveCompileScopes)return t.transitiveCompileScopes;let e={schemas:t.schemas||null,compilation:{directives:new Set,pipes:new Set},exported:{directives:new Set,pipes:new Set}};return R1(t.imports).forEach(i=>{let r=L0(i);r.exported.directives.forEach(o=>e.compilation.directives.add(o)),r.exported.pipes.forEach(o=>e.compilation.pipes.add(o))}),R1(t.declarations).forEach(i=>{Ld(i)?e.compilation.pipes.add(i):e.compilation.directives.add(i)}),R1(t.exports).forEach(i=>{let r=i;if(jY(r)){let o=L0(r);o.exported.directives.forEach(s=>{e.compilation.directives.add(s),e.exported.directives.add(s)}),o.exported.pipes.forEach(s=>{e.compilation.pipes.add(s),e.exported.pipes.add(s)})}else Ld(r)?e.exported.pipes.add(r):e.exported.directives.add(r)}),t.transitiveCompileScopes=e,e}(n);if(R7(n)){if(null!==(Nl(n)||Gf(n)))return{schemas:null,compilation:{directives:new Set,pipes:new Set},exported:{directives:new Set([n]),pipes:new Set}};if(null!==Ld(n))return{schemas:null,compilation:{directives:new Set,pipes:new Set},exported:{directives:new Set,pipes:new Set([n])}}}throw new Error(`${n.name} does not have a module def (\u0275mod property)`)}function _7(n){return function(n){return void 0!==n.ngModule}(n)?n.ngModule:n}var $N=0;function qY(n,t){let e=null;XY(n,t||{}),Object.defineProperty(n,l3,{get:()=>{if(null===e){let i=YY(n,t||{});e=Ll().compileDirective(Hp,i.sourceMapUrl,i.metadata)}return e},configurable:!1})}function YY(n,t){let e=n&&n.name,i=`ng:///${e}/\u0275dir.js`,r=Ll(),o=QY(n,t);return o.typeSourceSpan=r.createParseSourceSpan("Directive",e,i),o.usesInheritance&&KY(n),{metadata:o,sourceMapUrl:i}}function XY(n,t){let e=null;Object.defineProperty(n,Nd,{get:()=>{if(null===e){let i=YY(n,t),r=Ll();e=r.compileFactory(Hp,`ng:///${n.name}/\u0275fac.js`,{name:i.metadata.name,type:i.metadata.type,typeArgumentCount:0,deps:fT(n),target:r.FactoryTarget.Directive})}return e},configurable:!1})}function FCe(n){return Object.getPrototypeOf(n.prototype)===Object.prototype}function QY(n,t){let e=S3(),i=e.ownPropMetadata(n);return{name:n.name,type:n,selector:void 0!==t.selector?t.selector:null,host:t.host||A0,propMetadata:i,inputs:t.inputs||Qi,outputs:t.outputs||Qi,queries:v7(n,i,ZY),lifecycle:{usesOnChanges:e.hasLifecycleHook(n,"ngOnChanges")},typeSourceSpan:null,usesInheritance:!FCe(n),exportAs:BCe(t.exportAs),providers:t.providers||null,viewQueries:v7(n,i,JY),isStandalone:!!t.standalone}}function KY(n){let t=Object.prototype,e=Object.getPrototypeOf(n.prototype).constructor;for(;e&&e!==t;)!Gf(e)&&!Nl(e)&&HCe(e)&&qY(e,null),e=Object.getPrototypeOf(e)}function NCe(n){return"string"==typeof n?eX(n):Ki(n)}function LCe(n,t){return{propertyName:n,predicate:NCe(t.selector),descendants:t.descendants,first:t.first,read:t.read?t.read:null,static:!!t.static,emitDistinctChangesOnly:!!t.emitDistinctChangesOnly}}function v7(n,t,e){let i=[];for(let r in t)if(t.hasOwnProperty(r)){let o=t[r];o.forEach(s=>{if(e(s)){if(!s.selector)throw new Error(`Can't construct a query for the property "${r}" of "${o3(n)}" since the query selector wasn't defined.`);if(o.some($Y))throw new Error("Cannot combine @Input decorators with query decorators");i.push(LCe(r,s))}})}return i}function BCe(n){return void 0===n?null:eX(n)}function ZY(n){let t=n.ngMetadataName;return"ContentChild"===t||"ContentChildren"===t}function JY(n){let t=n.ngMetadataName;return"ViewChild"===t||"ViewChildren"===t}function $Y(n){return"Input"===n.ngMetadataName}function eX(n){return n.split(",").map(t=>t.trim())}var VCe=["ngOnChanges","ngOnInit","ngOnDestroy","ngDoCheck","ngAfterViewInit","ngAfterViewChecked","ngAfterContentInit","ngAfterContentChecked"];function HCe(n){let t=S3();if(VCe.some(i=>t.hasLifecycleHook(n,i)))return!0;let e=t.propMetadata(n);for(let i in e){let r=e[i];for(let o=0;o<r.length;o++){let s=r[o],a=s.ngMetadataName;if($Y(s)||ZY(s)||JY(s)||"Output"===a||"HostBinding"===a||"HostListener"===a)return!0}}return!1}function y7(n,t){return{type:n,name:n.name,pipeName:t.name,pure:void 0===t.pure||t.pure,isStandalone:!!t.standalone}}var zCe=Vx("Directive",(n={})=>n,void 0,void 0,(n,t)=>qY(n,t));function oT(...n){}Vx("Component",(n={})=>({changeDetection:px.Default,...n}),zCe,void 0,(n,t)=>function(n,t){let e=null;(function(n,t){f9(t)&&(Dx.set(n,t),h9.add(n))})(n,t),XY(n,t),Object.defineProperty(n,cT,{get:()=>{if(null===e){let i=Ll();if(f9(t)){let c=[`Component '${n.name}' is not resolved:`];throw t.templateUrl&&c.push(` - templateUrl: ${t.templateUrl}`),t.styleUrls&&t.styleUrls.length&&c.push(` - styleUrls: ${JSON.stringify(t.styleUrls)}`),c.push("Did you run and wait for 'resolveComponentResources()'?"),new Error(c.join("\n"))}let r=null,o=t.preserveWhitespaces;void 0===o&&(o=null!==r&&void 0!==r.preserveWhitespaces&&r.preserveWhitespaces);let s=t.encapsulation;void 0===s&&(s=null!==r&&void 0!==r.defaultEncapsulation?r.defaultEncapsulation:Ja.Emulated);let a=t.templateUrl||`ng:///${n.name}/template.html`,l={...QY(n,t),typeSourceSpan:i.createParseSourceSpan("Component",n.name,a),template:t.template||"",preserveWhitespaces:o,styles:t.styles||Qi,animations:t.animations,declarations:[],changeDetection:t.changeDetection,encapsulation:s,interpolation:t.interpolation,viewProviders:t.viewProviders||null,isStandalone:!!t.standalone};$N++;try{if(l.usesInheritance&&KY(n),e=i.compileComponent(Hp,a,l),t.standalone){let c=Fd(t.imports||Qi),{directiveDefs:u,pipeDefs:d}=function(n,t){let e=null,i=null;return{directiveDefs:()=>{if(null===e){e=[Nl(n)];let s=new Set;for(let a of t){let l=Ki(a);if(!s.has(l))if(s.add(l),I0(l)){let c=L0(l);for(let u of c.exported.directives){let d=Nl(u)||Gf(u);d&&!s.has(u)&&(s.add(u),e.push(d))}}else{let c=Nl(l)||Gf(l);c&&e.push(c)}}}return e},pipeDefs:()=>{if(null===i){i=[];let s=new Set;for(let a of t){let l=Ki(a);if(!s.has(l))if(s.add(l),I0(l)){let c=L0(l);for(let u of c.exported.pipes){let d=Ld(u);d&&!s.has(u)&&(s.add(u),i.push(d))}}else{let c=Ld(l);c&&i.push(c)}}}return i}}}(n,c);e.directiveDefs=u,e.pipeDefs=d,e.dependencies=()=>c.map(Ki)}}finally{$N--}if(0===$N&&function(){if(!JN){JN=!0;try{for(let n=F1.length-1;n>=0;n--){let{moduleType:t,ngModule:e}=F1[n];e.declarations&&e.declarations.every(GY)&&(F1.splice(n,1),ICe(t,e))}}finally{JN=!1}}}(),function(n){return void 0!==n.ngSelectorScope}(n)){let c=L0(n.ngSelectorScope);WY(e,c)}if(t.schemas){if(!t.standalone)throw new Error(`The 'schemas' was specified for the ${o3(n)} but is only valid on a component that is standalone.`);e.schemas=t.schemas}else t.standalone&&(e.schemas=[])}return e},configurable:!1})}(n,t)),Vx("Pipe",n=>({pure:!0,...n}),void 0,void 0,(n,t)=>function(n,t){let e=null,i=null;Object.defineProperty(n,Nd,{get:()=>{if(null===i){let r=y7(n,t),o=Ll();i=o.compileFactory(Hp,`ng:///${r.name}/\u0275fac.js`,{name:r.name,type:r.type,typeArgumentCount:0,deps:fT(n),target:o.FactoryTarget.Pipe})}return i},configurable:!1}),Object.defineProperty(n,c3,{get:()=>{if(null===e){let r=y7(n,t);e=Ll().compilePipe(Hp,`ng:///${r.name}/\u0275pipe.js`,r)}return e},configurable:!1})}(n,t)),Yp("Input",n=>({bindingPropertyName:n})),Yp("Output",n=>({bindingPropertyName:n})),Yp("HostBinding",n=>({hostPropertyName:n})),Yp("HostListener",(n,t)=>({eventName:n,args:t})),Vx("NgModule",n=>n,void 0,void 0,(n,t)=>function(n,t={}){(function(n,t,e=!1){let i=Fd(t.declarations||Qi),r=null;Object.defineProperty(n,I7,{configurable:!0,get:()=>(null===r&&(r=Ll().compileNgModule(Hp,`ng:///${n.name}/\u0275mod.js`,{type:n,bootstrap:Fd(t.bootstrap||Qi).map(Ki),declarations:i.map(Ki),imports:Fd(t.imports||Qi).map(Ki).map(_7),exports:Fd(t.exports||Qi).map(Ki).map(_7),schemas:t.schemas?Fd(t.schemas):null,id:t.id||null}),r.schemas||(r.schemas=[])),r)});let o=null;Object.defineProperty(n,Nd,{get:()=>{if(null===o){let a=Ll();o=a.compileFactory(Hp,`ng:///${n.name}/\u0275fac.js`,{name:n.name,type:n,deps:fT(n),target:a.FactoryTarget.NgModule,typeArgumentCount:0})}return o},configurable:!1});let s=null;Object.defineProperty(n,nL,{get:()=>{if(null===s){let a={name:n.name,type:n,providers:t.providers||Qi,imports:[(t.imports||Qi).map(Ki),(t.exports||Qi).map(Ki)]};s=Ll().compileInjector(Hp,`ng:///${n.name}/\u0275inj.js`,a)}return s},configurable:!1})})(n,t),void 0!==t.id&&m9(n,t.id),function(n,t){F1.push({moduleType:n,ngModule:t})}(n,t)}(n,t));var $3=new pe("Application Initializer"),OT=(()=>{class n{constructor(e){this.appInits=e,this.resolve=oT,this.reject=oT,this.initialized=!1,this.done=!1,this.donePromise=new Promise((i,r)=>{this.resolve=i,this.reject=r})}runInitializers(){if(this.initialized)return;let e=[],i=()=>{this.done=!0,this.resolve()};if(this.appInits)for(let r=0;r<this.appInits.length;r++){let o=this.appInits[r]();if(n_(o))e.push(o);else if(Q3(o)){let s=new Promise((a,l)=>{o.subscribe({complete:a,error:l})});e.push(s)}}Promise.all(e).then(()=>{i()}).catch(r=>{this.reject(r)}),0===e.length&&i(),this.initialized=!0}}return n.\u0275fac=function(e){return new(e||n)(j($3,8))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),$f=new pe("AppId",{providedIn:"root",factory:function(){return`${eL()}${eL()}${eL()}`}});function eL(){return String.fromCharCode(97+Math.floor(25*Math.random()))}var eB=new pe("Platform Initializer"),Gd=new pe("Platform ID",{providedIn:"platform",factory:()=>"unknown"}),GCe=new pe("appBootstrapListener"),Pi=(new pe("Application Packages Root URL"),new pe("AnimationModuleType")),Wd=new pe("LocaleId",{providedIn:"root",factory:()=>jo(Wd,di.Optional|di.SkipSelf)||typeof $localize<"u"&&$localize.locale||nT}),XCe=(new pe("DefaultCurrencyCode",{providedIn:"root",factory:()=>"USD"}),new pe("Translations"),new pe("TranslationsFormat"),new pe("compilerOptions"),Promise.resolve(0));function KL(n){typeof Zone>"u"?XCe.then(()=>{n&&n.apply(null,null)}):Zone.current.scheduleMicroTask("scheduleMicrotask",n)}var _t=class{constructor({enableLongStackTrace:t=!1,shouldCoalesceEventChangeDetection:e=!1,shouldCoalesceRunChangeDetection:i=!1}){if(this.hasPendingMacrotasks=!1,this.hasPendingMicrotasks=!1,this.isStable=!0,this.onUnstable=new G(!1),this.onMicrotaskEmpty=new G(!1),this.onStable=new G(!1),this.onError=new G(!1),typeof Zone>"u")throw new At(908,!1);Zone.assertZonePatched();let r=this;if(r._nesting=0,r._outer=r._inner=Zone.current,Zone.AsyncStackTaggingZoneSpec){let o=Zone.AsyncStackTaggingZoneSpec;r._inner=r._inner.fork(new o("Angular"))}Zone.TaskTrackingZoneSpec&&(r._inner=r._inner.fork(new Zone.TaskTrackingZoneSpec)),t&&Zone.longStackTraceZoneSpec&&(r._inner=r._inner.fork(Zone.longStackTraceZoneSpec)),r.shouldCoalesceEventChangeDetection=!i&&e,r.shouldCoalesceRunChangeDetection=i,r.lastRequestAnimationFrameId=-1,r.nativeRequestAnimationFrame=function(){let n=to.requestAnimationFrame,t=to.cancelAnimationFrame;if(typeof Zone<"u"&&n&&t){let e=n[Zone.__symbol__("OriginalDelegate")];e&&(n=e);let i=t[Zone.__symbol__("OriginalDelegate")];i&&(t=i)}return{nativeRequestAnimationFrame:n,nativeCancelAnimationFrame:t}}().nativeRequestAnimationFrame,function(n){let t=()=>{!function(n){n.isCheckStableRunning||-1!==n.lastRequestAnimationFrameId||(n.lastRequestAnimationFrameId=n.nativeRequestAnimationFrame.call(to,()=>{n.fakeTopEventTask||(n.fakeTopEventTask=Zone.root.scheduleEventTask("fakeTopEventTask",()=>{n.lastRequestAnimationFrameId=-1,ZL(n),n.isCheckStableRunning=!0,tB(n),n.isCheckStableRunning=!1},void 0,()=>{},()=>{})),n.fakeTopEventTask.invoke()}),ZL(n))}(n)};n._inner=n._inner.fork({name:"angular",properties:{isAngularZone:!0},onInvokeTask:(e,i,r,o,s,a)=>{try{return b7(n),e.invokeTask(r,o,s,a)}finally{(n.shouldCoalesceEventChangeDetection&&"eventTask"===o.type||n.shouldCoalesceRunChangeDetection)&&t(),x7(n)}},onInvoke:(e,i,r,o,s,a,l)=>{try{return b7(n),e.invoke(r,o,s,a,l)}finally{n.shouldCoalesceRunChangeDetection&&t(),x7(n)}},onHasTask:(e,i,r,o)=>{e.hasTask(r,o),i===r&&("microTask"==o.change?(n._hasPendingMicrotasks=o.microTask,ZL(n),tB(n)):"macroTask"==o.change&&(n.hasPendingMacrotasks=o.macroTask))},onHandleError:(e,i,r,o)=>(e.handleError(r,o),n.runOutsideAngular(()=>n.onError.emit(o)),!1)})}(r)}static isInAngularZone(){return typeof Zone<"u"&&!0===Zone.current.get("isAngularZone")}static assertInAngularZone(){if(!_t.isInAngularZone())throw new At(909,!1)}static assertNotInAngularZone(){if(_t.isInAngularZone())throw new At(909,!1)}run(t,e,i){return this._inner.run(t,e,i)}runTask(t,e,i,r){let o=this._inner,s=o.scheduleEventTask("NgZoneEvent: "+r,t,KCe,oT,oT);try{return o.runTask(s,e,i)}finally{o.cancelTask(s)}}runGuarded(t,e,i){return this._inner.runGuarded(t,e,i)}runOutsideAngular(t){return this._outer.run(t)}},KCe={};function tB(n){if(0==n._nesting&&!n.hasPendingMicrotasks&&!n.isStable)try{n._nesting++,n.onMicrotaskEmpty.emit(null)}finally{if(n._nesting--,!n.hasPendingMicrotasks)try{n.runOutsideAngular(()=>n.onStable.emit(null))}finally{n.isStable=!0}}}function ZL(n){n.hasPendingMicrotasks=!!(n._hasPendingMicrotasks||(n.shouldCoalesceEventChangeDetection||n.shouldCoalesceRunChangeDetection)&&-1!==n.lastRequestAnimationFrameId)}function b7(n){n._nesting++,n.isStable&&(n.isStable=!1,n.onUnstable.emit(null))}function x7(n){n._nesting--,tB(n)}var iB,nB=new pe(""),eC=new pe(""),kT=(()=>{class n{constructor(e,i,r){this._ngZone=e,this.registry=i,this._pendingCount=0,this._isZoneStable=!0,this._didWork=!1,this._callbacks=[],this.taskTrackingZone=null,iB||(function(n){iB=n}(r),r.addToWindow(i)),this._watchAngularEvents(),e.run(()=>{this.taskTrackingZone=typeof Zone>"u"?null:Zone.current.get("TaskTrackingZone")})}_watchAngularEvents(){this._ngZone.onUnstable.subscribe({next:()=>{this._didWork=!0,this._isZoneStable=!1}}),this._ngZone.runOutsideAngular(()=>{this._ngZone.onStable.subscribe({next:()=>{_t.assertNotInAngularZone(),KL(()=>{this._isZoneStable=!0,this._runCallbacksIfReady()})}})})}increasePendingRequestCount(){return this._pendingCount+=1,this._didWork=!0,this._pendingCount}decreasePendingRequestCount(){if(this._pendingCount-=1,this._pendingCount<0)throw new Error("pending async requests below zero");return this._runCallbacksIfReady(),this._pendingCount}isStable(){return this._isZoneStable&&0===this._pendingCount&&!this._ngZone.hasPendingMacrotasks}_runCallbacksIfReady(){if(this.isStable())KL(()=>{for(;0!==this._callbacks.length;){let e=this._callbacks.pop();clearTimeout(e.timeoutId),e.doneCb(this._didWork)}this._didWork=!1});else{let e=this.getPendingTasks();this._callbacks=this._callbacks.filter(i=>!i.updateCb||!i.updateCb(e)||(clearTimeout(i.timeoutId),!1)),this._didWork=!0}}getPendingTasks(){return this.taskTrackingZone?this.taskTrackingZone.macroTasks.map(e=>({source:e.source,creationLocation:e.creationLocation,data:e.data})):[]}addCallback(e,i,r){let o=-1;i&&i>0&&(o=setTimeout(()=>{this._callbacks=this._callbacks.filter(s=>s.timeoutId!==o),e(this._didWork,this.getPendingTasks())},i)),this._callbacks.push({doneCb:e,timeoutId:o,updateCb:r})}whenStable(e,i,r){if(r&&!this.taskTrackingZone)throw new Error('Task tracking zone is required when passing an update callback to whenStable(). Is "zone.js/plugins/task-tracking" loaded?');this.addCallback(e,i,r),this._runCallbacksIfReady()}getPendingRequestCount(){return this._pendingCount}registerApplication(e){this.registry.registerApplication(e,this)}unregisterApplication(e){this.registry.unregisterApplication(e)}findProviders(e,i,r){return[]}}return n.\u0275fac=function(e){return new(e||n)(j(_t),j(FT),j(eC))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),FT=(()=>{class n{constructor(){this._applications=new Map}registerApplication(e,i){this._applications.set(e,i)}unregisterApplication(e){this._applications.delete(e)}unregisterAllApplications(){this._applications.clear()}getTestability(e){return this._applications.get(e)||null}getAllTestabilities(){return Array.from(this._applications.values())}getAllRootElements(){return Array.from(this._applications.keys())}findTestabilityInTree(e,i=!0){return iB?.findTestabilityInTree(this,e,i)??null}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"platform"}),n})(),xx=null,tX=new pe("AllowMultipleToken"),nX=new pe("PlatformDestroyListeners");function rB(n,t,e=[]){let i=`Platform: ${t}`,r=new pe(i);return(o=[])=>{let s=iX();if(!s||s.injector.get(tX,!1)){let a=[...e,...o,{provide:r,useValue:!0}];n?n(a):function(n){if(xx&&!xx.get(tX,!1))throw new At(400,!1);xx=n;let t=n.get(rX);(function(n){let t=n.get(eB,null);t&&t.forEach(e=>e())})(n)}(function(n=[],t){return Xn.create({name:t,providers:[{provide:gT,useValue:"platform"},{provide:nX,useValue:new Set([()=>xx=null])},...n]})}(a,i))}return function(n){let t=iX();if(!t)throw new At(401,!1);return t}()}}function iX(){return xx?.get(rX)??null}var rX=(()=>{class n{constructor(e){this._injector=e,this._modules=[],this._destroyListeners=[],this._destroyed=!1}bootstrapModuleFactory(e,i){let r=function(n,t){let e;return e="noop"===n?new class{constructor(){this.hasPendingMicrotasks=!1,this.hasPendingMacrotasks=!1,this.isStable=!0,this.onUnstable=new G,this.onMicrotaskEmpty=new G,this.onStable=new G,this.onError=new G}run(t,e,i){return t.apply(e,i)}runGuarded(t,e,i){return t.apply(e,i)}runOutsideAngular(t){return t()}runTask(t,e,i,r){return t.apply(e,i)}}:("zone.js"===n?void 0:n)||new _t(t),e}(i?.ngZone,function(n){return{enableLongStackTrace:!1,shouldCoalesceEventChangeDetection:!(!n||!n.ngZoneEventCoalescing)||!1,shouldCoalesceRunChangeDetection:!(!n||!n.ngZoneRunCoalescing)||!1}}(i)),o=[{provide:_t,useValue:r}];return r.run(()=>{let s=Xn.create({providers:o,parent:this.injector,name:e.moduleType.name}),a=e.create(s),l=a.injector.get(Qs,null);if(!l)throw new At(402,!1);return r.runOutsideAngular(()=>{let c=r.onError.subscribe({next:u=>{l.handleError(u)}});a.onDestroy(()=>{N1(this._modules,a),c.unsubscribe()})}),function(n,t,e){try{let i=e();return n_(i)?i.catch(r=>{throw t.runOutsideAngular(()=>n.handleError(r)),r}):i}catch(i){throw t.runOutsideAngular(()=>n.handleError(i)),i}}(l,r,()=>{let c=a.injector.get(OT);return c.runInitializers(),c.donePromise.then(()=>(function(n){(function(n,t){null==n&&T7("Expected localeId to be defined",n,null,"!=")})(n),"string"==typeof n&&(gY=n.toLowerCase().replace(/_/g,"-"))}(a.injector.get(Wd,nT)||nT),this._moduleDoBootstrap(a),a))})})}bootstrapModule(e,i=[]){let r=oX({},i);return function(n,t,e){let i=new qL(e);return Promise.resolve(i)}(0,0,e).then(o=>this.bootstrapModuleFactory(o,r))}_moduleDoBootstrap(e){let i=e.injector.get(Iu);if(e._bootstrapComponents.length>0)e._bootstrapComponents.forEach(r=>i.bootstrap(r));else{if(!e.instance.ngDoBootstrap)throw new At(403,!1);e.instance.ngDoBootstrap(i)}this._modules.push(e)}onDestroy(e){this._destroyListeners.push(e)}get injector(){return this._injector}destroy(){if(this._destroyed)throw new At(404,!1);this._modules.slice().forEach(i=>i.destroy()),this._destroyListeners.forEach(i=>i());let e=this._injector.get(nX,null);e&&(e.forEach(i=>i()),e.clear()),this._destroyed=!0}get destroyed(){return this._destroyed}}return n.\u0275fac=function(e){return new(e||n)(j(Xn))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"platform"}),n})();function oX(n,t){return Array.isArray(t)?t.reduce(oX,n):{...n,...t}}var Iu=(()=>{class n{constructor(e,i,r){this._zone=e,this._injector=i,this._exceptionHandler=r,this._bootstrapListeners=[],this._views=[],this._runningTick=!1,this._stable=!0,this._destroyed=!1,this._destroyListeners=[],this.componentTypes=[],this.components=[],this._onMicrotaskEmptySubscription=this._zone.onMicrotaskEmpty.subscribe({next:()=>{this._zone.run(()=>{this.tick()})}});let o=new un(a=>{this._stable=this._zone.isStable&&!this._zone.hasPendingMacrotasks&&!this._zone.hasPendingMicrotasks,this._zone.runOutsideAngular(()=>{a.next(this._stable),a.complete()})}),s=new un(a=>{let l;this._zone.runOutsideAngular(()=>{l=this._zone.onStable.subscribe(()=>{_t.assertNotInAngularZone(),KL(()=>{!this._stable&&!this._zone.hasPendingMacrotasks&&!this._zone.hasPendingMicrotasks&&(this._stable=!0,a.next(!0))})})});let c=this._zone.onUnstable.subscribe(()=>{_t.assertInAngularZone(),this._stable&&(this._stable=!1,this._zone.runOutsideAngular(()=>{a.next(!1)}))});return()=>{l.unsubscribe(),c.unsubscribe()}});this.isStable=Jt(o,s.pipe(Ts()))}get destroyed(){return this._destroyed}get injector(){return this._injector}bootstrap(e,i){let s,r=e instanceof J1;if(!this._injector.get(OT).done)throw!r&&R7(e),new At(405,false);s=r?e:this._injector.get(gs).resolveComponentFactory(e),this.componentTypes.push(s.componentType);let a=function(n){return n.isBoundToModule}(s)?void 0:this._injector.get(Gp),c=s.create(Xn.NULL,[],i||s.selector,a),u=c.location.nativeElement,d=c.injector.get(nB,null);return d?.registerApplication(u),c.onDestroy(()=>{this.detachView(c.hostView),N1(this.components,c),d?.unregisterApplication(u)}),this._loadComponent(c),c}tick(){if(this._runningTick)throw new At(101,!1);try{this._runningTick=!0;for(let e of this._views)e.detectChanges()}catch(e){this._zone.runOutsideAngular(()=>this._exceptionHandler.handleError(e))}finally{this._runningTick=!1}}attachView(e){let i=e;this._views.push(i),i.attachToAppRef(this)}detachView(e){let i=e;N1(this._views,i),i.detachFromAppRef()}_loadComponent(e){this.attachView(e.hostView),this.tick(),this.components.push(e),this._injector.get(GCe,[]).concat(this._bootstrapListeners).forEach(r=>r(e))}ngOnDestroy(){if(!this._destroyed)try{this._destroyListeners.forEach(e=>e()),this._views.slice().forEach(e=>e.destroy()),this._onMicrotaskEmptySubscription.unsubscribe()}finally{this._destroyed=!0,this._views=[],this._bootstrapListeners=[],this._destroyListeners=[]}}onDestroy(e){return this._destroyListeners.push(e),()=>N1(this._destroyListeners,e)}destroy(){if(this._destroyed)throw new At(406,!1);let e=this._injector;e.destroy&&!e.destroyed&&e.destroy()}get viewCount(){return this._views.length}warnIfDestroyed(){}}return n.\u0275fac=function(e){return new(e||n)(j(_t),j(jp),j(Qs))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function N1(n,t){let e=n.indexOf(t);e>-1&&n.splice(e,1)}var sX=!0,aX=!1;function tC(){return aX=!0,sX}var nn=(()=>{class n{}return n.__NG_ELEMENT_ID__=uMe,n})();function uMe(n){return function(n,t,e){if(h3(n)&&!e){let i=qp(n.index,t);return new Qf(i,i)}return 47&n.type?new Qf(t[16],t):null}(zo(),rt(),16==(16&n))}var sT=class{constructor(){}supports(t){return wT(t)}create(t){return new $L(t)}},pMe=(n,t)=>t,$L=class{constructor(t){this.length=0,this._linkedRecords=null,this._unlinkedRecords=null,this._previousItHead=null,this._itHead=null,this._itTail=null,this._additionsHead=null,this._additionsTail=null,this._movesHead=null,this._movesTail=null,this._removalsHead=null,this._removalsTail=null,this._identityChangesHead=null,this._identityChangesTail=null,this._trackByFn=t||pMe}forEachItem(t){let e;for(e=this._itHead;null!==e;e=e._next)t(e)}forEachOperation(t){let e=this._itHead,i=this._removalsHead,r=0,o=null;for(;e||i;){let s=!i||e&&e.currentIndex<M7(i,r,o)?e:i,a=M7(s,r,o),l=s.currentIndex;if(s===i)r--,i=i._nextRemoved;else if(e=e._next,null==s.previousIndex)r++;else{o||(o=[]);let c=a-r,u=l-r;if(c!=u){for(let p=0;p<c;p++){let h=p<o.length?o[p]:o[p]=0,f=h+p;u<=f&&f<c&&(o[p]=h+1)}o[s.previousIndex]=u-c}}a!==l&&t(s,a,l)}}forEachPreviousItem(t){let e;for(e=this._previousItHead;null!==e;e=e._nextPrevious)t(e)}forEachAddedItem(t){let e;for(e=this._additionsHead;null!==e;e=e._nextAdded)t(e)}forEachMovedItem(t){let e;for(e=this._movesHead;null!==e;e=e._nextMoved)t(e)}forEachRemovedItem(t){let e;for(e=this._removalsHead;null!==e;e=e._nextRemoved)t(e)}forEachIdentityChange(t){let e;for(e=this._identityChangesHead;null!==e;e=e._nextIdentityChange)t(e)}diff(t){if(null==t&&(t=[]),!wT(t))throw new At(900,!1);return this.check(t)?this:null}onDestroy(){}check(t){this._reset();let r,o,s,e=this._itHead,i=!1;if(Array.isArray(t)){this.length=t.length;for(let a=0;a<this.length;a++)o=t[a],s=this._trackByFn(a,o),null!==e&&Object.is(e.trackById,s)?(i&&(e=this._verifyReinsertion(e,o,s,a)),Object.is(e.item,o)||this._addIdentityChange(e,o)):(e=this._mismatch(e,o,s,a),i=!0),e=e._next}else r=0,function(n,t){if(Array.isArray(n))for(let e=0;e<n.length;e++)t(n[e]);else{let i,e=n[MT()]();for(;!(i=e.next()).done;)t(i.value)}}(t,a=>{s=this._trackByFn(r,a),null!==e&&Object.is(e.trackById,s)?(i&&(e=this._verifyReinsertion(e,a,s,r)),Object.is(e.item,a)||this._addIdentityChange(e,a)):(e=this._mismatch(e,a,s,r),i=!0),e=e._next,r++}),this.length=r;return this._truncate(e),this.collection=t,this.isDirty}get isDirty(){return null!==this._additionsHead||null!==this._movesHead||null!==this._removalsHead||null!==this._identityChangesHead}_reset(){if(this.isDirty){let t;for(t=this._previousItHead=this._itHead;null!==t;t=t._next)t._nextPrevious=t._next;for(t=this._additionsHead;null!==t;t=t._nextAdded)t.previousIndex=t.currentIndex;for(this._additionsHead=this._additionsTail=null,t=this._movesHead;null!==t;t=t._nextMoved)t.previousIndex=t.currentIndex;this._movesHead=this._movesTail=null,this._removalsHead=this._removalsTail=null,this._identityChangesHead=this._identityChangesTail=null}}_mismatch(t,e,i,r){let o;return null===t?o=this._itTail:(o=t._prev,this._remove(t)),null!==(t=null===this._unlinkedRecords?null:this._unlinkedRecords.get(i,null))?(Object.is(t.item,e)||this._addIdentityChange(t,e),this._reinsertAfter(t,o,r)):null!==(t=null===this._linkedRecords?null:this._linkedRecords.get(i,r))?(Object.is(t.item,e)||this._addIdentityChange(t,e),this._moveAfter(t,o,r)):t=this._addAfter(new e3(e,i),o,r),t}_verifyReinsertion(t,e,i,r){let o=null===this._unlinkedRecords?null:this._unlinkedRecords.get(i,null);return null!==o?t=this._reinsertAfter(o,t._prev,r):t.currentIndex!=r&&(t.currentIndex=r,this._addToMoves(t,r)),t}_truncate(t){for(;null!==t;){let e=t._next;this._addToRemovals(this._unlink(t)),t=e}null!==this._unlinkedRecords&&this._unlinkedRecords.clear(),null!==this._additionsTail&&(this._additionsTail._nextAdded=null),null!==this._movesTail&&(this._movesTail._nextMoved=null),null!==this._itTail&&(this._itTail._next=null),null!==this._removalsTail&&(this._removalsTail._nextRemoved=null),null!==this._identityChangesTail&&(this._identityChangesTail._nextIdentityChange=null)}_reinsertAfter(t,e,i){null!==this._unlinkedRecords&&this._unlinkedRecords.remove(t);let r=t._prevRemoved,o=t._nextRemoved;return null===r?this._removalsHead=o:r._nextRemoved=o,null===o?this._removalsTail=r:o._prevRemoved=r,this._insertAfter(t,e,i),this._addToMoves(t,i),t}_moveAfter(t,e,i){return this._unlink(t),this._insertAfter(t,e,i),this._addToMoves(t,i),t}_addAfter(t,e,i){return this._insertAfter(t,e,i),this._additionsTail=null===this._additionsTail?this._additionsHead=t:this._additionsTail._nextAdded=t,t}_insertAfter(t,e,i){let r=null===e?this._itHead:e._next;return t._next=r,t._prev=e,null===r?this._itTail=t:r._prev=t,null===e?this._itHead=t:e._next=t,null===this._linkedRecords&&(this._linkedRecords=new aT),this._linkedRecords.put(t),t.currentIndex=i,t}_remove(t){return this._addToRemovals(this._unlink(t))}_unlink(t){null!==this._linkedRecords&&this._linkedRecords.remove(t);let e=t._prev,i=t._next;return null===e?this._itHead=i:e._next=i,null===i?this._itTail=e:i._prev=e,t}_addToMoves(t,e){return t.previousIndex===e||(this._movesTail=null===this._movesTail?this._movesHead=t:this._movesTail._nextMoved=t),t}_addToRemovals(t){return null===this._unlinkedRecords&&(this._unlinkedRecords=new aT),this._unlinkedRecords.put(t),t.currentIndex=null,t._nextRemoved=null,null===this._removalsTail?(this._removalsTail=this._removalsHead=t,t._prevRemoved=null):(t._prevRemoved=this._removalsTail,this._removalsTail=this._removalsTail._nextRemoved=t),t}_addIdentityChange(t,e){return t.item=e,this._identityChangesTail=null===this._identityChangesTail?this._identityChangesHead=t:this._identityChangesTail._nextIdentityChange=t,t}},e3=class{constructor(t,e){this.item=t,this.trackById=e,this.currentIndex=null,this.previousIndex=null,this._nextPrevious=null,this._prev=null,this._next=null,this._prevDup=null,this._nextDup=null,this._prevRemoved=null,this._nextRemoved=null,this._nextAdded=null,this._nextMoved=null,this._nextIdentityChange=null}},aT=class{constructor(){this.map=new Map}put(t){let e=t.trackById,i=this.map.get(e);i||(i=new class{constructor(){this._head=null,this._tail=null}add(t){null===this._head?(this._head=this._tail=t,t._nextDup=null,t._prevDup=null):(this._tail._nextDup=t,t._prevDup=this._tail,t._nextDup=null,this._tail=t)}get(t,e){let i;for(i=this._head;null!==i;i=i._nextDup)if((null===e||e<=i.currentIndex)&&Object.is(i.trackById,t))return i;return null}remove(t){let e=t._prevDup,i=t._nextDup;return null===e?this._head=i:e._nextDup=i,null===i?this._tail=e:i._prevDup=e,null===this._head}},this.map.set(e,i)),i.add(t)}get(t,e){let r=this.map.get(t);return r?r.get(t,e):null}remove(t){let e=t.trackById;return this.map.get(e).remove(t)&&this.map.delete(e),t}get isEmpty(){return 0===this.map.size}clear(){this.map.clear()}};function M7(n,t,e){let i=n.previousIndex;if(null===i)return i;let r=0;return e&&i<e.length&&(r=e[i]),i+t+r}var lT=class{constructor(){}supports(t){return t instanceof Map||Y3(t)}create(){return new n3}},n3=class{constructor(){this._records=new Map,this._mapHead=null,this._appendAfter=null,this._previousMapHead=null,this._changesHead=null,this._changesTail=null,this._additionsHead=null,this._additionsTail=null,this._removalsHead=null,this._removalsTail=null}get isDirty(){return null!==this._additionsHead||null!==this._changesHead||null!==this._removalsHead}forEachItem(t){let e;for(e=this._mapHead;null!==e;e=e._next)t(e)}forEachPreviousItem(t){let e;for(e=this._previousMapHead;null!==e;e=e._nextPrevious)t(e)}forEachChangedItem(t){let e;for(e=this._changesHead;null!==e;e=e._nextChanged)t(e)}forEachAddedItem(t){let e;for(e=this._additionsHead;null!==e;e=e._nextAdded)t(e)}forEachRemovedItem(t){let e;for(e=this._removalsHead;null!==e;e=e._nextRemoved)t(e)}diff(t){if(t){if(!(t instanceof Map||Y3(t)))throw new At(900,!1)}else t=new Map;return this.check(t)?this:null}onDestroy(){}check(t){this._reset();let e=this._mapHead;if(this._appendAfter=null,this._forEach(t,(i,r)=>{if(e&&e.key===r)this._maybeAddToChanges(e,i),this._appendAfter=e,e=e._next;else{let o=this._getOrCreateRecordForKey(r,i);e=this._insertBeforeOrAppend(e,o)}}),e){e._prev&&(e._prev._next=null),this._removalsHead=e;for(let i=e;null!==i;i=i._nextRemoved)i===this._mapHead&&(this._mapHead=null),this._records.delete(i.key),i._nextRemoved=i._next,i.previousValue=i.currentValue,i.currentValue=null,i._prev=null,i._next=null}return this._changesTail&&(this._changesTail._nextChanged=null),this._additionsTail&&(this._additionsTail._nextAdded=null),this.isDirty}_insertBeforeOrAppend(t,e){if(t){let i=t._prev;return e._next=t,e._prev=i,t._prev=e,i&&(i._next=e),t===this._mapHead&&(this._mapHead=e),this._appendAfter=t,t}return this._appendAfter?(this._appendAfter._next=e,e._prev=this._appendAfter):this._mapHead=e,this._appendAfter=e,null}_getOrCreateRecordForKey(t,e){if(this._records.has(t)){let r=this._records.get(t);this._maybeAddToChanges(r,e);let o=r._prev,s=r._next;return o&&(o._next=s),s&&(s._prev=o),r._next=null,r._prev=null,r}let i=new i3(t);return this._records.set(t,i),i.currentValue=e,this._addToAdditions(i),i}_reset(){if(this.isDirty){let t;for(this._previousMapHead=this._mapHead,t=this._previousMapHead;null!==t;t=t._next)t._nextPrevious=t._next;for(t=this._changesHead;null!==t;t=t._nextChanged)t.previousValue=t.currentValue;for(t=this._additionsHead;null!=t;t=t._nextAdded)t.previousValue=t.currentValue;this._changesHead=this._changesTail=null,this._additionsHead=this._additionsTail=null,this._removalsHead=null}}_maybeAddToChanges(t,e){Object.is(e,t.currentValue)||(t.previousValue=t.currentValue,t.currentValue=e,this._addToChanges(t))}_addToAdditions(t){null===this._additionsHead?this._additionsHead=this._additionsTail=t:(this._additionsTail._nextAdded=t,this._additionsTail=t)}_addToChanges(t){null===this._changesHead?this._changesHead=this._changesTail=t:(this._changesTail._nextChanged=t,this._changesTail=t)}_forEach(t,e){t instanceof Map?t.forEach(e):Object.keys(t).forEach(i=>e(t[i],i))}},i3=class{constructor(t){this.key=t,this.previousValue=null,this.currentValue=null,this._nextPrevious=null,this._next=null,this._prev=null,this._nextAdded=null,this._nextRemoved=null,this._nextChanged=null}};function w7(){return new kc([new sT])}var kc=(()=>{class n{constructor(e){this.factories=e}static create(e,i){if(null!=i){let r=i.factories.slice();e=e.concat(r)}return new n(e)}static extend(e){return{provide:n,useFactory:i=>n.create(e,i||w7()),deps:[[n,new tl,new ns]]}}find(e){let i=this.factories.find(r=>r.supports(e));if(null!=i)return i;throw new At(901,!1)}}return n.\u0275prov=ye({token:n,providedIn:"root",factory:w7}),n})();function S7(){return new nC([new lT])}var nC=(()=>{class n{constructor(e){this.factories=e}static create(e,i){if(i){let r=i.factories.slice();e=e.concat(r)}return new n(e)}static extend(e){return{provide:n,useFactory:i=>n.create(e,i||S7()),deps:[[n,new tl,new ns]]}}find(e){let i=this.factories.find(r=>r.supports(e));if(i)return i;throw new At(901,!1)}}return n.\u0275prov=ye({token:n,providedIn:"root",factory:S7}),n})(),hMe=[new lT],fMe=[new sT],cX=(new kc(fMe),new nC(hMe),rB(null,"core",[])),uX=(()=>{class n{constructor(e){}}return n.\u0275fac=function(e){return new(e||n)(j(Iu))},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})();function NT(n){return"boolean"==typeof n?n:null!=n&&"false"!==n}var Wl=(()=>{return(n=Wl||(Wl={}))[n.RAW_TEXT=0]="RAW_TEXT",n[n.ESCAPABLE_RAW_TEXT=1]="ESCAPABLE_RAW_TEXT",n[n.PARSABLE_DATA=2]="PARSABLE_DATA",Wl;var n})();function Kd(n){if(":"!=n[0])return[null,n];let t=n.indexOf(":",1);if(-1===t)throw new Error(`Unsupported format "${n}" expecting ":namespace:name"`);return[n.slice(1,t),n.slice(t+1)]}function CB(n){return"ng-container"===Kd(n)[1]}function MB(n){return"ng-content"===Kd(n)[1]}function dX(n){return null===n?null:Kd(n)[0]}function wB(n,t){return n?`:${n}:${t}`:t}var pX,LT,ei=class{constructor({closedByChildren:t,implicitNamespacePrefix:e,contentType:i=Wl.PARSABLE_DATA,closedByParent:r=!1,isVoid:o=!1,ignoreFirstLf:s=!1,preventNamespaceInheritance:a=!1}={}){this.closedByChildren={},this.closedByParent=!1,this.canSelfClose=!1,t&&t.length>0&&t.forEach(l=>this.closedByChildren[l]=!0),this.isVoid=o,this.closedByParent=r||o,this.implicitNamespacePrefix=e||null,this.contentType=i,this.ignoreFirstLf=s,this.preventNamespaceInheritance=a}isClosedByChild(t){return this.isVoid||t.toLowerCase()in this.closedByChildren}getContentType(t){return"object"==typeof this.contentType?(void 0===t?void 0:this.contentType[t])??this.contentType.default:this.contentType}};function FV(n){return LT||(pX=new ei,LT={base:new ei({isVoid:!0}),meta:new ei({isVoid:!0}),area:new ei({isVoid:!0}),embed:new ei({isVoid:!0}),link:new ei({isVoid:!0}),img:new ei({isVoid:!0}),input:new ei({isVoid:!0}),param:new ei({isVoid:!0}),hr:new ei({isVoid:!0}),br:new ei({isVoid:!0}),source:new ei({isVoid:!0}),track:new ei({isVoid:!0}),wbr:new ei({isVoid:!0}),p:new ei({closedByChildren:["address","article","aside","blockquote","div","dl","fieldset","footer","form","h1","h2","h3","h4","h5","h6","header","hgroup","hr","main","nav","ol","p","pre","section","table","ul"],closedByParent:!0}),thead:new ei({closedByChildren:["tbody","tfoot"]}),tbody:new ei({closedByChildren:["tbody","tfoot"],closedByParent:!0}),tfoot:new ei({closedByChildren:["tbody"],closedByParent:!0}),tr:new ei({closedByChildren:["tr"],closedByParent:!0}),td:new ei({closedByChildren:["td","th"],closedByParent:!0}),th:new ei({closedByChildren:["td","th"],closedByParent:!0}),col:new ei({isVoid:!0}),svg:new ei({implicitNamespacePrefix:"svg"}),foreignObject:new ei({implicitNamespacePrefix:"svg",preventNamespaceInheritance:!0}),math:new ei({implicitNamespacePrefix:"math"}),li:new ei({closedByChildren:["li"],closedByParent:!0}),dt:new ei({closedByChildren:["dt","dd"]}),dd:new ei({closedByChildren:["dt","dd"],closedByParent:!0}),rb:new ei({closedByChildren:["rb","rt","rtc","rp"],closedByParent:!0}),rt:new ei({closedByChildren:["rb","rt","rtc","rp"],closedByParent:!0}),rtc:new ei({closedByChildren:["rb","rtc","rp"],closedByParent:!0}),rp:new ei({closedByChildren:["rb","rt","rtc","rp"],closedByParent:!0}),optgroup:new ei({closedByChildren:["optgroup"],closedByParent:!0}),option:new ei({closedByChildren:["option","optgroup"],closedByParent:!0}),pre:new ei({ignoreFirstLf:!0}),listing:new ei({ignoreFirstLf:!0}),style:new ei({contentType:Wl.RAW_TEXT}),script:new ei({contentType:Wl.RAW_TEXT}),title:new ei({contentType:{default:Wl.ESCAPABLE_RAW_TEXT,svg:Wl.PARSABLE_DATA}}),textarea:new ei({contentType:Wl.ESCAPABLE_RAW_TEXT,ignoreFirstLf:!0})}),LT[n]??LT[n.toLowerCase()]??pX}var hX=new RegExp("(\\:not\\()|(([\\.\\#]?)[-\\w]+)|(?:\\[([-.\\w*\\\\$]+)(?:=([\"']?)([^\\]\"']*)\\5)?\\])|(\\))|(\\s*,\\s*)","g"),Zd=class{constructor(){this.element=null,this.classNames=[],this.attrs=[],this.notSelectors=[]}static parse(t){let o,e=[],i=(l,c)=>{c.notSelectors.length>0&&!c.element&&0==c.classNames.length&&0==c.attrs.length&&(c.element="*"),l.push(c)},r=new Zd,s=r,a=!1;for(hX.lastIndex=0;o=hX.exec(t);){if(o[1]){if(a)throw new Error("Nesting :not in a selector is not allowed");a=!0,s=new Zd,r.notSelectors.push(s)}let l=o[2];if(l){let u=o[3];"#"===u?s.addAttribute("id",l.slice(1)):"."===u?s.addClassName(l.slice(1)):s.setElement(l)}let c=o[4];if(c&&s.addAttribute(s.unescapeAttribute(c),o[6]),o[7]&&(a=!1,s=r),o[8]){if(a)throw new Error("Multiple selectors in :not are not supported");i(e,r),r=s=new Zd}}return i(e,r),e}unescapeAttribute(t){let e="",i=!1;for(let r=0;r<t.length;r++){let o=t.charAt(r);if("\\"!==o){if("$"===o&&!i)throw new Error(`Error in attribute selector "${t}". Unescaped "$" is not supported. Please escape with "\\$".`);i=!1,e+=o}else i=!0}return e}escapeAttribute(t){return t.replace(/\\/g,"\\\\").replace(/\$/g,"\\$")}isElementSelector(){return this.hasElementSelector()&&0==this.classNames.length&&0==this.attrs.length&&0===this.notSelectors.length}hasElementSelector(){return!!this.element}setElement(t=null){this.element=t}getMatchingElementTemplate(){let t=this.element||"div",e=this.classNames.length>0?` class="${this.classNames.join(" ")}"`:"",i="";for(let r=0;r<this.attrs.length;r+=2)i+=` ${this.attrs[r]}${""!==this.attrs[r+1]?`="${this.attrs[r+1]}"`:""}`;return FV(t).isVoid?`<${t}${e}${i}/>`:`<${t}${e}${i}></${t}>`}getAttrs(){let t=[];return this.classNames.length>0&&t.push("class",this.classNames.join(" ")),t.concat(this.attrs)}addAttribute(t,e=""){this.attrs.push(t,e&&e.toLowerCase()||"")}addClassName(t){this.classNames.push(t.toLowerCase())}toString(){let t=this.element||"";if(this.classNames&&this.classNames.forEach(e=>t+=`.${e}`),this.attrs)for(let e=0;e<this.attrs.length;e+=2){let i=this.escapeAttribute(this.attrs[e]),r=this.attrs[e+1];t+=`[${i}${r?"="+r:""}]`}return this.notSelectors.forEach(e=>t+=`:not(${e})`),t}},qd=(()=>{return(n=qd||(qd={}))[n.Emulated=0]="Emulated",n[n.None=2]="None",n[n.ShadowDom=3]="ShadowDom",qd;var n})(),cC=(()=>{return(n=cC||(cC={}))[n.OnPush=0]="OnPush",n[n.Default=1]="Default",cC;var n})(),io=(()=>{return(n=io||(io={}))[n.NONE=0]="NONE",n[n.HTML=1]="HTML",n[n.STYLE=2]="STYLE",n[n.SCRIPT=3]="SCRIPT",n[n.URL=4]="URL",n[n.RESOURCE_URL=5]="RESOURCE_URL",io;var n})();function vMe(n){let t=function(n){let t=n.classNames&&n.classNames.length?[8,...n.classNames]:[];return[n.element&&"*"!==n.element?n.element:"",...n.attrs,...t]}(n),e=n.notSelectors&&n.notSelectors.length?n.notSelectors.map(i=>function(n){let t=n.classNames&&n.classNames.length?[8,...n.classNames]:[];return n.element?[5,n.element,...n.attrs,...t]:n.attrs.length?[3,...n.attrs,...t]:n.classNames&&n.classNames.length?[9,...n.classNames]:[]}(i)):[];return t.concat(...e)}function NV(n){return n?Zd.parse(n).map(vMe):[]}var yMe=/-+([a-z0-9])/g;function OQ(n,t,e){let i=n.indexOf(t);return-1==i?e:[n.slice(0,i).trim(),n.slice(i+1).trim()]}function QT(n){throw new Error(`Internal Error: ${n}`)}function LV(n){let t=[];for(let e=0;e<n.length;e++){let i=n.charCodeAt(e);if(i>=55296&&i<=56319&&n.length>e+1){let r=n.charCodeAt(e+1);r>=56320&&r<=57343&&(e++,i=(i-55296<<10)+r-56320+65536)}i<=127?t.push(i):i<=2047?t.push(i>>6&31|192,63&i|128):i<=65535?t.push(i>>12|224,i>>6&63|128,63&i|128):i<=2097151&&t.push(i>>18&7|240,i>>12&63|128,i>>6&63|128,63&i|128)}return t}function kQ(n){if("string"==typeof n)return n;if(Array.isArray(n))return"["+n.map(kQ).join(", ")+"]";if(null==n)return""+n;if(n.overriddenName)return`${n.overriddenName}`;if(n.name)return`${n.name}`;if(!n.toString)return"object";let t=n.toString();if(null==t)return""+t;let e=t.indexOf("\n");return-1===e?t:t.substring(0,e)}var p_=(()=>typeof global<"u"&&global||typeof window<"u"&&window||typeof self<"u"&&typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope&&self)(),nh=class{constructor(t){this.digits=t}static zero(){return new nh([0])}static one(){return new nh([1])}clone(){return new nh(this.digits.slice())}add(t){let e=this.clone();return e.addToSelf(t),e}addToSelf(t){let e=Math.max(this.digits.length,t.digits.length),i=0;for(let r=0;r<e;r++){let o=i;r<this.digits.length&&(o+=this.digits[r]),r<t.digits.length&&(o+=t.digits[r]),o>=10?(this.digits[r]=o-10,i=1):(this.digits[r]=o,i=0)}i>0&&(this.digits[e]=1)}toString(){let t="";for(let e=this.digits.length-1;e>=0;e--)t+=this.digits[e];return t}},KT=class{constructor(t){this.powerOfTwos=[t]}getValue(){return this.powerOfTwos[0]}multiplyBy(t){let e=nh.zero();return this.multiplyByAndAddTo(t,e),e}multiplyByAndAddTo(t,e){for(let i=0;0!==t;t>>>=1,i++)if(1&t){let r=this.getMultipliedByPowerOfTwo(i);e.addToSelf(r)}}getMultipliedByPowerOfTwo(t){for(let e=this.powerOfTwos.length;e<=t;e++){let i=this.powerOfTwos[e-1];this.powerOfTwos[e]=i.add(i)}return this.powerOfTwos[t]}};function SMe(n){return function(n){let t=LV(n),e=function(n,t){let e=n.length+3>>>2,i=[];for(let r=0;r<e;r++)i[r]=em(n,4*r,t);return i}(t,Fc.Big),i=8*t.length,r=function(n,t){let e=[];for(let i=0;i<80;i++)e.push(undefined);return e}(),o=1732584193,s=4023233417,a=2562383102,l=271733878,c=3285377520;e[i>>5]|=128<<24-i%32,e[15+(i+64>>9<<4)]=i;for(let u=0;u<e.length;u+=16){let d=o,p=s,h=a,f=l,m=c;for(let x=0;x<80;x++){r[x]=x<16?e[u+x]:oB(r[x-3]^r[x-8]^r[x-14]^r[x-16],1);let g=IMe(x,s,a,l),b=g[0],D=g[1],T=[oB(o,5),b,c,D,r[x]].reduce(ea);c=l,l=a,a=oB(s,30),s=o,o=T}o=ea(o,d),s=ea(s,p),a=ea(a,h),l=ea(l,f),c=ea(c,m)}return function(n){let t="";for(let e=0;e<n.length;e++){let i=DB(n,e);t+=(i>>>4).toString(16)+(15&i).toString(16)}return t.toLowerCase()}(function(n){return n.reduce((t,e)=>t.concat(function(n){let t=[];for(let e=0;e<4;e++)t.push(n>>>8*(3-e)&255);return t}(e)),[])}([o,s,a,l,c]))}(function(n){return n.map(t=>t.visit(TMe,null))}(n.nodes).join("")+`[${n.meaning}]`)}function FQ(n){let t=new TB;return AD(n.nodes.map(i=>i.visit(t,null)).join(""),n.meaning)}var ZT=class{visitText(t,e){return t.value}visitContainer(t,e){return`[${t.children.map(i=>i.visit(this)).join(", ")}]`}visitIcu(t,e){let i=Object.keys(t.cases).map(r=>`${r} {${t.cases[r].visit(this)}}`);return`{${t.expression}, ${t.type}, ${i.join(", ")}}`}visitTagPlaceholder(t,e){return t.isVoid?`<ph tag name="${t.startName}"/>`:`<ph tag name="${t.startName}">${t.children.map(i=>i.visit(this)).join(", ")}</ph name="${t.closeName}">`}visitPlaceholder(t,e){return t.value?`<ph name="${t.name}">${t.value}</ph>`:`<ph name="${t.name}"/>`}visitIcuPlaceholder(t,e){return`<ph icu name="${t.name}">${t.value.visit(this)}</ph>`}},TMe=new ZT,TB=class extends ZT{visitIcu(t,e){let i=Object.keys(t.cases).map(r=>`${r} {${t.cases[r].visit(this)}}`);return`{${t.type}, ${i.join(", ")}}`}};function IMe(n,t,e,i){return n<20?[t&e|~t&i,1518500249]:n<40?[t^e^i,1859775393]:n<60?[t&e|t&i|e&i,2400959708]:[t^e^i,3395469782]}function gX(n){let t=LV(n),e=_X(t,0),i=_X(t,102072);return 0==e&&(0==i||1==i)&&(e^=319790063,i^=-1801410264),[e,i]}function AD(n,t=""){let e=gX(n);if(t){let o=gX(t);e=function(n,t){let e=n[0],r=t[0],s=NQ(n[1],t[1]),a=s[0],l=s[1];return[ea(ea(e,r),a),l]}(function(n,t){let e=n[0],i=n[1];return[e<<1|i>>>31,i<<1|e>>>31]}(e),o)}return function(n,t){let e=yX.toThePowerOf(0).multiplyBy(t);return yX.toThePowerOf(4).multiplyByAndAddTo(n,e),e.toString()}(2147483647&e[0],e[1])}function _X(n,t){let r,e=2654435769,i=2654435769,o=n.length;for(r=0;r+12<=o;r+=12){e=ea(e,em(n,r,Fc.Little)),i=ea(i,em(n,r+4,Fc.Little));let s=vX(e,i,t=ea(t,em(n,r+8,Fc.Little)));e=s[0],i=s[1],t=s[2]}return e=ea(e,em(n,r,Fc.Little)),i=ea(i,em(n,r+4,Fc.Little)),t=ea(t,o),vX(e,i,t=ea(t,em(n,r+8,Fc.Little)<<8))[2]}function vX(n,t,e){return n=is(n,t),n=is(n,e),n^=e>>>13,t=is(t,e),t=is(t,n),t^=n<<8,e=is(e,n),e=is(e,t),e^=t>>>13,n=is(n,t),n=is(n,e),n^=e>>>12,t=is(t,e),t=is(t,n),t^=n<<16,e=is(e,n),e=is(e,t),e^=t>>>5,n=is(n,t),n=is(n,e),n^=e>>>3,t=is(t,e),t=is(t,n),t^=n<<10,e=is(e,n),e=is(e,t),[n,t,e^=t>>>15]}var Fc=(()=>{return(n=Fc||(Fc={}))[n.Little=0]="Little",n[n.Big=1]="Big",Fc;var n})();function ea(n,t){return NQ(n,t)[1]}function NQ(n,t){let e=(65535&n)+(65535&t),i=(n>>>16)+(t>>>16)+(e>>>16);return[i>>>16,i<<16|65535&e]}function is(n,t){let e=(65535&n)-(65535&t);return(n>>16)-(t>>16)+(e>>16)<<16|65535&e}function oB(n,t){return n<<t|n>>>32-t}function DB(n,t){return t>=n.length?0:n[t]}function em(n,t,e){let i=0;if(e===Fc.Big)for(let r=0;r<4;r++)i+=DB(n,t+r)<<24-8*r;else for(let r=0;r<4;r++)i+=DB(n,t+r)<<8*r;return i}var yX=new class{constructor(t){this.base=t,this.exponents=[new KT(nh.one())]}toThePowerOf(t){for(let e=this.exponents.length;e<=t;e++){let i=this.exponents[e-1].multiplyBy(this.base);this.exponents[e]=new KT(i)}return this.exponents[t]}}(256),jT=(()=>{return(n=jT||(jT={}))[n.None=0]="None",n[n.Const=1]="Const",jT;var n})(),JT=class{constructor(t=jT.None){this.modifiers=t}hasModifier(t){return 0!=(this.modifiers&t)}},Bc=(()=>{return(n=Bc||(Bc={}))[n.Dynamic=0]="Dynamic",n[n.Bool=1]="Bool",n[n.String=2]="String",n[n.Int=3]="Int",n[n.Number=4]="Number",n[n.Function=5]="Function",n[n.Inferred=6]="Inferred",n[n.None=7]="None",Bc;var n})(),Bu=class extends JT{constructor(t,e){super(e),this.name=t}visitType(t,e){return t.visitBuiltinType(this,e)}},Vc=class extends JT{constructor(t,e,i=null){super(e),this.value=t,this.typeParams=i}visitType(t,e){return t.visitExpressionType(this,e)}},V_=new Bu(Bc.Dynamic),Pa=new Bu(Bc.Inferred),BMe=new Bu(Bc.Bool),ZC=(new Bu(Bc.Int),new Bu(Bc.Number)),LQ=new Bu(Bc.String),Jd=(new Bu(Bc.Function),new Bu(Bc.None)),am=(()=>{return(n=am||(am={}))[n.Minus=0]="Minus",n[n.Plus=1]="Plus",am;var n})(),Cn=(()=>{return(n=Cn||(Cn={}))[n.Equals=0]="Equals",n[n.NotEquals=1]="NotEquals",n[n.Identical=2]="Identical",n[n.NotIdentical=3]="NotIdentical",n[n.Minus=4]="Minus",n[n.Plus=5]="Plus",n[n.Divide=6]="Divide",n[n.Multiply=7]="Multiply",n[n.Modulo=8]="Modulo",n[n.And=9]="And",n[n.Or=10]="Or",n[n.BitwiseAnd=11]="BitwiseAnd",n[n.Lower=12]="Lower",n[n.LowerEquals=13]="LowerEquals",n[n.Bigger=14]="Bigger",n[n.BiggerEquals=15]="BiggerEquals",n[n.NullishCoalesce=16]="NullishCoalesce",Cn;var n})();function BQ(n,t,e){let i=n.length;if(i!==t.length)return!1;for(let r=0;r<i;r++)if(!e(n[r],t[r]))return!1;return!0}function Uc(n,t){return BQ(n,t,(e,i)=>e.isEquivalent(i))}var Or=class{constructor(t,e){this.type=t||null,this.sourceSpan=e||null}prop(t,e){return new b_(this,t,null,e)}key(t,e,i){return new MC(this,t,e,i)}callFn(t,e,i){return new oh(this,t,null,e,i)}instantiate(t,e,i){return new dm(this,t,e,i)}conditional(t,e=null,i){return new bC(this,t,e,null,i)}equals(t,e){return new gr(Cn.Equals,this,t,null,e)}notEquals(t,e){return new gr(Cn.NotEquals,this,t,null,e)}identical(t,e){return new gr(Cn.Identical,this,t,null,e)}notIdentical(t,e){return new gr(Cn.NotIdentical,this,t,null,e)}minus(t,e){return new gr(Cn.Minus,this,t,null,e)}plus(t,e){return new gr(Cn.Plus,this,t,null,e)}divide(t,e){return new gr(Cn.Divide,this,t,null,e)}multiply(t,e){return new gr(Cn.Multiply,this,t,null,e)}modulo(t,e){return new gr(Cn.Modulo,this,t,null,e)}and(t,e){return new gr(Cn.And,this,t,null,e)}bitwiseAnd(t,e,i=!0){return new gr(Cn.BitwiseAnd,this,t,null,e,i)}or(t,e){return new gr(Cn.Or,this,t,null,e)}lower(t,e){return new gr(Cn.Lower,this,t,null,e)}lowerEquals(t,e){return new gr(Cn.LowerEquals,this,t,null,e)}bigger(t,e){return new gr(Cn.Bigger,this,t,null,e)}biggerEquals(t,e){return new gr(Cn.BiggerEquals,this,t,null,e)}isBlank(t){return this.equals(WT,t)}nullishCoalesce(t,e){return new gr(Cn.NullishCoalesce,this,t,null,e)}toStmt(){return new Hu(this,null)}},um=class extends Or{constructor(t,e,i){super(e,i),this.name=t}isEquivalent(t){return t instanceof um&&this.name===t.name}isConstant(){return!1}visitExpression(t,e){return t.visitReadVarExpr(this,e)}set(t){return new gC(this.name,t,null,this.sourceSpan)}},v_=class extends Or{constructor(t,e,i){super(e,i),this.expr=t}visitExpression(t,e){return t.visitTypeofExpr(this,e)}isEquivalent(t){return t instanceof v_&&t.expr.isEquivalent(this.expr)}isConstant(){return this.expr.isConstant()}},Ln=class extends Or{constructor(t,e,i){super(e,i),this.node=t}isEquivalent(t){return t instanceof Ln&&this.node===t.node}isConstant(){return!1}visitExpression(t,e){return t.visitWrappedNodeExpr(this,e)}},gC=class extends Or{constructor(t,e,i,r){super(i||e.type,r),this.name=t,this.value=e}isEquivalent(t){return t instanceof gC&&this.name===t.name&&this.value.isEquivalent(t.value)}isConstant(){return!1}visitExpression(t,e){return t.visitWriteVarExpr(this,e)}toDeclStmt(t,e){return new Vu(this.name,this.value,t,e,this.sourceSpan)}toConstDecl(){return this.toDeclStmt(Pa,ll.Final)}},_C=class extends Or{constructor(t,e,i,r,o){super(r||i.type,o),this.receiver=t,this.index=e,this.value=i}isEquivalent(t){return t instanceof _C&&this.receiver.isEquivalent(t.receiver)&&this.index.isEquivalent(t.index)&&this.value.isEquivalent(t.value)}isConstant(){return!1}visitExpression(t,e){return t.visitWriteKeyExpr(this,e)}},vC=class extends Or{constructor(t,e,i,r,o){super(r||i.type,o),this.receiver=t,this.name=e,this.value=i}isEquivalent(t){return t instanceof vC&&this.receiver.isEquivalent(t.receiver)&&this.name===t.name&&this.value.isEquivalent(t.value)}isConstant(){return!1}visitExpression(t,e){return t.visitWritePropExpr(this,e)}},oh=class extends Or{constructor(t,e,i,r,o=!1){super(i,r),this.fn=t,this.args=e,this.pure=o}isEquivalent(t){return t instanceof oh&&this.fn.isEquivalent(t.fn)&&Uc(this.args,t.args)&&this.pure===t.pure}isConstant(){return!1}visitExpression(t,e){return t.visitInvokeFunctionExpr(this,e)}},yC=class extends Or{constructor(t,e,i,r){super(i,r),this.tag=t,this.template=e}isEquivalent(t){return t instanceof yC&&this.tag.isEquivalent(t.tag)&&BQ(this.template.elements,t.template.elements,(e,i)=>e.text===i.text)&&Uc(this.template.expressions,t.template.expressions)}isConstant(){return!1}visitExpression(t,e){return t.visitTaggedTemplateExpr(this,e)}},dm=class extends Or{constructor(t,e,i,r){super(i,r),this.classExpr=t,this.args=e}isEquivalent(t){return t instanceof dm&&this.classExpr.isEquivalent(t.classExpr)&&Uc(this.args,t.args)}isConstant(){return!1}visitExpression(t,e){return t.visitInstantiateExpr(this,e)}},cl=class extends Or{constructor(t,e,i){super(e,i),this.value=t}isEquivalent(t){return t instanceof cl&&this.value===t.value}isConstant(){return!0}visitExpression(t,e){return t.visitLiteralExpr(this,e)}},$T=class{constructor(t,e){this.elements=t,this.expressions=e}},eD=class{constructor(t,e,i){this.text=t,this.sourceSpan=e,this.rawText=i??e?.toString()??IB(GT(t))}},lm=class{constructor(t,e){this.text=t,this.sourceSpan=e}},h_=class{constructor(t,e,i){this.text=t,this.sourceSpan=e,this.associatedMessage=i}},AB=class extends Or{constructor(t,e,i,r,o){super(LQ,o),this.metaBlock=t,this.messageParts=e,this.placeHolderNames=i,this.expressions=r}isEquivalent(t){return!1}isConstant(){return!1}visitExpression(t,e){return t.visitLocalizedString(this,e)}serializeI18nHead(){let t=this.metaBlock.description||"";return this.metaBlock.meaning&&(t=`${this.metaBlock.meaning}|${t}`),this.metaBlock.customId&&(t=`${t}@@${this.metaBlock.customId}`),this.metaBlock.legacyIds&&this.metaBlock.legacyIds.forEach(e=>{t=`${t}\u241f${e}`}),xX(t,this.messageParts[0].text,this.getMessagePartSourceSpan(0))}getMessagePartSourceSpan(t){return this.messageParts[t]?.sourceSpan??this.sourceSpan}getPlaceholderSourceSpan(t){return this.placeHolderNames[t]?.sourceSpan??this.expressions[t]?.sourceSpan??this.sourceSpan}serializeI18nTemplatePart(t){let e=this.placeHolderNames[t-1],i=this.messageParts[t],r=e.text;return 0===e.associatedMessage?.legacyIds.length&&(r+=`@@${AD(e.associatedMessage.messageString,e.associatedMessage.meaning)}`),xX(r,i.text,this.getMessagePartSourceSpan(t))}},GT=n=>n.replace(/\\/g,"\\\\"),zMe=n=>n.replace(/^:/,"\\:"),jMe=n=>n.replace(/:/g,"\\:"),IB=n=>n.replace(/`/g,"\\`").replace(/\${/g,"$\\{");function xX(n,t,e){return""===n?{cooked:t,raw:IB(zMe(GT(t))),range:e}:{cooked:`:${n}:${t}`,raw:IB(`:${jMe(GT(n))}:${GT(t)}`),range:e}}var y_=class extends Or{constructor(t,e,i=null,r){super(e,r),this.value=t,this.typeParams=i}isEquivalent(t){return t instanceof y_&&this.value.name===t.value.name&&this.value.moduleName===t.value.moduleName&&this.value.runtime===t.value.runtime}isConstant(){return!1}visitExpression(t,e){return t.visitExternalExpr(this,e)}},bC=class extends Or{constructor(t,e,i=null,r,o){super(r||e.type,o),this.condition=t,this.falseCase=i,this.trueCase=e}isEquivalent(t){return t instanceof bC&&this.condition.isEquivalent(t.condition)&&this.trueCase.isEquivalent(t.trueCase)&&function(n,t){return null==n||null==t?n==t:n.isEquivalent(t)}(this.falseCase,t.falseCase)}isConstant(){return!1}visitExpression(t,e){return t.visitConditionalExpr(this,e)}},xC=class extends Or{constructor(t,e){super(BMe,e),this.condition=t}isEquivalent(t){return t instanceof xC&&this.condition.isEquivalent(t.condition)}isConstant(){return!1}visitExpression(t,e){return t.visitNotExpr(this,e)}},ia=class{constructor(t,e=null){this.name=t,this.type=e}isEquivalent(t){return this.name===t.name}},pm=class extends Or{constructor(t,e,i,r,o){super(i,r),this.params=t,this.statements=e,this.name=o}isEquivalent(t){return t instanceof pm&&Uc(this.params,t.params)&&Uc(this.statements,t.statements)}isConstant(){return!1}visitExpression(t,e){return t.visitFunctionExpr(this,e)}toDeclStmt(t,e){return new wC(t,this.params,this.statements,this.type,e,this.sourceSpan)}},CC=class extends Or{constructor(t,e,i,r,o=!0){super(i||ZC,r),this.operator=t,this.expr=e,this.parens=o}isEquivalent(t){return t instanceof CC&&this.operator===t.operator&&this.expr.isEquivalent(t.expr)}isConstant(){return!1}visitExpression(t,e){return t.visitUnaryOperatorExpr(this,e)}},gr=class extends Or{constructor(t,e,i,r,o,s=!0){super(r||e.type,o),this.operator=t,this.rhs=i,this.parens=s,this.lhs=e}isEquivalent(t){return t instanceof gr&&this.operator===t.operator&&this.lhs.isEquivalent(t.lhs)&&this.rhs.isEquivalent(t.rhs)}isConstant(){return!1}visitExpression(t,e){return t.visitBinaryOperatorExpr(this,e)}},b_=class extends Or{constructor(t,e,i,r){super(i,r),this.receiver=t,this.name=e}isEquivalent(t){return t instanceof b_&&this.receiver.isEquivalent(t.receiver)&&this.name===t.name}isConstant(){return!1}visitExpression(t,e){return t.visitReadPropExpr(this,e)}set(t){return new vC(this.receiver,this.name,t,null,this.sourceSpan)}},MC=class extends Or{constructor(t,e,i,r){super(i,r),this.receiver=t,this.index=e}isEquivalent(t){return t instanceof MC&&this.receiver.isEquivalent(t.receiver)&&this.index.isEquivalent(t.index)}isConstant(){return!1}visitExpression(t,e){return t.visitReadKeyExpr(this,e)}set(t){return new _C(this.receiver,this.index,t,null,this.sourceSpan)}},hm=class extends Or{constructor(t,e,i){super(e,i),this.entries=t}isConstant(){return this.entries.every(t=>t.isConstant())}isEquivalent(t){return t instanceof hm&&Uc(this.entries,t.entries)}visitExpression(t,e){return t.visitLiteralArrayExpr(this,e)}},tD=class{constructor(t,e,i){this.key=t,this.value=e,this.quoted=i}isEquivalent(t){return this.key===t.key&&this.value.isEquivalent(t.value)}},x_=class extends Or{constructor(t,e,i){super(e,i),this.entries=t,this.valueType=null,e&&(this.valueType=e.valueType)}isEquivalent(t){return t instanceof x_&&Uc(this.entries,t.entries)}isConstant(){return this.entries.every(t=>t.value.isConstant())}visitExpression(t,e){return t.visitLiteralMapExpr(this,e)}},PB=new cl(null,null,null),WT=new cl(null,Pa,null),ll=(()=>{return(n=ll||(ll={}))[n.None=0]="None",n[n.Final=1]="Final",n[n.Private=2]="Private",n[n.Exported=4]="Exported",n[n.Static=8]="Static",ll;var n})(),RB=class{constructor(t,e,i){this.text=t,this.multiline=e,this.trailingNewline=i}toString(){return this.multiline?` ${this.text} `:this.text}},nD=class extends RB{constructor(t){super("",!0,!0),this.tags=t}toString(){return function(n){if(0===n.length)return"";if(1===n.length&&n[0].tagName&&!n[0].text)return`*${MX(n[0])} `;let t="*\n";for(let e of n)t+=" *",t+=MX(e).replace(/\n/g,"\n * "),t+="\n";return t+=" ",t}(this.tags)}},fm=class{constructor(t=ll.None,e=null,i){this.modifiers=t,this.sourceSpan=e,this.leadingComments=i}hasModifier(t){return 0!=(this.modifiers&t)}addLeadingComment(t){this.leadingComments=this.leadingComments??[],this.leadingComments.push(t)}},Vu=class extends fm{constructor(t,e,i,r,o,s){super(r,o,s),this.name=t,this.value=e,this.type=i||e&&e.type||null}isEquivalent(t){return t instanceof Vu&&this.name===t.name&&(this.value?!!t.value&&this.value.isEquivalent(t.value):!t.value)}visitStatement(t,e){return t.visitDeclareVarStmt(this,e)}},wC=class extends fm{constructor(t,e,i,r,o,s,a){super(o,s,a),this.name=t,this.params=e,this.statements=i,this.type=r||null}isEquivalent(t){return t instanceof wC&&Uc(this.params,t.params)&&Uc(this.statements,t.statements)}visitStatement(t,e){return t.visitDeclareFunctionStmt(this,e)}},Hu=class extends fm{constructor(t,e,i){super(ll.None,e,i),this.expr=t}isEquivalent(t){return t instanceof Hu&&this.expr.isEquivalent(t.expr)}visitStatement(t,e){return t.visitExpressionStmt(this,e)}},Do=class extends fm{constructor(t,e=null,i){super(ll.None,e,i),this.value=t}isEquivalent(t){return t instanceof Do&&this.value.isEquivalent(t.value)}visitStatement(t,e){return t.visitReturnStmt(this,e)}},SC=class extends fm{constructor(t,e,i=[],r,o){super(ll.None,r,o),this.condition=t,this.trueCase=e,this.falseCase=i}isEquivalent(t){return t instanceof SC&&this.condition.isEquivalent(t.condition)&&Uc(this.trueCase,t.trueCase)&&Uc(this.falseCase,t.falseCase)}visitStatement(t,e){return t.visitIfStmt(this,e)}};function Ri(n,t,e){return new um(n,t,e)}function Tn(n,t=null,e){return new y_(n,null,t,e)}function ul(n,t,e){return new Vc(n,t,e)}function BV(n){return new v_(n)}function _r(n,t,e){return new hm(n,t,e)}function ql(n,t=null){return new x_(n.map(e=>new tD(e.key,e.value,e.quoted)),t,null)}function ra(n,t,e,i,r){return new pm(n,t,e,i,r)}function VV(n,t,e,i,r){return new SC(n,t,e,i,r)}function CX(n,t,e,i){return new yC(n,t,e,i)}function ht(n,t,e){return new cl(n,t,e)}function VQ(n){return n instanceof cl&&null===n.value}function MX(n){let t="";if(n.tagName&&(t+=` @${n.tagName}`),n.text){if(n.text.match(/\/\*|\*\//))throw new Error('JSDoc text cannot contain "/*" and "*/"');t+=" "+n.text.replace(/@/g,"\\@")}return t}var wX=Ri("<unknown>"),HQ={},C_=class extends Or{constructor(t){super(t.type),this.resolved=t,this.original=t}visitExpression(t,e){return e===HQ?this.original.visitExpression(t,e):this.resolved.visitExpression(t,e)}isEquivalent(t){return t instanceof C_&&this.resolved.isEquivalent(t.resolved)}isConstant(){return!0}fixup(t){this.resolved=t,this.shared=!0}},iD=class{constructor(t=!1){this.isClosureCompilerEnabled=t,this.statements=[],this.literals=new Map,this.literalFactories=new Map,this.nextNameIndex=0}getConstLiteral(t,e){if(t instanceof cl&&!SX(t)||t instanceof C_)return t;let i=this.keyOf(t),r=this.literals.get(i),o=!1;if(r||(r=new C_(t),this.literals.set(i,r),o=!0),!o&&!r.shared||o&&e){let a,l,s=this.freshName();this.isClosureCompilerEnabled&&SX(t)?(a=Ri(s).set(new pm([],[new Do(t)])),l=Ri(s).callFn([])):(a=Ri(s).set(t),l=Ri(s)),this.statements.push(a.toDeclStmt(Pa,ll.Final)),r.fixup(l)}return r}getLiteralFactory(t){if(t instanceof hm){let e=t.entries.map(r=>r.isConstant()?r:wX),i=this.keyOf(_r(e));return this._getLiteralFactory(i,t.entries,r=>_r(r))}{let e=ql(t.entries.map(r=>({key:r.key,value:r.value.isConstant()?r.value:wX,quoted:r.quoted}))),i=this.keyOf(e);return this._getLiteralFactory(i,t.entries.map(r=>r.value),r=>ql(r.map((o,s)=>({key:t.entries[s].key,value:o,quoted:t.entries[s].quoted}))))}}_getLiteralFactory(t,e,i){let r=this.literalFactories.get(t),o=e.filter(s=>!s.isConstant());if(!r){let s=e.map((u,d)=>u.isConstant()?this.getConstLiteral(u,!0):Ri(`a${d}`)),l=ra(s.filter(KMe).map(u=>new ia(u.name,V_)),[new Do(i(s))],Pa),c=this.freshName();this.statements.push(Ri(c).set(l).toDeclStmt(Pa,ll.Final)),r=Ri(c),this.literalFactories.set(t,r)}return{literalFactory:r,literalFactoryArguments:o}}uniqueName(t){return`${t}${this.nextNameIndex++}`}freshName(){return this.uniqueName("_c")}keyOf(t){return t.visitExpression(new OB,HQ)}},OB=class{constructor(){this.visitWrappedNodeExpr=rs,this.visitWriteVarExpr=rs,this.visitWriteKeyExpr=rs,this.visitWritePropExpr=rs,this.visitInvokeFunctionExpr=rs,this.visitTaggedTemplateExpr=rs,this.visitInstantiateExpr=rs,this.visitConditionalExpr=rs,this.visitNotExpr=rs,this.visitAssertNotNullExpr=rs,this.visitCastExpr=rs,this.visitFunctionExpr=rs,this.visitUnaryOperatorExpr=rs,this.visitBinaryOperatorExpr=rs,this.visitReadPropExpr=rs,this.visitReadKeyExpr=rs,this.visitCommaExpr=rs,this.visitLocalizedString=rs}visitLiteralExpr(t){return`${"string"==typeof t.value?'"'+t.value+'"':t.value}`}visitLiteralArrayExpr(t,e){return`[${t.entries.map(i=>i.visitExpression(this,e)).join(",")}]`}visitLiteralMapExpr(t,e){return`{${t.entries.map(o=>`${(o=>{let s=o.quoted?'"':"";return`${s}${o.key}${s}`})(o)}:${o.value.visitExpression(this,e)}`).join(",")}`}visitExternalExpr(t){return t.value.moduleName?`EX:${t.value.moduleName}:${t.value.name}`:`EX:${t.value.runtime.name}`}visitReadVarExpr(t){return`VAR:${t.name}`}visitTypeofExpr(t,e){return`TYPEOF:${t.expr.visitExpression(this,e)}`}};function rs(n){throw new Error(`Invalid state: Visitor ${this.constructor.name} doesn't handle ${n.constructor.name}`)}function KMe(n){return n instanceof um}function SX(n){return n instanceof cl&&"string"==typeof n.value&&n.value.length>=50}var xe="@angular/core",te=(()=>{class n{}return n.NEW_METHOD="factory",n.TRANSFORM_METHOD="transform",n.PATCH_DEPS="patchedDeps",n.core={name:null,moduleName:xe},n.namespaceHTML={name:"\u0275\u0275namespaceHTML",moduleName:xe},n.namespaceMathML={name:"\u0275\u0275namespaceMathML",moduleName:xe},n.namespaceSVG={name:"\u0275\u0275namespaceSVG",moduleName:xe},n.element={name:"\u0275\u0275element",moduleName:xe},n.elementStart={name:"\u0275\u0275elementStart",moduleName:xe},n.elementEnd={name:"\u0275\u0275elementEnd",moduleName:xe},n.advance={name:"\u0275\u0275advance",moduleName:xe},n.syntheticHostProperty={name:"\u0275\u0275syntheticHostProperty",moduleName:xe},n.syntheticHostListener={name:"\u0275\u0275syntheticHostListener",moduleName:xe},n.attribute={name:"\u0275\u0275attribute",moduleName:xe},n.attributeInterpolate1={name:"\u0275\u0275attributeInterpolate1",moduleName:xe},n.attributeInterpolate2={name:"\u0275\u0275attributeInterpolate2",moduleName:xe},n.attributeInterpolate3={name:"\u0275\u0275attributeInterpolate3",moduleName:xe},n.attributeInterpolate4={name:"\u0275\u0275attributeInterpolate4",moduleName:xe},n.attributeInterpolate5={name:"\u0275\u0275attributeInterpolate5",moduleName:xe},n.attributeInterpolate6={name:"\u0275\u0275attributeInterpolate6",moduleName:xe},n.attributeInterpolate7={name:"\u0275\u0275attributeInterpolate7",moduleName:xe},n.attributeInterpolate8={name:"\u0275\u0275attributeInterpolate8",moduleName:xe},n.attributeInterpolateV={name:"\u0275\u0275attributeInterpolateV",moduleName:xe},n.classProp={name:"\u0275\u0275classProp",moduleName:xe},n.elementContainerStart={name:"\u0275\u0275elementContainerStart",moduleName:xe},n.elementContainerEnd={name:"\u0275\u0275elementContainerEnd",moduleName:xe},n.elementContainer={name:"\u0275\u0275elementContainer",moduleName:xe},n.styleMap={name:"\u0275\u0275styleMap",moduleName:xe},n.styleMapInterpolate1={name:"\u0275\u0275styleMapInterpolate1",moduleName:xe},n.styleMapInterpolate2={name:"\u0275\u0275styleMapInterpolate2",moduleName:xe},n.styleMapInterpolate3={name:"\u0275\u0275styleMapInterpolate3",moduleName:xe},n.styleMapInterpolate4={name:"\u0275\u0275styleMapInterpolate4",moduleName:xe},n.styleMapInterpolate5={name:"\u0275\u0275styleMapInterpolate5",moduleName:xe},n.styleMapInterpolate6={name:"\u0275\u0275styleMapInterpolate6",moduleName:xe},n.styleMapInterpolate7={name:"\u0275\u0275styleMapInterpolate7",moduleName:xe},n.styleMapInterpolate8={name:"\u0275\u0275styleMapInterpolate8",moduleName:xe},n.styleMapInterpolateV={name:"\u0275\u0275styleMapInterpolateV",moduleName:xe},n.classMap={name:"\u0275\u0275classMap",moduleName:xe},n.classMapInterpolate1={name:"\u0275\u0275classMapInterpolate1",moduleName:xe},n.classMapInterpolate2={name:"\u0275\u0275classMapInterpolate2",moduleName:xe},n.classMapInterpolate3={name:"\u0275\u0275classMapInterpolate3",moduleName:xe},n.classMapInterpolate4={name:"\u0275\u0275classMapInterpolate4",moduleName:xe},n.classMapInterpolate5={name:"\u0275\u0275classMapInterpolate5",moduleName:xe},n.classMapInterpolate6={name:"\u0275\u0275classMapInterpolate6",moduleName:xe},n.classMapInterpolate7={name:"\u0275\u0275classMapInterpolate7",moduleName:xe},n.classMapInterpolate8={name:"\u0275\u0275classMapInterpolate8",moduleName:xe},n.classMapInterpolateV={name:"\u0275\u0275classMapInterpolateV",moduleName:xe},n.styleProp={name:"\u0275\u0275styleProp",moduleName:xe},n.stylePropInterpolate1={name:"\u0275\u0275stylePropInterpolate1",moduleName:xe},n.stylePropInterpolate2={name:"\u0275\u0275stylePropInterpolate2",moduleName:xe},n.stylePropInterpolate3={name:"\u0275\u0275stylePropInterpolate3",moduleName:xe},n.stylePropInterpolate4={name:"\u0275\u0275stylePropInterpolate4",moduleName:xe},n.stylePropInterpolate5={name:"\u0275\u0275stylePropInterpolate5",moduleName:xe},n.stylePropInterpolate6={name:"\u0275\u0275stylePropInterpolate6",moduleName:xe},n.stylePropInterpolate7={name:"\u0275\u0275stylePropInterpolate7",moduleName:xe},n.stylePropInterpolate8={name:"\u0275\u0275stylePropInterpolate8",moduleName:xe},n.stylePropInterpolateV={name:"\u0275\u0275stylePropInterpolateV",moduleName:xe},n.nextContext={name:"\u0275\u0275nextContext",moduleName:xe},n.resetView={name:"\u0275\u0275resetView",moduleName:xe},n.templateCreate={name:"\u0275\u0275template",moduleName:xe},n.text={name:"\u0275\u0275text",moduleName:xe},n.enableBindings={name:"\u0275\u0275enableBindings",moduleName:xe},n.disableBindings={name:"\u0275\u0275disableBindings",moduleName:xe},n.getCurrentView={name:"\u0275\u0275getCurrentView",moduleName:xe},n.textInterpolate={name:"\u0275\u0275textInterpolate",moduleName:xe},n.textInterpolate1={name:"\u0275\u0275textInterpolate1",moduleName:xe},n.textInterpolate2={name:"\u0275\u0275textInterpolate2",moduleName:xe},n.textInterpolate3={name:"\u0275\u0275textInterpolate3",moduleName:xe},n.textInterpolate4={name:"\u0275\u0275textInterpolate4",moduleName:xe},n.textInterpolate5={name:"\u0275\u0275textInterpolate5",moduleName:xe},n.textInterpolate6={name:"\u0275\u0275textInterpolate6",moduleName:xe},n.textInterpolate7={name:"\u0275\u0275textInterpolate7",moduleName:xe},n.textInterpolate8={name:"\u0275\u0275textInterpolate8",moduleName:xe},n.textInterpolateV={name:"\u0275\u0275textInterpolateV",moduleName:xe},n.restoreView={name:"\u0275\u0275restoreView",moduleName:xe},n.pureFunction0={name:"\u0275\u0275pureFunction0",moduleName:xe},n.pureFunction1={name:"\u0275\u0275pureFunction1",moduleName:xe},n.pureFunction2={name:"\u0275\u0275pureFunction2",moduleName:xe},n.pureFunction3={name:"\u0275\u0275pureFunction3",moduleName:xe},n.pureFunction4={name:"\u0275\u0275pureFunction4",moduleName:xe},n.pureFunction5={name:"\u0275\u0275pureFunction5",moduleName:xe},n.pureFunction6={name:"\u0275\u0275pureFunction6",moduleName:xe},n.pureFunction7={name:"\u0275\u0275pureFunction7",moduleName:xe},n.pureFunction8={name:"\u0275\u0275pureFunction8",moduleName:xe},n.pureFunctionV={name:"\u0275\u0275pureFunctionV",moduleName:xe},n.pipeBind1={name:"\u0275\u0275pipeBind1",moduleName:xe},n.pipeBind2={name:"\u0275\u0275pipeBind2",moduleName:xe},n.pipeBind3={name:"\u0275\u0275pipeBind3",moduleName:xe},n.pipeBind4={name:"\u0275\u0275pipeBind4",moduleName:xe},n.pipeBindV={name:"\u0275\u0275pipeBindV",moduleName:xe},n.hostProperty={name:"\u0275\u0275hostProperty",moduleName:xe},n.property={name:"\u0275\u0275property",moduleName:xe},n.propertyInterpolate={name:"\u0275\u0275propertyInterpolate",moduleName:xe},n.propertyInterpolate1={name:"\u0275\u0275propertyInterpolate1",moduleName:xe},n.propertyInterpolate2={name:"\u0275\u0275propertyInterpolate2",moduleName:xe},n.propertyInterpolate3={name:"\u0275\u0275propertyInterpolate3",moduleName:xe},n.propertyInterpolate4={name:"\u0275\u0275propertyInterpolate4",moduleName:xe},n.propertyInterpolate5={name:"\u0275\u0275propertyInterpolate5",moduleName:xe},n.propertyInterpolate6={name:"\u0275\u0275propertyInterpolate6",moduleName:xe},n.propertyInterpolate7={name:"\u0275\u0275propertyInterpolate7",moduleName:xe},n.propertyInterpolate8={name:"\u0275\u0275propertyInterpolate8",moduleName:xe},n.propertyInterpolateV={name:"\u0275\u0275propertyInterpolateV",moduleName:xe},n.i18n={name:"\u0275\u0275i18n",moduleName:xe},n.i18nAttributes={name:"\u0275\u0275i18nAttributes",moduleName:xe},n.i18nExp={name:"\u0275\u0275i18nExp",moduleName:xe},n.i18nStart={name:"\u0275\u0275i18nStart",moduleName:xe},n.i18nEnd={name:"\u0275\u0275i18nEnd",moduleName:xe},n.i18nApply={name:"\u0275\u0275i18nApply",moduleName:xe},n.i18nPostprocess={name:"\u0275\u0275i18nPostprocess",moduleName:xe},n.pipe={name:"\u0275\u0275pipe",moduleName:xe},n.projection={name:"\u0275\u0275projection",moduleName:xe},n.projectionDef={name:"\u0275\u0275projectionDef",moduleName:xe},n.reference={name:"\u0275\u0275reference",moduleName:xe},n.inject={name:"\u0275\u0275inject",moduleName:xe},n.injectAttribute={name:"\u0275\u0275injectAttribute",moduleName:xe},n.directiveInject={name:"\u0275\u0275directiveInject",moduleName:xe},n.invalidFactory={name:"\u0275\u0275invalidFactory",moduleName:xe},n.invalidFactoryDep={name:"\u0275\u0275invalidFactoryDep",moduleName:xe},n.templateRefExtractor={name:"\u0275\u0275templateRefExtractor",moduleName:xe},n.forwardRef={name:"forwardRef",moduleName:xe},n.resolveForwardRef={name:"resolveForwardRef",moduleName:xe},n.\u0275\u0275defineInjectable={name:"\u0275\u0275defineInjectable",moduleName:xe},n.declareInjectable={name:"\u0275\u0275ngDeclareInjectable",moduleName:xe},n.InjectableDeclaration={name:"\u0275\u0275InjectableDeclaration",moduleName:xe},n.resolveWindow={name:"\u0275\u0275resolveWindow",moduleName:xe},n.resolveDocument={name:"\u0275\u0275resolveDocument",moduleName:xe},n.resolveBody={name:"\u0275\u0275resolveBody",moduleName:xe},n.defineComponent={name:"\u0275\u0275defineComponent",moduleName:xe},n.declareComponent={name:"\u0275\u0275ngDeclareComponent",moduleName:xe},n.setComponentScope={name:"\u0275\u0275setComponentScope",moduleName:xe},n.ChangeDetectionStrategy={name:"ChangeDetectionStrategy",moduleName:xe},n.ViewEncapsulation={name:"ViewEncapsulation",moduleName:xe},n.ComponentDeclaration={name:"\u0275\u0275ComponentDeclaration",moduleName:xe},n.FactoryDeclaration={name:"\u0275\u0275FactoryDeclaration",moduleName:xe},n.declareFactory={name:"\u0275\u0275ngDeclareFactory",moduleName:xe},n.FactoryTarget={name:"\u0275\u0275FactoryTarget",moduleName:xe},n.defineDirective={name:"\u0275\u0275defineDirective",moduleName:xe},n.declareDirective={name:"\u0275\u0275ngDeclareDirective",moduleName:xe},n.DirectiveDeclaration={name:"\u0275\u0275DirectiveDeclaration",moduleName:xe},n.InjectorDef={name:"\u0275\u0275InjectorDef",moduleName:xe},n.InjectorDeclaration={name:"\u0275\u0275InjectorDeclaration",moduleName:xe},n.defineInjector={name:"\u0275\u0275defineInjector",moduleName:xe},n.declareInjector={name:"\u0275\u0275ngDeclareInjector",moduleName:xe},n.NgModuleDeclaration={name:"\u0275\u0275NgModuleDeclaration",moduleName:xe},n.ModuleWithProviders={name:"ModuleWithProviders",moduleName:xe},n.defineNgModule={name:"\u0275\u0275defineNgModule",moduleName:xe},n.declareNgModule={name:"\u0275\u0275ngDeclareNgModule",moduleName:xe},n.setNgModuleScope={name:"\u0275\u0275setNgModuleScope",moduleName:xe},n.registerNgModuleType={name:"\u0275\u0275registerNgModuleType",moduleName:xe},n.PipeDeclaration={name:"\u0275\u0275PipeDeclaration",moduleName:xe},n.definePipe={name:"\u0275\u0275definePipe",moduleName:xe},n.declarePipe={name:"\u0275\u0275ngDeclarePipe",moduleName:xe},n.declareClassMetadata={name:"\u0275\u0275ngDeclareClassMetadata",moduleName:xe},n.setClassMetadata={name:"\u0275setClassMetadata",moduleName:xe},n.queryRefresh={name:"\u0275\u0275queryRefresh",moduleName:xe},n.viewQuery={name:"\u0275\u0275viewQuery",moduleName:xe},n.loadQuery={name:"\u0275\u0275loadQuery",moduleName:xe},n.contentQuery={name:"\u0275\u0275contentQuery",moduleName:xe},n.NgOnChangesFeature={name:"\u0275\u0275NgOnChangesFeature",moduleName:xe},n.InheritDefinitionFeature={name:"\u0275\u0275InheritDefinitionFeature",moduleName:xe},n.CopyDefinitionFeature={name:"\u0275\u0275CopyDefinitionFeature",moduleName:xe},n.StandaloneFeature={name:"\u0275\u0275StandaloneFeature",moduleName:xe},n.ProvidersFeature={name:"\u0275\u0275ProvidersFeature",moduleName:xe},n.listener={name:"\u0275\u0275listener",moduleName:xe},n.getInheritedFactory={name:"\u0275\u0275getInheritedFactory",moduleName:xe},n.sanitizeHtml={name:"\u0275\u0275sanitizeHtml",moduleName:xe},n.sanitizeStyle={name:"\u0275\u0275sanitizeStyle",moduleName:xe},n.sanitizeResourceUrl={name:"\u0275\u0275sanitizeResourceUrl",moduleName:xe},n.sanitizeScript={name:"\u0275\u0275sanitizeScript",moduleName:xe},n.sanitizeUrl={name:"\u0275\u0275sanitizeUrl",moduleName:xe},n.sanitizeUrlOrResourceUrl={name:"\u0275\u0275sanitizeUrlOrResourceUrl",moduleName:xe},n.trustConstantHtml={name:"\u0275\u0275trustConstantHtml",moduleName:xe},n.trustConstantResourceUrl={name:"\u0275\u0275trustConstantResourceUrl",moduleName:xe},n})();function BT(n){n=n<0?1+(-n<<1):n<<1;let t="";do{let e=31&n;(n>>=5)>0&&(e|=32),t+=sC(e)}while(n>0);return t}function sC(n){if(n<0||n>=64)throw new Error("Can only encode value in the range [0, 63]");return"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[n]}var twe=/'|\\|\n|\r|\$/g,nwe=/^[$A-Z_][0-9A-Z_$]*$/i,rD=class{constructor(t){this.indent=t,this.partsLength=0,this.parts=[],this.srcSpans=[]}},EC=class{constructor(t){this._indent=t,this._lines=[new rD(t)]}static createRoot(){return new EC(0)}get _currentLine(){return this._lines[this._lines.length-1]}println(t,e=""){this.print(t||null,e,!0)}lineIsEmpty(){return 0===this._currentLine.parts.length}lineLength(){return this._currentLine.indent*"  ".length+this._currentLine.partsLength}print(t,e,i=!1){e.length>0&&(this._currentLine.parts.push(e),this._currentLine.partsLength+=e.length,this._currentLine.srcSpans.push(t&&t.sourceSpan||null)),i&&this._lines.push(new rD(this._indent))}removeEmptyLastLine(){this.lineIsEmpty()&&this._lines.pop()}incIndent(){this._indent++,this.lineIsEmpty()&&(this._currentLine.indent=this._indent)}decIndent(){this._indent--,this.lineIsEmpty()&&(this._currentLine.indent=this._indent)}toSource(){return this.sourceLines.map(t=>t.parts.length>0?EX(t.indent)+t.parts.join(""):"").join("\n")}toSourceMapGenerator(t,e=0){let i=new class{constructor(t=null){this.file=t,this.sourcesContent=new Map,this.lines=[],this.lastCol0=0,this.hasMappings=!1}addSource(t,e=null){return this.sourcesContent.has(t)||this.sourcesContent.set(t,e),this}addLine(){return this.lines.push([]),this.lastCol0=0,this}addMapping(t,e,i,r){if(!this.currentLine)throw new Error("A line must be added before mappings can be added");if(null!=e&&!this.sourcesContent.has(e))throw new Error(`Unknown source file "${e}"`);if(null==t)throw new Error("The column in the generated code must be provided");if(t<this.lastCol0)throw new Error("Mapping should be added in output order");if(e&&(null==i||null==r))throw new Error("The source location must be provided when a source url is provided");return this.hasMappings=!0,this.lastCol0=t,this.currentLine.push({col0:t,sourceUrl:e,sourceLine0:i,sourceCol0:r}),this}get currentLine(){return this.lines.slice(-1)[0]}toJSON(){if(!this.hasMappings)return null;let t=new Map,e=[],i=[];Array.from(this.sourcesContent.keys()).forEach((c,u)=>{t.set(c,u),e.push(c),i.push(this.sourcesContent.get(c)||null)});let r="",o=0,s=0,a=0,l=0;return this.lines.forEach(c=>{o=0,r+=c.map(u=>{let d=BT(u.col0-o);return o=u.col0,null!=u.sourceUrl&&(d+=BT(t.get(u.sourceUrl)-s),s=t.get(u.sourceUrl),d+=BT(u.sourceLine0-a),a=u.sourceLine0,d+=BT(u.sourceCol0-l),l=u.sourceCol0),d}).join(","),r+=";"}),r=r.slice(0,-1),{file:this.file||"",version:3,sourceRoot:"",sources:e,sourcesContent:i,mappings:r}}toJsComment(){return this.hasMappings?"//# sourceMappingURL=data:application/json;base64,"+function(n){let t="",e=LV(n);for(let i=0;i<e.length;){let r=e[i++],o=i<e.length?e[i++]:null,s=i<e.length?e[i++]:null;t+=sC(r>>2),t+=sC((3&r)<<4|(null===o?0:o>>4)),t+=null===o?"=":sC((15&o)<<2|(null===s?0:s>>6)),t+=null===o||null===s?"=":sC(63&s)}return t}(JSON.stringify(this,null,0)):""}}(t),r=!1,o=()=>{r||(i.addSource(t," ").addMapping(0,t,0,0),r=!0)};for(let s=0;s<e;s++)i.addLine(),o();return this.sourceLines.forEach((s,a)=>{i.addLine();let l=s.srcSpans,c=s.parts,u=s.indent*"  ".length,d=0;for(;d<l.length&&!l[d];)u+=c[d].length,d++;for(d<l.length&&0===a&&0===u?r=!0:o();d<l.length;){let p=l[d],h=p.start.file,f=p.start.line,m=p.start.col;for(i.addSource(h.url,h.content).addMapping(u,h.url,f,m),u+=c[d].length,d++;d<l.length&&(p===l[d]||!l[d]);)u+=c[d].length,d++}}),i}spanOf(t,e){let i=this._lines[t];if(i){let r=e-EX(i.indent).length;for(let o=0;o<i.parts.length;o++){let s=i.parts[o];if(s.length>r)return i.srcSpans[o];r-=s.length}}return null}get sourceLines(){return this._lines.length&&0===this._lines[this._lines.length-1].parts.length?this._lines.slice(0,-1):this._lines}},NB=class{constructor(t){this._escapeDollarInStrings=t}printLeadingComments(t,e){if(void 0!==t.leadingComments)for(let i of t.leadingComments)i instanceof nD?e.print(t,`/*${i.toString()}*/`,i.trailingNewline):i.multiline?e.print(t,`/* ${i.text} */`,i.trailingNewline):i.text.split("\n").forEach(r=>{e.println(t,`// ${r}`)})}visitExpressionStmt(t,e){return this.printLeadingComments(t,e),t.expr.visitExpression(this,e),e.println(t,";"),null}visitReturnStmt(t,e){return this.printLeadingComments(t,e),e.print(t,"return "),t.value.visitExpression(this,e),e.println(t,";"),null}visitIfStmt(t,e){this.printLeadingComments(t,e),e.print(t,"if ("),t.condition.visitExpression(this,e),e.print(t,") {");let i=null!=t.falseCase&&t.falseCase.length>0;return t.trueCase.length<=1&&!i?(e.print(t," "),this.visitAllStatements(t.trueCase,e),e.removeEmptyLastLine(),e.print(t," ")):(e.println(),e.incIndent(),this.visitAllStatements(t.trueCase,e),e.decIndent(),i&&(e.println(t,"} else {"),e.incIndent(),this.visitAllStatements(t.falseCase,e),e.decIndent())),e.println(t,"}"),null}visitWriteVarExpr(t,e){let i=e.lineIsEmpty();return i||e.print(t,"("),e.print(t,`${t.name} = `),t.value.visitExpression(this,e),i||e.print(t,")"),null}visitWriteKeyExpr(t,e){let i=e.lineIsEmpty();return i||e.print(t,"("),t.receiver.visitExpression(this,e),e.print(t,"["),t.index.visitExpression(this,e),e.print(t,"] = "),t.value.visitExpression(this,e),i||e.print(t,")"),null}visitWritePropExpr(t,e){let i=e.lineIsEmpty();return i||e.print(t,"("),t.receiver.visitExpression(this,e),e.print(t,`.${t.name} = `),t.value.visitExpression(this,e),i||e.print(t,")"),null}visitInvokeFunctionExpr(t,e){return t.fn.visitExpression(this,e),e.print(t,"("),this.visitAllExpressions(t.args,e,","),e.print(t,")"),null}visitTaggedTemplateExpr(t,e){t.tag.visitExpression(this,e),e.print(t,"`"+t.template.elements[0].rawText);for(let i=1;i<t.template.elements.length;i++)e.print(t,"${"),t.template.expressions[i-1].visitExpression(this,e),e.print(t,`}${t.template.elements[i].rawText}`);return e.print(t,"`"),null}visitWrappedNodeExpr(t,e){throw new Error("Abstract emitter cannot visit WrappedNodeExpr.")}visitTypeofExpr(t,e){e.print(t,"typeof "),t.expr.visitExpression(this,e)}visitReadVarExpr(t,e){return e.print(t,t.name),null}visitInstantiateExpr(t,e){return e.print(t,"new "),t.classExpr.visitExpression(this,e),e.print(t,"("),this.visitAllExpressions(t.args,e,","),e.print(t,")"),null}visitLiteralExpr(t,e){let i=t.value;return e.print(t,"string"==typeof i?rm(i,this._escapeDollarInStrings):`${i}`),null}visitLocalizedString(t,e){let i=t.serializeI18nHead();e.print(t,"$localize `"+i.raw);for(let r=1;r<t.messageParts.length;r++)e.print(t,"${"),t.expressions[r-1].visitExpression(this,e),e.print(t,`}${t.serializeI18nTemplatePart(r).raw}`);return e.print(t,"`"),null}visitConditionalExpr(t,e){return e.print(t,"("),t.condition.visitExpression(this,e),e.print(t,"? "),t.trueCase.visitExpression(this,e),e.print(t,": "),t.falseCase.visitExpression(this,e),e.print(t,")"),null}visitNotExpr(t,e){return e.print(t,"!"),t.condition.visitExpression(this,e),null}visitUnaryOperatorExpr(t,e){let i;switch(t.operator){case am.Plus:i="+";break;case am.Minus:i="-";break;default:throw new Error(`Unknown operator ${t.operator}`)}return t.parens&&e.print(t,"("),e.print(t,i),t.expr.visitExpression(this,e),t.parens&&e.print(t,")"),null}visitBinaryOperatorExpr(t,e){let i;switch(t.operator){case Cn.Equals:i="==";break;case Cn.Identical:i="===";break;case Cn.NotEquals:i="!=";break;case Cn.NotIdentical:i="!==";break;case Cn.And:i="&&";break;case Cn.BitwiseAnd:i="&";break;case Cn.Or:i="||";break;case Cn.Plus:i="+";break;case Cn.Minus:i="-";break;case Cn.Divide:i="/";break;case Cn.Multiply:i="*";break;case Cn.Modulo:i="%";break;case Cn.Lower:i="<";break;case Cn.LowerEquals:i="<=";break;case Cn.Bigger:i=">";break;case Cn.BiggerEquals:i=">=";break;case Cn.NullishCoalesce:i="??";break;default:throw new Error(`Unknown operator ${t.operator}`)}return t.parens&&e.print(t,"("),t.lhs.visitExpression(this,e),e.print(t,` ${i} `),t.rhs.visitExpression(this,e),t.parens&&e.print(t,")"),null}visitReadPropExpr(t,e){return t.receiver.visitExpression(this,e),e.print(t,"."),e.print(t,t.name),null}visitReadKeyExpr(t,e){return t.receiver.visitExpression(this,e),e.print(t,"["),t.index.visitExpression(this,e),e.print(t,"]"),null}visitLiteralArrayExpr(t,e){return e.print(t,"["),this.visitAllExpressions(t.entries,e,","),e.print(t,"]"),null}visitLiteralMapExpr(t,e){return e.print(t,"{"),this.visitAllObjects(i=>{e.print(t,`${rm(i.key,this._escapeDollarInStrings,i.quoted)}:`),i.value.visitExpression(this,e)},t.entries,e,","),e.print(t,"}"),null}visitCommaExpr(t,e){return e.print(t,"("),this.visitAllExpressions(t.parts,e,","),e.print(t,")"),null}visitAllExpressions(t,e,i){this.visitAllObjects(r=>r.visitExpression(this,e),t,e,i)}visitAllObjects(t,e,i,r){let o=!1;for(let s=0;s<e.length;s++)s>0&&(i.lineLength()>80?(i.print(null,r,!0),o||(i.incIndent(),i.incIndent(),o=!0)):i.print(null,r,!1)),t(e[s]);o&&(i.decIndent(),i.decIndent())}visitAllStatements(t,e){t.forEach(i=>i.visitStatement(this,e))}};function rm(n,t,e=!0){if(null==n)return null;let i=n.replace(twe,(...o)=>"$"==o[0]?t?"\\$":"$":"\n"==o[0]?"\\n":"\r"==o[0]?"\\r":`\\${o[0]}`);return e||!nwe.test(i)?`'${i}'`:i}function EX(n){let t="";for(let e=0;e<n;e++)t+="  ";return t}function ID(n,t){if(0===t)return ul(n);let e=[];for(let i=0;i<t;i++)e.push(V_);return ul(n,void 0,e)}function zQ(n){return`@${n}`}function rwe(n,t){let e=rm(t,!1,!1);return e!==t?`${n}[${e}]`:`${n}.${t}`}function jQ(n,t){return`animation_${n}_${t}`}function As(n){let t=new Ln(n);return{value:t,type:t}}function om(n,t){let e=_r(n.map(i=>i.value));return t?ra([],[new Do(e)]):e}function HV(n,t){return{expression:n,forwardRef:t}}var f_=(()=>{return(n=f_||(f_={}))[n.Class=0]="Class",n[n.Function=1]="Function",f_;var n})(),Nc=(()=>{return(n=Nc||(Nc={}))[n.Directive=0]="Directive",n[n.Component=1]="Component",n[n.Injectable=2]="Injectable",n[n.Pipe=3]="Pipe",n[n.NgModule=4]="NgModule",Nc;var n})();function nm(n){let t=Ri("t"),e=null,i=DX(n)?t:new gr(Cn.Or,t,n.internalType),r=null;null!==n.deps?"invalid"!==n.deps&&(r=new dm(i,TX(n.deps,n.target))):(e=Ri(`\u0275${n.name}_BaseFactory`),r=e.callFn([i]));let o=[],s=null;function a(c){let u=Ri("r");o.push(u.set(PB).toDeclStmt());let d=null!==r?u.set(r).toStmt():Tn(te.invalidFactory).callFn([]).toStmt();return o.push(VV(t,[d],[u.set(c).toStmt()])),u}if(DX(n)){let c=TX(n.delegateDeps,n.target);s=a(new(n.delegateType===f_.Class?dm:oh)(n.delegate,c))}else s=function(n){return void 0!==n.expression}(n)?a(n.expression):r;if(null===s)o.push(Tn(te.invalidFactory).callFn([]).toStmt());else if(null!==e){let c=Tn(te.getInheritedFactory).callFn([n.internalType]),u=new gr(Cn.Or,e,e.set(c));o.push(new Do(u.callFn([i])))}else o.push(new Do(s));let l=ra([new ia("t",V_)],o,Pa,void 0,`${n.name}_Factory`);return null!==e&&(l=ra([],[new Vu(e.name),new Do(l)]).callFn([],void 0,!0)),{expression:l,statements:[],type:cwe(n)}}function cwe(n){let t=null!==n.deps&&"invalid"!==n.deps?function(n){let t=!1,e=n.map(i=>{let r=function(n){let t=[];return null!==n.attributeNameType&&t.push({key:"attribute",value:n.attributeNameType,quoted:!1}),n.optional&&t.push({key:"optional",value:ht(!0),quoted:!1}),n.host&&t.push({key:"host",value:ht(!0),quoted:!1}),n.self&&t.push({key:"self",value:ht(!0),quoted:!1}),n.skipSelf&&t.push({key:"skipSelf",value:ht(!0),quoted:!1}),t.length>0?ql(t):null}(i);return null!==r?(t=!0,r):ht(null)});return t?ul(_r(e)):Jd}(n.deps):Jd;return ul(Tn(te.FactoryDeclaration,[ID(n.type.type,n.typeArgumentCount),t]))}function TX(n,t){return n.map((e,i)=>function(n,t,e){if(null===n.token)return Tn(te.invalidFactoryDep).callFn([ht(e)]);if(null===n.attributeNameType){let i=0|(n.self?2:0)|(n.skipSelf?4:0)|(n.host?1:0)|(n.optional?8:0)|(t===Nc.Pipe?16:0),r=0!==i||n.optional?ht(i):null,o=[n.token];r&&o.push(r);let s=function(n){switch(n){case Nc.Component:case Nc.Directive:case Nc.Pipe:return te.directiveInject;default:return te.inject}}(t);return Tn(s).callFn(o)}return Tn(te.injectAttribute).callFn([n.token])}(e,t,i))}function DX(n){return void 0!==n.delegateType}var M_=class{constructor(t,e){this.value=t,this.sourceSpan=e}visit(t){return t.visitText(this)}},TC=class{constructor(t,e,i){this.value=t,this.sourceSpan=e,this.i18n=i}visit(t){return t.visitBoundText(this)}},DC=class{constructor(t,e,i,r,o,s){this.name=t,this.value=e,this.sourceSpan=i,this.keySpan=r,this.valueSpan=o,this.i18n=s}visit(t){return t.visitTextAttribute(this)}},w_=class{constructor(t,e,i,r,o,s,a,l,c){this.name=t,this.type=e,this.securityContext=i,this.value=r,this.unit=o,this.sourceSpan=s,this.keySpan=a,this.valueSpan=l,this.i18n=c}static fromBoundElementProperty(t,e){if(void 0===t.keySpan)throw new Error(`Unexpected state: keySpan must be defined for bound attributes but was not for ${t.name}: ${t.sourceSpan}`);return new w_(t.name,t.type,t.securityContext,t.value,t.unit,t.sourceSpan,t.keySpan,t.valueSpan,e)}visit(t){return t.visitBoundAttribute(this)}},S_=class{constructor(t,e,i,r,o,s,a,l){this.name=t,this.type=e,this.handler=i,this.target=r,this.phase=o,this.sourceSpan=s,this.handlerSpan=a,this.keySpan=l}static fromParsedEvent(t){let e=0===t.type?t.targetOrPhase:null,i=1===t.type?t.targetOrPhase:null;if(void 0===t.keySpan)throw new Error(`Unexpected state: keySpan must be defined for bound event but was not for ${t.name}: ${t.sourceSpan}`);return new S_(t.name,t.type,t.handler,e,i,t.sourceSpan,t.handlerSpan,t.keySpan)}visit(t){return t.visitBoundEvent(this)}},E_=class{constructor(t,e,i,r,o,s,a,l,c,u){this.name=t,this.attributes=e,this.inputs=i,this.outputs=r,this.children=o,this.references=s,this.sourceSpan=a,this.startSourceSpan=l,this.endSourceSpan=c,this.i18n=u}visit(t){return t.visitElement(this)}},uC=class{constructor(t,e,i,r,o,s,a,l,c,u,d,p){this.tagName=t,this.attributes=e,this.inputs=i,this.outputs=r,this.templateAttrs=o,this.children=s,this.references=a,this.variables=l,this.sourceSpan=c,this.startSourceSpan=u,this.endSourceSpan=d,this.i18n=p}visit(t){return t.visitTemplate(this)}},oD=class{constructor(t,e,i,r,o){this.name=t,this.value=e,this.sourceSpan=i,this.keySpan=r,this.valueSpan=o}visit(t){return t.visitVariable(this)}},sD=class{constructor(t,e,i,r){this.vars=t,this.placeholders=e,this.sourceSpan=i,this.i18n=r}visit(t){return t.visitIcu(this)}};function AX(n,t){let e=[];if(n.visit)for(let i of t)n.visit(i)||i.visit(n);else for(let i of t){let r=i.visit(n);r&&e.push(r)}return e}var Fu=class{constructor(t,e,i,r,o,s){this.nodes=t,this.placeholders=e,this.placeholderToMessage=i,this.meaning=r,this.description=o,this.customId=s,this.id=this.customId,this.legacyIds=[],this.messageString=function(n){let t=new UB;return n.map(i=>i.visit(t)).join("")}(this.nodes),this.sources=t.length?[{filePath:t[0].sourceSpan.start.file.url,startLine:t[0].sourceSpan.start.line+1,startCol:t[0].sourceSpan.start.col+1,endLine:t[t.length-1].sourceSpan.end.line+1,endCol:t[0].sourceSpan.start.col+1}]:[]}},l_=class{constructor(t,e){this.value=t,this.sourceSpan=e}visit(t,e){return t.visitText(this,e)}},mm=class{constructor(t,e){this.children=t,this.sourceSpan=e}visit(t,e){return t.visitContainer(this,e)}},aD=class{constructor(t,e,i,r){this.expression=t,this.type=e,this.cases=i,this.sourceSpan=r}visit(t,e){return t.visitIcu(this,e)}},lD=class{constructor(t,e,i){this.value=t,this.name=e,this.sourceSpan=i}visit(t,e){return t.visitPlaceholder(this,e)}},T_=class{constructor(t,e,i){this.value=t,this.name=e,this.sourceSpan=i}visit(t,e){return t.visitIcuPlaceholder(this,e)}},UB=class{visitText(t){return t.value}visitContainer(t){return t.children.map(e=>e.visit(this)).join("")}visitIcu(t){let e=Object.keys(t.cases).map(i=>`${i} {${t.cases[i].visit(this)}}`);return`{${t.expressionPlaceholder}, ${t.type}, ${e.join(" ")}}`}visitTagPlaceholder(t){let e=t.children.map(i=>i.visit(this)).join("");return`{$${t.startName}}${e}{$${t.closeName}}`}visitPlaceholder(t){return`{$${t.name}}`}visitIcuPlaceholder(t){return`{$${t.name}}`}};new class{visitTag(t){let e=this._serializeAttributes(t.attrs);if(0==t.children.length)return`<${t.name}${e}/>`;let i=t.children.map(r=>r.visit(this));return`<${t.name}${e}>${i.join("")}</${t.name}>`}visitText(t){return t.value}visitDeclaration(t){return`<?xml${this._serializeAttributes(t.attrs)} ?>`}_serializeAttributes(t){let e=Object.keys(t).map(i=>`${i}="${t[i]}"`).join(" ");return e.length>0?" "+e:""}visitDoctype(t){return`<!DOCTYPE ${t.rootTag} [\n${t.dtd}\n]>`}};var jB="i18n-";function AC(n){return n instanceof Fu}function VT(n){return AC(n)&&1===n.nodes.length&&n.nodes[0]instanceof aD}function Cwe(n){return!!n.i18n}function WQ(n){return n.nodes[0]}function PD(n,t=0){return`\ufffd${n}${t>0?`:${t}`:""}\ufffd`}function Swe(n=0){let t=n;return()=>t++}function PX(n){let t={};return n.forEach((e,i)=>{t[i]=ht(e.length>1?`[${e.join("|")}]`:e[0])}),t}function qT(n,t,...e){let i=n.get(t)||[];i.push(...e),n.set(t,i)}function qQ(n,t=0,e=0){let i=t,r=new Map,o=n instanceof Fu?n.nodes.find(s=>s instanceof mm):n;return o&&o.children.filter(s=>s instanceof lD).forEach((s,a)=>{let l=PD(i+a,e);qT(r,s.name,l)}),r}function UV(n={},t){let e={};return n&&Object.keys(n).length&&Object.keys(n).forEach(i=>e[JC(i,t)]=n[i]),e}function JC(n,t=!0){let e=function(n){return n.toUpperCase().replace(/[^A-Z0-9_]/g,"_")}(n);if(!t)return e;let r,i=e.split("_");if(1===i.length)return n.toLowerCase();/^\d+$/.test(i[i.length-1])&&(r=i.pop());let o=i.shift().toLowerCase();return i.length&&(o+=i.map(s=>s.charAt(0).toUpperCase()+s.slice(1).toLowerCase()).join("")),r?`${o}_${r}`:o}function RX(n){return`MSG_${n}`.toUpperCase()}function Ewe(n){return new Vu(n.name,void 0,Pa,void 0,n.sourceSpan)}var Twe=/[-.]/,Hc="ctx",$C="rf",YQ="restoredCtx",Rwe=new Set([te.element,te.elementStart,te.elementEnd,te.elementContainer,te.elementContainerStart,te.elementContainerEnd,te.i18nExp,te.listener,te.classProp,te.syntheticHostListener,te.hostProperty,te.syntheticHostProperty,te.property,te.propertyInterpolate1,te.propertyInterpolate2,te.propertyInterpolate3,te.propertyInterpolate4,te.propertyInterpolate5,te.propertyInterpolate6,te.propertyInterpolate7,te.propertyInterpolate8,te.propertyInterpolateV,te.attribute,te.attributeInterpolate1,te.attributeInterpolate2,te.attributeInterpolate3,te.attributeInterpolate4,te.attributeInterpolate5,te.attributeInterpolate6,te.attributeInterpolate7,te.attributeInterpolate8,te.attributeInterpolateV,te.styleProp,te.stylePropInterpolate1,te.stylePropInterpolate2,te.stylePropInterpolate3,te.stylePropInterpolate4,te.stylePropInterpolate5,te.stylePropInterpolate6,te.stylePropInterpolate7,te.stylePropInterpolate8,te.stylePropInterpolateV,te.textInterpolate,te.textInterpolate1,te.textInterpolate2,te.textInterpolate3,te.textInterpolate4,te.textInterpolate5,te.textInterpolate6,te.textInterpolate7,te.textInterpolate8,te.textInterpolateV]);function gm(n,t,e){return Tn(t,null,n).callFn(e,n)}function XQ(n,t){let e=null;return()=>(e||(n.push(new Vu("_t",void 0,V_)),e=Ri(t)),e)}function iC(n){throw new Error(`Invalid state: Visitor ${this.constructor.name} doesn't handle ${n.constructor.name}`)}function Nu(n){return Array.isArray(n)?_r(n.map(Nu)):ht(n,Pa)}function OX(n,t){return Object.getOwnPropertyNames(n).length>0?function(n,t){return ql(Object.getOwnPropertyNames(n).map(e=>{let r,o,s,a,i=n[e];return Array.isArray(i)?([o,r]=i,s=e,a=o!==r):(s=r=e,o=i,a=!1),{key:s,quoted:Twe.test(s),value:t&&a?_r([Nu(o),Nu(r)]):Nu(o)}}))}(n,t):null}function sB(n){for(;VQ(n[n.length-1]);)n.pop();return n}function kwe(n,t){if(Array.isArray(n.predicate)){let e=[];return n.predicate.forEach(i=>{let r=i.split(",").map(o=>ht(o.trim()));e.push(...r)}),t.getConstLiteral(_r(e),!0)}switch(n.predicate.forwardRef){case 0:case 2:return n.predicate.expression;case 1:return Tn(te.resolveForwardRef).callFn([n.predicate.expression])}}var sh=class{constructor(){this.values=[]}set(t,e){e&&this.values.push({key:t,value:e,quoted:!1})}toLiteralMap(){return ql(this.values)}};function wm(n){let{expressions:t,strings:e}=n;return 1===t.length&&2===e.length&&""===e[0]&&""===e[1]?1:t.length+e.length}function cD(n){let t=[],e=null,i=null,r=0;for(let o of n){let s=("function"==typeof o.paramsOrFn?o.paramsOrFn():o.paramsOrFn)??[],a=Array.isArray(s)?s:[s];r<500&&i===o.reference&&Rwe.has(i)?(e=e.callFn(a,e.sourceSpan),r++):(null!==e&&t.push(e.toStmt()),e=gm(o.span,o.reference,a),i=o.reference,r=0)}return null!==e&&t.push(e.toStmt()),t}function kX(n,t){let e=null,i={name:n.name,type:n.type,internalType:n.internalType,typeArgumentCount:n.typeArgumentCount,deps:[],target:Nc.Injectable};if(void 0!==n.useClass){let l,a=n.useClass.expression.isEquivalent(n.internalType);void 0!==n.deps&&(l=n.deps),e=void 0!==l?nm({...i,delegate:n.useClass.expression,delegateDeps:l,delegateType:f_.Class}):a?nm(i):{statements:[],expression:FX(n.type.value,n.useClass.expression,t)}}else e=void 0!==n.useFactory?void 0!==n.deps?nm({...i,delegate:n.useFactory,delegateDeps:n.deps||[],delegateType:f_.Function}):{statements:[],expression:ra([],[new Do(n.useFactory.callFn([]))])}:void 0!==n.useValue?nm({...i,expression:n.useValue.expression}):void 0!==n.useExisting?nm({...i,expression:Tn(te.inject).callFn([n.useExisting.expression])}):{statements:[],expression:FX(n.type.value,n.internalType,t)};let r=n.internalType,o=new sh;return o.set("token",r),o.set("factory",e.expression),null!==n.providedIn.expression.value&&o.set("providedIn",function({expression:n,forwardRef:t}){switch(t){case 0:case 1:return n;case 2:return function(n){return Tn(te.forwardRef).callFn([ra([],[new Do(n)])])}(n)}}(n.providedIn)),{expression:Tn(te.\u0275\u0275defineInjectable).callFn([o.toLiteralMap()],void 0,!0),type:Fwe(n),statements:e.statements}}function Fwe(n){return new Vc(Tn(te.InjectableDeclaration,[ID(n.type.type,n.typeArgumentCount)]))}function FX(n,t,e){return n.node===t.node?t.prop("\u0275fac"):NX(e?Tn(te.resolveForwardRef).callFn([t]):t)}function NX(n){return ra([new ia("t",V_)],[new Do(n.prop("\u0275fac").callFn([Ri("t")]))])}var Nwe=[/^\s*$/,/[<>]/,/^[{}]$/,/&(#|[a-z])/i,/^\/\//],D_=class{constructor(t,e){this.start=t,this.end=e}static fromArray(t){return t?(function(n,t){if(null!=t&&(!Array.isArray(t)||2!=t.length))throw new Error("Expected 'interpolation' to be an array, [start, end].");if(null!=t){let e=t[0],i=t[1];Nwe.forEach(r=>{if(r.test(e)||r.test(i))throw new Error(`['${e}', '${i}'] contains unusable interpolation symbol.`)})}}(0,t),new D_(t[0],t[1])):Pu}},Pu=new D_("{{","}}"),th=123,Ou=125;function QV(n){return n>=9&&n<=32||160==n}function $p(n){return 48<=n&&n<=57}function KV(n){return n>=97&&n<=122||n>=65&&n<=90}function cK(n){return 10===n||13===n}function VX(n){return 48<=n&&n<=55}function WB(n){return 39===n||34===n||96===n}var vm=class{constructor(t,e,i,r){this.file=t,this.offset=e,this.line=i,this.col=r}toString(){return null!=this.offset?`${this.file.url}@${this.line}:${this.col}`:this.file.url}moveBy(t){let e=this.file.content,i=e.length,r=this.offset,o=this.line,s=this.col;for(;r>0&&t<0;)if(r--,t++,10==e.charCodeAt(r)){o--;let l=e.substring(0,r-1).lastIndexOf(String.fromCharCode(10));s=l>0?r-l:r}else s--;for(;r<i&&t>0;){let a=e.charCodeAt(r);r++,t--,10==a?(o++,s=0):s++}return new vm(this.file,r,o,s)}getContext(t,e){let i=this.file.content,r=this.offset;if(null!=r){r>i.length-1&&(r=i.length-1);let o=r,s=0,a=0;for(;s<t&&r>0&&(r--,s++,"\n"!=i[r]||++a!=e););for(s=0,a=0;s<t&&o<i.length-1&&(o++,s++,"\n"!=i[o]||++a!=e););return{before:i.substring(r,this.offset),after:i.substring(this.offset,o+1)}}return null}},pD=class{constructor(t,e){this.content=t,this.url=e}},Go=class{constructor(t,e,i=t,r=null){this.start=t,this.end=e,this.fullStart=i,this.details=r}toString(){return this.start.file.content.substring(this.start.offset,this.end.offset)}},ku=(()=>{return(n=ku||(ku={}))[n.WARNING=0]="WARNING",n[n.ERROR=1]="ERROR",ku;var n})(),ym=class{constructor(t,e,i=ku.ERROR){this.span=t,this.msg=e,this.level=i}contextualMessage(){let t=this.span.start.getContext(100,3);return t?`${this.msg} ("${t.before}[${ku[this.level]} ->]${t.after}")`:this.msg}toString(){let t=this.span.details?`, ${this.span.details}`:"";return`${this.contextualMessage()}: ${this.span.start}${t}`}},Zwe=0;function m_(n){return n.replace(/\W/g,"_")}var HT,HX='(this&&this.__makeTemplateObject||function(e,t){return Object.defineProperty?Object.defineProperty(e,"raw",{value:t}):e.raw=t,e})',qB=class extends NB{constructor(){super(!1)}visitWrappedNodeExpr(t,e){throw new Error("Cannot emit a WrappedNodeExpr in Javascript.")}visitDeclareVarStmt(t,e){return e.print(t,`var ${t.name}`),t.value&&(e.print(t," = "),t.value.visitExpression(this,e)),e.println(t,";"),null}visitTaggedTemplateExpr(t,e){let i=t.template.elements;return t.tag.visitExpression(this,e),e.print(t,`(${HX}(`),e.print(t,`[${i.map(r=>rm(r.text,!1)).join(", ")}], `),e.print(t,`[${i.map(r=>rm(r.rawText,!1)).join(", ")}])`),t.template.expressions.forEach(r=>{e.print(t,", "),r.visitExpression(this,e)}),e.print(t,")"),null}visitFunctionExpr(t,e){return e.print(t,`function${t.name?" "+t.name:""}(`),this._visitParams(t.params,e),e.println(t,") {"),e.incIndent(),this.visitAllStatements(t.statements,e),e.decIndent(),e.print(t,"}"),null}visitDeclareFunctionStmt(t,e){return e.print(t,`function ${t.name}(`),this._visitParams(t.params,e),e.println(t,") {"),e.incIndent(),this.visitAllStatements(t.statements,e),e.decIndent(),e.println(t,"}"),null}visitLocalizedString(t,e){e.print(t,`$localize(${HX}(`);let i=[t.serializeI18nHead()];for(let r=1;r<t.messageParts.length;r++)i.push(t.serializeI18nTemplatePart(r));return e.print(t,`[${i.map(r=>rm(r.cooked,!1)).join(", ")}], `),e.print(t,`[${i.map(r=>rm(r.raw,!1)).join(", ")}])`),t.expressions.forEach(r=>{e.print(t,", "),r.visitExpression(this,e)}),e.print(t,")"),null}_visitParams(t,e){this.visitAllObjects(i=>e.print(null,i.name),t,e,",")}};function UX(...n){if(!p_.trustedTypes)return new Function(...n);let i=`(function anonymous(${n.slice(0,-1).join(",")}\n) { ${n[n.length-1]}\n})`,r=p_.eval(function(n){return function(){if(void 0===HT&&(HT=null,p_.trustedTypes))try{HT=p_.trustedTypes.createPolicy("angular#unsafe-jit",{createScript:n=>n})}catch{}return HT}()?.createScript(n)||n}(i));return void 0===r.bind?new Function(...n):(r.toString=()=>i,r.bind(p_))}var XB=class extends qB{constructor(t){super(),this.refResolver=t,this._evalArgNames=[],this._evalArgValues=[],this._evalExportedVars=[]}createReturnStmt(t){new Do(new x_(this._evalExportedVars.map(i=>new tD(i,Ri(i),!1)))).visitStatement(this,t)}getArgs(){let t={};for(let e=0;e<this._evalArgNames.length;e++)t[this._evalArgNames[e]]=this._evalArgValues[e];return t}visitExternalExpr(t,e){return this._emitReferenceToExternal(t,this.refResolver.resolveExternalReference(t.value),e),null}visitWrappedNodeExpr(t,e){return this._emitReferenceToExternal(t,t.node,e),null}visitDeclareVarStmt(t,e){return t.hasModifier(ll.Exported)&&this._evalExportedVars.push(t.name),super.visitDeclareVarStmt(t,e)}visitDeclareFunctionStmt(t,e){return t.hasModifier(ll.Exported)&&this._evalExportedVars.push(t.name),super.visitDeclareFunctionStmt(t,e)}_emitReferenceToExternal(t,e,i){let r=this._evalArgValues.indexOf(e);if(-1===r){r=this._evalArgValues.length,this._evalArgValues.push(e);let o=function(n){if(!n||!n.reference)return null;let t=n.reference;if(t.__anonymousType)return t.__anonymousType;if(t.__forward_ref__)return"__forward_ref__";let e=kQ(t);return e.indexOf("(")>=0?(e="anonymous_"+Zwe++,t.__anonymousType=e):e=m_(e),e}({reference:e})||"val";this._evalArgNames.push(`jit_${o}_${r}`)}i.print(t,this._evalArgNames[r])}};function zX(n){let t=new sh;null!==n.providers&&t.set("providers",n.providers),n.imports.length>0&&t.set("imports",_r(n.imports));let e=Tn(te.defineInjector).callFn([t.toLiteralMap()],void 0,!0),i=function(n){return new Vc(Tn(te.InjectorDeclaration,[new Vc(n.type.type)]))}(n);return{expression:e,type:i,statements:[]}}var g_=(()=>{return(n=g_||(g_={}))[n.Inline=0]="Inline",n[n.SideEffect=1]="SideEffect",n[n.Omit=2]="Omit",g_;var n})();function iSe(n){let{adjacentType:t,internalType:e,bootstrap:i,declarations:r,imports:o,exports:s,schemas:a,containsForwardDecls:l,selectorScopeMode:c,id:u}=n,d=[],p=new sh;if(p.set("type",e),i.length>0&&p.set("bootstrap",om(i,l)),c===g_.Inline)r.length>0&&p.set("declarations",om(r,l)),o.length>0&&p.set("imports",om(o,l)),s.length>0&&p.set("exports",om(s,l));else if(c===g_.SideEffect){let m=function(n){let{adjacentType:t,declarations:e,imports:i,exports:r,containsForwardDecls:o}=n,s=new sh;if(e.length>0&&s.set("declarations",om(e,o)),i.length>0&&s.set("imports",om(i,o)),r.length>0&&s.set("exports",om(r,o)),0===Object.keys(s.values).length)return null;let l=function(n){return function(n,t){let e=new y_({name:"ngJitMode",moduleName:null}),i=new gr(Cn.Identical,new v_(e),ht("undefined")),r=new gr(Cn.Or,i,e,void 0,void 0,!0);return new gr(Cn.And,r,t)}(0,n)}(new oh(Tn(te.setNgModuleScope),[t,s.toLiteralMap()])),c=new pm([],[l.toStmt()]);return new oh(c,[]).toStmt()}(n);null!==m&&d.push(m)}null!==a&&a.length>0&&p.set("schemas",_r(a.map(m=>m.value))),null!==u&&(p.set("id",u),d.push(Tn(te.registerNgModuleType).callFn([t,u]).toStmt()));let h=Tn(te.defineNgModule).callFn([p.toLiteralMap()],void 0,!0),f=function({type:n,declarations:t,exports:e,imports:i,includeImportTypes:r,publicDeclarationTypes:o}){return new Vc(Tn(te.NgModuleDeclaration,[new Vc(n.type),null===o?aB(t):aSe(o),r?aB(i):Jd,aB(e)]))}(n);return{expression:h,type:f,statements:d}}function aB(n){let t=n.map(e=>BV(e.type));return n.length>0?ul(_r(t)):Jd}function aSe(n){let t=n.map(e=>BV(e));return n.length>0?ul(_r(t)):Jd}function jX(n){let t=[];t.push({key:"name",value:ht(n.pipeName),quoted:!1}),t.push({key:"type",value:n.type.value,quoted:!1}),t.push({key:"pure",value:ht(n.pure),quoted:!1}),n.isStandalone&&t.push({key:"standalone",value:ht(!0),quoted:!1});let e=Tn(te.definePipe).callFn([ql(t)],void 0,!0),i=function(n){return new Vc(Tn(te.PipeDeclaration,[ID(n.type.type,n.typeArgumentCount),new Vc(new cl(n.pipeName)),new Vc(new cl(n.isStandalone))]))}(n);return{expression:e,type:i,statements:[]}}var __=(()=>{return(n=__||(__={}))[n.Directive=0]="Directive",n[n.Pipe=1]="Pipe",n[n.NgModule=2]="NgModule",__;var n})(),RC=class{constructor(t,e,i,r){this.input=e,this.errLocation=i,this.ctxLocation=r,this.message=`Parser Error: ${t} ${i} [${e}] in ${r}`}},bm=class{constructor(t,e){this.start=t,this.end=e}toAbsolute(t){return new al(t+this.start,t+this.end)}},Ao=class{constructor(t,e){this.span=t,this.sourceSpan=e}toString(){return"AST"}},A_=class extends Ao{constructor(t,e,i){super(t,e),this.nameSpan=i}},Ia=class extends Ao{visit(t,e=null){}},xm=class extends Ao{visit(t,e=null){return t.visitImplicitReceiver(this,e)}},OC=class extends xm{visit(t,e=null){return t.visitThisReceiver?.(this,e)}},kC=class extends Ao{constructor(t,e,i){super(t,e),this.expressions=i}visit(t,e=null){return t.visitChain(this,e)}},FC=class extends Ao{constructor(t,e,i,r,o){super(t,e),this.condition=i,this.trueExp=r,this.falseExp=o}visit(t,e=null){return t.visitConditional(this,e)}},Lu=class extends A_{constructor(t,e,i,r,o){super(t,e,i),this.receiver=r,this.name=o}visit(t,e=null){return t.visitPropertyRead(this,e)}},NC=class extends A_{constructor(t,e,i,r,o,s){super(t,e,i),this.receiver=r,this.name=o,this.value=s}visit(t,e=null){return t.visitPropertyWrite(this,e)}},LC=class extends A_{constructor(t,e,i,r,o){super(t,e,i),this.receiver=r,this.name=o}visit(t,e=null){return t.visitSafePropertyRead(this,e)}},I_=class extends Ao{constructor(t,e,i,r){super(t,e),this.receiver=i,this.key=r}visit(t,e=null){return t.visitKeyedRead(this,e)}},P_=class extends Ao{constructor(t,e,i,r){super(t,e),this.receiver=i,this.key=r}visit(t,e=null){return t.visitSafeKeyedRead(this,e)}},BC=class extends Ao{constructor(t,e,i,r,o){super(t,e),this.receiver=i,this.key=r,this.value=o}visit(t,e=null){return t.visitKeyedWrite(this,e)}},R_=class extends A_{constructor(t,e,i,r,o,s){super(t,e,s),this.exp=i,this.name=r,this.args=o}visit(t,e=null){return t.visitPipe(this,e)}},ta=class extends Ao{constructor(t,e,i){super(t,e),this.value=i}visit(t,e=null){return t.visitLiteralPrimitive(this,e)}},O_=class extends Ao{constructor(t,e,i){super(t,e),this.expressions=i}visit(t,e=null){return t.visitLiteralArray(this,e)}},VC=class extends Ao{constructor(t,e,i,r){super(t,e),this.keys=i,this.values=r}visit(t,e=null){return t.visitLiteralMap(this,e)}},vs=class extends Ao{constructor(t,e,i,r){super(t,e),this.strings=i,this.expressions=r}visit(t,e=null){return t.visitInterpolation(this,e)}},Gl=class extends Ao{constructor(t,e,i,r,o){super(t,e),this.operation=i,this.left=r,this.right=o}visit(t,e=null){return t.visitBinary(this,e)}},zc=class extends Gl{constructor(t,e,i,r,o,s,a){super(t,e,o,s,a),this.operator=i,this.expr=r,this.left=null,this.right=null,this.operation=null}static createMinus(t,e,i){return new zc(t,e,"-",i,"-",new ta(t,e,0),i)}static createPlus(t,e,i){return new zc(t,e,"+",i,"-",i,new ta(t,e,0))}visit(t,e=null){return void 0!==t.visitUnary?t.visitUnary(this,e):t.visitBinary(this,e)}},HC=class extends Ao{constructor(t,e,i){super(t,e),this.expression=i}visit(t,e=null){return t.visitPrefixNot(this,e)}},UC=class extends Ao{constructor(t,e,i){super(t,e),this.expression=i}visit(t,e=null){return t.visitNonNullAssert(this,e)}},ah=class extends Ao{constructor(t,e,i,r,o){super(t,e),this.receiver=i,this.args=r,this.argumentSpan=o}visit(t,e=null){return t.visitCall(this,e)}},k_=class extends Ao{constructor(t,e,i,r,o){super(t,e),this.receiver=i,this.args=r,this.argumentSpan=o}visit(t,e=null){return t.visitSafeCall(this,e)}},al=class{constructor(t,e){this.start=t,this.end=e}},Ru=class extends Ao{constructor(t,e,i,r,o){super(new bm(0,null===e?0:e.length),new al(r,null===e?r:r+e.length)),this.ast=t,this.source=e,this.location=i,this.errors=o}visit(t,e=null){return t.visitASTWithSource?t.visitASTWithSource(this,e):this.ast.visit(t,e)}toString(){return`${this.source} in ${this.location}`}},zC=class{constructor(t,e,i){this.sourceSpan=t,this.key=e,this.value=i}},ZB=class{visit(t,e){t.visit(this,e)}visitUnary(t,e){this.visit(t.expr,e)}visitBinary(t,e){this.visit(t.left,e),this.visit(t.right,e)}visitChain(t,e){this.visitAll(t.expressions,e)}visitConditional(t,e){this.visit(t.condition,e),this.visit(t.trueExp,e),this.visit(t.falseExp,e)}visitPipe(t,e){this.visit(t.exp,e),this.visitAll(t.args,e)}visitImplicitReceiver(t,e){}visitThisReceiver(t,e){}visitInterpolation(t,e){this.visitAll(t.expressions,e)}visitKeyedRead(t,e){this.visit(t.receiver,e),this.visit(t.key,e)}visitKeyedWrite(t,e){this.visit(t.receiver,e),this.visit(t.key,e),this.visit(t.value,e)}visitLiteralArray(t,e){this.visitAll(t.expressions,e)}visitLiteralMap(t,e){this.visitAll(t.values,e)}visitLiteralPrimitive(t,e){}visitPrefixNot(t,e){this.visit(t.expression,e)}visitNonNullAssert(t,e){this.visit(t.expression,e)}visitPropertyRead(t,e){this.visit(t.receiver,e)}visitPropertyWrite(t,e){this.visit(t.receiver,e),this.visit(t.value,e)}visitSafePropertyRead(t,e){this.visit(t.receiver,e)}visitSafeKeyedRead(t,e){this.visit(t.receiver,e),this.visit(t.key,e)}visitCall(t,e){this.visit(t.receiver,e),this.visitAll(t.args,e)}visitSafeCall(t,e){this.visit(t.receiver,e),this.visitAll(t.args,e)}visitAll(t,e){for(let i of t)this.visit(i,e)}},JB=class{visitImplicitReceiver(t,e){return t}visitThisReceiver(t,e){return t}visitInterpolation(t,e){return new vs(t.span,t.sourceSpan,t.strings,this.visitAll(t.expressions))}visitLiteralPrimitive(t,e){return new ta(t.span,t.sourceSpan,t.value)}visitPropertyRead(t,e){return new Lu(t.span,t.sourceSpan,t.nameSpan,t.receiver.visit(this),t.name)}visitPropertyWrite(t,e){return new NC(t.span,t.sourceSpan,t.nameSpan,t.receiver.visit(this),t.name,t.value.visit(this))}visitSafePropertyRead(t,e){return new LC(t.span,t.sourceSpan,t.nameSpan,t.receiver.visit(this),t.name)}visitLiteralArray(t,e){return new O_(t.span,t.sourceSpan,this.visitAll(t.expressions))}visitLiteralMap(t,e){return new VC(t.span,t.sourceSpan,t.keys,this.visitAll(t.values))}visitUnary(t,e){switch(t.operator){case"+":return zc.createPlus(t.span,t.sourceSpan,t.expr.visit(this));case"-":return zc.createMinus(t.span,t.sourceSpan,t.expr.visit(this));default:throw new Error(`Unknown unary operator ${t.operator}`)}}visitBinary(t,e){return new Gl(t.span,t.sourceSpan,t.operation,t.left.visit(this),t.right.visit(this))}visitPrefixNot(t,e){return new HC(t.span,t.sourceSpan,t.expression.visit(this))}visitNonNullAssert(t,e){return new UC(t.span,t.sourceSpan,t.expression.visit(this))}visitConditional(t,e){return new FC(t.span,t.sourceSpan,t.condition.visit(this),t.trueExp.visit(this),t.falseExp.visit(this))}visitPipe(t,e){return new R_(t.span,t.sourceSpan,t.exp.visit(this),t.name,this.visitAll(t.args),t.nameSpan)}visitKeyedRead(t,e){return new I_(t.span,t.sourceSpan,t.receiver.visit(this),t.key.visit(this))}visitKeyedWrite(t,e){return new BC(t.span,t.sourceSpan,t.receiver.visit(this),t.key.visit(this),t.value.visit(this))}visitCall(t,e){return new ah(t.span,t.sourceSpan,t.receiver.visit(this),this.visitAll(t.args),t.argumentSpan)}visitSafeCall(t,e){return new k_(t.span,t.sourceSpan,t.receiver.visit(this),this.visitAll(t.args),t.argumentSpan)}visitAll(t){let e=[];for(let i=0;i<t.length;++i)e[i]=t[i].visit(this);return e}visitChain(t,e){return new kC(t.span,t.sourceSpan,this.visitAll(t.expressions))}visitSafeKeyedRead(t,e){return new P_(t.span,t.sourceSpan,t.receiver.visit(this),t.key.visit(this))}},$B=class{visitImplicitReceiver(t,e){return t}visitThisReceiver(t,e){return t}visitInterpolation(t,e){let i=this.visitAll(t.expressions);return i!==t.expressions?new vs(t.span,t.sourceSpan,t.strings,i):t}visitLiteralPrimitive(t,e){return t}visitPropertyRead(t,e){let i=t.receiver.visit(this);return i!==t.receiver?new Lu(t.span,t.sourceSpan,t.nameSpan,i,t.name):t}visitPropertyWrite(t,e){let i=t.receiver.visit(this),r=t.value.visit(this);return i!==t.receiver||r!==t.value?new NC(t.span,t.sourceSpan,t.nameSpan,i,t.name,r):t}visitSafePropertyRead(t,e){let i=t.receiver.visit(this);return i!==t.receiver?new LC(t.span,t.sourceSpan,t.nameSpan,i,t.name):t}visitLiteralArray(t,e){let i=this.visitAll(t.expressions);return i!==t.expressions?new O_(t.span,t.sourceSpan,i):t}visitLiteralMap(t,e){let i=this.visitAll(t.values);return i!==t.values?new VC(t.span,t.sourceSpan,t.keys,i):t}visitUnary(t,e){let i=t.expr.visit(this);if(i!==t.expr)switch(t.operator){case"+":return zc.createPlus(t.span,t.sourceSpan,i);case"-":return zc.createMinus(t.span,t.sourceSpan,i);default:throw new Error(`Unknown unary operator ${t.operator}`)}return t}visitBinary(t,e){let i=t.left.visit(this),r=t.right.visit(this);return i!==t.left||r!==t.right?new Gl(t.span,t.sourceSpan,t.operation,i,r):t}visitPrefixNot(t,e){let i=t.expression.visit(this);return i!==t.expression?new HC(t.span,t.sourceSpan,i):t}visitNonNullAssert(t,e){let i=t.expression.visit(this);return i!==t.expression?new UC(t.span,t.sourceSpan,i):t}visitConditional(t,e){let i=t.condition.visit(this),r=t.trueExp.visit(this),o=t.falseExp.visit(this);return i!==t.condition||r!==t.trueExp||o!==t.falseExp?new FC(t.span,t.sourceSpan,i,r,o):t}visitPipe(t,e){let i=t.exp.visit(this),r=this.visitAll(t.args);return i!==t.exp||r!==t.args?new R_(t.span,t.sourceSpan,i,t.name,r,t.nameSpan):t}visitKeyedRead(t,e){let i=t.receiver.visit(this),r=t.key.visit(this);return i!==t.receiver||r!==t.key?new I_(t.span,t.sourceSpan,i,r):t}visitKeyedWrite(t,e){let i=t.receiver.visit(this),r=t.key.visit(this),o=t.value.visit(this);return i!==t.receiver||r!==t.key||o!==t.value?new BC(t.span,t.sourceSpan,i,r,o):t}visitAll(t){let e=[],i=!1;for(let r=0;r<t.length;++r){let o=t[r],s=o.visit(this);e[r]=s,i=i||s!==o}return i?e:t}visitChain(t,e){let i=this.visitAll(t.expressions);return i!==t.expressions?new kC(t.span,t.sourceSpan,i):t}visitCall(t,e){let i=t.receiver.visit(this),r=this.visitAll(t.args);return i!==t.receiver||r!==t.args?new ah(t.span,t.sourceSpan,i,r,t.argumentSpan):t}visitSafeCall(t,e){let i=t.receiver.visit(this),r=this.visitAll(t.args);return i!==t.receiver||r!==t.args?new k_(t.span,t.sourceSpan,i,r,t.argumentSpan):t}visitSafeKeyedRead(t,e){let i=t.receiver.visit(this),r=t.key.visit(this);return i!==t.receiver||r!==t.key?new P_(t.span,t.sourceSpan,i,r):t}},pC=class{constructor(t,e,i,r,o,s){this.name=t,this.expression=e,this.type=i,this.sourceSpan=r,this.keySpan=o,this.valueSpan=s,this.isLiteral=this.type===ih.LITERAL_ATTR,this.isAnimation=this.type===ih.ANIMATION}},ih=(()=>{return(n=ih||(ih={}))[n.DEFAULT=0]="DEFAULT",n[n.LITERAL_ATTR=1]="LITERAL_ATTR",n[n.ANIMATION=2]="ANIMATION",ih;var n})(),hD=class{constructor(t,e,i,r,o,s,a){this.name=t,this.targetOrPhase=e,this.type=i,this.handler=r,this.sourceSpan=o,this.handlerSpan=s,this.keySpan=a}},eV=class{constructor(t,e,i,r,o){this.name=t,this.value=e,this.sourceSpan=i,this.keySpan=r,this.valueSpan=o}},fD=class{constructor(t,e,i,r,o,s,a,l){this.name=t,this.type=e,this.securityContext=i,this.value=r,this.unit=o,this.sourceSpan=s,this.keySpan=a,this.valueSpan=l}},jC=class{};function cSe(n,t,e,i,r,o,s){n||(n=new mD(s));let a=function(n,t){return function(n,t){let e=new iV(n);return t.visit(e)}(n,t)}({createLiteralArrayConverter:d=>p=>_r(p),createLiteralMapConverter:d=>p=>ql(d.map((f,m)=>({key:f.key,value:p[m],quoted:f.quoted}))),createPipeConverter:d=>{throw new Error(`Illegal State: Actions are not allowed to contain pipes. Pipe: ${d}`)}},e),l=new GC(n,t,i,!1,r,o),c=[];hK(a.visit(l,zi.Statement),c),function(n,t,e){for(let i=n-1;i>=0;i--)e.unshift(pK(t,i))}(l.temporaryCount,i,c),l.usesImplicitReceiver&&n.notifyImplicitReceiverUse();let u=c.length-1;if(u>=0){let d=c[u];d instanceof Hu&&(c[u]=new Do(d.expr))}return c}function uK(n,t,e,i){n||(n=new mD);let r=new GC(n,t,i,!1),o=e.visit(r,zi.Expression),s=dK(r,i);return r.usesImplicitReceiver&&n.notifyImplicitReceiverUse(),new class{constructor(t,e){this.stmts=t,this.currValExpr=e}}(s,o)}function dK(n,t){let e=[];for(let i=0;i<n.temporaryCount;i++)e.push(pK(t,i));return e}function nV(n,t){return`tmp_${n}_${t}`}function pK(n,t){return new Vu(nV(n,t))}jC.event=Ri("$event");var zi=(()=>{return(n=zi||(zi={}))[n.Statement=0]="Statement",n[n.Expression=1]="Expression",zi;var n})();function GX(n,t){if(n!==zi.Expression)throw new Error(`Expected an expression, but saw ${t}`)}function $s(n,t){return n===zi.Statement?t.toStmt():t}var iV=class extends JB{constructor(t){super(),this._converterFactory=t}visitPipe(t,e){let i=[t.exp,...t.args].map(r=>r.visit(this,e));return new rh(t.span,t.sourceSpan,i,this._converterFactory.createPipeConverter(t.name,i.length))}visitLiteralArray(t,e){let i=t.expressions.map(r=>r.visit(this,e));return new rh(t.span,t.sourceSpan,i,this._converterFactory.createLiteralArrayConverter(t.expressions.length))}visitLiteralMap(t,e){let i=t.values.map(r=>r.visit(this,e));return new rh(t.span,t.sourceSpan,i,this._converterFactory.createLiteralMapConverter(t.keys))}},GC=class{constructor(t,e,i,r,o,s){this._localResolver=t,this._implicitReceiver=e,this.bindingId=i,this.supportsInterpolation=r,this.baseSourceSpan=o,this.implicitReceiverAccesses=s,this._nodeMap=new Map,this._resultMap=new Map,this._currentTemporary=0,this.temporaryCount=0,this.usesImplicitReceiver=!1}visitUnary(t,e){let i;switch(t.operator){case"+":i=am.Plus;break;case"-":i=am.Minus;break;default:throw new Error(`Unsupported operator ${t.operator}`)}return $s(e,new CC(i,this._visit(t.expr,zi.Expression),void 0,this.convertSourceSpan(t.span)))}visitBinary(t,e){let i;switch(t.operation){case"+":i=Cn.Plus;break;case"-":i=Cn.Minus;break;case"*":i=Cn.Multiply;break;case"/":i=Cn.Divide;break;case"%":i=Cn.Modulo;break;case"&&":i=Cn.And;break;case"||":i=Cn.Or;break;case"==":i=Cn.Equals;break;case"!=":i=Cn.NotEquals;break;case"===":i=Cn.Identical;break;case"!==":i=Cn.NotIdentical;break;case"<":i=Cn.Lower;break;case">":i=Cn.Bigger;break;case"<=":i=Cn.LowerEquals;break;case">=":i=Cn.BiggerEquals;break;case"??":return this.convertNullishCoalesce(t,e);default:throw new Error(`Unsupported operation ${t.operation}`)}return $s(e,new gr(i,this._visit(t.left,zi.Expression),this._visit(t.right,zi.Expression),void 0,this.convertSourceSpan(t.span)))}visitChain(t,e){return function(n,t){if(n!==zi.Statement)throw new Error(`Expected a statement, but saw ${t}`)}(e,t),this.visitAll(t.expressions,e)}visitConditional(t,e){return $s(e,this._visit(t.condition,zi.Expression).conditional(this._visit(t.trueExp,zi.Expression),this._visit(t.falseExp,zi.Expression),this.convertSourceSpan(t.span)))}visitPipe(t,e){throw new Error(`Illegal state: Pipes should have been converted into functions. Pipe: ${t.name}`)}visitImplicitReceiver(t,e){return GX(e,t),this.usesImplicitReceiver=!0,this._implicitReceiver}visitThisReceiver(t,e){return this.visitImplicitReceiver(t,e)}visitInterpolation(t,e){if(!this.supportsInterpolation)throw new Error("Unexpected interpolation");GX(e,t);let i=[];for(let o=0;o<t.strings.length-1;o++)i.push(ht(t.strings[o])),i.push(this._visit(t.expressions[o],zi.Expression));i.push(ht(t.strings[t.strings.length-1]));let r=t.strings;return 2===r.length&&""===r[0]&&""===r[1]?i=[i[1]]:t.expressions.length>=9&&(i=[_r(i)]),new rV(i)}visitKeyedRead(t,e){let i=this.leftMostSafeNode(t);return i?this.convertSafeAccess(t,i,e):$s(e,this._visit(t.receiver,zi.Expression).key(this._visit(t.key,zi.Expression)))}visitKeyedWrite(t,e){let i=this._visit(t.receiver,zi.Expression),r=this._visit(t.key,zi.Expression),o=this._visit(t.value,zi.Expression);return i===this._implicitReceiver&&this._localResolver.maybeRestoreView(),$s(e,i.key(r).set(o))}visitLiteralArray(t,e){throw new Error("Illegal State: literal arrays should have been converted into functions")}visitLiteralMap(t,e){throw new Error("Illegal State: literal maps should have been converted into functions")}visitLiteralPrimitive(t,e){return $s(e,ht(t.value,null==t.value||!0===t.value||!0===t.value?Pa:void 0,this.convertSourceSpan(t.span)))}_getLocal(t,e){return this._localResolver.globals?.has(t)&&e instanceof OC?null:this._localResolver.getLocal(t)}visitPrefixNot(t,e){return $s(e,function(n,t){return new xC(n,void 0)}(this._visit(t.expression,zi.Expression)))}visitNonNullAssert(t,e){return $s(e,this._visit(t.expression,zi.Expression))}visitPropertyRead(t,e){let i=this.leftMostSafeNode(t);if(i)return this.convertSafeAccess(t,i,e);{let r=null,o=this.usesImplicitReceiver,s=this._visit(t.receiver,zi.Expression);return s===this._implicitReceiver&&(r=this._getLocal(t.name,t.receiver),r&&(this.usesImplicitReceiver=o,this.addImplicitReceiverAccess(t.name))),null==r&&(r=s.prop(t.name,this.convertSourceSpan(t.span))),$s(e,r)}}visitPropertyWrite(t,e){let i=this._visit(t.receiver,zi.Expression),r=this.usesImplicitReceiver,o=null;if(i===this._implicitReceiver){let s=this._getLocal(t.name,t.receiver);if(s){if(!(s instanceof b_))throw new Error(`Cannot assign value "${t.value instanceof Lu?t.value.name:void 0}" to template variable "${t.name}". Template variables are read-only.`);o=s,this.usesImplicitReceiver=r,this.addImplicitReceiverAccess(t.name)}}return null===o&&(o=i.prop(t.name,this.convertSourceSpan(t.span))),$s(e,o.set(this._visit(t.value,zi.Expression)))}visitSafePropertyRead(t,e){return this.convertSafeAccess(t,this.leftMostSafeNode(t),e)}visitSafeKeyedRead(t,e){return this.convertSafeAccess(t,this.leftMostSafeNode(t),e)}visitAll(t,e){return t.map(i=>this._visit(i,e))}visitCall(t,e){let i=this.leftMostSafeNode(t);if(i)return this.convertSafeAccess(t,i,e);let r=this.visitAll(t.args,zi.Expression);if(t instanceof rh)return $s(e,t.converter(r));let o=t.receiver;if(o instanceof Lu&&o.receiver instanceof xm&&!(o.receiver instanceof OC)&&"$any"===o.name){if(1!==r.length)throw new Error(`Invalid call to $any, expected 1 argument but received ${r.length||"none"}`);return $s(e,r[0])}return $s(e,this._visit(o,zi.Expression).callFn(r,this.convertSourceSpan(t.span)))}visitSafeCall(t,e){return this.convertSafeAccess(t,this.leftMostSafeNode(t),e)}_visit(t,e){return this._resultMap.get(t)||(this._nodeMap.get(t)||t).visit(this,e)}convertSafeAccess(t,e,i){let o,r=this._visit(e.receiver,zi.Expression);this.needsTemporaryInSafeAccess(e.receiver)&&(o=this.allocateTemporary(),r=o.set(r),this._resultMap.set(e.receiver,o));let s=r.isBlank();this._nodeMap.set(e,e instanceof k_?new ah(e.span,e.sourceSpan,e.receiver,e.args,e.argumentSpan):e instanceof P_?new I_(e.span,e.sourceSpan,e.receiver,e.key):new Lu(e.span,e.sourceSpan,e.nameSpan,e.receiver,e.name));let a=this._visit(t,zi.Expression);return this._nodeMap.delete(e),o&&this.releaseTemporary(o),$s(i,s.conditional(PB,a))}convertNullishCoalesce(t,e){let i=this._visit(t.left,zi.Expression),r=this._visit(t.right,zi.Expression),o=this.allocateTemporary();return this.releaseTemporary(o),$s(e,o.set(i).notIdentical(PB).and(o.notIdentical(ht(void 0))).conditional(o,r))}leftMostSafeNode(t){let e=(i,r)=>(this._nodeMap.get(r)||r).visit(i);return t.visit({visitUnary:i=>null,visitBinary:i=>null,visitChain:i=>null,visitConditional:i=>null,visitCall(i){return e(this,i.receiver)},visitSafeCall(i){return e(this,i.receiver)||i},visitImplicitReceiver:i=>null,visitThisReceiver:i=>null,visitInterpolation:i=>null,visitKeyedRead(i){return e(this,i.receiver)},visitKeyedWrite:i=>null,visitLiteralArray:i=>null,visitLiteralMap:i=>null,visitLiteralPrimitive:i=>null,visitPipe:i=>null,visitPrefixNot:i=>null,visitNonNullAssert:i=>null,visitPropertyRead(i){return e(this,i.receiver)},visitPropertyWrite:i=>null,visitSafePropertyRead(i){return e(this,i.receiver)||i},visitSafeKeyedRead(i){return e(this,i.receiver)||i}})}needsTemporaryInSafeAccess(t){let e=(r,o)=>o&&(this._nodeMap.get(o)||o).visit(r);return t.visit({visitUnary(r){return e(this,r.expr)},visitBinary(r){return e(this,r.left)||e(this,r.right)},visitChain:r=>!1,visitConditional(r){return e(this,r.condition)||e(this,r.trueExp)||e(this,r.falseExp)},visitCall:r=>!0,visitSafeCall:r=>!0,visitImplicitReceiver:r=>!1,visitThisReceiver:r=>!1,visitInterpolation(r){return((r,o)=>o.some(s=>e(r,s)))(this,r.expressions)},visitKeyedRead:r=>!1,visitKeyedWrite:r=>!1,visitLiteralArray:r=>!0,visitLiteralMap:r=>!0,visitLiteralPrimitive:r=>!1,visitPipe:r=>!0,visitPrefixNot(r){return e(this,r.expression)},visitNonNullAssert(r){return e(this,r.expression)},visitPropertyRead:r=>!1,visitPropertyWrite:r=>!1,visitSafePropertyRead:r=>!1,visitSafeKeyedRead:r=>!1})}allocateTemporary(){let t=this._currentTemporary++;return this.temporaryCount=Math.max(this._currentTemporary,this.temporaryCount),new um(nV(this.bindingId,t))}releaseTemporary(t){if(this._currentTemporary--,t.name!=nV(this.bindingId,this._currentTemporary))throw new Error(`Temporary ${t.name} released out of order`)}convertSourceSpan(t){if(this.baseSourceSpan){let e=this.baseSourceSpan.start.moveBy(t.start),i=this.baseSourceSpan.start.moveBy(t.end),r=this.baseSourceSpan.fullStart.moveBy(t.start);return new Go(e,i,r)}return null}addImplicitReceiverAccess(t){this.implicitReceiverAccesses&&this.implicitReceiverAccesses.add(t)}};function hK(n,t){Array.isArray(n)?n.forEach(e=>hK(e,t)):t.push(n)}function lB(){throw new Error("Unsupported operation")}var rV=class extends Or{constructor(t){super(null,null),this.args=t,this.isConstant=lB,this.isEquivalent=lB,this.visitExpression=lB}},mD=class{constructor(t){this.globals=t}notifyImplicitReceiverUse(){}maybeRestoreView(){}getLocal(t){return t===jC.event.name?jC.event:null}},rh=class extends ah{constructor(t,e,i,r){super(t,e,new Ia(t,e),i,null),this.converter=r}},mSe=/polyfill-next-selector[^}]*content:[\s]*?(['"])(.*?)\1[;\s]*}([^{]*?){/gim,gSe=/(polyfill-rule)[^}]*(content:[\s]*(['"])(.*?)\3)[;\s]*[^}]*}/gim,WX=/(polyfill-unscoped-rule)[^}]*(content:[\s]*(['"])(.*?)\3)[;\s]*[^}]*}/gim,gD="-shadowcsshost",ZV="-shadowcsscontext",JV="(?:\\(((?:\\([^)(]*\\)|[^)(]*)+?)\\))?([^,{]*)",_Se=new RegExp(gD+JV,"gim"),vSe=new RegExp(ZV+JV,"gim"),ySe=new RegExp(ZV+JV,"im"),tm=gD+"-no-combinator",qX=/-shadowcsshost-no-combinator([^\s]*)/,bSe=[/::shadow/g,/::content/g,/\/shadow-deep\//g,/\/shadow\//g],YX=/(?:>>>)|(?:\/deep\/)|(?:::ng-deep)/g,d_=/-shadowcsshost/gim,CSe=/:host/gim,MSe=/:host-context/gim,wSe=/\/\*[\s\S]*?\*\//g,ESe=/\/\*\s*#\s*source(Mapping)?URL=[\s\S]+?\*\//g,cB="%BLOCK%",ASe=/(\s*)([^;\{\}]+?)(\s*)((?:{%BLOCK%}?\s*;?)|(?:\s*;))/g,ISe=/%QUOTED%/g,PSe=new Map([["{","}"]]),RSe=new Map([['"','"'],["'","'"]]),WC=class{constructor(t,e){this.selector=t,this.content=e}};function XX(n,t){let e=QX(n,RSe,"%QUOTED%"),i=QX(e.escapedString,PSe,cB),r=0,o=0;return i.escapedString.replace(ASe,(...s)=>{let a=s[2],l="",c=s[4],u="";c&&c.startsWith("{"+cB)&&(l=i.blocks[r++],c=c.substring(cB.length+1),u="{");let d=t(new WC(a,l));return`${s[1]}${d.selector}${s[3]}${u}${d.content}${c}`}).replace(ISe,()=>e.blocks[o++])}function QX(n,t,e){let l,c,i=[],r=[],o=0,s=0,a=-1;for(let u=0;u<n.length;u++){let d=n[u];"\\"===d?u++:d===c?(o--,0===o&&(r.push(n.substring(a,u)),i.push(e),s=u,a=-1,l=c=void 0)):d===l?o++:0===o&&t.has(d)&&(l=d,c=t.get(d),o=1,a=u+1,i.push(n.substring(s,a)))}return-1!==a?(r.push(n.substring(a)),i.push(e)):i.push(n.substring(s)),new class{constructor(t,e){this.escapedString=t,this.blocks=e}}(i.join(""),r)}function kSe(n,t){let e=n.length;for(let i=1;i<t;i++)for(let r=0;r<e;r++)n[r+i*e]=n[r].slice(0)}function KX(n){let t=n.charCodeAt(0);if(t==n.charCodeAt(n.length-1)&&(39==t||34==t)){let i=n.substring(1,n.length-1);-1==i.indexOf("'")&&-1==i.indexOf('"')&&(n=i)}return n}function fK(n){return n.replace(/[a-z][A-Z]/g,t=>t.charAt(0)+"-"+t.charAt(1)).toLowerCase()}var vD=class{constructor(t){this._directiveExpr=t,this._hasInitialValues=!1,this.hasBindings=!1,this.hasBindingsWithPipes=!1,this._classMapInput=null,this._styleMapInput=null,this._singleStyleInputs=null,this._singleClassInputs=null,this._lastStylingInput=null,this._firstStylingInput=null,this._stylesIndex=new Map,this._classesIndex=new Map,this._initialStyleValues=[],this._initialClassValues=[]}registerBoundInput(t){let e=null,i=t.name;switch(t.type){case 0:e=this.registerInputBasedOnName(i,t.value,t.sourceSpan);break;case 3:e=this.registerStyleInput(i,!1,t.value,t.sourceSpan,t.unit);break;case 2:e=this.registerClassInput(i,!1,t.value,t.sourceSpan)}return!!e}registerInputBasedOnName(t,e,i){let r=null,o=t.substring(0,6),s="style"===t||"style."===o||"style!"===o;if(s||!s&&("class"===t||"class."===o||"class!"===o)){let l="."!==t.charAt(5),c=t.slice(l?5:6);r=s?this.registerStyleInput(c,l,e,i):this.registerClassInput(c,l,e,i)}return r}registerStyleInput(t,e,i,r,o){if($X(i))return null;t.startsWith("--")||(t=fK(t));let{property:s,hasOverrideFlag:a,suffix:l}=JX(t),c={name:s,suffix:o="string"==typeof o&&0!==o.length?o:l,value:i,sourceSpan:r,hasOverrideFlag:a};return e?this._styleMapInput=c:((this._singleStyleInputs=this._singleStyleInputs||[]).push(c),ZX(this._stylesIndex,s)),this._lastStylingInput=c,this._firstStylingInput=this._firstStylingInput||c,this._checkForPipes(i),this.hasBindings=!0,c}registerClassInput(t,e,i,r){if($X(i))return null;let{property:o,hasOverrideFlag:s}=JX(t),a={name:o,value:i,sourceSpan:r,hasOverrideFlag:s,suffix:null};return e?this._classMapInput=a:((this._singleClassInputs=this._singleClassInputs||[]).push(a),ZX(this._classesIndex,o)),this._lastStylingInput=a,this._firstStylingInput=this._firstStylingInput||a,this._checkForPipes(i),this.hasBindings=!0,a}_checkForPipes(t){t instanceof Ru&&t.ast instanceof R_&&(this.hasBindingsWithPipes=!0)}registerStyleAttr(t){this._initialStyleValues=function(n){let t=[],e=0,i=0,r=0,o=0,s=0,a=null,l=!1;for(;e<n.length;)switch(n.charCodeAt(e++)){case 40:i++;break;case 41:i--;break;case 39:l=l||o>0,0===r?r=39:39===r&&92!==n.charCodeAt(e-1)&&(r=0);break;case 34:l=l||o>0,0===r?r=34:34===r&&92!==n.charCodeAt(e-1)&&(r=0);break;case 58:!a&&0===i&&0===r&&(a=fK(n.substring(s,e-1).trim()),o=e);break;case 59:if(a&&o>0&&0===i&&0===r){let u=n.substring(o,e-1).trim();t.push(a,l?KX(u):u),s=e,o=0,a=null,l=!1}}if(a&&o){let c=n.slice(o).trim();t.push(a,l?KX(c):c)}return t}(t),this._hasInitialValues=!0}registerClassAttr(t){this._initialClassValues=t.trim().split(/\s+/g),this._hasInitialValues=!0}populateInitialStylingAttrs(t){if(this._initialClassValues.length){t.push(ht(1));for(let e=0;e<this._initialClassValues.length;e++)t.push(ht(this._initialClassValues[e]))}if(this._initialStyleValues.length){t.push(ht(2));for(let e=0;e<this._initialStyleValues.length;e+=2)t.push(ht(this._initialStyleValues[e]),ht(this._initialStyleValues[e+1]))}}assignHostAttrs(t,e){this._directiveExpr&&(t.length||this._hasInitialValues)&&(this.populateInitialStylingAttrs(t),e.set("hostAttrs",_r(t)))}buildClassMapInstruction(t){return this._classMapInput?this._buildMapBasedInstruction(t,!0,this._classMapInput):null}buildStyleMapInstruction(t){return this._styleMapInput?this._buildMapBasedInstruction(t,!1,this._styleMapInput):null}_buildMapBasedInstruction(t,e,i){let s,r=2,o=i.value.visit(t);return o instanceof vs?(r+=o.expressions.length,s=e?function(n){switch(wm(n)){case 1:return te.classMap;case 3:return te.classMapInterpolate1;case 5:return te.classMapInterpolate2;case 7:return te.classMapInterpolate3;case 9:return te.classMapInterpolate4;case 11:return te.classMapInterpolate5;case 13:return te.classMapInterpolate6;case 15:return te.classMapInterpolate7;case 17:return te.classMapInterpolate8;default:return te.classMapInterpolateV}}(o):function(n){switch(wm(n)){case 1:return te.styleMap;case 3:return te.styleMapInterpolate1;case 5:return te.styleMapInterpolate2;case 7:return te.styleMapInterpolate3;case 9:return te.styleMapInterpolate4;case 11:return te.styleMapInterpolate5;case 13:return te.styleMapInterpolate6;case 15:return te.styleMapInterpolate7;case 17:return te.styleMapInterpolate8;default:return te.styleMapInterpolateV}}(o)):s=e?te.classMap:te.styleMap,{reference:s,calls:[{supportsInterpolation:!0,sourceSpan:i.sourceSpan,allocateBindingSlots:r,params:a=>{let l=a(o);return Array.isArray(l)?l:[l]}}]}}_buildSingleInputs(t,e,i,r,o){let s=[];return e.forEach(a=>{let l=s[s.length-1],c=a.value.visit(i),u=t,d=2;c instanceof vs&&(d+=c.expressions.length,r&&(u=r(c)));let p={sourceSpan:a.sourceSpan,allocateBindingSlots:d,supportsInterpolation:!!r,params:h=>{let f=[];f.push(ht(a.name));let m=h(c);return Array.isArray(m)?f.push(...m):f.push(m),!o&&null!==a.suffix&&f.push(ht(a.suffix)),f}};l&&l.reference===u?l.calls.push(p):s.push({reference:u,calls:[p]})}),s}_buildClassInputs(t){return this._singleClassInputs?this._buildSingleInputs(te.classProp,this._singleClassInputs,t,null,!0):[]}_buildStyleInputs(t){return this._singleStyleInputs?this._buildSingleInputs(te.styleProp,this._singleStyleInputs,t,VSe,!1):[]}buildUpdateLevelInstructions(t){let e=[];if(this.hasBindings){let i=this.buildStyleMapInstruction(t);i&&e.push(i);let r=this.buildClassMapInstruction(t);r&&e.push(r),e.push(...this._buildStyleInputs(t)),e.push(...this._buildClassInputs(t))}return e}};function ZX(n,t){n.has(t)||n.set(t,n.size)}function JX(n){let t=!1,e=n.indexOf("!important");-1!==e&&(n=e>0?n.substring(0,e):"",t=!0);let i=null,r=n,o=n.lastIndexOf(".");return o>0&&(i=n.slice(o+1),r=n.substring(0,o)),{property:r,suffix:i,hasOverrideFlag:t}}function VSe(n){switch(wm(n)){case 1:return te.styleProp;case 3:return te.stylePropInterpolate1;case 5:return te.stylePropInterpolate2;case 7:return te.stylePropInterpolate3;case 9:return te.stylePropInterpolate4;case 11:return te.stylePropInterpolate5;case 13:return te.stylePropInterpolate6;case 15:return te.stylePropInterpolate7;case 17:return te.stylePropInterpolate8;default:return te.stylePropInterpolateV}}function $X(n){return n instanceof Ru&&(n=n.ast),n instanceof Ia}var ni=(()=>{return(n=ni||(ni={}))[n.Character=0]="Character",n[n.Identifier=1]="Identifier",n[n.PrivateIdentifier=2]="PrivateIdentifier",n[n.Keyword=3]="Keyword",n[n.String=4]="String",n[n.Operator=5]="Operator",n[n.Number=6]="Number",n[n.Error=7]="Error",ni;var n})(),USe=["var","let","as","null","undefined","true","false","if","else","this"],yD=class{tokenize(t){let e=new lV(t),i=[],r=e.scanToken();for(;null!=r;)i.push(r),r=e.scanToken();return i}},jc=class{constructor(t,e,i,r,o){this.index=t,this.end=e,this.type=i,this.numValue=r,this.strValue=o}isCharacter(t){return this.type==ni.Character&&this.numValue==t}isNumber(){return this.type==ni.Number}isString(){return this.type==ni.String}isOperator(t){return this.type==ni.Operator&&this.strValue==t}isIdentifier(){return this.type==ni.Identifier}isPrivateIdentifier(){return this.type==ni.PrivateIdentifier}isKeyword(){return this.type==ni.Keyword}isKeywordLet(){return this.type==ni.Keyword&&"let"==this.strValue}isKeywordAs(){return this.type==ni.Keyword&&"as"==this.strValue}isKeywordNull(){return this.type==ni.Keyword&&"null"==this.strValue}isKeywordUndefined(){return this.type==ni.Keyword&&"undefined"==this.strValue}isKeywordTrue(){return this.type==ni.Keyword&&"true"==this.strValue}isKeywordFalse(){return this.type==ni.Keyword&&"false"==this.strValue}isKeywordThis(){return this.type==ni.Keyword&&"this"==this.strValue}isError(){return this.type==ni.Error}toNumber(){return this.type==ni.Number?this.numValue:-1}toString(){switch(this.type){case ni.Character:case ni.Identifier:case ni.Keyword:case ni.Operator:case ni.PrivateIdentifier:case ni.String:case ni.Error:return this.strValue;case ni.Number:return this.numValue.toString();default:return null}}};function eQ(n,t,e){return new jc(n,t,ni.Character,e,String.fromCharCode(e))}function uB(n,t,e){return new jc(n,t,ni.Operator,0,e)}var dB=new jc(-1,-1,ni.Character,0,""),lV=class{constructor(t){this.input=t,this.peek=0,this.index=-1,this.length=t.length,this.advance()}advance(){this.peek=++this.index>=this.length?0:this.input.charCodeAt(this.index)}scanToken(){let t=this.input,e=this.length,i=this.peek,r=this.index;for(;i<=32;){if(++r>=e){i=0;break}i=t.charCodeAt(r)}if(this.peek=i,this.index=r,r>=e)return null;if(tQ(i))return this.scanIdentifier();if($p(i))return this.scanNumber(r);let o=r;switch(i){case 46:return this.advance(),$p(this.peek)?this.scanNumber(o):eQ(o,this.index,46);case 40:case 41:case th:case Ou:case 91:case 93:case 44:case 58:case 59:return this.scanCharacter(o,i);case 39:case 34:return this.scanString();case 35:return this.scanPrivateIdentifier();case 43:case 45:case 42:case 47:case 37:case 94:return this.scanOperator(o,String.fromCharCode(i));case 63:return this.scanQuestion(o);case 60:case 62:return this.scanComplexOperator(o,String.fromCharCode(i),61,"=");case 33:case 61:return this.scanComplexOperator(o,String.fromCharCode(i),61,"=",61,"=");case 38:return this.scanComplexOperator(o,"&",38,"&");case 124:return this.scanComplexOperator(o,"|",124,"|");case 160:for(;QV(this.peek);)this.advance();return this.scanToken()}return this.advance(),this.error(`Unexpected character [${String.fromCharCode(i)}]`,0)}scanCharacter(t,e){return this.advance(),eQ(t,this.index,e)}scanOperator(t,e){return this.advance(),uB(t,this.index,e)}scanComplexOperator(t,e,i,r,o,s){this.advance();let a=e;return this.peek==i&&(this.advance(),a+=r),null!=o&&this.peek==o&&(this.advance(),a+=s),uB(t,this.index,a)}scanIdentifier(){let t=this.index;for(this.advance();nQ(this.peek);)this.advance();let e=this.input.substring(t,this.index);return USe.indexOf(e)>-1?function(n,t,e){return new jc(n,t,ni.Keyword,0,e)}(t,this.index,e):function(n,t,e){return new jc(n,t,ni.Identifier,0,e)}(t,this.index,e)}scanPrivateIdentifier(){let t=this.index;if(this.advance(),!tQ(this.peek))return this.error("Invalid character [#]",-1);for(;nQ(this.peek);)this.advance();let e=this.input.substring(t,this.index);return function(n,t,e){return new jc(n,t,ni.PrivateIdentifier,0,e)}(t,this.index,e)}scanNumber(t){let e=this.index===t,i=!1;for(this.advance();;){if(!$p(this.peek))if(95===this.peek){if(!$p(this.input.charCodeAt(this.index-1))||!$p(this.input.charCodeAt(this.index+1)))return this.error("Invalid numeric separator",0);i=!0}else if(46===this.peek)e=!1;else{if(101!=(n=this.peek)&&69!=n)break;if(this.advance(),QSe(this.peek)&&this.advance(),!$p(this.peek))return this.error("Invalid exponent",-1);e=!1}this.advance()}var n;let r=this.input.substring(t,this.index);i&&(r=r.replace(/_/g,""));let o=e?function(n){let t=parseInt(n);if(isNaN(t))throw new Error("Invalid integer literal when parsing "+n);return t}(r):parseFloat(r);return function(n,t,e){return new jc(n,t,ni.Number,e,"")}(t,this.index,o)}scanString(){let t=this.index,e=this.peek;this.advance();let i="",r=this.index,o=this.input;for(;this.peek!=e;)if(92==this.peek){let a;if(i+=o.substring(r,this.index),this.advance(),this.peek=this.peek,117==this.peek){let l=o.substring(this.index+1,this.index+5);if(!/^[0-9a-f]+$/i.test(l))return this.error(`Invalid unicode escape [\\u${l}]`,0);a=parseInt(l,16);for(let c=0;c<5;c++)this.advance()}else a=KSe(this.peek),this.advance();i+=String.fromCharCode(a),r=this.index}else{if(0==this.peek)return this.error("Unterminated quote",0);this.advance()}let s=o.substring(r,this.index);return this.advance(),function(n,t,e){return new jc(n,t,ni.String,0,e)}(t,this.index,i+s)}scanQuestion(t){this.advance();let e="?";return(63===this.peek||46===this.peek)&&(e+=46===this.peek?".":"?",this.advance()),uB(t,this.index,e)}error(t,e){let i=this.index+e;return function(n,t,e){return new jc(n,t,ni.Error,0,e)}(i,this.index,`Lexer Error: ${t} at column ${i} in expression [${this.input}]`)}};function tQ(n){return 97<=n&&n<=122||65<=n&&n<=90||95==n||36==n}function nQ(n){return KV(n)||$p(n)||95==n||36==n}function QSe(n){return 45==n||43==n}function KSe(n){switch(n){case 110:return 10;case 102:return 12;case 114:return 13;case 116:return 9;case 118:return 11;default:return n}}var bD=class{constructor(t){this._lexer=t,this.errors=[]}parseAction(t,e,i,r,o=Pu){this._checkNoInterpolation(t,i,o);let s=this._stripComments(t),a=this._lexer.tokenize(s),l=1;e&&(l|=2);let c=new im(t,i,r,a,l,this.errors,0).parseChain();return new Ru(c,t,i,r,this.errors)}parseBinding(t,e,i,r=Pu){let o=this._parseBindingAst(t,e,i,r);return new Ru(o,t,e,i,this.errors)}checkSimpleExpression(t){let e=new dV;return t.visit(e),e.errors}parseSimpleBinding(t,e,i,r=Pu){let o=this._parseBindingAst(t,e,i,r),s=this.checkSimpleExpression(o);return s.length>0&&this._reportError(`Host binding expression cannot contain ${s.join(" ")}`,t,e),new Ru(o,t,e,i,this.errors)}_reportError(t,e,i,r){this.errors.push(new RC(t,e,i,r))}_parseBindingAst(t,e,i,r){this._checkNoInterpolation(t,e,r);let o=this._stripComments(t),s=this._lexer.tokenize(o);return new im(t,e,i,s,0,this.errors,0).parseChain()}parseTemplateBindings(t,e,i,r,o){let s=this._lexer.tokenize(e);return new im(e,i,o,s,0,this.errors,0).parseTemplateBindings({source:t,span:new al(r,r+t.length)})}parseInterpolation(t,e,i,r,o=Pu){let{strings:s,expressions:a,offsets:l}=this.splitInterpolation(t,e,r,o);if(0===a.length)return null;let c=[];for(let u=0;u<a.length;++u){let p=this._stripComments(a[u].text),h=this._lexer.tokenize(p),f=new im(t,e,i,h,0,this.errors,l[u]).parseChain();c.push(f)}return this.createInterpolationAst(s.map(u=>u.text),c,t,e,i)}parseInterpolationExpression(t,e,i){let r=this._stripComments(t),o=this._lexer.tokenize(r),s=new im(t,e,i,o,0,this.errors,0).parseChain();return this.createInterpolationAst(["",""],[s],t,e,i)}createInterpolationAst(t,e,i,r,o){let s=new bm(0,i.length),a=new vs(s,s.toAbsolute(o),t,e);return new Ru(a,i,r,o,this.errors)}splitInterpolation(t,e,i,r=Pu){let o=[],s=[],a=[],l=i?function(n){let t=new Map,e=0,i=0,r=0;for(;r<n.length;){let o=n[r];if(9===o.type){let[s,a]=o.parts;e+=a.length,i+=s.length}else{let s=o.parts.reduce((a,l)=>a+l.length,0);i+=s,e+=s}t.set(i,e),r++}return t}(i):null,c=0,u=!1,d=!1,{start:p,end:h}=r;for(;c<t.length;)if(u){let f=c,m=f+p.length,x=this._getInterpolationEndIndex(t,h,m);if(-1===x){u=!1,d=!0;break}let g=x+h.length,b=t.substring(m,x);0===b.trim().length&&this._reportError("Blank expressions are not allowed in interpolated strings",t,`at column ${c} in`,e),s.push({text:b,start:f,end:g});let T=(l?.get(f)??f)+p.length;a.push(T),c=g,u=!1}else{let f=c;c=t.indexOf(p,c),-1===c&&(c=t.length);let m=t.substring(f,c);o.push({text:m,start:f,end:c}),u=!0}if(!u)if(d){let f=o[o.length-1];f.text+=t.substring(c),f.end=t.length}else o.push({text:t.substring(c),start:c,end:t.length});return new class{constructor(t,e,i){this.strings=t,this.expressions=e,this.offsets=i}}(o,s,a)}wrapLiteralPrimitive(t,e,i){let r=new bm(0,null==t?0:t.length);return new Ru(new ta(r,r.toAbsolute(i),t),t,e,i,this.errors)}_stripComments(t){let e=this._commentStart(t);return null!=e?t.substring(0,e):t}_commentStart(t){let e=null;for(let i=0;i<t.length-1;i++){let r=t.charCodeAt(i),o=t.charCodeAt(i+1);if(47===r&&47==o&&null==e)return i;e===r?e=null:null==e&&WB(r)&&(e=r)}return null}_checkNoInterpolation(t,e,{start:i,end:r}){let o=-1,s=-1;for(let a of this._forEachUnquotedChar(t,0))if(-1===o)t.startsWith(i)&&(o=a);else if(s=this._getInterpolationEndIndex(t,r,a),s>-1)break;o>-1&&s>-1&&this._reportError(`Got interpolation (${i}${r}) where expression was expected`,t,`at column ${o} in`,e)}_getInterpolationEndIndex(t,e,i){for(let r of this._forEachUnquotedChar(t,i)){if(t.startsWith(e,r))return r;if(t.startsWith("//",r))return t.indexOf(e,r)}return-1}*_forEachUnquotedChar(t,e){let i=null,r=0;for(let o=e;o<t.length;o++){let s=t[o];!WB(t.charCodeAt(o))||null!==i&&i!==s||r%2!=0?null===i&&(yield o):i=null===i?s:null,r="\\"===s?r+1:0}}},sm=(()=>{return(n=sm||(sm={}))[n.None=0]="None",n[n.Writable=1]="Writable",sm;var n})(),im=class{constructor(t,e,i,r,o,s,a){this.input=t,this.location=e,this.absoluteOffset=i,this.tokens=r,this.parseFlags=o,this.errors=s,this.offset=a,this.rparensExpected=0,this.rbracketsExpected=0,this.rbracesExpected=0,this.context=sm.None,this.sourceSpanCache=new Map,this.index=0}peek(t){let e=this.index+t;return e<this.tokens.length?this.tokens[e]:dB}get next(){return this.peek(0)}get atEOF(){return this.index>=this.tokens.length}get inputIndex(){return this.atEOF?this.currentEndIndex:this.next.index+this.offset}get currentEndIndex(){return this.index>0?this.peek(-1).end+this.offset:0===this.tokens.length?this.input.length+this.offset:this.next.index+this.offset}get currentAbsoluteOffset(){return this.absoluteOffset+this.inputIndex}span(t,e){let i=this.currentEndIndex;if(void 0!==e&&e>this.currentEndIndex&&(i=e),t>i){let r=i;i=t,t=r}return new bm(t,i)}sourceSpan(t,e){let i=`${t}@${this.inputIndex}:${e}`;return this.sourceSpanCache.has(i)||this.sourceSpanCache.set(i,this.span(t,e).toAbsolute(this.absoluteOffset)),this.sourceSpanCache.get(i)}advance(){this.index++}withContext(t,e){this.context|=t;let i=e();return this.context^=t,i}consumeOptionalCharacter(t){return!!this.next.isCharacter(t)&&(this.advance(),!0)}peekKeywordLet(){return this.next.isKeywordLet()}peekKeywordAs(){return this.next.isKeywordAs()}expectCharacter(t){this.consumeOptionalCharacter(t)||this.error(`Missing expected ${String.fromCharCode(t)}`)}consumeOptionalOperator(t){return!!this.next.isOperator(t)&&(this.advance(),!0)}expectOperator(t){this.consumeOptionalOperator(t)||this.error(`Missing expected operator ${t}`)}prettyPrintToken(t){return t===dB?"end of input":`token ${t}`}expectIdentifierOrKeyword(){let t=this.next;return t.isIdentifier()||t.isKeyword()?(this.advance(),t.toString()):(t.isPrivateIdentifier()?this._reportErrorForPrivateIdentifier(t,"expected identifier or keyword"):this.error(`Unexpected ${this.prettyPrintToken(t)}, expected identifier or keyword`),null)}expectIdentifierOrKeywordOrString(){let t=this.next;return t.isIdentifier()||t.isKeyword()||t.isString()?(this.advance(),t.toString()):(t.isPrivateIdentifier()?this._reportErrorForPrivateIdentifier(t,"expected identifier, keyword or string"):this.error(`Unexpected ${this.prettyPrintToken(t)}, expected identifier, keyword, or string`),"")}parseChain(){let t=[],e=this.inputIndex;for(;this.index<this.tokens.length;){let i=this.parsePipe();if(t.push(i),this.consumeOptionalCharacter(59))for(1&this.parseFlags||this.error("Binding expression cannot contain chained expression");this.consumeOptionalCharacter(59););else if(this.index<this.tokens.length){let r=this.index;if(this.error(`Unexpected token '${this.next}'`),this.index===r)break}}if(0===t.length){let i=this.offset,r=this.offset+this.input.length;return new Ia(this.span(i,r),this.sourceSpan(i,r))}return 1==t.length?t[0]:new kC(this.span(e),this.sourceSpan(e),t)}parsePipe(){let t=this.inputIndex,e=this.parseExpression();if(this.consumeOptionalOperator("|")){1&this.parseFlags&&this.error("Cannot have a pipe in an action expression");do{let o,s,i=this.inputIndex,r=this.expectIdentifierOrKeyword();null!==r?o=this.sourceSpan(i):(r="",s=-1!==this.next.index?this.next.index:this.input.length+this.offset,o=new bm(s,s).toAbsolute(this.absoluteOffset));let a=[];for(;this.consumeOptionalCharacter(58);)a.push(this.parseExpression());e=new R_(this.span(t),this.sourceSpan(t,s),e,r,a,o)}while(this.consumeOptionalOperator("|"))}return e}parseExpression(){return this.parseConditional()}parseConditional(){let t=this.inputIndex,e=this.parseLogicalOr();if(this.consumeOptionalOperator("?")){let r,i=this.parsePipe();if(this.consumeOptionalCharacter(58))r=this.parsePipe();else{let s=this.input.substring(t,this.inputIndex);this.error(`Conditional expression ${s} requires all 3 expressions`),r=new Ia(this.span(t),this.sourceSpan(t))}return new FC(this.span(t),this.sourceSpan(t),e,i,r)}return e}parseLogicalOr(){let t=this.inputIndex,e=this.parseLogicalAnd();for(;this.consumeOptionalOperator("||");){let i=this.parseLogicalAnd();e=new Gl(this.span(t),this.sourceSpan(t),"||",e,i)}return e}parseLogicalAnd(){let t=this.inputIndex,e=this.parseNullishCoalescing();for(;this.consumeOptionalOperator("&&");){let i=this.parseNullishCoalescing();e=new Gl(this.span(t),this.sourceSpan(t),"&&",e,i)}return e}parseNullishCoalescing(){let t=this.inputIndex,e=this.parseEquality();for(;this.consumeOptionalOperator("??");){let i=this.parseEquality();e=new Gl(this.span(t),this.sourceSpan(t),"??",e,i)}return e}parseEquality(){let t=this.inputIndex,e=this.parseRelational();for(;this.next.type==ni.Operator;){let i=this.next.strValue;switch(i){case"==":case"===":case"!=":case"!==":this.advance();let r=this.parseRelational();e=new Gl(this.span(t),this.sourceSpan(t),i,e,r);continue}break}return e}parseRelational(){let t=this.inputIndex,e=this.parseAdditive();for(;this.next.type==ni.Operator;){let i=this.next.strValue;switch(i){case"<":case">":case"<=":case">=":this.advance();let r=this.parseAdditive();e=new Gl(this.span(t),this.sourceSpan(t),i,e,r);continue}break}return e}parseAdditive(){let t=this.inputIndex,e=this.parseMultiplicative();for(;this.next.type==ni.Operator;){let i=this.next.strValue;switch(i){case"+":case"-":this.advance();let r=this.parseMultiplicative();e=new Gl(this.span(t),this.sourceSpan(t),i,e,r);continue}break}return e}parseMultiplicative(){let t=this.inputIndex,e=this.parsePrefix();for(;this.next.type==ni.Operator;){let i=this.next.strValue;switch(i){case"*":case"%":case"/":this.advance();let r=this.parsePrefix();e=new Gl(this.span(t),this.sourceSpan(t),i,e,r);continue}break}return e}parsePrefix(){if(this.next.type==ni.Operator){let i,t=this.inputIndex;switch(this.next.strValue){case"+":return this.advance(),i=this.parsePrefix(),zc.createPlus(this.span(t),this.sourceSpan(t),i);case"-":return this.advance(),i=this.parsePrefix(),zc.createMinus(this.span(t),this.sourceSpan(t),i);case"!":return this.advance(),i=this.parsePrefix(),new HC(this.span(t),this.sourceSpan(t),i)}}return this.parseCallChain()}parseCallChain(){let t=this.inputIndex,e=this.parsePrimary();for(;;)if(this.consumeOptionalCharacter(46))e=this.parseAccessMember(e,t,!1);else if(this.consumeOptionalOperator("?."))e=this.consumeOptionalCharacter(40)?this.parseCall(e,t,!0):this.consumeOptionalCharacter(91)?this.parseKeyedReadOrWrite(e,t,!0):this.parseAccessMember(e,t,!0);else if(this.consumeOptionalCharacter(91))e=this.parseKeyedReadOrWrite(e,t,!1);else if(this.consumeOptionalCharacter(40))e=this.parseCall(e,t,!1);else{if(!this.consumeOptionalOperator("!"))return e;e=new UC(this.span(t),this.sourceSpan(t),e)}}parsePrimary(){let t=this.inputIndex;if(this.consumeOptionalCharacter(40)){this.rparensExpected++;let e=this.parsePipe();return this.rparensExpected--,this.expectCharacter(41),e}if(this.next.isKeywordNull())return this.advance(),new ta(this.span(t),this.sourceSpan(t),null);if(this.next.isKeywordUndefined())return this.advance(),new ta(this.span(t),this.sourceSpan(t),void 0);if(this.next.isKeywordTrue())return this.advance(),new ta(this.span(t),this.sourceSpan(t),!0);if(this.next.isKeywordFalse())return this.advance(),new ta(this.span(t),this.sourceSpan(t),!1);if(this.next.isKeywordThis())return this.advance(),new OC(this.span(t),this.sourceSpan(t));if(this.consumeOptionalCharacter(91)){this.rbracketsExpected++;let e=this.parseExpressionList(93);return this.rbracketsExpected--,this.expectCharacter(93),new O_(this.span(t),this.sourceSpan(t),e)}if(this.next.isCharacter(th))return this.parseLiteralMap();if(this.next.isIdentifier())return this.parseAccessMember(new xm(this.span(t),this.sourceSpan(t)),t,!1);if(this.next.isNumber()){let e=this.next.toNumber();return this.advance(),new ta(this.span(t),this.sourceSpan(t),e)}if(this.next.isString()){let e=this.next.toString();return this.advance(),new ta(this.span(t),this.sourceSpan(t),e)}return this.next.isPrivateIdentifier()?(this._reportErrorForPrivateIdentifier(this.next,null),new Ia(this.span(t),this.sourceSpan(t))):this.index>=this.tokens.length?(this.error(`Unexpected end of expression: ${this.input}`),new Ia(this.span(t),this.sourceSpan(t))):(this.error(`Unexpected token ${this.next}`),new Ia(this.span(t),this.sourceSpan(t)))}parseExpressionList(t){let e=[];do{if(this.next.isCharacter(t))break;e.push(this.parsePipe())}while(this.consumeOptionalCharacter(44));return e}parseLiteralMap(){let t=[],e=[],i=this.inputIndex;if(this.expectCharacter(th),!this.consumeOptionalCharacter(Ou)){this.rbracesExpected++;do{let r=this.inputIndex,o=this.next.isString(),s=this.expectIdentifierOrKeywordOrString();if(t.push({key:s,quoted:o}),o)this.expectCharacter(58),e.push(this.parsePipe());else if(this.consumeOptionalCharacter(58))e.push(this.parsePipe());else{let a=this.span(r),l=this.sourceSpan(r);e.push(new Lu(a,l,l,new xm(a,l),s))}}while(this.consumeOptionalCharacter(44));this.rbracesExpected--,this.expectCharacter(Ou)}return new VC(this.span(i),this.sourceSpan(i),t,e)}parseAccessMember(t,e,i){let a,r=this.inputIndex,o=this.withContext(sm.Writable,()=>{let l=this.expectIdentifierOrKeyword()??"";return 0===l.length&&this.error("Expected identifier for property access",t.span.end),l}),s=this.sourceSpan(r);if(i)this.consumeOptionalAssignment()?(this.error("The '?.' operator cannot be used in the assignment"),a=new Ia(this.span(e),this.sourceSpan(e))):a=new LC(this.span(e),this.sourceSpan(e),s,t,o);else if(this.consumeOptionalAssignment()){if(!(1&this.parseFlags))return this.error("Bindings cannot contain assignments"),new Ia(this.span(e),this.sourceSpan(e));let l=this.parseConditional();a=new NC(this.span(e),this.sourceSpan(e),s,t,o,l)}else a=new Lu(this.span(e),this.sourceSpan(e),s,t,o);return a}parseCall(t,e,i){let r=this.inputIndex;this.rparensExpected++;let o=this.parseCallArguments(),s=this.span(r,this.inputIndex).toAbsolute(this.absoluteOffset);this.expectCharacter(41),this.rparensExpected--;let a=this.span(e),l=this.sourceSpan(e);return i?new k_(a,l,t,o,s):new ah(a,l,t,o,s)}consumeOptionalAssignment(){return 2&this.parseFlags&&this.next.isOperator("!")&&this.peek(1).isOperator("=")?(this.advance(),this.advance(),!0):this.consumeOptionalOperator("=")}parseCallArguments(){if(this.next.isCharacter(41))return[];let t=[];do{t.push(this.parsePipe())}while(this.consumeOptionalCharacter(44));return t}expectTemplateBindingKey(){let t="",e=!1,i=this.currentAbsoluteOffset;do{t+=this.expectIdentifierOrKeywordOrString(),e=this.consumeOptionalOperator("-"),e&&(t+="-")}while(e);return{source:t,span:new al(i,i+t.length)}}parseTemplateBindings(t){let e=[];for(e.push(...this.parseDirectiveKeywordBindings(t));this.index<this.tokens.length;){let i=this.parseLetBinding();if(i)e.push(i);else{let r=this.expectTemplateBindingKey(),o=this.parseAsBinding(r);o?e.push(o):(r.source=t.source+r.source.charAt(0).toUpperCase()+r.source.substring(1),e.push(...this.parseDirectiveKeywordBindings(r)))}this.consumeStatementTerminator()}return new class{constructor(t,e,i){this.templateBindings=t,this.warnings=e,this.errors=i}}(e,[],this.errors)}parseKeyedReadOrWrite(t,e,i){return this.withContext(sm.Writable,()=>{this.rbracketsExpected++;let r=this.parsePipe();if(r instanceof Ia&&this.error("Key access cannot be empty"),this.rbracketsExpected--,this.expectCharacter(93),!this.consumeOptionalOperator("="))return i?new P_(this.span(e),this.sourceSpan(e),t,r):new I_(this.span(e),this.sourceSpan(e),t,r);if(!i){let o=this.parseConditional();return new BC(this.span(e),this.sourceSpan(e),t,r,o)}return this.error("The '?.' operator cannot be used in the assignment"),new Ia(this.span(e),this.sourceSpan(e))})}parseDirectiveKeywordBindings(t){let e=[];this.consumeOptionalCharacter(58);let i=this.getDirectiveBoundTarget(),r=this.currentAbsoluteOffset,o=this.parseAsBinding(t);o||(this.consumeStatementTerminator(),r=this.currentAbsoluteOffset);let s=new al(t.span.start,r);return e.push(new class{constructor(t,e,i){this.sourceSpan=t,this.key=e,this.value=i}}(s,t,i)),o&&e.push(o),e}getDirectiveBoundTarget(){if(this.next===dB||this.peekKeywordAs()||this.peekKeywordLet())return null;let t=this.parsePipe(),{start:e,end:i}=t.span,r=this.input.substring(e,i);return new Ru(t,r,this.location,this.absoluteOffset+e,this.errors)}parseAsBinding(t){if(!this.peekKeywordAs())return null;this.advance();let e=this.expectTemplateBindingKey();this.consumeStatementTerminator();let i=new al(t.span.start,this.currentAbsoluteOffset);return new zC(i,e,t)}parseLetBinding(){if(!this.peekKeywordLet())return null;let t=this.currentAbsoluteOffset;this.advance();let e=this.expectTemplateBindingKey(),i=null;this.consumeOptionalOperator("=")&&(i=this.expectTemplateBindingKey()),this.consumeStatementTerminator();let r=new al(t,this.currentAbsoluteOffset);return new zC(r,e,i)}consumeStatementTerminator(){this.consumeOptionalCharacter(59)||this.consumeOptionalCharacter(44)}error(t,e=null){this.errors.push(new RC(t,this.input,this.locationText(e),this.location)),this.skip()}locationText(t=null){return null==t&&(t=this.index),t<this.tokens.length?`at column ${this.tokens[t].index+1} in`:"at the end of the expression"}_reportErrorForPrivateIdentifier(t,e){let i=`Private identifiers are not supported. Unexpected private identifier: ${t}`;null!==e&&(i+=`, ${e}`),this.error(i)}skip(){let t=this.next;for(;this.index<this.tokens.length&&!t.isCharacter(59)&&!t.isOperator("|")&&(this.rparensExpected<=0||!t.isCharacter(41))&&(this.rbracesExpected<=0||!t.isCharacter(Ou))&&(this.rbracketsExpected<=0||!t.isCharacter(93))&&!(this.context&sm.Writable&&t.isOperator("="));)this.next.isError()&&this.errors.push(new RC(this.next.toString(),this.input,this.locationText(),this.location)),this.advance(),t=this.next}},dV=class extends ZB{constructor(){super(...arguments),this.errors=[]}visitPipe(){this.errors.push("pipes")}},Cm=class{constructor(t,e){this.sourceSpan=t,this.i18n=e}},F_=class extends Cm{constructor(t,e,i,r){super(e,r),this.value=t,this.tokens=i}visit(t,e){return t.visitText(this,e)}},N_=class extends Cm{constructor(t,e,i,r,o,s){super(r,s),this.switchValue=t,this.type=e,this.cases=i,this.switchValueSourceSpan=o}visit(t,e){return t.visitExpansion(this,e)}},hV=class extends Cm{constructor(t,e,i,r,o,s,a){super(i,a),this.name=t,this.value=e,this.keySpan=r,this.valueSpan=o,this.valueTokens=s}visit(t,e){return t.visitAttribute(this,e)}},qC=class extends Cm{constructor(t,e,i,r,o,s=null,a){super(r,a),this.name=t,this.attrs=e,this.children=i,this.startSourceSpan=o,this.endSourceSpan=s}visit(t,e){return t.visitElement(this,e)}},xD=class{constructor(t,e){this.value=t,this.sourceSpan=e}visit(t,e){return t.visitComment(this,e)}};function Uu(n,t,e=null){let i=[],r=n.visit?o=>n.visit(o,e)||o.visit(n,e):o=>o.visit(n,e);return t.forEach(o=>{let s=r(o);s&&i.push(s)}),i}var CD={AElig:"\xc6",AMP:"&",amp:"&",Aacute:"\xc1",Abreve:"\u0102",Acirc:"\xc2",Acy:"\u0410",Afr:"\ud835\udd04",Agrave:"\xc0",Alpha:"\u0391",Amacr:"\u0100",And:"\u2a53",Aogon:"\u0104",Aopf:"\ud835\udd38",ApplyFunction:"\u2061",af:"\u2061",Aring:"\xc5",angst:"\xc5",Ascr:"\ud835\udc9c",Assign:"\u2254",colone:"\u2254",coloneq:"\u2254",Atilde:"\xc3",Auml:"\xc4",Backslash:"\u2216",setminus:"\u2216",setmn:"\u2216",smallsetminus:"\u2216",ssetmn:"\u2216",Barv:"\u2ae7",Barwed:"\u2306",doublebarwedge:"\u2306",Bcy:"\u0411",Because:"\u2235",becaus:"\u2235",because:"\u2235",Bernoullis:"\u212c",Bscr:"\u212c",bernou:"\u212c",Beta:"\u0392",Bfr:"\ud835\udd05",Bopf:"\ud835\udd39",Breve:"\u02d8",breve:"\u02d8",Bumpeq:"\u224e",HumpDownHump:"\u224e",bump:"\u224e",CHcy:"\u0427",COPY:"\xa9",copy:"\xa9",Cacute:"\u0106",Cap:"\u22d2",CapitalDifferentialD:"\u2145",DD:"\u2145",Cayleys:"\u212d",Cfr:"\u212d",Ccaron:"\u010c",Ccedil:"\xc7",Ccirc:"\u0108",Cconint:"\u2230",Cdot:"\u010a",Cedilla:"\xb8",cedil:"\xb8",CenterDot:"\xb7",centerdot:"\xb7",middot:"\xb7",Chi:"\u03a7",CircleDot:"\u2299",odot:"\u2299",CircleMinus:"\u2296",ominus:"\u2296",CirclePlus:"\u2295",oplus:"\u2295",CircleTimes:"\u2297",otimes:"\u2297",ClockwiseContourIntegral:"\u2232",cwconint:"\u2232",CloseCurlyDoubleQuote:"\u201d",rdquo:"\u201d",rdquor:"\u201d",CloseCurlyQuote:"\u2019",rsquo:"\u2019",rsquor:"\u2019",Colon:"\u2237",Proportion:"\u2237",Colone:"\u2a74",Congruent:"\u2261",equiv:"\u2261",Conint:"\u222f",DoubleContourIntegral:"\u222f",ContourIntegral:"\u222e",conint:"\u222e",oint:"\u222e",Copf:"\u2102",complexes:"\u2102",Coproduct:"\u2210",coprod:"\u2210",CounterClockwiseContourIntegral:"\u2233",awconint:"\u2233",Cross:"\u2a2f",Cscr:"\ud835\udc9e",Cup:"\u22d3",CupCap:"\u224d",asympeq:"\u224d",DDotrahd:"\u2911",DJcy:"\u0402",DScy:"\u0405",DZcy:"\u040f",Dagger:"\u2021",ddagger:"\u2021",Darr:"\u21a1",Dashv:"\u2ae4",DoubleLeftTee:"\u2ae4",Dcaron:"\u010e",Dcy:"\u0414",Del:"\u2207",nabla:"\u2207",Delta:"\u0394",Dfr:"\ud835\udd07",DiacriticalAcute:"\xb4",acute:"\xb4",DiacriticalDot:"\u02d9",dot:"\u02d9",DiacriticalDoubleAcute:"\u02dd",dblac:"\u02dd",DiacriticalGrave:"`",grave:"`",DiacriticalTilde:"\u02dc",tilde:"\u02dc",Diamond:"\u22c4",diam:"\u22c4",diamond:"\u22c4",DifferentialD:"\u2146",dd:"\u2146",Dopf:"\ud835\udd3b",Dot:"\xa8",DoubleDot:"\xa8",die:"\xa8",uml:"\xa8",DotDot:"\u20dc",DotEqual:"\u2250",doteq:"\u2250",esdot:"\u2250",DoubleDownArrow:"\u21d3",Downarrow:"\u21d3",dArr:"\u21d3",DoubleLeftArrow:"\u21d0",Leftarrow:"\u21d0",lArr:"\u21d0",DoubleLeftRightArrow:"\u21d4",Leftrightarrow:"\u21d4",hArr:"\u21d4",iff:"\u21d4",DoubleLongLeftArrow:"\u27f8",Longleftarrow:"\u27f8",xlArr:"\u27f8",DoubleLongLeftRightArrow:"\u27fa",Longleftrightarrow:"\u27fa",xhArr:"\u27fa",DoubleLongRightArrow:"\u27f9",Longrightarrow:"\u27f9",xrArr:"\u27f9",DoubleRightArrow:"\u21d2",Implies:"\u21d2",Rightarrow:"\u21d2",rArr:"\u21d2",DoubleRightTee:"\u22a8",vDash:"\u22a8",DoubleUpArrow:"\u21d1",Uparrow:"\u21d1",uArr:"\u21d1",DoubleUpDownArrow:"\u21d5",Updownarrow:"\u21d5",vArr:"\u21d5",DoubleVerticalBar:"\u2225",par:"\u2225",parallel:"\u2225",shortparallel:"\u2225",spar:"\u2225",DownArrow:"\u2193",ShortDownArrow:"\u2193",darr:"\u2193",downarrow:"\u2193",DownArrowBar:"\u2913",DownArrowUpArrow:"\u21f5",duarr:"\u21f5",DownBreve:"\u0311",DownLeftRightVector:"\u2950",DownLeftTeeVector:"\u295e",DownLeftVector:"\u21bd",leftharpoondown:"\u21bd",lhard:"\u21bd",DownLeftVectorBar:"\u2956",DownRightTeeVector:"\u295f",DownRightVector:"\u21c1",rhard:"\u21c1",rightharpoondown:"\u21c1",DownRightVectorBar:"\u2957",DownTee:"\u22a4",top:"\u22a4",DownTeeArrow:"\u21a7",mapstodown:"\u21a7",Dscr:"\ud835\udc9f",Dstrok:"\u0110",ENG:"\u014a",ETH:"\xd0",Eacute:"\xc9",Ecaron:"\u011a",Ecirc:"\xca",Ecy:"\u042d",Edot:"\u0116",Efr:"\ud835\udd08",Egrave:"\xc8",Element:"\u2208",in:"\u2208",isin:"\u2208",isinv:"\u2208",Emacr:"\u0112",EmptySmallSquare:"\u25fb",EmptyVerySmallSquare:"\u25ab",Eogon:"\u0118",Eopf:"\ud835\udd3c",Epsilon:"\u0395",Equal:"\u2a75",EqualTilde:"\u2242",eqsim:"\u2242",esim:"\u2242",Equilibrium:"\u21cc",rightleftharpoons:"\u21cc",rlhar:"\u21cc",Escr:"\u2130",expectation:"\u2130",Esim:"\u2a73",Eta:"\u0397",Euml:"\xcb",Exists:"\u2203",exist:"\u2203",ExponentialE:"\u2147",ee:"\u2147",exponentiale:"\u2147",Fcy:"\u0424",Ffr:"\ud835\udd09",FilledSmallSquare:"\u25fc",FilledVerySmallSquare:"\u25aa",blacksquare:"\u25aa",squarf:"\u25aa",squf:"\u25aa",Fopf:"\ud835\udd3d",ForAll:"\u2200",forall:"\u2200",Fouriertrf:"\u2131",Fscr:"\u2131",GJcy:"\u0403",GT:">",gt:">",Gamma:"\u0393",Gammad:"\u03dc",Gbreve:"\u011e",Gcedil:"\u0122",Gcirc:"\u011c",Gcy:"\u0413",Gdot:"\u0120",Gfr:"\ud835\udd0a",Gg:"\u22d9",ggg:"\u22d9",Gopf:"\ud835\udd3e",GreaterEqual:"\u2265",ge:"\u2265",geq:"\u2265",GreaterEqualLess:"\u22db",gel:"\u22db",gtreqless:"\u22db",GreaterFullEqual:"\u2267",gE:"\u2267",geqq:"\u2267",GreaterGreater:"\u2aa2",GreaterLess:"\u2277",gl:"\u2277",gtrless:"\u2277",GreaterSlantEqual:"\u2a7e",geqslant:"\u2a7e",ges:"\u2a7e",GreaterTilde:"\u2273",gsim:"\u2273",gtrsim:"\u2273",Gscr:"\ud835\udca2",Gt:"\u226b",NestedGreaterGreater:"\u226b",gg:"\u226b",HARDcy:"\u042a",Hacek:"\u02c7",caron:"\u02c7",Hat:"^",Hcirc:"\u0124",Hfr:"\u210c",Poincareplane:"\u210c",HilbertSpace:"\u210b",Hscr:"\u210b",hamilt:"\u210b",Hopf:"\u210d",quaternions:"\u210d",HorizontalLine:"\u2500",boxh:"\u2500",Hstrok:"\u0126",HumpEqual:"\u224f",bumpe:"\u224f",bumpeq:"\u224f",IEcy:"\u0415",IJlig:"\u0132",IOcy:"\u0401",Iacute:"\xcd",Icirc:"\xce",Icy:"\u0418",Idot:"\u0130",Ifr:"\u2111",Im:"\u2111",image:"\u2111",imagpart:"\u2111",Igrave:"\xcc",Imacr:"\u012a",ImaginaryI:"\u2148",ii:"\u2148",Int:"\u222c",Integral:"\u222b",int:"\u222b",Intersection:"\u22c2",bigcap:"\u22c2",xcap:"\u22c2",InvisibleComma:"\u2063",ic:"\u2063",InvisibleTimes:"\u2062",it:"\u2062",Iogon:"\u012e",Iopf:"\ud835\udd40",Iota:"\u0399",Iscr:"\u2110",imagline:"\u2110",Itilde:"\u0128",Iukcy:"\u0406",Iuml:"\xcf",Jcirc:"\u0134",Jcy:"\u0419",Jfr:"\ud835\udd0d",Jopf:"\ud835\udd41",Jscr:"\ud835\udca5",Jsercy:"\u0408",Jukcy:"\u0404",KHcy:"\u0425",KJcy:"\u040c",Kappa:"\u039a",Kcedil:"\u0136",Kcy:"\u041a",Kfr:"\ud835\udd0e",Kopf:"\ud835\udd42",Kscr:"\ud835\udca6",LJcy:"\u0409",LT:"<",lt:"<",Lacute:"\u0139",Lambda:"\u039b",Lang:"\u27ea",Laplacetrf:"\u2112",Lscr:"\u2112",lagran:"\u2112",Larr:"\u219e",twoheadleftarrow:"\u219e",Lcaron:"\u013d",Lcedil:"\u013b",Lcy:"\u041b",LeftAngleBracket:"\u27e8",lang:"\u27e8",langle:"\u27e8",LeftArrow:"\u2190",ShortLeftArrow:"\u2190",larr:"\u2190",leftarrow:"\u2190",slarr:"\u2190",LeftArrowBar:"\u21e4",larrb:"\u21e4",LeftArrowRightArrow:"\u21c6",leftrightarrows:"\u21c6",lrarr:"\u21c6",LeftCeiling:"\u2308",lceil:"\u2308",LeftDoubleBracket:"\u27e6",lobrk:"\u27e6",LeftDownTeeVector:"\u2961",LeftDownVector:"\u21c3",dharl:"\u21c3",downharpoonleft:"\u21c3",LeftDownVectorBar:"\u2959",LeftFloor:"\u230a",lfloor:"\u230a",LeftRightArrow:"\u2194",harr:"\u2194",leftrightarrow:"\u2194",LeftRightVector:"\u294e",LeftTee:"\u22a3",dashv:"\u22a3",LeftTeeArrow:"\u21a4",mapstoleft:"\u21a4",LeftTeeVector:"\u295a",LeftTriangle:"\u22b2",vartriangleleft:"\u22b2",vltri:"\u22b2",LeftTriangleBar:"\u29cf",LeftTriangleEqual:"\u22b4",ltrie:"\u22b4",trianglelefteq:"\u22b4",LeftUpDownVector:"\u2951",LeftUpTeeVector:"\u2960",LeftUpVector:"\u21bf",uharl:"\u21bf",upharpoonleft:"\u21bf",LeftUpVectorBar:"\u2958",LeftVector:"\u21bc",leftharpoonup:"\u21bc",lharu:"\u21bc",LeftVectorBar:"\u2952",LessEqualGreater:"\u22da",leg:"\u22da",lesseqgtr:"\u22da",LessFullEqual:"\u2266",lE:"\u2266",leqq:"\u2266",LessGreater:"\u2276",lessgtr:"\u2276",lg:"\u2276",LessLess:"\u2aa1",LessSlantEqual:"\u2a7d",leqslant:"\u2a7d",les:"\u2a7d",LessTilde:"\u2272",lesssim:"\u2272",lsim:"\u2272",Lfr:"\ud835\udd0f",Ll:"\u22d8",Lleftarrow:"\u21da",lAarr:"\u21da",Lmidot:"\u013f",LongLeftArrow:"\u27f5",longleftarrow:"\u27f5",xlarr:"\u27f5",LongLeftRightArrow:"\u27f7",longleftrightarrow:"\u27f7",xharr:"\u27f7",LongRightArrow:"\u27f6",longrightarrow:"\u27f6",xrarr:"\u27f6",Lopf:"\ud835\udd43",LowerLeftArrow:"\u2199",swarr:"\u2199",swarrow:"\u2199",LowerRightArrow:"\u2198",searr:"\u2198",searrow:"\u2198",Lsh:"\u21b0",lsh:"\u21b0",Lstrok:"\u0141",Lt:"\u226a",NestedLessLess:"\u226a",ll:"\u226a",Map:"\u2905",Mcy:"\u041c",MediumSpace:"\u205f",Mellintrf:"\u2133",Mscr:"\u2133",phmmat:"\u2133",Mfr:"\ud835\udd10",MinusPlus:"\u2213",mnplus:"\u2213",mp:"\u2213",Mopf:"\ud835\udd44",Mu:"\u039c",NJcy:"\u040a",Nacute:"\u0143",Ncaron:"\u0147",Ncedil:"\u0145",Ncy:"\u041d",NegativeMediumSpace:"\u200b",NegativeThickSpace:"\u200b",NegativeThinSpace:"\u200b",NegativeVeryThinSpace:"\u200b",ZeroWidthSpace:"\u200b",NewLine:"\n",Nfr:"\ud835\udd11",NoBreak:"\u2060",NonBreakingSpace:"\xa0",nbsp:"\xa0",Nopf:"\u2115",naturals:"\u2115",Not:"\u2aec",NotCongruent:"\u2262",nequiv:"\u2262",NotCupCap:"\u226d",NotDoubleVerticalBar:"\u2226",npar:"\u2226",nparallel:"\u2226",nshortparallel:"\u2226",nspar:"\u2226",NotElement:"\u2209",notin:"\u2209",notinva:"\u2209",NotEqual:"\u2260",ne:"\u2260",NotEqualTilde:"\u2242\u0338",nesim:"\u2242\u0338",NotExists:"\u2204",nexist:"\u2204",nexists:"\u2204",NotGreater:"\u226f",ngt:"\u226f",ngtr:"\u226f",NotGreaterEqual:"\u2271",nge:"\u2271",ngeq:"\u2271",NotGreaterFullEqual:"\u2267\u0338",ngE:"\u2267\u0338",ngeqq:"\u2267\u0338",NotGreaterGreater:"\u226b\u0338",nGtv:"\u226b\u0338",NotGreaterLess:"\u2279",ntgl:"\u2279",NotGreaterSlantEqual:"\u2a7e\u0338",ngeqslant:"\u2a7e\u0338",nges:"\u2a7e\u0338",NotGreaterTilde:"\u2275",ngsim:"\u2275",NotHumpDownHump:"\u224e\u0338",nbump:"\u224e\u0338",NotHumpEqual:"\u224f\u0338",nbumpe:"\u224f\u0338",NotLeftTriangle:"\u22ea",nltri:"\u22ea",ntriangleleft:"\u22ea",NotLeftTriangleBar:"\u29cf\u0338",NotLeftTriangleEqual:"\u22ec",nltrie:"\u22ec",ntrianglelefteq:"\u22ec",NotLess:"\u226e",nless:"\u226e",nlt:"\u226e",NotLessEqual:"\u2270",nle:"\u2270",nleq:"\u2270",NotLessGreater:"\u2278",ntlg:"\u2278",NotLessLess:"\u226a\u0338",nLtv:"\u226a\u0338",NotLessSlantEqual:"\u2a7d\u0338",nleqslant:"\u2a7d\u0338",nles:"\u2a7d\u0338",NotLessTilde:"\u2274",nlsim:"\u2274",NotNestedGreaterGreater:"\u2aa2\u0338",NotNestedLessLess:"\u2aa1\u0338",NotPrecedes:"\u2280",npr:"\u2280",nprec:"\u2280",NotPrecedesEqual:"\u2aaf\u0338",npre:"\u2aaf\u0338",npreceq:"\u2aaf\u0338",NotPrecedesSlantEqual:"\u22e0",nprcue:"\u22e0",NotReverseElement:"\u220c",notni:"\u220c",notniva:"\u220c",NotRightTriangle:"\u22eb",nrtri:"\u22eb",ntriangleright:"\u22eb",NotRightTriangleBar:"\u29d0\u0338",NotRightTriangleEqual:"\u22ed",nrtrie:"\u22ed",ntrianglerighteq:"\u22ed",NotSquareSubset:"\u228f\u0338",NotSquareSubsetEqual:"\u22e2",nsqsube:"\u22e2",NotSquareSuperset:"\u2290\u0338",NotSquareSupersetEqual:"\u22e3",nsqsupe:"\u22e3",NotSubset:"\u2282\u20d2",nsubset:"\u2282\u20d2",vnsub:"\u2282\u20d2",NotSubsetEqual:"\u2288",nsube:"\u2288",nsubseteq:"\u2288",NotSucceeds:"\u2281",nsc:"\u2281",nsucc:"\u2281",NotSucceedsEqual:"\u2ab0\u0338",nsce:"\u2ab0\u0338",nsucceq:"\u2ab0\u0338",NotSucceedsSlantEqual:"\u22e1",nsccue:"\u22e1",NotSucceedsTilde:"\u227f\u0338",NotSuperset:"\u2283\u20d2",nsupset:"\u2283\u20d2",vnsup:"\u2283\u20d2",NotSupersetEqual:"\u2289",nsupe:"\u2289",nsupseteq:"\u2289",NotTilde:"\u2241",nsim:"\u2241",NotTildeEqual:"\u2244",nsime:"\u2244",nsimeq:"\u2244",NotTildeFullEqual:"\u2247",ncong:"\u2247",NotTildeTilde:"\u2249",nap:"\u2249",napprox:"\u2249",NotVerticalBar:"\u2224",nmid:"\u2224",nshortmid:"\u2224",nsmid:"\u2224",Nscr:"\ud835\udca9",Ntilde:"\xd1",Nu:"\u039d",OElig:"\u0152",Oacute:"\xd3",Ocirc:"\xd4",Ocy:"\u041e",Odblac:"\u0150",Ofr:"\ud835\udd12",Ograve:"\xd2",Omacr:"\u014c",Omega:"\u03a9",ohm:"\u03a9",Omicron:"\u039f",Oopf:"\ud835\udd46",OpenCurlyDoubleQuote:"\u201c",ldquo:"\u201c",OpenCurlyQuote:"\u2018",lsquo:"\u2018",Or:"\u2a54",Oscr:"\ud835\udcaa",Oslash:"\xd8",Otilde:"\xd5",Otimes:"\u2a37",Ouml:"\xd6",OverBar:"\u203e",oline:"\u203e",OverBrace:"\u23de",OverBracket:"\u23b4",tbrk:"\u23b4",OverParenthesis:"\u23dc",PartialD:"\u2202",part:"\u2202",Pcy:"\u041f",Pfr:"\ud835\udd13",Phi:"\u03a6",Pi:"\u03a0",PlusMinus:"\xb1",plusmn:"\xb1",pm:"\xb1",Popf:"\u2119",primes:"\u2119",Pr:"\u2abb",Precedes:"\u227a",pr:"\u227a",prec:"\u227a",PrecedesEqual:"\u2aaf",pre:"\u2aaf",preceq:"\u2aaf",PrecedesSlantEqual:"\u227c",prcue:"\u227c",preccurlyeq:"\u227c",PrecedesTilde:"\u227e",precsim:"\u227e",prsim:"\u227e",Prime:"\u2033",Product:"\u220f",prod:"\u220f",Proportional:"\u221d",prop:"\u221d",propto:"\u221d",varpropto:"\u221d",vprop:"\u221d",Pscr:"\ud835\udcab",Psi:"\u03a8",QUOT:'"',quot:'"',Qfr:"\ud835\udd14",Qopf:"\u211a",rationals:"\u211a",Qscr:"\ud835\udcac",RBarr:"\u2910",drbkarow:"\u2910",REG:"\xae",circledR:"\xae",reg:"\xae",Racute:"\u0154",Rang:"\u27eb",Rarr:"\u21a0",twoheadrightarrow:"\u21a0",Rarrtl:"\u2916",Rcaron:"\u0158",Rcedil:"\u0156",Rcy:"\u0420",Re:"\u211c",Rfr:"\u211c",real:"\u211c",realpart:"\u211c",ReverseElement:"\u220b",SuchThat:"\u220b",ni:"\u220b",niv:"\u220b",ReverseEquilibrium:"\u21cb",leftrightharpoons:"\u21cb",lrhar:"\u21cb",ReverseUpEquilibrium:"\u296f",duhar:"\u296f",Rho:"\u03a1",RightAngleBracket:"\u27e9",rang:"\u27e9",rangle:"\u27e9",RightArrow:"\u2192",ShortRightArrow:"\u2192",rarr:"\u2192",rightarrow:"\u2192",srarr:"\u2192",RightArrowBar:"\u21e5",rarrb:"\u21e5",RightArrowLeftArrow:"\u21c4",rightleftarrows:"\u21c4",rlarr:"\u21c4",RightCeiling:"\u2309",rceil:"\u2309",RightDoubleBracket:"\u27e7",robrk:"\u27e7",RightDownTeeVector:"\u295d",RightDownVector:"\u21c2",dharr:"\u21c2",downharpoonright:"\u21c2",RightDownVectorBar:"\u2955",RightFloor:"\u230b",rfloor:"\u230b",RightTee:"\u22a2",vdash:"\u22a2",RightTeeArrow:"\u21a6",map:"\u21a6",mapsto:"\u21a6",RightTeeVector:"\u295b",RightTriangle:"\u22b3",vartriangleright:"\u22b3",vrtri:"\u22b3",RightTriangleBar:"\u29d0",RightTriangleEqual:"\u22b5",rtrie:"\u22b5",trianglerighteq:"\u22b5",RightUpDownVector:"\u294f",RightUpTeeVector:"\u295c",RightUpVector:"\u21be",uharr:"\u21be",upharpoonright:"\u21be",RightUpVectorBar:"\u2954",RightVector:"\u21c0",rharu:"\u21c0",rightharpoonup:"\u21c0",RightVectorBar:"\u2953",Ropf:"\u211d",reals:"\u211d",RoundImplies:"\u2970",Rrightarrow:"\u21db",rAarr:"\u21db",Rscr:"\u211b",realine:"\u211b",Rsh:"\u21b1",rsh:"\u21b1",RuleDelayed:"\u29f4",SHCHcy:"\u0429",SHcy:"\u0428",SOFTcy:"\u042c",Sacute:"\u015a",Sc:"\u2abc",Scaron:"\u0160",Scedil:"\u015e",Scirc:"\u015c",Scy:"\u0421",Sfr:"\ud835\udd16",ShortUpArrow:"\u2191",UpArrow:"\u2191",uarr:"\u2191",uparrow:"\u2191",Sigma:"\u03a3",SmallCircle:"\u2218",compfn:"\u2218",Sopf:"\ud835\udd4a",Sqrt:"\u221a",radic:"\u221a",Square:"\u25a1",squ:"\u25a1",square:"\u25a1",SquareIntersection:"\u2293",sqcap:"\u2293",SquareSubset:"\u228f",sqsub:"\u228f",sqsubset:"\u228f",SquareSubsetEqual:"\u2291",sqsube:"\u2291",sqsubseteq:"\u2291",SquareSuperset:"\u2290",sqsup:"\u2290",sqsupset:"\u2290",SquareSupersetEqual:"\u2292",sqsupe:"\u2292",sqsupseteq:"\u2292",SquareUnion:"\u2294",sqcup:"\u2294",Sscr:"\ud835\udcae",Star:"\u22c6",sstarf:"\u22c6",Sub:"\u22d0",Subset:"\u22d0",SubsetEqual:"\u2286",sube:"\u2286",subseteq:"\u2286",Succeeds:"\u227b",sc:"\u227b",succ:"\u227b",SucceedsEqual:"\u2ab0",sce:"\u2ab0",succeq:"\u2ab0",SucceedsSlantEqual:"\u227d",sccue:"\u227d",succcurlyeq:"\u227d",SucceedsTilde:"\u227f",scsim:"\u227f",succsim:"\u227f",Sum:"\u2211",sum:"\u2211",Sup:"\u22d1",Supset:"\u22d1",Superset:"\u2283",sup:"\u2283",supset:"\u2283",SupersetEqual:"\u2287",supe:"\u2287",supseteq:"\u2287",THORN:"\xde",TRADE:"\u2122",trade:"\u2122",TSHcy:"\u040b",TScy:"\u0426",Tab:"\t",Tau:"\u03a4",Tcaron:"\u0164",Tcedil:"\u0162",Tcy:"\u0422",Tfr:"\ud835\udd17",Therefore:"\u2234",there4:"\u2234",therefore:"\u2234",Theta:"\u0398",ThickSpace:"\u205f\u200a",ThinSpace:"\u2009",thinsp:"\u2009",Tilde:"\u223c",sim:"\u223c",thicksim:"\u223c",thksim:"\u223c",TildeEqual:"\u2243",sime:"\u2243",simeq:"\u2243",TildeFullEqual:"\u2245",cong:"\u2245",TildeTilde:"\u2248",ap:"\u2248",approx:"\u2248",asymp:"\u2248",thickapprox:"\u2248",thkap:"\u2248",Topf:"\ud835\udd4b",TripleDot:"\u20db",tdot:"\u20db",Tscr:"\ud835\udcaf",Tstrok:"\u0166",Uacute:"\xda",Uarr:"\u219f",Uarrocir:"\u2949",Ubrcy:"\u040e",Ubreve:"\u016c",Ucirc:"\xdb",Ucy:"\u0423",Udblac:"\u0170",Ufr:"\ud835\udd18",Ugrave:"\xd9",Umacr:"\u016a",UnderBar:"_",lowbar:"_",UnderBrace:"\u23df",UnderBracket:"\u23b5",bbrk:"\u23b5",UnderParenthesis:"\u23dd",Union:"\u22c3",bigcup:"\u22c3",xcup:"\u22c3",UnionPlus:"\u228e",uplus:"\u228e",Uogon:"\u0172",Uopf:"\ud835\udd4c",UpArrowBar:"\u2912",UpArrowDownArrow:"\u21c5",udarr:"\u21c5",UpDownArrow:"\u2195",updownarrow:"\u2195",varr:"\u2195",UpEquilibrium:"\u296e",udhar:"\u296e",UpTee:"\u22a5",bot:"\u22a5",bottom:"\u22a5",perp:"\u22a5",UpTeeArrow:"\u21a5",mapstoup:"\u21a5",UpperLeftArrow:"\u2196",nwarr:"\u2196",nwarrow:"\u2196",UpperRightArrow:"\u2197",nearr:"\u2197",nearrow:"\u2197",Upsi:"\u03d2",upsih:"\u03d2",Upsilon:"\u03a5",Uring:"\u016e",Uscr:"\ud835\udcb0",Utilde:"\u0168",Uuml:"\xdc",VDash:"\u22ab",Vbar:"\u2aeb",Vcy:"\u0412",Vdash:"\u22a9",Vdashl:"\u2ae6",Vee:"\u22c1",bigvee:"\u22c1",xvee:"\u22c1",Verbar:"\u2016",Vert:"\u2016",VerticalBar:"\u2223",mid:"\u2223",shortmid:"\u2223",smid:"\u2223",VerticalLine:"|",verbar:"|",vert:"|",VerticalSeparator:"\u2758",VerticalTilde:"\u2240",wr:"\u2240",wreath:"\u2240",VeryThinSpace:"\u200a",hairsp:"\u200a",Vfr:"\ud835\udd19",Vopf:"\ud835\udd4d",Vscr:"\ud835\udcb1",Vvdash:"\u22aa",Wcirc:"\u0174",Wedge:"\u22c0",bigwedge:"\u22c0",xwedge:"\u22c0",Wfr:"\ud835\udd1a",Wopf:"\ud835\udd4e",Wscr:"\ud835\udcb2",Xfr:"\ud835\udd1b",Xi:"\u039e",Xopf:"\ud835\udd4f",Xscr:"\ud835\udcb3",YAcy:"\u042f",YIcy:"\u0407",YUcy:"\u042e",Yacute:"\xdd",Ycirc:"\u0176",Ycy:"\u042b",Yfr:"\ud835\udd1c",Yopf:"\ud835\udd50",Yscr:"\ud835\udcb4",Yuml:"\u0178",ZHcy:"\u0416",Zacute:"\u0179",Zcaron:"\u017d",Zcy:"\u0417",Zdot:"\u017b",Zeta:"\u0396",Zfr:"\u2128",zeetrf:"\u2128",Zopf:"\u2124",integers:"\u2124",Zscr:"\ud835\udcb5",aacute:"\xe1",abreve:"\u0103",ac:"\u223e",mstpos:"\u223e",acE:"\u223e\u0333",acd:"\u223f",acirc:"\xe2",acy:"\u0430",aelig:"\xe6",afr:"\ud835\udd1e",agrave:"\xe0",alefsym:"\u2135",aleph:"\u2135",alpha:"\u03b1",amacr:"\u0101",amalg:"\u2a3f",and:"\u2227",wedge:"\u2227",andand:"\u2a55",andd:"\u2a5c",andslope:"\u2a58",andv:"\u2a5a",ang:"\u2220",angle:"\u2220",ange:"\u29a4",angmsd:"\u2221",measuredangle:"\u2221",angmsdaa:"\u29a8",angmsdab:"\u29a9",angmsdac:"\u29aa",angmsdad:"\u29ab",angmsdae:"\u29ac",angmsdaf:"\u29ad",angmsdag:"\u29ae",angmsdah:"\u29af",angrt:"\u221f",angrtvb:"\u22be",angrtvbd:"\u299d",angsph:"\u2222",angzarr:"\u237c",aogon:"\u0105",aopf:"\ud835\udd52",apE:"\u2a70",apacir:"\u2a6f",ape:"\u224a",approxeq:"\u224a",apid:"\u224b",apos:"'",aring:"\xe5",ascr:"\ud835\udcb6",ast:"*",midast:"*",atilde:"\xe3",auml:"\xe4",awint:"\u2a11",bNot:"\u2aed",backcong:"\u224c",bcong:"\u224c",backepsilon:"\u03f6",bepsi:"\u03f6",backprime:"\u2035",bprime:"\u2035",backsim:"\u223d",bsim:"\u223d",backsimeq:"\u22cd",bsime:"\u22cd",barvee:"\u22bd",barwed:"\u2305",barwedge:"\u2305",bbrktbrk:"\u23b6",bcy:"\u0431",bdquo:"\u201e",ldquor:"\u201e",bemptyv:"\u29b0",beta:"\u03b2",beth:"\u2136",between:"\u226c",twixt:"\u226c",bfr:"\ud835\udd1f",bigcirc:"\u25ef",xcirc:"\u25ef",bigodot:"\u2a00",xodot:"\u2a00",bigoplus:"\u2a01",xoplus:"\u2a01",bigotimes:"\u2a02",xotime:"\u2a02",bigsqcup:"\u2a06",xsqcup:"\u2a06",bigstar:"\u2605",starf:"\u2605",bigtriangledown:"\u25bd",xdtri:"\u25bd",bigtriangleup:"\u25b3",xutri:"\u25b3",biguplus:"\u2a04",xuplus:"\u2a04",bkarow:"\u290d",rbarr:"\u290d",blacklozenge:"\u29eb",lozf:"\u29eb",blacktriangle:"\u25b4",utrif:"\u25b4",blacktriangledown:"\u25be",dtrif:"\u25be",blacktriangleleft:"\u25c2",ltrif:"\u25c2",blacktriangleright:"\u25b8",rtrif:"\u25b8",blank:"\u2423",blk12:"\u2592",blk14:"\u2591",blk34:"\u2593",block:"\u2588",bne:"=\u20e5",bnequiv:"\u2261\u20e5",bnot:"\u2310",bopf:"\ud835\udd53",bowtie:"\u22c8",boxDL:"\u2557",boxDR:"\u2554",boxDl:"\u2556",boxDr:"\u2553",boxH:"\u2550",boxHD:"\u2566",boxHU:"\u2569",boxHd:"\u2564",boxHu:"\u2567",boxUL:"\u255d",boxUR:"\u255a",boxUl:"\u255c",boxUr:"\u2559",boxV:"\u2551",boxVH:"\u256c",boxVL:"\u2563",boxVR:"\u2560",boxVh:"\u256b",boxVl:"\u2562",boxVr:"\u255f",boxbox:"\u29c9",boxdL:"\u2555",boxdR:"\u2552",boxdl:"\u2510",boxdr:"\u250c",boxhD:"\u2565",boxhU:"\u2568",boxhd:"\u252c",boxhu:"\u2534",boxminus:"\u229f",minusb:"\u229f",boxplus:"\u229e",plusb:"\u229e",boxtimes:"\u22a0",timesb:"\u22a0",boxuL:"\u255b",boxuR:"\u2558",boxul:"\u2518",boxur:"\u2514",boxv:"\u2502",boxvH:"\u256a",boxvL:"\u2561",boxvR:"\u255e",boxvh:"\u253c",boxvl:"\u2524",boxvr:"\u251c",brvbar:"\xa6",bscr:"\ud835\udcb7",bsemi:"\u204f",bsol:"\\",bsolb:"\u29c5",bsolhsub:"\u27c8",bull:"\u2022",bullet:"\u2022",bumpE:"\u2aae",cacute:"\u0107",cap:"\u2229",capand:"\u2a44",capbrcup:"\u2a49",capcap:"\u2a4b",capcup:"\u2a47",capdot:"\u2a40",caps:"\u2229\ufe00",caret:"\u2041",ccaps:"\u2a4d",ccaron:"\u010d",ccedil:"\xe7",ccirc:"\u0109",ccups:"\u2a4c",ccupssm:"\u2a50",cdot:"\u010b",cemptyv:"\u29b2",cent:"\xa2",cfr:"\ud835\udd20",chcy:"\u0447",check:"\u2713",checkmark:"\u2713",chi:"\u03c7",cir:"\u25cb",cirE:"\u29c3",circ:"\u02c6",circeq:"\u2257",cire:"\u2257",circlearrowleft:"\u21ba",olarr:"\u21ba",circlearrowright:"\u21bb",orarr:"\u21bb",circledS:"\u24c8",oS:"\u24c8",circledast:"\u229b",oast:"\u229b",circledcirc:"\u229a",ocir:"\u229a",circleddash:"\u229d",odash:"\u229d",cirfnint:"\u2a10",cirmid:"\u2aef",cirscir:"\u29c2",clubs:"\u2663",clubsuit:"\u2663",colon:":",comma:",",commat:"@",comp:"\u2201",complement:"\u2201",congdot:"\u2a6d",copf:"\ud835\udd54",copysr:"\u2117",crarr:"\u21b5",cross:"\u2717",cscr:"\ud835\udcb8",csub:"\u2acf",csube:"\u2ad1",csup:"\u2ad0",csupe:"\u2ad2",ctdot:"\u22ef",cudarrl:"\u2938",cudarrr:"\u2935",cuepr:"\u22de",curlyeqprec:"\u22de",cuesc:"\u22df",curlyeqsucc:"\u22df",cularr:"\u21b6",curvearrowleft:"\u21b6",cularrp:"\u293d",cup:"\u222a",cupbrcap:"\u2a48",cupcap:"\u2a46",cupcup:"\u2a4a",cupdot:"\u228d",cupor:"\u2a45",cups:"\u222a\ufe00",curarr:"\u21b7",curvearrowright:"\u21b7",curarrm:"\u293c",curlyvee:"\u22ce",cuvee:"\u22ce",curlywedge:"\u22cf",cuwed:"\u22cf",curren:"\xa4",cwint:"\u2231",cylcty:"\u232d",dHar:"\u2965",dagger:"\u2020",daleth:"\u2138",dash:"\u2010",hyphen:"\u2010",dbkarow:"\u290f",rBarr:"\u290f",dcaron:"\u010f",dcy:"\u0434",ddarr:"\u21ca",downdownarrows:"\u21ca",ddotseq:"\u2a77",eDDot:"\u2a77",deg:"\xb0",delta:"\u03b4",demptyv:"\u29b1",dfisht:"\u297f",dfr:"\ud835\udd21",diamondsuit:"\u2666",diams:"\u2666",digamma:"\u03dd",gammad:"\u03dd",disin:"\u22f2",div:"\xf7",divide:"\xf7",divideontimes:"\u22c7",divonx:"\u22c7",djcy:"\u0452",dlcorn:"\u231e",llcorner:"\u231e",dlcrop:"\u230d",dollar:"$",dopf:"\ud835\udd55",doteqdot:"\u2251",eDot:"\u2251",dotminus:"\u2238",minusd:"\u2238",dotplus:"\u2214",plusdo:"\u2214",dotsquare:"\u22a1",sdotb:"\u22a1",drcorn:"\u231f",lrcorner:"\u231f",drcrop:"\u230c",dscr:"\ud835\udcb9",dscy:"\u0455",dsol:"\u29f6",dstrok:"\u0111",dtdot:"\u22f1",dtri:"\u25bf",triangledown:"\u25bf",dwangle:"\u29a6",dzcy:"\u045f",dzigrarr:"\u27ff",eacute:"\xe9",easter:"\u2a6e",ecaron:"\u011b",ecir:"\u2256",eqcirc:"\u2256",ecirc:"\xea",ecolon:"\u2255",eqcolon:"\u2255",ecy:"\u044d",edot:"\u0117",efDot:"\u2252",fallingdotseq:"\u2252",efr:"\ud835\udd22",eg:"\u2a9a",egrave:"\xe8",egs:"\u2a96",eqslantgtr:"\u2a96",egsdot:"\u2a98",el:"\u2a99",elinters:"\u23e7",ell:"\u2113",els:"\u2a95",eqslantless:"\u2a95",elsdot:"\u2a97",emacr:"\u0113",empty:"\u2205",emptyset:"\u2205",emptyv:"\u2205",varnothing:"\u2205",emsp13:"\u2004",emsp14:"\u2005",emsp:"\u2003",eng:"\u014b",ensp:"\u2002",eogon:"\u0119",eopf:"\ud835\udd56",epar:"\u22d5",eparsl:"\u29e3",eplus:"\u2a71",epsi:"\u03b5",epsilon:"\u03b5",epsiv:"\u03f5",straightepsilon:"\u03f5",varepsilon:"\u03f5",equals:"=",equest:"\u225f",questeq:"\u225f",equivDD:"\u2a78",eqvparsl:"\u29e5",erDot:"\u2253",risingdotseq:"\u2253",erarr:"\u2971",escr:"\u212f",eta:"\u03b7",eth:"\xf0",euml:"\xeb",euro:"\u20ac",excl:"!",fcy:"\u0444",female:"\u2640",ffilig:"\ufb03",fflig:"\ufb00",ffllig:"\ufb04",ffr:"\ud835\udd23",filig:"\ufb01",fjlig:"fj",flat:"\u266d",fllig:"\ufb02",fltns:"\u25b1",fnof:"\u0192",fopf:"\ud835\udd57",fork:"\u22d4",pitchfork:"\u22d4",forkv:"\u2ad9",fpartint:"\u2a0d",frac12:"\xbd",half:"\xbd",frac13:"\u2153",frac14:"\xbc",frac15:"\u2155",frac16:"\u2159",frac18:"\u215b",frac23:"\u2154",frac25:"\u2156",frac34:"\xbe",frac35:"\u2157",frac38:"\u215c",frac45:"\u2158",frac56:"\u215a",frac58:"\u215d",frac78:"\u215e",frasl:"\u2044",frown:"\u2322",sfrown:"\u2322",fscr:"\ud835\udcbb",gEl:"\u2a8c",gtreqqless:"\u2a8c",gacute:"\u01f5",gamma:"\u03b3",gap:"\u2a86",gtrapprox:"\u2a86",gbreve:"\u011f",gcirc:"\u011d",gcy:"\u0433",gdot:"\u0121",gescc:"\u2aa9",gesdot:"\u2a80",gesdoto:"\u2a82",gesdotol:"\u2a84",gesl:"\u22db\ufe00",gesles:"\u2a94",gfr:"\ud835\udd24",gimel:"\u2137",gjcy:"\u0453",glE:"\u2a92",gla:"\u2aa5",glj:"\u2aa4",gnE:"\u2269",gneqq:"\u2269",gnap:"\u2a8a",gnapprox:"\u2a8a",gne:"\u2a88",gneq:"\u2a88",gnsim:"\u22e7",gopf:"\ud835\udd58",gscr:"\u210a",gsime:"\u2a8e",gsiml:"\u2a90",gtcc:"\u2aa7",gtcir:"\u2a7a",gtdot:"\u22d7",gtrdot:"\u22d7",gtlPar:"\u2995",gtquest:"\u2a7c",gtrarr:"\u2978",gvertneqq:"\u2269\ufe00",gvnE:"\u2269\ufe00",hardcy:"\u044a",harrcir:"\u2948",harrw:"\u21ad",leftrightsquigarrow:"\u21ad",hbar:"\u210f",hslash:"\u210f",planck:"\u210f",plankv:"\u210f",hcirc:"\u0125",hearts:"\u2665",heartsuit:"\u2665",hellip:"\u2026",mldr:"\u2026",hercon:"\u22b9",hfr:"\ud835\udd25",hksearow:"\u2925",searhk:"\u2925",hkswarow:"\u2926",swarhk:"\u2926",hoarr:"\u21ff",homtht:"\u223b",hookleftarrow:"\u21a9",larrhk:"\u21a9",hookrightarrow:"\u21aa",rarrhk:"\u21aa",hopf:"\ud835\udd59",horbar:"\u2015",hscr:"\ud835\udcbd",hstrok:"\u0127",hybull:"\u2043",iacute:"\xed",icirc:"\xee",icy:"\u0438",iecy:"\u0435",iexcl:"\xa1",ifr:"\ud835\udd26",igrave:"\xec",iiiint:"\u2a0c",qint:"\u2a0c",iiint:"\u222d",tint:"\u222d",iinfin:"\u29dc",iiota:"\u2129",ijlig:"\u0133",imacr:"\u012b",imath:"\u0131",inodot:"\u0131",imof:"\u22b7",imped:"\u01b5",incare:"\u2105",infin:"\u221e",infintie:"\u29dd",intcal:"\u22ba",intercal:"\u22ba",intlarhk:"\u2a17",intprod:"\u2a3c",iprod:"\u2a3c",iocy:"\u0451",iogon:"\u012f",iopf:"\ud835\udd5a",iota:"\u03b9",iquest:"\xbf",iscr:"\ud835\udcbe",isinE:"\u22f9",isindot:"\u22f5",isins:"\u22f4",isinsv:"\u22f3",itilde:"\u0129",iukcy:"\u0456",iuml:"\xef",jcirc:"\u0135",jcy:"\u0439",jfr:"\ud835\udd27",jmath:"\u0237",jopf:"\ud835\udd5b",jscr:"\ud835\udcbf",jsercy:"\u0458",jukcy:"\u0454",kappa:"\u03ba",kappav:"\u03f0",varkappa:"\u03f0",kcedil:"\u0137",kcy:"\u043a",kfr:"\ud835\udd28",kgreen:"\u0138",khcy:"\u0445",kjcy:"\u045c",kopf:"\ud835\udd5c",kscr:"\ud835\udcc0",lAtail:"\u291b",lBarr:"\u290e",lEg:"\u2a8b",lesseqqgtr:"\u2a8b",lHar:"\u2962",lacute:"\u013a",laemptyv:"\u29b4",lambda:"\u03bb",langd:"\u2991",lap:"\u2a85",lessapprox:"\u2a85",laquo:"\xab",larrbfs:"\u291f",larrfs:"\u291d",larrlp:"\u21ab",looparrowleft:"\u21ab",larrpl:"\u2939",larrsim:"\u2973",larrtl:"\u21a2",leftarrowtail:"\u21a2",lat:"\u2aab",latail:"\u2919",late:"\u2aad",lates:"\u2aad\ufe00",lbarr:"\u290c",lbbrk:"\u2772",lbrace:"{",lcub:"{",lbrack:"[",lsqb:"[",lbrke:"\u298b",lbrksld:"\u298f",lbrkslu:"\u298d",lcaron:"\u013e",lcedil:"\u013c",lcy:"\u043b",ldca:"\u2936",ldrdhar:"\u2967",ldrushar:"\u294b",ldsh:"\u21b2",le:"\u2264",leq:"\u2264",leftleftarrows:"\u21c7",llarr:"\u21c7",leftthreetimes:"\u22cb",lthree:"\u22cb",lescc:"\u2aa8",lesdot:"\u2a7f",lesdoto:"\u2a81",lesdotor:"\u2a83",lesg:"\u22da\ufe00",lesges:"\u2a93",lessdot:"\u22d6",ltdot:"\u22d6",lfisht:"\u297c",lfr:"\ud835\udd29",lgE:"\u2a91",lharul:"\u296a",lhblk:"\u2584",ljcy:"\u0459",llhard:"\u296b",lltri:"\u25fa",lmidot:"\u0140",lmoust:"\u23b0",lmoustache:"\u23b0",lnE:"\u2268",lneqq:"\u2268",lnap:"\u2a89",lnapprox:"\u2a89",lne:"\u2a87",lneq:"\u2a87",lnsim:"\u22e6",loang:"\u27ec",loarr:"\u21fd",longmapsto:"\u27fc",xmap:"\u27fc",looparrowright:"\u21ac",rarrlp:"\u21ac",lopar:"\u2985",lopf:"\ud835\udd5d",loplus:"\u2a2d",lotimes:"\u2a34",lowast:"\u2217",loz:"\u25ca",lozenge:"\u25ca",lpar:"(",lparlt:"\u2993",lrhard:"\u296d",lrm:"\u200e",lrtri:"\u22bf",lsaquo:"\u2039",lscr:"\ud835\udcc1",lsime:"\u2a8d",lsimg:"\u2a8f",lsquor:"\u201a",sbquo:"\u201a",lstrok:"\u0142",ltcc:"\u2aa6",ltcir:"\u2a79",ltimes:"\u22c9",ltlarr:"\u2976",ltquest:"\u2a7b",ltrPar:"\u2996",ltri:"\u25c3",triangleleft:"\u25c3",lurdshar:"\u294a",luruhar:"\u2966",lvertneqq:"\u2268\ufe00",lvnE:"\u2268\ufe00",mDDot:"\u223a",macr:"\xaf",strns:"\xaf",male:"\u2642",malt:"\u2720",maltese:"\u2720",marker:"\u25ae",mcomma:"\u2a29",mcy:"\u043c",mdash:"\u2014",mfr:"\ud835\udd2a",mho:"\u2127",micro:"\xb5",midcir:"\u2af0",minus:"\u2212",minusdu:"\u2a2a",mlcp:"\u2adb",models:"\u22a7",mopf:"\ud835\udd5e",mscr:"\ud835\udcc2",mu:"\u03bc",multimap:"\u22b8",mumap:"\u22b8",nGg:"\u22d9\u0338",nGt:"\u226b\u20d2",nLeftarrow:"\u21cd",nlArr:"\u21cd",nLeftrightarrow:"\u21ce",nhArr:"\u21ce",nLl:"\u22d8\u0338",nLt:"\u226a\u20d2",nRightarrow:"\u21cf",nrArr:"\u21cf",nVDash:"\u22af",nVdash:"\u22ae",nacute:"\u0144",nang:"\u2220\u20d2",napE:"\u2a70\u0338",napid:"\u224b\u0338",napos:"\u0149",natur:"\u266e",natural:"\u266e",ncap:"\u2a43",ncaron:"\u0148",ncedil:"\u0146",ncongdot:"\u2a6d\u0338",ncup:"\u2a42",ncy:"\u043d",ndash:"\u2013",neArr:"\u21d7",nearhk:"\u2924",nedot:"\u2250\u0338",nesear:"\u2928",toea:"\u2928",nfr:"\ud835\udd2b",nharr:"\u21ae",nleftrightarrow:"\u21ae",nhpar:"\u2af2",nis:"\u22fc",nisd:"\u22fa",njcy:"\u045a",nlE:"\u2266\u0338",nleqq:"\u2266\u0338",nlarr:"\u219a",nleftarrow:"\u219a",nldr:"\u2025",nopf:"\ud835\udd5f",not:"\xac",notinE:"\u22f9\u0338",notindot:"\u22f5\u0338",notinvb:"\u22f7",notinvc:"\u22f6",notnivb:"\u22fe",notnivc:"\u22fd",nparsl:"\u2afd\u20e5",npart:"\u2202\u0338",npolint:"\u2a14",nrarr:"\u219b",nrightarrow:"\u219b",nrarrc:"\u2933\u0338",nrarrw:"\u219d\u0338",nscr:"\ud835\udcc3",nsub:"\u2284",nsubE:"\u2ac5\u0338",nsubseteqq:"\u2ac5\u0338",nsup:"\u2285",nsupE:"\u2ac6\u0338",nsupseteqq:"\u2ac6\u0338",ntilde:"\xf1",nu:"\u03bd",num:"#",numero:"\u2116",numsp:"\u2007",nvDash:"\u22ad",nvHarr:"\u2904",nvap:"\u224d\u20d2",nvdash:"\u22ac",nvge:"\u2265\u20d2",nvgt:">\u20d2",nvinfin:"\u29de",nvlArr:"\u2902",nvle:"\u2264\u20d2",nvlt:"<\u20d2",nvltrie:"\u22b4\u20d2",nvrArr:"\u2903",nvrtrie:"\u22b5\u20d2",nvsim:"\u223c\u20d2",nwArr:"\u21d6",nwarhk:"\u2923",nwnear:"\u2927",oacute:"\xf3",ocirc:"\xf4",ocy:"\u043e",odblac:"\u0151",odiv:"\u2a38",odsold:"\u29bc",oelig:"\u0153",ofcir:"\u29bf",ofr:"\ud835\udd2c",ogon:"\u02db",ograve:"\xf2",ogt:"\u29c1",ohbar:"\u29b5",olcir:"\u29be",olcross:"\u29bb",olt:"\u29c0",omacr:"\u014d",omega:"\u03c9",omicron:"\u03bf",omid:"\u29b6",oopf:"\ud835\udd60",opar:"\u29b7",operp:"\u29b9",or:"\u2228",vee:"\u2228",ord:"\u2a5d",order:"\u2134",orderof:"\u2134",oscr:"\u2134",ordf:"\xaa",ordm:"\xba",origof:"\u22b6",oror:"\u2a56",orslope:"\u2a57",orv:"\u2a5b",oslash:"\xf8",osol:"\u2298",otilde:"\xf5",otimesas:"\u2a36",ouml:"\xf6",ovbar:"\u233d",para:"\xb6",parsim:"\u2af3",parsl:"\u2afd",pcy:"\u043f",percnt:"%",period:".",permil:"\u2030",pertenk:"\u2031",pfr:"\ud835\udd2d",phi:"\u03c6",phiv:"\u03d5",straightphi:"\u03d5",varphi:"\u03d5",phone:"\u260e",pi:"\u03c0",piv:"\u03d6",varpi:"\u03d6",planckh:"\u210e",plus:"+",plusacir:"\u2a23",pluscir:"\u2a22",plusdu:"\u2a25",pluse:"\u2a72",plussim:"\u2a26",plustwo:"\u2a27",pointint:"\u2a15",popf:"\ud835\udd61",pound:"\xa3",prE:"\u2ab3",prap:"\u2ab7",precapprox:"\u2ab7",precnapprox:"\u2ab9",prnap:"\u2ab9",precneqq:"\u2ab5",prnE:"\u2ab5",precnsim:"\u22e8",prnsim:"\u22e8",prime:"\u2032",profalar:"\u232e",profline:"\u2312",profsurf:"\u2313",prurel:"\u22b0",pscr:"\ud835\udcc5",psi:"\u03c8",puncsp:"\u2008",qfr:"\ud835\udd2e",qopf:"\ud835\udd62",qprime:"\u2057",qscr:"\ud835\udcc6",quatint:"\u2a16",quest:"?",rAtail:"\u291c",rHar:"\u2964",race:"\u223d\u0331",racute:"\u0155",raemptyv:"\u29b3",rangd:"\u2992",range:"\u29a5",raquo:"\xbb",rarrap:"\u2975",rarrbfs:"\u2920",rarrc:"\u2933",rarrfs:"\u291e",rarrpl:"\u2945",rarrsim:"\u2974",rarrtl:"\u21a3",rightarrowtail:"\u21a3",rarrw:"\u219d",rightsquigarrow:"\u219d",ratail:"\u291a",ratio:"\u2236",rbbrk:"\u2773",rbrace:"}",rcub:"}",rbrack:"]",rsqb:"]",rbrke:"\u298c",rbrksld:"\u298e",rbrkslu:"\u2990",rcaron:"\u0159",rcedil:"\u0157",rcy:"\u0440",rdca:"\u2937",rdldhar:"\u2969",rdsh:"\u21b3",rect:"\u25ad",rfisht:"\u297d",rfr:"\ud835\udd2f",rharul:"\u296c",rho:"\u03c1",rhov:"\u03f1",varrho:"\u03f1",rightrightarrows:"\u21c9",rrarr:"\u21c9",rightthreetimes:"\u22cc",rthree:"\u22cc",ring:"\u02da",rlm:"\u200f",rmoust:"\u23b1",rmoustache:"\u23b1",rnmid:"\u2aee",roang:"\u27ed",roarr:"\u21fe",ropar:"\u2986",ropf:"\ud835\udd63",roplus:"\u2a2e",rotimes:"\u2a35",rpar:")",rpargt:"\u2994",rppolint:"\u2a12",rsaquo:"\u203a",rscr:"\ud835\udcc7",rtimes:"\u22ca",rtri:"\u25b9",triangleright:"\u25b9",rtriltri:"\u29ce",ruluhar:"\u2968",rx:"\u211e",sacute:"\u015b",scE:"\u2ab4",scap:"\u2ab8",succapprox:"\u2ab8",scaron:"\u0161",scedil:"\u015f",scirc:"\u015d",scnE:"\u2ab6",succneqq:"\u2ab6",scnap:"\u2aba",succnapprox:"\u2aba",scnsim:"\u22e9",succnsim:"\u22e9",scpolint:"\u2a13",scy:"\u0441",sdot:"\u22c5",sdote:"\u2a66",seArr:"\u21d8",sect:"\xa7",semi:";",seswar:"\u2929",tosa:"\u2929",sext:"\u2736",sfr:"\ud835\udd30",sharp:"\u266f",shchcy:"\u0449",shcy:"\u0448",shy:"\xad",sigma:"\u03c3",sigmaf:"\u03c2",sigmav:"\u03c2",varsigma:"\u03c2",simdot:"\u2a6a",simg:"\u2a9e",simgE:"\u2aa0",siml:"\u2a9d",simlE:"\u2a9f",simne:"\u2246",simplus:"\u2a24",simrarr:"\u2972",smashp:"\u2a33",smeparsl:"\u29e4",smile:"\u2323",ssmile:"\u2323",smt:"\u2aaa",smte:"\u2aac",smtes:"\u2aac\ufe00",softcy:"\u044c",sol:"/",solb:"\u29c4",solbar:"\u233f",sopf:"\ud835\udd64",spades:"\u2660",spadesuit:"\u2660",sqcaps:"\u2293\ufe00",sqcups:"\u2294\ufe00",sscr:"\ud835\udcc8",star:"\u2606",sub:"\u2282",subset:"\u2282",subE:"\u2ac5",subseteqq:"\u2ac5",subdot:"\u2abd",subedot:"\u2ac3",submult:"\u2ac1",subnE:"\u2acb",subsetneqq:"\u2acb",subne:"\u228a",subsetneq:"\u228a",subplus:"\u2abf",subrarr:"\u2979",subsim:"\u2ac7",subsub:"\u2ad5",subsup:"\u2ad3",sung:"\u266a",sup1:"\xb9",sup2:"\xb2",sup3:"\xb3",supE:"\u2ac6",supseteqq:"\u2ac6",supdot:"\u2abe",supdsub:"\u2ad8",supedot:"\u2ac4",suphsol:"\u27c9",suphsub:"\u2ad7",suplarr:"\u297b",supmult:"\u2ac2",supnE:"\u2acc",supsetneqq:"\u2acc",supne:"\u228b",supsetneq:"\u228b",supplus:"\u2ac0",supsim:"\u2ac8",supsub:"\u2ad4",supsup:"\u2ad6",swArr:"\u21d9",swnwar:"\u292a",szlig:"\xdf",target:"\u2316",tau:"\u03c4",tcaron:"\u0165",tcedil:"\u0163",tcy:"\u0442",telrec:"\u2315",tfr:"\ud835\udd31",theta:"\u03b8",thetasym:"\u03d1",thetav:"\u03d1",vartheta:"\u03d1",thorn:"\xfe",times:"\xd7",timesbar:"\u2a31",timesd:"\u2a30",topbot:"\u2336",topcir:"\u2af1",topf:"\ud835\udd65",topfork:"\u2ada",tprime:"\u2034",triangle:"\u25b5",utri:"\u25b5",triangleq:"\u225c",trie:"\u225c",tridot:"\u25ec",triminus:"\u2a3a",triplus:"\u2a39",trisb:"\u29cd",tritime:"\u2a3b",trpezium:"\u23e2",tscr:"\ud835\udcc9",tscy:"\u0446",tshcy:"\u045b",tstrok:"\u0167",uHar:"\u2963",uacute:"\xfa",ubrcy:"\u045e",ubreve:"\u016d",ucirc:"\xfb",ucy:"\u0443",udblac:"\u0171",ufisht:"\u297e",ufr:"\ud835\udd32",ugrave:"\xf9",uhblk:"\u2580",ulcorn:"\u231c",ulcorner:"\u231c",ulcrop:"\u230f",ultri:"\u25f8",umacr:"\u016b",uogon:"\u0173",uopf:"\ud835\udd66",upsi:"\u03c5",upsilon:"\u03c5",upuparrows:"\u21c8",uuarr:"\u21c8",urcorn:"\u231d",urcorner:"\u231d",urcrop:"\u230e",uring:"\u016f",urtri:"\u25f9",uscr:"\ud835\udcca",utdot:"\u22f0",utilde:"\u0169",uuml:"\xfc",uwangle:"\u29a7",vBar:"\u2ae8",vBarv:"\u2ae9",vangrt:"\u299c",varsubsetneq:"\u228a\ufe00",vsubne:"\u228a\ufe00",varsubsetneqq:"\u2acb\ufe00",vsubnE:"\u2acb\ufe00",varsupsetneq:"\u228b\ufe00",vsupne:"\u228b\ufe00",varsupsetneqq:"\u2acc\ufe00",vsupnE:"\u2acc\ufe00",vcy:"\u0432",veebar:"\u22bb",veeeq:"\u225a",vellip:"\u22ee",vfr:"\ud835\udd33",vopf:"\ud835\udd67",vscr:"\ud835\udccb",vzigzag:"\u299a",wcirc:"\u0175",wedbar:"\u2a5f",wedgeq:"\u2259",weierp:"\u2118",wp:"\u2118",wfr:"\ud835\udd34",wopf:"\ud835\udd68",wscr:"\ud835\udccc",xfr:"\ud835\udd35",xi:"\u03be",xnis:"\u22fb",xopf:"\ud835\udd69",xscr:"\ud835\udccd",yacute:"\xfd",yacy:"\u044f",ycirc:"\u0177",ycy:"\u044b",yen:"\xa5",yfr:"\ud835\udd36",yicy:"\u0457",yopf:"\ud835\udd6a",yscr:"\ud835\udcce",yucy:"\u044e",yuml:"\xff",zacute:"\u017a",zcaron:"\u017e",zcy:"\u0437",zdot:"\u017c",zeta:"\u03b6",zfr:"\ud835\udd37",zhcy:"\u0436",zigrarr:"\u21dd",zopf:"\ud835\udd6b",zscr:"\ud835\udccf",zwj:"\u200d",zwnj:"\u200c",ngsp:"\ue500"},hC=class extends ym{constructor(t,e,i){super(i,t),this.tokenType=e}},eEe=/\r\n?/g;function rC(n){return`Unexpected character "${0===n?"EOF":String.fromCharCode(n)}"`}function iQ(n){return`Unknown entity "${n}" - use the "&#<decimal>;" or  "&#x<hex>;" syntax`}var fC=(()=>{return(n=fC||(fC={})).HEX="hexadecimal",n.DEC="decimal",fC;var n})(),mC=class{constructor(t){this.error=t}};function rl(n){return!QV(n)||0===n}function rQ(n){return QV(n)||62===n||60===n||47===n||39===n||34===n||61===n||0===n}function iEe(n){return 59===n||0===n||!function(n){return n>=97&&n<=102||n>=65&&n<=70||$p(n)}(n)}function rEe(n){return 59===n||0===n||!KV(n)}function oQ(n){return n>=97&&n<=122?n-97+65:n}var Mm=class{constructor(t,e){if(t instanceof Mm){this.file=t.file,this.input=t.input,this.end=t.end;let i=t.state;this.state={peek:i.peek,offset:i.offset,line:i.line,column:i.column}}else{if(!e)throw new Error("Programming error: the range argument must be provided with a file argument.");this.file=t,this.input=t.content,this.end=e.endPos,this.state={peek:-1,offset:e.startPos,line:e.startLine,column:e.startCol}}}clone(){return new Mm(this)}peek(){return this.state.peek}charsLeft(){return this.end-this.state.offset}diff(t){return this.state.offset-t.state.offset}advance(){this.advanceState(this.state)}init(){this.updatePeek(this.state)}getSpan(t,e){let i=t=t||this;if(e)for(;this.diff(t)>0&&-1!==e.indexOf(t.peek());)i===t&&(t=t.clone()),t.advance();let r=this.locationFromCursor(t),o=this.locationFromCursor(this),s=i!==t?this.locationFromCursor(i):r;return new Go(r,o,s)}getChars(t){return this.input.substring(t.state.offset,this.state.offset)}charAt(t){return this.input.charCodeAt(t)}advanceState(t){if(t.offset>=this.end)throw this.state=t,new YC('Unexpected character "EOF"',this);let e=this.charAt(t.offset);10===e?(t.line++,t.column=0):cK(e)||t.column++,t.offset++,this.updatePeek(t)}updatePeek(t){t.peek=t.offset>=this.end?0:this.charAt(t.offset)}locationFromCursor(t){return new vm(t.file,t.state.offset,t.state.line,t.state.column)}},L_=class extends Mm{constructor(t,e){t instanceof L_?(super(t),this.internalState={...t.internalState}):(super(t,e),this.internalState=this.state)}advance(){this.state=this.internalState,super.advance(),this.processEscapeSequence()}init(){super.init(),this.processEscapeSequence()}clone(){return new L_(this)}getChars(t){let e=t.clone(),i="";for(;e.internalState.offset<this.internalState.offset;)i+=String.fromCodePoint(e.peek()),e.advance();return i}processEscapeSequence(){let t=()=>this.internalState.peek;if(92===t())if(this.internalState={...this.state},this.advanceState(this.internalState),110===t())this.state.peek=10;else if(114===t())this.state.peek=13;else if(118===t())this.state.peek=11;else if(116===t())this.state.peek=9;else if(98===t())this.state.peek=8;else if(102===t())this.state.peek=12;else if(117===t())if(this.advanceState(this.internalState),t()===th){this.advanceState(this.internalState);let e=this.clone(),i=0;for(;t()!==Ou;)this.advanceState(this.internalState),i++;this.state.peek=this.decodeHexDigits(e,i)}else{let e=this.clone();this.advanceState(this.internalState),this.advanceState(this.internalState),this.advanceState(this.internalState),this.state.peek=this.decodeHexDigits(e,4)}else if(120===t()){this.advanceState(this.internalState);let e=this.clone();this.advanceState(this.internalState),this.state.peek=this.decodeHexDigits(e,2)}else if(VX(t())){let e="",i=0,r=this.clone();for(;VX(t())&&i<3;)r=this.clone(),e+=String.fromCodePoint(t()),this.advanceState(this.internalState),i++;this.state.peek=parseInt(e,8),this.internalState=r.internalState}else cK(this.internalState.peek)?(this.advanceState(this.internalState),this.state=this.internalState):this.state.peek=this.internalState.peek}decodeHexDigits(t,e){let i=this.input.slice(t.internalState.offset,t.internalState.offset+e),r=parseInt(i,16);if(isNaN(r))throw t.state=t.internalState,new YC("Invalid hexadecimal escape sequence",t);return r}},YC=class{constructor(t,e){this.msg=t,this.cursor=e}},ol=class extends ym{constructor(t,e,i){super(e,i),this.elementName=t}static create(t,e,i){return new ol(t,e,i)}},MD=class{constructor(t,e){this.rootNodes=t,this.errors=e}},gV=class{constructor(t){this.getTagDefinition=t}parse(t,e,i){let r=function(n,t,e,i={}){let r=new class{constructor(t,e,i){this._getTagDefinition=e,this._currentTokenStart=null,this._currentTokenType=null,this._expansionCaseStack=[],this._inInterpolation=!1,this.tokens=[],this.errors=[],this.nonNormalizedIcuExpressions=[],this._tokenizeIcu=i.tokenizeExpansionForms||!1,this._interpolationConfig=i.interpolationConfig||Pu,this._leadingTriviaCodePoints=i.leadingTriviaChars&&i.leadingTriviaChars.map(o=>o.codePointAt(0)||0);let r=i.range||{endPos:t.content.length,startPos:0,startLine:0,startCol:0};this._cursor=i.escapedString?new L_(t,r):new Mm(t,r),this._preserveLineEndings=i.preserveLineEndings||!1,this._escapedString=i.escapedString||!1,this._i18nNormalizeLineEndingsInICUs=i.i18nNormalizeLineEndingsInICUs||!1;try{this._cursor.init()}catch(o){this.handleError(o)}}_processCarriageReturns(t){return this._preserveLineEndings?t:t.replace(eEe,"\n")}tokenize(){for(;0!==this._cursor.peek();){let t=this._cursor.clone();try{this._attemptCharCode(60)?this._attemptCharCode(33)?this._attemptCharCode(91)?this._consumeCdata(t):this._attemptCharCode(45)?this._consumeComment(t):this._consumeDocType(t):this._attemptCharCode(47)?this._consumeTagClose(t):this._consumeTagOpen(t):this._tokenizeIcu&&this._tokenizeExpansionForm()||this._consumeWithInterpolation(5,8,()=>this._isTextEnd(),()=>this._isTagStart())}catch(e){this.handleError(e)}}this._beginToken(24),this._endToken([])}_tokenizeExpansionForm(){if(this.isExpansionFormStart())return this._consumeExpansionFormStart(),!0;if(this._cursor.peek()!==Ou&&this._isInExpansionForm())return this._consumeExpansionCaseStart(),!0;if(this._cursor.peek()===Ou){if(this._isInExpansionCase())return this._consumeExpansionCaseEnd(),!0;if(this._isInExpansionForm())return this._consumeExpansionFormEnd(),!0}return!1}_beginToken(t,e=this._cursor.clone()){this._currentTokenStart=e,this._currentTokenType=t}_endToken(t,e){if(null===this._currentTokenStart)throw new hC("Programming error - attempted to end a token when there was no start to the token",this._currentTokenType,this._cursor.getSpan(e));if(null===this._currentTokenType)throw new hC("Programming error - attempted to end a token which has no token type",null,this._cursor.getSpan(this._currentTokenStart));let i={type:this._currentTokenType,parts:t,sourceSpan:(e??this._cursor).getSpan(this._currentTokenStart,this._leadingTriviaCodePoints)};return this.tokens.push(i),this._currentTokenStart=null,this._currentTokenType=null,i}_createError(t,e){this._isInExpansionForm()&&(t+=' (Do you have an unescaped "{" in your template? Use "{{ \'{\' }}") to escape it.)');let i=new hC(t,this._currentTokenType,e);return this._currentTokenStart=null,this._currentTokenType=null,new mC(i)}handleError(t){if(t instanceof YC&&(t=this._createError(t.msg,this._cursor.getSpan(t.cursor))),!(t instanceof mC))throw t;this.errors.push(t.error)}_attemptCharCode(t){return this._cursor.peek()===t&&(this._cursor.advance(),!0)}_attemptCharCodeCaseInsensitive(t){return!!function(n,t){return oQ(n)===oQ(t)}(this._cursor.peek(),t)&&(this._cursor.advance(),!0)}_requireCharCode(t){let e=this._cursor.clone();if(!this._attemptCharCode(t))throw this._createError(rC(this._cursor.peek()),this._cursor.getSpan(e))}_attemptStr(t){let e=t.length;if(this._cursor.charsLeft()<e)return!1;let i=this._cursor.clone();for(let r=0;r<e;r++)if(!this._attemptCharCode(t.charCodeAt(r)))return this._cursor=i,!1;return!0}_attemptStrCaseInsensitive(t){for(let e=0;e<t.length;e++)if(!this._attemptCharCodeCaseInsensitive(t.charCodeAt(e)))return!1;return!0}_requireStr(t){let e=this._cursor.clone();if(!this._attemptStr(t))throw this._createError(rC(this._cursor.peek()),this._cursor.getSpan(e))}_attemptCharCodeUntilFn(t){for(;!t(this._cursor.peek());)this._cursor.advance()}_requireCharCodeUntilFn(t,e){let i=this._cursor.clone();if(this._attemptCharCodeUntilFn(t),this._cursor.diff(i)<e)throw this._createError(rC(this._cursor.peek()),this._cursor.getSpan(i))}_attemptUntilChar(t){for(;this._cursor.peek()!==t;)this._cursor.advance()}_readChar(){let t=String.fromCodePoint(this._cursor.peek());return this._cursor.advance(),t}_consumeEntity(t){this._beginToken(9);let e=this._cursor.clone();if(this._cursor.advance(),this._attemptCharCode(35)){let i=this._attemptCharCode(120)||this._attemptCharCode(88),r=this._cursor.clone();if(this._attemptCharCodeUntilFn(iEe),59!=this._cursor.peek())throw this._cursor.advance(),this._createError(function(n,t){return`Unable to parse entity "${t}" - ${n} character reference entities must end with ";"`}(i?fC.HEX:fC.DEC,this._cursor.getChars(e)),this._cursor.getSpan());let o=this._cursor.getChars(r);this._cursor.advance();try{let s=parseInt(o,i?16:10);this._endToken([String.fromCharCode(s),this._cursor.getChars(e)])}catch{throw this._createError(iQ(this._cursor.getChars(e)),this._cursor.getSpan())}}else{let i=this._cursor.clone();if(this._attemptCharCodeUntilFn(rEe),59!=this._cursor.peek())this._beginToken(t,e),this._cursor=i,this._endToken(["&"]);else{let r=this._cursor.getChars(i);this._cursor.advance();let o=CD[r];if(!o)throw this._createError(iQ(r),this._cursor.getSpan(e));this._endToken([o,`&${r};`])}}}_consumeRawText(t,e){this._beginToken(t?6:7);let i=[];for(;;){let r=this._cursor.clone(),o=e();if(this._cursor=r,o)break;t&&38===this._cursor.peek()?(this._endToken([this._processCarriageReturns(i.join(""))]),i.length=0,this._consumeEntity(6),this._beginToken(6)):i.push(this._readChar())}this._endToken([this._processCarriageReturns(i.join(""))])}_consumeComment(t){this._beginToken(10,t),this._requireCharCode(45),this._endToken([]),this._consumeRawText(!1,()=>this._attemptStr("--\x3e")),this._beginToken(11),this._requireStr("--\x3e"),this._endToken([])}_consumeCdata(t){this._beginToken(12,t),this._requireStr("CDATA["),this._endToken([]),this._consumeRawText(!1,()=>this._attemptStr("]]>")),this._beginToken(13),this._requireStr("]]>"),this._endToken([])}_consumeDocType(t){this._beginToken(18,t);let e=this._cursor.clone();this._attemptUntilChar(62);let i=this._cursor.getChars(e);this._cursor.advance(),this._endToken([i])}_consumePrefixAndName(){let t=this._cursor.clone(),e="";for(;58!==this._cursor.peek()&&!(((n=this._cursor.peek())<97||122<n)&&(n<65||90<n)&&(n<48||n>57));)this._cursor.advance();var n;let i;return 58===this._cursor.peek()?(e=this._cursor.getChars(t),this._cursor.advance(),i=this._cursor.clone()):i=t,this._requireCharCodeUntilFn(rQ,""===e?0:1),[e,this._cursor.getChars(i)]}_consumeTagOpen(t){let e,i,r;try{if(!KV(this._cursor.peek()))throw this._createError(rC(this._cursor.peek()),this._cursor.getSpan(t));for(r=this._consumeTagOpenStart(t),i=r.parts[0],e=r.parts[1],this._attemptCharCodeUntilFn(rl);47!==this._cursor.peek()&&62!==this._cursor.peek()&&60!==this._cursor.peek()&&0!==this._cursor.peek();)this._consumeAttributeName(),this._attemptCharCodeUntilFn(rl),this._attemptCharCode(61)&&(this._attemptCharCodeUntilFn(rl),this._consumeAttributeValue()),this._attemptCharCodeUntilFn(rl);this._consumeTagOpenEnd()}catch(s){if(s instanceof mC)return void(r?r.type=4:(this._beginToken(5,t),this._endToken(["<"])));throw s}let o=this._getTagDefinition(e).getContentType(i);o===Wl.RAW_TEXT?this._consumeRawTextWithTagClose(i,e,!1):o===Wl.ESCAPABLE_RAW_TEXT&&this._consumeRawTextWithTagClose(i,e,!0)}_consumeRawTextWithTagClose(t,e,i){this._consumeRawText(i,()=>!!(this._attemptCharCode(60)&&this._attemptCharCode(47)&&(this._attemptCharCodeUntilFn(rl),this._attemptStrCaseInsensitive(e)))&&(this._attemptCharCodeUntilFn(rl),this._attemptCharCode(62))),this._beginToken(3),this._requireCharCodeUntilFn(r=>62===r,3),this._cursor.advance(),this._endToken([t,e])}_consumeTagOpenStart(t){this._beginToken(0,t);let e=this._consumePrefixAndName();return this._endToken(e)}_consumeAttributeName(){let t=this._cursor.peek();if(39===t||34===t)throw this._createError(rC(t),this._cursor.getSpan());this._beginToken(14);let e=this._consumePrefixAndName();this._endToken(e)}_consumeAttributeValue(){if(39===this._cursor.peek()||34===this._cursor.peek()){let e=this._cursor.peek();this._consumeQuote(e);let i=()=>this._cursor.peek()===e;this._consumeWithInterpolation(16,17,i,i),this._consumeQuote(e)}else{let e=()=>rQ(this._cursor.peek());this._consumeWithInterpolation(16,17,e,e)}}_consumeQuote(t){this._beginToken(15),this._requireCharCode(t),this._endToken([String.fromCodePoint(t)])}_consumeTagOpenEnd(){let t=this._attemptCharCode(47)?2:1;this._beginToken(t),this._requireCharCode(62),this._endToken([])}_consumeTagClose(t){this._beginToken(3,t),this._attemptCharCodeUntilFn(rl);let e=this._consumePrefixAndName();this._attemptCharCodeUntilFn(rl),this._requireCharCode(62),this._endToken(e)}_consumeExpansionFormStart(){this._beginToken(19),this._requireCharCode(th),this._endToken([]),this._expansionCaseStack.push(19),this._beginToken(7);let t=this._readUntil(44),e=this._processCarriageReturns(t);if(this._i18nNormalizeLineEndingsInICUs)this._endToken([e]);else{let r=this._endToken([t]);e!==t&&this.nonNormalizedIcuExpressions.push(r)}this._requireCharCode(44),this._attemptCharCodeUntilFn(rl),this._beginToken(7);let i=this._readUntil(44);this._endToken([i]),this._requireCharCode(44),this._attemptCharCodeUntilFn(rl)}_consumeExpansionCaseStart(){this._beginToken(20);let t=this._readUntil(th).trim();this._endToken([t]),this._attemptCharCodeUntilFn(rl),this._beginToken(21),this._requireCharCode(th),this._endToken([]),this._attemptCharCodeUntilFn(rl),this._expansionCaseStack.push(21)}_consumeExpansionCaseEnd(){this._beginToken(22),this._requireCharCode(Ou),this._endToken([]),this._attemptCharCodeUntilFn(rl),this._expansionCaseStack.pop()}_consumeExpansionFormEnd(){this._beginToken(23),this._requireCharCode(Ou),this._endToken([]),this._expansionCaseStack.pop()}_consumeWithInterpolation(t,e,i,r){this._beginToken(t);let o=[];for(;!i();){let s=this._cursor.clone();this._interpolationConfig&&this._attemptStr(this._interpolationConfig.start)?(this._endToken([this._processCarriageReturns(o.join(""))],s),o.length=0,this._consumeInterpolation(e,s,r),this._beginToken(t)):38===this._cursor.peek()?(this._endToken([this._processCarriageReturns(o.join(""))]),o.length=0,this._consumeEntity(t),this._beginToken(t)):o.push(this._readChar())}this._inInterpolation=!1,this._endToken([this._processCarriageReturns(o.join(""))])}_consumeInterpolation(t,e,i){let r=[];this._beginToken(t,e),r.push(this._interpolationConfig.start);let o=this._cursor.clone(),s=null,a=!1;for(;0!==this._cursor.peek()&&(null===i||!i());){let l=this._cursor.clone();if(this._isTagStart())return this._cursor=l,r.push(this._getProcessedChars(o,l)),void this._endToken(r);if(null===s){if(this._attemptStr(this._interpolationConfig.end))return r.push(this._getProcessedChars(o,l)),r.push(this._interpolationConfig.end),void this._endToken(r);this._attemptStr("//")&&(a=!0)}let c=this._cursor.peek();this._cursor.advance(),92===c?this._cursor.advance():c===s?s=null:!a&&null===s&&WB(c)&&(s=c)}r.push(this._getProcessedChars(o,this._cursor)),this._endToken(r)}_getProcessedChars(t,e){return this._processCarriageReturns(e.getChars(t))}_isTextEnd(){return!!(this._isTagStart()||0===this._cursor.peek()||this._tokenizeIcu&&!this._inInterpolation&&(this.isExpansionFormStart()||this._cursor.peek()===Ou&&this._isInExpansionCase()))}_isTagStart(){if(60===this._cursor.peek()){let t=this._cursor.clone();t.advance();let e=t.peek();if(97<=e&&e<=122||65<=e&&e<=90||47===e||33===e)return!0}return!1}_readUntil(t){let e=this._cursor.clone();return this._attemptUntilChar(t),this._cursor.getChars(e)}_isInExpansionCase(){return this._expansionCaseStack.length>0&&21===this._expansionCaseStack[this._expansionCaseStack.length-1]}_isInExpansionForm(){return this._expansionCaseStack.length>0&&19===this._expansionCaseStack[this._expansionCaseStack.length-1]}isExpansionFormStart(){if(this._cursor.peek()!==th)return!1;if(this._interpolationConfig){let t=this._cursor.clone(),e=this._attemptStr(this._interpolationConfig.start);return this._cursor=t,!e}return!0}}(new pD(n,t),e,i);return r.tokenize(),new class{constructor(t,e,i){this.tokens=t,this.errors=e,this.nonNormalizedIcuExpressions=i}}(function(n){let e,t=[];for(let i=0;i<n.length;i++){let r=n[i];e&&5===e.type&&5===r.type||e&&16===e.type&&16===r.type?(e.parts[0]+=r.parts[0],e.sourceSpan.end=r.sourceSpan.end):(e=r,t.push(e))}return t}(r.tokens),r.errors,r.nonNormalizedIcuExpressions)}(t,e,this.getTagDefinition,i),o=new XC(r.tokens,this.getTagDefinition);return o.build(),new MD(o.rootNodes,r.errors.concat(o.errors))}},XC=class{constructor(t,e){this.tokens=t,this.getTagDefinition=e,this._index=-1,this._elementStack=[],this.rootNodes=[],this.errors=[],this._advance()}build(){for(;24!==this._peek.type;)0===this._peek.type||4===this._peek.type?this._consumeStartTag(this._advance()):3===this._peek.type?this._consumeEndTag(this._advance()):12===this._peek.type?(this._closeVoidElement(),this._consumeCdata(this._advance())):10===this._peek.type?(this._closeVoidElement(),this._consumeComment(this._advance())):5===this._peek.type||7===this._peek.type||6===this._peek.type?(this._closeVoidElement(),this._consumeText(this._advance())):19===this._peek.type?this._consumeExpansion(this._advance()):this._advance()}_advance(){let t=this._peek;return this._index<this.tokens.length-1&&this._index++,this._peek=this.tokens[this._index],t}_advanceIf(t){return this._peek.type===t?this._advance():null}_consumeCdata(t){this._consumeText(this._advance()),this._advanceIf(13)}_consumeComment(t){let e=this._advanceIf(7);this._advanceIf(11);let i=null!=e?e.parts[0].trim():null;this._addToParent(new xD(i,t.sourceSpan))}_consumeExpansion(t){let e=this._advance(),i=this._advance(),r=[];for(;20===this._peek.type;){let s=this._parseExpansionCase();if(!s)return;r.push(s)}if(23!==this._peek.type)return void this.errors.push(ol.create(null,this._peek.sourceSpan,"Invalid ICU message. Missing '}'."));let o=new Go(t.sourceSpan.start,this._peek.sourceSpan.end,t.sourceSpan.fullStart);this._addToParent(new N_(e.parts[0],i.parts[0],r,o,e.sourceSpan)),this._advance()}_parseExpansionCase(){let t=this._advance();if(21!==this._peek.type)return this.errors.push(ol.create(null,this._peek.sourceSpan,"Invalid ICU message. Missing '{'.")),null;let e=this._advance(),i=this._collectExpansionExpTokens(e);if(!i)return null;let r=this._advance();i.push({type:24,parts:[],sourceSpan:r.sourceSpan});let o=new XC(i,this.getTagDefinition);if(o.build(),o.errors.length>0)return this.errors=this.errors.concat(o.errors),null;let s=new Go(t.sourceSpan.start,r.sourceSpan.end,t.sourceSpan.fullStart),a=new Go(e.sourceSpan.start,r.sourceSpan.end,e.sourceSpan.fullStart);return new class{constructor(t,e,i,r,o){this.value=t,this.expression=e,this.sourceSpan=i,this.valueSourceSpan=r,this.expSourceSpan=o}visit(t,e){return t.visitExpansionCase(this,e)}}(t.parts[0],o.rootNodes,s,t.sourceSpan,a)}_collectExpansionExpTokens(t){let e=[],i=[21];for(;;){if((19===this._peek.type||21===this._peek.type)&&i.push(this._peek.type),22===this._peek.type){if(!sQ(i,21))return this.errors.push(ol.create(null,t.sourceSpan,"Invalid ICU message. Missing '}'.")),null;if(i.pop(),0===i.length)return e}if(23===this._peek.type){if(!sQ(i,19))return this.errors.push(ol.create(null,t.sourceSpan,"Invalid ICU message. Missing '}'.")),null;i.pop()}if(24===this._peek.type)return this.errors.push(ol.create(null,t.sourceSpan,"Invalid ICU message. Missing '}'.")),null;e.push(this._advance())}}_consumeText(t){let e=[t],i=t.sourceSpan,r=t.parts[0];if(r.length>0&&"\n"===r[0]){let o=this._getParentElement();null!=o&&0===o.children.length&&this.getTagDefinition(o.name).ignoreFirstLf&&(r=r.substring(1),e[0]={type:t.type,sourceSpan:t.sourceSpan,parts:[r]})}for(;8===this._peek.type||5===this._peek.type||9===this._peek.type;)t=this._advance(),e.push(t),r+=8===t.type?t.parts.join("").replace(/&([^;]+);/g,aQ):9===t.type?t.parts[0]:t.parts.join("");r.length>0&&this._addToParent(new F_(r,new Go(i.start,t.sourceSpan.end,i.fullStart,i.details),e))}_closeVoidElement(){let t=this._getParentElement();t&&this.getTagDefinition(t.name).isVoid&&this._elementStack.pop()}_consumeStartTag(t){let[e,i]=t.parts,r=[];for(;14===this._peek.type;)r.push(this._consumeAttr(this._advance()));let o=this._getElementFullName(e,i,this._getParentElement()),s=!1;if(2===this._peek.type){this._advance(),s=!0;let d=this.getTagDefinition(o);d.canSelfClose||null!==dX(o)||d.isVoid||this.errors.push(ol.create(o,t.sourceSpan,`Only void and foreign elements can be self closed "${t.parts[1]}"`))}else 1===this._peek.type&&(this._advance(),s=!1);let a=this._peek.sourceSpan.fullStart,l=new Go(t.sourceSpan.start,a,t.sourceSpan.fullStart),c=new Go(t.sourceSpan.start,a,t.sourceSpan.fullStart),u=new qC(o,r,[],l,c,void 0);this._pushElement(u),s?this._popElement(o,l):4===t.type&&(this._popElement(o,null),this.errors.push(ol.create(o,l,`Opening tag "${o}" not terminated.`)))}_pushElement(t){let e=this._getParentElement();e&&this.getTagDefinition(e.name).isClosedByChild(t.name)&&this._elementStack.pop(),this._addToParent(t),this._elementStack.push(t)}_consumeEndTag(t){let e=this._getElementFullName(t.parts[0],t.parts[1],this._getParentElement());this.getTagDefinition(e).isVoid?this.errors.push(ol.create(e,t.sourceSpan,`Void elements do not have end tags "${t.parts[1]}"`)):this._popElement(e,t.sourceSpan)||this.errors.push(ol.create(e,t.sourceSpan,`Unexpected closing tag "${e}". It may happen when the tag has already been closed by another tag. For more info see https://www.w3.org/TR/html5/syntax.html#closing-elements-that-have-implied-end-tags`))}_popElement(t,e){let i=!1;for(let r=this._elementStack.length-1;r>=0;r--){let o=this._elementStack[r];if(o.name===t)return o.endSourceSpan=e,o.sourceSpan.end=null!==e?e.end:o.sourceSpan.end,this._elementStack.splice(r,this._elementStack.length-r),!i;this.getTagDefinition(o.name).closedByParent||(i=!0)}return!1}_consumeAttr(t){let e=wB(t.parts[0],t.parts[1]),i=t.sourceSpan.end;15===this._peek.type&&this._advance();let s,a,r="",o=[];if(16===this._peek.type)for(s=this._peek.sourceSpan,a=this._peek.sourceSpan.end;16===this._peek.type||17===this._peek.type||9===this._peek.type;){let u=this._advance();o.push(u),r+=17===u.type?u.parts.join("").replace(/&([^;]+);/g,aQ):9===u.type?u.parts[0]:u.parts.join(""),a=i=u.sourceSpan.end}15===this._peek.type&&(i=this._advance().sourceSpan.end);let c=s&&a&&new Go(s.start,a,s.fullStart);return new hV(e,r,new Go(t.sourceSpan.start,i,t.sourceSpan.fullStart),t.sourceSpan,c,o.length>0?o:void 0,void 0)}_getParentElement(){return this._elementStack.length>0?this._elementStack[this._elementStack.length-1]:null}_addToParent(t){let e=this._getParentElement();null!=e?e.children.push(t):this.rootNodes.push(t)}_getElementFullName(t,e,i){if(""===t&&""===(t=this.getTagDefinition(e).implicitNamespacePrefix||"")&&null!=i){let r=Kd(i.name)[1];this.getTagDefinition(r).preventNamespaceInheritance||(t=dX(i.name))}return wB(t,e)}};function sQ(n,t){return n.length>0&&n[n.length-1]===t}function aQ(n,t){return void 0!==CD[t]?CD[t]||n:/^#x[a-f0-9]+$/i.test(t)?String.fromCodePoint(parseInt(t.slice(2),16)):/^#\d+$/.test(t)?String.fromCodePoint(parseInt(t.slice(1),10)):n}var XT,_V=class extends gV{constructor(){super(FV)}parse(t,e,i){return super.parse(t,e,i)}},gK="ngPreserveWhitespaces",lEe=new Set(["pre","template","textarea","script","style"]),_K=" \f\n\r\t\v\u1680\u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff",cEe=new RegExp(`[^${_K}]`),uEe=new RegExp(`[${_K}]{2,}`,"g");function vK(n){return n.replace(new RegExp("\ue500","g")," ")}function yK(n){return vK(n).replace(uEe," ")}function wD(n,t=!1){return ql(Object.keys(n).map(e=>({key:e,quoted:t,value:n[e]})))}function lQ(){return XT||(XT={},UT(io.HTML,["iframe|srcdoc","*|innerHTML","*|outerHTML"]),UT(io.STYLE,["*|style"]),UT(io.URL,["*|formAction","area|href","area|ping","audio|src","a|href","a|ping","blockquote|cite","body|background","del|cite","form|action","img|src","input|src","ins|cite","q|cite","source|src","track|src","video|poster","video|src"]),UT(io.RESOURCE_URL,["applet|code","applet|codebase","base|href","embed|src","frame|src","head|profile","html|manifest","iframe|src","link|href","media|src","object|codebase","object|data","script|src"])),XT}function UT(n,t){for(let e of t)XT[e.toLowerCase()]=n}var yV=class{},vEe=["[Element]|textContent,%classList,className,id,innerHTML,*beforecopy,*beforecut,*beforepaste,*copy,*cut,*paste,*search,*selectstart,*webkitfullscreenchange,*webkitfullscreenerror,*wheel,outerHTML,#scrollLeft,#scrollTop,slot,*message,*mozfullscreenchange,*mozfullscreenerror,*mozpointerlockchange,*mozpointerlockerror,*webglcontextcreationerror,*webglcontextlost,*webglcontextrestored","[HTMLElement]^[Element]|accessKey,contentEditable,dir,!draggable,!hidden,innerText,lang,*abort,*auxclick,*blur,*cancel,*canplay,*canplaythrough,*change,*click,*close,*contextmenu,*cuechange,*dblclick,*drag,*dragend,*dragenter,*dragleave,*dragover,*dragstart,*drop,*durationchange,*emptied,*ended,*error,*focus,*gotpointercapture,*input,*invalid,*keydown,*keypress,*keyup,*load,*loadeddata,*loadedmetadata,*loadstart,*lostpointercapture,*mousedown,*mouseenter,*mouseleave,*mousemove,*mouseout,*mouseover,*mouseup,*mousewheel,*pause,*play,*playing,*pointercancel,*pointerdown,*pointerenter,*pointerleave,*pointermove,*pointerout,*pointerover,*pointerup,*progress,*ratechange,*reset,*resize,*scroll,*seeked,*seeking,*select,*show,*stalled,*submit,*suspend,*timeupdate,*toggle,*volumechange,*waiting,outerText,!spellcheck,%style,#tabIndex,title,!translate","abbr,address,article,aside,b,bdi,bdo,cite,code,dd,dfn,dt,em,figcaption,figure,footer,header,i,kbd,main,mark,nav,noscript,rb,rp,rt,rtc,ruby,s,samp,section,small,strong,sub,sup,u,var,wbr^[HTMLElement]|accessKey,contentEditable,dir,!draggable,!hidden,innerText,lang,*abort,*auxclick,*blur,*cancel,*canplay,*canplaythrough,*change,*click,*close,*contextmenu,*cuechange,*dblclick,*drag,*dragend,*dragenter,*dragleave,*dragover,*dragstart,*drop,*durationchange,*emptied,*ended,*error,*focus,*gotpointercapture,*input,*invalid,*keydown,*keypress,*keyup,*load,*loadeddata,*loadedmetadata,*loadstart,*lostpointercapture,*mousedown,*mouseenter,*mouseleave,*mousemove,*mouseout,*mouseover,*mouseup,*mousewheel,*pause,*play,*playing,*pointercancel,*pointerdown,*pointerenter,*pointerleave,*pointermove,*pointerout,*pointerover,*pointerup,*progress,*ratechange,*reset,*resize,*scroll,*seeked,*seeking,*select,*show,*stalled,*submit,*suspend,*timeupdate,*toggle,*volumechange,*waiting,outerText,!spellcheck,%style,#tabIndex,title,!translate","media^[HTMLElement]|!autoplay,!controls,%controlsList,%crossOrigin,#currentTime,!defaultMuted,#defaultPlaybackRate,!disableRemotePlayback,!loop,!muted,*encrypted,*waitingforkey,#playbackRate,preload,src,%srcObject,#volume",":svg:^[HTMLElement]|*abort,*auxclick,*blur,*cancel,*canplay,*canplaythrough,*change,*click,*close,*contextmenu,*cuechange,*dblclick,*drag,*dragend,*dragenter,*dragleave,*dragover,*dragstart,*drop,*durationchange,*emptied,*ended,*error,*focus,*gotpointercapture,*input,*invalid,*keydown,*keypress,*keyup,*load,*loadeddata,*loadedmetadata,*loadstart,*lostpointercapture,*mousedown,*mouseenter,*mouseleave,*mousemove,*mouseout,*mouseover,*mouseup,*mousewheel,*pause,*play,*playing,*pointercancel,*pointerdown,*pointerenter,*pointerleave,*pointermove,*pointerout,*pointerover,*pointerup,*progress,*ratechange,*reset,*resize,*scroll,*seeked,*seeking,*select,*show,*stalled,*submit,*suspend,*timeupdate,*toggle,*volumechange,*waiting,%style,#tabIndex",":svg:graphics^:svg:|",":svg:animation^:svg:|*begin,*end,*repeat",":svg:geometry^:svg:|",":svg:componentTransferFunction^:svg:|",":svg:gradient^:svg:|",":svg:textContent^:svg:graphics|",":svg:textPositioning^:svg:textContent|","a^[HTMLElement]|charset,coords,download,hash,host,hostname,href,hreflang,name,password,pathname,ping,port,protocol,referrerPolicy,rel,rev,search,shape,target,text,type,username","area^[HTMLElement]|alt,coords,download,hash,host,hostname,href,!noHref,password,pathname,ping,port,protocol,referrerPolicy,rel,search,shape,target,username","audio^media|","br^[HTMLElement]|clear","base^[HTMLElement]|href,target","body^[HTMLElement]|aLink,background,bgColor,link,*beforeunload,*blur,*error,*focus,*hashchange,*languagechange,*load,*message,*offline,*online,*pagehide,*pageshow,*popstate,*rejectionhandled,*resize,*scroll,*storage,*unhandledrejection,*unload,text,vLink","button^[HTMLElement]|!autofocus,!disabled,formAction,formEnctype,formMethod,!formNoValidate,formTarget,name,type,value","canvas^[HTMLElement]|#height,#width","content^[HTMLElement]|select","dl^[HTMLElement]|!compact","datalist^[HTMLElement]|","details^[HTMLElement]|!open","dialog^[HTMLElement]|!open,returnValue","dir^[HTMLElement]|!compact","div^[HTMLElement]|align","embed^[HTMLElement]|align,height,name,src,type,width","fieldset^[HTMLElement]|!disabled,name","font^[HTMLElement]|color,face,size","form^[HTMLElement]|acceptCharset,action,autocomplete,encoding,enctype,method,name,!noValidate,target","frame^[HTMLElement]|frameBorder,longDesc,marginHeight,marginWidth,name,!noResize,scrolling,src","frameset^[HTMLElement]|cols,*beforeunload,*blur,*error,*focus,*hashchange,*languagechange,*load,*message,*offline,*online,*pagehide,*pageshow,*popstate,*rejectionhandled,*resize,*scroll,*storage,*unhandledrejection,*unload,rows","hr^[HTMLElement]|align,color,!noShade,size,width","head^[HTMLElement]|","h1,h2,h3,h4,h5,h6^[HTMLElement]|align","html^[HTMLElement]|version","iframe^[HTMLElement]|align,!allowFullscreen,frameBorder,height,longDesc,marginHeight,marginWidth,name,referrerPolicy,%sandbox,scrolling,src,srcdoc,width","img^[HTMLElement]|align,alt,border,%crossOrigin,#height,#hspace,!isMap,longDesc,lowsrc,name,referrerPolicy,sizes,src,srcset,useMap,#vspace,#width","input^[HTMLElement]|accept,align,alt,autocapitalize,autocomplete,!autofocus,!checked,!defaultChecked,defaultValue,dirName,!disabled,%files,formAction,formEnctype,formMethod,!formNoValidate,formTarget,#height,!incremental,!indeterminate,max,#maxLength,min,#minLength,!multiple,name,pattern,placeholder,!readOnly,!required,selectionDirection,#selectionEnd,#selectionStart,#size,src,step,type,useMap,value,%valueAsDate,#valueAsNumber,#width","li^[HTMLElement]|type,#value","label^[HTMLElement]|htmlFor","legend^[HTMLElement]|align","link^[HTMLElement]|as,charset,%crossOrigin,!disabled,href,hreflang,integrity,media,referrerPolicy,rel,%relList,rev,%sizes,target,type","map^[HTMLElement]|name","marquee^[HTMLElement]|behavior,bgColor,direction,height,#hspace,#loop,#scrollAmount,#scrollDelay,!trueSpeed,#vspace,width","menu^[HTMLElement]|!compact","meta^[HTMLElement]|content,httpEquiv,name,scheme","meter^[HTMLElement]|#high,#low,#max,#min,#optimum,#value","ins,del^[HTMLElement]|cite,dateTime","ol^[HTMLElement]|!compact,!reversed,#start,type","object^[HTMLElement]|align,archive,border,code,codeBase,codeType,data,!declare,height,#hspace,name,standby,type,useMap,#vspace,width","optgroup^[HTMLElement]|!disabled,label","option^[HTMLElement]|!defaultSelected,!disabled,label,!selected,text,value","output^[HTMLElement]|defaultValue,%htmlFor,name,value","p^[HTMLElement]|align","param^[HTMLElement]|name,type,value,valueType","picture^[HTMLElement]|","pre^[HTMLElement]|#width","progress^[HTMLElement]|#max,#value","q,blockquote,cite^[HTMLElement]|","script^[HTMLElement]|!async,charset,%crossOrigin,!defer,event,htmlFor,integrity,src,text,type","select^[HTMLElement]|autocomplete,!autofocus,!disabled,#length,!multiple,name,!required,#selectedIndex,#size,value","shadow^[HTMLElement]|","slot^[HTMLElement]|name","source^[HTMLElement]|media,sizes,src,srcset,type","span^[HTMLElement]|","style^[HTMLElement]|!disabled,media,type","caption^[HTMLElement]|align","th,td^[HTMLElement]|abbr,align,axis,bgColor,ch,chOff,#colSpan,headers,height,!noWrap,#rowSpan,scope,vAlign,width","col,colgroup^[HTMLElement]|align,ch,chOff,#span,vAlign,width","table^[HTMLElement]|align,bgColor,border,%caption,cellPadding,cellSpacing,frame,rules,summary,%tFoot,%tHead,width","tr^[HTMLElement]|align,bgColor,ch,chOff,vAlign","tfoot,thead,tbody^[HTMLElement]|align,ch,chOff,vAlign","template^[HTMLElement]|","textarea^[HTMLElement]|autocapitalize,autocomplete,!autofocus,#cols,defaultValue,dirName,!disabled,#maxLength,#minLength,name,placeholder,!readOnly,!required,#rows,selectionDirection,#selectionEnd,#selectionStart,value,wrap","title^[HTMLElement]|text","track^[HTMLElement]|!default,kind,label,src,srclang","ul^[HTMLElement]|!compact,type","unknown^[HTMLElement]|","video^media|#height,poster,#width",":svg:a^:svg:graphics|",":svg:animate^:svg:animation|",":svg:animateMotion^:svg:animation|",":svg:animateTransform^:svg:animation|",":svg:circle^:svg:geometry|",":svg:clipPath^:svg:graphics|",":svg:defs^:svg:graphics|",":svg:desc^:svg:|",":svg:discard^:svg:|",":svg:ellipse^:svg:geometry|",":svg:feBlend^:svg:|",":svg:feColorMatrix^:svg:|",":svg:feComponentTransfer^:svg:|",":svg:feComposite^:svg:|",":svg:feConvolveMatrix^:svg:|",":svg:feDiffuseLighting^:svg:|",":svg:feDisplacementMap^:svg:|",":svg:feDistantLight^:svg:|",":svg:feDropShadow^:svg:|",":svg:feFlood^:svg:|",":svg:feFuncA^:svg:componentTransferFunction|",":svg:feFuncB^:svg:componentTransferFunction|",":svg:feFuncG^:svg:componentTransferFunction|",":svg:feFuncR^:svg:componentTransferFunction|",":svg:feGaussianBlur^:svg:|",":svg:feImage^:svg:|",":svg:feMerge^:svg:|",":svg:feMergeNode^:svg:|",":svg:feMorphology^:svg:|",":svg:feOffset^:svg:|",":svg:fePointLight^:svg:|",":svg:feSpecularLighting^:svg:|",":svg:feSpotLight^:svg:|",":svg:feTile^:svg:|",":svg:feTurbulence^:svg:|",":svg:filter^:svg:|",":svg:foreignObject^:svg:graphics|",":svg:g^:svg:graphics|",":svg:image^:svg:graphics|",":svg:line^:svg:geometry|",":svg:linearGradient^:svg:gradient|",":svg:mpath^:svg:|",":svg:marker^:svg:|",":svg:mask^:svg:|",":svg:metadata^:svg:|",":svg:path^:svg:geometry|",":svg:pattern^:svg:|",":svg:polygon^:svg:geometry|",":svg:polyline^:svg:geometry|",":svg:radialGradient^:svg:gradient|",":svg:rect^:svg:geometry|",":svg:svg^:svg:graphics|#currentScale,#zoomAndPan",":svg:script^:svg:|type",":svg:set^:svg:animation|",":svg:stop^:svg:|",":svg:style^:svg:|!disabled,media,title,type",":svg:switch^:svg:graphics|",":svg:symbol^:svg:|",":svg:tspan^:svg:textPositioning|",":svg:text^:svg:textPositioning|",":svg:textPath^:svg:textContent|",":svg:title^:svg:|",":svg:use^:svg:graphics|",":svg:view^:svg:|#zoomAndPan","data^[HTMLElement]|value","keygen^[HTMLElement]|!autofocus,challenge,!disabled,form,keytype,name","menuitem^[HTMLElement]|type,label,icon,!disabled,!checked,radiogroup,!default","summary^[HTMLElement]|","time^[HTMLElement]|dateTime",":svg:cursor^:svg:|"],bK=new Map(Object.entries({class:"className",for:"htmlFor",formaction:"formAction",innerHtml:"innerHTML",readonly:"readOnly",tabindex:"tabIndex"})),yEe=Array.from(bK).reduce((n,[t,e])=>(n.set(t,e),n),new Map),SD=class extends yV{constructor(){super(),this._schema=new Map,this._eventSchema=new Map,vEe.forEach(t=>{let e=new Map,i=new Set,[r,o]=t.split("|"),s=o.split(","),[a,l]=r.split("^");a.split(",").forEach(u=>{this._schema.set(u.toLowerCase(),e),this._eventSchema.set(u.toLowerCase(),i)});let c=l&&this._schema.get(l.toLowerCase());if(c){for(let[u,d]of c)e.set(u,d);for(let u of this._eventSchema.get(l.toLowerCase()))i.add(u)}s.forEach(u=>{if(u.length>0)switch(u[0]){case"*":i.add(u.substring(1));break;case"!":e.set(u.substring(1),"boolean");break;case"#":e.set(u.substring(1),"number");break;case"%":e.set(u.substring(1),"object");break;default:e.set(u,"string")}})})}hasProperty(t,e,i){if(i.some(o=>"no-errors-schema"===o.name))return!0;if(t.indexOf("-")>-1){if(CB(t)||MB(t))return!1;if(i.some(o=>"custom-elements"===o.name))return!0}return(this._schema.get(t.toLowerCase())||this._schema.get("unknown")).has(e)}hasElement(t,e){return!!(e.some(i=>"no-errors-schema"===i.name)||t.indexOf("-")>-1&&(CB(t)||MB(t)||e.some(i=>"custom-elements"===i.name)))||this._schema.has(t.toLowerCase())}securityContext(t,e,i){i&&(e=this.getMappedPropName(e)),t=t.toLowerCase(),e=e.toLowerCase();let r=lQ()[t+"|"+e];return r||(r=lQ()["*|"+e],r||io.NONE)}getMappedPropName(t){return bK.get(t)??t}getDefaultComponentElementName(){return"ng-component"}validateProperty(t){return t.toLowerCase().startsWith("on")?{error:!0,msg:`Binding to event property '${t}' is disallowed for security reasons, please use (${t.slice(2)})=...\nIf '${t}' is a directive input, make sure the directive is imported by the current module.`}:{error:!1}}validateAttribute(t){return t.toLowerCase().startsWith("on")?{error:!0,msg:`Binding to event attribute '${t}' is disallowed for security reasons, please use (${t.slice(2)})=...`}:{error:!1}}allKnownElementNames(){return Array.from(this._schema.keys())}allKnownAttributesOfElement(t){let e=this._schema.get(t.toLowerCase())||this._schema.get("unknown");return Array.from(e.keys()).map(i=>yEe.get(i)??i)}allKnownEventsOfElement(t){return Array.from(this._eventSchema.get(t.toLowerCase())??[])}normalizeAnimationStyleProperty(t){return t.replace(yMe,(...t)=>t[1].toUpperCase())}normalizeAnimationStyleValue(t,e,i){let r="",o=i.toString().trim(),s=null;if(function(n){switch(n){case"width":case"height":case"minWidth":case"minHeight":case"maxWidth":case"maxHeight":case"left":case"top":case"bottom":case"right":case"fontSize":case"outlineWidth":case"outlineOffset":case"paddingTop":case"paddingLeft":case"paddingBottom":case"paddingRight":case"marginTop":case"marginLeft":case"marginBottom":case"marginRight":case"borderRadius":case"borderWidth":case"borderTopWidth":case"borderLeftWidth":case"borderRightWidth":case"borderBottomWidth":case"textIndent":return!0;default:return!1}}(t)&&0!==i&&"0"!==i)if("number"==typeof i)r="px";else{let a=i.match(/^[+-]?[\d\.]+([a-z]*)$/);a&&0==a[1].length&&(s=`Please provide a CSS unit value for ${e}:${i}`)}return{error:s,value:o+r}}},cQ=new Set(["iframe|srcdoc","*|innerhtml","*|outerhtml","embed|src","object|codebase","object|data"]);function xK(n,t){return n=n.toLowerCase(),t=t.toLowerCase(),cQ.has(n+"|"+t)||cQ.has("*|"+t)}var pB="animate-";function hB(n){return"@"==n[0]}function fB(n,t,e,i){let r=[];return Zd.parse(t).forEach(o=>{let s=o.element?[o.element]:n.allKnownElementNames(),a=new Set(o.notSelectors.filter(c=>c.isElementSelector()).map(c=>c.element)),l=s.filter(c=>!a.has(c));r.push(...l.map(c=>n.securityContext(c,e,i)))}),0===r.length?[io.NONE]:Array.from(new Set(r)).sort()}function Kp(n,t){let e=t.start-n.start.offset,i=t.end-n.end.offset;return new Go(n.start.moveBy(e),n.end.moveBy(i),n.fullStart.moveBy(e),n.details)}var EEe=/^([^:/?#]+):/;function CK(n){let t=null,e=null,i=null,r=!1,o="";n.attrs.forEach(l=>{let c=l.name.toLowerCase();"select"==c?t=l.value:"href"==c?e=l.value:"rel"==c?i=l.value:"ngNonBindable"==l.name?r=!0:"ngProjectAs"==l.name&&l.value.length>0&&(o=l.value)}),t=function(n){return null===n||0===n.length?"*":n}(t);let s=n.name.toLowerCase(),a=na.OTHER;return MB(s)?a=na.NG_CONTENT:"style"==s?a=na.STYLE:"script"==s?a=na.SCRIPT:"link"==s&&"stylesheet"==i&&(a=na.STYLESHEET),new xV(a,t,e,r,o)}var na=(()=>{return(n=na||(na={}))[n.NG_CONTENT=0]="NG_CONTENT",n[n.STYLE=1]="STYLE",n[n.STYLESHEET=2]="STYLESHEET",n[n.SCRIPT=3]="SCRIPT",n[n.OTHER=4]="OTHER",na;var n})(),xV=class{constructor(t,e,i,r,o){this.type=t,this.selectAttr=e,this.hrefAttr=i,this.nonBindable=r,this.projectAs=o}},LEe=/^(?:(bind-)|(let-)|(ref-|#)|(on-)|(bindon-)|(@))(.*)$/,Zp_BANANA_BOX={start:"[(",end:")]"},Zp_PROPERTY={start:"[",end:"]"},Zp_EVENT={start:"(",end:")"},HEe=new class{visitElement(t){let e=CK(t);if(e.type===na.SCRIPT||e.type===na.STYLE||e.type===na.STYLESHEET)return null;let i=Uu(this,t.children,null);return new E_(t.name,Uu(this,t.attrs),[],[],i,[],t.sourceSpan,t.startSourceSpan,t.endSourceSpan)}visitComment(t){return null}visitAttribute(t){return new DC(t.name,t.value,t.sourceSpan,t.keySpan,t.valueSpan,t.i18n)}visitText(t){return new M_(t.value,t.sourceSpan)}visitExpansion(t){return null}visitExpansionCase(t){return null}};function _Q(n){return/^data-/i.test(n)?n.substring(5):n}function mB(n,t){t.push(...n.map(e=>S_.fromParsedEvent(e)))}var Lc=(()=>{return(n=Lc||(Lc={}))[n.ELEMENT=0]="ELEMENT",n[n.TEMPLATE=1]="TEMPLATE",Lc;var n})(),QC=class{constructor(t,e,i=0,r=null,o,s){this.index=t,this.ref=e,this.level=i,this.templateIndex=r,this.meta=o,this.registry=s,this.bindings=new Set,this.placeholders=new Map,this.isEmitted=!1,this._unresolvedCtxCount=0,this._registry=s||{getUniqueId:Swe(),icus:new Map},this.id=this._registry.getUniqueId()}appendTag(t,e,i,r){e.isVoid&&r||qT(this.placeholders,e.isVoid||!r?e.startName:e.closeName,{type:t,index:i,ctx:this.id,isVoid:e.isVoid,closed:r})}get icus(){return this._registry.icus}get isRoot(){return 0===this.level}get isResolved(){return 0===this._unresolvedCtxCount}getSerializedPlaceholders(){let t=new Map;return this.placeholders.forEach((e,i)=>t.set(i,e.map(WEe))),t}appendBinding(t){this.bindings.add(t)}appendIcu(t,e){qT(this._registry.icus,t,e)}appendBoundText(t){qQ(t,this.bindings.size,this.id).forEach((i,r)=>qT(this.placeholders,r,...i))}appendTemplate(t,e){this.appendTag(Lc.TEMPLATE,t,e,!1),this.appendTag(Lc.TEMPLATE,t,e,!0),this._unresolvedCtxCount++}appendElement(t,e,i){this.appendTag(Lc.ELEMENT,t,e,i)}appendProjection(t,e){this.appendTag(Lc.ELEMENT,t,e,!1),this.appendTag(Lc.ELEMENT,t,e,!0)}forkChildContext(t,e,i){return new QC(t,this.ref,this.level+1,e,i,this._registry)}reconcileChildContext(t){["start","close"].forEach(i=>{let s=(this.placeholders.get(t.meta[`${i}Name`])||[]).find(vQ(this.id,t.templateIndex));s&&(s.ctx=t.id)}),t.placeholders.forEach((i,r)=>{let o=this.placeholders.get(r);if(!o)return void this.placeholders.set(r,i);let s=o.findIndex(vQ(t.id,t.templateIndex));if(s>=0){let a=r.startsWith("CLOSE");r.endsWith("NG-TEMPLATE")?o.splice(s+(a?0:1),0,...i):(i[a?i.length-1:0].tmpl=o[s],o.splice(s,1,...i))}else o.push(...i);this.placeholders.set(r,o)}),this._unresolvedCtxCount--}};function gB(n,t,e,i){return PD(`${i?"/":""}${n}${t}`,e)}function _B(n,{index:t,ctx:e,isVoid:i},r){return i?gB(n,t,e)+gB(n,t,e,!0):gB(n,t,e,r)}function vQ(n,t){return e=>"object"==typeof e&&e.type===Lc.TEMPLATE&&e.index===t&&e.ctx===n}function WEe(n){let t=(r,o)=>_B("#",r,o),e=(r,o)=>_B("*",r,o);switch(n.type){case Lc.ELEMENT:return n.closed?t(n,!0)+(n.tmpl?e(n.tmpl,!0):""):n.tmpl?e(n.tmpl)+t(n)+(n.isVoid?e(n.tmpl,!0):""):t(n);case Lc.TEMPLATE:return e(n,n.closed);default:return n}}var qEe=new class{visitText(t){return t.value}visitContainer(t){return t.children.map(e=>e.visit(this)).join("")}visitIcu(t){let e=Object.keys(t.cases).map(r=>`${r} {${t.cases[r].visit(this)}}`);return`{${t.expressionPlaceholder}, ${t.type}, ${e.join(" ")}}`}visitTagPlaceholder(t){return t.isVoid?this.formatPh(t.startName):`${this.formatPh(t.startName)}${t.children.map(e=>e.visit(this)).join("")}${this.formatPh(t.closeName)}`}visitPlaceholder(t){return this.formatPh(t.name)}visitIcuPlaceholder(t,e){return this.formatPh(t.name)}formatPh(t){return`{${JC(t,!1)}}`}};function MK(n){return n.visit(qEe)}var yQ={A:"LINK",B:"BOLD_TEXT",BR:"LINE_BREAK",EM:"EMPHASISED_TEXT",H1:"HEADING_LEVEL1",H2:"HEADING_LEVEL2",H3:"HEADING_LEVEL3",H4:"HEADING_LEVEL4",H5:"HEADING_LEVEL5",H6:"HEADING_LEVEL6",HR:"HORIZONTAL_RULE",I:"ITALIC_TEXT",LI:"LIST_ITEM",LINK:"MEDIA_LINK",OL:"ORDERED_LIST",P:"PARAGRAPH",Q:"QUOTATION",S:"STRIKETHROUGH_TEXT",SMALL:"SMALL_TEXT",SUB:"SUBSTRIPT",SUP:"SUPERSCRIPT",TBODY:"TABLE_BODY",TD:"TABLE_CELL",TFOOT:"TABLE_FOOTER",TH:"TABLE_HEADER_CELL",THEAD:"TABLE_HEADER",TR:"TABLE_ROW",TT:"MONOSPACED_TEXT",U:"UNDERLINED_TEXT",UL:"UNORDERED_LIST"},SV=class{constructor(){this._placeHolderNameCounts={},this._signatureToName={}}getStartTagPlaceholderName(t,e,i){let r=this._hashTag(t,e,i);if(this._signatureToName[r])return this._signatureToName[r];let o=t.toUpperCase(),s=yQ[o]||`TAG_${o}`,a=this._generateUniqueName(i?s:`START_${s}`);return this._signatureToName[r]=a,a}getCloseTagPlaceholderName(t){let e=this._hashClosingTag(t);if(this._signatureToName[e])return this._signatureToName[e];let i=t.toUpperCase(),o=this._generateUniqueName(`CLOSE_${yQ[i]||`TAG_${i}`}`);return this._signatureToName[e]=o,o}getPlaceholderName(t,e){let i=t.toUpperCase(),r=`PH: ${i}=${e}`;if(this._signatureToName[r])return this._signatureToName[r];let o=this._generateUniqueName(i);return this._signatureToName[r]=o,o}getUniquePlaceholder(t){return this._generateUniqueName(t.toUpperCase())}_hashTag(t,e,i){return`<${t}`+Object.keys(e).sort().map(a=>` ${a}=${e[a]}`).join("")+(i?"/>":`></${t}>`)}_hashClosingTag(t){return this._hashTag(`/${t}`,{},!1)}_generateUniqueName(t){if(!this._placeHolderNameCounts.hasOwnProperty(t))return this._placeHolderNameCounts[t]=1,t;let i=this._placeHolderNameCounts[t];return this._placeHolderNameCounts[t]=i+1,`${t}_${i}`}},YEe=new bD(new yD);function QEe(n,t){return t}var $Ee=/\/\/[\s\S]*i18n[\s\S]*\([\s\S]*ph[\s\S]*=[\s\S]*("|')([\s\S]*?)\1[\s\S]*\)/g,TV=class extends ym{constructor(t,e){super(t,e)}},t1e=(n,t)=>(n instanceof Cm&&(t instanceof T_&&n.i18n instanceof Fu&&(t.previousMessage=n.i18n),n.i18n=t),t),ED=class{constructor(t=Pu,e=!1,i=!1){this.interpolationConfig=t,this.keepI18nAttrs=e,this.enableI18nLegacyMessageIdFormat=i,this.hasI18nMeta=!1,this._errors=[],this._createI18nMessage=function(n){let t=new class{constructor(t,e){this._expressionParser=t,this._interpolationConfig=e}toI18nMessage(t,e="",i="",r="",o){let s={isIcu:1==t.length&&t[0]instanceof N_,icuDepth:0,placeholderRegistry:new SV,placeholderToContent:{},placeholderToMessage:{},visitNodeFn:o||QEe},a=Uu(this,t,s);return new Fu(a,s.placeholderToContent,s.placeholderToMessage,e,i,r)}visitElement(t,e){let i=Uu(this,t.children,e),r={};t.attrs.forEach(c=>{r[c.name]=c.value});let o=FV(t.name).isVoid,s=e.placeholderRegistry.getStartTagPlaceholderName(t.name,r,o);e.placeholderToContent[s]={text:t.startSourceSpan.toString(),sourceSpan:t.startSourceSpan};let a="";o||(a=e.placeholderRegistry.getCloseTagPlaceholderName(t.name),e.placeholderToContent[a]={text:`</${t.name}>`,sourceSpan:t.endSourceSpan??t.sourceSpan});let l=new class{constructor(t,e,i,r,o,s,a,l,c){this.tag=t,this.attrs=e,this.startName=i,this.closeName=r,this.children=o,this.isVoid=s,this.sourceSpan=a,this.startSourceSpan=l,this.endSourceSpan=c}visit(t,e){return t.visitTagPlaceholder(this,e)}}(t.name,r,s,a,i,o,t.sourceSpan,t.startSourceSpan,t.endSourceSpan);return e.visitNodeFn(t,l)}visitAttribute(t,e){let i=void 0===t.valueTokens||1===t.valueTokens.length?new l_(t.value,t.valueSpan||t.sourceSpan):this._visitTextWithInterpolation(t.valueTokens,t.valueSpan||t.sourceSpan,e,t.i18n);return e.visitNodeFn(t,i)}visitText(t,e){let i=1===t.tokens.length?new l_(t.value,t.sourceSpan):this._visitTextWithInterpolation(t.tokens,t.sourceSpan,e,t.i18n);return e.visitNodeFn(t,i)}visitComment(t,e){return null}visitExpansion(t,e){e.icuDepth++;let i={},r=new aD(t.switchValue,t.type,i,t.sourceSpan);if(t.cases.forEach(a=>{i[a.value]=new mm(a.expression.map(l=>l.visit(this,e)),a.expSourceSpan)}),e.icuDepth--,e.isIcu||e.icuDepth>0){let a=e.placeholderRegistry.getUniquePlaceholder(`VAR_${t.type}`);return r.expressionPlaceholder=a,e.placeholderToContent[a]={text:t.switchValue,sourceSpan:t.switchValueSourceSpan},e.visitNodeFn(t,r)}let o=e.placeholderRegistry.getPlaceholderName("ICU",t.sourceSpan.toString());e.placeholderToMessage[o]=this.toI18nMessage([t],"","","",void 0);let s=new T_(r,o,t.sourceSpan);return e.visitNodeFn(t,s)}visitExpansionCase(t,e){throw new Error("Unreachable code")}_visitTextWithInterpolation(t,e,i,r){let o=[],s=!1;for(let a of t)switch(a.type){case 8:case 17:s=!0;let l=a.parts[1],c=l.split($Ee)[2]||"INTERPOLATION",u=i.placeholderRegistry.getPlaceholderName(c,l);i.placeholderToContent[u]={text:a.parts.join(""),sourceSpan:a.sourceSpan},o.push(new lD(l,u,a.sourceSpan));break;default:if(a.parts[0].length>0){let d=o[o.length-1];d instanceof l_?(d.value+=a.parts[0],d.sourceSpan=new Go(d.sourceSpan.start,a.sourceSpan.end,d.sourceSpan.fullStart,d.sourceSpan.details)):o.push(new l_(a.parts[0],a.sourceSpan))}}return s?(function(n,t){if(t instanceof Fu&&(function(n){let t=n.nodes;if(1!==t.length||!(t[0]instanceof mm))throw new Error("Unexpected previous i18n message - expected it to consist of only a single `Container` node.")}(t),t=t.nodes[0]),t instanceof mm){!function(n,t){if(n.length!==t.length)throw new Error("The number of i18n message children changed between first and second pass.");if(n.some((e,i)=>t[i].constructor!==e.constructor))throw new Error("The types of the i18n message children changed between first and second pass.")}(t.children,n);for(let e=0;e<n.length;e++)n[e].sourceSpan=t.children[e].sourceSpan}}(o,r),new mm(o,e)):o[0]}}(YEe,n);return(e,i,r,o,s)=>t.toI18nMessage(e,i,r,o,s)}(this.interpolationConfig)}_generateI18nMessage(t,e="",i){let{meaning:r,description:o,customId:s}=this._parseMetadata(e),a=this._createI18nMessage(t,r,o,s,i);return this._setMessageId(a,e),this._setLegacyIds(a,e),a}visitAllWithErrors(t){let e=t.map(i=>i.visit(this,null));return new MD(e,this._errors)}visitElement(t){let e;if(function(n){return n.attrs.some(t=>function(n){return"i18n"===n||n.startsWith(jB)}(t.name))}(t)){this.hasI18nMeta=!0;let i=[],r={};for(let o of t.attrs)if("i18n"===o.name)e=this._generateI18nMessage(t.children,t.i18n||o.value,t1e),0===e.nodes.length&&(e=void 0),t.i18n=e;else if(o.name.startsWith(jB)){let s=o.name.slice(jB.length);xK(t.name,s)?this._reportError(o,`Translating attribute '${s}' is disallowed for security reasons.`):r[s]=o.value}else i.push(o);if(Object.keys(r).length)for(let o of i){let s=r[o.name];void 0!==s&&o.value&&(o.i18n=this._generateI18nMessage([o],o.i18n||s))}this.keepI18nAttrs||(t.attrs=i)}return Uu(this,t.children,e),t}visitExpansion(t,e){let i,r=t.i18n;if(this.hasI18nMeta=!0,r instanceof T_){let o=r.name;i=this._generateI18nMessage([t],r),WQ(i).name=o,null!==e&&(e.placeholderToMessage[o]=i)}else i=this._generateI18nMessage([t],e||r);return t.i18n=i,t}visitText(t){return t}visitAttribute(t){return t}visitComment(t){return t}visitExpansionCase(t){return t}_parseMetadata(t){return"string"==typeof t?function(n=""){let t,e,i;if(n=n.trim()){let s,r=n.indexOf("@@"),o=n.indexOf("|");[s,t]=r>-1?[n.slice(0,r),n.slice(r+2)]:[n,""],[e,i]=o>-1?[s.slice(0,o),s.slice(o+1)]:["",s]}return{customId:t,meaning:e,description:i}}(t):t instanceof Fu?t:{}}_setMessageId(t,e){var n;t.id||(t.id=e instanceof Fu&&e.id||(n=t).id||FQ(n))}_setLegacyIds(t,e){if(this.enableI18nLegacyMessageIdFormat)t.legacyIds=[SMe(t),FQ(t)];else if("string"!=typeof e){let i=e instanceof Fu?e:e instanceof T_?e.previousMessage:void 0;t.legacyIds=i?i.legacyIds:[]}}_reportError(t,e){this._errors.push(new TV(t.sourceSpan,e))}};function a1e(n,t,e,i){let r=function(n){return n.nodes.map(t=>t.visit(l1e,null)).join("")}(t),o=[ht(r)];Object.keys(i).length&&(o.push(wD(UV(i,!0),!0)),o.push(wD({original_code:ql(Object.keys(i).map(l=>({key:JC(l),quoted:!0,value:ht(t.placeholders[l]?t.placeholders[l].sourceSpan.toString():t.placeholderToMessage[l].nodes.map(c=>c.sourceSpan.toString()).join(""))})))})));let s=e.set(Ri("goog.getMsg").callFn(o)).toConstDecl();return s.addLeadingComment(function(n){let t=[];return t.push(n.description?{tagName:"desc",text:n.description}:{tagName:"suppress",text:"{msgDescriptions}"}),n.meaning&&t.push({tagName:"meaning",text:n.meaning}),function(n=[]){return new nD(n)}(t)}(t)),[s,new Hu(n.set(e))]}var l1e=new class{formatPh(t){return`{$${JC(t)}}`}visitText(t){return t.value}visitContainer(t){return t.children.map(e=>e.visit(this)).join("")}visitIcu(t){return MK(t)}visitTagPlaceholder(t){return t.isVoid?this.formatPh(t.startName):`${this.formatPh(t.startName)}${t.children.map(e=>e.visit(this)).join("")}${this.formatPh(t.closeName)}`}visitPlaceholder(t){return this.formatPh(t.name)}visitIcuPlaceholder(t,e){return this.formatPh(t.name)}};function u1e(n,t,e){let{messageParts:i,placeHolders:r}=function(n){let t=[],e=new class{constructor(t,e){this.placeholderToMessage=t,this.pieces=e}visitText(t){if(this.pieces[this.pieces.length-1]instanceof lm)this.pieces[this.pieces.length-1].text+=t.value;else{let e=new Go(t.sourceSpan.fullStart,t.sourceSpan.end,t.sourceSpan.fullStart,t.sourceSpan.details);this.pieces.push(new lm(t.value,e))}}visitContainer(t){t.children.forEach(e=>e.visit(this))}visitIcu(t){this.pieces.push(new lm(MK(t),t.sourceSpan))}visitTagPlaceholder(t){this.pieces.push(this.createPlaceholderPiece(t.startName,t.startSourceSpan??t.sourceSpan)),t.isVoid||(t.children.forEach(e=>e.visit(this)),this.pieces.push(this.createPlaceholderPiece(t.closeName,t.endSourceSpan??t.sourceSpan)))}visitPlaceholder(t){this.pieces.push(this.createPlaceholderPiece(t.name,t.sourceSpan))}visitIcuPlaceholder(t){this.pieces.push(this.createPlaceholderPiece(t.name,t.sourceSpan,this.placeholderToMessage[t.name]))}createPlaceholderPiece(t,e,i){return new h_(JC(t,!1),e,i)}}(n.placeholderToMessage,t);return n.nodes.forEach(i=>i.visit(e)),function(n){let t=[],e=[];n[0]instanceof h_&&t.push(vB(n[0].sourceSpan.start));for(let i=0;i<n.length;i++){let r=n[i];r instanceof lm?t.push(r):(e.push(r),n[i-1]instanceof h_&&t.push(vB(n[i-1].sourceSpan.end)))}return n[n.length-1]instanceof h_&&t.push(vB(n[n.length-1].sourceSpan.end)),{messageParts:t,placeHolders:e}}(t)}(t),o=function(n){let t=n.nodes[0];return new Go(t.sourceSpan.fullStart,n.nodes[n.nodes.length-1].sourceSpan.end,t.sourceSpan.fullStart,t.sourceSpan.details)}(t),s=r.map(c=>e[c.text]),a=function(n,t,e,i,r){return new AB(n,t,e,i,r)}(t,i,r,s,o),l=n.set(a);return[new Hu(l)]}function vB(n){return new lm("",new Go(n,n))}var wK=new Set(["$event"]),yB=new Map([["window",te.resolveWindow],["document",te.resolveDocument],["body",te.resolveBody]]),g1e=[" ","\n","\r","\t"];function lh(n,t){return VV(Ri($C).bitwiseAnd(ht(n),null,!1),t)}function SK(n,t=null,e=null){let{type:i,name:r,target:o,phase:s,handler:a}=n;if(o&&!yB.has(o))throw new Error(`Unexpected global target '${o}' defined for '${r}' event.\n        Supported list of global targets: ${Array.from(yB.keys())}.`);let l="$event",c=new Set,u=null===e||0===e.bindingLevel?Ri(Hc):e.getOrCreateSharedContextVar(0),d=cSe(e,u,a,"b",n.handlerSpan,c,wK),p=[],h=e?.variableDeclarations(),f=e?.restoreViewStatement();if(h&&p.push(...h),p.push(...d),f){p.unshift(f);let T=p[p.length-1];T instanceof Do?p[p.length-1]=new Do(gm(T.value.sourceSpan,te.resetView,[T.value])):p.push(new Hu(gm(null,te.resetView,[])))}let m=1===i?function(n,t){return`@${n}.${t}`}(r,s):r,x=t&&m_(t),g=[];c.has(l)&&g.push(new ia(l,V_));let b=ra(g,p,Pa,null,x),D=[ht(m),b];return o&&D.push(ht(!1),Tn(yB.get(o))),D}var KC=class{constructor(t,e,i=0,r,o,s,a,l,c,u,d=function(){return{prepareStatements:[],constExpressions:[],i18nVarRefsCache:new Map}}()){this.constantPool=t,this.level=i,this.contextName=r,this.i18nContext=o,this.templateIndex=s,this.templateName=a,this._namespace=l,this.i18nUseExternalIds=u,this._constants=d,this._dataIndex=0,this._bindingContext=0,this._prefixCode=[],this._creationCodeFns=[],this._updateCodeFns=[],this._currentIndex=0,this._tempVariables=[],this._nestedTemplateFns=[],this.i18n=null,this._pureFunctionSlots=0,this._bindingSlots=0,this._ngContentReservedSlots=[],this._ngContentSelectorsOffset=0,this._implicitReceiverExpr=null,this.visitReference=iC,this.visitVariable=iC,this.visitTextAttribute=iC,this.visitBoundAttribute=iC,this.visitBoundEvent=iC,this._bindingScope=e.nestedScope(i),this.fileBasedI18nSuffix=c.replace(/[^A-Za-z0-9]/g,"_")+"_",this._valueConverter=new TD(t,()=>this.allocateDataSlot(),p=>this.allocatePureFunctionSlots(p),(p,h,f,m)=>{this._bindingScope.set(this.level,h,m),this.creationInstruction(null,te.pipe,[ht(f),ht(p)])})}buildTemplateFunction(t,e,i=0,r){this._ngContentSelectorsOffset=i,this._namespace!==te.namespaceHTML&&this.creationInstruction(null,this._namespace),e.forEach(h=>this.registerContextVariables(h));let o=this.i18nContext||AC(r)&&!VT(r)&&!(1===(n=t).length&&n[0]instanceof E_&&t[0].i18n===r),s=bB(t);var n;if(o&&this.i18nStart(null,r,s),AX(this,t),this._pureFunctionSlots+=this._bindingSlots,this._valueConverter.updatePipeSlotOffsets(this._bindingSlots),this._nestedTemplateFns.forEach(h=>h()),0===this.level&&this._ngContentReservedSlots.length){let h=[];if(this._ngContentReservedSlots.length>1||"*"!==this._ngContentReservedSlots[0]){let f=this._ngContentReservedSlots.map(m=>"*"!==m?NV(m):m);h.push(this.constantPool.getConstLiteral(Nu(f),!0))}this.creationInstruction(null,te.projectionDef,h,!0)}o&&this.i18nEnd(null,s);let a=cD(this._creationCodeFns),l=cD(this._updateCodeFns),c=this._bindingScope.viewSnapshotStatements(),u=this._bindingScope.variableDeclarations().concat(this._tempVariables),d=a.length>0?[lh(1,c.concat(a))]:[],p=l.length>0?[lh(2,u.concat(l))]:[];return ra([new ia($C,ZC),new ia(Hc,null)],[...this._prefixCode,...d,...p],Pa,null,this.templateName)}getLocal(t){return this._bindingScope.get(t)}notifyImplicitReceiverUse(){this._bindingScope.notifyImplicitReceiverUse()}maybeRestoreView(){this._bindingScope.maybeRestoreView()}i18nTranslate(t,e={},i,r){let o=i||this.i18nGenerateMainBlockVar(),a=function(n,t,e,i={},r){let o=[Ewe(t),VV(BV(Ri(MQ)).notIdentical(ht("undefined",LQ)).and(Ri(MQ)),a1e(t,n,e,i),u1e(t,n,UV(i,!1)))];return r&&o.push(new Hu(t.set(r(t)))),o}(t,o,this.i18nGenerateClosureVar(t.id),e,r);return this._constants.prepareStatements.push(...a),o}registerContextVariables(t){let e=this._bindingScope.freshReferenceName(),i=this.level,r=Ri(t.name+e);this._bindingScope.set(i,t.name,r,1,(o,s)=>{let a;return o.bindingLevel===i?o.isListenerScope()&&o.hasRestoreViewVariable()?(a=Ri(YQ),o.notifyRestoredViewContextUse()):a=Ri(Hc):a=o.getSharedContextName(i)||IV(s),[r.set(a.prop(t.value||"$implicit")).toConstDecl()]})}i18nAppendBindings(t){t.length>0&&t.forEach(e=>this.i18n.appendBinding(e))}i18nBindProps(t){let e={};return Object.keys(t).forEach(i=>{let r=t[i];if(r instanceof M_)e[i]=ht(r.value);else{let o=r.value.visit(this._valueConverter);if(this.allocateBindingSlots(o),o instanceof vs){let{strings:s,expressions:a}=o,{id:l,bindings:c}=this.i18n,u=function(n,t=0,e=0){if(!n.length)return"";let i="",r=n.length-1;for(let o=0;o<r;o++)i+=`${n[o]}${PD(t+o,e)}`;return i+=n[r],i}(s,c.size,l);this.i18nAppendBindings(a),e[i]=ht(u)}}}),e}i18nGenerateMainBlockVar(){return Ri(this.constantPool.uniqueName("i18n_"))}i18nGenerateClosureVar(t){let e,i=this.fileBasedI18nSuffix.toUpperCase();if(this.i18nUseExternalIds){let r=RX("EXTERNAL_"),o=this.constantPool.uniqueName(i);e=`${r}${m_(t)}$$${o}`}else{let r=RX(i);e=this.constantPool.uniqueName(r)}return Ri(e)}i18nUpdateRef(t){let{icus:e,meta:i,isRoot:r,isResolved:o,isEmitted:s}=t;if(r&&o&&!s&&!VT(i)){t.isEmitted=!0;let d,a=t.getSerializedPlaceholders(),l={},c=a.size?PX(a):{};e.size&&e.forEach((p,h)=>{if(1===p.length)c[h]=p[0];else{let f=PD(`I18N_EXP_${h}`);c[h]=ht(f),l[h]=_r(p)}}),(Array.from(a.values()).some(p=>p.length>1)||Object.keys(l).length)&&(d=p=>{let h=[p];return Object.keys(l).length&&h.push(wD(l,!0)),gm(null,te.i18nPostprocess,h)}),this.i18nTranslate(i,c,t.ref,d)}}i18nStart(t=null,e,i){let r=this.allocateDataSlot();this.i18n=this.i18nContext?this.i18nContext.forkChildContext(r,this.templateIndex,e):new QC(r,this.i18nGenerateMainBlockVar(),0,this.templateIndex,e);let{id:o,ref:s}=this.i18n,a=[ht(r),this.addToConsts(s)];o>0&&a.push(ht(o)),this.creationInstruction(t,i?te.i18n:te.i18nStart,a)}i18nEnd(t=null,e){if(!this.i18n)throw new Error("i18nEnd is executed with no i18n context present");this.i18nContext?(this.i18nContext.reconcileChildContext(this.i18n),this.i18nUpdateRef(this.i18nContext)):this.i18nUpdateRef(this.i18n);let{index:i,bindings:r}=this.i18n;if(r.size){for(let o of r)this.updateInstructionWithAdvance(this.getConstCount()-1,t,te.i18nExp,()=>this.convertPropertyBinding(o));this.updateInstruction(t,te.i18nApply,[ht(i)])}e||this.creationInstruction(t,te.i18nEnd),this.i18n=null}i18nAttributesInstruction(t,e,i){let r=!1,o=[];if(e.forEach(s=>{let a=s.i18n,l=s.value.visit(this._valueConverter);if(this.allocateBindingSlots(l),l instanceof vs){let u=PX(qQ(a));o.push(ht(s.name),this.i18nTranslate(a,u)),l.expressions.forEach(d=>{r=!0,this.updateInstructionWithAdvance(t,i,te.i18nExp,()=>this.convertPropertyBinding(d))})}}),o.length>0){let s=ht(this.allocateDataSlot()),a=this.addToConsts(_r(o));this.creationInstruction(i,te.i18nAttributes,[s,a]),r&&this.updateInstruction(i,te.i18nApply,[s])}}getNamespaceInstruction(t){switch(t){case"math":return te.namespaceMathML;case"svg":return te.namespaceSVG;default:return te.namespaceHTML}}addNamespaceInstruction(t,e){this._namespace=t,this.creationInstruction(e.startSourceSpan,t)}interpolatedUpdateInstruction(t,e,i,r,o,s){this.updateInstructionWithAdvance(e,r.sourceSpan,t,()=>[ht(i),...this.getUpdateInstructionArguments(o),...s])}visitContent(t){let e=this.allocateDataSlot(),i=this._ngContentSelectorsOffset+this._ngContentReservedSlots.length,r=[ht(e)];this._ngContentReservedSlots.push(t.selector);let o=t.attributes.filter(a=>"select"!==a.name.toLowerCase()),s=this.getAttributeExpressions(t.name,o,[],[]);s.length>0?r.push(ht(i),_r(s)):0!==i&&r.push(ht(i)),this.creationInstruction(t.sourceSpan,te.projection,r),this.i18n&&this.i18n.appendProjection(t.i18n,e)}visitElement(t){let e=this.allocateDataSlot(),i=new vD(null),r=!1,o=AC(t.i18n)&&!VT(t.i18n),s=[],[a,l]=Kd(t.name),c=CB(t.name);for(let ue of t.attributes){let{name:he,value:w}=ue;"ngNonBindable"===he?r=!0:"style"===he?i.registerStyleAttr(w):"class"===he?i.registerClassAttr(w):s.push(ue)}let u=[ht(e)];c||u.push(ht(l));let d=[],p=[];t.inputs.forEach(ue=>{i.registerBoundInput(ue)||(0===ue.type&&ue.i18n?p.push(ue):d.push(ue))});let h=this.getAttributeExpressions(t.name,s,d,t.outputs,i,[],p);u.push(this.addAttrsToConsts(h));let f=this.prepareRefsArray(t.references);u.push(this.addToConsts(f));let m=this._namespace,x=this.getNamespaceInstruction(a);x!==m&&this.addNamespaceInstruction(x,t),this.i18n&&this.i18n.appendElement(t.i18n,e);let g=!o&&this.i18n?!bB(t.children):t.children.length>0,b=!i.hasBindingsWithPipes&&0===t.outputs.length&&0===p.length&&!g,D=!b&&bB(t.children);if(b)this.creationInstruction(t.sourceSpan,c?te.elementContainer:te.element,sB(u));else{if(this.creationInstruction(t.startSourceSpan,c?te.elementContainerStart:te.elementStart,sB(u)),r&&this.creationInstruction(t.startSourceSpan,te.disableBindings),p.length>0&&this.i18nAttributesInstruction(e,p,t.startSourceSpan??t.sourceSpan),t.outputs.length>0)for(let ue of t.outputs)this.creationInstruction(ue.sourceSpan,te.listener,this.prepareListenerParameter(t.name,ue,e));o&&this.i18nStart(t.startSourceSpan,t.i18n,D)}let T=i.buildUpdateLevelInstructions(this._valueConverter),k=T.length-1;for(let ue=0;ue<=k;ue++)this._bindingSlots+=this.processStylingUpdateInstruction(e,T[ue]);let Z=ht(void 0),z=[],fe=[];d.forEach(ue=>{let he=ue.type;if(4===he){let w=ue.value.visit(this._valueConverter),F=!(w instanceof ta&&!w.value);this.allocateBindingSlots(w),z.push({span:ue.sourceSpan,paramsOrFn:zT(()=>F?this.convertPropertyBinding(w):Z,zQ(ue.name))})}else{if(ue.i18n)return;let w=ue.value.visit(this._valueConverter);if(void 0!==w){let F=[],[q,K]=Kd(ue.name),Y=TK(ue.securityContext,1===he);if(Y&&F.push(Y),q){let ae=ht(q);Y?F.push(ae):F.push(ht(null),ae)}if(this.allocateBindingSlots(w),0===he)w instanceof vs?this.interpolatedUpdateInstruction(CQ(w),e,K,ue,w,F):z.push({span:ue.sourceSpan,paramsOrFn:zT(()=>this.convertPropertyBinding(w),K,F)});else if(1===he)if(w instanceof vs&&wm(w)>1)this.interpolatedUpdateInstruction(function(n){switch(wm(n)){case 3:return te.attributeInterpolate1;case 5:return te.attributeInterpolate2;case 7:return te.attributeInterpolate3;case 9:return te.attributeInterpolate4;case 11:return te.attributeInterpolate5;case 13:return te.attributeInterpolate6;case 15:return te.attributeInterpolate7;case 17:return te.attributeInterpolate8;default:return te.attributeInterpolateV}}(w),e,K,ue,w,F);else{let ae=w instanceof vs?w.expressions[0]:w;fe.push({span:ue.sourceSpan,paramsOrFn:zT(()=>this.convertPropertyBinding(ae),K,F)})}else this.updateInstructionWithAdvance(e,ue.sourceSpan,te.classProp,()=>[ht(e),ht(K),this.convertPropertyBinding(w),...F])}}});for(let ue of z)this.updateInstructionWithAdvance(e,ue.span,te.property,ue.paramsOrFn);for(let ue of fe)this.updateInstructionWithAdvance(e,ue.span,te.attribute,ue.paramsOrFn);if(AX(this,t.children),!o&&this.i18n&&this.i18n.appendElement(t.i18n,e,!0),!b){let ue=t.endSourceSpan??t.sourceSpan;o&&this.i18nEnd(ue,D),r&&this.creationInstruction(ue,te.enableBindings),this.creationInstruction(ue,c?te.elementContainerEnd:te.elementEnd)}}visitTemplate(t){let e="ng-template",i=this.allocateDataSlot();this.i18n&&this.i18n.appendTemplate(t.i18n,i);let r=t.tagName?Kd(t.tagName)[1]:t.tagName,o=`${this.contextName}${t.tagName?"_"+m_(t.tagName):""}_${i}`,s=`${o}_Template`,a=[ht(i),Ri(s),ht(r)],l=this.getAttributeExpressions(e,t.attributes,t.inputs,t.outputs,void 0,t.templateAttrs);if(a.push(this.addAttrsToConsts(l)),t.references&&t.references.length){let u=this.prepareRefsArray(t.references);a.push(this.addToConsts(u)),a.push(Tn(te.templateRefExtractor))}let c=new KC(this.constantPool,this._bindingScope,this.level+1,o,this.i18n,i,s,this._namespace,this.fileBasedI18nSuffix,this.i18nUseExternalIds,this._constants);if(this._nestedTemplateFns.push(()=>{let u=c.buildTemplateFunction(t.children,t.variables,this._ngContentReservedSlots.length+this._ngContentSelectorsOffset,t.i18n);this.constantPool.statements.push(u.toDeclStmt(s)),c._ngContentReservedSlots.length&&this._ngContentReservedSlots.push(...c._ngContentReservedSlots)}),this.creationInstruction(t.sourceSpan,te.templateCreate,()=>(a.splice(2,0,ht(c.getConstCount()),ht(c.getVarCount())),sB(a))),this.templatePropertyBindings(i,t.templateAttrs),r===e){let[u,d]=function(n,t){let e=[],i=[];for(let r of n)(t(r)?e:i).push(r);return[e,i]}(t.inputs,Cwe);u.length>0&&this.i18nAttributesInstruction(i,u,t.startSourceSpan??t.sourceSpan),d.length>0&&this.templatePropertyBindings(i,d);for(let p of t.outputs)this.creationInstruction(p.sourceSpan,te.listener,this.prepareListenerParameter("ng_template",p,i))}}visitBoundText(t){if(this.i18n){let r=t.value.visit(this._valueConverter);return this.allocateBindingSlots(r),void(r instanceof vs&&(this.i18n.appendBoundText(t.i18n),this.i18nAppendBindings(r.expressions)))}let e=this.allocateDataSlot();this.creationInstruction(t.sourceSpan,te.text,[ht(e)]);let i=t.value.visit(this._valueConverter);this.allocateBindingSlots(i),i instanceof vs?this.updateInstructionWithAdvance(e,t.sourceSpan,function(n){switch(wm(n)){case 1:return te.textInterpolate;case 3:return te.textInterpolate1;case 5:return te.textInterpolate2;case 7:return te.textInterpolate3;case 9:return te.textInterpolate4;case 11:return te.textInterpolate5;case 13:return te.textInterpolate6;case 15:return te.textInterpolate7;case 17:return te.textInterpolate8;default:return te.textInterpolateV}}(i),()=>this.getUpdateInstructionArguments(i)):QT("Text nodes should be interpolated and never bound directly.")}visitText(t){this.i18n||this.creationInstruction(t.sourceSpan,te.text,[ht(this.allocateDataSlot()),ht(t.value)])}visitIcu(t){let e=!1;this.i18n||(e=!0,this.i18nStart(null,t.i18n,!0));let i=this.i18n,r=this.i18nBindProps(t.vars),o=this.i18nBindProps(t.placeholders),s=t.i18n,a=l=>{let u=UV({...r,...o},!1);return gm(null,te.i18nPostprocess,[l,wD(u,!0)])};if(VT(i.meta))this.i18nTranslate(s,{},i.ref,a);else{let l=this.i18nTranslate(s,{},void 0,a);i.appendIcu(WQ(s).name,l)}return e&&this.i18nEnd(null,!0),null}allocateDataSlot(){return this._dataIndex++}getConstCount(){return this._dataIndex}getVarCount(){return this._pureFunctionSlots}getConsts(){return this._constants}getNgContentSelectors(){return this._ngContentReservedSlots.length?this.constantPool.getConstLiteral(Nu(this._ngContentReservedSlots),!0):null}bindingContext(){return""+this._bindingContext++}templatePropertyBindings(t,e){let i=[];for(let r of e){if(!(r instanceof w_))continue;let o=r.value.visit(this._valueConverter);if(void 0!==o)if(this.allocateBindingSlots(o),o instanceof vs){let s=[];this.interpolatedUpdateInstruction(CQ(o),t,r.name,r,o,s)}else i.push({span:r.sourceSpan,paramsOrFn:zT(()=>this.convertPropertyBinding(o),r.name)})}for(let r of i)this.updateInstructionWithAdvance(t,r.span,te.property,r.paramsOrFn)}instructionFn(t,e,i,r,o=!1){t[o?"unshift":"push"]({span:e,reference:i,paramsOrFn:r})}processStylingUpdateInstruction(t,e){let i=0;if(e)for(let r of e.calls)i+=r.allocateBindingSlots,this.updateInstructionWithAdvance(t,r.sourceSpan,e.reference,()=>r.params(o=>r.supportsInterpolation&&o instanceof vs?this.getUpdateInstructionArguments(o):this.convertPropertyBinding(o)));return i}creationInstruction(t,e,i,r){this.instructionFn(this._creationCodeFns,t,e,i||[],r)}updateInstructionWithAdvance(t,e,i,r){this.addAdvanceInstructionIfNecessary(t,e),this.updateInstruction(e,i,r)}updateInstruction(t,e,i){this.instructionFn(this._updateCodeFns,t,e,i||[])}addAdvanceInstructionIfNecessary(t,e){if(t!==this._currentIndex){let i=t-this._currentIndex;if(i<1)throw new Error("advance instruction can only go forwards");this.instructionFn(this._updateCodeFns,e,te.advance,[ht(i)]),this._currentIndex=t}}allocatePureFunctionSlots(t){let e=this._pureFunctionSlots;return this._pureFunctionSlots+=t,e}allocateBindingSlots(t){this._bindingSlots+=t instanceof vs?t.expressions.length:1}getImplicitReceiverExpr(){return this._implicitReceiverExpr?this._implicitReceiverExpr:this._implicitReceiverExpr=0===this.level?Ri(Hc):this._bindingScope.getOrCreateSharedContextVar(0)}convertPropertyBinding(t){let e=uK(this,this.getImplicitReceiverExpr(),t,this.bindingContext()),i=e.currValExpr;return this._tempVariables.push(...e.stmts),i}getUpdateInstructionArguments(t){let{args:e,stmts:i}=function(n,t,e,i){let r=new GC(n,t,i,!0),o=r.visitInterpolation(e,zi.Expression);return r.usesImplicitReceiver&&n.notifyImplicitReceiverUse(),{stmts:dK(r,i),args:o.args}}(this,this.getImplicitReceiverExpr(),t,this.bindingContext());return this._tempVariables.push(...i),e}getAttributeExpressions(t,e,i,r,o,s=[],a=[]){let u,l=new Set,c=[];for(let p of e)if("ngProjectAs"===p.name&&(u=p),p.i18n){let f,{i18nVarRefsCache:h}=this._constants;h.has(p.i18n)?f=h.get(p.i18n):(f=this.i18nTranslate(p.i18n),h.set(p.i18n,f)),c.push(ht(p.name),f)}else c.push(...xQ(p.name),E1e(t,p));function d(p,h){"string"==typeof p?l.has(p)||(c.push(...xQ(p)),void 0!==h&&c.push(h),l.add(p)):c.push(ht(p))}if(u&&c.push(...function(n){let t=NV(n.value)[0];return[ht(5),Nu(t)]}(u)),o&&o.populateInitialStylingAttrs(c),i.length||r.length){let p=c.length;for(let h=0;h<i.length;h++){let f=i[h];4!==f.type&&1!==f.type&&d(f.name)}for(let h=0;h<r.length;h++){let f=r[h];1!==f.type&&d(f.name)}c.length!==p&&c.splice(p,0,ht(3))}return s.length&&(c.push(ht(4)),s.forEach(p=>d(p.name))),a.length&&(c.push(ht(6)),a.forEach(p=>d(p.name))),c}addToConsts(t){if(VQ(t))return WT;let e=this._constants.constExpressions;for(let i=0;i<e.length;i++)if(e[i].isEquivalent(t))return ht(i);return ht(e.push(t)-1)}addAttrsToConsts(t){return t.length>0?this.addToConsts(_r(t)):WT}prepareRefsArray(t){return t&&0!==t.length?Nu(DK(t.map(i=>{let r=this.allocateDataSlot(),o=this._bindingScope.freshReferenceName(),s=this.level,a=Ri(o);return this._bindingScope.set(s,i.name,a,0,(l,c)=>{let u=c>0?[IV(c).toStmt()]:[],d=a.set(Tn(te.reference).callFn([ht(r)]));return u.concat(d.toConstDecl())},!0),[i.name,i.value]}))):WT}prepareListenerParameter(t,e,i){return()=>{let r=e.name,o=1===e.type?jQ(r,e.phase):m_(r),s=`${this.templateName}_${t}_${o}_${i}_listener`,a=this._bindingScope.nestedScope(this._bindingScope.bindingLevel,wK);return SK(e,s,a)}}},TD=class extends $B{constructor(t,e,i,r){super(),this.constantPool=t,this.allocateSlot=e,this.allocatePureFunctionSlots=i,this.definePipe=r,this._pipeBindExprs=[]}visitPipe(t,e){let i=this.allocateSlot(),r=`PIPE:${i}`,o=this.allocatePureFunctionSlots(2+t.args.length),s=new Lu(t.span,t.sourceSpan,t.nameSpan,new xm(t.span,t.sourceSpan),r),{identifier:a,isVarLength:l}=function(n){let t=v1e[n.length];return{identifier:t||te.pipeBindV,isVarLength:!t}}(t.args);this.definePipe(t.name,r,i,Tn(a));let c=[t.exp,...t.args],u=this.visitAll(l?[new O_(t.span,t.sourceSpan,c)]:c),d=new ah(t.span,t.sourceSpan,s,[new ta(t.span,t.sourceSpan,i),new ta(t.span,t.sourceSpan,o),...u],null);return this._pipeBindExprs.push(d),d}updatePipeSlotOffsets(t){this._pipeBindExprs.forEach(e=>{e.args[1].value+=t})}visitLiteralArray(t,e){return new rh(t.span,t.sourceSpan,this.visitAll(t.expressions),i=>{let r=_r(i);return bQ(this.constantPool,r,this.allocatePureFunctionSlots)})}visitLiteralMap(t,e){return new rh(t.span,t.sourceSpan,this.visitAll(t.values),i=>{let r=ql(i.map((o,s)=>({key:t.keys[s].key,value:o,quoted:t.keys[s].quoted})));return bQ(this.constantPool,r,this.allocatePureFunctionSlots)})}},v1e=[te.pipeBind1,te.pipeBind2,te.pipeBind3,te.pipeBind4],b1e=[te.pureFunction0,te.pureFunction1,te.pureFunction2,te.pureFunction3,te.pureFunction4,te.pureFunction5,te.pureFunction6,te.pureFunction7,te.pureFunction8];function IV(n){return Tn(te.nextContext).callFn(n>1?[ht(n)]:[])}function bQ(n,t,e){let{literalFactory:i,literalFactoryArguments:r}=n.getLiteralFactory(t),o=e(1+r.length),{identifier:s,isVarLength:a}=function(n){let t=b1e[n.length];return{identifier:t||te.pureFunctionV,isVarLength:!t}}(r),l=[ht(o),i];return a?l.push(_r(r)):l.push(...r),Tn(s).callFn(l)}function xQ(n){let[t,e]=Kd(n),i=ht(e);return t?[ht(0),ht(t),i]:[i]}var o_="$$shared_ctx$$",B_=class{constructor(t=0,e=null,i){if(this.bindingLevel=t,this.parent=e,this.globals=i,this.map=new Map,this.referenceNameIndex=0,this.restoreViewVariable=null,this.usesRestoredViewContext=!1,void 0!==i)for(let r of i)this.set(0,r,Ri(r))}static createRootScope(){return new B_}get(t){let e=this;for(;e;){let i=e.map.get(t);if(null!=i)return e!==this&&(i={retrievalLevel:i.retrievalLevel,lhs:i.lhs,declareLocalCallback:i.declareLocalCallback,declare:!1,priority:i.priority},this.map.set(t,i),this.maybeGenerateSharedContextVar(i),this.maybeRestoreView()),i.declareLocalCallback&&!i.declare&&(i.declare=!0),i.lhs;e=e.parent}return 0===this.bindingLevel?null:this.getComponentProperty(t)}set(t,e,i,r=0,o,s){if(this.map.has(e)){if(s)return this;QT(`The name ${e} is already defined in scope to be ${this.map.get(e)}`)}return this.map.set(e,{retrievalLevel:t,lhs:i,declare:!1,declareLocalCallback:o,priority:r}),this}getLocal(t){return this.get(t)}notifyImplicitReceiverUse(){0!==this.bindingLevel&&(this.map.get(o_+0).declare=!0)}nestedScope(t,e){let i=new B_(t,this,e);return t>0&&i.generateSharedContextVar(0),i}getOrCreateSharedContextVar(t){let e=o_+t;return this.map.has(e)||this.generateSharedContextVar(t),this.map.get(e).lhs}getSharedContextName(t){let e=this.map.get(o_+t);return e&&e.declare?e.lhs:null}maybeGenerateSharedContextVar(t){if(1===t.priority&&t.retrievalLevel<this.bindingLevel){let e=this.map.get(o_+t.retrievalLevel);e?e.declare=!0:this.generateSharedContextVar(t.retrievalLevel)}}generateSharedContextVar(t){let e=Ri(Hc+this.freshReferenceName());this.map.set(o_+t,{retrievalLevel:t,lhs:e,declareLocalCallback:(i,r)=>[e.set(IV(r)).toConstDecl()],declare:!1,priority:2})}getComponentProperty(t){let e=this.map.get(o_+0);return e.declare=!0,this.maybeRestoreView(),e.lhs.prop(t)}maybeRestoreView(){this.isListenerScope()&&(this.parent.restoreViewVariable||(this.parent.restoreViewVariable=Ri(this.parent.freshReferenceName())),this.restoreViewVariable=this.parent.restoreViewVariable)}restoreViewStatement(){if(this.restoreViewVariable){let t=gm(null,te.restoreView,[this.restoreViewVariable]);return this.usesRestoredViewContext?Ri(YQ).set(t).toConstDecl():t.toStmt()}return null}viewSnapshotStatements(){return this.restoreViewVariable?[this.restoreViewVariable.set(gm(null,te.getCurrentView,[])).toConstDecl()]:[]}isListenerScope(){return this.parent&&this.parent.bindingLevel===this.bindingLevel}variableDeclarations(){let t=0;return Array.from(this.map.values()).filter(e=>e.declare).sort((e,i)=>i.retrievalLevel-e.retrievalLevel||i.priority-e.priority).reduce((e,i)=>{let r=this.bindingLevel-i.retrievalLevel,o=i.declareLocalCallback(this,r-t);return t=r,e.concat(o)},[])}freshReferenceName(){let t=this;for(;t.parent;)t=t.parent;return"_r"+t.referenceNameIndex++}hasRestoreViewVariable(){return!!this.restoreViewVariable}notifyRestoredViewContextUse(){this.usesRestoredViewContext=!0}};function CQ(n){switch(wm(n)){case 1:return te.propertyInterpolate;case 3:return te.propertyInterpolate1;case 5:return te.propertyInterpolate2;case 7:return te.propertyInterpolate3;case 9:return te.propertyInterpolate4;case 11:return te.propertyInterpolate5;case 13:return te.propertyInterpolate6;case 15:return te.propertyInterpolate7;case 17:return te.propertyInterpolate8;default:return te.propertyInterpolateV}}function S1e(n,t,e={}){let{interpolationConfig:i,preserveWhitespaces:r,enableI18nLegacyMessageIdFormat:o}=e,s=DD(i),l=(new _V).parse(n,t,{leadingTriviaChars:g1e,...e,tokenizeExpansionForms:!0});if(!e.alwaysAttemptHtmlToR3AstConversion&&l.errors&&l.errors.length>0){let D={interpolationConfig:i,preserveWhitespaces:r,errors:l.errors,nodes:[],styleUrls:[],styles:[],ngContentSelectors:[]};return e.collectCommentNodes&&(D.commentNodes=[]),D}let c=l.rootNodes,u=new ED(i,!r,o),d=u.visitAllWithErrors(c);if(!e.alwaysAttemptHtmlToR3AstConversion&&d.errors&&d.errors.length>0){let D={interpolationConfig:i,preserveWhitespaces:r,errors:d.errors,nodes:[],styleUrls:[],styles:[],ngContentSelectors:[]};return e.collectCommentNodes&&(D.commentNodes=[]),D}c=d.rootNodes,r||(c=Uu(new class{visitElement(t,e){return lEe.has(t.name)||t.attrs.some(t=>t.name===gK)?new qC(t.name,Uu(this,t.attrs),t.children,t.sourceSpan,t.startSourceSpan,t.endSourceSpan,t.i18n):new qC(t.name,t.attrs,function(n,t){let e=[];return t.forEach((i,r)=>{let s=i.visit(n,{prev:t[r-1],next:t[r+1]});s&&e.push(s)}),e}(this,t.children),t.sourceSpan,t.startSourceSpan,t.endSourceSpan,t.i18n)}visitAttribute(t,e){return t.name!==gK?t:null}visitText(t,e){if(t.value.match(cEe)||e&&(e.prev instanceof N_||e.next instanceof N_)){let o=t.tokens.map(a=>5===a.type?function({type:n,parts:t,sourceSpan:e}){return{type:n,parts:[yK(t[0])],sourceSpan:e}}(a):a),s=yK(t.value);return new F_(s,t.sourceSpan,o,t.i18n)}return null}visitComment(t,e){return t}visitExpansion(t,e){return t}visitExpansionCase(t,e){return t}},c),u.hasI18nMeta&&(c=Uu(new ED(i,!1),c)));let{nodes:p,errors:h,styleUrls:f,styles:m,ngContentSelectors:x,commentNodes:g}=function(n,t,e){let i=new class{constructor(t,e){this.bindingParser=t,this.options=e,this.errors=[],this.styles=[],this.styleUrls=[],this.ngContentSelectors=[],this.commentNodes=[],this.inI18nBlock=!1}visitElement(t){let e=AC(t.i18n);e&&(this.inI18nBlock&&this.reportError("Cannot mark an element as translatable inside of a translatable section. Please remove the nested i18n marker.",t.sourceSpan),this.inI18nBlock=!0);let i=CK(t);if(i.type===na.SCRIPT)return null;if(i.type===na.STYLE){let x=1===(n=t).children.length&&n.children[0]instanceof F_?n.children[0].value:null;return null!==x&&this.styles.push(x),null}if(i.type===na.STYLESHEET&&function(n){if(null==n||0===n.length||"/"==n[0])return!1;let t=n.match(EEe);return null===t||"package"==t[1]||"asset"==t[1]}(i.hrefAttr))return this.styleUrls.push(i.hrefAttr),null;var n;let r=function(n){return"ng-template"===Kd(n)[1]}(t.name),o=[],s=[],a=[],l=[],c=[],u={},d=[],p=[],h=!1;for(let x of t.attrs){let g=!1,b=_Q(x.name),D=!1;if(x.i18n&&(u[x.name]=x.i18n),b.startsWith("*")){h&&this.reportError("Can't have multiple template bindings on one element. Use only one attribute prefixed with *",x.sourceSpan),D=!0,h=!0;let T=x.value,k=b.substring("*".length),Z=[];this.bindingParser.parseInlineTemplateBinding(k,T,x.sourceSpan,x.valueSpan?x.valueSpan.start.offset:x.sourceSpan.start.offset+x.name.length,[],d,Z,!0),p.push(...Z.map(fe=>new oD(fe.name,fe.value,fe.sourceSpan,fe.keySpan,fe.valueSpan)))}else g=this.parseAttribute(r,x,[],o,s,a,l);!g&&!D&&c.push(this.visitAttribute(x))}let m,f=Uu(i.nonBindable?HEe:this,t.children);if(i.type===na.NG_CONTENT){t.children&&!t.children.every(b=>function(n){return n instanceof F_&&0==n.value.trim().length}(b)||function(n){return n instanceof xD}(b))&&this.reportError("<ng-content> element cannot have content.",t.sourceSpan);let x=i.selectAttr,g=t.attrs.map(b=>this.visitAttribute(b));m=new class{constructor(t,e,i,r){this.selector=t,this.attributes=e,this.sourceSpan=i,this.i18n=r,this.name="ng-content"}visit(t){return t.visitContent(this)}}(x,g,t.sourceSpan,t.i18n),this.ngContentSelectors.push(x)}else if(r){let x=this.extractAttributes(t.name,o,u);m=new uC(t.name,c,x.bound,s,[],f,l,a,t.sourceSpan,t.startSourceSpan,t.endSourceSpan,t.i18n)}else{let x=this.extractAttributes(t.name,o,u);m=new E_(t.name,c,x.bound,s,f,l,t.sourceSpan,t.startSourceSpan,t.endSourceSpan,t.i18n)}if(h){let x=this.extractAttributes("ng-template",d,u),g=[];x.literal.forEach(k=>g.push(k)),x.bound.forEach(k=>g.push(k));let b=m instanceof E_?{attributes:m.attributes,inputs:m.inputs,outputs:m.outputs}:{attributes:[],inputs:[],outputs:[]};m=new uC(m instanceof uC?null:m.name,b.attributes,b.inputs,b.outputs,g,[m],[],p,t.sourceSpan,t.startSourceSpan,t.endSourceSpan,r&&e?void 0:t.i18n)}return e&&(this.inI18nBlock=!1),m}visitAttribute(t){return new DC(t.name,t.value,t.sourceSpan,t.keySpan,t.valueSpan,t.i18n)}visitText(t){return this._visitTextWithInterpolation(t.value,t.sourceSpan,t.tokens,t.i18n)}visitExpansion(t){if(!t.i18n)return null;if(!AC(t.i18n))throw new Error(`Invalid type "${t.i18n.constructor}" for "i18n" property of ${t.sourceSpan.toString()}. Expected a "Message"`);let e=t.i18n,i={},r={};return Object.keys(e.placeholders).forEach(o=>{let s=e.placeholders[o];if(o.startsWith("VAR_")){let a=o.trim(),l=this.bindingParser.parseInterpolationExpression(s.text,s.sourceSpan);i[a]=new TC(l,s.sourceSpan)}else r[o]=this._visitTextWithInterpolation(s.text,s.sourceSpan,null)}),new sD(i,r,t.sourceSpan,e)}visitExpansionCase(t){return null}visitComment(t){return this.options.collectCommentNodes&&this.commentNodes.push(new class{constructor(t,e){this.value=t,this.sourceSpan=e}visit(t){throw new Error("visit() not implemented for Comment")}}(t.value||"",t.sourceSpan)),null}extractAttributes(t,e,i){let r=[],o=[];return e.forEach(s=>{let a=i[s.name];if(s.isLiteral)o.push(new DC(s.name,s.expression.source||"",s.sourceSpan,s.keySpan,s.valueSpan,a));else{let l=this.bindingParser.createBoundElementProperty(t,s,!0,!1);r.push(w_.fromBoundElementProperty(l,a))}}),{bound:r,literal:o}}parseAttribute(t,e,i,r,o,s,a){let l=_Q(e.name),c=e.value,u=e.sourceSpan,d=e.valueSpan?e.valueSpan.start.offset:u.start.offset;function p(g,b,D){let k=g.start.moveBy(b.length+(e.name.length-l.length)),Z=k.moveBy(D.length);return new Go(k,Z,k,D)}let h=l.match(LEe);if(h){if(null!=h[1]){let g=h[7],b=p(u,h[1],g);this.bindingParser.parsePropertyBinding(g,c,!1,u,d,e.valueSpan,i,r,b)}else if(h[2])if(t){let g=h[7],b=p(u,h[2],g);this.parseVariable(g,c,u,b,e.valueSpan,s)}else this.reportError('"let-" is only supported on ng-template elements.',u);else if(h[3]){let g=h[7],b=p(u,h[3],g);this.parseReference(g,c,u,b,e.valueSpan,a)}else if(h[4]){let g=[],b=h[7],D=p(u,h[4],b);this.bindingParser.parseEvent(b,c,!1,u,e.valueSpan||u,i,g,D),mB(g,o)}else if(h[5]){let g=h[7],b=p(u,h[5],g);this.bindingParser.parsePropertyBinding(g,c,!1,u,d,e.valueSpan,i,r,b),this.parseAssignmentEvent(g,c,u,e.valueSpan,i,o,b)}else if(h[6]){let g=p(u,"",l);this.bindingParser.parseLiteralAttr(l,c,u,d,e.valueSpan,i,r,g)}return!0}let f=null;if(l.startsWith(Zp_BANANA_BOX.start)?f=Zp_BANANA_BOX:l.startsWith(Zp_PROPERTY.start)?f=Zp_PROPERTY:l.startsWith(Zp_EVENT.start)&&(f=Zp_EVENT),null!==f&&l.endsWith(f.end)&&l.length>f.start.length+f.end.length){let g=l.substring(f.start.length,l.length-f.end.length),b=p(u,f.start,g);if(f.start===Zp_BANANA_BOX.start)this.bindingParser.parsePropertyBinding(g,c,!1,u,d,e.valueSpan,i,r,b),this.parseAssignmentEvent(g,c,u,e.valueSpan,i,o,b);else if(f.start===Zp_PROPERTY.start)this.bindingParser.parsePropertyBinding(g,c,!1,u,d,e.valueSpan,i,r,b);else{let D=[];this.bindingParser.parseEvent(g,c,!1,u,e.valueSpan||u,i,D,b),mB(D,o)}return!0}let m=p(u,"",l);return this.bindingParser.parsePropertyInterpolation(l,c,u,e.valueSpan,i,r,m,e.valueTokens??null)}_visitTextWithInterpolation(t,e,i,r){let o=vK(t),s=this.bindingParser.parseInterpolation(o,e,i);return s?new TC(s,e,r):new M_(o,e)}parseVariable(t,e,i,r,o,s){t.indexOf("-")>-1?this.reportError('"-" is not allowed in variable names',i):0===t.length&&this.reportError("Variable does not have a name",i),s.push(new oD(t,e,i,r,o))}parseReference(t,e,i,r,o,s){t.indexOf("-")>-1?this.reportError('"-" is not allowed in reference names',i):0===t.length?this.reportError("Reference does not have a name",i):s.some(a=>a.name===t)&&this.reportError(`Reference "#${t}" is defined more than once`,i),s.push(new class{constructor(t,e,i,r,o){this.name=t,this.value=e,this.sourceSpan=i,this.keySpan=r,this.valueSpan=o}visit(t){return t.visitReference(this)}}(t,e,i,r,o))}parseAssignmentEvent(t,e,i,r,o,s,a){let l=[];this.bindingParser.parseEvent(`${t}Change`,`${e} =$event`,!0,i,r||i,o,l,a),mB(l,s)}reportError(t,e,i=ku.ERROR){this.errors.push(new ym(e,t,i))}}(t,e),s={nodes:Uu(i,n),errors:t.errors.concat(i.errors),styleUrls:i.styleUrls,styles:i.styles,ngContentSelectors:i.ngContentSelectors};return e.collectCommentNodes&&(s.commentNodes=i.commentNodes),s}(c,s,{collectCommentNodes:!!e.collectCommentNodes});h.push(...l.errors,...d.errors);let b={interpolationConfig:i,preserveWhitespaces:r,errors:h.length>0?h:null,nodes:p,styleUrls:f,styles:m,ngContentSelectors:x};return e.collectCommentNodes&&(b.commentNodes=g),b}var EK=new SD;function DD(n=Pu){return new class{constructor(t,e,i,r){this._exprParser=t,this._interpolationConfig=e,this._schemaRegistry=i,this.errors=r}get interpolationConfig(){return this._interpolationConfig}createBoundHostProperties(t,e){let i=[];for(let r of Object.keys(t)){let o=t[r];"string"==typeof o?this.parsePropertyBinding(r,o,!0,e,e.start.offset,void 0,[],i,e):this._reportError(`Value of the host property binding "${r}" needs to be a string representing an expression but got "${o}" (${typeof o})`,e)}return i}createDirectiveHostEventAsts(t,e){let i=[];for(let r of Object.keys(t)){let o=t[r];"string"==typeof o?this.parseEvent(r,o,!1,e,e,[],i,e):this._reportError(`Value of the host listener "${r}" needs to be a string representing an expression but got "${o}" (${typeof o})`,e)}return i}parseInterpolation(t,e,i){let r=e.start.toString(),o=e.fullStart.offset;try{let s=this._exprParser.parseInterpolation(t,r,o,i,this._interpolationConfig);return s&&this._reportExpressionParserErrors(s.errors,e),s}catch(s){return this._reportError(`${s}`,e),this._exprParser.wrapLiteralPrimitive("ERROR",r,o)}}parseInterpolationExpression(t,e){let i=e.start.toString(),r=e.start.offset;try{let o=this._exprParser.parseInterpolationExpression(t,i,r);return o&&this._reportExpressionParserErrors(o.errors,e),o}catch(o){return this._reportError(`${o}`,e),this._exprParser.wrapLiteralPrimitive("ERROR",i,r)}}parseInlineTemplateBinding(t,e,i,r,o,s,a,l){let u=this._parseTemplateBindings(t,e,i,i.start.offset+"*".length,r);for(let d of u){let p=Kp(i,d.sourceSpan),h=d.key.source,f=Kp(i,d.key.span);if(d instanceof zC){let m=d.value?d.value.source:"$implicit",x=d.value?Kp(i,d.value.span):void 0;a.push(new eV(h,m,p,f,x))}else if(d.value){let m=l?p:i,x=Kp(i,d.value.ast.sourceSpan);this._parsePropertyAst(h,d.value,m,f,x,o,s)}else o.push([h,""]),this.parseLiteralAttr(h,null,f,r,void 0,o,s,f)}}_parseTemplateBindings(t,e,i,r,o){let s=i.start.toString();try{let a=this._exprParser.parseTemplateBindings(t,e,s,r,o);return this._reportExpressionParserErrors(a.errors,i),a.warnings.forEach(l=>{this._reportError(l,i,ku.WARNING)}),a.templateBindings}catch(a){return this._reportError(`${a}`,i),[]}}parseLiteralAttr(t,e,i,r,o,s,a,l){hB(t)?(t=t.substring(1),void 0!==l&&(l=Kp(l,new al(l.start.offset+1,l.end.offset))),e&&this._reportError('Assigning animation triggers via @prop="exp" attributes with an expression is invalid. Use property bindings (e.g. [@prop]="exp") or use an attribute without a value (e.g. @prop) instead.',i,ku.ERROR),this._parseAnimation(t,e,i,r,l,o,s,a)):a.push(new pC(t,this._exprParser.wrapLiteralPrimitive(e,"",r),ih.LITERAL_ATTR,i,l,o))}parsePropertyBinding(t,e,i,r,o,s,a,l,c){0===t.length&&this._reportError("Property name is missing in binding",r);let u=!1;t.startsWith(pB)?(u=!0,t=t.substring(pB.length),void 0!==c&&(c=Kp(c,new al(c.start.offset+pB.length,c.end.offset)))):hB(t)&&(u=!0,t=t.substring(1),void 0!==c&&(c=Kp(c,new al(c.start.offset+1,c.end.offset)))),u?this._parseAnimation(t,e,r,o,c,s,a,l):this._parsePropertyAst(t,this._parseBinding(e,i,s||r,o),r,c,s,a,l)}parsePropertyInterpolation(t,e,i,r,o,s,a,l){let c=this.parseInterpolation(e,r||i,l);return!!c&&(this._parsePropertyAst(t,c,i,a,r,o,s),!0)}_parsePropertyAst(t,e,i,r,o,s,a){s.push([t,e.source]),a.push(new pC(t,e,ih.DEFAULT,i,r,o))}_parseAnimation(t,e,i,r,o,s,a,l){0===t.length&&this._reportError("Animation trigger is missing",i);let c=this._parseBinding(e||"undefined",!1,s||i,r);a.push([t,c.source]),l.push(new pC(t,c,ih.ANIMATION,i,o,s))}_parseBinding(t,e,i,r){let o=(i&&i.start||"(unknown)").toString();try{let s=e?this._exprParser.parseSimpleBinding(t,o,r,this._interpolationConfig):this._exprParser.parseBinding(t,o,r,this._interpolationConfig);return s&&this._reportExpressionParserErrors(s.errors,i),s}catch(s){return this._reportError(`${s}`,i),this._exprParser.wrapLiteralPrimitive("ERROR",o,r)}}createBoundElementProperty(t,e,i=!1,r=!0){if(e.isAnimation)return new fD(e.name,4,io.NONE,e.expression,null,e.sourceSpan,e.keySpan,e.valueSpan);let s,c,o=null,a=null,l=e.name.split(".");if(l.length>1)if("attr"==l[0]){a=l.slice(1).join("."),i||this._validatePropertyOrAttributeName(a,e.sourceSpan,!0),c=fB(this._schemaRegistry,t,a,!0);let u=a.indexOf(":");if(u>-1){let d=a.substring(0,u),p=a.substring(u+1);a=wB(d,p)}s=1}else"class"==l[0]?(a=l[1],s=2,c=[io.NONE]):"style"==l[0]&&(o=l.length>2?l[2]:null,a=l[1],s=3,c=[io.STYLE]);if(null===a){let u=this._schemaRegistry.getMappedPropName(e.name);a=r?u:e.name,c=fB(this._schemaRegistry,t,u,!1),s=0,i||this._validatePropertyOrAttributeName(u,e.sourceSpan,!1)}return new fD(a,s,c[0],e.expression,o,e.sourceSpan,e.keySpan,e.valueSpan)}parseEvent(t,e,i,r,o,s,a,l){0===t.length&&this._reportError("Event name is missing in binding",r),hB(t)?(t=t.slice(1),void 0!==l&&(l=Kp(l,new al(l.start.offset+1,l.end.offset))),this._parseAnimationEvent(t,e,i,r,o,a,l)):this._parseRegularEvent(t,e,i,r,o,s,a,l)}calcPossibleSecurityContexts(t,e,i){let r=this._schemaRegistry.getMappedPropName(e);return fB(this._schemaRegistry,t,r,i)}_parseAnimationEvent(t,e,i,r,o,s,a){let l=function(n,t){return OQ(n,".",t)}(t,[t,""]),c=l[0],u=l[1].toLowerCase(),d=this._parseAction(e,i,o);s.push(new hD(c,u,1,d,r,o,a)),0===c.length&&this._reportError("Animation event name is missing in binding",r),u?"start"!==u&&"done"!==u&&this._reportError(`The provided animation output phase value "${u}" for "@${c}" is not supported (use start or done)`,r):this._reportError(`The animation trigger output event (@${c}) is missing its phase value name (start or done are currently supported)`,r)}_parseRegularEvent(t,e,i,r,o,s,a,l){let[c,u]=function(n,t){return OQ(n,":",t)}(t,[null,t]),d=this._parseAction(e,i,o);s.push([t,d.source]),a.push(new hD(u,c,0,d,r,o,l))}_parseAction(t,e,i){let r=(i&&i.start||"(unknown").toString(),o=i&&i.start?i.start.offset:0;try{let s=this._exprParser.parseAction(t,e,r,o,this._interpolationConfig);return s&&this._reportExpressionParserErrors(s.errors,i),!s||s.ast instanceof Ia?(this._reportError("Empty expressions are not allowed",i),this._exprParser.wrapLiteralPrimitive("ERROR",r,o)):s}catch(s){return this._reportError(`${s}`,i),this._exprParser.wrapLiteralPrimitive("ERROR",r,o)}}_reportError(t,e,i=ku.ERROR){this.errors.push(new ym(e,t,i))}_reportExpressionParserErrors(t,e){for(let i of t)this._reportError(i.message,e)}_validatePropertyOrAttributeName(t,e,i){let r=i?this._schemaRegistry.validateAttribute(t):this._schemaRegistry.validateProperty(t);r.error&&this._reportError(r.msg,e,ku.ERROR)}}(new bD(new yD),n,EK,[])}function TK(n,t){switch(n){case io.HTML:return Tn(te.sanitizeHtml);case io.SCRIPT:return Tn(te.sanitizeScript);case io.STYLE:return t?Tn(te.sanitizeStyle):null;case io.URL:return Tn(te.sanitizeUrl);case io.RESOURCE_URL:return Tn(te.sanitizeResourceUrl);default:return null}}function E1e(n,t){let e=Nu(t.value);if(!xK(n,t.name))return e;switch(EK.securityContext(n,t.name,!0)){case io.HTML:return CX(Tn(te.trustConstantHtml),new $T([new eD(t.value)],[]),void 0,t.valueSpan);case io.RESOURCE_URL:return CX(Tn(te.trustConstantResourceUrl),new $T([new eD(t.value)],[]),void 0,t.valueSpan);default:return e}}function D1e(n){return n instanceof M_||n instanceof TC||n instanceof sD}function bB(n){return n.every(D1e)}function zT(n,t,e){return()=>{let i=n(),r=Array.isArray(i)?i:[i];return e&&r.push(...e),t&&r.unshift(ht(t)),r}}var MQ="ngI18nClosureMode";function DK(n){return n.reduce((t,e)=>{let i=Array.isArray(e)?DK(e):e;return t.concat(i)},[])}var P1e=/attr\.([^\]]+)/;function IK(n,t,e){let i=new sh,r=NV(n.selector);return i.set("type",n.internalType),r.length>0&&i.set("selectors",Nu(r)),n.queries.length>0&&i.set("contentQueries",function(n,t,e){let i=[],r=[],o=XQ(r,"_t");for(let a of n){i.push(Tn(te.contentQuery).callFn([Ri("dirIndex"),...RK(a,t)]).toStmt());let l=o(),c=Tn(te.loadQuery).callFn([]),u=Tn(te.queryRefresh).callFn([l.set(c)]),d=Ri(Hc).prop(a.propertyName).set(a.first?l.prop("first"):l);r.push(u.and(d).toStmt())}let s=e?`${e}_ContentQueries`:null;return ra([new ia($C,ZC),new ia(Hc,null),new ia("dirIndex",null)],[lh(1,i),lh(2,r)],Pa,null,s)}(n.queries,t,n.name)),n.viewQueries.length&&i.set("viewQuery",function(n,t,e){let i=[],r=[],o=XQ(r,"_t");n.forEach(a=>{let l=Tn(te.viewQuery).callFn(RK(a,t));i.push(l.toStmt());let c=o(),u=Tn(te.loadQuery).callFn([]),d=Tn(te.queryRefresh).callFn([c.set(u)]),p=Ri(Hc).prop(a.propertyName).set(a.first?c.prop("first"):c);r.push(d.and(p).toStmt())});let s=e?`${e}_Query`:null;return ra([new ia($C,ZC),new ia(Hc,null)],[lh(1,i),lh(2,r)],Pa,null,s)}(n.viewQueries,t,n.name)),i.set("hostBindings",function(n,t,e,i,r,o,s){let a=Ri(Hc),l=new vD(a),{styleAttr:c,classAttr:u}=n.specialAttributes;void 0!==c&&l.registerStyleAttr(c),void 0!==u&&l.registerClassAttr(u);let d=[],p=[],h=[],f=t,m=e.createDirectiveHostEventAsts(n.listeners,f);m&&m.length&&d.push(...function(n,t){let e=[],i=[],r=[];for(let o of n){let s=o.name&&m_(o.name),a=1===o.type?jQ(s,o.targetOrPhase):s,l=t&&s?`${t}_${a}_HostBindingHandler`:null,c=SK(S_.fromParsedEvent(o),l);1==o.type?i.push(c):e.push(c)}for(let o of i)r.push({reference:te.syntheticHostListener,paramsOrFn:o,span:null});for(let o of e)r.push({reference:te.listener,paramsOrFn:o,span:null});return r}(m,o));let x=e.createBoundHostProperties(n.properties,f),g=[],b=0;x&&x.forEach(ue=>{l.registerInputBasedOnName(ue.name,ue.expression,f)?b+=2:(g.push(ue),b++)});let D,T=()=>(D||(D=new TD(i,()=>QT("Unexpected node"),he=>{let w=b;return b+=he,w},()=>QT("Unexpected pipe"))),D),k=[],Z=[],z=[];for(let ue of g){let he=ue.expression.visit(T()),w=SQ(a,he),{bindingName:F,instruction:q,isAttribute:K}=q1e(ue),de=e.calcPossibleSecurityContexts(r,F,K).filter(le=>le!==io.NONE),Y=null;de.length&&(Y=2===de.length&&de.indexOf(io.URL)>-1&&de.indexOf(io.RESOURCE_URL)>-1?Tn(te.sanitizeUrlOrResourceUrl):TK(de[0],K));let ae=[ht(F),w.currValExpr];Y&&ae.push(Y),h.push(...w.stmts),q===te.hostProperty?k.push(ae):q===te.attribute?Z.push(ae):q===te.syntheticHostProperty?z.push(ae):p.push({reference:q,paramsOrFn:ae,span:null})}for(let ue of k)p.push({reference:te.hostProperty,paramsOrFn:ue,span:null});for(let ue of Z)p.push({reference:te.attribute,paramsOrFn:ue,span:null});for(let ue of z)p.push({reference:te.syntheticHostProperty,paramsOrFn:ue,span:null});let fe=function(n){let t=[];for(let e of Object.getOwnPropertyNames(n)){let i=n[e];t.push(ht(e),i)}return t}(n.attributes);if(l.assignHostAttrs(fe,s),l.hasBindings&&l.buildUpdateLevelInstructions(T()).forEach(ue=>{for(let he of ue.calls)b+=Math.max(he.allocateBindingSlots-2,0),p.push({reference:ue.reference,paramsOrFn:W1e(he,a,SQ),span:null})}),b&&s.set("hostVars",ht(b)),d.length>0||p.length>0){let ue=o?`${o}_HostBindings`:null,he=[];return d.length>0&&he.push(lh(1,cD(d))),p.length>0&&he.push(lh(2,h.concat(cD(p)))),ra([new ia($C,ZC),new ia(Hc,null)],he,Pa,null,ue)}return null}(n.host,n.typeSourceSpan,e,t,n.selector||"",n.name,i)),i.set("inputs",OX(n.inputs,!0)),i.set("outputs",OX(n.outputs)),null!==n.exportAs&&i.set("exportAs",_r(n.exportAs.map(o=>ht(o)))),n.isStandalone&&i.set("standalone",ht(!0)),i}function PK(n,t){let e=[],i=t.providers,r=t.viewProviders;if(i||r){let o=[i||new hm([])];r&&o.push(r),e.push(Tn(te.ProvidersFeature).callFn(o))}t.usesInheritance&&e.push(Tn(te.InheritDefinitionFeature)),t.fullInheritance&&e.push(Tn(te.CopyDefinitionFeature)),t.lifecycle.usesOnChanges&&e.push(Tn(te.NgOnChangesFeature)),t.hasOwnProperty("template")&&t.isStandalone&&e.push(Tn(te.StandaloneFeature)),e.length&&n.set("features",_r(e))}function RK(n,t){let e=[kwe(n,t),ht(B1e(n))];return n.read&&e.push(n.read),e}function B1e(n){return(n.descendants?1:0)|(n.static?2:0)|(n.emitDistinctChangesOnly?4:0)}function U1e(n){return ul(ht(n))}function wQ(n){return ul(ql(Object.keys(n).map(e=>({key:e,value:ht(Array.isArray(n[e])?n[e][0]:n[e]),quoted:!0}))))}function PV(n){return n.length>0?ul(_r(n.map(t=>ht(t)))):Jd}function OK(n){let t=null!==n.selector?n.selector.replace(/\n/g,""):null;return[ID(n.type.type,n.typeArgumentCount),null!==t?U1e(t):Jd,null!==n.exportAs?PV(n.exportAs):Jd,wQ(n.inputs),wQ(n.outputs),PV(n.queries.map(e=>e.propertyName))]}function SQ(n,t){return uK(null,n,t,"b")}function W1e(n,t,e){return n.params(i=>e(t,i).currValExpr)}function q1e(n){let e,t=n.name,i=t.match(P1e);return i?(t=i[1],e=te.attribute):n.isAnimation?(t=zQ(t),e=te.syntheticHostProperty):e=te.hostProperty,{bindingName:t,instruction:e,isAttribute:!!i}}var n,X1e=/^(?:\[([^\]]+)\])|(?:\(([^\)]+)\))$/,RV=class{};function EQ(n){return{...n,predicate:kK(n.predicate),read:n.read?new Ln(n.read):null,static:n.static,emitDistinctChangesOnly:n.emitDistinctChangesOnly}}function TQ(n){return{propertyName:n.propertyName,first:n.first??!1,predicate:kK(n.predicate),descendants:n.descendants??!1,read:n.read?new Ln(n.read):null,static:n.static??!1,emitDistinctChangesOnly:n.emitDistinctChangesOnly??!0}}function kK(n){return Array.isArray(n)?n:HV(new Ln(n),1)}function DQ(n){let t=RQ(n.inputs||[]),e=RQ(n.outputs||[]),i=n.propMetadata,r={},o={};for(let s in i)i.hasOwnProperty(s)&&i[s].forEach(a=>{lTe(a)?r[s]=a.bindingPropertyName?[a.bindingPropertyName,s]:s:cTe(a)&&(o[s]=a.bindingPropertyName||s)});return{...n,typeArgumentCount:0,typeSourceSpan:n.typeSourceSpan,type:As(n.type),internalType:new Ln(n.type),deps:null,host:oTe(n.propMetadata,n.typeSourceSpan,n.host),inputs:{...t,...r},outputs:{...e,...o},queries:n.queries.map(EQ),providers:null!=n.providers?new Ln(n.providers):null,viewQueries:n.viewQueries.map(EQ),fullInheritance:!1}}function FK(n,t){return{name:n.type.name,type:As(n.type),typeSourceSpan:t,internalType:new Ln(n.type),selector:n.selector??null,inputs:n.inputs??{},outputs:n.outputs??{},host:J1e(n.host),queries:(n.queries??[]).map(TQ),viewQueries:(n.viewQueries??[]).map(TQ),providers:void 0!==n.providers?new Ln(n.providers):null,exportAs:n.exportAs??null,usesInheritance:n.usesInheritance??!1,lifecycle:{usesOnChanges:n.usesOnChanges??!1},deps:null,typeArgumentCount:0,fullInheritance:!1,isStandalone:n.isStandalone??!1}}function J1e(n={}){return{attributes:$1e(n.attributes??{}),listeners:n.listeners??{},properties:n.properties??{},specialAttributes:{classAttr:n.classAttribute,styleAttr:n.styleAttribute}}}function $1e(n){let t={};for(let e of Object.keys(n))t[e]=new Ln(n[e]);return t}function tTe(n){return{...n,type:new Ln(n.type)}}function xB(n,t=null){return{kind:__.Directive,isComponent:t||"component"===n.kind,selector:n.selector,type:new Ln(n.type),inputs:n.inputs??[],outputs:n.outputs??[],exportAs:n.exportAs??null}}function iTe(n){return{kind:__.Pipe,name:n.name,type:new Ln(n.type)}}function NK(n,t,e,i,r){let o=r?D_.fromArray(r):Pu,s=S1e(n,e,{preserveWhitespaces:i,interpolationConfig:o});if(null!==s.errors){let a=s.errors.map(l=>l.toString()).join(", ");throw new Error(`Errors during JIT compilation of template for ${t}: ${a}`)}return{template:s,interpolation:o}}function s_(n,t){if(n.hasOwnProperty(t))return HV(new Ln(n[t]),0)}function AQ(n,t){if(n.hasOwnProperty(t))return new Ln(n[t])}function IQ(n){return HV("function"==typeof n?new Ln(n):new cl(n??null),0)}function LK(n){let t=null!=n.attribute,e=null===n.token?null:new Ln(n.token);return BK(t?new Ln(n.attribute):e,t,n.host,n.optional,n.self,n.skipSelf)}function PQ(n){let t=n.attribute??!1;return BK(null===n.token?null:new Ln(n.token),t,n.host??!1,n.optional??!1,n.self??!1,n.skipSelf??!1)}function BK(n,t,e,i,r,o){return{token:n,attributeNameType:t?ht("unknown"):null,host:e,optional:i,self:r,skipSelf:o}}function oTe(n,t,e){let i=function(n){let t={},e={},i={},r={};for(let o of Object.keys(n)){let s=n[o],a=o.match(X1e);if(null===a)switch(o){case"class":if("string"!=typeof s)throw new Error("Class binding must be string");r.classAttr=s;break;case"style":if("string"!=typeof s)throw new Error("Style binding must be string");r.styleAttr=s;break;default:t[o]="string"==typeof s?ht(s):s}else if(null!=a[1]){if("string"!=typeof s)throw new Error("Property binding must be string");i[a[1]]=s}else if(null!=a[2]){if("string"!=typeof s)throw new Error("Event binding must be string");e[a[2]]=s}}return{attributes:t,listeners:e,properties:i,specialAttributes:r}}(e||{}),r=function(n,t){let e=DD();return e.createDirectiveHostEventAsts(n.listeners,t),e.createBoundHostProperties(n.properties,t),e.errors}(i,t);if(r.length)throw new Error(r.map(o=>o.msg).join("\n"));for(let o in n)n.hasOwnProperty(o)&&n[o].forEach(s=>{sTe(s)?i.properties[s.hostPropertyName||o]=rwe("this",o):aTe(s)&&(i.listeners[s.eventName||o]=`${o}(${(s.args||[]).join(",")})`)});return i}function sTe(n){return"HostBinding"===n.ngMetadataName}function aTe(n){return"HostListener"===n.ngMetadataName}function lTe(n){return"Input"===n.ngMetadataName}function cTe(n){return"Output"===n.ngMetadataName}function RQ(n){return n.reduce((t,e)=>{let[i,r]=e.split(":",2).map(o=>o.trim());return t[i]=r||i,t},{})}new class{constructor(t){this.full=t;let e=t.split(".");this.major=e[0],this.minor=e[1],this.patch=e.slice(2).join(".")}}("14.2.11"),new class{constructor(){this.closedByParent=!1,this.isVoid=!1,this.ignoreFirstLf=!1,this.canSelfClose=!0,this.preventNamespaceInheritance=!1}requireExtraParent(t){return!1}isClosedByChild(t){return!1}getContentType(){return Wl.PARSABLE_DATA}},((n=p_).ng||(n.ng={})).\u0275compilerFacade=new class{constructor(t=new class{evaluateStatements(t,e,i,r){let o=new XB(i),s=EC.createRoot();return e.length>0&&!e[0].isEquivalent(ht("use strict").toStmt())&&(e=[ht("use strict").toStmt(),...e]),o.visitAllStatements(e,s),o.createReturnStmt(s),this.evaluateCode(t,s,o.getArgs(),r)}evaluateCode(t,e,i,r){let o=`"use strict";${e.toSource()}\n//# sourceURL=${t}`,s=[],a=[];for(let c in i)a.push(i[c]),s.push(c);if(r){let c=UX(...s.concat("return null;")).toString(),u=c.slice(0,c.indexOf("return null;")).split("\n").length-1;o+=`\n${e.toSourceMapGenerator(t,u).toJsComment()}`}let l=UX(...s.concat(o));return this.executeFunction(l,a)}executeFunction(t,e){return t(...e)}}){this.jitEvaluator=t,this.FactoryTarget=Nc,this.ResourceLoader=RV,this.elementSchemaRegistry=new SD}compilePipe(t,e,i){let o=jX({name:i.name,type:As(i.type),internalType:new Ln(i.type),typeArgumentCount:0,deps:null,pipeName:i.pipeName,pure:i.pure,isStandalone:i.isStandalone});return this.jitExpression(o.expression,t,e,[])}compilePipeDeclaration(t,e,i){let o=jX({name:(n=i).type.name,type:As(n.type),internalType:new Ln(n.type),typeArgumentCount:0,pipeName:n.name,deps:null,pure:n.pure??!0,isStandalone:n.isStandalone??!1});var n;return this.jitExpression(o.expression,t,e,[])}compileInjectable(t,e,i){let{expression:r,statements:o}=kX({name:i.name,type:As(i.type),internalType:new Ln(i.type),typeArgumentCount:i.typeArgumentCount,providedIn:IQ(i.providedIn),useClass:s_(i,"useClass"),useFactory:AQ(i,"useFactory"),useValue:s_(i,"useValue"),useExisting:s_(i,"useExisting"),deps:i.deps?.map(LK)},!0);return this.jitExpression(r,t,e,o)}compileInjectableDeclaration(t,e,i){let{expression:r,statements:o}=kX({name:i.type.name,type:As(i.type),internalType:new Ln(i.type),typeArgumentCount:0,providedIn:IQ(i.providedIn),useClass:s_(i,"useClass"),useFactory:AQ(i,"useFactory"),useValue:s_(i,"useValue"),useExisting:s_(i,"useExisting"),deps:i.deps?.map(PQ)},!0);return this.jitExpression(r,t,e,o)}compileInjector(t,e,i){let o=zX({name:i.name,type:As(i.type),internalType:new Ln(i.type),providers:i.providers&&i.providers.length>0?new Ln(i.providers):null,imports:i.imports.map(s=>new Ln(s))});return this.jitExpression(o.expression,t,e,[])}compileInjectorDeclaration(t,e,i){let r={name:(n=i).type.name,type:As(n.type),internalType:new Ln(n.type),providers:void 0!==n.providers&&n.providers.length>0?new Ln(n.providers):null,imports:void 0!==n.imports?n.imports.map(t=>new Ln(t)):[]},o=zX(r);var n;return this.jitExpression(o.expression,t,e,[])}compileNgModule(t,e,i){let o=iSe({type:As(i.type),internalType:new Ln(i.type),adjacentType:new Ln(i.type),bootstrap:i.bootstrap.map(As),declarations:i.declarations.map(As),publicDeclarationTypes:null,imports:i.imports.map(As),includeImportTypes:!0,exports:i.exports.map(As),selectorScopeMode:g_.Inline,containsForwardDecls:!1,schemas:i.schemas?i.schemas.map(As):null,id:i.id?new Ln(i.id):null});return this.jitExpression(o.expression,t,e,[])}compileNgModuleDeclaration(t,e,i){let r=function(n){let t=new sh;return t.set("type",new Ln(n.type)),void 0!==n.bootstrap&&t.set("bootstrap",new Ln(n.bootstrap)),void 0!==n.declarations&&t.set("declarations",new Ln(n.declarations)),void 0!==n.imports&&t.set("imports",new Ln(n.imports)),void 0!==n.exports&&t.set("exports",new Ln(n.exports)),void 0!==n.schemas&&t.set("schemas",new Ln(n.schemas)),void 0!==n.id&&t.set("id",new Ln(n.id)),Tn(te.defineNgModule).callFn([t.toLiteralMap()])}(i);return this.jitExpression(r,t,e,[])}compileDirective(t,e,i){let r=DQ(i);return this.compileDirectiveFromMeta(t,e,r)}compileDirectiveDeclaration(t,e,i){let o=FK(i,this.createParseSourceSpan("Directive",i.type.name,e));return this.compileDirectiveFromMeta(t,e,o)}compileDirectiveFromMeta(t,e,i){let r=new iD,s=function(n,t,e){let i=IK(n,t,e);PK(i,n);let r=Tn(te.defineDirective).callFn([i.toLiteralMap()],void 0,!0),o=function(n){let t=OK(n);return t.push(Jd),t.push(ul(ht(n.isStandalone))),ul(Tn(te.DirectiveDeclaration,t))}(n);return{expression:r,type:o,statements:[]}}(i,r,DD());return this.jitExpression(s.expression,t,e,r.statements)}compileComponent(t,e,i){let{template:r,interpolation:o}=NK(i.template,i.name,e,i.preserveWhitespaces,i.interpolation),s={...i,...DQ(i),selector:i.selector||this.elementSchemaRegistry.getDefaultComponentElementName(),template:r,declarations:i.declarations.map(tTe),declarationListEmitMode:0,styles:[...i.styles,...r.styles],encapsulation:i.encapsulation,interpolation:o,changeDetection:i.changeDetection,animations:null!=i.animations?new Ln(i.animations):null,viewProviders:null!=i.viewProviders?new Ln(i.viewProviders):null,relativeContextFilePath:"",i18nUseExternalIds:!0};return this.compileComponentFromMeta(t,`ng:///${i.name}.js`,s)}compileComponentDeclaration(t,e,i){let o=function(n,t,e){let{template:i,interpolation:r}=NK(n.template,n.type.name,e,n.preserveWhitespaces??!1,n.interpolation),o=[];if(n.dependencies)for(let s of n.dependencies)switch(s.kind){case"directive":case"component":o.push(xB(s));break;case"pipe":o.push(iTe(s))}else(n.components||n.directives||n.pipes)&&(n.components&&o.push(...n.components.map(s=>xB(s,!0))),n.directives&&o.push(...n.directives.map(s=>xB(s))),n.pipes&&o.push(...function(n){return n?Object.keys(n).map(t=>({kind:__.Pipe,name:t,type:new Ln(n[t])})):[]}(n.pipes)));return{...FK(n,t),template:i,styles:n.styles??[],declarations:o,viewProviders:void 0!==n.viewProviders?new Ln(n.viewProviders):null,animations:void 0!==n.animations?new Ln(n.animations):null,changeDetection:n.changeDetection??cC.Default,encapsulation:n.encapsulation??qd.Emulated,interpolation:r,declarationListEmitMode:2,relativeContextFilePath:"",i18nUseExternalIds:!0}}(i,this.createParseSourceSpan("Component",i.type.name,e),e);return this.compileComponentFromMeta(t,e,o)}compileComponentFromMeta(t,e,i){let r=new iD,s=function(n,t,e){let i=IK(n,t,e);PK(i,n);let r=n.selector&&Zd.parse(n.selector),o=r&&r[0];if(o){let g=o.getAttrs();g.length&&i.set("attrs",t.getConstLiteral(_r(g.map(b=>ht(null!=b?b:void 0))),!0))}let s=n.name,a=s?`${s}_Template`:null,l=n.changeDetection,c=n.template,u=new KC(t,B_.createRootScope(),0,s,null,null,a,te.namespaceHTML,n.relativeContextFilePath,n.i18nUseExternalIds),d=u.buildTemplateFunction(c.nodes,[]),p=u.getNgContentSelectors();p&&i.set("ngContentSelectors",p),i.set("decls",ht(u.getConstCount())),i.set("vars",ht(u.getVarCount()));let{constExpressions:h,prepareStatements:f}=u.getConsts();if(h.length>0){let g=_r(h);f.length>0&&(g=ra([],[...f,new Do(g)])),i.set("consts",g)}if(i.set("template",d),n.declarations.length>0&&i.set("dependencies",function(n,t){switch(t){case 0:return n;case 1:return ra([],[new Do(n)]);case 2:let e=n.prop("map").callFn([Tn(te.resolveForwardRef)]);return ra([],[new Do(e)])}}(_r(n.declarations.map(g=>g.type)),n.declarationListEmitMode)),null===n.encapsulation&&(n.encapsulation=qd.Emulated),n.styles&&n.styles.length){let b=(n.encapsulation==qd.Emulated?function(n,t,e){let i=new class{constructor(){this.strictStyling=!0}shimCssText(t,e,i=""){let r=t.match(ESe)||[];return t=function(n){return n.replace(wSe,"")}(t),t=this._insertDirectives(t),[this._scopeCssText(t,e,i),...r].join("\n")}_insertDirectives(t){return t=this._insertPolyfillDirectivesInCssText(t),this._insertPolyfillRulesInCssText(t)}_insertPolyfillDirectivesInCssText(t){return t.replace(mSe,function(...e){return e[2]+"{"})}_insertPolyfillRulesInCssText(t){return t.replace(gSe,(...e)=>{let i=e[0].replace(e[1],"").replace(e[2],"");return e[4]+i})}_scopeCssText(t,e,i){let r=this._extractUnscopedRulesFromCssText(t);return t=this._insertPolyfillHostInCssText(t),t=this._convertColonHost(t),t=this._convertColonHostContext(t),t=this._convertShadowDOMSelectors(t),e&&(t=this._scopeSelectors(t,e,i)),(t=t+"\n"+r).trim()}_extractUnscopedRulesFromCssText(t){let i,e="";for(WX.lastIndex=0;null!==(i=WX.exec(t));)e+=i[0].replace(i[2],"").replace(i[1],i[4])+"\n\n";return e}_convertColonHost(t){return t.replace(_Se,(e,i,r)=>{if(i){let o=[],s=i.split(",").map(a=>a.trim());for(let a of s){if(!a)break;let l=tm+a.replace(gD,"")+r;o.push(l)}return o.join(",")}return tm+r})}_convertColonHostContext(t){return t.replace(vSe,e=>{let r,i=[[]];for(;r=ySe.exec(e);){let o=(r[1]??"").trim().split(",").map(a=>a.trim()).filter(a=>""!==a),s=i.length;kSe(i,o.length);for(let a=0;a<o.length;a++)for(let l=0;l<s;l++)i[l+a*s].push(o[a]);e=r[2]}return i.map(o=>function(n,t){let e=tm;d_.lastIndex=0;let i=d_.test(t);if(0===n.length)return e+t;let r=[n.pop()||""];for(;n.length>0;){let o=r.length,s=n.pop();for(let a=0;a<o;a++){let l=r[a];r[2*o+a]=l+" "+s,r[o+a]=s+" "+l,r[a]=s+l}}return r.map(o=>i?`${o}${t}`:`${o}${e}${t}, ${o} ${e}${t}`).join(",")}(o,e)).join(", ")})}_convertShadowDOMSelectors(t){return bSe.reduce((e,i)=>e.replace(i," "),t)}_scopeSelectors(t,e,i){return XX(t,r=>{let o=r.selector,s=r.content;return"@"!==r.selector[0]?o=this._scopeSelector(r.selector,e,i,this.strictStyling):r.selector.startsWith("@media")||r.selector.startsWith("@supports")||r.selector.startsWith("@document")||r.selector.startsWith("@layer")?s=this._scopeSelectors(r.content,e,i):(r.selector.startsWith("@font-face")||r.selector.startsWith("@page"))&&(s=this._stripScopingSelectors(r.content)),new WC(o,s)})}_stripScopingSelectors(t){return XX(t,e=>{let i=e.selector.replace(YX," ").replace(qX," ");return new WC(i,e.content)})}_scopeSelector(t,e,i,r){return t.split(",").map(o=>o.trim().split(YX)).map(o=>{let[s,...a]=o;return[(c=>this._selectorNeedsScoping(c,e)?r?this._applyStrictSelectorScope(c,e,i):this._applySelectorScope(c,e,i):c)(s),...a].join(" ")}).join(", ")}_selectorNeedsScoping(t,e){return!this._makeScopeMatcher(e).test(t)}_makeScopeMatcher(t){return t=t.replace(/\[/g,"\\[").replace(/\]/g,"\\]"),new RegExp("^("+t+")([>\\s~+[.,{:][\\s\\S]*)?$","m")}_applySelectorScope(t,e,i){return this._applySimpleSelectorScope(t,e,i)}_applySimpleSelectorScope(t,e,i){if(d_.lastIndex=0,d_.test(t)){let r=this.strictStyling?`[${i}]`:e;return t.replace(qX,(o,s)=>s.replace(/([^:]*)(:*)(.*)/,(a,l,c,u)=>l+r+c+u)).replace(d_,r+" ")}return e+" "+t}_applyStrictSelectorScope(t,e,i){let u,o="["+(e=e.replace(/\[is=([^\]]*)\]/g,(m,...x)=>x[0]))+"]",s=m=>{let x=m.trim();if(!x)return"";if(m.indexOf(tm)>-1)x=this._applySimpleSelectorScope(m,e,i);else{let g=m.replace(d_,"");if(g.length>0){let b=g.match(/([^:]*)(:*)(.*)/);b&&(x=b[1]+o+b[2]+b[3])}}return x},a=new class{constructor(t){this.placeholders=[],this.index=0,t=this._escapeRegexMatches(t,/(\[[^\]]*\])/g),t=this._escapeRegexMatches(t,/(\\.)/g),this._content=t.replace(/(:nth-[-\w]+)(\([^)]+\))/g,(e,i,r)=>{let o=`__ph-${this.index}__`;return this.placeholders.push(r),this.index++,i+o})}restore(t){return t.replace(/__ph-(\d+)__/g,(e,i)=>this.placeholders[+i])}content(){return this._content}_escapeRegexMatches(t,e){return t.replace(e,(i,r)=>{let o=`__ph-${this.index}__`;return this.placeholders.push(r),this.index++,o})}}(t),l="",c=0,d=/( |>|\+|~(?!=))\s*/g,h=!((t=a.content()).indexOf(tm)>-1);for(;null!==(u=d.exec(t));){let m=u[1],x=t.slice(c,u.index).trim();h=h||x.indexOf(tm)>-1,l+=`${h?s(x):x} ${m} `,c=d.lastIndex}let f=t.substring(c);return h=h||f.indexOf(tm)>-1,l+=h?s(f):f,a.restore(l)}_insertPolyfillHostInCssText(t){return t.replace(MSe,ZV).replace(CSe,gD)}};return n.map(r=>i.shimCssText(r,"_ngcontent-%COMP%","_nghost-%COMP%"))}(n.styles):n.styles).reduce((D,T)=>(T.trim().length>0&&D.push(t.getConstLiteral(ht(T))),D),[]);b.length>0&&i.set("styles",_r(b))}else n.encapsulation===qd.Emulated&&(n.encapsulation=qd.None);n.encapsulation!==qd.Emulated&&i.set("encapsulation",ht(n.encapsulation)),null!==n.animations&&i.set("data",ql([{key:"animation",value:n.animations,quoted:!1}])),null!=l&&l!==cC.Default&&i.set("changeDetection",ht(l));let m=Tn(te.defineComponent).callFn([i.toLiteralMap()],void 0,!0),x=function(n){let t=OK(n);return t.push(PV(n.template.ngContentSelectors)),t.push(ul(ht(n.isStandalone))),ul(Tn(te.ComponentDeclaration,t))}(n);return{expression:m,type:x,statements:[]}}(i,r,DD(i.interpolation));return this.jitExpression(s.expression,t,e,r.statements)}compileFactory(t,e,i){let r=nm({name:i.name,type:As(i.type),internalType:new Ln(i.type),typeArgumentCount:i.typeArgumentCount,deps:(n=i.deps,null==n?null:n.map(LK)),target:i.target});var n;return this.jitExpression(r.expression,t,e,r.statements)}compileFactoryDeclaration(t,e,i){let r=nm({name:i.type.name,type:As(i.type),internalType:new Ln(i.type),typeArgumentCount:0,deps:Array.isArray(i.deps)?i.deps.map(PQ):i.deps,target:i.target});return this.jitExpression(r.expression,t,e,r.statements)}createParseSourceSpan(t,e,i){return function(n,t,e){let r=new pD("",`in ${n} ${t} in ${e}`);return new Go(new vm(r,-1,-1,-1),new vm(r,-1,-1,-1))}(t,e,i)}jitExpression(t,e,i,r){let o=[...r,new Vu("$def",t,void 0,ll.Exported)];return this.jitEvaluator.evaluateStatements(i,o,new class{constructor(t){this.context=t}resolveExternalReference(t){if("@angular/core"!==t.moduleName)throw new Error(`Cannot resolve external reference to ${t.moduleName}, only references to @angular/core are supported.`);if(!this.context.hasOwnProperty(t.name))throw new Error(`No value provided for @angular/core symbol '${t.name}'.`);return this.context[t.name]}}(e),!0).$def}};var OD=function(n,...t){if(OD.translate){let i=OD.translate(n,t);n=i[0],t=i[1]}let e=VK(n[0],n.raw[0]);for(let i=1;i<n.length;i++)e+=t[i-1]+VK(n[i],n.raw[i]);return e};function VK(n,t){return":"===t.charAt(0)?n.substring(function(n,t){for(let e=1,i=1;e<n.length;e++,i++)if("\\"===t[i])i++;else if(":"===n[e])return e;throw new Error(`Unterminated $localize metadata block in "${t}".`)}(n,t)+1):n}(()=>typeof globalThis<"u"&&globalThis||typeof global<"u"&&global||typeof window<"u"&&window||typeof self<"u"&&typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope&&self)().$localize=OD;var r5=null;function Yl(){return r5}var zD=class{},Ht=new pe("DocumentToken"),KK=(()=>{class n{historyGo(e){throw new Error("Not implemented")}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:function(){return j(ZK)},providedIn:"platform"}),n})();new pe("Location Initialized");var ZK=(()=>{class n extends KK{constructor(e){super(),this._doc=e,this._init()}_init(){this.location=window.location,this._history=window.history}getBaseHrefFromDOM(){return Yl().getBaseHref(this._doc)}onPopState(e){let i=Yl().getGlobalEventTarget(this._doc,"window");return i.addEventListener("popstate",e,!1),()=>i.removeEventListener("popstate",e)}onHashChange(e){let i=Yl().getGlobalEventTarget(this._doc,"window");return i.addEventListener("hashchange",e,!1),()=>i.removeEventListener("hashchange",e)}get href(){return this.location.href}get protocol(){return this.location.protocol}get hostname(){return this.location.hostname}get port(){return this.location.port}get pathname(){return this.location.pathname}get search(){return this.location.search}get hash(){return this.location.hash}set pathname(e){this.location.pathname=e}pushState(e,i,r){UK()?this._history.pushState(e,i,r):this.location.hash=r}replaceState(e,i,r){UK()?this._history.replaceState(e,i,r):this.location.hash=r}forward(){this._history.forward()}back(){this._history.back()}historyGo(e=0){this._history.go(e)}getState(){return this._history.state}}return n.\u0275fac=function(e){return new(e||n)(j(Ht))},n.\u0275prov=ye({token:n,factory:function(){return new ZK(j(Ht))},providedIn:"platform"}),n})();function UK(){return!!window.history.pushState}function JK(n,t){if(0==n.length)return t;if(0==t.length)return n;let e=0;return n.endsWith("/")&&e++,t.startsWith("/")&&e++,2==e?n+t.substring(1):1==e?n+t:n+"/"+t}function zK(n){let t=n.match(/#|\?|$/),e=t&&t.index||n.length;return n.slice(0,e-("/"===n[e-1]?1:0))+n.slice(e)}function Sm(n){return n&&"?"!==n[0]?"?"+n:n}var c5=(()=>{class n{historyGo(e){throw new Error("Not implemented")}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:function(){return jo(yTe)},providedIn:"root"}),n})(),vTe=new pe("appBaseHref"),yTe=(()=>{class n extends c5{constructor(e,i){super(),this._platformLocation=e,this._removeListenerFns=[],this._baseHref=i??this._platformLocation.getBaseHrefFromDOM()??jo(Ht).location?.origin??""}ngOnDestroy(){for(;this._removeListenerFns.length;)this._removeListenerFns.pop()()}onPopState(e){this._removeListenerFns.push(this._platformLocation.onPopState(e),this._platformLocation.onHashChange(e))}getBaseHref(){return this._baseHref}prepareExternalUrl(e){return JK(this._baseHref,e)}path(e=!1){let i=this._platformLocation.pathname+Sm(this._platformLocation.search),r=this._platformLocation.hash;return r&&e?`${i}${r}`:i}pushState(e,i,r,o){let s=this.prepareExternalUrl(r+Sm(o));this._platformLocation.pushState(e,i,s)}replaceState(e,i,r,o){let s=this.prepareExternalUrl(r+Sm(o));this._platformLocation.replaceState(e,i,s)}forward(){this._platformLocation.forward()}back(){this._platformLocation.back()}getState(){return this._platformLocation.getState()}historyGo(e=0){this._platformLocation.historyGo?.(e)}}return n.\u0275fac=function(e){return new(e||n)(j(KK),j(vTe,8))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),iM=(()=>{class n{constructor(e){this._subject=new G,this._urlChangeListeners=[],this._urlChangeSubscription=null,this._locationStrategy=e;let i=this._locationStrategy.getBaseHref();this._baseHref=zK(jK(i)),this._locationStrategy.onPopState(r=>{this._subject.emit({url:this.path(!0),pop:!0,state:r.state,type:r.type})})}ngOnDestroy(){this._urlChangeSubscription?.unsubscribe(),this._urlChangeListeners=[]}path(e=!1){return this.normalize(this._locationStrategy.path(e))}getState(){return this._locationStrategy.getState()}isCurrentPathEqualTo(e,i=""){return this.path()==this.normalize(e+Sm(i))}normalize(e){return n.stripTrailingSlash(function(n,t){return n&&t.startsWith(n)?t.substring(n.length):t}(this._baseHref,jK(e)))}prepareExternalUrl(e){return e&&"/"!==e[0]&&(e="/"+e),this._locationStrategy.prepareExternalUrl(e)}go(e,i="",r=null){this._locationStrategy.pushState(r,"",e,i),this._notifyUrlChangeListeners(this.prepareExternalUrl(e+Sm(i)),r)}replaceState(e,i="",r=null){this._locationStrategy.replaceState(r,"",e,i),this._notifyUrlChangeListeners(this.prepareExternalUrl(e+Sm(i)),r)}forward(){this._locationStrategy.forward()}back(){this._locationStrategy.back()}historyGo(e=0){this._locationStrategy.historyGo?.(e)}onUrlChange(e){return this._urlChangeListeners.push(e),this._urlChangeSubscription||(this._urlChangeSubscription=this.subscribe(i=>{this._notifyUrlChangeListeners(i.url,i.state)})),()=>{let i=this._urlChangeListeners.indexOf(e);this._urlChangeListeners.splice(i,1),0===this._urlChangeListeners.length&&(this._urlChangeSubscription?.unsubscribe(),this._urlChangeSubscription=null)}}_notifyUrlChangeListeners(e="",i){this._urlChangeListeners.forEach(r=>r(e,i))}subscribe(e,i,r){return this._subject.subscribe({next:e,error:i,complete:r})}}return n.normalizeQueryParams=Sm,n.joinWithSlash=JK,n.stripTrailingSlash=zK,n.\u0275fac=function(e){return new(e||n)(j(c5))},n.\u0275prov=ye({token:n,factory:function(){return new iM(j(c5))},providedIn:"root"}),n})();function jK(n){return n.replace(/\/index.html$/,"")}var HD=(()=>(function(n){n[n.Decimal=0]="Decimal",n[n.Percent=1]="Percent",n[n.Currency=2]="Currency",n[n.Scientific=3]="Scientific"}(HD||(HD={})),HD))(),ys=(()=>(function(n){n[n.Format=0]="Format",n[n.Standalone=1]="Standalone"}(ys||(ys={})),ys))(),or=(()=>(function(n){n[n.Narrow=0]="Narrow",n[n.Abbreviated=1]="Abbreviated",n[n.Wide=2]="Wide",n[n.Short=3]="Short"}(or||(or={})),or))(),oa=(()=>(function(n){n[n.Short=0]="Short",n[n.Medium=1]="Medium",n[n.Long=2]="Long",n[n.Full=3]="Full"}(oa||(oa={})),oa))(),Is=(()=>(function(n){n[n.Decimal=0]="Decimal",n[n.Group=1]="Group",n[n.List=2]="List",n[n.PercentSign=3]="PercentSign",n[n.PlusSign=4]="PlusSign",n[n.MinusSign=5]="MinusSign",n[n.Exponential=6]="Exponential",n[n.SuperscriptingExponent=7]="SuperscriptingExponent",n[n.PerMille=8]="PerMille",n[n.Infinity=9]="Infinity",n[n.NaN=10]="NaN",n[n.TimeSeparator=11]="TimeSeparator",n[n.CurrencyDecimal=12]="CurrencyDecimal",n[n.CurrencyGroup=13]="CurrencyGroup"}(Is||(Is={})),Is))();function kD(n,t){return Xl(Aa(n)[Rr.DateFormat],t)}function FD(n,t){return Xl(Aa(n)[Rr.TimeFormat],t)}function ND(n,t){return Xl(Aa(n)[Rr.DateTimeFormat],t)}function ep(n,t){let e=Aa(n),i=e[Rr.NumberSymbols][t];if(typeof i>"u"){if(t===Is.CurrencyDecimal)return e[Rr.NumberSymbols][Is.Decimal];if(t===Is.CurrencyGroup)return e[Rr.NumberSymbols][Is.Group]}return i}function $K(n){if(!n[Rr.ExtraData])throw new Error(`Missing extra locale data for the locale "${n[Rr.LocaleId]}". Use "registerLocaleData" to load new data. See the "I18n guide" on angular.io to know more.`)}function Xl(n,t){for(let e=t;e>-1;e--)if(typeof n[e]<"u")return n[e];throw new Error("Locale data API: locale data undefined")}function $V(n){let[t,e]=n.split(":");return{hours:+t,minutes:+e}}var ITe=/^(\d{4,})-?(\d\d)-?(\d\d)(?:T(\d\d)(?::?(\d\d)(?::?(\d\d)(?:\.(\d+))?)?)?(Z|([+-])(\d\d):?(\d\d))?)?$/,tM={},PTe=/((?:[^BEGHLMOSWYZabcdhmswyz']+)|(?:'(?:[^']|'')*')|(?:G{1,5}|y{1,4}|Y{1,4}|M{1,5}|L{1,5}|w{1,2}|W{1}|d{1,2}|E{1,6}|c{1,6}|a{1,5}|b{1,5}|B{1,5}|h{1,2}|H{1,2}|m{1,2}|s{1,2}|S{1,3}|z{1,4}|Z{1,5}|O{1,4}))([\s\S]*)/,Wc=(()=>(function(n){n[n.Short=0]="Short",n[n.ShortGMT=1]="ShortGMT",n[n.Long=2]="Long",n[n.Extended=3]="Extended"}(Wc||(Wc={})),Wc))(),Ui=(()=>(function(n){n[n.FullYear=0]="FullYear",n[n.Month=1]="Month",n[n.Date=2]="Date",n[n.Hours=3]="Hours",n[n.Minutes=4]="Minutes",n[n.Seconds=5]="Seconds",n[n.FractionalSeconds=6]="FractionalSeconds",n[n.Day=7]="Day"}(Ui||(Ui={})),Ui))(),Hi=(()=>(function(n){n[n.DayPeriods=0]="DayPeriods",n[n.Days=1]="Days",n[n.Months=2]="Months",n[n.Eras=3]="Eras"}(Hi||(Hi={})),Hi))();function RTe(n,t,e,i){let r=function(n){if(GK(n))return n;if("number"==typeof n&&!isNaN(n))return new Date(n);if("string"==typeof n){if(n=n.trim(),/^(\d{4}(-\d{1,2}(-\d{1,2})?)?)$/.test(n)){let[r,o=1,s=1]=n.split("-").map(a=>+a);return jD(r,o-1,s)}let i,e=parseFloat(n);if(!isNaN(n-e))return new Date(e);if(i=n.match(ITe))return function(n){let t=new Date(0),e=0,i=0,r=n[8]?t.setUTCFullYear:t.setFullYear,o=n[8]?t.setUTCHours:t.setHours;n[9]&&(e=Number(n[9]+n[10]),i=Number(n[9]+n[11])),r.call(t,Number(n[1]),Number(n[2])-1,Number(n[3]));let s=Number(n[4]||0)-e,a=Number(n[5]||0)-i,l=Number(n[6]||0),c=Math.floor(1e3*parseFloat("0."+(n[7]||0)));return o.call(t,s,a,l,c),t}(i)}let t=new Date(n);if(!GK(t))throw new Error(`Unable to convert "${n}" into a date`);return t}(n);t=$d(e,t)||t;let a,s=[];for(;t;){if(a=PTe.exec(t),!a){s.push(t);break}{s=s.concat(a.slice(1));let u=s.pop();if(!u)break;t=u}}let l=r.getTimezoneOffset();i&&(l=tZ(i,l),r=function(n,t,e){let r=n.getTimezoneOffset();return function(n,t){return(n=new Date(n.getTime())).setMinutes(n.getMinutes()+t),n}(n,-1*(tZ(t,r)-r))}(r,i));let c="";return s.forEach(u=>{let d=function(n){if(t5[n])return t5[n];let t;switch(n){case"G":case"GG":case"GGG":t=xr(Hi.Eras,or.Abbreviated);break;case"GGGG":t=xr(Hi.Eras,or.Wide);break;case"GGGGG":t=xr(Hi.Eras,or.Narrow);break;case"y":t=Io(Ui.FullYear,1,0,!1,!0);break;case"yy":t=Io(Ui.FullYear,2,0,!0,!0);break;case"yyy":t=Io(Ui.FullYear,3,0,!1,!0);break;case"yyyy":t=Io(Ui.FullYear,4,0,!1,!0);break;case"Y":t=VD(1);break;case"YY":t=VD(2,!0);break;case"YYY":t=VD(3);break;case"YYYY":t=VD(4);break;case"M":case"L":t=Io(Ui.Month,1,1);break;case"MM":case"LL":t=Io(Ui.Month,2,1);break;case"MMM":t=xr(Hi.Months,or.Abbreviated);break;case"MMMM":t=xr(Hi.Months,or.Wide);break;case"MMMMM":t=xr(Hi.Months,or.Narrow);break;case"LLL":t=xr(Hi.Months,or.Abbreviated,ys.Standalone);break;case"LLLL":t=xr(Hi.Months,or.Wide,ys.Standalone);break;case"LLLLL":t=xr(Hi.Months,or.Narrow,ys.Standalone);break;case"w":t=e5(1);break;case"ww":t=e5(2);break;case"W":t=e5(1,!0);break;case"d":t=Io(Ui.Date,1);break;case"dd":t=Io(Ui.Date,2);break;case"c":case"cc":t=Io(Ui.Day,1);break;case"ccc":t=xr(Hi.Days,or.Abbreviated,ys.Standalone);break;case"cccc":t=xr(Hi.Days,or.Wide,ys.Standalone);break;case"ccccc":t=xr(Hi.Days,or.Narrow,ys.Standalone);break;case"cccccc":t=xr(Hi.Days,or.Short,ys.Standalone);break;case"E":case"EE":case"EEE":t=xr(Hi.Days,or.Abbreviated);break;case"EEEE":t=xr(Hi.Days,or.Wide);break;case"EEEEE":t=xr(Hi.Days,or.Narrow);break;case"EEEEEE":t=xr(Hi.Days,or.Short);break;case"a":case"aa":case"aaa":t=xr(Hi.DayPeriods,or.Abbreviated);break;case"aaaa":t=xr(Hi.DayPeriods,or.Wide);break;case"aaaaa":t=xr(Hi.DayPeriods,or.Narrow);break;case"b":case"bb":case"bbb":t=xr(Hi.DayPeriods,or.Abbreviated,ys.Standalone,!0);break;case"bbbb":t=xr(Hi.DayPeriods,or.Wide,ys.Standalone,!0);break;case"bbbbb":t=xr(Hi.DayPeriods,or.Narrow,ys.Standalone,!0);break;case"B":case"BB":case"BBB":t=xr(Hi.DayPeriods,or.Abbreviated,ys.Format,!0);break;case"BBBB":t=xr(Hi.DayPeriods,or.Wide,ys.Format,!0);break;case"BBBBB":t=xr(Hi.DayPeriods,or.Narrow,ys.Format,!0);break;case"h":t=Io(Ui.Hours,1,-12);break;case"hh":t=Io(Ui.Hours,2,-12);break;case"H":t=Io(Ui.Hours,1);break;case"HH":t=Io(Ui.Hours,2);break;case"m":t=Io(Ui.Minutes,1);break;case"mm":t=Io(Ui.Minutes,2);break;case"s":t=Io(Ui.Seconds,1);break;case"ss":t=Io(Ui.Seconds,2);break;case"S":t=Io(Ui.FractionalSeconds,1);break;case"SS":t=Io(Ui.FractionalSeconds,2);break;case"SSS":t=Io(Ui.FractionalSeconds,3);break;case"Z":case"ZZ":case"ZZZ":t=BD(Wc.Short);break;case"ZZZZZ":t=BD(Wc.Extended);break;case"O":case"OO":case"OOO":case"z":case"zz":case"zzz":t=BD(Wc.ShortGMT);break;case"OOOO":case"ZZZZ":case"zzzz":t=BD(Wc.Long);break;default:return null}return t5[n]=t,t}(u);c+=d?d(r,e,l):"''"===u?"'":u.replace(/(^'|'$)/g,"").replace(/''/g,"'")}),c}function jD(n,t,e){let i=new Date(0);return i.setFullYear(n,t,e),i.setHours(0,0,0),i}function $d(n,t){let e=function(n){return Aa(n)[Rr.LocaleId]}(n);if(tM[e]=tM[e]||{},tM[e][t])return tM[e][t];let i="";switch(t){case"shortDate":i=kD(n,oa.Short);break;case"mediumDate":i=kD(n,oa.Medium);break;case"longDate":i=kD(n,oa.Long);break;case"fullDate":i=kD(n,oa.Full);break;case"shortTime":i=FD(n,oa.Short);break;case"mediumTime":i=FD(n,oa.Medium);break;case"longTime":i=FD(n,oa.Long);break;case"fullTime":i=FD(n,oa.Full);break;case"short":let r=$d(n,"shortTime"),o=$d(n,"shortDate");i=LD(ND(n,oa.Short),[r,o]);break;case"medium":let s=$d(n,"mediumTime"),a=$d(n,"mediumDate");i=LD(ND(n,oa.Medium),[s,a]);break;case"long":let l=$d(n,"longTime"),c=$d(n,"longDate");i=LD(ND(n,oa.Long),[l,c]);break;case"full":let u=$d(n,"fullTime"),d=$d(n,"fullDate");i=LD(ND(n,oa.Full),[u,d])}return i&&(tM[e][t]=i),i}function LD(n,t){return t&&(n=n.replace(/\{([^}]+)}/g,function(e,i){return null!=t&&i in t?t[i]:e})),n}function Gc(n,t,e="-",i,r){let o="";(n<0||r&&n<=0)&&(r?n=1-n:(n=-n,o=e));let s=String(n);for(;s.length<t;)s="0"+s;return i&&(s=s.slice(s.length-t)),o+s}function Io(n,t,e=0,i=!1,r=!1){return function(o,s){let a=function(n,t){switch(n){case Ui.FullYear:return t.getFullYear();case Ui.Month:return t.getMonth();case Ui.Date:return t.getDate();case Ui.Hours:return t.getHours();case Ui.Minutes:return t.getMinutes();case Ui.Seconds:return t.getSeconds();case Ui.FractionalSeconds:return t.getMilliseconds();case Ui.Day:return t.getDay();default:throw new Error(`Unknown DateType value "${n}".`)}}(n,o);if((e>0||a>-e)&&(a+=e),n===Ui.Hours)0===a&&-12===e&&(a=12);else if(n===Ui.FractionalSeconds)return function(n,t){return Gc(n,3).substring(0,t)}(a,t);let l=ep(s,Is.MinusSign);return Gc(a,t,l,i,r)}}function xr(n,t,e=ys.Format,i=!1){return function(r,o){return function(n,t,e,i,r,o){switch(e){case Hi.Months:return function(n,t,e){let i=Aa(n),o=Xl([i[Rr.MonthsFormat],i[Rr.MonthsStandalone]],t);return Xl(o,e)}(t,r,i)[n.getMonth()];case Hi.Days:return function(n,t,e){let i=Aa(n),o=Xl([i[Rr.DaysFormat],i[Rr.DaysStandalone]],t);return Xl(o,e)}(t,r,i)[n.getDay()];case Hi.DayPeriods:let s=n.getHours(),a=n.getMinutes();if(o){let c=function(n){let t=Aa(n);return $K(t),(t[Rr.ExtraData][2]||[]).map(i=>"string"==typeof i?$V(i):[$V(i[0]),$V(i[1])])}(t),u=function(n,t,e){let i=Aa(n);$K(i);let o=Xl([i[Rr.ExtraData][0],i[Rr.ExtraData][1]],t)||[];return Xl(o,e)||[]}(t,r,i),d=c.findIndex(p=>{if(Array.isArray(p)){let[h,f]=p,m=s>=h.hours&&a>=h.minutes,x=s<f.hours||s===f.hours&&a<f.minutes;if(h.hours<f.hours){if(m&&x)return!0}else if(m||x)return!0}else if(p.hours===s&&p.minutes===a)return!0;return!1});if(-1!==d)return u[d]}return function(n,t,e){let i=Aa(n),o=Xl([i[Rr.DayPeriodsFormat],i[Rr.DayPeriodsStandalone]],t);return Xl(o,e)}(t,r,i)[s<12?0:1];case Hi.Eras:return function(n,t){return Xl(Aa(n)[Rr.Eras],t)}(t,i)[n.getFullYear()<=0?0:1];default:throw new Error(`unexpected translation type ${e}`)}}(r,o,n,t,e,i)}}function BD(n){return function(t,e,i){let r=-1*i,o=ep(e,Is.MinusSign),s=r>0?Math.floor(r/60):Math.ceil(r/60);switch(n){case Wc.Short:return(r>=0?"+":"")+Gc(s,2,o)+Gc(Math.abs(r%60),2,o);case Wc.ShortGMT:return"GMT"+(r>=0?"+":"")+Gc(s,1,o);case Wc.Long:return"GMT"+(r>=0?"+":"")+Gc(s,2,o)+":"+Gc(Math.abs(r%60),2,o);case Wc.Extended:return 0===i?"Z":(r>=0?"+":"")+Gc(s,2,o)+":"+Gc(Math.abs(r%60),2,o);default:throw new Error(`Unknown zone width "${n}"`)}}}function eZ(n){return jD(n.getFullYear(),n.getMonth(),n.getDate()+(4-n.getDay()))}function e5(n,t=!1){return function(e,i){let r;if(t){let o=new Date(e.getFullYear(),e.getMonth(),1).getDay()-1,s=e.getDate();r=1+Math.floor((s+o)/7)}else{let o=eZ(e),s=function(n){let t=jD(n,0,1).getDay();return jD(n,0,1+(t<=4?4:11)-t)}(o.getFullYear()),a=o.getTime()-s.getTime();r=1+Math.round(a/6048e5)}return Gc(r,n,ep(i,Is.MinusSign))}}function VD(n,t=!1){return function(e,i){return Gc(eZ(e).getFullYear(),n,ep(i,Is.MinusSign),t)}}var t5={};function tZ(n,t){n=n.replace(/:/g,"");let e=Date.parse("Jan 01, 1970 00:00:00 "+n)/6e4;return isNaN(e)?t:e}function GK(n){return n instanceof Date&&!isNaN(n.valueOf())}var jTe=/^(\d+)?\.((\d+)(-(\d+))?)?$/;function u5(n,t,e){let i=function(n,t){return Aa(n)[Rr.NumberFormats][t]}(t,HD.Decimal),r=function(n,t="-"){let e={minInt:1,minFrac:0,maxFrac:0,posPre:"",posSuf:"",negPre:"",negSuf:"",gSize:0,lgSize:0},i=n.split(";"),r=i[0],o=i[1],s=-1!==r.indexOf(".")?r.split("."):[r.substring(0,r.lastIndexOf("0")+1),r.substring(r.lastIndexOf("0")+1)],a=s[0],l=s[1]||"";e.posPre=a.substring(0,a.indexOf("#"));for(let u=0;u<l.length;u++){let d=l.charAt(u);"0"===d?e.minFrac=e.maxFrac=u+1:"#"===d?e.maxFrac=u+1:e.posSuf+=d}let c=a.split(",");if(e.gSize=c[1]?c[1].length:0,e.lgSize=c[2]||c[1]?(c[2]||c[1]).length:0,o){let u=r.length-e.posPre.length-e.posSuf.length,d=o.indexOf("#");e.negPre=o.substring(0,d).replace(/'/g,""),e.negSuf=o.slice(d+u).replace(/'/g,"")}else e.negPre=t+e.posPre,e.negSuf=e.posSuf;return e}(i,ep(t,Is.MinusSign));return function(n,t,e,i,r,o,s=!1){let a="",l=!1;if(isFinite(n)){let c=function(n){let i,r,o,s,a,t=Math.abs(n)+"",e=0;for((r=t.indexOf("."))>-1&&(t=t.replace(".","")),(o=t.search(/e/i))>0?(r<0&&(r=o),r+=+t.slice(o+1),t=t.substring(0,o)):r<0&&(r=t.length),o=0;"0"===t.charAt(o);o++);if(o===(a=t.length))i=[0],r=1;else{for(a--;"0"===t.charAt(a);)a--;for(r-=o,i=[],s=0;o<=a;o++,s++)i[s]=Number(t.charAt(o))}return r>22&&(i=i.splice(0,21),e=r-1,r=1),{digits:i,exponent:e,integerLen:r}}(n);s&&(c=function(n){if(0===n.digits[0])return n;let t=n.digits.length-n.integerLen;return n.exponent?n.exponent+=2:(0===t?n.digits.push(0,0):1===t&&n.digits.push(0),n.integerLen+=2),n}(c));let u=t.minInt,d=t.minFrac,p=t.maxFrac;if(o){let b=o.match(jTe);if(null===b)throw new Error(`${o} is not a valid digit info`);let D=b[1],T=b[3],k=b[5];null!=D&&(u=i5(D)),null!=T&&(d=i5(T)),null!=k?p=i5(k):null!=T&&d>p&&(p=d)}!function(n,t,e){if(t>e)throw new Error(`The minimum number of digits after fraction (${t}) is higher than the maximum (${e}).`);let i=n.digits,r=i.length-n.integerLen,o=Math.min(Math.max(t,r),e),s=o+n.integerLen,a=i[s];if(s>0){i.splice(Math.max(n.integerLen,s));for(let d=s;d<i.length;d++)i[d]=0}else{r=Math.max(0,r),n.integerLen=1,i.length=Math.max(1,s=o+1),i[0]=0;for(let d=1;d<s;d++)i[d]=0}if(a>=5)if(s-1<0){for(let d=0;d>s;d--)i.unshift(0),n.integerLen++;i.unshift(1),n.integerLen++}else i[s-1]++;for(;r<Math.max(0,o);r++)i.push(0);let l=0!==o,c=t+n.integerLen,u=i.reduceRight(function(d,p,h,f){return f[h]=(p+=d)<10?p:p-10,l&&(0===f[h]&&h>=c?f.pop():l=!1),p>=10?1:0},0);u&&(i.unshift(u),n.integerLen++)}(c,d,p);let h=c.digits,f=c.integerLen,m=c.exponent,x=[];for(l=h.every(b=>!b);f<u;f++)h.unshift(0);for(;f<0;f++)h.unshift(0);f>0?x=h.splice(f,h.length):(x=h,h=[0]);let g=[];for(h.length>=t.lgSize&&g.unshift(h.splice(-t.lgSize,h.length).join(""));h.length>t.gSize;)g.unshift(h.splice(-t.gSize,h.length).join(""));h.length&&g.unshift(h.join("")),a=g.join(ep(e,i)),x.length&&(a+=ep(e,r)+x.join("")),m&&(a+=ep(e,Is.Exponential)+"+"+m)}else a=ep(e,Is.Infinity);return a=n<0&&!l?t.negPre+a+t.negSuf:t.posPre+a+t.posSuf,a}(n,r,t,Is.Group,Is.Decimal,e)}function i5(n){let t=parseInt(n);if(isNaN(t))throw new Error("Invalid integer literal when parsing "+n);return t}function qD(n,t){t=encodeURIComponent(t);for(let e of n.split(";")){let i=e.indexOf("="),[r,o]=-1==i?[e,""]:[e.slice(0,i),e.slice(i+1)];if(r.trim()===t)return decodeURIComponent(o)}return null}var Fn=(()=>{class n{constructor(e,i,r,o){this._iterableDiffers=e,this._keyValueDiffers=i,this._ngEl=r,this._renderer=o,this._iterableDiffer=null,this._keyValueDiffer=null,this._initialClasses=[],this._rawClass=null}set klass(e){this._removeClasses(this._initialClasses),this._initialClasses="string"==typeof e?e.split(/\s+/):[],this._applyClasses(this._initialClasses),this._applyClasses(this._rawClass)}set ngClass(e){this._removeClasses(this._rawClass),this._applyClasses(this._initialClasses),this._iterableDiffer=null,this._keyValueDiffer=null,this._rawClass="string"==typeof e?e.split(/\s+/):e,this._rawClass&&(wT(this._rawClass)?this._iterableDiffer=this._iterableDiffers.find(this._rawClass).create():this._keyValueDiffer=this._keyValueDiffers.find(this._rawClass).create())}ngDoCheck(){if(this._iterableDiffer){let e=this._iterableDiffer.diff(this._rawClass);e&&this._applyIterableChanges(e)}else if(this._keyValueDiffer){let e=this._keyValueDiffer.diff(this._rawClass);e&&this._applyKeyValueChanges(e)}}_applyKeyValueChanges(e){e.forEachAddedItem(i=>this._toggleClass(i.key,i.currentValue)),e.forEachChangedItem(i=>this._toggleClass(i.key,i.currentValue)),e.forEachRemovedItem(i=>{i.previousValue&&this._toggleClass(i.key,!1)})}_applyIterableChanges(e){e.forEachAddedItem(i=>{if("string"!=typeof i.item)throw new Error(`NgClass can only toggle CSS classes expressed as strings, got ${To(i.item)}`);this._toggleClass(i.item,!0)}),e.forEachRemovedItem(i=>this._toggleClass(i.item,!1))}_applyClasses(e){e&&(Array.isArray(e)||e instanceof Set?e.forEach(i=>this._toggleClass(i,!0)):Object.keys(e).forEach(i=>this._toggleClass(i,!!e[i])))}_removeClasses(e){e&&(Array.isArray(e)||e instanceof Set?e.forEach(i=>this._toggleClass(i,!1)):Object.keys(e).forEach(i=>this._toggleClass(i,!1)))}_toggleClass(e,i){(e=e.trim())&&e.split(/\s+/g).forEach(r=>{i?this._renderer.addClass(this._ngEl.nativeElement,r):this._renderer.removeClass(this._ngEl.nativeElement,r)})}}return n.\u0275fac=function(e){return new(e||n)(M(kc),M(nC),M(Re),M(Eu))},n.\u0275dir=He({type:n,selectors:[["","ngClass",""]],inputs:{klass:["class","klass"],ngClass:"ngClass"},standalone:!0}),n})(),dn=(()=>{class n{constructor(e,i,r){this._viewContainer=e,this._template=i,this._differs=r,this._ngForOf=null,this._ngForOfDirty=!0,this._differ=null}set ngForOf(e){this._ngForOf=e,this._ngForOfDirty=!0}set ngForTrackBy(e){this._trackByFn=e}get ngForTrackBy(){return this._trackByFn}set ngForTemplate(e){e&&(this._template=e)}ngDoCheck(){if(this._ngForOfDirty){this._ngForOfDirty=!1;let e=this._ngForOf;!this._differ&&e&&(this._differ=this._differs.find(e).create(this.ngForTrackBy))}if(this._differ){let e=this._differ.diff(this._ngForOf);e&&this._applyChanges(e)}}_applyChanges(e){let i=this._viewContainer;e.forEachOperation((r,o,s)=>{if(null==r.previousIndex)i.createEmbeddedView(this._template,new class{constructor(t,e,i,r){this.$implicit=t,this.ngForOf=e,this.index=i,this.count=r}get first(){return 0===this.index}get last(){return this.index===this.count-1}get even(){return this.index%2==0}get odd(){return!this.even}}(r.item,this._ngForOf,-1,-1),null===s?void 0:s);else if(null==s)i.remove(null===o?void 0:o);else if(null!==o){let a=i.get(o);i.move(a,s),YK(a,r)}});for(let r=0,o=i.length;r<o;r++){let a=i.get(r).context;a.index=r,a.count=o,a.ngForOf=this._ngForOf}e.forEachIdentityChange(r=>{YK(i.get(r.currentIndex),r)})}static ngTemplateContextGuard(e,i){return!0}}return n.\u0275fac=function(e){return new(e||n)(M(Oi),M(Vi),M(kc))},n.\u0275dir=He({type:n,selectors:[["","ngFor","","ngForOf",""]],inputs:{ngForOf:"ngForOf",ngForTrackBy:"ngForTrackBy",ngForTemplate:"ngForTemplate"},standalone:!0}),n})();function YK(n,t){n.context.$implicit=t.item}var Be=(()=>{class n{constructor(e,i){this._viewContainer=e,this._context=new s5,this._thenTemplateRef=null,this._elseTemplateRef=null,this._thenViewRef=null,this._elseViewRef=null,this._thenTemplateRef=i}set ngIf(e){this._context.$implicit=this._context.ngIf=e,this._updateView()}set ngIfThen(e){XK("ngIfThen",e),this._thenTemplateRef=e,this._thenViewRef=null,this._updateView()}set ngIfElse(e){XK("ngIfElse",e),this._elseTemplateRef=e,this._elseViewRef=null,this._updateView()}_updateView(){this._context.$implicit?this._thenViewRef||(this._viewContainer.clear(),this._elseViewRef=null,this._thenTemplateRef&&(this._thenViewRef=this._viewContainer.createEmbeddedView(this._thenTemplateRef,this._context))):this._elseViewRef||(this._viewContainer.clear(),this._thenViewRef=null,this._elseTemplateRef&&(this._elseViewRef=this._viewContainer.createEmbeddedView(this._elseTemplateRef,this._context)))}static ngTemplateContextGuard(e,i){return!0}}return n.\u0275fac=function(e){return new(e||n)(M(Oi),M(Vi))},n.\u0275dir=He({type:n,selectors:[["","ngIf",""]],inputs:{ngIf:"ngIf",ngIfThen:"ngIfThen",ngIfElse:"ngIfElse"},standalone:!0}),n})(),s5=class{constructor(){this.$implicit=null,this.ngIf=null}};function XK(n,t){if(t&&!t.createEmbeddedView)throw new Error(`${n} must be a TemplateRef, but received '${To(t)}'.`)}var WD=class{constructor(t,e){this._viewContainerRef=t,this._templateRef=e,this._created=!1}create(){this._created=!0,this._viewContainerRef.createEmbeddedView(this._templateRef)}destroy(){this._created=!1,this._viewContainerRef.clear()}enforceState(t){t&&!this._created?this.create():!t&&this._created&&this.destroy()}},Cr=(()=>{class n{constructor(){this._defaultUsed=!1,this._caseCount=0,this._lastCaseCheckIndex=0,this._lastCasesMatched=!1}set ngSwitch(e){this._ngSwitch=e,0===this._caseCount&&this._updateDefaultCases(!0)}_addCase(){return this._caseCount++}_addDefault(e){this._defaultViews||(this._defaultViews=[]),this._defaultViews.push(e)}_matchCase(e){let i=e==this._ngSwitch;return this._lastCasesMatched=this._lastCasesMatched||i,this._lastCaseCheckIndex++,this._lastCaseCheckIndex===this._caseCount&&(this._updateDefaultCases(!this._lastCasesMatched),this._lastCaseCheckIndex=0,this._lastCasesMatched=!1),i}_updateDefaultCases(e){if(this._defaultViews&&e!==this._defaultUsed){this._defaultUsed=e;for(let i=0;i<this._defaultViews.length;i++)this._defaultViews[i].enforceState(e)}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=He({type:n,selectors:[["","ngSwitch",""]],inputs:{ngSwitch:"ngSwitch"},standalone:!0}),n})(),Ur=(()=>{class n{constructor(e,i,r){this.ngSwitch=r,r._addCase(),this._view=new WD(e,i)}ngDoCheck(){this._view.enforceState(this.ngSwitch._matchCase(this.ngSwitchCase))}}return n.\u0275fac=function(e){return new(e||n)(M(Oi),M(Vi),M(Cr,9))},n.\u0275dir=He({type:n,selectors:[["","ngSwitchCase",""]],inputs:{ngSwitchCase:"ngSwitchCase"},standalone:!0}),n})(),ch=(()=>{class n{constructor(e,i,r){r._addDefault(new WD(e,i))}}return n.\u0275fac=function(e){return new(e||n)(M(Oi),M(Vi),M(Cr,9))},n.\u0275dir=He({type:n,selectors:[["","ngSwitchDefault",""]],standalone:!0}),n})(),zu=(()=>{class n{constructor(e,i,r){this._ngEl=e,this._differs=i,this._renderer=r,this._ngStyle=null,this._differ=null}set ngStyle(e){this._ngStyle=e,!this._differ&&e&&(this._differ=this._differs.find(e).create())}ngDoCheck(){if(this._differ){let e=this._differ.diff(this._ngStyle);e&&this._applyChanges(e)}}_setStyle(e,i){let[r,o]=e.split("."),s=-1===r.indexOf("-")?void 0:Bl.DashCase;null!=i?this._renderer.setStyle(this._ngEl.nativeElement,r,o?`${i}${o}`:i,s):this._renderer.removeStyle(this._ngEl.nativeElement,r,s)}_applyChanges(e){e.forEachRemovedItem(i=>this._setStyle(i.key,null)),e.forEachAddedItem(i=>this._setStyle(i.key,i.currentValue)),e.forEachChangedItem(i=>this._setStyle(i.key,i.currentValue))}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(nC),M(Eu))},n.\u0275dir=He({type:n,selectors:[["","ngStyle",""]],inputs:{ngStyle:"ngStyle"},standalone:!0}),n})(),os=(()=>{class n{constructor(e){this._viewContainerRef=e,this._viewRef=null,this.ngTemplateOutletContext=null,this.ngTemplateOutlet=null,this.ngTemplateOutletInjector=null}ngOnChanges(e){if(e.ngTemplateOutlet||e.ngTemplateOutletInjector){let i=this._viewContainerRef;if(this._viewRef&&i.remove(i.indexOf(this._viewRef)),this.ngTemplateOutlet){let{ngTemplateOutlet:r,ngTemplateOutletContext:o,ngTemplateOutletInjector:s}=this;this._viewRef=i.createEmbeddedView(r,o,s?{injector:s}:void 0)}else this._viewRef=null}else this._viewRef&&e.ngTemplateOutletContext&&this.ngTemplateOutletContext&&(this._viewRef.context=this.ngTemplateOutletContext)}}return n.\u0275fac=function(e){return new(e||n)(M(Oi))},n.\u0275dir=He({type:n,selectors:[["","ngTemplateOutlet",""]],inputs:{ngTemplateOutletContext:"ngTemplateOutletContext",ngTemplateOutlet:"ngTemplateOutlet",ngTemplateOutletInjector:"ngTemplateOutletInjector"},standalone:!0,features:[Ft]}),n})();function YD(n,t){return new At(2100,!1)}var JTe=new class{createSubscription(t,e){return t.then(e,i=>{throw i})}dispose(t){}},$Te=new class{createSubscription(t,e){return t.subscribe({next:e,error:i=>{throw i}})}dispose(t){t.unsubscribe()}},Ge=(()=>{class n{constructor(e){this._latestValue=null,this._subscription=null,this._obj=null,this._strategy=null,this._ref=e}ngOnDestroy(){this._subscription&&this._dispose(),this._ref=null}transform(e){return this._obj?e!==this._obj?(this._dispose(),this.transform(e)):this._latestValue:(e&&this._subscribe(e),this._latestValue)}_subscribe(e){this._obj=e,this._strategy=this._selectStrategy(e),this._subscription=this._strategy.createSubscription(e,i=>this._updateLatestValue(e,i))}_selectStrategy(e){if(n_(e))return JTe;if(X3(e))return $Te;throw YD()}_dispose(){this._strategy.dispose(this._subscription),this._latestValue=null,this._subscription=null,this._obj=null}_updateLatestValue(e,i){e===this._obj&&(this._latestValue=i,this._ref.markForCheck())}}return n.\u0275fac=function(e){return new(e||n)(M(nn,16))},n.\u0275pipe=B0({name:"async",type:n,pure:!1,standalone:!0}),n})(),eDe=new pe("DATE_PIPE_DEFAULT_TIMEZONE"),U_=(()=>{class n{constructor(e,i){this.locale=e,this.defaultTimezone=i}transform(e,i="mediumDate",r,o){if(null==e||""===e||e!=e)return null;try{return RTe(e,i,o||this.locale,r??this.defaultTimezone??void 0)}catch(s){throw YD()}}}return n.\u0275fac=function(e){return new(e||n)(M(Wd,16),M(eDe,24))},n.\u0275pipe=B0({name:"date",type:n,pure:!0,standalone:!0}),n})(),Ql=(()=>{class n{constructor(e){this._locale=e}transform(e,i,r){if(!function(n){return!(null==n||""===n||n!=n)}(e))return null;r=r||this._locale;try{let o=function(n){if("string"==typeof n&&!isNaN(Number(n)-parseFloat(n)))return Number(n);if("number"!=typeof n)throw new Error(`${n} is not a number`);return n}(e);return u5(o,r,i)}catch(o){throw YD()}}}return n.\u0275fac=function(e){return new(e||n)(M(Wd,16))},n.\u0275pipe=B0({name:"number",type:n,pure:!0,standalone:!0}),n})(),nZ=(()=>{class n{transform(e,i,r){if(null==e)return null;if(!this.supports(e))throw YD();return e.slice(i,r)}supports(e){return"string"==typeof e||Array.isArray(e)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275pipe=B0({name:"slice",type:n,pure:!1,standalone:!0}),n})(),Me=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),d5="browser";function XD(n){return n===d5}new Ic("14.2.11");var Em=class{};function sDe(n){return n.startsWith("/")?n.slice(1):n}new pe("PRECONNECT_CHECK_BLOCKLIST");var aDe=n=>n.src,lDe=new pe("ImageLoader",{providedIn:"root",factory:()=>aDe});function QD(n,t){return function(i,r={ensurePreconnect:!0}){return function(n){if("string"!=typeof n||""===n.trim())return!1;try{return new URL(n),!0}catch{return!1}}(i)||function(n,t){throw new At(2959,!1)}(),i=function(n){return n.endsWith("/")?n.slice(0,-1):n}(i),[{provide:lDe,useValue:a=>(function(n){return/^https?:\/\//.test(n)}(a.src)&&function(n,t){throw new At(2959,!1)}(),n(i,{...a,src:sDe(a.src)}))}]}}QD(function(n,t){let e="format=auto";return t.width&&(e+=`,width=${t.width}`),`${n}/cdn-cgi/image/${e}/${t.src}`}),QD(function(n,t){let e="f_auto,q_auto";return t.width&&(e+=`,w_${t.width}`),`${n}/image/upload/${e}/${t.src}`}),QD(function(n,t){let e="tr:q-auto";return t.width&&(e+=`,w-${t.width}`),`${n}/${e}/${t.src}`}),QD(function(n,t){let e=new URL(`${n}/${t.src}`);return e.searchParams.set("auto","format"),t.width&&e.searchParams.set("w",t.width.toString()),e.href});var KD,h5=class extends zD{constructor(){super(...arguments),this.supportsDOMEvents=!0}},aM=class extends h5{static makeCurrent(){!function(n){r5||(r5=n)}(new aM)}onAndCancel(t,e,i){return t.addEventListener(e,i,!1),()=>{t.removeEventListener(e,i,!1)}}dispatchEvent(t,e){t.dispatchEvent(e)}remove(t){t.parentNode&&t.parentNode.removeChild(t)}createElement(t,e){return(e=e||this.getDefaultDocument()).createElement(t)}createHtmlDocument(){return document.implementation.createHTMLDocument("fakeTitle")}getDefaultDocument(){return document}isElementNode(t){return t.nodeType===Node.ELEMENT_NODE}isShadowRoot(t){return t instanceof DocumentFragment}getGlobalEventTarget(t,e){return"window"===e?window:"document"===e?t:"body"===e?t.body:null}getBaseHref(t){let e=(rM=rM||document.querySelector("base"))?rM.getAttribute("href"):null;return null==e?null:function(n){(KD=KD||document.createElement("a")).setAttribute("href",n);let t=KD.pathname;return"/"===t.charAt(0)?t:`/${t}`}(e)}resetBaseElement(){rM=null}getUserAgent(){return window.navigator.userAgent}getCookie(t){return qD(document.cookie,t)}},rM=null,cZ=new pe("TRANSITION_ID"),yDe=[{provide:$3,useFactory:function(n,t,e){return()=>{e.get(OT).donePromise.then(()=>{let i=Yl(),r=t.querySelectorAll(`style[ng-transition="${n}"]`);for(let o=0;o<r.length;o++)i.remove(r[o])})}},deps:[cZ,Ht,Xn],multi:!0}],bDe=(()=>{class n{build(){return new XMLHttpRequest}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),ZD=new pe("EventManagerPlugins"),JD=(()=>{class n{constructor(e,i){this._zone=i,this._eventNameToPlugin=new Map,e.forEach(r=>r.manager=this),this._plugins=e.slice().reverse()}addEventListener(e,i,r){return this._findPluginFor(i).addEventListener(e,i,r)}addGlobalEventListener(e,i,r){return this._findPluginFor(i).addGlobalEventListener(e,i,r)}getZone(){return this._zone}_findPluginFor(e){let i=this._eventNameToPlugin.get(e);if(i)return i;let r=this._plugins;for(let o=0;o<r.length;o++){let s=r[o];if(s.supports(e))return this._eventNameToPlugin.set(e,s),s}throw new Error(`No event manager plugin found for event ${e}`)}}return n.\u0275fac=function(e){return new(e||n)(j(ZD),j(_t))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),$D=class{constructor(t){this._doc=t}addGlobalEventListener(t,e,i){let r=Yl().getGlobalEventTarget(this._doc,t);if(!r)throw new Error(`Unsupported event target ${r} for event ${e}`);return this.addEventListener(r,e,i)}},uZ=(()=>{class n{constructor(){this._stylesSet=new Set}addStyles(e){let i=new Set;e.forEach(r=>{this._stylesSet.has(r)||(this._stylesSet.add(r),i.add(r))}),this.onStylesAdded(i)}onStylesAdded(e){}getAllStyles(){return Array.from(this._stylesSet)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),oM=(()=>{class n extends uZ{constructor(e){super(),this._doc=e,this._hostNodes=new Map,this._hostNodes.set(e.head,[])}_addStylesToHost(e,i,r){e.forEach(o=>{let s=this._doc.createElement("style");s.textContent=o,r.push(i.appendChild(s))})}addHost(e){let i=[];this._addStylesToHost(this._stylesSet,e,i),this._hostNodes.set(e,i)}removeHost(e){let i=this._hostNodes.get(e);i&&i.forEach(iZ),this._hostNodes.delete(e)}onStylesAdded(e){this._hostNodes.forEach((i,r)=>{this._addStylesToHost(e,r,i)})}ngOnDestroy(){this._hostNodes.forEach(e=>e.forEach(iZ))}}return n.\u0275fac=function(e){return new(e||n)(j(Ht))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})();function iZ(n){Yl().remove(n)}var p5={svg:"http://www.w3.org/2000/svg",xhtml:"http://www.w3.org/1999/xhtml",xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/",math:"http://www.w3.org/1998/MathML/"},_5=/%COMP%/g;function eA(n,t,e){for(let i=0;i<t.length;i++){let r=t[i];Array.isArray(r)?eA(n,r,e):(r=r.replace(_5,n),e.push(r))}return e}function oZ(n){return t=>{if("__ngUnwrap__"===t)return n;!1===n(t)&&(t.preventDefault(),t.returnValue=!1)}}var sM=(()=>{class n{constructor(e,i,r){this.eventManager=e,this.sharedStylesHost=i,this.appId=r,this.rendererByCompId=new Map,this.defaultRenderer=new lM(e)}createRenderer(e,i){if(!e||!i)return this.defaultRenderer;switch(i.encapsulation){case Ja.Emulated:{let r=this.rendererByCompId.get(i.id);return r||(r=new m5(this.eventManager,this.sharedStylesHost,i,this.appId),this.rendererByCompId.set(i.id,r)),r.applyToHost(e),r}case 1:case Ja.ShadowDom:return new g5(this.eventManager,this.sharedStylesHost,e,i);default:if(!this.rendererByCompId.has(i.id)){let r=eA(i.id,i.styles,[]);this.sharedStylesHost.addStyles(r),this.rendererByCompId.set(i.id,this.defaultRenderer)}return this.defaultRenderer}}begin(){}end(){}}return n.\u0275fac=function(e){return new(e||n)(j(JD),j(oM),j($f))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),lM=class{constructor(t){this.eventManager=t,this.data=Object.create(null),this.destroyNode=null}destroy(){}createElement(t,e){return e?document.createElementNS(p5[e]||e,t):document.createElement(t)}createComment(t){return document.createComment(t)}createText(t){return document.createTextNode(t)}appendChild(t,e){(aZ(t)?t.content:t).appendChild(e)}insertBefore(t,e,i){t&&(aZ(t)?t.content:t).insertBefore(e,i)}removeChild(t,e){t&&t.removeChild(e)}selectRootElement(t,e){let i="string"==typeof t?document.querySelector(t):t;if(!i)throw new Error(`The selector "${t}" did not match any elements`);return e||(i.textContent=""),i}parentNode(t){return t.parentNode}nextSibling(t){return t.nextSibling}setAttribute(t,e,i,r){if(r){e=r+":"+e;let o=p5[r];o?t.setAttributeNS(o,e,i):t.setAttribute(e,i)}else t.setAttribute(e,i)}removeAttribute(t,e,i){if(i){let r=p5[i];r?t.removeAttributeNS(r,e):t.removeAttribute(`${i}:${e}`)}else t.removeAttribute(e)}addClass(t,e){t.classList.add(e)}removeClass(t,e){t.classList.remove(e)}setStyle(t,e,i,r){r&(Bl.DashCase|Bl.Important)?t.style.setProperty(e,i,r&Bl.Important?"important":""):t.style[e]=i}removeStyle(t,e,i){i&Bl.DashCase?t.style.removeProperty(e):t.style[e]=""}setProperty(t,e,i){t[e]=i}setValue(t,e){t.nodeValue=e}listen(t,e,i){return"string"==typeof t?this.eventManager.addGlobalEventListener(t,e,oZ(i)):this.eventManager.addEventListener(t,e,oZ(i))}};function aZ(n){return"TEMPLATE"===n.tagName&&void 0!==n.content}"@".charCodeAt(0);var m5=class extends lM{constructor(t,e,i,r){super(t),this.component=i;let o=eA(r+"-"+i.id,i.styles,[]);e.addStyles(o),this.contentAttr=function(n){return"_ngcontent-%COMP%".replace(_5,n)}(r+"-"+i.id),this.hostAttr=function(n){return"_nghost-%COMP%".replace(_5,n)}(r+"-"+i.id)}applyToHost(t){super.setAttribute(t,this.hostAttr,"")}createElement(t,e){let i=super.createElement(t,e);return super.setAttribute(i,this.contentAttr,""),i}},g5=class extends lM{constructor(t,e,i,r){super(t),this.sharedStylesHost=e,this.hostEl=i,this.shadowRoot=i.attachShadow({mode:"open"}),this.sharedStylesHost.addHost(this.shadowRoot);let o=eA(r.id,r.styles,[]);for(let s=0;s<o.length;s++){let a=document.createElement("style");a.textContent=o[s],this.shadowRoot.appendChild(a)}}nodeOrShadowRoot(t){return t===this.hostEl?this.shadowRoot:t}destroy(){this.sharedStylesHost.removeHost(this.shadowRoot)}appendChild(t,e){return super.appendChild(this.nodeOrShadowRoot(t),e)}insertBefore(t,e,i){return super.insertBefore(this.nodeOrShadowRoot(t),e,i)}removeChild(t,e){return super.removeChild(this.nodeOrShadowRoot(t),e)}parentNode(t){return this.nodeOrShadowRoot(super.parentNode(this.nodeOrShadowRoot(t)))}},EDe=(()=>{class n extends $D{constructor(e){super(e)}supports(e){return!0}addEventListener(e,i,r){return e.addEventListener(i,r,!1),()=>this.removeEventListener(e,i,r)}removeEventListener(e,i,r){return e.removeEventListener(i,r)}}return n.\u0275fac=function(e){return new(e||n)(j(Ht))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),lZ=["alt","control","meta","shift"],TDe={"\b":"Backspace","\t":"Tab","\x7f":"Delete","\x1b":"Escape",Del:"Delete",Esc:"Escape",Left:"ArrowLeft",Right:"ArrowRight",Up:"ArrowUp",Down:"ArrowDown",Menu:"ContextMenu",Scroll:"ScrollLock",Win:"OS"},DDe={alt:n=>n.altKey,control:n=>n.ctrlKey,meta:n=>n.metaKey,shift:n=>n.shiftKey},ADe=(()=>{class n extends $D{constructor(e){super(e)}supports(e){return null!=n.parseEventName(e)}addEventListener(e,i,r){let o=n.parseEventName(i),s=n.eventCallback(o.fullKey,r,this.manager.getZone());return this.manager.getZone().runOutsideAngular(()=>Yl().onAndCancel(e,o.domEventName,s))}static parseEventName(e){let i=e.toLowerCase().split("."),r=i.shift();if(0===i.length||"keydown"!==r&&"keyup"!==r)return null;let o=n._normalizeKey(i.pop()),s="",a=i.indexOf("code");if(a>-1&&(i.splice(a,1),s="code."),lZ.forEach(c=>{let u=i.indexOf(c);u>-1&&(i.splice(u,1),s+=c+".")}),s+=o,0!=i.length||0===o.length)return null;let l={};return l.domEventName=r,l.fullKey=s,l}static matchEventFullKeyCode(e,i){let r=TDe[e.key]||e.key,o="";return i.indexOf("code.")>-1&&(r=e.code,o="code."),!(null==r||!r)&&(r=r.toLowerCase()," "===r?r="space":"."===r&&(r="dot"),lZ.forEach(s=>{s!==r&&(0,DDe[s])(e)&&(o+=s+".")}),o+=r,o===i)}static eventCallback(e,i,r){return o=>{n.matchEventFullKeyCode(o,e)&&r.runGuarded(()=>i(o))}}static _normalizeKey(e){return"esc"===e?"escape":e}}return n.\u0275fac=function(e){return new(e||n)(j(Ht))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),ODe=[{provide:Gd,useValue:d5},{provide:eB,useValue:function(){aM.makeCurrent()},multi:!0},{provide:Ht,useFactory:function(){return function(n){pL=n}(document),document},deps:[]}],y5=rB(cX,"browser",ODe),pZ=new pe(""),kDe=[{provide:eC,useClass:class{addToWindow(t){to.getAngularTestability=(i,r=!0)=>{let o=t.findTestabilityInTree(i,r);if(null==o)throw new Error("Could not find testability for element.");return o},to.getAllAngularTestabilities=()=>t.getAllTestabilities(),to.getAllAngularRootElements=()=>t.getAllRootElements(),to.frameworkStabilizers||(to.frameworkStabilizers=[]),to.frameworkStabilizers.push(i=>{let r=to.getAllAngularTestabilities(),o=r.length,s=!1,a=function(l){s=s||l,o--,0==o&&i(s)};r.forEach(function(l){l.whenStable(a)})})}findTestabilityInTree(t,e,i){return null==e?null:t.getTestability(e)??(i?Yl().isShadowRoot(e)?this.findTestabilityInTree(t,e.host,!0):this.findTestabilityInTree(t,e.parentElement,!0):null)}},deps:[]},{provide:nB,useClass:kT,deps:[_t,FT,eC]},{provide:kT,useClass:kT,deps:[_t,FT,eC]}],FDe=[{provide:gT,useValue:"root"},{provide:Qs,useFactory:function(){return new Qs},deps:[]},{provide:ZD,useClass:EDe,multi:!0,deps:[Ht,_t,Gd]},{provide:ZD,useClass:ADe,multi:!0,deps:[Ht]},{provide:sM,useClass:sM,deps:[JD,oM,$f]},{provide:wu,useExisting:sM},{provide:uZ,useExisting:oM},{provide:oM,useClass:oM,deps:[Ht]},{provide:JD,useClass:JD,deps:[ZD,_t]},{provide:Em,useClass:bDe,deps:[]},[]],tA=(()=>{class n{constructor(e){}static withServerTransition(e){return{ngModule:n,providers:[{provide:$f,useValue:e.appId},{provide:cZ,useExisting:$f},yDe]}}}return n.\u0275fac=function(e){return new(e||n)(j(pZ,12))},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[...FDe,...kDe],imports:[Me,uX]}),n})(),Tm=(new pe("HammerGestureConfig"),new pe("HammerLoader"),(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:function(e){let i=null;return i=e?new(e||n):j(hZ),i},providedIn:"root"}),n})()),hZ=(()=>{class n extends Tm{constructor(e){super(),this._doc=e}sanitize(e,i){if(null==i)return null;switch(e){case mo.NONE:return i;case mo.HTML:return Pc(i,"HTML")?Ta(i):D3(this._doc,String(i)).toString();case mo.STYLE:return Pc(i,"Style")?Ta(i):i;case mo.SCRIPT:if(Pc(i,"Script"))return Ta(i);throw new Error("unsafe value used in a script context");case mo.URL:return Pc(i,"URL")?Ta(i):zx(String(i));case mo.RESOURCE_URL:if(Pc(i,"ResourceURL"))return Ta(i);throw new Error("unsafe value used in a resource URL context (see https://g.co/ng/security#xss)");default:throw new Error(`Unexpected SecurityContext ${e} (see https://g.co/ng/security#xss)`)}}bypassSecurityTrustHtml(e){return function(n){return new hL(n)}(e)}bypassSecurityTrustStyle(e){return function(n){return new fL(n)}(e)}bypassSecurityTrustScript(e){return function(n){return new mL(n)}(e)}bypassSecurityTrustUrl(e){return function(n){return new gL(n)}(e)}bypassSecurityTrustResourceUrl(e){return function(n){return new _L(n)}(e)}}return n.\u0275fac=function(e){return new(e||n)(j(Ht))},n.\u0275prov=ye({token:n,factory:function(e){let i=null;return i=e?new e:function(n){return new hZ(n.get(Ht))}(j(Xn)),i},providedIn:"root"}),n})(),cM=(new Ic("14.2.11"),oN(mZ(),1),class{}),nA=class{},ju="*";function Kr(n,t){return{type:7,name:n,definitions:t,options:{}}}function ji(n,t=null){return{type:4,styles:t,timings:n}}function x5(n,t=null){return{type:3,steps:n,options:t}}function iA(n,t=null){return{type:2,steps:n,options:t}}function gn(n){return{type:6,styles:n,offset:null}}function ki(n,t,e){return{type:0,name:n,styles:t,options:e}}function Dm(n){return{type:5,steps:n}}function Li(n,t,e=null){return{type:1,expr:n,animation:t,options:e}}function Am(n=null){return{type:9,options:n}}function Im(n,t,e=null){return{type:11,selector:n,animation:t,options:e}}function gZ(n){Promise.resolve().then(n)}var dh=class{constructor(t=0,e=0){this._onDoneFns=[],this._onStartFns=[],this._onDestroyFns=[],this._originalOnDoneFns=[],this._originalOnStartFns=[],this._started=!1,this._destroyed=!1,this._finished=!1,this._position=0,this.parentPlayer=null,this.totalTime=t+e}_onFinish(){this._finished||(this._finished=!0,this._onDoneFns.forEach(t=>t()),this._onDoneFns=[])}onStart(t){this._originalOnStartFns.push(t),this._onStartFns.push(t)}onDone(t){this._originalOnDoneFns.push(t),this._onDoneFns.push(t)}onDestroy(t){this._onDestroyFns.push(t)}hasStarted(){return this._started}init(){}play(){this.hasStarted()||(this._onStart(),this.triggerMicrotask()),this._started=!0}triggerMicrotask(){gZ(()=>this._onFinish())}_onStart(){this._onStartFns.forEach(t=>t()),this._onStartFns=[]}pause(){}restart(){}finish(){this._onFinish()}destroy(){this._destroyed||(this._destroyed=!0,this.hasStarted()||this._onStart(),this.finish(),this._onDestroyFns.forEach(t=>t()),this._onDestroyFns=[])}reset(){this._started=!1,this._finished=!1,this._onStartFns=this._originalOnStartFns,this._onDoneFns=this._originalOnDoneFns}setPosition(t){this._position=this.totalTime?t*this.totalTime:1}getPosition(){return this.totalTime?this._position/this.totalTime:1}triggerCallback(t){let e="start"==t?this._onStartFns:this._onDoneFns;e.forEach(i=>i()),e.length=0}},uM=class{constructor(t){this._onDoneFns=[],this._onStartFns=[],this._finished=!1,this._started=!1,this._destroyed=!1,this._onDestroyFns=[],this.parentPlayer=null,this.totalTime=0,this.players=t;let e=0,i=0,r=0,o=this.players.length;0==o?gZ(()=>this._onFinish()):this.players.forEach(s=>{s.onDone(()=>{++e==o&&this._onFinish()}),s.onDestroy(()=>{++i==o&&this._onDestroy()}),s.onStart(()=>{++r==o&&this._onStart()})}),this.totalTime=this.players.reduce((s,a)=>Math.max(s,a.totalTime),0)}_onFinish(){this._finished||(this._finished=!0,this._onDoneFns.forEach(t=>t()),this._onDoneFns=[])}init(){this.players.forEach(t=>t.init())}onStart(t){this._onStartFns.push(t)}_onStart(){this.hasStarted()||(this._started=!0,this._onStartFns.forEach(t=>t()),this._onStartFns=[])}onDone(t){this._onDoneFns.push(t)}onDestroy(t){this._onDestroyFns.push(t)}hasStarted(){return this._started}play(){this.parentPlayer||this.init(),this._onStart(),this.players.forEach(t=>t.play())}pause(){this.players.forEach(t=>t.pause())}restart(){this.players.forEach(t=>t.restart())}finish(){this._onFinish(),this.players.forEach(t=>t.finish())}destroy(){this._onDestroy()}_onDestroy(){this._destroyed||(this._destroyed=!0,this._onFinish(),this.players.forEach(t=>t.destroy()),this._onDestroyFns.forEach(t=>t()),this._onDestroyFns=[])}reset(){this.players.forEach(t=>t.reset()),this._destroyed=!1,this._finished=!1,this._started=!1}setPosition(t){let e=t*this.totalTime;this.players.forEach(i=>{let r=i.totalTime?Math.min(1,e/i.totalTime):1;i.setPosition(r)})}getPosition(){let t=this.players.reduce((e,i)=>null===e||i.totalTime>e.totalTime?i:e,null);return null!=t?t.getPosition():0}beforeDestroy(){this.players.forEach(t=>{t.beforeDestroy&&t.beforeDestroy()})}triggerCallback(t){let e="start"==t?this._onStartFns:this._onDoneFns;e.forEach(i=>i()),e.length=0}};function _Z(n){return new At(3e3,!1)}function z5(){return typeof process<"u"&&"[object process]"==={}.toString.call(process)}function ph(n){switch(n.length){case 0:return new dh;case 1:return n[0];default:return new uM(n)}}function RZ(n,t,e,i,r=new Map,o=new Map){let s=[],a=[],l=-1,c=null;if(i.forEach(u=>{let d=u.get("offset"),p=d==l,h=p&&c||new Map;u.forEach((f,m)=>{let x=m,g=f;if("offset"!==m)switch(x=t.normalizePropertyName(x,s),g){case"!":g=r.get(m);break;case ju:g=o.get(m);break;default:g=t.normalizeStyleValue(m,x,g,s)}h.set(x,g)}),p||a.push(h),c=h,l=d}),s.length)throw new At(3502,!1);return a}function j5(n,t,e,i){switch(t){case"start":n.onStart(()=>i(e&&C5(e,"start",n)));break;case"done":n.onDone(()=>i(e&&C5(e,"done",n)));break;case"destroy":n.onDestroy(()=>i(e&&C5(e,"destroy",n)))}}function C5(n,t,e){let o=G5(n.element,n.triggerName,n.fromState,n.toState,t||n.phaseName,e.totalTime??n.totalTime,!!e.disabled),s=n._data;return null!=s&&(o._data=s),o}function G5(n,t,e,i,r="",o=0,s){return{element:n,triggerName:t,fromState:e,toState:i,phaseName:r,totalTime:o,disabled:!!s}}function pl(n,t,e){let i=n.get(t);return i||n.set(t,i=e),i}function vZ(n){let t=n.indexOf(":");return[n.substring(1,t),n.slice(t+1)]}var D5=(n,t)=>!1,OZ=(n,t,e)=>[],kZ=null;function W5(n){let t=n.parentNode||n.host;return t===kZ?null:t}(z5()||typeof Element<"u")&&(typeof window<"u"&&typeof window.document<"u"?(kZ=(()=>document.documentElement)(),D5=(n,t)=>{for(;t;){if(t===n)return!0;t=W5(t)}return!1}):D5=(n,t)=>n.contains(t),OZ=(n,t,e)=>{if(e)return Array.from(n.querySelectorAll(t));let i=n.querySelector(t);return i?[i]:[]});var Pm=null,yZ=!1;var FZ=D5,NZ=OZ,q5=(()=>{class n{validateStyleProperty(e){return function(n){Pm||(Pm=(typeof document<"u"?document.body:null)||{},yZ=!!Pm.style&&"WebkitAppearance"in Pm.style);let t=!0;return Pm.style&&!function(n){return"ebkit"==n.substring(1,6)}(n)&&(t=n in Pm.style,!t&&yZ&&(t="Webkit"+n.charAt(0).toUpperCase()+n.slice(1)in Pm.style)),t}(e)}matchesElement(e,i){return!1}containsElement(e,i){return FZ(e,i)}getParentElement(e){return W5(e)}query(e,i,r){return NZ(e,i,r)}computeStyle(e,i,r){return r||""}animate(e,i,r,o,s,a=[],l){return new dh(r,o)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),vM=(()=>{class n{}return n.NOOP=new q5,n})(),BZ="ng-enter",A5="ng-leave",oA="ng-trigger",cA=".ng-trigger",bZ="ng-animating",I5=".ng-animating";function tp(n){if("number"==typeof n)return n;let t=n.match(/^(-?[\.\d]+)(m?s)/);return!t||t.length<2?0:P5(parseFloat(t[1]),t[2])}function P5(n,t){return"s"===t?1e3*n:n}function uA(n,t,e){return n.hasOwnProperty("duration")?n:function(n,t,e){let r,o=0,s="";if("string"==typeof n){let a=n.match(/^(-?[\.\d]+)(m?s)(?:\s+(-?[\.\d]+)(m?s))?(?:\s+([-a-z]+(?:\(.+?\))?))?$/i);if(null===a)return t.push(_Z()),{duration:0,delay:0,easing:""};r=P5(parseFloat(a[1]),a[2]);let l=a[3];null!=l&&(o=P5(parseFloat(l),a[4]));let c=a[5];c&&(s=c)}else r=n;if(!e){let a=!1,l=t.length;r<0&&(t.push(new At(3100,!1)),a=!0),o<0&&(t.push(new At(3101,!1)),a=!0),a&&t.splice(l,0,_Z())}return{duration:r,delay:o,easing:s}}(n,t,e)}function yM(n,t={}){return Object.keys(n).forEach(e=>{t[e]=n[e]}),t}function VZ(n){let t=new Map;return Object.keys(n).forEach(e=>{t.set(e,n[e])}),t}function j_(n,t=new Map,e){if(e)for(let[i,r]of e)t.set(i,r);for(let[i,r]of n)t.set(i,r);return t}function xZ(n,t,e){return e?t+":"+e+";":""}function HZ(n){let t="";for(let e=0;e<n.style.length;e++){let i=n.style.item(e);t+=xZ(0,i,n.style.getPropertyValue(i))}for(let e in n.style)n.style.hasOwnProperty(e)&&!e.startsWith("_")&&(t+=xZ(0,SAe(e),n.style[e]));n.setAttribute("style",t)}function Gu(n,t,e){n.style&&(t.forEach((i,r)=>{let o=Y5(r);e&&!e.has(r)&&e.set(r,n.style[o]),n.style[o]=i}),z5()&&HZ(n))}function Om(n,t){n.style&&(t.forEach((e,i)=>{let r=Y5(i);n.style[r]=""}),z5()&&HZ(n))}function dM(n){return Array.isArray(n)?1==n.length?n[0]:iA(n):n}var R5=new RegExp("{{\\s*(.+?)\\s*}}","g");function UZ(n){let t=[];if("string"==typeof n){let e;for(;e=R5.exec(n);)t.push(e[1]);R5.lastIndex=0}return t}function hM(n,t,e){let i=n.toString(),r=i.replace(R5,(o,s)=>{let a=t[s];return null==a&&(e.push(new At(3003,!1)),a=""),a.toString()});return r==i?n:r}function dA(n){let t=[],e=n.next();for(;!e.done;)t.push(e.value),e=n.next();return t}var wAe=/-+([a-z0-9])/g;function Y5(n){return n.replace(wAe,(...t)=>t[1].toUpperCase())}function SAe(n){return n.replace(/([a-z])([A-Z])/g,"$1-$2").toLowerCase()}function dl(n,t,e){switch(t.type){case 7:return n.visitTrigger(t,e);case 0:return n.visitState(t,e);case 1:return n.visitTransition(t,e);case 2:return n.visitSequence(t,e);case 3:return n.visitGroup(t,e);case 4:return n.visitAnimate(t,e);case 5:return n.visitKeyframes(t,e);case 6:return n.visitStyle(t,e);case 8:return n.visitReference(t,e);case 9:return n.visitAnimateChild(t,e);case 10:return n.visitAnimateRef(t,e);case 11:return n.visitQuery(t,e);case 12:return n.visitStagger(t,e);default:throw new At(3004,!1)}}function zZ(n,t){return window.getComputedStyle(n)[t]}function IAe(n,t){let e=[];return"string"==typeof n?n.split(/\s*,\s*/).forEach(i=>function(n,t,e){if(":"==n[0]){let l=function(n,t){switch(n){case":enter":return"void => *";case":leave":return"* => void";case":increment":return(e,i)=>parseFloat(i)>parseFloat(e);case":decrement":return(e,i)=>parseFloat(i)<parseFloat(e);default:return t.push(new At(3016,!1)),"* => *"}}(n,e);if("function"==typeof l)return void t.push(l);n=l}let i=n.match(/^(\*|[-\w]+)\s*(<?[=-]>)\s*(\*|[-\w]+)$/);if(null==i||i.length<4)return e.push(new At(3015,!1)),t;let r=i[1],o=i[2],s=i[3];t.push(CZ(r,s)),"<"==o[0]&&!("*"==r&&"*"==s)&&t.push(CZ(s,r))}(i,e,t)):e.push(n),e}var sA=new Set(["true","1"]),aA=new Set(["false","0"]);function CZ(n,t){let e=sA.has(n)||aA.has(n),i=sA.has(t)||aA.has(t);return(r,o)=>{let s="*"==n||n==r,a="*"==t||t==o;return!s&&e&&"boolean"==typeof r&&(s=r?sA.has(n):aA.has(n)),!a&&i&&"boolean"==typeof o&&(a=o?sA.has(t):aA.has(t)),s&&a}}var OAe=new RegExp("s*:selfs*,?","g");function qZ(n,t,e,i){return new O5(n).build(t,e,i)}var O5=class{constructor(t){this._driver=t}build(t,e,i){let r=new k5(e);return this._resetContextStyleTimingState(r),dl(this,dM(t),r)}_resetContextStyleTimingState(t){t.currentQuerySelector="",t.collectedStyles=new Map,t.collectedStyles.set("",new Map),t.currentTime=0}visitTrigger(t,e){let i=e.queryCount=0,r=e.depCount=0,o=[],s=[];return"@"==t.name.charAt(0)&&e.errors.push(new At(3006,!1)),t.definitions.forEach(a=>{if(this._resetContextStyleTimingState(e),0==a.type){let l=a,c=l.name;c.toString().split(/\s*,\s*/).forEach(u=>{l.name=u,o.push(this.visitState(l,e))}),l.name=c}else if(1==a.type){let l=this.visitTransition(a,e);i+=l.queryCount,r+=l.depCount,s.push(l)}else e.errors.push(new At(3007,!1))}),{type:7,name:t.name,states:o,transitions:s,queryCount:i,depCount:r,options:null}}visitState(t,e){let i=this.visitStyle(t.styles,e),r=t.options&&t.options.params||null;if(i.containsDynamicStyles){let o=new Set,s=r||{};i.styles.forEach(a=>{a instanceof Map&&a.forEach(l=>{UZ(l).forEach(c=>{s.hasOwnProperty(c)||o.add(c)})})}),o.size&&(dA(o.values()),e.errors.push(new At(3008,!1)))}return{type:0,name:t.name,style:i,options:r?{params:r}:null}}visitTransition(t,e){e.queryCount=0,e.depCount=0;let i=dl(this,dM(t.animation),e);return{type:1,matchers:IAe(t.expr,e.errors),animation:i,queryCount:e.queryCount,depCount:e.depCount,options:Rm(t.options)}}visitSequence(t,e){return{type:2,steps:t.steps.map(i=>dl(this,i,e)),options:Rm(t.options)}}visitGroup(t,e){let i=e.currentTime,r=0,o=t.steps.map(s=>{e.currentTime=i;let a=dl(this,s,e);return r=Math.max(r,e.currentTime),a});return e.currentTime=r,{type:3,steps:o,options:Rm(t.options)}}visitAnimate(t,e){let i=function(n,t){if(n.hasOwnProperty("duration"))return n;if("number"==typeof n)return M5(uA(n,t).duration,0,"");let e=n;if(e.split(/\s+/).some(o=>"{"==o.charAt(0)&&"{"==o.charAt(1))){let o=M5(0,0,"");return o.dynamic=!0,o.strValue=e,o}let r=uA(e,t);return M5(r.duration,r.delay,r.easing)}(t.timings,e.errors);e.currentAnimateTimings=i;let r,o=t.styles?t.styles:gn({});if(5==o.type)r=this.visitKeyframes(o,e);else{let s=t.styles,a=!1;if(!s){a=!0;let c={};i.easing&&(c.easing=i.easing),s=gn(c)}e.currentTime+=i.duration+i.delay;let l=this.visitStyle(s,e);l.isEmptyStep=a,r=l}return e.currentAnimateTimings=null,{type:4,timings:i,style:r,options:null}}visitStyle(t,e){let i=this._makeStyleAst(t,e);return this._validateStyleAst(i,e),i}_makeStyleAst(t,e){let i=[],r=Array.isArray(t.styles)?t.styles:[t.styles];for(let a of r)"string"==typeof a?a===ju?i.push(a):e.errors.push(new At(3002,!1)):i.push(VZ(a));let o=!1,s=null;return i.forEach(a=>{if(a instanceof Map&&(a.has("easing")&&(s=a.get("easing"),a.delete("easing")),!o))for(let l of a.values())if(l.toString().indexOf("{{")>=0){o=!0;break}}),{type:6,styles:i,easing:s,offset:t.offset,containsDynamicStyles:o,options:null}}_validateStyleAst(t,e){let i=e.currentAnimateTimings,r=e.currentTime,o=e.currentTime;i&&o>0&&(o-=i.duration+i.delay),t.styles.forEach(s=>{"string"!=typeof s&&s.forEach((a,l)=>{let c=e.collectedStyles.get(e.currentQuerySelector),u=c.get(l),d=!0;u&&(o!=r&&o>=u.startTime&&r<=u.endTime&&(e.errors.push(new At(3010,!1)),d=!1),o=u.startTime),d&&c.set(l,{startTime:o,endTime:r}),e.options&&function(n,t,e){let i=t.params||{},r=UZ(n);r.length&&r.forEach(o=>{i.hasOwnProperty(o)||e.push(new At(3001,!1))})}(a,e.options,e.errors)})})}visitKeyframes(t,e){let i={type:5,styles:[],options:null};if(!e.currentAnimateTimings)return e.errors.push(new At(3011,!1)),i;let o=0,s=[],a=!1,l=!1,c=0,u=t.steps.map(g=>{let b=this._makeStyleAst(g,e),D=null!=b.offset?b.offset:function(n){if("string"==typeof n)return null;let t=null;if(Array.isArray(n))n.forEach(e=>{if(e instanceof Map&&e.has("offset")){let i=e;t=parseFloat(i.get("offset")),i.delete("offset")}});else if(n instanceof Map&&n.has("offset")){let e=n;t=parseFloat(e.get("offset")),e.delete("offset")}return t}(b.styles),T=0;return null!=D&&(o++,T=b.offset=D),l=l||T<0||T>1,a=a||T<c,c=T,s.push(T),b});l&&e.errors.push(new At(3012,!1)),a&&e.errors.push(new At(3200,!1));let d=t.steps.length,p=0;o>0&&o<d?e.errors.push(new At(3202,!1)):0==o&&(p=1/(d-1));let h=d-1,f=e.currentTime,m=e.currentAnimateTimings,x=m.duration;return u.forEach((g,b)=>{let D=p>0?b==h?1:p*b:s[b],T=D*x;e.currentTime=f+m.delay+T,m.duration=T,this._validateStyleAst(g,e),g.offset=D,i.styles.push(g)}),i}visitReference(t,e){return{type:8,animation:dl(this,dM(t.animation),e),options:Rm(t.options)}}visitAnimateChild(t,e){return e.depCount++,{type:9,options:Rm(t.options)}}visitAnimateRef(t,e){return{type:10,animation:this.visitReference(t.animation,e),options:Rm(t.options)}}visitQuery(t,e){let i=e.currentQuerySelector,r=t.options||{};e.queryCount++,e.currentQuery=t;let[o,s]=function(n){let t=!!n.split(/\s*,\s*/).find(e=>":self"==e);return t&&(n=n.replace(OAe,"")),n=n.replace(/@\*/g,cA).replace(/@\w+/g,e=>cA+"-"+e.slice(1)).replace(/:animating/g,I5),[n,t]}(t.selector);e.currentQuerySelector=i.length?i+" "+o:o,pl(e.collectedStyles,e.currentQuerySelector,new Map);let a=dl(this,dM(t.animation),e);return e.currentQuery=null,e.currentQuerySelector=i,{type:11,selector:o,limit:r.limit||0,optional:!!r.optional,includeSelf:s,animation:a,originalSelector:t.selector,options:Rm(t.options)}}visitStagger(t,e){e.currentQuery||e.errors.push(new At(3013,!1));let i="full"===t.timings?{duration:0,delay:0,easing:"full"}:uA(t.timings,e.errors,!0);return{type:12,animation:dl(this,dM(t.animation),e),timings:i,options:null}}},k5=class{constructor(t){this.errors=t,this.queryCount=0,this.depCount=0,this.currentTransition=null,this.currentQuery=null,this.currentQuerySelector=null,this.currentAnimateTimings=null,this.currentTime=0,this.collectedStyles=new Map,this.options=null,this.unsupportedCSSPropertiesFound=new Set}};function Rm(n){return n?(n=yM(n)).params&&(n.params=function(n){return n?yM(n):null}(n.params)):n={},n}function M5(n,t,e){return{duration:n,delay:t,easing:e}}function X5(n,t,e,i,r,o,s=null,a=!1){return{type:1,element:n,keyframes:t,preStyleProps:e,postStyleProps:i,duration:r,delay:o,totalTime:r+o,easing:s,subTimeline:a}}var fM=class{constructor(){this._map=new Map}get(t){return this._map.get(t)||[]}append(t,e){let i=this._map.get(t);i||this._map.set(t,i=[]),i.push(...e)}has(t){return this._map.has(t)}clear(){this._map.clear()}},HAe=new RegExp(":enter","g"),zAe=new RegExp(":leave","g");function YZ(n,t,e,i,r,o=new Map,s=new Map,a,l,c=[]){return(new F5).buildKeyframes(n,t,e,i,r,o,s,a,l,c)}var F5=class{buildKeyframes(t,e,i,r,o,s,a,l,c,u=[]){c=c||new fM;let d=new mM(t,e,c,r,o,u,[]);d.options=l;let p=l.delay?tp(l.delay):0;d.currentTimeline.delayNextStep(p),d.currentTimeline.setStyles([s],null,d.errors,l),dl(this,i,d);let h=d.timelines.filter(f=>f.containsAnimation());if(h.length&&a.size){let f;for(let m=h.length-1;m>=0;m--){let x=h[m];if(x.element===e){f=x;break}}f&&!f.allowOnlyTimelineStyles()&&f.setStyles([a],null,d.errors,l)}return h.length?h.map(f=>f.buildKeyframes()):[X5(e,[],[],[],0,p,"",!1)]}visitTrigger(t,e){}visitState(t,e){}visitTransition(t,e){}visitAnimateChild(t,e){let i=e.subInstructions.get(e.element);if(i){let r=e.createSubContext(t.options),o=e.currentTimeline.currentTime,s=this._visitSubInstructions(i,r,r.options);o!=s&&e.transformIntoNewTimeline(s)}e.previousNode=t}visitAnimateRef(t,e){let i=e.createSubContext(t.options);i.transformIntoNewTimeline(),this._applyAnimationRefDelays([t.options,t.animation.options],e,i),this.visitReference(t.animation,i),e.transformIntoNewTimeline(i.currentTimeline.currentTime),e.previousNode=t}_applyAnimationRefDelays(t,e,i){for(let r of t){let o=r?.delay;if(o){let s="number"==typeof o?o:tp(hM(o,r?.params??{},e.errors));i.delayNextStep(s)}}}_visitSubInstructions(t,e,i){let o=e.currentTimeline.currentTime,s=null!=i.duration?tp(i.duration):null,a=null!=i.delay?tp(i.delay):null;return 0!==s&&t.forEach(l=>{let c=e.appendInstructionToTimeline(l,s,a);o=Math.max(o,c.duration+c.delay)}),o}visitReference(t,e){e.updateOptions(t.options,!0),dl(this,t.animation,e),e.previousNode=t}visitSequence(t,e){let i=e.subContextCount,r=e,o=t.options;if(o&&(o.params||o.delay)&&(r=e.createSubContext(o),r.transformIntoNewTimeline(),null!=o.delay)){6==r.previousNode.type&&(r.currentTimeline.snapshotCurrentStyles(),r.previousNode=hA);let s=tp(o.delay);r.delayNextStep(s)}t.steps.length&&(t.steps.forEach(s=>dl(this,s,r)),r.currentTimeline.applyStylesToKeyframe(),r.subContextCount>i&&r.transformIntoNewTimeline()),e.previousNode=t}visitGroup(t,e){let i=[],r=e.currentTimeline.currentTime,o=t.options&&t.options.delay?tp(t.options.delay):0;t.steps.forEach(s=>{let a=e.createSubContext(t.options);o&&a.delayNextStep(o),dl(this,s,a),r=Math.max(r,a.currentTimeline.currentTime),i.push(a.currentTimeline)}),i.forEach(s=>e.currentTimeline.mergeTimelineCollectedStyles(s)),e.transformIntoNewTimeline(r),e.previousNode=t}_visitTiming(t,e){if(t.dynamic){let i=t.strValue;return uA(e.params?hM(i,e.params,e.errors):i,e.errors)}return{duration:t.duration,delay:t.delay,easing:t.easing}}visitAnimate(t,e){let i=e.currentAnimateTimings=this._visitTiming(t.timings,e),r=e.currentTimeline;i.delay&&(e.incrementTime(i.delay),r.snapshotCurrentStyles());let o=t.style;5==o.type?this.visitKeyframes(o,e):(e.incrementTime(i.duration),this.visitStyle(o,e),r.applyStylesToKeyframe()),e.currentAnimateTimings=null,e.previousNode=t}visitStyle(t,e){let i=e.currentTimeline,r=e.currentAnimateTimings;!r&&i.hasCurrentStyleProperties()&&i.forwardFrame();let o=r&&r.easing||t.easing;t.isEmptyStep?i.applyEmptyStep(o):i.setStyles(t.styles,o,e.errors,e.options),e.previousNode=t}visitKeyframes(t,e){let i=e.currentAnimateTimings,r=e.currentTimeline.duration,o=i.duration,a=e.createSubContext().currentTimeline;a.easing=i.easing,t.styles.forEach(l=>{a.forwardTime((l.offset||0)*o),a.setStyles(l.styles,l.easing,e.errors,e.options),a.applyStylesToKeyframe()}),e.currentTimeline.mergeTimelineCollectedStyles(a),e.transformIntoNewTimeline(r+o),e.previousNode=t}visitQuery(t,e){let i=e.currentTimeline.currentTime,r=t.options||{},o=r.delay?tp(r.delay):0;o&&(6===e.previousNode.type||0==i&&e.currentTimeline.hasCurrentStyleProperties())&&(e.currentTimeline.snapshotCurrentStyles(),e.previousNode=hA);let s=i,a=e.invokeQuery(t.selector,t.originalSelector,t.limit,t.includeSelf,!!r.optional,e.errors);e.currentQueryTotal=a.length;let l=null;a.forEach((c,u)=>{e.currentQueryIndex=u;let d=e.createSubContext(t.options,c);o&&d.delayNextStep(o),c===e.element&&(l=d.currentTimeline),dl(this,t.animation,d),d.currentTimeline.applyStylesToKeyframe(),s=Math.max(s,d.currentTimeline.currentTime)}),e.currentQueryIndex=0,e.currentQueryTotal=0,e.transformIntoNewTimeline(s),l&&(e.currentTimeline.mergeTimelineCollectedStyles(l),e.currentTimeline.snapshotCurrentStyles()),e.previousNode=t}visitStagger(t,e){let i=e.parentContext,r=e.currentTimeline,o=t.timings,s=Math.abs(o.duration),a=s*(e.currentQueryTotal-1),l=s*e.currentQueryIndex;switch(o.duration<0?"reverse":o.easing){case"reverse":l=a-l;break;case"full":l=i.currentStaggerTime}let u=e.currentTimeline;l&&u.delayNextStep(l);let d=u.currentTime;dl(this,t.animation,e),e.previousNode=t,i.currentStaggerTime=r.currentTime-d+(r.startTime-i.currentTimeline.startTime)}},hA={},mM=class{constructor(t,e,i,r,o,s,a,l){this._driver=t,this.element=e,this.subInstructions=i,this._enterClassName=r,this._leaveClassName=o,this.errors=s,this.timelines=a,this.parentContext=null,this.currentAnimateTimings=null,this.previousNode=hA,this.subContextCount=0,this.options={},this.currentQueryIndex=0,this.currentQueryTotal=0,this.currentStaggerTime=0,this.currentTimeline=l||new G_(this._driver,e,0),a.push(this.currentTimeline)}get params(){return this.options.params}updateOptions(t,e){if(!t)return;let i=t,r=this.options;null!=i.duration&&(r.duration=tp(i.duration)),null!=i.delay&&(r.delay=tp(i.delay));let o=i.params;if(o){let s=r.params;s||(s=this.options.params={}),Object.keys(o).forEach(a=>{(!e||!s.hasOwnProperty(a))&&(s[a]=hM(o[a],s,this.errors))})}}_copyOptions(){let t={};if(this.options){let e=this.options.params;if(e){let i=t.params={};Object.keys(e).forEach(r=>{i[r]=e[r]})}}return t}createSubContext(t=null,e,i){let r=e||this.element,o=new mM(this._driver,r,this.subInstructions,this._enterClassName,this._leaveClassName,this.errors,this.timelines,this.currentTimeline.fork(r,i||0));return o.previousNode=this.previousNode,o.currentAnimateTimings=this.currentAnimateTimings,o.options=this._copyOptions(),o.updateOptions(t),o.currentQueryIndex=this.currentQueryIndex,o.currentQueryTotal=this.currentQueryTotal,o.parentContext=this,this.subContextCount++,o}transformIntoNewTimeline(t){return this.previousNode=hA,this.currentTimeline=this.currentTimeline.fork(this.element,t),this.timelines.push(this.currentTimeline),this.currentTimeline}appendInstructionToTimeline(t,e,i){let r={duration:e??t.duration,delay:this.currentTimeline.currentTime+(i??0)+t.delay,easing:""},o=new N5(this._driver,t.element,t.keyframes,t.preStyleProps,t.postStyleProps,r,t.stretchStartingKeyframe);return this.timelines.push(o),r}incrementTime(t){this.currentTimeline.forwardTime(this.currentTimeline.duration+t)}delayNextStep(t){t>0&&this.currentTimeline.delayNextStep(t)}invokeQuery(t,e,i,r,o,s){let a=[];if(r&&a.push(this.element),t.length>0){t=(t=t.replace(HAe,"."+this._enterClassName)).replace(zAe,"."+this._leaveClassName);let c=this._driver.query(this.element,t,1!=i);0!==i&&(c=i<0?c.slice(c.length+i,c.length):c.slice(0,i)),a.push(...c)}return!o&&0==a.length&&s.push(new At(3014,!1)),a}},G_=class{constructor(t,e,i,r){this._driver=t,this.element=e,this.startTime=i,this._elementTimelineStylesLookup=r,this.duration=0,this._previousKeyframe=new Map,this._currentKeyframe=new Map,this._keyframes=new Map,this._styleSummary=new Map,this._localTimelineStyles=new Map,this._pendingStyles=new Map,this._backFill=new Map,this._currentEmptyStepKeyframe=null,this._elementTimelineStylesLookup||(this._elementTimelineStylesLookup=new Map),this._globalTimelineStyles=this._elementTimelineStylesLookup.get(e),this._globalTimelineStyles||(this._globalTimelineStyles=this._localTimelineStyles,this._elementTimelineStylesLookup.set(e,this._localTimelineStyles)),this._loadKeyframe()}containsAnimation(){switch(this._keyframes.size){case 0:return!1;case 1:return this.hasCurrentStyleProperties();default:return!0}}hasCurrentStyleProperties(){return this._currentKeyframe.size>0}get currentTime(){return this.startTime+this.duration}delayNextStep(t){let e=1===this._keyframes.size&&this._pendingStyles.size;this.duration||e?(this.forwardTime(this.currentTime+t),e&&this.snapshotCurrentStyles()):this.startTime+=t}fork(t,e){return this.applyStylesToKeyframe(),new G_(this._driver,t,e||this.currentTime,this._elementTimelineStylesLookup)}_loadKeyframe(){this._currentKeyframe&&(this._previousKeyframe=this._currentKeyframe),this._currentKeyframe=this._keyframes.get(this.duration),this._currentKeyframe||(this._currentKeyframe=new Map,this._keyframes.set(this.duration,this._currentKeyframe))}forwardFrame(){this.duration+=1,this._loadKeyframe()}forwardTime(t){this.applyStylesToKeyframe(),this.duration=t,this._loadKeyframe()}_updateStyle(t,e){this._localTimelineStyles.set(t,e),this._globalTimelineStyles.set(t,e),this._styleSummary.set(t,{time:this.currentTime,value:e})}allowOnlyTimelineStyles(){return this._currentEmptyStepKeyframe!==this._currentKeyframe}applyEmptyStep(t){t&&this._previousKeyframe.set("easing",t);for(let[e,i]of this._globalTimelineStyles)this._backFill.set(e,i||ju),this._currentKeyframe.set(e,ju);this._currentEmptyStepKeyframe=this._currentKeyframe}setStyles(t,e,i,r){e&&this._previousKeyframe.set("easing",e);let o=r&&r.params||{},s=function(n,t){let i,e=new Map;return n.forEach(r=>{if("*"===r){i=i||t.keys();for(let o of i)e.set(o,ju)}else j_(r,e)}),e}(t,this._globalTimelineStyles);for(let[a,l]of s){let c=hM(l,o,i);this._pendingStyles.set(a,c),this._localTimelineStyles.has(a)||this._backFill.set(a,this._globalTimelineStyles.get(a)??ju),this._updateStyle(a,c)}}applyStylesToKeyframe(){0!=this._pendingStyles.size&&(this._pendingStyles.forEach((t,e)=>{this._currentKeyframe.set(e,t)}),this._pendingStyles.clear(),this._localTimelineStyles.forEach((t,e)=>{this._currentKeyframe.has(e)||this._currentKeyframe.set(e,t)}))}snapshotCurrentStyles(){for(let[t,e]of this._localTimelineStyles)this._pendingStyles.set(t,e),this._updateStyle(t,e)}getFinalKeyframe(){return this._keyframes.get(this.duration)}get properties(){let t=[];for(let e in this._currentKeyframe)t.push(e);return t}mergeTimelineCollectedStyles(t){t._styleSummary.forEach((e,i)=>{let r=this._styleSummary.get(i);(!r||e.time>r.time)&&this._updateStyle(i,e.value)})}buildKeyframes(){this.applyStylesToKeyframe();let t=new Set,e=new Set,i=1===this._keyframes.size&&0===this.duration,r=[];this._keyframes.forEach((a,l)=>{let c=j_(a,new Map,this._backFill);c.forEach((u,d)=>{"!"===u?t.add(d):u===ju&&e.add(d)}),i||c.set("offset",l/this.duration),r.push(c)});let o=t.size?dA(t.values()):[],s=e.size?dA(e.values()):[];if(i){let a=r[0],l=new Map(a);a.set("offset",0),l.set("offset",1),r=[a,l]}return X5(this.element,r,o,s,this.duration,this.startTime,this.easing,!1)}},N5=class extends G_{constructor(t,e,i,r,o,s,a=!1){super(t,e,s.delay),this.keyframes=i,this.preStyleProps=r,this.postStyleProps=o,this._stretchStartingKeyframe=a,this.timings={duration:s.duration,delay:s.delay,easing:s.easing}}containsAnimation(){return this.keyframes.length>1}buildKeyframes(){let t=this.keyframes,{delay:e,duration:i,easing:r}=this.timings;if(this._stretchStartingKeyframe&&e){let o=[],s=i+e,a=e/s,l=j_(t[0]);l.set("offset",0),o.push(l);let c=j_(t[0]);c.set("offset",wZ(a)),o.push(c);let u=t.length-1;for(let d=1;d<=u;d++){let p=j_(t[d]),h=p.get("offset");p.set("offset",wZ((e+h*i)/s)),o.push(p)}i=s,e=0,r="",t=o}return X5(this.element,t,this.preStyleProps,this.postStyleProps,i,e,r,!0)}};function wZ(n,t=3){let e=Math.pow(10,t-1);return Math.round(n*e)/e}var km=class{},GAe=new Set(["width","height","minWidth","minHeight","maxWidth","maxHeight","left","top","bottom","right","fontSize","outlineWidth","outlineOffset","paddingTop","paddingLeft","paddingBottom","paddingRight","marginTop","marginLeft","marginBottom","marginRight","borderRadius","borderWidth","borderTopWidth","borderLeftWidth","borderRightWidth","borderBottomWidth","textIndent","perspective"]),fA=class extends km{normalizePropertyName(t,e){return Y5(t)}normalizeStyleValue(t,e,i,r){let o="",s=i.toString().trim();if(GAe.has(e)&&0!==i&&"0"!==i)if("number"==typeof i)o="px";else{let a=i.match(/^[+-]?[\d\.]+([a-z]*)$/);a&&0==a[1].length&&r.push(new At(3005,!1))}return s+o}};function SZ(n,t,e,i,r,o,s,a,l,c,u,d,p){return{type:0,element:n,triggerName:t,isRemovalTransition:r,fromState:e,fromStyles:o,toState:i,toStyles:s,timelines:a,queriedElements:l,preStyleProps:c,postStyleProps:u,totalTime:d,errors:p}}var w5={},mA=class{constructor(t,e,i){this._triggerName=t,this.ast=e,this._stateStyles=i}match(t,e,i,r){return function(n,t,e,i,r){return n.some(o=>o(t,e,i,r))}(this.ast.matchers,t,e,i,r)}buildStyles(t,e,i){let r=this._stateStyles.get("*");return void 0!==t&&(r=this._stateStyles.get(t?.toString())||r),r?r.buildStyles(e,i):new Map}build(t,e,i,r,o,s,a,l,c,u){let d=[],p=this.ast.options&&this.ast.options.params||w5,f=this.buildStyles(i,a&&a.params||w5,d),m=l&&l.params||w5,x=this.buildStyles(r,m,d),g=new Set,b=new Map,D=new Map,T="void"===r,k={params:qAe(m,p),delay:this.ast.options?.delay},Z=u?[]:YZ(t,e,this.ast.animation,o,s,f,x,k,c,d),z=0;if(Z.forEach(ue=>{z=Math.max(ue.duration+ue.delay,z)}),d.length)return SZ(e,this._triggerName,i,r,T,f,x,[],[],b,D,z,d);Z.forEach(ue=>{let he=ue.element,w=pl(b,he,new Set);ue.preStyleProps.forEach(q=>w.add(q));let F=pl(D,he,new Set);ue.postStyleProps.forEach(q=>F.add(q)),he!==e&&g.add(he)});let fe=dA(g.values());return SZ(e,this._triggerName,i,r,T,f,x,Z,fe,b,D,z)}};function qAe(n,t){let e=yM(t);for(let i in n)n.hasOwnProperty(i)&&null!=n[i]&&(e[i]=n[i]);return e}function EZ(n,t,e){n.has(t)?n.has(e)||n.set(e,n.get(t)):n.has(e)&&n.set(t,n.get(e))}var QAe=new fM,TZ="ng-animate-queued",S5="ng-animate-disabled",eIe=[],XZ={namespaceId:"",setForRemoval:!1,setForMove:!1,hasAnimation:!1,removedBeforeQueried:!1},tIe={namespaceId:"",setForMove:!1,setForRemoval:!1,hasAnimation:!1,removedBeforeQueried:!0},Kl="__ng_removed",gM=class{constructor(t,e=""){this.namespaceId=e;let i=t&&t.hasOwnProperty("value");if(this.value=function(n){return n??null}(i?t.value:t),i){let o=yM(t);delete o.value,this.options=o}else this.options={};this.options.params||(this.options.params={})}get params(){return this.options.params}absorbOptions(t){let e=t.params;if(e){let i=this.options.params;Object.keys(e).forEach(r=>{null==i[r]&&(i[r]=e[r])})}}},pM="void",E5=new gM(pM),_M=class{constructor(t,e,i){this.namespaceId=t,this.triggerName=e,this.element=i,this._player=new dh,this._containsRealPlayer=!1,this._queuedCallbacks=new Map,this.destroyed=!1,this.markedForDestroy=!1,this.disabled=!1,this.queued=!0,this.totalTime=0}setRealPlayer(t){this._containsRealPlayer||(this._player=t,this._queuedCallbacks.forEach((e,i)=>{e.forEach(r=>j5(t,i,void 0,r))}),this._queuedCallbacks.clear(),this._containsRealPlayer=!0,this.overrideTotalTime(t.totalTime),this.queued=!1)}getRealPlayer(){return this._player}overrideTotalTime(t){this.totalTime=t}syncPlayerEvents(t){let e=this._player;e.triggerCallback&&t.onStart(()=>e.triggerCallback("start")),t.onDone(()=>this.finish()),t.onDestroy(()=>this.destroy())}_queueEvent(t,e){pl(this._queuedCallbacks,t,[]).push(e)}onDone(t){this.queued&&this._queueEvent("done",t),this._player.onDone(t)}onStart(t){this.queued&&this._queueEvent("start",t),this._player.onStart(t)}onDestroy(t){this.queued&&this._queueEvent("destroy",t),this._player.onDestroy(t)}init(){this._player.init()}hasStarted(){return!this.queued&&this._player.hasStarted()}play(){!this.queued&&this._player.play()}pause(){!this.queued&&this._player.pause()}restart(){!this.queued&&this._player.restart()}finish(){this._player.finish()}destroy(){this.destroyed=!0,this._player.destroy()}reset(){!this.queued&&this._player.reset()}setPosition(t){this.queued||this._player.setPosition(t)}getPosition(){return this.queued?0:this._player.getPosition()}triggerCallback(t){let e=this._player;e.triggerCallback&&e.triggerCallback(t)}};function lA(n){return n&&1===n.nodeType}function DZ(n,t){let e=n.style.display;return n.style.display=t??"none",e}function AZ(n,t,e,i,r){let o=[];e.forEach(l=>o.push(DZ(l)));let s=[];i.forEach((l,c)=>{let u=new Map;l.forEach(d=>{let p=t.computeStyle(c,d,r);u.set(d,p),(!p||0==p.length)&&(c[Kl]=tIe,s.push(c))}),n.set(c,u)});let a=0;return e.forEach(l=>DZ(l,o[a++])),s}function IZ(n,t){let e=new Map;if(n.forEach(a=>e.set(a,[])),0==t.length)return e;let r=new Set(t),o=new Map;function s(a){if(!a)return 1;let l=o.get(a);if(l)return l;let c=a.parentNode;return l=e.has(c)?c:r.has(c)?1:s(c),o.set(a,l),l}return t.forEach(a=>{let l=s(a);1!==l&&e.get(l).push(a)}),e}function Zl(n,t){n.classList?.add(t)}function z_(n,t){n.classList?.remove(t)}function oIe(n,t,e){ph(e).onDone(()=>n.processLeaveNode(t))}function QZ(n,t){for(let e=0;e<n.length;e++){let i=n[e];i instanceof uM?QZ(i.players,t):t.push(i)}}function PZ(n,t,e){let i=e.get(n);if(!i)return!1;let r=t.get(n);return r?i.forEach(o=>r.add(o)):t.set(n,i),e.delete(n),!0}var hh=class{constructor(t,e,i){this.bodyNode=t,this._driver=e,this._normalizer=i,this._triggerCache={},this.onRemovalComplete=(r,o)=>{},this._transitionEngine=new class{constructor(t,e,i){this.bodyNode=t,this.driver=e,this._normalizer=i,this.players=[],this.newHostElements=new Map,this.playersByElement=new Map,this.playersByQueriedElement=new Map,this.statesByElement=new Map,this.disabledNodes=new Set,this.totalAnimations=0,this.totalQueuedPlayers=0,this._namespaceLookup={},this._namespaceList=[],this._flushFns=[],this._whenQuietFns=[],this.namespacesByHostElement=new Map,this.collectedEnterElements=[],this.collectedLeaveElements=[],this.onRemovalComplete=(r,o)=>{}}_onRemovalComplete(t,e){this.onRemovalComplete(t,e)}get queuedPlayers(){let t=[];return this._namespaceList.forEach(e=>{e.players.forEach(i=>{i.queued&&t.push(i)})}),t}createNamespace(t,e){let i=new class{constructor(t,e,i){this.id=t,this.hostElement=e,this._engine=i,this.players=[],this._triggers=new Map,this._queue=[],this._elementListeners=new Map,this._hostClassName="ng-tns-"+t,Zl(e,this._hostClassName)}listen(t,e,i,r){if(!this._triggers.has(e))throw new At(3302,!1);if(null==i||0==i.length)throw new At(3303,!1);if(!function(n){return"start"==n||"done"==n}(i))throw new At(3400,!1);let o=pl(this._elementListeners,t,[]),s={name:e,phase:i,callback:r};o.push(s);let a=pl(this._engine.statesByElement,t,new Map);return a.has(e)||(Zl(t,oA),Zl(t,oA+"-"+e),a.set(e,E5)),()=>{this._engine.afterFlush(()=>{let l=o.indexOf(s);l>=0&&o.splice(l,1),this._triggers.has(e)||a.delete(e)})}}register(t,e){return!this._triggers.has(t)&&(this._triggers.set(t,e),!0)}_getTrigger(t){let e=this._triggers.get(t);if(!e)throw new At(3401,!1);return e}trigger(t,e,i,r=!0){let o=this._getTrigger(e),s=new _M(this.id,e,t),a=this._engine.statesByElement.get(t);a||(Zl(t,oA),Zl(t,oA+"-"+e),this._engine.statesByElement.set(t,a=new Map));let l=a.get(e),c=new gM(i,this.id);if(!(i&&i.hasOwnProperty("value"))&&l&&c.absorbOptions(l.options),a.set(e,c),l||(l=E5),c.value!==pM&&l.value===c.value){if(!function(n,t){let e=Object.keys(n),i=Object.keys(t);if(e.length!=i.length)return!1;for(let r=0;r<e.length;r++){let o=e[r];if(!t.hasOwnProperty(o)||n[o]!==t[o])return!1}return!0}(l.params,c.params)){let m=[],x=o.matchStyles(l.value,l.params,m),g=o.matchStyles(c.value,c.params,m);m.length?this._engine.reportError(m):this._engine.afterFlush(()=>{Om(t,x),Gu(t,g)})}return}let p=pl(this._engine.playersByElement,t,[]);p.forEach(m=>{m.namespaceId==this.id&&m.triggerName==e&&m.queued&&m.destroy()});let h=o.matchTransition(l.value,c.value,t,c.params),f=!1;if(!h){if(!r)return;h=o.fallbackTransition,f=!0}return this._engine.totalQueuedPlayers++,this._queue.push({element:t,triggerName:e,transition:h,fromState:l,toState:c,player:s,isFallbackTransition:f}),f||(Zl(t,TZ),s.onStart(()=>{z_(t,TZ)})),s.onDone(()=>{let m=this.players.indexOf(s);m>=0&&this.players.splice(m,1);let x=this._engine.playersByElement.get(t);if(x){let g=x.indexOf(s);g>=0&&x.splice(g,1)}}),this.players.push(s),p.push(s),s}deregister(t){this._triggers.delete(t),this._engine.statesByElement.forEach(e=>e.delete(t)),this._elementListeners.forEach((e,i)=>{this._elementListeners.set(i,e.filter(r=>r.name!=t))})}clearElementCache(t){this._engine.statesByElement.delete(t),this._elementListeners.delete(t);let e=this._engine.playersByElement.get(t);e&&(e.forEach(i=>i.destroy()),this._engine.playersByElement.delete(t))}_signalRemovalForInnerTriggers(t,e){let i=this._engine.driver.query(t,cA,!0);i.forEach(r=>{if(r[Kl])return;let o=this._engine.fetchNamespacesByElement(r);o.size?o.forEach(s=>s.triggerLeaveAnimation(r,e,!1,!0)):this.clearElementCache(r)}),this._engine.afterFlushAnimationsDone(()=>i.forEach(r=>this.clearElementCache(r)))}triggerLeaveAnimation(t,e,i,r){let o=this._engine.statesByElement.get(t),s=new Map;if(o){let a=[];if(o.forEach((l,c)=>{if(s.set(c,l.value),this._triggers.has(c)){let u=this.trigger(t,c,pM,r);u&&a.push(u)}}),a.length)return this._engine.markElementAsRemoved(this.id,t,!0,e,s),i&&ph(a).onDone(()=>this._engine.processLeaveNode(t)),!0}return!1}prepareLeaveAnimationListeners(t){let e=this._elementListeners.get(t),i=this._engine.statesByElement.get(t);if(e&&i){let r=new Set;e.forEach(o=>{let s=o.name;if(r.has(s))return;r.add(s);let l=this._triggers.get(s).fallbackTransition,c=i.get(s)||E5,u=new gM(pM),d=new _M(this.id,s,t);this._engine.totalQueuedPlayers++,this._queue.push({element:t,triggerName:s,transition:l,fromState:c,toState:u,player:d,isFallbackTransition:!0})})}}removeNode(t,e){let i=this._engine;if(t.childElementCount&&this._signalRemovalForInnerTriggers(t,e),this.triggerLeaveAnimation(t,e,!0))return;let r=!1;if(i.totalAnimations){let o=i.players.length?i.playersByQueriedElement.get(t):[];if(o&&o.length)r=!0;else{let s=t;for(;s=s.parentNode;)if(i.statesByElement.get(s)){r=!0;break}}}if(this.prepareLeaveAnimationListeners(t),r)i.markElementAsRemoved(this.id,t,!1,e);else{let o=t[Kl];(!o||o===XZ)&&(i.afterFlush(()=>this.clearElementCache(t)),i.destroyInnerAnimations(t),i._onRemovalComplete(t,e))}}insertNode(t,e){Zl(t,this._hostClassName)}drainQueuedTransitions(t){let e=[];return this._queue.forEach(i=>{let r=i.player;if(r.destroyed)return;let o=i.element,s=this._elementListeners.get(o);s&&s.forEach(a=>{if(a.name==i.triggerName){let l=G5(o,i.triggerName,i.fromState.value,i.toState.value);l._data=t,j5(i.player,a.phase,l,a.callback)}}),r.markedForDestroy?this._engine.afterFlush(()=>{r.destroy()}):e.push(i)}),this._queue=[],e.sort((i,r)=>{let o=i.transition.ast.depCount,s=r.transition.ast.depCount;return 0==o||0==s?o-s:this._engine.driver.containsElement(i.element,r.element)?1:-1})}destroy(t){this.players.forEach(e=>e.destroy()),this._signalRemovalForInnerTriggers(this.hostElement,t)}elementContainsData(t){let e=!1;return this._elementListeners.has(t)&&(e=!0),e=!!this._queue.find(i=>i.element===t)||e,e}}(t,e,this);return this.bodyNode&&this.driver.containsElement(this.bodyNode,e)?this._balanceNamespaceList(i,e):(this.newHostElements.set(e,i),this.collectEnterElement(e)),this._namespaceLookup[t]=i}_balanceNamespaceList(t,e){let i=this._namespaceList,r=this.namespacesByHostElement;if(i.length-1>=0){let s=!1,a=this.driver.getParentElement(e);for(;a;){let l=r.get(a);if(l){let c=i.indexOf(l);i.splice(c+1,0,t),s=!0;break}a=this.driver.getParentElement(a)}s||i.unshift(t)}else i.push(t);return r.set(e,t),t}register(t,e){let i=this._namespaceLookup[t];return i||(i=this.createNamespace(t,e)),i}registerTrigger(t,e,i){let r=this._namespaceLookup[t];r&&r.register(e,i)&&this.totalAnimations++}destroy(t,e){if(!t)return;let i=this._fetchNamespace(t);this.afterFlush(()=>{this.namespacesByHostElement.delete(i.hostElement),delete this._namespaceLookup[t];let r=this._namespaceList.indexOf(i);r>=0&&this._namespaceList.splice(r,1)}),this.afterFlushAnimationsDone(()=>i.destroy(e))}_fetchNamespace(t){return this._namespaceLookup[t]}fetchNamespacesByElement(t){let e=new Set,i=this.statesByElement.get(t);if(i)for(let r of i.values())if(r.namespaceId){let o=this._fetchNamespace(r.namespaceId);o&&e.add(o)}return e}trigger(t,e,i,r){if(lA(e)){let o=this._fetchNamespace(t);if(o)return o.trigger(e,i,r),!0}return!1}insertNode(t,e,i,r){if(!lA(e))return;let o=e[Kl];if(o&&o.setForRemoval){o.setForRemoval=!1,o.setForMove=!0;let s=this.collectedLeaveElements.indexOf(e);s>=0&&this.collectedLeaveElements.splice(s,1)}if(t){let s=this._fetchNamespace(t);s&&s.insertNode(e,i)}r&&this.collectEnterElement(e)}collectEnterElement(t){this.collectedEnterElements.push(t)}markElementAsDisabled(t,e){e?this.disabledNodes.has(t)||(this.disabledNodes.add(t),Zl(t,S5)):this.disabledNodes.has(t)&&(this.disabledNodes.delete(t),z_(t,S5))}removeNode(t,e,i,r){if(lA(e)){let o=t?this._fetchNamespace(t):null;if(o?o.removeNode(e,r):this.markElementAsRemoved(t,e,!1,r),i){let s=this.namespacesByHostElement.get(e);s&&s.id!==t&&s.removeNode(e,r)}}else this._onRemovalComplete(e,r)}markElementAsRemoved(t,e,i,r,o){this.collectedLeaveElements.push(e),e[Kl]={namespaceId:t,setForRemoval:r,hasAnimation:i,removedBeforeQueried:!1,previousTriggersValues:o}}listen(t,e,i,r,o){return lA(e)?this._fetchNamespace(t).listen(e,i,r,o):()=>{}}_buildInstruction(t,e,i,r,o){return t.transition.build(this.driver,t.element,t.fromState.value,t.toState.value,i,r,t.fromState.options,t.toState.options,e,o)}destroyInnerAnimations(t){let e=this.driver.query(t,cA,!0);e.forEach(i=>this.destroyActiveAnimationsForElement(i)),0!=this.playersByQueriedElement.size&&(e=this.driver.query(t,I5,!0),e.forEach(i=>this.finishActiveQueriedAnimationOnElement(i)))}destroyActiveAnimationsForElement(t){let e=this.playersByElement.get(t);e&&e.forEach(i=>{i.queued?i.markedForDestroy=!0:i.destroy()})}finishActiveQueriedAnimationOnElement(t){let e=this.playersByQueriedElement.get(t);e&&e.forEach(i=>i.finish())}whenRenderingDone(){return new Promise(t=>{if(this.players.length)return ph(this.players).onDone(()=>t());t()})}processLeaveNode(t){let e=t[Kl];if(e&&e.setForRemoval){if(t[Kl]=XZ,e.namespaceId){this.destroyInnerAnimations(t);let i=this._fetchNamespace(e.namespaceId);i&&i.clearElementCache(t)}this._onRemovalComplete(t,e.setForRemoval)}t.classList?.contains(S5)&&this.markElementAsDisabled(t,!1),this.driver.query(t,".ng-animate-disabled",!0).forEach(i=>{this.markElementAsDisabled(i,!1)})}flush(t=-1){let e=[];if(this.newHostElements.size&&(this.newHostElements.forEach((i,r)=>this._balanceNamespaceList(i,r)),this.newHostElements.clear()),this.totalAnimations&&this.collectedEnterElements.length)for(let i=0;i<this.collectedEnterElements.length;i++)Zl(this.collectedEnterElements[i],"ng-star-inserted");if(this._namespaceList.length&&(this.totalQueuedPlayers||this.collectedLeaveElements.length)){let i=[];try{e=this._flushAnimations(i,t)}finally{for(let r=0;r<i.length;r++)i[r]()}}else for(let i=0;i<this.collectedLeaveElements.length;i++)this.processLeaveNode(this.collectedLeaveElements[i]);if(this.totalQueuedPlayers=0,this.collectedEnterElements.length=0,this.collectedLeaveElements.length=0,this._flushFns.forEach(i=>i()),this._flushFns=[],this._whenQuietFns.length){let i=this._whenQuietFns;this._whenQuietFns=[],e.length?ph(e).onDone(()=>{i.forEach(r=>r())}):i.forEach(r=>r())}}reportError(t){throw new At(3402,!1)}_flushAnimations(t,e){let i=new fM,r=[],o=new Map,s=[],a=new Map,l=new Map,c=new Map,u=new Set;this.disabledNodes.forEach(Y=>{u.add(Y);let ae=this.driver.query(Y,".ng-animate-queued",!0);for(let le=0;le<ae.length;le++)u.add(ae[le])});let d=this.bodyNode,p=Array.from(this.statesByElement.keys()),h=IZ(p,this.collectedEnterElements),f=new Map,m=0;h.forEach((Y,ae)=>{let le=BZ+m++;f.set(ae,le),Y.forEach(Ie=>Zl(Ie,le))});let x=[],g=new Set,b=new Set;for(let Y=0;Y<this.collectedLeaveElements.length;Y++){let ae=this.collectedLeaveElements[Y],le=ae[Kl];le&&le.setForRemoval&&(x.push(ae),g.add(ae),le.hasAnimation?this.driver.query(ae,".ng-star-inserted",!0).forEach(Ie=>g.add(Ie)):b.add(ae))}let D=new Map,T=IZ(p,Array.from(g));T.forEach((Y,ae)=>{let le=A5+m++;D.set(ae,le),Y.forEach(Ie=>Zl(Ie,le))}),t.push(()=>{h.forEach((Y,ae)=>{let le=f.get(ae);Y.forEach(Ie=>z_(Ie,le))}),T.forEach((Y,ae)=>{let le=D.get(ae);Y.forEach(Ie=>z_(Ie,le))}),x.forEach(Y=>{this.processLeaveNode(Y)})});let k=[],Z=[];for(let Y=this._namespaceList.length-1;Y>=0;Y--)this._namespaceList[Y].drainQueuedTransitions(e).forEach(le=>{let Ie=le.player,ve=le.element;if(k.push(Ie),this.collectedEnterElements.length){let pt=ve[Kl];if(pt&&pt.setForMove){if(pt.previousTriggersValues&&pt.previousTriggersValues.has(le.triggerName)){let wt=pt.previousTriggersValues.get(le.triggerName),Te=this.statesByElement.get(le.element);if(Te&&Te.has(le.triggerName)){let xt=Te.get(le.triggerName);xt.value=wt,Te.set(le.triggerName,xt)}}return void Ie.destroy()}}let De=!d||!this.driver.containsElement(d,ve),nt=D.get(ve),gt=f.get(ve),Ue=this._buildInstruction(le,i,gt,nt,De);if(Ue.errors&&Ue.errors.length)return void Z.push(Ue);if(De)return Ie.onStart(()=>Om(ve,Ue.fromStyles)),Ie.onDestroy(()=>Gu(ve,Ue.toStyles)),void r.push(Ie);if(le.isFallbackTransition)return Ie.onStart(()=>Om(ve,Ue.fromStyles)),Ie.onDestroy(()=>Gu(ve,Ue.toStyles)),void r.push(Ie);let Ae=[];Ue.timelines.forEach(pt=>{pt.stretchStartingKeyframe=!0,this.disabledNodes.has(pt.element)||Ae.push(pt)}),Ue.timelines=Ae,i.append(ve,Ue.timelines),s.push({instruction:Ue,player:Ie,element:ve}),Ue.queriedElements.forEach(pt=>pl(a,pt,[]).push(Ie)),Ue.preStyleProps.forEach((pt,wt)=>{if(pt.size){let Te=l.get(wt);Te||l.set(wt,Te=new Set),pt.forEach((xt,mt)=>Te.add(mt))}}),Ue.postStyleProps.forEach((pt,wt)=>{let Te=c.get(wt);Te||c.set(wt,Te=new Set),pt.forEach((xt,mt)=>Te.add(mt))})});if(Z.length){let Y=[];Z.forEach(ae=>{Y.push(new At(3505,!1))}),k.forEach(ae=>ae.destroy()),this.reportError(Y)}let z=new Map,fe=new Map;s.forEach(Y=>{let ae=Y.element;i.has(ae)&&(fe.set(ae,ae),this._beforeAnimationBuild(Y.player.namespaceId,Y.instruction,z))}),r.forEach(Y=>{let ae=Y.element;this._getPreviousPlayers(ae,!1,Y.namespaceId,Y.triggerName,null).forEach(Ie=>{pl(z,ae,[]).push(Ie),Ie.destroy()})});let ue=x.filter(Y=>PZ(Y,l,c)),he=new Map;AZ(he,this.driver,b,c,ju).forEach(Y=>{PZ(Y,l,c)&&ue.push(Y)});let F=new Map;h.forEach((Y,ae)=>{AZ(F,this.driver,new Set(Y),l,"!")}),ue.forEach(Y=>{let ae=he.get(Y),le=F.get(Y);he.set(Y,new Map([...Array.from(ae?.entries()??[]),...Array.from(le?.entries()??[])]))});let q=[],K=[],de={};s.forEach(Y=>{let{element:ae,player:le,instruction:Ie}=Y;if(i.has(ae)){if(u.has(ae))return le.onDestroy(()=>Gu(ae,Ie.toStyles)),le.disabled=!0,le.overrideTotalTime(Ie.totalTime),void r.push(le);let ve=de;if(fe.size>1){let nt=ae,gt=[];for(;nt=nt.parentNode;){let Ue=fe.get(nt);if(Ue){ve=Ue;break}gt.push(nt)}gt.forEach(Ue=>fe.set(Ue,ve))}let De=this._buildAnimation(le.namespaceId,Ie,z,o,F,he);if(le.setRealPlayer(De),ve===de)q.push(le);else{let nt=this.playersByElement.get(ve);nt&&nt.length&&(le.parentPlayer=ph(nt)),r.push(le)}}else Om(ae,Ie.fromStyles),le.onDestroy(()=>Gu(ae,Ie.toStyles)),K.push(le),u.has(ae)&&r.push(le)}),K.forEach(Y=>{let ae=o.get(Y.element);if(ae&&ae.length){let le=ph(ae);Y.setRealPlayer(le)}}),r.forEach(Y=>{Y.parentPlayer?Y.syncPlayerEvents(Y.parentPlayer):Y.destroy()});for(let Y=0;Y<x.length;Y++){let ae=x[Y],le=ae[Kl];if(z_(ae,A5),le&&le.hasAnimation)continue;let Ie=[];if(a.size){let De=a.get(ae);De&&De.length&&Ie.push(...De);let nt=this.driver.query(ae,I5,!0);for(let gt=0;gt<nt.length;gt++){let Ue=a.get(nt[gt]);Ue&&Ue.length&&Ie.push(...Ue)}}let ve=Ie.filter(De=>!De.destroyed);ve.length?oIe(this,ae,ve):this.processLeaveNode(ae)}return x.length=0,q.forEach(Y=>{this.players.push(Y),Y.onDone(()=>{Y.destroy();let ae=this.players.indexOf(Y);this.players.splice(ae,1)}),Y.play()}),q}elementContainsData(t,e){let i=!1,r=e[Kl];return r&&r.setForRemoval&&(i=!0),this.playersByElement.has(e)&&(i=!0),this.playersByQueriedElement.has(e)&&(i=!0),this.statesByElement.has(e)&&(i=!0),this._fetchNamespace(t).elementContainsData(e)||i}afterFlush(t){this._flushFns.push(t)}afterFlushAnimationsDone(t){this._whenQuietFns.push(t)}_getPreviousPlayers(t,e,i,r,o){let s=[];if(e){let a=this.playersByQueriedElement.get(t);a&&(s=a)}else{let a=this.playersByElement.get(t);if(a){let l=!o||o==pM;a.forEach(c=>{c.queued||!l&&c.triggerName!=r||s.push(c)})}}return(i||r)&&(s=s.filter(a=>!(i&&i!=a.namespaceId||r&&r!=a.triggerName))),s}_beforeAnimationBuild(t,e,i){let o=e.element,s=e.isRemovalTransition?void 0:t,a=e.isRemovalTransition?void 0:e.triggerName;for(let l of e.timelines){let c=l.element,u=c!==o,d=pl(i,c,[]);this._getPreviousPlayers(c,u,s,a,e.toState).forEach(h=>{let f=h.getRealPlayer();f.beforeDestroy&&f.beforeDestroy(),h.destroy(),d.push(h)})}Om(o,e.fromStyles)}_buildAnimation(t,e,i,r,o,s){let a=e.triggerName,l=e.element,c=[],u=new Set,d=new Set,p=e.timelines.map(f=>{let m=f.element;u.add(m);let x=m[Kl];if(x&&x.removedBeforeQueried)return new dh(f.duration,f.delay);let g=m!==l,b=function(n){let t=[];return QZ(n,t),t}((i.get(m)||eIe).map(z=>z.getRealPlayer())).filter(z=>!!z.element&&z.element===m),D=o.get(m),T=s.get(m),k=RZ(0,this._normalizer,0,f.keyframes,D,T),Z=this._buildPlayer(f,k,b);if(f.subTimeline&&r&&d.add(m),g){let z=new _M(t,a,m);z.setRealPlayer(Z),c.push(z)}return Z});c.forEach(f=>{pl(this.playersByQueriedElement,f.element,[]).push(f),f.onDone(()=>function(n,t,e){let i=n.get(t);if(i){if(i.length){let r=i.indexOf(e);i.splice(r,1)}0==i.length&&n.delete(t)}return i}(this.playersByQueriedElement,f.element,f))}),u.forEach(f=>Zl(f,bZ));let h=ph(p);return h.onDestroy(()=>{u.forEach(f=>z_(f,bZ)),Gu(l,e.toStyles)}),d.forEach(f=>{pl(r,f,[]).push(h)}),h}_buildPlayer(t,e,i){return e.length>0?this.driver.animate(t.element,e,t.duration,t.delay,t.easing,i):new dh(t.duration,t.delay)}}(t,e,i),this._timelineEngine=new class{constructor(t,e,i){this.bodyNode=t,this._driver=e,this._normalizer=i,this._animations=new Map,this._playersById=new Map,this.players=[]}register(t,e){let i=[],o=qZ(this._driver,e,i,[]);if(i.length)throw new At(3503,!1);this._animations.set(t,o)}_buildPlayer(t,e,i){let r=t.element,o=RZ(0,this._normalizer,0,t.keyframes,e,i);return this._driver.animate(r,o,t.duration,t.delay,t.easing,[],!0)}create(t,e,i={}){let s,r=[],o=this._animations.get(t),a=new Map;if(o?(s=YZ(this._driver,e,o,BZ,A5,new Map,new Map,i,QAe,r),s.forEach(u=>{let d=pl(a,u.element,new Map);u.postStyleProps.forEach(p=>d.set(p,null))})):(r.push(new At(3300,!1)),s=[]),r.length)throw new At(3504,!1);a.forEach((u,d)=>{u.forEach((p,h)=>{u.set(h,this._driver.computeStyle(d,h,ju))})});let c=ph(s.map(u=>{let d=a.get(u.element);return this._buildPlayer(u,new Map,d)}));return this._playersById.set(t,c),c.onDestroy(()=>this.destroy(t)),this.players.push(c),c}destroy(t){let e=this._getPlayer(t);e.destroy(),this._playersById.delete(t);let i=this.players.indexOf(e);i>=0&&this.players.splice(i,1)}_getPlayer(t){let e=this._playersById.get(t);if(!e)throw new At(3301,!1);return e}listen(t,e,i,r){let o=G5(e,"","","");return j5(this._getPlayer(t),i,o,r),()=>{}}command(t,e,i,r){if("register"==i)return void this.register(t,r[0]);if("create"==i)return void this.create(t,e,r[0]||{});let o=this._getPlayer(t);switch(i){case"play":o.play();break;case"pause":o.pause();break;case"reset":o.reset();break;case"restart":o.restart();break;case"finish":o.finish();break;case"init":o.init();break;case"setPosition":o.setPosition(parseFloat(r[0]));break;case"destroy":this.destroy(t)}}}(t,e,i),this._transitionEngine.onRemovalComplete=(r,o)=>this.onRemovalComplete(r,o)}registerTrigger(t,e,i,r,o){let s=t+"-"+r,a=this._triggerCache[s];if(!a){let l=[],u=qZ(this._driver,o,l,[]);if(l.length)throw new At(3404,!1);a=function(n,t,e){return new class{constructor(t,e,i){this.name=t,this.ast=e,this._normalizer=i,this.transitionFactories=[],this.states=new Map,e.states.forEach(r=>{let o=r.options&&r.options.params||{};this.states.set(r.name,new class{constructor(t,e,i){this.styles=t,this.defaultParams=e,this.normalizer=i}buildStyles(t,e){let i=new Map,r=yM(this.defaultParams);return Object.keys(t).forEach(o=>{let s=t[o];null!==s&&(r[o]=s)}),this.styles.styles.forEach(o=>{"string"!=typeof o&&o.forEach((s,a)=>{s&&(s=hM(s,r,e));let l=this.normalizer.normalizePropertyName(a,e);s=this.normalizer.normalizeStyleValue(a,l,s,e),i.set(l,s)})}),i}}(r.style,o,i))}),EZ(this.states,"true","1"),EZ(this.states,"false","0"),e.transitions.forEach(r=>{this.transitionFactories.push(new mA(t,r,this.states))}),this.fallbackTransition=function(n,t,e){return new mA(n,{type:1,animation:{type:2,steps:[],options:null},matchers:[(s,a)=>!0],options:null,queryCount:0,depCount:0},t)}(t,this.states)}get containsQueries(){return this.ast.queryCount>0}matchTransition(t,e,i,r){return this.transitionFactories.find(s=>s.match(t,e,i,r))||null}matchStyles(t,e,i){return this.fallbackTransition.buildStyles(t,e,i)}}(n,t,e)}(r,u,this._normalizer),this._triggerCache[s]=a}this._transitionEngine.registerTrigger(e,r,a)}register(t,e){this._transitionEngine.register(t,e)}destroy(t,e){this._transitionEngine.destroy(t,e)}onInsert(t,e,i,r){this._transitionEngine.insertNode(t,e,i,r)}onRemove(t,e,i,r){this._transitionEngine.removeNode(t,e,r||!1,i)}disableAnimations(t,e){this._transitionEngine.markElementAsDisabled(t,e)}process(t,e,i,r){if("@"==i.charAt(0)){let[o,s]=vZ(i);this._timelineEngine.command(o,e,s,r)}else this._transitionEngine.trigger(t,e,i,r)}listen(t,e,i,r,o){if("@"==i.charAt(0)){let[s,a]=vZ(i);return this._timelineEngine.listen(s,e,a,o)}return this._transitionEngine.listen(t,e,i,r,o)}flush(t=-1){this._transitionEngine.flush(t)}get players(){return this._transitionEngine.players.concat(this._timelineEngine.players)}whenRenderingDone(){return this._transitionEngine.whenRenderingDone()}},cIe=(()=>{class n{constructor(e,i,r){this._element=e,this._startStyles=i,this._endStyles=r,this._state=0;let o=n.initialStylesByElement.get(e);o||n.initialStylesByElement.set(e,o=new Map),this._initialStyles=o}start(){this._state<1&&(this._startStyles&&Gu(this._element,this._startStyles,this._initialStyles),this._state=1)}finish(){this.start(),this._state<2&&(Gu(this._element,this._initialStyles),this._endStyles&&(Gu(this._element,this._endStyles),this._endStyles=null),this._state=1)}destroy(){this.finish(),this._state<3&&(n.initialStylesByElement.delete(this._element),this._startStyles&&(Om(this._element,this._startStyles),this._endStyles=null),this._endStyles&&(Om(this._element,this._endStyles),this._endStyles=null),Gu(this._element,this._initialStyles),this._state=3)}}return n.initialStylesByElement=new WeakMap,n})();function T5(n){let t=null;return n.forEach((e,i)=>{(function(n){return"display"===n||"position"===n})(i)&&(t=t||new Map,t.set(i,e))}),t}var gA=class{constructor(t,e,i,r){this.element=t,this.keyframes=e,this.options=i,this._specialStyles=r,this._onDoneFns=[],this._onStartFns=[],this._onDestroyFns=[],this._initialized=!1,this._finished=!1,this._started=!1,this._destroyed=!1,this._originalOnDoneFns=[],this._originalOnStartFns=[],this.time=0,this.parentPlayer=null,this.currentSnapshot=new Map,this._duration=i.duration,this._delay=i.delay||0,this.time=this._duration+this._delay}_onFinish(){this._finished||(this._finished=!0,this._onDoneFns.forEach(t=>t()),this._onDoneFns=[])}init(){this._buildPlayer(),this._preparePlayerBeforeStart()}_buildPlayer(){if(this._initialized)return;this._initialized=!0;let t=this.keyframes;this.domPlayer=this._triggerWebAnimation(this.element,t,this.options),this._finalKeyframe=t.length?t[t.length-1]:new Map,this.domPlayer.addEventListener("finish",()=>this._onFinish())}_preparePlayerBeforeStart(){this._delay?this._resetDomPlayerState():this.domPlayer.pause()}_convertKeyframesToObject(t){let e=[];return t.forEach(i=>{e.push(Object.fromEntries(i))}),e}_triggerWebAnimation(t,e,i){return t.animate(this._convertKeyframesToObject(e),i)}onStart(t){this._originalOnStartFns.push(t),this._onStartFns.push(t)}onDone(t){this._originalOnDoneFns.push(t),this._onDoneFns.push(t)}onDestroy(t){this._onDestroyFns.push(t)}play(){this._buildPlayer(),this.hasStarted()||(this._onStartFns.forEach(t=>t()),this._onStartFns=[],this._started=!0,this._specialStyles&&this._specialStyles.start()),this.domPlayer.play()}pause(){this.init(),this.domPlayer.pause()}finish(){this.init(),this._specialStyles&&this._specialStyles.finish(),this._onFinish(),this.domPlayer.finish()}reset(){this._resetDomPlayerState(),this._destroyed=!1,this._finished=!1,this._started=!1,this._onStartFns=this._originalOnStartFns,this._onDoneFns=this._originalOnDoneFns}_resetDomPlayerState(){this.domPlayer&&this.domPlayer.cancel()}restart(){this.reset(),this.play()}hasStarted(){return this._started}destroy(){this._destroyed||(this._destroyed=!0,this._resetDomPlayerState(),this._onFinish(),this._specialStyles&&this._specialStyles.destroy(),this._onDestroyFns.forEach(t=>t()),this._onDestroyFns=[])}setPosition(t){void 0===this.domPlayer&&this.init(),this.domPlayer.currentTime=t*this.time}getPosition(){return this.domPlayer.currentTime/this.time}get totalTime(){return this._delay+this._duration}beforeDestroy(){let t=new Map;this.hasStarted()&&this._finalKeyframe.forEach((i,r)=>{"offset"!==r&&t.set(r,this._finished?i:zZ(this.element,r))}),this.currentSnapshot=t}triggerCallback(t){let e="start"===t?this._onStartFns:this._onDoneFns;e.forEach(i=>i()),e.length=0}},pIe=(()=>{class n extends cM{constructor(e,i){super(),this._nextAnimationId=0,this._renderer=e.createRenderer(i.body,{id:"0",encapsulation:Ja.None,styles:[],data:{animation:[]}})}build(e){let i=this._nextAnimationId.toString();this._nextAnimationId++;let r=Array.isArray(e)?iA(e):e;return ZZ(this._renderer,null,i,"register",[r]),new Q5(i,this._renderer)}}return n.\u0275fac=function(e){return new(e||n)(j(wu),j(Ht))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),Q5=class extends nA{constructor(t,e){super(),this._id=t,this._renderer=e}create(t,e){return new K5(this._id,t,e||{},this._renderer)}},K5=class{constructor(t,e,i,r){this.id=t,this.element=e,this._renderer=r,this.parentPlayer=null,this._started=!1,this.totalTime=0,this._command("create",i)}_listen(t,e){return this._renderer.listen(this.element,`@@${this.id}:${t}`,e)}_command(t,...e){return ZZ(this._renderer,this.element,this.id,t,e)}onDone(t){this._listen("done",t)}onStart(t){this._listen("start",t)}onDestroy(t){this._listen("destroy",t)}init(){this._command("init")}hasStarted(){return this._started}play(){this._command("play"),this._started=!0}pause(){this._command("pause")}restart(){this._command("restart")}finish(){this._command("finish")}destroy(){this._command("destroy")}reset(){this._command("reset"),this._started=!1}setPosition(t){this._command("setPosition",t)}getPosition(){return this._renderer.engine.players[+this.id]?.getPosition()??0}};function ZZ(n,t,e,i,r){return n.setProperty(t,`@@${e}:${i}`,r)}var JZ="@.disabled",hIe=(()=>{class n{constructor(e,i,r){this.delegate=e,this.engine=i,this._zone=r,this._currentId=0,this._microtaskId=1,this._animationCallbacksBuffer=[],this._rendererCache=new Map,this._cdRecurDepth=0,this.promise=Promise.resolve(0),i.onRemovalComplete=(o,s)=>{let a=s?.parentNode(o);a&&s.removeChild(a,o)}}createRenderer(e,i){let o=this.delegate.createRenderer(e,i);if(!(e&&i&&i.data&&i.data.animation)){let u=this._rendererCache.get(o);return u||(u=new yA("",o,this.engine,()=>this._rendererCache.delete(o)),this._rendererCache.set(o,u)),u}let s=i.id,a=i.id+"-"+this._currentId;this._currentId++,this.engine.register(a,e);let l=u=>{Array.isArray(u)?u.forEach(l):this.engine.registerTrigger(s,a,e,u.name,u)};return i.data.animation.forEach(l),new Z5(this,a,o,this.engine)}begin(){this._cdRecurDepth++,this.delegate.begin&&this.delegate.begin()}_scheduleCountTask(){this.promise.then(()=>{this._microtaskId++})}scheduleListenerCallback(e,i,r){e>=0&&e<this._microtaskId?this._zone.run(()=>i(r)):(0==this._animationCallbacksBuffer.length&&Promise.resolve(null).then(()=>{this._zone.run(()=>{this._animationCallbacksBuffer.forEach(o=>{let[s,a]=o;s(a)}),this._animationCallbacksBuffer=[]})}),this._animationCallbacksBuffer.push([i,r]))}end(){this._cdRecurDepth--,0==this._cdRecurDepth&&this._zone.runOutsideAngular(()=>{this._scheduleCountTask(),this.engine.flush(this._microtaskId)}),this.delegate.end&&this.delegate.end()}whenRenderingDone(){return this.engine.whenRenderingDone()}}return n.\u0275fac=function(e){return new(e||n)(j(wu),j(hh),j(_t))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),yA=class{constructor(t,e,i,r){this.namespaceId=t,this.delegate=e,this.engine=i,this._onDestroy=r,this.destroyNode=this.delegate.destroyNode?o=>e.destroyNode(o):null}get data(){return this.delegate.data}destroy(){this.engine.destroy(this.namespaceId,this.delegate),this.delegate.destroy(),this._onDestroy?.()}createElement(t,e){return this.delegate.createElement(t,e)}createComment(t){return this.delegate.createComment(t)}createText(t){return this.delegate.createText(t)}appendChild(t,e){this.delegate.appendChild(t,e),this.engine.onInsert(this.namespaceId,e,t,!1)}insertBefore(t,e,i,r=!0){this.delegate.insertBefore(t,e,i),this.engine.onInsert(this.namespaceId,e,t,r)}removeChild(t,e,i){this.engine.onRemove(this.namespaceId,e,this.delegate,i)}selectRootElement(t,e){return this.delegate.selectRootElement(t,e)}parentNode(t){return this.delegate.parentNode(t)}nextSibling(t){return this.delegate.nextSibling(t)}setAttribute(t,e,i,r){this.delegate.setAttribute(t,e,i,r)}removeAttribute(t,e,i){this.delegate.removeAttribute(t,e,i)}addClass(t,e){this.delegate.addClass(t,e)}removeClass(t,e){this.delegate.removeClass(t,e)}setStyle(t,e,i,r){this.delegate.setStyle(t,e,i,r)}removeStyle(t,e,i){this.delegate.removeStyle(t,e,i)}setProperty(t,e,i){"@"==e.charAt(0)&&e==JZ?this.disableAnimations(t,!!i):this.delegate.setProperty(t,e,i)}setValue(t,e){this.delegate.setValue(t,e)}listen(t,e,i){return this.delegate.listen(t,e,i)}disableAnimations(t,e){this.engine.disableAnimations(t,e)}},Z5=class extends yA{constructor(t,e,i,r,o){super(e,i,r,o),this.factory=t,this.namespaceId=e}setProperty(t,e,i){"@"==e.charAt(0)?"."==e.charAt(1)&&e==JZ?this.disableAnimations(t,i=void 0===i||!!i):this.engine.process(this.namespaceId,t,e.slice(1),i):this.delegate.setProperty(t,e,i)}listen(t,e,i){if("@"==e.charAt(0)){let r=function(n){switch(n){case"body":return document.body;case"document":return document;case"window":return window;default:return n}}(t),o=e.slice(1),s="";return"@"!=o.charAt(0)&&([o,s]=function(n){let t=n.indexOf(".");return[n.substring(0,t),n.slice(t+1)]}(o)),this.engine.listen(this.namespaceId,r,o,s,a=>{this.factory.scheduleListenerCallback(a._data||-1,i,a)})}return this.delegate.listen(t,e,i)}},gIe=(()=>{class n extends hh{constructor(e,i,r,o){super(e.body,i,r)}ngOnDestroy(){this.flush()}}return n.\u0275fac=function(e){return new(e||n)(j(Ht),j(vM),j(km),j(Iu))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),$Z=[{provide:cM,useClass:pIe},{provide:km,useFactory:function(){return new fA}},{provide:hh,useClass:gIe},{provide:wu,useFactory:function(n,t,e){return new hIe(n,t,e)},deps:[sM,hh,_t]}],KZ=[{provide:vM,useFactory:()=>new class{validateStyleProperty(t){return!0}validateAnimatableStyleProperty(t){return!0}matchesElement(t,e){return!1}containsElement(t,e){return FZ(t,e)}getParentElement(t){return W5(t)}query(t,e,i){return NZ(t,e,i)}computeStyle(t,e,i){return window.getComputedStyle(t)[e]}animate(t,e,i,r,o,s=[]){let l={duration:i,delay:r,fill:0==r?"both":"forwards"};o&&(l.easing=o);let c=new Map,u=s.filter(h=>h instanceof gA);(function(n,t){return 0===n||0===t})(i,r)&&u.forEach(h=>{h.currentSnapshot.forEach((f,m)=>c.set(m,f))});let d=function(n){return n.length?n[0]instanceof Map?n:n.map(t=>VZ(t)):[]}(e).map(h=>j_(h));d=function(n,t,e){if(e.size&&t.length){let i=t[0],r=[];if(e.forEach((o,s)=>{i.has(s)||r.push(s),i.set(s,o)}),r.length)for(let o=1;o<t.length;o++){let s=t[o];r.forEach(a=>s.set(a,zZ(n,a)))}}return t}(t,d,c);let p=function(n,t){let e=null,i=null;return Array.isArray(t)&&t.length?(e=T5(t[0]),t.length>1&&(i=T5(t[t.length-1]))):t instanceof Map&&(e=T5(t)),e||i?new cIe(n,e,i):null}(t,d);return new gA(t,d,l,p)}}},{provide:Pi,useValue:"BrowserAnimations"},...$Z],yIe=[{provide:vM,useClass:q5},{provide:Pi,useValue:"NoopAnimations"},...$Z],eJ=(()=>{class n{static withConfig(e){return{ngModule:n,providers:e.disableAnimations?yIe:KZ}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:KZ,imports:[tA]}),n})(),t4={};function be(n,t){if(t4[n]=(t4[n]||0)+1,"function"==typeof t)return J5(n,(...i)=>({...t(...i),type:n}));switch(t?t._as:"empty"){case"empty":return J5(n,()=>({type:n}));case"props":return J5(n,i=>({...i,type:n}));default:throw new Error("Unexpected config.")}}function J5(n,t){return Object.defineProperty(t,"type",{value:n,writable:!1})}var gJ="@ngrx/store/init",q_=(()=>{class n extends hr{constructor(){super({type:gJ})}next(e){if("function"==typeof e)throw new TypeError("\n        Dispatch expected an object, instead it received a function.\n        If you're using the createAction function, make sure to invoke the function\n        before dispatching the action. For example, someAction should be someAction().");if(typeof e>"u")throw new TypeError("Actions must be objects");if(typeof e.type>"u")throw new TypeError("Actions must have a type property");super.next(e)}complete(){}ngOnDestroy(){super.complete()}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),bIe=[q_],_J=new pe("@ngrx/store Internal Root Guard"),tJ=new pe("@ngrx/store Internal Initial State"),o4=new pe("@ngrx/store Initial State"),vJ=new pe("@ngrx/store Reducer Factory"),nJ=new pe("@ngrx/store Internal Reducer Factory Provider"),yJ=new pe("@ngrx/store Initial Reducers"),$5=new pe("@ngrx/store Internal Initial Reducers"),iJ=new pe("@ngrx/store Store Features"),rJ=new pe("@ngrx/store Internal Store Reducers"),e4=new pe("@ngrx/store Internal Feature Reducers"),oJ=new pe("@ngrx/store Internal Feature Configs"),bJ=new pe("@ngrx/store Internal Store Features"),sJ=new pe("@ngrx/store Internal Feature Reducers Token"),xJ=new pe("@ngrx/store Feature Reducers"),aJ=new pe("@ngrx/store User Provided Meta Reducers"),W_=new pe("@ngrx/store Meta Reducers"),lJ=new pe("@ngrx/store Internal Resolved Meta Reducers"),cJ=new pe("@ngrx/store User Runtime Checks Config"),uJ=new pe("@ngrx/store Internal User Runtime Checks Config"),bM=new pe("@ngrx/store Internal Runtime Checks"),s4=new pe("@ngrx/store Check if Action types are unique");function Fm(n,t={}){let e=Object.keys(n),i={};for(let o=0;o<e.length;o++){let s=e[o];"function"==typeof n[s]&&(i[s]=n[s])}let r=Object.keys(i);return function(s,a){s=void 0===s?t:s;let l=!1,c={};for(let u=0;u<r.length;u++){let d=r[u],h=s[d],f=(0,i[d])(h,a);c[d]=f,l=l||f!==h}return l?c:s}}function MA(...n){return function(t){if(0===n.length)return t;let e=n[n.length-1];return n.slice(0,-1).reduceRight((r,o)=>o(r),e(t))}}function CJ(n,t){return Array.isArray(t)&&t.length>0&&(n=MA.apply(null,[...t,n])),(e,i)=>{let r=n(e);return(o,s)=>r(o=void 0===o?i:o,s)}}new pe("@ngrx/store Root Store Provider"),new pe("@ngrx/store Feature State Provider");var xM=class extends un{},bA=class extends q_{},xA=(()=>{class n extends hr{constructor(e,i,r,o){super(o(r,i)),this.dispatcher=e,this.initialState=i,this.reducers=r,this.reducerFactory=o}get currentReducers(){return this.reducers}addFeature(e){this.addFeatures([e])}addFeatures(e){let i=e.reduce((r,{reducers:o,reducerFactory:s,metaReducers:a,initialState:l,key:c})=>{let u="function"==typeof o?function(n){let t=Array.isArray(n)&&n.length>0?MA(...n):e=>e;return(e,i)=>(e=t(e),(r,o)=>e(r=void 0===r?i:r,o))}(a)(o,l):CJ(s,a)(o,l);return r[c]=u,r},{});this.addReducers(i)}removeFeature(e){this.removeFeatures([e])}removeFeatures(e){this.removeReducers(e.map(i=>i.key))}addReducer(e,i){this.addReducers({[e]:i})}addReducers(e){this.reducers={...this.reducers,...e},this.updateReducers(Object.keys(e))}removeReducer(e){this.removeReducers([e])}removeReducers(e){e.forEach(i=>{this.reducers=function(n,t){return Object.keys(n).filter(e=>e!==t).reduce((e,i)=>Object.assign(e,{[i]:n[i]}),{})}(this.reducers,i)}),this.updateReducers(e)}updateReducers(e){this.next(this.reducerFactory(this.reducers,this.initialState)),this.dispatcher.next({type:"@ngrx/store/update-reducers",features:e})}ngOnDestroy(){this.complete()}}return n.\u0275fac=function(e){return new(e||n)(j(bA),j(o4),j(yJ),j(vJ))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),EIe=[xA,{provide:xM,useExisting:xA},{provide:bA,useExisting:q_}],CM=(()=>{class n extends ke{ngOnDestroy(){this.complete()}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),TIe=[CM],CA=class extends un{},dJ=(()=>{class n extends hr{constructor(e,i,r,o){super(o);let c=e.pipe(Bf(gN)).pipe(Wt(i)).pipe(function(n,t){return en(AW(n,t,arguments.length>=2,!0))}(DIe,{state:o}));this.stateSubscription=c.subscribe(({state:u,action:d})=>{this.next(u),r.next(d)})}ngOnDestroy(){this.stateSubscription.unsubscribe(),this.complete()}}return n.INIT=gJ,n.\u0275fac=function(e){return new(e||n)(j(q_),j(xM),j(CM),j(o4))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})();function DIe(n={state:void 0},[t,e]){let{state:i}=n;return{state:e(i,t),action:t}}var AIe=[dJ,{provide:CA,useExisting:dJ}],Ce=(()=>{class n extends un{constructor(e,i,r){super(),this.actionsObserver=i,this.reducerManager=r,this.source=e}select(e,...i){return vt.call(null,e,...i)(this)}lift(e){let i=new n(this,this.actionsObserver,this.reducerManager);return i.operator=e,i}dispatch(e){this.actionsObserver.next(e)}next(e){this.actionsObserver.next(e)}error(e){this.actionsObserver.error(e)}complete(){this.actionsObserver.complete()}addReducer(e,i){this.reducerManager.addReducer(e,i)}removeReducer(e){this.reducerManager.removeReducer(e)}}return n.\u0275fac=function(e){return new(e||n)(j(CA),j(q_),j(xA))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),IIe=[Ce];function vt(n,t,...e){return function(r){let o;if("string"==typeof n){let s=[t,...e].filter(Boolean);o=r.pipe(function(...n){let t=n.length;if(0===t)throw new Error("list of properties cannot be empty.");return L(e=>{let i=e;for(let r=0;r<t;r++){let o=i?.[n[r]];if(!(typeof o<"u"))return;i=o}return i})}(n,...s))}else{if("function"!=typeof n)throw new TypeError(`Unexpected type '${typeof n}' in select operator, expected 'string' or 'function'`);o=r.pipe(L(s=>n(s,t)))}return o.pipe(yi())}}var a4="https://ngrx.io/guide/store/configuration/runtime-checks";function pJ(n){return void 0===n}function hJ(n){return null===n}function MJ(n){return Array.isArray(n)}function wJ(n){return"object"==typeof n&&null!==n}function n4(n){return"function"==typeof n}function fJ(n,t){return n===t}function HIe(n,t,e){for(let i=0;i<n.length;i++)if(!e(n[i],t[i]))return!0;return!1}function SJ(n,t=fJ,e=fJ){let o,i=null,r=null;return{memoized:function(){if(void 0!==o)return o.result;if(!i)return r=n.apply(null,arguments),i=arguments,r;if(!HIe(arguments,i,t))return r;let u=n.apply(null,arguments);return i=arguments,e(r,u)?r:(r=u,u)},reset:function(){i=null,r=null},setResult:function(u){o={result:u}},clearResult:function(){o=void 0}}}function J(...n){return function(n,t={stateFn:UIe}){return function(...e){let i=e;if(Array.isArray(i[0])){let[u,...d]=i;i=[...u,...d]}let r=i.slice(0,i.length-1),o=i[i.length-1],s=r.filter(u=>u.release&&"function"==typeof u.release),a=n(function(...u){return o.apply(null,u)}),l=SJ(function(u,d){return t.stateFn.apply(null,[u,r,d,a])});return Object.assign(l.memoized,{release:function(){l.reset(),a.reset(),s.forEach(u=>u.release())},projector:a.memoized,setResult:l.setResult,clearResult:l.clearResult})}}(SJ)(...n)}function UIe(n,t,e,i){if(void 0===e){let o=t.map(s=>s(n));return i.memoized.apply(null,o)}let r=t.map(o=>o(n,e));return i.memoized.apply(null,[...r,e])}function Mr(n){return J(t=>{let e=t[n];return tC()&&!(n in t)&&console.warn(`@ngrx/store: The feature name "${n}" does not exist in the state, therefore createFeatureSelector cannot access it.  Be sure it is imported in a loaded module using StoreModule.forRoot('${n}', ...) or StoreModule.forFeature('${n}', ...).  If the default state is intended to be undefined, as is the case with router state, this development-only warning message can be ignored.`),e},t=>t)}function jIe(n,t){return t instanceof pe?n.get(t):t}function GIe(n,t,e){return e.map((i,r)=>{if(t[r]instanceof pe){let o=n.get(t[r]);return{key:i.key,reducerFactory:o.reducerFactory?o.reducerFactory:Fm,metaReducers:o.metaReducers?o.metaReducers:[],initialState:o.initialState}}return i})}function WIe(n,t){return t.map(i=>i instanceof pe?n.get(i):i)}function EJ(n){return"function"==typeof n?n():n}function qIe(n,t){return n.concat(t)}function YIe(n){if(n)throw new TypeError("The root Store has been provided more than once. Feature modules should provide feature states instead.");return"guarded"}function i4(n){Object.freeze(n);let t=n4(n);return Object.getOwnPropertyNames(n).forEach(e=>{if(!e.startsWith("\u0275")&&function(n,t){return Object.prototype.hasOwnProperty.call(n,t)}(n,e)&&(!t||"caller"!==e&&"callee"!==e&&"arguments"!==e)){let i=n[e];(wJ(i)||n4(i))&&!Object.isFrozen(i)&&i4(i)}}),n}function r4(n,t=[]){return(pJ(n)||hJ(n))&&0===t.length?{path:["root"],value:n}:Object.keys(n).reduce((i,r)=>{if(i)return i;let o=n[r];return function(n){return n4(n)&&n.hasOwnProperty("\u0275cmp")}(o)?i:!(pJ(o)||hJ(o)||function(n){return"number"==typeof n}(o)||function(n){return"boolean"==typeof n}(o)||function(n){return"string"==typeof n}(o)||MJ(o))&&(function(n){if(!function(n){return wJ(n)&&!MJ(n)}(n))return!1;let t=Object.getPrototypeOf(n);return t===Object.prototype||null===t}(o)?r4(o,[...t,r]):{path:[...t,r],value:o})},!1)}function mJ(n,t){if(!1===n)return;let e=n.path.join("."),i=new Error(`Detected unserializable ${t} at "${e}". ${a4}#strict${t}serializability`);throw i.value=n.value,i.unserializablePath=e,i}function ZIe(n){return tC()?{strictStateSerializability:!1,strictActionSerializability:!1,strictStateImmutability:!0,strictActionImmutability:!0,strictActionWithinNgZone:!1,strictActionTypeUniqueness:!1,...n}:{strictStateSerializability:!1,strictActionSerializability:!1,strictStateImmutability:!1,strictActionImmutability:!1,strictActionWithinNgZone:!1,strictActionTypeUniqueness:!1}}function JIe({strictActionSerializability:n,strictStateSerializability:t}){return e=>n||t?function(n,t){return function(e,i){t.action(i)&&mJ(r4(i),"action");let r=n(e,i);return t.state()&&mJ(r4(r),"state"),r}}(e,{action:i=>n&&!l4(i),state:()=>t}):e}function $Ie({strictActionImmutability:n,strictStateImmutability:t}){return e=>n||t?function(n,t){return function(e,i){let r=t.action(i)?i4(i):i,o=n(e,r);return t.state()?i4(o):o}}(e,{action:i=>n&&!l4(i),state:()=>t}):e}function l4(n){return n.type.startsWith("@ngrx")}function e2e({strictActionWithinNgZone:n}){return t=>n?function(n,t){return function(e,i){if(t.action(i)&&!_t.isInAngularZone())throw new Error(`Action '${i.type}' running outside NgZone. ${a4}#strictactionwithinngzone`);return n(e,i)}}(t,{action:e=>n&&!l4(e)}):t}function t2e(n){return[{provide:uJ,useValue:n},{provide:cJ,useFactory:n2e,deps:[uJ]},{provide:bM,deps:[cJ],useFactory:ZIe},{provide:W_,multi:!0,deps:[bM],useFactory:$Ie},{provide:W_,multi:!0,deps:[bM],useFactory:JIe},{provide:W_,multi:!0,deps:[bM],useFactory:e2e}]}function TJ(){return[{provide:s4,multi:!0,deps:[bM],useFactory:i2e}]}function n2e(n){return n}function i2e(n){if(!n.strictActionTypeUniqueness)return;let t=Object.entries(t4).filter(([,e])=>e>1).map(([e])=>e);if(t.length)throw new Error(`Action types are registered more than once, ${t.map(e=>`"${e}"`).join(", ")}. ${a4}#strictactiontypeuniqueness`)}function r2e(n,t){return[{provide:_J,useFactory:YIe,deps:[[Ce,new ns,new tl]]},{provide:tJ,useValue:t.initialState},{provide:o4,useFactory:EJ,deps:[tJ]},{provide:$5,useValue:n},{provide:rJ,useExisting:n instanceof pe?n:$5},{provide:yJ,deps:[Xn,$5,[new j0(rJ)]],useFactory:jIe},{provide:aJ,useValue:t.metaReducers?t.metaReducers:[]},{provide:lJ,deps:[W_,aJ],useFactory:qIe},{provide:nJ,useValue:t.reducerFactory?t.reducerFactory:Fm},{provide:vJ,deps:[nJ,lJ],useFactory:CJ},bIe,EIe,TIe,AIe,IIe,t2e(t.runtimeChecks),TJ()]}function o2e(n,t,e={}){return[{provide:oJ,multi:!0,useValue:n instanceof Object?{}:e},{provide:iJ,multi:!0,useValue:{key:n instanceof Object?n.name:n,reducerFactory:e instanceof pe||!e.reducerFactory?Fm:e.reducerFactory,metaReducers:e instanceof pe||!e.metaReducers?[]:e.metaReducers,initialState:e instanceof pe||!e.initialState?void 0:e.initialState}},{provide:bJ,deps:[Xn,oJ,iJ],useFactory:GIe},{provide:e4,multi:!0,useValue:n instanceof Object?n.reducer:t},{provide:sJ,multi:!0,useExisting:t instanceof pe?t:e4},{provide:xJ,multi:!0,deps:[Xn,e4,[new j0(sJ)]],useFactory:WIe},TJ()]}var MM=(()=>{class n{constructor(e,i,r,o,s,a){}}return n.\u0275fac=function(e){return new(e||n)(j(q_),j(xM),j(CM),j(Ce),j(_J,8),j(s4,8))},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),wA=(()=>{class n{constructor(e,i,r,o,s){this.features=e,this.featureReducers=i,this.reducerManager=r;let a=e.map((l,c)=>{let d=i.shift()[c];return{...l,reducers:d,initialState:EJ(l.initialState)}});r.addFeatures(a)}ngOnDestroy(){this.reducerManager.removeFeatures(this.features)}}return n.\u0275fac=function(e){return new(e||n)(j(bJ),j(xJ),j(xA),j(MM),j(s4,8))},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),wr=(()=>{class n{static forRoot(e,i={}){return{ngModule:MM,providers:[...r2e(e,i)]}}static forFeature(e,i,r={}){return{ngModule:wA,providers:[...o2e(e,i,r)]}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})();function Se(...n){return{reducer:n.pop(),types:n.map(i=>i.type)}}function vr(n,...t){let e=new Map;for(let i of t)for(let r of i.types){let o=e.get(r);e.set(r,o?(a,l)=>i.reducer(o(a,l),l):i.reducer)}return function(i=n,r){let o=e.get(r.type);return o?o(i,r):i}}var s2e={dispatch:!0,useEffectsErrorHandler:!0},EA="__@ngrx/effects_create__";function cr(n,t){let e=n(),i={...s2e,...t};return Object.defineProperty(e,EA,{value:i}),e}function a2e(n){return Object.getOwnPropertyNames(n).filter(i=>!(!n[i]||!n[i].hasOwnProperty(EA))&&n[i][EA].hasOwnProperty("dispatch")).map(i=>({propertyName:i,...n[i][EA]}))}function u4(n){return Object.getPrototypeOf(n)}var IJ="__@ngrx/effects__";function l2e(n){return MA(u2e,u4)(n)}function u2e(n){return function(n){return n.constructor.hasOwnProperty(IJ)}(n)?n.constructor[IJ]:[]}function PJ(n,t,e=10){return n.pipe(fo(i=>(t&&t.handleError(i),e<=1?n:PJ(n,t,e-1))))}var Po=(()=>{class n extends un{constructor(e){super(),e&&(this.source=e)}lift(e){let i=new n;return i.source=this,i.operator=e,i}}return n.\u0275fac=function(e){return new(e||n)(j(CM))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function ii(...n){return Ye(t=>n.some(e=>"string"==typeof e?e===t.type:e.type===t.type))}var RJ=new pe("@ngrx/effects Internal Root Guard"),SA=new pe("@ngrx/effects User Provided Effects"),c4=new pe("@ngrx/effects Internal Root Effects"),OJ=new pe("@ngrx/effects Root Effects"),DJ=new pe("@ngrx/effects Internal Feature Effects"),kJ=new pe("@ngrx/effects Feature Effects"),f2e=new pe("@ngrx/effects Effects Error Handler",{providedIn:"root",factory:()=>PJ}),FJ="@ngrx/effects/init";function w2e(n){return d4(n,"ngrxOnInitEffects")}function d4(n,t){return n&&t in n&&"function"==typeof n[t]}be(FJ);var NJ=(()=>{class n extends ke{constructor(e,i){super(),this.errorHandler=e,this.effectsErrorHandler=i}addEffects(e){this.next(e)}toActions(){return this.pipe(x1(u4),xn(e=>e.pipe(x1(S2e))),xn(e=>{let i=e.pipe(y1(o=>function(n,t){return e=>{let i=function(n,t,e){let i=u4(n).constructor.name,r=function(n){return[l2e,a2e].reduce((e,i)=>e.concat(i(n)),[])}(n).map(({propertyName:o,dispatch:s,useEffectsErrorHandler:a})=>{let l="function"==typeof n[o]?n[o]():n[o],c=a?e(l,t):l;return!1===s?c.pipe(lx()):c.pipe(en((n,t)=>{n.subscribe(jt(t,e=>{t.next(Rl.createNext(e))},()=>{t.next(Rl.createComplete()),t.complete()},e=>{t.next(Rl.createError(e)),t.complete()}))})).pipe(L(d=>({effect:n[o],notification:d,propertyName:o,sourceName:i,sourceInstance:n})))});return Jt(...r)}(e,n,t);return function(n){return d4(n,"ngrxOnRunEffects")}(e)?e.ngrxOnRunEffects(i):i}}(this.errorHandler,this.effectsErrorHandler)(o)),L(o=>(function(n,t){if("N"===n.notification.kind){let e=n.notification.value;!function(n){return"function"!=typeof n&&n&&n.type&&"string"==typeof n.type}(e)&&t.handleError(new Error(`Effect ${function({propertyName:n,sourceInstance:t,sourceName:e}){let i="function"==typeof t[n];return`"${e}.${String(n)}${i?"()":""}"`}(n)} dispatched an invalid action: ${function(n){try{return JSON.stringify(n)}catch{return n}}(e)}`))}}(o,this.errorHandler),o.notification)),Ye(o=>"N"===o.kind&&null!=o.value),en((n,t)=>{n.subscribe(jt(t,e=>bN(e,t)))}));return Jt(i,e.pipe(Qt(1),Ye(w2e),L(o=>o.ngrxOnInitEffects())))}))}}return n.\u0275fac=function(e){return new(e||n)(j(Qs),j(f2e))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function S2e(n){return function(n){return d4(n,"ngrxOnIdentifyEffects")}(n)?n.ngrxOnIdentifyEffects():""}var LJ=(()=>{class n{constructor(e,i){this.effectSources=e,this.store=i,this.effectsSubscription=null}get isStarted(){return!!this.effectsSubscription}start(){this.effectsSubscription||(this.effectsSubscription=this.effectSources.toActions().subscribe(this.store))}ngOnDestroy(){this.effectsSubscription&&(this.effectsSubscription.unsubscribe(),this.effectsSubscription=null)}}return n.\u0275fac=function(e){return new(e||n)(j(NJ),j(Ce))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),BJ=(()=>{class n{constructor(e,i,r,o,s,a,l){this.sources=e,i.start(),o.forEach(c=>e.addEffects(c)),r.dispatch({type:FJ})}addEffects(e){this.sources.addEffects(e)}}return n.\u0275fac=function(e){return new(e||n)(j(NJ),j(LJ),j(Ce),j(OJ),j(MM,8),j(wA,8),j(RJ,8))},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),T2e=(()=>{class n{constructor(e,i,r,o){i.forEach(s=>s.forEach(a=>e.addEffects(a)))}}return n.\u0275fac=function(e){return new(e||n)(j(BJ),j(kJ),j(MM,8),j(wA,8))},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),ro=(()=>{class n{static forFeature(e=[]){return{ngModule:T2e,providers:[e,{provide:DJ,multi:!0,useValue:e},{provide:SA,multi:!0,useValue:[]},{provide:kJ,multi:!0,useFactory:AJ,deps:[Xn,DJ,SA]}]}}static forRoot(e=[]){return{ngModule:BJ,providers:[e,{provide:c4,useValue:[e]},{provide:RJ,useFactory:A2e,deps:[[LJ,new ns,new tl],[c4,new w3]]},{provide:SA,multi:!0,useValue:[]},{provide:OJ,useFactory:AJ,deps:[Xn,c4,SA]}]}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})();function AJ(n,t,e){let i=[];for(let r of t)i.push(...r);for(let r of e)i.push(...r);return function(n,t){return t.map(e=>n.get(e))}(n,i)}function A2e(n,t){if((1!==t.length||0!==t[0].length)&&n)throw new TypeError("EffectsModule.forRoot() called twice. Feature modules should use EffectsModule.forFeature() instead.");return"guarded"}var hi=(()=>(function(n){n[n.UNKNOWN=0]="UNKNOWN",n[n.EXPERIMENTS=1]="EXPERIMENTS",n[n.EXPERIMENT=2]="EXPERIMENT",n[n.COMPARE_EXPERIMENT=3]="COMPARE_EXPERIMENT",n[n.NOT_SET=4]="NOT_SET",n[n.FLAGS=5]="FLAGS"}(hi||(hi={})),hi))(),TA="defaultExperimentId",Y_=(()=>(function(n){n[n.EXPERIMENTS=0]="EXPERIMENTS",n[n.DASHBOARD=1]="DASHBOARD"}(Y_||(Y_={})),Y_))();function SM(n){return n.split(",").map(t=>{let e=t.indexOf(":");if(e<0)throw new Error(`Expect colon delimiting name and ID: ${t}`);let i=t.slice(0,e),r=t.slice(e+1);if(!r)throw new Error(`Expect id to be non-falsy: ${t}`);return{name:i,id:r}})}function VJ(n){return n.map(({alias:t,id:e})=>`${t}:${e}`).join(",")}function wM(n,t){switch(n){case hi.EXPERIMENT:return Object.prototype.hasOwnProperty.call(t,"experimentId")?[t.experimentId]:[TA];case hi.COMPARE_EXPERIMENT:return SM(t.experimentIds).map(({id:i})=>i);default:return null}}function Ps(n,t){if(!n||!t)return n===t;if(n.routeKind!==t.routeKind)return!1;let e=wM(n.routeKind,n.params),i=wM(t.routeKind,t.params);if(null===e||null===i)return e===i;if(e.length!==i.length)return!1;let r=i.sort();return e.sort().every((o,s)=>r[s]===o)}function p4(n){switch(n){case hi.EXPERIMENTS:return Y_.EXPERIMENTS;case hi.EXPERIMENT:case hi.COMPARE_EXPERIMENT:return Y_.DASHBOARD;case hi.UNKNOWN:case hi.NOT_SET:case hi.FLAGS:return null}}function DA(n,t,e){let i=p4(n);return null!==i&&!e.some(r=>r.deepLinkGroup===i&&r.namespaceId===t)}var jJ_getHref=()=>window.location.href,Nm=(()=>{class n{getHref(){return jJ_getHref()}getSearch(){let e=new URLSearchParams(window.location.search),i=[];return e.forEach((r,o)=>{i.push({key:o,value:r})}),i}getHash(){return window.location.hash}getPath(){return window.location.pathname}getHistoryState(){return window.history.state}replaceStateUrl(e){window.history.replaceState(window.history.state,"",e)}pushStateUrl(e){window.history.pushState(null,"",e)}replaceStateData(e){window.history.replaceState(e,"")}onPopState(){return _i(window,"popstate").pipe(L(e=>({pathname:this.getPath(),state:e.state})))}getResolvedPath(e){return new URL(e,jJ_getHref()).pathname}getFullPath(e,i,r){let o=this.getResolvedPath(e),s="";return i.length&&(s="?"+function(n){let t=new URLSearchParams;for(let{key:e,value:i}of n)t.append(e,i);return t}(i).toString()),`${o}${s}${r?this.getHash():""}`}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),Lm=(()=>{class n{constructor(e){this.appRoot=this.getAppRootFromMetaElement(e)}getAppRootFromMetaElement(e){let i=document.querySelector('head meta[name="tb-relative-root"]');if(!i)return"/";let{pathname:r}=new URL(i.content,e.getHref());return r.replace(/\/*$/,"/")}getAbsPathnameWithAppRoot(e){return this.appRoot.slice(0,-1)+e}getAppRootlessPathname(e){return e.startsWith(this.appRoot)?"/"+e.slice(this.appRoot.length):e}}return n.\u0275fac=function(e){return new(e||n)(j(Nm))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),X_=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[Nm]}),n})(),Q_=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[Lm],imports:[X_]}),n})(),m4=new pe("[App Routing] Dirty Updates"),AA=(()=>{class n{constructor(e){this.dirtyUpdatesSelectorFactories=e}getDirtyUpdatesSelectors(){return this.dirtyUpdatesSelectorFactories??[]}static registerDirtyUpdates(e){return{ngModule:n,providers:[{provide:m4,multi:!0,useFactory:e}]}}}return n.\u0275fac=function(e){return new(e||n)(j(m4,8))},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),GJ=be("[App Routing] Discarding Unsaved Updates"),K_=be("[App Routing] State Rehydrated From Url",{_as:"props",_p:void 0}),IA=be("[App Routing] Route Config Loaded",{_as:"props",_p:void 0}),g4=be("[App Routing] In App Navigation Requested",{_as:"props",_p:void 0}),PA=be("[App Routing] In App Navigating",{_as:"props",_p:void 0}),Jl=be("[App Routing] In App Navigated",{_as:"props",_p:void 0}),_4=new pe("[App Routing] Programmatical Navigation Provider"),RA=(()=>{class n{constructor(e){this.providers=new Map;for(let i of e||[]){if(this.providers.has(i.actionCreator.type))throw new RangeError(`"${i.actionCreator.type}" is already registered for nav. Multiple navigations on same kick is not allowed.`);this.providers.set(i.actionCreator.type,i.lambda)}}getNavigation(e){let i=this.providers.get(e.type);return i?i(e):null}static registerProgrammaticalNavigation(e){return{ngModule:n,providers:[{provide:_4,multi:!0,useFactory:e}]}}}return n.\u0275fac=function(e){return new(e||n)(j(_4,8))},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})();function EM(n){return null!=n.routeKind}function b4(n){return XJ(n).map(e=>{let i=e.startsWith(":");return i?{pathPart:e,isParam:!0,paramName:e.slice(1)}:{pathPart:e,isParam:i}})}var Z_=class{constructor(t){this.validateConfig(t),this.pathFragments=b4(t.path),this.pathMatchers=this.getPathMatchers(this.pathFragments)}static getMatcher(t){return EM(t)?new TM(t):function(n){return void 0!==n.redirectionPath}(t)?new v4(t):new y4(t)}validateConfig({path:t}){if(!t.startsWith("/"))throw new RangeError(`config.path should start with '/'. ${t}`);let e=0;for(;(e=t.indexOf(":",e+1))>=0;){if("/"!==t[e-1])throw new RangeError(`config.path parameter should come after '/'. ${t}`);if(void 0===t[e+1]||"/"===t[e+1])throw new RangeError(`config.path parameter should have non-empty name. ${t}`)}}getPathMatchers(t){return t.map(e=>{let{pathPart:i}=e;return e.isParam?r=>({isParamPathPart:!0,partMatched:!0,paramName:e.paramName,paramValue:r}):r=>({isParamPathPart:!1,partMatched:r===i})})}match(t){let e={};if(this.pathMatchers.length!==t.length)return{result:!1};let i=0;for(let r of this.pathMatchers){let s=r(t[i++]);if(!s.partMatched)return{result:!1};s.isParamPathPart&&(e={...e,[s.paramName]:s.paramValue})}return{result:!0,params:e,pathParts:t,isRedirection:!1,redirectionQueryParams:void 0}}matchByParams(t){return{result:!0,params:t,pathParts:this.reprojectPathByParams(this.pathFragments,t),isRedirection:!1,redirectionQueryParams:void 0}}reprojectPathByParams(t,e){let i=[];for(let r of t)if(r.isParam){let{paramName:o}=r;if(!e.hasOwnProperty(o))throw new RangeError(`Failed to reproject parameter. "${o}" parameter should be present.`);i.push(e[o])}else i.push(r.pathPart);return i}},TM=class extends Z_{constructor(t){super(t),this.definition=t}},v4=class extends Z_{constructor(t){super(t),this.definition=t,this.redirectionFragments=b4(t.redirectionPath)}match(t){let e=super.match(t);if(!e.result)return e;let i=this.reprojectPathByParams(this.redirectionFragments,e.params);return{result:!0,params:e.params,pathParts:i,isRedirection:!0,redirectionQueryParams:void 0}}},y4=class extends Z_{constructor(t){super(t),this.definition=t}match(t){let e=super.match(t);if(!e.result)return e;let{pathParts:i,queryParams:r}=this.definition.redirector(t);return{result:!0,params:e.params,pathParts:i,isRedirection:!0,redirectionQueryParams:r}}},DM=class{constructor(t,e=3){if(this.maxRedirection=e,e<0)throw new RangeError("maxRedirection has to be non-negative number");this.validateRouteConfigs(t),this.defaultRouteConfig=null,this.routeKindToConcreteConfigMatchers=new Map,this.configMatchers=[];for(let i of t){let r=Z_.getMatcher(i);this.configMatchers.push(r),r instanceof TM&&(this.routeKindToConcreteConfigMatchers.set(r.definition.routeKind,r),r.definition.defaultRoute&&(this.defaultRouteConfig=r))}}validateRouteConfigs(t){let e=t.filter(EM),i=e.filter(o=>o.defaultRoute);if(i.length>1){let o=i.map(({path:s})=>s).join(", ");throw new RangeError(`There are more than one defaultRoutes. ${o}`)}if(1===i.length){let{path:o}=i[0];if(Boolean(b4(o).find(({isParam:a})=>a)))throw new RangeError(`A defaultRoute cannot have any params. ${o}`)}let r=new Set;for(let{routeKind:o}of e){if(r.has(o))throw new RangeError(`Multiple route configuration for kind: ${o}. Configurations should have unique routeKinds`);r.add(o)}}generateAction(t,e){return t.actionGenerator?t.actionGenerator(e):null}match(t){if(!t.pathname.startsWith("/"))throw new RangeError('Navigation has to made with pathname that starts with "/"');let o,e=XJ(t.pathname),i=0,r=!1;for(;;){let s=!1;for(let a of this.configMatchers){let l=a.match(e);if(l.result){s=!0;let{params:c,pathParts:u,isRedirection:d}=l;if(d){e=u,r=!0,o=l.redirectionQueryParams;break}if(!(a instanceof TM))throw new RangeError("No concrete route definition `match` return redirection");let{definition:p}=a,h={routeKind:p.routeKind,params:c,pathname:YJ(u),deepLinkProvider:p.deepLinkProvider||null,action:this.generateAction(p,u)};return r?{...h,originateFromRedirection:!0,redirectionOnlyQueryParams:o}:{...h,originateFromRedirection:!1}}}if(r&&i++,!s||i>this.maxRedirection)break}if(i>this.maxRedirection)throw new Error(`Potential redirection loop (redirecting more than ${this.maxRedirection} times. Please do not have cycles in the routes.`);if(this.defaultRouteConfig){let{definition:s}=this.defaultRouteConfig;return{routeKind:s.routeKind,deepLinkProvider:s.deepLinkProvider??null,pathname:s.path,params:{},originateFromRedirection:!0,redirectionOnlyQueryParams:void 0,action:this.generateAction(s,e)}}return null}matchByRouteKind(t,e){let i=this.routeKindToConcreteConfigMatchers.get(t);if(!i)throw new RangeError(`Requires configuration for routeKind: ${t}`);let r=i.matchByParams(e);return{routeKind:t,params:e,pathname:YJ(r.pathParts),deepLinkProvider:i.definition.deepLinkProvider||null,originateFromRedirection:!1,action:this.generateAction(i.definition,r.pathParts)}}};function XJ(n){return n.split("/").slice(1)}function YJ(n){return"/"+n.join("/")}var x4=new pe("[App Routing] Route Config"),qc=(()=>{class n{constructor(e){if(this.routeKindToNgComponent=new Map,!e)return void(this.routeConfigs=new DM([]));let i=[];for(let r of e)for(let o of r)i.push(o);this.routeConfigs=new DM(i),i.forEach(r=>{EM(r)&&this.routeKindToNgComponent.set(r.routeKind,r.ngComponent)})}getRegisteredRouteKinds(){return this.routeKindToNgComponent.keys()}getRouteConfigs(){return this.routeConfigs}getNgComponentByRouteKind(e){return this.routeKindToNgComponent.get(e)||null}static registerRoutes(e){return{ngModule:n,providers:[{provide:x4,multi:!0,useFactory:e}]}}}return n.\u0275fac=function(e){return new(e||n)(j(x4,8))},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),OA="app_routing",AM=Mr(OA),Ra=J(AM,n=>n.activeRoute),ZJ=J(AM,n=>n.nextRoute),JJ=J(AM,n=>n.activeNamespaceId),$J=J(AM,n=>n.rehydratedDeepLinks),e$=J(AM,n=>n.registeredRouteKeys),qu=J(Ra,n=>n?n.routeKind:hi.NOT_SET),M4=J(Ra,n=>n?n.params:{}),Wo=J(qu,M4,(n,t)=>wM(n,t)),Yu=(J(qu,M4,(n,t)=>{if(n!==hi.COMPARE_EXPERIMENT)return{};let i=function(n){let t=new Map,e=SM(n.experimentIds);for(let{id:i,name:r}of e)r&&t.set(i,r);return t}(t);return Object.fromEntries(i.entries())}),J(qu,M4,(n,t)=>{if(n!==hi.COMPARE_EXPERIMENT)return{};let i=function(n){let t=new Map,e=SM(n.experimentIds),i=0;for(let{id:r,name:o}of e)i++,!t.has(r)&&t.set(r,{aliasText:o,aliasNumber:i});return t}(t);return Object.fromEntries(i.entries())})),w4=be("[App Routing] Effects Init"),sa=(()=>(function(n){n[n.UNCHANGED=0]="UNCHANGED",n[n.NEW=1]="NEW",n[n.FROM_HISTORY=2]="FROM_HISTORY"}(sa||(sa={})),sa))(),t$=(()=>{class n{constructor(e,i,r,o,s,a,l){this.actions$=e,this.store=i,this.location=r,this.dirtyUpdatesRegistry=o,this.registry=s,this.programmaticalNavModule=a,this.appRootProvider=l,this.onNavigationRequested$=this.actions$.pipe(ii(g4),L(c=>({pathname:c.pathname.startsWith("/")?this.appRootProvider.getAbsPathnameWithAppRoot(c.pathname):this.location.getResolvedPath(c.pathname),options:{browserInitiated:!1,replaceState:c.replaceState??!1,namespaceUpdate:{option:c.resetNamespacedState?sa.NEW:sa.UNCHANGED}}}))),this.bootstrapReducers$=cr(()=>this.actions$.pipe(ii(w4),L(()=>IA({routeKinds:new Set(this.registry.getRegisteredRouteKinds())})))),this.onInit$=this.actions$.pipe(ii(w4)).pipe(Ol(0),L(()=>{let c=this.location.getHistoryState()?.namespaceId,u=void 0===c?{option:sa.NEW}:{option:sa.FROM_HISTORY,namespaceId:c};return{pathname:this.location.getPath(),options:{browserInitiated:!0,replaceState:!0,namespaceUpdate:u}}})),this.onPopState$=this.location.onPopState().pipe(L(c=>({pathname:c.pathname,options:{browserInitiated:!0,replaceState:!0,namespaceUpdate:void 0===c.state?.namespaceId?{option:sa.UNCHANGED}:{option:sa.FROM_HISTORY,namespaceId:c.state.namespaceId}}}))),this.userInitNavRoute$=Jt(this.onNavigationRequested$,this.onInit$,this.onPopState$).pipe(L(c=>{if(!c.pathname.startsWith("/"))throw new Error(`[App routing] pathname must start with '/'. Got: ${c.pathname}`);return{...c,pathname:this.appRootProvider.getAppRootlessPathname(c.pathname)}}),L(c=>({routeMatch:this.routeConfigs.match(c),options:c.options}))),this.programmaticalNavRoute$=this.actions$.pipe(L(c=>this.programmaticalNavModule.getNavigation(c)),Ye(c=>null!==c),L(c=>{let f,u=c,{replaceState:d=!1,resetNamespacedState:p,routeKind:h}=u;return f=u.routeKind===hi.COMPARE_EXPERIMENT?{experimentIds:VJ(u.routeParams.aliasAndExperimentIds)}:u.routeParams,{replaceState:d,routeKind:h,routeParams:f,resetNamespacedState:p}}),L(({replaceState:c,routeKind:u,routeParams:d,resetNamespacedState:p})=>({routeMatch:this.routeConfigs?this.routeConfigs.matchByRouteKind(u,d):null,options:{replaceState:c,browserInitiated:!1,namespaceUpdate:{option:p?sa.NEW:sa.UNCHANGED}}}))),this.validatedRouteMatch$=Jt(this.userInitNavRoute$,this.programmaticalNavRoute$).pipe(Ye(({routeMatch:c})=>Boolean(c)),L(({routeMatch:c,options:u})=>({routeMatch:c,options:u}))),this.navigate$=cr(()=>this.validatedRouteMatch$.pipe(Wt(this.store.select(Ra)),xn(([d,p])=>{let h=null!==p&&Ps(p,d.routeMatch),f=this.dirtyUpdatesRegistry.getDirtyUpdatesSelectors();return h||!f.length?Xt(d):lr(this.dirtyUpdatesRegistry.getDirtyUpdatesSelectors().map(m=>this.store.select(m).pipe(Qt(1)))).pipe(L(m=>void 0!==m[0].experimentIds&&m[0].experimentIds.length>0),Ye(m=>{if(m){let x=window.confirm("You have unsaved edits, are you sure you want to discard them?");return x&&this.store.dispatch(GJ()),x}return!0}),L(()=>d))}),Wt(this.store.select($J)),kt(([{routeMatch:d,options:p},h])=>{if(!p.browserInitiated||!d.deepLinkProvider||p.namespaceUpdate.option===sa.FROM_HISTORY&&!DA(d.routeKind,p.namespaceUpdate.namespaceId,h))return;let f=d.originateFromRedirection&&d.redirectionOnlyQueryParams?d.redirectionOnlyQueryParams:this.location.getSearch(),m=d.deepLinkProvider.deserializeQueryParams(f);this.store.dispatch(K_({routeKind:d.routeKind,partialState:m}))}),kt(([{routeMatch:d}])=>{d.action&&this.store.dispatch(d.action)}),ui(([{routeMatch:d,options:p}])=>null===d.deepLinkProvider?Xt({route:{routeKind:d.routeKind,params:d.params},pathname:d.pathname,queryParams:[],options:p}):d.deepLinkProvider.serializeStateToQueryParams(this.store).pipe(L((h,f)=>({route:{routeKind:d.routeKind,params:d.params},pathname:d.pathname,queryParams:h,options:0===f?p:{...p,namespaceUpdate:{option:sa.UNCHANGED},replaceState:!0}})))),kt(({route:d})=>{this.store.dispatch(PA({after:d}))}),Hr(0)).pipe(Wt(this.store.select(Ra)),L(([d,p])=>{let h=null===p||null===d.route||Ps(p,d.route);return{...d,preserveHash:h}}),kt(({preserveHash:d,pathname:p,queryParams:h,options:f})=>{(function(n,t){return n.pathname===t.pathname&&n.queryParams.length===t.queryParams.length&&n.queryParams.every((e,i)=>{let r=t.queryParams[i];return e.key===r.key&&e.value===r.value})})({pathname:p,queryParams:h},{pathname:this.appRootProvider.getAppRootlessPathname(this.location.getPath()),queryParams:this.location.getSearch()})||(f.replaceState?this.location.replaceStateUrl(this.appRootProvider.getAbsPathnameWithAppRoot(this.location.getFullPath(p,h,d))):this.location.pushStateUrl(this.appRootProvider.getAbsPathnameWithAppRoot(this.location.getFullPath(p,h,d))))})).pipe(Wt(this.store.select(Ra),this.store.select(JJ)),L(([{route:d,options:p},h,f])=>{let m=function(n,t,e){return t.namespaceUpdate.option===sa.FROM_HISTORY?t.namespaceUpdate.namespaceId:null==e||t.namespaceUpdate.option===sa.NEW?`${Date.now().toString()}:${function(){let n=new Uint8Array(32);crypto.getRandomValues(n);let t="";for(let e of n)t+=(e>>4).toString(16);return t}()}`:e}(0,p,f);return this.location.replaceStateData({...this.location.getHistoryState(),namespaceId:m}),Jl({before:h,after:d,beforeNamespaceId:f,afterNamespaceId:m})}))),this.routeConfigs=s.getRouteConfigs()}ngrxOnInitEffects(){return w4()}}return n.\u0275fac=function(e){return new(e||n)(j(Po),j(Ce),j(Nm),j(AA),j(qc),j(RA),j(Lm))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),k2e=vr({activeRoute:null,nextRoute:null,activeNamespaceId:null,rehydratedDeepLinks:[],registeredRouteKeys:new Set},Se(PA,(n,{after:t})=>({...n,nextRoute:t})),Se(Jl,(n,{after:t,afterNamespaceId:e})=>{let i=n.rehydratedDeepLinks;return DA(t.routeKind,e,i)&&(i=[...i],i.push({deepLinkGroup:p4(t.routeKind),namespaceId:e})),{...n,activeRoute:t,nextRoute:null,activeNamespaceId:e,rehydratedDeepLinks:i}}),Se(IA,(n,{routeKinds:t})=>({...n,registeredRouteKeys:t})));function n$(n,t){return k2e(n,t)}var J_=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[AA,RA],imports:[qc,wr.forFeature(OA,n$),ro.forFeature([t$]),Q_,X_]}),n})(),i$="__tab__",r$=(()=>{class n{constructor(){this.tfStorage=document.createElement("tf-storage"),document.createElement("tf-globals").tf_globals.setUseHash(!0),this.tfStorage.tf_storage.migrateLegacyURLScheme()}getString(e){return this.tfStorage.tf_storage.getString(e)}setString(e,i,r){this.tfStorage.tf_storage.setString(e,i,r)}getPluginId(){return this.getString(i$)}setPluginId(e,i){this.setString(i$,e,i)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),fh=class{},S4=new pe("[Persistent Settings] Global Settings"),Sr=(()=>{class n{constructor(e){this.globalSettingSelectors=[],e&&(this.globalSettingSelectors=e.map(i=>i()))}getGlobalSettingSelectors(){return this.globalSettingSelectors??[]}static defineGlobalSetting(e){return{ngModule:n,providers:[{provide:S4,multi:!0,useValue:e}]}}}return n.\u0275fac=function(e){return new(e||n)(j(S4,8))},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),Oa=(()=>(function(n){n.BROWSER_DEFAULT="browser_default",n.LIGHT="light",n.DARK="dark"}(Oa||(Oa={})),Oa))(),o$="_tb_global_settings.timeseries",s$="_tb_global_settings",a$="notificationLastReadTimestamp",kA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),FA=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),E4=(()=>{class n extends FA{uiToBackend(e){let i={};return void 0!==e.ignoreOutliers&&(i.ignoreOutliers=e.ignoreOutliers),void 0!==e.scalarSmoothing&&(i.scalarSmoothing=e.scalarSmoothing),void 0!==e.tooltipSort&&(i.tooltipSort=e.tooltipSort),void 0!==e.autoReload&&(i.autoReload=e.autoReload),void 0!==e.autoReloadPeriodInMs&&(i.autoReloadPeriodInMs=e.autoReloadPeriodInMs),void 0!==e.pageSize&&(i.paginationSize=e.pageSize),void 0!==e.themeOverride&&(i.theme=e.themeOverride),void 0!==e.notificationLastReadTimeInMs&&(i.notificationLastReadTimeInMs=e.notificationLastReadTimeInMs),void 0!==e.sideBarWidthInPercent&&(i.sideBarWidthInPercent=e.sideBarWidthInPercent),void 0!==e.timeSeriesSettingsPaneOpened&&(i.timeSeriesSettingsPaneOpened=e.timeSeriesSettingsPaneOpened),void 0!==e.timeSeriesCardMinWidth&&(i.timeSeriesCardMinWidth=e.timeSeriesCardMinWidth),void 0!==e.stepSelectorEnabled&&(i.stepSelectorEnabled=e.stepSelectorEnabled),void 0!==e.rangeSelectionEnabled&&(i.rangeSelectionEnabled=e.rangeSelectionEnabled),void 0!==e.linkedTimeEnabled&&(i.linkedTimeEnabled=e.linkedTimeEnabled),i}backendToUi(e){let i={};return e.hasOwnProperty("scalarSmoothing")&&"number"==typeof e.scalarSmoothing&&(i.scalarSmoothing=e.scalarSmoothing),e.hasOwnProperty("ignoreOutliers")&&"boolean"==typeof e.ignoreOutliers&&(i.ignoreOutliers=e.ignoreOutliers),e.hasOwnProperty("tooltipSort")&&"string"==typeof e.tooltipSort&&(i.tooltipSort=e.tooltipSort),e.hasOwnProperty("autoReload")&&"boolean"==typeof e.autoReload&&(i.autoReload=e.autoReload),e.hasOwnProperty("autoReloadPeriodInMs")&&"number"==typeof e.autoReloadPeriodInMs&&(i.autoReloadPeriodInMs=e.autoReloadPeriodInMs),e.hasOwnProperty("paginationSize")&&"number"==typeof e.paginationSize&&(i.pageSize=e.paginationSize),e.hasOwnProperty("theme")&&"string"==typeof e.theme&&new Set(Object.values(Oa)).has(e.theme)&&(i.themeOverride=e.theme),e.hasOwnProperty("notificationLastReadTimeInMs")&&"number"==typeof e.notificationLastReadTimeInMs&&(i.notificationLastReadTimeInMs=e.notificationLastReadTimeInMs),e.hasOwnProperty("sideBarWidthInPercent")&&"number"==typeof e.sideBarWidthInPercent&&(i.sideBarWidthInPercent=e.sideBarWidthInPercent),e.hasOwnProperty("timeSeriesSettingsPaneOpened")&&"boolean"==typeof e.timeSeriesSettingsPaneOpened&&(i.timeSeriesSettingsPaneOpened=e.timeSeriesSettingsPaneOpened),e.hasOwnProperty("timeSeriesCardMinWidth")&&"number"==typeof e.timeSeriesCardMinWidth&&(i.timeSeriesCardMinWidth=e.timeSeriesCardMinWidth),e.hasOwnProperty("stepSelectorEnabled")&&"boolean"==typeof e.stepSelectorEnabled&&(i.stepSelectorEnabled=e.stepSelectorEnabled),e.hasOwnProperty("rangeSelectionEnabled")&&"boolean"==typeof e.rangeSelectionEnabled&&(i.rangeSelectionEnabled=e.rangeSelectionEnabled),e.hasOwnProperty("linkedTimeEnabled")&&"boolean"==typeof e.linkedTimeEnabled&&(i.linkedTimeEnabled=e.linkedTimeEnabled),i}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),l$=(()=>{class n{constructor(e){this.converter=e}setSettings(e){return Object.keys(e)?this.getSettings().pipe(kt(i=>{localStorage.setItem(s$,JSON.stringify(this.converter.uiToBackend({...i,...e}))),localStorage.removeItem(o$),localStorage.removeItem(a$)}),L(()=>{})):eo}deserialize(e){try{return JSON.parse(e)}catch{return{}}}getSettings(){let e=localStorage.getItem(a$);return Xt({...this.converter.backendToUi(this.deserialize(e?JSON.stringify({notificationLastReadTimeInMs:Number(e)}):"{}")),...this.converter.backendToUi(this.deserialize(localStorage.getItem(o$)??"{}")),...this.converter.backendToUi(this.deserialize(localStorage.getItem(s$)??"{}"))})}}return n.\u0275fac=function(e){return new(e||n)(j(FA))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),c$=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[{provide:kA,useClass:l$},E4,{provide:FA,useExisting:E4}]}),n})(),Yc=be("[Persistent Settings] Global Settings Loaded",{_as:"props",_p:void 0}),u$=be("[Persistent Settings] Effects Init"),d$=(()=>{class n{constructor(e,i,r,o){this.actions$=e,this.store=i,this.configModule=r,this.dataSource=o,this.initializeAndUpdateSettings$=cr(()=>{let s=this.actions$.pipe(ii(u$),xn(()=>this.dataSource.getSettings()),kt(a=>{this.store.dispatch(Yc({partialSettings:a}))}),Ol(0),xn(()=>Jt(...this.configModule.getGlobalSettingSelectors().map(l=>this.store.select(l).pipe(yi((c,u)=>{let d=Object.values(c),p=Object.values(u);return d.length===p.length&&d.every((h,f)=>h===p[f])}),Za(1))))),Ts());return s.pipe(function(n){return en((t,e)=>{let i=[];return t.subscribe(jt(e,r=>i.push(r),()=>{e.next(i),e.complete()})),n.subscribe(jt(e,()=>{let r=i;i=[],e.next(r)},Mc)),()=>{i=null}})}(s.pipe(Hr(500))),xn(a=>{let l={};for(let c of a)Object.assign(l,c);return this.dataSource.setSettings(l)}))},{dispatch:!1})}ngrxOnInitEffects(){return u$()}}return n.\u0275fac=function(e){return new(e||n)(j(Po),j(Ce),j(Sr),j(kA))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),T4=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[Sr],imports:[ro.forFeature([d$]),c$]}),n})(),LA=class{},BA=class{},hl=class{constructor(t){this.normalizedNames=new Map,this.lazyUpdate=null,t?this.lazyInit="string"==typeof t?()=>{this.headers=new Map,t.split("\n").forEach(e=>{let i=e.indexOf(":");if(i>0){let r=e.slice(0,i),o=r.toLowerCase(),s=e.slice(i+1).trim();this.maybeSetNormalizedName(r,o),this.headers.has(o)?this.headers.get(o).push(s):this.headers.set(o,[s])}})}:()=>{this.headers=new Map,Object.keys(t).forEach(e=>{let i=t[e],r=e.toLowerCase();"string"==typeof i&&(i=[i]),i.length>0&&(this.headers.set(r,i),this.maybeSetNormalizedName(e,r))})}:this.headers=new Map}has(t){return this.init(),this.headers.has(t.toLowerCase())}get(t){this.init();let e=this.headers.get(t.toLowerCase());return e&&e.length>0?e[0]:null}keys(){return this.init(),Array.from(this.normalizedNames.values())}getAll(t){return this.init(),this.headers.get(t.toLowerCase())||null}append(t,e){return this.clone({name:t,value:e,op:"a"})}set(t,e){return this.clone({name:t,value:e,op:"s"})}delete(t,e){return this.clone({name:t,value:e,op:"d"})}maybeSetNormalizedName(t,e){this.normalizedNames.has(e)||this.normalizedNames.set(e,t)}init(){this.lazyInit&&(this.lazyInit instanceof hl?this.copyFrom(this.lazyInit):this.lazyInit(),this.lazyInit=null,this.lazyUpdate&&(this.lazyUpdate.forEach(t=>this.applyUpdate(t)),this.lazyUpdate=null))}copyFrom(t){t.init(),Array.from(t.headers.keys()).forEach(e=>{this.headers.set(e,t.headers.get(e)),this.normalizedNames.set(e,t.normalizedNames.get(e))})}clone(t){let e=new hl;return e.lazyInit=this.lazyInit&&this.lazyInit instanceof hl?this.lazyInit:this,e.lazyUpdate=(this.lazyUpdate||[]).concat([t]),e}applyUpdate(t){let e=t.name.toLowerCase();switch(t.op){case"a":case"s":let i=t.value;if("string"==typeof i&&(i=[i]),0===i.length)return;this.maybeSetNormalizedName(t.name,e);let r=("a"===t.op?this.headers.get(e):void 0)||[];r.push(...i),this.headers.set(e,r);break;case"d":let o=t.value;if(o){let s=this.headers.get(e);if(!s)return;s=s.filter(a=>-1===o.indexOf(a)),0===s.length?(this.headers.delete(e),this.normalizedNames.delete(e)):this.headers.set(e,s)}else this.headers.delete(e),this.normalizedNames.delete(e)}}forEach(t){this.init(),Array.from(this.normalizedNames.keys()).forEach(e=>t(this.normalizedNames.get(e),this.headers.get(e)))}},V2e=/%(\d[a-f0-9])/gi,H2e={40:"@","3A":":",24:"$","2C":",","3B":";","3D":"=","3F":"?","2F":"/"};function p$(n){return encodeURIComponent(n).replace(V2e,(t,e)=>H2e[e]??t)}function NA(n){return`${n}`}var Xu=class{constructor(t={}){if(this.updates=null,this.cloneFrom=null,this.encoder=t.encoder||new class{encodeKey(t){return p$(t)}encodeValue(t){return p$(t)}decodeKey(t){return decodeURIComponent(t)}decodeValue(t){return decodeURIComponent(t)}},t.fromString){if(t.fromObject)throw new Error("Cannot specify both fromString and fromObject.");this.map=function(n,t){let e=new Map;return n.length>0&&n.replace(/^\?/,"").split("&").forEach(r=>{let o=r.indexOf("="),[s,a]=-1==o?[t.decodeKey(r),""]:[t.decodeKey(r.slice(0,o)),t.decodeValue(r.slice(o+1))],l=e.get(s)||[];l.push(a),e.set(s,l)}),e}(t.fromString,this.encoder)}else t.fromObject?(this.map=new Map,Object.keys(t.fromObject).forEach(e=>{let i=t.fromObject[e],r=Array.isArray(i)?i.map(NA):[NA(i)];this.map.set(e,r)})):this.map=null}has(t){return this.init(),this.map.has(t)}get(t){this.init();let e=this.map.get(t);return e?e[0]:null}getAll(t){return this.init(),this.map.get(t)||null}keys(){return this.init(),Array.from(this.map.keys())}append(t,e){return this.clone({param:t,value:e,op:"a"})}appendAll(t){let e=[];return Object.keys(t).forEach(i=>{let r=t[i];Array.isArray(r)?r.forEach(o=>{e.push({param:i,value:o,op:"a"})}):e.push({param:i,value:r,op:"a"})}),this.clone(e)}set(t,e){return this.clone({param:t,value:e,op:"s"})}delete(t,e){return this.clone({param:t,value:e,op:"d"})}toString(){return this.init(),this.keys().map(t=>{let e=this.encoder.encodeKey(t);return this.map.get(t).map(i=>e+"="+this.encoder.encodeValue(i)).join("&")}).filter(t=>""!==t).join("&")}clone(t){let e=new Xu({encoder:this.encoder});return e.cloneFrom=this.cloneFrom||this,e.updates=(this.updates||[]).concat(t),e}init(){null===this.map&&(this.map=new Map),null!==this.cloneFrom&&(this.cloneFrom.init(),this.cloneFrom.keys().forEach(t=>this.map.set(t,this.cloneFrom.map.get(t))),this.updates.forEach(t=>{switch(t.op){case"a":case"s":let e=("a"===t.op?this.map.get(t.param):void 0)||[];e.push(NA(t.value)),this.map.set(t.param,e);break;case"d":if(void 0===t.value){this.map.delete(t.param);break}{let i=this.map.get(t.param)||[],r=i.indexOf(NA(t.value));-1!==r&&i.splice(r,1),i.length>0?this.map.set(t.param,i):this.map.delete(t.param)}}}),this.cloneFrom=this.updates=null)}};function h$(n){return typeof ArrayBuffer<"u"&&n instanceof ArrayBuffer}function f$(n){return typeof Blob<"u"&&n instanceof Blob}function m$(n){return typeof FormData<"u"&&n instanceof FormData}var Bm=class{constructor(t,e,i,r){let o;if(this.url=e,this.body=null,this.reportProgress=!1,this.withCredentials=!1,this.responseType="json",this.method=t.toUpperCase(),function(n){switch(n){case"DELETE":case"GET":case"HEAD":case"OPTIONS":case"JSONP":return!1;default:return!0}}(this.method)||r?(this.body=void 0!==i?i:null,o=r):o=i,o&&(this.reportProgress=!!o.reportProgress,this.withCredentials=!!o.withCredentials,o.responseType&&(this.responseType=o.responseType),o.headers&&(this.headers=o.headers),o.context&&(this.context=o.context),o.params&&(this.params=o.params)),this.headers||(this.headers=new hl),this.context||(this.context=new class{constructor(){this.map=new Map}set(t,e){return this.map.set(t,e),this}get(t){return this.map.has(t)||this.map.set(t,t.defaultValue()),this.map.get(t)}delete(t){return this.map.delete(t),this}has(t){return this.map.has(t)}keys(){return this.map.keys()}}),this.params){let s=this.params.toString();if(0===s.length)this.urlWithParams=e;else{let a=e.indexOf("?");this.urlWithParams=e+(-1===a?"?":a<e.length-1?"&":"")+s}}else this.params=new Xu,this.urlWithParams=e}serializeBody(){return null===this.body?null:h$(this.body)||f$(this.body)||m$(this.body)||function(n){return typeof URLSearchParams<"u"&&n instanceof URLSearchParams}(this.body)||"string"==typeof this.body?this.body:this.body instanceof Xu?this.body.toString():"object"==typeof this.body||"boolean"==typeof this.body||Array.isArray(this.body)?JSON.stringify(this.body):this.body.toString()}detectContentTypeHeader(){return null===this.body||m$(this.body)?null:f$(this.body)?this.body.type||null:h$(this.body)?null:"string"==typeof this.body?"text/plain":this.body instanceof Xu?"application/x-www-form-urlencoded;charset=UTF-8":"object"==typeof this.body||"number"==typeof this.body||"boolean"==typeof this.body?"application/json":null}clone(t={}){let e=t.method||this.method,i=t.url||this.url,r=t.responseType||this.responseType,o=void 0!==t.body?t.body:this.body,s=void 0!==t.withCredentials?t.withCredentials:this.withCredentials,a=void 0!==t.reportProgress?t.reportProgress:this.reportProgress,l=t.headers||this.headers,c=t.params||this.params,u=t.context??this.context;return void 0!==t.setHeaders&&(l=Object.keys(t.setHeaders).reduce((d,p)=>d.set(p,t.setHeaders[p]),l)),t.setParams&&(c=Object.keys(t.setParams).reduce((d,p)=>d.set(p,t.setParams[p]),c)),new Bm(e,i,o,{params:c,headers:l,context:u,reportProgress:a,responseType:r,withCredentials:s})}},mh=(()=>(function(n){n[n.Sent=0]="Sent",n[n.UploadProgress=1]="UploadProgress",n[n.ResponseHeader=2]="ResponseHeader",n[n.DownloadProgress=3]="DownloadProgress",n[n.Response=4]="Response",n[n.User=5]="User"}(mh||(mh={})),mh))(),PM=class{constructor(t,e=200,i="OK"){this.headers=t.headers||new hl,this.status=void 0!==t.status?t.status:e,this.statusText=t.statusText||i,this.url=t.url||null,this.ok=this.status>=200&&this.status<300}},RM=class extends PM{constructor(t={}){super(t),this.type=mh.ResponseHeader}clone(t={}){return new RM({headers:t.headers||this.headers,status:void 0!==t.status?t.status:this.status,statusText:t.statusText||this.statusText,url:t.url||this.url||void 0})}},$_=class extends PM{constructor(t={}){super(t),this.type=mh.Response,this.body=void 0!==t.body?t.body:null}clone(t={}){return new $_({body:void 0!==t.body?t.body:this.body,headers:t.headers||this.headers,status:void 0!==t.status?t.status:this.status,statusText:t.statusText||this.statusText,url:t.url||this.url||void 0})}},np=class extends PM{constructor(t){super(t,0,"Unknown Error"),this.name="HttpErrorResponse",this.ok=!1,this.message=this.status>=200&&this.status<300?`Http failure during parsing for ${t.url||"(unknown url)"}`:`Http failure response for ${t.url||"(unknown url)"}: ${t.status} ${t.statusText}`,this.error=t.error||null}};function D4(n,t){return{body:t,headers:n.headers,context:n.context,observe:n.observe,params:n.params,reportProgress:n.reportProgress,responseType:n.responseType,withCredentials:n.withCredentials}}var Vm=(()=>{class n{constructor(e){this.handler=e}request(e,i,r={}){let o;if(e instanceof Bm)o=e;else{let l,c;l=r.headers instanceof hl?r.headers:new hl(r.headers),r.params&&(c=r.params instanceof Xu?r.params:new Xu({fromObject:r.params})),o=new Bm(e,i,void 0!==r.body?r.body:null,{headers:l,context:r.context,params:c,reportProgress:r.reportProgress,responseType:r.responseType||"json",withCredentials:r.withCredentials})}let s=Xt(o).pipe(function(n,t){return En(t)?xn(n,t,1):xn(n,1)}(l=>this.handler.handle(l)));if(e instanceof Bm||"events"===r.observe)return s;let a=s.pipe(Ye(l=>l instanceof $_));switch(r.observe||"body"){case"body":switch(o.responseType){case"arraybuffer":return a.pipe(L(l=>{if(null!==l.body&&!(l.body instanceof ArrayBuffer))throw new Error("Response is not an ArrayBuffer.");return l.body}));case"blob":return a.pipe(L(l=>{if(null!==l.body&&!(l.body instanceof Blob))throw new Error("Response is not a Blob.");return l.body}));case"text":return a.pipe(L(l=>{if(null!==l.body&&"string"!=typeof l.body)throw new Error("Response is not a string.");return l.body}));default:return a.pipe(L(l=>l.body))}case"response":return a;default:throw new Error(`Unreachable: unhandled observe type ${r.observe}}`)}}delete(e,i={}){return this.request("DELETE",e,i)}get(e,i={}){return this.request("GET",e,i)}head(e,i={}){return this.request("HEAD",e,i)}jsonp(e,i){return this.request("JSONP",e,{params:(new Xu).append(i,"JSONP_CALLBACK"),observe:"body",responseType:"json"})}options(e,i={}){return this.request("OPTIONS",e,i)}patch(e,i,r={}){return this.request("PATCH",e,D4(r,i))}post(e,i,r={}){return this.request("POST",e,D4(r,i))}put(e,i,r={}){return this.request("PUT",e,D4(r,i))}}return n.\u0275fac=function(e){return new(e||n)(j(LA))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),HA=new pe("HTTP_INTERCEPTORS"),j2e=(()=>{class n{intercept(e,i){return i.handle(e)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),G2e=/^\)\]\}',?\n/,g$=(()=>{class n{constructor(e){this.xhrFactory=e}handle(e){if("JSONP"===e.method)throw new Error("Attempted to construct Jsonp request without HttpClientJsonpModule installed.");return new un(i=>{let r=this.xhrFactory.build();if(r.open(e.method,e.urlWithParams),e.withCredentials&&(r.withCredentials=!0),e.headers.forEach((h,f)=>r.setRequestHeader(h,f.join(","))),e.headers.has("Accept")||r.setRequestHeader("Accept","application/json, text/plain, */*"),!e.headers.has("Content-Type")){let h=e.detectContentTypeHeader();null!==h&&r.setRequestHeader("Content-Type",h)}if(e.responseType){let h=e.responseType.toLowerCase();r.responseType="json"!==h?h:"text"}let o=e.serializeBody(),s=null,a=()=>{if(null!==s)return s;let h=r.statusText||"OK",f=new hl(r.getAllResponseHeaders()),m=function(n){return"responseURL"in n&&n.responseURL?n.responseURL:/^X-Request-URL:/m.test(n.getAllResponseHeaders())?n.getResponseHeader("X-Request-URL"):null}(r)||e.url;return s=new RM({headers:f,status:r.status,statusText:h,url:m}),s},l=()=>{let{headers:h,status:f,statusText:m,url:x}=a(),g=null;204!==f&&(g=typeof r.response>"u"?r.responseText:r.response),0===f&&(f=g?200:0);let b=f>=200&&f<300;if("json"===e.responseType&&"string"==typeof g){let D=g;g=g.replace(G2e,"");try{g=""!==g?JSON.parse(g):null}catch(T){g=D,b&&(b=!1,g={error:T,text:g})}}b?(i.next(new $_({body:g,headers:h,status:f,statusText:m,url:x||void 0})),i.complete()):i.error(new np({error:g,headers:h,status:f,statusText:m,url:x||void 0}))},c=h=>{let{url:f}=a(),m=new np({error:h,status:r.status||0,statusText:r.statusText||"Unknown Error",url:f||void 0});i.error(m)},u=!1,d=h=>{u||(i.next(a()),u=!0);let f={type:mh.DownloadProgress,loaded:h.loaded};h.lengthComputable&&(f.total=h.total),"text"===e.responseType&&!!r.responseText&&(f.partialText=r.responseText),i.next(f)},p=h=>{let f={type:mh.UploadProgress,loaded:h.loaded};h.lengthComputable&&(f.total=h.total),i.next(f)};return r.addEventListener("load",l),r.addEventListener("error",c),r.addEventListener("timeout",c),r.addEventListener("abort",c),e.reportProgress&&(r.addEventListener("progress",d),null!==o&&r.upload&&r.upload.addEventListener("progress",p)),r.send(o),i.next({type:mh.Sent}),()=>{r.removeEventListener("error",c),r.removeEventListener("abort",c),r.removeEventListener("load",l),r.removeEventListener("timeout",c),e.reportProgress&&(r.removeEventListener("progress",d),null!==o&&r.upload&&r.upload.removeEventListener("progress",p)),r.readyState!==r.DONE&&r.abort()}})}}return n.\u0275fac=function(e){return new(e||n)(j(Em))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),O4=new pe("XSRF_COOKIE_NAME"),k4=new pe("XSRF_HEADER_NAME"),VA=class{},q2e=(()=>{class n{constructor(e,i,r){this.doc=e,this.platform=i,this.cookieName=r,this.lastCookieString="",this.lastToken=null,this.parseCount=0}getToken(){if("server"===this.platform)return null;let e=this.doc.cookie||"";return e!==this.lastCookieString&&(this.parseCount++,this.lastToken=qD(e,this.cookieName),this.lastCookieString=e),this.lastToken}}return n.\u0275fac=function(e){return new(e||n)(j(Ht),j(Gd),j(O4))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),A4=(()=>{class n{constructor(e,i){this.tokenService=e,this.headerName=i}intercept(e,i){let r=e.url.toLowerCase();if("GET"===e.method||"HEAD"===e.method||r.startsWith("http://")||r.startsWith("https://"))return i.handle(e);let o=this.tokenService.getToken();return null!==o&&!e.headers.has(this.headerName)&&(e=e.clone({headers:e.headers.set(this.headerName,o)})),i.handle(e)}}return n.\u0275fac=function(e){return new(e||n)(j(VA),j(k4))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),Y2e=(()=>{class n{constructor(e,i){this.backend=e,this.injector=i,this.chain=null}handle(e){if(null===this.chain){let i=this.injector.get(HA,[]);this.chain=i.reduceRight((r,o)=>new class{constructor(t,e){this.next=t,this.interceptor=e}handle(t){return this.interceptor.intercept(t,this.next)}}(r,o),this.backend)}return this.chain.handle(e)}}return n.\u0275fac=function(e){return new(e||n)(j(BA),j(Xn))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),X2e=(()=>{class n{static disable(){return{ngModule:n,providers:[{provide:A4,useClass:j2e}]}}static withOptions(e={}){return{ngModule:n,providers:[e.cookieName?{provide:O4,useValue:e.cookieName}:[],e.headerName?{provide:k4,useValue:e.headerName}:[]]}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[A4,{provide:HA,useExisting:A4,multi:!0},{provide:VA,useClass:q2e},{provide:O4,useValue:"XSRF-TOKEN"},{provide:k4,useValue:"X-XSRF-TOKEN"}]}),n})(),_$=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[Vm,{provide:LA,useClass:Y2e},g$,{provide:BA,useExisting:g$}],imports:[X2e.withOptions({cookieName:"XSRF-TOKEN",headerName:"X-XSRF-TOKEN"})]}),n})(),UA="feature",ev=Mr(UA),gh=J(ev,n=>n.isFeatureFlagsLoaded),bs=J(ev,n=>({...n.defaultFlags,...n.flagOverrides})),y$=J(ev,n=>n.defaultFlags),zA=J(ev,n=>n.flagOverrides||{}),Hm=J(ev,n=>n.metadata),jA=J(ev,n=>{let t={};for(let e in n.flagOverrides){let i=n.metadata[e];i&&i.queryParamOverride&&i.sendToServerWhenOverridden&&(t[e]=n.flagOverrides[e])}return t}),b$=J(bs,n=>n.isAutoDarkModeAllowed),Qu=J(bs,n=>null!==n.enableDarkModeOverride?n.enableDarkModeOverride:n.defaultEnableDarkMode),GA=J(bs,n=>n.enableDarkModeOverride),x$=J(bs,n=>n.enabledExperimentalPlugins),C$=J(bs,n=>n.inColab),WA=J(bs,n=>n.metricsImageSupportEnabled),M$=J(bs,n=>n.enabledLinkedTime),w$=J(bs,n=>n.forceSvg),S$=J(bs,n=>n.enabledScalarDataTable),E$=J(bs,n=>n.enableShowFlags),T$=J(bs,n=>n.allowRangeSelection),D$=J(bs,n=>n.enabledProspectiveFob),qA=J(bs,n=>n.enableScalarColumnCustomization);function Q2e(n){let t={};for(let[e,i]of n.entries())t[e]=i;return t}function F4(n){let t=n.headers||new hl;return t=t.append("X-XSRF-Protected","1"),{...n,headers:t}}var ka=(()=>{class n{constructor(e,i,r){this.appRootProvider=e,this.http=i,this.store=r}resolveAppRoot(e){return e.startsWith("/")?this.appRootProvider.getAbsPathnameWithAppRoot(e):e}get(e,i={}){return this.http.get(this.resolveAppRoot(e),i)}post(e,i,r={}){return r=F4(r),this.store.select(gh).pipe(Ye(o=>Boolean(o)),Qt(1),Wt(this.store.select(C$)),xn(([,o])=>{let s=this.resolveAppRoot(e);return o?this.http.get(s,{headers:r.headers??{},params:Q2e(i)}):this.http.post(s,i,r)}))}put(e,i,r={}){return this.http.put(this.resolveAppRoot(e),i,F4(r))}delete(e,i={}){return this.http.delete(this.resolveAppRoot(e),F4(i))}}return n.\u0275fac=function(e){return new(e||n)(j(Lm),j(Vm),j(Ce))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),Ku=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[ka],imports:[_$,Q_]}),n})(),$l=(()=>(function(n){n.UNKNOWN="UNKNOWN",n.NOT_FOUND="NOT_FOUND",n.PERMISSION_DENIED="PERMISSION_DENIED"}($l||($l={})),$l))(),A$=new pe("TensorBoard brand name"),Ro=(()=>(function(n){n.STEP="step",n.WALL_TIME="wall_time",n.RELATIVE="relative"}(Ro||(Ro={})),Ro))(),zr=(()=>(function(n){n.OFFSET="offset",n.OVERLAY="overlay"}(zr||(zr={})),zr))();function I$(n){let t=$l.UNKNOWN;return n instanceof np&&(404===n.status&&(t=$l.NOT_FOUND),403===n.status&&(t=$l.PERMISSION_DENIED)),wc(new OM(t))}var OM=class{constructor(t){this.failureCode=t}},YA=(()=>{class n{constructor(e){this.http=e,this.tfBackend=document.createElement("tf-backend").tf_backend}fetchPluginsListing(e){let i=function(n){if(!n.length)return null;let t=new URLSearchParams;for(let e of n)t.append("experimentalPlugin",e);return t}(e),r=i?`data/plugins_listing?${i.toString()}`:"data/plugins_listing";return this.http.get(r).pipe(fo(I$))}fetchEnvironment(){return lr([this.http.get("data/environment"),Eo(this.tfBackend.environmentStore.refresh())]).pipe(L(([r])=>r),fo(I$))}}return n.\u0275fac=function(e){return new(e||n)(j(ka))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),P$=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[YA],imports:[Ku]}),n})(),Oe=(()=>(function(n){n[n.NOT_LOADED=0]="NOT_LOADED",n[n.LOADED=1]="LOADED",n[n.LOADING=2]="LOADING",n[n.FAILED=3]="FAILED"}(Oe||(Oe={})),Oe))(),Zu=be("[Core] Plugin Changed",{_as:"props",_p:void 0}),XA=be("[Core] Plugin Url Hash Changed",{_as:"props",_p:void 0}),R$=be("[Core] Loaded"),Fa=be("[Core] User Triggered Reload"),aa=be("[Core] Auto Reload"),QA=be("[Core] PluginListing Fetch Requested"),Um=be("[Core] PluginListing Fetch Successful",{_as:"props",_p:void 0}),kM=be("[Core] PluginListing Fetch Failed",{_as:"props",_p:void 0}),KA=be("[Core] Polymer Component Runs Fetch Requested"),ZA=be("[Core] Polymer Component Runs Fetch Successful"),JA=be("[Core] Polymer Component Runs Fetch Failed"),$A=be("[Core] Environment Fetch Successful",{_as:"props",_p:void 0}),O$=be("[Core] Run Selection Changed",{_as:"props",_p:void 0}),k$=be("[Core] Run Fetch Successful",{_as:"props",_p:void 0}),nv=be("[Core] Side Bar Width Changed",{_as:"props",_p:void 0});function zm(n,t,e){let i=Object.keys(n),r={...n,...t,privateNamespacedState:{}};return{initialState:r,reducers:vr(r,Se(Jl,(a,{before:l,after:c,beforeNamespaceId:u,afterNamespaceId:d})=>{let p=a;return u!==d&&(p=function(a,l,c){let u={...a.privateNamespacedState};if(l){let p={};for(let h of i)p[h]=a[h];u={...u,[l]:p}}let d={};return a.privateNamespacedState?.[c]?d=a.privateNamespacedState[c]:l&&(d=n),{...a,...d,privateNamespacedState:u}}(a,u,d)),e&&(p=e(p,l,c)),p}))}}function jm(...n){return(t,e)=>{let i=t;for(let r of n)i=r(i,e);return i}}var FM={activePlugin:null,plugins:{},coreDataLoadState:{state:Oe.NOT_LOADED,lastLoadedTimeInMs:null},pluginsListLoaded:{state:Oe.NOT_LOADED,lastLoadedTimeInMs:null,failureCode:null},environment:{data_location:"",window_title:""},polymerRunsLoadState:{state:Oe.NOT_LOADED,lastLoadedTimeInMs:null},polymerInteropRuns:[],polymerInteropRunSelection:new Set,sideBarWidthInPercent:20},$2e=vr(FM,Se(Zu,XA,(n,{plugin:t})=>({...n,activePlugin:t})),Se(QA,n=>({...n,coreDataLoadState:{...n.coreDataLoadState,state:Oe.LOADING},pluginsListLoaded:{...n.pluginsListLoaded,state:Oe.LOADING}})),Se(kM,(n,{failureCode:t})=>({...n,coreDataLoadState:{...n.coreDataLoadState,state:Oe.FAILED},pluginsListLoaded:{...n.pluginsListLoaded,state:Oe.FAILED,failureCode:t}})),Se(Um,(n,{plugins:t})=>{let e=Object.keys(t).find(s=>t[s].enabled)||null,i=n.activePlugin||e,r=Date.now(),o=n.coreDataLoadState;return n.polymerRunsLoadState.state===Oe.LOADED&&(o={state:Oe.LOADED,lastLoadedTimeInMs:r}),{...n,activePlugin:i,coreDataLoadState:o,plugins:t,pluginsListLoaded:{state:Oe.LOADED,lastLoadedTimeInMs:r,failureCode:null}}}),Se(KA,n=>({...n,coreDataLoadState:{...n.coreDataLoadState,state:Oe.LOADING},polymerRunsLoadState:{...n.polymerRunsLoadState,state:Oe.LOADING}})),Se(ZA,n=>{let t=Date.now(),e=n.coreDataLoadState;return n.pluginsListLoaded.state===Oe.LOADED&&(e={state:Oe.LOADED,lastLoadedTimeInMs:t}),{...n,coreDataLoadState:e,polymerRunsLoadState:{...n.polymerRunsLoadState,state:Oe.LOADED,lastLoadedTimeInMs:t}}}),Se(JA,n=>({...n,coreDataLoadState:{...n.coreDataLoadState,state:Oe.FAILED},polymerRunsLoadState:{...n.polymerRunsLoadState,state:Oe.FAILED}})),Se($A,(n,{environment:t})=>({...n,environment:t})),Se(k$,(n,{runs:t})=>({...n,polymerInteropRuns:t})),Se(O$,(n,{nextSelection:t})=>({...n,polymerInteropRunSelection:new Set(t)})),Se(nv,(n,{widthInPercent:t})=>({...n,sideBarWidthInPercent:Math.min(Math.max(0,t),100)})),Se(Yc,(n,{partialSettings:t})=>{let e={...n},i=t.sideBarWidthInPercent;return"number"==typeof i&&i>=0&&i<=100&&(e.sideBarWidthInPercent=i),e})),{reducers:ePe}=zm(FM,{});function F$(n,t){return jm($2e,ePe)(n,t)}var _h=Mr("core"),nI=J(_h,n=>n.pluginsListLoaded),N$=J(_h,n=>n.polymerRunsLoadState),L$=J(_h,n=>n.coreDataLoadState.state),iv=J(_h,n=>n.coreDataLoadState.lastLoadedTimeInMs),Rs=J(_h,n=>n.activePlugin),rv=J(_h,n=>n.plugins),ov=J(_h,n=>n.environment),iI=J(_h,n=>n.sideBarWidthInPercent),B$=new Set([hi.COMPARE_EXPERIMENT,hi.EXPERIMENT,hi.NOT_SET]),V$=(()=>{class n{constructor(e,i,r){this.actions$=e,this.store=i,this.webappDataSource=r,this.tfBackend={ref:document.createElement("tf-backend").tf_backend},this.onDashboardLoad$=Jt(this.actions$.pipe(ii(R$,Jl),Wt(this.store.select(Ra)),yi(([,o],[,s])=>Ps(o,s))),this.actions$.pipe(ii(aa,Fa))).pipe(Wt(this.store.select(qu)),Ye(([,o])=>B$.has(o)),b0(1,void 0,{leading:!0})),this.fetchWebAppData$=cr(()=>{let o=this.onDashboardLoad$.pipe(Wt(this.store.select(nI),this.store.select(x$)),Ye(([,{state:a}])=>a!==Oe.LOADING),kt(()=>this.store.dispatch(QA())),xn(([,,a])=>function(...n){let t=vu(n),e=m1(n);return e.length?new un(i=>{let r=e.map(()=>[]),o=e.map(()=>!1);i.add(()=>{r=o=null});for(let s=0;!i.closed&&s<e.length;s++)gi(e[s]).subscribe(jt(i,a=>{if(r[s].push(a),r.every(l=>l.length)){let l=r.map(c=>c.shift());i.next(t?t(...l):l),r.some((c,u)=>!c.length&&o[u])&&i.complete()}},()=>{o[s]=!0,!r[s].length&&i.complete()}));return()=>{r=o=null}}):eo}(this.webappDataSource.fetchPluginsListing(a),this.fetchEnvironment()).pipe(L(([l])=>{this.store.dispatch(Um({plugins:l}))}),fo(l=>(this.store.dispatch(kM(l instanceof OM?{failureCode:l.failureCode}:{failureCode:$l.UNKNOWN})),eo)))));return Jt(o,this.onDashboardLoad$.pipe(L(([,a])=>a),ui(a=>a!==hi.COMPARE_EXPERIMENT?Xt([]):this.store.select(Yu).pipe(yi((l,c)=>{let u=Object.entries(l),d=new Map(Object.entries(c));if(u.length!==d.size)return!1;for(let[p,h]of u)if(!d.get(p)||d.get(p).aliasText!==h.aliasText||d.get(p).aliasNumber!==h.aliasNumber)return!1;return!0}),Ol(0),b0(500,void 0,{leading:!0,trailing:!0}))),Wt(this.store.select(qu),this.store.select(N$)),Ye(([,a,l])=>B$.has(a)&&l.state!==Oe.LOADING),kt(()=>{this.store.dispatch(KA())}),ui(()=>this.refreshPolymerRuns()),kt(()=>{this.store.dispatch(ZA())}),fo(()=>(this.store.dispatch(JA()),eo))))},{dispatch:!1}),this.dispatchChangePlugin$=cr(()=>Jt(this.onDashboardLoad$,this.actions$.pipe(ii(Um))).pipe(Wt(this.store.select(Rs)),L(([,o])=>o),yi(),Ye(o=>null!==o),Qt(1),kt(o=>{this.store.dispatch(Zu({plugin:o}))})),{dispatch:!1})}refreshPolymerRuns(){return Eo(this.tfBackend.ref.runsStore.refresh())}fetchEnvironment(){return this.webappDataSource.fetchEnvironment().pipe(kt(e=>{this.store.dispatch($A({environment:e}))}))}}return n.\u0275fac=function(e){return new(e||n)(j(Po),j(Ce),j(YA))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),N4=new pe("Core Feature Config");function H$(n){return{initialState:{...FM,activePlugin:n.getPluginId()||null}}}function iPe(){return J(iI,n=>({sideBarWidthInPercent:n}))}var ec=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[{provide:N4,deps:[fh],useFactory:H$}],imports:[ro.forFeature([V$]),wr.forFeature("core",F$,N4),P$,Sr.defineGlobalSetting(iPe)]}),n})(),U$=new pe("[Alert] Action-To-Alert Provider"),Ju=(()=>{class n{constructor(e){this.providers=new Map;for(let i of e||[])for(let r of i){if(this.providers.has(r.actionCreator.type))throw new RangeError(`"${r.actionCreator.type}" is already registered for alerts. Multiple alerts for the same action is not allowed.`);this.providers.set(r.actionCreator.type,r.alertFromAction)}}getAlertFromAction(e){let i=this.providers.get(e.type);return i?i(e):null}static registerAlertActions(e){return{ngModule:n,providers:[{provide:U$,multi:!0,useFactory:e}]}}}return n.\u0275fac=function(e){return new(e||n)(j(U$,8))},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),rI=be("[Runs] Fetch Runs Requested",{_as:"props",_p:void 0}),vh=be("[Runs] Fetch Runs Succeeded",{_as:"props",_p:void 0}),sv=be("[Runs] Fetch Runs Failed",{_as:"props",_p:void 0}),oI=be("[Runs] Run Selection Toggled",{_as:"props",_p:void 0}),sI=be("[Runs] Single Run Selected",{_as:"props",_p:void 0}),aI=be("[Runs] Run Page Selection Toggled",{_as:"props",_p:void 0}),lI=be("[Runs] Run Selector Pagination Option Changed",{_as:"props",_p:void 0}),cI=be("[Runs] Run Selector Sort Changed",{_as:"props",_p:void 0}),NM=be("[Runs] Run Selector Regex Filter Changed",{_as:"props",_p:void 0}),uI=be("[Runs] Run Color Changed",{_as:"props",_p:void 0}),dI=be("[Runs] Run Table Shown",{_as:"props",_p:void 0}),av=be("[Runs] Run Group By Changed",{_as:"props",_p:void 0}),Ci=(()=>(function(n){n[n.DISCRETE=0]="DISCRETE",n[n.INTERVAL=1]="INTERVAL"}(Ci||(Ci={})),Ci))(),pI=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Gm={};BE(Gm,{hparamsDiscreteHparamFilterChanged:()=>V4,hparamsIntervalHparamFilterChanged:()=>H4,hparamsMetricFilterChanged:()=>U4});var V4=be("[Hparams] Hparams Discrete Hparam Filter Changed",{_as:"props",_p:void 0}),H4=be("[Hparams] Hparams Interval Hparam Filter Changed",{_as:"props",_p:void 0}),U4=be("[Hparams] Hparams Metric Filter Changed",{_as:"props",_p:void 0});function Wm(n){return JSON.stringify([...n].sort())}function LM(n){let t=new Map,e=new Map,i=new Map;for(let r of n)for(let[o,s]of r)if(s.type===Ci.DISCRETE){let{possibleValues:a,values:l}=e.get(o)||{possibleValues:new Set,values:new Set};for(let c of s.filterValues)l.add(c);for(let c of s.possibleValues)a.add(c);e.set(o,{possibleValues:a,values:l})}else{let a=i.get(o);i.set(o,{filterLowerValue:Math.min(s.filterLowerValue,a?.filterLowerValue??1/0),filterUpperValue:Math.max(s.filterUpperValue,a?.filterUpperValue??-1/0),minValue:Math.min(s.minValue,a?.minValue??1/0),maxValue:Math.max(s.maxValue,a?.maxValue??-1/0)})}for(let[r,{values:o,possibleValues:s}]of e)t.set(r,{type:Ci.DISCRETE,includeUndefined:!0,possibleValues:[...s],filterValues:[...o]});for(let[r,{minValue:o,maxValue:s,filterLowerValue:a,filterUpperValue:l}]of i){if(t.has(r)){let c=t.get(r);if(c.type===Ci.DISCRETE&&c.possibleValues.some(u=>u))throw new RangeError(`Cannot combine hparam, ${r}, as it is of mixed types.`)}t.set(r,{type:Ci.INTERVAL,includeUndefined:!0,minValue:o,maxValue:s,filterLowerValue:a,filterUpperValue:l})}return t}function hI(n){let t=new Map;for(let e of n)for(let[i,r]of e){let o=t.get(i);t.set(i,{type:Ci.INTERVAL,includeUndefined:!0,...o,minValue:Math.min(r.minValue,o?.minValue??1/0),maxValue:Math.max(r.maxValue,o?.maxValue??-1/0),filterLowerValue:Math.min(r.filterLowerValue,o?.filterLowerValue??1/0),filterUpperValue:Math.max(r.filterUpperValue,o?.filterUpperValue??-1/0)})}return t}var lPe=vr({specs:{},filters:{}},Se(V4,(n,t)=>{let{experimentIds:e,hparamName:i,filterValues:r,includeUndefined:o}=t,s=Wm(e),a=n.filters[s]??{hparams:new Map},l=a.hparams.get(i);if(l&&l.type!==Ci.DISCRETE)throw new RangeError(`New discrete filter of ${i} conflicts existing filter of `+Ci[l.type]);let c=LM(e.filter(h=>Boolean(n.specs[h])).map(h=>n.specs[h].hparam.defaultFilters)).get(i);if(!c)throw new Error(`Cannot set hparam, ${i}, when it is not known for experimentIds: ${e.join(", ")}`);if(c.type!==Ci.DISCRETE)throw new Error(`Cannot set ${i} when default filter is not of discrete type.`);let u=new Set(c.possibleValues),d=[...r].filter(h=>!u.has(h));if(d.length)throw new Error(`New filter for ${i} has more than one value that is not present in the spec. Bad values: ${d.join(", ")}`);let p=new Map(a.hparams);return p.set(i,{...l,type:Ci.DISCRETE,includeUndefined:o,possibleValues:[...u],filterValues:r}),{...n,filters:{...n.filters,[s]:{...a,hparams:p}}}}),Se(H4,(n,t)=>{let{experimentIds:e,hparamName:i,filterLowerValue:r,filterUpperValue:o,includeUndefined:s}=t,a=Wm(e),l=n.filters[a]??{metrics:new Map,hparams:new Map},c=l.hparams.get(i);if(c&&c.type!==Ci.INTERVAL)throw new RangeError(`New interval filter of ${i} conflicts existing filter of `+Ci[c.type]);let u=LM(e.filter(p=>Boolean(n.specs[p])).map(p=>n.specs[p].hparam.defaultFilters)).get(i);if(!u)throw new Error(`Cannot set hpara, ${i}, when it is not known for experimentIds: ${e.join(", ")}`);if(u.type!==Ci.INTERVAL)throw new Error(`Cannot set ${i} when default filter is not of interval type.`);let d=new Map(l.hparams);return d.set(i,{...c,type:Ci.INTERVAL,includeUndefined:s,minValue:u.minValue,maxValue:u.maxValue,filterLowerValue:r,filterUpperValue:o}),{...n,filters:{...n.filters,[a]:{...l,hparams:d}}}}),Se(U4,(n,t)=>{let{experimentIds:e,metricTag:i,filterLowerValue:r,filterUpperValue:o,includeUndefined:s}=t,a=Wm(e),l=n.filters[a]??{metrics:new Map,hparams:new Map},c=hI(e.filter(p=>Boolean(n.specs[p])).map(p=>n.specs[p].metric.defaultFilters)).get(i);if(!c)throw new Error(`Cannot set metric, ${i}, when it is not known for experimentIds: ${e.join(", ")}`);let u=l.metrics.get(i),d=new Map(l.metrics);return d.set(i,{...u,type:Ci.INTERVAL,includeUndefined:s,minValue:c.minValue,maxValue:c.maxValue,filterLowerValue:r,filterUpperValue:o}),{...n,filters:{...n.filters,[a]:{...l,metrics:d}}}}),Se(vh,(n,t)=>{if(0===Object.keys(t.newRunsAndMetadata).length)return n;let e={...n.specs},i=new Map,r=new Set;for(let o of Object.keys(t.newRunsAndMetadata)){let s=new Map,a=new Map,l=new Map,c=new Map,{runs:u,metadata:d}=t.newRunsAndMetadata[o];for(let p of u){let h=d.runToHparamsAndMetrics[p.id];if(h)for(let f of h.metrics){let m=i.get(f.tag);i.set(f.tag,{min:m?Math.min(m.min,f.value):f.value,max:m?Math.max(m.max,f.value):f.value})}}for(let{name:p,domain:h}of d.hparamSpecs)if(h.type===Ci.DISCRETE){let f=l.get(p)||new Set;for(let m of h.values)f.add(m);l.set(p,f)}else{let f=c.get(p);c.set(p,{minValue:f?Math.min(h.minValue,f.minValue):h.minValue,maxValue:f?Math.max(h.maxValue,f.maxValue):h.maxValue})}for(let p of d.metricSpecs)r.add(p.tag);for(let[p,h]of l)s.set(p,{type:Ci.DISCRETE,includeUndefined:!0,possibleValues:[...h],filterValues:[...h]});for(let[p,{minValue:h,maxValue:f}]of c)s.set(p,{type:Ci.INTERVAL,includeUndefined:!0,minValue:h,maxValue:f,filterLowerValue:h,filterUpperValue:f});for(let p of r){let h=i.get(p),f=h?.min??0,m=h?.max??0;a.set(p,{type:Ci.INTERVAL,includeUndefined:!0,minValue:f,maxValue:m,filterLowerValue:f,filterUpperValue:m})}e[o]={hparam:{...e[o]?.hparam,specs:d.hparamSpecs,defaultFilters:s},metric:{...e[o]?.metric,specs:d.metricSpecs,defaultFilters:a}}}return{...n,specs:e}}));function z$(n,t){return lPe(n,t)}var fI="hparams",j$=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[wr.forFeature(fI,z$)]}),n})(),mI=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[j$]}),n})();function cPe(n,t){return`${t}/${n}`}var G$=(()=>{class n{constructor(e){this.http=e}fetchRuns(e){return this.http.get("data/runs").pipe(L(i=>i.map(r=>({id:cPe(r,e),name:r,startTime:0}))))}fetchHparamsMetadata(e){return Xt({hparamSpecs:[],metricSpecs:[],runToHparamsAndMetrics:{}})}}return n.\u0275fac=function(e){return new(e||n)(j(ka))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),W$=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[{provide:pI,useClass:G$}]}),n})(),q$=J(Mr("alerts"),n=>n.latestAlert),_I="experiments",pPe=J(Mr(_I),n=>n.data),vI=J(pPe,(n,t)=>{let{experimentId:e}=t;return n.experimentMap[e]||null}),ri=(()=>(function(n){n.SCALARS="scalars",n.HISTOGRAMS="histograms",n.IMAGES="images"}(ri||(ri={})),ri))(),Ji=(()=>(function(n){n[n.STEP=0]="STEP",n[n.RELATIVE=1]="RELATIVE",n[n.WALL_TIME=2]="WALL_TIME"}(Ji||(Ji={})),Ji))(),BM="timeseries";function X$(n){return n===ri.SCALARS||n===ri.HISTOGRAMS||n===ri.IMAGES}var hPe=[ri.IMAGES];function fl(n){return hPe.includes(n)}var fPe=[ri.HISTOGRAMS,ri.IMAGES];function ml(n){return fPe.includes(n)}function z4(n){return ml(n.plugin)}var $u=class{};function bI(n){return n.hasOwnProperty("error")}var j4="data/plugin/timeseries";function Q$(n){let t=n.indexOf("/");return{run:n.substring(t+1),experimentId:n.substring(0,t)}}function Z$(n,t){return`${t}/${n}`}function K$(n,t){let{runToSeries:e,run:i,...r}=n,o={...r};return e&&(o.runToSeries=G4(e,t)),i&&(o.runId=Z$(i,t)),o}function G4(n,t){let e={};for(let i in n)n.hasOwnProperty(i)&&(e[Z$(i,t)]=n[i]);return e}var J$=(()=>{class n{constructor(e,i){this.http=e,this.store=i}fetchTagMetadata(e){let i=e.map(o=>this.http.get(`/experiment/${o}/${j4}/tags`).pipe(L(a=>function(n,t){let e={};for(let i of Object.keys(n)){let r=i;if(fl(r)){let{tagRunSampledInfo:o,...s}=n[r],a={};for(let l in o)o.hasOwnProperty(l)&&(a[l]=G4(o[l],t));e[r]={...s,tagRunSampledInfo:a}}else{let{runTagInfo:o,...s}=n[r];e[r]={...s,runTagInfo:G4(o,t)}}}return e}(a,o)))),r=this.store.select(gh).pipe(Ye(Boolean),Qt(1),Wt(this.store.select(WA)),L(([,o])=>o));return lr(i).pipe(Wt(r),L(([o,s])=>{let a=function(n){let t={};for(let e of n)for(let i of Object.values(ri))if(fl(i)){t[i]=t[i]||{tagDescriptions:{},tagRunSampledInfo:{}};let{tagDescriptions:r,tagRunSampledInfo:o}=e[i];t[i].tagDescriptions={...t[i].tagDescriptions,...r};let s=t[i].tagRunSampledInfo;for(let a of Object.keys(o)){s[a]=s[a]||{};for(let l of Object.keys(o[a]))s[a][l]=o[a][l]}}else{t[i]=t[i]||{tagDescriptions:{},runTagInfo:{}};let{tagDescriptions:r,runTagInfo:o}=e[i];t[i].tagDescriptions={...t[i].tagDescriptions,...r},t[i].runTagInfo={...t[i].runTagInfo,...o}}return t}(o);return s||(a[ri.IMAGES]={tagDescriptions:{},tagRunSampledInfo:{}}),a}))}fetchTimeSeries(e){let i=e.map(r=>{if(ml(r.plugin)){let{runId:l,...c}=r,{run:u,experimentId:d}=Q$(l),p={...c,run:u};return this.fetchTimeSeriesBackendRequest(p,d).pipe(L(({response:h,experimentId:f})=>K$(h,f)))}let{experimentIds:o,...s}=r;return lr(o.map(l=>this.fetchTimeSeriesBackendRequest(s,l))).pipe(L(l=>{let{runToSeries:c,error:u,...d}=l[0].response,p=d;for(let{response:h,experimentId:f}of l){let m=K$(h,f);if(p.error)continue;let{runToSeries:x,error:g}=m;if(g)p.error=g,p.runToSeries=void 0;else{p.runToSeries=p.runToSeries||{};for(let b of Object.keys(x))p.runToSeries[b]=x[b]}}return p}))});return lr(i)}fetchTimeSeriesBackendRequest(e,i){let r=new FormData;return r.append("requests",JSON.stringify([e])),this.http.post(`/experiment/${i}/${j4}/timeSeries`,r).pipe(L(o=>({response:o[0],experimentId:i})))}imageUrl(e){return`${j4}/imageData?imageId=${e}`}downloadUrl(e,i,r,o){let l,{run:s,experimentId:a}=Q$(r);if(e!==ri.SCALARS)throw new Error(`Not implemented: downloadUrl for ${e} is not implemented yet`);if(l="scalars/scalars",!a)throw new Error("experimentId is empty; it is required to form downloadUrl.");return`/experiment/${a}/data/plugin/scalars/scalars?${new URLSearchParams({tag:i,run:s,format:o})}`}}return n.\u0275fac=function(e){return new(e||n)(j(ka),j(Ce))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),vPe=new URLSearchParams(window.location.search),xI=(()=>{class n{getParams(){return vPe}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),VM="tb_feature_flag_storage_key",W4=(()=>{class n{constructor(e){this.queryParams=e}getFeatures(e,i){let r=e?this.getPartialFeaturesFromMediaQuery():{},o=function(n,t){return Object.entries(n).reduce((e,[i,r])=>{let o=function(n,t){let e=n.queryParamOverride;if(!e||!t.has(e))return null;let i=t.get(e);return null==i?null:n.parseValue(i)}(r,t);return null!==o&&(e[i]=o),e},{})}(i,this.queryParams.getParams());return{...r,...Object.fromEntries(Object.entries(this.getPersistentFeatureFlags()).filter(([a])=>i[a])),...o}}persistFeatureFlags(e){let r={...this.getPersistentFeatureFlags(),...e};localStorage.setItem(VM,JSON.stringify(r))}resetPersistedFeatureFlag(e){let i=this.getPersistentFeatureFlags();if(null!=i[e]){if(delete i[e],0===Object.keys(i).length)return void localStorage.removeItem(VM);localStorage.setItem(VM,JSON.stringify(i))}}resetAllPersistedFeatureFlags(){localStorage.removeItem(VM)}getPersistentFeatureFlags(){let e=localStorage.getItem(VM);return null==e?{}:JSON.parse(e)}getPartialFeaturesFromMediaQuery(){let e={};return window.matchMedia("(prefers-color-scheme: dark)").matches&&(e.defaultEnableDarkMode=!0),e}}return n.\u0275fac=function(e){return new(e||n)(j(xI))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),CI=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),tee=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[W4,xI,{provide:CI,useClass:W4}]}),n})(),HM=be("[FEATURE FLAG] Partial Feature Flags Loaded",{_as:"props",_p:void 0}),MI=be("[FEATURE FLAG] Enable Dark Mode Override Changed",{_as:"props",_p:void 0}),qm=be("[FEATURE FLAG] Store the feature flags in persistent localStorage",{_as:"props",_p:void 0}),yh=be("[FEATURE FLAG] Reset feature flag overrides",{_as:"props",_p:void 0}),lv=be("[FEATURE FLAG] Reset all feature flag overrides"),q4="_tb_force_svg",wI=(()=>{class n{constructor(){}getForceSvgFlag(){return!!localStorage.getItem(q4)}updateForceSvgFlag(e){e?localStorage.setItem(q4,"present"):localStorage.removeItem(q4)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),nee=be("[FEATURE FLAG] Effects Init"),iee=(()=>{class n{constructor(e,i,r,o){this.actions$=e,this.store=i,this.dataSource=r,this.forceSvgDataSource=o,this.tfFeatureFlags={ref:document.createElement("tf-feature-flags").tf_feature_flags},this.getFeatureFlags$=cr(()=>this.actions$.pipe(ii(nee),fr(this.store.select(b$),this.store.select(Hm)),L(([,s,a])=>{let l=this.dataSource.getFeatures(s,a);return null!=l.forceSvg?this.forceSvgDataSource.updateForceSvgFlag(l.forceSvg):this.forceSvgDataSource.getForceSvgFlag()&&(l.forceSvg=!0),HM({features:l})}))),this.updatePolymerFeatureFlags$=cr(()=>this.actions$.pipe(ii(HM),Wt(this.store.select(bs),this.store.select(jA)),kt(([,s,a])=>{this.tfFeatureFlags.ref.setFeatureFlags(s,a)})),{dispatch:!1}),this.storeFeatureFlag$=cr(()=>this.actions$.pipe(ii(qm),kt(({flags:s})=>{this.dataSource.persistFeatureFlags(s)})),{dispatch:!1}),this.resetFeatureFlagOverrides$=cr(()=>this.actions$.pipe(ii(yh),kt(({flags:s})=>{s.forEach(a=>{this.dataSource.resetPersistedFeatureFlag(a)})})),{dispatch:!1}),this.resetAllFeatureFlagOverrides$=cr(()=>this.actions$.pipe(ii(lv),kt(()=>{this.dataSource.resetAllPersistedFeatureFlags()})),{dispatch:!1})}ngrxOnInitEffects(){return nee()}}return n.\u0275fac=function(e){return new(e||n)(j(Po),j(Ce),j(CI),j(wI))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),ree=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[wI]}),n})(),see=(()=>{class n{constructor(e){this.store=e}intercept(e,i){return this.store.pipe(vt(jA),function(n,t){let e=arguments.length>=2;return i=>i.pipe(n?Ye((r,o)=>n(r,o,i)):ms,Qt(1),e?_1(t):v1(()=>new _0))}(),ui(r=>(e=e.clone({headers:e.headers.set("X-TensorBoard-Feature-Flags",JSON.stringify(r))}),i.handle(e))))}}return n.\u0275fac=function(e){return new(e||n)(j(Ce))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})();function ip(n){return"false"!==n}var Y4={scalarsBatchSize:{defaultValue:void 0,queryParamOverride:"scalarsBatchSize",parseValue:parseInt},enabledExperimentalPlugins:{defaultValue:[],queryParamOverride:"experimentalPlugin",parseValue:function(n){return n?n.split(","):[]}},enabledLinkedTime:{defaultValue:!0,queryParamOverride:"enableLinkedTime",parseValue:ip},enabledScalarDataTable:{defaultValue:!0,queryParamOverride:"enableDataTable",parseValue:ip},forceSvg:{defaultValue:!1,queryParamOverride:"forceSVG",parseValue:ip},enableDarkModeOverride:{defaultValue:null,queryParamOverride:null},defaultEnableDarkMode:{defaultValue:!1,queryParamOverride:"darkMode",parseValue:ip},isAutoDarkModeAllowed:{defaultValue:!0,queryParamOverride:null},inColab:{defaultValue:!1,queryParamOverride:"tensorboardColab",parseValue:ip},metricsImageSupportEnabled:{defaultValue:!0,queryParamOverride:null},enableShowFlags:{defaultValue:!1,queryParamOverride:"showFlags",parseValue:ip},allowRangeSelection:{defaultValue:!0,queryParamOverride:"allowRangeSelection",parseValue:ip},enabledProspectiveFob:{defaultValue:!0,queryParamOverride:"enableProspectiveFob",parseValue:ip},enableScalarColumnCustomization:{defaultValue:!1,queryParamOverride:"enableScalarColumnCustomization",parseValue:ip}},X4={isFeatureFlagsLoaded:!1,defaultFlags:function(n){return Object.entries(n).reduce((t,[e,i])=>(t[e]=i.defaultValue,t),{})}(Y4),metadata:Y4,flagOverrides:{}},Q4=new pe("[Feature Flag] Store Config");function lee(){return{initialState:X4}}var EPe=vr(X4,Se(HM,(n,{features:t})=>({...n,isFeatureFlagsLoaded:!0,flagOverrides:{...n.flagOverrides,...t}})),Se(MI,(n,{enableDarkMode:t})=>({...n,flagOverrides:{...n.flagOverrides,enableDarkModeOverride:t}})),Se(qm,(n,t)=>({...n,flagOverrides:{...n.flagOverrides,...t.flags}})),Se(yh,(n,t)=>{if(!t||!t.flags||!t.flags.length)return n;let e={...n.flagOverrides};return t.flags.forEach(i=>{delete e[i]}),{...n,flagOverrides:e}}),Se(lv,n=>({...n,flagOverrides:{}})),Se(Yc,(n,{partialSettings:t})=>{if(!t.themeOverride)return n;let e;switch(t.themeOverride){case Oa.BROWSER_DEFAULT:e=null;break;case Oa.DARK:e=!0;break;case Oa.LIGHT:e=!1}return{...n,flagOverrides:{...n.flagOverrides,enableDarkModeOverride:e}}}));function cee(n,t){return EPe(n,t)}function TPe(){return J(GA,n=>null===n?{themeOverride:Oa.BROWSER_DEFAULT}:{themeOverride:n?Oa.DARK:Oa.LIGHT})}var cv=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[{provide:Q4,useFactory:lee},{provide:HA,useClass:see,multi:!0}],imports:[ree,tee,wr.forFeature(UA,cee,Q4),ro.forFeature([iee]),Sr.defineGlobalSetting(TPe)]}),n})(),SI=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[{provide:$u,useClass:J$}],imports:[cv,Ku]}),n})();function rp(n,t,e,i){return n[t].hasOwnProperty(e)?fl(t)?n[t][e].hasOwnProperty(i)?n[t][e][i]:null:n[t][e]:null}function EI(n,t,e,i){if(fl(t)){let s={...n[t]},a=function(n,t,e){let r=n.hasOwnProperty(t)?{...n[t]}:{},o=r.hasOwnProperty(e);return r[e]=o?{...r[e]}:{runToSeries:{},runToLoadState:{}},r}(s,e,i);return s[e]=a,s}let r={...n[t]},o=r.hasOwnProperty(e);return r[e]=o?{...r[e]}:{runToSeries:{},runToLoadState:{}},r}function pee(n){return JSON.stringify(n)}function TI(n,t,e){let i={...e};for(let r of t)i[r]=n;return i}function uv(n,t,e,i){if(fl(t)){let o=n[t].tagRunSampledInfo;return o.hasOwnProperty(e)?Object.keys(o[e]).filter(a=>i<o[e][a].maxSamplesPerStep):[]}let r=n[t].tagToRuns;return r.hasOwnProperty(e)?r[e]:[]}function PPe(n,t){return n.plugin===t.plugin&&n.tag===t.tag&&n.sample===t.sample&&(n.runId===t.runId||!n.runId&&!t.runId)}function K4(n,t,e,i,r,o,s){let a=new Set(n),l=[];for(let u of n)for(let d of t)if(PPe(e[d],u)){l.push(d),a.delete(u);break}if(!l.length)return{unresolvedImportedPinnedCards:n,cardMetadataMap:e,cardToPinnedCopy:i,cardToPinnedCopyCache:r,pinnedCardToOriginal:o,cardStepIndex:s};let c={cardToPinnedCopy:i,cardToPinnedCopyCache:r,pinnedCardToOriginal:o,cardStepIndex:s,cardMetadataMap:e};for(let u of l)c=Z4(u,c.cardToPinnedCopy,c.cardToPinnedCopyCache,c.pinnedCardToOriginal,c.cardStepIndex,c.cardMetadataMap);return{...c,unresolvedImportedPinnedCards:[...a]}}function Z4(n,t,e,i,r,o){if(t.has(n))return{cardToPinnedCopy:t,cardToPinnedCopyCache:e,pinnedCardToOriginal:i,cardStepIndex:r,cardMetadataMap:o};let s=new Map(t),a=new Map(e),l=new Map(i),c={...r},u={...o},d=function(n){return JSON.stringify({baseCardId:n})}(n);s.set(n,d),a.set(n,d),l.set(d,n),r.hasOwnProperty(n)&&(c[d]=r[n]);let p=o[n];if(!p)throw new Error("Cannot pin a card without metadata");return u[d]=p,{cardToPinnedCopy:s,cardToPinnedCopyCache:a,pinnedCardToOriginal:l,cardStepIndex:c,cardMetadataMap:u}}function DI(n){return n.pinnedCardToOriginal.size+n.unresolvedImportedPinnedCards.length<10}function J4(n,t,e,i){let r={...n};return Object.keys(n).forEach(o=>{if(!o.includes('"plugin":"images"'))return;let s=$4(o,t,e),a=null;if(null===i.end)a=function(n,t){let e=t.indexOf(n);if(-1!==e)return{index:e,isClosest:!1};for(let i=0;i<t.length-1;i++){let r=t[i],o=t[i+1],s=.1*(o-r);if(n<r)return null;if(!(n>o)){if(n-r<=s)return{index:i,isClosest:!0};if(o-n<=s)return{index:i+1,isClosest:!0}}}return null}(i.start.step,s);else{let c=s[n[o].index],u=function(n,t){if(!n)return[];if(null===n.end)return-1!==t.indexOf(n.start.step)?[n.start.step]:[];let e=[];for(let i of t)i>=n.start.step&&i<=n.end.step&&e.push(i);return e}(i,s);a=function(n,t,e){if(0===n.length)return null;let i=n[0],r=n[n.length-1];return e>r?{index:t.indexOf(r),isClosest:!1}:e<i?{index:t.indexOf(i),isClosest:!1}:null}(u,s,c)}null!==a&&(r[o]=a)}),r}function $4(n,t,e){if(!t.hasOwnProperty(n))return[];let{plugin:i,tag:r,sample:o,runId:s}=t[n];if(null===s)return[];let a=rp(e,i,r,o);return null!==a&&a.runToSeries.hasOwnProperty(s)?a.runToSeries[s].map(l=>l.step):[]}var Oo=(()=>(function(n){n.DEFAULT="default",n.ALPHABETICAL="alphabetical",n.ASCENDING="ascending",n.DESCENDING="descending",n.NEAREST="nearest",n.NEAREST_Y="nearest_Y"}(Oo||(Oo={})),Oo))(),AI="metrics",II={cardMinWidth:null,tooltipSort:Oo.ALPHABETICAL,ignoreOutliers:!0,xAxisType:Ji.STEP,scalarSmoothing:.6,scalarPartitionNonMonotonicX:!1,imageBrightnessInMilli:1e3,imageContrastInMilli:1e3,imageShowActualSize:!1,histogramMode:zr.OFFSET},ur=Mr(AI),UM=J(ur,n=>n.tagMetadataLoadState),LPe=(J(ur,n=>n.tagMetadata),J(ur,n=>n.cardList)),bh=J(ur,(n,t)=>{if(!n.cardMetadataMap.hasOwnProperty(t))return Oe.NOT_LOADED;let{plugin:e,tag:i,runId:r,sample:o}=n.cardMetadataMap[t],s=rp(n.timeSeriesData,e,i,o);if(!s)return Oe.NOT_LOADED;let a=s.runToLoadState;if(r)return a.hasOwnProperty(r)?a[r]:Oe.NOT_LOADED;let l=uv(n.tagMetadata,e,i,o);if(!l.length)throw new Error("Cannot load a card whose tag has no runs");return l.every(c=>a[c]===Oe.LOADED)?Oe.LOADED:l.some(c=>a[c]===Oe.LOADING)?Oe.LOADING:Oe.NOT_LOADED}),xh=J(ur,(n,t)=>{if(!n.cardMetadataMap.hasOwnProperty(t))return null;let{plugin:e,tag:i,sample:r}=n.cardMetadataMap[t],o=rp(n.timeSeriesData,e,i,r);return o?o.runToSeries:null}),eH=J(ur,n=>n.cardMetadataMap),tc=J(eH,(n,t)=>n.hasOwnProperty(t)?n[t]:null),BPe=J(ur,n=>n.visibleCardMap),mee=J(BPe,n=>new Set(n.values())),PI=J(LPe,eH,(n,t)=>n.filter(e=>t.hasOwnProperty(e)).map(e=>({cardId:e,...t[e]}))),tH=J(ur,(n,t)=>n.cardStepIndex.hasOwnProperty(t)?n.cardStepIndex[t]:null),gee=J(ur,(n,t)=>$4(t,n.cardMetadataMap,n.timeSeriesData)),_ee=J(ur,n=>n.cardToPinnedCopy),VPe=J(ur,n=>n.pinnedCardToOriginal),zM=J(_ee,eH,(n,t)=>[...n.values()].filter(e=>t.hasOwnProperty(e)).map(e=>({cardId:e,...t[e]}))),Ch=J(_ee,VPe,(n,t,e)=>n.has(e)||t.has(e)),vee=J(ur,n=>n.unresolvedImportedPinnedCards),yee=J(ur,n=>DI(n)),ed=J(ur,n=>({...n.settings,...n.settingOverrides})),bee=J(ur,n=>n.settingOverrides),dv=J(ed,n=>n.cardMinWidth),pv=J(ed,n=>n.tooltipSort),hv=J(ed,n=>n.ignoreOutliers),td=J(ed,n=>n.xAxisType),RI=J(ed,n=>n.histogramMode),op=J(ed,n=>n.scalarSmoothing),OI=J(ed,n=>n.scalarPartitionNonMonotonicX),kI=J(ed,n=>n.imageBrightnessInMilli),FI=J(ed,n=>n.imageContrastInMilli),NI=J(ed,n=>n.imageShowActualSize),Xc=J(ur,n=>n.tagFilter),LI=J(ur,(n,t)=>Boolean(n.tagGroupExpanded.get(t))),Ym=J(ur,n=>n.linkedTimeEnabled),fv=J(ur,n=>n.stepSelectorEnabled),mv=J(ur,n=>n.rangeSelectionEnabled),nH=J(ur,n=>{let{min:t,max:e}=n.stepMinMax;return{min:t===1/0?0:t,max:e===-1/0?1e3:e}}),BI=J(ur,n=>n.singleSelectionHeaders),VI=J(ur,n=>n.rangeSelectionHeaders),iH=J(ur,nH,(n,t)=>n.linkedTimeSelection?n.linkedTimeSelection:{start:{step:t.min},end:null}),Xm=J(ur,iH,(n,t)=>n.linkedTimeEnabled?t:null),nd=J(ur,n=>n.filteredPluginTypes),HI=J(ur,n=>n.isSettingsPaneOpen),UI=J(ur,n=>n.isSlideoutMenuOpen),Cee=Mr("notification"),id=(J(Cee,n=>n.notifications),J(Cee,n=>n.lastReadTimestampInMs??-1),(()=>(function(n){n[n.EXPERIMENT_NAME=0]="EXPERIMENT_NAME",n[n.HPARAM=1]="HPARAM",n[n.METRIC=2]="METRIC",n[n.RUN_NAME=3]="RUN_NAME"}(id||(id={})),id))()),sr=(()=>(function(n){n[n.RUN=0]="RUN",n[n.EXPERIMENT=1]="EXPERIMENT",n[n.REGEX=2]="REGEX"}(sr||(sr={})),sr))();function GM(n,t,e){let i={},r=[],o={matches:i,nonMatches:r};switch(n.key){case sr.RUN:for(let a of t)i[a.id]=[a];break;case sr.EXPERIMENT:for(let a of t){let l=e[a.id],c=i[l]||[];c.push(a),i[l]=c}break;case sr.REGEX:if(!n.regexString)break;let s;try{s=new RegExp(n.regexString)}catch{break}for(let a of t){let l=a.name.match(s);if(l){let u=l.length>1?JSON.stringify(l.slice(1)):"pseudo_group",d=i[u]||[];d.push(a),i[u]=d}else r.push(a)}}return o}function jI(n,t){return n===sr.REGEX?{key:n,regexString:t??""}:{key:n}}var Mee=Mr("runs"),gl=J(Mee,n=>n.data),wee=J(gl,n=>n.runIdToExpId),GI=J(gl,(n,t)=>n.runIdToExpId[t.runId]??null),WI=J(gl,(n,t)=>n.runMetadata[t.runId]??null),rd=J(gl,(n,t)=>(n.runIds[t.experimentId]||[]).filter(i=>Boolean(n.runMetadata[i])).map(i=>n.runMetadata[i])),See=J(gl,(n,t)=>n.runIds[t.experimentId]??[]),qI=J(gl,n=>new Map(Object.entries(n.runMetadata))),WM=J(gl,(n,t)=>n.runsLoadState[t.experimentId]||{lastLoadedTimeInMs:null,state:Oe.NOT_LOADED}),rH=J(gl,n=>null!==n.userSetGroupByKey?jI(n.userSetGroupByKey,n.colorGroupRegexString):null),Eee=J(rH,gl,(n,t)=>n??t.initialGroupBy),Qm=J(gl,n=>n.regexFilter),oH=J(Mee,n=>n.ui),sH=J(oH,n=>n.paginationOption),aH=J(oH,n=>n.sort),Tee=J(oH,n=>n.selectionState),Dee=J(gl,n=>n.runColorOverrideForGroupBy),Aee=J(gl,n=>n.defaultRunColorIdForGroupBy),YI=J(gl,n=>n.colorGroupRegexString),XI=be("[Settings] Reload Enable Toggled"),QI=be("[Settings] Reload Period Change",{_as:"props",_p:void 0}),KI=be("[Settings] Page Size Change",{_as:"props",_p:void 0}),Na={};BE(Na,{getColorPalette:()=>HPe,getPageSize:()=>Km,getReloadEnabled:()=>YM,getReloadPeriodInMs:()=>XM,getSettingsLoadState:()=>lH});var ZI="settings",Ree={state:Oe.LOADED,lastLoadedTimeInMs:Date.now(),settings:{reloadPeriodInMs:3e4,reloadEnabled:!1,pageSize:12,colorPalette:{id:"default",name:"Defalt",colors:[{name:"Slate",lightHex:"#425066",darkHex:"#8e98a3"},{name:"Cyan",lightHex:"#12b5cb",darkHex:"#12b5cb"},{name:"Pink",lightHex:"#e52592",darkHex:"#e52592"},{name:"Yellow",lightHex:"#f9ab00",darkHex:"#f9ab00"},{name:"Purple",lightHex:"#9334e6",darkHex:"#9334e6"},{name:"Light Green",lightHex:"#7cb342",darkHex:"#7cb342"},{name:"Orange",lightHex:"#e8710a",darkHex:"#e8710a"}],inactive:{name:"Gray",lightHex:"#e0e0e0",darkHex:"#3b3b3b"}}}},qM=Mr(ZI),lH=J(qM,n=>n.state),YM=J(qM,n=>n.settings.reloadEnabled),XM=J(qM,n=>n.settings.reloadPeriodInMs),Km=J(qM,n=>n.settings.pageSize),HPe=J(qM,n=>n.settings.colorPalette);function JI(n,t,e){if(!t)return!0;let i;try{i=new RegExp(t,"i")}catch{return!1}let r=[n.runName];return e&&r.push(n.experimentAlias.aliasText,`${n.experimentAlias.aliasText}/${n.runName}`),r.some(o=>i.test(o))}var UPe=J(Wo,Tee,wee,(n,t,e)=>{if(!n)return new Map;let i=new Map;for(let[r,o]of t.entries()){let s=e[r];s&&n.indexOf(s)>=0&&i.set(r,o)}return i}),oo=J(Wo,UPe,Qm,n=>{let t=Wo(n)??[],e=Yu(n),i=new Map;for(let r of t){let o=rd(n,{experimentId:r});for(let s of o)i.set(s.id,{runName:s.name,experimentAlias:e[r]})}return i},qu,(n,t,e,i,r)=>{if(!n)return null;let o=r===hi.COMPARE_EXPERIMENT,s=new Map;for(let[a,l]of t.entries()){let c=i.get(a);s.set(a,JI(c,e,o)&&l)}return s}),nc=J(Na.getColorPalette,Aee,Dee,Qu,(n,t,e,i)=>{let r={};return t.forEach((o,s)=>{let a=i?n.inactive.darkHex:n.inactive.lightHex;if(e.has(s))a=e.get(s);else if(o>=0){let l=n.colors[o%n.colors.length];a=i?l.darkHex:l.lightHex}r[s]=a}),r}),Oee=(()=>{class n{constructor(e,i,r){this.actions$=e,this.store=i,this.runsDataSource=r,this.loadRunsOnRunTableShown$=cr(()=>this.actions$.pipe(ii(dI),xn(({experimentIds:o})=>this.getExperimentsWithLoadState(o,a=>a===Oe.FAILED||a===Oe.NOT_LOADED).pipe(Ye(a=>!!a.length),xn(a=>this.fetchAllRunsList(o,a))))),{dispatch:!1}),this.experimentsWithStaleRunsOnRouteChange$=this.actions$.pipe(ii(Jl),Wt(this.store.select(Ra)),yi(([,o],[,s])=>Ps(o,s)),Wt(this.store.select(Wo)),Ye(([,o])=>!!o),L(([,o])=>o),xn(o=>this.getExperimentsWithLoadState(o,s=>s===Oe.FAILED||s===Oe.NOT_LOADED).pipe(L(s=>({experimentIds:o,experimentIdsToBeFetched:s}))))),this.experimentsWithStaleRunsOnReload$=this.actions$.pipe(ii(aa,Fa),Wt(this.store.select(Wo)),Ye(([,o])=>!!o),L(([,o])=>o),xn(o=>this.getExperimentsWithLoadState(o,s=>s!==Oe.LOADING).pipe(L(s=>({experimentIds:o,experimentIdsToBeFetched:s}))))),this.loadRunsOnNavigationOrReload$=cr(()=>Jt(this.experimentsWithStaleRunsOnRouteChange$,this.experimentsWithStaleRunsOnReload$).pipe(xn(({experimentIds:o,experimentIdsToBeFetched:s})=>this.fetchAllRunsList(o,s))),{dispatch:!1})}getRunsListLoadState(e){return this.store.select(WM,{experimentId:e}).pipe(Qt(1))}getExperimentsWithLoadState(e,i){return lr(e.map(r=>this.getRunsListLoadState(r))).pipe(L(r=>e.filter((o,s)=>i(r[s].state))))}fetchAllRunsList(e,i){return Xt({experimentIds:e,experimentIdsToBeFetched:i}).pipe(kt(()=>{this.store.dispatch(rI({experimentIds:e,requestedExperimentIds:i}))}),xn(()=>{let r=new Set(i);return lr(e.map(s=>r.has(s)?this.fetchRunsForExperiment(s):this.maybeWaitForRunsAndGetRuns(s)))}),L(r=>{let o={},s=[];for(let a of r)s.push(...a.runs),a.fromRemote&&(o[a.experimentId]={runs:a.runs,metadata:a.metadata});return{newRunsAndMetadata:o,runsForAllExperiments:s}}),kt(({newRunsAndMetadata:r,runsForAllExperiments:o})=>{this.store.dispatch(vh({experimentIds:e,newRunsAndMetadata:r,runsForAllExperiments:o}))}),fo(r=>(this.store.dispatch(sv({experimentIds:e,requestedExperimentIds:i})),Xt(null))),L(()=>null))}maybeWaitForRunsAndGetRuns(e){return this.store.select(WM,{experimentId:e}).pipe(Ye(i=>i.state!==Oe.LOADING),Qt(1),xn(i=>i.state===Oe.FAILED?wc(new Error("Pending request failed")):Xt(i)),Wt(this.store.select(rd,{experimentId:e})),L(([,i])=>({fromRemote:!1,experimentId:e,runs:i})))}fetchRunsForExperiment(e){return lr([this.runsDataSource.fetchRuns(e),this.runsDataSource.fetchHparamsMetadata(e)]).pipe(L(([i,r])=>({fromRemote:!0,experimentId:e,runs:i,metadata:r})))}}return n.\u0275fac=function(e){return new(e||n)(j(Po),j(Ce),j(pI))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),ic=(()=>(function(n){n.ASC="asc",n.DESC="desc",n.UNSET=""}(ic||(ic={})),ic))(),{initialState:zPe,reducers:jPe}=zm({runColorOverrideForGroupBy:new Map,defaultRunColorIdForGroupBy:new Map,groupKeyToColorId:new Map,initialGroupBy:{key:sr.RUN},userSetGroupByKey:null,colorGroupRegexString:"",regexFilter:""},{runIds:{},runIdToExpId:{},runMetadata:{},runsLoadState:{}},(n,t,e)=>Ps(t,e)?n:{...n,initialGroupBy:{key:e.routeKind===hi.COMPARE_EXPERIMENT?sr.EXPERIMENT:sr.RUN}}),GPe=vr(zPe,Se(K_,(n,{routeKind:t,partialState:e})=>{if(t!==hi.COMPARE_EXPERIMENT&&t!==hi.EXPERIMENT)return n;let r=e.runs.groupBy,o=e.runs.regexFilter??"";if(!r&&!o)return n;let{colorGroupRegexString:s,userSetGroupByKey:a}=n;return r&&(s=r.key===sr.REGEX?r.regexString:n.colorGroupRegexString,a=r.key??null),{...n,colorGroupRegexString:s,regexFilter:o,userSetGroupByKey:a}}),Se(rI,(n,t)=>{let e={...n.runsLoadState};for(let i of t.requestedExperimentIds)e[i]=e[i]?{...e[i],state:Oe.LOADING}:{lastLoadedTimeInMs:null,state:Oe.LOADING};return{...n,runsLoadState:e}}),Se(vh,(n,t)=>{let e={...n.runIds},i={...n.runMetadata},r={...n.runIdToExpId},o={...n.runsLoadState};for(let s of Object.keys(t.newRunsAndMetadata)){let{runs:a,metadata:l}=t.newRunsAndMetadata[s];e[s]=a.map(({id:c})=>c),o[s]={...o[s],lastLoadedTimeInMs:Date.now(),state:Oe.LOADED};for(let c of a){let u=l.runToHparamsAndMetrics[c.id];i[c.id]={...c,hparams:u?u.hparams:null,metrics:u?u.metrics:null},r[c.id]=s}}return{...n,runIds:e,runIdToExpId:r,runMetadata:i,runsLoadState:o}}),Se(sv,(n,t)=>{let e={...n.runsLoadState};for(let i of t.requestedExperimentIds)e[i]=e[i]?{...e[i],state:Oe.FAILED}:{lastLoadedTimeInMs:null,state:Oe.FAILED};return{...n,runsLoadState:e}}),Se(vh,(n,{runsForAllExperiments:t})=>{let e=new Map(n.groupKeyToColorId),i=new Map(n.defaultRunColorIdForGroupBy),r=n.initialGroupBy;null!==n.userSetGroupByKey&&(r=jI(n.userSetGroupByKey,n.colorGroupRegexString));let o=GM(r,t,n.runIdToExpId);Object.entries(o.matches).forEach(([s,a])=>{let l=e.get(s)??e.size;e.set(s,l);for(let c of a)i.set(c.id,l)});for(let s of o.nonMatches)i.set(s.id,-1);return{...n,defaultRunColorIdForGroupBy:i,groupKeyToColorId:e}}),Se(av,(n,{experimentIds:t,groupBy:e})=>{let i=new Map,r=new Map(n.defaultRunColorIdForGroupBy),s=GM(e,t.flatMap(l=>n.runIds[l]).map(l=>n.runMetadata[l]),n.runIdToExpId);Object.entries(s.matches).forEach(([l,c])=>{let u=i.get(l)??i.size;i.set(l,u);for(let d of c)r.set(d.id,u)});for(let l of s.nonMatches)r.set(l.id,-1);let a=e.key===sr.REGEX?e.regexString:n.colorGroupRegexString;return{...n,colorGroupRegexString:a,userSetGroupByKey:e.key,defaultRunColorIdForGroupBy:r,groupKeyToColorId:i,runColorOverrideForGroupBy:new Map}}),Se(uI,(n,{runId:t,newColor:e})=>{let i=new Map(n.runColorOverrideForGroupBy);return i.set(t,e),{...n,runColorOverrideForGroupBy:i}}),Se(NM,(n,t)=>({...n,regexFilter:t.regexString}))),WPe=jm(GPe,jPe),qPe={key:null,direction:ic.UNSET},{initialState:YPe,reducers:XPe}=zm({paginationOption:{pageIndex:0,pageSize:10},sort:qPe,selectionState:new Map},{}),QPe=vr(YPe,Se(lI,(n,{pageSize:t,pageIndex:e})=>({...n,paginationOption:{pageSize:t,pageIndex:e}})),Se(NM,(n,t)=>({...n,paginationOption:{...n.paginationOption,pageIndex:0}})),Se(cI,(n,t)=>({...n,sort:{key:t.key,direction:t.direction}})),Se(vh,(n,t)=>{let e=new Map(n.selectionState),i=t.runsForAllExperiments.length<=500;for(let r of t.runsForAllExperiments)e.has(r.id)||e.set(r.id,i);return{...n,selectionState:e}}),Se(oI,(n,{runId:t})=>{let e=new Map(n.selectionState);return e.set(t,!Boolean(e.get(t))),{...n,selectionState:e}}),Se(sI,(n,{runId:t})=>{let e=new Map;for(let i of n.selectionState.keys())e.set(i,t===i);return{...n,selectionState:e}}),Se(aI,(n,{runIds:t})=>{let e=new Map(n.selectionState),i=!t.every(r=>Boolean(e.get(r)));for(let r of t)e.set(r,i);return{...n,selectionState:e}})),KPe=jm(QPe,XPe);function kee(n,t){return Fm({data:WPe,ui:KPe})(n,t)}function ZPe(){return[{actionCreator:sv,alertFromAction:()=>({localizedMessage:"Failed to fetch runs"})}]}var $I=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[wr.forFeature("runs",kee),ro.forFeature([Oee]),W$,Ju.registerAlertActions(ZPe),mI]}),n})(),sp=(()=>(function(n){n.RUNS_CHANGED="experimental.RunsChanged",n.GET_RUNS="experimental.GetRuns",n.GET_URL_DATA="experimental.GetURLPluginData",n.DATA_RELOADED="experimental.DataReloaded"}(sp||(sp={})),sp))(),Nee=new WeakMap,gv=new Set,cH=new Map,t2=new Map;function Lee(n,t){return e=>{let i=t2.get(t),r=Nee.get(i)||null;return n(r,e)}}window.addEventListener("message",n=>{if("experimental.bootstrap"!==n.data)return;let t=n.ports[0];if(!t)return;let e=n.source?n.source.frameElement:null;!e||function(n,t){let e=new class{constructor(t){this.port=t,this.id=0,this.responseWaits=new Map,this.listeners=new Map,this.port.addEventListener("message",e=>this.onMessage(e))}listen(t,e){this.listeners.set(t,e)}unlisten(t){this.listeners.delete(t)}async onMessage(t){let e=JSON.parse(t.data),i=e.type,r=e.id,o=e.payload,s=e.error;if(e.isReply){if(!this.responseWaits.has(r))return;let{resolve:d,reject:p}=this.responseWaits.get(r);return this.responseWaits.delete(r),void(s?p(new Error(s)):d(o))}let l=null,c=null;if(this.listeners.has(i)){let d=this.listeners.get(i);try{l=await d(o)}catch(p){c=p}}this.postMessage({type:i,id:r,payload:l,error:c,isReply:!0})}postMessage(t){this.port.postMessage(JSON.stringify(t))}sendMessage(t,e){let i=this.id++;return this.postMessage({type:t,id:i,payload:e,error:null,isReply:!1}),new Promise((o,s)=>{this.responseWaits.set(i,{resolve:o,reject:s})})}}(n);gv.add(e),t2.set(e,t),n.start();for(let[i,r]of cH){let o=Lee(r,e);e.listen(i,o)}}(t,e)});var dH,_v=(()=>{class n{broadcast(e,i){return function(n,t){for(let i of gv)t2.get(i).isConnected||(gv.delete(i),t2.delete(i));let e=[...gv].map(i=>i.sendMessage(n,t));return Promise.all(e)}(e,i)}listen(e,i){!function(n,t){cH.set(n,t);for(let e of gv){let i=Lee(t,e);e.listen(n,i)}}(e,i)}unlisten(e){!function(n){cH.delete(n);for(let t of gv)t.unlisten(n)}(e)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),n2=(()=>{class n{constructor(e,i){this.ipc=e,this.store=i}init(){let e=document.createElement("tf-storage");this.ipc.listen(sp.GET_URL_DATA,i=>{if(!i)return;let r=`p.${i.pluginName}.`,o={},s=e.tf_storage.getUrlHashDict();for(let a in s)a.startsWith(r)&&(o[a.substring(r.length)]=s[a]);return o}),this.store.select(iv).pipe(Ye(i=>null!==i),yi()).subscribe(()=>{this.ipc.broadcast(sp.DATA_RELOADED,void 0)})}}return n.\u0275fac=function(e){return new(e||n)(j(_v),j(Ce))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),i2=(()=>{class n{constructor(e,i){this.ipc=e,this.store=i}init(){let e=this.store.select(Wo).pipe(xn(i=>i?Lt(i.map(o=>this.store.select(rd,{experimentId:o}))).pipe(L(o=>o.flat()),yi((o,s)=>o.length===s.length&&o.every((a,l)=>s[l].id===a.id)),L(o=>o.map(({name:s})=>s))):Xt([])));e.subscribe(i=>{this.ipc.broadcast(sp.RUNS_CHANGED,i)}),this.ipc.listen(sp.GET_RUNS,()=>e.pipe(Qt(1)).toPromise())}}return n.\u0275fac=function(e){return new(e||n)(j(_v),j(Ce))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),r2=(()=>{class n{constructor(e,i){i.init(),e.init()}registerPluginIframe(e,i){!function(n,t){Nee.set(n,{pluginName:t})}(e,i)}}return n.\u0275fac=function(e){return new(e||n)(j(i2),j(n2))},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[_v,n2,i2],imports:[J_,ec,$I]}),n})(),vv=be("[Alert] Alert Reported",{_as:"props",_p:void 0}),Hee=(()=>{class n{constructor(e,i,r){this.actions$=e,this.store=i,this.alertActionModule=r,this.reportRegisteredActionAlerts$=cr(()=>this.actions$.pipe(kt(o=>{let s=this.alertActionModule.getAlertFromAction(o);s&&this.store.dispatch(vv(s))})),{dispatch:!1})}}return n.\u0275fac=function(e){return new(e||n)(j(Po),j(Ce),j(Ju))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),aRe=vr({latestAlert:null},Se(vv,(n,{localizedMessage:t,followupAction:e})=>{let i={localizedMessage:t,created:Date.now()};return e&&(i.followupAction=e),{...n,latestAlert:i}}));function Uee(n,t){return aRe(n,t)}try{dH=typeof Intl<"u"&&Intl.v8BreakIterator}catch{dH=!1}var yv,QM,o2,Zm,uH,oi=(()=>{class n{constructor(e){this._platformId=e,this.isBrowser=this._platformId?XD(this._platformId):"object"==typeof document&&!!document,this.EDGE=this.isBrowser&&/(edge)/i.test(navigator.userAgent),this.TRIDENT=this.isBrowser&&/(msie|trident)/i.test(navigator.userAgent),this.BLINK=this.isBrowser&&!(!window.chrome&&!dH)&&typeof CSS<"u"&&!this.EDGE&&!this.TRIDENT,this.WEBKIT=this.isBrowser&&/AppleWebKit/i.test(navigator.userAgent)&&!this.BLINK&&!this.EDGE&&!this.TRIDENT,this.IOS=this.isBrowser&&/iPad|iPhone|iPod/.test(navigator.userAgent)&&!("MSStream"in window),this.FIREFOX=this.isBrowser&&/(firefox|minefield)/i.test(navigator.userAgent),this.ANDROID=this.isBrowser&&/android/i.test(navigator.userAgent)&&!this.TRIDENT,this.SAFARI=this.isBrowser&&/safari/i.test(navigator.userAgent)&&this.WEBKIT}}return n.\u0275fac=function(e){return new(e||n)(j(Gd))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),zee=["color","button","checkbox","date","datetime-local","email","file","hidden","image","month","number","password","radio","range","reset","search","submit","tel","text","time","url","week"];function pH(){if(yv)return yv;if("object"!=typeof document||!document)return yv=new Set(zee);let n=document.createElement("input");return yv=new Set(zee.filter(t=>(n.setAttribute("type",t),n.type===t)))}function la(n){return function(){if(null==QM&&typeof window<"u")try{window.addEventListener("test",null,Object.defineProperty({},"passive",{get:()=>QM=!0}))}finally{QM=QM||!1}return QM}()?n:!!n.capture}function s2(){if(null==Zm){if("object"!=typeof document||!document||"function"!=typeof Element||!Element)return Zm=!1;if("scrollBehavior"in document.documentElement.style)Zm=!0;else{let n=Element.prototype.scrollTo;Zm=!!n&&!/\{\s*\[native code\]\s*\}/.test(n.toString())}}return Zm}function bv(){if("object"!=typeof document||!document)return 0;if(null==o2){let n=document.createElement("div"),t=n.style;n.dir="rtl",t.width="1px",t.overflow="auto",t.visibility="hidden",t.pointerEvents="none",t.position="absolute";let e=document.createElement("div"),i=e.style;i.width="2px",i.height="1px",n.appendChild(e),document.body.appendChild(n),o2=0,0===n.scrollLeft&&(n.scrollLeft=1,o2=0===n.scrollLeft?1:2),n.remove()}return o2}function a2(n){if(function(){if(null==uH){let n=typeof document<"u"?document.head:null;uH=!(!n||!n.createShadowRoot&&!n.attachShadow)}return uH}()){let t=n.getRootNode?n.getRootNode():null;if(typeof ShadowRoot<"u"&&ShadowRoot&&t instanceof ShadowRoot)return t}return null}function KM(){let n=typeof document<"u"&&document?document.activeElement:null;for(;n&&n.shadowRoot;){let t=n.shadowRoot.activeElement;if(t===n)break;n=t}return n}function Qc(n){return n.composedPath?n.composedPath()[0]:n.target}function ZM(){return typeof __karma__<"u"&&!!__karma__||typeof jasmine<"u"&&!!jasmine||typeof jest<"u"&&!!jest||typeof Mocha<"u"&&!!Mocha}function kr(n,...t){return t.length?t.some(e=>n[e]):n.altKey||n.shiftKey||n.ctrlKey||n.metaKey}function Rt(n){return null!=n&&"false"!=`${n}`}function Bi(n,t=0){return hH(n)?Number(n):t}function hH(n){return!isNaN(parseFloat(n))&&!isNaN(Number(n))}function xv(n){return Array.isArray(n)?n:[n]}function yo(n){return null==n?"":"string"==typeof n?n:`${n}px`}function La(n){return n instanceof Re?n.nativeElement:n}var Cv,Gee=(()=>{class n{create(e){return typeof MutationObserver>"u"?null:new MutationObserver(e)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),uRe=(()=>{class n{constructor(e){this._mutationObserverFactory=e,this._observedElements=new Map}ngOnDestroy(){this._observedElements.forEach((e,i)=>this._cleanupObserver(i))}observe(e){let i=La(e);return new un(r=>{let s=this._observeElement(i).subscribe(r);return()=>{s.unsubscribe(),this._unobserveElement(i)}})}_observeElement(e){if(this._observedElements.has(e))this._observedElements.get(e).count++;else{let i=new ke,r=this._mutationObserverFactory.create(o=>i.next(o));r&&r.observe(e,{characterData:!0,childList:!0,subtree:!0}),this._observedElements.set(e,{observer:r,stream:i,count:1})}return this._observedElements.get(e).stream}_unobserveElement(e){this._observedElements.has(e)&&(this._observedElements.get(e).count--,this._observedElements.get(e).count||this._cleanupObserver(e))}_cleanupObserver(e){if(this._observedElements.has(e)){let{observer:i,stream:r}=this._observedElements.get(e);i&&i.disconnect(),r.complete(),this._observedElements.delete(e)}}}return n.\u0275fac=function(e){return new(e||n)(j(Gee))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),wh=(()=>{class n{constructor(e,i,r){this._contentObserver=e,this._elementRef=i,this._ngZone=r,this.event=new G,this._disabled=!1,this._currentSubscription=null}get disabled(){return this._disabled}set disabled(e){this._disabled=Rt(e),this._disabled?this._unsubscribe():this._subscribe()}get debounce(){return this._debounce}set debounce(e){this._debounce=Bi(e),this._subscribe()}ngAfterContentInit(){!this._currentSubscription&&!this.disabled&&this._subscribe()}ngOnDestroy(){this._unsubscribe()}_subscribe(){this._unsubscribe();let e=this._contentObserver.observe(this._elementRef);this._ngZone.runOutsideAngular(()=>{this._currentSubscription=(this.debounce?e.pipe(Hr(this.debounce)):e).subscribe(this.event)})}_unsubscribe(){this._currentSubscription?.unsubscribe()}}return n.\u0275fac=function(e){return new(e||n)(M(uRe),M(Re),M(_t))},n.\u0275dir=He({type:n,selectors:[["","cdkObserveContent",""]],inputs:{disabled:["cdkObserveContentDisabled","disabled"],debounce:"debounce"},outputs:{event:"cdkObserveContent"},exportAs:["cdkObserveContent"]}),n})(),od=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[Gee]}),n})(),Wee=new Set,dRe=(()=>{class n{constructor(e){this._platform=e,this._matchMedia=this._platform.isBrowser&&window.matchMedia?window.matchMedia.bind(window):hRe}matchMedia(e){return(this._platform.WEBKIT||this._platform.BLINK)&&function(n){if(!Wee.has(n))try{Cv||((Cv=document.createElement("style")).setAttribute("type","text/css"),document.head.appendChild(Cv)),Cv.sheet&&(Cv.sheet.insertRule(`@media ${n} {body{ }}`,0),Wee.add(n))}catch(t){console.error(t)}}(e),this._matchMedia(e)}}return n.\u0275fac=function(e){return new(e||n)(j(oi))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function hRe(n){return{matches:"all"===n||""===n,media:n,addListener:()=>{},removeListener:()=>{}}}var Jm=(()=>{class n{constructor(e,i){this._mediaMatcher=e,this._zone=i,this._queries=new Map,this._destroySubject=new ke}ngOnDestroy(){this._destroySubject.next(),this._destroySubject.complete()}isMatched(e){return qee(xv(e)).some(r=>this._registerQuery(r).mql.matches)}observe(e){let o=Lt(qee(xv(e)).map(s=>this._registerQuery(s).observable));return o=Vp(o.pipe(Qt(1)),o.pipe(Za(1),Hr(0))),o.pipe(L(s=>{let a={matches:!1,breakpoints:{}};return s.forEach(({matches:l,query:c})=>{a.matches=a.matches||l,a.breakpoints[c]=l}),a}))}_registerQuery(e){if(this._queries.has(e))return this._queries.get(e);let i=this._mediaMatcher.matchMedia(e),o={observable:new un(s=>{let a=l=>this._zone.run(()=>s.next(l));return i.addListener(a),()=>{i.removeListener(a)}}).pipe(zn(i),L(({matches:s})=>({query:e,matches:s})),st(this._destroySubject)),mql:i};return this._queries.set(e,o),o}}return n.\u0275fac=function(e){return new(e||n)(j(dRe),j(_t))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function qee(n){return n.map(t=>t.split(",")).reduce((t,e)=>t.concat(e)).map(t=>t.trim())}function p2(n,t){return(n.getAttribute(t)||"").match(/\S+/g)||[]}var $ee="cdk-describedby-message",u2="cdk-describedby-host",gH=0,f2=(()=>{class n{constructor(e,i){this._platform=i,this._messageRegistry=new Map,this._messagesContainer=null,this._id=""+gH++,this._document=e,this._id=jo($f)+"-"+gH++}describe(e,i,r){if(!this._canBeDescribed(e,i))return;let o=fH(i,r);"string"!=typeof i?(Xee(i,this._id),this._messageRegistry.set(o,{messageElement:i,referenceCount:0})):this._messageRegistry.has(o)||this._createMessageElement(i,r),this._isElementDescribedByMessage(e,o)||this._addMessageReference(e,o)}removeDescription(e,i,r){if(!i||!this._isElementNode(e))return;let o=fH(i,r);if(this._isElementDescribedByMessage(e,o)&&this._removeMessageReference(e,o),"string"==typeof i){let s=this._messageRegistry.get(o);s&&0===s.referenceCount&&this._deleteMessageElement(o)}0===this._messagesContainer?.childNodes.length&&(this._messagesContainer.remove(),this._messagesContainer=null)}ngOnDestroy(){let e=this._document.querySelectorAll(`[${u2}="${this._id}"]`);for(let i=0;i<e.length;i++)this._removeCdkDescribedByReferenceIds(e[i]),e[i].removeAttribute(u2);this._messagesContainer?.remove(),this._messagesContainer=null,this._messageRegistry.clear()}_createMessageElement(e,i){let r=this._document.createElement("div");Xee(r,this._id),r.textContent=e,i&&r.setAttribute("role",i),this._createMessagesContainer(),this._messagesContainer.appendChild(r),this._messageRegistry.set(fH(e,i),{messageElement:r,referenceCount:0})}_deleteMessageElement(e){this._messageRegistry.get(e)?.messageElement?.remove(),this._messageRegistry.delete(e)}_createMessagesContainer(){if(this._messagesContainer)return;let e="cdk-describedby-message-container",i=this._document.querySelectorAll(`.${e}[platform="server"]`);for(let o=0;o<i.length;o++)i[o].remove();let r=this._document.createElement("div");r.style.visibility="hidden",r.classList.add(e),r.classList.add("cdk-visually-hidden"),this._platform&&!this._platform.isBrowser&&r.setAttribute("platform","server"),this._document.body.appendChild(r),this._messagesContainer=r}_removeCdkDescribedByReferenceIds(e){let i=p2(e,"aria-describedby").filter(r=>0!=r.indexOf($ee));e.setAttribute("aria-describedby",i.join(" "))}_addMessageReference(e,i){let r=this._messageRegistry.get(i);(function(n,t,e){let i=p2(n,t);i.some(r=>r.trim()==e.trim())||(i.push(e.trim()),n.setAttribute(t,i.join(" ")))})(e,"aria-describedby",r.messageElement.id),e.setAttribute(u2,this._id),r.referenceCount++}_removeMessageReference(e,i){let r=this._messageRegistry.get(i);r.referenceCount--,function(n,t,e){let r=p2(n,t).filter(o=>o!=e.trim());r.length?n.setAttribute(t,r.join(" ")):n.removeAttribute(t)}(e,"aria-describedby",r.messageElement.id),e.removeAttribute(u2)}_isElementDescribedByMessage(e,i){let r=p2(e,"aria-describedby"),o=this._messageRegistry.get(i),s=o&&o.messageElement.id;return!!s&&-1!=r.indexOf(s)}_canBeDescribed(e,i){if(!this._isElementNode(e))return!1;if(i&&"object"==typeof i)return!0;let r=null==i?"":`${i}`.trim(),o=e.getAttribute("aria-label");return!(!r||o&&o.trim()===r)}_isElementNode(e){return e.nodeType===this._document.ELEMENT_NODE}}return n.\u0275fac=function(e){return new(e||n)(j(Ht),j(oi))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function fH(n,t){return"string"==typeof n?`${t||""}/${n}`:n}function Xee(n,t){n.id||(n.id=`${$ee}-${t}-${gH++}`)}var h2=class{constructor(t){this._items=t,this._activeItemIndex=-1,this._activeItem=null,this._wrap=!1,this._letterKeyStream=new ke,this._typeaheadSubscription=Sn.EMPTY,this._vertical=!0,this._allowedModifierKeys=[],this._homeAndEnd=!1,this._skipPredicateFn=e=>e.disabled,this._pressedLetters=[],this.tabOut=new ke,this.change=new ke,t instanceof Hl&&t.changes.subscribe(e=>{if(this._activeItem){let r=e.toArray().indexOf(this._activeItem);r>-1&&r!==this._activeItemIndex&&(this._activeItemIndex=r)}})}skipPredicate(t){return this._skipPredicateFn=t,this}withWrap(t=!0){return this._wrap=t,this}withVerticalOrientation(t=!0){return this._vertical=t,this}withHorizontalOrientation(t){return this._horizontal=t,this}withAllowedModifierKeys(t){return this._allowedModifierKeys=t,this}withTypeAhead(t=200){return this._typeaheadSubscription.unsubscribe(),this._typeaheadSubscription=this._letterKeyStream.pipe(kt(e=>this._pressedLetters.push(e)),Hr(t),Ye(()=>this._pressedLetters.length>0),L(()=>this._pressedLetters.join(""))).subscribe(e=>{let i=this._getItemsArray();for(let r=1;r<i.length+1;r++){let o=(this._activeItemIndex+r)%i.length,s=i[o];if(!this._skipPredicateFn(s)&&0===s.getLabel().toUpperCase().trim().indexOf(e)){this.setActiveItem(o);break}}this._pressedLetters=[]}),this}withHomeAndEnd(t=!0){return this._homeAndEnd=t,this}setActiveItem(t){let e=this._activeItem;this.updateActiveItem(t),this._activeItem!==e&&this.change.next(this._activeItemIndex)}onKeydown(t){let e=t.keyCode,r=["altKey","ctrlKey","metaKey","shiftKey"].every(o=>!t[o]||this._allowedModifierKeys.indexOf(o)>-1);switch(e){case 9:return void this.tabOut.next();case 40:if(this._vertical&&r){this.setNextItemActive();break}return;case 38:if(this._vertical&&r){this.setPreviousItemActive();break}return;case 39:if(this._horizontal&&r){"rtl"===this._horizontal?this.setPreviousItemActive():this.setNextItemActive();break}return;case 37:if(this._horizontal&&r){"rtl"===this._horizontal?this.setNextItemActive():this.setPreviousItemActive();break}return;case 36:if(this._homeAndEnd&&r){this.setFirstItemActive();break}return;case 35:if(this._homeAndEnd&&r){this.setLastItemActive();break}return;default:return void((r||kr(t,"shiftKey"))&&(t.key&&1===t.key.length?this._letterKeyStream.next(t.key.toLocaleUpperCase()):(e>=65&&e<=90||e>=48&&e<=57)&&this._letterKeyStream.next(String.fromCharCode(e))))}this._pressedLetters=[],t.preventDefault()}get activeItemIndex(){return this._activeItemIndex}get activeItem(){return this._activeItem}isTyping(){return this._pressedLetters.length>0}setFirstItemActive(){this._setActiveItemByIndex(0,1)}setLastItemActive(){this._setActiveItemByIndex(this._items.length-1,-1)}setNextItemActive(){this._activeItemIndex<0?this.setFirstItemActive():this._setActiveItemByDelta(1)}setPreviousItemActive(){this._activeItemIndex<0&&this._wrap?this.setLastItemActive():this._setActiveItemByDelta(-1)}updateActiveItem(t){let e=this._getItemsArray(),i="number"==typeof t?t:e.indexOf(t);this._activeItem=e[i]??null,this._activeItemIndex=i}_setActiveItemByDelta(t){this._wrap?this._setActiveInWrapMode(t):this._setActiveInDefaultMode(t)}_setActiveInWrapMode(t){let e=this._getItemsArray();for(let i=1;i<=e.length;i++){let r=(this._activeItemIndex+t*i+e.length)%e.length;if(!this._skipPredicateFn(e[r]))return void this.setActiveItem(r)}}_setActiveInDefaultMode(t){this._setActiveItemByIndex(this._activeItemIndex+t,t)}_setActiveItemByIndex(t,e){let i=this._getItemsArray();if(i[t]){for(;this._skipPredicateFn(i[t]);)if(!i[t+=e])return;this.setActiveItem(t)}}_getItemsArray(){return this._items instanceof Hl?this._items.toArray():this._items}},wv=class extends h2{setActiveItem(t){this.activeItem&&this.activeItem.setInactiveStyles(),super.setActiveItem(t),this.activeItem&&this.activeItem.setActiveStyles()}},Sh=class extends h2{constructor(){super(...arguments),this._origin="program"}setFocusOrigin(t){return this._origin=t,this}setActiveItem(t){super.setActiveItem(t),this.activeItem&&this.activeItem.focus(this._origin)}},Sv=(()=>{class n{constructor(e){this._platform=e}isDisabled(e){return e.hasAttribute("disabled")}isVisible(e){return function(n){return!!(n.offsetWidth||n.offsetHeight||"function"==typeof n.getClientRects&&n.getClientRects().length)}(e)&&"visible"===getComputedStyle(e).visibility}isTabbable(e){if(!this._platform.isBrowser)return!1;let i=function(n){try{return n.frameElement}catch{return null}}(function(n){return n.ownerDocument&&n.ownerDocument.defaultView||window}(e));if(i&&(-1===Qee(i)||!this.isVisible(i)))return!1;let r=e.nodeName.toLowerCase(),o=Qee(e);return e.hasAttribute("contenteditable")?-1!==o:!("iframe"===r||"object"===r||this._platform.WEBKIT&&this._platform.IOS&&!function(n){let t=n.nodeName.toLowerCase(),e="input"===t&&n.type;return"text"===e||"password"===e||"select"===t||"textarea"===t}(e))&&("audio"===r?!!e.hasAttribute("controls")&&-1!==o:"video"===r?-1!==o&&(null!==o||this._platform.FIREFOX||e.hasAttribute("controls")):e.tabIndex>=0)}isFocusable(e,i){return function(n){return!function(n){return function(n){return"input"==n.nodeName.toLowerCase()}(n)&&"hidden"==n.type}(n)&&(function(n){let t=n.nodeName.toLowerCase();return"input"===t||"select"===t||"button"===t||"textarea"===t}(n)||function(n){return function(n){return"a"==n.nodeName.toLowerCase()}(n)&&n.hasAttribute("href")}(n)||n.hasAttribute("contenteditable")||ete(n))}(e)&&!this.isDisabled(e)&&(i?.ignoreVisibility||this.isVisible(e))}}return n.\u0275fac=function(e){return new(e||n)(j(oi))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function ete(n){if(!n.hasAttribute("tabindex")||void 0===n.tabIndex)return!1;let t=n.getAttribute("tabindex");return!(!t||isNaN(parseInt(t,10)))}function Qee(n){if(!ete(n))return null;let t=parseInt(n.getAttribute("tabindex")||"",10);return isNaN(t)?-1:t}var JM=(()=>{class n{constructor(e,i,r){this._checker=e,this._ngZone=i,this._document=r}create(e,i=!1){return new class{constructor(t,e,i,r,o=!1){this._element=t,this._checker=e,this._ngZone=i,this._document=r,this._hasAttached=!1,this.startAnchorListener=()=>this.focusLastTabbableElement(),this.endAnchorListener=()=>this.focusFirstTabbableElement(),this._enabled=!0,o||this.attachAnchors()}get enabled(){return this._enabled}set enabled(t){this._enabled=t,this._startAnchor&&this._endAnchor&&(this._toggleAnchorTabIndex(t,this._startAnchor),this._toggleAnchorTabIndex(t,this._endAnchor))}destroy(){let t=this._startAnchor,e=this._endAnchor;t&&(t.removeEventListener("focus",this.startAnchorListener),t.remove()),e&&(e.removeEventListener("focus",this.endAnchorListener),e.remove()),this._startAnchor=this._endAnchor=null,this._hasAttached=!1}attachAnchors(){return!!this._hasAttached||(this._ngZone.runOutsideAngular(()=>{this._startAnchor||(this._startAnchor=this._createAnchor(),this._startAnchor.addEventListener("focus",this.startAnchorListener)),this._endAnchor||(this._endAnchor=this._createAnchor(),this._endAnchor.addEventListener("focus",this.endAnchorListener))}),this._element.parentNode&&(this._element.parentNode.insertBefore(this._startAnchor,this._element),this._element.parentNode.insertBefore(this._endAnchor,this._element.nextSibling),this._hasAttached=!0),this._hasAttached)}focusInitialElementWhenReady(t){return new Promise(e=>{this._executeOnStable(()=>e(this.focusInitialElement(t)))})}focusFirstTabbableElementWhenReady(t){return new Promise(e=>{this._executeOnStable(()=>e(this.focusFirstTabbableElement(t)))})}focusLastTabbableElementWhenReady(t){return new Promise(e=>{this._executeOnStable(()=>e(this.focusLastTabbableElement(t)))})}_getRegionBoundary(t){let e=this._element.querySelectorAll(`[cdk-focus-region-${t}], [cdkFocusRegion${t}], [cdk-focus-${t}]`);return"start"==t?e.length?e[0]:this._getFirstTabbableElement(this._element):e.length?e[e.length-1]:this._getLastTabbableElement(this._element)}focusInitialElement(t){let e=this._element.querySelector("[cdk-focus-initial], [cdkFocusInitial]");if(e){if(!this._checker.isFocusable(e)){let i=this._getFirstTabbableElement(e);return i?.focus(t),!!i}return e.focus(t),!0}return this.focusFirstTabbableElement(t)}focusFirstTabbableElement(t){let e=this._getRegionBoundary("start");return e&&e.focus(t),!!e}focusLastTabbableElement(t){let e=this._getRegionBoundary("end");return e&&e.focus(t),!!e}hasAttached(){return this._hasAttached}_getFirstTabbableElement(t){if(this._checker.isFocusable(t)&&this._checker.isTabbable(t))return t;let e=t.children;for(let i=0;i<e.length;i++){let r=e[i].nodeType===this._document.ELEMENT_NODE?this._getFirstTabbableElement(e[i]):null;if(r)return r}return null}_getLastTabbableElement(t){if(this._checker.isFocusable(t)&&this._checker.isTabbable(t))return t;let e=t.children;for(let i=e.length-1;i>=0;i--){let r=e[i].nodeType===this._document.ELEMENT_NODE?this._getLastTabbableElement(e[i]):null;if(r)return r}return null}_createAnchor(){let t=this._document.createElement("div");return this._toggleAnchorTabIndex(this._enabled,t),t.classList.add("cdk-visually-hidden"),t.classList.add("cdk-focus-trap-anchor"),t.setAttribute("aria-hidden","true"),t}_toggleAnchorTabIndex(t,e){t?e.setAttribute("tabindex","0"):e.removeAttribute("tabindex")}toggleAnchors(t){this._startAnchor&&this._endAnchor&&(this._toggleAnchorTabIndex(t,this._startAnchor),this._toggleAnchorTabIndex(t,this._endAnchor))}_executeOnStable(t){this._ngZone.isStable?t():this._ngZone.onStable.pipe(Qt(1)).subscribe(t)}}(e,this._checker,this._ngZone,this._document,i)}}return n.\u0275fac=function(e){return new(e||n)(j(Sv),j(_t),j(Ht))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function $M(n){return 0===n.buttons||0===n.offsetX&&0===n.offsetY}function ew(n){let t=n.touches&&n.touches[0]||n.changedTouches&&n.changedTouches[0];return!(!t||-1!==t.identifier||null!=t.radiusX&&1!==t.radiusX||null!=t.radiusY&&1!==t.radiusY)}new pe("FOCUS_TRAP_INERT_STRATEGY");var kRe=new pe("cdk-input-modality-detector-options"),FRe={ignoreKeys:[18,17,224,91,16]},Mv=la({passive:!0,capture:!0}),NRe=(()=>{class n{constructor(e,i,r,o){this._platform=e,this._mostRecentTarget=null,this._modality=new hr(null),this._lastTouchMs=0,this._onKeydown=s=>{this._options?.ignoreKeys?.some(a=>a===s.keyCode)||(this._modality.next("keyboard"),this._mostRecentTarget=Qc(s))},this._onMousedown=s=>{Date.now()-this._lastTouchMs<650||(this._modality.next($M(s)?"keyboard":"mouse"),this._mostRecentTarget=Qc(s))},this._onTouchstart=s=>{ew(s)?this._modality.next("keyboard"):(this._lastTouchMs=Date.now(),this._modality.next("touch"),this._mostRecentTarget=Qc(s))},this._options={...FRe,...o},this.modalityDetected=this._modality.pipe(Za(1)),this.modalityChanged=this.modalityDetected.pipe(yi()),e.isBrowser&&i.runOutsideAngular(()=>{r.addEventListener("keydown",this._onKeydown,Mv),r.addEventListener("mousedown",this._onMousedown,Mv),r.addEventListener("touchstart",this._onTouchstart,Mv)})}get mostRecentModality(){return this._modality.value}ngOnDestroy(){this._modality.complete(),this._platform.isBrowser&&(document.removeEventListener("keydown",this._onKeydown,Mv),document.removeEventListener("mousedown",this._onMousedown,Mv),document.removeEventListener("touchstart",this._onTouchstart,Mv))}}return n.\u0275fac=function(e){return new(e||n)(j(oi),j(_t),j(Ht),j(kRe,8))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),LRe=new pe("liveAnnouncerElement",{providedIn:"root",factory:function(){return null}}),VRe=new pe("LIVE_ANNOUNCER_DEFAULT_OPTIONS"),tw=(()=>{class n{constructor(e,i,r,o){this._ngZone=i,this._defaultOptions=o,this._document=r,this._liveElement=e||this._createLiveElement()}announce(e,...i){let o,s,r=this._defaultOptions;return 1===i.length&&"number"==typeof i[0]?s=i[0]:[o,s]=i,this.clear(),clearTimeout(this._previousTimeout),o||(o=r&&r.politeness?r.politeness:"polite"),null==s&&r&&(s=r.duration),this._liveElement.setAttribute("aria-live",o),this._ngZone.runOutsideAngular(()=>(this._currentPromise||(this._currentPromise=new Promise(a=>this._currentResolve=a)),clearTimeout(this._previousTimeout),this._previousTimeout=setTimeout(()=>{this._liveElement.textContent=e,"number"==typeof s&&(this._previousTimeout=setTimeout(()=>this.clear(),s)),this._currentResolve(),this._currentPromise=this._currentResolve=void 0},100),this._currentPromise))}clear(){this._liveElement&&(this._liveElement.textContent="")}ngOnDestroy(){clearTimeout(this._previousTimeout),this._liveElement?.remove(),this._liveElement=null,this._currentResolve?.(),this._currentPromise=this._currentResolve=void 0}_createLiveElement(){let e="cdk-live-announcer-element",i=this._document.getElementsByClassName(e),r=this._document.createElement("div");for(let o=0;o<i.length;o++)i[o].remove();return r.classList.add(e),r.classList.add("cdk-visually-hidden"),r.setAttribute("aria-atomic","true"),r.setAttribute("aria-live","polite"),this._document.body.appendChild(r),r}}return n.\u0275fac=function(e){return new(e||n)(j(LRe,8),j(_t),j(Ht),j(VRe,8))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),HRe=new pe("cdk-focus-monitor-default-options"),d2=la({passive:!0,capture:!0}),Fr=(()=>{class n{constructor(e,i,r,o,s){this._ngZone=e,this._platform=i,this._inputModalityDetector=r,this._origin=null,this._windowFocused=!1,this._originFromTouchInteraction=!1,this._elementInfo=new Map,this._monitoredElementCount=0,this._rootNodeFocusListenerCount=new Map,this._windowFocusListener=()=>{this._windowFocused=!0,this._windowFocusTimeoutId=window.setTimeout(()=>this._windowFocused=!1)},this._stopInputModalityDetector=new ke,this._rootNodeFocusAndBlurListener=a=>{for(let c=Qc(a);c;c=c.parentElement)"focus"===a.type?this._onFocus(a,c):this._onBlur(a,c)},this._document=o,this._detectionMode=s?.detectionMode||0}monitor(e,i=!1){let r=La(e);if(!this._platform.isBrowser||1!==r.nodeType)return Xt(null);let o=a2(r)||this._getDocument(),s=this._elementInfo.get(r);if(s)return i&&(s.checkChildren=!0),s.subject;let a={checkChildren:i,subject:new ke,rootNode:o};return this._elementInfo.set(r,a),this._registerGlobalListeners(a),a.subject}stopMonitoring(e){let i=La(e),r=this._elementInfo.get(i);r&&(r.subject.complete(),this._setClasses(i),this._elementInfo.delete(i),this._removeGlobalListeners(r))}focusVia(e,i,r){let o=La(e);o===this._getDocument().activeElement?this._getClosestElementsInfo(o).forEach(([a,l])=>this._originChanged(a,i,l)):(this._setOrigin(i),"function"==typeof o.focus&&o.focus(r))}ngOnDestroy(){this._elementInfo.forEach((e,i)=>this.stopMonitoring(i))}_getDocument(){return this._document||document}_getWindow(){return this._getDocument().defaultView||window}_getFocusOrigin(e){return this._origin?this._originFromTouchInteraction?this._shouldBeAttributedToTouch(e)?"touch":"program":this._origin:this._windowFocused&&this._lastFocusOrigin?this._lastFocusOrigin:e&&this._isLastInteractionFromInputLabel(e)?"mouse":"program"}_shouldBeAttributedToTouch(e){return 1===this._detectionMode||!!e?.contains(this._inputModalityDetector._mostRecentTarget)}_setClasses(e,i){e.classList.toggle("cdk-focused",!!i),e.classList.toggle("cdk-touch-focused","touch"===i),e.classList.toggle("cdk-keyboard-focused","keyboard"===i),e.classList.toggle("cdk-mouse-focused","mouse"===i),e.classList.toggle("cdk-program-focused","program"===i)}_setOrigin(e,i=!1){this._ngZone.runOutsideAngular(()=>{this._origin=e,this._originFromTouchInteraction="touch"===e&&i,0===this._detectionMode&&(clearTimeout(this._originTimeoutId),this._originTimeoutId=setTimeout(()=>this._origin=null,this._originFromTouchInteraction?650:1))})}_onFocus(e,i){let r=this._elementInfo.get(i),o=Qc(e);!r||!r.checkChildren&&i!==o||this._originChanged(i,this._getFocusOrigin(o),r)}_onBlur(e,i){let r=this._elementInfo.get(i);!r||r.checkChildren&&e.relatedTarget instanceof Node&&i.contains(e.relatedTarget)||(this._setClasses(i),this._emitOrigin(r,null))}_emitOrigin(e,i){e.subject.observers.length&&this._ngZone.run(()=>e.subject.next(i))}_registerGlobalListeners(e){if(!this._platform.isBrowser)return;let i=e.rootNode,r=this._rootNodeFocusListenerCount.get(i)||0;r||this._ngZone.runOutsideAngular(()=>{i.addEventListener("focus",this._rootNodeFocusAndBlurListener,d2),i.addEventListener("blur",this._rootNodeFocusAndBlurListener,d2)}),this._rootNodeFocusListenerCount.set(i,r+1),1==++this._monitoredElementCount&&(this._ngZone.runOutsideAngular(()=>{this._getWindow().addEventListener("focus",this._windowFocusListener)}),this._inputModalityDetector.modalityDetected.pipe(st(this._stopInputModalityDetector)).subscribe(o=>{this._setOrigin(o,!0)}))}_removeGlobalListeners(e){let i=e.rootNode;if(this._rootNodeFocusListenerCount.has(i)){let r=this._rootNodeFocusListenerCount.get(i);r>1?this._rootNodeFocusListenerCount.set(i,r-1):(i.removeEventListener("focus",this._rootNodeFocusAndBlurListener,d2),i.removeEventListener("blur",this._rootNodeFocusAndBlurListener,d2),this._rootNodeFocusListenerCount.delete(i))}--this._monitoredElementCount||(this._getWindow().removeEventListener("focus",this._windowFocusListener),this._stopInputModalityDetector.next(),clearTimeout(this._windowFocusTimeoutId),clearTimeout(this._originTimeoutId))}_originChanged(e,i,r){this._setClasses(e,i),this._emitOrigin(r,i),this._lastFocusOrigin=i}_getClosestElementsInfo(e){let i=[];return this._elementInfo.forEach((r,o)=>{(o===e||r.checkChildren&&o.contains(e))&&i.push([o,r])}),i}_isLastInteractionFromInputLabel(e){let{_mostRecentTarget:i,mostRecentModality:r}=this._inputModalityDetector;if("mouse"!==r||!i||i===e||"INPUT"!==e.nodeName&&"TEXTAREA"!==e.nodeName||e.disabled)return!1;let o=e.labels;if(o)for(let s=0;s<o.length;s++)if(o[s].contains(i))return!0;return!1}}return n.\u0275fac=function(e){return new(e||n)(j(_t),j(oi),j(NRe),j(Ht,8),j(HRe,8))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),nte=(()=>{class n{constructor(e,i){this._elementRef=e,this._focusMonitor=i,this._focusOrigin=null,this.cdkFocusChange=new G}get focusOrigin(){return this._focusOrigin}ngAfterViewInit(){let e=this._elementRef.nativeElement;this._monitorSubscription=this._focusMonitor.monitor(e,1===e.nodeType&&e.hasAttribute("cdkMonitorSubtreeFocus")).subscribe(i=>{this._focusOrigin=i,this.cdkFocusChange.emit(i)})}ngOnDestroy(){this._focusMonitor.stopMonitoring(this._elementRef),this._monitorSubscription&&this._monitorSubscription.unsubscribe()}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(Fr))},n.\u0275dir=He({type:n,selectors:[["","cdkMonitorElementFocus",""],["","cdkMonitorSubtreeFocus",""]],outputs:{cdkFocusChange:"cdkFocusChange"},exportAs:["cdkMonitorFocus"]}),n})(),Kee="cdk-high-contrast-black-on-white",Zee="cdk-high-contrast-white-on-black",mH="cdk-high-contrast-active",CH=(()=>{class n{constructor(e,i){this._platform=e,this._document=i,this._breakpointSubscription=jo(Jm).observe("(forced-colors: active)").subscribe(()=>{this._hasCheckedHighContrastMode&&(this._hasCheckedHighContrastMode=!1,this._applyBodyHighContrastModeCssClasses())})}getHighContrastMode(){if(!this._platform.isBrowser)return 0;let e=this._document.createElement("div");e.style.backgroundColor="rgb(1,2,3)",e.style.position="absolute",this._document.body.appendChild(e);let i=this._document.defaultView||window,r=i&&i.getComputedStyle?i.getComputedStyle(e):null,o=(r&&r.backgroundColor||"").replace(/ /g,"");switch(e.remove(),o){case"rgb(0,0,0)":case"rgb(45,50,54)":case"rgb(32,32,32)":return 2;case"rgb(255,255,255)":case"rgb(255,250,239)":return 1}return 0}ngOnDestroy(){this._breakpointSubscription.unsubscribe()}_applyBodyHighContrastModeCssClasses(){if(!this._hasCheckedHighContrastMode&&this._platform.isBrowser&&this._document.body){let e=this._document.body.classList;e.remove(mH,Kee,Zee),this._hasCheckedHighContrastMode=!0;let i=this.getHighContrastMode();1===i?e.add(mH,Kee):2===i&&e.add(mH,Zee)}}}return n.\u0275fac=function(e){return new(e||n)(j(oi),j(Ht))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Ev=(()=>{class n{constructor(e){e._applyBodyHighContrastModeCssClasses()}}return n.\u0275fac=function(e){return new(e||n)(j(CH))},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[od]}),n})(),URe=new pe("cdk-dir-doc",{providedIn:"root",factory:function(){return jo(Ht)}}),jRe=/^(ar|ckb|dv|he|iw|fa|nqo|ps|sd|ug|ur|yi|.*[-_](Adlm|Arab|Hebr|Nkoo|Rohg|Thaa))(?!.*[-_](Latn|Cyrl)($|-|_))($|-|_)/i,$i=(()=>{class n{constructor(e){if(this.value="ltr",this.change=new G,e){let r=e.documentElement?e.documentElement.dir:null;this.value=function(n){let t=n?.toLowerCase()||"";return"auto"===t&&typeof navigator<"u"&&navigator?.language?jRe.test(navigator.language)?"rtl":"ltr":"rtl"===t?"rtl":"ltr"}((e.body?e.body.dir:null)||r||"ltr")}}ngOnDestroy(){this.change.complete()}}return n.\u0275fac=function(e){return new(e||n)(j(URe,8))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Dh=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})();function WRe(n,t){if(1&n&&O(0,"mat-pseudo-checkbox",4),2&n){let e=S();y("state",e.selected?"checked":"unchecked")("disabled",e.disabled)}}function qRe(n,t){if(1&n&&(_(0,"span",5),A(1),v()),2&n){let e=S();C(1),je("(",e.group.label,")")}}var YRe=["*"],ste=(new Ic("14.2.7"),(()=>{class n{}return n.STANDARD_CURVE="cubic-bezier(0.4,0.0,0.2,1)",n.DECELERATION_CURVE="cubic-bezier(0.0,0.0,0.2,1)",n.ACCELERATION_CURVE="cubic-bezier(0.4,0.0,1,1)",n.SHARP_CURVE="cubic-bezier(0.4,0.0,0.6,1)",n})()),ate=(()=>{class n{}return n.COMPLEX="375ms",n.ENTERING="225ms",n.EXITING="195ms",n})(),QRe=new pe("mat-sanity-checks",{providedIn:"root",factory:function(){return!0}}),ln=(()=>{class n{constructor(e,i,r){this._sanityChecks=i,this._document=r,this._hasDoneGlobalChecks=!1,e._applyBodyHighContrastModeCssClasses(),this._hasDoneGlobalChecks||(this._hasDoneGlobalChecks=!0)}_checkIsEnabled(e){return!ZM()&&("boolean"==typeof this._sanityChecks?this._sanityChecks:!!this._sanityChecks[e])}}return n.\u0275fac=function(e){return new(e||n)(j(CH),j(QRe,8),j(Ht))},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Dh,Dh]}),n})();function so(n){return class extends n{constructor(...t){super(...t),this._disabled=!1}get disabled(){return this._disabled}set disabled(t){this._disabled=Rt(t)}}}function ko(n,t){return class extends n{constructor(...e){super(...e),this.defaultColor=t,this.color=t}get color(){return this._color}set color(e){let i=e||this.defaultColor;i!==this._color&&(this._color&&this._elementRef.nativeElement.classList.remove(`mat-${this._color}`),i&&this._elementRef.nativeElement.classList.add(`mat-${i}`),this._color=i)}}}function qo(n){return class extends n{constructor(...t){super(...t),this._disableRipple=!1}get disableRipple(){return this._disableRipple}set disableRipple(t){this._disableRipple=Rt(t)}}}function oc(n,t=0){return class extends n{constructor(...e){super(...e),this._tabIndex=t,this.defaultTabIndex=t}get tabIndex(){return this.disabled?-1:this._tabIndex}set tabIndex(e){this._tabIndex=null!=e?Bi(e):this.defaultTabIndex}}}function Dv(n){return class extends n{constructor(...t){super(...t),this.errorState=!1}updateErrorState(){let t=this.errorState,o=(this.errorStateMatcher||this._defaultErrorStateMatcher).isErrorState(this.ngControl?this.ngControl.control:null,this._parentFormGroup||this._parentForm);o!==t&&(this.errorState=o,this.stateChanges.next())}}}function m2(n){return class extends n{constructor(...t){super(...t),this._isInitialized=!1,this._pendingSubscribers=[],this.initialized=new un(e=>{this._isInitialized?this._notifySubscriber(e):this._pendingSubscribers.push(e)})}_markInitialized(){this._isInitialized=!0,this._pendingSubscribers.forEach(this._notifySubscriber),this._pendingSubscribers=null}_notifySubscriber(t){t.next(),t.complete()}}}new pe("MAT_DATE_LOCALE",{providedIn:"root",factory:function(){return jo(Wd)}}),new pe("mat-date-formats");var cd=(()=>{class n{isErrorState(e,i){return!!(e&&e.invalid&&(e.touched||i&&i.submitted))}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),ite={enterDuration:225,exitDuration:150},MH=la({passive:!0}),rte=["mousedown","touchstart"],ote=["mouseup","mouseleave","touchend","touchcancel"],Tv=class{constructor(t,e,i,r){this._target=t,this._ngZone=e,this._isPointerDown=!1,this._activeRipples=new Map,this._pointerUpEventsRegistered=!1,r.isBrowser&&(this._containerElement=La(i))}fadeInRipple(t,e,i={}){let r=this._containerRect=this._containerRect||this._containerElement.getBoundingClientRect(),o={...ite,...i.animation};i.centered&&(t=r.left+r.width/2,e=r.top+r.height/2);let s=i.radius||function(n,t,e){let i=Math.max(Math.abs(n-e.left),Math.abs(n-e.right)),r=Math.max(Math.abs(t-e.top),Math.abs(t-e.bottom));return Math.sqrt(i*i+r*r)}(t,e,r),a=t-r.left,l=e-r.top,c=o.enterDuration,u=document.createElement("div");u.classList.add("mat-ripple-element"),u.style.left=a-s+"px",u.style.top=l-s+"px",u.style.height=2*s+"px",u.style.width=2*s+"px",null!=i.color&&(u.style.backgroundColor=i.color),u.style.transitionDuration=`${c}ms`,this._containerElement.appendChild(u);let d=window.getComputedStyle(u),h=d.transitionDuration,f="none"===d.transitionProperty||"0s"===h||"0s, 0s"===h,m=new class{constructor(t,e,i,r=!1){this._renderer=t,this.element=e,this.config=i,this._animationForciblyDisabledThroughCss=r,this.state=3}fadeOut(){this._renderer.fadeOutRipple(this)}}(this,u,i,f);u.style.transform="scale3d(1, 1, 1)",m.state=0,i.persistent||(this._mostRecentTransientRipple=m);let x=null;return!f&&(c||o.exitDuration)&&this._ngZone.runOutsideAngular(()=>{let g=()=>this._finishRippleTransition(m),b=()=>this._destroyRipple(m);u.addEventListener("transitionend",g),u.addEventListener("transitioncancel",b),x={onTransitionEnd:g,onTransitionCancel:b}}),this._activeRipples.set(m,x),(f||!c)&&this._finishRippleTransition(m),m}fadeOutRipple(t){if(2===t.state||3===t.state)return;let e=t.element,i={...ite,...t.config.animation};e.style.transitionDuration=`${i.exitDuration}ms`,e.style.opacity="0",t.state=2,(t._animationForciblyDisabledThroughCss||!i.exitDuration)&&this._finishRippleTransition(t)}fadeOutAll(){this._getActiveRipples().forEach(t=>t.fadeOut())}fadeOutAllNonPersistent(){this._getActiveRipples().forEach(t=>{t.config.persistent||t.fadeOut()})}setupTriggerEvents(t){let e=La(t);!e||e===this._triggerElement||(this._removeTriggerEvents(),this._triggerElement=e,this._registerEvents(rte))}handleEvent(t){"mousedown"===t.type?this._onMousedown(t):"touchstart"===t.type?this._onTouchStart(t):this._onPointerUp(),this._pointerUpEventsRegistered||(this._registerEvents(ote),this._pointerUpEventsRegistered=!0)}_finishRippleTransition(t){0===t.state?this._startFadeOutTransition(t):2===t.state&&this._destroyRipple(t)}_startFadeOutTransition(t){let e=t===this._mostRecentTransientRipple,{persistent:i}=t.config;t.state=1,!i&&(!e||!this._isPointerDown)&&t.fadeOut()}_destroyRipple(t){let e=this._activeRipples.get(t)??null;this._activeRipples.delete(t),this._activeRipples.size||(this._containerRect=null),t===this._mostRecentTransientRipple&&(this._mostRecentTransientRipple=null),t.state=3,null!==e&&(t.element.removeEventListener("transitionend",e.onTransitionEnd),t.element.removeEventListener("transitioncancel",e.onTransitionCancel)),t.element.remove()}_onMousedown(t){let e=$M(t),i=this._lastTouchStartEvent&&Date.now()<this._lastTouchStartEvent+800;!this._target.rippleDisabled&&!e&&!i&&(this._isPointerDown=!0,this.fadeInRipple(t.clientX,t.clientY,this._target.rippleConfig))}_onTouchStart(t){if(!this._target.rippleDisabled&&!ew(t)){this._lastTouchStartEvent=Date.now(),this._isPointerDown=!0;let e=t.changedTouches;for(let i=0;i<e.length;i++)this.fadeInRipple(e[i].clientX,e[i].clientY,this._target.rippleConfig)}}_onPointerUp(){!this._isPointerDown||(this._isPointerDown=!1,this._getActiveRipples().forEach(t=>{!t.config.persistent&&(1===t.state||t.config.terminateOnPointerUp&&0===t.state)&&t.fadeOut()}))}_registerEvents(t){this._ngZone.runOutsideAngular(()=>{t.forEach(e=>{this._triggerElement.addEventListener(e,this,MH)})})}_getActiveRipples(){return Array.from(this._activeRipples.keys())}_removeTriggerEvents(){this._triggerElement&&(rte.forEach(t=>{this._triggerElement.removeEventListener(t,this,MH)}),this._pointerUpEventsRegistered&&ote.forEach(t=>{this._triggerElement.removeEventListener(t,this,MH)}))}},g2=new pe("mat-ripple-global-options"),Yo=(()=>{class n{constructor(e,i,r,o,s){this._elementRef=e,this._animationMode=s,this.radius=0,this._disabled=!1,this._isInitialized=!1,this._globalOptions=o||{},this._rippleRenderer=new Tv(this,i,e,r)}get disabled(){return this._disabled}set disabled(e){e&&this.fadeOutAllNonPersistent(),this._disabled=e,this._setupTriggerEventsIfEnabled()}get trigger(){return this._trigger||this._elementRef.nativeElement}set trigger(e){this._trigger=e,this._setupTriggerEventsIfEnabled()}ngOnInit(){this._isInitialized=!0,this._setupTriggerEventsIfEnabled()}ngOnDestroy(){this._rippleRenderer._removeTriggerEvents()}fadeOutAll(){this._rippleRenderer.fadeOutAll()}fadeOutAllNonPersistent(){this._rippleRenderer.fadeOutAllNonPersistent()}get rippleConfig(){return{centered:this.centered,radius:this.radius,color:this.color,animation:{...this._globalOptions.animation,..."NoopAnimations"===this._animationMode?{enterDuration:0,exitDuration:0}:{},...this.animation},terminateOnPointerUp:this._globalOptions.terminateOnPointerUp}}get rippleDisabled(){return this.disabled||!!this._globalOptions.disabled}_setupTriggerEventsIfEnabled(){!this.disabled&&this._isInitialized&&this._rippleRenderer.setupTriggerEvents(this.trigger)}launch(e,i=0,r){return"number"==typeof e?this._rippleRenderer.fadeInRipple(e,i,{...this.rippleConfig,...r}):this._rippleRenderer.fadeInRipple(0,0,{...this.rippleConfig,...e})}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(_t),M(oi),M(g2,8),M(Pi,8))},n.\u0275dir=He({type:n,selectors:[["","mat-ripple",""],["","matRipple",""]],hostAttrs:[1,"mat-ripple"],hostVars:2,hostBindings:function(e,i){2&e&&et("mat-ripple-unbounded",i.unbounded)},inputs:{color:["matRippleColor","color"],unbounded:["matRippleUnbounded","unbounded"],centered:["matRippleCentered","centered"],radius:["matRippleRadius","radius"],animation:["matRippleAnimation","animation"],disabled:["matRippleDisabled","disabled"],trigger:["matRippleTrigger","trigger"]},exportAs:["matRipple"]}),n})(),_l=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[ln,ln]}),n})(),$Re=(()=>{class n{constructor(e){this._animationMode=e,this.state="unchecked",this.disabled=!1}}return n.\u0275fac=function(e){return new(e||n)(M(Pi,8))},n.\u0275cmp=R({type:n,selectors:[["mat-pseudo-checkbox"]],hostAttrs:[1,"mat-pseudo-checkbox"],hostVars:8,hostBindings:function(e,i){2&e&&et("mat-pseudo-checkbox-indeterminate","indeterminate"===i.state)("mat-pseudo-checkbox-checked","checked"===i.state)("mat-pseudo-checkbox-disabled",i.disabled)("_mat-animation-noopable","NoopAnimations"===i._animationMode)},inputs:{state:"state",disabled:"disabled"},decls:0,vars:0,template:function(e,i){},styles:['.mat-pseudo-checkbox{width:16px;height:16px;border:2px solid;border-radius:2px;cursor:pointer;display:inline-block;vertical-align:middle;box-sizing:border-box;position:relative;flex-shrink:0;transition:border-color 90ms cubic-bezier(0, 0, 0.2, 0.1),background-color 90ms cubic-bezier(0, 0, 0.2, 0.1)}.mat-pseudo-checkbox::after{position:absolute;opacity:0;content:"";border-bottom:2px solid currentColor;transition:opacity 90ms cubic-bezier(0, 0, 0.2, 0.1)}.mat-pseudo-checkbox.mat-pseudo-checkbox-checked,.mat-pseudo-checkbox.mat-pseudo-checkbox-indeterminate{border-color:rgba(0,0,0,0)}.mat-pseudo-checkbox._mat-animation-noopable{transition:none !important;animation:none !important}.mat-pseudo-checkbox._mat-animation-noopable::after{transition:none}.mat-pseudo-checkbox-disabled{cursor:default}.mat-pseudo-checkbox-indeterminate::after{top:5px;left:1px;width:10px;opacity:1;border-radius:2px}.mat-pseudo-checkbox-checked::after{top:2.4px;left:1px;width:8px;height:3px;border-left:2px solid currentColor;transform:rotate(-45deg);opacity:1;box-sizing:content-box}'],encapsulation:2,changeDetection:0}),n})(),eOe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[ln]}),n})(),iw=new pe("MAT_OPTION_PARENT_COMPONENT"),rw=(so(class{}),new pe("MatOptgroup")),tOe=0,nw=class{constructor(t,e=!1){this.source=t,this.isUserInput=e}},nOe=(()=>{class n{constructor(e,i,r,o){this._element=e,this._changeDetectorRef=i,this._parent=r,this.group=o,this._selected=!1,this._active=!1,this._disabled=!1,this._mostRecentViewValue="",this.id="mat-option-"+tOe++,this.onSelectionChange=new G,this._stateChanges=new ke}get multiple(){return this._parent&&this._parent.multiple}get selected(){return this._selected}get disabled(){return this.group&&this.group.disabled||this._disabled}set disabled(e){this._disabled=Rt(e)}get disableRipple(){return!(!this._parent||!this._parent.disableRipple)}get active(){return this._active}get viewValue(){return(this._getHostElement().textContent||"").trim()}select(){this._selected||(this._selected=!0,this._changeDetectorRef.markForCheck(),this._emitSelectionChangeEvent())}deselect(){this._selected&&(this._selected=!1,this._changeDetectorRef.markForCheck(),this._emitSelectionChangeEvent())}focus(e,i){let r=this._getHostElement();"function"==typeof r.focus&&r.focus(i)}setActiveStyles(){this._active||(this._active=!0,this._changeDetectorRef.markForCheck())}setInactiveStyles(){this._active&&(this._active=!1,this._changeDetectorRef.markForCheck())}getLabel(){return this.viewValue}_handleKeydown(e){(13===e.keyCode||32===e.keyCode)&&!kr(e)&&(this._selectViaInteraction(),e.preventDefault())}_selectViaInteraction(){this.disabled||(this._selected=!this.multiple||!this._selected,this._changeDetectorRef.markForCheck(),this._emitSelectionChangeEvent(!0))}_getAriaSelected(){return this.selected||!this.multiple&&null}_getTabIndex(){return this.disabled?"-1":"0"}_getHostElement(){return this._element.nativeElement}ngAfterViewChecked(){if(this._selected){let e=this.viewValue;e!==this._mostRecentViewValue&&(this._mostRecentViewValue=e,this._stateChanges.next())}}ngOnDestroy(){this._stateChanges.complete()}_emitSelectionChangeEvent(e=!1){this.onSelectionChange.emit(new nw(this,e))}}return n.\u0275fac=function(e){nl()},n.\u0275dir=He({type:n,inputs:{value:"value",id:"id",disabled:"disabled"},outputs:{onSelectionChange:"onSelectionChange"}}),n})(),Os=(()=>{class n extends nOe{constructor(e,i,r,o){super(e,i,r,o)}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(nn),M(iw,8),M(rw,8))},n.\u0275cmp=R({type:n,selectors:[["mat-option"]],hostAttrs:["role","option",1,"mat-option","mat-focus-indicator"],hostVars:12,hostBindings:function(e,i){1&e&&P("click",function(){return i._selectViaInteraction()})("keydown",function(o){return i._handleKeydown(o)}),2&e&&(_s("id",i.id),ze("tabindex",i._getTabIndex())("aria-selected",i._getAriaSelected())("aria-disabled",i.disabled.toString()),et("mat-selected",i.selected)("mat-option-multiple",i.multiple)("mat-active",i.active)("mat-option-disabled",i.disabled))},exportAs:["matOption"],features:[tt],ngContentSelectors:YRe,decls:5,vars:4,consts:[["class","mat-option-pseudo-checkbox",3,"state","disabled",4,"ngIf"],[1,"mat-option-text"],["class","cdk-visually-hidden",4,"ngIf"],["mat-ripple","",1,"mat-option-ripple",3,"matRippleTrigger","matRippleDisabled"],[1,"mat-option-pseudo-checkbox",3,"state","disabled"],[1,"cdk-visually-hidden"]],template:function(e,i){1&e&&(xi(),E(0,WRe,1,2,"mat-pseudo-checkbox",0),_(1,"span",1),Vn(2),v(),E(3,qRe,2,1,"span",2),O(4,"div",3)),2&e&&(y("ngIf",i.multiple),C(3),y("ngIf",i.group&&i.group._inert),C(1),y("matRippleTrigger",i._getHostElement())("matRippleDisabled",i.disabled||i.disableRipple))},dependencies:[Yo,Be,$Re],styles:['.mat-option{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;line-height:48px;height:48px;padding:0 16px;text-align:left;text-decoration:none;max-width:100%;position:relative;cursor:pointer;outline:none;display:flex;flex-direction:row;max-width:100%;box-sizing:border-box;align-items:center;-webkit-tap-highlight-color:rgba(0,0,0,0)}.mat-option[disabled]{cursor:default}[dir=rtl] .mat-option{text-align:right}.mat-option .mat-icon{margin-right:16px;vertical-align:middle}.mat-option .mat-icon svg{vertical-align:top}[dir=rtl] .mat-option .mat-icon{margin-left:16px;margin-right:0}.mat-option[aria-disabled=true]{-webkit-user-select:none;user-select:none;cursor:default}.mat-optgroup .mat-option:not(.mat-option-multiple){padding-left:32px}[dir=rtl] .mat-optgroup .mat-option:not(.mat-option-multiple){padding-left:16px;padding-right:32px}.mat-option.mat-active::before{content:""}.cdk-high-contrast-active .mat-option[aria-disabled=true]{opacity:.5}.cdk-high-contrast-active .mat-option.mat-selected:not(.mat-option-multiple)::after{content:"";position:absolute;top:50%;right:16px;transform:translateY(-50%);width:10px;height:0;border-bottom:solid 10px;border-radius:10px}[dir=rtl] .cdk-high-contrast-active .mat-option.mat-selected:not(.mat-option-multiple)::after{right:auto;left:16px}.mat-option-text{display:inline-block;flex-grow:1;overflow:hidden;text-overflow:ellipsis}.mat-option .mat-option-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}.mat-option-pseudo-checkbox{margin-right:8px}[dir=rtl] .mat-option-pseudo-checkbox{margin-left:8px;margin-right:0}'],encapsulation:2,changeDetection:0}),n})();function ow(n,t,e){if(e.length){let i=t.toArray(),r=e.toArray(),o=0;for(let s=0;s<n+1;s++)i[s].group&&i[s].group===r[o]&&o++;return o}return 0}function _2(n,t,e,i){return n<e?n:n+t>e+i?Math.max(0,n-i+t):e}var Av=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[_l,Me,ln,eOe]}),n})(),lte=["mat-button",""],cte=["*"],oOe=["mat-button","mat-flat-button","mat-icon-button","mat-raised-button","mat-stroked-button","mat-mini-fab","mat-fab"],sOe=ko(so(qo(class{constructor(n){this._elementRef=n}}))),_n=(()=>{class n extends sOe{constructor(e,i,r){super(e),this._focusMonitor=i,this._animationMode=r,this.isRoundButton=this._hasHostAttributes("mat-fab","mat-mini-fab"),this.isIconButton=this._hasHostAttributes("mat-icon-button");for(let o of oOe)this._hasHostAttributes(o)&&this._getHostElement().classList.add(o);e.nativeElement.classList.add("mat-button-base"),this.isRoundButton&&(this.color="accent")}ngAfterViewInit(){this._focusMonitor.monitor(this._elementRef,!0)}ngOnDestroy(){this._focusMonitor.stopMonitoring(this._elementRef)}focus(e,i){e?this._focusMonitor.focusVia(this._getHostElement(),e,i):this._getHostElement().focus(i)}_getHostElement(){return this._elementRef.nativeElement}_isRippleDisabled(){return this.disableRipple||this.disabled}_hasHostAttributes(...e){return e.some(i=>this._getHostElement().hasAttribute(i))}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(Fr),M(Pi,8))},n.\u0275cmp=R({type:n,selectors:[["button","mat-button",""],["button","mat-raised-button",""],["button","mat-icon-button",""],["button","mat-fab",""],["button","mat-mini-fab",""],["button","mat-stroked-button",""],["button","mat-flat-button",""]],viewQuery:function(e,i){if(1&e&&ot(Yo,5),2&e){let r;Ne(r=Le())&&(i.ripple=r.first)}},hostAttrs:[1,"mat-focus-indicator"],hostVars:5,hostBindings:function(e,i){2&e&&(ze("disabled",i.disabled||null),et("_mat-animation-noopable","NoopAnimations"===i._animationMode)("mat-button-disabled",i.disabled))},inputs:{disabled:"disabled",disableRipple:"disableRipple",color:"color"},exportAs:["matButton"],features:[tt],attrs:lte,ngContentSelectors:cte,decls:4,vars:5,consts:[[1,"mat-button-wrapper"],["matRipple","",1,"mat-button-ripple",3,"matRippleDisabled","matRippleCentered","matRippleTrigger"],[1,"mat-button-focus-overlay"]],template:function(e,i){1&e&&(xi(),_(0,"span",0),Vn(1),v(),O(2,"span",1)(3,"span",2)),2&e&&(C(2),et("mat-button-ripple-round",i.isRoundButton||i.isIconButton),y("matRippleDisabled",i._isRippleDisabled())("matRippleCentered",i.isIconButton)("matRippleTrigger",i._getHostElement()))},dependencies:[Yo],styles:[".mat-button .mat-button-focus-overlay,.mat-icon-button .mat-button-focus-overlay{opacity:0}.mat-button:hover:not(.mat-button-disabled) .mat-button-focus-overlay,.mat-stroked-button:hover:not(.mat-button-disabled) .mat-button-focus-overlay{opacity:.04}@media(hover: none){.mat-button:hover:not(.mat-button-disabled) .mat-button-focus-overlay,.mat-stroked-button:hover:not(.mat-button-disabled) .mat-button-focus-overlay{opacity:0}}.mat-button,.mat-icon-button,.mat-stroked-button,.mat-flat-button{box-sizing:border-box;position:relative;-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0);display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible}.mat-button::-moz-focus-inner,.mat-icon-button::-moz-focus-inner,.mat-stroked-button::-moz-focus-inner,.mat-flat-button::-moz-focus-inner{border:0}.mat-button.mat-button-disabled,.mat-icon-button.mat-button-disabled,.mat-stroked-button.mat-button-disabled,.mat-flat-button.mat-button-disabled{cursor:default}.mat-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-button.cdk-program-focused .mat-button-focus-overlay,.mat-icon-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-icon-button.cdk-program-focused .mat-button-focus-overlay,.mat-stroked-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-stroked-button.cdk-program-focused .mat-button-focus-overlay,.mat-flat-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-flat-button.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-button::-moz-focus-inner,.mat-icon-button::-moz-focus-inner,.mat-stroked-button::-moz-focus-inner,.mat-flat-button::-moz-focus-inner{border:0}.mat-raised-button{box-sizing:border-box;position:relative;-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0);display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1)}.mat-raised-button::-moz-focus-inner{border:0}.mat-raised-button.mat-button-disabled{cursor:default}.mat-raised-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-raised-button.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-raised-button::-moz-focus-inner{border:0}.mat-raised-button._mat-animation-noopable{transition:none !important;animation:none !important}.mat-stroked-button{border:1px solid currentColor;padding:0 15px;line-height:34px}.mat-stroked-button .mat-button-ripple.mat-ripple,.mat-stroked-button .mat-button-focus-overlay{top:-1px;left:-1px;right:-1px;bottom:-1px}.mat-fab{box-sizing:border-box;position:relative;-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0);display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);min-width:0;border-radius:50%;width:56px;height:56px;padding:0;flex-shrink:0}.mat-fab::-moz-focus-inner{border:0}.mat-fab.mat-button-disabled{cursor:default}.mat-fab.cdk-keyboard-focused .mat-button-focus-overlay,.mat-fab.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-fab::-moz-focus-inner{border:0}.mat-fab._mat-animation-noopable{transition:none !important;animation:none !important}.mat-fab .mat-button-wrapper{padding:16px 0;display:inline-block;line-height:24px}.mat-mini-fab{box-sizing:border-box;position:relative;-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0);display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);min-width:0;border-radius:50%;width:40px;height:40px;padding:0;flex-shrink:0}.mat-mini-fab::-moz-focus-inner{border:0}.mat-mini-fab.mat-button-disabled{cursor:default}.mat-mini-fab.cdk-keyboard-focused .mat-button-focus-overlay,.mat-mini-fab.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-mini-fab::-moz-focus-inner{border:0}.mat-mini-fab._mat-animation-noopable{transition:none !important;animation:none !important}.mat-mini-fab .mat-button-wrapper{padding:8px 0;display:inline-block;line-height:24px}.mat-icon-button{padding:0;min-width:0;width:40px;height:40px;flex-shrink:0;line-height:40px;border-radius:50%}.mat-icon-button i,.mat-icon-button .mat-icon{line-height:24px}.mat-button-ripple.mat-ripple,.mat-button-focus-overlay{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;border-radius:inherit}.mat-button-ripple.mat-ripple:not(:empty){transform:translateZ(0)}.mat-button-focus-overlay{opacity:0;transition:opacity 200ms cubic-bezier(0.35, 0, 0.25, 1),background-color 200ms cubic-bezier(0.35, 0, 0.25, 1)}._mat-animation-noopable .mat-button-focus-overlay{transition:none}.mat-button-ripple-round{border-radius:50%;z-index:1}.mat-button .mat-button-wrapper>*,.mat-flat-button .mat-button-wrapper>*,.mat-stroked-button .mat-button-wrapper>*,.mat-raised-button .mat-button-wrapper>*,.mat-icon-button .mat-button-wrapper>*,.mat-fab .mat-button-wrapper>*,.mat-mini-fab .mat-button-wrapper>*{vertical-align:middle}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon-button,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon-button{display:inline-flex;justify-content:center;align-items:center;font-size:inherit;width:2.5em;height:2.5em}.mat-flat-button::before,.mat-raised-button::before,.mat-fab::before,.mat-mini-fab::before{margin:calc(calc(var(--mat-focus-indicator-border-width, 3px) + 2px) * -1)}.mat-stroked-button::before{margin:calc(calc(var(--mat-focus-indicator-border-width, 3px) + 3px) * -1)}.cdk-high-contrast-active .mat-button,.cdk-high-contrast-active .mat-flat-button,.cdk-high-contrast-active .mat-raised-button,.cdk-high-contrast-active .mat-icon-button,.cdk-high-contrast-active .mat-fab,.cdk-high-contrast-active .mat-mini-fab{outline:solid 1px}"],encapsulation:2,changeDetection:0}),n})(),Iv=(()=>{class n extends _n{constructor(e,i,r,o){super(i,e,r),this._ngZone=o,this._haltDisabledEvents=s=>{this.disabled&&(s.preventDefault(),s.stopImmediatePropagation())}}ngAfterViewInit(){super.ngAfterViewInit(),this._ngZone?this._ngZone.runOutsideAngular(()=>{this._elementRef.nativeElement.addEventListener("click",this._haltDisabledEvents)}):this._elementRef.nativeElement.addEventListener("click",this._haltDisabledEvents)}ngOnDestroy(){super.ngOnDestroy(),this._elementRef.nativeElement.removeEventListener("click",this._haltDisabledEvents)}}return n.\u0275fac=function(e){return new(e||n)(M(Fr),M(Re),M(Pi,8),M(_t,8))},n.\u0275cmp=R({type:n,selectors:[["a","mat-button",""],["a","mat-raised-button",""],["a","mat-icon-button",""],["a","mat-fab",""],["a","mat-mini-fab",""],["a","mat-stroked-button",""],["a","mat-flat-button",""]],hostAttrs:[1,"mat-focus-indicator"],hostVars:7,hostBindings:function(e,i){2&e&&(ze("tabindex",i.disabled?-1:i.tabIndex)("disabled",i.disabled||null)("aria-disabled",i.disabled.toString()),et("_mat-animation-noopable","NoopAnimations"===i._animationMode)("mat-button-disabled",i.disabled))},inputs:{disabled:"disabled",disableRipple:"disableRipple",color:"color",tabIndex:"tabIndex"},exportAs:["matButton","matAnchor"],features:[tt],attrs:lte,ngContentSelectors:cte,decls:4,vars:5,consts:[[1,"mat-button-wrapper"],["matRipple","",1,"mat-button-ripple",3,"matRippleDisabled","matRippleCentered","matRippleTrigger"],[1,"mat-button-focus-overlay"]],template:function(e,i){1&e&&(xi(),_(0,"span",0),Vn(1),v(),O(2,"span",1)(3,"span",2)),2&e&&(C(2),et("mat-button-ripple-round",i.isRoundButton||i.isIconButton),y("matRippleDisabled",i._isRippleDisabled())("matRippleCentered",i.isIconButton)("matRippleTrigger",i._getHostElement()))},dependencies:[Yo],styles:[".mat-button .mat-button-focus-overlay,.mat-icon-button .mat-button-focus-overlay{opacity:0}.mat-button:hover:not(.mat-button-disabled) .mat-button-focus-overlay,.mat-stroked-button:hover:not(.mat-button-disabled) .mat-button-focus-overlay{opacity:.04}@media(hover: none){.mat-button:hover:not(.mat-button-disabled) .mat-button-focus-overlay,.mat-stroked-button:hover:not(.mat-button-disabled) .mat-button-focus-overlay{opacity:0}}.mat-button,.mat-icon-button,.mat-stroked-button,.mat-flat-button{box-sizing:border-box;position:relative;-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0);display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible}.mat-button::-moz-focus-inner,.mat-icon-button::-moz-focus-inner,.mat-stroked-button::-moz-focus-inner,.mat-flat-button::-moz-focus-inner{border:0}.mat-button.mat-button-disabled,.mat-icon-button.mat-button-disabled,.mat-stroked-button.mat-button-disabled,.mat-flat-button.mat-button-disabled{cursor:default}.mat-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-button.cdk-program-focused .mat-button-focus-overlay,.mat-icon-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-icon-button.cdk-program-focused .mat-button-focus-overlay,.mat-stroked-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-stroked-button.cdk-program-focused .mat-button-focus-overlay,.mat-flat-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-flat-button.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-button::-moz-focus-inner,.mat-icon-button::-moz-focus-inner,.mat-stroked-button::-moz-focus-inner,.mat-flat-button::-moz-focus-inner{border:0}.mat-raised-button{box-sizing:border-box;position:relative;-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0);display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1)}.mat-raised-button::-moz-focus-inner{border:0}.mat-raised-button.mat-button-disabled{cursor:default}.mat-raised-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-raised-button.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-raised-button::-moz-focus-inner{border:0}.mat-raised-button._mat-animation-noopable{transition:none !important;animation:none !important}.mat-stroked-button{border:1px solid currentColor;padding:0 15px;line-height:34px}.mat-stroked-button .mat-button-ripple.mat-ripple,.mat-stroked-button .mat-button-focus-overlay{top:-1px;left:-1px;right:-1px;bottom:-1px}.mat-fab{box-sizing:border-box;position:relative;-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0);display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);min-width:0;border-radius:50%;width:56px;height:56px;padding:0;flex-shrink:0}.mat-fab::-moz-focus-inner{border:0}.mat-fab.mat-button-disabled{cursor:default}.mat-fab.cdk-keyboard-focused .mat-button-focus-overlay,.mat-fab.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-fab::-moz-focus-inner{border:0}.mat-fab._mat-animation-noopable{transition:none !important;animation:none !important}.mat-fab .mat-button-wrapper{padding:16px 0;display:inline-block;line-height:24px}.mat-mini-fab{box-sizing:border-box;position:relative;-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0);display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);min-width:0;border-radius:50%;width:40px;height:40px;padding:0;flex-shrink:0}.mat-mini-fab::-moz-focus-inner{border:0}.mat-mini-fab.mat-button-disabled{cursor:default}.mat-mini-fab.cdk-keyboard-focused .mat-button-focus-overlay,.mat-mini-fab.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-mini-fab::-moz-focus-inner{border:0}.mat-mini-fab._mat-animation-noopable{transition:none !important;animation:none !important}.mat-mini-fab .mat-button-wrapper{padding:8px 0;display:inline-block;line-height:24px}.mat-icon-button{padding:0;min-width:0;width:40px;height:40px;flex-shrink:0;line-height:40px;border-radius:50%}.mat-icon-button i,.mat-icon-button .mat-icon{line-height:24px}.mat-button-ripple.mat-ripple,.mat-button-focus-overlay{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;border-radius:inherit}.mat-button-ripple.mat-ripple:not(:empty){transform:translateZ(0)}.mat-button-focus-overlay{opacity:0;transition:opacity 200ms cubic-bezier(0.35, 0, 0.25, 1),background-color 200ms cubic-bezier(0.35, 0, 0.25, 1)}._mat-animation-noopable .mat-button-focus-overlay{transition:none}.mat-button-ripple-round{border-radius:50%;z-index:1}.mat-button .mat-button-wrapper>*,.mat-flat-button .mat-button-wrapper>*,.mat-stroked-button .mat-button-wrapper>*,.mat-raised-button .mat-button-wrapper>*,.mat-icon-button .mat-button-wrapper>*,.mat-fab .mat-button-wrapper>*,.mat-mini-fab .mat-button-wrapper>*{vertical-align:middle}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon-button,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon-button{display:inline-flex;justify-content:center;align-items:center;font-size:inherit;width:2.5em;height:2.5em}.mat-flat-button::before,.mat-raised-button::before,.mat-fab::before,.mat-mini-fab::before{margin:calc(calc(var(--mat-focus-indicator-border-width, 3px) + 2px) * -1)}.mat-stroked-button::before{margin:calc(calc(var(--mat-focus-indicator-border-width, 3px) + 3px) * -1)}.cdk-high-contrast-active .mat-button,.cdk-high-contrast-active .mat-flat-button,.cdk-high-contrast-active .mat-raised-button,.cdk-high-contrast-active .mat-icon-button,.cdk-high-contrast-active .mat-fab,.cdk-high-contrast-active .mat-mini-fab{outline:solid 1px}"],encapsulation:2,changeDetection:0}),n})(),Pn=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[_l,ln,ln]}),n})(),Pv=class{},v2=class extends Pv{constructor(t){super(),this._data=t}connect(){return ax(this._data)?this._data:Xt(this._data)}disconnect(){}},y2=class{constructor(){this.viewCacheSize=20,this._viewCache=[]}applyChanges(t,e,i,r,o){t.forEachOperation((s,a,l)=>{let c,u;null==s.previousIndex?(c=this._insertView(()=>i(s,a,l),l,e,r(s)),u=c?1:0):null==l?(this._detachAndCacheView(a,e),u=3):(c=this._moveView(a,l,e,r(s)),u=2),o&&o({context:c?.context,operation:u,record:s})})}detach(){for(let t of this._viewCache)t.destroy();this._viewCache=[]}_insertView(t,e,i,r){let o=this._insertViewFromCache(e,i);if(o)return void(o.context.$implicit=r);let s=t();return i.createEmbeddedView(s.templateRef,s.context,s.index)}_detachAndCacheView(t,e){let i=e.detach(t);this._maybeCacheView(i,e)}_moveView(t,e,i,r){let o=i.get(t);return i.move(o,e),o.context.$implicit=r,o}_maybeCacheView(t,e){if(this._viewCache.length<this.viewCacheSize)this._viewCache.push(t);else{let i=e.indexOf(t);-1===i?t.destroy():e.remove(i)}}_insertViewFromCache(t,e){let i=this._viewCache.pop();return i&&e.insert(i,t),i||null}},Ah=class{constructor(t=!1,e,i=!0,r){this._multiple=t,this._emitChanges=i,this.compareWith=r,this._selection=new Set,this._deselectedToEmit=[],this._selectedToEmit=[],this.changed=new ke,e&&e.length&&(t?e.forEach(o=>this._markSelected(o)):this._markSelected(e[0]),this._selectedToEmit.length=0)}get selected(){return this._selected||(this._selected=Array.from(this._selection.values())),this._selected}select(...t){this._verifyValueAssignment(t),t.forEach(i=>this._markSelected(i));let e=this._hasQueuedChanges();return this._emitChangeEvent(),e}deselect(...t){this._verifyValueAssignment(t),t.forEach(i=>this._unmarkSelected(i));let e=this._hasQueuedChanges();return this._emitChangeEvent(),e}setSelection(...t){this._verifyValueAssignment(t);let e=this.selected,i=new Set(t);t.forEach(o=>this._markSelected(o)),e.filter(o=>!i.has(o)).forEach(o=>this._unmarkSelected(o));let r=this._hasQueuedChanges();return this._emitChangeEvent(),r}toggle(t){return this.isSelected(t)?this.deselect(t):this.select(t)}clear(t=!0){this._unmarkAll();let e=this._hasQueuedChanges();return t&&this._emitChangeEvent(),e}isSelected(t){if(this.compareWith){for(let e of this._selection)if(this.compareWith(e,t))return!0;return!1}return this._selection.has(t)}isEmpty(){return 0===this._selection.size}hasValue(){return!this.isEmpty()}sort(t){this._multiple&&this.selected&&this._selected.sort(t)}isMultipleSelection(){return this._multiple}_emitChangeEvent(){this._selected=null,(this._selectedToEmit.length||this._deselectedToEmit.length)&&(this.changed.next({source:this,added:this._selectedToEmit,removed:this._deselectedToEmit}),this._deselectedToEmit=[],this._selectedToEmit=[])}_markSelected(t){this.isSelected(t)||(this._multiple||this._unmarkAll(),this.isSelected(t)||this._selection.add(t),this._emitChanges&&this._selectedToEmit.push(t))}_unmarkSelected(t){this.isSelected(t)&&(this._selection.delete(t),this._emitChanges&&this._deselectedToEmit.push(t))}_unmarkAll(){this.isEmpty()||this._selection.forEach(t=>this._unmarkSelected(t))}_verifyValueAssignment(t){}_hasQueuedChanges(){return!(!this._deselectedToEmit.length&&!this._selectedToEmit.length)}},SH=new pe("_ViewRepeater"),aOe=["contentWrapper"],lOe=["*"],hte=new pe("VIRTUAL_SCROLL_STRATEGY");function cOe(n){return n._scrollStrategy}var b2=(()=>{class n{constructor(){this._itemSize=20,this._minBufferPx=100,this._maxBufferPx=200,this._scrollStrategy=new class{constructor(t,e,i){this._scrolledIndexChange=new ke,this.scrolledIndexChange=this._scrolledIndexChange.pipe(yi()),this._viewport=null,this._itemSize=t,this._minBufferPx=e,this._maxBufferPx=i}attach(t){this._viewport=t,this._updateTotalContentSize(),this._updateRenderedRange()}detach(){this._scrolledIndexChange.complete(),this._viewport=null}updateItemAndBufferSize(t,e,i){this._itemSize=t,this._minBufferPx=e,this._maxBufferPx=i,this._updateTotalContentSize(),this._updateRenderedRange()}onContentScrolled(){this._updateRenderedRange()}onDataLengthChanged(){this._updateTotalContentSize(),this._updateRenderedRange()}onContentRendered(){}onRenderedOffsetChanged(){}scrollToIndex(t,e){this._viewport&&this._viewport.scrollToOffset(t*this._itemSize,e)}_updateTotalContentSize(){!this._viewport||this._viewport.setTotalContentSize(this._viewport.getDataLength()*this._itemSize)}_updateRenderedRange(){if(!this._viewport)return;let t=this._viewport.getRenderedRange(),e={start:t.start,end:t.end},i=this._viewport.getViewportSize(),r=this._viewport.getDataLength(),o=this._viewport.measureScrollOffset(),s=this._itemSize>0?o/this._itemSize:0;if(e.end>r){let l=Math.ceil(i/this._itemSize),c=Math.max(0,Math.min(s,r-l));s!=c&&(s=c,o=c*this._itemSize,e.start=Math.floor(s)),e.end=Math.max(0,Math.min(r,e.start+l))}let a=o-e.start*this._itemSize;if(a<this._minBufferPx&&0!=e.start){let l=Math.ceil((this._maxBufferPx-a)/this._itemSize);e.start=Math.max(0,e.start-l),e.end=Math.min(r,Math.ceil(s+(i+this._minBufferPx)/this._itemSize))}else{let l=e.end*this._itemSize-(o+i);if(l<this._minBufferPx&&e.end!=r){let c=Math.ceil((this._maxBufferPx-l)/this._itemSize);c>0&&(e.end=Math.min(r,e.end+c),e.start=Math.max(0,Math.floor(s-this._minBufferPx/this._itemSize)))}}this._viewport.setRenderedRange(e),this._viewport.setRenderedContentOffset(this._itemSize*e.start),this._scrolledIndexChange.next(Math.floor(s))}}(this.itemSize,this.minBufferPx,this.maxBufferPx)}get itemSize(){return this._itemSize}set itemSize(e){this._itemSize=Bi(e)}get minBufferPx(){return this._minBufferPx}set minBufferPx(e){this._minBufferPx=Bi(e)}get maxBufferPx(){return this._maxBufferPx}set maxBufferPx(e){this._maxBufferPx=Bi(e)}ngOnChanges(){this._scrollStrategy.updateItemAndBufferSize(this.itemSize,this.minBufferPx,this.maxBufferPx)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=He({type:n,selectors:[["cdk-virtual-scroll-viewport","itemSize",""]],inputs:{itemSize:"itemSize",minBufferPx:"minBufferPx",maxBufferPx:"maxBufferPx"},features:[$t([{provide:hte,useFactory:cOe,deps:[Jn(()=>n)]}]),Ft]}),n})(),$m=(()=>{class n{constructor(e,i,r){this._ngZone=e,this._platform=i,this._scrolled=new ke,this._globalSubscription=null,this._scrolledCount=0,this.scrollContainers=new Map,this._document=r}register(e){this.scrollContainers.has(e)||this.scrollContainers.set(e,e.elementScrolled().subscribe(()=>this._scrolled.next(e)))}deregister(e){let i=this.scrollContainers.get(e);i&&(i.unsubscribe(),this.scrollContainers.delete(e))}scrolled(e=20){return this._platform.isBrowser?new un(i=>{this._globalSubscription||this._addGlobalListener();let r=e>0?this._scrolled.pipe(bu(e)).subscribe(i):this._scrolled.subscribe(i);return this._scrolledCount++,()=>{r.unsubscribe(),this._scrolledCount--,this._scrolledCount||this._removeGlobalListener()}}):Xt()}ngOnDestroy(){this._removeGlobalListener(),this.scrollContainers.forEach((e,i)=>this.deregister(i)),this._scrolled.complete()}ancestorScrolled(e,i){let r=this.getAncestorScrollContainers(e);return this.scrolled(i).pipe(Ye(o=>!o||r.indexOf(o)>-1))}getAncestorScrollContainers(e){let i=[];return this.scrollContainers.forEach((r,o)=>{this._scrollableContainsElement(o,e)&&i.push(o)}),i}_getWindow(){return this._document.defaultView||window}_scrollableContainsElement(e,i){let r=La(i),o=e.getElementRef().nativeElement;do{if(r==o)return!0}while(r=r.parentElement);return!1}_addGlobalListener(){this._globalSubscription=this._ngZone.runOutsideAngular(()=>_i(this._getWindow().document,"scroll").subscribe(()=>this._scrolled.next()))}_removeGlobalListener(){this._globalSubscription&&(this._globalSubscription.unsubscribe(),this._globalSubscription=null)}}return n.\u0275fac=function(e){return new(e||n)(j(_t),j(oi),j(Ht,8))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Ih=(()=>{class n{constructor(e,i,r,o){this.elementRef=e,this.scrollDispatcher=i,this.ngZone=r,this.dir=o,this._destroyed=new ke,this._elementScrolled=new un(s=>this.ngZone.runOutsideAngular(()=>_i(this.elementRef.nativeElement,"scroll").pipe(st(this._destroyed)).subscribe(s)))}ngOnInit(){this.scrollDispatcher.register(this)}ngOnDestroy(){this.scrollDispatcher.deregister(this),this._destroyed.next(),this._destroyed.complete()}elementScrolled(){return this._elementScrolled}getElementRef(){return this.elementRef}scrollTo(e){let i=this.elementRef.nativeElement,r=this.dir&&"rtl"==this.dir.value;null==e.left&&(e.left=r?e.end:e.start),null==e.right&&(e.right=r?e.start:e.end),null!=e.bottom&&(e.top=i.scrollHeight-i.clientHeight-e.bottom),r&&0!=bv()?(null!=e.left&&(e.right=i.scrollWidth-i.clientWidth-e.left),2==bv()?e.left=e.right:1==bv()&&(e.left=e.right?-e.right:e.right)):null!=e.right&&(e.left=i.scrollWidth-i.clientWidth-e.right),this._applyScrollToOptions(e)}_applyScrollToOptions(e){let i=this.elementRef.nativeElement;s2()?i.scrollTo(e):(null!=e.top&&(i.scrollTop=e.top),null!=e.left&&(i.scrollLeft=e.left))}measureScrollOffset(e){let i="left",r="right",o=this.elementRef.nativeElement;if("top"==e)return o.scrollTop;if("bottom"==e)return o.scrollHeight-o.clientHeight-o.scrollTop;let s=this.dir&&"rtl"==this.dir.value;return"start"==e?e=s?r:i:"end"==e&&(e=s?i:r),s&&2==bv()?e==i?o.scrollWidth-o.clientWidth-o.scrollLeft:o.scrollLeft:s&&1==bv()?e==i?o.scrollLeft+o.scrollWidth-o.clientWidth:-o.scrollLeft:e==i?o.scrollLeft:o.scrollWidth-o.clientWidth-o.scrollLeft}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M($m),M(_t),M($i,8))},n.\u0275dir=He({type:n,selectors:[["","cdk-scrollable",""],["","cdkScrollable",""]]}),n})(),Va=(()=>{class n{constructor(e,i,r){this._platform=e,this._change=new ke,this._changeListener=o=>{this._change.next(o)},this._document=r,i.runOutsideAngular(()=>{if(e.isBrowser){let o=this._getWindow();o.addEventListener("resize",this._changeListener),o.addEventListener("orientationchange",this._changeListener)}this.change().subscribe(()=>this._viewportSize=null)})}ngOnDestroy(){if(this._platform.isBrowser){let e=this._getWindow();e.removeEventListener("resize",this._changeListener),e.removeEventListener("orientationchange",this._changeListener)}this._change.complete()}getViewportSize(){this._viewportSize||this._updateViewportSize();let e={width:this._viewportSize.width,height:this._viewportSize.height};return this._platform.isBrowser||(this._viewportSize=null),e}getViewportRect(){let e=this.getViewportScrollPosition(),{width:i,height:r}=this.getViewportSize();return{top:e.top,left:e.left,bottom:e.top+r,right:e.left+i,height:r,width:i}}getViewportScrollPosition(){if(!this._platform.isBrowser)return{top:0,left:0};let e=this._document,i=this._getWindow(),r=e.documentElement,o=r.getBoundingClientRect();return{top:-o.top||e.body.scrollTop||i.scrollY||r.scrollTop||0,left:-o.left||e.body.scrollLeft||i.scrollX||r.scrollLeft||0}}change(e=20){return e>0?this._change.pipe(bu(e)):this._change}_getWindow(){return this._document.defaultView||window}_updateViewportSize(){let e=this._getWindow();this._viewportSize=this._platform.isBrowser?{width:e.innerWidth,height:e.innerHeight}:{width:0,height:0}}}return n.\u0275fac=function(e){return new(e||n)(j(oi),j(_t),j(Ht,8))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),dte=new pe("VIRTUAL_SCROLLABLE"),pOe=(()=>{class n extends Ih{constructor(e,i,r,o){super(e,i,r,o)}measureViewportSize(e){let i=this.elementRef.nativeElement;return"horizontal"===e?i.clientWidth:i.clientHeight}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M($m),M(_t),M($i,8))},n.\u0275dir=He({type:n,features:[tt]}),n})(),fOe=typeof requestAnimationFrame<"u"?_N:f0,eg=(()=>{class n extends pOe{constructor(e,i,r,o,s,a,l,c){super(e,a,r,s),this.elementRef=e,this._changeDetectorRef=i,this._scrollStrategy=o,this.scrollable=c,this._platform=jo(oi),this._detachedSubject=new ke,this._renderedRangeSubject=new ke,this._orientation="vertical",this._appendOnly=!1,this.scrolledIndexChange=new un(u=>this._scrollStrategy.scrolledIndexChange.subscribe(d=>Promise.resolve().then(()=>this.ngZone.run(()=>u.next(d))))),this.renderedRangeStream=this._renderedRangeSubject,this._totalContentSize=0,this._totalContentWidth="",this._totalContentHeight="",this._renderedRange={start:0,end:0},this._dataLength=0,this._viewportSize=0,this._renderedContentOffset=0,this._renderedContentOffsetNeedsRewrite=!1,this._isChangeDetectionPending=!1,this._runAfterChangeDetection=[],this._viewportChanges=Sn.EMPTY,this._viewportChanges=l.change().subscribe(()=>{this.checkViewportSize()}),this.scrollable||(this.elementRef.nativeElement.classList.add("cdk-virtual-scrollable"),this.scrollable=this)}get orientation(){return this._orientation}set orientation(e){this._orientation!==e&&(this._orientation=e,this._calculateSpacerSize())}get appendOnly(){return this._appendOnly}set appendOnly(e){this._appendOnly=Rt(e)}ngOnInit(){!this._platform.isBrowser||(this.scrollable===this&&super.ngOnInit(),this.ngZone.runOutsideAngular(()=>Promise.resolve().then(()=>{this._measureViewportSize(),this._scrollStrategy.attach(this),this.scrollable.elementScrolled().pipe(zn(null),bu(0,fOe)).subscribe(()=>this._scrollStrategy.onContentScrolled()),this._markChangeDetectionNeeded()})))}ngOnDestroy(){this.detach(),this._scrollStrategy.detach(),this._renderedRangeSubject.complete(),this._detachedSubject.complete(),this._viewportChanges.unsubscribe(),super.ngOnDestroy()}attach(e){this.ngZone.runOutsideAngular(()=>{this._forOf=e,this._forOf.dataStream.pipe(st(this._detachedSubject)).subscribe(i=>{let r=i.length;r!==this._dataLength&&(this._dataLength=r,this._scrollStrategy.onDataLengthChanged()),this._doChangeDetection()})})}detach(){this._forOf=null,this._detachedSubject.next()}getDataLength(){return this._dataLength}getViewportSize(){return this._viewportSize}getRenderedRange(){return this._renderedRange}measureBoundingClientRectWithScrollOffset(e){return this.getElementRef().nativeElement.getBoundingClientRect()[e]}setTotalContentSize(e){this._totalContentSize!==e&&(this._totalContentSize=e,this._calculateSpacerSize(),this._markChangeDetectionNeeded())}setRenderedRange(e){(function(n,t){return n.start==t.start&&n.end==t.end})(this._renderedRange,e)||(this.appendOnly&&(e={start:0,end:Math.max(this._renderedRange.end,e.end)}),this._renderedRangeSubject.next(this._renderedRange=e),this._markChangeDetectionNeeded(()=>this._scrollStrategy.onContentRendered()))}getOffsetToRenderedContentStart(){return this._renderedContentOffsetNeedsRewrite?null:this._renderedContentOffset}setRenderedContentOffset(e,i="to-start"){e=this.appendOnly&&"to-start"===i?0:e;let o="horizontal"==this.orientation,s=o?"X":"Y",l=`translate${s}(${Number((o&&this.dir&&"rtl"==this.dir.value?-1:1)*e)}px)`;this._renderedContentOffset=e,"to-end"===i&&(l+=` translate${s}(-100%)`,this._renderedContentOffsetNeedsRewrite=!0),this._renderedContentTransform!=l&&(this._renderedContentTransform=l,this._markChangeDetectionNeeded(()=>{this._renderedContentOffsetNeedsRewrite?(this._renderedContentOffset-=this.measureRenderedContentSize(),this._renderedContentOffsetNeedsRewrite=!1,this.setRenderedContentOffset(this._renderedContentOffset)):this._scrollStrategy.onRenderedOffsetChanged()}))}scrollToOffset(e,i="auto"){let r={behavior:i};"horizontal"===this.orientation?r.start=e:r.top=e,this.scrollable.scrollTo(r)}scrollToIndex(e,i="auto"){this._scrollStrategy.scrollToIndex(e,i)}measureScrollOffset(e){let i;return i=this.scrollable==this?r=>super.measureScrollOffset(r):r=>this.scrollable.measureScrollOffset(r),Math.max(0,i(e??("horizontal"===this.orientation?"start":"top"))-this.measureViewportOffset())}measureViewportOffset(e){let i,r="left",o="right",s="rtl"==this.dir?.value;i="start"==e?s?o:r:"end"==e?s?r:o:e||("horizontal"===this.orientation?"left":"top");let a=this.scrollable.measureBoundingClientRectWithScrollOffset(i);return this.elementRef.nativeElement.getBoundingClientRect()[i]-a}measureRenderedContentSize(){let e=this._contentWrapper.nativeElement;return"horizontal"===this.orientation?e.offsetWidth:e.offsetHeight}measureRangeSize(e){return this._forOf?this._forOf.measureRangeSize(e,this.orientation):0}checkViewportSize(){this._measureViewportSize(),this._scrollStrategy.onDataLengthChanged()}_measureViewportSize(){this._viewportSize=this.scrollable.measureViewportSize(this.orientation)}_markChangeDetectionNeeded(e){e&&this._runAfterChangeDetection.push(e),this._isChangeDetectionPending||(this._isChangeDetectionPending=!0,this.ngZone.runOutsideAngular(()=>Promise.resolve().then(()=>{this._doChangeDetection()})))}_doChangeDetection(){this._isChangeDetectionPending=!1,this._contentWrapper.nativeElement.style.transform=this._renderedContentTransform,this.ngZone.run(()=>this._changeDetectorRef.markForCheck());let e=this._runAfterChangeDetection;this._runAfterChangeDetection=[];for(let i of e)i()}_calculateSpacerSize(){this._totalContentHeight="horizontal"===this.orientation?"":`${this._totalContentSize}px`,this._totalContentWidth="horizontal"===this.orientation?`${this._totalContentSize}px`:""}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(nn),M(_t),M(hte,8),M($i,8),M($m),M(Va),M(dte,8))},n.\u0275cmp=R({type:n,selectors:[["cdk-virtual-scroll-viewport"]],viewQuery:function(e,i){if(1&e&&ot(aOe,7),2&e){let r;Ne(r=Le())&&(i._contentWrapper=r.first)}},hostAttrs:[1,"cdk-virtual-scroll-viewport"],hostVars:4,hostBindings:function(e,i){2&e&&et("cdk-virtual-scroll-orientation-horizontal","horizontal"===i.orientation)("cdk-virtual-scroll-orientation-vertical","horizontal"!==i.orientation)},inputs:{orientation:"orientation",appendOnly:"appendOnly"},outputs:{scrolledIndexChange:"scrolledIndexChange"},features:[$t([{provide:Ih,useFactory:(t,e)=>t||e,deps:[[new ns,new j0(dte)],n]}]),tt],ngContentSelectors:lOe,decls:4,vars:4,consts:[[1,"cdk-virtual-scroll-content-wrapper"],["contentWrapper",""],[1,"cdk-virtual-scroll-spacer"]],template:function(e,i){1&e&&(xi(),_(0,"div",0,1),Vn(2),v(),O(3,"div",2)),2&e&&(C(3),Pt("width",i._totalContentWidth)("height",i._totalContentHeight))},styles:["cdk-virtual-scroll-viewport{display:block;position:relative;transform:translateZ(0)}.cdk-virtual-scrollable{overflow:auto;will-change:scroll-position;contain:strict;-webkit-overflow-scrolling:touch}.cdk-virtual-scroll-content-wrapper{position:absolute;top:0;left:0;contain:content}[dir=rtl] .cdk-virtual-scroll-content-wrapper{right:0;left:auto}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper{min-height:100%}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-left:0;padding-right:0;margin-left:0;margin-right:0;border-left-width:0;border-right-width:0;outline:none}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper{min-width:100%}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-top:0;padding-bottom:0;margin-top:0;margin-bottom:0;border-top-width:0;border-bottom-width:0;outline:none}.cdk-virtual-scroll-spacer{height:1px;transform-origin:0 0;flex:0 0 auto}[dir=rtl] .cdk-virtual-scroll-spacer{transform-origin:100% 0}"],encapsulation:2,changeDetection:0}),n})();function pte(n,t,e){if(!e.getBoundingClientRect)return 0;let r=e.getBoundingClientRect();return"horizontal"===n?"start"===t?r.left:r.right:"start"===t?r.top:r.bottom}var x2=(()=>{class n{constructor(e,i,r,o,s,a){this._viewContainerRef=e,this._template=i,this._differs=r,this._viewRepeater=o,this._viewport=s,this.viewChange=new ke,this._dataSourceChanges=new ke,this.dataStream=this._dataSourceChanges.pipe(zn(null),y0(),ui(([l,c])=>this._changeDataSource(l,c)),Ma(1)),this._differ=null,this._needsUpdate=!1,this._destroyed=new ke,this.dataStream.subscribe(l=>{this._data=l,this._onRenderedDataChange()}),this._viewport.renderedRangeStream.pipe(st(this._destroyed)).subscribe(l=>{this._renderedRange=l,this.viewChange.observers.length&&a.run(()=>this.viewChange.next(this._renderedRange)),this._onRenderedDataChange()}),this._viewport.attach(this)}get cdkVirtualForOf(){return this._cdkVirtualForOf}set cdkVirtualForOf(e){this._cdkVirtualForOf=e,function(n){return n&&"function"==typeof n.connect&&!(n instanceof ix)}(e)?this._dataSourceChanges.next(e):this._dataSourceChanges.next(new v2(ax(e)?e:Array.from(e||[])))}get cdkVirtualForTrackBy(){return this._cdkVirtualForTrackBy}set cdkVirtualForTrackBy(e){this._needsUpdate=!0,this._cdkVirtualForTrackBy=e?(i,r)=>e(i+(this._renderedRange?this._renderedRange.start:0),r):void 0}set cdkVirtualForTemplate(e){e&&(this._needsUpdate=!0,this._template=e)}get cdkVirtualForTemplateCacheSize(){return this._viewRepeater.viewCacheSize}set cdkVirtualForTemplateCacheSize(e){this._viewRepeater.viewCacheSize=Bi(e)}measureRangeSize(e,i){if(e.start>=e.end)return 0;let s,a,r=e.start-this._renderedRange.start,o=e.end-e.start;for(let l=0;l<o;l++){let c=this._viewContainerRef.get(l+r);if(c&&c.rootNodes.length){s=a=c.rootNodes[0];break}}for(let l=o-1;l>-1;l--){let c=this._viewContainerRef.get(l+r);if(c&&c.rootNodes.length){a=c.rootNodes[c.rootNodes.length-1];break}}return s&&a?pte(i,"end",a)-pte(i,"start",s):0}ngDoCheck(){if(this._differ&&this._needsUpdate){let e=this._differ.diff(this._renderedItems);e?this._applyChanges(e):this._updateContext(),this._needsUpdate=!1}}ngOnDestroy(){this._viewport.detach(),this._dataSourceChanges.next(void 0),this._dataSourceChanges.complete(),this.viewChange.complete(),this._destroyed.next(),this._destroyed.complete(),this._viewRepeater.detach()}_onRenderedDataChange(){!this._renderedRange||(this._renderedItems=this._data.slice(this._renderedRange.start,this._renderedRange.end),this._differ||(this._differ=this._differs.find(this._renderedItems).create((e,i)=>this.cdkVirtualForTrackBy?this.cdkVirtualForTrackBy(e,i):i)),this._needsUpdate=!0)}_changeDataSource(e,i){return e&&e.disconnect(this),this._needsUpdate=!0,i?i.connect(this):Xt()}_updateContext(){let e=this._data.length,i=this._viewContainerRef.length;for(;i--;){let r=this._viewContainerRef.get(i);r.context.index=this._renderedRange.start+i,r.context.count=e,this._updateComputedContextProperties(r.context),r.detectChanges()}}_applyChanges(e){this._viewRepeater.applyChanges(e,this._viewContainerRef,(o,s,a)=>this._getEmbeddedViewArgs(o,a),o=>o.item),e.forEachIdentityChange(o=>{this._viewContainerRef.get(o.currentIndex).context.$implicit=o.item});let i=this._data.length,r=this._viewContainerRef.length;for(;r--;){let o=this._viewContainerRef.get(r);o.context.index=this._renderedRange.start+r,o.context.count=i,this._updateComputedContextProperties(o.context)}}_updateComputedContextProperties(e){e.first=0===e.index,e.last=e.index===e.count-1,e.even=e.index%2==0,e.odd=!e.even}_getEmbeddedViewArgs(e,i){return{templateRef:this._template,context:{$implicit:e.item,cdkVirtualForOf:this._cdkVirtualForOf,index:-1,count:-1,first:!1,last:!1,odd:!1,even:!1},index:i}}}return n.\u0275fac=function(e){return new(e||n)(M(Oi),M(Vi),M(kc),M(SH),M(eg,4),M(_t))},n.\u0275dir=He({type:n,selectors:[["","cdkVirtualFor","","cdkVirtualForOf",""]],inputs:{cdkVirtualForOf:"cdkVirtualForOf",cdkVirtualForTrackBy:"cdkVirtualForTrackBy",cdkVirtualForTemplate:"cdkVirtualForTemplate",cdkVirtualForTemplateCacheSize:"cdkVirtualForTemplateCacheSize"},features:[$t([{provide:SH,useClass:y2}])]}),n})(),ud=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),Zc=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Dh,ud,Dh,ud]}),n})(),sw=class{attach(t){return this._attachedHost=t,t.attach(this)}detach(){let t=this._attachedHost;null!=t&&(this._attachedHost=null,t.detach())}get isAttached(){return null!=this._attachedHost}setAttachedHost(t){this._attachedHost=t}},$c=class extends sw{constructor(t,e,i,r){super(),this.component=t,this.viewContainerRef=e,this.injector=i,this.componentFactoryResolver=r}},ks=class extends sw{constructor(t,e,i,r){super(),this.templateRef=t,this.viewContainerRef=e,this.context=i,this.injector=r}get origin(){return this.templateRef.elementRef}attach(t,e=this.context){return this.context=e,super.attach(t)}detach(){return this.context=void 0,super.detach()}},TH=class extends sw{constructor(t){super(),this.element=t instanceof Re?t.nativeElement:t}},Ph=class{constructor(){this._isDisposed=!1,this.attachDomPortal=null}hasAttached(){return!!this._attachedPortal}attach(t){return t instanceof $c?(this._attachedPortal=t,this.attachComponentPortal(t)):t instanceof ks?(this._attachedPortal=t,this.attachTemplatePortal(t)):this.attachDomPortal&&t instanceof TH?(this._attachedPortal=t,this.attachDomPortal(t)):void 0}detach(){this._attachedPortal&&(this._attachedPortal.setAttachedHost(null),this._attachedPortal=null),this._invokeDisposeFn()}dispose(){this.hasAttached()&&this.detach(),this._invokeDisposeFn(),this._isDisposed=!0}setDisposeFn(t){this._disposeFn=t}_invokeDisposeFn(){this._disposeFn&&(this._disposeFn(),this._disposeFn=null)}},aw=class extends Ph{constructor(t,e,i,r,o){super(),this.outletElement=t,this._componentFactoryResolver=e,this._appRef=i,this._defaultInjector=r,this.attachDomPortal=s=>{let a=s.element,l=this._document.createComment("dom-portal");a.parentNode.insertBefore(l,a),this.outletElement.appendChild(a),this._attachedPortal=s,super.setDisposeFn(()=>{l.parentNode&&l.parentNode.replaceChild(a,l)})},this._document=o}attachComponentPortal(t){let r,i=(t.componentFactoryResolver||this._componentFactoryResolver).resolveComponentFactory(t.component);return t.viewContainerRef?(r=t.viewContainerRef.createComponent(i,t.viewContainerRef.length,t.injector||t.viewContainerRef.injector),this.setDisposeFn(()=>r.destroy())):(r=i.create(t.injector||this._defaultInjector||Xn.NULL),this._appRef.attachView(r.hostView),this.setDisposeFn(()=>{this._appRef.viewCount>0&&this._appRef.detachView(r.hostView),r.destroy()})),this.outletElement.appendChild(this._getComponentRootNode(r)),this._attachedPortal=t,r}attachTemplatePortal(t){let e=t.viewContainerRef,i=e.createEmbeddedView(t.templateRef,t.context,{injector:t.injector});return i.rootNodes.forEach(r=>this.outletElement.appendChild(r)),i.detectChanges(),this.setDisposeFn(()=>{let r=e.indexOf(i);-1!==r&&e.remove(r)}),this._attachedPortal=t,i}dispose(){super.dispose(),this.outletElement.remove()}_getComponentRootNode(t){return t.hostView.rootNodes[0]}},fte=(()=>{class n extends ks{constructor(e,i){super(e,i)}}return n.\u0275fac=function(e){return new(e||n)(M(Vi),M(Oi))},n.\u0275dir=He({type:n,selectors:[["","cdkPortal",""]],exportAs:["cdkPortal"],features:[tt]}),n})(),da=(()=>{class n extends Ph{constructor(e,i,r){super(),this._componentFactoryResolver=e,this._viewContainerRef=i,this._isInitialized=!1,this.attached=new G,this.attachDomPortal=o=>{let s=o.element,a=this._document.createComment("dom-portal");o.setAttachedHost(this),s.parentNode.insertBefore(a,s),this._getRootNode().appendChild(s),this._attachedPortal=o,super.setDisposeFn(()=>{a.parentNode&&a.parentNode.replaceChild(s,a)})},this._document=r}get portal(){return this._attachedPortal}set portal(e){this.hasAttached()&&!e&&!this._isInitialized||(this.hasAttached()&&super.detach(),e&&super.attach(e),this._attachedPortal=e||null)}get attachedRef(){return this._attachedRef}ngOnInit(){this._isInitialized=!0}ngOnDestroy(){super.dispose(),this._attachedPortal=null,this._attachedRef=null}attachComponentPortal(e){e.setAttachedHost(this);let i=null!=e.viewContainerRef?e.viewContainerRef:this._viewContainerRef,o=(e.componentFactoryResolver||this._componentFactoryResolver).resolveComponentFactory(e.component),s=i.createComponent(o,i.length,e.injector||i.injector);return i!==this._viewContainerRef&&this._getRootNode().appendChild(s.hostView.rootNodes[0]),super.setDisposeFn(()=>s.destroy()),this._attachedPortal=e,this._attachedRef=s,this.attached.emit(s),s}attachTemplatePortal(e){e.setAttachedHost(this);let i=this._viewContainerRef.createEmbeddedView(e.templateRef,e.context,{injector:e.injector});return super.setDisposeFn(()=>this._viewContainerRef.clear()),this._attachedPortal=e,this._attachedRef=i,this.attached.emit(i),i}_getRootNode(){let e=this._viewContainerRef.element.nativeElement;return e.nodeType===e.ELEMENT_NODE?e:e.parentNode}}return n.\u0275fac=function(e){return new(e||n)(M(gs),M(Oi),M(Ht))},n.\u0275dir=He({type:n,selectors:[["","cdkPortalOutlet",""]],inputs:{portal:["cdkPortalOutlet","portal"]},outputs:{attached:"attached"},exportAs:["cdkPortalOutlet"],features:[tt]}),n})(),eu=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),mte=s2(),M2=class{enable(){}disable(){}attach(){}};function IH(n,t){return t.some(e=>n.bottom<e.top||n.top>e.bottom||n.right<e.left||n.left>e.right)}function gte(n,t){return t.some(e=>n.top<e.top||n.bottom>e.bottom||n.left<e.left||n.right>e.right)}var ng=class{constructor(t,e,i,r){this._scrollDispatcher=t,this._viewportRuler=e,this._ngZone=i,this._config=r,this._scrollSubscription=null}attach(t){this._overlayRef=t}enable(){this._scrollSubscription||(this._scrollSubscription=this._scrollDispatcher.scrolled(this._config?this._config.scrollThrottle:0).subscribe(()=>{if(this._overlayRef.updatePosition(),this._config&&this._config.autoClose){let e=this._overlayRef.overlayElement.getBoundingClientRect(),{width:i,height:r}=this._viewportRuler.getViewportSize();IH(e,[{width:i,height:r,bottom:r,right:i,top:0,left:0}])&&(this.disable(),this._ngZone.run(()=>this._overlayRef.detach()))}}))}disable(){this._scrollSubscription&&(this._scrollSubscription.unsubscribe(),this._scrollSubscription=null)}detach(){this.disable(),this._overlayRef=null}},mOe=(()=>{class n{constructor(e,i,r,o){this._scrollDispatcher=e,this._viewportRuler=i,this._ngZone=r,this.noop=()=>new M2,this.close=s=>new class{constructor(t,e,i,r){this._scrollDispatcher=t,this._ngZone=e,this._viewportRuler=i,this._config=r,this._scrollSubscription=null,this._detach=()=>{this.disable(),this._overlayRef.hasAttached()&&this._ngZone.run(()=>this._overlayRef.detach())}}attach(t){this._overlayRef=t}enable(){if(this._scrollSubscription)return;let t=this._scrollDispatcher.scrolled(0);this._config&&this._config.threshold&&this._config.threshold>1?(this._initialScrollPosition=this._viewportRuler.getViewportScrollPosition().top,this._scrollSubscription=t.subscribe(()=>{let e=this._viewportRuler.getViewportScrollPosition().top;Math.abs(e-this._initialScrollPosition)>this._config.threshold?this._detach():this._overlayRef.updatePosition()})):this._scrollSubscription=t.subscribe(this._detach)}disable(){this._scrollSubscription&&(this._scrollSubscription.unsubscribe(),this._scrollSubscription=null)}detach(){this.disable(),this._overlayRef=null}}(this._scrollDispatcher,this._ngZone,this._viewportRuler,s),this.block=()=>new class{constructor(t,e){this._viewportRuler=t,this._previousHTMLStyles={top:"",left:""},this._isEnabled=!1,this._document=e}attach(){}enable(){if(this._canBeEnabled()){let t=this._document.documentElement;this._previousScrollPosition=this._viewportRuler.getViewportScrollPosition(),this._previousHTMLStyles.left=t.style.left||"",this._previousHTMLStyles.top=t.style.top||"",t.style.left=yo(-this._previousScrollPosition.left),t.style.top=yo(-this._previousScrollPosition.top),t.classList.add("cdk-global-scrollblock"),this._isEnabled=!0}}disable(){if(this._isEnabled){let t=this._document.documentElement,i=t.style,r=this._document.body.style,o=i.scrollBehavior||"",s=r.scrollBehavior||"";this._isEnabled=!1,i.left=this._previousHTMLStyles.left,i.top=this._previousHTMLStyles.top,t.classList.remove("cdk-global-scrollblock"),mte&&(i.scrollBehavior=r.scrollBehavior="auto"),window.scroll(this._previousScrollPosition.left,this._previousScrollPosition.top),mte&&(i.scrollBehavior=o,r.scrollBehavior=s)}}_canBeEnabled(){if(this._document.documentElement.classList.contains("cdk-global-scrollblock")||this._isEnabled)return!1;let e=this._document.body,i=this._viewportRuler.getViewportSize();return e.scrollHeight>i.height||e.scrollWidth>i.width}}(this._viewportRuler,this._document),this.reposition=s=>new ng(this._scrollDispatcher,this._viewportRuler,this._ngZone,s),this._document=o}}return n.\u0275fac=function(e){return new(e||n)(j($m),j(Va),j(_t),j(Ht))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),sc=class{constructor(t){if(this.scrollStrategy=new M2,this.panelClass="",this.hasBackdrop=!1,this.backdropClass="cdk-overlay-dark-backdrop",this.disposeOnNavigation=!1,t){let e=Object.keys(t);for(let i of e)void 0!==t[i]&&(this[i]=t[i])}}},xte=(()=>{class n{constructor(e){this._attachedOverlays=[],this._document=e}ngOnDestroy(){this.detach()}add(e){this.remove(e),this._attachedOverlays.push(e)}remove(e){let i=this._attachedOverlays.indexOf(e);i>-1&&this._attachedOverlays.splice(i,1),0===this._attachedOverlays.length&&this.detach()}}return n.\u0275fac=function(e){return new(e||n)(j(Ht))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),gOe=(()=>{class n extends xte{constructor(e,i){super(e),this._ngZone=i,this._keydownListener=r=>{let o=this._attachedOverlays;for(let s=o.length-1;s>-1;s--)if(o[s]._keydownEvents.observers.length>0){let a=o[s]._keydownEvents;this._ngZone?this._ngZone.run(()=>a.next(r)):a.next(r);break}}}add(e){super.add(e),this._isAttached||(this._ngZone?this._ngZone.runOutsideAngular(()=>this._document.body.addEventListener("keydown",this._keydownListener)):this._document.body.addEventListener("keydown",this._keydownListener),this._isAttached=!0)}detach(){this._isAttached&&(this._document.body.removeEventListener("keydown",this._keydownListener),this._isAttached=!1)}}return n.\u0275fac=function(e){return new(e||n)(j(Ht),j(_t,8))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),_Oe=(()=>{class n extends xte{constructor(e,i,r){super(e),this._platform=i,this._ngZone=r,this._cursorStyleIsSet=!1,this._pointerDownListener=o=>{this._pointerDownEventTarget=Qc(o)},this._clickListener=o=>{let s=Qc(o),a="click"===o.type&&this._pointerDownEventTarget?this._pointerDownEventTarget:s;this._pointerDownEventTarget=null;let l=this._attachedOverlays.slice();for(let c=l.length-1;c>-1;c--){let u=l[c];if(u._outsidePointerEvents.observers.length<1||!u.hasAttached())continue;if(u.overlayElement.contains(s)||u.overlayElement.contains(a))break;let d=u._outsidePointerEvents;this._ngZone?this._ngZone.run(()=>d.next(o)):d.next(o)}}}add(e){if(super.add(e),!this._isAttached){let i=this._document.body;this._ngZone?this._ngZone.runOutsideAngular(()=>this._addEventListeners(i)):this._addEventListeners(i),this._platform.IOS&&!this._cursorStyleIsSet&&(this._cursorOriginalValue=i.style.cursor,i.style.cursor="pointer",this._cursorStyleIsSet=!0),this._isAttached=!0}}detach(){if(this._isAttached){let e=this._document.body;e.removeEventListener("pointerdown",this._pointerDownListener,!0),e.removeEventListener("click",this._clickListener,!0),e.removeEventListener("auxclick",this._clickListener,!0),e.removeEventListener("contextmenu",this._clickListener,!0),this._platform.IOS&&this._cursorStyleIsSet&&(e.style.cursor=this._cursorOriginalValue,this._cursorStyleIsSet=!1),this._isAttached=!1}}_addEventListeners(e){e.addEventListener("pointerdown",this._pointerDownListener,!0),e.addEventListener("click",this._clickListener,!0),e.addEventListener("auxclick",this._clickListener,!0),e.addEventListener("contextmenu",this._clickListener,!0)}}return n.\u0275fac=function(e){return new(e||n)(j(Ht),j(oi),j(_t,8))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),Rv=(()=>{class n{constructor(e,i){this._platform=i,this._document=e}ngOnDestroy(){this._containerElement?.remove()}getContainerElement(){return this._containerElement||this._createContainer(),this._containerElement}_createContainer(){let e="cdk-overlay-container";if(this._platform.isBrowser||ZM()){let r=this._document.querySelectorAll(`.${e}[platform="server"], .${e}[platform="test"]`);for(let o=0;o<r.length;o++)r[o].remove()}let i=this._document.createElement("div");i.classList.add(e),ZM()?i.setAttribute("platform","test"):this._platform.isBrowser||i.setAttribute("platform","server"),this._document.body.appendChild(i),this._containerElement=i}}return n.\u0275fac=function(e){return new(e||n)(j(Ht),j(oi))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),dd=class{constructor(t,e,i,r,o,s,a,l,c,u=!1){this._portalOutlet=t,this._host=e,this._pane=i,this._config=r,this._ngZone=o,this._keyboardDispatcher=s,this._document=a,this._location=l,this._outsideClickDispatcher=c,this._animationsDisabled=u,this._backdropElement=null,this._backdropClick=new ke,this._attachments=new ke,this._detachments=new ke,this._locationChanges=Sn.EMPTY,this._backdropClickHandler=d=>this._backdropClick.next(d),this._backdropTransitionendHandler=d=>{this._disposeBackdrop(d.target)},this._keydownEvents=new ke,this._outsidePointerEvents=new ke,r.scrollStrategy&&(this._scrollStrategy=r.scrollStrategy,this._scrollStrategy.attach(this)),this._positionStrategy=r.positionStrategy}get overlayElement(){return this._pane}get backdropElement(){return this._backdropElement}get hostElement(){return this._host}attach(t){!this._host.parentElement&&this._previousHostParent&&this._previousHostParent.appendChild(this._host);let e=this._portalOutlet.attach(t);return this._positionStrategy&&this._positionStrategy.attach(this),this._updateStackingOrder(),this._updateElementSize(),this._updateElementDirection(),this._scrollStrategy&&this._scrollStrategy.enable(),this._ngZone.onStable.pipe(Qt(1)).subscribe(()=>{this.hasAttached()&&this.updatePosition()}),this._togglePointerEvents(!0),this._config.hasBackdrop&&this._attachBackdrop(),this._config.panelClass&&this._toggleClasses(this._pane,this._config.panelClass,!0),this._attachments.next(),this._keyboardDispatcher.add(this),this._config.disposeOnNavigation&&(this._locationChanges=this._location.subscribe(()=>this.dispose())),this._outsideClickDispatcher.add(this),"function"==typeof e?.onDestroy&&e.onDestroy(()=>{this.hasAttached()&&this._ngZone.runOutsideAngular(()=>Promise.resolve().then(()=>this.detach()))}),e}detach(){if(!this.hasAttached())return;this.detachBackdrop(),this._togglePointerEvents(!1),this._positionStrategy&&this._positionStrategy.detach&&this._positionStrategy.detach(),this._scrollStrategy&&this._scrollStrategy.disable();let t=this._portalOutlet.detach();return this._detachments.next(),this._keyboardDispatcher.remove(this),this._detachContentWhenStable(),this._locationChanges.unsubscribe(),this._outsideClickDispatcher.remove(this),t}dispose(){let t=this.hasAttached();this._positionStrategy&&this._positionStrategy.dispose(),this._disposeScrollStrategy(),this._disposeBackdrop(this._backdropElement),this._locationChanges.unsubscribe(),this._keyboardDispatcher.remove(this),this._portalOutlet.dispose(),this._attachments.complete(),this._backdropClick.complete(),this._keydownEvents.complete(),this._outsidePointerEvents.complete(),this._outsideClickDispatcher.remove(this),this._host?.remove(),this._previousHostParent=this._pane=this._host=null,t&&this._detachments.next(),this._detachments.complete()}hasAttached(){return this._portalOutlet.hasAttached()}backdropClick(){return this._backdropClick}attachments(){return this._attachments}detachments(){return this._detachments}keydownEvents(){return this._keydownEvents}outsidePointerEvents(){return this._outsidePointerEvents}getConfig(){return this._config}updatePosition(){this._positionStrategy&&this._positionStrategy.apply()}updatePositionStrategy(t){t!==this._positionStrategy&&(this._positionStrategy&&this._positionStrategy.dispose(),this._positionStrategy=t,this.hasAttached()&&(t.attach(this),this.updatePosition()))}updateSize(t){this._config={...this._config,...t},this._updateElementSize()}setDirection(t){this._config={...this._config,direction:t},this._updateElementDirection()}addPanelClass(t){this._pane&&this._toggleClasses(this._pane,t,!0)}removePanelClass(t){this._pane&&this._toggleClasses(this._pane,t,!1)}getDirection(){let t=this._config.direction;return t?"string"==typeof t?t:t.value:"ltr"}updateScrollStrategy(t){t!==this._scrollStrategy&&(this._disposeScrollStrategy(),this._scrollStrategy=t,this.hasAttached()&&(t.attach(this),t.enable()))}_updateElementDirection(){this._host.setAttribute("dir",this.getDirection())}_updateElementSize(){if(!this._pane)return;let t=this._pane.style;t.width=yo(this._config.width),t.height=yo(this._config.height),t.minWidth=yo(this._config.minWidth),t.minHeight=yo(this._config.minHeight),t.maxWidth=yo(this._config.maxWidth),t.maxHeight=yo(this._config.maxHeight)}_togglePointerEvents(t){this._pane.style.pointerEvents=t?"":"none"}_attachBackdrop(){let t="cdk-overlay-backdrop-showing";this._backdropElement=this._document.createElement("div"),this._backdropElement.classList.add("cdk-overlay-backdrop"),this._animationsDisabled&&this._backdropElement.classList.add("cdk-overlay-backdrop-noop-animation"),this._config.backdropClass&&this._toggleClasses(this._backdropElement,this._config.backdropClass,!0),this._host.parentElement.insertBefore(this._backdropElement,this._host),this._backdropElement.addEventListener("click",this._backdropClickHandler),!this._animationsDisabled&&typeof requestAnimationFrame<"u"?this._ngZone.runOutsideAngular(()=>{requestAnimationFrame(()=>{this._backdropElement&&this._backdropElement.classList.add(t)})}):this._backdropElement.classList.add(t)}_updateStackingOrder(){this._host.nextSibling&&this._host.parentNode.appendChild(this._host)}detachBackdrop(){let t=this._backdropElement;if(t){if(this._animationsDisabled)return void this._disposeBackdrop(t);t.classList.remove("cdk-overlay-backdrop-showing"),this._ngZone.runOutsideAngular(()=>{t.addEventListener("transitionend",this._backdropTransitionendHandler)}),t.style.pointerEvents="none",this._backdropTimeout=this._ngZone.runOutsideAngular(()=>setTimeout(()=>{this._disposeBackdrop(t)},500))}}_toggleClasses(t,e,i){let r=xv(e||[]).filter(o=>!!o);r.length&&(i?t.classList.add(...r):t.classList.remove(...r))}_detachContentWhenStable(){this._ngZone.runOutsideAngular(()=>{let t=this._ngZone.onStable.pipe(st(Jt(this._attachments,this._detachments))).subscribe(()=>{(!this._pane||!this._host||0===this._pane.children.length)&&(this._pane&&this._config.panelClass&&this._toggleClasses(this._pane,this._config.panelClass,!1),this._host&&this._host.parentElement&&(this._previousHostParent=this._host.parentElement,this._host.remove()),t.unsubscribe())})})}_disposeScrollStrategy(){let t=this._scrollStrategy;t&&(t.disable(),t.detach&&t.detach())}_disposeBackdrop(t){t&&(t.removeEventListener("click",this._backdropClickHandler),t.removeEventListener("transitionend",this._backdropTransitionendHandler),t.remove(),this._backdropElement===t&&(this._backdropElement=null)),this._backdropTimeout&&(clearTimeout(this._backdropTimeout),this._backdropTimeout=void 0)}},_te="cdk-overlay-connected-position-bounding-box",vOe=/([A-Za-z%]+)$/;function tg(n,t){for(let e in t)t.hasOwnProperty(e)&&(n[e]=t[e]);return n}function vte(n){if("number"!=typeof n&&null!=n){let[t,e]=n.split(vOe);return e&&"px"!==e?null:parseFloat(t)}return n||null}function yte(n){return{top:Math.floor(n.top),right:Math.floor(n.right),bottom:Math.floor(n.bottom),left:Math.floor(n.left),width:Math.floor(n.width),height:Math.floor(n.height)}}var bte="cdk-global-overlay-wrapper",yOe=(()=>{class n{constructor(e,i,r,o){this._viewportRuler=e,this._document=i,this._platform=r,this._overlayContainer=o}global(){return new class{constructor(){this._cssPosition="static",this._topOffset="",this._bottomOffset="",this._alignItems="",this._xPosition="",this._xOffset="",this._width="",this._height="",this._isDisposed=!1}attach(t){let e=t.getConfig();this._overlayRef=t,this._width&&!e.width&&t.updateSize({width:this._width}),this._height&&!e.height&&t.updateSize({height:this._height}),t.hostElement.classList.add(bte),this._isDisposed=!1}top(t=""){return this._bottomOffset="",this._topOffset=t,this._alignItems="flex-start",this}left(t=""){return this._xOffset=t,this._xPosition="left",this}bottom(t=""){return this._topOffset="",this._bottomOffset=t,this._alignItems="flex-end",this}right(t=""){return this._xOffset=t,this._xPosition="right",this}start(t=""){return this._xOffset=t,this._xPosition="start",this}end(t=""){return this._xOffset=t,this._xPosition="end",this}width(t=""){return this._overlayRef?this._overlayRef.updateSize({width:t}):this._width=t,this}height(t=""){return this._overlayRef?this._overlayRef.updateSize({height:t}):this._height=t,this}centerHorizontally(t=""){return this.left(t),this._xPosition="center",this}centerVertically(t=""){return this.top(t),this._alignItems="center",this}apply(){if(!this._overlayRef||!this._overlayRef.hasAttached())return;let t=this._overlayRef.overlayElement.style,e=this._overlayRef.hostElement.style,i=this._overlayRef.getConfig(),{width:r,height:o,maxWidth:s,maxHeight:a}=i,l=!("100%"!==r&&"100vw"!==r||s&&"100%"!==s&&"100vw"!==s),c=!("100%"!==o&&"100vh"!==o||a&&"100%"!==a&&"100vh"!==a),u=this._xPosition,d=this._xOffset,p="rtl"===this._overlayRef.getConfig().direction,h="",f="",m="";l?m="flex-start":"center"===u?(m="center",p?f=d:h=d):p?"left"===u||"end"===u?(m="flex-end",h=d):("right"===u||"start"===u)&&(m="flex-start",f=d):"left"===u||"start"===u?(m="flex-start",h=d):("right"===u||"end"===u)&&(m="flex-end",f=d),t.position=this._cssPosition,t.marginLeft=l?"0":h,t.marginTop=c?"0":this._topOffset,t.marginBottom=this._bottomOffset,t.marginRight=l?"0":f,e.justifyContent=m,e.alignItems=c?"flex-start":this._alignItems}dispose(){if(this._isDisposed||!this._overlayRef)return;let t=this._overlayRef.overlayElement.style,e=this._overlayRef.hostElement,i=e.style;e.classList.remove(bte),i.justifyContent=i.alignItems=t.marginTop=t.marginBottom=t.marginLeft=t.marginRight=t.position="",this._overlayRef=null,this._isDisposed=!0}}}flexibleConnectedTo(e){return new class{constructor(t,e,i,r,o){this._viewportRuler=e,this._document=i,this._platform=r,this._overlayContainer=o,this._lastBoundingBoxSize={width:0,height:0},this._isPushed=!1,this._canPush=!0,this._growAfterOpen=!1,this._hasFlexibleDimensions=!0,this._positionLocked=!1,this._viewportMargin=0,this._scrollables=[],this._preferredPositions=[],this._positionChanges=new ke,this._resizeSubscription=Sn.EMPTY,this._offsetX=0,this._offsetY=0,this._appliedPanelClasses=[],this.positionChanges=this._positionChanges,this.setOrigin(t)}get positions(){return this._preferredPositions}attach(t){this._validatePositions(),t.hostElement.classList.add(_te),this._overlayRef=t,this._boundingBox=t.hostElement,this._pane=t.overlayElement,this._isDisposed=!1,this._isInitialRender=!0,this._lastPosition=null,this._resizeSubscription.unsubscribe(),this._resizeSubscription=this._viewportRuler.change().subscribe(()=>{this._isInitialRender=!0,this.apply()})}apply(){if(this._isDisposed||!this._platform.isBrowser)return;if(!this._isInitialRender&&this._positionLocked&&this._lastPosition)return void this.reapplyLastPosition();this._clearPanelClasses(),this._resetOverlayElementStyles(),this._resetBoundingBoxStyles(),this._viewportRect=this._getNarrowedViewportRect(),this._originRect=this._getOriginRect(),this._overlayRect=this._pane.getBoundingClientRect(),this._containerRect=this._overlayContainer.getContainerElement().getBoundingClientRect();let s,t=this._originRect,e=this._overlayRect,i=this._viewportRect,r=this._containerRect,o=[];for(let a of this._preferredPositions){let l=this._getOriginPoint(t,r,a),c=this._getOverlayPoint(l,e,a),u=this._getOverlayFit(c,e,i,a);if(u.isCompletelyWithinViewport)return this._isPushed=!1,void this._applyPosition(a,l);this._canFitWithFlexibleDimensions(u,c,i)?o.push({position:a,origin:l,overlayRect:e,boundingBoxRect:this._calculateBoundingBoxRect(l,a)}):(!s||s.overlayFit.visibleArea<u.visibleArea)&&(s={overlayFit:u,overlayPoint:c,originPoint:l,position:a,overlayRect:e})}if(o.length){let a=null,l=-1;for(let c of o){let u=c.boundingBoxRect.width*c.boundingBoxRect.height*(c.position.weight||1);u>l&&(l=u,a=c)}return this._isPushed=!1,void this._applyPosition(a.position,a.origin)}if(this._canPush)return this._isPushed=!0,void this._applyPosition(s.position,s.originPoint);this._applyPosition(s.position,s.originPoint)}detach(){this._clearPanelClasses(),this._lastPosition=null,this._previousPushAmount=null,this._resizeSubscription.unsubscribe()}dispose(){this._isDisposed||(this._boundingBox&&tg(this._boundingBox.style,{top:"",left:"",right:"",bottom:"",height:"",width:"",alignItems:"",justifyContent:""}),this._pane&&this._resetOverlayElementStyles(),this._overlayRef&&this._overlayRef.hostElement.classList.remove(_te),this.detach(),this._positionChanges.complete(),this._overlayRef=this._boundingBox=null,this._isDisposed=!0)}reapplyLastPosition(){if(this._isDisposed||!this._platform.isBrowser)return;let t=this._lastPosition;if(t){this._originRect=this._getOriginRect(),this._overlayRect=this._pane.getBoundingClientRect(),this._viewportRect=this._getNarrowedViewportRect(),this._containerRect=this._overlayContainer.getContainerElement().getBoundingClientRect();let e=this._getOriginPoint(this._originRect,this._containerRect,t);this._applyPosition(t,e)}else this.apply()}withScrollableContainers(t){return this._scrollables=t,this}withPositions(t){return this._preferredPositions=t,-1===t.indexOf(this._lastPosition)&&(this._lastPosition=null),this._validatePositions(),this}withViewportMargin(t){return this._viewportMargin=t,this}withFlexibleDimensions(t=!0){return this._hasFlexibleDimensions=t,this}withGrowAfterOpen(t=!0){return this._growAfterOpen=t,this}withPush(t=!0){return this._canPush=t,this}withLockedPosition(t=!0){return this._positionLocked=t,this}setOrigin(t){return this._origin=t,this}withDefaultOffsetX(t){return this._offsetX=t,this}withDefaultOffsetY(t){return this._offsetY=t,this}withTransformOriginOn(t){return this._transformOriginSelector=t,this}_getOriginPoint(t,e,i){let r,o;if("center"==i.originX)r=t.left+t.width/2;else{let s=this._isRtl()?t.right:t.left,a=this._isRtl()?t.left:t.right;r="start"==i.originX?s:a}return e.left<0&&(r-=e.left),o="center"==i.originY?t.top+t.height/2:"top"==i.originY?t.top:t.bottom,e.top<0&&(o-=e.top),{x:r,y:o}}_getOverlayPoint(t,e,i){let r,o;return r="center"==i.overlayX?-e.width/2:"start"===i.overlayX?this._isRtl()?-e.width:0:this._isRtl()?0:-e.width,o="center"==i.overlayY?-e.height/2:"top"==i.overlayY?0:-e.height,{x:t.x+r,y:t.y+o}}_getOverlayFit(t,e,i,r){let o=yte(e),{x:s,y:a}=t,l=this._getOffset(r,"x"),c=this._getOffset(r,"y");l&&(s+=l),c&&(a+=c);let p=0-a,h=a+o.height-i.height,f=this._subtractOverflows(o.width,0-s,s+o.width-i.width),m=this._subtractOverflows(o.height,p,h),x=f*m;return{visibleArea:x,isCompletelyWithinViewport:o.width*o.height===x,fitsInViewportVertically:m===o.height,fitsInViewportHorizontally:f==o.width}}_canFitWithFlexibleDimensions(t,e,i){if(this._hasFlexibleDimensions){let r=i.bottom-e.y,o=i.right-e.x,s=vte(this._overlayRef.getConfig().minHeight),a=vte(this._overlayRef.getConfig().minWidth),c=t.fitsInViewportHorizontally||null!=a&&a<=o;return(t.fitsInViewportVertically||null!=s&&s<=r)&&c}return!1}_pushOverlayOnScreen(t,e,i){if(this._previousPushAmount&&this._positionLocked)return{x:t.x+this._previousPushAmount.x,y:t.y+this._previousPushAmount.y};let r=yte(e),o=this._viewportRect,s=Math.max(t.x+r.width-o.width,0),a=Math.max(t.y+r.height-o.height,0),l=Math.max(o.top-i.top-t.y,0),c=Math.max(o.left-i.left-t.x,0),u=0,d=0;return u=r.width<=o.width?c||-s:t.x<this._viewportMargin?o.left-i.left-t.x:0,d=r.height<=o.height?l||-a:t.y<this._viewportMargin?o.top-i.top-t.y:0,this._previousPushAmount={x:u,y:d},{x:t.x+u,y:t.y+d}}_applyPosition(t,e){if(this._setTransformOrigin(t),this._setOverlayElementStyles(e,t),this._setBoundingBoxStyles(e,t),t.panelClass&&this._addPanelClasses(t.panelClass),this._lastPosition=t,this._positionChanges.observers.length){let i=this._getScrollVisibility(),r=new class{constructor(t,e){this.connectionPair=t,this.scrollableViewProperties=e}}(t,i);this._positionChanges.next(r)}this._isInitialRender=!1}_setTransformOrigin(t){if(!this._transformOriginSelector)return;let i,e=this._boundingBox.querySelectorAll(this._transformOriginSelector),r=t.overlayY;i="center"===t.overlayX?"center":this._isRtl()?"start"===t.overlayX?"right":"left":"start"===t.overlayX?"left":"right";for(let o=0;o<e.length;o++)e[o].style.transformOrigin=`${i} ${r}`}_calculateBoundingBoxRect(t,e){let o,s,a,u,d,p,i=this._viewportRect,r=this._isRtl();if("top"===e.overlayY)s=t.y,o=i.height-s+this._viewportMargin;else if("bottom"===e.overlayY)a=i.height-t.y+2*this._viewportMargin,o=i.height-a+this._viewportMargin;else{let h=Math.min(i.bottom-t.y+i.top,t.y),f=this._lastBoundingBoxSize.height;o=2*h,s=t.y-h,o>f&&!this._isInitialRender&&!this._growAfterOpen&&(s=t.y-f/2)}if("end"===e.overlayX&&!r||"start"===e.overlayX&&r)p=i.width-t.x+this._viewportMargin,u=t.x-this._viewportMargin;else if("start"===e.overlayX&&!r||"end"===e.overlayX&&r)d=t.x,u=i.right-t.x;else{let h=Math.min(i.right-t.x+i.left,t.x),f=this._lastBoundingBoxSize.width;u=2*h,d=t.x-h,u>f&&!this._isInitialRender&&!this._growAfterOpen&&(d=t.x-f/2)}return{top:s,left:d,bottom:a,right:p,width:u,height:o}}_setBoundingBoxStyles(t,e){let i=this._calculateBoundingBoxRect(t,e);!this._isInitialRender&&!this._growAfterOpen&&(i.height=Math.min(i.height,this._lastBoundingBoxSize.height),i.width=Math.min(i.width,this._lastBoundingBoxSize.width));let r={};if(this._hasExactPosition())r.top=r.left="0",r.bottom=r.right=r.maxHeight=r.maxWidth="",r.width=r.height="100%";else{let o=this._overlayRef.getConfig().maxHeight,s=this._overlayRef.getConfig().maxWidth;r.height=yo(i.height),r.top=yo(i.top),r.bottom=yo(i.bottom),r.width=yo(i.width),r.left=yo(i.left),r.right=yo(i.right),r.alignItems="center"===e.overlayX?"center":"end"===e.overlayX?"flex-end":"flex-start",r.justifyContent="center"===e.overlayY?"center":"bottom"===e.overlayY?"flex-end":"flex-start",o&&(r.maxHeight=yo(o)),s&&(r.maxWidth=yo(s))}this._lastBoundingBoxSize=i,tg(this._boundingBox.style,r)}_resetBoundingBoxStyles(){tg(this._boundingBox.style,{top:"0",left:"0",right:"0",bottom:"0",height:"",width:"",alignItems:"",justifyContent:""})}_resetOverlayElementStyles(){tg(this._pane.style,{top:"",left:"",bottom:"",right:"",position:"",transform:""})}_setOverlayElementStyles(t,e){let i={},r=this._hasExactPosition(),o=this._hasFlexibleDimensions,s=this._overlayRef.getConfig();if(r){let u=this._viewportRuler.getViewportScrollPosition();tg(i,this._getExactOverlayY(e,t,u)),tg(i,this._getExactOverlayX(e,t,u))}else i.position="static";let a="",l=this._getOffset(e,"x"),c=this._getOffset(e,"y");l&&(a+=`translateX(${l}px) `),c&&(a+=`translateY(${c}px)`),i.transform=a.trim(),s.maxHeight&&(r?i.maxHeight=yo(s.maxHeight):o&&(i.maxHeight="")),s.maxWidth&&(r?i.maxWidth=yo(s.maxWidth):o&&(i.maxWidth="")),tg(this._pane.style,i)}_getExactOverlayY(t,e,i){let r={top:"",bottom:""},o=this._getOverlayPoint(e,this._overlayRect,t);return this._isPushed&&(o=this._pushOverlayOnScreen(o,this._overlayRect,i)),"bottom"===t.overlayY?r.bottom=this._document.documentElement.clientHeight-(o.y+this._overlayRect.height)+"px":r.top=yo(o.y),r}_getExactOverlayX(t,e,i){let s,r={left:"",right:""},o=this._getOverlayPoint(e,this._overlayRect,t);return this._isPushed&&(o=this._pushOverlayOnScreen(o,this._overlayRect,i)),s=this._isRtl()?"end"===t.overlayX?"left":"right":"end"===t.overlayX?"right":"left","right"===s?r.right=this._document.documentElement.clientWidth-(o.x+this._overlayRect.width)+"px":r.left=yo(o.x),r}_getScrollVisibility(){let t=this._getOriginRect(),e=this._pane.getBoundingClientRect(),i=this._scrollables.map(r=>r.getElementRef().nativeElement.getBoundingClientRect());return{isOriginClipped:gte(t,i),isOriginOutsideView:IH(t,i),isOverlayClipped:gte(e,i),isOverlayOutsideView:IH(e,i)}}_subtractOverflows(t,...e){return e.reduce((i,r)=>i-Math.max(r,0),t)}_getNarrowedViewportRect(){let t=this._document.documentElement.clientWidth,e=this._document.documentElement.clientHeight,i=this._viewportRuler.getViewportScrollPosition();return{top:i.top+this._viewportMargin,left:i.left+this._viewportMargin,right:i.left+t-this._viewportMargin,bottom:i.top+e-this._viewportMargin,width:t-2*this._viewportMargin,height:e-2*this._viewportMargin}}_isRtl(){return"rtl"===this._overlayRef.getDirection()}_hasExactPosition(){return!this._hasFlexibleDimensions||this._isPushed}_getOffset(t,e){return"x"===e?null==t.offsetX?this._offsetX:t.offsetX:null==t.offsetY?this._offsetY:t.offsetY}_validatePositions(){}_addPanelClasses(t){this._pane&&xv(t).forEach(e=>{""!==e&&-1===this._appliedPanelClasses.indexOf(e)&&(this._appliedPanelClasses.push(e),this._pane.classList.add(e))})}_clearPanelClasses(){this._pane&&(this._appliedPanelClasses.forEach(t=>{this._pane.classList.remove(t)}),this._appliedPanelClasses=[])}_getOriginRect(){let t=this._origin;if(t instanceof Re)return t.nativeElement.getBoundingClientRect();if(t instanceof Element)return t.getBoundingClientRect();let e=t.width||0,i=t.height||0;return{top:t.y,bottom:t.y+i,left:t.x,right:t.x+e,height:i,width:e}}}(e,this._viewportRuler,this._document,this._platform,this._overlayContainer)}}return n.\u0275fac=function(e){return new(e||n)(j(Va),j(Ht),j(oi),j(Rv))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),bOe=0,tr=(()=>{class n{constructor(e,i,r,o,s,a,l,c,u,d,p,h){this.scrollStrategies=e,this._overlayContainer=i,this._componentFactoryResolver=r,this._positionBuilder=o,this._keyboardDispatcher=s,this._injector=a,this._ngZone=l,this._document=c,this._directionality=u,this._location=d,this._outsideClickDispatcher=p,this._animationsModuleType=h}create(e){let i=this._createHostElement(),r=this._createPaneElement(i),o=this._createPortalOutlet(r),s=new sc(e);return s.direction=s.direction||this._directionality.value,new dd(o,i,r,s,this._ngZone,this._keyboardDispatcher,this._document,this._location,this._outsideClickDispatcher,"NoopAnimations"===this._animationsModuleType)}position(){return this._positionBuilder}_createPaneElement(e){let i=this._document.createElement("div");return i.id="cdk-overlay-"+bOe++,i.classList.add("cdk-overlay-pane"),e.appendChild(i),i}_createHostElement(){let e=this._document.createElement("div");return this._overlayContainer.getContainerElement().appendChild(e),e}_createPortalOutlet(e){return this._appRef||(this._appRef=this._injector.get(Iu)),new aw(e,this._componentFactoryResolver,this._appRef,this._injector,this._document)}}return n.\u0275fac=function(e){return new(e||n)(j(mOe),j(Rv),j(gs),j(yOe),j(gOe),j(Xn),j(_t),j(Ht),j($i),j(iM),j(_Oe),j(Pi,8))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),xOe=[{originX:"start",originY:"bottom",overlayX:"start",overlayY:"top"},{originX:"start",originY:"top",overlayX:"start",overlayY:"bottom"},{originX:"end",originY:"top",overlayX:"end",overlayY:"bottom"},{originX:"end",originY:"bottom",overlayX:"end",overlayY:"top"}],Cte=new pe("cdk-connected-overlay-scroll-strategy"),ig=(()=>{class n{constructor(e){this.elementRef=e}}return n.\u0275fac=function(e){return new(e||n)(M(Re))},n.\u0275dir=He({type:n,selectors:[["","cdk-overlay-origin",""],["","overlay-origin",""],["","cdkOverlayOrigin",""]],exportAs:["cdkOverlayOrigin"]}),n})(),Rh=(()=>{class n{constructor(e,i,r,o,s){this._overlay=e,this._dir=s,this._hasBackdrop=!1,this._lockPosition=!1,this._growAfterOpen=!1,this._flexibleDimensions=!1,this._push=!1,this._backdropSubscription=Sn.EMPTY,this._attachSubscription=Sn.EMPTY,this._detachSubscription=Sn.EMPTY,this._positionSubscription=Sn.EMPTY,this.viewportMargin=0,this.open=!1,this.disableClose=!1,this.backdropClick=new G,this.positionChange=new G,this.attach=new G,this.detach=new G,this.overlayKeydown=new G,this.overlayOutsideClick=new G,this._templatePortal=new ks(i,r),this._scrollStrategyFactory=o,this.scrollStrategy=this._scrollStrategyFactory()}get offsetX(){return this._offsetX}set offsetX(e){this._offsetX=e,this._position&&this._updatePositionStrategy(this._position)}get offsetY(){return this._offsetY}set offsetY(e){this._offsetY=e,this._position&&this._updatePositionStrategy(this._position)}get hasBackdrop(){return this._hasBackdrop}set hasBackdrop(e){this._hasBackdrop=Rt(e)}get lockPosition(){return this._lockPosition}set lockPosition(e){this._lockPosition=Rt(e)}get flexibleDimensions(){return this._flexibleDimensions}set flexibleDimensions(e){this._flexibleDimensions=Rt(e)}get growAfterOpen(){return this._growAfterOpen}set growAfterOpen(e){this._growAfterOpen=Rt(e)}get push(){return this._push}set push(e){this._push=Rt(e)}get overlayRef(){return this._overlayRef}get dir(){return this._dir?this._dir.value:"ltr"}ngOnDestroy(){this._attachSubscription.unsubscribe(),this._detachSubscription.unsubscribe(),this._backdropSubscription.unsubscribe(),this._positionSubscription.unsubscribe(),this._overlayRef&&this._overlayRef.dispose()}ngOnChanges(e){this._position&&(this._updatePositionStrategy(this._position),this._overlayRef.updateSize({width:this.width,minWidth:this.minWidth,height:this.height,minHeight:this.minHeight}),e.origin&&this.open&&this._position.apply()),e.open&&(this.open?this._attachOverlay():this._detachOverlay())}_createOverlay(){(!this.positions||!this.positions.length)&&(this.positions=xOe);let e=this._overlayRef=this._overlay.create(this._buildConfig());this._attachSubscription=e.attachments().subscribe(()=>this.attach.emit()),this._detachSubscription=e.detachments().subscribe(()=>this.detach.emit()),e.keydownEvents().subscribe(i=>{this.overlayKeydown.next(i),27===i.keyCode&&!this.disableClose&&!kr(i)&&(i.preventDefault(),this._detachOverlay())}),this._overlayRef.outsidePointerEvents().subscribe(i=>{this.overlayOutsideClick.next(i)})}_buildConfig(){let e=this._position=this.positionStrategy||this._createPositionStrategy(),i=new sc({direction:this._dir,positionStrategy:e,scrollStrategy:this.scrollStrategy,hasBackdrop:this.hasBackdrop});return(this.width||0===this.width)&&(i.width=this.width),(this.height||0===this.height)&&(i.height=this.height),(this.minWidth||0===this.minWidth)&&(i.minWidth=this.minWidth),(this.minHeight||0===this.minHeight)&&(i.minHeight=this.minHeight),this.backdropClass&&(i.backdropClass=this.backdropClass),this.panelClass&&(i.panelClass=this.panelClass),i}_updatePositionStrategy(e){let i=this.positions.map(r=>({originX:r.originX,originY:r.originY,overlayX:r.overlayX,overlayY:r.overlayY,offsetX:r.offsetX||this.offsetX,offsetY:r.offsetY||this.offsetY,panelClass:r.panelClass||void 0}));return e.setOrigin(this._getFlexibleConnectedPositionStrategyOrigin()).withPositions(i).withFlexibleDimensions(this.flexibleDimensions).withPush(this.push).withGrowAfterOpen(this.growAfterOpen).withViewportMargin(this.viewportMargin).withLockedPosition(this.lockPosition).withTransformOriginOn(this.transformOriginSelector)}_createPositionStrategy(){let e=this._overlay.position().flexibleConnectedTo(this._getFlexibleConnectedPositionStrategyOrigin());return this._updatePositionStrategy(e),e}_getFlexibleConnectedPositionStrategyOrigin(){return this.origin instanceof ig?this.origin.elementRef:this.origin}_attachOverlay(){this._overlayRef?this._overlayRef.getConfig().hasBackdrop=this.hasBackdrop:this._createOverlay(),this._overlayRef.hasAttached()||this._overlayRef.attach(this._templatePortal),this.hasBackdrop?this._backdropSubscription=this._overlayRef.backdropClick().subscribe(e=>{this.backdropClick.emit(e)}):this._backdropSubscription.unsubscribe(),this._positionSubscription.unsubscribe(),this.positionChange.observers.length>0&&(this._positionSubscription=this._position.positionChanges.pipe(cx(()=>this.positionChange.observers.length>0)).subscribe(e=>{this.positionChange.emit(e),0===this.positionChange.observers.length&&this._positionSubscription.unsubscribe()}))}_detachOverlay(){this._overlayRef&&this._overlayRef.detach(),this._backdropSubscription.unsubscribe(),this._positionSubscription.unsubscribe()}}return n.\u0275fac=function(e){return new(e||n)(M(tr),M(Vi),M(Oi),M(Cte),M($i,8))},n.\u0275dir=He({type:n,selectors:[["","cdk-connected-overlay",""],["","connected-overlay",""],["","cdkConnectedOverlay",""]],inputs:{origin:["cdkConnectedOverlayOrigin","origin"],positions:["cdkConnectedOverlayPositions","positions"],positionStrategy:["cdkConnectedOverlayPositionStrategy","positionStrategy"],offsetX:["cdkConnectedOverlayOffsetX","offsetX"],offsetY:["cdkConnectedOverlayOffsetY","offsetY"],width:["cdkConnectedOverlayWidth","width"],height:["cdkConnectedOverlayHeight","height"],minWidth:["cdkConnectedOverlayMinWidth","minWidth"],minHeight:["cdkConnectedOverlayMinHeight","minHeight"],backdropClass:["cdkConnectedOverlayBackdropClass","backdropClass"],panelClass:["cdkConnectedOverlayPanelClass","panelClass"],viewportMargin:["cdkConnectedOverlayViewportMargin","viewportMargin"],scrollStrategy:["cdkConnectedOverlayScrollStrategy","scrollStrategy"],open:["cdkConnectedOverlayOpen","open"],disableClose:["cdkConnectedOverlayDisableClose","disableClose"],transformOriginSelector:["cdkConnectedOverlayTransformOriginOn","transformOriginSelector"],hasBackdrop:["cdkConnectedOverlayHasBackdrop","hasBackdrop"],lockPosition:["cdkConnectedOverlayLockPosition","lockPosition"],flexibleDimensions:["cdkConnectedOverlayFlexibleDimensions","flexibleDimensions"],growAfterOpen:["cdkConnectedOverlayGrowAfterOpen","growAfterOpen"],push:["cdkConnectedOverlayPush","push"]},outputs:{backdropClick:"backdropClick",positionChange:"positionChange",attach:"attach",detach:"detach",overlayKeydown:"overlayKeydown",overlayOutsideClick:"overlayOutsideClick"},exportAs:["cdkConnectedOverlay"],features:[Ft]}),n})(),MOe={provide:Cte,deps:[tr],useFactory:function(n){return()=>n.scrollStrategies.reposition()}},ss=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[tr,MOe],imports:[Dh,eu,Zc,Zc]}),n})();function wOe(n,t){if(1&n){let e=Pe();_(0,"div",2)(1,"button",3),P("click",function(){return oe(e),se(S().action())}),A(2),v()()}if(2&n){let e=S();C(2),yt(e.data.action)}}function SOe(n,t){}var w2=new pe("MatSnackBarData"),Ov=class{constructor(){this.politeness="assertive",this.announcementMessage="",this.duration=0,this.data=null,this.horizontalPosition="center",this.verticalPosition="bottom"}},EOe=Math.pow(2,31)-1,rg=class{constructor(t,e){this._overlayRef=e,this._afterDismissed=new ke,this._afterOpened=new ke,this._onAction=new ke,this._dismissedByAction=!1,this.containerInstance=t,t._onExit.subscribe(()=>this._finishDismiss())}dismiss(){this._afterDismissed.closed||this.containerInstance.exit(),clearTimeout(this._durationTimeoutId)}dismissWithAction(){this._onAction.closed||(this._dismissedByAction=!0,this._onAction.next(),this._onAction.complete(),this.dismiss()),clearTimeout(this._durationTimeoutId)}closeWithAction(){this.dismissWithAction()}_dismissAfter(t){this._durationTimeoutId=setTimeout(()=>this.dismiss(),Math.min(t,EOe))}_open(){this._afterOpened.closed||(this._afterOpened.next(),this._afterOpened.complete())}_finishDismiss(){this._overlayRef.dispose(),this._onAction.closed||this._onAction.complete(),this._afterDismissed.next({dismissedByAction:this._dismissedByAction}),this._afterDismissed.complete(),this._dismissedByAction=!1}afterDismissed(){return this._afterDismissed}afterOpened(){return this.containerInstance._onEnter}onAction(){return this._onAction}},TOe=(()=>{class n{constructor(e,i){this.snackBarRef=e,this.data=i}action(){this.snackBarRef.dismissWithAction()}get hasAction(){return!!this.data.action}}return n.\u0275fac=function(e){return new(e||n)(M(rg),M(w2))},n.\u0275cmp=R({type:n,selectors:[["simple-snack-bar"]],hostAttrs:[1,"mat-simple-snackbar"],decls:3,vars:2,consts:[[1,"mat-simple-snack-bar-content"],["class","mat-simple-snackbar-action",4,"ngIf"],[1,"mat-simple-snackbar-action"],["mat-button","",3,"click"]],template:function(e,i){1&e&&(_(0,"span",0),A(1),v(),E(2,wOe,3,1,"div",1)),2&e&&(C(1),yt(i.data.message),C(1),y("ngIf",i.hasAction))},dependencies:[Be,_n],styles:[".mat-simple-snackbar{display:flex;justify-content:space-between;align-items:center;line-height:20px;opacity:1}.mat-simple-snackbar-action{flex-shrink:0;margin:-8px -8px -8px 8px}.mat-simple-snackbar-action button{max-height:36px;min-width:0}[dir=rtl] .mat-simple-snackbar-action{margin-left:-8px;margin-right:8px}.mat-simple-snack-bar-content{overflow:hidden;text-overflow:ellipsis}"],encapsulation:2,changeDetection:0}),n})(),DOe={snackBarState:Kr("state",[ki("void, hidden",gn({transform:"scale(0.8)",opacity:0})),ki("visible",gn({transform:"scale(1)",opacity:1})),Li("* => visible",ji("150ms cubic-bezier(0, 0, 0.2, 1)")),Li("* => void, * => hidden",ji("75ms cubic-bezier(0.4, 0.0, 1, 1)",gn({opacity:0})))])},AOe=(()=>{class n extends Ph{constructor(e,i,r,o,s){super(),this._ngZone=e,this._elementRef=i,this._changeDetectorRef=r,this._platform=o,this.snackBarConfig=s,this._announceDelay=150,this._destroyed=!1,this._onAnnounce=new ke,this._onExit=new ke,this._onEnter=new ke,this._animationState="void",this.attachDomPortal=a=>{this._assertNotAttached();let l=this._portalOutlet.attachDomPortal(a);return this._afterPortalAttached(),l},this._live="assertive"!==s.politeness||s.announcementMessage?"off"===s.politeness?"off":"polite":"assertive",this._platform.FIREFOX&&("polite"===this._live&&(this._role="status"),"assertive"===this._live&&(this._role="alert"))}attachComponentPortal(e){this._assertNotAttached();let i=this._portalOutlet.attachComponentPortal(e);return this._afterPortalAttached(),i}attachTemplatePortal(e){this._assertNotAttached();let i=this._portalOutlet.attachTemplatePortal(e);return this._afterPortalAttached(),i}onAnimationEnd(e){let{fromState:i,toState:r}=e;if(("void"===r&&"void"!==i||"hidden"===r)&&this._completeExit(),"visible"===r){let o=this._onEnter;this._ngZone.run(()=>{o.next(),o.complete()})}}enter(){this._destroyed||(this._animationState="visible",this._changeDetectorRef.detectChanges(),this._screenReaderAnnounce())}exit(){return this._ngZone.run(()=>{this._animationState="hidden",this._elementRef.nativeElement.setAttribute("mat-exit",""),clearTimeout(this._announceTimeoutId)}),this._onExit}ngOnDestroy(){this._destroyed=!0,this._completeExit()}_completeExit(){this._ngZone.onMicrotaskEmpty.pipe(Qt(1)).subscribe(()=>{this._ngZone.run(()=>{this._onExit.next(),this._onExit.complete()})})}_afterPortalAttached(){let e=this._elementRef.nativeElement,i=this.snackBarConfig.panelClass;i&&(Array.isArray(i)?i.forEach(r=>e.classList.add(r)):e.classList.add(i))}_assertNotAttached(){this._portalOutlet.hasAttached()}_screenReaderAnnounce(){this._announceTimeoutId||this._ngZone.runOutsideAngular(()=>{this._announceTimeoutId=setTimeout(()=>{let e=this._elementRef.nativeElement.querySelector("[aria-hidden]"),i=this._elementRef.nativeElement.querySelector("[aria-live]");if(e&&i){let r=null;this._platform.isBrowser&&document.activeElement instanceof HTMLElement&&e.contains(document.activeElement)&&(r=document.activeElement),e.removeAttribute("aria-hidden"),i.appendChild(e),r?.focus(),this._onAnnounce.next(),this._onAnnounce.complete()}},this._announceDelay)})}}return n.\u0275fac=function(e){return new(e||n)(M(_t),M(Re),M(nn),M(oi),M(Ov))},n.\u0275dir=He({type:n,viewQuery:function(e,i){if(1&e&&ot(da,7),2&e){let r;Ne(r=Le())&&(i._portalOutlet=r.first)}},features:[tt]}),n})(),IOe=(()=>{class n extends AOe{_afterPortalAttached(){super._afterPortalAttached(),"center"===this.snackBarConfig.horizontalPosition&&this._elementRef.nativeElement.classList.add("mat-snack-bar-center"),"top"===this.snackBarConfig.verticalPosition&&this._elementRef.nativeElement.classList.add("mat-snack-bar-top")}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275cmp=R({type:n,selectors:[["snack-bar-container"]],hostAttrs:[1,"mat-snack-bar-container"],hostVars:1,hostBindings:function(e,i){1&e&&i_("@state.done",function(o){return i.onAnimationEnd(o)}),2&e&&r_("@state",i._animationState)},features:[tt],decls:3,vars:2,consts:[["aria-hidden","true"],["cdkPortalOutlet",""]],template:function(e,i){1&e&&(_(0,"div",0),E(1,SOe,0,0,"ng-template",1),v(),O(2,"div")),2&e&&(C(2),ze("aria-live",i._live)("role",i._role))},dependencies:[da],styles:[".mat-snack-bar-container{border-radius:4px;box-sizing:border-box;display:block;margin:24px;max-width:33vw;min-width:344px;padding:14px 16px;min-height:48px;transform-origin:center}.cdk-high-contrast-active .mat-snack-bar-container{border:solid 1px}.mat-snack-bar-handset{width:100%}.mat-snack-bar-handset .mat-snack-bar-container{margin:8px;max-width:100%;min-width:0;width:100%}"],encapsulation:2,data:{animation:[DOe.snackBarState]}}),n})(),kH=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[ss,eu,Me,Pn,ln,ln]}),n})(),Mte=new pe("mat-snack-bar-default-options",{providedIn:"root",factory:function(){return new Ov}}),ROe=(()=>{class n{constructor(e,i,r,o,s,a){this._overlay=e,this._live=i,this._injector=r,this._breakpointObserver=o,this._parentSnackBar=s,this._defaultConfig=a,this._snackBarRefAtThisLevel=null}get _openedSnackBarRef(){let e=this._parentSnackBar;return e?e._openedSnackBarRef:this._snackBarRefAtThisLevel}set _openedSnackBarRef(e){this._parentSnackBar?this._parentSnackBar._openedSnackBarRef=e:this._snackBarRefAtThisLevel=e}openFromComponent(e,i){return this._attach(e,i)}openFromTemplate(e,i){return this._attach(e,i)}open(e,i="",r){let o={...this._defaultConfig,...r};return o.data={message:e,action:i},o.announcementMessage===e&&(o.announcementMessage=void 0),this.openFromComponent(this.simpleSnackBarComponent,o)}dismiss(){this._openedSnackBarRef&&this._openedSnackBarRef.dismiss()}ngOnDestroy(){this._snackBarRefAtThisLevel&&this._snackBarRefAtThisLevel.dismiss()}_attachSnackBarContainer(e,i){let o=Xn.create({parent:i&&i.viewContainerRef&&i.viewContainerRef.injector||this._injector,providers:[{provide:Ov,useValue:i}]}),s=new $c(this.snackBarContainerComponent,i.viewContainerRef,o),a=e.attach(s);return a.instance.snackBarConfig=i,a.instance}_attach(e,i){let r={...new Ov,...this._defaultConfig,...i},o=this._createOverlay(r),s=this._attachSnackBarContainer(o,r),a=new rg(s,o);if(e instanceof Vi){let l=new ks(e,null,{$implicit:r.data,snackBarRef:a});a.instance=s.attachTemplatePortal(l)}else{let l=this._createInjector(r,a),c=new $c(e,void 0,l),u=s.attachComponentPortal(c);a.instance=u.instance}return this._breakpointObserver.observe("(max-width: 599.98px) and (orientation: portrait)").pipe(st(o.detachments())).subscribe(l=>{o.overlayElement.classList.toggle(this.handsetCssClass,l.matches)}),r.announcementMessage&&s._onAnnounce.subscribe(()=>{this._live.announce(r.announcementMessage,r.politeness)}),this._animateSnackBar(a,r),this._openedSnackBarRef=a,this._openedSnackBarRef}_animateSnackBar(e,i){e.afterDismissed().subscribe(()=>{this._openedSnackBarRef==e&&(this._openedSnackBarRef=null),i.announcementMessage&&this._live.clear()}),this._openedSnackBarRef?(this._openedSnackBarRef.afterDismissed().subscribe(()=>{e.containerInstance.enter()}),this._openedSnackBarRef.dismiss()):e.containerInstance.enter(),i.duration&&i.duration>0&&e.afterOpened().subscribe(()=>e._dismissAfter(i.duration))}_createOverlay(e){let i=new sc;i.direction=e.direction;let r=this._overlay.position().global(),o="rtl"===e.direction,s="left"===e.horizontalPosition||"start"===e.horizontalPosition&&!o||"end"===e.horizontalPosition&&o,a=!s&&"center"!==e.horizontalPosition;return s?r.left("0"):a?r.right("0"):r.centerHorizontally(),"top"===e.verticalPosition?r.top("0"):r.bottom("0"),i.positionStrategy=r,this._overlay.create(i)}_createInjector(e,i){return Xn.create({parent:e&&e.viewContainerRef&&e.viewContainerRef.injector||this._injector,providers:[{provide:rg,useValue:i},{provide:w2,useValue:e.data}]})}}return n.\u0275fac=function(e){return new(e||n)(j(tr),j(tw),j(Xn),j(Jm),j(n,12),j(Mte))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),wte=(()=>{class n extends ROe{constructor(e,i,r,o,s,a){super(e,i,r,o,s,a),this.simpleSnackBarComponent=TOe,this.snackBarContainerComponent=IOe,this.handsetCssClass="mat-snack-bar-handset"}}return n.\u0275fac=function(e){return new(e||n)(j(tr),j(tw),j(Xn),j(Jm),j(n,12),j(Mte))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:kH}),n})(),OOe=/[\\^$.*+?()[\]{}|]/g,Ete="\\u0000-\\u0020\\u007f-\\u009f",FOe=new RegExp("(?:[a-zA-Z][a-zA-Z0-9+.-]{2,}:\\/\\/|data:|www\\.)[^\\s"+Ete+'"]{2,}[^\\s'+Ete+"\"')}\\],:;.!?]","gu");function Dte(n){return function(n,t){t.flags.includes("g")||(t=new RegExp(t,t.flags+"g"));let e=[],i=0;for(let r of n.matchAll(t)){let o=r.index,s=r[0];o>i&&e.push({index:i,text:n.substring(i,o),matchesRegex:!1}),e.push({index:o,text:s,matchesRegex:!0}),i=o+s.length}return n.length>i&&e.push({index:i,text:n.substring(i,n.length),matchesRegex:!1}),e}(n,FOe).map(({matchesRegex:t,text:e})=>({isURL:t,text:e}))}function NOe(n,t){if(1&n&&(sn(0),A(1),an()),2&n){let e=S().$implicit;C(1),je(" ",e.text," ")}}function LOe(n,t){if(1&n&&(_(0,"a",7),A(1),v()),2&n){let e=S().$implicit;Zi("href",e.text,zl),C(1),yt(e.text)}}function BOe(n,t){if(1&n&&(sn(0),E(1,NOe,2,1,"ng-container",5),E(2,LOe,2,2,"ng-template",null,6,qt),an()),2&n){let e=t.$implicit,i=$e(3);C(1),y("ngIf",!e.isURL)("ngIfElse",i)}}function VOe(n,t){if(1&n){let e=Pe();_(0,"button",8),P("click",function(){return oe(e),se(S().onActionButtonClicked())}),A(1),v()}if(2&n){let e=S();C(1),je(" ",e.alert.followupAction.localizedLabel," ")}}var Ate=(()=>{class n{constructor(e,i,r){this.snackBarRef=e,this.unknownData=i,this.store=r,this.splitByURL=Dte,this.alert=i}async onActionButtonClicked(){this.snackBarRef.dismiss();let e=await this.alert.followupAction.getFollowupAction(this.store);this.store.dispatch(e)}onCloseButtonClicked(){this.snackBarRef.dismiss()}}return n.\u0275fac=function(e){return new(e||n)(M(rg),M(w2),M(Ce))},n.\u0275cmp=R({type:n,selectors:[["alert-display-snackbar"]],decls:6,vars:2,consts:function(){let t;return t=$localize`:A button to close the snackbar message␟ea4d9fe61420a3fce81cf54c4c615e3c19c646a6␟1536087519743707362:Dismiss`,[[1,"message"],[4,"ngFor","ngForOf"],[1,"controls"],["mat-button","","class","followup-button",3,"click",4,"ngIf"],["mat-button","","aria-label",t,1,"dismiss-button",3,"click"],[4,"ngIf","ngIfElse"],["linkPiece",""],["rel","noreferrer noopener","target","_blank",3,"href"],["mat-button","",1,"followup-button",3,"click"]]},template:function(e,i){1&e&&(_(0,"div",0),E(1,BOe,4,2,"ng-container",1),v(),_(2,"div",2),E(3,VOe,2,1,"button",3),_(4,"button",4),P("click",function(){return i.onCloseButtonClicked()}),A(5," Dismiss "),v()()),2&e&&(C(1),y("ngForOf",i.splitByURL(i.alert.localizedMessage)),C(2),y("ngIf",i.alert.followupAction))},dependencies:[dn,Be,_n],styles:["[_nghost-%COMP%]{display:flex;flex-wrap:wrap}.message[_ngcontent-%COMP%]{font-size:14px;align-self:center;margin:5px 0;word-break:break-word}.message[_ngcontent-%COMP%]   a[_ngcontent-%COMP%]{color:inherit}.controls[_ngcontent-%COMP%]{white-space:nowrap;margin-left:auto}button[_ngcontent-%COMP%]{text-transform:uppercase}"],changeDetection:0}),n})(),Ite=(()=>{class n{constructor(e,i){this.store=e,this.snackBar=i,this.ngUnsubscribe=new ke}ngOnInit(){this.store.select(q$).pipe(st(this.ngUnsubscribe),Ye(e=>Boolean(e))).subscribe(e=>{this.showAlert(e)})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}showAlert(e){this.snackBar.openFromComponent(Ate,{duration:5e3,horizontalPosition:"start",verticalPosition:"bottom",data:e})}}return n.\u0275fac=function(e){return new(e||n)(M(Ce),M(wte))},n.\u0275cmp=R({type:n,selectors:[["alert-snackbar"]],decls:0,vars:0,template:function(e,i){},encapsulation:2,changeDetection:0}),n})(),S2=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,Pn,kH]}),n})(),E2=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Ju,S2,wr.forFeature("alerts",Uee),ro.forFeature([Hee])]}),n})();function UOe(n,t){}var og=class{constructor(){this.role="dialog",this.panelClass="",this.hasBackdrop=!0,this.backdropClass="",this.disableClose=!1,this.width="",this.height="",this.data=null,this.ariaDescribedBy=null,this.ariaLabelledBy=null,this.ariaLabel=null,this.ariaModal=!0,this.autoFocus="first-tabbable",this.restoreFocus=!0,this.closeOnNavigation=!0,this.closeOnDestroy=!0}},NH=(()=>{class n extends Ph{constructor(e,i,r,o,s,a,l,c){super(),this._elementRef=e,this._focusTrapFactory=i,this._config=o,this._interactivityChecker=s,this._ngZone=a,this._overlayRef=l,this._focusMonitor=c,this._elementFocusedBeforeDialogWasOpened=null,this._closeInteractionType=null,this.attachDomPortal=u=>{this._portalOutlet.hasAttached();let d=this._portalOutlet.attachDomPortal(u);return this._contentAttached(),d},this._ariaLabelledBy=this._config.ariaLabelledBy||null,this._document=r}_contentAttached(){this._initializeFocusTrap(),this._handleBackdropClicks(),this._captureInitialFocus()}_captureInitialFocus(){this._trapFocus()}ngOnDestroy(){this._restoreFocus()}attachComponentPortal(e){this._portalOutlet.hasAttached();let i=this._portalOutlet.attachComponentPortal(e);return this._contentAttached(),i}attachTemplatePortal(e){this._portalOutlet.hasAttached();let i=this._portalOutlet.attachTemplatePortal(e);return this._contentAttached(),i}_recaptureFocus(){this._containsFocus()||this._trapFocus()}_forceFocus(e,i){this._interactivityChecker.isFocusable(e)||(e.tabIndex=-1,this._ngZone.runOutsideAngular(()=>{let r=()=>{e.removeEventListener("blur",r),e.removeEventListener("mousedown",r),e.removeAttribute("tabindex")};e.addEventListener("blur",r),e.addEventListener("mousedown",r)})),e.focus(i)}_focusByCssSelector(e,i){let r=this._elementRef.nativeElement.querySelector(e);r&&this._forceFocus(r,i)}_trapFocus(){let e=this._elementRef.nativeElement;switch(this._config.autoFocus){case!1:case"dialog":this._containsFocus()||e.focus();break;case!0:case"first-tabbable":this._focusTrap.focusInitialElementWhenReady().then(i=>{i||this._focusDialogContainer()});break;case"first-heading":this._focusByCssSelector('h1, h2, h3, h4, h5, h6, [role="heading"]');break;default:this._focusByCssSelector(this._config.autoFocus)}}_restoreFocus(){let e=this._config.restoreFocus,i=null;if("string"==typeof e?i=this._document.querySelector(e):"boolean"==typeof e?i=e?this._elementFocusedBeforeDialogWasOpened:null:e&&(i=e),this._config.restoreFocus&&i&&"function"==typeof i.focus){let r=KM(),o=this._elementRef.nativeElement;(!r||r===this._document.body||r===o||o.contains(r))&&(this._focusMonitor?(this._focusMonitor.focusVia(i,this._closeInteractionType),this._closeInteractionType=null):i.focus())}this._focusTrap&&this._focusTrap.destroy()}_focusDialogContainer(){this._elementRef.nativeElement.focus&&this._elementRef.nativeElement.focus()}_containsFocus(){let e=this._elementRef.nativeElement,i=KM();return e===i||e.contains(i)}_initializeFocusTrap(){this._focusTrap=this._focusTrapFactory.create(this._elementRef.nativeElement),this._document&&(this._elementFocusedBeforeDialogWasOpened=KM())}_handleBackdropClicks(){this._overlayRef.backdropClick().subscribe(()=>{this._config.disableClose&&this._recaptureFocus()})}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(JM),M(Ht,8),M(og),M(Sv),M(_t),M(dd),M(Fr))},n.\u0275cmp=R({type:n,selectors:[["cdk-dialog-container"]],viewQuery:function(e,i){if(1&e&&ot(da,7),2&e){let r;Ne(r=Le())&&(i._portalOutlet=r.first)}},hostAttrs:["tabindex","-1",1,"cdk-dialog-container"],hostVars:6,hostBindings:function(e,i){2&e&&ze("id",i._config.id||null)("role",i._config.role)("aria-modal",i._config.ariaModal)("aria-labelledby",i._config.ariaLabel?null:i._ariaLabelledBy)("aria-label",i._config.ariaLabel)("aria-describedby",i._config.ariaDescribedBy||null)},features:[tt],decls:1,vars:0,consts:[["cdkPortalOutlet",""]],template:function(e,i){1&e&&E(0,UOe,0,0,"ng-template",0)},dependencies:[da],styles:[".cdk-dialog-container{display:block;width:100%;height:100%;min-height:inherit;max-height:inherit}"],encapsulation:2}),n})(),lw=class{constructor(t,e){this.overlayRef=t,this.config=e,this.closed=new ke,this.disableClose=e.disableClose,this.backdropClick=t.backdropClick(),this.keydownEvents=t.keydownEvents(),this.outsidePointerEvents=t.outsidePointerEvents(),this.id=e.id,this.keydownEvents.subscribe(i=>{27===i.keyCode&&!this.disableClose&&!kr(i)&&(i.preventDefault(),this.close(void 0,{focusOrigin:"keyboard"}))}),this.backdropClick.subscribe(()=>{this.disableClose||this.close(void 0,{focusOrigin:"mouse"})})}close(t,e){if(this.containerInstance){let i=this.closed;this.containerInstance._closeInteractionType=e?.focusOrigin||"program",this.overlayRef.dispose(),i.next(t),i.complete(),this.componentInstance=this.containerInstance=null}}updatePosition(){return this.overlayRef.updatePosition(),this}updateSize(t="",e=""){return this.overlayRef.updateSize({width:t,height:e}),this}addPanelClass(t){return this.overlayRef.addPanelClass(t),this}removePanelClass(t){return this.overlayRef.removePanelClass(t),this}},Pte=new pe("DialogScrollStrategy"),zOe=new pe("DialogData"),jOe=new pe("DefaultDialogConfig"),WOe={provide:Pte,deps:[tr],useFactory:function(n){return()=>n.scrollStrategies.block()}},qOe=0,LH=(()=>{class n{constructor(e,i,r,o,s,a){this._overlay=e,this._injector=i,this._defaultOptions=r,this._parentDialog=o,this._overlayContainer=s,this._openDialogsAtThisLevel=[],this._afterAllClosedAtThisLevel=new ke,this._afterOpenedAtThisLevel=new ke,this._ariaHiddenElements=new Map,this.afterAllClosed=Qa(()=>this.openDialogs.length?this._getAfterAllClosed():this._getAfterAllClosed().pipe(zn(void 0))),this._scrollStrategy=a}get openDialogs(){return this._parentDialog?this._parentDialog.openDialogs:this._openDialogsAtThisLevel}get afterOpened(){return this._parentDialog?this._parentDialog.afterOpened:this._afterOpenedAtThisLevel}open(e,i){(i={...this._defaultOptions||new og,...i}).id=i.id||"cdk-dialog-"+qOe++,i.id&&this.getDialogById(i.id);let o=this._getOverlayConfig(i),s=this._overlay.create(o),a=new lw(s,i),l=this._attachContainer(s,a,i);return a.containerInstance=l,this._attachDialogContent(e,a,l,i),this.openDialogs.length||this._hideNonDialogContentFromAssistiveTechnology(),this.openDialogs.push(a),a.closed.subscribe(()=>this._removeOpenDialog(a,!0)),this.afterOpened.next(a),a}closeAll(){FH(this.openDialogs,e=>e.close())}getDialogById(e){return this.openDialogs.find(i=>i.id===e)}ngOnDestroy(){FH(this._openDialogsAtThisLevel,e=>{!1===e.config.closeOnDestroy&&this._removeOpenDialog(e,!1)}),FH(this._openDialogsAtThisLevel,e=>e.close()),this._afterAllClosedAtThisLevel.complete(),this._afterOpenedAtThisLevel.complete(),this._openDialogsAtThisLevel=[]}_getOverlayConfig(e){let i=new sc({positionStrategy:e.positionStrategy||this._overlay.position().global().centerHorizontally().centerVertically(),scrollStrategy:e.scrollStrategy||this._scrollStrategy(),panelClass:e.panelClass,hasBackdrop:e.hasBackdrop,direction:e.direction,minWidth:e.minWidth,minHeight:e.minHeight,maxWidth:e.maxWidth,maxHeight:e.maxHeight,width:e.width,height:e.height,disposeOnNavigation:e.closeOnNavigation});return e.backdropClass&&(i.backdropClass=e.backdropClass),i}_attachContainer(e,i,r){let a,o=r.injector||r.viewContainerRef?.injector,s=[{provide:og,useValue:r},{provide:lw,useValue:i},{provide:dd,useValue:e}];r.container?"function"==typeof r.container?a=r.container:(a=r.container.type,s.push(...r.container.providers(r))):a=NH;let l=new $c(a,r.viewContainerRef,Xn.create({parent:o||this._injector,providers:s}),r.componentFactoryResolver);return e.attach(l).instance}_attachDialogContent(e,i,r,o){if(e instanceof Vi){let s=this._createInjector(o,i,r,void 0),a={$implicit:o.data,dialogRef:i};o.templateContext&&(a={...a,..."function"==typeof o.templateContext?o.templateContext():o.templateContext}),r.attachTemplatePortal(new ks(e,null,a,s))}else{let s=this._createInjector(o,i,r,this._injector),a=r.attachComponentPortal(new $c(e,o.viewContainerRef,s,o.componentFactoryResolver));i.componentInstance=a.instance}}_createInjector(e,i,r,o){let s=e.injector||e.viewContainerRef?.injector,a=[{provide:zOe,useValue:e.data},{provide:lw,useValue:i}];return e.providers&&("function"==typeof e.providers?a.push(...e.providers(i,e,r)):a.push(...e.providers)),e.direction&&(!s||!s.get($i,null,di.Optional))&&a.push({provide:$i,useValue:{value:e.direction,change:Xt()}}),Xn.create({parent:s||o,providers:a})}_removeOpenDialog(e,i){let r=this.openDialogs.indexOf(e);r>-1&&(this.openDialogs.splice(r,1),this.openDialogs.length||(this._ariaHiddenElements.forEach((o,s)=>{o?s.setAttribute("aria-hidden",o):s.removeAttribute("aria-hidden")}),this._ariaHiddenElements.clear(),i&&this._getAfterAllClosed().next()))}_hideNonDialogContentFromAssistiveTechnology(){let e=this._overlayContainer.getContainerElement();if(e.parentElement){let i=e.parentElement.children;for(let r=i.length-1;r>-1;r--){let o=i[r];o!==e&&"SCRIPT"!==o.nodeName&&"STYLE"!==o.nodeName&&!o.hasAttribute("aria-live")&&(this._ariaHiddenElements.set(o,o.getAttribute("aria-hidden")),o.setAttribute("aria-hidden","true"))}}}_getAfterAllClosed(){let e=this._parentDialog;return e?e._getAfterAllClosed():this._afterAllClosedAtThisLevel}}return n.\u0275fac=function(e){return new(e||n)(j(tr),j(Xn),j(jOe,8),j(n,12),j(Rv),j(Pte))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})();function FH(n,t){let e=n.length;for(;e--;)t(n[e])}var Rte=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[LH,WOe],imports:[ss,eu,Ev,eu]}),n})();function YOe(n,t){}var kv={params:{enterAnimationDuration:"150ms",exitAnimationDuration:"75ms"}},XOe={dialogContainer:Kr("dialogContainer",[ki("void, exit",gn({opacity:0,transform:"scale(0.7)"})),ki("enter",gn({transform:"none"})),Li("* => enter",x5([ji("{{enterAnimationDuration}} cubic-bezier(0, 0, 0.2, 1)",gn({transform:"none",opacity:1})),Im("@*",Am(),{optional:!0})]),kv),Li("* => void, * => exit",x5([ji("{{exitAnimationDuration}} cubic-bezier(0.4, 0.0, 0.2, 1)",gn({opacity:0})),Im("@*",Am(),{optional:!0})]),kv)])},Fv=class{constructor(){this.role="dialog",this.panelClass="",this.hasBackdrop=!0,this.backdropClass="",this.disableClose=!1,this.width="",this.height="",this.maxWidth="80vw",this.data=null,this.ariaDescribedBy=null,this.ariaLabelledBy=null,this.ariaLabel=null,this.ariaModal=!0,this.autoFocus="first-tabbable",this.restoreFocus=!0,this.delayFocusTrap=!0,this.closeOnNavigation=!0,this.enterAnimationDuration=kv.params.enterAnimationDuration,this.exitAnimationDuration=kv.params.exitAnimationDuration}},QOe=(()=>{class n extends NH{constructor(e,i,r,o,s,a,l,c){super(e,i,r,o,s,a,l,c),this._animationStateChanged=new G}_captureInitialFocus(){this._config.delayFocusTrap||this._trapFocus()}_openAnimationDone(e){this._config.delayFocusTrap&&this._trapFocus(),this._animationStateChanged.next({state:"opened",totalTime:e})}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(JM),M(Ht,8),M(Fv),M(Sv),M(_t),M(dd),M(Fr))},n.\u0275cmp=R({type:n,selectors:[["ng-component"]],features:[tt],decls:0,vars:0,template:function(e,i){},encapsulation:2}),n})(),KOe=(()=>{class n extends QOe{constructor(e,i,r,o,s,a,l,c,u){super(e,i,r,o,s,a,l,u),this._changeDetectorRef=c,this._state="enter"}_onAnimationDone({toState:e,totalTime:i}){"enter"===e?this._openAnimationDone(i):"exit"===e&&this._animationStateChanged.next({state:"closed",totalTime:i})}_onAnimationStart({toState:e,totalTime:i}){"enter"===e?this._animationStateChanged.next({state:"opening",totalTime:i}):("exit"===e||"void"===e)&&this._animationStateChanged.next({state:"closing",totalTime:i})}_startExitAnimation(){this._state="exit",this._changeDetectorRef.markForCheck()}_getAnimationState(){return{value:this._state,params:{enterAnimationDuration:this._config.enterAnimationDuration||kv.params.enterAnimationDuration,exitAnimationDuration:this._config.exitAnimationDuration||kv.params.exitAnimationDuration}}}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(JM),M(Ht,8),M(Fv),M(Sv),M(_t),M(dd),M(nn),M(Fr))},n.\u0275cmp=R({type:n,selectors:[["mat-dialog-container"]],hostAttrs:["tabindex","-1",1,"mat-dialog-container"],hostVars:7,hostBindings:function(e,i){1&e&&i_("@dialogContainer.start",function(o){return i._onAnimationStart(o)})("@dialogContainer.done",function(o){return i._onAnimationDone(o)}),2&e&&(_s("id",i._config.id),ze("aria-modal",i._config.ariaModal)("role",i._config.role)("aria-labelledby",i._config.ariaLabel?null:i._ariaLabelledBy)("aria-label",i._config.ariaLabel)("aria-describedby",i._config.ariaDescribedBy||null),r_("@dialogContainer",i._getAnimationState()))},features:[tt],decls:1,vars:0,consts:[["cdkPortalOutlet",""]],template:function(e,i){1&e&&E(0,YOe,0,0,"ng-template",0)},dependencies:[da],styles:[".mat-dialog-container{display:block;padding:24px;border-radius:4px;box-sizing:border-box;overflow:auto;outline:0;width:100%;height:100%;min-height:inherit;max-height:inherit}.cdk-high-contrast-active .mat-dialog-container{outline:solid 1px}.mat-dialog-content{display:block;margin:0 -24px;padding:0 24px;max-height:65vh;overflow:auto;-webkit-overflow-scrolling:touch}.mat-dialog-title{margin:0 0 20px;display:block}.mat-dialog-actions{padding:8px 0;display:flex;flex-wrap:wrap;min-height:52px;align-items:center;box-sizing:content-box;margin-bottom:-24px}.mat-dialog-actions.mat-dialog-actions-align-center,.mat-dialog-actions[align=center]{justify-content:center}.mat-dialog-actions.mat-dialog-actions-align-end,.mat-dialog-actions[align=end]{justify-content:flex-end}.mat-dialog-actions .mat-button-base+.mat-button-base,.mat-dialog-actions .mat-mdc-button-base+.mat-mdc-button-base{margin-left:8px}[dir=rtl] .mat-dialog-actions .mat-button-base+.mat-button-base,[dir=rtl] .mat-dialog-actions .mat-mdc-button-base+.mat-mdc-button-base{margin-left:0;margin-right:8px}"],encapsulation:2,data:{animation:[XOe.dialogContainer]}}),n})(),tu=class{constructor(t,e,i){this._ref=t,this._containerInstance=i,this._afterOpened=new ke,this._beforeClosed=new ke,this._state=0,this.disableClose=e.disableClose,this.id=t.id,i._animationStateChanged.pipe(Ye(r=>"opened"===r.state),Qt(1)).subscribe(()=>{this._afterOpened.next(),this._afterOpened.complete()}),i._animationStateChanged.pipe(Ye(r=>"closed"===r.state),Qt(1)).subscribe(()=>{clearTimeout(this._closeFallbackTimeout),this._finishDialogClose()}),t.overlayRef.detachments().subscribe(()=>{this._beforeClosed.next(this._result),this._beforeClosed.complete(),this._finishDialogClose()}),Jt(this.backdropClick(),this.keydownEvents().pipe(Ye(r=>27===r.keyCode&&!this.disableClose&&!kr(r)))).subscribe(r=>{this.disableClose||(r.preventDefault(),Ote(this,"keydown"===r.type?"keyboard":"mouse"))})}close(t){this._result=t,this._containerInstance._animationStateChanged.pipe(Ye(e=>"closing"===e.state),Qt(1)).subscribe(e=>{this._beforeClosed.next(t),this._beforeClosed.complete(),this._ref.overlayRef.detachBackdrop(),this._closeFallbackTimeout=setTimeout(()=>this._finishDialogClose(),e.totalTime+100)}),this._state=1,this._containerInstance._startExitAnimation()}afterOpened(){return this._afterOpened}afterClosed(){return this._ref.closed}beforeClosed(){return this._beforeClosed}backdropClick(){return this._ref.backdropClick}keydownEvents(){return this._ref.keydownEvents}updatePosition(t){let e=this._ref.config.positionStrategy;return t&&(t.left||t.right)?t.left?e.left(t.left):e.right(t.right):e.centerHorizontally(),t&&(t.top||t.bottom)?t.top?e.top(t.top):e.bottom(t.bottom):e.centerVertically(),this._ref.updatePosition(),this}updateSize(t="",e=""){return this._ref.updateSize(t,e),this}addPanelClass(t){return this._ref.addPanelClass(t),this}removePanelClass(t){return this._ref.removePanelClass(t),this}getState(){return this._state}_finishDialogClose(){this._state=2,this._ref.close(this._result,{focusOrigin:this._closeInteractionType}),this.componentInstance=null}};function Ote(n,t,e){return n._closeInteractionType=t,n.close(e)}var cw=new pe("MatDialogData"),ZOe=new pe("mat-dialog-default-options"),kte=new pe("mat-dialog-scroll-strategy"),$Oe={provide:kte,deps:[tr],useFactory:function(n){return()=>n.scrollStrategies.block()}},eke=0,tke=(()=>{class n{constructor(e,i,r,o,s,a,l,c,u,d){this._overlay=e,this._defaultOptions=r,this._parentDialog=o,this._dialogRefConstructor=l,this._dialogContainerType=c,this._dialogDataToken=u,this._openDialogsAtThisLevel=[],this._afterAllClosedAtThisLevel=new ke,this._afterOpenedAtThisLevel=new ke,this._idPrefix="mat-dialog-",this.afterAllClosed=Qa(()=>this.openDialogs.length?this._getAfterAllClosed():this._getAfterAllClosed().pipe(zn(void 0))),this._scrollStrategy=a,this._dialog=i.get(LH)}get openDialogs(){return this._parentDialog?this._parentDialog.openDialogs:this._openDialogsAtThisLevel}get afterOpened(){return this._parentDialog?this._parentDialog.afterOpened:this._afterOpenedAtThisLevel}_getAfterAllClosed(){let e=this._parentDialog;return e?e._getAfterAllClosed():this._afterAllClosedAtThisLevel}open(e,i){let r;(i={...this._defaultOptions||new Fv,...i}).id=i.id||`${this._idPrefix}${eke++}`,i.scrollStrategy=i.scrollStrategy||this._scrollStrategy();let o=this._dialog.open(e,{...i,positionStrategy:this._overlay.position().global().centerHorizontally().centerVertically(),disableClose:!0,closeOnDestroy:!1,container:{type:this._dialogContainerType,providers:()=>[{provide:Fv,useValue:i},{provide:og,useValue:i}]},templateContext:()=>({dialogRef:r}),providers:(s,a,l)=>(r=new this._dialogRefConstructor(s,i,l),r.updatePosition(i?.position),[{provide:this._dialogContainerType,useValue:l},{provide:this._dialogDataToken,useValue:a.data},{provide:this._dialogRefConstructor,useValue:r}])});return r.componentInstance=o.componentInstance,this.openDialogs.push(r),this.afterOpened.next(r),r.afterClosed().subscribe(()=>{let s=this.openDialogs.indexOf(r);s>-1&&(this.openDialogs.splice(s,1),this.openDialogs.length||this._getAfterAllClosed().next())}),r}closeAll(){this._closeDialogs(this.openDialogs)}getDialogById(e){return this.openDialogs.find(i=>i.id===e)}ngOnDestroy(){this._closeDialogs(this._openDialogsAtThisLevel),this._afterAllClosedAtThisLevel.complete(),this._afterOpenedAtThisLevel.complete()}_closeDialogs(e){let i=e.length;for(;i--;)e[i].close()}}return n.\u0275fac=function(e){nl()},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),vl=(()=>{class n extends tke{constructor(e,i,r,o,s,a,l,c){super(e,i,o,a,l,s,tu,KOe,cw,c)}}return n.\u0275fac=function(e){return new(e||n)(j(tr),j(Xn),j(iM,8),j(ZOe,8),j(kte),j(n,12),j(Rv),j(Pi,8))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),nke=0,T2=(()=>{class n{constructor(e,i,r){this.dialogRef=e,this._elementRef=i,this._dialog=r,this.type="button"}ngOnInit(){this.dialogRef||(this.dialogRef=Nte(this._elementRef,this._dialog.openDialogs))}ngOnChanges(e){let i=e._matDialogClose||e._matDialogCloseResult;i&&(this.dialogResult=i.currentValue)}_onButtonClick(e){Ote(this.dialogRef,0===e.screenX&&0===e.screenY?"keyboard":"mouse",this.dialogResult)}}return n.\u0275fac=function(e){return new(e||n)(M(tu,8),M(Re),M(vl))},n.\u0275dir=He({type:n,selectors:[["","mat-dialog-close",""],["","matDialogClose",""]],hostVars:2,hostBindings:function(e,i){1&e&&P("click",function(o){return i._onButtonClick(o)}),2&e&&ze("aria-label",i.ariaLabel||null)("type",i.type)},inputs:{ariaLabel:["aria-label","ariaLabel"],type:"type",dialogResult:["mat-dialog-close","dialogResult"],_matDialogClose:["matDialogClose","_matDialogClose"]},exportAs:["matDialogClose"],features:[Ft]}),n})(),Fte=(()=>{class n{constructor(e,i,r){this._dialogRef=e,this._elementRef=i,this._dialog=r,this.id="mat-dialog-title-"+nke++}ngOnInit(){this._dialogRef||(this._dialogRef=Nte(this._elementRef,this._dialog.openDialogs)),this._dialogRef&&Promise.resolve().then(()=>{let e=this._dialogRef._containerInstance;e&&!e._ariaLabelledBy&&(e._ariaLabelledBy=this.id)})}}return n.\u0275fac=function(e){return new(e||n)(M(tu,8),M(Re),M(vl))},n.\u0275dir=He({type:n,selectors:[["","mat-dialog-title",""],["","matDialogTitle",""]],hostAttrs:[1,"mat-dialog-title"],hostVars:1,hostBindings:function(e,i){2&e&&_s("id",i.id)},inputs:{id:"id"},exportAs:["matDialogTitle"]}),n})(),D2=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=He({type:n,selectors:[["","mat-dialog-content",""],["mat-dialog-content"],["","matDialogContent",""]],hostAttrs:[1,"mat-dialog-content"]}),n})(),A2=(()=>{class n{constructor(){this.align="start"}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=He({type:n,selectors:[["","mat-dialog-actions",""],["mat-dialog-actions"],["","matDialogActions",""]],hostAttrs:[1,"mat-dialog-actions"],hostVars:4,hostBindings:function(e,i){2&e&&et("mat-dialog-actions-align-center","center"===i.align)("mat-dialog-actions-align-end","end"===i.align)},inputs:{align:"align"}}),n})();function Nte(n,t){let e=n.nativeElement.parentElement;for(;e&&!e.classList.contains("mat-dialog-container");)e=e.parentElement;return e?t.find(i=>i.id===e.id):null}var Oh=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[vl,$Oe],imports:[Rte,ss,eu,ln,ln]}),n})(),ike=["connectionContainer"],rke=["inputContainer"],oke=["label"];function ske(n,t){1&n&&(sn(0),_(1,"div",14),O(2,"div",15)(3,"div",16)(4,"div",17),v(),_(5,"div",18),O(6,"div",15)(7,"div",16)(8,"div",17),v(),an())}function ake(n,t){if(1&n){let e=Pe();_(0,"div",19),P("cdkObserveContent",function(){return oe(e),se(S().updateOutlineGap())}),Vn(1,1),v()}2&n&&y("cdkObserveContentDisabled","outline"!=S().appearance)}function lke(n,t){if(1&n&&(sn(0),Vn(1,2),_(2,"span"),A(3),v(),an()),2&n){let e=S(2);C(3),yt(e._control.placeholder)}}function cke(n,t){1&n&&Vn(0,3,["*ngSwitchCase","true"])}function uke(n,t){1&n&&(_(0,"span",23),A(1," *"),v())}function dke(n,t){if(1&n){let e=Pe();_(0,"label",20,21),P("cdkObserveContent",function(){return oe(e),se(S().updateOutlineGap())}),E(2,lke,4,1,"ng-container",12),E(3,cke,1,0,"ng-content",12),E(4,uke,2,0,"span",22),v()}if(2&n){let e=S();et("mat-empty",e._control.empty&&!e._shouldAlwaysFloat())("mat-form-field-empty",e._control.empty&&!e._shouldAlwaysFloat())("mat-accent","accent"==e.color)("mat-warn","warn"==e.color),y("cdkObserveContentDisabled","outline"!=e.appearance)("id",e._labelId)("ngSwitch",e._hasLabel()),ze("for",e._control.id)("aria-owns",e._control.id),C(2),y("ngSwitchCase",!1),C(1),y("ngSwitchCase",!0),C(1),y("ngIf",!e.hideRequiredMarker&&e._control.required&&!e._control.disabled)}}function pke(n,t){1&n&&(_(0,"div",24),Vn(1,4),v())}function hke(n,t){if(1&n&&(_(0,"div",25),O(1,"span",26),v()),2&n){let e=S();C(1),et("mat-accent","accent"==e.color)("mat-warn","warn"==e.color)}}function fke(n,t){1&n&&(_(0,"div"),Vn(1,5),v()),2&n&&y("@transitionMessages",S()._subscriptAnimationState)}function mke(n,t){if(1&n&&(_(0,"div",30),A(1),v()),2&n){let e=S(2);y("id",e._hintLabelId),C(1),yt(e.hintLabel)}}function gke(n,t){if(1&n&&(_(0,"div",27),E(1,mke,2,2,"div",28),Vn(2,6),O(3,"div",29),Vn(4,7),v()),2&n){let e=S();y("@transitionMessages",e._subscriptAnimationState),C(1),y("ngIf",e.hintLabel)}}var _ke=["*",[["","matPrefix",""]],[["mat-placeholder"]],[["mat-label"]],[["","matSuffix",""]],[["mat-error"]],[["mat-hint",3,"align","end"]],[["mat-hint","align","end"]]],vke=["*","[matPrefix]","mat-placeholder","mat-label","[matSuffix]","mat-error","mat-hint:not([align='end'])","mat-hint[align='end']"],yke=0,Vte=new pe("MatError"),Hte=(()=>{class n{constructor(e,i){this.id="mat-error-"+yke++,e||i.nativeElement.setAttribute("aria-live","polite")}}return n.\u0275fac=function(e){return new(e||n)(vo("aria-live"),M(Re))},n.\u0275dir=He({type:n,selectors:[["mat-error"]],hostAttrs:["aria-atomic","true",1,"mat-error"],hostVars:1,hostBindings:function(e,i){2&e&&ze("id",i.id)},inputs:{id:"id"},features:[$t([{provide:Vte,useExisting:n}])]}),n})(),bke={transitionMessages:Kr("transitionMessages",[ki("enter",gn({opacity:1,transform:"translateY(0%)"})),Li("void => enter",[gn({opacity:0,transform:"translateY(-5px)"}),ji("300ms cubic-bezier(0.55, 0, 0.55, 0.2)")])])},kh=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=He({type:n}),n})(),xke=new pe("MatHint"),Nv=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=He({type:n,selectors:[["mat-label"]]}),n})(),Cke=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=He({type:n,selectors:[["mat-placeholder"]]}),n})(),Mke=new pe("MatPrefix"),wke=new pe("MatSuffix"),Lte=0,Eke=ko(class{constructor(n){this._elementRef=n}},"primary"),Tke=new pe("MAT_FORM_FIELD_DEFAULT_OPTIONS"),sg=new pe("MatFormField"),pd=(()=>{class n extends Eke{constructor(e,i,r,o,s,a,l){super(e),this._changeDetectorRef=i,this._dir=r,this._defaults=o,this._platform=s,this._ngZone=a,this._outlineGapCalculationNeededImmediately=!1,this._outlineGapCalculationNeededOnStable=!1,this._destroyed=new ke,this._hideRequiredMarker=!1,this._showAlwaysAnimate=!1,this._subscriptAnimationState="",this._hintLabel="",this._hintLabelId="mat-hint-"+Lte++,this._labelId="mat-form-field-label-"+Lte++,this.floatLabel=this._getDefaultFloatLabelState(),this._animationsEnabled="NoopAnimations"!==l,this.appearance=o?.appearance||"legacy",o&&(this._hideRequiredMarker=Boolean(o.hideRequiredMarker),o.color&&(this.color=this.defaultColor=o.color))}get appearance(){return this._appearance}set appearance(e){let i=this._appearance;this._appearance=e||this._defaults?.appearance||"legacy","outline"===this._appearance&&i!==e&&(this._outlineGapCalculationNeededOnStable=!0)}get hideRequiredMarker(){return this._hideRequiredMarker}set hideRequiredMarker(e){this._hideRequiredMarker=Rt(e)}_shouldAlwaysFloat(){return"always"===this.floatLabel&&!this._showAlwaysAnimate}_canLabelFloat(){return"never"!==this.floatLabel}get hintLabel(){return this._hintLabel}set hintLabel(e){this._hintLabel=e,this._processHints()}get floatLabel(){return"legacy"!==this.appearance&&"never"===this._floatLabel?"auto":this._floatLabel}set floatLabel(e){e!==this._floatLabel&&(this._floatLabel=e||this._getDefaultFloatLabelState(),this._changeDetectorRef.markForCheck())}get _control(){return this._explicitFormFieldControl||this._controlNonStatic||this._controlStatic}set _control(e){this._explicitFormFieldControl=e}getLabelId(){return this._hasFloatingLabel()?this._labelId:null}getConnectedOverlayOrigin(){return this._connectionContainerRef||this._elementRef}ngAfterContentInit(){this._validateControlChild();let e=this._control;e.controlType&&this._elementRef.nativeElement.classList.add(`mat-form-field-type-${e.controlType}`),e.stateChanges.pipe(zn(null)).subscribe(()=>{this._validatePlaceholders(),this._syncDescribedByIds(),this._changeDetectorRef.markForCheck()}),e.ngControl&&e.ngControl.valueChanges&&e.ngControl.valueChanges.pipe(st(this._destroyed)).subscribe(()=>this._changeDetectorRef.markForCheck()),this._ngZone.runOutsideAngular(()=>{this._ngZone.onStable.pipe(st(this._destroyed)).subscribe(()=>{this._outlineGapCalculationNeededOnStable&&this.updateOutlineGap()})}),Jt(this._prefixChildren.changes,this._suffixChildren.changes).subscribe(()=>{this._outlineGapCalculationNeededOnStable=!0,this._changeDetectorRef.markForCheck()}),this._hintChildren.changes.pipe(zn(null)).subscribe(()=>{this._processHints(),this._changeDetectorRef.markForCheck()}),this._errorChildren.changes.pipe(zn(null)).subscribe(()=>{this._syncDescribedByIds(),this._changeDetectorRef.markForCheck()}),this._dir&&this._dir.change.pipe(st(this._destroyed)).subscribe(()=>{"function"==typeof requestAnimationFrame?this._ngZone.runOutsideAngular(()=>{requestAnimationFrame(()=>this.updateOutlineGap())}):this.updateOutlineGap()})}ngAfterContentChecked(){this._validateControlChild(),this._outlineGapCalculationNeededImmediately&&this.updateOutlineGap()}ngAfterViewInit(){this._subscriptAnimationState="enter",this._changeDetectorRef.detectChanges()}ngOnDestroy(){this._destroyed.next(),this._destroyed.complete()}_shouldForward(e){let i=this._control?this._control.ngControl:null;return i&&i[e]}_hasPlaceholder(){return!!(this._control&&this._control.placeholder||this._placeholderChild)}_hasLabel(){return!(!this._labelChildNonStatic&&!this._labelChildStatic)}_shouldLabelFloat(){return this._canLabelFloat()&&(this._control&&this._control.shouldLabelFloat||this._shouldAlwaysFloat())}_hideControlPlaceholder(){return"legacy"===this.appearance&&!this._hasLabel()||this._hasLabel()&&!this._shouldLabelFloat()}_hasFloatingLabel(){return this._hasLabel()||"legacy"===this.appearance&&this._hasPlaceholder()}_getDisplayedMessages(){return this._errorChildren&&this._errorChildren.length>0&&this._control.errorState?"error":"hint"}_animateAndLockLabel(){this._hasFloatingLabel()&&this._canLabelFloat()&&(this._animationsEnabled&&this._label&&(this._showAlwaysAnimate=!0,_i(this._label.nativeElement,"transitionend").pipe(Qt(1)).subscribe(()=>{this._showAlwaysAnimate=!1})),this.floatLabel="always",this._changeDetectorRef.markForCheck())}_validatePlaceholders(){}_processHints(){this._validateHints(),this._syncDescribedByIds()}_validateHints(){}_getDefaultFloatLabelState(){return this._defaults&&this._defaults.floatLabel||"auto"}_syncDescribedByIds(){if(this._control){let e=[];if(this._control.userAriaDescribedBy&&"string"==typeof this._control.userAriaDescribedBy&&e.push(...this._control.userAriaDescribedBy.split(" ")),"hint"===this._getDisplayedMessages()){let i=this._hintChildren?this._hintChildren.find(o=>"start"===o.align):null,r=this._hintChildren?this._hintChildren.find(o=>"end"===o.align):null;i?e.push(i.id):this._hintLabel&&e.push(this._hintLabelId),r&&e.push(r.id)}else this._errorChildren&&e.push(...this._errorChildren.map(i=>i.id));this._control.setDescribedByIds(e)}}_validateControlChild(){}updateOutlineGap(){let e=this._label?this._label.nativeElement:null,i=this._connectionContainerRef.nativeElement,r=".mat-form-field-outline-start",o=".mat-form-field-outline-gap";if("outline"!==this.appearance||!this._platform.isBrowser)return;if(!e||!e.children.length||!e.textContent.trim()){let u=i.querySelectorAll(`${r}, ${o}`);for(let d=0;d<u.length;d++)u[d].style.width="0";return}if(!this._isAttachedToDOM())return void(this._outlineGapCalculationNeededImmediately=!0);let s=0,a=0,l=i.querySelectorAll(r),c=i.querySelectorAll(o);if(this._label&&this._label.nativeElement.children.length){let u=i.getBoundingClientRect();if(0===u.width&&0===u.height)return this._outlineGapCalculationNeededOnStable=!0,void(this._outlineGapCalculationNeededImmediately=!1);let d=this._getStartEnd(u),p=e.children,h=this._getStartEnd(p[0].getBoundingClientRect()),f=0;for(let m=0;m<p.length;m++)f+=p[m].offsetWidth;s=Math.abs(h-d)-5,a=f>0?.75*f+10:0}for(let u=0;u<l.length;u++)l[u].style.width=`${s}px`;for(let u=0;u<c.length;u++)c[u].style.width=`${a}px`;this._outlineGapCalculationNeededOnStable=this._outlineGapCalculationNeededImmediately=!1}_getStartEnd(e){return this._dir&&"rtl"===this._dir.value?e.right:e.left}_isAttachedToDOM(){let e=this._elementRef.nativeElement;if(e.getRootNode){let i=e.getRootNode();return i&&i!==e}return document.documentElement.contains(e)}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(nn),M($i,8),M(Tke,8),M(oi),M(_t),M(Pi,8))},n.\u0275cmp=R({type:n,selectors:[["mat-form-field"]],contentQueries:function(e,i,r){if(1&e&&(Ei(r,kh,5),Ei(r,kh,7),Ei(r,Nv,5),Ei(r,Nv,7),Ei(r,Cke,5),Ei(r,Vte,5),Ei(r,xke,5),Ei(r,Mke,5),Ei(r,wke,5)),2&e){let o;Ne(o=Le())&&(i._controlNonStatic=o.first),Ne(o=Le())&&(i._controlStatic=o.first),Ne(o=Le())&&(i._labelChildNonStatic=o.first),Ne(o=Le())&&(i._labelChildStatic=o.first),Ne(o=Le())&&(i._placeholderChild=o.first),Ne(o=Le())&&(i._errorChildren=o),Ne(o=Le())&&(i._hintChildren=o),Ne(o=Le())&&(i._prefixChildren=o),Ne(o=Le())&&(i._suffixChildren=o)}},viewQuery:function(e,i){if(1&e&&(ot(ike,7),ot(rke,5),ot(oke,5)),2&e){let r;Ne(r=Le())&&(i._connectionContainerRef=r.first),Ne(r=Le())&&(i._inputContainerRef=r.first),Ne(r=Le())&&(i._label=r.first)}},hostAttrs:[1,"mat-form-field"],hostVars:40,hostBindings:function(e,i){2&e&&et("mat-form-field-appearance-standard","standard"==i.appearance)("mat-form-field-appearance-fill","fill"==i.appearance)("mat-form-field-appearance-outline","outline"==i.appearance)("mat-form-field-appearance-legacy","legacy"==i.appearance)("mat-form-field-invalid",i._control.errorState)("mat-form-field-can-float",i._canLabelFloat())("mat-form-field-should-float",i._shouldLabelFloat())("mat-form-field-has-label",i._hasFloatingLabel())("mat-form-field-hide-placeholder",i._hideControlPlaceholder())("mat-form-field-disabled",i._control.disabled)("mat-form-field-autofilled",i._control.autofilled)("mat-focused",i._control.focused)("ng-untouched",i._shouldForward("untouched"))("ng-touched",i._shouldForward("touched"))("ng-pristine",i._shouldForward("pristine"))("ng-dirty",i._shouldForward("dirty"))("ng-valid",i._shouldForward("valid"))("ng-invalid",i._shouldForward("invalid"))("ng-pending",i._shouldForward("pending"))("_mat-animation-noopable",!i._animationsEnabled)},inputs:{color:"color",appearance:"appearance",hideRequiredMarker:"hideRequiredMarker",hintLabel:"hintLabel",floatLabel:"floatLabel"},exportAs:["matFormField"],features:[$t([{provide:sg,useExisting:n}]),tt],ngContentSelectors:vke,decls:15,vars:8,consts:[[1,"mat-form-field-wrapper"],[1,"mat-form-field-flex",3,"click"],["connectionContainer",""],[4,"ngIf"],["class","mat-form-field-prefix",3,"cdkObserveContentDisabled","cdkObserveContent",4,"ngIf"],[1,"mat-form-field-infix"],["inputContainer",""],[1,"mat-form-field-label-wrapper"],["class","mat-form-field-label",3,"cdkObserveContentDisabled","id","mat-empty","mat-form-field-empty","mat-accent","mat-warn","ngSwitch","cdkObserveContent",4,"ngIf"],["class","mat-form-field-suffix",4,"ngIf"],["class","mat-form-field-underline",4,"ngIf"],[1,"mat-form-field-subscript-wrapper",3,"ngSwitch"],[4,"ngSwitchCase"],["class","mat-form-field-hint-wrapper",4,"ngSwitchCase"],[1,"mat-form-field-outline"],[1,"mat-form-field-outline-start"],[1,"mat-form-field-outline-gap"],[1,"mat-form-field-outline-end"],[1,"mat-form-field-outline","mat-form-field-outline-thick"],[1,"mat-form-field-prefix",3,"cdkObserveContentDisabled","cdkObserveContent"],[1,"mat-form-field-label",3,"cdkObserveContentDisabled","id","ngSwitch","cdkObserveContent"],["label",""],["class","mat-placeholder-required mat-form-field-required-marker","aria-hidden","true",4,"ngIf"],["aria-hidden","true",1,"mat-placeholder-required","mat-form-field-required-marker"],[1,"mat-form-field-suffix"],[1,"mat-form-field-underline"],[1,"mat-form-field-ripple"],[1,"mat-form-field-hint-wrapper"],["class","mat-hint",3,"id",4,"ngIf"],[1,"mat-form-field-hint-spacer"],[1,"mat-hint",3,"id"]],template:function(e,i){1&e&&(xi(_ke),_(0,"div",0)(1,"div",1,2),P("click",function(o){return i._control.onContainerClick&&i._control.onContainerClick(o)}),E(3,ske,9,0,"ng-container",3),E(4,ake,2,1,"div",4),_(5,"div",5,6),Vn(7),_(8,"span",7),E(9,dke,5,16,"label",8),v()(),E(10,pke,2,0,"div",9),v(),E(11,hke,2,4,"div",10),_(12,"div",11),E(13,fke,2,1,"div",12),E(14,gke,5,2,"div",13),v()()),2&e&&(C(3),y("ngIf","outline"==i.appearance),C(1),y("ngIf",i._prefixChildren.length),C(5),y("ngIf",i._hasFloatingLabel()),C(1),y("ngIf",i._suffixChildren.length),C(1),y("ngIf","outline"!=i.appearance),C(1),y("ngSwitch",i._getDisplayedMessages()),C(1),y("ngSwitchCase","error"),C(1),y("ngSwitchCase","hint"))},dependencies:[Be,Cr,Ur,wh],styles:[".mat-form-field{display:inline-block;position:relative;text-align:left}[dir=rtl] .mat-form-field{text-align:right}.mat-form-field-wrapper{position:relative}.mat-form-field-flex{display:inline-flex;align-items:baseline;box-sizing:border-box;width:100%}.mat-form-field-prefix,.mat-form-field-suffix{white-space:nowrap;flex:none;position:relative}.mat-form-field-infix{display:block;position:relative;flex:auto;min-width:0;width:180px}.cdk-high-contrast-active .mat-form-field-infix{border-image:linear-gradient(transparent, transparent)}.mat-form-field-label-wrapper{position:absolute;left:0;box-sizing:content-box;width:100%;height:100%;overflow:hidden;pointer-events:none}[dir=rtl] .mat-form-field-label-wrapper{left:auto;right:0}.mat-form-field-label{position:absolute;left:0;font:inherit;pointer-events:none;width:100%;white-space:nowrap;text-overflow:ellipsis;overflow:hidden;transform-origin:0 0;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),color 400ms cubic-bezier(0.25, 0.8, 0.25, 1),width 400ms cubic-bezier(0.25, 0.8, 0.25, 1);display:none}[dir=rtl] .mat-form-field-label{transform-origin:100% 0;left:auto;right:0}.cdk-high-contrast-active .mat-form-field-disabled .mat-form-field-label{color:GrayText}.mat-form-field-empty.mat-form-field-label,.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label{display:block}.mat-form-field-autofill-control:-webkit-autofill+.mat-form-field-label-wrapper .mat-form-field-label{display:none}.mat-form-field-can-float .mat-form-field-autofill-control:-webkit-autofill+.mat-form-field-label-wrapper .mat-form-field-label{display:block;transition:none}.mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label,.mat-input-server[placeholder]:not(:placeholder-shown)+.mat-form-field-label-wrapper .mat-form-field-label{display:none}.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label,.mat-form-field-can-float .mat-input-server[placeholder]:not(:placeholder-shown)+.mat-form-field-label-wrapper .mat-form-field-label{display:block}.mat-form-field-label:not(.mat-form-field-empty){transition:none}.mat-form-field-underline{position:absolute;width:100%;pointer-events:none;transform:scale3d(1, 1.0001, 1)}.mat-form-field-ripple{position:absolute;left:0;width:100%;transform-origin:50%;transform:scaleX(0.5);opacity:0;transition:background-color 300ms cubic-bezier(0.55, 0, 0.55, 0.2)}.mat-form-field.mat-focused .mat-form-field-ripple,.mat-form-field.mat-form-field-invalid .mat-form-field-ripple{opacity:1;transform:none;transition:transform 300ms cubic-bezier(0.25, 0.8, 0.25, 1),opacity 100ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 300ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-subscript-wrapper{position:absolute;box-sizing:border-box;width:100%;overflow:hidden}.mat-form-field-subscript-wrapper .mat-icon,.mat-form-field-label-wrapper .mat-icon{width:1em;height:1em;font-size:inherit;vertical-align:baseline}.mat-form-field-hint-wrapper{display:flex}.mat-form-field-hint-spacer{flex:1 0 1em}.mat-error{display:block}.mat-form-field-control-wrapper{position:relative}.mat-form-field-hint-end{order:1}.mat-form-field._mat-animation-noopable .mat-form-field-label,.mat-form-field._mat-animation-noopable .mat-form-field-ripple{transition:none}",'.mat-form-field-appearance-fill .mat-form-field-flex{border-radius:4px 4px 0 0;padding:.75em .75em 0 .75em}.cdk-high-contrast-active .mat-form-field-appearance-fill .mat-form-field-flex{outline:solid 1px}.cdk-high-contrast-active .mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-flex{outline-color:GrayText}.cdk-high-contrast-active .mat-form-field-appearance-fill.mat-focused .mat-form-field-flex{outline:dashed 3px}.mat-form-field-appearance-fill .mat-form-field-underline::before{content:"";display:block;position:absolute;bottom:0;height:1px;width:100%}.mat-form-field-appearance-fill .mat-form-field-ripple{bottom:0;height:2px}.cdk-high-contrast-active .mat-form-field-appearance-fill .mat-form-field-ripple{height:0}.mat-form-field-appearance-fill:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-underline .mat-form-field-ripple{opacity:1;transform:none;transition:opacity 600ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-appearance-fill._mat-animation-noopable:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-underline .mat-form-field-ripple{transition:none}.mat-form-field-appearance-fill .mat-form-field-subscript-wrapper{padding:0 1em}','.mat-input-element{font:inherit;background:rgba(0,0,0,0);color:currentColor;border:none;outline:none;padding:0;margin:0;width:100%;max-width:100%;vertical-align:bottom;text-align:inherit;box-sizing:content-box}.mat-input-element:-moz-ui-invalid{box-shadow:none}.mat-input-element,.mat-input-element::-webkit-search-cancel-button,.mat-input-element::-webkit-search-decoration,.mat-input-element::-webkit-search-results-button,.mat-input-element::-webkit-search-results-decoration{-webkit-appearance:none}.mat-input-element::-webkit-contacts-auto-fill-button,.mat-input-element::-webkit-caps-lock-indicator,.mat-input-element:not([type=password])::-webkit-credentials-auto-fill-button{visibility:hidden}.mat-input-element[type=date],.mat-input-element[type=datetime],.mat-input-element[type=datetime-local],.mat-input-element[type=month],.mat-input-element[type=week],.mat-input-element[type=time]{line-height:1}.mat-input-element[type=date]::after,.mat-input-element[type=datetime]::after,.mat-input-element[type=datetime-local]::after,.mat-input-element[type=month]::after,.mat-input-element[type=week]::after,.mat-input-element[type=time]::after{content:" ";white-space:pre;width:1px}.mat-input-element::-webkit-inner-spin-button,.mat-input-element::-webkit-calendar-picker-indicator,.mat-input-element::-webkit-clear-button{font-size:.75em}.mat-input-element::placeholder{-webkit-user-select:none;user-select:none;transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-input-element::-moz-placeholder{-webkit-user-select:none;user-select:none;transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-input-element::-webkit-input-placeholder{-webkit-user-select:none;user-select:none;transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-input-element:-ms-input-placeholder{-webkit-user-select:none;user-select:none;transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-hide-placeholder .mat-input-element::placeholder{color:rgba(0,0,0,0) !important;-webkit-text-fill-color:rgba(0,0,0,0);transition:none}.cdk-high-contrast-active .mat-form-field-hide-placeholder .mat-input-element::placeholder{opacity:0}.mat-form-field-hide-placeholder .mat-input-element::-moz-placeholder{color:rgba(0,0,0,0) !important;-webkit-text-fill-color:rgba(0,0,0,0);transition:none}.cdk-high-contrast-active .mat-form-field-hide-placeholder .mat-input-element::-moz-placeholder{opacity:0}.mat-form-field-hide-placeholder .mat-input-element::-webkit-input-placeholder{color:rgba(0,0,0,0) !important;-webkit-text-fill-color:rgba(0,0,0,0);transition:none}.cdk-high-contrast-active .mat-form-field-hide-placeholder .mat-input-element::-webkit-input-placeholder{opacity:0}.mat-form-field-hide-placeholder .mat-input-element:-ms-input-placeholder{color:rgba(0,0,0,0) !important;-webkit-text-fill-color:rgba(0,0,0,0);transition:none}.cdk-high-contrast-active .mat-form-field-hide-placeholder .mat-input-element:-ms-input-placeholder{opacity:0}._mat-animation-noopable .mat-input-element::placeholder{transition:none}._mat-animation-noopable .mat-input-element::-moz-placeholder{transition:none}._mat-animation-noopable .mat-input-element::-webkit-input-placeholder{transition:none}._mat-animation-noopable .mat-input-element:-ms-input-placeholder{transition:none}textarea.mat-input-element{resize:vertical;overflow:auto}textarea.mat-input-element.cdk-textarea-autosize{resize:none}textarea.mat-input-element{padding:2px 0;margin:-2px 0}select.mat-input-element{-moz-appearance:none;-webkit-appearance:none;position:relative;background-color:rgba(0,0,0,0);display:inline-flex;box-sizing:border-box;padding-top:1em;top:-1em;margin-bottom:-1em}select.mat-input-element::-moz-focus-inner{border:0}select.mat-input-element:not(:disabled){cursor:pointer}.mat-form-field-type-mat-native-select .mat-form-field-infix::after{content:"";width:0;height:0;border-left:5px solid rgba(0,0,0,0);border-right:5px solid rgba(0,0,0,0);border-top:5px solid;position:absolute;top:50%;right:0;margin-top:-2.5px;pointer-events:none}[dir=rtl] .mat-form-field-type-mat-native-select .mat-form-field-infix::after{right:auto;left:0}.mat-form-field-type-mat-native-select .mat-input-element{padding-right:15px}[dir=rtl] .mat-form-field-type-mat-native-select .mat-input-element{padding-right:0;padding-left:15px}.mat-form-field-type-mat-native-select .mat-form-field-label-wrapper{max-width:calc(100% - 10px)}.mat-form-field-type-mat-native-select.mat-form-field-appearance-outline .mat-form-field-infix::after{margin-top:-5px}.mat-form-field-type-mat-native-select.mat-form-field-appearance-fill .mat-form-field-infix::after{margin-top:-10px}',".mat-form-field-appearance-legacy .mat-form-field-label{transform:perspective(100px)}.mat-form-field-appearance-legacy .mat-form-field-prefix .mat-icon,.mat-form-field-appearance-legacy .mat-form-field-suffix .mat-icon{width:1em}.mat-form-field-appearance-legacy .mat-form-field-prefix .mat-icon-button,.mat-form-field-appearance-legacy .mat-form-field-suffix .mat-icon-button{font:inherit;vertical-align:baseline}.mat-form-field-appearance-legacy .mat-form-field-prefix .mat-icon-button .mat-icon,.mat-form-field-appearance-legacy .mat-form-field-suffix .mat-icon-button .mat-icon{font-size:inherit}.mat-form-field-appearance-legacy .mat-form-field-underline{height:1px}.cdk-high-contrast-active .mat-form-field-appearance-legacy .mat-form-field-underline{height:0;border-top:solid 1px}.mat-form-field-appearance-legacy .mat-form-field-ripple{top:0;height:2px;overflow:hidden}.cdk-high-contrast-active .mat-form-field-appearance-legacy .mat-form-field-ripple{height:0;border-top:solid 2px}.mat-form-field-appearance-legacy.mat-form-field-disabled .mat-form-field-underline{background-position:0;background-color:rgba(0,0,0,0)}.cdk-high-contrast-active .mat-form-field-appearance-legacy.mat-form-field-disabled .mat-form-field-underline{border-top-style:dotted;border-top-width:2px;border-top-color:GrayText}.mat-form-field-appearance-legacy.mat-form-field-invalid:not(.mat-focused) .mat-form-field-ripple{height:1px}",".mat-form-field-appearance-outline .mat-form-field-wrapper{margin:.25em 0}.mat-form-field-appearance-outline .mat-form-field-flex{padding:0 .75em 0 .75em;margin-top:-0.25em;position:relative}.mat-form-field-appearance-outline .mat-form-field-prefix,.mat-form-field-appearance-outline .mat-form-field-suffix{top:.25em}.mat-form-field-appearance-outline .mat-form-field-outline{display:flex;position:absolute;top:.25em;left:0;right:0;bottom:0;pointer-events:none}.mat-form-field-appearance-outline .mat-form-field-outline-start,.mat-form-field-appearance-outline .mat-form-field-outline-end{border:1px solid currentColor;min-width:5px}.mat-form-field-appearance-outline .mat-form-field-outline-start{border-radius:5px 0 0 5px;border-right-style:none}[dir=rtl] .mat-form-field-appearance-outline .mat-form-field-outline-start{border-right-style:solid;border-left-style:none;border-radius:0 5px 5px 0}.mat-form-field-appearance-outline .mat-form-field-outline-end{border-radius:0 5px 5px 0;border-left-style:none;flex-grow:1}[dir=rtl] .mat-form-field-appearance-outline .mat-form-field-outline-end{border-left-style:solid;border-right-style:none;border-radius:5px 0 0 5px}.mat-form-field-appearance-outline .mat-form-field-outline-gap{border-radius:.000001px;border:1px solid currentColor;border-left-style:none;border-right-style:none}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-outline-gap{border-top-color:rgba(0,0,0,0)}.mat-form-field-appearance-outline .mat-form-field-outline-thick{opacity:0}.mat-form-field-appearance-outline .mat-form-field-outline-thick .mat-form-field-outline-start,.mat-form-field-appearance-outline .mat-form-field-outline-thick .mat-form-field-outline-end,.mat-form-field-appearance-outline .mat-form-field-outline-thick .mat-form-field-outline-gap{border-width:2px}.mat-form-field-appearance-outline.mat-focused .mat-form-field-outline,.mat-form-field-appearance-outline.mat-form-field-invalid .mat-form-field-outline{opacity:0;transition:opacity 100ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-appearance-outline.mat-focused .mat-form-field-outline-thick,.mat-form-field-appearance-outline.mat-form-field-invalid .mat-form-field-outline-thick{opacity:1}.cdk-high-contrast-active .mat-form-field-appearance-outline.mat-focused .mat-form-field-outline-thick{border:3px dashed}.mat-form-field-appearance-outline:not(.mat-form-field-disabled) .mat-form-field-flex:hover .mat-form-field-outline{opacity:0;transition:opacity 600ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-appearance-outline:not(.mat-form-field-disabled) .mat-form-field-flex:hover .mat-form-field-outline-thick{opacity:1}.mat-form-field-appearance-outline .mat-form-field-subscript-wrapper{padding:0 1em}.cdk-high-contrast-active .mat-form-field-appearance-outline.mat-form-field-disabled .mat-form-field-outline{color:GrayText}.mat-form-field-appearance-outline._mat-animation-noopable:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-outline,.mat-form-field-appearance-outline._mat-animation-noopable .mat-form-field-outline,.mat-form-field-appearance-outline._mat-animation-noopable .mat-form-field-outline-start,.mat-form-field-appearance-outline._mat-animation-noopable .mat-form-field-outline-end,.mat-form-field-appearance-outline._mat-animation-noopable .mat-form-field-outline-gap{transition:none}",".mat-form-field-appearance-standard .mat-form-field-flex{padding-top:.75em}.mat-form-field-appearance-standard .mat-form-field-underline{height:1px}.cdk-high-contrast-active .mat-form-field-appearance-standard .mat-form-field-underline{height:0;border-top:solid 1px}.mat-form-field-appearance-standard .mat-form-field-ripple{bottom:0;height:2px}.cdk-high-contrast-active .mat-form-field-appearance-standard .mat-form-field-ripple{height:0;border-top:solid 2px}.mat-form-field-appearance-standard.mat-form-field-disabled .mat-form-field-underline{background-position:0;background-color:rgba(0,0,0,0)}.cdk-high-contrast-active .mat-form-field-appearance-standard.mat-form-field-disabled .mat-form-field-underline{border-top-style:dotted;border-top-width:2px}.mat-form-field-appearance-standard:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-underline .mat-form-field-ripple{opacity:1;transform:none;transition:opacity 600ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-appearance-standard._mat-animation-noopable:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-underline .mat-form-field-ripple{transition:none}"],encapsulation:2,data:{animation:[bke.transitionMessages]},changeDetection:0}),n})(),ag=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,ln,od,ln]}),n})(),Kte=(()=>{class n{constructor(e,i){this._renderer=e,this._elementRef=i,this.onChange=r=>{},this.onTouched=()=>{}}setProperty(e,i){this._renderer.setProperty(this._elementRef.nativeElement,e,i)}registerOnTouched(e){this.onTouched=e}registerOnChange(e){this.onChange=e}setDisabledState(e){this.setProperty("disabled",e)}}return n.\u0275fac=function(e){return new(e||n)(M(Eu),M(Re))},n.\u0275dir=He({type:n}),n})(),lg=(()=>{class n extends Kte{}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275dir=He({type:n,features:[tt]}),n})(),No=new pe("NgValueAccessor"),Dke={provide:No,useExisting:Jn(()=>Ake),multi:!0},Ake=(()=>{class n extends lg{writeValue(e){this.setProperty("checked",e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275dir=He({type:n,selectors:[["input","type","checkbox","formControlName",""],["input","type","checkbox","formControl",""],["input","type","checkbox","ngModel",""]],hostBindings:function(e,i){1&e&&P("change",function(o){return i.onChange(o.target.checked)})("blur",function(){return i.onTouched()})},features:[$t([Dke]),tt]}),n})(),Ike={provide:No,useExisting:Jn(()=>Bv),multi:!0},Rke=new pe("CompositionEventMode"),Bv=(()=>{class n extends Kte{constructor(e,i,r){super(e,i),this._compositionMode=r,this._composing=!1,null==this._compositionMode&&(this._compositionMode=!function(){let n=Yl()?Yl().getUserAgent():"";return/android (\d+)/.test(n.toLowerCase())}())}writeValue(e){this.setProperty("value",e??"")}_handleInput(e){(!this._compositionMode||this._compositionMode&&!this._composing)&&this.onChange(e)}_compositionStart(){this._composing=!0}_compositionEnd(e){this._composing=!1,this._compositionMode&&this.onChange(e)}}return n.\u0275fac=function(e){return new(e||n)(M(Eu),M(Re),M(Rke,8))},n.\u0275dir=He({type:n,selectors:[["input","formControlName","",3,"type","checkbox"],["textarea","formControlName",""],["input","formControl","",3,"type","checkbox"],["textarea","formControl",""],["input","ngModel","",3,"type","checkbox"],["textarea","ngModel",""],["","ngDefaultControl",""]],hostBindings:function(e,i){1&e&&P("input",function(o){return i._handleInput(o.target.value)})("blur",function(){return i.onTouched()})("compositionstart",function(){return i._compositionStart()})("compositionend",function(o){return i._compositionEnd(o.target.value)})},features:[$t([Ike]),tt]}),n})();function Fh(n){return null==n||("string"==typeof n||Array.isArray(n))&&0===n.length}function Zte(n){return null!=n&&"number"==typeof n.length}var Lo=new pe("NgValidators"),Nh=new pe("NgAsyncValidators"),kke=/^(?=.{1,254}$)(?=.{1,64}@)[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/,Fo=class{static min(t){return Jte(t)}static max(t){return $te(t)}static required(t){return ene(t)}static requiredTrue(t){return tne(t)}static email(t){return nne(t)}static minLength(t){return ine(t)}static maxLength(t){return rne(t)}static pattern(t){return one(t)}static nullValidator(t){return null}static compose(t){return dne(t)}static composeAsync(t){return pne(t)}};function Jte(n){return t=>{if(Fh(t.value)||Fh(n))return null;let e=parseFloat(t.value);return!isNaN(e)&&e<n?{min:{min:n,actual:t.value}}:null}}function $te(n){return t=>{if(Fh(t.value)||Fh(n))return null;let e=parseFloat(t.value);return!isNaN(e)&&e>n?{max:{max:n,actual:t.value}}:null}}function ene(n){return Fh(n.value)?{required:!0}:null}function tne(n){return!0===n.value?null:{required:!0}}function nne(n){return Fh(n.value)||kke.test(n.value)?null:{email:!0}}function ine(n){return t=>Fh(t.value)||!Zte(t.value)?null:t.value.length<n?{minlength:{requiredLength:n,actualLength:t.value.length}}:null}function rne(n){return t=>Zte(t.value)&&t.value.length>n?{maxlength:{requiredLength:n,actualLength:t.value.length}}:null}function one(n){if(!n)return P2;let t,e;return"string"==typeof n?(e="","^"!==n.charAt(0)&&(e+="^"),e+=n,"$"!==n.charAt(n.length-1)&&(e+="$"),t=new RegExp(e)):(e=n.toString(),t=n),i=>{if(Fh(i.value))return null;let r=i.value;return t.test(r)?null:{pattern:{requiredPattern:e,actualValue:r}}}}function P2(n){return null}function sne(n){return null!=n}function ane(n){return n_(n)?Eo(n):n}function lne(n){let t={};return n.forEach(e=>{t=null!=e?{...t,...e}:t}),0===Object.keys(t).length?null:t}function cne(n,t){return t.map(e=>e(n))}function une(n){return n.map(t=>function(n){return!n.validate}(t)?t:e=>t.validate(e))}function dne(n){if(!n)return null;let t=n.filter(sne);return 0==t.length?null:function(e){return lne(cne(e,t))}}function UH(n){return null!=n?dne(une(n)):null}function pne(n){if(!n)return null;let t=n.filter(sne);return 0==t.length?null:function(e){return lr(cne(e,t).map(ane)).pipe(L(lne))}}function zH(n){return null!=n?pne(une(n)):null}function Ute(n,t){return null===n?[t]:Array.isArray(n)?[...n,t]:[n,t]}function hne(n){return n._rawValidators}function fne(n){return n._rawAsyncValidators}function BH(n){return n?Array.isArray(n)?n:[n]:[]}function R2(n,t){return Array.isArray(n)?n.includes(t):n===t}function zte(n,t){let e=BH(t);return BH(n).forEach(r=>{R2(e,r)||e.push(r)}),e}function jte(n,t){return BH(t).filter(e=>!R2(n,e))}var O2=class{constructor(){this._rawValidators=[],this._rawAsyncValidators=[],this._onDestroyCallbacks=[]}get value(){return this.control?this.control.value:null}get valid(){return this.control?this.control.valid:null}get invalid(){return this.control?this.control.invalid:null}get pending(){return this.control?this.control.pending:null}get disabled(){return this.control?this.control.disabled:null}get enabled(){return this.control?this.control.enabled:null}get errors(){return this.control?this.control.errors:null}get pristine(){return this.control?this.control.pristine:null}get dirty(){return this.control?this.control.dirty:null}get touched(){return this.control?this.control.touched:null}get status(){return this.control?this.control.status:null}get untouched(){return this.control?this.control.untouched:null}get statusChanges(){return this.control?this.control.statusChanges:null}get valueChanges(){return this.control?this.control.valueChanges:null}get path(){return null}_setValidators(t){this._rawValidators=t||[],this._composedValidatorFn=UH(this._rawValidators)}_setAsyncValidators(t){this._rawAsyncValidators=t||[],this._composedAsyncValidatorFn=zH(this._rawAsyncValidators)}get validator(){return this._composedValidatorFn||null}get asyncValidator(){return this._composedAsyncValidatorFn||null}_registerOnDestroy(t){this._onDestroyCallbacks.push(t)}_invokeOnDestroyCallbacks(){this._onDestroyCallbacks.forEach(t=>t()),this._onDestroyCallbacks=[]}reset(t){this.control&&this.control.reset(t)}hasError(t,e){return!!this.control&&this.control.hasError(t,e)}getError(t,e){return this.control?this.control.getError(t,e):null}},Fs=class extends O2{get formDirective(){return null}get path(){return null}},Ns=class extends O2{constructor(){super(...arguments),this._parent=null,this.name=null,this.valueAccessor=null}},VH=class{constructor(t){this._cd=t}get isTouched(){return!!this._cd?.control?.touched}get isUntouched(){return!!this._cd?.control?.untouched}get isPristine(){return!!this._cd?.control?.pristine}get isDirty(){return!!this._cd?.control?.dirty}get isValid(){return!!this._cd?.control?.valid}get isInvalid(){return!!this._cd?.control?.invalid}get isPending(){return!!this._cd?.control?.pending}get isSubmitted(){return!!this._cd?.submitted}},V2=(()=>{class n extends VH{constructor(e){super(e)}}return n.\u0275fac=function(e){return new(e||n)(M(Ns,2))},n.\u0275dir=He({type:n,selectors:[["","formControlName",""],["","ngModel",""],["","formControl",""]],hostVars:14,hostBindings:function(e,i){2&e&&et("ng-untouched",i.isUntouched)("ng-touched",i.isTouched)("ng-pristine",i.isPristine)("ng-dirty",i.isDirty)("ng-valid",i.isValid)("ng-invalid",i.isInvalid)("ng-pending",i.isPending)},features:[tt]}),n})(),dw="VALID",I2="INVALID",Lv="PENDING",pw="DISABLED";function gne(n){return(H2(n)?n.validators:n)||null}function Gte(n){return Array.isArray(n)?UH(n):n||null}function _ne(n,t){return(H2(t)?t.asyncValidators:n)||null}function Wte(n){return Array.isArray(n)?zH(n):n||null}function H2(n){return null!=n&&!Array.isArray(n)&&"object"==typeof n}var k2=class{constructor(t,e){this._pendingDirty=!1,this._hasOwnPendingAsyncValidator=!1,this._pendingTouched=!1,this._onCollectionChange=()=>{},this._parent=null,this.pristine=!0,this.touched=!1,this._onDisabledChange=[],this._rawValidators=t,this._rawAsyncValidators=e,this._composedValidatorFn=Gte(this._rawValidators),this._composedAsyncValidatorFn=Wte(this._rawAsyncValidators)}get validator(){return this._composedValidatorFn}set validator(t){this._rawValidators=this._composedValidatorFn=t}get asyncValidator(){return this._composedAsyncValidatorFn}set asyncValidator(t){this._rawAsyncValidators=this._composedAsyncValidatorFn=t}get parent(){return this._parent}get valid(){return this.status===dw}get invalid(){return this.status===I2}get pending(){return this.status==Lv}get disabled(){return this.status===pw}get enabled(){return this.status!==pw}get dirty(){return!this.pristine}get untouched(){return!this.touched}get updateOn(){return this._updateOn?this._updateOn:this.parent?this.parent.updateOn:"change"}setValidators(t){this._rawValidators=t,this._composedValidatorFn=Gte(t)}setAsyncValidators(t){this._rawAsyncValidators=t,this._composedAsyncValidatorFn=Wte(t)}addValidators(t){this.setValidators(zte(t,this._rawValidators))}addAsyncValidators(t){this.setAsyncValidators(zte(t,this._rawAsyncValidators))}removeValidators(t){this.setValidators(jte(t,this._rawValidators))}removeAsyncValidators(t){this.setAsyncValidators(jte(t,this._rawAsyncValidators))}hasValidator(t){return R2(this._rawValidators,t)}hasAsyncValidator(t){return R2(this._rawAsyncValidators,t)}clearValidators(){this.validator=null}clearAsyncValidators(){this.asyncValidator=null}markAsTouched(t={}){this.touched=!0,this._parent&&!t.onlySelf&&this._parent.markAsTouched(t)}markAllAsTouched(){this.markAsTouched({onlySelf:!0}),this._forEachChild(t=>t.markAllAsTouched())}markAsUntouched(t={}){this.touched=!1,this._pendingTouched=!1,this._forEachChild(e=>{e.markAsUntouched({onlySelf:!0})}),this._parent&&!t.onlySelf&&this._parent._updateTouched(t)}markAsDirty(t={}){this.pristine=!1,this._parent&&!t.onlySelf&&this._parent.markAsDirty(t)}markAsPristine(t={}){this.pristine=!0,this._pendingDirty=!1,this._forEachChild(e=>{e.markAsPristine({onlySelf:!0})}),this._parent&&!t.onlySelf&&this._parent._updatePristine(t)}markAsPending(t={}){this.status=Lv,!1!==t.emitEvent&&this.statusChanges.emit(this.status),this._parent&&!t.onlySelf&&this._parent.markAsPending(t)}disable(t={}){let e=this._parentMarkedDirty(t.onlySelf);this.status=pw,this.errors=null,this._forEachChild(i=>{i.disable({...t,onlySelf:!0})}),this._updateValue(),!1!==t.emitEvent&&(this.valueChanges.emit(this.value),this.statusChanges.emit(this.status)),this._updateAncestors({...t,skipPristineCheck:e}),this._onDisabledChange.forEach(i=>i(!0))}enable(t={}){let e=this._parentMarkedDirty(t.onlySelf);this.status=dw,this._forEachChild(i=>{i.enable({...t,onlySelf:!0})}),this.updateValueAndValidity({onlySelf:!0,emitEvent:t.emitEvent}),this._updateAncestors({...t,skipPristineCheck:e}),this._onDisabledChange.forEach(i=>i(!1))}_updateAncestors(t){this._parent&&!t.onlySelf&&(this._parent.updateValueAndValidity(t),t.skipPristineCheck||this._parent._updatePristine(),this._parent._updateTouched())}setParent(t){this._parent=t}getRawValue(){return this.value}updateValueAndValidity(t={}){this._setInitialStatus(),this._updateValue(),this.enabled&&(this._cancelExistingSubscription(),this.errors=this._runValidator(),this.status=this._calculateStatus(),(this.status===dw||this.status===Lv)&&this._runAsyncValidator(t.emitEvent)),!1!==t.emitEvent&&(this.valueChanges.emit(this.value),this.statusChanges.emit(this.status)),this._parent&&!t.onlySelf&&this._parent.updateValueAndValidity(t)}_updateTreeValidity(t={emitEvent:!0}){this._forEachChild(e=>e._updateTreeValidity(t)),this.updateValueAndValidity({onlySelf:!0,emitEvent:t.emitEvent})}_setInitialStatus(){this.status=this._allControlsDisabled()?pw:dw}_runValidator(){return this.validator?this.validator(this):null}_runAsyncValidator(t){if(this.asyncValidator){this.status=Lv,this._hasOwnPendingAsyncValidator=!0;let e=ane(this.asyncValidator(this));this._asyncValidationSubscription=e.subscribe(i=>{this._hasOwnPendingAsyncValidator=!1,this.setErrors(i,{emitEvent:t})})}}_cancelExistingSubscription(){this._asyncValidationSubscription&&(this._asyncValidationSubscription.unsubscribe(),this._hasOwnPendingAsyncValidator=!1)}setErrors(t,e={}){this.errors=t,this._updateControlsErrors(!1!==e.emitEvent)}get(t){let e=t;return null==e||(Array.isArray(e)||(e=e.split(".")),0===e.length)?null:e.reduce((i,r)=>i&&i._find(r),this)}getError(t,e){let i=e?this.get(e):this;return i&&i.errors?i.errors[t]:null}hasError(t,e){return!!this.getError(t,e)}get root(){let t=this;for(;t._parent;)t=t._parent;return t}_updateControlsErrors(t){this.status=this._calculateStatus(),t&&this.statusChanges.emit(this.status),this._parent&&this._parent._updateControlsErrors(t)}_initObservables(){this.valueChanges=new G,this.statusChanges=new G}_calculateStatus(){return this._allControlsDisabled()?pw:this.errors?I2:this._hasOwnPendingAsyncValidator||this._anyControlsHaveStatus(Lv)?Lv:this._anyControlsHaveStatus(I2)?I2:dw}_anyControlsHaveStatus(t){return this._anyControls(e=>e.status===t)}_anyControlsDirty(){return this._anyControls(t=>t.dirty)}_anyControlsTouched(){return this._anyControls(t=>t.touched)}_updatePristine(t={}){this.pristine=!this._anyControlsDirty(),this._parent&&!t.onlySelf&&this._parent._updatePristine(t)}_updateTouched(t={}){this.touched=this._anyControlsTouched(),this._parent&&!t.onlySelf&&this._parent._updateTouched(t)}_registerOnCollectionChange(t){this._onCollectionChange=t}_setUpdateStrategy(t){H2(t)&&null!=t.updateOn&&(this._updateOn=t.updateOn)}_parentMarkedDirty(t){return!t&&!(!this._parent||!this._parent.dirty)&&!this._parent._anyControlsDirty()}_find(t){return null}},F2=class extends k2{constructor(t,e,i){super(gne(e),_ne(i,e)),this.controls=t,this._initObservables(),this._setUpdateStrategy(e),this._setUpControls(),this.updateValueAndValidity({onlySelf:!0,emitEvent:!!this.asyncValidator})}registerControl(t,e){return this.controls[t]?this.controls[t]:(this.controls[t]=e,e.setParent(this),e._registerOnCollectionChange(this._onCollectionChange),e)}addControl(t,e,i={}){this.registerControl(t,e),this.updateValueAndValidity({emitEvent:i.emitEvent}),this._onCollectionChange()}removeControl(t,e={}){this.controls[t]&&this.controls[t]._registerOnCollectionChange(()=>{}),delete this.controls[t],this.updateValueAndValidity({emitEvent:e.emitEvent}),this._onCollectionChange()}setControl(t,e,i={}){this.controls[t]&&this.controls[t]._registerOnCollectionChange(()=>{}),delete this.controls[t],e&&this.registerControl(t,e),this.updateValueAndValidity({emitEvent:i.emitEvent}),this._onCollectionChange()}contains(t){return this.controls.hasOwnProperty(t)&&this.controls[t].enabled}setValue(t,e={}){(function(n,t,e){n._forEachChild((i,r)=>{if(void 0===e[r])throw new At(1002,"")})})(this,0,t),Object.keys(t).forEach(i=>{(function(n,t,e){let i=n.controls;if(!(t?Object.keys(i):i).length)throw new At(1e3,"");if(!i[e])throw new At(1001,"")})(this,!0,i),this.controls[i].setValue(t[i],{onlySelf:!0,emitEvent:e.emitEvent})}),this.updateValueAndValidity(e)}patchValue(t,e={}){null!=t&&(Object.keys(t).forEach(i=>{let r=this.controls[i];r&&r.patchValue(t[i],{onlySelf:!0,emitEvent:e.emitEvent})}),this.updateValueAndValidity(e))}reset(t={},e={}){this._forEachChild((i,r)=>{i.reset(t[r],{onlySelf:!0,emitEvent:e.emitEvent})}),this._updatePristine(e),this._updateTouched(e),this.updateValueAndValidity(e)}getRawValue(){return this._reduceChildren({},(t,e,i)=>(t[i]=e.getRawValue(),t))}_syncPendingControls(){let t=this._reduceChildren(!1,(e,i)=>!!i._syncPendingControls()||e);return t&&this.updateValueAndValidity({onlySelf:!0}),t}_forEachChild(t){Object.keys(this.controls).forEach(e=>{let i=this.controls[e];i&&t(i,e)})}_setUpControls(){this._forEachChild(t=>{t.setParent(this),t._registerOnCollectionChange(this._onCollectionChange)})}_updateValue(){this.value=this._reduceValue()}_anyControls(t){for(let[e,i]of Object.entries(this.controls))if(this.contains(e)&&t(i))return!0;return!1}_reduceValue(){return this._reduceChildren({},(e,i,r)=>((i.enabled||this.disabled)&&(e[r]=i.value),e))}_reduceChildren(t,e){let i=t;return this._forEachChild((r,o)=>{i=e(i,r,o)}),i}_allControlsDisabled(){for(let t of Object.keys(this.controls))if(this.controls[t].enabled)return!1;return Object.keys(this.controls).length>0||this.disabled}_find(t){return this.controls.hasOwnProperty(t)?this.controls[t]:null}};function U2(n,t){return[...t.path,n]}function fw(n,t){jH(n,t),t.valueAccessor.writeValue(n.value),n.disabled&&t.valueAccessor.setDisabledState?.(!0),function(n,t){t.valueAccessor.registerOnChange(e=>{n._pendingValue=e,n._pendingChange=!0,n._pendingDirty=!0,"change"===n.updateOn&&vne(n,t)})}(n,t),function(n,t){let e=(i,r)=>{t.valueAccessor.writeValue(i),r&&t.viewToModelUpdate(i)};n.registerOnChange(e),t._registerOnDestroy(()=>{n._unregisterOnChange(e)})}(n,t),function(n,t){t.valueAccessor.registerOnTouched(()=>{n._pendingTouched=!0,"blur"===n.updateOn&&n._pendingChange&&vne(n,t),"submit"!==n.updateOn&&n.markAsTouched()})}(n,t),function(n,t){if(t.valueAccessor.setDisabledState){let e=i=>{t.valueAccessor.setDisabledState(i)};n.registerOnDisabledChange(e),t._registerOnDestroy(()=>{n._unregisterOnDisabledChange(e)})}}(n,t)}function N2(n,t,e=!0){let i=()=>{};t.valueAccessor&&(t.valueAccessor.registerOnChange(i),t.valueAccessor.registerOnTouched(i)),B2(n,t),n&&(t._invokeOnDestroyCallbacks(),n._registerOnCollectionChange(()=>{}))}function L2(n,t){n.forEach(e=>{e.registerOnValidatorChange&&e.registerOnValidatorChange(t)})}function jH(n,t){let e=hne(n);null!==t.validator?n.setValidators(Ute(e,t.validator)):"function"==typeof e&&n.setValidators([e]);let i=fne(n);null!==t.asyncValidator?n.setAsyncValidators(Ute(i,t.asyncValidator)):"function"==typeof i&&n.setAsyncValidators([i]);let r=()=>n.updateValueAndValidity();L2(t._rawValidators,r),L2(t._rawAsyncValidators,r)}function B2(n,t){let e=!1;if(null!==n){if(null!==t.validator){let r=hne(n);if(Array.isArray(r)&&r.length>0){let o=r.filter(s=>s!==t.validator);o.length!==r.length&&(e=!0,n.setValidators(o))}}if(null!==t.asyncValidator){let r=fne(n);if(Array.isArray(r)&&r.length>0){let o=r.filter(s=>s!==t.asyncValidator);o.length!==r.length&&(e=!0,n.setAsyncValidators(o))}}}let i=()=>{};return L2(t._rawValidators,i),L2(t._rawAsyncValidators,i),e}function vne(n,t){n._pendingDirty&&n.markAsDirty(),n.setValue(n._pendingValue,{emitModelToViewChange:!1}),t.viewToModelUpdate(n._pendingValue),n._pendingChange=!1}function yne(n,t){jH(n,t)}function GH(n,t){if(!n.hasOwnProperty("model"))return!1;let e=n.model;return!!e.isFirstChange()||!Object.is(t,e.currentValue)}function bne(n,t){n._syncPendingControls(),t.forEach(e=>{let i=e.control;"submit"===i.updateOn&&i._pendingChange&&(e.viewToModelUpdate(i._pendingValue),i._pendingChange=!1)})}function WH(n,t){if(!t)return null;let e,i,r;return Array.isArray(t),t.forEach(o=>{o.constructor===Bv?e=o:function(n){return Object.getPrototypeOf(n.constructor)===lg}(o)?i=o:r=o}),r||i||e||null}var Qke={provide:Fs,useExisting:Jn(()=>Lh)},hw=Promise.resolve(),Lh=(()=>{class n extends Fs{constructor(e,i){super(),this.submitted=!1,this._directives=new Set,this.ngSubmit=new G,this.form=new F2({},UH(e),zH(i))}ngAfterViewInit(){this._setUpdateStrategy()}get formDirective(){return this}get control(){return this.form}get path(){return[]}get controls(){return this.form.controls}addControl(e){hw.then(()=>{let i=this._findContainer(e.path);e.control=i.registerControl(e.name,e.control),fw(e.control,e),e.control.updateValueAndValidity({emitEvent:!1}),this._directives.add(e)})}getControl(e){return this.form.get(e.path)}removeControl(e){hw.then(()=>{let i=this._findContainer(e.path);i&&i.removeControl(e.name),this._directives.delete(e)})}addFormGroup(e){hw.then(()=>{let i=this._findContainer(e.path),r=new F2({});yne(r,e),i.registerControl(e.name,r),r.updateValueAndValidity({emitEvent:!1})})}removeFormGroup(e){hw.then(()=>{let i=this._findContainer(e.path);i&&i.removeControl(e.name)})}getFormGroup(e){return this.form.get(e.path)}updateModel(e,i){hw.then(()=>{this.form.get(e.path).setValue(i)})}setValue(e){this.control.setValue(e)}onSubmit(e){return this.submitted=!0,bne(this.form,this._directives),this.ngSubmit.emit(e),"dialog"===e?.target?.method}onReset(){this.resetForm()}resetForm(e){this.form.reset(e),this.submitted=!1}_setUpdateStrategy(){this.options&&null!=this.options.updateOn&&(this.form._updateOn=this.options.updateOn)}_findContainer(e){return e.pop(),e.length?this.form.get(e):this.form}}return n.\u0275fac=function(e){return new(e||n)(M(Lo,10),M(Nh,10))},n.\u0275dir=He({type:n,selectors:[["form",3,"ngNoForm","",3,"formGroup",""],["ng-form"],["","ngForm",""]],hostBindings:function(e,i){1&e&&P("submit",function(o){return i.onSubmit(o)})("reset",function(){return i.onReset()})},inputs:{options:["ngFormOptions","options"]},outputs:{ngSubmit:"ngSubmit"},exportAs:["ngForm"],features:[$t([Qke]),tt]}),n})();function qte(n,t){let e=n.indexOf(t);e>-1&&n.splice(e,1)}function Yte(n){return"object"==typeof n&&null!==n&&2===Object.keys(n).length&&"value"in n&&"disabled"in n}var Bh=class extends k2{constructor(t=null,e,i){super(gne(e),_ne(i,e)),this.defaultValue=null,this._onChange=[],this._pendingChange=!1,this._applyFormState(t),this._setUpdateStrategy(e),this._initObservables(),this.updateValueAndValidity({onlySelf:!0,emitEvent:!!this.asyncValidator}),H2(e)&&(e.nonNullable||e.initialValueIsDefault)&&(this.defaultValue=Yte(t)?t.value:t)}setValue(t,e={}){this.value=this._pendingValue=t,this._onChange.length&&!1!==e.emitModelToViewChange&&this._onChange.forEach(i=>i(this.value,!1!==e.emitViewToModelChange)),this.updateValueAndValidity(e)}patchValue(t,e={}){this.setValue(t,e)}reset(t=this.defaultValue,e={}){this._applyFormState(t),this.markAsPristine(e),this.markAsUntouched(e),this.setValue(this.value,e),this._pendingChange=!1}_updateValue(){}_anyControls(t){return!1}_allControlsDisabled(){return this.disabled}registerOnChange(t){this._onChange.push(t)}_unregisterOnChange(t){qte(this._onChange,t)}registerOnDisabledChange(t){this._onDisabledChange.push(t)}_unregisterOnDisabledChange(t){qte(this._onDisabledChange,t)}_forEachChild(t){}_syncPendingControls(){return!("submit"!==this.updateOn||(this._pendingDirty&&this.markAsDirty(),this._pendingTouched&&this.markAsTouched(),!this._pendingChange)||(this.setValue(this._pendingValue,{onlySelf:!0,emitModelToViewChange:!1}),0))}_applyFormState(t){Yte(t)?(this.value=this._pendingValue=t.value,t.disabled?this.disable({onlySelf:!0,emitEvent:!1}):this.enable({onlySelf:!0,emitEvent:!1})):this.value=this._pendingValue=t}},xne=(()=>{class n extends Fs{ngOnInit(){this._checkParentType(),this.formDirective.addFormGroup(this)}ngOnDestroy(){this.formDirective&&this.formDirective.removeFormGroup(this)}get control(){return this.formDirective.getFormGroup(this)}get path(){return U2(null==this.name?this.name:this.name.toString(),this._parent)}get formDirective(){return this._parent?this._parent.formDirective:null}_checkParentType(){}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275dir=He({type:n,features:[tt]}),n})(),Zke={provide:Fs,useExisting:Jn(()=>Jke)},Jke=(()=>{class n extends xne{constructor(e,i,r){super(),this._parent=e,this._setValidators(i),this._setAsyncValidators(r)}_checkParentType(){}}return n.\u0275fac=function(e){return new(e||n)(M(Fs,5),M(Lo,10),M(Nh,10))},n.\u0275dir=He({type:n,selectors:[["","ngModelGroup",""]],inputs:{name:["ngModelGroup","name"]},exportAs:["ngModelGroup"],features:[$t([Zke]),tt]}),n})(),$ke={provide:Ns,useExisting:Jn(()=>eFe)},Xte=Promise.resolve(),eFe=(()=>{class n extends Ns{constructor(e,i,r,o,s){super(),this._changeDetectorRef=s,this.control=new Bh,this._registered=!1,this.update=new G,this._parent=e,this._setValidators(i),this._setAsyncValidators(r),this.valueAccessor=WH(0,o)}ngOnChanges(e){if(this._checkForErrors(),!this._registered||"name"in e){if(this._registered&&(this._checkName(),this.formDirective)){let i=e.name.previousValue;this.formDirective.removeControl({name:i,path:this._getPath(i)})}this._setUpControl()}"isDisabled"in e&&this._updateDisabled(e),GH(e,this.viewModel)&&(this._updateValue(this.model),this.viewModel=this.model)}ngOnDestroy(){this.formDirective&&this.formDirective.removeControl(this)}get path(){return this._getPath(this.name)}get formDirective(){return this._parent?this._parent.formDirective:null}viewToModelUpdate(e){this.viewModel=e,this.update.emit(e)}_setUpControl(){this._setUpdateStrategy(),this._isStandalone()?this._setUpStandalone():this.formDirective.addControl(this),this._registered=!0}_setUpdateStrategy(){this.options&&null!=this.options.updateOn&&(this.control._updateOn=this.options.updateOn)}_isStandalone(){return!this._parent||!(!this.options||!this.options.standalone)}_setUpStandalone(){fw(this.control,this),this.control.updateValueAndValidity({emitEvent:!1})}_checkForErrors(){this._isStandalone()||this._checkParentType(),this._checkName()}_checkParentType(){}_checkName(){this.options&&this.options.name&&(this.name=this.options.name),this._isStandalone()}_updateValue(e){Xte.then(()=>{this.control.setValue(e,{emitViewToModelChange:!1}),this._changeDetectorRef?.markForCheck()})}_updateDisabled(e){let i=e.isDisabled.currentValue,r=0!==i&&NT(i);Xte.then(()=>{r&&!this.control.disabled?this.control.disable():!r&&this.control.disabled&&this.control.enable(),this._changeDetectorRef?.markForCheck()})}_getPath(e){return this._parent?U2(e,this._parent):[e]}}return n.\u0275fac=function(e){return new(e||n)(M(Fs,9),M(Lo,10),M(Nh,10),M(No,10),M(nn,8))},n.\u0275dir=He({type:n,selectors:[["","ngModel","",3,"formControlName","",3,"formControl",""]],inputs:{name:"name",isDisabled:["disabled","isDisabled"],model:["ngModel","model"],options:["ngModelOptions","options"]},outputs:{update:"ngModelChange"},exportAs:["ngModel"],features:[$t([$ke]),tt,Ft]}),n})(),tFe={provide:No,useExisting:Jn(()=>qH),multi:!0},qH=(()=>{class n extends lg{writeValue(e){this.setProperty("value",e??"")}registerOnChange(e){this.onChange=i=>{e(""==i?null:parseFloat(i))}}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275dir=He({type:n,selectors:[["input","type","number","formControlName",""],["input","type","number","formControl",""],["input","type","number","ngModel",""]],hostBindings:function(e,i){1&e&&P("input",function(o){return i.onChange(o.target.value)})("blur",function(){return i.onTouched()})},features:[$t([tFe]),tt]}),n})(),nFe={provide:No,useExisting:Jn(()=>rFe),multi:!0},Cne=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),iFe=(()=>{class n{constructor(){this._accessors=[]}add(e,i){this._accessors.push([e,i])}remove(e){for(let i=this._accessors.length-1;i>=0;--i)if(this._accessors[i][1]===e)return void this._accessors.splice(i,1)}select(e){this._accessors.forEach(i=>{this._isSameGroup(i,e)&&i[1]!==e&&i[1].fireUncheck(e.value)})}_isSameGroup(e,i){return!!e[0].control&&e[0]._parent===i._control._parent&&e[1].name===i.name}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:Cne}),n})(),rFe=(()=>{class n extends lg{constructor(e,i,r,o){super(e,i),this._registry=r,this._injector=o,this.onChange=()=>{}}ngOnInit(){this._control=this._injector.get(Ns),this._checkName(),this._registry.add(this._control,this)}ngOnDestroy(){this._registry.remove(this)}writeValue(e){this._state=e===this.value,this.setProperty("checked",this._state)}registerOnChange(e){this._fn=e,this.onChange=()=>{e(this.value),this._registry.select(this)}}fireUncheck(e){this.writeValue(e)}_checkName(){!this.name&&this.formControlName&&(this.name=this.formControlName)}}return n.\u0275fac=function(e){return new(e||n)(M(Eu),M(Re),M(iFe),M(Xn))},n.\u0275dir=He({type:n,selectors:[["input","type","radio","formControlName",""],["input","type","radio","formControl",""],["input","type","radio","ngModel",""]],hostBindings:function(e,i){1&e&&P("change",function(){return i.onChange()})("blur",function(){return i.onTouched()})},inputs:{name:"name",formControlName:"formControlName",value:"value"},features:[$t([nFe]),tt]}),n})(),oFe={provide:No,useExisting:Jn(()=>sFe),multi:!0},sFe=(()=>{class n extends lg{writeValue(e){this.setProperty("value",parseFloat(e))}registerOnChange(e){this.onChange=i=>{e(""==i?null:parseFloat(i))}}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275dir=He({type:n,selectors:[["input","type","range","formControlName",""],["input","type","range","formControl",""],["input","type","range","ngModel",""]],hostBindings:function(e,i){1&e&&P("change",function(o){return i.onChange(o.target.value)})("input",function(o){return i.onChange(o.target.value)})("blur",function(){return i.onTouched()})},features:[$t([oFe]),tt]}),n})(),YH=new pe("NgModelWithFormControlWarning"),aFe={provide:Ns,useExisting:Jn(()=>mw)},mw=(()=>{class n extends Ns{constructor(e,i,r,o){super(),this._ngModelWarningConfig=o,this.update=new G,this._ngModelWarningSent=!1,this._setValidators(e),this._setAsyncValidators(i),this.valueAccessor=WH(0,r)}set isDisabled(e){}ngOnChanges(e){if(this._isControlChanged(e)){let i=e.form.previousValue;i&&N2(i,this,!1),fw(this.form,this),this.form.updateValueAndValidity({emitEvent:!1})}GH(e,this.viewModel)&&(this.form.setValue(this.model),this.viewModel=this.model)}ngOnDestroy(){this.form&&N2(this.form,this,!1)}get path(){return[]}get control(){return this.form}viewToModelUpdate(e){this.viewModel=e,this.update.emit(e)}_isControlChanged(e){return e.hasOwnProperty("form")}}return n._ngModelWarningSentOnce=!1,n.\u0275fac=function(e){return new(e||n)(M(Lo,10),M(Nh,10),M(No,10),M(YH,8))},n.\u0275dir=He({type:n,selectors:[["","formControl",""]],inputs:{form:["formControl","form"],isDisabled:["disabled","isDisabled"],model:["ngModel","model"]},outputs:{update:"ngModelChange"},exportAs:["ngForm"],features:[$t([aFe]),tt,Ft]}),n})(),lFe={provide:Fs,useExisting:Jn(()=>Vh)},Vh=(()=>{class n extends Fs{constructor(e,i){super(),this.submitted=!1,this._onCollectionChange=()=>this._updateDomValue(),this.directives=[],this.form=null,this.ngSubmit=new G,this._setValidators(e),this._setAsyncValidators(i)}ngOnChanges(e){this._checkFormPresent(),e.hasOwnProperty("form")&&(this._updateValidators(),this._updateDomValue(),this._updateRegistrations(),this._oldForm=this.form)}ngOnDestroy(){this.form&&(B2(this.form,this),this.form._onCollectionChange===this._onCollectionChange&&this.form._registerOnCollectionChange(()=>{}))}get formDirective(){return this}get control(){return this.form}get path(){return[]}addControl(e){let i=this.form.get(e.path);return fw(i,e),i.updateValueAndValidity({emitEvent:!1}),this.directives.push(e),i}getControl(e){return this.form.get(e.path)}removeControl(e){N2(e.control||null,e,!1),function(n,t){let e=n.indexOf(t);e>-1&&n.splice(e,1)}(this.directives,e)}addFormGroup(e){this._setUpFormContainer(e)}removeFormGroup(e){this._cleanUpFormContainer(e)}getFormGroup(e){return this.form.get(e.path)}addFormArray(e){this._setUpFormContainer(e)}removeFormArray(e){this._cleanUpFormContainer(e)}getFormArray(e){return this.form.get(e.path)}updateModel(e,i){this.form.get(e.path).setValue(i)}onSubmit(e){return this.submitted=!0,bne(this.form,this.directives),this.ngSubmit.emit(e),"dialog"===e?.target?.method}onReset(){this.resetForm()}resetForm(e){this.form.reset(e),this.submitted=!1}_updateDomValue(){this.directives.forEach(e=>{let i=e.control,r=this.form.get(e.path);i!==r&&(N2(i||null,e),(n=>n instanceof Bh)(r)&&(fw(r,e),e.control=r))}),this.form._updateTreeValidity({emitEvent:!1})}_setUpFormContainer(e){let i=this.form.get(e.path);yne(i,e),i.updateValueAndValidity({emitEvent:!1})}_cleanUpFormContainer(e){if(this.form){let i=this.form.get(e.path);i&&function(n,t){return B2(n,t)}(i,e)&&i.updateValueAndValidity({emitEvent:!1})}}_updateRegistrations(){this.form._registerOnCollectionChange(this._onCollectionChange),this._oldForm&&this._oldForm._registerOnCollectionChange(()=>{})}_updateValidators(){jH(this.form,this),this._oldForm&&B2(this._oldForm,this)}_checkFormPresent(){}}return n.\u0275fac=function(e){return new(e||n)(M(Lo,10),M(Nh,10))},n.\u0275dir=He({type:n,selectors:[["","formGroup",""]],hostBindings:function(e,i){1&e&&P("submit",function(o){return i.onSubmit(o)})("reset",function(){return i.onReset()})},inputs:{form:["formGroup","form"]},outputs:{ngSubmit:"ngSubmit"},exportAs:["ngForm"],features:[$t([lFe]),tt,Ft]}),n})(),cFe={provide:Fs,useExisting:Jn(()=>Mne)},Mne=(()=>{class n extends xne{constructor(e,i,r){super(),this._parent=e,this._setValidators(i),this._setAsyncValidators(r)}_checkParentType(){Sne(this._parent)}}return n.\u0275fac=function(e){return new(e||n)(M(Fs,13),M(Lo,10),M(Nh,10))},n.\u0275dir=He({type:n,selectors:[["","formGroupName",""]],inputs:{name:["formGroupName","name"]},features:[$t([cFe]),tt]}),n})(),uFe={provide:Fs,useExisting:Jn(()=>wne)},wne=(()=>{class n extends Fs{constructor(e,i,r){super(),this._parent=e,this._setValidators(i),this._setAsyncValidators(r)}ngOnInit(){this._checkParentType(),this.formDirective.addFormArray(this)}ngOnDestroy(){this.formDirective&&this.formDirective.removeFormArray(this)}get control(){return this.formDirective.getFormArray(this)}get formDirective(){return this._parent?this._parent.formDirective:null}get path(){return U2(null==this.name?this.name:this.name.toString(),this._parent)}_checkParentType(){Sne(this._parent)}}return n.\u0275fac=function(e){return new(e||n)(M(Fs,13),M(Lo,10),M(Nh,10))},n.\u0275dir=He({type:n,selectors:[["","formArrayName",""]],inputs:{name:["formArrayName","name"]},features:[$t([uFe]),tt]}),n})();function Sne(n){return!(n instanceof Mne||n instanceof Vh||n instanceof wne)}var dFe={provide:Ns,useExisting:Jn(()=>pFe)},pFe=(()=>{class n extends Ns{constructor(e,i,r,o,s){super(),this._ngModelWarningConfig=s,this._added=!1,this.update=new G,this._ngModelWarningSent=!1,this._parent=e,this._setValidators(i),this._setAsyncValidators(r),this.valueAccessor=WH(0,o)}set isDisabled(e){}ngOnChanges(e){this._added||this._setUpControl(),GH(e,this.viewModel)&&(this.viewModel=this.model,this.formDirective.updateModel(this,this.model))}ngOnDestroy(){this.formDirective&&this.formDirective.removeControl(this)}viewToModelUpdate(e){this.viewModel=e,this.update.emit(e)}get path(){return U2(null==this.name?this.name:this.name.toString(),this._parent)}get formDirective(){return this._parent?this._parent.formDirective:null}_checkParentType(){}_setUpControl(){this._checkParentType(),this.control=this.formDirective.addControl(this),this._added=!0}}return n._ngModelWarningSentOnce=!1,n.\u0275fac=function(e){return new(e||n)(M(Fs,13),M(Lo,10),M(Nh,10),M(No,10),M(YH,8))},n.\u0275dir=He({type:n,selectors:[["","formControlName",""]],inputs:{name:["formControlName","name"],isDisabled:["disabled","isDisabled"],model:["ngModel","model"]},outputs:{update:"ngModelChange"},features:[$t([dFe]),tt,Ft]}),n})(),hFe={provide:No,useExisting:Jn(()=>Tne),multi:!0};function Ene(n,t){return null==n?`${t}`:(t&&"object"==typeof t&&(t="Object"),`${n}: ${t}`.slice(0,50))}var Tne=(()=>{class n extends lg{constructor(){super(...arguments),this._optionMap=new Map,this._idCounter=0,this._compareWith=Object.is}set compareWith(e){this._compareWith=e}writeValue(e){this.value=e;let r=Ene(this._getOptionId(e),e);this.setProperty("value",r)}registerOnChange(e){this.onChange=i=>{this.value=this._getOptionValue(i),e(this.value)}}_registerOption(){return(this._idCounter++).toString()}_getOptionId(e){for(let i of Array.from(this._optionMap.keys()))if(this._compareWith(this._optionMap.get(i),e))return i;return null}_getOptionValue(e){let i=function(n){return n.split(":")[0]}(e);return this._optionMap.has(i)?this._optionMap.get(i):e}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275dir=He({type:n,selectors:[["select","formControlName","",3,"multiple",""],["select","formControl","",3,"multiple",""],["select","ngModel","",3,"multiple",""]],hostBindings:function(e,i){1&e&&P("change",function(o){return i.onChange(o.target.value)})("blur",function(){return i.onTouched()})},inputs:{compareWith:"compareWith"},features:[$t([hFe]),tt]}),n})(),Dne=(()=>{class n{constructor(e,i,r){this._element=e,this._renderer=i,this._select=r,this._select&&(this.id=this._select._registerOption())}set ngValue(e){null!=this._select&&(this._select._optionMap.set(this.id,e),this._setElementValue(Ene(this.id,e)),this._select.writeValue(this._select.value))}set value(e){this._setElementValue(e),this._select&&this._select.writeValue(this._select.value)}_setElementValue(e){this._renderer.setProperty(this._element.nativeElement,"value",e)}ngOnDestroy(){this._select&&(this._select._optionMap.delete(this.id),this._select.writeValue(this._select.value))}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(Eu),M(Tne,9))},n.\u0275dir=He({type:n,selectors:[["option"]],inputs:{ngValue:"ngValue",value:"value"}}),n})(),mFe={provide:No,useExisting:Jn(()=>Ane),multi:!0};function Qte(n,t){return null==n?`${t}`:("string"==typeof t&&(t=`'${t}'`),t&&"object"==typeof t&&(t="Object"),`${n}: ${t}`.slice(0,50))}var Ane=(()=>{class n extends lg{constructor(){super(...arguments),this._optionMap=new Map,this._idCounter=0,this._compareWith=Object.is}set compareWith(e){this._compareWith=e}writeValue(e){let i;if(this.value=e,Array.isArray(e)){let r=e.map(o=>this._getOptionId(o));i=(o,s)=>{o._setSelected(r.indexOf(s.toString())>-1)}}else i=(r,o)=>{r._setSelected(!1)};this._optionMap.forEach(i)}registerOnChange(e){this.onChange=i=>{let r=[],o=i.selectedOptions;if(void 0!==o){let s=o;for(let a=0;a<s.length;a++){let c=this._getOptionValue(s[a].value);r.push(c)}}else{let s=i.options;for(let a=0;a<s.length;a++){let l=s[a];if(l.selected){let c=this._getOptionValue(l.value);r.push(c)}}}this.value=r,e(r)}}_registerOption(e){let i=(this._idCounter++).toString();return this._optionMap.set(i,e),i}_getOptionId(e){for(let i of Array.from(this._optionMap.keys()))if(this._compareWith(this._optionMap.get(i)._value,e))return i;return null}_getOptionValue(e){let i=function(n){return n.split(":")[0]}(e);return this._optionMap.has(i)?this._optionMap.get(i)._value:e}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275dir=He({type:n,selectors:[["select","multiple","","formControlName",""],["select","multiple","","formControl",""],["select","multiple","","ngModel",""]],hostBindings:function(e,i){1&e&&P("change",function(o){return i.onChange(o.target)})("blur",function(){return i.onTouched()})},inputs:{compareWith:"compareWith"},features:[$t([mFe]),tt]}),n})(),Ine=(()=>{class n{constructor(e,i,r){this._element=e,this._renderer=i,this._select=r,this._select&&(this.id=this._select._registerOption(this))}set ngValue(e){null!=this._select&&(this._value=e,this._setElementValue(Qte(this.id,e)),this._select.writeValue(this._select.value))}set value(e){this._select?(this._value=e,this._setElementValue(Qte(this.id,e)),this._select.writeValue(this._select.value)):this._setElementValue(e)}_setElementValue(e){this._renderer.setProperty(this._element.nativeElement,"value",e)}_setSelected(e){this._renderer.setProperty(this._element.nativeElement,"selected",e)}ngOnDestroy(){this._select&&(this._select._optionMap.delete(this.id),this._select.writeValue(this._select.value))}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(Eu),M(Ane,9))},n.\u0275dir=He({type:n,selectors:[["option"]],inputs:{ngValue:"ngValue",value:"value"}}),n})();function Pne(n){return"number"==typeof n?n:parseInt(n,10)}function Rne(n){return"number"==typeof n?n:parseFloat(n)}var cg=(()=>{class n{constructor(){this._validator=P2}ngOnChanges(e){if(this.inputName in e){let i=this.normalizeInput(e[this.inputName].currentValue);this._enabled=this.enabled(i),this._validator=this._enabled?this.createValidator(i):P2,this._onChange&&this._onChange()}}validate(e){return this._validator(e)}registerOnValidatorChange(e){this._onChange=e}enabled(e){return null!=e}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=He({type:n,features:[Ft]}),n})(),_Fe={provide:Lo,useExisting:Jn(()=>vFe),multi:!0},vFe=(()=>{class n extends cg{constructor(){super(...arguments),this.inputName="max",this.normalizeInput=e=>Rne(e),this.createValidator=e=>$te(e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275dir=He({type:n,selectors:[["input","type","number","max","","formControlName",""],["input","type","number","max","","formControl",""],["input","type","number","max","","ngModel",""]],hostVars:1,hostBindings:function(e,i){2&e&&ze("max",i._enabled?i.max:null)},inputs:{max:"max"},features:[$t([_Fe]),tt]}),n})(),yFe={provide:Lo,useExisting:Jn(()=>bFe),multi:!0},bFe=(()=>{class n extends cg{constructor(){super(...arguments),this.inputName="min",this.normalizeInput=e=>Rne(e),this.createValidator=e=>Jte(e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275dir=He({type:n,selectors:[["input","type","number","min","","formControlName",""],["input","type","number","min","","formControl",""],["input","type","number","min","","ngModel",""]],hostVars:1,hostBindings:function(e,i){2&e&&ze("min",i._enabled?i.min:null)},inputs:{min:"min"},features:[$t([yFe]),tt]}),n})(),xFe={provide:Lo,useExisting:Jn(()=>One),multi:!0},CFe={provide:Lo,useExisting:Jn(()=>gw),multi:!0},One=(()=>{class n extends cg{constructor(){super(...arguments),this.inputName="required",this.normalizeInput=NT,this.createValidator=e=>ene}enabled(e){return e}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275dir=He({type:n,selectors:[["","required","","formControlName","",3,"type","checkbox"],["","required","","formControl","",3,"type","checkbox"],["","required","","ngModel","",3,"type","checkbox"]],hostVars:1,hostBindings:function(e,i){2&e&&ze("required",i._enabled?"":null)},inputs:{required:"required"},features:[$t([xFe]),tt]}),n})(),gw=(()=>{class n extends One{constructor(){super(...arguments),this.createValidator=e=>tne}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275dir=He({type:n,selectors:[["input","type","checkbox","required","","formControlName",""],["input","type","checkbox","required","","formControl",""],["input","type","checkbox","required","","ngModel",""]],hostVars:1,hostBindings:function(e,i){2&e&&ze("required",i._enabled?"":null)},features:[$t([CFe]),tt]}),n})(),MFe={provide:Lo,useExisting:Jn(()=>wFe),multi:!0},wFe=(()=>{class n extends cg{constructor(){super(...arguments),this.inputName="email",this.normalizeInput=NT,this.createValidator=e=>nne}enabled(e){return e}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275dir=He({type:n,selectors:[["","email","","formControlName",""],["","email","","formControl",""],["","email","","ngModel",""]],inputs:{email:"email"},features:[$t([MFe]),tt]}),n})(),SFe={provide:Lo,useExisting:Jn(()=>EFe),multi:!0},EFe=(()=>{class n extends cg{constructor(){super(...arguments),this.inputName="minlength",this.normalizeInput=e=>Pne(e),this.createValidator=e=>ine(e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275dir=He({type:n,selectors:[["","minlength","","formControlName",""],["","minlength","","formControl",""],["","minlength","","ngModel",""]],hostVars:1,hostBindings:function(e,i){2&e&&ze("minlength",i._enabled?i.minlength:null)},inputs:{minlength:"minlength"},features:[$t([SFe]),tt]}),n})(),TFe={provide:Lo,useExisting:Jn(()=>DFe),multi:!0},DFe=(()=>{class n extends cg{constructor(){super(...arguments),this.inputName="maxlength",this.normalizeInput=e=>Pne(e),this.createValidator=e=>rne(e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275dir=He({type:n,selectors:[["","maxlength","","formControlName",""],["","maxlength","","formControl",""],["","maxlength","","ngModel",""]],hostVars:1,hostBindings:function(e,i){2&e&&ze("maxlength",i._enabled?i.maxlength:null)},inputs:{maxlength:"maxlength"},features:[$t([TFe]),tt]}),n})(),AFe={provide:Lo,useExisting:Jn(()=>IFe),multi:!0},IFe=(()=>{class n extends cg{constructor(){super(...arguments),this.inputName="pattern",this.normalizeInput=e=>e,this.createValidator=e=>one(e)}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275dir=He({type:n,selectors:[["","pattern","","formControlName",""],["","pattern","","formControl",""],["","pattern","","ngModel",""]],hostVars:1,hostBindings:function(e,i){2&e&&ze("pattern",i._enabled?i.pattern:null)},inputs:{pattern:"pattern"},features:[$t([AFe]),tt]}),n})(),kne=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Cne]}),n})(),jr=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[kne]}),n})(),z2=(()=>{class n{static withConfig(e){return{ngModule:n,providers:[{provide:YH,useValue:e.warnOnNgModelWithFormControl}]}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[kne]}),n})(),PFe=(new Ic("14.2.11"),["trigger"]),RFe=["panel"];function OFe(n,t){if(1&n&&(_(0,"span",8),A(1),v()),2&n){let e=S();C(1),yt(e.placeholder)}}function kFe(n,t){if(1&n&&(_(0,"span",12),A(1),v()),2&n){let e=S(2);C(1),yt(e.triggerValue)}}function FFe(n,t){1&n&&Vn(0,0,["*ngSwitchCase","true"])}function NFe(n,t){1&n&&(_(0,"span",9),E(1,kFe,2,1,"span",10),E(2,FFe,1,0,"ng-content",11),v()),2&n&&(y("ngSwitch",!!S().customTrigger),C(2),y("ngSwitchCase",!0))}function LFe(n,t){if(1&n){let e=Pe();_(0,"div",13)(1,"div",14,15),P("@transformPanel.done",function(r){return oe(e),se(S()._panelDoneAnimatingStream.next(r.toState))})("keydown",function(r){return oe(e),se(S()._handleKeydown(r))}),Vn(3,1),v()()}if(2&n){let e=S();y("@transformPanelWrap",void 0),C(1),Qx("mat-select-panel ",e._getPanelTheme(),""),Pt("transform-origin",e._transformOrigin)("font-size",e._triggerFontSize,"px"),y("ngClass",e.panelClass)("@transformPanel",e.multiple?"showing-multiple":"showing"),ze("id",e.id+"-panel")("aria-multiselectable",e.multiple)("aria-label",e.ariaLabel||null)("aria-labelledby",e._getPanelAriaLabelledby())}}var BFe=[[["mat-select-trigger"]],"*"],VFe=["mat-select-trigger","*"],Fne={transformPanelWrap:Kr("transformPanelWrap",[Li("* => void",Im("@transformPanel",[Am()],{optional:!0}))]),transformPanel:Kr("transformPanel",[ki("void",gn({transform:"scaleY(0.8)",minWidth:"100%",opacity:0})),ki("showing",gn({opacity:1,minWidth:"calc(100% + 32px)",transform:"scaleY(1)"})),ki("showing-multiple",gn({opacity:1,minWidth:"calc(100% + 64px)",transform:"scaleY(1)"})),Li("void => *",ji("120ms cubic-bezier(0, 0, 0.2, 1)")),Li("* => void",ji("100ms 25ms linear",gn({opacity:0})))])},Nne=0,Bne=new pe("mat-select-scroll-strategy"),jFe=new pe("MAT_SELECT_CONFIG"),GFe={provide:Bne,deps:[tr],useFactory:function(n){return()=>n.scrollStrategies.reposition()}},WFe=qo(oc(so(Dv(class{constructor(n,t,e,i,r){this._elementRef=n,this._defaultErrorStateMatcher=t,this._parentForm=e,this._parentFormGroup=i,this.ngControl=r,this.stateChanges=new ke}})))),qFe=new pe("MatSelectTrigger"),YFe=(()=>{class n extends WFe{constructor(e,i,r,o,s,a,l,c,u,d,p,h,f,m){super(s,o,l,c,d),this._viewportRuler=e,this._changeDetectorRef=i,this._ngZone=r,this._dir=a,this._parentFormField=u,this._liveAnnouncer=f,this._defaultOptions=m,this._panelOpen=!1,this._compareWith=(x,g)=>x===g,this._uid="mat-select-"+Nne++,this._triggerAriaLabelledBy=null,this._destroy=new ke,this._onChange=()=>{},this._onTouched=()=>{},this._valueId="mat-select-value-"+Nne++,this._panelDoneAnimatingStream=new ke,this._overlayPanelClass=this._defaultOptions?.overlayPanelClass||"",this._focused=!1,this.controlType="mat-select",this._multiple=!1,this._disableOptionCentering=this._defaultOptions?.disableOptionCentering??!1,this.ariaLabel="",this.optionSelectionChanges=Qa(()=>{let x=this.options;return x?x.changes.pipe(zn(x),ui(()=>Jt(...x.map(g=>g.onSelectionChange)))):this._ngZone.onStable.pipe(Qt(1),ui(()=>this.optionSelectionChanges))}),this.openedChange=new G,this._openedStream=this.openedChange.pipe(Ye(x=>x),L(()=>{})),this._closedStream=this.openedChange.pipe(Ye(x=>!x),L(()=>{})),this.selectionChange=new G,this.valueChange=new G,this.ngControl&&(this.ngControl.valueAccessor=this),null!=m?.typeaheadDebounceInterval&&(this._typeaheadDebounceInterval=m.typeaheadDebounceInterval),this._scrollStrategyFactory=h,this._scrollStrategy=this._scrollStrategyFactory(),this.tabIndex=parseInt(p)||0,this.id=this.id}get focused(){return this._focused||this._panelOpen}get placeholder(){return this._placeholder}set placeholder(e){this._placeholder=e,this.stateChanges.next()}get required(){return this._required??this.ngControl?.control?.hasValidator(Fo.required)??!1}set required(e){this._required=Rt(e),this.stateChanges.next()}get multiple(){return this._multiple}set multiple(e){this._multiple=Rt(e)}get disableOptionCentering(){return this._disableOptionCentering}set disableOptionCentering(e){this._disableOptionCentering=Rt(e)}get compareWith(){return this._compareWith}set compareWith(e){this._compareWith=e,this._selectionModel&&this._initializeSelection()}get value(){return this._value}set value(e){this._assignValue(e)&&this._onChange(e)}get typeaheadDebounceInterval(){return this._typeaheadDebounceInterval}set typeaheadDebounceInterval(e){this._typeaheadDebounceInterval=Bi(e)}get id(){return this._id}set id(e){this._id=e||this._uid,this.stateChanges.next()}ngOnInit(){this._selectionModel=new Ah(this.multiple),this.stateChanges.next(),this._panelDoneAnimatingStream.pipe(yi(),st(this._destroy)).subscribe(()=>this._panelDoneAnimating(this.panelOpen))}ngAfterContentInit(){this._initKeyManager(),this._selectionModel.changed.pipe(st(this._destroy)).subscribe(e=>{e.added.forEach(i=>i.select()),e.removed.forEach(i=>i.deselect())}),this.options.changes.pipe(zn(null),st(this._destroy)).subscribe(()=>{this._resetOptions(),this._initializeSelection()})}ngDoCheck(){let e=this._getTriggerAriaLabelledby(),i=this.ngControl;if(e!==this._triggerAriaLabelledBy){let r=this._elementRef.nativeElement;this._triggerAriaLabelledBy=e,e?r.setAttribute("aria-labelledby",e):r.removeAttribute("aria-labelledby")}i&&(this._previousControl!==i.control&&(void 0!==this._previousControl&&null!==i.disabled&&i.disabled!==this.disabled&&(this.disabled=i.disabled),this._previousControl=i.control),this.updateErrorState())}ngOnChanges(e){(e.disabled||e.userAriaDescribedBy)&&this.stateChanges.next(),e.typeaheadDebounceInterval&&this._keyManager&&this._keyManager.withTypeAhead(this._typeaheadDebounceInterval)}ngOnDestroy(){this._destroy.next(),this._destroy.complete(),this.stateChanges.complete()}toggle(){this.panelOpen?this.close():this.open()}open(){this._canOpen()&&(this._panelOpen=!0,this._keyManager.withHorizontalOrientation(null),this._highlightCorrectOption(),this._changeDetectorRef.markForCheck())}close(){this._panelOpen&&(this._panelOpen=!1,this._keyManager.withHorizontalOrientation(this._isRtl()?"rtl":"ltr"),this._changeDetectorRef.markForCheck(),this._onTouched())}writeValue(e){this._assignValue(e)}registerOnChange(e){this._onChange=e}registerOnTouched(e){this._onTouched=e}setDisabledState(e){this.disabled=e,this._changeDetectorRef.markForCheck(),this.stateChanges.next()}get panelOpen(){return this._panelOpen}get selected(){return this.multiple?this._selectionModel?.selected||[]:this._selectionModel?.selected[0]}get triggerValue(){if(this.empty)return"";if(this._multiple){let e=this._selectionModel.selected.map(i=>i.viewValue);return this._isRtl()&&e.reverse(),e.join(", ")}return this._selectionModel.selected[0].viewValue}_isRtl(){return!!this._dir&&"rtl"===this._dir.value}_handleKeydown(e){this.disabled||(this.panelOpen?this._handleOpenKeydown(e):this._handleClosedKeydown(e))}_handleClosedKeydown(e){let i=e.keyCode,r=40===i||38===i||37===i||39===i,o=13===i||32===i,s=this._keyManager;if(!s.isTyping()&&o&&!kr(e)||(this.multiple||e.altKey)&&r)e.preventDefault(),this.open();else if(!this.multiple){let a=this.selected;s.onKeydown(e);let l=this.selected;l&&a!==l&&this._liveAnnouncer.announce(l.viewValue,1e4)}}_handleOpenKeydown(e){let i=this._keyManager,r=e.keyCode,o=40===r||38===r,s=i.isTyping();if(o&&e.altKey)e.preventDefault(),this.close();else if(s||13!==r&&32!==r||!i.activeItem||kr(e))if(!s&&this._multiple&&65===r&&e.ctrlKey){e.preventDefault();let a=this.options.some(l=>!l.disabled&&!l.selected);this.options.forEach(l=>{l.disabled||(a?l.select():l.deselect())})}else{let a=i.activeItemIndex;i.onKeydown(e),this._multiple&&o&&e.shiftKey&&i.activeItem&&i.activeItemIndex!==a&&i.activeItem._selectViaInteraction()}else e.preventDefault(),i.activeItem._selectViaInteraction()}_onFocus(){this.disabled||(this._focused=!0,this.stateChanges.next())}_onBlur(){this._focused=!1,!this.disabled&&!this.panelOpen&&(this._onTouched(),this._changeDetectorRef.markForCheck(),this.stateChanges.next())}_onAttached(){this._overlayDir.positionChange.pipe(Qt(1)).subscribe(()=>{this._changeDetectorRef.detectChanges(),this._positioningSettled()})}_getPanelTheme(){return this._parentFormField?`mat-${this._parentFormField.color}`:""}get empty(){return!this._selectionModel||this._selectionModel.isEmpty()}_initializeSelection(){Promise.resolve().then(()=>{this.ngControl&&(this._value=this.ngControl.value),this._setSelectionByValue(this._value),this.stateChanges.next()})}_setSelectionByValue(e){if(this._selectionModel.selected.forEach(i=>i.setInactiveStyles()),this._selectionModel.clear(),this.multiple&&e)Array.isArray(e),e.forEach(i=>this._selectOptionByValue(i)),this._sortValues();else{let i=this._selectOptionByValue(e);i?this._keyManager.updateActiveItem(i):this.panelOpen||this._keyManager.updateActiveItem(-1)}this._changeDetectorRef.markForCheck()}_selectOptionByValue(e){let i=this.options.find(r=>{if(this._selectionModel.isSelected(r))return!1;try{return null!=r.value&&this._compareWith(r.value,e)}catch{return!1}});return i&&this._selectionModel.select(i),i}_assignValue(e){return!!(e!==this._value||this._multiple&&Array.isArray(e))&&(this.options&&this._setSelectionByValue(e),this._value=e,!0)}_initKeyManager(){this._keyManager=new wv(this.options).withTypeAhead(this._typeaheadDebounceInterval).withVerticalOrientation().withHorizontalOrientation(this._isRtl()?"rtl":"ltr").withHomeAndEnd().withAllowedModifierKeys(["shiftKey"]),this._keyManager.tabOut.pipe(st(this._destroy)).subscribe(()=>{this.panelOpen&&(!this.multiple&&this._keyManager.activeItem&&this._keyManager.activeItem._selectViaInteraction(),this.focus(),this.close())}),this._keyManager.change.pipe(st(this._destroy)).subscribe(()=>{this._panelOpen&&this.panel?this._scrollOptionIntoView(this._keyManager.activeItemIndex||0):!this._panelOpen&&!this.multiple&&this._keyManager.activeItem&&this._keyManager.activeItem._selectViaInteraction()})}_resetOptions(){let e=Jt(this.options.changes,this._destroy);this.optionSelectionChanges.pipe(st(e)).subscribe(i=>{this._onSelect(i.source,i.isUserInput),i.isUserInput&&!this.multiple&&this._panelOpen&&(this.close(),this.focus())}),Jt(...this.options.map(i=>i._stateChanges)).pipe(st(e)).subscribe(()=>{this._changeDetectorRef.markForCheck(),this.stateChanges.next()})}_onSelect(e,i){let r=this._selectionModel.isSelected(e);null!=e.value||this._multiple?(r!==e.selected&&(e.selected?this._selectionModel.select(e):this._selectionModel.deselect(e)),i&&this._keyManager.setActiveItem(e),this.multiple&&(this._sortValues(),i&&this.focus())):(e.deselect(),this._selectionModel.clear(),null!=this.value&&this._propagateChanges(e.value)),r!==this._selectionModel.isSelected(e)&&this._propagateChanges(),this.stateChanges.next()}_sortValues(){if(this.multiple){let e=this.options.toArray();this._selectionModel.sort((i,r)=>this.sortComparator?this.sortComparator(i,r,e):e.indexOf(i)-e.indexOf(r)),this.stateChanges.next()}}_propagateChanges(e){let i=null;i=this.multiple?this.selected.map(r=>r.value):this.selected?this.selected.value:e,this._value=i,this.valueChange.emit(i),this._onChange(i),this.selectionChange.emit(this._getChangeEvent(i)),this._changeDetectorRef.markForCheck()}_highlightCorrectOption(){this._keyManager&&(this.empty?this._keyManager.setFirstItemActive():this._keyManager.setActiveItem(this._selectionModel.selected[0]))}_canOpen(){return!this._panelOpen&&!this.disabled&&this.options?.length>0}focus(e){this._elementRef.nativeElement.focus(e)}_getPanelAriaLabelledby(){if(this.ariaLabel)return null;let e=this._parentFormField?.getLabelId();return this.ariaLabelledby?(e?e+" ":"")+this.ariaLabelledby:e}_getAriaActiveDescendant(){return this.panelOpen&&this._keyManager&&this._keyManager.activeItem?this._keyManager.activeItem.id:null}_getTriggerAriaLabelledby(){if(this.ariaLabel)return null;let e=this._parentFormField?.getLabelId(),i=(e?e+" ":"")+this._valueId;return this.ariaLabelledby&&(i+=" "+this.ariaLabelledby),i}_panelDoneAnimating(e){this.openedChange.emit(e)}setDescribedByIds(e){e.length?this._elementRef.nativeElement.setAttribute("aria-describedby",e.join(" ")):this._elementRef.nativeElement.removeAttribute("aria-describedby")}onContainerClick(){this.focus(),this.open()}get shouldLabelFloat(){return this._panelOpen||!this.empty||this._focused&&!!this._placeholder}}return n.\u0275fac=function(e){return new(e||n)(M(Va),M(nn),M(_t),M(cd),M(Re),M($i,8),M(Lh,8),M(Vh,8),M(sg,8),M(Ns,10),vo("tabindex"),M(Bne),M(tw),M(jFe,8))},n.\u0275dir=He({type:n,viewQuery:function(e,i){if(1&e&&(ot(PFe,5),ot(RFe,5),ot(Rh,5)),2&e){let r;Ne(r=Le())&&(i.trigger=r.first),Ne(r=Le())&&(i.panel=r.first),Ne(r=Le())&&(i._overlayDir=r.first)}},inputs:{userAriaDescribedBy:["aria-describedby","userAriaDescribedBy"],panelClass:"panelClass",placeholder:"placeholder",required:"required",multiple:"multiple",disableOptionCentering:"disableOptionCentering",compareWith:"compareWith",value:"value",ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],errorStateMatcher:"errorStateMatcher",typeaheadDebounceInterval:"typeaheadDebounceInterval",sortComparator:"sortComparator",id:"id"},outputs:{openedChange:"openedChange",_openedStream:"opened",_closedStream:"closed",selectionChange:"selectionChange",valueChange:"valueChange"},features:[tt,Ft]}),n})(),Hh=(()=>{class n extends YFe{constructor(){super(...arguments),this._scrollTop=0,this._triggerFontSize=0,this._transformOrigin="top",this._offsetY=0,this._positions=[{originX:"start",originY:"top",overlayX:"start",overlayY:"top"},{originX:"start",originY:"bottom",overlayX:"start",overlayY:"bottom"}]}_calculateOverlayScroll(e,i,r){let o=this._getItemHeight();return Math.min(Math.max(0,o*e-i+o/2),r)}ngOnInit(){super.ngOnInit(),this._viewportRuler.change().pipe(st(this._destroy)).subscribe(()=>{this.panelOpen&&(this._triggerRect=this.trigger.nativeElement.getBoundingClientRect(),this._changeDetectorRef.markForCheck())})}open(){super._canOpen()&&(super.open(),this._triggerRect=this.trigger.nativeElement.getBoundingClientRect(),this._triggerFontSize=parseInt(getComputedStyle(this.trigger.nativeElement).fontSize||"0"),this._calculateOverlayPosition(),this._ngZone.onStable.pipe(Qt(1)).subscribe(()=>{this._triggerFontSize&&this._overlayDir.overlayRef&&this._overlayDir.overlayRef.overlayElement&&(this._overlayDir.overlayRef.overlayElement.style.fontSize=`${this._triggerFontSize}px`)}))}_scrollOptionIntoView(e){let i=ow(e,this.options,this.optionGroups),r=this._getItemHeight();this.panel.nativeElement.scrollTop=0===e&&1===i?0:_2((e+i)*r,r,this.panel.nativeElement.scrollTop,256)}_positioningSettled(){this._calculateOverlayOffsetX(),this.panel.nativeElement.scrollTop=this._scrollTop}_panelDoneAnimating(e){this.panelOpen?this._scrollTop=0:(this._overlayDir.offsetX=0,this._changeDetectorRef.markForCheck()),super._panelDoneAnimating(e)}_getChangeEvent(e){return new class{constructor(t,e){this.source=t,this.value=e}}(this,e)}_calculateOverlayOffsetX(){let s,e=this._overlayDir.overlayRef.overlayElement.getBoundingClientRect(),i=this._viewportRuler.getViewportSize(),r=this._isRtl(),o=this.multiple?56:32;if(this.multiple)s=40;else if(this.disableOptionCentering)s=16;else{let c=this._selectionModel.selected[0]||this.options.first;s=c&&c.group?32:16}r||(s*=-1);let a=0-(e.left+s-(r?o:0)),l=e.right+s-i.width+(r?0:o);a>0?s+=a+8:l>0&&(s-=l+8),this._overlayDir.offsetX=Math.round(s),this._overlayDir.overlayRef.updatePosition()}_calculateOverlayOffsetY(e,i,r){let l,o=this._getItemHeight(),s=(o-this._triggerRect.height)/2,a=Math.floor(256/o);return this.disableOptionCentering?0:(l=0===this._scrollTop?e*o:this._scrollTop===r?(e-(this._getItemCount()-a))*o+(o-(this._getItemCount()*o-256)%o):i-o/2,Math.round(-1*l-s))}_checkOverlayWithinViewport(e){let i=this._getItemHeight(),r=this._viewportRuler.getViewportSize(),o=this._triggerRect.top-8,s=r.height-this._triggerRect.bottom-8,a=Math.abs(this._offsetY),c=Math.min(this._getItemCount()*i,256)-a-this._triggerRect.height;c>s?this._adjustPanelUp(c,s):a>o?this._adjustPanelDown(a,o,e):this._transformOrigin=this._getOriginBasedOnOption()}_adjustPanelUp(e,i){let r=Math.round(e-i);this._scrollTop-=r,this._offsetY-=r,this._transformOrigin=this._getOriginBasedOnOption(),this._scrollTop<=0&&(this._scrollTop=0,this._offsetY=0,this._transformOrigin="50% bottom 0px")}_adjustPanelDown(e,i,r){let o=Math.round(e-i);if(this._scrollTop+=o,this._offsetY+=o,this._transformOrigin=this._getOriginBasedOnOption(),this._scrollTop>=r)return this._scrollTop=r,this._offsetY=0,void(this._transformOrigin="50% top 0px")}_calculateOverlayPosition(){let a,e=this._getItemHeight(),i=this._getItemCount(),r=Math.min(i*e,256),s=i*e-r;a=this.empty?0:Math.max(this.options.toArray().indexOf(this._selectionModel.selected[0]),0),a+=ow(a,this.options,this.optionGroups);let l=r/2;this._scrollTop=this._calculateOverlayScroll(a,l,s),this._offsetY=this._calculateOverlayOffsetY(a,l,s),this._checkOverlayWithinViewport(s)}_getOriginBasedOnOption(){let e=this._getItemHeight(),i=(e-this._triggerRect.height)/2;return`50% ${Math.abs(this._offsetY)-i+e/2}px 0px`}_getItemHeight(){return 3*this._triggerFontSize}_getItemCount(){return this.options.length+this.optionGroups.length}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275cmp=R({type:n,selectors:[["mat-select"]],contentQueries:function(e,i,r){if(1&e&&(Ei(r,qFe,5),Ei(r,Os,5),Ei(r,rw,5)),2&e){let o;Ne(o=Le())&&(i.customTrigger=o.first),Ne(o=Le())&&(i.options=o),Ne(o=Le())&&(i.optionGroups=o)}},hostAttrs:["role","combobox","aria-autocomplete","none","aria-haspopup","true",1,"mat-select"],hostVars:19,hostBindings:function(e,i){1&e&&P("keydown",function(o){return i._handleKeydown(o)})("focus",function(){return i._onFocus()})("blur",function(){return i._onBlur()}),2&e&&(ze("id",i.id)("tabindex",i.tabIndex)("aria-controls",i.panelOpen?i.id+"-panel":null)("aria-expanded",i.panelOpen)("aria-label",i.ariaLabel||null)("aria-required",i.required.toString())("aria-disabled",i.disabled.toString())("aria-invalid",i.errorState)("aria-activedescendant",i._getAriaActiveDescendant()),et("mat-select-disabled",i.disabled)("mat-select-invalid",i.errorState)("mat-select-required",i.required)("mat-select-empty",i.empty)("mat-select-multiple",i.multiple))},inputs:{disabled:"disabled",disableRipple:"disableRipple",tabIndex:"tabIndex"},exportAs:["matSelect"],features:[$t([{provide:kh,useExisting:n},{provide:iw,useExisting:n}]),tt],ngContentSelectors:VFe,decls:9,vars:12,consts:[["cdk-overlay-origin","",1,"mat-select-trigger",3,"click"],["origin","cdkOverlayOrigin","trigger",""],[1,"mat-select-value",3,"ngSwitch"],["class","mat-select-placeholder mat-select-min-line",4,"ngSwitchCase"],["class","mat-select-value-text",3,"ngSwitch",4,"ngSwitchCase"],[1,"mat-select-arrow-wrapper"],[1,"mat-select-arrow"],["cdk-connected-overlay","","cdkConnectedOverlayLockPosition","","cdkConnectedOverlayHasBackdrop","","cdkConnectedOverlayBackdropClass","cdk-overlay-transparent-backdrop",3,"cdkConnectedOverlayPanelClass","cdkConnectedOverlayScrollStrategy","cdkConnectedOverlayOrigin","cdkConnectedOverlayOpen","cdkConnectedOverlayPositions","cdkConnectedOverlayMinWidth","cdkConnectedOverlayOffsetY","backdropClick","attach","detach"],[1,"mat-select-placeholder","mat-select-min-line"],[1,"mat-select-value-text",3,"ngSwitch"],["class","mat-select-min-line",4,"ngSwitchDefault"],[4,"ngSwitchCase"],[1,"mat-select-min-line"],[1,"mat-select-panel-wrap"],["role","listbox","tabindex","-1",3,"ngClass","keydown"],["panel",""]],template:function(e,i){if(1&e&&(xi(BFe),_(0,"div",0,1),P("click",function(){return i.toggle()}),_(3,"div",2),E(4,OFe,2,1,"span",3),E(5,NFe,3,2,"span",4),v(),_(6,"div",5),O(7,"div",6),v()(),E(8,LFe,4,14,"ng-template",7),P("backdropClick",function(){return i.close()})("attach",function(){return i._onAttached()})("detach",function(){return i.close()})),2&e){let r=$e(1);ze("aria-owns",i.panelOpen?i.id+"-panel":null),C(3),y("ngSwitch",i.empty),ze("id",i._valueId),C(1),y("ngSwitchCase",!0),C(1),y("ngSwitchCase",!1),C(3),y("cdkConnectedOverlayPanelClass",i._overlayPanelClass)("cdkConnectedOverlayScrollStrategy",i._scrollStrategy)("cdkConnectedOverlayOrigin",r)("cdkConnectedOverlayOpen",i.panelOpen)("cdkConnectedOverlayPositions",i._positions)("cdkConnectedOverlayMinWidth",null==i._triggerRect?null:i._triggerRect.width)("cdkConnectedOverlayOffsetY",i._offsetY)}},dependencies:[Fn,Cr,Ur,ch,Rh,ig],styles:['.mat-select{display:inline-block;width:100%;outline:none}.mat-select-trigger{display:inline-flex;align-items:center;cursor:pointer;position:relative;box-sizing:border-box;width:100%}.mat-select-disabled .mat-select-trigger{-webkit-user-select:none;user-select:none;cursor:default}.mat-select-value{width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.mat-select-value-text{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.mat-select-arrow-wrapper{height:16px;flex-shrink:0;display:inline-flex;align-items:center}.mat-form-field-appearance-fill .mat-select-arrow-wrapper{transform:translateY(-50%)}.mat-form-field-appearance-outline .mat-select-arrow-wrapper{transform:translateY(-25%)}.mat-form-field-appearance-standard.mat-form-field-has-label .mat-select:not(.mat-select-empty) .mat-select-arrow-wrapper{transform:translateY(-50%)}.mat-form-field-appearance-standard .mat-select.mat-select-empty .mat-select-arrow-wrapper{transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}._mat-animation-noopable.mat-form-field-appearance-standard .mat-select.mat-select-empty .mat-select-arrow-wrapper{transition:none}.mat-select-arrow{width:0;height:0;border-left:5px solid rgba(0,0,0,0);border-right:5px solid rgba(0,0,0,0);border-top:5px solid;margin:0 4px}.mat-form-field.mat-focused .mat-select-arrow{transform:translateX(0)}.mat-select-panel-wrap{flex-basis:100%}.mat-select-panel{min-width:112px;max-width:280px;overflow:auto;-webkit-overflow-scrolling:touch;padding-top:0;padding-bottom:0;max-height:256px;min-width:100%;border-radius:4px;outline:0}.cdk-high-contrast-active .mat-select-panel{outline:solid 1px}.mat-select-panel .mat-optgroup-label,.mat-select-panel .mat-option{font-size:inherit;line-height:3em;height:3em}.mat-form-field-type-mat-select:not(.mat-form-field-disabled) .mat-form-field-flex{cursor:pointer}.mat-form-field-type-mat-select .mat-form-field-label{width:calc(100% - 18px)}.mat-select-placeholder{transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}._mat-animation-noopable .mat-select-placeholder{transition:none}.mat-form-field-hide-placeholder .mat-select-placeholder{color:rgba(0,0,0,0);-webkit-text-fill-color:rgba(0,0,0,0);transition:none;display:block}.mat-select-min-line:empty::before{content:" ";white-space:pre;width:1px;display:inline-block;visibility:hidden}'],encapsulation:2,data:{animation:[Fne.transformPanelWrap,Fne.transformPanel]},changeDetection:0}),n})(),lc=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[GFe],imports:[Me,ss,Av,ln,ud,ag,Av,ln]}),n})();function XFe(n,t){1&n&&(sn(0),_(1,"div",1),A(2," There is a difference between Default - (Enabled/Disabled) and (Enabled/Disabled) "),v(),_(3,"div",1),A(4," Only flags with non default values are sent to the backend. "),v(),an())}function QFe(n,t){1&n&&(_(0,"sup",11),A(1,"1"),v())}function KFe(n,t){1&n&&Ni(0)}function ZFe(n,t){if(1&n){let e=Pe();_(0,"mat-select",12),P("selectionChange",function(r){oe(e);let o=S().$implicit;return se(S().flagChanged.emit({flag:o.flag,status:r.value}))}),_(1,"mat-option",13),A(2),v(),_(3,"mat-option",14),A(4,"Enabled"),v(),_(5,"mat-option",15),A(6,"Disabled"),v()()}if(2&n){let e=S().$implicit,i=S();y("value",e.status),C(2),je(" Default ",i.formatFlagValue(e.defaultValue)," ")}}function JFe(n,t){if(1&n&&(_(0,"td"),A(1),v()),2&n){let e=S().$implicit,i=S();C(1),je("Unsupported By UI ",i.formatFlagValue(e.value),"")}}function $Fe(n,t){if(1&n&&(sn(0),_(1,"tr")(2,"td")(3,"div"),A(4),E(5,QFe,2,0,"sup",7),v()(),E(6,KFe,1,0,"ng-container",8),E(7,ZFe,7,2,"ng-template",null,9,qt),E(9,JFe,2,1,"ng-template",null,10,qt),v(),an()),2&n){let e=t.$implicit,i=$e(8),r=$e(10),o=S();C(4),je(" ",e.flag," "),C(1),y("ngIf",e.sendToServerWhenOverridden),C(1),y("ngIf",o.isEditable(e))("ngIfThen",i)("ngIfElse",r)}}function eNe(n,t){1&n&&(_(0,"div",11),A(1," 1. Sent to server when overridden "),v())}var q2,Vne=(()=>{class n{constructor(){this.hasFlagsSentToServer=!1,this.flagChanged=new G,this.allFlagsReset=new G}serializeFlagValue(e){return!0===e?"Enabled":!1===e?"Disabled":null==e?"null":Array.isArray(e)?JSON.stringify(e):e.toString()}isEditable(e){return"boolean"==typeof e.defaultValue}formatFlagValue(e){let i=this.serializeFlagValue(e);return 0===i.length?"":`- ${i}`}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["feature-flag-page-component"]],inputs:{featureFlagStatuses:"featureFlagStatuses",hasFlagsSentToServer:"hasFlagsSentToServer"},outputs:{flagChanged:"flagChanged",allFlagsReset:"allFlagsReset"},decls:11,vars:3,consts:[[1,"scrolling-page"],[1,"message"],[1,"warning"],[4,"ngIf"],[1,"feature-flag-table"],[4,"ngFor","ngForOf"],["mat-button","",3,"click"],["class","note-1",4,"ngIf"],[4,"ngIf","ngIfThen","ngIfElse"],["selectBlock",""],["unsupportedBlock",""],[1,"note-1"],[3,"value","selectionChange"],["value","default"],["value","enabled"],["value","disabled"]],template:function(e,i){1&e&&(_(0,"div",0)(1,"div",1)(2,"h2",2),A(3,"WARNING: EXPERIMENTAL FEATURES AHEAD!"),v(),A(4," By enabling these features, you could put the application in an unusable state or expose yourself to untested features or potential bugs. "),v(),E(5,XFe,5,0,"ng-container",3),_(6,"table",4),E(7,$Fe,11,5,"ng-container",5),v(),_(8,"button",6),P("click",function(){return i.allFlagsReset.emit()}),A(9,"Reset All"),v(),E(10,eNe,2,0,"div",7),v()),2&e&&(C(5),y("ngIf",i.hasFlagsSentToServer),C(2),y("ngForOf",i.featureFlagStatuses),C(3),y("ngIf",i.hasFlagsSentToServer))},dependencies:[dn,Be,_n,Hh,Os],styles:[".message[_ngcontent-%COMP%]{margin-bottom:16px}.message[_ngcontent-%COMP%]   .warning[_ngcontent-%COMP%]{color:#f44336}.note-1[_ngcontent-%COMP%]{color:#ff9800}.scrolling-page[_ngcontent-%COMP%]{max-height:90vh}.feature-flag-table[_ngcontent-%COMP%]{width:100%}"]}),n})(),W2=(()=>{class n{constructor(e){this.store=e,this.hasFlagsSentToServer$=this.store.select(Hm).pipe(L(i=>Object.values(i).some(r=>r.sendToServerWhenOverridden))),this.featureFlags$=this.store.select(zA).pipe(Wt(this.store.select(y$),this.store.select(Hm)),L(([i,r,o])=>Object.entries(r).map(([s,a])=>{let l=function(n,t){return void 0===t[n]?"default":t[n]?"enabled":"disabled"}(s,i);return{flag:s,defaultValue:a,status:l,sendToServerWhenOverridden:o[s].sendToServerWhenOverridden}})))}onFlagChanged({flag:e,status:i}){switch(i){case"default":this.store.dispatch(yh({flags:[e]}));break;case"enabled":this.store.dispatch(qm({flags:{[e]:!0}}));break;case"disabled":this.store.dispatch(qm({flags:{[e]:!1}}));break;default:throw new Error("Flag changed to invalid status")}}onAllFlagsReset(){this.store.dispatch(lv())}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["feature-flag-page"]],decls:3,vars:6,consts:[[3,"featureFlagStatuses","hasFlagsSentToServer","flagChanged","allFlagsReset"]],template:function(e,i){1&e&&(_(0,"feature-flag-page-component",0),P("flagChanged",function(o){return i.onFlagChanged(o)})("allFlagsReset",function(){return i.onAllFlagsReset()}),B(1,"async"),B(2,"async"),v()),2&e&&y("featureFlagStatuses",U(1,2,i.featureFlags$))("hasFlagsSentToServer",U(2,4,i.hasFlagsSentToServer$))},dependencies:[Vne,Ge],encapsulation:2}),n})(),Hne=(()=>{class n{constructor(e,i){this.store=e,this.dialog=i,this.showFeatureFlags$=this.store.select(E$)}ngOnInit(){this.showFeatureFlags$.subscribe(e=>{if(e)return this.featureFlagsDialog=this.dialog.open(W2),void this.featureFlagsDialog.afterClosed().subscribe(()=>{this.store.dispatch(yh({flags:["enableShowFlags"]})),setTimeout(()=>{window.location.reload()},1)})})}}return n.\u0275fac=function(e){return new(e||n)(M(Ce),M(vl))},n.\u0275cmp=R({type:n,selectors:[["feature-flag-modal-trigger"]],decls:0,vars:0,template:function(e,i){},encapsulation:2}),n})(),oNe=["routeContainer"],Une=(()=>{class n{constructor(e){this.componentFactoryResolver=e}ngOnChanges(e){let i=e.activeNgComponent;if(i&&(this.routeContainer.clear(),i.currentValue)){let r=this.componentFactoryResolver.resolveComponentFactory(i.currentValue);this.routeContainer.createComponent(r)}}}return n.\u0275fac=function(e){return new(e||n)(M(gs))},n.\u0275cmp=R({type:n,selectors:[["router-outlet-component"]],viewQuery:function(e,i){if(1&e&&ot(oNe,7,Oi),2&e){let r;Ne(r=Le())&&(i.routeContainer=r.first)}},inputs:{activeNgComponent:"activeNgComponent"},features:[Ft],decls:2,vars:0,consts:[["routeContainer",""]],template:function(e,i){1&e&&Ni(0,null,0)},encapsulation:2,changeDetection:0}),n})(),zne=(()=>{class n{constructor(e,i){this.store=e,this.registry=i,this.activeNgComponent$=Lt([this.store.select(Ra),this.store.select(ZJ)]).pipe(L(([r,o])=>r&&(null===o||Ps(r,o))?this.registry.getNgComponentByRouteKind(r.routeKind):null))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce),M(qc))},n.\u0275cmp=R({type:n,selectors:[["router-outlet"]],decls:2,vars:3,consts:[[3,"activeNgComponent"]],template:function(e,i){1&e&&(O(0,"router-outlet-component",0),B(1,"async")),2&e&&y("activeNgComponent",U(1,1,i.activeNgComponent$))},dependencies:[Une,Ge],encapsulation:2,changeDetection:0}),n})(),jne=(()=>{class n{constructor(e){e.select(Qu).subscribe(i=>{document.body.classList.toggle("dark-mode",i)})}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["dark-mode-supporter"]],decls:0,vars:0,template:function(e,i){},styles:["[_nghost-%COMP%] {\n        display: none;\n      }"],changeDetection:0}),n})(),Uv=(()=>(function(n){n[n.ACTIVE_PLUGIN=0]="ACTIVE_PLUGIN"}(Uv||(Uv={})),Uv))(),Gne=(()=>{class n{constructor(e){this.deepLinker=e,this.onValueChange=new G,this.ngUnsubscribe=new ke,this.onHashChange=_i(window,"popstate",{passive:!0}).pipe(st(this.ngUnsubscribe))}ngOnInit(){this.onHashChange.subscribe(()=>{let e=this.deepLinker.getPluginId();e!==this.activePluginId&&this.onValueChange.emit({prop:Uv.ACTIVE_PLUGIN,value:e})})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}ngOnChanges(e){if(e.activePluginId){let i=e.activePluginId;this.deepLinker.setPluginId(null===i.currentValue?"":i.currentValue,{defaultValue:"",useLocationReplace:null===i.previousValue||i.firstChange})}}}return n.\u0275fac=function(e){return new(e||n)(M(fh))},n.\u0275cmp=R({type:n,selectors:[["hash-storage-component"]],inputs:{activePluginId:"activePluginId"},outputs:{onValueChange:"onValueChange"},features:[Ft],decls:0,vars:0,template:function(e,i){},encapsulation:2,changeDetection:0}),n})(),Wne=(()=>{class n{constructor(e){this.store=e,this.activePluginId$=this.store.pipe(vt(Rs))}onValueChanged(e){e.prop===Uv.ACTIVE_PLUGIN&&this.store.dispatch(XA({plugin:e.value}))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["hash-storage"]],decls:2,vars:3,consts:[[3,"activePluginId","onValueChange"]],template:function(e,i){1&e&&(_(0,"hash-storage-component",0),P("onValueChange",function(o){return i.onValueChanged(o)}),B(1,"async"),v()),2&e&&y("activePluginId",U(1,1,i.activePluginId$))},dependencies:[Gne,Ge],styles:["[_nghost-%COMP%] {\n        display: none;\n      }"],changeDetection:0}),n})(),dNe=["*"];function vw(n){return function(){if(void 0===q2&&(q2=null,typeof window<"u")){let n=window;void 0!==n.trustedTypes&&(q2=n.trustedTypes.createPolicy("angular#components",{createHTML:t=>t}))}return q2}()?.createHTML(n)||n}function qne(n){return Error(`Unable to find icon with the name "${n}"`)}function Yne(n){return Error(`The URL provided to MatIconRegistry was not trusted as a resource URL via Angular's DomSanitizer. Attempted URL was "${n}".`)}function Xne(n){return Error(`The literal provided to MatIconRegistry was not trusted as safe HTML by Angular's DomSanitizer. Attempted literal was "${n}".`)}var cp=class{constructor(t,e,i){this.url=t,this.svgText=e,this.options=i}},zv=(()=>{class n{constructor(e,i,r,o){this._httpClient=e,this._sanitizer=i,this._errorHandler=o,this._svgIconConfigs=new Map,this._iconSetConfigs=new Map,this._cachedIconsByUrl=new Map,this._inProgressUrlFetches=new Map,this._fontCssClassesByAlias=new Map,this._resolvers=[],this._defaultFontSetClass=["material-icons","mat-ligature-font"],this._document=r}addSvgIcon(e,i,r){return this.addSvgIconInNamespace("",e,i,r)}addSvgIconLiteral(e,i,r){return this.addSvgIconLiteralInNamespace("",e,i,r)}addSvgIconInNamespace(e,i,r,o){return this._addSvgIconConfig(e,i,new cp(r,null,o))}addSvgIconResolver(e){return this._resolvers.push(e),this}addSvgIconLiteralInNamespace(e,i,r,o){let s=this._sanitizer.sanitize(mo.HTML,r);if(!s)throw Xne(r);let a=vw(s);return this._addSvgIconConfig(e,i,new cp("",a,o))}addSvgIconSet(e,i){return this.addSvgIconSetInNamespace("",e,i)}addSvgIconSetLiteral(e,i){return this.addSvgIconSetLiteralInNamespace("",e,i)}addSvgIconSetInNamespace(e,i,r){return this._addSvgIconSetConfig(e,new cp(i,null,r))}addSvgIconSetLiteralInNamespace(e,i,r){let o=this._sanitizer.sanitize(mo.HTML,i);if(!o)throw Xne(i);let s=vw(o);return this._addSvgIconSetConfig(e,new cp("",s,r))}registerFontClassAlias(e,i=e){return this._fontCssClassesByAlias.set(e,i),this}classNameForFontAlias(e){return this._fontCssClassesByAlias.get(e)||e}setDefaultFontSetClass(...e){return this._defaultFontSetClass=e,this}getDefaultFontSetClass(){return this._defaultFontSetClass}getSvgIconFromUrl(e){let i=this._sanitizer.sanitize(mo.RESOURCE_URL,e);if(!i)throw Yne(e);let r=this._cachedIconsByUrl.get(i);return r?Xt(Y2(r)):this._loadSvgIconFromConfig(new cp(e,null)).pipe(kt(o=>this._cachedIconsByUrl.set(i,o)),L(o=>Y2(o)))}getNamedSvgIcon(e,i=""){let r=Qne(i,e),o=this._svgIconConfigs.get(r);if(o)return this._getSvgFromConfig(o);if(o=this._getIconConfigFromResolvers(i,e),o)return this._svgIconConfigs.set(r,o),this._getSvgFromConfig(o);let s=this._iconSetConfigs.get(i);return s?this._getSvgFromIconSetConfigs(e,s):wc(qne(r))}ngOnDestroy(){this._resolvers=[],this._svgIconConfigs.clear(),this._iconSetConfigs.clear(),this._cachedIconsByUrl.clear()}_getSvgFromConfig(e){return e.svgText?Xt(Y2(this._svgElementFromConfig(e))):this._loadSvgIconFromConfig(e).pipe(L(i=>Y2(i)))}_getSvgFromIconSetConfigs(e,i){let r=this._extractIconWithNameFromAnySet(e,i);return r?Xt(r):lr(i.filter(s=>!s.svgText).map(s=>this._loadSvgIconSetFromConfig(s).pipe(fo(a=>{let c=`Loading icon set URL: ${this._sanitizer.sanitize(mo.RESOURCE_URL,s.url)} failed: ${a.message}`;return this._errorHandler.handleError(new Error(c)),Xt(null)})))).pipe(L(()=>{let s=this._extractIconWithNameFromAnySet(e,i);if(!s)throw qne(e);return s}))}_extractIconWithNameFromAnySet(e,i){for(let r=i.length-1;r>=0;r--){let o=i[r];if(o.svgText&&o.svgText.toString().indexOf(e)>-1){let s=this._svgElementFromConfig(o),a=this._extractSvgIconFromSet(s,e,o.options);if(a)return a}}return null}_loadSvgIconFromConfig(e){return this._fetchIcon(e).pipe(kt(i=>e.svgText=i),L(()=>this._svgElementFromConfig(e)))}_loadSvgIconSetFromConfig(e){return e.svgText?Xt(null):this._fetchIcon(e).pipe(kt(i=>e.svgText=i))}_extractSvgIconFromSet(e,i,r){let o=e.querySelector(`[id="${i}"]`);if(!o)return null;let s=o.cloneNode(!0);if(s.removeAttribute("id"),"svg"===s.nodeName.toLowerCase())return this._setSvgAttributes(s,r);if("symbol"===s.nodeName.toLowerCase())return this._setSvgAttributes(this._toSvgElement(s),r);let a=this._svgElementFromString(vw("<svg></svg>"));return a.appendChild(s),this._setSvgAttributes(a,r)}_svgElementFromString(e){let i=this._document.createElement("DIV");i.innerHTML=e;let r=i.querySelector("svg");if(!r)throw Error("<svg> tag not found");return r}_toSvgElement(e){let i=this._svgElementFromString(vw("<svg></svg>")),r=e.attributes;for(let o=0;o<r.length;o++){let{name:s,value:a}=r[o];"id"!==s&&i.setAttribute(s,a)}for(let o=0;o<e.childNodes.length;o++)e.childNodes[o].nodeType===this._document.ELEMENT_NODE&&i.appendChild(e.childNodes[o].cloneNode(!0));return i}_setSvgAttributes(e,i){return e.setAttribute("fit",""),e.setAttribute("height","100%"),e.setAttribute("width","100%"),e.setAttribute("preserveAspectRatio","xMidYMid meet"),e.setAttribute("focusable","false"),i&&i.viewBox&&e.setAttribute("viewBox",i.viewBox),e}_fetchIcon(e){let{url:i,options:r}=e,o=r?.withCredentials??!1;if(!this._httpClient)throw Error("Could not find HttpClient provider for use with Angular Material icons. Please include the HttpClientModule from @angular/common/http in your app imports.");if(null==i)throw Error(`Cannot fetch icon from URL "${i}".`);let s=this._sanitizer.sanitize(mo.RESOURCE_URL,i);if(!s)throw Yne(i);let a=this._inProgressUrlFetches.get(s);if(a)return a;let l=this._httpClient.get(s,{responseType:"text",withCredentials:o}).pipe(L(c=>vw(c)),function(n){return en((t,e)=>{try{t.subscribe(e)}finally{e.add(n)}})}(()=>this._inProgressUrlFetches.delete(s)),Ts());return this._inProgressUrlFetches.set(s,l),l}_addSvgIconConfig(e,i,r){return this._svgIconConfigs.set(Qne(e,i),r),this}_addSvgIconSetConfig(e,i){let r=this._iconSetConfigs.get(e);return r?r.push(i):this._iconSetConfigs.set(e,[i]),this}_svgElementFromConfig(e){if(!e.svgElement){let i=this._svgElementFromString(e.svgText);this._setSvgAttributes(i,e.options),e.svgElement=i}return e.svgElement}_getIconConfigFromResolvers(e,i){for(let r=0;r<this._resolvers.length;r++){let o=this._resolvers[r](i,e);if(o)return mNe(o)?new cp(o.url,null,o.options):new cp(o,null)}}}return n.\u0275fac=function(e){return new(e||n)(j(Vm,8),j(Tm),j(Ht,8),j(Qs))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})();function Y2(n){return n.cloneNode(!0)}function Qne(n,t){return n+":"+t}function mNe(n){return!(!n.url||!n.options)}new ns,new tl,new ns,new ns;var gNe=ko(class{constructor(n){this._elementRef=n}}),_Ne=new pe("MAT_ICON_DEFAULT_OPTIONS"),vNe=new pe("mat-icon-location",{providedIn:"root",factory:function(){let n=jo(Ht),t=n?n.location:null;return{getPathname:()=>t?t.pathname+t.search:""}}}),Kne=["clip-path","color-profile","src","cursor","fill","filter","marker","marker-start","marker-mid","marker-end","mask","stroke"],bNe=Kne.map(n=>`[${n}]`).join(", "),xNe=/^url\(['"]?#(.*?)['"]?\)$/,Gt=(()=>{class n extends gNe{constructor(e,i,r,o,s,a){super(e),this._iconRegistry=i,this._location=o,this._errorHandler=s,this._inline=!1,this._previousFontSetClass=[],this._currentIconFetch=Sn.EMPTY,a&&(a.color&&(this.color=this.defaultColor=a.color),a.fontSet&&(this.fontSet=a.fontSet)),r||e.nativeElement.setAttribute("aria-hidden","true")}get inline(){return this._inline}set inline(e){this._inline=Rt(e)}get svgIcon(){return this._svgIcon}set svgIcon(e){e!==this._svgIcon&&(e?this._updateSvgIcon(e):this._svgIcon&&this._clearSvgElement(),this._svgIcon=e)}get fontSet(){return this._fontSet}set fontSet(e){let i=this._cleanupFontValue(e);i!==this._fontSet&&(this._fontSet=i,this._updateFontIconClasses())}get fontIcon(){return this._fontIcon}set fontIcon(e){let i=this._cleanupFontValue(e);i!==this._fontIcon&&(this._fontIcon=i,this._updateFontIconClasses())}_splitIconName(e){if(!e)return["",""];let i=e.split(":");switch(i.length){case 1:return["",i[0]];case 2:return i;default:throw Error(`Invalid icon name: "${e}"`)}}ngOnInit(){this._updateFontIconClasses()}ngAfterViewChecked(){let e=this._elementsWithExternalReferences;if(e&&e.size){let i=this._location.getPathname();i!==this._previousPath&&(this._previousPath=i,this._prependPathToReferences(i))}}ngOnDestroy(){this._currentIconFetch.unsubscribe(),this._elementsWithExternalReferences&&this._elementsWithExternalReferences.clear()}_usingFontIcon(){return!this.svgIcon}_setSvgElement(e){this._clearSvgElement();let i=this._location.getPathname();this._previousPath=i,this._cacheChildrenWithExternalReferences(e),this._prependPathToReferences(i),this._elementRef.nativeElement.appendChild(e)}_clearSvgElement(){let e=this._elementRef.nativeElement,i=e.childNodes.length;for(this._elementsWithExternalReferences&&this._elementsWithExternalReferences.clear();i--;){let r=e.childNodes[i];(1!==r.nodeType||"svg"===r.nodeName.toLowerCase())&&r.remove()}}_updateFontIconClasses(){if(!this._usingFontIcon())return;let e=this._elementRef.nativeElement,i=(this.fontSet?this._iconRegistry.classNameForFontAlias(this.fontSet).split(/ +/):this._iconRegistry.getDefaultFontSetClass()).filter(r=>r.length>0);this._previousFontSetClass.forEach(r=>e.classList.remove(r)),i.forEach(r=>e.classList.add(r)),this._previousFontSetClass=i,this.fontIcon!==this._previousFontIconClass&&!i.includes("mat-ligature-font")&&(this._previousFontIconClass&&e.classList.remove(this._previousFontIconClass),this.fontIcon&&e.classList.add(this.fontIcon),this._previousFontIconClass=this.fontIcon)}_cleanupFontValue(e){return"string"==typeof e?e.trim().split(" ")[0]:e}_prependPathToReferences(e){let i=this._elementsWithExternalReferences;i&&i.forEach((r,o)=>{r.forEach(s=>{o.setAttribute(s.name,`url('${e}#${s.value}')`)})})}_cacheChildrenWithExternalReferences(e){let i=e.querySelectorAll(bNe),r=this._elementsWithExternalReferences=this._elementsWithExternalReferences||new Map;for(let o=0;o<i.length;o++)Kne.forEach(s=>{let a=i[o],l=a.getAttribute(s),c=l?l.match(xNe):null;if(c){let u=r.get(a);u||(u=[],r.set(a,u)),u.push({name:s,value:c[1]})}})}_updateSvgIcon(e){if(this._svgNamespace=null,this._svgName=null,this._currentIconFetch.unsubscribe(),e){let[i,r]=this._splitIconName(e);i&&(this._svgNamespace=i),r&&(this._svgName=r),this._currentIconFetch=this._iconRegistry.getNamedSvgIcon(r,i).pipe(Qt(1)).subscribe(o=>this._setSvgElement(o),o=>{this._errorHandler.handleError(new Error(`Error retrieving icon ${i}:${r}! ${o.message}`))})}}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(zv),vo("aria-hidden"),M(vNe),M(Qs),M(_Ne,8))},n.\u0275cmp=R({type:n,selectors:[["mat-icon"]],hostAttrs:["role","img",1,"mat-icon","notranslate"],hostVars:8,hostBindings:function(e,i){2&e&&(ze("data-mat-icon-type",i._usingFontIcon()?"font":"svg")("data-mat-icon-name",i._svgName||i.fontIcon)("data-mat-icon-namespace",i._svgNamespace||i.fontSet)("fontIcon",i._usingFontIcon()?i.fontIcon:null),et("mat-icon-inline",i.inline)("mat-icon-no-color","primary"!==i.color&&"accent"!==i.color&&"warn"!==i.color))},inputs:{color:"color",inline:"inline",svgIcon:"svgIcon",fontSet:"fontSet",fontIcon:"fontIcon"},exportAs:["matIcon"],features:[tt],ngContentSelectors:dNe,decls:1,vars:0,template:function(e,i){1&e&&(xi(),Vn(0))},styles:[".mat-icon{-webkit-user-select:none;user-select:none;background-repeat:no-repeat;display:inline-block;fill:currentColor;height:24px;width:24px;overflow:hidden}.mat-icon.mat-icon-inline{font-size:inherit;height:inherit;line-height:inherit;width:inherit}.mat-icon.mat-ligature-font[fontIcon]::before{content:attr(fontIcon)}[dir=rtl] .mat-icon-rtl-mirror{transform:scale(-1, 1)}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon{display:block}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon-button .mat-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon-button .mat-icon{margin:auto}"],encapsulation:2,changeDetection:0}),n})(),pn=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[ln,ln]}),n})(),CNe=["*",[["mat-toolbar-row"]]],MNe=["*","mat-toolbar-row"],wNe=ko(class{constructor(n){this._elementRef=n}}),SNe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=He({type:n,selectors:[["mat-toolbar-row"]],hostAttrs:[1,"mat-toolbar-row"],exportAs:["matToolbarRow"]}),n})(),Zne=(()=>{class n extends wNe{constructor(e,i,r){super(e),this._platform=i,this._document=r}ngAfterViewInit(){this._platform.isBrowser&&(this._checkToolbarMixedModes(),this._toolbarRows.changes.subscribe(()=>this._checkToolbarMixedModes()))}_checkToolbarMixedModes(){}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(oi),M(Ht))},n.\u0275cmp=R({type:n,selectors:[["mat-toolbar"]],contentQueries:function(e,i,r){if(1&e&&Ei(r,SNe,5),2&e){let o;Ne(o=Le())&&(i._toolbarRows=o)}},hostAttrs:[1,"mat-toolbar"],hostVars:4,hostBindings:function(e,i){2&e&&et("mat-toolbar-multiple-rows",i._toolbarRows.length>0)("mat-toolbar-single-row",0===i._toolbarRows.length)},inputs:{color:"color"},exportAs:["matToolbar"],features:[tt],ngContentSelectors:MNe,decls:2,vars:0,template:function(e,i){1&e&&(xi(CNe),Vn(0),Vn(1,1))},styles:[".cdk-high-contrast-active .mat-toolbar{outline:solid 1px}.mat-toolbar-row,.mat-toolbar-single-row{display:flex;box-sizing:border-box;padding:0 16px;width:100%;flex-direction:row;align-items:center;white-space:nowrap}.mat-toolbar-multiple-rows{display:flex;box-sizing:border-box;flex-direction:column;width:100%}"],encapsulation:2,changeDetection:0}),n})(),Jne=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[ln,ln]}),n})();function QH(n){return n.state!==Oe.NOT_LOADED&&n.state!==Oe.LOADING}var TNe=vr(Ree,Se(XI,n=>QH(n)?{...n,settings:{...n.settings,reloadEnabled:!n.settings.reloadEnabled}}:n),Se(QI,(n,{periodInMs:t})=>{if(!QH(n))return n;let e=t>=3e4?t:n.settings.reloadPeriodInMs;return{...n,settings:{...n.settings,reloadPeriodInMs:e}}}),Se(KI,(n,{size:t})=>{if(!QH(n))return n;let e=t>0?t:n.settings.pageSize;return{...n,settings:{...n.settings,pageSize:e}}}),Se(Yc,(n,{partialSettings:t})=>{let e={};return Number.isFinite(t.pageSize)&&t.pageSize>0&&(e.pageSize=Number(t.pageSize)),"boolean"==typeof t.autoReload&&(e.reloadEnabled=t.autoReload),Number.isFinite(t.autoReloadPeriodInMs)&&t.autoReloadPeriodInMs>3e4&&(e.reloadPeriodInMs=Number(t.autoReloadPeriodInMs)),{...n,settings:{...n.settings,...e}}}));function $ne(n,t){return TNe(n,t)}var DNe=["input"],ANe=["label"],INe=function(n){return{enterDuration:n}},PNe=["*"],RNe=new pe("mat-checkbox-default-options",{providedIn:"root",factory:function(){return{color:"accent",clickAction:"check-indeterminate"}}});var ONe=0,eie={color:"accent",clickAction:"check-indeterminate"},kNe={provide:No,useExisting:Jn(()=>yl),multi:!0},FNe=oc(ko(qo(so(class{constructor(n){this._elementRef=n}})))),NNe=(()=>{class n extends FNe{constructor(e,i,r,o,s,a,l){super(i),this._changeDetectorRef=r,this._ngZone=o,this._animationMode=a,this._options=l,this.ariaLabel="",this.ariaLabelledby=null,this.labelPosition="after",this.name=null,this.change=new G,this.indeterminateChange=new G,this._onTouched=()=>{},this._currentAnimationClass="",this._currentCheckState=0,this._controlValueAccessorChangeFn=()=>{},this._checked=!1,this._disabled=!1,this._indeterminate=!1,this._options=this._options||eie,this.color=this.defaultColor=this._options.color||eie.color,this.tabIndex=parseInt(s)||0,this.id=this._uniqueId=`${e}${++ONe}`}get inputId(){return`${this.id||this._uniqueId}-input`}get required(){return this._required}set required(e){this._required=Rt(e)}ngAfterViewInit(){this._syncIndeterminate(this._indeterminate)}get checked(){return this._checked}set checked(e){let i=Rt(e);i!=this.checked&&(this._checked=i,this._changeDetectorRef.markForCheck())}get disabled(){return this._disabled}set disabled(e){let i=Rt(e);i!==this.disabled&&(this._disabled=i,this._changeDetectorRef.markForCheck())}get indeterminate(){return this._indeterminate}set indeterminate(e){let i=e!=this._indeterminate;this._indeterminate=Rt(e),i&&(this._transitionCheckState(this._indeterminate?3:this.checked?1:2),this.indeterminateChange.emit(this._indeterminate)),this._syncIndeterminate(this._indeterminate)}_isRippleDisabled(){return this.disableRipple||this.disabled}_onLabelTextChange(){this._changeDetectorRef.detectChanges()}writeValue(e){this.checked=!!e}registerOnChange(e){this._controlValueAccessorChangeFn=e}registerOnTouched(e){this._onTouched=e}setDisabledState(e){this.disabled=e}_getAriaChecked(){return this.checked?"true":this.indeterminate?"mixed":"false"}_transitionCheckState(e){let i=this._currentCheckState,r=this._getAnimationTargetElement();if(i!==e&&r&&(this._currentAnimationClass&&r.classList.remove(this._currentAnimationClass),this._currentAnimationClass=this._getAnimationClassForCheckStateTransition(i,e),this._currentCheckState=e,this._currentAnimationClass.length>0)){r.classList.add(this._currentAnimationClass);let o=this._currentAnimationClass;this._ngZone.runOutsideAngular(()=>{setTimeout(()=>{r.classList.remove(o)},1e3)})}}_emitChangeEvent(){this._controlValueAccessorChangeFn(this.checked),this.change.emit(this._createChangeEvent(this.checked)),this._inputElement&&(this._inputElement.nativeElement.checked=this.checked)}toggle(){this.checked=!this.checked,this._controlValueAccessorChangeFn(this.checked)}_handleInputClick(){let e=this._options?.clickAction;this.disabled||"noop"===e?!this.disabled&&"noop"===e&&(this._inputElement.nativeElement.checked=this.checked,this._inputElement.nativeElement.indeterminate=this.indeterminate):(this.indeterminate&&"check"!==e&&Promise.resolve().then(()=>{this._indeterminate=!1,this.indeterminateChange.emit(this._indeterminate)}),this._checked=!this._checked,this._transitionCheckState(this._checked?1:2),this._emitChangeEvent())}_onInteractionEvent(e){e.stopPropagation()}_onBlur(){Promise.resolve().then(()=>{this._onTouched(),this._changeDetectorRef.markForCheck()})}_getAnimationClassForCheckStateTransition(e,i){if("NoopAnimations"===this._animationMode)return"";switch(e){case 0:if(1===i)return this._animationClasses.uncheckedToChecked;if(3==i)return this._checked?this._animationClasses.checkedToIndeterminate:this._animationClasses.uncheckedToIndeterminate;break;case 2:return 1===i?this._animationClasses.uncheckedToChecked:this._animationClasses.uncheckedToIndeterminate;case 1:return 2===i?this._animationClasses.checkedToUnchecked:this._animationClasses.checkedToIndeterminate;case 3:return 1===i?this._animationClasses.indeterminateToChecked:this._animationClasses.indeterminateToUnchecked}return""}_syncIndeterminate(e){let i=this._inputElement;i&&(i.nativeElement.indeterminate=e)}}return n.\u0275fac=function(e){nl()},n.\u0275dir=He({type:n,viewQuery:function(e,i){if(1&e&&(ot(DNe,5),ot(ANe,5),ot(Yo,5)),2&e){let r;Ne(r=Le())&&(i._inputElement=r.first),Ne(r=Le())&&(i._labelElement=r.first),Ne(r=Le())&&(i.ripple=r.first)}},inputs:{ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],ariaDescribedby:["aria-describedby","ariaDescribedby"],id:"id",required:"required",labelPosition:"labelPosition",name:"name",value:"value",checked:"checked",disabled:"disabled",indeterminate:"indeterminate"},outputs:{change:"change",indeterminateChange:"indeterminateChange"},features:[tt]}),n})(),yl=(()=>{class n extends NNe{constructor(e,i,r,o,s,a,l){super("mat-checkbox-",e,i,o,s,a,l),this._focusMonitor=r,this._animationClasses={uncheckedToChecked:"mat-checkbox-anim-unchecked-checked",uncheckedToIndeterminate:"mat-checkbox-anim-unchecked-indeterminate",checkedToUnchecked:"mat-checkbox-anim-checked-unchecked",checkedToIndeterminate:"mat-checkbox-anim-checked-indeterminate",indeterminateToChecked:"mat-checkbox-anim-indeterminate-checked",indeterminateToUnchecked:"mat-checkbox-anim-indeterminate-unchecked"}}_createChangeEvent(e){let i=new class{};return i.source=this,i.checked=e,i}_getAnimationTargetElement(){return this._elementRef.nativeElement}ngAfterViewInit(){super.ngAfterViewInit(),this._focusMonitor.monitor(this._elementRef,!0).subscribe(e=>{e||this._onBlur()})}ngOnDestroy(){this._focusMonitor.stopMonitoring(this._elementRef)}_onInputClick(e){e.stopPropagation(),super._handleInputClick()}focus(e,i){e?this._focusMonitor.focusVia(this._inputElement,e,i):this._inputElement.nativeElement.focus(i)}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(nn),M(Fr),M(_t),vo("tabindex"),M(Pi,8),M(RNe,8))},n.\u0275cmp=R({type:n,selectors:[["mat-checkbox"]],hostAttrs:[1,"mat-checkbox"],hostVars:14,hostBindings:function(e,i){2&e&&(_s("id",i.id),ze("tabindex",null)("aria-label",null)("aria-labelledby",null),et("mat-checkbox-indeterminate",i.indeterminate)("mat-checkbox-checked",i.checked)("mat-checkbox-disabled",i.disabled)("mat-checkbox-label-before","before"==i.labelPosition)("_mat-animation-noopable","NoopAnimations"===i._animationMode))},inputs:{disableRipple:"disableRipple",color:"color",tabIndex:"tabIndex"},exportAs:["matCheckbox"],features:[$t([kNe]),tt],ngContentSelectors:PNe,decls:17,vars:21,consts:[[1,"mat-checkbox-layout"],["label",""],[1,"mat-checkbox-inner-container"],["type","checkbox",1,"mat-checkbox-input","cdk-visually-hidden",3,"id","required","checked","disabled","tabIndex","change","click"],["input",""],["matRipple","",1,"mat-checkbox-ripple","mat-focus-indicator",3,"matRippleTrigger","matRippleDisabled","matRippleRadius","matRippleCentered","matRippleAnimation"],[1,"mat-ripple-element","mat-checkbox-persistent-ripple"],[1,"mat-checkbox-frame"],[1,"mat-checkbox-background"],["version","1.1","focusable","false","viewBox","0 0 24 24","aria-hidden","true",1,"mat-checkbox-checkmark"],["fill","none","stroke","white","d","M4.1,12.7 9,17.6 20.3,6.3",1,"mat-checkbox-checkmark-path"],[1,"mat-checkbox-mixedmark"],[1,"mat-checkbox-label",3,"cdkObserveContent"],["checkboxLabel",""],[2,"display","none"]],template:function(e,i){if(1&e&&(xi(),_(0,"label",0,1)(2,"span",2)(3,"input",3,4),P("change",function(o){return i._onInteractionEvent(o)})("click",function(o){return i._onInputClick(o)}),v(),_(5,"span",5),O(6,"span",6),v(),O(7,"span",7),_(8,"span",8),In(),_(9,"svg",9),O(10,"path",10),v(),Js(),O(11,"span",11),v()(),_(12,"span",12,13),P("cdkObserveContent",function(){return i._onLabelTextChange()}),_(14,"span",14),A(15,"\xa0"),v(),Vn(16),v()()),2&e){let r=$e(1),o=$e(13);ze("for",i.inputId),C(2),et("mat-checkbox-inner-container-no-side-margin",!o.textContent||!o.textContent.trim()),C(1),y("id",i.inputId)("required",i.required)("checked",i.checked)("disabled",i.disabled)("tabIndex",i.tabIndex),ze("value",i.value)("name",i.name)("aria-label",i.ariaLabel||null)("aria-labelledby",i.ariaLabelledby)("aria-checked",i._getAriaChecked())("aria-describedby",i.ariaDescribedby),C(2),y("matRippleTrigger",r)("matRippleDisabled",i._isRippleDisabled())("matRippleRadius",20)("matRippleCentered",!0)("matRippleAnimation",On(19,INe,"NoopAnimations"===i._animationMode?0:150))}},dependencies:[Yo,wh],styles:['@keyframes mat-checkbox-fade-in-background{0%{opacity:0}50%{opacity:1}}@keyframes mat-checkbox-fade-out-background{0%,50%{opacity:1}100%{opacity:0}}@keyframes mat-checkbox-unchecked-checked-checkmark-path{0%,50%{stroke-dashoffset:22.910259}50%{animation-timing-function:cubic-bezier(0, 0, 0.2, 0.1)}100%{stroke-dashoffset:0}}@keyframes mat-checkbox-unchecked-indeterminate-mixedmark{0%,68.2%{transform:scaleX(0)}68.2%{animation-timing-function:cubic-bezier(0, 0, 0, 1)}100%{transform:scaleX(1)}}@keyframes mat-checkbox-checked-unchecked-checkmark-path{from{animation-timing-function:cubic-bezier(0.4, 0, 1, 1);stroke-dashoffset:0}to{stroke-dashoffset:-22.910259}}@keyframes mat-checkbox-checked-indeterminate-checkmark{from{animation-timing-function:cubic-bezier(0, 0, 0.2, 0.1);opacity:1;transform:rotate(0deg)}to{opacity:0;transform:rotate(45deg)}}@keyframes mat-checkbox-indeterminate-checked-checkmark{from{animation-timing-function:cubic-bezier(0.14, 0, 0, 1);opacity:0;transform:rotate(45deg)}to{opacity:1;transform:rotate(360deg)}}@keyframes mat-checkbox-checked-indeterminate-mixedmark{from{animation-timing-function:cubic-bezier(0, 0, 0.2, 0.1);opacity:0;transform:rotate(-45deg)}to{opacity:1;transform:rotate(0deg)}}@keyframes mat-checkbox-indeterminate-checked-mixedmark{from{animation-timing-function:cubic-bezier(0.14, 0, 0, 1);opacity:1;transform:rotate(0deg)}to{opacity:0;transform:rotate(315deg)}}@keyframes mat-checkbox-indeterminate-unchecked-mixedmark{0%{animation-timing-function:linear;opacity:1;transform:scaleX(1)}32.8%,100%{opacity:0;transform:scaleX(0)}}.mat-checkbox-background,.mat-checkbox-frame{top:0;left:0;right:0;bottom:0;position:absolute;border-radius:2px;box-sizing:border-box;pointer-events:none}.mat-checkbox{display:inline-block;transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);cursor:pointer;-webkit-tap-highlight-color:rgba(0,0,0,0);position:relative}.mat-checkbox._mat-animation-noopable{transition:none !important;animation:none !important}.mat-checkbox .mat-ripple-element:not(.mat-checkbox-persistent-ripple){opacity:.16}.mat-checkbox .mat-checkbox-ripple{position:absolute;left:calc(50% - 20px);top:calc(50% - 20px);height:40px;width:40px;z-index:1;pointer-events:none}.mat-checkbox-layout{-webkit-user-select:none;user-select:none;cursor:inherit;align-items:baseline;vertical-align:middle;display:inline-flex;white-space:nowrap}.mat-checkbox-label{-webkit-user-select:auto;user-select:auto}.mat-checkbox-inner-container{display:inline-block;height:16px;line-height:0;margin:auto;margin-right:8px;order:0;position:relative;vertical-align:middle;white-space:nowrap;width:16px;flex-shrink:0}[dir=rtl] .mat-checkbox-inner-container{margin-left:8px;margin-right:auto}.mat-checkbox-inner-container-no-side-margin{margin-left:0;margin-right:0}.mat-checkbox-frame{background-color:rgba(0,0,0,0);transition:border-color 90ms cubic-bezier(0, 0, 0.2, 0.1);border-width:2px;border-style:solid}._mat-animation-noopable .mat-checkbox-frame{transition:none}.mat-checkbox-background{align-items:center;display:inline-flex;justify-content:center;transition:background-color 90ms cubic-bezier(0, 0, 0.2, 0.1),opacity 90ms cubic-bezier(0, 0, 0.2, 0.1);-webkit-print-color-adjust:exact;color-adjust:exact}._mat-animation-noopable .mat-checkbox-background{transition:none}.cdk-high-contrast-active .mat-checkbox .mat-checkbox-background{background:none}.mat-checkbox-persistent-ripple{display:block;width:100%;height:100%;transform:none}.mat-checkbox-inner-container:hover .mat-checkbox-persistent-ripple{opacity:.04}.mat-checkbox.cdk-keyboard-focused .mat-checkbox-persistent-ripple{opacity:.12}.mat-checkbox-persistent-ripple,.mat-checkbox.mat-checkbox-disabled .mat-checkbox-inner-container:hover .mat-checkbox-persistent-ripple{opacity:0}@media(hover: none){.mat-checkbox-inner-container:hover .mat-checkbox-persistent-ripple{display:none}}.mat-checkbox-checkmark{top:0;left:0;right:0;bottom:0;position:absolute;width:100%}.mat-checkbox-checkmark-path{stroke-dashoffset:22.910259;stroke-dasharray:22.910259;stroke-width:2.1333333333px}.cdk-high-contrast-black-on-white .mat-checkbox-checkmark-path{stroke:#000 !important}.mat-checkbox-mixedmark{width:calc(100% - 6px);height:2px;opacity:0;transform:scaleX(0) rotate(0deg);border-radius:2px}.cdk-high-contrast-active .mat-checkbox-mixedmark{height:0;border-top:solid 2px;margin-top:2px}.mat-checkbox-label-before .mat-checkbox-inner-container{order:1;margin-left:8px;margin-right:auto}[dir=rtl] .mat-checkbox-label-before .mat-checkbox-inner-container{margin-left:auto;margin-right:8px}.mat-checkbox-checked .mat-checkbox-checkmark{opacity:1}.mat-checkbox-checked .mat-checkbox-checkmark-path{stroke-dashoffset:0}.mat-checkbox-checked .mat-checkbox-mixedmark{transform:scaleX(1) rotate(-45deg)}.mat-checkbox-indeterminate .mat-checkbox-checkmark{opacity:0;transform:rotate(45deg)}.mat-checkbox-indeterminate .mat-checkbox-checkmark-path{stroke-dashoffset:0}.mat-checkbox-indeterminate .mat-checkbox-mixedmark{opacity:1;transform:scaleX(1) rotate(0deg)}.mat-checkbox-unchecked .mat-checkbox-background{background-color:rgba(0,0,0,0)}.mat-checkbox-disabled{cursor:default}.cdk-high-contrast-active .mat-checkbox-disabled{opacity:.5}.mat-checkbox-anim-unchecked-checked .mat-checkbox-background{animation:180ms linear 0ms mat-checkbox-fade-in-background}.mat-checkbox-anim-unchecked-checked .mat-checkbox-checkmark-path{animation:180ms linear 0ms mat-checkbox-unchecked-checked-checkmark-path}.mat-checkbox-anim-unchecked-indeterminate .mat-checkbox-background{animation:180ms linear 0ms mat-checkbox-fade-in-background}.mat-checkbox-anim-unchecked-indeterminate .mat-checkbox-mixedmark{animation:90ms linear 0ms mat-checkbox-unchecked-indeterminate-mixedmark}.mat-checkbox-anim-checked-unchecked .mat-checkbox-background{animation:180ms linear 0ms mat-checkbox-fade-out-background}.mat-checkbox-anim-checked-unchecked .mat-checkbox-checkmark-path{animation:90ms linear 0ms mat-checkbox-checked-unchecked-checkmark-path}.mat-checkbox-anim-checked-indeterminate .mat-checkbox-checkmark{animation:90ms linear 0ms mat-checkbox-checked-indeterminate-checkmark}.mat-checkbox-anim-checked-indeterminate .mat-checkbox-mixedmark{animation:90ms linear 0ms mat-checkbox-checked-indeterminate-mixedmark}.mat-checkbox-anim-indeterminate-checked .mat-checkbox-checkmark{animation:500ms linear 0ms mat-checkbox-indeterminate-checked-checkmark}.mat-checkbox-anim-indeterminate-checked .mat-checkbox-mixedmark{animation:500ms linear 0ms mat-checkbox-indeterminate-checked-mixedmark}.mat-checkbox-anim-indeterminate-unchecked .mat-checkbox-background{animation:180ms linear 0ms mat-checkbox-fade-out-background}.mat-checkbox-anim-indeterminate-unchecked .mat-checkbox-mixedmark{animation:300ms linear 0ms mat-checkbox-indeterminate-unchecked-mixedmark}.mat-checkbox-input{bottom:0;left:50%}.mat-checkbox-input:focus~.mat-focus-indicator::before{content:""}'],encapsulation:2,changeDetection:0}),n})(),LNe={provide:Lo,useExisting:Jn(()=>BNe),multi:!0},BNe=(()=>{class n extends gw{}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275dir=He({type:n,selectors:[["mat-checkbox","required","","formControlName",""],["mat-checkbox","required","","formControl",""],["mat-checkbox","required","","ngModel",""]],features:[$t([LNe]),tt]}),n})(),tie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),Ls=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[_l,ln,od,tie,ln,tie]}),n})(),iie=la({passive:!0}),rie=(()=>{class n{constructor(e,i){this._platform=e,this._ngZone=i,this._monitoredElements=new Map}monitor(e){if(!this._platform.isBrowser)return eo;let i=La(e),r=this._monitoredElements.get(i);if(r)return r.subject;let o=new ke,s="cdk-text-field-autofilled",a=l=>{"cdk-text-field-autofill-start"!==l.animationName||i.classList.contains(s)?"cdk-text-field-autofill-end"===l.animationName&&i.classList.contains(s)&&(i.classList.remove(s),this._ngZone.run(()=>o.next({target:l.target,isAutofilled:!1}))):(i.classList.add(s),this._ngZone.run(()=>o.next({target:l.target,isAutofilled:!0})))};return this._ngZone.runOutsideAngular(()=>{i.addEventListener("animationstart",a,iie),i.classList.add("cdk-text-field-autofill-monitored")}),this._monitoredElements.set(i,{subject:o,unlisten:()=>{i.removeEventListener("animationstart",a,iie)}}),o}stopMonitoring(e){let i=La(e),r=this._monitoredElements.get(i);r&&(r.unlisten(),r.subject.complete(),i.classList.remove("cdk-text-field-autofill-monitored"),i.classList.remove("cdk-text-field-autofilled"),this._monitoredElements.delete(i))}ngOnDestroy(){this._monitoredElements.forEach((e,i)=>this.stopMonitoring(i))}}return n.\u0275fac=function(e){return new(e||n)(j(oi),j(_t))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),ZH=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),HNe=new pe("MAT_INPUT_VALUE_ACCESSOR"),UNe=["button","checkbox","file","hidden","image","radio","range","reset","submit"],zNe=0,jNe=Dv(class{constructor(n,t,e,i){this._defaultErrorStateMatcher=n,this._parentForm=t,this._parentFormGroup=e,this.ngControl=i,this.stateChanges=new ke}}),Uh=(()=>{class n extends jNe{constructor(e,i,r,o,s,a,l,c,u,d){super(a,o,s,r),this._elementRef=e,this._platform=i,this._autofillMonitor=c,this._formField=d,this._uid="mat-input-"+zNe++,this.focused=!1,this.stateChanges=new ke,this.controlType="mat-input",this.autofilled=!1,this._disabled=!1,this._type="text",this._readonly=!1,this._neverEmptyInputTypes=["date","datetime","datetime-local","month","time","week"].filter(f=>pH().has(f)),this._iOSKeyupListener=f=>{let m=f.target;!m.value&&0===m.selectionStart&&0===m.selectionEnd&&(m.setSelectionRange(1,1),m.setSelectionRange(0,0))};let p=this._elementRef.nativeElement,h=p.nodeName.toLowerCase();this._inputValueAccessor=l||p,this._previousNativeValue=this.value,this.id=this.id,i.IOS&&u.runOutsideAngular(()=>{e.nativeElement.addEventListener("keyup",this._iOSKeyupListener)}),this._isServer=!this._platform.isBrowser,this._isNativeSelect="select"===h,this._isTextarea="textarea"===h,this._isInFormField=!!d,this._isNativeSelect&&(this.controlType=p.multiple?"mat-native-select-multiple":"mat-native-select")}get disabled(){return this.ngControl&&null!==this.ngControl.disabled?this.ngControl.disabled:this._disabled}set disabled(e){this._disabled=Rt(e),this.focused&&(this.focused=!1,this.stateChanges.next())}get id(){return this._id}set id(e){this._id=e||this._uid}get required(){return this._required??this.ngControl?.control?.hasValidator(Fo.required)??!1}set required(e){this._required=Rt(e)}get type(){return this._type}set type(e){this._type=e||"text",this._validateType(),!this._isTextarea&&pH().has(this._type)&&(this._elementRef.nativeElement.type=this._type)}get value(){return this._inputValueAccessor.value}set value(e){e!==this.value&&(this._inputValueAccessor.value=e,this.stateChanges.next())}get readonly(){return this._readonly}set readonly(e){this._readonly=Rt(e)}ngAfterViewInit(){this._platform.isBrowser&&this._autofillMonitor.monitor(this._elementRef.nativeElement).subscribe(e=>{this.autofilled=e.isAutofilled,this.stateChanges.next()})}ngOnChanges(){this.stateChanges.next()}ngOnDestroy(){this.stateChanges.complete(),this._platform.isBrowser&&this._autofillMonitor.stopMonitoring(this._elementRef.nativeElement),this._platform.IOS&&this._elementRef.nativeElement.removeEventListener("keyup",this._iOSKeyupListener)}ngDoCheck(){this.ngControl&&this.updateErrorState(),this._dirtyCheckNativeValue(),this._dirtyCheckPlaceholder()}focus(e){this._elementRef.nativeElement.focus(e)}_focusChanged(e){e!==this.focused&&(this.focused=e,this.stateChanges.next())}_onInput(){}_dirtyCheckPlaceholder(){let e=this._formField,i=e&&"legacy"===e.appearance&&!e._hasLabel?.()?null:this.placeholder;if(i!==this._previousPlaceholder){let r=this._elementRef.nativeElement;this._previousPlaceholder=i,i?r.setAttribute("placeholder",i):r.removeAttribute("placeholder")}}_dirtyCheckNativeValue(){let e=this._elementRef.nativeElement.value;this._previousNativeValue!==e&&(this._previousNativeValue=e,this.stateChanges.next())}_validateType(){UNe.indexOf(this._type)}_isNeverEmpty(){return this._neverEmptyInputTypes.indexOf(this._type)>-1}_isBadInput(){let e=this._elementRef.nativeElement.validity;return e&&e.badInput}get empty(){return!(this._isNeverEmpty()||this._elementRef.nativeElement.value||this._isBadInput()||this.autofilled)}get shouldLabelFloat(){if(this._isNativeSelect){let e=this._elementRef.nativeElement,i=e.options[0];return this.focused||e.multiple||!this.empty||!!(e.selectedIndex>-1&&i&&i.label)}return this.focused||!this.empty}setDescribedByIds(e){e.length?this._elementRef.nativeElement.setAttribute("aria-describedby",e.join(" ")):this._elementRef.nativeElement.removeAttribute("aria-describedby")}onContainerClick(){this.focused||this.focus()}_isInlineSelect(){let e=this._elementRef.nativeElement;return this._isNativeSelect&&(e.multiple||e.size>1)}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(oi),M(Ns,10),M(Lh,8),M(Vh,8),M(cd),M(HNe,10),M(rie),M(_t),M(sg,8))},n.\u0275dir=He({type:n,selectors:[["input","matInput",""],["textarea","matInput",""],["select","matNativeControl",""],["input","matNativeControl",""],["textarea","matNativeControl",""]],hostAttrs:[1,"mat-input-element","mat-form-field-autofill-control"],hostVars:12,hostBindings:function(e,i){1&e&&P("focus",function(){return i._focusChanged(!0)})("blur",function(){return i._focusChanged(!1)})("input",function(){return i._onInput()}),2&e&&(_s("disabled",i.disabled)("required",i.required),ze("id",i.id)("data-placeholder",i.placeholder)("name",i.name||null)("readonly",i.readonly&&!i._isNativeSelect||null)("aria-invalid",i.empty&&i.required?null:i.errorState)("aria-required",i.required),et("mat-input-server",i._isServer)("mat-native-select-inline",i._isInlineSelect()))},inputs:{disabled:"disabled",id:"id",placeholder:"placeholder",name:"name",required:"required",type:"type",errorStateMatcher:"errorStateMatcher",userAriaDescribedBy:["aria-describedby","userAriaDescribedBy"],value:"value",readonly:"readonly"},exportAs:["matInput"],features:[$t([{provide:kh,useExisting:n}]),tt,Ft]}),n})(),Ha=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[cd],imports:[ZH,ag,ln,ZH,ag]}),n})();function GNe(n,t){if(1&n&&(_(0,"mat-error"),A(1),v()),2&n){let e=S();C(1),je(" Reload period has to be minimum of ",e.MIN_RELOAD_PERIOD_IN_S," seconds. ")}}function WNe(n,t){1&n&&(_(0,"mat-error"),A(1," Page size has to be a positive integer. "),v())}var oie=(()=>{class n{constructor(){this.reloadToggled=new G,this.reloadPeriodInMsChanged=new G,this.pageSizeChanged=new G,this.MIN_RELOAD_PERIOD_IN_S=30,this.reloadPeriodControl=new Bh(this.MIN_RELOAD_PERIOD_IN_S,[Fo.required,Fo.min(this.MIN_RELOAD_PERIOD_IN_S)]),this.paginationControl=new Bh(1,[Fo.required,Fo.min(1),n=>{let t=Number(n.value);return Math.round(t)===n.value?null:{integer:{value:n.value}}}]),this.ngUnsubscribe=new ke}ngOnInit(){this.reloadPeriodControl.valueChanges.pipe(st(this.ngUnsubscribe),Hr(500),Ye(()=>this.reloadPeriodControl.valid)).subscribe(()=>{this.reloadPeriodControl.valid&&this.reloadPeriodInMsChanged.emit(1e3*this.reloadPeriodControl.value)}),this.paginationControl.valueChanges.pipe(st(this.ngUnsubscribe),Hr(500),Ye(()=>this.paginationControl.valid)).subscribe(()=>{this.pageSizeChanged.emit(this.paginationControl.value)})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}ngOnChanges(e){if(e.reloadPeriodInMs){let i=e.reloadPeriodInMs;i.previousValue!==i.currentValue&&this.reloadPeriodControl.setValue(i.currentValue/1e3)}if(e.reloadEnabled&&(e.reloadEnabled.currentValue?this.reloadPeriodControl.enable():this.reloadPeriodControl.disable()),e.pageSize){let i=e.pageSize;i.previousValue!==i.currentValue&&this.paginationControl.setValue(i.currentValue)}}onReloadToggle(){this.reloadToggled.emit()}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["settings-dialog-component"]],inputs:{reloadEnabled:"reloadEnabled",reloadPeriodInMs:"reloadPeriodInMs",pageSize:"pageSize"},outputs:{reloadToggled:"reloadToggled",reloadPeriodInMsChanged:"reloadPeriodInMsChanged",pageSizeChanged:"pageSizeChanged"},features:[Ft],decls:14,vars:5,consts:[[1,"reload-toggle"],[3,"checked","change"],["matInput","","type","number","placeholder","Reload Period (seconds)",1,"reload-period",3,"formControl"],[4,"ngIf"],["matInput","","type","number","placeholder","Pagination Limit",1,"page-size",3,"formControl"]],template:function(e,i){1&e&&(_(0,"h3"),A(1,"Settings"),v(),_(2,"div")(3,"div",0)(4,"mat-checkbox",1),P("change",function(){return i.onReloadToggle()}),A(5,"Reload data"),v()(),_(6,"div")(7,"mat-form-field"),O(8,"input",2),v(),E(9,GNe,2,1,"mat-error",3),v()(),_(10,"div")(11,"mat-form-field"),O(12,"input",4),v(),E(13,WNe,2,0,"mat-error",3),v()),2&e&&(C(4),y("checked",i.reloadEnabled),C(4),y("formControl",i.reloadPeriodControl),C(1),y("ngIf",i.reloadPeriodControl.hasError("min")||i.reloadPeriodControl.hasError("required")),C(3),y("formControl",i.paginationControl),C(1),y("ngIf",i.paginationControl.invalid))},dependencies:[Be,Bv,qH,V2,mw,yl,Hte,pd,Uh],styles:["[_nghost-%COMP%] {\n  font-size: 15px;\n}\n\n[_nghost-%COMP%]    > div[_ngcontent-%COMP%] {\n  margin: 10px 0;\n}\n\n[_nghost-%COMP%]    > [_ngcontent-%COMP%]:first-child {\n  margin-top: 0;\n}\n\n[_nghost-%COMP%]    > [_ngcontent-%COMP%]:last-child {\n  margin-bottom: 0;\n}\n\nh3[_ngcontent-%COMP%] {\n  font-size: 20px;\n}\n\n.reload-toggle[_ngcontent-%COMP%] {\n  margin-bottom: 10px;\n}"]}),n})(),sie=(()=>{class n{constructor(e){this.store=e,this.reloadEnabled$=this.store.select(YM),this.reloadPeriodInMs$=this.store.select(XM),this.pageSize$=this.store.select(Km)}onReloadToggled(){this.store.dispatch(XI())}onReloadPeriodInMsChanged(e){this.store.dispatch(QI({periodInMs:e}))}onPageSizeChanged(e){this.store.dispatch(KI({size:e}))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["settings-dialog"]],decls:4,vars:9,consts:[[3,"reloadEnabled","reloadPeriodInMs","pageSize","reloadToggled","reloadPeriodInMsChanged","pageSizeChanged"]],template:function(e,i){1&e&&(_(0,"settings-dialog-component",0),P("reloadToggled",function(){return i.onReloadToggled()})("reloadPeriodInMsChanged",function(o){return i.onReloadPeriodInMsChanged(o)})("pageSizeChanged",function(o){return i.onPageSizeChanged(o)}),B(1,"async"),B(2,"async"),B(3,"async"),v()),2&e&&y("reloadEnabled",U(1,3,i.reloadEnabled$))("reloadPeriodInMs",U(2,5,i.reloadPeriodInMs$))("pageSize",U(3,7,i.pageSize$))},dependencies:[oie,Ge],encapsulation:2}),n})(),aie=(()=>{class n{constructor(e){this.dialog=e}isButtonDisabled(){return this.settingsLoadState===Oe.NOT_LOADED||this.settingsLoadState===Oe.LOADING}openDialog(){this.dialog.open(sie,{width:"400px"})}}return n.\u0275fac=function(e){return new(e||n)(M(vl))},n.\u0275cmp=R({type:n,selectors:[["settings-button-component"]],inputs:{settingsLoadState:"settingsLoadState"},decls:2,vars:1,consts:[["mat-icon-button","",3,"disabled","click"],["svgIcon","settings_24px"]],template:function(e,i){1&e&&(_(0,"button",0),P("click",function(){return i.openDialog()}),O(1,"mat-icon",1),v()),2&e&&y("disabled",i.isButtonDisabled())},dependencies:[_n,Gt],encapsulation:2}),n})(),lie=(()=>{class n{constructor(e){this.store=e,this.settingsLoadState$=this.store.select(lH)}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["settings-button"]],decls:2,vars:3,consts:[[3,"settingsLoadState"]],template:function(e,i){1&e&&(O(0,"settings-button-component",0),B(1,"async")),2&e&&y("settingsLoadState",U(1,1,i.settingsLoadState$))},dependencies:[aie,Ge],encapsulation:2}),n})(),KNe=(()=>{class n{constructor(e){this._document=e}copy(e){let i=this.beginCopy(e),r=i.copy();return i.destroy(),r}beginCopy(e){return new class{constructor(t,e){this._document=e;let i=this._textarea=this._document.createElement("textarea"),r=i.style;r.position="fixed",r.top=r.opacity="0",r.left="-999em",i.setAttribute("aria-hidden","true"),i.value=t,i.readOnly=!0,this._document.body.appendChild(i)}copy(){let t=this._textarea,e=!1;try{if(t){let i=this._document.activeElement;t.select(),t.setSelectionRange(0,t.value.length),e=this._document.execCommand("copy"),i&&i.focus()}}catch{}return e}destroy(){let t=this._textarea;t&&(t.remove(),this._textarea=void 0)}}(e,this._document)}}return n.\u0275fac=function(e){return new(e||n)(j(Ht))},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),ZNe=new pe("CDK_COPY_TO_CLIPBOARD_CONFIG"),cie=(()=>{class n{constructor(e,i,r){this._clipboard=e,this._ngZone=i,this.text="",this.attempts=1,this.copied=new G,this._pending=new Set,r&&null!=r.attempts&&(this.attempts=r.attempts)}copy(e=this.attempts){if(e>1){let i=e,r=this._clipboard.beginCopy(this.text);this._pending.add(r);let o=()=>{let s=r.copy();s||!--i||this._destroyed?(this._currentTimeout=null,this._pending.delete(r),r.destroy(),this.copied.emit(s)):this._currentTimeout=this._ngZone.runOutsideAngular(()=>setTimeout(o,1))};o()}else this.copied.emit(this._clipboard.copy(this.text))}ngOnDestroy(){this._currentTimeout&&clearTimeout(this._currentTimeout),this._pending.forEach(e=>e.destroy()),this._pending.clear(),this._destroyed=!0}}return n.\u0275fac=function(e){return new(e||n)(M(KNe),M(_t),M(ZNe,8))},n.\u0275dir=He({type:n,selectors:[["","cdkCopyToClipboard",""]],hostBindings:function(e,i){1&e&&P("click",function(){return i.copy()})},inputs:{text:["cdkCopyToClipboard","text"],attempts:["cdkCopyToClipboardAttempts","attempts"]},outputs:{copied:"cdkCopyToClipboardCopied"}}),n})(),uie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),die=(()=>{class n{constructor(e){this.dialogRef=e,this.tensorboardDotDevUrl="https://tensorboard.dev/?utm_source=tensorboard"}onClose(){this.dialogRef.close()}getCommandText(){return this.logdir?"tensorboard dev upload --logdir \\\n    '"+this.logdir.replace(/'/g,"'\\''")+"'":"tensorboard dev upload --logdir {logdir}"}}return n.\u0275fac=function(e){return new(e||n)(M(tu))},n.\u0275cmp=R({type:n,selectors:[["tbdev-upload-dialog-component"]],inputs:{logdir:"logdir"},decls:21,vars:4,consts:[["target","_blank","rel","noreferrer noopener",1,"anchor-text",3,"href"],[1,"command"],["mat-icon-button","","title","Click to copy the command",1,"command-copy",3,"cdkCopyToClipboard"],["svgIcon","content_copy_24px"],[1,"bottom-buttons"],["mat-flat-button","",1,"close-button",3,"click"],["mat-flat-button","","target","_blank","rel","noreferrer noopener",1,"learn-more-button",3,"href"]],template:function(e,i){1&e&&(_(0,"h3"),A(1,"Upload to TensorBoard.dev"),v(),_(2,"p")(3,"a",0),A(4," TensorBoard.dev"),v(),A(5," enables you to easily host, track, and share your ML experiments with everyone. You can share a link to the uploaded TensorBoard in papers, blog posts, and social media. This can showcase the results more effectively and helps reproducibility.\n"),v(),_(6,"p"),A(7,"To upload a logdir to TensorBoard.dev, run the command:"),v(),_(8,"div",1)(9,"pre")(10,"code"),A(11),v()(),_(12,"button",2),O(13,"mat-icon",3),v()(),_(14,"p"),A(15," Only certain plugins are currently supported. Uploaded TensorBoards are public and visible to everyone; do not upload sensitive data.\n"),v(),_(16,"div",4)(17,"button",5),P("click",function(){return i.onClose()}),A(18," Close "),v(),_(19,"a",6),A(20," Learn more "),v()()),2&e&&(C(3),Zi("href",i.tensorboardDotDevUrl,zl),C(8),yt(i.getCommandText()),C(1),y("cdkCopyToClipboard",i.getCommandText()),C(7),Zi("href",i.tensorboardDotDevUrl,zl))},dependencies:[cie,_n,Iv,Gt],styles:["div[_ngcontent-%COMP%], p[_ngcontent-%COMP%]{margin:16px 0}[_nghost-%COMP%] > [_ngcontent-%COMP%]:first-child{margin-top:0}[_nghost-%COMP%] > [_ngcontent-%COMP%]:last-child{margin-bottom:0}h3[_ngcontent-%COMP%]{font-size:14px;font-weight:500;line-height:1.5}p[_ngcontent-%COMP%]{color:#212121;font-size:12px;line-height:1.5}body.dark-mode[_nghost-%COMP%]   p[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   p[_ngcontent-%COMP%]{color:#fff}.anchor-text[_ngcontent-%COMP%]{text-decoration:none}.command[_ngcontent-%COMP%]{align-items:center;background:#f5f6f7;border-radius:4px;display:flex;justify-content:space-between;padding:2px 12px}body.dark-mode[_nghost-%COMP%]   .command[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .command[_ngcontent-%COMP%]{background-color:#616161}pre[_ngcontent-%COMP%]{overflow-x:auto}code[_ngcontent-%COMP%]{font-size:14px;line-height:1.5}.bottom-buttons[_ngcontent-%COMP%]{align-items:center;display:flex;justify-content:flex-end}.close-button[_ngcontent-%COMP%]{color:#616161;text-transform:uppercase;margin-right:8px}body.dark-mode[_nghost-%COMP%]   .close-button[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .close-button[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}[_nghost-%COMP%]   .learn-more-button[_ngcontent-%COMP%]{color:#1976d2;text-transform:uppercase}body.dark-mode   [_nghost-%COMP%]   .learn-more-button[_ngcontent-%COMP%]{color:#42a5f5}"]}),n})(),eLe=J(ov,n=>n.data_location),pie=(()=>{class n{constructor(e){this.store=e,this.logdir$=this.store.pipe(vt(eLe))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["tbdev-upload-dialog"]],decls:2,vars:3,consts:[[3,"logdir"]],template:function(e,i){1&e&&(O(0,"tbdev-upload-dialog-component",0),B(1,"async")),2&e&&y("logdir",U(1,1,i.logdir$))},dependencies:[die,Ge],encapsulation:2}),n})();function tLe(n,t){if(1&n){let e=Pe();_(0,"button",1),P("click",function(){return oe(e),se(S().openDialog())}),_(1,"span",2),O(2,"mat-icon",3),A(3," Upload "),v()()}}var nLe=["localhost","127.0.0.1"],hie=(()=>{class n{constructor(e,i){this.window=e,this.dialog=i,this.shown=nLe.includes(e.location.hostname)}openDialog(){this.dialog.open(pie,{width:"560px"})}}return n.\u0275fac=function(e){return new(e||n)(M("window"),M(vl))},n.\u0275cmp=R({type:n,selectors:[["tbdev-upload-button"]],hostVars:2,hostBindings:function(e,i){2&e&&et("shown",i.shown)},decls:1,vars:1,consts:[["mat-stroked-button","",3,"click",4,"ngIf"],["mat-stroked-button","",3,"click"],[1,"button-contents"],["svgIcon","info_outline_24px"]],template:function(e,i){1&e&&E(0,tLe,4,0,"button",0),2&e&&y("ngIf",i.shown)},dependencies:[Be,_n,Gt],styles:["[_nghost-%COMP%]   button.mat-stroked-button[_ngcontent-%COMP%]{background-color:#ff9800;border:1px solid #ebebeb}body.dark-mode   [_nghost-%COMP%]   button.mat-stroked-button[_ngcontent-%COMP%]{background-color:#ef6c00}.button-contents[_ngcontent-%COMP%]{align-items:center;display:flex;text-transform:uppercase}mat-icon[_ngcontent-%COMP%]{margin-right:6px}"]}),n})(),rLe=["mat-menu-item",""];function oLe(n,t){1&n&&(In(),_(0,"svg",2),O(1,"polygon",3),v())}var mie=["*"];function sLe(n,t){if(1&n){let e=Pe();_(0,"div",0),P("keydown",function(r){return oe(e),se(S()._handleKeydown(r))})("click",function(){return oe(e),se(S().closed.emit("click"))})("@transformMenu.start",function(r){return oe(e),se(S()._onAnimationStart(r))})("@transformMenu.done",function(r){return oe(e),se(S()._onAnimationDone(r))}),_(1,"div",1),Vn(2),v()()}if(2&n){let e=S();y("id",e.panelId)("ngClass",e._classList)("@transformMenu",e._panelAnimationState),ze("aria-label",e.ariaLabel||null)("aria-labelledby",e.ariaLabelledby||null)("aria-describedby",e.ariaDescribedby||null)}}var K2={transformMenu:Kr("transformMenu",[ki("void",gn({opacity:0,transform:"scale(0.8)"})),Li("void => enter",ji("120ms cubic-bezier(0, 0, 0.2, 1)",gn({opacity:1,transform:"scale(1)"}))),Li("* => void",ji("100ms 25ms linear",gn({opacity:0})))]),fadeInItems:Kr("fadeInItems",[ki("showing",gn({opacity:1})),Li("void => *",[gn({opacity:0}),ji("400ms 100ms cubic-bezier(0.55, 0, 0.55, 0.2)")])])},aLe=new pe("MatMenuContent"),$H=new pe("MAT_MENU_PANEL"),lLe=qo(so(class{})),nu=(()=>{class n extends lLe{constructor(e,i,r,o,s){super(),this._elementRef=e,this._document=i,this._focusMonitor=r,this._parentMenu=o,this._changeDetectorRef=s,this.role="menuitem",this._hovered=new ke,this._focused=new ke,this._highlighted=!1,this._triggersSubmenu=!1,o?.addItem?.(this)}focus(e,i){this._focusMonitor&&e?this._focusMonitor.focusVia(this._getHostElement(),e,i):this._getHostElement().focus(i),this._focused.next(this)}ngAfterViewInit(){this._focusMonitor&&this._focusMonitor.monitor(this._elementRef,!1)}ngOnDestroy(){this._focusMonitor&&this._focusMonitor.stopMonitoring(this._elementRef),this._parentMenu&&this._parentMenu.removeItem&&this._parentMenu.removeItem(this),this._hovered.complete(),this._focused.complete()}_getTabIndex(){return this.disabled?"-1":"0"}_getHostElement(){return this._elementRef.nativeElement}_checkDisabled(e){this.disabled&&(e.preventDefault(),e.stopPropagation())}_handleMouseEnter(){this._hovered.next(this)}getLabel(){let e=this._elementRef.nativeElement.cloneNode(!0),i=e.querySelectorAll("mat-icon, .material-icons");for(let r=0;r<i.length;r++)i[r].remove();return e.textContent?.trim()||""}_setHighlighted(e){this._highlighted=e,this._changeDetectorRef?.markForCheck()}_hasFocus(){return this._document&&this._document.activeElement===this._getHostElement()}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(Ht),M(Fr),M($H,8),M(nn))},n.\u0275cmp=R({type:n,selectors:[["","mat-menu-item",""]],hostAttrs:[1,"mat-focus-indicator"],hostVars:10,hostBindings:function(e,i){1&e&&P("click",function(o){return i._checkDisabled(o)})("mouseenter",function(){return i._handleMouseEnter()}),2&e&&(ze("role",i.role)("tabindex",i._getTabIndex())("aria-disabled",i.disabled.toString())("disabled",i.disabled||null),et("mat-menu-item",!0)("mat-menu-item-highlighted",i._highlighted)("mat-menu-item-submenu-trigger",i._triggersSubmenu))},inputs:{disabled:"disabled",disableRipple:"disableRipple",role:"role"},exportAs:["matMenuItem"],features:[tt],attrs:rLe,ngContentSelectors:mie,decls:3,vars:3,consts:[["matRipple","",1,"mat-menu-ripple",3,"matRippleDisabled","matRippleTrigger"],["class","mat-menu-submenu-icon","viewBox","0 0 5 10","focusable","false",4,"ngIf"],["viewBox","0 0 5 10","focusable","false",1,"mat-menu-submenu-icon"],["points","0,0 5,5 0,10"]],template:function(e,i){1&e&&(xi(),Vn(0),O(1,"div",0),E(2,oLe,2,0,"svg",1)),2&e&&(C(1),y("matRippleDisabled",i.disableRipple||i.disabled)("matRippleTrigger",i._getHostElement()),C(1),y("ngIf",i._triggersSubmenu))},dependencies:[Be,Yo],encapsulation:2,changeDetection:0}),n})(),gie=new pe("mat-menu-default-options",{providedIn:"root",factory:function(){return{overlapTrigger:!1,xPosition:"after",yPosition:"below",backdropClass:"cdk-overlay-transparent-backdrop"}}}),uLe=0,yw=(()=>{class n{constructor(e,i,r,o){this._elementRef=e,this._ngZone=i,this._defaultOptions=r,this._changeDetectorRef=o,this._xPosition=this._defaultOptions.xPosition,this._yPosition=this._defaultOptions.yPosition,this._directDescendantItems=new Hl,this._tabSubscription=Sn.EMPTY,this._classList={},this._panelAnimationState="void",this._animationDone=new ke,this.overlayPanelClass=this._defaultOptions.overlayPanelClass||"",this.backdropClass=this._defaultOptions.backdropClass,this._overlapTrigger=this._defaultOptions.overlapTrigger,this._hasBackdrop=this._defaultOptions.hasBackdrop,this.closed=new G,this.close=this.closed,this.panelId="mat-menu-panel-"+uLe++}get xPosition(){return this._xPosition}set xPosition(e){this._xPosition=e,this.setPositionClasses()}get yPosition(){return this._yPosition}set yPosition(e){this._yPosition=e,this.setPositionClasses()}get overlapTrigger(){return this._overlapTrigger}set overlapTrigger(e){this._overlapTrigger=Rt(e)}get hasBackdrop(){return this._hasBackdrop}set hasBackdrop(e){this._hasBackdrop=Rt(e)}set panelClass(e){let i=this._previousPanelClass;i&&i.length&&i.split(" ").forEach(r=>{this._classList[r]=!1}),this._previousPanelClass=e,e&&e.length&&(e.split(" ").forEach(r=>{this._classList[r]=!0}),this._elementRef.nativeElement.className="")}get classList(){return this.panelClass}set classList(e){this.panelClass=e}ngOnInit(){this.setPositionClasses()}ngAfterContentInit(){this._updateDirectDescendants(),this._keyManager=new Sh(this._directDescendantItems).withWrap().withTypeAhead().withHomeAndEnd(),this._tabSubscription=this._keyManager.tabOut.subscribe(()=>this.closed.emit("tab")),this._directDescendantItems.changes.pipe(zn(this._directDescendantItems),ui(e=>Jt(...e.map(i=>i._focused)))).subscribe(e=>this._keyManager.updateActiveItem(e)),this._directDescendantItems.changes.subscribe(e=>{let i=this._keyManager;if("enter"===this._panelAnimationState&&i.activeItem?._hasFocus()){let r=e.toArray(),o=Math.max(0,Math.min(r.length-1,i.activeItemIndex||0));r[o]&&!r[o].disabled?i.setActiveItem(o):i.setNextItemActive()}})}ngOnDestroy(){this._directDescendantItems.destroy(),this._tabSubscription.unsubscribe(),this.closed.complete()}_hovered(){return this._directDescendantItems.changes.pipe(zn(this._directDescendantItems),ui(i=>Jt(...i.map(r=>r._hovered))))}addItem(e){}removeItem(e){}_handleKeydown(e){let i=e.keyCode,r=this._keyManager;switch(i){case 27:kr(e)||(e.preventDefault(),this.closed.emit("keydown"));break;case 37:this.parentMenu&&"ltr"===this.direction&&this.closed.emit("keydown");break;case 39:this.parentMenu&&"rtl"===this.direction&&this.closed.emit("keydown");break;default:return(38===i||40===i)&&r.setFocusOrigin("keyboard"),void r.onKeydown(e)}e.stopPropagation()}focusFirstItem(e="program"){this._ngZone.onStable.pipe(Qt(1)).subscribe(()=>{let i=null;if(this._directDescendantItems.length&&(i=this._directDescendantItems.first._getHostElement().closest('[role="menu"]')),!i||!i.contains(document.activeElement)){let r=this._keyManager;r.setFocusOrigin(e).setFirstItemActive(),!r.activeItem&&i&&i.focus()}})}resetActiveItem(){this._keyManager.setActiveItem(-1)}setElevation(e){let i=Math.min(this._baseElevation+e,24),r=`${this._elevationPrefix}${i}`,o=Object.keys(this._classList).find(s=>s.startsWith(this._elevationPrefix));(!o||o===this._previousElevation)&&(this._previousElevation&&(this._classList[this._previousElevation]=!1),this._classList[r]=!0,this._previousElevation=r)}setPositionClasses(e=this.xPosition,i=this.yPosition){let r=this._classList;r["mat-menu-before"]="before"===e,r["mat-menu-after"]="after"===e,r["mat-menu-above"]="above"===i,r["mat-menu-below"]="below"===i,this._changeDetectorRef?.markForCheck()}_startAnimation(){this._panelAnimationState="enter"}_resetAnimation(){this._panelAnimationState="void"}_onAnimationDone(e){this._animationDone.next(e),this._isAnimating=!1}_onAnimationStart(e){this._isAnimating=!0,"enter"===e.toState&&0===this._keyManager.activeItemIndex&&(e.element.scrollTop=0)}_updateDirectDescendants(){this._allItems.changes.pipe(zn(this._allItems)).subscribe(e=>{this._directDescendantItems.reset(e.filter(i=>i._parentMenu===this)),this._directDescendantItems.notifyOnChanges()})}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(_t),M(gie),M(nn))},n.\u0275dir=He({type:n,contentQueries:function(e,i,r){if(1&e&&(Ei(r,aLe,5),Ei(r,nu,5),Ei(r,nu,4)),2&e){let o;Ne(o=Le())&&(i.lazyContent=o.first),Ne(o=Le())&&(i._allItems=o),Ne(o=Le())&&(i.items=o)}},viewQuery:function(e,i){if(1&e&&ot(Vi,5),2&e){let r;Ne(r=Le())&&(i.templateRef=r.first)}},inputs:{backdropClass:"backdropClass",ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],ariaDescribedby:["aria-describedby","ariaDescribedby"],xPosition:"xPosition",yPosition:"yPosition",overlapTrigger:"overlapTrigger",hasBackdrop:"hasBackdrop",panelClass:["class","panelClass"],classList:"classList"},outputs:{closed:"closed",close:"close"}}),n})(),hd=(()=>{class n extends yw{constructor(e,i,r,o){super(e,i,r,o),this._elevationPrefix="mat-elevation-z",this._baseElevation=4}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(_t),M(gie),M(nn))},n.\u0275cmp=R({type:n,selectors:[["mat-menu"]],hostVars:3,hostBindings:function(e,i){2&e&&ze("aria-label",null)("aria-labelledby",null)("aria-describedby",null)},exportAs:["matMenu"],features:[$t([{provide:$H,useExisting:n}]),tt],ngContentSelectors:mie,decls:1,vars:0,consts:[["tabindex","-1","role","menu",1,"mat-menu-panel",3,"id","ngClass","keydown","click"],[1,"mat-menu-content"]],template:function(e,i){1&e&&(xi(),E(0,sLe,3,6,"ng-template"))},dependencies:[Fn],styles:['mat-menu{display:none}.mat-menu-panel{min-width:112px;max-width:280px;overflow:auto;-webkit-overflow-scrolling:touch;max-height:calc(100vh - 48px);border-radius:4px;outline:0;min-height:64px;position:relative}.mat-menu-panel.ng-animating{pointer-events:none}.cdk-high-contrast-active .mat-menu-panel{outline:solid 1px}.mat-menu-content:not(:empty){padding-top:8px;padding-bottom:8px}.mat-menu-item{-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:rgba(0,0,0,0);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;line-height:48px;height:48px;padding:0 16px;text-align:left;text-decoration:none;max-width:100%;position:relative}.mat-menu-item::-moz-focus-inner{border:0}.mat-menu-item[disabled]{cursor:default}[dir=rtl] .mat-menu-item{text-align:right}.mat-menu-item .mat-icon{margin-right:16px;vertical-align:middle}.mat-menu-item .mat-icon svg{vertical-align:top}[dir=rtl] .mat-menu-item .mat-icon{margin-left:16px;margin-right:0}.mat-menu-item[disabled]::after{display:block;position:absolute;content:"";top:0;left:0;bottom:0;right:0}.cdk-high-contrast-active .mat-menu-item{margin-top:1px}.mat-menu-item-submenu-trigger{padding-right:32px}[dir=rtl] .mat-menu-item-submenu-trigger{padding-right:16px;padding-left:32px}.mat-menu-submenu-icon{position:absolute;top:50%;right:16px;transform:translateY(-50%);width:5px;height:10px;fill:currentColor}[dir=rtl] .mat-menu-submenu-icon{right:auto;left:16px;transform:translateY(-50%) scaleX(-1)}.cdk-high-contrast-active .mat-menu-submenu-icon{fill:CanvasText}button.mat-menu-item{width:100%}.mat-menu-item .mat-menu-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}'],encapsulation:2,data:{animation:[K2.transformMenu,K2.fadeInItems]},changeDetection:0}),n})(),_ie=new pe("mat-menu-scroll-strategy"),pLe={provide:_ie,deps:[tr],useFactory:function(n){return()=>n.scrollStrategies.reposition()}},fie=la({passive:!0}),hLe=(()=>{class n{constructor(e,i,r,o,s,a,l,c,u){this._overlay=e,this._element=i,this._viewContainerRef=r,this._menuItemInstance=a,this._dir=l,this._focusMonitor=c,this._ngZone=u,this._overlayRef=null,this._menuOpen=!1,this._closingActionsSubscription=Sn.EMPTY,this._hoverSubscription=Sn.EMPTY,this._menuCloseSubscription=Sn.EMPTY,this._handleTouchStart=d=>{ew(d)||(this._openedBy="touch")},this._openedBy=void 0,this.restoreFocus=!0,this.menuOpened=new G,this.onMenuOpen=this.menuOpened,this.menuClosed=new G,this.onMenuClose=this.menuClosed,this._scrollStrategy=o,this._parentMaterialMenu=s instanceof yw?s:void 0,i.nativeElement.addEventListener("touchstart",this._handleTouchStart,fie),a&&(a._triggersSubmenu=this.triggersSubmenu())}get _deprecatedMatMenuTriggerFor(){return this.menu}set _deprecatedMatMenuTriggerFor(e){this.menu=e}get menu(){return this._menu}set menu(e){e!==this._menu&&(this._menu=e,this._menuCloseSubscription.unsubscribe(),e&&(this._menuCloseSubscription=e.close.subscribe(i=>{this._destroyMenu(i),("click"===i||"tab"===i)&&this._parentMaterialMenu&&this._parentMaterialMenu.closed.emit(i)})))}ngAfterContentInit(){this._handleHover()}ngOnDestroy(){this._overlayRef&&(this._overlayRef.dispose(),this._overlayRef=null),this._element.nativeElement.removeEventListener("touchstart",this._handleTouchStart,fie),this._menuCloseSubscription.unsubscribe(),this._closingActionsSubscription.unsubscribe(),this._hoverSubscription.unsubscribe()}get menuOpen(){return this._menuOpen}get dir(){return this._dir&&"rtl"===this._dir.value?"rtl":"ltr"}triggersSubmenu(){return!(!this._menuItemInstance||!this._parentMaterialMenu)}toggleMenu(){return this._menuOpen?this.closeMenu():this.openMenu()}openMenu(){let e=this.menu;if(this._menuOpen||!e)return;let i=this._createOverlay(e),r=i.getConfig(),o=r.positionStrategy;this._setPosition(e,o),r.hasBackdrop=null==e.hasBackdrop?!this.triggersSubmenu():e.hasBackdrop,i.attach(this._getPortal(e)),e.lazyContent&&e.lazyContent.attach(this.menuData),this._closingActionsSubscription=this._menuClosingActions().subscribe(()=>this.closeMenu()),this._initMenu(e),e instanceof yw&&(e._startAnimation(),e._directDescendantItems.changes.pipe(st(e.close)).subscribe(()=>{o.withLockedPosition(!1).reapplyLastPosition(),o.withLockedPosition(!0)}))}closeMenu(){this.menu?.close.emit()}focus(e,i){this._focusMonitor&&e?this._focusMonitor.focusVia(this._element,e,i):this._element.nativeElement.focus(i)}updatePosition(){this._overlayRef?.updatePosition()}_destroyMenu(e){if(!this._overlayRef||!this.menuOpen)return;let i=this.menu;this._closingActionsSubscription.unsubscribe(),this._overlayRef.detach(),this.restoreFocus&&("keydown"===e||!this._openedBy||!this.triggersSubmenu())&&this.focus(this._openedBy),this._openedBy=void 0,i instanceof yw?(i._resetAnimation(),i.lazyContent?i._animationDone.pipe(Ye(r=>"void"===r.toState),Qt(1),st(i.lazyContent._attached)).subscribe({next:()=>i.lazyContent.detach(),complete:()=>this._setIsMenuOpen(!1)}):this._setIsMenuOpen(!1)):(this._setIsMenuOpen(!1),i?.lazyContent?.detach())}_initMenu(e){e.parentMenu=this.triggersSubmenu()?this._parentMaterialMenu:void 0,e.direction=this.dir,this._setMenuElevation(e),e.focusFirstItem(this._openedBy||"program"),this._setIsMenuOpen(!0)}_setMenuElevation(e){if(e.setElevation){let i=0,r=e.parentMenu;for(;r;)i++,r=r.parentMenu;e.setElevation(i)}}_setIsMenuOpen(e){this._menuOpen=e,this._menuOpen?this.menuOpened.emit():this.menuClosed.emit(),this.triggersSubmenu()&&this._menuItemInstance._setHighlighted(e)}_createOverlay(e){if(!this._overlayRef){let i=this._getOverlayConfig(e);this._subscribeToPositions(e,i.positionStrategy),this._overlayRef=this._overlay.create(i),this._overlayRef.keydownEvents().subscribe()}return this._overlayRef}_getOverlayConfig(e){return new sc({positionStrategy:this._overlay.position().flexibleConnectedTo(this._element).withLockedPosition().withGrowAfterOpen().withTransformOriginOn(".mat-menu-panel, .mat-mdc-menu-panel"),backdropClass:e.backdropClass||"cdk-overlay-transparent-backdrop",panelClass:e.overlayPanelClass,scrollStrategy:this._scrollStrategy(),direction:this._dir})}_subscribeToPositions(e,i){e.setPositionClasses&&i.positionChanges.subscribe(r=>{let o="start"===r.connectionPair.overlayX?"after":"before",s="top"===r.connectionPair.overlayY?"below":"above";this._ngZone?this._ngZone.run(()=>e.setPositionClasses(o,s)):e.setPositionClasses(o,s)})}_setPosition(e,i){let[r,o]="before"===e.xPosition?["end","start"]:["start","end"],[s,a]="above"===e.yPosition?["bottom","top"]:["top","bottom"],[l,c]=[s,a],[u,d]=[r,o],p=0;if(this.triggersSubmenu()){if(d=r="before"===e.xPosition?"start":"end",o=u="end"===r?"start":"end",this._parentMaterialMenu){if(null==this._parentInnerPadding){let h=this._parentMaterialMenu.items.first;this._parentInnerPadding=h?h._getHostElement().offsetTop:0}p="bottom"===s?this._parentInnerPadding:-this._parentInnerPadding}}else e.overlapTrigger||(l="top"===s?"bottom":"top",c="top"===a?"bottom":"top");i.withPositions([{originX:r,originY:l,overlayX:u,overlayY:s,offsetY:p},{originX:o,originY:l,overlayX:d,overlayY:s,offsetY:p},{originX:r,originY:c,overlayX:u,overlayY:a,offsetY:-p},{originX:o,originY:c,overlayX:d,overlayY:a,offsetY:-p}])}_menuClosingActions(){let e=this._overlayRef.backdropClick(),i=this._overlayRef.detachments();return Jt(e,this._parentMaterialMenu?this._parentMaterialMenu.closed:Xt(),this._parentMaterialMenu?this._parentMaterialMenu._hovered().pipe(Ye(s=>s!==this._menuItemInstance),Ye(()=>this._menuOpen)):Xt(),i)}_handleMousedown(e){$M(e)||(this._openedBy=0===e.button?"mouse":void 0,this.triggersSubmenu()&&e.preventDefault())}_handleKeydown(e){let i=e.keyCode;(13===i||32===i)&&(this._openedBy="keyboard"),this.triggersSubmenu()&&(39===i&&"ltr"===this.dir||37===i&&"rtl"===this.dir)&&(this._openedBy="keyboard",this.openMenu())}_handleClick(e){this.triggersSubmenu()?(e.stopPropagation(),this.openMenu()):this.toggleMenu()}_handleHover(){!this.triggersSubmenu()||!this._parentMaterialMenu||(this._hoverSubscription=this._parentMaterialMenu._hovered().pipe(Ye(e=>e===this._menuItemInstance&&!e.disabled),Ol(0,f0)).subscribe(()=>{this._openedBy="mouse",this.menu instanceof yw&&this.menu._isAnimating?this.menu._animationDone.pipe(Qt(1),Ol(0,f0),st(this._parentMaterialMenu._hovered())).subscribe(()=>this.openMenu()):this.openMenu()}))}_getPortal(e){return(!this._portal||this._portal.templateRef!==e.templateRef)&&(this._portal=new ks(e.templateRef,this._viewContainerRef)),this._portal}}return n.\u0275fac=function(e){return new(e||n)(M(tr),M(Re),M(Oi),M(_ie),M($H,8),M(nu,10),M($i,8),M(Fr),M(_t))},n.\u0275dir=He({type:n,hostVars:3,hostBindings:function(e,i){1&e&&P("click",function(o){return i._handleClick(o)})("mousedown",function(o){return i._handleMousedown(o)})("keydown",function(o){return i._handleKeydown(o)}),2&e&&ze("aria-haspopup",i.menu?"menu":null)("aria-expanded",i.menuOpen||null)("aria-controls",i.menuOpen?i.menu.panelId:null)},inputs:{_deprecatedMatMenuTriggerFor:["mat-menu-trigger-for","_deprecatedMatMenuTriggerFor"],menu:["matMenuTriggerFor","menu"],menuData:["matMenuTriggerData","menuData"],restoreFocus:["matMenuTriggerRestoreFocus","restoreFocus"]},outputs:{menuOpened:"menuOpened",onMenuOpen:"onMenuOpen",menuClosed:"menuClosed",onMenuClose:"onMenuClose"}}),n})(),fd=(()=>{class n extends hLe{}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275dir=He({type:n,selectors:[["","mat-menu-trigger-for",""],["","matMenuTriggerFor",""]],hostAttrs:[1,"mat-menu-trigger"],exportAs:["matMenuTrigger"],features:[tt]}),n})(),zh=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[pLe],imports:[Me,ln,_l,ss,ud,ln]}),n})();function fLe(n,t){1&n&&O(0,"mat-icon",8)}function mLe(n,t){1&n&&O(0,"mat-icon",9)}function gLe(n,t){1&n&&O(0,"mat-icon",10)}var Ua=(()=>(function(n){n[n.DEFAULT=0]="DEFAULT",n[n.DARK_MODE_ON=1]="DARK_MODE_ON",n[n.DARK_MODE_OFF=2]="DARK_MODE_OFF"}(Ua||(Ua={})),Ua))(),vie=(()=>{class n{constructor(){this.DarkModeOverride=Ua,this.onOverrideChanged=new G}getButtonTitle(){let e;switch(this.darkModeOverride){case Ua.DEFAULT:e="Browser default";break;case Ua.DARK_MODE_ON:e="Dark mode";break;case Ua.DARK_MODE_OFF:e="Light mode"}return`Current mode: [${e}]. Switch between browser default, light, or dark theme.`}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["app-header-dark-mode-toggle-component"]],inputs:{darkModeOverride:"darkModeOverride"},outputs:{onOverrideChanged:"onOverrideChanged"},decls:15,vars:6,consts:[["mat-icon-button","","aria-label","Menu for changing light or dark theme",3,"matMenuTriggerFor","ngSwitch","title"],["svgIcon","brightness_6_24px",4,"ngSwitchCase"],["svgIcon","light_mode_24px",4,"ngSwitchCase"],["svgIcon","dark_mode_24px",4,"ngSwitchCase"],["menu","matMenu"],["mat-menu-item","","title","Set the theme to match the default mode in the browser.",3,"click"],["mat-menu-item","","title","Force light TensorBoard theme.",3,"click"],["mat-menu-item","","title","Force dark TensorBoard theme.",3,"click"],["svgIcon","brightness_6_24px"],["svgIcon","light_mode_24px"],["svgIcon","dark_mode_24px"]],template:function(e,i){1&e&&(_(0,"button",0),E(1,fLe,1,0,"mat-icon",1),E(2,mLe,1,0,"mat-icon",2),E(3,gLe,1,0,"mat-icon",3),v(),_(4,"mat-menu",null,4)(6,"button",5),P("click",function(){return i.onOverrideChanged.emit(i.DarkModeOverride.DEFAULT)}),_(7,"label"),A(8,"Browser default"),v()(),_(9,"button",6),P("click",function(){return i.onOverrideChanged.emit(i.DarkModeOverride.DARK_MODE_OFF)}),_(10,"label"),A(11,"Light"),v()(),_(12,"button",7),P("click",function(){return i.onOverrideChanged.emit(i.DarkModeOverride.DARK_MODE_ON)}),_(13,"label"),A(14,"Dark"),v()()()),2&e&&(y("matMenuTriggerFor",$e(5))("ngSwitch",i.darkModeOverride)("title",i.getButtonTitle()),C(1),y("ngSwitchCase",i.DarkModeOverride.DEFAULT),C(1),y("ngSwitchCase",i.DarkModeOverride.DARK_MODE_OFF),C(1),y("ngSwitchCase",i.DarkModeOverride.DARK_MODE_ON))},dependencies:[_n,Gt,hd,nu,fd,Cr,Ur],encapsulation:2}),n})(),yie=(()=>{class n{constructor(e){this.store=e,this.darkModeOverride$=this.store.select(GA).pipe(L(i=>null===i?Ua.DEFAULT:i?Ua.DARK_MODE_ON:Ua.DARK_MODE_OFF))}changeDarkMode(e){let i=null;switch(e){case Ua.DEFAULT:i=null;break;case Ua.DARK_MODE_OFF:i=!1;break;case Ua.DARK_MODE_ON:i=!0}this.store.dispatch(MI({enableDarkMode:i}))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["app-header-dark-mode-toggle"]],decls:2,vars:3,consts:[[3,"darkModeOverride","onOverrideChanged"]],template:function(e,i){1&e&&(_(0,"app-header-dark-mode-toggle-component",0),P("onOverrideChanged",function(o){return i.changeDarkMode(o)}),B(1,"async"),v()),2&e&&y("darkModeOverride",U(1,1,i.darkModeOverride$))},dependencies:[vie,Ge],encapsulation:2}),n})();function yLe(n,t){1&n&&Vn(0)}var Mie=["*"];function bLe(n,t){}var xLe=function(n){return{animationDuration:n}},CLe=function(n,t){return{value:n,params:t}},MLe=["tabListContainer"],wLe=["tabList"],SLe=["tabListInner"],ELe=["nextPaginator"],TLe=["previousPaginator"],DLe=["tabBodyWrapper"],ALe=["tabHeader"];function ILe(n,t){}function PLe(n,t){1&n&&E(0,ILe,0,0,"ng-template",10),2&n&&y("cdkPortalOutlet",S().$implicit.templateLabel)}function RLe(n,t){1&n&&A(0),2&n&&yt(S().$implicit.textLabel)}function OLe(n,t){if(1&n){let e=Pe();_(0,"div",6),P("click",function(){let r=oe(e),o=r.$implicit,s=r.index,a=S(),l=$e(1);return se(a._handleClick(o,l,s))})("cdkFocusChange",function(r){let s=oe(e).index;return se(S()._tabFocusChanged(r,s))}),_(1,"div",7),E(2,PLe,1,1,"ng-template",8),E(3,RLe,1,1,"ng-template",null,9,qt),v()()}if(2&n){let e=t.$implicit,i=t.index,r=$e(4),o=S();et("mat-tab-label-active",o.selectedIndex===i),y("id",o._getTabLabelId(i))("ngClass",e.labelClass)("disabled",e.disabled)("matRippleDisabled",e.disabled||o.disableRipple),ze("tabIndex",o._getTabIndex(e,i))("aria-posinset",i+1)("aria-setsize",o._tabs.length)("aria-controls",o._getTabContentId(i))("aria-selected",o.selectedIndex===i)("aria-label",e.ariaLabel||null)("aria-labelledby",!e.ariaLabel&&e.ariaLabelledby?e.ariaLabelledby:null),C(2),y("ngIf",e.templateLabel)("ngIfElse",r)}}function kLe(n,t){if(1&n){let e=Pe();_(0,"mat-tab-body",11),P("_onCentered",function(){return oe(e),se(S()._removeTabBodyWrapperHeight())})("_onCentering",function(r){return oe(e),se(S()._setTabBodyWrapperHeight(r))}),v()}if(2&n){let e=t.$implicit,i=t.index,r=S();et("mat-tab-body-active",r.selectedIndex===i),y("id",r._getTabContentId(i))("ngClass",e.bodyClass)("content",e.content)("position",e.position)("origin",e.origin)("animationDuration",r.animationDuration)("preserveContent",r.preserveContent),ze("tabindex",null!=r.contentTabIndex&&r.selectedIndex===i?r.contentTabIndex:null)("aria-labelledby",r._getTabLabelId(i))}}var FLe=new pe("MatInkBarPositioner",{providedIn:"root",factory:function(){return t=>({left:t?(t.offsetLeft||0)+"px":"0",width:t?(t.offsetWidth||0)+"px":"0"})}}),bie=(()=>{class n{constructor(e,i,r,o){this._elementRef=e,this._ngZone=i,this._inkBarPositioner=r,this._animationMode=o}alignToElement(e){this.show(),this._ngZone.run(()=>{this._ngZone.onStable.pipe(Qt(1)).subscribe(()=>{let i=this._inkBarPositioner(e),r=this._elementRef.nativeElement;r.style.left=i.left,r.style.width=i.width})})}show(){this._elementRef.nativeElement.style.visibility="visible"}hide(){this._elementRef.nativeElement.style.visibility="hidden"}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(_t),M(FLe),M(Pi,8))},n.\u0275dir=He({type:n,selectors:[["mat-ink-bar"]],hostAttrs:[1,"mat-ink-bar"],hostVars:2,hostBindings:function(e,i){2&e&&et("_mat-animation-noopable","NoopAnimations"===i._animationMode)}}),n})(),LLe=new pe("MatTabContent"),wie=new pe("MatTabLabel"),Sie=new pe("MAT_TAB"),Eie=(()=>{class n extends fte{constructor(e,i,r){super(e,i),this._closestTab=r}}return n.\u0275fac=function(e){return new(e||n)(M(Vi),M(Oi),M(Sie,8))},n.\u0275dir=He({type:n,selectors:[["","mat-tab-label",""],["","matTabLabel",""]],features:[$t([{provide:wie,useExisting:n}]),tt]}),n})(),BLe=so(class{}),Tie=new pe("MAT_TAB_GROUP"),xw=(()=>{class n extends BLe{constructor(e,i){super(),this._viewContainerRef=e,this._closestTabGroup=i,this.textLabel="",this._contentPortal=null,this._stateChanges=new ke,this.position=null,this.origin=null,this.isActive=!1}get templateLabel(){return this._templateLabel}set templateLabel(e){this._setTemplateLabelInput(e)}get content(){return this._contentPortal}ngOnChanges(e){(e.hasOwnProperty("textLabel")||e.hasOwnProperty("disabled"))&&this._stateChanges.next()}ngOnDestroy(){this._stateChanges.complete()}ngOnInit(){this._contentPortal=new ks(this._explicitContent||this._implicitContent,this._viewContainerRef)}_setTemplateLabelInput(e){e&&e._closestTab===this&&(this._templateLabel=e)}}return n.\u0275fac=function(e){return new(e||n)(M(Oi),M(Tie,8))},n.\u0275cmp=R({type:n,selectors:[["mat-tab"]],contentQueries:function(e,i,r){if(1&e&&(Ei(r,wie,5),Ei(r,LLe,7,Vi)),2&e){let o;Ne(o=Le())&&(i.templateLabel=o.first),Ne(o=Le())&&(i._explicitContent=o.first)}},viewQuery:function(e,i){if(1&e&&ot(Vi,7),2&e){let r;Ne(r=Le())&&(i._implicitContent=r.first)}},inputs:{disabled:"disabled",textLabel:["label","textLabel"],ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],labelClass:"labelClass",bodyClass:"bodyClass"},exportAs:["matTab"],features:[$t([{provide:Sie,useExisting:n}]),tt,Ft],ngContentSelectors:Mie,decls:1,vars:0,template:function(e,i){1&e&&(xi(),E(0,yLe,1,0,"ng-template"))},encapsulation:2}),n})(),VLe={translateTab:Kr("translateTab",[ki("center, void, left-origin-center, right-origin-center",gn({transform:"none"})),ki("left",gn({transform:"translate3d(-100%, 0, 0)",minHeight:"1px",visibility:"hidden"})),ki("right",gn({transform:"translate3d(100%, 0, 0)",minHeight:"1px",visibility:"hidden"})),Li("* => left, * => right, left => center, right => center",ji("{{animationDuration}} cubic-bezier(0.35, 0, 0.25, 1)")),Li("void => left-origin-center",[gn({transform:"translate3d(-100%, 0, 0)",visibility:"hidden"}),ji("{{animationDuration}} cubic-bezier(0.35, 0, 0.25, 1)")]),Li("void => right-origin-center",[gn({transform:"translate3d(100%, 0, 0)",visibility:"hidden"}),ji("{{animationDuration}} cubic-bezier(0.35, 0, 0.25, 1)")])])},HLe=(()=>{class n extends da{constructor(e,i,r,o){super(e,i,o),this._host=r,this._centeringSub=Sn.EMPTY,this._leavingSub=Sn.EMPTY}ngOnInit(){super.ngOnInit(),this._centeringSub=this._host._beforeCentering.pipe(zn(this._host._isCenterPosition(this._host._position))).subscribe(e=>{e&&!this.hasAttached()&&this.attach(this._host._content)}),this._leavingSub=this._host._afterLeavingCenter.subscribe(()=>{this._host.preserveContent||this.detach()})}ngOnDestroy(){super.ngOnDestroy(),this._centeringSub.unsubscribe(),this._leavingSub.unsubscribe()}}return n.\u0275fac=function(e){return new(e||n)(M(gs),M(Oi),M(Jn(()=>Die)),M(Ht))},n.\u0275dir=He({type:n,selectors:[["","matTabBodyHost",""]],features:[tt]}),n})(),ULe=(()=>{class n{constructor(e,i,r){this._elementRef=e,this._dir=i,this._dirChangeSubscription=Sn.EMPTY,this._translateTabComplete=new ke,this._onCentering=new G,this._beforeCentering=new G,this._afterLeavingCenter=new G,this._onCentered=new G(!0),this.animationDuration="500ms",this.preserveContent=!1,i&&(this._dirChangeSubscription=i.change.subscribe(o=>{this._computePositionAnimationState(o),r.markForCheck()})),this._translateTabComplete.pipe(yi((o,s)=>o.fromState===s.fromState&&o.toState===s.toState)).subscribe(o=>{this._isCenterPosition(o.toState)&&this._isCenterPosition(this._position)&&this._onCentered.emit(),this._isCenterPosition(o.fromState)&&!this._isCenterPosition(this._position)&&this._afterLeavingCenter.emit()})}set position(e){this._positionIndex=e,this._computePositionAnimationState()}ngOnInit(){"center"==this._position&&null!=this.origin&&(this._position=this._computePositionFromOrigin(this.origin))}ngOnDestroy(){this._dirChangeSubscription.unsubscribe(),this._translateTabComplete.complete()}_onTranslateTabStarted(e){let i=this._isCenterPosition(e.toState);this._beforeCentering.emit(i),i&&this._onCentering.emit(this._elementRef.nativeElement.clientHeight)}_getLayoutDirection(){return this._dir&&"rtl"===this._dir.value?"rtl":"ltr"}_isCenterPosition(e){return"center"==e||"left-origin-center"==e||"right-origin-center"==e}_computePositionAnimationState(e=this._getLayoutDirection()){this._position=this._positionIndex<0?"ltr"==e?"left":"right":this._positionIndex>0?"ltr"==e?"right":"left":"center"}_computePositionFromOrigin(e){let i=this._getLayoutDirection();return"ltr"==i&&e<=0||"rtl"==i&&e>0?"left-origin-center":"right-origin-center"}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M($i,8),M(nn))},n.\u0275dir=He({type:n,inputs:{_content:["content","_content"],origin:"origin",animationDuration:"animationDuration",preserveContent:"preserveContent",position:"position"},outputs:{_onCentering:"_onCentering",_beforeCentering:"_beforeCentering",_afterLeavingCenter:"_afterLeavingCenter",_onCentered:"_onCentered"}}),n})(),Die=(()=>{class n extends ULe{constructor(e,i,r){super(e,i,r)}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M($i,8),M(nn))},n.\u0275cmp=R({type:n,selectors:[["mat-tab-body"]],viewQuery:function(e,i){if(1&e&&ot(da,5),2&e){let r;Ne(r=Le())&&(i._portalHost=r.first)}},hostAttrs:[1,"mat-tab-body"],features:[tt],decls:3,vars:6,consts:[["cdkScrollable","",1,"mat-tab-body-content"],["content",""],["matTabBodyHost",""]],template:function(e,i){1&e&&(_(0,"div",0,1),P("@translateTab.start",function(o){return i._onTranslateTabStarted(o)})("@translateTab.done",function(o){return i._translateTabComplete.next(o)}),E(2,bLe,0,0,"ng-template",2),v()),2&e&&y("@translateTab",Qr(3,CLe,i._position,On(1,xLe,i.animationDuration)))},dependencies:[HLe],styles:['.mat-tab-body-content{height:100%;overflow:auto}.mat-tab-group-dynamic-height .mat-tab-body-content{overflow:hidden}.mat-tab-body-content[style*="visibility: hidden"]{display:none}'],encapsulation:2,data:{animation:[VLe.translateTab]}}),n})(),Aie=new pe("MAT_TABS_CONFIG"),zLe=so(class{}),Iie=(()=>{class n extends zLe{constructor(e){super(),this.elementRef=e}focus(){this.elementRef.nativeElement.focus()}getOffsetLeft(){return this.elementRef.nativeElement.offsetLeft}getOffsetWidth(){return this.elementRef.nativeElement.offsetWidth}}return n.\u0275fac=function(e){return new(e||n)(M(Re))},n.\u0275dir=He({type:n,selectors:[["","matTabLabelWrapper",""]],hostVars:3,hostBindings:function(e,i){2&e&&(ze("aria-disabled",!!i.disabled),et("mat-tab-disabled",i.disabled))},inputs:{disabled:"disabled"},features:[tt]}),n})(),xie=la({passive:!0}),WLe=(()=>{class n{constructor(e,i,r,o,s,a,l){this._elementRef=e,this._changeDetectorRef=i,this._viewportRuler=r,this._dir=o,this._ngZone=s,this._platform=a,this._animationMode=l,this._scrollDistance=0,this._selectedIndexChanged=!1,this._destroyed=new ke,this._showPaginationControls=!1,this._disableScrollAfter=!0,this._disableScrollBefore=!0,this._stopScrolling=new ke,this._disablePagination=!1,this._selectedIndex=0,this.selectFocusedIndex=new G,this.indexFocused=new G,s.runOutsideAngular(()=>{_i(e.nativeElement,"mouseleave").pipe(st(this._destroyed)).subscribe(()=>{this._stopInterval()})})}get disablePagination(){return this._disablePagination}set disablePagination(e){this._disablePagination=Rt(e)}get selectedIndex(){return this._selectedIndex}set selectedIndex(e){e=Bi(e),this._selectedIndex!=e&&(this._selectedIndexChanged=!0,this._selectedIndex=e,this._keyManager&&this._keyManager.updateActiveItem(e))}ngAfterViewInit(){_i(this._previousPaginator.nativeElement,"touchstart",xie).pipe(st(this._destroyed)).subscribe(()=>{this._handlePaginatorPress("before")}),_i(this._nextPaginator.nativeElement,"touchstart",xie).pipe(st(this._destroyed)).subscribe(()=>{this._handlePaginatorPress("after")})}ngAfterContentInit(){let e=this._dir?this._dir.change:Xt("ltr"),i=this._viewportRuler.change(150),r=()=>{this.updatePagination(),this._alignInkBarToSelectedTab()};this._keyManager=new Sh(this._items).withHorizontalOrientation(this._getLayoutDirection()).withHomeAndEnd().withWrap(),this._keyManager.updateActiveItem(this._selectedIndex),this._ngZone.onStable.pipe(Qt(1)).subscribe(r),Jt(e,i,this._items.changes,this._itemsResized()).pipe(st(this._destroyed)).subscribe(()=>{this._ngZone.run(()=>{Promise.resolve().then(()=>{this._scrollDistance=Math.max(0,Math.min(this._getMaxScrollDistance(),this._scrollDistance)),r()})}),this._keyManager.withHorizontalOrientation(this._getLayoutDirection())}),this._keyManager.change.pipe(st(this._destroyed)).subscribe(o=>{this.indexFocused.emit(o),this._setTabFocus(o)})}_itemsResized(){return"function"!=typeof ResizeObserver?eo:this._items.changes.pipe(zn(this._items),ui(e=>new un(i=>this._ngZone.runOutsideAngular(()=>{let r=new ResizeObserver(o=>i.next(o));return e.forEach(o=>r.observe(o.elementRef.nativeElement)),()=>{r.disconnect()}}))),Za(1),Ye(e=>e.some(i=>i.contentRect.width>0&&i.contentRect.height>0)))}ngAfterContentChecked(){this._tabLabelCount!=this._items.length&&(this.updatePagination(),this._tabLabelCount=this._items.length,this._changeDetectorRef.markForCheck()),this._selectedIndexChanged&&(this._scrollToLabel(this._selectedIndex),this._checkScrollingControls(),this._alignInkBarToSelectedTab(),this._selectedIndexChanged=!1,this._changeDetectorRef.markForCheck()),this._scrollDistanceChanged&&(this._updateTabScrollPosition(),this._scrollDistanceChanged=!1,this._changeDetectorRef.markForCheck())}ngOnDestroy(){this._destroyed.next(),this._destroyed.complete(),this._stopScrolling.complete()}_handleKeydown(e){if(!kr(e))switch(e.keyCode){case 13:case 32:this.focusIndex!==this.selectedIndex&&(this.selectFocusedIndex.emit(this.focusIndex),this._itemSelected(e));break;default:this._keyManager.onKeydown(e)}}_onContentChanges(){let e=this._elementRef.nativeElement.textContent;e!==this._currentTextContent&&(this._currentTextContent=e||"",this._ngZone.run(()=>{this.updatePagination(),this._alignInkBarToSelectedTab(),this._changeDetectorRef.markForCheck()}))}updatePagination(){this._checkPaginationEnabled(),this._checkScrollingControls(),this._updateTabScrollPosition()}get focusIndex(){return this._keyManager?this._keyManager.activeItemIndex:0}set focusIndex(e){!this._isValidIndex(e)||this.focusIndex===e||!this._keyManager||this._keyManager.setActiveItem(e)}_isValidIndex(e){if(!this._items)return!0;let i=this._items?this._items.toArray()[e]:null;return!!i&&!i.disabled}_setTabFocus(e){if(this._showPaginationControls&&this._scrollToLabel(e),this._items&&this._items.length){this._items.toArray()[e].focus();let i=this._tabListContainer.nativeElement;i.scrollLeft="ltr"==this._getLayoutDirection()?0:i.scrollWidth-i.offsetWidth}}_getLayoutDirection(){return this._dir&&"rtl"===this._dir.value?"rtl":"ltr"}_updateTabScrollPosition(){if(this.disablePagination)return;let e=this.scrollDistance,i="ltr"===this._getLayoutDirection()?-e:e;this._tabList.nativeElement.style.transform=`translateX(${Math.round(i)}px)`,(this._platform.TRIDENT||this._platform.EDGE)&&(this._tabListContainer.nativeElement.scrollLeft=0)}get scrollDistance(){return this._scrollDistance}set scrollDistance(e){this._scrollTo(e)}_scrollHeader(e){return this._scrollTo(this._scrollDistance+("before"==e?-1:1)*this._tabListContainer.nativeElement.offsetWidth/3)}_handlePaginatorClick(e){this._stopInterval(),this._scrollHeader(e)}_scrollToLabel(e){if(this.disablePagination)return;let i=this._items?this._items.toArray()[e]:null;if(!i)return;let a,l,r=this._tabListContainer.nativeElement.offsetWidth,{offsetLeft:o,offsetWidth:s}=i.elementRef.nativeElement;"ltr"==this._getLayoutDirection()?(a=o,l=a+s):(l=this._tabListInner.nativeElement.offsetWidth-o,a=l-s);let c=this.scrollDistance,u=this.scrollDistance+r;a<c?this.scrollDistance-=c-a+60:l>u&&(this.scrollDistance+=l-u+60)}_checkPaginationEnabled(){if(this.disablePagination)this._showPaginationControls=!1;else{let e=this._tabListInner.nativeElement.scrollWidth>this._elementRef.nativeElement.offsetWidth;e||(this.scrollDistance=0),e!==this._showPaginationControls&&this._changeDetectorRef.markForCheck(),this._showPaginationControls=e}}_checkScrollingControls(){this.disablePagination?this._disableScrollAfter=this._disableScrollBefore=!0:(this._disableScrollBefore=0==this.scrollDistance,this._disableScrollAfter=this.scrollDistance==this._getMaxScrollDistance(),this._changeDetectorRef.markForCheck())}_getMaxScrollDistance(){return this._tabListInner.nativeElement.scrollWidth-this._tabListContainer.nativeElement.offsetWidth||0}_alignInkBarToSelectedTab(){let e=this._items&&this._items.length?this._items.toArray()[this.selectedIndex]:null,i=e?e.elementRef.nativeElement:null;i?this._inkBar.alignToElement(i):this._inkBar.hide()}_stopInterval(){this._stopScrolling.next()}_handlePaginatorPress(e,i){i&&null!=i.button&&0!==i.button||(this._stopInterval(),Ka(650,100).pipe(st(Jt(this._stopScrolling,this._destroyed))).subscribe(()=>{let{maxScrollDistance:r,distance:o}=this._scrollHeader(e);(0===o||o>=r)&&this._stopInterval()}))}_scrollTo(e){if(this.disablePagination)return{maxScrollDistance:0,distance:0};let i=this._getMaxScrollDistance();return this._scrollDistance=Math.max(0,Math.min(i,e)),this._scrollDistanceChanged=!0,this._checkScrollingControls(),{maxScrollDistance:i,distance:this._scrollDistance}}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(nn),M(Va),M($i,8),M(_t),M(oi),M(Pi,8))},n.\u0275dir=He({type:n,inputs:{disablePagination:"disablePagination"}}),n})(),qLe=(()=>{class n extends WLe{constructor(e,i,r,o,s,a,l){super(e,i,r,o,s,a,l),this._disableRipple=!1}get disableRipple(){return this._disableRipple}set disableRipple(e){this._disableRipple=Rt(e)}_itemSelected(e){e.preventDefault()}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(nn),M(Va),M($i,8),M(_t),M(oi),M(Pi,8))},n.\u0275dir=He({type:n,inputs:{disableRipple:"disableRipple"},features:[tt]}),n})(),YLe=(()=>{class n extends qLe{constructor(e,i,r,o,s,a,l){super(e,i,r,o,s,a,l)}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(nn),M(Va),M($i,8),M(_t),M(oi),M(Pi,8))},n.\u0275cmp=R({type:n,selectors:[["mat-tab-header"]],contentQueries:function(e,i,r){if(1&e&&Ei(r,Iie,4),2&e){let o;Ne(o=Le())&&(i._items=o)}},viewQuery:function(e,i){if(1&e&&(ot(bie,7),ot(MLe,7),ot(wLe,7),ot(SLe,7),ot(ELe,5),ot(TLe,5)),2&e){let r;Ne(r=Le())&&(i._inkBar=r.first),Ne(r=Le())&&(i._tabListContainer=r.first),Ne(r=Le())&&(i._tabList=r.first),Ne(r=Le())&&(i._tabListInner=r.first),Ne(r=Le())&&(i._nextPaginator=r.first),Ne(r=Le())&&(i._previousPaginator=r.first)}},hostAttrs:[1,"mat-tab-header"],hostVars:4,hostBindings:function(e,i){2&e&&et("mat-tab-header-pagination-controls-enabled",i._showPaginationControls)("mat-tab-header-rtl","rtl"==i._getLayoutDirection())},inputs:{selectedIndex:"selectedIndex"},outputs:{selectFocusedIndex:"selectFocusedIndex",indexFocused:"indexFocused"},features:[tt],ngContentSelectors:Mie,decls:14,vars:10,consts:[["aria-hidden","true","type","button","mat-ripple","","tabindex","-1",1,"mat-tab-header-pagination","mat-tab-header-pagination-before","mat-elevation-z4",3,"matRippleDisabled","disabled","click","mousedown","touchend"],["previousPaginator",""],[1,"mat-tab-header-pagination-chevron"],[1,"mat-tab-label-container",3,"keydown"],["tabListContainer",""],["role","tablist",1,"mat-tab-list",3,"cdkObserveContent"],["tabList",""],[1,"mat-tab-labels"],["tabListInner",""],["aria-hidden","true","type","button","mat-ripple","","tabindex","-1",1,"mat-tab-header-pagination","mat-tab-header-pagination-after","mat-elevation-z4",3,"matRippleDisabled","disabled","mousedown","click","touchend"],["nextPaginator",""]],template:function(e,i){1&e&&(xi(),_(0,"button",0,1),P("click",function(){return i._handlePaginatorClick("before")})("mousedown",function(o){return i._handlePaginatorPress("before",o)})("touchend",function(){return i._stopInterval()}),O(2,"div",2),v(),_(3,"div",3,4),P("keydown",function(o){return i._handleKeydown(o)}),_(5,"div",5,6),P("cdkObserveContent",function(){return i._onContentChanges()}),_(7,"div",7,8),Vn(9),v(),O(10,"mat-ink-bar"),v()(),_(11,"button",9,10),P("mousedown",function(o){return i._handlePaginatorPress("after",o)})("click",function(){return i._handlePaginatorClick("after")})("touchend",function(){return i._stopInterval()}),O(13,"div",2),v()),2&e&&(et("mat-tab-header-pagination-disabled",i._disableScrollBefore),y("matRippleDisabled",i._disableScrollBefore||i.disableRipple)("disabled",i._disableScrollBefore||null),C(5),et("_mat-animation-noopable","NoopAnimations"===i._animationMode),C(6),et("mat-tab-header-pagination-disabled",i._disableScrollAfter),y("matRippleDisabled",i._disableScrollAfter||i.disableRipple)("disabled",i._disableScrollAfter||null))},dependencies:[Yo,wh,bie],styles:[".mat-tab-header{display:flex;overflow:hidden;position:relative;flex-shrink:0}.mat-tab-header-pagination{-webkit-user-select:none;user-select:none;position:relative;display:none;justify-content:center;align-items:center;min-width:32px;cursor:pointer;z-index:2;-webkit-tap-highlight-color:rgba(0,0,0,0);touch-action:none;box-sizing:content-box;background:none;border:none;outline:0;padding:0}.mat-tab-header-pagination::-moz-focus-inner{border:0}.mat-tab-header-pagination-controls-enabled .mat-tab-header-pagination{display:flex}.mat-tab-header-pagination-before,.mat-tab-header-rtl .mat-tab-header-pagination-after{padding-left:4px}.mat-tab-header-pagination-before .mat-tab-header-pagination-chevron,.mat-tab-header-rtl .mat-tab-header-pagination-after .mat-tab-header-pagination-chevron{transform:rotate(-135deg)}.mat-tab-header-rtl .mat-tab-header-pagination-before,.mat-tab-header-pagination-after{padding-right:4px}.mat-tab-header-rtl .mat-tab-header-pagination-before .mat-tab-header-pagination-chevron,.mat-tab-header-pagination-after .mat-tab-header-pagination-chevron{transform:rotate(45deg)}.mat-tab-header-pagination-chevron{border-style:solid;border-width:2px 2px 0 0;height:8px;width:8px}.mat-tab-header-pagination-disabled{box-shadow:none;cursor:default}.mat-tab-list{flex-grow:1;position:relative;transition:transform 500ms cubic-bezier(0.35, 0, 0.25, 1)}.mat-ink-bar{position:absolute;bottom:0;height:2px;transition:500ms cubic-bezier(0.35, 0, 0.25, 1)}.mat-ink-bar._mat-animation-noopable{transition:none !important;animation:none !important}.mat-tab-group-inverted-header .mat-ink-bar{bottom:auto;top:0}.cdk-high-contrast-active .mat-ink-bar{outline:solid 2px;height:0}.mat-tab-labels{display:flex}[mat-align-tabs=center]>.mat-tab-header .mat-tab-labels{justify-content:center}[mat-align-tabs=end]>.mat-tab-header .mat-tab-labels{justify-content:flex-end}.mat-tab-label-container{display:flex;flex-grow:1;overflow:hidden;z-index:1}.mat-tab-list._mat-animation-noopable{transition:none !important;animation:none !important}.mat-tab-label{height:48px;padding:0 24px;cursor:pointer;box-sizing:border-box;opacity:.6;min-width:160px;text-align:center;display:inline-flex;justify-content:center;align-items:center;white-space:nowrap;position:relative}.mat-tab-label:focus{outline:none}.mat-tab-label:focus:not(.mat-tab-disabled){opacity:1}.mat-tab-label.mat-tab-disabled{cursor:default}.cdk-high-contrast-active .mat-tab-label.mat-tab-disabled{opacity:.5}.mat-tab-label .mat-tab-label-content{display:inline-flex;justify-content:center;align-items:center;white-space:nowrap}.cdk-high-contrast-active .mat-tab-label{opacity:1}.mat-tab-label::before{margin:5px}@media(max-width: 599px){.mat-tab-label{min-width:72px}}"],encapsulation:2}),n})(),XLe=0,QLe=ko(qo(class{constructor(n){this._elementRef=n}}),"primary"),KLe=(()=>{class n extends QLe{constructor(e,i,r,o){super(e),this._changeDetectorRef=i,this._animationMode=o,this._tabs=new Hl,this._indexToSelect=0,this._lastFocusedTabIndex=null,this._tabBodyWrapperHeight=0,this._tabsSubscription=Sn.EMPTY,this._tabLabelSubscription=Sn.EMPTY,this._dynamicHeight=!1,this._selectedIndex=null,this.headerPosition="above",this._disablePagination=!1,this._preserveContent=!1,this.selectedIndexChange=new G,this.focusChange=new G,this.animationDone=new G,this.selectedTabChange=new G(!0),this._groupId=XLe++,this.animationDuration=r&&r.animationDuration?r.animationDuration:"500ms",this.disablePagination=!(!r||null==r.disablePagination)&&r.disablePagination,this.dynamicHeight=!(!r||null==r.dynamicHeight)&&r.dynamicHeight,this.contentTabIndex=r?.contentTabIndex??null,this.preserveContent=!!r?.preserveContent}get dynamicHeight(){return this._dynamicHeight}set dynamicHeight(e){this._dynamicHeight=Rt(e)}get selectedIndex(){return this._selectedIndex}set selectedIndex(e){this._indexToSelect=Bi(e,null)}get animationDuration(){return this._animationDuration}set animationDuration(e){this._animationDuration=/^\d+$/.test(e+"")?e+"ms":e}get contentTabIndex(){return this._contentTabIndex}set contentTabIndex(e){this._contentTabIndex=Bi(e,null)}get disablePagination(){return this._disablePagination}set disablePagination(e){this._disablePagination=Rt(e)}get preserveContent(){return this._preserveContent}set preserveContent(e){this._preserveContent=Rt(e)}get backgroundColor(){return this._backgroundColor}set backgroundColor(e){let i=this._elementRef.nativeElement;i.classList.remove(`mat-background-${this.backgroundColor}`),e&&i.classList.add(`mat-background-${e}`),this._backgroundColor=e}ngAfterContentChecked(){let e=this._indexToSelect=this._clampTabIndex(this._indexToSelect);if(this._selectedIndex!=e){let i=null==this._selectedIndex;if(!i){this.selectedTabChange.emit(this._createChangeEvent(e));let r=this._tabBodyWrapper.nativeElement;r.style.minHeight=r.clientHeight+"px"}Promise.resolve().then(()=>{this._tabs.forEach((r,o)=>r.isActive=o===e),i||(this.selectedIndexChange.emit(e),this._tabBodyWrapper.nativeElement.style.minHeight="")})}this._tabs.forEach((i,r)=>{i.position=r-e,null!=this._selectedIndex&&0==i.position&&!i.origin&&(i.origin=e-this._selectedIndex)}),this._selectedIndex!==e&&(this._selectedIndex=e,this._lastFocusedTabIndex=null,this._changeDetectorRef.markForCheck())}ngAfterContentInit(){this._subscribeToAllTabChanges(),this._subscribeToTabLabels(),this._tabsSubscription=this._tabs.changes.subscribe(()=>{let e=this._clampTabIndex(this._indexToSelect);if(e===this._selectedIndex){let r,i=this._tabs.toArray();for(let o=0;o<i.length;o++)if(i[o].isActive){this._indexToSelect=this._selectedIndex=o,this._lastFocusedTabIndex=null,r=i[o];break}!r&&i[e]&&Promise.resolve().then(()=>{i[e].isActive=!0,this.selectedTabChange.emit(this._createChangeEvent(e))})}this._changeDetectorRef.markForCheck()})}_subscribeToAllTabChanges(){this._allTabs.changes.pipe(zn(this._allTabs)).subscribe(e=>{this._tabs.reset(e.filter(i=>i._closestTabGroup===this||!i._closestTabGroup)),this._tabs.notifyOnChanges()})}ngOnDestroy(){this._tabs.destroy(),this._tabsSubscription.unsubscribe(),this._tabLabelSubscription.unsubscribe()}realignInkBar(){this._tabHeader&&this._tabHeader._alignInkBarToSelectedTab()}updatePagination(){this._tabHeader&&this._tabHeader.updatePagination()}focusTab(e){let i=this._tabHeader;i&&(i.focusIndex=e)}_focusChanged(e){this._lastFocusedTabIndex=e,this.focusChange.emit(this._createChangeEvent(e))}_createChangeEvent(e){let i=new class{};return i.index=e,this._tabs&&this._tabs.length&&(i.tab=this._tabs.toArray()[e]),i}_subscribeToTabLabels(){this._tabLabelSubscription&&this._tabLabelSubscription.unsubscribe(),this._tabLabelSubscription=Jt(...this._tabs.map(e=>e._stateChanges)).subscribe(()=>this._changeDetectorRef.markForCheck())}_clampTabIndex(e){return Math.min(this._tabs.length-1,Math.max(e||0,0))}_getTabLabelId(e){return`mat-tab-label-${this._groupId}-${e}`}_getTabContentId(e){return`mat-tab-content-${this._groupId}-${e}`}_setTabBodyWrapperHeight(e){if(!this._dynamicHeight||!this._tabBodyWrapperHeight)return;let i=this._tabBodyWrapper.nativeElement;i.style.height=this._tabBodyWrapperHeight+"px",this._tabBodyWrapper.nativeElement.offsetHeight&&(i.style.height=e+"px")}_removeTabBodyWrapperHeight(){let e=this._tabBodyWrapper.nativeElement;this._tabBodyWrapperHeight=e.clientHeight,e.style.height="",this.animationDone.emit()}_handleClick(e,i,r){e.disabled||(this.selectedIndex=i.focusIndex=r)}_getTabIndex(e,i){return e.disabled?null:i===(this._lastFocusedTabIndex??this.selectedIndex)?0:-1}_tabFocusChanged(e,i){e&&"mouse"!==e&&"touch"!==e&&(this._tabHeader.focusIndex=i)}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(nn),M(Aie,8),M(Pi,8))},n.\u0275dir=He({type:n,inputs:{dynamicHeight:"dynamicHeight",selectedIndex:"selectedIndex",headerPosition:"headerPosition",animationDuration:"animationDuration",contentTabIndex:"contentTabIndex",disablePagination:"disablePagination",preserveContent:"preserveContent",backgroundColor:"backgroundColor"},outputs:{selectedIndexChange:"selectedIndexChange",focusChange:"focusChange",animationDone:"animationDone",selectedTabChange:"selectedTabChange"},features:[tt]}),n})(),Z2=(()=>{class n extends KLe{constructor(e,i,r,o){super(e,i,r,o)}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(nn),M(Aie,8),M(Pi,8))},n.\u0275cmp=R({type:n,selectors:[["mat-tab-group"]],contentQueries:function(e,i,r){if(1&e&&Ei(r,xw,5),2&e){let o;Ne(o=Le())&&(i._allTabs=o)}},viewQuery:function(e,i){if(1&e&&(ot(DLe,5),ot(ALe,5)),2&e){let r;Ne(r=Le())&&(i._tabBodyWrapper=r.first),Ne(r=Le())&&(i._tabHeader=r.first)}},hostAttrs:[1,"mat-tab-group"],hostVars:4,hostBindings:function(e,i){2&e&&et("mat-tab-group-dynamic-height",i.dynamicHeight)("mat-tab-group-inverted-header","below"===i.headerPosition)},inputs:{color:"color",disableRipple:"disableRipple"},exportAs:["matTabGroup"],features:[$t([{provide:Tie,useExisting:n}]),tt],decls:6,vars:7,consts:[[3,"selectedIndex","disableRipple","disablePagination","indexFocused","selectFocusedIndex"],["tabHeader",""],["class","mat-tab-label mat-focus-indicator","role","tab","matTabLabelWrapper","","mat-ripple","","cdkMonitorElementFocus","",3,"id","mat-tab-label-active","ngClass","disabled","matRippleDisabled","click","cdkFocusChange",4,"ngFor","ngForOf"],[1,"mat-tab-body-wrapper"],["tabBodyWrapper",""],["role","tabpanel",3,"id","mat-tab-body-active","ngClass","content","position","origin","animationDuration","preserveContent","_onCentered","_onCentering",4,"ngFor","ngForOf"],["role","tab","matTabLabelWrapper","","mat-ripple","","cdkMonitorElementFocus","",1,"mat-tab-label","mat-focus-indicator",3,"id","ngClass","disabled","matRippleDisabled","click","cdkFocusChange"],[1,"mat-tab-label-content"],[3,"ngIf","ngIfElse"],["tabTextLabel",""],[3,"cdkPortalOutlet"],["role","tabpanel",3,"id","ngClass","content","position","origin","animationDuration","preserveContent","_onCentered","_onCentering"]],template:function(e,i){1&e&&(_(0,"mat-tab-header",0,1),P("indexFocused",function(o){return i._focusChanged(o)})("selectFocusedIndex",function(o){return i.selectedIndex=o}),E(2,OLe,5,15,"div",2),v(),_(3,"div",3,4),E(5,kLe,1,11,"mat-tab-body",5),v()),2&e&&(y("selectedIndex",i.selectedIndex||0)("disableRipple",i.disableRipple)("disablePagination",i.disablePagination),C(2),y("ngForOf",i._tabs),C(1),et("_mat-animation-noopable","NoopAnimations"===i._animationMode),C(2),y("ngForOf",i._tabs))},dependencies:[Fn,dn,Be,da,Yo,nte,Iie,Die,YLe],styles:[".mat-tab-group{display:flex;flex-direction:column;max-width:100%}.mat-tab-group.mat-tab-group-inverted-header{flex-direction:column-reverse}.mat-tab-label{height:48px;padding:0 24px;cursor:pointer;box-sizing:border-box;opacity:.6;min-width:160px;text-align:center;display:inline-flex;justify-content:center;align-items:center;white-space:nowrap;position:relative}.mat-tab-label:focus{outline:none}.mat-tab-label:focus:not(.mat-tab-disabled){opacity:1}.mat-tab-label.mat-tab-disabled{cursor:default}.cdk-high-contrast-active .mat-tab-label.mat-tab-disabled{opacity:.5}.mat-tab-label .mat-tab-label-content{display:inline-flex;justify-content:center;align-items:center;white-space:nowrap}.cdk-high-contrast-active .mat-tab-label{opacity:1}@media(max-width: 599px){.mat-tab-label{padding:0 12px}}@media(max-width: 959px){.mat-tab-label{padding:0 12px}}.mat-tab-group[mat-stretch-tabs]>.mat-tab-header .mat-tab-label{flex-basis:0;flex-grow:1}.mat-tab-body-wrapper{position:relative;overflow:hidden;display:flex;transition:height 500ms cubic-bezier(0.35, 0, 0.25, 1)}.mat-tab-body-wrapper._mat-animation-noopable{transition:none !important;animation:none !important}.mat-tab-body{top:0;left:0;right:0;bottom:0;position:absolute;display:block;overflow:hidden;outline:0;flex-basis:100%}.mat-tab-body.mat-tab-body-active{position:relative;overflow-x:hidden;overflow-y:auto;z-index:1;flex-grow:1}.mat-tab-group.mat-tab-group-dynamic-height .mat-tab-body.mat-tab-body-active{overflow-y:hidden}"],encapsulation:2}),n})(),J2=(oc(qo(so(class{}))),(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,ln,eu,_l,od,Ev,ln]}),n})());function ZLe(n,t){if(1&n){let e=Pe();_(0,"span",5),P("click",function(r){oe(e);let o=S().$implicit;return se(S().onActivePluginSelection(r,o.id))}),A(1),v()}if(2&n){let e=S().$implicit;ze("data-plugin-id",e.id),C(1),je(" ",e.tab_name," ")}}function JLe(n,t){1&n&&(_(0,"mat-tab",3),E(1,ZLe,2,2,"ng-template",4),v()),2&n&&y("disabled",!t.$implicit.enabled)}function $Le(n,t){if(1&n&&(_(0,"mat-option",9),A(1),v()),2&n){let e=t.$implicit;y("value",e.id),ze("data-plugin-id",e.id),C(1),je(" ",e.tab_name," ")}}function e3e(n,t){if(1&n){let e=Pe();_(0,"mat-form-field",6)(1,"mat-label"),A(2,"Inactive"),v(),_(3,"mat-select",7),P("selectionChange",function(r){return oe(e),se(S().onDisabledPluginSelectionChanged(r))}),E(4,$Le,2,3,"mat-option",8),v()()}if(2&n){let e=S();C(3),y("value",e.selectedPlugin),C(1),y("ngForOf",e.disabledPlugins)}}var Rie=(()=>{class n{constructor(){this.onPluginSelectionChanged=new G}getActivePluginIndex(){return this.activePlugins.findIndex(({id:e})=>e===this.selectedPlugin)}onActivePluginSelection(e,i){e.stopPropagation(),this.onPluginSelectionChanged.emit(i)}onDisabledPluginSelectionChanged(e){this.onPluginSelectionChanged.emit(e.value)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["plugin-selector-component"]],inputs:{activePlugins:"activePlugins",disabledPlugins:"disabledPlugins",selectedPlugin:"selectedPlugin"},outputs:{onPluginSelectionChanged:"onPluginSelectionChanged"},decls:3,vars:3,consts:[["animationDuration","100ms",1,"active-plugin-list",3,"selectedIndex"],[3,"disabled",4,"ngFor","ngForOf"],["floatLabel","never",4,"ngIf"],[3,"disabled"],["mat-tab-label",""],[1,"plugin-name",3,"click"],["floatLabel","never"],[3,"value","selectionChange"],[3,"value",4,"ngFor","ngForOf"],[3,"value"]],template:function(e,i){1&e&&(_(0,"mat-tab-group",0),E(1,JLe,2,1,"mat-tab",1),v(),E(2,e3e,5,2,"mat-form-field",2)),2&e&&(y("selectedIndex",i.getActivePluginIndex()),C(1),y("ngForOf",i.activePlugins),C(1),y("ngIf",i.disabledPlugins.length>0))},dependencies:[Z2,Eie,xw,pd,Nv,Hh,Os,dn,Be],styles:["[_nghost-%COMP%]{align-items:center;display:flex;flex:1 1 auto;font-size:14px;height:100%;overflow:hidden}mat-form-field[_ngcontent-%COMP%]{flex:0 0;margin-top:5px;width:130px}mat-label[_ngcontent-%COMP%], mat-select[_ngcontent-%COMP%], mat-option[_ngcontent-%COMP%]{font-weight:500;text-transform:uppercase}.active-plugin-list[_ngcontent-%COMP%]{align-self:stretch;flex:1 1 auto;overflow:hidden}.plugin-name[_ngcontent-%COMP%]{align-items:center;display:inline-flex;height:100%;justify-content:center;padding:0 12px;width:100%}[_nghost-%COMP%]     .active-plugin-list.mat-primary .mat-tab-list .mat-ink-bar{background-color:currentColor}[_nghost-%COMP%]     .active-plugin-list .mat-tab-label, [_nghost-%COMP%]     .active-plugin-list .mat-tab-link{color:inherit;opacity:.7}[_nghost-%COMP%]     .active-plugin-list .mat-tab-label.mat-tab-label-active, [_nghost-%COMP%]     .active-plugin-list .mat-tab-link.mat-tab-label-active{opacity:1}[_nghost-%COMP%]     .active-plugin-list .mat-tab-header-pagination-chevron{border-color:currentColor}[_nghost-%COMP%]     .active-plugin-list .mat-tab-header-pagination-disabled{visibility:hidden}[_nghost-%COMP%]     .active-plugin-list .mat-tab-disabled{display:none}[_nghost-%COMP%]     .active-plugin-list mat-tab-list, [_nghost-%COMP%]     .active-plugin-list .mat-tab-header, [_nghost-%COMP%]     .active-plugin-list .mat-tab-labels, [_nghost-%COMP%]     .active-plugin-list .mat-tab-label{height:100%}[_nghost-%COMP%]     .active-plugin-list .mat-tab-label{min-width:48px;padding:0;text-transform:uppercase}[_nghost-%COMP%]     .active-plugin-list .mat-tab-label-content{height:100%}[_nghost-%COMP%]     .active-plugin-list mat-tab-header .mat-tab-list{padding:0 36px}[_nghost-%COMP%]     .active-plugin-list mat-tab-header>:first-child, [_nghost-%COMP%]     .active-plugin-list mat-tab-header>.mat-tab-label-container, [_nghost-%COMP%]     .active-plugin-list mat-tab-header>:last-child{bottom:0;position:absolute;top:0}[_nghost-%COMP%]     .active-plugin-list mat-tab-header>:first-child, [_nghost-%COMP%]     .active-plugin-list mat-tab-header>.mat-tab-label-container{left:0}[_nghost-%COMP%]     .active-plugin-list mat-tab-header>:last-child, [_nghost-%COMP%]     .active-plugin-list mat-tab-header>.mat-tab-label-container{right:0}[_nghost-%COMP%]     .active-plugin-list mat-tab-header>.mat-tab-header-pagination{background-color:#f57c00}body.dark-mode   [_nghost-%COMP%]     .active-plugin-list mat-tab-header>.mat-tab-header-pagination{background-color:#ef6c00}"]}),n})(),Oie=J(rv,n=>Object.keys(n).map(t=>Object.assign({},{id:t},n[t]))),n3e=J(Oie,n=>n.filter(t=>!t.enabled)),kie=(()=>{class n{constructor(e){this.store=e,this.activePlugin$=this.store.pipe(vt(Rs)),this.plugins$=this.store.pipe(vt(Oie)),this.disabledPlugins$=this.store.pipe(vt(n3e))}onPluginSelectionChange(e){this.store.dispatch(Zu({plugin:e}))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["plugin-selector"]],decls:4,vars:9,consts:[[3,"activePlugins","disabledPlugins","selectedPlugin","onPluginSelectionChanged"]],template:function(e,i){1&e&&(_(0,"plugin-selector-component",0),P("onPluginSelectionChanged",function(o){return i.onPluginSelectionChange(o)}),B(1,"async"),B(2,"async"),B(3,"async"),v()),2&e&&y("activePlugins",U(1,3,i.plugins$))("disabledPlugins",U(2,5,i.disabledPlugins$))("selectedPlugin",U(3,7,i.activePlugin$))},dependencies:[Rie,Ge],encapsulation:2}),n})(),r3e=J(rv,Rs,(n,t)=>!(!t||!n[t])&&n[t].disable_reload),Fie=(()=>{class n{constructor(e){this.store=e,this.reloadDisabled$=this.store.select(r3e),this.isReloading$=this.store.select(L$).pipe(fr(this.reloadDisabled$),L(([i,r])=>!r&&i===Oe.LOADING)),this.lastLoadedTimeInMs$=this.store.select(iv)}triggerReload(){this.store.dispatch(Fa())}getReloadTitle(e){return e?`Last Updated: ${e}`:"Loading..."}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["app-header-reload"]],decls:6,vars:13,consts:[["mat-icon-button","",1,"reload-button",3,"title","disabled","click"],["svgIcon","refresh_24px",1,"refresh-icon"]],template:function(e,i){1&e&&(_(0,"button",0),P("click",function(){return i.triggerReload()}),B(1,"async"),B(2,"date"),B(3,"async"),B(4,"async"),O(5,"mat-icon",1),v()),2&e&&(et("loading",U(1,4,i.isReloading$)),y("title",i.getReloadTitle(Jf(2,6,U(3,9,i.lastLoadedTimeInMs$),"medium")))("disabled",U(4,11,i.reloadDisabled$)))},dependencies:[_n,Gt,Ge,U_],styles:[".reload-button[_ngcontent-%COMP%], .refresh-icon[_ngcontent-%COMP%] {\n        align-items: center;\n        display: flex;\n        justify-content: center;\n      }\n\n      .reload-button.loading[_ngcontent-%COMP%] {\n        animation: rotate 2s linear infinite;\n      }\n\n      @keyframes rotate {\n        0% {\n          transform: rotate(0deg);\n        }\n        50% {\n          transform: rotate(180deg);\n        }\n        100% {\n          transform: rotate(360deg);\n        }\n      }"]}),n})(),Nie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["app-header"]],decls:10,vars:0,consts:[[1,"brand"],[1,"plugins"],["mat-icon-button","","href","https://github.com/tensorflow/tensorboard/blob/master/README.md","rel","noopener noreferrer","target","_blank","aria-label","Help",1,"readme"],["svgIcon","help_outline_24px"]],template:function(e,i){1&e&&(_(0,"mat-toolbar")(1,"span",0),A(2,"TensorBoard"),v(),O(3,"plugin-selector",1)(4,"tbdev-upload-button")(5,"app-header-dark-mode-toggle")(6,"app-header-reload")(7,"settings-button"),_(8,"a",2),O(9,"mat-icon",3),v()())},dependencies:[Iv,Gt,Zne,lie,hie,yie,kie,Fie],styles:["mat-toolbar[_ngcontent-%COMP%]{align-items:center;color:#fff;display:flex;height:64px;overflow:hidden;width:100%}tbdev-upload-button.shown[_ngcontent-%COMP%]{margin:0 8px 0 16px}.brand[_ngcontent-%COMP%], .readme[_ngcontent-%COMP%], app-header-reload[_ngcontent-%COMP%], settings-button[_ngcontent-%COMP%]{flex:0 0 auto}.brand[_ngcontent-%COMP%]{letter-spacing:-0.025em;margin-left:10px;text-rendering:optimizeLegibility}.plugins[_ngcontent-%COMP%]{align-items:center;display:flex;flex:1 1 auto;font-size:14px;height:100%;overflow:hidden}"]}),n})(),l3e_setDocumentTitle=function(n){document.title=n},Lie=(()=>{class n{ngOnChanges(e){e.title&&l3e_setDocumentTitle(e.title.currentValue)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["page-title-component"]],inputs:{title:"title"},features:[Ft],decls:0,vars:0,template:function(e,i){},encapsulation:2,changeDetection:0}),n})(),Bie="TensorBoard",Vie=(()=>{class n{constructor(e,i){this.store=e,this.customBrandName=i,this.getExperimentId$=this.store.select(Wo).pipe(L(r=>r?.[0])),this.experimentName$=this.getExperimentId$.pipe(Ye(Boolean),xn(r=>this.store.select(vI,{experimentId:r})),L(r=>r?r.name:null)),this.title$=this.store.select(ov).pipe(fr(this.store.select(qu),this.experimentName$),L(([r,o,s])=>{let a=this.customBrandName||Bie;return r.window_title?r.window_title:o===hi.EXPERIMENT&&s?`${s} - ${a}`:a}),zn(this.customBrandName||Bie),yi())}}return n.\u0275fac=function(e){return new(e||n)(M(Ce),M(A$,8))},n.\u0275cmp=R({type:n,selectors:[["page-title"]],decls:2,vars:3,consts:[[3,"title"]],template:function(e,i){1&e&&(O(0,"page-title-component",0),B(1,"async")),2&e&&y("title",U(1,1,i.title$))},dependencies:[Lie,Ge],styles:["[_nghost-%COMP%] {\n        display: none;\n      }"],changeDetection:0}),n})(),Hie=(()=>{class n{constructor(e){this.store=e,this.ngUnsubscribe=new ke,this.getPageSize$=this.store.pipe(vt(Km)),this.paginatedViewStore=document.createElement("tf-paginated-view-store").tf_paginated_view}ngOnInit(){this.getPageSize$.pipe(st(this.ngUnsubscribe),yi()).subscribe(e=>{this.paginatedViewStore.setLimit(e)})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["settings-polymer-interop"]],decls:0,vars:0,template:function(e,i){},encapsulation:2,changeDetection:0}),n})(),Uie=(()=>{class n{constructor(e){this.vcRef=e}}return n.\u0275fac=function(e){return new(e||n)(M(Oi))},n.\u0275cmp=R({type:n,selectors:[["tb-webapp"]],decls:9,vars:0,template:function(e,i){1&e&&(O(0,"app-header"),_(1,"main"),O(2,"router-outlet"),v(),O(3,"alert-snackbar")(4,"hash-storage")(5,"page-title")(6,"settings-polymer-interop")(7,"dark-mode-supporter")(8,"feature-flag-modal-trigger"))},dependencies:[Hne,zne,Ite,jne,Wne,Nie,Vie,Hie],styles:["html[_ngcontent-%COMP%], body[_ngcontent-%COMP%]{font-family:Roboto,sans-serif;height:100%;margin:0;padding:0}[_nghost-%COMP%]{background:#f5f5f5;display:flex;flex-direction:column;height:100%}app-header[_ngcontent-%COMP%]{box-shadow:0 1px 3px 3px rgba(0,0,0,.25);flex:0 0;z-index:1}body.dark-mode[_nghost-%COMP%]   app-header[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   app-header[_ngcontent-%COMP%]{box-shadow:0 1px 3px 3px rgba(255,255,255,.1)}main[_ngcontent-%COMP%]{flex-grow:1;overflow:auto}"]}),n})(),zie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,Q_,X_,qc]}),n})(),jie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),Gie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[{provide:fh,useClass:r$}]}),n})(),Wie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,Gie]}),n})(),qie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me]}),n})(),Yie={id:TA,name:"",start_time:0},h3e=vr({experimentMap:{[Yie.id]:Yie}});function Xie(n,t){return Fm({data:h3e})(n,t)}var Qie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[wr.forFeature(_I,Xie)]}),n})(),Kie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,Pn,lc]}),n})(),Zie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,Kie]}),n})(),Jie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,jr,z2,Pn,Ls,Oh,pn,Ha]}),n})();function f3e(){return J(YM,n=>({autoReload:n}))}function m3e(){return J(XM,n=>({autoReloadPeriodInMs:n}))}function g3e(){return J(Km,n=>({pageSize:n}))}var $2=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[wr.forFeature(ZI,$ne),Sr.defineGlobalSetting(f3e),Sr.defineGlobalSetting(m3e),Sr.defineGlobalSetting(g3e),Jie]}),n})(),$ie=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[{provide:"window",useValue:window}],imports:[uie,Me,Pn,Oh,pn]}),n})(),ere=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Pn,pn,J2,Jne,lc,zh,Me,ec,$2,$ie]}),n})(),tre=(()=>{class n{constructor(e,i){let r=e.bypassSecurityTrustResourceUrl("./icon_bundle.svg");i.addSvgIconSet(r)}}return n.\u0275fac=function(e){return new(e||n)(j(Tm),j(zv))},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[pn]}),n})(),tU=new pe("[plugins] Plugin registry config"),nre=new Map,Bs=(()=>{class n{constructor(e){if(!e)return;let i=new Set(e.map(r=>r.pluginName));console.assert(i.size===e.length,"Cannot register the same plugin multiple times.");for(let r of e){let{pluginName:o,componentClass:s}=r;nre.set(o,s)}}static forPlugin(e,i){return{ngModule:n,providers:[{provide:tU,multi:!0,useValue:{pluginName:e,componentClass:i}}]}}getComponent(e){return nre.get(e)||null}}return n.\u0275fac=function(e){return new(e||n)(j(tU,8))},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),eP=(()=>{class n{constructor(e){this.http=e,this.httpPathPrefix="data/plugin/debugger-v2"}fetchRuns(){return this.http.get(this.httpPathPrefix+"/runs")}fetchExecutionDigests(e,i,r){return this.http.get(this.httpPathPrefix+"/execution/digests",{params:{run:e,begin:String(i),end:String(r)}})}fetchExecutionData(e,i,r){return this.http.get(this.httpPathPrefix+"/execution/data",{params:{run:e,begin:String(i),end:String(r)}})}fetchGraphExecutionDigests(e,i,r,o){if(void 0!==o)throw new Error("trace_id is not implemented for fetchGraphExecutionDigests() yet");return this.http.get(this.httpPathPrefix+"/graph_execution/digests",{params:{run:e,begin:String(i),end:String(r)}})}fetchGraphExecutionData(e,i,r,o){if(void 0!==o)throw new Error("trace_id is not implemented for fetchGraphExecutionData() yet");return this.http.get(this.httpPathPrefix+"/graph_execution/data",{params:{run:e,begin:String(i),end:String(r)}})}fetchGraphOpInfo(e,i,r){return this.http.get(this.httpPathPrefix+"/graphs/op_info",{params:{run:e,graph_id:i,op_name:r}})}fetchSourceFileList(e){return this.http.get(this.httpPathPrefix+"/source_files/list",{params:{run:e}})}fetchSourceFile(e,i){return this.http.get(this.httpPathPrefix+"/source_files/file",{params:{run:e,index:String(i)}})}fetchStackFrames(e,i){return this.http.get(this.httpPathPrefix+"/stack_frames/stack_frames",{params:{run:e,stack_frame_ids:i.join(",")}}).pipe(L(r=>({stack_frames:r.stack_frames.map(o=>function(n){return{host_name:n[0],file_path:n[1],lineno:n[2],function_name:n[3]}}(o))})))}fetchAlerts(e,i,r,o){let s={run:e,begin:String(i),end:String(r)};return void 0!==o&&(s.alert_type=o),this.http.get(this.httpPathPrefix+"/alerts",{params:s})}}return n.\u0275fac=function(e){return new(e||n)(j(ka))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),ire=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[eP],imports:[Ku]}),n})(),tP=be("[Debugger] Debugger Loaded"),nP=be("[Debugger] Debugger Unloaded"),Mw=be("[Debugger] A New Debugger Data Polling Event Begins"),iP=be("[Debugger] Debugger Runs Requested"),rP=be("[Debugger] Debugger Runs Loaded",{_as:"props",_p:void 0}),rre=be("[Debugger] Debugger Runs Request Failed"),ww=be("[Debugger] Number and Breakdown of Alerts Requested"),oP=be("[Debugger] Number and Breakdown of Alerts Loaded",{_as:"props",_p:void 0}),sP=be("[Debugger] Alerts Data of an AlertType Is Loaded",{_as:"props",_p:void 0}),Gv=be("[Debugger] Alert Type Focus Toggled",{_as:"props",_p:void 0}),aP=be("[Debugger] Number of Top-Level Executions Requested"),lP=be("[Debugger] Number of Top-Level Executions Loaded",{_as:"props",_p:void 0}),cP=be("[Debugger] ExecutionDigests Requested",{_as:"props",_p:void 0}),uP=be("[Debugger] ExecutionDigests Loaded",{_as:"props",_p:void 0}),Wv=be("[Debugger] Scroll Leftward on the Execution Timeline"),qv=be("[Debugger] Scroll Rightward on the Execution Timeline"),Yv=be("[Debugger] Scroll the Execution Timeline to Given Index",{_as:"props",_p:void 0}),Xv=be("[Debugger] Execution Data Objects Being Focused On",{_as:"props",_p:void 0}),dP=be("[Debugger] Execution Data Objects Loaded",{_as:"props",_p:void 0}),pP=be("[Debugger] Number of Intra-Graph Executions Requested"),hP=be("[Debugger] Number of Intra-Graph Executions Loaded",{_as:"props",_p:void 0}),fP=be("[Debugger] Intra-Graph Execution Data Requested",{_as:"props",_p:void 0}),mP=be("[Debugger] Intra-Graph Execution Data Loaded",{_as:"props",_p:void 0}),Qv=be("[Debugger] Scroll Intra-Graph Execution List to Given Index",{_as:"props",_p:void 0}),Kv=be("[Debugger] Graph Execution is Focused On",{_as:"props",_p:void 0}),Zv=be("[Debugger] Graph Op Is Focused On",{_as:"props",_p:void 0}),gP=be("[Debugger] Graph Op Info Requested",{_as:"props",_p:void 0}),_P=be("[Debugger] Graph Op Info Loaded",{_as:"props",_p:void 0}),vP=be("[Debugger] Source File List Requested."),yP=be("[Debugger] Source File List Loaded",{_as:"props",_p:void 0}),Jv=be("[Debugger] Source File Line Is Focused on",{_as:"props",_p:void 0}),bP=be("[Debugger] Source File Requested",{_as:"props",_p:void 0}),xP=be("[Debugger] Source File Loaded",{_as:"props",_p:void 0}),Sw=be("[Debugger] A Set of Stack Frames Have Been Loaded",{_as:"props",_p:void 0}),Ew="debugger",as=(()=>(function(n){n[n.UNSPECIFIED=0]="UNSPECIFIED",n[n.NO_TENSOR=1]="NO_TENSOR",n[n.CURT_HEALTH=2]="CURT_HEALTH",n[n.CONCISE_HEALTH=3]="CONCISE_HEALTH",n[n.FULL_HEALTH=4]="FULL_HEALTH",n[n.SHAPE=5]="SHAPE",n[n.FULL_NUMERICS=6]="FULL_NUMERICS",n[n.FULL_TENSOR=7]="FULL_TENSOR",n[n.REDUCE_INF_NAN_THREE_SLOTS=8]="REDUCE_INF_NAN_THREE_SLOTS"}(as||(as={})),as))(),md=(()=>(function(n){n.FUNCTION_RECOMPILE_ALERT="FunctionRecompilesAlert",n.INF_NAN_ALERT="InfNanAlert",n.TENSOR_SHAPE_ALERT="TensorShapeAlert"}(md||(md={})),md))(),xs=(()=>(function(n){n[n.EXECUTION=0]="EXECUTION",n[n.GRAPH_OP_CREATION=1]="GRAPH_OP_CREATION"}(xs||(xs={})),xs))();function $v(n){if(null===n.codeLocationFocusType)return null;let t=[];if(n.codeLocationFocusType===xs.EXECUTION){let{focusIndex:i,executionData:r}=n.executions;if(null===i||void 0===r[i])return null;t=r[i].stack_frame_ids}else{if(null===n.graphs.focusedOp)return null;let{graphId:i,opName:r}=n.graphs.focusedOp;if(void 0===n.graphs.ops[i]||!n.graphs.ops[i].has(r))return null;t=n.graphs.ops[i].get(r).stack_frame_ids}let e=[];for(let i of t){if(null==n.stackFrames[i])return null;e.push(n.stackFrames[i])}return e}function Tw(n,t){return n.findIndex(e=>e.host_name===t.host_name&&e.file_path===t.file_path)}function nU(n,t,e){if(t>=e)throw new Error(`Expected begin to be less than end, but got begin=${t}, end=${e}`);return n.findIndex(i=>i.begin===t&&i.end===e)}function CP(n){let t=n.sourceCode.focusLineSpec;if(!n.stickToBottommostFrameInFocusedFile)return t;let e=$v(n);if(null===e)return t;let i=function(n,t){if(null===t)return null;for(let e=n.length-1;e>=0;--e){let i=n[e],{host_name:r,file_path:o}=i;if(r===t.host_name&&o===t.file_path)return i}return null}(e,t);return null===i?t:i}var D3e=vr({runs:{},runsLoaded:{state:Oe.NOT_LOADED,lastLoadedTimeInMs:null},activeRunId:null,lastDataPollOnsetTimeMs:-1,lastNonEmptyPollDataTimeMs:1,alerts:{alertsLoaded:{state:Oe.NOT_LOADED,lastLoadedTimeInMs:null},numAlerts:0,alertsBreakdown:{},alerts:{},executionIndices:{},graphExecutionIndices:{},focusType:null},executions:{numExecutionsLoaded:{state:Oe.NOT_LOADED,lastLoadedTimeInMs:null},executionDigestsLoaded:{loadingRanges:[],numExecutions:0,pageLoadedSizes:{}},displayCount:50,pageSize:100,scrollBeginIndex:0,focusIndex:null,executionDigests:{},executionData:{}},graphExecutions:{numExecutionsLoaded:{state:Oe.NOT_LOADED,lastLoadedTimeInMs:null},executionDigestsLoaded:{loadingRanges:[],numExecutions:0,pageLoadedSizes:{}},displayCount:100,pageSize:200,scrollBeginIndex:0,focusIndex:null,graphExecutionDigests:{},graphExecutionDataLoadingPages:[],graphExecutionDataPageLoadedSizes:{},graphExecutionData:{}},graphs:{ops:{},loadingOps:{},focusedOp:null},stackFrames:{},codeLocationFocusType:null,stickToBottommostFrameInFocusedFile:!1,sourceCode:{sourceFileListLoaded:{state:Oe.NOT_LOADED,lastLoadedTimeInMs:null},sourceFileList:[],fileContents:[],focusLineSpec:null}},Se(iP,n=>({...n,runsLoaded:{...n.runsLoaded,state:Oe.LOADING}})),Se(rre,n=>({...n,runsLoaded:{...n.runsLoaded,state:Oe.FAILED}})),Se(rP,(n,{runs:t})=>{let e=Object.keys(t),i=e.length>0&&null===n.activeRunId;return{...n,lastNonEmptyPollDataTimeMs:i?Date.now():n.lastNonEmptyPollDataTimeMs,runs:t,runsLoaded:{state:Oe.LOADED,lastLoadedTimeInMs:Date.now()},activeRunId:e.length>0?e[0]:null}}),Se(Mw,n=>({...n,lastDataPollOnsetTimeMs:Date.now()})),Se(ww,n=>null===n.activeRunId?n:{...n,alerts:{...n.alerts,alertsLoaded:{...n.alerts.alertsLoaded,state:Oe.LOADING}}}),Se(oP,(n,{numAlerts:t,alertsBreakdown:e})=>{if(null===n.activeRunId)return n;let r=t>n.alerts.numAlerts;return{...n,lastNonEmptyPollDataTimeMs:r?Date.now():n.lastNonEmptyPollDataTimeMs,alerts:{...n.alerts,alertsLoaded:{...n.alerts.alertsLoaded,state:Oe.LOADED,lastLoadedTimeInMs:Date.now()},numAlerts:t,alertsBreakdown:e}}}),Se(sP,(n,{numAlerts:t,alertsBreakdown:e,alertType:i,begin:r,alerts:o})=>{if(null===n.activeRunId)return n;let a={},l=n.alerts.executionIndices[i]?n.alerts.executionIndices[i].slice():[],c=n.alerts.graphExecutionIndices[i]?n.alerts.graphExecutionIndices[i].slice():[];for(let p=0;p<o.length;++p){let h=r+p,f=o[p];if(a[h]=f,f.alert_type===md.INF_NAN_ALERT){let m=f;l[h]=m.execution_index,null!==m.graph_execution_trace_index&&(c[h]=m.graph_execution_trace_index)}}void 0!==n.alerts.alerts[i]&&Object.assign(a,n.alerts.alerts[i]);let u=n.executions.scrollBeginIndex,d=n.graphExecutions.focusIndex;if(i===md.INF_NAN_ALERT&&0===r){let p=o[0];u=Math.max(0,p.execution_index-Math.floor(n.executions.displayCount/2)),null!==p.graph_execution_trace_index&&(d=p.graph_execution_trace_index)}return{...n,executions:{...n.executions,scrollBeginIndex:u},graphExecutions:{...n.graphExecutions,focusIndex:d},alerts:{...n.alerts,alertsLoaded:{...n.alerts.alertsLoaded,state:Oe.LOADED,lastLoadedTimeInMs:Date.now()},numAlerts:t,alertsBreakdown:e,alerts:{...n.alerts.alerts,[i]:a},executionIndices:{...n.alerts.executionIndices,[i]:l},graphExecutionIndices:{...n.alerts.graphExecutionIndices,[i]:c}}}}),Se(Gv,(n,{alertType:t})=>{let e={...n,alerts:{...n.alerts,focusType:n.alerts.focusType===t?null:t}},i=e.alerts.focusType;if(null!==i){let r=e.alerts.executionIndices[i]||[];void 0!==r[0]&&(e.executions={...e.executions,scrollBeginIndex:Math.max(0,Number(r[0])-Math.floor(e.executions.displayCount/2))})}return e}),Se(aP,n=>null===n.activeRunId?n:{...n,executions:{...n.executions,numExecutionsLoaded:{...n.executions.numExecutionsLoaded,state:Oe.LOADING}}}),Se(lP,(n,{numExecutions:t})=>{if(null===n.activeRunId)return n;let i=t>n.executions.executionDigestsLoaded.numExecutions,r={...n,lastNonEmptyPollDataTimeMs:i?Date.now():n.lastNonEmptyPollDataTimeMs,executions:{...n.executions,numExecutionsLoaded:{...n.executions.numExecutionsLoaded,state:Oe.LOADED,lastLoadedTimeInMs:Date.now()},executionDigestsLoaded:{...n.executions.executionDigestsLoaded,numExecutions:t}}};return t>0&&null===n.executions.focusIndex&&(r.executions.focusIndex=0),r}),Se(cP,(n,t)=>{if(null===n.activeRunId)return n;let i=[...n.executions.executionDigestsLoaded.loadingRanges];return-1===nU(i,t.begin,t.end)&&i.push({begin:t.begin,end:t.end}),{...n,executions:{...n.executions,executionDigestsLoaded:{...n.executions.executionDigestsLoaded,loadingRanges:i}}}}),Se(uP,(n,t)=>{if(null===n.activeRunId)return n;let i=[...n.executions.executionDigestsLoaded.loadingRanges],r=nU(i,t.begin,t.end);-1!==r&&i.splice(r,1);let o={...n,executions:{...n.executions,executionDigestsLoaded:{...n.executions.executionDigestsLoaded,numExecutions:t.num_digests,loadingRanges:i},executionDigests:{...n.executions.executionDigests}}};for(let s=t.begin;s<t.end;++s)o.executions.executionDigests[s]=t.execution_digests[s-t.begin];return t.end>t.begin&&(o.executions.executionDigestsLoaded.pageLoadedSizes={...o.executions.executionDigestsLoaded.pageLoadedSizes,[t.begin/n.executions.pageSize]:t.end-t.begin}),o}),Se(Wv,n=>{if(null===n.activeRunId)return n;let e=n.executions.scrollBeginIndex;return e>0&&e--,{...n,executions:{...n.executions,scrollBeginIndex:e}}}),Se(qv,n=>{if(null===n.activeRunId)return n;let e=n.executions.scrollBeginIndex;return e+n.executions.displayCount+1<=n.executions.executionDigestsLoaded.numExecutions&&e++,{...n,executions:{...n.executions,scrollBeginIndex:e}}}),Se(Yv,(n,t)=>{if(t.index<0||!Number.isInteger(t.index))throw new Error(`Attempt to scroll to negative or non-integer execution index (${t.index})`);let{displayCount:e}=n.executions,{numExecutions:i}=n.executions.executionDigestsLoaded;if(t.index>Math.max(0,i-e))throw new Error(`Attempt to scroll to execution index (${t.index}), which exceeds maximum allowed index (numExecutions=${i}; displayCount=${e})`);return{...n,executions:{...n.executions,scrollBeginIndex:t.index}}}),Se(Xv,(n,t)=>{let e={...n,executions:{...n.executions,focusIndex:n.executions.scrollBeginIndex+t.displayIndex},codeLocationFocusType:xs.EXECUTION,sourceCode:{...n.sourceCode}};return e.sourceCode.focusLineSpec=CP(e),e}),Se(dP,(n,t)=>{if(null===n.activeRunId)return n;let i={...n,executions:{...n.executions,executionData:{...n.executions.executionData}}};for(let r=t.begin;r<t.end;++r)i.executions.executionData[r]=t.executions[r-t.begin];return i}),Se(pP,n=>null===n.activeRunId?n:{...n,graphExecutions:{...n.graphExecutions,numExecutionsLoaded:{...n.graphExecutions.numExecutionsLoaded,state:Oe.LOADING}}}),Se(hP,(n,{numGraphExecutions:t})=>{if(null===n.activeRunId)return n;let e=t>n.graphExecutions.executionDigestsLoaded.numExecutions,i={...n,lastNonEmptyPollDataTimeMs:e?Date.now():n.lastNonEmptyPollDataTimeMs,graphExecutions:{...n.graphExecutions,numExecutionsLoaded:{...n.graphExecutions.numExecutionsLoaded,state:Oe.LOADED,lastLoadedTimeInMs:Date.now()},executionDigestsLoaded:{...n.graphExecutions.executionDigestsLoaded,numExecutions:t}}};return t>0&&null===n.graphExecutions.focusIndex&&(i.graphExecutions.focusIndex=0),i}),Se(fP,(n,{pageIndex:t})=>{if(null===n.activeRunId)return n;let e=n.graphExecutions.graphExecutionDataLoadingPages.slice();return-1===e.indexOf(t)&&e.push(t),{...n,graphExecutions:{...n.graphExecutions,graphExecutionDataLoadingPages:e}}}),Se(mP,(n,t)=>{if(null===n.activeRunId)return n;let{pageSize:e}=n.graphExecutions,i=n.graphExecutions.graphExecutionDataLoadingPages.slice(),r={...n.graphExecutions.graphExecutionDataPageLoadedSizes},o={...n.graphExecutions.graphExecutionData};for(let s=t.begin;s<t.end;++s){let a=Math.floor(s/e);-1!==i.indexOf(a)&&i.splice(i.indexOf(a),1),void 0===r[a]&&(r[a]=0),void 0===o[s]&&r[a]++,o[s]=t.graph_executions[s-t.begin]}return{...n,graphExecutions:{...n.graphExecutions,graphExecutionDataLoadingPages:i,graphExecutionDataPageLoadedSizes:r,graphExecutionData:o}}}),Se(Qv,(n,t)=>{if(t.index<0||!Number.isInteger(t.index))throw new Error(`Attempt to scroll to negative or non-integer graph-execution index (${t.index})`);return{...n,graphExecutions:{...n.graphExecutions,scrollBeginIndex:t.index}}}),Se(Kv,(n,t)=>are(n,t.graph_id,t.op_name,t.index)),Se(Zv,(n,t)=>are(n,t.graph_id,t.op_name)),Se(gP,(n,t)=>{let{graph_id:e,op_name:i}=t,r={...n,graphs:{...n.graphs,loadingOps:{...n.graphs.loadingOps}}};return void 0===r.graphs.loadingOps[e]&&(r.graphs.loadingOps[e]=new Map),r.graphs.loadingOps[e].has(i)||r.graphs.loadingOps[e].set(i,Oe.LOADING),r}),Se(_P,(n,t)=>{let{graphOpInfoResponse:e}=t,{graph_ids:i}=e,r=i[i.length-1],o={...n,graphs:{...n.graphs,ops:{...n.graphs.ops,[r]:new Map(n.graphs.ops[r])},loadingOps:{...n.graphs.loadingOps,[r]:new Map(n.graphs.loadingOps[r])}}};for(let s of e.inputs)!s.data||o.graphs.ops[r].set(s.op_name,s.data);for(let s=0;s<e.consumers.length;++s)for(let a of e.consumers[s])!a.data||o.graphs.ops[r].set(a.op_name,a.data);return o.graphs.ops[r].set(e.op_name,{...e,inputs:e.inputs.map(s=>({op_name:s.op_name,output_slot:s.output_slot})),consumers:e.consumers.map(s=>s.map(a=>({op_name:a.op_name,input_slot:a.input_slot})))}),o.graphs.loadingOps[r].set(e.op_name,Oe.LOADED),o}),Se(vP,n=>({...n,sourceCode:{...n.sourceCode,sourceFileListLoaded:{...n.sourceCode.sourceFileListLoaded,state:Oe.LOADING}}})),Se(yP,(n,t)=>{let e={...n,sourceCode:{...n.sourceCode,sourceFileListLoaded:{...n.sourceCode.sourceFileListLoaded,state:Oe.LOADED,lastLoadedTimeInMs:Date.now()},sourceFileList:t.sourceFiles,fileContents:n.sourceCode.fileContents.slice()}},i=t.sourceFiles.length,{fileContents:r}=e.sourceCode;for(let o=0;o<i;++o)r[o]=n.sourceCode.fileContents[o]??{loadState:Oe.NOT_LOADED,lines:null};return e}),Se(Jv,(n,t)=>{let e=$v(n),i={...n,sourceCode:{...n.sourceCode,focusLineSpec:t.stackFrame}};return null!==e&&(i.stickToBottommostFrameInFocusedFile=function(n,t){let e=-1,i=-1;if(n.forEach(({file_path:r,lineno:o},s)=>{r===t.file_path&&(i=s,o===t.lineno&&(e=s))}),-1===e)throw new Error(`Stack frame ${JSON.stringify(t)} is not found.`);return e===i}(e,t.stackFrame)),i}),Se(bP,(n,t)=>{let e={...n,sourceCode:{...n.sourceCode,fileContents:n.sourceCode.fileContents.slice()}},i=Tw(e.sourceCode.sourceFileList,t);if(!(i>=0))throw new Error(`Cannot find the following file in file list: host_name="${t.host_name}", file_path="${t.file_path}"`);return e.sourceCode.fileContents.splice(i,1,{...e.sourceCode.fileContents[i],loadState:Oe.LOADING}),e}),Se(xP,(n,t)=>{let e={...n,sourceCode:{...n.sourceCode,fileContents:n.sourceCode.fileContents.slice()}},i=Tw(e.sourceCode.sourceFileList,t);if(!(i>=0))throw new Error(`Cannot find the following file in file list: host_name="${t.host_name}", file_path="${t.file_path}"`);return e.sourceCode.fileContents.splice(i,1,{loadState:Oe.LOADED,lines:t.lines}),e}),Se(Sw,(n,t)=>{if(null===n.activeRunId)return n;let i={...n,stackFrames:{...n.stackFrames,...t.stackFrames},sourceCode:{...n.sourceCode}};return i.sourceCode.focusLineSpec=CP(i),i}));function are(n,t,e,i){let r={...n,graphs:{...n.graphs,focusedOp:{graphId:t,opName:e}},codeLocationFocusType:xs.GRAPH_OP_CREATION,sourceCode:{...n.sourceCode}};return r.sourceCode.focusLineSpec=CP(r),void 0!==i&&(r.graphExecutions={...n.graphExecutions,focusIndex:i}),r}function lre(n,t){return D3e(n,t)}var ls=Mr(Ew),ug=J(ls,n=>n.runs),iU=J(ls,n=>n.runsLoaded),Vs=J(ls,n=>n.activeRunId),cre=J(ls,n=>n.lastDataPollOnsetTimeMs-n.lastNonEmptyPollDataTimeMs),ey=J(ls,n=>n.alerts),rU=J(ey,n=>n.alertsLoaded),ure=J(ey,n=>n.numAlerts),MP=J(ey,n=>n.focusType),dre=J(ey,n=>null===n.focusType?0:n.alertsBreakdown[n.focusType]||0),pre=J(ey,n=>null===n.focusType||void 0===n.alerts[n.focusType]?null:n.alerts[n.focusType]),hre=J(ey,n=>n.alertsBreakdown),dg=J(ls,n=>n.executions),wP=J(dg,n=>n.numExecutionsLoaded),Dw=J(dg,n=>n.executionDigestsLoaded),jh=J(dg,n=>n.executionDigestsLoaded.numExecutions),Aw=J(dg,n=>n.scrollBeginIndex),ty=J(dg,n=>n.pageSize),ny=J(dg,n=>n.displayCount),fre=J(dg,n=>{let t=[];for(let e=n.scrollBeginIndex;e<n.scrollBeginIndex+n.displayCount;++e)t.push(e in n.executionDigests?n.executionDigests[e]:null);return t}),Gh=J(ls,n=>n.graphExecutions),mre=J(Gh,n=>n.numExecutionsLoaded),Iw=J(ls,n=>n.graphExecutions.executionDigestsLoaded.numExecutions),gre=J(Gh,n=>n.scrollBeginIndex),_re=J(Gh,n=>n.displayCount),vre=J(Gh,n=>n.pageSize),yre=J(Gh,n=>n.graphExecutionDataLoadingPages),bre=J(Gh,n=>n.graphExecutionDataPageLoadedSizes),oU=J(Gh,n=>n.graphExecutionData),sU=J(Gh,n=>n.focusIndex),aU=J(ls,n=>n.graphs),lU=J(aU,n=>{let{focusedOp:t,ops:e}=n;return null===t||void 0===e[t.graphId]?null:e[t.graphId].get(t.opName)||null}),cU=J(aU,n=>{let{focusedOp:t,ops:e}=n;if(null===t||void 0===e[t.graphId]||!e[t.graphId].has(t.opName))return null;{let i=e[t.graphId],{inputs:r}=i.get(t.opName);return r.map(o=>{let s={...o};return i.has(o.op_name)&&(s.data=i.get(o.op_name)),s})}}),xre=J(sU,oU,cU,(n,t,e)=>{if(null===n||null===e)return null;let i=e.map(a=>!1),r=[];if(0===e.length)return r;let o=t[n].graph_id,s=Math.max(0,n-200);for(let a=n-1;a>=s;--a)if(void 0!==t[a])for(let l=0;l<e.length&&(i[l]||t[a].graph_id!==o||t[a].op_name!==e[l].op_name||t[a].output_slot!==e[l].output_slot||(r.push(a),i[l]=!0,r.length!==e.length));++l);return r}),Cre=J(aU,n=>{let{focusedOp:t,ops:e}=n;if(null===t||void 0===e[t.graphId]||!e[t.graphId].has(t.opName))return null;{let i=e[t.graphId],{consumers:r}=i.get(t.opName);return r.map(o=>o.map(s=>{let a={...s};return i.has(s.op_name)&&(a.data=i.get(s.op_name)),a}))}}),Mre=J(ls,n=>{let t=n.executions.scrollBeginIndex,e=n.executions.scrollBeginIndex+n.executions.displayCount,i=new Array(e-t).fill(null),r=n.alerts.focusType;if(null===r)return i;let o=n.alerts.executionIndices[r];if(void 0===o)return i;for(let s=t;s<e;++s)o.includes(s)&&(i[s-t]=n.alerts.focusType);return i}),SP=J(ls,n=>n.executions),uU=J(SP,n=>n.focusIndex),wre=J(SP,n=>{if(null===n.focusIndex)return null;let{focusIndex:t,scrollBeginIndex:e,displayCount:i}=n;return t<e||t>=e+i?null:t-e}),dU=J(SP,n=>n.executionData),Sre=J(ls,n=>n.graphs.loadingOps),pU=J(ls,n=>n.stackFrames),pg=J(SP,n=>{let{focusIndex:t,executionData:e}=n;return null===t||void 0===e[t]?null:e[t]}),Pw=J(ls,uU,pg,lU,(n,t,e,i)=>{let{codeLocationFocusType:r}=n;return null===r?null:r===xs.EXECUTION?null===t||null===e?null:{codeLocationType:xs.EXECUTION,opType:e.op_type,executionIndex:t}:null===i?null:{codeLocationType:xs.GRAPH_OP_CREATION,opType:i.op_type,opName:i.op_name}}),Ere=J(ls,$v),EP=J(ls,n=>n.sourceCode),Tre=J(EP,n=>n.sourceFileListLoaded),hU=(J(EP,n=>n.sourceFileList),J(EP,n=>{let{sourceFileList:t,focusLineSpec:e}=n;return null===e?-1:Tw(t,e)})),TP=J(EP,hU,(n,t)=>-1===t?null:n.fileContents[t]||null),DP=J(ls,n=>n.sourceCode.focusLineSpec),Dre=J(ls,n=>n.stickToBottommostFrameInFocusedFile),Are=function(n){return[n]};function I3e(n,t){if(1&n){let e=Pe();_(0,"div",7),P("click",function(){let o=oe(e).$implicit;return se(S().onToggleFocusType.emit(o.type))}),_(1,"div",8),A(2),v(),_(3,"div",9),A(4),v(),O(5,"div"),v()}if(2&n){let e=t.$implicit,i=S();y("ngClass",On(4,Are,e.type===i.focusType?"focus":"")),C(2),yt(e.displayName),C(2),Xp(" ",e.displaySymbol,": ",e.count," ")}}var Ire=(()=>{class n{constructor(){this.numAlerts=0,this.alertsBreakdown=[],this.focusType=null,this.onToggleFocusType=new G}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["alerts-component"]],inputs:{numAlerts:"numAlerts",alertsBreakdown:"alertsBreakdown",focusType:"focusType"},outputs:{onToggleFocusType:"onToggleFocusType"},decls:10,vars:5,consts:[[1,"alerts-container"],[1,"debugging-title"],[1,"num-alerts-container"],[1,"num-alerts-label"],[1,"num-alerts-value",3,"ngClass"],[1,"alerts-breakdown-container"],["class","alerts-breakdown-type",3,"ngClass","click",4,"ngFor","ngForOf"],[1,"alerts-breakdown-type",3,"ngClass","click"],[1,"alert-type-name"],[1,"alert-type-count"]],template:function(e,i){1&e&&(_(0,"div",0)(1,"div",1),A(2,"Debugging"),v(),_(3,"div",2)(4,"div",3),A(5,"Alerts"),v(),_(6,"div",4),A(7),v()(),_(8,"div",5),E(9,I3e,6,6,"div",6),v()()),2&e&&(C(6),y("ngClass",On(3,Are,i.numAlerts>0?"non-zero":"")),C(1),je(" ",i.numAlerts," "),C(2),y("ngForOf",i.alertsBreakdown))},dependencies:[Fn,dn],styles:[".alerts-breakdown-container[_ngcontent-%COMP%] {\n  font-size: 13px;\n  padding: 10px 10px 10px;\n  position: relative;\n}\n\n.alerts-breakdown-type[_ngcontent-%COMP%] {\n  border-radius: 0 10px 10px 0;\n  cursor: pointer;\n  display: flex;\n  padding: 6px 0 6px 50px;\n  vertical-align: middle;\n}\n\n.alerts-breakdown-type.focus[_ngcontent-%COMP%] {\n  background-color: #ffeee0;\n}\n\n.alerts-container[_ngcontent-%COMP%] {\n  font-family: 'Roboto', Arial, Helvetica, sans-serif;\n}\n\n.alert-type-count[_ngcontent-%COMP%] {\n  \n  background-color: #e52592;\n  border-radius: 3px;\n  color: #fff;\n  display: inline-block;\n  padding: 3px;\n  position: absolute;\n  right: 20px;\n  vertical-align: middle;\n}\n\n.alert-type-name[_ngcontent-%COMP%] {\n  display: inline-block;\n  padding: 3px;\n  vertical-align: middle;\n}\n\n.debugging-title[_ngcontent-%COMP%] {\n  font-size: 18px;\n}\n\n.num-alerts-container[_ngcontent-%COMP%] {\n  font-weight: bold;\n  padding: 10px 10px 10px 30px;\n  position: relative;\n}\n\n.num-alerts-label[_ngcontent-%COMP%] {\n  display: inline-block;\n  font-size: 13px;\n}\n\n.num-alerts-value[_ngcontent-%COMP%] {\n  border-radius: 12px;\n  display: inline-block;\n  font-size: 13px;\n  font-weight: normal;\n  line-height: 24px;\n  position: absolute;\n  right: 20px;\n  text-align: center;\n  vertical-align: middle;\n  width: 24px;\n}\n\n.num-alerts-value.non-zero[_ngcontent-%COMP%] {\n  background-color: #ffb780;\n  font-weight: bold;\n}"]}),n})(),R3e={[md.FUNCTION_RECOMPILE_ALERT]:{displayName:"Function recompiles",displaySymbol:"C"},[md.INF_NAN_ALERT]:{displayName:"NaN/\u221e",displaySymbol:"\u221e"},[md.TENSOR_SHAPE_ALERT]:{displayName:"Tensor shape",displaySymbol:"\u25a0"}},Pre=(()=>{class n{constructor(e){this.store=e,this.numAlerts$=this.store.pipe(vt(ure)),this.alertsBreakdown$=this.store.pipe(vt(J(hre,i=>{let r=Object.keys(i);return r.sort(),r.map(o=>({type:o,...R3e[o],count:i[o]}))}))),this.focusType$=this.store.pipe(vt(MP))}onToggleFocusType(e){this.store.dispatch(Gv({alertType:e}))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["tf-debugger-v2-alerts"]],decls:4,vars:9,consts:[[3,"numAlerts","alertsBreakdown","focusType","onToggleFocusType"]],template:function(e,i){1&e&&(_(0,"alerts-component",0),P("onToggleFocusType",function(o){return i.onToggleFocusType(o)}),B(1,"async"),B(2,"async"),B(3,"async"),v()),2&e&&y("numAlerts",U(1,3,i.numAlerts$))("alertsBreakdown",U(2,5,i.alertsBreakdown$))("focusType",U(3,7,i.focusType$))},dependencies:[Ire,Ge],encapsulation:2,changeDetection:0}),n})(),Rw={19:"float16",1:"float32",2:"float64",3:"int32",4:"uint8",17:"uint16",22:"uint32",23:"uint64",5:"int16",6:"int8",7:"string",8:"complex64",18:"complex128",9:"int64",10:"bool",11:"qint8",12:"quint8",15:"qint16",16:"quint16",13:"qint32",14:"bfloat16",20:"resource",21:"variant",119:"float16_ref",101:"float32_ref",102:"float64_ref",103:"int32_ref",122:"uint32_ref",104:"uint8_ref",117:"uint16_ref",105:"int16_ref",106:"int8_ref",107:"string_ref",108:"complex64_ref",118:"complex128_ref",109:"int64_ref",123:"uint64_ref",110:"bool_ref",111:"qint8_ref",112:"quint8_ref",115:"qint16_ref",116:"quint16_ref",113:"qint32_ref",114:"bfloat16_ref",120:"resource_ref",121:"variant_ref"};function AP(n){let{tensorDebugMode:t,array:e}=n;switch(t){case as.NO_TENSOR:if(null!==e)throw new Error("Unexpectedly received non-null debug-tensor-value array under NO_TENSOR mode");return{};case as.CURT_HEALTH:if(null===e||2!==e.length)throw new Error(`Under CURT_HEALTH mode, expected debug-tensor-value array to have length 2, but got ${JSON.stringify(e)}`);return{hasInfOrNaN:Boolean(e[1])};case as.CONCISE_HEALTH:{if(null===e||5!==e.length)throw new Error(`Under CONCISE_HEALTH mode, expected debug-tensor-value array to have length 5, but got ${JSON.stringify(e)}`);let i={size:e[1]};return e[2]>0&&(i.numNegativeInfs=e[2]),e[3]>0&&(i.numPositiveInfs=e[3]),e[4]>0&&(i.numNaNs=e[4]),i}case as.SHAPE:{if(null===e||10!==e.length)throw new Error(`Under SHAPE mode, expected debug-tensor-value array to have length 10, but got ${JSON.stringify(e)}`);let i=e[2],r=e.slice(4,Math.min(4+i,e.length));return r.length<i&&(r=new Array(i-r.length).concat(r)),{dtype:Rw[e[1]],rank:i,size:e[3],shape:r}}case as.FULL_HEALTH:{if(null===e||11!==e.length)throw new Error(`Under FULL_HEALTH mode, expected debug-tensor-value array to have length 11, but got ${JSON.stringify(e)}`);let r={dtype:Rw[e[2]],rank:e[3],size:e[4]};return e[5]>0&&(r.numNegativeInfs=e[5]),e[6]>0&&(r.numPositiveInfs=e[6]),e[7]>0&&(r.numNaNs=e[7]),e[8]>0&&(r.numNegativeFinites=e[8]),e[9]>0&&(r.numZeros=e[9]),e[10]>0&&(r.numPositiveFinites=e[10]),r}case as.FULL_TENSOR:if(null!==e)throw new Error("Unexpectedly received non-null debug-tensor-value array under FULL_TENSOR mode");return{};default:throw new Error(`Unrecognized tensorDebugMode: ${t}`)}}var fU="[_nghost-%COMP%] {\n    background-color: #e3e5e8;\n    border: 1px solid #c0c0c0;\n    border-radius: 4px;\n    font-family: 'Roboto Mono', monospace;\n    height: 14px;\n    line-height: 14px;\n    margin: 0 2px;\n    padding: 1px 3px;\n    width: max-content;\n  }";function k3e(n,t){1&n&&O(0,"div",4)}function F3e(n,t){if(1&n&&(_(0,"div",7)(1,"span",8),A(2,"NaN"),v(),_(3,"span",9),A(4),v()()),2&n){let e=S(2);C(4),je("\xd7",e.numNaNs,"")}}function N3e(n,t){if(1&n&&(_(0,"div",7)(1,"span",8),A(2,"-\u221e"),v(),_(3,"span",9),A(4),v()()),2&n){let e=S(2);C(4),je("\xd7",e.numNegativeInfs,"")}}function L3e(n,t){if(1&n&&(_(0,"div",7)(1,"span",8),A(2,"+\u221e"),v(),_(3,"span",9),A(4),v()()),2&n){let e=S(2);C(4),je("\xd7",e.numPositiveInfs,"")}}function B3e(n,t){if(1&n&&(_(0,"div",7)(1,"span",10),A(2,"-"),v(),_(3,"span",9),A(4),v()()),2&n){let e=S(2);C(4),je("\xd7",e.numNegativeFinites,"")}}function V3e(n,t){if(1&n&&(_(0,"div",7)(1,"span",10),A(2,"0"),v(),_(3,"span",9),A(4),v()()),2&n){let e=S(2);C(4),je("\xd7",e.numZeros,"")}}function H3e(n,t){if(1&n&&(_(0,"div",7)(1,"span",10),A(2,"+"),v(),_(3,"span",9),A(4),v()()),2&n){let e=S(2);C(4),je("\xd7",e.numPositiveFinites,"")}}function U3e(n,t){if(1&n&&(_(0,"div",5),E(1,F3e,5,1,"div",6),E(2,N3e,5,1,"div",6),E(3,L3e,5,1,"div",6),E(4,B3e,5,1,"div",6),E(5,V3e,5,1,"div",6),E(6,H3e,5,1,"div",6),v()),2&n){let e=S();C(1),y("ngIf",void 0!==e.numNaNs&&e.numNaNs>0),C(1),y("ngIf",void 0!==e.numNegativeInfs&&e.numNegativeInfs>0),C(1),y("ngIf",void 0!==e.numPositiveInfs&&e.numPositiveInfs>0),C(1),y("ngIf",void 0!==e.numNegativeFinites&&e.numNegativeFinites>0),C(1),y("ngIf",void 0!==e.numZeros&&e.numZeros>0),C(1),y("ngIf",void 0!==e.numPositiveFinites&&e.numPositiveFinites>0)}}var z3e=function(n){return["container",n]};function j3e(n,t){1&n&&O(0,"debug-tensor-dtype",5),2&n&&y("dtype",S().debugTensorValue.dtype)}function G3e(n,t){1&n&&O(0,"debug-tensor-rank",6),2&n&&y("rank",S().debugTensorValue.rank)}function W3e(n,t){1&n&&O(0,"debug-tensor-shape",7),2&n&&y("shape",S().debugTensorValue.shape)}function q3e(n,t){1&n&&O(0,"debug-tensor-has-inf-or-nan",8),2&n&&y("hasInfOrNaN",S().debugTensorValue.hasInfOrNaN)}function Y3e(n,t){if(1&n&&O(0,"debug-tensor-numeric-breakdown",9),2&n){let e=S();Zi("size",e.debugTensorValue.size),y("numNegativeInfs",e.debugTensorValue.numNegativeInfs)("numPositiveInfs",e.debugTensorValue.numPositiveInfs)("numNaNs",e.debugTensorValue.numNaNs)("numNegativeFinites",e.debugTensorValue.numNegativeFinites)("numZeros",e.debugTensorValue.numZeros)("numPositiveFinites",e.debugTensorValue.numPositiveFinites)}}var X3e=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["debug-tensor-dtype"]],inputs:{dtype:"dtype"},decls:1,vars:1,template:function(e,i){1&e&&A(0),2&e&&je(" ",i.dtype," ")},styles:[fU]}),n})(),Q3e=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["debug-tensor-rank"]],inputs:{rank:"rank"},decls:1,vars:1,template:function(e,i){1&e&&A(0),2&e&&je(" ",i.rank,"D ")},styles:[fU]}),n})(),K3e=(()=>{class n{get shapeString(){return"["+this.shape.map(e=>void 0===e?"?":String(e)).join(",")+"]"}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["debug-tensor-shape"]],inputs:{shape:"shape"},decls:1,vars:1,template:function(e,i){1&e&&A(0),2&e&&je(" shape:",i.shapeString," ")},styles:[fU]}),n})(),Z3e=(()=>{class n{get breakdownExists(){return void 0!==this.numNaNs||void 0!==this.numNegativeInfs||void 0!==this.numPositiveInfs||void 0!==this.numNegativeFinites||void 0!==this.numZeros||void 0!==this.numPositiveFinites}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["debug-tensor-numeric-breakdown"]],inputs:{size:"size",numNaNs:"numNaNs",numNegativeInfs:"numNegativeInfs",numPositiveInfs:"numPositiveInfs",numNegativeFinites:"numNegativeFinites",numZeros:"numZeros",numPositiveFinites:"numPositiveFinites"},decls:7,vars:3,consts:[[1,"size"],[1,"size-value"],["class","break",4,"ngIf"],["class","breakdown",4,"ngIf"],[1,"break"],[1,"breakdown"],["class","category",4,"ngIf"],[1,"category"],[1,"category-tag","infinite"],[1,"category-count"],[1,"category-tag","finite"]],template:function(e,i){1&e&&(_(0,"div",0)(1,"span"),A(2,"size:"),v(),_(3,"span",1),A(4),v()(),E(5,k3e,1,0,"div",2),E(6,U3e,7,6,"div",3)),2&e&&(C(4),yt(i.size),C(1),y("ngIf",i.breakdownExists),C(1),y("ngIf",i.breakdownExists))},dependencies:[Be],styles:["[_nghost-%COMP%] {\n        background-color: #e3e5e8;\n        border: 1px solid #c0c0c0;\n        border-radius: 4px;\n        font-family: 'Roboto Mono', monospace;\n        font-size: 10px;\n        margin: 0 2px;\n        padding: 1px;\n      }\n      .break[_ngcontent-%COMP%] {\n        flex-basis: 100%;\n        width: 0;\n      }\n      .size[_ngcontent-%COMP%] {\n        display: block;\n        height: 11px;\n        line-height: 11px;\n        margin: 0 3px;\n        vertical-align: middle;\n      }\n      .breakdown[_ngcontent-%COMP%] {\n        border-top: 1px solid rgba(0, 0, 0, 0.12);\n        display: flex;\n        height: 11px;\n        line-height: 11px;\n        padding: 2px;\n        vertical-align: middle;\n      }\n      .category[_ngcontent-%COMP%] {\n        margin-bottom: 2px;\n        margin-left: 4px;\n        margin-top: 2px;\n        heigth: 100%;\n        width: max-content;\n      }\n      .category-tag[_ngcontent-%COMP%] {\n        border-radius: 2px;\n        padding: 0 2px;\n      }\n      .finite[_ngcontent-%COMP%] {\n        background-color: #aaa;\n        color: #fefefe;\n      }\n      .infinite[_ngcontent-%COMP%] {\n        background-color: #e52592;\n        color: #fff;\n      }"]}),n})(),J3e=(()=>{class n{get infoString(){return this.hasInfOrNaN?"Has \u221e/NaN":"No \u221e/NaN"}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["debug-tensor-has-inf-or-nan"]],inputs:{hasInfOrNaN:"hasInfOrNaN"},decls:2,vars:4,consts:[[3,"ngClass"]],template:function(e,i){1&e&&(_(0,"div",0),A(1),v()),2&e&&(y("ngClass",On(2,z3e,i.hasInfOrNaN?"has-inf-or-nan":"")),C(1),je(" ",i.infoString," "))},dependencies:[Fn],styles:[".container[_ngcontent-%COMP%] {\n        background-color: #e3e5e8;\n        border: 1px solid #c0c0c0;\n        border-radius: 4px;\n        color: #666666;\n        font-family: 'Roboto Mono', monospace;\n        height: 14px;\n        line-height: 14px;\n        margin: 0 2px;\n        padding: 1px 3px;\n        width: max-content;\n      }\n      .has-inf-or-nan[_ngcontent-%COMP%] {\n        background-color: #e52592;\n        color: #fff;\n      }"]}),n})(),IP=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["debug-tensor-value"]],inputs:{debugTensorValue:"debugTensorValue"},decls:5,vars:5,consts:[[3,"dtype",4,"ngIf"],[3,"rank",4,"ngIf"],[3,"shape",4,"ngIf"],[3,"hasInfOrNaN",4,"ngIf"],[3,"size","numNegativeInfs","numPositiveInfs","numNaNs","numNegativeFinites","numZeros","numPositiveFinites",4,"ngIf"],[3,"dtype"],[3,"rank"],[3,"shape"],[3,"hasInfOrNaN"],[3,"size","numNegativeInfs","numPositiveInfs","numNaNs","numNegativeFinites","numZeros","numPositiveFinites"]],template:function(e,i){1&e&&(E(0,j3e,1,1,"debug-tensor-dtype",0),E(1,G3e,1,1,"debug-tensor-rank",1),E(2,W3e,1,1,"debug-tensor-shape",2),E(3,q3e,1,1,"debug-tensor-has-inf-or-nan",3),E(4,Y3e,1,7,"debug-tensor-numeric-breakdown",4)),2&e&&(y("ngIf",void 0!==i.debugTensorValue.dtype),C(1),y("ngIf",void 0!==i.debugTensorValue.rank),C(1),y("ngIf",void 0!==i.debugTensorValue.shape),C(1),y("ngIf",void 0!==i.debugTensorValue.hasInfOrNaN),C(1),y("ngIf",void 0!==i.debugTensorValue.size))},dependencies:[Be,X3e,J3e,Z3e,Q3e,K3e],styles:["[_nghost-%COMP%] {\n        align-items: flex-start;\n        display: flex;\n        flex-wrap: nowrap;\n        overflow: hidden;\n        vertical-align: top;\n      }\n      debug-tensor-numeric-breakdown[_ngcontent-%COMP%] {\n        display: inline-block;\n      }"]}),n})();function $3e(n,t){1&n&&(_(0,"div",12),A(1,"\u25b6"),v())}var eBe=function(n,t){return{tensorDebugMode:n,array:t}};function tBe(n,t){if(1&n&&O(0,"debug-tensor-value",17),2&n){let e=S(2).$implicit,i=S(2);y("debugTensorValue",i.parseDebugTensorValue(Qr(1,eBe,i.graphExecutionData[e].tensor_debug_mode,i.graphExecutionData[e].debug_tensor_value)))}}function nBe(n,t){if(1&n){let e=Pe();_(0,"div")(1,"div",13)(2,"button",14),P("click",function(){oe(e);let r=S().$implicit,o=S(2);return se(o.onTensorNameClick.emit({index:r,graph_id:o.graphExecutionData[r].graph_id,op_name:o.graphExecutionData[r].op_name}))}),A(3),v(),_(4,"div",15),A(5),v()(),E(6,tBe,1,4,"debug-tensor-value",16),v()}if(2&n){let e=S().$implicit,i=S(2);C(2),Zi("title",i.getTensorName(e)),C(1),je(" ",i.getTensorName(e)," "),C(2),yt(i.graphExecutionData[e].op_type),C(1),y("ngIf",null!==i.graphExecutionData[e].debug_tensor_value)}}function iBe(n,t){1&n&&(_(0,"div",18),A(1," Loading... "),v())}var rBe=function(n){return{"input-of-focus":n}};function oBe(n,t){if(1&n&&(_(0,"div",5)(1,"div",6)(2,"div",7),E(3,$3e,2,0,"div",8),A(4),v(),E(5,nBe,7,4,"div",9),E(6,iBe,2,0,"ng-template",10,11,qt),v()()),2&n){let e=t.$implicit,i=$e(7),r=S(2);C(1),y("ngClass",On(5,rBe,r.isInputOfFocus(e))),C(2),y("ngIf",e===r.focusIndex),C(1),je(" ",e," "),C(1),y("ngIf",r.graphExecutionData[e])("ngIfElse",i)}}function sBe(n,t){if(1&n){let e=Pe();_(0,"cdk-virtual-scroll-viewport",3),P("scrolledIndexChange",function(r){return oe(e),se(S().onScrolledIndexChange.emit(r))}),E(1,oBe,8,7,"div",4),v()}if(2&n){let e=S();C(1),y("cdkVirtualForOf",e.graphExecutionIndices)}}var Ore=(()=>{class n{constructor(){this.onScrolledIndexChange=new G,this.onTensorNameClick=new G,this.parseDebugTensorValue=AP,this.TEST_ONLY={getViewPort:()=>this.viewPort}}ngOnChanges(e){if(this.viewPort&&e.focusIndex&&null!==e.focusIndex.currentValue){let i=this.viewPort.getRenderedRange(),r=e.focusIndex.currentValue,o=Math.round((i.end-i.start)/3),s=Math.max(r-o,0);this.viewPort.scrollToIndex(s,r>=i.start&&r<i.end?"smooth":void 0)}}getTensorName(e){return`${this.graphExecutionData[e].op_name}:${this.graphExecutionData[e].output_slot}`}isInputOfFocus(e){return null!==this.focusInputIndices&&this.focusInputIndices.includes(e)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["graph-executions-component"]],viewQuery:function(e,i){if(1&e&&ot(eg,5),2&e){let r;Ne(r=Le())&&(i.viewPort=r.first)}},inputs:{numGraphExecutions:"numGraphExecutions",graphExecutionData:"graphExecutionData",graphExecutionIndices:"graphExecutionIndices",focusIndex:"focusIndex",focusInputIndices:"focusInputIndices"},outputs:{onScrolledIndexChange:"onScrolledIndexChange",onTensorNameClick:"onTensorNameClick"},features:[Ft],decls:4,vars:2,consts:[[1,"graph-executions-container"],[1,"graph-executions-title"],["itemSize","38","class","graph-executions-viewport",3,"scrolledIndexChange",4,"ngIf"],["itemSize","38",1,"graph-executions-viewport",3,"scrolledIndexChange"],["class","tensor-container",4,"cdkVirtualFor","cdkVirtualForOf"],[1,"tensor-container"],[1,"tensor-item",3,"ngClass"],[1,"graph-execution-index"],["class","graph-execution-focus",4,"ngIf"],[4,"ngIf","ngIfElse"],["class","tensor-item"],["dataLoading",""],[1,"graph-execution-focus"],[1,"tensor-name-and-op-type"],[1,"tensor-name",3,"title","click"],[1,"op-type"],[3,"debugTensorValue",4,"ngIf"],[3,"debugTensorValue"],[1,"loading-spinner"]],template:function(e,i){1&e&&(_(0,"div",0)(1,"div",1),A(2),v(),E(3,sBe,2,1,"cdk-virtual-scroll-viewport",2),v()),2&e&&(C(2),je(" Graph Executions (",i.numGraphExecutions,") "),C(1),y("ngIf",null!==i.numGraphExecutions&&i.numGraphExecutions>0))},dependencies:[Fn,Be,IP,b2,x2,eg],styles:['.graph-executions-container[_ngcontent-%COMP%]{border-left:1px solid #ebebeb;display:flex;flex-direction:column;height:100%;margin-left:8px;padding-left:10px}body.dark-mode[_nghost-%COMP%]   .graph-executions-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .graph-executions-container[_ngcontent-%COMP%]{border-left:1px solid #555}.graph-execution-focus[_ngcontent-%COMP%]{display:inline-block}.graph-execution-index[_ngcontent-%COMP%]{color:#616161;display:inline-block;padding-right:4px;text-align:right;width:40px}body.dark-mode[_nghost-%COMP%]   .graph-execution-index[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .graph-execution-index[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.graph-executions-title[_ngcontent-%COMP%]{box-shadow:0 5px 3px -3px #ccc;padding-bottom:5px}.graph-executions-viewport[_ngcontent-%COMP%]{flex-grow:1;font-size:12px;width:100%;overflow-x:hidden}.input-of-focus[_ngcontent-%COMP%]{background-color:#fff099}body.dark-mode[_nghost-%COMP%]   .input-of-focus[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .input-of-focus[_ngcontent-%COMP%]{background-color:#e65100}.loading-spinner[_ngcontent-%COMP%]{display:inline-block}.op-type[_ngcontent-%COMP%]{background-color:#eceff1;border:1px solid #ebebeb;border-radius:4px;font-family:"Roboto Mono",monospace;font-size:10px;height:14px;line-height:14px;padding:1px 3px;width:max-content;direction:rtl;display:block}body.dark-mode[_nghost-%COMP%]   .op-type[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-type[_ngcontent-%COMP%]{border:1px solid #555}body.dark-mode[_nghost-%COMP%]   .op-type[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-type[_ngcontent-%COMP%]{background-color:#455a64}.tensor-container[_ngcontent-%COMP%]{width:100%}.tensor-item[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;display:flex;flex-wrap:nowrap;height:38px;line-height:38px;text-align:left;vertical-align:middle;white-space:nowrap;width:100%}body.dark-mode[_nghost-%COMP%]   .tensor-item[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .tensor-item[_ngcontent-%COMP%]{border-bottom:1px solid #555}.tensor-name[_ngcontent-%COMP%]{background-color:rgba(0,0,0,0);border:none;box-sizing:border-box;color:inherit;cursor:pointer;direction:rtl;display:block;height:16px;line-height:16px;margin:2px 0 1px;max-width:calc(100% - 2px);overflow:hidden;padding:0 2px;text-align:right;text-decoration:underline;text-overflow:ellipsis;white-space:nowrap}.tensor-name[_ngcontent-%COMP%]:focus{outline:1px solid #c6cad1}.tensor-name-and-op-type[_ngcontent-%COMP%]{direction:rtl;display:inline-block;overflow:hidden;padding-right:8px;text-align:right;width:240px}debug-tensor-value[_ngcontent-%COMP%]{display:inline-block;margin:2px 0}'],changeDetection:0}),n})(),kre=(()=>{class n{constructor(e){this.store=e,this.numGraphExecutions$=this.store.pipe(vt(Iw)),this.graphExecutionData$=this.store.pipe(vt(oU)),this.graphExecutionIndices$=this.store.pipe(vt(J(Iw,i=>0===i?null:Array.from({length:i}).map((r,o)=>o)))),this.focusIndex$=this.store.pipe(vt(sU)),this.focusInputIndices$=this.store.pipe(vt(xre))}onScrolledIndexChange(e){this.store.dispatch(Qv({index:e}))}onTensorNameClick(e){this.store.dispatch(Kv(e))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["tf-debugger-v2-graph-executions"]],decls:6,vars:15,consts:[[3,"numGraphExecutions","graphExecutionData","graphExecutionIndices","focusIndex","focusInputIndices","onScrolledIndexChange","onTensorNameClick"]],template:function(e,i){1&e&&(_(0,"graph-executions-component",0),P("onScrolledIndexChange",function(o){return i.onScrolledIndexChange(o)})("onTensorNameClick",function(o){return i.onTensorNameClick(o)}),B(1,"async"),B(2,"async"),B(3,"async"),B(4,"async"),B(5,"async"),v()),2&e&&y("numGraphExecutions",U(1,5,i.numGraphExecutions$))("graphExecutionData",U(2,7,i.graphExecutionData$))("graphExecutionIndices",U(3,9,i.graphExecutionIndices$))("focusIndex",U(4,11,i.focusIndex$))("focusInputIndices",U(5,13,i.focusInputIndices$))},dependencies:[Ore,Ge],encapsulation:2}),n})();function cBe(n,t){1&n&&(_(0,"span"),A(1," Output "),v())}function uBe(n,t){1&n&&(_(0,"span"),A(1," Input "),v())}function dBe(n,t){if(1&n&&(_(0,"div",6)(1,"span",7),E(2,cBe,2,0,"span",8),E(3,uBe,2,0,"span",8),v(),A(4),v()),2&n){let e=S();C(1),y("ngSwitch",e.kind),C(1),y("ngSwitchCase","input"),C(1),y("ngSwitchCase","consumer"),C(1),je(" slot: ",e.slot," ")}}function pBe(n,t){if(1&n&&(_(0,"div",9),A(1),v()),2&n){let e=S();C(1),je(" ",e.opData.op_type," ")}}function hBe(n,t){1&n&&(_(0,"span",10),A(1," (Op info unavailable.) "),v())}var fBe=function(n){return[n]},Fre=(()=>{class n{constructor(){this.onOpNameClick=new G}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["graph-op"]],inputs:{kind:"kind",opName:"opName",slot:"slot",opData:"opData"},outputs:{onOpNameClick:"onOpNameClick"},decls:9,vars:7,consts:[[1,"op-container"],[1,"input-tensor-name"],[1,"op-name",3,"ngClass","click"],["class","slot",4,"ngIf"],["class","op-type",4,"ngIf","ngIfElse"],["opInfoMissing",""],[1,"slot"],[3,"ngSwitch"],[4,"ngSwitchCase"],[1,"op-type"],[1,"op-info-missing"]],template:function(e,i){if(1&e&&(_(0,"button",0)(1,"div",1)(2,"button",2),P("click",function(){return i.onOpNameClick.emit({op_name:i.opName})}),_(3,"span"),A(4),v()(),E(5,dBe,5,4,"div",3),v(),E(6,pBe,2,1,"div",4),E(7,hBe,2,0,"ng-template",null,5,qt),v()),2&e){let r=$e(8);C(2),y("ngClass",On(5,fBe,"self"===i.kind?"self-op-name":"")),C(2),yt(i.opName),C(1),y("ngIf","self"!==i.kind),C(1),y("ngIf",void 0!==i.opData)("ngIfElse",r)}},dependencies:[Fn,Be,Cr,Ur],styles:['.op-container[_ngcontent-%COMP%], .op-name[_ngcontent-%COMP%]{color:inherit;background-color:inherit}.op-container[_ngcontent-%COMP%]{border:2px solid #ebebeb;border-radius:4px;box-shadow:1px 3px #eee;cursor:pointer;margin:0 5px 0 0;padding:2px 6px;text-align:right;width:200px}body.dark-mode[_nghost-%COMP%]   .op-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-container[_ngcontent-%COMP%]{border:2px solid #555}body.dark-mode[_nghost-%COMP%]   .op-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-container[_ngcontent-%COMP%]{box-shadow:1px 3px #757575}.op-container[_ngcontent-%COMP%]:focus{outline:0}.op-container[_ngcontent-%COMP%]:hover{border:2px solid #ffd3b2}.op-info-missing[_ngcontent-%COMP%]{color:gray}.op-name[_ngcontent-%COMP%]{border:none;cursor:pointer;display:inline-block;overflow-wrap:anywhere;padding:0;text-align:right;text-decoration:underline;white-space:pre-wrap}.op-name[_ngcontent-%COMP%]:focus{outline:0}.op-type[_ngcontent-%COMP%]{background-color:#eceff1;border:1px solid #ebebeb;border-radius:4px;font-family:"Roboto Mono",monospace;font-size:10px;height:14px;line-height:14px;padding:1px 3px;width:max-content;display:inline-block;margin-top:3px}body.dark-mode[_nghost-%COMP%]   .op-type[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-type[_ngcontent-%COMP%]{border:1px solid #555}body.dark-mode[_nghost-%COMP%]   .op-type[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-type[_ngcontent-%COMP%]{background-color:#455a64}.self-op-name[_ngcontent-%COMP%]{font-weight:bold;text-decoration:none}.slot[_ngcontent-%COMP%]{color:#616161}body.dark-mode[_nghost-%COMP%]   .slot[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slot[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}']}),n})();function gBe(n,t){if(1&n){let e=Pe();_(0,"div",13)(1,"div",14),A(2),v(),_(3,"graph-op",15),P("onOpNameClick",function(r){oe(e);let o=S(3);return se(o.onGraphOpNavigate.emit({op_name:r.op_name,graph_id:o.graphId}))}),v()()}if(2&n){let e=t.$implicit,i=t.index;C(2),je("Input slot ",i,":"),C(1),y("kind","input")("opName",e.op_name)("slot",e.output_slot)("opData",e.data)}}function _Be(n,t){if(1&n&&(_(0,"div",11)(1,"div"),E(2,gBe,4,5,"div",12),v()()),2&n){let e=S(2);C(2),y("ngForOf",e.inputOps)}}function vBe(n,t){1&n&&(_(0,"div",16),A(1," (This op has no input tensor.) "),v())}function yBe(n,t){if(1&n){let e=Pe();_(0,"div",23)(1,"graph-op",15),P("onOpNameClick",function(r){oe(e);let o=S(4);return se(o.onGraphOpNavigate.emit({op_name:r.op_name,graph_id:o.graphId}))}),v()()}if(2&n){let e=t.$implicit;C(1),y("kind","consumer")("opName",e.op_name)("slot",e.input_slot)("opData",e.data)}}function bBe(n,t){if(1&n&&(_(0,"div",19)(1,"div",20),A(2),_(3,"span"),AT(4,21),v(),A(5,") "),v(),E(6,yBe,2,4,"div",22),v()),2&n){let e=t.$implicit,i=t.index;C(2),Xp(" Output slot ",i,": (",e.length," "),C(2),Kx(e.length),IT(4),C(2),y("ngForOf",e)}}function xBe(n,t){if(1&n&&(_(0,"div",17)(1,"div"),E(2,bBe,7,4,"div",18),v()()),2&n){let e=S(2);C(2),y("ngForOf",e.consumerOps)}}function CBe(n,t){if(1&n&&(_(0,"div",24),A(1),_(2,"span"),AT(3,25),v(),A(4," and no consumer.) "),v()),2&n){let e=S(2);C(1),je(" (This op has ",e.opInfo.consumers.length," output "),C(2),Kx(e.opInfo.consumers.length),IT(3)}}function MBe(n,t){if(1&n){let e=Pe();_(0,"div"),E(1,_Be,3,1,"div",4),E(2,vBe,2,0,"ng-template",null,5,qt),_(4,"div",6)(5,"div",7),A(6,"Op:"),v(),_(7,"graph-op",8),P("onOpNameClick",function(r){oe(e);let o=S();return se(o.onGraphOpNavigate.emit({op_name:r.op_name,graph_id:o.graphId}))}),v()(),E(8,xBe,3,1,"div",9),E(9,CBe,5,2,"ng-template",null,10,qt),v()}if(2&n){let e=$e(3),i=$e(10),r=S();C(1),y("ngIf",r.inputOps.length>0)("ngIfElse",e),C(6),y("kind","self")("opName",r.opInfo.op_name)("opData",r.opInfo),C(1),y("ngIf",r.totalNumConsumers>0)("ngIfElse",i)}}function wBe(n,t){1&n&&(_(0,"span",26),A(1," (Op info unavailable.) "),v())}function SBe(n,t){1&n&&(_(0,"div",27),A(1," No graph op selected. Click a tensor name in the Graph Executions table to view the neighborhood of the tensor's op in its graph. "),v())}var Nre=(()=>{class n{constructor(){this.onGraphOpNavigate=new G}get graphId(){return this.opInfo.graph_ids[this.opInfo.graph_ids.length-1]}get totalNumConsumers(){return this.consumerOps.reduce((e,i)=>e+i.length,0)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["graph-component"]],inputs:{opInfo:"opInfo",inputOps:"inputOps",consumerOps:"consumerOps"},outputs:{onGraphOpNavigate:"onGraphOpNavigate"},decls:9,vars:2,consts:function(){let t,e,i,r;return t=$localize`:␟fe55f9b193ea20aae5b5635e68d9386503847746␟4955133740841299851:{VAR_PLURAL, plural, =0 {consumer} =1 {consumer} other {consumers}}`,t=PT(t,{VAR_PLURAL:"\ufffd0\ufffd"}),e=$localize`:␟baa460e2f2b857e26292b246fc18ae0ea9b5e537␟5556340343850165516: ${t}:ICU:`,i=$localize`:␟6aa75f627e0dc16150ef448464e0c857aaa0dc18␟5156712935150586878:{VAR_PLURAL, plural, =0 {tensor} =1 {tensor} other {tensors}}`,i=PT(i,{VAR_PLURAL:"\ufffd0\ufffd"}),r=$localize`:␟893476c2c421cee47663c9732fa41a750d3a73df␟246067053735162634: ${i}:ICU:`,[[1,"graph-structure-container"],[4,"ngIf","ngIfElse"],["opInfoMissing",""],["noOpFocused",""],["class","inputs-container",4,"ngIf","ngIfElse"],["noInputs",""],[1,"self-op-container"],[1,"self-op-header"],[3,"kind","opName","opData","onOpNameClick"],["class","consumers-container",4,"ngIf","ngIfElse"],["noConsumers",""],[1,"inputs-container"],["class","input-op-section",4,"ngFor","ngForOf"],[1,"input-op-section"],[1,"input-slot-header"],[3,"kind","opName","slot","opData","onOpNameClick"],[1,"inputs-container","no-inputs-indicator"],[1,"consumers-container"],["class","slot-consumers-container",4,"ngFor","ngForOf"],[1,"slot-consumers-container"],[1,"slot-consumers-header"],e,["class","consumer-section",4,"ngFor","ngForOf"],[1,"consumer-section"],[1,"op-consumers-container"],r,[1,"op-info-missing"],[1,"no-op-focused"]]},template:function(e,i){if(1&e&&(_(0,"div")(1,"div"),A(2,"Graph Structure"),v(),_(3,"div",0),E(4,MBe,11,7,"div",1),v(),E(5,wBe,2,0,"ng-template",null,2,qt),E(7,SBe,2,0,"ng-template",null,3,qt),v()),2&e){let r=$e(8);C(4),y("ngIf",null!=i.opInfo)("ngIfElse",r)}},dependencies:[dn,Be,Fre],styles:['[_nghost-%COMP%]{overflow-y:auto}.consumers-container[_ngcontent-%COMP%]{padding-bottom:5px;overflow-x:auto;white-space:nowrap}.consumer-section[_ngcontent-%COMP%]{display:block;margin:5px 0}.graph-structure-container[_ngcontent-%COMP%]{font-size:12px;overflow-y:auto;white-space:nowrap}.inputs-container[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12);margin-top:5px;overflow-x:auto;padding-bottom:0;white-space:nowrap}.input-op-section[_ngcontent-%COMP%]{border-right:1px solid rgba(0,0,0,.12);display:inline-block;margin-right:5px;padding-bottom:5px}.input-slot-header[_ngcontent-%COMP%]{background-color:#fff099;margin-bottom:5px}body.dark-mode[_nghost-%COMP%]   .input-slot-header[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .input-slot-header[_ngcontent-%COMP%]{background-color:#e65100}.input-tensor-name[_ngcontent-%COMP%]{display:block;white-space:nowrap}.no-op-focused[_ngcontent-%COMP%]{color:gray;font-family:"Roboto",Arial,Helvetica,sans-serif;font-size:13px;white-space:normal}.self-op-header[_ngcontent-%COMP%]{font-weight:bold;margin-bottom:5px}.self-op-container[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12);padding-bottom:5px}.slot-consumers-container[_ngcontent-%COMP%]{border-right:1px solid rgba(0,0,0,.12);display:inline-block;margin-right:5px;padding-top:5px;vertical-align:top}.slot-consumers-header[_ngcontent-%COMP%]{white-space:nowrap}'],changeDetection:0}),n})(),Lre=(()=>{class n{constructor(e){this.store=e,this.opInfo$=this.store.pipe(vt(lU)),this.inputOps$=this.store.pipe(vt(cU)),this.consumerOps$=this.store.pipe(vt(Cre))}onGraphOpNavigate(e){this.store.dispatch(Zv(e))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["tf-debugger-v2-graph"]],decls:4,vars:9,consts:[[3,"opInfo","inputOps","consumerOps","onGraphOpNavigate"]],template:function(e,i){1&e&&(_(0,"graph-component",0),P("onGraphOpNavigate",function(o){return i.onGraphOpNavigate(o)}),B(1,"async"),B(2,"async"),B(3,"async"),v()),2&e&&y("opInfo",U(1,3,i.opInfo$))("inputOps",U(2,5,i.inputOps$))("consumerOps",U(3,7,i.consumerOps$))},dependencies:[Nre,Ge],encapsulation:2}),n})(),Bre=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["inactive-component"]],decls:54,vars:0,consts:[[1,"container"],[1,"title"],[1,"code"],[1,"arg"],[1,"exhibits-container"],[1,"exhibit"],[1,"screenshot"],["src","data:image/png;base64,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"],[1,"description"],["src","data:image/png;base64,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"],["src","data:image/png;base64,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"],[1,"details-container"],[1,"details"],["href","https://www.tensorflow.org/api_docs/python/tf/debugging/experimental/enable_dump_debug_info","target","blank","rel","noreferrer noopener"],["href","https://www.tensorflow.org/api_docs/python/tf/debugging","target","blank","rel","noreferrer noopener"]],template:function(e,i){1&e&&(_(0,"div",0)(1,"div",1),A(2,"Debugger V2 is inactive because no data is available."),v(),_(3,"div"),A(4,"To use the debugger,"),v(),_(5,"div")(6,"ol")(7,"li"),A(8," Add the following line to the beginning of your program: "),_(9,"div",2)(10,"span"),A(11,"tf.debugging.experimental.enable_dump_debug_info("),v(),_(12,"span",3),A(13,"logdir"),v(),A(14,", "),_(15,"span",3),A(16,'tensor_debug_mode="FULL_HEALTH"'),v(),A(17,", "),_(18,"span",3),A(19,"circular_buffer_size=-1"),v(),_(20,"span"),A(21,")"),v()()(),_(22,"li"),A(23,"Re-run the program."),v()()(),_(24,"div",4)(25,"div",5)(26,"div",6),O(27,"img",7),v(),_(28,"div",8),A(29,"Auto-alerts for problems found"),v()(),_(30,"div",5)(31,"div",6),O(32,"img",9),v(),_(33,"div",8),A(34," Integrated debugging to trace problems to their causes "),v()(),_(35,"div",5)(36,"div",6),O(37,"img",10),v(),_(38,"div",8),A(39,"Link log to code"),v()()(),_(40,"div",11)(41,"div",12),A(42," The log directory must contain TensorFlow Debugger (V2) data. tf.debugging.experimental.enable_dump_debug_info() will collect tensor data, graph structures, the associated stack traces, and source code to the specificed directory logdir as the instrumented TensorFlow program executes. "),v(),_(43,"div",12)(44,"div"),A(45," See "),_(46,"a",13),A(47," documentation "),v(),A(48," of the Python API of Debugger V2. "),v(),_(49,"div"),A(50," See "),_(51,"a",14),A(52," here "),v(),A(53," for other TensorFlow debugging APIs. "),v()()()())},styles:[".arg[_ngcontent-%COMP%] {\n  color: lightblue;\n  font-style: italic;\n  margin: 2px;\n}\n\n.code[_ngcontent-%COMP%] {\n  font-family: 'Roboto Mono', monospace;\n  margin: 10px;\n}\n\n.container[_ngcontent-%COMP%] {\n  height: 100%;\n  font-family: Roboto;\n  font-size: 15px;\n  overflow-y: auto;\n  padding: 50px;\n}\n\n.details-container[_ngcontent-%COMP%] {\n  display: inline-flex;\n  vertical-align: middle;\n  width: 100%;\n}\n\n.details[_ngcontent-%COMP%] {\n  display: inline-block;\n  margin: 10px 60px;\n  width: 50%;\n}\n\n.exhibit-container[_ngcontent-%COMP%] {\n  white-space: nowrap;\n  width: 100%;\n}\n\n.exhibit[_ngcontent-%COMP%] {\n  align-content: center;\n  display: inline-block;\n  margin: 10px 60px;\n  vertical-align: top;\n  width: 310px;\n}\n\n.exhibit[_ngcontent-%COMP%]   .description[_ngcontent-%COMP%] {\n  font-weight: bold;\n  text-align: center;\n  width: 310px;\n}\n\n.exhibit[_ngcontent-%COMP%]   .screenshot[_ngcontent-%COMP%]   canvas[_ngcontent-%COMP%] {\n  height: 200px;\n  width: 100%;\n}\n\n.title[_ngcontent-%COMP%] {\n  font-size: 135%;\n  font-weight: bold;\n  margin-bottom: 25px;\n}"]}),n})(),Vre=(()=>{class n{constructor(e){this.store=e}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["tf-debugger-v2-inactive"]],decls:1,vars:0,template:function(e,i){1&e&&O(0,"inactive-component")},dependencies:[Bre],encapsulation:2}),n})(),Ure_getWindow=function(){return window};function Hre(n){let t=Ure_getWindow().require;return new Promise(e=>{t(n,e)})}var gU_loadMonaco=async function(){let n=Ure_getWindow();if(void 0===n.monaco){if(!n.require)throw new Error("loadMonaco() failed because function require() is unavailable");n.require.config({paths:{vs:"/tf-imports/vs"}}),await Hre(["vs/editor/editor.main"]),await Hre(["vs/python/python.contribution"])}};function PP(n){return n?"vs-dark":"vs"}var hg=(()=>{class n{constructor(e){this.resizeEventDebouncePeriodInMs=100,this.onResize=new G,this.ngUnsubscribe$=new ke,this.onResize$=new ke;let i=new ResizeObserver(()=>{this.onResize$.next()});i.observe(e.nativeElement),this.ngUnsubscribe$.subscribe(()=>{i.unobserve(e.nativeElement)})}ngOnInit(){this.onResize$.pipe(Za(1),Hr(this.resizeEventDebouncePeriodInMs),st(this.ngUnsubscribe$)).subscribe(()=>{this.onResize.emit()})}ngOnDestroy(){this.ngUnsubscribe$.next(),this.ngUnsubscribe$.complete()}}return n.\u0275fac=function(e){return new(e||n)(M(Re))},n.\u0275dir=He({type:n,selectors:[["","detectResize",""]],inputs:{resizeEventDebouncePeriodInMs:"resizeEventDebouncePeriodInMs"},outputs:{onResize:"onResize"}}),n})(),OBe=["codeViewerContainer"],Wre=(()=>{class n{constructor(){this.lines=null,this.focusedLineno=null,this.monaco=null,this.editor=null,this.decorations=[],this.RESIZE_DEBOUNCE_INTERVAL_MS=50}onResize(){this.editor&&this.editor.layout()}ngOnChanges(e){if(null===this.monaco)return;let i=e.monaco&&null===this.editor;null===this.editor&&(this.editor=this.monaco.editor.create(this.codeViewerContainer.nativeElement,{value:(this.lines??[]).join("\n"),language:"python",readOnly:!0,fontSize:10,minimap:{enabled:!0},theme:PP(this.useDarkMode)})),e.lines&&this.lines&&this.editor.setValue(this.lines.join("\n"));let r=i||e.focusedLineno?this.focusedLineno:null;if(r&&this.lines){this.editor.revealLineInCenter(r,this.monaco.editor.ScrollType.Smooth);let o=this.lines[r-1].length;this.decorations=this.editor.deltaDecorations(this.decorations,[{range:new this.monaco.Range(r,1,r,1),options:{isWholeLine:!0,linesDecorationsClassName:"highlight-gutter"}},{range:new this.monaco.Range(r,1,r,o+1),options:{inlineClassName:"highlight-line"}}])}e.useDarkMode&&this.monaco.editor.setTheme(PP(this.useDarkMode))}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["source-code-component"]],viewQuery:function(e,i){if(1&e&&ot(OBe,7,Re),2&e){let r;Ne(r=Le())&&(i.codeViewerContainer=r.first)}},inputs:{lines:"lines",focusedLineno:"focusedLineno",monaco:"monaco",useDarkMode:"useDarkMode"},features:[Ft],decls:2,vars:1,consts:[["detectResize","",1,"code-viewer-container",3,"resizeEventDebouncePeriodInMs","onResize"],["codeViewerContainer",""]],template:function(e,i){1&e&&(_(0,"div",0,1),P("onResize",function(){return i.onResize()}),v()),2&e&&y("resizeEventDebouncePeriodInMs",i.RESIZE_DEBOUNCE_INTERVAL_MS)},dependencies:[hg],styles:[".code-viewer-container[_ngcontent-%COMP%] {\n  height: 100%;\n}\n\n[_nghost-%COMP%]     .highlight-gutter {\n  background: rgba(255, 111, 0, 0.7);\n  width: 5px !important;\n}\n\n[_nghost-%COMP%]     .highlight-line {\n  background: rgba(255, 111, 0, 0.3);\n}"],changeDetection:0}),n})(),qre=(()=>{class n{constructor(){this.lines=null,this.focusedLineno=null,this.useDarkMode=!1,this.monaco$=null}ngOnInit(){this.monaco$=Eo(gU_loadMonaco()).pipe(L(()=>window.monaco))}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["source-code"]],inputs:{lines:"lines",focusedLineno:"focusedLineno",useDarkMode:"useDarkMode"},decls:2,vars:6,consts:[[3,"lines","focusedLineno","monaco","useDarkMode"]],template:function(e,i){1&e&&(O(0,"source-code-component",0),B(1,"async")),2&e&&y("lines",i.lines)("focusedLineno",i.focusedLineno)("monaco",U(1,4,i.monaco$))("useDarkMode",i.useDarkMode)},dependencies:[Wre,Ge],encapsulation:2}),n})();function NBe(n,t){if(1&n&&(_(0,"div",6),A(1),v()),2&n){let e=S();C(1),je(" ",e.focusedSourceLineSpec.file_path," ")}}function LBe(n,t){1&n&&(_(0,"div",7),A(1," No file selected. Click a line number in the Stack Trace section to show the source code. "),v())}function BBe(n,t){if(1&n&&O(0,"source-code",8),2&n){let e=S();y("lines",e.focusedSourceFileContent.lines)("focusedLineno",e.focusedSourceLineSpec.lineno)("useDarkMode",e.useDarkMode)}}var Yre=(()=>{class n{constructor(){this.focusedSourceFileContent=null,this.focusedSourceLineSpec=null}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["source-files-component"]],inputs:{focusedSourceFileContent:"focusedSourceFileContent",focusedSourceLineSpec:"focusedSourceLineSpec",useDarkMode:"useDarkMode"},decls:8,vars:3,consts:[[1,"source-files-container"],[1,"header-section"],[1,"title-tag"],["class","file-label",4,"ngIf","ngIfElse"],["noFileSelected",""],[3,"lines","focusedLineno","useDarkMode",4,"ngIf"],[1,"file-label"],[1,"no-file-selected"],[3,"lines","focusedLineno","useDarkMode"]],template:function(e,i){if(1&e&&(_(0,"div",0)(1,"div",1)(2,"div",2),A(3,"Source Code"),v(),E(4,NBe,2,1,"div",3),E(5,LBe,2,0,"ng-template",null,4,qt),v(),E(7,BBe,1,3,"source-code",5),v()),2&e){let r=$e(6);C(4),y("ngIf",null!==i.focusedSourceLineSpec)("ngIfElse",r),C(3),y("ngIf",null!==i.focusedSourceFileContent&&null!==i.focusedSourceLineSpec&&null!==i.focusedSourceFileContent.lines)}},dependencies:[Be,qre],styles:['.header-section[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;display:flex;height:24px;padding-bottom:6px;vertical-align:middle;white-space:nowrap;width:100%}body.dark-mode[_nghost-%COMP%]   .header-section[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .header-section[_ngcontent-%COMP%]{border-bottom:1px solid #555}.file-label[_ngcontent-%COMP%]{display:inline-block;font-weight:normal;white-space:normal;overflow-wrap:anywhere;overflow-y:auto;padding:0 20px}.no-file-selected[_ngcontent-%COMP%]{display:inline-block;color:#666;padding:0 20px;white-space:normal}.source-files-container[_ngcontent-%COMP%]{display:flex;flex-direction:column;font-family:"Roboto Mono",monospace;font-size:10px;height:100%}.title-tag[_ngcontent-%COMP%]{display:inline-block;font-weight:bold;height:100%;padding-left:6px;vertical-align:top}source-code[_ngcontent-%COMP%]{flex-grow:1;width:100%}']}),n})(),Xre=(()=>{class n{constructor(e){this.store=e,this.focusedSourceFileContent$=this.store.select(TP),this.focusedSourceLineSpec$=this.store.select(DP),this.useDarkMode$=this.store.select(Qu)}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["tf-debugger-v2-source-files"]],decls:4,vars:9,consts:[[3,"focusedSourceFileContent","focusedSourceLineSpec","useDarkMode"]],template:function(e,i){1&e&&(O(0,"source-files-component",0),B(1,"async"),B(2,"async"),B(3,"async")),2&e&&y("focusedSourceFileContent",U(1,3,i.focusedSourceFileContent$))("focusedSourceLineSpec",U(2,5,i.focusedSourceLineSpec$))("useDarkMode",U(3,7,i.useDarkMode$))},dependencies:[Yre,Ge],encapsulation:2}),n})(),UBe=["stackFrameArray"];function zBe(n,t){if(1&n&&(_(0,"span",13),A(1),v()),2&n){let e=S(3);C(1),je(" #",e.executionIndex,": ")}}function jBe(n,t){if(1&n&&(_(0,"span",14),A(1),v()),2&n){let e=S(3);C(1),je(" ",e.opType," ")}}function GBe(n,t){if(1&n&&(_(0,"div"),A(1," Eager execution "),E(2,zBe,2,1,"span",11),E(3,jBe,2,1,"span",12),v()),2&n){let e=S(2);C(2),y("ngIf",null!==e.opType),C(1),y("ngIf",null!==e.opType)}}function WBe(n,t){if(1&n&&(_(0,"span",16),A(1),v()),2&n){let e=S(3);C(1),je(' "',e.opName,'" ')}}function qBe(n,t){if(1&n&&(_(0,"span",14),A(1),v()),2&n){let e=S(3);C(1),je(" ",e.opType," ")}}function YBe(n,t){if(1&n&&(_(0,"div"),A(1," Creation of graph op "),E(2,WBe,2,1,"span",15),E(3,qBe,2,1,"span",12),v()),2&n){let e=S(2);C(2),y("ngIf",null!==e.opName),C(1),y("ngIf",null!==e.opType)}}function XBe(n,t){if(1&n&&(_(0,"span",17),A(1),v()),2&n){let e=S(2);C(1),je(" (Host name: ",e.stackFramesForDisplay[0].host_name,") ")}}function QBe(n,t){if(1&n&&(_(0,"div",7)(1,"span")(2,"span",8),E(3,GBe,4,2,"div",9),E(4,YBe,4,2,"div",9),v()(),_(5,"div"),E(6,XBe,2,1,"span",10),v()()),2&n){let e=S();C(2),y("ngSwitch",e.codeLocationType),C(1),y("ngSwitchCase",e.CodeLocationType.EXECUTION),C(1),y("ngSwitchCase",e.CodeLocationType.GRAPH_OP_CREATION),C(2),y("ngIf",null!==e.stackFramesForDisplay&&e.stackFramesForDisplay.length>0)}}function KBe(n,t){1&n&&(_(0,"div",18),A(1," Click an eager execution or graph op to show its original stack trace. "),v())}function ZBe(n,t){1&n&&(_(0,"div",28),A(1," \u2913 "),v())}var JBe=function(n,t){return[n,t]};function $Be(n,t){if(1&n){let e=Pe();_(0,"div",22)(1,"div",23),A(2),v(),_(3,"div",24),E(4,ZBe,2,0,"div",25),_(5,"div",26),P("click",function(){let o=oe(e).$implicit;return se(S(2).onSourceLineClicked.emit(o))}),A(6),v(),_(7,"div",27),A(8),v()()()}if(2&n){let e=t.$implicit,i=S(2);y("ngClass",Qr(6,JBe,e.belongsToFocusedFile?"focused-file":"",e.focused?"focused-stack-frame":"")),C(1),Zi("title",e.file_path),C(1),je(" ",e.concise_file_path," "),C(2),y("ngIf",i.stickToBottommostFrameInFocusedFile&&e.focused),C(2),je(" Line ",e.lineno," "),C(2),je(" ",e.function_name," ")}}function eVe(n,t){if(1&n&&(_(0,"div",19,20),E(2,$Be,9,9,"div",21),v()),2&n){let e=S();C(2),y("ngForOf",e.stackFramesForDisplay)}}function tVe(n,t){}var Qre=(()=>{class n{constructor(){this.stackFramesForDisplay=null,this.onSourceLineClicked=new G,this.CodeLocationType=xs}ngAfterViewChecked(){if(void 0===this.stackFrameArray)return;let e=this.stackFrameArray.nativeElement,i=e.querySelector(".focused-stack-frame");if(null!==i)return void this.scrollToElement(e,i);let r=e.querySelector(".stack-frame-container:last-child");null!==r&&this.scrollToElement(e,r)}scrollToElement(e,i){e.scrollTop=i.offsetTop}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["stack-trace-component"]],viewQuery:function(e,i){if(1&e&&ot(UBe,5),2&e){let r;Ne(r=Le())&&(i.stackFrameArray=r.first)}},inputs:{codeLocationType:"codeLocationType",opType:"opType",opName:"opName",executionIndex:"executionIndex",stickToBottommostFrameInFocusedFile:"stickToBottommostFrameInFocusedFile",stackFramesForDisplay:"stackFramesForDisplay"},outputs:{onSourceLineClicked:"onSourceLineClicked"},decls:10,vars:4,consts:[[1,"stack-trace-container"],[1,"stack-trace-header"],[1,"stack-trace-title"],["class","stack-trace-aux-info",4,"ngIf","ngIfElse"],["noStackTrace",""],["class","stack-frame-array",4,"ngIf","ngIfElse"],["loadingSection",""],[1,"stack-trace-aux-info"],[1,"code-location-origin",3,"ngSwitch"],[4,"ngSwitchCase"],["class","stack-trace-host-name",4,"ngIf"],["class","eager-execution-index",4,"ngIf"],["class","op-type",4,"ngIf"],[1,"eager-execution-index"],[1,"op-type"],["class","op-name",4,"ngIf"],[1,"op-name"],[1,"stack-trace-host-name"],[1,"stack-trace-aux-info","no-stack-trace"],[1,"stack-frame-array"],["stackFrameArray",""],["class","stack-frame-container",3,"ngClass",4,"ngFor","ngForOf"],[1,"stack-frame-container",3,"ngClass"],[1,"stack-frame-file-path",3,"title"],[1,"stack-frame-lineno-function"],["class","stick-to-bottommost-indicator","title","Sticking to the bottommost frame in the current source file when navigating executions and graph ops. To remove this sticking, click any non-bottommost stack frame.",4,"ngIf"],[1,"stack-frame-lineno",3,"click"],[1,"stack-frame-function"],["title","Sticking to the bottommost frame in the current source file when navigating executions and graph ops. To remove this sticking, click any non-bottommost stack frame.",1,"stick-to-bottommost-indicator"]],template:function(e,i){if(1&e&&(_(0,"div",0)(1,"div",1)(2,"span",2),A(3," Stack Trace "),v(),E(4,QBe,7,4,"div",3),E(5,KBe,2,0,"ng-template",null,4,qt),v(),E(7,eVe,3,1,"div",5),E(8,tVe,0,0,"ng-template",null,6,qt),v()),2&e){let r=$e(6),o=$e(9);C(4),y("ngIf",null!==i.codeLocationType)("ngIfElse",r),C(3),y("ngIf",null!==i.stackFramesForDisplay)("ngIfElse",o)}},dependencies:[Fn,dn,Be,Cr,Ur],styles:['.focused-file[_ngcontent-%COMP%]{font-weight:bold}.focused-stack-frame[_ngcontent-%COMP%]{background-color:rgba(255,111,0,.3)}.no-stack-trace[_ngcontent-%COMP%]{color:gray}.op-name[_ngcontent-%COMP%]{word-wrap:anywhere}.op-type[_ngcontent-%COMP%]{background-color:#eceff1;border:1px solid #ebebeb;border-radius:4px;font-family:"Roboto Mono",monospace;font-size:10px;height:14px;line-height:14px;padding:1px 3px;width:max-content}body.dark-mode[_nghost-%COMP%]   .op-type[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-type[_ngcontent-%COMP%]{border:1px solid #555}body.dark-mode[_nghost-%COMP%]   .op-type[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .op-type[_ngcontent-%COMP%]{background-color:#455a64}.stack-frame-array[_ngcontent-%COMP%]{overflow-x:hidden;overflow-y:auto;width:calc(100% - 8px)}.stack-frame-container[_ngcontent-%COMP%]{border-bottom:1px solid #a0a0a0}.stack-frame-file-path[_ngcontent-%COMP%]{max-width:180px;width:180px}.stack-frame-lineno-function[_ngcontent-%COMP%]{text-align:right;white-space:nowrap}.stack-frame-function[_ngcontent-%COMP%]{display:inline-block;max-width:200px;padding-left:10px;text-align:left;white-space:normal;width:200px;word-wrap:anywhere}.stack-frame-lineno[_ngcontent-%COMP%]{cursor:pointer;display:inline-block;max-width:80px;text-align:left;text-decoration:underline;width:80px}.stack-trace-aux-info[_ngcontent-%COMP%]{margin-top:15px;padding-left:24px}.stack-trace-container[_ngcontent-%COMP%]{border-left:1px solid #ebebeb;box-sizing:border-box;display:flex;flex-flow:column;font-size:10px;font-family:"Roboto Mono",monospace;height:100%;margin-left:8px;max-height:360px;overflow-x:hidden;overflow-y:hidden;padding-left:8px;width:100%}body.dark-mode[_nghost-%COMP%]   .stack-trace-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .stack-trace-container[_ngcontent-%COMP%]{border-left:1px solid #555}.stack-trace-header[_ngcontent-%COMP%]{box-shadow:0 5px 3px -3px #ccc;padding-bottom:3px}.stack-trace-host-name[_ngcontent-%COMP%]{color:gray}.stack-trace-title[_ngcontent-%COMP%]{font-weight:bold}.stick-to-bottommost-indicator[_ngcontent-%COMP%]{display:inline-block;font-weight:bold;font-size:12px;padding-right:3px}']}),n})(),Kre=(()=>{class n{constructor(e){this.store=e,this.codeLocationType$=this.store.pipe(vt(J(Pw,i=>null===i?null:i.codeLocationType))),this.opType$=this.store.pipe(vt(J(Pw,i=>null===i?null:i.opType))),this.opName$=this.store.pipe(vt(J(Pw,i=>null===i||i.codeLocationType!==xs.GRAPH_OP_CREATION?null:i.opName))),this.executionIndex$=this.store.pipe(vt(J(Pw,i=>null===i||i.codeLocationType!==xs.EXECUTION?null:i.executionIndex))),this.stickToBottommostFrameInFocusedFile$=this.store.pipe(vt(Dre)),this.stackFramesForDisplay$=this.store.pipe(vt(J(Ere,DP,(i,r)=>{if(null===i)return null;let o=[];for(let s of i){let{host_name:a,file_path:l,lineno:c,function_name:u}=s,d=l.split("/"),h=null!==r&&a===r.host_name&&l===r.file_path;o.push({host_name:a,file_path:l,concise_file_path:d[d.length-1],lineno:c,function_name:u,belongsToFocusedFile:h,focused:h&&c===r.lineno})}return o})))}onSourceLineClicked(e){let{host_name:i,file_path:r,lineno:o,function_name:s}=e;this.store.dispatch(Jv({stackFrame:{host_name:i,file_path:r,lineno:o,function_name:s}}))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["tf-debugger-v2-stack-trace"]],decls:7,vars:18,consts:[[3,"codeLocationType","opType","opName","executionIndex","stickToBottommostFrameInFocusedFile","stackFramesForDisplay","onSourceLineClicked"]],template:function(e,i){1&e&&(_(0,"stack-trace-component",0),P("onSourceLineClicked",function(o){return i.onSourceLineClicked(o)}),B(1,"async"),B(2,"async"),B(3,"async"),B(4,"async"),B(5,"async"),B(6,"async"),v()),2&e&&y("codeLocationType",U(1,6,i.codeLocationType$))("opType",U(2,8,i.opType$))("opName",U(3,10,i.opName$))("executionIndex",U(4,12,i.executionIndex$))("stickToBottommostFrameInFocusedFile",U(5,14,i.stickToBottommostFrameInFocusedFile$))("stackFramesForDisplay",U(6,16,i.stackFramesForDisplay$))},dependencies:[Qre,Ge],encapsulation:2}),n})(),rVe=function(n,t){return{tensorDebugMode:n,array:t}};function oVe(n,t){if(1&n&&(_(0,"div",12)(1,"div",13),A(2),v(),_(3,"div",14),O(4,"debug-tensor-value",15),v()()),2&n){let e=t.$implicit,i=t.index,r=S(3);C(2),je("Output slot ",i,":"),C(2),y("debugTensorValue",r.parseDebugTensorValue(Qr(2,rVe,r.tensorDebugMode,e)))}}function sVe(n,t){if(1&n&&(_(0,"div",10),E(1,oVe,5,5,"div",11),v()),2&n){let e=S(2);C(1),y("ngForOf",e.debugTensorValues)}}function aVe(n,t){if(1&n&&(_(0,"div")(1,"div")(2,"div",3)(3,"span",4),A(4," Op: "),v(),_(5,"span",5),A(6),v()(),_(7,"div",3)(8,"span",4),A(9," # of input tensors: "),v(),_(10,"span",6),A(11),v()(),_(12,"div",3)(13,"span",4),A(14," # of output tensors: "),v(),_(15,"span",7),A(16),v(),_(17,"span",8),A(18),v()(),E(19,sVe,2,1,"div",9),v()()),2&n){let e=S();C(6),je(" ",e.focusedExecutionData.op_type," "),C(5),je(" ",null==e.focusedExecutionData.input_tensor_ids?0:e.focusedExecutionData.input_tensor_ids.length," "),C(5),je(" ",null==e.focusedExecutionData.output_tensor_ids?0:e.focusedExecutionData.output_tensor_ids.length," "),C(2),je(" (debug mode: ",e.TensorDebugMode[e.tensorDebugMode],") "),C(1),y("ngIf",e.hasDebugTensorValues)}}function lVe(n,t){}var Zre=(()=>{class n{constructor(){this.tensorDebugMode=as.UNSPECIFIED,this.hasDebugTensorValues=!1,this.debugTensorValues=null,this.debugTensorDtypes=null,this.TensorDebugMode=as,this.parseDebugTensorValue=AP}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["execution-data-component"]],inputs:{focusedExecutionIndex:"focusedExecutionIndex",focusedExecutionData:"focusedExecutionData",tensorDebugMode:"tensorDebugMode",hasDebugTensorValues:"hasDebugTensorValues",debugTensorValues:"debugTensorValues",debugTensorDtypes:"debugTensorDtypes"},decls:7,vars:3,consts:[[1,"focus-execution-container"],[4,"ngIf","ngIfElse"],["loading_section",""],[1,"execution-data-field"],[1,"execution-data-key"],[1,"execution-data-value","op-type"],[1,"execution-data-value","input-tensors"],[1,"execution-data-value","output-tensors"],[1,"execution-data-value"],["class","output-slots",4,"ngIf"],[1,"output-slots"],["class","output-slot-container",4,"ngFor","ngForOf"],[1,"output-slot-container"],[1,"output-slot-number"],[1,"output-slot-debug-tensor-value"],[3,"debugTensorValue"]],template:function(e,i){if(1&e&&(_(0,"div",0)(1,"div")(2,"span"),A(3),v()(),E(4,aVe,20,5,"div",1),E(5,lVe,0,0,"ng-template",null,2,qt),v()),2&e){let r=$e(6);C(3),je(" Python Execution #",i.focusedExecutionIndex," "),C(1),y("ngIf",null!==i.focusedExecutionData)("ngIfElse",r)}},dependencies:[dn,Be,IP],styles:['.debug-tensor-values-table[_ngcontent-%COMP%]{width:100%}.debug-tensor-values-table[_ngcontent-%COMP%]   td[_ngcontent-%COMP%]{border-top:1px solid #000;text-align:left}.debug-tensor-values-table[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{text-align:left}.execution-data-field[_ngcontent-%COMP%]{white-space:nowrap}.execution-data-key[_ngcontent-%COMP%]{display:inline-block;max-width:120px;text-align:right;width:120px}.execution-data-value[_ngcontent-%COMP%]{display:inline-block;margin-left:10px}.focus-execution-container[_ngcontent-%COMP%]{background-color:#ffcc80;border-radius:4px;font-size:12px;height:120px;padding:5px;width:360px}body.dark-mode[_nghost-%COMP%]   .focus-execution-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .focus-execution-container[_ngcontent-%COMP%]{background-color:#e65100}.output-slots[_ngcontent-%COMP%]{height:60px;overflow-x:auto;overflow-y:auto}.output-slot-container[_ngcontent-%COMP%]{border-top:1px solid #ebebeb;margin-top:5px;padding:2px 0;vertical-align:top}body.dark-mode[_nghost-%COMP%]   .output-slot-container[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .output-slot-container[_ngcontent-%COMP%]{border-top:1px solid #555}.output-slot-number[_ngcontent-%COMP%]{display:block;font-family:"Roboto Mono",monospace}.output-slot-debug-tensor-value[_ngcontent-%COMP%]{display:block;margin:3px 0 3px 30px}.output-tensors[_ngcontent-%COMP%]{margin-top:5px}']}),n})(),Jre="Unknown dtype",$re=(()=>{class n{constructor(e){this.store=e,this.focusedExecutionData$=this.store.pipe(vt(pg)),this.tensorDebugMode$=this.store.pipe(vt(J(pg,i=>null===i?as.UNSPECIFIED:i.tensor_debug_mode))),this.hasDebugTensorValues$=this.store.pipe(vt(J(pg,i=>{if(null===i||null===i.debug_tensor_values)return!1;for(let r of i.debug_tensor_values)if(null!==r&&r.length>0)return!0;return!1}))),this.debugTensorValues$=this.store.pipe(vt(J(pg,i=>null===i?null:i.debug_tensor_values))),this.debugTensorDtypes$=this.store.pipe(vt(J(pg,i=>{if(null===i||null===i.debug_tensor_values||i.tensor_debug_mode!==as.FULL_HEALTH&&i.tensor_debug_mode!==as.SHAPE)return null;let r=[];for(let o of i.debug_tensor_values)if(null===o)r.push(Jre);else{let s=String(i.tensor_debug_mode===as.FULL_HEALTH?o[2]:o[1]);r.push(Rw[s]||Jre)}return r})))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["tf-debugger-v2-execution-data"]],inputs:{focusedExecutionIndex:"focusedExecutionIndex"},decls:6,vars:16,consts:[[3,"focusedExecutionIndex","focusedExecutionData","tensorDebugMode","hasDebugTensorValues","debugTensorValues","debugTensorDtypes"]],template:function(e,i){1&e&&(O(0,"execution-data-component",0),B(1,"async"),B(2,"async"),B(3,"async"),B(4,"async"),B(5,"async")),2&e&&y("focusedExecutionIndex",i.focusedExecutionIndex)("focusedExecutionData",U(1,6,i.focusedExecutionData$))("tensorDebugMode",U(2,8,i.tensorDebugMode$))("hasDebugTensorValues",U(3,10,i.hasDebugTensorValues$))("debugTensorValues",U(4,12,i.debugTensorValues$))("debugTensorDtypes",U(5,14,i.debugTensorDtypes$))},dependencies:[Zre,Ge],encapsulation:2}),n})(),hVe=["sliderWrapper"],cc=la({passive:!1}),vVe={provide:No,useExisting:Jn(()=>up),multi:!0},yVe=oc(ko(so(class{constructor(n){this._elementRef=n}}),"accent")),up=(()=>{class n extends yVe{constructor(e,i,r,o,s,a,l,c){super(e),this._focusMonitor=i,this._changeDetectorRef=r,this._dir=o,this._ngZone=a,this._animationMode=c,this._invert=!1,this._max=100,this._min=0,this._step=1,this._thumbLabel=!1,this._tickInterval=0,this._value=null,this._vertical=!1,this.change=new G,this.input=new G,this.valueChange=new G,this.onTouched=()=>{},this._percent=0,this._isSliding=null,this._isActive=!1,this._tickIntervalPercent=0,this._sliderDimensions=null,this._controlValueAccessorChangeFn=()=>{},this._dirChangeSubscription=Sn.EMPTY,this._pointerDown=u=>{this.disabled||this._isSliding||!Ow(u)&&0!==u.button||this._ngZone.run(()=>{this._touchId=Ow(u)?function(n,t){for(let e=0;e<n.touches.length;e++){let i=n.touches[e].target;if(t===i||t.contains(i))return n.touches[e].identifier}}(u,this._elementRef.nativeElement):void 0;let d=toe(u,this._touchId);if(d){let p=this.value;this._isSliding="pointer",this._lastPointerEvent=u,this._focusHostElement(),this._onMouseenter(),this._bindGlobalEvents(u),this._focusHostElement(),this._updateValueFromPosition(d),this._valueOnSlideStart=p,u.cancelable&&u.preventDefault(),p!=this.value&&this._emitInputEvent()}})},this._pointerMove=u=>{if("pointer"===this._isSliding){let d=toe(u,this._touchId);if(d){u.cancelable&&u.preventDefault();let p=this.value;this._lastPointerEvent=u,this._updateValueFromPosition(d),p!=this.value&&this._emitInputEvent()}}},this._pointerUp=u=>{"pointer"===this._isSliding&&(!Ow(u)||"number"!=typeof this._touchId||vU(u.changedTouches,this._touchId))&&(u.cancelable&&u.preventDefault(),this._removeGlobalEvents(),this._isSliding=null,this._touchId=void 0,this._valueOnSlideStart!=this.value&&!this.disabled&&this._emitChangeEvent(),this._valueOnSlideStart=this._lastPointerEvent=null)},this._windowBlur=()=>{this._lastPointerEvent&&this._pointerUp(this._lastPointerEvent)},this._document=l,this.tabIndex=parseInt(s)||0,a.runOutsideAngular(()=>{let u=e.nativeElement;u.addEventListener("mousedown",this._pointerDown,cc),u.addEventListener("touchstart",this._pointerDown,cc)})}get invert(){return this._invert}set invert(e){this._invert=Rt(e)}get max(){return this._max}set max(e){this._max=Bi(e,this._max),this._percent=this._calculatePercentage(this._value),this._changeDetectorRef.markForCheck()}get min(){return this._min}set min(e){this._min=Bi(e,this._min),this._percent=this._calculatePercentage(this._value),this._changeDetectorRef.markForCheck()}get step(){return this._step}set step(e){this._step=Bi(e,this._step),this._step%1!=0&&(this._roundToDecimal=this._step.toString().split(".").pop().length),this._changeDetectorRef.markForCheck()}get thumbLabel(){return this._thumbLabel}set thumbLabel(e){this._thumbLabel=Rt(e)}get tickInterval(){return this._tickInterval}set tickInterval(e){this._tickInterval="auto"===e?"auto":"number"==typeof e||"string"==typeof e?Bi(e,this._tickInterval):0}get value(){return null===this._value&&(this.value=this._min),this._value}set value(e){if(e!==this._value){let i=Bi(e,0);this._roundToDecimal&&i!==this.min&&i!==this.max&&(i=parseFloat(i.toFixed(this._roundToDecimal))),this._value=i,this._percent=this._calculatePercentage(this._value),this._changeDetectorRef.markForCheck()}}get vertical(){return this._vertical}set vertical(e){this._vertical=Rt(e)}get displayValue(){return this.displayWith?this.displayWith(this.value):this._roundToDecimal&&this.value&&this.value%1!=0?this.value.toFixed(this._roundToDecimal):this.value||0}focus(e){this._focusHostElement(e)}blur(){this._blurHostElement()}get percent(){return this._clamp(this._percent)}_shouldInvertAxis(){return this.vertical?!this.invert:this.invert}_isMinValue(){return 0===this.percent}_getThumbGap(){return this.disabled?7:this._isMinValue()&&!this.thumbLabel?this._isActive?10:7:0}_getTrackBackgroundStyles(){let i=this.vertical?`1, ${1-this.percent}, 1`:1-this.percent+", 1, 1";return{transform:`translate${this.vertical?"Y":"X"}(${this._shouldInvertMouseCoords()?"-":""}${this._getThumbGap()}px) scale3d(${i})`}}_getTrackFillStyles(){let e=this.percent,r=this.vertical?`1, ${e}, 1`:`${e}, 1, 1`;return{transform:`translate${this.vertical?"Y":"X"}(${this._shouldInvertMouseCoords()?"":"-"}${this._getThumbGap()}px) scale3d(${r})`,display:0===e?"none":""}}_getTicksContainerStyles(){return{transform:`translate${this.vertical?"Y":"X"}(${this.vertical||"rtl"!=this._getDirection()?"-":""}${this._tickIntervalPercent/2*100}%)`}}_getTicksStyles(){let e=100*this._tickIntervalPercent,a={backgroundSize:this.vertical?`2px ${e}%`:`${e}% 2px`,transform:`translateZ(0) translate${this.vertical?"Y":"X"}(${this.vertical||"rtl"!=this._getDirection()?"":"-"}${e/2}%)${this.vertical||"rtl"!=this._getDirection()?"":" rotate(180deg)"}`};if(this._isMinValue()&&this._getThumbGap()){let c,l=this._shouldInvertAxis();c=this.vertical?l?"Bottom":"Top":l?"Right":"Left",a[`padding${c}`]=`${this._getThumbGap()}px`}return a}_getThumbContainerStyles(){let e=this._shouldInvertAxis();return{transform:`translate${this.vertical?"Y":"X"}(-${100*(("rtl"!=this._getDirection()||this.vertical?e:!e)?this.percent:1-this.percent)}%)`}}_shouldInvertMouseCoords(){let e=this._shouldInvertAxis();return"rtl"!=this._getDirection()||this.vertical?e:!e}_getDirection(){return this._dir&&"rtl"==this._dir.value?"rtl":"ltr"}ngAfterViewInit(){this._focusMonitor.monitor(this._elementRef,!0).subscribe(e=>{this._isActive=!!e&&"keyboard"!==e,this._changeDetectorRef.detectChanges()}),this._dir&&(this._dirChangeSubscription=this._dir.change.subscribe(()=>{this._changeDetectorRef.markForCheck()}))}ngOnDestroy(){let e=this._elementRef.nativeElement;e.removeEventListener("mousedown",this._pointerDown,cc),e.removeEventListener("touchstart",this._pointerDown,cc),this._lastPointerEvent=null,this._removeGlobalEvents(),this._focusMonitor.stopMonitoring(this._elementRef),this._dirChangeSubscription.unsubscribe()}_onMouseenter(){this.disabled||(this._sliderDimensions=this._getSliderDimensions(),this._updateTickIntervalPercent())}_onFocus(){this._sliderDimensions=this._getSliderDimensions(),this._updateTickIntervalPercent()}_onBlur(){this.onTouched()}_onKeydown(e){if(this.disabled||kr(e)||this._isSliding&&"keyboard"!==this._isSliding)return;let i=this.value;switch(e.keyCode){case 33:this._increment(10);break;case 34:this._increment(-10);break;case 35:this.value=this.max;break;case 36:this.value=this.min;break;case 37:this._increment("rtl"==this._getDirection()?1:-1);break;case 38:this._increment(1);break;case 39:this._increment("rtl"==this._getDirection()?-1:1);break;case 40:this._increment(-1);break;default:return}i!=this.value&&(this._emitInputEvent(),this._emitChangeEvent()),this._isSliding="keyboard",e.preventDefault()}_onKeyup(){"keyboard"===this._isSliding&&(this._isSliding=null)}_getWindow(){return this._document.defaultView||window}_bindGlobalEvents(e){let i=this._document,r=Ow(e),s=r?"touchend":"mouseup";i.addEventListener(r?"touchmove":"mousemove",this._pointerMove,cc),i.addEventListener(s,this._pointerUp,cc),r&&i.addEventListener("touchcancel",this._pointerUp,cc);let a=this._getWindow();typeof a<"u"&&a&&a.addEventListener("blur",this._windowBlur)}_removeGlobalEvents(){let e=this._document;e.removeEventListener("mousemove",this._pointerMove,cc),e.removeEventListener("mouseup",this._pointerUp,cc),e.removeEventListener("touchmove",this._pointerMove,cc),e.removeEventListener("touchend",this._pointerUp,cc),e.removeEventListener("touchcancel",this._pointerUp,cc);let i=this._getWindow();typeof i<"u"&&i&&i.removeEventListener("blur",this._windowBlur)}_increment(e){let i=this._clamp(this.value||0,this.min,this.max);this.value=this._clamp(i+this.step*e,this.min,this.max)}_updateValueFromPosition(e){if(!this._sliderDimensions)return;let s=this._clamp(((this.vertical?e.y:e.x)-(this.vertical?this._sliderDimensions.top:this._sliderDimensions.left))/(this.vertical?this._sliderDimensions.height:this._sliderDimensions.width));if(this._shouldInvertMouseCoords()&&(s=1-s),0===s)this.value=this.min;else if(1===s)this.value=this.max;else{let a=this._calculateValue(s),l=Math.round((a-this.min)/this.step)*this.step+this.min;this.value=this._clamp(l,this.min,this.max)}}_emitChangeEvent(){this._controlValueAccessorChangeFn(this.value),this.valueChange.emit(this.value),this.change.emit(this._createChangeEvent())}_emitInputEvent(){this.input.emit(this._createChangeEvent())}_updateTickIntervalPercent(){if(!this.tickInterval||!this._sliderDimensions)return;let e;if("auto"==this.tickInterval){let i=this.vertical?this._sliderDimensions.height:this._sliderDimensions.width;e=Math.ceil(30/(i*this.step/(this.max-this.min)))*this.step/i}else e=this.tickInterval*this.step/(this.max-this.min);this._tickIntervalPercent=eoe(e)?e:0}_createChangeEvent(e=this.value){let i=new class{};return i.source=this,i.value=e,i}_calculatePercentage(e){let i=((e||0)-this.min)/(this.max-this.min);return eoe(i)?i:0}_calculateValue(e){return this.min+e*(this.max-this.min)}_clamp(e,i=0,r=1){return Math.max(i,Math.min(e,r))}_getSliderDimensions(){return this._sliderWrapper?this._sliderWrapper.nativeElement.getBoundingClientRect():null}_focusHostElement(e){this._elementRef.nativeElement.focus(e)}_blurHostElement(){this._elementRef.nativeElement.blur()}writeValue(e){this.value=e}registerOnChange(e){this._controlValueAccessorChangeFn=e}registerOnTouched(e){this.onTouched=e}setDisabledState(e){this.disabled=e}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(Fr),M(nn),M($i,8),vo("tabindex"),M(_t),M(Ht),M(Pi,8))},n.\u0275cmp=R({type:n,selectors:[["mat-slider"]],viewQuery:function(e,i){if(1&e&&ot(hVe,5),2&e){let r;Ne(r=Le())&&(i._sliderWrapper=r.first)}},hostAttrs:["role","slider",1,"mat-slider","mat-focus-indicator"],hostVars:29,hostBindings:function(e,i){1&e&&P("focus",function(){return i._onFocus()})("blur",function(){return i._onBlur()})("keydown",function(o){return i._onKeydown(o)})("keyup",function(){return i._onKeyup()})("mouseenter",function(){return i._onMouseenter()})("selectstart",function(o){return o.preventDefault()}),2&e&&(_s("tabIndex",i.tabIndex),ze("aria-disabled",i.disabled)("aria-valuemax",i.max)("aria-valuemin",i.min)("aria-valuenow",i.value)("aria-valuetext",null==i.valueText?i.displayValue:i.valueText)("aria-orientation",i.vertical?"vertical":"horizontal"),et("mat-slider-disabled",i.disabled)("mat-slider-has-ticks",i.tickInterval)("mat-slider-horizontal",!i.vertical)("mat-slider-axis-inverted",i._shouldInvertAxis())("mat-slider-invert-mouse-coords",i._shouldInvertMouseCoords())("mat-slider-sliding",i._isSliding)("mat-slider-thumb-label-showing",i.thumbLabel)("mat-slider-vertical",i.vertical)("mat-slider-min-value",i._isMinValue())("mat-slider-hide-last-tick",i.disabled||i._isMinValue()&&i._getThumbGap()&&i._shouldInvertAxis())("_mat-animation-noopable","NoopAnimations"===i._animationMode))},inputs:{disabled:"disabled",color:"color",tabIndex:"tabIndex",invert:"invert",max:"max",min:"min",step:"step",thumbLabel:"thumbLabel",tickInterval:"tickInterval",value:"value",displayWith:"displayWith",valueText:"valueText",vertical:"vertical"},outputs:{change:"change",input:"input",valueChange:"valueChange"},exportAs:["matSlider"],features:[$t([vVe]),tt],decls:13,vars:6,consts:[[1,"mat-slider-wrapper"],["sliderWrapper",""],[1,"mat-slider-track-wrapper"],[1,"mat-slider-track-background",3,"ngStyle"],[1,"mat-slider-track-fill",3,"ngStyle"],[1,"mat-slider-ticks-container",3,"ngStyle"],[1,"mat-slider-ticks",3,"ngStyle"],[1,"mat-slider-thumb-container",3,"ngStyle"],[1,"mat-slider-focus-ring"],[1,"mat-slider-thumb"],[1,"mat-slider-thumb-label"],[1,"mat-slider-thumb-label-text"]],template:function(e,i){1&e&&(_(0,"div",0,1)(2,"div",2),O(3,"div",3)(4,"div",4),v(),_(5,"div",5),O(6,"div",6),v(),_(7,"div",7),O(8,"div",8)(9,"div",9),_(10,"div",10)(11,"span",11),A(12),v()()()()),2&e&&(C(3),y("ngStyle",i._getTrackBackgroundStyles()),C(1),y("ngStyle",i._getTrackFillStyles()),C(1),y("ngStyle",i._getTicksContainerStyles()),C(1),y("ngStyle",i._getTicksStyles()),C(1),y("ngStyle",i._getThumbContainerStyles()),C(5),yt(i.displayValue))},dependencies:[zu],styles:['.mat-slider{display:inline-block;position:relative;box-sizing:border-box;padding:8px;outline:none;vertical-align:middle}.mat-slider:not(.mat-slider-disabled):active,.mat-slider.mat-slider-sliding:not(.mat-slider-disabled){cursor:grabbing}.mat-slider-wrapper{-webkit-print-color-adjust:exact;color-adjust:exact;position:absolute}.mat-slider-track-wrapper{position:absolute;top:0;left:0;overflow:hidden}.mat-slider-track-fill{position:absolute;transform-origin:0 0;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-track-background{position:absolute;transform-origin:100% 100%;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-ticks-container{position:absolute;left:0;top:0;overflow:hidden}.mat-slider-ticks{-webkit-background-clip:content-box;background-clip:content-box;background-repeat:repeat;box-sizing:border-box;opacity:0;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-thumb-container{position:absolute;z-index:1;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-focus-ring{position:absolute;width:30px;height:30px;border-radius:50%;transform:scale(0);opacity:0;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 400ms cubic-bezier(0.25, 0.8, 0.25, 1),opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider.cdk-keyboard-focused .mat-slider-focus-ring,.mat-slider.cdk-program-focused .mat-slider-focus-ring{transform:scale(1);opacity:1}.mat-slider:not(.mat-slider-disabled):not(.mat-slider-sliding) .mat-slider-thumb-label,.mat-slider:not(.mat-slider-disabled):not(.mat-slider-sliding) .mat-slider-thumb{cursor:grab}.mat-slider-thumb{position:absolute;right:-10px;bottom:-10px;box-sizing:border-box;width:20px;height:20px;border:3px solid rgba(0,0,0,0);border-radius:50%;transform:scale(0.7);transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 400ms cubic-bezier(0.25, 0.8, 0.25, 1),border-color 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-thumb-label{display:none;align-items:center;justify-content:center;position:absolute;width:28px;height:28px;border-radius:50%;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),border-radius 400ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.cdk-high-contrast-active .mat-slider-thumb-label{outline:solid 1px}.mat-slider-thumb-label-text{z-index:1;opacity:0;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-sliding .mat-slider-track-fill,.mat-slider-sliding .mat-slider-track-background,.mat-slider-sliding .mat-slider-thumb-container{transition-duration:0ms}.mat-slider-has-ticks .mat-slider-wrapper::after{content:"";position:absolute;border-width:0;border-style:solid;opacity:0;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-has-ticks.cdk-focused:not(.mat-slider-hide-last-tick) .mat-slider-wrapper::after,.mat-slider-has-ticks:hover:not(.mat-slider-hide-last-tick) .mat-slider-wrapper::after{opacity:1}.mat-slider-has-ticks.cdk-focused:not(.mat-slider-disabled) .mat-slider-ticks,.mat-slider-has-ticks:hover:not(.mat-slider-disabled) .mat-slider-ticks{opacity:1}.mat-slider-thumb-label-showing .mat-slider-focus-ring{display:none}.mat-slider-thumb-label-showing .mat-slider-thumb-label{display:flex}.mat-slider-axis-inverted .mat-slider-track-fill{transform-origin:100% 100%}.mat-slider-axis-inverted .mat-slider-track-background{transform-origin:0 0}.mat-slider:not(.mat-slider-disabled).cdk-focused.mat-slider-thumb-label-showing .mat-slider-thumb{transform:scale(0)}.mat-slider:not(.mat-slider-disabled).cdk-focused .mat-slider-thumb-label{border-radius:50% 50% 0}.mat-slider:not(.mat-slider-disabled).cdk-focused .mat-slider-thumb-label-text{opacity:1}.mat-slider:not(.mat-slider-disabled).cdk-mouse-focused .mat-slider-thumb,.mat-slider:not(.mat-slider-disabled).cdk-touch-focused .mat-slider-thumb,.mat-slider:not(.mat-slider-disabled).cdk-program-focused .mat-slider-thumb{border-width:2px;transform:scale(1)}.mat-slider-disabled .mat-slider-focus-ring{transform:scale(0);opacity:0}.mat-slider-disabled .mat-slider-thumb{border-width:4px;transform:scale(0.5)}.mat-slider-disabled .mat-slider-thumb-label{display:none}.mat-slider-horizontal{height:48px;min-width:128px}.mat-slider-horizontal .mat-slider-wrapper{height:2px;top:23px;left:8px;right:8px}.mat-slider-horizontal .mat-slider-wrapper::after{height:2px;border-left-width:2px;right:0;top:0}.mat-slider-horizontal .mat-slider-track-wrapper{height:2px;width:100%}.mat-slider-horizontal .mat-slider-track-fill{height:2px;width:100%;transform:scaleX(0)}.mat-slider-horizontal .mat-slider-track-background{height:2px;width:100%;transform:scaleX(1)}.mat-slider-horizontal .mat-slider-ticks-container{height:2px;width:100%}.cdk-high-contrast-active .mat-slider-horizontal .mat-slider-ticks-container{height:0;outline:solid 2px;top:1px}.mat-slider-horizontal .mat-slider-ticks{height:2px;width:100%}.mat-slider-horizontal .mat-slider-thumb-container{width:100%;height:0;top:50%}.mat-slider-horizontal .mat-slider-focus-ring{top:-15px;right:-15px}.mat-slider-horizontal .mat-slider-thumb-label{right:-14px;top:-40px;transform:translateY(26px) scale(0.01) rotate(45deg)}.mat-slider-horizontal .mat-slider-thumb-label-text{transform:rotate(-45deg)}.mat-slider-horizontal.cdk-focused .mat-slider-thumb-label{transform:rotate(45deg)}.cdk-high-contrast-active .mat-slider-horizontal.cdk-focused .mat-slider-thumb-label,.cdk-high-contrast-active .mat-slider-horizontal.cdk-focused .mat-slider-thumb-label-text{transform:none}.mat-slider-vertical{width:48px;min-height:128px}.mat-slider-vertical .mat-slider-wrapper{width:2px;top:8px;bottom:8px;left:23px}.mat-slider-vertical .mat-slider-wrapper::after{width:2px;border-top-width:2px;bottom:0;left:0}.mat-slider-vertical .mat-slider-track-wrapper{height:100%;width:2px}.mat-slider-vertical .mat-slider-track-fill{height:100%;width:2px;transform:scaleY(0)}.mat-slider-vertical .mat-slider-track-background{height:100%;width:2px;transform:scaleY(1)}.mat-slider-vertical .mat-slider-ticks-container{width:2px;height:100%}.cdk-high-contrast-active .mat-slider-vertical .mat-slider-ticks-container{width:0;outline:solid 2px;left:1px}.mat-slider-vertical .mat-slider-focus-ring{bottom:-15px;left:-15px}.mat-slider-vertical .mat-slider-ticks{width:2px;height:100%}.mat-slider-vertical .mat-slider-thumb-container{height:100%;width:0;left:50%}.mat-slider-vertical .mat-slider-thumb{-webkit-backface-visibility:hidden;backface-visibility:hidden}.mat-slider-vertical .mat-slider-thumb-label{bottom:-14px;left:-40px;transform:translateX(26px) scale(0.01) rotate(-45deg)}.mat-slider-vertical .mat-slider-thumb-label-text{transform:rotate(45deg)}.mat-slider-vertical.cdk-focused .mat-slider-thumb-label{transform:rotate(-45deg)}[dir=rtl] .mat-slider-wrapper::after{left:0;right:auto}[dir=rtl] .mat-slider-horizontal .mat-slider-track-fill{transform-origin:100% 100%}[dir=rtl] .mat-slider-horizontal .mat-slider-track-background{transform-origin:0 0}[dir=rtl] .mat-slider-horizontal.mat-slider-axis-inverted .mat-slider-track-fill{transform-origin:0 0}[dir=rtl] .mat-slider-horizontal.mat-slider-axis-inverted .mat-slider-track-background{transform-origin:100% 100%}.mat-slider._mat-animation-noopable .mat-slider-track-fill,.mat-slider._mat-animation-noopable .mat-slider-track-background,.mat-slider._mat-animation-noopable .mat-slider-ticks,.mat-slider._mat-animation-noopable .mat-slider-thumb-container,.mat-slider._mat-animation-noopable .mat-slider-focus-ring,.mat-slider._mat-animation-noopable .mat-slider-thumb,.mat-slider._mat-animation-noopable .mat-slider-thumb-label,.mat-slider._mat-animation-noopable .mat-slider-thumb-label-text,.mat-slider._mat-animation-noopable .mat-slider-has-ticks .mat-slider-wrapper::after{transition:none}'],encapsulation:2,changeDetection:0}),n})();function eoe(n){return!isNaN(n)&&isFinite(n)}function Ow(n){return"t"===n.type[0]}function toe(n,t){let e;return e=Ow(n)?"number"==typeof t?vU(n.touches,t)||vU(n.changedTouches,t):n.touches[0]||n.changedTouches[0]:n,e?{x:e.clientX,y:e.clientY}:void 0}function vU(n,t){for(let e=0;e<n.length;e++)if(n[e].identifier===t)return n[e]}var Wh=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,ln,ln]}),n})();function xVe(n,t){if(1&n){let e=Pe();_(0,"mat-slider",11),P("input",function(r){return oe(e),se(S(2).onSliderChange.emit(r.value))}),v()}if(2&n){let e=S(2);y("min",0)("max",e.scrollBeginIndexUpperLimit)("value",e.scrollBeginIndex)}}function CVe(n,t){if(1&n){let e=Pe();_(0,"div",6)(1,"button",7),P("click",function(){return oe(e),se(S().onNavigateLeft.emit())}),A(2," < "),v(),_(3,"div",8),A(4),v(),_(5,"button",9),P("click",function(){return oe(e),se(S().onNavigateRight.emit())}),A(6," > "),v(),E(7,xVe,1,3,"mat-slider",10),v()}if(2&n){let e=S();C(4),TT(" ",e.scrollBeginIndex," ~ ",e.scrollBeginIndex+e.displayCount-1," of ",e.numExecutions," "),C(3),y("ngIf",e.scrollBeginIndexUpperLimit>0)}}var MVe=function(n,t,e){return[n,t,e]};function wVe(n,t){if(1&n){let e=Pe();_(0,"div",14),P("click",function(){let o=oe(e).index;return se(S(2).onExecutionDigestClicked.emit(o))}),_(1,"div",15),A(2),v()()}if(2&n){let e=t.$implicit,i=t.index,r=S(2);C(1),Zi("title",e.op_type),y("ngClass",Zx(3,MVe,e.is_graph?"func-graph-execution":"",i===r.focusedExecutionDisplayIndex?"focused":"",r.displayFocusedAlertTypes[i]||"")),C(1),je(" ",e.short_op_type," ")}}function SVe(n,t){if(1&n&&(_(0,"div",12),E(1,wVe,3,7,"div",13),v()),2&n){let e=S();C(1),y("ngForOf",e.displayExecutionDigests)}}function EVe(n,t){if(1&n&&(sn(0),O(1,"tf-debugger-v2-execution-data",16),an()),2&n){let e=S();C(1),y("focusedExecutionIndex",e.focusedExecutionIndex)}}var noe=(()=>{class n{constructor(){this.activeRunId=null,this.loadingNumExecutions=!1,this.numExecutions=0,this.scrollBeginIndex=0,this.scrollBeginIndexUpperLimit=0,this.pageSize=0,this.displayCount=0,this.displayExecutionDigests=[],this.displayFocusedAlertTypes=[],this.focusedExecutionIndex=null,this.focusedExecutionDisplayIndex=null,this.focusedExecutionData=null,this.onNavigateLeft=new G,this.onNavigateRight=new G,this.onExecutionDigestClicked=new G,this.onSliderChange=new G}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["timeline-component"]],inputs:{activeRunId:"activeRunId",loadingNumExecutions:"loadingNumExecutions",numExecutions:"numExecutions",scrollBeginIndex:"scrollBeginIndex",scrollBeginIndexUpperLimit:"scrollBeginIndexUpperLimit",pageSize:"pageSize",displayCount:"displayCount",displayExecutionDigests:"displayExecutionDigests",displayFocusedAlertTypes:"displayFocusedAlertTypes",focusedExecutionIndex:"focusedExecutionIndex",focusedExecutionDisplayIndex:"focusedExecutionDisplayIndex",focusedExecutionData:"focusedExecutionData"},outputs:{onNavigateLeft:"onNavigateLeft",onNavigateRight:"onNavigateRight",onExecutionDigestClicked:"onExecutionDigestClicked",onSliderChange:"onSliderChange"},decls:9,vars:4,consts:[[1,"timeline-title"],[1,"execution-count"],[1,"top-level-executions"],["class","navigation-section",4,"ngIf"],["class","execution-timeline",4,"ngIf"],[4,"ngIf"],[1,"navigation-section"],["mat-button","",1,"navigation-button-left",3,"click"],[1,"navigation-position-info"],["mat-button","",1,"navigation-button-right",3,"click"],["class","timeline-slider","step","1",3,"min","max","value","input",4,"ngIf"],["step","1",1,"timeline-slider",3,"min","max","value","input"],[1,"execution-timeline"],[3,"click",4,"ngFor","ngForOf"],[3,"click"],[1,"execution-digest",3,"ngClass","title"],[3,"focusedExecutionIndex"]],template:function(e,i){1&e&&(_(0,"div")(1,"div",0),A(2," Python Execution Timeline "),_(3,"span",1),A(4),v()(),_(5,"div",2),E(6,CVe,8,4,"div",3),E(7,SVe,2,1,"div",4),E(8,EVe,2,1,"ng-container",5),v()()),2&e&&(C(4),je(" (",i.numExecutions,") "),C(2),y("ngIf",i.numExecutions),C(1),y("ngIf",i.numExecutions),C(1),y("ngIf",null!==i.activeRunId&&null!==i.focusedExecutionIndex))},dependencies:[Fn,dn,Be,$re,_n,up],styles:[".execution-digest[_ngcontent-%COMP%] {\n  background-color: #e3e5e8;\n  border: 1px solid #c0c0c0;\n  color: #425066;\n  display: inline-block;\n  font-size: 10px;\n  height: 15px;\n  padding: 1px;\n  text-align: center;\n  vertical-align: middle;\n  width: 12px;\n}\n\n.execution-digest.func-graph-execution[_ngcontent-%COMP%] {\n  background-color: #c7dbf5;\n  color: #4e5664;\n  text-decoration: underline;\n}\n\n.execution-digest.focused[_ngcontent-%COMP%] {\n  background-color: #ffd4b3;\n  border: 1px solid #000;\n  font-weight: bold;\n}\n\n.execution-digest.InfNanAlert[_ngcontent-%COMP%] {\n  background-color: #e52592;\n  color: #fff;\n}\n\n\n.execution-digest[_ngcontent-%COMP%]:hover {\n  border: 1px solid #000;\n  font-weight: bold;\n}\n\n.execution-timeline[_ngcontent-%COMP%] {\n  display: flex;\n  overflow-x: hidden;\n  white-space: nowrap;\n  width: 100%;\n  margin-top: 5px;\n  margin-bottom: 5px;\n}\n\n.timeline-slider[_ngcontent-%COMP%] {\n  display: inline-block;\n  height: 48px;\n  left: 340px; \n  padding: 0;\n  position: absolute;\n  right: 40px;\n}\n\n  .timeline-slider .mat-slider-thumb {\n  border-radius: 5px;\n  right: -40px;\n  width: 80px;\n}\n\n\n.navigation-position-info[_ngcontent-%COMP%] {\n  display: inline-flex;\n  font-size: 14px;\n  line-height: normal;\n  max-width: 200px;\n  padding-left: 10px;\n  padding-right: 10px;\n  text-align: center;\n  vertical-align: middle;\n}\n\n.navigation-section[_ngcontent-%COMP%] {\n  height: 48px;\n  line-height: 48px;\n  position: relative;\n  vertical-align: middle;\n  width: 100%;\n}"],changeDetection:0}),n})(),DVe=["__forward_","__backward_","__inference_"],ioe=(()=>{class n{constructor(e){this.store=e,this.activeRunId$=this.store.pipe(vt(Vs)),this.loadingNumExecutions$=this.store.pipe(vt(J(wP,i=>i.state==Oe.LOADING))),this.scrollBeginIndex$=this.store.pipe(vt(Aw)),this.scrollBeginIndexUpperLimit$=this.store.pipe(vt(J(jh,ny,(i,r)=>Math.max(0,i-r)))),this.pageSize$=this.store.pipe(vt(ty)),this.displayCount$=this.store.pipe(vt(ny)),this.displayExecutionDigests$=this.store.pipe(vt(J(fre,i=>i.map(r=>function(n,t=1){if(!n)return{op_type:"(N/A)",short_op_type:"..",is_graph:!1};let e=DVe.filter(i=>n.op_type.startsWith(i));if(e.length){let i=n.op_type.slice(e[0].length);return{op_type:n.op_type,short_op_type:i.slice(0,t),is_graph:!0}}return{op_type:n.op_type,short_op_type:n.op_type.slice(0,t),is_graph:!1}}(r))))),this.displayFocusedAlertTypes$=this.store.pipe(vt(Mre)),this.focusedExecutionIndex$=this.store.pipe(vt(uU)),this.focusedExecutionDisplayIndex$=this.store.pipe(vt(wre)),this.numExecutions$=this.store.pipe(vt(jh))}onNavigateLeft(){this.store.dispatch(Wv())}onNavigateRight(){this.store.dispatch(qv())}onExecutionDigestClicked(e){this.store.dispatch(Xv({displayIndex:e}))}onSliderChange(e){this.store.dispatch(Yv({index:e}))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["tf-debugger-v2-timeline"]],decls:12,vars:33,consts:[[3,"activeRunId","loadingNumExecutions","numExecutions","scrollBeginIndex","scrollBeginIndexUpperLimit","pageSize","displayCount","displayExecutionDigests","displayFocusedAlertTypes","focusedExecutionIndex","focusedExecutionDisplayIndex","onNavigateLeft","onNavigateRight","onExecutionDigestClicked","onSliderChange"]],template:function(e,i){1&e&&(_(0,"timeline-component",0),P("onNavigateLeft",function(){return i.onNavigateLeft()})("onNavigateRight",function(){return i.onNavigateRight()})("onExecutionDigestClicked",function(o){return i.onExecutionDigestClicked(o)})("onSliderChange",function(o){return i.onSliderChange(o)}),B(1,"async"),B(2,"async"),B(3,"async"),B(4,"async"),B(5,"async"),B(6,"async"),B(7,"async"),B(8,"async"),B(9,"async"),B(10,"async"),B(11,"async"),v()),2&e&&y("activeRunId",U(1,11,i.activeRunId$))("loadingNumExecutions",U(2,13,i.loadingNumExecutions$))("numExecutions",U(3,15,i.numExecutions$))("scrollBeginIndex",U(4,17,i.scrollBeginIndex$))("scrollBeginIndexUpperLimit",U(5,19,i.scrollBeginIndexUpperLimit$))("pageSize",U(6,21,i.pageSize$))("displayCount",U(7,23,i.displayCount$))("displayExecutionDigests",U(8,25,i.displayExecutionDigests$))("displayFocusedAlertTypes",U(9,27,i.displayFocusedAlertTypes$))("focusedExecutionIndex",U(10,29,i.focusedExecutionIndex$))("focusedExecutionDisplayIndex",U(11,31,i.focusedExecutionDisplayIndex$))},dependencies:[noe,Ge],encapsulation:2,changeDetection:0}),n})();function PVe(n,t){1&n&&O(0,"tf-debugger-v2-inactive")}function RVe(n,t){1&n&&(_(0,"div",3),O(1,"tf-debugger-v2-alerts"),_(2,"div",4),O(3,"tf-debugger-v2-timeline")(4,"tf-debugger-v2-graph"),v(),O(5,"tf-debugger-v2-graph-executions"),v(),_(6,"div",5),O(7,"tf-debugger-v2-source-files")(8,"tf-debugger-v2-stack-trace"),v())}var roe=(()=>{class n{constructor(){this.runs={},this.runIds=[],this.activeRunId=null}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["debugger-component"]],inputs:{runs:"runs",runIds:"runIds",activeRunId:"activeRunId"},decls:4,vars:2,consts:[[1,"debugger-container"],[4,"ngIf","ngIfElse"],["dataAvailable",""],[1,"top-section"],[1,"top-center-section"],[1,"bottom-section"]],template:function(e,i){if(1&e&&(_(0,"div",0),E(1,PVe,1,0,"tf-debugger-v2-inactive",1),E(2,RVe,9,0,"ng-template",null,2,qt),v()),2&e){let r=$e(3);C(1),y("ngIf",0===i.runIds.length)("ngIfElse",r)}},dependencies:[Pre,Be,kre,Lre,Vre,Xre,Kre,ioe],styles:[".bottom-section[_ngcontent-%COMP%]{box-sizing:border-box;border-top:1px solid #ebebeb;display:flex;flex-grow:1;height:34%;padding-top:6px}body.dark-mode[_nghost-%COMP%]   .bottom-section[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .bottom-section[_ngcontent-%COMP%]{border-top:1px solid #555}.debugger-container[_ngcontent-%COMP%]{box-sizing:border-box;height:100%;overflow:hidden}.top-section[_ngcontent-%COMP%]{box-sizing:border-box;display:flex;flex-grow:1;height:66%;padding:6px 0}tf-debugger-v2-alerts[_ngcontent-%COMP%]{border-right:1px solid #ebebeb;display:inline-block;margin-right:10px;min-width:160px;width:calc(15% - 11px)}body.dark-mode[_nghost-%COMP%]   tf-debugger-v2-alerts[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   tf-debugger-v2-alerts[_ngcontent-%COMP%]{border-right:1px solid #555}tf-debugger-v2-graph-executions[_ngcontent-%COMP%]{display:inline-block;flex-grow:1;min-width:540px;width:540px}tf-debugger-v2-source-files[_ngcontent-%COMP%]{display:inline-block;height:100%;width:70%}tf-debugger-v2-stack-trace[_ngcontent-%COMP%]{display:inline-block;flex-grow:1;height:100%;min-width:540px;width:540px}.top-center-section[_ngcontent-%COMP%]{display:inline-block;overflow:auto;width:55%}tf-debugger-v2-timeline[_ngcontent-%COMP%]{display:block}tf-debugger-v2-graph[_ngcontent-%COMP%]{border-top:1px solid #ebebeb;display:block;margin-top:5px}body.dark-mode[_nghost-%COMP%]   tf-debugger-v2-graph[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   tf-debugger-v2-graph[_ngcontent-%COMP%]{border-top:1px solid #555}"],changeDetection:0}),n})(),ooe=(()=>{class n{constructor(e){this.store=e,this.runs$=this.store.pipe(vt(ug)),this.runsIds$=this.store.pipe(vt(J(ug,i=>Object.keys(i)))),this.activeRunId$=this.store.pipe(vt(Vs))}ngOnInit(){this.store.dispatch(tP())}ngOnDestroy(){this.store.dispatch(nP())}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["tf-debugger-v2"]],decls:4,vars:9,consts:[[3,"runs","runIds","activeRunId"]],template:function(e,i){1&e&&(O(0,"debugger-component",0),B(1,"async"),B(2,"async"),B(3,"async")),2&e&&y("runs",U(1,3,i.runs$))("runIds",U(2,5,i.runsIds$))("activeRunId",U(3,7,i.activeRunId$))},dependencies:[roe,Ge],styles:["[_nghost-%COMP%] {\n        display: block;\n        height: 100%;\n      }"]}),n})(),kP="debugger-v2";function yU(n,t,e,i,r){if(e<=0||!Number.isInteger(e))throw new Error(`Invalid pageSize: ${e}`);if(t>i)throw new Error(`end index (${t}) exceeds total number of items (${i})`);if(t-n>e)throw new Error("begin-end span exceeds page size, which is not allowed");let o=[],s=Math.floor(n/e);(!(s in r)||r[s]<e&&s*e+r[s]<i)&&o.push(s);let a=Math.floor((t-1)/e);return a!==s&&(!(a in r)||a*e+r[a]<t&&t<i)&&o.push(a),o}var loe=(()=>{class n{constructor(e,i,r){this.actions$=e,this.store=i,this.dataSource=r,this.loadData$=cr(()=>{let o=this.loadDebuggerRuns(Jt(this.onDebuggerDataPoll(),this.onCoreReload())).pipe(Ts()),s=this.loadSourceFileList(o),a=this.createNumExecutionLoader(o),l=this.createNumAlertsAndBreakdownLoader(o),c=this.onAlertTypeFocused(),u=this.fetchExecutionDigestsForAlertTypeFocus(c),d=this.createInitialExecutionDetector(a).pipe(Ts()),p=this.createExecutionDigestLoader(Jt(this.onExecutionScroll(),this.createInitialExecutionDigest(d),u)),h=this.createExecutionDataAndStackFramesLoader(Jt(this.onExecutionDigestFocused(),d.pipe(Wt(this.store.select(Vs),this.store.select(dU)),L(([,b,D])=>({activeRunId:b,loadedExecutionData:D,focusIndex:0})))));return Jt(l,p,h,this.createNumGraphExecutionLoader(o),s,this.onSourceFileFocused(),this.loadGraphExecutionPages(this.onGraphExecutionScroll()),this.loadGraphOpStackFrames(this.loadGraphOpInfo())).pipe(L(()=>({})))},{dispatch:!1})}onDebuggerDataPoll(){return this.actions$.pipe(ii(tP),ui(e=>function(n,t,e){return n.pipe(function(n){return en((t,e)=>{let i,o,r=!1,s=!1,a=!1,l=()=>a&&s&&(e.complete(),!0),u=()=>{a=!1,i=t.subscribe(jt(e,void 0,()=>{a=!0,!l()&&(o||(o=new ke,n(o).subscribe(jt(e,()=>{i?u():r=!0},()=>{s=!0,l()}))),o).next()})),r&&(i.unsubscribe(),i=null,r=!1,u())};u()})}(i=>i.pipe(Wt(t),v0(([,r])=>Ka(r)))),st(e),L(()=>{}))}(Xt(e),this.store.select(cre).pipe(L(i=>function(n){return n>6e4?6e4:n>4e3?n:2e3}(i))),this.actions$.pipe(ii(nP)))),kt(()=>this.store.dispatch(Mw())),L(()=>{}))}onCoreReload(){return Jt(this.actions$.pipe(ii(Fa,aa)),this.actions$.pipe(ii(Zu)).pipe(Wt(this.store.select(iU)),Ye(([,e])=>e.state===Oe.NOT_LOADED||e.state===Oe.FAILED&&null===e.lastLoadedTimeInMs))).pipe(Wt(this.store.select(Rs)),Ye(([,e])=>e===kP),kt(()=>this.store.dispatch(Mw())),L(()=>{}))}loadDebuggerRuns(e){return e.pipe(Wt(this.store.select(iU)),Ye(([,{state:i}])=>i!==Oe.LOADING),kt(()=>this.store.dispatch(iP())),xn(()=>this.dataSource.fetchRuns().pipe(kt(i=>{this.store.dispatch(rP({runs:i}))}),L(()=>{}))))}createNumExecutionLoader(e){return e.pipe(Wt(this.store.select(ug),this.store.select(wP)),Ye(([,i,r])=>Object.keys(i).length>0&&r.state!==Oe.LOADING),kt(()=>this.store.dispatch(aP())),xn(([,i])=>{let r=Object.keys(i)[0];return this.dataSource.fetchExecutionDigests(r,0,0).pipe(kt(a=>{this.store.dispatch(lP({numExecutions:a.num_digests}))}),L(()=>{}))}))}createNumGraphExecutionLoader(e){return e.pipe(Wt(this.store.select(ug),this.store.select(mre)),Ye(([,i,r])=>Object.keys(i).length>0&&r.state!==Oe.LOADING),kt(()=>this.store.dispatch(pP())),xn(([,i])=>{let r=Object.keys(i)[0];return this.dataSource.fetchGraphExecutionDigests(r,0,0).pipe(kt(a=>{this.store.dispatch(hP({numGraphExecutions:a.num_digests}))}),L(()=>{}))}))}createNumAlertsAndBreakdownLoader(e){return e.pipe(Wt(this.store.select(ug),this.store.select(rU)),Ye(([,i,r])=>Object.keys(i).length>0&&r.state!==Oe.LOADING),kt(()=>this.store.dispatch(ww())),xn(([,i])=>{let r=Object.keys(i)[0];return this.dataSource.fetchAlerts(r,0,0).pipe(kt(a=>{this.store.dispatch(oP({numAlerts:a.num_alerts,alertsBreakdown:a.alerts_breakdown}))}),L(()=>{}))}))}createInitialExecutionDetector(e){return e.pipe(Wt(this.store.select(jh),this.store.select(Dw)),Ye(([,i,r])=>i>0&&0===Object.keys(r.pageLoadedSizes).length),L(()=>{}))}createInitialExecutionDigest(e){return e.pipe(Wt(this.store.select(jh),this.store.select(Vs),this.store.select(ty)),Ye(([,,i])=>null!==i),L(([,i,r,o])=>({begin:0,end:Math.min(i,o),runId:r})))}onExecutionScroll(){return this.actions$.pipe(ii(Wv,qv,Yv),Wt(this.store.select(Vs),this.store.select(Aw),this.store.select(jh),this.store.select(ny),this.store.select(ty)),Ye(([e])=>null!==e),L(([,e,i,r,o,s])=>({runId:e,begin:i,end:Math.min(r,i+o),pageSize:s})),Wt(this.store.select(Dw)),L(([e,i])=>({props:e,loaded:i,missingPages:yU(e.begin,e.end,e.pageSize,i.numExecutions,i.pageLoadedSizes)})),Ye(({missingPages:e})=>e.length>0),L(({props:e,loaded:i,missingPages:r})=>{let{runId:o,pageSize:s}=e;return{begin:r[0]*s,end:Math.min(i.numExecutions,(r[r.length-1]+1)*s),runId:o}}))}createExecutionDigestLoader(e){return e.pipe(Wt(this.store.select(Dw)),Ye(([{begin:i,end:r},o])=>r>i&&!function(n,t,e){if(t>=e)throw new Error(`Expected begin to be less than end, but got begin=${t}, end=${e}`);return-1!==n.findIndex(i=>i.begin>=t&&i.end<=e)}(o.loadingRanges,i,r)),kt(([{begin:i,end:r}])=>{this.store.dispatch(cP({begin:i,end:r}))}),xn(([{runId:i,begin:r,end:o}])=>this.dataSource.fetchExecutionDigests(i,r,o).pipe(kt(s=>{this.store.dispatch(uP(s))}),L(()=>{}))))}onExecutionDigestFocused(){return this.actions$.pipe(ii(Xv),Wt(this.store.select(Vs),this.store.select(dU),this.store.select(Aw)),L(([e,i,r,o])=>({activeRunId:i,loadedExecutionData:r,focusIndex:o+e.displayIndex})))}createExecutionDataAndStackFramesLoader(e){return e.pipe(Ye(({activeRunId:i,loadedExecutionData:r,focusIndex:o})=>null!==i&&null!==o&&void 0===r[o]),xn(({activeRunId:i,focusIndex:r})=>{let o=r,s=o+1;return this.dataSource.fetchExecutionData(i,o,s).pipe(kt(a=>{this.store.dispatch(dP(a))}),L(a=>({executionData:a,begin:o,end:s})))}),L(({executionData:i})=>i.executions[0]),Wt(this.store.select(Vs),this.store.select(pU)),Ye(([i,r,o])=>{if(null===r)return!1;for(let s of i.stack_frame_ids)if(void 0===o[s])return!0;return!1}),xn(([i,r])=>{let o=i.stack_frame_ids;return this.dataSource.fetchStackFrames(r,o).pipe(kt(s=>{let a={};for(let l=0;l<o.length;++l)a[o[l]]=s.stack_frames[l];this.store.dispatch(Sw({stackFrames:a}))}),L(()=>{}))}))}onGraphExecutionScroll(){return this.actions$.pipe(ii(Qv),Hr(100),Wt(this.store.select(Vs),this.store.select(Iw),this.store.select(gre)),Ye(([,e,i])=>null!==e&&i>0),L(([,e,i,r])=>({runId:e,numGraphExecutions:i,scrollBeginIndex:r})),Wt(this.store.select(vre),this.store.select(_re),this.store.select(yre),this.store.select(bre)),L(([{runId:e,numGraphExecutions:i,scrollBeginIndex:r},o,s,a,l])=>{let c=yU(r,Math.min(r+s,i),o,i,l);return c=c.filter(u=>-1===a.indexOf(u)),{runId:e,missingPages:c,pageSize:o,numGraphExecutions:i}}))}loadGraphExecutionPages(e){return e.pipe(Ye(({missingPages:i})=>i.length>0),kt(({missingPages:i})=>{i.forEach(r=>{this.store.dispatch(fP({pageIndex:r}))})}),xn(({runId:i,missingPages:r,pageSize:o,numGraphExecutions:s})=>{let a=r[0]*o,l=Math.min((r[r.length-1]+1)*o,s);return this.dataSource.fetchGraphExecutionData(i,a,l).pipe(kt(c=>{this.store.dispatch(mP(c))}),L(()=>{}))}))}loadGraphOpInfo(){return this.actions$.pipe(ii(Zv,Kv),Wt(this.store.select(Vs),this.store.select(Sre)),Ye(([e,i,r])=>{let{graph_id:o,op_name:s}=e;return!(null===i||void 0!==r[o]&&r[o].has(s)&&(r[o].get(s)===Oe.LOADING||r[o].get(s)===Oe.LOADED))}),kt(([{graph_id:e,op_name:i}])=>this.store.dispatch(gP({graph_id:e,op_name:i}))),xn(([e,i])=>{let{graph_id:r,op_name:o}=e;return this.dataSource.fetchGraphOpInfo(i,r,o).pipe(kt(s=>this.store.dispatch(_P({graphOpInfoResponse:s}))),L(s=>({runId:i,stackFrameIds:s.stack_frame_ids})))}))}loadGraphOpStackFrames(e){return e.pipe(Wt(this.store.select(pU)),L(([{runId:i,stackFrameIds:r},o])=>({runId:i,missingStackFrameIds:r.filter(a=>void 0===o[a])})),Ye(({runId:i,missingStackFrameIds:r})=>null!==i&&r.length>0),xn(({runId:i,missingStackFrameIds:r})=>this.dataSource.fetchStackFrames(i,r).pipe(kt(o=>{let s={};for(let a=0;a<r.length;++a)s[r[a]]=o.stack_frames[a];this.store.dispatch(Sw({stackFrames:s}))}),L(()=>{}))))}onAlertTypeFocused(){return this.actions$.pipe(ii(Gv),Wt(this.store.select(Vs),this.store.select(MP),this.store.select(dre),this.store.select(pre),this.store.select(rU)),Ye(([,e,i,r,o,s])=>null!==e&&null!==i&&r>0&&(null===o||Object.keys(o).length<r)&&s.state!==Oe.LOADING),kt(()=>this.store.dispatch(ww())),xn(([,e,i])=>this.dataSource.fetchAlerts(e,0,-1,i)),kt(({num_alerts:e,alerts_breakdown:i,alert_type:r,begin:o,end:s,alerts:a})=>{this.store.dispatch(sP({numAlerts:e,alertsBreakdown:i,alertType:r,begin:o,end:s,alerts:a}))}))}fetchExecutionDigestsForAlertTypeFocus(e){return e.pipe(Wt(this.store.select(ty),this.store.select(ny),this.store.select(jh),this.store.select(Dw),this.store.select(Vs)),L(([i,r,o,s,a,l])=>{let u=i.alerts[0].execution_index,d=yU(Math.max(0,u-Math.floor(o/2)),Math.min(u+Math.floor(o/2),s),r,s,a.pageLoadedSizes);return 0===d.length?{runId:l,begin:0,end:0}:{runId:l,begin:d[0]*r,end:Math.min(a.numExecutions,(d[d.length-1]+1)*r)}}))}loadSourceFileList(e){return e.pipe(Wt(this.store.select(Vs),this.store.select(Tre)),Ye(([,i,r])=>null!==i&&r.state!==Oe.LOADING),kt(()=>this.store.dispatch(vP())),xn(([,i])=>this.dataSource.fetchSourceFileList(i).pipe(kt(r=>{let o=[];r.forEach(([s,a])=>{o.push({host_name:s,file_path:a})}),this.store.dispatch(yP({sourceFiles:o}))}),L(()=>{}))))}onSourceFileFocused(){return this.actions$.pipe(ii(Jv),Wt(this.store.select(Vs),this.store.select(hU),this.store.select(TP)),L(([e,i,r,o])=>({runId:i,stackFrame:e.stackFrame,fileIndex:r,fileContent:o})),Ye(({runId:e,fileContent:i})=>null!==e&&null!==i&&i.loadState===Oe.NOT_LOADED),kt(({stackFrame:e})=>this.store.dispatch(bP({host_name:e.host_name,file_path:e.file_path}))),xn(({fileIndex:e,runId:i})=>this.dataSource.fetchSourceFile(i,e).pipe(kt(r=>{this.store.dispatch(xP(r))}),L(()=>{}))))}}return n.\u0275fac=function(e){return new(e||n)(j(Po),j(Ce),j(eP))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),coe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me]}),n})(),uoe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me]}),n})(),FP=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me]}),n})(),doe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,FP,Zc]}),n})(),poe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),qh=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),NP=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,qh]}),n})(),hoe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,NP]}),n})(),foe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,NP]}),n})(),moe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,FP]}),n})(),goe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,moe,Pn,Wh]}),n})(),_oe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[coe,Me,ec,doe,uoe,poe,hoe,foe,ire,goe,wr.forFeature(Ew,lre),ro.forFeature([loe]),Bs.forPlugin(kP,ooe)]}),n})(),LP=be("[Metrics] Metrics Settings Pane Closed"),BP=be("[Metrics] Metrics Settings Pane Toggled"),VP=be("[Metrics] Slide out settings menu toggled"),HP=be("[Metrics] Metrics Tag Metadata Requested"),UP=be("[Metrics] Metrics Tag Metadata Loaded",{_as:"props",_p:void 0}),zP=be("[Metrics] Metrics Tag Metadata Failed"),jP=be("[Metrics] Metrics Settings Change Tooltip",{_as:"props",_p:void 0}),GP=(be("[Metrics] Metrics Settings Toggle Show Data Download"),be("[Metrics] Metrics Setting Toggle Ignore Outlier")),WP=be("[Metrics] Metrics Setting Change X Axis Type",{_as:"props",_p:void 0}),qP=be("[Metrics] Metrics Setting Change Card Width",{_as:"props",_p:void 0}),YP=be("[Metrics] Metrics Setting Reset Card Width"),XP=be("[Metrics] Metrics Setting Change Scalar Smoothing",{_as:"props",_p:void 0}),QP=be("[Metrics] Metrics Setting Partition Non Monotonic X Toggled"),KP=be("[Metrics] Metrics Setting Change Image Brightness",{_as:"props",_p:void 0}),ZP=be("[Metrics] Metrics Setting Change Image Contrast",{_as:"props",_p:void 0}),JP=be("[Metrics] Image Brightness Setting Reset"),$P=be("[Metrics] Image Contrast Setting Reset"),eR=be("[Metrics] Metrics Setting Toggle Image Show Actual Size"),tR=be("[Metrics] Metrics Setting Change Histogram Mode",{_as:"props",_p:void 0}),nR=be("[Metrics] Multiple Time Series Requested",{_as:"props",_p:void 0}),iR=be("[Metrics] Fetch Time Series Request Failed",{_as:"props",_p:void 0}),rR=be("[Metrics] Fetch Time Series Response Loaded",{_as:"props",_p:void 0}),iy=be("[Metrics] Card Visibility Changed",{_as:"props",_p:void 0}),oR=be("[Metrics] Card Step Slider Changed",{_as:"props",_p:void 0}),sR=be("[Metrics] Tag Filter Changed",{_as:"props",_p:void 0}),aR=be("[Metrics] Metrics Tag Group Expansion Changed",{_as:"props",_p:void 0}),ry=be("[Metrics] Card Pin State Toggled",{_as:"props",_p:void 0}),lR=be("[Metrics] Toggle Visible Plugin",{_as:"props",_p:void 0}),cR=be("[Metrics] Toggle Show All Plugins"),Yh=be("[Metrics] Time Selection Changed",{_as:"props",_p:void 0}),voe=be("[Metrics] Linked Time Selection Cleared"),uR=be("[Metrics] Linked Time Enable Toggle",{_as:"props",_p:void 0}),yoe=be("[Metrics] Sorting Data Table By Header",{_as:"props",_p:void 0}),dR=be("[Metrics] Data table column dragged",{_as:"props",_p:void 0}),boe=be("[Metrics] Data table columns edited in edit menu",{_as:"props",_p:void 0}),pR=be("[Metrics] Data table column toggled in edit menu",{_as:"props",_p:void 0}),Xh=be("[Metrics] Time Selector Enable Toggle",{_as:"props",_p:void 0}),hR=be("[Metrics] Range Selection Toggled",{_as:"props",_p:void 0});function kw(n,t){let e={};for(let i of Object.keys(n))e[i]=t(n[i],i);return e}var cs=(()=>(function(n){n.NONE="no affordance",n.EXTENDED_LINE="extendedLine",n.FOB="fob",n.FOB_REMOVED="fobRemoved",n.FOB_TEXT="fobText",n.SETTINGS_TEXT="settingsText",n.SETTINGS_SLIDER="settingsSlider",n.CHANGE_TO_SINGLE="changeToSingle",n.HISTOGRAM_CLICK_TO_RANGE="histogramClickToRange",n.FOB_ADDED="fobAdded"}(cs||(cs={})),cs))(),bl=(()=>(function(n){n.NONE="no toggle affordance",n.FOB_DESELECT="fobDeselect",n.CHECK_BOX="checkBox"}(bl||(bl={})),bl))(),pa=(()=>(function(n){n[n.HORIZONTAL=0]="HORIZONTAL",n[n.VERTICAL=1]="VERTICAL"}(pa||(pa={})),pa))();function fR(n){let t=new Map,e=n.slice().sort((i,r)=>Fw(i.tag,r.tag));for(let i of e){let r=BVe(i.tag);t.has(r)||t.set(r,{groupName:r,items:[]}),t.get(r).items.push(i)}return[...t.values()]}function BVe(n){return n.split("/",1)[0]}function Fw(n,t){let e=0,i=0;for(;;){if(e===n.length)return i===t.length?0:-1;if(i===t.length)return 1;if(fg(n[e])&&fg(t[i])){let r=e,o=i;e=xoe(n,e+1),i=xoe(t,i+1);let s=Number(n.slice(r,e)),a=Number(t.slice(o,i));if(s<a)return-1;if(s>a)return 1}else{if(bU(n[e])){if(!bU(t[i]))return-1}else{if(bU(t[i]))return 1;if(n[e]<t[i])return-1;if(n[e]>t[i])return 1}e++,i++}}}function xoe(n,t){let e;var o;(o=e||(e={}))[o.NATURAL=0]="NATURAL",o[o.REAL=1]="REAL",o[o.EXPONENT_SIGN=2]="EXPONENT_SIGN",o[o.EXPONENT=3]="EXPONENT";let i=e.NATURAL,r=t;for(;r<n.length;r++)if(i===e.NATURAL){if("."===n[r])i=e.REAL;else if("e"===n[r]||"E"===n[r])i=e.EXPONENT_SIGN;else if(!fg(n[r]))break}else if(i===e.REAL){if("e"===n[r]||"E"===n[r])i=e.EXPONENT_SIGN;else if(!fg(n[r]))break}else if(i===e.EXPONENT_SIGN){if(!fg(n[r])&&"+"!==n[r]&&"-"!==n[r])break;i=e.EXPONENT}else if(i===e.EXPONENT&&!fg(n[r]))break;return r}function fg(n){return"0"<=n&&n<="9"}function bU(n){return"/"===n||fg(n)}var sy=(()=>(function(n){n[n.ORIGINAL=0]="ORIGINAL",n[n.DERIVED=1]="DERIVED"}(sy||(sy={})),sy))(),Kt=(()=>(function(n){n.COLOR="COLOR",n.RELATIVE_TIME="RELATIVE_TIME",n.RUN="RUN",n.STEP="STEP",n.TIME="TIME",n.VALUE="VALUE",n.SMOOTHED="SMOOTHED",n.VALUE_CHANGE="VALUE_CHANGE",n.START_STEP="START_STEP",n.END_STEP="END_STEP",n.START_VALUE="START_VALUE",n.END_VALUE="END_VALUE",n.MIN_VALUE="MIN_VALUE",n.MAX_VALUE="MAX_VALUE",n.PERCENTAGE_CHANGE="PERCENTAGE_CHANGE"}(Kt||(Kt={})),Kt))(),gd=(()=>(function(n){n[n.SINGLE=0]="SINGLE",n[n.RANGE=1]="RANGE"}(gd||(gd={})),gd))(),xl=(()=>(function(n){n[n.ASCENDING=0]="ASCENDING",n[n.DESCENDING=1]="DESCENDING"}(xl||(xl={})),xl))();function xU(n,t,e){let{plugin:i,tag:r,runId:o,sample:s}=t[n],a=rp(e,i,r,s);if(a){if(null!==o&&a.runToSeries.hasOwnProperty(o)){let c=a.runToSeries[o].length;return c>0?c-1:null}let l=Object.values(a.runToSeries).map(c=>c.length);if(l.length)return Math.max(...l)-1}return null}function HVe(n,t,e,i){let r={...t};for(let o in n){if(!n.hasOwnProperty(o))continue;let s=xU(o,n,e);if(null===s){t.hasOwnProperty(o)&&(r[o]=null);continue}let a=t.hasOwnProperty(o)?t[o].index:null,l=xU(o,n,i),c=null!==a&&a===l;(null!==a&&a>s||null===a||c)&&(r[o]={index:s,isClosest:!1})}return r}function Coe(n){let t=kw(n.runToLoadState,e=>e===Oe.LOADING?Oe.LOADING:Oe.NOT_LOADED);return{...n,runToLoadState:t}}function Moe(n,t,e,i){return JSON.stringify([n,t,e||"",i])}var{initialState:Soe,reducers:UVe}=zm({tagMetadataLoadState:{state:Oe.NOT_LOADED,lastLoadedTimeInMs:null},tagMetadata:{scalars:{tagDescriptions:{},tagToRuns:{}},histograms:{tagDescriptions:{},tagToRuns:{}},images:{tagDescriptions:{},tagRunSampledInfo:{}}},cardList:[],cardToPinnedCopy:new Map,cardToPinnedCopyCache:new Map,pinnedCardToOriginal:new Map,unresolvedImportedPinnedCards:[],cardMetadataMap:{},cardStepIndex:{},tagFilter:"",tagGroupExpanded:new Map,linkedTimeSelection:null,linkedTimeEnabled:!1,stepSelectorEnabled:!1,rangeSelectionEnabled:!1,singleSelectionHeaders:[{type:Kt.RUN,enabled:!0},{type:Kt.SMOOTHED,enabled:!0},{type:Kt.VALUE,enabled:!0},{type:Kt.STEP,enabled:!0},{type:Kt.RELATIVE_TIME,enabled:!0}],rangeSelectionHeaders:[{type:Kt.RUN,enabled:!0},{type:Kt.MIN_VALUE,enabled:!0},{type:Kt.MAX_VALUE,enabled:!0},{type:Kt.START_VALUE,enabled:!0},{type:Kt.END_VALUE,enabled:!0},{type:Kt.VALUE_CHANGE,enabled:!0},{type:Kt.PERCENTAGE_CHANGE,enabled:!0},{type:Kt.START_STEP,enabled:!0},{type:Kt.END_STEP,enabled:!0}],filteredPluginTypes:new Set,stepMinMax:{min:1/0,max:-1/0}},{isSettingsPaneOpen:!0,isSlideoutMenuOpen:!1,timeSeriesData:{scalars:{},histograms:{},images:{}},settings:II,settingOverrides:{},visibleCardMap:new Map},(n,t,e)=>Ps(t,e)?n:{...n,tagMetadataLoadState:{state:Oe.NOT_LOADED,lastLoadedTimeInMs:null},tagMetadata:{scalars:{tagDescriptions:{},tagToRuns:{}},histograms:{tagDescriptions:{},tagToRuns:{}},images:{tagDescriptions:{},tagRunSampledInfo:{}}},cardList:[],cardMetadataMap:{},visibleCardMap:new Map}),CU=Soe,zVe=vr(Soe,Se(K_,(n,{routeKind:t,partialState:e})=>{if(t!==hi.EXPERIMENT&&t!==hi.COMPARE_EXPERIMENT)return n;let i=new Set;for(let u of n.pinnedCardToOriginal.keys()){let{plugin:d,tag:p,runId:h,sample:f}=n.cardMetadataMap[u];i.add(Moe(d,p,h,f))}let r=e,o=[];for(let u of[...n.unresolvedImportedPinnedCards,...r.metrics.pinnedCards]){let d=Moe(u.plugin,u.tag,u.runId,u.sample);i.has(d)||(i.add(d),o.push(u))}let s=K4(o,n.cardList,n.cardMetadataMap,n.cardToPinnedCopy,n.cardToPinnedCopyCache,n.pinnedCardToOriginal,n.cardStepIndex),a=r.metrics.smoothing,l=n.settingOverrides;if(Number.isFinite(a)&&null!==a){let u=Math.max(0,Math.min(.999,Number(a.toPrecision(3))));l={...n.settingOverrides,scalarSmoothing:u}}let c={...n,...s,settingOverrides:l};return null!==r.metrics.tagFilter&&(c.tagFilter=r.metrics.tagFilter),c}),Se(Yc,(n,{partialSettings:t})=>{let e={};t.tooltipSort&&Object.values(Oo).includes(t.tooltipSort)&&(e.tooltipSort=t.tooltipSort),"number"==typeof t.timeSeriesCardMinWidth&&(e.cardMinWidth=t.timeSeriesCardMinWidth),"boolean"==typeof t.ignoreOutliers&&(e.ignoreOutliers=t.ignoreOutliers),"number"==typeof t.scalarSmoothing&&(e.scalarSmoothing=t.scalarSmoothing);let i=t.timeSeriesSettingsPaneOpened??n.isSettingsPaneOpen,r=t.stepSelectorEnabled??n.stepSelectorEnabled,o=t.rangeSelectionEnabled??n.rangeSelectionEnabled,s=t.linkedTimeEnabled??n.linkedTimeEnabled;return{...n,isSettingsPaneOpen:i,stepSelectorEnabled:r,rangeSelectionEnabled:o,linkedTimeEnabled:s,settings:{...n.settings,...e}}}),Se(aa,Fa,n=>{let t=n.tagMetadataLoadState.state===Oe.LOADING?Oe.LOADING:Oe.NOT_LOADED,e=kw(n.timeSeriesData,(i,r)=>kw(i,o=>fl(r)?kw(o,s=>Coe(s)):Coe(o)));return{...n,tagMetadataLoadState:{...n.tagMetadataLoadState,state:t},timeSeriesData:e}}),Se(HP,n=>({...n,tagMetadataLoadState:{...n.tagMetadataLoadState,state:Oe.LOADING}})),Se(zP,n=>({...n,tagMetadataLoadState:{...n.tagMetadataLoadState,state:Oe.FAILED}})),Se(UP,(n,{tagMetadata:t})=>{let e={scalars:woe(t,ri.SCALARS),histograms:woe(t,ri.HISTOGRAMS),images:t[ri.IMAGES]},i={},r=function(n){let t=[];for(let e of Object.keys(n)){let r,i=e;if(fl(i)){if(!ml(i))throw new Error("Multi-run, sampled plugin support not yet implemented");{let o=n[i].tagRunSampledInfo;for(let s of Object.keys(o))for(let a of Object.keys(o[s])){let{maxSamplesPerStep:l}=o[s][a];for(let c=0;c<l;c++)t.push({plugin:i,tag:s,runId:a,sample:c,numSample:l})}}}else if(ml(i)){r=n[i].tagToRuns;for(let o of Object.keys(r))for(let s of r[o])t.push({plugin:i,tag:o,runId:s})}else{r=n[i].tagToRuns;for(let o of Object.keys(r))t.push({plugin:i,tag:o,runId:null})}}return t}(e),o=[];for(let h of r){let f=pee(h);i[f]=h,o.push(f)}let s=n.tagGroupExpanded;if(0===n.tagGroupExpanded.size){let f=fR(o.map(m=>({...i[m],cardId:m})).filter(Boolean));s=new Map(n.tagGroupExpanded);for(let m of f.slice(0,2))s.set(m.groupName,!0)}let{nextCardToPinnedCopy:a,nextPinnedCardToOriginal:l,pinnedCardMetadataMap:c}=function(n,t,e){let i=new Map,r=new Map,o={};return n.forEach((s,a)=>{-1!==e.indexOf(a)&&(i.set(a,s),r.set(s,a),o[s]=t[a])}),{nextCardToPinnedCopy:i,nextPinnedCardToOriginal:r,pinnedCardMetadataMap:o}}(n.cardToPinnedCopyCache,i,o),u={...i,...c},d=function(n,t){let e={};return Object.entries(n).forEach(([i,r])=>{t[i]&&(e[i]=r)}),e}(n.cardStepIndex,u),p=K4(n.unresolvedImportedPinnedCards,o,u,a,n.cardToPinnedCopyCache,l,d);return{...n,...p,tagGroupExpanded:s,tagMetadataLoadState:{state:Oe.LOADED,lastLoadedTimeInMs:Date.now()},tagMetadata:e,cardList:o}}),Se(sR,(n,{tagFilter:t})=>({...n,tagFilter:t})),Se(jP,(n,{sort:t})=>({...n,settingOverrides:{...n.settingOverrides,tooltipSort:t}})),Se(GP,n=>{let t=!(n.settingOverrides.ignoreOutliers??n.settings.ignoreOutliers);return{...n,settingOverrides:{...n.settingOverrides,ignoreOutliers:t}}}),Se(WP,(n,{xAxisType:t})=>({...n,settingOverrides:{...n.settingOverrides,xAxisType:t}})),Se(XP,(n,{smoothing:t})=>({...n,settingOverrides:{...n.settingOverrides,scalarSmoothing:t}})),Se(QP,n=>{let t=!(n.settingOverrides.scalarPartitionNonMonotonicX??n.settings.scalarPartitionNonMonotonicX);return{...n,settingOverrides:{...n.settingOverrides,scalarPartitionNonMonotonicX:t}}}),Se(KP,(n,{brightnessInMilli:t})=>({...n,settingOverrides:{...n.settingOverrides,imageBrightnessInMilli:t}})),Se(ZP,(n,{contrastInMilli:t})=>({...n,settingOverrides:{...n.settingOverrides,imageContrastInMilli:t}})),Se(JP,n=>{let{imageBrightnessInMilli:t,...e}=n.settingOverrides;return{...n,settingOverrides:e}}),Se($P,n=>{let{imageContrastInMilli:t,...e}=n.settingOverrides;return{...n,settingOverrides:e}}),Se(eR,n=>{let t=!(n.settingOverrides.imageShowActualSize??n.settings.imageShowActualSize);return{...n,settingOverrides:{...n.settingOverrides,imageShowActualSize:t}}}),Se(tR,(n,{histogramMode:t})=>({...n,settingOverrides:{...n.settingOverrides,histogramMode:t}})),Se(qP,(n,{cardMinWidth:t})=>({...n,settingOverrides:{...n.settingOverrides,cardMinWidth:t}})),Se(YP,n=>({...n,settingOverrides:{...n.settingOverrides,cardMinWidth:null}})),Se(nR,(n,{requests:t})=>{if(!t.length)return n;let e={...n.timeSeriesData};for(let i of t){let{plugin:r,tag:o,sample:s}=i;e[r]=EI(e,r,o,s);let a=rp(e,r,o,s),l=z4(i)?[i.runId]:uv(n.tagMetadata,r,o,s);a.runToLoadState=TI(Oe.LOADING,l,a.runToLoadState)}return{...n,timeSeriesData:e}}),Se(iR,(n,{request:t})=>{let e={...n.timeSeriesData},{plugin:i,tag:r,sample:o}=t;e[i]=EI(e,i,r,o);let s=rp(e,i,r,o),a=z4(t)?[t.runId]:uv(n.tagMetadata,i,r,o);return s.runToLoadState=TI(Oe.FAILED,a,s.runToLoadState),{...n,timeSeriesData:e}}),Se(rR,(n,{response:t})=>{let e={...n.stepMinMax},i={...n.timeSeriesData},{plugin:r,tag:o,runId:s,sample:a}=t;i[r]=EI(i,r,o,a);let l=rp(i,r,o,a);if(bI(t)){let u=s?[s]:uv(n.tagMetadata,r,o,a);l.runToLoadState=TI(Oe.FAILED,u,l.runToLoadState)}else{let u=t.runToSeries;l.runToSeries={...l.runToSeries},l.runToLoadState={...l.runToLoadState};for(let d in u)if(u.hasOwnProperty(d)){l.runToSeries[d]=u[d],l.runToLoadState[d]=Oe.LOADED;for(let p of u[d])e.min=Math.min(e.min,p.step),e.max=Math.max(e.max,p.step)}}return{...n,timeSeriesData:i,cardStepIndex:HVe(n.cardMetadataMap,n.cardStepIndex,i,n.timeSeriesData),stepMinMax:e}}),Se(oR,(n,{cardId:t,stepIndex:e})=>{let i=xU(t,n.cardMetadataMap,n.timeSeriesData),r=e;return null===i?r=null:e>i&&(r=i),{...n,cardStepIndex:{...n.cardStepIndex,[t]:{index:r,isClosest:!1}}}}),Se(aR,(n,{tagGroup:t})=>{let e=new Map(n.tagGroupExpanded);return e.set(t,!e.get(t)),{...n,tagGroupExpanded:e}}),Se(iy,(n,{enteredCards:t,exitedCards:e})=>{if(!t.length&&!e.length)return n;let i=new Map(n.visibleCardMap);return t.forEach(({elementId:r,cardId:o})=>{let s=i.get(r)??null;if(null!==s&&s!==o)throw new Error("A DOM element cannot be reused for more than 1 unique card metadata");i.set(r,o)}),e.forEach(({elementId:r})=>{i.delete(r)}),{...n,visibleCardMap:i}}),Se(ry,(n,{cardId:t})=>{let e=n.pinnedCardToOriginal.has(t),i=!e&&!n.cardToPinnedCopy.has(t);if(i&&!DI(n))return n;let r=new Map(n.cardToPinnedCopy),o=new Map(n.cardToPinnedCopyCache),s=new Map(n.pinnedCardToOriginal),a={...n.cardMetadataMap},l={...n.cardStepIndex};if(e){let c=n.pinnedCardToOriginal.get(t);r.delete(c),o.delete(c),s.delete(t),delete a[t],delete l[t]}else if(i){let c=Z4(t,r,o,s,l,a);r=c.cardToPinnedCopy,o=c.cardToPinnedCopyCache,s=c.pinnedCardToOriginal,a=c.cardMetadataMap,l=c.cardStepIndex}else{let c=n.cardToPinnedCopy.get(t);r.delete(t),o.delete(t),s.delete(c),delete a[c],delete l[c]}return{...n,cardMetadataMap:a,cardStepIndex:l,cardToPinnedCopy:r,cardToPinnedCopyCache:o,pinnedCardToOriginal:s}}),Se(uR,n=>{let t=!n.linkedTimeEnabled,e={...n.cardStepIndex},i=n.linkedTimeSelection,r=n.stepSelectorEnabled;if(t){let{min:o}=n.stepMinMax,s=o===1/0?0:o;i=n.linkedTimeSelection??{start:{step:s},end:null},e=J4(n.cardStepIndex,n.cardMetadataMap,n.timeSeriesData,i),r=t}return{...n,cardStepIndex:e,linkedTimeEnabled:t,linkedTimeSelection:i,stepSelectorEnabled:r}}),Se(hR,n=>{let t=!n.rangeSelectionEnabled,e=n.stepSelectorEnabled,i=n.linkedTimeSelection;return t?(e=t,i||(i={start:{step:n.stepMinMax.min},end:{step:n.stepMinMax.max}}),i.end||(i={...i,end:{step:n.stepMinMax.max}})):i&&(i={...i,end:null}),{...n,stepSelectorEnabled:e,rangeSelectionEnabled:t,linkedTimeSelection:i}}),Se(Yh,(n,t)=>{let{timeSelection:e}=t,i=e.start.step,r=e.end?.step,s=n.rangeSelectionEnabled;n.linkedTimeEnabled&&(s=void 0!==r);let a={start:{step:i},end:void 0===r?null:{step:i>r?i:r}},l=J4(n.cardStepIndex,n.cardMetadataMap,n.timeSeriesData,a);return{...n,linkedTimeSelection:a,cardStepIndex:l,rangeSelectionEnabled:s}}),Se(Xh,(n,{affordance:t})=>{if(!n.linkedTimeEnabled&&t!==bl.CHECK_BOX)return{...n};let e=!n.stepSelectorEnabled,i=e&&n.linkedTimeEnabled,r=e&&n.rangeSelectionEnabled;return{...n,linkedTimeEnabled:i,stepSelectorEnabled:e,rangeSelectionEnabled:r}}),Se(voe,n=>({...n,linkedTimeSelection:null})),Se(dR,(n,{newOrder:t})=>n.rangeSelectionEnabled?{...n,rangeSelectionHeaders:t}:{...n,singleSelectionHeaders:t}),Se(boe,(n,{dataTableMode:t,headers:e})=>{let i=[],r=[];return e.forEach(o=>{o.enabled?i.push(o):r.push(o)}),t===gd.RANGE?{...n,rangeSelectionHeaders:i.concat(r)}:{...n,singleSelectionHeaders:i.concat(r)}}),Se(pR,(n,{dataTableMode:t,headerType:e})=>{let i=t===gd.RANGE?n.rangeSelectionHeaders:n.singleSelectionHeaders,r=i.findIndex(a=>a.type===e),o=function(n){let t=0;return n.forEach(e=>{e.enabled&&t++}),t}(i);i[r].enabled&&o--;let s=function(n,t,e){let i=[...e];return i.splice(n,1),i.splice(t,0,e[n]),i}(r,o,i);return s[o]={type:s[o].type,enabled:!s[o].enabled},t===gd.RANGE?{...n,rangeSelectionHeaders:s}:{...n,singleSelectionHeaders:s}}),Se(lR,(n,{plugin:t})=>{let e=new Set(n.filteredPluginTypes);return e.has(t)?e.delete(t):e.add(t),Object.values(ri).every(i=>e.has(i))&&(e=new Set),{...n,filteredPluginTypes:e}}),Se(cR,n=>({...n,filteredPluginTypes:new Set})),Se(BP,n=>({...n,isSettingsPaneOpen:!n.isSettingsPaneOpen})),Se(LP,n=>({...n,isSettingsPaneOpen:!1})),Se(VP,n=>({...n,isSlideoutMenuOpen:!n.isSlideoutMenuOpen})));function Eoe(n,t){return jm(zVe,UVe)(n,t)}function woe(n,t){return{tagDescriptions:n[t].tagDescriptions,tagToRuns:jVe(n[t].runTagInfo)}}function jVe(n){let t={};for(let e in n)for(let i of n[e])t[i]=[...t[i]||[],e];return t}var qVe=J(bh,tc,(n,t,e)=>t?{...t,loadState:n,id:e}:null),Toe=be("[Metrics Effects] Init"),Doe=(()=>{class n{constructor(e,i,r){this.actions$=e,this.store=i,this.dataSource=r,this.dashboardShownWithoutData$=this.actions$.pipe(ii(Toe,Zu,Um,Jl),Wt(this.store.select(Rs),this.store.select(UM)),Ye(([,o,s])=>o===BM&&s.state===Oe.NOT_LOADED)),this.reloadRequestedWhileShown$=this.actions$.pipe(ii(aa,Fa),Wt(this.store.select(Rs)),Ye(([,o])=>o===BM)),this.loadTagMetadata$=Jt(this.dashboardShownWithoutData$,this.reloadRequestedWhileShown$).pipe(Wt(this.store.select(UM),this.store.select(Wo)),Ye(([,o,s])=>o.state!==Oe.LOADING&&null!==s),kt(()=>{this.store.dispatch(HP())}),ui(([,,o])=>this.dataSource.fetchTagMetadata(o).pipe(kt(s=>{this.store.dispatch(UP({tagMetadata:s}))}),fo(()=>(this.store.dispatch(zP()),Xt(null)))))),this.visibleCardsWithoutDataChanged$=this.actions$.pipe(ii(iy),Wt(this.getVisibleCardFetchInfos()),L(([,o])=>o.filter(s=>s.loadState===Oe.NOT_LOADED))),this.visibleCardsReloaded$=this.reloadRequestedWhileShown$.pipe(Wt(this.getVisibleCardFetchInfos()),L(([,o])=>o.filter(s=>s.loadState!==Oe.LOADING))),this.loadTimeSeries$=Jt(this.visibleCardsWithoutDataChanged$,this.visibleCardsReloaded$).pipe(Ye(o=>o.length>0),Wt(this.store.select(Wo).pipe(Ye(o=>null!==o))),xn(([o,s])=>this.fetchTimeSeriesForCards(o,s))),this.dataEffects$=cr(()=>Jt(this.loadTagMetadata$,this.loadTimeSeries$),{dispatch:!1})}ngrxOnInitEffects(){return Toe()}getVisibleCardFetchInfos(){return this.store.select(mee).pipe(ui(i=>i.size?lr([...i].map(o=>this.store.select(qVe,o).pipe(Qt(1)))):Xt([])),L(i=>i.filter(Boolean)))}fetchTimeSeries(e){return this.dataSource.fetchTimeSeries([e]).pipe(kt(i=>{let r=i.filter(bI);r.length&&console.error("Time series response contained errors:",r),this.store.dispatch(rR({response:i[0]}))}),fo(()=>(this.store.dispatch(iR({request:e})),Xt(null))))}fetchTimeSeriesForCards(e,i){return Xt(e.map(o=>{let{plugin:s,tag:a,runId:l,sample:c}=o,u=ml(s)?{plugin:s,tag:a,runId:l}:{plugin:s,tag:a,experimentIds:i};return void 0!==c&&(u.sample=c),u})).pipe(kt(o=>{this.store.dispatch(nR({requests:o}))}),xn(o=>Jt(...o.map(a=>this.fetchTimeSeries(a)))))}}return n.\u0275fac=function(e){return new(e||n)(j(Po),j(Ce),j($u))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),MU=new pe("Metrics Store Config"),wU=new pe("Metrics Initial Settings Config");function Aoe(n){return n?{initialState:{...CU,settings:n}}:{initialState:CU}}var Cl=(()=>(function(n){n[n.LEFT=1]="LEFT",n[n.RIGHT=2]="RIGHT",n[n.MIDDLE=4]="MIDDLE",n[n.FOURTH=8]="FOURTH",n[n.FIFTH=32]="FIFTH"}(Cl||(Cl={})),Cl))(),Ioe=0;function YVe(n,t){if(1&n){let e=Pe();_(0,"button",3),P("click",function(){return oe(e),se(S().expandSidebar())}),O(1,"mat-icon",4),v()}}function XVe(n,t){if(1&n&&(_(0,"nav",5),B(1,"async"),Vn(2,1),v()),2&n){let e=S();Pt("width",U(1,4,e.width$),"%")("min-width",e.MINIMUM_SIDEBAR_WIDTH_IN_PX,"px")}}function QVe(n,t){if(1&n){let e=Pe();_(0,"div",6),P("mousedown",function(){return oe(e),se(S().resizeGrabbed())}),v()}}var KVe=[[["","main",""]],[["","sidebar",""]]],ZVe=["[main]","[sidebar]"],Roe=(()=>{class n{constructor(e,i){this.store=e,this.width$=this.store.select(iI),this.ngUnsubscribe=new ke,this.resizing=!1,this.MINIMUM_SIDEBAR_WIDTH_IN_PX=75,_i(i.nativeElement,"mousemove").pipe(st(this.ngUnsubscribe),Ye(()=>this.resizing)).subscribe(r=>{if((r.buttons&Cl.LEFT)!==Cl.LEFT)return void(this.resizing=!1);r.preventDefault();let{width:o}=i.nativeElement.getBoundingClientRect();this.store.dispatch(nv({widthInPercent:r.clientX<=this.MINIMUM_SIDEBAR_WIDTH_IN_PX?0:r.clientX/o*100}))}),_i(i.nativeElement,"mouseup",{passive:!0}).pipe(st(this.ngUnsubscribe)).subscribe(()=>{this.resizing=!1})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}resizeGrabbed(){this.resizing=!0}expandSidebar(){this.store.dispatch(nv({widthInPercent:20}))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce),M(Re))},n.\u0275cmp=R({type:n,selectors:[["tb-dashboard-layout"]],ngContentSelectors:ZVe,decls:7,vars:9,consts:[["class","expand",3,"click",4,"ngIf"],["class","sidebar",3,"width","minWidth",4,"ngIf"],["class","resizer",3,"mousedown",4,"ngIf"],[1,"expand",3,"click"],["svgIcon","expand_more_24px"],[1,"sidebar"],[1,"resizer",3,"mousedown"]],template:function(e,i){1&e&&(xi(KVe),E(0,YVe,2,0,"button",0),B(1,"async"),E(2,XVe,3,6,"nav",1),B(3,"async"),E(4,QVe,1,0,"div",2),B(5,"async"),Vn(6)),2&e&&(y("ngIf",0===U(1,3,i.width$)),C(2),y("ngIf",U(3,5,i.width$)>0),C(2),y("ngIf",U(5,7,i.width$)>0))},dependencies:[Be,Gt,Ge],styles:["[_nghost-%COMP%]{display:flex;flex-direction:row;height:100%;width:100%;position:relative}.sidebar[_ngcontent-%COMP%]{max-width:80vw}.resizer[_ngcontent-%COMP%], .expand[_ngcontent-%COMP%]{border-color:#ebebeb;box-sizing:border-box;flex:0 0;justify-self:stretch}body.dark-mode[_nghost-%COMP%]   .resizer[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .resizer[_ngcontent-%COMP%]{border-color:#555}body.dark-mode[_nghost-%COMP%]   .expand[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .expand[_ngcontent-%COMP%]{border-color:#555}.expand[_ngcontent-%COMP%]{width:20px}.resizer[_ngcontent-%COMP%]{align-items:center;border-style:solid;border-width:0 2px;cursor:ew-resize;contain:strict;display:flex;justify-self:stretch}.resizer[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{width:100%}.resizer[_ngcontent-%COMP%]:hover{border-color:#ccc;outline:3px solid #ccc;z-index:1}body.dark-mode[_nghost-%COMP%]   .resizer[_ngcontent-%COMP%]:hover, body.dark-mode   [_nghost-%COMP%]   .resizer[_ngcontent-%COMP%]:hover{outline-color:#777;border-color:#777}.expand[_ngcontent-%COMP%]{align-items:center;background:rgba(0,0,0,0);border-style:solid;border-width:0 1px 0 0;color:inherit;contain:content;cursor:pointer;display:flex;justify-self:stretch;padding:0}.expand[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{transform:rotate(-90deg);transform-origin:center}"],changeDetection:0}),n})(),SU=new WeakMap,Nw=class{constructor(t,e){this.root=t,this.buffer=e,this.destroyedTargets=new WeakSet}initialize(t){if(this.intersectionObserver)return;this.intersectionCallback=t;let e={threshold:0,root:this.root??null};this.buffer&&(e.rootMargin=this.buffer),this.intersectionObserver=new IntersectionObserver(this.onCardIntersection.bind(this),e)}add(t){this.ensureInitialized()&&this.intersectionObserver.observe(t)}willDestroy(t){this.ensureInitialized()&&this.destroyedTargets.add(t)}ensureInitialized(){if(!this.intersectionObserver)throw new Error("CardObserver must be initialized before use");return!0}onCardIntersection(t){t.sort((r,o)=>r.time-o.time);let e=new Set,i=new Set;for(let{isIntersecting:r,target:o}of t)r?(e.add(o),i.delete(o)):(e.delete(o),i.add(o)),this.destroyedTargets.has(o)&&!r&&(this.destroyedTargets.delete(o),this.intersectionObserver.unobserve(o));this.intersectionCallback(e,i)}onCardIntersectionForTest(t){this.onCardIntersection(t)}},Ooe=(()=>{class n{constructor(e,i){this.host=e,this.store=i}onCardIntersection(e,i){let r=[...e].map(s=>{let a=SU.get(s);if(!a)throw new Error("A CardObserver element must have an associated element id and card id.");return{elementId:a.elementId,cardId:a.cardId}}),o=[...i].map(s=>{let a=SU.get(s);if(!a)throw new Error("A CardObserver element must have an associated element id and card id.");return{elementId:a.elementId,cardId:a.cardId}});this.store.dispatch(iy({enteredCards:r,exitedCards:o}))}ngOnInit(){let e=this.host.nativeElement;SU.set(e,{elementId:(Ioe++,Symbol(Ioe)),cardId:this.cardId}),this.cardObserver||(this.cardObserver=new Nw),this.cardObserver.initialize(this.onCardIntersection.bind(this)),this.cardObserver.add(e)}ngOnDestroy(){this.cardObserver&&this.cardObserver.willDestroy(this.host.nativeElement)}hostForTest(){return this.host}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(Ce))},n.\u0275dir=He({type:n,selectors:[["","cardLazyLoader",""]],inputs:{cardId:["cardLazyLoader","cardId"],cardObserver:"cardObserver"}}),n})(),e5e=["button"],t5e=["*"],koe=new pe("MAT_BUTTON_TOGGLE_DEFAULT_OPTIONS"),Foe=new pe("MatButtonToggleGroup"),n5e={provide:No,useExisting:Jn(()=>EU),multi:!0},Noe=0,mR=class{constructor(t,e){this.source=t,this.value=e}},EU=(()=>{class n{constructor(e,i){this._changeDetector=e,this._vertical=!1,this._multiple=!1,this._disabled=!1,this._controlValueAccessorChangeFn=()=>{},this._onTouched=()=>{},this._name="mat-button-toggle-group-"+Noe++,this.valueChange=new G,this.change=new G,this.appearance=i&&i.appearance?i.appearance:"standard"}get name(){return this._name}set name(e){this._name=e,this._markButtonsForCheck()}get vertical(){return this._vertical}set vertical(e){this._vertical=Rt(e)}get value(){let e=this._selectionModel?this._selectionModel.selected:[];return this.multiple?e.map(i=>i.value):e[0]?e[0].value:void 0}set value(e){this._setSelectionByValue(e),this.valueChange.emit(this.value)}get selected(){let e=this._selectionModel?this._selectionModel.selected:[];return this.multiple?e:e[0]||null}get multiple(){return this._multiple}set multiple(e){this._multiple=Rt(e),this._markButtonsForCheck()}get disabled(){return this._disabled}set disabled(e){this._disabled=Rt(e),this._markButtonsForCheck()}ngOnInit(){this._selectionModel=new Ah(this.multiple,void 0,!1)}ngAfterContentInit(){this._selectionModel.select(...this._buttonToggles.filter(e=>e.checked))}writeValue(e){this.value=e,this._changeDetector.markForCheck()}registerOnChange(e){this._controlValueAccessorChangeFn=e}registerOnTouched(e){this._onTouched=e}setDisabledState(e){this.disabled=e}_emitChangeEvent(e){let i=new mR(e,this.value);this._controlValueAccessorChangeFn(i.value),this.change.emit(i)}_syncButtonToggle(e,i,r=!1,o=!1){!this.multiple&&this.selected&&!e.checked&&(this.selected.checked=!1),this._selectionModel?i?this._selectionModel.select(e):this._selectionModel.deselect(e):o=!0,o?Promise.resolve().then(()=>this._updateModelValue(e,r)):this._updateModelValue(e,r)}_isSelected(e){return this._selectionModel&&this._selectionModel.isSelected(e)}_isPrechecked(e){return!(typeof this._rawValue>"u")&&(this.multiple&&Array.isArray(this._rawValue)?this._rawValue.some(i=>null!=e.value&&i===e.value):e.value===this._rawValue)}_setSelectionByValue(e){this._rawValue=e,this._buttonToggles&&(this.multiple&&e?(Array.isArray(e),this._clearSelection(),e.forEach(i=>this._selectValue(i))):(this._clearSelection(),this._selectValue(e)))}_clearSelection(){this._selectionModel.clear(),this._buttonToggles.forEach(e=>e.checked=!1)}_selectValue(e){let i=this._buttonToggles.find(r=>null!=r.value&&r.value===e);i&&(i.checked=!0,this._selectionModel.select(i))}_updateModelValue(e,i){i&&this._emitChangeEvent(e),this.valueChange.emit(this.value)}_markButtonsForCheck(){this._buttonToggles?.forEach(e=>e._markForCheck())}}return n.\u0275fac=function(e){return new(e||n)(M(nn),M(koe,8))},n.\u0275dir=He({type:n,selectors:[["mat-button-toggle-group"]],contentQueries:function(e,i,r){if(1&e&&Ei(r,r5e,5),2&e){let o;Ne(o=Le())&&(i._buttonToggles=o)}},hostAttrs:["role","group",1,"mat-button-toggle-group"],hostVars:5,hostBindings:function(e,i){2&e&&(ze("aria-disabled",i.disabled),et("mat-button-toggle-vertical",i.vertical)("mat-button-toggle-group-appearance-standard","standard"===i.appearance))},inputs:{appearance:"appearance",name:"name",vertical:"vertical",value:"value",multiple:"multiple",disabled:"disabled"},outputs:{valueChange:"valueChange",change:"change"},exportAs:["matButtonToggleGroup"],features:[$t([n5e,{provide:Foe,useExisting:n}])]}),n})(),i5e=qo(class{}),r5e=(()=>{class n extends i5e{constructor(e,i,r,o,s,a){super(),this._changeDetectorRef=i,this._elementRef=r,this._focusMonitor=o,this._checked=!1,this.ariaLabelledby=null,this._disabled=!1,this.change=new G;let l=Number(s);this.tabIndex=l||0===l?l:null,this.buttonToggleGroup=e,this.appearance=a&&a.appearance?a.appearance:"standard"}get buttonId(){return`${this.id}-button`}get appearance(){return this.buttonToggleGroup?this.buttonToggleGroup.appearance:this._appearance}set appearance(e){this._appearance=e}get checked(){return this.buttonToggleGroup?this.buttonToggleGroup._isSelected(this):this._checked}set checked(e){let i=Rt(e);i!==this._checked&&(this._checked=i,this.buttonToggleGroup&&this.buttonToggleGroup._syncButtonToggle(this,this._checked),this._changeDetectorRef.markForCheck())}get disabled(){return this._disabled||this.buttonToggleGroup&&this.buttonToggleGroup.disabled}set disabled(e){this._disabled=Rt(e)}ngOnInit(){let e=this.buttonToggleGroup;this.id=this.id||"mat-button-toggle-"+Noe++,e&&(e._isPrechecked(this)?this.checked=!0:e._isSelected(this)!==this._checked&&e._syncButtonToggle(this,this._checked))}ngAfterViewInit(){this._focusMonitor.monitor(this._elementRef,!0)}ngOnDestroy(){let e=this.buttonToggleGroup;this._focusMonitor.stopMonitoring(this._elementRef),e&&e._isSelected(this)&&e._syncButtonToggle(this,!1,!1,!0)}focus(e){this._buttonElement.nativeElement.focus(e)}_onButtonClick(){let e=!!this._isSingleSelector()||!this._checked;e!==this._checked&&(this._checked=e,this.buttonToggleGroup&&(this.buttonToggleGroup._syncButtonToggle(this,this._checked,!0),this.buttonToggleGroup._onTouched())),this.change.emit(new mR(this,this.value))}_markForCheck(){this._changeDetectorRef.markForCheck()}_getButtonName(){return this._isSingleSelector()?this.buttonToggleGroup.name:this.name||null}_isSingleSelector(){return this.buttonToggleGroup&&!this.buttonToggleGroup.multiple}}return n.\u0275fac=function(e){return new(e||n)(M(Foe,8),M(nn),M(Re),M(Fr),vo("tabindex"),M(koe,8))},n.\u0275cmp=R({type:n,selectors:[["mat-button-toggle"]],viewQuery:function(e,i){if(1&e&&ot(e5e,5),2&e){let r;Ne(r=Le())&&(i._buttonElement=r.first)}},hostAttrs:["role","presentation",1,"mat-button-toggle"],hostVars:12,hostBindings:function(e,i){1&e&&P("focus",function(){return i.focus()}),2&e&&(ze("aria-label",null)("aria-labelledby",null)("id",i.id)("name",null),et("mat-button-toggle-standalone",!i.buttonToggleGroup)("mat-button-toggle-checked",i.checked)("mat-button-toggle-disabled",i.disabled)("mat-button-toggle-appearance-standard","standard"===i.appearance))},inputs:{disableRipple:"disableRipple",ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],id:"id",name:"name",value:"value",tabIndex:"tabIndex",appearance:"appearance",checked:"checked",disabled:"disabled"},outputs:{change:"change"},exportAs:["matButtonToggle"],features:[tt],ngContentSelectors:t5e,decls:6,vars:9,consts:[["type","button",1,"mat-button-toggle-button","mat-focus-indicator",3,"id","disabled","click"],["button",""],[1,"mat-button-toggle-label-content"],[1,"mat-button-toggle-focus-overlay"],["matRipple","",1,"mat-button-toggle-ripple",3,"matRippleTrigger","matRippleDisabled"]],template:function(e,i){if(1&e&&(xi(),_(0,"button",0,1),P("click",function(){return i._onButtonClick()}),_(2,"span",2),Vn(3),v()(),O(4,"span",3)(5,"span",4)),2&e){let r=$e(1);y("id",i.buttonId)("disabled",i.disabled||null),ze("tabindex",i.disabled?-1:i.tabIndex)("aria-pressed",i.checked)("name",i._getButtonName())("aria-label",i.ariaLabel)("aria-labelledby",i.ariaLabelledby),C(5),y("matRippleTrigger",r)("matRippleDisabled",i.disableRipple||i.disabled)}},dependencies:[Yo],styles:[".mat-button-toggle-standalone,.mat-button-toggle-group{position:relative;display:inline-flex;flex-direction:row;white-space:nowrap;overflow:hidden;border-radius:2px;-webkit-tap-highlight-color:rgba(0,0,0,0);transform:translateZ(0)}.cdk-high-contrast-active .mat-button-toggle-standalone,.cdk-high-contrast-active .mat-button-toggle-group{outline:solid 1px}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.mat-button-toggle-group-appearance-standard{border-radius:4px}.cdk-high-contrast-active .mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.cdk-high-contrast-active .mat-button-toggle-group-appearance-standard{outline:0}.mat-button-toggle-vertical{flex-direction:column}.mat-button-toggle-vertical .mat-button-toggle-label-content{display:block}.mat-button-toggle{white-space:nowrap;position:relative}.mat-button-toggle .mat-icon svg{vertical-align:top}.mat-button-toggle.cdk-keyboard-focused .mat-button-toggle-focus-overlay{opacity:1}.mat-button-toggle-appearance-standard:not(.mat-button-toggle-disabled):hover .mat-button-toggle-focus-overlay{opacity:.04}.mat-button-toggle-appearance-standard.cdk-keyboard-focused:not(.mat-button-toggle-disabled) .mat-button-toggle-focus-overlay{opacity:.12}@media(hover: none){.mat-button-toggle-appearance-standard:not(.mat-button-toggle-disabled):hover .mat-button-toggle-focus-overlay{display:none}}.mat-button-toggle-label-content{-webkit-user-select:none;user-select:none;display:inline-block;line-height:36px;padding:0 16px;position:relative}.mat-button-toggle-appearance-standard .mat-button-toggle-label-content{padding:0 12px}.mat-button-toggle-label-content>*{vertical-align:middle}.mat-button-toggle-focus-overlay{top:0;left:0;right:0;bottom:0;position:absolute;border-radius:inherit;pointer-events:none;opacity:0}.cdk-high-contrast-active .mat-button-toggle-checked .mat-button-toggle-focus-overlay{border-bottom:solid 36px;opacity:.5;height:0}.cdk-high-contrast-active .mat-button-toggle-checked:hover .mat-button-toggle-focus-overlay{opacity:.6}.cdk-high-contrast-active .mat-button-toggle-checked.mat-button-toggle-appearance-standard .mat-button-toggle-focus-overlay{border-bottom:solid 500px}.mat-button-toggle .mat-button-toggle-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}.mat-button-toggle-button{border:0;background:none;color:inherit;padding:0;margin:0;font:inherit;outline:none;width:100%;cursor:pointer}.mat-button-toggle-disabled .mat-button-toggle-button{cursor:default}.mat-button-toggle-button::-moz-focus-inner{border:0}"],encapsulation:2,changeDetection:0}),n})(),gR=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[ln,_l,ln]}),n})();function s5e(n,t){if(1&n&&(In(),O(0,"circle",4)),2&n){let e=S(),i=$e(1);Pt("animation-name","mat-progress-spinner-stroke-rotate-"+e._spinnerAnimationLabel)("stroke-dashoffset",e._getStrokeDashOffset(),"px")("stroke-dasharray",e._getStrokeCircumference(),"px")("stroke-width",e._getCircleStrokeWidth(),"%")("transform-origin",e._getCircleTransformOrigin(i)),ze("r",e._getCircleRadius())}}function a5e(n,t){if(1&n&&(In(),O(0,"circle",4)),2&n){let e=S(),i=$e(1);Pt("stroke-dashoffset",e._getStrokeDashOffset(),"px")("stroke-dasharray",e._getStrokeCircumference(),"px")("stroke-width",e._getCircleStrokeWidth(),"%")("transform-origin",e._getCircleTransformOrigin(i)),ze("r",e._getCircleRadius())}}var c5e=ko(class{constructor(n){this._elementRef=n}},"primary"),u5e=new pe("mat-progress-spinner-default-options",{providedIn:"root",factory:function(){return{diameter:100}}}),Bo=class extends c5e{constructor(t,e,i,r,o,s,a,l){super(t),this._document=i,this._diameter=100,this._value=0,this._resizeSubscription=Sn.EMPTY,this.mode="determinate";let c=Bo._diameters;this._spinnerAnimationLabel=this._getSpinnerAnimationLabel(),c.has(i.head)||c.set(i.head,new Set([100])),this._noopAnimations="NoopAnimations"===r&&!!o&&!o._forceAnimations,"mat-spinner"===t.nativeElement.nodeName.toLowerCase()&&(this.mode="indeterminate"),o&&(o.color&&(this.color=this.defaultColor=o.color),o.diameter&&(this.diameter=o.diameter),o.strokeWidth&&(this.strokeWidth=o.strokeWidth)),e.isBrowser&&e.SAFARI&&a&&s&&l&&(this._resizeSubscription=a.change(150).subscribe(()=>{"indeterminate"===this.mode&&l.run(()=>s.markForCheck())}))}get diameter(){return this._diameter}set diameter(t){this._diameter=Bi(t),this._spinnerAnimationLabel=this._getSpinnerAnimationLabel(),this._styleRoot&&this._attachStyleNode()}get strokeWidth(){return this._strokeWidth||this.diameter/10}set strokeWidth(t){this._strokeWidth=Bi(t)}get value(){return"determinate"===this.mode?this._value:0}set value(t){this._value=Math.max(0,Math.min(100,Bi(t)))}ngOnInit(){let t=this._elementRef.nativeElement;this._styleRoot=a2(t)||this._document.head,this._attachStyleNode(),t.classList.add("mat-progress-spinner-indeterminate-animation")}ngOnDestroy(){this._resizeSubscription.unsubscribe()}_getCircleRadius(){return(this.diameter-10)/2}_getViewBox(){let t=2*this._getCircleRadius()+this.strokeWidth;return`0 0 ${t} ${t}`}_getStrokeCircumference(){return 2*Math.PI*this._getCircleRadius()}_getStrokeDashOffset(){return"determinate"===this.mode?this._getStrokeCircumference()*(100-this._value)/100:null}_getCircleStrokeWidth(){return this.strokeWidth/this.diameter*100}_getCircleTransformOrigin(t){let e=50*(t.currentScale??1);return`${e}% ${e}%`}_attachStyleNode(){let t=this._styleRoot,e=this._diameter,i=Bo._diameters,r=i.get(t);if(!r||!r.has(e)){let o=this._document.createElement("style");o.setAttribute("mat-spinner-animation",this._spinnerAnimationLabel),o.textContent=this._getAnimationText(),t.appendChild(o),r||(r=new Set,i.set(t,r)),r.add(e)}}_getAnimationText(){let t=this._getStrokeCircumference();return"\n @keyframes mat-progress-spinner-stroke-rotate-DIAMETER {\n    0%      { stroke-dashoffset: START_VALUE;  transform: rotate(0); }\n    12.5%   { stroke-dashoffset: END_VALUE;    transform: rotate(0); }\n    12.5001%  { stroke-dashoffset: END_VALUE;    transform: rotateX(180deg) rotate(72.5deg); }\n    25%     { stroke-dashoffset: START_VALUE;  transform: rotateX(180deg) rotate(72.5deg); }\n\n    25.0001%   { stroke-dashoffset: START_VALUE;  transform: rotate(270deg); }\n    37.5%   { stroke-dashoffset: END_VALUE;    transform: rotate(270deg); }\n    37.5001%  { stroke-dashoffset: END_VALUE;    transform: rotateX(180deg) rotate(161.5deg); }\n    50%     { stroke-dashoffset: START_VALUE;  transform: rotateX(180deg) rotate(161.5deg); }\n\n    50.0001%  { stroke-dashoffset: START_VALUE;  transform: rotate(180deg); }\n    62.5%   { stroke-dashoffset: END_VALUE;    transform: rotate(180deg); }\n    62.5001%  { stroke-dashoffset: END_VALUE;    transform: rotateX(180deg) rotate(251.5deg); }\n    75%     { stroke-dashoffset: START_VALUE;  transform: rotateX(180deg) rotate(251.5deg); }\n\n    75.0001%  { stroke-dashoffset: START_VALUE;  transform: rotate(90deg); }\n    87.5%   { stroke-dashoffset: END_VALUE;    transform: rotate(90deg); }\n    87.5001%  { stroke-dashoffset: END_VALUE;    transform: rotateX(180deg) rotate(341.5deg); }\n    100%    { stroke-dashoffset: START_VALUE;  transform: rotateX(180deg) rotate(341.5deg); }\n  }\n".replace(/START_VALUE/g,""+.95*t).replace(/END_VALUE/g,""+.2*t).replace(/DIAMETER/g,`${this._spinnerAnimationLabel}`)}_getSpinnerAnimationLabel(){return this.diameter.toString().replace(".","_")}};Bo._diameters=new WeakMap,Bo.\u0275fac=function(t){return new(t||Bo)(M(Re),M(oi),M(Ht,8),M(Pi,8),M(u5e),M(nn),M(Va),M(_t))},Bo.\u0275cmp=R({type:Bo,selectors:[["mat-progress-spinner"],["mat-spinner"]],hostAttrs:["role","progressbar","tabindex","-1",1,"mat-progress-spinner","mat-spinner"],hostVars:10,hostBindings:function(t,e){2&t&&(ze("aria-valuemin","determinate"===e.mode?0:null)("aria-valuemax","determinate"===e.mode?100:null)("aria-valuenow","determinate"===e.mode?e.value:null)("mode",e.mode),Pt("width",e.diameter,"px")("height",e.diameter,"px"),et("_mat-animation-noopable",e._noopAnimations))},inputs:{color:"color",diameter:"diameter",strokeWidth:"strokeWidth",mode:"mode",value:"value"},exportAs:["matProgressSpinner"],features:[tt],decls:4,vars:8,consts:[["preserveAspectRatio","xMidYMid meet","focusable","false","aria-hidden","true",3,"ngSwitch"],["svg",""],["cx","50%","cy","50%",3,"animation-name","stroke-dashoffset","stroke-dasharray","stroke-width","transform-origin",4,"ngSwitchCase"],["cx","50%","cy","50%",3,"stroke-dashoffset","stroke-dasharray","stroke-width","transform-origin",4,"ngSwitchCase"],["cx","50%","cy","50%"]],template:function(t,e){1&t&&(In(),_(0,"svg",0,1),E(2,s5e,1,11,"circle",2),E(3,a5e,1,9,"circle",3),v()),2&t&&(Pt("width",e.diameter,"px")("height",e.diameter,"px"),y("ngSwitch","indeterminate"===e.mode),ze("viewBox",e._getViewBox()),C(2),y("ngSwitchCase",!0),C(1),y("ngSwitchCase",!1))},dependencies:[Cr,Ur],styles:[".mat-progress-spinner{display:block;position:relative;overflow:hidden}.mat-progress-spinner svg{position:absolute;transform:rotate(-90deg);top:0;left:0;transform-origin:center;overflow:visible}.mat-progress-spinner circle{fill:rgba(0,0,0,0);transition:stroke-dashoffset 225ms linear}.cdk-high-contrast-active .mat-progress-spinner circle{stroke:CanvasText}.mat-progress-spinner[mode=indeterminate] svg{animation:mat-progress-spinner-linear-rotate 2000ms linear infinite}.mat-progress-spinner[mode=indeterminate] circle{transition-property:stroke;animation-duration:4000ms;animation-timing-function:cubic-bezier(0.35, 0, 0.25, 1);animation-iteration-count:infinite}.mat-progress-spinner._mat-animation-noopable svg,.mat-progress-spinner._mat-animation-noopable circle{animation:none;transition:none}@keyframes mat-progress-spinner-linear-rotate{0%{transform:rotate(0deg)}100%{transform:rotate(360deg)}}@keyframes mat-progress-spinner-stroke-rotate-100{0%{stroke-dashoffset:268.606171575px;transform:rotate(0)}12.5%{stroke-dashoffset:56.5486677px;transform:rotate(0)}12.5001%{stroke-dashoffset:56.5486677px;transform:rotateX(180deg) rotate(72.5deg)}25%{stroke-dashoffset:268.606171575px;transform:rotateX(180deg) rotate(72.5deg)}25.0001%{stroke-dashoffset:268.606171575px;transform:rotate(270deg)}37.5%{stroke-dashoffset:56.5486677px;transform:rotate(270deg)}37.5001%{stroke-dashoffset:56.5486677px;transform:rotateX(180deg) rotate(161.5deg)}50%{stroke-dashoffset:268.606171575px;transform:rotateX(180deg) rotate(161.5deg)}50.0001%{stroke-dashoffset:268.606171575px;transform:rotate(180deg)}62.5%{stroke-dashoffset:56.5486677px;transform:rotate(180deg)}62.5001%{stroke-dashoffset:56.5486677px;transform:rotateX(180deg) rotate(251.5deg)}75%{stroke-dashoffset:268.606171575px;transform:rotateX(180deg) rotate(251.5deg)}75.0001%{stroke-dashoffset:268.606171575px;transform:rotate(90deg)}87.5%{stroke-dashoffset:56.5486677px;transform:rotate(90deg)}87.5001%{stroke-dashoffset:56.5486677px;transform:rotateX(180deg) rotate(341.5deg)}100%{stroke-dashoffset:268.606171575px;transform:rotateX(180deg) rotate(341.5deg)}}"],encapsulation:2,changeDetection:0});var _d=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[ln,Me,ln]}),n})();function h5e(n,t){if(1&n&&(_(0,"b"),A(1),v()),2&n){let e=S().$implicit;C(1),je("",e.displayAlias,":")}}function f5e(n,t){if(1&n&&(_(0,"mat-option",2)(1,"span",3),E(2,h5e,2,1,"b",4),A(3),v()()),2&n){let e=t.$implicit;y("value",e.value)("disabled",e.disabled),C(1),ET("title","",e.displayAlias,": ",e.displayText,""),C(1),y("ngIf",e.displayAlias),C(1),je(" ",e.displayText," ")}}var Loe=(()=>{class n{constructor(){this.value="",this.options=[],this.selectionChange=new G}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["tb-dropdown"]],inputs:{value:"value",options:"options"},outputs:{selectionChange:"selectionChange"},decls:2,vars:2,consts:[[3,"value","selectionChange"],[3,"value","disabled",4,"ngFor","ngForOf"],[3,"value","disabled"],[1,"option-content",3,"title"],[4,"ngIf"]],template:function(e,i){1&e&&(_(0,"mat-select",0),P("selectionChange",function(o){return i.selectionChange.emit(o.value)}),E(1,f5e,4,6,"mat-option",1),v()),2&e&&(y("value",i.value),C(1),y("ngForOf",i.options))},dependencies:[dn,Be,Hh,Os],styles:["mat-select[_ngcontent-%COMP%]{border:1px solid #8e98a3;border-radius:3px;box-sizing:border-box;padding:6px}mat-select[_ngcontent-%COMP%]:focus{outline-color:-webkit-focus-ring-color;outline-style:auto}  .mat-select-panel{max-width:70vw}  mat-option.mat-option{height:auto}  .mat-option-text{white-space:normal;word-break:break-all}.option-content[_ngcontent-%COMP%]{white-space:nowrap}"]}),n})();function g5e(n,t){if(1&n){let e=Pe();_(0,"div",32)(1,"mat-checkbox",27),P("change",function(){return oe(e),se(S(2).rangeSelectionToggled.emit())}),A(2,"Enable Range Selection "),v()()}if(2&n){let e=S(2);C(1),y("checked",e.isScalarStepSelectorRangeEnabled)("disabled",!e.isAxisTypeStep())}}function _5e(n,t){if(1&n){let e=Pe();_(0,"div",33)(1,"mat-checkbox",27),P("change",function(){return oe(e),se(S(2).linkedTimeToggled.emit())}),A(2),v()()}if(2&n){let e=S(2);C(1),y("checked",e.isLinkedTimeEnabled)("disabled",!e.isAxisTypeStep()),C(1),je("Link by step ",e.getLinkedTimeSelectionStartStep()," ")}}function v5e(n,t){1&n&&O(0,"mat-icon",37)}function y5e(n,t){1&n&&O(0,"mat-icon",38)}function b5e(n,t){if(1&n){let e=Pe();_(0,"div",34),P("click",function(){return oe(e),se(S(2).onSlideOutToggled.emit())}),E(1,v5e,1,0,"mat-icon",35),E(2,y5e,1,0,"mat-icon",36),A(3," Open Column Edit Control "),v()}if(2&n){let e=S(2);C(1),y("ngIf",!e.isSlideOutMenuOpen),C(1),y("ngIf",e.isSlideOutMenuOpen)}}function x5e(n,t){if(1&n){let e=Pe();_(0,"div",26)(1,"mat-checkbox",27),P("change",function(){return oe(e),se(S().stepSelectorToggled.emit())}),A(2,"Enable step selection and data table "),v(),_(3,"span",28),A(4,"(Scalars only)"),v(),E(5,g5e,3,2,"div",29),E(6,_5e,3,3,"div",30),E(7,b5e,4,2,"div",31),v()}if(2&n){let e=S();y("title",e.isAxisTypeStep()?"":"Only available when Horizontal Axis is set to step"),C(1),y("checked",e.isScalarStepSelectorEnabled)("disabled",!e.isAxisTypeStep()),C(4),y("ngIf",e.isRangeSelectionAllowed),C(1),y("ngIf",e.isLinkedTimeFeatureEnabled),C(1),y("ngIf",e.isScalarColumnCustomizationEnabled)}}function C5e(n,t){if(1&n){let e=Pe();_(0,"section",39)(1,"h3",1),A(2,"Images"),v(),_(3,"div",40)(4,"div",41),A(5,"Brightness"),v(),_(6,"div",8)(7,"mat-slider",42),P("input",function(r){return oe(e),se(S().imageBrightnessSliderChanged$.emit(r.value))}),v(),_(8,"button",43),P("click",function(){return oe(e),se(S().imageBrightnessReset.emit())}),O(9,"mat-icon",11),v()()(),_(10,"div",44)(11,"div",45),A(12,"Contrast"),v(),_(13,"div",8)(14,"mat-slider",46),P("input",function(r){return oe(e),se(S().imageContrastSliderChanged$.emit(r.value))}),v(),_(15,"button",47),P("click",function(){return oe(e),se(S().imageContrastReset.emit())}),O(16,"mat-icon",11),v()()(),_(17,"div",48)(18,"mat-checkbox",20),P("change",function(r){return oe(e),se(S().imageShowActualSizeChanged.emit(r.checked))}),A(19,"Show actual image size"),v()()()}if(2&n){let e=S();C(7),y("max",2e3)("min",0)("step",10)("value",e.imageBrightnessInMilli)("thumbLabel",!0)("displayWith",e.formatMilliToZeroth),C(7),y("max",5e3)("min",0)("step",10)("value",e.imageContrastInMilli)("thumbLabel",!0)("displayWith",e.formatMilliToZeroth),C(4),y("checked",e.imageShowActualSize)}}var Voe=(()=>{class n{constructor(e){this.locale=e,this.linkedTimeToggled=new G,this.linkedTimeSelectionChanged=new G,this.stepSelectorToggled=new G,this.rangeSelectionToggled=new G,this.onSlideOutToggled=new G,this.TooltipSortDropdownOptions=[{value:Oo.ALPHABETICAL,displayText:"Alphabetical"},{value:Oo.ASCENDING,displayText:"Ascending"},{value:Oo.DESCENDING,displayText:"Descending"},{value:Oo.NEAREST,displayText:"Nearest Pixel"},{value:Oo.NEAREST_Y,displayText:"Nearest Y"}],this.tooltipSortChanged=new G,this.ignoreOutliersChanged=new G,this.XAxisType=Ji,this.XAxisTypeDropdownOptions=[{value:Ji.STEP,displayText:"Step"},{value:Ji.RELATIVE,displayText:"Relative"},{value:Ji.WALL_TIME,displayText:"Wall"}],this.xAxisTypeChanged=new G,this.MAX_CARD_WIDTH_SLIDER_VALUE=735,this.MIN_CARD_WIDTH_SLIDER_VALUE=335,this.cardWidthSliderChanged$=new G,this.cardWidthChanged=this.cardWidthSliderChanged$.pipe(bu(250)),this.cardWidthReset=new G,this.HistogramModeDropdownOptions=[{value:zr.OFFSET,displayText:"Offset"},{value:zr.OVERLAY,displayText:"Overlay"}],this.histogramModeChanged=new G,this.MAX_SMOOTHING_VALUE=.999,this.MAX_SMOOTHING_SLIDER_VALUE=.99,this.scalarSmoothingControlChanged$=new G,this.scalarSmoothingChanged=this.scalarSmoothingControlChanged$.pipe(bu(250)),this.scalarPartitionXToggled=new G,this.imageBrightnessSliderChanged$=new G,this.imageBrightnessInMilliChanged=this.imageBrightnessSliderChanged$.pipe(bu(250)),this.imageBrightnessReset=new G,this.imageContrastSliderChanged$=new G,this.imageContrastInMilliChanged=this.imageContrastSliderChanged$.pipe(bu(250)),this.imageContrastReset=new G,this.imageShowActualSizeChanged=new G}onScalarSmoothingInput(e){let i=e.target;if(!i.value)return;let r=Math.min(Math.max(0,parseFloat(i.value)),.999);r!==parseFloat(i.value)&&(i.value=String(r)),this.scalarSmoothingControlChanged$.emit(r)}formatMilliToZeroth(e){return u5(e/1e3,this.locale||"en-US","1.0-2")}getLinkedTimeSelectionStartStep(){return this.isLinkedTimeEnabled||null===this.linkedTimeSelection||null!==this.linkedTimeSelection.end?"":this.linkedTimeSelection.start.step}isAxisTypeStep(){return this.xAxisType===Ji.STEP}}return n.\u0275fac=function(e){return new(e||n)(M(Wd))},n.\u0275cmp=R({type:n,selectors:[["metrics-dashboard-settings-component"]],inputs:{isLinkedTimeFeatureEnabled:"isLinkedTimeFeatureEnabled",isRangeSelectionAllowed:"isRangeSelectionAllowed",isLinkedTimeEnabled:"isLinkedTimeEnabled",isScalarStepSelectorFeatureEnabled:"isScalarStepSelectorFeatureEnabled",isScalarStepSelectorEnabled:"isScalarStepSelectorEnabled",isScalarStepSelectorRangeEnabled:"isScalarStepSelectorRangeEnabled",isScalarColumnCustomizationEnabled:"isScalarColumnCustomizationEnabled",linkedTimeSelection:"linkedTimeSelection",stepMinMax:"stepMinMax",isSlideOutMenuOpen:"isSlideOutMenuOpen",isImageSupportEnabled:"isImageSupportEnabled",tooltipSort:"tooltipSort",ignoreOutliers:"ignoreOutliers",xAxisType:"xAxisType",cardMinWidth:"cardMinWidth",histogramMode:"histogramMode",scalarSmoothing:"scalarSmoothing",scalarPartitionX:"scalarPartitionX",imageBrightnessInMilli:"imageBrightnessInMilli",imageContrastInMilli:"imageContrastInMilli",imageShowActualSize:"imageShowActualSize"},outputs:{linkedTimeToggled:"linkedTimeToggled",linkedTimeSelectionChanged:"linkedTimeSelectionChanged",stepSelectorToggled:"stepSelectorToggled",rangeSelectionToggled:"rangeSelectionToggled",onSlideOutToggled:"onSlideOutToggled",tooltipSortChanged:"tooltipSortChanged",ignoreOutliersChanged:"ignoreOutliersChanged",xAxisTypeChanged:"xAxisTypeChanged",cardWidthChanged:"cardWidthChanged",cardWidthReset:"cardWidthReset",histogramModeChanged:"histogramModeChanged",scalarSmoothingChanged:"scalarSmoothingChanged",scalarPartitionXToggled:"scalarPartitionXToggled",imageBrightnessInMilliChanged:"imageBrightnessInMilliChanged",imageBrightnessReset:"imageBrightnessReset",imageContrastInMilliChanged:"imageContrastInMilliChanged",imageContrastReset:"imageContrastReset",imageShowActualSizeChanged:"imageShowActualSizeChanged"},decls:43,vars:22,consts:function(){let t,e,i;return t=$localize`:A button to reset the card width setting␟ccdc96b003fbba90db7a6959b5b26e3cc58f7d80␟5223111047968102466:Reset card width`,e=$localize`:A button to reset the image brightness setting␟c482b3a47ea0975fa8be01afb3fbec9b76628bd7␟1189161857240378395:Reset brightness`,i=$localize`:A button to reset the image contrast setting␟ed712a8b927041be15252b29eb521ebb1374bad8␟5370703342923611955:Reset contrast`,[[1,"general"],[1,"section-title"],[1,"control-row","x-axis-type"],["id","x-axis-type-label",1,"control-name"],[3,"value","options","selectionChange"],["class","control-row scalars-step-selector",3,"title",4,"ngIf"],[1,"control-row","card-width"],["id","card-width-label",1,"control-name"],[1,"slider-row"],["aria-labelledby","card-width-label","color","primary",3,"max","min","step","value","thumbLabel","input"],["mat-icon-button","","aria-label",t,"title","Reset card width",1,"reset-button",3,"click"],["svgIcon","settings_backup_restore_24px"],[1,"scalars"],[1,"control-row","scalars-smoothing"],["id","scalars-smoothing-label",1,"control-name"],["aria-labelledby","scalars-smoothing-label","color","primary",3,"max","min","step","value","thumbLabel","input"],["aria-labelledby","scalars-smoothing-label","type","number","min","0","step","0.001",1,"slider-input",3,"max","value","input"],[1,"control-row","tooltip-sort"],[1,"control-name"],[1,"control-row","scalars-ignore-outliers"],[3,"checked","change"],[1,"control-row","scalars-partition-x"],["svgIcon","help_outline_24px","title","Non-monotonic steps can occur when reusing a logdir with multiple summary writers and overlapping steps. Line charts, without this option enabled, can appear zig zagged. This is common when restarting from a checkpoint.\n\nWhen enabled, a non-monotonic time series composed of N monotonic pieces will be shown as N monotonic lines.",1,"info"],[1,"Histograms"],[1,"control-row","histogram-mode"],["class","image",4,"ngIf"],[1,"control-row","scalars-step-selector",3,"title"],[3,"checked","disabled","change"],[1,"indent"],["class","indent range-selection",4,"ngIf"],["class","control-row linked-time indent",4,"ngIf"],["class","column-edit-menu-toggle",3,"click",4,"ngIf"],[1,"indent","range-selection"],[1,"control-row","linked-time","indent"],[1,"column-edit-menu-toggle",3,"click"],["svgIcon","chevron_left_24px",4,"ngIf"],["svgIcon","chevron_right_24px",4,"ngIf"],["svgIcon","chevron_left_24px"],["svgIcon","chevron_right_24px"],[1,"image"],[1,"control-row","image-brightness"],["id","image-brightness-label",1,"control-name"],["aria-labelledby","image-brightness-label","color","primary",3,"max","min","step","value","thumbLabel","displayWith","input"],["mat-icon-button","","aria-label",e,"title","Reset brightness",1,"reset-button",3,"click"],[1,"control-row","image-contrast"],["id","image-constrast-label",1,"control-name"],["aria-labelledby","image-constrast-label","color","primary",3,"max","min","step","value","thumbLabel","displayWith","input"],["mat-icon-button","","aria-label",i,"title","Reset contrast",1,"reset-button",3,"click"],[1,"control-row","image-show-actual-size"]]},template:function(e,i){1&e&&(_(0,"section",0)(1,"h3",1),A(2,"General"),v(),_(3,"div",2)(4,"div",3),A(5,"Horizontal Axis"),v(),_(6,"tb-dropdown",4),P("selectionChange",function(o){return i.xAxisTypeChanged.emit(o)}),v()(),E(7,x5e,8,6,"div",5),_(8,"div",6)(9,"div",7),A(10,"Card Width"),v(),_(11,"div",8)(12,"mat-slider",9),P("input",function(o){return i.cardWidthSliderChanged$.emit(o.value)}),v(),_(13,"button",10),P("click",function(){return i.cardWidthReset.emit()}),O(14,"mat-icon",11),v()()()(),_(15,"section",12)(16,"h3",1),A(17,"Scalars"),v(),_(18,"div",13)(19,"div",14),A(20,"Smoothing"),v(),_(21,"div",8)(22,"mat-slider",15),P("input",function(o){return i.scalarSmoothingControlChanged$.emit(o.value)}),v(),_(23,"input",16),P("input",function(o){return i.onScalarSmoothingInput(o)}),v()()(),_(24,"div",17)(25,"div",18),A(26,"Tooltip sorting method"),v(),_(27,"tb-dropdown",4),P("selectionChange",function(o){return i.tooltipSortChanged.emit(o)}),v()(),_(28,"div",19)(29,"mat-checkbox",20),P("change",function(o){return i.ignoreOutliersChanged.emit(o.checked)}),A(30,"Ignore outliers in chart scaling"),v()(),_(31,"div",21)(32,"mat-checkbox",20),P("change",function(){return i.scalarPartitionXToggled.emit()}),A(33,"Partition non-monotonic X axis"),v(),O(34,"mat-icon",22),v()(),_(35,"section",23)(36,"h3",1),A(37,"Histograms"),v(),_(38,"div",24)(39,"div",18),A(40,"Mode"),v(),_(41,"tb-dropdown",4),P("selectionChange",function(o){return i.histogramModeChanged.emit(o)}),v()()(),E(42,C5e,20,13,"section",25)),2&e&&(C(6),y("value",i.xAxisType)("options",i.XAxisTypeDropdownOptions),C(1),y("ngIf",i.isScalarStepSelectorFeatureEnabled),C(5),y("max",i.MAX_CARD_WIDTH_SLIDER_VALUE)("min",i.MIN_CARD_WIDTH_SLIDER_VALUE)("step",50)("value",i.cardMinWidth)("thumbLabel",!1),C(10),y("max",i.MAX_SMOOTHING_SLIDER_VALUE)("min",0)("step",.01)("value",i.scalarSmoothing)("thumbLabel",!0),C(1),y("max",i.MAX_SMOOTHING_VALUE)("value",i.scalarSmoothing),C(4),y("value",i.tooltipSort)("options",i.TooltipSortDropdownOptions),C(2),y("checked",i.ignoreOutliers),C(3),y("checked",i.scalarPartitionX),C(9),y("value",i.histogramMode)("options",i.HistogramModeDropdownOptions),C(1),y("ngIf",i.isImageSupportEnabled))},dependencies:[Be,Loe,_n,yl,Gt,up],styles:["[_nghost-%COMP%]{color:#616161;font-size:12px}body.dark-mode   [_nghost-%COMP%]{color:rgba(255,255,255,.7)}section[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;padding:16px}body.dark-mode[_nghost-%COMP%]   section[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   section[_ngcontent-%COMP%]{border-bottom:1px solid #555}.section-title[_ngcontent-%COMP%]{color:#212121;text-transform:uppercase;font-weight:500;font-size:13px;line-height:normal;margin:0 0 12px 0}body.dark-mode[_nghost-%COMP%]   .section-title[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .section-title[_ngcontent-%COMP%]{color:#fff}section[_ngcontent-%COMP%]   .control-row[_ngcontent-%COMP%]:not(:last-child){margin-bottom:12px}.control-name[_ngcontent-%COMP%]{margin-bottom:8px}.slider-row[_ngcontent-%COMP%]{display:flex;align-items:center;height:28px}.slider-row[_ngcontent-%COMP%]   .reset-button[_ngcontent-%COMP%]{margin-left:6px}.slider-row[_ngcontent-%COMP%]   .slider-input[_ngcontent-%COMP%]{background-color:inherit;border:1px solid #8e98a3;border-radius:2px;box-sizing:border-box;color:inherit;height:100%;margin-left:12px;padding:0 4px}body.dark-mode[_nghost-%COMP%]   .slider-row[_ngcontent-%COMP%]   .slider-input[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slider-row[_ngcontent-%COMP%]   .slider-input[_ngcontent-%COMP%]{border-color:#425066}.scalars-smoothing[_ngcontent-%COMP%]   .slider-input[_ngcontent-%COMP%]{flex:none;width:5em}.scalars-partition-x[_ngcontent-%COMP%]{align-items:center;display:flex}.scalars-partition-x[_ngcontent-%COMP%]   .info[_ngcontent-%COMP%]{height:15px;margin-left:5px;width:15px}mat-slider[_ngcontent-%COMP%]{flex:1;margin-left:-8px;margin-right:-8px}.column-edit-menu-toggle[_ngcontent-%COMP%]{align-items:center;display:flex;cursor:pointer}.column-edit-menu-toggle[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{height:15px;width:15px}tb-dropdown[_ngcontent-%COMP%]{display:block}.linked-time[_ngcontent-%COMP%]{padding:5px 0}.control-row[_ngcontent-%COMP%]   .indent[_ngcontent-%COMP%]{margin-left:25px}"],changeDetection:0}),n})(),T5e=Object.freeze({SLIDER:cs.SETTINGS_SLIDER,TEXT:cs.SETTINGS_TEXT,TEXT_DELETED:cs.CHANGE_TO_SINGLE}),Hoe=(()=>{class n{constructor(e){this.store=e,this.isLinkedTimeFeatureEnabled$=this.store.select(M$),this.isRangeSelectionAllowed$=this.store.select(T$),this.isScalarStepSelectorFeatureEnabled$=this.store.select(S$),this.isScalarStepSelectorEnabled$=this.store.select(fv),this.isScalarStepSelectorRangeEnabled$=this.store.select(mv),this.isLinkedTimeEnabled$=this.store.select(Ym),this.isScalarColumnCustomizationEnabled$=this.store.select(qA),this.linkedTimeSelection$=this.store.select(iH),this.stepMinMax$=this.store.select(nH),this.isSlideOutMenuOpen$=this.store.select(UI),this.isImageSupportEnabled$=this.store.select(gh).pipe(Ye(Boolean),Qt(1),Wt(this.store.select(WA)),L(([,i])=>i)),this.tooltipSort$=this.store.select(pv),this.ignoreOutliers$=this.store.select(hv),this.xAxisType$=this.store.select(td),this.cardMinWidth$=this.store.select(dv),this.histogramMode$=this.store.select(RI),this.scalarSmoothing$=this.store.select(op),this.scalarPartitionX$=this.store.select(OI),this.imageBrightnessInMilli$=this.store.select(kI),this.imageContrastInMilli$=this.store.select(FI),this.imageShowActualSize$=this.store.select(NI)}onTooltipSortChanged(e){this.store.dispatch(jP({sort:e}))}onIgnoreOutliersChanged(){this.store.dispatch(GP())}onXAxisTypeChanged(e){this.store.dispatch(WP({xAxisType:e}))}onCardWidthChanged(e){this.store.dispatch(qP({cardMinWidth:e}))}onCardWidthReset(){this.store.dispatch(YP())}onHistogramModeChanged(e){this.store.dispatch(tR({histogramMode:e}))}onScalarSmoothingChanged(e){this.store.dispatch(XP({smoothing:e}))}onScalarPartitionXToggled(){this.store.dispatch(QP())}onImageBrightnessInMilliChanged(e){this.store.dispatch(KP({brightnessInMilli:e}))}onImageBrightnessReset(){this.store.dispatch(JP())}onImageContrastReset(){this.store.dispatch($P())}onImageContrastInMilliChanged(e){this.store.dispatch(ZP({contrastInMilli:e}))}onImageShowActualSizeChanged(){this.store.dispatch(eR())}onLinkedTimeToggled(){this.store.dispatch(uR({affordance:bl.CHECK_BOX}))}onStepSelectorToggled(){this.store.dispatch(Xh({affordance:bl.CHECK_BOX}))}onRangeSelectionToggled(){this.store.dispatch(hR({affordance:bl.CHECK_BOX}))}onLinkedTimeSelectionChanged({timeSelection:e,source:i}){this.store.dispatch(Yh({timeSelection:e,affordance:T5e[i]}))}onSlideOutToggled(){this.store.dispatch(VP())}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["metrics-dashboard-settings"]],decls:22,vars:63,consts:[[3,"isImageSupportEnabled","tooltipSort","ignoreOutliers","xAxisType","cardMinWidth","histogramMode","scalarSmoothing","scalarPartitionX","imageBrightnessInMilli","imageContrastInMilli","imageShowActualSize","isLinkedTimeFeatureEnabled","isRangeSelectionAllowed","isScalarStepSelectorFeatureEnabled","isScalarStepSelectorEnabled","isScalarStepSelectorRangeEnabled","isLinkedTimeEnabled","isScalarColumnCustomizationEnabled","linkedTimeSelection","stepMinMax","isSlideOutMenuOpen","tooltipSortChanged","ignoreOutliersChanged","xAxisTypeChanged","cardWidthChanged","cardWidthReset","histogramModeChanged","scalarSmoothingChanged","scalarPartitionXToggled","imageBrightnessInMilliChanged","imageBrightnessReset","imageContrastInMilliChanged","imageContrastReset","imageShowActualSizeChanged","linkedTimeToggled","linkedTimeSelectionChanged","stepSelectorToggled","rangeSelectionToggled","onSlideOutToggled"]],template:function(e,i){1&e&&(_(0,"metrics-dashboard-settings-component",0),P("tooltipSortChanged",function(o){return i.onTooltipSortChanged(o)})("ignoreOutliersChanged",function(){return i.onIgnoreOutliersChanged()})("xAxisTypeChanged",function(o){return i.onXAxisTypeChanged(o)})("cardWidthChanged",function(o){return i.onCardWidthChanged(o)})("cardWidthReset",function(){return i.onCardWidthReset()})("histogramModeChanged",function(o){return i.onHistogramModeChanged(o)})("scalarSmoothingChanged",function(o){return i.onScalarSmoothingChanged(o)})("scalarPartitionXToggled",function(){return i.onScalarPartitionXToggled()})("imageBrightnessInMilliChanged",function(o){return i.onImageBrightnessInMilliChanged(o)})("imageBrightnessReset",function(){return i.onImageBrightnessReset()})("imageContrastInMilliChanged",function(o){return i.onImageContrastInMilliChanged(o)})("imageContrastReset",function(){return i.onImageContrastReset()})("imageShowActualSizeChanged",function(){return i.onImageShowActualSizeChanged()})("linkedTimeToggled",function(){return i.onLinkedTimeToggled()})("linkedTimeSelectionChanged",function(o){return i.onLinkedTimeSelectionChanged(o)})("stepSelectorToggled",function(){return i.onStepSelectorToggled()})("rangeSelectionToggled",function(){return i.onRangeSelectionToggled()})("onSlideOutToggled",function(){return i.onSlideOutToggled()}),B(1,"async"),B(2,"async"),B(3,"async"),B(4,"async"),B(5,"async"),B(6,"async"),B(7,"async"),B(8,"async"),B(9,"async"),B(10,"async"),B(11,"async"),B(12,"async"),B(13,"async"),B(14,"async"),B(15,"async"),B(16,"async"),B(17,"async"),B(18,"async"),B(19,"async"),B(20,"async"),B(21,"async"),v()),2&e&&y("isImageSupportEnabled",U(1,21,i.isImageSupportEnabled$))("tooltipSort",U(2,23,i.tooltipSort$))("ignoreOutliers",U(3,25,i.ignoreOutliers$))("xAxisType",U(4,27,i.xAxisType$))("cardMinWidth",U(5,29,i.cardMinWidth$))("histogramMode",U(6,31,i.histogramMode$))("scalarSmoothing",U(7,33,i.scalarSmoothing$))("scalarPartitionX",U(8,35,i.scalarPartitionX$))("imageBrightnessInMilli",U(9,37,i.imageBrightnessInMilli$))("imageContrastInMilli",U(10,39,i.imageContrastInMilli$))("imageShowActualSize",U(11,41,i.imageShowActualSize$))("isLinkedTimeFeatureEnabled",U(12,43,i.isLinkedTimeFeatureEnabled$))("isRangeSelectionAllowed",U(13,45,i.isRangeSelectionAllowed$))("isScalarStepSelectorFeatureEnabled",U(14,47,i.isScalarStepSelectorFeatureEnabled$))("isScalarStepSelectorEnabled",U(15,49,i.isScalarStepSelectorEnabled$))("isScalarStepSelectorRangeEnabled",U(16,51,i.isScalarStepSelectorRangeEnabled$))("isLinkedTimeEnabled",U(17,53,i.isLinkedTimeEnabled$))("isScalarColumnCustomizationEnabled",U(18,55,i.isScalarColumnCustomizationEnabled$))("linkedTimeSelection",U(19,57,i.linkedTimeSelection$))("stepMinMax",U(20,59,i.stepMinMax$))("isSlideOutMenuOpen",U(21,61,i.isSlideOutMenuOpen$))},dependencies:[Voe,Ge],encapsulation:2,changeDetection:0}),n})(),Uoe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["metrics-dashboard-right-pane"]],decls:1,vars:0,template:function(e,i){1&e&&O(0,"metrics-dashboard-settings")},dependencies:[Hoe],encapsulation:2,changeDetection:0}),n})();function I5e(n,t){1&n&&O(0,"mat-icon",3)}function P5e(n,t){1&n&&O(0,"mat-icon",3)}function R5e(n,t){1&n&&O(0,"div",4)}var vR=(()=>{class n{constructor(){this.ColumnHeaderType=Kt}getHeaderTextColumn(e){switch(e){case Kt.RUN:return"Run";case Kt.VALUE:return"Value";case Kt.STEP:return"Step";case Kt.TIME:return"Time";case Kt.RELATIVE_TIME:return"Relative";case Kt.SMOOTHED:return"Smoothed";case Kt.VALUE_CHANGE:return"Value";case Kt.START_STEP:return"Start Step";case Kt.END_STEP:return"End Step";case Kt.START_VALUE:return"Start Value";case Kt.END_VALUE:return"End Value";case Kt.MIN_VALUE:return"Min";case Kt.MAX_VALUE:return"Max";case Kt.PERCENTAGE_CHANGE:return"%";default:return""}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["tb-data-table-header"]],inputs:{header:"header"},decls:6,vars:4,consts:[[1,"header-container",3,"ngSwitch"],["svgIcon","change_history_24px",4,"ngSwitchCase"],["class","extra-right-padding",4,"ngSwitchDefault"],["svgIcon","change_history_24px"],[1,"extra-right-padding"]],template:function(e,i){1&e&&(_(0,"div",0),E(1,I5e,1,0,"mat-icon",1),E(2,P5e,1,0,"mat-icon",1),E(3,R5e,1,0,"div",2),_(4,"span"),A(5),v()()),2&e&&(y("ngSwitch",i.header.type),C(1),y("ngSwitchCase",i.ColumnHeaderType.VALUE_CHANGE),C(1),y("ngSwitchCase",i.ColumnHeaderType.PERCENTAGE_CHANGE),C(3),yt(i.getHeaderTextColumn(i.header.type)))},dependencies:[Cr,Ur,ch,Gt],styles:[".header-container[_ngcontent-%COMP%]{align-items:center;display:flex}.extra-right-padding[_ngcontent-%COMP%]{padding-right:1px}mat-icon[_ngcontent-%COMP%]{height:12px;width:12px}"],changeDetection:0}),n})();function O5e(n,t){if(1&n){let e=Pe();_(0,"div",6)(1,"mat-checkbox",7),P("change",function(){let o=oe(e).$implicit,s=S().dataTableMode;return se(S().toggleHeader(o,s))}),O(2,"tb-data-table-header",8),v()()}if(2&n){let e=t.$implicit;C(1),y("checked",e.enabled),C(1),y("header",e)}}function k5e(n,t){if(1&n&&(_(0,"div",4),E(1,O5e,3,2,"div",5),v()),2&n){let e=t.headers;C(1),y("ngForOf",e)}}var joe=function(n,t){return{headers:n,dataTableMode:t}},Goe=(()=>{class n{constructor(){this.DataTableMode=gd,this.selectedTab=gd.SINGLE,this.onScalarTableColumnToggled=new G}toggleHeader(e,i){this.onScalarTableColumnToggled.emit({dataTableMode:i,headerType:e.type})}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["metrics-scalar-column-editor-component"]],inputs:{rangeHeaders:"rangeHeaders",singleHeaders:"singleHeaders"},outputs:{onScalarTableColumnToggled:"onScalarTableColumnToggled"},decls:8,vars:12,consts:[[1,"tab-group"],[3,"label"],[3,"ngTemplateOutlet","ngTemplateOutletContext"],["headerList",""],[1,"header-list"],["class","header-list-item",4,"ngFor","ngForOf"],[1,"header-list-item"],[3,"checked","change"],[3,"header"]],template:function(e,i){if(1&e&&(_(0,"div")(1,"mat-tab-group",0)(2,"mat-tab",1),O(3,"ngContext",2),v(),_(4,"mat-tab",1),O(5,"ngContext",2),v()()(),E(6,k5e,2,1,"ng-template",null,3,qt)),2&e){let r=$e(7);C(2),y("label","Single"),C(1),y("ngTemplateOutlet",r)("ngTemplateOutletContext",Qr(6,joe,i.singleHeaders,i.DataTableMode.SINGLE)),C(1),y("label","Range"),C(1),y("ngTemplateOutlet",r)("ngTemplateOutletContext",Qr(9,joe,i.rangeHeaders,i.DataTableMode.RANGE))}},dependencies:[dn,os,vR,yl,Z2,xw],styles:["[_nghost-%COMP%]     .mat-tab-label{min-width:0}.tab-group[_ngcontent-%COMP%]{position:relative;z-index:0}.header-list[_ngcontent-%COMP%]{margin-top:5%;margin-left:5%}.header-list-item[_ngcontent-%COMP%]{padding:3px}"],changeDetection:0}),n})(),Woe=(()=>{class n{constructor(e){this.store=e,this.singleHeaders$=this.store.select(BI),this.rangeHeaders$=this.store.select(VI)}onScalarTableColumnToggled({dataTableMode:e,headerType:i}){this.store.dispatch(pR({dataTableMode:e,headerType:i}))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["metrics-scalar-column-editor"]],decls:3,vars:6,consts:[[3,"singleHeaders","rangeHeaders","onScalarTableColumnToggled"]],template:function(e,i){1&e&&(_(0,"metrics-scalar-column-editor-component",0),P("onScalarTableColumnToggled",function(o){return i.onScalarTableColumnToggled(o)}),B(1,"async"),B(2,"async"),v()),2&e&&y("singleHeaders",U(1,2,i.singleHeaders$))("rangeHeaders",U(2,4,i.rangeHeaders$))},dependencies:[Goe,Ge],encapsulation:2,changeDetection:0}),n})(),L5e=J(PI,oo,(n,t)=>n.filter(e=>!ml(e.plugin)||Boolean(t&&t.get(e.runId)))),mg=J(L5e,n=>n.sort((t,e)=>Fw(t.tag,e.tag))),ay=(()=>{class n{constructor(e,i){this.ref=e,this.cdkScrollable=i,this.onVisibilityChange=new G,this.ngUnsubscribe$=new ke,this.onEvent$=new ke}ngOnInit(){let e={root:this.cdkScrollable?this.cdkScrollable.getElementRef().nativeElement:null};this.intersectionObserverMargin&&(e.rootMargin=this.intersectionObserverMargin);let i=new IntersectionObserver(r=>{this.onEvent$.next(r)},e);i.observe(this.ref.nativeElement),this.ngUnsubscribe$.subscribe(()=>{i.unobserve(this.ref.nativeElement)}),this.onEvent$.pipe(st(this.ngUnsubscribe$)).subscribe(r=>{let o=r.slice(-1)[0];this.onVisibilityChange.emit({visible:o.isIntersecting})})}ngOnDestroy(){this.ngUnsubscribe$.next(),this.ngUnsubscribe$.complete()}waitForEventForTestOnly(){return new Promise(e=>this.onEvent$.pipe(Qt(1)).subscribe(()=>{e()}))}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(Ih,8))},n.\u0275dir=He({type:n,selectors:[["","observeIntersection",""]],inputs:{intersectionObserverMargin:"intersectionObserverMargin"},outputs:{onVisibilityChange:"onVisibilityChange"}}),n})(),qoe="/scalar_summary";function ly(n,t){let e=n;return t&&n.startsWith(t+"/")&&(e=n.slice(t.length+1)),e.endsWith(qoe)&&(e=e.slice(0,-qoe.length)),e||n}function Yoe(n,t,e){return n<t?t:n>e?e:n}function Qh(n,t,e){let i=Yoe(n.start.step,t,e),r=n.end?Yoe(n.end.step,t,e):null;return{startStep:i,endStep:r,clipped:i!==n.start.step||r!==(n.end?.step??null)}}var V5e=["measurer"],H5e=["input"],Joe=(()=>{class n{constructor(e){this.changeDetector=e,this.placeholder="",this.style="default",this.patternRegex=new RegExp(".*"),this.isValid=!0,this.onValueChange=new G,this.blur=new G,this.focus=new G,this.keydown=new G,this.keyup=new G,this.internalValue="",this.fontChangeListener=this.updateInputWidth.bind(this)}ngOnInit(){document.fonts&&document.fonts.addEventListener("loadingdone",this.fontChangeListener)}ngOnDestroy(){document.fonts&&document.fonts.removeEventListener("loadingdone",this.fontChangeListener)}ngOnChanges(e){e.pattern&&(this.patternRegex=new RegExp(this.pattern??"")),e.value&&(this.internalValue=this.value),this.isValid=this.patternRegex.test(this.internalValue)}ngAfterViewChecked(){this.updateInputWidth()}onInput(e){let i=this.internalValue;this.internalValue=this.inputElRef.nativeElement.value,this.internalValue!==i&&(this.isValid=this.patternRegex.test(this.internalValue),this.changeDetector.markForCheck()),this.onValueChange.emit({value:this.internalValue})}updateInputWidth(){let{width:e}=this.measurerElRef.nativeElement.getBoundingClientRect();this.inputElRef.nativeElement.style.width=`${e}px`}}return n.\u0275fac=function(e){return new(e||n)(M(nn))},n.\u0275cmp=R({type:n,selectors:[["content-wrapping-input"]],viewQuery:function(e,i){if(1&e&&(ot(V5e,7,Re),ot(H5e,7,Re)),2&e){let r;Ne(r=Le())&&(i.measurerElRef=r.first),Ne(r=Le())&&(i.inputElRef=r.first)}},hostVars:2,hostBindings:function(e,i){2&e&&Da(i.style)},inputs:{value:"value",placeholder:"placeholder",style:"style",pattern:"pattern"},outputs:{onValueChange:"onValueChange",blur:"blur",focus:"focus",keydown:"keydown",keyup:"keyup"},features:[Ft],decls:6,vars:7,consts:[["aria-hidden","true",1,"measurer"],["measurer",""],["autocomplete","off","spellcheck","false","type","text",3,"value","placeholder","blur","focus","input","keydown","keyup"],["input",""]],template:function(e,i){1&e&&(_(0,"span")(1,"span",0,1),A(3),v(),_(4,"input",2,3),P("blur",function(o){return i.blur.emit(o)})("focus",function(o){return i.focus.emit(o)})("input",function(o){return i.onInput(o)})("keydown",function(o){return i.keydown.emit(o)})("keyup",function(o){return i.keyup.emit(o)}),v()()),2&e&&(et("container",!0)("is-valid",i.isValid),C(3),yt(i.internalValue||i.placeholder),C(1),y("value",i.value)("placeholder",i.placeholder))},styles:["[_nghost-%COMP%]{display:inline-flex;width:max-content}[_nghost-%COMP%]:focus-within   .container[_ngcontent-%COMP%]{border-color:#f57c00}.default[_nghost-%COMP%]:hover   .container[_ngcontent-%COMP%]{border-color:#ebebeb}.error[_nghost-%COMP%]   .container[_ngcontent-%COMP%], [_nghost-%COMP%]   .container[_ngcontent-%COMP%]:not(.is-valid){border-color:#ef9a9a}.error[_nghost-%COMP%]   .container[_ngcontent-%COMP%]:hover, .error[_nghost-%COMP%]   .container[_ngcontent-%COMP%]:focus-within, [_nghost-%COMP%]   .container[_ngcontent-%COMP%]:not(.is-valid):hover, [_nghost-%COMP%]   .container[_ngcontent-%COMP%]:not(.is-valid):focus-within{border-color:#ef9a9a}.high-contrast[_nghost-%COMP%]   .container[_ngcontent-%COMP%]{border-color:#bdbdbd}.high-contrast[_nghost-%COMP%]   .container[_ngcontent-%COMP%]:hover{border-color:#757575}.container[_ngcontent-%COMP%]{border-radius:4px;border:2px solid rgba(0,0,0,0);padding:1px 2px;position:relative}.measurer[_ngcontent-%COMP%]{pointer-events:none;position:absolute;visibility:hidden}.measurer[_ngcontent-%COMP%], input[_ngcontent-%COMP%]{font-family:inherit;font-size:inherit;line-height:1.4;padding:0;white-space:pre}.measurer[_ngcontent-%COMP%]:empty, input[_ngcontent-%COMP%]:empty{width:2ch}input[_ngcontent-%COMP%]{appearance:none;background-color:inherit;border:0;color:inherit;display:inline-block;font-family:inherit;outline:0}input[_ngcontent-%COMP%]:focus{padding-right:1ch}"],changeDetection:0}),n})();function z5e(n,t){if(1&n){let e=Pe();_(0,"content-wrapping-input",3),P("onValueChange",function(r){return oe(e),se(S().aliasChanged.emit(r))}),v()}if(2&n){let e=S();jl(e.isAliasNameLegal?"high-contrast":"error"),y("value",e.alias.aliasText)}}function j5e(n,t){if(1&n&&(_(0,"span",4),A(1),v()),2&n){let e=S();et("illegal",!e.isAliasNameLegal),y("title",e.title),C(1),yt(e.alias.aliasText)}}var cy=(()=>{class n{constructor(){this.isAliasNameLegal=!0,this.aliasChanged=new G}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["tb-experiment-alias"]],inputs:{alias:"alias",aliasEditable:"aliasEditable",title:"title",isAliasNameLegal:"isAliasNameLegal"},outputs:{aliasChanged:"aliasChanged"},decls:5,vars:3,consts:[[1,"alias-number"],["placeholder","Alias for experiment",3,"style","value","onValueChange",4,"ngIf","ngIfElse"],["noEditAliasName",""],["placeholder","Alias for experiment",3,"value","onValueChange"],[3,"title"]],template:function(e,i){if(1&e&&(_(0,"span",0),A(1),v(),E(2,z5e,1,3,"content-wrapping-input",1),E(3,j5e,2,4,"ng-template",null,2,qt)),2&e){let r=$e(4);C(1),yt(i.alias.aliasNumber),C(1),y("ngIf",i.aliasEditable)("ngIfElse",r)}},dependencies:[Be,Joe],styles:[".alias-number[_ngcontent-%COMP%]{background-color:#e0e0e0;border:1px solid #ebebeb;color:#212121;border-radius:2px;margin-right:2px;padding:0 2px}body.dark-mode[_nghost-%COMP%]   .alias-number[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .alias-number[_ngcontent-%COMP%]{background-color:#616161}body.dark-mode[_nghost-%COMP%]   .alias-number[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .alias-number[_ngcontent-%COMP%]{border:1px solid #555}body.dark-mode[_nghost-%COMP%]   .alias-number[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .alias-number[_ngcontent-%COMP%]{color:#fff}[_nghost-%COMP%]{display:inline-flex;align-items:baseline}"]}),n})();function G5e(n,t){1&n&&O(0,"tb-experiment-alias",2),2&n&&y("alias",S().experimentAlias)}function W5e(n,t){1&n&&(_(0,"span"),A(1,"/"),v())}var $oe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["card-run-name-component"]],inputs:{name:"name",experimentAlias:"experimentAlias"},decls:4,vars:3,consts:[[3,"alias",4,"ngIf"],[4,"ngIf"],[3,"alias"]],template:function(e,i){1&e&&(E(0,G5e,1,1,"tb-experiment-alias",0),E(1,W5e,2,0,"span",1),_(2,"span"),A(3),v()),2&e&&(y("ngIf",null!=i.experimentAlias),C(1),y("ngIf",null!=i.experimentAlias),C(2),yt(i.name))},dependencies:[Be,cy],styles:["[_nghost-%COMP%]{color:#616161}body.dark-mode   [_nghost-%COMP%]{color:rgba(255,255,255,.7)}"],changeDetection:0}),n})(),yR=(()=>{class n{constructor(e){this.store=e}ngOnInit(){this.name$=Lt([this.store.select(WI,{runId:this.runId})]).pipe(L(([e])=>function(n,t,e){if(!t)return n;let i=t?.name??"...";return i}(this.runId,e))),this.experimentAlias$=Lt([this.store.select(GI,{runId:this.runId}),this.store.select(Yu)]).pipe(L(([e,i])=>e?i[e]:null))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["card-run-name"]],inputs:{runId:"runId"},decls:4,vars:9,consts:[[3,"name","experimentAlias"]],template:function(e,i){1&e&&(O(0,"card-run-name-component",0),B(1,"async"),B(2,"async"),B(3,"async")),2&e&&(y("name",U(1,3,i.name$))("experimentAlias",U(3,7,i.experimentAlias$)),ze("title",U(2,5,i.name$)))},dependencies:[$oe,Ge],encapsulation:2,changeDetection:0}),n})();function Y5e(n,t){if(1&n&&(_(0,"span",2),A(1),v()),2&n){let e=S();C(1),yt(e.firstTextPart())}}var uy=(()=>{class n{parseValue(){let e=this.value.lastIndexOf("/");return-1===e?{first:"",second:this.value}:{first:this.value.slice(0,e),second:this.value.slice(e)}}firstTextPart(){return this.parseValue().first}secondTextPart(){return this.parseValue().second}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["tb-truncated-path"]],inputs:{value:"value"},decls:3,vars:2,consts:[["class","first-text-part",4,"ngIf"],[1,"second-text-part"],[1,"first-text-part"]],template:function(e,i){1&e&&(E(0,Y5e,2,1,"span",0),_(1,"span",1),A(2),v()),2&e&&(y("ngIf",i.firstTextPart().length>0),C(2),yt(i.secondTextPart()))},dependencies:[Be],styles:["[_nghost-%COMP%]{display:inline-flex;white-space:nowrap}.first-text-part[_ngcontent-%COMP%]{flex:1 1 4ch;max-width:max-content}.first-text-part[_ngcontent-%COMP%], .second-text-part[_ngcontent-%COMP%]{overflow:hidden;text-overflow:ellipsis}"]}),n})();function X5e(n,t){1&n&&O(0,"mat-icon",2)}function Q5e(n,t){1&n&&O(0,"mat-icon",3)}var dy=(()=>{class n{constructor(){this.isClipped=!1,this.isClosestStepHighlighted=!1}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["vis-linked-time-selection-warning"]],inputs:{isClipped:"isClipped",isClosestStepHighlighted:"isClosestStepHighlighted"},decls:2,vars:2,consts:[["data-value","clipped","svgIcon","info_outline_24px","title","Linked step is not found in this visualization. We highlighted the closest step for you.",4,"ngIf"],["data-value","closestStepHighlighted","svgIcon","info_outline_24px","title","Data is not found on selected step. We highlighted the closest step for you.",4,"ngIf"],["data-value","clipped","svgIcon","info_outline_24px","title","Linked step is not found in this visualization. We highlighted the closest step for you."],["data-value","closestStepHighlighted","svgIcon","info_outline_24px","title","Data is not found on selected step. We highlighted the closest step for you."]],template:function(e,i){1&e&&(E(0,X5e,1,0,"mat-icon",0),E(1,Q5e,1,0,"mat-icon",1)),2&e&&(y("ngIf",i.isClipped),C(1),y("ngIf",i.isClosestStepHighlighted))},dependencies:[Be,Gt],styles:["[_nghost-%COMP%]{color:#d32f2f;height:1em;line-height:0;display:inline-flex}body.dark-mode   [_nghost-%COMP%]{color:#d32f2f}[_nghost-%COMP%]   mat-icon[_ngcontent-%COMP%]{height:100%;width:100%}"],changeDetection:0}),n})();function K5e(n,t){if(1&n&&(_(0,"span",19),A(1),B(2,"number"),v()),2&n){let e=S();C(1),je("Step ",U(2,1,e.steps[e.stepIndex]),"")}}function Z5e(n,t){if(1&n&&(_(0,"span",20),A(1),B(2,"number"),B(3,"number"),v()),2&n){let e=S();C(1),Xp("Sample ",U(2,2,e.sample+1),"/",U(3,4,e.numSample),"")}}function J5e(n,t){1&n&&O(0,"mat-spinner",21)}function $5e(n,t){if(1&n&&(_(0,"span"),O(1,"span",30)(2,"span",31),v()),2&n){let e=S(3);C(2),Pt("left",e.sliderStartPosition)("width",e.sliderTrackWidth)}}function e4e(n,t){if(1&n&&O(0,"div",32),2&n){let e=t.$implicit,i=S(3);Pt("left",i.getLinkedTimeTickLeftStyle(e))("margin-left",i.getLinkedTimeTickMarginLeftStyle(e))}}function t4e(n,t){if(1&n&&(_(0,"div",27),E(1,$5e,3,4,"span",28),E(2,e4e,1,4,"div",29),v()),2&n){let e=S(2);C(1),y("ngIf",null!==e.linkedTimeSelection.endStep),C(1),y("ngForOf",e.selectedSteps)}}var n4e=function(n){return[n]},i4e=function(n){return{filter:n}};function r4e(n,t){if(1&n){let e=Pe();sn(0),_(1,"div",22)(2,"mat-slider",23),P("input",function(r){return oe(e),se(S().onSliderInput(r))}),v(),E(3,t4e,3,2,"div",24),v(),_(4,"div",25),O(5,"img",26),v(),an()}if(2&n){let e=S();C(2),y("ngClass",On(11,n4e,e.linkedTimeSelection&&null!==e.linkedTimeSelection.endStep?"hide-slider":""))("disabled",e.steps.length<=1)("min",0)("max",e.steps.length-1)("step",1)("tickInterval",1)("value",e.stepIndex),C(1),y("ngIf",e.linkedTimeSelection),C(2),Xx("alt","Image at step ",e.steps[e.stepIndex],""),Zi("src",e.imageUrl,zl),y("ngStyle",On(13,i4e,e.cssFilter()))}}function o4e(n,t){1&n&&(_(0,"div",34),A(1," Data failed to load. "),v())}function s4e(n,t){if(1&n&&E(0,o4e,2,0,"div",33),2&n){let e=S();y("ngIf",e.loadState===e.DataLoadState.FAILED)}}var a4e=function(n){return{backgroundColor:n}},tse=(()=>{class n{constructor(){this.DataLoadState=Oe,this.sliderStartPosition="",this.sliderTrackWidth="",this.linkedTimeSelection=null,this.isClosestStepHighlighted=!1,this.onActualSizeToggle=new G,this.stepIndexChange=new G,this.onPinClicked=new G}cssFilter(){return`contrast(${this.contrastInMilli/10}%) brightness(${this.brightnessInMilli/1e3})`}onSliderInput(e){this.stepIndexChange.emit(e.value)}changeDistinct(e){return e.currentValue!==e.previousValue}ngOnChanges(e){(e.selectedSteps&&this.changeDistinct(e.selectedSteps)||e.linkedTimeSelection&&this.changeDistinct(e.linkedTimeSelection))&&this.renderRangeSlider()}renderRangeSlider(){if(!this.linkedTimeSelection||!this.linkedTimeSelection.endStep)return;let e=this.steps.length-1,i=this.linkedTimeSelection.startStep<this.steps[0]?this.steps[0]:this.linkedTimeSelection.startStep,r=this.linkedTimeSelection.endStep>this.steps[e]?this.steps[e]:this.linkedTimeSelection.endStep,{startPosition:o,width:s}=this.getTrackStartPositionAndWidth(i,r,e);this.sliderStartPosition=100*o+"%",this.sliderTrackWidth=100*s+"%"}getTrackStartPositionAndWidth(e,i,r){let o=1/r,s=0,a=0,l=0;for(;l<this.steps.length-1;l++){let c=this.steps[l],u=this.steps[l+1];if(c<=e&&e<=u){s+=(e-c)/(u-c);break}}for(s=(s+l)*o;l<this.steps.length-1;l++){let c=this.steps[l],u=this.steps[l+1];if(e>=c&&i<=u){a=(i-e)/(u-c);break}if(e>=c&&i>=u)a+=(u-e)/(u-c);else{if(!(i>=u)){a+=(i-c)/(u-c);break}a+=1}}return a*=o,(s>1||s<0)&&(s=0),{startPosition:s,width:a}}getLinkedTimeTickLeftStyle(e){if(-1==this.steps.indexOf(e))throw new Error("Invalid stepIndex: stepIndex value is not included in steps");return this.steps.indexOf(e)/(this.steps.length-1)*100+"%"}getLinkedTimeTickMarginLeftStyle(e){if(-1==this.steps.indexOf(e))throw new Error("Invalid stepIndex: stepIndex value is not included in steps");return`-${this.steps.indexOf(e)/(this.steps.length-1)*14}px`}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["image-card-component"]],hostVars:2,hostBindings:function(e,i){2&e&&et("actual-size",i.showActualSize)},inputs:{loadState:"loadState",title:"title",tag:"tag",runId:"runId",sample:"sample",numSample:"numSample",imageUrl:"imageUrl",stepIndex:"stepIndex",steps:"steps",brightnessInMilli:"brightnessInMilli",contrastInMilli:"contrastInMilli",showActualSize:"showActualSize",runColorScale:"runColorScale",allowToggleActualSize:"allowToggleActualSize",isPinned:"isPinned",selectedSteps:"selectedSteps",linkedTimeSelection:"linkedTimeSelection",isClosestStepHighlighted:"isClosestStepHighlighted"},outputs:{onActualSizeToggle:"onActualSizeToggle",stepIndexChange:"stepIndexChange",onPinClicked:"onPinClicked"},features:[Ft],decls:21,vars:16,consts:function(){let t,e;return t=$localize`:A button to pin a card.␟e665dc712bd5f18d4dfa3a29e125d565cc51e2f6␟7284606426234375344:Pin card`,e=$localize`:A button on an image card that toggles actual image size.␟3ca05ef3a6e3a37065f5e0f69c5d5a2178d90791␟7635101936664789140:Toggle actual image size`,[[1,"heading"],[1,"line"],[1,"tag"],[1,"tag-path",3,"title","value"],[3,"isClipped","isClosestStepHighlighted"],[1,"controls"],["mat-icon-button","","aria-label",t,1,"pin-button",3,"click"],[3,"svgIcon"],["mat-icon-button","","aria-label",e,"title","Toggle actual image size",3,"disabled","click"],["svgIcon","image_search_24px"],[1,"run"],[1,"dot",3,"ngStyle"],[1,"run-text",3,"runId"],[1,"metadata"],["class","step",4,"ngIf"],["class","sample",4,"ngIf"],["class","loading","diameter","18",4,"ngIf"],[4,"ngIf","ngIfElse"],["noImageData",""],[1,"step"],[1,"sample"],["diameter","18",1,"loading"],[1,"slider-row"],["color","primary",1,"step-slider",3,"ngClass","disabled","min","max","step","tickInterval","value","input"],["class","linked-time-wrapper",4,"ngIf"],[1,"img-container"],[3,"alt","src","ngStyle"],[1,"linked-time-wrapper"],[4,"ngIf"],["class","linked-time-tick",3,"left","margin-left",4,"ngFor","ngForOf"],[1,"slider-track"],[1,"slider-track-fill"],[1,"linked-time-tick"],["class","empty-message",4,"ngIf"],[1,"empty-message"]]},template:function(e,i){if(1&e&&(_(0,"div",0)(1,"div",1)(2,"span",2),O(3,"tb-truncated-path",3)(4,"vis-linked-time-selection-warning",4),v(),_(5,"span",5)(6,"button",6),P("click",function(){return i.onPinClicked.emit(!i.isPinned)}),O(7,"mat-icon",7),v(),_(8,"button",8),P("click",function(){return i.onActualSizeToggle.emit()}),O(9,"mat-icon",9),v()()(),_(10,"div",1)(11,"span",10),O(12,"span",11)(13,"card-run-name",12),v(),_(14,"div",13),E(15,K5e,3,3,"span",14),E(16,Z5e,4,6,"span",15),E(17,J5e,1,0,"mat-spinner",16),v()()(),E(18,r4e,6,15,"ng-container",17),E(19,s4e,1,1,"ng-template",null,18,qt)),2&e){let r=$e(20);C(3),Zi("title",i.tag),Zi("value",i.title),C(1),y("isClipped",i.linkedTimeSelection&&i.linkedTimeSelection.clipped)("isClosestStepHighlighted",i.isClosestStepHighlighted),C(2),ze("title",i.isPinned?"Unpin card":"Pin card"),C(1),y("svgIcon",i.isPinned?"keep_24px":"keep_outline_24px"),C(1),y("disabled",!i.allowToggleActualSize),C(4),y("ngStyle",On(14,a4e,i.runColorScale(i.runId))),C(1),y("runId",i.runId),C(2),y("ngIf",null!==i.stepIndex&&i.stepIndex<i.steps.length),C(1),y("ngIf",i.numSample>1),C(1),y("ngIf",i.loadState===i.DataLoadState.LOADING),C(1),y("ngIf",null!==i.stepIndex&&i.stepIndex<i.steps.length)("ngIfElse",r)}},dependencies:[Fn,dn,Be,zu,_n,Gt,Bo,up,yR,uy,dy,Ql],styles:["[_nghost-%COMP%]{box-sizing:border-box;display:flex;flex-basis:318px;flex-direction:column;flex-grow:1;height:100%;overflow:auto;padding:16px;padding-top:4px}.actual-size[_nghost-%COMP%]{height:auto}.heading[_ngcontent-%COMP%]{align-items:center;font-size:14px;margin-bottom:4px;position:relative}.line[_ngcontent-%COMP%]{align-items:center;display:grid;grid-template-columns:1fr max-content}.tag[_ngcontent-%COMP%]{align-items:center;display:flex;gap:5px}.metadata[_ngcontent-%COMP%]{display:flex;flex-wrap:wrap;gap:5px;justify-content:flex-end;max-width:175px;text-align:end}.tag-path[_ngcontent-%COMP%]{overflow:hidden}.pin-button[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{height:18px}.run[_ngcontent-%COMP%]{align-self:baseline;display:flex;overflow:hidden;white-space:nowrap}.run[_ngcontent-%COMP%]   .dot[_ngcontent-%COMP%]{flex:none;display:inline-block;width:13px;height:13px;border-radius:50%;margin-right:4px}.run[_ngcontent-%COMP%]   .run-text[_ngcontent-%COMP%]{overflow:hidden;text-overflow:ellipsis;max-width:120px}.run[_ngcontent-%COMP%], .sample[_ngcontent-%COMP%], .step[_ngcontent-%COMP%]{color:#616161;font-size:13px}body.dark-mode[_nghost-%COMP%]   .run[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .run[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}body.dark-mode[_nghost-%COMP%]   .sample[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .sample[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}body.dark-mode[_nghost-%COMP%]   .step[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .step[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.controls[_ngcontent-%COMP%]{color:#616161;white-space:nowrap;justify-self:flex-end;flex-shrink:0;margin-right:-12px}body.dark-mode[_nghost-%COMP%]   .controls[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .controls[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.img-container[_ngcontent-%COMP%]{flex-grow:1;overflow-y:auto;position:relative}.img-container[_ngcontent-%COMP%]   img[_ngcontent-%COMP%]{image-rendering:-moz-crisp-edges;image-rendering:pixelated}.actual-size[_nghost-%COMP%]   .img-container[_ngcontent-%COMP%]{overflow:auto;flex:none}[_nghost-%COMP%]:not(.actual-size)   img[_ngcontent-%COMP%]{position:absolute;max-height:100%;max-width:100%;width:auto;height:100%;object-fit:contain}.slider-row[_ngcontent-%COMP%]{display:flex;align-items:center;height:24px;position:relative}.step-slider[_ngcontent-%COMP%]{flex:1}[_nghost-%COMP%]     .mat-slider-min-value .mat-slider-thumb{background-color:#f57c00}[_nghost-%COMP%]     .hide-slider.mat-slider-horizontal .mat-slider-track-wrapper{height:0}.empty-message[_ngcontent-%COMP%]{margin-top:1em;font-size:13px}.linked-time-wrapper[_ngcontent-%COMP%]{position:absolute;top:5px;width:100%}.linked-time-tick[_ngcontent-%COMP%]{background-color:#e0e0e0;border-radius:50%;height:14px;position:absolute;width:14px}body.dark-mode[_nghost-%COMP%]   .linked-time-tick[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .linked-time-tick[_ngcontent-%COMP%]{background-color:#212121}.slider-track[_ngcontent-%COMP%], .slider-track-fill[_ngcontent-%COMP%]{height:2px;top:6px;position:absolute}.slider-track[_ngcontent-%COMP%]{background:rgba(0,0,0,.26);left:7px;width:calc(100% - 14px)}body.dark-mode[_nghost-%COMP%]   .slider-track[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slider-track[_ngcontent-%COMP%]{background:rgba(255,255,255,.3)}.slider-track-fill[_ngcontent-%COMP%]{background:#f57c00}body.dark-mode[_nghost-%COMP%]   .slider-track-fill[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slider-track-fill[_ngcontent-%COMP%]{background:#ef6c00}"],changeDetection:0}),n})(),nse=(()=>{class n{constructor(e,i){this.store=e,this.dataSource=i,this.fullWidthChanged=new G,this.pinStateChanged=new G,this.brightnessInMilli$=this.store.select(kI),this.contrastInMilli$=this.store.select(FI),this.actualSizeGlobalSetting$=this.store.select(NI),this.showActualSize=!1,this.actualSizeUiToggled=!1,this.actualSizeUiToggleSubject=new hr(this.actualSizeUiToggled),this.ngUnsubscribe=new ke}onStepIndexChanged(e){this.store.dispatch(oR({cardId:this.cardId,stepIndex:e}))}isImageCardMetadata(e){let{plugin:i}=e;return i===ri.IMAGES}onActualSizeToggle(){this.actualSizeUiToggled=!this.actualSizeUiToggled,this.actualSizeUiToggleSubject.next(this.actualSizeUiToggled)}ngOnInit(){Lt([this.actualSizeGlobalSetting$,this.actualSizeUiToggleSubject]).pipe(st(this.ngUnsubscribe),kt(([l,c])=>{this.showActualSize=l||c,this.fullWidthChanged.emit(this.showActualSize)})).subscribe(()=>{});let i=this.store.select(tc,this.cardId).pipe(st(this.ngUnsubscribe),Ye(l=>!!l&&this.isImageCardMetadata(l)),L(l=>l),Ma(1)),o=Lt([i,this.store.select(xh,this.cardId)]).pipe(st(this.ngUnsubscribe),L(([l,c])=>{let u=l.runId;return c&&c.hasOwnProperty(u)?c[u]:[]}),yi((l,c)=>l.length===c.length&&0===l.length||l===c),Ma(1));this.stepIndex$=this.store.select(tH,this.cardId).pipe(L(l=>l?l.index:null)),this.isClosestStepHighlighted$=this.store.select(tH,this.cardId).pipe(L(l=>!!l&&l.isClosest)),this.loadState$=this.store.select(bh,this.cardId),this.tag$=i.pipe(L(l=>l.tag)),this.title$=this.tag$.pipe(L(l=>ly(l,this.groupName))),this.runId$=i.pipe(L(l=>l.runId)),this.sample$=i.pipe(L(l=>l.sample)),this.numSample$=i.pipe(L(l=>l.numSample)),this.steps$=this.store.select(gee,this.cardId),this.isPinned$=this.store.select(Ch,this.cardId),this.linkedTimeSelection$=this.store.select(Xm).pipe(fr(this.steps$),L(([l,c])=>l?Qh(l,Math.min(...c),Math.max(...c)):null)),this.selectedSteps$=this.linkedTimeSelection$.pipe(fr(this.steps$),L(([l,c])=>l?null===l.endStep?-1!==c.indexOf(l.startStep)?[l.startStep]:[]:c.filter(u=>u>=l.startStep&&u<=l.endStep):[]));let a=Lt([o,this.stepIndex$]).pipe(L(([l,c])=>null!==c&&l[c]?l[c]:null));this.imageUrl$=a.pipe(L(l=>l?this.dataSource.imageUrl(l.imageId):null))}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}}return n.\u0275fac=function(e){return new(e||n)(M(Ce),M($u))},n.\u0275cmp=R({type:n,selectors:[["image-card"]],inputs:{cardId:"cardId",groupName:"groupName",runColorScale:"runColorScale"},outputs:{fullWidthChanged:"fullWidthChanged",pinStateChanged:"pinStateChanged"},decls:17,vars:50,consts:[[3,"loadState","title","tag","runId","sample","numSample","imageUrl","stepIndex","steps","isClosestStepHighlighted","brightnessInMilli","contrastInMilli","runColorScale","showActualSize","allowToggleActualSize","isPinned","linkedTimeSelection","selectedSteps","stepIndexChange","onActualSizeToggle","onPinClicked"]],template:function(e,i){1&e&&(_(0,"image-card-component",0),P("stepIndexChange",function(o){return i.onStepIndexChanged(o)})("onActualSizeToggle",function(){return i.onActualSizeToggle()})("onPinClicked",function(o){return i.pinStateChanged.emit(o)}),B(1,"async"),B(2,"async"),B(3,"async"),B(4,"async"),B(5,"async"),B(6,"async"),B(7,"async"),B(8,"async"),B(9,"async"),B(10,"async"),B(11,"async"),B(12,"async"),B(13,"async"),B(14,"async"),B(15,"async"),B(16,"async"),v()),2&e&&y("loadState",U(1,18,i.loadState$))("title",U(2,20,i.title$))("tag",U(3,22,i.tag$))("runId",U(4,24,i.runId$))("sample",U(5,26,i.sample$))("numSample",U(6,28,i.numSample$))("imageUrl",U(7,30,i.imageUrl$))("stepIndex",U(8,32,i.stepIndex$))("steps",U(9,34,i.steps$))("isClosestStepHighlighted",U(10,36,i.isClosestStepHighlighted$))("brightnessInMilli",U(11,38,i.brightnessInMilli$))("contrastInMilli",U(12,40,i.contrastInMilli$))("runColorScale",i.runColorScale)("showActualSize",i.showActualSize)("allowToggleActualSize",!1===U(13,42,i.actualSizeGlobalSetting$))("isPinned",U(14,44,i.isPinned$))("linkedTimeSelection",U(15,46,i.linkedTimeSelection$))("selectedSteps",U(16,48,i.selectedSteps$))},dependencies:[tse,Ge],styles:["[_nghost-%COMP%] {\n        display: flex;\n        flex-direction: column;\n        height: 100%;\n      }"],changeDetection:0}),n})(),dr=(()=>(function(n){n[n.SVG=0]="SVG",n[n.WEBGL=1]="WEBGL"}(dr||(dr={})),dr))(),Nr=(()=>(function(n){n[n.LINEAR=0]="LINEAR",n[n.LOG10=1]="LOG10",n[n.TIME=2]="TIME"}(Nr||(Nr={})),Nr))(),Gr=(()=>(function(n){n.NONE="NONE",n.DRAG_ZOOMING="DRAG_ZOOMING",n.SCROLL_ZOOMING="SCROLL_ZOOMING",n.PANNING="PANNING"}(Gr||(Gr={})),Gr))();function d4e(n,t){1&n&&(_(0,"span"),A(1,"scalar"),v())}function p4e(n,t){1&n&&(_(0,"span"),A(1,"histogram"),v())}function h4e(n,t){1&n&&(_(0,"span"),A(1,"unknown"),v())}function f4e(n,t){if(1&n&&(sn(0,13),E(1,d4e,2,0,"span",14),E(2,p4e,2,0,"span",14),E(3,h4e,2,0,"span",15),an()),2&n){let e=S(2);y("ngSwitch",e.cardMetadata.plugin),C(1),y("ngSwitchCase",e.PluginType.SCALARS),C(1),y("ngSwitchCase",e.PluginType.HISTOGRAMS)}}function m4e(n,t){1&n&&Ni(0)}function g4e(n,t){if(1&n&&(_(0,"option",16),A(1),v()),2&n){let e=t.$implicit;y("value",e.id),C(1),yt(e.name)}}function _4e(n,t){if(1&n){let e=Pe();sn(0),_(1,"h2"),E(2,f4e,4,3,"ng-template",null,2,qt),_(4,"span"),A(5,"Download\xa0"),v(),E(6,m4e,1,0,"ng-container",3),_(7,"span"),A(8,"\xa0data for\xa0"),v(),_(9,"code",4),A(10),v()(),_(11,"mat-dialog-content")(12,"mat-form-field",5)(13,"mat-label"),A(14,"Select a run to download a data for a series"),v(),_(15,"select",6),P("change",function(r){return oe(e),se(S().runSelected.emit(r.target.value))}),_(16,"option",7),A(17,"-"),v(),E(18,g4e,2,2,"option",8),v()(),_(19,"div",9)(20,"span"),A(21,"Download as\u2026"),v(),A(22,"\xa0"),_(23,"a",10),A(24,"JSON"),v(),_(25,"a",10),A(26,"CSV"),v()()(),_(27,"mat-dialog-actions",11)(28,"button",12),A(29,"Close"),v()(),an()}if(2&n){let e=$e(3),i=S();C(6),y("ngTemplateOutlet",e),C(3),y("title",i.cardMetadata.tag),C(1),yt(i.cardMetadata.tag),C(5),y("value",i.selectedRunId||""),C(1),y("value",""),C(2),y("ngForOf",i.runs),C(5),y("disabled",!i.downloadUrlJson)("download",i.getDownloadName("json")),ze("href",i.downloadUrlJson,zl),C(2),y("disabled",!i.downloadUrlCsv)("download",i.getDownloadName("csv")),ze("href",i.downloadUrlCsv,zl)}}function v4e(n,t){1&n&&A(0,"Loading...")}var rse=(()=>{class n{constructor(){this.runSelected=new G,this.PluginType=ri}getDownloadName(e){let i=this.runs.find(r=>r.id===this.selectedRunId);return i?`${i.name}.${e}`:""}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["data_download_dialog_component"]],inputs:{cardMetadata:"cardMetadata",runs:"runs",selectedRunId:"selectedRunId",downloadUrlCsv:"downloadUrlCsv",downloadUrlJson:"downloadUrlJson"},outputs:{runSelected:"runSelected"},decls:3,vars:2,consts:[[4,"ngIf","ngIfElse"],["noCardMetadata",""],["dataName",""],[4,"ngTemplateOutlet"],[1,"tag-name",3,"title"],["appearance","fill",1,"run-selector"],["matNativeControl","","name","run","cdkFocusInitial","","required","",3,"value","change"],["selected","",3,"value"],[3,"value",4,"ngFor","ngForOf"],[1,"download-controls"],["mat-stroked-button","",3,"disabled","download"],["align","end"],["mat-button","","mat-dialog-close",""],[3,"ngSwitch"],[4,"ngSwitchCase"],[4,"NgSwitchDefault"],[3,"value"]],template:function(e,i){if(1&e&&(E(0,_4e,30,12,"ng-container",0),E(1,v4e,1,0,"ng-template",null,1,qt)),2&e){let r=$e(2);y("ngIf",i.cardMetadata)("ngIfElse",r)}},dependencies:[dn,Be,os,Cr,Ur,Dne,Ine,_n,Iv,T2,D2,A2,pd,Nv,Uh],styles:["h2[_ngcontent-%COMP%]{font-size:1.25em;overflow-wrap:break-word}.run-selector[_ngcontent-%COMP%]{font-size:.9em;width:100%}.download-controls[_ngcontent-%COMP%]{font-size:.9em}.download-controls[_ngcontent-%COMP%]   a[_ngcontent-%COMP%]{margin:3px 10px 3px 0}"],changeDetection:0}),n})(),ose=(()=>{class n{constructor(e,i,r){this.selectedRunId$=new hr(null),this.cardMetadata$=e.select(tc,r.cardId).pipe(Ye(o=>Boolean(o))),this.downloadUrlCsv$=Lt([e.select(tc,r.cardId),this.selectedRunId$]).pipe(L(([o,s])=>o&&s?i.downloadUrl(o.plugin,o.tag,s,"csv"):null),zn(null)),this.downloadUrlJson$=Lt([e.select(tc,r.cardId),this.selectedRunId$]).pipe(L(([o,s])=>o&&s?i.downloadUrl(o.plugin,o.tag,s,"json"):null),zn(null)),this.runs$=Lt([e.select(qI),e.select(xh,r.cardId)]).pipe(L(([o,s])=>s?Object.keys(s).map(a=>o.get(a)).filter(Boolean):[]))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce),M($u),M(cw))},n.\u0275cmp=R({type:n,selectors:[["data_download_dialog"]],decls:6,vars:15,consts:[[3,"cardMetadata","runs","selectedRunId","downloadUrlCsv","downloadUrlJson","runSelected"]],template:function(e,i){1&e&&(_(0,"data_download_dialog_component",0),P("runSelected",function(o){return i.selectedRunId$.next(o)}),B(1,"async"),B(2,"async"),B(3,"async"),B(4,"async"),B(5,"async"),v()),2&e&&y("cardMetadata",U(1,5,i.cardMetadata$))("runs",U(2,7,i.runs$))("selectedRunId",U(3,9,i.selectedRunId$))("downloadUrlCsv",U(4,11,i.downloadUrlCsv$))("downloadUrlJson",U(5,13,i.downloadUrlJson$))},dependencies:[rse,Ge],encapsulation:2,changeDetection:0}),n})();function uc(n,t){return n<t?-1:n>t?1:n>=t?0:NaN}function Bw(n){return 1===n.length&&(n=function(n){return function(t,e){return uc(n(t),e)}}(n)),{left:function(t,e,i,r){for(null==i&&(i=0),null==r&&(r=t.length);i<r;){var o=i+r>>>1;n(t[o],e)<0?i=o+1:r=o}return i},right:function(t,e,i,r){for(null==i&&(i=0),null==r&&(r=t.length);i<r;){var o=i+r>>>1;n(t[o],e)>0?r=o:i=o+1}return i}}}var iu=Bw(uc).right;function xR(n,t){var r,o,s,e=n.length,i=-1;if(null==t){for(;++i<e;)if(null!=(r=n[i])&&r>=r)for(o=s=r;++i<e;)null!=(r=n[i])&&(o>r&&(o=r),s<r&&(s=r))}else for(;++i<e;)if(null!=(r=t(n[i],i,n))&&r>=r)for(o=s=r;++i<e;)null!=(r=t(n[i],i,n))&&(o>r&&(o=r),s<r&&(s=r));return[o,s]}var cse=Array.prototype.slice;function Vw(n){return function(){return n}}function use(n){return n}function Kh(n,t,e){n=+n,t=+t,e=(r=arguments.length)<2?(t=n,n=0,1):r<3?1:+e;for(var i=-1,r=0|Math.max(0,Math.ceil((t-n)/e)),o=new Array(r);++i<r;)o[i]=n+i*e;return o}var RU=Math.sqrt(50),OU=Math.sqrt(10),kU=Math.sqrt(2);function Hw(n,t,e){var i,o,s,a,r=-1;if(e=+e,(n=+n)==(t=+t)&&e>0)return[n];if((i=t<n)&&(o=n,n=t,t=o),0===(a=py(n,t,e))||!isFinite(a))return[];if(a>0)for(n=Math.ceil(n/a),t=Math.floor(t/a),s=new Array(o=Math.ceil(t-n+1));++r<o;)s[r]=(n+r)*a;else for(n=Math.floor(n*a),t=Math.ceil(t*a),s=new Array(o=Math.ceil(n-t+1));++r<o;)s[r]=(n-r)/a;return i&&s.reverse(),s}function py(n,t,e){var i=(t-n)/Math.max(0,e),r=Math.floor(Math.log(i)/Math.LN10),o=i/Math.pow(10,r);return r>=0?(o>=RU?10:o>=OU?5:o>=kU?2:1)*Math.pow(10,r):-Math.pow(10,-r)/(o>=RU?10:o>=OU?5:o>=kU?2:1)}function vd(n,t,e){var i=Math.abs(t-n)/Math.max(0,e),r=Math.pow(10,Math.floor(Math.log(i)/Math.LN10)),o=i/r;return o>=RU?r*=10:o>=OU?r*=5:o>=kU&&(r*=2),t<n?-r:r}function CR(n){return Math.ceil(Math.log(n.length)/Math.LN2)+1}function MR(){var n=use,t=xR,e=CR;function i(r){var o,a,s=r.length,l=new Array(s);for(o=0;o<s;++o)l[o]=n(r[o],o,r);var c=t(l),u=c[0],d=c[1],p=e(l,u,d);Array.isArray(p)||(p=vd(u,d,p),p=Kh(Math.ceil(u/p)*p,d,p));for(var h=p.length;p[0]<=u;)p.shift(),--h;for(;p[h-1]>d;)p.pop(),--h;var m,f=new Array(h+1);for(o=0;o<=h;++o)(m=f[o]=[]).x0=o>0?p[o-1]:u,m.x1=o<h?p[o]:d;for(o=0;o<s;++o)u<=(a=l[o])&&a<=d&&f[iu(p,a,0,h)].push(r[o]);return f}return i.value=function(r){return arguments.length?(n="function"==typeof r?r:Vw(r),i):n},i.domain=function(r){return arguments.length?(t="function"==typeof r?r:Vw([r[0],r[1]]),i):t},i.thresholds=function(r){return arguments.length?(e="function"==typeof r?r:Array.isArray(r)?Vw(cse.call(r)):Vw(r),i):e},i}var wR=Array.prototype.slice;function dse(n){return n}function D4e(n){return"translate("+(n+.5)+",0)"}function A4e(n){return"translate(0,"+(n+.5)+")"}function I4e(n){return function(t){return+n(t)}}function P4e(n){var t=Math.max(0,n.bandwidth()-1)/2;return n.round()&&(t=Math.round(t)),function(e){return+n(e)+t}}function R4e(){return!this.__axis}function BU(n,t){var e=[],i=null,r=null,o=6,s=6,a=3,l=1===n||4===n?-1:1,c=4===n||2===n?"x":"y",u=1===n||3===n?D4e:A4e;function d(p){var h=i??(t.ticks?t.ticks.apply(t,e):t.domain()),f=r??(t.tickFormat?t.tickFormat.apply(t,e):dse),m=Math.max(o,0)+a,x=t.range(),g=+x[0]+.5,b=+x[x.length-1]+.5,D=(t.bandwidth?P4e:I4e)(t.copy()),T=p.selection?p.selection():p,k=T.selectAll(".domain").data([null]),Z=T.selectAll(".tick").data(h,t).order(),z=Z.exit(),fe=Z.enter().append("g").attr("class","tick"),ue=Z.select("line"),he=Z.select("text");k=k.merge(k.enter().insert("path",".tick").attr("class","domain").attr("stroke","currentColor")),Z=Z.merge(fe),ue=ue.merge(fe.append("line").attr("stroke","currentColor").attr(c+"2",l*o)),he=he.merge(fe.append("text").attr("fill","currentColor").attr(c,l*m).attr("dy",1===n?"0em":3===n?"0.71em":"0.32em")),p!==T&&(k=k.transition(p),Z=Z.transition(p),ue=ue.transition(p),he=he.transition(p),z=z.transition(p).attr("opacity",1e-6).attr("transform",function(w){return isFinite(w=D(w))?u(w):this.getAttribute("transform")}),fe.attr("opacity",1e-6).attr("transform",function(w){var F=this.parentNode.__axis;return u(F&&isFinite(F=F(w))?F:D(w))})),z.remove(),k.attr("d",4===n||2==n?s?"M"+l*s+","+g+"H0.5V"+b+"H"+l*s:"M0.5,"+g+"V"+b:s?"M"+g+","+l*s+"V0.5H"+b+"V"+l*s:"M"+g+",0.5H"+b),Z.attr("opacity",1).attr("transform",function(w){return u(D(w))}),ue.attr(c+"2",l*o),he.attr(c,l*m).text(f),T.filter(R4e).attr("fill","none").attr("font-size",10).attr("font-family","sans-serif").attr("text-anchor",2===n?"start":4===n?"end":"middle"),T.each(function(){this.__axis=D})}return d.scale=function(p){return arguments.length?(t=p,d):t},d.ticks=function(){return e=wR.call(arguments),d},d.tickArguments=function(p){return arguments.length?(e=null==p?[]:wR.call(p),d):e.slice()},d.tickValues=function(p){return arguments.length?(i=null==p?null:wR.call(p),d):i&&i.slice()},d.tickFormat=function(p){return arguments.length?(r=p,d):r},d.tickSize=function(p){return arguments.length?(o=s=+p,d):o},d.tickSizeInner=function(p){return arguments.length?(o=+p,d):o},d.tickSizeOuter=function(p){return arguments.length?(s=+p,d):s},d.tickPadding=function(p){return arguments.length?(a=+p,d):a},d}function zw(n){return BU(2,n)}function jw(n){return BU(3,n)}var O4e={value:function(){}};function fse(){for(var i,n=0,t=arguments.length,e={};n<t;++n){if(!(i=arguments[n]+"")||i in e||/[\s.]/.test(i))throw new Error("illegal type: "+i);e[i]=[]}return new ER(e)}function ER(n){this._=n}function k4e(n,t){return n.trim().split(/^|\s+/).map(function(e){var i="",r=e.indexOf(".");if(r>=0&&(i=e.slice(r+1),e=e.slice(0,r)),e&&!t.hasOwnProperty(e))throw new Error("unknown type: "+e);return{type:e,name:i}})}function F4e(n,t){for(var r,e=0,i=n.length;e<i;++e)if((r=n[e]).name===t)return r.value}function hse(n,t,e){for(var i=0,r=n.length;i<r;++i)if(n[i].name===t){n[i]=O4e,n=n.slice(0,i).concat(n.slice(i+1));break}return null!=e&&n.push({name:t,value:e}),n}ER.prototype=fse.prototype={constructor:ER,on:function(n,t){var r,e=this._,i=k4e(n+"",e),o=-1,s=i.length;if(!(arguments.length<2)){if(null!=t&&"function"!=typeof t)throw new Error("invalid callback: "+t);for(;++o<s;)if(r=(n=i[o]).type)e[r]=hse(e[r],n.name,t);else if(null==t)for(r in e)e[r]=hse(e[r],n.name,null);return this}for(;++o<s;)if((r=(n=i[o]).type)&&(r=F4e(e[r],n.name)))return r},copy:function(){var n={},t=this._;for(var e in t)n[e]=t[e].slice();return new ER(n)},call:function(n,t){if((r=arguments.length-2)>0)for(var r,o,e=new Array(r),i=0;i<r;++i)e[i]=arguments[i+2];if(!this._.hasOwnProperty(n))throw new Error("unknown type: "+n);for(i=0,r=(o=this._[n]).length;i<r;++i)o[i].value.apply(t,e)},apply:function(n,t,e){if(!this._.hasOwnProperty(n))throw new Error("unknown type: "+n);for(var i=this._[n],r=0,o=i.length;r<o;++r)i[r].value.apply(t,e)}};var Gw=fse,TR="http://www.w3.org/1999/xhtml",HU={svg:"http://www.w3.org/2000/svg",xhtml:TR,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};function dp(n){var t=n+="",e=t.indexOf(":");return e>=0&&"xmlns"!==(t=n.slice(0,e))&&(n=n.slice(e+1)),HU.hasOwnProperty(t)?{space:HU[t],local:n}:n}function N4e(n){return function(){var t=this.ownerDocument,e=this.namespaceURI;return e===TR&&t.documentElement.namespaceURI===TR?t.createElement(n):t.createElementNS(e,n)}}function L4e(n){return function(){return this.ownerDocument.createElementNS(n.space,n.local)}}function DR(n){var t=dp(n);return(t.local?L4e:N4e)(t)}function B4e(){}function gg(n){return null==n?B4e:function(){return this.querySelector(n)}}function V4e(){return[]}function Ww(n){return null==n?V4e:function(){return this.querySelectorAll(n)}}function qw(n){return function(){return this.matches(n)}}function AR(n){return new Array(n.length)}function Yw(n,t){this.ownerDocument=n.ownerDocument,this.namespaceURI=n.namespaceURI,this._next=null,this._parent=n,this.__data__=t}function H4e(n,t,e,i,r,o){for(var a,s=0,l=t.length,c=o.length;s<c;++s)(a=t[s])?(a.__data__=o[s],i[s]=a):e[s]=new Yw(n,o[s]);for(;s<l;++s)(a=t[s])&&(r[s]=a)}function U4e(n,t,e,i,r,o,s){var a,l,h,c={},u=t.length,d=o.length,p=new Array(u);for(a=0;a<u;++a)(l=t[a])&&(p[a]=h="$"+s.call(l,l.__data__,a,t),h in c?r[a]=l:c[h]=l);for(a=0;a<d;++a)(l=c[h="$"+s.call(n,o[a],a,o)])?(i[a]=l,l.__data__=o[a],c[h]=null):e[a]=new Yw(n,o[a]);for(a=0;a<u;++a)(l=t[a])&&c[p[a]]===l&&(r[a]=l)}function z4e(n,t){return n<t?-1:n>t?1:n>=t?0:NaN}function j4e(n){return function(){this.removeAttribute(n)}}function G4e(n){return function(){this.removeAttributeNS(n.space,n.local)}}function W4e(n,t){return function(){this.setAttribute(n,t)}}function q4e(n,t){return function(){this.setAttributeNS(n.space,n.local,t)}}function Y4e(n,t){return function(){var e=t.apply(this,arguments);null==e?this.removeAttribute(n):this.setAttribute(n,e)}}function X4e(n,t){return function(){var e=t.apply(this,arguments);null==e?this.removeAttributeNS(n.space,n.local):this.setAttributeNS(n.space,n.local,e)}}function IR(n){return n.ownerDocument&&n.ownerDocument.defaultView||n.document&&n||n.defaultView}function Q4e(n){return function(){this.style.removeProperty(n)}}function K4e(n,t,e){return function(){this.style.setProperty(n,t,e)}}function Z4e(n,t,e){return function(){var i=t.apply(this,arguments);null==i?this.style.removeProperty(n):this.style.setProperty(n,i,e)}}function Zh(n,t){return n.style.getPropertyValue(t)||IR(n).getComputedStyle(n,null).getPropertyValue(t)}function J4e(n){return function(){delete this[n]}}function $4e(n,t){return function(){this[n]=t}}function eHe(n,t){return function(){var e=t.apply(this,arguments);null==e?delete this[n]:this[n]=e}}function Nse(n){return n.trim().split(/^|\s+/)}function UU(n){return n.classList||new Lse(n)}function Lse(n){this._node=n,this._names=Nse(n.getAttribute("class")||"")}function Bse(n,t){for(var e=UU(n),i=-1,r=t.length;++i<r;)e.add(t[i])}function Vse(n,t){for(var e=UU(n),i=-1,r=t.length;++i<r;)e.remove(t[i])}function tHe(n){return function(){Bse(this,n)}}function nHe(n){return function(){Vse(this,n)}}function iHe(n,t){return function(){(t.apply(this,arguments)?Bse:Vse)(this,n)}}function rHe(){this.textContent=""}function oHe(n){return function(){this.textContent=n}}function sHe(n){return function(){var t=n.apply(this,arguments);this.textContent=t??""}}function aHe(){this.innerHTML=""}function lHe(n){return function(){this.innerHTML=n}}function cHe(n){return function(){var t=n.apply(this,arguments);this.innerHTML=t??""}}function uHe(){this.nextSibling&&this.parentNode.appendChild(this)}function dHe(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function pHe(){return null}function hHe(){var n=this.parentNode;n&&n.removeChild(this)}function fHe(){var n=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(n,this.nextSibling):n}function mHe(){var n=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(n,this.nextSibling):n}Yw.prototype={constructor:Yw,appendChild:function(n){return this._parent.insertBefore(n,this._next)},insertBefore:function(n,t){return this._parent.insertBefore(n,t)},querySelector:function(n){return this._parent.querySelector(n)},querySelectorAll:function(n){return this._parent.querySelectorAll(n)}},Lse.prototype={add:function(n){this._names.indexOf(n)<0&&(this._names.push(n),this._node.setAttribute("class",this._names.join(" ")))},remove:function(n){var t=this._names.indexOf(n);t>=0&&(this._names.splice(t,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(n){return this._names.indexOf(n)>=0}};var Zse={},si=null;function gHe(n,t,e){return n=Jse(n,t,e),function(i){var r=i.relatedTarget;(!r||r!==this&&!(8&r.compareDocumentPosition(this)))&&n.call(this,i)}}function Jse(n,t,e){return function(i){var r=si;si=i;try{n.call(this,this.__data__,t,e)}finally{si=r}}}function _He(n){return n.trim().split(/^|\s+/).map(function(t){var e="",i=t.indexOf(".");return i>=0&&(e=t.slice(i+1),t=t.slice(0,i)),{type:t,name:e}})}function vHe(n){return function(){var t=this.__on;if(t){for(var o,e=0,i=-1,r=t.length;e<r;++e)o=t[e],n.type&&o.type!==n.type||o.name!==n.name?t[++i]=o:this.removeEventListener(o.type,o.listener,o.capture);++i?t.length=i:delete this.__on}}}function yHe(n,t,e){var i=Zse.hasOwnProperty(n.type)?gHe:Jse;return function(r,o,s){var l,a=this.__on,c=i(t,o,s);if(a)for(var u=0,d=a.length;u<d;++u)if((l=a[u]).type===n.type&&l.name===n.name)return this.removeEventListener(l.type,l.listener,l.capture),this.addEventListener(l.type,l.listener=c,l.capture=e),void(l.value=t);this.addEventListener(n.type,c,e),l={type:n.type,name:n.name,value:t,listener:c,capture:e},a?a.push(l):this.__on=[l]}}function eae(n,t,e){var i=IR(n),r=i.CustomEvent;"function"==typeof r?r=new r(t,e):(r=i.document.createEvent("Event"),e?(r.initEvent(t,e.bubbles,e.cancelable),r.detail=e.detail):r.initEvent(t,!1,!1)),n.dispatchEvent(r)}function bHe(n,t){return function(){return eae(this,n,t)}}function xHe(n,t){return function(){return eae(this,n,t.apply(this,arguments))}}typeof document<"u"&&("onmouseenter"in document.documentElement||(Zse={mouseenter:"mouseover",mouseleave:"mouseout"}));var jU=[null];function ao(n,t){this._groups=n,this._parents=t}function nae(){return new ao([[document.documentElement]],jU)}ao.prototype=nae.prototype={constructor:ao,select:function(n){"function"!=typeof n&&(n=gg(n));for(var t=this._groups,e=t.length,i=new Array(e),r=0;r<e;++r)for(var l,c,o=t[r],s=o.length,a=i[r]=new Array(s),u=0;u<s;++u)(l=o[u])&&(c=n.call(l,l.__data__,u,o))&&("__data__"in l&&(c.__data__=l.__data__),a[u]=c);return new ao(i,this._parents)},selectAll:function(n){"function"!=typeof n&&(n=Ww(n));for(var t=this._groups,e=t.length,i=[],r=[],o=0;o<e;++o)for(var l,s=t[o],a=s.length,c=0;c<a;++c)(l=s[c])&&(i.push(n.call(l,l.__data__,c,s)),r.push(l));return new ao(i,r)},filter:function(n){"function"!=typeof n&&(n=qw(n));for(var t=this._groups,e=t.length,i=new Array(e),r=0;r<e;++r)for(var l,o=t[r],s=o.length,a=i[r]=[],c=0;c<s;++c)(l=o[c])&&n.call(l,l.__data__,c,o)&&a.push(l);return new ao(i,this._parents)},data:function(n,t){if(!n)return h=new Array(this.size()),c=-1,this.each(function(Z){h[++c]=Z}),h;var e=t?U4e:H4e,i=this._parents,r=this._groups;"function"!=typeof n&&(n=function(n){return function(){return n}}(n));for(var o=r.length,s=new Array(o),a=new Array(o),l=new Array(o),c=0;c<o;++c){var u=i[c],d=r[c],p=d.length,h=n.call(u,u&&u.__data__,c,i),f=h.length,m=a[c]=new Array(f),x=s[c]=new Array(f);e(u,d,m,x,l[c]=new Array(p),h,t);for(var T,k,b=0,D=0;b<f;++b)if(T=m[b]){for(b>=D&&(D=b+1);!(k=x[D])&&++D<f;);T._next=k||null}}return(s=new ao(s,i))._enter=a,s._exit=l,s},enter:function(){return new ao(this._enter||this._groups.map(AR),this._parents)},exit:function(){return new ao(this._exit||this._groups.map(AR),this._parents)},join:function(n,t,e){var i=this.enter(),r=this,o=this.exit();return i="function"==typeof n?n(i):i.append(n+""),null!=t&&(r=t(r)),null==e?o.remove():e(o),i&&r?i.merge(r).order():r},merge:function(n){for(var t=this._groups,e=n._groups,i=t.length,o=Math.min(i,e.length),s=new Array(i),a=0;a<o;++a)for(var p,l=t[a],c=e[a],u=l.length,d=s[a]=new Array(u),h=0;h<u;++h)(p=l[h]||c[h])&&(d[h]=p);for(;a<i;++a)s[a]=t[a];return new ao(s,this._parents)},order:function(){for(var n=this._groups,t=-1,e=n.length;++t<e;)for(var s,i=n[t],r=i.length-1,o=i[r];--r>=0;)(s=i[r])&&(o&&4^s.compareDocumentPosition(o)&&o.parentNode.insertBefore(s,o),o=s);return this},sort:function(n){function t(d,p){return d&&p?n(d.__data__,p.__data__):!d-!p}n||(n=z4e);for(var e=this._groups,i=e.length,r=new Array(i),o=0;o<i;++o){for(var c,s=e[o],a=s.length,l=r[o]=new Array(a),u=0;u<a;++u)(c=s[u])&&(l[u]=c);l.sort(t)}return new ao(r,this._parents).order()},call:function(){var n=arguments[0];return arguments[0]=this,n.apply(null,arguments),this},nodes:function(){var n=new Array(this.size()),t=-1;return this.each(function(){n[++t]=this}),n},node:function(){for(var n=this._groups,t=0,e=n.length;t<e;++t)for(var i=n[t],r=0,o=i.length;r<o;++r){var s=i[r];if(s)return s}return null},size:function(){var n=0;return this.each(function(){++n}),n},empty:function(){return!this.node()},each:function(n){for(var t=this._groups,e=0,i=t.length;e<i;++e)for(var a,r=t[e],o=0,s=r.length;o<s;++o)(a=r[o])&&n.call(a,a.__data__,o,r);return this},attr:function(n,t){var e=dp(n);if(arguments.length<2){var i=this.node();return e.local?i.getAttributeNS(e.space,e.local):i.getAttribute(e)}return this.each((null==t?e.local?G4e:j4e:"function"==typeof t?e.local?X4e:Y4e:e.local?q4e:W4e)(e,t))},style:function(n,t,e){return arguments.length>1?this.each((null==t?Q4e:"function"==typeof t?Z4e:K4e)(n,t,e??"")):Zh(this.node(),n)},property:function(n,t){return arguments.length>1?this.each((null==t?J4e:"function"==typeof t?eHe:$4e)(n,t)):this.node()[n]},classed:function(n,t){var e=Nse(n+"");if(arguments.length<2){for(var i=UU(this.node()),r=-1,o=e.length;++r<o;)if(!i.contains(e[r]))return!1;return!0}return this.each(("function"==typeof t?iHe:t?tHe:nHe)(e,t))},text:function(n){return arguments.length?this.each(null==n?rHe:("function"==typeof n?sHe:oHe)(n)):this.node().textContent},html:function(n){return arguments.length?this.each(null==n?aHe:("function"==typeof n?cHe:lHe)(n)):this.node().innerHTML},raise:function(){return this.each(uHe)},lower:function(){return this.each(dHe)},append:function(n){var t="function"==typeof n?n:DR(n);return this.select(function(){return this.appendChild(t.apply(this,arguments))})},insert:function(n,t){var e="function"==typeof n?n:DR(n),i=null==t?pHe:"function"==typeof t?t:gg(t);return this.select(function(){return this.insertBefore(e.apply(this,arguments),i.apply(this,arguments)||null)})},remove:function(){return this.each(hHe)},clone:function(n){return this.select(n?mHe:fHe)},datum:function(n){return arguments.length?this.property("__data__",n):this.node().__data__},on:function(n,t,e){var r,s,i=_He(n+""),o=i.length;if(!(arguments.length<2)){for(a=t?yHe:vHe,null==e&&(e=!1),r=0;r<o;++r)this.each(a(i[r],t,e));return this}var a=this.node().__on;if(a)for(var u,l=0,c=a.length;l<c;++l)for(r=0,u=a[l];r<o;++r)if((s=i[r]).type===u.type&&s.name===u.name)return u.value},dispatch:function(n,t){return this.each(("function"==typeof t?xHe:bHe)(n,t))}};var pp=nae;function bo(n){return"string"==typeof n?new ao([[document.querySelector(n)]],[document.documentElement]):new ao([[n]],jU)}function PR(){for(var t,n=si;t=n.sourceEvent;)n=t;return n}function RR(n,t){var e=n.ownerSVGElement||n;if(e.createSVGPoint){var i=e.createSVGPoint();return i.x=t.clientX,i.y=t.clientY,[(i=i.matrixTransform(n.getScreenCTM().inverse())).x,i.y]}var r=n.getBoundingClientRect();return[t.clientX-r.left-n.clientLeft,t.clientY-r.top-n.clientTop]}function GU(n){var t=PR();return t.changedTouches&&(t=t.changedTouches[0]),RR(n,t)}function OR(){si.preventDefault(),si.stopImmediatePropagation()}function qU(n){var t=n.document.documentElement,e=bo(n).on("dragstart.drag",OR,!0);"onselectstart"in t?e.on("selectstart.drag",OR,!0):(t.__noselect=t.style.MozUserSelect,t.style.MozUserSelect="none")}function YU(n,t){var e=n.document.documentElement,i=bo(n).on("dragstart.drag",null);t&&(i.on("click.drag",OR,!0),setTimeout(function(){i.on("click.drag",null)},0)),"onselectstart"in e?i.on("selectstart.drag",null):(e.style.MozUserSelect=e.__noselect,delete e.__noselect)}function _g(n,t,e){n.prototype=t.prototype=e,e.constructor=n}function hy(n,t){var e=Object.create(n.prototype);for(var i in t)e[i]=t[i];return e}function Jh(){}var FR=1/.7,fy="\\s*([+-]?\\d+)\\s*",Qw="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",bd="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",CHe=/^#([0-9a-f]{3,8})$/,MHe=new RegExp("^rgb\\("+[fy,fy,fy]+"\\)$"),wHe=new RegExp("^rgb\\("+[bd,bd,bd]+"\\)$"),SHe=new RegExp("^rgba\\("+[fy,fy,fy,Qw]+"\\)$"),EHe=new RegExp("^rgba\\("+[bd,bd,bd,Qw]+"\\)$"),THe=new RegExp("^hsl\\("+[Qw,bd,bd]+"\\)$"),DHe=new RegExp("^hsla\\("+[Qw,bd,bd,Qw]+"\\)$"),iae={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};function rae(){return this.rgb().formatHex()}function oae(){return this.rgb().formatRgb()}function ru(n){var t,e;return n=(n+"").trim().toLowerCase(),(t=CHe.exec(n))?(e=t[1].length,t=parseInt(t[1],16),6===e?sae(t):3===e?new Hs(t>>8&15|t>>4&240,t>>4&15|240&t,(15&t)<<4|15&t,1):8===e?kR(t>>24&255,t>>16&255,t>>8&255,(255&t)/255):4===e?kR(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|240&t,((15&t)<<4|15&t)/255):null):(t=MHe.exec(n))?new Hs(t[1],t[2],t[3],1):(t=wHe.exec(n))?new Hs(255*t[1]/100,255*t[2]/100,255*t[3]/100,1):(t=SHe.exec(n))?kR(t[1],t[2],t[3],t[4]):(t=EHe.exec(n))?kR(255*t[1]/100,255*t[2]/100,255*t[3]/100,t[4]):(t=THe.exec(n))?cae(t[1],t[2]/100,t[3]/100,1):(t=DHe.exec(n))?cae(t[1],t[2]/100,t[3]/100,t[4]):iae.hasOwnProperty(n)?sae(iae[n]):"transparent"===n?new Hs(NaN,NaN,NaN,0):null}function sae(n){return new Hs(n>>16&255,n>>8&255,255&n,1)}function kR(n,t,e,i){return i<=0&&(n=t=e=NaN),new Hs(n,t,e,i)}function KU(n){return n instanceof Jh||(n=ru(n)),n?new Hs((n=n.rgb()).r,n.g,n.b,n.opacity):new Hs}function my(n,t,e,i){return 1===arguments.length?KU(n):new Hs(n,t,e,i??1)}function Hs(n,t,e,i){this.r=+n,this.g=+t,this.b=+e,this.opacity=+i}function aae(){return"#"+XU(this.r)+XU(this.g)+XU(this.b)}function lae(){var n=this.opacity;return(1===(n=isNaN(n)?1:Math.max(0,Math.min(1,n)))?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(1===n?")":", "+n+")")}function XU(n){return((n=Math.max(0,Math.min(255,Math.round(n)||0)))<16?"0":"")+n.toString(16)}function cae(n,t,e,i){return i<=0?n=t=e=NaN:e<=0||e>=1?n=t=NaN:t<=0&&(n=NaN),new yd(n,t,e,i)}function uae(n){if(n instanceof yd)return new yd(n.h,n.s,n.l,n.opacity);if(n instanceof Jh||(n=ru(n)),!n)return new yd;if(n instanceof yd)return n;var t=(n=n.rgb()).r/255,e=n.g/255,i=n.b/255,r=Math.min(t,e,i),o=Math.max(t,e,i),s=NaN,a=o-r,l=(o+r)/2;return a?(s=t===o?(e-i)/a+6*(e<i):e===o?(i-t)/a+2:(t-e)/a+4,a/=l<.5?o+r:2-o-r,s*=60):a=l>0&&l<1?0:s,new yd(s,a,l,n.opacity)}function vg(n,t,e,i){return 1===arguments.length?uae(n):new yd(n,t,e,i??1)}function yd(n,t,e,i){this.h=+n,this.s=+t,this.l=+e,this.opacity=+i}function QU(n,t,e){return 255*(n<60?t+(e-t)*n/60:n<180?e:n<240?t+(e-t)*(240-n)/60:t)}_g(Jh,ru,{copy:function(n){return Object.assign(new this.constructor,this,n)},displayable:function(){return this.rgb().displayable()},hex:rae,formatHex:rae,formatHsl:function(){return uae(this).formatHsl()},formatRgb:oae,toString:oae}),_g(Hs,my,hy(Jh,{brighter:function(n){return n=null==n?FR:Math.pow(FR,n),new Hs(this.r*n,this.g*n,this.b*n,this.opacity)},darker:function(n){return n=null==n?.7:Math.pow(.7,n),new Hs(this.r*n,this.g*n,this.b*n,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:aae,formatHex:aae,formatRgb:lae,toString:lae})),_g(yd,vg,hy(Jh,{brighter:function(n){return n=null==n?FR:Math.pow(FR,n),new yd(this.h,this.s,this.l*n,this.opacity)},darker:function(n){return n=null==n?.7:Math.pow(.7,n),new yd(this.h,this.s,this.l*n,this.opacity)},rgb:function(){var n=this.h%360+360*(this.h<0),t=isNaN(n)||isNaN(this.s)?0:this.s,e=this.l,i=e+(e<.5?e:1-e)*t,r=2*e-i;return new Hs(QU(n>=240?n-240:n+120,r,i),QU(n,r,i),QU(n<120?n+240:n-120,r,i),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var n=this.opacity;return(1===(n=isNaN(n)?1:Math.max(0,Math.min(1,n)))?"hsl(":"hsla(")+(this.h||0)+", "+100*(this.s||0)+"%, "+100*(this.l||0)+"%"+(1===n?")":", "+n+")")}}));var dae=Math.PI/180,pae=180/Math.PI,gae=4/29,gy=6/29,_ae=3*gy*gy;function vae(n){if(n instanceof xd)return new xd(n.l,n.a,n.b,n.opacity);if(n instanceof hp)return yae(n);n instanceof Hs||(n=KU(n));var o,s,t=ez(n.r),e=ez(n.g),i=ez(n.b),r=ZU((.2225045*t+.7168786*e+.0606169*i)/1);return t===e&&e===i?o=s=r:(o=ZU((.4360747*t+.3850649*e+.1430804*i)/.96422),s=ZU((.0139322*t+.0971045*e+.7141733*i)/.82521)),new xd(116*r-16,500*(o-r),200*(r-s),n.opacity)}function xd(n,t,e,i){this.l=+n,this.a=+t,this.b=+e,this.opacity=+i}function ZU(n){return n>.008856451679035631?Math.pow(n,1/3):n/_ae+gae}function JU(n){return n>gy?n*n*n:_ae*(n-gae)}function $U(n){return 255*(n<=.0031308?12.92*n:1.055*Math.pow(n,1/2.4)-.055)}function ez(n){return(n/=255)<=.04045?n/12.92:Math.pow((n+.055)/1.055,2.4)}function PHe(n){if(n instanceof hp)return new hp(n.h,n.c,n.l,n.opacity);if(n instanceof xd||(n=vae(n)),0===n.a&&0===n.b)return new hp(NaN,0<n.l&&n.l<100?0:NaN,n.l,n.opacity);var t=Math.atan2(n.b,n.a)*pae;return new hp(t<0?t+360:t,Math.sqrt(n.a*n.a+n.b*n.b),n.l,n.opacity)}function yg(n,t,e,i){return 1===arguments.length?PHe(n):new hp(n,t,e,i??1)}function hp(n,t,e,i){this.h=+n,this.c=+t,this.l=+e,this.opacity=+i}function yae(n){if(isNaN(n.h))return new xd(n.l,0,0,n.opacity);var t=n.h*dae;return new xd(n.l,Math.cos(t)*n.c,Math.sin(t)*n.c,n.opacity)}function nz(n,t,e,i,r){var o=n*n,s=o*n;return((1-3*n+3*o-s)*t+(4-6*o+3*s)*e+(1+3*n+3*o-3*s)*i+s*r)/6}function _y(n){return function(){return n}}function Cae(n,t){return function(e){return n+e*t}}function LR(n,t){var e=t-n;return e?Cae(n,e>180||e<-180?e-360*Math.round(e/360):e):_y(isNaN(n)?t:n)}function za(n,t){var e=t-n;return e?Cae(n,e):_y(isNaN(n)?t:n)}_g(xd,function(n,t,e,i){return 1===arguments.length?vae(n):new xd(n,t,e,i??1)},hy(Jh,{brighter:function(n){return new xd(this.l+18*(n??1),this.a,this.b,this.opacity)},darker:function(n){return new xd(this.l-18*(n??1),this.a,this.b,this.opacity)},rgb:function(){var n=(this.l+16)/116,t=isNaN(this.a)?n:n+this.a/500,e=isNaN(this.b)?n:n-this.b/200;return new Hs($U(3.1338561*(t=.96422*JU(t))-1.6168667*(n=1*JU(n))-.4906146*(e=.82521*JU(e))),$U(-.9787684*t+1.9161415*n+.033454*e),$U(.0719453*t-.2289914*n+1.4052427*e),this.opacity)}})),_g(hp,yg,hy(Jh,{brighter:function(n){return new hp(this.h,this.c,this.l+18*(n??1),this.opacity)},darker:function(n){return new hp(this.h,this.c,this.l-18*(n??1),this.opacity)},rgb:function(){return yae(this).rgb()}}));var bg=function n(t){var e=function(n){return 1==(n=+n)?za:function(t,e){return e-t?function(n,t,e){return n=Math.pow(n,e),t=Math.pow(t,e)-n,e=1/e,function(i){return Math.pow(n+i*t,e)}}(t,e,n):_y(isNaN(t)?e:t)}}(t);function i(r,o){var s=e((r=my(r)).r,(o=my(o)).r),a=e(r.g,o.g),l=e(r.b,o.b),c=za(r.opacity,o.opacity);return function(u){return r.r=s(u),r.g=a(u),r.b=l(u),r.opacity=c(u),r+""}}return i.gamma=n,i}(1);function wae(n){return function(t){var s,a,e=t.length,i=new Array(e),r=new Array(e),o=new Array(e);for(s=0;s<e;++s)a=my(t[s]),i[s]=a.r||0,r[s]=a.g||0,o[s]=a.b||0;return i=n(i),r=n(r),o=n(o),a.opacity=1,function(l){return a.r=i(l),a.g=r(l),a.b=o(l),a+""}}}var iz=wae(function(n){var t=n.length-1;return function(e){var i=e<=0?e=0:e>=1?(e=1,t-1):Math.floor(e*t),r=n[i],o=n[i+1];return nz((e-i/t)*t,i>0?n[i-1]:2*r-o,r,o,i<t-1?n[i+2]:2*o-r)}});function Sae(n,t){t||(t=[]);var r,e=n?Math.min(t.length,n.length):0,i=t.slice();return function(o){for(r=0;r<e;++r)i[r]=n[r]*(1-o)+t[r]*o;return i}}function Tae(n,t){var s,e=t?t.length:0,i=n?Math.min(e,n.length):0,r=new Array(i),o=new Array(e);for(s=0;s<i;++s)r[s]=fp(n[s],t[s]);for(;s<e;++s)o[s]=t[s];return function(a){for(s=0;s<i;++s)o[s]=r[s](a);return o}}function Dae(n,t){var e=new Date;return n=+n,t=+t,function(i){return e.setTime(n*(1-i)+t*i),e}}function Cs(n,t){return n=+n,t=+t,function(e){return n*(1-e)+t*e}}function Aae(n,t){var r,e={},i={};for(r in(null===n||"object"!=typeof n)&&(n={}),(null===t||"object"!=typeof t)&&(t={}),t)r in n?e[r]=fp(n[r],t[r]):i[r]=t[r];return function(o){for(r in e)i[r]=e[r](o);return i}}wae(function(n){var t=n.length;return function(e){var i=Math.floor(((e%=1)<0?++e:e)*t);return nz((e-i/t)*t,n[(i+t-1)%t],n[i%t],n[(i+1)%t],n[(i+2)%t])}});var oz=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,rz=new RegExp(oz.source,"g");function Kw(n,t){var i,r,o,e=oz.lastIndex=rz.lastIndex=0,s=-1,a=[],l=[];for(n+="",t+="";(i=oz.exec(n))&&(r=rz.exec(t));)(o=r.index)>e&&(o=t.slice(e,o),a[s]?a[s]+=o:a[++s]=o),(i=i[0])===(r=r[0])?a[s]?a[s]+=r:a[++s]=r:(a[++s]=null,l.push({i:s,x:Cs(i,r)})),e=rz.lastIndex;return e<t.length&&(o=t.slice(e),a[s]?a[s]+=o:a[++s]=o),a.length<2?l[0]?function(n){return function(t){return n(t)+""}}(l[0].x):function(n){return function(){return n}}(t):(t=l.length,function(c){for(var d,u=0;u<t;++u)a[(d=l[u]).i]=d.x(c);return a.join("")})}function fp(n,t){var i,e=typeof t;return null==t||"boolean"===e?_y(t):("number"===e?Cs:"string"===e?(i=ru(t))?(t=i,bg):Kw:t instanceof ru?bg:t instanceof Date?Dae:function(n){return ArrayBuffer.isView(n)&&!(n instanceof DataView)}(t)?Sae:Array.isArray(t)?Tae:"function"!=typeof t.valueOf&&"function"!=typeof t.toString||isNaN(t)?Aae:Cs)(n,t)}function sz(n,t){return n=+n,t=+t,function(e){return Math.round(n*(1-e)+t*e)}}var Zw,lz,Pae,VR,Iae=180/Math.PI,BR={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1};function az(n,t,e,i,r,o){var s,a,l;return(s=Math.sqrt(n*n+t*t))&&(n/=s,t/=s),(l=n*e+t*i)&&(e-=n*l,i-=t*l),(a=Math.sqrt(e*e+i*i))&&(e/=a,i/=a,l/=a),n*i<t*e&&(n=-n,t=-t,l=-l,s=-s),{translateX:r,translateY:o,rotate:Math.atan2(t,n)*Iae,skewX:Math.atan(l)*Iae,scaleX:s,scaleY:a}}function kae(n,t,e,i){function r(c){return c.length?c.pop()+" ":""}return function(c,u){var d=[],p=[];return c=n(c),u=n(u),function(c,u,d,p,h,f){if(c!==d||u!==p){var m=h.push("translate(",null,t,null,e);f.push({i:m-4,x:Cs(c,d)},{i:m-2,x:Cs(u,p)})}else(d||p)&&h.push("translate("+d+t+p+e)}(c.translateX,c.translateY,u.translateX,u.translateY,d,p),function(c,u,d,p){c!==u?(c-u>180?u+=360:u-c>180&&(c+=360),p.push({i:d.push(r(d)+"rotate(",null,i)-2,x:Cs(c,u)})):u&&d.push(r(d)+"rotate("+u+i)}(c.rotate,u.rotate,d,p),function(c,u,d,p){c!==u?p.push({i:d.push(r(d)+"skewX(",null,i)-2,x:Cs(c,u)}):u&&d.push(r(d)+"skewX("+u+i)}(c.skewX,u.skewX,d,p),function(c,u,d,p,h,f){if(c!==d||u!==p){var m=h.push(r(h)+"scale(",null,",",null,")");f.push({i:m-4,x:Cs(c,d)},{i:m-2,x:Cs(u,p)})}else(1!==d||1!==p)&&h.push(r(h)+"scale("+d+","+p+")")}(c.scaleX,c.scaleY,u.scaleX,u.scaleY,d,p),c=u=null,function(h){for(var x,f=-1,m=p.length;++f<m;)d[(x=p[f]).i]=x.x(h);return d.join("")}}}var cz=kae(function(n){return"none"===n?BR:(Zw||(Zw=document.createElement("DIV"),lz=document.documentElement,Pae=document.defaultView),Zw.style.transform=n,n=Pae.getComputedStyle(lz.appendChild(Zw),null).getPropertyValue("transform"),lz.removeChild(Zw),az(+(n=n.slice(7,-1).split(","))[0],+n[1],+n[2],+n[3],+n[4],+n[5]))},"px, ","px)","deg)"),uz=kae(function(n){return null==n?BR:(VR||(VR=document.createElementNS("http://www.w3.org/2000/svg","g")),VR.setAttribute("transform",n),(n=VR.transform.baseVal.consolidate())?az((n=n.matrix).a,n.b,n.c,n.d,n.e,n.f):BR)},", ",")",")");function Fae(n){return function(t,e){var i=n((t=vg(t)).h,(e=vg(e)).h),r=za(t.s,e.s),o=za(t.l,e.l),s=za(t.opacity,e.opacity);return function(a){return t.h=i(a),t.s=r(a),t.l=o(a),t.opacity=s(a),t+""}}}var dz=Fae(LR);function Nae(n){return function(t,e){var i=n((t=yg(t)).h,(e=yg(e)).h),r=za(t.c,e.c),o=za(t.l,e.l),s=za(t.opacity,e.opacity);return function(a){return t.h=i(a),t.c=r(a),t.l=o(a),t.opacity=s(a),t+""}}}Fae(za);var HR,eS,pz=Nae(LR),vy=(Nae(za),0),$w=0,Jw=0,UR=0,xg=0,zR=0,tS="object"==typeof performance&&performance.now?performance:Date,Vae="object"==typeof window&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(n){setTimeout(n,17)};function yy(){return xg||(Vae(BHe),xg=tS.now()+zR)}function BHe(){xg=0}function nS(){this._call=this._time=this._next=null}function jR(n,t,e){var i=new nS;return i.restart(n,t,e),i}function Lae(){xg=(UR=tS.now())+zR,vy=$w=0;try{!function(){yy(),++vy;for(var t,n=HR;n;)(t=xg-n._time)>=0&&n._call.call(null,t),n=n._next;--vy}()}finally{vy=0,function(){for(var n,e,t=HR,i=1/0;t;)t._call?(i>t._time&&(i=t._time),n=t,t=t._next):(e=t._next,t._next=null,t=n?n._next=e:HR=e);eS=n,hz(i)}(),xg=0}}function VHe(){var n=tS.now(),t=n-UR;t>1e3&&(zR-=t,UR=n)}function hz(n){vy||($w&&($w=clearTimeout($w)),n-xg>24?(n<1/0&&($w=setTimeout(Lae,n-tS.now()-zR)),Jw&&(Jw=clearInterval(Jw))):(Jw||(UR=tS.now(),Jw=setInterval(VHe,1e3)),vy=1,Vae(Lae)))}function GR(n,t,e){var i=new nS;return i.restart(function(r){i.stop(),n(r+t)},t=null==t?0:+t,e),i}nS.prototype=jR.prototype={constructor:nS,restart:function(n,t,e){if("function"!=typeof n)throw new TypeError("callback is not a function");e=(null==e?yy():+e)+(null==t?0:+t),!this._next&&eS!==this&&(eS?eS._next=this:HR=this,eS=this),this._call=n,this._time=e,hz()},stop:function(){this._call&&(this._call=null,this._time=1/0,hz())}};var UHe=Gw("start","end","cancel","interrupt"),zHe=[];function $h(n,t,e,i,r,o){var s=n.__transition;if(s){if(e in s)return}else n.__transition={};!function(n,t,e){var r,i=n.__transition;function s(c){var u,d,p,h;if(1!==e.state)return l();for(u in i)if((h=i[u]).name===e.name){if(3===h.state)return GR(s);4===h.state?(h.state=6,h.timer.stop(),h.on.call("interrupt",n,n.__data__,h.index,h.group),delete i[u]):+u<t&&(h.state=6,h.timer.stop(),h.on.call("cancel",n,n.__data__,h.index,h.group),delete i[u])}if(GR(function(){3===e.state&&(e.state=4,e.timer.restart(a,e.delay,e.time),a(c))}),e.state=2,e.on.call("start",n,n.__data__,e.index,e.group),2===e.state){for(e.state=3,r=new Array(p=e.tween.length),u=0,d=-1;u<p;++u)(h=e.tween[u].value.call(n,n.__data__,e.index,e.group))&&(r[++d]=h);r.length=d+1}}function a(c){for(var u=c<e.duration?e.ease.call(null,c/e.duration):(e.timer.restart(l),e.state=5,1),d=-1,p=r.length;++d<p;)r[d].call(n,u);5===e.state&&(e.on.call("end",n,n.__data__,e.index,e.group),l())}function l(){for(var c in e.state=6,e.timer.stop(),delete i[t],i)return;delete n.__transition}i[t]=e,e.timer=jR(function(c){e.state=1,e.timer.restart(s,e.delay,e.time),e.delay<=c&&s(c-e.delay)},0,e.time)}(n,e,{name:t,index:i,group:r,on:UHe,tween:zHe,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:0})}function rS(n,t){var e=Xo(n,t);if(e.state>0)throw new Error("too late; already scheduled");return e}function ha(n,t){var e=Xo(n,t);if(e.state>3)throw new Error("too late; already running");return e}function Xo(n,t){var e=n.__transition;if(!e||!(e=e[t]))throw new Error("transition not found");return e}function Cg(n,t){var i,r,s,e=n.__transition,o=!0;if(e){for(s in t=null==t?null:t+"",e)(i=e[s]).name===t?(r=i.state>2&&i.state<5,i.state=6,i.timer.stop(),i.on.call(r?"interrupt":"cancel",n,n.__data__,i.index,i.group),delete e[s]):o=!1;o&&delete n.__transition}}function GHe(n,t){var e,i;return function(){var r=ha(this,n),o=r.tween;if(o!==e)for(var s=0,a=(i=e=o).length;s<a;++s)if(i[s].name===t){(i=i.slice()).splice(s,1);break}r.tween=i}}function WHe(n,t,e){var i,r;if("function"!=typeof e)throw new Error;return function(){var o=ha(this,n),s=o.tween;if(s!==i){r=(i=s).slice();for(var a={name:t,value:e},l=0,c=r.length;l<c;++l)if(r[l].name===t){r[l]=a;break}l===c&&r.push(a)}o.tween=r}}function by(n,t,e){var i=n._id;return n.each(function(){var r=ha(this,i);(r.value||(r.value={}))[t]=e.apply(this,arguments)}),function(r){return Xo(r,i).value[t]}}function XR(n,t){var e;return("number"==typeof t?Cs:t instanceof ru?bg:(e=ru(t))?(t=e,bg):Kw)(n,t)}function qHe(n){return function(){this.removeAttribute(n)}}function YHe(n){return function(){this.removeAttributeNS(n.space,n.local)}}function XHe(n,t,e){var i,o,r=e+"";return function(){var s=this.getAttribute(n);return s===r?null:s===i?o:o=t(i=s,e)}}function QHe(n,t,e){var i,o,r=e+"";return function(){var s=this.getAttributeNS(n.space,n.local);return s===r?null:s===i?o:o=t(i=s,e)}}function KHe(n,t,e){var i,r,o;return function(){var s,l,a=e(this);return null==a?void this.removeAttribute(n):(s=this.getAttribute(n))===(l=a+"")?null:s===i&&l===r?o:(r=l,o=t(i=s,a))}}function ZHe(n,t,e){var i,r,o;return function(){var s,l,a=e(this);return null==a?void this.removeAttributeNS(n.space,n.local):(s=this.getAttributeNS(n.space,n.local))===(l=a+"")?null:s===i&&l===r?o:(r=l,o=t(i=s,a))}}function JHe(n,t){return function(e){this.setAttribute(n,t.call(this,e))}}function $He(n,t){return function(e){this.setAttributeNS(n.space,n.local,t.call(this,e))}}function eUe(n,t){var e,i;function r(){var o=t.apply(this,arguments);return o!==i&&(e=(i=o)&&$He(n,o)),e}return r._value=t,r}function tUe(n,t){var e,i;function r(){var o=t.apply(this,arguments);return o!==i&&(e=(i=o)&&JHe(n,o)),e}return r._value=t,r}function nUe(n,t){return function(){rS(this,n).delay=+t.apply(this,arguments)}}function iUe(n,t){return t=+t,function(){rS(this,n).delay=t}}function rUe(n,t){return function(){ha(this,n).duration=+t.apply(this,arguments)}}function oUe(n,t){return t=+t,function(){ha(this,n).duration=t}}function sUe(n,t){if("function"!=typeof t)throw new Error;return function(){ha(this,n).ease=t}}function lUe(n,t,e){var i,r,o=function(n){return(n+"").trim().split(/^|\s+/).every(function(t){var e=t.indexOf(".");return e>=0&&(t=t.slice(0,e)),!t||"start"===t})}(t)?rS:ha;return function(){var s=o(this,n),a=s.on;a!==i&&(r=(i=a).copy()).on(t,e),s.on=r}}var uUe=pp.prototype.constructor;function ile(n){return function(){this.style.removeProperty(n)}}function mUe(n,t,e){return function(i){this.style.setProperty(n,t.call(this,i),e)}}function gUe(n,t,e){var i,r;function o(){var s=t.apply(this,arguments);return s!==r&&(i=(r=s)&&mUe(n,s,e)),i}return o._value=t,o}function yUe(n){return function(t){this.textContent=n.call(this,t)}}function bUe(n){var t,e;function i(){var r=n.apply(this,arguments);return r!==e&&(t=(e=r)&&yUe(r)),t}return i._value=n,i}var xUe=0;function Us(n,t,e,i){this._groups=n,this._parents=t,this._name=e,this._id=i}function QR(){return++xUe}var xy=pp.prototype;Us.prototype=function(n){return pp().transition(n)}.prototype={constructor:Us,select:function(n){var t=this._name,e=this._id;"function"!=typeof n&&(n=gg(n));for(var i=this._groups,r=i.length,o=new Array(r),s=0;s<r;++s)for(var u,d,a=i[s],l=a.length,c=o[s]=new Array(l),p=0;p<l;++p)(u=a[p])&&(d=n.call(u,u.__data__,p,a))&&("__data__"in u&&(d.__data__=u.__data__),c[p]=d,$h(c[p],t,e,p,c,Xo(u,e)));return new Us(o,this._parents,t,e)},selectAll:function(n){var t=this._name,e=this._id;"function"!=typeof n&&(n=Ww(n));for(var i=this._groups,r=i.length,o=[],s=[],a=0;a<r;++a)for(var u,l=i[a],c=l.length,d=0;d<c;++d)if(u=l[d]){for(var h,p=n.call(u,u.__data__,d,l),f=Xo(u,e),m=0,x=p.length;m<x;++m)(h=p[m])&&$h(h,t,e,m,p,f);o.push(p),s.push(u)}return new Us(o,s,t,e)},filter:function(n){"function"!=typeof n&&(n=qw(n));for(var t=this._groups,e=t.length,i=new Array(e),r=0;r<e;++r)for(var l,o=t[r],s=o.length,a=i[r]=[],c=0;c<s;++c)(l=o[c])&&n.call(l,l.__data__,c,o)&&a.push(l);return new Us(i,this._parents,this._name,this._id)},merge:function(n){if(n._id!==this._id)throw new Error;for(var t=this._groups,e=n._groups,i=t.length,o=Math.min(i,e.length),s=new Array(i),a=0;a<o;++a)for(var p,l=t[a],c=e[a],u=l.length,d=s[a]=new Array(u),h=0;h<u;++h)(p=l[h]||c[h])&&(d[h]=p);for(;a<i;++a)s[a]=t[a];return new Us(s,this._parents,this._name,this._id)},selection:function(){return new uUe(this._groups,this._parents)},transition:function(){for(var n=this._name,t=this._id,e=QR(),i=this._groups,r=i.length,o=0;o<r;++o)for(var l,s=i[o],a=s.length,c=0;c<a;++c)if(l=s[c]){var u=Xo(l,t);$h(l,n,e,c,s,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new Us(i,this._parents,n,e)},call:xy.call,nodes:xy.nodes,node:xy.node,size:xy.size,empty:xy.empty,each:xy.each,on:function(n,t){var e=this._id;return arguments.length<2?Xo(this.node(),e).on.on(n):this.each(lUe(e,n,t))},attr:function(n,t){var e=dp(n),i="transform"===e?uz:XR;return this.attrTween(n,"function"==typeof t?(e.local?ZHe:KHe)(e,i,by(this,"attr."+n,t)):null==t?(e.local?YHe:qHe)(e):(e.local?QHe:XHe)(e,i,t))},attrTween:function(n,t){var e="attr."+n;if(arguments.length<2)return(e=this.tween(e))&&e._value;if(null==t)return this.tween(e,null);if("function"!=typeof t)throw new Error;var i=dp(n);return this.tween(e,(i.local?eUe:tUe)(i,t))},style:function(n,t,e){var i="transform"==(n+="")?cz:XR;return null==t?this.styleTween(n,function(n,t){var e,i,r;return function(){var o=Zh(this,n),s=(this.style.removeProperty(n),Zh(this,n));return o===s?null:o===e&&s===i?r:r=t(e=o,i=s)}}(n,i)).on("end.style."+n,ile(n)):"function"==typeof t?this.styleTween(n,function(n,t,e){var i,r,o;return function(){var s=Zh(this,n),a=e(this),l=a+"";return null==a&&(this.style.removeProperty(n),l=a=Zh(this,n)),s===l?null:s===i&&l===r?o:(r=l,o=t(i=s,a))}}(n,i,by(this,"style."+n,t))).each(function(n,t){var e,i,r,a,o="style."+t,s="end."+o;return function(){var l=ha(this,n),c=l.on,u=null==l.value[o]?a||(a=ile(t)):void 0;(c!==e||r!==u)&&(i=(e=c).copy()).on(s,r=u),l.on=i}}(this._id,n)):this.styleTween(n,function(n,t,e){var i,o,r=e+"";return function(){var s=Zh(this,n);return s===r?null:s===i?o:o=t(i=s,e)}}(n,i,t),e).on("end.style."+n,null)},styleTween:function(n,t,e){var i="style."+(n+="");if(arguments.length<2)return(i=this.tween(i))&&i._value;if(null==t)return this.tween(i,null);if("function"!=typeof t)throw new Error;return this.tween(i,gUe(n,t,e??""))},text:function(n){return this.tween("text","function"==typeof n?function(n){return function(){var t=n(this);this.textContent=t??""}}(by(this,"text",n)):function(n){return function(){this.textContent=n}}(null==n?"":n+""))},textTween:function(n){var t="text";if(arguments.length<1)return(t=this.tween(t))&&t._value;if(null==n)return this.tween(t,null);if("function"!=typeof n)throw new Error;return this.tween(t,bUe(n))},remove:function(){return this.on("end.remove",function(n){return function(){var t=this.parentNode;for(var e in this.__transition)if(+e!==n)return;t&&t.removeChild(this)}}(this._id))},tween:function(n,t){var e=this._id;if(n+="",arguments.length<2){for(var s,i=Xo(this.node(),e).tween,r=0,o=i.length;r<o;++r)if((s=i[r]).name===n)return s.value;return null}return this.each((null==t?GHe:WHe)(e,n,t))},delay:function(n){var t=this._id;return arguments.length?this.each(("function"==typeof n?nUe:iUe)(t,n)):Xo(this.node(),t).delay},duration:function(n){var t=this._id;return arguments.length?this.each(("function"==typeof n?rUe:oUe)(t,n)):Xo(this.node(),t).duration},ease:function(n){var t=this._id;return arguments.length?this.each(sUe(t,n)):Xo(this.node(),t).ease},end:function(){var n,t,e=this,i=e._id,r=e.size();return new Promise(function(o,s){var a={value:s},l={value:function(){0==--r&&o()}};e.each(function(){var c=ha(this,i),u=c.on;u!==n&&((t=(n=u).copy())._.cancel.push(a),t._.interrupt.push(a),t._.end.push(l)),c.on=t})})}};var gz={time:null,delay:0,duration:250,ease:function(n){return((n*=2)<=1?n*n*n:(n-=2)*n*n+2)/2}};function CUe(n,t){for(var e;!(e=n.__transition)||!(e=e[t]);)if(!(n=n.parentNode))return gz.time=yy(),gz;return e}function ZR(n){return function(){return n}}function dle(n,t,e){this.target=n,this.type=t,this.selection=e}function _z(){si.stopImmediatePropagation()}function JR(){si.preventDefault(),si.stopImmediatePropagation()}pp.prototype.interrupt=function(n){return this.each(function(){Cg(this,n)})},pp.prototype.transition=function(n){var t,e;n instanceof Us?(t=n._id,n=n._name):(t=QR(),(e=gz).time=yy(),n=null==n?null:n+"");for(var i=this._groups,r=i.length,o=0;o<r;++o)for(var l,s=i[o],a=s.length,c=0;c<a;++c)(l=s[c])&&$h(l,n,t,c,s,e||CUe(l,t));return new Us(i,this._parents,n,t)};var ple={name:"drag"},vz={name:"space"},Cy={name:"handle"},My={name:"center"};function hle(n){return[+n[0],+n[1]]}function xz(n){return[hle(n[0]),hle(n[1])]}function MUe(n){return function(t){return function(n,t,e){arguments.length<3&&(e=t,t=PR().changedTouches);for(var o,i=0,r=t?t.length:0;i<r;++i)if((o=t[i]).identifier===e)return RR(n,o);return null}(t,si.touches,n)}}var yz={name:"x",handles:["w","e"].map(oS),input:function(n,t){return null==n?null:[[+n[0],t[0][1]],[+n[1],t[1][1]]]},output:function(n){return n&&[n[0][0],n[1][0]]}},$R={name:"y",handles:["n","s"].map(oS),input:function(n,t){return null==n?null:[[t[0][0],+n[0]],[t[1][0],+n[1]]]},output:function(n){return n&&[n[0][1],n[1][1]]}},mp=(["n","w","e","s","nw","ne","sw","se"].map(oS),{overlay:"crosshair",selection:"move",n:"ns-resize",e:"ew-resize",s:"ns-resize",w:"ew-resize",nw:"nwse-resize",ne:"nesw-resize",se:"nwse-resize",sw:"nesw-resize"}),fle={e:"w",w:"e",nw:"ne",ne:"nw",se:"sw",sw:"se"},mle={n:"s",s:"n",nw:"sw",ne:"se",se:"ne",sw:"nw"},wUe={overlay:1,selection:1,n:null,e:1,s:null,w:-1,nw:-1,ne:1,se:1,sw:-1},SUe={overlay:1,selection:1,n:-1,e:null,s:1,w:null,nw:-1,ne:-1,se:1,sw:1};function oS(n){return{type:n}}function EUe(){return!si.ctrlKey&&!si.button}function TUe(){var n=this.ownerSVGElement||this;return n.hasAttribute("viewBox")?[[(n=n.viewBox.baseVal).x,n.y],[n.x+n.width,n.y+n.height]]:[[0,0],[n.width.baseVal.value,n.height.baseVal.value]]}function DUe(){return navigator.maxTouchPoints||"ontouchstart"in this}function bz(n){for(;!n.__brush;)if(!(n=n.parentNode))return;return n.__brush}function AUe(n){return n[0][0]===n[1][0]||n[0][1]===n[1][1]}Math;var Mz=Math.PI,wz=2*Mz,Mg=1e-6,kUe=wz-Mg;function Sz(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function _le(){return new Sz}Sz.prototype=_le.prototype={constructor:Sz,moveTo:function(n,t){this._+="M"+(this._x0=this._x1=+n)+","+(this._y0=this._y1=+t)},closePath:function(){null!==this._x1&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(n,t){this._+="L"+(this._x1=+n)+","+(this._y1=+t)},quadraticCurveTo:function(n,t,e,i){this._+="Q"+ +n+","+ +t+","+(this._x1=+e)+","+(this._y1=+i)},bezierCurveTo:function(n,t,e,i,r,o){this._+="C"+ +n+","+ +t+","+ +e+","+ +i+","+(this._x1=+r)+","+(this._y1=+o)},arcTo:function(n,t,e,i,r){var o=this._x1,s=this._y1,a=(e=+e)-(n=+n),l=(i=+i)-(t=+t),c=o-n,u=s-t,d=c*c+u*u;if((r=+r)<0)throw new Error("negative radius: "+r);if(null===this._x1)this._+="M"+(this._x1=n)+","+(this._y1=t);else if(d>Mg)if(Math.abs(u*a-l*c)>Mg&&r){var p=e-o,h=i-s,f=a*a+l*l,m=p*p+h*h,x=Math.sqrt(f),g=Math.sqrt(d),b=r*Math.tan((Mz-Math.acos((f+d-m)/(2*x*g)))/2),D=b/g,T=b/x;Math.abs(D-1)>Mg&&(this._+="L"+(n+D*c)+","+(t+D*u)),this._+="A"+r+","+r+",0,0,"+ +(u*p>c*h)+","+(this._x1=n+T*a)+","+(this._y1=t+T*l)}else this._+="L"+(this._x1=n)+","+(this._y1=t)},arc:function(n,t,e,i,r,o){n=+n,t=+t,o=!!o;var s=(e=+e)*Math.cos(i),a=e*Math.sin(i),l=n+s,c=t+a,u=1^o,d=o?i-r:r-i;if(e<0)throw new Error("negative radius: "+e);null===this._x1?this._+="M"+l+","+c:(Math.abs(this._x1-l)>Mg||Math.abs(this._y1-c)>Mg)&&(this._+="L"+l+","+c),e&&(d<0&&(d=d%wz+wz),d>kUe?this._+="A"+e+","+e+",0,1,"+u+","+(n-s)+","+(t-a)+"A"+e+","+e+",0,1,"+u+","+(this._x1=l)+","+(this._y1=c):d>Mg&&(this._+="A"+e+","+e+",0,"+ +(d>=Mz)+","+u+","+(this._x1=n+e*Math.cos(r))+","+(this._y1=t+e*Math.sin(r))))},rect:function(n,t,e,i){this._+="M"+(this._x0=this._x1=+n)+","+(this._y0=this._y1=+t)+"h"+ +e+"v"+ +i+"h"+-e+"Z"},toString:function(){return this._}};var sS=_le,Ml="$";function eO(){}function vle(n,t){var e=new eO;if(n instanceof eO)n.each(function(a,l){e.set(l,a)});else if(Array.isArray(n)){var o,i=-1,r=n.length;if(null==t)for(;++i<r;)e.set(i,n[i]);else for(;++i<r;)e.set(t(o=n[i],i,n),o)}else if(n)for(var s in n)e.set(s,n[s]);return e}eO.prototype=vle.prototype={constructor:eO,has:function(n){return Ml+n in this},get:function(n){return this[Ml+n]},set:function(n,t){return this[Ml+n]=t,this},remove:function(n){var t=Ml+n;return t in this&&delete this[t]},clear:function(){for(var n in this)n[0]===Ml&&delete this[n]},keys:function(){var n=[];for(var t in this)t[0]===Ml&&n.push(t.slice(1));return n},values:function(){var n=[];for(var t in this)t[0]===Ml&&n.push(this[t]);return n},entries:function(){var n=[];for(var t in this)t[0]===Ml&&n.push({key:t.slice(1),value:this[t]});return n},size:function(){var n=0;for(var t in this)t[0]===Ml&&++n;return n},empty:function(){for(var n in this)if(n[0]===Ml)return!1;return!0},each:function(n){for(var t in this)t[0]===Ml&&n(this[t],t.slice(1),this)}};var gp=vle;function tO(){}var wg=gp.prototype;function Sg(n,t){if((e=(n=t?n.toExponential(t-1):n.toExponential()).indexOf("e"))<0)return null;var e,i=n.slice(0,e);return[i.length>1?i[0]+i.slice(2):i,+n.slice(e+1)]}function Cd(n){return(n=Sg(Math.abs(n)))?n[1]:NaN}tO.prototype=function(n,t){var e=new tO;if(n instanceof tO)n.each(function(o){e.add(o)});else if(n){var i=-1,r=n.length;if(null==t)for(;++i<r;)e.add(n[i]);else for(;++i<r;)e.add(t(n[i],i,n))}return e}.prototype={constructor:tO,has:wg.has,add:function(n){return this[Ml+(n+="")]=n,this},remove:wg.remove,clear:wg.clear,values:wg.keys,size:wg.size,empty:wg.empty,each:wg.each},Math,Math.sqrt(5);var Ez,VUe=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function ef(n){if(!(t=VUe.exec(n)))throw new Error("invalid format: "+n);var t;return new nO({fill:t[1],align:t[2],sign:t[3],symbol:t[4],zero:t[5],width:t[6],comma:t[7],precision:t[8]&&t[8].slice(1),trim:t[9],type:t[10]})}function nO(n){this.fill=void 0===n.fill?" ":n.fill+"",this.align=void 0===n.align?">":n.align+"",this.sign=void 0===n.sign?"-":n.sign+"",this.symbol=void 0===n.symbol?"":n.symbol+"",this.zero=!!n.zero,this.width=void 0===n.width?void 0:+n.width,this.comma=!!n.comma,this.precision=void 0===n.precision?void 0:+n.precision,this.trim=!!n.trim,this.type=void 0===n.type?"":n.type+""}function Tz(n,t){var e=Sg(n,t);if(!e)return n+"";var i=e[0],r=e[1];return r<0?"0."+new Array(-r).join("0")+i:i.length>r+1?i.slice(0,r+1)+"."+i.slice(r+1):i+new Array(r-i.length+2).join("0")}ef.prototype=nO.prototype,nO.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(void 0===this.width?"":Math.max(1,0|this.width))+(this.comma?",":"")+(void 0===this.precision?"":"."+Math.max(0,0|this.precision))+(this.trim?"~":"")+this.type};var Dz={"%":function(n,t){return(100*n).toFixed(t)},b:function(n){return Math.round(n).toString(2)},c:function(n){return n+""},d:function(n){return Math.abs(n=Math.round(n))>=1e21?n.toLocaleString("en").replace(/,/g,""):n.toString(10)},e:function(n,t){return n.toExponential(t)},f:function(n,t){return n.toFixed(t)},g:function(n,t){return n.toPrecision(t)},o:function(n){return Math.round(n).toString(8)},p:function(n,t){return Tz(100*n,t)},r:Tz,s:function(n,t){var e=Sg(n,t);if(!e)return n+"";var i=e[0],r=e[1],o=r-(Ez=3*Math.max(-8,Math.min(8,Math.floor(r/3))))+1,s=i.length;return o===s?i:o>s?i+new Array(o-s+1).join("0"):o>0?i.slice(0,o)+"."+i.slice(o):"0."+new Array(1-o).join("0")+Sg(n,Math.max(0,t+o-1))[0]},X:function(n){return Math.round(n).toString(16).toUpperCase()},x:function(n){return Math.round(n).toString(16)}};function Az(n){return n}var iO,xo,rO,Ele=Array.prototype.map,Tle=["y","z","a","f","p","n","\xb5","m","","k","M","G","T","P","E","Z","Y"];function dc(){return Math.random()}iO=function(n){var t=void 0===n.grouping||void 0===n.thousands?Az:function(n,t){return function(e,i){for(var r=e.length,o=[],s=0,a=n[0],l=0;r>0&&a>0&&(l+a+1>i&&(a=Math.max(1,i-l)),o.push(e.substring(r-=a,r+a)),!((l+=a+1)>i));)a=n[s=(s+1)%n.length];return o.reverse().join(t)}}(Ele.call(n.grouping,Number),n.thousands+""),e=void 0===n.currency?"":n.currency[0]+"",i=void 0===n.currency?"":n.currency[1]+"",r=void 0===n.decimal?".":n.decimal+"",o=void 0===n.numerals?Az:function(n){return function(t){return t.replace(/[0-9]/g,function(e){return n[+e]})}}(Ele.call(n.numerals,String)),s=void 0===n.percent?"%":n.percent+"",a=void 0===n.minus?"-":n.minus+"",l=void 0===n.nan?"NaN":n.nan+"";function c(d){var p=(d=ef(d)).fill,h=d.align,f=d.sign,m=d.symbol,x=d.zero,g=d.width,b=d.comma,D=d.precision,T=d.trim,k=d.type;"n"===k?(b=!0,k="g"):Dz[k]||(void 0===D&&(D=12),T=!0,k="g"),(x||"0"===p&&"="===h)&&(x=!0,p="0",h="=");var Z="$"===m?e:"#"===m&&/[boxX]/.test(k)?"0"+k.toLowerCase():"",z="$"===m?i:/[%p]/.test(k)?s:"",fe=Dz[k],ue=/[defgprs%]/.test(k);function he(w){var K,de,Y,F=Z,q=z;if("c"===k)q=fe(w)+q,w="";else{var ae=(w=+w)<0||1/w<0;if(w=isNaN(w)?l:fe(Math.abs(w),D),T&&(w=function(n){e:for(var r,t=n.length,e=1,i=-1;e<t;++e)switch(n[e]){case".":i=r=e;break;case"0":0===i&&(i=e),r=e;break;default:if(!+n[e])break e;i>0&&(i=0)}return i>0?n.slice(0,i)+n.slice(r+1):n}(w)),ae&&0==+w&&"+"!==f&&(ae=!1),F=(ae?"("===f?f:a:"-"===f||"("===f?"":f)+F,q=("s"===k?Tle[8+Ez/3]:"")+q+(ae&&"("===f?")":""),ue)for(K=-1,de=w.length;++K<de;)if(48>(Y=w.charCodeAt(K))||Y>57){q=(46===Y?r+w.slice(K+1):w.slice(K))+q,w=w.slice(0,K);break}}b&&!x&&(w=t(w,1/0));var le=F.length+w.length+q.length,Ie=le<g?new Array(g-le+1).join(p):"";switch(b&&x&&(w=t(Ie+w,Ie.length?g-q.length:1/0),Ie=""),h){case"<":w=F+w+q+Ie;break;case"=":w=F+Ie+w+q;break;case"^":w=Ie.slice(0,le=Ie.length>>1)+F+w+q+Ie.slice(le);break;default:w=Ie+F+w+q}return o(w)}return D=void 0===D?6:/[gprs]/.test(k)?Math.max(1,Math.min(21,D)):Math.max(0,Math.min(20,D)),he.toString=function(){return d+""},he}return{format:c,formatPrefix:function(d,p){var h=c(((d=ef(d)).type="f",d)),f=3*Math.max(-8,Math.min(8,Math.floor(Cd(p)/3))),m=Math.pow(10,-f),x=Tle[8+f/3];return function(g){return h(m*g)+x}}}}({decimal:".",thousands:",",grouping:[3],currency:["$",""],minus:"-"}),xo=iO.format,rO=iO.formatPrefix,function n(t){function e(i,r){return i=null==i?0:+i,r=null==r?1:+r,1===arguments.length?(r=i,i=0):r-=i,function(){return t()*r+i}}return e.source=n,e}(dc);var kz=function n(t){function e(i,r){var o,s;return i=null==i?0:+i,r=null==r?1:+r,function(){var a;if(null!=o)a=o,o=null;else do{o=2*t()-1,a=2*t()-1,s=o*o+a*a}while(!s||s>1);return i+r*a*Math.sqrt(-2*Math.log(s)/s)}}return e.source=n,e}(dc),Fz=(function n(t){function e(){var i=kz.source(t).apply(this,arguments);return function(){return Math.exp(i())}}return e.source=n,e}(dc),function n(t){function e(i){return function(){for(var r=0,o=0;o<i;++o)r+=t();return r}}return e.source=n,e}(dc));function zs(n,t){switch(arguments.length){case 0:break;case 1:this.range(n);break;default:this.range(t).domain(n)}return this}(function n(t){function e(i){var r=Fz.source(t)(i);return function(){return r()/i}}return e.source=n,e})(dc),function n(t){function e(i){return function(){return-Math.log(1-t())/i}}return e.source=n,e}(dc);var Ale=Array.prototype,lS=Ale.map,tf=Ale.slice,Nz={name:"implicit"};function cS(){var n=gp(),t=[],e=[],i=Nz;function r(o){var s=o+"",a=n.get(s);if(!a){if(i!==Nz)return i;n.set(s,a=t.push(o))}return e[(a-1)%e.length]}return r.domain=function(o){if(!arguments.length)return t.slice();t=[],n=gp();for(var l,c,s=-1,a=o.length;++s<a;)n.has(c=(l=o[s])+"")||n.set(c,t.push(l));return r},r.range=function(o){return arguments.length?(e=tf.call(o),r):e.slice()},r.unknown=function(o){return arguments.length?(i=o,r):i},r.copy=function(){return cS(t,e).unknown(i)},zs.apply(r,arguments),r}function wy(){var r,o,n=cS().unknown(void 0),t=n.domain,e=n.range,i=[0,1],s=!1,a=0,l=0,c=.5;function u(){var d=t().length,p=i[1]<i[0],h=i[p-0],f=i[1-p];r=(f-h)/Math.max(1,d-a+2*l),s&&(r=Math.floor(r)),h+=(f-h-r*(d-a))*c,o=r*(1-a),s&&(h=Math.round(h),o=Math.round(o));var m=Kh(d).map(function(x){return h+r*x});return e(p?m.reverse():m)}return delete n.unknown,n.domain=function(d){return arguments.length?(t(d),u()):t()},n.range=function(d){return arguments.length?(i=[+d[0],+d[1]],u()):i.slice()},n.rangeRound=function(d){return i=[+d[0],+d[1]],s=!0,u()},n.bandwidth=function(){return o},n.step=function(){return r},n.round=function(d){return arguments.length?(s=!!d,u()):s},n.padding=function(d){return arguments.length?(a=Math.min(1,l=+d),u()):a},n.paddingInner=function(d){return arguments.length?(a=Math.min(1,d),u()):a},n.paddingOuter=function(d){return arguments.length?(l=+d,u()):l},n.align=function(d){return arguments.length?(c=Math.max(0,Math.min(1,d)),u()):c},n.copy=function(){return wy(t(),i).round(s).paddingInner(a).paddingOuter(l).align(c)},zs.apply(u(),arguments)}function Ile(n){var t=n.copy;return n.padding=n.paddingOuter,delete n.paddingInner,delete n.paddingOuter,n.copy=function(){return Ile(t())},n}function Sy(){return Ile(wy.apply(null,arguments).paddingInner(1))}function Lz(n){return+n}var Rle=[0,1];function ja(n){return n}function Bz(n,t){return(t-=n=+n)?function(e){return(e-n)/t}:function(n){return function(){return n}}(isNaN(t)?NaN:.5)}function Ole(n){var i,t=n[0],e=n[n.length-1];return t>e&&(i=t,t=e,e=i),function(r){return Math.max(t,Math.min(e,r))}}function GUe(n,t,e){var i=n[0],r=n[1],o=t[0],s=t[1];return r<i?(i=Bz(r,i),o=e(s,o)):(i=Bz(i,r),o=e(o,s)),function(a){return o(i(a))}}function WUe(n,t,e){var i=Math.min(n.length,t.length)-1,r=new Array(i),o=new Array(i),s=-1;for(n[i]<n[0]&&(n=n.slice().reverse(),t=t.slice().reverse());++s<i;)r[s]=Bz(n[s],n[s+1]),o[s]=e(t[s],t[s+1]);return function(a){var l=iu(n,a,1,i)-1;return o[l](r[l](a))}}function nf(n,t){return t.domain(n.domain()).range(n.range()).interpolate(n.interpolate()).clamp(n.clamp()).unknown(n.unknown())}function uS(){var i,r,o,a,l,c,n=Rle,t=Rle,e=fp,s=ja;function u(){return a=Math.min(n.length,t.length)>2?WUe:GUe,l=c=null,d}function d(p){return isNaN(p=+p)?o:(l||(l=a(n.map(i),t,e)))(i(s(p)))}return d.invert=function(p){return s(r((c||(c=a(t,n.map(i),Cs)))(p)))},d.domain=function(p){return arguments.length?(n=lS.call(p,Lz),s===ja||(s=Ole(n)),u()):n.slice()},d.range=function(p){return arguments.length?(t=tf.call(p),u()):t.slice()},d.rangeRound=function(p){return t=tf.call(p),e=sz,u()},d.clamp=function(p){return arguments.length?(s=p?Ole(n):ja,d):s!==ja},d.interpolate=function(p){return arguments.length?(e=p,u()):e},d.unknown=function(p){return arguments.length?(o=p,d):o},function(p,h){return i=p,r=h,u()}}function dS(n,t){return uS()(n,t)}function Eg(n){var t=n.domain;return n.ticks=function(e){var i=t();return Hw(i[0],i[i.length-1],e??10)},n.tickFormat=function(e,i){var r=t();return function(n,t,e,i){var o,r=vd(n,t,e);switch((i=ef(i??",f")).type){case"s":var s=Math.max(Math.abs(n),Math.abs(t));return null==i.precision&&!isNaN(o=function(n,t){return Math.max(0,3*Math.max(-8,Math.min(8,Math.floor(Cd(t)/3)))-Cd(Math.abs(n)))}(r,s))&&(i.precision=o),rO(i,s);case"":case"e":case"g":case"p":case"r":null==i.precision&&!isNaN(o=function(n,t){return n=Math.abs(n),t=Math.abs(t)-n,Math.max(0,Cd(t)-Cd(n))+1}(r,Math.max(Math.abs(n),Math.abs(t))))&&(i.precision=o-("e"===i.type));break;case"f":case"%":null==i.precision&&!isNaN(o=function(n){return Math.max(0,-Cd(Math.abs(n)))}(r))&&(i.precision=o-2*("%"===i.type))}return xo(i)}(r[0],r[r.length-1],e??10,i)},n.nice=function(e){null==e&&(e=10);var l,i=t(),r=0,o=i.length-1,s=i[r],a=i[o];return a<s&&(l=s,s=a,a=l,l=r,r=o,o=l),(l=py(s,a,e))>0?l=py(s=Math.floor(s/l)*l,a=Math.ceil(a/l)*l,e):l<0&&(l=py(s=Math.ceil(s*l)/l,a=Math.floor(a*l)/l,e)),l>0?(i[r]=Math.floor(s/l)*l,i[o]=Math.ceil(a/l)*l,t(i)):l<0&&(i[r]=Math.ceil(s*l)/l,i[o]=Math.floor(a*l)/l,t(i)),n},n}function Qo(){var n=dS(ja,ja);return n.copy=function(){return nf(n,Qo())},zs.apply(n,arguments),Eg(n)}function oO(n,t){var s,e=0,i=(n=n.slice()).length-1,r=n[e],o=n[i];return o<r&&(s=e,e=i,i=s,s=r,r=o,o=s),n[e]=t.floor(r),n[i]=t.ceil(o),n}function kle(n){return Math.log(n)}function Fle(n){return Math.exp(n)}function qUe(n){return-Math.log(-n)}function YUe(n){return-Math.exp(-n)}function XUe(n){return isFinite(n)?+("1e"+n):n<0?0:n}function Nle(n){return function(t){return-n(-t)}}function Hz(n){var r,o,t=n(kle,Fle),e=t.domain,i=10;function s(){return r=function(n){return n===Math.E?Math.log:10===n&&Math.log10||2===n&&Math.log2||(n=Math.log(n),function(t){return Math.log(t)/n})}(i),o=function(n){return 10===n?XUe:n===Math.E?Math.exp:function(t){return Math.pow(n,t)}}(i),e()[0]<0?(r=Nle(r),o=Nle(o),n(qUe,YUe)):n(kle,Fle),t}return t.base=function(a){return arguments.length?(i=+a,s()):i},t.domain=function(a){return arguments.length?(e(a),s()):e()},t.ticks=function(a){var d,l=e(),c=l[0],u=l[l.length-1];(d=u<c)&&(p=c,c=u,u=p);var f,m,x,p=r(c),h=r(u),g=null==a?10:+a,b=[];if(!(i%1)&&h-p<g){if(p=Math.round(p)-1,h=Math.round(h)+1,c>0){for(;p<h;++p)for(m=1,f=o(p);m<i;++m)if(!((x=f*m)<c)){if(x>u)break;b.push(x)}}else for(;p<h;++p)for(m=i-1,f=o(p);m>=1;--m)if(!((x=f*m)<c)){if(x>u)break;b.push(x)}}else b=Hw(p,h,Math.min(h-p,g)).map(o);return d?b.reverse():b},t.tickFormat=function(a,l){if(null==l&&(l=10===i?".0e":","),"function"!=typeof l&&(l=xo(l)),a===1/0)return l;null==a&&(a=10);var c=Math.max(1,i*a/t.ticks().length);return function(u){var d=u/o(Math.round(r(u)));return d*i<i-.5&&(d*=i),d<=c?l(u):""}},t.nice=function(){return e(oO(e(),{floor:function(a){return o(Math.floor(r(a)))},ceil:function(a){return o(Math.ceil(r(a)))}}))},t}function pS(){var n=Hz(uS()).domain([1,10]);return n.copy=function(){return nf(n,pS()).base(n.base())},zs.apply(n,arguments),n}var Uz=new Date,zz=new Date;function yr(n,t,e,i){function r(o){return n(o=0===arguments.length?new Date:new Date(+o)),o}return r.floor=function(o){return n(o=new Date(+o)),o},r.ceil=function(o){return n(o=new Date(o-1)),t(o,1),n(o),o},r.round=function(o){var s=r(o),a=r.ceil(o);return o-s<a-o?s:a},r.offset=function(o,s){return t(o=new Date(+o),null==s?1:Math.floor(s)),o},r.range=function(o,s,a){var c,l=[];if(o=r.ceil(o),a=null==a?1:Math.floor(a),!(o<s&&a>0))return l;do{l.push(c=new Date(+o)),t(o,a),n(o)}while(c<o&&o<s);return l},r.filter=function(o){return yr(function(s){if(s>=s)for(;n(s),!o(s);)s.setTime(s-1)},function(s,a){if(s>=s)if(a<0)for(;++a<=0;)for(;t(s,-1),!o(s););else for(;--a>=0;)for(;t(s,1),!o(s););})},e&&(r.count=function(o,s){return Uz.setTime(+o),zz.setTime(+s),n(Uz),n(zz),Math.floor(e(Uz,zz))},r.every=function(o){return o=Math.floor(o),isFinite(o)&&o>0?o>1?r.filter(i?function(s){return i(s)%o==0}:function(s){return r.count(0,s)%o==0}):r:null}),r}var sO=yr(function(){},function(n,t){n.setTime(+n+t)},function(n,t){return t-n});sO.every=function(n){return n=Math.floor(n),isFinite(n)&&n>0?n>1?yr(function(t){t.setTime(Math.floor(t/n)*n)},function(t,e){t.setTime(+t+e*n)},function(t,e){return(e-t)/n}):sO:null};var aO=sO,_p=6e4,cO=6048e5,Ble=yr(function(n){n.setTime(n-n.getMilliseconds())},function(n,t){n.setTime(+n+1e3*t)},function(n,t){return(t-n)/1e3},function(n){return n.getUTCSeconds()}),uO=Ble,Hle=yr(function(n){n.setTime(n-n.getMilliseconds()-1e3*n.getSeconds())},function(n,t){n.setTime(+n+t*_p)},function(n,t){return(t-n)/_p},function(n){return n.getMinutes()}),Gz=Hle,Ule=yr(function(n){n.setTime(n-n.getMilliseconds()-1e3*n.getSeconds()-n.getMinutes()*_p)},function(n,t){n.setTime(+n+36e5*t)},function(n,t){return(t-n)/36e5},function(n){return n.getHours()}),Wz=Ule,zle=yr(function(n){n.setHours(0,0,0,0)},function(n,t){n.setDate(n.getDate()+t)},function(n,t){return(t-n-(t.getTimezoneOffset()-n.getTimezoneOffset())*_p)/864e5},function(n){return n.getDate()-1}),Ey=zle;function Dg(n){return yr(function(t){t.setDate(t.getDate()-(t.getDay()+7-n)%7),t.setHours(0,0,0,0)},function(t,e){t.setDate(t.getDate()+7*e)},function(t,e){return(e-t-(e.getTimezoneOffset()-t.getTimezoneOffset())*_p)/cO})}var Ag=Dg(0),Ty=Dg(1),rf=(Dg(2),Dg(3),Dg(4)),Xle=(Dg(5),Dg(6),yr(function(n){n.setDate(1),n.setHours(0,0,0,0)},function(n,t){n.setMonth(n.getMonth()+t)},function(n,t){return t.getMonth()-n.getMonth()+12*(t.getFullYear()-n.getFullYear())},function(n){return n.getMonth()})),qz=Xle,Yz=yr(function(n){n.setMonth(0,1),n.setHours(0,0,0,0)},function(n,t){n.setFullYear(n.getFullYear()+t)},function(n,t){return t.getFullYear()-n.getFullYear()},function(n){return n.getFullYear()});Yz.every=function(n){return isFinite(n=Math.floor(n))&&n>0?yr(function(t){t.setFullYear(Math.floor(t.getFullYear()/n)*n),t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,e){t.setFullYear(t.getFullYear()+e*n)}):null};var vp=Yz,Qle=yr(function(n){n.setUTCHours(0,0,0,0)},function(n,t){n.setUTCDate(n.getUTCDate()+t)},function(n,t){return(t-n)/864e5},function(n){return n.getUTCDate()-1}),dO=Qle;function Ig(n){return yr(function(t){t.setUTCDate(t.getUTCDate()-(t.getUTCDay()+7-n)%7),t.setUTCHours(0,0,0,0)},function(t,e){t.setUTCDate(t.getUTCDate()+7*e)},function(t,e){return(e-t)/cO})}var hS=Ig(0),Dy=Ig(1),of=(Ig(2),Ig(3),Ig(4)),Xz=(Ig(5),Ig(6),yr(function(n){n.setUTCMonth(0,1),n.setUTCHours(0,0,0,0)},function(n,t){n.setUTCFullYear(n.getUTCFullYear()+t)},function(n,t){return t.getUTCFullYear()-n.getUTCFullYear()},function(n){return n.getUTCFullYear()}));Xz.every=function(n){return isFinite(n=Math.floor(n))&&n>0?yr(function(t){t.setUTCFullYear(Math.floor(t.getUTCFullYear()/n)*n),t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,e){t.setUTCFullYear(t.getUTCFullYear()+e*n)}):null};var Pg=Xz;function Qz(n){if(0<=n.y&&n.y<100){var t=new Date(-1,n.m,n.d,n.H,n.M,n.S,n.L);return t.setFullYear(n.y),t}return new Date(n.y,n.m,n.d,n.H,n.M,n.S,n.L)}function Kz(n){if(0<=n.y&&n.y<100){var t=new Date(Date.UTC(-1,n.m,n.d,n.H,n.M,n.S,n.L));return t.setUTCFullYear(n.y),t}return new Date(Date.UTC(n.y,n.m,n.d,n.H,n.M,n.S,n.L))}function fS(n,t,e){return{y:n,m:t,d:e,H:0,M:0,S:0,L:0}}var Ay,Iy,tce={"-":"",_:" ",0:"0"},us=/^\s*\d+/,gze=/^%/,_ze=/[\\^$*+?|[\]().{}]/g;function Gi(n,t,e){var i=n<0?"-":"",r=(i?-n:n)+"",o=r.length;return i+(o<e?new Array(e-o+1).join(t)+r:r)}function vze(n){return n.replace(_ze,"\\$&")}function mS(n){return new RegExp("^(?:"+n.map(vze).join("|")+")","i")}function gS(n){for(var t={},e=-1,i=n.length;++e<i;)t[n[e].toLowerCase()]=e;return t}function yze(n,t,e){var i=us.exec(t.slice(e,e+1));return i?(n.w=+i[0],e+i[0].length):-1}function bze(n,t,e){var i=us.exec(t.slice(e,e+1));return i?(n.u=+i[0],e+i[0].length):-1}function xze(n,t,e){var i=us.exec(t.slice(e,e+2));return i?(n.U=+i[0],e+i[0].length):-1}function Cze(n,t,e){var i=us.exec(t.slice(e,e+2));return i?(n.V=+i[0],e+i[0].length):-1}function Mze(n,t,e){var i=us.exec(t.slice(e,e+2));return i?(n.W=+i[0],e+i[0].length):-1}function nce(n,t,e){var i=us.exec(t.slice(e,e+4));return i?(n.y=+i[0],e+i[0].length):-1}function ice(n,t,e){var i=us.exec(t.slice(e,e+2));return i?(n.y=+i[0]+(+i[0]>68?1900:2e3),e+i[0].length):-1}function wze(n,t,e){var i=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(t.slice(e,e+6));return i?(n.Z=i[1]?0:-(i[2]+(i[3]||"00")),e+i[0].length):-1}function Sze(n,t,e){var i=us.exec(t.slice(e,e+1));return i?(n.q=3*i[0]-3,e+i[0].length):-1}function Eze(n,t,e){var i=us.exec(t.slice(e,e+2));return i?(n.m=i[0]-1,e+i[0].length):-1}function rce(n,t,e){var i=us.exec(t.slice(e,e+2));return i?(n.d=+i[0],e+i[0].length):-1}function Tze(n,t,e){var i=us.exec(t.slice(e,e+3));return i?(n.m=0,n.d=+i[0],e+i[0].length):-1}function oce(n,t,e){var i=us.exec(t.slice(e,e+2));return i?(n.H=+i[0],e+i[0].length):-1}function Dze(n,t,e){var i=us.exec(t.slice(e,e+2));return i?(n.M=+i[0],e+i[0].length):-1}function Aze(n,t,e){var i=us.exec(t.slice(e,e+2));return i?(n.S=+i[0],e+i[0].length):-1}function Ize(n,t,e){var i=us.exec(t.slice(e,e+3));return i?(n.L=+i[0],e+i[0].length):-1}function Pze(n,t,e){var i=us.exec(t.slice(e,e+6));return i?(n.L=Math.floor(i[0]/1e3),e+i[0].length):-1}function Rze(n,t,e){var i=gze.exec(t.slice(e,e+1));return i?e+i[0].length:-1}function Oze(n,t,e){var i=us.exec(t.slice(e));return i?(n.Q=+i[0],e+i[0].length):-1}function kze(n,t,e){var i=us.exec(t.slice(e));return i?(n.s=+i[0],e+i[0].length):-1}function sce(n,t){return Gi(n.getDate(),t,2)}function Fze(n,t){return Gi(n.getHours(),t,2)}function Nze(n,t){return Gi(n.getHours()%12||12,t,2)}function Lze(n,t){return Gi(1+Ey.count(vp(n),n),t,3)}function dce(n,t){return Gi(n.getMilliseconds(),t,3)}function Bze(n,t){return dce(n,t)+"000"}function Vze(n,t){return Gi(n.getMonth()+1,t,2)}function Hze(n,t){return Gi(n.getMinutes(),t,2)}function Uze(n,t){return Gi(n.getSeconds(),t,2)}function zze(n){var t=n.getDay();return 0===t?7:t}function jze(n,t){return Gi(Ag.count(vp(n)-1,n),t,2)}function pce(n){var t=n.getDay();return t>=4||0===t?rf(n):rf.ceil(n)}function Gze(n,t){return n=pce(n),Gi(rf.count(vp(n),n)+(4===vp(n).getDay()),t,2)}function Wze(n){return n.getDay()}function qze(n,t){return Gi(Ty.count(vp(n)-1,n),t,2)}function Yze(n,t){return Gi(n.getFullYear()%100,t,2)}function Xze(n,t){return Gi((n=pce(n)).getFullYear()%100,t,2)}function Qze(n,t){return Gi(n.getFullYear()%1e4,t,4)}function Kze(n,t){var e=n.getDay();return Gi((n=e>=4||0===e?rf(n):rf.ceil(n)).getFullYear()%1e4,t,4)}function Zze(n){var t=n.getTimezoneOffset();return(t>0?"-":(t*=-1,"+"))+Gi(t/60|0,"0",2)+Gi(t%60,"0",2)}function ace(n,t){return Gi(n.getUTCDate(),t,2)}function Jze(n,t){return Gi(n.getUTCHours(),t,2)}function $ze(n,t){return Gi(n.getUTCHours()%12||12,t,2)}function eje(n,t){return Gi(1+dO.count(Pg(n),n),t,3)}function hce(n,t){return Gi(n.getUTCMilliseconds(),t,3)}function tje(n,t){return hce(n,t)+"000"}function nje(n,t){return Gi(n.getUTCMonth()+1,t,2)}function ije(n,t){return Gi(n.getUTCMinutes(),t,2)}function rje(n,t){return Gi(n.getUTCSeconds(),t,2)}function oje(n){var t=n.getUTCDay();return 0===t?7:t}function sje(n,t){return Gi(hS.count(Pg(n)-1,n),t,2)}function fce(n){var t=n.getUTCDay();return t>=4||0===t?of(n):of.ceil(n)}function aje(n,t){return n=fce(n),Gi(of.count(Pg(n),n)+(4===Pg(n).getUTCDay()),t,2)}function lje(n){return n.getUTCDay()}function cje(n,t){return Gi(Dy.count(Pg(n)-1,n),t,2)}function uje(n,t){return Gi(n.getUTCFullYear()%100,t,2)}function dje(n,t){return Gi((n=fce(n)).getUTCFullYear()%100,t,2)}function pje(n,t){return Gi(n.getUTCFullYear()%1e4,t,4)}function hje(n,t){var e=n.getUTCDay();return Gi((n=e>=4||0===e?of(n):of.ceil(n)).getUTCFullYear()%1e4,t,4)}function fje(){return"+0000"}function lce(){return"%"}function cce(n){return+n}function uce(n){return Math.floor(+n/1e3)}Ay=function(n){var t=n.dateTime,e=n.date,i=n.time,r=n.periods,o=n.days,s=n.shortDays,a=n.months,l=n.shortMonths,c=mS(r),u=gS(r),d=mS(o),p=gS(o),h=mS(s),f=gS(s),m=mS(a),x=gS(a),g=mS(l),b=gS(l),D={a:function(Te){return s[Te.getDay()]},A:function(Te){return o[Te.getDay()]},b:function(Te){return l[Te.getMonth()]},B:function(Te){return a[Te.getMonth()]},c:null,d:sce,e:sce,f:Bze,g:Xze,G:Kze,H:Fze,I:Nze,j:Lze,L:dce,m:Vze,M:Hze,p:function(Te){return r[+(Te.getHours()>=12)]},q:function(Te){return 1+~~(Te.getMonth()/3)},Q:cce,s:uce,S:Uze,u:zze,U:jze,V:Gze,w:Wze,W:qze,x:null,X:null,y:Yze,Y:Qze,Z:Zze,"%":lce},T={a:function(Te){return s[Te.getUTCDay()]},A:function(Te){return o[Te.getUTCDay()]},b:function(Te){return l[Te.getUTCMonth()]},B:function(Te){return a[Te.getUTCMonth()]},c:null,d:ace,e:ace,f:tje,g:dje,G:hje,H:Jze,I:$ze,j:eje,L:hce,m:nje,M:ije,p:function(Te){return r[+(Te.getUTCHours()>=12)]},q:function(Te){return 1+~~(Te.getUTCMonth()/3)},Q:cce,s:uce,S:rje,u:oje,U:sje,V:aje,w:lje,W:cje,x:null,X:null,y:uje,Y:pje,Z:fje,"%":lce},k={a:function(Te,xt,mt){var ce=h.exec(xt.slice(mt));return ce?(Te.w=f[ce[0].toLowerCase()],mt+ce[0].length):-1},A:function(Te,xt,mt){var ce=d.exec(xt.slice(mt));return ce?(Te.w=p[ce[0].toLowerCase()],mt+ce[0].length):-1},b:function(Te,xt,mt){var ce=g.exec(xt.slice(mt));return ce?(Te.m=b[ce[0].toLowerCase()],mt+ce[0].length):-1},B:function(Te,xt,mt){var ce=m.exec(xt.slice(mt));return ce?(Te.m=x[ce[0].toLowerCase()],mt+ce[0].length):-1},c:function(Te,xt,mt){return fe(Te,t,xt,mt)},d:rce,e:rce,f:Pze,g:ice,G:nce,H:oce,I:oce,j:Tze,L:Ize,m:Eze,M:Dze,p:function(Te,xt,mt){var ce=c.exec(xt.slice(mt));return ce?(Te.p=u[ce[0].toLowerCase()],mt+ce[0].length):-1},q:Sze,Q:Oze,s:kze,S:Aze,u:bze,U:xze,V:Cze,w:yze,W:Mze,x:function(Te,xt,mt){return fe(Te,e,xt,mt)},X:function(Te,xt,mt){return fe(Te,i,xt,mt)},y:ice,Y:nce,Z:wze,"%":Rze};function Z(Te,xt){return function(mt){var bt,hn,on,ce=[],dt=-1,We=0,Mt=Te.length;for(mt instanceof Date||(mt=new Date(+mt));++dt<Mt;)37===Te.charCodeAt(dt)&&(ce.push(Te.slice(We,dt)),null!=(hn=tce[bt=Te.charAt(++dt)])?bt=Te.charAt(++dt):hn="e"===bt?" ":"0",(on=xt[bt])&&(bt=on(mt,hn)),ce.push(bt),We=dt+1);return ce.push(Te.slice(We,dt)),ce.join("")}}function z(Te,xt){return function(mt){var We,Mt,ce=fS(1900,void 0,1);if(fe(ce,Te,mt+="",0)!=mt.length)return null;if("Q"in ce)return new Date(ce.Q);if("s"in ce)return new Date(1e3*ce.s+("L"in ce?ce.L:0));if(xt&&!("Z"in ce)&&(ce.Z=0),"p"in ce&&(ce.H=ce.H%12+12*ce.p),void 0===ce.m&&(ce.m="q"in ce?ce.q:0),"V"in ce){if(ce.V<1||ce.V>53)return null;"w"in ce||(ce.w=1),"Z"in ce?(Mt=(We=Kz(fS(ce.y,0,1))).getUTCDay(),We=Mt>4||0===Mt?Dy.ceil(We):Dy(We),We=dO.offset(We,7*(ce.V-1)),ce.y=We.getUTCFullYear(),ce.m=We.getUTCMonth(),ce.d=We.getUTCDate()+(ce.w+6)%7):(Mt=(We=Qz(fS(ce.y,0,1))).getDay(),We=Mt>4||0===Mt?Ty.ceil(We):Ty(We),We=Ey.offset(We,7*(ce.V-1)),ce.y=We.getFullYear(),ce.m=We.getMonth(),ce.d=We.getDate()+(ce.w+6)%7)}else("W"in ce||"U"in ce)&&("w"in ce||(ce.w="u"in ce?ce.u%7:"W"in ce?1:0),Mt="Z"in ce?Kz(fS(ce.y,0,1)).getUTCDay():Qz(fS(ce.y,0,1)).getDay(),ce.m=0,ce.d="W"in ce?(ce.w+6)%7+7*ce.W-(Mt+5)%7:ce.w+7*ce.U-(Mt+6)%7);return"Z"in ce?(ce.H+=ce.Z/100|0,ce.M+=ce.Z%100,Kz(ce)):Qz(ce)}}function fe(Te,xt,mt,ce){for(var bt,hn,dt=0,We=xt.length,Mt=mt.length;dt<We;){if(ce>=Mt)return-1;if(37===(bt=xt.charCodeAt(dt++))){if(bt=xt.charAt(dt++),!(hn=k[bt in tce?xt.charAt(dt++):bt])||(ce=hn(Te,mt,ce))<0)return-1}else if(bt!=mt.charCodeAt(ce++))return-1}return ce}return D.x=Z(e,D),D.X=Z(i,D),D.c=Z(t,D),T.x=Z(e,T),T.X=Z(i,T),T.c=Z(t,T),{format:function(Te){var xt=Z(Te+="",D);return xt.toString=function(){return Te},xt},parse:function(Te){var xt=z(Te+="",!1);return xt.toString=function(){return Te},xt},utcFormat:function(Te){var xt=Z(Te+="",T);return xt.toString=function(){return Te},xt},utcParse:function(Te){var xt=z(Te+="",!0);return xt.toString=function(){return Te},xt}}}({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]}),Iy=Ay.format;var vS=6e4,yS=60*vS,bS=24*yS,$z=365*bS;function gje(n){return new Date(n)}function _je(n){return n instanceof Date?+n:+new Date(+n)}function ej(n,t,e,i,r,o,s,a,l){var c=dS(ja,ja),u=c.invert,d=c.domain,p=l(".%L"),h=l(":%S"),f=l("%I:%M"),m=l("%I %p"),x=l("%a %d"),g=l("%b %d"),b=l("%B"),D=l("%Y"),T=[[s,1,1e3],[s,5,5e3],[s,15,15e3],[s,30,3e4],[o,1,vS],[o,5,5*vS],[o,15,15*vS],[o,30,30*vS],[r,1,yS],[r,3,3*yS],[r,6,6*yS],[r,12,12*yS],[i,1,bS],[i,2,2*bS],[e,1,6048e5],[t,1,2592e6],[t,3,7776e6],[n,1,$z]];function k(z){return(s(z)<z?p:o(z)<z?h:r(z)<z?f:i(z)<z?m:t(z)<z?e(z)<z?x:g:n(z)<z?b:D)(z)}function Z(z,fe,ue,he){if(null==z&&(z=10),"number"==typeof z){var w=Math.abs(ue-fe)/z,F=Bw(function(q){return q[2]}).right(T,w);F===T.length?(he=vd(fe/$z,ue/$z,z),z=n):F?(he=(F=T[w/T[F-1][2]<T[F][2]/w?F-1:F])[1],z=F[0]):(he=Math.max(vd(fe,ue,z),1),z=a)}return null==he?z:z.every(he)}return c.invert=function(z){return new Date(u(z))},c.domain=function(z){return arguments.length?d(lS.call(z,_je)):d().map(gje)},c.ticks=function(z,fe){var q,ue=d(),he=ue[0],w=ue[ue.length-1],F=w<he;return F&&(q=he,he=w,w=q),q=(q=Z(z,he,w,fe))?q.range(he,w+1):[],F?q.reverse():q},c.tickFormat=function(z,fe){return null==fe?k:l(fe)},c.nice=function(z,fe){var ue=d();return(z=Z(z,ue[0],ue[ue.length-1],fe))?d(oO(ue,z)):c},c.copy=function(){return nf(c,ej(n,t,e,i,r,o,s,a,l))},c}function Rg(){return zs.apply(ej(vp,qz,Ag,Ey,Wz,Gz,uO,aO,Iy).domain([new Date(2e3,0,1),new Date(2e3,0,2)]),arguments)}function Py(n){for(var t=n.length/6|0,e=new Array(t),i=0;i<t;)e[i]="#"+n.slice(6*i,6*++i);return e}function Ry(n){return iz(n[n.length-1])}var tj=Ry(new Array(3).concat("deebf79ecae13182bd","eff3ffbdd7e76baed62171b5","eff3ffbdd7e76baed63182bd08519c","eff3ffc6dbef9ecae16baed63182bd08519c","eff3ffc6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b508519c08306b").map(Py)),nj=Ry(new Array(3).concat("f0f0f0bdbdbd636363","f7f7f7cccccc969696525252","f7f7f7cccccc969696636363252525","f7f7f7d9d9d9bdbdbd969696636363252525","f7f7f7d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525000000").map(Py)),ij=Ry(new Array(3).concat("fee0d2fc9272de2d26","fee5d9fcae91fb6a4acb181d","fee5d9fcae91fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181da50f1567000d").map(Py));function fa(n){return function(){return n}}function wce(n){this._context=n}function pO(n){return new wce(n)}function hO(n){return n[0]}function fO(n){return n[1]}function xS(){var n=hO,t=fO,e=fa(!0),i=null,r=pO,o=null;function s(a){var l,u,p,c=a.length,d=!1;for(null==i&&(o=r(p=sS())),l=0;l<=c;++l)!(l<c&&e(u=a[l],l,a))===d&&((d=!d)?o.lineStart():o.lineEnd()),d&&o.point(+n(u,l,a),+t(u,l,a));if(p)return o=null,p+""||null}return s.x=function(a){return arguments.length?(n="function"==typeof a?a:fa(+a),s):n},s.y=function(a){return arguments.length?(t="function"==typeof a?a:fa(+a),s):t},s.defined=function(a){return arguments.length?(e="function"==typeof a?a:fa(!!a),s):e},s.curve=function(a){return arguments.length?(r=a,null!=i&&(o=r(i)),s):r},s.context=function(a){return arguments.length?(null==a?i=o=null:o=r(i=a),s):i},s}function Sce(n,t,e){n._context.bezierCurveTo(n._x1+n._k*(n._x2-n._x0),n._y1+n._k*(n._y2-n._y0),n._x2+n._k*(n._x1-t),n._y2+n._k*(n._y1-e),n._x2,n._y2)}function mO(n,t){this._context=n,this._k=(1-t)/6}function Ece(n,t){this._context=n,this._alpha=t}Math,wce.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(n,t){switch(n=+n,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(n,t):this._context.moveTo(n,t);break;case 1:this._point=2;default:this._context.lineTo(n,t)}}},mO.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:Sce(this,this._x1,this._y1)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(n,t){switch(n=+n,t=+t,this._point){case 0:this._point=1,this._line?this._context.lineTo(n,t):this._context.moveTo(n,t);break;case 1:this._point=2,this._x1=n,this._y1=t;break;case 2:this._point=3;default:Sce(this,n,t)}this._x0=this._x1,this._x1=this._x2,this._x2=n,this._y0=this._y1,this._y1=this._y2,this._y2=t}},function n(t){function e(i){return new mO(i,t)}return e.tension=function(i){return n(+i)},e}(0),Ece.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:this.point(this._x2,this._y2)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(n,t){if(n=+n,t=+t,this._point){var e=this._x2-n,i=this._y2-t;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(e*e+i*i,this._alpha))}switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(n,t):this._context.moveTo(n,t);break;case 1:this._point=2;break;case 2:this._point=3;default:!function(n,t,e){var i=n._x1,r=n._y1,o=n._x2,s=n._y2;if(n._l01_a>1e-12){var a=2*n._l01_2a+3*n._l01_a*n._l12_a+n._l12_2a,l=3*n._l01_a*(n._l01_a+n._l12_a);i=(i*a-n._x0*n._l12_2a+n._x2*n._l01_2a)/l,r=(r*a-n._y0*n._l12_2a+n._y2*n._l01_2a)/l}if(n._l23_a>1e-12){var c=2*n._l23_2a+3*n._l23_a*n._l12_a+n._l12_2a,u=3*n._l23_a*(n._l23_a+n._l12_a);o=(o*c+n._x1*n._l23_2a-t*n._l12_2a)/u,s=(s*c+n._y1*n._l23_2a-e*n._l12_2a)/u}n._context.bezierCurveTo(i,r,o,s,n._x2,n._y2)}(this,n,t)}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=n,this._y0=this._y1,this._y1=this._y2,this._y2=t}};var sj=function n(t){function e(i){return t?new Ece(i,t):new mO(i,0)}return e.alpha=function(i){return n(+i)},e}(.5);function aj(){this._=null}function Oy(n){n.U=n.C=n.L=n.R=n.P=n.N=null}function CS(n,t){var e=t,i=t.R,r=e.U;r?r.L===e?r.L=i:r.R=i:n._=i,i.U=r,e.U=i,e.R=i.L,e.R&&(e.R.U=e),i.L=e}function MS(n,t){var e=t,i=t.L,r=e.U;r?r.L===e?r.L=i:r.R=i:n._=i,i.U=r,e.U=i,e.L=i.R,e.L&&(e.L.U=e),i.R=e}function Tce(n){for(;n.L;)n=n.L;return n}aj.prototype={constructor:aj,insert:function(n,t){var e,i,r;if(n){if(t.P=n,t.N=n.N,n.N&&(n.N.P=t),n.N=t,n.R){for(n=n.R;n.L;)n=n.L;n.L=t}else n.R=t;e=n}else this._?(n=Tce(this._),t.P=null,t.N=n,n.P=n.L=t,e=n):(t.P=t.N=null,this._=t,e=null);for(t.L=t.R=null,t.U=e,t.C=!0,n=t;e&&e.C;)e===(i=e.U).L?(r=i.R)&&r.C?(e.C=r.C=!1,i.C=!0,n=i):(n===e.R&&(CS(this,e),e=(n=e).U),e.C=!1,i.C=!0,MS(this,i)):(r=i.L)&&r.C?(e.C=r.C=!1,i.C=!0,n=i):(n===e.L&&(MS(this,e),e=(n=e).U),e.C=!1,i.C=!0,CS(this,i)),e=n.U;this._.C=!1},remove:function(n){n.N&&(n.N.P=n.P),n.P&&(n.P.N=n.N),n.N=n.P=null;var e,o,s,t=n.U,i=n.L,r=n.R;if(o=i?r?Tce(r):i:r,t?t.L===n?t.L=o:t.R=o:this._=o,i&&r?(s=o.C,o.C=n.C,o.L=i,i.U=o,o!==r?(t=o.U,o.U=n.U,t.L=n=o.R,o.R=r,r.U=o):(o.U=t,t=o,n=o.R)):(s=n.C,n=o),n&&(n.U=t),!s){if(n&&n.C)return void(n.C=!1);do{if(n===this._)break;if(n===t.L){if((e=t.R).C&&(e.C=!1,t.C=!0,CS(this,t),e=t.R),e.L&&e.L.C||e.R&&e.R.C){(!e.R||!e.R.C)&&(e.L.C=!1,e.C=!0,MS(this,e),e=t.R),e.C=t.C,t.C=e.R.C=!1,CS(this,t),n=this._;break}}else if((e=t.L).C&&(e.C=!1,t.C=!0,MS(this,t),e=t.L),e.L&&e.L.C||e.R&&e.R.C){(!e.L||!e.L.C)&&(e.R.C=!1,e.C=!0,CS(this,e),e=t.L),e.C=t.C,t.C=e.L.C=!1,MS(this,t),n=this._;break}e.C=!0,n=t,t=t.U}while(!n.C);n&&(n.C=!1)}}};var lj=aj;function ky(n,t,e,i){var r=[null,null],o=ds.push(r)-1;return r.left=n,r.right=t,e&&wS(r,n,t,e),i&&wS(r,t,n,i),ma[n.index].halfedges.push(o),ma[t.index].halfedges.push(o),r}function Fy(n,t,e){var i=[t,e];return i.left=n,i}function wS(n,t,e,i){n[0]||n[1]?n.left===e?n[1]=i:n[0]=i:(n[0]=i,n.left=t,n.right=e)}function xje(n,t,e,i,r){var m,o=n[0],s=n[1],a=o[0],l=o[1],d=0,p=1,h=s[0]-a,f=s[1]-l;if(m=t-a,h||!(m>0)){if(m/=h,h<0){if(m<d)return;m<p&&(p=m)}else if(h>0){if(m>p)return;m>d&&(d=m)}if(m=i-a,h||!(m<0)){if(m/=h,h<0){if(m>p)return;m>d&&(d=m)}else if(h>0){if(m<d)return;m<p&&(p=m)}if(m=e-l,f||!(m>0)){if(m/=f,f<0){if(m<d)return;m<p&&(p=m)}else if(f>0){if(m>p)return;m>d&&(d=m)}if(m=r-l,f||!(m<0)){if(m/=f,f<0){if(m>p)return;m>d&&(d=m)}else if(f>0){if(m<d)return;m<p&&(p=m)}return!(d>0)&&!(p<1)||(d>0&&(n[0]=[a+d*h,l+d*f]),p<1&&(n[1]=[a+p*h,l+p*f])),!0}}}}}function Cje(n,t,e,i,r){var o=n[1];if(o)return!0;var m,x,s=n[0],a=n.left,l=n.right,c=a[0],u=a[1],d=l[0],p=l[1],h=(c+d)/2;if(p===u){if(h<t||h>=i)return;if(c>d){if(s){if(s[1]>=r)return}else s=[h,e];o=[h,r]}else{if(s){if(s[1]<e)return}else s=[h,r];o=[h,e]}}else if(x=(u+p)/2-(m=(c-d)/(p-u))*h,m<-1||m>1)if(c>d){if(s){if(s[1]>=r)return}else s=[(e-x)/m,e];o=[(r-x)/m,r]}else{if(s){if(s[1]<e)return}else s=[(r-x)/m,r];o=[(e-x)/m,e]}else if(u<p){if(s){if(s[0]>=i)return}else s=[t,m*t+x];o=[i,m*i+x]}else{if(s){if(s[0]<t)return}else s=[i,m*i+x];o=[t,m*t+x]}return n[0]=s,n[1]=o,!0}function Mje(n,t){var e=n.site,i=t.left,r=t.right;return e===r&&(r=i,i=e),r?Math.atan2(r[1]-i[1],r[0]-i[0]):(e===i?(i=t[1],r=t[0]):(i=t[0],r=t[1]),Math.atan2(i[0]-r[0],r[1]-i[1]))}function cj(n,t){return t[+(t.left!==n.site)]}function wje(n,t){return t[+(t.left===n.site)]}var gO,Rce=[];function Sje(){Oy(this),this.x=this.y=this.arc=this.site=this.cy=null}function Og(n){var t=n.P,e=n.N;if(t&&e){var i=t.site,r=n.site,o=e.site;if(i!==o){var s=r[0],a=r[1],l=i[0]-s,c=i[1]-a,u=o[0]-s,d=o[1]-a,p=2*(l*d-c*u);if(!(p>=-Oce)){var h=l*l+c*c,f=u*u+d*d,m=(d*h-c*f)/p,x=(l*f-u*h)/p,g=Rce.pop()||new Sje;g.arc=n,g.site=r,g.x=m+s,g.y=(g.cy=x+a)+Math.sqrt(m*m+x*x),n.circle=g;for(var b=null,D=Ny._;D;)if(g.y<D.y||g.y===D.y&&g.x<=D.x){if(!D.L){b=D.P;break}D=D.L}else{if(!D.R){b=D;break}D=D.R}Ny.insert(b,g),b||(gO=g)}}}}function kg(n){var t=n.circle;t&&(t.P||(gO=t.N),Ny.remove(t),Rce.push(t),Oy(t),n.circle=null)}var Fce=[];function Eje(){Oy(this),this.edge=this.site=this.circle=null}function kce(n){var t=Fce.pop()||new Eje;return t.site=n,t}function uj(n){kg(n),Fg.remove(n),Fce.push(n),Oy(n)}function Nce(n){var t=n.circle,e=t.x,i=t.cy,r=[e,i],o=n.P,s=n.N,a=[n];uj(n);for(var l=o;l.circle&&Math.abs(e-l.circle.x)<pr&&Math.abs(i-l.circle.cy)<pr;)o=l.P,a.unshift(l),uj(l),l=o;a.unshift(l),kg(l);for(var c=s;c.circle&&Math.abs(e-c.circle.x)<pr&&Math.abs(i-c.circle.cy)<pr;)s=c.N,a.push(c),uj(c),c=s;a.push(c),kg(c);var d,u=a.length;for(d=1;d<u;++d)wS((c=a[d]).edge,(l=a[d-1]).site,c.site,r);(c=a[u-1]).edge=ky((l=a[0]).site,c.site,null,r),Og(l),Og(c)}function Lce(n){for(var i,r,o,s,t=n[0],e=n[1],a=Fg._;a;)if((o=Bce(a,e)-t)>pr)a=a.L;else{if(!((s=t-Tje(a,e))>pr)){o>-pr?(i=a.P,r=a):s>-pr?(i=a,r=a.N):i=r=a;break}if(!a.R){i=a;break}a=a.R}!function(n){ma[n.index]={site:n,halfedges:[]}}(n);var l=kce(n);if(Fg.insert(i,l),i||r){if(i===r)return kg(i),r=kce(i.site),Fg.insert(l,r),l.edge=r.edge=ky(i.site,l.site),Og(i),void Og(r);if(!r)return void(l.edge=ky(i.site,l.site));kg(i),kg(r);var c=i.site,u=c[0],d=c[1],p=n[0]-u,h=n[1]-d,f=r.site,m=f[0]-u,x=f[1]-d,g=2*(p*x-h*m),b=p*p+h*h,D=m*m+x*x,T=[(x*b-h*D)/g+u,(p*D-m*b)/g+d];wS(r.edge,c,f,T),l.edge=ky(c,n,null,T),r.edge=ky(n,f,null,T),Og(i),Og(r)}}function Bce(n,t){var e=n.site,i=e[0],r=e[1],o=r-t;if(!o)return i;var s=n.P;if(!s)return-1/0;var a=(e=s.site)[0],l=e[1],c=l-t;if(!c)return a;var u=a-i,d=1/o-1/c,p=u/c;return d?(-p+Math.sqrt(p*p-2*d*(u*u/(-2*c)-l+c/2+r-o/2)))/d+i:(i+a)/2}function Tje(n,t){var e=n.N;if(e)return Bce(e,t);var i=n.site;return i[1]===t?i[0]:1/0}var Fg,ma,Ny,ds,pr=1e-6,Oce=1e-12;function Dje(n,t,e){return(n[0]-e[0])*(t[1]-n[1])-(n[0]-t[0])*(e[1]-n[1])}function Aje(n,t){return t[1]-n[1]||t[0]-n[0]}function _O(n,t){var i,r,o,e=n.sort(Aje).pop();for(ds=[],ma=new Array(n.length),Fg=new lj,Ny=new lj;;)if(o=gO,e&&(!o||e[1]<o.y||e[1]===o.y&&e[0]<o.x))(e[0]!==i||e[1]!==r)&&(Lce(e),i=e[0],r=e[1]),e=n.pop();else{if(!o)break;Nce(o.arc)}if(function(){for(var e,i,r,o,n=0,t=ma.length;n<t;++n)if((e=ma[n])&&(o=(i=e.halfedges).length)){var s=new Array(o),a=new Array(o);for(r=0;r<o;++r)s[r]=r,a[r]=Mje(e,ds[i[r]]);for(s.sort(function(l,c){return a[c]-a[l]}),r=0;r<o;++r)a[r]=i[s[r]];for(r=0;r<o;++r)i[r]=a[r]}}(),t){var s=+t[0][0],a=+t[0][1],l=+t[1][0],c=+t[1][1];(function(n,t,e,i){for(var o,r=ds.length;r--;)Cje(o=ds[r],n,t,e,i)&&xje(o,n,t,e,i)&&(Math.abs(o[0][0]-o[1][0])>pr||Math.abs(o[0][1]-o[1][1])>pr)||delete ds[r]})(s,a,l,c),function(n,t,e,i){var o,s,a,l,c,u,d,p,h,f,m,x,r=ma.length,g=!0;for(o=0;o<r;++o)if(s=ma[o]){for(a=s.site,l=(c=s.halfedges).length;l--;)ds[c[l]]||c.splice(l,1);for(l=0,u=c.length;l<u;)m=(f=wje(s,ds[c[l]]))[0],x=f[1],p=(d=cj(s,ds[c[++l%u]]))[0],h=d[1],(Math.abs(m-p)>pr||Math.abs(x-h)>pr)&&(c.splice(l,0,ds.push(Fy(a,f,Math.abs(m-n)<pr&&i-x>pr?[n,Math.abs(p-n)<pr?h:i]:Math.abs(x-i)<pr&&e-m>pr?[Math.abs(h-i)<pr?p:e,i]:Math.abs(m-e)<pr&&x-t>pr?[e,Math.abs(p-e)<pr?h:t]:Math.abs(x-t)<pr&&m-n>pr?[Math.abs(h-t)<pr?p:n,t]:null))-1),++u);u&&(g=!1)}if(g){var b,D,T,k=1/0;for(o=0,g=null;o<r;++o)(s=ma[o])&&(T=(b=(a=s.site)[0]-n)*b+(D=a[1]-t)*D)<k&&(k=T,g=s);if(g){var Z=[n,t],z=[n,i],fe=[e,i],ue=[e,t];g.halfedges.push(ds.push(Fy(a=g.site,Z,z))-1,ds.push(Fy(a,z,fe))-1,ds.push(Fy(a,fe,ue))-1,ds.push(Fy(a,ue,Z))-1)}}for(o=0;o<r;++o)(s=ma[o])&&(s.halfedges.length||delete ma[o])}(s,a,l,c)}this.edges=ds,this.cells=ma,Fg=Ny=ds=ma=null}function Ng(n,t,e){this.k=n,this.x=t,this.y=e}_O.prototype={constructor:_O,polygons:function(){var n=this.edges;return this.cells.map(function(t){var e=t.halfedges.map(function(i){return cj(t,n[i])});return e.data=t.site.data,e})},triangles:function(){var n=[],t=this.edges;return this.cells.forEach(function(e,i){if(a=(o=e.halfedges).length)for(var o,a,l,r=e.site,s=-1,c=t[o[a-1]],u=c.left===r?c.right:c.left;++s<a;)l=u,u=(c=t[o[s]]).left===r?c.right:c.left,l&&u&&i<l.index&&i<u.index&&Dje(r,l,u)<0&&n.push([r.data,l.data,u.data])}),n},links:function(){return this.edges.filter(function(n){return n.right}).map(function(n){return{source:n.left.data,target:n.right.data}})},find:function(n,t,e){for(var r,a,i=this,o=i._found||0,s=i.cells.length;!(a=i.cells[o]);)if(++o>=s)return null;var l=n-a.site[0],c=t-a.site[1],u=l*l+c*c;do{a=i.cells[r=o],o=null,a.halfedges.forEach(function(d){var p=i.edges[d],h=p.left;if(h!==a.site&&h||(h=p.right)){var f=n-h[0],m=t-h[1],x=f*f+m*m;x<u&&(u=x,o=h.index)}})}while(null!==o);return i._found=r,null==e||u<=e*e?a.site:null}},Ng.prototype={constructor:Ng,scale:function(n){return 1===n?this:new Ng(this.k*n,this.x,this.y)},translate:function(n,t){return 0===n&0===t?this:new Ng(this.k,this.x+this.k*n,this.y+this.k*t)},apply:function(n){return[n[0]*this.k+this.x,n[1]*this.k+this.y]},applyX:function(n){return n*this.k+this.x},applyY:function(n){return n*this.k+this.y},invert:function(n){return[(n[0]-this.x)/this.k,(n[1]-this.y)/this.k]},invertX:function(n){return(n-this.x)/this.k},invertY:function(n){return(n-this.y)/this.k},rescaleX:function(n){return n.copy().domain(n.range().map(this.invertX,this).map(n.invert,n))},rescaleY:function(n){return n.copy().domain(n.range().map(this.invertY,this).map(n.invert,n))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}},new Ng(1,0,0);var zce=xo(".2~e"),Ije=xo(".4~r"),Vce=xo(",~");function Hce(n){if(0===n)return"0";let t=Math.abs(n);return t>=1e4||t<.001?zce(n):Ije(n)}var yp={formatTick:Hce,formatShort:Hce,formatReadable(n){let t=Math.abs(n);return t>=1e4||t<.001?zce(n):Vce(n)},formatLong:Vce},Pje=new Intl.NumberFormat(void 0,{maximumFractionDigits:3});function vO(n){return Pje.format(n)}var Md={formatTick:vO,formatShort:vO,formatReadable:vO,formatLong:vO},Rje=xo("0.3~s"),Oje=xo(",.3~f");function yO(n){let t=Math.abs(n);return t>=1e4||t<.001?Rje(n):Oje(n)}var jce={formatTick:yO,formatShort:yO,formatReadable:yO,formatLong:yO},gj=36e5,Ly=xo(".4~");function bO(n){if(0===n)return"0";let t=Math.sign(n)>0?"":"-",e=Math.abs(n);return t+=e<1e3?`${Ly(e)} ms`:e<6e4?`${Ly(e/1e3)} sec`:e<gj?`${Ly(e/6e4)} min`:e<864e5?`${Ly(e/gj)} hr`:e<31536e6?`${Ly(e/864e5)} day`:`${Ly(e/31536e6)} yr`,t}var hj,SS={formatTick:bO,formatShort:bO,formatReadable:bO,formatLong:bO},kje=Rg().tickFormat(),Gce={formatTick:n=>kje(new Date(n)),formatShort:n=>new Date(n).toLocaleString(hj,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric"}),formatReadable:n=>new Date(n).toLocaleString(hj,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short"}),formatLong:n=>new Date(n).toLocaleString(hj,{year:"numeric",month:"long",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short",fractionalSecondDigits:3})};function ou(n){switch(n){case Nr.LINEAR:return new ES;case Nr.LOG10:return new bj;case Nr.TIME:return new TS;default:throw new RangeError(`ScaleType ${n} not supported.`)}}var ES=class{constructor(){this.defaultFormatter=yp}transform(t,e,i){let[r,o]=t,s=o-r,[a,l]=e;return 0===s?a:(l-a)/s*(i-r)+a}forward(t,e,i){return this.transform(t,e,i)}reverse(t,e,i){return this.transform(e,t,i)}niceDomain(t){let[e,i]=t;if(i<e)throw new Error("Unexpected input: min is larger than max");if(i===e)return 0===e?[-1,1]:e<0?[2*e,0]:[0,2*e];let r=Qo(),o=.05*(i-e+Number.EPSILON),[s,a]=r.domain([e-o,i+o]).nice().domain();return[s,a]}ticks(t,e){return Qo().domain(t).ticks(e)}isSafeNumber(t){return Number.isFinite(t)}},bj=class{constructor(){this.defaultFormatter=yp}transform(t){return Math.log10(t>0?t:Number.MIN_VALUE)}untransform(t){return Math.exp(t/Math.LOG10E)}forward(t,e,i){if(i<=0)return e[0];let[r,o]=t,[s,a]=e,l=this.transform(r),u=this.transform(o)-l,d=a-s;return i=this.transform(i),d/(u+Number.EPSILON)*(i-l)+s}reverse(t,e,i){let[r,o]=t,[s,a]=e,l=this.transform(r),u=this.transform(o)-l;return this.untransform(u/(a-s+Number.EPSILON)*(i-s)+l)}niceDomain(t){let[e,i]=t;if(e>i)throw new Error("Unexpected input: min is larger than max");let r=Math.max(e,Number.MIN_VALUE),o=Math.max(i,Number.MIN_VALUE);return i<=0?[Number.MIN_VALUE,1]:[Math.max(Number.MIN_VALUE,.5*r),2*o]}ticks(t,e){let i=t[0]<=0?Number.MIN_VALUE:t[0],r=t[1]<=0?Number.MIN_VALUE:t[1],o=pS().domain([i,r]).ticks(e);return o.length?o:t}isSafeNumber(t){return Number.isFinite(t)&&t>0}},TS=class{constructor(){this.scale=Rg(),this.defaultFormatter=Gce}forward(t,e,i){return this.scale.domain(t).range(e)(i)}reverse(t,e,i){return this.scale.domain(t).range(e).invert(i).getTime()}niceDomain(t){let[e,i]=this.scale.domain(t).nice().domain();return[e.getTime(),i.getTime()]}ticks(t,e){return this.scale.domain(t).ticks(e).map(i=>i.getTime())}isSafeNumber(t){return Number.isFinite(t)}},xj=!1;if(self.hasOwnProperty("WebGL2RenderingContext")&&self.hasOwnProperty("document")){let n=document.createElement("canvas");n.addEventListener("webglcontextcreationerror",()=>{xj=!1});let t=n.getContext("webgl2");xj=Boolean(t)}var su_convertRectToExtent=function(n){return{x:[n.x,n.x+n.width],y:[n.y,n.y+n.height]}},su_isWebGl2Supported=function(){return xj},su_isOffscreenCanvasSupported=function(){return self.hasOwnProperty("OffscreenCanvas")},su_arePolylinesEqual=function(n,t){if(n.length!==t.length)return!1;for(let e=0;e<n.length;e++)if(n[e]!==t[e])return!1;return!0},By=class{constructor(){this.xScale=ou(Nr.LINEAR),this.yScale=ou(Nr.LINEAR),this.domContainerRect={x:0,width:1,y:0,height:1},this.lastUpdated=0,this.currentViewBoxRect={x:0,width:1,y:0,height:1}}getUpdateIdentifier(){return this.lastUpdated}updateIdentifier(){this.lastUpdated++}isYAxisPointedDown(){return!0}setXScale(t){this.xScale=t,this.updateIdentifier()}setYScale(t){this.yScale=t,this.updateIdentifier()}getCurrentViewBoxRect(){return this.currentViewBoxRect}setViewBoxRect(t){this.currentViewBoxRect=t,this.updateIdentifier()}setDomContainerRect(t){this.domContainerRect=t,this.updateIdentifier()}transformDataToUiCoord(t,e){let i=t,r=su_convertRectToExtent(this.currentViewBoxRect);return[this.xScale.forward(r.x,[i.x,i.x+i.width],e[0]),this.yScale.forward(r.y,this.isYAxisPointedDown()?[i.y+i.height,i.y]:[i.y,i.y+i.height],e[1])]}};function xO(n,t,e,i){let{color:r,visible:o,opacity:s}=i,a=n;return a||o?(a=a??t(),a=e(a),a.style.display=o?"":"none",a.style.stroke=r,a.style.opacity=String(s??1),a):null}var El=1001,Zo=1003,Gs=1006,_f=1009,WS=1012,Ug=1015,lb=1016,cb=1020,ga=1023,jg=1026,hb=1027,ob=2400,sb=2401,bf=3e3,Wr=3001,qS=35044,ok=35048,Ep=class{addEventListener(t,e){void 0===this._listeners&&(this._listeners={});let i=this._listeners;void 0===i[t]&&(i[t]=[]),-1===i[t].indexOf(e)&&i[t].push(e)}hasEventListener(t,e){if(void 0===this._listeners)return!1;let i=this._listeners;return void 0!==i[t]&&-1!==i[t].indexOf(e)}removeEventListener(t,e){if(void 0===this._listeners)return;let r=this._listeners[t];if(void 0!==r){let o=r.indexOf(e);-1!==o&&r.splice(o,1)}}dispatchEvent(t){if(void 0===this._listeners)return;let i=this._listeners[t.type];if(void 0!==i){t.target=this;let r=i.slice(0);for(let o=0,s=r.length;o<s;o++)r[o].call(this,t);t.target=null}}},Ms=[];for(let n=0;n<256;n++)Ms[n]=(n<16?"0":"")+n.toString(16);var Dj=Math.PI/180,h8=180/Math.PI;function du(){let n=4294967295*Math.random()|0,t=4294967295*Math.random()|0,e=4294967295*Math.random()|0,i=4294967295*Math.random()|0;return(Ms[255&n]+Ms[n>>8&255]+Ms[n>>16&255]+Ms[n>>24&255]+"-"+Ms[255&t]+Ms[t>>8&255]+"-"+Ms[t>>16&15|64]+Ms[t>>24&255]+"-"+Ms[63&e|128]+Ms[e>>8&255]+"-"+Ms[e>>16&255]+Ms[e>>24&255]+Ms[255&i]+Ms[i>>8&255]+Ms[i>>16&255]+Ms[i>>24&255]).toUpperCase()}function Ga(n,t,e){return Math.max(t,Math.min(e,n))}function Aj(n,t,e){return(1-e)*n+e*t}function xue(n){return 0==(n&n-1)&&0!==n}function H8e(n){return Math.pow(2,Math.floor(Math.log(n)/Math.LN2))}var at=class{constructor(t=0,e=0){this.x=t,this.y=e}get width(){return this.x}set width(t){this.x=t}get height(){return this.y}set height(t){this.y=t}set(t,e){return this.x=t,this.y=e,this}setScalar(t){return this.x=t,this.y=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y)}copy(t){return this.x=t.x,this.y=t.y,this}add(t,e){return void 0!==e?(console.warn("THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this)}addScalar(t){return this.x+=t,this.y+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this}sub(t,e){return void 0!==e?(console.warn("THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this)}subScalar(t){return this.x-=t,this.y-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this}multiply(t){return this.x*=t.x,this.y*=t.y,this}multiplyScalar(t){return this.x*=t,this.y*=t,this}divide(t){return this.x/=t.x,this.y/=t.y,this}divideScalar(t){return this.multiplyScalar(1/t)}applyMatrix3(t){let e=this.x,i=this.y,r=t.elements;return this.x=r[0]*e+r[3]*i+r[6],this.y=r[1]*e+r[4]*i+r[7],this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this}clampLength(t,e){let i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(t,Math.min(e,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this}negate(){return this.x=-this.x,this.y=-this.y,this}dot(t){return this.x*t.x+this.y*t.y}cross(t){return this.x*t.y-this.y*t.x}lengthSq(){return this.x*this.x+this.y*this.y}length(){return Math.sqrt(this.x*this.x+this.y*this.y)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)}normalize(){return this.divideScalar(this.length()||1)}angle(){return Math.atan2(-this.y,-this.x)+Math.PI}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){let e=this.x-t.x,i=this.y-t.y;return e*e+i*i}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this}equals(t){return t.x===this.x&&t.y===this.y}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t}fromBufferAttribute(t,e,i){return void 0!==i&&console.warn("THREE.Vector2: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this}rotateAround(t,e){let i=Math.cos(e),r=Math.sin(e),o=this.x-t.x,s=this.y-t.y;return this.x=o*i-s*r+t.x,this.y=o*r+s*i+t.y,this}random(){return this.x=Math.random(),this.y=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y}};at.prototype.isVector2=!0;var Jo=class{constructor(){this.elements=[1,0,0,0,1,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.")}set(t,e,i,r,o,s,a,l,c){let u=this.elements;return u[0]=t,u[1]=r,u[2]=a,u[3]=e,u[4]=o,u[5]=l,u[6]=i,u[7]=s,u[8]=c,this}identity(){return this.set(1,0,0,0,1,0,0,0,1),this}copy(t){let e=this.elements,i=t.elements;return e[0]=i[0],e[1]=i[1],e[2]=i[2],e[3]=i[3],e[4]=i[4],e[5]=i[5],e[6]=i[6],e[7]=i[7],e[8]=i[8],this}extractBasis(t,e,i){return t.setFromMatrix3Column(this,0),e.setFromMatrix3Column(this,1),i.setFromMatrix3Column(this,2),this}setFromMatrix4(t){let e=t.elements;return this.set(e[0],e[4],e[8],e[1],e[5],e[9],e[2],e[6],e[10]),this}multiply(t){return this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,e){let i=t.elements,r=e.elements,o=this.elements,s=i[0],a=i[3],l=i[6],c=i[1],u=i[4],d=i[7],p=i[2],h=i[5],f=i[8],m=r[0],x=r[3],g=r[6],b=r[1],D=r[4],T=r[7],k=r[2],Z=r[5],z=r[8];return o[0]=s*m+a*b+l*k,o[3]=s*x+a*D+l*Z,o[6]=s*g+a*T+l*z,o[1]=c*m+u*b+d*k,o[4]=c*x+u*D+d*Z,o[7]=c*g+u*T+d*z,o[2]=p*m+h*b+f*k,o[5]=p*x+h*D+f*Z,o[8]=p*g+h*T+f*z,this}multiplyScalar(t){let e=this.elements;return e[0]*=t,e[3]*=t,e[6]*=t,e[1]*=t,e[4]*=t,e[7]*=t,e[2]*=t,e[5]*=t,e[8]*=t,this}determinant(){let t=this.elements,e=t[0],i=t[1],r=t[2],o=t[3],s=t[4],a=t[5],l=t[6],c=t[7],u=t[8];return e*s*u-e*a*c-i*o*u+i*a*l+r*o*c-r*s*l}invert(){let t=this.elements,e=t[0],i=t[1],r=t[2],o=t[3],s=t[4],a=t[5],l=t[6],c=t[7],u=t[8],d=u*s-a*c,p=a*l-u*o,h=c*o-s*l,f=e*d+i*p+r*h;if(0===f)return this.set(0,0,0,0,0,0,0,0,0);let m=1/f;return t[0]=d*m,t[1]=(r*c-u*i)*m,t[2]=(a*i-r*s)*m,t[3]=p*m,t[4]=(u*e-r*l)*m,t[5]=(r*o-a*e)*m,t[6]=h*m,t[7]=(i*l-c*e)*m,t[8]=(s*e-i*o)*m,this}transpose(){let t,e=this.elements;return t=e[1],e[1]=e[3],e[3]=t,t=e[2],e[2]=e[6],e[6]=t,t=e[5],e[5]=e[7],e[7]=t,this}getNormalMatrix(t){return this.setFromMatrix4(t).invert().transpose()}transposeIntoArray(t){let e=this.elements;return t[0]=e[0],t[1]=e[3],t[2]=e[6],t[3]=e[1],t[4]=e[4],t[5]=e[7],t[6]=e[2],t[7]=e[5],t[8]=e[8],this}setUvTransform(t,e,i,r,o,s,a){let l=Math.cos(o),c=Math.sin(o);return this.set(i*l,i*c,-i*(l*s+c*a)+s+t,-r*c,r*l,-r*(-c*s+l*a)+a+e,0,0,1),this}scale(t,e){let i=this.elements;return i[0]*=t,i[3]*=t,i[6]*=t,i[1]*=e,i[4]*=e,i[7]*=e,this}rotate(t){let e=Math.cos(t),i=Math.sin(t),r=this.elements,o=r[0],s=r[3],a=r[6],l=r[1],c=r[4],u=r[7];return r[0]=e*o+i*l,r[3]=e*s+i*c,r[6]=e*a+i*u,r[1]=-i*o+e*l,r[4]=-i*s+e*c,r[7]=-i*a+e*u,this}translate(t,e){let i=this.elements;return i[0]+=t*i[2],i[3]+=t*i[5],i[6]+=t*i[8],i[1]+=e*i[2],i[4]+=e*i[5],i[7]+=e*i[8],this}equals(t){let e=this.elements,i=t.elements;for(let r=0;r<9;r++)if(e[r]!==i[r])return!1;return!0}fromArray(t,e=0){for(let i=0;i<9;i++)this.elements[i]=t[i+e];return this}toArray(t=[],e=0){let i=this.elements;return t[e]=i[0],t[e+1]=i[1],t[e+2]=i[2],t[e+3]=i[3],t[e+4]=i[4],t[e+5]=i[5],t[e+6]=i[6],t[e+7]=i[7],t[e+8]=i[8],t}clone(){return(new this.constructor).fromArray(this.elements)}};function Ode(n){for(let t=n.length-1;t>=0;--t)if(n[t]>65535)return!0;return!1}function YS(n){return document.createElementNS("http://www.w3.org/1999/xhtml",n)}Jo.prototype.isMatrix3=!0;var Cue={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074},au={h:0,s:0,l:0},CO={h:0,s:0,l:0};function Ij(n,t,e){return e<0&&(e+=1),e>1&&(e-=1),e<1/6?n+6*(t-n)*e:e<.5?t:e<2/3?n+6*(t-n)*(2/3-e):n}function ub(n){return n<.04045?.0773993808*n:Math.pow(.9478672986*n+.0521327014,2.4)}function Pj(n){return n<.0031308?12.92*n:1.055*Math.pow(n,.41666)-.055}var vn=(()=>{class n{constructor(e,i,r){return void 0===i&&void 0===r?this.set(e):this.setRGB(e,i,r)}set(e){return e&&e.isColor?this.copy(e):"number"==typeof e?this.setHex(e):"string"==typeof e&&this.setStyle(e),this}setScalar(e){return this.r=e,this.g=e,this.b=e,this}setHex(e){return e=Math.floor(e),this.r=(e>>16&255)/255,this.g=(e>>8&255)/255,this.b=(255&e)/255,this}setRGB(e,i,r){return this.r=e,this.g=i,this.b=r,this}setHSL(e,i,r){if(e=function(n,t){return(n%1+1)%1}(e),i=Ga(i,0,1),r=Ga(r,0,1),0===i)this.r=this.g=this.b=r;else{let o=r<=.5?r*(1+i):r+i-r*i,s=2*r-o;this.r=Ij(s,o,e+1/3),this.g=Ij(s,o,e),this.b=Ij(s,o,e-1/3)}return this}setStyle(e){function i(o){void 0!==o&&parseFloat(o)<1&&console.warn("THREE.Color: Alpha component of "+e+" will be ignored.")}let r;if(r=/^((?:rgb|hsl)a?)\(([^\)]*)\)/.exec(e)){let o,a=r[2];switch(r[1]){case"rgb":case"rgba":if(o=/^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a))return this.r=Math.min(255,parseInt(o[1],10))/255,this.g=Math.min(255,parseInt(o[2],10))/255,this.b=Math.min(255,parseInt(o[3],10))/255,i(o[4]),this;if(o=/^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a))return this.r=Math.min(100,parseInt(o[1],10))/100,this.g=Math.min(100,parseInt(o[2],10))/100,this.b=Math.min(100,parseInt(o[3],10))/100,i(o[4]),this;break;case"hsl":case"hsla":if(o=/^\s*(\d*\.?\d+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a)){let l=parseFloat(o[1])/360,c=parseInt(o[2],10)/100,u=parseInt(o[3],10)/100;return i(o[4]),this.setHSL(l,c,u)}}}else if(r=/^\#([A-Fa-f\d]+)$/.exec(e)){let o=r[1],s=o.length;if(3===s)return this.r=parseInt(o.charAt(0)+o.charAt(0),16)/255,this.g=parseInt(o.charAt(1)+o.charAt(1),16)/255,this.b=parseInt(o.charAt(2)+o.charAt(2),16)/255,this;if(6===s)return this.r=parseInt(o.charAt(0)+o.charAt(1),16)/255,this.g=parseInt(o.charAt(2)+o.charAt(3),16)/255,this.b=parseInt(o.charAt(4)+o.charAt(5),16)/255,this}return e&&e.length>0?this.setColorName(e):this}setColorName(e){let i=Cue[e.toLowerCase()];return void 0!==i?this.setHex(i):console.warn("THREE.Color: Unknown color "+e),this}clone(){return new this.constructor(this.r,this.g,this.b)}copy(e){return this.r=e.r,this.g=e.g,this.b=e.b,this}copySRGBToLinear(e){return this.r=ub(e.r),this.g=ub(e.g),this.b=ub(e.b),this}copyLinearToSRGB(e){return this.r=Pj(e.r),this.g=Pj(e.g),this.b=Pj(e.b),this}convertSRGBToLinear(){return this.copySRGBToLinear(this),this}convertLinearToSRGB(){return this.copyLinearToSRGB(this),this}getHex(){return 255*this.r<<16^255*this.g<<8^255*this.b<<0}getHexString(){return("000000"+this.getHex().toString(16)).slice(-6)}getHSL(e){let l,c,i=this.r,r=this.g,o=this.b,s=Math.max(i,r,o),a=Math.min(i,r,o),u=(a+s)/2;if(a===s)l=0,c=0;else{let d=s-a;switch(c=u<=.5?d/(s+a):d/(2-s-a),s){case i:l=(r-o)/d+(r<o?6:0);break;case r:l=(o-i)/d+2;break;case o:l=(i-r)/d+4}l/=6}return e.h=l,e.s=c,e.l=u,e}getStyle(){return"rgb("+(255*this.r|0)+","+(255*this.g|0)+","+(255*this.b|0)+")"}offsetHSL(e,i,r){return this.getHSL(au),au.h+=e,au.s+=i,au.l+=r,this.setHSL(au.h,au.s,au.l),this}add(e){return this.r+=e.r,this.g+=e.g,this.b+=e.b,this}addColors(e,i){return this.r=e.r+i.r,this.g=e.g+i.g,this.b=e.b+i.b,this}addScalar(e){return this.r+=e,this.g+=e,this.b+=e,this}sub(e){return this.r=Math.max(0,this.r-e.r),this.g=Math.max(0,this.g-e.g),this.b=Math.max(0,this.b-e.b),this}multiply(e){return this.r*=e.r,this.g*=e.g,this.b*=e.b,this}multiplyScalar(e){return this.r*=e,this.g*=e,this.b*=e,this}lerp(e,i){return this.r+=(e.r-this.r)*i,this.g+=(e.g-this.g)*i,this.b+=(e.b-this.b)*i,this}lerpColors(e,i,r){return this.r=e.r+(i.r-e.r)*r,this.g=e.g+(i.g-e.g)*r,this.b=e.b+(i.b-e.b)*r,this}lerpHSL(e,i){this.getHSL(au),e.getHSL(CO);let r=Aj(au.h,CO.h,i),o=Aj(au.s,CO.s,i),s=Aj(au.l,CO.l,i);return this.setHSL(r,o,s),this}equals(e){return e.r===this.r&&e.g===this.g&&e.b===this.b}fromArray(e,i=0){return this.r=e[i],this.g=e[i+1],this.b=e[i+2],this}toArray(e=[],i=0){return e[i]=this.r,e[i+1]=this.g,e[i+2]=this.b,e}fromBufferAttribute(e,i){return this.r=e.getX(i),this.g=e.getY(i),this.b=e.getZ(i),!0===e.normalized&&(this.r/=255,this.g/=255,this.b/=255),this}toJSON(){return this.getHex()}}return n.NAMES=Cue,n})();vn.prototype.isColor=!0,vn.prototype.r=1,vn.prototype.g=1,vn.prototype.b=1;var Vy,Tp=class{static getDataURL(t){if(/^data:/i.test(t.src)||typeof HTMLCanvasElement>"u")return t.src;let e;if(t instanceof HTMLCanvasElement)e=t;else{void 0===Vy&&(Vy=YS("canvas")),Vy.width=t.width,Vy.height=t.height;let i=Vy.getContext("2d");t instanceof ImageData?i.putImageData(t,0,0):i.drawImage(t,0,0,t.width,t.height),e=Vy}return e.width>2048||e.height>2048?(console.warn("THREE.ImageUtils.getDataURL: Image converted to jpg for performance reasons",t),e.toDataURL("image/jpeg",.6)):e.toDataURL("image/png")}static sRGBToLinear(t){if(typeof HTMLImageElement<"u"&&t instanceof HTMLImageElement||typeof HTMLCanvasElement<"u"&&t instanceof HTMLCanvasElement||typeof ImageBitmap<"u"&&t instanceof ImageBitmap){let e=YS("canvas");e.width=t.width,e.height=t.height;let i=e.getContext("2d");i.drawImage(t,0,0,t.width,t.height);let r=i.getImageData(0,0,t.width,t.height),o=r.data;for(let s=0;s<o.length;s++)o[s]=255*ub(o[s]/255);return i.putImageData(r,0,0),e}if(t.data){let e=t.data.slice(0);for(let i=0;i<e.length;i++)e[i]=e instanceof Uint8Array||e instanceof Uint8ClampedArray?Math.floor(255*ub(e[i]/255)):ub(e[i]);return{data:e,width:t.width,height:t.height}}return console.warn("THREE.ImageUtils.sRGBToLinear(): Unsupported image type. No color space conversion applied."),t}},U8e=0,Ho=class extends Ep{constructor(t=Ho.DEFAULT_IMAGE,e=Ho.DEFAULT_MAPPING,i=El,r=El,o=Gs,s=1008,a=ga,l=_f,c=1,u=bf){super(),Object.defineProperty(this,"id",{value:U8e++}),this.uuid=du(),this.name="",this.image=t,this.mipmaps=[],this.mapping=e,this.wrapS=i,this.wrapT=r,this.magFilter=o,this.minFilter=s,this.anisotropy=c,this.format=a,this.internalFormat=null,this.type=l,this.offset=new at(0,0),this.repeat=new at(1,1),this.center=new at(0,0),this.rotation=0,this.matrixAutoUpdate=!0,this.matrix=new Jo,this.generateMipmaps=!0,this.premultiplyAlpha=!1,this.flipY=!0,this.unpackAlignment=4,this.encoding=u,this.userData={},this.version=0,this.onUpdate=null,this.isRenderTargetTexture=!1,this.needsPMREMUpdate=!1}updateMatrix(){this.matrix.setUvTransform(this.offset.x,this.offset.y,this.repeat.x,this.repeat.y,this.rotation,this.center.x,this.center.y)}clone(){return(new this.constructor).copy(this)}copy(t){return this.name=t.name,this.image=t.image,this.mipmaps=t.mipmaps.slice(0),this.mapping=t.mapping,this.wrapS=t.wrapS,this.wrapT=t.wrapT,this.magFilter=t.magFilter,this.minFilter=t.minFilter,this.anisotropy=t.anisotropy,this.format=t.format,this.internalFormat=t.internalFormat,this.type=t.type,this.offset.copy(t.offset),this.repeat.copy(t.repeat),this.center.copy(t.center),this.rotation=t.rotation,this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrix.copy(t.matrix),this.generateMipmaps=t.generateMipmaps,this.premultiplyAlpha=t.premultiplyAlpha,this.flipY=t.flipY,this.unpackAlignment=t.unpackAlignment,this.encoding=t.encoding,this.userData=JSON.parse(JSON.stringify(t.userData)),this}toJSON(t){let e=void 0===t||"string"==typeof t;if(!e&&void 0!==t.textures[this.uuid])return t.textures[this.uuid];let i={metadata:{version:4.5,type:"Texture",generator:"Texture.toJSON"},uuid:this.uuid,name:this.name,mapping:this.mapping,repeat:[this.repeat.x,this.repeat.y],offset:[this.offset.x,this.offset.y],center:[this.center.x,this.center.y],rotation:this.rotation,wrap:[this.wrapS,this.wrapT],format:this.format,type:this.type,encoding:this.encoding,minFilter:this.minFilter,magFilter:this.magFilter,anisotropy:this.anisotropy,flipY:this.flipY,premultiplyAlpha:this.premultiplyAlpha,unpackAlignment:this.unpackAlignment};if(void 0!==this.image){let r=this.image;if(void 0===r.uuid&&(r.uuid=du()),!e&&void 0===t.images[r.uuid]){let o;if(Array.isArray(r)){o=[];for(let s=0,a=r.length;s<a;s++)o.push(Rj(r[s].isDataTexture?r[s].image:r[s]))}else o=Rj(r);t.images[r.uuid]={uuid:r.uuid,url:o}}i.image=r.uuid}return"{}"!==JSON.stringify(this.userData)&&(i.userData=this.userData),e||(t.textures[this.uuid]=i),i}dispose(){this.dispatchEvent({type:"dispose"})}transformUv(t){if(300!==this.mapping)return t;if(t.applyMatrix3(this.matrix),t.x<0||t.x>1)switch(this.wrapS){case 1e3:t.x=t.x-Math.floor(t.x);break;case El:t.x=t.x<0?0:1;break;case 1002:t.x=1===Math.abs(Math.floor(t.x)%2)?Math.ceil(t.x)-t.x:t.x-Math.floor(t.x)}if(t.y<0||t.y>1)switch(this.wrapT){case 1e3:t.y=t.y-Math.floor(t.y);break;case El:t.y=t.y<0?0:1;break;case 1002:t.y=1===Math.abs(Math.floor(t.y)%2)?Math.ceil(t.y)-t.y:t.y-Math.floor(t.y)}return this.flipY&&(t.y=1-t.y),t}set needsUpdate(t){!0===t&&this.version++}};function Rj(n){return typeof HTMLImageElement<"u"&&n instanceof HTMLImageElement||typeof HTMLCanvasElement<"u"&&n instanceof HTMLCanvasElement||typeof ImageBitmap<"u"&&n instanceof ImageBitmap?Tp.getDataURL(n):n.data?{data:Array.prototype.slice.call(n.data),width:n.width,height:n.height,type:n.data.constructor.name}:(console.warn("THREE.Texture: Unable to serialize Texture."),{})}Ho.DEFAULT_IMAGE=void 0,Ho.DEFAULT_MAPPING=300,Ho.prototype.isTexture=!0;var ar=class{constructor(t=0,e=0,i=0,r=1){this.x=t,this.y=e,this.z=i,this.w=r}get width(){return this.z}set width(t){this.z=t}get height(){return this.w}set height(t){this.w=t}set(t,e,i,r){return this.x=t,this.y=e,this.z=i,this.w=r,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this.w=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setW(t){return this.w=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;case 3:this.w=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;case 3:return this.w;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z,this.w)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this.w=void 0!==t.w?t.w:1,this}add(t,e){return void 0!==e?(console.warn("THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this.w+=t.w,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this.w+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this.z=t.z+e.z,this.w=t.w+e.w,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this.z+=t.z*e,this.w+=t.w*e,this}sub(t,e){return void 0!==e?(console.warn("THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this.w-=t.w,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this.w-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this.z=t.z-e.z,this.w=t.w-e.w,this}multiply(t){return this.x*=t.x,this.y*=t.y,this.z*=t.z,this.w*=t.w,this}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this.w*=t,this}applyMatrix4(t){let e=this.x,i=this.y,r=this.z,o=this.w,s=t.elements;return this.x=s[0]*e+s[4]*i+s[8]*r+s[12]*o,this.y=s[1]*e+s[5]*i+s[9]*r+s[13]*o,this.z=s[2]*e+s[6]*i+s[10]*r+s[14]*o,this.w=s[3]*e+s[7]*i+s[11]*r+s[15]*o,this}divideScalar(t){return this.multiplyScalar(1/t)}setAxisAngleFromQuaternion(t){this.w=2*Math.acos(t.w);let e=Math.sqrt(1-t.w*t.w);return e<1e-4?(this.x=1,this.y=0,this.z=0):(this.x=t.x/e,this.y=t.y/e,this.z=t.z/e),this}setAxisAngleFromRotationMatrix(t){let e,i,r,o,l=t.elements,c=l[0],u=l[4],d=l[8],p=l[1],h=l[5],f=l[9],m=l[2],x=l[6],g=l[10];if(Math.abs(u-p)<.01&&Math.abs(d-m)<.01&&Math.abs(f-x)<.01){if(Math.abs(u+p)<.1&&Math.abs(d+m)<.1&&Math.abs(f+x)<.1&&Math.abs(c+h+g-3)<.1)return this.set(1,0,0,0),this;e=Math.PI;let D=(c+1)/2,T=(h+1)/2,k=(g+1)/2,Z=(u+p)/4,z=(d+m)/4,fe=(f+x)/4;return D>T&&D>k?D<.01?(i=0,r=.707106781,o=.707106781):(i=Math.sqrt(D),r=Z/i,o=z/i):T>k?T<.01?(i=.707106781,r=0,o=.707106781):(r=Math.sqrt(T),i=Z/r,o=fe/r):k<.01?(i=.707106781,r=.707106781,o=0):(o=Math.sqrt(k),i=z/o,r=fe/o),this.set(i,r,o,e),this}let b=Math.sqrt((x-f)*(x-f)+(d-m)*(d-m)+(p-u)*(p-u));return Math.abs(b)<.001&&(b=1),this.x=(x-f)/b,this.y=(d-m)/b,this.z=(p-u)/b,this.w=Math.acos((c+h+g-1)/2),this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this.w=Math.min(this.w,t.w),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this.w=Math.max(this.w,t.w),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this.z=Math.max(t.z,Math.min(e.z,this.z)),this.w=Math.max(t.w,Math.min(e.w,this.w)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this.z=Math.max(t,Math.min(e,this.z)),this.w=Math.max(t,Math.min(e,this.w)),this}clampLength(t,e){let i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(t,Math.min(e,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this.w=Math.floor(this.w),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this.w=Math.ceil(this.w),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this.w=Math.round(this.w),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this.w=this.w<0?Math.ceil(this.w):Math.floor(this.w),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this.w=-this.w,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z+this.w*t.w}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)+Math.abs(this.w)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this.z+=(t.z-this.z)*e,this.w+=(t.w-this.w)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this.z=t.z+(e.z-t.z)*i,this.w=t.w+(e.w-t.w)*i,this}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z&&t.w===this.w}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this.z=t[e+2],this.w=t[e+3],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t[e+2]=this.z,t[e+3]=this.w,t}fromBufferAttribute(t,e,i){return void 0!==i&&console.warn("THREE.Vector4: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this.z=t.getZ(e),this.w=t.getW(e),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this.w=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z,yield this.w}};ar.prototype.isVector4=!0;var Wa=class extends Ep{constructor(t,e,i={}){super(),this.width=t,this.height=e,this.depth=1,this.scissor=new ar(0,0,t,e),this.scissorTest=!1,this.viewport=new ar(0,0,t,e),this.texture=new Ho(void 0,i.mapping,i.wrapS,i.wrapT,i.magFilter,i.minFilter,i.format,i.type,i.anisotropy,i.encoding),this.texture.isRenderTargetTexture=!0,this.texture.image={width:t,height:e,depth:1},this.texture.generateMipmaps=void 0!==i.generateMipmaps&&i.generateMipmaps,this.texture.internalFormat=void 0!==i.internalFormat?i.internalFormat:null,this.texture.minFilter=void 0!==i.minFilter?i.minFilter:Gs,this.depthBuffer=void 0===i.depthBuffer||i.depthBuffer,this.stencilBuffer=void 0!==i.stencilBuffer&&i.stencilBuffer,this.depthTexture=void 0!==i.depthTexture?i.depthTexture:null}setTexture(t){t.image={width:this.width,height:this.height,depth:this.depth},this.texture=t}setSize(t,e,i=1){(this.width!==t||this.height!==e||this.depth!==i)&&(this.width=t,this.height=e,this.depth=i,this.texture.image.width=t,this.texture.image.height=e,this.texture.image.depth=i,this.dispose()),this.viewport.set(0,0,t,e),this.scissor.set(0,0,t,e)}clone(){return(new this.constructor).copy(this)}copy(t){return this.width=t.width,this.height=t.height,this.depth=t.depth,this.viewport.copy(t.viewport),this.texture=t.texture.clone(),this.texture.image=Object.assign({},t.texture.image),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this}dispose(){this.dispatchEvent({type:"dispose"})}};Wa.prototype.isWebGLRenderTarget=!0,class extends Wa{constructor(t,e,i){super(t,e);let r=this.texture;this.texture=[];for(let o=0;o<i;o++)this.texture[o]=r.clone()}setSize(t,e,i=1){if(this.width!==t||this.height!==e||this.depth!==i){this.width=t,this.height=e,this.depth=i;for(let r=0,o=this.texture.length;r<o;r++)this.texture[r].image.width=t,this.texture[r].image.height=e,this.texture[r].image.depth=i;this.dispose()}return this.viewport.set(0,0,t,e),this.scissor.set(0,0,t,e),this}copy(t){this.dispose(),this.width=t.width,this.height=t.height,this.depth=t.depth,this.viewport.set(0,0,this.width,this.height),this.scissor.set(0,0,this.width,this.height),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this.texture.length=0;for(let e=0,i=t.texture.length;e<i;e++)this.texture[e]=t.texture[e].clone();return this}}.prototype.isWebGLMultipleRenderTargets=!0;var XS=class extends Wa{constructor(t,e,i={}){super(t,e,i),this.samples=4,this.ignoreDepthForMultisampleCopy=void 0===i.ignoreDepth||i.ignoreDepth,this.useRenderToTexture=void 0!==i.useRenderToTexture&&i.useRenderToTexture,this.useRenderbuffer=!1===this.useRenderToTexture}copy(t){return super.copy.call(this,t),this.samples=t.samples,this.useRenderToTexture=t.useRenderToTexture,this.useRenderbuffer=t.useRenderbuffer,this}};XS.prototype.isWebGLMultisampleRenderTarget=!0;var qs=class{constructor(t=0,e=0,i=0,r=1){this._x=t,this._y=e,this._z=i,this._w=r}static slerp(t,e,i,r){return console.warn("THREE.Quaternion: Static .slerp() has been deprecated. Use qm.slerpQuaternions( qa, qb, t ) instead."),i.slerpQuaternions(t,e,r)}static slerpFlat(t,e,i,r,o,s,a){let l=i[r+0],c=i[r+1],u=i[r+2],d=i[r+3],p=o[s+0],h=o[s+1],f=o[s+2],m=o[s+3];if(0===a)return t[e+0]=l,t[e+1]=c,t[e+2]=u,void(t[e+3]=d);if(1===a)return t[e+0]=p,t[e+1]=h,t[e+2]=f,void(t[e+3]=m);if(d!==m||l!==p||c!==h||u!==f){let x=1-a,g=l*p+c*h+u*f+d*m,b=g>=0?1:-1,D=1-g*g;if(D>Number.EPSILON){let k=Math.sqrt(D),Z=Math.atan2(k,g*b);x=Math.sin(x*Z)/k,a=Math.sin(a*Z)/k}let T=a*b;if(l=l*x+p*T,c=c*x+h*T,u=u*x+f*T,d=d*x+m*T,x===1-a){let k=1/Math.sqrt(l*l+c*c+u*u+d*d);l*=k,c*=k,u*=k,d*=k}}t[e]=l,t[e+1]=c,t[e+2]=u,t[e+3]=d}static multiplyQuaternionsFlat(t,e,i,r,o,s){let a=i[r],l=i[r+1],c=i[r+2],u=i[r+3],d=o[s],p=o[s+1],h=o[s+2],f=o[s+3];return t[e]=a*f+u*d+l*h-c*p,t[e+1]=l*f+u*p+c*d-a*h,t[e+2]=c*f+u*h+a*p-l*d,t[e+3]=u*f-a*d-l*p-c*h,t}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get w(){return this._w}set w(t){this._w=t,this._onChangeCallback()}set(t,e,i,r){return this._x=t,this._y=e,this._z=i,this._w=r,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._w)}copy(t){return this._x=t.x,this._y=t.y,this._z=t.z,this._w=t.w,this._onChangeCallback(),this}setFromEuler(t,e){if(!t||!t.isEuler)throw new Error("THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.");let i=t._x,r=t._y,o=t._z,s=t._order,a=Math.cos,l=Math.sin,c=a(i/2),u=a(r/2),d=a(o/2),p=l(i/2),h=l(r/2),f=l(o/2);switch(s){case"XYZ":this._x=p*u*d+c*h*f,this._y=c*h*d-p*u*f,this._z=c*u*f+p*h*d,this._w=c*u*d-p*h*f;break;case"YXZ":this._x=p*u*d+c*h*f,this._y=c*h*d-p*u*f,this._z=c*u*f-p*h*d,this._w=c*u*d+p*h*f;break;case"ZXY":this._x=p*u*d-c*h*f,this._y=c*h*d+p*u*f,this._z=c*u*f+p*h*d,this._w=c*u*d-p*h*f;break;case"ZYX":this._x=p*u*d-c*h*f,this._y=c*h*d+p*u*f,this._z=c*u*f-p*h*d,this._w=c*u*d+p*h*f;break;case"YZX":this._x=p*u*d+c*h*f,this._y=c*h*d+p*u*f,this._z=c*u*f-p*h*d,this._w=c*u*d-p*h*f;break;case"XZY":this._x=p*u*d-c*h*f,this._y=c*h*d-p*u*f,this._z=c*u*f+p*h*d,this._w=c*u*d+p*h*f;break;default:console.warn("THREE.Quaternion: .setFromEuler() encountered an unknown order: "+s)}return!1!==e&&this._onChangeCallback(),this}setFromAxisAngle(t,e){let i=e/2,r=Math.sin(i);return this._x=t.x*r,this._y=t.y*r,this._z=t.z*r,this._w=Math.cos(i),this._onChangeCallback(),this}setFromRotationMatrix(t){let e=t.elements,i=e[0],r=e[4],o=e[8],s=e[1],a=e[5],l=e[9],c=e[2],u=e[6],d=e[10],p=i+a+d;if(p>0){let h=.5/Math.sqrt(p+1);this._w=.25/h,this._x=(u-l)*h,this._y=(o-c)*h,this._z=(s-r)*h}else if(i>a&&i>d){let h=2*Math.sqrt(1+i-a-d);this._w=(u-l)/h,this._x=.25*h,this._y=(r+s)/h,this._z=(o+c)/h}else if(a>d){let h=2*Math.sqrt(1+a-i-d);this._w=(o-c)/h,this._x=(r+s)/h,this._y=.25*h,this._z=(l+u)/h}else{let h=2*Math.sqrt(1+d-i-a);this._w=(s-r)/h,this._x=(o+c)/h,this._y=(l+u)/h,this._z=.25*h}return this._onChangeCallback(),this}setFromUnitVectors(t,e){let i=t.dot(e)+1;return i<Number.EPSILON?(i=0,Math.abs(t.x)>Math.abs(t.z)?(this._x=-t.y,this._y=t.x,this._z=0,this._w=i):(this._x=0,this._y=-t.z,this._z=t.y,this._w=i)):(this._x=t.y*e.z-t.z*e.y,this._y=t.z*e.x-t.x*e.z,this._z=t.x*e.y-t.y*e.x,this._w=i),this.normalize()}angleTo(t){return 2*Math.acos(Math.abs(Ga(this.dot(t),-1,1)))}rotateTowards(t,e){let i=this.angleTo(t);if(0===i)return this;let r=Math.min(1,e/i);return this.slerp(t,r),this}identity(){return this.set(0,0,0,1)}invert(){return this.conjugate()}conjugate(){return this._x*=-1,this._y*=-1,this._z*=-1,this._onChangeCallback(),this}dot(t){return this._x*t._x+this._y*t._y+this._z*t._z+this._w*t._w}lengthSq(){return this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w}length(){return Math.sqrt(this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w)}normalize(){let t=this.length();return 0===t?(this._x=0,this._y=0,this._z=0,this._w=1):(t=1/t,this._x=this._x*t,this._y=this._y*t,this._z=this._z*t,this._w=this._w*t),this._onChangeCallback(),this}multiply(t,e){return void 0!==e?(console.warn("THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead."),this.multiplyQuaternions(t,e)):this.multiplyQuaternions(this,t)}premultiply(t){return this.multiplyQuaternions(t,this)}multiplyQuaternions(t,e){let i=t._x,r=t._y,o=t._z,s=t._w,a=e._x,l=e._y,c=e._z,u=e._w;return this._x=i*u+s*a+r*c-o*l,this._y=r*u+s*l+o*a-i*c,this._z=o*u+s*c+i*l-r*a,this._w=s*u-i*a-r*l-o*c,this._onChangeCallback(),this}slerp(t,e){if(0===e)return this;if(1===e)return this.copy(t);let i=this._x,r=this._y,o=this._z,s=this._w,a=s*t._w+i*t._x+r*t._y+o*t._z;if(a<0?(this._w=-t._w,this._x=-t._x,this._y=-t._y,this._z=-t._z,a=-a):this.copy(t),a>=1)return this._w=s,this._x=i,this._y=r,this._z=o,this;let l=1-a*a;if(l<=Number.EPSILON){let h=1-e;return this._w=h*s+e*this._w,this._x=h*i+e*this._x,this._y=h*r+e*this._y,this._z=h*o+e*this._z,this.normalize(),this._onChangeCallback(),this}let c=Math.sqrt(l),u=Math.atan2(c,a),d=Math.sin((1-e)*u)/c,p=Math.sin(e*u)/c;return this._w=s*d+this._w*p,this._x=i*d+this._x*p,this._y=r*d+this._y*p,this._z=o*d+this._z*p,this._onChangeCallback(),this}slerpQuaternions(t,e,i){return this.copy(t).slerp(e,i)}random(){let t=Math.random(),e=Math.sqrt(1-t),i=Math.sqrt(t),r=2*Math.PI*Math.random(),o=2*Math.PI*Math.random();return this.set(e*Math.cos(r),i*Math.sin(o),i*Math.cos(o),e*Math.sin(r))}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._w===this._w}fromArray(t,e=0){return this._x=t[e],this._y=t[e+1],this._z=t[e+2],this._w=t[e+3],this._onChangeCallback(),this}toArray(t=[],e=0){return t[e]=this._x,t[e+1]=this._y,t[e+2]=this._z,t[e+3]=this._w,t}fromBufferAttribute(t,e){return this._x=t.getX(e),this._y=t.getY(e),this._z=t.getZ(e),this._w=t.getW(e),this}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}};qs.prototype.isQuaternion=!0;var ie=class{constructor(t=0,e=0,i=0){this.x=t,this.y=e,this.z=i}set(t,e,i){return void 0===i&&(i=this.z),this.x=t,this.y=e,this.z=i,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this}add(t,e){return void 0!==e?(console.warn("THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this.z=t.z+e.z,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this.z+=t.z*e,this}sub(t,e){return void 0!==e?(console.warn("THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this.z=t.z-e.z,this}multiply(t,e){return void 0!==e?(console.warn("THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead."),this.multiplyVectors(t,e)):(this.x*=t.x,this.y*=t.y,this.z*=t.z,this)}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this}multiplyVectors(t,e){return this.x=t.x*e.x,this.y=t.y*e.y,this.z=t.z*e.z,this}applyEuler(t){return t&&t.isEuler||console.error("THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order."),this.applyQuaternion(Mue.setFromEuler(t))}applyAxisAngle(t,e){return this.applyQuaternion(Mue.setFromAxisAngle(t,e))}applyMatrix3(t){let e=this.x,i=this.y,r=this.z,o=t.elements;return this.x=o[0]*e+o[3]*i+o[6]*r,this.y=o[1]*e+o[4]*i+o[7]*r,this.z=o[2]*e+o[5]*i+o[8]*r,this}applyNormalMatrix(t){return this.applyMatrix3(t).normalize()}applyMatrix4(t){let e=this.x,i=this.y,r=this.z,o=t.elements,s=1/(o[3]*e+o[7]*i+o[11]*r+o[15]);return this.x=(o[0]*e+o[4]*i+o[8]*r+o[12])*s,this.y=(o[1]*e+o[5]*i+o[9]*r+o[13])*s,this.z=(o[2]*e+o[6]*i+o[10]*r+o[14])*s,this}applyQuaternion(t){let e=this.x,i=this.y,r=this.z,o=t.x,s=t.y,a=t.z,l=t.w,c=l*e+s*r-a*i,u=l*i+a*e-o*r,d=l*r+o*i-s*e,p=-o*e-s*i-a*r;return this.x=c*l+p*-o+u*-a-d*-s,this.y=u*l+p*-s+d*-o-c*-a,this.z=d*l+p*-a+c*-s-u*-o,this}project(t){return this.applyMatrix4(t.matrixWorldInverse).applyMatrix4(t.projectionMatrix)}unproject(t){return this.applyMatrix4(t.projectionMatrixInverse).applyMatrix4(t.matrixWorld)}transformDirection(t){let e=this.x,i=this.y,r=this.z,o=t.elements;return this.x=o[0]*e+o[4]*i+o[8]*r,this.y=o[1]*e+o[5]*i+o[9]*r,this.z=o[2]*e+o[6]*i+o[10]*r,this.normalize()}divide(t){return this.x/=t.x,this.y/=t.y,this.z/=t.z,this}divideScalar(t){return this.multiplyScalar(1/t)}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this.z=Math.max(t.z,Math.min(e.z,this.z)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this.z=Math.max(t,Math.min(e,this.z)),this}clampLength(t,e){let i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(t,Math.min(e,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this.z+=(t.z-this.z)*e,this}lerpVectors(t,e,i){return this.x=t.x+(e.x-t.x)*i,this.y=t.y+(e.y-t.y)*i,this.z=t.z+(e.z-t.z)*i,this}cross(t,e){return void 0!==e?(console.warn("THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead."),this.crossVectors(t,e)):this.crossVectors(this,t)}crossVectors(t,e){let i=t.x,r=t.y,o=t.z,s=e.x,a=e.y,l=e.z;return this.x=r*l-o*a,this.y=o*s-i*l,this.z=i*a-r*s,this}projectOnVector(t){let e=t.lengthSq();if(0===e)return this.set(0,0,0);let i=t.dot(this)/e;return this.copy(t).multiplyScalar(i)}projectOnPlane(t){return Oj.copy(this).projectOnVector(t),this.sub(Oj)}reflect(t){return this.sub(Oj.copy(t).multiplyScalar(2*this.dot(t)))}angleTo(t){let e=Math.sqrt(this.lengthSq()*t.lengthSq());if(0===e)return Math.PI/2;let i=this.dot(t)/e;return Math.acos(Ga(i,-1,1))}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){let e=this.x-t.x,i=this.y-t.y,r=this.z-t.z;return e*e+i*i+r*r}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)+Math.abs(this.z-t.z)}setFromSpherical(t){return this.setFromSphericalCoords(t.radius,t.phi,t.theta)}setFromSphericalCoords(t,e,i){let r=Math.sin(e)*t;return this.x=r*Math.sin(i),this.y=Math.cos(e)*t,this.z=r*Math.cos(i),this}setFromCylindrical(t){return this.setFromCylindricalCoords(t.radius,t.theta,t.y)}setFromCylindricalCoords(t,e,i){return this.x=t*Math.sin(e),this.y=i,this.z=t*Math.cos(e),this}setFromMatrixPosition(t){let e=t.elements;return this.x=e[12],this.y=e[13],this.z=e[14],this}setFromMatrixScale(t){let e=this.setFromMatrixColumn(t,0).length(),i=this.setFromMatrixColumn(t,1).length(),r=this.setFromMatrixColumn(t,2).length();return this.x=e,this.y=i,this.z=r,this}setFromMatrixColumn(t,e){return this.fromArray(t.elements,4*e)}setFromMatrix3Column(t,e){return this.fromArray(t.elements,3*e)}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this.z=t[e+2],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t[e+2]=this.z,t}fromBufferAttribute(t,e,i){return void 0!==i&&console.warn("THREE.Vector3: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this.z=t.getZ(e),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this}randomDirection(){let t=2*(Math.random()-.5),e=Math.random()*Math.PI*2,i=Math.sqrt(1-t**2);return this.x=i*Math.cos(e),this.y=i*Math.sin(e),this.z=t,this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z}};ie.prototype.isVector3=!0;var Oj=new ie,Mue=new qs,Tl=class{constructor(t=new ie(1/0,1/0,1/0),e=new ie(-1/0,-1/0,-1/0)){this.min=t,this.max=e}set(t,e){return this.min.copy(t),this.max.copy(e),this}setFromArray(t){let e=1/0,i=1/0,r=1/0,o=-1/0,s=-1/0,a=-1/0;for(let l=0,c=t.length;l<c;l+=3){let u=t[l],d=t[l+1],p=t[l+2];u<e&&(e=u),d<i&&(i=d),p<r&&(r=p),u>o&&(o=u),d>s&&(s=d),p>a&&(a=p)}return this.min.set(e,i,r),this.max.set(o,s,a),this}setFromBufferAttribute(t){let e=1/0,i=1/0,r=1/0,o=-1/0,s=-1/0,a=-1/0;for(let l=0,c=t.count;l<c;l++){let u=t.getX(l),d=t.getY(l),p=t.getZ(l);u<e&&(e=u),d<i&&(i=d),p<r&&(r=p),u>o&&(o=u),d>s&&(s=d),p>a&&(a=p)}return this.min.set(e,i,r),this.max.set(o,s,a),this}setFromPoints(t){this.makeEmpty();for(let e=0,i=t.length;e<i;e++)this.expandByPoint(t[e]);return this}setFromCenterAndSize(t,e){let i=Lg.copy(e).multiplyScalar(.5);return this.min.copy(t).sub(i),this.max.copy(t).add(i),this}setFromObject(t,e=!1){return this.makeEmpty(),this.expandByObject(t,e)}clone(){return(new this.constructor).copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=this.min.z=1/0,this.max.x=this.max.y=this.max.z=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y||this.max.z<this.min.z}getCenter(t){return this.isEmpty()?t.set(0,0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return this.isEmpty()?t.set(0,0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}expandByObject(t,e=!1){t.updateWorldMatrix(!1,!1);let i=t.geometry;if(void 0!==i)if(e&&null!=i.attributes&&void 0!==i.attributes.position){let o=i.attributes.position;for(let s=0,a=o.count;s<a;s++)Lg.fromBufferAttribute(o,s).applyMatrix4(t.matrixWorld),this.expandByPoint(Lg)}else null===i.boundingBox&&i.computeBoundingBox(),kj.copy(i.boundingBox),kj.applyMatrix4(t.matrixWorld),this.union(kj);let r=t.children;for(let o=0,s=r.length;o<s;o++)this.expandByObject(r[o],e);return this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y||t.z<this.min.z||t.z>this.max.z)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y&&this.min.z<=t.min.z&&t.max.z<=this.max.z}getParameter(t,e){return e.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y),(t.z-this.min.z)/(this.max.z-this.min.z))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y||t.max.z<this.min.z||t.min.z>this.max.z)}intersectsSphere(t){return this.clampPoint(t.center,Lg),Lg.distanceToSquared(t.center)<=t.radius*t.radius}intersectsPlane(t){let e,i;return t.normal.x>0?(e=t.normal.x*this.min.x,i=t.normal.x*this.max.x):(e=t.normal.x*this.max.x,i=t.normal.x*this.min.x),t.normal.y>0?(e+=t.normal.y*this.min.y,i+=t.normal.y*this.max.y):(e+=t.normal.y*this.max.y,i+=t.normal.y*this.min.y),t.normal.z>0?(e+=t.normal.z*this.min.z,i+=t.normal.z*this.max.z):(e+=t.normal.z*this.max.z,i+=t.normal.z*this.min.z),e<=-t.constant&&i>=-t.constant}intersectsTriangle(t){if(this.isEmpty())return!1;this.getCenter(AS),MO.subVectors(this.max,AS),Hy.subVectors(t.a,AS),Uy.subVectors(t.b,AS),zy.subVectors(t.c,AS),af.subVectors(Uy,Hy),lf.subVectors(zy,Uy),Bg.subVectors(Hy,zy);let e=[0,-af.z,af.y,0,-lf.z,lf.y,0,-Bg.z,Bg.y,af.z,0,-af.x,lf.z,0,-lf.x,Bg.z,0,-Bg.x,-af.y,af.x,0,-lf.y,lf.x,0,-Bg.y,Bg.x,0];return!(!Fj(e,Hy,Uy,zy,MO)||(e=[1,0,0,0,1,0,0,0,1],!Fj(e,Hy,Uy,zy,MO)))&&(wO.crossVectors(af,lf),e=[wO.x,wO.y,wO.z],Fj(e,Hy,Uy,zy,MO))}clampPoint(t,e){return e.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return Lg.copy(t).clamp(this.min,this.max).sub(t).length()}getBoundingSphere(t){return this.getCenter(t.center),t.radius=.5*this.getSize(Lg).length(),t}intersect(t){return this.min.max(t.min),this.max.min(t.max),this.isEmpty()&&this.makeEmpty(),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}applyMatrix4(t){return this.isEmpty()||(bp[0].set(this.min.x,this.min.y,this.min.z).applyMatrix4(t),bp[1].set(this.min.x,this.min.y,this.max.z).applyMatrix4(t),bp[2].set(this.min.x,this.max.y,this.min.z).applyMatrix4(t),bp[3].set(this.min.x,this.max.y,this.max.z).applyMatrix4(t),bp[4].set(this.max.x,this.min.y,this.min.z).applyMatrix4(t),bp[5].set(this.max.x,this.min.y,this.max.z).applyMatrix4(t),bp[6].set(this.max.x,this.max.y,this.min.z).applyMatrix4(t),bp[7].set(this.max.x,this.max.y,this.max.z).applyMatrix4(t),this.setFromPoints(bp)),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}};Tl.prototype.isBox3=!0;var bp=[new ie,new ie,new ie,new ie,new ie,new ie,new ie,new ie],Lg=new ie,kj=new Tl,Hy=new ie,Uy=new ie,zy=new ie,af=new ie,lf=new ie,Bg=new ie,AS=new ie,MO=new ie,wO=new ie,Vg=new ie;function Fj(n,t,e,i,r){for(let o=0,s=n.length-3;o<=s;o+=3){Vg.fromArray(n,o);let a=r.x*Math.abs(Vg.x)+r.y*Math.abs(Vg.y)+r.z*Math.abs(Vg.z),l=t.dot(Vg),c=e.dot(Vg),u=i.dot(Vg);if(Math.max(-Math.max(l,c,u),Math.min(l,c,u))>a)return!1}return!0}var z8e=new Tl,wue=new ie,SO=new ie,Nj=new ie,xf=class{constructor(t=new ie,e=-1){this.center=t,this.radius=e}set(t,e){return this.center.copy(t),this.radius=e,this}setFromPoints(t,e){let i=this.center;void 0!==e?i.copy(e):z8e.setFromPoints(t).getCenter(i);let r=0;for(let o=0,s=t.length;o<s;o++)r=Math.max(r,i.distanceToSquared(t[o]));return this.radius=Math.sqrt(r),this}copy(t){return this.center.copy(t.center),this.radius=t.radius,this}isEmpty(){return this.radius<0}makeEmpty(){return this.center.set(0,0,0),this.radius=-1,this}containsPoint(t){return t.distanceToSquared(this.center)<=this.radius*this.radius}distanceToPoint(t){return t.distanceTo(this.center)-this.radius}intersectsSphere(t){let e=this.radius+t.radius;return t.center.distanceToSquared(this.center)<=e*e}intersectsBox(t){return t.intersectsSphere(this)}intersectsPlane(t){return Math.abs(t.distanceToPoint(this.center))<=this.radius}clampPoint(t,e){let i=this.center.distanceToSquared(t);return e.copy(t),i>this.radius*this.radius&&(e.sub(this.center).normalize(),e.multiplyScalar(this.radius).add(this.center)),e}getBoundingBox(t){return this.isEmpty()?(t.makeEmpty(),t):(t.set(this.center,this.center),t.expandByScalar(this.radius),t)}applyMatrix4(t){return this.center.applyMatrix4(t),this.radius=this.radius*t.getMaxScaleOnAxis(),this}translate(t){return this.center.add(t),this}expandByPoint(t){Nj.subVectors(t,this.center);let e=Nj.lengthSq();if(e>this.radius*this.radius){let i=Math.sqrt(e),r=.5*(i-this.radius);this.center.add(Nj.multiplyScalar(r/i)),this.radius+=r}return this}union(t){return!0===this.center.equals(t.center)?SO.set(0,0,1).multiplyScalar(t.radius):SO.subVectors(t.center,this.center).normalize().multiplyScalar(t.radius),this.expandByPoint(wue.copy(t.center).add(SO)),this.expandByPoint(wue.copy(t.center).sub(SO)),this}equals(t){return t.center.equals(this.center)&&t.radius===this.radius}clone(){return(new this.constructor).copy(this)}},xp=new ie,Lj=new ie,EO=new ie,cf=new ie,Bj=new ie,TO=new ie,Vj=new ie,Cf=class{constructor(t=new ie,e=new ie(0,0,-1)){this.origin=t,this.direction=e}set(t,e){return this.origin.copy(t),this.direction.copy(e),this}copy(t){return this.origin.copy(t.origin),this.direction.copy(t.direction),this}at(t,e){return e.copy(this.direction).multiplyScalar(t).add(this.origin)}lookAt(t){return this.direction.copy(t).sub(this.origin).normalize(),this}recast(t){return this.origin.copy(this.at(t,xp)),this}closestPointToPoint(t,e){e.subVectors(t,this.origin);let i=e.dot(this.direction);return i<0?e.copy(this.origin):e.copy(this.direction).multiplyScalar(i).add(this.origin)}distanceToPoint(t){return Math.sqrt(this.distanceSqToPoint(t))}distanceSqToPoint(t){let e=xp.subVectors(t,this.origin).dot(this.direction);return e<0?this.origin.distanceToSquared(t):(xp.copy(this.direction).multiplyScalar(e).add(this.origin),xp.distanceToSquared(t))}distanceSqToSegment(t,e,i,r){Lj.copy(t).add(e).multiplyScalar(.5),EO.copy(e).sub(t).normalize(),cf.copy(this.origin).sub(Lj);let d,p,h,f,o=.5*t.distanceTo(e),s=-this.direction.dot(EO),a=cf.dot(this.direction),l=-cf.dot(EO),c=cf.lengthSq(),u=Math.abs(1-s*s);if(u>0)if(d=s*l-a,p=s*a-l,f=o*u,d>=0)if(p>=-f)if(p<=f){let m=1/u;d*=m,p*=m,h=d*(d+s*p+2*a)+p*(s*d+p+2*l)+c}else p=o,d=Math.max(0,-(s*p+a)),h=-d*d+p*(p+2*l)+c;else p=-o,d=Math.max(0,-(s*p+a)),h=-d*d+p*(p+2*l)+c;else p<=-f?(d=Math.max(0,-(-s*o+a)),p=d>0?-o:Math.min(Math.max(-o,-l),o),h=-d*d+p*(p+2*l)+c):p<=f?(d=0,p=Math.min(Math.max(-o,-l),o),h=p*(p+2*l)+c):(d=Math.max(0,-(s*o+a)),p=d>0?o:Math.min(Math.max(-o,-l),o),h=-d*d+p*(p+2*l)+c);else p=s>0?-o:o,d=Math.max(0,-(s*p+a)),h=-d*d+p*(p+2*l)+c;return i&&i.copy(this.direction).multiplyScalar(d).add(this.origin),r&&r.copy(EO).multiplyScalar(p).add(Lj),h}intersectSphere(t,e){xp.subVectors(t.center,this.origin);let i=xp.dot(this.direction),r=xp.dot(xp)-i*i,o=t.radius*t.radius;if(r>o)return null;let s=Math.sqrt(o-r),a=i-s,l=i+s;return a<0&&l<0?null:this.at(a<0?l:a,e)}intersectsSphere(t){return this.distanceSqToPoint(t.center)<=t.radius*t.radius}distanceToPlane(t){let e=t.normal.dot(this.direction);if(0===e)return 0===t.distanceToPoint(this.origin)?0:null;let i=-(this.origin.dot(t.normal)+t.constant)/e;return i>=0?i:null}intersectPlane(t,e){let i=this.distanceToPlane(t);return null===i?null:this.at(i,e)}intersectsPlane(t){let e=t.distanceToPoint(this.origin);return 0===e||t.normal.dot(this.direction)*e<0}intersectBox(t,e){let i,r,o,s,a,l,c=1/this.direction.x,u=1/this.direction.y,d=1/this.direction.z,p=this.origin;return c>=0?(i=(t.min.x-p.x)*c,r=(t.max.x-p.x)*c):(i=(t.max.x-p.x)*c,r=(t.min.x-p.x)*c),u>=0?(o=(t.min.y-p.y)*u,s=(t.max.y-p.y)*u):(o=(t.max.y-p.y)*u,s=(t.min.y-p.y)*u),i>s||o>r||((o>i||i!=i)&&(i=o),(s<r||r!=r)&&(r=s),d>=0?(a=(t.min.z-p.z)*d,l=(t.max.z-p.z)*d):(a=(t.max.z-p.z)*d,l=(t.min.z-p.z)*d),i>l||a>r)||((a>i||i!=i)&&(i=a),(l<r||r!=r)&&(r=l),r<0)?null:this.at(i>=0?i:r,e)}intersectsBox(t){return null!==this.intersectBox(t,xp)}intersectTriangle(t,e,i,r,o){Bj.subVectors(e,t),TO.subVectors(i,t),Vj.crossVectors(Bj,TO);let a,s=this.direction.dot(Vj);if(s>0){if(r)return null;a=1}else{if(!(s<0))return null;a=-1,s=-s}cf.subVectors(this.origin,t);let l=a*this.direction.dot(TO.crossVectors(cf,TO));if(l<0)return null;let c=a*this.direction.dot(Bj.cross(cf));if(c<0||l+c>s)return null;let u=-a*cf.dot(Vj);return u<0?null:this.at(u/s,o)}applyMatrix4(t){return this.origin.applyMatrix4(t),this.direction.transformDirection(t),this}equals(t){return t.origin.equals(this.origin)&&t.direction.equals(this.direction)}clone(){return(new this.constructor).copy(this)}},Rn=class{constructor(){this.elements=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.")}set(t,e,i,r,o,s,a,l,c,u,d,p,h,f,m,x){let g=this.elements;return g[0]=t,g[4]=e,g[8]=i,g[12]=r,g[1]=o,g[5]=s,g[9]=a,g[13]=l,g[2]=c,g[6]=u,g[10]=d,g[14]=p,g[3]=h,g[7]=f,g[11]=m,g[15]=x,this}identity(){return this.set(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1),this}clone(){return(new Rn).fromArray(this.elements)}copy(t){let e=this.elements,i=t.elements;return e[0]=i[0],e[1]=i[1],e[2]=i[2],e[3]=i[3],e[4]=i[4],e[5]=i[5],e[6]=i[6],e[7]=i[7],e[8]=i[8],e[9]=i[9],e[10]=i[10],e[11]=i[11],e[12]=i[12],e[13]=i[13],e[14]=i[14],e[15]=i[15],this}copyPosition(t){let e=this.elements,i=t.elements;return e[12]=i[12],e[13]=i[13],e[14]=i[14],this}setFromMatrix3(t){let e=t.elements;return this.set(e[0],e[3],e[6],0,e[1],e[4],e[7],0,e[2],e[5],e[8],0,0,0,0,1),this}extractBasis(t,e,i){return t.setFromMatrixColumn(this,0),e.setFromMatrixColumn(this,1),i.setFromMatrixColumn(this,2),this}makeBasis(t,e,i){return this.set(t.x,e.x,i.x,0,t.y,e.y,i.y,0,t.z,e.z,i.z,0,0,0,0,1),this}extractRotation(t){let e=this.elements,i=t.elements,r=1/jy.setFromMatrixColumn(t,0).length(),o=1/jy.setFromMatrixColumn(t,1).length(),s=1/jy.setFromMatrixColumn(t,2).length();return e[0]=i[0]*r,e[1]=i[1]*r,e[2]=i[2]*r,e[3]=0,e[4]=i[4]*o,e[5]=i[5]*o,e[6]=i[6]*o,e[7]=0,e[8]=i[8]*s,e[9]=i[9]*s,e[10]=i[10]*s,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,this}makeRotationFromEuler(t){t&&t.isEuler||console.error("THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.");let e=this.elements,i=t.x,r=t.y,o=t.z,s=Math.cos(i),a=Math.sin(i),l=Math.cos(r),c=Math.sin(r),u=Math.cos(o),d=Math.sin(o);if("XYZ"===t.order){let p=s*u,h=s*d,f=a*u,m=a*d;e[0]=l*u,e[4]=-l*d,e[8]=c,e[1]=h+f*c,e[5]=p-m*c,e[9]=-a*l,e[2]=m-p*c,e[6]=f+h*c,e[10]=s*l}else if("YXZ"===t.order){let p=l*u,h=l*d,f=c*u,m=c*d;e[0]=p+m*a,e[4]=f*a-h,e[8]=s*c,e[1]=s*d,e[5]=s*u,e[9]=-a,e[2]=h*a-f,e[6]=m+p*a,e[10]=s*l}else if("ZXY"===t.order){let p=l*u,h=l*d,f=c*u,m=c*d;e[0]=p-m*a,e[4]=-s*d,e[8]=f+h*a,e[1]=h+f*a,e[5]=s*u,e[9]=m-p*a,e[2]=-s*c,e[6]=a,e[10]=s*l}else if("ZYX"===t.order){let p=s*u,h=s*d,f=a*u,m=a*d;e[0]=l*u,e[4]=f*c-h,e[8]=p*c+m,e[1]=l*d,e[5]=m*c+p,e[9]=h*c-f,e[2]=-c,e[6]=a*l,e[10]=s*l}else if("YZX"===t.order){let p=s*l,h=s*c,f=a*l,m=a*c;e[0]=l*u,e[4]=m-p*d,e[8]=f*d+h,e[1]=d,e[5]=s*u,e[9]=-a*u,e[2]=-c*u,e[6]=h*d+f,e[10]=p-m*d}else if("XZY"===t.order){let p=s*l,h=s*c,f=a*l,m=a*c;e[0]=l*u,e[4]=-d,e[8]=c*u,e[1]=p*d+m,e[5]=s*u,e[9]=h*d-f,e[2]=f*d-h,e[6]=a*u,e[10]=m*d+p}return e[3]=0,e[7]=0,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,this}makeRotationFromQuaternion(t){return this.compose(j8e,t,G8e)}lookAt(t,e,i){let r=this.elements;return wl.subVectors(t,e),0===wl.lengthSq()&&(wl.z=1),wl.normalize(),uf.crossVectors(i,wl),0===uf.lengthSq()&&(1===Math.abs(i.z)?wl.x+=1e-4:wl.z+=1e-4,wl.normalize(),uf.crossVectors(i,wl)),uf.normalize(),DO.crossVectors(wl,uf),r[0]=uf.x,r[4]=DO.x,r[8]=wl.x,r[1]=uf.y,r[5]=DO.y,r[9]=wl.y,r[2]=uf.z,r[6]=DO.z,r[10]=wl.z,this}multiply(t,e){return void 0!==e?(console.warn("THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead."),this.multiplyMatrices(t,e)):this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,e){let i=t.elements,r=e.elements,o=this.elements,s=i[0],a=i[4],l=i[8],c=i[12],u=i[1],d=i[5],p=i[9],h=i[13],f=i[2],m=i[6],x=i[10],g=i[14],b=i[3],D=i[7],T=i[11],k=i[15],Z=r[0],z=r[4],fe=r[8],ue=r[12],he=r[1],w=r[5],F=r[9],q=r[13],K=r[2],de=r[6],Y=r[10],ae=r[14],le=r[3],Ie=r[7],ve=r[11],De=r[15];return o[0]=s*Z+a*he+l*K+c*le,o[4]=s*z+a*w+l*de+c*Ie,o[8]=s*fe+a*F+l*Y+c*ve,o[12]=s*ue+a*q+l*ae+c*De,o[1]=u*Z+d*he+p*K+h*le,o[5]=u*z+d*w+p*de+h*Ie,o[9]=u*fe+d*F+p*Y+h*ve,o[13]=u*ue+d*q+p*ae+h*De,o[2]=f*Z+m*he+x*K+g*le,o[6]=f*z+m*w+x*de+g*Ie,o[10]=f*fe+m*F+x*Y+g*ve,o[14]=f*ue+m*q+x*ae+g*De,o[3]=b*Z+D*he+T*K+k*le,o[7]=b*z+D*w+T*de+k*Ie,o[11]=b*fe+D*F+T*Y+k*ve,o[15]=b*ue+D*q+T*ae+k*De,this}multiplyScalar(t){let e=this.elements;return e[0]*=t,e[4]*=t,e[8]*=t,e[12]*=t,e[1]*=t,e[5]*=t,e[9]*=t,e[13]*=t,e[2]*=t,e[6]*=t,e[10]*=t,e[14]*=t,e[3]*=t,e[7]*=t,e[11]*=t,e[15]*=t,this}determinant(){let t=this.elements,e=t[0],i=t[4],r=t[8],o=t[12],s=t[1],a=t[5],l=t[9],c=t[13],u=t[2],d=t[6],p=t[10],h=t[14];return t[3]*(+o*l*d-r*c*d-o*a*p+i*c*p+r*a*h-i*l*h)+t[7]*(+e*l*h-e*c*p+o*s*p-r*s*h+r*c*u-o*l*u)+t[11]*(+e*c*d-e*a*h-o*s*d+i*s*h+o*a*u-i*c*u)+t[15]*(-r*a*u-e*l*d+e*a*p+r*s*d-i*s*p+i*l*u)}transpose(){let e,t=this.elements;return e=t[1],t[1]=t[4],t[4]=e,e=t[2],t[2]=t[8],t[8]=e,e=t[6],t[6]=t[9],t[9]=e,e=t[3],t[3]=t[12],t[12]=e,e=t[7],t[7]=t[13],t[13]=e,e=t[11],t[11]=t[14],t[14]=e,this}setPosition(t,e,i){let r=this.elements;return t.isVector3?(r[12]=t.x,r[13]=t.y,r[14]=t.z):(r[12]=t,r[13]=e,r[14]=i),this}invert(){let t=this.elements,e=t[0],i=t[1],r=t[2],o=t[3],s=t[4],a=t[5],l=t[6],c=t[7],u=t[8],d=t[9],p=t[10],h=t[11],f=t[12],m=t[13],x=t[14],g=t[15],b=d*x*c-m*p*c+m*l*h-a*x*h-d*l*g+a*p*g,D=f*p*c-u*x*c-f*l*h+s*x*h+u*l*g-s*p*g,T=u*m*c-f*d*c+f*a*h-s*m*h-u*a*g+s*d*g,k=f*d*l-u*m*l-f*a*p+s*m*p+u*a*x-s*d*x,Z=e*b+i*D+r*T+o*k;if(0===Z)return this.set(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);let z=1/Z;return t[0]=b*z,t[1]=(m*p*o-d*x*o-m*r*h+i*x*h+d*r*g-i*p*g)*z,t[2]=(a*x*o-m*l*o+m*r*c-i*x*c-a*r*g+i*l*g)*z,t[3]=(d*l*o-a*p*o-d*r*c+i*p*c+a*r*h-i*l*h)*z,t[4]=D*z,t[5]=(u*x*o-f*p*o+f*r*h-e*x*h-u*r*g+e*p*g)*z,t[6]=(f*l*o-s*x*o-f*r*c+e*x*c+s*r*g-e*l*g)*z,t[7]=(s*p*o-u*l*o+u*r*c-e*p*c-s*r*h+e*l*h)*z,t[8]=T*z,t[9]=(f*d*o-u*m*o-f*i*h+e*m*h+u*i*g-e*d*g)*z,t[10]=(s*m*o-f*a*o+f*i*c-e*m*c-s*i*g+e*a*g)*z,t[11]=(u*a*o-s*d*o-u*i*c+e*d*c+s*i*h-e*a*h)*z,t[12]=k*z,t[13]=(u*m*r-f*d*r+f*i*p-e*m*p-u*i*x+e*d*x)*z,t[14]=(f*a*r-s*m*r-f*i*l+e*m*l+s*i*x-e*a*x)*z,t[15]=(s*d*r-u*a*r+u*i*l-e*d*l-s*i*p+e*a*p)*z,this}scale(t){let e=this.elements,i=t.x,r=t.y,o=t.z;return e[0]*=i,e[4]*=r,e[8]*=o,e[1]*=i,e[5]*=r,e[9]*=o,e[2]*=i,e[6]*=r,e[10]*=o,e[3]*=i,e[7]*=r,e[11]*=o,this}getMaxScaleOnAxis(){let t=this.elements;return Math.sqrt(Math.max(t[0]*t[0]+t[1]*t[1]+t[2]*t[2],t[4]*t[4]+t[5]*t[5]+t[6]*t[6],t[8]*t[8]+t[9]*t[9]+t[10]*t[10]))}makeTranslation(t,e,i){return this.set(1,0,0,t,0,1,0,e,0,0,1,i,0,0,0,1),this}makeRotationX(t){let e=Math.cos(t),i=Math.sin(t);return this.set(1,0,0,0,0,e,-i,0,0,i,e,0,0,0,0,1),this}makeRotationY(t){let e=Math.cos(t),i=Math.sin(t);return this.set(e,0,i,0,0,1,0,0,-i,0,e,0,0,0,0,1),this}makeRotationZ(t){let e=Math.cos(t),i=Math.sin(t);return this.set(e,-i,0,0,i,e,0,0,0,0,1,0,0,0,0,1),this}makeRotationAxis(t,e){let i=Math.cos(e),r=Math.sin(e),o=1-i,s=t.x,a=t.y,l=t.z,c=o*s,u=o*a;return this.set(c*s+i,c*a-r*l,c*l+r*a,0,c*a+r*l,u*a+i,u*l-r*s,0,c*l-r*a,u*l+r*s,o*l*l+i,0,0,0,0,1),this}makeScale(t,e,i){return this.set(t,0,0,0,0,e,0,0,0,0,i,0,0,0,0,1),this}makeShear(t,e,i,r,o,s){return this.set(1,i,o,0,t,1,s,0,e,r,1,0,0,0,0,1),this}compose(t,e,i){let r=this.elements,o=e._x,s=e._y,a=e._z,l=e._w,c=o+o,u=s+s,d=a+a,p=o*c,h=o*u,f=o*d,m=s*u,x=s*d,g=a*d,b=l*c,D=l*u,T=l*d,k=i.x,Z=i.y,z=i.z;return r[0]=(1-(m+g))*k,r[1]=(h+T)*k,r[2]=(f-D)*k,r[3]=0,r[4]=(h-T)*Z,r[5]=(1-(p+g))*Z,r[6]=(x+b)*Z,r[7]=0,r[8]=(f+D)*z,r[9]=(x-b)*z,r[10]=(1-(p+m))*z,r[11]=0,r[12]=t.x,r[13]=t.y,r[14]=t.z,r[15]=1,this}decompose(t,e,i){let r=this.elements,o=jy.set(r[0],r[1],r[2]).length(),s=jy.set(r[4],r[5],r[6]).length(),a=jy.set(r[8],r[9],r[10]).length();this.determinant()<0&&(o=-o),t.x=r[12],t.y=r[13],t.z=r[14],lu.copy(this);let c=1/o,u=1/s,d=1/a;return lu.elements[0]*=c,lu.elements[1]*=c,lu.elements[2]*=c,lu.elements[4]*=u,lu.elements[5]*=u,lu.elements[6]*=u,lu.elements[8]*=d,lu.elements[9]*=d,lu.elements[10]*=d,e.setFromRotationMatrix(lu),i.x=o,i.y=s,i.z=a,this}makePerspective(t,e,i,r,o,s){void 0===s&&console.warn("THREE.Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.");let a=this.elements,c=2*o/(i-r),u=(e+t)/(e-t),d=(i+r)/(i-r),p=-(s+o)/(s-o),h=-2*s*o/(s-o);return a[0]=2*o/(e-t),a[4]=0,a[8]=u,a[12]=0,a[1]=0,a[5]=c,a[9]=d,a[13]=0,a[2]=0,a[6]=0,a[10]=p,a[14]=h,a[3]=0,a[7]=0,a[11]=-1,a[15]=0,this}makeOrthographic(t,e,i,r,o,s){let a=this.elements,l=1/(e-t),c=1/(i-r),u=1/(s-o),d=(e+t)*l,p=(i+r)*c,h=(s+o)*u;return a[0]=2*l,a[4]=0,a[8]=0,a[12]=-d,a[1]=0,a[5]=2*c,a[9]=0,a[13]=-p,a[2]=0,a[6]=0,a[10]=-2*u,a[14]=-h,a[3]=0,a[7]=0,a[11]=0,a[15]=1,this}equals(t){let e=this.elements,i=t.elements;for(let r=0;r<16;r++)if(e[r]!==i[r])return!1;return!0}fromArray(t,e=0){for(let i=0;i<16;i++)this.elements[i]=t[i+e];return this}toArray(t=[],e=0){let i=this.elements;return t[e]=i[0],t[e+1]=i[1],t[e+2]=i[2],t[e+3]=i[3],t[e+4]=i[4],t[e+5]=i[5],t[e+6]=i[6],t[e+7]=i[7],t[e+8]=i[8],t[e+9]=i[9],t[e+10]=i[10],t[e+11]=i[11],t[e+12]=i[12],t[e+13]=i[13],t[e+14]=i[14],t[e+15]=i[15],t}};Rn.prototype.isMatrix4=!0;var jy=new ie,lu=new Rn,j8e=new ie(0,0,0),G8e=new ie(1,1,1),uf=new ie,DO=new ie,wl=new ie,Sue=new Rn,Eue=new qs,Mf=class{constructor(t=0,e=0,i=0,r=Mf.DefaultOrder){this._x=t,this._y=e,this._z=i,this._order=r}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get order(){return this._order}set order(t){this._order=t,this._onChangeCallback()}set(t,e,i,r=this._order){return this._x=t,this._y=e,this._z=i,this._order=r,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._order)}copy(t){return this._x=t._x,this._y=t._y,this._z=t._z,this._order=t._order,this._onChangeCallback(),this}setFromRotationMatrix(t,e=this._order,i=!0){let r=t.elements,o=r[0],s=r[4],a=r[8],l=r[1],c=r[5],u=r[9],d=r[2],p=r[6],h=r[10];switch(e){case"XYZ":this._y=Math.asin(Ga(a,-1,1)),Math.abs(a)<.9999999?(this._x=Math.atan2(-u,h),this._z=Math.atan2(-s,o)):(this._x=Math.atan2(p,c),this._z=0);break;case"YXZ":this._x=Math.asin(-Ga(u,-1,1)),Math.abs(u)<.9999999?(this._y=Math.atan2(a,h),this._z=Math.atan2(l,c)):(this._y=Math.atan2(-d,o),this._z=0);break;case"ZXY":this._x=Math.asin(Ga(p,-1,1)),Math.abs(p)<.9999999?(this._y=Math.atan2(-d,h),this._z=Math.atan2(-s,c)):(this._y=0,this._z=Math.atan2(l,o));break;case"ZYX":this._y=Math.asin(-Ga(d,-1,1)),Math.abs(d)<.9999999?(this._x=Math.atan2(p,h),this._z=Math.atan2(l,o)):(this._x=0,this._z=Math.atan2(-s,c));break;case"YZX":this._z=Math.asin(Ga(l,-1,1)),Math.abs(l)<.9999999?(this._x=Math.atan2(-u,c),this._y=Math.atan2(-d,o)):(this._x=0,this._y=Math.atan2(a,h));break;case"XZY":this._z=Math.asin(-Ga(s,-1,1)),Math.abs(s)<.9999999?(this._x=Math.atan2(p,c),this._y=Math.atan2(a,o)):(this._x=Math.atan2(-u,h),this._y=0);break;default:console.warn("THREE.Euler: .setFromRotationMatrix() encountered an unknown order: "+e)}return this._order=e,!0===i&&this._onChangeCallback(),this}setFromQuaternion(t,e,i){return Sue.makeRotationFromQuaternion(t),this.setFromRotationMatrix(Sue,e,i)}setFromVector3(t,e=this._order){return this.set(t.x,t.y,t.z,e)}reorder(t){return Eue.setFromEuler(this),this.setFromQuaternion(Eue,t)}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._order===this._order}fromArray(t){return this._x=t[0],this._y=t[1],this._z=t[2],void 0!==t[3]&&(this._order=t[3]),this._onChangeCallback(),this}toArray(t=[],e=0){return t[e]=this._x,t[e+1]=this._y,t[e+2]=this._z,t[e+3]=this._order,t}toVector3(t){return t?t.set(this._x,this._y,this._z):new ie(this._x,this._y,this._z)}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}};Mf.prototype.isEuler=!0,Mf.DefaultOrder="XYZ",Mf.RotationOrders=["XYZ","YZX","ZXY","XZY","YXZ","ZYX"];var sk=class{constructor(){this.mask=1}set(t){this.mask=(1<<t|0)>>>0}enable(t){this.mask|=1<<t|0}enableAll(){this.mask=-1}toggle(t){this.mask^=1<<t|0}disable(t){this.mask&=~(1<<t|0)}disableAll(){this.mask=0}test(t){return 0!=(this.mask&t.mask)}isEnabled(t){return 0!=(this.mask&(1<<t|0))}},W8e=0,Tue=new ie,Gy=new qs,Cp=new Rn,AO=new ie,IS=new ie,q8e=new ie,Y8e=new qs,Due=new ie(1,0,0),Aue=new ie(0,1,0),Iue=new ie(0,0,1),X8e={type:"added"},Pue={type:"removed"},Xi=class extends Ep{constructor(){super(),Object.defineProperty(this,"id",{value:W8e++}),this.uuid=du(),this.name="",this.type="Object3D",this.parent=null,this.children=[],this.up=Xi.DefaultUp.clone();let t=new ie,e=new Mf,i=new qs,r=new ie(1,1,1);e._onChange(function(){i.setFromEuler(e,!1)}),i._onChange(function(){e.setFromQuaternion(i,void 0,!1)}),Object.defineProperties(this,{position:{configurable:!0,enumerable:!0,value:t},rotation:{configurable:!0,enumerable:!0,value:e},quaternion:{configurable:!0,enumerable:!0,value:i},scale:{configurable:!0,enumerable:!0,value:r},modelViewMatrix:{value:new Rn},normalMatrix:{value:new Jo}}),this.matrix=new Rn,this.matrixWorld=new Rn,this.matrixAutoUpdate=Xi.DefaultMatrixAutoUpdate,this.matrixWorldNeedsUpdate=!1,this.layers=new sk,this.visible=!0,this.castShadow=!1,this.receiveShadow=!1,this.frustumCulled=!0,this.renderOrder=0,this.animations=[],this.userData={}}onBeforeRender(){}onAfterRender(){}applyMatrix4(t){this.matrixAutoUpdate&&this.updateMatrix(),this.matrix.premultiply(t),this.matrix.decompose(this.position,this.quaternion,this.scale)}applyQuaternion(t){return this.quaternion.premultiply(t),this}setRotationFromAxisAngle(t,e){this.quaternion.setFromAxisAngle(t,e)}setRotationFromEuler(t){this.quaternion.setFromEuler(t,!0)}setRotationFromMatrix(t){this.quaternion.setFromRotationMatrix(t)}setRotationFromQuaternion(t){this.quaternion.copy(t)}rotateOnAxis(t,e){return Gy.setFromAxisAngle(t,e),this.quaternion.multiply(Gy),this}rotateOnWorldAxis(t,e){return Gy.setFromAxisAngle(t,e),this.quaternion.premultiply(Gy),this}rotateX(t){return this.rotateOnAxis(Due,t)}rotateY(t){return this.rotateOnAxis(Aue,t)}rotateZ(t){return this.rotateOnAxis(Iue,t)}translateOnAxis(t,e){return Tue.copy(t).applyQuaternion(this.quaternion),this.position.add(Tue.multiplyScalar(e)),this}translateX(t){return this.translateOnAxis(Due,t)}translateY(t){return this.translateOnAxis(Aue,t)}translateZ(t){return this.translateOnAxis(Iue,t)}localToWorld(t){return t.applyMatrix4(this.matrixWorld)}worldToLocal(t){return t.applyMatrix4(Cp.copy(this.matrixWorld).invert())}lookAt(t,e,i){t.isVector3?AO.copy(t):AO.set(t,e,i);let r=this.parent;this.updateWorldMatrix(!0,!1),IS.setFromMatrixPosition(this.matrixWorld),this.isCamera||this.isLight?Cp.lookAt(IS,AO,this.up):Cp.lookAt(AO,IS,this.up),this.quaternion.setFromRotationMatrix(Cp),r&&(Cp.extractRotation(r.matrixWorld),Gy.setFromRotationMatrix(Cp),this.quaternion.premultiply(Gy.invert()))}add(t){if(arguments.length>1){for(let e=0;e<arguments.length;e++)this.add(arguments[e]);return this}return t===this?(console.error("THREE.Object3D.add: object can't be added as a child of itself.",t),this):(t&&t.isObject3D?(null!==t.parent&&t.parent.remove(t),t.parent=this,this.children.push(t),t.dispatchEvent(X8e)):console.error("THREE.Object3D.add: object not an instance of THREE.Object3D.",t),this)}remove(t){if(arguments.length>1){for(let i=0;i<arguments.length;i++)this.remove(arguments[i]);return this}let e=this.children.indexOf(t);return-1!==e&&(t.parent=null,this.children.splice(e,1),t.dispatchEvent(Pue)),this}removeFromParent(){let t=this.parent;return null!==t&&t.remove(this),this}clear(){for(let t=0;t<this.children.length;t++){let e=this.children[t];e.parent=null,e.dispatchEvent(Pue)}return this.children.length=0,this}attach(t){return this.updateWorldMatrix(!0,!1),Cp.copy(this.matrixWorld).invert(),null!==t.parent&&(t.parent.updateWorldMatrix(!0,!1),Cp.multiply(t.parent.matrixWorld)),t.applyMatrix4(Cp),this.add(t),t.updateWorldMatrix(!1,!0),this}getObjectById(t){return this.getObjectByProperty("id",t)}getObjectByName(t){return this.getObjectByProperty("name",t)}getObjectByProperty(t,e){if(this[t]===e)return this;for(let i=0,r=this.children.length;i<r;i++){let s=this.children[i].getObjectByProperty(t,e);if(void 0!==s)return s}}getWorldPosition(t){return this.updateWorldMatrix(!0,!1),t.setFromMatrixPosition(this.matrixWorld)}getWorldQuaternion(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(IS,t,q8e),t}getWorldScale(t){return this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(IS,Y8e,t),t}getWorldDirection(t){this.updateWorldMatrix(!0,!1);let e=this.matrixWorld.elements;return t.set(e[8],e[9],e[10]).normalize()}raycast(){}traverse(t){t(this);let e=this.children;for(let i=0,r=e.length;i<r;i++)e[i].traverse(t)}traverseVisible(t){if(!1===this.visible)return;t(this);let e=this.children;for(let i=0,r=e.length;i<r;i++)e[i].traverseVisible(t)}traverseAncestors(t){let e=this.parent;null!==e&&(t(e),e.traverseAncestors(t))}updateMatrix(){this.matrix.compose(this.position,this.quaternion,this.scale),this.matrixWorldNeedsUpdate=!0}updateMatrixWorld(t){this.matrixAutoUpdate&&this.updateMatrix(),(this.matrixWorldNeedsUpdate||t)&&(null===this.parent?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),this.matrixWorldNeedsUpdate=!1,t=!0);let e=this.children;for(let i=0,r=e.length;i<r;i++)e[i].updateMatrixWorld(t)}updateWorldMatrix(t,e){let i=this.parent;if(!0===t&&null!==i&&i.updateWorldMatrix(!0,!1),this.matrixAutoUpdate&&this.updateMatrix(),null===this.parent?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),!0===e){let r=this.children;for(let o=0,s=r.length;o<s;o++)r[o].updateWorldMatrix(!1,!0)}}toJSON(t){let e=void 0===t||"string"==typeof t,i={};e&&(t={geometries:{},materials:{},textures:{},images:{},shapes:{},skeletons:{},animations:{}},i.metadata={version:4.5,type:"Object",generator:"Object3D.toJSON"});let r={};function o(a,l){return void 0===a[l.uuid]&&(a[l.uuid]=l.toJSON(t)),l.uuid}if(r.uuid=this.uuid,r.type=this.type,""!==this.name&&(r.name=this.name),!0===this.castShadow&&(r.castShadow=!0),!0===this.receiveShadow&&(r.receiveShadow=!0),!1===this.visible&&(r.visible=!1),!1===this.frustumCulled&&(r.frustumCulled=!1),0!==this.renderOrder&&(r.renderOrder=this.renderOrder),"{}"!==JSON.stringify(this.userData)&&(r.userData=this.userData),r.layers=this.layers.mask,r.matrix=this.matrix.toArray(),!1===this.matrixAutoUpdate&&(r.matrixAutoUpdate=!1),this.isInstancedMesh&&(r.type="InstancedMesh",r.count=this.count,r.instanceMatrix=this.instanceMatrix.toJSON(),null!==this.instanceColor&&(r.instanceColor=this.instanceColor.toJSON())),this.isScene)this.background&&(this.background.isColor?r.background=this.background.toJSON():this.background.isTexture&&(r.background=this.background.toJSON(t).uuid)),this.environment&&this.environment.isTexture&&(r.environment=this.environment.toJSON(t).uuid);else if(this.isMesh||this.isLine||this.isPoints){r.geometry=o(t.geometries,this.geometry);let a=this.geometry.parameters;if(void 0!==a&&void 0!==a.shapes){let l=a.shapes;if(Array.isArray(l))for(let c=0,u=l.length;c<u;c++)o(t.shapes,l[c]);else o(t.shapes,l)}}if(this.isSkinnedMesh&&(r.bindMode=this.bindMode,r.bindMatrix=this.bindMatrix.toArray(),void 0!==this.skeleton&&(o(t.skeletons,this.skeleton),r.skeleton=this.skeleton.uuid)),void 0!==this.material)if(Array.isArray(this.material)){let a=[];for(let l=0,c=this.material.length;l<c;l++)a.push(o(t.materials,this.material[l]));r.material=a}else r.material=o(t.materials,this.material);if(this.children.length>0){r.children=[];for(let a=0;a<this.children.length;a++)r.children.push(this.children[a].toJSON(t).object)}if(this.animations.length>0){r.animations=[];for(let a=0;a<this.animations.length;a++)r.animations.push(o(t.animations,this.animations[a]))}if(e){let a=s(t.geometries),l=s(t.materials),c=s(t.textures),u=s(t.images),d=s(t.shapes),p=s(t.skeletons),h=s(t.animations);a.length>0&&(i.geometries=a),l.length>0&&(i.materials=l),c.length>0&&(i.textures=c),u.length>0&&(i.images=u),d.length>0&&(i.shapes=d),p.length>0&&(i.skeletons=p),h.length>0&&(i.animations=h)}return i.object=r,i;function s(a){let l=[];for(let c in a){let u=a[c];delete u.metadata,l.push(u)}return l}}clone(t){return(new this.constructor).copy(this,t)}copy(t,e=!0){if(this.name=t.name,this.up.copy(t.up),this.position.copy(t.position),this.rotation.order=t.rotation.order,this.quaternion.copy(t.quaternion),this.scale.copy(t.scale),this.matrix.copy(t.matrix),this.matrixWorld.copy(t.matrixWorld),this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrixWorldNeedsUpdate=t.matrixWorldNeedsUpdate,this.layers.mask=t.layers.mask,this.visible=t.visible,this.castShadow=t.castShadow,this.receiveShadow=t.receiveShadow,this.frustumCulled=t.frustumCulled,this.renderOrder=t.renderOrder,this.userData=JSON.parse(JSON.stringify(t.userData)),!0===e)for(let i=0;i<t.children.length;i++)this.add(t.children[i].clone());return this}};Xi.DefaultUp=new ie(0,1,0),Xi.DefaultMatrixAutoUpdate=!0,Xi.prototype.isObject3D=!0;var cu=new ie,Mp=new ie,Hj=new ie,wp=new ie,Wy=new ie,qy=new ie,Rue=new ie,Uj=new ie,zj=new ie,jj=new ie,lo=class{constructor(t=new ie,e=new ie,i=new ie){this.a=t,this.b=e,this.c=i}static getNormal(t,e,i,r){r.subVectors(i,e),cu.subVectors(t,e),r.cross(cu);let o=r.lengthSq();return o>0?r.multiplyScalar(1/Math.sqrt(o)):r.set(0,0,0)}static getBarycoord(t,e,i,r,o){cu.subVectors(r,e),Mp.subVectors(i,e),Hj.subVectors(t,e);let s=cu.dot(cu),a=cu.dot(Mp),l=cu.dot(Hj),c=Mp.dot(Mp),u=Mp.dot(Hj),d=s*c-a*a;if(0===d)return o.set(-2,-1,-1);let p=1/d,h=(c*l-a*u)*p,f=(s*u-a*l)*p;return o.set(1-h-f,f,h)}static containsPoint(t,e,i,r){return this.getBarycoord(t,e,i,r,wp),wp.x>=0&&wp.y>=0&&wp.x+wp.y<=1}static getUV(t,e,i,r,o,s,a,l){return this.getBarycoord(t,e,i,r,wp),l.set(0,0),l.addScaledVector(o,wp.x),l.addScaledVector(s,wp.y),l.addScaledVector(a,wp.z),l}static isFrontFacing(t,e,i,r){return cu.subVectors(i,e),Mp.subVectors(t,e),cu.cross(Mp).dot(r)<0}set(t,e,i){return this.a.copy(t),this.b.copy(e),this.c.copy(i),this}setFromPointsAndIndices(t,e,i,r){return this.a.copy(t[e]),this.b.copy(t[i]),this.c.copy(t[r]),this}setFromAttributeAndIndices(t,e,i,r){return this.a.fromBufferAttribute(t,e),this.b.fromBufferAttribute(t,i),this.c.fromBufferAttribute(t,r),this}clone(){return(new this.constructor).copy(this)}copy(t){return this.a.copy(t.a),this.b.copy(t.b),this.c.copy(t.c),this}getArea(){return cu.subVectors(this.c,this.b),Mp.subVectors(this.a,this.b),.5*cu.cross(Mp).length()}getMidpoint(t){return t.addVectors(this.a,this.b).add(this.c).multiplyScalar(1/3)}getNormal(t){return lo.getNormal(this.a,this.b,this.c,t)}getPlane(t){return t.setFromCoplanarPoints(this.a,this.b,this.c)}getBarycoord(t,e){return lo.getBarycoord(t,this.a,this.b,this.c,e)}getUV(t,e,i,r,o){return lo.getUV(t,this.a,this.b,this.c,e,i,r,o)}containsPoint(t){return lo.containsPoint(t,this.a,this.b,this.c)}isFrontFacing(t){return lo.isFrontFacing(this.a,this.b,this.c,t)}intersectsBox(t){return t.intersectsTriangle(this)}closestPointToPoint(t,e){let s,a,i=this.a,r=this.b,o=this.c;Wy.subVectors(r,i),qy.subVectors(o,i),Uj.subVectors(t,i);let l=Wy.dot(Uj),c=qy.dot(Uj);if(l<=0&&c<=0)return e.copy(i);zj.subVectors(t,r);let u=Wy.dot(zj),d=qy.dot(zj);if(u>=0&&d<=u)return e.copy(r);let p=l*d-u*c;if(p<=0&&l>=0&&u<=0)return s=l/(l-u),e.copy(i).addScaledVector(Wy,s);jj.subVectors(t,o);let h=Wy.dot(jj),f=qy.dot(jj);if(f>=0&&h<=f)return e.copy(o);let m=h*c-l*f;if(m<=0&&c>=0&&f<=0)return a=c/(c-f),e.copy(i).addScaledVector(qy,a);let x=u*f-h*d;if(x<=0&&d-u>=0&&h-f>=0)return Rue.subVectors(o,r),a=(d-u)/(d-u+(h-f)),e.copy(r).addScaledVector(Rue,a);let g=1/(x+m+p);return s=m*g,a=p*g,e.copy(i).addScaledVector(Wy,s).addScaledVector(qy,a)}equals(t){return t.a.equals(this.a)&&t.b.equals(this.b)&&t.c.equals(this.c)}},Q8e=0,hs=class extends Ep{constructor(){super(),Object.defineProperty(this,"id",{value:Q8e++}),this.uuid=du(),this.name="",this.type="Material",this.fog=!0,this.blending=1,this.side=0,this.vertexColors=!1,this.opacity=1,this.transparent=!1,this.blendSrc=204,this.blendDst=205,this.blendEquation=100,this.blendSrcAlpha=null,this.blendDstAlpha=null,this.blendEquationAlpha=null,this.depthFunc=3,this.depthTest=!0,this.depthWrite=!0,this.stencilWriteMask=255,this.stencilFunc=519,this.stencilRef=0,this.stencilFuncMask=255,this.stencilFail=7680,this.stencilZFail=7680,this.stencilZPass=7680,this.stencilWrite=!1,this.clippingPlanes=null,this.clipIntersection=!1,this.clipShadows=!1,this.shadowSide=null,this.colorWrite=!0,this.alphaWrite=!0,this.precision=null,this.polygonOffset=!1,this.polygonOffsetFactor=0,this.polygonOffsetUnits=0,this.dithering=!1,this.alphaToCoverage=!1,this.premultipliedAlpha=!1,this.visible=!0,this.toneMapped=!0,this.userData={},this.version=0,this._alphaTest=0}get alphaTest(){return this._alphaTest}set alphaTest(t){this._alphaTest>0!=t>0&&this.version++,this._alphaTest=t}onBuild(){}onBeforeRender(){}onBeforeCompile(){}customProgramCacheKey(){return this.onBeforeCompile.toString()}setValues(t){if(void 0!==t)for(let e in t){let i=t[e];if(void 0===i){console.warn("THREE.Material: '"+e+"' parameter is undefined.");continue}if("shading"===e){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=1===i;continue}let r=this[e];void 0!==r?r&&r.isColor?r.set(i):r&&r.isVector3&&i&&i.isVector3?r.copy(i):this[e]=i:console.warn("THREE."+this.type+": '"+e+"' is not a property of this material.")}}toJSON(t){let e=void 0===t||"string"==typeof t;e&&(t={textures:{},images:{}});let i={metadata:{version:4.5,type:"Material",generator:"Material.toJSON"}};function r(o){let s=[];for(let a in o){let l=o[a];delete l.metadata,s.push(l)}return s}if(i.uuid=this.uuid,i.type=this.type,""!==this.name&&(i.name=this.name),this.color&&this.color.isColor&&(i.color=this.color.getHex()),void 0!==this.roughness&&(i.roughness=this.roughness),void 0!==this.metalness&&(i.metalness=this.metalness),void 0!==this.sheen&&(i.sheen=this.sheen),this.sheenColor&&this.sheenColor.isColor&&(i.sheenColor=this.sheenColor.getHex()),void 0!==this.sheenRoughness&&(i.sheenRoughness=this.sheenRoughness),this.emissive&&this.emissive.isColor&&(i.emissive=this.emissive.getHex()),this.emissiveIntensity&&1!==this.emissiveIntensity&&(i.emissiveIntensity=this.emissiveIntensity),this.specular&&this.specular.isColor&&(i.specular=this.specular.getHex()),void 0!==this.specularIntensity&&(i.specularIntensity=this.specularIntensity),this.specularColor&&this.specularColor.isColor&&(i.specularColor=this.specularColor.getHex()),void 0!==this.shininess&&(i.shininess=this.shininess),void 0!==this.clearcoat&&(i.clearcoat=this.clearcoat),void 0!==this.clearcoatRoughness&&(i.clearcoatRoughness=this.clearcoatRoughness),this.clearcoatMap&&this.clearcoatMap.isTexture&&(i.clearcoatMap=this.clearcoatMap.toJSON(t).uuid),this.clearcoatRoughnessMap&&this.clearcoatRoughnessMap.isTexture&&(i.clearcoatRoughnessMap=this.clearcoatRoughnessMap.toJSON(t).uuid),this.clearcoatNormalMap&&this.clearcoatNormalMap.isTexture&&(i.clearcoatNormalMap=this.clearcoatNormalMap.toJSON(t).uuid,i.clearcoatNormalScale=this.clearcoatNormalScale.toArray()),this.map&&this.map.isTexture&&(i.map=this.map.toJSON(t).uuid),this.matcap&&this.matcap.isTexture&&(i.matcap=this.matcap.toJSON(t).uuid),this.alphaMap&&this.alphaMap.isTexture&&(i.alphaMap=this.alphaMap.toJSON(t).uuid),this.lightMap&&this.lightMap.isTexture&&(i.lightMap=this.lightMap.toJSON(t).uuid,i.lightMapIntensity=this.lightMapIntensity),this.aoMap&&this.aoMap.isTexture&&(i.aoMap=this.aoMap.toJSON(t).uuid,i.aoMapIntensity=this.aoMapIntensity),this.bumpMap&&this.bumpMap.isTexture&&(i.bumpMap=this.bumpMap.toJSON(t).uuid,i.bumpScale=this.bumpScale),this.normalMap&&this.normalMap.isTexture&&(i.normalMap=this.normalMap.toJSON(t).uuid,i.normalMapType=this.normalMapType,i.normalScale=this.normalScale.toArray()),this.displacementMap&&this.displacementMap.isTexture&&(i.displacementMap=this.displacementMap.toJSON(t).uuid,i.displacementScale=this.displacementScale,i.displacementBias=this.displacementBias),this.roughnessMap&&this.roughnessMap.isTexture&&(i.roughnessMap=this.roughnessMap.toJSON(t).uuid),this.metalnessMap&&this.metalnessMap.isTexture&&(i.metalnessMap=this.metalnessMap.toJSON(t).uuid),this.emissiveMap&&this.emissiveMap.isTexture&&(i.emissiveMap=this.emissiveMap.toJSON(t).uuid),this.specularMap&&this.specularMap.isTexture&&(i.specularMap=this.specularMap.toJSON(t).uuid),this.specularIntensityMap&&this.specularIntensityMap.isTexture&&(i.specularIntensityMap=this.specularIntensityMap.toJSON(t).uuid),this.specularColorMap&&this.specularColorMap.isTexture&&(i.specularColorMap=this.specularColorMap.toJSON(t).uuid),this.envMap&&this.envMap.isTexture&&(i.envMap=this.envMap.toJSON(t).uuid,void 0!==this.combine&&(i.combine=this.combine)),void 0!==this.envMapIntensity&&(i.envMapIntensity=this.envMapIntensity),void 0!==this.reflectivity&&(i.reflectivity=this.reflectivity),void 0!==this.refractionRatio&&(i.refractionRatio=this.refractionRatio),this.gradientMap&&this.gradientMap.isTexture&&(i.gradientMap=this.gradientMap.toJSON(t).uuid),void 0!==this.transmission&&(i.transmission=this.transmission),this.transmissionMap&&this.transmissionMap.isTexture&&(i.transmissionMap=this.transmissionMap.toJSON(t).uuid),void 0!==this.thickness&&(i.thickness=this.thickness),this.thicknessMap&&this.thicknessMap.isTexture&&(i.thicknessMap=this.thicknessMap.toJSON(t).uuid),void 0!==this.attenuationDistance&&(i.attenuationDistance=this.attenuationDistance),void 0!==this.attenuationColor&&(i.attenuationColor=this.attenuationColor.getHex()),void 0!==this.size&&(i.size=this.size),null!==this.shadowSide&&(i.shadowSide=this.shadowSide),void 0!==this.sizeAttenuation&&(i.sizeAttenuation=this.sizeAttenuation),1!==this.blending&&(i.blending=this.blending),0!==this.side&&(i.side=this.side),this.vertexColors&&(i.vertexColors=!0),this.opacity<1&&(i.opacity=this.opacity),!0===this.transparent&&(i.transparent=this.transparent),i.depthFunc=this.depthFunc,i.depthTest=this.depthTest,i.depthWrite=this.depthWrite,i.colorWrite=this.colorWrite,i.alphaWrite=this.alphaWrite,i.stencilWrite=this.stencilWrite,i.stencilWriteMask=this.stencilWriteMask,i.stencilFunc=this.stencilFunc,i.stencilRef=this.stencilRef,i.stencilFuncMask=this.stencilFuncMask,i.stencilFail=this.stencilFail,i.stencilZFail=this.stencilZFail,i.stencilZPass=this.stencilZPass,this.rotation&&0!==this.rotation&&(i.rotation=this.rotation),!0===this.polygonOffset&&(i.polygonOffset=!0),0!==this.polygonOffsetFactor&&(i.polygonOffsetFactor=this.polygonOffsetFactor),0!==this.polygonOffsetUnits&&(i.polygonOffsetUnits=this.polygonOffsetUnits),this.linewidth&&1!==this.linewidth&&(i.linewidth=this.linewidth),void 0!==this.dashSize&&(i.dashSize=this.dashSize),void 0!==this.gapSize&&(i.gapSize=this.gapSize),void 0!==this.scale&&(i.scale=this.scale),!0===this.dithering&&(i.dithering=!0),this.alphaTest>0&&(i.alphaTest=this.alphaTest),!0===this.alphaToCoverage&&(i.alphaToCoverage=this.alphaToCoverage),!0===this.premultipliedAlpha&&(i.premultipliedAlpha=this.premultipliedAlpha),!0===this.wireframe&&(i.wireframe=this.wireframe),this.wireframeLinewidth>1&&(i.wireframeLinewidth=this.wireframeLinewidth),"round"!==this.wireframeLinecap&&(i.wireframeLinecap=this.wireframeLinecap),"round"!==this.wireframeLinejoin&&(i.wireframeLinejoin=this.wireframeLinejoin),!0===this.flatShading&&(i.flatShading=this.flatShading),!1===this.visible&&(i.visible=!1),!1===this.toneMapped&&(i.toneMapped=!1),"{}"!==JSON.stringify(this.userData)&&(i.userData=this.userData),e){let o=r(t.textures),s=r(t.images);o.length>0&&(i.textures=o),s.length>0&&(i.images=s)}return i}clone(){return(new this.constructor).copy(this)}copy(t){this.name=t.name,this.fog=t.fog,this.blending=t.blending,this.side=t.side,this.vertexColors=t.vertexColors,this.opacity=t.opacity,this.transparent=t.transparent,this.blendSrc=t.blendSrc,this.blendDst=t.blendDst,this.blendEquation=t.blendEquation,this.blendSrcAlpha=t.blendSrcAlpha,this.blendDstAlpha=t.blendDstAlpha,this.blendEquationAlpha=t.blendEquationAlpha,this.depthFunc=t.depthFunc,this.depthTest=t.depthTest,this.depthWrite=t.depthWrite,this.stencilWriteMask=t.stencilWriteMask,this.stencilFunc=t.stencilFunc,this.stencilRef=t.stencilRef,this.stencilFuncMask=t.stencilFuncMask,this.stencilFail=t.stencilFail,this.stencilZFail=t.stencilZFail,this.stencilZPass=t.stencilZPass,this.stencilWrite=t.stencilWrite;let e=t.clippingPlanes,i=null;if(null!==e){let r=e.length;i=new Array(r);for(let o=0;o!==r;++o)i[o]=e[o].clone()}return this.clippingPlanes=i,this.clipIntersection=t.clipIntersection,this.clipShadows=t.clipShadows,this.shadowSide=t.shadowSide,this.colorWrite=t.colorWrite,this.alphaWrite=t.alphaWrite,this.precision=t.precision,this.polygonOffset=t.polygonOffset,this.polygonOffsetFactor=t.polygonOffsetFactor,this.polygonOffsetUnits=t.polygonOffsetUnits,this.dithering=t.dithering,this.alphaTest=t.alphaTest,this.alphaToCoverage=t.alphaToCoverage,this.premultipliedAlpha=t.premultipliedAlpha,this.visible=t.visible,this.toneMapped=t.toneMapped,this.userData=JSON.parse(JSON.stringify(t.userData)),this}dispose(){this.dispatchEvent({type:"dispose"})}set needsUpdate(t){!0===t&&this.version++}};hs.prototype.isMaterial=!0;var Gg=class extends hs{constructor(t){super(),this.type="MeshBasicMaterial",this.color=new vn(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=0,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}};Gg.prototype.isMeshBasicMaterial=!0;var Er=new ie,IO=new at,Yr=class{constructor(t,e,i){if(Array.isArray(t))throw new TypeError("THREE.BufferAttribute: array should be a Typed Array.");this.name="",this.array=t,this.itemSize=e,this.count=void 0!==t?t.length/e:0,this.normalized=!0===i,this.usage=qS,this.updateRange={offset:0,count:-1},this.version=0}onUploadCallback(){}set needsUpdate(t){!0===t&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.name=t.name,this.array=new t.array.constructor(t.array),this.itemSize=t.itemSize,this.count=t.count,this.normalized=t.normalized,this.usage=t.usage,this}copyAt(t,e,i){t*=this.itemSize,i*=e.itemSize;for(let r=0,o=this.itemSize;r<o;r++)this.array[t+r]=e.array[i+r];return this}copyArray(t){return this.array.set(t),this}copyColorsArray(t){let e=this.array,i=0;for(let r=0,o=t.length;r<o;r++){let s=t[r];void 0===s&&(console.warn("THREE.BufferAttribute.copyColorsArray(): color is undefined",r),s=new vn),e[i++]=s.r,e[i++]=s.g,e[i++]=s.b}return this}copyVector2sArray(t){let e=this.array,i=0;for(let r=0,o=t.length;r<o;r++){let s=t[r];void 0===s&&(console.warn("THREE.BufferAttribute.copyVector2sArray(): vector is undefined",r),s=new at),e[i++]=s.x,e[i++]=s.y}return this}copyVector3sArray(t){let e=this.array,i=0;for(let r=0,o=t.length;r<o;r++){let s=t[r];void 0===s&&(console.warn("THREE.BufferAttribute.copyVector3sArray(): vector is undefined",r),s=new ie),e[i++]=s.x,e[i++]=s.y,e[i++]=s.z}return this}copyVector4sArray(t){let e=this.array,i=0;for(let r=0,o=t.length;r<o;r++){let s=t[r];void 0===s&&(console.warn("THREE.BufferAttribute.copyVector4sArray(): vector is undefined",r),s=new ar),e[i++]=s.x,e[i++]=s.y,e[i++]=s.z,e[i++]=s.w}return this}applyMatrix3(t){if(2===this.itemSize)for(let e=0,i=this.count;e<i;e++)IO.fromBufferAttribute(this,e),IO.applyMatrix3(t),this.setXY(e,IO.x,IO.y);else if(3===this.itemSize)for(let e=0,i=this.count;e<i;e++)Er.fromBufferAttribute(this,e),Er.applyMatrix3(t),this.setXYZ(e,Er.x,Er.y,Er.z);return this}applyMatrix4(t){for(let e=0,i=this.count;e<i;e++)Er.x=this.getX(e),Er.y=this.getY(e),Er.z=this.getZ(e),Er.applyMatrix4(t),this.setXYZ(e,Er.x,Er.y,Er.z);return this}applyNormalMatrix(t){for(let e=0,i=this.count;e<i;e++)Er.x=this.getX(e),Er.y=this.getY(e),Er.z=this.getZ(e),Er.applyNormalMatrix(t),this.setXYZ(e,Er.x,Er.y,Er.z);return this}transformDirection(t){for(let e=0,i=this.count;e<i;e++)Er.x=this.getX(e),Er.y=this.getY(e),Er.z=this.getZ(e),Er.transformDirection(t),this.setXYZ(e,Er.x,Er.y,Er.z);return this}set(t,e=0){return this.array.set(t,e),this}getX(t){return this.array[t*this.itemSize]}setX(t,e){return this.array[t*this.itemSize]=e,this}getY(t){return this.array[t*this.itemSize+1]}setY(t,e){return this.array[t*this.itemSize+1]=e,this}getZ(t){return this.array[t*this.itemSize+2]}setZ(t,e){return this.array[t*this.itemSize+2]=e,this}getW(t){return this.array[t*this.itemSize+3]}setW(t,e){return this.array[t*this.itemSize+3]=e,this}setXY(t,e,i){return this.array[0+(t*=this.itemSize)]=e,this.array[t+1]=i,this}setXYZ(t,e,i,r){return this.array[0+(t*=this.itemSize)]=e,this.array[t+1]=i,this.array[t+2]=r,this}setXYZW(t,e,i,r,o){return this.array[0+(t*=this.itemSize)]=e,this.array[t+1]=i,this.array[t+2]=r,this.array[t+3]=o,this}onUpload(t){return this.onUploadCallback=t,this}clone(){return new this.constructor(this.array,this.itemSize).copy(this)}toJSON(){let t={itemSize:this.itemSize,type:this.array.constructor.name,array:Array.prototype.slice.call(this.array),normalized:this.normalized};return""!==this.name&&(t.name=this.name),this.usage!==qS&&(t.usage=this.usage),(0!==this.updateRange.offset||-1!==this.updateRange.count)&&(t.updateRange=this.updateRange),t}};Yr.prototype.isBufferAttribute=!0;var ak=class extends Yr{constructor(t,e,i){super(new Uint16Array(t),e,i)}},lk=class extends Yr{constructor(t,e,i){super(new Uint32Array(t),e,i)}};(class extends Yr{constructor(t,e,i){super(new Uint16Array(t),e,i)}}).prototype.isFloat16BufferAttribute=!0;var Jr=class extends Yr{constructor(t,e,i){super(new Float32Array(t),e,i)}},K8e=0,pc=new Rn,Gj=new Xi,Yy=new ie,Sl=new Tl,PS=new Tl,ps=new ie,nr=class extends Ep{constructor(){super(),Object.defineProperty(this,"id",{value:K8e++}),this.uuid=du(),this.name="",this.type="BufferGeometry",this.index=null,this.attributes={},this.morphAttributes={},this.morphTargetsRelative=!1,this.groups=[],this.boundingBox=null,this.boundingSphere=null,this.drawRange={start:0,count:1/0},this.userData={}}getIndex(){return this.index}setIndex(t){return this.index=Array.isArray(t)?new(Ode(t)?lk:ak)(t,1):t,this}getAttribute(t){return this.attributes[t]}setAttribute(t,e){return this.attributes[t]=e,this}deleteAttribute(t){return delete this.attributes[t],this}hasAttribute(t){return void 0!==this.attributes[t]}addGroup(t,e,i=0){this.groups.push({start:t,count:e,materialIndex:i})}clearGroups(){this.groups=[]}setDrawRange(t,e){this.drawRange.start=t,this.drawRange.count=e}applyMatrix4(t){let e=this.attributes.position;void 0!==e&&(e.applyMatrix4(t),e.needsUpdate=!0);let i=this.attributes.normal;if(void 0!==i){let o=(new Jo).getNormalMatrix(t);i.applyNormalMatrix(o),i.needsUpdate=!0}let r=this.attributes.tangent;return void 0!==r&&(r.transformDirection(t),r.needsUpdate=!0),null!==this.boundingBox&&this.computeBoundingBox(),null!==this.boundingSphere&&this.computeBoundingSphere(),this}applyQuaternion(t){return pc.makeRotationFromQuaternion(t),this.applyMatrix4(pc),this}rotateX(t){return pc.makeRotationX(t),this.applyMatrix4(pc),this}rotateY(t){return pc.makeRotationY(t),this.applyMatrix4(pc),this}rotateZ(t){return pc.makeRotationZ(t),this.applyMatrix4(pc),this}translate(t,e,i){return pc.makeTranslation(t,e,i),this.applyMatrix4(pc),this}scale(t,e,i){return pc.makeScale(t,e,i),this.applyMatrix4(pc),this}lookAt(t){return Gj.lookAt(t),Gj.updateMatrix(),this.applyMatrix4(Gj.matrix),this}center(){return this.computeBoundingBox(),this.boundingBox.getCenter(Yy).negate(),this.translate(Yy.x,Yy.y,Yy.z),this}setFromPoints(t){let e=[];for(let i=0,r=t.length;i<r;i++){let o=t[i];e.push(o.x,o.y,o.z||0)}return this.setAttribute("position",new Jr(e,3)),this}computeBoundingBox(){null===this.boundingBox&&(this.boundingBox=new Tl);let t=this.attributes.position,e=this.morphAttributes.position;if(t&&t.isGLBufferAttribute)return console.error('THREE.BufferGeometry.computeBoundingBox(): GLBufferAttribute requires a manual bounding box. Alternatively set "mesh.frustumCulled" to "false".',this),void this.boundingBox.set(new ie(-1/0,-1/0,-1/0),new ie(1/0,1/0,1/0));if(void 0!==t){if(this.boundingBox.setFromBufferAttribute(t),e)for(let i=0,r=e.length;i<r;i++)Sl.setFromBufferAttribute(e[i]),this.morphTargetsRelative?(ps.addVectors(this.boundingBox.min,Sl.min),this.boundingBox.expandByPoint(ps),ps.addVectors(this.boundingBox.max,Sl.max),this.boundingBox.expandByPoint(ps)):(this.boundingBox.expandByPoint(Sl.min),this.boundingBox.expandByPoint(Sl.max))}else this.boundingBox.makeEmpty();(isNaN(this.boundingBox.min.x)||isNaN(this.boundingBox.min.y)||isNaN(this.boundingBox.min.z))&&console.error('THREE.BufferGeometry.computeBoundingBox(): Computed min/max have NaN values. The "position" attribute is likely to have NaN values.',this)}computeBoundingSphere(){null===this.boundingSphere&&(this.boundingSphere=new xf);let t=this.attributes.position,e=this.morphAttributes.position;if(t&&t.isGLBufferAttribute)return console.error('THREE.BufferGeometry.computeBoundingSphere(): GLBufferAttribute requires a manual bounding sphere. Alternatively set "mesh.frustumCulled" to "false".',this),void this.boundingSphere.set(new ie,1/0);if(t){let i=this.boundingSphere.center;if(Sl.setFromBufferAttribute(t),e)for(let o=0,s=e.length;o<s;o++)PS.setFromBufferAttribute(e[o]),this.morphTargetsRelative?(ps.addVectors(Sl.min,PS.min),Sl.expandByPoint(ps),ps.addVectors(Sl.max,PS.max),Sl.expandByPoint(ps)):(Sl.expandByPoint(PS.min),Sl.expandByPoint(PS.max));Sl.getCenter(i);let r=0;for(let o=0,s=t.count;o<s;o++)ps.fromBufferAttribute(t,o),r=Math.max(r,i.distanceToSquared(ps));if(e)for(let o=0,s=e.length;o<s;o++){let a=e[o],l=this.morphTargetsRelative;for(let c=0,u=a.count;c<u;c++)ps.fromBufferAttribute(a,c),l&&(Yy.fromBufferAttribute(t,c),ps.add(Yy)),r=Math.max(r,i.distanceToSquared(ps))}this.boundingSphere.radius=Math.sqrt(r),isNaN(this.boundingSphere.radius)&&console.error('THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.',this)}}computeTangents(){let t=this.index,e=this.attributes;if(null===t||void 0===e.position||void 0===e.normal||void 0===e.uv)return void console.error("THREE.BufferGeometry: .computeTangents() failed. Missing required attributes (index, position, normal or uv)");let i=t.array,r=e.position.array,o=e.normal.array,s=e.uv.array,a=r.length/3;void 0===e.tangent&&this.setAttribute("tangent",new Yr(new Float32Array(4*a),4));let l=e.tangent.array,c=[],u=[];for(let he=0;he<a;he++)c[he]=new ie,u[he]=new ie;let d=new ie,p=new ie,h=new ie,f=new at,m=new at,x=new at,g=new ie,b=new ie;function D(he,w,F){d.fromArray(r,3*he),p.fromArray(r,3*w),h.fromArray(r,3*F),f.fromArray(s,2*he),m.fromArray(s,2*w),x.fromArray(s,2*F),p.sub(d),h.sub(d),m.sub(f),x.sub(f);let q=1/(m.x*x.y-x.x*m.y);!isFinite(q)||(g.copy(p).multiplyScalar(x.y).addScaledVector(h,-m.y).multiplyScalar(q),b.copy(h).multiplyScalar(m.x).addScaledVector(p,-x.x).multiplyScalar(q),c[he].add(g),c[w].add(g),c[F].add(g),u[he].add(b),u[w].add(b),u[F].add(b))}let T=this.groups;0===T.length&&(T=[{start:0,count:i.length}]);for(let he=0,w=T.length;he<w;++he){let F=T[he],q=F.start;for(let de=q,Y=q+F.count;de<Y;de+=3)D(i[de+0],i[de+1],i[de+2])}let k=new ie,Z=new ie,z=new ie,fe=new ie;function ue(he){z.fromArray(o,3*he),fe.copy(z);let w=c[he];k.copy(w),k.sub(z.multiplyScalar(z.dot(w))).normalize(),Z.crossVectors(fe,w);let q=Z.dot(u[he])<0?-1:1;l[4*he]=k.x,l[4*he+1]=k.y,l[4*he+2]=k.z,l[4*he+3]=q}for(let he=0,w=T.length;he<w;++he){let F=T[he],q=F.start;for(let de=q,Y=q+F.count;de<Y;de+=3)ue(i[de+0]),ue(i[de+1]),ue(i[de+2])}}computeVertexNormals(){let t=this.index,e=this.getAttribute("position");if(void 0!==e){let i=this.getAttribute("normal");if(void 0===i)i=new Yr(new Float32Array(3*e.count),3),this.setAttribute("normal",i);else for(let p=0,h=i.count;p<h;p++)i.setXYZ(p,0,0,0);let r=new ie,o=new ie,s=new ie,a=new ie,l=new ie,c=new ie,u=new ie,d=new ie;if(t)for(let p=0,h=t.count;p<h;p+=3){let f=t.getX(p+0),m=t.getX(p+1),x=t.getX(p+2);r.fromBufferAttribute(e,f),o.fromBufferAttribute(e,m),s.fromBufferAttribute(e,x),u.subVectors(s,o),d.subVectors(r,o),u.cross(d),a.fromBufferAttribute(i,f),l.fromBufferAttribute(i,m),c.fromBufferAttribute(i,x),a.add(u),l.add(u),c.add(u),i.setXYZ(f,a.x,a.y,a.z),i.setXYZ(m,l.x,l.y,l.z),i.setXYZ(x,c.x,c.y,c.z)}else for(let p=0,h=e.count;p<h;p+=3)r.fromBufferAttribute(e,p+0),o.fromBufferAttribute(e,p+1),s.fromBufferAttribute(e,p+2),u.subVectors(s,o),d.subVectors(r,o),u.cross(d),i.setXYZ(p+0,u.x,u.y,u.z),i.setXYZ(p+1,u.x,u.y,u.z),i.setXYZ(p+2,u.x,u.y,u.z);this.normalizeNormals(),i.needsUpdate=!0}}merge(t,e){if(!t||!t.isBufferGeometry)return void console.error("THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.",t);void 0===e&&(e=0,console.warn("THREE.BufferGeometry.merge(): Overwriting original geometry, starting at offset=0. Use BufferGeometryUtils.mergeBufferGeometries() for lossless merge."));let i=this.attributes;for(let r in i){if(void 0===t.attributes[r])continue;let s=i[r].array,a=t.attributes[r],l=a.array,c=a.itemSize*e,u=Math.min(l.length,s.length-c);for(let d=0,p=c;d<u;d++,p++)s[p]=l[d]}return this}normalizeNormals(){let t=this.attributes.normal;for(let e=0,i=t.count;e<i;e++)ps.fromBufferAttribute(t,e),ps.normalize(),t.setXYZ(e,ps.x,ps.y,ps.z)}toNonIndexed(){function t(a,l){let c=a.array,u=a.itemSize,d=a.normalized,p=new c.constructor(l.length*u),h=0,f=0;for(let m=0,x=l.length;m<x;m++){h=a.isInterleavedBufferAttribute?l[m]*a.data.stride+a.offset:l[m]*u;for(let g=0;g<u;g++)p[f++]=c[h++]}return new Yr(p,u,d)}if(null===this.index)return console.warn("THREE.BufferGeometry.toNonIndexed(): BufferGeometry is already non-indexed."),this;let e=new nr,i=this.index.array,r=this.attributes;for(let a in r){let c=t(r[a],i);e.setAttribute(a,c)}let o=this.morphAttributes;for(let a in o){let l=[],c=o[a];for(let u=0,d=c.length;u<d;u++){let h=t(c[u],i);l.push(h)}e.morphAttributes[a]=l}e.morphTargetsRelative=this.morphTargetsRelative;let s=this.groups;for(let a=0,l=s.length;a<l;a++){let c=s[a];e.addGroup(c.start,c.count,c.materialIndex)}return e}toJSON(){let t={metadata:{version:4.5,type:"BufferGeometry",generator:"BufferGeometry.toJSON"}};if(t.uuid=this.uuid,t.type=this.type,""!==this.name&&(t.name=this.name),Object.keys(this.userData).length>0&&(t.userData=this.userData),void 0!==this.parameters){let l=this.parameters;for(let c in l)void 0!==l[c]&&(t[c]=l[c]);return t}t.data={attributes:{}};let e=this.index;null!==e&&(t.data.index={type:e.array.constructor.name,array:Array.prototype.slice.call(e.array)});let i=this.attributes;for(let l in i)t.data.attributes[l]=i[l].toJSON(t.data);let r={},o=!1;for(let l in this.morphAttributes){let c=this.morphAttributes[l],u=[];for(let d=0,p=c.length;d<p;d++)u.push(c[d].toJSON(t.data));u.length>0&&(r[l]=u,o=!0)}o&&(t.data.morphAttributes=r,t.data.morphTargetsRelative=this.morphTargetsRelative);let s=this.groups;s.length>0&&(t.data.groups=JSON.parse(JSON.stringify(s)));let a=this.boundingSphere;return null!==a&&(t.data.boundingSphere={center:a.center.toArray(),radius:a.radius}),t}clone(){return(new this.constructor).copy(this)}copy(t){this.index=null,this.attributes={},this.morphAttributes={},this.groups=[],this.boundingBox=null,this.boundingSphere=null;let e={};this.name=t.name;let i=t.index;null!==i&&this.setIndex(i.clone(e));let r=t.attributes;for(let c in r)this.setAttribute(c,r[c].clone(e));let o=t.morphAttributes;for(let c in o){let u=[],d=o[c];for(let p=0,h=d.length;p<h;p++)u.push(d[p].clone(e));this.morphAttributes[c]=u}this.morphTargetsRelative=t.morphTargetsRelative;let s=t.groups;for(let c=0,u=s.length;c<u;c++){let d=s[c];this.addGroup(d.start,d.count,d.materialIndex)}let a=t.boundingBox;null!==a&&(this.boundingBox=a.clone());let l=t.boundingSphere;return null!==l&&(this.boundingSphere=l.clone()),this.drawRange.start=t.drawRange.start,this.drawRange.count=t.drawRange.count,this.userData=t.userData,void 0!==t.parameters&&(this.parameters=Object.assign({},t.parameters)),this}dispose(){this.dispatchEvent({type:"dispose"})}};nr.prototype.isBufferGeometry=!0;var Oue=new Rn,Xy=new Cf,Wj=new xf,df=new ie,pf=new ie,hf=new ie,qj=new ie,Yj=new ie,Xj=new ie,PO=new ie,RO=new ie,OO=new ie,kO=new at,FO=new at,NO=new at,Qj=new ie,LO=new ie,Vo=class extends Xi{constructor(t=new nr,e=new Gg){super(),this.type="Mesh",this.geometry=t,this.material=e,this.updateMorphTargets()}copy(t){return super.copy(t),void 0!==t.morphTargetInfluences&&(this.morphTargetInfluences=t.morphTargetInfluences.slice()),void 0!==t.morphTargetDictionary&&(this.morphTargetDictionary=Object.assign({},t.morphTargetDictionary)),this.material=t.material,this.geometry=t.geometry,this}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let e=t.morphAttributes,i=Object.keys(e);if(i.length>0){let r=e[i[0]];if(void 0!==r){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let o=0,s=r.length;o<s;o++){let a=r[o].name||String(o);this.morphTargetInfluences.push(0),this.morphTargetDictionary[a]=o}}}}else{let e=t.morphTargets;void 0!==e&&e.length>0&&console.error("THREE.Mesh.updateMorphTargets() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}}raycast(t,e){let s,i=this.geometry,r=this.material,o=this.matrixWorld;if(void 0!==r&&(null===i.boundingSphere&&i.computeBoundingSphere(),Wj.copy(i.boundingSphere),Wj.applyMatrix4(o),!1!==t.ray.intersectsSphere(Wj))&&(Oue.copy(o).invert(),Xy.copy(t.ray).applyMatrix4(Oue),null===i.boundingBox||!1!==Xy.intersectsBox(i.boundingBox)))if(i.isBufferGeometry){let a=i.index,l=i.attributes.position,c=i.morphAttributes.position,u=i.morphTargetsRelative,d=i.attributes.uv,p=i.attributes.uv2,h=i.groups,f=i.drawRange;if(null!==a)if(Array.isArray(r))for(let m=0,x=h.length;m<x;m++){let g=h[m],b=r[g.materialIndex];for(let k=Math.max(g.start,f.start),Z=Math.min(a.count,Math.min(g.start+g.count,f.start+f.count));k<Z;k+=3){let z=a.getX(k),fe=a.getX(k+1),ue=a.getX(k+2);s=BO(this,b,t,Xy,l,c,u,d,p,z,fe,ue),s&&(s.faceIndex=Math.floor(k/3),s.face.materialIndex=g.materialIndex,e.push(s))}}else for(let g=Math.max(0,f.start),b=Math.min(a.count,f.start+f.count);g<b;g+=3){let D=a.getX(g),T=a.getX(g+1),k=a.getX(g+2);s=BO(this,r,t,Xy,l,c,u,d,p,D,T,k),s&&(s.faceIndex=Math.floor(g/3),e.push(s))}else if(void 0!==l)if(Array.isArray(r))for(let m=0,x=h.length;m<x;m++){let g=h[m],b=r[g.materialIndex];for(let k=Math.max(g.start,f.start),Z=Math.min(l.count,Math.min(g.start+g.count,f.start+f.count));k<Z;k+=3)s=BO(this,b,t,Xy,l,c,u,d,p,k,k+1,k+2),s&&(s.faceIndex=Math.floor(k/3),s.face.materialIndex=g.materialIndex,e.push(s))}else for(let g=Math.max(0,f.start),b=Math.min(l.count,f.start+f.count);g<b;g+=3)s=BO(this,r,t,Xy,l,c,u,d,p,g,g+1,g+2),s&&(s.faceIndex=Math.floor(g/3),e.push(s))}else i.isGeometry&&console.error("THREE.Mesh.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}};function BO(n,t,e,i,r,o,s,a,l,c,u,d){df.fromBufferAttribute(r,c),pf.fromBufferAttribute(r,u),hf.fromBufferAttribute(r,d);let p=n.morphTargetInfluences;if(o&&p){PO.set(0,0,0),RO.set(0,0,0),OO.set(0,0,0);for(let f=0,m=o.length;f<m;f++){let x=p[f],g=o[f];0!==x&&(qj.fromBufferAttribute(g,c),Yj.fromBufferAttribute(g,u),Xj.fromBufferAttribute(g,d),s?(PO.addScaledVector(qj,x),RO.addScaledVector(Yj,x),OO.addScaledVector(Xj,x)):(PO.addScaledVector(qj.sub(df),x),RO.addScaledVector(Yj.sub(pf),x),OO.addScaledVector(Xj.sub(hf),x)))}df.add(PO),pf.add(RO),hf.add(OO)}n.isSkinnedMesh&&(n.boneTransform(c,df),n.boneTransform(u,pf),n.boneTransform(d,hf));let h=function(n,t,e,i,r,o,s,a){let l;if(l=1===t.side?i.intersectTriangle(s,o,r,!0,a):i.intersectTriangle(r,o,s,2!==t.side,a),null===l)return null;LO.copy(a),LO.applyMatrix4(n.matrixWorld);let c=e.ray.origin.distanceTo(LO);return c<e.near||c>e.far?null:{distance:c,point:LO.clone(),object:n}}(n,t,e,i,df,pf,hf,Qj);if(h){a&&(kO.fromBufferAttribute(a,c),FO.fromBufferAttribute(a,u),NO.fromBufferAttribute(a,d),h.uv=lo.getUV(Qj,df,pf,hf,kO,FO,NO,new at)),l&&(kO.fromBufferAttribute(l,c),FO.fromBufferAttribute(l,u),NO.fromBufferAttribute(l,d),h.uv2=lo.getUV(Qj,df,pf,hf,kO,FO,NO,new at));let f={a:c,b:u,c:d,normal:new ie,materialIndex:0};lo.getNormal(df,pf,hf,f.normal),h.face=f}return h}Vo.prototype.isMesh=!0;var Wg=class extends nr{constructor(t=1,e=1,i=1,r=1,o=1,s=1){super(),this.type="BoxGeometry",this.parameters={width:t,height:e,depth:i,widthSegments:r,heightSegments:o,depthSegments:s};let a=this;r=Math.floor(r),o=Math.floor(o),s=Math.floor(s);let l=[],c=[],u=[],d=[],p=0,h=0;function f(m,x,g,b,D,T,k,Z,z,fe,ue){let he=T/z,w=k/fe,F=T/2,q=k/2,K=Z/2,de=z+1,Y=fe+1,ae=0,le=0,Ie=new ie;for(let ve=0;ve<Y;ve++){let De=ve*w-q;for(let nt=0;nt<de;nt++)Ie[m]=(nt*he-F)*b,Ie[x]=De*D,Ie[g]=K,c.push(Ie.x,Ie.y,Ie.z),Ie[m]=0,Ie[x]=0,Ie[g]=Z>0?1:-1,u.push(Ie.x,Ie.y,Ie.z),d.push(nt/z),d.push(1-ve/fe),ae+=1}for(let ve=0;ve<fe;ve++)for(let De=0;De<z;De++){let gt=p+De+de*(ve+1),Ue=p+(De+1)+de*(ve+1),Ae=p+(De+1)+de*ve;l.push(p+De+de*ve,gt,Ae),l.push(gt,Ue,Ae),le+=6}a.addGroup(h,le,ue),h+=le,p+=ae}f("z","y","x",-1,-1,i,e,t,s,o,0),f("z","y","x",1,-1,i,e,-t,s,o,1),f("x","z","y",1,1,t,i,e,r,s,2),f("x","z","y",1,-1,t,i,-e,r,s,3),f("x","y","z",1,-1,t,e,i,r,o,4),f("x","y","z",-1,-1,t,e,-i,r,o,5),this.setIndex(l),this.setAttribute("position",new Jr(c,3)),this.setAttribute("normal",new Jr(u,3)),this.setAttribute("uv",new Jr(d,2))}static fromJSON(t){return new Wg(t.width,t.height,t.depth,t.widthSegments,t.heightSegments,t.depthSegments)}};function fb(n){let t={};for(let e in n){t[e]={};for(let i in n[e]){let r=n[e][i];t[e][i]=r&&(r.isColor||r.isMatrix3||r.isMatrix4||r.isVector2||r.isVector3||r.isVector4||r.isTexture||r.isQuaternion)?r.clone():Array.isArray(r)?r.slice():r}}return t}function js(n){let t={};for(let e=0;e<n.length;e++){let i=fb(n[e]);for(let r in i)t[r]=i[r]}return t}var J8e={clone:fb,merge:js},Dp=class extends hs{constructor(t){super(),this.type="ShaderMaterial",this.defines={},this.uniforms={},this.vertexShader="void main() {\n\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}",this.fragmentShader="void main() {\n\tgl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\n}",this.linewidth=1,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.lights=!1,this.clipping=!1,this.extensions={derivatives:!1,fragDepth:!1,drawBuffers:!1,shaderTextureLOD:!1},this.defaultAttributeValues={color:[1,1,1],uv:[0,0],uv2:[0,0]},this.index0AttributeName=void 0,this.uniformsNeedUpdate=!1,this.glslVersion=null,void 0!==t&&(void 0!==t.attributes&&console.error("THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead."),this.setValues(t))}copy(t){return super.copy(t),this.fragmentShader=t.fragmentShader,this.vertexShader=t.vertexShader,this.uniforms=fb(t.uniforms),this.defines=Object.assign({},t.defines),this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.lights=t.lights,this.clipping=t.clipping,this.extensions=Object.assign({},t.extensions),this.glslVersion=t.glslVersion,this}toJSON(t){let e=super.toJSON(t);e.glslVersion=this.glslVersion,e.uniforms={};for(let r in this.uniforms){let s=this.uniforms[r].value;e.uniforms[r]=s&&s.isTexture?{type:"t",value:s.toJSON(t).uuid}:s&&s.isColor?{type:"c",value:s.getHex()}:s&&s.isVector2?{type:"v2",value:s.toArray()}:s&&s.isVector3?{type:"v3",value:s.toArray()}:s&&s.isVector4?{type:"v4",value:s.toArray()}:s&&s.isMatrix3?{type:"m3",value:s.toArray()}:s&&s.isMatrix4?{type:"m4",value:s.toArray()}:{value:s}}Object.keys(this.defines).length>0&&(e.defines=this.defines),e.vertexShader=this.vertexShader,e.fragmentShader=this.fragmentShader;let i={};for(let r in this.extensions)!0===this.extensions[r]&&(i[r]=!0);return Object.keys(i).length>0&&(e.extensions=i),e}};Dp.prototype.isShaderMaterial=!0;var QS=class extends Xi{constructor(){super(),this.type="Camera",this.matrixWorldInverse=new Rn,this.projectionMatrix=new Rn,this.projectionMatrixInverse=new Rn}copy(t,e){return super.copy(t,e),this.matrixWorldInverse.copy(t.matrixWorldInverse),this.projectionMatrix.copy(t.projectionMatrix),this.projectionMatrixInverse.copy(t.projectionMatrixInverse),this}getWorldDirection(t){this.updateWorldMatrix(!0,!1);let e=this.matrixWorld.elements;return t.set(-e[8],-e[9],-e[10]).normalize()}updateMatrixWorld(t){super.updateMatrixWorld(t),this.matrixWorldInverse.copy(this.matrixWorld).invert()}updateWorldMatrix(t,e){super.updateWorldMatrix(t,e),this.matrixWorldInverse.copy(this.matrixWorld).invert()}clone(){return(new this.constructor).copy(this)}};QS.prototype.isCamera=!0;var Ws=class extends QS{constructor(t=50,e=1,i=.1,r=2e3){super(),this.type="PerspectiveCamera",this.fov=t,this.zoom=1,this.near=i,this.far=r,this.focus=10,this.aspect=e,this.view=null,this.filmGauge=35,this.filmOffset=0,this.updateProjectionMatrix()}copy(t,e){return super.copy(t,e),this.fov=t.fov,this.zoom=t.zoom,this.near=t.near,this.far=t.far,this.focus=t.focus,this.aspect=t.aspect,this.view=null===t.view?null:Object.assign({},t.view),this.filmGauge=t.filmGauge,this.filmOffset=t.filmOffset,this}setFocalLength(t){let e=.5*this.getFilmHeight()/t;this.fov=2*h8*Math.atan(e),this.updateProjectionMatrix()}getFocalLength(){let t=Math.tan(.5*Dj*this.fov);return.5*this.getFilmHeight()/t}getEffectiveFOV(){return 2*h8*Math.atan(Math.tan(.5*Dj*this.fov)/this.zoom)}getFilmWidth(){return this.filmGauge*Math.min(this.aspect,1)}getFilmHeight(){return this.filmGauge/Math.max(this.aspect,1)}setViewOffset(t,e,i,r,o,s){this.aspect=t/e,null===this.view&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=e,this.view.offsetX=i,this.view.offsetY=r,this.view.width=o,this.view.height=s,this.updateProjectionMatrix()}clearViewOffset(){null!==this.view&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let t=this.near,e=t*Math.tan(.5*Dj*this.fov)/this.zoom,i=2*e,r=this.aspect*i,o=-.5*r,s=this.view;if(null!==this.view&&this.view.enabled){let l=s.fullWidth,c=s.fullHeight;o+=s.offsetX*r/l,e-=s.offsetY*i/c,r*=s.width/l,i*=s.height/c}let a=this.filmOffset;0!==a&&(o+=t*a/this.getFilmWidth()),this.projectionMatrix.makePerspective(o,o+r,e,e-i,t,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){let e=super.toJSON(t);return e.object.fov=this.fov,e.object.zoom=this.zoom,e.object.near=this.near,e.object.far=this.far,e.object.focus=this.focus,e.object.aspect=this.aspect,null!==this.view&&(e.object.view=Object.assign({},this.view)),e.object.filmGauge=this.filmGauge,e.object.filmOffset=this.filmOffset,e}};Ws.prototype.isPerspectiveCamera=!0;var KS=class extends Xi{constructor(t,e,i){if(super(),this.type="CubeCamera",!0!==i.isWebGLCubeRenderTarget)return void console.error("THREE.CubeCamera: The constructor now expects an instance of WebGLCubeRenderTarget as third parameter.");this.renderTarget=i;let r=new Ws(90,1,t,e);r.layers=this.layers,r.up.set(0,-1,0),r.lookAt(new ie(1,0,0)),this.add(r);let o=new Ws(90,1,t,e);o.layers=this.layers,o.up.set(0,-1,0),o.lookAt(new ie(-1,0,0)),this.add(o);let s=new Ws(90,1,t,e);s.layers=this.layers,s.up.set(0,0,1),s.lookAt(new ie(0,1,0)),this.add(s);let a=new Ws(90,1,t,e);a.layers=this.layers,a.up.set(0,0,-1),a.lookAt(new ie(0,-1,0)),this.add(a);let l=new Ws(90,1,t,e);l.layers=this.layers,l.up.set(0,-1,0),l.lookAt(new ie(0,0,1)),this.add(l);let c=new Ws(90,1,t,e);c.layers=this.layers,c.up.set(0,-1,0),c.lookAt(new ie(0,0,-1)),this.add(c)}update(t,e){null===this.parent&&this.updateMatrixWorld();let i=this.renderTarget,[r,o,s,a,l,c]=this.children,u=t.xr.enabled,d=t.getRenderTarget();t.xr.enabled=!1;let p=i.texture.generateMipmaps;i.texture.generateMipmaps=!1,t.setRenderTarget(i,0),t.render(e,r),t.setRenderTarget(i,1),t.render(e,o),t.setRenderTarget(i,2),t.render(e,s),t.setRenderTarget(i,3),t.render(e,a),t.setRenderTarget(i,4),t.render(e,l),i.texture.generateMipmaps=p,t.setRenderTarget(i,5),t.render(e,c),t.setRenderTarget(d),t.xr.enabled=u,i.texture.needsPMREMUpdate=!0}},mb=class extends Ho{constructor(t,e,i,r,o,s,a,l,c,u){super(t=void 0!==t?t:[],e=void 0!==e?e:301,i,r,o,s,a,l,c,u),this.flipY=!1}get images(){return this.image}set images(t){this.image=t}};mb.prototype.isCubeTexture=!0;var ck=class extends Wa{constructor(t,e,i){Number.isInteger(e)&&(console.warn("THREE.WebGLCubeRenderTarget: constructor signature is now WebGLCubeRenderTarget( size, options )"),e=i),super(t,t,e),this.texture=new mb(void 0,(e=e||{}).mapping,e.wrapS,e.wrapT,e.magFilter,e.minFilter,e.format,e.type,e.anisotropy,e.encoding),this.texture.isRenderTargetTexture=!0,this.texture.generateMipmaps=void 0!==e.generateMipmaps&&e.generateMipmaps,this.texture.minFilter=void 0!==e.minFilter?e.minFilter:Gs}fromEquirectangularTexture(t,e){this.texture.type=e.type,this.texture.format=ga,this.texture.encoding=e.encoding,this.texture.generateMipmaps=e.generateMipmaps,this.texture.minFilter=e.minFilter,this.texture.magFilter=e.magFilter;let i_uniforms={tEquirect:{value:null}},i_vertexShader="\n\n\t\t\t\tvarying vec3 vWorldDirection;\n\n\t\t\t\tvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\n\t\t\t\t\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n\n\t\t\t\t}\n\n\t\t\t\tvoid main() {\n\n\t\t\t\t\tvWorldDirection = transformDirection( position, modelMatrix );\n\n\t\t\t\t\t#include <begin_vertex>\n\t\t\t\t\t#include <project_vertex>\n\n\t\t\t\t}\n\t\t\t",i_fragmentShader="\n\n\t\t\t\tuniform sampler2D tEquirect;\n\n\t\t\t\tvarying vec3 vWorldDirection;\n\n\t\t\t\t#include <common>\n\n\t\t\t\tvoid main() {\n\n\t\t\t\t\tvec3 direction = normalize( vWorldDirection );\n\n\t\t\t\t\tvec2 sampleUV = equirectUv( direction );\n\n\t\t\t\t\tgl_FragColor = texture2D( tEquirect, sampleUV );\n\n\t\t\t\t}\n\t\t\t",r=new Wg(5,5,5),o=new Dp({name:"CubemapFromEquirect",uniforms:fb(i_uniforms),vertexShader:i_vertexShader,fragmentShader:i_fragmentShader,side:1,blending:0});o.uniforms.tEquirect.value=e;let s=new Vo(r,o),a=e.minFilter;return 1008===e.minFilter&&(e.minFilter=Gs),new KS(1,10,this).update(t,s),e.minFilter=a,s.geometry.dispose(),s.material.dispose(),this}clear(t,e,i,r){let o=t.getRenderTarget();for(let s=0;s<6;s++)t.setRenderTarget(this,s),t.clear(e,i,r);t.setRenderTarget(o)}};ck.prototype.isWebGLCubeRenderTarget=!0;var Kj=new ie,tGe=new ie,nGe=new Jo,uu=class{constructor(t=new ie(1,0,0),e=0){this.normal=t,this.constant=e}set(t,e){return this.normal.copy(t),this.constant=e,this}setComponents(t,e,i,r){return this.normal.set(t,e,i),this.constant=r,this}setFromNormalAndCoplanarPoint(t,e){return this.normal.copy(t),this.constant=-e.dot(this.normal),this}setFromCoplanarPoints(t,e,i){let r=Kj.subVectors(i,e).cross(tGe.subVectors(t,e)).normalize();return this.setFromNormalAndCoplanarPoint(r,t),this}copy(t){return this.normal.copy(t.normal),this.constant=t.constant,this}normalize(){let t=1/this.normal.length();return this.normal.multiplyScalar(t),this.constant*=t,this}negate(){return this.constant*=-1,this.normal.negate(),this}distanceToPoint(t){return this.normal.dot(t)+this.constant}distanceToSphere(t){return this.distanceToPoint(t.center)-t.radius}projectPoint(t,e){return e.copy(this.normal).multiplyScalar(-this.distanceToPoint(t)).add(t)}intersectLine(t,e){let i=t.delta(Kj),r=this.normal.dot(i);if(0===r)return 0===this.distanceToPoint(t.start)?e.copy(t.start):null;let o=-(t.start.dot(this.normal)+this.constant)/r;return o<0||o>1?null:e.copy(i).multiplyScalar(o).add(t.start)}intersectsLine(t){let e=this.distanceToPoint(t.start),i=this.distanceToPoint(t.end);return e<0&&i>0||i<0&&e>0}intersectsBox(t){return t.intersectsPlane(this)}intersectsSphere(t){return t.intersectsPlane(this)}coplanarPoint(t){return t.copy(this.normal).multiplyScalar(-this.constant)}applyMatrix4(t,e){let i=e||nGe.getNormalMatrix(t),r=this.coplanarPoint(Kj).applyMatrix4(t),o=this.normal.applyMatrix3(i).normalize();return this.constant=-r.dot(o),this}translate(t){return this.constant-=t.dot(this.normal),this}equals(t){return t.normal.equals(this.normal)&&t.constant===this.constant}clone(){return(new this.constructor).copy(this)}};uu.prototype.isPlane=!0;var Zy=new xf,VO=new ie,gb=class{constructor(t=new uu,e=new uu,i=new uu,r=new uu,o=new uu,s=new uu){this.planes=[t,e,i,r,o,s]}set(t,e,i,r,o,s){let a=this.planes;return a[0].copy(t),a[1].copy(e),a[2].copy(i),a[3].copy(r),a[4].copy(o),a[5].copy(s),this}copy(t){let e=this.planes;for(let i=0;i<6;i++)e[i].copy(t.planes[i]);return this}setFromProjectionMatrix(t){let e=this.planes,i=t.elements,r=i[0],o=i[1],s=i[2],a=i[3],l=i[4],c=i[5],u=i[6],d=i[7],p=i[8],h=i[9],f=i[10],m=i[11],x=i[12],g=i[13],b=i[14],D=i[15];return e[0].setComponents(a-r,d-l,m-p,D-x).normalize(),e[1].setComponents(a+r,d+l,m+p,D+x).normalize(),e[2].setComponents(a+o,d+c,m+h,D+g).normalize(),e[3].setComponents(a-o,d-c,m-h,D-g).normalize(),e[4].setComponents(a-s,d-u,m-f,D-b).normalize(),e[5].setComponents(a+s,d+u,m+f,D+b).normalize(),this}intersectsObject(t){let e=t.geometry;return null===e.boundingSphere&&e.computeBoundingSphere(),Zy.copy(e.boundingSphere).applyMatrix4(t.matrixWorld),this.intersectsSphere(Zy)}intersectsSprite(t){return Zy.center.set(0,0,0),Zy.radius=.7071067811865476,Zy.applyMatrix4(t.matrixWorld),this.intersectsSphere(Zy)}intersectsSphere(t){let e=this.planes,i=t.center,r=-t.radius;for(let o=0;o<6;o++)if(e[o].distanceToPoint(i)<r)return!1;return!0}intersectsBox(t){let e=this.planes;for(let i=0;i<6;i++){let r=e[i];if(VO.x=r.normal.x>0?t.max.x:t.min.x,VO.y=r.normal.y>0?t.max.y:t.min.y,VO.z=r.normal.z>0?t.max.z:t.min.z,r.distanceToPoint(VO)<0)return!1}return!0}containsPoint(t){let e=this.planes;for(let i=0;i<6;i++)if(e[i].distanceToPoint(t)<0)return!1;return!0}clone(){return(new this.constructor).copy(this)}};function kde(){let n=null,t=!1,e=null,i=null;function r(o,s){e(o,s),i=n.requestAnimationFrame(r)}return{start:function(){!0!==t&&null!==e&&(i=n.requestAnimationFrame(r),t=!0)},stop:function(){n.cancelAnimationFrame(i),t=!1},setAnimationLoop:function(o){e=o},setContext:function(o){n=o}}}function iGe(n,t){let e=t.isWebGL2,i=new WeakMap;return{get:function(c){return c.isInterleavedBufferAttribute&&(c=c.data),i.get(c)},remove:function(c){c.isInterleavedBufferAttribute&&(c=c.data);let u=i.get(c);u&&(n.deleteBuffer(u.buffer),i.delete(c))},update:function(c,u){if(c.isGLBufferAttribute){let p=i.get(c);return void((!p||p.version<c.version)&&i.set(c,{buffer:c.buffer,type:c.type,bytesPerElement:c.elementSize,version:c.version}))}c.isInterleavedBufferAttribute&&(c=c.data);let d=i.get(c);void 0===d?i.set(c,function(c,u){let d=c.array,p=c.usage,h=n.createBuffer();n.bindBuffer(u,h),n.bufferData(u,d,p),c.onUploadCallback();let f=5126;return d instanceof Float32Array?f=5126:d instanceof Float64Array?console.warn("THREE.WebGLAttributes: Unsupported data buffer format: Float64Array."):d instanceof Uint16Array?c.isFloat16BufferAttribute?e?f=5131:console.warn("THREE.WebGLAttributes: Usage of Float16BufferAttribute requires WebGL2."):f=5123:d instanceof Int16Array?f=5122:d instanceof Uint32Array?f=5125:d instanceof Int32Array?f=5124:d instanceof Int8Array?f=5120:(d instanceof Uint8Array||d instanceof Uint8ClampedArray)&&(f=5121),{buffer:h,type:f,bytesPerElement:d.BYTES_PER_ELEMENT,version:c.version}}(c,u)):d.version<c.version&&(function(c,u,d){let p=u.array,h=u.updateRange;n.bindBuffer(d,c),-1===h.count?n.bufferSubData(d,0,p):(e?n.bufferSubData(d,h.offset*p.BYTES_PER_ELEMENT,p,h.offset,h.count):n.bufferSubData(d,h.offset*p.BYTES_PER_ELEMENT,p.subarray(h.offset,h.offset+h.count)),h.count=-1)}(d.buffer,c,u),d.version=c.version)}}}var ZS=class extends nr{constructor(t=1,e=1,i=1,r=1){super(),this.type="PlaneGeometry",this.parameters={width:t,height:e,widthSegments:i,heightSegments:r};let o=t/2,s=e/2,a=Math.floor(i),l=Math.floor(r),c=a+1,u=l+1,d=t/a,p=e/l,h=[],f=[],m=[],x=[];for(let g=0;g<u;g++){let b=g*p-s;for(let D=0;D<c;D++)f.push(D*d-o,-b,0),m.push(0,0,1),x.push(D/a),x.push(1-g/l)}for(let g=0;g<l;g++)for(let b=0;b<a;b++){let T=b+c*(g+1),k=b+1+c*(g+1),Z=b+1+c*g;h.push(b+c*g,T,Z),h.push(T,k,Z)}this.setIndex(h),this.setAttribute("position",new Jr(f,3)),this.setAttribute("normal",new Jr(m,3)),this.setAttribute("uv",new Jr(x,2))}static fromJSON(t){return new ZS(t.width,t.height,t.widthSegments,t.heightSegments)}},Di={alphamap_fragment:"#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, vUv ).g;\n#endif",alphamap_pars_fragment:"#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif",alphatest_fragment:"#ifdef USE_ALPHATEST\n\tif ( diffuseColor.a < alphaTest ) discard;\n#endif",alphatest_pars_fragment:"#ifdef USE_ALPHATEST\n\tuniform float alphaTest;\n#endif",aomap_fragment:"#ifdef USE_AOMAP\n\tfloat ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;\n\treflectedLight.indirectDiffuse *= ambientOcclusion;\n\t#if defined( USE_ENVMAP ) && defined( STANDARD )\n\t\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n\t\treflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.roughness );\n\t#endif\n#endif",aomap_pars_fragment:"#ifdef USE_AOMAP\n\tuniform sampler2D aoMap;\n\tuniform float aoMapIntensity;\n#endif",begin_vertex:"vec3 transformed = vec3( position );",beginnormal_vertex:"vec3 objectNormal = vec3( normal );\n#ifdef USE_TANGENT\n\tvec3 objectTangent = vec3( tangent.xyz );\n#endif",bsdfs:"vec3 BRDF_Lambert( const in vec3 diffuseColor ) {\n\treturn RECIPROCAL_PI * diffuseColor;\n}\nvec3 F_Schlick( const in vec3 f0, const in float f90, const in float dotVH ) {\n\tfloat fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );\n\treturn f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );\n}\nfloat V_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 = pow2( alpha );\n\tfloat gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\tfloat gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n\treturn 0.5 / max( gv + gl, EPSILON );\n}\nfloat D_GGX( const in float alpha, const in float dotNH ) {\n\tfloat a2 = pow2( alpha );\n\tfloat denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;\n\treturn RECIPROCAL_PI * a2 / pow2( denom );\n}\nvec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 f0, const in float f90, const in float roughness ) {\n\tfloat alpha = pow2( roughness );\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNL = saturate( dot( normal, lightDir ) );\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat dotVH = saturate( dot( viewDir, halfDir ) );\n\tvec3 F = F_Schlick( f0, f90, dotVH );\n\tfloat V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n\tfloat D = D_GGX( alpha, dotNH );\n\treturn F * ( V * D );\n}\nvec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {\n\tconst float LUT_SIZE = 64.0;\n\tconst float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;\n\tconst float LUT_BIAS = 0.5 / LUT_SIZE;\n\tfloat dotNV = saturate( dot( N, V ) );\n\tvec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );\n\tuv = uv * LUT_SCALE + LUT_BIAS;\n\treturn uv;\n}\nfloat LTC_ClippedSphereFormFactor( const in vec3 f ) {\n\tfloat l = length( f );\n\treturn max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );\n}\nvec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {\n\tfloat x = dot( v1, v2 );\n\tfloat y = abs( x );\n\tfloat a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;\n\tfloat b = 3.4175940 + ( 4.1616724 + y ) * y;\n\tfloat v = a / b;\n\tfloat theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;\n\treturn cross( v1, v2 ) * theta_sintheta;\n}\nvec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {\n\tvec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];\n\tvec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];\n\tvec3 lightNormal = cross( v1, v2 );\n\tif( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );\n\tvec3 T1, T2;\n\tT1 = normalize( V - N * dot( V, N ) );\n\tT2 = - cross( N, T1 );\n\tmat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );\n\tvec3 coords[ 4 ];\n\tcoords[ 0 ] = mat * ( rectCoords[ 0 ] - P );\n\tcoords[ 1 ] = mat * ( rectCoords[ 1 ] - P );\n\tcoords[ 2 ] = mat * ( rectCoords[ 2 ] - P );\n\tcoords[ 3 ] = mat * ( rectCoords[ 3 ] - P );\n\tcoords[ 0 ] = normalize( coords[ 0 ] );\n\tcoords[ 1 ] = normalize( coords[ 1 ] );\n\tcoords[ 2 ] = normalize( coords[ 2 ] );\n\tcoords[ 3 ] = normalize( coords[ 3 ] );\n\tvec3 vectorFormFactor = vec3( 0.0 );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );\n\tfloat result = LTC_ClippedSphereFormFactor( vectorFormFactor );\n\treturn vec3( result );\n}\nfloat G_BlinnPhong_Implicit( ) {\n\treturn 0.25;\n}\nfloat D_BlinnPhong( const in float shininess, const in float dotNH ) {\n\treturn RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );\n}\nvec3 BRDF_BlinnPhong( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float shininess ) {\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat dotVH = saturate( dot( viewDir, halfDir ) );\n\tvec3 F = F_Schlick( specularColor, 1.0, dotVH );\n\tfloat G = G_BlinnPhong_Implicit( );\n\tfloat D = D_BlinnPhong( shininess, dotNH );\n\treturn F * ( G * D );\n}\n#if defined( USE_SHEEN )\nfloat D_Charlie( float roughness, float dotNH ) {\n\tfloat alpha = pow2( roughness );\n\tfloat invAlpha = 1.0 / alpha;\n\tfloat cos2h = dotNH * dotNH;\n\tfloat sin2h = max( 1.0 - cos2h, 0.0078125 );\n\treturn ( 2.0 + invAlpha ) * pow( sin2h, invAlpha * 0.5 ) / ( 2.0 * PI );\n}\nfloat V_Neubelt( float dotNV, float dotNL ) {\n\treturn saturate( 1.0 / ( 4.0 * ( dotNL + dotNV - dotNL * dotNV ) ) );\n}\nvec3 BRDF_Sheen( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, vec3 sheenColor, const in float sheenRoughness ) {\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNL = saturate( dot( normal, lightDir ) );\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat D = D_Charlie( sheenRoughness, dotNH );\n\tfloat V = V_Neubelt( dotNV, dotNL );\n\treturn sheenColor * ( D * V );\n}\n#endif",bumpmap_pars_fragment:"#ifdef USE_BUMPMAP\n\tuniform sampler2D bumpMap;\n\tuniform float bumpScale;\n\tvec2 dHdxy_fwd() {\n\t\tvec2 dSTdx = dFdx( vUv );\n\t\tvec2 dSTdy = dFdy( vUv );\n\t\tfloat Hll = bumpScale * texture2D( bumpMap, vUv ).x;\n\t\tfloat dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;\n\t\tfloat dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;\n\t\treturn vec2( dBx, dBy );\n\t}\n\tvec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy, float faceDirection ) {\n\t\tvec3 vSigmaX = vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );\n\t\tvec3 vSigmaY = vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );\n\t\tvec3 vN = surf_norm;\n\t\tvec3 R1 = cross( vSigmaY, vN );\n\t\tvec3 R2 = cross( vN, vSigmaX );\n\t\tfloat fDet = dot( vSigmaX, R1 ) * faceDirection;\n\t\tvec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );\n\t\treturn normalize( abs( fDet ) * surf_norm - vGrad );\n\t}\n#endif",clipping_planes_fragment:"#if NUM_CLIPPING_PLANES > 0\n\tvec4 plane;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {\n\t\tplane = clippingPlanes[ i ];\n\t\tif ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;\n\t}\n\t#pragma unroll_loop_end\n\t#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\n\t\tbool clipped = true;\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {\n\t\t\tplane = clippingPlanes[ i ];\n\t\t\tclipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t\tif ( clipped ) discard;\n\t#endif\n#endif",clipping_planes_pars_fragment:"#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n\tuniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];\n#endif",clipping_planes_pars_vertex:"#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n#endif",clipping_planes_vertex:"#if NUM_CLIPPING_PLANES > 0\n\tvClipPosition = - mvPosition.xyz;\n#endif",color_fragment:"#if defined( USE_COLOR_ALPHA )\n\tdiffuseColor *= vColor;\n#elif defined( USE_COLOR )\n\tdiffuseColor.rgb *= vColor;\n#endif",color_pars_fragment:"#if defined( USE_COLOR_ALPHA )\n\tvarying vec4 vColor;\n#elif defined( USE_COLOR )\n\tvarying vec3 vColor;\n#endif",color_pars_vertex:"#if defined( USE_COLOR_ALPHA )\n\tvarying vec4 vColor;\n#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )\n\tvarying vec3 vColor;\n#endif",color_vertex:"#if defined( USE_COLOR_ALPHA )\n\tvColor = vec4( 1.0 );\n#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )\n\tvColor = vec3( 1.0 );\n#endif\n#ifdef USE_COLOR\n\tvColor *= color;\n#endif\n#ifdef USE_INSTANCING_COLOR\n\tvColor.xyz *= instanceColor.xyz;\n#endif",common:"#define PI 3.141592653589793\n#define PI2 6.283185307179586\n#define PI_HALF 1.5707963267948966\n#define RECIPROCAL_PI 0.3183098861837907\n#define RECIPROCAL_PI2 0.15915494309189535\n#define EPSILON 1e-6\n#ifndef saturate\n#define saturate( a ) clamp( a, 0.0, 1.0 )\n#endif\n#define whiteComplement( a ) ( 1.0 - saturate( a ) )\nfloat pow2( const in float x ) { return x*x; }\nfloat pow3( const in float x ) { return x*x*x; }\nfloat pow4( const in float x ) { float x2 = x*x; return x2*x2; }\nfloat max3( const in vec3 v ) { return max( max( v.x, v.y ), v.z ); }\nfloat average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }\nhighp float rand( const in vec2 uv ) {\n\tconst highp float a = 12.9898, b = 78.233, c = 43758.5453;\n\thighp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );\n\treturn fract( sin( sn ) * c );\n}\n#ifdef HIGH_PRECISION\n\tfloat precisionSafeLength( vec3 v ) { return length( v ); }\n#else\n\tfloat precisionSafeLength( vec3 v ) {\n\t\tfloat maxComponent = max3( abs( v ) );\n\t\treturn length( v / maxComponent ) * maxComponent;\n\t}\n#endif\nstruct IncidentLight {\n\tvec3 color;\n\tvec3 direction;\n\tbool visible;\n};\nstruct ReflectedLight {\n\tvec3 directDiffuse;\n\tvec3 directSpecular;\n\tvec3 indirectDiffuse;\n\tvec3 indirectSpecular;\n};\nstruct GeometricContext {\n\tvec3 position;\n\tvec3 normal;\n\tvec3 viewDir;\n#ifdef USE_CLEARCOAT\n\tvec3 clearcoatNormal;\n#endif\n};\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n}\nvec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );\n}\nmat3 transposeMat3( const in mat3 m ) {\n\tmat3 tmp;\n\ttmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );\n\ttmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );\n\ttmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );\n\treturn tmp;\n}\nfloat linearToRelativeLuminance( const in vec3 color ) {\n\tvec3 weights = vec3( 0.2126, 0.7152, 0.0722 );\n\treturn dot( weights, color.rgb );\n}\nbool isPerspectiveMatrix( mat4 m ) {\n\treturn m[ 2 ][ 3 ] == - 1.0;\n}\nvec2 equirectUv( in vec3 dir ) {\n\tfloat u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;\n\tfloat v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\treturn vec2( u, v );\n}",cube_uv_reflection_fragment:"#ifdef ENVMAP_TYPE_CUBE_UV\n\t#define cubeUV_maxMipLevel 8.0\n\t#define cubeUV_minMipLevel 4.0\n\t#define cubeUV_maxTileSize 256.0\n\t#define cubeUV_minTileSize 16.0\n\tfloat getFace( vec3 direction ) {\n\t\tvec3 absDirection = abs( direction );\n\t\tfloat face = - 1.0;\n\t\tif ( absDirection.x > absDirection.z ) {\n\t\t\tif ( absDirection.x > absDirection.y )\n\t\t\t\tface = direction.x > 0.0 ? 0.0 : 3.0;\n\t\t\telse\n\t\t\t\tface = direction.y > 0.0 ? 1.0 : 4.0;\n\t\t} else {\n\t\t\tif ( absDirection.z > absDirection.y )\n\t\t\t\tface = direction.z > 0.0 ? 2.0 : 5.0;\n\t\t\telse\n\t\t\t\tface = direction.y > 0.0 ? 1.0 : 4.0;\n\t\t}\n\t\treturn face;\n\t}\n\tvec2 getUV( vec3 direction, float face ) {\n\t\tvec2 uv;\n\t\tif ( face == 0.0 ) {\n\t\t\tuv = vec2( direction.z, direction.y ) / abs( direction.x );\n\t\t} else if ( face == 1.0 ) {\n\t\t\tuv = vec2( - direction.x, - direction.z ) / abs( direction.y );\n\t\t} else if ( face == 2.0 ) {\n\t\t\tuv = vec2( - direction.x, direction.y ) / abs( direction.z );\n\t\t} else if ( face == 3.0 ) {\n\t\t\tuv = vec2( - direction.z, direction.y ) / abs( direction.x );\n\t\t} else if ( face == 4.0 ) {\n\t\t\tuv = vec2( - direction.x, direction.z ) / abs( direction.y );\n\t\t} else {\n\t\t\tuv = vec2( direction.x, direction.y ) / abs( direction.z );\n\t\t}\n\t\treturn 0.5 * ( uv + 1.0 );\n\t}\n\tvec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {\n\t\tfloat face = getFace( direction );\n\t\tfloat filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );\n\t\tmipInt = max( mipInt, cubeUV_minMipLevel );\n\t\tfloat faceSize = exp2( mipInt );\n\t\tfloat texelSize = 1.0 / ( 3.0 * cubeUV_maxTileSize );\n\t\tvec2 uv = getUV( direction, face ) * ( faceSize - 1.0 ) + 0.5;\n\t\tif ( face > 2.0 ) {\n\t\t\tuv.y += faceSize;\n\t\t\tface -= 3.0;\n\t\t}\n\t\tuv.x += face * faceSize;\n\t\tif ( mipInt < cubeUV_maxMipLevel ) {\n\t\t\tuv.y += 2.0 * cubeUV_maxTileSize;\n\t\t}\n\t\tuv.y += filterInt * 2.0 * cubeUV_minTileSize;\n\t\tuv.x += 3.0 * max( 0.0, cubeUV_maxTileSize - 2.0 * faceSize );\n\t\tuv *= texelSize;\n\t\treturn texture2D( envMap, uv ).rgb;\n\t}\n\t#define r0 1.0\n\t#define v0 0.339\n\t#define m0 - 2.0\n\t#define r1 0.8\n\t#define v1 0.276\n\t#define m1 - 1.0\n\t#define r4 0.4\n\t#define v4 0.046\n\t#define m4 2.0\n\t#define r5 0.305\n\t#define v5 0.016\n\t#define m5 3.0\n\t#define r6 0.21\n\t#define v6 0.0038\n\t#define m6 4.0\n\tfloat roughnessToMip( float roughness ) {\n\t\tfloat mip = 0.0;\n\t\tif ( roughness >= r1 ) {\n\t\t\tmip = ( r0 - roughness ) * ( m1 - m0 ) / ( r0 - r1 ) + m0;\n\t\t} else if ( roughness >= r4 ) {\n\t\t\tmip = ( r1 - roughness ) * ( m4 - m1 ) / ( r1 - r4 ) + m1;\n\t\t} else if ( roughness >= r5 ) {\n\t\t\tmip = ( r4 - roughness ) * ( m5 - m4 ) / ( r4 - r5 ) + m4;\n\t\t} else if ( roughness >= r6 ) {\n\t\t\tmip = ( r5 - roughness ) * ( m6 - m5 ) / ( r5 - r6 ) + m5;\n\t\t} else {\n\t\t\tmip = - 2.0 * log2( 1.16 * roughness );\t\t}\n\t\treturn mip;\n\t}\n\tvec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {\n\t\tfloat mip = clamp( roughnessToMip( roughness ), m0, cubeUV_maxMipLevel );\n\t\tfloat mipF = fract( mip );\n\t\tfloat mipInt = floor( mip );\n\t\tvec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );\n\t\tif ( mipF == 0.0 ) {\n\t\t\treturn vec4( color0, 1.0 );\n\t\t} else {\n\t\t\tvec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );\n\t\t\treturn vec4( mix( color0, color1, mipF ), 1.0 );\n\t\t}\n\t}\n#endif",defaultnormal_vertex:"vec3 transformedNormal = objectNormal;\n#ifdef USE_INSTANCING\n\tmat3 m = mat3( instanceMatrix );\n\ttransformedNormal /= vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) );\n\ttransformedNormal = m * transformedNormal;\n#endif\ntransformedNormal = normalMatrix * transformedNormal;\n#ifdef FLIP_SIDED\n\ttransformedNormal = - transformedNormal;\n#endif\n#ifdef USE_TANGENT\n\tvec3 transformedTangent = ( modelViewMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n\t#ifdef FLIP_SIDED\n\t\ttransformedTangent = - transformedTangent;\n\t#endif\n#endif",displacementmap_pars_vertex:"#ifdef USE_DISPLACEMENTMAP\n\tuniform sampler2D displacementMap;\n\tuniform float displacementScale;\n\tuniform float displacementBias;\n#endif",displacementmap_vertex:"#ifdef USE_DISPLACEMENTMAP\n\ttransformed += normalize( objectNormal ) * ( texture2D( displacementMap, vUv ).x * displacementScale + displacementBias );\n#endif",emissivemap_fragment:"#ifdef USE_EMISSIVEMAP\n\tvec4 emissiveColor = texture2D( emissiveMap, vUv );\n\ttotalEmissiveRadiance *= emissiveColor.rgb;\n#endif",emissivemap_pars_fragment:"#ifdef USE_EMISSIVEMAP\n\tuniform sampler2D emissiveMap;\n#endif",encodings_fragment:"gl_FragColor = linearToOutputTexel( gl_FragColor );",encodings_pars_fragment:"vec4 LinearToLinear( in vec4 value ) {\n\treturn value;\n}\nvec4 LinearTosRGB( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );\n}",envmap_fragment:"#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvec3 cameraToFrag;\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToFrag = normalize( vWorldPosition - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvec3 reflectVec = reflect( cameraToFrag, worldNormal );\n\t\t#else\n\t\t\tvec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );\n\t\t#endif\n\t#else\n\t\tvec3 reflectVec = vReflect;\n\t#endif\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tvec4 envColor = textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );\n\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\tvec4 envColor = textureCubeUV( envMap, reflectVec, 0.0 );\n\t#else\n\t\tvec4 envColor = vec4( 0.0 );\n\t#endif\n\t#ifdef ENVMAP_BLENDING_MULTIPLY\n\t\toutgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_MIX )\n\t\toutgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_ADD )\n\t\toutgoingLight += envColor.xyz * specularStrength * reflectivity;\n\t#endif\n#endif",envmap_common_pars_fragment:"#ifdef USE_ENVMAP\n\tuniform float envMapIntensity;\n\tuniform float flipEnvMap;\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tuniform samplerCube envMap;\n\t#else\n\t\tuniform sampler2D envMap;\n\t#endif\n\t\n#endif",envmap_pars_fragment:"#ifdef USE_ENVMAP\n\tuniform float reflectivity;\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\tvarying vec3 vWorldPosition;\n\t\tuniform float refractionRatio;\n\t#else\n\t\tvarying vec3 vReflect;\n\t#endif\n#endif",envmap_pars_vertex:"#ifdef USE_ENVMAP\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) ||defined( PHONG )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\t\n\t\tvarying vec3 vWorldPosition;\n\t#else\n\t\tvarying vec3 vReflect;\n\t\tuniform float refractionRatio;\n\t#endif\n#endif",envmap_physical_pars_fragment:"#if defined( USE_ENVMAP )\n\t#ifdef ENVMAP_MODE_REFRACTION\n\t\tuniform float refractionRatio;\n\t#endif\n\tvec3 getIBLIrradiance( const in vec3 normal ) {\n\t\t#if defined( ENVMAP_TYPE_CUBE_UV )\n\t\t\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, worldNormal, 1.0 );\n\t\t\treturn PI * envMapColor.rgb * envMapIntensity;\n\t\t#else\n\t\t\treturn vec3( 0.0 );\n\t\t#endif\n\t}\n\tvec3 getIBLRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {\n\t\t#if defined( ENVMAP_TYPE_CUBE_UV )\n\t\t\tvec3 reflectVec;\n\t\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\t\treflectVec = reflect( - viewDir, normal );\n\t\t\t\treflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );\n\t\t\t#else\n\t\t\t\treflectVec = refract( - viewDir, normal, refractionRatio );\n\t\t\t#endif\n\t\t\treflectVec = inverseTransformDirection( reflectVec, viewMatrix );\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness );\n\t\t\treturn envMapColor.rgb * envMapIntensity;\n\t\t#else\n\t\t\treturn vec3( 0.0 );\n\t\t#endif\n\t}\n#endif",envmap_vertex:"#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvWorldPosition = worldPosition.xyz;\n\t#else\n\t\tvec3 cameraToVertex;\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToVertex = normalize( worldPosition.xyz - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvReflect = reflect( cameraToVertex, worldNormal );\n\t\t#else\n\t\t\tvReflect = refract( cameraToVertex, worldNormal, refractionRatio );\n\t\t#endif\n\t#endif\n#endif",fog_vertex:"#ifdef USE_FOG\n\tvFogDepth = - mvPosition.z;\n#endif",fog_pars_vertex:"#ifdef USE_FOG\n\tvarying float vFogDepth;\n#endif",fog_fragment:"#ifdef USE_FOG\n\t#ifdef FOG_EXP2\n\t\tfloat fogFactor = 1.0 - exp( - fogDensity * fogDensity * vFogDepth * vFogDepth );\n\t#else\n\t\tfloat fogFactor = smoothstep( fogNear, fogFar, vFogDepth );\n\t#endif\n\tgl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );\n#endif",fog_pars_fragment:"#ifdef USE_FOG\n\tuniform vec3 fogColor;\n\tvarying float vFogDepth;\n\t#ifdef FOG_EXP2\n\t\tuniform float fogDensity;\n\t#else\n\t\tuniform float fogNear;\n\t\tuniform float fogFar;\n\t#endif\n#endif",gradientmap_pars_fragment:"#ifdef USE_GRADIENTMAP\n\tuniform sampler2D gradientMap;\n#endif\nvec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {\n\tfloat dotNL = dot( normal, lightDirection );\n\tvec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );\n\t#ifdef USE_GRADIENTMAP\n\t\treturn vec3( texture2D( gradientMap, coord ).r );\n\t#else\n\t\treturn ( coord.x < 0.7 ) ? vec3( 0.7 ) : vec3( 1.0 );\n\t#endif\n}",lightmap_fragment:"#ifdef USE_LIGHTMAP\n\tvec4 lightMapTexel = texture2D( lightMap, vUv2 );\n\tvec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tlightMapIrradiance *= PI;\n\t#endif\n\treflectedLight.indirectDiffuse += lightMapIrradiance;\n#endif",lightmap_pars_fragment:"#ifdef USE_LIGHTMAP\n\tuniform sampler2D lightMap;\n\tuniform float lightMapIntensity;\n#endif",lights_lambert_vertex:"vec3 diffuse = vec3( 1.0 );\nGeometricContext geometry;\ngeometry.position = mvPosition.xyz;\ngeometry.normal = normalize( transformedNormal );\ngeometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -mvPosition.xyz );\nGeometricContext backGeometry;\nbackGeometry.position = geometry.position;\nbackGeometry.normal = -geometry.normal;\nbackGeometry.viewDir = geometry.viewDir;\nvLightFront = vec3( 0.0 );\nvIndirectFront = vec3( 0.0 );\n#ifdef DOUBLE_SIDED\n\tvLightBack = vec3( 0.0 );\n\tvIndirectBack = vec3( 0.0 );\n#endif\nIncidentLight directLight;\nfloat dotNL;\nvec3 directLightColor_Diffuse;\nvIndirectFront += getAmbientLightIrradiance( ambientLightColor );\nvIndirectFront += getLightProbeIrradiance( lightProbe, geometry.normal );\n#ifdef DOUBLE_SIDED\n\tvIndirectBack += getAmbientLightIrradiance( ambientLightColor );\n\tvIndirectBack += getLightProbeIrradiance( lightProbe, backGeometry.normal );\n#endif\n#if NUM_POINT_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tgetPointLightInfo( pointLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( - dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tgetSpotLightInfo( spotLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( - dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if NUM_DIR_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tgetDirectionalLightInfo( directionalLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( - dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\tvIndirectFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvIndirectBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry.normal );\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif",lights_pars_begin:"uniform bool receiveShadow;\nuniform vec3 ambientLightColor;\nuniform vec3 lightProbe[ 9 ];\nvec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {\n\tfloat x = normal.x, y = normal.y, z = normal.z;\n\tvec3 result = shCoefficients[ 0 ] * 0.886227;\n\tresult += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;\n\tresult += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;\n\tresult += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;\n\tresult += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;\n\tresult += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;\n\tresult += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );\n\tresult += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;\n\tresult += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );\n\treturn result;\n}\nvec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in vec3 normal ) {\n\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\tvec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );\n\treturn irradiance;\n}\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\n\tvec3 irradiance = ambientLightColor;\n\treturn irradiance;\n}\nfloat getDistanceAttenuation( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\n\t#if defined ( PHYSICALLY_CORRECT_LIGHTS )\n\t\tfloat distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );\n\t\tif ( cutoffDistance > 0.0 ) {\n\t\t\tdistanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );\n\t\t}\n\t\treturn distanceFalloff;\n\t#else\n\t\tif ( cutoffDistance > 0.0 && decayExponent > 0.0 ) {\n\t\t\treturn pow( saturate( - lightDistance / cutoffDistance + 1.0 ), decayExponent );\n\t\t}\n\t\treturn 1.0;\n\t#endif\n}\nfloat getSpotAttenuation( const in float coneCosine, const in float penumbraCosine, const in float angleCosine ) {\n\treturn smoothstep( coneCosine, penumbraCosine, angleCosine );\n}\n#if NUM_DIR_LIGHTS > 0\n\tstruct DirectionalLight {\n\t\tvec3 direction;\n\t\tvec3 color;\n\t};\n\tuniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];\n\tvoid getDirectionalLightInfo( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight light ) {\n\t\tlight.color = directionalLight.color;\n\t\tlight.direction = directionalLight.direction;\n\t\tlight.visible = true;\n\t}\n#endif\n#if NUM_POINT_LIGHTS > 0\n\tstruct PointLight {\n\t\tvec3 position;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t};\n\tuniform PointLight pointLights[ NUM_POINT_LIGHTS ];\n\tvoid getPointLightInfo( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight light ) {\n\t\tvec3 lVector = pointLight.position - geometry.position;\n\t\tlight.direction = normalize( lVector );\n\t\tfloat lightDistance = length( lVector );\n\t\tlight.color = pointLight.color;\n\t\tlight.color *= getDistanceAttenuation( lightDistance, pointLight.distance, pointLight.decay );\n\t\tlight.visible = ( light.color != vec3( 0.0 ) );\n\t}\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\tstruct SpotLight {\n\t\tvec3 position;\n\t\tvec3 direction;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t\tfloat coneCos;\n\t\tfloat penumbraCos;\n\t};\n\tuniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\n\tvoid getSpotLightInfo( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight light ) {\n\t\tvec3 lVector = spotLight.position - geometry.position;\n\t\tlight.direction = normalize( lVector );\n\t\tfloat angleCos = dot( light.direction, spotLight.direction );\n\t\tfloat spotAttenuation = getSpotAttenuation( spotLight.coneCos, spotLight.penumbraCos, angleCos );\n\t\tif ( spotAttenuation > 0.0 ) {\n\t\t\tfloat lightDistance = length( lVector );\n\t\t\tlight.color = spotLight.color * spotAttenuation;\n\t\t\tlight.color *= getDistanceAttenuation( lightDistance, spotLight.distance, spotLight.decay );\n\t\t\tlight.visible = ( light.color != vec3( 0.0 ) );\n\t\t} else {\n\t\t\tlight.color = vec3( 0.0 );\n\t\t\tlight.visible = false;\n\t\t}\n\t}\n#endif\n#if NUM_RECT_AREA_LIGHTS > 0\n\tstruct RectAreaLight {\n\t\tvec3 color;\n\t\tvec3 position;\n\t\tvec3 halfWidth;\n\t\tvec3 halfHeight;\n\t};\n\tuniform sampler2D ltc_1;\tuniform sampler2D ltc_2;\n\tuniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\tstruct HemisphereLight {\n\t\tvec3 direction;\n\t\tvec3 skyColor;\n\t\tvec3 groundColor;\n\t};\n\tuniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];\n\tvec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in vec3 normal ) {\n\t\tfloat dotNL = dot( normal, hemiLight.direction );\n\t\tfloat hemiDiffuseWeight = 0.5 * dotNL + 0.5;\n\t\tvec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\n\t\treturn irradiance;\n\t}\n#endif",lights_toon_fragment:"ToonMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;",lights_toon_pars_fragment:"varying vec3 vViewPosition;\nstruct ToonMaterial {\n\tvec3 diffuseColor;\n};\nvoid RE_Direct_Toon( const in IncidentLight directLight, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\tvec3 irradiance = getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_Toon\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Toon\n#define Material_LightProbeLOD( material )\t(0)",lights_phong_fragment:"BlinnPhongMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularColor = specular;\nmaterial.specularShininess = shininess;\nmaterial.specularStrength = specularStrength;",lights_phong_pars_fragment:"varying vec3 vViewPosition;\nstruct BlinnPhongMaterial {\n\tvec3 diffuseColor;\n\tvec3 specularColor;\n\tfloat specularShininess;\n\tfloat specularStrength;\n};\nvoid RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n\treflectedLight.directSpecular += irradiance * BRDF_BlinnPhong( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularShininess ) * material.specularStrength;\n}\nvoid RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_BlinnPhong\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_BlinnPhong\n#define Material_LightProbeLOD( material )\t(0)",lights_physical_fragment:"PhysicalMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );\nvec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );\nfloat geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );\nmaterial.roughness = max( roughnessFactor, 0.0525 );material.roughness += geometryRoughness;\nmaterial.roughness = min( material.roughness, 1.0 );\n#ifdef IOR\n\t#ifdef SPECULAR\n\t\tfloat specularIntensityFactor = specularIntensity;\n\t\tvec3 specularColorFactor = specularColor;\n\t\t#ifdef USE_SPECULARINTENSITYMAP\n\t\t\tspecularIntensityFactor *= texture2D( specularIntensityMap, vUv ).a;\n\t\t#endif\n\t\t#ifdef USE_SPECULARCOLORMAP\n\t\t\tspecularColorFactor *= texture2D( specularColorMap, vUv ).rgb;\n\t\t#endif\n\t\tmaterial.specularF90 = mix( specularIntensityFactor, 1.0, metalnessFactor );\n\t#else\n\t\tfloat specularIntensityFactor = 1.0;\n\t\tvec3 specularColorFactor = vec3( 1.0 );\n\t\tmaterial.specularF90 = 1.0;\n\t#endif\n\tmaterial.specularColor = mix( min( pow2( ( ior - 1.0 ) / ( ior + 1.0 ) ) * specularColorFactor, vec3( 1.0 ) ) * specularIntensityFactor, diffuseColor.rgb, metalnessFactor );\n#else\n\tmaterial.specularColor = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessFactor );\n\tmaterial.specularF90 = 1.0;\n#endif\n#ifdef USE_CLEARCOAT\n\tmaterial.clearcoat = clearcoat;\n\tmaterial.clearcoatRoughness = clearcoatRoughness;\n\tmaterial.clearcoatF0 = vec3( 0.04 );\n\tmaterial.clearcoatF90 = 1.0;\n\t#ifdef USE_CLEARCOATMAP\n\t\tmaterial.clearcoat *= texture2D( clearcoatMap, vUv ).x;\n\t#endif\n\t#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\t\tmaterial.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vUv ).y;\n\t#endif\n\tmaterial.clearcoat = saturate( material.clearcoat );\tmaterial.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );\n\tmaterial.clearcoatRoughness += geometryRoughness;\n\tmaterial.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );\n#endif\n#ifdef USE_SHEEN\n\tmaterial.sheenColor = sheenColor;\n\t#ifdef USE_SHEENCOLORMAP\n\t\tmaterial.sheenColor *= texture2D( sheenColorMap, vUv ).rgb;\n\t#endif\n\tmaterial.sheenRoughness = clamp( sheenRoughness, 0.07, 1.0 );\n\t#ifdef USE_SHEENROUGHNESSMAP\n\t\tmaterial.sheenRoughness *= texture2D( sheenRoughnessMap, vUv ).a;\n\t#endif\n#endif",lights_physical_pars_fragment:"struct PhysicalMaterial {\n\tvec3 diffuseColor;\n\tfloat roughness;\n\tvec3 specularColor;\n\tfloat specularF90;\n\t#ifdef USE_CLEARCOAT\n\t\tfloat clearcoat;\n\t\tfloat clearcoatRoughness;\n\t\tvec3 clearcoatF0;\n\t\tfloat clearcoatF90;\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tvec3 sheenColor;\n\t\tfloat sheenRoughness;\n\t#endif\n};\nvec3 clearcoatSpecular = vec3( 0.0 );\nvec3 sheenSpecular = vec3( 0.0 );\nfloat IBLSheenBRDF( const in vec3 normal, const in vec3 viewDir, const in float roughness) {\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat r2 = roughness * roughness;\n\tfloat a = roughness < 0.25 ? -339.2 * r2 + 161.4 * roughness - 25.9 : -8.48 * r2 + 14.3 * roughness - 9.95;\n\tfloat b = roughness < 0.25 ? 44.0 * r2 - 23.7 * roughness + 3.26 : 1.97 * r2 - 3.27 * roughness + 0.72;\n\tfloat DG = exp( a * dotNV + b ) + ( roughness < 0.25 ? 0.0 : 0.1 * ( roughness - 0.25 ) );\n\treturn saturate( DG * RECIPROCAL_PI );\n}\nvec2 DFGApprox( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tconst vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );\n\tconst vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );\n\tvec4 r = roughness * c0 + c1;\n\tfloat a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;\n\tvec2 fab = vec2( - 1.04, 1.04 ) * a004 + r.zw;\n\treturn fab;\n}\nvec3 EnvironmentBRDF( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness ) {\n\tvec2 fab = DFGApprox( normal, viewDir, roughness );\n\treturn specularColor * fab.x + specularF90 * fab.y;\n}\nvoid computeMultiscattering( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\n\tvec2 fab = DFGApprox( normal, viewDir, roughness );\n\tvec3 FssEss = specularColor * fab.x + specularF90 * fab.y;\n\tfloat Ess = fab.x + fab.y;\n\tfloat Ems = 1.0 - Ess;\n\tvec3 Favg = specularColor + ( 1.0 - specularColor ) * 0.047619;\tvec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );\n\tsingleScatter += FssEss;\n\tmultiScatter += Fms * Ems;\n}\n#if NUM_RECT_AREA_LIGHTS > 0\n\tvoid RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\t\tvec3 normal = geometry.normal;\n\t\tvec3 viewDir = geometry.viewDir;\n\t\tvec3 position = geometry.position;\n\t\tvec3 lightPos = rectAreaLight.position;\n\t\tvec3 halfWidth = rectAreaLight.halfWidth;\n\t\tvec3 halfHeight = rectAreaLight.halfHeight;\n\t\tvec3 lightColor = rectAreaLight.color;\n\t\tfloat roughness = material.roughness;\n\t\tvec3 rectCoords[ 4 ];\n\t\trectCoords[ 0 ] = lightPos + halfWidth - halfHeight;\t\trectCoords[ 1 ] = lightPos - halfWidth - halfHeight;\n\t\trectCoords[ 2 ] = lightPos - halfWidth + halfHeight;\n\t\trectCoords[ 3 ] = lightPos + halfWidth + halfHeight;\n\t\tvec2 uv = LTC_Uv( normal, viewDir, roughness );\n\t\tvec4 t1 = texture2D( ltc_1, uv );\n\t\tvec4 t2 = texture2D( ltc_2, uv );\n\t\tmat3 mInv = mat3(\n\t\t\tvec3( t1.x, 0, t1.y ),\n\t\t\tvec3(    0, 1,    0 ),\n\t\t\tvec3( t1.z, 0, t1.w )\n\t\t);\n\t\tvec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );\n\t\treflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );\n\t\treflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );\n\t}\n#endif\nvoid RE_Direct_Physical( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\t#ifdef USE_CLEARCOAT\n\t\tfloat dotNLcc = saturate( dot( geometry.clearcoatNormal, directLight.direction ) );\n\t\tvec3 ccIrradiance = dotNLcc * directLight.color;\n\t\tclearcoatSpecular += ccIrradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.clearcoatNormal, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tsheenSpecular += irradiance * BRDF_Sheen( directLight.direction, geometry.viewDir, geometry.normal, material.sheenColor, material.sheenRoughness );\n\t#endif\n\treflectedLight.directSpecular += irradiance * BRDF_GGX( directLight.direction, geometry.viewDir, geometry.normal, material.specularColor, material.specularF90, material.roughness );\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n\t#ifdef USE_CLEARCOAT\n\t\tclearcoatSpecular += clearcoatRadiance * EnvironmentBRDF( geometry.clearcoatNormal, geometry.viewDir, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tsheenSpecular += irradiance * material.sheenColor * IBLSheenBRDF( geometry.normal, geometry.viewDir, material.sheenRoughness );\n\t#endif\n\tvec3 singleScattering = vec3( 0.0 );\n\tvec3 multiScattering = vec3( 0.0 );\n\tvec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;\n\tcomputeMultiscattering( geometry.normal, geometry.viewDir, material.specularColor, material.specularF90, material.roughness, singleScattering, multiScattering );\n\tvec3 diffuse = material.diffuseColor * ( 1.0 - ( singleScattering + multiScattering ) );\n\treflectedLight.indirectSpecular += radiance * singleScattering;\n\treflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;\n\treflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;\n}\n#define RE_Direct\t\t\t\tRE_Direct_Physical\n#define RE_Direct_RectArea\t\tRE_Direct_RectArea_Physical\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Physical\n#define RE_IndirectSpecular\t\tRE_IndirectSpecular_Physical\nfloat computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {\n\treturn saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );\n}",lights_fragment_begin:"\nGeometricContext geometry;\ngeometry.position = - vViewPosition;\ngeometry.normal = normal;\ngeometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );\n#ifdef USE_CLEARCOAT\n\tgeometry.clearcoatNormal = clearcoatNormal;\n#endif\nIncidentLight directLight;\n#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\n\tPointLight pointLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0\n\tPointLightShadow pointLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tpointLight = pointLights[ i ];\n\t\tgetPointLightInfo( pointLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )\n\t\tpointLightShadow = pointLightShadows[ i ];\n\t\tdirectLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\n\tSpotLight spotLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLightShadow spotLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tspotLight = spotLights[ i ];\n\t\tgetSpotLightInfo( spotLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n\t\tspotLightShadow = spotLightShadows[ i ];\n\t\tdirectLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )\n\tDirectionalLight directionalLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLightShadow directionalLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tdirectionalLight = directionalLights[ i ];\n\t\tgetDirectionalLightInfo( directionalLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )\n\t\tdirectionalLightShadow = directionalLightShadows[ i ];\n\t\tdirectLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )\n\tRectAreaLight rectAreaLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {\n\t\trectAreaLight = rectAreaLights[ i ];\n\t\tRE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if defined( RE_IndirectDiffuse )\n\tvec3 iblIrradiance = vec3( 0.0 );\n\tvec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\n\tirradiance += getLightProbeIrradiance( lightProbe, geometry.normal );\n\t#if ( NUM_HEMI_LIGHTS > 0 )\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\t\tirradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );\n\t\t}\n\t\t#pragma unroll_loop_end\n\t#endif\n#endif\n#if defined( RE_IndirectSpecular )\n\tvec3 radiance = vec3( 0.0 );\n\tvec3 clearcoatRadiance = vec3( 0.0 );\n#endif",lights_fragment_maps:"#if defined( RE_IndirectDiffuse )\n\t#ifdef USE_LIGHTMAP\n\t\tvec4 lightMapTexel = texture2D( lightMap, vUv2 );\n\t\tvec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tlightMapIrradiance *= PI;\n\t\t#endif\n\t\tirradiance += lightMapIrradiance;\n\t#endif\n\t#if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )\n\t\tiblIrradiance += getIBLIrradiance( geometry.normal );\n\t#endif\n#endif\n#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\n\tradiance += getIBLRadiance( geometry.viewDir, geometry.normal, material.roughness );\n\t#ifdef USE_CLEARCOAT\n\t\tclearcoatRadiance += getIBLRadiance( geometry.viewDir, geometry.clearcoatNormal, material.clearcoatRoughness );\n\t#endif\n#endif",lights_fragment_end:"#if defined( RE_IndirectDiffuse )\n\tRE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );\n#endif\n#if defined( RE_IndirectSpecular )\n\tRE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometry, material, reflectedLight );\n#endif",logdepthbuf_fragment:"#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\n\tgl_FragDepthEXT = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;\n#endif",logdepthbuf_pars_fragment:"#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\n\tuniform float logDepthBufFC;\n\tvarying float vFragDepth;\n\tvarying float vIsPerspective;\n#endif",logdepthbuf_pars_vertex:"#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvarying float vFragDepth;\n\t\tvarying float vIsPerspective;\n\t#else\n\t\tuniform float logDepthBufFC;\n\t#endif\n#endif",logdepthbuf_vertex:"#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvFragDepth = 1.0 + gl_Position.w;\n\t\tvIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );\n\t#else\n\t\tif ( isPerspectiveMatrix( projectionMatrix ) ) {\n\t\t\tgl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;\n\t\t\tgl_Position.z *= gl_Position.w;\n\t\t}\n\t#endif\n#endif",map_fragment:"#ifdef USE_MAP\n\tvec4 sampledDiffuseColor = texture2D( map, vUv );\n\t#ifdef DECODE_VIDEO_TEXTURE\n\t\tsampledDiffuseColor = vec4( mix( pow( sampledDiffuseColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), sampledDiffuseColor.rgb * 0.0773993808, vec3( lessThanEqual( sampledDiffuseColor.rgb, vec3( 0.04045 ) ) ) ), sampledDiffuseColor.w );\n\t#endif\n\tdiffuseColor *= sampledDiffuseColor;\n#endif",map_pars_fragment:"#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif",map_particle_fragment:"#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\tvec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;\n#endif\n#ifdef USE_MAP\n\tdiffuseColor *= texture2D( map, uv );\n#endif\n#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, uv ).g;\n#endif",map_particle_pars_fragment:"#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\tuniform mat3 uvTransform;\n#endif\n#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif\n#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif",metalnessmap_fragment:"float metalnessFactor = metalness;\n#ifdef USE_METALNESSMAP\n\tvec4 texelMetalness = texture2D( metalnessMap, vUv );\n\tmetalnessFactor *= texelMetalness.b;\n#endif",metalnessmap_pars_fragment:"#ifdef USE_METALNESSMAP\n\tuniform sampler2D metalnessMap;\n#endif",morphnormal_vertex:"#ifdef USE_MORPHNORMALS\n\tobjectNormal *= morphTargetBaseInfluence;\n\t#ifdef MORPHTARGETS_TEXTURE\n\t\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) objectNormal += getMorph( gl_VertexID, i, 1, 2 ) * morphTargetInfluences[ i ];\n\t\t}\n\t#else\n\t\tobjectNormal += morphNormal0 * morphTargetInfluences[ 0 ];\n\t\tobjectNormal += morphNormal1 * morphTargetInfluences[ 1 ];\n\t\tobjectNormal += morphNormal2 * morphTargetInfluences[ 2 ];\n\t\tobjectNormal += morphNormal3 * morphTargetInfluences[ 3 ];\n\t#endif\n#endif",morphtarget_pars_vertex:"#ifdef USE_MORPHTARGETS\n\tuniform float morphTargetBaseInfluence;\n\t#ifdef MORPHTARGETS_TEXTURE\n\t\tuniform float morphTargetInfluences[ MORPHTARGETS_COUNT ];\n\t\tuniform sampler2DArray morphTargetsTexture;\n\t\tuniform vec2 morphTargetsTextureSize;\n\t\tvec3 getMorph( const in int vertexIndex, const in int morphTargetIndex, const in int offset, const in int stride ) {\n\t\t\tfloat texelIndex = float( vertexIndex * stride + offset );\n\t\t\tfloat y = floor( texelIndex / morphTargetsTextureSize.x );\n\t\t\tfloat x = texelIndex - y * morphTargetsTextureSize.x;\n\t\t\tvec3 morphUV = vec3( ( x + 0.5 ) / morphTargetsTextureSize.x, y / morphTargetsTextureSize.y, morphTargetIndex );\n\t\t\treturn texture( morphTargetsTexture, morphUV ).xyz;\n\t\t}\n\t#else\n\t\t#ifndef USE_MORPHNORMALS\n\t\t\tuniform float morphTargetInfluences[ 8 ];\n\t\t#else\n\t\t\tuniform float morphTargetInfluences[ 4 ];\n\t\t#endif\n\t#endif\n#endif",morphtarget_vertex:"#ifdef USE_MORPHTARGETS\n\ttransformed *= morphTargetBaseInfluence;\n\t#ifdef MORPHTARGETS_TEXTURE\n\t\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\t\t#ifndef USE_MORPHNORMALS\n\t\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0, 1 ) * morphTargetInfluences[ i ];\n\t\t\t#else\n\t\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0, 2 ) * morphTargetInfluences[ i ];\n\t\t\t#endif\n\t\t}\n\t#else\n\t\ttransformed += morphTarget0 * morphTargetInfluences[ 0 ];\n\t\ttransformed += morphTarget1 * morphTargetInfluences[ 1 ];\n\t\ttransformed += morphTarget2 * morphTargetInfluences[ 2 ];\n\t\ttransformed += morphTarget3 * morphTargetInfluences[ 3 ];\n\t\t#ifndef USE_MORPHNORMALS\n\t\t\ttransformed += morphTarget4 * morphTargetInfluences[ 4 ];\n\t\t\ttransformed += morphTarget5 * morphTargetInfluences[ 5 ];\n\t\t\ttransformed += morphTarget6 * morphTargetInfluences[ 6 ];\n\t\t\ttransformed += morphTarget7 * morphTargetInfluences[ 7 ];\n\t\t#endif\n\t#endif\n#endif",normal_fragment_begin:"float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;\n#ifdef FLAT_SHADED\n\tvec3 fdx = vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );\n\tvec3 fdy = vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );\n\tvec3 normal = normalize( cross( fdx, fdy ) );\n#else\n\tvec3 normal = normalize( vNormal );\n\t#ifdef DOUBLE_SIDED\n\t\tnormal = normal * faceDirection;\n\t#endif\n\t#ifdef USE_TANGENT\n\t\tvec3 tangent = normalize( vTangent );\n\t\tvec3 bitangent = normalize( vBitangent );\n\t\t#ifdef DOUBLE_SIDED\n\t\t\ttangent = tangent * faceDirection;\n\t\t\tbitangent = bitangent * faceDirection;\n\t\t#endif\n\t\t#if defined( TANGENTSPACE_NORMALMAP ) || defined( USE_CLEARCOAT_NORMALMAP )\n\t\t\tmat3 vTBN = mat3( tangent, bitangent, normal );\n\t\t#endif\n\t#endif\n#endif\nvec3 geometryNormal = normal;",normal_fragment_maps:"#ifdef OBJECTSPACE_NORMALMAP\n\tnormal = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\t#ifdef FLIP_SIDED\n\t\tnormal = - normal;\n\t#endif\n\t#ifdef DOUBLE_SIDED\n\t\tnormal = normal * faceDirection;\n\t#endif\n\tnormal = normalize( normalMatrix * normal );\n#elif defined( TANGENTSPACE_NORMALMAP )\n\tvec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\tmapN.xy *= normalScale;\n\t#ifdef USE_TANGENT\n\t\tnormal = normalize( vTBN * mapN );\n\t#else\n\t\tnormal = perturbNormal2Arb( - vViewPosition, normal, mapN, faceDirection );\n\t#endif\n#elif defined( USE_BUMPMAP )\n\tnormal = perturbNormalArb( - vViewPosition, normal, dHdxy_fwd(), faceDirection );\n#endif",normal_pars_fragment:"#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif",normal_pars_vertex:"#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif",normal_vertex:"#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n\t#ifdef USE_TANGENT\n\t\tvTangent = normalize( transformedTangent );\n\t\tvBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );\n\t#endif\n#endif",normalmap_pars_fragment:"#ifdef USE_NORMALMAP\n\tuniform sampler2D normalMap;\n\tuniform vec2 normalScale;\n#endif\n#ifdef OBJECTSPACE_NORMALMAP\n\tuniform mat3 normalMatrix;\n#endif\n#if ! defined ( USE_TANGENT ) && ( defined ( TANGENTSPACE_NORMALMAP ) || defined ( USE_CLEARCOAT_NORMALMAP ) )\n\tvec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm, vec3 mapN, float faceDirection ) {\n\t\tvec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );\n\t\tvec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );\n\t\tvec2 st0 = dFdx( vUv.st );\n\t\tvec2 st1 = dFdy( vUv.st );\n\t\tvec3 N = surf_norm;\n\t\tvec3 q1perp = cross( q1, N );\n\t\tvec3 q0perp = cross( N, q0 );\n\t\tvec3 T = q1perp * st0.x + q0perp * st1.x;\n\t\tvec3 B = q1perp * st0.y + q0perp * st1.y;\n\t\tfloat det = max( dot( T, T ), dot( B, B ) );\n\t\tfloat scale = ( det == 0.0 ) ? 0.0 : faceDirection * inversesqrt( det );\n\t\treturn normalize( T * ( mapN.x * scale ) + B * ( mapN.y * scale ) + N * mapN.z );\n\t}\n#endif",clearcoat_normal_fragment_begin:"#ifdef USE_CLEARCOAT\n\tvec3 clearcoatNormal = geometryNormal;\n#endif",clearcoat_normal_fragment_maps:"#ifdef USE_CLEARCOAT_NORMALMAP\n\tvec3 clearcoatMapN = texture2D( clearcoatNormalMap, vUv ).xyz * 2.0 - 1.0;\n\tclearcoatMapN.xy *= clearcoatNormalScale;\n\t#ifdef USE_TANGENT\n\t\tclearcoatNormal = normalize( vTBN * clearcoatMapN );\n\t#else\n\t\tclearcoatNormal = perturbNormal2Arb( - vViewPosition, clearcoatNormal, clearcoatMapN, faceDirection );\n\t#endif\n#endif",clearcoat_pars_fragment:"#ifdef USE_CLEARCOATMAP\n\tuniform sampler2D clearcoatMap;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tuniform sampler2D clearcoatRoughnessMap;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tuniform sampler2D clearcoatNormalMap;\n\tuniform vec2 clearcoatNormalScale;\n#endif",output_fragment:"#ifdef OPAQUE\ndiffuseColor.a = 1.0;\n#endif\n#ifdef USE_TRANSMISSION\ndiffuseColor.a *= transmissionAlpha + 0.1;\n#endif\ngl_FragColor = vec4( outgoingLight, diffuseColor.a );",packing:"vec3 packNormalToRGB( const in vec3 normal ) {\n\treturn normalize( normal ) * 0.5 + 0.5;\n}\nvec3 unpackRGBToNormal( const in vec3 rgb ) {\n\treturn 2.0 * rgb.xyz - 1.0;\n}\nconst float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;\nconst vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );\nconst vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );\nconst float ShiftRight8 = 1. / 256.;\nvec4 packDepthToRGBA( const in float v ) {\n\tvec4 r = vec4( fract( v * PackFactors ), v );\n\tr.yzw -= r.xyz * ShiftRight8;\treturn r * PackUpscale;\n}\nfloat unpackRGBAToDepth( const in vec4 v ) {\n\treturn dot( v, UnpackFactors );\n}\nvec4 pack2HalfToRGBA( vec2 v ) {\n\tvec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ) );\n\treturn vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w );\n}\nvec2 unpackRGBATo2Half( vec4 v ) {\n\treturn vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );\n}\nfloat viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn ( viewZ + near ) / ( near - far );\n}\nfloat orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {\n\treturn linearClipZ * ( near - far ) - near;\n}\nfloat viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn ( ( near + viewZ ) * far ) / ( ( far - near ) * viewZ );\n}\nfloat perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {\n\treturn ( near * far ) / ( ( far - near ) * invClipZ - far );\n}",premultiplied_alpha_fragment:"#ifdef PREMULTIPLIED_ALPHA\n\tgl_FragColor.rgb *= gl_FragColor.a;\n#endif",project_vertex:"vec4 mvPosition = vec4( transformed, 1.0 );\n#ifdef USE_INSTANCING\n\tmvPosition = instanceMatrix * mvPosition;\n#endif\nmvPosition = modelViewMatrix * mvPosition;\ngl_Position = projectionMatrix * mvPosition;",dithering_fragment:"#ifdef DITHERING\n\tgl_FragColor.rgb = dithering( gl_FragColor.rgb );\n#endif",dithering_pars_fragment:"#ifdef DITHERING\n\tvec3 dithering( vec3 color ) {\n\t\tfloat grid_position = rand( gl_FragCoord.xy );\n\t\tvec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );\n\t\tdither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );\n\t\treturn color + dither_shift_RGB;\n\t}\n#endif",roughnessmap_fragment:"float roughnessFactor = roughness;\n#ifdef USE_ROUGHNESSMAP\n\tvec4 texelRoughness = texture2D( roughnessMap, vUv );\n\troughnessFactor *= texelRoughness.g;\n#endif",roughnessmap_pars_fragment:"#ifdef USE_ROUGHNESSMAP\n\tuniform sampler2D roughnessMap;\n#endif",shadowmap_pars_fragment:"#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tstruct DirectionalLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tstruct SpotLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tstruct PointLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t\tfloat shadowCameraNear;\n\t\t\tfloat shadowCameraFar;\n\t\t};\n\t\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n\tfloat texture2DCompare( sampler2D depths, vec2 uv, float compare ) {\n\t\treturn step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );\n\t}\n\tvec2 texture2DDistribution( sampler2D shadow, vec2 uv ) {\n\t\treturn unpackRGBATo2Half( texture2D( shadow, uv ) );\n\t}\n\tfloat VSMShadow (sampler2D shadow, vec2 uv, float compare ){\n\t\tfloat occlusion = 1.0;\n\t\tvec2 distribution = texture2DDistribution( shadow, uv );\n\t\tfloat hard_shadow = step( compare , distribution.x );\n\t\tif (hard_shadow != 1.0 ) {\n\t\t\tfloat distance = compare - distribution.x ;\n\t\t\tfloat variance = max( 0.00000, distribution.y * distribution.y );\n\t\t\tfloat softness_probability = variance / (variance + distance * distance );\t\t\tsoftness_probability = clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 );\t\t\tocclusion = clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );\n\t\t}\n\t\treturn occlusion;\n\t}\n\tfloat getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n\t\tfloat shadow = 1.0;\n\t\tshadowCoord.xyz /= shadowCoord.w;\n\t\tshadowCoord.z += shadowBias;\n\t\tbvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );\n\t\tbool inFrustum = all( inFrustumVec );\n\t\tbvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );\n\t\tbool frustumTest = all( frustumTestVec );\n\t\tif ( frustumTest ) {\n\t\t#if defined( SHADOWMAP_TYPE_PCF )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx0 = - texelSize.x * shadowRadius;\n\t\t\tfloat dy0 = - texelSize.y * shadowRadius;\n\t\t\tfloat dx1 = + texelSize.x * shadowRadius;\n\t\t\tfloat dy1 = + texelSize.y * shadowRadius;\n\t\t\tfloat dx2 = dx0 / 2.0;\n\t\t\tfloat dy2 = dy0 / 2.0;\n\t\t\tfloat dx3 = dx1 / 2.0;\n\t\t\tfloat dy3 = dy1 / 2.0;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n\t\t\t) * ( 1.0 / 17.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_PCF_SOFT )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx = texelSize.x;\n\t\t\tfloat dy = texelSize.y;\n\t\t\tvec2 uv = shadowCoord.xy;\n\t\t\tvec2 f = fract( uv * shadowMapSize + 0.5 );\n\t\t\tuv -= f * texelSize;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, uv, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + texelSize, shadowCoord.z ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),\n\t\t\t\t\t f.x ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),\n\t\t\t\t\t f.x ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t f.y ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t f.y ) +\n\t\t\t\tmix( mix( texture2DCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ), \n\t\t\t\t\t\t  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),\n\t\t\t\t\t\t  f.x ),\n\t\t\t\t\t mix( texture2DCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ), \n\t\t\t\t\t\t  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t\t  f.x ),\n\t\t\t\t\t f.y )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_VSM )\n\t\t\tshadow = VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#else\n\t\t\tshadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#endif\n\t\t}\n\t\treturn shadow;\n\t}\n\tvec2 cubeToUV( vec3 v, float texelSizeY ) {\n\t\tvec3 absV = abs( v );\n\t\tfloat scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );\n\t\tabsV *= scaleToCube;\n\t\tv *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );\n\t\tvec2 planar = v.xy;\n\t\tfloat almostATexel = 1.5 * texelSizeY;\n\t\tfloat almostOne = 1.0 - almostATexel;\n\t\tif ( absV.z >= almostOne ) {\n\t\t\tif ( v.z > 0.0 )\n\t\t\t\tplanar.x = 4.0 - v.x;\n\t\t} else if ( absV.x >= almostOne ) {\n\t\t\tfloat signX = sign( v.x );\n\t\t\tplanar.x = v.z * signX + 2.0 * signX;\n\t\t} else if ( absV.y >= almostOne ) {\n\t\t\tfloat signY = sign( v.y );\n\t\t\tplanar.x = v.x + 2.0 * signY + 2.0;\n\t\t\tplanar.y = v.z * signY - 2.0;\n\t\t}\n\t\treturn vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );\n\t}\n\tfloat getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {\n\t\tvec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );\n\t\tvec3 lightToPosition = shadowCoord.xyz;\n\t\tfloat dp = ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );\t\tdp += shadowBias;\n\t\tvec3 bd3D = normalize( lightToPosition );\n\t\t#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )\n\t\t\tvec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;\n\t\t\treturn (\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#else\n\t\t\treturn texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );\n\t\t#endif\n\t}\n#endif",shadowmap_pars_vertex:"#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tstruct DirectionalLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tuniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tstruct SpotLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tstruct PointLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t\tfloat shadowCameraNear;\n\t\t\tfloat shadowCameraFar;\n\t\t};\n\t\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n#endif",shadowmap_vertex:"#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0 || NUM_SPOT_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0\n\t\tvec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t\tvec4 shadowWorldPosition;\n\t#endif\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n#endif",shadowmask_pars_fragment:"float getShadowMask() {\n\tfloat shadow = 1.0;\n\t#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLightShadow directionalLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tdirectionalLight = directionalLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLightShadow spotLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tspotLight = spotLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\tPointLightShadow pointLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tpointLight = pointLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#endif\n\treturn shadow;\n}",skinbase_vertex:"#ifdef USE_SKINNING\n\tmat4 boneMatX = getBoneMatrix( skinIndex.x );\n\tmat4 boneMatY = getBoneMatrix( skinIndex.y );\n\tmat4 boneMatZ = getBoneMatrix( skinIndex.z );\n\tmat4 boneMatW = getBoneMatrix( skinIndex.w );\n#endif",skinning_pars_vertex:"#ifdef USE_SKINNING\n\tuniform mat4 bindMatrix;\n\tuniform mat4 bindMatrixInverse;\n\t#ifdef BONE_TEXTURE\n\t\tuniform highp sampler2D boneTexture;\n\t\tuniform int boneTextureSize;\n\t\tmat4 getBoneMatrix( const in float i ) {\n\t\t\tfloat j = i * 4.0;\n\t\t\tfloat x = mod( j, float( boneTextureSize ) );\n\t\t\tfloat y = floor( j / float( boneTextureSize ) );\n\t\t\tfloat dx = 1.0 / float( boneTextureSize );\n\t\t\tfloat dy = 1.0 / float( boneTextureSize );\n\t\t\ty = dy * ( y + 0.5 );\n\t\t\tvec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );\n\t\t\tvec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );\n\t\t\tvec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );\n\t\t\tvec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );\n\t\t\tmat4 bone = mat4( v1, v2, v3, v4 );\n\t\t\treturn bone;\n\t\t}\n\t#else\n\t\tuniform mat4 boneMatrices[ MAX_BONES ];\n\t\tmat4 getBoneMatrix( const in float i ) {\n\t\t\tmat4 bone = boneMatrices[ int(i) ];\n\t\t\treturn bone;\n\t\t}\n\t#endif\n#endif",skinning_vertex:"#ifdef USE_SKINNING\n\tvec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );\n\tvec4 skinned = vec4( 0.0 );\n\tskinned += boneMatX * skinVertex * skinWeight.x;\n\tskinned += boneMatY * skinVertex * skinWeight.y;\n\tskinned += boneMatZ * skinVertex * skinWeight.z;\n\tskinned += boneMatW * skinVertex * skinWeight.w;\n\ttransformed = ( bindMatrixInverse * skinned ).xyz;\n#endif",skinnormal_vertex:"#ifdef USE_SKINNING\n\tmat4 skinMatrix = mat4( 0.0 );\n\tskinMatrix += skinWeight.x * boneMatX;\n\tskinMatrix += skinWeight.y * boneMatY;\n\tskinMatrix += skinWeight.z * boneMatZ;\n\tskinMatrix += skinWeight.w * boneMatW;\n\tskinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;\n\tobjectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;\n\t#ifdef USE_TANGENT\n\t\tobjectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n\t#endif\n#endif",specularmap_fragment:"float specularStrength;\n#ifdef USE_SPECULARMAP\n\tvec4 texelSpecular = texture2D( specularMap, vUv );\n\tspecularStrength = texelSpecular.r;\n#else\n\tspecularStrength = 1.0;\n#endif",specularmap_pars_fragment:"#ifdef USE_SPECULARMAP\n\tuniform sampler2D specularMap;\n#endif",tonemapping_fragment:"#if defined( TONE_MAPPING )\n\tgl_FragColor.rgb = toneMapping( gl_FragColor.rgb );\n#endif",tonemapping_pars_fragment:"#ifndef saturate\n#define saturate( a ) clamp( a, 0.0, 1.0 )\n#endif\nuniform float toneMappingExposure;\nvec3 LinearToneMapping( vec3 color ) {\n\treturn toneMappingExposure * color;\n}\nvec3 ReinhardToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\treturn saturate( color / ( vec3( 1.0 ) + color ) );\n}\nvec3 OptimizedCineonToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\tcolor = max( vec3( 0.0 ), color - 0.004 );\n\treturn pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );\n}\nvec3 RRTAndODTFit( vec3 v ) {\n\tvec3 a = v * ( v + 0.0245786 ) - 0.000090537;\n\tvec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;\n\treturn a / b;\n}\nvec3 ACESFilmicToneMapping( vec3 color ) {\n\tconst mat3 ACESInputMat = mat3(\n\t\tvec3( 0.59719, 0.07600, 0.02840 ),\t\tvec3( 0.35458, 0.90834, 0.13383 ),\n\t\tvec3( 0.04823, 0.01566, 0.83777 )\n\t);\n\tconst mat3 ACESOutputMat = mat3(\n\t\tvec3(  1.60475, -0.10208, -0.00327 ),\t\tvec3( -0.53108,  1.10813, -0.07276 ),\n\t\tvec3( -0.07367, -0.00605,  1.07602 )\n\t);\n\tcolor *= toneMappingExposure / 0.6;\n\tcolor = ACESInputMat * color;\n\tcolor = RRTAndODTFit( color );\n\tcolor = ACESOutputMat * color;\n\treturn saturate( color );\n}\nvec3 CustomToneMapping( vec3 color ) { return color; }",transmission_fragment:"#ifdef USE_TRANSMISSION\n\tfloat transmissionAlpha = 1.0;\n\tfloat transmissionFactor = transmission;\n\tfloat thicknessFactor = thickness;\n\t#ifdef USE_TRANSMISSIONMAP\n\t\ttransmissionFactor *= texture2D( transmissionMap, vUv ).r;\n\t#endif\n\t#ifdef USE_THICKNESSMAP\n\t\tthicknessFactor *= texture2D( thicknessMap, vUv ).g;\n\t#endif\n\tvec3 pos = vWorldPosition;\n\tvec3 v = normalize( cameraPosition - pos );\n\tvec3 n = inverseTransformDirection( normal, viewMatrix );\n\tvec4 transmission = getIBLVolumeRefraction(\n\t\tn, v, roughnessFactor, material.diffuseColor, material.specularColor, material.specularF90,\n\t\tpos, modelMatrix, viewMatrix, projectionMatrix, ior, thicknessFactor,\n\t\tattenuationColor, attenuationDistance );\n\ttotalDiffuse = mix( totalDiffuse, transmission.rgb, transmissionFactor );\n\ttransmissionAlpha = mix( transmissionAlpha, transmission.a, transmissionFactor );\n#endif",transmission_pars_fragment:"#ifdef USE_TRANSMISSION\n\tuniform float transmission;\n\tuniform float thickness;\n\tuniform float attenuationDistance;\n\tuniform vec3 attenuationColor;\n\t#ifdef USE_TRANSMISSIONMAP\n\t\tuniform sampler2D transmissionMap;\n\t#endif\n\t#ifdef USE_THICKNESSMAP\n\t\tuniform sampler2D thicknessMap;\n\t#endif\n\tuniform vec2 transmissionSamplerSize;\n\tuniform sampler2D transmissionSamplerMap;\n\tuniform mat4 modelMatrix;\n\tuniform mat4 projectionMatrix;\n\tvarying vec3 vWorldPosition;\n\tvec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {\n\t\tvec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );\n\t\tvec3 modelScale;\n\t\tmodelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );\n\t\tmodelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );\n\t\tmodelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );\n\t\treturn normalize( refractionVector ) * thickness * modelScale;\n\t}\n\tfloat applyIorToRoughness( const in float roughness, const in float ior ) {\n\t\treturn roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );\n\t}\n\tvec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {\n\t\tfloat framebufferLod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );\n\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\treturn texture2DLodEXT( transmissionSamplerMap, fragCoord.xy, framebufferLod );\n\t\t#else\n\t\t\treturn texture2D( transmissionSamplerMap, fragCoord.xy, framebufferLod );\n\t\t#endif\n\t}\n\tvec3 applyVolumeAttenuation( const in vec3 radiance, const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {\n\t\tif ( attenuationDistance == 0.0 ) {\n\t\t\treturn radiance;\n\t\t} else {\n\t\t\tvec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;\n\t\t\tvec3 transmittance = exp( - attenuationCoefficient * transmissionDistance );\t\t\treturn transmittance * radiance;\n\t\t}\n\t}\n\tvec4 getIBLVolumeRefraction( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor,\n\t\tconst in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix,\n\t\tconst in mat4 viewMatrix, const in mat4 projMatrix, const in float ior, const in float thickness,\n\t\tconst in vec3 attenuationColor, const in float attenuationDistance ) {\n\t\tvec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );\n\t\tvec3 refractedRayExit = position + transmissionRay;\n\t\tvec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );\n\t\tvec2 refractionCoords = ndcPos.xy / ndcPos.w;\n\t\trefractionCoords += 1.0;\n\t\trefractionCoords /= 2.0;\n\t\tvec4 transmittedLight = getTransmissionSample( refractionCoords, roughness, ior );\n\t\tvec3 attenuatedColor = applyVolumeAttenuation( transmittedLight.rgb, length( transmissionRay ), attenuationColor, attenuationDistance );\n\t\tvec3 F = EnvironmentBRDF( n, v, specularColor, specularF90, roughness );\n\t\treturn vec4( ( 1.0 - F ) * attenuatedColor * diffuseColor, transmittedLight.a );\n\t}\n#endif",uv_pars_fragment:"#if ( defined( USE_UV ) && ! defined( UVS_VERTEX_ONLY ) )\n\tvarying vec2 vUv;\n#endif",uv_pars_vertex:"#ifdef USE_UV\n\t#ifdef UVS_VERTEX_ONLY\n\t\tvec2 vUv;\n\t#else\n\t\tvarying vec2 vUv;\n\t#endif\n\tuniform mat3 uvTransform;\n#endif",uv_vertex:"#ifdef USE_UV\n\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n#endif",uv2_pars_fragment:"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvarying vec2 vUv2;\n#endif",uv2_pars_vertex:"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tattribute vec2 uv2;\n\tvarying vec2 vUv2;\n\tuniform mat3 uv2Transform;\n#endif",uv2_vertex:"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvUv2 = ( uv2Transform * vec3( uv2, 1 ) ).xy;\n#endif",worldpos_vertex:"#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP ) || defined ( USE_TRANSMISSION )\n\tvec4 worldPosition = vec4( transformed, 1.0 );\n\t#ifdef USE_INSTANCING\n\t\tworldPosition = instanceMatrix * worldPosition;\n\t#endif\n\tworldPosition = modelMatrix * worldPosition;\n#endif",background_vert:"varying vec2 vUv;\nuniform mat3 uvTransform;\nvoid main() {\n\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n\tgl_Position = vec4( position.xy, 1.0, 1.0 );\n}",background_frag:"uniform sampler2D t2D;\nvarying vec2 vUv;\nvoid main() {\n\tgl_FragColor = texture2D( t2D, vUv );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}",cube_vert:"varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n\tgl_Position.z = gl_Position.w;\n}",cube_frag:"#include <envmap_common_pars_fragment>\nuniform float opacity;\nvarying vec3 vWorldDirection;\n#include <cube_uv_reflection_fragment>\nvoid main() {\n\tvec3 vReflect = vWorldDirection;\n\t#include <envmap_fragment>\n\tgl_FragColor = envColor;\n\tgl_FragColor.a *= opacity;\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}",depth_vert:"#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\t#include <uv_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvHighPrecisionZW = gl_Position.zw;\n}",depth_frag:"#if DEPTH_PACKING == 3200\n\tuniform float opacity;\n#endif\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#if DEPTH_PACKING == 3200\n\t\tdiffuseColor.a = opacity;\n\t#endif\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <logdepthbuf_fragment>\n\tfloat fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;\n\t#if DEPTH_PACKING == 3200\n\t\tgl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );\n\t#elif DEPTH_PACKING == 3201\n\t\tgl_FragColor = packDepthToRGBA( fragCoordZ );\n\t#endif\n}",distanceRGBA_vert:"#define DISTANCE\nvarying vec3 vWorldPosition;\n#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <worldpos_vertex>\n\t#include <clipping_planes_vertex>\n\tvWorldPosition = worldPosition.xyz;\n}",distanceRGBA_frag:"#define DISTANCE\nuniform vec3 referencePosition;\nuniform float nearDistance;\nuniform float farDistance;\nvarying vec3 vWorldPosition;\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main () {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\tfloat dist = length( vWorldPosition - referencePosition );\n\tdist = ( dist - nearDistance ) / ( farDistance - nearDistance );\n\tdist = saturate( dist );\n\tgl_FragColor = packDepthToRGBA( dist );\n}",equirect_vert:"varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n}",equirect_frag:"uniform sampler2D tEquirect;\nvarying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvec3 direction = normalize( vWorldDirection );\n\tvec2 sampleUV = equirectUv( direction );\n\tgl_FragColor = texture2D( tEquirect, sampleUV );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}",linedashed_vert:"uniform float scale;\nattribute float lineDistance;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\tvLineDistance = scale * lineDistance;\n\t#include <color_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}",linedashed_frag:"uniform vec3 diffuse;\nuniform float opacity;\nuniform float dashSize;\nuniform float totalSize;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tif ( mod( vLineDistance, totalSize ) > dashSize ) {\n\t\tdiscard;\n\t}\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <color_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n}",meshbasic_vert:"#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinbase_vertex>\n\t\t#include <skinnormal_vertex>\n\t\t#include <defaultnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <fog_vertex>\n}",meshbasic_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <cube_uv_reflection_fragment>\n#include <fog_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\t#ifdef USE_LIGHTMAP\n\t\tvec4 lightMapTexel= texture2D( lightMap, vUv2 );\n\t\treflectedLight.indirectDiffuse += lightMapTexel.rgb * lightMapIntensity;\n\t#else\n\t\treflectedLight.indirectDiffuse += vec3( 1.0 );\n\t#endif\n\t#include <aomap_fragment>\n\treflectedLight.indirectDiffuse *= diffuseColor.rgb;\n\tvec3 outgoingLight = reflectedLight.indirectDiffuse;\n\t#include <envmap_fragment>\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshlambert_vert:"#define LAMBERT\nvarying vec3 vLightFront;\nvarying vec3 vIndirectFront;\n#ifdef DOUBLE_SIDED\n\tvarying vec3 vLightBack;\n\tvarying vec3 vIndirectBack;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <lights_lambert_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",meshlambert_frag:"uniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\nvarying vec3 vLightFront;\nvarying vec3 vIndirectFront;\n#ifdef DOUBLE_SIDED\n\tvarying vec3 vLightBack;\n\tvarying vec3 vIndirectBack;\n#endif\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <cube_uv_reflection_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <fog_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\t#include <emissivemap_fragment>\n\t#ifdef DOUBLE_SIDED\n\t\treflectedLight.indirectDiffuse += ( gl_FrontFacing ) ? vIndirectFront : vIndirectBack;\n\t#else\n\t\treflectedLight.indirectDiffuse += vIndirectFront;\n\t#endif\n\t#include <lightmap_fragment>\n\treflectedLight.indirectDiffuse *= BRDF_Lambert( diffuseColor.rgb );\n\t#ifdef DOUBLE_SIDED\n\t\treflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;\n\t#else\n\t\treflectedLight.directDiffuse = vLightFront;\n\t#endif\n\treflectedLight.directDiffuse *= BRDF_Lambert( diffuseColor.rgb ) * getShadowMask();\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshmatcap_vert:"#define MATCAP\nvarying vec3 vViewPosition;\n#include <common>\n#include <uv_pars_vertex>\n#include <color_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n\tvViewPosition = - mvPosition.xyz;\n}",meshmatcap_frag:"#define MATCAP\nuniform vec3 diffuse;\nuniform float opacity;\nuniform sampler2D matcap;\nvarying vec3 vViewPosition;\n#include <common>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <fog_pars_fragment>\n#include <normal_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\tvec3 viewDir = normalize( vViewPosition );\n\tvec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );\n\tvec3 y = cross( viewDir, x );\n\tvec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;\n\t#ifdef USE_MATCAP\n\t\tvec4 matcapColor = texture2D( matcap, uv );\n\t#else\n\t\tvec4 matcapColor = vec4( vec3( mix( 0.2, 0.8, uv.y ) ), 1.0 );\n\t#endif\n\tvec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshnormal_vert:"#define NORMAL\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvViewPosition = - mvPosition.xyz;\n#endif\n}",meshnormal_frag:"#define NORMAL\nuniform float opacity;\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#include <packing>\n#include <uv_pars_fragment>\n#include <normal_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\t#include <logdepthbuf_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\tgl_FragColor = vec4( packNormalToRGB( normal ), opacity );\n}",meshphong_vert:"#define PHONG\nvarying vec3 vViewPosition;\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",meshphong_frag:"#define PHONG\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform vec3 specular;\nuniform float shininess;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <cube_uv_reflection_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_phong_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_phong_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshphysical_vert:"#define STANDARD\nvarying vec3 vViewPosition;\n#ifdef USE_TRANSMISSION\n\tvarying vec3 vWorldPosition;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n#ifdef USE_TRANSMISSION\n\tvWorldPosition = worldPosition.xyz;\n#endif\n}",meshphysical_frag:"#define STANDARD\n#ifdef PHYSICAL\n\t#define IOR\n\t#define SPECULAR\n#endif\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float roughness;\nuniform float metalness;\nuniform float opacity;\n#ifdef IOR\n\tuniform float ior;\n#endif\n#ifdef SPECULAR\n\tuniform float specularIntensity;\n\tuniform vec3 specularColor;\n\t#ifdef USE_SPECULARINTENSITYMAP\n\t\tuniform sampler2D specularIntensityMap;\n\t#endif\n\t#ifdef USE_SPECULARCOLORMAP\n\t\tuniform sampler2D specularColorMap;\n\t#endif\n#endif\n#ifdef USE_CLEARCOAT\n\tuniform float clearcoat;\n\tuniform float clearcoatRoughness;\n#endif\n#ifdef USE_SHEEN\n\tuniform vec3 sheenColor;\n\tuniform float sheenRoughness;\n\t#ifdef USE_SHEENCOLORMAP\n\t\tuniform sampler2D sheenColorMap;\n\t#endif\n\t#ifdef USE_SHEENROUGHNESSMAP\n\t\tuniform sampler2D sheenRoughnessMap;\n\t#endif\n#endif\nvarying vec3 vViewPosition;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <bsdfs>\n#include <cube_uv_reflection_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_physical_pars_fragment>\n#include <fog_pars_fragment>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_physical_pars_fragment>\n#include <transmission_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <clearcoat_pars_fragment>\n#include <roughnessmap_pars_fragment>\n#include <metalnessmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <roughnessmap_fragment>\n\t#include <metalnessmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <clearcoat_normal_fragment_begin>\n\t#include <clearcoat_normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_physical_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;\n\tvec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;\n\t#include <transmission_fragment>\n\tvec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;\n\t#ifdef USE_SHEEN\n\t\tfloat sheenEnergyComp = 1.0 - 0.157 * max3( material.sheenColor );\n\t\toutgoingLight = outgoingLight * sheenEnergyComp + sheenSpecular;\n\t#endif\n\t#ifdef USE_CLEARCOAT\n\t\tfloat dotNVcc = saturate( dot( geometry.clearcoatNormal, geometry.viewDir ) );\n\t\tvec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );\n\t\toutgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + clearcoatSpecular * material.clearcoat;\n\t#endif\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshtoon_vert:"#define TOON\nvarying vec3 vViewPosition;\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",meshtoon_frag:"#define TOON\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <gradientmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_toon_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_toon_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",points_vert:"uniform float size;\nuniform float scale;\n#include <common>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <color_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <project_vertex>\n\tgl_PointSize = size;\n\t#ifdef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );\n\t#endif\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <fog_vertex>\n}",points_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <color_pars_fragment>\n#include <map_particle_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_particle_fragment>\n\t#include <color_fragment>\n\t#include <alphatest_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n}",shadow_vert:"#include <common>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\nvoid main() {\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",shadow_frag:"uniform vec3 color;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\nvoid main() {\n\tgl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}",sprite_vert:"uniform float rotation;\nuniform vec2 center;\n#include <common>\n#include <uv_pars_vertex>\n#include <fog_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\tvec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );\n\tvec2 scale;\n\tscale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );\n\tscale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );\n\t#ifndef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) scale *= - mvPosition.z;\n\t#endif\n\tvec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;\n\tvec2 rotatedPosition;\n\trotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;\n\trotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;\n\tmvPosition.xy += rotatedPosition;\n\tgl_Position = projectionMatrix * mvPosition;\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}",sprite_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\t#include <output_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}"},Bt={common:{diffuse:{value:new vn(16777215)},opacity:{value:1},map:{value:null},uvTransform:{value:new Jo},uv2Transform:{value:new Jo},alphaMap:{value:null},alphaTest:{value:0}},specularmap:{specularMap:{value:null}},envmap:{envMap:{value:null},flipEnvMap:{value:-1},reflectivity:{value:1},ior:{value:1.5},refractionRatio:{value:.98}},aomap:{aoMap:{value:null},aoMapIntensity:{value:1}},lightmap:{lightMap:{value:null},lightMapIntensity:{value:1}},emissivemap:{emissiveMap:{value:null}},bumpmap:{bumpMap:{value:null},bumpScale:{value:1}},normalmap:{normalMap:{value:null},normalScale:{value:new at(1,1)}},displacementmap:{displacementMap:{value:null},displacementScale:{value:1},displacementBias:{value:0}},roughnessmap:{roughnessMap:{value:null}},metalnessmap:{metalnessMap:{value:null}},gradientmap:{gradientMap:{value:null}},fog:{fogDensity:{value:25e-5},fogNear:{value:1},fogFar:{value:2e3},fogColor:{value:new vn(16777215)}},lights:{ambientLightColor:{value:[]},lightProbe:{value:[]},directionalLights:{value:[],properties:{direction:{},color:{}}},directionalLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},directionalShadowMap:{value:[]},directionalShadowMatrix:{value:[]},spotLights:{value:[],properties:{color:{},position:{},direction:{},distance:{},coneCos:{},penumbraCos:{},decay:{}}},spotLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},spotShadowMap:{value:[]},spotShadowMatrix:{value:[]},pointLights:{value:[],properties:{color:{},position:{},decay:{},distance:{}}},pointLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{},shadowCameraNear:{},shadowCameraFar:{}}},pointShadowMap:{value:[]},pointShadowMatrix:{value:[]},hemisphereLights:{value:[],properties:{direction:{},skyColor:{},groundColor:{}}},rectAreaLights:{value:[],properties:{color:{},position:{},width:{},height:{}}},ltc_1:{value:null},ltc_2:{value:null}},points:{diffuse:{value:new vn(16777215)},opacity:{value:1},size:{value:1},scale:{value:1},map:{value:null},alphaMap:{value:null},alphaTest:{value:0},uvTransform:{value:new Jo}},sprite:{diffuse:{value:new vn(16777215)},opacity:{value:1},center:{value:new at(.5,.5)},rotation:{value:0},map:{value:null},alphaMap:{value:null},alphaTest:{value:0},uvTransform:{value:new Jo}}},Sd={basic:{uniforms:js([Bt.common,Bt.specularmap,Bt.envmap,Bt.aomap,Bt.lightmap,Bt.fog]),vertexShader:Di.meshbasic_vert,fragmentShader:Di.meshbasic_frag},lambert:{uniforms:js([Bt.common,Bt.specularmap,Bt.envmap,Bt.aomap,Bt.lightmap,Bt.emissivemap,Bt.fog,Bt.lights,{emissive:{value:new vn(0)}}]),vertexShader:Di.meshlambert_vert,fragmentShader:Di.meshlambert_frag},phong:{uniforms:js([Bt.common,Bt.specularmap,Bt.envmap,Bt.aomap,Bt.lightmap,Bt.emissivemap,Bt.bumpmap,Bt.normalmap,Bt.displacementmap,Bt.fog,Bt.lights,{emissive:{value:new vn(0)},specular:{value:new vn(1118481)},shininess:{value:30}}]),vertexShader:Di.meshphong_vert,fragmentShader:Di.meshphong_frag},standard:{uniforms:js([Bt.common,Bt.envmap,Bt.aomap,Bt.lightmap,Bt.emissivemap,Bt.bumpmap,Bt.normalmap,Bt.displacementmap,Bt.roughnessmap,Bt.metalnessmap,Bt.fog,Bt.lights,{emissive:{value:new vn(0)},roughness:{value:1},metalness:{value:0},envMapIntensity:{value:1}}]),vertexShader:Di.meshphysical_vert,fragmentShader:Di.meshphysical_frag},toon:{uniforms:js([Bt.common,Bt.aomap,Bt.lightmap,Bt.emissivemap,Bt.bumpmap,Bt.normalmap,Bt.displacementmap,Bt.gradientmap,Bt.fog,Bt.lights,{emissive:{value:new vn(0)}}]),vertexShader:Di.meshtoon_vert,fragmentShader:Di.meshtoon_frag},matcap:{uniforms:js([Bt.common,Bt.bumpmap,Bt.normalmap,Bt.displacementmap,Bt.fog,{matcap:{value:null}}]),vertexShader:Di.meshmatcap_vert,fragmentShader:Di.meshmatcap_frag},points:{uniforms:js([Bt.points,Bt.fog]),vertexShader:Di.points_vert,fragmentShader:Di.points_frag},dashed:{uniforms:js([Bt.common,Bt.fog,{scale:{value:1},dashSize:{value:1},totalSize:{value:2}}]),vertexShader:Di.linedashed_vert,fragmentShader:Di.linedashed_frag},depth:{uniforms:js([Bt.common,Bt.displacementmap]),vertexShader:Di.depth_vert,fragmentShader:Di.depth_frag},normal:{uniforms:js([Bt.common,Bt.bumpmap,Bt.normalmap,Bt.displacementmap,{opacity:{value:1}}]),vertexShader:Di.meshnormal_vert,fragmentShader:Di.meshnormal_frag},sprite:{uniforms:js([Bt.sprite,Bt.fog]),vertexShader:Di.sprite_vert,fragmentShader:Di.sprite_frag},background:{uniforms:{uvTransform:{value:new Jo},t2D:{value:null}},vertexShader:Di.background_vert,fragmentShader:Di.background_frag},cube:{uniforms:js([Bt.envmap,{opacity:{value:1}}]),vertexShader:Di.cube_vert,fragmentShader:Di.cube_frag},equirect:{uniforms:{tEquirect:{value:null}},vertexShader:Di.equirect_vert,fragmentShader:Di.equirect_frag},distanceRGBA:{uniforms:js([Bt.common,Bt.displacementmap,{referencePosition:{value:new ie},nearDistance:{value:1},farDistance:{value:1e3}}]),vertexShader:Di.distanceRGBA_vert,fragmentShader:Di.distanceRGBA_frag},shadow:{uniforms:js([Bt.lights,Bt.fog,{color:{value:new vn(0)},opacity:{value:1}}]),vertexShader:Di.shadow_vert,fragmentShader:Di.shadow_frag}};function IWe(n,t,e,i,r,o){let l,c,s=new vn(0),a=!0===r?0:1,u=null,d=0,p=null;function f(m,x){e.buffers.color.setClear(m.r,m.g,m.b,x,o)}return{getClearColor:function(){return s},setClearColor:function(m,x=1){s.set(m),a=x,f(s,a)},getClearAlpha:function(){return a},setClearAlpha:function(m){a=m,f(s,a)},render:function(m,x){let g=!1,b=!0===x.isScene?x.background:null;b&&b.isTexture&&(b=t.get(b));let D=n.xr,T=D.getSession&&D.getSession();T&&"additive"===T.environmentBlendMode&&(b=null),null===b?f(s,a):b&&b.isColor&&(f(b,1),g=!0),(n.autoClear||g)&&n.clear(n.autoClearColor,n.autoClearDepth,n.autoClearStencil),b&&(b.isCubeTexture||306===b.mapping)?(void 0===c&&(c=new Vo(new Wg(1,1,1),new Dp({name:"BackgroundCubeMaterial",uniforms:fb(Sd.cube.uniforms),vertexShader:Sd.cube.vertexShader,fragmentShader:Sd.cube.fragmentShader,side:1,depthTest:!1,depthWrite:!1,fog:!1})),c.geometry.deleteAttribute("normal"),c.geometry.deleteAttribute("uv"),c.onBeforeRender=function(k,Z,z){this.matrixWorld.copyPosition(z.matrixWorld)},Object.defineProperty(c.material,"envMap",{get:function(){return this.uniforms.envMap.value}}),i.update(c)),c.material.uniforms.envMap.value=b,c.material.uniforms.flipEnvMap.value=b.isCubeTexture&&!1===b.isRenderTargetTexture?-1:1,(u!==b||d!==b.version||p!==n.toneMapping)&&(c.material.needsUpdate=!0,u=b,d=b.version,p=n.toneMapping),m.unshift(c,c.geometry,c.material,0,0,null)):b&&b.isTexture&&(void 0===l&&(l=new Vo(new ZS(2,2),new Dp({name:"BackgroundMaterial",uniforms:fb(Sd.background.uniforms),vertexShader:Sd.background.vertexShader,fragmentShader:Sd.background.fragmentShader,side:0,depthTest:!1,depthWrite:!1,fog:!1})),l.geometry.deleteAttribute("normal"),Object.defineProperty(l.material,"map",{get:function(){return this.uniforms.t2D.value}}),i.update(l)),l.material.uniforms.t2D.value=b,!0===b.matrixAutoUpdate&&b.updateMatrix(),l.material.uniforms.uvTransform.value.copy(b.matrix),(u!==b||d!==b.version||p!==n.toneMapping)&&(l.material.needsUpdate=!0,u=b,d=b.version,p=n.toneMapping),m.unshift(l,l.geometry,l.material,0,0,null))}}}function PWe(n,t,e,i){let r=n.getParameter(34921),o=i.isWebGL2?null:t.get("OES_vertex_array_object"),s=i.isWebGL2||null!==o,a={},l=m(null),c=l;function p(q){return i.isWebGL2?n.bindVertexArray(q):o.bindVertexArrayOES(q)}function h(q){return i.isWebGL2?n.deleteVertexArray(q):o.deleteVertexArrayOES(q)}function m(q){let K=[],de=[],Y=[];for(let ae=0;ae<r;ae++)K[ae]=0,de[ae]=0,Y[ae]=0;return{geometry:null,program:null,wireframe:!1,newAttributes:K,enabledAttributes:de,attributeDivisors:Y,object:q,attributes:{},index:null}}function b(){let q=c.newAttributes;for(let K=0,de=q.length;K<de;K++)q[K]=0}function D(q){T(q,0)}function T(q,K){let Y=c.enabledAttributes,ae=c.attributeDivisors;c.newAttributes[q]=1,0===Y[q]&&(n.enableVertexAttribArray(q),Y[q]=1),ae[q]!==K&&((i.isWebGL2?n:t.get("ANGLE_instanced_arrays"))[i.isWebGL2?"vertexAttribDivisor":"vertexAttribDivisorANGLE"](q,K),ae[q]=K)}function k(){let q=c.newAttributes,K=c.enabledAttributes;for(let de=0,Y=K.length;de<Y;de++)K[de]!==q[de]&&(n.disableVertexAttribArray(de),K[de]=0)}function Z(q,K,de,Y,ae,le){!0!==i.isWebGL2||5124!==de&&5125!==de?n.vertexAttribPointer(q,K,de,Y,ae,le):n.vertexAttribIPointer(q,K,de,ae,le)}function w(){F(),c!==l&&(c=l,p(c.object))}function F(){l.geometry=null,l.program=null,l.wireframe=!1}return{setup:function(q,K,de,Y,ae){let le=!1;if(s){let Ie=function(q,K,de){let Y=!0===de.wireframe,ae=a[q.id];void 0===ae&&(ae={},a[q.id]=ae);let le=ae[K.id];void 0===le&&(le={},ae[K.id]=le);let Ie=le[Y];return void 0===Ie&&(Ie=m(i.isWebGL2?n.createVertexArray():o.createVertexArrayOES()),le[Y]=Ie),Ie}(Y,de,K);c!==Ie&&(c=Ie,p(c.object)),le=function(q,K){let de=c.attributes,Y=q.attributes,ae=0;for(let le in Y){let Ie=de[le],ve=Y[le];if(void 0===Ie||Ie.attribute!==ve||Ie.data!==ve.data)return!0;ae++}return c.attributesNum!==ae||c.index!==K}(Y,ae),le&&function(q,K){let de={},Y=q.attributes,ae=0;for(let le in Y){let Ie=Y[le],ve={};ve.attribute=Ie,Ie.data&&(ve.data=Ie.data),de[le]=ve,ae++}c.attributes=de,c.attributesNum=ae,c.index=K}(Y,ae)}else{let Ie=!0===K.wireframe;(c.geometry!==Y.id||c.program!==de.id||c.wireframe!==Ie)&&(c.geometry=Y.id,c.program=de.id,c.wireframe=Ie,le=!0)}!0===q.isInstancedMesh&&(le=!0),null!==ae&&e.update(ae,34963),le&&(function(q,K,de,Y){if(!1===i.isWebGL2&&(q.isInstancedMesh||Y.isInstancedBufferGeometry)&&null===t.get("ANGLE_instanced_arrays"))return;b();let ae=Y.attributes,le=de.getAttributes(),Ie=K.defaultAttributeValues;for(let ve in le){let De=le[ve];if(De.location>=0){let nt=ae[ve];if(void 0===nt&&("instanceMatrix"===ve&&q.instanceMatrix&&(nt=q.instanceMatrix),"instanceColor"===ve&&q.instanceColor&&(nt=q.instanceColor)),void 0!==nt){let gt=nt.normalized,Ue=nt.itemSize,Ae=e.get(nt);if(void 0===Ae)continue;let tn=Ae.buffer,pt=Ae.type,wt=Ae.bytesPerElement;if(nt.isInterleavedBufferAttribute){let Te=nt.data,xt=Te.stride,mt=nt.offset;if(Te&&Te.isInstancedInterleavedBuffer){for(let ce=0;ce<De.locationSize;ce++)T(De.location+ce,Te.meshPerAttribute);!0!==q.isInstancedMesh&&void 0===Y._maxInstanceCount&&(Y._maxInstanceCount=Te.meshPerAttribute*Te.count)}else for(let ce=0;ce<De.locationSize;ce++)D(De.location+ce);n.bindBuffer(34962,tn);for(let ce=0;ce<De.locationSize;ce++)Z(De.location+ce,Ue/De.locationSize,pt,gt,xt*wt,(mt+Ue/De.locationSize*ce)*wt)}else{if(nt.isInstancedBufferAttribute){for(let Te=0;Te<De.locationSize;Te++)T(De.location+Te,nt.meshPerAttribute);!0!==q.isInstancedMesh&&void 0===Y._maxInstanceCount&&(Y._maxInstanceCount=nt.meshPerAttribute*nt.count)}else for(let Te=0;Te<De.locationSize;Te++)D(De.location+Te);n.bindBuffer(34962,tn);for(let Te=0;Te<De.locationSize;Te++)Z(De.location+Te,Ue/De.locationSize,pt,gt,Ue*wt,Ue/De.locationSize*Te*wt)}}else if(void 0!==Ie){let gt=Ie[ve];if(void 0!==gt)switch(gt.length){case 2:n.vertexAttrib2fv(De.location,gt);break;case 3:n.vertexAttrib3fv(De.location,gt);break;case 4:n.vertexAttrib4fv(De.location,gt);break;default:n.vertexAttrib1fv(De.location,gt)}}}}k()}(q,K,de,Y),null!==ae&&n.bindBuffer(34963,e.get(ae).buffer))},reset:w,resetDefaultState:F,dispose:function(){w();for(let q in a){let K=a[q];for(let de in K){let Y=K[de];for(let ae in Y)h(Y[ae].object),delete Y[ae];delete K[de]}delete a[q]}},releaseStatesOfGeometry:function(q){if(void 0===a[q.id])return;let K=a[q.id];for(let de in K){let Y=K[de];for(let ae in Y)h(Y[ae].object),delete Y[ae];delete K[de]}delete a[q.id]},releaseStatesOfProgram:function(q){for(let K in a){let de=a[K];if(void 0===de[q.id])continue;let Y=de[q.id];for(let ae in Y)h(Y[ae].object),delete Y[ae];delete de[q.id]}},initAttributes:b,enableAttribute:D,disableUnusedAttributes:k}}function RWe(n,t,e,i){let o,r=i.isWebGL2;this.setMode=function(c){o=c},this.render=function(c,u){n.drawArrays(o,c,u),e.update(u,o,1)},this.renderInstances=function(c,u,d){if(0===d)return;let p,h;if(r)p=n,h="drawArraysInstanced";else if(p=t.get("ANGLE_instanced_arrays"),h="drawArraysInstancedANGLE",null===p)return void console.error("THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");p[h](o,c,u,d),e.update(u,o,d)}}function OWe(n,t,e){let i;function o(z){if("highp"===z){if(n.getShaderPrecisionFormat(35633,36338).precision>0&&n.getShaderPrecisionFormat(35632,36338).precision>0)return"highp";z="mediump"}return"mediump"===z&&n.getShaderPrecisionFormat(35633,36337).precision>0&&n.getShaderPrecisionFormat(35632,36337).precision>0?"mediump":"lowp"}let s=typeof WebGL2RenderingContext<"u"&&n instanceof WebGL2RenderingContext||typeof WebGL2ComputeRenderingContext<"u"&&n instanceof WebGL2ComputeRenderingContext,a=void 0!==e.precision?e.precision:"highp",l=o(a);l!==a&&(console.warn("THREE.WebGLRenderer:",a,"not supported, using",l,"instead."),a=l);let c=s||t.has("WEBGL_draw_buffers"),u=!0===e.logarithmicDepthBuffer,d=n.getParameter(34930),p=n.getParameter(35660),h=n.getParameter(3379),f=n.getParameter(34076),m=n.getParameter(34921),x=n.getParameter(36347),g=n.getParameter(36348),b=n.getParameter(36349),D=p>0,T=s||t.has("OES_texture_float");return{isWebGL2:s,drawBuffers:c,getMaxAnisotropy:function(){if(void 0!==i)return i;if(!0===t.has("EXT_texture_filter_anisotropic")){let z=t.get("EXT_texture_filter_anisotropic");i=n.getParameter(z.MAX_TEXTURE_MAX_ANISOTROPY_EXT)}else i=0;return i},getMaxPrecision:o,precision:a,logarithmicDepthBuffer:u,maxTextures:d,maxVertexTextures:p,maxTextureSize:h,maxCubemapSize:f,maxAttributes:m,maxVertexUniforms:x,maxVaryings:g,maxFragmentUniforms:b,vertexTextures:D,floatFragmentTextures:T,floatVertexTextures:D&&T,maxSamples:s?n.getParameter(36183):0}}function kWe(n){let t=this,e=null,i=0,r=!1,o=!1,s=new uu,a=new Jo,l={value:null,needsUpdate:!1};function c(){l.value!==e&&(l.value=e,l.needsUpdate=i>0),t.numPlanes=i,t.numIntersection=0}function u(d,p,h,f){let m=null!==d?d.length:0,x=null;if(0!==m){if(x=l.value,!0!==f||null===x){let g=h+4*m,b=p.matrixWorldInverse;a.getNormalMatrix(b),(null===x||x.length<g)&&(x=new Float32Array(g));for(let D=0,T=h;D!==m;++D,T+=4)s.copy(d[D]).applyMatrix4(b,a),s.normal.toArray(x,T),x[T+3]=s.constant}l.value=x,l.needsUpdate=!0}return t.numPlanes=m,t.numIntersection=0,x}this.uniform=l,this.numPlanes=0,this.numIntersection=0,this.init=function(d,p,h){let f=0!==d.length||p||0!==i||r;return r=p,e=u(d,h,0),i=d.length,f},this.beginShadows=function(){o=!0,u(null)},this.endShadows=function(){o=!1,c()},this.setState=function(d,p,h){let f=d.clippingPlanes,m=d.clipIntersection,x=d.clipShadows,g=n.get(d);if(!r||null===f||0===f.length||o&&!x)o?u(null):c();else{let b=o?0:i,D=4*b,T=g.clippingState||null;l.value=T,T=u(f,p,D,h);for(let k=0;k!==D;++k)T[k]=e[k];g.clippingState=T,this.numIntersection=m?this.numPlanes:0,this.numPlanes+=b}}}function FWe(n){let t=new WeakMap;function e(s,a){return 303===a?s.mapping=301:304===a&&(s.mapping=302),s}function r(s){let a=s.target;a.removeEventListener("dispose",r);let l=t.get(a);void 0!==l&&(t.delete(a),l.dispose())}return{get:function(s){if(s&&s.isTexture&&!1===s.isRenderTargetTexture){let a=s.mapping;if(303===a||304===a){if(t.has(s))return e(t.get(s).texture,s.mapping);{let l=s.image;if(l&&l.height>0){let c=new ck(l.height/2);return c.fromEquirectangularTexture(n,s),t.set(s,c),s.addEventListener("dispose",r),e(c.texture,s.mapping)}return null}}}return s},dispose:function(){t=new WeakMap}}}Sd.physical={uniforms:js([Sd.standard.uniforms,{clearcoat:{value:0},clearcoatMap:{value:null},clearcoatRoughness:{value:0},clearcoatRoughnessMap:{value:null},clearcoatNormalScale:{value:new at(1,1)},clearcoatNormalMap:{value:null},sheen:{value:0},sheenColor:{value:new vn(0)},sheenColorMap:{value:null},sheenRoughness:{value:1},sheenRoughnessMap:{value:null},transmission:{value:0},transmissionMap:{value:null},transmissionSamplerSize:{value:new at},transmissionSamplerMap:{value:null},thickness:{value:0},thicknessMap:{value:null},attenuationDistance:{value:0},attenuationColor:{value:new vn(0)},specularIntensity:{value:1},specularIntensityMap:{value:null},specularColor:{value:new vn(1,1,1)},specularColorMap:{value:null}}]),vertexShader:Di.meshphysical_vert,fragmentShader:Di.meshphysical_frag};var qg=class extends QS{constructor(t=-1,e=1,i=1,r=-1,o=.1,s=2e3){super(),this.type="OrthographicCamera",this.zoom=1,this.view=null,this.left=t,this.right=e,this.top=i,this.bottom=r,this.near=o,this.far=s,this.updateProjectionMatrix()}copy(t,e){return super.copy(t,e),this.left=t.left,this.right=t.right,this.top=t.top,this.bottom=t.bottom,this.near=t.near,this.far=t.far,this.zoom=t.zoom,this.view=null===t.view?null:Object.assign({},t.view),this}setViewOffset(t,e,i,r,o,s){null===this.view&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=e,this.view.offsetX=i,this.view.offsetY=r,this.view.width=o,this.view.height=s,this.updateProjectionMatrix()}clearViewOffset(){null!==this.view&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){let t=(this.right-this.left)/(2*this.zoom),e=(this.top-this.bottom)/(2*this.zoom),i=(this.right+this.left)/2,r=(this.top+this.bottom)/2,o=i-t,s=i+t,a=r+e,l=r-e;if(null!==this.view&&this.view.enabled){let c=(this.right-this.left)/this.view.fullWidth/this.zoom,u=(this.top-this.bottom)/this.view.fullHeight/this.zoom;o+=c*this.view.offsetX,s=o+c*this.view.width,a-=u*this.view.offsetY,l=a-u*this.view.height}this.projectionMatrix.makeOrthographic(o,s,a,l,this.near,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(t){let e=super.toJSON(t);return e.object.zoom=this.zoom,e.object.left=this.left,e.object.right=this.right,e.object.top=this.top,e.object.bottom=this.bottom,e.object.near=this.near,e.object.far=this.far,null!==this.view&&(e.object.view=Object.assign({},this.view)),e}};qg.prototype.isOrthographicCamera=!0;var _b=class extends Dp{constructor(t){super(t),this.type="RawShaderMaterial"}};_b.prototype.isRawShaderMaterial=!0;var wd=Math.pow(2,8),Fde=[.125,.215,.35,.446,.526,.582],Nde=5+Fde.length,Zj=new qg,{_lodPlanes:RS,_sizeLods:kue,_sigmas:HO}=NWe(),Fue=new vn,Jj=null,Hg=(1+Math.sqrt(5))/2,$y=1/Hg,Nue=[new ie(1,1,1),new ie(-1,1,1),new ie(1,1,-1),new ie(-1,1,-1),new ie(0,Hg,$y),new ie(0,Hg,-$y),new ie($y,0,Hg),new ie(-$y,0,Hg),new ie(Hg,$y,0),new ie(-Hg,$y,0)],uk=class{constructor(t){this._renderer=t,this._pingPongRenderTarget=null,this._blurMaterial=function(n){let t=new Float32Array(20),e=new ie(0,1,0);return new _b({name:"SphericalGaussianBlur",defines:{n:20},uniforms:{envMap:{value:null},samples:{value:1},weights:{value:t},latitudinal:{value:!1},dTheta:{value:0},mipInt:{value:0},poleAxis:{value:e}},vertexShader:"\n\n\t\tprecision mediump float;\n\t\tprecision mediump int;\n\n\t\tattribute vec3 position;\n\t\tattribute vec2 uv;\n\t\tattribute float faceIndex;\n\n\t\tvarying vec3 vOutputDirection;\n\n\t\t// RH coordinate system; PMREM face-indexing convention\n\t\tvec3 getDirection( vec2 uv, float face ) {\n\n\t\t\tuv = 2.0 * uv - 1.0;\n\n\t\t\tvec3 direction = vec3( uv, 1.0 );\n\n\t\t\tif ( face == 0.0 ) {\n\n\t\t\t\tdirection = direction.zyx; // ( 1, v, u ) pos x\n\n\t\t\t} else if ( face == 1.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xz *= -1.0; // ( -u, 1, -v ) pos y\n\n\t\t\t} else if ( face == 2.0 ) {\n\n\t\t\t\tdirection.x *= -1.0; // ( -u, v, 1 ) pos z\n\n\t\t\t} else if ( face == 3.0 ) {\n\n\t\t\t\tdirection = direction.zyx;\n\t\t\t\tdirection.xz *= -1.0; // ( -1, v, -u ) neg x\n\n\t\t\t} else if ( face == 4.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xy *= -1.0; // ( -u, -1, v ) neg y\n\n\t\t\t} else if ( face == 5.0 ) {\n\n\t\t\t\tdirection.z *= -1.0; // ( u, v, -1 ) neg z\n\n\t\t\t}\n\n\t\t\treturn direction;\n\n\t\t}\n\n\t\tvoid main() {\n\n\t\t\tvOutputDirection = getDirection( uv, faceIndex );\n\t\t\tgl_Position = vec4( position, 1.0 );\n\n\t\t}\n\t",fragmentShader:"\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform sampler2D envMap;\n\t\t\tuniform int samples;\n\t\t\tuniform float weights[ n ];\n\t\t\tuniform bool latitudinal;\n\t\t\tuniform float dTheta;\n\t\t\tuniform float mipInt;\n\t\t\tuniform vec3 poleAxis;\n\n\t\t\t#define ENVMAP_TYPE_CUBE_UV\n\t\t\t#include <cube_uv_reflection_fragment>\n\n\t\t\tvec3 getSample( float theta, vec3 axis ) {\n\n\t\t\t\tfloat cosTheta = cos( theta );\n\t\t\t\t// Rodrigues' axis-angle rotation\n\t\t\t\tvec3 sampleDirection = vOutputDirection * cosTheta\n\t\t\t\t\t+ cross( axis, vOutputDirection ) * sin( theta )\n\t\t\t\t\t+ axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );\n\n\t\t\t\treturn bilinearCubeUV( envMap, sampleDirection, mipInt );\n\n\t\t\t}\n\n\t\t\tvoid main() {\n\n\t\t\t\tvec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );\n\n\t\t\t\tif ( all( equal( axis, vec3( 0.0 ) ) ) ) {\n\n\t\t\t\t\taxis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );\n\n\t\t\t\t}\n\n\t\t\t\taxis = normalize( axis );\n\n\t\t\t\tgl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n\t\t\t\tgl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );\n\n\t\t\t\tfor ( int i = 1; i < n; i++ ) {\n\n\t\t\t\t\tif ( i >= samples ) {\n\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tfloat theta = dTheta * float( i );\n\t\t\t\t\tgl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );\n\t\t\t\t\tgl_FragColor.rgb += weights[ i ] * getSample( theta, axis );\n\n\t\t\t\t}\n\n\t\t\t}\n\t\t",blending:0,depthTest:!1,depthWrite:!1})}(),this._equirectShader=null,this._cubemapShader=null,this._compileMaterial(this._blurMaterial)}fromScene(t,e=0,i=.1,r=100){Jj=this._renderer.getRenderTarget();let o=this._allocateTargets();return this._sceneToCubeUV(t,i,r,o),e>0&&this._blur(o,0,0,e),this._applyPMREM(o),this._cleanup(o),o}fromEquirectangular(t,e=null){return this._fromTexture(t,e)}fromCubemap(t,e=null){return this._fromTexture(t,e)}compileCubemapShader(){null===this._cubemapShader&&(this._cubemapShader=Vue(),this._compileMaterial(this._cubemapShader))}compileEquirectangularShader(){null===this._equirectShader&&(this._equirectShader=Bue(),this._compileMaterial(this._equirectShader))}dispose(){this._blurMaterial.dispose(),null!==this._pingPongRenderTarget&&this._pingPongRenderTarget.dispose(),null!==this._cubemapShader&&this._cubemapShader.dispose(),null!==this._equirectShader&&this._equirectShader.dispose();for(let t=0;t<RS.length;t++)RS[t].dispose()}_cleanup(t){this._renderer.setRenderTarget(Jj),t.scissorTest=!1,UO(t,0,0,t.width,t.height)}_fromTexture(t,e){Jj=this._renderer.getRenderTarget();let i=e||this._allocateTargets(t);return this._textureToCubeUV(t,i),this._applyPMREM(i),this._cleanup(i),i}_allocateTargets(t){let e={magFilter:Gs,minFilter:Gs,generateMipmaps:!1,type:lb,format:ga,encoding:bf,depthBuffer:!1},i=Lue(e);return i.depthBuffer=!t,null===this._pingPongRenderTarget&&(this._pingPongRenderTarget=Lue(e)),i}_compileMaterial(t){let e=new Vo(RS[0],t);this._renderer.compile(e,Zj)}_sceneToCubeUV(t,e,i,r){let a=new Ws(90,1,e,i),l=[1,-1,1,1,1,1],c=[1,1,1,-1,-1,-1],u=this._renderer,d=u.autoClear,p=u.toneMapping;u.getClearColor(Fue),u.toneMapping=0,u.autoClear=!1;let h=new Gg({name:"PMREM.Background",side:1,depthWrite:!1,depthTest:!1}),f=new Vo(new Wg,h),m=!1,x=t.background;x?x.isColor&&(h.color.copy(x),t.background=null,m=!0):(h.color.copy(Fue),m=!0);for(let g=0;g<6;g++){let b=g%3;0===b?(a.up.set(0,l[g],0),a.lookAt(c[g],0,0)):1===b?(a.up.set(0,0,l[g]),a.lookAt(0,c[g],0)):(a.up.set(0,l[g],0),a.lookAt(0,0,c[g])),UO(r,b*wd,g>2?wd:0,wd,wd),u.setRenderTarget(r),m&&u.render(f,a),u.render(t,a)}f.geometry.dispose(),f.material.dispose(),u.toneMapping=p,u.autoClear=d,t.background=x}_textureToCubeUV(t,e){let i=this._renderer,r=301===t.mapping||302===t.mapping;r?(null===this._cubemapShader&&(this._cubemapShader=Vue()),this._cubemapShader.uniforms.flipEnvMap.value=!1===t.isRenderTargetTexture?-1:1):null===this._equirectShader&&(this._equirectShader=Bue());let o=r?this._cubemapShader:this._equirectShader,s=new Vo(RS[0],o),a=o.uniforms;a.envMap.value=t,r||a.texelSize.value.set(1/t.image.width,1/t.image.height),UO(e,0,0,3*wd,2*wd),i.setRenderTarget(e),i.render(s,Zj)}_applyPMREM(t){let e=this._renderer,i=e.autoClear;e.autoClear=!1;for(let r=1;r<Nde;r++){let o=Math.sqrt(HO[r]*HO[r]-HO[r-1]*HO[r-1]);this._blur(t,r-1,r,o,Nue[(r-1)%Nue.length])}e.autoClear=i}_blur(t,e,i,r,o){let s=this._pingPongRenderTarget;this._halfBlur(t,s,e,i,r,"latitudinal",o),this._halfBlur(s,t,i,i,r,"longitudinal",o)}_halfBlur(t,e,i,r,o,s,a){let l=this._renderer,c=this._blurMaterial;"latitudinal"!==s&&"longitudinal"!==s&&console.error("blur direction must be either latitudinal or longitudinal!");let d=new Vo(RS[r],c),p=c.uniforms,h=kue[i]-1,f=isFinite(o)?Math.PI/(2*h):2*Math.PI/39,m=o/f,x=isFinite(o)?1+Math.floor(3*m):20;x>20&&console.warn(`sigmaRadians, ${o}, is too large and will clip, as it requested ${x} samples when the maximum is set to 20`);let g=[],b=0;for(let Z=0;Z<20;++Z){let z=Z/m,fe=Math.exp(-z*z/2);g.push(fe),0===Z?b+=fe:Z<x&&(b+=2*fe)}for(let Z=0;Z<g.length;Z++)g[Z]=g[Z]/b;p.envMap.value=t.texture,p.samples.value=x,p.weights.value=g,p.latitudinal.value="latitudinal"===s,a&&(p.poleAxis.value=a),p.dTheta.value=f,p.mipInt.value=8-i;let D=kue[r];UO(e,3*Math.max(0,wd-2*D),(0===r?0:2*wd)+2*D*(r>4?r-8+4:0),3*D,2*D),l.setRenderTarget(e),l.render(d,Zj)}};function NWe(){let n=[],t=[],e=[],i=8;for(let r=0;r<Nde;r++){let o=Math.pow(2,i);t.push(o);let s=1/o;r>4?s=Fde[r-8+4-1]:0===r&&(s=0),e.push(s);let a=1/(o-1),l=-a/2,c=1+a/2,u=[l,l,c,l,c,c,l,l,c,c,l,c],d=6,p=6,h=3,f=2,m=1,x=new Float32Array(h*p*d),g=new Float32Array(f*p*d),b=new Float32Array(m*p*d);for(let T=0;T<d;T++){let k=T%3*2/3-1,Z=T>2?0:-1;x.set([k,Z,0,k+2/3,Z,0,k+2/3,Z+1,0,k,Z,0,k+2/3,Z+1,0,k,Z+1,0],h*p*T),g.set(u,f*p*T),b.set([T,T,T,T,T,T],m*p*T)}let D=new nr;D.setAttribute("position",new Yr(x,h)),D.setAttribute("uv",new Yr(g,f)),D.setAttribute("faceIndex",new Yr(b,m)),n.push(D),i>4&&i--}return{_lodPlanes:n,_sizeLods:t,_sigmas:e}}function Lue(n){let t=new Wa(3*wd,3*wd,n);return t.texture.mapping=306,t.texture.name="PMREM.cubeUv",t.scissorTest=!0,t}function UO(n,t,e,i,r){n.viewport.set(t,e,i,r),n.scissor.set(t,e,i,r)}function Bue(){let n=new at(1,1);return new _b({name:"EquirectangularToCubeUV",uniforms:{envMap:{value:null},texelSize:{value:n}},vertexShader:"\n\n\t\tprecision mediump float;\n\t\tprecision mediump int;\n\n\t\tattribute vec3 position;\n\t\tattribute vec2 uv;\n\t\tattribute float faceIndex;\n\n\t\tvarying vec3 vOutputDirection;\n\n\t\t// RH coordinate system; PMREM face-indexing convention\n\t\tvec3 getDirection( vec2 uv, float face ) {\n\n\t\t\tuv = 2.0 * uv - 1.0;\n\n\t\t\tvec3 direction = vec3( uv, 1.0 );\n\n\t\t\tif ( face == 0.0 ) {\n\n\t\t\t\tdirection = direction.zyx; // ( 1, v, u ) pos x\n\n\t\t\t} else if ( face == 1.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xz *= -1.0; // ( -u, 1, -v ) pos y\n\n\t\t\t} else if ( face == 2.0 ) {\n\n\t\t\t\tdirection.x *= -1.0; // ( -u, v, 1 ) pos z\n\n\t\t\t} else if ( face == 3.0 ) {\n\n\t\t\t\tdirection = direction.zyx;\n\t\t\t\tdirection.xz *= -1.0; // ( -1, v, -u ) neg x\n\n\t\t\t} else if ( face == 4.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xy *= -1.0; // ( -u, -1, v ) neg y\n\n\t\t\t} else if ( face == 5.0 ) {\n\n\t\t\t\tdirection.z *= -1.0; // ( u, v, -1 ) neg z\n\n\t\t\t}\n\n\t\t\treturn direction;\n\n\t\t}\n\n\t\tvoid main() {\n\n\t\t\tvOutputDirection = getDirection( uv, faceIndex );\n\t\t\tgl_Position = vec4( position, 1.0 );\n\n\t\t}\n\t",fragmentShader:"\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform sampler2D envMap;\n\t\t\tuniform vec2 texelSize;\n\n\t\t\t#include <common>\n\n\t\t\tvoid main() {\n\n\t\t\t\tgl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n\n\t\t\t\tvec3 outputDirection = normalize( vOutputDirection );\n\t\t\t\tvec2 uv = equirectUv( outputDirection );\n\n\t\t\t\tvec2 f = fract( uv / texelSize - 0.5 );\n\t\t\t\tuv -= f * texelSize;\n\t\t\t\tvec3 tl = texture2D ( envMap, uv ).rgb;\n\t\t\t\tuv.x += texelSize.x;\n\t\t\t\tvec3 tr = texture2D ( envMap, uv ).rgb;\n\t\t\t\tuv.y += texelSize.y;\n\t\t\t\tvec3 br = texture2D ( envMap, uv ).rgb;\n\t\t\t\tuv.x -= texelSize.x;\n\t\t\t\tvec3 bl = texture2D ( envMap, uv ).rgb;\n\n\t\t\t\tvec3 tm = mix( tl, tr, f.x );\n\t\t\t\tvec3 bm = mix( bl, br, f.x );\n\t\t\t\tgl_FragColor.rgb = mix( tm, bm, f.y );\n\n\t\t\t}\n\t\t",blending:0,depthTest:!1,depthWrite:!1})}function Vue(){return new _b({name:"CubemapToCubeUV",uniforms:{envMap:{value:null},flipEnvMap:{value:-1}},vertexShader:"\n\n\t\tprecision mediump float;\n\t\tprecision mediump int;\n\n\t\tattribute vec3 position;\n\t\tattribute vec2 uv;\n\t\tattribute float faceIndex;\n\n\t\tvarying vec3 vOutputDirection;\n\n\t\t// RH coordinate system; PMREM face-indexing convention\n\t\tvec3 getDirection( vec2 uv, float face ) {\n\n\t\t\tuv = 2.0 * uv - 1.0;\n\n\t\t\tvec3 direction = vec3( uv, 1.0 );\n\n\t\t\tif ( face == 0.0 ) {\n\n\t\t\t\tdirection = direction.zyx; // ( 1, v, u ) pos x\n\n\t\t\t} else if ( face == 1.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xz *= -1.0; // ( -u, 1, -v ) pos y\n\n\t\t\t} else if ( face == 2.0 ) {\n\n\t\t\t\tdirection.x *= -1.0; // ( -u, v, 1 ) pos z\n\n\t\t\t} else if ( face == 3.0 ) {\n\n\t\t\t\tdirection = direction.zyx;\n\t\t\t\tdirection.xz *= -1.0; // ( -1, v, -u ) neg x\n\n\t\t\t} else if ( face == 4.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xy *= -1.0; // ( -u, -1, v ) neg y\n\n\t\t\t} else if ( face == 5.0 ) {\n\n\t\t\t\tdirection.z *= -1.0; // ( u, v, -1 ) neg z\n\n\t\t\t}\n\n\t\t\treturn direction;\n\n\t\t}\n\n\t\tvoid main() {\n\n\t\t\tvOutputDirection = getDirection( uv, faceIndex );\n\t\t\tgl_Position = vec4( position, 1.0 );\n\n\t\t}\n\t",fragmentShader:"\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tuniform float flipEnvMap;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform samplerCube envMap;\n\n\t\t\tvoid main() {\n\n\t\t\t\tgl_FragColor = textureCube( envMap, vec3( flipEnvMap * vOutputDirection.x, vOutputDirection.yz ) );\n\n\t\t\t}\n\t\t",blending:0,depthTest:!1,depthWrite:!1})}function BWe(n){let t=new WeakMap,e=null;function o(a){let l=a.target;l.removeEventListener("dispose",o);let c=t.get(l);void 0!==c&&(t.delete(l),c.dispose())}return{get:function(a){if(a&&a.isTexture){let l=a.mapping,c=303===l||304===l,u=301===l||302===l;if(c||u){if(a.isRenderTargetTexture&&!0===a.needsPMREMUpdate){a.needsPMREMUpdate=!1;let d=t.get(a);return null===e&&(e=new uk(n)),d=c?e.fromEquirectangular(a,d):e.fromCubemap(a,d),t.set(a,d),d.texture}if(t.has(a))return t.get(a).texture;{let d=a.image;if(c&&d&&d.height>0||u&&d&&function(a){let l=0;for(let u=0;u<6;u++)void 0!==a[u]&&l++;return 6===l}(d)){null===e&&(e=new uk(n));let p=c?e.fromEquirectangular(a):e.fromCubemap(a);return t.set(a,p),a.addEventListener("dispose",o),p.texture}return null}}}return a},dispose:function(){t=new WeakMap,null!==e&&(e.dispose(),e=null)}}}function VWe(n){let t={};function e(i){if(void 0!==t[i])return t[i];let r;switch(i){case"WEBGL_depth_texture":r=n.getExtension("WEBGL_depth_texture")||n.getExtension("MOZ_WEBGL_depth_texture")||n.getExtension("WEBKIT_WEBGL_depth_texture");break;case"EXT_texture_filter_anisotropic":r=n.getExtension("EXT_texture_filter_anisotropic")||n.getExtension("MOZ_EXT_texture_filter_anisotropic")||n.getExtension("WEBKIT_EXT_texture_filter_anisotropic");break;case"WEBGL_compressed_texture_s3tc":r=n.getExtension("WEBGL_compressed_texture_s3tc")||n.getExtension("MOZ_WEBGL_compressed_texture_s3tc")||n.getExtension("WEBKIT_WEBGL_compressed_texture_s3tc");break;case"WEBGL_compressed_texture_pvrtc":r=n.getExtension("WEBGL_compressed_texture_pvrtc")||n.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc");break;default:r=n.getExtension(i)}return t[i]=r,r}return{has:function(i){return null!==e(i)},init:function(i){i.isWebGL2?e("EXT_color_buffer_float"):(e("WEBGL_depth_texture"),e("OES_texture_float"),e("OES_texture_half_float"),e("OES_texture_half_float_linear"),e("OES_standard_derivatives"),e("OES_element_index_uint"),e("OES_vertex_array_object"),e("ANGLE_instanced_arrays")),e("OES_texture_float_linear"),e("EXT_color_buffer_half_float"),e("WEBGL_multisampled_render_to_texture")},get:function(i){let r=e(i);return null===r&&console.warn("THREE.WebGLRenderer: "+i+" extension not supported."),r}}}function HWe(n,t,e,i){let r={},o=new WeakMap;function s(d){let p=d.target;null!==p.index&&t.remove(p.index);for(let f in p.attributes)t.remove(p.attributes[f]);p.removeEventListener("dispose",s),delete r[p.id];let h=o.get(p);h&&(t.remove(h),o.delete(p)),i.releaseStatesOfGeometry(p),!0===p.isInstancedBufferGeometry&&delete p._maxInstanceCount,e.memory.geometries--}function c(d){let p=[],h=d.index,f=d.attributes.position,m=0;if(null!==h){let b=h.array;m=h.version;for(let D=0,T=b.length;D<T;D+=3){let k=b[D+0],Z=b[D+1],z=b[D+2];p.push(k,Z,Z,z,z,k)}}else{m=f.version;for(let D=0,T=f.array.length/3-1;D<T;D+=3){let k=D+0,Z=D+1,z=D+2;p.push(k,Z,Z,z,z,k)}}let x=new(Ode(p)?lk:ak)(p,1);x.version=m;let g=o.get(d);g&&t.remove(g),o.set(d,x)}return{get:function(d,p){return!0===r[p.id]||(p.addEventListener("dispose",s),r[p.id]=!0,e.memory.geometries++),p},update:function(d){let p=d.attributes;for(let f in p)t.update(p[f],34962);let h=d.morphAttributes;for(let f in h){let m=h[f];for(let x=0,g=m.length;x<g;x++)t.update(m[x],34962)}},getWireframeAttribute:function(d){let p=o.get(d);if(p){let h=d.index;null!==h&&p.version<h.version&&c(d)}else c(d);return o.get(d)}}}function UWe(n,t,e,i){let o,a,l,r=i.isWebGL2;this.setMode=function(p){o=p},this.setIndex=function(p){a=p.type,l=p.bytesPerElement},this.render=function(p,h){n.drawElements(o,h,a,p*l),e.update(h,o,1)},this.renderInstances=function(p,h,f){if(0===f)return;let m,x;if(r)m=n,x="drawElementsInstanced";else if(m=t.get("ANGLE_instanced_arrays"),x="drawElementsInstancedANGLE",null===m)return void console.error("THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");m[x](o,h,a,p*l,f),e.update(h,o,f)}}function zWe(n){let e={frame:0,calls:0,triangles:0,points:0,lines:0};return{memory:{geometries:0,textures:0},render:e,programs:null,autoReset:!0,reset:function(){e.frame++,e.calls=0,e.triangles=0,e.points=0,e.lines=0},update:function(o,s,a){switch(e.calls++,s){case 4:e.triangles+=a*(o/3);break;case 1:e.lines+=a*(o/2);break;case 3:e.lines+=a*(o-1);break;case 2:e.lines+=a*o;break;case 0:e.points+=a*o;break;default:console.error("THREE.WebGLInfo: Unknown draw mode:",s)}}}}var JS=class extends Ho{constructor(t=null,e=1,i=1,r=1){super(null),this.image={data:t,width:e,height:i,depth:r},this.magFilter=Zo,this.minFilter=Zo,this.wrapR=El,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};function jWe(n,t){return n[0]-t[0]}function GWe(n,t){return Math.abs(t[1])-Math.abs(n[1])}function Hue(n,t){let e=1,i=t.isInterleavedBufferAttribute?t.data.array:t.array;i instanceof Int8Array?e=127:i instanceof Int16Array?e=32767:i instanceof Int32Array?e=2147483647:console.error("THREE.WebGLMorphtargets: Unsupported morph attribute data type: ",i),n.divideScalar(e)}function WWe(n,t,e){let i={},r=new Float32Array(8),o=new WeakMap,s=new ie,a=[];for(let c=0;c<8;c++)a[c]=[c,0];return{update:function(c,u,d,p){let h=c.morphTargetInfluences;if(!0===t.isWebGL2){let f=u.morphAttributes.position.length,m=o.get(u);if(void 0===m||m.count!==f){let F=function(){he.dispose(),o.delete(u),u.removeEventListener("dispose",F)};void 0!==m&&m.texture.dispose();let b=void 0!==u.morphAttributes.normal,D=u.morphAttributes.position,T=u.morphAttributes.normal||[],Z=!0===b?2:1,z=u.attributes.position.count*Z,fe=1;z>t.maxTextureSize&&(fe=Math.ceil(z/t.maxTextureSize),z=t.maxTextureSize);let ue=new Float32Array(z*fe*4*f),he=new JS(ue,z,fe,f);he.format=ga,he.type=Ug,he.needsUpdate=!0;let w=4*Z;for(let q=0;q<f;q++){let K=D[q],de=T[q],Y=z*fe*4*q;for(let ae=0;ae<K.count;ae++){s.fromBufferAttribute(K,ae),!0===K.normalized&&Hue(s,K);let le=ae*w;ue[Y+le+0]=s.x,ue[Y+le+1]=s.y,ue[Y+le+2]=s.z,ue[Y+le+3]=0,!0===b&&(s.fromBufferAttribute(de,ae),!0===de.normalized&&Hue(s,de),ue[Y+le+4]=s.x,ue[Y+le+5]=s.y,ue[Y+le+6]=s.z,ue[Y+le+7]=0)}}m={count:f,texture:he,size:new at(z,fe)},o.set(u,m),u.addEventListener("dispose",F)}let x=0;for(let b=0;b<h.length;b++)x+=h[b];let g=u.morphTargetsRelative?1:1-x;p.getUniforms().setValue(n,"morphTargetBaseInfluence",g),p.getUniforms().setValue(n,"morphTargetInfluences",h),p.getUniforms().setValue(n,"morphTargetsTexture",m.texture,e),p.getUniforms().setValue(n,"morphTargetsTextureSize",m.size)}else{let f=void 0===h?0:h.length,m=i[u.id];if(void 0===m||m.length!==f){m=[];for(let T=0;T<f;T++)m[T]=[T,0];i[u.id]=m}for(let T=0;T<f;T++){let k=m[T];k[0]=T,k[1]=h[T]}m.sort(GWe);for(let T=0;T<8;T++)T<f&&m[T][1]?(a[T][0]=m[T][0],a[T][1]=m[T][1]):(a[T][0]=Number.MAX_SAFE_INTEGER,a[T][1]=0);a.sort(jWe);let x=u.morphAttributes.position,g=u.morphAttributes.normal,b=0;for(let T=0;T<8;T++){let k=a[T],Z=k[0],z=k[1];Z!==Number.MAX_SAFE_INTEGER&&z?(x&&u.getAttribute("morphTarget"+T)!==x[Z]&&u.setAttribute("morphTarget"+T,x[Z]),g&&u.getAttribute("morphNormal"+T)!==g[Z]&&u.setAttribute("morphNormal"+T,g[Z]),r[T]=z,b+=z):(x&&!0===u.hasAttribute("morphTarget"+T)&&u.deleteAttribute("morphTarget"+T),g&&!0===u.hasAttribute("morphNormal"+T)&&u.deleteAttribute("morphNormal"+T),r[T]=0)}let D=u.morphTargetsRelative?1:1-b;p.getUniforms().setValue(n,"morphTargetBaseInfluence",D),p.getUniforms().setValue(n,"morphTargetInfluences",r)}}}}function qWe(n,t,e,i){let r=new WeakMap;function a(l){let c=l.target;c.removeEventListener("dispose",a),e.remove(c.instanceMatrix),null!==c.instanceColor&&e.remove(c.instanceColor)}return{update:function(l){let c=i.render.frame,d=t.get(l,l.geometry);return r.get(d)!==c&&(t.update(d),r.set(d,c)),l.isInstancedMesh&&(!1===l.hasEventListener("dispose",a)&&l.addEventListener("dispose",a),e.update(l.instanceMatrix,34962),null!==l.instanceColor&&e.update(l.instanceColor,34962)),d},dispose:function(){r=new WeakMap}}}JS.prototype.isDataTexture2DArray=!0;var dk=class extends Ho{constructor(t=null,e=1,i=1,r=1){super(null),this.image={data:t,width:e,height:i,depth:r},this.magFilter=Zo,this.minFilter=Zo,this.wrapR=El,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}};dk.prototype.isDataTexture3D=!0;var Lde=new Ho,Bde=new JS,Vde=new dk,Hde=new mb,Uue=[],zue=[],jue=new Float32Array(16),Gue=new Float32Array(9),Wue=new Float32Array(4);function Eb(n,t,e){let i=n[0];if(i<=0||i>0)return n;let r=t*e,o=Uue[r];if(void 0===o&&(o=new Float32Array(r),Uue[r]=o),0!==t){i.toArray(o,0);for(let s=1,a=0;s!==t;++s)a+=e,n[s].toArray(o,a)}return o}function _a(n,t){if(n.length!==t.length)return!1;for(let e=0,i=n.length;e<i;e++)if(n[e]!==t[e])return!1;return!0}function Ys(n,t){for(let e=0,i=t.length;e<i;e++)n[e]=t[e]}function kk(n,t){let e=zue[t];void 0===e&&(e=new Int32Array(t),zue[t]=e);for(let i=0;i!==t;++i)e[i]=n.allocateTextureUnit();return e}function YWe(n,t){let e=this.cache;e[0]!==t&&(n.uniform1f(this.addr,t),e[0]=t)}function XWe(n,t){let e=this.cache;if(void 0!==t.x)(e[0]!==t.x||e[1]!==t.y)&&(n.uniform2f(this.addr,t.x,t.y),e[0]=t.x,e[1]=t.y);else{if(_a(e,t))return;n.uniform2fv(this.addr,t),Ys(e,t)}}function QWe(n,t){let e=this.cache;if(void 0!==t.x)(e[0]!==t.x||e[1]!==t.y||e[2]!==t.z)&&(n.uniform3f(this.addr,t.x,t.y,t.z),e[0]=t.x,e[1]=t.y,e[2]=t.z);else if(void 0!==t.r)(e[0]!==t.r||e[1]!==t.g||e[2]!==t.b)&&(n.uniform3f(this.addr,t.r,t.g,t.b),e[0]=t.r,e[1]=t.g,e[2]=t.b);else{if(_a(e,t))return;n.uniform3fv(this.addr,t),Ys(e,t)}}function KWe(n,t){let e=this.cache;if(void 0!==t.x)(e[0]!==t.x||e[1]!==t.y||e[2]!==t.z||e[3]!==t.w)&&(n.uniform4f(this.addr,t.x,t.y,t.z,t.w),e[0]=t.x,e[1]=t.y,e[2]=t.z,e[3]=t.w);else{if(_a(e,t))return;n.uniform4fv(this.addr,t),Ys(e,t)}}function ZWe(n,t){let e=this.cache,i=t.elements;if(void 0===i){if(_a(e,t))return;n.uniformMatrix2fv(this.addr,!1,t),Ys(e,t)}else{if(_a(e,i))return;Wue.set(i),n.uniformMatrix2fv(this.addr,!1,Wue),Ys(e,i)}}function JWe(n,t){let e=this.cache,i=t.elements;if(void 0===i){if(_a(e,t))return;n.uniformMatrix3fv(this.addr,!1,t),Ys(e,t)}else{if(_a(e,i))return;Gue.set(i),n.uniformMatrix3fv(this.addr,!1,Gue),Ys(e,i)}}function $We(n,t){let e=this.cache,i=t.elements;if(void 0===i){if(_a(e,t))return;n.uniformMatrix4fv(this.addr,!1,t),Ys(e,t)}else{if(_a(e,i))return;jue.set(i),n.uniformMatrix4fv(this.addr,!1,jue),Ys(e,i)}}function e7e(n,t){let e=this.cache;e[0]!==t&&(n.uniform1i(this.addr,t),e[0]=t)}function t7e(n,t){let e=this.cache;_a(e,t)||(n.uniform2iv(this.addr,t),Ys(e,t))}function n7e(n,t){let e=this.cache;_a(e,t)||(n.uniform3iv(this.addr,t),Ys(e,t))}function i7e(n,t){let e=this.cache;_a(e,t)||(n.uniform4iv(this.addr,t),Ys(e,t))}function r7e(n,t){let e=this.cache;e[0]!==t&&(n.uniform1ui(this.addr,t),e[0]=t)}function o7e(n,t){let e=this.cache;_a(e,t)||(n.uniform2uiv(this.addr,t),Ys(e,t))}function s7e(n,t){let e=this.cache;_a(e,t)||(n.uniform3uiv(this.addr,t),Ys(e,t))}function a7e(n,t){let e=this.cache;_a(e,t)||(n.uniform4uiv(this.addr,t),Ys(e,t))}function l7e(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.safeSetTexture2D(t||Lde,r)}function c7e(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.setTexture3D(t||Vde,r)}function u7e(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.safeSetTextureCube(t||Hde,r)}function d7e(n,t,e){let i=this.cache,r=e.allocateTextureUnit();i[0]!==r&&(n.uniform1i(this.addr,r),i[0]=r),e.setTexture2DArray(t||Bde,r)}function h7e(n,t){n.uniform1fv(this.addr,t)}function f7e(n,t){let e=Eb(t,this.size,2);n.uniform2fv(this.addr,e)}function m7e(n,t){let e=Eb(t,this.size,3);n.uniform3fv(this.addr,e)}function g7e(n,t){let e=Eb(t,this.size,4);n.uniform4fv(this.addr,e)}function _7e(n,t){let e=Eb(t,this.size,4);n.uniformMatrix2fv(this.addr,!1,e)}function v7e(n,t){let e=Eb(t,this.size,9);n.uniformMatrix3fv(this.addr,!1,e)}function y7e(n,t){let e=Eb(t,this.size,16);n.uniformMatrix4fv(this.addr,!1,e)}function b7e(n,t){n.uniform1iv(this.addr,t)}function x7e(n,t){n.uniform2iv(this.addr,t)}function C7e(n,t){n.uniform3iv(this.addr,t)}function M7e(n,t){n.uniform4iv(this.addr,t)}function w7e(n,t){n.uniform1uiv(this.addr,t)}function S7e(n,t){n.uniform2uiv(this.addr,t)}function E7e(n,t){n.uniform3uiv(this.addr,t)}function T7e(n,t){n.uniform4uiv(this.addr,t)}function D7e(n,t,e){let i=t.length,r=kk(e,i);n.uniform1iv(this.addr,r);for(let o=0;o!==i;++o)e.safeSetTexture2D(t[o]||Lde,r[o])}function A7e(n,t,e){let i=t.length,r=kk(e,i);n.uniform1iv(this.addr,r);for(let o=0;o!==i;++o)e.setTexture3D(t[o]||Vde,r[o])}function I7e(n,t,e){let i=t.length,r=kk(e,i);n.uniform1iv(this.addr,r);for(let o=0;o!==i;++o)e.safeSetTextureCube(t[o]||Hde,r[o])}function P7e(n,t,e){let i=t.length,r=kk(e,i);n.uniform1iv(this.addr,r);for(let o=0;o!==i;++o)e.setTexture2DArray(t[o]||Bde,r[o])}function O7e(n,t,e){this.id=n,this.addr=e,this.cache=[],this.setValue=function(n){switch(n){case 5126:return YWe;case 35664:return XWe;case 35665:return QWe;case 35666:return KWe;case 35674:return ZWe;case 35675:return JWe;case 35676:return $We;case 5124:case 35670:return e7e;case 35667:case 35671:return t7e;case 35668:case 35672:return n7e;case 35669:case 35673:return i7e;case 5125:return r7e;case 36294:return o7e;case 36295:return s7e;case 36296:return a7e;case 35678:case 36198:case 36298:case 36306:case 35682:return l7e;case 35679:case 36299:case 36307:return c7e;case 35680:case 36300:case 36308:case 36293:return u7e;case 36289:case 36303:case 36311:case 36292:return d7e}}(t.type)}function Ude(n,t,e){this.id=n,this.addr=e,this.cache=[],this.size=t.size,this.setValue=function(n){switch(n){case 5126:return h7e;case 35664:return f7e;case 35665:return m7e;case 35666:return g7e;case 35674:return _7e;case 35675:return v7e;case 35676:return y7e;case 5124:case 35670:return b7e;case 35667:case 35671:return x7e;case 35668:case 35672:return C7e;case 35669:case 35673:return M7e;case 5125:return w7e;case 36294:return S7e;case 36295:return E7e;case 36296:return T7e;case 35678:case 36198:case 36298:case 36306:case 35682:return D7e;case 35679:case 36299:case 36307:return A7e;case 35680:case 36300:case 36308:case 36293:return I7e;case 36289:case 36303:case 36311:case 36292:return P7e}}(t.type)}function zde(n){this.id=n,this.seq=[],this.map={}}Ude.prototype.updateCache=function(n){let t=this.cache;n instanceof Float32Array&&t.length!==n.length&&(this.cache=new Float32Array(n.length)),Ys(t,n)},zde.prototype.setValue=function(n,t,e){let i=this.seq;for(let r=0,o=i.length;r!==o;++r){let s=i[r];s.setValue(n,t[s.id],e)}};var $j=/(\w+)(\])?(\[|\.)?/g;function que(n,t){n.seq.push(t),n.map[t.id]=t}function k7e(n,t,e){let i=n.name,r=i.length;for($j.lastIndex=0;;){let o=$j.exec(i),s=$j.lastIndex,a=o[1],c=o[3];if("]"===o[2]&&(a|=0),void 0===c||"["===c&&s+2===r){que(e,void 0===c?new O7e(a,n,t):new Ude(a,n,t));break}{let d=e.map[a];void 0===d&&(d=new zde(a),que(e,d)),e=d}}}function yf(n,t){this.seq=[],this.map={};let e=n.getProgramParameter(t,35718);for(let i=0;i<e;++i){let r=n.getActiveUniform(t,i);k7e(r,n.getUniformLocation(t,r.name),this)}}function Yue(n,t,e){let i=n.createShader(t);return n.shaderSource(i,e),n.compileShader(i),i}yf.prototype.setValue=function(n,t,e,i){let r=this.map[t];void 0!==r&&r.setValue(n,e,i)},yf.prototype.setOptional=function(n,t,e){let i=t[e];void 0!==i&&this.setValue(n,e,i)},yf.upload=function(n,t,e,i){for(let r=0,o=t.length;r!==o;++r){let s=t[r],a=e[s.id];!1!==a.needsUpdate&&s.setValue(n,a.value,i)}},yf.seqWithValue=function(n,t){let e=[];for(let i=0,r=n.length;i!==r;++i){let o=n[i];o.id in t&&e.push(o)}return e};var F7e=0;function Xue(n,t,e){let i=n.getShaderParameter(t,35713),r=n.getShaderInfoLog(t).trim();return i&&""===r?"":e.toUpperCase()+"\n\n"+r+"\n\n"+function(n){let t=n.split("\n");for(let e=0;e<t.length;e++)t[e]=e+1+": "+t[e];return t.join("\n")}(n.getShaderSource(t))}function B7e(n,t){let e=function(n){switch(n){case bf:return["Linear","( value )"];case Wr:return["sRGB","( value )"];default:return console.warn("THREE.WebGLProgram: Unsupported encoding:",n),["Linear","( value )"]}}(t);return"vec4 "+n+"( vec4 value ) { return LinearTo"+e[0]+e[1]+"; }"}function V7e(n,t){let e;switch(t){case 1:e="Linear";break;case 2:e="Reinhard";break;case 3:e="OptimizedCineon";break;case 4:e="ACESFilmic";break;case 5:e="Custom";break;default:console.warn("THREE.WebGLProgram: Unsupported toneMapping:",t),e="Linear"}return"vec3 "+n+"( vec3 color ) { return "+e+"ToneMapping( color ); }"}function VS(n){return""!==n}function Que(n,t){return n.replace(/NUM_DIR_LIGHTS/g,t.numDirLights).replace(/NUM_SPOT_LIGHTS/g,t.numSpotLights).replace(/NUM_RECT_AREA_LIGHTS/g,t.numRectAreaLights).replace(/NUM_POINT_LIGHTS/g,t.numPointLights).replace(/NUM_HEMI_LIGHTS/g,t.numHemiLights).replace(/NUM_DIR_LIGHT_SHADOWS/g,t.numDirLightShadows).replace(/NUM_SPOT_LIGHT_SHADOWS/g,t.numSpotLightShadows).replace(/NUM_POINT_LIGHT_SHADOWS/g,t.numPointLightShadows)}function Kue(n,t){return n.replace(/NUM_CLIPPING_PLANES/g,t.numClippingPlanes).replace(/UNION_CLIPPING_PLANES/g,t.numClippingPlanes-t.numClipIntersection)}var j7e=/^[ \t]*#include +<([\w\d./]+)>/gm;function g8(n){return n.replace(j7e,G7e)}function G7e(n,t){let e=Di[t];if(void 0===e)throw new Error("Can not resolve #include <"+t+">");return g8(e)}var W7e=/#pragma unroll_loop[\s]+?for \( int i \= (\d+)\; i < (\d+)\; i \+\+ \) \{([\s\S]+?)(?=\})\}/g,q7e=/#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*i\s*\+\+\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;function Zue(n){return n.replace(q7e,jde).replace(W7e,Y7e)}function Y7e(n,t,e,i){return console.warn("WebGLProgram: #pragma unroll_loop shader syntax is deprecated. Please use #pragma unroll_loop_start syntax instead."),jde(0,t,e,i)}function jde(n,t,e,i){let r="";for(let o=parseInt(t);o<parseInt(e);o++)r+=i.replace(/\[\s*i\s*\]/g,"[ "+o+" ]").replace(/UNROLLED_LOOP_INDEX/g,o);return r}function Jue(n){let t="precision "+n.precision+" float;\nprecision "+n.precision+" int;";return"highp"===n.precision?t+="\n#define HIGH_PRECISION":"mediump"===n.precision?t+="\n#define MEDIUM_PRECISION":"lowp"===n.precision&&(t+="\n#define LOW_PRECISION"),t}function J7e(n,t,e,i){let m,x,r=n.getContext(),o=e.defines,s=e.vertexShader,a=e.fragmentShader,l=function(n){let t="SHADOWMAP_TYPE_BASIC";return 1===n.shadowMapType?t="SHADOWMAP_TYPE_PCF":2===n.shadowMapType?t="SHADOWMAP_TYPE_PCF_SOFT":3===n.shadowMapType&&(t="SHADOWMAP_TYPE_VSM"),t}(e),c=function(n){let t="ENVMAP_TYPE_CUBE";if(n.envMap)switch(n.envMapMode){case 301:case 302:t="ENVMAP_TYPE_CUBE";break;case 306:case 307:t="ENVMAP_TYPE_CUBE_UV"}return t}(e),u=function(n){let t="ENVMAP_MODE_REFLECTION";if(n.envMap)switch(n.envMapMode){case 302:case 307:t="ENVMAP_MODE_REFRACTION"}return t}(e),d=function(n){let t="ENVMAP_BLENDING_NONE";if(n.envMap)switch(n.combine){case 0:t="ENVMAP_BLENDING_MULTIPLY";break;case 1:t="ENVMAP_BLENDING_MIX";break;case 2:t="ENVMAP_BLENDING_ADD"}return t}(e),p=e.isWebGL2?"":function(n){return[n.extensionDerivatives||n.envMapCubeUV||n.bumpMap||n.tangentSpaceNormalMap||n.clearcoatNormalMap||n.flatShading||"physical"===n.shaderID?"#extension GL_OES_standard_derivatives : enable":"",(n.extensionFragDepth||n.logarithmicDepthBuffer)&&n.rendererExtensionFragDepth?"#extension GL_EXT_frag_depth : enable":"",n.extensionDrawBuffers&&n.rendererExtensionDrawBuffers?"#extension GL_EXT_draw_buffers : require":"",(n.extensionShaderTextureLOD||n.envMap||n.transmission)&&n.rendererExtensionShaderTextureLod?"#extension GL_EXT_shader_texture_lod : enable":""].filter(VS).join("\n")}(e),h=function(n){let t=[];for(let e in n){let i=n[e];!1!==i&&t.push("#define "+e+" "+i)}return t.join("\n")}(o),f=r.createProgram(),g=e.glslVersion?"#version "+e.glslVersion+"\n":"";e.isRawShaderMaterial?(m=[h].filter(VS).join("\n"),m.length>0&&(m+="\n"),x=[p,h].filter(VS).join("\n"),x.length>0&&(x+="\n")):(m=[Jue(e),"#define SHADER_NAME "+e.shaderName,h,e.instancing?"#define USE_INSTANCING":"",e.instancingColor?"#define USE_INSTANCING_COLOR":"",e.supportsVertexTextures?"#define VERTEX_TEXTURES":"","#define MAX_BONES "+e.maxBones,e.useFog&&e.fog?"#define USE_FOG":"",e.useFog&&e.fogExp2?"#define FOG_EXP2":"",e.map?"#define USE_MAP":"",e.envMap?"#define USE_ENVMAP":"",e.envMap?"#define "+u:"",e.lightMap?"#define USE_LIGHTMAP":"",e.aoMap?"#define USE_AOMAP":"",e.emissiveMap?"#define USE_EMISSIVEMAP":"",e.bumpMap?"#define USE_BUMPMAP":"",e.normalMap?"#define USE_NORMALMAP":"",e.normalMap&&e.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",e.normalMap&&e.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",e.clearcoatMap?"#define USE_CLEARCOATMAP":"",e.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",e.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",e.displacementMap&&e.supportsVertexTextures?"#define USE_DISPLACEMENTMAP":"",e.specularMap?"#define USE_SPECULARMAP":"",e.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",e.specularColorMap?"#define USE_SPECULARCOLORMAP":"",e.roughnessMap?"#define USE_ROUGHNESSMAP":"",e.metalnessMap?"#define USE_METALNESSMAP":"",e.alphaMap?"#define USE_ALPHAMAP":"",e.transmission?"#define USE_TRANSMISSION":"",e.transmissionMap?"#define USE_TRANSMISSIONMAP":"",e.thicknessMap?"#define USE_THICKNESSMAP":"",e.sheenColorMap?"#define USE_SHEENCOLORMAP":"",e.sheenRoughnessMap?"#define USE_SHEENROUGHNESSMAP":"",e.vertexTangents?"#define USE_TANGENT":"",e.vertexColors?"#define USE_COLOR":"",e.vertexAlphas?"#define USE_COLOR_ALPHA":"",e.vertexUvs?"#define USE_UV":"",e.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",e.flatShading?"#define FLAT_SHADED":"",e.skinning?"#define USE_SKINNING":"",e.useVertexTexture?"#define BONE_TEXTURE":"",e.morphTargets?"#define USE_MORPHTARGETS":"",e.morphNormals&&!1===e.flatShading?"#define USE_MORPHNORMALS":"",e.morphTargets&&e.isWebGL2?"#define MORPHTARGETS_TEXTURE":"",e.morphTargets&&e.isWebGL2?"#define MORPHTARGETS_COUNT "+e.morphTargetsCount:"",e.doubleSided?"#define DOUBLE_SIDED":"",e.flipSided?"#define FLIP_SIDED":"",e.shadowMapEnabled?"#define USE_SHADOWMAP":"",e.shadowMapEnabled?"#define "+l:"",e.sizeAttenuation?"#define USE_SIZEATTENUATION":"",e.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",e.logarithmicDepthBuffer&&e.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"","uniform mat4 modelMatrix;","uniform mat4 modelViewMatrix;","uniform mat4 projectionMatrix;","uniform mat4 viewMatrix;","uniform mat3 normalMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;","#ifdef USE_INSTANCING","\tattribute mat4 instanceMatrix;","#endif","#ifdef USE_INSTANCING_COLOR","\tattribute vec3 instanceColor;","#endif","attribute vec3 position;","attribute vec3 normal;","attribute vec2 uv;","#ifdef USE_TANGENT","\tattribute vec4 tangent;","#endif","#if defined( USE_COLOR_ALPHA )","\tattribute vec4 color;","#elif defined( USE_COLOR )","\tattribute vec3 color;","#endif","#if ( defined( USE_MORPHTARGETS ) && ! defined( MORPHTARGETS_TEXTURE ) )","\tattribute vec3 morphTarget0;","\tattribute vec3 morphTarget1;","\tattribute vec3 morphTarget2;","\tattribute vec3 morphTarget3;","\t#ifdef USE_MORPHNORMALS","\t\tattribute vec3 morphNormal0;","\t\tattribute vec3 morphNormal1;","\t\tattribute vec3 morphNormal2;","\t\tattribute vec3 morphNormal3;","\t#else","\t\tattribute vec3 morphTarget4;","\t\tattribute vec3 morphTarget5;","\t\tattribute vec3 morphTarget6;","\t\tattribute vec3 morphTarget7;","\t#endif","#endif","#ifdef USE_SKINNING","\tattribute vec4 skinIndex;","\tattribute vec4 skinWeight;","#endif","\n"].filter(VS).join("\n"),x=[p,Jue(e),"#define SHADER_NAME "+e.shaderName,h,e.useFog&&e.fog?"#define USE_FOG":"",e.useFog&&e.fogExp2?"#define FOG_EXP2":"",e.map?"#define USE_MAP":"",e.matcap?"#define USE_MATCAP":"",e.envMap?"#define USE_ENVMAP":"",e.envMap?"#define "+c:"",e.envMap?"#define "+u:"",e.envMap?"#define "+d:"",e.lightMap?"#define USE_LIGHTMAP":"",e.aoMap?"#define USE_AOMAP":"",e.emissiveMap?"#define USE_EMISSIVEMAP":"",e.bumpMap?"#define USE_BUMPMAP":"",e.normalMap?"#define USE_NORMALMAP":"",e.normalMap&&e.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",e.normalMap&&e.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",e.clearcoat?"#define USE_CLEARCOAT":"",e.clearcoatMap?"#define USE_CLEARCOATMAP":"",e.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",e.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",e.specularMap?"#define USE_SPECULARMAP":"",e.specularIntensityMap?"#define USE_SPECULARINTENSITYMAP":"",e.specularColorMap?"#define USE_SPECULARCOLORMAP":"",e.roughnessMap?"#define USE_ROUGHNESSMAP":"",e.metalnessMap?"#define USE_METALNESSMAP":"",e.alphaMap?"#define USE_ALPHAMAP":"",e.alphaTest?"#define USE_ALPHATEST":"",e.sheen?"#define USE_SHEEN":"",e.sheenColorMap?"#define USE_SHEENCOLORMAP":"",e.sheenRoughnessMap?"#define USE_SHEENROUGHNESSMAP":"",e.transmission?"#define USE_TRANSMISSION":"",e.transmissionMap?"#define USE_TRANSMISSIONMAP":"",e.thicknessMap?"#define USE_THICKNESSMAP":"",e.decodeVideoTexture?"#define DECODE_VIDEO_TEXTURE":"",e.vertexTangents?"#define USE_TANGENT":"",e.vertexColors||e.instancingColor?"#define USE_COLOR":"",e.vertexAlphas?"#define USE_COLOR_ALPHA":"",e.vertexUvs?"#define USE_UV":"",e.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",e.gradientMap?"#define USE_GRADIENTMAP":"",e.flatShading?"#define FLAT_SHADED":"",e.doubleSided?"#define DOUBLE_SIDED":"",e.flipSided?"#define FLIP_SIDED":"",e.shadowMapEnabled?"#define USE_SHADOWMAP":"",e.shadowMapEnabled?"#define "+l:"",e.premultipliedAlpha?"#define PREMULTIPLIED_ALPHA":"",e.physicallyCorrectLights?"#define PHYSICALLY_CORRECT_LIGHTS":"",e.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",e.logarithmicDepthBuffer&&e.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"",(e.extensionShaderTextureLOD||e.envMap)&&e.rendererExtensionShaderTextureLod?"#define TEXTURE_LOD_EXT":"","uniform mat4 viewMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;",0!==e.toneMapping?"#define TONE_MAPPING":"",0!==e.toneMapping?Di.tonemapping_pars_fragment:"",0!==e.toneMapping?V7e("toneMapping",e.toneMapping):"",e.dithering?"#define DITHERING":"",e.alphaWrite?"":"#define OPAQUE",Di.encodings_pars_fragment,B7e("linearToOutputTexel",e.outputEncoding),e.depthPacking?"#define DEPTH_PACKING "+e.depthPacking:"","\n"].filter(VS).join("\n")),s=g8(s),s=Que(s,e),s=Kue(s,e),a=g8(a),a=Que(a,e),a=Kue(a,e),s=Zue(s),a=Zue(a),e.isWebGL2&&!0!==e.isRawShaderMaterial&&(g="#version 300 es\n",m=["precision mediump sampler2DArray;","#define attribute in","#define varying out","#define texture2D texture"].join("\n")+"\n"+m,x=["#define varying in","300 es"===e.glslVersion?"":"layout(location = 0) out highp vec4 pc_fragColor;","300 es"===e.glslVersion?"":"#define gl_FragColor pc_fragColor","#define gl_FragDepthEXT gl_FragDepth","#define texture2D texture","#define textureCube texture","#define texture2DProj textureProj","#define texture2DLodEXT textureLod","#define texture2DProjLodEXT textureProjLod","#define textureCubeLodEXT textureLod","#define texture2DGradEXT textureGrad","#define texture2DProjGradEXT textureProjGrad","#define textureCubeGradEXT textureGrad"].join("\n")+"\n"+x);let Z,z,D=g+x+a,T=Yue(r,35633,g+m+s),k=Yue(r,35632,D);if(r.attachShader(f,T),r.attachShader(f,k),void 0!==e.index0AttributeName?r.bindAttribLocation(f,0,e.index0AttributeName):!0===e.morphTargets&&r.bindAttribLocation(f,0,"position"),r.linkProgram(f),n.debug.checkShaderErrors){let fe=r.getProgramInfoLog(f).trim(),ue=r.getShaderInfoLog(T).trim(),he=r.getShaderInfoLog(k).trim(),w=!0,F=!0;if(!1===r.getProgramParameter(f,35714)){w=!1;let q=Xue(r,T,"vertex"),K=Xue(r,k,"fragment");console.error("THREE.WebGLProgram: Shader Error "+r.getError()+" - VALIDATE_STATUS "+r.getProgramParameter(f,35715)+"\n\nProgram Info Log: "+fe+"\n"+q+"\n"+K)}else""!==fe?console.warn("THREE.WebGLProgram: Program Info Log:",fe):(""===ue||""===he)&&(F=!1);F&&(this.diagnostics={runnable:w,programLog:fe,vertexShader:{log:ue,prefix:m},fragmentShader:{log:he,prefix:x}})}return r.deleteShader(T),r.deleteShader(k),this.getUniforms=function(){return void 0===Z&&(Z=new yf(r,f)),Z},this.getAttributes=function(){return void 0===z&&(z=function(n,t){let e={},i=n.getProgramParameter(t,35721);for(let r=0;r<i;r++){let o=n.getActiveAttrib(t,r),s=o.name,a=1;35674===o.type&&(a=2),35675===o.type&&(a=3),35676===o.type&&(a=4),e[s]={type:o.type,location:n.getAttribLocation(t,s),locationSize:a}}return e}(r,f)),z},this.destroy=function(){i.releaseStatesOfProgram(this),r.deleteProgram(f),this.program=void 0},this.name=e.shaderName,this.id=F7e++,this.cacheKey=t,this.usedTimes=1,this.program=f,this.vertexShader=T,this.fragmentShader=k,this}var $7e=0;function e9e(n,t,e,i,r,o,s){let a=new sk,l=new class{constructor(){this.shaderCache=new Map,this.materialCache=new Map}update(t){let i=t.fragmentShader,r=this._getShaderStage(t.vertexShader),o=this._getShaderStage(i),s=this._getShaderCacheForMaterial(t);return!1===s.has(r)&&(s.add(r),r.usedTimes++),!1===s.has(o)&&(s.add(o),o.usedTimes++),this}remove(t){let e=this.materialCache.get(t);for(let i of e)i.usedTimes--,0===i.usedTimes&&this.shaderCache.delete(i);return this.materialCache.delete(t),this}getVertexShaderID(t){return this._getShaderStage(t.vertexShader).id}getFragmentShaderID(t){return this._getShaderStage(t.fragmentShader).id}dispose(){this.shaderCache.clear(),this.materialCache.clear()}_getShaderCacheForMaterial(t){let e=this.materialCache;return!1===e.has(t)&&e.set(t,new Set),e.get(t)}_getShaderStage(t){let e=this.shaderCache;if(!1===e.has(t)){let i=new class{constructor(){this.id=$7e++,this.usedTimes=0}};e.set(t,i)}return e.get(t)}},c=[],u=r.isWebGL2,d=r.logarithmicDepthBuffer,p=r.floatVertexTextures,h=r.maxVertexUniforms,f=r.vertexTextures,m=r.precision,x={MeshDepthMaterial:"depth",MeshDistanceMaterial:"distanceRGBA",MeshNormalMaterial:"normal",MeshBasicMaterial:"basic",MeshLambertMaterial:"lambert",MeshPhongMaterial:"phong",MeshToonMaterial:"toon",MeshStandardMaterial:"physical",MeshPhysicalMaterial:"physical",MeshMatcapMaterial:"matcap",LineBasicMaterial:"basic",LineDashedMaterial:"dashed",PointsMaterial:"points",ShadowMaterial:"shadow",SpriteMaterial:"sprite"};return{getParameters:function(w,F,q,K,de){let De,nt,gt,Ue,Y=K.fog,le=(w.isMeshStandardMaterial?e:t).get(w.envMap||(w.isMeshStandardMaterial?K.environment:null)),Ie=x[w.type],ve=de.isSkinnedMesh?function(w){let q=w.skeleton.bones;if(p)return 1024;{let de=Math.floor((h-20)/4),Y=Math.min(de,q.length);return Y<q.length?(console.warn("THREE.WebGLRenderer: Skeleton has "+q.length+" bones. This GPU supports "+Y+"."),0):Y}}(de):0;if(null!==w.precision&&(m=r.getMaxPrecision(w.precision),m!==w.precision&&console.warn("THREE.WebGLProgram.getParameters:",w.precision,"not supported, using",m,"instead.")),Ie){let Te=Sd[Ie];De=Te.vertexShader,nt=Te.fragmentShader}else De=w.vertexShader,nt=w.fragmentShader,l.update(w),gt=l.getVertexShaderID(w),Ue=l.getFragmentShaderID(w);let Ae=n.getRenderTarget(),pt=w.clearcoat>0;return{isWebGL2:u,shaderID:Ie,shaderName:w.type,vertexShader:De,fragmentShader:nt,defines:w.defines,customVertexShaderID:gt,customFragmentShaderID:Ue,isRawShaderMaterial:!0===w.isRawShaderMaterial,glslVersion:w.glslVersion,precision:m,instancing:!0===de.isInstancedMesh,instancingColor:!0===de.isInstancedMesh&&null!==de.instanceColor,supportsVertexTextures:f,outputEncoding:null===Ae?n.outputEncoding:!0===Ae.isXRRenderTarget?Ae.texture.encoding:bf,map:!!w.map,matcap:!!w.matcap,envMap:!!le,envMapMode:le&&le.mapping,envMapCubeUV:!!le&&(306===le.mapping||307===le.mapping),lightMap:!!w.lightMap,aoMap:!!w.aoMap,emissiveMap:!!w.emissiveMap,bumpMap:!!w.bumpMap,normalMap:!!w.normalMap,objectSpaceNormalMap:1===w.normalMapType,tangentSpaceNormalMap:0===w.normalMapType,decodeVideoTexture:!!w.map&&!0===w.map.isVideoTexture&&w.map.encoding===Wr,clearcoat:pt,clearcoatMap:pt&&!!w.clearcoatMap,clearcoatRoughnessMap:pt&&!!w.clearcoatRoughnessMap,clearcoatNormalMap:pt&&!!w.clearcoatNormalMap,displacementMap:!!w.displacementMap,roughnessMap:!!w.roughnessMap,metalnessMap:!!w.metalnessMap,specularMap:!!w.specularMap,specularIntensityMap:!!w.specularIntensityMap,specularColorMap:!!w.specularColorMap,alphaMap:!!w.alphaMap,alphaTest:w.alphaTest>0,alphaWrite:w.alphaWrite||w.transparent,gradientMap:!!w.gradientMap,sheen:w.sheen>0,sheenColorMap:!!w.sheenColorMap,sheenRoughnessMap:!!w.sheenRoughnessMap,transmission:w.transmission>0,transmissionMap:!!w.transmissionMap,thicknessMap:!!w.thicknessMap,combine:w.combine,vertexTangents:!!w.normalMap&&!!de.geometry&&!!de.geometry.attributes.tangent,vertexColors:w.vertexColors,vertexAlphas:!0===w.vertexColors&&!!de.geometry&&!!de.geometry.attributes.color&&4===de.geometry.attributes.color.itemSize,vertexUvs:!!(w.map||w.bumpMap||w.normalMap||w.specularMap||w.alphaMap||w.emissiveMap||w.roughnessMap||w.metalnessMap||w.clearcoatMap||w.clearcoatRoughnessMap||w.clearcoatNormalMap||w.displacementMap||w.transmissionMap||w.thicknessMap||w.specularIntensityMap||w.specularColorMap||w.sheenColorMap||w.sheenRoughnessMap),uvsVertexOnly:!(w.map||w.bumpMap||w.normalMap||w.specularMap||w.alphaMap||w.emissiveMap||w.roughnessMap||w.metalnessMap||w.clearcoatNormalMap||w.transmission>0||w.transmissionMap||w.thicknessMap||w.specularIntensityMap||w.specularColorMap||w.sheen>0||w.sheenColorMap||w.sheenRoughnessMap||!w.displacementMap),fog:!!Y,useFog:w.fog,fogExp2:Y&&Y.isFogExp2,flatShading:!!w.flatShading,sizeAttenuation:w.sizeAttenuation,logarithmicDepthBuffer:d,skinning:!0===de.isSkinnedMesh&&ve>0,maxBones:ve,useVertexTexture:p,morphTargets:!!de.geometry&&!!de.geometry.morphAttributes.position,morphNormals:!!de.geometry&&!!de.geometry.morphAttributes.normal,morphTargetsCount:de.geometry&&de.geometry.morphAttributes.position?de.geometry.morphAttributes.position.length:0,numDirLights:F.directional.length,numPointLights:F.point.length,numSpotLights:F.spot.length,numRectAreaLights:F.rectArea.length,numHemiLights:F.hemi.length,numDirLightShadows:F.directionalShadowMap.length,numPointLightShadows:F.pointShadowMap.length,numSpotLightShadows:F.spotShadowMap.length,numClippingPlanes:s.numPlanes,numClipIntersection:s.numIntersection,dithering:w.dithering,shadowMapEnabled:n.shadowMap.enabled&&q.length>0,shadowMapType:n.shadowMap.type,toneMapping:w.toneMapped?n.toneMapping:0,physicallyCorrectLights:n.physicallyCorrectLights,premultipliedAlpha:w.premultipliedAlpha,doubleSided:2===w.side,flipSided:1===w.side,depthPacking:void 0!==w.depthPacking&&w.depthPacking,index0AttributeName:w.index0AttributeName,extensionDerivatives:w.extensions&&w.extensions.derivatives,extensionFragDepth:w.extensions&&w.extensions.fragDepth,extensionDrawBuffers:w.extensions&&w.extensions.drawBuffers,extensionShaderTextureLOD:w.extensions&&w.extensions.shaderTextureLOD,rendererExtensionFragDepth:u||i.has("EXT_frag_depth"),rendererExtensionDrawBuffers:u||i.has("WEBGL_draw_buffers"),rendererExtensionShaderTextureLod:u||i.has("EXT_shader_texture_lod"),customProgramCacheKey:w.customProgramCacheKey()}},getProgramCacheKey:function(w){let F=[];if(w.shaderID?F.push(w.shaderID):(F.push(w.customVertexShaderID),F.push(w.customFragmentShaderID)),void 0!==w.defines)for(let q in w.defines)F.push(q),F.push(w.defines[q]);return!1===w.isRawShaderMaterial&&(function(w,F){w.push(F.precision),w.push(F.outputEncoding),w.push(F.envMapMode),w.push(F.combine),w.push(F.vertexUvs),w.push(F.fogExp2),w.push(F.sizeAttenuation),w.push(F.maxBones),w.push(F.morphTargetsCount),w.push(F.numDirLights),w.push(F.numPointLights),w.push(F.numSpotLights),w.push(F.numHemiLights),w.push(F.numRectAreaLights),w.push(F.numDirLightShadows),w.push(F.numPointLightShadows),w.push(F.numSpotLightShadows),w.push(F.shadowMapType),w.push(F.toneMapping),w.push(F.numClippingPlanes),w.push(F.numClipIntersection),w.push(F.alphaWrite)}(F,w),function(w,F){a.disableAll(),F.isWebGL2&&a.enable(0),F.supportsVertexTextures&&a.enable(1),F.instancing&&a.enable(2),F.instancingColor&&a.enable(3),F.map&&a.enable(4),F.matcap&&a.enable(5),F.envMap&&a.enable(6),F.envMapCubeUV&&a.enable(7),F.lightMap&&a.enable(8),F.aoMap&&a.enable(9),F.emissiveMap&&a.enable(10),F.bumpMap&&a.enable(11),F.normalMap&&a.enable(12),F.objectSpaceNormalMap&&a.enable(13),F.tangentSpaceNormalMap&&a.enable(14),F.clearcoat&&a.enable(15),F.clearcoatMap&&a.enable(16),F.clearcoatRoughnessMap&&a.enable(17),F.clearcoatNormalMap&&a.enable(18),F.displacementMap&&a.enable(19),F.specularMap&&a.enable(20),F.roughnessMap&&a.enable(21),F.metalnessMap&&a.enable(22),F.gradientMap&&a.enable(23),F.alphaMap&&a.enable(24),F.alphaTest&&a.enable(25),F.vertexColors&&a.enable(26),F.vertexAlphas&&a.enable(27),F.vertexUvs&&a.enable(28),F.vertexTangents&&a.enable(29),F.uvsVertexOnly&&a.enable(30),F.fog&&a.enable(31),w.push(a.mask),a.disableAll(),F.useFog&&a.enable(0),F.flatShading&&a.enable(1),F.logarithmicDepthBuffer&&a.enable(2),F.skinning&&a.enable(3),F.useVertexTexture&&a.enable(4),F.morphTargets&&a.enable(5),F.morphNormals&&a.enable(6),F.premultipliedAlpha&&a.enable(7),F.shadowMapEnabled&&a.enable(8),F.physicallyCorrectLights&&a.enable(9),F.doubleSided&&a.enable(10),F.flipSided&&a.enable(11),F.depthPacking&&a.enable(12),F.dithering&&a.enable(13),F.specularIntensityMap&&a.enable(14),F.specularColorMap&&a.enable(15),F.transmission&&a.enable(16),F.transmissionMap&&a.enable(17),F.thicknessMap&&a.enable(18),F.sheen&&a.enable(19),F.sheenColorMap&&a.enable(20),F.sheenRoughnessMap&&a.enable(21),F.decodeVideoTexture&&a.enable(22),w.push(a.mask)}(F,w),F.push(n.outputEncoding)),F.push(w.customProgramCacheKey),F.join()},getUniforms:function(w){let q,F=x[w.type];return q=F?J8e.clone(Sd[F].uniforms):w.uniforms,q},acquireProgram:function(w,F){let q;for(let K=0,de=c.length;K<de;K++){let Y=c[K];if(Y.cacheKey===F){q=Y,++q.usedTimes;break}}return void 0===q&&(q=new J7e(n,F,w,o),c.push(q)),q},releaseProgram:function(w){if(0==--w.usedTimes){let F=c.indexOf(w);c[F]=c[c.length-1],c.pop(),w.destroy()}},releaseShaderCache:function(w){l.remove(w)},programs:c,dispose:function(){l.dispose()}}}function t9e(){let n=new WeakMap;return{get:function(o){let s=n.get(o);return void 0===s&&(s={},n.set(o,s)),s},remove:function(o){n.delete(o)},update:function(o,s,a){n.get(o)[s]=a},dispose:function(){n=new WeakMap}}}function n9e(n,t){return n.groupOrder!==t.groupOrder?n.groupOrder-t.groupOrder:n.renderOrder!==t.renderOrder?n.renderOrder-t.renderOrder:n.material.id!==t.material.id?n.material.id-t.material.id:n.z!==t.z?n.z-t.z:n.id-t.id}function $ue(n,t){return n.groupOrder!==t.groupOrder?n.groupOrder-t.groupOrder:n.renderOrder!==t.renderOrder?n.renderOrder-t.renderOrder:n.z!==t.z?t.z-n.z:n.id-t.id}function ede(){let n=[],t=0,e=[],i=[],r=[];function s(d,p,h,f,m,x){let g=n[t];return void 0===g?(g={id:d.id,object:d,geometry:p,material:h,groupOrder:f,renderOrder:d.renderOrder,z:m,group:x},n[t]=g):(g.id=d.id,g.object=d,g.geometry=p,g.material=h,g.groupOrder=f,g.renderOrder=d.renderOrder,g.z=m,g.group=x),t++,g}return{opaque:e,transmissive:i,transparent:r,init:function(){t=0,e.length=0,i.length=0,r.length=0},push:function(d,p,h,f,m,x){let g=s(d,p,h,f,m,x);h.transmission>0?i.push(g):!0===h.transparent?r.push(g):e.push(g)},unshift:function(d,p,h,f,m,x){let g=s(d,p,h,f,m,x);h.transmission>0?i.unshift(g):!0===h.transparent?r.unshift(g):e.unshift(g)},finish:function(){for(let d=t,p=n.length;d<p;d++){let h=n[d];if(null===h.id)break;h.id=null,h.object=null,h.geometry=null,h.material=null,h.group=null}},sort:function(d,p){e.length>1&&e.sort(d||n9e),i.length>1&&i.sort(p||$ue),r.length>1&&r.sort(p||$ue)}}}function i9e(){let n=new WeakMap;return{get:function(i,r){let o;return!1===n.has(i)?(o=new ede,n.set(i,[o])):r>=n.get(i).length?(o=new ede,n.get(i).push(o)):o=n.get(i)[r],o},dispose:function(){n=new WeakMap}}}function r9e(){let n={};return{get:function(t){if(void 0!==n[t.id])return n[t.id];let e;switch(t.type){case"DirectionalLight":e={direction:new ie,color:new vn};break;case"SpotLight":e={position:new ie,direction:new ie,color:new vn,distance:0,coneCos:0,penumbraCos:0,decay:0};break;case"PointLight":e={position:new ie,color:new vn,distance:0,decay:0};break;case"HemisphereLight":e={direction:new ie,skyColor:new vn,groundColor:new vn};break;case"RectAreaLight":e={color:new vn,position:new ie,halfWidth:new ie,halfHeight:new ie}}return n[t.id]=e,e}}}var s9e=0;function a9e(n,t){return(t.castShadow?1:0)-(n.castShadow?1:0)}function l9e(n,t){let e=new r9e,i=function(){let n={};return{get:function(t){if(void 0!==n[t.id])return n[t.id];let e;switch(t.type){case"DirectionalLight":case"SpotLight":e={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new at};break;case"PointLight":e={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new at,shadowCameraNear:1,shadowCameraFar:1e3}}return n[t.id]=e,e}}}(),r={version:0,hash:{directionalLength:-1,pointLength:-1,spotLength:-1,rectAreaLength:-1,hemiLength:-1,numDirectionalShadows:-1,numPointShadows:-1,numSpotShadows:-1},ambient:[0,0,0],probe:[],directional:[],directionalShadow:[],directionalShadowMap:[],directionalShadowMatrix:[],spot:[],spotShadow:[],spotShadowMap:[],spotShadowMatrix:[],rectArea:[],rectAreaLTC1:null,rectAreaLTC2:null,point:[],pointShadow:[],pointShadowMap:[],pointShadowMatrix:[],hemi:[]};for(let u=0;u<9;u++)r.probe.push(new ie);let o=new ie,s=new Rn,a=new Rn;return{setup:function(u,d){let p=0,h=0,f=0;for(let ue=0;ue<9;ue++)r.probe[ue].set(0,0,0);let m=0,x=0,g=0,b=0,D=0,T=0,k=0,Z=0;u.sort(a9e);let z=!0!==d?Math.PI:1;for(let ue=0,he=u.length;ue<he;ue++){let w=u[ue],F=w.color,q=w.intensity,K=w.distance,de=w.shadow&&w.shadow.map?w.shadow.map.texture:null;if(w.isAmbientLight)p+=F.r*q*z,h+=F.g*q*z,f+=F.b*q*z;else if(w.isLightProbe)for(let Y=0;Y<9;Y++)r.probe[Y].addScaledVector(w.sh.coefficients[Y],q);else if(w.isDirectionalLight){let Y=e.get(w);if(Y.color.copy(w.color).multiplyScalar(w.intensity*z),w.castShadow){let ae=w.shadow,le=i.get(w);le.shadowBias=ae.bias,le.shadowNormalBias=ae.normalBias,le.shadowRadius=ae.radius,le.shadowMapSize=ae.mapSize,r.directionalShadow[m]=le,r.directionalShadowMap[m]=de,r.directionalShadowMatrix[m]=w.shadow.matrix,T++}r.directional[m]=Y,m++}else if(w.isSpotLight){let Y=e.get(w);if(Y.position.setFromMatrixPosition(w.matrixWorld),Y.color.copy(F).multiplyScalar(q*z),Y.distance=K,Y.coneCos=Math.cos(w.angle),Y.penumbraCos=Math.cos(w.angle*(1-w.penumbra)),Y.decay=w.decay,w.castShadow){let ae=w.shadow,le=i.get(w);le.shadowBias=ae.bias,le.shadowNormalBias=ae.normalBias,le.shadowRadius=ae.radius,le.shadowMapSize=ae.mapSize,r.spotShadow[g]=le,r.spotShadowMap[g]=de,r.spotShadowMatrix[g]=w.shadow.matrix,Z++}r.spot[g]=Y,g++}else if(w.isRectAreaLight){let Y=e.get(w);Y.color.copy(F).multiplyScalar(q),Y.halfWidth.set(.5*w.width,0,0),Y.halfHeight.set(0,.5*w.height,0),r.rectArea[b]=Y,b++}else if(w.isPointLight){let Y=e.get(w);if(Y.color.copy(w.color).multiplyScalar(w.intensity*z),Y.distance=w.distance,Y.decay=w.decay,w.castShadow){let ae=w.shadow,le=i.get(w);le.shadowBias=ae.bias,le.shadowNormalBias=ae.normalBias,le.shadowRadius=ae.radius,le.shadowMapSize=ae.mapSize,le.shadowCameraNear=ae.camera.near,le.shadowCameraFar=ae.camera.far,r.pointShadow[x]=le,r.pointShadowMap[x]=de,r.pointShadowMatrix[x]=w.shadow.matrix,k++}r.point[x]=Y,x++}else if(w.isHemisphereLight){let Y=e.get(w);Y.skyColor.copy(w.color).multiplyScalar(q*z),Y.groundColor.copy(w.groundColor).multiplyScalar(q*z),r.hemi[D]=Y,D++}}b>0&&(t.isWebGL2||!0===n.has("OES_texture_float_linear")?(r.rectAreaLTC1=Bt.LTC_FLOAT_1,r.rectAreaLTC2=Bt.LTC_FLOAT_2):!0===n.has("OES_texture_half_float_linear")?(r.rectAreaLTC1=Bt.LTC_HALF_1,r.rectAreaLTC2=Bt.LTC_HALF_2):console.error("THREE.WebGLRenderer: Unable to use RectAreaLight. Missing WebGL extensions.")),r.ambient[0]=p,r.ambient[1]=h,r.ambient[2]=f;let fe=r.hash;(fe.directionalLength!==m||fe.pointLength!==x||fe.spotLength!==g||fe.rectAreaLength!==b||fe.hemiLength!==D||fe.numDirectionalShadows!==T||fe.numPointShadows!==k||fe.numSpotShadows!==Z)&&(r.directional.length=m,r.spot.length=g,r.rectArea.length=b,r.point.length=x,r.hemi.length=D,r.directionalShadow.length=T,r.directionalShadowMap.length=T,r.pointShadow.length=k,r.pointShadowMap.length=k,r.spotShadow.length=Z,r.spotShadowMap.length=Z,r.directionalShadowMatrix.length=T,r.pointShadowMatrix.length=k,r.spotShadowMatrix.length=Z,fe.directionalLength=m,fe.pointLength=x,fe.spotLength=g,fe.rectAreaLength=b,fe.hemiLength=D,fe.numDirectionalShadows=T,fe.numPointShadows=k,fe.numSpotShadows=Z,r.version=s9e++)},setupView:function(u,d){let p=0,h=0,f=0,m=0,x=0,g=d.matrixWorldInverse;for(let b=0,D=u.length;b<D;b++){let T=u[b];if(T.isDirectionalLight){let k=r.directional[p];k.direction.setFromMatrixPosition(T.matrixWorld),o.setFromMatrixPosition(T.target.matrixWorld),k.direction.sub(o),k.direction.transformDirection(g),p++}else if(T.isSpotLight){let k=r.spot[f];k.position.setFromMatrixPosition(T.matrixWorld),k.position.applyMatrix4(g),k.direction.setFromMatrixPosition(T.matrixWorld),o.setFromMatrixPosition(T.target.matrixWorld),k.direction.sub(o),k.direction.transformDirection(g),f++}else if(T.isRectAreaLight){let k=r.rectArea[m];k.position.setFromMatrixPosition(T.matrixWorld),k.position.applyMatrix4(g),a.identity(),s.copy(T.matrixWorld),s.premultiply(g),a.extractRotation(s),k.halfWidth.set(.5*T.width,0,0),k.halfHeight.set(0,.5*T.height,0),k.halfWidth.applyMatrix4(a),k.halfHeight.applyMatrix4(a),m++}else if(T.isPointLight){let k=r.point[h];k.position.setFromMatrixPosition(T.matrixWorld),k.position.applyMatrix4(g),h++}else if(T.isHemisphereLight){let k=r.hemi[x];k.direction.setFromMatrixPosition(T.matrixWorld),k.direction.transformDirection(g),k.direction.normalize(),x++}}},state:r}}function tde(n,t){let e=new l9e(n,t),i=[],r=[];return{init:function(){i.length=0,r.length=0},state:{lightsArray:i,shadowsArray:r,lights:e},setupLights:function(d){e.setup(i,d)},setupLightsView:function(d){e.setupView(i,d)},pushLight:function(d){i.push(d)},pushShadow:function(d){r.push(d)}}}function c9e(n,t){let e=new WeakMap;return{get:function(o,s=0){let a;return!1===e.has(o)?(a=new tde(n,t),e.set(o,[a])):s>=e.get(o).length?(a=new tde(n,t),e.get(o).push(a)):a=e.get(o)[s],a},dispose:function(){e=new WeakMap}}}var pk=class extends hs{constructor(t){super(),this.type="MeshDepthMaterial",this.depthPacking=3200,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.setValues(t)}copy(t){return super.copy(t),this.depthPacking=t.depthPacking,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this}};pk.prototype.isMeshDepthMaterial=!0;var hk=class extends hs{constructor(t){super(),this.type="MeshDistanceMaterial",this.referencePosition=new ie,this.nearDistance=1,this.farDistance=1e3,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.fog=!1,this.setValues(t)}copy(t){return super.copy(t),this.referencePosition.copy(t.referencePosition),this.nearDistance=t.nearDistance,this.farDistance=t.farDistance,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this}};function Gde(n,t,e){let i=new gb,r=new at,o=new at,s=new ar,a=new pk({depthPacking:3201}),l=new hk,c={},u=e.maxTextureSize,d={0:1,1:0,2:2},p=new Dp({defines:{VSM_SAMPLES:8},uniforms:{shadow_pass:{value:null},resolution:{value:new at},radius:{value:4}},vertexShader:"void main() {\n\tgl_Position = vec4( position, 1.0 );\n}",fragmentShader:"uniform sampler2D shadow_pass;\nuniform vec2 resolution;\nuniform float radius;\n#include <packing>\nvoid main() {\n\tconst float samples = float( VSM_SAMPLES );\n\tfloat mean = 0.0;\n\tfloat squared_mean = 0.0;\n\tfloat uvStride = samples <= 1.0 ? 0.0 : 2.0 / ( samples - 1.0 );\n\tfloat uvStart = samples <= 1.0 ? 0.0 : - 1.0;\n\tfor ( float i = 0.0; i < samples; i ++ ) {\n\t\tfloat uvOffset = uvStart + i * uvStride;\n\t\t#ifdef HORIZONTAL_PASS\n\t\t\tvec2 distribution = unpackRGBATo2Half( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( uvOffset, 0.0 ) * radius ) / resolution ) );\n\t\t\tmean += distribution.x;\n\t\t\tsquared_mean += distribution.y * distribution.y + distribution.x * distribution.x;\n\t\t#else\n\t\t\tfloat depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0, uvOffset ) * radius ) / resolution ) );\n\t\t\tmean += depth;\n\t\t\tsquared_mean += depth * depth;\n\t\t#endif\n\t}\n\tmean = mean / samples;\n\tsquared_mean = squared_mean / samples;\n\tfloat std_dev = sqrt( squared_mean - mean * mean );\n\tgl_FragColor = pack2HalfToRGBA( vec2( mean, std_dev ) );\n}"}),h=p.clone();h.defines.HORIZONTAL_PASS=1;let f=new nr;f.setAttribute("position",new Yr(new Float32Array([-1,-1,.5,3,-1,.5,-1,3,.5]),3));let m=new Vo(f,p),x=this;function g(T,k){let Z=t.update(m);p.defines.VSM_SAMPLES!==T.blurSamples&&(p.defines.VSM_SAMPLES=T.blurSamples,h.defines.VSM_SAMPLES=T.blurSamples,p.needsUpdate=!0,h.needsUpdate=!0),p.uniforms.shadow_pass.value=T.map.texture,p.uniforms.resolution.value=T.mapSize,p.uniforms.radius.value=T.radius,n.setRenderTarget(T.mapPass),n.clear(),n.renderBufferDirect(k,null,Z,p,m,null),h.uniforms.shadow_pass.value=T.mapPass.texture,h.uniforms.resolution.value=T.mapSize,h.uniforms.radius.value=T.radius,n.setRenderTarget(T.map),n.clear(),n.renderBufferDirect(k,null,Z,h,m,null)}function b(T,k,Z,z,fe,ue,he){let w=null,F=!0===z.isPointLight?T.customDistanceMaterial:T.customDepthMaterial;if(w=void 0!==F?F:!0===z.isPointLight?l:a,n.localClippingEnabled&&!0===Z.clipShadows&&0!==Z.clippingPlanes.length||Z.displacementMap&&0!==Z.displacementScale||Z.alphaMap&&Z.alphaTest>0){let q=w.uuid,K=Z.uuid,de=c[q];void 0===de&&(de={},c[q]=de);let Y=de[K];void 0===Y&&(Y=w.clone(),de[K]=Y),w=Y}return w.visible=Z.visible,w.wireframe=Z.wireframe,w.side=3===he?null!==Z.shadowSide?Z.shadowSide:Z.side:null!==Z.shadowSide?Z.shadowSide:d[Z.side],w.alphaMap=Z.alphaMap,w.alphaTest=Z.alphaTest,w.clipShadows=Z.clipShadows,w.clippingPlanes=Z.clippingPlanes,w.clipIntersection=Z.clipIntersection,w.displacementMap=Z.displacementMap,w.displacementScale=Z.displacementScale,w.displacementBias=Z.displacementBias,w.wireframeLinewidth=Z.wireframeLinewidth,w.linewidth=Z.linewidth,!0===z.isPointLight&&!0===w.isMeshDistanceMaterial&&(w.referencePosition.setFromMatrixPosition(z.matrixWorld),w.nearDistance=fe,w.farDistance=ue),w}function D(T,k,Z,z,fe){if(!1===T.visible)return;if(T.layers.test(k.layers)&&(T.isMesh||T.isLine||T.isPoints)&&(T.castShadow||T.receiveShadow&&3===fe)&&(!T.frustumCulled||i.intersectsObject(T))){T.modelViewMatrix.multiplyMatrices(Z.matrixWorldInverse,T.matrixWorld);let w=t.update(T),F=T.material;if(Array.isArray(F)){let q=w.groups;for(let K=0,de=q.length;K<de;K++){let Y=q[K],ae=F[Y.materialIndex];if(ae&&ae.visible){let le=b(T,0,ae,z,Z.near,Z.far,fe);n.renderBufferDirect(Z,null,w,le,T,Y)}}}else if(F.visible){let q=b(T,0,F,z,Z.near,Z.far,fe);n.renderBufferDirect(Z,null,w,q,T,null)}}let he=T.children;for(let w=0,F=he.length;w<F;w++)D(he[w],k,Z,z,fe)}this.enabled=!1,this.autoUpdate=!0,this.needsUpdate=!1,this.type=1,this.render=function(T,k,Z){if(!1===x.enabled||!1===x.autoUpdate&&!1===x.needsUpdate||0===T.length)return;let z=n.getRenderTarget(),fe=n.getActiveCubeFace(),ue=n.getActiveMipmapLevel(),he=n.state;he.setBlending(0),he.buffers.color.setClear(1,1,1,1),he.buffers.depth.setTest(!0),he.setScissorTest(!1);for(let w=0,F=T.length;w<F;w++){let q=T[w],K=q.shadow;if(void 0===K){console.warn("THREE.WebGLShadowMap:",q,"has no shadow.");continue}if(!1===K.autoUpdate&&!1===K.needsUpdate)continue;r.copy(K.mapSize);let de=K.getFrameExtents();if(r.multiply(de),o.copy(K.mapSize),(r.x>u||r.y>u)&&(r.x>u&&(o.x=Math.floor(u/de.x),r.x=o.x*de.x,K.mapSize.x=o.x),r.y>u&&(o.y=Math.floor(u/de.y),r.y=o.y*de.y,K.mapSize.y=o.y)),null===K.map&&!K.isPointLightShadow&&3===this.type){let ae={minFilter:Gs,magFilter:Gs,format:ga};K.map=new Wa(r.x,r.y,ae),K.map.texture.name=q.name+".shadowMap",K.mapPass=new Wa(r.x,r.y,ae),K.camera.updateProjectionMatrix()}null===K.map&&(K.map=new Wa(r.x,r.y,{minFilter:Zo,magFilter:Zo,format:ga}),K.map.texture.name=q.name+".shadowMap",K.camera.updateProjectionMatrix()),n.setRenderTarget(K.map),n.clear();let Y=K.getViewportCount();for(let ae=0;ae<Y;ae++){let le=K.getViewport(ae);s.set(o.x*le.x,o.y*le.y,o.x*le.z,o.y*le.w),he.viewport(s),K.updateMatrices(q,ae),i=K.getFrustum(),D(k,Z,K.camera,q,this.type)}!K.isPointLightShadow&&3===this.type&&g(K,Z),K.needsUpdate=!1}x.needsUpdate=!1,n.setRenderTarget(z,fe,ue)}}function p9e(n,t,e){let i=e.isWebGL2,a=new function(){let ge=!1,fn=new ar,Zt=null,Nn=new ar(0,0,0,0);return{setMask:function(Ze){Zt!==Ze&&!ge&&(n.colorMask(Ze,Ze,Ze,Ze),Zt=Ze)},setLocked:function(Ze){ge=Ze},setClear:function(Ze,Dn,Mi,Tr,Es){!0===Es&&(Ze*=Tr,Dn*=Tr,Mi*=Tr),fn.set(Ze,Dn,Mi,Tr),!1===Nn.equals(fn)&&(n.clearColor(Ze,Dn,Mi,Tr),Nn.copy(fn))},reset:function(){ge=!1,Zt=null,Nn.set(-1,0,0,0)}}},l=new function(){let ge=!1,fn=null,Zt=null,Nn=null;return{setTest:function(Ze){Ze?Ae(2929):tn(2929)},setMask:function(Ze){fn!==Ze&&!ge&&(n.depthMask(Ze),fn=Ze)},setFunc:function(Ze){if(Zt!==Ze){if(Ze)switch(Ze){case 0:n.depthFunc(512);break;case 1:n.depthFunc(519);break;case 2:n.depthFunc(513);break;case 3:default:n.depthFunc(515);break;case 4:n.depthFunc(514);break;case 5:n.depthFunc(518);break;case 6:n.depthFunc(516);break;case 7:n.depthFunc(517)}else n.depthFunc(515);Zt=Ze}},setLocked:function(Ze){ge=Ze},setClear:function(Ze){Nn!==Ze&&(n.clearDepth(Ze),Nn=Ze)},reset:function(){ge=!1,fn=null,Zt=null,Nn=null}}},c=new function(){let ge=!1,fn=null,Zt=null,Nn=null,Ze=null,Dn=null,Mi=null,Tr=null,Es=null;return{setTest:function(Br){ge||(Br?Ae(2960):tn(2960))},setMask:function(Br){fn!==Br&&!ge&&(n.stencilMask(Br),fn=Br)},setFunc:function(Br,Pl,ba){(Zt!==Br||Nn!==Pl||Ze!==ba)&&(n.stencilFunc(Br,Pl,ba),Zt=Br,Nn=Pl,Ze=ba)},setOp:function(Br,Pl,ba){(Dn!==Br||Mi!==Pl||Tr!==ba)&&(n.stencilOp(Br,Pl,ba),Dn=Br,Mi=Pl,Tr=ba)},setLocked:function(Br){ge=Br},setClear:function(Br){Es!==Br&&(n.clearStencil(Br),Es=Br)},reset:function(){ge=!1,fn=null,Zt=null,Nn=null,Ze=null,Dn=null,Mi=null,Tr=null,Es=null}}},u={},d={},p=new WeakMap,h=[],f=null,m=!1,x=null,g=null,b=null,D=null,T=null,k=null,Z=null,z=!1,fe=null,ue=null,he=null,w=null,F=null,q=n.getParameter(35661),K=!1,de=0,Y=n.getParameter(7938);-1!==Y.indexOf("WebGL")?(de=parseFloat(/^WebGL (\d)/.exec(Y)[1]),K=de>=1):-1!==Y.indexOf("OpenGL ES")&&(de=parseFloat(/^OpenGL ES (\d)/.exec(Y)[1]),K=de>=2);let ae=null,le={},Ie=n.getParameter(3088),ve=n.getParameter(2978),De=(new ar).fromArray(Ie),nt=(new ar).fromArray(ve);function gt(ge,fn,Zt){let Nn=new Uint8Array(4),Ze=n.createTexture();n.bindTexture(ge,Ze),n.texParameteri(ge,10241,9728),n.texParameteri(ge,10240,9728);for(let Dn=0;Dn<Zt;Dn++)n.texImage2D(fn+Dn,0,6408,1,1,0,6408,5121,Nn);return Ze}let Ue={};function Ae(ge){!0!==u[ge]&&(n.enable(ge),u[ge]=!0)}function tn(ge){!1!==u[ge]&&(n.disable(ge),u[ge]=!1)}Ue[3553]=gt(3553,3553,1),Ue[34067]=gt(34067,34069,6),a.setClear(0,0,0,1),l.setClear(1),c.setClear(0),Ae(2929),l.setFunc(3),We(!1),Mt(1),Ae(2884),ce(0);let xt={100:32774,101:32778,102:32779};if(i)xt[103]=32775,xt[104]=32776;else{let ge=t.get("EXT_blend_minmax");null!==ge&&(xt[103]=ge.MIN_EXT,xt[104]=ge.MAX_EXT)}let mt={200:0,201:1,202:768,204:770,210:776,208:774,206:772,203:769,205:771,209:775,207:773};function ce(ge,fn,Zt,Nn,Ze,Dn,Mi,Tr){if(0!==ge){if(!1===m&&(Ae(3042),m=!0),5===ge)Ze=Ze||fn,Dn=Dn||Zt,Mi=Mi||Nn,(fn!==g||Ze!==T)&&(n.blendEquationSeparate(xt[fn],xt[Ze]),g=fn,T=Ze),(Zt!==b||Nn!==D||Dn!==k||Mi!==Z)&&(n.blendFuncSeparate(mt[Zt],mt[Nn],mt[Dn],mt[Mi]),b=Zt,D=Nn,k=Dn,Z=Mi),x=ge,z=null;else if(ge!==x||Tr!==z){if((100!==g||100!==T)&&(n.blendEquation(32774),g=100,T=100),Tr)switch(ge){case 1:n.blendFuncSeparate(1,771,1,771);break;case 2:n.blendFunc(1,1);break;case 3:n.blendFuncSeparate(0,769,0,1);break;case 4:n.blendFuncSeparate(0,768,0,770);break;default:console.error("THREE.WebGLState: Invalid blending: ",ge)}else switch(ge){case 1:n.blendFuncSeparate(770,771,1,771);break;case 2:n.blendFunc(770,1);break;case 3:n.blendFuncSeparate(0,769,0,1);break;case 4:n.blendFunc(0,768);break;default:console.error("THREE.WebGLState: Invalid blending: ",ge)}b=null,D=null,k=null,Z=null,x=ge,z=Tr}}else!0===m&&(tn(3042),m=!1)}function We(ge){fe!==ge&&(n.frontFace(ge?2304:2305),fe=ge)}function Mt(ge){0!==ge?(Ae(2884),ge!==ue&&n.cullFace(1===ge?1029:2===ge?1028:1032)):tn(2884),ue=ge}function hn(ge,fn,Zt){ge?(Ae(32823),(w!==fn||F!==Zt)&&(n.polygonOffset(fn,Zt),w=fn,F=Zt)):tn(32823)}function fi(ge){void 0===ge&&(ge=33984+q-1),ae!==ge&&(n.activeTexture(ge),ae=ge)}return{buffers:{color:a,depth:l,stencil:c},enable:Ae,disable:tn,bindFramebuffer:function(ge,fn){return d[ge]!==fn&&(n.bindFramebuffer(ge,fn),d[ge]=fn,i&&(36009===ge&&(d[36160]=fn),36160===ge&&(d[36009]=fn)),!0)},drawBuffers:function(ge,fn){let Zt=h,Nn=!1;if(ge)if(Zt=p.get(fn),void 0===Zt&&(Zt=[],p.set(fn,Zt)),ge.isWebGLMultipleRenderTargets){let Ze=ge.texture;if(Zt.length!==Ze.length||36064!==Zt[0]){for(let Dn=0,Mi=Ze.length;Dn<Mi;Dn++)Zt[Dn]=36064+Dn;Zt.length=Ze.length,Nn=!0}}else 36064!==Zt[0]&&(Zt[0]=36064,Nn=!0);else 1029!==Zt[0]&&(Zt[0]=1029,Nn=!0);Nn&&(e.isWebGL2?n.drawBuffers(Zt):t.get("WEBGL_draw_buffers").drawBuffersWEBGL(Zt))},useProgram:function(ge){return f!==ge&&(n.useProgram(ge),f=ge,!0)},setBlending:ce,setMaterial:function(ge,fn){2===ge.side?tn(2884):Ae(2884);let Zt=1===ge.side;fn&&(Zt=!Zt),We(Zt),1===ge.blending&&!1===ge.transparent?ce(0):ce(ge.blending,ge.blendEquation,ge.blendSrc,ge.blendDst,ge.blendEquationAlpha,ge.blendSrcAlpha,ge.blendDstAlpha,ge.premultipliedAlpha),l.setFunc(ge.depthFunc),l.setTest(ge.depthTest),l.setMask(ge.depthWrite),a.setMask(ge.colorWrite);let Nn=ge.stencilWrite;c.setTest(Nn),Nn&&(c.setMask(ge.stencilWriteMask),c.setFunc(ge.stencilFunc,ge.stencilRef,ge.stencilFuncMask),c.setOp(ge.stencilFail,ge.stencilZFail,ge.stencilZPass)),hn(ge.polygonOffset,ge.polygonOffsetFactor,ge.polygonOffsetUnits),!0===ge.alphaToCoverage?Ae(32926):tn(32926)},setFlipSided:We,setCullFace:Mt,setLineWidth:function(ge){ge!==he&&(K&&n.lineWidth(ge),he=ge)},setPolygonOffset:hn,setScissorTest:function(ge){ge?Ae(3089):tn(3089)},activeTexture:fi,bindTexture:function(ge,fn){null===ae&&fi();let Zt=le[ae];void 0===Zt&&(Zt={type:void 0,texture:void 0},le[ae]=Zt),(Zt.type!==ge||Zt.texture!==fn)&&(n.bindTexture(ge,fn||Ue[ge]),Zt.type=ge,Zt.texture=fn)},unbindTexture:function(){let ge=le[ae];void 0!==ge&&void 0!==ge.type&&(n.bindTexture(ge.type,null),ge.type=void 0,ge.texture=void 0)},compressedTexImage2D:function(){try{n.compressedTexImage2D.apply(n,arguments)}catch(ge){console.error("THREE.WebGLState:",ge)}},texImage2D:function(){try{n.texImage2D.apply(n,arguments)}catch(ge){console.error("THREE.WebGLState:",ge)}},texImage3D:function(){try{n.texImage3D.apply(n,arguments)}catch(ge){console.error("THREE.WebGLState:",ge)}},texStorage2D:function(){try{n.texStorage2D.apply(n,arguments)}catch(ge){console.error("THREE.WebGLState:",ge)}},texStorage3D:function(){try{n.texStorage3D.apply(n,arguments)}catch(ge){console.error("THREE.WebGLState:",ge)}},texSubImage2D:function(){try{n.texSubImage2D.apply(n,arguments)}catch(ge){console.error("THREE.WebGLState:",ge)}},texSubImage3D:function(){try{n.texSubImage3D.apply(n,arguments)}catch(ge){console.error("THREE.WebGLState:",ge)}},compressedTexSubImage2D:function(){try{n.compressedTexSubImage2D.apply(n,arguments)}catch(ge){console.error("THREE.WebGLState:",ge)}},scissor:function(ge){!1===De.equals(ge)&&(n.scissor(ge.x,ge.y,ge.z,ge.w),De.copy(ge))},viewport:function(ge){!1===nt.equals(ge)&&(n.viewport(ge.x,ge.y,ge.z,ge.w),nt.copy(ge))},reset:function(){n.disable(3042),n.disable(2884),n.disable(2929),n.disable(32823),n.disable(3089),n.disable(2960),n.disable(32926),n.blendEquation(32774),n.blendFunc(1,0),n.blendFuncSeparate(1,0,1,0),n.colorMask(!0,!0,!0,!0),n.clearColor(0,0,0,0),n.depthMask(!0),n.depthFunc(513),n.clearDepth(1),n.stencilMask(4294967295),n.stencilFunc(519,0,4294967295),n.stencilOp(7680,7680,7680),n.clearStencil(0),n.cullFace(1029),n.frontFace(2305),n.polygonOffset(0,0),n.activeTexture(33984),n.bindFramebuffer(36160,null),!0===i&&(n.bindFramebuffer(36009,null),n.bindFramebuffer(36008,null)),n.useProgram(null),n.lineWidth(1),n.scissor(0,0,n.canvas.width,n.canvas.height),n.viewport(0,0,n.canvas.width,n.canvas.height),u={},ae=null,le={},d={},p=new WeakMap,h=[],f=null,m=!1,x=null,g=null,b=null,D=null,T=null,k=null,Z=null,z=!1,fe=null,ue=null,he=null,w=null,F=null,De.set(0,0,n.canvas.width,n.canvas.height),nt.set(0,0,n.canvas.width,n.canvas.height),a.reset(),l.reset(),c.reset()}}}function h9e(n,t,e,i,r,o,s){let m,a=r.isWebGL2,l=r.maxTextures,c=r.maxCubemapSize,u=r.maxTextureSize,d=r.maxSamples,h=t.has("WEBGL_multisampled_render_to_texture")?t.get("WEBGL_multisampled_render_to_texture"):void 0,f=new WeakMap,x=!1;try{x=typeof OffscreenCanvas<"u"&&null!==new OffscreenCanvas(1,1).getContext("2d")}catch{}function g(ee,W){return x?new OffscreenCanvas(ee,W):YS("canvas")}function b(ee,W,Xe,Tt){let mn=1;if((ee.width>Tt||ee.height>Tt)&&(mn=Tt/Math.max(ee.width,ee.height)),mn<1||!0===W){if(typeof HTMLImageElement<"u"&&ee instanceof HTMLImageElement||typeof HTMLCanvasElement<"u"&&ee instanceof HTMLCanvasElement||typeof ImageBitmap<"u"&&ee instanceof ImageBitmap){let qe=W?H8e:Math.floor,wn=qe(mn*ee.width),yn=qe(mn*ee.height);void 0===m&&(m=g(wn,yn));let zt=Xe?g(wn,yn):m;return zt.width=wn,zt.height=yn,zt.getContext("2d").drawImage(ee,0,0,wn,yn),console.warn("THREE.WebGLRenderer: Texture has been resized from ("+ee.width+"x"+ee.height+") to ("+wn+"x"+yn+")."),zt}return"data"in ee&&console.warn("THREE.WebGLRenderer: Image in DataTexture is too big ("+ee.width+"x"+ee.height+")."),ee}return ee}function D(ee){return xue(ee.width)&&xue(ee.height)}function k(ee,W){return ee.generateMipmaps&&W&&ee.minFilter!==Zo&&ee.minFilter!==Gs}function Z(ee){n.generateMipmap(ee)}function z(ee,W,Xe,Tt,mn=!1){if(!1===a)return W;if(null!==ee){if(void 0!==n[ee])return n[ee];console.warn("THREE.WebGLRenderer: Attempt to use non-existing WebGL internal format '"+ee+"'")}let qe=W;return 6403===W&&(5126===Xe&&(qe=33326),5131===Xe&&(qe=33325),5121===Xe&&(qe=33321)),33319===W&&(5126===Xe&&(qe=33328),5131===Xe&&(qe=33327),5121===Xe&&(qe=33323)),6408===W&&(5126===Xe&&(qe=34836),5131===Xe&&(qe=34842),5121===Xe&&(qe=Tt===Wr&&!1===mn?35907:32856),32819===Xe&&(qe=32854),32820===Xe&&(qe=32855)),(33325===qe||33326===qe||33327===qe||33328===qe||34842===qe||34836===qe)&&t.get("EXT_color_buffer_float"),qe}function fe(ee,W,Xe){return!0===k(ee,Xe)||ee.isFramebufferTexture&&ee.minFilter!==Zo&&ee.minFilter!==Gs?Math.log2(Math.max(W.width,W.height))+1:void 0!==ee.mipmaps&&ee.mipmaps.length>0?ee.mipmaps.length:ee.isCompressedTexture&&Array.isArray(ee.image)?W.mipmaps.length:1}function ue(ee){return ee===Zo||1004===ee||1005===ee?9728:9729}function he(ee){let W=ee.target;W.removeEventListener("dispose",he),function(ee){let W=i.get(ee);void 0!==W.__webglInit&&(n.deleteTexture(W.__webglTexture),i.remove(ee))}(W),W.isVideoTexture&&f.delete(W),s.memory.textures--}function w(ee){let W=ee.target;W.removeEventListener("dispose",w),function(ee){let W=ee.texture,Xe=i.get(ee),Tt=i.get(W);if(ee){if(void 0!==Tt.__webglTexture&&(n.deleteTexture(Tt.__webglTexture),s.memory.textures--),ee.depthTexture&&ee.depthTexture.dispose(),ee.isWebGLCubeRenderTarget)for(let mn=0;mn<6;mn++)n.deleteFramebuffer(Xe.__webglFramebuffer[mn]),Xe.__webglDepthbuffer&&n.deleteRenderbuffer(Xe.__webglDepthbuffer[mn]);else n.deleteFramebuffer(Xe.__webglFramebuffer),Xe.__webglDepthbuffer&&n.deleteRenderbuffer(Xe.__webglDepthbuffer),Xe.__webglMultisampledFramebuffer&&n.deleteFramebuffer(Xe.__webglMultisampledFramebuffer),Xe.__webglColorRenderbuffer&&n.deleteRenderbuffer(Xe.__webglColorRenderbuffer),Xe.__webglDepthRenderbuffer&&n.deleteRenderbuffer(Xe.__webglDepthRenderbuffer);if(ee.isWebGLMultipleRenderTargets)for(let mn=0,qe=W.length;mn<qe;mn++){let wn=i.get(W[mn]);wn.__webglTexture&&(n.deleteTexture(wn.__webglTexture),s.memory.textures--),i.remove(W[mn])}i.remove(W),i.remove(ee)}}(W)}let K=0;function ae(ee,W){let Xe=i.get(ee);if(ee.isVideoTexture&&function(ee){let W=s.render.frame;f.get(ee)!==W&&(f.set(ee,W),ee.update())}(ee),ee.version>0&&Xe.__version!==ee.version){let Tt=ee.image;if(void 0===Tt)console.warn("THREE.WebGLRenderer: Texture marked for update but image is undefined");else{if(!1!==Tt.complete)return void Ae(Xe,ee,W);console.warn("THREE.WebGLRenderer: Texture marked for update but image is incomplete")}}e.activeTexture(33984+W),e.bindTexture(3553,Xe.__webglTexture)}function ve(ee,W){let Xe=i.get(ee);ee.version>0&&Xe.__version!==ee.version?function(ee,W,Xe){if(6!==W.image.length)return;Ue(ee,W),e.activeTexture(33984+Xe),e.bindTexture(34067,ee.__webglTexture),n.pixelStorei(37440,W.flipY),n.pixelStorei(37441,W.premultiplyAlpha),n.pixelStorei(3317,W.unpackAlignment),n.pixelStorei(37443,0);let Tt=W&&(W.isCompressedTexture||W.image[0].isCompressedTexture),mn=W.image[0]&&W.image[0].isDataTexture,qe=[];for(let Ze=0;Ze<6;Ze++)qe[Ze]=Tt||mn?mn?W.image[Ze].image:W.image[Ze]:b(W.image[Ze],!1,!0,c),qe[Ze]=hn(W,qe[Ze]);let Nn,wn=qe[0],yn=D(wn)||a,zt=o.convert(W.format,W.encoding),Ut=o.convert(W.type),Wn=z(W.internalFormat,zt,Ut,W.encoding),ge=a&&!0!==W.isVideoTexture,fn=void 0===ee.__version,Zt=fe(W,wn,yn);if(gt(34067,W,yn),Tt){ge&&fn&&e.texStorage2D(34067,Zt,Wn,wn.width,wn.height);for(let Ze=0;Ze<6;Ze++){Nn=qe[Ze].mipmaps;for(let Dn=0;Dn<Nn.length;Dn++){let Mi=Nn[Dn];W.format!==ga?null!==zt?ge?e.compressedTexSubImage2D(34069+Ze,Dn,0,0,Mi.width,Mi.height,zt,Mi.data):e.compressedTexImage2D(34069+Ze,Dn,Wn,Mi.width,Mi.height,0,Mi.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()"):ge?e.texSubImage2D(34069+Ze,Dn,0,0,Mi.width,Mi.height,zt,Ut,Mi.data):e.texImage2D(34069+Ze,Dn,Wn,Mi.width,Mi.height,0,zt,Ut,Mi.data)}}}else{Nn=W.mipmaps,ge&&fn&&(Nn.length>0&&Zt++,e.texStorage2D(34067,Zt,Wn,qe[0].width,qe[0].height));for(let Ze=0;Ze<6;Ze++)if(mn){ge?e.texSubImage2D(34069+Ze,0,0,0,qe[Ze].width,qe[Ze].height,zt,Ut,qe[Ze].data):e.texImage2D(34069+Ze,0,Wn,qe[Ze].width,qe[Ze].height,0,zt,Ut,qe[Ze].data);for(let Dn=0;Dn<Nn.length;Dn++){let Tr=Nn[Dn].image[Ze].image;ge?e.texSubImage2D(34069+Ze,Dn+1,0,0,Tr.width,Tr.height,zt,Ut,Tr.data):e.texImage2D(34069+Ze,Dn+1,Wn,Tr.width,Tr.height,0,zt,Ut,Tr.data)}}else{ge?e.texSubImage2D(34069+Ze,0,0,0,zt,Ut,qe[Ze]):e.texImage2D(34069+Ze,0,Wn,zt,Ut,qe[Ze]);for(let Dn=0;Dn<Nn.length;Dn++){let Mi=Nn[Dn];ge?e.texSubImage2D(34069+Ze,Dn+1,0,0,zt,Ut,Mi.image[Ze]):e.texImage2D(34069+Ze,Dn+1,Wn,zt,Ut,Mi.image[Ze])}}}k(W,yn)&&Z(34067),ee.__version=W.version,W.onUpdate&&W.onUpdate(W)}(Xe,ee,W):(e.activeTexture(33984+W),e.bindTexture(34067,Xe.__webglTexture))}let De={1e3:10497,[El]:33071,1002:33648},nt={[Zo]:9728,1004:9984,1005:9986,[Gs]:9729,1007:9985,1008:9987};function gt(ee,W,Xe){if(Xe?(n.texParameteri(ee,10242,De[W.wrapS]),n.texParameteri(ee,10243,De[W.wrapT]),(32879===ee||35866===ee)&&n.texParameteri(ee,32882,De[W.wrapR]),n.texParameteri(ee,10240,nt[W.magFilter]),n.texParameteri(ee,10241,nt[W.minFilter])):(n.texParameteri(ee,10242,33071),n.texParameteri(ee,10243,33071),(32879===ee||35866===ee)&&n.texParameteri(ee,32882,33071),(W.wrapS!==El||W.wrapT!==El)&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping."),n.texParameteri(ee,10240,ue(W.magFilter)),n.texParameteri(ee,10241,ue(W.minFilter)),W.minFilter!==Zo&&W.minFilter!==Gs&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter.")),!0===t.has("EXT_texture_filter_anisotropic")){let Tt=t.get("EXT_texture_filter_anisotropic");if(W.type===Ug&&!1===t.has("OES_texture_float_linear")||!1===a&&W.type===lb&&!1===t.has("OES_texture_half_float_linear"))return;(W.anisotropy>1||i.get(W).__currentAnisotropy)&&(n.texParameterf(ee,Tt.TEXTURE_MAX_ANISOTROPY_EXT,Math.min(W.anisotropy,r.getMaxAnisotropy())),i.get(W).__currentAnisotropy=W.anisotropy)}}function Ue(ee,W){void 0===ee.__webglInit&&(ee.__webglInit=!0,W.addEventListener("dispose",he),ee.__webglTexture=n.createTexture(),s.memory.textures++)}function Ae(ee,W,Xe){let Tt=3553;W.isDataTexture2DArray&&(Tt=35866),W.isDataTexture3D&&(Tt=32879),Ue(ee,W),e.activeTexture(33984+Xe),e.bindTexture(Tt,ee.__webglTexture),n.pixelStorei(37440,W.flipY),n.pixelStorei(37441,W.premultiplyAlpha),n.pixelStorei(3317,W.unpackAlignment),n.pixelStorei(37443,0);let mn=function(ee){return!a&&(ee.wrapS!==El||ee.wrapT!==El||ee.minFilter!==Zo&&ee.minFilter!==Gs)}(W)&&!1===D(W.image),qe=b(W.image,mn,!1,u);qe=hn(W,qe);let wn=D(qe)||a,yn=o.convert(W.format,W.encoding),zt=o.convert(W.type),Ut=z(W.internalFormat,yn,zt,W.encoding,W.isVideoTexture);gt(Tt,W,wn);let Wn,ge=W.mipmaps,fn=a&&!0!==W.isVideoTexture,Zt=void 0===ee.__version,Nn=fe(W,qe,wn);if(W.isDepthTexture)Ut=6402,a?Ut=W.type===Ug?36012:1014===W.type?33190:W.type===cb?35056:33189:W.type===Ug&&console.error("WebGLRenderer: Floating point depth texture requires WebGL2."),W.format===jg&&6402===Ut&&W.type!==WS&&1014!==W.type&&(console.warn("THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture."),W.type=WS,zt=o.convert(W.type)),W.format===hb&&6402===Ut&&(Ut=34041,W.type!==cb&&(console.warn("THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture."),W.type=cb,zt=o.convert(W.type))),fn&&Zt?e.texStorage2D(3553,1,Ut,qe.width,qe.height):e.texImage2D(3553,0,Ut,qe.width,qe.height,0,yn,zt,null);else if(W.isDataTexture)if(ge.length>0&&wn){fn&&Zt&&e.texStorage2D(3553,Nn,Ut,ge[0].width,ge[0].height);for(let Ze=0,Dn=ge.length;Ze<Dn;Ze++)Wn=ge[Ze],fn?e.texSubImage2D(3553,0,0,0,Wn.width,Wn.height,yn,zt,Wn.data):e.texImage2D(3553,Ze,Ut,Wn.width,Wn.height,0,yn,zt,Wn.data);W.generateMipmaps=!1}else fn?(Zt&&e.texStorage2D(3553,Nn,Ut,qe.width,qe.height),e.texSubImage2D(3553,0,0,0,qe.width,qe.height,yn,zt,qe.data)):e.texImage2D(3553,0,Ut,qe.width,qe.height,0,yn,zt,qe.data);else if(W.isCompressedTexture){fn&&Zt&&e.texStorage2D(3553,Nn,Ut,ge[0].width,ge[0].height);for(let Ze=0,Dn=ge.length;Ze<Dn;Ze++)Wn=ge[Ze],W.format!==ga?null!==yn?fn?e.compressedTexSubImage2D(3553,Ze,0,0,Wn.width,Wn.height,yn,Wn.data):e.compressedTexImage2D(3553,Ze,Ut,Wn.width,Wn.height,0,Wn.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()"):fn?e.texSubImage2D(3553,Ze,0,0,Wn.width,Wn.height,yn,zt,Wn.data):e.texImage2D(3553,Ze,Ut,Wn.width,Wn.height,0,yn,zt,Wn.data)}else if(W.isDataTexture2DArray)fn?(Zt&&e.texStorage3D(35866,Nn,Ut,qe.width,qe.height,qe.depth),e.texSubImage3D(35866,0,0,0,0,qe.width,qe.height,qe.depth,yn,zt,qe.data)):e.texImage3D(35866,0,Ut,qe.width,qe.height,qe.depth,0,yn,zt,qe.data);else if(W.isDataTexture3D)fn?(Zt&&e.texStorage3D(32879,Nn,Ut,qe.width,qe.height,qe.depth),e.texSubImage3D(32879,0,0,0,0,qe.width,qe.height,qe.depth,yn,zt,qe.data)):e.texImage3D(32879,0,Ut,qe.width,qe.height,qe.depth,0,yn,zt,qe.data);else if(W.isFramebufferTexture)fn&&Zt?e.texStorage2D(3553,Nn,Ut,qe.width,qe.height):e.texImage2D(3553,0,Ut,qe.width,qe.height,0,yn,zt,null);else if(ge.length>0&&wn){fn&&Zt&&e.texStorage2D(3553,Nn,Ut,ge[0].width,ge[0].height);for(let Ze=0,Dn=ge.length;Ze<Dn;Ze++)Wn=ge[Ze],fn?e.texSubImage2D(3553,Ze,0,0,yn,zt,Wn):e.texImage2D(3553,Ze,Ut,yn,zt,Wn);W.generateMipmaps=!1}else fn?(Zt&&e.texStorage2D(3553,Nn,Ut,qe.width,qe.height),e.texSubImage2D(3553,0,0,0,yn,zt,qe)):e.texImage2D(3553,0,Ut,yn,zt,qe);k(W,wn)&&Z(Tt),ee.__version=W.version,W.onUpdate&&W.onUpdate(W)}function pt(ee,W,Xe,Tt,mn){let qe=o.convert(Xe.format,Xe.encoding),wn=o.convert(Xe.type),yn=z(Xe.internalFormat,qe,wn,Xe.encoding);i.get(W).__hasExternalTextures||(32879===mn||35866===mn?e.texImage3D(mn,0,yn,W.width,W.height,W.depth,0,qe,wn,null):e.texImage2D(mn,0,yn,W.width,W.height,0,qe,wn,null)),e.bindFramebuffer(36160,ee),W.useRenderToTexture?h.framebufferTexture2DMultisampleEXT(36160,Tt,mn,i.get(Xe).__webglTexture,0,Mt(W)):n.framebufferTexture2D(36160,Tt,mn,i.get(Xe).__webglTexture,0),e.bindFramebuffer(36160,null)}function wt(ee,W,Xe){if(n.bindRenderbuffer(36161,ee),W.depthBuffer&&!W.stencilBuffer){let Tt=33189;if(Xe||W.useRenderToTexture){let mn=W.depthTexture;mn&&mn.isDepthTexture&&(mn.type===Ug?Tt=36012:1014===mn.type&&(Tt=33190));let qe=Mt(W);W.useRenderToTexture?h.renderbufferStorageMultisampleEXT(36161,qe,Tt,W.width,W.height):n.renderbufferStorageMultisample(36161,qe,Tt,W.width,W.height)}else n.renderbufferStorage(36161,Tt,W.width,W.height);n.framebufferRenderbuffer(36160,36096,36161,ee)}else if(W.depthBuffer&&W.stencilBuffer){let Tt=Mt(W);Xe&&W.useRenderbuffer?n.renderbufferStorageMultisample(36161,Tt,35056,W.width,W.height):W.useRenderToTexture?h.renderbufferStorageMultisampleEXT(36161,Tt,35056,W.width,W.height):n.renderbufferStorage(36161,34041,W.width,W.height),n.framebufferRenderbuffer(36160,33306,36161,ee)}else{let Tt=!0===W.isWebGLMultipleRenderTargets?W.texture[0]:W.texture,mn=o.convert(Tt.format,Tt.encoding),qe=o.convert(Tt.type),wn=z(Tt.internalFormat,mn,qe,Tt.encoding),yn=Mt(W);Xe&&W.useRenderbuffer?n.renderbufferStorageMultisample(36161,yn,wn,W.width,W.height):W.useRenderToTexture?h.renderbufferStorageMultisampleEXT(36161,yn,wn,W.width,W.height):n.renderbufferStorage(36161,wn,W.width,W.height)}n.bindRenderbuffer(36161,null)}function xt(ee){let W=i.get(ee),Xe=!0===ee.isWebGLCubeRenderTarget;if(ee.depthTexture&&!W.__autoAllocateDepthBuffer){if(Xe)throw new Error("target.depthTexture not supported in Cube render targets");!function(ee,W){if(W&&W.isWebGLCubeRenderTarget)throw new Error("Depth Texture with cube render targets is not supported");if(e.bindFramebuffer(36160,ee),!W.depthTexture||!W.depthTexture.isDepthTexture)throw new Error("renderTarget.depthTexture must be an instance of THREE.DepthTexture");(!i.get(W.depthTexture).__webglTexture||W.depthTexture.image.width!==W.width||W.depthTexture.image.height!==W.height)&&(W.depthTexture.image.width=W.width,W.depthTexture.image.height=W.height,W.depthTexture.needsUpdate=!0),ae(W.depthTexture,0);let Tt=i.get(W.depthTexture).__webglTexture,mn=Mt(W);if(W.depthTexture.format===jg)W.useRenderToTexture?h.framebufferTexture2DMultisampleEXT(36160,36096,3553,Tt,0,mn):n.framebufferTexture2D(36160,36096,3553,Tt,0);else{if(W.depthTexture.format!==hb)throw new Error("Unknown depthTexture format");W.useRenderToTexture?h.framebufferTexture2DMultisampleEXT(36160,33306,3553,Tt,0,mn):n.framebufferTexture2D(36160,33306,3553,Tt,0)}}(W.__webglFramebuffer,ee)}else if(Xe){W.__webglDepthbuffer=[];for(let Tt=0;Tt<6;Tt++)e.bindFramebuffer(36160,W.__webglFramebuffer[Tt]),W.__webglDepthbuffer[Tt]=n.createRenderbuffer(),wt(W.__webglDepthbuffer[Tt],ee,!1)}else e.bindFramebuffer(36160,W.__webglFramebuffer),W.__webglDepthbuffer=n.createRenderbuffer(),wt(W.__webglDepthbuffer,ee,!1);e.bindFramebuffer(36160,null)}function Mt(ee){return a&&(ee.useRenderbuffer||ee.useRenderToTexture)?Math.min(d,ee.samples):0}function hn(ee,W){let Xe=ee.encoding,Tt=ee.format,mn=ee.type;return!0===ee.isCompressedTexture||!0===ee.isVideoTexture||1035===ee.format||Xe!==bf&&(Xe===Wr?!1===a?!0===t.has("EXT_sRGB")&&Tt===ga?(ee.format=1035,ee.minFilter=Gs,ee.generateMipmaps=!1):W=Tp.sRGBToLinear(W):(Tt!==ga||mn!==_f)&&console.warn("THREE.WebGLTextures: sRGB encoded textures have to use RGBAFormat and UnsignedByteType."):console.error("THREE.WebGLTextures: Unsupported texture encoding:",Xe)),W}let on=!1,fi=!1;this.allocateTextureUnit=function(){let ee=K;return ee>=l&&console.warn("THREE.WebGLTextures: Trying to use "+ee+" texture units while this GPU supports only "+l),K+=1,ee},this.resetTextureUnits=function(){K=0},this.setTexture2D=ae,this.setTexture2DArray=function(ee,W){let Xe=i.get(ee);ee.version>0&&Xe.__version!==ee.version?Ae(Xe,ee,W):(e.activeTexture(33984+W),e.bindTexture(35866,Xe.__webglTexture))},this.setTexture3D=function(ee,W){let Xe=i.get(ee);ee.version>0&&Xe.__version!==ee.version?Ae(Xe,ee,W):(e.activeTexture(33984+W),e.bindTexture(32879,Xe.__webglTexture))},this.setTextureCube=ve,this.rebindTextures=function(ee,W,Xe){let Tt=i.get(ee);void 0!==W&&pt(Tt.__webglFramebuffer,ee,ee.texture,36064,3553),void 0!==Xe&&xt(ee)},this.setupRenderTarget=function(ee){let W=ee.texture,Xe=i.get(ee),Tt=i.get(W);ee.addEventListener("dispose",w),!0!==ee.isWebGLMultipleRenderTargets&&(void 0===Tt.__webglTexture&&(Tt.__webglTexture=n.createTexture()),Tt.__version=W.version,s.memory.textures++);let mn=!0===ee.isWebGLCubeRenderTarget,qe=!0===ee.isWebGLMultipleRenderTargets,wn=W.isDataTexture3D||W.isDataTexture2DArray,yn=D(ee)||a;if(mn){Xe.__webglFramebuffer=[];for(let zt=0;zt<6;zt++)Xe.__webglFramebuffer[zt]=n.createFramebuffer()}else if(Xe.__webglFramebuffer=n.createFramebuffer(),qe)if(r.drawBuffers){let zt=ee.texture;for(let Ut=0,Wn=zt.length;Ut<Wn;Ut++){let ge=i.get(zt[Ut]);void 0===ge.__webglTexture&&(ge.__webglTexture=n.createTexture(),s.memory.textures++)}}else console.warn("THREE.WebGLRenderer: WebGLMultipleRenderTargets can only be used with WebGL2 or WEBGL_draw_buffers extension.");else if(ee.useRenderbuffer)if(a){Xe.__webglMultisampledFramebuffer=n.createFramebuffer(),Xe.__webglColorRenderbuffer=n.createRenderbuffer(),n.bindRenderbuffer(36161,Xe.__webglColorRenderbuffer);let zt=o.convert(W.format,W.encoding),Ut=o.convert(W.type),Wn=z(W.internalFormat,zt,Ut,W.encoding),ge=Mt(ee);n.renderbufferStorageMultisample(36161,ge,Wn,ee.width,ee.height),e.bindFramebuffer(36160,Xe.__webglMultisampledFramebuffer),n.framebufferRenderbuffer(36160,36064,36161,Xe.__webglColorRenderbuffer),n.bindRenderbuffer(36161,null),ee.depthBuffer&&(Xe.__webglDepthRenderbuffer=n.createRenderbuffer(),wt(Xe.__webglDepthRenderbuffer,ee,!0)),e.bindFramebuffer(36160,null)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.");if(mn){e.bindTexture(34067,Tt.__webglTexture),gt(34067,W,yn);for(let zt=0;zt<6;zt++)pt(Xe.__webglFramebuffer[zt],ee,W,36064,34069+zt);k(W,yn)&&Z(34067),e.unbindTexture()}else if(qe){let zt=ee.texture;for(let Ut=0,Wn=zt.length;Ut<Wn;Ut++){let ge=zt[Ut],fn=i.get(ge);e.bindTexture(3553,fn.__webglTexture),gt(3553,ge,yn),pt(Xe.__webglFramebuffer,ee,ge,36064+Ut,3553),k(ge,yn)&&Z(3553)}e.unbindTexture()}else{let zt=3553;wn&&(a?zt=W.isDataTexture3D?32879:35866:console.warn("THREE.DataTexture3D and THREE.DataTexture2DArray only supported with WebGL2.")),e.bindTexture(zt,Tt.__webglTexture),gt(zt,W,yn),pt(Xe.__webglFramebuffer,ee,W,36064,zt),k(W,yn)&&Z(zt),e.unbindTexture()}ee.depthBuffer&&xt(ee)},this.updateRenderTargetMipmap=function(ee){let W=D(ee)||a,Xe=!0===ee.isWebGLMultipleRenderTargets?ee.texture:[ee.texture];for(let Tt=0,mn=Xe.length;Tt<mn;Tt++){let qe=Xe[Tt];if(k(qe,W)){let wn=ee.isWebGLCubeRenderTarget?34067:3553,yn=i.get(qe).__webglTexture;e.bindTexture(wn,yn),Z(wn),e.unbindTexture()}}},this.updateMultisampleRenderTarget=function(ee){if(ee.useRenderbuffer)if(a){let W=ee.width,Xe=ee.height,Tt=16384,mn=[36064],qe=ee.stencilBuffer?33306:36096;ee.depthBuffer&&mn.push(qe),ee.ignoreDepthForMultisampleCopy||(ee.depthBuffer&&(Tt|=256),ee.stencilBuffer&&(Tt|=1024));let wn=i.get(ee);e.bindFramebuffer(36008,wn.__webglMultisampledFramebuffer),e.bindFramebuffer(36009,wn.__webglFramebuffer),ee.ignoreDepthForMultisampleCopy&&(n.invalidateFramebuffer(36008,[qe]),n.invalidateFramebuffer(36009,[qe])),n.blitFramebuffer(0,0,W,Xe,0,0,W,Xe,Tt,9728),n.invalidateFramebuffer(36008,mn),e.bindFramebuffer(36008,null),e.bindFramebuffer(36009,wn.__webglMultisampledFramebuffer)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.")},this.setupDepthRenderbuffer=xt,this.setupFrameBufferTexture=pt,this.safeSetTexture2D=function(ee,W){ee&&ee.isWebGLRenderTarget&&(!1===on&&(console.warn("THREE.WebGLTextures.safeSetTexture2D: don't use render targets as textures. Use their .texture property instead."),on=!0),ee=ee.texture),ae(ee,W)},this.safeSetTextureCube=function(ee,W){ee&&ee.isWebGLCubeRenderTarget&&(!1===fi&&(console.warn("THREE.WebGLTextures.safeSetTextureCube: don't use cube render targets as textures. Use their .texture property instead."),fi=!0),ee=ee.texture),ve(ee,W)}}function f9e(n,t,e){let i=e.isWebGL2;return{convert:function(o,s=null){let a;if(o===_f)return 5121;if(1017===o)return 32819;if(1018===o)return 32820;if(1010===o)return 5120;if(1011===o)return 5122;if(o===WS)return 5123;if(1013===o)return 5124;if(1014===o)return 5125;if(o===Ug)return 5126;if(o===lb)return i?5131:(a=t.get("OES_texture_half_float"),null!==a?a.HALF_FLOAT_OES:null);if(1021===o)return 6406;if(o===ga)return 6408;if(1024===o)return 6409;if(1025===o)return 6410;if(o===jg)return 6402;if(o===hb)return 34041;if(1028===o)return 6403;if(1035===o)return a=t.get("EXT_sRGB"),null!==a?a.SRGB_ALPHA_EXT:null;if(1029===o)return 36244;if(1030===o)return 33319;if(1031===o)return 33320;if(1033===o)return 36249;if(33776===o||33777===o||33778===o||33779===o)if(s===Wr){if(a=t.get("WEBGL_compressed_texture_s3tc_srgb"),null===a)return null;if(33776===o)return a.COMPRESSED_SRGB_S3TC_DXT1_EXT;if(33777===o)return a.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;if(33778===o)return a.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;if(33779===o)return a.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT}else{if(a=t.get("WEBGL_compressed_texture_s3tc"),null===a)return null;if(33776===o)return a.COMPRESSED_RGB_S3TC_DXT1_EXT;if(33777===o)return a.COMPRESSED_RGBA_S3TC_DXT1_EXT;if(33778===o)return a.COMPRESSED_RGBA_S3TC_DXT3_EXT;if(33779===o)return a.COMPRESSED_RGBA_S3TC_DXT5_EXT}if(35840===o||35841===o||35842===o||35843===o){if(a=t.get("WEBGL_compressed_texture_pvrtc"),null===a)return null;if(35840===o)return a.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;if(35841===o)return a.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;if(35842===o)return a.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;if(35843===o)return a.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG}if(36196===o)return a=t.get("WEBGL_compressed_texture_etc1"),null!==a?a.COMPRESSED_RGB_ETC1_WEBGL:null;if(37492===o||37496===o){if(a=t.get("WEBGL_compressed_texture_etc"),null===a)return null;if(37492===o)return s===Wr?a.COMPRESSED_SRGB8_ETC2:a.COMPRESSED_RGB8_ETC2;if(37496===o)return s===Wr?a.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:a.COMPRESSED_RGBA8_ETC2_EAC}if(37808===o||37809===o||37810===o||37811===o||37812===o||37813===o||37814===o||37815===o||37816===o||37817===o||37818===o||37819===o||37820===o||37821===o){if(a=t.get("WEBGL_compressed_texture_astc"),null===a)return null;if(37808===o)return s===Wr?a.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:a.COMPRESSED_RGBA_ASTC_4x4_KHR;if(37809===o)return s===Wr?a.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:a.COMPRESSED_RGBA_ASTC_5x4_KHR;if(37810===o)return s===Wr?a.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:a.COMPRESSED_RGBA_ASTC_5x5_KHR;if(37811===o)return s===Wr?a.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:a.COMPRESSED_RGBA_ASTC_6x5_KHR;if(37812===o)return s===Wr?a.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:a.COMPRESSED_RGBA_ASTC_6x6_KHR;if(37813===o)return s===Wr?a.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:a.COMPRESSED_RGBA_ASTC_8x5_KHR;if(37814===o)return s===Wr?a.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:a.COMPRESSED_RGBA_ASTC_8x6_KHR;if(37815===o)return s===Wr?a.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:a.COMPRESSED_RGBA_ASTC_8x8_KHR;if(37816===o)return s===Wr?a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:a.COMPRESSED_RGBA_ASTC_10x5_KHR;if(37817===o)return s===Wr?a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:a.COMPRESSED_RGBA_ASTC_10x6_KHR;if(37818===o)return s===Wr?a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:a.COMPRESSED_RGBA_ASTC_10x8_KHR;if(37819===o)return s===Wr?a.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:a.COMPRESSED_RGBA_ASTC_10x10_KHR;if(37820===o)return s===Wr?a.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:a.COMPRESSED_RGBA_ASTC_12x10_KHR;if(37821===o)return s===Wr?a.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:a.COMPRESSED_RGBA_ASTC_12x12_KHR}if(36492===o){if(a=t.get("EXT_texture_compression_bptc"),null===a)return null;if(36492===o)return s===Wr?a.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT:a.COMPRESSED_RGBA_BPTC_UNORM_EXT}return o===cb?i?34042:(a=t.get("WEBGL_depth_texture"),null!==a?a.UNSIGNED_INT_24_8_WEBGL:null):void 0}}}hk.prototype.isMeshDistanceMaterial=!0;var fk=class extends Ws{constructor(t=[]){super(),this.cameras=t}};fk.prototype.isArrayCamera=!0;var zg=class extends Xi{constructor(){super(),this.type="Group"}};zg.prototype.isGroup=!0;var m9e={type:"move"},US=class{constructor(){this._targetRay=null,this._grip=null,this._hand=null}getHandSpace(){return null===this._hand&&(this._hand=new zg,this._hand.matrixAutoUpdate=!1,this._hand.visible=!1,this._hand.joints={},this._hand.inputState={pinching:!1}),this._hand}getTargetRaySpace(){return null===this._targetRay&&(this._targetRay=new zg,this._targetRay.matrixAutoUpdate=!1,this._targetRay.visible=!1,this._targetRay.hasLinearVelocity=!1,this._targetRay.linearVelocity=new ie,this._targetRay.hasAngularVelocity=!1,this._targetRay.angularVelocity=new ie),this._targetRay}getGripSpace(){return null===this._grip&&(this._grip=new zg,this._grip.matrixAutoUpdate=!1,this._grip.visible=!1,this._grip.hasLinearVelocity=!1,this._grip.linearVelocity=new ie,this._grip.hasAngularVelocity=!1,this._grip.angularVelocity=new ie),this._grip}dispatchEvent(t){return null!==this._targetRay&&this._targetRay.dispatchEvent(t),null!==this._grip&&this._grip.dispatchEvent(t),null!==this._hand&&this._hand.dispatchEvent(t),this}disconnect(t){return this.dispatchEvent({type:"disconnected",data:t}),null!==this._targetRay&&(this._targetRay.visible=!1),null!==this._grip&&(this._grip.visible=!1),null!==this._hand&&(this._hand.visible=!1),this}update(t,e,i){let r=null,o=null,s=null,a=this._targetRay,l=this._grip,c=this._hand;if(t&&"visible-blurred"!==e.session.visibilityState)if(null!==a&&(r=e.getPose(t.targetRaySpace,i),null!==r&&(a.matrix.fromArray(r.transform.matrix),a.matrix.decompose(a.position,a.rotation,a.scale),r.linearVelocity?(a.hasLinearVelocity=!0,a.linearVelocity.copy(r.linearVelocity)):a.hasLinearVelocity=!1,r.angularVelocity?(a.hasAngularVelocity=!0,a.angularVelocity.copy(r.angularVelocity)):a.hasAngularVelocity=!1,this.dispatchEvent(m9e))),c&&t.hand){s=!0;for(let m of t.hand.values()){let x=e.getJointPose(m,i);if(void 0===c.joints[m.jointName]){let b=new zg;b.matrixAutoUpdate=!1,b.visible=!1,c.joints[m.jointName]=b,c.add(b)}let g=c.joints[m.jointName];null!==x&&(g.matrix.fromArray(x.transform.matrix),g.matrix.decompose(g.position,g.rotation,g.scale),g.jointRadius=x.radius),g.visible=null!==x}let p=c.joints["index-finger-tip"].position.distanceTo(c.joints["thumb-tip"].position),h=.02,f=.005;c.inputState.pinching&&p>h+f?(c.inputState.pinching=!1,this.dispatchEvent({type:"pinchend",handedness:t.handedness,target:this})):!c.inputState.pinching&&p<=h-f&&(c.inputState.pinching=!0,this.dispatchEvent({type:"pinchstart",handedness:t.handedness,target:this}))}else null!==l&&t.gripSpace&&(o=e.getPose(t.gripSpace,i),null!==o&&(l.matrix.fromArray(o.transform.matrix),l.matrix.decompose(l.position,l.rotation,l.scale),o.linearVelocity?(l.hasLinearVelocity=!0,l.linearVelocity.copy(o.linearVelocity)):l.hasLinearVelocity=!1,o.angularVelocity?(l.hasAngularVelocity=!0,l.angularVelocity.copy(o.angularVelocity)):l.hasAngularVelocity=!1));return null!==a&&(a.visible=null!==r),null!==l&&(l.visible=null!==o),null!==c&&(c.visible=null!==s),this}},$S=class extends Ho{constructor(t,e,i,r,o,s,a,l,c,u){if((u=void 0!==u?u:jg)!==jg&&u!==hb)throw new Error("DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat");void 0===i&&u===jg&&(i=WS),void 0===i&&u===hb&&(i=cb),super(null,r,o,s,a,l,u,i,c),this.image={width:t,height:e},this.magFilter=void 0!==a?a:Zo,this.minFilter=void 0!==l?l:Zo,this.flipY=!1,this.generateMipmaps=!1}};$S.prototype.isDepthTexture=!0;var y8=class extends Ep{constructor(t,e){super();let i=this,r=null,o=1,s=null,a="local-floor",l=t.extensions.has("WEBGL_multisampled_render_to_texture"),c=null,u=null,d=null,p=null,h=!1,f=null,m=e.getContextAttributes(),x=null,g=null,b=[],D=new Map,T=new Ws;T.layers.enable(1),T.viewport=new ar;let k=new Ws;k.layers.enable(2),k.viewport=new ar;let Z=[T,k],z=new fk;z.layers.enable(1),z.layers.enable(2);let fe=null,ue=null;function he(ve){let De=D.get(ve.inputSource);De&&De.dispatchEvent({type:ve.type,data:ve.inputSource})}function w(){D.forEach(function(ve,De){ve.disconnect(De)}),D.clear(),fe=null,ue=null,t.setRenderTarget(x),p=null,d=null,u=null,r=null,g=null,Ie.stop(),i.isPresenting=!1,i.dispatchEvent({type:"sessionend"})}function F(ve){let De=r.inputSources;for(let nt=0;nt<b.length;nt++)D.set(De[nt],b[nt]);for(let nt=0;nt<ve.removed.length;nt++){let gt=ve.removed[nt],Ue=D.get(gt);Ue&&(Ue.dispatchEvent({type:"disconnected",data:gt}),D.delete(gt))}for(let nt=0;nt<ve.added.length;nt++){let gt=ve.added[nt],Ue=D.get(gt);Ue&&Ue.dispatchEvent({type:"connected",data:gt})}}this.cameraAutoUpdate=!0,this.enabled=!1,this.isPresenting=!1,this.getController=function(ve){let De=b[ve];return void 0===De&&(De=new US,b[ve]=De),De.getTargetRaySpace()},this.getControllerGrip=function(ve){let De=b[ve];return void 0===De&&(De=new US,b[ve]=De),De.getGripSpace()},this.getHand=function(ve){let De=b[ve];return void 0===De&&(De=new US,b[ve]=De),De.getHandSpace()},this.setFramebufferScaleFactor=function(ve){o=ve,!0===i.isPresenting&&console.warn("THREE.WebXRManager: Cannot change framebuffer scale while presenting.")},this.setReferenceSpaceType=function(ve){a=ve,!0===i.isPresenting&&console.warn("THREE.WebXRManager: Cannot change reference space type while presenting.")},this.getReferenceSpace=function(){return s},this.getBaseLayer=function(){return null!==d?d:p},this.getBinding=function(){return u},this.getFrame=function(){return f},this.getSession=function(){return r},this.setSession=async function(ve){if(r=ve,null!==r){if(x=t.getRenderTarget(),r.addEventListener("select",he),r.addEventListener("selectstart",he),r.addEventListener("selectend",he),r.addEventListener("squeeze",he),r.addEventListener("squeezestart",he),r.addEventListener("squeezeend",he),r.addEventListener("end",w),r.addEventListener("inputsourceschange",F),!0!==m.xrCompatible&&await e.makeXRCompatible(),void 0===r.renderState.layers||!1===t.capabilities.isWebGL2)p=new XRWebGLLayer(r,e,{antialias:void 0!==r.renderState.layers||m.antialias,alpha:m.alpha,depth:m.depth,stencil:m.stencil,framebufferScaleFactor:o}),r.updateRenderState({baseLayer:p}),g=new Wa(p.framebufferWidth,p.framebufferHeight,{format:ga,type:_f,encoding:t.outputEncoding});else{h=m.antialias;let De=null,nt=null,gt=null;m.depth&&(gt=m.stencil?35056:33190,De=m.stencil?hb:jg,nt=m.stencil?cb:WS);let Ue={colorFormat:t.outputEncoding===Wr?35907:32856,depthFormat:gt,scaleFactor:o};u=new XRWebGLBinding(r,e),d=u.createProjectionLayer(Ue),r.updateRenderState({layers:[d]}),g=h?new XS(d.textureWidth,d.textureHeight,{format:ga,type:_f,depthTexture:new $S(d.textureWidth,d.textureHeight,nt,void 0,void 0,void 0,void 0,void 0,void 0,De),stencilBuffer:m.stencil,ignoreDepth:d.ignoreDepthValues,useRenderToTexture:l,encoding:t.outputEncoding}):new Wa(d.textureWidth,d.textureHeight,{format:ga,type:_f,depthTexture:new $S(d.textureWidth,d.textureHeight,nt,void 0,void 0,void 0,void 0,void 0,void 0,De),stencilBuffer:m.stencil,ignoreDepth:d.ignoreDepthValues,encoding:t.outputEncoding})}g.isXRRenderTarget=!0,this.setFoveation(1),s=await r.requestReferenceSpace(a),Ie.setContext(r),Ie.start(),i.isPresenting=!0,i.dispatchEvent({type:"sessionstart"})}};let q=new ie,K=new ie;function Y(ve,De){null===De?ve.matrixWorld.copy(ve.matrix):ve.matrixWorld.multiplyMatrices(De.matrixWorld,ve.matrix),ve.matrixWorldInverse.copy(ve.matrixWorld).invert()}this.updateCamera=function(ve){if(null===r)return;z.near=k.near=T.near=ve.near,z.far=k.far=T.far=ve.far,(fe!==z.near||ue!==z.far)&&(r.updateRenderState({depthNear:z.near,depthFar:z.far}),fe=z.near,ue=z.far);let De=ve.parent,nt=z.cameras;Y(z,De);for(let Ue=0;Ue<nt.length;Ue++)Y(nt[Ue],De);z.matrixWorld.decompose(z.position,z.quaternion,z.scale),ve.position.copy(z.position),ve.quaternion.copy(z.quaternion),ve.scale.copy(z.scale),ve.matrix.copy(z.matrix),ve.matrixWorld.copy(z.matrixWorld);let gt=ve.children;for(let Ue=0,Ae=gt.length;Ue<Ae;Ue++)gt[Ue].updateMatrixWorld(!0);2===nt.length?function(ve,De,nt){q.setFromMatrixPosition(De.matrixWorld),K.setFromMatrixPosition(nt.matrixWorld);let gt=q.distanceTo(K),Ue=De.projectionMatrix.elements,Ae=nt.projectionMatrix.elements,tn=Ue[14]/(Ue[10]-1),pt=Ue[14]/(Ue[10]+1),wt=(Ue[9]+1)/Ue[5],Te=(Ue[9]-1)/Ue[5],xt=(Ue[8]-1)/Ue[0],mt=(Ae[8]+1)/Ae[0],ce=tn*xt,dt=tn*mt,We=gt/(-xt+mt),Mt=We*-xt;De.matrixWorld.decompose(ve.position,ve.quaternion,ve.scale),ve.translateX(Mt),ve.translateZ(We),ve.matrixWorld.compose(ve.position,ve.quaternion,ve.scale),ve.matrixWorldInverse.copy(ve.matrixWorld).invert();let bt=tn+We,hn=pt+We;ve.projectionMatrix.makePerspective(ce-Mt,dt+(gt-Mt),wt*pt/hn*bt,Te*pt/hn*bt,bt,hn)}(z,T,k):z.projectionMatrix.copy(T.projectionMatrix)},this.getCamera=function(){return z},this.getFoveation=function(){return null!==d?d.fixedFoveation:null!==p?p.fixedFoveation:void 0},this.setFoveation=function(ve){null!==d&&(d.fixedFoveation=ve),null!==p&&void 0!==p.fixedFoveation&&(p.fixedFoveation=ve)};let ae=null,Ie=new kde;Ie.setAnimationLoop(function(ve,De){if(c=De.getViewerPose(s),f=De,null!==c){let gt=c.views;null!==p&&(t.setRenderTargetFramebuffer(g,p.framebuffer),t.setRenderTarget(g));let Ue=!1;gt.length!==z.cameras.length&&(z.cameras.length=0,Ue=!0);for(let Ae=0;Ae<gt.length;Ae++){let tn=gt[Ae],pt=null;if(null!==p)pt=p.getViewport(tn);else{let Te=u.getViewSubImage(d,tn);pt=Te.viewport,0===Ae&&(t.setRenderTargetTextures(g,Te.colorTexture,d.ignoreDepthValues?void 0:Te.depthStencilTexture),t.setRenderTarget(g))}let wt=Z[Ae];wt.matrix.fromArray(tn.transform.matrix),wt.projectionMatrix.fromArray(tn.projectionMatrix),wt.viewport.set(pt.x,pt.y,pt.width,pt.height),0===Ae&&z.matrix.copy(wt.matrix),!0===Ue&&z.cameras.push(wt)}}let nt=r.inputSources;for(let gt=0;gt<b.length;gt++)b[gt].update(nt[gt],De,s);ae&&ae(ve,De),f=null}),this.setAnimationLoop=function(ve){ae=ve},this.dispose=function(){}}};function g9e(n){function i(g,b){g.opacity.value=b.opacity,b.color&&g.diffuse.value.copy(b.color),b.emissive&&g.emissive.value.copy(b.emissive).multiplyScalar(b.emissiveIntensity),b.map&&(g.map.value=b.map),b.alphaMap&&(g.alphaMap.value=b.alphaMap),b.specularMap&&(g.specularMap.value=b.specularMap),b.alphaTest>0&&(g.alphaTest.value=b.alphaTest);let T,k,D=n.get(b).envMap;D&&(g.envMap.value=D,g.flipEnvMap.value=D.isCubeTexture&&!1===D.isRenderTargetTexture?-1:1,g.reflectivity.value=b.reflectivity,g.ior.value=b.ior,g.refractionRatio.value=b.refractionRatio),b.lightMap&&(g.lightMap.value=b.lightMap,g.lightMapIntensity.value=b.lightMapIntensity),b.aoMap&&(g.aoMap.value=b.aoMap,g.aoMapIntensity.value=b.aoMapIntensity),b.map?T=b.map:b.specularMap?T=b.specularMap:b.displacementMap?T=b.displacementMap:b.normalMap?T=b.normalMap:b.bumpMap?T=b.bumpMap:b.roughnessMap?T=b.roughnessMap:b.metalnessMap?T=b.metalnessMap:b.alphaMap?T=b.alphaMap:b.emissiveMap?T=b.emissiveMap:b.clearcoatMap?T=b.clearcoatMap:b.clearcoatNormalMap?T=b.clearcoatNormalMap:b.clearcoatRoughnessMap?T=b.clearcoatRoughnessMap:b.specularIntensityMap?T=b.specularIntensityMap:b.specularColorMap?T=b.specularColorMap:b.transmissionMap?T=b.transmissionMap:b.thicknessMap?T=b.thicknessMap:b.sheenColorMap?T=b.sheenColorMap:b.sheenRoughnessMap&&(T=b.sheenRoughnessMap),void 0!==T&&(T.isWebGLRenderTarget&&(T=T.texture),!0===T.matrixAutoUpdate&&T.updateMatrix(),g.uvTransform.value.copy(T.matrix)),b.aoMap?k=b.aoMap:b.lightMap&&(k=b.lightMap),void 0!==k&&(k.isWebGLRenderTarget&&(k=k.texture),!0===k.matrixAutoUpdate&&k.updateMatrix(),g.uv2Transform.value.copy(k.matrix))}function d(g,b){g.roughness.value=b.roughness,g.metalness.value=b.metalness,b.roughnessMap&&(g.roughnessMap.value=b.roughnessMap),b.metalnessMap&&(g.metalnessMap.value=b.metalnessMap),b.emissiveMap&&(g.emissiveMap.value=b.emissiveMap),b.bumpMap&&(g.bumpMap.value=b.bumpMap,g.bumpScale.value=b.bumpScale,1===b.side&&(g.bumpScale.value*=-1)),b.normalMap&&(g.normalMap.value=b.normalMap,g.normalScale.value.copy(b.normalScale),1===b.side&&g.normalScale.value.negate()),b.displacementMap&&(g.displacementMap.value=b.displacementMap,g.displacementScale.value=b.displacementScale,g.displacementBias.value=b.displacementBias),n.get(b).envMap&&(g.envMapIntensity.value=b.envMapIntensity)}return{refreshFogUniforms:function(g,b){g.fogColor.value.copy(b.color),b.isFog?(g.fogNear.value=b.near,g.fogFar.value=b.far):b.isFogExp2&&(g.fogDensity.value=b.density)},refreshMaterialUniforms:function(g,b,D,T,k){b.isMeshBasicMaterial?i(g,b):b.isMeshLambertMaterial?(i(g,b),function(g,b){b.emissiveMap&&(g.emissiveMap.value=b.emissiveMap)}(g,b)):b.isMeshToonMaterial?(i(g,b),function(g,b){b.gradientMap&&(g.gradientMap.value=b.gradientMap),b.emissiveMap&&(g.emissiveMap.value=b.emissiveMap),b.bumpMap&&(g.bumpMap.value=b.bumpMap,g.bumpScale.value=b.bumpScale,1===b.side&&(g.bumpScale.value*=-1)),b.normalMap&&(g.normalMap.value=b.normalMap,g.normalScale.value.copy(b.normalScale),1===b.side&&g.normalScale.value.negate()),b.displacementMap&&(g.displacementMap.value=b.displacementMap,g.displacementScale.value=b.displacementScale,g.displacementBias.value=b.displacementBias)}(g,b)):b.isMeshPhongMaterial?(i(g,b),function(g,b){g.specular.value.copy(b.specular),g.shininess.value=Math.max(b.shininess,1e-4),b.emissiveMap&&(g.emissiveMap.value=b.emissiveMap),b.bumpMap&&(g.bumpMap.value=b.bumpMap,g.bumpScale.value=b.bumpScale,1===b.side&&(g.bumpScale.value*=-1)),b.normalMap&&(g.normalMap.value=b.normalMap,g.normalScale.value.copy(b.normalScale),1===b.side&&g.normalScale.value.negate()),b.displacementMap&&(g.displacementMap.value=b.displacementMap,g.displacementScale.value=b.displacementScale,g.displacementBias.value=b.displacementBias)}(g,b)):b.isMeshStandardMaterial?(i(g,b),b.isMeshPhysicalMaterial?function(g,b,D){d(g,b),g.ior.value=b.ior,b.sheen>0&&(g.sheenColor.value.copy(b.sheenColor).multiplyScalar(b.sheen),g.sheenRoughness.value=b.sheenRoughness,b.sheenColorMap&&(g.sheenColorMap.value=b.sheenColorMap),b.sheenRoughnessMap&&(g.sheenRoughnessMap.value=b.sheenRoughnessMap)),b.clearcoat>0&&(g.clearcoat.value=b.clearcoat,g.clearcoatRoughness.value=b.clearcoatRoughness,b.clearcoatMap&&(g.clearcoatMap.value=b.clearcoatMap),b.clearcoatRoughnessMap&&(g.clearcoatRoughnessMap.value=b.clearcoatRoughnessMap),b.clearcoatNormalMap&&(g.clearcoatNormalScale.value.copy(b.clearcoatNormalScale),g.clearcoatNormalMap.value=b.clearcoatNormalMap,1===b.side&&g.clearcoatNormalScale.value.negate())),b.transmission>0&&(g.transmission.value=b.transmission,g.transmissionSamplerMap.value=D.texture,g.transmissionSamplerSize.value.set(D.width,D.height),b.transmissionMap&&(g.transmissionMap.value=b.transmissionMap),g.thickness.value=b.thickness,b.thicknessMap&&(g.thicknessMap.value=b.thicknessMap),g.attenuationDistance.value=b.attenuationDistance,g.attenuationColor.value.copy(b.attenuationColor)),g.specularIntensity.value=b.specularIntensity,g.specularColor.value.copy(b.specularColor),b.specularIntensityMap&&(g.specularIntensityMap.value=b.specularIntensityMap),b.specularColorMap&&(g.specularColorMap.value=b.specularColorMap)}(g,b,k):d(g,b)):b.isMeshMatcapMaterial?(i(g,b),function(g,b){b.matcap&&(g.matcap.value=b.matcap),b.bumpMap&&(g.bumpMap.value=b.bumpMap,g.bumpScale.value=b.bumpScale,1===b.side&&(g.bumpScale.value*=-1)),b.normalMap&&(g.normalMap.value=b.normalMap,g.normalScale.value.copy(b.normalScale),1===b.side&&g.normalScale.value.negate()),b.displacementMap&&(g.displacementMap.value=b.displacementMap,g.displacementScale.value=b.displacementScale,g.displacementBias.value=b.displacementBias)}(g,b)):b.isMeshDepthMaterial?(i(g,b),function(g,b){b.displacementMap&&(g.displacementMap.value=b.displacementMap,g.displacementScale.value=b.displacementScale,g.displacementBias.value=b.displacementBias)}(g,b)):b.isMeshDistanceMaterial?(i(g,b),function(g,b){b.displacementMap&&(g.displacementMap.value=b.displacementMap,g.displacementScale.value=b.displacementScale,g.displacementBias.value=b.displacementBias),g.referencePosition.value.copy(b.referencePosition),g.nearDistance.value=b.nearDistance,g.farDistance.value=b.farDistance}(g,b)):b.isMeshNormalMaterial?(i(g,b),function(g,b){b.bumpMap&&(g.bumpMap.value=b.bumpMap,g.bumpScale.value=b.bumpScale,1===b.side&&(g.bumpScale.value*=-1)),b.normalMap&&(g.normalMap.value=b.normalMap,g.normalScale.value.copy(b.normalScale),1===b.side&&g.normalScale.value.negate()),b.displacementMap&&(g.displacementMap.value=b.displacementMap,g.displacementScale.value=b.displacementScale,g.displacementBias.value=b.displacementBias)}(g,b)):b.isLineBasicMaterial?(function(g,b){g.diffuse.value.copy(b.color),g.opacity.value=b.opacity}(g,b),b.isLineDashedMaterial&&function(g,b){g.dashSize.value=b.dashSize,g.totalSize.value=b.dashSize+b.gapSize,g.scale.value=b.scale}(g,b)):b.isPointsMaterial?function(g,b,D,T){let k;g.diffuse.value.copy(b.color),g.opacity.value=b.opacity,g.size.value=b.size*D,g.scale.value=.5*T,b.map&&(g.map.value=b.map),b.alphaMap&&(g.alphaMap.value=b.alphaMap),b.alphaTest>0&&(g.alphaTest.value=b.alphaTest),b.map?k=b.map:b.alphaMap&&(k=b.alphaMap),void 0!==k&&(!0===k.matrixAutoUpdate&&k.updateMatrix(),g.uvTransform.value.copy(k.matrix))}(g,b,D,T):b.isSpriteMaterial?function(g,b){let D;g.diffuse.value.copy(b.color),g.opacity.value=b.opacity,g.rotation.value=b.rotation,b.map&&(g.map.value=b.map),b.alphaMap&&(g.alphaMap.value=b.alphaMap),b.alphaTest>0&&(g.alphaTest.value=b.alphaTest),b.map?D=b.map:b.alphaMap&&(D=b.alphaMap),void 0!==D&&(!0===D.matrixAutoUpdate&&D.updateMatrix(),g.uvTransform.value.copy(D.matrix))}(g,b):b.isShadowMaterial?(g.color.value.copy(b.color),g.opacity.value=b.opacity):b.isShaderMaterial&&(b.uniformsNeedUpdate=!1)}}}function ir(n={}){let t=void 0!==n.canvas?n.canvas:function(){let n=YS("canvas");return n.style.display="block",n}(),e=void 0!==n.context?n.context:null,i=void 0!==n.alpha&&n.alpha,r=void 0===n.depth||n.depth,o=void 0===n.stencil||n.stencil,s=void 0!==n.antialias&&n.antialias,a=void 0===n.premultipliedAlpha||n.premultipliedAlpha,l=void 0!==n.preserveDrawingBuffer&&n.preserveDrawingBuffer,c=void 0!==n.powerPreference?n.powerPreference:"default",u=void 0!==n.failIfMajorPerformanceCaveat&&n.failIfMajorPerformanceCaveat,d=null,p=null,h=[],f=[];this.domElement=t,this.debug={checkShaderErrors:!0},this.autoClear=!0,this.autoClearColor=!0,this.autoClearDepth=!0,this.autoClearStencil=!0,this.sortObjects=!0,this.clippingPlanes=[],this.localClippingEnabled=!1,this.outputEncoding=bf,this.physicallyCorrectLights=!1,this.toneMapping=0,this.toneMappingExposure=1;let m=this,x=!1,g=0,b=0,D=null,T=-1,k=null,Z=new ar,z=new ar,fe=null,ue=t.width,he=t.height,w=1,F=null,q=null,K=new ar(0,0,ue,he),de=new ar(0,0,ue,he),Y=!1,ae=new gb,le=!1,Ie=!1,ve=null,De=new Rn,nt=new ie,gt={background:null,fog:null,environment:null,overrideMaterial:null,isScene:!0};function Ue(){return null===D?w:1}let pt,wt,Te,xt,mt,ce,dt,We,Mt,bt,hn,on,fi,Wi,qi,ee,W,Xe,Tt,mn,qe,wn,yn,Ae=e;function tn(I,X){for(let $=0;$<I.length;$++){let me=t.getContext(I[$],X);if(null!==me)return me}return null}try{let I={alpha:!0,depth:r,stencil:o,antialias:s,premultipliedAlpha:a,preserveDrawingBuffer:l,powerPreference:c,failIfMajorPerformanceCaveat:u};if("setAttribute"in t&&t.setAttribute("data-engine","three.js r137"),t.addEventListener("webglcontextlost",Wn,!1),t.addEventListener("webglcontextrestored",ge,!1),null===Ae){let X=["webgl2","webgl","experimental-webgl"];if(!0===m.isWebGL1Renderer&&X.shift(),Ae=tn(X,I),null===Ae)throw tn(X)?new Error("Error creating WebGL context with your selected attributes."):new Error("Error creating WebGL context.")}void 0===Ae.getShaderPrecisionFormat&&(Ae.getShaderPrecisionFormat=function(){return{rangeMin:1,rangeMax:1,precision:1}})}catch(I){throw console.error("THREE.WebGLRenderer: "+I.message),I}function zt(){pt=new VWe(Ae),wt=new OWe(Ae,pt,n),pt.init(wt),wn=new f9e(Ae,pt,wt),Te=new p9e(Ae,pt,wt),xt=new zWe(Ae),mt=new t9e,ce=new h9e(Ae,pt,Te,mt,wt,wn,xt),dt=new FWe(m),We=new BWe(m),Mt=new iGe(Ae,wt),yn=new PWe(Ae,pt,Mt,wt),bt=new HWe(Ae,Mt,xt,yn),hn=new qWe(Ae,bt,Mt,xt),Tt=new WWe(Ae,wt,ce),ee=new kWe(mt),on=new e9e(m,dt,We,pt,wt,yn,ee),fi=new g9e(mt),Wi=new i9e,qi=new c9e(pt,wt),Xe=new IWe(m,dt,Te,hn,i,a),W=new Gde(m,hn,wt),mn=new RWe(Ae,pt,xt,wt),qe=new UWe(Ae,pt,xt,wt),xt.programs=on.programs,m.capabilities=wt,m.extensions=pt,m.properties=mt,m.renderLists=Wi,m.shadowMap=W,m.state=Te,m.info=xt}zt();let Ut=new y8(m,Ae);function Wn(I){I.preventDefault(),console.log("THREE.WebGLRenderer: Context Lost."),x=!0}function ge(){console.log("THREE.WebGLRenderer: Context Restored."),x=!1;let I=xt.autoReset,X=W.enabled,$=W.autoUpdate,ne=W.needsUpdate,me=W.type;zt(),xt.autoReset=I,W.enabled=X,W.autoUpdate=$,W.needsUpdate=ne,W.type=me}function fn(I){let X=I.target;X.removeEventListener("dispose",fn),function(I){(function(I){let X=mt.get(I).programs;void 0!==X&&(X.forEach(function($){on.releaseProgram($)}),I.isShaderMaterial&&on.releaseShaderCache(I))})(I),mt.remove(I)}(X)}this.xr=Ut,this.getContext=function(){return Ae},this.getContextAttributes=function(){return Ae.getContextAttributes()},this.forceContextLoss=function(){let I=pt.get("WEBGL_lose_context");I&&I.loseContext()},this.forceContextRestore=function(){let I=pt.get("WEBGL_lose_context");I&&I.restoreContext()},this.getPixelRatio=function(){return w},this.setPixelRatio=function(I){void 0!==I&&(w=I,this.setSize(ue,he,!1))},this.getSize=function(I){return I.set(ue,he)},this.setSize=function(I,X,$){Ut.isPresenting?console.warn("THREE.WebGLRenderer: Can't change size while VR device is presenting."):(ue=I,he=X,t.width=Math.floor(I*w),t.height=Math.floor(X*w),!1!==$&&(t.style.width=I+"px",t.style.height=X+"px"),this.setViewport(0,0,I,X))},this.getDrawingBufferSize=function(I){return I.set(ue*w,he*w).floor()},this.setDrawingBufferSize=function(I,X,$){ue=I,he=X,w=$,t.width=Math.floor(I*$),t.height=Math.floor(X*$),this.setViewport(0,0,I,X)},this.getCurrentViewport=function(I){return I.copy(Z)},this.getViewport=function(I){return I.copy(K)},this.setViewport=function(I,X,$,ne){I.isVector4?K.set(I.x,I.y,I.z,I.w):K.set(I,X,$,ne),Te.viewport(Z.copy(K).multiplyScalar(w).floor())},this.getScissor=function(I){return I.copy(de)},this.setScissor=function(I,X,$,ne){I.isVector4?de.set(I.x,I.y,I.z,I.w):de.set(I,X,$,ne),Te.scissor(z.copy(de).multiplyScalar(w).floor())},this.getScissorTest=function(){return Y},this.setScissorTest=function(I){Te.setScissorTest(Y=I)},this.setOpaqueSort=function(I){F=I},this.setTransparentSort=function(I){q=I},this.getClearColor=function(I){return I.copy(Xe.getClearColor())},this.setClearColor=function(){Xe.setClearColor.apply(Xe,arguments)},this.getClearAlpha=function(){return Xe.getClearAlpha()},this.setClearAlpha=function(){Xe.setClearAlpha.apply(Xe,arguments)},this.clear=function(I,X,$){let ne=0;(void 0===I||I)&&(ne|=16384),(void 0===X||X)&&(ne|=256),(void 0===$||$)&&(ne|=1024),Ae.clear(ne)},this.clearColor=function(){this.clear(!0,!1,!1)},this.clearDepth=function(){this.clear(!1,!0,!1)},this.clearStencil=function(){this.clear(!1,!1,!0)},this.dispose=function(){t.removeEventListener("webglcontextlost",Wn,!1),t.removeEventListener("webglcontextrestored",ge,!1),Wi.dispose(),qi.dispose(),mt.dispose(),dt.dispose(),We.dispose(),hn.dispose(),yn.dispose(),on.dispose(),Ut.dispose(),Ut.removeEventListener("sessionstart",Mi),Ut.removeEventListener("sessionend",Tr),ve&&(ve.dispose(),ve=null),Es.stop()},this.renderBufferDirect=function(I,X,$,ne,me,Ke){null===X&&(X=gt);let lt=me.isMesh&&me.matrixWorld.determinant()<0,Je=function(I,X,$,ne,me){!0!==X.isScene&&(X=gt),ce.resetTextureUnits();let Ke=X.fog,Je=null===D?m.outputEncoding:!0===D.isXRRenderTarget?D.texture.encoding:bf,ft=(ne.isMeshStandardMaterial?We:dt).get(ne.envMap||(ne.isMeshStandardMaterial?X.environment:null)),Ct=!0===ne.vertexColors&&!!$.attributes.color&&4===$.attributes.color.itemSize,It=!!ne.normalMap&&!!$.attributes.tangent,Nt=!!$.morphAttributes.position,bn=!!$.morphAttributes.normal,rr=$.morphAttributes.position?$.morphAttributes.position.length:0,Ai=ne.toneMapped?m.toneMapping:0,Mn=mt.get(ne),Hn=p.state.lights;!0!==le||!0!==Ie&&I===k||ee.setState(ne,I,I===k&&ne.id===T);let Ot=!1;ne.version===Mn.__version?(Mn.needsLights&&Mn.lightsStateVersion!==Hn.state.version||Mn.outputEncoding!==Je||me.isInstancedMesh&&!1===Mn.instancing||!me.isInstancedMesh&&!0===Mn.instancing||me.isSkinnedMesh&&!1===Mn.skinning||!me.isSkinnedMesh&&!0===Mn.skinning||Mn.envMap!==ft||ne.fog&&Mn.fog!==Ke||void 0!==Mn.numClippingPlanes&&(Mn.numClippingPlanes!==ee.numPlanes||Mn.numIntersection!==ee.numIntersection)||Mn.vertexAlphas!==Ct||Mn.vertexTangents!==It||Mn.morphTargets!==Nt||Mn.morphNormals!==bn||Mn.toneMapping!==Ai||!0===wt.isWebGL2&&Mn.morphTargetsCount!==rr)&&(Ot=!0):(Ot=!0,Mn.__version=ne.version);let wi=Mn.currentProgram;!0===Ot&&(wi=ex(ne,X,me));let ai=!1,Yn=!1,$n=!1,Yt=wi.getUniforms(),Yi=Mn.uniforms;if(Te.useProgram(wi.program)&&(ai=!0,Yn=!0,$n=!0),ne.id!==T&&(T=ne.id,Yn=!0),ai||k!==I){if(Yt.setValue(Ae,"projectionMatrix",I.projectionMatrix),wt.logarithmicDepthBuffer&&Yt.setValue(Ae,"logDepthBufFC",2/(Math.log(I.far+1)/Math.LN2)),k!==I&&(k=I,Yn=!0,$n=!0),ne.isShaderMaterial||ne.isMeshPhongMaterial||ne.isMeshToonMaterial||ne.isMeshStandardMaterial||ne.envMap){let An=Yt.map.cameraPosition;void 0!==An&&An.setValue(Ae,nt.setFromMatrixPosition(I.matrixWorld))}(ne.isMeshPhongMaterial||ne.isMeshToonMaterial||ne.isMeshLambertMaterial||ne.isMeshBasicMaterial||ne.isMeshStandardMaterial||ne.isShaderMaterial)&&Yt.setValue(Ae,"isOrthographic",!0===I.isOrthographicCamera),(ne.isMeshPhongMaterial||ne.isMeshToonMaterial||ne.isMeshLambertMaterial||ne.isMeshBasicMaterial||ne.isMeshStandardMaterial||ne.isShaderMaterial||ne.isShadowMaterial||me.isSkinnedMesh)&&Yt.setValue(Ae,"viewMatrix",I.matrixWorldInverse)}if(me.isSkinnedMesh){Yt.setOptional(Ae,me,"bindMatrix"),Yt.setOptional(Ae,me,"bindMatrixInverse");let An=me.skeleton;An&&(wt.floatVertexTextures?(null===An.boneTexture&&An.computeBoneTexture(),Yt.setValue(Ae,"boneTexture",An.boneTexture,ce),Yt.setValue(Ae,"boneTextureSize",An.boneTextureSize)):Yt.setOptional(Ae,An,"boneMatrices"))}return!!$&&(void 0!==$.morphAttributes.position||void 0!==$.morphAttributes.normal)&&Tt.update(me,$,ne,wi),(Yn||Mn.receiveShadow!==me.receiveShadow)&&(Mn.receiveShadow=me.receiveShadow,Yt.setValue(Ae,"receiveShadow",me.receiveShadow)),Yn&&(Yt.setValue(Ae,"toneMappingExposure",m.toneMappingExposure),Mn.needsLights&&function(I,X){I.ambientLightColor.needsUpdate=X,I.lightProbe.needsUpdate=X,I.directionalLights.needsUpdate=X,I.directionalLightShadows.needsUpdate=X,I.pointLights.needsUpdate=X,I.pointLightShadows.needsUpdate=X,I.spotLights.needsUpdate=X,I.spotLightShadows.needsUpdate=X,I.rectAreaLights.needsUpdate=X,I.hemisphereLights.needsUpdate=X}(Yi,$n),Ke&&ne.fog&&fi.refreshFogUniforms(Yi,Ke),fi.refreshMaterialUniforms(Yi,ne,w,he,ve),yf.upload(Ae,Mn.uniformsList,Yi,ce)),ne.isShaderMaterial&&!0===ne.uniformsNeedUpdate&&(yf.upload(Ae,Mn.uniformsList,Yi,ce),ne.uniformsNeedUpdate=!1),ne.isSpriteMaterial&&Yt.setValue(Ae,"center",me.center),Yt.setValue(Ae,"modelViewMatrix",me.modelViewMatrix),Yt.setValue(Ae,"normalMatrix",me.normalMatrix),Yt.setValue(Ae,"modelMatrix",me.matrixWorld),wi}(I,X,$,ne,me);Te.setMaterial(ne,lt);let ft=$.index,Ct=$.attributes.position;if(null===ft){if(void 0===Ct||0===Ct.count)return}else if(0===ft.count)return;let It=1;!0===ne.wireframe&&(ft=bt.getWireframeAttribute($),It=2),yn.setup(me,ne,Je,$,ft);let Nt,bn=mn;null!==ft&&(Nt=Mt.get(ft),bn=qe,bn.setIndex(Nt));let rr=null!==ft?ft.count:Ct.count,Ai=$.drawRange.start*It,Mn=$.drawRange.count*It,Hn=null!==Ke?Ke.start*It:0,Ot=null!==Ke?Ke.count*It:1/0,wi=Math.max(Ai,Hn),ai=Math.min(rr,Ai+Mn,Hn+Ot)-1,Yn=Math.max(0,ai-wi+1);if(0!==Yn){if(me.isMesh)!0===ne.wireframe?(Te.setLineWidth(ne.wireframeLinewidth*Ue()),bn.setMode(1)):bn.setMode(4);else if(me.isLine){let $n=ne.linewidth;void 0===$n&&($n=1),Te.setLineWidth($n*Ue()),bn.setMode(me.isLineSegments?1:me.isLineLoop?2:3)}else me.isPoints?bn.setMode(0):me.isSprite&&bn.setMode(4);if(me.isInstancedMesh)bn.renderInstances(wi,Yn,me.count);else if($.isInstancedBufferGeometry){let $n=Math.min($.instanceCount,$._maxInstanceCount);bn.renderInstances(wi,Yn,$n)}else bn.render(wi,Yn)}},this.compile=function(I,X){p=qi.get(I),p.init(),f.push(p),I.traverseVisible(function($){$.isLight&&$.layers.test(X.layers)&&(p.pushLight($),$.castShadow&&p.pushShadow($))}),p.setupLights(m.physicallyCorrectLights),I.traverse(function($){let ne=$.material;if(ne)if(Array.isArray(ne))for(let me=0;me<ne.length;me++)ex(ne[me],I,$);else ex(ne,I,$)}),f.pop(),p=null};let Ze=null;function Mi(){Es.stop()}function Tr(){Es.start()}let Es=new kde;function Br(I,X,$,ne){if(!1===I.visible)return;if(I.layers.test(X.layers))if(I.isGroup)$=I.renderOrder;else if(I.isLOD)!0===I.autoUpdate&&I.update(X);else if(I.isLight)p.pushLight(I),I.castShadow&&p.pushShadow(I);else if(I.isSprite){if(!I.frustumCulled||ae.intersectsSprite(I)){ne&&nt.setFromMatrixPosition(I.matrixWorld).applyMatrix4(De);let lt=hn.update(I),Je=I.material;Je.visible&&d.push(I,lt,Je,$,nt.z,null)}}else if((I.isMesh||I.isLine||I.isPoints)&&(I.isSkinnedMesh&&I.skeleton.frame!==xt.render.frame&&(I.skeleton.update(),I.skeleton.frame=xt.render.frame),!I.frustumCulled||ae.intersectsObject(I))){ne&&nt.setFromMatrixPosition(I.matrixWorld).applyMatrix4(De);let lt=hn.update(I),Je=I.material;if(Array.isArray(Je)){let ft=lt.groups;for(let Ct=0,It=ft.length;Ct<It;Ct++){let Nt=ft[Ct],bn=Je[Nt.materialIndex];bn&&bn.visible&&d.push(I,lt,bn,$,nt.z,Nt)}}else Je.visible&&d.push(I,lt,Je,$,nt.z,null)}let Ke=I.children;for(let lt=0,Je=Ke.length;lt<Je;lt++)Br(Ke[lt],X,$,ne)}function Pl(I,X,$,ne){let me=I.opaque,Ke=I.transmissive,lt=I.transparent;p.setupLightsView($),Ke.length>0&&function(I,X,$){null===ve&&(ve=new(!0===s&&!0===wt.isWebGL2?XS:Wa)(1024,1024,{generateMipmaps:!0,type:null!==wn.convert(lb)?lb:_f,minFilter:1008,magFilter:Zo,wrapS:El,wrapT:El,useRenderToTexture:pt.has("WEBGL_multisampled_render_to_texture")}));let ne=m.getRenderTarget();m.setRenderTarget(ve),m.clear();let me=m.toneMapping;m.toneMapping=0,bc(I,X,$),m.toneMapping=me,ce.updateMultisampleRenderTarget(ve),ce.updateRenderTargetMipmap(ve),m.setRenderTarget(ne)}(me,X,$),ne&&Te.viewport(Z.copy(ne)),me.length>0&&bc(me,X,$),Ke.length>0&&bc(Ke,X,$),lt.length>0&&bc(lt,X,$)}function bc(I,X,$){let ne=!0===X.isScene?X.overrideMaterial:null;for(let me=0,Ke=I.length;me<Ke;me++){let lt=I[me],Je=lt.object,ft=lt.geometry,Ct=null===ne?lt.material:ne,It=lt.group;Je.layers.test($.layers)&&iN(Je,X,$,ft,Ct,It)}}function iN(I,X,$,ne,me,Ke){I.onBeforeRender(m,X,$,ne,me,Ke),I.modelViewMatrix.multiplyMatrices($.matrixWorldInverse,I.matrixWorld),I.normalMatrix.getNormalMatrix(I.modelViewMatrix),me.onBeforeRender(m,X,$,ne,I,Ke),!0===me.transparent&&2===me.side?(me.side=1,me.needsUpdate=!0,m.renderBufferDirect($,X,ne,me,I,Ke),me.side=0,me.needsUpdate=!0,m.renderBufferDirect($,X,ne,me,I,Ke),me.side=2):m.renderBufferDirect($,X,ne,me,I,Ke),I.onAfterRender(m,X,$,ne,me,Ke)}function ex(I,X,$){!0!==X.isScene&&(X=gt);let ne=mt.get(I),me=p.state.lights,lt=me.state.version,Je=on.getParameters(I,me.state,p.state.shadowsArray,X,$),ft=on.getProgramCacheKey(Je),Ct=ne.programs;ne.environment=I.isMeshStandardMaterial?X.environment:null,ne.fog=X.fog,ne.envMap=(I.isMeshStandardMaterial?We:dt).get(I.envMap||ne.environment),void 0===Ct&&(I.addEventListener("dispose",fn),Ct=new Map,ne.programs=Ct);let It=Ct.get(ft);if(void 0!==It){if(ne.currentProgram===It&&ne.lightsStateVersion===lt)return FE(I,Je),It}else Je.uniforms=on.getUniforms(I),I.onBuild($,Je,m),I.onBeforeCompile(Je,m),It=on.acquireProgram(Je,ft),Ct.set(ft,It),ne.uniforms=Je.uniforms;let Nt=ne.uniforms;(!I.isShaderMaterial&&!I.isRawShaderMaterial||!0===I.clipping)&&(Nt.clippingPlanes=ee.uniform),FE(I,Je),ne.needsLights=function(I){return I.isMeshLambertMaterial||I.isMeshToonMaterial||I.isMeshPhongMaterial||I.isMeshStandardMaterial||I.isShadowMaterial||I.isShaderMaterial&&!0===I.lights}(I),ne.lightsStateVersion=lt,ne.needsLights&&(Nt.ambientLightColor.value=me.state.ambient,Nt.lightProbe.value=me.state.probe,Nt.directionalLights.value=me.state.directional,Nt.directionalLightShadows.value=me.state.directionalShadow,Nt.spotLights.value=me.state.spot,Nt.spotLightShadows.value=me.state.spotShadow,Nt.rectAreaLights.value=me.state.rectArea,Nt.ltc_1.value=me.state.rectAreaLTC1,Nt.ltc_2.value=me.state.rectAreaLTC2,Nt.pointLights.value=me.state.point,Nt.pointLightShadows.value=me.state.pointShadow,Nt.hemisphereLights.value=me.state.hemi,Nt.directionalShadowMap.value=me.state.directionalShadowMap,Nt.directionalShadowMatrix.value=me.state.directionalShadowMatrix,Nt.spotShadowMap.value=me.state.spotShadowMap,Nt.spotShadowMatrix.value=me.state.spotShadowMatrix,Nt.pointShadowMap.value=me.state.pointShadowMap,Nt.pointShadowMatrix.value=me.state.pointShadowMatrix);let bn=It.getUniforms(),rr=yf.seqWithValue(bn.seq,Nt);return ne.currentProgram=It,ne.uniformsList=rr,It}function FE(I,X){let $=mt.get(I);$.outputEncoding=X.outputEncoding,$.instancing=X.instancing,$.skinning=X.skinning,$.morphTargets=X.morphTargets,$.morphNormals=X.morphNormals,$.morphTargetsCount=X.morphTargetsCount,$.numClippingPlanes=X.numClippingPlanes,$.numIntersection=X.numClipIntersection,$.vertexAlphas=X.vertexAlphas,$.vertexTangents=X.vertexTangents,$.toneMapping=X.toneMapping}Es.setAnimationLoop(function(I){Ze&&Ze(I)}),typeof window<"u"&&Es.setContext(window),this.setAnimationLoop=function(I){Ze=I,Ut.setAnimationLoop(I),null===I?Es.stop():Es.start()},Ut.addEventListener("sessionstart",Mi),Ut.addEventListener("sessionend",Tr),this.render=function(I,X){if(void 0===X||!0===X.isCamera){if(!0!==x){if(!0===I.autoUpdate&&I.updateMatrixWorld(),null===X.parent&&X.updateMatrixWorld(),!0===Ut.enabled&&!0===Ut.isPresenting&&(!0===Ut.cameraAutoUpdate&&Ut.updateCamera(X),X=Ut.getCamera()),!0===I.isScene&&I.onBeforeRender(m,I,X,D),p=qi.get(I,f.length),p.init(),f.push(p),De.multiplyMatrices(X.projectionMatrix,X.matrixWorldInverse),ae.setFromProjectionMatrix(De),Ie=this.localClippingEnabled,le=ee.init(this.clippingPlanes,Ie,X),d=Wi.get(I,h.length),d.init(),h.push(d),Br(I,X,0,m.sortObjects),d.finish(),!0===m.sortObjects&&d.sort(F,q),!0===le&&ee.beginShadows(),W.render(p.state.shadowsArray,I,X),!0===le&&ee.endShadows(),!0===this.info.autoReset&&this.info.reset(),Xe.render(d,I),p.setupLights(m.physicallyCorrectLights),X.isArrayCamera){let ne=X.cameras;for(let me=0,Ke=ne.length;me<Ke;me++){let lt=ne[me];Pl(d,I,lt,lt.viewport)}}else Pl(d,I,X);null!==D&&(ce.updateMultisampleRenderTarget(D),ce.updateRenderTargetMipmap(D)),!0===I.isScene&&I.onAfterRender(m,I,X),Te.buffers.depth.setTest(!0),Te.buffers.depth.setMask(!0),Te.buffers.color.setMask(!0),Te.setPolygonOffset(!1),yn.resetDefaultState(),T=-1,k=null,f.pop(),p=f.length>0?f[f.length-1]:null,h.pop(),d=h.length>0?h[h.length-1]:null}}else console.error("THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.")},this.getActiveCubeFace=function(){return g},this.getActiveMipmapLevel=function(){return b},this.getRenderTarget=function(){return D},this.setRenderTargetTextures=function(I,X,$){mt.get(I.texture).__webglTexture=X,mt.get(I.depthTexture).__webglTexture=$;let ne=mt.get(I);ne.__hasExternalTextures=!0,ne.__hasExternalTextures&&(ne.__autoAllocateDepthBuffer=void 0===$,ne.__autoAllocateDepthBuffer||I.useRenderToTexture&&(console.warn("render-to-texture extension was disabled because an external texture was provided"),I.useRenderToTexture=!1,I.useRenderbuffer=!0))},this.setRenderTargetFramebuffer=function(I,X){let $=mt.get(I);$.__webglFramebuffer=X,$.__useDefaultFramebuffer=void 0===X},this.setRenderTarget=function(I,X=0,$=0){D=I,g=X,b=$;let ne=!0;if(I){let ft=mt.get(I);void 0!==ft.__useDefaultFramebuffer?(Te.bindFramebuffer(36160,null),ne=!1):void 0===ft.__webglFramebuffer?ce.setupRenderTarget(I):ft.__hasExternalTextures&&ce.rebindTextures(I,mt.get(I.texture).__webglTexture,mt.get(I.depthTexture).__webglTexture)}let me=null,Ke=!1,lt=!1;if(I){let ft=I.texture;(ft.isDataTexture3D||ft.isDataTexture2DArray)&&(lt=!0);let Ct=mt.get(I).__webglFramebuffer;I.isWebGLCubeRenderTarget?(me=Ct[X],Ke=!0):me=I.useRenderbuffer?mt.get(I).__webglMultisampledFramebuffer:Ct,Z.copy(I.viewport),z.copy(I.scissor),fe=I.scissorTest}else Z.copy(K).multiplyScalar(w).floor(),z.copy(de).multiplyScalar(w).floor(),fe=Y;if(Te.bindFramebuffer(36160,me)&&wt.drawBuffers&&ne&&Te.drawBuffers(I,me),Te.viewport(Z),Te.scissor(z),Te.setScissorTest(fe),Ke){let ft=mt.get(I.texture);Ae.framebufferTexture2D(36160,36064,34069+X,ft.__webglTexture,$)}else if(lt){let ft=mt.get(I.texture);Ae.framebufferTextureLayer(36160,36064,ft.__webglTexture,$||0,X||0)}T=-1},this.readRenderTargetPixels=function(I,X,$,ne,me,Ke,lt){if(!I||!I.isWebGLRenderTarget)return void console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.");let Je=mt.get(I).__webglFramebuffer;if(I.isWebGLCubeRenderTarget&&void 0!==lt&&(Je=Je[lt]),Je){Te.bindFramebuffer(36160,Je);try{let ft=I.texture,Ct=ft.format,It=ft.type;if(Ct!==ga&&wn.convert(Ct)!==Ae.getParameter(35739))return void console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.");let Nt=It===lb&&(pt.has("EXT_color_buffer_half_float")||wt.isWebGL2&&pt.has("EXT_color_buffer_float"));if(!(It===_f||wn.convert(It)===Ae.getParameter(35738)||It===Ug&&(wt.isWebGL2||pt.has("OES_texture_float")||pt.has("WEBGL_color_buffer_float"))||Nt))return void console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.");36053===Ae.checkFramebufferStatus(36160)?X>=0&&X<=I.width-ne&&$>=0&&$<=I.height-me&&Ae.readPixels(X,$,ne,me,wn.convert(Ct),wn.convert(It),Ke):console.error("THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete.")}finally{let ft=null!==D?mt.get(D).__webglFramebuffer:null;Te.bindFramebuffer(36160,ft)}}},this.copyFramebufferToTexture=function(I,X,$=0){if(!0!==X.isFramebufferTexture)return void console.error("THREE.WebGLRenderer: copyFramebufferToTexture() can only be used with FramebufferTexture.");let ne=Math.pow(2,-$),me=Math.floor(X.image.width*ne),Ke=Math.floor(X.image.height*ne);ce.setTexture2D(X,0),Ae.copyTexSubImage2D(3553,$,0,0,I.x,I.y,me,Ke),Te.unbindTexture()},this.copyTextureToTexture=function(I,X,$,ne=0){let me=X.image.width,Ke=X.image.height,lt=wn.convert($.format),Je=wn.convert($.type);ce.setTexture2D($,0),Ae.pixelStorei(37440,$.flipY),Ae.pixelStorei(37441,$.premultiplyAlpha),Ae.pixelStorei(3317,$.unpackAlignment),X.isDataTexture?Ae.texSubImage2D(3553,ne,I.x,I.y,me,Ke,lt,Je,X.image.data):X.isCompressedTexture?Ae.compressedTexSubImage2D(3553,ne,I.x,I.y,X.mipmaps[0].width,X.mipmaps[0].height,lt,X.mipmaps[0].data):Ae.texSubImage2D(3553,ne,I.x,I.y,lt,Je,X.image),0===ne&&$.generateMipmaps&&Ae.generateMipmap(3553),Te.unbindTexture()},this.copyTextureToTexture3D=function(I,X,$,ne,me=0){if(m.isWebGL1Renderer)return void console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: can only be used with WebGL2.");let It,Ke=I.max.x-I.min.x+1,lt=I.max.y-I.min.y+1,Je=I.max.z-I.min.z+1,ft=wn.convert(ne.format),Ct=wn.convert(ne.type);if(ne.isDataTexture3D)ce.setTexture3D(ne,0),It=32879;else{if(!ne.isDataTexture2DArray)return void console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: only supports THREE.DataTexture3D and THREE.DataTexture2DArray.");ce.setTexture2DArray(ne,0),It=35866}Ae.pixelStorei(37440,ne.flipY),Ae.pixelStorei(37441,ne.premultiplyAlpha),Ae.pixelStorei(3317,ne.unpackAlignment);let Nt=Ae.getParameter(3314),bn=Ae.getParameter(32878),rr=Ae.getParameter(3316),Ai=Ae.getParameter(3315),Mn=Ae.getParameter(32877),Hn=$.isCompressedTexture?$.mipmaps[0]:$.image;Ae.pixelStorei(3314,Hn.width),Ae.pixelStorei(32878,Hn.height),Ae.pixelStorei(3316,I.min.x),Ae.pixelStorei(3315,I.min.y),Ae.pixelStorei(32877,I.min.z),$.isDataTexture||$.isDataTexture3D?Ae.texSubImage3D(It,me,X.x,X.y,X.z,Ke,lt,Je,ft,Ct,Hn.data):$.isCompressedTexture?(console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: untested support for compressed srcTexture."),Ae.compressedTexSubImage3D(It,me,X.x,X.y,X.z,Ke,lt,Je,ft,Hn.data)):Ae.texSubImage3D(It,me,X.x,X.y,X.z,Ke,lt,Je,ft,Ct,Hn),Ae.pixelStorei(3314,Nt),Ae.pixelStorei(32878,bn),Ae.pixelStorei(3316,rr),Ae.pixelStorei(3315,Ai),Ae.pixelStorei(32877,Mn),0===me&&ne.generateMipmaps&&Ae.generateMipmap(It),Te.unbindTexture()},this.initTexture=function(I){ce.setTexture2D(I,0),Te.unbindTexture()},this.resetState=function(){g=0,b=0,D=null,Te.reset(),yn.reset()},typeof __THREE_DEVTOOLS__<"u"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}ir.prototype.isWebGLRenderer=!0,class extends ir{}.prototype.isWebGL1Renderer=!0;var eE=class{constructor(t,e=25e-5){this.name="",this.color=new vn(t),this.density=e}clone(){return new eE(this.color,this.density)}toJSON(){return{type:"FogExp2",color:this.color.getHex(),density:this.density}}};eE.prototype.isFogExp2=!0;var tE=class{constructor(t,e=1,i=1e3){this.name="",this.color=new vn(t),this.near=e,this.far=i}clone(){return new tE(this.color,this.near,this.far)}toJSON(){return{type:"Fog",color:this.color.getHex(),near:this.near,far:this.far}}};tE.prototype.isFog=!0;var vb=class extends Xi{constructor(){super(),this.type="Scene",this.background=null,this.environment=null,this.fog=null,this.overrideMaterial=null,this.autoUpdate=!0,typeof __THREE_DEVTOOLS__<"u"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}copy(t,e){return super.copy(t,e),null!==t.background&&(this.background=t.background.clone()),null!==t.environment&&(this.environment=t.environment.clone()),null!==t.fog&&(this.fog=t.fog.clone()),null!==t.overrideMaterial&&(this.overrideMaterial=t.overrideMaterial.clone()),this.autoUpdate=t.autoUpdate,this.matrixAutoUpdate=t.matrixAutoUpdate,this}toJSON(t){let e=super.toJSON(t);return null!==this.fog&&(e.object.fog=this.fog.toJSON()),e}};vb.prototype.isScene=!0;var Yg=class{constructor(t,e){this.array=t,this.stride=e,this.count=void 0!==t?t.length/e:0,this.usage=qS,this.updateRange={offset:0,count:-1},this.version=0,this.uuid=du()}onUploadCallback(){}set needsUpdate(t){!0===t&&this.version++}setUsage(t){return this.usage=t,this}copy(t){return this.array=new t.array.constructor(t.array),this.count=t.count,this.stride=t.stride,this.usage=t.usage,this}copyAt(t,e,i){t*=this.stride,i*=e.stride;for(let r=0,o=this.stride;r<o;r++)this.array[t+r]=e.array[i+r];return this}set(t,e=0){return this.array.set(t,e),this}clone(t){void 0===t.arrayBuffers&&(t.arrayBuffers={}),void 0===this.array.buffer._uuid&&(this.array.buffer._uuid=du()),void 0===t.arrayBuffers[this.array.buffer._uuid]&&(t.arrayBuffers[this.array.buffer._uuid]=this.array.slice(0).buffer);let e=new this.array.constructor(t.arrayBuffers[this.array.buffer._uuid]),i=new this.constructor(e,this.stride);return i.setUsage(this.usage),i}onUpload(t){return this.onUploadCallback=t,this}toJSON(t){return void 0===t.arrayBuffers&&(t.arrayBuffers={}),void 0===this.array.buffer._uuid&&(this.array.buffer._uuid=du()),void 0===t.arrayBuffers[this.array.buffer._uuid]&&(t.arrayBuffers[this.array.buffer._uuid]=Array.prototype.slice.call(new Uint32Array(this.array.buffer))),{uuid:this.uuid,buffer:this.array.buffer._uuid,type:this.array.constructor.name,stride:this.stride}}};Yg.prototype.isInterleavedBuffer=!0;var Co=new ie,Xg=class{constructor(t,e,i,r=!1){this.name="",this.data=t,this.itemSize=e,this.offset=i,this.normalized=!0===r}get count(){return this.data.count}get array(){return this.data.array}set needsUpdate(t){this.data.needsUpdate=t}applyMatrix4(t){for(let e=0,i=this.data.count;e<i;e++)Co.x=this.getX(e),Co.y=this.getY(e),Co.z=this.getZ(e),Co.applyMatrix4(t),this.setXYZ(e,Co.x,Co.y,Co.z);return this}applyNormalMatrix(t){for(let e=0,i=this.count;e<i;e++)Co.x=this.getX(e),Co.y=this.getY(e),Co.z=this.getZ(e),Co.applyNormalMatrix(t),this.setXYZ(e,Co.x,Co.y,Co.z);return this}transformDirection(t){for(let e=0,i=this.count;e<i;e++)Co.x=this.getX(e),Co.y=this.getY(e),Co.z=this.getZ(e),Co.transformDirection(t),this.setXYZ(e,Co.x,Co.y,Co.z);return this}setX(t,e){return this.data.array[t*this.data.stride+this.offset]=e,this}setY(t,e){return this.data.array[t*this.data.stride+this.offset+1]=e,this}setZ(t,e){return this.data.array[t*this.data.stride+this.offset+2]=e,this}setW(t,e){return this.data.array[t*this.data.stride+this.offset+3]=e,this}getX(t){return this.data.array[t*this.data.stride+this.offset]}getY(t){return this.data.array[t*this.data.stride+this.offset+1]}getZ(t){return this.data.array[t*this.data.stride+this.offset+2]}getW(t){return this.data.array[t*this.data.stride+this.offset+3]}setXY(t,e,i){return this.data.array[(t=t*this.data.stride+this.offset)+0]=e,this.data.array[t+1]=i,this}setXYZ(t,e,i,r){return this.data.array[(t=t*this.data.stride+this.offset)+0]=e,this.data.array[t+1]=i,this.data.array[t+2]=r,this}setXYZW(t,e,i,r,o){return this.data.array[(t=t*this.data.stride+this.offset)+0]=e,this.data.array[t+1]=i,this.data.array[t+2]=r,this.data.array[t+3]=o,this}clone(t){if(void 0===t){console.log("THREE.InterleavedBufferAttribute.clone(): Cloning an interlaved buffer attribute will deinterleave buffer data.");let e=[];for(let i=0;i<this.count;i++){let r=i*this.data.stride+this.offset;for(let o=0;o<this.itemSize;o++)e.push(this.data.array[r+o])}return new Yr(new this.array.constructor(e),this.itemSize,this.normalized)}return void 0===t.interleavedBuffers&&(t.interleavedBuffers={}),void 0===t.interleavedBuffers[this.data.uuid]&&(t.interleavedBuffers[this.data.uuid]=this.data.clone(t)),new Xg(t.interleavedBuffers[this.data.uuid],this.itemSize,this.offset,this.normalized)}toJSON(t){if(void 0===t){console.log("THREE.InterleavedBufferAttribute.toJSON(): Serializing an interlaved buffer attribute will deinterleave buffer data.");let e=[];for(let i=0;i<this.count;i++){let r=i*this.data.stride+this.offset;for(let o=0;o<this.itemSize;o++)e.push(this.data.array[r+o])}return{itemSize:this.itemSize,type:this.array.constructor.name,array:e,normalized:this.normalized}}return void 0===t.interleavedBuffers&&(t.interleavedBuffers={}),void 0===t.interleavedBuffers[this.data.uuid]&&(t.interleavedBuffers[this.data.uuid]=this.data.toJSON(t)),{isInterleavedBufferAttribute:!0,itemSize:this.itemSize,data:this.data.uuid,offset:this.offset,normalized:this.normalized}}};Xg.prototype.isInterleavedBufferAttribute=!0;var mk=class extends hs{constructor(t){super(),this.type="SpriteMaterial",this.color=new vn(16777215),this.map=null,this.alphaMap=null,this.rotation=0,this.sizeAttenuation=!0,this.transparent=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.rotation=t.rotation,this.sizeAttenuation=t.sizeAttenuation,this}};mk.prototype.isSpriteMaterial=!0;var eb,OS=new ie,tb=new ie,nb=new ie,ib=new at,kS=new at,Wde=new Rn,zO=new ie,FS=new ie,jO=new ie,nde=new at,e8=new at,ide=new at;function GO(n,t,e,i,r,o){ib.subVectors(n,e).addScalar(.5).multiply(i),void 0!==r?(kS.x=o*ib.x-r*ib.y,kS.y=r*ib.x+o*ib.y):kS.copy(ib),n.copy(t),n.x+=kS.x,n.y+=kS.y,n.applyMatrix4(Wde)}(class extends Xi{constructor(t){if(super(),this.type="Sprite",void 0===eb){eb=new nr;let e=new Float32Array([-.5,-.5,0,0,0,.5,-.5,0,1,0,.5,.5,0,1,1,-.5,.5,0,0,1]),i=new Yg(e,5);eb.setIndex([0,1,2,0,2,3]),eb.setAttribute("position",new Xg(i,3,0,!1)),eb.setAttribute("uv",new Xg(i,2,3,!1))}this.geometry=eb,this.material=void 0!==t?t:new mk,this.center=new at(.5,.5)}raycast(t,e){null===t.camera&&console.error('THREE.Sprite: "Raycaster.camera" needs to be set in order to raycast against sprites.'),tb.setFromMatrixScale(this.matrixWorld),Wde.copy(t.camera.matrixWorld),this.modelViewMatrix.multiplyMatrices(t.camera.matrixWorldInverse,this.matrixWorld),nb.setFromMatrixPosition(this.modelViewMatrix),t.camera.isPerspectiveCamera&&!1===this.material.sizeAttenuation&&tb.multiplyScalar(-nb.z);let r,o,i=this.material.rotation;0!==i&&(o=Math.cos(i),r=Math.sin(i));let s=this.center;GO(zO.set(-.5,-.5,0),nb,s,tb,r,o),GO(FS.set(.5,-.5,0),nb,s,tb,r,o),GO(jO.set(.5,.5,0),nb,s,tb,r,o),nde.set(0,0),e8.set(1,0),ide.set(1,1);let a=t.ray.intersectTriangle(zO,FS,jO,!1,OS);if(null===a&&(GO(FS.set(-.5,.5,0),nb,s,tb,r,o),e8.set(0,1),a=t.ray.intersectTriangle(zO,jO,FS,!1,OS),null===a))return;let l=t.ray.origin.distanceTo(OS);l<t.near||l>t.far||e.push({distance:l,point:OS.clone(),uv:lo.getUV(OS,zO,FS,jO,nde,e8,ide,new at),face:null,object:this})}copy(t){return super.copy(t),void 0!==t.center&&this.center.copy(t.center),this.material=t.material,this}}).prototype.isSprite=!0;var rde=new ie,ode=new ar,sde=new ar,v9e=new ie,ade=new Rn,gk=class extends Vo{constructor(t,e){super(t,e),this.type="SkinnedMesh",this.bindMode="attached",this.bindMatrix=new Rn,this.bindMatrixInverse=new Rn}copy(t){return super.copy(t),this.bindMode=t.bindMode,this.bindMatrix.copy(t.bindMatrix),this.bindMatrixInverse.copy(t.bindMatrixInverse),this.skeleton=t.skeleton,this}bind(t,e){this.skeleton=t,void 0===e&&(this.updateMatrixWorld(!0),this.skeleton.calculateInverses(),e=this.matrixWorld),this.bindMatrix.copy(e),this.bindMatrixInverse.copy(e).invert()}pose(){this.skeleton.pose()}normalizeSkinWeights(){let t=new ar,e=this.geometry.attributes.skinWeight;for(let i=0,r=e.count;i<r;i++){t.x=e.getX(i),t.y=e.getY(i),t.z=e.getZ(i),t.w=e.getW(i);let o=1/t.manhattanLength();o!==1/0?t.multiplyScalar(o):t.set(1,0,0,0),e.setXYZW(i,t.x,t.y,t.z,t.w)}}updateMatrixWorld(t){super.updateMatrixWorld(t),"attached"===this.bindMode?this.bindMatrixInverse.copy(this.matrixWorld).invert():"detached"===this.bindMode?this.bindMatrixInverse.copy(this.bindMatrix).invert():console.warn("THREE.SkinnedMesh: Unrecognized bindMode: "+this.bindMode)}boneTransform(t,e){let i=this.skeleton,r=this.geometry;ode.fromBufferAttribute(r.attributes.skinIndex,t),sde.fromBufferAttribute(r.attributes.skinWeight,t),rde.copy(e).applyMatrix4(this.bindMatrix),e.set(0,0,0);for(let o=0;o<4;o++){let s=sde.getComponent(o);if(0!==s){let a=ode.getComponent(o);ade.multiplyMatrices(i.bones[a].matrixWorld,i.boneInverses[a]),e.addScaledVector(v9e.copy(rde).applyMatrix4(ade),s)}}return e.applyMatrix4(this.bindMatrixInverse)}};gk.prototype.isSkinnedMesh=!0,class extends Xi{constructor(){super(),this.type="Bone"}}.prototype.isBone=!0,class extends Ho{constructor(t=null,e=1,i=1,r,o,s,a,l,c=Zo,u=Zo,d,p){super(null,s,a,l,c,u,r,o,d,p),this.image={data:t,width:e,height:i},this.magFilter=c,this.minFilter=u,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1}}.prototype.isDataTexture=!0;var nE=class extends Yr{constructor(t,e,i,r=1){"number"==typeof i&&(r=i,i=!1,console.error("THREE.InstancedBufferAttribute: The constructor now expects normalized as the third argument.")),super(t,e,i),this.meshPerAttribute=r}copy(t){return super.copy(t),this.meshPerAttribute=t.meshPerAttribute,this}toJSON(){let t=super.toJSON();return t.meshPerAttribute=this.meshPerAttribute,t.isInstancedBufferAttribute=!0,t}};nE.prototype.isInstancedBufferAttribute=!0;var lde=new Rn,cde=new Rn,WO=[],NS=new Vo;(class extends Vo{constructor(t,e,i){super(t,e),this.instanceMatrix=new nE(new Float32Array(16*i),16),this.instanceColor=null,this.count=i,this.frustumCulled=!1}copy(t){return super.copy(t),this.instanceMatrix.copy(t.instanceMatrix),null!==t.instanceColor&&(this.instanceColor=t.instanceColor.clone()),this.count=t.count,this}getColorAt(t,e){e.fromArray(this.instanceColor.array,3*t)}getMatrixAt(t,e){e.fromArray(this.instanceMatrix.array,16*t)}raycast(t,e){let i=this.matrixWorld,r=this.count;if(NS.geometry=this.geometry,NS.material=this.material,void 0!==NS.material)for(let o=0;o<r;o++){this.getMatrixAt(o,lde),cde.multiplyMatrices(i,lde),NS.matrixWorld=cde,NS.raycast(t,WO);for(let s=0,a=WO.length;s<a;s++){let l=WO[s];l.instanceId=o,l.object=this,e.push(l)}WO.length=0}}setColorAt(t,e){null===this.instanceColor&&(this.instanceColor=new nE(new Float32Array(3*this.instanceMatrix.count),3)),e.toArray(this.instanceColor.array,3*t)}setMatrixAt(t,e){e.toArray(this.instanceMatrix.array,16*t)}updateMorphTargets(){}dispose(){this.dispatchEvent({type:"dispose"})}}).prototype.isInstancedMesh=!0;var Ap=class extends hs{constructor(t){super(),this.type="LineBasicMaterial",this.color=new vn(16777215),this.linewidth=1,this.linecap="round",this.linejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.linewidth=t.linewidth,this.linecap=t.linecap,this.linejoin=t.linejoin,this}};Ap.prototype.isLineBasicMaterial=!0;var ude=new ie,dde=new ie,pde=new Rn,t8=new Cf,qO=new xf,iE=class extends Xi{constructor(t=new nr,e=new Ap){super(),this.type="Line",this.geometry=t,this.material=e,this.updateMorphTargets()}copy(t){return super.copy(t),this.material=t.material,this.geometry=t.geometry,this}computeLineDistances(){let t=this.geometry;if(t.isBufferGeometry)if(null===t.index){let e=t.attributes.position,i=[0];for(let r=1,o=e.count;r<o;r++)ude.fromBufferAttribute(e,r-1),dde.fromBufferAttribute(e,r),i[r]=i[r-1],i[r]+=ude.distanceTo(dde);t.setAttribute("lineDistance",new Jr(i,1))}else console.warn("THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.Line.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}raycast(t,e){let i=this.geometry,r=this.matrixWorld,o=t.params.Line.threshold,s=i.drawRange;if(null===i.boundingSphere&&i.computeBoundingSphere(),qO.copy(i.boundingSphere),qO.applyMatrix4(r),qO.radius+=o,!1===t.ray.intersectsSphere(qO))return;pde.copy(r).invert(),t8.copy(t.ray).applyMatrix4(pde);let a=o/((this.scale.x+this.scale.y+this.scale.z)/3),l=a*a,c=new ie,u=new ie,d=new ie,p=new ie,h=this.isLineSegments?2:1;if(i.isBufferGeometry){let f=i.index,x=i.attributes.position;if(null!==f)for(let D=Math.max(0,s.start),T=Math.min(f.count,s.start+s.count)-1;D<T;D+=h){let k=f.getX(D),Z=f.getX(D+1);if(c.fromBufferAttribute(x,k),u.fromBufferAttribute(x,Z),t8.distanceSqToSegment(c,u,p,d)>l)continue;p.applyMatrix4(this.matrixWorld);let fe=t.ray.origin.distanceTo(p);fe<t.near||fe>t.far||e.push({distance:fe,point:d.clone().applyMatrix4(this.matrixWorld),index:D,face:null,faceIndex:null,object:this})}else for(let D=Math.max(0,s.start),T=Math.min(x.count,s.start+s.count)-1;D<T;D+=h){if(c.fromBufferAttribute(x,D),u.fromBufferAttribute(x,D+1),t8.distanceSqToSegment(c,u,p,d)>l)continue;p.applyMatrix4(this.matrixWorld);let Z=t.ray.origin.distanceTo(p);Z<t.near||Z>t.far||e.push({distance:Z,point:d.clone().applyMatrix4(this.matrixWorld),index:D,face:null,faceIndex:null,object:this})}}else i.isGeometry&&console.error("THREE.Line.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let e=t.morphAttributes,i=Object.keys(e);if(i.length>0){let r=e[i[0]];if(void 0!==r){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let o=0,s=r.length;o<s;o++){let a=r[o].name||String(o);this.morphTargetInfluences.push(0),this.morphTargetDictionary[a]=o}}}}else{let e=t.morphTargets;void 0!==e&&e.length>0&&console.error("THREE.Line.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}};iE.prototype.isLine=!0;var hde=new ie,fde=new ie,rE=class extends iE{constructor(t,e){super(t,e),this.type="LineSegments"}computeLineDistances(){let t=this.geometry;if(t.isBufferGeometry)if(null===t.index){let e=t.attributes.position,i=[];for(let r=0,o=e.count;r<o;r+=2)hde.fromBufferAttribute(e,r),fde.fromBufferAttribute(e,r+1),i[r]=0===r?0:i[r-1],i[r+1]=i[r]+hde.distanceTo(fde);t.setAttribute("lineDistance",new Jr(i,1))}else console.warn("THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.LineSegments.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}};rE.prototype.isLineSegments=!0,class extends iE{constructor(t,e){super(t,e),this.type="LineLoop"}}.prototype.isLineLoop=!0;var _k=class extends hs{constructor(t){super(),this.type="PointsMaterial",this.color=new vn(16777215),this.map=null,this.alphaMap=null,this.size=1,this.sizeAttenuation=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.size=t.size,this.sizeAttenuation=t.sizeAttenuation,this}};_k.prototype.isPointsMaterial=!0;var mde=new Rn,E8=new Cf,YO=new xf,XO=new ie;function gde(n,t,e,i,r,o,s){let a=E8.distanceSqToPoint(n);if(a<e){let l=new ie;E8.closestPointToPoint(n,l),l.applyMatrix4(i);let c=r.ray.origin.distanceTo(l);if(c<r.near||c>r.far)return;o.push({distance:c,distanceToRay:Math.sqrt(a),point:l,index:t,face:null,object:s})}}(class extends Xi{constructor(t=new nr,e=new _k){super(),this.type="Points",this.geometry=t,this.material=e,this.updateMorphTargets()}copy(t){return super.copy(t),this.material=t.material,this.geometry=t.geometry,this}raycast(t,e){let i=this.geometry,r=this.matrixWorld,o=t.params.Points.threshold,s=i.drawRange;if(null===i.boundingSphere&&i.computeBoundingSphere(),YO.copy(i.boundingSphere),YO.applyMatrix4(r),YO.radius+=o,!1===t.ray.intersectsSphere(YO))return;mde.copy(r).invert(),E8.copy(t.ray).applyMatrix4(mde);let a=o/((this.scale.x+this.scale.y+this.scale.z)/3),l=a*a;if(i.isBufferGeometry){let c=i.index,d=i.attributes.position;if(null!==c)for(let f=Math.max(0,s.start),m=Math.min(c.count,s.start+s.count);f<m;f++){let x=c.getX(f);XO.fromBufferAttribute(d,x),gde(XO,x,l,r,t,e,this)}else for(let f=Math.max(0,s.start),m=Math.min(d.count,s.start+s.count);f<m;f++)XO.fromBufferAttribute(d,f),gde(XO,f,l,r,t,e,this)}else console.error("THREE.Points.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}updateMorphTargets(){let t=this.geometry;if(t.isBufferGeometry){let e=t.morphAttributes,i=Object.keys(e);if(i.length>0){let r=e[i[0]];if(void 0!==r){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let o=0,s=r.length;o<s;o++){let a=r[o].name||String(o);this.morphTargetInfluences.push(0),this.morphTargetDictionary[a]=o}}}}else{let e=t.morphTargets;void 0!==e&&e.length>0&&console.error("THREE.Points.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}}).prototype.isPoints=!0,class extends Ho{constructor(t,e,i,r,o,s,a,l,c){super(t,e,i,r,o,s,a,l,c),this.minFilter=void 0!==s?s:Gs,this.magFilter=void 0!==o?o:Gs,this.generateMipmaps=!1;let u=this;"requestVideoFrameCallback"in t&&t.requestVideoFrameCallback(function d(){u.needsUpdate=!0,t.requestVideoFrameCallback(d)})}clone(){return new this.constructor(this.image).copy(this)}update(){let t=this.image;"requestVideoFrameCallback"in t==0&&t.readyState>=t.HAVE_CURRENT_DATA&&(this.needsUpdate=!0)}}.prototype.isVideoTexture=!0,class extends Ho{constructor(t,e,i){super({width:t,height:e}),this.format=i,this.magFilter=Zo,this.minFilter=Zo,this.generateMipmaps=!1,this.needsUpdate=!0}}.prototype.isFramebufferTexture=!0,class extends Ho{constructor(t,e,i,r,o,s,a,l,c,u,d,p){super(null,s,a,l,c,u,r,o,d,p),this.image={width:e,height:i},this.mipmaps=t,this.flipY=!1,this.generateMipmaps=!1}}.prototype.isCompressedTexture=!0,class extends Ho{constructor(t,e,i,r,o,s,a,l,c){super(t,e,i,r,o,s,a,l,c),this.needsUpdate=!0}}.prototype.isCanvasTexture=!0;var yb=class extends nr{constructor(t=1,e=8,i=0,r=2*Math.PI){super(),this.type="CircleGeometry",this.parameters={radius:t,segments:e,thetaStart:i,thetaLength:r},e=Math.max(3,e);let o=[],s=[],a=[],l=[],c=new ie,u=new at;s.push(0,0,0),a.push(0,0,1),l.push(.5,.5);for(let d=0,p=3;d<=e;d++,p+=3){let h=i+d/e*r;c.x=t*Math.cos(h),c.y=t*Math.sin(h),s.push(c.x,c.y,c.z),a.push(0,0,1),u.x=(s[p]/t+1)/2,u.y=(s[p+1]/t+1)/2,l.push(u.x,u.y)}for(let d=1;d<=e;d++)o.push(d,d+1,0);this.setIndex(o),this.setAttribute("position",new Jr(s,3)),this.setAttribute("normal",new Jr(a,3)),this.setAttribute("uv",new Jr(l,2))}static fromJSON(t){return new yb(t.radius,t.segments,t.thetaStart,t.thetaLength)}},qa=(new ie,new ie,new ie,new lo,class{constructor(){this.type="Curve",this.arcLengthDivisions=200}getPoint(){return console.warn("THREE.Curve: .getPoint() not implemented."),null}getPointAt(t,e){let i=this.getUtoTmapping(t);return this.getPoint(i,e)}getPoints(t=5){let e=[];for(let i=0;i<=t;i++)e.push(this.getPoint(i/t));return e}getSpacedPoints(t=5){let e=[];for(let i=0;i<=t;i++)e.push(this.getPointAt(i/t));return e}getLength(){let t=this.getLengths();return t[t.length-1]}getLengths(t=this.arcLengthDivisions){if(this.cacheArcLengths&&this.cacheArcLengths.length===t+1&&!this.needsUpdate)return this.cacheArcLengths;this.needsUpdate=!1;let i,e=[],r=this.getPoint(0),o=0;e.push(0);for(let s=1;s<=t;s++)i=this.getPoint(s/t),o+=i.distanceTo(r),e.push(o),r=i;return this.cacheArcLengths=e,e}updateArcLengths(){this.needsUpdate=!0,this.getLengths()}getUtoTmapping(t,e){let s,i=this.getLengths(),r=0,o=i.length;s=e||t*i[o-1];let c,a=0,l=o-1;for(;a<=l;)if(r=Math.floor(a+(l-a)/2),c=i[r]-s,c<0)a=r+1;else{if(!(c>0)){l=r;break}l=r-1}if(r=l,i[r]===s)return r/(o-1);let u=i[r];return(r+(s-u)/(i[r+1]-u))/(o-1)}getTangent(t,e){let r=t-1e-4,o=t+1e-4;r<0&&(r=0),o>1&&(o=1);let s=this.getPoint(r),a=this.getPoint(o),l=e||(s.isVector2?new at:new ie);return l.copy(a).sub(s).normalize(),l}getTangentAt(t,e){let i=this.getUtoTmapping(t);return this.getTangent(i,e)}computeFrenetFrames(t,e){let i=new ie,r=[],o=[],s=[],a=new ie,l=new Rn;for(let h=0;h<=t;h++)r[h]=this.getTangentAt(h/t,new ie);o[0]=new ie,s[0]=new ie;let c=Number.MAX_VALUE,u=Math.abs(r[0].x),d=Math.abs(r[0].y),p=Math.abs(r[0].z);u<=c&&(c=u,i.set(1,0,0)),d<=c&&(c=d,i.set(0,1,0)),p<=c&&i.set(0,0,1),a.crossVectors(r[0],i).normalize(),o[0].crossVectors(r[0],a),s[0].crossVectors(r[0],o[0]);for(let h=1;h<=t;h++){if(o[h]=o[h-1].clone(),s[h]=s[h-1].clone(),a.crossVectors(r[h-1],r[h]),a.length()>Number.EPSILON){a.normalize();let f=Math.acos(Ga(r[h-1].dot(r[h]),-1,1));o[h].applyMatrix4(l.makeRotationAxis(a,f))}s[h].crossVectors(r[h],o[h])}if(!0===e){let h=Math.acos(Ga(o[0].dot(o[t]),-1,1));h/=t,r[0].dot(a.crossVectors(o[0],o[t]))>0&&(h=-h);for(let f=1;f<=t;f++)o[f].applyMatrix4(l.makeRotationAxis(r[f],h*f)),s[f].crossVectors(r[f],o[f])}return{tangents:r,normals:o,binormals:s}}clone(){return(new this.constructor).copy(this)}copy(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}toJSON(){let t={metadata:{version:4.5,type:"Curve",generator:"Curve.toJSON"}};return t.arcLengthDivisions=this.arcLengthDivisions,t.type=this.type,t}fromJSON(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}}),bb=class extends qa{constructor(t=0,e=0,i=1,r=1,o=0,s=2*Math.PI,a=!1,l=0){super(),this.type="EllipseCurve",this.aX=t,this.aY=e,this.xRadius=i,this.yRadius=r,this.aStartAngle=o,this.aEndAngle=s,this.aClockwise=a,this.aRotation=l}getPoint(t,e){let i=e||new at,r=2*Math.PI,o=this.aEndAngle-this.aStartAngle,s=Math.abs(o)<Number.EPSILON;for(;o<0;)o+=r;for(;o>r;)o-=r;o<Number.EPSILON&&(o=s?0:r),!0===this.aClockwise&&!s&&(o===r?o=-r:o-=r);let a=this.aStartAngle+t*o,l=this.aX+this.xRadius*Math.cos(a),c=this.aY+this.yRadius*Math.sin(a);if(0!==this.aRotation){let u=Math.cos(this.aRotation),d=Math.sin(this.aRotation),p=l-this.aX,h=c-this.aY;l=p*u-h*d+this.aX,c=p*d+h*u+this.aY}return i.set(l,c)}copy(t){return super.copy(t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this}toJSON(){let t=super.toJSON();return t.aX=this.aX,t.aY=this.aY,t.xRadius=this.xRadius,t.yRadius=this.yRadius,t.aStartAngle=this.aStartAngle,t.aEndAngle=this.aEndAngle,t.aClockwise=this.aClockwise,t.aRotation=this.aRotation,t}fromJSON(t){return super.fromJSON(t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this}};bb.prototype.isEllipseCurve=!0;var vk=class extends bb{constructor(t,e,i,r,o,s){super(t,e,i,i,r,o,s),this.type="ArcCurve"}};function SG(){let n=0,t=0,e=0,i=0;function r(o,s,a,l){n=o,t=a,e=-3*o+3*s-2*a-l,i=2*o-2*s+a+l}return{initCatmullRom:function(o,s,a,l,c){r(s,a,c*(a-o),c*(l-s))},initNonuniformCatmullRom:function(o,s,a,l,c,u,d){let p=(s-o)/c-(a-o)/(c+u)+(a-s)/u,h=(a-s)/u-(l-s)/(u+d)+(l-a)/d;p*=u,h*=u,r(s,a,p,h)},calc:function(o){let s=o*o;return n+t*o+e*s+i*(s*o)}}}vk.prototype.isArcCurve=!0;var QO=new ie,n8=new SG,i8=new SG,r8=new SG,yk=class extends qa{constructor(t=[],e=!1,i="centripetal",r=.5){super(),this.type="CatmullRomCurve3",this.points=t,this.closed=e,this.curveType=i,this.tension=r}getPoint(t,e=new ie){let c,u,i=e,r=this.points,o=r.length,s=(o-(this.closed?0:1))*t,a=Math.floor(s),l=s-a;this.closed?a+=a>0?0:(Math.floor(Math.abs(a)/o)+1)*o:0===l&&a===o-1&&(a=o-2,l=1),this.closed||a>0?c=r[(a-1)%o]:(QO.subVectors(r[0],r[1]).add(r[0]),c=QO);let d=r[a%o],p=r[(a+1)%o];if(this.closed||a+2<o?u=r[(a+2)%o]:(QO.subVectors(r[o-1],r[o-2]).add(r[o-1]),u=QO),"centripetal"===this.curveType||"chordal"===this.curveType){let h="chordal"===this.curveType?.5:.25,f=Math.pow(c.distanceToSquared(d),h),m=Math.pow(d.distanceToSquared(p),h),x=Math.pow(p.distanceToSquared(u),h);m<1e-4&&(m=1),f<1e-4&&(f=m),x<1e-4&&(x=m),n8.initNonuniformCatmullRom(c.x,d.x,p.x,u.x,f,m,x),i8.initNonuniformCatmullRom(c.y,d.y,p.y,u.y,f,m,x),r8.initNonuniformCatmullRom(c.z,d.z,p.z,u.z,f,m,x)}else"catmullrom"===this.curveType&&(n8.initCatmullRom(c.x,d.x,p.x,u.x,this.tension),i8.initCatmullRom(c.y,d.y,p.y,u.y,this.tension),r8.initCatmullRom(c.z,d.z,p.z,u.z,this.tension));return i.set(n8.calc(l),i8.calc(l),r8.calc(l)),i}copy(t){super.copy(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++)this.points.push(t.points[e].clone());return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this}toJSON(){let t=super.toJSON();t.points=[];for(let e=0,i=this.points.length;e<i;e++)t.points.push(this.points[e].toArray());return t.closed=this.closed,t.curveType=this.curveType,t.tension=this.tension,t}fromJSON(t){super.fromJSON(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++){let r=t.points[e];this.points.push((new ie).fromArray(r))}return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this}};function _de(n,t,e,i,r){let o=.5*(i-t),s=.5*(r-e),a=n*n;return(2*e-2*i+o+s)*(n*a)+(-3*e+3*i-2*o-s)*a+o*n+e}function zS(n,t,e,i){return function(n,t){let e=1-n;return e*e*t}(n,t)+function(n,t){return 2*(1-n)*n*t}(n,e)+function(n,t){return n*n*t}(n,i)}function jS(n,t,e,i,r){return function(n,t){let e=1-n;return e*e*e*t}(n,t)+function(n,t){let e=1-n;return 3*e*e*n*t}(n,e)+function(n,t){return 3*(1-n)*n*n*t}(n,i)+function(n,t){return n*n*n*t}(n,r)}yk.prototype.isCatmullRomCurve3=!0;var oE=class extends qa{constructor(t=new at,e=new at,i=new at,r=new at){super(),this.type="CubicBezierCurve",this.v0=t,this.v1=e,this.v2=i,this.v3=r}getPoint(t,e=new at){let i=e,r=this.v0,o=this.v1,s=this.v2,a=this.v3;return i.set(jS(t,r.x,o.x,s.x,a.x),jS(t,r.y,o.y,s.y,a.y)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this}};oE.prototype.isCubicBezierCurve=!0;var bk=class extends qa{constructor(t=new ie,e=new ie,i=new ie,r=new ie){super(),this.type="CubicBezierCurve3",this.v0=t,this.v1=e,this.v2=i,this.v3=r}getPoint(t,e=new ie){let i=e,r=this.v0,o=this.v1,s=this.v2,a=this.v3;return i.set(jS(t,r.x,o.x,s.x,a.x),jS(t,r.y,o.y,s.y,a.y),jS(t,r.z,o.z,s.z,a.z)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this}};bk.prototype.isCubicBezierCurve3=!0;var xb=class extends qa{constructor(t=new at,e=new at){super(),this.type="LineCurve",this.v1=t,this.v2=e}getPoint(t,e=new at){let i=e;return 1===t?i.copy(this.v2):(i.copy(this.v2).sub(this.v1),i.multiplyScalar(t).add(this.v1)),i}getPointAt(t,e){return this.getPoint(t,e)}getTangent(t,e){let i=e||new at;return i.copy(this.v2).sub(this.v1).normalize(),i}copy(t){return super.copy(t),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};xb.prototype.isLineCurve=!0;var sE=class extends qa{constructor(t=new at,e=new at,i=new at){super(),this.type="QuadraticBezierCurve",this.v0=t,this.v1=e,this.v2=i}getPoint(t,e=new at){let i=e,r=this.v0,o=this.v1,s=this.v2;return i.set(zS(t,r.x,o.x,s.x),zS(t,r.y,o.y,s.y)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};sE.prototype.isQuadraticBezierCurve=!0;var xk=class extends qa{constructor(t=new ie,e=new ie,i=new ie){super(),this.type="QuadraticBezierCurve3",this.v0=t,this.v1=e,this.v2=i}getPoint(t,e=new ie){let i=e,r=this.v0,o=this.v1,s=this.v2;return i.set(zS(t,r.x,o.x,s.x),zS(t,r.y,o.y,s.y),zS(t,r.z,o.z,s.z)),i}copy(t){return super.copy(t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}};xk.prototype.isQuadraticBezierCurve3=!0;var aE=class extends qa{constructor(t=[]){super(),this.type="SplineCurve",this.points=t}getPoint(t,e=new at){let i=e,r=this.points,o=(r.length-1)*t,s=Math.floor(o),a=o-s,l=r[0===s?s:s-1],c=r[s],u=r[s>r.length-2?r.length-1:s+1],d=r[s>r.length-3?r.length-1:s+2];return i.set(_de(a,l.x,c.x,u.x,d.x),_de(a,l.y,c.y,u.y,d.y)),i}copy(t){super.copy(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++)this.points.push(t.points[e].clone());return this}toJSON(){let t=super.toJSON();t.points=[];for(let e=0,i=this.points.length;e<i;e++)t.points.push(this.points[e].toArray());return t}fromJSON(t){super.fromJSON(t),this.points=[];for(let e=0,i=t.points.length;e<i;e++){let r=t.points[e];this.points.push((new at).fromArray(r))}return this}};aE.prototype.isSplineCurve=!0;var qde=Object.freeze({__proto__:null,ArcCurve:vk,CatmullRomCurve3:yk,CubicBezierCurve:oE,CubicBezierCurve3:bk,EllipseCurve:bb,LineCurve:xb,LineCurve3:class extends qa{constructor(t=new ie,e=new ie){super(),this.type="LineCurve3",this.isLineCurve3=!0,this.v1=t,this.v2=e}getPoint(t,e=new ie){let i=e;return 1===t?i.copy(this.v2):(i.copy(this.v2).sub(this.v1),i.multiplyScalar(t).add(this.v1)),i}getPointAt(t,e){return this.getPoint(t,e)}copy(t){return super.copy(t),this.v1.copy(t.v1),this.v2.copy(t.v2),this}toJSON(){let t=super.toJSON();return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t}fromJSON(t){return super.fromJSON(t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this}},QuadraticBezierCurve:sE,QuadraticBezierCurve3:xk,SplineCurve:aE}),O8=class extends qa{constructor(){super(),this.type="CurvePath",this.curves=[],this.autoClose=!1}add(t){this.curves.push(t)}closePath(){let t=this.curves[0].getPoint(0),e=this.curves[this.curves.length-1].getPoint(1);t.equals(e)||this.curves.push(new xb(e,t))}getPoint(t,e){let i=t*this.getLength(),r=this.getCurveLengths(),o=0;for(;o<r.length;){if(r[o]>=i){let s=r[o]-i,a=this.curves[o],l=a.getLength();return a.getPointAt(0===l?0:1-s/l,e)}o++}return null}getLength(){let t=this.getCurveLengths();return t[t.length-1]}updateArcLengths(){this.needsUpdate=!0,this.cacheLengths=null,this.getCurveLengths()}getCurveLengths(){if(this.cacheLengths&&this.cacheLengths.length===this.curves.length)return this.cacheLengths;let t=[],e=0;for(let i=0,r=this.curves.length;i<r;i++)e+=this.curves[i].getLength(),t.push(e);return this.cacheLengths=t,t}getSpacedPoints(t=40){let e=[];for(let i=0;i<=t;i++)e.push(this.getPoint(i/t));return this.autoClose&&e.push(e[0]),e}getPoints(t=12){let i,e=[];for(let r=0,o=this.curves;r<o.length;r++){let s=o[r],l=s.getPoints(s&&s.isEllipseCurve?2*t:s&&(s.isLineCurve||s.isLineCurve3)?1:s&&s.isSplineCurve?t*s.points.length:t);for(let c=0;c<l.length;c++){let u=l[c];i&&i.equals(u)||(e.push(u),i=u)}}return this.autoClose&&e.length>1&&!e[e.length-1].equals(e[0])&&e.push(e[0]),e}copy(t){super.copy(t),this.curves=[];for(let e=0,i=t.curves.length;e<i;e++)this.curves.push(t.curves[e].clone());return this.autoClose=t.autoClose,this}toJSON(){let t=super.toJSON();t.autoClose=this.autoClose,t.curves=[];for(let e=0,i=this.curves.length;e<i;e++)t.curves.push(this.curves[e].toJSON());return t}fromJSON(t){super.fromJSON(t),this.autoClose=t.autoClose,this.curves=[];for(let e=0,i=t.curves.length;e<i;e++){let r=t.curves[e];this.curves.push((new qde[r.type]).fromJSON(r))}return this}},lE=class extends O8{constructor(t){super(),this.type="Path",this.currentPoint=new at,t&&this.setFromPoints(t)}setFromPoints(t){this.moveTo(t[0].x,t[0].y);for(let e=1,i=t.length;e<i;e++)this.lineTo(t[e].x,t[e].y);return this}moveTo(t,e){return this.currentPoint.set(t,e),this}lineTo(t,e){let i=new xb(this.currentPoint.clone(),new at(t,e));return this.curves.push(i),this.currentPoint.set(t,e),this}quadraticCurveTo(t,e,i,r){let o=new sE(this.currentPoint.clone(),new at(t,e),new at(i,r));return this.curves.push(o),this.currentPoint.set(i,r),this}bezierCurveTo(t,e,i,r,o,s){let a=new oE(this.currentPoint.clone(),new at(t,e),new at(i,r),new at(o,s));return this.curves.push(a),this.currentPoint.set(o,s),this}splineThru(t){let e=[this.currentPoint.clone()].concat(t),i=new aE(e);return this.curves.push(i),this.currentPoint.copy(t[t.length-1]),this}arc(t,e,i,r,o,s){return this.absarc(t+this.currentPoint.x,e+this.currentPoint.y,i,r,o,s),this}absarc(t,e,i,r,o,s){return this.absellipse(t,e,i,i,r,o,s),this}ellipse(t,e,i,r,o,s,a,l){return this.absellipse(t+this.currentPoint.x,e+this.currentPoint.y,i,r,o,s,a,l),this}absellipse(t,e,i,r,o,s,a,l){let c=new bb(t,e,i,r,o,s,a,l);if(this.curves.length>0){let d=c.getPoint(0);d.equals(this.currentPoint)||this.lineTo(d.x,d.y)}this.curves.push(c);let u=c.getPoint(1);return this.currentPoint.copy(u),this}copy(t){return super.copy(t),this.currentPoint.copy(t.currentPoint),this}toJSON(){let t=super.toJSON();return t.currentPoint=this.currentPoint.toArray(),t}fromJSON(t){return super.fromJSON(t),this.currentPoint.fromArray(t.currentPoint),this}},Ip=class extends lE{constructor(t){super(t),this.uuid=du(),this.type="Shape",this.holes=[]}getPointsHoles(t){let e=[];for(let i=0,r=this.holes.length;i<r;i++)e[i]=this.holes[i].getPoints(t);return e}extractPoints(t){return{shape:this.getPoints(t),holes:this.getPointsHoles(t)}}copy(t){super.copy(t),this.holes=[];for(let e=0,i=t.holes.length;e<i;e++)this.holes.push(t.holes[e].clone());return this}toJSON(){let t=super.toJSON();t.uuid=this.uuid,t.holes=[];for(let e=0,i=this.holes.length;e<i;e++)t.holes.push(this.holes[e].toJSON());return t}fromJSON(t){super.fromJSON(t),this.uuid=t.uuid,this.holes=[];for(let e=0,i=t.holes.length;e<i;e++){let r=t.holes[e];this.holes.push((new lE).fromJSON(r))}return this}};function Yde(n,t,e,i,r){let o,s;if(r===function(n,t,e,i){let r=0;for(let o=t,s=e-i;o<e;o+=i)r+=(n[s]-n[o])*(n[o+1]+n[s+1]),s=o;return r}(n,t,e,i)>0)for(o=t;o<e;o+=i)s=vde(o,n[o],n[o+1],s);else for(o=e-i;o>=t;o-=i)s=vde(o,n[o],n[o+1],s);return s&&Fk(s,s.next)&&(dE(s),s=s.next),s}function wf(n,t){if(!n)return n;t||(t=n);let i,e=n;do{if(i=!1,e.steiner||!Fk(e,e.next)&&0!==Zr(e.prev,e,e.next))e=e.next;else{if(dE(e),e=t=e.prev,e===e.next)break;i=!0}}while(i||e!==t);return t}function cE(n,t,e,i,r,o,s){if(!n)return;!s&&o&&function(n,t,e,i){let r=n;do{null===r.z&&(r.z=k8(r.x,r.y,t,e,i)),r.prevZ=r.prev,r.nextZ=r.next,r=r.next}while(r!==n);r.prevZ.nextZ=null,r.prevZ=null,function(n){let t,e,i,r,o,s,a,l,c=1;do{for(e=n,n=null,o=null,s=0;e;){for(s++,i=e,a=0,t=0;t<c&&(a++,i=i.nextZ,i);t++);for(l=c;a>0||l>0&&i;)0!==a&&(0===l||!i||e.z<=i.z)?(r=e,e=e.nextZ,a--):(r=i,i=i.nextZ,l--),o?o.nextZ=r:n=r,r.prevZ=o,o=r;e=i}o.nextZ=null,c*=2}while(s>1)}(r)}(n,i,r,o);let l,c,a=n;for(;n.prev!==n.next;)if(l=n.prev,c=n.next,o?D9e(n,i,r,o):T9e(n))t.push(l.i/e),t.push(n.i/e),t.push(c.i/e),dE(n),n=c.next,a=c.next;else if((n=c)===a){s?1===s?cE(n=A9e(wf(n),t,e),t,e,i,r,o,2):2===s&&I9e(n,t,e,i,r,o):cE(wf(n),t,e,i,r,o,1);break}}function T9e(n){let t=n.prev,e=n,i=n.next;if(Zr(t,e,i)>=0)return!1;let r=n.next.next;for(;r!==n.prev;){if(ab(t.x,t.y,e.x,e.y,i.x,i.y,r.x,r.y)&&Zr(r.prev,r,r.next)>=0)return!1;r=r.next}return!0}function D9e(n,t,e,i){let r=n.prev,o=n,s=n.next;if(Zr(r,o,s)>=0)return!1;let c=r.x>o.x?r.x>s.x?r.x:s.x:o.x>s.x?o.x:s.x,u=r.y>o.y?r.y>s.y?r.y:s.y:o.y>s.y?o.y:s.y,d=k8(r.x<o.x?r.x<s.x?r.x:s.x:o.x<s.x?o.x:s.x,r.y<o.y?r.y<s.y?r.y:s.y:o.y<s.y?o.y:s.y,t,e,i),p=k8(c,u,t,e,i),h=n.prevZ,f=n.nextZ;for(;h&&h.z>=d&&f&&f.z<=p;){if(h!==n.prev&&h!==n.next&&ab(r.x,r.y,o.x,o.y,s.x,s.y,h.x,h.y)&&Zr(h.prev,h,h.next)>=0||(h=h.prevZ,f!==n.prev&&f!==n.next&&ab(r.x,r.y,o.x,o.y,s.x,s.y,f.x,f.y)&&Zr(f.prev,f,f.next)>=0))return!1;f=f.nextZ}for(;h&&h.z>=d;){if(h!==n.prev&&h!==n.next&&ab(r.x,r.y,o.x,o.y,s.x,s.y,h.x,h.y)&&Zr(h.prev,h,h.next)>=0)return!1;h=h.prevZ}for(;f&&f.z<=p;){if(f!==n.prev&&f!==n.next&&ab(r.x,r.y,o.x,o.y,s.x,s.y,f.x,f.y)&&Zr(f.prev,f,f.next)>=0)return!1;f=f.nextZ}return!0}function A9e(n,t,e){let i=n;do{let r=i.prev,o=i.next.next;!Fk(r,o)&&Xde(r,i,i.next,o)&&uE(r,o)&&uE(o,r)&&(t.push(r.i/e),t.push(i.i/e),t.push(o.i/e),dE(i),dE(i.next),i=n=o),i=i.next}while(i!==n);return wf(i)}function I9e(n,t,e,i,r,o){let s=n;do{let a=s.next.next;for(;a!==s.prev;){if(s.i!==a.i&&V9e(s,a)){let l=Qde(s,a);return s=wf(s,s.next),l=wf(l,l.next),cE(s,t,e,i,r,o),void cE(l,t,e,i,r,o)}a=a.next}s=s.next}while(s!==n)}function R9e(n,t){return n.x-t.x}function O9e(n,t){if(t=function(n,t){let s,e=t,i=n.x,r=n.y,o=-1/0;do{if(r<=e.y&&r>=e.next.y&&e.next.y!==e.y){let p=e.x+(r-e.y)*(e.next.x-e.x)/(e.next.y-e.y);if(p<=i&&p>o){if(o=p,p===i){if(r===e.y)return e;if(r===e.next.y)return e.next}s=e.x<e.next.x?e:e.next}}e=e.next}while(e!==t);if(!s)return null;if(i===o)return s;let d,a=s,l=s.x,c=s.y,u=1/0;e=s;do{i>=e.x&&e.x>=l&&i!==e.x&&ab(r<c?i:o,r,l,c,r<c?o:i,r,e.x,e.y)&&(d=Math.abs(r-e.y)/(i-e.x),uE(e,n)&&(d<u||d===u&&(e.x>s.x||e.x===s.x&&F9e(s,e)))&&(s=e,u=d)),e=e.next}while(e!==a);return s}(n,t),t){let e=Qde(t,n);wf(t,t.next),wf(e,e.next)}}function F9e(n,t){return Zr(n.prev,n,t.prev)<0&&Zr(t.next,n,n.next)<0}function k8(n,t,e,i,r){return(n=1431655765&((n=858993459&((n=252645135&((n=16711935&((n=32767*(n-e)*r)|n<<8))|n<<4))|n<<2))|n<<1))|(t=1431655765&((t=858993459&((t=252645135&((t=16711935&((t=32767*(t-i)*r)|t<<8))|t<<4))|t<<2))|t<<1))<<1}function B9e(n){let t=n,e=n;do{(t.x<e.x||t.x===e.x&&t.y<e.y)&&(e=t),t=t.next}while(t!==n);return e}function ab(n,t,e,i,r,o,s,a){return(r-s)*(t-a)-(n-s)*(o-a)>=0&&(n-s)*(i-a)-(e-s)*(t-a)>=0&&(e-s)*(o-a)-(r-s)*(i-a)>=0}function V9e(n,t){return n.next.i!==t.i&&n.prev.i!==t.i&&!function(n,t){let e=n;do{if(e.i!==n.i&&e.next.i!==n.i&&e.i!==t.i&&e.next.i!==t.i&&Xde(e,e.next,n,t))return!0;e=e.next}while(e!==n);return!1}(n,t)&&(uE(n,t)&&uE(t,n)&&function(n,t){let e=n,i=!1,r=(n.x+t.x)/2,o=(n.y+t.y)/2;do{e.y>o!=e.next.y>o&&e.next.y!==e.y&&r<(e.next.x-e.x)*(o-e.y)/(e.next.y-e.y)+e.x&&(i=!i),e=e.next}while(e!==n);return i}(n,t)&&(Zr(n.prev,n,t.prev)||Zr(n,t.prev,t))||Fk(n,t)&&Zr(n.prev,n,n.next)>0&&Zr(t.prev,t,t.next)>0)}function Zr(n,t,e){return(t.y-n.y)*(e.x-t.x)-(t.x-n.x)*(e.y-t.y)}function Fk(n,t){return n.x===t.x&&n.y===t.y}function Xde(n,t,e,i){let r=ZO(Zr(n,t,e)),o=ZO(Zr(n,t,i)),s=ZO(Zr(e,i,n)),a=ZO(Zr(e,i,t));return!!(r!==o&&s!==a||0===r&&KO(n,e,t)||0===o&&KO(n,i,t)||0===s&&KO(e,n,i)||0===a&&KO(e,t,i))}function KO(n,t,e){return t.x<=Math.max(n.x,e.x)&&t.x>=Math.min(n.x,e.x)&&t.y<=Math.max(n.y,e.y)&&t.y>=Math.min(n.y,e.y)}function ZO(n){return n>0?1:n<0?-1:0}function uE(n,t){return Zr(n.prev,n,n.next)<0?Zr(n,t,n.next)>=0&&Zr(n,n.prev,t)>=0:Zr(n,t,n.prev)<0||Zr(n,n.next,t)<0}function Qde(n,t){let e=new F8(n.i,n.x,n.y),i=new F8(t.i,t.x,t.y),r=n.next,o=t.prev;return n.next=t,t.prev=n,e.next=r,r.prev=e,i.next=e,e.prev=i,o.next=i,i.prev=o,i}function vde(n,t,e,i){let r=new F8(n,t,e);return i?(r.next=i.next,r.prev=i,i.next.prev=r,i.next=r):(r.prev=r,r.next=r),r}function dE(n){n.next.prev=n.prev,n.prev.next=n.next,n.prevZ&&(n.prevZ.nextZ=n.nextZ),n.nextZ&&(n.nextZ.prevZ=n.prevZ)}function F8(n,t,e){this.i=n,this.x=t,this.y=e,this.prev=null,this.next=null,this.z=null,this.prevZ=null,this.nextZ=null,this.steiner=!1}var Ed=class{static area(t){let e=t.length,i=0;for(let r=e-1,o=0;o<e;r=o++)i+=t[r].x*t[o].y-t[o].x*t[r].y;return.5*i}static isClockWise(t){return Ed.area(t)<0}static triangulateShape(t,e){let i=[],r=[],o=[];yde(t),bde(i,t);let s=t.length;e.forEach(yde);for(let l=0;l<e.length;l++)r.push(s),s+=e[l].length,bde(i,e[l]);let a=function(n,t,e=2){let a,l,c,u,d,p,h,i=t&&t.length,r=i?t[0]*e:n.length,o=Yde(n,0,r,e,!0),s=[];if(!o||o.next===o.prev)return s;if(i&&(o=function(n,t,e,i){let o,s,a,l,c,r=[];for(o=0,s=t.length;o<s;o++)a=t[o]*i,l=o<s-1?t[o+1]*i:n.length,c=Yde(n,a,l,i,!1),c===c.next&&(c.steiner=!0),r.push(B9e(c));for(r.sort(R9e),o=0;o<r.length;o++)O9e(r[o],e),e=wf(e,e.next);return e}(n,t,o,e)),n.length>80*e){a=c=n[0],l=u=n[1];for(let f=e;f<r;f+=e)d=n[f],p=n[f+1],d<a&&(a=d),p<l&&(l=p),d>c&&(c=d),p>u&&(u=p);h=Math.max(c-a,u-l),h=0!==h?1/h:0}return cE(o,s,e,a,l,h),s}(i,r);for(let l=0;l<a.length;l+=3)o.push(a.slice(l,l+3));return o}};function yde(n){let t=n.length;t>2&&n[t-1].equals(n[0])&&n.pop()}function bde(n,t){for(let e=0;e<t.length;e++)n.push(t[e].x),n.push(t[e].y)}var Sf=class extends nr{constructor(t=new Ip([new at(.5,.5),new at(-.5,.5),new at(-.5,-.5),new at(.5,-.5)]),e={}){super(),this.type="ExtrudeGeometry",this.parameters={shapes:t,options:e},t=Array.isArray(t)?t:[t];let i=this,r=[],o=[];for(let a=0,l=t.length;a<l;a++)s(t[a]);function s(a){let l=[],c=void 0!==e.curveSegments?e.curveSegments:12,u=void 0!==e.steps?e.steps:1,d=void 0!==e.depth?e.depth:1,p=void 0===e.bevelEnabled||e.bevelEnabled,h=void 0!==e.bevelThickness?e.bevelThickness:.2,f=void 0!==e.bevelSize?e.bevelSize:h-.1,m=void 0!==e.bevelOffset?e.bevelOffset:0,x=void 0!==e.bevelSegments?e.bevelSegments:3,g=e.extrudePath,b=void 0!==e.UVGenerator?e.UVGenerator:j9e;void 0!==e.amount&&(console.warn("THREE.ExtrudeBufferGeometry: amount has been renamed to depth."),d=e.amount);let D,k,Z,z,fe,T=!1;g&&(D=g.getSpacedPoints(u),T=!0,p=!1,k=g.computeFrenetFrames(u,!1),Z=new ie,z=new ie,fe=new ie),p||(x=0,h=0,f=0,m=0);let ue=a.extractPoints(c),he=ue.shape,w=ue.holes;if(!Ed.isClockWise(he)){he=he.reverse();for(let ce=0,dt=w.length;ce<dt;ce++){let We=w[ce];Ed.isClockWise(We)&&(w[ce]=We.reverse())}}let q=Ed.triangulateShape(he,w),K=he;for(let ce=0,dt=w.length;ce<dt;ce++)he=he.concat(w[ce]);function de(ce,dt,We){return dt||console.error("THREE.ExtrudeGeometry: vec does not exist"),dt.clone().multiplyScalar(We).add(ce)}let Y=he.length,ae=q.length;function le(ce,dt,We){let Mt,bt,hn,on=ce.x-dt.x,fi=ce.y-dt.y,Wi=We.x-ce.x,qi=We.y-ce.y,ee=on*on+fi*fi;if(Math.abs(on*qi-fi*Wi)>Number.EPSILON){let Xe=Math.sqrt(ee),Tt=Math.sqrt(Wi*Wi+qi*qi),mn=dt.x-fi/Xe,qe=dt.y+on/Xe,zt=((We.x-qi/Tt-mn)*qi-(We.y+Wi/Tt-qe)*Wi)/(on*qi-fi*Wi);Mt=mn+on*zt-ce.x,bt=qe+fi*zt-ce.y;let Ut=Mt*Mt+bt*bt;if(Ut<=2)return new at(Mt,bt);hn=Math.sqrt(Ut/2)}else{let Xe=!1;on>Number.EPSILON?Wi>Number.EPSILON&&(Xe=!0):on<-Number.EPSILON?Wi<-Number.EPSILON&&(Xe=!0):Math.sign(fi)===Math.sign(qi)&&(Xe=!0),Xe?(Mt=-fi,bt=on,hn=Math.sqrt(ee)):(Mt=on,bt=fi,hn=Math.sqrt(ee/2))}return new at(Mt/hn,bt/hn)}let Ie=[];for(let ce=0,dt=K.length,We=dt-1,Mt=ce+1;ce<dt;ce++,We++,Mt++)We===dt&&(We=0),Mt===dt&&(Mt=0),Ie[ce]=le(K[ce],K[We],K[Mt]);let De,ve=[],nt=Ie.concat();for(let ce=0,dt=w.length;ce<dt;ce++){let We=w[ce];De=[];for(let Mt=0,bt=We.length,hn=bt-1,on=Mt+1;Mt<bt;Mt++,hn++,on++)hn===bt&&(hn=0),on===bt&&(on=0),De[Mt]=le(We[Mt],We[hn],We[on]);ve.push(De),nt=nt.concat(De)}for(let ce=0;ce<x;ce++){let dt=ce/x,We=h*Math.cos(dt*Math.PI/2),Mt=f*Math.sin(dt*Math.PI/2)+m;for(let bt=0,hn=K.length;bt<hn;bt++){let on=de(K[bt],Ie[bt],Mt);pt(on.x,on.y,-We)}for(let bt=0,hn=w.length;bt<hn;bt++){let on=w[bt];De=ve[bt];for(let fi=0,Wi=on.length;fi<Wi;fi++){let qi=de(on[fi],De[fi],Mt);pt(qi.x,qi.y,-We)}}}let gt=f+m;for(let ce=0;ce<Y;ce++){let dt=p?de(he[ce],nt[ce],gt):he[ce];T?(z.copy(k.normals[0]).multiplyScalar(dt.x),Z.copy(k.binormals[0]).multiplyScalar(dt.y),fe.copy(D[0]).add(z).add(Z),pt(fe.x,fe.y,fe.z)):pt(dt.x,dt.y,0)}for(let ce=1;ce<=u;ce++)for(let dt=0;dt<Y;dt++){let We=p?de(he[dt],nt[dt],gt):he[dt];T?(z.copy(k.normals[ce]).multiplyScalar(We.x),Z.copy(k.binormals[ce]).multiplyScalar(We.y),fe.copy(D[ce]).add(z).add(Z),pt(fe.x,fe.y,fe.z)):pt(We.x,We.y,d/u*ce)}for(let ce=x-1;ce>=0;ce--){let dt=ce/x,We=h*Math.cos(dt*Math.PI/2),Mt=f*Math.sin(dt*Math.PI/2)+m;for(let bt=0,hn=K.length;bt<hn;bt++){let on=de(K[bt],Ie[bt],Mt);pt(on.x,on.y,d+We)}for(let bt=0,hn=w.length;bt<hn;bt++){let on=w[bt];De=ve[bt];for(let fi=0,Wi=on.length;fi<Wi;fi++){let qi=de(on[fi],De[fi],Mt);T?pt(qi.x,qi.y+D[u-1].y,D[u-1].x+We):pt(qi.x,qi.y,d+We)}}}function tn(ce,dt){let We=ce.length;for(;--We>=0;){let Mt=We,bt=We-1;bt<0&&(bt=ce.length-1);for(let hn=0,on=u+2*x;hn<on;hn++){let fi=Y*hn,Wi=Y*(hn+1);Te(dt+Mt+fi,dt+bt+fi,dt+bt+Wi,dt+Mt+Wi)}}}function pt(ce,dt,We){l.push(ce),l.push(dt),l.push(We)}function wt(ce,dt,We){xt(ce),xt(dt),xt(We);let Mt=r.length/3,bt=b.generateTopUV(i,r,Mt-3,Mt-2,Mt-1);mt(bt[0]),mt(bt[1]),mt(bt[2])}function Te(ce,dt,We,Mt){xt(ce),xt(dt),xt(Mt),xt(dt),xt(We),xt(Mt);let bt=r.length/3,hn=b.generateSideWallUV(i,r,bt-6,bt-3,bt-2,bt-1);mt(hn[0]),mt(hn[1]),mt(hn[3]),mt(hn[1]),mt(hn[2]),mt(hn[3])}function xt(ce){r.push(l[3*ce+0]),r.push(l[3*ce+1]),r.push(l[3*ce+2])}function mt(ce){o.push(ce.x),o.push(ce.y)}(function(){let ce=r.length/3;if(p){let dt=0,We=Y*dt;for(let Mt=0;Mt<ae;Mt++){let bt=q[Mt];wt(bt[2]+We,bt[1]+We,bt[0]+We)}dt=u+2*x,We=Y*dt;for(let Mt=0;Mt<ae;Mt++){let bt=q[Mt];wt(bt[0]+We,bt[1]+We,bt[2]+We)}}else{for(let dt=0;dt<ae;dt++){let We=q[dt];wt(We[2],We[1],We[0])}for(let dt=0;dt<ae;dt++){let We=q[dt];wt(We[0]+Y*u,We[1]+Y*u,We[2]+Y*u)}}i.addGroup(ce,r.length/3-ce,0)})(),function(){let ce=r.length/3,dt=0;tn(K,dt),dt+=K.length;for(let We=0,Mt=w.length;We<Mt;We++){let bt=w[We];tn(bt,dt),dt+=bt.length}i.addGroup(ce,r.length/3-ce,1)}()}this.setAttribute("position",new Jr(r,3)),this.setAttribute("uv",new Jr(o,2)),this.computeVertexNormals()}toJSON(){let t=super.toJSON();return function(n,t,e){if(e.shapes=[],Array.isArray(n))for(let i=0,r=n.length;i<r;i++)e.shapes.push(n[i].uuid);else e.shapes.push(n.uuid);return void 0!==t.extrudePath&&(e.options.extrudePath=t.extrudePath.toJSON()),e}(this.parameters.shapes,this.parameters.options,t)}static fromJSON(t,e){let i=[];for(let o=0,s=t.shapes.length;o<s;o++)i.push(e[t.shapes[o]]);let r=t.options.extrudePath;return void 0!==r&&(t.options.extrudePath=(new qde[r.type]).fromJSON(r)),new Sf(i,t.options)}},j9e={generateTopUV:function(n,t,e,i,r){let a=t[3*i],l=t[3*i+1],c=t[3*r],u=t[3*r+1];return[new at(t[3*e],t[3*e+1]),new at(a,l),new at(c,u)]},generateSideWallUV:function(n,t,e,i,r,o){let s=t[3*e],a=t[3*e+1],l=t[3*e+2],c=t[3*i],u=t[3*i+1],d=t[3*i+2],p=t[3*r],h=t[3*r+1],f=t[3*r+2],m=t[3*o],x=t[3*o+1],g=t[3*o+2];return Math.abs(a-u)<Math.abs(s-c)?[new at(s,1-l),new at(c,1-d),new at(p,1-f),new at(m,1-g)]:[new at(a,1-l),new at(u,1-d),new at(h,1-f),new at(x,1-g)]}},Qg=class extends nr{constructor(t=new Ip([new at(0,.5),new at(-.5,-.5),new at(.5,-.5)]),e=12){super(),this.type="ShapeGeometry",this.parameters={shapes:t,curveSegments:e};let i=[],r=[],o=[],s=[],a=0,l=0;if(!1===Array.isArray(t))c(t);else for(let u=0;u<t.length;u++)c(t[u]),this.addGroup(a,l,u),a+=l,l=0;function c(u){let d=r.length/3,p=u.extractPoints(e),h=p.shape,f=p.holes;!1===Ed.isClockWise(h)&&(h=h.reverse());for(let x=0,g=f.length;x<g;x++){let b=f[x];!0===Ed.isClockWise(b)&&(f[x]=b.reverse())}let m=Ed.triangulateShape(h,f);for(let x=0,g=f.length;x<g;x++)h=h.concat(f[x]);for(let x=0,g=h.length;x<g;x++){let b=h[x];r.push(b.x,b.y,0),o.push(0,0,1),s.push(b.x,b.y)}for(let x=0,g=m.length;x<g;x++){let b=m[x];i.push(b[0]+d,b[1]+d,b[2]+d),l+=3}}this.setIndex(i),this.setAttribute("position",new Jr(r,3)),this.setAttribute("normal",new Jr(o,3)),this.setAttribute("uv",new Jr(s,2))}toJSON(){let t=super.toJSON();return function(n,t){if(t.shapes=[],Array.isArray(n))for(let e=0,i=n.length;e<i;e++)t.shapes.push(n[e].uuid);else t.shapes.push(n.uuid);return t}(this.parameters.shapes,t)}static fromJSON(t,e){let i=[];for(let r=0,o=t.shapes.length;r<o;r++)i.push(e[t.shapes[r]]);return new Qg(i,t.curveSegments)}};(class extends hs{constructor(t){super(),this.type="ShadowMaterial",this.color=new vn(0),this.transparent=!0,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this}}).prototype.isShadowMaterial=!0;var Ck=class extends hs{constructor(t){super(),this.defines={STANDARD:""},this.type="MeshStandardMaterial",this.color=new vn(16777215),this.roughness=1,this.metalness=0,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new vn(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new at(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.roughnessMap=null,this.metalnessMap=null,this.alphaMap=null,this.envMap=null,this.envMapIntensity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.defines={STANDARD:""},this.color.copy(t.color),this.roughness=t.roughness,this.metalness=t.metalness,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.roughnessMap=t.roughnessMap,this.metalnessMap=t.metalnessMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.envMapIntensity=t.envMapIntensity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this}};Ck.prototype.isMeshStandardMaterial=!0,class extends Ck{constructor(t){super(),this.defines={STANDARD:"",PHYSICAL:""},this.type="MeshPhysicalMaterial",this.clearcoatMap=null,this.clearcoatRoughness=0,this.clearcoatRoughnessMap=null,this.clearcoatNormalScale=new at(1,1),this.clearcoatNormalMap=null,this.ior=1.5,Object.defineProperty(this,"reflectivity",{get:function(){return Ga(2.5*(this.ior-1)/(this.ior+1),0,1)},set:function(e){this.ior=(1+.4*e)/(1-.4*e)}}),this.sheenColor=new vn(0),this.sheenColorMap=null,this.sheenRoughness=1,this.sheenRoughnessMap=null,this.transmissionMap=null,this.thickness=0,this.thicknessMap=null,this.attenuationDistance=0,this.attenuationColor=new vn(1,1,1),this.specularIntensity=1,this.specularIntensityMap=null,this.specularColor=new vn(1,1,1),this.specularColorMap=null,this._sheen=0,this._clearcoat=0,this._transmission=0,this.setValues(t)}get sheen(){return this._sheen}set sheen(t){this._sheen>0!=t>0&&this.version++,this._sheen=t}get clearcoat(){return this._clearcoat}set clearcoat(t){this._clearcoat>0!=t>0&&this.version++,this._clearcoat=t}get transmission(){return this._transmission}set transmission(t){this._transmission>0!=t>0&&this.version++,this._transmission=t}copy(t){return super.copy(t),this.defines={STANDARD:"",PHYSICAL:""},this.clearcoat=t.clearcoat,this.clearcoatMap=t.clearcoatMap,this.clearcoatRoughness=t.clearcoatRoughness,this.clearcoatRoughnessMap=t.clearcoatRoughnessMap,this.clearcoatNormalMap=t.clearcoatNormalMap,this.clearcoatNormalScale.copy(t.clearcoatNormalScale),this.ior=t.ior,this.sheen=t.sheen,this.sheenColor.copy(t.sheenColor),this.sheenColorMap=t.sheenColorMap,this.sheenRoughness=t.sheenRoughness,this.sheenRoughnessMap=t.sheenRoughnessMap,this.transmission=t.transmission,this.transmissionMap=t.transmissionMap,this.thickness=t.thickness,this.thicknessMap=t.thicknessMap,this.attenuationDistance=t.attenuationDistance,this.attenuationColor.copy(t.attenuationColor),this.specularIntensity=t.specularIntensity,this.specularIntensityMap=t.specularIntensityMap,this.specularColor.copy(t.specularColor),this.specularColorMap=t.specularColorMap,this}}.prototype.isMeshPhysicalMaterial=!0,class extends hs{constructor(t){super(),this.type="MeshPhongMaterial",this.color=new vn(16777215),this.specular=new vn(1118481),this.shininess=30,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new vn(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new at(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=0,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.specular.copy(t.specular),this.shininess=t.shininess,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.flatShading=t.flatShading,this}}.prototype.isMeshPhongMaterial=!0,class extends hs{constructor(t){super(),this.defines={TOON:""},this.type="MeshToonMaterial",this.color=new vn(16777215),this.map=null,this.gradientMap=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new vn(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new at(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.gradientMap=t.gradientMap,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}}.prototype.isMeshToonMaterial=!0,class extends hs{constructor(t){super(),this.type="MeshNormalMaterial",this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new at(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.flatShading=t.flatShading,this}}.prototype.isMeshNormalMaterial=!0,class extends hs{constructor(t){super(),this.type="MeshLambertMaterial",this.color=new vn(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new vn(0),this.emissiveIntensity=1,this.emissiveMap=null,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=0,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.setValues(t)}copy(t){return super.copy(t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this}}.prototype.isMeshLambertMaterial=!0,class extends hs{constructor(t){super(),this.defines={MATCAP:""},this.type="MeshMatcapMaterial",this.color=new vn(16777215),this.matcap=null,this.map=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new at(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.flatShading=!1,this.setValues(t)}copy(t){return super.copy(t),this.defines={MATCAP:""},this.color.copy(t.color),this.matcap=t.matcap,this.map=t.map,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.flatShading=t.flatShading,this}}.prototype.isMeshMatcapMaterial=!0,class extends Ap{constructor(t){super(),this.type="LineDashedMaterial",this.scale=1,this.dashSize=3,this.gapSize=1,this.setValues(t)}copy(t){return super.copy(t),this.scale=t.scale,this.dashSize=t.dashSize,this.gapSize=t.gapSize,this}}.prototype.isLineDashedMaterial=!0;var qr={arraySlice:function(n,t,e){return qr.isTypedArray(n)?new n.constructor(n.subarray(t,void 0!==e?e:n.length)):n.slice(t,e)},convertArray:function(n,t,e){return!n||!e&&n.constructor===t?n:"number"==typeof t.BYTES_PER_ELEMENT?new t(n):Array.prototype.slice.call(n)},isTypedArray:function(n){return ArrayBuffer.isView(n)&&!(n instanceof DataView)},getKeyframeOrder:function(n){let e=n.length,i=new Array(e);for(let r=0;r!==e;++r)i[r]=r;return i.sort(function(r,o){return n[r]-n[o]}),i},sortedArray:function(n,t,e){let i=n.length,r=new n.constructor(i);for(let o=0,s=0;s!==i;++o){let a=e[o]*t;for(let l=0;l!==t;++l)r[s++]=n[a+l]}return r},flattenJSON:function(n,t,e,i){let r=1,o=n[0];for(;void 0!==o&&void 0===o[i];)o=n[r++];if(void 0===o)return;let s=o[i];if(void 0!==s)if(Array.isArray(s))do{s=o[i],void 0!==s&&(t.push(o.time),e.push.apply(e,s)),o=n[r++]}while(void 0!==o);else if(void 0!==s.toArray)do{s=o[i],void 0!==s&&(t.push(o.time),s.toArray(e,e.length)),o=n[r++]}while(void 0!==o);else do{s=o[i],void 0!==s&&(t.push(o.time),e.push(s)),o=n[r++]}while(void 0!==o)},subclip:function(n,t,e,i,r=30){let o=n.clone();o.name=t;let s=[];for(let l=0;l<o.tracks.length;++l){let c=o.tracks[l],u=c.getValueSize(),d=[],p=[];for(let h=0;h<c.times.length;++h){let f=c.times[h]*r;if(!(f<e||f>=i)){d.push(c.times[h]);for(let m=0;m<u;++m)p.push(c.values[h*u+m])}}0!==d.length&&(c.times=qr.convertArray(d,c.times.constructor),c.values=qr.convertArray(p,c.values.constructor),s.push(c))}o.tracks=s;let a=1/0;for(let l=0;l<o.tracks.length;++l)a>o.tracks[l].times[0]&&(a=o.tracks[l].times[0]);for(let l=0;l<o.tracks.length;++l)o.tracks[l].shift(-1*a);return o.resetDuration(),o},makeClipAdditive:function(n,t=0,e=n,i=30){i<=0&&(i=30);let r=e.tracks.length,o=t/i;for(let s=0;s<r;++s){let a=e.tracks[s],l=a.ValueTypeName;if("bool"===l||"string"===l)continue;let c=n.tracks.find(function(g){return g.name===a.name&&g.ValueTypeName===l});if(void 0===c)continue;let u=0,d=a.getValueSize();a.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(u=d/3);let p=0,h=c.getValueSize();c.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(p=h/3);let m,f=a.times.length-1;if(o<=a.times[0])m=qr.arraySlice(a.values,u,d-u);else if(o>=a.times[f]){let g=f*d+u;m=qr.arraySlice(a.values,g,g+d-u)}else{let g=a.createInterpolant(),b=u,D=d-u;g.evaluate(o),m=qr.arraySlice(g.resultBuffer,b,D)}"quaternion"===l&&(new qs).fromArray(m).normalize().conjugate().toArray(m);let x=c.times.length;for(let g=0;g<x;++g){let b=g*h+p;if("quaternion"===l)qs.multiplyQuaternionsFlat(c.values,b,m,0,c.values,b);else{let D=h-2*p;for(let T=0;T<D;++T)c.values[b+T]-=m[T]}}}return n.blendMode=2501,n}},Td=class{constructor(t,e,i,r){this.parameterPositions=t,this._cachedIndex=0,this.resultBuffer=void 0!==r?r:new e.constructor(i),this.sampleValues=e,this.valueSize=i,this.settings=null,this.DefaultSettings_={}}evaluate(t){let e=this.parameterPositions,i=this._cachedIndex,r=e[i],o=e[i-1];e:{t:{let s;n:{i:if(!(t<r)){for(let a=i+2;;){if(void 0===r){if(t<o)break i;return i=e.length,this._cachedIndex=i,this.afterEnd_(i-1,t,o)}if(i===a)break;if(o=r,r=e[++i],t<r)break t}s=e.length;break n}if(t>=o)break e;{let a=e[1];t<a&&(i=2,o=a);for(let l=i-2;;){if(void 0===o)return this._cachedIndex=0,this.beforeStart_(0,t,r);if(i===l)break;if(r=o,o=e[--i-1],t>=o)break t}s=i,i=0}}for(;i<s;){let a=i+s>>>1;t<e[a]?s=a:i=a+1}if(r=e[i],o=e[i-1],void 0===o)return this._cachedIndex=0,this.beforeStart_(0,t,r);if(void 0===r)return i=e.length,this._cachedIndex=i,this.afterEnd_(i-1,o,t)}this._cachedIndex=i,this.intervalChanged_(i,o,r)}return this.interpolate_(i,o,t,r)}getSettings_(){return this.settings||this.DefaultSettings_}copySampleValue_(t){let e=this.resultBuffer,i=this.sampleValues,r=this.valueSize,o=t*r;for(let s=0;s!==r;++s)e[s]=i[o+s];return e}interpolate_(){throw new Error("call to abstract method")}intervalChanged_(){}};Td.prototype.beforeStart_=Td.prototype.copySampleValue_,Td.prototype.afterEnd_=Td.prototype.copySampleValue_;var G8=class extends Td{constructor(t,e,i,r){super(t,e,i,r),this._weightPrev=-0,this._offsetPrev=-0,this._weightNext=-0,this._offsetNext=-0,this.DefaultSettings_={endingStart:ob,endingEnd:ob}}intervalChanged_(t,e,i){let r=this.parameterPositions,o=t-2,s=t+1,a=r[o],l=r[s];if(void 0===a)switch(this.getSettings_().endingStart){case sb:o=t,a=2*e-i;break;case 2402:o=r.length-2,a=e+r[o]-r[o+1];break;default:o=t,a=i}if(void 0===l)switch(this.getSettings_().endingEnd){case sb:s=t,l=2*i-e;break;case 2402:s=1,l=i+r[1]-r[0];break;default:s=t-1,l=e}let c=.5*(i-e),u=this.valueSize;this._weightPrev=c/(e-a),this._weightNext=c/(l-i),this._offsetPrev=o*u,this._offsetNext=s*u}interpolate_(t,e,i,r){let o=this.resultBuffer,s=this.sampleValues,a=this.valueSize,l=t*a,c=l-a,u=this._offsetPrev,d=this._offsetNext,p=this._weightPrev,h=this._weightNext,f=(i-e)/(r-e),m=f*f,x=m*f,g=-p*x+2*p*m-p*f,b=(1+p)*x+(-1.5-2*p)*m+(-.5+p)*f+1,D=(-1-h)*x+(1.5+h)*m+.5*f,T=h*x-h*m;for(let k=0;k!==a;++k)o[k]=g*s[u+k]+b*s[c+k]+D*s[l+k]+T*s[d+k];return o}},Mk=class extends Td{constructor(t,e,i,r){super(t,e,i,r)}interpolate_(t,e,i,r){let o=this.resultBuffer,s=this.sampleValues,a=this.valueSize,l=t*a,c=l-a,u=(i-e)/(r-e),d=1-u;for(let p=0;p!==a;++p)o[p]=s[c+p]*d+s[l+p]*u;return o}},W8=class extends Td{constructor(t,e,i,r){super(t,e,i,r)}interpolate_(t){return this.copySampleValue_(t-1)}},hc=class{constructor(t,e,i,r){if(void 0===t)throw new Error("THREE.KeyframeTrack: track name is undefined");if(void 0===e||0===e.length)throw new Error("THREE.KeyframeTrack: no keyframes in track named "+t);this.name=t,this.times=qr.convertArray(e,this.TimeBufferType),this.values=qr.convertArray(i,this.ValueBufferType),this.setInterpolation(r||this.DefaultInterpolation)}static toJSON(t){let i,e=t.constructor;if(e.toJSON!==this.toJSON)i=e.toJSON(t);else{i={name:t.name,times:qr.convertArray(t.times,Array),values:qr.convertArray(t.values,Array)};let r=t.getInterpolation();r!==t.DefaultInterpolation&&(i.interpolation=r)}return i.type=t.ValueTypeName,i}InterpolantFactoryMethodDiscrete(t){return new W8(this.times,this.values,this.getValueSize(),t)}InterpolantFactoryMethodLinear(t){return new Mk(this.times,this.values,this.getValueSize(),t)}InterpolantFactoryMethodSmooth(t){return new G8(this.times,this.values,this.getValueSize(),t)}setInterpolation(t){let e;switch(t){case 2300:e=this.InterpolantFactoryMethodDiscrete;break;case 2301:e=this.InterpolantFactoryMethodLinear;break;case 2302:e=this.InterpolantFactoryMethodSmooth}if(void 0===e){let i="unsupported interpolation for "+this.ValueTypeName+" keyframe track named "+this.name;if(void 0===this.createInterpolant){if(t===this.DefaultInterpolation)throw new Error(i);this.setInterpolation(this.DefaultInterpolation)}return console.warn("THREE.KeyframeTrack:",i),this}return this.createInterpolant=e,this}getInterpolation(){switch(this.createInterpolant){case this.InterpolantFactoryMethodDiscrete:return 2300;case this.InterpolantFactoryMethodLinear:return 2301;case this.InterpolantFactoryMethodSmooth:return 2302}}getValueSize(){return this.values.length/this.times.length}shift(t){if(0!==t){let e=this.times;for(let i=0,r=e.length;i!==r;++i)e[i]+=t}return this}scale(t){if(1!==t){let e=this.times;for(let i=0,r=e.length;i!==r;++i)e[i]*=t}return this}trim(t,e){let i=this.times,r=i.length,o=0,s=r-1;for(;o!==r&&i[o]<t;)++o;for(;-1!==s&&i[s]>e;)--s;if(++s,0!==o||s!==r){o>=s&&(s=Math.max(s,1),o=s-1);let a=this.getValueSize();this.times=qr.arraySlice(i,o,s),this.values=qr.arraySlice(this.values,o*a,s*a)}return this}validate(){let t=!0,e=this.getValueSize();e-Math.floor(e)!=0&&(console.error("THREE.KeyframeTrack: Invalid value size in track.",this),t=!1);let i=this.times,r=this.values,o=i.length;0===o&&(console.error("THREE.KeyframeTrack: Track is empty.",this),t=!1);let s=null;for(let a=0;a!==o;a++){let l=i[a];if("number"==typeof l&&isNaN(l)){console.error("THREE.KeyframeTrack: Time is not a valid number.",this,a,l),t=!1;break}if(null!==s&&s>l){console.error("THREE.KeyframeTrack: Out of order keys.",this,a,l,s),t=!1;break}s=l}if(void 0!==r&&qr.isTypedArray(r))for(let a=0,l=r.length;a!==l;++a){let c=r[a];if(isNaN(c)){console.error("THREE.KeyframeTrack: Value is not a valid number.",this,a,c),t=!1;break}}return t}optimize(){let t=qr.arraySlice(this.times),e=qr.arraySlice(this.values),i=this.getValueSize(),r=2302===this.getInterpolation(),o=t.length-1,s=1;for(let a=1;a<o;++a){let l=!1,c=t[a];if(c!==t[a+1]&&(1!==a||c!==t[0]))if(r)l=!0;else{let d=a*i,p=d-i,h=d+i;for(let f=0;f!==i;++f){let m=e[d+f];if(m!==e[p+f]||m!==e[h+f]){l=!0;break}}}if(l){if(a!==s){t[s]=t[a];let d=a*i,p=s*i;for(let h=0;h!==i;++h)e[p+h]=e[d+h]}++s}}if(o>0){t[s]=t[o];for(let a=o*i,l=s*i,c=0;c!==i;++c)e[l+c]=e[a+c];++s}return s!==t.length?(this.times=qr.arraySlice(t,0,s),this.values=qr.arraySlice(e,0,s*i)):(this.times=t,this.values=e),this}clone(){let t=qr.arraySlice(this.times,0),e=qr.arraySlice(this.values,0),r=new(0,this.constructor)(this.name,t,e);return r.createInterpolant=this.createInterpolant,r}};hc.prototype.TimeBufferType=Float32Array,hc.prototype.ValueBufferType=Float32Array,hc.prototype.DefaultInterpolation=2301;var Ef=class extends hc{};Ef.prototype.ValueTypeName="bool",Ef.prototype.ValueBufferType=Array,Ef.prototype.DefaultInterpolation=2300,Ef.prototype.InterpolantFactoryMethodLinear=void 0,Ef.prototype.InterpolantFactoryMethodSmooth=void 0;var wk=class extends hc{};wk.prototype.ValueTypeName="color";var Cb=class extends hc{};Cb.prototype.ValueTypeName="number";var q8=class extends Td{constructor(t,e,i,r){super(t,e,i,r)}interpolate_(t,e,i,r){let o=this.resultBuffer,s=this.sampleValues,a=this.valueSize,l=(i-e)/(r-e),c=t*a;for(let u=c+a;c!==u;c+=4)qs.slerpFlat(o,0,s,c-a,s,c,l);return o}},Kg=class extends hc{InterpolantFactoryMethodLinear(t){return new q8(this.times,this.values,this.getValueSize(),t)}};Kg.prototype.ValueTypeName="quaternion",Kg.prototype.DefaultInterpolation=2301,Kg.prototype.InterpolantFactoryMethodSmooth=void 0;var Tf=class extends hc{};Tf.prototype.ValueTypeName="string",Tf.prototype.ValueBufferType=Array,Tf.prototype.DefaultInterpolation=2300,Tf.prototype.InterpolantFactoryMethodLinear=void 0,Tf.prototype.InterpolantFactoryMethodSmooth=void 0;var Mb=class extends hc{};Mb.prototype.ValueTypeName="vector";var Sk=class{constructor(t,e=-1,i,r=2500){this.name=t,this.tracks=i,this.duration=e,this.blendMode=r,this.uuid=du(),this.duration<0&&this.resetDuration()}static parse(t){let e=[],i=t.tracks,r=1/(t.fps||1);for(let s=0,a=i.length;s!==a;++s)e.push(Y9e(i[s]).scale(r));let o=new this(t.name,t.duration,e,t.blendMode);return o.uuid=t.uuid,o}static toJSON(t){let e=[],i=t.tracks,r={name:t.name,duration:t.duration,tracks:e,uuid:t.uuid,blendMode:t.blendMode};for(let o=0,s=i.length;o!==s;++o)e.push(hc.toJSON(i[o]));return r}static CreateFromMorphTargetSequence(t,e,i,r){let o=e.length,s=[];for(let a=0;a<o;a++){let l=[],c=[];l.push((a+o-1)%o,a,(a+1)%o),c.push(0,1,0);let u=qr.getKeyframeOrder(l);l=qr.sortedArray(l,1,u),c=qr.sortedArray(c,1,u),!r&&0===l[0]&&(l.push(o),c.push(c[0])),s.push(new Cb(".morphTargetInfluences["+e[a].name+"]",l,c).scale(1/i))}return new this(t,-1,s)}static findByName(t,e){let i=t;if(!Array.isArray(t)){let r=t;i=r.geometry&&r.geometry.animations||r.animations}for(let r=0;r<i.length;r++)if(i[r].name===e)return i[r];return null}static CreateClipsFromMorphTargetSequences(t,e,i){let r={},o=/^([\w-]*?)([\d]+)$/;for(let a=0,l=t.length;a<l;a++){let c=t[a],u=c.name.match(o);if(u&&u.length>1){let d=u[1],p=r[d];p||(r[d]=p=[]),p.push(c)}}let s=[];for(let a in r)s.push(this.CreateFromMorphTargetSequence(a,r[a],e,i));return s}static parseAnimation(t,e){if(!t)return console.error("THREE.AnimationClip: No animation in JSONLoader data."),null;let i=function(d,p,h,f,m){if(0!==h.length){let x=[],g=[];qr.flattenJSON(h,x,g,f),0!==x.length&&m.push(new d(p,x,g))}},r=[],o=t.name||"default",s=t.fps||30,a=t.blendMode,l=t.length||-1,c=t.hierarchy||[];for(let d=0;d<c.length;d++){let p=c[d].keys;if(p&&0!==p.length)if(p[0].morphTargets){let f,h={};for(f=0;f<p.length;f++)if(p[f].morphTargets)for(let m=0;m<p[f].morphTargets.length;m++)h[p[f].morphTargets[m]]=-1;for(let m in h){let x=[],g=[];for(let b=0;b!==p[f].morphTargets.length;++b){let D=p[f];x.push(D.time),g.push(D.morphTarget===m?1:0)}r.push(new Cb(".morphTargetInfluence["+m+"]",x,g))}l=h.length*(s||1)}else{let h=".bones["+e[d].name+"]";i(Mb,h+".position",p,"pos",r),i(Kg,h+".quaternion",p,"rot",r),i(Mb,h+".scale",p,"scl",r)}}return 0===r.length?null:new this(o,l,r,a)}resetDuration(){let e=0;for(let i=0,r=this.tracks.length;i!==r;++i){let o=this.tracks[i];e=Math.max(e,o.times[o.times.length-1])}return this.duration=e,this}trim(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].trim(0,this.duration);return this}validate(){let t=!0;for(let e=0;e<this.tracks.length;e++)t=t&&this.tracks[e].validate();return t}optimize(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].optimize();return this}clone(){let t=[];for(let e=0;e<this.tracks.length;e++)t.push(this.tracks[e].clone());return new this.constructor(this.name,this.duration,t,this.blendMode)}toJSON(){return this.constructor.toJSON(this)}};function Y9e(n){if(void 0===n.type)throw new Error("THREE.KeyframeTrack: track type undefined, can not parse");let t=function(n){switch(n.toLowerCase()){case"scalar":case"double":case"float":case"number":case"integer":return Cb;case"vector":case"vector2":case"vector3":case"vector4":return Mb;case"color":return wk;case"quaternion":return Kg;case"bool":case"boolean":return Ef;case"string":return Tf}throw new Error("THREE.KeyframeTrack: Unsupported typeName: "+n)}(n.type);if(void 0===n.times){let e=[],i=[];qr.flattenJSON(n.keys,e,i,"value"),n.times=e,n.values=i}return void 0!==t.parse?t.parse(n):new t(n.name,n.times,n.values,n.interpolation)}var wb={enabled:!1,files:{},add:function(n,t){!1!==this.enabled&&(this.files[n]=t)},get:function(n){if(!1!==this.enabled)return this.files[n]},remove:function(n){delete this.files[n]},clear:function(){this.files={}}},X9e=new class{constructor(t,e,i){let l,r=this,o=!1,s=0,a=0,c=[];this.onStart=void 0,this.onLoad=t,this.onProgress=e,this.onError=i,this.itemStart=function(u){a++,!1===o&&void 0!==r.onStart&&r.onStart(u,s,a),o=!0},this.itemEnd=function(u){s++,void 0!==r.onProgress&&r.onProgress(u,s,a),s===a&&(o=!1,void 0!==r.onLoad&&r.onLoad())},this.itemError=function(u){void 0!==r.onError&&r.onError(u)},this.resolveURL=function(u){return l?l(u):u},this.setURLModifier=function(u){return l=u,this},this.addHandler=function(u,d){return c.push(u,d),this},this.removeHandler=function(u){let d=c.indexOf(u);return-1!==d&&c.splice(d,2),this},this.getHandler=function(u){for(let d=0,p=c.length;d<p;d+=2){let h=c[d],f=c[d+1];if(h.global&&(h.lastIndex=0),h.test(u))return f}return null}}},Dd=class{constructor(t){this.manager=void 0!==t?t:X9e,this.crossOrigin="anonymous",this.withCredentials=!1,this.path="",this.resourcePath="",this.requestHeader={}}load(){}loadAsync(t,e){let i=this;return new Promise(function(r,o){i.load(t,r,e,o)})}parse(){}setCrossOrigin(t){return this.crossOrigin=t,this}setWithCredentials(t){return this.withCredentials=t,this}setPath(t){return this.path=t,this}setResourcePath(t){return this.resourcePath=t,this}setRequestHeader(t){return this.requestHeader=t,this}},Sp={},X8=class extends Dd{constructor(t){super(t)}load(t,e,i,r){void 0===t&&(t=""),void 0!==this.path&&(t=this.path+t),t=this.manager.resolveURL(t);let o=wb.get(t);if(void 0!==o)return this.manager.itemStart(t),setTimeout(()=>{e&&e(o),this.manager.itemEnd(t)},0),o;if(void 0!==Sp[t])return void Sp[t].push({onLoad:e,onProgress:i,onError:r});Sp[t]=[],Sp[t].push({onLoad:e,onProgress:i,onError:r});let s=new Request(t,{headers:new Headers(this.requestHeader),credentials:this.withCredentials?"include":"same-origin"}),a=this.mimeType,l=this.responseType;fetch(s).then(c=>{if(200===c.status||0===c.status){if(0===c.status&&console.warn("THREE.FileLoader: HTTP Status 0 received."),typeof ReadableStream>"u"||void 0===c.body.getReader)return c;let u=Sp[t],d=c.body.getReader(),p=c.headers.get("Content-Length"),h=p?parseInt(p):0,f=0!==h,m=0,x=new ReadableStream({start(g){!function b(){d.read().then(({done:D,value:T})=>{if(D)g.close();else{m+=T.byteLength;let k=new ProgressEvent("progress",{lengthComputable:f,loaded:m,total:h});for(let Z=0,z=u.length;Z<z;Z++){let fe=u[Z];fe.onProgress&&fe.onProgress(k)}g.enqueue(T),b()}})}()}});return new Response(x)}throw Error(`fetch for "${c.url}" responded with ${c.status}: ${c.statusText}`)}).then(c=>{switch(l){case"arraybuffer":return c.arrayBuffer();case"blob":return c.blob();case"document":return c.text().then(u=>(new DOMParser).parseFromString(u,a));case"json":return c.json();default:if(void 0===a)return c.text();{let d=/charset="?([^;"\s]*)"?/i.exec(a),p=d&&d[1]?d[1].toLowerCase():void 0,h=new TextDecoder(p);return c.arrayBuffer().then(f=>h.decode(f))}}}).then(c=>{wb.add(t,c);let u=Sp[t];delete Sp[t];for(let d=0,p=u.length;d<p;d++){let h=u[d];h.onLoad&&h.onLoad(c)}}).catch(c=>{let u=Sp[t];if(void 0===u)throw this.manager.itemError(t),c;delete Sp[t];for(let d=0,p=u.length;d<p;d++){let h=u[d];h.onError&&h.onError(c)}this.manager.itemError(t)}).finally(()=>{this.manager.itemEnd(t)}),this.manager.itemStart(t)}setResponseType(t){return this.responseType=t,this}setMimeType(t){return this.mimeType=t,this}},Ek=class extends Dd{constructor(t){super(t)}load(t,e,i,r){void 0!==this.path&&(t=this.path+t),t=this.manager.resolveURL(t);let o=this,s=wb.get(t);if(void 0!==s)return o.manager.itemStart(t),setTimeout(function(){e&&e(s),o.manager.itemEnd(t)},0),s;let a=YS("img");function l(){u(),wb.add(t,this),e&&e(this),o.manager.itemEnd(t)}function c(d){u(),r&&r(d),o.manager.itemError(t),o.manager.itemEnd(t)}function u(){a.removeEventListener("load",l,!1),a.removeEventListener("error",c,!1)}return a.addEventListener("load",l,!1),a.addEventListener("error",c,!1),"data:"!==t.substr(0,5)&&void 0!==this.crossOrigin&&(a.crossOrigin=this.crossOrigin),o.manager.itemStart(t),a.src=t,a}},Q8=class extends Dd{constructor(t){super(t)}load(t,e,i,r){let o=new mb,s=new Ek(this.manager);s.setCrossOrigin(this.crossOrigin),s.setPath(this.path);let a=0;function l(c){s.load(t[c],function(u){o.images[c]=u,a++,6===a&&(o.needsUpdate=!0,e&&e(o))},void 0,r)}for(let c=0;c<t.length;++c)l(c);return o}},K8=class extends Dd{constructor(t){super(t)}load(t,e,i,r){let o=new Ho,s=new Ek(this.manager);return s.setCrossOrigin(this.crossOrigin),s.setPath(this.path),s.load(t,function(a){o.image=a,o.needsUpdate=!0,void 0!==e&&e(o)},i,r),o}},fc=class extends Xi{constructor(t,e=1){super(),this.type="Light",this.color=new vn(t),this.intensity=e}dispose(){}copy(t){return super.copy(t),this.color.copy(t.color),this.intensity=t.intensity,this}toJSON(t){let e=super.toJSON(t);return e.object.color=this.color.getHex(),e.object.intensity=this.intensity,void 0!==this.groundColor&&(e.object.groundColor=this.groundColor.getHex()),void 0!==this.distance&&(e.object.distance=this.distance),void 0!==this.angle&&(e.object.angle=this.angle),void 0!==this.decay&&(e.object.decay=this.decay),void 0!==this.penumbra&&(e.object.penumbra=this.penumbra),void 0!==this.shadow&&(e.object.shadow=this.shadow.toJSON()),e}};fc.prototype.isLight=!0,class extends fc{constructor(t,e,i){super(t,i),this.type="HemisphereLight",this.position.copy(Xi.DefaultUp),this.updateMatrix(),this.groundColor=new vn(e)}copy(t){return fc.prototype.copy.call(this,t),this.groundColor.copy(t.groundColor),this}}.prototype.isHemisphereLight=!0;var xde=new Rn,Cde=new ie,Mde=new ie,pE=class{constructor(t){this.camera=t,this.bias=0,this.normalBias=0,this.radius=1,this.blurSamples=8,this.mapSize=new at(512,512),this.map=null,this.mapPass=null,this.matrix=new Rn,this.autoUpdate=!0,this.needsUpdate=!1,this._frustum=new gb,this._frameExtents=new at(1,1),this._viewportCount=1,this._viewports=[new ar(0,0,1,1)]}getViewportCount(){return this._viewportCount}getFrustum(){return this._frustum}updateMatrices(t){let e=this.camera,i=this.matrix;Cde.setFromMatrixPosition(t.matrixWorld),e.position.copy(Cde),Mde.setFromMatrixPosition(t.target.matrixWorld),e.lookAt(Mde),e.updateMatrixWorld(),xde.multiplyMatrices(e.projectionMatrix,e.matrixWorldInverse),this._frustum.setFromProjectionMatrix(xde),i.set(.5,0,0,.5,0,.5,0,.5,0,0,.5,.5,0,0,0,1),i.multiply(e.projectionMatrix),i.multiply(e.matrixWorldInverse)}getViewport(t){return this._viewports[t]}getFrameExtents(){return this._frameExtents}dispose(){this.map&&this.map.dispose(),this.mapPass&&this.mapPass.dispose()}copy(t){return this.camera=t.camera.clone(),this.bias=t.bias,this.radius=t.radius,this.mapSize.copy(t.mapSize),this}clone(){return(new this.constructor).copy(this)}toJSON(){let t={};return 0!==this.bias&&(t.bias=this.bias),0!==this.normalBias&&(t.normalBias=this.normalBias),1!==this.radius&&(t.radius=this.radius),(512!==this.mapSize.x||512!==this.mapSize.y)&&(t.mapSize=this.mapSize.toArray()),t.camera=this.camera.toJSON(!1).object,delete t.camera.matrix,t}},Tk=class extends pE{constructor(){super(new Ws(50,1,.5,500)),this.focus=1}updateMatrices(t){let e=this.camera,i=2*h8*t.angle*this.focus,r=this.mapSize.width/this.mapSize.height,o=t.distance||e.far;(i!==e.fov||r!==e.aspect||o!==e.far)&&(e.fov=i,e.aspect=r,e.far=o,e.updateProjectionMatrix()),super.updateMatrices(t)}copy(t){return super.copy(t),this.focus=t.focus,this}};Tk.prototype.isSpotLightShadow=!0,class extends fc{constructor(t,e,i=0,r=Math.PI/3,o=0,s=1){super(t,e),this.type="SpotLight",this.position.copy(Xi.DefaultUp),this.updateMatrix(),this.target=new Xi,this.distance=i,this.angle=r,this.penumbra=o,this.decay=s,this.shadow=new Tk}get power(){return this.intensity*Math.PI}set power(t){this.intensity=t/Math.PI}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.distance=t.distance,this.angle=t.angle,this.penumbra=t.penumbra,this.decay=t.decay,this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}}.prototype.isSpotLight=!0;var wde=new Rn,LS=new ie,o8=new ie,Dk=class extends pE{constructor(){super(new Ws(90,1,.5,500)),this._frameExtents=new at(4,2),this._viewportCount=6,this._viewports=[new ar(2,1,1,1),new ar(0,1,1,1),new ar(3,1,1,1),new ar(1,1,1,1),new ar(3,0,1,1),new ar(1,0,1,1)],this._cubeDirections=[new ie(1,0,0),new ie(-1,0,0),new ie(0,0,1),new ie(0,0,-1),new ie(0,1,0),new ie(0,-1,0)],this._cubeUps=[new ie(0,1,0),new ie(0,1,0),new ie(0,1,0),new ie(0,1,0),new ie(0,0,1),new ie(0,0,-1)]}updateMatrices(t,e=0){let i=this.camera,r=this.matrix,o=t.distance||i.far;o!==i.far&&(i.far=o,i.updateProjectionMatrix()),LS.setFromMatrixPosition(t.matrixWorld),i.position.copy(LS),o8.copy(i.position),o8.add(this._cubeDirections[e]),i.up.copy(this._cubeUps[e]),i.lookAt(o8),i.updateMatrixWorld(),r.makeTranslation(-LS.x,-LS.y,-LS.z),wde.multiplyMatrices(i.projectionMatrix,i.matrixWorldInverse),this._frustum.setFromProjectionMatrix(wde)}};Dk.prototype.isPointLightShadow=!0,class extends fc{constructor(t,e,i=0,r=1){super(t,e),this.type="PointLight",this.distance=i,this.decay=r,this.shadow=new Dk}get power(){return 4*this.intensity*Math.PI}set power(t){this.intensity=t/(4*Math.PI)}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.distance=t.distance,this.decay=t.decay,this.shadow=t.shadow.clone(),this}}.prototype.isPointLight=!0;var Ak=class extends pE{constructor(){super(new qg(-5,5,5,-5,.5,500))}};Ak.prototype.isDirectionalLightShadow=!0,class extends fc{constructor(t,e){super(t,e),this.type="DirectionalLight",this.position.copy(Xi.DefaultUp),this.updateMatrix(),this.target=new Xi,this.shadow=new Ak}dispose(){this.shadow.dispose()}copy(t){return super.copy(t),this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}}.prototype.isDirectionalLight=!0,class extends fc{constructor(t,e){super(t,e),this.type="AmbientLight"}}.prototype.isAmbientLight=!0,class extends fc{constructor(t,e,i=10,r=10){super(t,e),this.type="RectAreaLight",this.width=i,this.height=r}get power(){return this.intensity*this.width*this.height*Math.PI}set power(t){this.intensity=t/(this.width*this.height*Math.PI)}copy(t){return super.copy(t),this.width=t.width,this.height=t.height,this}toJSON(t){let e=super.toJSON(t);return e.object.width=this.width,e.object.height=this.height,e}}.prototype.isRectAreaLight=!0;var Ik=class{constructor(){this.coefficients=[];for(let t=0;t<9;t++)this.coefficients.push(new ie)}set(t){for(let e=0;e<9;e++)this.coefficients[e].copy(t[e]);return this}zero(){for(let t=0;t<9;t++)this.coefficients[t].set(0,0,0);return this}getAt(t,e){let i=t.x,r=t.y,o=t.z,s=this.coefficients;return e.copy(s[0]).multiplyScalar(.282095),e.addScaledVector(s[1],.488603*r),e.addScaledVector(s[2],.488603*o),e.addScaledVector(s[3],.488603*i),e.addScaledVector(s[4],i*r*1.092548),e.addScaledVector(s[5],r*o*1.092548),e.addScaledVector(s[6],.315392*(3*o*o-1)),e.addScaledVector(s[7],i*o*1.092548),e.addScaledVector(s[8],.546274*(i*i-r*r)),e}getIrradianceAt(t,e){let i=t.x,r=t.y,o=t.z,s=this.coefficients;return e.copy(s[0]).multiplyScalar(.886227),e.addScaledVector(s[1],1.023328*r),e.addScaledVector(s[2],1.023328*o),e.addScaledVector(s[3],1.023328*i),e.addScaledVector(s[4],.858086*i*r),e.addScaledVector(s[5],.858086*r*o),e.addScaledVector(s[6],.743125*o*o-.247708),e.addScaledVector(s[7],.858086*i*o),e.addScaledVector(s[8],.429043*(i*i-r*r)),e}add(t){for(let e=0;e<9;e++)this.coefficients[e].add(t.coefficients[e]);return this}addScaledSH(t,e){for(let i=0;i<9;i++)this.coefficients[i].addScaledVector(t.coefficients[i],e);return this}scale(t){for(let e=0;e<9;e++)this.coefficients[e].multiplyScalar(t);return this}lerp(t,e){for(let i=0;i<9;i++)this.coefficients[i].lerp(t.coefficients[i],e);return this}equals(t){for(let e=0;e<9;e++)if(!this.coefficients[e].equals(t.coefficients[e]))return!1;return!0}copy(t){return this.set(t.coefficients)}clone(){return(new this.constructor).copy(this)}fromArray(t,e=0){let i=this.coefficients;for(let r=0;r<9;r++)i[r].fromArray(t,e+3*r);return this}toArray(t=[],e=0){let i=this.coefficients;for(let r=0;r<9;r++)i[r].toArray(t,e+3*r);return t}static getBasisAt(t,e){let i=t.x,r=t.y,o=t.z;e[0]=.282095,e[1]=.488603*r,e[2]=.488603*o,e[3]=.488603*i,e[4]=1.092548*i*r,e[5]=1.092548*r*o,e[6]=.315392*(3*o*o-1),e[7]=1.092548*i*o,e[8]=.546274*(i*i-r*r)}};Ik.prototype.isSphericalHarmonics3=!0;var hE=class extends fc{constructor(t=new Ik,e=1){super(void 0,e),this.sh=t}copy(t){return super.copy(t),this.sh.copy(t.sh),this}fromJSON(t){return this.intensity=t.intensity,this.sh.fromArray(t.sh),this}toJSON(t){let e=super.toJSON(t);return e.object.sh=this.sh.toArray(),e}};hE.prototype.isLightProbe=!0;var iG=class{static decodeText(t){if(typeof TextDecoder<"u")return(new TextDecoder).decode(t);let e="";for(let i=0,r=t.length;i<r;i++)e+=String.fromCharCode(t[i]);try{return decodeURIComponent(escape(e))}catch{return e}}static extractUrlBase(t){let e=t.lastIndexOf("/");return-1===e?"./":t.substr(0,e+1)}static resolveURL(t,e){return"string"!=typeof t||""===t?"":(/^https?:\/\//i.test(e)&&/^\//.test(t)&&(e=e.replace(/(^https?:\/\/[^\/]+).*/i,"$1")),/^(https?:)?\/\//i.test(t)||/^data:.*,.*$/i.test(t)||/^blob:.*$/i.test(t)?t:e+t)}};(class extends nr{constructor(){super(),this.type="InstancedBufferGeometry",this.instanceCount=1/0}copy(t){return super.copy(t),this.instanceCount=t.instanceCount,this}clone(){return(new this.constructor).copy(this)}toJSON(){let t=super.toJSON(this);return t.instanceCount=this.instanceCount,t.isInstancedBufferGeometry=!0,t}}).prototype.isInstancedBufferGeometry=!0,class extends Dd{constructor(t){super(t),typeof createImageBitmap>"u"&&console.warn("THREE.ImageBitmapLoader: createImageBitmap() not supported."),typeof fetch>"u"&&console.warn("THREE.ImageBitmapLoader: fetch() not supported."),this.options={premultiplyAlpha:"none"}}setOptions(t){return this.options=t,this}load(t,e,i,r){void 0===t&&(t=""),void 0!==this.path&&(t=this.path+t),t=this.manager.resolveURL(t);let o=this,s=wb.get(t);if(void 0!==s)return o.manager.itemStart(t),setTimeout(function(){e&&e(s),o.manager.itemEnd(t)},0),s;let a={};a.credentials="anonymous"===this.crossOrigin?"same-origin":"include",a.headers=this.requestHeader,fetch(t,a).then(function(l){return l.blob()}).then(function(l){return createImageBitmap(l,Object.assign(o.options,{colorSpaceConversion:"none"}))}).then(function(l){wb.add(t,l),e&&e(l),o.manager.itemEnd(t)}).catch(function(l){r&&r(l),o.manager.itemError(t),o.manager.itemEnd(t)}),o.manager.itemStart(t)}}.prototype.isImageBitmapLoader=!0;var JO,sG=class extends Dd{constructor(t){super(t)}load(t,e,i,r){let o=this,s=new X8(this.manager);s.setResponseType("arraybuffer"),s.setPath(this.path),s.setRequestHeader(this.requestHeader),s.setWithCredentials(this.withCredentials),s.load(t,function(a){try{let l=a.slice(0);(void 0===JO&&(JO=new(window.AudioContext||window.webkitAudioContext)),JO).decodeAudioData(l,function(u){e(u)})}catch(l){r?r(l):console.error(l),o.manager.itemError(t)}},i,r)}};(class extends hE{constructor(t,e,i=1){super(void 0,i);let r=(new vn).set(t),o=(new vn).set(e),s=new ie(r.r,r.g,r.b),a=new ie(o.r,o.g,o.b),l=Math.sqrt(Math.PI),c=l*Math.sqrt(.75);this.sh.coefficients[0].copy(s).add(a).multiplyScalar(l),this.sh.coefficients[1].copy(s).sub(a).multiplyScalar(c)}}).prototype.isHemisphereLightProbe=!0,class extends hE{constructor(t,e=1){super(void 0,e);let i=(new vn).set(t);this.sh.coefficients[0].set(i.r,i.g,i.b).multiplyScalar(2*Math.sqrt(Math.PI))}}.prototype.isAmbientLightProbe=!0;var dG=class{constructor(t,e,i){let r,o,s;switch(this.binding=t,this.valueSize=i,e){case"quaternion":r=this._slerp,o=this._slerpAdditive,s=this._setAdditiveIdentityQuaternion,this.buffer=new Float64Array(6*i),this._workIndex=5;break;case"string":case"bool":r=this._select,o=this._select,s=this._setAdditiveIdentityOther,this.buffer=new Array(5*i);break;default:r=this._lerp,o=this._lerpAdditive,s=this._setAdditiveIdentityNumeric,this.buffer=new Float64Array(5*i)}this._mixBufferRegion=r,this._mixBufferRegionAdditive=o,this._setIdentity=s,this._origIndex=3,this._addIndex=4,this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,this.useCount=0,this.referenceCount=0}accumulate(t,e){let i=this.buffer,r=this.valueSize,o=t*r+r,s=this.cumulativeWeight;if(0===s){for(let a=0;a!==r;++a)i[o+a]=i[a];s=e}else s+=e,this._mixBufferRegion(i,o,0,e/s,r);this.cumulativeWeight=s}accumulateAdditive(t){let e=this.buffer,i=this.valueSize,r=i*this._addIndex;0===this.cumulativeWeightAdditive&&this._setIdentity(),this._mixBufferRegionAdditive(e,r,0,t,i),this.cumulativeWeightAdditive+=t}apply(t){let e=this.valueSize,i=this.buffer,r=t*e+e,o=this.cumulativeWeight,s=this.cumulativeWeightAdditive,a=this.binding;this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,o<1&&this._mixBufferRegion(i,r,e*this._origIndex,1-o,e),s>0&&this._mixBufferRegionAdditive(i,r,this._addIndex*e,1,e);for(let l=e,c=e+e;l!==c;++l)if(i[l]!==i[l+e]){a.setValue(i,r);break}}saveOriginalState(){let e=this.buffer,i=this.valueSize,r=i*this._origIndex;this.binding.getValue(e,r);for(let o=i,s=r;o!==s;++o)e[o]=e[r+o%i];this._setIdentity(),this.cumulativeWeight=0,this.cumulativeWeightAdditive=0}restoreOriginalState(){this.binding.setValue(this.buffer,3*this.valueSize)}_setAdditiveIdentityNumeric(){let t=this._addIndex*this.valueSize,e=t+this.valueSize;for(let i=t;i<e;i++)this.buffer[i]=0}_setAdditiveIdentityQuaternion(){this._setAdditiveIdentityNumeric(),this.buffer[this._addIndex*this.valueSize+3]=1}_setAdditiveIdentityOther(){let t=this._origIndex*this.valueSize,e=this._addIndex*this.valueSize;for(let i=0;i<this.valueSize;i++)this.buffer[e+i]=this.buffer[t+i]}_select(t,e,i,r,o){if(r>=.5)for(let s=0;s!==o;++s)t[e+s]=t[i+s]}_slerp(t,e,i,r){qs.slerpFlat(t,e,t,e,t,i,r)}_slerpAdditive(t,e,i,r,o){let s=this._workIndex*o;qs.multiplyQuaternionsFlat(t,s,t,e,t,i),qs.slerpFlat(t,e,t,e,t,s,r)}_lerp(t,e,i,r,o){let s=1-r;for(let a=0;a!==o;++a){let l=e+a;t[l]=t[l]*s+t[i+a]*r}}_lerpAdditive(t,e,i,r,o){for(let s=0;s!==o;++s){let a=e+s;t[a]=t[a]+t[i+s]*r}}},EG="\\[\\]\\.:\\/",K9e=new RegExp("["+EG+"]","g"),TG="[^"+EG+"]",Z9e="[^"+EG.replace("\\.","")+"]",J9e=/((?:WC+[\/:])*)/.source.replace("WC",TG),$9e=/(WCOD+)?/.source.replace("WCOD",Z9e),eqe=/(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace("WC",TG),tqe=/\.(WC+)(?:\[(.+)\])?/.source.replace("WC",TG),nqe=new RegExp("^"+J9e+$9e+eqe+tqe+"$"),iqe=["material","materials","bones"],pG=class{constructor(t,e,i){let r=i||Lr.parseTrackName(e);this._targetGroup=t,this._bindings=t.subscribe_(e,r)}getValue(t,e){this.bind();let r=this._bindings[this._targetGroup.nCachedObjects_];void 0!==r&&r.getValue(t,e)}setValue(t,e){let i=this._bindings;for(let r=this._targetGroup.nCachedObjects_,o=i.length;r!==o;++r)i[r].setValue(t,e)}bind(){let t=this._bindings;for(let e=this._targetGroup.nCachedObjects_,i=t.length;e!==i;++e)t[e].bind()}unbind(){let t=this._bindings;for(let e=this._targetGroup.nCachedObjects_,i=t.length;e!==i;++e)t[e].unbind()}},Lr=(()=>{class n{constructor(e,i,r){this.path=i,this.parsedPath=r||n.parseTrackName(i),this.node=n.findNode(e,this.parsedPath.nodeName)||e,this.rootNode=e,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}static create(e,i,r){return e&&e.isAnimationObjectGroup?new n.Composite(e,i,r):new n(e,i,r)}static sanitizeNodeName(e){return e.replace(/\s/g,"_").replace(K9e,"")}static parseTrackName(e){let i=nqe.exec(e);if(!i)throw new Error("PropertyBinding: Cannot parse trackName: "+e);let r={nodeName:i[2],objectName:i[3],objectIndex:i[4],propertyName:i[5],propertyIndex:i[6]},o=r.nodeName&&r.nodeName.lastIndexOf(".");if(void 0!==o&&-1!==o){let s=r.nodeName.substring(o+1);-1!==iqe.indexOf(s)&&(r.nodeName=r.nodeName.substring(0,o),r.objectName=s)}if(null===r.propertyName||0===r.propertyName.length)throw new Error("PropertyBinding: can not parse propertyName from trackName: "+e);return r}static findNode(e,i){if(!i||""===i||"."===i||-1===i||i===e.name||i===e.uuid)return e;if(e.skeleton){let r=e.skeleton.getBoneByName(i);if(void 0!==r)return r}if(e.children){let r=function(s){for(let a=0;a<s.length;a++){let l=s[a];if(l.name===i||l.uuid===i)return l;let c=r(l.children);if(c)return c}return null},o=r(e.children);if(o)return o}return null}_getValue_unavailable(){}_setValue_unavailable(){}_getValue_direct(e,i){e[i]=this.targetObject[this.propertyName]}_getValue_array(e,i){let r=this.resolvedProperty;for(let o=0,s=r.length;o!==s;++o)e[i++]=r[o]}_getValue_arrayElement(e,i){e[i]=this.resolvedProperty[this.propertyIndex]}_getValue_toArray(e,i){this.resolvedProperty.toArray(e,i)}_setValue_direct(e,i){this.targetObject[this.propertyName]=e[i]}_setValue_direct_setNeedsUpdate(e,i){this.targetObject[this.propertyName]=e[i],this.targetObject.needsUpdate=!0}_setValue_direct_setMatrixWorldNeedsUpdate(e,i){this.targetObject[this.propertyName]=e[i],this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_array(e,i){let r=this.resolvedProperty;for(let o=0,s=r.length;o!==s;++o)r[o]=e[i++]}_setValue_array_setNeedsUpdate(e,i){let r=this.resolvedProperty;for(let o=0,s=r.length;o!==s;++o)r[o]=e[i++];this.targetObject.needsUpdate=!0}_setValue_array_setMatrixWorldNeedsUpdate(e,i){let r=this.resolvedProperty;for(let o=0,s=r.length;o!==s;++o)r[o]=e[i++];this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_arrayElement(e,i){this.resolvedProperty[this.propertyIndex]=e[i]}_setValue_arrayElement_setNeedsUpdate(e,i){this.resolvedProperty[this.propertyIndex]=e[i],this.targetObject.needsUpdate=!0}_setValue_arrayElement_setMatrixWorldNeedsUpdate(e,i){this.resolvedProperty[this.propertyIndex]=e[i],this.targetObject.matrixWorldNeedsUpdate=!0}_setValue_fromArray(e,i){this.resolvedProperty.fromArray(e,i)}_setValue_fromArray_setNeedsUpdate(e,i){this.resolvedProperty.fromArray(e,i),this.targetObject.needsUpdate=!0}_setValue_fromArray_setMatrixWorldNeedsUpdate(e,i){this.resolvedProperty.fromArray(e,i),this.targetObject.matrixWorldNeedsUpdate=!0}_getValue_unbound(e,i){this.bind(),this.getValue(e,i)}_setValue_unbound(e,i){this.bind(),this.setValue(e,i)}bind(){let e=this.node,i=this.parsedPath,r=i.objectName,o=i.propertyName,s=i.propertyIndex;if(e||(e=n.findNode(this.rootNode,i.nodeName)||this.rootNode,this.node=e),this.getValue=this._getValue_unavailable,this.setValue=this._setValue_unavailable,!e)return void console.error("THREE.PropertyBinding: Trying to update node for track: "+this.path+" but it wasn't found.");if(r){let u=i.objectIndex;switch(r){case"materials":if(!e.material)return void console.error("THREE.PropertyBinding: Can not bind to material as node does not have a material.",this);if(!e.material.materials)return void console.error("THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.",this);e=e.material.materials;break;case"bones":if(!e.skeleton)return void console.error("THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.",this);e=e.skeleton.bones;for(let d=0;d<e.length;d++)if(e[d].name===u){u=d;break}break;default:if(void 0===e[r])return void console.error("THREE.PropertyBinding: Can not bind to objectName of node undefined.",this);e=e[r]}if(void 0!==u){if(void 0===e[u])return void console.error("THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.",this,e);e=e[u]}}let a=e[o];if(void 0===a)return void console.error("THREE.PropertyBinding: Trying to update property for track: "+i.nodeName+"."+o+" but it wasn't found.",e);let l=this.Versioning.None;this.targetObject=e,void 0!==e.needsUpdate?l=this.Versioning.NeedsUpdate:void 0!==e.matrixWorldNeedsUpdate&&(l=this.Versioning.MatrixWorldNeedsUpdate);let c=this.BindingType.Direct;if(void 0!==s){if("morphTargetInfluences"===o){if(!e.geometry)return void console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.",this);if(!e.geometry.isBufferGeometry)return void console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences on THREE.Geometry. Use THREE.BufferGeometry instead.",this);if(!e.geometry.morphAttributes)return void console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.",this);void 0!==e.morphTargetDictionary[s]&&(s=e.morphTargetDictionary[s])}c=this.BindingType.ArrayElement,this.resolvedProperty=a,this.propertyIndex=s}else void 0!==a.fromArray&&void 0!==a.toArray?(c=this.BindingType.HasFromToArray,this.resolvedProperty=a):Array.isArray(a)?(c=this.BindingType.EntireArray,this.resolvedProperty=a):this.propertyName=o;this.getValue=this.GetterByBindingType[c],this.setValue=this.SetterByBindingTypeAndVersioning[c][l]}unbind(){this.node=null,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}}return n.Composite=pG,n})();Lr.prototype.BindingType={Direct:0,EntireArray:1,ArrayElement:2,HasFromToArray:3},Lr.prototype.Versioning={None:0,NeedsUpdate:1,MatrixWorldNeedsUpdate:2},Lr.prototype.GetterByBindingType=[Lr.prototype._getValue_direct,Lr.prototype._getValue_array,Lr.prototype._getValue_arrayElement,Lr.prototype._getValue_toArray],Lr.prototype.SetterByBindingTypeAndVersioning=[[Lr.prototype._setValue_direct,Lr.prototype._setValue_direct_setNeedsUpdate,Lr.prototype._setValue_direct_setMatrixWorldNeedsUpdate],[Lr.prototype._setValue_array,Lr.prototype._setValue_array_setNeedsUpdate,Lr.prototype._setValue_array_setMatrixWorldNeedsUpdate],[Lr.prototype._setValue_arrayElement,Lr.prototype._setValue_arrayElement_setNeedsUpdate,Lr.prototype._setValue_arrayElement_setMatrixWorldNeedsUpdate],[Lr.prototype._setValue_fromArray,Lr.prototype._setValue_fromArray_setNeedsUpdate,Lr.prototype._setValue_fromArray_setMatrixWorldNeedsUpdate]],class extends Ep{constructor(t){super(),this._root=t,this._initMemoryManager(),this._accuIndex=0,this.time=0,this.timeScale=1}_bindAction(t,e){let i=t._localRoot||this._root,r=t._clip.tracks,o=r.length,s=t._propertyBindings,a=t._interpolants,l=i.uuid,c=this._bindingsByRootAndName,u=c[l];void 0===u&&(u={},c[l]=u);for(let d=0;d!==o;++d){let p=r[d],h=p.name,f=u[h];if(void 0!==f)++f.referenceCount,s[d]=f;else{if(f=s[d],void 0!==f){null===f._cacheIndex&&(++f.referenceCount,this._addInactiveBinding(f,l,h));continue}f=new dG(Lr.create(i,h,e&&e._propertyBindings[d].binding.parsedPath),p.ValueTypeName,p.getValueSize()),++f.referenceCount,this._addInactiveBinding(f,l,h),s[d]=f}a[d].resultBuffer=f.buffer}}_activateAction(t){if(!this._isActiveAction(t)){if(null===t._cacheIndex){let i=(t._localRoot||this._root).uuid,r=t._clip.uuid,o=this._actionsByClip[r];this._bindAction(t,o&&o.knownActions[0]),this._addInactiveAction(t,r,i)}let e=t._propertyBindings;for(let i=0,r=e.length;i!==r;++i){let o=e[i];0==o.useCount++&&(this._lendBinding(o),o.saveOriginalState())}this._lendAction(t)}}_deactivateAction(t){if(this._isActiveAction(t)){let e=t._propertyBindings;for(let i=0,r=e.length;i!==r;++i){let o=e[i];0==--o.useCount&&(o.restoreOriginalState(),this._takeBackBinding(o))}this._takeBackAction(t)}}_initMemoryManager(){this._actions=[],this._nActiveActions=0,this._actionsByClip={},this._bindings=[],this._nActiveBindings=0,this._bindingsByRootAndName={},this._controlInterpolants=[],this._nActiveControlInterpolants=0;let t=this;this.stats={actions:{get total(){return t._actions.length},get inUse(){return t._nActiveActions}},bindings:{get total(){return t._bindings.length},get inUse(){return t._nActiveBindings}},controlInterpolants:{get total(){return t._controlInterpolants.length},get inUse(){return t._nActiveControlInterpolants}}}}_isActiveAction(t){let e=t._cacheIndex;return null!==e&&e<this._nActiveActions}_addInactiveAction(t,e,i){let r=this._actions,o=this._actionsByClip,s=o[e];if(void 0===s)s={knownActions:[t],actionByRoot:{}},t._byClipCacheIndex=0,o[e]=s;else{let a=s.knownActions;t._byClipCacheIndex=a.length,a.push(t)}t._cacheIndex=r.length,r.push(t),s.actionByRoot[i]=t}_removeInactiveAction(t){let e=this._actions,i=e[e.length-1],r=t._cacheIndex;i._cacheIndex=r,e[r]=i,e.pop(),t._cacheIndex=null;let o=t._clip.uuid,s=this._actionsByClip,a=s[o],l=a.knownActions,c=l[l.length-1],u=t._byClipCacheIndex;c._byClipCacheIndex=u,l[u]=c,l.pop(),t._byClipCacheIndex=null,delete a.actionByRoot[(t._localRoot||this._root).uuid],0===l.length&&delete s[o],this._removeInactiveBindingsForAction(t)}_removeInactiveBindingsForAction(t){let e=t._propertyBindings;for(let i=0,r=e.length;i!==r;++i){let o=e[i];0==--o.referenceCount&&this._removeInactiveBinding(o)}}_lendAction(t){let e=this._actions,i=t._cacheIndex,r=this._nActiveActions++,o=e[r];t._cacheIndex=r,e[r]=t,o._cacheIndex=i,e[i]=o}_takeBackAction(t){let e=this._actions,i=t._cacheIndex,r=--this._nActiveActions,o=e[r];t._cacheIndex=r,e[r]=t,o._cacheIndex=i,e[i]=o}_addInactiveBinding(t,e,i){let r=this._bindingsByRootAndName,o=this._bindings,s=r[e];void 0===s&&(s={},r[e]=s),s[i]=t,t._cacheIndex=o.length,o.push(t)}_removeInactiveBinding(t){let e=this._bindings,i=t.binding,r=i.rootNode.uuid,o=i.path,s=this._bindingsByRootAndName,a=s[r],l=e[e.length-1],c=t._cacheIndex;l._cacheIndex=c,e[c]=l,e.pop(),delete a[o],0===Object.keys(a).length&&delete s[r]}_lendBinding(t){let e=this._bindings,i=t._cacheIndex,r=this._nActiveBindings++,o=e[r];t._cacheIndex=r,e[r]=t,o._cacheIndex=i,e[i]=o}_takeBackBinding(t){let e=this._bindings,i=t._cacheIndex,r=--this._nActiveBindings,o=e[r];t._cacheIndex=r,e[r]=t,o._cacheIndex=i,e[i]=o}_lendControlInterpolant(){let t=this._controlInterpolants,e=this._nActiveControlInterpolants++,i=t[e];return void 0===i&&(i=new Mk(new Float32Array(2),new Float32Array(2),1,this._controlInterpolantsResultBuffer),i.__cacheIndex=e,t[e]=i),i}_takeBackControlInterpolant(t){let e=this._controlInterpolants,i=t.__cacheIndex,r=--this._nActiveControlInterpolants,o=e[r];t.__cacheIndex=r,e[r]=t,o.__cacheIndex=i,e[i]=o}clipAction(t,e,i){let r=e||this._root,o=r.uuid,s="string"==typeof t?Sk.findByName(r,t):t,a=null!==s?s.uuid:t,l=this._actionsByClip[a],c=null;if(void 0===i&&(i=null!==s?s.blendMode:2500),void 0!==l){let d=l.actionByRoot[o];if(void 0!==d&&d.blendMode===i)return d;c=l.knownActions[0],null===s&&(s=c._clip)}if(null===s)return null;let u=new class{constructor(t,e,i=null,r=e.blendMode){this._mixer=t,this._clip=e,this._localRoot=i,this.blendMode=r;let o=e.tracks,s=o.length,a=new Array(s),l={endingStart:ob,endingEnd:ob};for(let c=0;c!==s;++c){let u=o[c].createInterpolant(null);a[c]=u,u.settings=l}this._interpolantSettings=l,this._interpolants=a,this._propertyBindings=new Array(s),this._cacheIndex=null,this._byClipCacheIndex=null,this._timeScaleInterpolant=null,this._weightInterpolant=null,this.loop=2201,this._loopCount=-1,this._startTime=null,this.time=0,this.timeScale=1,this._effectiveTimeScale=1,this.weight=1,this._effectiveWeight=1,this.repetitions=1/0,this.paused=!1,this.enabled=!0,this.clampWhenFinished=!1,this.zeroSlopeAtStart=!0,this.zeroSlopeAtEnd=!0}play(){return this._mixer._activateAction(this),this}stop(){return this._mixer._deactivateAction(this),this.reset()}reset(){return this.paused=!1,this.enabled=!0,this.time=0,this._loopCount=-1,this._startTime=null,this.stopFading().stopWarping()}isRunning(){return this.enabled&&!this.paused&&0!==this.timeScale&&null===this._startTime&&this._mixer._isActiveAction(this)}isScheduled(){return this._mixer._isActiveAction(this)}startAt(t){return this._startTime=t,this}setLoop(t,e){return this.loop=t,this.repetitions=e,this}setEffectiveWeight(t){return this.weight=t,this._effectiveWeight=this.enabled?t:0,this.stopFading()}getEffectiveWeight(){return this._effectiveWeight}fadeIn(t){return this._scheduleFading(t,0,1)}fadeOut(t){return this._scheduleFading(t,1,0)}crossFadeFrom(t,e,i){if(t.fadeOut(e),this.fadeIn(e),i){let r=this._clip.duration,o=t._clip.duration,a=r/o;t.warp(1,o/r,e),this.warp(a,1,e)}return this}crossFadeTo(t,e,i){return t.crossFadeFrom(this,e,i)}stopFading(){let t=this._weightInterpolant;return null!==t&&(this._weightInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}setEffectiveTimeScale(t){return this.timeScale=t,this._effectiveTimeScale=this.paused?0:t,this.stopWarping()}getEffectiveTimeScale(){return this._effectiveTimeScale}setDuration(t){return this.timeScale=this._clip.duration/t,this.stopWarping()}syncWith(t){return this.time=t.time,this.timeScale=t.timeScale,this.stopWarping()}halt(t){return this.warp(this._effectiveTimeScale,0,t)}warp(t,e,i){let r=this._mixer,o=r.time,s=this.timeScale,a=this._timeScaleInterpolant;null===a&&(a=r._lendControlInterpolant(),this._timeScaleInterpolant=a);let l=a.parameterPositions,c=a.sampleValues;return l[0]=o,l[1]=o+i,c[0]=t/s,c[1]=e/s,this}stopWarping(){let t=this._timeScaleInterpolant;return null!==t&&(this._timeScaleInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}getMixer(){return this._mixer}getClip(){return this._clip}getRoot(){return this._localRoot||this._mixer._root}_update(t,e,i,r){if(!this.enabled)return void this._updateWeight(t);let o=this._startTime;if(null!==o){let l=(t-o)*i;if(l<0||0===i)return;this._startTime=null,e=i*l}e*=this._updateTimeScale(t);let s=this._updateTime(e),a=this._updateWeight(t);if(a>0){let l=this._interpolants,c=this._propertyBindings;if(2501===this.blendMode)for(let u=0,d=l.length;u!==d;++u)l[u].evaluate(s),c[u].accumulateAdditive(a);else for(let u=0,d=l.length;u!==d;++u)l[u].evaluate(s),c[u].accumulate(r,a)}}_updateWeight(t){let e=0;if(this.enabled){e=this.weight;let i=this._weightInterpolant;if(null!==i){let r=i.evaluate(t)[0];e*=r,t>i.parameterPositions[1]&&(this.stopFading(),0===r&&(this.enabled=!1))}}return this._effectiveWeight=e,e}_updateTimeScale(t){let e=0;if(!this.paused){e=this.timeScale;let i=this._timeScaleInterpolant;null!==i&&(e*=i.evaluate(t)[0],t>i.parameterPositions[1]&&(this.stopWarping(),0===e?this.paused=!0:this.timeScale=e))}return this._effectiveTimeScale=e,e}_updateTime(t){let e=this._clip.duration,i=this.loop,r=this.time+t,o=this._loopCount,s=2202===i;if(0===t)return-1===o?r:s&&1==(1&o)?e-r:r;if(2200===i){-1===o&&(this._loopCount=0,this._setEndings(!0,!0,!1));e:{if(r>=e)r=e;else{if(!(r<0)){this.time=r;break e}r=0}this.clampWhenFinished?this.paused=!0:this.enabled=!1,this.time=r,this._mixer.dispatchEvent({type:"finished",action:this,direction:t<0?-1:1})}}else{if(-1===o&&(t>=0?(o=0,this._setEndings(!0,0===this.repetitions,s)):this._setEndings(0===this.repetitions,!0,s)),r>=e||r<0){let a=Math.floor(r/e);r-=e*a,o+=Math.abs(a);let l=this.repetitions-o;if(l<=0)this.clampWhenFinished?this.paused=!0:this.enabled=!1,r=t>0?e:0,this.time=r,this._mixer.dispatchEvent({type:"finished",action:this,direction:t>0?1:-1});else{if(1===l){let c=t<0;this._setEndings(c,!c,s)}else this._setEndings(!1,!1,s);this._loopCount=o,this.time=r,this._mixer.dispatchEvent({type:"loop",action:this,loopDelta:a})}}else this.time=r;if(s&&1==(1&o))return e-r}return r}_setEndings(t,e,i){let r=this._interpolantSettings;i?(r.endingStart=sb,r.endingEnd=sb):(r.endingStart=t?this.zeroSlopeAtStart?sb:ob:2402,r.endingEnd=e?this.zeroSlopeAtEnd?sb:ob:2402)}_scheduleFading(t,e,i){let r=this._mixer,o=r.time,s=this._weightInterpolant;null===s&&(s=r._lendControlInterpolant(),this._weightInterpolant=s);let a=s.parameterPositions,l=s.sampleValues;return a[0]=o,l[0]=e,a[1]=o+t,l[1]=i,this}}(this,s,e,i);return this._bindAction(u,c),this._addInactiveAction(u,a,o),u}existingAction(t,e){let i=e||this._root,r=i.uuid,o="string"==typeof t?Sk.findByName(i,t):t,a=this._actionsByClip[o?o.uuid:t];return void 0!==a&&a.actionByRoot[r]||null}stopAllAction(){let t=this._actions;for(let i=this._nActiveActions-1;i>=0;--i)t[i].stop();return this}update(t){let e=this._actions,i=this._nActiveActions,r=this.time+=t*=this.timeScale,o=Math.sign(t),s=this._accuIndex^=1;for(let c=0;c!==i;++c)e[c]._update(r,t,o,s);let a=this._bindings,l=this._nActiveBindings;for(let c=0;c!==l;++c)a[c].apply(s);return this}setTime(t){this.time=0;for(let e=0;e<this._actions.length;e++)this._actions[e].time=0;return this.update(t)}getRoot(){return this._root}uncacheClip(t){let e=this._actions,i=t.uuid,r=this._actionsByClip,o=r[i];if(void 0!==o){let s=o.knownActions;for(let a=0,l=s.length;a!==l;++a){let c=s[a];this._deactivateAction(c);let u=c._cacheIndex,d=e[e.length-1];c._cacheIndex=null,c._byClipCacheIndex=null,d._cacheIndex=u,e[u]=d,e.pop(),this._removeInactiveBindingsForAction(c)}delete r[i]}}uncacheRoot(t){let e=t.uuid,i=this._actionsByClip;for(let s in i){let l=i[s].actionByRoot[e];void 0!==l&&(this._deactivateAction(l),this._removeInactiveAction(l))}let o=this._bindingsByRootAndName[e];if(void 0!==o)for(let s in o){let a=o[s];a.restoreOriginalState(),this._removeInactiveBinding(a)}}uncacheAction(t,e){let i=this.existingAction(t,e);null!==i&&(this._deactivateAction(i),this._removeInactiveAction(i))}}.prototype._controlInterpolantsResultBuffer=new Float32Array(1);var fE=class{constructor(t){"string"==typeof t&&(console.warn("THREE.Uniform: Type parameter is no longer needed."),t=arguments[1]),this.value=t}clone(){return new fE(void 0===this.value.clone?this.value:this.value.clone())}};(class extends Yg{constructor(t,e,i=1){super(t,e),this.meshPerAttribute=i}copy(t){return super.copy(t),this.meshPerAttribute=t.meshPerAttribute,this}clone(t){let e=super.clone(t);return e.meshPerAttribute=this.meshPerAttribute,e}toJSON(t){let e=super.toJSON(t);return e.isInstancedInterleavedBuffer=!0,e.meshPerAttribute=this.meshPerAttribute,e}}).prototype.isInstancedInterleavedBuffer=!0;var Sde=new at,Zg=class{constructor(t=new at(1/0,1/0),e=new at(-1/0,-1/0)){this.min=t,this.max=e}set(t,e){return this.min.copy(t),this.max.copy(e),this}setFromPoints(t){this.makeEmpty();for(let e=0,i=t.length;e<i;e++)this.expandByPoint(t[e]);return this}setFromCenterAndSize(t,e){let i=Sde.copy(e).multiplyScalar(.5);return this.min.copy(t).sub(i),this.max.copy(t).add(i),this}clone(){return(new this.constructor).copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=1/0,this.max.x=this.max.y=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y}getCenter(t){return this.isEmpty()?t.set(0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return this.isEmpty()?t.set(0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y}getParameter(t,e){return e.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y)}clampPoint(t,e){return e.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return Sde.copy(t).clamp(this.min,this.max).sub(t).length()}intersect(t){return this.min.max(t.min),this.max.min(t.max),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}};Zg.prototype.isBox2=!0;var ff=new ie,ek=new Rn,s8=new Rn;function Kde(n){let t=[];n&&n.isBone&&t.push(n);for(let e=0;e<n.children.length;e++)t.push.apply(t,Kde(n.children[e]));return t}var rqe=new Float32Array(1);function DG(n,t,e){if(1===e)return new vn(t);let i=vg(t);if(!i)throw new Error(`d3 failed to recognize the color: ${t}`);return new vn(dz(i,n)(1-e))}new Int32Array(rqe.buffer),qa.create=function(n,t){return console.log("THREE.Curve.create() has been deprecated"),n.prototype=Object.create(qa.prototype),n.prototype.constructor=n,n.prototype.getPoint=t,n},lE.prototype.fromPoints=function(n){return console.warn("THREE.Path: .fromPoints() has been renamed to .setFromPoints()."),this.setFromPoints(n)},class extends rE{constructor(t=10,e=10,i=4473924,r=8947848){i=new vn(i),r=new vn(r);let o=e/2,s=t/e,a=t/2,l=[],c=[];for(let p=0,h=0,f=-a;p<=e;p++,f+=s){l.push(-a,0,f,a,0,f),l.push(f,0,-a,f,0,a);let m=p===o?i:r;m.toArray(c,h),h+=3,m.toArray(c,h),h+=3,m.toArray(c,h),h+=3,m.toArray(c,h),h+=3}let u=new nr;u.setAttribute("position",new Jr(l,3)),u.setAttribute("color",new Jr(c,3)),super(u,new Ap({vertexColors:!0,toneMapped:!1})),this.type="GridHelper"}}.prototype.setColors=function(){console.error("THREE.GridHelper: setColors() has been deprecated, pass them in the constructor instead.")},class extends rE{constructor(t){let e=Kde(t),i=new nr,r=[],o=[],s=new vn(0,0,1),a=new vn(0,1,0);for(let c=0;c<e.length;c++){let u=e[c];u.parent&&u.parent.isBone&&(r.push(0,0,0),r.push(0,0,0),o.push(s.r,s.g,s.b),o.push(a.r,a.g,a.b))}i.setAttribute("position",new Jr(r,3)),i.setAttribute("color",new Jr(o,3)),super(i,new Ap({vertexColors:!0,depthTest:!1,depthWrite:!1,toneMapped:!1,transparent:!0})),this.type="SkeletonHelper",this.isSkeletonHelper=!0,this.root=t,this.bones=e,this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1}updateMatrixWorld(t){let e=this.bones,i=this.geometry,r=i.getAttribute("position");s8.copy(this.root.matrixWorld).invert();for(let o=0,s=0;o<e.length;o++){let a=e[o];a.parent&&a.parent.isBone&&(ek.multiplyMatrices(s8,a.matrixWorld),ff.setFromMatrixPosition(ek),r.setXYZ(s,ff.x,ff.y,ff.z),ek.multiplyMatrices(s8,a.parent.matrixWorld),ff.setFromMatrixPosition(ek),r.setXYZ(s+1,ff.x,ff.y,ff.z),s+=2)}i.getAttribute("position").needsUpdate=!0,super.updateMatrixWorld(t)}}.prototype.update=function(){console.error("THREE.SkeletonHelper: update() no longer needs to be called.")},Dd.prototype.extractUrlBase=function(n){return console.warn("THREE.Loader: .extractUrlBase() has been deprecated. Use THREE.LoaderUtils.extractUrlBase() instead."),iG.extractUrlBase(n)},Dd.Handlers={add:function(){console.error("THREE.Loader: Handlers.add() has been removed. Use LoadingManager.addHandler() instead.")},get:function(){console.error("THREE.Loader: Handlers.get() has been removed. Use LoadingManager.getHandler() instead.")}},Zg.prototype.center=function(n){return console.warn("THREE.Box2: .center() has been renamed to .getCenter()."),this.getCenter(n)},Zg.prototype.empty=function(){return console.warn("THREE.Box2: .empty() has been renamed to .isEmpty()."),this.isEmpty()},Zg.prototype.isIntersectionBox=function(n){return console.warn("THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(n)},Zg.prototype.size=function(n){return console.warn("THREE.Box2: .size() has been renamed to .getSize()."),this.getSize(n)},Tl.prototype.center=function(n){return console.warn("THREE.Box3: .center() has been renamed to .getCenter()."),this.getCenter(n)},Tl.prototype.empty=function(){return console.warn("THREE.Box3: .empty() has been renamed to .isEmpty()."),this.isEmpty()},Tl.prototype.isIntersectionBox=function(n){return console.warn("THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(n)},Tl.prototype.isIntersectionSphere=function(n){return console.warn("THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(n)},Tl.prototype.size=function(n){return console.warn("THREE.Box3: .size() has been renamed to .getSize()."),this.getSize(n)},xf.prototype.empty=function(){return console.warn("THREE.Sphere: .empty() has been renamed to .isEmpty()."),this.isEmpty()},gb.prototype.setFromMatrix=function(n){return console.warn("THREE.Frustum: .setFromMatrix() has been renamed to .setFromProjectionMatrix()."),this.setFromProjectionMatrix(n)},Jo.prototype.flattenToArrayOffset=function(n,t){return console.warn("THREE.Matrix3: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(n,t)},Jo.prototype.multiplyVector3=function(n){return console.warn("THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead."),n.applyMatrix3(this)},Jo.prototype.multiplyVector3Array=function(){console.error("THREE.Matrix3: .multiplyVector3Array() has been removed.")},Jo.prototype.applyToBufferAttribute=function(n){return console.warn("THREE.Matrix3: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix3( matrix ) instead."),n.applyMatrix3(this)},Jo.prototype.applyToVector3Array=function(){console.error("THREE.Matrix3: .applyToVector3Array() has been removed.")},Jo.prototype.getInverse=function(n){return console.warn("THREE.Matrix3: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(n).invert()},Rn.prototype.extractPosition=function(n){return console.warn("THREE.Matrix4: .extractPosition() has been renamed to .copyPosition()."),this.copyPosition(n)},Rn.prototype.flattenToArrayOffset=function(n,t){return console.warn("THREE.Matrix4: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(n,t)},Rn.prototype.getPosition=function(){return console.warn("THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead."),(new ie).setFromMatrixColumn(this,3)},Rn.prototype.setRotationFromQuaternion=function(n){return console.warn("THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion()."),this.makeRotationFromQuaternion(n)},Rn.prototype.multiplyToArray=function(){console.warn("THREE.Matrix4: .multiplyToArray() has been removed.")},Rn.prototype.multiplyVector3=function(n){return console.warn("THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)},Rn.prototype.multiplyVector4=function(n){return console.warn("THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)},Rn.prototype.multiplyVector3Array=function(){console.error("THREE.Matrix4: .multiplyVector3Array() has been removed.")},Rn.prototype.rotateAxis=function(n){console.warn("THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead."),n.transformDirection(this)},Rn.prototype.crossVector=function(n){return console.warn("THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)},Rn.prototype.translate=function(){console.error("THREE.Matrix4: .translate() has been removed.")},Rn.prototype.rotateX=function(){console.error("THREE.Matrix4: .rotateX() has been removed.")},Rn.prototype.rotateY=function(){console.error("THREE.Matrix4: .rotateY() has been removed.")},Rn.prototype.rotateZ=function(){console.error("THREE.Matrix4: .rotateZ() has been removed.")},Rn.prototype.rotateByAxis=function(){console.error("THREE.Matrix4: .rotateByAxis() has been removed.")},Rn.prototype.applyToBufferAttribute=function(n){return console.warn("THREE.Matrix4: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix4( matrix ) instead."),n.applyMatrix4(this)},Rn.prototype.applyToVector3Array=function(){console.error("THREE.Matrix4: .applyToVector3Array() has been removed.")},Rn.prototype.makeFrustum=function(n,t,e,i,r,o){return console.warn("THREE.Matrix4: .makeFrustum() has been removed. Use .makePerspective( left, right, top, bottom, near, far ) instead."),this.makePerspective(n,t,i,e,r,o)},Rn.prototype.getInverse=function(n){return console.warn("THREE.Matrix4: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(n).invert()},uu.prototype.isIntersectionLine=function(n){return console.warn("THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine()."),this.intersectsLine(n)},qs.prototype.multiplyVector3=function(n){return console.warn("THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead."),n.applyQuaternion(this)},qs.prototype.inverse=function(){return console.warn("THREE.Quaternion: .inverse() has been renamed to invert()."),this.invert()},Cf.prototype.isIntersectionBox=function(n){return console.warn("THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(n)},Cf.prototype.isIntersectionPlane=function(n){return console.warn("THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane()."),this.intersectsPlane(n)},Cf.prototype.isIntersectionSphere=function(n){return console.warn("THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(n)},lo.prototype.area=function(){return console.warn("THREE.Triangle: .area() has been renamed to .getArea()."),this.getArea()},lo.prototype.barycoordFromPoint=function(n,t){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),this.getBarycoord(n,t)},lo.prototype.midpoint=function(n){return console.warn("THREE.Triangle: .midpoint() has been renamed to .getMidpoint()."),this.getMidpoint(n)},lo.prototypenormal=function(n){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),this.getNormal(n)},lo.prototype.plane=function(n){return console.warn("THREE.Triangle: .plane() has been renamed to .getPlane()."),this.getPlane(n)},lo.barycoordFromPoint=function(n,t,e,i,r){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),lo.getBarycoord(n,t,e,i,r)},lo.normal=function(n,t,e,i){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),lo.getNormal(n,t,e,i)},Ip.prototype.extractAllPoints=function(n){return console.warn("THREE.Shape: .extractAllPoints() has been removed. Use .extractPoints() instead."),this.extractPoints(n)},Ip.prototype.extrude=function(n){return console.warn("THREE.Shape: .extrude() has been removed. Use ExtrudeGeometry() instead."),new Sf(this,n)},Ip.prototype.makeGeometry=function(n){return console.warn("THREE.Shape: .makeGeometry() has been removed. Use ShapeGeometry() instead."),new Qg(this,n)},at.prototype.fromAttribute=function(n,t,e){return console.warn("THREE.Vector2: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(n,t,e)},at.prototype.distanceToManhattan=function(n){return console.warn("THREE.Vector2: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(n)},at.prototype.lengthManhattan=function(){return console.warn("THREE.Vector2: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()},ie.prototype.setEulerFromRotationMatrix=function(){console.error("THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.")},ie.prototype.setEulerFromQuaternion=function(){console.error("THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.")},ie.prototype.getPositionFromMatrix=function(n){return console.warn("THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition()."),this.setFromMatrixPosition(n)},ie.prototype.getScaleFromMatrix=function(n){return console.warn("THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale()."),this.setFromMatrixScale(n)},ie.prototype.getColumnFromMatrix=function(n,t){return console.warn("THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn()."),this.setFromMatrixColumn(t,n)},ie.prototype.applyProjection=function(n){return console.warn("THREE.Vector3: .applyProjection() has been removed. Use .applyMatrix4( m ) instead."),this.applyMatrix4(n)},ie.prototype.fromAttribute=function(n,t,e){return console.warn("THREE.Vector3: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(n,t,e)},ie.prototype.distanceToManhattan=function(n){return console.warn("THREE.Vector3: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(n)},ie.prototype.lengthManhattan=function(){return console.warn("THREE.Vector3: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()},ar.prototype.fromAttribute=function(n,t,e){return console.warn("THREE.Vector4: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(n,t,e)},ar.prototype.lengthManhattan=function(){return console.warn("THREE.Vector4: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()},Xi.prototype.getChildByName=function(n){return console.warn("THREE.Object3D: .getChildByName() has been renamed to .getObjectByName()."),this.getObjectByName(n)},Xi.prototype.renderDepth=function(){console.warn("THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.")},Xi.prototype.translate=function(n,t){return console.warn("THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead."),this.translateOnAxis(t,n)},Xi.prototype.getWorldRotation=function(){console.error("THREE.Object3D: .getWorldRotation() has been removed. Use THREE.Object3D.getWorldQuaternion( target ) instead.")},Xi.prototype.applyMatrix=function(n){return console.warn("THREE.Object3D: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(n)},Object.defineProperties(Xi.prototype,{eulerOrder:{get:function(){return console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order},set:function(n){console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order=n}},useQuaternion:{get:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")},set:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")}}}),Vo.prototype.setDrawMode=function(){console.error("THREE.Mesh: .setDrawMode() has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")},Object.defineProperties(Vo.prototype,{drawMode:{get:function(){return console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode."),0},set:function(){console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")}}}),gk.prototype.initBones=function(){console.error("THREE.SkinnedMesh: initBones() has been removed.")},Ws.prototype.setLens=function(n,t){console.warn("THREE.PerspectiveCamera.setLens is deprecated. Use .setFocalLength and .filmGauge for a photographic setup."),void 0!==t&&(this.filmGauge=t),this.setFocalLength(n)},Object.defineProperties(fc.prototype,{onlyShadow:{set:function(){console.warn("THREE.Light: .onlyShadow has been removed.")}},shadowCameraFov:{set:function(n){console.warn("THREE.Light: .shadowCameraFov is now .shadow.camera.fov."),this.shadow.camera.fov=n}},shadowCameraLeft:{set:function(n){console.warn("THREE.Light: .shadowCameraLeft is now .shadow.camera.left."),this.shadow.camera.left=n}},shadowCameraRight:{set:function(n){console.warn("THREE.Light: .shadowCameraRight is now .shadow.camera.right."),this.shadow.camera.right=n}},shadowCameraTop:{set:function(n){console.warn("THREE.Light: .shadowCameraTop is now .shadow.camera.top."),this.shadow.camera.top=n}},shadowCameraBottom:{set:function(n){console.warn("THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom."),this.shadow.camera.bottom=n}},shadowCameraNear:{set:function(n){console.warn("THREE.Light: .shadowCameraNear is now .shadow.camera.near."),this.shadow.camera.near=n}},shadowCameraFar:{set:function(n){console.warn("THREE.Light: .shadowCameraFar is now .shadow.camera.far."),this.shadow.camera.far=n}},shadowCameraVisible:{set:function(){console.warn("THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.")}},shadowBias:{set:function(n){console.warn("THREE.Light: .shadowBias is now .shadow.bias."),this.shadow.bias=n}},shadowDarkness:{set:function(){console.warn("THREE.Light: .shadowDarkness has been removed.")}},shadowMapWidth:{set:function(n){console.warn("THREE.Light: .shadowMapWidth is now .shadow.mapSize.width."),this.shadow.mapSize.width=n}},shadowMapHeight:{set:function(n){console.warn("THREE.Light: .shadowMapHeight is now .shadow.mapSize.height."),this.shadow.mapSize.height=n}}}),Object.defineProperties(Yr.prototype,{length:{get:function(){return console.warn("THREE.BufferAttribute: .length has been deprecated. Use .count instead."),this.array.length}},dynamic:{get:function(){return console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.usage===ok},set:function(){console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.setUsage(ok)}}}),Yr.prototype.setDynamic=function(n){return console.warn("THREE.BufferAttribute: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(!0===n?ok:qS),this},Yr.prototype.copyIndicesArray=function(){console.error("THREE.BufferAttribute: .copyIndicesArray() has been removed.")},Yr.prototype.setArray=function(){console.error("THREE.BufferAttribute: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")},nr.prototype.addIndex=function(n){console.warn("THREE.BufferGeometry: .addIndex() has been renamed to .setIndex()."),this.setIndex(n)},nr.prototype.addAttribute=function(n,t){return console.warn("THREE.BufferGeometry: .addAttribute() has been renamed to .setAttribute()."),t&&t.isBufferAttribute||t&&t.isInterleavedBufferAttribute?"index"===n?(console.warn("THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute."),this.setIndex(t),this):this.setAttribute(n,t):(console.warn("THREE.BufferGeometry: .addAttribute() now expects ( name, attribute )."),this.setAttribute(n,new Yr(arguments[1],arguments[2])))},nr.prototype.addDrawCall=function(n,t,e){void 0!==e&&console.warn("THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset."),console.warn("THREE.BufferGeometry: .addDrawCall() is now .addGroup()."),this.addGroup(n,t)},nr.prototype.clearDrawCalls=function(){console.warn("THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups()."),this.clearGroups()},nr.prototype.computeOffsets=function(){console.warn("THREE.BufferGeometry: .computeOffsets() has been removed.")},nr.prototype.removeAttribute=function(n){return console.warn("THREE.BufferGeometry: .removeAttribute() has been renamed to .deleteAttribute()."),this.deleteAttribute(n)},nr.prototype.applyMatrix=function(n){return console.warn("THREE.BufferGeometry: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(n)},Object.defineProperties(nr.prototype,{drawcalls:{get:function(){return console.error("THREE.BufferGeometry: .drawcalls has been renamed to .groups."),this.groups}},offsets:{get:function(){return console.warn("THREE.BufferGeometry: .offsets has been renamed to .groups."),this.groups}}}),Yg.prototype.setDynamic=function(n){return console.warn("THREE.InterleavedBuffer: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(!0===n?ok:qS),this},Yg.prototype.setArray=function(){console.error("THREE.InterleavedBuffer: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")},Sf.prototype.getArrays=function(){console.error("THREE.ExtrudeGeometry: .getArrays() has been removed.")},Sf.prototype.addShapeList=function(){console.error("THREE.ExtrudeGeometry: .addShapeList() has been removed.")},Sf.prototype.addShape=function(){console.error("THREE.ExtrudeGeometry: .addShape() has been removed.")},vb.prototype.dispose=function(){console.error("THREE.Scene: .dispose() has been removed.")},fE.prototype.onUpdate=function(){return console.warn("THREE.Uniform: .onUpdate() has been removed. Use object.onBeforeRender() instead."),this},Object.defineProperties(hs.prototype,{wrapAround:{get:function(){console.warn("THREE.Material: .wrapAround has been removed.")},set:function(){console.warn("THREE.Material: .wrapAround has been removed.")}},overdraw:{get:function(){console.warn("THREE.Material: .overdraw has been removed.")},set:function(){console.warn("THREE.Material: .overdraw has been removed.")}},wrapRGB:{get:function(){return console.warn("THREE.Material: .wrapRGB has been removed."),new vn}},shading:{get:function(){console.error("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead.")},set:function(n){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=1===n}},stencilMask:{get:function(){return console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask},set:function(n){console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask=n}},vertexTangents:{get:function(){console.warn("THREE."+this.type+": .vertexTangents has been removed.")},set:function(){console.warn("THREE."+this.type+": .vertexTangents has been removed.")}}}),Object.defineProperties(Dp.prototype,{derivatives:{get:function(){return console.warn("THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives},set:function(n){console.warn("THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives=n}}}),ir.prototype.clearTarget=function(n,t,e,i){console.warn("THREE.WebGLRenderer: .clearTarget() has been deprecated. Use .setRenderTarget() and .clear() instead."),this.setRenderTarget(n),this.clear(t,e,i)},ir.prototype.animate=function(n){console.warn("THREE.WebGLRenderer: .animate() is now .setAnimationLoop()."),this.setAnimationLoop(n)},ir.prototype.getCurrentRenderTarget=function(){return console.warn("THREE.WebGLRenderer: .getCurrentRenderTarget() is now .getRenderTarget()."),this.getRenderTarget()},ir.prototype.getMaxAnisotropy=function(){return console.warn("THREE.WebGLRenderer: .getMaxAnisotropy() is now .capabilities.getMaxAnisotropy()."),this.capabilities.getMaxAnisotropy()},ir.prototype.getPrecision=function(){return console.warn("THREE.WebGLRenderer: .getPrecision() is now .capabilities.precision."),this.capabilities.precision},ir.prototype.resetGLState=function(){return console.warn("THREE.WebGLRenderer: .resetGLState() is now .state.reset()."),this.state.reset()},ir.prototype.supportsFloatTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( 'OES_texture_float' )."),this.extensions.get("OES_texture_float")},ir.prototype.supportsHalfFloatTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( 'OES_texture_half_float' )."),this.extensions.get("OES_texture_half_float")},ir.prototype.supportsStandardDerivatives=function(){return console.warn("THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( 'OES_standard_derivatives' )."),this.extensions.get("OES_standard_derivatives")},ir.prototype.supportsCompressedTextureS3TC=function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( 'WEBGL_compressed_texture_s3tc' )."),this.extensions.get("WEBGL_compressed_texture_s3tc")},ir.prototype.supportsCompressedTexturePVRTC=function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( 'WEBGL_compressed_texture_pvrtc' )."),this.extensions.get("WEBGL_compressed_texture_pvrtc")},ir.prototype.supportsBlendMinMax=function(){return console.warn("THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( 'EXT_blend_minmax' )."),this.extensions.get("EXT_blend_minmax")},ir.prototype.supportsVertexTextures=function(){return console.warn("THREE.WebGLRenderer: .supportsVertexTextures() is now .capabilities.vertexTextures."),this.capabilities.vertexTextures},ir.prototype.supportsInstancedArrays=function(){return console.warn("THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( 'ANGLE_instanced_arrays' )."),this.extensions.get("ANGLE_instanced_arrays")},ir.prototype.enableScissorTest=function(n){console.warn("THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest()."),this.setScissorTest(n)},ir.prototype.initMaterial=function(){console.warn("THREE.WebGLRenderer: .initMaterial() has been removed.")},ir.prototype.addPrePlugin=function(){console.warn("THREE.WebGLRenderer: .addPrePlugin() has been removed.")},ir.prototype.addPostPlugin=function(){console.warn("THREE.WebGLRenderer: .addPostPlugin() has been removed.")},ir.prototype.updateShadowMap=function(){console.warn("THREE.WebGLRenderer: .updateShadowMap() has been removed.")},ir.prototype.setFaceCulling=function(){console.warn("THREE.WebGLRenderer: .setFaceCulling() has been removed.")},ir.prototype.allocTextureUnit=function(){console.warn("THREE.WebGLRenderer: .allocTextureUnit() has been removed.")},ir.prototype.setTexture=function(){console.warn("THREE.WebGLRenderer: .setTexture() has been removed.")},ir.prototype.setTexture2D=function(){console.warn("THREE.WebGLRenderer: .setTexture2D() has been removed.")},ir.prototype.setTextureCube=function(){console.warn("THREE.WebGLRenderer: .setTextureCube() has been removed.")},ir.prototype.getActiveMipMapLevel=function(){return console.warn("THREE.WebGLRenderer: .getActiveMipMapLevel() is now .getActiveMipmapLevel()."),this.getActiveMipmapLevel()},Object.defineProperties(ir.prototype,{shadowMapEnabled:{get:function(){return this.shadowMap.enabled},set:function(n){console.warn("THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled."),this.shadowMap.enabled=n}},shadowMapType:{get:function(){return this.shadowMap.type},set:function(n){console.warn("THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type."),this.shadowMap.type=n}},shadowMapCullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")}},context:{get:function(){return console.warn("THREE.WebGLRenderer: .context has been removed. Use .getContext() instead."),this.getContext()}},vr:{get:function(){return console.warn("THREE.WebGLRenderer: .vr has been renamed to .xr"),this.xr}},gammaInput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead."),!1},set:function(){console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead.")}},gammaOutput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),!1},set:function(n){console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),this.outputEncoding=!0===n?Wr:bf}},toneMappingWhitePoint:{get:function(){return console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed."),1},set:function(){console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed.")}},gammaFactor:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaFactor has been removed."),2},set:function(){console.warn("THREE.WebGLRenderer: .gammaFactor has been removed.")}}}),Object.defineProperties(Gde.prototype,{cullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")}},renderReverseSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")}},renderSingleSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")}}}),Object.defineProperties(Wa.prototype,{wrapS:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS},set:function(n){console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS=n}},wrapT:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT},set:function(n){console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT=n}},magFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter},set:function(n){console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter=n}},minFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter},set:function(n){console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter=n}},anisotropy:{get:function(){return console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy},set:function(n){console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy=n}},offset:{get:function(){return console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset},set:function(n){console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset=n}},repeat:{get:function(){return console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat},set:function(n){console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat=n}},format:{get:function(){return console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format},set:function(n){console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format=n}},type:{get:function(){return console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type},set:function(n){console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type=n}},generateMipmaps:{get:function(){return console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps},set:function(n){console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps=n}}}),class extends Xi{constructor(t){super(),this.type="Audio",this.listener=t,this.context=t.context,this.gain=this.context.createGain(),this.gain.connect(t.getInput()),this.autoplay=!1,this.buffer=null,this.detune=0,this.loop=!1,this.loopStart=0,this.loopEnd=0,this.offset=0,this.duration=void 0,this.playbackRate=1,this.isPlaying=!1,this.hasPlaybackControl=!0,this.source=null,this.sourceType="empty",this._startedAt=0,this._progress=0,this._connected=!1,this.filters=[]}getOutput(){return this.gain}setNodeSource(t){return this.hasPlaybackControl=!1,this.sourceType="audioNode",this.source=t,this.connect(),this}setMediaElementSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaNode",this.source=this.context.createMediaElementSource(t),this.connect(),this}setMediaStreamSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaStreamNode",this.source=this.context.createMediaStreamSource(t),this.connect(),this}setBuffer(t){return this.buffer=t,this.sourceType="buffer",this.autoplay&&this.play(),this}play(t=0){if(!0===this.isPlaying)return void console.warn("THREE.Audio: Audio is already playing.");if(!1===this.hasPlaybackControl)return void console.warn("THREE.Audio: this Audio has no playback control.");this._startedAt=this.context.currentTime+t;let e=this.context.createBufferSource();return e.buffer=this.buffer,e.loop=this.loop,e.loopStart=this.loopStart,e.loopEnd=this.loopEnd,e.onended=this.onEnded.bind(this),e.start(this._startedAt,this._progress+this.offset,this.duration),this.isPlaying=!0,this.source=e,this.setDetune(this.detune),this.setPlaybackRate(this.playbackRate),this.connect()}pause(){if(!1!==this.hasPlaybackControl)return!0===this.isPlaying&&(this._progress+=Math.max(this.context.currentTime-this._startedAt,0)*this.playbackRate,!0===this.loop&&(this._progress=this._progress%(this.duration||this.buffer.duration)),this.source.stop(),this.source.onended=null,this.isPlaying=!1),this;console.warn("THREE.Audio: this Audio has no playback control.")}stop(){if(!1!==this.hasPlaybackControl)return this._progress=0,this.source.stop(),this.source.onended=null,this.isPlaying=!1,this;console.warn("THREE.Audio: this Audio has no playback control.")}connect(){if(this.filters.length>0){this.source.connect(this.filters[0]);for(let t=1,e=this.filters.length;t<e;t++)this.filters[t-1].connect(this.filters[t]);this.filters[this.filters.length-1].connect(this.getOutput())}else this.source.connect(this.getOutput());return this._connected=!0,this}disconnect(){if(this.filters.length>0){this.source.disconnect(this.filters[0]);for(let t=1,e=this.filters.length;t<e;t++)this.filters[t-1].disconnect(this.filters[t]);this.filters[this.filters.length-1].disconnect(this.getOutput())}else this.source.disconnect(this.getOutput());return this._connected=!1,this}getFilters(){return this.filters}setFilters(t){return t||(t=[]),!0===this._connected?(this.disconnect(),this.filters=t.slice(),this.connect()):this.filters=t.slice(),this}setDetune(t){if(this.detune=t,void 0!==this.source.detune)return!0===this.isPlaying&&this.source.detune.setTargetAtTime(this.detune,this.context.currentTime,.01),this}getDetune(){return this.detune}getFilter(){return this.getFilters()[0]}setFilter(t){return this.setFilters(t?[t]:[])}setPlaybackRate(t){if(!1!==this.hasPlaybackControl)return this.playbackRate=t,!0===this.isPlaying&&this.source.playbackRate.setTargetAtTime(this.playbackRate,this.context.currentTime,.01),this;console.warn("THREE.Audio: this Audio has no playback control.")}getPlaybackRate(){return this.playbackRate}onEnded(){this.isPlaying=!1}getLoop(){return!1===this.hasPlaybackControl?(console.warn("THREE.Audio: this Audio has no playback control."),!1):this.loop}setLoop(t){if(!1!==this.hasPlaybackControl)return this.loop=t,!0===this.isPlaying&&(this.source.loop=this.loop),this;console.warn("THREE.Audio: this Audio has no playback control.")}setLoopStart(t){return this.loopStart=t,this}setLoopEnd(t){return this.loopEnd=t,this}getVolume(){return this.gain.gain.value}setVolume(t){return this.gain.gain.setTargetAtTime(t,this.context.currentTime,.01),this}}.prototype.load=function(n){console.warn("THREE.Audio: .load has been deprecated. Use THREE.AudioLoader instead.");let t=this;return(new sG).load(n,function(i){t.setBuffer(i)}),this},KS.prototype.updateCubeMap=function(n,t){return console.warn("THREE.CubeCamera: .updateCubeMap() is now .update()."),this.update(n,t)},KS.prototype.clear=function(n,t,e,i){return console.warn("THREE.CubeCamera: .clear() is now .renderTarget.clear()."),this.renderTarget.clear(n,t,e,i)},Tp.crossOrigin=void 0,Tp.loadTexture=function(n,t,e,i){console.warn("THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.");let r=new K8;r.setCrossOrigin(this.crossOrigin);let o=r.load(n,e,void 0,i);return t&&(o.mapping=t),o},Tp.loadTextureCube=function(n,t,e,i){console.warn("THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.");let r=new Q8;r.setCrossOrigin(this.crossOrigin);let o=r.load(n,e,void 0,i);return t&&(o.mapping=t),o},Tp.loadCompressedTexture=function(){console.error("THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.")},Tp.loadCompressedTextureCube=function(){console.error("THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.")},typeof __THREE_DEVTOOLS__<"u"&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("register",{detail:{revision:"137"}})),typeof window<"u"&&(window.__THREE__?console.warn("WARNING: Multiple instances of Three.js being imported."):window.__THREE__="137");var pu=(()=>(function(n){n[n.CIRCLE=0]="CIRCLE",n[n.LINE=1]="LINE",n[n.TRIANGLE=2]="TRIANGLE",n[n.TRAPEZOID=3]="TRAPEZOID"}(pu||(pu={})),pu))();function Jde(n,t){let e=t.length/2,i=n.attributes.position;(!i||i.count!==3*e)&&(i=new Yr(new Float32Array(3*e),3),n.setAttribute("position",i));let r=i.array;for(let o=0;o<e;o++)r[3*o]=t[2*o],r[3*o+1]=t[2*o+1];i.needsUpdate=!0,n.setDrawRange(0,3*e),n.computeBoundingSphere()}function $de(n,t,e){let i=Math.max(t.length/2-1,0),r=2*i*3,o=3*r,s=n.attributes.position;(!s||s.count!==r)&&(s=new Yr(new Float32Array(o),3),n.setAttribute("position",s));let a=s.array;for(let l=0;l<i;l++){let[c,u,d,p]=[t[2*l],t[2*l+1],t[2*l+2],t[2*l+3]],h=new at(c,u),f=new at(d,p),m=new at(d-c,p-u),x=new at(-m.y,m.x).setLength(e/2),g=h.clone().add(x),b=h.clone().sub(x),D=f.clone().add(x),T=f.clone().sub(x),k=[g.x,g.y,0,b.x,b.y,0,D.x,D.y,0,D.x,D.y,0,b.x,b.y,0,T.x,T.y,0];a.set(k,l*k.length)}s.needsUpdate=!0,n.setDrawRange(0,o),n.computeBoundingSphere()}function Nk(n,t,e,i){let{visible:r,color:o,opacity:s}=i;if(Array.isArray(t.material))throw new Error("Invariant error: only expect one material on an object");let a=t.material;if(a.visible!==r&&(a.visible=r,a.needsUpdate=!0),!r)return!1;let l=DG(n,o,s??1),c=e(t.geometry);return t.geometry!==c&&(t.geometry=c),a.color.equals(l)||(a.color.set(l),a.needsUpdate=!0),!0}var Bk=class{constructor(t){this.rawSeriesData=[],this.series=[],this.paintDirty=!0,this.renderCache=new class{constructor(){this.prevFrameCache=new Map,this.currFrameCache=new Map}getFromPreviousFrame(t){return this.prevFrameCache.get(t)??null}setToCurrentFrame(t,e){this.currFrameCache.set(t,e)}finalizeFrameAndGetRemoved(){let t=[];for(let[e,i]of this.prevFrameCache.entries())this.currFrameCache.has(e)||t.push(i);return this.prevFrameCache=this.currFrameCache,this.currFrameCache=new Map,t}},this.coordinateIdentifier=null,this.layout={x:0,width:1,y:0,height:1},this.getMetadataMapImpl=t.getMetadataMap,this.coordinator=t.coordinator,this.renderer=t.renderer,this.paintBrush=new class{constructor(t,e){this.renderCache=t,this.renderer=e}setLine(t,e,i){let r=this.renderer.createOrUpdateLineObject(this.renderCache.getFromPreviousFrame(t),e,i);r&&this.renderCache.setToCurrentFrame(t,r)}setTriangle(t,e,i){let r=this.renderer.createOrUpdateTriangleObject(this.renderCache.getFromPreviousFrame(t),e,i);r&&this.renderCache.setToCurrentFrame(t,r)}setCircle(t,e,i){let r=this.renderer.createOrUpdateCircleObject(this.renderCache.getFromPreviousFrame(t),e,i);r&&this.renderCache.setToCurrentFrame(t,r)}setTrapezoid(t,e,i,r){let o=this.renderer.createOrUpdateTrapezoidObject(this.renderCache.getFromPreviousFrame(t),e,i,r);o&&this.renderCache.setToCurrentFrame(t,o)}}(this.renderCache,this.renderer)}setLayoutRect(t){(this.layout.x!==t.x||this.layout.width!==t.width||this.layout.y!==t.y||this.layout.height!==t.height)&&(this.paintDirty=!0),this.layout=t}getLayoutRect(){return this.layout}getMetadataMap(){return this.getMetadataMapImpl()}markAsPaintDirty(){this.paintDirty=!0}render(){if(this.transformCoordinatesIfStale(),this.paintDirty){this.redraw();for(let t of this.renderCache.finalizeFrameAndGetRemoved())this.renderer.destroyObject(t);this.paintDirty=!1}}isCoordinateUpdated(){return this.coordinator.getUpdateIdentifier()!==this.coordinateIdentifier}clearCoordinateIdentifier(){this.coordinateIdentifier=null}setData(t){this.clearCoordinateIdentifier(),this.rawSeriesData=t}transformCoordinatesIfStale(){if(!this.isCoordinateUpdated())return;let t=this.getLayoutRect();this.series=new Array(this.rawSeriesData.length);for(let e=0;e<this.rawSeriesData.length;e++){let i=this.rawSeriesData[e];this.series[e]={id:i.id,polyline:new Float32Array(2*i.points.length)};for(let r=0;r<i.points.length;r++){let[o,s]=this.coordinator.transformDataToUiCoord(t,[i.points[r].x,i.points[r].y]);this.series[e].polyline[2*r]=o,this.series[e].polyline[2*r+1]=s}}this.coordinateIdentifier=this.coordinator.getUpdateIdentifier(),this.markAsPaintDirty()}},Tb=(()=>(function(n){n[n.NUMBER=0]="NUMBER",n[n.NAN=1]="NAN"}(Tb||(Tb={})),Tb))(),Vk=class extends Bk{recordPartition(t,e,i){return t?{type:Tb.NUMBER,polyline:e}:{type:Tb.NAN,polyline:e.map((r,o)=>isNaN(r)?o%2==0?i.x:i.y:r)}}partitionPolyline(t){let e=[],i=0,r=!1,o=this.coordinator.transformDataToUiCoord(this.getLayoutRect(),[0,0]),s={x:o[0],y:o[1]},a=null;for(let l=0;l<t.length;l+=2){let c=t[l],u=t[l+1],d=isNaN(c)||isNaN(u);d!==r&&i!==l&&(e.push(this.recordPartition(!r,t.slice(i,l),null===a?{x:c,y:u}:a)),i=l),d||(a={x:c,y:u}),r=d}return i!==t.length-1&&e.push(this.recordPartition(!r,t.slice(i,t.length),a??s)),e}redraw(){for(let t of this.series){let i=this.getMetadataMap()[t.id];if(!i)continue;if(t.polyline.length%2!=0)throw new Error(`Cannot have odd length-ed polyline: ${t.polyline.length}`);let r=this.partitionPolyline(t.polyline);for(let[o,{type:s,polyline:a}]of r.entries())if(s===Tb.NUMBER)2===a.length?this.paintBrush.setCircle(JSON.stringify(["circle",t.id,o]),{x:a[0],y:a[1]},{color:i.color,visible:i.visible,opacity:i.opacity??1,radius:4}):this.paintBrush.setLine(JSON.stringify(["line",t.id,o]),a,{color:i.color,visible:i.visible,opacity:i.opacity??1,width:2});else if(!i.aux)for(let l=0;l<a.length;l+=2)this.paintBrush.setTriangle(JSON.stringify(["NaN",t.id,a[l],a[l+1]]),{x:a[l],y:a[l+1]},{color:i.color,visible:i.visible,opacity:i.opacity??1,size:12})}}},Hk=class extends By{constructor(){super(...arguments),this.camera=new qg(0,1e3,1e3,0,0,100)}isYAxisPointedDown(){return!1}setDomContainerRect(t){super.setDomContainerRect(t),this.camera.left=t.x,this.camera.right=t.x+t.width,this.camera.top=t.y+t.height,this.camera.bottom=t.y,this.camera.updateProjectionMatrix()}getCamera(){return this.camera}},Uk=class{constructor(t){switch(this.metadataMap={},this.shouldRepaint=!1,this.callbacks=t.callbacks,t.type){case dr.SVG:this.coordinator=new By,this.renderer=new class{constructor(t){this.svg=t}flush(){}onResize(t){}destroyObject(t){this.svg.removeChild(t.dom)}setUseDarkMode(t){}createPathDString(t){if(!t.length)return"";let e=new Array(t.length/2);e[0]=`M${t[0]},${t[1]}`;for(let i=1;i<t.length/2;i++)e[i]=`L${t[2*i]},${t[2*i+1]}`;return e.join("")}createOrUpdateLineObject(t,e,i){let r=xO(t?.dom,()=>{let o=document.createElementNS("http://www.w3.org/2000/svg","path");o.style.fill="none";let s=this.createPathDString(e);return o.setAttribute("d",s),this.svg.appendChild(o),o},o=>{if(!t?.data||!su_arePolylinesEqual(e,t?.data)){let s=this.createPathDString(e);o.setAttribute("d",s)}return o},i);return null===r?null:(r.style.strokeWidth=String(i.width),{dom:r,data:e})}createOrUpdateTriangleObject(t,e,i){let{size:r,color:o}=i,s=r*Math.sqrt(3)/2,a=new Float32Array([e.x-r/2,e.y+s/3,e.x+r/2,e.y+s/3,e.x,e.y-2*s/3]),l=xO(t?.dom,()=>{let c=document.createElementNS("http://www.w3.org/2000/svg","path");c.classList.add("triangle"),c.style.fill="none";let u=this.createPathDString(a);return c.setAttribute("d",u+"Z"),this.svg.appendChild(c),c},c=>{let u=this.createPathDString(a);return c.setAttribute("d",u+"Z"),c},i);return null===l?null:(l.style.fill=o,{dom:l,data:a})}createOrUpdateCircleObject(t,e,i){let{color:r,radius:o}=i,s=xO(t?.dom,()=>{let a=document.createElementNS("http://www.w3.org/2000/svg","circle");return a.style.fill=r,a.setAttribute("cx",String(e.x)),a.setAttribute("cy",String(e.y)),a.setAttribute("r",String(o)),this.svg.appendChild(a),a},a=>(a.style.fill=r,a.setAttribute("cx",String(e.x)),a.setAttribute("cy",String(e.y)),a.setAttribute("r",String(o)),a),i);return null===s?null:{dom:s,data:e}}createOrUpdateTrapezoidObject(t,e,i,r){if(e.y!==i.y)throw new RangeError("Input error: start.y != end.y.");let{altitude:o,color:s}=r,a=2/Math.sqrt(3)*o,l=new Float32Array([e.x-a/2,e.y+o/2,e.x,e.y-o/2,i.x,i.y-o/2,i.x+a/2,i.y+o/2]),c=xO(t?.dom,()=>{let u=document.createElementNS("http://www.w3.org/2000/svg","path");u.classList.add("trapezoid"),u.style.fill="none";let d=this.createPathDString(l);return u.setAttribute("d",d+"Z"),this.svg.appendChild(u),u},u=>{let d=this.createPathDString(l);return u.setAttribute("d",d+"Z"),u},r);return null===c?null:(c.style.fill=s,{dom:c,data:l})}dispose(){}}(t.container);break;case dr.WEBGL:{let e=new Hk;this.coordinator=e,this.renderer=new class{constructor(t,e,i,r){this.coordinator=e,this.scene=new vb,this.backgroundColor="#fff",su_isOffscreenCanvasSupported()&&t instanceof OffscreenCanvas&&(t.style=t.style||{}),r&&t.addEventListener("webglcontextlost",r),this.renderer=new ir({canvas:t,antialias:!0,alpha:!0}),this.renderer.setPixelRatio(i)}onResize(t){this.renderer.setSize(t.width,t.height)}destroyObject(t){let e=t.obj3d;if(this.scene.remove(e),e instanceof Vo){e.geometry.dispose();let i=Array.isArray(e.material)?e.material:[e.material];for(let r of i)r.dispose()}}setUseDarkMode(t){this.backgroundColor=t?"#303030":"#fff"}createOrUpdateLineObject(t,e,i){if(!t&&!i.visible)return null;let{visible:r,width:o}=i;if(!t){let u=DG(this.backgroundColor,i.color,i.opacity??1),d=new nr,p=new Ap({color:u}),h=new Vo(d,p);return p.visible=r,$de(d,e,o),this.scene.add(h),{type:pu.LINE,data:e,obj3d:h,width:o}}let{data:s,obj3d:a,width:l}=t;return Nk(this.backgroundColor,a,u=>((o!==l||!s||!su_arePolylinesEqual(s,e))&&$de(u,e,o),u),i)?{type:pu.LINE,data:e,obj3d:a,width:o}:t}createMesh(t,e){if(!e.visible)return null;let{visible:i,color:r,opacity:o}=e,s=DG(this.backgroundColor,r,o??1),a=new Gg({color:s,visible:i});return new Vo(t,a)}createOrUpdateTriangleObject(t,e,i){let{size:r}=i,o=r*Math.sqrt(3)/2,s=new Float32Array([e.x-r/2,e.y-o/3,e.x+r/2,e.y-o/3,e.x,e.y+2*o/3]);if(!t){let l=new nr;Jde(l,s);let c=this.createMesh(l,i);return null===c?null:(this.scene.add(c),{type:pu.TRIANGLE,data:e,obj3d:c})}return Nk(this.backgroundColor,t.obj3d,l=>(Jde(l,s),l),i)?{type:pu.TRIANGLE,data:e,obj3d:t.obj3d}:t}createOrUpdateCircleObject(t,e,i){let{radius:r}=i,o=new yb(i.radius);if(!t){let a=this.createMesh(o,i);return null===a?null:(a.position.set(e.x,e.y,0),this.scene.add(a),{type:pu.CIRCLE,data:{loc:e,radius:r},obj3d:a})}return Nk(this.backgroundColor,t.obj3d,()=>o,i)?(t.obj3d.position.set(e.x,e.y,0),{type:pu.CIRCLE,data:{loc:e,radius:r},obj3d:t.obj3d}):t}createOrUpdateTrapezoidObject(t,e,i,r){if(e.y!==i.y)throw new RangeError("Input error: start.y != end.y.");let{altitude:o}=r,s=2/Math.sqrt(3)*o,a=new Ip([new at(e.x-s/2,e.y-o/2),new at(e.x,e.y+o/2),new at(i.x,i.y+o/2),new at(i.x+s/2,i.y-o/2)]);a.autoClose=!0;let l=new Qg(a);if(!t){let u=this.createMesh(l,r);return null===u?null:(this.scene.add(u),{type:pu.TRAPEZOID,data:[e,i],obj3d:u})}return Nk(this.backgroundColor,t.obj3d,()=>l,r)?{type:pu.TRAPEZOID,data:[e,i],obj3d:t.obj3d}:t}flush(){this.renderer.render(this.scene,this.coordinator.getCamera())}dispose(){this.renderer.dispose()}}(t.container,e,t.devicePixelRatio,t.callbacks.onContextLost);break}}this.renderer.setUseDarkMode(t.useDarkMode),this.seriesLineView=new Vk({renderer:this.renderer,coordinator:this.coordinator,getMetadataMap:()=>this.metadataMap}),this.resize(t.domDimension)}dispose(){}setXScaleType(t){this.coordinator.setXScale(ou(t)),this.scheduleRepaint()}setYScaleType(t){this.coordinator.setYScale(ou(t)),this.scheduleRepaint()}resize(t){this.coordinator.setDomContainerRect({x:0,y:0,...t}),this.renderer.onResize({x:0,y:0,...t}),this.seriesLineView.setLayoutRect({...t,x:0,y:0}),this.scheduleRepaint()}setMetadata(t){let e=!1;Object.entries(t).forEach(([i,r])=>{let o=this.metadataMap[i];(!o||r.color!==o.color||r.visible!==o.visible||r.opacity!==o.opacity)&&(e=!0),this.metadataMap[i]=r}),e&&this.seriesLineView.markAsPaintDirty(),this.scheduleRepaint()}setViewBox(t){this.coordinator.setViewBoxRect({x:t.x[0],width:t.x[1]-t.x[0],y:t.y[0],height:t.y[1]-t.y[0]}),this.scheduleRepaint()}setData(t){this.seriesLineView.setData(t),this.scheduleRepaint()}setUseDarkMode(t){this.renderer.setUseDarkMode(t),this.seriesLineView.markAsPaintDirty(),this.scheduleRepaint()}scheduleRepaint(){this.shouldRepaint||(this.shouldRepaint=!0,(n=>{self.requestAnimationFrame(n)})(()=>{this.repaint(),this.shouldRepaint=!1}))}repaint(){this.seriesLineView.render(),this.renderer.flush(),this.callbacks.onDrawEnd()}},Dl=(()=>(function(n){n[n.SERIES_DATA_UPDATED=0]="SERIES_DATA_UPDATED",n[n.SERIES_METADATA_CHANGED=1]="SERIES_METADATA_CHANGED",n[n.SCALE_UPDATED=2]="SCALE_UPDATED",n[n.VIEW_BOX_UPDATED=3]="VIEW_BOX_UPDATED",n[n.INIT=4]="INIT",n[n.DOM_RESIZED=5]="DOM_RESIZED",n[n.DARK_MODE_UPDATED=6]="DARK_MODE_UPDATED",n[n.DISPOSED=7]="DISPOSED"}(Dl||(Dl={})),Dl))(),Db=(()=>(function(n){n[n.ON_REDRAW_END=0]="ON_REDRAW_END",n[n.ON_CONTEXT_LOST=1]="ON_CONTEXT_LOST"}(Db||(Db={})),Db))();function tpe(n){if(n.includes("/"))throw new RangeError("Worker factory only allows file name and no resource path.");return new Worker(n)}var Jg=class{constructor(t){if(this.callbacks=t.callbacks,t.type!==dr.WEBGL)throw new RangeError(`Cannot use non WEBGL renderer for the offscreen line chart. Received ${dr[t.type]} `);let e=new MessageChannel;e.port1.onmessage=o=>{this.onMessageFromWorker(o.data)},this.txMessagePort=e.port1;let i=t.container.transferControlToOffscreen();this.workerInstance=Jg.workerPool.getNext();let r={type:Dl.INIT,canvas:i,devicePixelRatio:window.devicePixelRatio,dim:t.domDimension,rendererType:t.type,useDarkMode:t.useDarkMode};this.workerInstance.postMessage(r,[i,e.port2])}dispose(){this.sendMessage({type:Dl.DISPOSED}),this.workerInstance.free(),this.txMessagePort.close()}setXScaleType(t){this.sendMessage({type:Dl.SCALE_UPDATED,axis:"x",scaleType:t})}setYScaleType(t){this.sendMessage({type:Dl.SCALE_UPDATED,axis:"y",scaleType:t})}resize(t){this.sendMessage({type:Dl.DOM_RESIZED,dim:t})}setMetadata(t){this.sendMessage({type:Dl.SERIES_METADATA_CHANGED,metadata:t})}setViewBox(t){this.sendMessage({type:Dl.VIEW_BOX_UPDATED,extent:t})}setData(t){let e=function(n){let t=n.reduce((o,s)=>o+s.points.length,0),e=0,i=new Float64Array(2*t),r=[];for(let o of n){r.push({id:o.id,length:o.points.length});for(let s=0;s<o.points.length;s++)i[e++]=o.points[s].x,i[e++]=o.points[s].y}return{idsAndLengths:r,flattenedSeries:i.buffer}}(t);this.sendMessage({type:Dl.SERIES_DATA_UPDATED,compactDataSeries:e},[e.flattenedSeries])}setUseDarkMode(t){this.sendMessage({type:Dl.DARK_MODE_UPDATED,useDarkMode:t})}sendMessage(t,e){e?this.txMessagePort.postMessage(t,e):this.txMessagePort.postMessage(t)}onMessageFromWorker(t){switch(t.type){case Db.ON_REDRAW_END:this.callbacks.onDrawEnd();break;case Db.ON_CONTEXT_LOST:this.callbacks.onContextLost()}}};function Ad(n,t){return"x"===t?[0,n.width]:[n.height,0]}function vE(n,t){let e=Math.floor(n/50);return Math.min(e,t)}function PG(n,t,e,i){return{major:[],minor:n.ticks(i,e).map(o=>({value:o,tickFormattedString:t.formatTick(o)}))}}Jg.workerPool=new class{constructor(t,e=10,i=tpe){this.workerResourcePath=t,this.maxPoolSize=e,this.workerFactory=i,this.workers=[]}getNext(){let t;if(this.workers.every(({activeCount:i})=>i>0)&&this.workers.length<this.maxPoolSize){let i=this.workerFactory(this.workerResourcePath);t={activeCount:0,postMessage:(r,o)=>{i.postMessage(r,o)},free:()=>{t.activeCount=Math.max(t.activeCount-1,0)}},this.workers.push(t)}else{let i=this.workers.map(({activeCount:o})=>o),r=i.indexOf(Math.min(...i));t=this.workers[r]}return t.activeCount++,t}}("chart_worker.js?_file_hash=c4417681");var IG=document.createElement("canvas").getContext("2d"),yE={getStandardTicks:PG,getTicksForTemporalScale:function(n,t,e,i){let[r,o]=i,s=n.ticks(i,2);if(o-r>=864e5||s.length>2)return PG(n,t,e,i);let a=n.ticks(i,e);return{major:s.map(l=>({start:l,tickFormattedString:t.formatShort(l)})),minor:a.map(l=>({value:l,tickFormattedString:t.formatTick(l)}))}},getTicksForLinearScale:function(n,t,e,i){let[r,o]=i,s=Math.abs(o-r);if(s>.001)return PG(n,t,e,i);let a=n.ticks([r,o],e),l=n.ticks([r,o],2),c=[],u=function(n){let t=n.toExponential().split("e-",2);return 2===t.length?Number(t[1])-1:0}(s);s<1&&l.every(h=>{let f=Math.abs(h);return f>=0&&f<1})&&(u+=1);let d=new Map;for(let h of l){let[f,m=""]=String(h).split(".",2),x=Number(f+"."+m.slice(0,u));d.set(x,{start:x,tickFormattedString:0===x?"\u2014":t.formatReadable(x)})}let p=10*Math.pow(10,-u);for(let h of a)for(let f of[...d.keys()].reverse()){let m=h-f;if(m>=0&&m<p){if(0===f)c.push({value:h,tickFormattedString:t.formatTick(h)});else{let x=String(h).slice(String(f).length);c.push({value:h,tickFormattedString:`\u2026${x||"0"}`})}break}}return{major:Array.from(d.values()),minor:c}},filterTicksByVisibility:function(n,t,e,i,r=5){if(!n.length||!IG)return n;let o="x"===e?1:-1,s=null;return n.filter(a=>{let l=t(a);IG.font=i;let c=IG.measureText(a.tickFormattedString),u="x"===e?c.width:c.actualBoundingBoxAscent-c.actualBoundingBoxDescent;return null===s?!(l+o*u<0||(s=l+o*u,0)):!(o*(s+o*r-l)>0||(s=l+o*u,0))})}};function dqe(n,t){if(1&n&&(In(),_(0,"g",17)(1,"text"),A(2),v(),_(3,"title"),A(4),v()()),2&n){let e=t.$implicit,i=S();C(1),Pt("font",i.axisFont),ze("x",i.textXPosition(e.value))("y",i.textYPosition(e.value)),C(1),je(" ",e.tickFormattedString," "),C(2),yt(i.getFormatter().formatLong(e.value))}}function pqe(n,t){if(1&n&&(_(0,"span",20)(1,"span"),A(2),v()()),2&n){let e=t.$implicit,i=t.index,r=t.last,o=S(2);Pt("left",o.getMajorXPosition(e),"px")("width",o.getMajorWidthString(e,r,o.majorTicks[i+1]))("bottom",o.getMajorYPosition(e),"px")("height",o.getMajorHeightString(e,r,o.majorTicks[i+1]))("font",o.axisFont),et("major-label",!0)("last",r),y("title",o.getFormatter().formatLong(e.start)),C(2),yt(e.tickFormattedString)}}function hqe(n,t){if(1&n&&(_(0,"div",18),E(1,pqe,3,16,"span",19),v()),2&n){let e=S();C(1),y("ngForOf",e.majorTicks)("ngForTrackBy",e.trackByMajorTick)}}var ope=(()=>{class n{constructor(){this.onViewExtentChange=new G,this.editMenuOpened=!1,this.majorTicks=[],this.minorTicks=[]}ngOnChanges(){let e=null,r=vE("x"===this.axis?this.domDim.width:this.domDim.height,this.gridCount);e=this.scale instanceof ES?yE.getTicksForLinearScale(this.scale,this.getFormatter(),r,this.axisExtent):this.scale instanceof TS?yE.getTicksForTemporalScale(this.scale,this.getFormatter(),r,this.axisExtent):yE.getStandardTicks(this.scale,this.getFormatter(),r,this.axisExtent),this.majorTicks=e.major,this.minorTicks=yE.filterTicksByVisibility(e.minor,o=>this.getDomPos(o.value),this.axis,"11px Roboto, sans-serif")}getFormatter(){return this.customFormatter??this.scale.defaultFormatter}trackByMinorTick(e){return e.value}trackByMajorTick(e){return e.start}getDomPos(e){return this.scale.forward(this.axisExtent,Ad(this.domDim,this.axis),e)}textXPosition(e){return"x"===this.axis?String(this.getDomPos(e)):"100%"}textYPosition(e){return"x"===this.axis?"":String(this.getDomPos(e))}getMajorXPosition(e){return"y"===this.axis?0:Math.min(this.domDim.width,Math.max(0,this.getDomPos(e.start)))}getMajorWidthString(e,i,r){return"y"===this.axis?"":(i||!r?this.domDim.width:this.getMajorXPosition(r))-this.getMajorXPosition(e)+"px"}getMajorYPosition(e){return"x"===this.axis?0:this.domDim.height-Math.min(this.domDim.height,Math.max(0,this.getDomPos(e.start)))}getMajorHeightString(e,i,r){return"x"===this.axis?"":(i||!r?this.domDim.height:this.getMajorYPosition(r))-this.getMajorYPosition(e)+"px"}keydownPreventClose(e){"Escape"!==e.key&&e.stopPropagation()}extentChanged(e,i){let r=Number(e),o=Number(i);if(o<r){let s=r;r=o,o=s}!Number.isFinite(r)||!Number.isFinite(o)||this.onViewExtentChange.emit([r,o])}onAxisUpdateMenuOpen(e,i,r){e.value=String(r[0]),i.value=String(r[1]),e.focus()}setEditMenuOpened(e){this.editMenuOpened=e}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["line-chart-axis"]],inputs:{axisExtent:"axisExtent",axis:"axis",scale:"scale",gridCount:"gridCount",domDim:"domDim",customFormatter:"customFormatter"},outputs:{onViewExtentChange:"onViewExtentChange"},features:[Ft],decls:26,vars:13,consts:[[1,"line"],[1,"minor"],[1,"ticks"],["class","minor-tick-label",4,"ngFor","ngForOf","ngForTrackBy"],["mat-icon-button","","title","Click to manually set min & max values",3,"matMenuTriggerFor","menuOpened","menuClosed"],["matMenuTrigger","matMenuTrigger"],["svgIcon","edit_24px"],["class","major ticks",4,"ngIf"],["xPosition","before",3,"yPosition"],["manualControl","matMenu"],[1,"extent-edit-input",3,"click","keydown"],["type","number",3,"value"],["minInput",""],["maxInput",""],[1,"extent-edit-control",3,"keydown"],["mat-raised-button","","color","primary",1,"extent-edit-change",3,"click"],["mat-stroked-button","",1,"extent-edit-cancel",3,"click"],[1,"minor-tick-label"],[1,"major","ticks"],[3,"major-label","last","left","width","bottom","height","font","title",4,"ngFor","ngForOf","ngForTrackBy"],[3,"title"]],template:function(e,i){if(1&e){let r=Pe();_(0,"div"),O(1,"div",0),_(2,"div",1),In(),_(3,"svg",2),E(4,dqe,5,6,"g",3),v(),Js(),_(5,"button",4,5),P("menuOpened",function(){oe(r);let s=$e(15),a=$e(20);return i.onAxisUpdateMenuOpen(s,a,i.axisExtent),se(i.setEditMenuOpened(!0))})("menuClosed",function(){return i.setEditMenuOpened(!1)}),O(7,"mat-icon",6),v()(),E(8,hqe,2,2,"div",7),v(),_(9,"mat-menu",8,9)(11,"div",10),P("click",function(s){return s.stopPropagation()})("keydown",function(s){return i.keydownPreventClose(s)}),_(12,"label"),A(13,"min"),v(),O(14,"input",11,12),v(),_(16,"div",10),P("click",function(s){return s.stopPropagation()})("keydown",function(s){return i.keydownPreventClose(s)}),_(17,"label"),A(18,"max"),v(),O(19,"input",11,13),v(),_(21,"div",14),P("keydown",function(s){return i.keydownPreventClose(s)}),_(22,"button",15),P("click",function(){oe(r);let s=$e(15),a=$e(20),l=$e(6);return i.extentChanged(s.value,a.value),se(l.closeMenu())}),A(23," Change "),v(),_(24,"button",16),P("click",function(){return oe(r),se($e(6).closeMenu())}),A(25," Cancel "),v()()()}if(2&e){let r=$e(10);Da(i.axis+"-axis axis"),C(4),y("ngForOf",i.minorTicks)("ngForTrackBy",i.trackByMinorTick),C(1),et("extent-edit-button",!0)("extent-edit-menu-opened",i.editMenuOpened),y("matMenuTriggerFor",r),C(3),y("ngIf",i.majorTicks.length),C(1),y("yPosition","y"===i.axis?"above":"below"),C(5),y("value",i.axisExtent[0]),C(5),y("value",i.axisExtent[1])}},dependencies:[dn,Be,_n,Gt,hd,fd],styles:["[_nghost-%COMP%]{contain:strict;display:flex;overflow:hidden}.major-label[_ngcontent-%COMP%], text[_ngcontent-%COMP%]{fill:currentColor;font-size:11px;user-select:none}.axis[_ngcontent-%COMP%]{display:flex;height:100%;width:100%}.major[_ngcontent-%COMP%], .minor[_ngcontent-%COMP%]{flex:1 0;overflow:hidden}.line[_ngcontent-%COMP%]{background-color:#aaa;flex:0 0 1px;justify-content:stretch}.ticks[_ngcontent-%COMP%]{height:100%;position:relative;width:100%}.x-axis[_ngcontent-%COMP%]{flex-direction:column}.x-axis[_ngcontent-%COMP%]   .line[_ngcontent-%COMP%]{margin-bottom:3px}.x-axis[_ngcontent-%COMP%]   text[_ngcontent-%COMP%]{dominant-baseline:text-before-edge;text-anchor:middle}.x-axis[_ngcontent-%COMP%]   .ticks[_ngcontent-%COMP%]{-webkit-mask-image:linear-gradient(to right, rgba(0, 0, 0, 0) 0%, #000 10%, #000 90%, rgba(0, 0, 0, 0) 100%);mask-image:linear-gradient(to right, rgba(0, 0, 0, 0) 0%, #000 10%, #000 90%, rgba(0, 0, 0, 0) 100%)}.y-axis[_ngcontent-%COMP%]{flex-direction:row-reverse}.y-axis[_ngcontent-%COMP%]   .line[_ngcontent-%COMP%]{margin-left:5px}.y-axis[_ngcontent-%COMP%]   text[_ngcontent-%COMP%]{dominant-baseline:central;text-anchor:end}.y-axis[_ngcontent-%COMP%]   .ticks[_ngcontent-%COMP%]{-webkit-mask-image:linear-gradient(to bottom, rgba(0, 0, 0, 0) 0%, #000 10%, #000 90%, rgba(0, 0, 0, 0) 100%);mask-image:linear-gradient(to bottom, rgba(0, 0, 0, 0) 0%, #000 10%, #000 90%, rgba(0, 0, 0, 0) 100%)}.extent-edit-button[_ngcontent-%COMP%]{background-color:#eee;font-size:0;height:24px;line-height:24px;position:absolute;right:5px;top:5px;visibility:hidden;width:24px}.extent-edit-button[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{height:16px;width:16px;line-height:16px}.extent-edit-input[_ngcontent-%COMP%]{align-items:center;column-gap:5px;display:grid;font-size:12px;grid-template-columns:30px minmax(auto, 100px);height:30px;margin:10px 20px}.extent-edit-input[_ngcontent-%COMP%]   input[_ngcontent-%COMP%]{background-color:inherit;border-radius:4px;border-style:solid;color:inherit}.extent-edit-control[_ngcontent-%COMP%]{align-items:center;display:flex;flex-direction:row-reverse;justify-content:flex-end;margin:10px 20px}.extent-edit-control[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{font-size:12px;height:30px;line-height:1.4;margin-left:5px;padding:0 10px}.axis[_ngcontent-%COMP%]:hover   .extent-edit-button[_ngcontent-%COMP%], .axis[_ngcontent-%COMP%]:focus-within   .extent-edit-button[_ngcontent-%COMP%], .extent-edit-menu-opened[_ngcontent-%COMP%]{visibility:visible}.major[_ngcontent-%COMP%]{position:relative;overflow:hidden;contain:strict}.major[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%]{align-items:center;box-sizing:border-box;display:inline-flex;justify-content:center;overflow:hidden;position:absolute;white-space:nowrap}.major[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%]   span[_ngcontent-%COMP%]{max-width:100%}.x-axis[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%]{border-left:1px solid #9e9e9e;padding:0 5px}.x-axis[_ngcontent-%COMP%]   .major-label.last[_ngcontent-%COMP%]{border-right:1px solid #9e9e9e}.y-axis[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%]{border-bottom:1px solid #9e9e9e;height:100%;padding:5px 0;width:100%}.y-axis[_ngcontent-%COMP%]   .major-label.last[_ngcontent-%COMP%]{border-top:1px solid #9e9e9e}.y-axis[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%] > span[_ngcontent-%COMP%]{transform:rotate(-90deg);transform-origin:center}"],changeDetection:0}),n})();function bE(n,t){let e=Math.min(iu(n.map(({x:o})=>o),t),n.length-1),i=Math.max(0,e-1);return Math.abs(n[i].x-t)-Math.abs(n[e].x-t)<=0?i:e}function spe(n,t,e,i,r,o){let s;switch(n.deltaMode){case WheelEvent.DOM_DELTA_PIXEL:s=1;break;case WheelEvent.DOM_DELTA_LINE:s=8;break;case WheelEvent.DOM_DELTA_PAGE:s=20;break;default:s=1,console.warn(`Unknown WheelEvent deltaMode: ${n.deltaMode}.`)}let a=n.deltaY*s,l=a<0?Math.max(a*i,-.95):a*i,{width:c,height:u}=e,d=[r.reverse(t.x,[0,c],-n.offsetX*l),r.reverse(t.x,[0,c],c+(c-n.offsetX)*l)],p=[o.reverse(t.y,[u,0],-n.offsetY*l),o.reverse(t.y,[u,0],u+(u-n.offsetY)*l)];return{x:d[1]<d[0]?[d[1],d[0]]:d,y:p[1]<p[0]?[p[1],p[0]]:p}}var gqe=["dots"];function _qe(n,t){if(1&n&&(In(),O(0,"circle",12)),2&n){let e=S().$implicit,i=S(2);ze("cx",i.getDomX(e.dataPoint.x))("cy",i.getDomY(e.dataPoint.y))("fill",e.metadata.color)}}function vqe(n,t){if(1&n&&(In(),sn(0),E(1,_qe,1,3,"circle",11),an()),2&n){let e=t.$implicit,i=S(2);C(1),y("ngIf",i.shouldRenderTooltipPoint(e.dataPoint))}}function yqe(n,t){if(1&n&&(In(),sn(0),E(1,vqe,2,1,"ng-container",10),an()),2&n){let e=S();C(1),y("ngForOf",e.cursoredData)("ngForTrackBy",e.trackBySeriesName)}}function bqe(n,t){if(1&n&&(In(),O(0,"rect",13)),2&n){let e=S();ze("x",e.zoomBoxInUiCoordinate.x)("width",e.zoomBoxInUiCoordinate.width)("y",e.zoomBoxInUiCoordinate.y)("height",e.zoomBoxInUiCoordinate.height)}}var xqe=function(n,t,e){return{data:n,cursorLocationInDataCoord:t,cursorLocation:e}};function Cqe(n,t){if(1&n&&(_(0,"div",14),Ni(1,15),v()),2&n){let e=S(),i=$e(11);C(1),y("ngTemplateOutlet",e.tooltipTemplate?e.tooltipTemplate:i)("ngTemplateOutletContext",Zx(2,xqe,e.cursoredData,e.cursorLocationInDataCoord,e.cursorLocation))}}function Mqe(n,t){if(1&n&&(sn(0),_(1,"tr",17)(2,"td",18),O(3,"span"),v(),_(4,"td",19),A(5),v(),_(6,"td"),A(7),v(),_(8,"td"),A(9),v()(),an()),2&n){let e=t.$implicit;C(3),Pt("background-color",e.metadata.color),C(2),yt(e.metadata.displayName),C(2),yt(e.dataPoint.y),C(2),yt(e.dataPoint.x)}}function wqe(n,t){if(1&n&&(_(0,"table")(1,"thead")(2,"tr"),O(3,"th",16),_(4,"th"),A(5,"Name"),v(),_(6,"th"),A(7,"Y"),v(),_(8,"th"),A(9,"X"),v()()(),_(10,"tbody"),E(11,Mqe,10,5,"ng-container",10),v()()),2&n){let e=t.data,i=S();C(11),y("ngForOf",e)("ngForTrackBy",i.trackBySeriesName)}}function Eqe(n){return n.scrollStrategies.reposition()}var ape=(()=>{class n{constructor(e,i){this.changeDetector=e,this.scrollStrategy=i,this.onViewExtentChange=new G,this.onViewExtentReset=new G,this.onInteractionStateChange=new G,this.InteractionState=Gr,this.state=new hr(Gr.NONE),this.specialKeyPressed=!1,this.zoomBoxInUiCoordinate={x:0,width:0,height:0,y:0},this.tooltipPositions=[{offsetY:5,originX:"start",overlayX:"start",originY:"bottom",overlayY:"top"},{offsetY:5,originX:"end",overlayX:"end",originY:"bottom",overlayY:"top"},{offsetY:-15,originX:"start",overlayX:"start",originY:"top",overlayY:"bottom"},{offsetY:-15,originX:"end",overlayX:"end",originY:"top",overlayY:"bottom"},{offsetX:5,originX:"end",overlayX:"start",originY:"top",overlayY:"top"},{offsetX:-5,originX:"start",overlayX:"end",originY:"top",overlayY:"top"}],this.cursorLocationInDataCoord=null,this.cursorLocation=null,this.cursoredData=[],this.tooltipDisplayAttached=!1,this.showZoomInstruction=!1,this.dragStartCoord=null,this.isCursorInside=!1,this.ngUnsubscribe=new ke,this.subscriptions=[]}ngAfterViewInit(){this.subscriptions.push(this.state.subscribe(e=>{this.onInteractionStateChange.emit(e)})),this.ngUnsubscribe.pipe(L(()=>{this.subscriptions.forEach(e=>e.unsubscribe())})),_i(this.dotsContainer.nativeElement,"dblclick",{passive:!0}).pipe(st(this.ngUnsubscribe)).subscribe(()=>{this.onViewExtentReset.emit(),this.state.next(Gr.NONE),this.changeDetector.markForCheck()}),_i(window,"keydown",{passive:!0}).pipe(st(this.ngUnsubscribe)).subscribe(e=>{let i=this.shouldPan(e);i!==this.specialKeyPressed&&(this.specialKeyPressed=i,this.changeDetector.markForCheck())}),_i(window,"keyup",{passive:!0}).pipe(st(this.ngUnsubscribe)).subscribe(e=>{let i=this.shouldPan(e);i!==this.specialKeyPressed&&(this.specialKeyPressed=i,this.changeDetector.markForCheck())}),_i(this.dotsContainer.nativeElement,"mousedown",{passive:!0}).pipe(st(this.ngUnsubscribe)).subscribe(e=>{let i=this.state.getValue(),r=this.shouldPan(e)?Gr.PANNING:Gr.DRAG_ZOOMING;i===Gr.NONE&&r===Gr.DRAG_ZOOMING&&(this.dragStartCoord={x:e.offsetX,y:e.offsetY},this.zoomBoxInUiCoordinate={x:e.offsetX,width:0,y:e.offsetY,height:0}),i!==r&&(this.state.next(r),this.changeDetector.markForCheck())}),_i(this.dotsContainer.nativeElement,"mouseup",{passive:!0}).pipe(st(this.ngUnsubscribe)).subscribe(e=>{let i=(e.buttons&Cl.LEFT)===Cl.LEFT;this.dragStartCoord=null;let r=this.zoomBoxInUiCoordinate;if(!i&&this.state.getValue()===Gr.DRAG_ZOOMING&&r.width>0&&r.height>0){let o=this.getDataX(r.x),s=this.getDataX(r.x+r.width),a=this.getDataY(r.y+r.height),l=this.getDataY(r.y);this.onViewExtentChange.emit({dataExtent:{x:[o,s],y:[a,l]}})}this.state.getValue()!==Gr.NONE&&(this.state.next(Gr.NONE),this.changeDetector.markForCheck())}),_i(this.dotsContainer.nativeElement,"mouseenter",{passive:!0}).pipe(st(this.ngUnsubscribe)).subscribe(e=>{this.isCursorInside=!0,this.updateTooltip(e),this.changeDetector.markForCheck()}),_i(this.dotsContainer.nativeElement,"mouseleave",{passive:!0}).pipe(st(this.ngUnsubscribe)).subscribe(e=>{this.dragStartCoord=null,this.isCursorInside=!1,this.updateTooltip(e),this.state.next(Gr.NONE),this.changeDetector.markForCheck()}),_i(this.dotsContainer.nativeElement,"mousemove",{passive:!0}).pipe(st(this.ngUnsubscribe)).subscribe(e=>{switch(this.state.getValue()){case Gr.SCROLL_ZOOMING:this.state.next(Gr.NONE),this.updateTooltip(e),this.changeDetector.markForCheck();break;case Gr.NONE:this.updateTooltip(e),this.changeDetector.markForCheck();break;case Gr.PANNING:{let i=-e.movementX,r=-e.movementY,{width:o,height:s}=this.domDim,a=this.getDataX(i),l=this.getDataX(o+i),c=this.getDataY(s+r),u=this.getDataY(r);this.onViewExtentChange.emit({dataExtent:{x:[a,l],y:[c,u]}});break}case Gr.DRAG_ZOOMING:{if(!this.dragStartCoord)break;let i=[this.dragStartCoord.x,e.offsetX],r=[this.dragStartCoord.y,e.offsetY];this.zoomBoxInUiCoordinate={x:Math.min(...i),width:Math.max(...i)-Math.min(...i),y:Math.min(...r),height:Math.max(...r)-Math.min(...r)}}this.changeDetector.markForCheck()}}),_i(this.dotsContainer.nativeElement,"wheel",{passive:!1}).pipe(st(this.ngUnsubscribe),ui(e=>{let i=!e.ctrlKey&&!e.shiftKey&&e.altKey;return this.showZoomInstruction=!i,this.changeDetector.markForCheck(),i?(e.preventDefault(),Xt(e)):Ka(3e3).pipe(kt(()=>{this.showZoomInstruction=!1,this.changeDetector.markForCheck()}),L(()=>null))}),Ye(e=>Boolean(e))).subscribe(e=>{this.onViewExtentChange.emit({dataExtent:spe(e,this.viewExtent,this.domDim,.01,this.xScale,this.yScale)}),this.state.getValue()!==Gr.SCROLL_ZOOMING&&(this.state.next(Gr.SCROLL_ZOOMING),this.changeDetector.markForCheck())})}ngOnChanges(){this.updateCursoredDataAndTooltipVisibility()}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}shouldPan(e){let i=e.shiftKey||e.altKey;if(e instanceof KeyboardEvent)return i;let r=(e.buttons&Cl.LEFT)===Cl.LEFT,o=(e.buttons&Cl.MIDDLE)===Cl.MIDDLE;return!(!r&&!o)&&(o&&!r||i)}trackBySeriesName(e,i){return i.id}getDomX(e){return this.xScale.forward(this.viewExtent.x,Ad(this.domDim,"x"),e)}getDataX(e){return this.xScale.reverse(this.viewExtent.x,Ad(this.domDim,"x"),e)}getDomY(e){return this.yScale.forward(this.viewExtent.y,Ad(this.domDim,"y"),e)}getDataY(e){return this.yScale.reverse(this.viewExtent.y,Ad(this.domDim,"y"),e)}shouldRenderTooltipPoint(e){return null!==e&&!isNaN(e.x)&&!isNaN(e.y)}updateTooltip(e){this.cursorLocationInDataCoord={x:this.getDataX(e.offsetX),y:this.getDataY(e.offsetY)},this.cursorLocation={x:e.offsetX,y:e.offsetY},this.updateCursoredDataAndTooltipVisibility()}onTooltipDisplayDetached(){this.tooltipDisplayAttached=!1}updateCursoredDataAndTooltipVisibility(){let e=this.cursorLocationInDataCoord;if(null===e)return this.cursoredData=[],void(this.tooltipDisplayAttached=!1);this.cursoredData=this.isCursorInside?this.seriesData.map(i=>({seriesDatum:i,metadata:this.seriesMetadataMap[i.id]})).filter(({metadata:i})=>i&&i.visible&&!Boolean(i.aux)).map(({seriesDatum:i,metadata:r})=>{let o=bE(i.points,e.x),s=i.points[o];return{id:i.id,closestPointIndex:o,dataPoint:s,domPoint:{x:this.getDomX(s.x),y:this.getDomY(s.y)},metadata:r}}).filter(i=>i):[],this.tooltipDisplayAttached=Boolean(this.cursoredData.length)}}return n.\u0275fac=function(e){return new(e||n)(M(nn),M(ng))},n.\u0275cmp=R({type:n,selectors:[["line-chart-interactive-view"]],viewQuery:function(e,i){if(1&e&&(ot(gqe,7,Re),ot(Rh,5)),2&e){let r;Ne(r=Le())&&(i.dotsContainer=r.first),Ne(r=Le())&&(i.overlay=r.first)}},hostVars:2,hostBindings:function(e,i){2&e&&et("show-zoom-instruction",i.showZoomInstruction)},inputs:{seriesData:"seriesData",seriesMetadataMap:"seriesMetadataMap",viewExtent:"viewExtent",xScale:"xScale",yScale:"yScale",domDim:"domDim",tooltipOriginEl:"tooltipOriginEl",tooltipTemplate:"tooltipTemplate"},outputs:{onViewExtentChange:"onViewExtentChange",onViewExtentReset:"onViewExtentReset",onInteractionStateChange:"onInteractionStateChange"},features:[$t([{provide:ng,useFactory:Eqe,deps:[tr]}]),Ft],decls:12,vars:15,consts:[[1,"dots"],["dots",""],[4,"ngIf"],["class","zoom-box",4,"ngIf"],[1,"zoom-instruction"],[1,"instruction-content"],["cdkOverlayOrigin","",1,"tooltip-origin"],["tooltipOrigin","cdkOverlayOrigin"],["cdkConnectedOverlay","",3,"cdkConnectedOverlayOrigin","cdkConnectedOverlayOpen","cdkConnectedOverlayPositions","cdkConnectedOverlayScrollStrategy","cdkConnectedOverlayLockPosition","cdkConnectedOverlayFlexibleDimensions","cdkConnectedOverlayGrowAfterOpen","detach"],["defaultTooltip",""],[4,"ngFor","ngForOf","ngForTrackBy"],["r","4",4,"ngIf"],["r","4"],[1,"zoom-box"],[1,"tooltip-container"],[3,"ngTemplateOutlet","ngTemplateOutletContext"],[1,"circle-header"],[1,"tooltip-row"],[1,"tooltip-row-circle"],[1,"name"]],template:function(e,i){1&e&&(In(),_(0,"svg",0,1),E(2,yqe,2,2,"ng-container",2),E(3,bqe,1,4,"rect",3),v(),Js(),_(4,"div",4)(5,"span",5),A(6,"Alt + Scroll to Zoom"),v()(),O(7,"div",6,7),E(9,Cqe,2,6,"ng-template",8),P("detach",function(){return i.onTooltipDisplayDetached()}),E(10,wqe,12,2,"ng-template",null,9,qt)),2&e&&(et("pannable",i.specialKeyPressed)("draggable",i.state.getValue()===i.InteractionState.NONE||i.state.getValue()===i.InteractionState.DRAG_ZOOMING)("panning",i.state.getValue()===i.InteractionState.PANNING),C(2),y("ngIf",i.state.getValue()===i.InteractionState.NONE),C(1),y("ngIf",i.state.getValue()===i.InteractionState.DRAG_ZOOMING),C(6),y("cdkConnectedOverlayOrigin",i.tooltipOriginEl)("cdkConnectedOverlayOpen",i.tooltipDisplayAttached&&i.state.getValue()===i.InteractionState.NONE)("cdkConnectedOverlayPositions",i.tooltipPositions)("cdkConnectedOverlayScrollStrategy",i.scrollStrategy)("cdkConnectedOverlayLockPosition",!1)("cdkConnectedOverlayFlexibleDimensions",!0)("cdkConnectedOverlayGrowAfterOpen",!0))},dependencies:[dn,Be,os,Rh,ig],styles:["[_nghost-%COMP%]{display:flex;position:relative;user-select:none}.dots[_ngcontent-%COMP%]{height:100%;width:100%}.dots.draggable[_ngcontent-%COMP%]{cursor:crosshair}.dots.pannable[_ngcontent-%COMP%]{cursor:grab}.dots.panning[_ngcontent-%COMP%]{cursor:grabbing}.tooltip-row-circle[_ngcontent-%COMP%]{align-items:center;display:inline-flex;height:12px;width:12px}.tooltip-row-circle[_ngcontent-%COMP%] > span[_ngcontent-%COMP%]{border-radius:50%;border:1px solid rgba(255,255,255,.6);display:inline-block;height:10px;width:10px}.tooltip-origin[_ngcontent-%COMP%]{bottom:0;left:0;position:absolute;right:0}.tooltip-container[_ngcontent-%COMP%]{background:rgba(0,0,0,.85);border-radius:4px;color:#fff;contain:paint style layout;font-size:.9em;overflow:auto;padding:5px;pointer-events:none;width:100%}th[_ngcontent-%COMP%], td[_ngcontent-%COMP%]{padding:2px 5px;text-align:left}th[_ngcontent-%COMP%]{font-weight:500;padding-bottom:5px}.zoom-box[_ngcontent-%COMP%]{fill-opacity:.03;fill:#000;stroke:#ccc}.zoom-instruction[_ngcontent-%COMP%]{align-items:center;display:flex;justify-content:center;left:0;opacity:0;pointer-events:none;position:absolute;right:0;top:10px;transition:opacity .5s;z-index:1}.instruction-content[_ngcontent-%COMP%]{background:rgba(0,0,0,.6);border-radius:5px;color:#fff;padding:5px 10px;user-select:none}.show-zoom-instruction[_nghost-%COMP%]   .zoom-instruction[_ngcontent-%COMP%]{opacity:1}"],changeDetection:0}),n})();function Dqe(n,t){if(1&n&&(In(),O(0,"line",2)),2&n){let e=t.$implicit,i=S();et("zero",0===e),ze("x1",i.getDomX(e))("x2",i.getDomX(e))("y2",i.domDim.height)}}function Aqe(n,t){if(1&n&&(In(),O(0,"line",3)),2&n){let e=t.$implicit,i=S();et("zero",0===e),ze("y1",i.getDomY(e))("x2",i.domDim.width)("y2",i.getDomY(e))}}var lpe=(()=>{class n{getDomX(e){return this.xScale.forward(this.viewExtent.x,Ad(this.domDim,"x"),e)}getDomY(e){return this.yScale.forward(this.viewExtent.y,Ad(this.domDim,"y"),e)}getXTicks(){return this.xScale.ticks(this.viewExtent.x,vE(this.domDim.width,this.xGridCount))}getYTicks(){return this.yScale.ticks(this.viewExtent.y,vE(this.domDim.height,this.yGridCount))}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["line-chart-grid-view"]],inputs:{viewExtent:"viewExtent",xScale:"xScale",xGridCount:"xGridCount",yScale:"yScale",yGridCount:"yGridCount",domDim:"domDim"},decls:3,vars:2,consts:[["y1","0",3,"zero",4,"ngFor","ngForOf"],["x1","0",3,"zero",4,"ngFor","ngForOf"],["y1","0"],["x1","0"]],template:function(e,i){1&e&&(In(),_(0,"svg"),E(1,Dqe,1,5,"line",0),E(2,Aqe,1,5,"line",1),v()),2&e&&(C(1),y("ngForOf",i.getXTicks()),C(1),y("ngForOf",i.getYTicks()))},dependencies:[dn],styles:["[_nghost-%COMP%] {\n        display: flex;\n        overflow: hidden;\n      }\n\n      svg[_ngcontent-%COMP%] {\n        height: 100%;\n        width: 100%;\n      }\n\n      line[_ngcontent-%COMP%] {\n        stroke: #ccc;\n        stroke-width: 1px;\n      }\n\n      .zero[_ngcontent-%COMP%] {\n        stroke: #aaa;\n        stroke-width: 1.5px;\n      }"],changeDetection:0}),n})(),Pqe=["seriesView"],Rqe=["xAxis"],Oqe=["yAxis"],kqe=["chartEl"];function Fqe(n,t){if(1&n&&O(0,"line-chart-grid-view",16),2&n){let e=S();y("viewExtent",e.viewBox)("xScale",e.xScale)("yScale",e.yScale)("xGridCount",e.X_GRID_COUNT)("yGridCount",e.Y_GRID_COUNT)("domDim",e.domDimensions.main)}}function Nqe(n,t){1&n&&(In(),O(0,"svg",null,17))}function Lqe(n,t){1&n&&O(0,"canvas",null,17)}function Bqe(n,t){if(1&n&&(sn(0),E(1,Nqe,2,0,"svg",5),E(2,Lqe,2,0,"canvas",5),an()),2&n){let e=S();C(1),y("ngIf",e.getRendererType()===e.RendererType.SVG),C(1),y("ngIf",e.getRendererType()===e.RendererType.WEBGL)}}function Vqe(n,t){if(1&n){let e=Pe();_(0,"line-chart-interactive-view",18),P("onViewExtentChange",function(r){return oe(e),se(S().onViewBoxChanged(r))})("onViewExtentReset",function(){return oe(e),se(S().viewBoxReset())})("onInteractionStateChange",function(r){return oe(e),se(S().onInteractionStateChange(r))}),v()}if(2&n){let e=S(),i=$e(1);y("seriesData",e.seriesData)("seriesMetadataMap",e.seriesMetadataMap)("viewExtent",e.viewBox)("xScale",e.xScale)("yScale",e.yScale)("tooltipOriginEl",i)("domDim",e.domDimensions.main)("tooltipTemplate",e.tooltipTemplate)}}var Hqe=function(n,t,e,i){return{xScale:n,yScale:t,domDimension:e,viewExtent:i}};function Uqe(n,t){if(1&n&&(_(0,"div",19),Ni(1,20),v()),2&n){let e=S();C(1),y("ngTemplateOutlet",e.customVisTemplate)("ngTemplateOutletContext",K3(2,Hqe,e.xScale,e.yScale,e.domDimensions.main,e.viewBox))}}function zqe(n,t){if(1&n){let e=Pe();_(0,"line-chart-axis",21),P("onViewExtentChange",function(r){return oe(e),se(S().onViewBoxChangedFromAxis(r,"y"))}),v()}if(2&n){let e=S();y("axisExtent",e.viewBox.y)("customFormatter",e.customYFormatter)("domDim",e.domDimensions.yAxis)("gridCount",e.Y_GRID_COUNT)("scale",e.yScale)}}function jqe(n,t){if(1&n){let e=Pe();_(0,"line-chart-axis",22),P("onViewExtentChange",function(r){return oe(e),se(S().onViewBoxChangedFromAxis(r,"x"))}),v()}if(2&n){let e=S();y("axisExtent",e.viewBox.x)("customFormatter",e.customXFormatter)("domDim",e.domDimensions.xAxis)("gridCount",e.X_GRID_COUNT)("scale",e.xScale)}}function Gqe(n,t){1&n&&(_(0,"div",23),O(1,"span",24),v())}var Wqe=function(n,t,e,i,r){return{xScale:n,yScale:t,domDimension:e,viewExtent:i,interactionState:r}};function qqe(n,t){if(1&n&&(_(0,"div",25,26),Ni(2,20),v()),2&n){let e=S();C(2),y("ngTemplateOutlet",e.customChartOverlayTemplate)("ngTemplateOutletContext",Z3(2,Wqe,e.xScale,e.yScale,e.domDimensions.main,e.viewBox,e.interactionState))}}var Yqe=function(n,t){return{container:!0,"dark-mode":n,"line-only-mode":t,"line-chart":!0}},RG={x:[0,1],y:[0,1]},jk=(()=>{class n{constructor(e){this.changeDetector=e,this.RendererType=dr,this.useDarkMode=!1,this.preferredRendererType=dr.WEBGL,this.xScaleType=Nr.LINEAR,this.yScaleType=Nr.LINEAR,this.lineOnly=!1,this.viewBoxChanged=new G,this.onViewBoxOverridden=new Lf(1),this.ignoreYOutliers=!1,this.Y_GRID_COUNT=6,this.X_GRID_COUNT=10,this.xScale=ou(this.xScaleType),this.yScale=ou(this.xScaleType),this.viewBox=RG,this.domDimensions={main:{width:0,height:0},xAxis:{width:0,height:0},yAxis:{width:0,height:0}},this.showChartRendererElement=!0,this.interactionState=Gr.NONE,this.lineChart=null,this.isDataUpdated=!1,this.isMetadataUpdated=!1,this.isFixedViewBoxUpdated=!1,this.isViewBoxOverridden=!1,this.useDarkModeUpdated=!1,this.isViewBoxChanged=!0,this.scaleUpdated=!0,this.isRenderingContextLost=!1}ngOnInit(){this.onViewBoxOverridden.next(this.isViewBoxOverridden)}ngOnChanges(e){e.xScaleType&&(this.xScale=ou(this.xScaleType),this.scaleUpdated=!0),e.yScaleType&&(this.yScale=ou(this.yScaleType),this.scaleUpdated=!0),e.seriesData&&(this.isDataUpdated=!0),e.fixedViewBox&&(this.isFixedViewBoxUpdated=!0),e.seriesMetadataMap&&(this.isMetadataUpdated=!0),e.useDarkMode&&(this.useDarkModeUpdated=!0),this.scaleUpdated&&this.setIsViewBoxOverridden(!1),this.isViewBoxChanged=this.isViewBoxChanged||this.scaleUpdated||!this.isViewBoxOverridden&&this.shouldUpdateDefaultViewBox(e),this.updateLineChart()}ngAfterViewInit(){this.initializeChart(),this.updateLineChart(),this.changeDetector.detectChanges()}recoverRendererIfNeeded(){!this.isRenderingContextLost||this.disableUpdate||(this.showChartRendererElement=!1,this.changeDetector.detectChanges(),this.showChartRendererElement=!0,this.changeDetector.detectChanges(),this.initializeChart(),this.scaleUpdated=!0,this.isMetadataUpdated=!0,this.isDataUpdated=!0,this.useDarkModeUpdated=!0,this.isFixedViewBoxUpdated=!0,this.isViewBoxChanged=!0,this.isRenderingContextLost=!1)}onViewResize(){!this.lineChart||(this.readAndUpdateDomDimensions(),this.lineChart.resize(this.domDimensions.main),this.changeDetector.detectChanges())}shouldUpdateDefaultViewBox(e){if(e.xScaleType||e.yScaleType||e.ignoreYOutliers||e.seriesData)return!0;let r=e.seriesMetadataMap;if(r){let o=r.previousValue;if(Object.keys(this.seriesMetadataMap).length!==Object.keys(o??{}).length)return!0;for(let[s,a]of Object.entries(this.seriesMetadataMap)){let l=o&&o[s];if(!l||a.visible!==l.visible)return!0}}return!1}onContextLost(){this.isRenderingContextLost=!0,this.lineChart&&(this.lineChart.dispose(),this.lineChart=null)}triggerContextLostForTest(){this.onContextLost()}getLineChartForTest(){return this.lineChart}initializeChart(){this.lineChart&&this.lineChart.dispose();let e=this.getRendererType(),i={onDrawEnd:()=>{},onContextLost:this.onContextLost.bind(this)},r=null;switch(this.readAndUpdateDomDimensions(),e){case dr.SVG:r={type:dr.SVG,container:this.chartEl.nativeElement,callbacks:i,domDimension:this.domDimensions.main,useDarkMode:this.useDarkMode};break;case dr.WEBGL:r={type:dr.WEBGL,container:this.chartEl.nativeElement,devicePixelRatio:window.devicePixelRatio,callbacks:i,domDimension:this.domDimensions.main,useDarkMode:this.useDarkMode};break;default:throw new Error(`<line-chart> does not yet support rendererType: ${e}`)}let s=e!==dr.SVG&&su_isOffscreenCanvasSupported()?Jg:Uk;this.lineChart=new s(r)}ngOnDestroy(){this.lineChart&&this.lineChart.dispose()}getRendererType(){return function(n){switch(n){case dr.SVG:return dr.SVG;case dr.WEBGL:return su_isWebGl2Supported()?dr.WEBGL:dr.SVG;default:throw new Error(`Unknown rendererType: ${n}`)}}(this.preferredRendererType)}readAndUpdateDomDimensions(){this.domDimensions={main:{width:this.seriesView.nativeElement.clientWidth,height:this.seriesView.nativeElement.clientHeight},xAxis:{width:this.xAxis.nativeElement.clientWidth,height:this.xAxis.nativeElement.clientHeight},yAxis:{width:this.yAxis.nativeElement.clientWidth,height:this.yAxis.nativeElement.clientHeight}}}updateLineChart(){if(this.recoverRendererIfNeeded(),this.lineChart&&!this.disableUpdate){if(this.scaleUpdated&&(this.scaleUpdated=!1,this.lineChart.setXScaleType(this.xScaleType),this.lineChart.setYScaleType(this.yScaleType)),this.isMetadataUpdated&&(this.isMetadataUpdated=!1,this.lineChart.setMetadata(this.seriesMetadataMap)),this.isDataUpdated&&(this.isDataUpdated=!1,this.lineChart.setData(this.seriesData)),this.useDarkModeUpdated&&(this.useDarkModeUpdated=!1,this.lineChart.setUseDarkMode(this.useDarkMode)),!this.isViewBoxOverridden&&this.fixedViewBox)this.viewBox=this.fixedViewBox;else if(!this.isViewBoxOverridden&&this.isViewBoxChanged){let i=function(n,t,e,i,r){let o=null,s=null,a=[];for(let{id:d,points:p}of n){let h=t[d];if(h&&!h.aux&&h.visible)for(let f=0;f<p.length;f++){let{x:m,y:x}=p[f];i(m)&&(o=null===o||m<o?m:o,s=null===s||m>s?m:s),r(x)&&a.push(x)}}a.sort(uc);let c=a[0],u=a[a.length-1];return e&&a.length>2&&(c=a[Math.ceil(.05*(a.length-1))],u=a[Math.floor(.95*(a.length-1))]),{x:null!==o&&null!==s?[o,s]:void 0,y:void 0!==c&&void 0!==u?[c,u]:void 0}}(this.seriesData,this.seriesMetadataMap,this.ignoreYOutliers,this.xScale.isSafeNumber,this.yScale.isSafeNumber);this.viewBox={x:this.xScale.niceDomain(i.x??RG.x),y:this.yScale.niceDomain(i.y??RG.y)}}(this.isFixedViewBoxUpdated||this.isViewBoxChanged)&&(this.isFixedViewBoxUpdated=!1,this.isViewBoxChanged=!1,this.lineChart.setViewBox(this.viewBox),this.changeDetector.detectChanges())}}onViewBoxChanged({dataExtent:e}){this.setIsViewBoxOverridden(!0),this.isViewBoxChanged=!0,this.viewBox=e,this.updateLineChart(),this.viewBoxChanged.emit(e)}viewBoxReset(){this.setIsViewBoxOverridden(!1),this.isViewBoxChanged=!0,this.updateLineChart(),this.viewBoxChanged.emit(this.viewBox)}setIsViewBoxOverridden(e){let i=this.isViewBoxOverridden;this.isViewBoxOverridden=e,i!==e&&this.onViewBoxOverridden.next(e)}onInteractionStateChange(e){this.interactionState=e}getIsViewBoxOverridden(){return this.onViewBoxOverridden}onViewBoxChangedFromAxis(e,i){let r={...this.viewBox,[i]:e};this.onViewBoxChanged({dataExtent:r})}}return n.\u0275fac=function(e){return new(e||n)(M(nn))},n.\u0275cmp=R({type:n,selectors:[["line-chart"]],viewQuery:function(e,i){if(1&e&&(ot(Pqe,7,Re),ot(Rqe,7,Re),ot(Oqe,7,Re),ot(kqe,5,Re)),2&e){let r;Ne(r=Le())&&(i.seriesView=r.first),Ne(r=Le())&&(i.xAxis=r.first),Ne(r=Le())&&(i.yAxis=r.first),Ne(r=Le())&&(i.chartEl=r.first)}},inputs:{customVisTemplate:"customVisTemplate",customChartOverlayTemplate:"customChartOverlayTemplate",useDarkMode:"useDarkMode",preferredRendererType:"preferredRendererType",seriesData:"seriesData",fixedViewBox:"fixedViewBox",seriesMetadataMap:"seriesMetadataMap",xScaleType:"xScaleType",yScaleType:"yScaleType",customXFormatter:"customXFormatter",customYFormatter:"customYFormatter",tooltipTemplate:"tooltipTemplate",lineOnly:"lineOnly",disableUpdate:"disableUpdate",ignoreYOutliers:"ignoreYOutliers"},outputs:{viewBoxChanged:"viewBoxChanged"},features:[Ft],decls:16,vars:13,consts:[["detectResize","","cdkOverlayOrigin","",3,"ngClass","resizeEventDebouncePeriodInMs","onResize"],["overlayTarget","cdkOverlayOrigin"],[1,"series-view"],["seriesView",""],[3,"viewExtent","xScale","yScale","xGridCount","yGridCount","domDim",4,"ngIf"],[4,"ngIf"],[3,"seriesData","seriesMetadataMap","viewExtent","xScale","yScale","tooltipOriginEl","domDim","tooltipTemplate","onViewExtentChange","onViewExtentReset","onInteractionStateChange",4,"ngIf"],["class","custom-vis",4,"ngIf"],[1,"y-axis"],["yAxis",""],["axis","y",3,"axisExtent","customFormatter","domDim","gridCount","scale","onViewExtentChange",4,"ngIf"],[1,"x-axis"],["xAxis",""],["axis","x",3,"axisExtent","customFormatter","domDim","gridCount","scale","onViewExtentChange",4,"ngIf"],["class","dot",4,"ngIf"],["class","custom-vis custom-chart-overlay-vis",4,"ngIf"],[3,"viewExtent","xScale","yScale","xGridCount","yGridCount","domDim"],["chartEl",""],[3,"seriesData","seriesMetadataMap","viewExtent","xScale","yScale","tooltipOriginEl","domDim","tooltipTemplate","onViewExtentChange","onViewExtentReset","onInteractionStateChange"],[1,"custom-vis"],[3,"ngTemplateOutlet","ngTemplateOutletContext"],["axis","y",3,"axisExtent","customFormatter","domDim","gridCount","scale","onViewExtentChange"],["axis","x",3,"axisExtent","customFormatter","domDim","gridCount","scale","onViewExtentChange"],[1,"dot"],[1,"rect"],[1,"custom-vis","custom-chart-overlay-vis"],["customChartOverlay",""]],template:function(e,i){1&e&&(_(0,"div",0,1),P("onResize",function(){return i.onViewResize()}),_(2,"div",2,3),E(4,Fqe,1,6,"line-chart-grid-view",4),E(5,Bqe,3,2,"ng-container",5),E(6,Vqe,1,8,"line-chart-interactive-view",6),E(7,Uqe,2,7,"div",7),v(),_(8,"div",8,9),E(10,zqe,1,5,"line-chart-axis",10),v(),_(11,"div",11,12),E(13,jqe,1,5,"line-chart-axis",13),v(),E(14,Gqe,2,0,"div",14),E(15,qqe,3,8,"div",15),v()),2&e&&(y("ngClass",Qr(10,Yqe,i.useDarkMode,i.lineOnly))("resizeEventDebouncePeriodInMs",0),C(4),y("ngIf",!i.lineOnly),C(1),y("ngIf",i.showChartRendererElement),C(1),y("ngIf",!i.lineOnly),C(1),y("ngIf",i.customVisTemplate),C(3),y("ngIf",!i.lineOnly),C(3),y("ngIf",!i.lineOnly),C(1),y("ngIf",!i.lineOnly),C(1),y("ngIf",i.customChartOverlayTemplate))},dependencies:[Fn,Be,os,ig,ope,ape,lpe,hg],styles:['[_nghost-%COMP%]{contain:strict;display:inline-block}[_nghost-%COMP%]     .line-chart:has(.horizontal-prospective-area:hover) .x-axis .extent-edit-button{visibility:visible}[_nghost-%COMP%]   .custom-vis[_ngcontent-%COMP%]{pointer-events:none}.container[_ngcontent-%COMP%]{background:inherit;display:grid;height:100%;overflow:hidden;width:100%;grid-template-areas:"yaxis series" "dot xaxis" ". customChartOverlay";grid-template-columns:50px 1fr;grid-auto-rows:1fr 30px 0px}.container.dark-mode[_ngcontent-%COMP%]{color:#fff}.container.line-only-mode[_ngcontent-%COMP%]{grid-template-columns:0 1fr;grid-auto-rows:1fr 0}.series-view[_ngcontent-%COMP%]{grid-area:series;position:relative;overflow:hidden}.series-view[_ngcontent-%COMP%]   .custom-vis[_ngcontent-%COMP%], .series-view[_ngcontent-%COMP%]   canvas[_ngcontent-%COMP%], .series-view[_ngcontent-%COMP%]   svg[_ngcontent-%COMP%], .series-view[_ngcontent-%COMP%]   line-chart-grid-view[_ngcontent-%COMP%], .series-view[_ngcontent-%COMP%]   line-chart-interactive-view[_ngcontent-%COMP%]{height:100%;left:0;position:absolute;top:0;width:100%}.x-axis[_ngcontent-%COMP%]   .custom-vis[_ngcontent-%COMP%], .y-axis[_ngcontent-%COMP%]   .custom-vis[_ngcontent-%COMP%]{height:100%;left:0;overflow:hidden;position:absolute;top:0;width:100%;-webkit-mask-image:linear-gradient(to right, rgba(0, 0, 0, 0) 0%, #000 10%, #000 90%, rgba(0, 0, 0, 0) 100%);mask-image:linear-gradient(to right, rgba(0, 0, 0, 0) 0%, #000 10%, #000 90%, rgba(0, 0, 0, 0) 100%)}.x-axis[_ngcontent-%COMP%]   line-chart-axis[_ngcontent-%COMP%], .y-axis[_ngcontent-%COMP%]   line-chart-axis[_ngcontent-%COMP%]{height:100%}.x-axis[_ngcontent-%COMP%]{grid-area:xaxis;position:relative}.y-axis[_ngcontent-%COMP%]{grid-area:yaxis}.dot[_ngcontent-%COMP%]{align-items:flex-start;display:flex;grid-area:dot;justify-content:flex-end}.dot[_ngcontent-%COMP%]   .rect[_ngcontent-%COMP%]{height:1px;width:1px;background-color:#aaa}.custom-chart-overlay-vis[_ngcontent-%COMP%]{grid-area:customChartOverlay;grid-row-end:2;grid-row-start:1}'],changeDetection:0}),n})();function Qqe(n,t){if(1&n&&O(0,"mat-icon",10),2&n){let e=S(2).$implicit,i=S();y("ngClass",e.type===i.sortingInfo.header?"show":"show-on-hover")}}function Kqe(n,t){if(1&n&&O(0,"mat-icon",11),2&n){let e=S(2).$implicit,i=S();y("ngClass",e.type===i.sortingInfo.header?"show":"show-on-hover")}}function Zqe(n,t){if(1&n){let e=Pe();_(0,"th",4),P("click",function(){oe(e);let r=S().$implicit;return se(S().headerClicked(r.type))}),_(1,"div",5),P("dragstart",function(){oe(e);let r=S().$implicit;return se(S().dragStart(r))})("dragend",function(){return oe(e),se(S(2).dragEnd())})("dragenter",function(){oe(e);let r=S().$implicit;return se(S().dragEnter(r))}),O(2,"tb-data-table-header",6),_(3,"div",7),E(4,Qqe,1,1,"mat-icon",8),E(5,Kqe,1,1,"mat-icon",9),v()()()}if(2&n){let e=S().$implicit,i=S();C(1),y("draggable",i.columnCustomizationEnabled)("ngClass",i.getHeaderHighlightStyle(e.type)),C(1),y("header",e),C(2),y("ngIf",i.sortingInfo.order===i.SortingOrder.ASCENDING||e.type!==i.sortingInfo.header),C(1),y("ngIf",i.sortingInfo.order===i.SortingOrder.DESCENDING&&e.type===i.sortingInfo.header)}}function Jqe(n,t){if(1&n&&(sn(0),E(1,Zqe,6,5,"th",3),an()),2&n){let e=t.$implicit,i=S();C(1),y("ngIf",i.showColumn(e))}}function $qe(n,t){1&n&&Ni(0)}var cpe=function(n){return{$implicit:n}};function eYe(n,t){if(1&n&&(_(0,"div",18),E(1,$qe,1,0,"ng-container",19),A(2),v()),2&n){let e=S(2).$implicit,i=S().$implicit,r=S(),o=$e(9);C(1),y("ngTemplateOutlet",o)("ngTemplateOutletContext",On(3,cpe,i.VALUE_CHANGE)),C(1),je(" ",r.getFormattedDataForColumn(e.type,i)," ")}}function tYe(n,t){1&n&&Ni(0)}function nYe(n,t){if(1&n&&(_(0,"div",18),E(1,tYe,1,0,"ng-container",19),A(2),v()),2&n){let e=S(2).$implicit,i=S().$implicit,r=S(),o=$e(9);C(1),y("ngTemplateOutlet",o)("ngTemplateOutletContext",On(3,cpe,i.PERCENTAGE_CHANGE)),C(1),je(" ",r.getFormattedDataForColumn(e.type,i)," ")}}function iYe(n,t){if(1&n&&(_(0,"div",20),A(1),v()),2&n){let e=S(2).$implicit,i=S().$implicit,r=S();C(1),je(" ",r.getFormattedDataForColumn(e.type,i)," ")}}function rYe(n,t){if(1&n&&(_(0,"td",15),E(1,eYe,3,5,"div",16),E(2,nYe,3,5,"div",16),E(3,iYe,2,1,"div",17),v()),2&n){let e=S().$implicit,i=S(2);y("ngSwitch",e.type),C(1),y("ngSwitchCase",i.ColumnHeaders.VALUE_CHANGE),C(1),y("ngSwitchCase",i.ColumnHeaders.PERCENTAGE_CHANGE)}}function oYe(n,t){if(1&n&&(sn(0),E(1,rYe,4,3,"td",14),an()),2&n){let e=t.$implicit,i=S(2);C(1),y("ngIf",i.showColumn(e))}}function sYe(n,t){if(1&n&&(sn(0),_(1,"tr",12)(2,"td",13),O(3,"span"),v(),E(4,oYe,2,1,"ng-container",1),v(),an()),2&n){let e=t.$implicit,i=S();C(3),Pt("background-color",e.COLOR),C(1),y("ngForOf",i.headers)}}function aYe(n,t){1&n&&O(0,"mat-icon",23)}function lYe(n,t){1&n&&O(0,"mat-icon",24)}function cYe(n,t){if(1&n&&(E(0,aYe,1,0,"mat-icon",21),E(1,lYe,1,0,"mat-icon",22)),2&n){let e=t.$implicit;y("ngIf",e>=0),C(1),y("ngIf",e<0)}}var Pp=(()=>(function(n){n[n.RIGHT=0]="RIGHT",n[n.LEFT=1]="LEFT"}(Pp||(Pp={})),Pp))(),OG=function(n){n.preventDefault()},upe=(()=>{class n{constructor(){this.sortDataBy=new G,this.orderColumns=new G,this.ColumnHeaders=Kt,this.SortingOrder=xl,this.Side=Pp,this.highlightSide=Pp.RIGHT}ngOnDestroy(){document.removeEventListener("dragover",OG)}getFormattedDataForColumn(e,i){switch(e){case Kt.RUN:return void 0===i.RUN?"":i.RUN;case Kt.VALUE:return void 0===i.VALUE?"":yp.formatShort(i.VALUE);case Kt.STEP:return void 0===i.STEP?"":Md.formatShort(i.STEP);case Kt.TIME:return void 0===i.TIME?"":new Date(i.TIME).toISOString();case Kt.RELATIVE_TIME:return void 0===i.RELATIVE_TIME?"":SS.formatReadable(i.RELATIVE_TIME);case Kt.SMOOTHED:return void 0===i.SMOOTHED?"":yp.formatShort(i.SMOOTHED);case Kt.VALUE_CHANGE:return void 0===i.VALUE_CHANGE?"":yp.formatShort(Math.abs(i.VALUE_CHANGE));case Kt.START_STEP:return void 0===i.START_STEP?"":Md.formatShort(i.START_STEP);case Kt.END_STEP:return void 0===i.END_STEP?"":Md.formatShort(i.END_STEP);case Kt.START_VALUE:return void 0===i.START_VALUE?"":Md.formatShort(i.START_VALUE);case Kt.END_VALUE:return void 0===i.END_VALUE?"":Md.formatShort(i.END_VALUE);case Kt.MIN_VALUE:return void 0===i.MIN_VALUE?"":Md.formatShort(i.MIN_VALUE);case Kt.MAX_VALUE:return void 0===i.MAX_VALUE?"":Md.formatShort(i.MAX_VALUE);case Kt.PERCENTAGE_CHANGE:return void 0===i.PERCENTAGE_CHANGE?"":Math.round(100*i.PERCENTAGE_CHANGE).toString()+"%";default:return""}}headerClicked(e){this.sortDataBy.emit(this.sortingInfo.header!==e||this.sortingInfo.order!==xl.ASCENDING?{header:e,order:xl.ASCENDING}:{header:e,order:xl.DESCENDING})}dragStart(e){this.draggingHeaderType=e.type,document.addEventListener("dragover",OG)}dragEnd(){!this.draggingHeaderType||!this.highlightedColumnType||(this.orderColumns.emit(this.moveHeader(this.getIndexOfHeaderWithType(this.draggingHeaderType),this.getIndexOfHeaderWithType(this.highlightedColumnType))),this.draggingHeaderType=void 0,this.highlightedColumnType=void 0,document.removeEventListener("dragover",OG))}dragEnter(e){!this.draggingHeaderType||(this.highlightSide=this.getIndexOfHeaderWithType(e.type)<this.getIndexOfHeaderWithType(this.draggingHeaderType)?Pp.LEFT:Pp.RIGHT,this.highlightedColumnType=e.type)}moveHeader(e,i){let r=[...this.headers];return r.splice(e,1),r.splice(i,0,this.headers[e]),r}getHeaderHighlightStyle(e){return e!==this.highlightedColumnType?{}:{highlight:!0,"highlight-border-right":this.highlightSide===Pp.RIGHT,"highlight-border-left":this.highlightSide===Pp.LEFT}}showColumn(e){return e.enabled&&(this.smoothingEnabled||e.type!==Kt.SMOOTHED)}getIndexOfHeaderWithType(e){return this.headers.findIndex(i=>e===i.type)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["tb-data-table"]],inputs:{headers:"headers",data:"data",sortingInfo:"sortingInfo",columnCustomizationEnabled:"columnCustomizationEnabled",smoothingEnabled:"smoothingEnabled"},outputs:{sortDataBy:"sortDataBy",orderColumns:"orderColumns"},decls:10,vars:2,consts:[[1,"data-table"],[4,"ngFor","ngForOf"],["arrow",""],[3,"click",4,"ngIf"],[3,"click"],[1,"cell",3,"draggable","ngClass","dragstart","dragend","dragenter"],[3,"header"],[1,"sorting-icon-container"],["svgIcon","arrow_upward_24px",3,"ngClass",4,"ngIf"],["svgIcon","arrow_downward_24px",3,"ngClass",4,"ngIf"],["svgIcon","arrow_upward_24px",3,"ngClass"],["svgIcon","arrow_downward_24px",3,"ngClass"],[1,"row"],[1,"row-circle"],[3,"ngSwitch",4,"ngIf"],[3,"ngSwitch"],["class","cell",4,"ngSwitchCase"],["class","cell extra-right-padding",4,"ngSwitchDefault"],[1,"cell"],[4,"ngTemplateOutlet","ngTemplateOutletContext"],[1,"cell","extra-right-padding"],["svgIcon","arrow_upward_24px",4,"ngIf"],["svgIcon","arrow_downward_24px",4,"ngIf"],["svgIcon","arrow_upward_24px"],["svgIcon","arrow_downward_24px"]],template:function(e,i){1&e&&(_(0,"div")(1,"table",0)(2,"thead")(3,"tr"),O(4,"th"),E(5,Jqe,2,1,"ng-container",1),v()(),_(6,"tbody"),E(7,sYe,5,3,"ng-container",1),v()()(),E(8,cYe,2,2,"ng-template",null,2,qt)),2&e&&(C(5),y("ngForOf",i.headers),C(2),y("ngForOf",i.data))},dependencies:[Fn,dn,Be,os,Cr,Ur,ch,Gt,vR],styles:[".data-table[_ngcontent-%COMP%]{border-spacing:4px;font-size:13px}.data-table[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{background-color:#fff;position:sticky;text-align:left;top:0;vertical-align:bottom}.data-table[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]:hover{cursor:pointer}body.dark-mode[_nghost-%COMP%]   .data-table[_ngcontent-%COMP%]   th[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .data-table[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{background-color:#303030}.data-table[_ngcontent-%COMP%]   .cell[_ngcontent-%COMP%]{align-items:center;display:flex}.data-table[_ngcontent-%COMP%]   .extra-right-padding[_ngcontent-%COMP%]{padding-right:1px}.data-table[_ngcontent-%COMP%]   .row[_ngcontent-%COMP%]{white-space:nowrap}.data-table[_ngcontent-%COMP%]   .row-circle[_ngcontent-%COMP%]{align-items:center;display:inline-flex;height:12px;width:12px}.data-table[_ngcontent-%COMP%]   .row-circle[_ngcontent-%COMP%] > span[_ngcontent-%COMP%]{border-radius:50%;border:1px solid rgba(255,255,255,.4);display:inline-block;height:10px;width:10px}.data-table[_ngcontent-%COMP%]   .cell[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{height:12px;width:12px}.data-table[_ngcontent-%COMP%]   .sorting-icon-container[_ngcontent-%COMP%]{width:12px;height:12px;border-radius:5px}.data-table[_ngcontent-%COMP%]   .show[_ngcontent-%COMP%]{opacity:1}.data-table[_ngcontent-%COMP%]   .show-on-hover[_ngcontent-%COMP%]{opacity:0}.data-table[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]:hover   .show-on-hover[_ngcontent-%COMP%]{opacity:.3}.data-table[_ngcontent-%COMP%]   .highlight[_ngcontent-%COMP%]{background-color:#eee}.data-table[_ngcontent-%COMP%]   .highlight-border-right[_ngcontent-%COMP%]{border-right:2px solid #ff9800}.data-table[_ngcontent-%COMP%]   .highlight-border-left[_ngcontent-%COMP%]{border-left:2px solid #ff9800}"],changeDetection:0}),n})(),ppe=(()=>{class n{constructor(){this.sortDataBy=new G,this.orderColumns=new G}getMinValueInRange(e,i,r,o=!1){let s=this.maybeSmoothedValue(e[i],o);for(let a=i;a<=r;a++)s>this.maybeSmoothedValue(e[a],o)&&(s=this.maybeSmoothedValue(e[a],o));return s}getMaxValueInRange(e,i,r,o=!1){let s=this.maybeSmoothedValue(e[i],o);for(let a=i;a<=r;a++)s<this.maybeSmoothedValue(e[a],o)&&(s=this.maybeSmoothedValue(e[a],o));return s}maybeSmoothedValue(e,i){return i?e.y:e.value}getTimeSelectionTableData(){if(null===this.stepOrLinkedTimeSelection)return[];let e=this.stepOrLinkedTimeSelection.start.step,i=this.stepOrLinkedTimeSelection.end?.step,r=this.dataSeries.filter(o=>{let s=this.chartMetadataMap[o.id];return s&&s.visible&&!Boolean(s.aux)}).map(o=>{let s=this.chartMetadataMap[o.id],a=bE(o.points,e),l=o.points[a],c=null,u=null;null!=i&&(u=bE(o.points,i),c=o.points[u]);let d={id:o.id};d.COLOR=s.color;for(let p of this.columnHeaders)switch(p.type){case Kt.RUN:let h="";s.alias&&(h=`${s.alias.aliasNumber} ${s.alias.aliasText}/`),d.RUN=`${h}${s.displayName}`;continue;case Kt.STEP:d.STEP=l.step;continue;case Kt.VALUE:d.VALUE=l.value;continue;case Kt.RELATIVE_TIME:d.RELATIVE_TIME=l.relativeTimeInMs;continue;case Kt.SMOOTHED:d.SMOOTHED=l.y;continue;case Kt.VALUE_CHANGE:if(!c)continue;d.VALUE_CHANGE=c.y-l.y;continue;case Kt.START_STEP:d.START_STEP=l.step;continue;case Kt.END_STEP:if(!c)continue;d.END_STEP=c.step;continue;case Kt.START_VALUE:d.START_VALUE=l.y;continue;case Kt.END_VALUE:if(!c)continue;d.END_VALUE=c.y;continue;case Kt.MIN_VALUE:if(!u)continue;d.MIN_VALUE=this.getMinValueInRange(o.points,a,u,!0);continue;case Kt.MAX_VALUE:if(!u)continue;d.MAX_VALUE=this.getMaxValueInRange(o.points,a,u,!0);continue;case Kt.PERCENTAGE_CHANGE:if(!c)continue;d.PERCENTAGE_CHANGE=(c.y-l.y)/l.y;continue;default:continue}return d});return r.sort((o,s)=>{let a=this.getSortableValue(o,this.sortingInfo.header),l=this.getSortableValue(s,this.sortingInfo.header);return a<l?this.sortingInfo.order===xl.ASCENDING?-1:1:a>l?this.sortingInfo.order===xl.ASCENDING?1:-1:0}),r}getSortableValue(e,i){return function(n){return Number.isNaN(n)||"NaN"===n||null==n?-1/0:n}(i===Kt.RUN?this.chartMetadataMap[e.id].displayName:e[i])}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["scalar-card-data-table"]],inputs:{chartMetadataMap:"chartMetadataMap",dataSeries:"dataSeries",stepOrLinkedTimeSelection:"stepOrLinkedTimeSelection",columnHeaders:"columnHeaders",sortingInfo:"sortingInfo",columnCustomizationEnabled:"columnCustomizationEnabled",smoothingEnabled:"smoothingEnabled"},outputs:{sortDataBy:"sortDataBy",orderColumns:"orderColumns"},decls:1,vars:5,consts:[[3,"headers","data","sortingInfo","columnCustomizationEnabled","smoothingEnabled","sortDataBy","orderColumns"]],template:function(e,i){1&e&&(_(0,"tb-data-table",0),P("sortDataBy",function(o){return i.sortDataBy.emit(o)})("orderColumns",function(o){return i.orderColumns.emit(o)}),v()),2&e&&y("headers",i.columnHeaders)("data",i.getTimeSelectionTableData())("sortingInfo",i.sortingInfo)("columnCustomizationEnabled",i.columnCustomizationEnabled)("smoothingEnabled",i.smoothingEnabled)},dependencies:[upe],encapsulation:2,changeDetection:0}),n})();var pYe=["stepSpan"];function hYe(n,t){if(1&n){let e=Pe();_(0,"button",4),P("click",function(){return oe(e),se(S().fobRemoved.emit())}),O(1,"mat-icon",5),v()}}function fYe(n,t){if(1&n){let e=Pe();_(0,"button",4),P("click",function(){return oe(e),se(S().fobRemoved.emit())}),O(1,"mat-icon",6),v()}}var mYe=function(n,t){return{fob:!0,unremovable:n,prospective:t}},hpe=(()=>{class n{constructor(){this.allowRemoval=!0,this.isProspective=!1,this.stepChanged=new G,this.fobRemoved=new G}ngOnChanges(e){e.step&&document.activeElement===this.stepSpan.nativeElement&&this.stepSpan.nativeElement.blur()}validateStep(e){let i=String.fromCharCode(e.which);(" "===e.key||isNaN(Number(i)))&&e.preventDefault()}stepTyped(e){e.preventDefault();let i=e.target.innerText;this.stepChanged.emit(""!==i?Number(i):null)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["card-fob"]],viewQuery:function(e,i){if(1&e&&ot(pYe,7,Re),2&e){let r;Ne(r=Le())&&(i.stepSpan=r.first)}},inputs:{step:"step",allowRemoval:"allowRemoval",isProspective:"isProspective"},outputs:{stepChanged:"stepChanged",fobRemoved:"fobRemoved"},features:[Ft],decls:5,vars:7,consts:[[3,"ngClass"],["contenteditable","","role","textbox","aria-label","Edit step",3,"innerHTML","blur","keypress","keydown.enter","keydown.shift.enter"],["stepSpan",""],["aria-label","Deselect fob",3,"click",4,"ngIf"],["aria-label","Deselect fob",3,"click"],["svgIcon","close_24px"],["svgIcon","keep_24px"]],template:function(e,i){1&e&&(_(0,"div",0)(1,"span",1,2),P("blur",function(o){return i.stepTyped(o)})("keypress",function(o){return i.validateStep(o)})("keydown.enter",function(o){return i.stepTyped(o)})("keydown.shift.enter",function(o){return o.preventDefault()}),v(),E(3,hYe,2,0,"button",3),E(4,fYe,2,0,"button",3),v()),2&e&&(y("ngClass",Qr(4,mYe,!i.allowRemoval,i.isProspective)),C(1),y("innerHTML",i.step,A3),C(2),y("ngIf",i.allowRemoval),C(1),y("ngIf",i.isProspective))},dependencies:[Fn,Be,Gt],styles:["[_nghost-%COMP%]{display:inline-block}.fob[_ngcontent-%COMP%]{display:inline-flex;background-color:#e0e0e0;border-radius:25px;padding:2px 2px 2px 4px;font-size:11px;text-align:center;width:min-content}.fob[_ngcontent-%COMP%] > .prospective[_ngcontent-%COMP%]{padding-top:1px}.fob[_ngcontent-%COMP%]:hover{cursor:grab}.fob[_ngcontent-%COMP%]:hover.prospective{cursor:pointer}.fob[_ngcontent-%COMP%]:active{cursor:grabbing}.fob.unremovable[_ngcontent-%COMP%]{padding:2px 4px}.fob.prospective[_ngcontent-%COMP%]{align-items:center;box-sizing:border-box;border:1px dashed #9e9e9e;font-weight:bold;height:17px}span[_ngcontent-%COMP%]{color:inherit;display:inline-block}body.dark-mode[_nghost-%COMP%]   span[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   span[_ngcontent-%COMP%]{color:#616161}button[_ngcontent-%COMP%]{margin-left:2px;padding:0;border:0;border-radius:50%;font-size:11px;width:11px;height:11px;background-color:inherit;color:inherit}button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{width:100%;height:110%}body.dark-mode[_nghost-%COMP%]   button[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   button[_ngcontent-%COMP%]{color:#616161}button[_ngcontent-%COMP%]:hover{background-color:#9e9e9e;color:#eee;cursor:pointer}body.dark-mode[_nghost-%COMP%]   button[_ngcontent-%COMP%]:hover, body.dark-mode   [_nghost-%COMP%]   button[_ngcontent-%COMP%]:hover{background-color:#616161;color:#e0e0e0}"],changeDetection:0}),n})(),_Ye=["startFobWrapper"],vYe=["endFobWrapper"],yYe=["prospectiveFobWrapper"];function bYe(n,t){1&n&&O(0,"div",7)}function xYe(n,t){if(1&n&&(_(0,"div",3,4),E(2,bYe,1,0,"div",5),O(3,"card-fob",6),v()),2&n){let e=S(2);Pt("transform",e.getCssTranslatePxForProspectiveFob()),C(2),y("ngIf",e.showExtendedLine),C(1),y("ngClass",e.isVertical()?"vertical-fob":"horizontal-fob")("allowRemoval",!1)("isProspective",!0)("step",e.prospectiveStep)}}function CYe(n,t){if(1&n){let e=Pe();sn(0),E(1,xYe,4,7,"div",1),_(2,"div",2),P("mousemove",function(r){return oe(e),se(S().mouseOverProspectiveFobArea(r))})("click",function(r){return oe(e),se(S().prospectiveFobClicked(r))})("mouseleave",function(){return oe(e),se(S().onProspectiveAreaMouseLeave())}),v(),an()}if(2&n){let e=S();C(1),y("ngIf",null!==e.prospectiveStep),C(1),y("ngClass",e.isVertical()?"vertical-prospective-area":"horizontal-prospective-area")}}function MYe(n,t){if(1&n){let e=Pe();_(0,"div",11),P("mousedown",function(r){oe(e);let o=S(2);return se(o.startDrag(o.Fob.START,o.TimeSelectionAffordance.EXTENDED_LINE,r))}),v()}}function wYe(n,t){if(1&n){let e=Pe();_(0,"div",3,8),E(2,MYe,1,0,"div",9),_(3,"card-fob",10),P("mousedown",function(r){oe(e);let o=S();return se(o.startDrag(o.Fob.START,o.TimeSelectionAffordance.FOB,r))})("stepChanged",function(r){oe(e);let o=S();return se(o.stepTyped(o.Fob.START,r))})("fobRemoved",function(){oe(e);let r=S();return se(r.onFobRemoved(r.Fob.START))}),v()()}if(2&n){let e=S();Pt("transform",e.getCssTranslatePxForStartFob()),C(2),y("ngIf",e.showExtendedLine),C(1),y("ngClass",e.isVertical()?"vertical-fob":"horizontal-fob")("step",e.timeSelection.start.step)}}function SYe(n,t){if(1&n){let e=Pe();_(0,"div",11),P("mousedown",function(r){oe(e);let o=S(2);return se(o.startDrag(o.Fob.END,o.TimeSelectionAffordance.EXTENDED_LINE,r))}),v()}}function EYe(n,t){if(1&n){let e=Pe();_(0,"div",3,12),E(2,SYe,1,0,"div",9),_(3,"card-fob",13),P("mousedown",function(r){oe(e);let o=S();return se(o.startDrag(o.Fob.END,o.TimeSelectionAffordance.FOB,r))})("stepChanged",function(r){oe(e);let o=S();return se(o.stepTyped(o.Fob.END,r))})("fobRemoved",function(){oe(e);let r=S();return se(r.onFobRemoved(r.Fob.END))}),v()()}if(2&n){let e=S();Pt("transform",e.getCssTranslatePxForEndFob()),C(2),y("ngIf",e.showExtendedLine),C(1),y("ngClass",e.isVertical()?"vertical-fob":"horizontal-fob")("step",e.timeSelection.end.step)}}var Xr=(()=>(function(n){n[n.NONE=0]="NONE",n[n.START=1]="START",n[n.END=2]="END"}(Xr||(Xr={})),Xr))(),TYe={start:Xr.START,end:Xr.END},Gk=(()=>{class n{constructor(e){this.root=e,this.showExtendedLine=!1,this.isProspectiveFobFeatureEnabled=!1,this.prospectiveStep=null,this.prospectiveStepAxisPosition=null,this.onTimeSelectionChanged=new G,this.onTimeSelectionToggled=new G,this.onProspectiveStepChanged=new G,this.hasFobMoved=!1,this.currentDraggingFob=Xr.NONE,this.affordance=cs.NONE,this.mouseListener=this.mouseMove.bind(this),this.stopListener=this.stopDrag.bind(this),this.Fob=Xr,this.TimeSelectionAffordance=cs}getCssTranslatePxForStartFob(){return this.axisDirection===pa.VERTICAL?`translate(0px, ${this.startStepAxisPosition}px)`:`translate(${this.startStepAxisPosition}px, 0px)`}getCssTranslatePxForEndFob(){return null===this.endStepAxisPosition?"":this.axisDirection===pa.VERTICAL?`translate(0px, ${this.endStepAxisPosition}px)`:`translate(${this.endStepAxisPosition}px, 0px)`}getCssTranslatePxForProspectiveFob(){return null===this.prospectiveStep?"":this.axisDirection===pa.VERTICAL?`translate(0px, ${this.prospectiveStepAxisPosition}px)`:`translate(${this.prospectiveStepAxisPosition}px, 0px)`}stopEventPropagation(e){e.stopPropagation(),e.preventDefault()}startDrag(e,i,r){i!==cs.FOB&&this.stopEventPropagation(r),document.addEventListener("mousemove",this.mouseListener),document.addEventListener("mouseup",this.stopListener),this.currentDraggingFob=e,this.affordance=i}stopDrag(){document.removeEventListener("mousemove",this.mouseListener),document.removeEventListener("mouseup",this.stopListener),this.currentDraggingFob=Xr.NONE,this.hasFobMoved&&this.timeSelection&&this.onTimeSelectionChanged.emit({timeSelection:this.timeSelection,affordance:this.affordance}),this.affordance=cs.NONE,this.hasFobMoved=!1}isVertical(){return this.axisDirection===pa.VERTICAL}shouldSwapFobs(e){return!(!this.timeSelection||!this.timeSelection.end)&&(this.currentDraggingFob===Xr.END?e<this.timeSelection.start.step:this.currentDraggingFob===Xr.START&&e>this.timeSelection.end.step)}getNewTimeSelection(e,i){let r={...i};if(!this.timeSelection)return r;if(!this.timeSelection.end)return r.start={step:e},r;if(this.shouldSwapFobs(e)){let[o,s]=this.currentDraggingFob===Xr.END?["end","start"]:["start","end"];return this.currentDraggingFob=TYe[s],r[o]=this.timeSelection[s],r[s]={step:e},r}return this.currentDraggingFob===Xr.END?(r.end={step:e},r):(r.start={step:e},r)}getNewStepFromMouseEvent(e){let i=null,r=this.getMousePositionFromEvent(e),o=this.axisDirection===pa.VERTICAL?e.movementY:e.movementX;return this.isMovingHigher(r,o)?i=this.cardFobHelper.getStepHigherThanAxisPosition(r):this.isMovingLower(r,o)&&(i=this.cardFobHelper.getStepLowerThanAxisPosition(r)),null===i?null:i}mouseMove(e){if(this.currentDraggingFob===Xr.NONE)return;let i=this.getNewStepFromMouseEvent(e);if(null===i||!this.timeSelection)return;let r=this.getNewTimeSelection(i,this.timeSelection);this.onTimeSelectionChanged.emit({timeSelection:r}),this.hasFobMoved=!0}mouseOverProspectiveFobArea(e){if(null!=this.timeSelection?.end)return;let i=this.getNewStepFromMouseEvent(e);null!==i&&this.onProspectiveStepChanged.emit(i)}isMovingLower(e,i){if(this.currentDraggingFob===Xr.NONE&&null===this.prospectiveStep)return!0;let r=this.getCurrentFobStep();return void 0!==r&&e<this.getDraggingFobCenter()&&i<0&&r>this.lowestStep}isMovingHigher(e,i){if(this.currentDraggingFob===Xr.NONE&&null===this.prospectiveStep)return!0;let r=this.getCurrentFobStep();return void 0!==r&&e>this.getDraggingFobCenter()&&i>0&&r<this.highestStep}getDraggingFobCenter(){let e=this.getCurrentFob()?.nativeElement;if(!e)return 0;let i=e.getBoundingClientRect().top,r=e.getBoundingClientRect().left;return this.axisDirection===pa.VERTICAL?i-this.root.nativeElement.getBoundingClientRect().top:r-this.root.nativeElement.getBoundingClientRect().left}getCurrentFob(){switch(this.currentDraggingFob){case Xr.START:return this.startFobWrapper;case Xr.END:return this.endFobWrapper;case Xr.NONE:return this.prospectiveFobWrapper}}getCurrentFobStep(){switch(this.currentDraggingFob){case Xr.START:return this.timeSelection?.start.step;case Xr.END:return this.timeSelection?.end?.step;case Xr.NONE:return this.prospectiveStep??void 0}}getMousePositionFromEvent(e){return this.axisDirection===pa.VERTICAL?e.clientY-this.root.nativeElement.getBoundingClientRect().top:e.clientX-this.root.nativeElement.getBoundingClientRect().left}stepTyped(e,i){if(null===i)return void(null!==this.timeSelection.end&&this.onFobRemoved(e));let r={...this.timeSelection};e===Xr.START?r.start={step:i}:e===Xr.END&&(r.end={step:i}),null!==r.end&&r.start.step>r.end.step&&(r={start:r.end,end:r.start}),this.onTimeSelectionChanged.emit({timeSelection:r,affordance:cs.FOB_TEXT})}prospectiveFobClicked(e){e.stopPropagation();let i=this.getProspectiveTimeSelection();!i||(this.onTimeSelectionChanged.emit({affordance:cs.FOB_ADDED,timeSelection:i}),this.onProspectiveStepChanged.emit(null))}getProspectiveTimeSelection(){if(this.prospectiveStep)return this.timeSelection?{start:{step:Math.min(this.timeSelection.start.step,this.prospectiveStep)},end:{step:Math.max(this.timeSelection.start.step,this.prospectiveStep)}}:{start:{step:this.prospectiveStep},end:null}}onFobRemoved(e){e!==Xr.END?null===this.timeSelection.end?this.onTimeSelectionToggled.emit():this.onTimeSelectionChanged.emit({affordance:cs.FOB_REMOVED,timeSelection:{start:this.timeSelection.end,end:null}}):this.onTimeSelectionChanged.emit({affordance:cs.FOB_REMOVED,timeSelection:{...this.timeSelection,end:null}})}onProspectiveAreaMouseLeave(){this.onProspectiveStepChanged.emit(null)}}return n.\u0275fac=function(e){return new(e||n)(M(Re))},n.\u0275cmp=R({type:n,selectors:[["card-fob-controller"]],viewQuery:function(e,i){if(1&e&&(ot(_Ye,5),ot(vYe,5),ot(yYe,5)),2&e){let r;Ne(r=Le())&&(i.startFobWrapper=r.first),Ne(r=Le())&&(i.endFobWrapper=r.first),Ne(r=Le())&&(i.prospectiveFobWrapper=r.first)}},inputs:{axisDirection:"axisDirection",timeSelection:"timeSelection",cardFobHelper:"cardFobHelper",startStepAxisPosition:"startStepAxisPosition",endStepAxisPosition:"endStepAxisPosition",highestStep:"highestStep",lowestStep:"lowestStep",showExtendedLine:"showExtendedLine",isProspectiveFobFeatureEnabled:"isProspectiveFobFeatureEnabled",prospectiveStep:"prospectiveStep",prospectiveStepAxisPosition:"prospectiveStepAxisPosition"},outputs:{onTimeSelectionChanged:"onTimeSelectionChanged",onTimeSelectionToggled:"onTimeSelectionToggled",onProspectiveStepChanged:"onProspectiveStepChanged"},decls:4,vars:3,consts:[[4,"ngIf"],["class","time-fob-wrapper",3,"transform",4,"ngIf"],[1,"prospective-fob-area",3,"ngClass","mousemove","click","mouseleave"],[1,"time-fob-wrapper"],["prospectiveFobWrapper",""],["class","extended-line",4,"ngIf"],[3,"ngClass","allowRemoval","isProspective","step"],[1,"extended-line"],["startFobWrapper",""],["class","extended-line",3,"mousedown",4,"ngIf"],[1,"startFob",3,"ngClass","step","mousedown","stepChanged","fobRemoved"],[1,"extended-line",3,"mousedown"],["endFobWrapper",""],[1,"endFob",3,"ngClass","step","mousedown","stepChanged","fobRemoved"]],template:function(e,i){1&e&&(_(0,"div"),E(1,CYe,3,2,"ng-container",0),E(2,wYe,4,5,"div",1),E(3,EYe,4,5,"div",1),v()),2&e&&(C(1),y("ngIf",i.isProspectiveFobFeatureEnabled),C(1),y("ngIf",i.timeSelection),C(1),y("ngIf",i.timeSelection&&i.timeSelection.end))},dependencies:[Fn,Be,hpe],styles:["[_nghost-%COMP%]{pointer-events:all}.time-fob-wrapper[_ngcontent-%COMP%]{display:inline-block;position:absolute;top:0;width:0}.vertical-fob[_ngcontent-%COMP%]{transform:translateY(-50%)}.horizontal-fob[_ngcontent-%COMP%]{transform:translateX(-50%)}.extended-line[_ngcontent-%COMP%]{border-style:dashed;border-width:0 1px;height:calc(100% - 30px)}.extended-line[_ngcontent-%COMP%]:hover{background:linear-gradient(to right, transparent 18px, #ccc 19px, #ccc 21px, transparent 22px);border:0;cursor:ew-resize;margin-left:-20px;padding:0 20px}.horizontal-prospective-area[_ngcontent-%COMP%]{bottom:0;cursor:pointer;position:absolute;height:30px;width:calc(100% - 74px)}.prospective-area[_ngcontent-%COMP%]{display:block}"],changeDetection:0}),n})(),mpe=(()=>{class n{constructor(){this.isProspectiveFobFeatureEnabled=!1,this.disableInteraction=!1,this.onTimeSelectionChanged=new G,this.onTimeSelectionToggled=new G,this.axisDirection=pa.HORIZONTAL,this.cardFobHelper={getStepHigherThanAxisPosition:this.getStepHigherThanAxisPosition.bind(this),getStepLowerThanAxisPosition:this.getStepLowerThanAxisPosition.bind(this)},this.prospectiveStep=null}getAxisPositionFromStartStep(){return this.timeSelection?this.scale.forward(this.minMaxHorizontalViewExtend,[0,this.axisSize],this.timeSelection.start.step):""}getAxisPositionFromEndStep(){return this.timeSelection?.end?this.scale.forward(this.minMaxHorizontalViewExtend,[0,this.axisSize],this.timeSelection?.end.step??this.minMaxStep.maxStep):null}getAxisPositionFromProspectiveStep(){return null===this.prospectiveStep?null:this.scale.forward(this.minMaxHorizontalViewExtend,[0,this.axisSize],this.prospectiveStep)}onProspectiveStepChanged(e){this.prospectiveStep=e}getHighestStep(){return this.minMaxStep.maxStep}getLowestStep(){return this.minMaxStep.minStep}getStepHigherThanAxisPosition(e){return this.getStepAtMousePostion(e)}getStepLowerThanAxisPosition(e){return this.getStepAtMousePostion(e)}getStepAtMousePostion(e){let i=Math.round(this.scale.reverse(this.minMaxHorizontalViewExtend,[0,this.axisSize],e));return i>this.getHighestStep()?this.getHighestStep():i<this.getLowestStep()?this.getLowestStep():i}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["scalar-card-fob-controller"]],inputs:{timeSelection:"timeSelection",scale:"scale",minMaxHorizontalViewExtend:"minMaxHorizontalViewExtend",minMaxStep:"minMaxStep",axisSize:"axisSize",isProspectiveFobFeatureEnabled:"isProspectiveFobFeatureEnabled",disableInteraction:"disableInteraction"},outputs:{onTimeSelectionChanged:"onTimeSelectionChanged",onTimeSelectionToggled:"onTimeSelectionToggled"},decls:1,vars:13,consts:[[3,"axisDirection","timeSelection","startStepAxisPosition","endStepAxisPosition","prospectiveStepAxisPosition","highestStep","lowestStep","prospectiveStep","isProspectiveFobFeatureEnabled","cardFobHelper","showExtendedLine","onProspectiveStepChanged","onTimeSelectionChanged","onTimeSelectionToggled"]],template:function(e,i){1&e&&(_(0,"card-fob-controller",0),P("onProspectiveStepChanged",function(o){return i.onProspectiveStepChanged(o)})("onTimeSelectionChanged",function(o){return i.onTimeSelectionChanged.emit(o)})("onTimeSelectionToggled",function(o){return i.onTimeSelectionToggled.emit(o)}),v()),2&e&&(Pt("pointer-events",i.disableInteraction?"none":"all"),y("axisDirection",i.axisDirection)("timeSelection",i.timeSelection)("startStepAxisPosition",i.getAxisPositionFromStartStep())("endStepAxisPosition",i.getAxisPositionFromEndStep())("prospectiveStepAxisPosition",i.getAxisPositionFromProspectiveStep())("highestStep",i.getHighestStep())("lowestStep",i.getLowestStep())("prospectiveStep",i.prospectiveStep)("isProspectiveFobFeatureEnabled",i.isProspectiveFobFeatureEnabled)("cardFobHelper",i.cardFobHelper)("showExtendedLine",!0))},dependencies:[Gk],styles:["scalar-card-fob-controller .time-fob-wrapper{height:100%}"],changeDetection:0}),n})();function AYe(n,t){1&n&&O(0,"mat-spinner",25)}function IYe(n,t){1&n&&(_(0,"th"),A(1,"Smoothed"),v())}function PYe(n,t){if(1&n&&(sn(0),O(1,"tb-experiment-alias",31),A(2,"/"),an()),2&n){let e=S().$implicit;C(1),y("alias",e.metadata.alias)}}function RYe(n,t){if(1&n&&(_(0,"td"),A(1),v()),2&n){let e=S().$implicit,i=S(2);C(1),je(" ",i.valueFormatter.formatShort(e.dataPoint.y)," ")}}function OYe(n,t){if(1&n&&(sn(0),_(1,"tr",29)(2,"td",30),O(3,"span"),v(),_(4,"td",2),E(5,PYe,3,1,"ng-container",22),A(6),v(),E(7,RYe,2,1,"td",22),_(8,"td"),A(9),v(),_(10,"td"),A(11),v(),_(12,"td"),A(13),B(14,"date"),v(),_(15,"td"),A(16),v()(),an()),2&n){let e=t.$implicit,i=S(2);C(1),et("closest",e.metadata.closest),C(2),Pt("background-color",e.metadata.color),C(2),y("ngIf",e.metadata.alias),C(1),je("",e.metadata.displayName," "),C(1),y("ngIf",i.smoothingEnabled),C(2),yt(i.valueFormatter.formatShort(e.dataPoint.value)),C(2),yt(i.stepFormatter.formatShort(e.dataPoint.step)),C(2),yt(Jf(14,11,e.dataPoint.wallTime,"short")),C(3),je(" ",i.relativeXFormatter.formatReadable(e.dataPoint.relativeTimeInMs)," ")}}function kYe(n,t){if(1&n&&(_(0,"table",26)(1,"thead")(2,"tr"),O(3,"th",27),_(4,"th"),A(5,"Run"),v(),E(6,IYe,2,0,"th",22),_(7,"th"),A(8,"Value"),v(),_(9,"th"),A(10,"Step"),v(),_(11,"th"),A(12,"Time"),v(),_(13,"th"),A(14,"Relative"),v()()(),_(15,"tbody"),E(16,OYe,17,14,"ng-container",28),v()()),2&n){let e=t.data,i=t.cursorLocationInDataCoord,r=t.cursorLocation,o=S();C(6),y("ngIf",o.smoothingEnabled),C(10),y("ngForOf",o.getCursorAwareTooltipData(e,i,r))("ngForTrackBy",o.trackByTooltipDatum)}}function FYe(n,t){if(1&n){let e=Pe();sn(0),_(1,"div",32)(2,"scalar-card-data-table",33),P("sortDataBy",function(r){return oe(e),se(S().sortDataBy(r))})("orderColumns",function(r){return oe(e),se(S().reorderColumnHeaders.emit(r))}),v()(),an()}if(2&n){let e=S();C(2),y("chartMetadataMap",e.chartMetadataMap)("dataSeries",e.dataSeries)("stepOrLinkedTimeSelection",e.stepOrLinkedTimeSelection)("columnHeaders",e.columnHeaders)("sortingInfo",e.sortingInfo)("columnCustomizationEnabled",e.columnCustomizationEnabled)("smoothingEnabled",e.smoothingEnabled)}}var NYe=function(n){return[0,n]},LYe=function(){return{"out-of-selected-time":!0,end:!0,range:!0}};function BYe(n,t){if(1&n&&O(0,"div",34),2&n){let e=S(2),i=e.viewExtent,r=e.domDimension,o=e.xScale,s=S();Pt("left",o.forward(i.x,On(3,NYe,r.width),null==s.stepOrLinkedTimeSelection.end?null:s.stepOrLinkedTimeSelection.end.step)+"px"),y("ngClass",Qp(5,LYe))}}var VYe=function(n){return[n,0]},HYe=function(n){return{"out-of-selected-time":!0,start:!0,range:n}};function UYe(n,t){if(1&n&&(sn(0),O(1,"div",34),E(2,BYe,1,6,"div",35),an()),2&n){let e=S(),i=e.viewExtent,r=e.domDimension,o=e.xScale,s=S();C(1),Pt("right",o.forward(i.x,On(4,VYe,r.width),s.stepOrLinkedTimeSelection.start.step)+"px"),y("ngClass",On(6,HYe,!(null==s.stepOrLinkedTimeSelection.end||!s.stepOrLinkedTimeSelection.end.step))),C(1),y("ngIf",null==s.stepOrLinkedTimeSelection.end?null:s.stepOrLinkedTimeSelection.end.step)}}function zYe(n,t){1&n&&E(0,UYe,3,8,"ng-container",22),2&n&&y("ngIf",S().stepOrLinkedTimeSelection)}function jYe(n,t){if(1&n){let e=Pe();sn(0),_(1,"scalar-card-fob-controller",36),P("onTimeSelectionChanged",function(r){return oe(e),se(S(2).onTimeSelectionChanged.emit(r))})("onTimeSelectionToggled",function(){return oe(e),se(S(2).onFobRemoved())}),v(),an()}if(2&n){let e=S(),i=e.interactionState,r=e.xScale,o=e.viewExtent,s=e.domDimension,a=S();C(1),y("disableInteraction","NONE"!==i)("timeSelection",a.stepOrLinkedTimeSelection)("scale",r)("minMaxHorizontalViewExtend",o.x)("minMaxStep",a.minMaxStep)("axisSize",s.width)("isProspectiveFobFeatureEnabled",a.isProspectiveFobFeatureEnabled)}}function GYe(n,t){1&n&&E(0,jYe,2,7,"ng-container",22),2&n&&y("ngIf",S().showFobController())}var gpe=(()=>{class n{constructor(e,i){this.ref=e,this.dialog=i,this.DataLoadState=Oe,this.RendererType=dr,this.ScaleType=Nr,this.isProspectiveFobFeatureEnabled=!1,this.onFullSizeToggle=new G,this.onPinClicked=new G,this.onTimeSelectionChanged=new G,this.onStepSelectorToggled=new G,this.onDataTableSorting=new G,this.reorderColumnHeaders=new G,this.onLineChartZoom=new G,this.sortingInfo={header:Kt.RUN,order:xl.ASCENDING},this.yScaleType=Nr.LINEAR,this.isViewBoxOverridden=!1,this.relativeXFormatter=SS,this.valueFormatter=yp,this.stepFormatter=Md}toggleYScaleType(){this.yScaleType=this.yScaleType===Nr.LINEAR?Nr.LOG10:Nr.LINEAR}sortDataBy(e){this.sortingInfo=e,this.onDataTableSorting.emit(e)}resetDomain(){this.lineChart&&this.lineChart.viewBoxReset()}trackByTooltipDatum(e,i){return i.id}getCustomXFormatter(){switch(this.xAxisType){case Ji.RELATIVE:return SS;case Ji.STEP:return jce;default:return}}getCursorAwareTooltipData(e,i,r){let o=e.map(l=>({...l,metadata:{...l.metadata,closest:!1,distToCursorPixels:Math.hypot(l.domPoint.x-r.x,l.domPoint.y-r.y),distToCursorX:l.dataPoint.x-i.x,distToCursorY:l.dataPoint.y-i.y}})),s=1/0,a=0;for(let l=0;l<o.length;l++)s>o[l].metadata.distToCursorPixels&&(s=o[l].metadata.distToCursorPixels,a=l);switch(o.length&&(o[a].metadata.closest=!0),this.tooltipSort){case Oo.ASCENDING:return o.sort((l,c)=>l.dataPoint.y-c.dataPoint.y);case Oo.DESCENDING:return o.sort((l,c)=>c.dataPoint.y-l.dataPoint.y);case Oo.NEAREST:return o.sort((l,c)=>l.metadata.distToCursorPixels-c.metadata.distToCursorPixels);case Oo.NEAREST_Y:return o.sort((l,c)=>l.metadata.distToCursorY-c.metadata.distToCursorY);case Oo.DEFAULT:case Oo.ALPHABETICAL:return o.sort((l,c)=>l.metadata.displayName<c.metadata.displayName?-1:l.metadata.displayName>c.metadata.displayName?1:0)}}openDataDownloadDialog(){this.dialog.open(this.DataDownloadComponent,{data:{cardId:this.cardId}})}onFobRemoved(){this.onStepSelectorToggled.emit(bl.FOB_DESELECT)}showDataTable(){return this.xAxisType===Ji.STEP&&null!==this.stepOrLinkedTimeSelection}showFobController(){return this.xAxisType===Ji.STEP&&(null!==this.stepOrLinkedTimeSelection||this.isProspectiveFobFeatureEnabled)}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(vl))},n.\u0275cmp=R({type:n,selectors:[["scalar-card-component"]],viewQuery:function(e,i){if(1&e&&ot(jk,5),2&e){let r;Ne(r=Le())&&(i.lineChart=r.first)}},inputs:{cardId:"cardId",chartMetadataMap:"chartMetadataMap",DataDownloadComponent:"DataDownloadComponent",dataSeries:"dataSeries",ignoreOutliers:"ignoreOutliers",isCardVisible:"isCardVisible",isPinned:"isPinned",loadState:"loadState",showFullSize:"showFullSize",smoothingEnabled:"smoothingEnabled",tag:"tag",title:"title",tooltipSort:"tooltipSort",xAxisType:"xAxisType",xScaleType:"xScaleType",useDarkMode:"useDarkMode",forceSvg:"forceSvg",columnCustomizationEnabled:"columnCustomizationEnabled",linkedTimeSelection:"linkedTimeSelection",stepOrLinkedTimeSelection:"stepOrLinkedTimeSelection",isProspectiveFobFeatureEnabled:"isProspectiveFobFeatureEnabled",minMaxStep:"minMaxStep",columnHeaders:"columnHeaders"},outputs:{onFullSizeToggle:"onFullSizeToggle",onPinClicked:"onPinClicked",onTimeSelectionChanged:"onTimeSelectionChanged",onStepSelectorToggled:"onStepSelectorToggled",onDataTableSorting:"onDataTableSorting",reorderColumnHeaders:"reorderColumnHeaders",onLineChartZoom:"onLineChartZoom"},decls:36,vars:27,consts:function(){let t,e,i,r,o;return t=$localize`:A button that resets line chart domain to the data␟e68a552941ab427a99e7437e08443f30ac71ccd6␟3830646521058268558:Fit line chart domains to data`,e=$localize`:A button to pin a card.␟e665dc712bd5f18d4dfa3a29e125d565cc51e2f6␟7284606426234375344:Pin card`,i=$localize`:A button on line chart that toggles full size mode.␟fc8f767d0b9f930187a1bae34477ad28736ece33␟915721563638926597:Toggle full size mode`,r=$localize`:An overflow menu button that opens more line chart options␟b260fab946a3077ce20fd28e336979f586720e8d␟878053740210336435:More line chart options`,o=$localize`:A button that toggles log scale on y-axis on a line chart␟fe91f96ab9b3baca5a48913f2b0fae84483d93e3␟3374645620638883926:Toggle Y-axis log scale on line chart`,[[1,"always-visible"],[1,"heading"],[1,"name"],[1,"tag",3,"title","value"],[3,"isClipped"],[1,"controls"],["mat-icon-button","","aria-label",t,3,"disabled","title","click"],["svgIcon","settings_overscan_24px"],["mat-icon-button","","aria-label",e,1,"pin-button",3,"click"],[3,"svgIcon"],["mat-icon-button","","aria-label",i,"title","Toggle full size mode",3,"click"],["mat-icon-button","","aria-label",r,"title","More line chart options",3,"matMenuTriggerFor"],["svgIcon","more_vert_24px"],["menu","matMenu"],["mat-menu-item","","aria-label",o,3,"click"],["svgIcon","line_weight_24px"],["mat-menu-item","","aria-label","Open dialog to download data",3,"click"],["svgIcon","get_app_24px"],[1,"chart-container"],["diameter","18",4,"ngIf"],[3,"disableUpdate","preferredRendererType","seriesData","seriesMetadataMap","xScaleType","yScaleType","customXFormatter","ignoreYOutliers","tooltipTemplate","useDarkMode","customVisTemplate","customChartOverlayTemplate","onViewBoxOverridden","viewBoxChanged"],["tooltip",""],[4,"ngIf"],["lineChartCustomVis",""],["lineChartCustomXAxisVis",""],["diameter","18"],[1,"tooltip"],[1,"circle-header"],[4,"ngFor","ngForOf","ngForTrackBy"],[1,"tooltip-row"],[1,"tooltip-row-circle"],[3,"alias"],[1,"data-table-container"],[3,"chartMetadataMap","dataSeries","stepOrLinkedTimeSelection","columnHeaders","sortingInfo","columnCustomizationEnabled","smoothingEnabled","sortDataBy","orderColumns"],[3,"ngClass"],[3,"ngClass","left",4,"ngIf"],[3,"disableInteraction","timeSelection","scale","minMaxHorizontalViewExtend","minMaxStep","axisSize","isProspectiveFobFeatureEnabled","onTimeSelectionChanged","onTimeSelectionToggled"]]},template:function(e,i){if(1&e&&(_(0,"div",0)(1,"div",1)(2,"span",2),O(3,"tb-truncated-path",3)(4,"vis-linked-time-selection-warning",4),v(),_(5,"span",5)(6,"button",6),P("click",function(){return i.resetDomain()}),B(7,"async"),B(8,"async"),O(9,"mat-icon",7),v(),_(10,"button",8),P("click",function(){return i.onPinClicked.emit(!i.isPinned)}),O(11,"mat-icon",9),v(),_(12,"button",10),P("click",function(){return i.onFullSizeToggle.emit()}),O(13,"mat-icon",9),v(),_(14,"button",11),O(15,"mat-icon",12),v(),_(16,"mat-menu",null,13)(18,"button",14),P("click",function(){return i.toggleYScaleType()}),O(19,"mat-icon",15),_(20,"span"),A(21,"Toggle Y-axis log scale"),v()(),_(22,"button",16),P("click",function(){return i.openDataDownloadDialog()}),O(23,"mat-icon",17),_(24,"span"),A(25,"Download data"),v()()()()(),_(26,"div",18),E(27,AYe,1,0,"mat-spinner",19),_(28,"line-chart",20),P("onViewBoxOverridden",function(o){return i.isViewBoxOverridden=o})("viewBoxChanged",function(o){return i.onLineChartZoom.emit(o)}),v(),E(29,kYe,17,3,"ng-template",null,21,qt),v()(),E(31,FYe,3,7,"ng-container",22),E(32,zYe,1,1,"ng-template",null,23,qt),E(34,GYe,1,1,"ng-template",null,24,qt)),2&e){let r=$e(17),o=$e(30),s=$e(33),a=$e(35);C(3),Zi("title",i.tag),Zi("value",i.title),C(1),y("isClipped",i.linkedTimeSelection&&i.linkedTimeSelection.clipped),C(2),y("disabled",!i.lineChart||!U(7,23,i.lineChart.getIsViewBoxOverridden()))("title",i.lineChart&&U(8,25,i.lineChart.getIsViewBoxOverridden())?"Line chart is already fitted to data. When data updates, the line chart will auto fit to its domain.":"Fit line chart domains to data"),C(4),ze("title",i.isPinned?"Unpin card":"Pin card"),C(1),y("svgIcon",i.isPinned?"keep_24px":"keep_outline_24px"),C(2),y("svgIcon",i.showFullSize?"fullscreen_exit_24px":"fullscreen_24px"),C(1),y("matMenuTriggerFor",r),C(13),y("ngIf",i.loadState===i.DataLoadState.LOADING),C(1),y("disableUpdate",!i.isCardVisible)("preferredRendererType",i.forceSvg?i.RendererType.SVG:i.RendererType.WEBGL)("seriesData",i.dataSeries)("seriesMetadataMap",i.chartMetadataMap)("xScaleType",i.xScaleType)("yScaleType",i.yScaleType)("customXFormatter",i.getCustomXFormatter())("ignoreYOutliers",i.ignoreOutliers)("tooltipTemplate",o)("useDarkMode",i.useDarkMode)("customVisTemplate",s)("customChartOverlayTemplate",a),C(3),y("ngIf",i.showDataTable())}},dependencies:[Fn,dn,Be,cy,jk,_n,Gt,hd,nu,fd,Bo,uy,dy,ppe,mpe,Ge,U_],styles:["[_nghost-%COMP%]{display:flex;flex-direction:column;box-sizing:border-box;height:100%;overflow:auto;padding:16px;padding-top:4px}.always-visible[_ngcontent-%COMP%]{display:flex;flex-basis:298px;flex-direction:column;flex-grow:1}.heading[_ngcontent-%COMP%]{align-items:center;display:flex;font-size:14px;justify-content:space-between;margin-bottom:4px;position:relative}.heading[_ngcontent-%COMP%]   .name[_ngcontent-%COMP%]{align-items:center;display:grid;gap:5px;grid-template-columns:auto auto}.heading[_ngcontent-%COMP%]   vis-selected-time-clipped[_ngcontent-%COMP%]{font-size:1.2em;line-height:0}.tag[_ngcontent-%COMP%]{overflow:hidden}.pin-button[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{height:18px}.controls[_ngcontent-%COMP%]{color:#616161;white-space:nowrap;flex-shrink:0;margin-right:-12px}body.dark-mode[_nghost-%COMP%]   .controls[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .controls[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.chart-container[_ngcontent-%COMP%]{flex-grow:1}.chart-container[_ngcontent-%COMP%]   mat-spinner[_ngcontent-%COMP%]{position:absolute;right:11px;top:11px}.chart-container[_ngcontent-%COMP%]   line-chart[_ngcontent-%COMP%]{display:block;height:100%}.tooltip[_ngcontent-%COMP%]{border-spacing:4px;font-size:13px}.tooltip[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{text-align:left}.tooltip[_ngcontent-%COMP%]   .tooltip-row[_ngcontent-%COMP%]{white-space:nowrap}.tooltip[_ngcontent-%COMP%]   .tooltip-row-circle[_ngcontent-%COMP%]{align-items:center;display:inline-flex;height:12px;width:12px}.tooltip[_ngcontent-%COMP%]   .tooltip-row-circle[_ngcontent-%COMP%] > span[_ngcontent-%COMP%]{border-radius:50%;border:1px solid rgba(255,255,255,.4);display:inline-block;height:10px;width:10px}.tooltip[_ngcontent-%COMP%]   .closest[_ngcontent-%COMP%]   .tooltip-row-circle[_ngcontent-%COMP%] > span[_ngcontent-%COMP%]{border-color:#fff;box-shadow:inset 0 0 0 1px #fff}.out-of-selected-time[_ngcontent-%COMP%]{height:100%;position:absolute}.out-of-selected-time.start[_ngcontent-%COMP%]{border-right-width:2px;margin-left:-1px}.out-of-selected-time.start.range[_ngcontent-%COMP%]{left:0}.out-of-selected-time.end[_ngcontent-%COMP%]{border-left-width:2px;margin-right:-1px;right:0}.out-of-selected-time.range[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.5)}body.dark-mode[_nghost-%COMP%]   .out-of-selected-time.range[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .out-of-selected-time.range[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.4)}.data-table-container[_ngcontent-%COMP%]{width:100%;height:100px;overflow:auto}"],changeDetection:0}),n})(),kG=-1/0,FG=1/0;function qYe(n,t){return n.length===t.length&&n.every((e,i)=>{let r=t[i],o=e.points,s=r.points;return e.runId===r.runId&&o.length===s.length&&o.every((a,l)=>{let c=s[l];return a.x===c.x&&a.y===c.y})})}var _pe=(()=>{class n{constructor(e){this.store=e,this.DataDownloadComponent=ose,this.fullWidthChanged=new G,this.fullHeightChanged=new G,this.pinStateChanged=new G,this.isVisible=!1,this.isProspectiveFobFeatureEnabled$=this.store.select(D$),this.minMaxSteps$=new hr({minStep:kG,maxStep:FG}),this.lineChartZoom$=new hr({minStep:kG,maxStep:FG}),this.stepSelectorTimeSelection$=new hr(null),this.useDarkMode$=this.store.select(Qu),this.ignoreOutliers$=this.store.select(hv),this.tooltipSort$=this.store.select(pv),this.xAxisType$=this.store.select(td),this.forceSvg$=this.store.select(w$),this.columnCustomizationEnabled$=this.store.select(qA),this.xScaleType$=this.store.select(td).pipe(L(i=>{switch(i){case Ji.STEP:case Ji.RELATIVE:return Nr.LINEAR;case Ji.WALL_TIME:return Nr.TIME;default:throw new Error(`Invalid xAxisType for line chart. ${i}`)}})),this.scalarSmoothing$=this.store.select(op),this.smoothingEnabled$=this.store.select(op).pipe(L(i=>i>0)),this.showFullSize=!1,this.ngUnsubscribe=new ke}onVisibilityChange({visible:e}){this.isVisible=e}isScalarCardMetadata(e){let{plugin:i}=e;return i===ri.SCALARS}onFullSizeToggle(){this.showFullSize=!this.showFullSize,this.fullWidthChanged.emit(this.showFullSize),this.fullHeightChanged.emit(this.showFullSize)}ngOnInit(){let i=this.store.select(tc,this.cardId).pipe(Ye(l=>!!l&&this.isScalarCardMetadata(l)),L(l=>l));function s(l){return JSON.stringify(["smoothed",l])}let a=this.store.select(xh,this.cardId).pipe(st(this.ngUnsubscribe),Ye(l=>Boolean(l)),L(l=>l),Ma(1)).pipe(fr(this.store.select(td)),L(([l,c])=>Object.keys(l).map(p=>({runId:p,points:this.stepSeriesToLineSeries(l[p],c)}))),yi(qYe)).pipe(fr(this.store.select(OI)),st(this.ngUnsubscribe),L(([l,c])=>c?function(n){let t=[];for(let e of n){let i=[],r=Number.isFinite(e.points[0]?.x)?e.points[0].x:-1/0,o=[];for(let s of e.points)Number.isFinite(s.x)?(s.x<r&&(i.push({seriesId:JSON.stringify([e.runId,i.length]),runId:e.runId,points:o}),o=[]),o.push(s),r=s.x):o.push(s);i.push({seriesId:JSON.stringify([e.runId,i.length]),runId:e.runId,points:o});for(let s=0;s<i.length;s++)t.push({...i[s],partitionIndex:s,partitionSize:i.length})}return t}(l):l.map(u=>({...u,seriesId:u.runId,partitionIndex:0,partitionSize:1}))),L(l=>l.map(c=>{let u=c.points[0]?.wallTime;return{...c,points:c.points.map(d=>({...d,relativeTimeInMs:d.wallTime-u}))}})),fr(this.store.select(td)),L(([l,c])=>l.map(u=>({...u,points:u.points.map(d=>{let p;switch(c){case Ji.RELATIVE:p=d.relativeTimeInMs;break;case Ji.WALL_TIME:p=d.wallTime;break;default:p=d.step}return{...d,x:p}})}))),Ma(1));Lt([a,this.lineChartZoom$]).subscribe(([l,c])=>{let u=l.map(({points:m})=>m.map(({x:x})=>x)).flat(),d=0===u.length?kG:Math.min(...u),p=0===u.length?FG:Math.max(...u),h=Math.max(d,c.minStep),f=Math.min(p,c.maxStep);this.minMaxSteps$.next({minStep:h,maxStep:f})}),this.dataSeries$=a.pipe(fr(this.store.select(op)),ui(([l,c])=>{let u=l.map(({seriesId:d,points:p})=>({id:d,points:p}));return c<=0?Xt(u):Eo(async function(n,t){Number.isFinite(t)||(t=0),t=Math.max(0,Math.min(t,1));let e=[];for(let i of n){let r=i.points[0]?.y;if(i.points.every(c=>c.y==r)){e.push(i);continue}let s=i.points.length>0?0:NaN,a=0,l=i.points.map(c=>{let u=c.y;if(Number.isFinite(u)){s=s*t+(1-t)*u,a++;let d=1===t?1:1-Math.pow(t,a);return{x:c.x,y:s/d}}return{x:c.x,y:u}});e.push({id:i.id,points:l})}return e}(u,c)).pipe(L(d=>{let p=u.map((h,f)=>({id:s(h.id),points:d[f].points.map(({y:m},x)=>({...h.points[x],y:m}))}));return[...u,...p]}))}),zn([])),this.linkedTimeSelection$=Lt([this.minMaxSteps$,this.store.select(Ym),this.store.select(Xm),this.store.select(td)]).pipe(L(([{minStep:l,maxStep:c},u,d,p])=>u&&p===Ji.STEP&&d?Qh(d,l,c):null)),this.stepOrLinkedTimeSelection$=Lt([this.stepSelectorTimeSelection$,this.linkedTimeSelection$,this.store.select(Ym)]).pipe(L(([l,c,u])=>u&&c?{start:{step:c.startStep},end:null===c.endStep?null:{step:c.endStep}}:l)),this.columnHeaders$=Lt([this.stepOrLinkedTimeSelection$,this.store.select(BI),this.store.select(VI)]).pipe(L(([l,c,u])=>null===l||null===l.end?c:u)),this.chartMetadataMap$=a.pipe(ui(l=>Lt(l.map(c=>this.getRunDisplayNameAndAlias(c.runId).pipe(L(u=>({...c,...u})))))),fr(this.store.select(oo),this.store.select(nc),this.store.select(op)),Hr(0),L(([l,c,u,d])=>{let p={},h=d>0;for(let f of l){let{seriesId:m,runId:x,displayName:g,alias:b,partitionIndex:D,partitionSize:T}=f;p[m]={type:sy.ORIGINAL,id:m,alias:b,displayName:T>1?`${g}: ${D}`:g,visible:Boolean(c&&c.get(x)),color:u[x]??"#fff",aux:!1,opacity:1}}if(!h)return p;for(let[f,m]of Object.entries(p)){let x=s(f);p[x]={...m,id:x,type:sy.DERIVED,aux:!1,originalSeriesId:f},m.aux=!0,m.opacity=.25}return p}),zn({})),this.loadState$=this.store.select(bh,this.cardId),this.tag$=i.pipe(L(l=>l.tag)),this.title$=this.tag$.pipe(L(l=>ly(l,this.groupName))),this.isPinned$=this.store.select(Ch,this.cardId),this.store.select(fv).pipe(Wt(this.minMaxSteps$),st(this.ngUnsubscribe)).subscribe(([l,c])=>{l?null!==this.stepSelectorTimeSelection$.getValue()||this.stepSelectorTimeSelection$.next({start:{step:c.minStep},end:null}):this.stepSelectorTimeSelection$.next(null)}),this.store.select(mv).pipe(Wt(this.minMaxSteps$),st(this.ngUnsubscribe)).subscribe(([l,c])=>{let u=this.stepSelectorTimeSelection$.getValue();null!==u?l||null===u.end?l&&null===u.end&&this.stepSelectorTimeSelection$.next({start:u.start,end:{step:c.maxStep}}):this.stepSelectorTimeSelection$.next({start:u.start,end:null}):l&&this.stepSelectorTimeSelection$.next({start:{step:c.minStep},end:l?{step:c.maxStep}:null})}),this.minMaxSteps$.pipe(st(this.ngUnsubscribe)).subscribe(({minStep:l,maxStep:c})=>{if(!this.stepSelectorTimeSelection$.getValue())return;let u=this.stepSelectorTimeSelection$.getValue()?.start.step,d=this.stepSelectorTimeSelection$.getValue()?.end?.step,p=function(n,t,e){let i=Qh(n,t,e);return{start:{step:i.startStep},end:null===i.endStep?null:{step:i.endStep}}}({start:{step:u??l},end:this.stepSelectorTimeSelection$.getValue()?.end?{step:d??c}:null},l,c);this.stepSelectorTimeSelection$.next(p)})}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}getRunDisplayNameAndAlias(e){return Lt([this.store.select(GI,{runId:e}),this.store.select(Yu),this.store.select(WI,{runId:e})]).pipe(L(([i,r,o])=>{let s=null!==i?r[i]??null:null;return{displayName:o||s?o?.name??"...":e,alias:s}}))}stepSeriesToLineSeries(e,i){let r=i===Ji.STEP;return e.map(o=>{let s=1e3*o.wallTime;return{...o,x:r?o.step:s,y:o.value,wallTime:s,relativeTimeInMs:0}})}onDataTableSorting(e){this.store.dispatch(yoe(e))}onTimeSelectionChanged(e){let{minStep:i,maxStep:r}=this.minMaxSteps$.getValue(),{startStep:o,endStep:s}=Qh(e.timeSelection,i,r),a={start:{step:o},end:s?{step:s}:null};this.store.dispatch(Yh(e)),this.stepSelectorTimeSelection$.next(a)}onStepSelectorToggled(e){this.stepSelectorTimeSelection$.getValue()&&this.stepSelectorTimeSelection$.next(null),this.store.dispatch(Xh({affordance:e}))}onLineChartZoom(e){let i=e.x,r={minStep:Math.ceil(Math.min(...i)),maxStep:Math.floor(Math.max(...i))};this.lineChartZoom$.next(r)}reorderColumnHeaders(e){this.store.dispatch(dR({newOrder:e}))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["scalar-card"]],inputs:{DataDownloadComponent:"DataDownloadComponent",cardId:"cardId",groupName:"groupName"},outputs:{fullWidthChanged:"fullWidthChanged",fullHeightChanged:"fullHeightChanged",pinStateChanged:"pinStateChanged"},decls:20,vars:61,consts:[["observeIntersection","",3,"cardId","chartMetadataMap","DataDownloadComponent","dataSeries","ignoreOutliers","isCardVisible","isPinned","loadState","showFullSize","smoothingEnabled","tag","title","tooltipSort","xAxisType","xScaleType","useDarkMode","linkedTimeSelection","stepOrLinkedTimeSelection","isProspectiveFobFeatureEnabled","forceSvg","columnCustomizationEnabled","minMaxStep","columnHeaders","onFullSizeToggle","onPinClicked","onVisibilityChange","onTimeSelectionChanged","onStepSelectorToggled","onDataTableSorting","onLineChartZoom","reorderColumnHeaders"]],template:function(e,i){1&e&&(_(0,"scalar-card-component",0),P("onFullSizeToggle",function(){return i.onFullSizeToggle()})("onPinClicked",function(o){return i.pinStateChanged.emit(o)})("onVisibilityChange",function(o){return i.onVisibilityChange(o)})("onTimeSelectionChanged",function(o){return i.onTimeSelectionChanged(o)})("onStepSelectorToggled",function(o){return i.onStepSelectorToggled(o)})("onDataTableSorting",function(o){return i.onDataTableSorting(o)})("onLineChartZoom",function(o){return i.onLineChartZoom(o)})("reorderColumnHeaders",function(o){return i.reorderColumnHeaders(o)}),B(1,"async"),B(2,"async"),B(3,"async"),B(4,"async"),B(5,"async"),B(6,"async"),B(7,"async"),B(8,"async"),B(9,"async"),B(10,"async"),B(11,"async"),B(12,"async"),B(13,"async"),B(14,"async"),B(15,"async"),B(16,"async"),B(17,"async"),B(18,"async"),B(19,"async"),v()),2&e&&y("cardId",i.cardId)("chartMetadataMap",U(1,23,i.chartMetadataMap$))("DataDownloadComponent",i.DataDownloadComponent)("dataSeries",U(2,25,i.dataSeries$))("ignoreOutliers",U(3,27,i.ignoreOutliers$))("isCardVisible",i.isVisible)("isPinned",U(4,29,i.isPinned$))("loadState",U(5,31,i.loadState$))("showFullSize",i.showFullSize)("smoothingEnabled",U(6,33,i.smoothingEnabled$))("tag",U(7,35,i.tag$))("title",U(8,37,i.title$))("tooltipSort",U(9,39,i.tooltipSort$))("xAxisType",U(10,41,i.xAxisType$))("xScaleType",U(11,43,i.xScaleType$))("useDarkMode",U(12,45,i.useDarkMode$))("linkedTimeSelection",U(13,47,i.linkedTimeSelection$))("stepOrLinkedTimeSelection",U(14,49,i.stepOrLinkedTimeSelection$))("isProspectiveFobFeatureEnabled",U(15,51,i.isProspectiveFobFeatureEnabled$))("forceSvg",U(16,53,i.forceSvg$))("columnCustomizationEnabled",U(17,55,i.columnCustomizationEnabled$))("minMaxStep",U(18,57,i.minMaxSteps$))("columnHeaders",U(19,59,i.columnHeaders$))},dependencies:[ay,gpe,Ge],styles:["[_nghost-%COMP%] {\n        display: block;\n        height: 100%;\n      }"],changeDetection:0}),n})();function QYe(n,t,e){let i=[],{left:r,right:o}=t,s=(o-r)/e,a=0,l=0;for(let c=0;c<e;c++){let u=r+c*s,d=u+s,p=c===e-1,h=l;for(l=0;a<n.length;){let f=n[a],m=KYe(f,u,d,!p);if(h+=m.curr,l+=m.next,f.x+f.dx>d)break;a++}i.push({x:u,dx:s,y:h})}return i}function KYe(n,t,e,i){let r=n.x,o=n.x+n.dx;if(r>e||o<t)return{curr:0,next:0};if(0===n.dx)return i&&o>=e?{curr:0,next:n.y}:{curr:n.y,next:0};let s=Math.min(o,e)-Math.max(r,t);return{curr:n.y*s/n.dx,next:0}}var $Ye=xo(".2~s"),eXe=xo(".4~r"),tXe=xo(".2~e");function ype(n){if(0===n)return"0";let t=Math.abs(n);return t>=1e4?$Ye(n):t<.001?tXe(n):eXe(n)}var nXe=["main"],iXe=["xAxis"],rXe=["yAxis"],oXe=["content"],sXe=["histograms"];function aXe(n,t){if(1&n&&(In(),_(0,"g")(1,"text"),A(2),v()()),2&n){let e=S();Pt("transform",e.getCssTranslatePx(e.tooltipData.xAxis.position,9)),C(2),yt(e.tooltipData.xAxis.label)}}function lXe(n,t){if(1&n&&(In(),_(0,"g")(1,"text"),A(2),v()()),2&n){let e=S();Pt("transform",e.getGroupTransform(e.tooltipData.closestDatum)),C(1),ze("y",e.tooltipData.yAxis.position),C(1),je(" ",e.tooltipData.yAxis.label," ")}}function cXe(n,t){if(1&n){let e=Pe();In(),Js(),sn(0),_(1,"histogram-card-fob-controller",16),P("onTimeSelectionChanged",function(r){return oe(e),se(S().onLinkedTimeSelectionChanged.emit(r))})("onTimeSelectionToggled",function(){return oe(e),se(S().onLinkedTimeToggled.emit())}),v(),an()}if(2&n){let e=S();C(1),y("timeSelection",e.timeSelection)("steps",e.getSteps())("temporalScale",e.scales.temporalScale)}}function uXe(n,t){if(1&n&&(In(),_(0,"g"),O(1,"line",17),v()),2&n){let e=t.$implicit;Pt("transform",S().getCssTranslatePx(0,e))}}function dXe(n,t){1&n&&(In(),O(0,"line",21))}function pXe(n,t){if(1&n&&(In(),O(0,"circle",22)),2&n){let e=S().$implicit,i=S();Pt("transform",i.getCssTranslatePx(i.getUiCoordFromBinForContent(i.getClosestBinFromBinCoordinate(e,i.tooltipData.xPositionInBinCoord)).x,i.getUiCoordFromBinForContent(i.getClosestBinFromBinCoordinate(e,i.tooltipData.xPositionInBinCoord)).y))}}function hXe(n,t){if(1&n){let e=Pe();In(),_(0,"g",18),P("mouseenter",function(r){let s=oe(e).$implicit;return se(S().updateColorOnHover(r,s,!0))})("mouseleave",function(r){let s=oe(e).$implicit;return se(S().updateColorOnHover(r,s,!1))})("click",function(){let o=oe(e).$implicit;return se(S().onLinkedTimeRangeChanged(o))}),E(1,dXe,1,0,"line",19),O(2,"path"),E(3,pXe,1,2,"circle",20),v()}if(2&n){let e=t.$implicit,i=S();Pt("transform",i.getGroupTransform(e))("color",i.getHistogramFill(e)),et("histogram",!0)("no-color",!i.isDatumInTimeSelectionRange(e)),C(1),y("ngIf",i.mode===i.HistogramMode.OFFSET),C(1),ze("d",i.getHistogramPath(e)),C(1),y("ngIf",i.tooltipData)}}function fXe(n,t){if(1&n&&(In(),O(0,"circle",22)),2&n){let e=S(2);ze("cx",e.getUiCoordFromBinForContent(e.tooltipData.closestBin).x)("cy",e.getUiCoordFromBinForContent(e.tooltipData.closestBin).y)}}function mXe(n,t){if(1&n&&(In(),_(0,"g",4)(1,"g"),O(2,"path"),E(3,fXe,1,2,"circle",23),v(),_(4,"g",24)(5,"text",25),A(6),v()()()),2&n){let e=S();C(1),Pt("transform",e.getGroupTransform(e.tooltipData.closestDatum)),C(1),ze("d",e.getHistogramPath(e.tooltipData.closestDatum)),C(1),y("ngIf",e.tooltipData.closestBin),C(1),Pt("transform",e.getCssTranslatePx(e.tooltipData.value.position.x,e.tooltipData.value.position.y)),C(2),yt(e.tooltipData.value.label)}}var Wk=(()=>{class n{constructor(e){this.changeDetector=e,this.mode=zr.OFFSET,this.timeProperty=Ro.STEP,this.timeSelection=null,this.onLinkedTimeSelectionChanged=new G,this.onLinkedTimeToggled=new G,this.HistogramMode=zr,this.TimeProperty=Ro,this.tooltipData=null,this.ngUnsubscribe=new ke,this.layout={histogramHeight:0,contentClientRect:{height:0,width:0}},this.scales=null,this.formatters={binNumber:ype,count:xo(".3n"),wallTime:Iy("%m/%d %X"),step:xo(".0f"),relative:i=>xo(".1r")(i/36e5)+"h"},this.domVisible=!1}ngOnChanges(){this.updateChartIfVisible()}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}ngAfterViewInit(){_i(this.main.nativeElement,"mousemove",{passive:!0}).pipe(st(this.ngUnsubscribe)).subscribe(e=>this.onMouseMove(e))}getCssTranslatePx(e,i){return`translate(${e}px, ${i}px)`}getClosestBinFromBinCoordinate(e,i){if(!e.bins.length)return{x:0,dx:0,y:0};let r=e.bins[0],o=e.bins.slice(-1)[0];return i<r.x?r:i>=o.x+o.dx?o:e.bins.find(a=>a.x<=i&&i<a.x+a.dx)}getUiCoordFromBinForContent(e){return this.scales?{x:this.scales.binScale(xE(e)),y:this.scales.countScale(e.y)}:{x:0,y:0}}getHistogramPath(e){if(!this.scales||!e.bins.length)return"";let i=this.scales.binScale,r=this.scales.countScale,o=e.bins[0],s=e.bins.slice(-1)[0],a=[`M${i(xE(o))},${r(0)}`];for(let l of e.bins)a.push(`L${i(xE(l))},${r(l.y)}`);return a.push(`L${i(xE(s))},${r(0)}`),a.join("")}trackByWallTime(e){return e.wallTime}getGroupTransform(e){return this.scales&&this.mode!==zr.OVERLAY?this.getCssTranslatePx(0,this.scales.temporalScale(this.getTimeValue(e))):""}getSteps(){return this.data.map(e=>e.step)}isTimeSelectionEnabled(e){return Boolean(this.mode===zr.OFFSET&&this.timeProperty===Ro.STEP&&this.scales&&e)}isDatumInTimeSelectionRange(e){return!this.isTimeSelectionEnabled(this.timeSelection)||(null===this.timeSelection.end?this.timeSelection.start.step===e.step:this.timeSelection.start.step<=e.step&&this.timeSelection.end.step>=e.step)}getHistogramFill(e){return this.scales?this.scales.d3ColorScale(this.getTimeValue(e)):""}updateColorOnHover(e,i,r){!this.isTimeSelectionEnabled(this.timeSelection)||this.isDatumInTimeSelectionRange(i)||(r?e.target.classList.remove("no-color"):e.target.classList.add("no-color"))}getGridTickYLocs(){if(!this.scales||this.mode===zr.OFFSET)return[];let e=this.scales.countScale;return e.ticks().map(i=>e(i))}onResize(){this.updateClientRects(),this.updateChartIfVisible()}onVisibilityChange({visible:e}){this.domVisible=e,e&&(this.updateClientRects(),this.updateChartIfVisible())}onLinkedTimeRangeChanged(e){if(!this.isTimeSelectionEnabled(this.timeSelection))return;let i=this.timeSelection.start.step,r=this.timeSelection.end?.step,o=e.step<i?e.step:i,s=r;s=void 0===s?e.step>i?e.step:i:e.step>s?e.step:s,(o!==i||s!==r)&&o!==s&&this.onLinkedTimeSelectionChanged.emit({timeSelection:{start:{step:o},end:{step:s}},affordance:cs.HISTOGRAM_CLICK_TO_RANGE})}getTimeValue(e){switch(this.timeProperty){case Ro.WALL_TIME:return e.wallTime;case Ro.STEP:return e.step;case Ro.RELATIVE:return e.wallTime-this.data[0].wallTime}}updateClientRects(){this.content&&(this.layout.contentClientRect=this.content.nativeElement.getBoundingClientRect(),this.layout.histogramHeight=this.layout.contentClientRect.height/2.5)}updateChartIfVisible(){!this.domVisible||(this.scales=this.computeScales(this.data),this.renderXAxis(),this.renderYAxis(),this.changeDetector.detectChanges())}computeScales(e){let{width:i,height:r}=this.layout.contentClientRect,{min:o,max:s}=bpe(e,g=>function(n,t){return n.reduce((e,i)=>Math.min(e,i.x),1/0)}(g.bins),g=>NG(g.bins,({x:b,dx:D})=>b+D)),a=NG(e,g=>NG(g.bins,({y:b})=>b)),l=Qo().domain([o,s]).nice(),c=this.mode!==zr.OVERLAY&&this.timeProperty==Ro.WALL_TIME?Rg():Qo(),u=e.map(g=>this.getTimeValue(g)),{min:d,max:p}=bpe(u,g=>g),h=[d,p];c.domain(h);let f=Qo();f.domain([0,a]);let m=yg(this.color||"#000"),x=Qo();return x.domain(h),l.range([0,i]),x.range([m.brighter(),m.darker()]),x.interpolate(pz),this.mode===zr.OVERLAY?(c.range([r,r]),f.range([r,0])):(c.range([r-(this.mode===zr.OFFSET?r-this.layout.histogramHeight:0),r]),f.range([0,-this.layout.histogramHeight])),{binScale:l,d3ColorScale:x,countScale:f,temporalScale:c}}renderXAxis(){if(!this.scales)return;let{width:e}=this.layout.contentClientRect,i=jw(this.scales.binScale).ticks(Math.max(2,e/20));i.tickFormat(this.formatters.binNumber),i(bo(this.xAxis.nativeElement))}getYAxisFormatter(){if(this.mode===zr.OVERLAY)return this.formatters.count;switch(this.timeProperty){case Ro.WALL_TIME:return this.formatters.wallTime;case Ro.STEP:return this.formatters.step;case Ro.RELATIVE:return this.formatters.relative;default:throw RangeError(`Y axis formatter for ${this.timeProperty} must be implemented`)}}getMaxTicks(e){let{height:i}=this.layout.contentClientRect,r=i/15;if(this.timeProperty===Ro.STEP){let[o,s]=e.domain(),a=Math.max(s-o+1,1);return Math.min(a,r)}return r}renderYAxis(){if(!this.scales)return;let e=this.mode===zr.OVERLAY?this.scales.countScale:this.scales.temporalScale,i=this.getMaxTicks(e),r=zw(e).ticks(Math.max(2,i));r.tickFormat(this.getYAxisFormatter()),r(bo(this.yAxis.nativeElement))}findClosestDatumIndex(e){let i=e.target,r=i;for(;i&&i!==this.histograms.nativeElement;)r=i,i=i.parentElement;return i?Array.from(i.children).indexOf(r):-1}onMouseMoveForTestOnly(e){return this.onMouseMove(e)}onMouseMove(e){if(!this.scales)return;let i=e.offsetX,r=e.offsetY,o=this.findClosestDatumIndex(e);if(o<0)return;let s=this.scales.binScale.invert(i),a=this.data[o],l=this.getClosestBinFromBinCoordinate(a,s);this.tooltipData={value:{position:{x:i,y:r},label:this.mode===zr.OFFSET?this.formatters.count(l.y):`Step: ${this.formatters.step(a.step)}`},xAxis:{position:this.getUiCoordFromBinForContent(l).x,label:this.formatters.binNumber(xE(l))},yAxis:{position:this.scales.countScale(this.mode===zr.OFFSET?0:l.y),label:this.mode===zr.OFFSET?this.getYAxisFormatter()(this.getTimeValue(a)):this.formatters.binNumber(l.y)},xPositionInBinCoord:s,closestDatum:a,closestBin:l},this.changeDetector.detectChanges()}}return n.\u0275fac=function(e){return new(e||n)(M(nn))},n.\u0275cmp=R({type:n,selectors:[["tb-histogram"]],viewQuery:function(e,i){if(1&e&&(ot(nXe,5),ot(iXe,5),ot(rXe,5),ot(oXe,5),ot(sXe,5)),2&e){let r;Ne(r=Le())&&(i.main=r.first),Ne(r=Le())&&(i.xAxis=r.first),Ne(r=Le())&&(i.yAxis=r.first),Ne(r=Le())&&(i.content=r.first),Ne(r=Le())&&(i.histograms=r.first)}},inputs:{mode:"mode",timeProperty:"timeProperty",color:"color",data:"data",timeSelection:"timeSelection"},outputs:{onLinkedTimeSelectionChanged:"onLinkedTimeSelectionChanged",onLinkedTimeToggled:"onLinkedTimeToggled"},features:[Ft],decls:22,vars:15,consts:[["detectResize","","observeIntersection","",3,"onResize","onVisibilityChange"],["main",""],[1,"axis","x-axis"],["xAxis",""],[1,"tooltip"],[3,"transform",4,"ngIf"],[1,"axis","y-axis"],["yAxis",""],[4,"ngIf"],[1,"content"],["content",""],[1,"grid"],[3,"transform",4,"ngFor","ngForOf"],["histograms",""],[3,"transform","histogram","no-color","color","mouseenter","mouseleave","click",4,"ngFor","ngForOf","ngForTrackBy"],["class","tooltip",4,"ngIf"],[1,"histogram-card-fob",3,"timeSelection","steps","temporalScale","onTimeSelectionChanged","onTimeSelectionToggled"],["x2","100%",1,"tick"],[3,"mouseenter","mouseleave","click"],["class","baseline","x2","100%",4,"ngIf"],["r","2",3,"transform",4,"ngIf"],["x2","100%",1,"baseline"],["r","2"],["r","2",4,"ngIf"],[1,"value-label"],["x","3","y","-3"]],template:function(e,i){1&e&&(_(0,"div",0,1),P("onResize",function(){return i.onResize()})("onVisibilityChange",function(o){return i.onVisibilityChange(o)}),In(),_(2,"svg",2),O(3,"g",null,3),_(5,"g",4),E(6,aXe,3,3,"g",5),v()(),Js(),_(7,"div",6),In(),_(8,"svg"),O(9,"g",null,7),_(11,"g",4),E(12,lXe,3,4,"g",5),v()(),E(13,cXe,2,3,"ng-container",8),v(),_(14,"svg",9,10)(16,"g",11),E(17,uXe,2,2,"g",12),v(),_(18,"g",null,13),E(20,hXe,4,11,"g",14),v(),E(21,mXe,7,7,"g",15),v()()),2&e&&(Da("main "+i.mode+" "+i.timeProperty),C(6),y("ngIf",i.tooltipData),C(5),Pt("transform",i.getCssTranslatePx(9,0)),C(1),y("ngIf",i.tooltipData),C(1),y("ngIf",i.isTimeSelectionEnabled(i.timeSelection)),C(4),y("ngForOf",i.getGridTickYLocs()),C(1),et("histograms",!0)("linked-time-single-step",i.timeSelection&&!i.timeSelection.end),C(2),y("ngForOf",i.data)("ngForTrackBy",i.trackByWallTime),C(1),y("ngIf",i.tooltipData))},styles:['[_nghost-%COMP%], .main[_ngcontent-%COMP%]{display:inline-block;height:100%;width:100%}[_nghost-%COMP%]{box-sizing:border-box;padding:10px}.main[_ngcontent-%COMP%]{display:grid;grid-template-areas:"content y-axis" "x-axis .";grid-template-columns:1fr 50px;grid-template-rows:1fr 30px}.main.wall_time[_ngcontent-%COMP%]{grid-template-columns:1fr 75px}.tooltip[_ngcontent-%COMP%], .baseline[_ngcontent-%COMP%]{color:#000}body.dark-mode[_nghost-%COMP%]   .tooltip[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .tooltip[_ngcontent-%COMP%]{color:#fff}body.dark-mode[_nghost-%COMP%]   .baseline[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .baseline[_ngcontent-%COMP%]{color:#fff}.linked-time-fob[_ngcontent-%COMP%]   text[_ngcontent-%COMP%], .tooltip[_ngcontent-%COMP%]   text[_ngcontent-%COMP%]{font-weight:bold;font-size:10px}.linked-time-fob[_ngcontent-%COMP%]   text[_ngcontent-%COMP%], .linked-time-fob[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .tooltip[_ngcontent-%COMP%]   text[_ngcontent-%COMP%], .tooltip[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{fill:currentColor}.linked-time-fob[_ngcontent-%COMP%]   .value-label[_ngcontent-%COMP%], .tooltip[_ngcontent-%COMP%]   .value-label[_ngcontent-%COMP%]{dominant-baseline:ideographic;text-anchor:start}.axis[_ngcontent-%COMP%]    {color:#616161;position:relative;overflow:hidden}body.dark-mode[_nghost-%COMP%]   .axis[_ngcontent-%COMP%]    , body.dark-mode   [_nghost-%COMP%]   .axis[_ngcontent-%COMP%]    {color:rgba(255,255,255,.7)}.axis[_ngcontent-%COMP%]     .domain, .axis[_ngcontent-%COMP%]     .tick text{display:none}.axis[_ngcontent-%COMP%]     .tick:nth-child(2n+1) text{display:initial}svg[_ngcontent-%COMP%]{height:100%;width:100%;pointer-events:visiblePainted}svg[_ngcontent-%COMP%]   line[_ngcontent-%COMP%], svg[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], svg[_ngcontent-%COMP%]   .tooltip[_ngcontent-%COMP%]{pointer-events:none}svg[_ngcontent-%COMP%]   g[_ngcontent-%COMP%]{will-change:transform}.x-axis[_ngcontent-%COMP%]{grid-area:x-axis}.x-axis[_ngcontent-%COMP%]   .tooltip[_ngcontent-%COMP%]{dominant-baseline:hanging;text-anchor:middle}.y-axis[_ngcontent-%COMP%]{grid-area:y-axis;overflow:clip visible}.y-axis[_ngcontent-%COMP%]   .tooltip[_ngcontent-%COMP%]{dominant-baseline:middle;text-anchor:start}.histogram-card-fob[_ngcontent-%COMP%]{left:9px;position:absolute}.content[_ngcontent-%COMP%]   .tick[_ngcontent-%COMP%], .axis[_ngcontent-%COMP%]     .tick line{stroke:#ddd}body.dark-mode[_nghost-%COMP%]   .content[_ngcontent-%COMP%]   .tick[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .content[_ngcontent-%COMP%]   .tick[_ngcontent-%COMP%]{stroke:#555}body.dark-mode[_nghost-%COMP%]   .axis[_ngcontent-%COMP%]     .tick line, body.dark-mode   [_nghost-%COMP%]   .axis[_ngcontent-%COMP%]     .tick line{stroke:#555}.content[_ngcontent-%COMP%]{grid-area:content;overflow:visible;z-index:1}.content[_ngcontent-%COMP%]   .tick[_ngcontent-%COMP%]{stroke-width:1px;stroke-dasharray:2}.content[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .content[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{fill:currentColor;stroke-opacity:.6;stroke-width:1px}.content[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{filter:drop-shadow(0 0 1px rgba(0, 0, 0, 0.6));stroke:#fff;will-change:transform}.content[_ngcontent-%COMP%]   .baseline[_ngcontent-%COMP%]{stroke-opacity:.1;stroke-width:1px;stroke:currentColor;width:100%}.content[_ngcontent-%COMP%]   .tooltip[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{stroke-opacity:1;stroke:currentColor;fill:rgba(0,0,0,0)}.content[_ngcontent-%COMP%]   .no-color[_ngcontent-%COMP%]{color:rgba(221,221,221,.4) !important}.content[_ngcontent-%COMP%]   .no-color[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{stroke-opacity:.2}body.dark-mode[_nghost-%COMP%]   .content[_ngcontent-%COMP%]   .no-color[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .content[_ngcontent-%COMP%]   .no-color[_ngcontent-%COMP%]{color:rgba(51,51,51,.4) !important}.offset[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   .histograms[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{stroke:#fff}body.dark-mode[_nghost-%COMP%]   .offset[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   .histograms[_ngcontent-%COMP%]   path[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .offset[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   .histograms[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{stroke:#555}.offset[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   .histograms.linked-time-single-step[_ngcontent-%COMP%]   [_ngcontent-%COMP%]:not(.no-color)   path[_ngcontent-%COMP%]{stroke:#000}body.dark-mode[_nghost-%COMP%]   .offset[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   .histograms.linked-time-single-step[_ngcontent-%COMP%]   [_ngcontent-%COMP%]:not(.no-color)   path[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .offset[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   .histograms.linked-time-single-step[_ngcontent-%COMP%]   [_ngcontent-%COMP%]:not(.no-color)   path[_ngcontent-%COMP%]{stroke:#fff}.overlay[_ngcontent-%COMP%]   .x-axis[_ngcontent-%COMP%]     .tick line{display:none}.overlay[_ngcontent-%COMP%]   .content[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{fill-opacity:0;stroke:currentColor}.tooltip[_ngcontent-%COMP%], .content[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{display:none}.main[_ngcontent-%COMP%]:hover   .content[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .main[_ngcontent-%COMP%]:hover   .tooltip[_ngcontent-%COMP%]{display:block}'],changeDetection:0}),n})();function NG(n,t){return n.reduce((e,i)=>Math.max(e,t(i)),-1/0)}function bpe(n,t,e){e||(e=t);let i=1/0,r=-1/0;for(let o of n)i=Math.min(i,t(o)),r=Math.max(r,e(o));return{min:i,max:r}}function xE(n){return n.x+.5*n.dx}function vXe(n,t){1&n&&(_(0,"span",14),O(1,"mat-spinner",15),v())}function yXe(n,t){if(1&n){let e=Pe();_(0,"tb-histogram",16),P("onLinkedTimeSelectionChanged",function(r){return oe(e),se(S().onLinkedTimeSelectionChanged.emit(r))})("onLinkedTimeToggled",function(){return oe(e),se(S().onLinkedTimeToggled.emit())}),v()}if(2&n){let e=S();y("data",e.data)("mode",e.mode)("timeProperty",e.timeProperty(e.xAxisType))("color",e.runColorScale(e.runId))("timeSelection",e.convertToTimeSelection(e.linkedTimeSelection))}}function bXe(n,t){1&n&&(_(0,"div",18),A(1," Data failed to load. "),v())}function xXe(n,t){if(1&n&&E(0,bXe,2,0,"div",17),2&n){let e=S();y("ngIf",e.loadState===e.DataLoadState.FAILED)}}var CXe=function(n){return{backgroundColor:n}},xpe=(()=>{class n{constructor(){this.DataLoadState=Oe,this.onFullSizeToggle=new G,this.onPinClicked=new G,this.onLinkedTimeSelectionChanged=new G,this.onLinkedTimeToggled=new G}timeProperty(e){switch(e){case Ji.STEP:return Ro.STEP;case Ji.WALL_TIME:return Ro.WALL_TIME;case Ji.RELATIVE:return Ro.RELATIVE;default:throw new Error("Invalid xAxisType for histogram time property.")}}convertToTimeSelection(e){return null===e?null:{start:{step:e.startStep},end:e.endStep?{step:e.endStep}:null}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["histogram-card-component"]],inputs:{loadState:"loadState",title:"title",tag:"tag",runId:"runId",data:"data",mode:"mode",xAxisType:"xAxisType",runColorScale:"runColorScale",showFullSize:"showFullSize",isPinned:"isPinned",linkedTimeSelection:"linkedTimeSelection",isClosestStepHighlighted:"isClosestStepHighlighted"},outputs:{onFullSizeToggle:"onFullSizeToggle",onPinClicked:"onPinClicked",onLinkedTimeSelectionChanged:"onLinkedTimeSelectionChanged",onLinkedTimeToggled:"onLinkedTimeToggled"},decls:16,vars:14,consts:function(){let t,e;return t=$localize`:A button to pin a card.␟e665dc712bd5f18d4dfa3a29e125d565cc51e2f6␟7284606426234375344:Pin card`,e=$localize`:A button on a histogram card that toggles full size mode.␟fc8f767d0b9f930187a1bae34477ad28736ece33␟915721563638926597:Toggle full size mode`,[[1,"heading"],[1,"tag"],[3,"title","value"],[3,"isClipped","isClosestStepHighlighted"],[1,"run"],[1,"dot",3,"ngStyle"],[1,"run-text",3,"runId"],[1,"controls"],["mat-icon-button","","aria-label",t,1,"pin-button",3,"click"],[3,"svgIcon"],["mat-icon-button","","aria-label",e,"title","Toggle full size mode",3,"click"],["class","spinner",4,"ngIf"],[3,"data","mode","timeProperty","color","timeSelection","onLinkedTimeSelectionChanged","onLinkedTimeToggled",4,"ngIf","ngIfElse"],["noData",""],[1,"spinner"],["diameter","18"],[3,"data","mode","timeProperty","color","timeSelection","onLinkedTimeSelectionChanged","onLinkedTimeToggled"],["class","empty-message",4,"ngIf"],[1,"empty-message"]]},template:function(e,i){if(1&e&&(_(0,"div",0)(1,"div",1),O(2,"tb-truncated-path",2)(3,"vis-linked-time-selection-warning",3),v(),_(4,"div",4),O(5,"span",5)(6,"card-run-name",6),v(),_(7,"span",7)(8,"button",8),P("click",function(){return i.onPinClicked.emit(!i.isPinned)}),O(9,"mat-icon",9),v(),_(10,"button",10),P("click",function(){return i.onFullSizeToggle.emit()}),O(11,"mat-icon",9),v()(),E(12,vXe,2,0,"span",11),v(),E(13,yXe,1,5,"tb-histogram",12),E(14,xXe,1,1,"ng-template",null,13,qt)),2&e){let r=$e(15);C(2),y("title",i.tag)("value",i.title),C(1),y("isClipped",i.linkedTimeSelection&&i.linkedTimeSelection.clipped)("isClosestStepHighlighted",i.isClosestStepHighlighted),C(2),y("ngStyle",On(12,CXe,i.runColorScale(i.runId))),C(1),y("runId",i.runId),C(2),ze("title",i.isPinned?"Unpin card":"Pin card"),C(1),y("svgIcon",i.isPinned?"keep_24px":"keep_outline_24px"),C(2),y("svgIcon",i.showFullSize?"fullscreen_exit_24px":"fullscreen_24px"),C(1),y("ngIf",i.loadState===i.DataLoadState.LOADING),C(1),y("ngIf",i.data&&i.data.length)("ngIfElse",r)}},dependencies:[Be,zu,Wk,_n,Gt,Bo,yR,uy,dy],styles:['[_nghost-%COMP%]{box-sizing:border-box;display:flex;flex-basis:318px;flex-direction:column;flex-grow:1;height:100%;overflow:auto;padding:16px;padding-top:4px}.heading[_ngcontent-%COMP%]{align-items:center;display:grid;grid-template-areas:"tag controls" "run spinner";grid-template-columns:1fr auto;font-size:14px;margin-bottom:4px}.tag[_ngcontent-%COMP%]{align-items:center;display:flex;gap:5px;grid-area:tag;overflow:hidden}.tag[_ngcontent-%COMP%]   vis-selected-time-clipped[_ngcontent-%COMP%]{line-height:0}.pin-button[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{height:18px}.run[_ngcontent-%COMP%]{grid-area:run;display:flex;white-space:nowrap;font-size:13px}.run[_ngcontent-%COMP%]   .dot[_ngcontent-%COMP%]{flex:none;display:inline-block;width:13px;height:13px;border-radius:50%;margin-right:4px}.run[_ngcontent-%COMP%]   .run-text[_ngcontent-%COMP%]{overflow:hidden;text-overflow:ellipsis;max-width:120px}.controls[_ngcontent-%COMP%]{color:#616161;white-space:nowrap;grid-area:controls;justify-self:flex-end;flex-shrink:0;margin-right:-12px}body.dark-mode[_nghost-%COMP%]   .controls[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .controls[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.spinner[_ngcontent-%COMP%]{display:flex;grid-area:spinner;height:100%;justify-content:center;position:relative}mat-spinner[_ngcontent-%COMP%]{top:0;right:0;position:absolute}tb-histogram[_ngcontent-%COMP%]{flex-grow:1}.empty-message[_ngcontent-%COMP%]{margin-top:1em;font-size:13px}'],changeDetection:0}),n})(),Cpe=(()=>{class n{constructor(e){this.store=e,this.fullWidthChanged=new G,this.fullHeightChanged=new G,this.pinStateChanged=new G,this.mode$=this.store.select(RI),this.xAxisType$=this.store.select(td),this.showFullSize=!1}isHistogramCardMetadata(e){let{plugin:i}=e;return i===ri.HISTOGRAMS}onFullSizeToggle(){this.showFullSize=!this.showFullSize,this.fullWidthChanged.emit(this.showFullSize),this.fullHeightChanged.emit(this.showFullSize)}ngOnInit(){let i=this.store.select(tc,this.cardId).pipe(Ye(o=>!!o&&this.isHistogramCardMetadata(o)),L(o=>o)),r=Lt([i,this.store.select(xh,this.cardId)]);this.data$=r.pipe(L(([o,s])=>{let a=o.runId;return s&&s.hasOwnProperty(a)?function(n,t=30){if(!n.length||t<1)return[];let e=function(n){let t=null,e=null;for(let{bins:i}of n){if(!i.length)continue;let r=i[i.length-1],o=i[0].x,s=r.x+r.dx;(null===t||o<t)&&(t=o),(null===e||s>e)&&(e=s)}return null===t||null===e?null:{left:t,right:e}}(n);return e&&e.left===e.right&&(e.right=1.1*e.right+1,e.left=e.left/1.1-1),n.map(i=>({step:i.step,wallTime:i.wallTime,bins:e?QYe(i.bins,e,t):[]}))}(s[a].map(u=>{let{wallTime:d,step:p}=u;return{wallTime:d,step:p,bins:u.bins.map(f=>({x:f.min,dx:f.max-f.min,y:f.count}))}})):[]})),this.steps$=this.data$.pipe(L(o=>o.map(s=>s.step))),this.linkedTimeSelection$=Lt([this.store.select(Xm),this.steps$]).pipe(L(([o,s])=>{if(!o)return null;let a=1/0,l=-1/0;for(let u of s)a=Math.min(u,a),l=Math.max(u,l);return function(n,t){if(null!==n.endStep)return n;let e=function(n,t){let e=1/0,i=null;for(let r of t){let o=Math.abs(n-r);o<e&&(e=o,i=r)}return i}(n.startStep,t);return null!==e?{...n,startStep:e}:n}(Qh(o,a,l),s)})),this.isClosestStepHighlighted$=Lt([this.store.select(Xm),this.linkedTimeSelection$]).pipe(L(([o,s])=>o&&s&&!s.clipped&&null===o.end&&o.start.step!==s.startStep)),this.loadState$=this.store.select(bh,this.cardId),this.tag$=i.pipe(L(o=>o.tag)),this.title$=this.tag$.pipe(L(o=>ly(o,this.groupName))),this.runId$=i.pipe(L(o=>o.runId)),this.isPinned$=this.store.select(Ch,this.cardId)}onLinkedTimeSelectionChanged(e){this.store.dispatch(Yh(e))}onLinkedTimeToggled(){this.store.dispatch(Xh({affordance:bl.FOB_DESELECT}))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["histogram-card"]],inputs:{cardId:"cardId",groupName:"groupName",runColorScale:"runColorScale"},outputs:{fullWidthChanged:"fullWidthChanged",fullHeightChanged:"fullHeightChanged",pinStateChanged:"pinStateChanged"},decls:11,vars:32,consts:[[3,"loadState","title","tag","runId","data","mode","xAxisType","runColorScale","showFullSize","isPinned","isClosestStepHighlighted","linkedTimeSelection","onFullSizeToggle","onPinClicked","onLinkedTimeSelectionChanged","onLinkedTimeToggled"]],template:function(e,i){1&e&&(_(0,"histogram-card-component",0),P("onFullSizeToggle",function(){return i.onFullSizeToggle()})("onPinClicked",function(o){return i.pinStateChanged.emit(o)})("onLinkedTimeSelectionChanged",function(o){return i.onLinkedTimeSelectionChanged(o)})("onLinkedTimeToggled",function(){return i.onLinkedTimeToggled()}),B(1,"async"),B(2,"async"),B(3,"async"),B(4,"async"),B(5,"async"),B(6,"async"),B(7,"async"),B(8,"async"),B(9,"async"),B(10,"async"),v()),2&e&&y("loadState",U(1,12,i.loadState$))("title",U(2,14,i.title$))("tag",U(3,16,i.tag$))("runId",U(4,18,i.runId$))("data",U(5,20,i.data$))("mode",U(6,22,i.mode$))("xAxisType",U(7,24,i.xAxisType$))("runColorScale",i.runColorScale)("showFullSize",i.showFullSize)("isPinned",U(8,26,i.isPinned$))("isClosestStepHighlighted",U(9,28,i.isClosestStepHighlighted$))("linkedTimeSelection",U(10,30,i.linkedTimeSelection$))},dependencies:[xpe,Ge],styles:["[_nghost-%COMP%] {\n        display: flex;\n        flex-direction: column;\n        height: 100%;\n      }"],changeDetection:0}),n})();function SXe(n,t){if(1&n){let e=Pe();_(0,"image-card",6),P("fullWidthChanged",function(r){return oe(e),se(S(2).onFullWidthChanged(r))})("pinStateChanged",function(){return oe(e),se(S(2).onPinStateChanged())}),v()}if(2&n){let e=S(2);y("cardId",e.cardId)("groupName",e.groupName)("runColorScale",e.runColorScale)}}function EXe(n,t){if(1&n){let e=Pe();_(0,"scalar-card",7),P("fullWidthChanged",function(r){return oe(e),se(S(2).onFullWidthChanged(r))})("fullHeightChanged",function(r){return oe(e),se(S(2).onFullHeightChanged(r))})("pinStateChanged",function(){return oe(e),se(S(2).onPinStateChanged())}),v()}if(2&n){let e=S(2);y("cardId",e.cardId)("groupName",e.groupName)}}function TXe(n,t){if(1&n){let e=Pe();_(0,"histogram-card",8),P("fullWidthChanged",function(r){return oe(e),se(S(2).onFullWidthChanged(r))})("fullHeightChanged",function(r){return oe(e),se(S(2).onFullHeightChanged(r))})("pinStateChanged",function(){return oe(e),se(S(2).onPinStateChanged())}),v()}if(2&n){let e=S(2);y("cardId",e.cardId)("groupName",e.groupName)("runColorScale",e.runColorScale)}}function DXe(n,t){if(1&n&&(_(0,"div"),A(1),v()),2&n){let e=S(2);C(1),je("Placeholder error for: ",e.cardId,"")}}function AXe(n,t){if(1&n&&(sn(0,1),E(1,SXe,1,3,"image-card",2),E(2,EXe,1,2,"scalar-card",3),E(3,TXe,1,3,"histogram-card",4),E(4,DXe,2,1,"div",5),an()),2&n){let e=S();y("ngSwitch",e.pluginType),C(1),y("ngSwitchCase",e.PluginType.IMAGES),C(1),y("ngSwitchCase",e.PluginType.SCALARS),C(1),y("ngSwitchCase",e.PluginType.HISTOGRAMS)}}var Mpe=(()=>{class n{constructor(){this.PluginType=ri,this.fullWidthChanged=new G,this.fullHeightChanged=new G,this.pinStateChanged=new G}onFullWidthChanged(e){this.fullWidthChanged.emit(e)}onFullHeightChanged(e){this.fullHeightChanged.emit(e)}onPinStateChanged(){this.pinStateChanged.emit()}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["card-view-component"]],inputs:{isEverVisible:"isEverVisible",cardId:"cardId",groupName:"groupName",pluginType:"pluginType",runColorScale:"runColorScale"},outputs:{fullWidthChanged:"fullWidthChanged",fullHeightChanged:"fullHeightChanged",pinStateChanged:"pinStateChanged"},decls:1,vars:1,consts:[[3,"ngSwitch",4,"ngIf"],[3,"ngSwitch"],[3,"cardId","groupName","runColorScale","fullWidthChanged","pinStateChanged",4,"ngSwitchCase"],[3,"cardId","groupName","fullWidthChanged","fullHeightChanged","pinStateChanged",4,"ngSwitchCase"],[3,"cardId","groupName","runColorScale","fullWidthChanged","fullHeightChanged","pinStateChanged",4,"ngSwitchCase"],[4,"ngSwitchDefault"],[3,"cardId","groupName","runColorScale","fullWidthChanged","pinStateChanged"],[3,"cardId","groupName","fullWidthChanged","fullHeightChanged","pinStateChanged"],[3,"cardId","groupName","runColorScale","fullWidthChanged","fullHeightChanged","pinStateChanged"]],template:function(e,i){1&e&&E(0,AXe,5,4,"ng-container",0),2&e&&y("ngIf",i.isEverVisible)},dependencies:[Be,Cr,Ur,ch,nse,_pe,Cpe],encapsulation:2,changeDetection:0}),n})(),wpe=(()=>{class n{constructor(e){this.store=e,this.isEverVisible=!1,this.fullWidthChanged=new G,this.fullHeightChanged=new G,this.runColorScale$=this.store.select(nc).pipe(b0(350,void 0,{leading:!0,trailing:!0}),L(i=>r=>i.hasOwnProperty(r)?i[r]:"#fff"))}onVisibilityChange({visible:e}){this.isEverVisible=this.isEverVisible||e}onFullWidthChanged(e){this.fullWidthChanged.emit(e)}onFullHeightChanged(e){this.fullHeightChanged.emit(e)}onPinStateChanged(){this.store.select(Ch,this.cardId).pipe(Qt(1),Wt(this.store.select(yee))).subscribe(([e,i])=>{this.store.dispatch(ry({cardId:this.cardId,canCreateNewPins:i,wasPinned:e}))})}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["card-view"]],inputs:{cardId:"cardId",groupName:"groupName",pluginType:"pluginType"},outputs:{fullWidthChanged:"fullWidthChanged",fullHeightChanged:"fullHeightChanged"},decls:2,vars:7,consts:[["observeIntersection","","intersectionObserverMargin","200px 200px 200px 200px",3,"isEverVisible","cardId","groupName","pluginType","runColorScale","fullWidthChanged","fullHeightChanged","pinStateChanged","onVisibilityChange"]],template:function(e,i){1&e&&(_(0,"card-view-component",0),P("fullWidthChanged",function(o){return i.onFullWidthChanged(o)})("fullHeightChanged",function(o){return i.onFullHeightChanged(o)})("pinStateChanged",function(){return i.onPinStateChanged()})("onVisibilityChange",function(o){return i.onVisibilityChange(o)}),B(1,"async"),v()),2&e&&y("isEverVisible",i.isEverVisible)("cardId",i.cardId)("groupName",i.groupName)("pluginType",i.pluginType)("runColorScale",U(1,5,i.runColorScale$))},dependencies:[ay,Mpe,Ge],styles:["[_nghost-%COMP%]{background-color:#fff}body.dark-mode   [_nghost-%COMP%]{background-color:#303030}"],changeDetection:0}),n})();function OXe(n,t){1&n&&Ni(0)}var kXe=function(n,t){return{"full-width":n,"full-height":t}};function FXe(n,t){if(1&n){let e=Pe();_(0,"div",5)(1,"card-view",6),P("fullWidthChanged",function(r){let s=oe(e).$implicit;return se(S(2).onFullWidthChanged(s.cardId,r))})("fullHeightChanged",function(r){let s=oe(e).$implicit;return se(S(2).onFullHeightChanged(s.cardId,r))}),v()()}if(2&n){let e=t.$implicit,i=S(2);y("ngClass",Qr(6,kXe,i.cardsAtFullWidth.has(e.cardId),i.cardsAtFullHeight.has(e.cardId))),C(1),y("cardId",e.cardId)("groupName",i.groupName)("pluginType",e.plugin)("cardObserver",i.cardObserver)("cardLazyLoader",e.cardId)}}function NXe(n,t){1&n&&Ni(0)}var LXe=function(){return{isBottomControl:!1}},BXe=function(){return{isBottomControl:!0}};function VXe(n,t){if(1&n&&(_(0,"div"),E(1,OXe,1,0,"ng-container",2),_(2,"div",3),E(3,FXe,2,9,"div",4),v(),E(4,NXe,1,0,"ng-container",2),v()),2&n){let e=S(),i=$e(2);C(1),y("ngTemplateOutlet",i)("ngTemplateOutletContext",Qp(8,LXe)),C(1),Pt("grid-template-columns",e.gridTemplateColumn),C(1),y("ngForOf",e.cardIdsWithMetadata)("ngForTrackBy",e.trackByCards),C(1),y("ngTemplateOutlet",i)("ngTemplateOutletContext",Qp(9,BXe))}}function HXe(n,t){if(1&n){let e=Pe();_(0,"button",12),P("click",function(r){oe(e);let o=S(3);return se(o.handlePageChange(o.pageIndex-1,r.target))}),A(1," Previous "),v()}2&n&&y("disabled",0===S(3).pageIndex)}function UXe(n,t){if(1&n){let e=Pe();_(0,"span",15)(1,"input",16),P("input",function(r){return oe(e),se(S(4).onPaginationInputChange(r))})("change",function(r){return oe(e),se(S(4).onPaginationInputChange(r))}),v(),A(2),v()}if(2&n){let e=S(4);C(1),y("value",e.pageIndex+1)("max",e.numPages),C(1),je(" of ",e.numPages,"")}}function zXe(n,t){if(1&n){let e=Pe();_(0,"span"),E(1,UXe,3,3,"span",13),_(2,"button",14),P("click",function(r){oe(e);let o=S(3);return se(o.handlePageChange(o.pageIndex+1,r.target))}),A(3," Next "),v()()}if(2&n){let e=S(2).isBottomControl,i=S();C(1),y("ngIf",i.showPaginationInput(e)),C(1),y("disabled",i.pageIndex+1>=i.numPages)}}function jXe(n,t){if(1&n&&(_(0,"div",8)(1,"span",9),E(2,HXe,2,1,"button",10),v(),_(3,"span",11),E(4,zXe,4,2,"span",0),v()()),2&n){let e=S(2);C(2),y("ngIf",e.showPaginationControls),C(2),y("ngIf",e.showPaginationControls)}}function GXe(n,t){1&n&&E(0,jXe,5,2,"div",7),2&n&&y("ngIf",S().showPaginationControls)}var Spe=(()=>{class n{constructor(e){this.cdkScrollable=e,this.PluginType=ri,this.gridTemplateColumn="",this.cardsAtFullWidth=new Set,this.cardsAtFullHeight=new Set,this.pageIndexChanged=new G}ngOnInit(){this.isCardWidthValid(this.cardMinWidth)&&(this.gridTemplateColumn=`repeat(auto-fill, minmax(${this.cardMinWidth}px, 1fr))`)}ngOnChanges(e){if(e.cardMinWidth){let i=e.cardMinWidth.currentValue;this.isCardWidthValid(i)?(this.cardMinWidth=i,this.gridTemplateColumn=`repeat(auto-fill, minmax(${this.cardMinWidth}px, 1fr))`):this.gridTemplateColumn=""}}isCardWidthValid(e){return e&&e>=335&&e<=735}showPaginationInput(e){return e}handlePageChange(e,i){let r=i.getBoundingClientRect().top;setTimeout(()=>{this.scrollToKeepTargetPosition(i,r)},0),this.pageIndexChanged.emit(e)}scrollToKeepTargetPosition(e,i){let r=this.cdkScrollable?.getElementRef().nativeElement;r&&r.scrollTo(0,e.getBoundingClientRect().top-i+r.scrollTop)}trackByCards(e,i){return i.cardId}onPaginationInputChange(e){let i=e.target;if("input"===e.type&&""===i.value)return;let r=Number(i.value)-1,o=Math.min(Math.max(0,r),this.numPages-1);i.value!==String(o+1)&&(i.value=String(o+1)),this.handlePageChange(o,i)}onFullWidthChanged(e,i){i?this.cardsAtFullWidth.add(e):this.cardsAtFullWidth.delete(e)}onFullHeightChanged(e,i){i?this.cardsAtFullHeight.add(e):this.cardsAtFullHeight.delete(e)}}return n.\u0275fac=function(e){return new(e||n)(M(Ih,8))},n.\u0275cmp=R({type:n,selectors:[["metrics-card-grid-component"]],inputs:{isGroupExpanded:"isGroupExpanded",pageIndex:"pageIndex",numPages:"numPages",cardIdsWithMetadata:"cardIdsWithMetadata",cardMinWidth:"cardMinWidth",cardObserver:"cardObserver",showPaginationControls:"showPaginationControls"},outputs:{pageIndexChanged:"pageIndexChanged"},features:[Ft],decls:3,vars:1,consts:function(){let t,e;return t=$localize`:A button that sets a group to the previous page.␟575e782fd27f2ee70a034a775efe9ad162472250␟3629960544875360046:Previous page`,e=$localize`:A button that sets a group to the next page.␟ce3cefb1cd0099aa5003dda16ec9eb21fd8ba789␟3337301694210287595:Next page`,[[4,"ngIf"],["groupControls",""],[4,"ngTemplateOutlet","ngTemplateOutletContext"],[1,"card-grid"],["class","card-space",3,"ngClass",4,"ngFor","ngForOf","ngForTrackBy"],[1,"card-space",3,"ngClass"],[3,"cardId","groupName","pluginType","cardObserver","cardLazyLoader","fullWidthChanged","fullHeightChanged"],["class","group-controls",4,"ngIf"],[1,"group-controls"],[1,"prev-container"],["class","prev pagination-button","mat-button","","aria-label",t,3,"disabled","click",4,"ngIf"],[1,"input-and-next-container"],["mat-button","","aria-label",t,1,"prev","pagination-button",3,"disabled","click"],["class","pagination-input",4,"ngIf"],["mat-button","","aria-label",e,1,"next","pagination-button",3,"disabled","click"],[1,"pagination-input"],["type","number","min","1",3,"value","max","input","change"]]},template:function(e,i){1&e&&(E(0,VXe,5,10,"div",0),E(1,GXe,1,1,"ng-template",null,1,qt)),2&e&&y("ngIf",i.isGroupExpanded)},dependencies:[Ooe,wpe,Fn,dn,Be,os,_n],styles:["[_nghost-%COMP%]{contain:content}.card-grid[_ngcontent-%COMP%]{display:grid;grid-template-columns:repeat(auto-fill, minmax(335px, 1fr));gap:16px;padding:16px}.card-space.full-width[_ngcontent-%COMP%]{grid-column-start:1;grid-column-end:-1}.card-space.full-height[_ngcontent-%COMP%]{min-height:480px}.card-space.full-height[_ngcontent-%COMP%]   card-view[_ngcontent-%COMP%]{height:100%}card-view[_ngcontent-%COMP%]{border:1px solid #ebebeb;border-radius:4px;box-sizing:border-box;contain:layout paint;display:block;min-height:320px}body.dark-mode[_nghost-%COMP%]   card-view[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   card-view[_ngcontent-%COMP%]{border:1px solid #555}.group-controls[_ngcontent-%COMP%]{color:#616161;display:grid;align-items:center;grid-template-columns:1fr 1fr;gap:16px;padding:0 16px}body.dark-mode[_nghost-%COMP%]   .group-controls[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group-controls[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.group-controls[_ngcontent-%COMP%]:first-of-type{padding-top:16px}.group-controls[_ngcontent-%COMP%]:last-of-type{padding-bottom:16px}.prev-container[_ngcontent-%COMP%]{justify-self:flex-start}.input-and-next-container[_ngcontent-%COMP%]{justify-self:flex-end}.pagination-input[_ngcontent-%COMP%]{margin-right:16px}.pagination-input[_ngcontent-%COMP%]   input[_ngcontent-%COMP%]{background:rgba(0,0,0,0);border:1px solid currentColor;color:inherit;font:inherit}.pagination-button[_ngcontent-%COMP%]{color:#616161;background-color:#fff}body.dark-mode[_nghost-%COMP%]   .pagination-button[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .pagination-button[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.pagination-button[_ngcontent-%COMP%]:disabled{color:#757575}body.dark-mode[_nghost-%COMP%]   .pagination-button[_ngcontent-%COMP%]:disabled, body.dark-mode   [_nghost-%COMP%]   .pagination-button[_ngcontent-%COMP%]:disabled{color:#616161}"],changeDetection:0}),n})(),Ab=(()=>{class n{constructor(e){this.store=e,this.groupName=null,this.groupName$=new hr(null),this.pageIndex$=new hr(0),this.items$=new hr([]),this.ngUnsubscribe=new ke,this.numPages$=Lt([this.items$,this.store.select(Na.getPageSize)]).pipe(L(([i,r])=>Math.ceil(i.length/r))),this.isGroupExpanded$=this.groupName$.pipe(ui(i=>null!==i?this.store.select(LI,i):Xt(!0))),this.showPaginationControls$=this.numPages$.pipe(L(i=>i>1)),this.normalizedPageIndex$=Lt([this.pageIndex$,this.numPages$]).pipe(st(this.ngUnsubscribe),kt(([i,r])=>{0!==r&&(i>=r?this.pageIndex$.next(r-1):i<0&&this.pageIndex$.next(0))}),L(([i,r])=>Math.min(Math.max(i,0),r-1)),Ma(1)),this.pagedItems$=Lt([this.items$,this.store.select(Na.getPageSize),this.normalizedPageIndex$,this.isGroupExpanded$]).pipe(L(([i,r,o,s])=>i.slice(r*o,r*o+(s?r:0)))),this.cardMinWidth$=this.store.select(dv)}ngOnChanges(e){e.cardIdsWithMetadata&&this.items$.next(this.cardIdsWithMetadata),e.groupName&&this.groupName$.next(this.groupName)}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}onPageIndexChanged(e){this.pageIndex$.next(e)}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["metrics-card-grid"]],inputs:{groupName:"groupName",cardIdsWithMetadata:"cardIdsWithMetadata",cardObserver:"cardObserver"},features:[Ft],decls:7,vars:19,consts:[[3,"isGroupExpanded","pageIndex","numPages","showPaginationControls","cardIdsWithMetadata","cardMinWidth","cardObserver","pageIndexChanged"]],template:function(e,i){1&e&&(_(0,"metrics-card-grid-component",0),P("pageIndexChanged",function(o){return i.onPageIndexChanged(o)}),B(1,"async"),B(2,"async"),B(3,"async"),B(4,"async"),B(5,"async"),B(6,"async"),v()),2&e&&y("isGroupExpanded",U(1,7,i.isGroupExpanded$))("pageIndex",U(2,9,i.normalizedPageIndex$))("numPages",U(3,11,i.numPages$))("showPaginationControls",U(4,13,i.showPaginationControls$))("cardIdsWithMetadata",U(5,15,i.pagedItems$))("cardMinWidth",U(6,17,i.cardMinWidth$))("cardObserver",i.cardObserver)},dependencies:[Spe,Ge],encapsulation:2,changeDetection:0}),n})();function XXe(n,t){if(1&n&&(_(0,"span",7),A(1),B(2,"number"),v()),2&n){let e=S();C(1),je("",U(2,1,e.numberOfCards)," cards")}}function QXe(n,t){1&n&&O(0,"mat-icon",8)}function KXe(n,t){1&n&&O(0,"mat-icon",9)}var Epe=(()=>{class n{constructor(){this.groupExpansionToggled=new G}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["metrics-card-group-toolbar-component"]],inputs:{groupName:"groupName",numberOfCards:"numberOfCards",isGroupExpanded:"isGroupExpanded"},outputs:{groupExpansionToggled:"groupExpansionToggled"},decls:9,vars:5,consts:function(){let t;return t=$localize`:A button that allows user to expand a tag group.␟ffaa11471b878a6dffe2e68c6f37064a9e074853␟5386054325274779258:Expand group`,[["aria-label",t,1,"group-toolbar",3,"click"],[1,"group-title-wrapper"],["aria-role","heading","aria-level","3",1,"group-title",3,"title"],["class","group-card-count",4,"ngIf"],[1,"expand-group-icon"],["svgIcon","expand_less_24px",4,"ngIf","ngIfElse"],["expandMore",""],[1,"group-card-count"],["svgIcon","expand_less_24px"],["svgIcon","expand_more_24px"]]},template:function(e,i){if(1&e&&(_(0,"button",0),P("click",function(){return i.groupExpansionToggled.emit()}),_(1,"span",1)(2,"span",2),A(3),v(),E(4,XXe,3,3,"span",3),v(),_(5,"span",4),E(6,QXe,1,0,"mat-icon",5),E(7,KXe,1,0,"ng-template",null,6,qt),v()()),2&e){let r=$e(8);C(2),Zi("title",i.groupName),C(1),yt(i.groupName),C(1),y("ngIf",i.numberOfCards>1),C(2),y("ngIf",i.isGroupExpanded)("ngIfElse",r)}},dependencies:[Be,Gt,Ql],styles:["[_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#fff;border-bottom:1px solid #ebebeb;align-items:center;background-color:#fff;display:flex;flex:none;height:42px;margin-bottom:-1px;padding:0 16px;position:sticky;top:0;z-index:1;box-shadow:0px 2px 4px 0px rgba(0,0,0,.15)}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#303030}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{box-shadow:0px 2px 4px 0px rgba(255,255,255,.15)}[_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border:0;border-top:1px solid #ebebeb;color:#212121;top:-1px;display:flex;width:100%;font:inherit}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border-top:1px solid #555}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{color:#fff}.card-group:first-of-type   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border-top:0}[_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]:hover{cursor:pointer}.expand-group-icon[_ngcontent-%COMP%]{color:#616161}body.dark-mode[_nghost-%COMP%]   .expand-group-icon[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .expand-group-icon[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.expand-group-icon[_ngcontent-%COMP%]:disabled{color:#757575}body.dark-mode[_nghost-%COMP%]   .expand-group-icon[_ngcontent-%COMP%]:disabled, body.dark-mode   [_nghost-%COMP%]   .expand-group-icon[_ngcontent-%COMP%]:disabled{color:#616161}.group-title-wrapper[_ngcontent-%COMP%]{flex-grow:1;text-align:left}.group-title[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.group-card-count[_ngcontent-%COMP%]{font-size:12px;font-weight:400;color:#616161;margin-left:6px}body.dark-mode[_nghost-%COMP%]   .group-card-count[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group-card-count[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}"],changeDetection:0}),n})(),Tpe=(()=>{class n{constructor(e){this.store=e,this.groupName=null,this.isGroupExpanded$=Xt(!1)}ngOnInit(){this.isGroupExpanded$=null!==this.groupName?this.store.select(LI,this.groupName):Xt(!1)}onGroupExpansionToggled(){if(null===this.groupName)throw new RangeError("Invariant error: expansion cannot be toggled when groupName is null");this.store.dispatch(aR({tagGroup:this.groupName}))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["metrics-card-group-toolbar"]],inputs:{groupName:"groupName",numberOfCards:"numberOfCards"},decls:2,vars:5,consts:[[3,"numberOfCards","isGroupExpanded","groupName","groupExpansionToggled"]],template:function(e,i){1&e&&(_(0,"metrics-card-group-toolbar-component",0),P("groupExpansionToggled",function(){return i.onGroupExpansionToggled()}),B(1,"async"),v()),2&e&&y("numberOfCards",i.numberOfCards)("isGroupExpanded",U(1,3,i.isGroupExpanded$))("groupName",i.groupName)},dependencies:[Epe,Ge],encapsulation:2,changeDetection:0}),n})();function $Xe(n,t){if(1&n&&(_(0,"div",1),O(1,"metrics-card-group-toolbar",2)(2,"metrics-card-grid",3),v()),2&n){let e=t.$implicit,i=S();C(1),y("numberOfCards",e.items.length)("groupName",e.groupName),C(1),y("cardIdsWithMetadata",e.items)("cardObserver",i.cardObserver)("groupName",e.groupName)}}var Dpe=(()=>{class n{constructor(){this.PluginType=ri}trackByGroup(e,i){return i.groupName}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["metrics-card-groups-component"]],inputs:{cardGroups:"cardGroups",cardObserver:"cardObserver"},decls:1,vars:2,consts:[["class","card-group",4,"ngFor","ngForOf","ngForTrackBy"],[1,"card-group"],[3,"numberOfCards","groupName"],[3,"cardIdsWithMetadata","cardObserver","groupName"]],template:function(e,i){1&e&&E(0,$Xe,3,5,"div",0),2&e&&y("ngForOf",i.cardGroups)("ngForTrackBy",i.trackByGroup)},dependencies:[dn,Ab,Tpe],styles:["[_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#fff;border-bottom:1px solid #ebebeb;align-items:center;background-color:#fff;display:flex;flex:none;height:42px;margin-bottom:-1px;padding:0 16px;position:sticky;top:0;z-index:1;box-shadow:0px 2px 4px 0px rgba(0,0,0,.15)}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#303030}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{box-shadow:0px 2px 4px 0px rgba(255,255,255,.15)}"],changeDetection:0}),n})(),Ape=(()=>{class n{constructor(e){this.store=e,this.cardGroups$=this.store.select(mg).pipe(fr(this.store.select(nd)),L(([i,r])=>r.size?i.filter(o=>r.has(o.plugin)):i),L(i=>fR(i)))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["metrics-card-groups"]],inputs:{cardObserver:"cardObserver"},decls:2,vars:4,consts:[[3,"cardGroups","cardObserver"]],template:function(e,i){1&e&&(O(0,"metrics-card-groups-component",0),B(1,"async")),2&e&&y("cardGroups",U(1,2,i.cardGroups$))("cardObserver",i.cardObserver)},dependencies:[Dpe,Ge],encapsulation:2,changeDetection:0}),n})();function nQe(n,t){if(1&n&&(_(0,"span"),A(1),v()),2&n){let e=S();C(1),je(" and ",e.getPluginTypeFilterString(e.pluginTypes)," visualization filter")}}var Ipe=(()=>{class n{constructor(){this.PluginType=ri,this.listFormatter=new Intl.ListFormat(void 0,{style:"long",type:"disjunction"})}getPluginTypeFilterString(e){let i=[...e].map(r=>{switch(r){case ri.SCALARS:return"scalar";case ri.IMAGES:return"image";case ri.HISTOGRAMS:return"histogram";default:throw new RangeError(`Please implement human readable name for plugin type: ${r}`)}});return this.listFormatter.format(i)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["metrics-empty-tag-match-component"]],inputs:{pluginTypes:"pluginTypes",tagFilterRegex:"tagFilterRegex",tagCounts:"tagCounts"},decls:6,vars:5,consts:[[4,"ngIf"]],template:function(e,i){1&e&&(A(0,"No matches for tag filter "),_(1,"code"),A(2),v(),E(3,nQe,2,1,"span",0),A(4),B(5,"number")),2&e&&(C(2),je("/",i.tagFilterRegex,"/"),C(1),y("ngIf",i.pluginTypes.size),C(1),je(" out of ",U(5,3,i.tagCounts)," tags."))},dependencies:[Be,Ql],encapsulation:2,changeDetection:0}),n})(),Ppe=(()=>{class n{constructor(e){this.store=e,this.pluginTypes$=this.store.select(nd),this.tagFilterRegex$=this.store.select(Xc),this.tagCounts$=this.store.select(mg).pipe(L(i=>new Set(i.map(({tag:r})=>r)).size))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["metrics-empty-tag-match"]],decls:4,vars:9,consts:[[3,"pluginTypes","tagFilterRegex","tagCounts"]],template:function(e,i){1&e&&(O(0,"metrics-empty-tag-match-component",0),B(1,"async"),B(2,"async"),B(3,"async")),2&e&&y("pluginTypes",U(1,3,i.pluginTypes$))("tagFilterRegex",U(2,5,i.tagFilterRegex$))("tagCounts",U(3,7,i.tagCounts$))},dependencies:[Ipe,Ge],encapsulation:2,changeDetection:0}),n})();function oQe(n,t){if(1&n&&(_(0,"span",6),A(1),B(2,"number"),v()),2&n){let e=S();C(1),je("",U(2,1,e.cardIdsWithMetadata.length)," cards")}}function sQe(n,t){1&n&&O(0,"metrics-empty-tag-match",7)}var Rpe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["metrics-filtered-view-component"]],inputs:{isEmptyMatch:"isEmptyMatch",cardObserver:"cardObserver",cardIdsWithMetadata:"cardIdsWithMetadata"},decls:7,vars:4,consts:[[1,"group-toolbar"],[1,"group-text"],["aria-role","heading","aria-level","3",1,"group-title"],["class","group-card-count",4,"ngIf"],["class","warn",4,"ngIf"],[3,"cardIdsWithMetadata","cardObserver"],[1,"group-card-count"],[1,"warn"]],template:function(e,i){1&e&&(_(0,"div",0)(1,"span",1)(2,"span",2),A(3,"Tags matching filter"),v(),E(4,oQe,3,3,"span",3),v()(),E(5,sQe,1,0,"metrics-empty-tag-match",4),O(6,"metrics-card-grid",5)),2&e&&(C(4),y("ngIf",i.cardIdsWithMetadata.length>1),C(1),y("ngIf",i.isEmptyMatch),C(1),y("cardIdsWithMetadata",i.cardIdsWithMetadata)("cardObserver",i.cardObserver))},dependencies:[Be,Ab,Ppe,Ql],styles:["[_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#fff;border-bottom:1px solid #ebebeb;align-items:center;background-color:#fff;display:flex;flex:none;height:42px;margin-bottom:-1px;padding:0 16px;position:sticky;top:0;z-index:1;box-shadow:0px 2px 4px 0px rgba(0,0,0,.15)}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#303030}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{box-shadow:0px 2px 4px 0px rgba(255,255,255,.15)}.group-text[_ngcontent-%COMP%]{display:flex;align-items:baseline}.group-title[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.group-card-count[_ngcontent-%COMP%]{font-size:12px;font-weight:400;color:#616161;margin-left:6px}body.dark-mode[_nghost-%COMP%]   .group-card-count[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group-card-count[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}metrics-empty-tag-match[_ngcontent-%COMP%]{color:#616161;font-size:13px;font-style:italic;padding:16px;text-align:center;display:block}body.dark-mode[_nghost-%COMP%]   metrics-empty-tag-match[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   metrics-empty-tag-match[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}"],changeDetection:0}),n})(),Ope=(()=>{class n{constructor(e){this.store=e,this.cardIdsWithMetadata$=this.store.select(mg).pipe(fr(this.store.select(nd)),L(([i,r])=>r.size?i.filter(o=>r.has(o.plugin)):i),fr(this.store.select(Xc)),Hr(200),L(([i,r])=>{try{return{cardList:i,regex:new RegExp(r,"i")}}catch{return{cardList:i,regex:null}}}),Ye(({regex:i})=>null!==i),L(({cardList:i,regex:r})=>i.filter(({tag:o})=>r.test(o))),yi((i,r)=>i.length===r.length&&i.every((o,s)=>o.cardId===r[s].cardId)),Ts(),zn([])),this.isEmptyMatch$=this.cardIdsWithMetadata$.pipe(fr(this.store.select(mg)),L(([i,r])=>Boolean(r.length)&&0===i.length))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["metrics-filtered-view"]],inputs:{cardObserver:"cardObserver"},decls:3,vars:7,consts:[[3,"isEmptyMatch","cardIdsWithMetadata","cardObserver"]],template:function(e,i){1&e&&(O(0,"metrics-filtered-view-component",0),B(1,"async"),B(2,"async")),2&e&&y("isEmptyMatch",U(1,3,i.isEmptyMatch$))("cardIdsWithMetadata",U(2,5,i.cardIdsWithMetadata$))("cardObserver",i.cardObserver)},dependencies:[Rpe,Ge],encapsulation:2,changeDetection:0}),n})(),uQe=["panel"];function dQe(n,t){if(1&n&&(_(0,"div",0,1),Vn(2),v()),2&n){let e=t.id,i=S();y("id",i.id)("ngClass",i._classList),ze("aria-label",i.ariaLabel||null)("aria-labelledby",i._getPanelAriaLabelledby(e))}}var pQe=["*"],hQe=0,fQe=qo(class{}),kpe=new pe("mat-autocomplete-default-options",{providedIn:"root",factory:function(){return{autoActiveFirstOption:!1,autoSelectActiveOption:!1}}}),gQe=(()=>{class n extends fQe{constructor(e,i,r,o){super(),this._changeDetectorRef=e,this._elementRef=i,this._activeOptionChanges=Sn.EMPTY,this.showPanel=!1,this._isOpen=!1,this.displayWith=null,this.optionSelected=new G,this.opened=new G,this.closed=new G,this.optionActivated=new G,this._classList={},this.id="mat-autocomplete-"+hQe++,this.inertGroups=o?.SAFARI||!1,this._autoActiveFirstOption=!!r.autoActiveFirstOption,this._autoSelectActiveOption=!!r.autoSelectActiveOption}get isOpen(){return this._isOpen&&this.showPanel}get autoActiveFirstOption(){return this._autoActiveFirstOption}set autoActiveFirstOption(e){this._autoActiveFirstOption=Rt(e)}get autoSelectActiveOption(){return this._autoSelectActiveOption}set autoSelectActiveOption(e){this._autoSelectActiveOption=Rt(e)}set classList(e){this._classList=e&&e.length?function(n,t=/\s+/){let e=[];if(null!=n){let i=Array.isArray(n)?n:`${n}`.split(t);for(let r of i){let o=`${r}`.trim();o&&e.push(o)}}return e}(e).reduce((i,r)=>(i[r]=!0,i),{}):{},this._setVisibilityClasses(this._classList),this._elementRef.nativeElement.className=""}ngAfterContentInit(){this._keyManager=new wv(this.options).withWrap(),this._activeOptionChanges=this._keyManager.change.subscribe(e=>{this.isOpen&&this.optionActivated.emit({source:this,option:this.options.toArray()[e]||null})}),this._setVisibility()}ngOnDestroy(){this._activeOptionChanges.unsubscribe()}_setScrollTop(e){this.panel&&(this.panel.nativeElement.scrollTop=e)}_getScrollTop(){return this.panel?this.panel.nativeElement.scrollTop:0}_setVisibility(){this.showPanel=!!this.options.length,this._setVisibilityClasses(this._classList),this._changeDetectorRef.markForCheck()}_emitSelectEvent(e){let i=new class{constructor(t,e){this.source=t,this.option=e}}(this,e);this.optionSelected.emit(i)}_getPanelAriaLabelledby(e){return this.ariaLabel?null:this.ariaLabelledby?(e?e+" ":"")+this.ariaLabelledby:e}_setVisibilityClasses(e){e[this._visibleClass]=this.showPanel,e[this._hiddenClass]=!this.showPanel}}return n.\u0275fac=function(e){return new(e||n)(M(nn),M(Re),M(kpe),M(oi))},n.\u0275dir=He({type:n,viewQuery:function(e,i){if(1&e&&(ot(Vi,7),ot(uQe,5)),2&e){let r;Ne(r=Le())&&(i.template=r.first),Ne(r=Le())&&(i.panel=r.first)}},inputs:{ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],displayWith:"displayWith",autoActiveFirstOption:"autoActiveFirstOption",autoSelectActiveOption:"autoSelectActiveOption",panelWidth:"panelWidth",classList:["class","classList"]},outputs:{optionSelected:"optionSelected",opened:"opened",closed:"closed",optionActivated:"optionActivated"},features:[tt]}),n})(),qk=(()=>{class n extends gQe{constructor(){super(...arguments),this._visibleClass="mat-autocomplete-visible",this._hiddenClass="mat-autocomplete-hidden"}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275cmp=R({type:n,selectors:[["mat-autocomplete"]],contentQueries:function(e,i,r){if(1&e&&(Ei(r,rw,5),Ei(r,Os,5)),2&e){let o;Ne(o=Le())&&(i.optionGroups=o),Ne(o=Le())&&(i.options=o)}},hostAttrs:[1,"mat-autocomplete"],inputs:{disableRipple:"disableRipple"},exportAs:["matAutocomplete"],features:[$t([{provide:iw,useExisting:n}]),tt],ngContentSelectors:pQe,decls:1,vars:0,consts:[["role","listbox",1,"mat-autocomplete-panel",3,"id","ngClass"],["panel",""]],template:function(e,i){1&e&&(xi(),E(0,dQe,3,4,"ng-template"))},dependencies:[Fn],styles:[".mat-autocomplete-panel{min-width:112px;max-width:280px;overflow:auto;-webkit-overflow-scrolling:touch;visibility:hidden;max-width:none;max-height:256px;position:relative;width:100%;border-bottom-left-radius:4px;border-bottom-right-radius:4px}.mat-autocomplete-panel.mat-autocomplete-visible{visibility:visible}.mat-autocomplete-panel.mat-autocomplete-hidden{visibility:hidden}.mat-autocomplete-panel-above .mat-autocomplete-panel{border-radius:0;border-top-left-radius:4px;border-top-right-radius:4px}.mat-autocomplete-panel .mat-divider-horizontal{margin-top:-1px}.cdk-high-contrast-active .mat-autocomplete-panel{outline:solid 1px}mat-autocomplete{display:none}"],encapsulation:2,changeDetection:0}),n})(),Fpe=new pe("mat-autocomplete-scroll-strategy"),vQe={provide:Fpe,deps:[tr],useFactory:function(n){return()=>n.scrollStrategies.reposition()}},yQe={provide:No,useExisting:Jn(()=>$g),multi:!0},bQe=(()=>{class n{constructor(e,i,r,o,s,a,l,c,u,d,p){this._element=e,this._overlay=i,this._viewContainerRef=r,this._zone=o,this._changeDetectorRef=s,this._dir=l,this._formField=c,this._document=u,this._viewportRuler=d,this._defaults=p,this._componentDestroyed=!1,this._autocompleteDisabled=!1,this._manuallyFloatingLabel=!1,this._viewportSubscription=Sn.EMPTY,this._canOpenOnNextFocus=!0,this._closeKeyEventStream=new ke,this._windowBlurHandler=()=>{this._canOpenOnNextFocus=this._document.activeElement!==this._element.nativeElement||this.panelOpen},this._onChange=()=>{},this._onTouched=()=>{},this.position="auto",this.autocompleteAttribute="off",this._overlayAttached=!1,this.optionSelections=Qa(()=>{let h=this.autocomplete?this.autocomplete.options:null;return h?h.changes.pipe(zn(h),ui(()=>Jt(...h.map(f=>f.onSelectionChange)))):this._zone.onStable.pipe(Qt(1),ui(()=>this.optionSelections))}),this._scrollStrategy=a}get autocompleteDisabled(){return this._autocompleteDisabled}set autocompleteDisabled(e){this._autocompleteDisabled=Rt(e)}ngAfterViewInit(){let e=this._getWindow();typeof e<"u"&&this._zone.runOutsideAngular(()=>e.addEventListener("blur",this._windowBlurHandler))}ngOnChanges(e){e.position&&this._positionStrategy&&(this._setStrategyPositions(this._positionStrategy),this.panelOpen&&this._overlayRef.updatePosition())}ngOnDestroy(){let e=this._getWindow();typeof e<"u"&&e.removeEventListener("blur",this._windowBlurHandler),this._viewportSubscription.unsubscribe(),this._componentDestroyed=!0,this._destroyPanel(),this._closeKeyEventStream.complete()}get panelOpen(){return this._overlayAttached&&this.autocomplete.showPanel}openPanel(){this._attachOverlay(),this._floatLabel()}closePanel(){this._resetLabel(),this._overlayAttached&&(this.panelOpen&&this._zone.run(()=>{this.autocomplete.closed.emit()}),this.autocomplete._isOpen=this._overlayAttached=!1,this._pendingAutoselectedOption=null,this._overlayRef&&this._overlayRef.hasAttached()&&(this._overlayRef.detach(),this._closingActionsSubscription.unsubscribe()),this._componentDestroyed||this._changeDetectorRef.detectChanges())}updatePosition(){this._overlayAttached&&this._overlayRef.updatePosition()}get panelClosingActions(){return Jt(this.optionSelections,this.autocomplete._keyManager.tabOut.pipe(Ye(()=>this._overlayAttached)),this._closeKeyEventStream,this._getOutsideClickStream(),this._overlayRef?this._overlayRef.detachments().pipe(Ye(()=>this._overlayAttached)):Xt()).pipe(L(e=>e instanceof nw?e:null))}get activeOption(){return this.autocomplete&&this.autocomplete._keyManager?this.autocomplete._keyManager.activeItem:null}_getOutsideClickStream(){return Jt(_i(this._document,"click"),_i(this._document,"auxclick"),_i(this._document,"touchend")).pipe(Ye(e=>{let i=Qc(e),r=this._formField?this._formField._elementRef.nativeElement:null,o=this.connectedTo?this.connectedTo.elementRef.nativeElement:null;return this._overlayAttached&&i!==this._element.nativeElement&&this._document.activeElement!==this._element.nativeElement&&(!r||!r.contains(i))&&(!o||!o.contains(i))&&!!this._overlayRef&&!this._overlayRef.overlayElement.contains(i)}))}writeValue(e){Promise.resolve(null).then(()=>this._assignOptionValue(e))}registerOnChange(e){this._onChange=e}registerOnTouched(e){this._onTouched=e}setDisabledState(e){this._element.nativeElement.disabled=e}_handleKeydown(e){let i=e.keyCode,r=kr(e);if(27===i&&!r&&e.preventDefault(),this.activeOption&&13===i&&this.panelOpen&&!r)this.activeOption._selectViaInteraction(),this._resetActiveItem(),e.preventDefault();else if(this.autocomplete){let o=this.autocomplete._keyManager.activeItem,s=38===i||40===i;9===i||s&&!r&&this.panelOpen?this.autocomplete._keyManager.onKeydown(e):s&&this._canOpen()&&this.openPanel(),(s||this.autocomplete._keyManager.activeItem!==o)&&(this._scrollToOption(this.autocomplete._keyManager.activeItemIndex||0),this.autocomplete.autoSelectActiveOption&&this.activeOption&&(this._pendingAutoselectedOption||(this._valueBeforeAutoSelection=this._element.nativeElement.value),this._pendingAutoselectedOption=this.activeOption,this._assignOptionValue(this.activeOption.value)))}}_handleInput(e){let i=e.target,r=i.value;"number"===i.type&&(r=""==r?null:parseFloat(r)),this._previousValue!==r&&(this._previousValue=r,this._pendingAutoselectedOption=null,this._onChange(r),this._canOpen()&&this._document.activeElement===e.target&&this.openPanel())}_handleFocus(){this._canOpenOnNextFocus?this._canOpen()&&(this._previousValue=this._element.nativeElement.value,this._attachOverlay(),this._floatLabel(!0)):this._canOpenOnNextFocus=!0}_handleClick(){this._canOpen()&&!this.panelOpen&&this.openPanel()}_floatLabel(e=!1){this._formField&&"auto"===this._formField.floatLabel&&(e?this._formField._animateAndLockLabel():this._formField.floatLabel="always",this._manuallyFloatingLabel=!0)}_resetLabel(){this._manuallyFloatingLabel&&(this._formField.floatLabel="auto",this._manuallyFloatingLabel=!1)}_subscribeToClosingActions(){return Jt(this._zone.onStable.pipe(Qt(1)),this.autocomplete.options.changes.pipe(kt(()=>this._positionStrategy.reapplyLastPosition()),Ol(0))).pipe(ui(()=>(this._zone.run(()=>{let r=this.panelOpen;this._resetActiveItem(),this.autocomplete._setVisibility(),this._changeDetectorRef.detectChanges(),this.panelOpen&&this._overlayRef.updatePosition(),r!==this.panelOpen&&(this.panelOpen?this.autocomplete.opened.emit():this.autocomplete.closed.emit())}),this.panelClosingActions)),Qt(1)).subscribe(r=>this._setValueAndClose(r))}_destroyPanel(){this._overlayRef&&(this.closePanel(),this._overlayRef.dispose(),this._overlayRef=null)}_assignOptionValue(e){let i=this.autocomplete&&this.autocomplete.displayWith?this.autocomplete.displayWith(e):e;this._updateNativeInputValue(i??"")}_updateNativeInputValue(e){this._formField?this._formField._control.value=e:this._element.nativeElement.value=e,this._previousValue=e}_setValueAndClose(e){let i=e?e.source:this._pendingAutoselectedOption;i&&(this._clearPreviousSelectedOption(i),this._assignOptionValue(i.value),this._onChange(i.value),this.autocomplete._emitSelectEvent(i),this._element.nativeElement.focus()),this.closePanel()}_clearPreviousSelectedOption(e){this.autocomplete.options.forEach(i=>{i!==e&&i.selected&&i.deselect()})}_attachOverlay(){let e=this._overlayRef;e?(this._positionStrategy.setOrigin(this._getConnectedElement()),e.updateSize({width:this._getPanelWidth()})):(this._portal=new ks(this.autocomplete.template,this._viewContainerRef,{id:this._formField?.getLabelId()}),e=this._overlay.create(this._getOverlayConfig()),this._overlayRef=e,this._handleOverlayEvents(e),this._viewportSubscription=this._viewportRuler.change().subscribe(()=>{this.panelOpen&&e&&e.updateSize({width:this._getPanelWidth()})})),e&&!e.hasAttached()&&(e.attach(this._portal),this._closingActionsSubscription=this._subscribeToClosingActions());let i=this.panelOpen;this.autocomplete._setVisibility(),this.autocomplete._isOpen=this._overlayAttached=!0,this.panelOpen&&i!==this.panelOpen&&this.autocomplete.opened.emit()}_getOverlayConfig(){return new sc({positionStrategy:this._getOverlayPosition(),scrollStrategy:this._scrollStrategy(),width:this._getPanelWidth(),direction:this._dir,panelClass:this._defaults?.overlayPanelClass})}_getOverlayPosition(){let e=this._overlay.position().flexibleConnectedTo(this._getConnectedElement()).withFlexibleDimensions(!1).withPush(!1);return this._setStrategyPositions(e),this._positionStrategy=e,e}_setStrategyPositions(e){let s,i=[{originX:"start",originY:"bottom",overlayX:"start",overlayY:"top"},{originX:"end",originY:"bottom",overlayX:"end",overlayY:"top"}],r=this._aboveClass,o=[{originX:"start",originY:"top",overlayX:"start",overlayY:"bottom",panelClass:r},{originX:"end",originY:"top",overlayX:"end",overlayY:"bottom",panelClass:r}];s="above"===this.position?o:"below"===this.position?i:[...i,...o],e.withPositions(s)}_getConnectedElement(){return this.connectedTo?this.connectedTo.elementRef:this._formField?this._formField.getConnectedOverlayOrigin():this._element}_getPanelWidth(){return this.autocomplete.panelWidth||this._getHostWidth()}_getHostWidth(){return this._getConnectedElement().nativeElement.getBoundingClientRect().width}_resetActiveItem(){let e=this.autocomplete;e.autoActiveFirstOption?e._keyManager.setFirstItemActive():e._keyManager.setActiveItem(-1)}_canOpen(){let e=this._element.nativeElement;return!e.readOnly&&!e.disabled&&!this._autocompleteDisabled}_getWindow(){return this._document?.defaultView||window}_scrollToOption(e){let i=this.autocomplete,r=ow(e,i.options,i.optionGroups);if(0===e&&1===r)i._setScrollTop(0);else if(i.panel){let o=i.options.toArray()[e];if(o){let s=o._getHostElement(),a=_2(s.offsetTop,s.offsetHeight,i._getScrollTop(),i.panel.nativeElement.offsetHeight);i._setScrollTop(a)}}}_handleOverlayEvents(e){e.keydownEvents().subscribe(i=>{(27===i.keyCode&&!kr(i)||38===i.keyCode&&kr(i,"altKey"))&&(this._pendingAutoselectedOption&&(this._updateNativeInputValue(this._valueBeforeAutoSelection??""),this._pendingAutoselectedOption=null),this._closeKeyEventStream.next(),this._resetActiveItem(),i.stopPropagation(),i.preventDefault())}),e.outsidePointerEvents().subscribe()}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(tr),M(Oi),M(_t),M(nn),M(Fpe),M($i,8),M(sg,9),M(Ht,8),M(Va),M(kpe,8))},n.\u0275dir=He({type:n,inputs:{autocomplete:["matAutocomplete","autocomplete"],position:["matAutocompletePosition","position"],connectedTo:["matAutocompleteConnectedTo","connectedTo"],autocompleteAttribute:["autocomplete","autocompleteAttribute"],autocompleteDisabled:["matAutocompleteDisabled","autocompleteDisabled"]},features:[Ft]}),n})(),$g=(()=>{class n extends bQe{constructor(){super(...arguments),this._aboveClass="mat-autocomplete-panel-above"}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275dir=He({type:n,selectors:[["input","matAutocomplete",""],["textarea","matAutocomplete",""]],hostAttrs:[1,"mat-autocomplete-trigger"],hostVars:7,hostBindings:function(e,i){1&e&&P("focusin",function(){return i._handleFocus()})("blur",function(){return i._onTouched()})("input",function(o){return i._handleInput(o)})("keydown",function(o){return i._handleKeydown(o)})("click",function(){return i._handleClick()}),2&e&&ze("autocomplete",i.autocompleteAttribute)("role",i.autocompleteDisabled?null:"combobox")("aria-autocomplete",i.autocompleteDisabled?null:"list")("aria-activedescendant",i.panelOpen&&i.activeOption?i.activeOption.id:null)("aria-expanded",i.autocompleteDisabled?null:i.panelOpen.toString())("aria-owns",i.autocompleteDisabled||!i.panelOpen||null==i.autocomplete?null:i.autocomplete.id)("aria-haspopup",i.autocompleteDisabled?null:"listbox")},exportAs:["matAutocompleteTrigger"],features:[$t([yQe]),tt]}),n})(),Ib=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[vQe],imports:[ss,Av,ln,Me,ud,Av,ln]}),n})(),Yk=(()=>{class n{constructor(){this.value="",this.placeholder=""}onInputKeyUp(e){"Enter"===e.key&&this.autocompleteTrigger.closePanel()}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["tb-filter-input"]],viewQuery:function(e,i){if(1&e&&ot($g,5),2&e){let r;Ne(r=Le())&&(i.autocompleteTrigger=r.first)}},inputs:{value:"value",matAutocomplete:"matAutocomplete",placeholder:"placeholder"},decls:2,vars:4,consts:[["svgIcon","search_24px"],["type","text","autocomplete","off",3,"placeholder","matAutocomplete","matAutocompleteDisabled","value","keyup"]],template:function(e,i){1&e&&(O(0,"mat-icon",0),_(1,"input",1),P("keyup",function(o){return i.onInputKeyUp(o)}),v()),2&e&&(C(1),y("placeholder",i.placeholder)("matAutocomplete",i.matAutocomplete)("matAutocompleteDisabled",!i.matAutocomplete)("value",i.value))},dependencies:[$g,Gt],styles:["[_nghost-%COMP%]{display:flex;font-size:13px}mat-icon[_ngcontent-%COMP%]{color:#616161;flex:none;margin-right:5px}body.dark-mode[_nghost-%COMP%]   mat-icon[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   mat-icon[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}input[_ngcontent-%COMP%]{background-color:inherit;caret-color:currentColor;color:currentColor;font:inherit;border:none;outline:none;padding:0;flex-grow:1}"]}),n})();function xQe(n,t){1&n&&O(0,"mat-icon",7)}function CQe(n,t){if(1&n&&(_(0,"mat-option",8),A(1),v()),2&n){let e=t.$implicit;y("value",e),ze("title",e),C(1),yt(e)}}function MQe(n,t){if(1&n&&(_(0,"div",9)(1,"em"),A(2),B(3,"number"),v()()),2&n){let e=S();C(2),je("and ",U(3,1,e.completions.length-25)," more tags matched")}}var Lpe=(()=>{class n{constructor(){this.onRegexFilterValueChange=new G}onCompletionAccepted(e){this.onRegexFilterValueChange.emit(function(n){return n.replace(OOe,"\\$&")}(e))}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["metrics-tag-filter-component"]],hostVars:2,hostBindings:function(e,i){2&e&&et("valid",i.isRegexFilterValid)},inputs:{regexFilterValue:"regexFilterValue",isRegexFilterValid:"isRegexFilterValid",completions:"completions"},outputs:{onRegexFilterValueChange:"onRegexFilterValueChange"},decls:7,vars:5,consts:[[1,"tag-filter"],["placeholder","Filter tags (regex)",3,"value","matAutocomplete","input"],["svgIcon","error_24px","class","error-icon","title","Invalid regex filter. The result may be stale.",4,"ngIf"],[1,"tag-options",3,"optionSelected"],["filterMatches","matAutocomplete"],["class","option",3,"value",4,"ngFor","ngForOf"],["class","and-more",4,"ngIf"],["svgIcon","error_24px","title","Invalid regex filter. The result may be stale.",1,"error-icon"],[1,"option",3,"value"],[1,"and-more"]],template:function(e,i){if(1&e&&(_(0,"div",0)(1,"tb-filter-input",1),P("input",function(o){return i.onRegexFilterValueChange.emit(o.target.value)}),v(),E(2,xQe,1,0,"mat-icon",2),v(),_(3,"mat-autocomplete",3,4),P("optionSelected",function(o){return i.onCompletionAccepted(o.option.value)}),E(5,CQe,2,3,"mat-option",5),E(6,MQe,4,3,"div",6),v()),2&e){let r=$e(4);C(1),y("value",i.regexFilterValue)("matAutocomplete",r),C(1),y("ngIf",!i.isRegexFilterValid),C(3),y("ngForOf",null==i.completions?null:i.completions.slice(0,25)),C(1),y("ngIf",(null==i.completions?null:i.completions.length)>25)}},dependencies:[dn,Be,Yk,qk,Os,Gt,Ql],styles:[".tag-filter[_ngcontent-%COMP%]{display:flex;position:relative}tb-filter-input[_ngcontent-%COMP%]{flex-grow:1}[_nghost-%COMP%]{color:#212121}body.dark-mode   [_nghost-%COMP%]{color:#fff}[_nghost-%COMP%]:not(.valid){color:#c62828}[_nghost-%COMP%]:not(.valid)   .error-icon[_ngcontent-%COMP%]{color:#c62828;position:absolute;right:0}  .tag-options .option,   .tag-options .and-more{-webkit-box-orient:vertical;-webkit-line-clamp:3;display:-webkit-box;font-size:14px;line-height:1.4;padding:8px 16px}  .tag-options .and-more{color:#616161}body.dark-mode[_nghost-%COMP%]     .tag-options .and-more, body.dark-mode   [_nghost-%COMP%]     .tag-options .and-more{color:rgba(255,255,255,.7)}"],changeDetection:0}),n})(),Bpe=(()=>{class n{constructor(e){this.store=e,this.tagFilter$=this.store.select(Xc),this.isTagFilterRegexValid$=this.tagFilter$.pipe(L(i=>{try{return new RegExp(i),!0}catch{return!1}})),this.completions$=this.store.select(PI).pipe(fr(this.store.select(nd)),L(([i,r])=>i.filter(({plugin:o})=>!r.size||r.has(o)).map(({tag:o})=>o)),L(i=>[...new Set(i)]),L(i=>i.sort(Fw)),fr(this.store.select(Xc)),L(([i,r])=>{try{return[i,new RegExp(r,"i")]}catch{return[i,null]}}),Ye(([,i])=>null!==i),L(([i,r])=>i.filter(o=>r.test(o))))}onTagFilterChange(e){this.store.dispatch(sR({tagFilter:e}))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["metrics-tag-filter"]],decls:4,vars:9,consts:[[3,"regexFilterValue","isRegexFilterValid","completions","onRegexFilterValueChange"]],template:function(e,i){1&e&&(_(0,"metrics-tag-filter-component",0),P("onRegexFilterValueChange",function(o){return i.onTagFilterChange(o)}),B(1,"async"),B(2,"async"),B(3,"async"),v()),2&e&&y("regexFilterValue",U(1,3,i.tagFilter$))("isRegexFilterValid",U(2,5,i.isTagFilterRegexValid$))("completions",U(3,7,i.completions$))},dependencies:[Lpe,Ge],encapsulation:2,changeDetection:0}),n})();function EQe(n,t){if(1&n&&(_(0,"span",8),A(1),v()),2&n){let e=S();C(1),je("",e.cardIdsWithMetadata.length," cards")}}function TQe(n,t){1&n&&(_(0,"span",9),A(1,"New card pinned"),v()),2&n&&ze("data-id",t.$implicit)}function DQe(n,t){if(1&n&&O(0,"metrics-card-grid",10),2&n){let e=S();y("cardIdsWithMetadata",e.cardIdsWithMetadata)("cardObserver",e.cardObserver)}}function AQe(n,t){1&n&&(_(0,"div",11),A(1,"Pin cards for a quick view and comparison"),v())}var Vpe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["metrics-pinned-view-component"]],inputs:{cardObserver:"cardObserver",cardIdsWithMetadata:"cardIdsWithMetadata",newCardPinnedIds:"newCardPinnedIds"},decls:10,vars:4,consts:[[1,"group-toolbar"],["svgIcon","keep_24px"],[1,"group-text"],["aria-role","heading","aria-level","3",1,"group-title"],["class","group-card-count",4,"ngIf"],["class","new-card-pinned",4,"ngFor","ngForOf"],[3,"cardIdsWithMetadata","cardObserver",4,"ngIf","ngIfElse"],["emptyPinnedView",""],[1,"group-card-count"],[1,"new-card-pinned"],[3,"cardIdsWithMetadata","cardObserver"],[1,"empty-message"]],template:function(e,i){if(1&e&&(_(0,"div",0),O(1,"mat-icon",1),_(2,"span",2)(3,"span",3),A(4,"Pinned"),v(),E(5,EQe,2,1,"span",4),E(6,TQe,2,1,"span",5),v()(),E(7,DQe,1,2,"metrics-card-grid",6),E(8,AQe,2,0,"ng-template",null,7,qt)),2&e){let r=$e(9);C(5),y("ngIf",i.cardIdsWithMetadata.length>1),C(1),y("ngForOf",i.newCardPinnedIds),C(1),y("ngIf",i.cardIdsWithMetadata.length)("ngIfElse",r)}},dependencies:[dn,Be,Gt,Ab],styles:["[_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#fff;border-bottom:1px solid #ebebeb;align-items:center;background-color:#fff;display:flex;flex:none;height:42px;margin-bottom:-1px;padding:0 16px;position:sticky;top:0;z-index:1;box-shadow:0px 2px 4px 0px rgba(0,0,0,.15)}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{background-color:#303030}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode   [_nghost-%COMP%]   .group-toolbar[_ngcontent-%COMP%]{box-shadow:0px 2px 4px 0px rgba(255,255,255,.15)}mat-icon[_ngcontent-%COMP%]{color:#616161;flex:none;margin-right:5px}body.dark-mode[_nghost-%COMP%]   mat-icon[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   mat-icon[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.group-text[_ngcontent-%COMP%]{display:flex;align-items:baseline;gap:6px}.group-title[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.group-card-count[_ngcontent-%COMP%]{font-size:12px;font-weight:400;color:#616161}body.dark-mode[_nghost-%COMP%]   .group-card-count[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group-card-count[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.empty-message[_ngcontent-%COMP%]{color:#616161;font-size:13px;font-style:italic;padding:16px;text-align:center}body.dark-mode[_nghost-%COMP%]   .empty-message[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .empty-message[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.new-card-pinned[_ngcontent-%COMP%]{animation:pinned-view-fade-out 3s linear;background:#f44336;border-radius:5px;color:#fff;display:inline-block;font-size:13px;opacity:0;padding:3px 5px}@keyframes pinned-view-fade-out{from{opacity:1}66%{opacity:.99}to{opacity:0}}"],changeDetection:0}),n})(),Hpe=(()=>{class n{constructor(e){this.store=e,this.cardIdsWithMetadata$=this.store.select(zM).pipe(zn([])),this.newCardPinnedIds$=this.store.select(zM).pipe(Za(1),L(i=>i.map(r=>r.cardId)),y0(),L(([i,r])=>{let o=new Set(i),s=new Set(r);for(let a of s)if(!o.has(a))return Date.now();return null}),zn(null),y0(),L(([i,r])=>null===i&&null===r?null:null===r?[i]:[r]),Ye(i=>null!==i),L(i=>[i[0]]))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["metrics-pinned-view"]],inputs:{cardObserver:"cardObserver"},decls:3,vars:7,consts:[[3,"cardIdsWithMetadata","newCardPinnedIds","cardObserver"]],template:function(e,i){1&e&&(O(0,"metrics-pinned-view-component",0),B(1,"async"),B(2,"async")),2&e&&y("cardIdsWithMetadata",U(1,3,i.cardIdsWithMetadata$))("newCardPinnedIds",U(2,5,i.newCardPinnedIds$))("cardObserver",i.cardObserver)},dependencies:[Vpe,Ge],encapsulation:2,changeDetection:0}),n})();function RQe(n,t){1&n&&O(0,"metrics-filtered-view",12),2&n&&y("cardObserver",S().cardObserver)}function OQe(n,t){1&n&&(_(0,"div",16),O(1,"mat-spinner",17),v())}var kQe=function(n){return{"slide-out-menu-expanded":n}};function FQe(n,t){if(1&n&&(_(0,"div",18),O(1,"metrics-scalar-column-editor"),v()),2&n){let e=S();y("ngClass",On(1,kQe,e.slideOutMenuOpen))}}function NQe(n,t){if(1&n){let e=Pe();_(0,"div",19)(1,"div",20)(2,"h2",21),A(3,"Settings"),v(),_(4,"button",22),P("click",function(){return oe(e),se(S().onCloseSidepaneButtonClicked.emit())}),O(5,"mat-icon",23),v()(),O(6,"metrics-dashboard-right-pane"),v()}}var LQe=function(n){return{checked:n,"settings-button":!0}},Upe=(()=>{class n{constructor(e){this.host=e,this.onSettingsButtonClicked=new G,this.onCloseSidepaneButtonClicked=new G,this.onPluginTypeToggled=new G,this.onPluginTypeAllToggled=new G,this.PluginType=ri,this.cardObserver=new Nw(this.host.nativeElement,"600px 0px 600px 0px")}}return n.\u0275fac=function(e){return new(e||n)(M(Re))},n.\u0275cmp=R({type:n,selectors:[["metrics-main-view-component"]],inputs:{showFilteredView:"showFilteredView",isSidepaneOpen:"isSidepaneOpen",filteredPluginTypes:"filteredPluginTypes",initialTagsLoading:"initialTagsLoading",slideOutMenuOpen:"slideOutMenuOpen"},outputs:{onSettingsButtonClicked:"onSettingsButtonClicked",onCloseSidepaneButtonClicked:"onCloseSidepaneButtonClicked",onPluginTypeToggled:"onPluginTypeToggled",onPluginTypeAllToggled:"onPluginTypeAllToggled"},decls:23,vars:22,consts:function(){let t,e;return t=$localize`:Label on a toolbar button to toggle the settings side pane.␟d3516db6bbe6860a55beab66e4969dac625b8d72␟7659285445580838925:Toggle settings side pane`,e=$localize`:Label on a button to close the settings side pane.␟04521dc0b6a65cf5c382944c9a8b4b844a3e9598␟8156766997747165871:Close side pane`,[[1,"toolbar"],["multiple","","appearance","standard",1,"filter-view"],["mat-button","","role","checkbox","data-value","all",1,"filter-view-button",3,"click"],["mat-button","","role","checkbox","data-value","scalars",1,"filter-view-button",3,"click"],["mat-button","","role","checkbox","data-value","image",1,"filter-view-button",3,"click"],["mat-button","","role","checkbox","data-value","histogram",1,"filter-view-button",3,"click"],[1,"right-items"],["mat-stroked-button","","aria-label",t,3,"ngClass","click"],["svgIcon","settings_24px"],[1,"split-content"],["cdkScrollable",""],[3,"cardObserver",4,"ngIf"],[3,"cardObserver"],["class","loading-container",4,"ngIf"],["class","slide-out-menu",3,"ngClass",4,"ngIf"],["class","sidebar",4,"ngIf"],[1,"loading-container"],["diameter","36"],[1,"slide-out-menu",3,"ngClass"],[1,"sidebar"],[1,"header"],[1,"title"],["mat-icon-button","","aria-label",e,3,"click"],["svgIcon","close_24px"]]},template:function(e,i){1&e&&(_(0,"div",0),O(1,"metrics-tag-filter"),_(2,"mat-button-toggle-group",1)(3,"button",2),P("click",function(){return i.onPluginTypeAllToggled.emit()}),A(4," All "),v(),_(5,"button",3),P("click",function(){return i.onPluginTypeToggled.emit(i.PluginType.SCALARS)}),A(6," Scalars "),v(),_(7,"button",4),P("click",function(){return i.onPluginTypeToggled.emit(i.PluginType.IMAGES)}),A(8," Image "),v(),_(9,"button",5),P("click",function(){return i.onPluginTypeToggled.emit(i.PluginType.HISTOGRAMS)}),A(10," Histogram "),v()(),_(11,"div",6)(12,"button",7),P("click",function(){return i.onSettingsButtonClicked.emit()}),O(13,"mat-icon",8),A(14," Settings "),v()()(),_(15,"div",9)(16,"div",10),E(17,RQe,1,1,"metrics-filtered-view",11),O(18,"metrics-pinned-view",12),E(19,OQe,2,0,"div",13),O(20,"metrics-card-groups",12),v(),E(21,FQe,2,3,"div",14),E(22,NQe,7,0,"div",15),v()),2&e&&(C(3),ze("aria-checked",0===i.filteredPluginTypes.size),C(2),ze("aria-checked",i.filteredPluginTypes.has(i.PluginType.SCALARS)),C(2),ze("aria-checked",i.filteredPluginTypes.has(i.PluginType.IMAGES)),C(2),ze("aria-checked",i.filteredPluginTypes.has(i.PluginType.HISTOGRAMS)),C(3),y("ngClass",On(20,LQe,i.isSidepaneOpen)),ze("aria-pressed",i.isSidepaneOpen),C(4),et("main",!0)("filter-view",i.showFilteredView),C(1),y("ngIf",i.showFilteredView),C(1),Pt("display",i.showFilteredView?"none":""),y("cardObserver",i.cardObserver),C(1),y("ngIf",i.initialTagsLoading),C(1),Pt("display",i.showFilteredView?"none":""),y("cardObserver",i.cardObserver),C(1),y("ngIf",i.isSidepaneOpen),C(1),y("ngIf",i.isSidepaneOpen))},dependencies:[Fn,Be,Ih,_n,EU,Gt,Bo,Uoe,Woe,Ape,Ope,Bpe,Hpe],styles:["[_nghost-%COMP%]{display:flex;flex-direction:column;height:100%}.toolbar[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;flex:none;display:flex;align-items:center;justify-content:space-between;height:48px;padding:0 16px}body.dark-mode[_nghost-%COMP%]   .toolbar[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .toolbar[_ngcontent-%COMP%]{border-bottom:1px solid #555}.toolbar[_ngcontent-%COMP%]   metrics-tag-filter[_ngcontent-%COMP%]{flex:1 1 100px}.toolbar[_ngcontent-%COMP%]   .right-items[_ngcontent-%COMP%]{border-left:1px solid #ebebeb;margin-left:16px;padding-left:16px}body.dark-mode[_nghost-%COMP%]   .toolbar[_ngcontent-%COMP%]   .right-items[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .toolbar[_ngcontent-%COMP%]   .right-items[_ngcontent-%COMP%]{border-left:1px solid #555}.filter-view[_ngcontent-%COMP%]{border-radius:4px;flex:none;margin-right:5px}.filter-view[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{border-radius:0;font-size:12px;font-weight:normal;height:25px;line-height:25px;min-width:unset;padding:0 12px}.filter-view[_ngcontent-%COMP%]   button[_ngcontent-%COMP%] + button[_ngcontent-%COMP%]{border-left:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   .filter-view[_ngcontent-%COMP%]   button[_ngcontent-%COMP%] + button[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .filter-view[_ngcontent-%COMP%]   button[_ngcontent-%COMP%] + button[_ngcontent-%COMP%]{border-left:1px solid #555}.filter-view[_ngcontent-%COMP%]   button[aria-checked=true][_ngcontent-%COMP%]{background-color:#e0e0e0}body.dark-mode[_nghost-%COMP%]   .filter-view[_ngcontent-%COMP%]   button[aria-checked=true][_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .filter-view[_ngcontent-%COMP%]   button[aria-checked=true][_ngcontent-%COMP%]{background-color:#212121}.split-content[_ngcontent-%COMP%]{display:flex;overflow-y:auto;flex:1}.main[_ngcontent-%COMP%], .sidebar[_ngcontent-%COMP%]{contain:strict;background-color:#fff;overflow-x:hidden;overflow-y:auto;will-change:transform,scroll-position}body.dark-mode[_nghost-%COMP%]   .main[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .main[_ngcontent-%COMP%]{background-color:#303030}body.dark-mode[_nghost-%COMP%]   .sidebar[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .sidebar[_ngcontent-%COMP%]{background-color:#303030}.main[_ngcontent-%COMP%]{background-color:#f5f6f7;flex:1 1;display:flex;flex-direction:column}body.dark-mode[_nghost-%COMP%]   .main[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .main[_ngcontent-%COMP%]{background-color:#3a3a3a}.main[_ngcontent-%COMP%]   metrics-filtered-view[_ngcontent-%COMP%], .main[_ngcontent-%COMP%]   metrics-pinned-view[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   .main[_ngcontent-%COMP%]   metrics-filtered-view[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .main[_ngcontent-%COMP%]   metrics-filtered-view[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode[_nghost-%COMP%]   .main[_ngcontent-%COMP%]   metrics-pinned-view[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .main[_ngcontent-%COMP%]   metrics-pinned-view[_ngcontent-%COMP%]{border-bottom:1px solid #555}.main.filter-view[_ngcontent-%COMP%]{overflow:hidden}.main.filter-view[_ngcontent-%COMP%]   metrics-filtered-view[_ngcontent-%COMP%]{contain:content;overflow:auto;will-change:transform,scroll-position}.loading-container[_ngcontent-%COMP%]{align-items:center;display:flex;justify-content:center;margin:20px 0}.sidebar[_ngcontent-%COMP%]{border-left:1px solid #ebebeb;flex:0 0 250px}body.dark-mode[_nghost-%COMP%]   .sidebar[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .sidebar[_ngcontent-%COMP%]{border-left:1px solid #555}.sidebar[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;display:flex;align-items:center;justify-content:space-between;height:42px;padding:0 16px}body.dark-mode[_nghost-%COMP%]   .sidebar[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .sidebar[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]{border-bottom:1px solid #555}.sidebar[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]   .title[_ngcontent-%COMP%]{font-size:18px;font-weight:400;line-height:normal;margin:0}[_nghost-%COMP%]   .settings-button[_ngcontent-%COMP%]{color:#616161;display:inline-flex}body.dark-mode   [_nghost-%COMP%]   .settings-button[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}[_nghost-%COMP%]   .settings-button.checked[_ngcontent-%COMP%]{background-color:#e0e0e0;border-color:#e0e0e0}body.dark-mode   [_nghost-%COMP%]   .settings-button.checked[_ngcontent-%COMP%]{background-color:#212121}[_nghost-%COMP%]   .settings-button[_ngcontent-%COMP%]     .mat-button-wrapper{display:inline-flex;align-items:center}[_nghost-%COMP%]   .settings-button[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{margin-right:4px}.slide-out-menu[_ngcontent-%COMP%]{background-color:#fff;height:100%;position:absolute;right:50px;top:49px;transition:all .75s ease;visibility:hidden;width:200px;border-left:1px solid #ebebeb}body.dark-mode[_nghost-%COMP%]   .slide-out-menu[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slide-out-menu[_ngcontent-%COMP%]{border-left:1px solid #555}body.dark-mode[_nghost-%COMP%]   .slide-out-menu[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slide-out-menu[_ngcontent-%COMP%]{background-color:#303030}.slide-out-menu-expanded[_ngcontent-%COMP%]{right:250px;visibility:visible}"],changeDetection:0}),n})(),zpe=(()=>{class n{constructor(e){this.store=e,this.isSidepaneOpen$=this.store.select(HI),this.initialTagsLoading$=this.store.select(UM).pipe(cx(i=>null===i.lastLoadedTimeInMs,!0),L(i=>i.state===Oe.LOADING&&null===i.lastLoadedTimeInMs)),this.showFilteredView$=this.store.select(Xc).pipe(L(i=>i.length>0)),this.filteredPluginTypes$=this.store.select(nd),this.isSlideoutMenuOpen$=this.store.select(UI)}onSettingsButtonClicked(){this.store.dispatch(BP())}onCloseSidepaneButtonClicked(){this.store.dispatch(LP())}onPluginVisibilityToggled(e){this.store.dispatch(lR({plugin:e}))}onShowAllPlugins(){this.store.dispatch(cR())}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["metrics-main-view"]],decls:6,vars:15,consts:[[3,"showFilteredView","isSidepaneOpen","initialTagsLoading","filteredPluginTypes","slideOutMenuOpen","onSettingsButtonClicked","onCloseSidepaneButtonClicked","onPluginTypeToggled","onPluginTypeAllToggled"]],template:function(e,i){1&e&&(_(0,"metrics-main-view-component",0),P("onSettingsButtonClicked",function(){return i.onSettingsButtonClicked()})("onCloseSidepaneButtonClicked",function(){return i.onCloseSidepaneButtonClicked()})("onPluginTypeToggled",function(o){return i.onPluginVisibilityToggled(o)})("onPluginTypeAllToggled",function(){return i.onShowAllPlugins()}),B(1,"async"),B(2,"async"),B(3,"async"),B(4,"async"),B(5,"async"),v()),2&e&&y("showFilteredView",U(1,5,i.showFilteredView$))("isSidepaneOpen",U(2,7,i.isSidepaneOpen$))("initialTagsLoading",U(3,9,i.initialTagsLoading$))("filteredPluginTypes",U(4,11,i.filteredPluginTypes$))("slideOutMenuOpen",U(5,13,i.isSlideoutMenuOpen$))},dependencies:[Upe,Ge],encapsulation:2,changeDetection:0}),n})(),va=(()=>(function(n){n.CHECKBOX="checkbox",n.RUN_NAME="run_name",n.EXPERIMENT_NAME="experiment_name",n.RUN_COLOR="run_color"}(va||(va={})),va))(),Df={};BE(Df,{getExperimentsHparamsAndMetricsSpecs:()=>GQe,getHparamFilterMap:()=>UQe,getMetricFilterMap:()=>jQe});var CE=Mr(fI),HQe=J(CE,(n,t)=>{let e=[];for(let i of t)!n.specs[i]||e.push(n.specs[i].hparam.defaultFilters);return LM(e)}),UQe=J(HQe,CE,(n,t,e)=>{let i=Wm(e);return new Map([...n,...t.filters[i]?.hparams??[]])}),zQe=J(CE,(n,t)=>{let e=[];for(let i of t)!n.specs[i]||e.push(n.specs[i].metric.defaultFilters);return hI(e)}),jQe=J(zQe,CE,(n,t,e)=>{let i=Wm(e);return new Map([...n,...t.filters[i]?.metrics??[]])}),GQe=J(CE,(n,t)=>function(...n){let t=new Map,e=new Map,i=new Map,r=new Map,o=[];for(let s of n){for(let a of s.hparams)if(e.has(a.name)||e.set(a.name,new Set),e.get(a.name).add(a.displayName),t.has(a.name)){let l=t.get(a.name),c=a;if(l.type!==c.type&&o.push(`Hparam, ${c.name}, types have to match. Got: ${l.type} vs. ${c.type}`),l.domain.type===Ci.INTERVAL&&c.domain.type===Ci.INTERVAL)(l.domain.minValue!==c.domain.minValue||l.domain.maxValue!==c.domain.maxValue)&&o.push(`Hparam, ${c.name}, domains have to match. Got: ${l.domain} vs. ${c.domain}`);else if(l.domain.type===Ci.DISCRETE&&c.domain.type===Ci.DISCRETE){let u=new Set([...l.domain.values,...c.domain.values]);(l.domain.values.length!==c.domain.values.length||l.domain.values.length!==u.size)&&o.push(`Hparam, ${c.name}, domains have to match. Got: ${l.domain} vs. ${c.domain}`)}else o.push(`Hparam, ${c.name}, domains have to match. Got: ${l.domain} vs. ${c.domain}`)}else t.set(a.name,{...a});for(let a of s.metrics)if(r.has(a.tag)||r.set(a.tag,new Set),r.get(a.tag).add(a.displayName),i.has(a.tag)){let l=i.get(a.tag),c=a;l.datasetType!==c.datasetType&&o.push(`Metric, ${c.tag}, datasetTypes have to match. Got: ${l.datasetType} vs. ${c.datasetType}`)}else i.set(a.tag,{...a})}if(o.length)throw new Error(`Validation error:\n${o.join("\n")}`);return{hparams:[...t].map(([s,a])=>({...a,displayName:[...e.get(s)].join(" or ")})),metrics:[...i].map(([s,a])=>({...a,displayName:[...r.get(s)].join(" or ")}))}}(...t.experimentIds.map(e=>{let i=n.specs[e];return i?{hparams:i.hparam.specs,metrics:i.metric.specs}:null}).filter(Boolean))),WQe=["tooltip"],Gpe="tooltip-panel",Wpe=la({passive:!0}),qpe=new pe("mat-tooltip-scroll-strategy"),QQe={provide:qpe,deps:[tr],useFactory:function(n){return()=>n.scrollStrategies.reposition({scrollThrottle:20})}},KQe=new pe("mat-tooltip-default-options",{providedIn:"root",factory:function(){return{showDelay:0,hideDelay:0,touchendHideDelay:1500}}}),JQe=(()=>{class n{constructor(e,i,r,o,s,a,l,c,u,d,p,h){this._overlay=e,this._elementRef=i,this._scrollDispatcher=r,this._viewContainerRef=o,this._ngZone=s,this._platform=a,this._ariaDescriber=l,this._focusMonitor=c,this._dir=d,this._defaultOptions=p,this._position="below",this._disabled=!1,this._viewInitialized=!1,this._pointerExitEventsInitialized=!1,this._viewportMargin=8,this._cssClassPrefix="mat",this._showDelay=this._defaultOptions.showDelay,this._hideDelay=this._defaultOptions.hideDelay,this.touchGestures="auto",this._message="",this._passiveListeners=[],this._destroyed=new ke,this._scrollStrategy=u,this._document=h,p&&(p.position&&(this.position=p.position),p.touchGestures&&(this.touchGestures=p.touchGestures)),d.change.pipe(st(this._destroyed)).subscribe(()=>{this._overlayRef&&this._updatePosition(this._overlayRef)})}get position(){return this._position}set position(e){e!==this._position&&(this._position=e,this._overlayRef&&(this._updatePosition(this._overlayRef),this._tooltipInstance?.show(0),this._overlayRef.updatePosition()))}get disabled(){return this._disabled}set disabled(e){this._disabled=Rt(e),this._disabled?this.hide(0):this._setupPointerEnterEventsIfNeeded()}get showDelay(){return this._showDelay}set showDelay(e){this._showDelay=Bi(e)}get hideDelay(){return this._hideDelay}set hideDelay(e){this._hideDelay=Bi(e),this._tooltipInstance&&(this._tooltipInstance._mouseLeaveHideDelay=this._hideDelay)}get message(){return this._message}set message(e){this._ariaDescriber.removeDescription(this._elementRef.nativeElement,this._message,"tooltip"),this._message=null!=e?String(e).trim():"",!this._message&&this._isTooltipVisible()?this.hide(0):(this._setupPointerEnterEventsIfNeeded(),this._updateTooltipMessage(),this._ngZone.runOutsideAngular(()=>{Promise.resolve().then(()=>{this._ariaDescriber.describe(this._elementRef.nativeElement,this.message,"tooltip")})}))}get tooltipClass(){return this._tooltipClass}set tooltipClass(e){this._tooltipClass=e,this._tooltipInstance&&this._setTooltipClass(this._tooltipClass)}ngAfterViewInit(){this._viewInitialized=!0,this._setupPointerEnterEventsIfNeeded(),this._focusMonitor.monitor(this._elementRef).pipe(st(this._destroyed)).subscribe(e=>{e?"keyboard"===e&&this._ngZone.run(()=>this.show()):this._ngZone.run(()=>this.hide(0))})}ngOnDestroy(){let e=this._elementRef.nativeElement;clearTimeout(this._touchstartTimeout),this._overlayRef&&(this._overlayRef.dispose(),this._tooltipInstance=null),this._passiveListeners.forEach(([i,r])=>{e.removeEventListener(i,r,Wpe)}),this._passiveListeners.length=0,this._destroyed.next(),this._destroyed.complete(),this._ariaDescriber.removeDescription(e,this.message,"tooltip"),this._focusMonitor.stopMonitoring(e)}show(e=this.showDelay){if(this.disabled||!this.message||this._isTooltipVisible())return void this._tooltipInstance?._cancelPendingAnimations();let i=this._createOverlay();this._detach(),this._portal=this._portal||new $c(this._tooltipComponent,this._viewContainerRef);let r=this._tooltipInstance=i.attach(this._portal).instance;r._triggerElement=this._elementRef.nativeElement,r._mouseLeaveHideDelay=this._hideDelay,r.afterHidden().pipe(st(this._destroyed)).subscribe(()=>this._detach()),this._setTooltipClass(this._tooltipClass),this._updateTooltipMessage(),r.show(e)}hide(e=this.hideDelay){let i=this._tooltipInstance;i&&(i.isVisible()?i.hide(e):(i._cancelPendingAnimations(),this._detach()))}toggle(){this._isTooltipVisible()?this.hide():this.show()}_isTooltipVisible(){return!!this._tooltipInstance&&this._tooltipInstance.isVisible()}_createOverlay(){if(this._overlayRef)return this._overlayRef;let e=this._scrollDispatcher.getAncestorScrollContainers(this._elementRef),i=this._overlay.position().flexibleConnectedTo(this._elementRef).withTransformOriginOn(`.${this._cssClassPrefix}-tooltip`).withFlexibleDimensions(!1).withViewportMargin(this._viewportMargin).withScrollableContainers(e);return i.positionChanges.pipe(st(this._destroyed)).subscribe(r=>{this._updateCurrentPositionClass(r.connectionPair),this._tooltipInstance&&r.scrollableViewProperties.isOverlayClipped&&this._tooltipInstance.isVisible()&&this._ngZone.run(()=>this.hide(0))}),this._overlayRef=this._overlay.create({direction:this._dir,positionStrategy:i,panelClass:`${this._cssClassPrefix}-${Gpe}`,scrollStrategy:this._scrollStrategy()}),this._updatePosition(this._overlayRef),this._overlayRef.detachments().pipe(st(this._destroyed)).subscribe(()=>this._detach()),this._overlayRef.outsidePointerEvents().pipe(st(this._destroyed)).subscribe(()=>this._tooltipInstance?._handleBodyInteraction()),this._overlayRef.keydownEvents().pipe(st(this._destroyed)).subscribe(r=>{this._isTooltipVisible()&&27===r.keyCode&&!kr(r)&&(r.preventDefault(),r.stopPropagation(),this._ngZone.run(()=>this.hide(0)))}),this._defaultOptions?.disableTooltipInteractivity&&this._overlayRef.addPanelClass(`${this._cssClassPrefix}-tooltip-panel-non-interactive`),this._overlayRef}_detach(){this._overlayRef&&this._overlayRef.hasAttached()&&this._overlayRef.detach(),this._tooltipInstance=null}_updatePosition(e){let i=e.getConfig().positionStrategy,r=this._getOrigin(),o=this._getOverlayPosition();i.withPositions([this._addOffset({...r.main,...o.main}),this._addOffset({...r.fallback,...o.fallback})])}_addOffset(e){return e}_getOrigin(){let r,e=!this._dir||"ltr"==this._dir.value,i=this.position;"above"==i||"below"==i?r={originX:"center",originY:"above"==i?"top":"bottom"}:"before"==i||"left"==i&&e||"right"==i&&!e?r={originX:"start",originY:"center"}:("after"==i||"right"==i&&e||"left"==i&&!e)&&(r={originX:"end",originY:"center"});let{x:o,y:s}=this._invertPosition(r.originX,r.originY);return{main:r,fallback:{originX:o,originY:s}}}_getOverlayPosition(){let r,e=!this._dir||"ltr"==this._dir.value,i=this.position;"above"==i?r={overlayX:"center",overlayY:"bottom"}:"below"==i?r={overlayX:"center",overlayY:"top"}:"before"==i||"left"==i&&e||"right"==i&&!e?r={overlayX:"end",overlayY:"center"}:("after"==i||"right"==i&&e||"left"==i&&!e)&&(r={overlayX:"start",overlayY:"center"});let{x:o,y:s}=this._invertPosition(r.overlayX,r.overlayY);return{main:r,fallback:{overlayX:o,overlayY:s}}}_updateTooltipMessage(){this._tooltipInstance&&(this._tooltipInstance.message=this.message,this._tooltipInstance._markForCheck(),this._ngZone.onMicrotaskEmpty.pipe(Qt(1),st(this._destroyed)).subscribe(()=>{this._tooltipInstance&&this._overlayRef.updatePosition()}))}_setTooltipClass(e){this._tooltipInstance&&(this._tooltipInstance.tooltipClass=e,this._tooltipInstance._markForCheck())}_invertPosition(e,i){return"above"===this.position||"below"===this.position?"top"===i?i="bottom":"bottom"===i&&(i="top"):"end"===e?e="start":"start"===e&&(e="end"),{x:e,y:i}}_updateCurrentPositionClass(e){let s,{overlayY:i,originX:r,originY:o}=e;if(s="center"===i?this._dir&&"rtl"===this._dir.value?"end"===r?"left":"right":"start"===r?"left":"right":"bottom"===i&&"top"===o?"above":"below",s!==this._currentPosition){let a=this._overlayRef;if(a){let l=`${this._cssClassPrefix}-${Gpe}-`;a.removePanelClass(l+this._currentPosition),a.addPanelClass(l+s)}this._currentPosition=s}}_setupPointerEnterEventsIfNeeded(){this._disabled||!this.message||!this._viewInitialized||this._passiveListeners.length||(this._platformSupportsMouseEvents()?this._passiveListeners.push(["mouseenter",()=>{this._setupPointerExitEventsIfNeeded(),this.show()}]):"off"!==this.touchGestures&&(this._disableNativeGesturesIfNecessary(),this._passiveListeners.push(["touchstart",()=>{this._setupPointerExitEventsIfNeeded(),clearTimeout(this._touchstartTimeout),this._touchstartTimeout=setTimeout(()=>this.show(),500)}])),this._addListeners(this._passiveListeners))}_setupPointerExitEventsIfNeeded(){if(this._pointerExitEventsInitialized)return;this._pointerExitEventsInitialized=!0;let e=[];if(this._platformSupportsMouseEvents())e.push(["mouseleave",i=>{let r=i.relatedTarget;(!r||!this._overlayRef?.overlayElement.contains(r))&&this.hide()}],["wheel",i=>this._wheelListener(i)]);else if("off"!==this.touchGestures){this._disableNativeGesturesIfNecessary();let i=()=>{clearTimeout(this._touchstartTimeout),this.hide(this._defaultOptions.touchendHideDelay)};e.push(["touchend",i],["touchcancel",i])}this._addListeners(e),this._passiveListeners.push(...e)}_addListeners(e){e.forEach(([i,r])=>{this._elementRef.nativeElement.addEventListener(i,r,Wpe)})}_platformSupportsMouseEvents(){return!this._platform.IOS&&!this._platform.ANDROID}_wheelListener(e){if(this._isTooltipVisible()){let i=this._document.elementFromPoint(e.clientX,e.clientY),r=this._elementRef.nativeElement;i!==r&&!r.contains(i)&&this.hide()}}_disableNativeGesturesIfNecessary(){let e=this.touchGestures;if("off"!==e){let i=this._elementRef.nativeElement,r=i.style;("on"===e||"INPUT"!==i.nodeName&&"TEXTAREA"!==i.nodeName)&&(r.userSelect=r.msUserSelect=r.webkitUserSelect=r.MozUserSelect="none"),("on"===e||!i.draggable)&&(r.webkitUserDrag="none"),r.touchAction="none",r.webkitTapHighlightColor="transparent"}}}return n.\u0275fac=function(e){nl()},n.\u0275dir=He({type:n,inputs:{position:["matTooltipPosition","position"],disabled:["matTooltipDisabled","disabled"],showDelay:["matTooltipShowDelay","showDelay"],hideDelay:["matTooltipHideDelay","hideDelay"],touchGestures:["matTooltipTouchGestures","touchGestures"],message:["matTooltip","message"],tooltipClass:["matTooltipClass","tooltipClass"]}}),n})(),Xk=(()=>{class n extends JQe{constructor(e,i,r,o,s,a,l,c,u,d,p,h){super(e,i,r,o,s,a,l,c,u,d,p,h),this._tooltipComponent=eKe}}return n.\u0275fac=function(e){return new(e||n)(M(tr),M(Re),M($m),M(Oi),M(_t),M(oi),M(f2),M(Fr),M(qpe),M($i,8),M(KQe,8),M(Ht))},n.\u0275dir=He({type:n,selectors:[["","matTooltip",""]],hostAttrs:[1,"mat-tooltip-trigger"],exportAs:["matTooltip"],features:[tt]}),n})(),$Qe=(()=>{class n{constructor(e,i){this._changeDetectorRef=e,this._closeOnInteraction=!1,this._isVisible=!1,this._onHide=new ke,this._animationsDisabled="NoopAnimations"===i}show(e){clearTimeout(this._hideTimeoutId),this._showTimeoutId=setTimeout(()=>{this._toggleVisibility(!0),this._showTimeoutId=void 0},e)}hide(e){clearTimeout(this._showTimeoutId),this._hideTimeoutId=setTimeout(()=>{this._toggleVisibility(!1),this._hideTimeoutId=void 0},e)}afterHidden(){return this._onHide}isVisible(){return this._isVisible}ngOnDestroy(){this._cancelPendingAnimations(),this._onHide.complete(),this._triggerElement=null}_handleBodyInteraction(){this._closeOnInteraction&&this.hide(0)}_markForCheck(){this._changeDetectorRef.markForCheck()}_handleMouseLeave({relatedTarget:e}){(!e||!this._triggerElement.contains(e))&&(this.isVisible()?this.hide(this._mouseLeaveHideDelay):this._finalizeAnimation(!1))}_onShow(){}_handleAnimationEnd({animationName:e}){(e===this._showAnimation||e===this._hideAnimation)&&this._finalizeAnimation(e===this._showAnimation)}_cancelPendingAnimations(){clearTimeout(this._showTimeoutId),clearTimeout(this._hideTimeoutId),this._showTimeoutId=this._hideTimeoutId=void 0}_finalizeAnimation(e){e?this._closeOnInteraction=!0:this.isVisible()||this._onHide.next()}_toggleVisibility(e){let i=this._tooltip.nativeElement,r=this._showAnimation,o=this._hideAnimation;if(i.classList.remove(e?o:r),i.classList.add(e?r:o),this._isVisible=e,e&&!this._animationsDisabled&&"function"==typeof getComputedStyle){let s=getComputedStyle(i);("0s"===s.getPropertyValue("animation-duration")||"none"===s.getPropertyValue("animation-name"))&&(this._animationsDisabled=!0)}e&&this._onShow(),this._animationsDisabled&&(i.classList.add("_mat-animation-noopable"),this._finalizeAnimation(e))}}return n.\u0275fac=function(e){return new(e||n)(M(nn),M(Pi,8))},n.\u0275dir=He({type:n}),n})(),eKe=(()=>{class n extends $Qe{constructor(e,i,r){super(e,r),this._breakpointObserver=i,this._isHandset=this._breakpointObserver.observe("(max-width: 599.98px) and (orientation: portrait), (max-width: 959.98px) and (orientation: landscape)"),this._showAnimation="mat-tooltip-show",this._hideAnimation="mat-tooltip-hide"}}return n.\u0275fac=function(e){return new(e||n)(M(nn),M(Jm),M(Pi,8))},n.\u0275cmp=R({type:n,selectors:[["mat-tooltip-component"]],viewQuery:function(e,i){if(1&e&&ot(WQe,7),2&e){let r;Ne(r=Le())&&(i._tooltip=r.first)}},hostAttrs:["aria-hidden","true"],hostVars:2,hostBindings:function(e,i){1&e&&P("mouseleave",function(o){return i._handleMouseLeave(o)}),2&e&&Pt("zoom",i.isVisible()?1:null)},features:[tt],decls:4,vars:6,consts:[[1,"mat-tooltip",3,"ngClass","animationend"],["tooltip",""]],template:function(e,i){if(1&e&&(_(0,"div",0,1),P("animationend",function(o){return i._handleAnimationEnd(o)}),B(2,"async"),A(3),v()),2&e){let r;et("mat-tooltip-handset",null==(r=U(2,4,i._isHandset))?null:r.matches),y("ngClass",i.tooltipClass),C(3),yt(i.message)}},dependencies:[Fn,Ge],styles:[".mat-tooltip{color:#fff;border-radius:4px;margin:14px;max-width:250px;padding-left:8px;padding-right:8px;overflow:hidden;text-overflow:ellipsis;transform:scale(0)}.mat-tooltip._mat-animation-noopable{animation:none;transform:scale(1)}.cdk-high-contrast-active .mat-tooltip{outline:solid 1px}.mat-tooltip-handset{margin:24px;padding-left:16px;padding-right:16px}.mat-tooltip-panel-non-interactive{pointer-events:none}@keyframes mat-tooltip-show{0%{opacity:0;transform:scale(0)}50%{opacity:.5;transform:scale(0.99)}100%{opacity:1;transform:scale(1)}}@keyframes mat-tooltip-hide{0%{opacity:1;transform:scale(1)}100%{opacity:0;transform:scale(1)}}.mat-tooltip-show{animation:mat-tooltip-show 200ms cubic-bezier(0, 0, 0.2, 1) forwards}.mat-tooltip-hide{animation:mat-tooltip-hide 100ms cubic-bezier(0, 0, 0.2, 1) forwards}"],encapsulation:2,changeDetection:0}),n})(),Qk=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[QQe],imports:[Ev,Me,ss,ln,ln,ud]}),n})();function tKe(n,t){if(1&n&&(_(0,"mat-option",19),A(1),v()),2&n){let e=t.$implicit;y("value",e),C(1),je(" ",e," ")}}function nKe(n,t){if(1&n){let e=Pe();_(0,"mat-form-field",16)(1,"mat-select",17),P("selectionChange",function(r){return oe(e),se(S(2)._changePageSize(r.value))}),E(2,tKe,2,2,"mat-option",18),v()()}if(2&n){let e=S(2);y("appearance",e._formFieldAppearance)("color",e.color),C(1),y("value",e.pageSize)("disabled",e.disabled)("panelClass",e.selectConfig.panelClass||"")("disableOptionCentering",e.selectConfig.disableOptionCentering)("aria-label",e._intl.itemsPerPageLabel),C(1),y("ngForOf",e._displayedPageSizeOptions)}}function iKe(n,t){if(1&n&&(_(0,"div",20),A(1),v()),2&n){let e=S(2);C(1),yt(e.pageSize)}}function rKe(n,t){if(1&n&&(_(0,"div",12)(1,"div",13),A(2),v(),E(3,nKe,3,8,"mat-form-field",14),E(4,iKe,2,1,"div",15),v()),2&n){let e=S();C(2),je(" ",e._intl.itemsPerPageLabel," "),C(1),y("ngIf",e._displayedPageSizeOptions.length>1),C(1),y("ngIf",e._displayedPageSizeOptions.length<=1)}}function oKe(n,t){if(1&n){let e=Pe();_(0,"button",21),P("click",function(){return oe(e),se(S().firstPage())}),In(),_(1,"svg",7),O(2,"path",22),v()()}if(2&n){let e=S();y("matTooltip",e._intl.firstPageLabel)("matTooltipDisabled",e._previousButtonsDisabled())("matTooltipPosition","above")("disabled",e._previousButtonsDisabled()),ze("aria-label",e._intl.firstPageLabel)}}function sKe(n,t){if(1&n){let e=Pe();In(),Js(),_(0,"button",23),P("click",function(){return oe(e),se(S().lastPage())}),In(),_(1,"svg",7),O(2,"path",24),v()()}if(2&n){let e=S();y("matTooltip",e._intl.lastPageLabel)("matTooltipDisabled",e._nextButtonsDisabled())("matTooltipPosition","above")("disabled",e._nextButtonsDisabled()),ze("aria-label",e._intl.lastPageLabel)}}Kr("state",[ki("initial, void, hidden",gn({opacity:0,transform:"scale(0)"})),ki("visible",gn({transform:"scale(1)"})),Li("* => visible",ji("200ms cubic-bezier(0, 0, 0.2, 1)",Dm([gn({opacity:0,transform:"scale(0)",offset:0}),gn({opacity:.5,transform:"scale(0.99)",offset:.5}),gn({opacity:1,transform:"scale(1)",offset:1})]))),Li("* => hidden",ji("100ms cubic-bezier(0, 0, 0.2, 1)",gn({opacity:0})))]);var e0=(()=>{class n{constructor(){this.changes=new ke,this.itemsPerPageLabel="Items per page:",this.nextPageLabel="Next page",this.previousPageLabel="Previous page",this.firstPageLabel="First page",this.lastPageLabel="Last page",this.getRangeLabel=(e,i,r)=>{if(0==r||0==i)return`0 of ${r}`;let o=e*i;return`${o+1} \u2013 ${o<(r=Math.max(r,0))?Math.min(o+i,r):o+i} of ${r}`}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),lKe={provide:e0,deps:[[new ns,new tl,e0]],useFactory:function(n){return n||new e0}},uKe=new pe("MAT_PAGINATOR_DEFAULT_OPTIONS"),dKe=so(m2(class{})),pKe=(()=>{class n extends dKe{constructor(e,i,r){if(super(),this._intl=e,this._changeDetectorRef=i,this._pageIndex=0,this._length=0,this._pageSizeOptions=[],this._hidePageSize=!1,this._showFirstLastButtons=!1,this.selectConfig={},this.page=new G,this._intlChanges=e.changes.subscribe(()=>this._changeDetectorRef.markForCheck()),r){let{pageSize:o,pageSizeOptions:s,hidePageSize:a,showFirstLastButtons:l}=r;null!=o&&(this._pageSize=o),null!=s&&(this._pageSizeOptions=s),null!=a&&(this._hidePageSize=a),null!=l&&(this._showFirstLastButtons=l)}}get pageIndex(){return this._pageIndex}set pageIndex(e){this._pageIndex=Math.max(Bi(e),0),this._changeDetectorRef.markForCheck()}get length(){return this._length}set length(e){this._length=Bi(e),this._changeDetectorRef.markForCheck()}get pageSize(){return this._pageSize}set pageSize(e){this._pageSize=Math.max(Bi(e),0),this._updateDisplayedPageSizeOptions()}get pageSizeOptions(){return this._pageSizeOptions}set pageSizeOptions(e){this._pageSizeOptions=(e||[]).map(i=>Bi(i)),this._updateDisplayedPageSizeOptions()}get hidePageSize(){return this._hidePageSize}set hidePageSize(e){this._hidePageSize=Rt(e)}get showFirstLastButtons(){return this._showFirstLastButtons}set showFirstLastButtons(e){this._showFirstLastButtons=Rt(e)}ngOnInit(){this._initialized=!0,this._updateDisplayedPageSizeOptions(),this._markInitialized()}ngOnDestroy(){this._intlChanges.unsubscribe()}nextPage(){if(!this.hasNextPage())return;let e=this.pageIndex;this.pageIndex=this.pageIndex+1,this._emitPageEvent(e)}previousPage(){if(!this.hasPreviousPage())return;let e=this.pageIndex;this.pageIndex=this.pageIndex-1,this._emitPageEvent(e)}firstPage(){if(!this.hasPreviousPage())return;let e=this.pageIndex;this.pageIndex=0,this._emitPageEvent(e)}lastPage(){if(!this.hasNextPage())return;let e=this.pageIndex;this.pageIndex=this.getNumberOfPages()-1,this._emitPageEvent(e)}hasPreviousPage(){return this.pageIndex>=1&&0!=this.pageSize}hasNextPage(){let e=this.getNumberOfPages()-1;return this.pageIndex<e&&0!=this.pageSize}getNumberOfPages(){return this.pageSize?Math.ceil(this.length/this.pageSize):0}_changePageSize(e){let r=this.pageIndex;this.pageIndex=Math.floor(this.pageIndex*this.pageSize/e)||0,this.pageSize=e,this._emitPageEvent(r)}_nextButtonsDisabled(){return this.disabled||!this.hasNextPage()}_previousButtonsDisabled(){return this.disabled||!this.hasPreviousPage()}_updateDisplayedPageSizeOptions(){!this._initialized||(this.pageSize||(this._pageSize=0!=this.pageSizeOptions.length?this.pageSizeOptions[0]:50),this._displayedPageSizeOptions=this.pageSizeOptions.slice(),-1===this._displayedPageSizeOptions.indexOf(this.pageSize)&&this._displayedPageSizeOptions.push(this.pageSize),this._displayedPageSizeOptions.sort((e,i)=>e-i),this._changeDetectorRef.markForCheck())}_emitPageEvent(e){this.page.emit({previousPageIndex:e,pageIndex:this.pageIndex,pageSize:this.pageSize,length:this.length})}}return n.\u0275fac=function(e){nl()},n.\u0275dir=He({type:n,inputs:{color:"color",pageIndex:"pageIndex",length:"length",pageSize:"pageSize",pageSizeOptions:"pageSizeOptions",hidePageSize:"hidePageSize",showFirstLastButtons:"showFirstLastButtons",selectConfig:"selectConfig"},outputs:{page:"page"},features:[tt]}),n})(),Kk=(()=>{class n extends pKe{constructor(e,i,r){super(e,i,r),r&&null!=r.formFieldAppearance&&(this._formFieldAppearance=r.formFieldAppearance)}}return n.\u0275fac=function(e){return new(e||n)(M(e0),M(nn),M(uKe,8))},n.\u0275cmp=R({type:n,selectors:[["mat-paginator"]],hostAttrs:["role","group",1,"mat-paginator"],inputs:{disabled:"disabled"},exportAs:["matPaginator"],features:[tt],decls:14,vars:14,consts:[[1,"mat-paginator-outer-container"],[1,"mat-paginator-container"],["class","mat-paginator-page-size",4,"ngIf"],[1,"mat-paginator-range-actions"],[1,"mat-paginator-range-label"],["mat-icon-button","","type","button","class","mat-paginator-navigation-first",3,"matTooltip","matTooltipDisabled","matTooltipPosition","disabled","click",4,"ngIf"],["mat-icon-button","","type","button",1,"mat-paginator-navigation-previous",3,"matTooltip","matTooltipDisabled","matTooltipPosition","disabled","click"],["viewBox","0 0 24 24","focusable","false",1,"mat-paginator-icon"],["d","M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"],["mat-icon-button","","type","button",1,"mat-paginator-navigation-next",3,"matTooltip","matTooltipDisabled","matTooltipPosition","disabled","click"],["d","M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"],["mat-icon-button","","type","button","class","mat-paginator-navigation-last",3,"matTooltip","matTooltipDisabled","matTooltipPosition","disabled","click",4,"ngIf"],[1,"mat-paginator-page-size"],[1,"mat-paginator-page-size-label"],["class","mat-paginator-page-size-select",3,"appearance","color",4,"ngIf"],["class","mat-paginator-page-size-value",4,"ngIf"],[1,"mat-paginator-page-size-select",3,"appearance","color"],[3,"value","disabled","panelClass","disableOptionCentering","aria-label","selectionChange"],[3,"value",4,"ngFor","ngForOf"],[3,"value"],[1,"mat-paginator-page-size-value"],["mat-icon-button","","type","button",1,"mat-paginator-navigation-first",3,"matTooltip","matTooltipDisabled","matTooltipPosition","disabled","click"],["d","M18.41 16.59L13.82 12l4.59-4.59L17 6l-6 6 6 6zM6 6h2v12H6z"],["mat-icon-button","","type","button",1,"mat-paginator-navigation-last",3,"matTooltip","matTooltipDisabled","matTooltipPosition","disabled","click"],["d","M5.59 7.41L10.18 12l-4.59 4.59L7 18l6-6-6-6zM16 6h2v12h-2z"]],template:function(e,i){1&e&&(_(0,"div",0)(1,"div",1),E(2,rKe,5,3,"div",2),_(3,"div",3)(4,"div",4),A(5),v(),E(6,oKe,3,5,"button",5),_(7,"button",6),P("click",function(){return i.previousPage()}),In(),_(8,"svg",7),O(9,"path",8),v()(),Js(),_(10,"button",9),P("click",function(){return i.nextPage()}),In(),_(11,"svg",7),O(12,"path",10),v()(),E(13,sKe,3,5,"button",11),v()()()),2&e&&(C(2),y("ngIf",!i.hidePageSize),C(3),je(" ",i._intl.getRangeLabel(i.pageIndex,i.pageSize,i.length)," "),C(1),y("ngIf",i.showFirstLastButtons),C(1),y("matTooltip",i._intl.previousPageLabel)("matTooltipDisabled",i._previousButtonsDisabled())("matTooltipPosition","above")("disabled",i._previousButtonsDisabled()),ze("aria-label",i._intl.previousPageLabel),C(3),y("matTooltip",i._intl.nextPageLabel)("matTooltipDisabled",i._nextButtonsDisabled())("matTooltipPosition","above")("disabled",i._nextButtonsDisabled()),ze("aria-label",i._intl.nextPageLabel),C(3),y("ngIf",i.showFirstLastButtons))},dependencies:[dn,Be,_n,pd,Hh,Os,Xk],styles:[".mat-paginator{display:block}.mat-paginator-outer-container{display:flex}.mat-paginator-container{display:flex;align-items:center;justify-content:flex-end;padding:0 8px;flex-wrap:wrap-reverse;width:100%}.mat-paginator-page-size{display:flex;align-items:baseline;margin-right:8px}[dir=rtl] .mat-paginator-page-size{margin-right:0;margin-left:8px}.mat-paginator-page-size-label{margin:0 4px}.mat-paginator-page-size-select{margin:6px 4px 0 4px;width:56px}.mat-paginator-page-size-select.mat-form-field-appearance-outline{width:64px}.mat-paginator-page-size-select.mat-form-field-appearance-fill{width:64px}.mat-paginator-range-label{margin:0 32px 0 24px}.mat-paginator-range-actions{display:flex;align-items:center}.mat-paginator-icon{display:inline-block;width:28px;fill:currentColor}[dir=rtl] .mat-paginator-icon{transform:rotate(180deg)}.cdk-high-contrast-active .mat-paginator-icon{fill:CanvasText}"],encapsulation:2,changeDetection:0}),n})(),Xpe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[lKe],imports:[Me,Pn,lc,Qk,ln]}),n})(),fKe=["mat-sort-header",""];function mKe(n,t){if(1&n){let e=Pe();_(0,"div",3),P("@arrowPosition.start",function(){return oe(e),se(S()._disableViewStateAnimation=!0)})("@arrowPosition.done",function(){return oe(e),se(S()._disableViewStateAnimation=!1)}),O(1,"div",4),_(2,"div",5),O(3,"div",6)(4,"div",7)(5,"div",8),v()()}if(2&n){let e=S();y("@arrowOpacity",e._getArrowViewState())("@arrowPosition",e._getArrowViewState())("@allowChildren",e._getArrowDirectionState()),C(2),y("@indicator",e._getArrowDirectionState()),C(1),y("@leftPointer",e._getArrowDirectionState()),C(1),y("@rightPointer",e._getArrowDirectionState())}}var gKe=["*"],Qpe=new pe("MAT_SORT_DEFAULT_OPTIONS"),_Ke=m2(so(class{})),ME=(()=>{class n extends _Ke{constructor(e){super(),this._defaultOptions=e,this.sortables=new Map,this._stateChanges=new ke,this.start="asc",this._direction="",this.sortChange=new G}get direction(){return this._direction}set direction(e){this._direction=e}get disableClear(){return this._disableClear}set disableClear(e){this._disableClear=Rt(e)}register(e){this.sortables.set(e.id,e)}deregister(e){this.sortables.delete(e.id)}sort(e){this.active!=e.id?(this.active=e.id,this.direction=e.start?e.start:this.start):this.direction=this.getNextSortDirection(e),this.sortChange.emit({active:this.active,direction:this.direction})}getNextSortDirection(e){if(!e)return"";let r=function(n,t){let e=["asc","desc"];return"desc"==n&&e.reverse(),t||e.push(""),e}(e.start||this.start,e?.disableClear??this.disableClear??!!this._defaultOptions?.disableClear),o=r.indexOf(this.direction)+1;return o>=r.length&&(o=0),r[o]}ngOnInit(){this._markInitialized()}ngOnChanges(){this._stateChanges.next()}ngOnDestroy(){this._stateChanges.complete()}}return n.\u0275fac=function(e){return new(e||n)(M(Qpe,8))},n.\u0275dir=He({type:n,selectors:[["","matSort",""]],hostAttrs:[1,"mat-sort"],inputs:{disabled:["matSortDisabled","disabled"],active:["matSortActive","active"],start:["matSortStart","start"],direction:["matSortDirection","direction"],disableClear:["matSortDisableClear","disableClear"]},outputs:{sortChange:"matSortChange"},exportAs:["matSort"],features:[tt,Ft]}),n})(),Af=ate.ENTERING+" "+ste.STANDARD_CURVE,Pb={indicator:Kr("indicator",[ki("active-asc, asc",gn({transform:"translateY(0px)"})),ki("active-desc, desc",gn({transform:"translateY(10px)"})),Li("active-asc <=> active-desc",ji(Af))]),leftPointer:Kr("leftPointer",[ki("active-asc, asc",gn({transform:"rotate(-45deg)"})),ki("active-desc, desc",gn({transform:"rotate(45deg)"})),Li("active-asc <=> active-desc",ji(Af))]),rightPointer:Kr("rightPointer",[ki("active-asc, asc",gn({transform:"rotate(45deg)"})),ki("active-desc, desc",gn({transform:"rotate(-45deg)"})),Li("active-asc <=> active-desc",ji(Af))]),arrowOpacity:Kr("arrowOpacity",[ki("desc-to-active, asc-to-active, active",gn({opacity:1})),ki("desc-to-hint, asc-to-hint, hint",gn({opacity:.54})),ki("hint-to-desc, active-to-desc, desc, hint-to-asc, active-to-asc, asc, void",gn({opacity:0})),Li("* => asc, * => desc, * => active, * => hint, * => void",ji("0ms")),Li("* <=> *",ji(Af))]),arrowPosition:Kr("arrowPosition",[Li("* => desc-to-hint, * => desc-to-active",ji(Af,Dm([gn({transform:"translateY(-25%)"}),gn({transform:"translateY(0)"})]))),Li("* => hint-to-desc, * => active-to-desc",ji(Af,Dm([gn({transform:"translateY(0)"}),gn({transform:"translateY(25%)"})]))),Li("* => asc-to-hint, * => asc-to-active",ji(Af,Dm([gn({transform:"translateY(25%)"}),gn({transform:"translateY(0)"})]))),Li("* => hint-to-asc, * => active-to-asc",ji(Af,Dm([gn({transform:"translateY(0)"}),gn({transform:"translateY(-25%)"})]))),ki("desc-to-hint, asc-to-hint, hint, desc-to-active, asc-to-active, active",gn({transform:"translateY(0)"})),ki("hint-to-desc, active-to-desc, desc",gn({transform:"translateY(-25%)"})),ki("hint-to-asc, active-to-asc, asc",gn({transform:"translateY(25%)"}))]),allowChildren:Kr("allowChildren",[Li("* <=> *",[Im("@*",Am(),{optional:!0})])])},Zk=(()=>{class n{constructor(){this.changes=new ke}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:n.\u0275fac,providedIn:"root"}),n})(),bKe={provide:Zk,deps:[[new ns,new tl,Zk]],useFactory:function(n){return n||new Zk}},xKe=so(class{}),Kpe=(()=>{class n extends xKe{constructor(e,i,r,o,s,a,l,c){super(),this._intl=e,this._changeDetectorRef=i,this._sort=r,this._columnDef=o,this._focusMonitor=s,this._elementRef=a,this._ariaDescriber=l,this._showIndicatorHint=!1,this._viewState={},this._arrowDirection="",this._disableViewStateAnimation=!1,this.arrowPosition="after",this._sortActionDescription="Sort",c?.arrowPosition&&(this.arrowPosition=c?.arrowPosition),this._handleStateChanges()}get sortActionDescription(){return this._sortActionDescription}set sortActionDescription(e){this._updateSortActionDescription(e)}get disableClear(){return this._disableClear}set disableClear(e){this._disableClear=Rt(e)}ngOnInit(){!this.id&&this._columnDef&&(this.id=this._columnDef.name),this._updateArrowDirection(),this._setAnimationTransitionState({toState:this._isSorted()?"active":this._arrowDirection}),this._sort.register(this),this._sortButton=this._elementRef.nativeElement.querySelector(".mat-sort-header-container"),this._updateSortActionDescription(this._sortActionDescription)}ngAfterViewInit(){this._focusMonitor.monitor(this._elementRef,!0).subscribe(e=>{let i=!!e;i!==this._showIndicatorHint&&(this._setIndicatorHintVisible(i),this._changeDetectorRef.markForCheck())})}ngOnDestroy(){this._focusMonitor.stopMonitoring(this._elementRef),this._sort.deregister(this),this._rerenderSubscription.unsubscribe()}_setIndicatorHintVisible(e){this._isDisabled()&&e||(this._showIndicatorHint=e,this._isSorted()||(this._updateArrowDirection(),this._setAnimationTransitionState(this._showIndicatorHint?{fromState:this._arrowDirection,toState:"hint"}:{fromState:"hint",toState:this._arrowDirection})))}_setAnimationTransitionState(e){this._viewState=e||{},this._disableViewStateAnimation&&(this._viewState={toState:e.toState})}_toggleOnInteraction(){this._sort.sort(this),("hint"===this._viewState.toState||"active"===this._viewState.toState)&&(this._disableViewStateAnimation=!0)}_handleClick(){this._isDisabled()||this._sort.sort(this)}_handleKeydown(e){!this._isDisabled()&&(32===e.keyCode||13===e.keyCode)&&(e.preventDefault(),this._toggleOnInteraction())}_isSorted(){return this._sort.active==this.id&&("asc"===this._sort.direction||"desc"===this._sort.direction)}_getArrowDirectionState(){return`${this._isSorted()?"active-":""}${this._arrowDirection}`}_getArrowViewState(){let e=this._viewState.fromState;return(e?`${e}-to-`:"")+this._viewState.toState}_updateArrowDirection(){this._arrowDirection=this._isSorted()?this._sort.direction:this.start||this._sort.start}_isDisabled(){return this._sort.disabled||this.disabled}_getAriaSortAttribute(){return this._isSorted()?"asc"==this._sort.direction?"ascending":"descending":"none"}_renderArrow(){return!this._isDisabled()||this._isSorted()}_updateSortActionDescription(e){this._sortButton&&(this._ariaDescriber?.removeDescription(this._sortButton,this._sortActionDescription),this._ariaDescriber?.describe(this._sortButton,e)),this._sortActionDescription=e}_handleStateChanges(){this._rerenderSubscription=Jt(this._sort.sortChange,this._sort._stateChanges,this._intl.changes).subscribe(()=>{this._isSorted()&&(this._updateArrowDirection(),("hint"===this._viewState.toState||"active"===this._viewState.toState)&&(this._disableViewStateAnimation=!0),this._setAnimationTransitionState({fromState:this._arrowDirection,toState:"active"}),this._showIndicatorHint=!1),!this._isSorted()&&this._viewState&&"active"===this._viewState.toState&&(this._disableViewStateAnimation=!1,this._setAnimationTransitionState({fromState:"active",toState:this._arrowDirection})),this._changeDetectorRef.markForCheck()})}}return n.\u0275fac=function(e){return new(e||n)(M(Zk),M(nn),M(ME,8),M("MAT_SORT_HEADER_COLUMN_DEF",8),M(Fr),M(Re),M(f2,8),M(Qpe,8))},n.\u0275cmp=R({type:n,selectors:[["","mat-sort-header",""]],hostAttrs:[1,"mat-sort-header"],hostVars:3,hostBindings:function(e,i){1&e&&P("click",function(){return i._handleClick()})("keydown",function(o){return i._handleKeydown(o)})("mouseenter",function(){return i._setIndicatorHintVisible(!0)})("mouseleave",function(){return i._setIndicatorHintVisible(!1)}),2&e&&(ze("aria-sort",i._getAriaSortAttribute()),et("mat-sort-header-disabled",i._isDisabled()))},inputs:{disabled:"disabled",id:["mat-sort-header","id"],arrowPosition:"arrowPosition",start:"start",sortActionDescription:"sortActionDescription",disableClear:"disableClear"},exportAs:["matSortHeader"],features:[tt],attrs:fKe,ngContentSelectors:gKe,decls:4,vars:7,consts:[[1,"mat-sort-header-container","mat-focus-indicator"],[1,"mat-sort-header-content"],["class","mat-sort-header-arrow",4,"ngIf"],[1,"mat-sort-header-arrow"],[1,"mat-sort-header-stem"],[1,"mat-sort-header-indicator"],[1,"mat-sort-header-pointer-left"],[1,"mat-sort-header-pointer-right"],[1,"mat-sort-header-pointer-middle"]],template:function(e,i){1&e&&(xi(),_(0,"div",0)(1,"div",1),Vn(2),v(),E(3,mKe,6,6,"div",2),v()),2&e&&(et("mat-sort-header-sorted",i._isSorted())("mat-sort-header-position-before","before"===i.arrowPosition),ze("tabindex",i._isDisabled()?null:0)("role",i._isDisabled()?null:"button"),C(3),y("ngIf",i._renderArrow()))},dependencies:[Be],styles:[".mat-sort-header-container{display:flex;cursor:pointer;align-items:center;letter-spacing:normal;outline:0}[mat-sort-header].cdk-keyboard-focused .mat-sort-header-container,[mat-sort-header].cdk-program-focused .mat-sort-header-container{border-bottom:solid 1px currentColor}.mat-sort-header-disabled .mat-sort-header-container{cursor:default}.mat-sort-header-container::before{margin:calc(calc(var(--mat-focus-indicator-border-width, 3px) + 2px) * -1)}.mat-sort-header-content{text-align:center;display:flex;align-items:center}.mat-sort-header-position-before{flex-direction:row-reverse}.mat-sort-header-arrow{height:12px;width:12px;min-width:12px;position:relative;display:flex;opacity:0}.mat-sort-header-arrow,[dir=rtl] .mat-sort-header-position-before .mat-sort-header-arrow{margin:0 0 0 6px}.mat-sort-header-position-before .mat-sort-header-arrow,[dir=rtl] .mat-sort-header-arrow{margin:0 6px 0 0}.mat-sort-header-stem{background:currentColor;height:10px;width:2px;margin:auto;display:flex;align-items:center}.cdk-high-contrast-active .mat-sort-header-stem{width:0;border-left:solid 2px}.mat-sort-header-indicator{width:100%;height:2px;display:flex;align-items:center;position:absolute;top:0;left:0}.mat-sort-header-pointer-middle{margin:auto;height:2px;width:2px;background:currentColor;transform:rotate(45deg)}.cdk-high-contrast-active .mat-sort-header-pointer-middle{width:0;height:0;border-top:solid 2px;border-left:solid 2px}.mat-sort-header-pointer-left,.mat-sort-header-pointer-right{background:currentColor;width:6px;height:2px;position:absolute;top:0}.cdk-high-contrast-active .mat-sort-header-pointer-left,.cdk-high-contrast-active .mat-sort-header-pointer-right{width:0;height:0;border-left:solid 6px;border-top:solid 2px}.mat-sort-header-pointer-left{transform-origin:right;left:0}.mat-sort-header-pointer-right{transform-origin:left;right:0}"],encapsulation:2,data:{animation:[Pb.indicator,Pb.leftPointer,Pb.rightPointer,Pb.arrowOpacity,Pb.arrowPosition,Pb.allowChildren]},changeDetection:0}),n})(),Zpe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[bKe],imports:[Me,ln]}),n})();function jG(n){return class extends n{constructor(...t){super(...t),this._sticky=!1,this._hasStickyChanged=!1}get sticky(){return this._sticky}set sticky(t){let e=this._sticky;this._sticky=Rt(t),this._hasStickyChanged=e!==this._sticky}hasStickyChanged(){let t=this._hasStickyChanged;return this._hasStickyChanged=!1,t}resetStickyChanged(){this._hasStickyChanged=!1}}}var GG=new pe("CDK_TABLE"),Jpe=(new pe("text-column-options"),jG(class{}),new pe("_COALESCED_STYLE_SCHEDULER"),(()=>{class n{constructor(e,i){this.template=e,this._differs=i}ngOnChanges(e){if(!this._columnsDiffer){let i=e.columns&&e.columns.currentValue||[];this._columnsDiffer=this._differs.find(i).create(),this._columnsDiffer.diff(i)}}getColumnsDiff(){return this._columnsDiffer.diff(this.columns)}extractCellTemplate(e){return this instanceof $pe?e.headerCell.template:this instanceof ehe?e.footerCell.template:e.cell.template}}return n.\u0275fac=function(e){return new(e||n)(M(Vi),M(kc))},n.\u0275dir=He({type:n,features:[Ft]}),n})()),wKe=jG(class extends Jpe{}),$pe=(()=>{class n extends wKe{constructor(e,i,r){super(e,i),this._table=r}ngOnChanges(e){super.ngOnChanges(e)}}return n.\u0275fac=function(e){return new(e||n)(M(Vi),M(kc),M(GG,8))},n.\u0275dir=He({type:n,selectors:[["","cdkHeaderRowDef",""]],inputs:{columns:["cdkHeaderRowDef","columns"],sticky:["cdkHeaderRowDefSticky","sticky"]},features:[tt,Ft]}),n})(),SKe=jG(class extends Jpe{}),ehe=(()=>{class n extends SKe{constructor(e,i,r){super(e,i),this._table=r}ngOnChanges(e){super.ngOnChanges(e)}}return n.\u0275fac=function(e){return new(e||n)(M(Vi),M(kc),M(GG,8))},n.\u0275dir=He({type:n,selectors:[["","cdkFooterRowDef",""]],inputs:{columns:["cdkFooterRowDef","columns"],sticky:["cdkFooterRowDefSticky","sticky"]},features:[tt,Ft]}),n})(),the=(new pe("CDK_SPL"),(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Zc]}),n})()),nhe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[the,ln,ln]}),n})(),WG=class extends Pv{constructor(t=[]){super(),this._renderData=new hr([]),this._filter=new hr(""),this._internalPageChanges=new ke,this._renderChangesSubscription=null,this.sortingDataAccessor=(e,i)=>{let r=e[i];if(hH(r)){let o=Number(r);return o<9007199254740991?o:r}return r},this.sortData=(e,i)=>{let r=i.active,o=i.direction;return r&&""!=o?e.sort((s,a)=>{let l=this.sortingDataAccessor(s,r),c=this.sortingDataAccessor(a,r),u=typeof l,d=typeof c;u!==d&&("number"===u&&(l+=""),"number"===d&&(c+=""));let p=0;return null!=l&&null!=c?l>c?p=1:l<c&&(p=-1):null!=l?p=1:null!=c&&(p=-1),p*("asc"==o?1:-1)}):e},this.filterPredicate=(e,i)=>{let r=Object.keys(e).reduce((s,a)=>s+e[a]+"\u25ec","").toLowerCase(),o=i.trim().toLowerCase();return-1!=r.indexOf(o)},this._data=new hr(t),this._updateChangeSubscription()}get data(){return this._data.value}set data(t){t=Array.isArray(t)?t:[],this._data.next(t),this._renderChangesSubscription||this._filterData(t)}get filter(){return this._filter.value}set filter(t){this._filter.next(t),this._renderChangesSubscription||this._filterData(this.data)}get sort(){return this._sort}set sort(t){this._sort=t,this._updateChangeSubscription()}get paginator(){return this._paginator}set paginator(t){this._paginator=t,this._updateChangeSubscription()}_updateChangeSubscription(){let t=this._sort?Jt(this._sort.sortChange,this._sort.initialized):Xt(null),e=this._paginator?Jt(this._paginator.page,this._internalPageChanges,this._paginator.initialized):Xt(null),r=Lt([this._data,this._filter]).pipe(L(([a])=>this._filterData(a))),o=Lt([r,t]).pipe(L(([a])=>this._orderData(a))),s=Lt([o,e]).pipe(L(([a])=>this._pageData(a)));this._renderChangesSubscription?.unsubscribe(),this._renderChangesSubscription=s.subscribe(a=>this._renderData.next(a))}_filterData(t){return this.filteredData=null==this.filter||""===this.filter?t:t.filter(e=>this.filterPredicate(e,this.filter)),this.paginator&&this._updatePaginator(this.filteredData.length),this.filteredData}_orderData(t){return this.sort?this.sortData(t.slice(),this.sort):t}_pageData(t){if(!this.paginator)return t;let e=this.paginator.pageIndex*this.paginator.pageSize;return t.slice(e,e+this.paginator.pageSize)}_updatePaginator(t){Promise.resolve().then(()=>{let e=this.paginator;if(e&&(e.length=t,e.pageIndex>0)){let i=Math.ceil(e.length/e.pageSize)-1||0,r=Math.min(e.pageIndex,i);r!==e.pageIndex&&(e.pageIndex=r,this._internalPageChanges.next())}})}connect(){return this._renderChangesSubscription||this._updateChangeSubscription(),this._renderData}disconnect(){this._renderChangesSubscription?.unsubscribe(),this._renderChangesSubscription=null}},Jk=class extends WG{},DKe=["dialogPopup"],AKe=["hueSlider"],IKe=["alphaSlider"];function PKe(n,t){if(1&n&&O(0,"div"),2&n){let e=S();Qx("arrow arrow-",e.cpUsePosition,""),Pt("top",e.arrowTop,"px")}}function RKe(n,t){if(1&n){let e=Pe();_(0,"div",28),P("newValue",function(r){return oe(e),se(S().onColorChange(r))})("dragStart",function(){return oe(e),se(S().onDragStart("saturation-lightness"))})("dragEnd",function(){return oe(e),se(S().onDragEnd("saturation-lightness"))}),O(1,"div",14),v()}if(2&n){let e=S();Pt("background-color",e.hueSliderColor),y("rgX",1)("rgY",1),C(1),Pt("top",null==e.slider?null:e.slider.v,"px")("left",null==e.slider?null:e.slider.s,"px")}}function OKe(n,t){1&n&&(In(),_(0,"svg",29),O(1,"path",30)(2,"path",31),v())}function kKe(n,t){if(1&n){let e=Pe();_(0,"button",32),P("click",function(r){oe(e);let o=S();return se(o.onAddPresetColor(r,o.selectedColor))}),A(1),v()}if(2&n){let e=S();Da(e.cpAddColorButtonClass),y("disabled",e.cpPresetColors&&e.cpPresetColors.length>=e.cpMaxPresetColorsLength),C(1),je(" ",e.cpAddColorButtonText," ")}}function FKe(n,t){1&n&&O(0,"div",33)}function NKe(n,t){if(1&n){let e=Pe();_(0,"input",39),P("keyup.enter",function(r){return oe(e),se(S(2).onAcceptColor(r))})("newValue",function(r){return oe(e),se(S(2).onAlphaInput(r))}),v()}if(2&n){let e=S(2);y("rg",1)("value",null==e.cmykText?null:e.cmykText.a)}}function LKe(n,t){1&n&&(_(0,"div"),A(1,"A"),v())}function BKe(n,t){if(1&n){let e=Pe();_(0,"div",34)(1,"div",35)(2,"input",36),P("keyup.enter",function(r){return oe(e),se(S().onAcceptColor(r))})("newValue",function(r){return oe(e),se(S().onCyanInput(r))}),v(),_(3,"input",36),P("keyup.enter",function(r){return oe(e),se(S().onAcceptColor(r))})("newValue",function(r){return oe(e),se(S().onMagentaInput(r))}),v(),_(4,"input",36),P("keyup.enter",function(r){return oe(e),se(S().onAcceptColor(r))})("newValue",function(r){return oe(e),se(S().onYellowInput(r))}),v(),_(5,"input",36),P("keyup.enter",function(r){return oe(e),se(S().onAcceptColor(r))})("newValue",function(r){return oe(e),se(S().onBlackInput(r))}),v(),E(6,NKe,1,2,"input",37),v(),_(7,"div",35)(8,"div"),A(9,"C"),v(),_(10,"div"),A(11,"M"),v(),_(12,"div"),A(13,"Y"),v(),_(14,"div"),A(15,"K"),v(),E(16,LKe,2,0,"div",38),v()()}if(2&n){let e=S();Pt("display",3!==e.format?"none":"block"),C(2),y("rg",100)("value",null==e.cmykText?null:e.cmykText.c),C(1),y("rg",100)("value",null==e.cmykText?null:e.cmykText.m),C(1),y("rg",100)("value",null==e.cmykText?null:e.cmykText.y),C(1),y("rg",100)("value",null==e.cmykText?null:e.cmykText.k),C(1),y("ngIf","disabled"!==e.cpAlphaChannel),C(10),y("ngIf","disabled"!==e.cpAlphaChannel)}}function VKe(n,t){if(1&n){let e=Pe();_(0,"input",39),P("keyup.enter",function(r){return oe(e),se(S(2).onAcceptColor(r))})("newValue",function(r){return oe(e),se(S(2).onAlphaInput(r))}),v()}if(2&n){let e=S(2);y("rg",1)("value",null==e.hslaText?null:e.hslaText.a)}}function HKe(n,t){1&n&&(_(0,"div"),A(1,"A"),v())}function UKe(n,t){if(1&n){let e=Pe();_(0,"div",40)(1,"div",35)(2,"input",41),P("keyup.enter",function(r){return oe(e),se(S().onAcceptColor(r))})("newValue",function(r){return oe(e),se(S().onHueInput(r))}),v(),_(3,"input",36),P("keyup.enter",function(r){return oe(e),se(S().onAcceptColor(r))})("newValue",function(r){return oe(e),se(S().onSaturationInput(r))}),v(),_(4,"input",36),P("keyup.enter",function(r){return oe(e),se(S().onAcceptColor(r))})("newValue",function(r){return oe(e),se(S().onLightnessInput(r))}),v(),E(5,VKe,1,2,"input",37),v(),_(6,"div",35)(7,"div"),A(8,"H"),v(),_(9,"div"),A(10,"S"),v(),_(11,"div"),A(12,"L"),v(),E(13,HKe,2,0,"div",38),v()()}if(2&n){let e=S();Pt("display",2!==e.format?"none":"block"),C(2),y("rg",360)("value",null==e.hslaText?null:e.hslaText.h),C(1),y("rg",100)("value",null==e.hslaText?null:e.hslaText.s),C(1),y("rg",100)("value",null==e.hslaText?null:e.hslaText.l),C(1),y("ngIf","disabled"!==e.cpAlphaChannel),C(8),y("ngIf","disabled"!==e.cpAlphaChannel)}}function zKe(n,t){if(1&n){let e=Pe();_(0,"input",39),P("keyup.enter",function(r){return oe(e),se(S(2).onAcceptColor(r))})("newValue",function(r){return oe(e),se(S(2).onAlphaInput(r))}),v()}if(2&n){let e=S(2);y("rg",1)("value",null==e.rgbaText?null:e.rgbaText.a)}}function jKe(n,t){1&n&&(_(0,"div"),A(1,"A"),v())}function GKe(n,t){if(1&n){let e=Pe();_(0,"div",42)(1,"div",35)(2,"input",43),P("keyup.enter",function(r){return oe(e),se(S().onAcceptColor(r))})("newValue",function(r){return oe(e),se(S().onRedInput(r))}),v(),_(3,"input",43),P("keyup.enter",function(r){return oe(e),se(S().onAcceptColor(r))})("newValue",function(r){return oe(e),se(S().onGreenInput(r))}),v(),_(4,"input",43),P("keyup.enter",function(r){return oe(e),se(S().onAcceptColor(r))})("newValue",function(r){return oe(e),se(S().onBlueInput(r))}),v(),E(5,zKe,1,2,"input",37),v(),_(6,"div",35)(7,"div"),A(8,"R"),v(),_(9,"div"),A(10,"G"),v(),_(11,"div"),A(12,"B"),v(),E(13,jKe,2,0,"div",38),v()()}if(2&n){let e=S();Pt("display",1!==e.format?"none":"block"),C(2),y("rg",255)("value",null==e.rgbaText?null:e.rgbaText.r),C(1),y("rg",255)("value",null==e.rgbaText?null:e.rgbaText.g),C(1),y("rg",255)("value",null==e.rgbaText?null:e.rgbaText.b),C(1),y("ngIf","disabled"!==e.cpAlphaChannel),C(8),y("ngIf","disabled"!==e.cpAlphaChannel)}}function WKe(n,t){if(1&n){let e=Pe();_(0,"input",39),P("keyup.enter",function(r){return oe(e),se(S(2).onAcceptColor(r))})("newValue",function(r){return oe(e),se(S(2).onAlphaInput(r))}),v()}if(2&n){let e=S(2);y("rg",1)("value",e.hexAlpha)}}function qKe(n,t){1&n&&(_(0,"div"),A(1,"A"),v())}function YKe(n,t){if(1&n){let e=Pe();_(0,"div",44)(1,"div",35)(2,"input",45),P("blur",function(){return oe(e),se(S().onHexInput(null))})("keyup.enter",function(r){return oe(e),se(S().onAcceptColor(r))})("newValue",function(r){return oe(e),se(S().onHexInput(r))}),v(),E(3,WKe,1,2,"input",37),v(),_(4,"div",35)(5,"div"),A(6,"Hex"),v(),E(7,qKe,2,0,"div",38),v()()}if(2&n){let e=S();Pt("display",0!==e.format?"none":"block"),et("hex-alpha","forced"===e.cpAlphaChannel),C(2),y("value",e.hexText),C(1),y("ngIf","forced"===e.cpAlphaChannel),C(4),y("ngIf","forced"===e.cpAlphaChannel)}}function XKe(n,t){if(1&n){let e=Pe();_(0,"input",39),P("keyup.enter",function(r){return oe(e),se(S(2).onAcceptColor(r))})("newValue",function(r){return oe(e),se(S(2).onAlphaInput(r))}),v()}if(2&n){let e=S(2);y("rg",1)("value",null==e.hslaText?null:e.hslaText.a)}}function QKe(n,t){if(1&n){let e=Pe();_(0,"div",46)(1,"div",35)(2,"input",36),P("keyup.enter",function(r){return oe(e),se(S().onAcceptColor(r))})("newValue",function(r){return oe(e),se(S().onValueInput(r))}),v(),E(3,XKe,1,2,"input",37),v(),_(4,"div",35)(5,"div"),A(6,"V"),v(),_(7,"div"),A(8,"A"),v()()()}if(2&n){let e=S();C(2),y("rg",100)("value",null==e.hslaText?null:e.hslaText.l),C(1),y("ngIf","disabled"!==e.cpAlphaChannel)}}function KKe(n,t){if(1&n){let e=Pe();_(0,"div",47)(1,"span",48),P("click",function(){return oe(e),se(S().onFormatToggle(-1))}),v(),_(2,"span",48),P("click",function(){return oe(e),se(S().onFormatToggle(1))}),v()()}}function ZKe(n,t){if(1&n){let e=Pe();_(0,"span",55),P("click",function(r){oe(e);let o=S().$implicit;return se(S(3).onRemovePresetColor(r,o))}),v()}2&n&&Da(S(4).cpRemoveColorButtonClass)}function JKe(n,t){if(1&n){let e=Pe();_(0,"div",53),P("click",function(){let o=oe(e).$implicit;return se(S(3).setColorFromString(o))}),E(1,ZKe,1,3,"span",54),v()}if(2&n){let e=t.$implicit,i=S(3);Pt("background-color",e),C(1),y("ngIf",i.cpAddColorButton)}}function $Ke(n,t){if(1&n&&(_(0,"div"),E(1,JKe,2,3,"div",52),v()),2&n){let e=S(2);Da(e.cpPresetColorsClass),C(1),y("ngForOf",e.cpPresetColors)}}function eZe(n,t){if(1&n&&(_(0,"div"),A(1),v()),2&n){let e=S(2);Da(e.cpPresetEmptyMessageClass),C(1),yt(e.cpPresetEmptyMessage)}}function tZe(n,t){if(1&n&&(_(0,"div",49),O(1,"hr"),_(2,"div",50),A(3),v(),E(4,$Ke,2,4,"div",51),E(5,eZe,2,4,"div",51),v()),2&n){let e=S();C(3),yt(e.cpPresetLabel),C(1),y("ngIf",null==e.cpPresetColors?null:e.cpPresetColors.length),C(1),y("ngIf",!(null!=e.cpPresetColors&&e.cpPresetColors.length)&&e.cpAddColorButton)}}function nZe(n,t){if(1&n){let e=Pe();_(0,"button",58),P("click",function(r){return oe(e),se(S(2).onCancelColor(r))}),A(1),v()}if(2&n){let e=S(2);Da(e.cpCancelButtonClass),C(1),yt(e.cpCancelButtonText)}}function iZe(n,t){if(1&n){let e=Pe();_(0,"button",58),P("click",function(r){return oe(e),se(S(2).onAcceptColor(r))}),A(1),v()}if(2&n){let e=S(2);Da(e.cpOKButtonClass),C(1),yt(e.cpOKButtonText)}}function rZe(n,t){if(1&n&&(_(0,"div",56),E(1,nZe,2,4,"button",57),E(2,iZe,2,4,"button",57),v()),2&n){let e=S();C(1),y("ngIf",e.cpCancelButton),C(1),y("ngIf",e.cpOKButton)}}function oZe(n,t){1&n&&Ni(0)}function sZe(n,t){if(1&n&&(_(0,"div",59),E(1,oZe,1,0,"ng-container",60),v()),2&n){let e=S();C(1),y("ngTemplateOutlet",e.cpExtraTemplate)}}var ws=(()=>(function(n){n[n.HEX=0]="HEX",n[n.RGBA=1]="RGBA",n[n.HSLA=2]="HSLA",n[n.CMYK=3]="CMYK"}(ws||(ws={})),ws))(),hu=class{constructor(t,e,i,r){this.r=t,this.g=e,this.b=i,this.a=r}},Rb=class{constructor(t,e,i,r){this.h=t,this.s=e,this.v=i,this.a=r}},Rp=class{constructor(t,e,i,r){this.h=t,this.s=e,this.l=i,this.a=r}},t0=class{constructor(t,e,i,r,o=1){this.c=t,this.m=e,this.y=i,this.k=r,this.a=o}},cZe=(()=>{class n{constructor(){this.newValue=new G}inputChange(e){let i=e.target.value;if(void 0===this.rg)this.newValue.emit(i);else{let r=parseFloat(i);this.newValue.emit({v:r,rg:this.rg})}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275dir=He({type:n,selectors:[["","text",""]],hostBindings:function(e,i){1&e&&P("input",function(o){return i.inputChange(o)})},inputs:{rg:"rg",text:"text"},outputs:{newValue:"newValue"}}),n})(),uZe=(()=>{class n{constructor(e){this.elRef=e,this.dragEnd=new G,this.dragStart=new G,this.newValue=new G,this.listenerMove=i=>this.move(i),this.listenerStop=()=>this.stop()}mouseDown(e){this.start(e)}touchStart(e){this.start(e)}move(e){e.preventDefault(),this.setCursor(e)}start(e){this.setCursor(e),e.stopPropagation(),document.addEventListener("mouseup",this.listenerStop),document.addEventListener("touchend",this.listenerStop),document.addEventListener("mousemove",this.listenerMove),document.addEventListener("touchmove",this.listenerMove),this.dragStart.emit()}stop(){document.removeEventListener("mouseup",this.listenerStop),document.removeEventListener("touchend",this.listenerStop),document.removeEventListener("mousemove",this.listenerMove),document.removeEventListener("touchmove",this.listenerMove),this.dragEnd.emit()}getX(e){let i=this.elRef.nativeElement.getBoundingClientRect();return(void 0!==e.pageX?e.pageX:e.touches[0].pageX)-i.left-window.pageXOffset}getY(e){let i=this.elRef.nativeElement.getBoundingClientRect();return(void 0!==e.pageY?e.pageY:e.touches[0].pageY)-i.top-window.pageYOffset}setCursor(e){let i=this.elRef.nativeElement.offsetWidth,r=this.elRef.nativeElement.offsetHeight,o=Math.max(0,Math.min(this.getX(e),i)),s=Math.max(0,Math.min(this.getY(e),r));void 0!==this.rgX&&void 0!==this.rgY?this.newValue.emit({s:o/i,v:1-s/r,rgX:this.rgX,rgY:this.rgY}):void 0===this.rgX&&void 0!==this.rgY?this.newValue.emit({v:s/r,rgY:this.rgY}):void 0!==this.rgX&&void 0===this.rgY&&this.newValue.emit({v:o/i,rgX:this.rgX})}}return n.\u0275fac=function(e){return new(e||n)(M(Re))},n.\u0275dir=He({type:n,selectors:[["","slider",""]],hostBindings:function(e,i){1&e&&P("mousedown",function(o){return i.mouseDown(o)})("touchstart",function(o){return i.touchStart(o)})},inputs:{rgX:"rgX",rgY:"rgY",slider:"slider"},outputs:{dragEnd:"dragEnd",dragStart:"dragStart",newValue:"newValue"}}),n})(),$k=class{constructor(t,e,i,r){this.h=t,this.s=e,this.v=i,this.a=r}},eF=class{constructor(t,e,i,r){this.h=t,this.s=e,this.v=i,this.a=r}},qG=(()=>{class n{constructor(){this.active=null}setActive(e){this.active&&this.active!==e&&"inline"!==this.active.cpDialogDisplay&&this.active.closeDialog(),this.active=e}hsva2hsla(e){let i=e.h,r=e.s,o=e.v,s=e.a;if(0===o)return new Rp(i,0,0,s);if(0===r&&1===o)return new Rp(i,1,1,s);{let a=o*(2-r)/2;return new Rp(i,o*r/(1-Math.abs(2*a-1)),a,s)}}hsla2hsva(e){let i=Math.min(e.h,1),r=Math.min(e.s,1),o=Math.min(e.l,1),s=Math.min(e.a,1);if(0===o)return new Rb(i,0,0,s);{let a=o+r*(1-Math.abs(2*o-1))/2;return new Rb(i,2*(a-o)/a,a,s)}}hsvaToRgba(e){let i,r,o,s=e.h,a=e.s,l=e.v,c=e.a,u=Math.floor(6*s),d=6*s-u,p=l*(1-a),h=l*(1-d*a),f=l*(1-(1-d)*a);switch(u%6){case 0:i=l,r=f,o=p;break;case 1:i=h,r=l,o=p;break;case 2:i=p,r=l,o=f;break;case 3:i=p,r=h,o=l;break;case 4:i=f,r=p,o=l;break;case 5:i=l,r=p,o=h;break;default:i=0,r=0,o=0}return new hu(i,r,o,c)}cmykToRgb(e){return new hu((1-e.c)*(1-e.k),(1-e.m)*(1-e.k),(1-e.y)*(1-e.k),e.a)}rgbaToCmyk(e){let i=1-Math.max(e.r,e.g,e.b);return 1===i?new t0(0,0,0,1,e.a):new t0((1-e.r-i)/(1-i),(1-e.g-i)/(1-i),(1-e.b-i)/(1-i),i,e.a)}rgbaToHsva(e){let i,r,o=Math.min(e.r,1),s=Math.min(e.g,1),a=Math.min(e.b,1),l=Math.min(e.a,1),c=Math.max(o,s,a),u=Math.min(o,s,a),d=c,p=c-u;if(r=0===c?0:p/c,c===u)i=0;else{switch(c){case o:i=(s-a)/p+(s<a?6:0);break;case s:i=(a-o)/p+2;break;case a:i=(o-s)/p+4;break;default:i=0}i/=6}return new Rb(i,r,d,l)}rgbaToHex(e,i){let r="#"+(16777216|e.r<<16|e.g<<8|e.b).toString(16).substr(1);return i&&(r+=(256|Math.round(255*e.a)).toString(16).substr(1)),r}normalizeCMYK(e){return new t0(e.c/100,e.m/100,e.y/100,e.k/100,e.a)}denormalizeCMYK(e){return new t0(Math.floor(100*e.c),Math.floor(100*e.m),Math.floor(100*e.y),Math.floor(100*e.k),e.a)}denormalizeRGBA(e){return new hu(Math.round(255*e.r),Math.round(255*e.g),Math.round(255*e.b),e.a)}stringToHsva(e="",i=!1){let r=null;e=(e||"").toLowerCase();let o=[{re:/(rgb)a?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*%?,\s*(\d{1,3})\s*%?(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/,parse:function(s){return new hu(parseInt(s[2],10)/255,parseInt(s[3],10)/255,parseInt(s[4],10)/255,isNaN(parseFloat(s[5]))?1:parseFloat(s[5]))}},{re:/(hsl)a?\(\s*(\d{1,3})\s*,\s*(\d{1,3})%\s*,\s*(\d{1,3})%\s*(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/,parse:function(s){return new Rp(parseInt(s[2],10)/360,parseInt(s[3],10)/100,parseInt(s[4],10)/100,isNaN(parseFloat(s[5]))?1:parseFloat(s[5]))}}];o.push(i?{re:/#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})?$/,parse:function(s){return new hu(parseInt(s[1],16)/255,parseInt(s[2],16)/255,parseInt(s[3],16)/255,parseInt(s[4]||"FF",16)/255)}}:{re:/#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})$/,parse:function(s){return new hu(parseInt(s[1],16)/255,parseInt(s[2],16)/255,parseInt(s[3],16)/255,1)}}),o.push({re:/#([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])$/,parse:function(s){return new hu(parseInt(s[1]+s[1],16)/255,parseInt(s[2]+s[2],16)/255,parseInt(s[3]+s[3],16)/255,1)}});for(let s in o)if(o.hasOwnProperty(s)){let a=o[s],l=a.re.exec(e),c=l&&a.parse(l);if(c)return c instanceof hu?r=this.rgbaToHsva(c):c instanceof Rp&&(r=this.hsla2hsva(c)),r}return r}outputFormat(e,i,r){switch("auto"===i&&(i=e.a<1?"rgba":"hex"),i){case"hsla":let o=this.hsva2hsla(e),s=new Rp(Math.round(360*o.h),Math.round(100*o.s),Math.round(100*o.l),Math.round(100*o.a)/100);return e.a<1||"always"===r?"hsla("+s.h+","+s.s+"%,"+s.l+"%,"+s.a+")":"hsl("+s.h+","+s.s+"%,"+s.l+"%)";case"rgba":let a=this.denormalizeRGBA(this.hsvaToRgba(e));return e.a<1||"always"===r?"rgba("+a.r+","+a.g+","+a.b+","+Math.round(100*a.a)/100+")":"rgb("+a.r+","+a.g+","+a.b+")";default:let l="always"===r||"forced"===r;return this.rgbaToHex(this.denormalizeRGBA(this.hsvaToRgba(e)),l)}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),ihe=typeof window<"u"&&"ontouchstart"in window,dZe=(()=>{class n{constructor(e,i,r,o,s,a){this.ngZone=e,this.elRef=i,this.cdRef=r,this.document=o,this.platformId=s,this.service=a,this.isIE10=!1,this.dialogArrowSize=10,this.dialogArrowOffset=15,this.dialogInputFields=[ws.HEX,ws.RGBA,ws.HSLA,ws.CMYK],this.useRootViewContainer=!1,this.eyeDropperSupported=XD(this.platformId)&&"EyeDropper"in this.document.defaultView}handleEsc(e){this.show&&"popup"===this.cpDialogDisplay&&this.onCancelColor(e)}handleEnter(e){this.show&&"popup"===this.cpDialogDisplay&&this.onAcceptColor(e)}ngOnInit(){this.slider=new $k(0,0,0,0),this.sliderDimMax=new eF(this.hueSlider.nativeElement.offsetWidth||140,this.cpWidth,130,this.alphaSlider.nativeElement.offsetWidth||140),this.format=this.cpCmykEnabled?ws.CMYK:"rgba"===this.cpOutputFormat?ws.RGBA:"hsla"===this.cpOutputFormat?ws.HSLA:ws.HEX,this.listenerMouseDown=r=>{this.onMouseDown(r)},this.listenerResize=()=>{this.onResize()},this.openDialog(this.initialColor,!1)}ngOnDestroy(){this.closeDialog()}ngAfterViewInit(){230===this.cpWidth&&"inline"!==this.cpDialogDisplay||(this.sliderDimMax=new eF(this.hueSlider.nativeElement.offsetWidth||140,this.cpWidth,130,this.alphaSlider.nativeElement.offsetWidth||140),this.updateColorPicker(!1),this.cdRef.detectChanges())}openDialog(e,i=!0){this.service.setActive(this),this.width||(this.cpWidth=this.directiveElementRef.nativeElement.offsetWidth),this.height||(this.height=320),this.setInitialColor(e),this.setColorFromString(e,i),this.openColorPicker()}closeDialog(){this.closeColorPicker()}setupDialog(e,i,r,o,s,a,l,c,u,d,p,h,f,m,x,g,b,D,T,k,Z,z,fe,ue,he,w,F,q,K,de,Y,ae,le,Ie,ve,De,nt,gt){this.setInitialColor(r),this.setColorMode(c),this.isIE10=10===function(){let n="";typeof navigator<"u"&&(n=navigator.userAgent.toLowerCase());let t=n.indexOf("msie ");return t>0&&parseInt(n.substring(t+5,n.indexOf(".",t)),10)}(),this.directiveInstance=e,this.directiveElementRef=i,this.cpDisableInput=h,this.cpCmykEnabled=u,this.cpAlphaChannel=d,this.cpOutputFormat=p,this.cpDialogDisplay=a,this.cpIgnoredElements=f,this.cpSaveClickOutside=m,this.cpCloseClickOutside=x,this.useRootViewContainer=g,this.width=this.cpWidth=parseInt(o,10),this.height=this.cpHeight=parseInt(s,10),this.cpPosition=b,this.cpPositionOffset=parseInt(D,10),this.cpOKButton=w,this.cpOKButtonText=q,this.cpOKButtonClass=F,this.cpCancelButton=K,this.cpCancelButtonText=Y,this.cpCancelButtonClass=de,this.cpEyeDropper=De,this.fallbackColor=l||"#fff",this.setPresetConfig(k,Z),this.cpPresetColorsClass=z,this.cpMaxPresetColorsLength=fe,this.cpPresetEmptyMessage=ue,this.cpPresetEmptyMessageClass=he,this.cpAddColorButton=ae,this.cpAddColorButtonText=Ie,this.cpAddColorButtonClass=le,this.cpRemoveColorButtonClass=ve,this.cpTriggerElement=nt,this.cpExtraTemplate=gt,T||(this.dialogArrowOffset=0),"inline"===a&&(this.dialogArrowSize=0,this.dialogArrowOffset=0),"hex"===p&&"always"!==d&&"forced"!==d&&(this.cpAlphaChannel="disabled")}setColorMode(e){switch(e.toString().toUpperCase()){case"1":case"C":case"COLOR":default:this.cpColorMode=1;break;case"2":case"G":case"GRAYSCALE":this.cpColorMode=2;break;case"3":case"P":case"PRESETS":this.cpColorMode=3}}setInitialColor(e){this.initialColor=e}setPresetConfig(e,i){this.cpPresetLabel=e,this.cpPresetColors=i}setColorFromString(e,i=!0,r=!0){let o;"always"===this.cpAlphaChannel||"forced"===this.cpAlphaChannel?(o=this.service.stringToHsva(e,!0),!o&&!this.hsva&&(o=this.service.stringToHsva(e,!1))):o=this.service.stringToHsva(e,!1),!o&&!this.hsva&&(o=this.service.stringToHsva(this.fallbackColor,!1)),o&&(this.hsva=o,this.sliderH=this.hsva.h,"hex"===this.cpOutputFormat&&"disabled"===this.cpAlphaChannel&&(this.hsva.a=1),this.updateColorPicker(i,r))}onResize(){"fixed"===this.position?this.setDialogPosition():"inline"!==this.cpDialogDisplay&&this.closeColorPicker()}onDragEnd(e){this.directiveInstance.sliderDragEnd({slider:e,color:this.outputColor})}onDragStart(e){this.directiveInstance.sliderDragStart({slider:e,color:this.outputColor})}onMouseDown(e){this.show&&!this.isIE10&&"popup"===this.cpDialogDisplay&&e.target!==this.directiveElementRef.nativeElement&&!this.isDescendant(this.elRef.nativeElement,e.target)&&!this.isDescendant(this.directiveElementRef.nativeElement,e.target)&&0===this.cpIgnoredElements.filter(i=>i===e.target).length&&this.ngZone.run(()=>{this.cpSaveClickOutside?this.directiveInstance.colorSelected(this.outputColor):(this.hsva=null,this.setColorFromString(this.initialColor,!1),this.cpCmykEnabled&&this.directiveInstance.cmykChanged(this.cmykColor),this.directiveInstance.colorChanged(this.initialColor),this.directiveInstance.colorCanceled()),this.cpCloseClickOutside&&this.closeColorPicker()})}onAcceptColor(e){e.stopPropagation(),this.outputColor&&this.directiveInstance.colorSelected(this.outputColor),"popup"===this.cpDialogDisplay&&this.closeColorPicker()}onCancelColor(e){this.hsva=null,e.stopPropagation(),this.directiveInstance.colorCanceled(),this.setColorFromString(this.initialColor,!0),"popup"===this.cpDialogDisplay&&(this.cpCmykEnabled&&this.directiveInstance.cmykChanged(this.cmykColor),this.directiveInstance.colorChanged(this.initialColor,!0),this.closeColorPicker())}onEyeDropper(){this.eyeDropperSupported&&(new window.EyeDropper).open().then(i=>{this.setColorFromString(i.sRGBHex,!0)})}onFormatToggle(e){let i=this.dialogInputFields.length-(this.cpCmykEnabled?0:1),r=((this.dialogInputFields.indexOf(this.format)+e)%i+i)%i;this.format=this.dialogInputFields[r]}onColorChange(e){this.hsva.s=e.s/e.rgX,this.hsva.v=e.v/e.rgY,this.updateColorPicker(),this.directiveInstance.sliderChanged({slider:"lightness",value:this.hsva.v,color:this.outputColor}),this.directiveInstance.sliderChanged({slider:"saturation",value:this.hsva.s,color:this.outputColor})}onHueChange(e){this.hsva.h=e.v/e.rgX,this.sliderH=this.hsva.h,this.updateColorPicker(),this.directiveInstance.sliderChanged({slider:"hue",value:this.hsva.h,color:this.outputColor})}onValueChange(e){this.hsva.v=e.v/e.rgX,this.updateColorPicker(),this.directiveInstance.sliderChanged({slider:"value",value:this.hsva.v,color:this.outputColor})}onAlphaChange(e){this.hsva.a=e.v/e.rgX,this.updateColorPicker(),this.directiveInstance.sliderChanged({slider:"alpha",value:this.hsva.a,color:this.outputColor})}onHexInput(e){if(null===e)this.updateColorPicker();else{e&&"#"!==e[0]&&(e="#"+e);let i=/^#([a-f0-9]{3}|[a-f0-9]{6})$/gi;"always"===this.cpAlphaChannel&&(i=/^#([a-f0-9]{3}|[a-f0-9]{6}|[a-f0-9]{8})$/gi);let r=i.test(e);r&&(e.length<5&&(e="#"+e.substring(1).split("").map(o=>o+o).join("")),"forced"===this.cpAlphaChannel&&(e+=Math.round(255*this.hsva.a).toString(16)),this.setColorFromString(e,!0,!1)),this.directiveInstance.inputChanged({input:"hex",valid:r,value:e,color:this.outputColor})}}onRedInput(e){let i=this.service.hsvaToRgba(this.hsva),r=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;r&&(i.r=e.v/e.rg,this.hsva=this.service.rgbaToHsva(i),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"red",valid:r,value:i.r,color:this.outputColor})}onBlueInput(e){let i=this.service.hsvaToRgba(this.hsva),r=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;r&&(i.b=e.v/e.rg,this.hsva=this.service.rgbaToHsva(i),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"blue",valid:r,value:i.b,color:this.outputColor})}onGreenInput(e){let i=this.service.hsvaToRgba(this.hsva),r=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;r&&(i.g=e.v/e.rg,this.hsva=this.service.rgbaToHsva(i),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"green",valid:r,value:i.g,color:this.outputColor})}onHueInput(e){let i=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;i&&(this.hsva.h=e.v/e.rg,this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"hue",valid:i,value:this.hsva.h,color:this.outputColor})}onValueInput(e){let i=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;i&&(this.hsva.v=e.v/e.rg,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"value",valid:i,value:this.hsva.v,color:this.outputColor})}onAlphaInput(e){let i=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;i&&(this.hsva.a=e.v/e.rg,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"alpha",valid:i,value:this.hsva.a,color:this.outputColor})}onLightnessInput(e){let i=this.service.hsva2hsla(this.hsva),r=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;r&&(i.l=e.v/e.rg,this.hsva=this.service.hsla2hsva(i),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"lightness",valid:r,value:i.l,color:this.outputColor})}onSaturationInput(e){let i=this.service.hsva2hsla(this.hsva),r=!isNaN(e.v)&&e.v>=0&&e.v<=e.rg;r&&(i.s=e.v/e.rg,this.hsva=this.service.hsla2hsva(i),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"saturation",valid:r,value:i.s,color:this.outputColor})}onCyanInput(e){!isNaN(e.v)&&e.v>=0&&e.v<=e.rg&&(this.cmyk.c=e.v,this.updateColorPicker(!1,!0,!0)),this.directiveInstance.inputChanged({input:"cyan",valid:!0,value:this.cmyk.c,color:this.outputColor})}onMagentaInput(e){!isNaN(e.v)&&e.v>=0&&e.v<=e.rg&&(this.cmyk.m=e.v,this.updateColorPicker(!1,!0,!0)),this.directiveInstance.inputChanged({input:"magenta",valid:!0,value:this.cmyk.m,color:this.outputColor})}onYellowInput(e){!isNaN(e.v)&&e.v>=0&&e.v<=e.rg&&(this.cmyk.y=e.v,this.updateColorPicker(!1,!0,!0)),this.directiveInstance.inputChanged({input:"yellow",valid:!0,value:this.cmyk.y,color:this.outputColor})}onBlackInput(e){!isNaN(e.v)&&e.v>=0&&e.v<=e.rg&&(this.cmyk.k=e.v,this.updateColorPicker(!1,!0,!0)),this.directiveInstance.inputChanged({input:"black",valid:!0,value:this.cmyk.k,color:this.outputColor})}onAddPresetColor(e,i){e.stopPropagation(),this.cpPresetColors.filter(r=>r===i).length||(this.cpPresetColors=this.cpPresetColors.concat(i),this.directiveInstance.presetColorsChanged(this.cpPresetColors))}onRemovePresetColor(e,i){e.stopPropagation(),this.cpPresetColors=this.cpPresetColors.filter(r=>r!==i),this.directiveInstance.presetColorsChanged(this.cpPresetColors)}openColorPicker(){this.show||(this.show=!0,this.hidden=!0,setTimeout(()=>{this.hidden=!1,this.setDialogPosition(),this.cdRef.detectChanges()},0),this.directiveInstance.stateChanged(!0),this.isIE10||this.ngZone.runOutsideAngular(()=>{ihe?document.addEventListener("touchstart",this.listenerMouseDown):document.addEventListener("mousedown",this.listenerMouseDown)}),window.addEventListener("resize",this.listenerResize))}closeColorPicker(){this.show&&(this.show=!1,this.directiveInstance.stateChanged(!1),this.isIE10||(ihe?document.removeEventListener("touchstart",this.listenerMouseDown):document.removeEventListener("mousedown",this.listenerMouseDown)),window.removeEventListener("resize",this.listenerResize),this.cdRef.destroyed||this.cdRef.detectChanges())}updateColorPicker(e=!0,i=!0,r=!1){if(this.sliderDimMax){2===this.cpColorMode&&(this.hsva.s=0);let o,s,a,l=this.outputColor;if(s=this.service.hsva2hsla(this.hsva),this.cpCmykEnabled?(r?(a=this.service.cmykToRgb(this.service.normalizeCMYK(this.cmyk)),this.hsva=this.service.rgbaToHsva(a)):(a=this.service.hsvaToRgba(this.hsva),this.cmyk=this.service.denormalizeCMYK(this.service.rgbaToCmyk(a))),a=this.service.denormalizeRGBA(a),this.sliderH=this.hsva.h):a=this.service.denormalizeRGBA(this.service.hsvaToRgba(this.hsva)),o=this.service.denormalizeRGBA(this.service.hsvaToRgba(new Rb(this.sliderH||this.hsva.h,1,1,1))),i&&(this.hslaText=new Rp(Math.round(360*s.h),Math.round(100*s.s),Math.round(100*s.l),Math.round(100*s.a)/100),this.rgbaText=new hu(a.r,a.g,a.b,Math.round(100*a.a)/100),this.cpCmykEnabled&&(this.cmykText=new t0(this.cmyk.c,this.cmyk.m,this.cmyk.y,this.cmyk.k,Math.round(100*this.cmyk.a)/100)),this.hexText=this.service.rgbaToHex(a,"always"===this.cpAlphaChannel),this.hexAlpha=this.rgbaText.a),"auto"===this.cpOutputFormat&&this.format!==ws.RGBA&&this.format!==ws.CMYK&&this.format!==ws.HSLA&&this.hsva.a<1&&(this.format=this.hsva.a<1?ws.RGBA:ws.HEX),this.hueSliderColor="rgb("+o.r+","+o.g+","+o.b+")",this.alphaSliderColor="rgb("+a.r+","+a.g+","+a.b+")",this.outputColor=this.service.outputFormat(this.hsva,this.cpOutputFormat,this.cpAlphaChannel),this.selectedColor=this.service.outputFormat(this.hsva,"rgba",null),this.format!==ws.CMYK)this.cmykColor="";else if("always"===this.cpAlphaChannel||"enabled"===this.cpAlphaChannel||"forced"===this.cpAlphaChannel){let c=Math.round(100*this.cmyk.a)/100;this.cmykColor=`cmyka(${this.cmyk.c},${this.cmyk.m},${this.cmyk.y},${this.cmyk.k},${c})`}else this.cmykColor=`cmyk(${this.cmyk.c},${this.cmyk.m},${this.cmyk.y},${this.cmyk.k})`;this.slider=new $k((this.sliderH||this.hsva.h)*this.sliderDimMax.h-8,this.hsva.s*this.sliderDimMax.s-8,(1-this.hsva.v)*this.sliderDimMax.v-8,this.hsva.a*this.sliderDimMax.a-8),e&&l!==this.outputColor&&(this.cpCmykEnabled&&this.directiveInstance.cmykChanged(this.cmykColor),this.directiveInstance.colorChanged(this.outputColor))}}setDialogPosition(){if("inline"===this.cpDialogDisplay)this.position="relative";else{let r,e="static",i="",o=null,s=null,a=this.directiveElementRef.nativeElement.parentNode,l=this.dialogElement.nativeElement.offsetHeight;for(;null!==a&&"HTML"!==a.tagName;){if(r=window.getComputedStyle(a),e=r.getPropertyValue("position"),i=r.getPropertyValue("transform"),"static"!==e&&null===o&&(o=a),i&&"none"!==i&&null===s&&(s=a),"fixed"===e){o=s;break}a=a.parentNode}let c=this.createDialogBox(this.directiveElementRef.nativeElement,"fixed"!==e);if(this.useRootViewContainer||"fixed"===e&&(!o||o instanceof HTMLUnknownElement))this.top=c.top,this.left=c.left;else{null===o&&(o=a);let d=this.createDialogBox(o,"fixed"!==e);this.top=c.top-d.top,this.left=c.left-d.left}"fixed"===e&&(this.position="fixed");let u=this.cpPosition;"auto"===this.cpPosition&&(u=function(n,t){let e="right",i="bottom",{height:r,width:o}=n,{top:s,left:a}=t,l=s+t.height,c=a+t.width,u=s-r<0,d=l+r>(window.innerHeight||document.documentElement.clientHeight),p=a-o<0,h=c+o>(window.innerWidth||document.documentElement.clientWidth);return d&&(i="top"),u&&(i="bottom"),p&&(e="right"),h&&(e="left"),u&&d&&p&&h?["left","right","top","bottom"].reduce((x,g)=>n[x]>n[g]?x:g):p&&h?u?"bottom":d||s>l?"top":"bottom":u&&d?p?"right":h||a>c?"left":"right":`${i}-${e}`}(this.dialogElement.nativeElement.getBoundingClientRect(),this.cpTriggerElement.nativeElement.getBoundingClientRect())),"top"===u?(this.arrowTop=l-1,this.top-=l+this.dialogArrowSize,this.left+=this.cpPositionOffset/100*c.width-this.dialogArrowOffset):"bottom"===u?(this.top+=c.height+this.dialogArrowSize,this.left+=this.cpPositionOffset/100*c.width-this.dialogArrowOffset):"top-left"===u||"left-top"===u?(this.top-=l-c.height+c.height*this.cpPositionOffset/100,this.left-=this.cpWidth+this.dialogArrowSize-2-this.dialogArrowOffset):"top-right"===u||"right-top"===u?(this.top-=l-c.height+c.height*this.cpPositionOffset/100,this.left+=c.width+this.dialogArrowSize-2-this.dialogArrowOffset):"left"===u||"bottom-left"===u||"left-bottom"===u?(this.top+=c.height*this.cpPositionOffset/100-this.dialogArrowOffset,this.left-=this.cpWidth+this.dialogArrowSize-2):(this.top+=c.height*this.cpPositionOffset/100-this.dialogArrowOffset,this.left+=c.width+this.dialogArrowSize-2),this.cpUsePosition=u}}isDescendant(e,i){let r=i.parentNode;for(;null!==r;){if(r===e)return!0;r=r.parentNode}return!1}createDialogBox(e,i){let{top:r,left:o}=e.getBoundingClientRect();return{top:r+(i?window.pageYOffset:0),left:o+(i?window.pageXOffset:0),width:e.offsetWidth,height:e.offsetHeight}}}return n.\u0275fac=function(e){return new(e||n)(M(_t),M(Re),M(nn),M(Ht),M(Gd),M(qG))},n.\u0275cmp=R({type:n,selectors:[["color-picker"]],viewQuery:function(e,i){if(1&e&&(ot(DKe,7),ot(AKe,7),ot(IKe,7)),2&e){let r;Ne(r=Le())&&(i.dialogElement=r.first),Ne(r=Le())&&(i.hueSlider=r.first),Ne(r=Le())&&(i.alphaSlider=r.first)}},hostBindings:function(e,i){1&e&&P("keyup.esc",function(o){return i.handleEsc(o)},0,_T)("keyup.enter",function(o){return i.handleEnter(o)},!1,_T)},decls:30,vars:51,consts:[[1,"color-picker",3,"click"],["dialogPopup",""],[3,"class","top",4,"ngIf"],["class","saturation-lightness",3,"slider","rgX","rgY","background-color","newValue","dragStart","dragEnd",4,"ngIf"],[1,"hue-alpha","box"],[1,"left"],[1,"selected-color-background"],[1,"selected-color",3,"click"],["class","eyedropper-icon","xmlns","http://www.w3.org/2000/svg","height","24px","viewBox","0 0 24 24","width","24px","fill","#000000",4,"ngIf"],["type","button",3,"class","disabled","click",4,"ngIf"],[1,"right"],["style","height: 16px;",4,"ngIf"],[1,"hue",3,"slider","rgX","newValue","dragStart","dragEnd"],["hueSlider",""],[1,"cursor"],[1,"value",3,"slider","rgX","newValue","dragStart","dragEnd"],["valueSlider",""],[1,"alpha",3,"slider","rgX","newValue","dragStart","dragEnd"],["alphaSlider",""],["class","cmyk-text",3,"display",4,"ngIf"],["class","hsla-text",3,"display",4,"ngIf"],["class","rgba-text",3,"display",4,"ngIf"],["class","hex-text",3,"hex-alpha","display",4,"ngIf"],["class","value-text",4,"ngIf"],["class","type-policy",4,"ngIf"],["class","preset-area",4,"ngIf"],["class","button-area",4,"ngIf"],["class","extra-template",4,"ngIf"],[1,"saturation-lightness",3,"slider","rgX","rgY","newValue","dragStart","dragEnd"],["xmlns","http://www.w3.org/2000/svg","height","24px","viewBox","0 0 24 24","width","24px","fill","#000000",1,"eyedropper-icon"],["d","M0 0h24v24H0V0z","fill","none"],["d","M17.66 5.41l.92.92-2.69 2.69-.92-.92 2.69-2.69M17.67 3c-.26 0-.51.1-.71.29l-3.12 3.12-1.93-1.91-1.41 1.41 1.42 1.42L3 16.25V21h4.75l8.92-8.92 1.42 1.42 1.41-1.41-1.92-1.92 3.12-3.12c.4-.4.4-1.03.01-1.42l-2.34-2.34c-.2-.19-.45-.29-.7-.29zM6.92 19L5 17.08l8.06-8.06 1.92 1.92L6.92 19z"],["type","button",3,"disabled","click"],[2,"height","16px"],[1,"cmyk-text"],[1,"box"],["type","number","pattern","[0-9]*","min","0","max","100",3,"text","rg","value","keyup.enter","newValue"],["type","number","pattern","[0-9]+([\\.,][0-9]{1,2})?","min","0","max","1","step","0.1",3,"text","rg","value","keyup.enter","newValue",4,"ngIf"],[4,"ngIf"],["type","number","pattern","[0-9]+([\\.,][0-9]{1,2})?","min","0","max","1","step","0.1",3,"text","rg","value","keyup.enter","newValue"],[1,"hsla-text"],["type","number","pattern","[0-9]*","min","0","max","360",3,"text","rg","value","keyup.enter","newValue"],[1,"rgba-text"],["type","number","pattern","[0-9]*","min","0","max","255",3,"text","rg","value","keyup.enter","newValue"],[1,"hex-text"],[3,"text","value","blur","keyup.enter","newValue"],[1,"value-text"],[1,"type-policy"],[1,"type-policy-arrow",3,"click"],[1,"preset-area"],[1,"preset-label"],[3,"class",4,"ngIf"],["class","preset-color",3,"backgroundColor","click",4,"ngFor","ngForOf"],[1,"preset-color",3,"click"],[3,"class","click",4,"ngIf"],[3,"click"],[1,"button-area"],["type","button",3,"class","click",4,"ngIf"],["type","button",3,"click"],[1,"extra-template"],[4,"ngTemplateOutlet"]],template:function(e,i){1&e&&(_(0,"div",0,1),P("click",function(o){return o.stopPropagation()}),E(2,PKe,1,5,"div",2),E(3,RKe,2,8,"div",3),_(4,"div",4)(5,"div",5),O(6,"div",6),_(7,"div",7),P("click",function(){return i.eyeDropperSupported&&i.cpEyeDropper&&i.onEyeDropper()}),E(8,OKe,3,0,"svg",8),v(),E(9,kKe,2,5,"button",9),v(),_(10,"div",10),E(11,FKe,1,0,"div",11),_(12,"div",12,13),P("newValue",function(o){return i.onHueChange(o)})("dragStart",function(){return i.onDragStart("hue")})("dragEnd",function(){return i.onDragEnd("hue")}),O(14,"div",14),v(),_(15,"div",15,16),P("newValue",function(o){return i.onValueChange(o)})("dragStart",function(){return i.onDragStart("value")})("dragEnd",function(){return i.onDragEnd("value")}),O(17,"div",14),v(),_(18,"div",17,18),P("newValue",function(o){return i.onAlphaChange(o)})("dragStart",function(){return i.onDragStart("alpha")})("dragEnd",function(){return i.onDragEnd("alpha")}),O(20,"div",14),v()()(),E(21,BKe,17,12,"div",19),E(22,UKe,14,10,"div",20),E(23,GKe,14,10,"div",21),E(24,YKe,8,7,"div",22),E(25,QKe,9,3,"div",23),E(26,KKe,3,0,"div",24),E(27,tZe,6,3,"div",25),E(28,rZe,3,2,"div",26),E(29,sZe,2,1,"div",27),v()),2&e&&(Pt("display",i.show?"block":"none")("visibility",i.hidden?"hidden":"visible")("top",i.top,"px")("left",i.left,"px")("position",i.position)("height",i.cpHeight,"px")("width",i.cpWidth,"px"),et("open",i.show),C(2),y("ngIf","popup"===i.cpDialogDisplay),C(1),y("ngIf",1===(i.cpColorMode||1)),C(4),Pt("background-color",i.selectedColor)("cursor",i.eyeDropperSupported&&i.cpEyeDropper?"pointer":null),C(1),y("ngIf",i.eyeDropperSupported&&i.cpEyeDropper),C(1),y("ngIf",i.cpAddColorButton),C(2),y("ngIf","disabled"===i.cpAlphaChannel),C(1),Pt("display",1===(i.cpColorMode||1)?"block":"none"),y("rgX",1),C(2),Pt("left",null==i.slider?null:i.slider.h,"px"),C(1),Pt("display",2===(i.cpColorMode||1)?"block":"none"),y("rgX",1),C(2),Pt("right",null==i.slider?null:i.slider.v,"px"),C(1),Pt("display","disabled"===i.cpAlphaChannel?"none":"block")("background-color",i.alphaSliderColor),y("rgX",1),C(2),Pt("left",null==i.slider?null:i.slider.a,"px"),C(1),y("ngIf",!i.cpDisableInput&&1===(i.cpColorMode||1)),C(1),y("ngIf",!i.cpDisableInput&&1===(i.cpColorMode||1)),C(1),y("ngIf",!i.cpDisableInput&&1===(i.cpColorMode||1)),C(1),y("ngIf",!i.cpDisableInput&&1===(i.cpColorMode||1)),C(1),y("ngIf",!i.cpDisableInput&&2===(i.cpColorMode||1)),C(1),y("ngIf",!i.cpDisableInput&&1===(i.cpColorMode||1)),C(1),y("ngIf",(null==i.cpPresetColors?null:i.cpPresetColors.length)||i.cpAddColorButton),C(1),y("ngIf",i.cpOKButton||i.cpCancelButton),C(1),y("ngIf",i.cpExtraTemplate))},dependencies:[dn,Be,os,cZe,uZe],styles:['.color-picker{position:absolute;z-index:1000;width:230px;height:auto;border:#777 solid 1px;cursor:default;-webkit-user-select:none;user-select:none;background-color:#fff}.color-picker *{box-sizing:border-box;margin:0;font-size:11px}.color-picker input{width:0;height:26px;min-width:0;font-size:13px;text-align:center;color:#000}.color-picker input:invalid,.color-picker input:-moz-ui-invalid,.color-picker input:-moz-submit-invalid{box-shadow:none}.color-picker input::-webkit-inner-spin-button,.color-picker input::-webkit-outer-spin-button{margin:0;-webkit-appearance:none}.color-picker .arrow{position:absolute;z-index:999999;width:0;height:0;border-style:solid}.color-picker .arrow.arrow-top{left:8px;border-width:10px 5px;border-color:#777 rgba(0,0,0,0) rgba(0,0,0,0) rgba(0,0,0,0)}.color-picker .arrow.arrow-bottom{top:-20px;left:8px;border-width:10px 5px;border-color:rgba(0,0,0,0) rgba(0,0,0,0) #777 rgba(0,0,0,0)}.color-picker .arrow.arrow-top-left,.color-picker .arrow.arrow-left-top{right:-21px;bottom:8px;border-width:5px 10px;border-color:rgba(0,0,0,0) rgba(0,0,0,0) rgba(0,0,0,0) #777}.color-picker .arrow.arrow-top-right,.color-picker .arrow.arrow-right-top{bottom:8px;left:-20px;border-width:5px 10px;border-color:rgba(0,0,0,0) #777 rgba(0,0,0,0) rgba(0,0,0,0)}.color-picker .arrow.arrow-left,.color-picker .arrow.arrow-left-bottom,.color-picker .arrow.arrow-bottom-left{top:8px;right:-21px;border-width:5px 10px;border-color:rgba(0,0,0,0) rgba(0,0,0,0) rgba(0,0,0,0) #777}.color-picker .arrow.arrow-right,.color-picker .arrow.arrow-right-bottom,.color-picker .arrow.arrow-bottom-right{top:8px;left:-20px;border-width:5px 10px;border-color:rgba(0,0,0,0) #777 rgba(0,0,0,0) rgba(0,0,0,0)}.color-picker .cursor{position:relative;width:16px;height:16px;border:#222 solid 2px;border-radius:50%;cursor:default}.color-picker .box{display:flex;padding:4px 8px}.color-picker .left{position:relative;padding:16px 8px}.color-picker .right{flex:1 1 auto;padding:12px 8px}.color-picker .button-area{padding:0 16px 16px;text-align:right}.color-picker .button-area button{margin-left:8px}.color-picker .preset-area{padding:4px 15px}.color-picker .preset-area .preset-label{overflow:hidden;width:100%;padding:4px;font-size:11px;white-space:nowrap;text-align:left;text-overflow:ellipsis;color:#555}.color-picker .preset-area .preset-color{position:relative;display:inline-block;width:18px;height:18px;margin:4px 6px 8px;border:#a9a9a9 solid 1px;border-radius:25%;cursor:pointer}.color-picker .preset-area .preset-empty-message{min-height:18px;margin-top:4px;margin-bottom:8px;font-style:italic;text-align:center}.color-picker .hex-text{width:100%;padding:4px 8px;font-size:11px}.color-picker .hex-text .box{padding:0 24px 8px 8px}.color-picker .hex-text .box div{float:left;flex:1 1 auto;text-align:center;color:#555;clear:left}.color-picker .hex-text .box input{flex:1 1 auto;padding:1px;border:#a9a9a9 solid 1px}.color-picker .hex-alpha .box div:first-child,.color-picker .hex-alpha .box input:first-child{flex-grow:3;margin-right:8px}.color-picker .cmyk-text,.color-picker .hsla-text,.color-picker .rgba-text,.color-picker .value-text{width:100%;padding:4px 8px;font-size:11px}.color-picker .cmyk-text .box,.color-picker .hsla-text .box,.color-picker .rgba-text .box{padding:0 24px 8px 8px}.color-picker .value-text .box{padding:0 8px 8px}.color-picker .cmyk-text .box div,.color-picker .hsla-text .box div,.color-picker .rgba-text .box div,.color-picker .value-text .box div{flex:1 1 auto;margin-right:8px;text-align:center;color:#555}.color-picker .cmyk-text .box div:last-child,.color-picker .hsla-text .box div:last-child,.color-picker .rgba-text .box div:last-child,.color-picker .value-text .box div:last-child{margin-right:0}.color-picker .cmyk-text .box input,.color-picker .hsla-text .box input,.color-picker .rgba-text .box input,.color-picker .value-text .box input{float:left;flex:1;padding:1px;margin:0 8px 0 0;border:#a9a9a9 solid 1px}.color-picker .cmyk-text .box input:last-child,.color-picker .hsla-text .box input:last-child,.color-picker .rgba-text .box input:last-child,.color-picker .value-text .box input:last-child{margin-right:0}.color-picker .hue-alpha{align-items:center;margin-bottom:3px}.color-picker .hue{direction:ltr;width:100%;height:16px;margin-bottom:16px;border:none;cursor:pointer;background-size:100% 100%;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAJYAAAAQCAYAAAD06IYnAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH4AIWDwkUFWbCCAAAAFxJREFUaN7t0kEKg0AQAME2x83/n2qu5qCgD1iDhCoYdpnbQC9bbY1qVO/jvc6k3ad91s7/7F1/csgPrujuQ17BDYSFsBAWwgJhISyEBcJCWAgLhIWwEBYIi2f7Ar/1TCgFH2X9AAAAAElFTkSuQmCC)}.color-picker .value{direction:rtl;width:100%;height:16px;margin-bottom:16px;border:none;cursor:pointer;background-size:100% 100%;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAJYAAAAQCAYAAAD06IYnAAACTklEQVR42u3SYUcrABhA4U2SkmRJMmWSJklKJiWZZpKUJJskKUmaTFImKZOUzMySpGRmliRNJilJSpKSJEtmSpIpmWmSdO736/6D+x7OP3gUCoWCv1cqlSQlJZGcnExKSgqpqamkpaWRnp5ORkYGmZmZqFQqsrKyyM7OJicnh9zcXNRqNXl5eeTn56PRaCgoKKCwsJCioiK0Wi3FxcWUlJRQWlpKWVkZ5eXlVFRUUFlZiU6no6qqiurqampqaqitraWurg69Xk99fT0GgwGj0UhDQwONjY00NTXR3NxMS0sLra2ttLW10d7ejslkwmw209HRQWdnJ11dXXR3d9PT00Nvby99fX309/czMDDA4OAgFouFoaEhrFYrw8PDjIyMMDo6ytjYGDabjfHxcSYmJpicnGRqagq73c709DQzMzPMzs4yNzfH/Pw8DocDp9OJy+XC7XazsLDA4uIiS0tLLC8vs7KywurqKmtra3g8HrxeLz6fD7/fz/r6OhsbG2xubrK1tcX29jaBQICdnR2CwSC7u7vs7e2xv7/PwcEBh4eHHB0dcXx8zMnJCaenp5ydnXF+fs7FxQWXl5dcXV1xfX3Nzc0Nt7e33N3dEQqFuL+/5+HhgXA4TCQS4fHxkaenJ56fn3l5eeH19ZVoNMrb2xvv7+98fHwQi8WIx+N8fn6SSCT4+vri+/ubn58ffn9/+VcKgSWwBJbAElgCS2AJLIElsASWwBJYAktgCSyBJbAElsASWAJLYAksgSWwBJbAElgCS2AJLIElsP4/WH8AmJ5Z6jHS4h8AAAAASUVORK5CYII=)}.color-picker .alpha{direction:ltr;width:100%;height:16px;border:none;cursor:pointer;background-size:100% 100%;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAJYAAAAQCAYAAAD06IYnAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH4AIWDwYQlZMa3gAAAWVJREFUaN7tmEGO6jAQRCsOArHgBpyAJYGjcGocxAm4A2IHpmoWE0eBH+ezmFlNvU06shJ3W6VEelWMUQAIIF9f6qZpimsA1LYtS2uF51/u27YVAFZVRUkEoGHdPV/sIcbIEIIkUdI/9Xa7neyv61+SWFUVAVCSct00TWn2fv6u3+Ecfd3tXzy/0+nEUu+SPjo/kqzrmiQpScN6v98XewfA8/lMkiLJ2WxGSUopcT6fM6U0NX9/frfbjev1WtfrlZfLhYfDQQHG/AIOlnGwjINlHCxjHCzjYJm/TJWdCwquJXseFFzGwDNNeiKMOJTO8xQdDQaeB29+K9efeLaBo9J7vdvtJj1RjFFjfiv7qv95tjx/7leSQgh93e1ffMeIp6O+YQjho/N791t1XVOSSI7N//K+4/GoxWLBx+PB5/Op5XLJ+/3OlJJWqxU3m83ovv5iGf8KjYNlHCxjHCzjYBkHy5gf5gusvQU7U37jTAAAAABJRU5ErkJggg==)}.color-picker .type-policy{position:absolute;top:218px;right:12px;width:16px;height:24px;background-size:8px 16px;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABIAAAAgCAYAAAAffCjxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAACewAAAnsB01CO3AAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAIASURBVEiJ7ZY9axRRFIafsxMStrLQJpAgpBFhi+C9w1YSo00I6RZ/g9vZpBf/QOr4GyRgkSKNSrAadsZqQGwCkuAWyRZJsySwvhZ7N/vhzrgbLH3Ld8597jlzz50zJokyxXH8DqDVar0qi6v8BbItqSGpEcfxdlmsFWXkvX8AfAVWg3UKPEnT9GKujMzsAFgZsVaCN1VTQd77XUnrgE1kv+6935268WRpzrnHZvYRWC7YvC3pRZZl3wozqtVqiyH9IgjAspkd1Gq1xUJQtVrdB9ZKIAOthdg/Qc65LUk7wNIMoCVJO865rYFhkqjX6/d7vV4GPJwBMqofURS5JEk6FYBer/eeYb/Mo9WwFnPOvQbeAvfuAAK4BN4sAJtAG/gJIElmNuiJyba3EGNmZiPeZuEVmVell/Y/6N+CzDn3AXhEOOo7Hv/3BeAz8IzQkMPnJbuPx1wC+yYJ7/0nYIP5S/0FHKdp+rwCEEXRS/rf5Hl1Gtb2M0iSpCOpCZzPATmX1EySpHMLAsiy7MjMDoHrGSDXZnaYZdnRwBh7J91utwmczAA6CbG3GgPleX4jqUH/a1CktqRGnuc3hSCAMB32gKspkCtgb3KCQMmkjeP4WNJThrNNZval1WptTIsv7JtQ4tmIdRa8qSoEpWl6YWZNoAN0zKxZNPehpLSBZv2t+Q0CJ9lLnARQLAAAAABJRU5ErkJggg==);background-repeat:no-repeat;background-position:center}.color-picker .type-policy .type-policy-arrow{display:block;width:100%;height:50%}.color-picker .selected-color{position:absolute;top:16px;left:8px;width:40px;height:40px;border:1px solid #a9a9a9;border-radius:50%}.color-picker .selected-color-background{width:40px;height:40px;border-radius:50%;background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAoCAYAAACM/rhtAAAAh0lEQVRYR+2W0QlAMQgD60zdfwOdqa8TmI/wQMr5K0I5bZLIzLOa2nt37VVVbd+dDx5obgCC3KBLwJ2ff4PnVidkf+ucIhw80HQaCLo3DMH3CRK3iFsmAWVl6hPNDwt8EvNE5q+YuEXcMgkonVM6SdyCoEvAnZ8v1Hjx817MilmxSUB5rdLJDycZgUAZUch/AAAAAElFTkSuQmCC)}.color-picker .saturation-lightness{direction:ltr;width:100%;height:130px;border:none;cursor:pointer;touch-action:manipulation;background-size:100% 100%;background-image:url(data:image/png;base64,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)}.color-picker .cp-add-color-button-class{position:absolute;display:inline;padding:0;margin:3px -3px;border:0;cursor:pointer;background:transparent}.color-picker .cp-add-color-button-class:hover{text-decoration:underline}.color-picker .cp-add-color-button-class:disabled{cursor:not-allowed;color:#999}.color-picker .cp-add-color-button-class:disabled:hover{text-decoration:none}.color-picker .cp-remove-color-button-class{position:absolute;top:-5px;right:-5px;display:block;width:10px;height:10px;border-radius:50%;cursor:pointer;text-align:center;background:#fff;box-shadow:1px 1px 5px #333}.color-picker .cp-remove-color-button-class:before{content:"x";position:relative;bottom:3.5px;display:inline-block;font-size:10px}.color-picker .eyedropper-icon{position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);fill:#fff;mix-blend-mode:exclusion}\n'],encapsulation:2}),n})(),rhe=(()=>{class n{constructor(e,i,r,o,s,a){this.injector=e,this.cfr=i,this.appRef=r,this.vcRef=o,this.elRef=s,this._service=a,this.dialogCreated=!1,this.ignoreChanges=!1,this.viewAttachedToAppRef=!1,this.cpWidth="230px",this.cpHeight="auto",this.cpToggle=!1,this.cpDisabled=!1,this.cpIgnoredElements=[],this.cpFallbackColor="",this.cpColorMode="color",this.cpCmykEnabled=!1,this.cpOutputFormat="auto",this.cpAlphaChannel="enabled",this.cpDisableInput=!1,this.cpDialogDisplay="popup",this.cpSaveClickOutside=!0,this.cpCloseClickOutside=!0,this.cpUseRootViewContainer=!1,this.cpPosition="auto",this.cpPositionOffset="0%",this.cpPositionRelativeToArrow=!1,this.cpOKButton=!1,this.cpOKButtonText="OK",this.cpOKButtonClass="cp-ok-button-class",this.cpCancelButton=!1,this.cpCancelButtonText="Cancel",this.cpCancelButtonClass="cp-cancel-button-class",this.cpEyeDropper=!1,this.cpPresetLabel="Preset colors",this.cpPresetColorsClass="cp-preset-colors-class",this.cpMaxPresetColorsLength=6,this.cpPresetEmptyMessage="No colors added",this.cpPresetEmptyMessageClass="preset-empty-message",this.cpAddColorButton=!1,this.cpAddColorButtonText="Add color",this.cpAddColorButtonClass="cp-add-color-button-class",this.cpRemoveColorButtonClass="cp-remove-color-button-class",this.cpInputChange=new G(!0),this.cpToggleChange=new G(!0),this.cpSliderChange=new G(!0),this.cpSliderDragEnd=new G(!0),this.cpSliderDragStart=new G(!0),this.colorPickerOpen=new G(!0),this.colorPickerClose=new G(!0),this.colorPickerCancel=new G(!0),this.colorPickerSelect=new G(!0),this.colorPickerChange=new G(!1),this.cpCmykColorChange=new G(!0),this.cpPresetColorsChange=new G(!0)}handleClick(){this.inputFocus()}handleFocus(){this.inputFocus()}handleInput(e){this.inputChange(e)}ngOnDestroy(){null!=this.cmpRef&&(this.viewAttachedToAppRef&&this.appRef.detachView(this.cmpRef.hostView),this.cmpRef.destroy(),this.cmpRef=null,this.dialog=null)}ngOnChanges(e){e.cpToggle&&!this.cpDisabled&&(e.cpToggle.currentValue?this.openDialog():e.cpToggle.currentValue||this.closeDialog()),e.colorPicker&&(this.dialog&&!this.ignoreChanges&&("inline"===this.cpDialogDisplay&&this.dialog.setInitialColor(e.colorPicker.currentValue),this.dialog.setColorFromString(e.colorPicker.currentValue,!1),this.cpUseRootViewContainer&&"inline"!==this.cpDialogDisplay&&this.cmpRef.changeDetectorRef.detectChanges()),this.ignoreChanges=!1),(e.cpPresetLabel||e.cpPresetColors)&&this.dialog&&this.dialog.setPresetConfig(this.cpPresetLabel,this.cpPresetColors)}openDialog(){if(this.dialogCreated)this.dialog&&this.dialog.openDialog(this.colorPicker);else{let e=this.vcRef;if(this.dialogCreated=!0,this.viewAttachedToAppRef=!1,this.cpUseRootViewContainer&&"inline"!==this.cpDialogDisplay){let o=this.injector.get(this.appRef.componentTypes[0],Xn.NULL);o!==Xn.NULL?e=o.vcRef||o.viewContainerRef||this.vcRef:this.viewAttachedToAppRef=!0}let i=this.cfr.resolveComponentFactory(dZe);if(this.viewAttachedToAppRef)this.cmpRef=i.create(this.injector),this.appRef.attachView(this.cmpRef.hostView),document.body.appendChild(this.cmpRef.hostView.rootNodes[0]);else{let r=Xn.create({providers:[],parent:e.injector});this.cmpRef=e.createComponent(i,0,r,[])}this.cmpRef.instance.setupDialog(this,this.elRef,this.colorPicker,this.cpWidth,this.cpHeight,this.cpDialogDisplay,this.cpFallbackColor,this.cpColorMode,this.cpCmykEnabled,this.cpAlphaChannel,this.cpOutputFormat,this.cpDisableInput,this.cpIgnoredElements,this.cpSaveClickOutside,this.cpCloseClickOutside,this.cpUseRootViewContainer,this.cpPosition,this.cpPositionOffset,this.cpPositionRelativeToArrow,this.cpPresetLabel,this.cpPresetColors,this.cpPresetColorsClass,this.cpMaxPresetColorsLength,this.cpPresetEmptyMessage,this.cpPresetEmptyMessageClass,this.cpOKButton,this.cpOKButtonClass,this.cpOKButtonText,this.cpCancelButton,this.cpCancelButtonClass,this.cpCancelButtonText,this.cpAddColorButton,this.cpAddColorButtonClass,this.cpAddColorButtonText,this.cpRemoveColorButtonClass,this.cpEyeDropper,this.elRef,this.cpExtraTemplate),this.dialog=this.cmpRef.instance,this.vcRef!==e&&this.cmpRef.changeDetectorRef.detectChanges()}}closeDialog(){this.dialog&&"popup"===this.cpDialogDisplay&&this.dialog.closeDialog()}cmykChanged(e){this.cpCmykColorChange.emit(e)}stateChanged(e){this.cpToggleChange.emit(e),e?this.colorPickerOpen.emit(this.colorPicker):this.colorPickerClose.emit(this.colorPicker)}colorChanged(e,i=!0){this.ignoreChanges=i,this.colorPickerChange.emit(e)}colorSelected(e){this.colorPickerSelect.emit(e)}colorCanceled(){this.colorPickerCancel.emit()}inputFocus(){let e=this.elRef.nativeElement,i=this.cpIgnoredElements.filter(r=>r===e);!this.cpDisabled&&!i.length&&(typeof document<"u"&&e===document.activeElement?this.openDialog():this.dialog&&this.dialog.show?this.closeDialog():this.openDialog())}inputChange(e){this.dialog?this.dialog.setColorFromString(e.target.value,!0):(this.colorPicker=e.target.value,this.colorPickerChange.emit(this.colorPicker))}inputChanged(e){this.cpInputChange.emit(e)}sliderChanged(e){this.cpSliderChange.emit(e)}sliderDragEnd(e){this.cpSliderDragEnd.emit(e)}sliderDragStart(e){this.cpSliderDragStart.emit(e)}presetColorsChanged(e){this.cpPresetColorsChange.emit(e)}}return n.\u0275fac=function(e){return new(e||n)(M(Xn),M(gs),M(Iu),M(Oi),M(Re),M(qG))},n.\u0275dir=He({type:n,selectors:[["","colorPicker",""]],hostBindings:function(e,i){1&e&&P("click",function(){return i.handleClick()})("focus",function(){return i.handleFocus()})("input",function(o){return i.handleInput(o)})},inputs:{colorPicker:"colorPicker",cpWidth:"cpWidth",cpHeight:"cpHeight",cpToggle:"cpToggle",cpDisabled:"cpDisabled",cpIgnoredElements:"cpIgnoredElements",cpFallbackColor:"cpFallbackColor",cpColorMode:"cpColorMode",cpCmykEnabled:"cpCmykEnabled",cpOutputFormat:"cpOutputFormat",cpAlphaChannel:"cpAlphaChannel",cpDisableInput:"cpDisableInput",cpDialogDisplay:"cpDialogDisplay",cpSaveClickOutside:"cpSaveClickOutside",cpCloseClickOutside:"cpCloseClickOutside",cpUseRootViewContainer:"cpUseRootViewContainer",cpPosition:"cpPosition",cpPositionOffset:"cpPositionOffset",cpPositionRelativeToArrow:"cpPositionRelativeToArrow",cpOKButton:"cpOKButton",cpOKButtonText:"cpOKButtonText",cpOKButtonClass:"cpOKButtonClass",cpCancelButton:"cpCancelButton",cpCancelButtonText:"cpCancelButtonText",cpCancelButtonClass:"cpCancelButtonClass",cpEyeDropper:"cpEyeDropper",cpPresetLabel:"cpPresetLabel",cpPresetColors:"cpPresetColors",cpPresetColorsClass:"cpPresetColorsClass",cpMaxPresetColorsLength:"cpMaxPresetColorsLength",cpPresetEmptyMessage:"cpPresetEmptyMessage",cpPresetEmptyMessageClass:"cpPresetEmptyMessageClass",cpAddColorButton:"cpAddColorButton",cpAddColorButtonText:"cpAddColorButtonText",cpAddColorButtonClass:"cpAddColorButtonClass",cpRemoveColorButtonClass:"cpRemoveColorButtonClass",cpExtraTemplate:"cpExtraTemplate"},outputs:{cpInputChange:"cpInputChange",cpToggleChange:"cpToggleChange",cpSliderChange:"cpSliderChange",cpSliderDragEnd:"cpSliderDragEnd",cpSliderDragStart:"cpSliderDragStart",colorPickerOpen:"colorPickerOpen",colorPickerClose:"colorPickerClose",colorPickerCancel:"colorPickerCancel",colorPickerSelect:"colorPickerSelect",colorPickerChange:"colorPickerChange",cpCmykColorChange:"cpCmykColorChange",cpPresetColorsChange:"cpPresetColorsChange"},exportAs:["ngxColorPicker"],features:[Ft]}),n})(),ohe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[qG],imports:[Me]}),n})(),fZe=["container"];function mZe(n,t){if(1&n){let e=Pe();_(0,"mat-slider",4),P("input",function(r){return oe(e),se(S().handleSingleSliderChange(r.value))}),v()}if(2&n){let e=S();y("disabled",!e.enabled)("min",e.min)("max",e.max)("step",1)("value",e.lowerValue)}}function gZe(n,t){if(1&n){let e=Pe();_(0,"span",5,6),O(2,"span",7)(3,"span",8),_(4,"span",9),P("mousedown",function(r){oe(e);let o=S();return se(o.handleMouseDown(r,o.Position.LEFT))}),v(),_(5,"span",9),P("mousedown",function(r){oe(e);let o=S();return se(o.handleMouseDown(r,o.Position.RIGHT))}),v()()}if(2&n){let e=S();C(3),Pt("left",e.getThumbPosition(e.lowerValue))("width",e.getTrackWidth()),C(1),Pt("left",e.getThumbPosition(e.lowerValue)),et("active",e.isThumbActive(e.Position.LEFT)),C(1),Pt("left",e.getThumbPosition(e.upperValue)),et("active",e.isThumbActive(e.Position.RIGHT))}}var mc=(()=>(function(n){n[n.NONE=0]="NONE",n[n.LEFT=1]="LEFT",n[n.RIGHT=2]="RIGHT"}(mc||(mc={})),mc))(),she=(()=>{class n{constructor(e){this.changeDetector=e,this.tickCount=20,this.enabled=!0,this.returnIntegers=!1,this.rangeValuesChanged=new G,this.singleValueChanged=new G,this.Position=mc,this.activeThumb=mc.NONE,this.offsetXFromOriginOfActiveThumb=0,this.ngUnsubscribe=new ke}getThumbPosition(e){let i=this.getClippedValue(e),r=this.max-this.min;return r<=0?"50%":(i-this.min)/r*100+"%"}getTrackWidth(){if(null===this.upperValue)return"0%";let e=this.max-this.min;return e<=0?"0%":(this.getClippedValue(this.upperValue)-this.getClippedValue(this.lowerValue))/e*100+"%"}getClippedValue(e){return Math.min(Math.max(e,this.min),this.max)}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}ngOnInit(){_i(document,"mousemove",{passive:!0}).pipe(st(this.ngUnsubscribe)).subscribe(e=>{this.handleMouseMove(e)}),_i(document,"mouseup",{passive:!0}).pipe(st(this.ngUnsubscribe)).subscribe(e=>{this.handleMouseOut(e)})}handleMouseDown(e,i){e.stopPropagation(),e.preventDefault(),this.activeThumb=i,this.offsetXFromOriginOfActiveThumb=6-e.offsetX}calculateValueFromMouseEvent(e){let a,{left:i,right:r}=this.container.nativeElement.getBoundingClientRect(),s=e.clientX-i+this.offsetXFromOriginOfActiveThumb;if(null!==this.tickCount&&this.tickCount>0){let c=(r-i)/this.tickCount;a=Math.round(s/c)*c/(r-i)}else a=s/(r-i);let l=this.getClippedValue(this.min+(this.max-this.min)*a);return this.returnIntegers?Math.round(l):Number(l.toFixed(10))}handleMouseMove(e){if(this.activeThumb===mc.NONE||null===this.upperValue)return;let i=this.calculateValueFromMouseEvent(e),r=[this.lowerValue,this.upperValue];this.activeThumb===mc.LEFT?(i>this.upperValue&&(this.activeThumb=mc.RIGHT),r=[i,this.upperValue]):(i<this.lowerValue&&(this.activeThumb=mc.LEFT),r=[this.lowerValue,i]),this.maybeNotifyNextRangeValues(r,"SLIDER"),this.changeDetector.markForCheck()}maybeNotifyNextRangeValues(e,i){let[r,o]=e.sort((s,a)=>s-a);(this.lowerValue!==r||this.upperValue!==o)&&this.rangeValuesChanged.emit({lowerValue:r,upperValue:o,source:i})}handleMouseOut(e){this.activeThumb!==mc.NONE&&(this.activeThumb=mc.NONE,this.changeDetector.markForCheck())}handleSingleSliderChange(e){this.singleValueChanged.emit({value:e,source:"SLIDER"})}handleInputChange(e,i){let r=e.target,o=this.getClippedValue(Number(r.value));isNaN(o)||(i===mc.LEFT?null===this.upperValue?this.singleValueChanged.emit({value:o,source:"TEXT"}):this.maybeNotifyNextRangeValues([o,this.upperValue],"TEXT"):""===r.value?this.singleValueChanged.emit({value:this.lowerValue,source:"TEXT_DELETED"}):this.maybeNotifyNextRangeValues([this.lowerValue,o],"TEXT"))}isThumbActive(e){return this.activeThumb===e}}return n.\u0275fac=function(e){return new(e||n)(M(nn))},n.\u0275cmp=R({type:n,selectors:[["tb-range-input"]],viewQuery:function(e,i){if(1&e&&ot(fZe,5,Re),2&e){let r;Ne(r=Le())&&(i.container=r.first)}},inputs:{min:"min",max:"max",lowerValue:"lowerValue",upperValue:"upperValue",tickCount:"tickCount",enabled:"enabled",returnIntegers:"returnIntegers"},outputs:{rangeValuesChanged:"rangeValuesChanged",singleValueChanged:"singleValueChanged"},decls:5,vars:6,consts:[["type","number",1,"lower-input",3,"disabled","value","change"],["type","number",1,"upper-input",3,"disabled","value","change"],["class","single-slider","color","primary",3,"disabled","min","max","step","value","input",4,"ngIf","ngIfElse"],["range",""],["color","primary",1,"single-slider",3,"disabled","min","max","step","value","input"],[1,"container"],["container",""],[1,"slider-track"],[1,"slider-track-fill"],[1,"thumb",3,"mousedown"]],template:function(e,i){if(1&e&&(_(0,"input",0),P("change",function(o){return i.handleInputChange(o,i.Position.LEFT)}),v(),_(1,"input",1),P("change",function(o){return i.handleInputChange(o,i.Position.RIGHT)}),v(),E(2,mZe,1,5,"mat-slider",2),E(3,gZe,6,12,"ng-template",null,3,qt)),2&e){let r=$e(4);y("disabled",!i.enabled)("value",i.lowerValue),C(1),y("disabled",!i.enabled)("value",null!==i.upperValue?i.upperValue:""),C(1),y("ngIf",null===i.upperValue)("ngIfElse",r)}},dependencies:[Be,up],styles:['[_nghost-%COMP%]{box-sizing:border-box;display:inline-grid;grid-gap:10px;grid-template-areas:"lower-input upper-input" "slider slider";grid-template-columns:1fr 1fr;font-size:0;min-width:100px;padding:6px}input[_ngcontent-%COMP%]{background-color:inherit;border-style:solid;box-sizing:border-box;color:inherit;overflow:hidden;width:100%}.lower-input[_ngcontent-%COMP%]{grid-area:lower-input}.upper-input[_ngcontent-%COMP%]{grid-area:upper-input;justify-self:flex-end}.single-slider[_ngcontent-%COMP%]{grid-area:slider;padding:0px}.single-slider[_ngcontent-%COMP%]     .mat-slider-wrapper{top:5px;left:0px;right:0px}  .single-slider.mat-slider-horizontal{height:12px}.container[_ngcontent-%COMP%]{grid-area:slider;align-items:center;box-sizing:border-box;display:inline-flex;height:12px;justify-content:center;position:relative;width:100%}.slider-track[_ngcontent-%COMP%]{background:rgba(0,0,0,.26);height:2px;width:100%}body.dark-mode[_nghost-%COMP%]   .slider-track[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slider-track[_ngcontent-%COMP%]{background:rgba(255,255,255,.3)}.slider-track-fill[_ngcontent-%COMP%]{position:absolute;height:2px}.thumb[_ngcontent-%COMP%]{box-sadhow:0 0 0 1px rgba(0,0,0,.26);border-radius:100%;display:inline-block;height:12px;margin-left:-6px;position:absolute;top:0;transform-origin:center;transition:transform .3s ease;width:12px;will-change:transform}body.dark-mode[_nghost-%COMP%]   .thumb[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .thumb[_ngcontent-%COMP%]{box-sadhow:0 0 0 1px rgba(255,255,255,.3)}.thumb[_ngcontent-%COMP%]:hover{cursor:grab}.thumb[_ngcontent-%COMP%]:active{cursor:grabbing}.thumb.active[_ngcontent-%COMP%]{transform:scale(1.2)}.slider-track-fill[_ngcontent-%COMP%], .thumb[_ngcontent-%COMP%]{background:#f57c00}body.dark-mode[_nghost-%COMP%]   .slider-track-fill[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .slider-track-fill[_ngcontent-%COMP%]{background:#ef6c00}body.dark-mode[_nghost-%COMP%]   .thumb[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .thumb[_ngcontent-%COMP%]{background:#ef6c00}'],changeDetection:0}),n})(),yZe=["regexStringInput"];function bZe(n,t){if(1&n&&(sn(0),_(1,"li",22),A(2),v(),an()),2&n){let e=t.$implicit;C(1),y("title",e.name),C(1),yt(e.name)}}function xZe(n,t){if(1&n&&(_(0,"li",23)(1,"em"),A(2),B(3,"number"),v()()),2&n){let e=S().$implicit;C(2),je("and ",U(3,1,e.runs.length-5)," more")}}function CZe(n,t){1&n&&(_(0,"li",24)(1,"em"),A(2,"No runs are in the group"),v()())}var MZe=function(n){return{borderColor:n}},wZe=function(n){return{backgroundColor:n}};function SZe(n,t){if(1&n&&(_(0,"ul",16)(1,"li")(2,"label"),O(3,"span",17),_(4,"code",18),A(5),v()(),_(6,"ul"),E(7,bZe,3,2,"ng-container",19),B(8,"slice"),E(9,xZe,4,3,"li",20),E(10,CZe,3,0,"li",21),v()()()),2&n){let e=t.$implicit;y("ngStyle",On(11,MZe,e.color)),C(3),y("ngStyle",On(13,wZe,e.color)),C(1),y("title",e.groupId),C(1),yt(e.groupId),C(2),y("ngForOf",J3(8,7,e.runs,0,5)),C(2),y("ngIf",e.runs.length>5),C(1),y("ngIf",0===e.runs.length)}}function EZe(n,t){if(1&n&&(_(0,"div",14),E(1,SZe,11,15,"ul",15),v()),2&n){let e=S(2);C(1),y("ngForOf",e.colorRunPairList)}}function TZe(n,t){if(1&n&&(_(0,"div",25),A(1," There are no runs matching the regex, "),_(2,"code"),A(3),v(),A(4,". Please check if your regex string is correct. "),v()),2&n){let e=S(2);C(3),je("/",e.regexString,"/")}}function DZe(n,t){if(1&n&&(_(0,"div",10)(1,"h4"),A(2,"Color group preview"),v(),_(3,"div",11),E(4,EZe,2,1,"div",12),E(5,TZe,5,1,"ng-template",null,13,qt),v()()),2&n){let e=$e(6),i=S();C(4),y("ngIf",i.colorRunPairList.length)("ngIfElse",e)}}var ahe=(()=>{class n{constructor(e,i){this.dialogRef=e,this.hostElRef=i,this.onSave=new G,this.regexInputOnChange=new G,this.timeOutId=0}resetFocus(){this.hostElRef.nativeElement.contains(document.activeElement)||this.regexStringInput.nativeElement.focus()}onEnter(e){this.onSaveClick(e),this.dialogRef.close()}onSaveClick(e){this.onSave.emit(e)}fillExample(e){this.regexString=e,this.regexInputChange(e)}regexInputChange(e){this.regexInputOnChange.emit(e)}handleFocusOut(){clearTimeout(this.timeOutId),this.timeOutId=setTimeout(this.resetFocus.bind(this),0)}}return n.\u0275fac=function(e){return new(e||n)(M(tu),M(Re))},n.\u0275cmp=R({type:n,selectors:[["regex-edit-dialog-component"]],viewQuery:function(e,i){if(1&e&&ot(yZe,7),2&e){let r;Ne(r=Le())&&(i.regexStringInput=r.first)}},inputs:{regexString:"regexString",colorRunPairList:"colorRunPairList"},outputs:{onSave:"onSave",regexInputOnChange:"regexInputOnChange"},decls:30,vars:2,consts:function(){let t;return t=$localize`:Color Runs by Regex Query␟15ed9f6fd2d4906a4803fc1255de3c5db2c56530␟9088985113960312808:Color Runs by Regex Query`,[[1,"regex-edit-dialog",3,"focusout"],["mat-dialog-title",""],["matInput","","aria-label",t,"cdkFocusInitial","",3,"value","keydown.enter","input"],["regexStringInput",""],[1,"example-details"],[3,"click"],["class","group-container",4,"ngIf"],["mat-dialog-actions","","align","end"],["mat-button","","mat-dialog-close",""],["mat-raised-button","","color","primary","mat-dialog-close","",3,"click"],[1,"group-container"],[1,"grouping-preview"],["class","match-container",4,"ngIf","ngIfElse"],["empty",""],[1,"match-container"],["class","group",3,"ngStyle",4,"ngFor","ngForOf"],[1,"group",3,"ngStyle"],[1,"color-swatch",3,"ngStyle"],[1,"group-id",3,"title"],[4,"ngFor","ngForOf"],["class","more",4,"ngIf"],["class","no-match",4,"ngIf"],[3,"title"],[1,"more"],[1,"no-match"],[1,"warning"]]},template:function(e,i){if(1&e){let r=Pe();_(0,"div",0),P("focusout",function(){return i.handleFocusOut()}),_(1,"h1",1),A(2,"Color runs by regex"),v(),_(3,"mat-dialog-content")(4,"p"),A(5,"Enter a regex with capturing groups to match against run names:"),v(),_(6,"mat-form-field")(7,"input",2,3),P("keydown.enter",function(s){return i.onEnter(s.target.value)})("input",function(s){return i.regexInputChange(s.target.value)}),v()()(),_(9,"div",4)(10,"p"),A(11,' Each matching run will be assigned a color based on the "key" formed by its matches to the capturing groups. '),O(12,"br"),_(13,"button",5),P("click",function(){return i.fillExample("(train|eval)")}),A(14," Try "),_(15,"code"),A(16,"(train|eval)"),v()(),A(17," to assign all runs containing "),_(18,"code"),A(19,"train"),v(),A(20," to one color and all runs containing "),_(21,"code"),A(22,"eval"),v(),A(23," to another color. "),v()(),E(24,DZe,7,2,"div",6),_(25,"div",7)(26,"button",8),A(27,"Cancel"),v(),_(28,"button",9),P("click",function(){oe(r);let s=$e(8);return se(i.onSaveClick(s.value))}),A(29," Save "),v()()()}2&e&&(C(7),Zi("value",i.regexString),C(17),y("ngIf",i.regexString))},dependencies:[dn,Be,zu,pd,_n,T2,Fte,D2,A2,Uh,nZ,Ql],styles:[".example-details[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{background-color:rgba(0,0,0,0);padding:0;border:none;cursor:pointer;text-decoration:underline;color:#1976d2}body.dark-mode[_nghost-%COMP%]   .example-details[_ngcontent-%COMP%]   button[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .example-details[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{color:#42a5f5}.example-details[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]:visited{color:#7b1fa2}body.dark-mode[_nghost-%COMP%]   .example-details[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]:visited, body.dark-mode   [_nghost-%COMP%]   .example-details[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]:visited{color:#ba68c8}.group-container[_ngcontent-%COMP%]{margin:10px 0}.group-container[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{margin-bottom:10px}.group-container[_ngcontent-%COMP%]   .warning[_ngcontent-%COMP%]{color:#616161;font-size:.9em}body.dark-mode[_nghost-%COMP%]   .group-container[_ngcontent-%COMP%]   .warning[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group-container[_ngcontent-%COMP%]   .warning[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}.grouping-preview[_ngcontent-%COMP%]{border:1px solid #ebebeb;max-height:50vh;overflow-y:auto;padding:20px}body.dark-mode[_nghost-%COMP%]   .grouping-preview[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .grouping-preview[_ngcontent-%COMP%]{border:1px solid #555}.match-container[_ngcontent-%COMP%]{align-items:flex-start;display:grid;flex-wrap:wrap;gap:10px;grid-template-columns:repeat(2, minmax(50%, 1fr))}.color-swatch[_ngcontent-%COMP%]{border-radius:50%;box-shadow:0 0 2px #000;display:inline-block;height:15px;width:15px}ul[_ngcontent-%COMP%]{list-style-type:none;padding:0}mat-form-field[_ngcontent-%COMP%]{width:100%}.group[_ngcontent-%COMP%]{border:1px solid #ebebeb;border-radius:3px;margin:0;padding:10px}body.dark-mode[_nghost-%COMP%]   .group[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group[_ngcontent-%COMP%]{border:1px solid #555}.group[_ngcontent-%COMP%]   label[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;align-items:center;display:grid;gap:10px;grid-template-columns:max-content auto;padding:5px 0}body.dark-mode[_nghost-%COMP%]   .group[_ngcontent-%COMP%]   label[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group[_ngcontent-%COMP%]   label[_ngcontent-%COMP%]{border-bottom:1px solid #555}.group[_ngcontent-%COMP%]   label[_ngcontent-%COMP%]   .group-id[_ngcontent-%COMP%]{font-size:.95em;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.group[_ngcontent-%COMP%]   ul[_ngcontent-%COMP%]{font-size:.9em}.group[_ngcontent-%COMP%]   ul[_ngcontent-%COMP%]   li[_ngcontent-%COMP%]{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.group[_ngcontent-%COMP%]   .more[_ngcontent-%COMP%], .group[_ngcontent-%COMP%]   .no-match[_ngcontent-%COMP%]{color:#616161;margin-top:5px}body.dark-mode[_nghost-%COMP%]   .group[_ngcontent-%COMP%]   .more[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group[_ngcontent-%COMP%]   .more[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}body.dark-mode[_nghost-%COMP%]   .group[_ngcontent-%COMP%]   .no-match[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .group[_ngcontent-%COMP%]   .no-match[_ngcontent-%COMP%]{color:rgba(255,255,255,.7)}"],changeDetection:0}),n})(),lhe=(()=>{class n{constructor(e,i,r){this.store=e,this.dialogRef=i,this.tentativeRegexString$=new ke,this.groupByRegexString$=Qa(()=>Jt(this.store.select(YI).pipe(Qt(1)),this.tentativeRegexString$)).pipe(zn("")),this.colorRunPairList$=Qa(()=>this.groupByRegexString$.pipe(Hr(500),Ye(o=>{try{let s=new RegExp(o);return Boolean(s)}catch{return!1}}),fr(this.allRuns$,this.runIdToEid$,this.store.select(Na.getColorPalette),this.store.select(Qu)),L(([o,s,a,l,c])=>{let d=GM({key:sr.REGEX,regexString:o},s,a),p=new Map,h=[];for(let[f,m]of Object.entries(d.matches)){let x=p.get(f);if(!x){let g=l.colors[p.size%l.colors.length];x=c?g.darkHex:g.lightHex,p.set(f,x)}h.push({groupId:f,color:x,runs:m})}return h}))).pipe(zn([])),this.experimentIds=r.experimentIds,this.runIdToEid$=Lt(this.experimentIds.map(o=>this.store.select(See,{experimentId:o}).pipe(L(s=>({experimentId:o,runIds:s}))))).pipe(L(o=>{let s={};for(let{runIds:a,experimentId:l}of o)for(let c of a)s[c]=l;return s})),this.allRuns$=Lt(this.experimentIds.map(o=>this.store.select(rd,{experimentId:o}))).pipe(L(o=>o.flat()))}onRegexInputOnChange(e){this.tentativeRegexString$.next(e)}onSave(e){this.store.dispatch(av({experimentIds:this.experimentIds,groupBy:{key:sr.REGEX,regexString:e}}))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce),M(tu),M(cw))},n.\u0275cmp=R({type:n,selectors:[["regex-edit-dialog"]],decls:3,vars:6,consts:[[3,"regexString","colorRunPairList","onSave","regexInputOnChange"]],template:function(e,i){1&e&&(_(0,"regex-edit-dialog-component",0),P("onSave",function(o){return i.onSave(o)})("regexInputOnChange",function(o){return i.onRegexInputOnChange(o)}),B(1,"async"),B(2,"async"),v()),2&e&&y("regexString",U(1,2,i.groupByRegexString$))("colorRunPairList",U(2,4,i.colorRunPairList$))},dependencies:[ahe,Ge],styles:["[_nghost-%COMP%], regex-edit-dialog-component[_ngcontent-%COMP%] {\n        display: block;\n        height: 100%;\n        width: 100%;\n      }"]}),n})();function PZe(n,t){1&n&&O(0,"mat-icon",14)}function RZe(n,t){if(1&n){let e=Pe();_(0,"button",13),P("click",function(){oe(e);let r=S();return se(r.onGroupByChange.emit({key:r.GroupByKey.EXPERIMENT}))}),_(1,"span"),E(2,PZe,1,0,"mat-icon",7),v(),_(3,"label"),A(4,"Experiment"),v()()}if(2&n){let e=S();ze("aria-checked",e.selectedGroupBy.key===e.GroupByKey.EXPERIMENT),C(2),y("ngIf",e.selectedGroupBy.key===e.GroupByKey.EXPERIMENT)}}function OZe(n,t){1&n&&O(0,"mat-icon",14)}function kZe(n,t){1&n&&O(0,"mat-icon",14)}function FZe(n,t){if(1&n&&(_(0,"label"),A(1),v()),2&n){let e=S();C(1),yt(e.regexString)}}function NZe(n,t){1&n&&(_(0,"label",15),A(1,"(none set)"),v())}var che=(()=>{class n{constructor(e){this.dialog=e,this.GroupByKey=sr,this.onGroupByChange=new G}onRegexStringEdit(){this.dialog.open(lhe,{maxHeight:"95vh",maxWidth:"80vw",data:{experimentIds:this.experimentIds}})}onGroupByRegexClick(){this.regexString?this.onGroupByChange.emit({key:sr.REGEX,regexString:this.regexString}):this.onRegexStringEdit()}}return n.\u0275fac=function(e){return new(e||n)(M(vl))},n.\u0275cmp=R({type:n,selectors:[["runs-group-menu-button-component"]],inputs:{showExperimentsGroupBy:"showExperimentsGroupBy",experimentIds:"experimentIds",regexString:"regexString",selectedGroupBy:"selectedGroupBy"},outputs:{onGroupByChange:"onGroupByChange"},decls:22,vars:8,consts:[["mat-icon-button","","title","Color runs by...",3,"matMenuTriggerFor"],["svgIcon","palette_24px"],[1,"run-table-color-group-by"],["groupByMenu","matMenu"],[1,"label"],["mat-menu-item","","role","menuitemradio","data-value","experiment",3,"click",4,"ngIf"],["mat-menu-item","","role","menuitemradio","data-value","run",3,"click"],["svgIcon","done_24px",4,"ngIf"],["mat-menu-item","","role","menuitemradio","data-value","regex",3,"click"],["mat-menu-item","","role","menuitem","data-value","regex-edit",1,"display-regex-string",3,"click"],["svgIcon","edit_24px"],[4,"ngIf"],["class","none-set-string",4,"ngIf"],["mat-menu-item","","role","menuitemradio","data-value","experiment",3,"click"],["svgIcon","done_24px"],[1,"none-set-string"]],template:function(e,i){1&e&&(_(0,"button",0),O(1,"mat-icon",1),v(),_(2,"mat-menu",2,3)(4,"div",4),A(5,"Color runs by"),v(),E(6,RZe,5,2,"button",5),_(7,"button",6),P("click",function(){return i.onGroupByChange.emit({key:i.GroupByKey.RUN})}),_(8,"span"),E(9,OZe,1,0,"mat-icon",7),v(),_(10,"label"),A(11,"Run"),v()(),_(12,"button",8),P("click",function(){return i.onGroupByRegexClick()}),_(13,"span"),E(14,kZe,1,0,"mat-icon",7),v(),_(15,"label"),A(16,"Regex"),v()(),_(17,"button",9),P("click",function(){return i.onRegexStringEdit()}),_(18,"span"),O(19,"mat-icon",10),v(),E(20,FZe,2,1,"label",11),E(21,NZe,2,0,"label",12),v()()),2&e&&(y("matMenuTriggerFor",$e(3)),C(6),y("ngIf",i.showExperimentsGroupBy),C(1),ze("aria-checked",i.selectedGroupBy.key===i.GroupByKey.RUN),C(2),y("ngIf",i.selectedGroupBy.key===i.GroupByKey.RUN),C(3),ze("aria-checked",i.selectedGroupBy.key===i.GroupByKey.REGEX),C(2),y("ngIf",i.selectedGroupBy.key===i.GroupByKey.REGEX),C(6),y("ngIf",i.regexString),C(1),y("ngIf",!i.regexString))},dependencies:[Be,_n,Gt,hd,nu,fd],styles:[".run-table-color-group-by{font-size:16px}  .run-table-color-group-by .label{color:#616161;font-size:.9em;margin:10px 0;padding:0 16px;pointer-events:none}  .run-table-color-group-by button{display:grid;gap:2px 10px;grid-template-columns:20px auto}  .run-table-color-group-by mat-icon{height:20px;width:20px}  .run-table-color-group-by .display-regex-string{padding-left:40px}  .run-table-color-group-by .display-regex-string .none-set-string{color:#616161}body.dark-mode[_nghost-%COMP%]     .run-table-color-group-by .display-regex-string .none-set-string, body.dark-mode   [_nghost-%COMP%]     .run-table-color-group-by .display-regex-string .none-set-string{color:rgba(255,255,255,.7)}"],changeDetection:0}),n})(),uhe=(()=>{class n{constructor(e){this.store=e,this.showExperimentsGroupBy$=this.store.select(e$).pipe(L(i=>i.has(hi.COMPARE_EXPERIMENT))),this.selectedGroupBy$=this.store.select(Eee),this.groupByRegexString$=this.store.select(YI)}onGroupByChange(e){this.store.dispatch(av({experimentIds:this.experimentIds,groupBy:e}))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["runs-group-menu-button"]],inputs:{experimentIds:"experimentIds"},decls:4,vars:10,consts:[[3,"regexString","selectedGroupBy","showExperimentsGroupBy","experimentIds","onGroupByChange"]],template:function(e,i){1&e&&(_(0,"runs-group-menu-button-component",0),P("onGroupByChange",function(o){return i.onGroupByChange(o)}),B(1,"async"),B(2,"async"),B(3,"async"),v()),2&e&&y("regexString",U(1,4,i.groupByRegexString$))("selectedGroupBy",U(2,6,i.selectedGroupBy$))("showExperimentsGroupBy",U(3,8,i.showExperimentsGroupBy$))("experimentIds",i.experimentIds)},dependencies:[che,Ge],encapsulation:2,changeDetection:0}),n})(),VZe=["filter"];function HZe(n,t){1&n&&Ni(0)}function UZe(n,t){1&n&&Ni(0)}var zZe=function(n){return{item:n}};function jZe(n,t){if(1&n&&(sn(0),E(1,UZe,1,0,"ng-container",12),an()),2&n){let e=t.$implicit;S();let i=$e(14);C(1),y("ngTemplateOutlet",i)("ngTemplateOutletContext",On(2,zZe,e))}}function GZe(n,t){1&n&&(_(0,"div",13),O(1,"mat-spinner",14),v())}function WZe(n,t){1&n&&(_(0,"div",15),A(1,"No Runs"),v())}function qZe(n,t){if(1&n&&(_(0,"div",15)(1,"span"),A(2,'No runs match "'),_(3,"code"),A(4),v(),A(5,'"'),v()()),2&n){let e=S();C(4),yt(e.regexFilter)}}var YZe=function(){return[5,10,20]};function XZe(n,t){if(1&n){let e=Pe();_(0,"mat-paginator",16),P("page",function(r){return oe(e),se(S().onPaginationChange.emit(r))}),v()}if(2&n){let e=S();y("pageSizeOptions",Qp(4,YZe))("pageIndex",e.paginationOption.pageIndex)("pageSize",e.paginationOption.pageSize)("length",e.filteredItemsLength)}}function QZe(n,t){if(1&n){let e=Pe();_(0,"mat-checkbox",26),P("change",function(){return oe(e),se(S(3).handlePageToggle())}),v()}if(2&n){let e=S(3);y("checked",e.allPageItemsSelected())("indeterminate",!e.allPageItemsSelected()&&e.somePageItemsSelected())}}var dhe=function(n){return{type:n}};function KZe(n,t){if(1&n&&(_(0,"span",27),A(1,"Experiment"),v()),2&n){let e=S(3);y("mat-sort-header",On(1,dhe,e.SortType.EXPERIMENT_NAME))}}function ZZe(n,t){if(1&n&&(_(0,"span",27),A(1,"Run"),v()),2&n){let e=S(3);y("mat-sort-header",On(1,dhe,e.SortType.RUN_NAME))}}function JZe(n,t){if(1&n&&(_(0,"span"),O(1,"runs-group-menu-button",28),v()),2&n){let e=S(3);C(1),y("experimentIds",e.experimentIds)}}var phe=function(n){return["column",n]};function $Ze(n,t){if(1&n&&(_(0,"span",21),sn(1,22),E(2,QZe,1,2,"mat-checkbox",23),E(3,KZe,2,3,"span",24),E(4,ZZe,2,3,"span",24),E(5,JZe,2,1,"span",25),an(),v()),2&n){let e=t.$implicit,i=S(2);y("ngClass",On(6,phe,"tb-column-"+e)),C(1),y("ngSwitch",e),C(1),y("ngSwitchCase",i.RunsTableColumn.CHECKBOX),C(1),y("ngSwitchCase",i.RunsTableColumn.EXPERIMENT_NAME),C(1),y("ngSwitchCase",i.RunsTableColumn.RUN_NAME),C(1),y("ngSwitchCase",i.RunsTableColumn.RUN_COLOR)}}function eJe(n,t){if(1&n){let e=Pe();sn(0),_(1,"div",37),P("click",function(r){return r.stopPropagation()}),_(2,"tb-range-input",38),P("rangeValuesChanged",function(r){oe(e);let o=S(2).$implicit;return se(S(2).handleHparamIntervalChanged(o,r))}),v()(),an()}if(2&n){let e=S(2).$implicit;C(2),y("min",e.filter.minValue)("max",e.filter.maxValue)("lowerValue",e.filter.filterLowerValue)("upperValue",e.filter.filterUpperValue)}}function tJe(n,t){if(1&n){let e=Pe();_(0,"div",40),P("click",function(r){return r.stopPropagation()}),_(1,"mat-checkbox",36),P("change",function(){let o=oe(e).$implicit,s=S(3).$implicit;return se(S(2).handleHparamDiscreteChanged(s,o))}),_(2,"span"),A(3),v()()()}if(2&n){let e=t.$implicit,i=S(3).$implicit;C(1),y("checked",i.filter.filterValues.includes(e)),C(2),yt(e)}}function nJe(n,t){if(1&n&&(sn(0),E(1,tJe,4,2,"div",39),an()),2&n){let e=S(2).$implicit;C(1),y("ngForOf",e.filter.possibleValues)}}function iJe(n,t){if(1&n){let e=Pe();sn(0),_(1,"button",32),P("click",function(r){return r.stopPropagation()}),O(2,"mat-icon",33),v(),_(3,"mat-menu",null,34)(5,"div",35),P("click",function(r){return r.stopPropagation()}),_(6,"mat-checkbox",36),P("change",function(){oe(e);let r=S().$implicit;return se(S(2).handleHparamIncludeUndefinedToggled(r))}),_(7,"span"),A(8,"(show empty value)"),v()()(),E(9,eJe,3,4,"ng-container",31),E(10,nJe,2,1,"ng-container",31),v(),an()}if(2&n){let e=$e(4),i=S().$implicit,r=S(2);C(1),y("matMenuTriggerFor",e),ze("aria-label","Filter hparam "+(i.displayName||i.name)),C(5),y("checked",i.filter.includeUndefined),C(3),y("ngIf",i.filter.type===r.DomainType.INTERVAL),C(1),y("ngIf",i.filter.type===r.DomainType.DISCRETE)}}var rJe=function(n,t){return{type:n,name:t}};function oJe(n,t){if(1&n&&(_(0,"span",29)(1,"span",30),A(2),v(),E(3,iJe,11,5,"ng-container",31),v()),2&n){let e=t.$implicit,i=S(2);y("mat-sort-header",Qr(3,rJe,i.SortType.HPARAM,e.name)),C(2),yt(e.displayName||e.name),C(1),y("ngIf",e.filter)}}function sJe(n,t){if(1&n){let e=Pe();sn(0),_(1,"button",32),P("click",function(r){return r.stopPropagation()}),O(2,"mat-icon",33),v(),_(3,"mat-menu",null,34)(5,"div",35),P("click",function(r){return r.stopPropagation()}),_(6,"mat-checkbox",36),P("change",function(){oe(e);let r=S().$implicit;return se(S(2).handleMetricIncludeUndefinedChanged(r))}),_(7,"span"),A(8,"(show empty value)"),v()()(),_(9,"div",37),P("click",function(r){return r.stopPropagation()}),_(10,"tb-range-input",38),P("rangeValuesChanged",function(r){oe(e);let o=S().$implicit;return se(S(2).handleMetricFilterChanged(o,r))}),v()()(),an()}if(2&n){let e=$e(4),i=S().$implicit;C(1),y("matMenuTriggerFor",e),ze("aria-label","Filter metric "+(i.displayName||i.tag)),C(5),y("checked",i.filter.includeUndefined),C(4),y("min",i.filter.minValue)("max",i.filter.maxValue)("lowerValue",i.filter.filterLowerValue)("upperValue",i.filter.filterUpperValue)}}var aJe=function(n,t){return{type:n,tag:t}};function lJe(n,t){if(1&n&&(_(0,"span",29)(1,"span",30),A(2),v(),E(3,sJe,11,7,"ng-container",31),v()),2&n){let e=t.$implicit,i=S(2);y("mat-sort-header",Qr(3,aJe,i.SortType.METRIC,e.tag)),C(2),yt(e.displayName||e.tag),C(1),y("ngIf",e.filter)}}function cJe(n,t){if(1&n){let e=Pe();_(0,"div",17)(1,"div",18),P("matSortChange",function(r){return oe(e),se(S().handleSortChange(r))}),E(2,$Ze,6,8,"span",19),E(3,oJe,4,6,"span",20),E(4,lJe,4,6,"span",20),v()()}if(2&n){let e=S();C(1),y("matSortActive",e.sortOption.column),C(1),y("ngForOf",e.columns),C(1),y("ngForOf",e.hparamColumns)("ngForTrackBy",e.trackByHparamColumn),C(1),y("ngForOf",e.metricColumns)("ngForTrackBy",e.trackByMetricColumn)}}function uJe(n,t){if(1&n){let e=Pe();_(0,"span")(1,"mat-checkbox",47),P("change",function(){oe(e);let r=S(2).item;return se(S().onSelectionToggle.emit(r))})("dblclick",function(){oe(e);let r=S(2).item;return se(S().onSelectionDblClick.emit(r))}),v()()}if(2&n){let e=S(2).item;C(1),y("checked",e.selected)}}function dJe(n,t){if(1&n&&O(0,"tb-experiment-alias",48),2&n){let e=S(2).item;y("alias",e.experimentAlias)("title",e.experimentName)}}function pJe(n,t){if(1&n&&(_(0,"span",30),A(1),v()),2&n){let e=S(2).item;C(1),yt(e.run.name)}}var hJe=function(n){return{"run-color-swatch":!0,"no-color":n}};function fJe(n,t){if(1&n){let e=Pe();_(0,"span")(1,"button",49),P("colorPickerChange",function(r){oe(e);let o=S(2).item;return se(S().onRunColorChange.emit({runId:o.run.id,newColor:r}))}),v()()}if(2&n){let e=S(2).item;C(1),Pt("background",e.runColor),y("ngClass",On(8,hJe,!e.runColor))("colorPicker",e.runColor)("cpDialogDisplay","popup")("cpPositionOffset",-20)("cpUseRootViewContainer",!0)("cpOutputFormat","hex")}}function mJe(n,t){if(1&n&&(_(0,"span",44),sn(1,22),E(2,uJe,2,1,"span",25),E(3,dJe,1,2,"tb-experiment-alias",45),E(4,pJe,2,1,"span",46),E(5,fJe,2,10,"span",25),an(),v()),2&n){let e=t.$implicit,i=S(2);y("ngClass",On(6,phe,"tb-column-"+e)),C(1),y("ngSwitch",e),C(1),y("ngSwitchCase",i.RunsTableColumn.CHECKBOX),C(1),y("ngSwitchCase",i.RunsTableColumn.EXPERIMENT_NAME),C(1),y("ngSwitchCase",i.RunsTableColumn.RUN_NAME),C(1),y("ngSwitchCase",i.RunsTableColumn.RUN_COLOR)}}function gJe(n,t){if(1&n&&(_(0,"span",50),A(1),v()),2&n){let e=t.$implicit,i=S().item;C(1),yt(i.hparams.get(e.name))}}function _Je(n,t){if(1&n&&(_(0,"span",50),A(1),v()),2&n){let e=t.$implicit,i=S().item;C(1),yt(i.metrics.get(e.tag))}}function vJe(n,t){if(1&n&&(_(0,"div",41),E(1,mJe,6,8,"span",42),E(2,gJe,2,1,"span",43),E(3,_Je,2,1,"span",43),v()),2&n){let e=t.item,i=S();ze("data-id",e.run.id),C(1),y("ngForOf",i.columns),C(1),y("ngForOf",i.hparamColumns),C(1),y("ngForOf",i.metricColumns)}}var yJe=(()=>{class n extends e0{constructor(){super(...arguments),this.itemsPerPageLabel="Show runs:"}}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),hhe=(()=>{class n{constructor(){this.dataSource=new Jk,this.DomainType=Ci,this.RunsTableColumn=va,this.SortType=id,this.onRegexFilterChange=new G,this.onSelectionToggle=new G,this.onSelectionDblClick=new G,this.onPageSelectionToggle=new G,this.onPaginationChange=new G,this.onSortChange=new G,this.onRunColorChange=new G,this.onHparamDiscreteFilterChanged=new G,this.onHparamIntervalFilterChanged=new G,this.onMetricFilterChanged=new G}ngOnChanges(){this.dataSource.data=this.pageItems}getHparamColumnId(e){return`h:${e.name}`}getMetricColumnId(e){return`m:${e.tag}`}getColumnIds(){return[...this.columns,...this.hparamColumns.map(this.getHparamColumnId),...this.metricColumns.map(this.getMetricColumnId)]}allPageItemsSelected(){return Boolean(this.pageItems.length)&&this.pageItems.every(e=>e.selected)}somePageItemsSelected(){return this.pageItems.some(e=>e.selected)}handlePageToggle(){this.onPageSelectionToggle.emit({items:this.pageItems})}handleSortChange(e){let i;switch(e.direction){case"asc":i=ic.ASC;break;case"desc":i=ic.DESC;break;default:i=ic.UNSET}this.onSortChange.emit({key:e.active,direction:i})}onFilterKeyUp(e){this.onRegexFilterChange.emit(e.target.value)}tableTrackBy(e,i){return i.run.id}handleHparamIncludeUndefinedToggled(e){let{name:i,filter:r}=e;if(!r)throw new RangeError("Invariant error: require filter to exist for it to change");r.type===Ci.DISCRETE?this.onHparamDiscreteFilterChanged.emit({hparamName:i,includeUndefined:!r.includeUndefined,filterValues:r.filterValues}):this.onHparamIntervalFilterChanged.emit({name:i,includeUndefined:!r.includeUndefined,filterLowerValue:r.filterLowerValue,filterUpperValue:r.filterUpperValue})}handleHparamIntervalChanged(e,i){let{name:r,filter:o}=e;if(!o)throw new RangeError("Invariant error: require filter to exist for it to change");this.onHparamIntervalFilterChanged.emit({name:r,includeUndefined:o.includeUndefined,filterLowerValue:i.lowerValue,filterUpperValue:i.upperValue})}handleHparamDiscreteChanged(e,i){let{name:r,filter:o}=e;if(!o)throw new RangeError("Invariant error: require filter to exist for it to change");if(o.type!==Ci.DISCRETE)throw new RangeError(`Invariant error: expected discrete domain for ${r}`);let s=new Set([...o.filterValues]);s.has(i)?s.delete(i):s.add(i),this.onHparamDiscreteFilterChanged.emit({hparamName:r,includeUndefined:o.includeUndefined,filterValues:[...s]})}handleMetricIncludeUndefinedChanged(e){if(!e.filter)throw new RangeError("Invariant error: require filter to exist for it to change");this.onMetricFilterChanged.emit({name:e.tag,includeUndefined:!e.filter.includeUndefined,filterLowerValue:e.filter.filterLowerValue,filterUpperValue:e.filter.filterUpperValue})}handleMetricFilterChanged(e,i){if(!e.filter)throw new RangeError("Invariant error: require filter to exist for it to change");this.onMetricFilterChanged.emit({name:e.tag,includeUndefined:e.filter.includeUndefined,filterLowerValue:i.lowerValue,filterUpperValue:i.upperValue})}trackByHparamColumn(e){return e.name}trackByMetricColumn(e){return e.tag}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["runs-table-component"]],viewQuery:function(e,i){if(1&e&&(ot(VZe,7,Re),ot(Kk,7),ot(ME,7)),2&e){let r;Ne(r=Le())&&(i.filter=r.first),Ne(r=Le())&&(i.paginator=r.first),Ne(r=Le())&&(i.sort=r.first)}},hostVars:2,hostBindings:function(e,i){2&e&&et("flex-layout",i.useFlexibleLayout)},inputs:{experimentIds:"experimentIds",showExperimentName:"showExperimentName",columns:"columns",hparamColumns:"hparamColumns",metricColumns:"metricColumns",allItemsLength:"allItemsLength",filteredItemsLength:"filteredItemsLength",useFlexibleLayout:"useFlexibleLayout",usePagination:"usePagination",pageItems:"pageItems",loading:"loading",numSelectedItems:"numSelectedItems",sortOption:"sortOption",paginationOption:"paginationOption",regexFilter:"regexFilter"},outputs:{onRegexFilterChange:"onRegexFilterChange",onSelectionToggle:"onSelectionToggle",onSelectionDblClick:"onSelectionDblClick",onPageSelectionToggle:"onPageSelectionToggle",onPaginationChange:"onPaginationChange",onSortChange:"onSortChange",onRunColorChange:"onRunColorChange",onHparamDiscreteFilterChanged:"onHparamDiscreteFilterChanged",onHparamIntervalFilterChanged:"onHparamIntervalFilterChanged",onMetricFilterChanged:"onMetricFilterChanged"},features:[$t([{provide:e0,useClass:yJe}]),Ft],decls:15,vars:8,consts:[[1,"filter-row"],["placeholder","Filter runs (regex)",1,"run-filter",3,"value","keyup"],[1,"table-container"],["role","table"],[4,"ngTemplateOutlet"],["role","rowgroup",1,"rows"],[4,"ngFor","ngForOf","ngForTrackBy"],["class","loading",4,"ngIf"],["class","no-runs",4,"ngIf"],["showFirstLastButtons","",3,"pageSizeOptions","pageIndex","pageSize","length","page",4,"ngIf"],["header",""],["row",""],[4,"ngTemplateOutlet","ngTemplateOutletContext"],[1,"loading"],["mode","indeterminate","diameter","28"],[1,"no-runs"],["showFirstLastButtons","",3,"pageSizeOptions","pageIndex","pageSize","length","page"],["role","rowgroup",1,"header"],["matSort","","role","row",3,"matSortActive","matSortChange"],["role","columnheader",3,"ngClass",4,"ngFor","ngForOf"],["role","columnheader","class","column",3,"mat-sort-header",4,"ngFor","ngForOf","ngForTrackBy"],["role","columnheader",3,"ngClass"],[3,"ngSwitch"],[3,"checked","indeterminate","change",4,"ngSwitchCase"],[3,"mat-sort-header",4,"ngSwitchCase"],[4,"ngSwitchCase"],[3,"checked","indeterminate","change"],[3,"mat-sort-header"],[3,"experimentIds"],["role","columnheader",1,"column",3,"mat-sort-header"],[1,"name"],[4,"ngIf"],["mat-icon-button","",3,"matMenuTriggerFor","click"],["svgIcon","filter_alt_24px"],["filterMenu","matMenu"],["mat-menu-item","","role","menuitemcheckbox","disableRipple","",1,"filter-menu-checkbox-row",3,"click"],[3,"checked","change"],["disableRipple","","mat-menu-item","",1,"range-input-container",3,"click"],[3,"min","max","lowerValue","upperValue","rangeValuesChanged"],["mat-menu-item","","class","filter-menu-checkbox-row","role","menuitemcheckbox",3,"click",4,"ngFor","ngForOf"],["mat-menu-item","","role","menuitemcheckbox",1,"filter-menu-checkbox-row",3,"click"],["role","row"],["role","cell",3,"ngClass",4,"ngFor","ngForOf"],["role","cell","class","column",4,"ngFor","ngForOf"],["role","cell",3,"ngClass"],[3,"alias","title",4,"ngSwitchCase"],["class","name",4,"ngSwitchCase"],["title","Click to toggle run selection or double click to select only this run.",3,"checked","change","dblclick"],[3,"alias","title"],[3,"ngClass","colorPicker","cpDialogDisplay","cpPositionOffset","cpUseRootViewContainer","cpOutputFormat","colorPickerChange"],["role","cell",1,"column"]],template:function(e,i){if(1&e&&(_(0,"div",0)(1,"tb-filter-input",1),P("keyup",function(o){return i.onFilterKeyUp(o)}),v()(),_(2,"div",2)(3,"div",3),E(4,HZe,1,0,"ng-container",4),_(5,"div",5),E(6,jZe,2,4,"ng-container",6),v()(),E(7,GZe,2,0,"div",7),E(8,WZe,2,0,"div",8),E(9,qZe,6,1,"div",8),v(),E(10,XZe,1,5,"mat-paginator",9),E(11,cJe,5,6,"ng-template",null,10,qt),E(13,vJe,4,4,"ng-template",null,11,qt)),2&e){let r=$e(12);C(1),Zi("value",i.regexFilter),C(3),y("ngTemplateOutlet",r),C(2),y("ngForOf",i.pageItems)("ngForTrackBy",i.tableTrackBy),C(1),y("ngIf",i.loading),C(1),y("ngIf",!i.loading&&0===i.allItemsLength),C(1),y("ngIf",!i.loading&&i.allItemsLength>0&&0===i.filteredItemsLength),C(1),y("ngIf",i.usePagination)}},dependencies:[rhe,Fn,dn,Be,os,Cr,Ur,cy,Yk,_n,yl,Gt,hd,nu,fd,Kk,Bo,ME,Kpe,she,uhe],styles:["[_nghost-%COMP%]{display:flex;flex-direction:column;font-size:13px;overflow:hidden}.filter-row[_ngcontent-%COMP%]{flex:none}.table-container[_ngcontent-%COMP%]{contain:layout paint;flex-grow:1;max-width:100%;overflow-x:auto;overflow-y:auto;will-change:transform,scroll-position}.flex-layout[_nghost-%COMP%]   .name[_ngcontent-%COMP%]{word-break:break-word;overflow-wrap:break-word}.flex-layout[_nghost-%COMP%]   mat-paginator[_ngcontent-%COMP%]{border-top:1px solid #ebebeb;padding-bottom:12px}body.dark-mode   .flex-layout[_nghost-%COMP%]   mat-paginator[_ngcontent-%COMP%]{border-top:1px solid #555}[role=table][_ngcontent-%COMP%]{display:table;width:100%}[role=table][_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]{white-space:nowrap}[role=table][_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]   [role=columnheader][_ngcontent-%COMP%]{background-color:#fff;position:sticky;top:0;z-index:1}body.dark-mode[_nghost-%COMP%]   [role=table][_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]   [role=columnheader][_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   [role=table][_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]   [role=columnheader][_ngcontent-%COMP%]{background-color:#303030}[role=table][_ngcontent-%COMP%]   [role=row][_ngcontent-%COMP%]{contain:strict;display:table-row;height:43px}[role=table][_ngcontent-%COMP%]   [role=row][_ngcontent-%COMP%]   .column[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;display:table-cell;padding:5px;vertical-align:middle}body.dark-mode[_nghost-%COMP%]   [role=table][_ngcontent-%COMP%]   [role=row][_ngcontent-%COMP%]   .column[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   [role=table][_ngcontent-%COMP%]   [role=row][_ngcontent-%COMP%]   .column[_ngcontent-%COMP%]{border-bottom:1px solid #555}[role=table][_ngcontent-%COMP%]   [role=row][_ngcontent-%COMP%]   .column[_ngcontent-%COMP%]:first-child{padding-left:24px}[role=table][_ngcontent-%COMP%]   [role=row][_ngcontent-%COMP%]   .column[_ngcontent-%COMP%]:last-child{padding-right:24px}[role=rowgroup][_ngcontent-%COMP%]{display:table-row-group}[role=rowgroup].header[_ngcontent-%COMP%]{display:table-header-group}.loading[_ngcontent-%COMP%], .no-runs[_ngcontent-%COMP%]{align-items:center;border:0;border-bottom:1px solid #ebebeb;display:flex;height:48px;padding:0 24px}body.dark-mode[_nghost-%COMP%]   .loading[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .loading[_ngcontent-%COMP%]{border-bottom:1px solid #555}body.dark-mode[_nghost-%COMP%]   .no-runs[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .no-runs[_ngcontent-%COMP%]{border-bottom:1px solid #555}.loading[_ngcontent-%COMP%]{justify-content:center}.select-all[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{padding-bottom:12px;padding-top:12px}.select-all-content[_ngcontent-%COMP%], .select-all-content[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{font-weight:400;line-height:1.6;text-align:left}.select-all-content[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{font-weight:500;padding:0 4px}.filter-row[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;display:flex;align-items:center;height:48px;padding:0 16px 0 21px}body.dark-mode[_nghost-%COMP%]   .filter-row[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .filter-row[_ngcontent-%COMP%]{border-bottom:1px solid #555}.filter-row[_ngcontent-%COMP%]   tb-filter-input[_ngcontent-%COMP%]{flex-grow:1}.tb-column-checkbox[_ngcontent-%COMP%], .tb-column-run_color[_ngcontent-%COMP%]{width:20px}.tb-column-run_color[_ngcontent-%COMP%]{text-align:center}.run-color-swatch[_ngcontent-%COMP%]{border-radius:100%;border:1px solid #ebebeb;height:20px;width:20px;outline:none}.run-color-swatch.no-color[_ngcontent-%COMP%]{border-color:#c6cad1;border-width:2px}.range-input-container[_ngcontent-%COMP%]{height:auto}[_nghost-%COMP%]     mat-paginator mat-form-field{margin:0}.filter-menu-checkbox-row[_ngcontent-%COMP%]   mat-checkbox[_ngcontent-%COMP%]     label{display:flex;height:100%;align-items:center}.filter-menu-checkbox-row[_ngcontent-%COMP%]   mat-checkbox[_ngcontent-%COMP%]     label .mat-checkbox-inner-container{margin-left:0}.filter-menu-checkbox-row[_ngcontent-%COMP%]   mat-checkbox[_ngcontent-%COMP%]     label .mat-checkbox-label{overflow:hidden;text-overflow:ellipsis}body.dark-mode[_nghost-%COMP%]   mat-paginator[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   mat-paginator[_ngcontent-%COMP%]{background-color:#303030}"],changeDetection:0}),n})(),xJe=J(WM,n=>n.state===Oe.LOADING);function fhe(n,t){switch(t.type){case id.EXPERIMENT_NAME:return[n.experimentAlias,n.run.name,n.run.id];case id.RUN_NAME:return[n.run.name,n.experimentAlias,n.run.id];case id.HPARAM:return[n.hparams.get(t.name),n.run.name,n.experimentAlias,n.run.id];case id.METRIC:return[n.metrics.get(t.tag),n.run.name,n.experimentAlias,n.run.id];default:throw new Error(`Not yet implemented: ${t}`)}}function mhe(n,t){return void 0===t?n.includeUndefined:n.type===Ci.DISCRETE?n.filterValues.includes(t):n.type===Ci.INTERVAL&&n.filterLowerValue<=t&&t<=n.filterUpperValue}var ghe=(()=>{class n{constructor(e){this.store=e,this.loading$=null,this.hparamColumns$=Xt([]),this.metricColumns$=Xt([]),this.useFlexibleLayout=!1,this.usePagination=!1,this.columns=[va.RUN_NAME],this.showHparamsAndMetrics=!1,this.sortOption$=this.store.select(aH),this.paginationOption$=this.store.select(sH),this.regexFilter$=this.store.select(Qm),this.ngUnsubscribe=new ke}isExperimentNameVisible(){return this.columns.some(e=>e===va.EXPERIMENT_NAME)}ngOnInit(){let i=Lt(this.experimentIds.map(s=>this.getRunTableItemsForExperiment(s))).pipe(L(s=>[].concat(...s)));this.allUnsortedRunTableItems$=i.pipe(st(this.ngUnsubscribe),Ma(1)),this.allItemsLength$=this.allUnsortedRunTableItems$.pipe(L(s=>s.length));let r=this.getFilteredItems$(this.allUnsortedRunTableItems$).pipe(st(this.ngUnsubscribe),Ma(1));this.filteredItemsLength$=r.pipe(L(s=>s.length)),this.pageItems$=this.sortedAndSlicedItems$(r),this.numSelectedItems$=this.allUnsortedRunTableItems$.pipe(L(s=>s.reduce((a,l)=>a+Number(l.selected),0)));let o=this.experimentIds.map(s=>this.store.select(xJe,{experimentId:s}));if(this.loading$=Lt(o).pipe(L(s=>s.some(a=>a))),this.showHparamsAndMetrics){let s=this.store.select(Df.getExperimentsHparamsAndMetricsSpecs,{experimentIds:this.experimentIds});this.hparamColumns$=Lt([this.store.select(Df.getHparamFilterMap,this.experimentIds),s]).pipe(L(([a,{hparams:l}])=>l.map(({name:c,displayName:u})=>{let p=a.get(c);if(!p)throw new RangeError(`Invariant error: a filter for ${c} must exist when the hparam exists`);return{displayName:u,name:c,filter:p}}))),this.metricColumns$=Lt([this.store.select(Df.getMetricFilterMap,this.experimentIds),s]).pipe(L(([a,{metrics:l}])=>l.map(({tag:c,displayName:u})=>{let d=a.get(c);if(!d)throw new RangeError(`Invariant error: a filter for ${c} must exist when the metric exists`);return{displayName:u,tag:c,filter:d}})))}this.columns.includes(va.CHECKBOX)&&this.store.select(Ra).pipe(st(this.ngUnsubscribe),yi((a,l)=>Ps(a,l)),ui(()=>i.pipe(Ye(a=>a.length>500),Qt(1)))).subscribe(()=>{this.store.dispatch(vv({localizedMessage:"The number of runs exceeds 500. New runs are unselected for performance reasons."}))}),this.store.dispatch(dI({experimentIds:this.experimentIds}))}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}getFilteredItems$(e){return Lt([e,this.store.select(Qm)]).pipe(L(([i,r])=>{if(!r)return i;let o=this.columns.includes(va.EXPERIMENT_NAME);return i.filter(s=>JI({runName:s.run.name,experimentAlias:s.experimentAlias},r,o))}),ui(i=>this.showHparamsAndMetrics?Lt(this.store.select(Df.getHparamFilterMap,this.experimentIds),this.store.select(Df.getMetricFilterMap,this.experimentIds)).pipe(L(([r,o])=>i.filter(({hparams:s,metrics:a})=>[...r.entries()].every(([c,u])=>mhe(u,s.get(c)))&&[...o.entries()].every(([c,u])=>mhe(u,a.get(c)))))):Xt(i)))}sortedAndSlicedItems$(e){let i=Lt([e,this.store.select(aH)]).pipe(L(([o,s])=>function(n,t){let e=t.key,i=[...n];return null===e||t.direction===ic.UNSET||i.sort((r,o)=>{let s=fhe(r,e),a=fhe(o,e);if(s.length!==a.length)throw new Error(`Invariant error: a given sort should result in same number of items: ${t}`);for(let l=0;l<s.length;l++){let c=s[l],u=a[l];if(c!==u){if(void 0===c||void 0===u)return void 0===u?-1:1;if(typeof c!=typeof u)throw new Error(`Cannot compare values of different types: ${typeof c} vs. ${typeof u}`);return c<u==(t.direction===ic.ASC)?-1:1}}return 0}),i}(o,s)));return Lt([i,this.store.select(sH)]).pipe(L(([o,s])=>{if(!this.usePagination)return o.slice();let{pageSize:a,pageIndex:l}=s;return o.slice(l*a,(l+1)*a)}),zn([]))}getRunTableItemsForExperiment(e){return Lt([this.store.select(rd,{experimentId:e}),this.store.select(vI,{experimentId:e}),this.store.select(oo),this.store.select(nc),this.store.select(Yu)]).pipe(L(([i,r,o,s,a])=>i.map(l=>{let c=new Map;(l.hparams||[]).forEach(d=>{c.set(d.name,d.value)});let u=new Map;return(l.metrics||[]).forEach(d=>{u.set(d.tag,d.value)}),{run:l,experimentName:r?.name||"",experimentAlias:a[e],selected:Boolean(o&&o.get(l.id)),runColor:s[l.id],hparams:c,metrics:u}})))}onRunSelectionToggle(e){this.store.dispatch(oI({runId:e.run.id}))}onRunSelectionDblClick(e){this.store.dispatch(sI({runId:e.run.id}))}onPageSelectionToggle(e){let{items:i}=e,r=i.map(({run:o})=>o.id);this.store.dispatch(aI({runIds:r}))}onPaginationChange(e){if(!this.usePagination)throw new Error("Pagination events cannot be dispatched when pagination is disabled");let{pageIndex:i,pageSize:r}=e;this.store.dispatch(lI({pageIndex:i,pageSize:r}))}onSortChange(e){this.store.dispatch(cI(e))}onRegexFilterChange(e){this.store.dispatch(NM({regexString:e}))}onRunColorChange({runId:e,newColor:i}){this.store.dispatch(uI({runId:e,newColor:i}))}onHparamDiscreteFilterChanged(e){let{hparamName:i,filterValues:r,includeUndefined:o}=e;this.store.dispatch(Gm.hparamsDiscreteHparamFilterChanged({experimentIds:this.experimentIds,hparamName:i,filterValues:r,includeUndefined:o}))}onHparamIntervalFilterChanged(e){let{name:i,filterLowerValue:r,filterUpperValue:o,includeUndefined:s}=e;this.store.dispatch(Gm.hparamsIntervalHparamFilterChanged({experimentIds:this.experimentIds,hparamName:i,filterLowerValue:r,filterUpperValue:o,includeUndefined:s}))}onMetricFilterChanged(e){let{name:i,includeUndefined:r,filterLowerValue:o,filterUpperValue:s}=e;this.store.dispatch(Gm.hparamsMetricFilterChanged({experimentIds:this.experimentIds,metricTag:i,includeUndefined:r,filterLowerValue:o,filterUpperValue:s}))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["runs-table"]],hostVars:2,hostBindings:function(e,i){2&e&&et("flex-layout",i.useFlexibleLayout)},inputs:{useFlexibleLayout:"useFlexibleLayout",usePagination:"usePagination",columns:"columns",experimentIds:"experimentIds",showHparamsAndMetrics:"showHparamsAndMetrics"},decls:11,vars:35,consts:[[3,"experimentIds","useFlexibleLayout","numSelectedItems","columns","hparamColumns","metricColumns","showExperimentName","pageItems","filteredItemsLength","allItemsLength","loading","paginationOption","regexFilter","sortOption","usePagination","onSelectionToggle","onSelectionDblClick","onPageSelectionToggle","onPaginationChange","onRegexFilterChange","onSortChange","onRunColorChange","onHparamIntervalFilterChanged","onHparamDiscreteFilterChanged","onMetricFilterChanged"]],template:function(e,i){1&e&&(_(0,"runs-table-component",0),P("onSelectionToggle",function(o){return i.onRunSelectionToggle(o)})("onSelectionDblClick",function(o){return i.onRunSelectionDblClick(o)})("onPageSelectionToggle",function(o){return i.onPageSelectionToggle(o)})("onPaginationChange",function(o){return i.onPaginationChange(o)})("onRegexFilterChange",function(o){return i.onRegexFilterChange(o)})("onSortChange",function(o){return i.onSortChange(o)})("onRunColorChange",function(o){return i.onRunColorChange(o)})("onHparamIntervalFilterChanged",function(o){return i.onHparamIntervalFilterChanged(o)})("onHparamDiscreteFilterChanged",function(o){return i.onHparamDiscreteFilterChanged(o)})("onMetricFilterChanged",function(o){return i.onMetricFilterChanged(o)}),B(1,"async"),B(2,"async"),B(3,"async"),B(4,"async"),B(5,"async"),B(6,"async"),B(7,"async"),B(8,"async"),B(9,"async"),B(10,"async"),v()),2&e&&y("experimentIds",i.experimentIds)("useFlexibleLayout",i.useFlexibleLayout)("numSelectedItems",U(1,15,i.numSelectedItems$))("columns",i.columns)("hparamColumns",U(2,17,i.hparamColumns$))("metricColumns",U(3,19,i.metricColumns$))("showExperimentName",i.isExperimentNameVisible())("pageItems",U(4,21,i.pageItems$))("filteredItemsLength",U(5,23,i.filteredItemsLength$))("allItemsLength",U(6,25,i.allItemsLength$))("loading",U(7,27,i.loading$))("paginationOption",U(8,29,i.paginationOption$))("regexFilter",U(9,31,i.regexFilter$))("sortOption",U(10,33,i.sortOption$))("usePagination",i.usePagination)},dependencies:[hhe,Ge],styles:[".flex-layout[_nghost-%COMP%] {\n        display: flex;\n      }\n\n      .flex-layout[_nghost-%COMP%]    > runs-table-component[_ngcontent-%COMP%] {\n        width: 100%;\n      }"],changeDetection:0}),n})(),_he=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["runs-selector-component"]],inputs:{experimentIds:"experimentIds",showHparamsAndMetrics:"showHparamsAndMetrics",columns:"columns"},decls:1,vars:4,consts:[[3,"useFlexibleLayout","columns","experimentIds","showHparamsAndMetrics"]],template:function(e,i){1&e&&O(0,"runs-table",0),2&e&&y("useFlexibleLayout",!0)("columns",i.columns)("experimentIds",i.experimentIds)("showHparamsAndMetrics",i.showHparamsAndMetrics)},dependencies:[ghe],styles:["runs-table[_ngcontent-%COMP%] {\n        height: 100%;\n      }"],changeDetection:0}),n})(),Ob=(()=>{class n{constructor(e){this.store=e,this.experimentIds$=this.store.select(Wo).pipe(L(i=>i??[])),this.columns$=this.store.select(Wo).pipe(L(i=>[va.CHECKBOX,va.RUN_NAME,i&&i.length>1?va.EXPERIMENT_NAME:null,va.RUN_COLOR].filter(r=>null!==r)))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["runs-selector"]],inputs:{showHparamsAndMetrics:"showHparamsAndMetrics"},decls:3,vars:7,consts:[[3,"experimentIds","columns","showHparamsAndMetrics"]],template:function(e,i){1&e&&(O(0,"runs-selector-component",0),B(1,"async"),B(2,"async")),2&e&&y("experimentIds",U(1,3,i.experimentIds$))("columns",U(2,5,i.columns$))("showHparamsAndMetrics",i.showHparamsAndMetrics)},dependencies:[_he,Ge],encapsulation:2,changeDetection:0}),n})(),vhe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["metrics-dashboard"]],decls:3,vars:0,consts:[["sidebar",""],["main",""]],template:function(e,i){1&e&&(_(0,"tb-dashboard-layout"),O(1,"runs-selector",0)(2,"metrics-main-view",1),v())},dependencies:[Roe,zpe,Ob],styles:["[_nghost-%COMP%]{contain:strict;display:flex;flex-direction:column;height:100%;justify-content:stretch;overflow:hidden}.notice[_ngcontent-%COMP%]{background-color:rgba(255,245,157,.85);border-bottom:1px solid #ffeb3b;color:#212121;display:block;flex:0 0}tb-dashboard-layout[_ngcontent-%COMP%]{flex:1 1;overflow:hidden}nav[_ngcontent-%COMP%]{background-color:#fff;border-right:1px solid #ebebeb;flex:none;width:340px}body.dark-mode[_nghost-%COMP%]   nav[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   nav[_ngcontent-%COMP%]{background-color:#303030;border-right-color:#555}metrics-main-view[_ngcontent-%COMP%]{flex:1 1}"],changeDetection:0}),n})(),XG=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,pn,Pn]}),n})(),yhe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me]}),n})(),bhe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),kb=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,bhe]}),n})(),tF=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,Ib,pn]}),n})(),nF=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,Wh]}),n})(),xhe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[ohe,Me,kb,tF,ag,Pn,Ls,Oh,Ha,pn,zh,Xpe,_d,Zpe,nhe,nF,E2]}),n})(),Fb=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,xhe]}),n})(),Nb=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),iF=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,pn]}),n})(),Che=(()=>{class n{constructor(){this.onTimeSelectionChanged=new G,this.onTimeSelectionToggled=new G,this.axisDirection=pa.VERTICAL,this.cardFobHelper={getStepHigherThanAxisPosition:this.getStepHigherThanAxisPosition.bind(this),getStepLowerThanAxisPosition:this.getStepLowerThanAxisPosition.bind(this)}}getAxisPositionFromStartStep(){return this.temporalScale(this.timeSelection.start.step)}getAxisPositionFromEndStep(){return null===this.timeSelection.end?null:this.temporalScale(this.timeSelection.end.step)}getHighestStep(){return this.steps[this.steps.length-1]}getLowestStep(){return this.steps[0]}getStepHigherThanAxisPosition(e){let i=0;for(;e>this.temporalScale(this.steps[i])&&i<this.steps.length-1;)i++;return this.steps[i]}getStepLowerThanAxisPosition(e){let i=this.steps.length-1;for(;e<this.temporalScale(this.steps[i])&&i>0;)i--;return this.steps[i]}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["histogram-card-fob-controller"]],inputs:{steps:"steps",timeSelection:"timeSelection",temporalScale:"temporalScale"},outputs:{onTimeSelectionChanged:"onTimeSelectionChanged",onTimeSelectionToggled:"onTimeSelectionToggled"},decls:1,vars:7,consts:[[3,"axisDirection","timeSelection","startStepAxisPosition","endStepAxisPosition","highestStep","lowestStep","cardFobHelper","onTimeSelectionChanged","onTimeSelectionToggled"]],template:function(e,i){1&e&&(_(0,"card-fob-controller",0),P("onTimeSelectionChanged",function(o){return i.onTimeSelectionChanged.emit(o)})("onTimeSelectionToggled",function(){return i.onTimeSelectionToggled.emit()}),v()),2&e&&y("axisDirection",i.axisDirection)("timeSelection",i.timeSelection)("startStepAxisPosition",i.getAxisPositionFromStartStep())("endStepAxisPosition",i.getAxisPositionFromEndStep())("highestStep",i.getHighestStep())("lowestStep",i.getLowestStep())("cardFobHelper",i.cardFobHelper)},dependencies:[Gk],encapsulation:2,changeDetection:0}),n})(),Mhe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[iF,Me,qh,Nb]}),n})();Nx(Wk,[dn,Be,hg,ay,Che],[]);var Lb=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me]}),n})(),rF=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,kb]}),n})(),Bb=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,pn]}),n})(),whe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,Mhe,Pn,pn,_d,rF,Lb,Bb]}),n})(),She=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,Pn,pn,_d,Wh,rF,Lb,Bb]}),n})(),oF=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,pn]}),n})(),Ehe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,pn,oF]}),n})(),The=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,ss,Pn,pn,Ha,zh]}),n})(),Dhe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,ss,The,qh]}),n})(),Ahe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,jr,Pn,Oh,Ha,lc,SI]}),n})(),Ihe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[iF,Me,Ahe,Ehe,kb,Nb,Dhe,Pn,pn,zh,_d,qh,Lb,Bb]}),n})(),Phe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,She,Ihe,whe,Nb]}),n})(),Rhe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,lc]}),n})(),sF=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,Rhe,Pn,gR,Ls,pn,lc,Wh,cv,nF]}),n})(),Ohe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,oF,Ls,J2]}),n})(),khe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Phe,Me,tF,Ib,Pn,gR,pn,Ha,_d,sF,Ohe,Zc]}),n})(),Fhe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,yhe,XG,khe,pn,sF,Fb]}),n})();function EJe(){return[{actionCreator:ry,alertFromAction:n=>{let{wasPinned:t,canCreateNewPins:e}=n;return t||e?null:{localizedMessage:"Max pin limit exceeded. Remove existing pins before adding more. See https://github.com/tensorflow/tensorboard/issues/4242"}}}]}function TJe(){return J(op,n=>({scalarSmoothing:n}))}function DJe(){return J(hv,n=>({ignoreOutliers:n}))}function AJe(){return J(pv,n=>({tooltipSort:String(n)}))}function IJe(){return J(HI,n=>({timeSeriesSettingsPaneOpened:n}))}function PJe(){return J(dv,n=>({timeSeriesCardMinWidth:n}))}function RJe(){return J(fv,n=>({stepSelectorEnabled:n}))}function OJe(){return J(mv,n=>({rangeSelectionEnabled:n}))}function kJe(){return J(Ym,n=>({linkedTimeEnabled:n}))}var Nhe=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[{provide:MU,useFactory:Aoe,deps:[wU]},{provide:wU,useValue:II}],imports:[Me,J_,ec,Bs.forPlugin(BM,vhe),SI,Fhe,wr.forFeature(AI,Eoe,MU),ro.forFeature([Doe]),Ju.registerAlertActions(EJe),Sr.defineGlobalSetting(TJe),Sr.defineGlobalSetting(DJe),Sr.defineGlobalSetting(AJe),Sr.defineGlobalSetting(IJe),Sr.defineGlobalSetting(PJe),Sr.defineGlobalSetting(RJe),Sr.defineGlobalSetting(OJe),Sr.defineGlobalSetting(kJe)]}),n})();function Lhe(n){return n.startsWith("count@")}function aF(n){return n.startsWith("nPMI@")||n.startsWith("nPMI_diff@")}function Vb(n){return n.startsWith("nPMI@")}function Ss(n){return n.split("@",2)[1]}function q$e(n){let e,i,t=n.length;for(;t;)i=Math.floor(Math.random()*t--),e=n[t],n[t]=n[i],n[i]=e;return n}function Y$e(n){return[...new Array(n)].map((t,e)=>e)}function vF(n,t){return`${t}/${n}`}oN($fe(),1);var yF=(()=>{class n{constructor(e){this.http=e,this.httpPathPrefix="data/plugin/npmi"}fetchData(e){return lr(this.fetchAnnotations(e),this.fetchMetrics(e),this.fetchValues(e),this.fetchEmbeddings(e)).pipe(L(([i,r,o,s])=>{let c,a={},l={},u=0;for(let d of Object.keys(i))for(let p in i[d]){let h=i[d][p];Object.keys(s).length&&!l[h]&&s[d][p]&&s[d][p].some(x=>0!==x)&&(l[h]={vector:s[d][p],index:u,name:h},u+=1);let f=new Map;for(let x in r[d]){let g=r[d][x],b=Ss(g),D=f.get(b);D||(D={nPMIValue:null,countValue:null,annotation:h,metric:b,run:d},f.set(b,D)),Lhe(g)?D.countValue=o[d][p][x]:aF(g)&&(D.nPMIValue=o[d][p][x])}a[h]=[...a[h]?a[h]:[],...f.values()]}return Object.keys(l).length&&(c=function(n){let t=Object.keys(n);return{points:n,pointKeys:t,shuffledDataIndices:q$e(Y$e(t.length)),hasUmapRun:!1}}(l)),{annotationData:a,metrics:r,embeddingDataSet:c}}),fo(i=>i instanceof np&&400<=i.status&&i.status<500?Xt({annotationData:{},metrics:{},embeddingDataSet:void 0}):wc(i)))}fetchAnnotations(e){let i=e.map(r=>this.http.get(`/experiment/${r}/${this.httpPathPrefix}/annotations`).pipe(L(s=>function(n,t){return Object.fromEntries(Object.entries(n).map(([e,i])=>[vF(e,t),i]))}(s,r))));return lr(i).pipe(L(r=>{let o={};for(let s of r)o={...o,...s};return o}))}fetchMetrics(e){let i=e.map(r=>this.http.get(`/experiment/${r}/${this.httpPathPrefix}/metrics`).pipe(L(s=>function(n,t){return Object.fromEntries(Object.entries(n).map(([e,i])=>[vF(e,t),i]))}(s,r))));return lr(i).pipe(L(r=>{let o={};for(let s of r)o={...o,...s};return o}))}fetchValues(e){let i=e.map(r=>this.http.get(`/experiment/${r}/${this.httpPathPrefix}/values`).pipe(L(s=>function(n,t){return Object.fromEntries(Object.entries(n).map(([e,i])=>[vF(e,t),i]))}(s,r))));return lr(i).pipe(L(r=>{let o={};for(let s of r)o={...o,...s};return o}))}fetchEmbeddings(e){let i=e.map(r=>this.http.get(`/experiment/${r}/${this.httpPathPrefix}/embeddings`).pipe(L(s=>function(n,t){return Object.fromEntries(Object.entries(n).map(([e,i])=>[vF(e,t),i]))}(s,r))));return lr(i).pipe(L(r=>{let o={};for(let s of r)o={...o,...s};return o}))}}return n.\u0275fac=function(e){return new(e||n)(j(ka))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),tme=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[yF],imports:[Ku]}),n})(),bF=be("[NPMI] nPMI Loaded"),xF=be("[NPMI] nPMI Plugin Data Requested"),CF=be("[NPMI] nPMI Plugin Data Loaded",{_as:"props",_p:void 0}),MF=be("[NPMI] nPMI Plugin Data Request Failed"),wF=be("[NPMI] Adding/Removing Annotations to/from Selected",{_as:"props",_p:void 0}),RE=be("[NPMI] Annotations Set",{_as:"props",_p:void 0}),SF=be("[NPMI] Clearing the Annotation Selection"),EF=be("[NPMI] Adding/Removing Annotations to/from Flagged",{_as:"props",_p:void 0}),TF=be("[NPMI] Adding/Removing Annotations to/from Hidden",{_as:"props",_p:void 0}),jb=be("[NPMI] Annotations Regex Changed",{_as:"props",_p:void 0}),OE=be("[NPMI] Metrics Regex Changed",{_as:"props",_p:void 0}),DF=be("[NPMI] Metric Filter Added",{_as:"props",_p:void 0}),Gb=be("[NPMI] Metric Filter Removed",{_as:"props",_p:void 0}),Wb=be("[NPMI] Metric Filter Changed",{_as:"props",_p:void 0}),AF=be("[NPMI] Annotation Sort Changed",{_as:"props",_p:void 0}),IF=be("[NPMI] Similarity Sort Changed",{_as:"props",_p:void 0}),PF=be("[NPMI] Toggle PC Expanded"),RF=be("[NPMI] Toggle Annotations Expanded"),qb=be("[NPMI] Toggle Sidebar Expanded"),OF=be("[NPMI] Show Counts Toggled"),kF=be("[NPMI] Show Hidden Annotations Toggled"),FF=be("[NPMI] Embeddings View Toggled",{_as:"props",_p:void 0}),NF=be("[NPMI] Sidebar Width Changed",{_as:"props",_p:void 0}),LF=be("[NPMI] Embeddings Sidebar Width Changed",{_as:"props",_p:void 0}),Yb=be("[NPMI] Embeddings Sidebar Expanded Toggled"),nme=be("[NPMI] Change Embedding DataSet",{_as:"props",_p:void 0}),s0=(()=>(function(n){n[n.AND=0]="AND"}(s0||(s0={})),s0))(),mu=(()=>(function(n){n[n.METRIC=0]="METRIC",n[n.OPERATOR=1]="OPERATOR"}(mu||(mu={})),mu))(),kp=(()=>(function(n){n[n.DEFAULT=0]="DEFAULT",n[n.EMBEDDINGS=1]="EMBEDDINGS"}(kp||(kp={})),kp))(),$r=(()=>(function(n){n[n.DESCENDING=0]="DESCENDING",n[n.ASCENDNG=1]="ASCENDNG",n[n.SIMILAR=2]="SIMILAR",n[n.DISSIMILAR=3]="DISSIMILAR"}($r||($r={})),$r))(),uo=Mr("npmi"),ime=J(uo,n=>n.pluginDataLoaded.state),Pf=J(uo,n=>n.annotationData),Rf=J(uo,n=>n.runToMetrics),BF=J(uo,n=>n.embeddingDataSet),vc=J(uo,n=>n.selectedAnnotations),VF=J(uo,n=>n.flaggedAnnotations),Xb=J(uo,n=>n.hiddenAnnotations),Qb=J(uo,n=>n.annotationsRegex),rme=J(uo,n=>n.metricsRegex),HF=J(uo,n=>n.metricArithmetic),Il=J(uo,n=>n.metricFilters),Kb=J(uo,n=>n.sort),ome=J(uo,n=>n.pcExpanded),UF=J(uo,n=>n.annotationsExpanded),zF=J(uo,n=>n.sidebarExpanded),jF=J(uo,n=>n.showCounts),Zb=J(uo,n=>n.showHiddenAnnotations),sme=J(uo,n=>n.viewActive),Of=J(uo,n=>n.sidebarWidth),ame=J(uo,n=>n.embeddingsMetric),lme=J(uo,n=>n.embeddingsSidebarWidth),GF=J(uo,n=>n.embeddingsSidebarExpanded),cme=(()=>{class n{constructor(e,i,r){this.actions$=e,this.store=i,this.dataSource=r,this.loadData$=cr(()=>Jt(this.loadPluginData()).pipe(L(()=>({}))),{dispatch:!1})}loadPluginData(){return this.actions$.pipe(ii(bF),Wt(this.store.select(ime),this.store.select(Wo)),Ye(([,e,i])=>e!==Oe.LOADING&&null!==i),kt(()=>this.store.dispatch(xF())),xn(([,,e])=>this.dataSource.fetchData(e).pipe(kt(i=>{this.store.dispatch(CF(i))}),L(()=>{}),fo(()=>(this.store.dispatch(MF()),eo)))))}}return n.\u0275fac=function(e){return new(e||n)(j(Po),j(Ce),j(yF))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),ume=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["npmi-inactive-view"]],decls:6,vars:0,consts:[[1,"container"],[1,"title"]],template:function(e,i){1&e&&(_(0,"div")(1,"div",0)(2,"div",1),A(3,"nPMI is inactive because no data is available."),v(),_(4,"div"),A(5," To use the nPMI, calculate nPMI values, and log them using the summary writer. "),v()()())},styles:[".container[_ngcontent-%COMP%] {\n  height: 100%;\n  font-family: Roboto;\n  font-size: 15px;\n  padding: 50px;\n}\n\n.title[_ngcontent-%COMP%] {\n  font-size: 135%;\n  font-weight: bold;\n  margin-bottom: 25px;\n}"]}),n})(),tet=vr({pluginDataLoaded:{state:Oe.NOT_LOADED,lastLoadedTimeInMs:null},annotationData:{},embeddingDataSet:void 0,runToMetrics:{},selectedAnnotations:[],flaggedAnnotations:[],hiddenAnnotations:[],annotationsRegex:"",metricsRegex:"",metricArithmetic:[],metricFilters:{},sort:{metric:"",order:$r.DESCENDING},pcExpanded:!0,annotationsExpanded:!0,sidebarExpanded:!0,showCounts:!0,showHiddenAnnotations:!1,sidebarWidth:300,viewActive:kp.DEFAULT,embeddingsMetric:"",embeddingsSidebarWidth:500,embeddingsSidebarExpanded:!0},Se(xF,n=>({...n,pluginDataLoaded:{...n.pluginDataLoaded,state:Oe.LOADING}})),Se(MF,n=>({...n,pluginDataLoaded:{...n.pluginDataLoaded,state:Oe.FAILED}})),Se(CF,(n,{annotationData:t,metrics:e,embeddingDataSet:i})=>{let r={};for(let o in e){r[o]=[];for(let s of e[o])aF(s)&&r[o].push(s)}return{...n,runToMetrics:r,annotationData:t,embeddingDataSet:i,pluginDataLoaded:{state:Oe.LOADED,lastLoadedTimeInMs:Date.now()}}}),Se(wF,(n,{annotations:t})=>{let e=new Set([...n.selectedAnnotations,...t]);if(e.size===n.selectedAnnotations.length)for(let i of t)e.delete(i);return{...n,selectedAnnotations:[...e]}}),Se(RE,(n,{annotations:t})=>({...n,selectedAnnotations:t})),Se(SF,n=>({...n,selectedAnnotations:[]})),Se(EF,(n,{annotations:t})=>{let e=new Set([...n.flaggedAnnotations,...t]);if(e.size===n.flaggedAnnotations.length)for(let i of t)e.delete(i);return{...n,flaggedAnnotations:[...e],selectedAnnotations:[]}}),Se(TF,(n,{annotations:t})=>{let e=new Set([...n.hiddenAnnotations,...t]);if(e.size===n.hiddenAnnotations.length)for(let i of t)e.delete(i);return{...n,hiddenAnnotations:[...e],selectedAnnotations:[]}}),Se(jb,(n,{regex:t})=>({...n,annotationsRegex:t})),Se(OE,(n,{regex:t})=>({...n,metricsRegex:t})),Se(DF,(n,{metric:t})=>{if(n.metricFilters[t])return n;let e=[];return 0!==n.metricArithmetic.length&&e.push({kind:mu.OPERATOR,operator:s0.AND}),e.push({kind:mu.METRIC,metric:t}),{...n,metricArithmetic:[...n.metricArithmetic,...e],metricFilters:{...n.metricFilters,[t]:{max:1,min:-1,includeNaN:!1}},sort:{metric:t,order:$r.DESCENDING}}}),Se(Gb,(n,{metric:t})=>{if(!n.metricFilters[t])return n;let e=0,i=0,r=2,{[t]:o,...s}=n.metricFilters;for(let a in n.metricArithmetic){let l=n.metricArithmetic[a];l.kind===mu.METRIC&&l.metric===t&&(e=parseInt(a))}return 0!==e&&(i=e-1,r=e+1),{...n,metricArithmetic:[...n.metricArithmetic.slice(0,i),...n.metricArithmetic.slice(r)],metricFilters:s}}),Se(Wb,(n,{metric:t,max:e,min:i,includeNaN:r})=>n.metricFilters[t]?{...n,metricFilters:{...n.metricFilters,[t]:{max:e,min:i,includeNaN:r}}}:n),Se(AF,(n,{metric:t})=>{let e={metric:t,order:$r.DESCENDING};return n.sort.metric===t&&n.sort.order===$r.DESCENDING&&(e.order=$r.ASCENDNG),{...n,sort:e}}),Se(IF,(n,{annotation:t})=>{let e={metric:t,order:$r.SIMILAR};return n.sort.metric===t&&n.sort.order===$r.SIMILAR&&(e.order=$r.DISSIMILAR),{...n,sort:e}}),Se(PF,n=>({...n,pcExpanded:!n.pcExpanded})),Se(RF,n=>({...n,annotationsExpanded:!n.annotationsExpanded})),Se(qb,n=>({...n,sidebarExpanded:!n.sidebarExpanded})),Se(OF,n=>({...n,showCounts:!n.showCounts})),Se(kF,n=>({...n,showHiddenAnnotations:!n.showHiddenAnnotations})),Se(FF,(n,{metric:t})=>{let e=kp.EMBEDDINGS,i=t;return t===n.embeddingsMetric&&(e=kp.DEFAULT,i=""),{...n,viewActive:e,embeddingsMetric:i}}),Se(NF,(n,{sidebarWidth:t})=>({...n,sidebarWidth:t})),Se(LF,(n,{sidebarWidth:t})=>({...n,embeddingsSidebarWidth:t})),Se(Yb,n=>({...n,embeddingsSidebarExpanded:!n.embeddingsSidebarExpanded})),Se(nme,(n,{dataSet:t})=>({...n,embeddingDataSet:t})));function dme(n,t){return tet(n,t)}function net(n,t){1&n&&O(0,"mat-icon",7)}function iet(n,t){if(1&n&&(_(0,"mat-option",8),A(1),v()),2&n){let e=t.$implicit;y("value",e),C(1),yt(e)}}var pme=(()=>{class n{constructor(){this.onRegexFilterValueChange=new G,this.onAddFilter=new G}onOptionSelected(e,i){this.onAddFilter.emit(e.option.value),i.value=""}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["metric-search-component"]],hostVars:2,hostBindings:function(e,i){2&e&&et("valid",i.isRegexFilterValid)},inputs:{completions:"completions",regexFilterValue:"regexFilterValue",isRegexFilterValid:"isRegexFilterValid"},outputs:{onRegexFilterValueChange:"onRegexFilterValueChange",onAddFilter:"onAddFilter"},decls:7,vars:4,consts:[["svgIcon","search_24px"],["matInput","","autocomplete","off","placeholder","Add Metric Filter",3,"value","matAutocomplete","input"],["matInput",""],["svgIcon","error_24px","class","error-icon","matTooltip","Invalid regex filter. The result may be stale.",4,"ngIf"],["autoActiveFirstOption","",3,"optionSelected"],["filterMatches","matAutocomplete"],[3,"value",4,"ngFor","ngForOf"],["svgIcon","error_24px","matTooltip","Invalid regex filter. The result may be stale.",1,"error-icon"],[3,"value"]],template:function(e,i){if(1&e){let r=Pe();O(0,"mat-icon",0),_(1,"input",1,2),P("input",function(s){return i.onRegexFilterValueChange.emit(s.target.value)}),v(),E(3,net,1,0,"mat-icon",3),_(4,"mat-autocomplete",4,5),P("optionSelected",function(s){oe(r);let a=$e(2);return se(i.onOptionSelected(s,a))}),E(6,iet,2,2,"mat-option",6),v()}if(2&e){let r=$e(5);C(1),y("value",i.regexFilterValue)("matAutocomplete",r),C(2),y("ngIf",!i.isRegexFilterValid),C(3),y("ngForOf",i.completions)}},dependencies:[dn,Be,Gt,Uh,qk,$g,Os],styles:["mat-icon[_ngcontent-%COMP%]{flex:none;margin-right:5px}[_nghost-%COMP%]{display:flex;padding:0 10px;position:relative;font-size:.9em}[_nghost-%COMP%]:not(.valid){color:#c62828}[_nghost-%COMP%]:not(.valid)   input[_ngcontent-%COMP%]{caret-color:currentColor}"],changeDetection:0}),n})(),hme=(()=>{class n{constructor(e){this.store=e,this.metricsRegex$=this.store.select(rme),this.activeRuns$=this.store.pipe(vt(oo)).pipe(L(i=>i?Array.from(i.entries()).filter(r=>r[1]).map(r=>r[0]):[])),this.metricsForActiveRuns$=Lt(this.activeRuns$,this.store.select(Rf)).pipe(L(([i,r])=>{let o=new Set;for(let s of i)if(r[s])for(let a of r[s])o.add(a);return[...o]})),this.isMetricsFilterValid$=this.metricsRegex$.pipe(L(i=>{try{return Boolean(new RegExp(i))}catch{return!1}})),this.metricFilterKeys$=this.store.pipe(vt(Il)).pipe(L(i=>Object.keys(i))),this.completions$=Lt(this.metricsForActiveRuns$,this.metricsRegex$,this.metricFilterKeys$).pipe(L(([i,r,o])=>{let s=i.filter(a=>!o.includes(a));try{let a=new RegExp(r,"i");return s.filter(l=>a.test(l)).sort()}catch{return[]}}))}onFilterChange(e){this.store.dispatch(OE({regex:e}))}onAddFilter(e){this.store.dispatch(DF({metric:e})),this.store.dispatch(OE({regex:""}))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["npmi-metric-search"]],decls:4,vars:9,consts:[[3,"regexFilterValue","completions","isRegexFilterValid","onRegexFilterValueChange","onAddFilter"]],template:function(e,i){1&e&&(_(0,"metric-search-component",0),P("onRegexFilterValueChange",function(o){return i.onFilterChange(o)})("onAddFilter",function(o){return i.onAddFilter(o)}),B(1,"async"),B(2,"async"),B(3,"async"),v()),2&e&&y("regexFilterValue",U(1,3,i.metricsRegex$))("completions",U(2,5,i.completions$))("isRegexFilterValid",U(3,7,i.isMetricsFilterValid$))},dependencies:[pme,Ge],encapsulation:2,changeDetection:0}),n})(),set=["*"],fme=new pe("MatChipRemove"),aet=new pe("MatChipAvatar"),cet=new pe("MatChipTrailingIcon"),uet=oc(ko(qo(class{constructor(t){this._elementRef=t}}),"primary"),-1),Jb=(()=>{class n extends uet{constructor(e,i,r,o,s,a,l,c){super(e),this._ngZone=i,this._changeDetectorRef=s,this._hasFocus=!1,this.chipListSelectable=!0,this._chipListMultiple=!1,this._chipListDisabled=!1,this.role="option",this._selected=!1,this._selectable=!0,this._disabled=!1,this._removable=!0,this._onFocus=new ke,this._onBlur=new ke,this.selectionChange=new G,this.destroyed=new G,this.removed=new G,this._addHostClassName(),this._chipRippleTarget=a.createElement("div"),this._chipRippleTarget.classList.add("mat-chip-ripple"),this._elementRef.nativeElement.appendChild(this._chipRippleTarget),this._chipRipple=new Tv(this,i,this._chipRippleTarget,r),this._chipRipple.setupTriggerEvents(e),this.rippleConfig=o||{},this._animationsDisabled="NoopAnimations"===l,this.tabIndex=null!=c&&parseInt(c)||-1}get rippleDisabled(){return this.disabled||this.disableRipple||this._animationsDisabled||!!this.rippleConfig.disabled}get selected(){return this._selected}set selected(e){let i=Rt(e);i!==this._selected&&(this._selected=i,this._dispatchSelectionChange())}get value(){return void 0!==this._value?this._value:this._elementRef.nativeElement.textContent}set value(e){this._value=e}get selectable(){return this._selectable&&this.chipListSelectable}set selectable(e){this._selectable=Rt(e)}get disabled(){return this._chipListDisabled||this._disabled}set disabled(e){this._disabled=Rt(e)}get removable(){return this._removable}set removable(e){this._removable=Rt(e)}get ariaSelected(){return this.selectable&&(this._chipListMultiple||this.selected)?this.selected.toString():null}_addHostClassName(){let e="mat-basic-chip",i=this._elementRef.nativeElement;i.hasAttribute(e)||i.tagName.toLowerCase()===e?i.classList.add(e):i.classList.add("mat-standard-chip")}ngOnDestroy(){this.destroyed.emit({chip:this}),this._chipRipple._removeTriggerEvents()}select(){this._selected||(this._selected=!0,this._dispatchSelectionChange(),this._changeDetectorRef.markForCheck())}deselect(){this._selected&&(this._selected=!1,this._dispatchSelectionChange(),this._changeDetectorRef.markForCheck())}selectViaInteraction(){this._selected||(this._selected=!0,this._dispatchSelectionChange(!0),this._changeDetectorRef.markForCheck())}toggleSelected(e=!1){return this._selected=!this.selected,this._dispatchSelectionChange(e),this._changeDetectorRef.markForCheck(),this.selected}focus(){this._hasFocus||(this._elementRef.nativeElement.focus(),this._onFocus.next({chip:this})),this._hasFocus=!0}remove(){this.removable&&this.removed.emit({chip:this})}_handleClick(e){this.disabled&&e.preventDefault()}_handleKeydown(e){if(!this.disabled)switch(e.keyCode){case 46:case 8:this.remove(),e.preventDefault();break;case 32:this.selectable&&this.toggleSelected(!0),e.preventDefault()}}_blur(){this._ngZone.onStable.pipe(Qt(1)).subscribe(()=>{this._ngZone.run(()=>{this._hasFocus=!1,this._onBlur.next({chip:this})})})}_dispatchSelectionChange(e=!1){this.selectionChange.emit({source:this,isUserInput:e,selected:this._selected})}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(_t),M(oi),M(g2,8),M(nn),M(Ht),M(Pi,8),vo("tabindex"))},n.\u0275dir=He({type:n,selectors:[["mat-basic-chip"],["","mat-basic-chip",""],["mat-chip"],["","mat-chip",""]],contentQueries:function(e,i,r){if(1&e&&(Ei(r,aet,5),Ei(r,cet,5),Ei(r,fme,5)),2&e){let o;Ne(o=Le())&&(i.avatar=o.first),Ne(o=Le())&&(i.trailingIcon=o.first),Ne(o=Le())&&(i.removeIcon=o.first)}},hostAttrs:[1,"mat-chip","mat-focus-indicator"],hostVars:15,hostBindings:function(e,i){1&e&&P("click",function(o){return i._handleClick(o)})("keydown",function(o){return i._handleKeydown(o)})("focus",function(){return i.focus()})("blur",function(){return i._blur()}),2&e&&(ze("tabindex",i.disabled?null:i.tabIndex)("role",i.role)("disabled",i.disabled||null)("aria-disabled",i.disabled.toString())("aria-selected",i.ariaSelected),et("mat-chip-selected",i.selected)("mat-chip-with-avatar",i.avatar)("mat-chip-with-trailing-icon",i.trailingIcon||i.removeIcon)("mat-chip-disabled",i.disabled)("_mat-animation-noopable",i._animationsDisabled))},inputs:{color:"color",disableRipple:"disableRipple",tabIndex:"tabIndex",role:"role",selected:"selected",value:"value",selectable:"selectable",disabled:"disabled",removable:"removable"},outputs:{selectionChange:"selectionChange",destroyed:"destroyed",removed:"removed"},exportAs:["matChip"],features:[tt]}),n})(),mme=(()=>{class n{constructor(e,i){this._parentChip=e,"BUTTON"===i.nativeElement.nodeName&&i.nativeElement.setAttribute("type","button")}_handleClick(e){let i=this._parentChip;i.removable&&!i.disabled&&i.remove(),e.stopPropagation(),e.preventDefault()}}return n.\u0275fac=function(e){return new(e||n)(M(Jb),M(Re))},n.\u0275dir=He({type:n,selectors:[["","matChipRemove",""]],hostAttrs:[1,"mat-chip-remove","mat-chip-trailing-icon"],hostBindings:function(e,i){1&e&&P("click",function(o){return i._handleClick(o)})},features:[$t([{provide:fme,useExisting:n}])]}),n})(),det=new pe("mat-chips-default-options"),pet=Dv(class{constructor(n,t,e,i){this._defaultErrorStateMatcher=n,this._parentForm=t,this._parentFormGroup=e,this.ngControl=i,this.stateChanges=new ke}}),het=0,gme=(()=>{class n extends pet{constructor(e,i,r,o,s,a,l){super(a,o,s,l),this._elementRef=e,this._changeDetectorRef=i,this._dir=r,this.controlType="mat-chip-list",this._lastDestroyedChipIndex=null,this._destroyed=new ke,this._uid="mat-chip-list-"+het++,this._tabIndex=0,this._userTabIndex=null,this._onTouched=()=>{},this._onChange=()=>{},this._multiple=!1,this._compareWith=(c,u)=>c===u,this._disabled=!1,this.ariaOrientation="horizontal",this._selectable=!0,this.change=new G,this.valueChange=new G,this.ngControl&&(this.ngControl.valueAccessor=this)}get selected(){return this.multiple?this._selectionModel?.selected||[]:this._selectionModel?.selected[0]}get role(){return this._explicitRole?this._explicitRole:this.empty?null:"listbox"}set role(e){this._explicitRole=e}get multiple(){return this._multiple}set multiple(e){this._multiple=Rt(e),this._syncChipsState()}get compareWith(){return this._compareWith}set compareWith(e){this._compareWith=e,this._selectionModel&&this._initializeSelection()}get value(){return this._value}set value(e){this.writeValue(e),this._value=e}get id(){return this._chipInput?this._chipInput.id:this._uid}get required(){return this._required??this.ngControl?.control?.hasValidator(Fo.required)??!1}set required(e){this._required=Rt(e),this.stateChanges.next()}get placeholder(){return this._chipInput?this._chipInput.placeholder:this._placeholder}set placeholder(e){this._placeholder=e,this.stateChanges.next()}get focused(){return this._chipInput&&this._chipInput.focused||this._hasFocusedChip()}get empty(){return(!this._chipInput||this._chipInput.empty)&&(!this.chips||0===this.chips.length)}get shouldLabelFloat(){return!this.empty||this.focused}get disabled(){return this.ngControl?!!this.ngControl.disabled:this._disabled}set disabled(e){this._disabled=Rt(e),this._syncChipsState()}get selectable(){return this._selectable}set selectable(e){this._selectable=Rt(e),this._syncChipsState()}set tabIndex(e){this._userTabIndex=e,this._tabIndex=e}get chipSelectionChanges(){return Jt(...this.chips.map(e=>e.selectionChange))}get chipFocusChanges(){return Jt(...this.chips.map(e=>e._onFocus))}get chipBlurChanges(){return Jt(...this.chips.map(e=>e._onBlur))}get chipRemoveChanges(){return Jt(...this.chips.map(e=>e.destroyed))}ngAfterContentInit(){this._keyManager=new Sh(this.chips).withWrap().withVerticalOrientation().withHomeAndEnd().withHorizontalOrientation(this._dir?this._dir.value:"ltr"),this._dir&&this._dir.change.pipe(st(this._destroyed)).subscribe(e=>this._keyManager.withHorizontalOrientation(e)),this._keyManager.tabOut.pipe(st(this._destroyed)).subscribe(()=>{this._allowFocusEscape()}),this.chips.changes.pipe(zn(null),st(this._destroyed)).subscribe(()=>{(this.disabled||!this.selectable)&&Promise.resolve().then(()=>{this._syncChipsState()}),this._resetChips(),this._initializeSelection(),this._updateTabIndex(),this._updateFocusForDestroyedChips(),this.stateChanges.next()})}ngOnInit(){this._selectionModel=new Ah(this.multiple,void 0,!1),this.stateChanges.next()}ngDoCheck(){this.ngControl&&(this.updateErrorState(),this.ngControl.disabled!==this._disabled&&(this.disabled=!!this.ngControl.disabled))}ngOnDestroy(){this._destroyed.next(),this._destroyed.complete(),this.stateChanges.complete(),this._dropSubscriptions()}registerInput(e){this._chipInput=e,this._elementRef.nativeElement.setAttribute("data-mat-chip-input",e.id)}setDescribedByIds(e){e.length?this._elementRef.nativeElement.setAttribute("aria-describedby",e.join(" ")):this._elementRef.nativeElement.removeAttribute("aria-describedby")}writeValue(e){this.chips&&this._setSelectionByValue(e,!1)}registerOnChange(e){this._onChange=e}registerOnTouched(e){this._onTouched=e}setDisabledState(e){this.disabled=e,this.stateChanges.next()}onContainerClick(e){this._originatesFromChip(e)||this.focus()}focus(e){this.disabled||this._chipInput&&this._chipInput.focused||(this.chips.length>0?(this._keyManager.setFirstItemActive(),this.stateChanges.next()):(this._focusInput(e),this.stateChanges.next()))}_focusInput(e){this._chipInput&&this._chipInput.focus(e)}_keydown(e){let i=e.target;i&&i.classList.contains("mat-chip")&&(this._keyManager.onKeydown(e),this.stateChanges.next())}_updateTabIndex(){this._tabIndex=this._userTabIndex||(0===this.chips.length?-1:0)}_updateFocusForDestroyedChips(){if(null!=this._lastDestroyedChipIndex)if(this.chips.length){let e=Math.min(this._lastDestroyedChipIndex,this.chips.length-1);this._keyManager.setActiveItem(e)}else this.focus();this._lastDestroyedChipIndex=null}_isValidIndex(e){return e>=0&&e<this.chips.length}_setSelectionByValue(e,i=!0){if(this._clearSelection(),this.chips.forEach(r=>r.deselect()),Array.isArray(e))e.forEach(r=>this._selectValue(r,i)),this._sortValues();else{let r=this._selectValue(e,i);r&&i&&this._keyManager.setActiveItem(r)}}_selectValue(e,i=!0){let r=this.chips.find(o=>null!=o.value&&this._compareWith(o.value,e));return r&&(i?r.selectViaInteraction():r.select(),this._selectionModel.select(r)),r}_initializeSelection(){Promise.resolve().then(()=>{(this.ngControl||this._value)&&(this._setSelectionByValue(this.ngControl?this.ngControl.value:this._value,!1),this.stateChanges.next())})}_clearSelection(e){this._selectionModel.clear(),this.chips.forEach(i=>{i!==e&&i.deselect()}),this.stateChanges.next()}_sortValues(){this._multiple&&(this._selectionModel.clear(),this.chips.forEach(e=>{e.selected&&this._selectionModel.select(e)}),this.stateChanges.next())}_propagateChanges(e){let i=null;i=Array.isArray(this.selected)?this.selected.map(r=>r.value):this.selected?this.selected.value:e,this._value=i,this.change.emit(new class{constructor(t,e){this.source=t,this.value=e}}(this,i)),this.valueChange.emit(i),this._onChange(i),this._changeDetectorRef.markForCheck()}_blur(){this._hasFocusedChip()||this._keyManager.setActiveItem(-1),this.disabled||(this._chipInput?setTimeout(()=>{this.focused||this._markAsTouched()}):this._markAsTouched())}_markAsTouched(){this._onTouched(),this._changeDetectorRef.markForCheck(),this.stateChanges.next()}_allowFocusEscape(){-1!==this._tabIndex&&(this._tabIndex=-1,setTimeout(()=>{this._tabIndex=this._userTabIndex||0,this._changeDetectorRef.markForCheck()}))}_resetChips(){this._dropSubscriptions(),this._listenToChipsFocus(),this._listenToChipsSelection(),this._listenToChipsRemoved()}_dropSubscriptions(){this._chipFocusSubscription&&(this._chipFocusSubscription.unsubscribe(),this._chipFocusSubscription=null),this._chipBlurSubscription&&(this._chipBlurSubscription.unsubscribe(),this._chipBlurSubscription=null),this._chipSelectionSubscription&&(this._chipSelectionSubscription.unsubscribe(),this._chipSelectionSubscription=null),this._chipRemoveSubscription&&(this._chipRemoveSubscription.unsubscribe(),this._chipRemoveSubscription=null)}_listenToChipsSelection(){this._chipSelectionSubscription=this.chipSelectionChanges.subscribe(e=>{e.source.selected?this._selectionModel.select(e.source):this._selectionModel.deselect(e.source),this.multiple||this.chips.forEach(i=>{!this._selectionModel.isSelected(i)&&i.selected&&i.deselect()}),e.isUserInput&&this._propagateChanges()})}_listenToChipsFocus(){this._chipFocusSubscription=this.chipFocusChanges.subscribe(e=>{let i=this.chips.toArray().indexOf(e.chip);this._isValidIndex(i)&&this._keyManager.updateActiveItem(i),this.stateChanges.next()}),this._chipBlurSubscription=this.chipBlurChanges.subscribe(()=>{this._blur(),this.stateChanges.next()})}_listenToChipsRemoved(){this._chipRemoveSubscription=this.chipRemoveChanges.subscribe(e=>{let i=e.chip,r=this.chips.toArray().indexOf(e.chip);this._isValidIndex(r)&&i._hasFocus&&(this._lastDestroyedChipIndex=r)})}_originatesFromChip(e){let i=e.target;for(;i&&i!==this._elementRef.nativeElement;){if(i.classList.contains("mat-chip"))return!0;i=i.parentElement}return!1}_hasFocusedChip(){return this.chips&&this.chips.some(e=>e._hasFocus)}_syncChipsState(){this.chips&&this.chips.forEach(e=>{e._chipListDisabled=this._disabled,e._chipListMultiple=this.multiple,e.chipListSelectable=this._selectable})}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(nn),M($i,8),M(Lh,8),M(Vh,8),M(cd),M(Ns,10))},n.\u0275cmp=R({type:n,selectors:[["mat-chip-list"]],contentQueries:function(e,i,r){if(1&e&&Ei(r,Jb,5),2&e){let o;Ne(o=Le())&&(i.chips=o)}},hostAttrs:[1,"mat-chip-list"],hostVars:14,hostBindings:function(e,i){1&e&&P("focus",function(){return i.focus()})("blur",function(){return i._blur()})("keydown",function(o){return i._keydown(o)}),2&e&&(_s("id",i._uid),ze("tabindex",i.disabled?null:i._tabIndex)("aria-required",i.role?i.required:null)("aria-disabled",i.disabled.toString())("aria-invalid",i.errorState)("aria-multiselectable",i.multiple)("role",i.role)("aria-orientation",i.ariaOrientation),et("mat-chip-list-disabled",i.disabled)("mat-chip-list-invalid",i.errorState)("mat-chip-list-required",i.required))},inputs:{role:"role",userAriaDescribedBy:["aria-describedby","userAriaDescribedBy"],errorStateMatcher:"errorStateMatcher",multiple:"multiple",compareWith:"compareWith",value:"value",required:"required",placeholder:"placeholder",disabled:"disabled",ariaOrientation:["aria-orientation","ariaOrientation"],selectable:"selectable",tabIndex:"tabIndex"},outputs:{change:"change",valueChange:"valueChange"},exportAs:["matChipList"],features:[$t([{provide:kh,useExisting:n}]),tt],ngContentSelectors:set,decls:2,vars:0,consts:[[1,"mat-chip-list-wrapper"]],template:function(e,i){1&e&&(xi(),_(0,"div",0),Vn(1),v())},styles:['.mat-chip{position:relative;box-sizing:border-box;-webkit-tap-highlight-color:rgba(0,0,0,0);border:none;-webkit-appearance:none;-moz-appearance:none}.mat-chip::before{margin:calc(calc(var(--mat-focus-indicator-border-width, 3px) + 2px) * -1)}.mat-standard-chip{transition:box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);display:inline-flex;padding:7px 12px;border-radius:16px;align-items:center;cursor:default;min-height:32px;height:1px}.mat-standard-chip._mat-animation-noopable{transition:none !important;animation:none !important}.mat-standard-chip .mat-chip-remove{border:none;-webkit-appearance:none;-moz-appearance:none;padding:0;background:none}.mat-standard-chip .mat-chip-remove.mat-icon,.mat-standard-chip .mat-chip-remove .mat-icon{width:18px;height:18px;font-size:18px}.mat-standard-chip::after{top:0;left:0;right:0;bottom:0;position:absolute;border-radius:inherit;opacity:0;content:"";pointer-events:none;transition:opacity 200ms cubic-bezier(0.35, 0, 0.25, 1)}.mat-standard-chip:hover::after{opacity:.12}.mat-standard-chip:focus{outline:none}.mat-standard-chip:focus::after{opacity:.16}.cdk-high-contrast-active .mat-standard-chip{outline:solid 1px}.cdk-high-contrast-active .mat-standard-chip.mat-chip-selected{outline-width:3px}.mat-standard-chip.mat-chip-disabled::after{opacity:0}.mat-standard-chip.mat-chip-disabled .mat-chip-remove,.mat-standard-chip.mat-chip-disabled .mat-chip-trailing-icon{cursor:default}.mat-standard-chip.mat-chip-with-trailing-icon.mat-chip-with-avatar,.mat-standard-chip.mat-chip-with-avatar{padding-top:0;padding-bottom:0}.mat-standard-chip.mat-chip-with-trailing-icon.mat-chip-with-avatar{padding-right:8px;padding-left:0}[dir=rtl] .mat-standard-chip.mat-chip-with-trailing-icon.mat-chip-with-avatar{padding-left:8px;padding-right:0}.mat-standard-chip.mat-chip-with-trailing-icon{padding-top:7px;padding-bottom:7px;padding-right:8px;padding-left:12px}[dir=rtl] .mat-standard-chip.mat-chip-with-trailing-icon{padding-left:8px;padding-right:12px}.mat-standard-chip.mat-chip-with-avatar{padding-left:0;padding-right:12px}[dir=rtl] .mat-standard-chip.mat-chip-with-avatar{padding-right:0;padding-left:12px}.mat-standard-chip .mat-chip-avatar{width:24px;height:24px;margin-right:8px;margin-left:4px}[dir=rtl] .mat-standard-chip .mat-chip-avatar{margin-left:8px;margin-right:4px}.mat-standard-chip .mat-chip-remove,.mat-standard-chip .mat-chip-trailing-icon{width:18px;height:18px;cursor:pointer}.mat-standard-chip .mat-chip-remove,.mat-standard-chip .mat-chip-trailing-icon{margin-left:8px;margin-right:0}[dir=rtl] .mat-standard-chip .mat-chip-remove,[dir=rtl] .mat-standard-chip .mat-chip-trailing-icon{margin-right:8px;margin-left:0}.mat-chip-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;border-radius:inherit;overflow:hidden;transform:translateZ(0)}.mat-chip-list-wrapper{display:flex;flex-direction:row;flex-wrap:wrap;align-items:center;margin:-4px}.mat-chip-list-wrapper input.mat-input-element,.mat-chip-list-wrapper .mat-standard-chip{margin:4px}.mat-chip-list-stacked .mat-chip-list-wrapper{flex-direction:column;align-items:flex-start}.mat-chip-list-stacked .mat-chip-list-wrapper .mat-standard-chip{width:100%}.mat-chip-avatar{border-radius:50%;justify-content:center;align-items:center;display:flex;overflow:hidden;object-fit:cover}input.mat-chip-input{width:150px;margin:4px;flex:1 0 150px}'],encapsulation:2,changeDetection:0}),n})(),$b=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[cd,{provide:det,useValue:{separatorKeyCodes:[13]}}],imports:[ln]}),n})(),fet=function(n,t){return{"embedding-selected":n,"embedding-unselected":t}};function met(n,t){if(1&n){let e=Pe();_(0,"mat-icon",5),P("click",function(){oe(e);let r=S();return se(r.onSelect.emit(r.metric))}),v()}if(2&n){let e=S();y("ngClass",Qr(1,fet,e.embeddingsMetric===e.metric,e.embeddingsMetric!==e.metric))}}var _me=function(n){return{width:n}},vme=function(n){return{"value-invalid":n}},yme=(()=>{class n{constructor(){this.onRemove=new G,this.onSelect=new G,this.onFilterChange=new G,this.focusMin=!1,this.focusMax=!1,this.ngUnsubscribe=new ke}ngOnInit(){this.minFormControl=new Bh(this.filterValues.min,[Fo.required,Fo.min(-1),Fo.max(1),this.minValueValidator.bind(this)]),this.maxFormControl=new Bh(this.filterValues.max,[Fo.required,Fo.min(-1),Fo.max(1),this.maxValueValidator.bind(this)]),this.minFormControl.valueChanges.pipe(st(this.ngUnsubscribe)).subscribe(()=>{this.minFormControl.valid&&this.maxFormControl.valid&&this.onFilterChange.emit({min:parseFloat(this.minFormControl.value),max:parseFloat(this.maxFormControl.value)})}),this.maxFormControl.valueChanges.pipe(st(this.ngUnsubscribe)).subscribe(()=>{this.minFormControl.valid&&this.maxFormControl.valid&&this.onFilterChange.emit({min:parseFloat(this.minFormControl.value),max:parseFloat(this.maxFormControl.value)})})}ngOnChanges(e){this.minFormControl&&this.maxFormControl&&(this.minFormControl.setValue(this.filterValues.min,{emitEvent:!1}),this.maxFormControl.setValue(this.filterValues.max,{emitEvent:!1}))}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}minValueValidator(e){return this.maxFormControl&&"NaN"!==e.value?isNaN(parseFloat(e.value))?{value:"the string you entered is neither NaN nor a number"}:parseFloat(e.value)>parseFloat(this.maxFormControl.value)?{value:"the number you entered is larger than the max value"}:null:null}maxValueValidator(e){return this.minFormControl?"NaN"===this.minFormControl.value&&"NaN"===e.value?null:isNaN(parseFloat(e.value))?{value:"the string you entered is neither NaN nor a number"}:e.value<this.minFormControl.value?{value:"the number you entered is smaller than the min value"}:null:null}getErrorDescription(e){if(e){let i=Object.keys(e)[0];return"required"===i?"you did not enter anything":"min"===i?"the number must be at least -1.0":"max"===i?"the number is bigger than 1.0":e[i]}return""}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["metric-arithmetic-element-component"]],inputs:{metric:"metric",filterValues:"filterValues",hasEmbeddingsData:"hasEmbeddingsData",embeddingsMetric:"embeddingsMetric"},outputs:{onRemove:"onRemove",onSelect:"onSelect",onFilterChange:"onFilterChange"},features:[Ft],decls:10,vars:22,consts:[[1,"filter-chip",3,"removed"],["class","embeddings-button","svgIcon","group_work_24px",3,"ngClass","click",4,"ngIf"],[1,"metric-arithmetic-element-range",3,"keydown"],["matInput","",1,"input-field",3,"value","matTooltip","matTooltipDisabled","ngStyle","ngClass","formControl","focus","focusout"],["matChipRemove","","svgIcon","cancel_24px"],["svgIcon","group_work_24px",1,"embeddings-button",3,"ngClass","click"]],template:function(e,i){1&e&&(_(0,"mat-chip",0),P("removed",function(){return i.onRemove.emit(i.metric)}),E(1,met,1,4,"mat-icon",1),A(2),_(3,"div",2),P("keydown",function(o){return o.stopPropagation()}),A(4," [ "),_(5,"input",3),P("focus",function(){return i.focusMin=!0})("focusout",function(){return i.focusMin=!1}),v(),A(6," ; "),_(7,"input",3),P("focus",function(){return i.focusMax=!0})("focusout",function(){return i.focusMax=!1}),v(),A(8," ] "),v(),O(9,"mat-icon",4),v()),2&e&&(C(1),y("ngIf",i.hasEmbeddingsData),C(1),je(" ",i.metric," "),C(3),y("value",i.filterValues.min)("matTooltip",i.getErrorDescription(i.minFormControl.errors))("matTooltipDisabled",!i.minFormControl.invalid)("ngStyle",On(14,_me,i.focusMin?"100px":i.minFormControl.value.toString().length+"ch"))("ngClass",On(16,vme,!i.minFormControl.valid))("formControl",i.minFormControl),C(2),y("value",i.filterValues.max)("matTooltip",i.getErrorDescription(i.maxFormControl.errors))("matTooltipDisabled",!i.maxFormControl.invalid)("ngStyle",On(18,_me,i.focusMax?"100px":i.maxFormControl.value.toString().length+"ch"))("ngClass",On(20,vme,!i.maxFormControl.valid))("formControl",i.maxFormControl))},dependencies:[Fn,Be,zu,Bv,V2,mw,Gt,Jb,mme,Xk],styles:[".filter-chip[_ngcontent-%COMP%]{align-items:center;display:flex;margin-left:5px}.metric-arithmetic-element-range[_ngcontent-%COMP%]{align-items:center;background-color:#fff;font-size:.8em;height:30px;justify-content:center;line-height:30px;padding:0 5px;margin-left:5px}.input-field[_ngcontent-%COMP%]{background-color:rgba(0,0,0,0);border:none;font-family:monospace;font-size:1.1em;transition:width 1s}.input-field[_ngcontent-%COMP%]:focus{background-color:rgba(0,0,0,.12);border:none;outline:none}.value-invalid[_ngcontent-%COMP%]{color:#f44336}.embedding-selected[_ngcontent-%COMP%]{color:#f57c00;opacity:1}.embedding-unselected[_ngcontent-%COMP%]{opacity:.4}.embeddings-button[_ngcontent-%COMP%]{width:18px;height:18px;margin-right:8px;cursor:pointer}"],changeDetection:0}),n})(),bme=(()=>{class n{constructor(e){this.store=e,this.filterValues$=this.store.pipe(vt(Il)).pipe(L(i=>{let r=i[this.metric];return r?{min:r.includeNaN?"NaN":this.roundToThreeDecimalPoints(r.min),max:r.max<r.min?"NaN":this.roundToThreeDecimalPoints(r.max)}:{min:-1,max:1}})),this.hasEmbeddingsData$=this.store.pipe(vt(BF)).pipe(L(i=>void 0!==i)),this.embeddingsMetric$=this.store.pipe(vt(ame))}remove(e){this.store.dispatch(Gb({metric:e}))}select(e){this.store.dispatch(FF({metric:e}))}filterChange(e){let i=isNaN(e.min)?-1:e.min,r=isNaN(e.max)?-2:e.max,o=isNaN(e.min);this.store.dispatch(Wb({metric:this.metric,max:r,min:i,includeNaN:o}))}roundToThreeDecimalPoints(e){return Math.round(1e3*(e+Number.EPSILON))/1e3}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["npmi-metric-arithmetic-element"]],inputs:{metric:"metric"},decls:4,vars:10,consts:[[3,"metric","filterValues","hasEmbeddingsData","embeddingsMetric","onRemove","onSelect","onFilterChange"]],template:function(e,i){1&e&&(_(0,"metric-arithmetic-element-component",0),P("onRemove",function(o){return i.remove(o)})("onSelect",function(o){return i.select(o)})("onFilterChange",function(o){return i.filterChange(o)}),B(1,"async"),B(2,"async"),B(3,"async"),v()),2&e&&y("metric",i.metric)("filterValues",U(1,4,i.filterValues$))("hasEmbeddingsData",U(2,6,i.hasEmbeddingsData$))("embeddingsMetric",U(3,8,i.embeddingsMetric$))},dependencies:[yme,Ge],encapsulation:2,changeDetection:0}),n})(),xme=(()=>{class n{constructor(){this.Operator=s0}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["npmi-metric-arithmetic-operator"]],inputs:{operator:"operator"},decls:2,vars:1,template:function(e,i){1&e&&(_(0,"mat-chip"),A(1),v()),2&e&&(C(1),je(" ",i.operator===i.Operator.AND?"&":""," "))},dependencies:[Jb],encapsulation:2,changeDetection:0}),n})();function yet(n,t){1&n&&O(0,"npmi-metric-arithmetic-element",4),2&n&&y("metric",S().$implicit.metric)}function bet(n,t){1&n&&O(0,"npmi-metric-arithmetic-operator",5),2&n&&y("operator",S().$implicit.operator)}function xet(n,t){if(1&n&&(_(0,"div"),E(1,yet,1,1,"npmi-metric-arithmetic-element",2),E(2,bet,1,1,"npmi-metric-arithmetic-operator",3),v()),2&n){let e=t.$implicit,i=S();C(1),y("ngIf",e.kind===i.ArithmeticKind.METRIC),C(1),y("ngIf",e.kind===i.ArithmeticKind.OPERATOR)}}var Cme=(()=>{class n{constructor(){this.ArithmeticKind=mu}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["metric-arithmetic-component"]],inputs:{metricArithmetic:"metricArithmetic"},decls:2,vars:2,consts:[[3,"selectable"],[4,"ngFor","ngForOf"],[3,"metric",4,"ngIf"],[3,"operator",4,"ngIf"],[3,"metric"],[3,"operator"]],template:function(e,i){1&e&&(_(0,"mat-chip-list",0),E(1,xet,3,2,"div",1),v()),2&e&&(y("selectable",!1),C(1),y("ngForOf",i.metricArithmetic))},dependencies:[dn,Be,gme,bme,xme],styles:["[_nghost-%COMP%]{align-items:center;display:flex;flex-direction:row;flex-wrap:wrap}"],changeDetection:0}),n})(),Mme=(()=>{class n{constructor(e){this.store=e,this.metricArithmetic$=this.store.pipe(vt(HF))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["npmi-metric-arithmetic"]],decls:2,vars:3,consts:[[3,"metricArithmetic"]],template:function(e,i){1&e&&(O(0,"metric-arithmetic-component",0),B(1,"async")),2&e&&y("metricArithmetic",U(1,1,i.metricArithmetic$))},dependencies:[Cme,Ge],encapsulation:2,changeDetection:0}),n})();function wme(n,t,e){let i=[[t,...e]];if(!e.length||!n.length)return"data:text/csv;charset=utf-8,"+i.map(a=>a.join(",")).join("\n");let r=e.map(s=>Ss(s));for(let[s,a]of n){let l=a.filter(c=>c.run===t);if(l.length){let c=[s];for(let u of r){let d=l.find(p=>p.metric===u);c.push(void 0===d?"null":`${d.nPMIValue}`)}i.push(c)}}return"data:text/csv;charset=utf-8,"+i.map(s=>s.join(",")).join("\n")}var wet=function(n){return{"active-button":n}},Sme=(()=>{class n{downloadResults(){for(let e of this.runs){let i=wme(this.flaggedData,e,this.metrics),r=document.createElement("a");r.setAttribute("href",i),r.setAttribute("download",`report_${e}.csv`),r.click()}}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["results-download-component"]],inputs:{numFlaggedAnnotations:"numFlaggedAnnotations",runs:"runs",flaggedData:"flaggedData",metrics:"metrics"},decls:4,vars:5,consts:[["mat-stroked-button","","title","Export CSV reports of all flagged annotations. Will generate one CSV per active run.",3,"disabled","ngClass","click"],[1,"button-contents"],["svgIcon","get_app_24px"]],template:function(e,i){1&e&&(_(0,"button",0),P("click",function(){return i.downloadResults()}),_(1,"span",1),O(2,"mat-icon",2),A(3),v()()),2&e&&(y("disabled",0===i.numFlaggedAnnotations)("ngClass",On(3,wet,i.numFlaggedAnnotations>0)),C(3),je(" Flagged Rows (",i.numFlaggedAnnotations,") "))},dependencies:[Fn,Gt,_n],styles:[".active-button[_ngcontent-%COMP%]{background-color:#ff9800;border:1px solid #ebebeb;color:#fff}.button-contents[_ngcontent-%COMP%]{align-items:center;display:flex;text-transform:uppercase}mat-icon[_ngcontent-%COMP%]{margin-right:6px}"],changeDetection:0}),n})(),Eme=(()=>{class n{constructor(e){this.store=e,this.flaggedAnnotations$=this.store.select(VF),this.numFlaggedAnnotations$=this.flaggedAnnotations$.pipe(L(i=>i.length)),this.activeRuns$=this.store.select(oo).pipe(L(i=>i?Array.from(i.entries()).filter(r=>r[1]).map(r=>r[0]):[])),this.flaggedData$=Lt([this.store.select(Pf),this.flaggedAnnotations$]).pipe(L(([i,r])=>{let o=new Set(r);return Object.entries(i).filter(a=>o.has(a[0]))})),this.metrics$=Lt([this.store.select(Rf),this.activeRuns$,this.store.select(Il)]).pipe(L(([i,r,o])=>{let s=Object.keys(o);for(let a of r)i[a]&&(s=s.concat(i[a].filter(l=>Vb(l))));return s=[...new Set(s)],s}))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["npmi-results-download"]],decls:5,vars:12,consts:[[3,"numFlaggedAnnotations","runs","flaggedData","metrics"]],template:function(e,i){1&e&&(O(0,"results-download-component",0),B(1,"async"),B(2,"async"),B(3,"async"),B(4,"async")),2&e&&y("numFlaggedAnnotations",U(1,4,i.numFlaggedAnnotations$))("runs",U(2,6,i.activeRuns$))("flaggedData",U(3,8,i.flaggedData$))("metrics",U(4,10,i.metrics$))},dependencies:[Sme,Ge],encapsulation:2,changeDetection:0}),n})(),WF=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["npmi-data-selection"]],decls:4,vars:0,consts:[[1,"data-selection"],[1,"metrics-selector"]],template:function(e,i){1&e&&(_(0,"div",0),O(1,"npmi-metric-search",1)(2,"npmi-results-download"),v(),O(3,"npmi-metric-arithmetic"))},dependencies:[hme,Mme,Eme],styles:["[_nghost-%COMP%]{display:flex;flex-direction:column;background-color:#fff;border:1px solid #ebebeb;padding:10px 20px}.data-selection[_ngcontent-%COMP%]{display:flex;align-items:center}.metrics-selector[_ngcontent-%COMP%]{flex:1 1}"],changeDetection:0}),n})();function qF(n,t,e){if(e)return n;let i={...n};return t.forEach(r=>delete i[r]),i}var Aet=["chart"],Ime=(()=>{class n{constructor(){this.onRemove=new G,this.onUpdateFilter=new G,this.height=300,this.chartWidth=0,this.chartHeight=0,this.drawHeight=0,this.drawWidth=0,this.margin={top:20,right:10,bottom:20,left:10},this.drawMargin={top:0,right:0,bottom:20,left:20},this.brush=function(n){var a,t=TUe,e=EUe,i=DUe,r=!0,o=Gw("start","brush","end"),s=6;function l(x){var g=x.property("__brush",m).selectAll(".overlay").data([oS("overlay")]);g.enter().append("rect").attr("class","overlay").attr("pointer-events","all").attr("cursor",mp.overlay).merge(g).each(function(){var D=bz(this).extent;bo(this).attr("x",D[0][0]).attr("y",D[0][1]).attr("width",D[1][0]-D[0][0]).attr("height",D[1][1]-D[0][1])}),x.selectAll(".selection").data([oS("selection")]).enter().append("rect").attr("class","selection").attr("cursor",mp.selection).attr("fill","#777").attr("fill-opacity",.3).attr("stroke","#fff").attr("shape-rendering","crispEdges");var b=x.selectAll(".handle").data(n.handles,function(D){return D.type});b.exit().remove(),b.enter().append("rect").attr("class",function(D){return"handle handle--"+D.type}).attr("cursor",function(D){return mp[D.type]}),x.each(c).attr("fill","none").attr("pointer-events","all").on("mousedown.brush",p).filter(i).on("touchstart.brush",p).on("touchmove.brush",h).on("touchend.brush touchcancel.brush",f).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function c(){var x=bo(this),g=bz(this).selection;g?(x.selectAll(".selection").style("display",null).attr("x",g[0][0]).attr("y",g[0][1]).attr("width",g[1][0]-g[0][0]).attr("height",g[1][1]-g[0][1]),x.selectAll(".handle").style("display",null).attr("x",function(b){return"e"===b.type[b.type.length-1]?g[1][0]-s/2:g[0][0]-s/2}).attr("y",function(b){return"s"===b.type[0]?g[1][1]-s/2:g[0][1]-s/2}).attr("width",function(b){return"n"===b.type||"s"===b.type?g[1][0]-g[0][0]+s:s}).attr("height",function(b){return"e"===b.type||"w"===b.type?g[1][1]-g[0][1]+s:s})):x.selectAll(".selection,.handle").style("display","none").attr("x",null).attr("y",null).attr("width",null).attr("height",null)}function u(x,g,b){var D=x.__brush.emitter;return!D||b&&D.clean?new d(x,g,b):D}function d(x,g,b){this.that=x,this.args=g,this.state=x.__brush,this.active=0,this.clean=b}function p(){if((!a||si.touches)&&e.apply(this,arguments)){var ue,he,F,q,de,Y,le,Ie,nt,Ue,Ae,x=this,g=si.target.__data__.type,b="selection"===(r&&si.metaKey?g="overlay":g)?ple:r&&si.altKey?My:Cy,D=n===$R?null:wUe[g],T=n===yz?null:SUe[g],k=bz(x),Z=k.extent,z=k.selection,fe=Z[0][0],w=Z[0][1],K=Z[1][0],ae=Z[1][1],ve=0,De=0,gt=D&&T&&r&&si.shiftKey,tn=si.touches?MUe(si.changedTouches[0].identifier):GU,pt=tn(x),wt=pt,Te=u(x,arguments,!0).beforestart();"overlay"===g?(z&&(nt=!0),k.selection=z=[[ue=n===$R?fe:pt[0],F=n===yz?w:pt[1]],[de=n===$R?K:ue,le=n===yz?ae:F]]):(ue=z[0][0],F=z[0][1],de=z[1][0],le=z[1][1]),he=ue,q=F,Y=de,Ie=le;var xt=bo(x).attr("pointer-events","none"),mt=xt.selectAll(".overlay").attr("cursor",mp[g]);if(si.touches)Te.moved=dt,Te.ended=Mt;else{var ce=bo(si.view).on("mousemove.brush",dt,!0).on("mouseup.brush",Mt,!0);r&&ce.on("keydown.brush",bt,!0).on("keyup.brush",hn,!0),qU(si.view)}_z(),Cg(x),c.call(x),Te.start()}function dt(){var on=tn(x);gt&&!Ue&&!Ae&&(Math.abs(on[0]-wt[0])>Math.abs(on[1]-wt[1])?Ae=!0:Ue=!0),wt=on,nt=!0,JR(),We()}function We(){var on;switch(ve=wt[0]-pt[0],De=wt[1]-pt[1],b){case vz:case ple:D&&(ve=Math.max(fe-ue,Math.min(K-de,ve)),he=ue+ve,Y=de+ve),T&&(De=Math.max(w-F,Math.min(ae-le,De)),q=F+De,Ie=le+De);break;case Cy:D<0?(ve=Math.max(fe-ue,Math.min(K-ue,ve)),he=ue+ve,Y=de):D>0&&(ve=Math.max(fe-de,Math.min(K-de,ve)),he=ue,Y=de+ve),T<0?(De=Math.max(w-F,Math.min(ae-F,De)),q=F+De,Ie=le):T>0&&(De=Math.max(w-le,Math.min(ae-le,De)),q=F,Ie=le+De);break;case My:D&&(he=Math.max(fe,Math.min(K,ue-ve*D)),Y=Math.max(fe,Math.min(K,de+ve*D))),T&&(q=Math.max(w,Math.min(ae,F-De*T)),Ie=Math.max(w,Math.min(ae,le+De*T)))}Y<he&&(D*=-1,on=ue,ue=de,de=on,on=he,he=Y,Y=on,g in fle&&mt.attr("cursor",mp[g=fle[g]])),Ie<q&&(T*=-1,on=F,F=le,le=on,on=q,q=Ie,Ie=on,g in mle&&mt.attr("cursor",mp[g=mle[g]])),k.selection&&(z=k.selection),Ue&&(he=z[0][0],Y=z[1][0]),Ae&&(q=z[0][1],Ie=z[1][1]),(z[0][0]!==he||z[0][1]!==q||z[1][0]!==Y||z[1][1]!==Ie)&&(k.selection=[[he,q],[Y,Ie]],c.call(x),Te.brush())}function Mt(){if(_z(),si.touches){if(si.touches.length)return;a&&clearTimeout(a),a=setTimeout(function(){a=null},500)}else YU(si.view,nt),ce.on("keydown.brush keyup.brush mousemove.brush mouseup.brush",null);xt.attr("pointer-events","all"),mt.attr("cursor",mp.overlay),k.selection&&(z=k.selection),AUe(z)&&(k.selection=null,c.call(x)),Te.end()}function bt(){switch(si.keyCode){case 16:gt=D&&T;break;case 18:b===Cy&&(D&&(de=Y-ve*D,ue=he+ve*D),T&&(le=Ie-De*T,F=q+De*T),b=My,We());break;case 32:(b===Cy||b===My)&&(D<0?de=Y-ve:D>0&&(ue=he-ve),T<0?le=Ie-De:T>0&&(F=q-De),b=vz,mt.attr("cursor",mp.selection),We());break;default:return}JR()}function hn(){switch(si.keyCode){case 16:gt&&(Ue=Ae=gt=!1,We());break;case 18:b===My&&(D<0?de=Y:D>0&&(ue=he),T<0?le=Ie:T>0&&(F=q),b=Cy,We());break;case 32:b===vz&&(si.altKey?(D&&(de=Y-ve*D,ue=he+ve*D),T&&(le=Ie-De*T,F=q+De*T),b=My):(D<0?de=Y:D>0&&(ue=he),T<0?le=Ie:T>0&&(F=q),b=Cy),mt.attr("cursor",mp[g]),We());break;default:return}JR()}}function h(){u(this,arguments).moved()}function f(){u(this,arguments).ended()}function m(){var x=this.__brush||{selection:null};return x.extent=xz(t.apply(this,arguments)),x.dim=n,x}return l.move=function(x,g){x.selection?x.on("start.brush",function(){u(this,arguments).beforestart().start()}).on("interrupt.brush end.brush",function(){u(this,arguments).end()}).tween("brush",function(){var b=this,D=b.__brush,T=u(b,arguments),k=D.selection,Z=n.input("function"==typeof g?g.apply(this,arguments):g,D.extent),z=fp(k,Z);function fe(ue){D.selection=1===ue&&null===Z?null:z(ue),c.call(b),T.brush()}return null!==k&&null!==Z?fe:fe(1)}):x.each(function(){var b=this,D=arguments,T=b.__brush,k=n.input("function"==typeof g?g.apply(b,D):g,T.extent),Z=u(b,D).beforestart();Cg(b),T.selection=null===k?null:k,c.call(b),Z.start().brush().end()})},l.clear=function(x){l.move(x,null)},d.prototype={beforestart:function(){return 1==++this.active&&(this.state.emitter=this,this.starting=!0),this},start:function(){return this.starting?(this.starting=!1,this.emit("start")):this.emit("brush"),this},brush:function(){return this.emit("brush"),this},end:function(){return 0==--this.active&&(delete this.state.emitter,this.emit("end")),this},emit:function(x){!function(n,t,e,i){var r=si;n.sourceEvent=si,si=n;try{t.apply(e,i)}finally{si=r}}(new dle(l,x,n.output(this.state.selection)),o.apply,o,[x,this.that,this.args])}},l.extent=function(x){return arguments.length?(t="function"==typeof x?x:ZR(xz(x)),l):t},l.filter=function(x){return arguments.length?(e="function"==typeof x?x:ZR(!!x),l):e},l.touchable=function(x){return arguments.length?(i="function"==typeof x?x:ZR(!!x),l):i},l.handleSize=function(x){return arguments.length?(s=+x,l):s},l.keyModifiers=function(x){return arguments.length?(r=!!x,l):r},l.on=function(){var x=o.on.apply(o,arguments);return x===o?l:x},l}($R),this.maxBinSize=0,this.area=function(){var n=hO,t=null,e=fa(0),i=fO,r=fa(!0),o=null,s=pO,a=null;function l(u){var d,p,h,m,g,f=u.length,x=!1,b=new Array(f),D=new Array(f);for(null==o&&(a=s(g=sS())),d=0;d<=f;++d){if(!(d<f&&r(m=u[d],d,u))===x)if(x=!x)p=d,a.areaStart(),a.lineStart();else{for(a.lineEnd(),a.lineStart(),h=d-1;h>=p;--h)a.point(b[h],D[h]);a.lineEnd(),a.areaEnd()}x&&(b[d]=+n(m,d,u),D[d]=+e(m,d,u),a.point(t?+t(m,d,u):b[d],i?+i(m,d,u):D[d]))}if(g)return a=null,g+""||null}function c(){return xS().defined(r).curve(s).context(o)}return l.x=function(u){return arguments.length?(n="function"==typeof u?u:fa(+u),t=null,l):n},l.x0=function(u){return arguments.length?(n="function"==typeof u?u:fa(+u),l):n},l.x1=function(u){return arguments.length?(t=null==u?null:"function"==typeof u?u:fa(+u),l):t},l.y=function(u){return arguments.length?(e="function"==typeof u?u:fa(+u),i=null,l):e},l.y0=function(u){return arguments.length?(e="function"==typeof u?u:fa(+u),l):e},l.y1=function(u){return arguments.length?(i=null==u?null:"function"==typeof u?u:fa(+u),l):i},l.lineX0=l.lineY0=function(){return c().x(n).y(e)},l.lineY1=function(){return c().x(n).y(i)},l.lineX1=function(){return c().x(t).y(e)},l.defined=function(u){return arguments.length?(r="function"==typeof u?u:fa(!!u),l):r},l.curve=function(u){return arguments.length?(s=u,null!=o&&(a=s(o)),l):s},l.context=function(u){return arguments.length?(null==u?o=a=null:a=s(o=u),l):o},l}().x0(function(e){return this.xScaleNum(-e.length)}.bind(this)).x1(function(e){return this.xScaleNum(e.length)}.bind(this)).y(function(e){return e.x0===-1/0?this.chartHeight-this.drawMargin.top:this.yScale((e.x1+e.x0)/2)}.bind(this)).curve(sj)}ngAfterViewInit(){this.updateDimensions(),this.svg=bo(this.chartContainer.nativeElement).select("svg"),this.mainContainer=this.svg.append("g").attr("transform",`translate(${this.margin.left}, ${this.margin.top})`),this.drawContainer=this.mainContainer.append("g").attr("transform",`translate(${this.drawMargin.left}, ${this.drawMargin.top})`),this.dotsGroup=this.drawContainer.append("g").attr("class","dotsGroup"),this.yAxisGroup=this.mainContainer.append("g").attr("class","axis axis--y"),this.xAxisGroup=this.mainContainer.append("g").attr("class","axis axis--x"),this.miscGroup=this.drawContainer.append("g"),this.xScale=wy().padding(.05),this.xAxis=jw(this.xScale),this.yScale=Qo().range([this.drawHeight,0]),this.yAxis=function(n){return BU(4,n)}(this.yScale),this.xScaleNum=Qo(),this.initializeBrush(),this.drawMisc(),this.redraw()}ngOnChanges(e){this.svg&&this.redraw()}redraw(){this.updateDimensions(),this.setMaxBinSize(),this.updateAxes(),this.draw()}updateDimensions(){this.chartWidth=this.width-this.margin.left-this.margin.right,this.drawWidth=this.chartWidth-this.drawMargin.left-this.drawMargin.right,this.chartHeight=this.height-this.margin.top-this.margin.bottom,this.drawHeight=this.chartHeight-this.drawMargin.top-this.drawMargin.bottom}setMaxBinSize(){Object.values(this.chartData.violinData).forEach(e=>{let i=e.map(o=>o.length),r=Math.max(...i);this.maxBinSize=Math.max(r,this.maxBinSize)})}updateAxes(){this.xScale.range([0,this.drawWidth]).domain(Object.keys(this.chartData.violinData)),this.yScale.domain([this.chartData.extremes.min,this.chartData.extremes.max]),this.xScaleNum.range([0,this.xScale.bandwidth()]).domain([-this.maxBinSize,this.maxBinSize])}initializeBrush(){this.brush.on("end",this.brushMoved.bind(this))}draw(){this.drawAxes(),this.drawPlot(),this.refreshMisc(),this.refreshBrush()}drawAxes(){this.yAxisGroup.attr("transform",`translate(${this.drawMargin.left},\n      ${this.drawMargin.top})`).call(this.yAxis),this.xAxisGroup.attr("transform",`translate(${this.drawMargin.left},\n      ${this.drawMargin.top+this.chartHeight})`).call(this.xAxis)}drawPlot(){let e=this.dotsGroup.selectAll(".violin-plot").data(Object.entries(this.chartData.violinData));e.enter().append("path").attr("class","violin-plot").style("stroke",function(i){return this.colorScale(i[0])}.bind(this)).style("fill",function(i){return`${this.colorScale(i[0])}33`}.bind(this)).attr("transform",function(i){return`translate(${this.xScale(i[0])}, 0)`}.bind(this)).datum(function(i){return i[1]}).attr("d",this.area),e.attr("transform",function(i){return`translate(${this.xScale(i[0])}, 0)`}.bind(this)).datum(function(i){return i[1]}).attr("d",this.area),e.exit().remove()}drawMisc(){this.zeroLine=this.miscGroup.append("line").style("stroke","black").attr("x1",0).attr("y1",this.yScale(0)).attr("x2",this.drawWidth).attr("y2",this.yScale(0)),this.nanText=this.miscGroup.append("text").style("fill","black").text("NaN").attr("font-size","10px").attr("text-anchor","end").attr("alignment-baseline","middle").attr("x",-5).attr("y",this.chartHeight-this.drawMargin.top),this.nanLine=this.miscGroup.append("line").style("stroke","grey").style("stroke-dasharray","3, 3").attr("x1",0).attr("y1",this.chartHeight-this.drawMargin.top).attr("x2",this.drawWidth).attr("y2",this.chartHeight-this.drawMargin.top)}refreshMisc(){this.zeroLine.attr("y1",this.yScale(0)).attr("x2",this.drawWidth).attr("y2",this.yScale(0)),this.nanText.attr("y",this.chartHeight-this.drawMargin.top),this.nanLine.attr("y1",this.drawHeight+this.drawMargin.top).attr("x2",this.drawWidth).attr("y2",this.drawHeight+this.drawMargin.top)}refreshBrush(){this.brush.extent([[0,0],[this.drawWidth,this.drawHeight+this.margin.top]]);let e=[0,this.drawHeight+this.margin.top];if(this.filter.max<this.filter.min)e[0]=this.filter.includeNaN?this.yScale(this.chartData.extremes.min):e[1];else{if(!this.filter.includeNaN){let r=Math.max(this.chartData.extremes.min,this.filter.min);e[1]=this.yScale(r)}let i=Math.min(this.chartData.extremes.max,this.filter.max);e[0]=this.yScale(i)}this.drawContainer.call(this.brush).call(this.brush.move,e)}brushMoved(){if(!si||!si.sourceEvent)return;let e=si.selection;if(e){let i=!1,r=-2,o=this.chartData.extremes.min;e[0]<=this.drawHeight+this.margin.top&&e[1]>=this.drawHeight&&(i=!0),e[0]<this.drawHeight&&(r=this.yScale.invert(e[0])),e[1]<this.drawHeight&&(o=this.yScale.invert(e[1])),this.onUpdateFilter.emit({max:r,min:o,includeNaN:i})}else this.onUpdateFilter.emit({max:1,min:-1,includeNaN:!0})}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["violin-filter-component"]],viewQuery:function(e,i){if(1&e&&ot(Aet,7,Re),2&e){let r;Ne(r=Le())&&(i.chartContainer=r.first)}},inputs:{metricName:"metricName",filter:"filter",chartData:"chartData",width:"width",colorScale:"colorScale"},outputs:{onRemove:"onRemove",onUpdateFilter:"onUpdateFilter"},features:[Ft],decls:9,vars:1,consts:function(){let t;return t=$localize`:Label for a button that removes a metric filter.␟a6bfad58bb363d5c891d0a5474b1d77ef90a34da␟8454961797762907624:Remove Filter`,[[1,"chart-container"],["title","Shows the nPMI value distribution per run. Ranges of selected values can be manipulated by modifying the grey box.",1,"chart-head"],[1,"chart-heading"],["mat-icon-button","","aria-label",t,3,"click"],["svgIcon","clear_24px"],[1,"chart"],["chart",""],[1,"draw-area"]]},template:function(e,i){1&e&&(_(0,"div",0)(1,"div",1)(2,"div",2),A(3),v(),_(4,"button",3),P("click",function(){return i.onRemove.emit()}),O(5,"mat-icon",4),v()(),_(6,"div",5,6),In(),O(8,"svg",7),v()()),2&e&&(C(3),yt(i.metricName))},dependencies:[_n,Gt],styles:[".chart-container[_ngcontent-%COMP%]{background-color:#fff;border-bottom:1px solid #ebebeb;display:flex;flex-direction:column;overflow:hidden}.chart[_ngcontent-%COMP%]{height:300px;width:100%}.chart-head[_ngcontent-%COMP%]{align-items:center;display:flex;justify-content:space-between}.chart-heading[_ngcontent-%COMP%]{font-size:13px;padding-left:10px;padding-top:10px}.draw-area[_ngcontent-%COMP%]{height:100%;width:100%}.stroked-line[_ngcontent-%COMP%]{stroke:rgba(0,0,0,.12);stroke-dasharray:3 3}"],changeDetection:0}),n})(),Pme=(()=>{class n{constructor(e){this.store=e,this.activeRuns$=this.store.pipe(vt(oo)).pipe(L(i=>i?Array.from(i.entries()).filter(r=>r[1]).map(r=>r[0]):[])),this.visibleAnnotations$=Lt([this.store.select(Pf),this.store.select(Xb),this.store.select(Zb)]).pipe(L(([i,r,o])=>qF(i,r,o))),this.chartWidth$=this.store.pipe(vt(Of)).pipe(L(i=>Math.max(150,i))),this.runColorScale$=this.store.select(nc).pipe(L(i=>r=>{if(!i.hasOwnProperty(r))throw new Error(`[Color scale] unknown runId: ${r}.`);return i[r]}))}ngOnInit(){this.chartData$=Lt([this.visibleAnnotations$,this.activeRuns$]).pipe(L(([e,i])=>function(n,t,e){let i={},r={},o=new Set(t),s=Ss(e),a={max:-1,min:1};Object.values(n).forEach(d=>{d.forEach(p=>{let h=p.run;if(o.has(h)&&p.metric===s)if(null===p.nPMIValue)r[h]?r[h].push(null):r[h]=[null];else{let f=p.nPMIValue;a.max=a.max<f?f:a.max,a.min=a.min>f?f:a.min,i[p.run]?i[h].push(f):i[h]=[f]}})});let l={},c=MR().domain([a.min,a.max]).value(d=>d),u=MR().domain([-1/0,1/0]).thresholds(0).value(d=>d);for(let d of o)if(l[d]=c(i[d]),r[d]){let p=u(r[d]);l[d].unshift(p[0])}return{violinData:l,extremes:a}}(e,i,this.metricName)))}removeMetric(){this.store.dispatch(Gb({metric:this.metricName}))}updateFilter(e){this.store.dispatch(Wb({metric:this.metricName,...e}))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["npmi-violin-filter"]],inputs:{metricName:"metricName",filter:"filter"},decls:4,vars:11,consts:[[3,"metricName","filter","chartData","width","colorScale","onRemove","onUpdateFilter"]],template:function(e,i){1&e&&(_(0,"violin-filter-component",0),P("onRemove",function(){return i.removeMetric()})("onUpdateFilter",function(o){return i.updateFilter(o)}),B(1,"async"),B(2,"async"),B(3,"async"),v()),2&e&&y("metricName",i.metricName)("filter",i.filter)("chartData",U(1,5,i.chartData$))("width",U(2,7,i.chartWidth$))("colorScale",U(3,9,i.runColorScale$))},dependencies:[Ime,Ge],encapsulation:2,changeDetection:0}),n})();function Ret(n,t){if(1&n&&O(0,"npmi-violin-filter",8),2&n){let e=t.$implicit;y("metricName",e[0])("filter",e[1])}}function Oet(n,t){1&n&&(_(0,"div",9)(1,"span",10),A(2," You can add more filters at the top. "),v()())}var Rme=(()=>{class n{constructor(){this.toggleSidebarExpanded=new G}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["violin-filters-component"]],inputs:{sidebarExpanded:"sidebarExpanded",metricFilters:"metricFilters"},outputs:{toggleSidebarExpanded:"toggleSidebarExpanded"},decls:9,vars:2,consts:function(){let t;return t=$localize`:Label for a button that expands/hides the sidebar.␟48c29903ce881ab61088f8d49d827203716aaed4␟4658602991970260215:Expand/Hide Sidebar`,[[1,"filters-toolbar"],[1,"filters-title"],[1,"side-toggle"],["mat-icon-button","","aria-label",t,3,"click"],["svgIcon","chevron_left_24px"],[1,"filters"],[3,"metricName","filter",4,"ngFor","ngForOf"],["class","filters-hint",4,"ngIf"],[3,"metricName","filter"],[1,"filters-hint"],[1,"filters-hint-text"]]},template:function(e,i){1&e&&(_(0,"div",0)(1,"h3",1),A(2,"Active Filters"),v(),_(3,"div",2)(4,"button",3),P("click",function(){return i.toggleSidebarExpanded.emit()}),O(5,"mat-icon",4),v()()(),_(6,"div",5),E(7,Ret,1,2,"npmi-violin-filter",6),v(),E(8,Oet,3,0,"div",7)),2&e&&(C(7),y("ngForOf",i.metricFilters),C(1),y("ngIf",0===i.metricFilters.length))},dependencies:[dn,Be,Gt,_n,Pme],styles:["[_nghost-%COMP%]{display:flex;flex-direction:column;height:100%}.filters-toolbar[_ngcontent-%COMP%]{align-items:center;border-bottom:1px solid #ebebeb;display:flex;height:42px;justify-content:space-between;padding:0 10px}.filters-title[_ngcontent-%COMP%]{display:inline;font-size:14px;font-weight:500}.side-toggle[_ngcontent-%COMP%]{align-items:center;background-color:#fff;border-radius:3px;border:1px solid #ebebeb;display:flex;height:30px;justify-content:center;width:30px}.filters[_ngcontent-%COMP%]{overflow-y:auto}.filters-hint[_ngcontent-%COMP%]{align-items:center;display:flex;height:42px;padding:0 16px}.filters-hint-text[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}"],changeDetection:0}),n})(),Ome=(()=>{class n{constructor(e){this.store=e,this.sidebarExpanded$=this.store.select(zF),this.metricFilters$=this.store.select(Il).pipe(L(i=>Object.entries(i)))}onToggleSidebarExpanded(){this.store.dispatch(qb())}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["npmi-violin-filters"]],decls:3,vars:6,consts:[[3,"sidebarExpanded","metricFilters","toggleSidebarExpanded"]],template:function(e,i){1&e&&(_(0,"violin-filters-component",0),P("toggleSidebarExpanded",function(){return i.onToggleSidebarExpanded()}),B(1,"async"),B(2,"async"),v()),2&e&&y("sidebarExpanded",U(1,2,i.sidebarExpanded$))("metricFilters",U(2,4,i.metricFilters$))},dependencies:[Rme,Ge],encapsulation:2,changeDetection:0}),n})();function Vet(n,t,e){return n.length!=t.length?e:t.map((o,s)=>o-n[s]).map(o=>Math.pow(o,2)).reduce((o,s)=>o+s,0)}var Het=["input"],Uet=function(n){return{enterDuration:n}},zet=["*"],jet=new pe("mat-slide-toggle-default-options",{providedIn:"root",factory:()=>({disableToggleValue:!1})}),Get=0,Wet={provide:No,useExisting:Jn(()=>_6),multi:!0},qet=oc(ko(qo(so(class{constructor(n){this._elementRef=n}})))),Yet=(()=>{class n extends qet{constructor(e,i,r,o,s,a,l){super(e),this._focusMonitor=i,this._changeDetectorRef=r,this.defaults=s,this._onChange=c=>{},this._onTouched=()=>{},this._required=!1,this._checked=!1,this.name=null,this.labelPosition="after",this.ariaLabel=null,this.ariaLabelledby=null,this.change=new G,this.toggleChange=new G,this.tabIndex=parseInt(o)||0,this.color=this.defaultColor=s.color||"accent",this._noopAnimations="NoopAnimations"===a,this.id=this._uniqueId=`${l}${++Get}`}get required(){return this._required}set required(e){this._required=Rt(e)}get checked(){return this._checked}set checked(e){this._checked=Rt(e),this._changeDetectorRef.markForCheck()}get inputId(){return`${this.id||this._uniqueId}-input`}ngAfterContentInit(){this._focusMonitor.monitor(this._elementRef,!0).subscribe(e=>{"keyboard"===e||"program"===e?this._focused=!0:e||Promise.resolve().then(()=>{this._focused=!1,this._onTouched(),this._changeDetectorRef.markForCheck()})})}ngOnDestroy(){this._focusMonitor.stopMonitoring(this._elementRef)}writeValue(e){this.checked=!!e}registerOnChange(e){this._onChange=e}registerOnTouched(e){this._onTouched=e}setDisabledState(e){this.disabled=e,this._changeDetectorRef.markForCheck()}toggle(){this.checked=!this.checked,this._onChange(this.checked)}_emitChangeEvent(){this._onChange(this.checked),this.change.emit(this._createChangeEvent(this.checked))}}return n.\u0275fac=function(e){nl()},n.\u0275dir=He({type:n,inputs:{name:"name",id:"id",labelPosition:"labelPosition",ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],ariaDescribedby:["aria-describedby","ariaDescribedby"],required:"required",checked:"checked"},outputs:{change:"change",toggleChange:"toggleChange"},features:[tt]}),n})(),_6=(()=>{class n extends Yet{constructor(e,i,r,o,s,a){super(e,i,r,o,s,a,"mat-slide-toggle-")}_createChangeEvent(e){return new class{constructor(t,e){this.source=t,this.checked=e}}(this,e)}_onChangeEvent(e){e.stopPropagation(),this.toggleChange.emit(),this.defaults.disableToggleValue?this._inputElement.nativeElement.checked=this.checked:(this.checked=this._inputElement.nativeElement.checked,this._emitChangeEvent())}_onInputClick(e){e.stopPropagation()}focus(e,i){i?this._focusMonitor.focusVia(this._inputElement,i,e):this._inputElement.nativeElement.focus(e)}_onLabelTextChange(){this._changeDetectorRef.detectChanges()}}return n.\u0275fac=function(e){return new(e||n)(M(Re),M(Fr),M(nn),vo("tabindex"),M(jet),M(Pi,8))},n.\u0275cmp=R({type:n,selectors:[["mat-slide-toggle"]],viewQuery:function(e,i){if(1&e&&ot(Het,5),2&e){let r;Ne(r=Le())&&(i._inputElement=r.first)}},hostAttrs:[1,"mat-slide-toggle"],hostVars:13,hostBindings:function(e,i){2&e&&(_s("id",i.id),ze("tabindex",null)("aria-label",null)("aria-labelledby",null)("name",null),et("mat-checked",i.checked)("mat-disabled",i.disabled)("mat-slide-toggle-label-before","before"==i.labelPosition)("_mat-animation-noopable",i._noopAnimations))},inputs:{disabled:"disabled",disableRipple:"disableRipple",color:"color",tabIndex:"tabIndex"},exportAs:["matSlideToggle"],features:[$t([Wet]),tt],ngContentSelectors:zet,decls:14,vars:20,consts:[[1,"mat-slide-toggle-label"],["label",""],[1,"mat-slide-toggle-bar"],["type","checkbox","role","switch",1,"mat-slide-toggle-input","cdk-visually-hidden",3,"id","required","tabIndex","checked","disabled","change","click"],["input",""],[1,"mat-slide-toggle-thumb-container"],[1,"mat-slide-toggle-thumb"],["mat-ripple","",1,"mat-slide-toggle-ripple","mat-focus-indicator",3,"matRippleTrigger","matRippleDisabled","matRippleCentered","matRippleRadius","matRippleAnimation"],[1,"mat-ripple-element","mat-slide-toggle-persistent-ripple"],[1,"mat-slide-toggle-content",3,"cdkObserveContent"],["labelContent",""],[2,"display","none"]],template:function(e,i){if(1&e&&(xi(),_(0,"label",0,1)(2,"span",2)(3,"input",3,4),P("change",function(o){return i._onChangeEvent(o)})("click",function(o){return i._onInputClick(o)}),v(),_(5,"span",5),O(6,"span",6),_(7,"span",7),O(8,"span",8),v()()(),_(9,"span",9,10),P("cdkObserveContent",function(){return i._onLabelTextChange()}),_(11,"span",11),A(12,"\xa0"),v(),Vn(13),v()()),2&e){let r=$e(1),o=$e(10);ze("for",i.inputId),C(2),et("mat-slide-toggle-bar-no-side-margin",!o.textContent||!o.textContent.trim()),C(1),y("id",i.inputId)("required",i.required)("tabIndex",i.tabIndex)("checked",i.checked)("disabled",i.disabled),ze("name",i.name)("aria-checked",i.checked)("aria-label",i.ariaLabel)("aria-labelledby",i.ariaLabelledby)("aria-describedby",i.ariaDescribedby),C(4),y("matRippleTrigger",r)("matRippleDisabled",i.disableRipple||i.disabled)("matRippleCentered",!0)("matRippleRadius",20)("matRippleAnimation",On(18,Uet,i._noopAnimations?0:150))}},dependencies:[Yo,wh],styles:['.mat-slide-toggle{display:inline-block;height:24px;max-width:100%;line-height:24px;white-space:nowrap;outline:none;-webkit-tap-highlight-color:rgba(0,0,0,0)}.mat-slide-toggle.mat-checked .mat-slide-toggle-thumb-container{transform:translate3d(16px, 0, 0)}[dir=rtl] .mat-slide-toggle.mat-checked .mat-slide-toggle-thumb-container{transform:translate3d(-16px, 0, 0)}.mat-slide-toggle.mat-disabled{opacity:.38}.mat-slide-toggle.mat-disabled .mat-slide-toggle-label,.mat-slide-toggle.mat-disabled .mat-slide-toggle-thumb-container{cursor:default}.mat-slide-toggle-label{-webkit-user-select:none;user-select:none;display:flex;flex:1;flex-direction:row;align-items:center;height:inherit;cursor:pointer}.mat-slide-toggle-content{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.mat-slide-toggle-label-before .mat-slide-toggle-label{order:1}.mat-slide-toggle-label-before .mat-slide-toggle-bar{order:2}[dir=rtl] .mat-slide-toggle-label-before .mat-slide-toggle-bar,.mat-slide-toggle-bar{margin-right:8px;margin-left:0}[dir=rtl] .mat-slide-toggle-bar,.mat-slide-toggle-label-before .mat-slide-toggle-bar{margin-left:8px;margin-right:0}.mat-slide-toggle-bar-no-side-margin{margin-left:0;margin-right:0}.mat-slide-toggle-thumb-container{position:absolute;z-index:1;width:20px;height:20px;top:-3px;left:0;transform:translate3d(0, 0, 0);transition:all 80ms linear;transition-property:transform}._mat-animation-noopable .mat-slide-toggle-thumb-container{transition:none}[dir=rtl] .mat-slide-toggle-thumb-container{left:auto;right:0}.mat-slide-toggle-thumb{height:20px;width:20px;border-radius:50%;display:block}.mat-slide-toggle-bar{position:relative;width:36px;height:14px;flex-shrink:0;border-radius:8px}.mat-slide-toggle-input{bottom:0;left:10px}[dir=rtl] .mat-slide-toggle-input{left:auto;right:10px}.mat-slide-toggle-bar,.mat-slide-toggle-thumb{transition:all 80ms linear;transition-property:background-color;transition-delay:50ms}._mat-animation-noopable .mat-slide-toggle-bar,._mat-animation-noopable .mat-slide-toggle-thumb{transition:none}.mat-slide-toggle .mat-slide-toggle-ripple{position:absolute;top:calc(50% - 20px);left:calc(50% - 20px);height:40px;width:40px;z-index:1;pointer-events:none}.mat-slide-toggle .mat-slide-toggle-ripple .mat-ripple-element:not(.mat-slide-toggle-persistent-ripple){opacity:.12}.mat-slide-toggle-persistent-ripple{width:100%;height:100%;transform:none}.mat-slide-toggle-bar:hover .mat-slide-toggle-persistent-ripple{opacity:.04}.mat-slide-toggle:not(.mat-disabled).cdk-keyboard-focused .mat-slide-toggle-persistent-ripple{opacity:.12}.mat-slide-toggle-persistent-ripple,.mat-slide-toggle.mat-disabled .mat-slide-toggle-bar:hover .mat-slide-toggle-persistent-ripple{opacity:0}@media(hover: none){.mat-slide-toggle-bar:hover .mat-slide-toggle-persistent-ripple{display:none}}.mat-slide-toggle-input:focus~.mat-slide-toggle-thumb-container .mat-focus-indicator::before{content:""}.cdk-high-contrast-active .mat-slide-toggle-thumb,.cdk-high-contrast-active .mat-slide-toggle-bar{border:1px solid}'],encapsulation:2,changeDetection:0}),n})(),Xet={provide:Lo,useExisting:Jn(()=>Qet),multi:!0},Qet=(()=>{class n extends gw{}return n.\u0275fac=function(){let t;return function(i){return(t||(t=pi(n)))(i||n)}}(),n.\u0275dir=He({type:n,selectors:[["mat-slide-toggle","required","","formControlName",""],["mat-slide-toggle","required","","formControl",""],["mat-slide-toggle","required","","ngModel",""]],features:[$t([Xet]),tt]}),n})(),Fme=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),Nme=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Fme,_l,ln,od,Fme,ln]}),n})();function Zet(n,t){1&n&&O(0,"mat-icon",3)}var Lme=(()=>{class n{constructor(){this.onRegexFilterValueChange=new G}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["npmi-annotations-search-component"]],hostVars:2,hostBindings:function(e,i){2&e&&et("valid",i.isRegexFilterValid)},inputs:{regexFilterValue:"regexFilterValue",isRegexFilterValid:"isRegexFilterValid"},outputs:{onRegexFilterValueChange:"onRegexFilterValueChange"},decls:3,vars:2,consts:[["svgIcon","search_24px"],["autocomplete","off","placeholder","Filter Annotations",3,"value","input"],["svgIcon","error_24px","class","error-icon","matTooltip","Invalid regex filter. The result may be stale.",4,"ngIf"],["svgIcon","error_24px","matTooltip","Invalid regex filter. The result may be stale.",1,"error-icon"]],template:function(e,i){1&e&&(O(0,"mat-icon",0),_(1,"input",1),P("input",function(o){return i.onRegexFilterValueChange.emit(o.target.value)}),v(),E(2,Zet,1,0,"mat-icon",2)),2&e&&(C(1),y("value",i.regexFilterValue),C(1),y("ngIf",!i.isRegexFilterValid))},dependencies:[Be,Gt],styles:["[_nghost-%COMP%]{display:flex;position:relative}[_nghost-%COMP%]:not(.valid){color:#c62828}[_nghost-%COMP%]:not(.valid)   input[_ngcontent-%COMP%]{caret-color:currentColor}[_nghost-%COMP%]:not(.valid)   .error-icon[_ngcontent-%COMP%]{color:#c62828;position:absolute;right:0}"],changeDetection:0}),n})(),Bme=(()=>{class n{constructor(e){this.store=e,this.annotationsFilter$=this.store.select(Qb),this.isAnnotationsFilterValid$=this.annotationsFilter$.pipe(L(i=>{try{return new RegExp(i),!0}catch{return!1}}))}filterChange(e){this.store.dispatch(jb({regex:e}))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["npmi-annotations-search"]],decls:3,vars:6,consts:[[3,"regexFilterValue","isRegexFilterValid","onRegexFilterValueChange"]],template:function(e,i){1&e&&(_(0,"npmi-annotations-search-component",0),P("onRegexFilterValueChange",function(o){return i.filterChange(o)}),B(1,"async"),B(2,"async"),v()),2&e&&y("regexFilterValue",U(1,2,i.annotationsFilter$))("isRegexFilterValid",U(2,4,i.isAnnotationsFilterValid$))},dependencies:[Lme,Ge],encapsulation:2,changeDetection:0}),n})();function ett(n,t){if(1&n){let e=Pe();sn(0),_(1,"button",5),P("click",function(){oe(e);let r=S();return se(r.onFlagAnnotations.emit(r.selectedAnnotations))}),O(2,"mat-icon",6),v(),_(3,"button",7),P("click",function(){oe(e);let r=S();return se(r.onHideAnnotations.emit(r.selectedAnnotations))}),O(4,"mat-icon",8),v(),an()}if(2&n){let e=S();C(1),y("disabled",0===e.selectedAnnotations.length),C(2),y("disabled",0===e.selectedAnnotations.length)}}function ttt(n,t){if(1&n){let e=Pe();sn(0),_(1,"mat-slide-toggle",9),P("change",function(){return oe(e),se(S().onToggleShowCounts.emit())}),A(2," Sample Count "),v(),_(3,"mat-slide-toggle",10),P("change",function(){return oe(e),se(S().onToggleShowHidden.emit())}),A(4," Show Hidden "),v(),O(5,"npmi-annotations-search"),an()}if(2&n){let e=S();C(1),y("checked",e.showCounts),C(2),y("checked",e.showHidden)}}var Vme=(()=>{class n{constructor(){this.onFlagAnnotations=new G,this.onHideAnnotations=new G,this.onToggleExpanded=new G,this.onToggleShowCounts=new G,this.onToggleShowHidden=new G}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["npmi-annotations-list-toolbar-component"]],inputs:{numAnnotations:"numAnnotations",expanded:"expanded",selectedAnnotations:"selectedAnnotations",annotationsExpanded:"annotationsExpanded",showCounts:"showCounts",showHidden:"showHidden"},outputs:{onFlagAnnotations:"onFlagAnnotations",onHideAnnotations:"onHideAnnotations",onToggleExpanded:"onToggleExpanded",onToggleShowCounts:"onToggleShowCounts",onToggleShowHidden:"onToggleShowHidden"},decls:7,vars:4,consts:function(){let t,e,i;return t=$localize`:Label for a button that hides/shows the annotations list.␟b3603ba33e5308dd8c5e805e508b2f7233df89d4␟7336374413056342492:Hides/Shows the Annotations List`,e=$localize`:Label for a button that flags selected annotations.␟5692ad8831038a90c5863a1e9adf9748cac3cad8␟2244099891313336595:Flag Selected Annotations`,i=$localize`:Label for a button that hides selected annotations.␟0342cdb3358fa8e3fa27220a8258a7287430b70f␟5462832391092087485:Hide Selected Annotations`,[[1,"annotations-title-container"],[1,"annotations-title"],[4,"ngIf"],["mat-icon-button","","aria-label",t,1,"expand-button",3,"click"],[3,"svgIcon"],["mat-icon-button","","aria-label",e,"title","Flagging annotations adds them to your investigation results, which can later be exported.",3,"disabled","click"],["svgIcon","flag_24px"],["mat-icon-button","","aria-label",i,"title","Removing non-critical annotations unclutters the view. Removed annotations are removed from all visualizations.",3,"disabled","click"],["svgIcon","visibility_off_24px"],["title","Hides and shows the sample count where applicable (how many samples belong to a category).",1,"show-toggle",3,"checked","change"],["title","Hides and shows hidden annotations in all visualizations.",1,"show-toggle",3,"checked","change"]]},template:function(e,i){1&e&&(_(0,"div",0)(1,"h3",1),A(2),v(),E(3,ett,5,2,"ng-container",2),v(),E(4,ttt,6,2,"ng-container",2),_(5,"button",3),P("click",function(){return i.onToggleExpanded.emit()}),O(6,"mat-icon",4),v()),2&e&&(C(2),je("Annotations (",i.numAnnotations,")"),C(1),y("ngIf",i.expanded),C(1),y("ngIf",i.expanded),C(2),y("svgIcon",i.expanded?"expand_less_24px":"expand_more_24px"))},dependencies:[Be,Gt,_n,_6,Bme],styles:["[_nghost-%COMP%]{align-items:center;box-sizing:border-box;display:flex;flex-direction:row;padding:0 16px;width:100%}.annotations-title[_ngcontent-%COMP%]{display:inline;font-size:.9em;font-weight:500;padding-right:10px}.annotations-title-container[_ngcontent-%COMP%]{align-items:center;display:flex;flex-wrap:nowrap;flex:1 1;height:42px}.show-toggle[_ngcontent-%COMP%]{font-size:.9em;margin-right:.8em}"],changeDetection:0}),n})(),Hme=(()=>{class n{constructor(e){this.store=e,this.selectedAnnotations$=this.store.select(vc),this.annotationsExpanded$=this.store.select(UF),this.showCounts$=this.store.select(jF),this.showHidden$=this.store.select(Zb),this.annotationsFilter$=this.store.select(Qb),this.isAnnotationsFilterValid$=this.annotationsFilter$.pipe(L(i=>{try{return Boolean(new RegExp(i))}catch{return!1}}))}filterChange(e){this.store.dispatch(jb({regex:e}))}flagAnnotations(e){this.store.dispatch(EF({annotations:e}))}hideAnnotations(e){this.store.dispatch(TF({annotations:e}))}toggleExpanded(){this.store.dispatch(RF())}toggleShowCounts(){this.store.dispatch(OF())}toggleShowHidden(){this.store.dispatch(kF())}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["npmi-annotations-list-toolbar"]],inputs:{numAnnotations:"numAnnotations",expanded:"expanded"},decls:5,vars:14,consts:[[3,"numAnnotations","expanded","selectedAnnotations","annotationsExpanded","showCounts","showHidden","onFlagAnnotations","onHideAnnotations","onToggleExpanded","onToggleShowCounts","onToggleShowHidden"]],template:function(e,i){1&e&&(_(0,"npmi-annotations-list-toolbar-component",0),P("onFlagAnnotations",function(o){return i.flagAnnotations(o)})("onHideAnnotations",function(o){return i.hideAnnotations(o)})("onToggleExpanded",function(){return i.toggleExpanded()})("onToggleShowCounts",function(){return i.toggleShowCounts()})("onToggleShowHidden",function(){return i.toggleShowHidden()}),B(1,"async"),B(2,"async"),B(3,"async"),B(4,"async"),v()),2&e&&y("numAnnotations",i.numAnnotations)("expanded",i.expanded)("selectedAnnotations",U(1,6,i.selectedAnnotations$))("annotationsExpanded",U(2,8,i.annotationsExpanded$))("showCounts",U(3,10,i.showCounts$))("showHidden",U(4,12,i.showHidden$))},dependencies:[Vme,Ge],encapsulation:2,changeDetection:0}),n})();function rtt(n,t){if(1&n&&O(0,"mat-icon",8),2&n){let e=S(2);y("svgIcon",e.sort.order===e.SortOrder.DESCENDING?"arrow_downward_24px":"arrow_upward_24px")("ngClass",e.sort.order===e.SortOrder.DESCENDING?"down-icon":"up-icon")}}function ott(n,t){if(1&n){let e=Pe();_(0,"div",4)(1,"div",5)(2,"div",6),P("click",function(){let o=oe(e).$implicit;return se(S().onChangeSort.emit(o))}),A(3),E(4,rtt,1,2,"mat-icon",7),v()()()}if(2&n){let e=t.$implicit,i=S();C(3),je(" ",i.stripMetric(e)," "),C(1),y("ngIf",e===i.sort.metric)}}var Ume=(()=>{class n{constructor(){this.onChangeSort=new G,this.onAllAnnotationsToggled=new G,this.SortOrder=$r}stripMetric(e){return Ss(e)}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["npmi-annotations-list-header-component"]],inputs:{numAnnotations:"numAnnotations",selectedAnnotations:"selectedAnnotations",activeMetrics:"activeMetrics",sort:"sort"},outputs:{onChangeSort:"onChangeSort",onAllAnnotationsToggled:"onAllAnnotationsToggled"},decls:4,vars:2,consts:[[1,"toggle-all-container"],[3,"checked","change"],[1,"annotations-header-containers"],["class","header-column",4,"ngFor","ngForOf"],[1,"header-column"],[1,"header-container"],["tabindex","0","role","button","title","Change the sort by clicking any of the metrics.",1,"header-clickable",3,"click"],["class","sort-icon",3,"svgIcon","ngClass",4,"ngIf"],[1,"sort-icon",3,"svgIcon","ngClass"]],template:function(e,i){1&e&&(_(0,"div",0)(1,"mat-checkbox",1),P("change",function(o){return i.onAllAnnotationsToggled.emit(o.checked)}),v()(),_(2,"div",2),E(3,ott,5,2,"div",3),v()),2&e&&(C(1),y("checked",i.selectedAnnotations.length===i.numAnnotations),C(2),y("ngForOf",i.activeMetrics))},dependencies:[Fn,dn,Be,yl,Gt],styles:["[_nghost-%COMP%]{border-bottom:2px solid #ebebeb;display:flex;height:28px;align-items:flex-end;margin-top:8px}.annotations-header-containers[_ngcontent-%COMP%]{display:flex;font-size:.9em;font-weight:500;flex-grow:1}.header-column[_ngcontent-%COMP%]{flex:1 1}.header-container[_ngcontent-%COMP%]{display:inline-block}.header-clickable[_ngcontent-%COMP%]{cursor:pointer;display:flex;outline:none}.toggle-all-container[_ngcontent-%COMP%]{margin-left:10px;width:90px}.sort-icon[_ngcontent-%COMP%]{height:16px}"],changeDetection:0}),n})(),zme=(()=>{class n{constructor(e){this.store=e,this.selectedAnnotations$=this.store.select(vc),this.annotationSort$=this.store.select(Kb)}changeSort(e){this.store.dispatch(AF({metric:e}))}allAnnotationsToggled(e){this.store.dispatch(RE(e?{annotations:Object.keys(this.annotations)}:{annotations:[]}))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["npmi-annotations-list-header"]],inputs:{numAnnotations:"numAnnotations",annotations:"annotations",activeMetrics:"activeMetrics"},decls:3,vars:8,consts:[[3,"numAnnotations","selectedAnnotations","sort","activeMetrics","onChangeSort","onAllAnnotationsToggled"]],template:function(e,i){1&e&&(_(0,"npmi-annotations-list-header-component",0),P("onChangeSort",function(o){return i.changeSort(o)})("onAllAnnotationsToggled",function(o){return i.allAnnotationsToggled(o)}),B(1,"async"),B(2,"async"),v()),2&e&&y("numAnnotations",i.numAnnotations)("selectedAnnotations",U(1,4,i.selectedAnnotations$))("sort",U(2,6,i.annotationSort$))("activeMetrics",i.activeMetrics)},dependencies:[Ume,Ge],encapsulation:2,changeDetection:0}),n})(),ltt=["glyph"],jme=(()=>{class n{ngAfterViewInit(){this.svg=bo(this.glyphSVG.nativeElement),this.mainContainer=this.svg.append("g"),this.draw()}draw(){"circle"==this.shape?this.mainContainer.append("circle").attr("fill",this.color).attr("stroke","black").attr("cx",5).attr("cy",5).attr("r",5):"bar"==this.shape?this.mainContainer.append("rect").attr("fill",this.color).attr("x",0).attr("y",0).attr("width",10).attr("height",10):"runIndicator"==this.shape&&this.mainContainer.append("g").append("path").attr("fill",this.color).attr("stroke","black").attr("d","M 2 0 L 10 0 L 7 5 L 10 10 L 2 10 Z")}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["npmi-legend-element"]],viewQuery:function(e,i){if(1&e&&ot(ltt,7,Re),2&e){let r;Ne(r=Le())&&(i.glyphSVG=r.first)}},inputs:{text:"text",color:"color",shape:"shape"},decls:4,vars:1,consts:[[1,"glyph"],["glyph",""],[1,"legend-element-title"]],template:function(e,i){1&e&&(In(),O(0,"svg",0,1),Js(),_(2,"div",2),A(3),v()),2&e&&(C(3),yt(i.text))},styles:["[_nghost-%COMP%]{align-items:center;display:flex;padding-right:10px}.legend-element-title[_ngcontent-%COMP%]{font-size:.8em;padding-left:5px}.glyph[_ngcontent-%COMP%]{width:10px;height:10px}"],changeDetection:0}),n})(),Gme=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["npmi-annotations-list-legend"]],decls:4,vars:0,consts:[["text","run indicator","color","rgb(0,0,0)","shape","runIndicator"],["text","positive correlation","color","rgb(109, 174, 213)","shape","bar"],["text","negative correlation","color","rgb(249, 105, 76)","shape","bar"],["text","sample count","color","rgb(151, 151, 151)","shape","circle"]],template:function(e,i){1&e&&O(0,"npmi-legend-element",0)(1,"npmi-legend-element",1)(2,"npmi-legend-element",2)(3,"npmi-legend-element",3)},dependencies:[jme],styles:["[_nghost-%COMP%]{display:flex;padding:0 16px}"]}),n})(),dtt=["chart"],ptt=["hintClip"];function htt(n,t){1&n&&O(0,"mat-icon",12)}function ftt(n,t){1&n&&O(0,"mat-icon",13)}function mtt(n,t){if(1&n&&O(0,"mat-icon",14),2&n){let e=S();y("svgIcon",e.sort.order===e.SortOrder.SIMILAR?"arrow_downward_24px":"arrow_upward_24px")("ngClass",e.sort.order===e.SortOrder.SIMILAR?"down-icon":"up-icon")}}var Wme=(()=>{class n{constructor(){this.selected=!1,this.onShowSimilarAnnotations=new G,this.SortOrder=$r,this.width=10,this.chartWidth=10,this.chartHeight=10,this.maxDotRadius=10,this.countDotOffset=70,this.countTextPadding=2,this.margin={top:0,right:0,bottom:0,left:100},this.strokeColor="#fff",this.textClass="default-text",this.runs=[]}onResize(e){this.redraw()}ngAfterViewInit(){this.svg=bo(this.annotationContainer.nativeElement).select("svg"),this.xScale=Sy().padding(0),this.yScale=Sy().padding(0),this.sizeScale=Qo().domain([0,1]),this.countSizeScale=Qo().range([2,this.maxDotRadius]),this.mainContainer=this.svg.append("g").attr("transform",`translate(${this.margin.left}, ${this.margin.top})`),this.barsGroup=this.mainContainer.append("g"),this.countDotsGroup=this.mainContainer.append("g"),this.textsGroup=this.mainContainer.append("g"),this.countTextsGroup=this.mainContainer.append("g"),this.runHintGroup=this.svg.append("g"),this.redraw()}ngOnChanges(e){this.svg&&this.redraw()}redraw(){this.selected=this.selectedAnnotations.includes(this.annotation),this.updateDimensions(),this.setTextClass(),this.updateAxes(),this.draw()}updateDimensions(){let e=new Set;this.data.forEach(i=>{e.add(i.run)}),this.runs=[...e],this.svg.style("height",this.numActiveRuns*this.runHeight+"px"),this.chartHeight=this.runs.length*this.runHeight-this.margin.top-this.margin.bottom,this.width=this.annotationContainer.nativeElement.clientWidth||10,this.chartWidth=this.width-this.margin.left-this.margin.right}setTextClass(){this.textClass="default-text",this.flaggedAnnotations.includes(this.annotation)?this.textClass="flag-text":this.hiddenAnnotations.includes(this.annotation)&&(this.textClass="hidden-text")}updateAxes(){this.xScale.rangeRound([0,this.chartWidth-this.chartWidth/this.activeMetrics.length]).domain(this.activeMetrics.map(e=>Ss(e))),this.yScale.rangeRound([0,this.chartHeight-this.runHeight]).domain(this.runs),this.sizeScale.range([0,this.chartWidth/this.activeMetrics.length]),this.countSizeScale.domain([0,this.maxCount])}draw(){this.drawRunIndicators(),this.drawRunHintTexts(),this.drawBars(),this.drawTexts(),this.showCounts?(this.drawCountDots(),this.drawCountTexts()):(this.countDotsGroup.selectAll(".count-dot").remove(),this.countTextsGroup.selectAll(".count-background-text").remove(),this.countTextsGroup.selectAll(".count-text").remove())}drawRunIndicators(){bo(this.clipPathElement.nativeElement).select("rect").attr("width",this.margin.left-30).attr("height",this.chartHeight);let e=this.runHintGroup.selectAll(".hint").data(this.runs),i=e.enter().append("g").attr("class","hint");i.append("path").attr("d","M 0 0 L 15 0 L 10 10 L 15 20 L 0 20 Z"),i.merge(e).attr("transform",function(r){return`translate(10, ${this.yScale(r)+5})`}.bind(this)).attr("fill",function(r){return this.colorScale(r)}.bind(this)),e.exit().remove()}drawRunHintTexts(){let e=this.runHintGroup.selectAll(".hint-text").data(this.runs);e.enter().append("text").attr("x",25).attr("font-size","10px").attr("alignment-baseline","middle").attr("clip-path","url(#hint-clip)").merge(e).attr("y",function(r){return this.yScale(r)+15}.bind(this)).attr("class",`hint-text ${this.textClass}`).text(r=>this.runIdToRuns.get(r)?.name||""),e.exit().remove()}drawBars(){let e=this.barsGroup.selectAll(".bar").data(this.data);e.enter().append("rect").attr("class","bar").attr("height",20).merge(e).attr("fill",r=>null===r.nPMIValue?"":r.nPMIValue>=0?tj(r.nPMIValue):ij(-1*r.nPMIValue)).attr("x",function(r){return this.xScale(r.metric)}.bind(this)).attr("y",function(r){return this.yScale(r.run)+5}.bind(this)).attr("width",function(r){return null===r.nPMIValue?0:this.sizeScale(Math.abs(r.nPMIValue))}.bind(this)),e.exit().remove()}drawCountDots(){let e=this.countDotsGroup.selectAll(".count-dot").data(this.data);e.enter().append("circle").attr("class","count-dot").attr("stroke","black").merge(e).attr("fill",function(r){return null===r.countValue?"":nj(r.countValue/this.maxCount)}.bind(this)).attr("cx",function(r){return this.xScale(r.metric)+this.countDotOffset}.bind(this)).attr("cy",function(r){return this.yScale(r.run)+this.runHeight/2}.bind(this)).attr("r",function(r){return null===r.countValue?0:this.countSizeScale(r.countValue)}.bind(this)),e.exit().remove()}drawTexts(){let e=this.textsGroup.selectAll(".npmi-background-text").data(this.data);e.enter().append("text").attr("class","npmi-background-text").attr("stroke-width",3).attr("stroke-linejoin","round").attr("stroke",this.strokeColor).attr("font-size","13px").attr("alignment-baseline","middle").merge(e).attr("x",function(s){return this.xScale(s.metric)+5}.bind(this)).attr("y",function(s){return this.yScale(s.run)+this.runHeight/2}.bind(this)).text(s=>null===s.nPMIValue?"null":Math.round(1e3*(s.nPMIValue+Number.EPSILON))/1e3),e.exit().remove();let r=this.textsGroup.selectAll(".npmi-text").data(this.data);r.enter().append("text").attr("class","npmi-text").attr("font-size","13px").attr("alignment-baseline","middle").merge(r).attr("x",function(s){return this.xScale(s.metric)+5}.bind(this)).attr("y",function(s){return this.yScale(s.run)+this.runHeight/2}.bind(this)).text(s=>null===s.nPMIValue?"null":Math.round(1e3*(s.nPMIValue+Number.EPSILON))/1e3),r.exit().remove()}drawCountTexts(){let e=this.countTextsGroup.selectAll(".count-background-text").data(this.data);e.enter().append("text").attr("class","count-background-text").attr("stroke-width",3).attr("stroke-linejoin","round").attr("stroke",this.strokeColor).attr("font-size","10px").attr("alignment-baseline","middle").merge(e).attr("x",function(s){return this.xScale(s.metric)+this.countDotOffset+this.countTextPadding+this.maxDotRadius}.bind(this)).attr("y",function(s){return this.yScale(s.run)+this.runHeight/2}.bind(this)).text(s=>null===s.countValue?"":Intl.NumberFormat().format(s.countValue)),e.exit().remove();let r=this.countTextsGroup.selectAll(".count-text").data(this.data);r.enter().append("text").attr("class","count-text").attr("font-size","10px").attr("alignment-baseline","middle").merge(r).attr("x",function(s){return this.xScale(s.metric)+this.countDotOffset+this.countTextPadding+this.maxDotRadius}.bind(this)).attr("y",function(s){return this.yScale(s.run)+this.runHeight/2}.bind(this)).text(s=>null===s.countValue?"":Intl.NumberFormat().format(s.countValue)),r.exit().remove()}similaritySort(e){this.hasEmbedding&&(e.stopPropagation(),this.onShowSimilarAnnotations.emit())}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["annotation-component"]],viewQuery:function(e,i){if(1&e&&(ot(dtt,7,Re),ot(ptt,7,Re)),2&e){let r;Ne(r=Le())&&(i.annotationContainer=r.first),Ne(r=Le())&&(i.clipPathElement=r.first)}},hostVars:2,hostBindings:function(e,i){1&e&&P("resize",function(){return i.onResize()},0,Wx),2&e&&et("selected-row",i.selected)},inputs:{data:"data",maxCount:"maxCount",selectedAnnotations:"selectedAnnotations",flaggedAnnotations:"flaggedAnnotations",hiddenAnnotations:"hiddenAnnotations",activeMetrics:"activeMetrics",numActiveRuns:"numActiveRuns",showCounts:"showCounts",annotation:"annotation",runHeight:"runHeight",hasEmbedding:"hasEmbedding",sort:"sort",sidebarWidth:"sidebarWidth",colorScale:"colorScale",runIdToRuns:"runIdToRuns"},outputs:{onShowSimilarAnnotations:"onShowSimilarAnnotations"},features:[Ft],decls:14,vars:10,consts:[[1,"annotation-title"],[1,"annotation-checkbox",3,"checked","click"],[1,"annotation-button",3,"ngClass","click"],["class","flagged-icon","svgIcon","flag_24px",4,"ngIf"],["class","hidden-icon","svgIcon","visibility_off_24px",4,"ngIf"],["class","annotation-icon",3,"svgIcon","ngClass",4,"ngIf"],[1,"chart-div"],["chart",""],[1,"chart-svg"],["id","hint-clip"],["hintClip",""],["x","0","y","0"],["svgIcon","flag_24px",1,"flagged-icon"],["svgIcon","visibility_off_24px",1,"hidden-icon"],[1,"annotation-icon",3,"svgIcon","ngClass"]],template:function(e,i){1&e&&(_(0,"div",0)(1,"mat-checkbox",1),P("click",function(o){return o.preventDefault()}),v(),_(2,"button",2),P("click",function(o){return i.similaritySort(o)}),A(3),v(),E(4,htt,1,0,"mat-icon",3),E(5,ftt,1,0,"mat-icon",4),E(6,mtt,1,2,"mat-icon",5),v(),_(7,"div",6,7),In(),_(9,"svg",8)(10,"defs")(11,"clipPath",9,10),O(13,"rect",11),v()()()()),2&e&&(et("flagged-annotation",i.flaggedAnnotations.includes(i.annotation))("hidden-annotation",i.hiddenAnnotations.includes(i.annotation)&&!i.flaggedAnnotations.includes(i.annotation)),C(1),y("checked",i.selectedAnnotations.includes(i.annotation)),C(1),y("ngClass",i.hasEmbedding?"clickable-annotation":""),C(1),je(" ",i.annotation," "),C(1),y("ngIf",i.flaggedAnnotations.includes(i.annotation)),C(1),y("ngIf",i.hiddenAnnotations.includes(i.annotation)),C(1),y("ngIf",i.annotation===i.sort.metric))},dependencies:[Fn,Be,yl,Gt],styles:[":host{padding-top:5px}.annotation-title{align-items:center;display:flex;font-size:13px;height:20px;padding:0 10px;user-select:none}.selected-row{background-color:#e0e0e0;display:block}.flagged-annotation{color:#f57c00}.hidden-annotation{color:#757575}.annotation-checkbox{padding-right:5px}.flagged-icon{transform:scale(0.6)}.hidden-icon{transform:scale(0.6)}.annotation-icon{transform:scale(0.6)}.chart-div{border-bottom:1px solid #ebebeb}.chart-svg{width:100%;user-select:none}.default-text{fill:#000}.flag-text{fill:#f57c00}.hidden-text{fill:#757575}.clickable-annotation{cursor:pointer}button{all:unset}\n"],encapsulation:2,changeDetection:0}),n})(),qme=(()=>{class n{constructor(e){this.store=e,this.sort$=this.store.select(Kb),this.flaggedAnnotations$=this.store.select(VF),this.hiddenAnnotations$=this.store.select(Xb),this.selectedAnnotations$=this.store.select(vc),this.showCounts$=this.store.select(jF),this.sidebarWidth$=this.store.select(Of),this.runColorScale$=this.store.select(nc).pipe(L(i=>r=>{if(!i.hasOwnProperty(r))throw new Error(`[Color scale] unknown runId: ${r}.`);return i[r]})),this.runIdToRuns$=this.store.select(qI)}showSimilarAnnotations(){this.store.dispatch(IF({annotation:this.annotation}))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["npmi-annotation"]],inputs:{data:"data",maxCount:"maxCount",activeMetrics:"activeMetrics",numActiveRuns:"numActiveRuns",annotation:"annotation",runHeight:"runHeight",hasEmbedding:"hasEmbedding"},decls:9,vars:31,consts:[[3,"data","maxCount","activeMetrics","numActiveRuns","annotation","runHeight","hasEmbedding","sort","selectedAnnotations","flaggedAnnotations","hiddenAnnotations","showCounts","sidebarWidth","colorScale","runIdToRuns","onShowSimilarAnnotations"]],template:function(e,i){1&e&&(_(0,"annotation-component",0),P("onShowSimilarAnnotations",function(){return i.showSimilarAnnotations()}),B(1,"async"),B(2,"async"),B(3,"async"),B(4,"async"),B(5,"async"),B(6,"async"),B(7,"async"),B(8,"async"),v()),2&e&&y("data",i.data)("maxCount",i.maxCount)("activeMetrics",i.activeMetrics)("numActiveRuns",i.numActiveRuns)("annotation",i.annotation)("runHeight",i.runHeight)("hasEmbedding",i.hasEmbedding)("sort",U(1,15,i.sort$))("selectedAnnotations",U(2,17,i.selectedAnnotations$))("flaggedAnnotations",U(3,19,i.flaggedAnnotations$))("hiddenAnnotations",U(4,21,i.hiddenAnnotations$))("showCounts",U(5,23,i.showCounts$))("sidebarWidth",U(6,25,i.sidebarWidth$))("colorScale",U(7,27,i.runColorScale$))("runIdToRuns",U(8,29,i.runIdToRuns$))},dependencies:[Wme,Ge],encapsulation:2,changeDetection:0}),n})();function vtt(n,t){if(1&n){let e=Pe();_(0,"npmi-annotation",5),P("click",function(r){let s=oe(e).$implicit;return se(S(2).rowClicked(r,s))}),v()}if(2&n){let e=t.$implicit,i=S(2);y("data",i.annotations[e])("activeMetrics",i.activeMetrics)("numActiveRuns",i.numActiveRuns)("maxCount",i.maxCount)("annotation",e)("runHeight",i.runHeight)("hasEmbedding",i.embeddingData&&void 0!==i.embeddingData[e])}}function ytt(n,t){if(1&n&&(sn(0),O(1,"npmi-annotations-list-legend")(2,"npmi-annotations-list-header",2),_(3,"cdk-virtual-scroll-viewport",3),E(4,vtt,1,7,"npmi-annotation",4),v(),an()),2&n){let e=S();C(2),y("annotations",e.annotations)("numAnnotations",e.numAnnotations)("activeMetrics",e.activeMetrics),C(1),Zi("itemSize",e.numActiveRuns*e.runHeight+25),C(1),y("cdkVirtualForOf",e.sortedAnnotations)}}var Yme=(()=>{class n{constructor(){this.onRowClick=new G,this.runHeight=30}rowClicked(e,i){if(e.shiftKey){let r=this.sortedAnnotations.indexOf(i);if(0===this.selectedAnnotations.length)this.onRowClick.emit(this.sortedAnnotations.slice(0,r+1));else{let s=this.sortedAnnotations.indexOf(this.selectedAnnotations[this.selectedAnnotations.length-1]);this.onRowClick.emit(s<r?this.sortedAnnotations.slice(s,r+1):this.sortedAnnotations.slice(r,s+1))}}else this.onRowClick.emit([i])}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["annotations-list-component"]],inputs:{annotations:"annotations",embeddingData:"embeddingData",annotationsExpanded:"annotationsExpanded",numAnnotations:"numAnnotations",annotationSort:"annotationSort",activeMetrics:"activeMetrics",numActiveRuns:"numActiveRuns",sortedAnnotations:"sortedAnnotations",selectedAnnotations:"selectedAnnotations",maxCount:"maxCount"},outputs:{onRowClick:"onRowClick"},decls:2,vars:3,consts:[[3,"numAnnotations","expanded"],[4,"ngIf"],[3,"annotations","numAnnotations","activeMetrics"],["minBufferPx","300","maxBufferPx","600",1,"annotation-rows",3,"itemSize"],[3,"data","activeMetrics","numActiveRuns","maxCount","annotation","runHeight","hasEmbedding","click",4,"cdkVirtualFor","cdkVirtualForOf"],[3,"data","activeMetrics","numActiveRuns","maxCount","annotation","runHeight","hasEmbedding","click"]],template:function(e,i){1&e&&(O(0,"npmi-annotations-list-toolbar",0),E(1,ytt,5,5,"ng-container",1)),2&e&&(y("numAnnotations",i.numAnnotations)("expanded",i.annotationsExpanded),C(1),y("ngIf",i.annotationsExpanded))},dependencies:[Be,Hme,zme,Gme,b2,x2,eg,qme],styles:["[_nghost-%COMP%]{background-color:#fff;border:1px solid #ebebeb;display:flex;flex-direction:column;height:calc(100% - 2px);width:calc(100% - 2px)}.annotation-rows[_ngcontent-%COMP%]{display:flex;flex-direction:column;flex:1 1;overflow-y:auto}"],changeDetection:0}),n})(),YF=(()=>{class n{constructor(e){this.store=e,this.annotationsExpanded$=this.store.pipe(vt(UF)),this.activeRuns$=this.store.pipe(vt(oo)).pipe(L(i=>i?Array.from(i.entries()).filter(r=>r[1]).map(r=>r[0]):[])),this.embeddingData$=this.store.pipe(vt(BF)),this.numActiveRuns$=this.activeRuns$.pipe(L(i=>i.length)),this.activeMetrics$=Lt([this.store.select(Rf),this.activeRuns$,this.store.select(Il)]).pipe(L(([i,r,o])=>{let s=[];for(let a of r)i[a]&&(s=s.concat(i[a].filter(l=>Vb(l))));return s=[...new Set([...Object.keys(o),...s])],s})),this.visibleAnnotations$=Lt([this.store.select(Pf),this.store.select(Xb),this.store.select(Zb)]).pipe(L(([i,r,o])=>qF(i,r,o))),this.filteredAnnotations$=Lt([this.visibleAnnotations$,this.store.select(HF),this.store.select(Il),this.activeRuns$,this.activeMetrics$,this.store.select(Qb)]).pipe(L(([i,r,o,s,a,l])=>function(n,t,e,i,r,o){let s={},a=new Set(t),l=new Set(r.map(u=>Ss(u))),c=new RegExp(o,"i");return Object.entries(n).forEach(u=>{if(!c.test(u[0]))return;let d=u[1];d=d.filter(p=>a.has(p.run)&&l.has(p.metric)),function(n,t,e){return n.every(i=>{if(i.kind===mu.OPERATOR)return!0;let r=t[i.metric];return void 0===r||e.some(o=>o.metric===Ss(i.metric)&&(null===o.nPMIValue?r.includeNaN:o.nPMIValue<=r.max&&o.nPMIValue>=r.min))})}(e,i,d)&&0!==d.length&&(s[u[0]]=d)}),s}(i,s,r,o,a,l))).pipe(Ts()),this.numAnnotations$=this.filteredAnnotations$.pipe(L(i=>Object.keys(i).length)),this.sortedAnnotations$=Lt([this.filteredAnnotations$,this.store.pipe(vt(Kb)),this.embeddingData$]).pipe(L(([i,r,o])=>function(n,t,e){let i=Object.keys(n),r=t.order===$r.DISSIMILAR||t.order===$r.SIMILAR;if(""===t.metric||(void 0===e||void 0===e.points[t.metric])&&r)return i;let o=r?function(n,t,e){let i={},r=Number.POSITIVE_INFINITY,o=Number.NEGATIVE_INFINITY;e.order===$r.SIMILAR&&(r=Number.NEGATIVE_INFINITY,o=Number.POSITIVE_INFINITY);for(let s of n)i[s]=s===e.metric?r:void 0===t.points[s]?o:t.points[s].vector?Vet(t.points[e.metric].vector,t.points[s].vector,o):o;return i}(i,e,t):function(n,t,e){let i=Ss(e.metric),r={};if(e.order===$r.DESCENDING)for(let o of n)r[o]=Math.max(...t[o].filter(s=>s.metric===i).map(s=>null===s.nPMIValue?-1/0:s.nPMIValue));else for(let o of n)r[o]=Math.min(...t[o].filter(s=>s.metric===i).map(s=>null===s.nPMIValue?1/0:s.nPMIValue));return r}(i,n,t);return function(n,t,e){return n.sort(e?(i,r)=>t[i]-t[r]:(i,r)=>t[r]-t[i])}(i,o,t.order===$r.ASCENDNG||t.order===$r.SIMILAR)}(i,r,o))),this.selectedAnnotations$=this.store.pipe(vt(vc)),this.maxCount$=this.filteredAnnotations$.pipe(L(i=>{let r=0;return Object.values(i).forEach(o=>{o.forEach(s=>{s.countValue&&(r=Math.max(r,s.countValue))})}),r}))}rowClicked(e){this.store.dispatch(wF({annotations:e}))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["npmi-annotations-list"]],decls:10,vars:27,consts:[[3,"annotations","embeddingData","annotationsExpanded","numAnnotations","activeMetrics","numActiveRuns","sortedAnnotations","selectedAnnotations","maxCount","onRowClick"]],template:function(e,i){1&e&&(_(0,"annotations-list-component",0),P("onRowClick",function(o){return i.rowClicked(o)}),B(1,"async"),B(2,"async"),B(3,"async"),B(4,"async"),B(5,"async"),B(6,"async"),B(7,"async"),B(8,"async"),B(9,"async"),v()),2&e&&y("annotations",U(1,9,i.filteredAnnotations$))("embeddingData",U(2,11,i.embeddingData$))("annotationsExpanded",U(3,13,i.annotationsExpanded$))("numAnnotations",U(4,15,i.numAnnotations$))("activeMetrics",U(5,17,i.activeMetrics$))("numActiveRuns",U(6,19,i.numActiveRuns$))("sortedAnnotations",U(7,21,i.sortedAnnotations$))("selectedAnnotations",U(8,23,i.selectedAnnotations$))("maxCount",U(9,25,i.maxCount$))},dependencies:[Yme,Ge],encapsulation:2,changeDetection:0}),n})(),xtt=["chart"],Kme=(()=>{class n{constructor(){this.width=0,this.chartWidth=0,this.height=300,this.margin={top:20,right:40,bottom:20,left:40},this.chartHeight=this.height-this.margin.top-this.margin.bottom}onResize(e){this.redraw()}ngAfterViewInit(){this.svg=bo(this.svgElement.nativeElement),this.mainContainer=this.svg.append("g").attr("transform",`translate(${this.margin.left}, ${this.margin.top})`),this.coordinatesGroup=this.mainContainer.append("g"),this.labelsGroup=this.mainContainer.append("g"),this.axisGroup=this.mainContainer.append("g"),this.xScale=Sy().padding(.1),this.yScale=Qo().range([this.chartHeight,0]),this.yAxis=zw(this.yScale),this.redraw()}ngOnChanges(e){this.svg&&this.redraw()}redraw(){this.updateDimensions(),this.updateAxes(),this.draw()}updateDimensions(){this.width=this.svgElement.nativeElement.clientWidth||10,this.chartWidth=this.width-this.margin.left-this.margin.right}updateAxes(){this.xScale.rangeRound([0,this.chartWidth]).domain(this.activeMetrics),this.yScale.domain([this.coordinateData.extremes.min,this.coordinateData.extremes.max])}draw(){this.drawAxes(),this.drawAxisLabels(),this.drawCoordinates(),this.drawLabels()}drawAxes(){let e=this.axisGroup.selectAll(".axis-y").data(this.activeMetrics);e.enter().append("g").attr("class","axis-y").merge(e).attr("transform",function(r){return`translate(${this.xScale(r)}, 0)`}.bind(this)).call(this.yAxis),e.exit().remove()}drawAxisLabels(){let e=this.axisGroup.selectAll(".axis-bg-text").data(this.activeMetrics);e.enter().append("text").attr("class","axis-bg-text").attr("font-size","13px").attr("stroke-width",2).attr("stroke-linejoin","round").attr("stroke","white").merge(e).text(s=>s).attr("transform",function(s){return`translate(${this.xScale(s)-5}, ${this.yScale(this.coordinateData.extremes.min)}) rotate(-90)`}.bind(this)),e.exit().remove();let r=this.axisGroup.selectAll(".axis-text").data(this.activeMetrics);r.enter().append("text").attr("font-size","13px").attr("class","axis-text").merge(r).text(s=>s).attr("transform",function(s){return`translate(${this.xScale(s)-5}, ${this.yScale(this.coordinateData.extremes.min)}) rotate(-90)`}.bind(this)),r.exit().remove()}drawCoordinates(){let e=this.coordinatesGroup.selectAll(".coord").data(this.coordinateData.coordinates);e.enter().append("path").attr("class","coord").attr("fill","none").merge(e).attr("d",this.path.bind(this)).attr("stroke",function(s){return this.colorScale(s.runId)}.bind(this)),e.exit().remove();let r=this.coordinatesGroup.selectAll(".hiddenCoord").data(this.coordinateData.coordinates);r.enter().append("path").attr("class","hiddenCoord").attr("stroke-width","10px").attr("fill","none").attr("stroke","rgba(0, 0, 0, 0.0)").on("mouseover",this.handleCoordinateMouseOver.bind(this)).on("mouseout",this.handleCoordinateMouseOut.bind(this)).merge(r).attr("d",this.path.bind(this)),r.exit().remove()}path(e){return e.values.sort((r,o)=>this.activeMetrics.indexOf(r.metric)-this.activeMetrics.indexOf(o.metric)),xS()(e.values.map(function(r){let o=this.yScale(r.nPMIValue);return[this.xScale(r.metric),o]}.bind(this)))}handleCoordinateMouseOver(e,i){this.labelsGroup.selectAll(".coordinate-label").filter(function(r){return r.annotation!==e.annotation}).style("opacity",.1),this.coordinatesGroup.selectAll(".coord").filter(function(r){return r.annotation!==e.annotation}).style("opacity",.1)}handleCoordinateMouseOut(){this.labelsGroup.selectAll(".coordinate-label").style("opacity",1),this.coordinatesGroup.selectAll(".coord").style("opacity",1)}drawLabels(){let e=30/this.xScale.step(),i=this.coordinateData.coordinates.length<30?this.coordinateData.coordinates:[],r=this.labelsGroup.selectAll(".coordinate-label").data(i);r.enter().append("text").attr("class","coordinate-label").attr("font-size","10px").merge(r).text(function(s){return s.annotation}).attr("x",this.xScale(this.activeMetrics[0])+30).attr("y",function(s){let a=this.yScale(s.values[0].nPMIValue?s.values[0].nPMIValue:0),l=this.yScale(s.values[1].nPMIValue?s.values[1].nPMIValue:0);return(1-e)*a+e*l}.bind(this)),r.exit().remove()}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["parallel-coordinates-component"]],viewQuery:function(e,i){if(1&e&&ot(xtt,7,Re),2&e){let r;Ne(r=Le())&&(i.svgElement=r.first)}},hostBindings:function(e,i){1&e&&P("resize",function(o){return i.onResize(o)},0,Wx)},inputs:{activeMetrics:"activeMetrics",coordinateData:"coordinateData",sidebarWidth:"sidebarWidth",colorScale:"colorScale"},features:[Ft],decls:2,vars:0,consts:[[1,"pc-chart"],["chart",""]],template:function(e,i){1&e&&(In(),O(0,"svg",0,1))},styles:[".pc-chart[_ngcontent-%COMP%]{height:300px;width:100%}"],changeDetection:0}),n})(),Zme=(()=>{class n{constructor(e){this.store=e,this.activeRuns$=this.store.pipe(vt(oo)).pipe(L(i=>i?Array.from(i.entries()).filter(r=>r[1]).map(r=>r[0]):[])),this.activeMetrics$=Lt(this.store.select(Rf),this.activeRuns$,this.store.select(Il)).pipe(L(([i,r,o])=>{let s=[];for(let a of r)i[a]&&(s=s.concat(i[a].filter(l=>Vb(l))));return s=[...new Set([...Object.keys(o),...s])],s.map(a=>Ss(a))})),this.coordinateData$=Lt([this.store.select(Pf),this.store.select(vc),this.activeRuns$,this.activeMetrics$]).pipe(L(([i,r,o,s])=>function(n,t,e,i){let r=[],o={max:-1,min:1},s=new Set(e),a=new Set(i);return 0===s.size||0===a.size||0===Object.keys(n).length?{coordinates:[],extremes:{min:-1,max:1}}:(t.forEach(l=>{let u={};n[l].forEach(d=>{!s.has(d.run)||!a.has(d.metric)||(u[d.run]?u[d.run].push(d):u[d.run]=[d],null!==d.nPMIValue?(o.max=Math.max(o.max,d.nPMIValue),o.min=Math.min(o.min,d.nPMIValue)):(o.max=Math.max(o.max,0),o.min=Math.min(o.min,0)))});for(let d of Object.keys(u))r.push({annotation:l,runId:d,values:u[d]})}),o.max<o.min&&(o.max=1,o.min=-1),{coordinates:r,extremes:o})}(i,r,o,s))),this.sidebarWidth$=this.store.select(Of),this.runColorScale$=this.store.select(nc).pipe(L(i=>r=>{if(!i.hasOwnProperty(r))throw new Error(`[Color scale] unknown runId: ${r}.`);return i[r]}))}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["npmi-parallel-coordinates"]],decls:5,vars:12,consts:[[3,"activeMetrics","coordinateData","sidebarWidth","colorScale"]],template:function(e,i){1&e&&(O(0,"parallel-coordinates-component",0),B(1,"async"),B(2,"async"),B(3,"async"),B(4,"async")),2&e&&y("activeMetrics",U(1,4,i.activeMetrics$))("coordinateData",U(2,6,i.coordinateData$))("sidebarWidth",U(3,8,i.sidebarWidth$))("colorScale",U(4,10,i.runColorScale$))},dependencies:[Kme,Ge],encapsulation:2,changeDetection:0}),n})();function wtt(n,t){1&n&&O(0,"mat-icon",9)}function Stt(n,t){1&n&&O(0,"mat-icon",10)}function Ett(n,t){1&n&&O(0,"npmi-parallel-coordinates")}var Jme=(()=>{class n{constructor(){this.onClearSelectedAnnotations=new G,this.onToggleExpanded=new G}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["selected-annotations-component"]],inputs:{pcExpanded:"pcExpanded",selectedAnnotations:"selectedAnnotations"},outputs:{onClearSelectedAnnotations:"onClearSelectedAnnotations",onToggleExpanded:"onToggleExpanded"},decls:11,vars:4,consts:function(){let t,e;return t=$localize`:Label for a button that clears the annotation selection.␟2b52289f2c4b7f5b182ed23c9154722ecd46a2d4␟2494660520341308830:Clear Annotation Selection`,e=$localize`:Label for a button that expands or hides selected annotations.␟8f4ad305c19e3655f3189e3e264e83fb76f7bb95␟5670797784070952095:Expand/Hide Selected Annotations`,[[1,"pc-container"],[1,"pc-toolbar"],[1,"pc-title"],["mat-icon-button","","aria-label",t,"title","Deselects all selected annotations.",1,"clear-button",3,"disabled","click"],["svgIcon","clear_24px"],["mat-icon-button","","aria-label",e,1,"expand-button",3,"click"],["svgIcon","expand_less_24px","class","expand-less-icon",4,"ngIf","ngIfElse"],["notExpanded",""],[4,"ngIf"],["svgIcon","expand_less_24px",1,"expand-less-icon"],["svgIcon","expand_more_24px",1,"expand-icon"]]},template:function(e,i){if(1&e&&(_(0,"div",0)(1,"div",1)(2,"h3",2),A(3,"Selected Annotations"),v(),_(4,"button",3),P("click",function(){return i.onClearSelectedAnnotations.emit()}),O(5,"mat-icon",4),v(),_(6,"button",5),P("click",function(){return i.onToggleExpanded.emit()}),E(7,wtt,1,0,"mat-icon",6),E(8,Stt,1,0,"ng-template",null,7,qt),v()(),E(10,Ett,1,0,"npmi-parallel-coordinates",8),v()),2&e){let r=$e(9);C(4),y("disabled",0===i.selectedAnnotations.length),C(3),y("ngIf",i.pcExpanded)("ngIfElse",r),C(3),y("ngIf",i.pcExpanded)}},dependencies:[Be,Gt,_n,Zme],styles:[".pc-container[_ngcontent-%COMP%]{background-color:#fff;border:1px solid #ebebeb}.pc-toolbar[_ngcontent-%COMP%]{align-items:center;border-bottom:1px solid #ebebeb;display:flex;height:42px;padding:0 16px}.pc-title[_ngcontent-%COMP%]{font-size:14px;font-weight:500;display:inline;flex:1 1}"],changeDetection:0}),n})(),XF=(()=>{class n{constructor(e){this.store=e,this.pcExpanded$=this.store.pipe(vt(ome)),this.selectedAnnotations$=this.store.select(vc)}clearSelectedAnnotations(){this.store.dispatch(SF())}toggleExpanded(){this.store.dispatch(PF())}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["npmi-selected-annotations"]],decls:3,vars:6,consts:[[3,"pcExpanded","selectedAnnotations","onClearSelectedAnnotations","onToggleExpanded"]],template:function(e,i){1&e&&(_(0,"selected-annotations-component",0),P("onClearSelectedAnnotations",function(){return i.clearSelectedAnnotations()})("onToggleExpanded",function(){return i.toggleExpanded()}),B(1,"async"),B(2,"async"),v()),2&e&&y("pcExpanded",U(1,2,i.pcExpanded$))("selectedAnnotations",U(2,4,i.selectedAnnotations$))},dependencies:[Jme,Ge],encapsulation:2,changeDetection:0}),n})();function Dtt(n,t){1&n&&(_(0,"div",6)(1,"div",7),O(2,"npmi-violin-filters",8),_(3,"div",9),O(4,"runs-selector"),v()()()),2&n&&Pt("width",S().sidebarWidth,"px")}function Att(n,t){if(1&n){let e=Pe();_(0,"div",10),P("mousedown",function(){return oe(e),se(S().resizeGrabbed.emit())}),v()}}function Itt(n,t){1&n&&(_(0,"div",11),O(1,"npmi-annotations-list",12)(2,"npmi-selected-annotations"),v())}function Ptt(n,t){1&n&&(_(0,"div",13),A(1,"You need to select at least one run."),v())}function Rtt(n,t){if(1&n){let e=Pe();_(0,"div",14)(1,"button",15),P("click",function(){return oe(e),se(S().toggleSidebarExpanded.emit())}),O(2,"mat-icon",16),v()()}}var ege=(()=>{class n{constructor(){this.toggleSidebarExpanded=new G,this.resizeTriggered=new G,this.resizeGrabbed=new G,this.resizeReleased=new G}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["main-component"]],inputs:{runActive:"runActive",sidebarExpanded:"sidebarExpanded",sidebarWidth:"sidebarWidth"},outputs:{toggleSidebarExpanded:"toggleSidebarExpanded",resizeTriggered:"resizeTriggered",resizeGrabbed:"resizeGrabbed",resizeReleased:"resizeReleased"},decls:8,vars:5,consts:function(){let t;return t=$localize`:Label for a button that toggles the sidebar.␟f63b57932d179cca62ac9fcae63dd7f5e6fa389f␟4485009347444704878:Toggle Sidebar`,[[1,"content",3,"mouseup","mousemove"],["class","sidebar-container",3,"width",4,"ngIf"],["class","grabber",3,"mousedown",4,"ngIf"],["class","analysis-container",4,"ngIf","ngIfElse"],["noRun",""],["class","side-toggle",4,"ngIf"],[1,"sidebar-container"],[1,"sidebar-contents"],[1,"violin-filters"],[1,"run-selector"],[1,"grabber",3,"mousedown"],[1,"analysis-container"],[1,"annotations-list"],[1,"noRun"],[1,"side-toggle"],["mat-icon-button","","aria-label",t,3,"click"],["svgIcon","chevron_right_24px"]]},template:function(e,i){if(1&e&&(O(0,"npmi-data-selection"),_(1,"div",0),P("mouseup",function(){return i.resizeReleased.emit()})("mousemove",function(o){return i.resizeTriggered.emit(o)}),E(2,Dtt,5,2,"div",1),E(3,Att,1,0,"div",2),E(4,Itt,3,0,"div",3),E(5,Ptt,2,0,"ng-template",null,4,qt),v(),E(7,Rtt,3,0,"div",5)),2&e){let r=$e(6);C(2),y("ngIf",i.sidebarExpanded),C(1),y("ngIf",i.sidebarExpanded),C(1),y("ngIf",!0===i.runActive)("ngIfElse",r),C(3),y("ngIf",!i.sidebarExpanded)}},dependencies:[Be,Gt,Ob,WF,_n,Ome,YF,XF],styles:['[_nghost-%COMP%]{display:flex;flex-direction:column;height:100%}.content[_ngcontent-%COMP%]{display:flex;flex:1;min-height:0px;width:100%}.sidebar-container[_ngcontent-%COMP%]{height:100%;overflow:hidden}.sidebar-contents[_ngcontent-%COMP%]{height:100%;display:flex;flex-direction:column;min-width:150px}.analysis-container[_ngcontent-%COMP%]{display:flex;flex-direction:column;height:100%;flex:1 1}.run-selector[_ngcontent-%COMP%]{max-height:100%;width:100%}.violin-filters[_ngcontent-%COMP%]{width:100%}.side-toggle[_ngcontent-%COMP%]{width:30px;height:30px;position:absolute;left:10px;bottom:10px;border:1px solid #ebebeb;border-radius:3px;display:flex;align-items:center;justify-content:center}.grabber[_ngcontent-%COMP%]{content:"";cursor:ew-resize;height:100%;width:3px;overflow:hidden;background-color:rgba(0,0,0,.12)}.annotations-list[_ngcontent-%COMP%]{width:100%;min-height:0px;flex:1 1}'],changeDetection:0}),n})(),tge=(()=>{class n{constructor(e){this.store=e,this.runActive$=this.store.pipe(vt(oo)).pipe(L(i=>!!i&&[...i.values()].includes(!0))),this.sidebarExpanded$=this.store.pipe(vt(zF)),this.sidebarWidth$=this.store.pipe(vt(Of)),this.resizing=!1}onToggleSidebarExpanded(){this.store.dispatch(qb())}onResizeTriggered(e){this.resizing&&this.store.dispatch(NF({sidebarWidth:e.clientX}))}onResizeGrabbed(){this.resizing=!0}onResizeReleased(){this.resizing=!1}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["npmi-main"]],decls:4,vars:9,consts:[[3,"runActive","sidebarExpanded","sidebarWidth","toggleSidebarExpanded","resizeTriggered","resizeGrabbed","resizeReleased"]],template:function(e,i){1&e&&(_(0,"main-component",0),P("toggleSidebarExpanded",function(){return i.onToggleSidebarExpanded()})("resizeTriggered",function(o){return i.onResizeTriggered(o)})("resizeGrabbed",function(){return i.onResizeGrabbed()})("resizeReleased",function(){return i.onResizeReleased()}),B(1,"async"),B(2,"async"),B(3,"async"),v()),2&e&&y("runActive",U(1,3,i.runActive$))("sidebarExpanded",U(2,5,i.sidebarExpanded$))("sidebarWidth",U(3,7,i.sidebarWidth$))},dependencies:[ege,Ge],encapsulation:2,changeDetection:0}),n})(),nge=(()=>{class n{constructor(){this.toggleSidebarExpanded=new G}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["embedding-projection-component"]],inputs:{sidebarExpanded:"sidebarExpanded"},outputs:{toggleSidebarExpanded:"toggleSidebarExpanded"},decls:7,vars:0,consts:function(){let t;return t=$localize`:Label for a button that expands/hides the sidebar.␟48c29903ce881ab61088f8d49d827203716aaed4␟4658602991970260215:Expand/Hide Sidebar`,[[1,"embedding-projection-toolbar"],[1,"embedding-projection-title"],[1,"side-toggle"],["mat-icon-button","","aria-label",t,3,"click"],["svgIcon","chevron_left_24px"],[1,"projection"]]},template:function(e,i){1&e&&(_(0,"div",0)(1,"h3",1),A(2,"Embeddings Projected"),v(),_(3,"div",2)(4,"button",3),P("click",function(){return i.toggleSidebarExpanded.emit()}),O(5,"mat-icon",4),v()()(),O(6,"div",5))},dependencies:[Gt,_n],styles:["[_nghost-%COMP%]{display:flex;flex-direction:column;height:100%}.embedding-projection-toolbar[_ngcontent-%COMP%]{align-items:center;border-bottom:1px solid #ebebeb;display:flex;height:42px;justify-content:space-between;padding:0 10px}.embedding-projection-title[_ngcontent-%COMP%]{display:inline;font-size:14px;font-weight:500}.projection[_ngcontent-%COMP%]{overflow-y:auto}.side-toggle[_ngcontent-%COMP%]{align-items:center;background-color:#fff;border-radius:3px;border:1px solid #ebebeb;display:flex;height:30px;justify-content:center;width:30px}"],changeDetection:0}),n})(),ige=(()=>{class n{constructor(e){this.store=e,this.sidebarExpanded$=this.store.select(GF)}onToggleSidebarExpanded(){this.store.dispatch(Yb())}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["npmi-embedding-projection"]],decls:2,vars:3,consts:[[3,"sidebarExpanded","toggleSidebarExpanded"]],template:function(e,i){1&e&&(_(0,"embedding-projection-component",0),P("toggleSidebarExpanded",function(){return i.onToggleSidebarExpanded()}),B(1,"async"),v()),2&e&&y("sidebarExpanded",U(1,1,i.sidebarExpanded$))},dependencies:[nge,Ge],encapsulation:2,changeDetection:0}),n})();function Ltt(n,t){1&n&&(_(0,"div",6)(1,"div",7),O(2,"npmi-embedding-projection",8)(3,"div",9),_(4,"div",10),O(5,"runs-selector"),v()()()),2&n&&Pt("width",S().sidebarWidth,"px")}function Btt(n,t){if(1&n){let e=Pe();_(0,"div",11),P("mousedown",function(){return oe(e),se(S().resizeGrabbed.emit())}),v()}}function Vtt(n,t){1&n&&(_(0,"div",12),O(1,"npmi-annotations-list",13)(2,"npmi-selected-annotations"),v())}function Htt(n,t){1&n&&(_(0,"div",14),A(1,"You need to select at least one run."),v())}function Utt(n,t){if(1&n){let e=Pe();_(0,"div",15)(1,"button",16),P("click",function(){return oe(e),se(S().toggleSidebarExpanded.emit())}),O(2,"mat-icon",17),v()()}}var rge=(()=>{class n{constructor(){this.toggleSidebarExpanded=new G,this.resizeTriggered=new G,this.resizeGrabbed=new G,this.resizeReleased=new G}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["embeddings-component"]],inputs:{runActive:"runActive",sidebarExpanded:"sidebarExpanded",sidebarWidth:"sidebarWidth"},outputs:{toggleSidebarExpanded:"toggleSidebarExpanded",resizeTriggered:"resizeTriggered",resizeGrabbed:"resizeGrabbed",resizeReleased:"resizeReleased"},decls:8,vars:5,consts:function(){let t;return t=$localize`:Label for a button that toggles the sidebar.␟f63b57932d179cca62ac9fcae63dd7f5e6fa389f␟4485009347444704878:Toggle Sidebar`,[[1,"content",3,"mouseup","mousemove"],["class","sidebar-container",3,"width",4,"ngIf"],["class","grabber",3,"mousedown",4,"ngIf"],["class","analysis-container",4,"ngIf","ngIfElse"],["noRun",""],["class","side-toggle",4,"ngIf"],[1,"sidebar-container"],[1,"sidebar-contents"],[1,"embedding-projection"],[1,"run-divider"],[1,"run-selector"],[1,"grabber",3,"mousedown"],[1,"analysis-container"],[1,"annotations-list"],[1,"noRun"],[1,"side-toggle"],["mat-icon-button","","aria-label",t,3,"click"],["svgIcon","chevron_right_24px"]]},template:function(e,i){if(1&e&&(O(0,"npmi-data-selection"),_(1,"div",0),P("mouseup",function(){return i.resizeReleased.emit()})("mousemove",function(o){return i.resizeTriggered.emit(o)}),E(2,Ltt,6,2,"div",1),E(3,Btt,1,0,"div",2),E(4,Vtt,3,0,"div",3),E(5,Htt,2,0,"ng-template",null,4,qt),v(),E(7,Utt,3,0,"div",5)),2&e){let r=$e(6);C(2),y("ngIf",i.sidebarExpanded),C(1),y("ngIf",i.sidebarExpanded),C(1),y("ngIf",!0===i.runActive)("ngIfElse",r),C(3),y("ngIf",!i.sidebarExpanded)}},dependencies:[Be,Gt,Ob,WF,_n,YF,XF,ige],styles:['[_nghost-%COMP%]{display:flex;flex-direction:column;height:100%}.content[_ngcontent-%COMP%]{display:flex;flex:1;min-height:0px;width:100%}.sidebar-container[_ngcontent-%COMP%]{height:100%;overflow:hidden}.sidebar-contents[_ngcontent-%COMP%]{display:flex;flex-direction:column;height:100%;min-width:150px}.analysis-container[_ngcontent-%COMP%]{display:flex;flex:1 1;flex-direction:column;height:100%}.run-selector[_ngcontent-%COMP%]{max-height:100%;width:100%}.embedding-projection[_ngcontent-%COMP%]{min-height:0px;width:100%}.side-toggle[_ngcontent-%COMP%]{align-items:center;border:1px solid #ebebeb;border-radius:3px;bottom:10px;display:flex;height:30px;justify-content:center;left:10px;position:absolute;width:30px}.run-divider[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12);content:"";height:1px;overflow:hidden}.grabber[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12);content:"";cursor:ew-resize;height:100%;overflow:hidden;width:3px}.annotations-list[_ngcontent-%COMP%]{flex:1 1;min-height:0px;width:100%}'],changeDetection:0}),n})(),oge=(()=>{class n{constructor(e){this.store=e,this.runActive$=this.store.pipe(vt(oo)).pipe(L(i=>!!i&&[...i.values()].includes(!0))),this.sidebarExpanded$=this.store.pipe(vt(GF)),this.sidebarWidth$=this.store.pipe(vt(lme)),this.resizing=!1}onToggleSidebarExpanded(){this.store.dispatch(Yb())}onResizeTriggered(e){this.resizing&&this.store.dispatch(LF({sidebarWidth:e.clientX}))}onResizeGrabbed(){this.resizing=!0}onResizeReleased(){this.resizing=!1}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["npmi-embeddings"]],decls:4,vars:9,consts:[[3,"runActive","sidebarExpanded","sidebarWidth","toggleSidebarExpanded","resizeTriggered","resizeGrabbed","resizeReleased"]],template:function(e,i){1&e&&(_(0,"embeddings-component",0),P("toggleSidebarExpanded",function(){return i.onToggleSidebarExpanded()})("resizeTriggered",function(o){return i.onResizeTriggered(o)})("resizeGrabbed",function(){return i.onResizeGrabbed()})("resizeReleased",function(){return i.onResizeReleased()}),B(1,"async"),B(2,"async"),B(3,"async"),v()),2&e&&y("runActive",U(1,3,i.runActive$))("sidebarExpanded",U(2,5,i.sidebarExpanded$))("sidebarWidth",U(3,7,i.sidebarWidth$))},dependencies:[rge,Ge],encapsulation:2,changeDetection:0}),n})();function Gtt(n,t){1&n&&O(0,"npmi-inactive-view")}function Wtt(n,t){1&n&&O(0,"npmi-main")}function qtt(n,t){1&n&&O(0,"npmi-embeddings")}function Ytt(n,t){if(1&n&&(E(0,Wtt,1,0,"npmi-main",3),E(1,qtt,1,0,"npmi-embeddings",3)),2&n){let e=S();y("ngIf",e.activeView===e.ViewActive.DEFAULT),C(1),y("ngIf",e.activeView===e.ViewActive.EMBEDDINGS)}}var sge=(()=>{class n{constructor(){this.ViewActive=kp}}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["npmi-component"]],inputs:{runs:"runs",activeView:"activeView"},decls:4,vars:2,consts:[[1,"npmi-container"],[4,"ngIf","ngIfElse"],["dataAvailable",""],[4,"ngIf"]],template:function(e,i){if(1&e&&(_(0,"div",0),E(1,Gtt,1,0,"npmi-inactive-view",1),E(2,Ytt,2,2,"ng-template",null,2,qt),v()),2&e){let r=$e(3);C(1),y("ngIf",0===i.runs.size)("ngIfElse",r)}},dependencies:[Be,ume,tge,oge],styles:["[_nghost-%COMP%]{display:flex;height:100%}.npmi-container[_ngcontent-%COMP%]{flex:1 1}"],changeDetection:0}),n})(),age=(()=>{class n{constructor(e){this.store=e,this.runs$=this.store.pipe(vt(oo)),this.activeView$=this.store.pipe(vt(sme))}ngOnInit(){this.store.dispatch(bF())}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["npmi"]],decls:3,vars:6,consts:[[3,"runs","activeView"]],template:function(e,i){1&e&&(O(0,"npmi-component",0),B(1,"async"),B(2,"async")),2&e&&y("runs",U(1,2,i.runs$))("activeView",U(2,4,i.activeView$))},dependencies:[sge,Ge],encapsulation:2}),n})(),lge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,jr,Ls,pn,Pn]}),n})(),cge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,jr,pn,Ha]}),n})(),uge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,jr,pn,Pn,Nme,cge]}),n})(),dge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,jr,Ls,pn]}),n})(),pge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me]}),n})(),hge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[pge]}),n})(),QF=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,uge,dge,hge,Zc,lge]}),n})(),fge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,jr,pn,Pn]}),n})(),mge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,jr,z2,pn,$b,Qk]}),n})(),gge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,$b]}),n})(),_ge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,$b,mge,gge]}),n})(),vge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,pn,Ha,Ib]}),n})(),yge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,pn,Pn]}),n})(),KF=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,vge,_ge,yge]}),n})(),bge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me]}),n})(),ZF=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,pn,Pn,bge]}),n})(),xge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,jr,Ls,pn,Fb,KF,Pn,QF,ZF,fge]}),n})(),Cge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),Mge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,jr,Pn,pn]}),n})(),wge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,jr,pn,Pn,Mge]}),n})(),Sge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,jr,Ls,pn,Fb,KF,Pn,wge,QF,ZF]}),n})(),Ege=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,Cge,Sge,xge,tme,wr.forFeature("npmi",dme),ro.forFeature([cme]),Bs.forPlugin("npmi",age)]}),n})(),JF=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),v6=(()=>{class n{constructor(e){this.http=e,this.httpPathPrefix="data/plugin/text_v2"}fetchRunToTag(){return this.http.get(this.httpPathPrefix+"/tags").pipe(L(e=>{let i=new Map;return Object.entries(e).forEach(([r,o])=>{i.set(r,o)}),i}))}fetchTextData(e,i){let r=new URLSearchParams({run:e,tag:i});return this.http.get(this.httpPathPrefix+`/text?${r.toString()}`).pipe(L(o=>o.map(s=>({originalShape:s.original_shape,step:s.step,stringArray:s.string_array,wallTimeInMs:1e3*s.wall_time,truncated:s.truncated}))))}}return n.\u0275fac=function(e){return new(e||n)(j(ka))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),Tge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[v6,{provide:JF,useExisting:v6}],imports:[Ku]}),n})(),Dge=be("[Text] Text Plugin Loaded"),Age=be("[Text] Runs To Tag Loaded",{_as:"props",_p:void 0}),Ige=be("[Text] Tag Group Visibility Changed",{_as:"props",_p:void 0}),Pge=be("[Text] Text Data Loaded Loaded",{_as:"props",_p:void 0}),y6=Mr("text"),Rge=(J(y6,n=>n.runToTags),J(y6,n=>{let t=new Set,e=new Set;for(let i of n.visibleRunTags.values())for(let r of i){let o=JSON.stringify(r);t.has(o)||(t.add(o),e.add(r))}return[...e]})),Oge=J(y6,(n,t)=>{let e=n.data.get(t.run);return e&&e.get(t.tag)||null}),kge=(()=>{class n{constructor(e,i,r){this.actions$=e,this.store=i,this.dataSource=r,this.loadRunToTags$=cr(()=>this.actions$.pipe(ii(Dge),ui(()=>this.dataSource.fetchRunToTag().pipe(kt(o=>{this.store.dispatch(Age({runToTags:o}))}),L(()=>{})))),{dispatch:!1}),this.loadData$=cr(()=>{let o=this.actions$.pipe(ii(Ige),ui(({visibleTextCards:a})=>{let l=a.map(({run:c,tag:u})=>this.store.select(Oge,{run:c,tag:u}).pipe(function(n,t){let e=arguments.length>=2;return i=>i.pipe(n?Ye((r,o)=>n(r,o,i)):ms,PW(1),e?_1(t):v1(()=>new _0))}(),L(d=>({run:c,tag:u,textData:d}))));return lr(l).pipe(L(c=>c.filter(({textData:u})=>null===u).map(({run:u,tag:d})=>({run:u,tag:d}))))}));return Jt(o,this.actions$.pipe(ii(Fa,aa),Wt(this.store.select(Rge)),L(([,a])=>a))).pipe(xn(a=>lr(a.map(l=>this.fetchTextData(l)))))},{dispatch:!1})}fetchTextData(e){let{run:i,tag:r}=e;return this.dataSource.fetchTextData(i,r).pipe(kt(o=>{this.store.dispatch(Pge({run:i,tag:r,stepData:o}))}),L(()=>{}))}}return n.\u0275fac=function(e){return new(e||n)(j(Po),j(Ce),j(JF))},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),$tt=vr({runToTags:new Map([["run1",["a/b","a/c"]],["run2",["a/b","a/d"]],["run3",["c","a/b"]]]),data:new Map([["run1",new Map([["a/b",[{originalShape:[3],step:0,stringArray:[["foo","bar","baz"]],wallTimeInMs:15778656e5,truncated:!1},{originalShape:[3],step:1,stringArray:[["foo","baz"]],wallTimeInMs:1577865601e3,truncated:!1}]],["a/c",[{originalShape:[3],step:0,stringArray:[["We conducted an experiment and found the following data:\n\nPounds of chocolate | Happiness\n---|---\n0 | 1\n1 | 4\n2 | 9\n3 | 16\n4 | 25\n5 | 36\n6 | 49\n7 | 64\n8 | 81\n9 | 100\n10 | 121"]],wallTimeInMs:15778656e5,truncated:!1},{originalShape:[3],step:1,stringArray:[["\xd7","**0**","**1**","**2**","**3**","**4**","**5**"],["**0**","0","0","0","0","0","0"],["**1**","0","1","2","3","4","5"],["**2**","0","2","4","6","8","10"],["**3**","0","3","6","9","12","15"],["**4**","0","4","8","12","16","20"],["**5**","0","5","10","15","20","25"]],wallTimeInMs:1577865601e3,truncated:!1}]]])]]),visibleRunTags:new Map});function Fge(n,t){return $tt(n,t)}var Nge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["text-dashboard"]],decls:1,vars:0,template:function(e,i){1&e&&A(0," This is the text dashboard ")},encapsulation:2,changeDetection:0}),n})(),Lge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),Bge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,Lge,Bs.forPlugin("text_v2",Nge),Tge,wr.forFeature("text",Fge),ro.forFeature([kge])]}),n})(),Vge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[_oe,Nhe,Ege,Bge]}),n})(),Fp=(()=>(function(n){n.CUSTOM_ELEMENT="CUSTOM_ELEMENT",n.IFRAME="IFRAME",n.NG_COMPONENT="NG_COMPONENT",n.NONE="NONE"}(Fp||(Fp={})),Fp))(),ent=["pluginContainer"],tnt=["ngPluginContainer"];function nnt(n,t){1&n&&Ni(0)}function int(n,t){if(1&n&&(sn(0),E(1,nnt,1,0,"ng-container",9),an()),2&n){let e=S(2),i=$e(6);C(1),y("ngTemplateOutlet",e.environmentFailureNotFoundTemplate?e.environmentFailureNotFoundTemplate:i)}}function rnt(n,t){1&n&&Ni(0)}function ont(n,t){if(1&n&&(sn(0),E(1,rnt,1,0,"ng-container",9),an()),2&n){let e=S(2),i=$e(6);C(1),y("ngTemplateOutlet",e.environmentFailurePermissionDeniedTemplate?e.environmentFailurePermissionDeniedTemplate:i)}}function snt(n,t){1&n&&Ni(0)}function ant(n,t){if(1&n&&(sn(0),E(1,snt,1,0,"ng-container",9),an()),2&n){let e=S(2),i=$e(6);C(1),y("ngTemplateOutlet",e.environmentFailureUnknownTemplate?e.environmentFailureUnknownTemplate:i)}}function lnt(n,t){if(1&n&&(sn(0),_(1,"h3",10),A(2," There\u2019s no dashboard by the name of \u201c"),_(3,"code"),A(4),v(),A(5,"\u201d. "),v(),_(6,"p"),A(7,"You can select a dashboard from the list above."),v(),_(8,"p"),Ni(9,11),v(),an()),2&n){let e=S(2),i=$e(8);C(4),yt(e.activePluginId),C(5),y("ngTemplateOutlet",i)}}function cnt(n,t){if(1&n&&(sn(0),_(1,"h3",12),A(2," No dashboards are active for the current data set. "),v(),_(3,"p"),A(4,"Probable causes:"),v(),_(5,"ul")(6,"li"),A(7,"You haven\u2019t written any data to your event files."),v(),_(8,"li"),A(9,"TensorBoard can\u2019t find your event files."),v()(),A(10," If you\u2019re new to using TensorBoard, and want to find out how to add data and set up your event files, check out the "),_(11,"a",13),A(12,"README"),v(),A(13," and perhaps the "),_(14,"a",14),A(15,"TensorBoard tutorial"),v(),A(16,". "),_(17,"p"),A(18," If you think TensorBoard is configured properly, please see "),_(19,"a",15),A(20,"the section of the README devoted to missing data problems"),v(),A(21," and consider filing an issue on GitHub. "),v(),_(22,"p"),Ni(23,11),v(),an()),2&n){S(2);let e=$e(8);C(23),y("ngTemplateOutlet",e)}}function unt(n,t){if(1&n&&(_(0,"div",6)(1,"div",7),E(2,int,2,1,"ng-container",8),E(3,ont,2,1,"ng-container",8),E(4,ant,2,1,"ng-container",8),E(5,lnt,10,2,"ng-container",8),E(6,cnt,24,1,"ng-container",8),v()()),2&n){let e=S();y("ngSwitch",e.pluginLoadState),C(2),y("ngSwitchCase",e.PluginLoadState.ENVIRONMENT_FAILURE_NOT_FOUND),C(1),y("ngSwitchCase",e.PluginLoadState.ENVIRONMENT_FAILURE_PERMISSION_DENIED),C(1),y("ngSwitchCase",e.PluginLoadState.ENVIRONMENT_FAILURE_UNKNOWN),C(1),y("ngSwitchCase",e.PluginLoadState.UNKNOWN_PLUGIN_ID),C(1),y("ngSwitchCase",e.PluginLoadState.NO_ENABLED_PLUGINS)}}function dnt(n,t){if(1&n&&(_(0,"h3",16),A(1,"Data could not be loaded."),v(),_(2,"p"),A(3,"The TensorBoard server may be down or inaccessible."),v(),_(4,"p"),Ni(5,11),v()),2&n){S();let e=$e(8);C(5),y("ngTemplateOutlet",e)}}function pnt(n,t){if(1&n&&(_(0,"p",19)(1,"i"),A(2,"Log directory: "),_(3,"span"),A(4),v()()()),2&n){let e=S(2);C(4),yt(e.dataLocation)}}function hnt(n,t){if(1&n&&(_(0,"span",17),A(1),B(2,"date"),v(),E(3,pnt,5,1,"p",18)),2&n){let e=S();C(1),je("Last reload: ",Jf(2,2,e.lastUpdated,"medium"),""),C(2),y("ngIf",e.dataLocation)}}var fnt=function(n){return{plugins:!0,"is-first-party-plugin":n}},yc=(()=>(function(n){n[n.ENVIRONMENT_FAILURE_NOT_FOUND=0]="ENVIRONMENT_FAILURE_NOT_FOUND",n[n.ENVIRONMENT_FAILURE_PERMISSION_DENIED=1]="ENVIRONMENT_FAILURE_PERMISSION_DENIED",n[n.ENVIRONMENT_FAILURE_UNKNOWN=2]="ENVIRONMENT_FAILURE_UNKNOWN",n[n.NO_ENABLED_PLUGINS=3]="NO_ENABLED_PLUGINS",n[n.UNKNOWN_PLUGIN_ID=4]="UNKNOWN_PLUGIN_ID",n[n.LOADED=5]="LOADED",n[n.LOADING=6]="LOADING"}(yc||(yc={})),yc))(),Hge=(()=>{class n{constructor(e,i,r){this.componentFactoryResolver=e,this.pluginRegistry=i,this.pluginApiHost=r,this.PluginLoadState=yc,this.LoadingMechanismType=Fp,this.pluginInstances=new Map}ngOnChanges(e){if(!this.isFeatureFlagsLoaded||!this.activeKnownPlugin||this.settingsLoadState===Oe.NOT_LOADED||this.settingsLoadState===Oe.LOADING)return;let i=Boolean(this.activeKnownPlugin&&!this.pluginInstances.has(this.activeKnownPlugin.id));if(e.activeKnownPlugin||e.isFeatureFlagsLoaded||e.settingsLoadState){let r=e.activeKnownPlugin?.previousValue;if(r&&r.id!==this.activeKnownPlugin.id&&this.hidePlugin(r),i){let o=this.createPlugin(this.activeKnownPlugin);o&&this.pluginInstances.set(this.activeKnownPlugin.id,o)}else this.showPlugin(this.activeKnownPlugin)}(i||e.lastUpdated)&&this.reload(this.activeKnownPlugin,i)}hidePlugin(e){if(!this.pluginInstances.has(e.id))return;let i=this.pluginInstances.get(e.id);Object.assign(i.style,{maxHeight:0,overflow:"hidden",visibility:"hidden",position:"absolute"})}showPlugin(e){if(!this.pluginInstances.has(e.id))return;let i=this.pluginInstances.get(e.id);Object.assign(i.style,{maxHeight:null,overflow:null,visibility:null,position:null})}createPlugin(e){let i=null;switch(e.loading_mechanism.type){case Fp.CUSTOM_ELEMENT:i=document.createElement(e.loading_mechanism.element_name),i.reloadOnReady=!1,i.featureFlags=this.featureFlags,this.pluginsContainer.nativeElement.appendChild(i);break;case Fp.IFRAME:if(!this.pluginApiHost)throw Error(`IFRAME-based plugins not supported: ${e.id}`);i=document.createElement("iframe"),i.setAttribute("src",`data/plugin_entry.html?name=${e.id}`),this.pluginApiHost.registerPluginIframe(i,e.id),this.pluginsContainer.nativeElement.appendChild(i);break;case Fp.NG_COMPONENT:let r=this.pluginRegistry.getComponent(e.id);if(r){let o=this.componentFactoryResolver.resolveComponentFactory(r);i=this.ngPluginContainer.createComponent(o).location.nativeElement}else console.error(`No registered Angular component for plugin: ${e.id}`);break;case Fp.NONE:break;default:console.error("Unexpected plugin")}return i}reload(e,i){if(!i&&e.disable_reload)return;let r=this.pluginInstances.get(e.id);r&&r.reload&&r.reload()}}return n.\u0275fac=function(e){return new(e||n)(M(gs),M(Bs),M(r2,8))},n.\u0275cmp=R({type:n,selectors:[["plugins-component"]],viewQuery:function(e,i){if(1&e&&(ot(ent,7,Re),ot(tnt,7,Oi)),2&e){let r;Ne(r=Le())&&(i.pluginsContainer=r.first),Ne(r=Le())&&(i.ngPluginContainer=r.first)}},inputs:{activePluginId:"activePluginId",activeKnownPlugin:"activeKnownPlugin",pluginLoadState:"pluginLoadState",dataLocation:"dataLocation",isFeatureFlagsLoaded:"isFeatureFlagsLoaded",settingsLoadState:"settingsLoadState",featureFlags:"featureFlags",lastUpdated:"lastUpdated",environmentFailureNotFoundTemplate:"environmentFailureNotFoundTemplate",environmentFailurePermissionDeniedTemplate:"environmentFailurePermissionDeniedTemplate",environmentFailureUnknownTemplate:"environmentFailureUnknownTemplate"},features:[Ft],decls:9,vars:4,consts:[[3,"ngClass"],["pluginContainer",""],["ngPluginContainer",""],["class","warning",3,"ngSwitch",4,"ngIf"],["environmentFailureDefaultTemplate",""],["dateAndDataLocation",""],[1,"warning",3,"ngSwitch"],[1,"warning-message"],[4,"ngSwitchCase"],[4,"ngTemplateOutlet"],[1,"unknown-plugin"],[3,"ngTemplateOutlet"],[1,"no-active-plugin"],["href","https://github.com/tensorflow/tensorboard/blob/master/README.md"],["href","https://www.tensorflow.org/get_started/summaries_and_tensorboard"],["href","https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"],[1,"environment-not-loaded"],[1,"last-reload-time"],["class","data-location",4,"ngIf"],[1,"data-location"]],template:function(e,i){1&e&&(_(0,"div",0,1),Ni(2,null,2),v(),E(4,unt,7,6,"div",3),E(5,dnt,6,1,"ng-template",null,4,qt),E(7,hnt,4,5,"ng-template",null,5,qt)),2&e&&(y("ngClass",On(2,fnt,(null==i.activeKnownPlugin?null:i.activeKnownPlugin.loading_mechanism.type)!==i.LoadingMechanismType.IFRAME)),C(4),y("ngIf",i.pluginLoadState!==i.PluginLoadState.LOADED&&i.pluginLoadState!==i.PluginLoadState.LOADING))},dependencies:[Fn,Be,os,Cr,Ur,U_],styles:["[_nghost-%COMP%]{background-color:#fff;color:#212121;display:block;position:relative}body.dark-mode   [_nghost-%COMP%]   .plugins.is-first-party-plugin[_ngcontent-%COMP%]{background-color:#303030;color:#fff}.plugins[_ngcontent-%COMP%]{height:100%;position:relative}.warning[_ngcontent-%COMP%]{background:#fff;bottom:0;left:0;position:absolute;right:0;top:0}body.dark-mode[_nghost-%COMP%]   .warning[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .warning[_ngcontent-%COMP%]{background:#303030}.warning-message[_ngcontent-%COMP%]{color:#212121;margin:80px auto 0;max-width:540px}body.dark-mode[_nghost-%COMP%]   .warning-message[_ngcontent-%COMP%], body.dark-mode   [_nghost-%COMP%]   .warning-message[_ngcontent-%COMP%]{color:#fff}.last-reload-time[_ngcontent-%COMP%]{font-style:italic}.plugins[_ngcontent-%COMP%]     iframe{border:0;display:block;height:100%;width:100%}"],changeDetection:0}),n})(),mnt=J(rv,Rs,(n,t)=>t&&n[t]?Object.assign({id:t},n[t]):null),eN=(()=>{class n{constructor(e){this.store=e,this.activeKnownPlugin$=this.store.select(mnt),this.activePluginId$=this.store.select(Rs),this.pluginLoadState$=Lt(this.activeKnownPlugin$,this.activePluginId$,this.store.select(nI)).pipe(L(([i,r,o])=>null!==o.failureCode?o.failureCode===$l.NOT_FOUND?yc.ENVIRONMENT_FAILURE_NOT_FOUND:o.failureCode===$l.PERMISSION_DENIED?yc.ENVIRONMENT_FAILURE_PERMISSION_DENIED:yc.ENVIRONMENT_FAILURE_UNKNOWN:null!==i?yc.LOADED:null===o.lastLoadedTimeInMs&&o.state===Oe.LOADING?yc.LOADING:r?yc.UNKNOWN_PLUGIN_ID:yc.NO_ENABLED_PLUGINS)),this.lastLoadedTimeInMs$=this.store.select(iv),this.dataLocation$=this.store.select(ov).pipe(L(i=>i.data_location)),this.isFeatureFlagsLoaded$=this.store.select(gh),this.featureFlags$=this.store.select(bs),this.settingsLoadState$=this.store.select(Na.getSettingsLoadState)}}return n.\u0275fac=function(e){return new(e||n)(M(Ce))},n.\u0275cmp=R({type:n,selectors:[["plugins"]],inputs:{environmentFailureNotFoundTemplate:"environmentFailureNotFoundTemplate",environmentFailurePermissionDeniedTemplate:"environmentFailurePermissionDeniedTemplate",environmentFailureUnknownTemplate:"environmentFailureUnknownTemplate"},decls:9,vars:27,consts:[[3,"activeKnownPlugin","activePluginId","dataLocation","lastUpdated","pluginLoadState","isFeatureFlagsLoaded","settingsLoadState","featureFlags","environmentFailureNotFoundTemplate","environmentFailurePermissionDeniedTemplate","environmentFailureUnknownTemplate"]],template:function(e,i){1&e&&(O(0,"plugins-component",0),B(1,"async"),B(2,"async"),B(3,"async"),B(4,"async"),B(5,"async"),B(6,"async"),B(7,"async"),B(8,"async")),2&e&&y("activeKnownPlugin",U(1,11,i.activeKnownPlugin$))("activePluginId",U(2,13,i.activePluginId$))("dataLocation",U(3,15,i.dataLocation$))("lastUpdated",U(4,17,i.lastLoadedTimeInMs$))("pluginLoadState",U(5,19,i.pluginLoadState$))("isFeatureFlagsLoaded",U(6,21,i.isFeatureFlagsLoaded$))("settingsLoadState",U(7,23,i.settingsLoadState$))("featureFlags",U(8,25,i.featureFlags$))("environmentFailureNotFoundTemplate",i.environmentFailureNotFoundTemplate)("environmentFailurePermissionDeniedTemplate",i.environmentFailurePermissionDeniedTemplate)("environmentFailureUnknownTemplate",i.environmentFailureUnknownTemplate)},styles:["plugins-component[_ngcontent-%COMP%] { height: 100%; }"],changeDetection:0}),n})(),tN=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[ec,Me,Bs]}),n})();Nx(eN,[Hge],[Ge]);var Uge=(()=>{class n{constructor(e,i){this.store=e,this.document=i,this.onVisibilityChange=this.onVisibilityChangeImpl.bind(this),this.reloadEnabled$=this.store.pipe(vt(Na.getReloadEnabled)),this.reloadPeriodInMs$=this.store.pipe(vt(Na.getReloadPeriodInMs)),this.reloadTimerId=null,this.missedAutoReload=!1,this.ngUnsubscribe=new ke}ngOnInit(){this.document.addEventListener("visibilitychange",this.onVisibilityChange),Lt(this.reloadEnabled$.pipe(yi()),this.reloadPeriodInMs$.pipe(yi())).pipe(st(this.ngUnsubscribe)).subscribe(([e,i])=>{this.cancelLoad(),e&&this.load(i)})}onVisibilityChangeImpl(){"visible"===this.document.visibilityState&&this.missedAutoReload&&(this.missedAutoReload=!1,this.store.dispatch(aa()))}load(e){this.reloadTimerId=setTimeout(()=>{"visible"===this.document.visibilityState?this.store.dispatch(aa()):this.missedAutoReload=!0,this.load(e)},e)}cancelLoad(){null!==this.reloadTimerId&&clearTimeout(this.reloadTimerId),this.reloadTimerId=null}ngOnDestroy(){this.cancelLoad(),this.document.removeEventListener("visibilitychange",this.onVisibilityChange),this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}}return n.\u0275fac=function(e){return new(e||n)(M(Ce),M(Ht))},n.\u0275cmp=R({type:n,selectors:[["reloader"]],decls:0,vars:0,template:function(e,i){},encapsulation:2,changeDetection:0}),n})(),zge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275cmp=R({type:n,selectors:[["tensorboard-wrapper-component"]],decls:2,vars:0,consts:[[1,"plugins"]],template:function(e,i){1&e&&O(0,"plugins",0)(1,"reloader")},dependencies:[eN,Uge],styles:["[_nghost-%COMP%] {\n        display: flex;\n        flex-direction: column;\n        height: 100%;\n      }\n\n      .plugins[_ngcontent-%COMP%] {\n        flex: 1 1;\n        overflow: auto;\n        position: relative;\n      }"],changeDetection:0}),n})(),jge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275prov=ye({token:n,factory:n.\u0275fac}),n})(),b6="smoothing",x6="runColorGroup",C6="tagFilter",M6="runFilter",w6="regex:",nN=class extends jge{getMetricsPinnedCards(t){return Lt([t.select(zM),t.select(vee)]).pipe(L(([e,i])=>{if(!e.length&&!i.length)return[];let o=[...e.map(({plugin:s,tag:a,sample:l,runId:c})=>{let u={plugin:s,tag:a};return ml(s)&&(u.runId=c),fl(s)&&(u.sample=l),u}),...i];return[{key:"pinnedCards",value:JSON.stringify(o)}]}))}serializeStateToQueryParams(t){return Lt([this.getMetricsPinnedCards(t),t.select(Xc).pipe(L(e=>e?[{key:C6,value:e}]:[])),Lt([t.select(zA),t.select(Hm)]).pipe(L(([e,i])=>function(n,t){return Object.entries(n).map(([e,i])=>{if(void 0===i)return{};let r=t[e];return r&&r.queryParamOverride?{key:r.queryParamOverride,value:i?.toString()}:{}}).filter(({key:e,value:i})=>e&&void 0!==i)}(e,i))),t.select(bee).pipe(L(e=>Number.isFinite(e.scalarSmoothing)?[{key:b6,value:String(e.scalarSmoothing)}]:[])),t.select(rH).pipe(L(e=>{if(!e)return[];let i;switch(e.key){case sr.EXPERIMENT:i="experiment";break;case sr.RUN:i="run";break;case sr.REGEX:i=`${w6}${e.regexString}`;break;default:throw new RangeError("Serialization not implemented")}return[{key:x6,value:i}]})),t.select(Qm).pipe(L(e=>e?[{key:M6,value:e}]:[]))]).pipe(L(e=>e.flat()))}deserializeQueryParams(t){let e=null,i=null,r=null,o=null,s=null;for(let{key:a,value:l}of t)switch(a){case"pinnedCards":e=vnt(l);break;case b6:i=Number(l);break;case x6:switch(l){case"experiment":o={key:sr.EXPERIMENT};break;case"run":o={key:sr.RUN}}if(l.startsWith(w6)){let c=l.slice(w6.length);o={key:sr.REGEX,regexString:c}}break;case C6:r=l;break;case M6:s=l}return{metrics:{pinnedCards:e||[],smoothing:i,tagFilter:r},runs:{groupBy:o,regexFilter:s}}}};function vnt(n){let t;try{t=JSON.parse(n)}catch{return null}if(!Array.isArray(t))return null;let e=[];for(let i of t){let o="string"==typeof i.runId,s="number"==typeof i.sample,a="string"==typeof i.tag,l=o||typeof i.runId>"u",c=s||typeof i.sample>"u";if(!("string"==typeof i.plugin&&a&&l&&c&&X$(i.plugin)&&i.tag))continue;if(ml(i.plugin)){if(!i.runId)continue}else if(i.runId)continue;if(s&&(!fl(i.plugin)||!Number.isInteger(i.sample)||i.sample<0))continue;let u={plugin:i.plugin,tag:i.tag};o&&(u.runId=i.runId),s&&(u.sample=i.sample),e.push(u)}return e}function Wge(){return[{routeKind:hi.EXPERIMENT,path:"/",ngComponent:zge,defaultRoute:!0,deepLinkProvider:new nN},{routeKind:hi.FLAGS,path:"/flags/",ngComponent:W2}]}function ynt(n){return(t,e)=>{let i=n(t,e);return console.groupCollapsed(e.type),console.log("prev state",t),console.log("action",e),console.log("next state",i),console.groupEnd(),i}}function qge(){return tC()?ynt:n=>(t,e)=>n(t,e)}nN=pW([rq()],nN);var Yge=new pe("Root reducers token",{factory:()=>({})}),Xge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({providers:[{provide:W_,useFactory:qge,multi:!0}],imports:[wr.forRoot(Yge,{runtimeChecks:{strictStateImmutability:!0,strictActionImmutability:!0,strictActionSerializability:!1,strictStateSerializability:!1}}),ro.forRoot([])]}),n})(),Qge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({}),n})(),Kge=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n}),n.\u0275inj=V({imports:[Me,tN,Qge]}),n})(),S6=(()=>{class n{}return n.\u0275fac=function(e){return new(e||n)},n.\u0275mod=H({type:n,bootstrap:[Uie]}),n.\u0275inj=V({imports:[cv,Zie,tA,eJ,J_,zie,qc.registerRoutes(Wge),E2,S2,jie,Kge,ec,Qie,Wie,ere,mI,tre,qie,T4,r2,tN,$I,$2,Xge,Vge]}),n})();"loading"!==document.readyState?y5().bootstrapModule(S6):window.addEventListener("DOMContentLoaded",()=>{y5().bootstrapModule(S6)}),function(){if(aX)throw new Error("Cannot enable prod mode after platform setup.");sX=!1}()})();
/** vim: et:ts=4:sw=4:sts=4
 * @license RequireJS 2.3.6 Copyright jQuery Foundation and other contributors.
 * Released under MIT license, https://github.com/requirejs/requirejs/blob/master/LICENSE
 */
//Not using strict: uneven strict support in browsers, #392, and causes
//problems with requirejs.exec()/transpiler plugins that may not be strict.
/*jslint regexp: true, nomen: true, sloppy: true */
/*global window, navigator, document, importScripts, setTimeout, opera */

var requirejs, require, define;
(function (global, setTimeout) {
    var req, s, head, baseElement, dataMain, src,
        interactiveScript, currentlyAddingScript, mainScript, subPath,
        version = '2.3.6',
        commentRegExp = /\/\*[\s\S]*?\*\/|([^:"'=]|^)\/\/.*$/mg,
        cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
        jsSuffixRegExp = /\.js$/,
        currDirRegExp = /^\.\//,
        op = Object.prototype,
        ostring = op.toString,
        hasOwn = op.hasOwnProperty,
        isBrowser = !!(typeof window !== 'undefined' && typeof navigator !== 'undefined' && window.document),
        isWebWorker = !isBrowser && typeof importScripts !== 'undefined',
        //PS3 indicates loaded and complete, but need to wait for complete
        //specifically. Sequence is 'loading', 'loaded', execution,
        // then 'complete'. The UA check is unfortunate, but not sure how
        //to feature test w/o causing perf issues.
        readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ?
                      /^complete$/ : /^(complete|loaded)$/,
        defContextName = '_',
        //Oh the tragedy, detecting opera. See the usage of isOpera for reason.
        isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]',
        contexts = {},
        cfg = {},
        globalDefQueue = [],
        useInteractive = false;

    //Could match something like ')//comment', do not lose the prefix to comment.
    function commentReplace(match, singlePrefix) {
        return singlePrefix || '';
    }

    function isFunction(it) {
        return ostring.call(it) === '[object Function]';
    }

    function isArray(it) {
        return ostring.call(it) === '[object Array]';
    }

    /**
     * Helper function for iterating over an array. If the func returns
     * a true value, it will break out of the loop.
     */
    function each(ary, func) {
        if (ary) {
            var i;
            for (i = 0; i < ary.length; i += 1) {
                if (ary[i] && func(ary[i], i, ary)) {
                    break;
                }
            }
        }
    }

    /**
     * Helper function for iterating over an array backwards. If the func
     * returns a true value, it will break out of the loop.
     */
    function eachReverse(ary, func) {
        if (ary) {
            var i;
            for (i = ary.length - 1; i > -1; i -= 1) {
                if (ary[i] && func(ary[i], i, ary)) {
                    break;
                }
            }
        }
    }

    function hasProp(obj, prop) {
        return hasOwn.call(obj, prop);
    }

    function getOwn(obj, prop) {
        return hasProp(obj, prop) && obj[prop];
    }

    /**
     * Cycles over properties in an object and calls a function for each
     * property value. If the function returns a truthy value, then the
     * iteration is stopped.
     */
    function eachProp(obj, func) {
        var prop;
        for (prop in obj) {
            if (hasProp(obj, prop)) {
                if (func(obj[prop], prop)) {
                    break;
                }
            }
        }
    }

    /**
     * Simple function to mix in properties from source into target,
     * but only if target does not already have a property of the same name.
     */
    function mixin(target, source, force, deepStringMixin) {
        if (source) {
            eachProp(source, function (value, prop) {
                if (force || !hasProp(target, prop)) {
                    if (deepStringMixin && typeof value === 'object' && value &&
                        !isArray(value) && !isFunction(value) &&
                        !(value instanceof RegExp)) {

                        if (!target[prop]) {
                            target[prop] = {};
                        }
                        mixin(target[prop], value, force, deepStringMixin);
                    } else {
                        target[prop] = value;
                    }
                }
            });
        }
        return target;
    }

    //Similar to Function.prototype.bind, but the 'this' object is specified
    //first, since it is easier to read/figure out what 'this' will be.
    function bind(obj, fn) {
        return function () {
            return fn.apply(obj, arguments);
        };
    }

    function scripts() {
        return document.getElementsByTagName('script');
    }

    function defaultOnError(err) {
        throw err;
    }

    //Allow getting a global that is expressed in
    //dot notation, like 'a.b.c'.
    function getGlobal(value) {
        if (!value) {
            return value;
        }
        var g = global;
        each(value.split('.'), function (part) {
            g = g[part];
        });
        return g;
    }

    /**
     * Constructs an error with a pointer to an URL with more information.
     * @param {String} id the error ID that maps to an ID on a web page.
     * @param {String} message human readable error.
     * @param {Error} [err] the original error, if there is one.
     *
     * @returns {Error}
     */
    function makeError(id, msg, err, requireModules) {
        var e = new Error(msg + '\nhttps://requirejs.org/docs/errors.html#' + id);
        e.requireType = id;
        e.requireModules = requireModules;
        if (err) {
            e.originalError = err;
        }
        return e;
    }

    if (typeof define !== 'undefined') {
        //If a define is already in play via another AMD loader,
        //do not overwrite.
        return;
    }

    if (typeof requirejs !== 'undefined') {
        if (isFunction(requirejs)) {
            //Do not overwrite an existing requirejs instance.
            return;
        }
        cfg = requirejs;
        requirejs = undefined;
    }

    //Allow for a require config object
    if (typeof require !== 'undefined' && !isFunction(require)) {
        //assume it is a config object.
        cfg = require;
        require = undefined;
    }

    function newContext(contextName) {
        var inCheckLoaded, Module, context, handlers,
            checkLoadedTimeoutId,
            config = {
                //Defaults. Do not set a default for map
                //config to speed up normalize(), which
                //will run faster if there is no default.
                waitSeconds: 7,
                baseUrl: './',
                paths: {},
                bundles: {},
                pkgs: {},
                shim: {},
                config: {}
            },
            registry = {},
            //registry of just enabled modules, to speed
            //cycle breaking code when lots of modules
            //are registered, but not activated.
            enabledRegistry = {},
            undefEvents = {},
            defQueue = [],
            defined = {},
            urlFetched = {},
            bundlesMap = {},
            requireCounter = 1,
            unnormalizedCounter = 1;

        /**
         * Trims the . and .. from an array of path segments.
         * It will keep a leading path segment if a .. will become
         * the first path segment, to help with module name lookups,
         * which act like paths, but can be remapped. But the end result,
         * all paths that use this function should look normalized.
         * NOTE: this method MODIFIES the input array.
         * @param {Array} ary the array of path segments.
         */
        function trimDots(ary) {
            var i, part;
            for (i = 0; i < ary.length; i++) {
                part = ary[i];
                if (part === '.') {
                    ary.splice(i, 1);
                    i -= 1;
                } else if (part === '..') {
                    // If at the start, or previous value is still ..,
                    // keep them so that when converted to a path it may
                    // still work when converted to a path, even though
                    // as an ID it is less than ideal. In larger point
                    // releases, may be better to just kick out an error.
                    if (i === 0 || (i === 1 && ary[2] === '..') || ary[i - 1] === '..') {
                        continue;
                    } else if (i > 0) {
                        ary.splice(i - 1, 2);
                        i -= 2;
                    }
                }
            }
        }

        /**
         * Given a relative module name, like ./something, normalize it to
         * a real name that can be mapped to a path.
         * @param {String} name the relative name
         * @param {String} baseName a real name that the name arg is relative
         * to.
         * @param {Boolean} applyMap apply the map config to the value. Should
         * only be done if this normalization is for a dependency ID.
         * @returns {String} normalized name
         */
        function normalize(name, baseName, applyMap) {
            var pkgMain, mapValue, nameParts, i, j, nameSegment, lastIndex,
                foundMap, foundI, foundStarMap, starI, normalizedBaseParts,
                baseParts = (baseName && baseName.split('/')),
                map = config.map,
                starMap = map && map['*'];

            //Adjust any relative paths.
            if (name) {
                name = name.split('/');
                lastIndex = name.length - 1;

                // If wanting node ID compatibility, strip .js from end
                // of IDs. Have to do this here, and not in nameToUrl
                // because node allows either .js or non .js to map
                // to same file.
                if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
                    name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
                }

                // Starts with a '.' so need the baseName
                if (name[0].charAt(0) === '.' && baseParts) {
                    //Convert baseName to array, and lop off the last part,
                    //so that . matches that 'directory' and not name of the baseName's
                    //module. For instance, baseName of 'one/two/three', maps to
                    //'one/two/three.js', but we want the directory, 'one/two' for
                    //this normalization.
                    normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
                    name = normalizedBaseParts.concat(name);
                }

                trimDots(name);
                name = name.join('/');
            }

            //Apply map config if available.
            if (applyMap && map && (baseParts || starMap)) {
                nameParts = name.split('/');

                outerLoop: for (i = nameParts.length; i > 0; i -= 1) {
                    nameSegment = nameParts.slice(0, i).join('/');

                    if (baseParts) {
                        //Find the longest baseName segment match in the config.
                        //So, do joins on the biggest to smallest lengths of baseParts.
                        for (j = baseParts.length; j > 0; j -= 1) {
                            mapValue = getOwn(map, baseParts.slice(0, j).join('/'));

                            //baseName segment has config, find if it has one for
                            //this name.
                            if (mapValue) {
                                mapValue = getOwn(mapValue, nameSegment);
                                if (mapValue) {
                                    //Match, update name to the new value.
                                    foundMap = mapValue;
                                    foundI = i;
                                    break outerLoop;
                                }
                            }
                        }
                    }

                    //Check for a star map match, but just hold on to it,
                    //if there is a shorter segment match later in a matching
                    //config, then favor over this star map.
                    if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
                        foundStarMap = getOwn(starMap, nameSegment);
                        starI = i;
                    }
                }

                if (!foundMap && foundStarMap) {
                    foundMap = foundStarMap;
                    foundI = starI;
                }

                if (foundMap) {
                    nameParts.splice(0, foundI, foundMap);
                    name = nameParts.join('/');
                }
            }

            // If the name points to a package's name, use
            // the package main instead.
            pkgMain = getOwn(config.pkgs, name);

            return pkgMain ? pkgMain : name;
        }

        function removeScript(name) {
            if (isBrowser) {
                each(scripts(), function (scriptNode) {
                    if (scriptNode.getAttribute('data-requiremodule') === name &&
                            scriptNode.getAttribute('data-requirecontext') === context.contextName) {
                        scriptNode.parentNode.removeChild(scriptNode);
                        return true;
                    }
                });
            }
        }

        function hasPathFallback(id) {
            var pathConfig = getOwn(config.paths, id);
            if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {
                //Pop off the first array value, since it failed, and
                //retry
                pathConfig.shift();
                context.require.undef(id);

                //Custom require that does not do map translation, since
                //ID is "absolute", already mapped/resolved.
                context.makeRequire(null, {
                    skipMap: true
                })([id]);

                return true;
            }
        }

        //Turns a plugin!resource to [plugin, resource]
        //with the plugin being undefined if the name
        //did not have a plugin prefix.
        function splitPrefix(name) {
            var prefix,
                index = name ? name.indexOf('!') : -1;
            if (index > -1) {
                prefix = name.substring(0, index);
                name = name.substring(index + 1, name.length);
            }
            return [prefix, name];
        }

        /**
         * Creates a module mapping that includes plugin prefix, module
         * name, and path. If parentModuleMap is provided it will
         * also normalize the name via require.normalize()
         *
         * @param {String} name the module name
         * @param {String} [parentModuleMap] parent module map
         * for the module name, used to resolve relative names.
         * @param {Boolean} isNormalized: is the ID already normalized.
         * This is true if this call is done for a define() module ID.
         * @param {Boolean} applyMap: apply the map config to the ID.
         * Should only be true if this map is for a dependency.
         *
         * @returns {Object}
         */
        function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
            var url, pluginModule, suffix, nameParts,
                prefix = null,
                parentName = parentModuleMap ? parentModuleMap.name : null,
                originalName = name,
                isDefine = true,
                normalizedName = '';

            //If no name, then it means it is a require call, generate an
            //internal name.
            if (!name) {
                isDefine = false;
                name = '_@r' + (requireCounter += 1);
            }

            nameParts = splitPrefix(name);
            prefix = nameParts[0];
            name = nameParts[1];

            if (prefix) {
                prefix = normalize(prefix, parentName, applyMap);
                pluginModule = getOwn(defined, prefix);
            }

            //Account for relative paths if there is a base name.
            if (name) {
                if (prefix) {
                    if (isNormalized) {
                        normalizedName = name;
                    } else if (pluginModule && pluginModule.normalize) {
                        //Plugin is loaded, use its normalize method.
                        normalizedName = pluginModule.normalize(name, function (name) {
                            return normalize(name, parentName, applyMap);
                        });
                    } else {
                        // If nested plugin references, then do not try to
                        // normalize, as it will not normalize correctly. This
                        // places a restriction on resourceIds, and the longer
                        // term solution is not to normalize until plugins are
                        // loaded and all normalizations to allow for async
                        // loading of a loader plugin. But for now, fixes the
                        // common uses. Details in #1131
                        normalizedName = name.indexOf('!') === -1 ?
                                         normalize(name, parentName, applyMap) :
                                         name;
                    }
                } else {
                    //A regular module.
                    normalizedName = normalize(name, parentName, applyMap);

                    //Normalized name may be a plugin ID due to map config
                    //application in normalize. The map config values must
                    //already be normalized, so do not need to redo that part.
                    nameParts = splitPrefix(normalizedName);
                    prefix = nameParts[0];
                    normalizedName = nameParts[1];
                    isNormalized = true;

                    url = context.nameToUrl(normalizedName);
                }
            }

            //If the id is a plugin id that cannot be determined if it needs
            //normalization, stamp it with a unique ID so two matching relative
            //ids that may conflict can be separate.
            suffix = prefix && !pluginModule && !isNormalized ?
                     '_unnormalized' + (unnormalizedCounter += 1) :
                     '';

            return {
                prefix: prefix,
                name: normalizedName,
                parentMap: parentModuleMap,
                unnormalized: !!suffix,
                url: url,
                originalName: originalName,
                isDefine: isDefine,
                id: (prefix ?
                        prefix + '!' + normalizedName :
                        normalizedName) + suffix
            };
        }

        function getModule(depMap) {
            var id = depMap.id,
                mod = getOwn(registry, id);

            if (!mod) {
                mod = registry[id] = new context.Module(depMap);
            }

            return mod;
        }

        function on(depMap, name, fn) {
            var id = depMap.id,
                mod = getOwn(registry, id);

            if (hasProp(defined, id) &&
                    (!mod || mod.defineEmitComplete)) {
                if (name === 'defined') {
                    fn(defined[id]);
                }
            } else {
                mod = getModule(depMap);
                if (mod.error && name === 'error') {
                    fn(mod.error);
                } else {
                    mod.on(name, fn);
                }
            }
        }

        function onError(err, errback) {
            var ids = err.requireModules,
                notified = false;

            if (errback) {
                errback(err);
            } else {
                each(ids, function (id) {
                    var mod = getOwn(registry, id);
                    if (mod) {
                        //Set error on module, so it skips timeout checks.
                        mod.error = err;
                        if (mod.events.error) {
                            notified = true;
                            mod.emit('error', err);
                        }
                    }
                });

                if (!notified) {
                    req.onError(err);
                }
            }
        }

        /**
         * Internal method to transfer globalQueue items to this context's
         * defQueue.
         */
        function takeGlobalQueue() {
            //Push all the globalDefQueue items into the context's defQueue
            if (globalDefQueue.length) {
                each(globalDefQueue, function(queueItem) {
                    var id = queueItem[0];
                    if (typeof id === 'string') {
                        context.defQueueMap[id] = true;
                    }
                    defQueue.push(queueItem);
                });
                globalDefQueue = [];
            }
        }

        handlers = {
            'require': function (mod) {
                if (mod.require) {
                    return mod.require;
                } else {
                    return (mod.require = context.makeRequire(mod.map));
                }
            },
            'exports': function (mod) {
                mod.usingExports = true;
                if (mod.map.isDefine) {
                    if (mod.exports) {
                        return (defined[mod.map.id] = mod.exports);
                    } else {
                        return (mod.exports = defined[mod.map.id] = {});
                    }
                }
            },
            'module': function (mod) {
                if (mod.module) {
                    return mod.module;
                } else {
                    return (mod.module = {
                        id: mod.map.id,
                        uri: mod.map.url,
                        config: function () {
                            return getOwn(config.config, mod.map.id) || {};
                        },
                        exports: mod.exports || (mod.exports = {})
                    });
                }
            }
        };

        function cleanRegistry(id) {
            //Clean up machinery used for waiting modules.
            delete registry[id];
            delete enabledRegistry[id];
        }

        function breakCycle(mod, traced, processed) {
            var id = mod.map.id;

            if (mod.error) {
                mod.emit('error', mod.error);
            } else {
                traced[id] = true;
                each(mod.depMaps, function (depMap, i) {
                    var depId = depMap.id,
                        dep = getOwn(registry, depId);

                    //Only force things that have not completed
                    //being defined, so still in the registry,
                    //and only if it has not been matched up
                    //in the module already.
                    if (dep && !mod.depMatched[i] && !processed[depId]) {
                        if (getOwn(traced, depId)) {
                            mod.defineDep(i, defined[depId]);
                            mod.check(); //pass false?
                        } else {
                            breakCycle(dep, traced, processed);
                        }
                    }
                });
                processed[id] = true;
            }
        }

        function checkLoaded() {
            var err, usingPathFallback,
                waitInterval = config.waitSeconds * 1000,
                //It is possible to disable the wait interval by using waitSeconds of 0.
                expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
                noLoads = [],
                reqCalls = [],
                stillLoading = false,
                needCycleCheck = true;

            //Do not bother if this call was a result of a cycle break.
            if (inCheckLoaded) {
                return;
            }

            inCheckLoaded = true;

            //Figure out the state of all the modules.
            eachProp(enabledRegistry, function (mod) {
                var map = mod.map,
                    modId = map.id;

                //Skip things that are not enabled or in error state.
                if (!mod.enabled) {
                    return;
                }

                if (!map.isDefine) {
                    reqCalls.push(mod);
                }

                if (!mod.error) {
                    //If the module should be executed, and it has not
                    //been inited and time is up, remember it.
                    if (!mod.inited && expired) {
                        if (hasPathFallback(modId)) {
                            usingPathFallback = true;
                            stillLoading = true;
                        } else {
                            noLoads.push(modId);
                            removeScript(modId);
                        }
                    } else if (!mod.inited && mod.fetched && map.isDefine) {
                        stillLoading = true;
                        if (!map.prefix) {
                            //No reason to keep looking for unfinished
                            //loading. If the only stillLoading is a
                            //plugin resource though, keep going,
                            //because it may be that a plugin resource
                            //is waiting on a non-plugin cycle.
                            return (needCycleCheck = false);
                        }
                    }
                }
            });

            if (expired && noLoads.length) {
                //If wait time expired, throw error of unloaded modules.
                err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads);
                err.contextName = context.contextName;
                return onError(err);
            }

            //Not expired, check for a cycle.
            if (needCycleCheck) {
                each(reqCalls, function (mod) {
                    breakCycle(mod, {}, {});
                });
            }

            //If still waiting on loads, and the waiting load is something
            //other than a plugin resource, or there are still outstanding
            //scripts, then just try back later.
            if ((!expired || usingPathFallback) && stillLoading) {
                //Something is still waiting to load. Wait for it, but only
                //if a timeout is not already in effect.
                if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
                    checkLoadedTimeoutId = setTimeout(function () {
                        checkLoadedTimeoutId = 0;
                        checkLoaded();
                    }, 50);
                }
            }

            inCheckLoaded = false;
        }

        Module = function (map) {
            this.events = getOwn(undefEvents, map.id) || {};
            this.map = map;
            this.shim = getOwn(config.shim, map.id);
            this.depExports = [];
            this.depMaps = [];
            this.depMatched = [];
            this.pluginMaps = {};
            this.depCount = 0;

            /* this.exports this.factory
               this.depMaps = [],
               this.enabled, this.fetched
            */
        };

        Module.prototype = {
            init: function (depMaps, factory, errback, options) {
                options = options || {};

                //Do not do more inits if already done. Can happen if there
                //are multiple define calls for the same module. That is not
                //a normal, common case, but it is also not unexpected.
                if (this.inited) {
                    return;
                }

                this.factory = factory;

                if (errback) {
                    //Register for errors on this module.
                    this.on('error', errback);
                } else if (this.events.error) {
                    //If no errback already, but there are error listeners
                    //on this module, set up an errback to pass to the deps.
                    errback = bind(this, function (err) {
                        this.emit('error', err);
                    });
                }

                //Do a copy of the dependency array, so that
                //source inputs are not modified. For example
                //"shim" deps are passed in here directly, and
                //doing a direct modification of the depMaps array
                //would affect that config.
                this.depMaps = depMaps && depMaps.slice(0);

                this.errback = errback;

                //Indicate this module has be initialized
                this.inited = true;

                this.ignore = options.ignore;

                //Could have option to init this module in enabled mode,
                //or could have been previously marked as enabled. However,
                //the dependencies are not known until init is called. So
                //if enabled previously, now trigger dependencies as enabled.
                if (options.enabled || this.enabled) {
                    //Enable this module and dependencies.
                    //Will call this.check()
                    this.enable();
                } else {
                    this.check();
                }
            },

            defineDep: function (i, depExports) {
                //Because of cycles, defined callback for a given
                //export can be called more than once.
                if (!this.depMatched[i]) {
                    this.depMatched[i] = true;
                    this.depCount -= 1;
                    this.depExports[i] = depExports;
                }
            },

            fetch: function () {
                if (this.fetched) {
                    return;
                }
                this.fetched = true;

                context.startTime = (new Date()).getTime();

                var map = this.map;

                //If the manager is for a plugin managed resource,
                //ask the plugin to load it now.
                if (this.shim) {
                    context.makeRequire(this.map, {
                        enableBuildCallback: true
                    })(this.shim.deps || [], bind(this, function () {
                        return map.prefix ? this.callPlugin() : this.load();
                    }));
                } else {
                    //Regular dependency.
                    return map.prefix ? this.callPlugin() : this.load();
                }
            },

            load: function () {
                var url = this.map.url;

                //Regular dependency.
                if (!urlFetched[url]) {
                    urlFetched[url] = true;
                    context.load(this.map.id, url);
                }
            },

            /**
             * Checks if the module is ready to define itself, and if so,
             * define it.
             */
            check: function () {
                if (!this.enabled || this.enabling) {
                    return;
                }

                var err, cjsModule,
                    id = this.map.id,
                    depExports = this.depExports,
                    exports = this.exports,
                    factory = this.factory;

                if (!this.inited) {
                    // Only fetch if not already in the defQueue.
                    if (!hasProp(context.defQueueMap, id)) {
                        this.fetch();
                    }
                } else if (this.error) {
                    this.emit('error', this.error);
                } else if (!this.defining) {
                    //The factory could trigger another require call
                    //that would result in checking this module to
                    //define itself again. If already in the process
                    //of doing that, skip this work.
                    this.defining = true;

                    if (this.depCount < 1 && !this.defined) {
                        if (isFunction(factory)) {
                            //If there is an error listener, favor passing
                            //to that instead of throwing an error. However,
                            //only do it for define()'d  modules. require
                            //errbacks should not be called for failures in
                            //their callbacks (#699). However if a global
                            //onError is set, use that.
                            if ((this.events.error && this.map.isDefine) ||
                                req.onError !== defaultOnError) {
                                try {
                                    exports = context.execCb(id, factory, depExports, exports);
                                } catch (e) {
                                    err = e;
                                }
                            } else {
                                exports = context.execCb(id, factory, depExports, exports);
                            }

                            // Favor return value over exports. If node/cjs in play,
                            // then will not have a return value anyway. Favor
                            // module.exports assignment over exports object.
                            if (this.map.isDefine && exports === undefined) {
                                cjsModule = this.module;
                                if (cjsModule) {
                                    exports = cjsModule.exports;
                                } else if (this.usingExports) {
                                    //exports already set the defined value.
                                    exports = this.exports;
                                }
                            }

                            if (err) {
                                err.requireMap = this.map;
                                err.requireModules = this.map.isDefine ? [this.map.id] : null;
                                err.requireType = this.map.isDefine ? 'define' : 'require';
                                return onError((this.error = err));
                            }

                        } else {
                            //Just a literal value
                            exports = factory;
                        }

                        this.exports = exports;

                        if (this.map.isDefine && !this.ignore) {
                            defined[id] = exports;

                            if (req.onResourceLoad) {
                                var resLoadMaps = [];
                                each(this.depMaps, function (depMap) {
                                    resLoadMaps.push(depMap.normalizedMap || depMap);
                                });
                                req.onResourceLoad(context, this.map, resLoadMaps);
                            }
                        }

                        //Clean up
                        cleanRegistry(id);

                        this.defined = true;
                    }

                    //Finished the define stage. Allow calling check again
                    //to allow define notifications below in the case of a
                    //cycle.
                    this.defining = false;

                    if (this.defined && !this.defineEmitted) {
                        this.defineEmitted = true;
                        this.emit('defined', this.exports);
                        this.defineEmitComplete = true;
                    }

                }
            },

            callPlugin: function () {
                var map = this.map,
                    id = map.id,
                    //Map already normalized the prefix.
                    pluginMap = makeModuleMap(map.prefix);

                //Mark this as a dependency for this plugin, so it
                //can be traced for cycles.
                this.depMaps.push(pluginMap);

                on(pluginMap, 'defined', bind(this, function (plugin) {
                    var load, normalizedMap, normalizedMod,
                        bundleId = getOwn(bundlesMap, this.map.id),
                        name = this.map.name,
                        parentName = this.map.parentMap ? this.map.parentMap.name : null,
                        localRequire = context.makeRequire(map.parentMap, {
                            enableBuildCallback: true
                        });

                    //If current map is not normalized, wait for that
                    //normalized name to load instead of continuing.
                    if (this.map.unnormalized) {
                        //Normalize the ID if the plugin allows it.
                        if (plugin.normalize) {
                            name = plugin.normalize(name, function (name) {
                                return normalize(name, parentName, true);
                            }) || '';
                        }

                        //prefix and name should already be normalized, no need
                        //for applying map config again either.
                        normalizedMap = makeModuleMap(map.prefix + '!' + name,
                                                      this.map.parentMap,
                                                      true);
                        on(normalizedMap,
                            'defined', bind(this, function (value) {
                                this.map.normalizedMap = normalizedMap;
                                this.init([], function () { return value; }, null, {
                                    enabled: true,
                                    ignore: true
                                });
                            }));

                        normalizedMod = getOwn(registry, normalizedMap.id);
                        if (normalizedMod) {
                            //Mark this as a dependency for this plugin, so it
                            //can be traced for cycles.
                            this.depMaps.push(normalizedMap);

                            if (this.events.error) {
                                normalizedMod.on('error', bind(this, function (err) {
                                    this.emit('error', err);
                                }));
                            }
                            normalizedMod.enable();
                        }

                        return;
                    }

                    //If a paths config, then just load that file instead to
                    //resolve the plugin, as it is built into that paths layer.
                    if (bundleId) {
                        this.map.url = context.nameToUrl(bundleId);
                        this.load();
                        return;
                    }

                    load = bind(this, function (value) {
                        this.init([], function () { return value; }, null, {
                            enabled: true
                        });
                    });

                    load.error = bind(this, function (err) {
                        this.inited = true;
                        this.error = err;
                        err.requireModules = [id];

                        //Remove temp unnormalized modules for this module,
                        //since they will never be resolved otherwise now.
                        eachProp(registry, function (mod) {
                            if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
                                cleanRegistry(mod.map.id);
                            }
                        });

                        onError(err);
                    });

                    //Allow plugins to load other code without having to know the
                    //context or how to 'complete' the load.
                    load.fromText = bind(this, function (text, textAlt) {
                        /*jslint evil: true */
                        var moduleName = map.name,
                            moduleMap = makeModuleMap(moduleName),
                            hasInteractive = useInteractive;

                        //As of 2.1.0, support just passing the text, to reinforce
                        //fromText only being called once per resource. Still
                        //support old style of passing moduleName but discard
                        //that moduleName in favor of the internal ref.
                        if (textAlt) {
                            text = textAlt;
                        }

                        //Turn off interactive script matching for IE for any define
                        //calls in the text, then turn it back on at the end.
                        if (hasInteractive) {
                            useInteractive = false;
                        }

                        //Prime the system by creating a module instance for
                        //it.
                        getModule(moduleMap);

                        //Transfer any config to this other module.
                        if (hasProp(config.config, id)) {
                            config.config[moduleName] = config.config[id];
                        }

                        try {
                            req.exec(text);
                        } catch (e) {
                            return onError(makeError('fromtexteval',
                                             'fromText eval for ' + id +
                                            ' failed: ' + e,
                                             e,
                                             [id]));
                        }

                        if (hasInteractive) {
                            useInteractive = true;
                        }

                        //Mark this as a dependency for the plugin
                        //resource
                        this.depMaps.push(moduleMap);

                        //Support anonymous modules.
                        context.completeLoad(moduleName);

                        //Bind the value of that module to the value for this
                        //resource ID.
                        localRequire([moduleName], load);
                    });

                    //Use parentName here since the plugin's name is not reliable,
                    //could be some weird string with no path that actually wants to
                    //reference the parentName's path.
                    plugin.load(map.name, localRequire, load, config);
                }));

                context.enable(pluginMap, this);
                this.pluginMaps[pluginMap.id] = pluginMap;
            },

            enable: function () {
                enabledRegistry[this.map.id] = this;
                this.enabled = true;

                //Set flag mentioning that the module is enabling,
                //so that immediate calls to the defined callbacks
                //for dependencies do not trigger inadvertent load
                //with the depCount still being zero.
                this.enabling = true;

                //Enable each dependency
                each(this.depMaps, bind(this, function (depMap, i) {
                    var id, mod, handler;

                    if (typeof depMap === 'string') {
                        //Dependency needs to be converted to a depMap
                        //and wired up to this module.
                        depMap = makeModuleMap(depMap,
                                               (this.map.isDefine ? this.map : this.map.parentMap),
                                               false,
                                               !this.skipMap);
                        this.depMaps[i] = depMap;

                        handler = getOwn(handlers, depMap.id);

                        if (handler) {
                            this.depExports[i] = handler(this);
                            return;
                        }

                        this.depCount += 1;

                        on(depMap, 'defined', bind(this, function (depExports) {
                            if (this.undefed) {
                                return;
                            }
                            this.defineDep(i, depExports);
                            this.check();
                        }));

                        if (this.errback) {
                            on(depMap, 'error', bind(this, this.errback));
                        } else if (this.events.error) {
                            // No direct errback on this module, but something
                            // else is listening for errors, so be sure to
                            // propagate the error correctly.
                            on(depMap, 'error', bind(this, function(err) {
                                this.emit('error', err);
                            }));
                        }
                    }

                    id = depMap.id;
                    mod = registry[id];

                    //Skip special modules like 'require', 'exports', 'module'
                    //Also, don't call enable if it is already enabled,
                    //important in circular dependency cases.
                    if (!hasProp(handlers, id) && mod && !mod.enabled) {
                        context.enable(depMap, this);
                    }
                }));

                //Enable each plugin that is used in
                //a dependency
                eachProp(this.pluginMaps, bind(this, function (pluginMap) {
                    var mod = getOwn(registry, pluginMap.id);
                    if (mod && !mod.enabled) {
                        context.enable(pluginMap, this);
                    }
                }));

                this.enabling = false;

                this.check();
            },

            on: function (name, cb) {
                var cbs = this.events[name];
                if (!cbs) {
                    cbs = this.events[name] = [];
                }
                cbs.push(cb);
            },

            emit: function (name, evt) {
                each(this.events[name], function (cb) {
                    cb(evt);
                });
                if (name === 'error') {
                    //Now that the error handler was triggered, remove
                    //the listeners, since this broken Module instance
                    //can stay around for a while in the registry.
                    delete this.events[name];
                }
            }
        };

        function callGetModule(args) {
            //Skip modules already defined.
            if (!hasProp(defined, args[0])) {
                getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);
            }
        }

        function removeListener(node, func, name, ieName) {
            //Favor detachEvent because of IE9
            //issue, see attachEvent/addEventListener comment elsewhere
            //in this file.
            if (node.detachEvent && !isOpera) {
                //Probably IE. If not it will throw an error, which will be
                //useful to know.
                if (ieName) {
                    node.detachEvent(ieName, func);
                }
            } else {
                node.removeEventListener(name, func, false);
            }
        }

        /**
         * Given an event from a script node, get the requirejs info from it,
         * and then removes the event listeners on the node.
         * @param {Event} evt
         * @returns {Object}
         */
        function getScriptData(evt) {
            //Using currentTarget instead of target for Firefox 2.0's sake. Not
            //all old browsers will be supported, but this one was easy enough
            //to support and still makes sense.
            var node = evt.currentTarget || evt.srcElement;

            //Remove the listeners once here.
            removeListener(node, context.onScriptLoad, 'load', 'onreadystatechange');
            removeListener(node, context.onScriptError, 'error');

            return {
                node: node,
                id: node && node.getAttribute('data-requiremodule')
            };
        }

        function intakeDefines() {
            var args;

            //Any defined modules in the global queue, intake them now.
            takeGlobalQueue();

            //Make sure any remaining defQueue items get properly processed.
            while (defQueue.length) {
                args = defQueue.shift();
                if (args[0] === null) {
                    return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' +
                        args[args.length - 1]));
                } else {
                    //args are id, deps, factory. Should be normalized by the
                    //define() function.
                    callGetModule(args);
                }
            }
            context.defQueueMap = {};
        }

        context = {
            config: config,
            contextName: contextName,
            registry: registry,
            defined: defined,
            urlFetched: urlFetched,
            defQueue: defQueue,
            defQueueMap: {},
            Module: Module,
            makeModuleMap: makeModuleMap,
            nextTick: req.nextTick,
            onError: onError,

            /**
             * Set a configuration for the context.
             * @param {Object} cfg config object to integrate.
             */
            configure: function (cfg) {
                //Make sure the baseUrl ends in a slash.
                if (cfg.baseUrl) {
                    if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
                        cfg.baseUrl += '/';
                    }
                }

                // Convert old style urlArgs string to a function.
                if (typeof cfg.urlArgs === 'string') {
                    var urlArgs = cfg.urlArgs;
                    cfg.urlArgs = function(id, url) {
                        return (url.indexOf('?') === -1 ? '?' : '&') + urlArgs;
                    };
                }

                //Save off the paths since they require special processing,
                //they are additive.
                var shim = config.shim,
                    objs = {
                        paths: true,
                        bundles: true,
                        config: true,
                        map: true
                    };

                eachProp(cfg, function (value, prop) {
                    if (objs[prop]) {
                        if (!config[prop]) {
                            config[prop] = {};
                        }
                        mixin(config[prop], value, true, true);
                    } else {
                        config[prop] = value;
                    }
                });

                //Reverse map the bundles
                if (cfg.bundles) {
                    eachProp(cfg.bundles, function (value, prop) {
                        each(value, function (v) {
                            if (v !== prop) {
                                bundlesMap[v] = prop;
                            }
                        });
                    });
                }

                //Merge shim
                if (cfg.shim) {
                    eachProp(cfg.shim, function (value, id) {
                        //Normalize the structure
                        if (isArray(value)) {
                            value = {
                                deps: value
                            };
                        }
                        if ((value.exports || value.init) && !value.exportsFn) {
                            value.exportsFn = context.makeShimExports(value);
                        }
                        shim[id] = value;
                    });
                    config.shim = shim;
                }

                //Adjust packages if necessary.
                if (cfg.packages) {
                    each(cfg.packages, function (pkgObj) {
                        var location, name;

                        pkgObj = typeof pkgObj === 'string' ? {name: pkgObj} : pkgObj;

                        name = pkgObj.name;
                        location = pkgObj.location;
                        if (location) {
                            config.paths[name] = pkgObj.location;
                        }

                        //Save pointer to main module ID for pkg name.
                        //Remove leading dot in main, so main paths are normalized,
                        //and remove any trailing .js, since different package
                        //envs have different conventions: some use a module name,
                        //some use a file name.
                        config.pkgs[name] = pkgObj.name + '/' + (pkgObj.main || 'main')
                                     .replace(currDirRegExp, '')
                                     .replace(jsSuffixRegExp, '');
                    });
                }

                //If there are any "waiting to execute" modules in the registry,
                //update the maps for them, since their info, like URLs to load,
                //may have changed.
                eachProp(registry, function (mod, id) {
                    //If module already has init called, since it is too
                    //late to modify them, and ignore unnormalized ones
                    //since they are transient.
                    if (!mod.inited && !mod.map.unnormalized) {
                        mod.map = makeModuleMap(id, null, true);
                    }
                });

                //If a deps array or a config callback is specified, then call
                //require with those args. This is useful when require is defined as a
                //config object before require.js is loaded.
                if (cfg.deps || cfg.callback) {
                    context.require(cfg.deps || [], cfg.callback);
                }
            },

            makeShimExports: function (value) {
                function fn() {
                    var ret;
                    if (value.init) {
                        ret = value.init.apply(global, arguments);
                    }
                    return ret || (value.exports && getGlobal(value.exports));
                }
                return fn;
            },

            makeRequire: function (relMap, options) {
                options = options || {};

                function localRequire(deps, callback, errback) {
                    var id, map, requireMod;

                    if (options.enableBuildCallback && callback && isFunction(callback)) {
                        callback.__requireJsBuild = true;
                    }

                    if (typeof deps === 'string') {
                        if (isFunction(callback)) {
                            //Invalid call
                            return onError(makeError('requireargs', 'Invalid require call'), errback);
                        }

                        //If require|exports|module are requested, get the
                        //value for them from the special handlers. Caveat:
                        //this only works while module is being defined.
                        if (relMap && hasProp(handlers, deps)) {
                            return handlers[deps](registry[relMap.id]);
                        }

                        //Synchronous access to one module. If require.get is
                        //available (as in the Node adapter), prefer that.
                        if (req.get) {
                            return req.get(context, deps, relMap, localRequire);
                        }

                        //Normalize module name, if it contains . or ..
                        map = makeModuleMap(deps, relMap, false, true);
                        id = map.id;

                        if (!hasProp(defined, id)) {
                            return onError(makeError('notloaded', 'Module name "' +
                                        id +
                                        '" has not been loaded yet for context: ' +
                                        contextName +
                                        (relMap ? '' : '. Use require([])')));
                        }
                        return defined[id];
                    }

                    //Grab defines waiting in the global queue.
                    intakeDefines();

                    //Mark all the dependencies as needing to be loaded.
                    context.nextTick(function () {
                        //Some defines could have been added since the
                        //require call, collect them.
                        intakeDefines();

                        requireMod = getModule(makeModuleMap(null, relMap));

                        //Store if map config should be applied to this require
                        //call for dependencies.
                        requireMod.skipMap = options.skipMap;

                        requireMod.init(deps, callback, errback, {
                            enabled: true
                        });

                        checkLoaded();
                    });

                    return localRequire;
                }

                mixin(localRequire, {
                    isBrowser: isBrowser,

                    /**
                     * Converts a module name + .extension into an URL path.
                     * *Requires* the use of a module name. It does not support using
                     * plain URLs like nameToUrl.
                     */
                    toUrl: function (moduleNamePlusExt) {
                        var ext,
                            index = moduleNamePlusExt.lastIndexOf('.'),
                            segment = moduleNamePlusExt.split('/')[0],
                            isRelative = segment === '.' || segment === '..';

                        //Have a file extension alias, and it is not the
                        //dots from a relative path.
                        if (index !== -1 && (!isRelative || index > 1)) {
                            ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
                            moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
                        }

                        return context.nameToUrl(normalize(moduleNamePlusExt,
                                                relMap && relMap.id, true), ext,  true);
                    },

                    defined: function (id) {
                        return hasProp(defined, makeModuleMap(id, relMap, false, true).id);
                    },

                    specified: function (id) {
                        id = makeModuleMap(id, relMap, false, true).id;
                        return hasProp(defined, id) || hasProp(registry, id);
                    }
                });

                //Only allow undef on top level require calls
                if (!relMap) {
                    localRequire.undef = function (id) {
                        //Bind any waiting define() calls to this context,
                        //fix for #408
                        takeGlobalQueue();

                        var map = makeModuleMap(id, relMap, true),
                            mod = getOwn(registry, id);

                        mod.undefed = true;
                        removeScript(id);

                        delete defined[id];
                        delete urlFetched[map.url];
                        delete undefEvents[id];

                        //Clean queued defines too. Go backwards
                        //in array so that the splices do not
                        //mess up the iteration.
                        eachReverse(defQueue, function(args, i) {
                            if (args[0] === id) {
                                defQueue.splice(i, 1);
                            }
                        });
                        delete context.defQueueMap[id];

                        if (mod) {
                            //Hold on to listeners in case the
                            //module will be attempted to be reloaded
                            //using a different config.
                            if (mod.events.defined) {
                                undefEvents[id] = mod.events;
                            }

                            cleanRegistry(id);
                        }
                    };
                }

                return localRequire;
            },

            /**
             * Called to enable a module if it is still in the registry
             * awaiting enablement. A second arg, parent, the parent module,
             * is passed in for context, when this method is overridden by
             * the optimizer. Not shown here to keep code compact.
             */
            enable: function (depMap) {
                var mod = getOwn(registry, depMap.id);
                if (mod) {
                    getModule(depMap).enable();
                }
            },

            /**
             * Internal method used by environment adapters to complete a load event.
             * A load event could be a script load or just a load pass from a synchronous
             * load call.
             * @param {String} moduleName the name of the module to potentially complete.
             */
            completeLoad: function (moduleName) {
                var found, args, mod,
                    shim = getOwn(config.shim, moduleName) || {},
                    shExports = shim.exports;

                takeGlobalQueue();

                while (defQueue.length) {
                    args = defQueue.shift();
                    if (args[0] === null) {
                        args[0] = moduleName;
                        //If already found an anonymous module and bound it
                        //to this name, then this is some other anon module
                        //waiting for its completeLoad to fire.
                        if (found) {
                            break;
                        }
                        found = true;
                    } else if (args[0] === moduleName) {
                        //Found matching define call for this script!
                        found = true;
                    }

                    callGetModule(args);
                }
                context.defQueueMap = {};

                //Do this after the cycle of callGetModule in case the result
                //of those calls/init calls changes the registry.
                mod = getOwn(registry, moduleName);

                if (!found && !hasProp(defined, moduleName) && mod && !mod.inited) {
                    if (config.enforceDefine && (!shExports || !getGlobal(shExports))) {
                        if (hasPathFallback(moduleName)) {
                            return;
                        } else {
                            return onError(makeError('nodefine',
                                             'No define call for ' + moduleName,
                                             null,
                                             [moduleName]));
                        }
                    } else {
                        //A script that does not call define(), so just simulate
                        //the call for it.
                        callGetModule([moduleName, (shim.deps || []), shim.exportsFn]);
                    }
                }

                checkLoaded();
            },

            /**
             * Converts a module name to a file path. Supports cases where
             * moduleName may actually be just an URL.
             * Note that it **does not** call normalize on the moduleName,
             * it is assumed to have already been normalized. This is an
             * internal API, not a public one. Use toUrl for the public API.
             */
            nameToUrl: function (moduleName, ext, skipExt) {
                var paths, syms, i, parentModule, url,
                    parentPath, bundleId,
                    pkgMain = getOwn(config.pkgs, moduleName);

                if (pkgMain) {
                    moduleName = pkgMain;
                }

                bundleId = getOwn(bundlesMap, moduleName);

                if (bundleId) {
                    return context.nameToUrl(bundleId, ext, skipExt);
                }

                //If a colon is in the URL, it indicates a protocol is used and it is just
                //an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?)
                //or ends with .js, then assume the user meant to use an url and not a module id.
                //The slash is important for protocol-less URLs as well as full paths.
                if (req.jsExtRegExp.test(moduleName)) {
                    //Just a plain path, not module name lookup, so just return it.
                    //Add extension if it is included. This is a bit wonky, only non-.js things pass
                    //an extension, this method probably needs to be reworked.
                    url = moduleName + (ext || '');
                } else {
                    //A module that needs to be converted to a path.
                    paths = config.paths;

                    syms = moduleName.split('/');
                    //For each module name segment, see if there is a path
                    //registered for it. Start with most specific name
                    //and work up from it.
                    for (i = syms.length; i > 0; i -= 1) {
                        parentModule = syms.slice(0, i).join('/');

                        parentPath = getOwn(paths, parentModule);
                        if (parentPath) {
                            //If an array, it means there are a few choices,
                            //Choose the one that is desired
                            if (isArray(parentPath)) {
                                parentPath = parentPath[0];
                            }
                            syms.splice(0, i, parentPath);
                            break;
                        }
                    }

                    //Join the path parts together, then figure out if baseUrl is needed.
                    url = syms.join('/');
                    url += (ext || (/^data\:|^blob\:|\?/.test(url) || skipExt ? '' : '.js'));
                    url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;
                }

                return config.urlArgs && !/^blob\:/.test(url) ?
                       url + config.urlArgs(moduleName, url) : url;
            },

            //Delegates to req.load. Broken out as a separate function to
            //allow overriding in the optimizer.
            load: function (id, url) {
                req.load(context, id, url);
            },

            /**
             * Executes a module callback function. Broken out as a separate function
             * solely to allow the build system to sequence the files in the built
             * layer in the right sequence.
             *
             * @private
             */
            execCb: function (name, callback, args, exports) {
                return callback.apply(exports, args);
            },

            /**
             * callback for script loads, used to check status of loading.
             *
             * @param {Event} evt the event from the browser for the script
             * that was loaded.
             */
            onScriptLoad: function (evt) {
                //Using currentTarget instead of target for Firefox 2.0's sake. Not
                //all old browsers will be supported, but this one was easy enough
                //to support and still makes sense.
                if (evt.type === 'load' ||
                        (readyRegExp.test((evt.currentTarget || evt.srcElement).readyState))) {
                    //Reset interactive script so a script node is not held onto for
                    //to long.
                    interactiveScript = null;

                    //Pull out the name of the module and the context.
                    var data = getScriptData(evt);
                    context.completeLoad(data.id);
                }
            },

            /**
             * Callback for script errors.
             */
            onScriptError: function (evt) {
                var data = getScriptData(evt);
                if (!hasPathFallback(data.id)) {
                    var parents = [];
                    eachProp(registry, function(value, key) {
                        if (key.indexOf('_@r') !== 0) {
                            each(value.depMaps, function(depMap) {
                                if (depMap.id === data.id) {
                                    parents.push(key);
                                    return true;
                                }
                            });
                        }
                    });
                    return onError(makeError('scripterror', 'Script error for "' + data.id +
                                             (parents.length ?
                                             '", needed by: ' + parents.join(', ') :
                                             '"'), evt, [data.id]));
                }
            }
        };

        context.require = context.makeRequire();
        return context;
    }

    /**
     * Main entry point.
     *
     * If the only argument to require is a string, then the module that
     * is represented by that string is fetched for the appropriate context.
     *
     * If the first argument is an array, then it will be treated as an array
     * of dependency string names to fetch. An optional function callback can
     * be specified to execute when all of those dependencies are available.
     *
     * Make a local req variable to help Caja compliance (it assumes things
     * on a require that are not standardized), and to give a short
     * name for minification/local scope use.
     */
    req = requirejs = function (deps, callback, errback, optional) {

        //Find the right context, use default
        var context, config,
            contextName = defContextName;

        // Determine if have config object in the call.
        if (!isArray(deps) && typeof deps !== 'string') {
            // deps is a config object
            config = deps;
            if (isArray(callback)) {
                // Adjust args if there are dependencies
                deps = callback;
                callback = errback;
                errback = optional;
            } else {
                deps = [];
            }
        }

        if (config && config.context) {
            contextName = config.context;
        }

        context = getOwn(contexts, contextName);
        if (!context) {
            context = contexts[contextName] = req.s.newContext(contextName);
        }

        if (config) {
            context.configure(config);
        }

        return context.require(deps, callback, errback);
    };

    /**
     * Support require.config() to make it easier to cooperate with other
     * AMD loaders on globally agreed names.
     */
    req.config = function (config) {
        return req(config);
    };

    /**
     * Execute something after the current tick
     * of the event loop. Override for other envs
     * that have a better solution than setTimeout.
     * @param  {Function} fn function to execute later.
     */
    req.nextTick = typeof setTimeout !== 'undefined' ? function (fn) {
        setTimeout(fn, 4);
    } : function (fn) { fn(); };

    /**
     * Export require as a global, but only if it does not already exist.
     */
    if (!require) {
        require = req;
    }

    req.version = version;

    //Used to filter out dependencies that are already paths.
    req.jsExtRegExp = /^\/|:|\?|\.js$/;
    req.isBrowser = isBrowser;
    s = req.s = {
        contexts: contexts,
        newContext: newContext
    };

    //Create default context.
    req({});

    //Exports some context-sensitive methods on global require.
    each([
        'toUrl',
        'undef',
        'defined',
        'specified'
    ], function (prop) {
        //Reference from contexts instead of early binding to default context,
        //so that during builds, the latest instance of the default context
        //with its config gets used.
        req[prop] = function () {
            var ctx = contexts[defContextName];
            return ctx.require[prop].apply(ctx, arguments);
        };
    });

    if (isBrowser) {
        head = s.head = document.getElementsByTagName('head')[0];
        //If BASE tag is in play, using appendChild is a problem for IE6.
        //When that browser dies, this can be removed. Details in this jQuery bug:
        //http://dev.jquery.com/ticket/2709
        baseElement = document.getElementsByTagName('base')[0];
        if (baseElement) {
            head = s.head = baseElement.parentNode;
        }
    }

    /**
     * Any errors that require explicitly generates will be passed to this
     * function. Intercept/override it if you want custom error handling.
     * @param {Error} err the error object.
     */
    req.onError = defaultOnError;

    /**
     * Creates the node for the load command. Only used in browser envs.
     */
    req.createNode = function (config, moduleName, url) {
        var node = config.xhtml ?
                document.createElementNS('http://www.w3.org/1999/xhtml', 'html:script') :
                document.createElement('script');
        node.type = config.scriptType || 'text/javascript';
        node.charset = 'utf-8';
        node.async = true;
        return node;
    };

    /**
     * Does the request to load a module for the browser case.
     * Make this a separate function to allow other environments
     * to override it.
     *
     * @param {Object} context the require context to find state.
     * @param {String} moduleName the name of the module.
     * @param {Object} url the URL to the module.
     */
    req.load = function (context, moduleName, url) {
        var config = (context && context.config) || {},
            node;
        if (isBrowser) {
            //In the browser so use a script tag
            node = req.createNode(config, moduleName, url);

            node.setAttribute('data-requirecontext', context.contextName);
            node.setAttribute('data-requiremodule', moduleName);

            //Set up load listener. Test attachEvent first because IE9 has
            //a subtle issue in its addEventListener and script onload firings
            //that do not match the behavior of all other browsers with
            //addEventListener support, which fire the onload event for a
            //script right after the script execution. See:
            //https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution
            //UNFORTUNATELY Opera implements attachEvent but does not follow the script
            //script execution mode.
            if (node.attachEvent &&
                    //Check if node.attachEvent is artificially added by custom script or
                    //natively supported by browser
                    //read https://github.com/requirejs/requirejs/issues/187
                    //if we can NOT find [native code] then it must NOT natively supported.
                    //in IE8, node.attachEvent does not have toString()
                    //Note the test for "[native code" with no closing brace, see:
                    //https://github.com/requirejs/requirejs/issues/273
                    !(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code') < 0) &&
                    !isOpera) {
                //Probably IE. IE (at least 6-8) do not fire
                //script onload right after executing the script, so
                //we cannot tie the anonymous define call to a name.
                //However, IE reports the script as being in 'interactive'
                //readyState at the time of the define call.
                useInteractive = true;

                node.attachEvent('onreadystatechange', context.onScriptLoad);
                //It would be great to add an error handler here to catch
                //404s in IE9+. However, onreadystatechange will fire before
                //the error handler, so that does not help. If addEventListener
                //is used, then IE will fire error before load, but we cannot
                //use that pathway given the connect.microsoft.com issue
                //mentioned above about not doing the 'script execute,
                //then fire the script load event listener before execute
                //next script' that other browsers do.
                //Best hope: IE10 fixes the issues,
                //and then destroys all installs of IE 6-9.
                //node.attachEvent('onerror', context.onScriptError);
            } else {
                node.addEventListener('load', context.onScriptLoad, false);
                node.addEventListener('error', context.onScriptError, false);
            }
            node.src = url;

            //Calling onNodeCreated after all properties on the node have been
            //set, but before it is placed in the DOM.
            if (config.onNodeCreated) {
                config.onNodeCreated(node, config, moduleName, url);
            }

            //For some cache cases in IE 6-8, the script executes before the end
            //of the appendChild execution, so to tie an anonymous define
            //call to the module name (which is stored on the node), hold on
            //to a reference to this node, but clear after the DOM insertion.
            currentlyAddingScript = node;
            if (baseElement) {
                head.insertBefore(node, baseElement);
            } else {
                head.appendChild(node);
            }
            currentlyAddingScript = null;

            return node;
        } else if (isWebWorker) {
            try {
                //In a web worker, use importScripts. This is not a very
                //efficient use of importScripts, importScripts will block until
                //its script is downloaded and evaluated. However, if web workers
                //are in play, the expectation is that a build has been done so
                //that only one script needs to be loaded anyway. This may need
                //to be reevaluated if other use cases become common.

                // Post a task to the event loop to work around a bug in WebKit
                // where the worker gets garbage-collected after calling
                // importScripts(): https://webkit.org/b/153317
                setTimeout(function() {}, 0);
                importScripts(url);

                //Account for anonymous modules
                context.completeLoad(moduleName);
            } catch (e) {
                context.onError(makeError('importscripts',
                                'importScripts failed for ' +
                                    moduleName + ' at ' + url,
                                e,
                                [moduleName]));
            }
        }
    };

    function getInteractiveScript() {
        if (interactiveScript && interactiveScript.readyState === 'interactive') {
            return interactiveScript;
        }

        eachReverse(scripts(), function (script) {
            if (script.readyState === 'interactive') {
                return (interactiveScript = script);
            }
        });
        return interactiveScript;
    }

    //Look for a data-main script attribute, which could also adjust the baseUrl.
    if (isBrowser && !cfg.skipDataMain) {
        //Figure out baseUrl. Get it from the script tag with require.js in it.
        eachReverse(scripts(), function (script) {
            //Set the 'head' where we can append children by
            //using the script's parent.
            if (!head) {
                head = script.parentNode;
            }

            //Look for a data-main attribute to set main script for the page
            //to load. If it is there, the path to data main becomes the
            //baseUrl, if it is not already set.
            dataMain = script.getAttribute('data-main');
            if (dataMain) {
                //Preserve dataMain in case it is a path (i.e. contains '?')
                mainScript = dataMain;

                //Set final baseUrl if there is not already an explicit one,
                //but only do so if the data-main value is not a loader plugin
                //module ID.
                if (!cfg.baseUrl && mainScript.indexOf('!') === -1) {
                    //Pull off the directory of data-main for use as the
                    //baseUrl.
                    src = mainScript.split('/');
                    mainScript = src.pop();
                    subPath = src.length ? src.join('/')  + '/' : './';

                    cfg.baseUrl = subPath;
                }

                //Strip off any trailing .js since mainScript is now
                //like a module name.
                mainScript = mainScript.replace(jsSuffixRegExp, '');

                //If mainScript is still a path, fall back to dataMain
                if (req.jsExtRegExp.test(mainScript)) {
                    mainScript = dataMain;
                }

                //Put the data-main script in the files to load.
                cfg.deps = cfg.deps ? cfg.deps.concat(mainScript) : [mainScript];

                return true;
            }
        });
    }

    /**
     * The function that handles definitions of modules. Differs from
     * require() in that a string for the module should be the first argument,
     * and the function to execute after dependencies are loaded should
     * return a value to define the module corresponding to the first argument's
     * name.
     */
    define = function (name, deps, callback) {
        var node, context;

        //Allow for anonymous modules
        if (typeof name !== 'string') {
            //Adjust args appropriately
            callback = deps;
            deps = name;
            name = null;
        }

        //This module may not have dependencies
        if (!isArray(deps)) {
            callback = deps;
            deps = null;
        }

        //If no name, and callback is a function, then figure out if it a
        //CommonJS thing with dependencies.
        if (!deps && isFunction(callback)) {
            deps = [];
            //Remove comments from the callback string,
            //look for require calls, and pull them into the dependencies,
            //but only if there are function args.
            if (callback.length) {
                callback
                    .toString()
                    .replace(commentRegExp, commentReplace)
                    .replace(cjsRequireRegExp, function (match, dep) {
                        deps.push(dep);
                    });

                //May be a CommonJS thing even without require calls, but still
                //could use exports, and module. Avoid doing exports and module
                //work though if it just needs require.
                //REQUIRES the function to expect the CommonJS variables in the
                //order listed below.
                deps = (callback.length === 1 ? ['require'] : ['require', 'exports', 'module']).concat(deps);
            }
        }

        //If in IE 6-8 and hit an anonymous define() call, do the interactive
        //work.
        if (useInteractive) {
            node = currentlyAddingScript || getInteractiveScript();
            if (node) {
                if (!name) {
                    name = node.getAttribute('data-requiremodule');
                }
                context = contexts[node.getAttribute('data-requirecontext')];
            }
        }

        //Always save off evaluating the def call until the script onload handler.
        //This allows multiple modules to be in a file without prematurely
        //tracing dependencies, and allows for anonymous module support,
        //where the module name is not known until the script onload event
        //occurs. If no context, use the global queue, and get it processed
        //in the onscript load callback.
        if (context) {
            context.defQueue.push([name, deps, callback]);
            context.defQueueMap[name] = true;
        } else {
            globalDefQueue.push([name, deps, callback]);
        }
    };

    define.amd = {
        jQuery: true
    };

    /**
     * Executes the text. Normally just uses eval, but can be modified
     * to use a better, environment-specific call. Only used for transpiling
     * loader plugins, not for plain JS modules.
     * @param {String} text the text to execute/evaluate.
     */
    req.exec = function (text) {
        /*jslint evil: true */
        return eval(text);
    };

    //Set up with config info.
    req(cfg);
}(this, (typeof setTimeout === 'undefined' ? undefined : setTimeout)));

",
+              "headers": [
+                [
+                  "content-type",
+                  "text/javascript; charset=utf-8"
+                ]
+              ],
+              "ok": true,
+              "status": 200,
+              "status_text": ""
+            },
+            "https://localhost:6006/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22coco/bbox_mAP_75%22%7D%5D": {
+              "data": "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",
+              "ok": true,
+              "headers": [
+                [
+                  "content-type",
+                  "application/json"
+                ]
+              ],
+              "status": 200,
+              "status_text": ""
+            },
+            "https://localhost:6006/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22coco/bbox_mAP_l%22%7D%5D": {
+              "data": "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",
+              "ok": true,
+              "headers": [
+                [
+                  "content-type",
+                  "application/json"
+                ]
+              ],
+              "status": 200,
+              "status_text": ""
+            },
+            "https://localhost:6006/experiment/defaultExperimentId/data/plugin/timeseries/timeSeries?requests=%5B%7B%22plugin%22:%22scalars%22,%22tag%22:%22coco/bbox_mAP_m%22%7D%5D": {
+              "data": "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",
+              "ok": true,
+              "headers": [
+                [
+                  "content-type",
+                  "application/json"
+                ]
+              ],
+              "status": 200,
+              "status_text": ""
+            }
+          }
+        },
+        "id": "_wpQGXu9aONh",
+        "outputId": "1093cdcd-5b8a-44b4-f3b0-cbc73083ba78"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              ""
+            ],
+            "application/javascript": [
+              "\n",
+              "        (async () => {\n",
+              "            const url = new URL(await google.colab.kernel.proxyPort(6006, {'cache': true}));\n",
+              "            url.searchParams.set('tensorboardColab', 'true');\n",
+              "            const iframe = document.createElement('iframe');\n",
+              "            iframe.src = url;\n",
+              "            iframe.setAttribute('width', '100%');\n",
+              "            iframe.setAttribute('height', '800');\n",
+              "            iframe.setAttribute('frameborder', 0);\n",
+              "            document.body.appendChild(iframe);\n",
+              "        })();\n",
+              "    "
+            ]
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "# load tensorboard in colab\n",
+        "%load_ext tensorboard\n",
+        "\n",
+        "# see curves in tensorboard\n",
+        "%tensorboard --logdir ./work_dirs"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "MfQ-yspZLuuI"
+      },
+      "source": [
+        "From the tensorboard, we can observe that changes of loss and learning rate. We can see the losses of each branch gradually decrease as the training goes by.\n",
+        "\n",
+        "## Test the Trained Detector\n",
+        "\n",
+        "After finetuning the detector, let's visualize the prediction results!"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 71,
+          "referenced_widgets": [
+            "01b8530a4c8c48ee9ce8f7ff552a293f",
+            "4bb4e998336e4889afec5712698e98a8"
+          ]
+        },
+        "id": "CHDYQSRNNDxt",
+        "outputId": "10dfc047-8adf-4e30-a737-230c23602a1b"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Loads checkpoint by local backend from path: ./work_dirs/rtmdet_tiny_1xb4-20e_balloon/best_coco_bbox_mAP_epoch_17.pth\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "Output()"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "01b8530a4c8c48ee9ce8f7ff552a293f"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [],
+            "text/html": [
+              "
    \n"
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "\n"
+            ],
+            "text/html": [
+              "
    \n",
+              "
    \n"
+            ]
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "from mmdet.apis import DetInferencer\n",
+        "import glob\n",
+        "\n",
+        "# Choose to use a config\n",
+        "config = 'configs/rtmdet/rtmdet_tiny_1xb4-20e_balloon.py'\n",
+        "# Setup a checkpoint file to load\n",
+        "checkpoint = glob.glob('./work_dirs/rtmdet_tiny_1xb4-20e_balloon/best_coco*.pth')[0]\n",
+        "\n",
+        "# Set the device to be used for evaluation\n",
+        "device = 'cuda:0'\n",
+        "\n",
+        "# Initialize the DetInferencer\n",
+        "inferencer = DetInferencer(config, checkpoint, device)\n",
+        "\n",
+        "# Use the detector to do inference\n",
+        "img = './data/balloon/val/4838031651_3e7b5ea5c7_b.jpg'\n",
+        "result = inferencer(img, out_dir='./output')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 14,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 618
+        },
+        "id": "zDzwbUsfN4lR",
+        "outputId": "26cbef68-3f0e-4958-af2c-48b837f61ae7"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              ""
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {},
+          "execution_count": 14
+        }
+      ],
+      "source": [
+        "# Show the output image\n",
+        "Image.open('./output/vis/4838031651_3e7b5ea5c7_b.jpg')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "F1L8o3rtc37M"
+      },
+      "source": [
+        "## What to Do Next?\n",
+        "\n",
+        "So far, we have learnt how to test and train a one-stage detector using MMDetection. To further explore MMDetection, you could do several other things as shown below:\n",
+        "\n",
+        "- Try YOLO series object detection using [MMYOLO](https://github.com/open-mmlab/mmyolo), also one of the OpenMMLab projects. In MMYOLO, not only can you try all the methods supported in MMDetection but also some YOLO series detectors.\n",
+        "- Try rotated object detection using [MMRotate](https://github.com/open-mmlab/mmrotate), also one of the OpenMMLab projects. In MMRotate, not only can you try all the methods supported in MMDetection but also some rotated object detectors.\n",
+        "- Try 3D object detection using [MMDetection3D](https://github.com/open-mmlab/mmdetection3d), also one of the OpenMMLab projects. In MMDetection3D, not only can you try all the methods supported in MMDetection but also some 3D object detectors.\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "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.8.13"
+    },
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "b1188048a1f04c2fa77c0d3829da39bd": {
+          "model_module": "@jupyter-widgets/output",
+          "model_name": "OutputModel",
+          "model_module_version": "1.0.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/output",
+            "_model_module_version": "1.0.0",
+            "_model_name": "OutputModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/output",
+            "_view_module_version": "1.0.0",
+            "_view_name": "OutputView",
+            "layout": "IPY_MODEL_534561e3c4804bae96a30d44493d701d",
+            "msg_id": "",
+            "outputs": [
+              {
+                "output_type": "display_data",
+                "data": {
+                  "text/plain": "Inference \u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;58;58;58m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;249;38;114m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;58;58;58m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;249;38;114m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m  \u001b[36m \u001b[0m\n",
+                  "text/html": "
    Inference ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━   \n
    \n"
+                },
+                "metadata": {}
+              }
+            ]
+          }
+        },
+        "534561e3c4804bae96a30d44493d701d": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "01b8530a4c8c48ee9ce8f7ff552a293f": {
+          "model_module": "@jupyter-widgets/output",
+          "model_name": "OutputModel",
+          "model_module_version": "1.0.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/output",
+            "_model_module_version": "1.0.0",
+            "_model_name": "OutputModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/output",
+            "_view_module_version": "1.0.0",
+            "_view_name": "OutputView",
+            "layout": "IPY_MODEL_4bb4e998336e4889afec5712698e98a8",
+            "msg_id": "",
+            "outputs": [
+              {
+                "output_type": "display_data",
+                "data": {
+                  "text/plain": "Inference \u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;58;58;58m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;249;38;114m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;58;58;58m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;249;38;114m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m  \u001b[36m \u001b[0m\n",
+                  "text/html": "
    Inference ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━   \n
    \n"
+                },
+                "metadata": {}
+              }
+            ]
+          }
+        },
+        "4bb4e998336e4889afec5712698e98a8": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        }
+      }
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
diff --git a/mmdetection/demo/create_result_gif.py b/mmdetection/demo/create_result_gif.py
new file mode 100644
index 00000000..8e56a33a
--- /dev/null
+++ b/mmdetection/demo/create_result_gif.py
@@ -0,0 +1,165 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os
+import os.path as osp
+
+import matplotlib.patches as mpatches
+import matplotlib.pyplot as plt
+import mmcv
+import numpy as np
+from mmengine.utils import scandir
+
+try:
+    import imageio
+except ImportError:
+    imageio = None
+
+
+# TODO verify after refactoring analyze_results.py
+def parse_args():
+    parser = argparse.ArgumentParser(description='Create GIF for demo')
+    parser.add_argument(
+        'image_dir',
+        help='directory where result '
+        'images save path generated by ‘analyze_results.py’')
+    parser.add_argument(
+        '--out',
+        type=str,
+        default='result.gif',
+        help='gif path where will be saved')
+    args = parser.parse_args()
+    return args
+
+
+def _generate_batch_data(sampler, batch_size):
+    batch = []
+    for idx in sampler:
+        batch.append(idx)
+        if len(batch) == batch_size:
+            yield batch
+            batch = []
+    if len(batch) > 0:
+        yield batch
+
+
+def create_gif(frames, gif_name, duration=2):
+    """Create gif through imageio.
+
+    Args:
+        frames (list[ndarray]): Image frames
+        gif_name (str): Saved gif name
+        duration (int): Display interval (s),
+            Default: 2
+    """
+    if imageio is None:
+        raise RuntimeError('imageio is not installed,'
+                           'Please use “pip install imageio” to install')
+    imageio.mimsave(gif_name, frames, 'GIF', duration=duration)
+
+
+def create_frame_by_matplotlib(image_dir,
+                               nrows=1,
+                               fig_size=(300, 300),
+                               font_size=15):
+    """Create gif frame image through matplotlib.
+
+    Args:
+        image_dir (str): Root directory of result images
+        nrows (int): Number of rows displayed, Default: 1
+        fig_size (tuple): Figure size of the pyplot figure.
+           Default: (300, 300)
+        font_size (int): Font size of texts. Default: 15
+
+    Returns:
+        list[ndarray]: image frames
+    """
+
+    result_dir_names = os.listdir(image_dir)
+    assert len(result_dir_names) == 2
+    # Longer length has higher priority
+    result_dir_names.reverse()
+
+    images_list = []
+    for dir_names in result_dir_names:
+        images_list.append(scandir(osp.join(image_dir, dir_names)))
+
+    frames = []
+    for paths in _generate_batch_data(zip(*images_list), nrows):
+
+        fig, axes = plt.subplots(nrows=nrows, ncols=2)
+        fig.suptitle('Good/bad case selected according '
+                     'to the COCO mAP of the single image')
+
+        det_patch = mpatches.Patch(color='salmon', label='prediction')
+        gt_patch = mpatches.Patch(color='royalblue', label='ground truth')
+        # bbox_to_anchor may need to be finetuned
+        plt.legend(
+            handles=[det_patch, gt_patch],
+            bbox_to_anchor=(1, -0.18),
+            loc='lower right',
+            borderaxespad=0.)
+
+        if nrows == 1:
+            axes = [axes]
+
+        dpi = fig.get_dpi()
+        # set fig size and margin
+        fig.set_size_inches(
+            (fig_size[0] * 2 + fig_size[0] // 20) / dpi,
+            (fig_size[1] * nrows + fig_size[1] // 3) / dpi,
+        )
+
+        fig.tight_layout()
+        # set subplot margin
+        plt.subplots_adjust(
+            hspace=.05,
+            wspace=0.05,
+            left=0.02,
+            right=0.98,
+            bottom=0.02,
+            top=0.98)
+
+        for i, (path_tuple, ax_tuple) in enumerate(zip(paths, axes)):
+            image_path_left = osp.join(
+                osp.join(image_dir, result_dir_names[0], path_tuple[0]))
+            image_path_right = osp.join(
+                osp.join(image_dir, result_dir_names[1], path_tuple[1]))
+            image_left = mmcv.imread(image_path_left)
+            image_left = mmcv.rgb2bgr(image_left)
+            image_right = mmcv.imread(image_path_right)
+            image_right = mmcv.rgb2bgr(image_right)
+
+            if i == 0:
+                ax_tuple[0].set_title(
+                    result_dir_names[0], fontdict={'size': font_size})
+                ax_tuple[1].set_title(
+                    result_dir_names[1], fontdict={'size': font_size})
+            ax_tuple[0].imshow(
+                image_left, extent=(0, *fig_size, 0), interpolation='bilinear')
+            ax_tuple[0].axis('off')
+            ax_tuple[1].imshow(
+                image_right,
+                extent=(0, *fig_size, 0),
+                interpolation='bilinear')
+            ax_tuple[1].axis('off')
+
+        canvas = fig.canvas
+        s, (width, height) = canvas.print_to_buffer()
+        buffer = np.frombuffer(s, dtype='uint8')
+        img_rgba = buffer.reshape(height, width, 4)
+        rgb, alpha = np.split(img_rgba, [3], axis=2)
+        img = rgb.astype('uint8')
+
+        frames.append(img)
+
+    return frames
+
+
+def main():
+    args = parse_args()
+    frames = create_frame_by_matplotlib(args.image_dir)
+    create_gif(frames, args.out)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmdetection/demo/demo.jpg b/mmdetection/demo/demo.jpg
new file mode 100644
index 00000000..dd613cee
Binary files /dev/null and b/mmdetection/demo/demo.jpg differ
diff --git a/mmdetection/demo/demo.mp4 b/mmdetection/demo/demo.mp4
new file mode 100644
index 00000000..6c06d15d
Binary files /dev/null and b/mmdetection/demo/demo.mp4 differ
diff --git a/mmdetection/demo/demo_mot.mp4 b/mmdetection/demo/demo_mot.mp4
new file mode 100644
index 00000000..12e377e6
Binary files /dev/null and b/mmdetection/demo/demo_mot.mp4 differ
diff --git a/mmdetection/demo/demo_multi_model.py b/mmdetection/demo/demo_multi_model.py
new file mode 100644
index 00000000..f7935de6
--- /dev/null
+++ b/mmdetection/demo/demo_multi_model.py
@@ -0,0 +1,212 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+"""Support for multi-model fusion, and currently only the Weighted Box Fusion
+(WBF) fusion method is supported.
+
+References: https://github.com/ZFTurbo/Weighted-Boxes-Fusion
+
+Example:
+
+     python demo/demo_multi_model.py demo/demo.jpg \
+         ./configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_1x_coco.py \
+         ./configs/retinanet/retinanet_r50-caffe_fpn_1x_coco.py \
+         --checkpoints \
+         https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_caffe_fpn_1x_coco/faster_rcnn_r50_caffe_fpn_1x_coco_bbox_mAP-0.378_20200504_180032-c5925ee5.pth \  # noqa
+         https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r50_caffe_fpn_1x_coco/retinanet_r50_caffe_fpn_1x_coco_20200531-f11027c5.pth \
+         --weights 1 2
+"""
+
+import argparse
+import os.path as osp
+
+import mmcv
+import mmengine
+from mmengine.fileio import isdir, join_path, list_dir_or_file
+from mmengine.logging import print_log
+from mmengine.structures import InstanceData
+
+from mmdet.apis import DetInferencer
+from mmdet.models.utils import weighted_boxes_fusion
+from mmdet.registry import VISUALIZERS
+from mmdet.structures import DetDataSample
+
+IMG_EXTENSIONS = ('.jpg', '.jpeg', '.png', '.ppm', '.bmp', '.pgm', '.tif',
+                  '.tiff', '.webp')
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='MMDetection multi-model inference demo')
+    parser.add_argument(
+        'inputs', type=str, help='Input image file or folder path.')
+    parser.add_argument(
+        'config',
+        type=str,
+        nargs='*',
+        help='Config file(s), support receive multiple files')
+    parser.add_argument(
+        '--checkpoints',
+        type=str,
+        nargs='*',
+        help='Checkpoint file(s), support receive multiple files, '
+        'remember to correspond to the above config',
+    )
+    parser.add_argument(
+        '--weights',
+        type=float,
+        nargs='*',
+        default=None,
+        help='weights for each model, remember to '
+        'correspond to the above config')
+    parser.add_argument(
+        '--fusion-iou-thr',
+        type=float,
+        default=0.55,
+        help='IoU value for boxes to be a match in wbf')
+    parser.add_argument(
+        '--skip-box-thr',
+        type=float,
+        default=0.0,
+        help='exclude boxes with score lower than this variable in wbf')
+    parser.add_argument(
+        '--conf-type',
+        type=str,
+        default='avg',  # avg, max, box_and_model_avg, absent_model_aware_avg
+        help='how to calculate confidence in weighted boxes in wbf')
+    parser.add_argument(
+        '--out-dir',
+        type=str,
+        default='outputs',
+        help='Output directory of images or prediction results.')
+    parser.add_argument(
+        '--device', default='cuda:0', help='Device used for inference')
+    parser.add_argument(
+        '--pred-score-thr',
+        type=float,
+        default=0.3,
+        help='bbox score threshold')
+    parser.add_argument(
+        '--batch-size', type=int, default=1, help='Inference batch size.')
+    parser.add_argument(
+        '--show',
+        action='store_true',
+        help='Display the image in a popup window.')
+    parser.add_argument(
+        '--no-save-vis',
+        action='store_true',
+        help='Do not save detection vis results')
+    parser.add_argument(
+        '--no-save-pred',
+        action='store_true',
+        help='Do not save detection json results')
+    parser.add_argument(
+        '--palette',
+        default='none',
+        choices=['coco', 'voc', 'citys', 'random', 'none'],
+        help='Color palette used for visualization')
+
+    args = parser.parse_args()
+
+    if args.no_save_vis and args.no_save_pred:
+        args.out_dir = ''
+
+    return args
+
+
+def main():
+    args = parse_args()
+
+    results = []
+    cfg_visualizer = None
+    dataset_meta = None
+
+    inputs = []
+    filename_list = []
+    if isdir(args.inputs):
+        dir = list_dir_or_file(
+            args.inputs, list_dir=False, suffix=IMG_EXTENSIONS)
+        for filename in dir:
+            img = mmcv.imread(join_path(args.inputs, filename))
+            inputs.append(img)
+            filename_list.append(filename)
+    else:
+        img = mmcv.imread(args.inputs)
+        inputs.append(img)
+        img_name = osp.basename(args.inputs)
+        filename_list.append(img_name)
+
+    for i, (config,
+            checkpoint) in enumerate(zip(args.config, args.checkpoints)):
+        inferencer = DetInferencer(
+            config, checkpoint, device=args.device, palette=args.palette)
+
+        result_raw = inferencer(
+            inputs=inputs,
+            batch_size=args.batch_size,
+            no_save_vis=True,
+            pred_score_thr=args.pred_score_thr)
+
+        if i == 0:
+            cfg_visualizer = inferencer.cfg.visualizer
+            dataset_meta = inferencer.model.dataset_meta
+            results = [{
+                'bboxes_list': [],
+                'scores_list': [],
+                'labels_list': []
+            } for _ in range(len(result_raw['predictions']))]
+
+        for res, raw in zip(results, result_raw['predictions']):
+            res['bboxes_list'].append(raw['bboxes'])
+            res['scores_list'].append(raw['scores'])
+            res['labels_list'].append(raw['labels'])
+
+    visualizer = VISUALIZERS.build(cfg_visualizer)
+    visualizer.dataset_meta = dataset_meta
+
+    for i in range(len(results)):
+        bboxes, scores, labels = weighted_boxes_fusion(
+            results[i]['bboxes_list'],
+            results[i]['scores_list'],
+            results[i]['labels_list'],
+            weights=args.weights,
+            iou_thr=args.fusion_iou_thr,
+            skip_box_thr=args.skip_box_thr,
+            conf_type=args.conf_type)
+
+        pred_instances = InstanceData()
+        pred_instances.bboxes = bboxes
+        pred_instances.scores = scores
+        pred_instances.labels = labels
+
+        fusion_result = DetDataSample(pred_instances=pred_instances)
+
+        img_name = filename_list[i]
+
+        if not args.no_save_pred:
+            out_json_path = (
+                args.out_dir + '/preds/' + img_name.split('.')[0] + '.json')
+            mmengine.dump(
+                {
+                    'labels': labels.tolist(),
+                    'scores': scores.tolist(),
+                    'bboxes': bboxes.tolist()
+                }, out_json_path)
+
+        out_file = osp.join(args.out_dir, 'vis',
+                            img_name) if not args.no_save_vis else None
+
+        visualizer.add_datasample(
+            img_name,
+            inputs[i][..., ::-1],
+            data_sample=fusion_result,
+            show=args.show,
+            draw_gt=False,
+            wait_time=0,
+            pred_score_thr=args.pred_score_thr,
+            out_file=out_file)
+
+    if not args.no_save_vis:
+        print_log(f'results have been saved at {args.out_dir}')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmdetection/demo/image_demo.py b/mmdetection/demo/image_demo.py
new file mode 100644
index 00000000..1f994cb4
--- /dev/null
+++ b/mmdetection/demo/image_demo.py
@@ -0,0 +1,192 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+"""Image Demo.
+
+This script adopts a new infenence class, currently supports image path,
+np.array and folder input formats, and will support video and webcam
+in the future.
+
+Example:
+    Save visualizations and predictions results::
+
+        python demo/image_demo.py demo/demo.jpg rtmdet-s
+
+        python demo/image_demo.py demo/demo.jpg \
+        configs/rtmdet/rtmdet_s_8xb32-300e_coco.py \
+        --weights rtmdet_s_8xb32-300e_coco_20220905_161602-387a891e.pth
+
+        python demo/image_demo.py demo/demo.jpg \
+        glip_atss_swin-t_a_fpn_dyhead_pretrain_obj365 --texts bench
+
+        python demo/image_demo.py demo/demo.jpg \
+        glip_atss_swin-t_a_fpn_dyhead_pretrain_obj365 --texts 'bench . car .'
+
+        python demo/image_demo.py demo/demo.jpg \
+        glip_atss_swin-t_a_fpn_dyhead_pretrain_obj365
+        --texts 'bench . car .' -c
+
+        python demo/image_demo.py demo/demo.jpg \
+        glip_atss_swin-t_a_fpn_dyhead_pretrain_obj365 \
+        --texts 'There are a lot of cars here.'
+
+        python demo/image_demo.py demo/demo.jpg \
+        glip_atss_swin-t_a_fpn_dyhead_pretrain_obj365 \
+        --texts '$: coco'
+
+        python demo/image_demo.py demo/demo.jpg \
+        glip_atss_swin-t_a_fpn_dyhead_pretrain_obj365 \
+        --texts '$: lvis' --pred-score-thr 0.7 \
+        --palette random --chunked-size 80
+
+        python demo/image_demo.py demo/demo.jpg \
+        grounding_dino_swin-t_pretrain_obj365_goldg_cap4m \
+        --texts '$: lvis' --pred-score-thr 0.4 \
+        --palette random --chunked-size 80
+
+        python demo/image_demo.py demo/demo.jpg \
+        grounding_dino_swin-t_pretrain_obj365_goldg_cap4m \
+        --texts "a red car in the upper right corner" \
+        --tokens-positive -1
+
+    Visualize prediction results::
+
+        python demo/image_demo.py demo/demo.jpg rtmdet-ins-s --show
+
+        python demo/image_demo.py demo/demo.jpg rtmdet-ins_s_8xb32-300e_coco \
+        --show
+"""
+
+import ast
+from argparse import ArgumentParser
+
+from mmengine.logging import print_log
+
+from mmdet.apis import DetInferencer
+from mmdet.evaluation import get_classes
+
+
+def parse_args():
+    parser = ArgumentParser()
+    parser.add_argument(
+        'inputs', type=str, help='Input image file or folder path.')
+    parser.add_argument(
+        'model',
+        type=str,
+        help='Config or checkpoint .pth file or the model name '
+        'and alias defined in metafile. The model configuration '
+        'file will try to read from .pth if the parameter is '
+        'a .pth weights file.')
+    parser.add_argument('--weights', default=None, help='Checkpoint file')
+    parser.add_argument(
+        '--out-dir',
+        type=str,
+        default='outputs',
+        help='Output directory of images or prediction results.')
+    # Once you input a format similar to $: xxx, it indicates that
+    # the prompt is based on the dataset class name.
+    # support $: coco, $: voc, $: cityscapes, $: lvis, $: imagenet_det.
+    # detail to `mmdet/evaluation/functional/class_names.py`
+    parser.add_argument(
+        '--texts', help='text prompt, such as "bench . car .", "$: coco"')
+    parser.add_argument(
+        '--device', default='cuda:0', help='Device used for inference')
+    parser.add_argument(
+        '--pred-score-thr',
+        type=float,
+        default=0.3,
+        help='bbox score threshold')
+    parser.add_argument(
+        '--batch-size', type=int, default=1, help='Inference batch size.')
+    parser.add_argument(
+        '--show',
+        action='store_true',
+        help='Display the image in a popup window.')
+    parser.add_argument(
+        '--no-save-vis',
+        action='store_true',
+        help='Do not save detection vis results')
+    parser.add_argument(
+        '--no-save-pred',
+        action='store_true',
+        help='Do not save detection json results')
+    parser.add_argument(
+        '--print-result',
+        action='store_true',
+        help='Whether to print the results.')
+    parser.add_argument(
+        '--palette',
+        default='none',
+        choices=['coco', 'voc', 'citys', 'random', 'none'],
+        help='Color palette used for visualization')
+    # only for GLIP and Grounding DINO
+    parser.add_argument(
+        '--custom-entities',
+        '-c',
+        action='store_true',
+        help='Whether to customize entity names? '
+        'If so, the input text should be '
+        '"cls_name1 . cls_name2 . cls_name3 ." format')
+    parser.add_argument(
+        '--chunked-size',
+        '-s',
+        type=int,
+        default=-1,
+        help='If the number of categories is very large, '
+        'you can specify this parameter to truncate multiple predictions.')
+    # only for Grounding DINO
+    parser.add_argument(
+        '--tokens-positive',
+        '-p',
+        type=str,
+        help='Used to specify which locations in the input text are of '
+        'interest to the user. -1 indicates that no area is of interest, '
+        'None indicates ignoring this parameter. '
+        'The two-dimensional array represents the start and end positions.')
+
+    call_args = vars(parser.parse_args())
+
+    if call_args['no_save_vis'] and call_args['no_save_pred']:
+        call_args['out_dir'] = ''
+
+    if call_args['model'].endswith('.pth'):
+        print_log('The model is a weight file, automatically '
+                  'assign the model to --weights')
+        call_args['weights'] = call_args['model']
+        call_args['model'] = None
+
+    if call_args['texts'] is not None:
+        if call_args['texts'].startswith('$:'):
+            dataset_name = call_args['texts'][3:].strip()
+            class_names = get_classes(dataset_name)
+            call_args['texts'] = [tuple(class_names)]
+
+    if call_args['tokens_positive'] is not None:
+        call_args['tokens_positive'] = ast.literal_eval(
+            call_args['tokens_positive'])
+
+    init_kws = ['model', 'weights', 'device', 'palette']
+    init_args = {}
+    for init_kw in init_kws:
+        init_args[init_kw] = call_args.pop(init_kw)
+
+    return init_args, call_args
+
+
+def main():
+    init_args, call_args = parse_args()
+    # TODO: Video and Webcam are currently not supported and
+    #  may consume too much memory if your input folder has a lot of images.
+    #  We will be optimized later.
+    inferencer = DetInferencer(**init_args)
+
+    chunked_size = call_args.pop('chunked_size')
+    inferencer.model.test_cfg.chunked_size = chunked_size
+
+    inferencer(**call_args)
+
+    if call_args['out_dir'] != '' and not (call_args['no_save_vis']
+                                           and call_args['no_save_pred']):
+        print_log(f'results have been saved at {call_args["out_dir"]}')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmdetection/demo/inference_demo.ipynb b/mmdetection/demo/inference_demo.ipynb
new file mode 100644
index 00000000..36df6f84
--- /dev/null
+++ b/mmdetection/demo/inference_demo.ipynb
@@ -0,0 +1,1413 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "gCMycQ_2U8SA"
+      },
+      "source": [
+        "
    \n",
+        "  \n",
+        "  
     
    \n",
+        "  
    \n",
+        "    OpenMMLab website\n",
+        "    \n",
+        "      \n",
+        "        HOT\n",
+        "      \n",
+        "    \n",
+        "        \n",
+        "    OpenMMLab platform\n",
+        "    \n",
+        "      \n",
+        "        TRY IT OUT\n",
+        "      \n",
+        "    \n",
+        "  
    \n",
+        "  
     
    \n",
+        "\n",
+        "\"Open\n",
+        "\n",
+        "[![PyPI](https://img.shields.io/pypi/v/mmdet)](https://pypi.org/project/mmdet)\n",
+        "[![docs](https://img.shields.io/badge/docs-latest-blue)](https://mmdetection.readthedocs.io/en/latest/)\n",
+        "[![badge](https://github.com/open-mmlab/mmdetection/workflows/build/badge.svg)](https://github.com/open-mmlab/mmdetection/actions)\n",
+        "[![codecov](https://codecov.io/gh/open-mmlab/mmdetection/branch/master/graph/badge.svg)](https://codecov.io/gh/open-mmlab/mmdetection)\n",
+        "[![license](https://img.shields.io/github/license/open-mmlab/mmdetection.svg)](https://github.com/open-mmlab/mmdetection/blob/master/LICENSE)\n",
+        "[![open issues](https://isitmaintained.com/badge/open/open-mmlab/mmdetection.svg)](https://github.com/open-mmlab/mmdetection/issues)\n",
+        "[![issue resolution](https://isitmaintained.com/badge/resolution/open-mmlab/mmdetection.svg)](https://github.com/open-mmlab/mmdetection/issues)\n",
+        "\n",
+        "[📘Documentation](https://mmdetection.readthedocs.io/en/3.x/) |\n",
+        "[🛠️Installation](https://mmdetection.readthedocs.io/en/3.x/get_started.html) |\n",
+        "[👀Model Zoo](https://mmdetection.readthedocs.io/en/3.x/model_zoo.html) |\n",
+        "[🆕Update News](https://mmdetection.readthedocs.io/en/3.x/notes/changelog.html) |\n",
+        "[🚀Ongoing Projects](https://github.com/open-mmlab/mmdetection/projects) |\n",
+        "[🤔Reporting Issues](https://github.com/open-mmlab/mmdetection/issues/new/choose)\n",
+        "\n",
+        "
    \n",
+        "\n",
+        "
    \n",
+        "  \n",
+        "    \"\"\n",
+        "  \"\"\n",
+        "  \n",
+        "    \"\"\n",
+        "  \"\"\n",
+        "  \n",
+        "    \"\"\n",
+        "  \"\"\n",
+        "  \n",
+        "    \"\"\n",
+        "  \"\"\n",
+        "  \n",
+        "    \"\"\n",
+        "  \"\"\n",
+        "  \n",
+        "    \"\"\n",
+        "
    "
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "aGYwt_UjIrqp"
+      },
+      "source": [
+        "# Inferencer\n",
+        "\n",
+        "In this tutorial, you will learn how to perform inference with a MMDetection `DetInferencer`.\n",
+        "\n",
+        "Let's start!\n",
+        "\n",
+        "```{note}\n",
+        "The commands in this tutorial are mainly for Colab.\n",
+        "You can click the button above, `Open in Colab`, to run this notebook in Colab.\n",
+        "```"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "tJxJHruNLb7Y"
+      },
+      "source": [
+        "## Install MMDetection"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Wi4LPmsR66sy",
+        "outputId": "0077a9a3-0183-4002-fe7a-2a12f020cf69"
+      },
+      "outputs": [],
+      "source": [
+        "# Check nvcc version\n",
+        "!nvcc -V\n",
+        "# Check GCC version\n",
+        "!gcc --version"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "gkGnB9WyHSXB",
+        "outputId": "5945fe0b-13a5-4f1b-dff9-8beb1df67ab0"
+      },
+      "outputs": [],
+      "source": [
+        "# install dependencies\n",
+        "%pip install -U openmim\n",
+        "!mim install \"mmengine>=0.7.0\"\n",
+        "!mim install \"mmcv>=2.0.0rc4\"\n",
+        "\n",
+        "# Install mmdetection\n",
+        "!rm -rf mmdetection\n",
+        "!git clone https://github.com/open-mmlab/mmdetection.git -b dev-3.x\n",
+        "%cd mmdetection\n",
+        "\n",
+        "%pip install -e ."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "_YeUiqAoCaoV",
+        "outputId": "06e4c803-ac46-49e6-b8fa-1a85c23fa482"
+      },
+      "outputs": [],
+      "source": [
+        "from mmengine.utils import get_git_hash\n",
+        "from mmengine.utils.dl_utils import collect_env as collect_base_env\n",
+        "\n",
+        "import mmdet\n",
+        "\n",
+        "\n",
+        "def collect_env():\n",
+        "    \"\"\"Collect the information of the running environments.\"\"\"\n",
+        "    env_info = collect_base_env()\n",
+        "    env_info['MMDetection'] = f'{mmdet.__version__}+{get_git_hash()[:7]}'\n",
+        "    return env_info\n",
+        "\n",
+        "\n",
+        "if __name__ == '__main__':\n",
+        "    for name, val in collect_env().items():\n",
+        "        print(f'{name}: {val}')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "fLgFRMtP91ue"
+      },
+      "source": [
+        "## `DetInferencer`\n",
+        "\n",
+        "### Basic Usage\n",
+        "\n",
+        "We use the high-level API `DetInferencer` implemented in the MMDetection. This API is created to ease the inference process. The details of the codes can be found [here](https://github.com/open-mmlab/mmdetection/blob/dev-3.x/mmdet/apis/det_inferencer.py)."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000,
+          "referenced_widgets": [
+            "6fa2cda48fda43f9bf53a0f533392eba",
+            "0226fedc26044ab2abdccc4fcbe226f8"
+          ]
+        },
+        "id": "WJHpC402p2w9",
+        "outputId": "c2326326-d198-4fce-ec0e-a9cc2e35ba09"
+      },
+      "outputs": [],
+      "source": [
+        "from mmdet.apis import DetInferencer\n",
+        "\n",
+        "# Initialize the DetInferencer\n",
+        "inferencer = DetInferencer('rtmdet_tiny_8xb32-300e_coco')\n",
+        "\n",
+        "# Perform inference\n",
+        "inferencer('demo/demo.jpg', out_dir='./output')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 444
+        },
+        "id": "34JfPWRRSlNh",
+        "outputId": "8eec8bc4-4824-47ac-b10f-41538422fb28"
+      },
+      "outputs": [],
+      "source": [
+        "# Show the output image\n",
+        "from PIL import Image\n",
+        "Image.open('./output/vis/demo.jpg')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "-53WPeyBqRHe"
+      },
+      "source": [
+        "### Initialization\n",
+        "\n",
+        "Each Inferencer must be initialized with a model. You can also choose the inference device during initialization.\n",
+        "\n",
+        "#### Model Initialization\n",
+        "\n",
+        "- To infer with MMDetection's pre-trained model, passing its name to the argument `model` can work. The weights will be automatically downloaded and loaded from OpenMMLab's model zoo."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "bbMu3IPtv-cX",
+        "outputId": "2bceb594-06c8-4c18-e8c6-b1816b0acb23"
+      },
+      "outputs": [],
+      "source": [
+        "inferencer = DetInferencer(model='rtmdet_tiny_8xb32-300e_coco')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "AwKtnol3TQlM"
+      },
+      "source": [
+        "There is a very easy to list all model names in MMDetection."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "3kYfK3ssTIQE",
+        "outputId": "88c4fbb9-bb92-42af-baaa-14cee5b5bdc1"
+      },
+      "outputs": [],
+      "source": [
+        "# models is a list of model names, and them will print automatically\n",
+        "models = DetInferencer.list_models('mmdet')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "G-25HR9HTZvr"
+      },
+      "source": [
+        "You can load another weight by passing its path/url to `weights`."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "j4doHX4exvS1",
+        "outputId": "54ac0be2-835f-4390-aa0e-3be5236d8cc9"
+      },
+      "outputs": [],
+      "source": [
+        "!mkdir ./checkpoints\n",
+        "!mim download mmdet --config rtmdet_tiny_8xb32-300e_coco --dest ./checkpoints"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "8LQB4EC-Tako",
+        "outputId": "2cc0960e-d5b5-4c3a-8a0c-cec23989f6a0"
+      },
+      "outputs": [],
+      "source": [
+        "# Setup a checkpoint file to load\n",
+        "checkpoint = './checkpoints/rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth'\n",
+        "\n",
+        "# Initialize the DetInferencer\n",
+        "inferencer = DetInferencer(model='rtmdet_tiny_8xb32-300e_coco', weights=checkpoint)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Atft9tjcwgeD"
+      },
+      "source": [
+        "- To load custom config and weight, you can pass the path to the config file to `model` and the path to the weight to `weights`."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "eukDD4Rzwp9P",
+        "outputId": "0a34392c-0544-4a90-c844-7628d184efc0"
+      },
+      "outputs": [],
+      "source": [
+        "# Choose to use a config\n",
+        "config_path = './configs/rtmdet/rtmdet_tiny_8xb32-300e_coco.py'\n",
+        "\n",
+        "# Setup a checkpoint file to load\n",
+        "checkpoint = './checkpoints/rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth'\n",
+        "\n",
+        "# Initialize the DetInferencer\n",
+        "inferencer = DetInferencer(model=config_path, weights=checkpoint)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "FC1je9iiTuMS"
+      },
+      "source": [
+        "- By default, [MMEngine](https://github.com/open-mmlab/mmengine/) dumps config to the weight. If you have a weight trained on MMEngine, you can also pass the path to the weight file to `weights` without specifying `model`:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Kenyo80RTx63",
+        "outputId": "46fe8219-d1a7-4e45-b5a1-b6d21c30be42"
+      },
+      "outputs": [],
+      "source": [
+        "# It will raise an error if the config file cannot be found in the weight. Currently, within the MMDetection model repository, only the weights of ddq-detr-4scale_r50 can be loaded in this manner.\n",
+        "inferencer = DetInferencer(weights='https://download.openmmlab.com/mmdetection/v3.0/ddq/ddq-detr-4scale_r50_8xb2-12e_coco/ddq-detr-4scale_r50_8xb2-12e_coco_20230809_170711-42528127.pth')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "b-AlYOw4T3AO"
+      },
+      "source": [
+        "- Passing config file to `model` without specifying `weight` will result in a randomly initialized model."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "quFQ8abYT6As"
+      },
+      "source": [
+        "### Device\n",
+        "\n",
+        "Each Inferencer instance is bound to a device.\n",
+        "By default, the best device is automatically decided by [MMEngine](https://github.com/open-mmlab/mmengine/). You can also alter the device by specifying the `device` argument. For example, you can use the following code to create an Inferencer on GPU 0."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Wi6DRpsQPEmV",
+        "outputId": "9eac2017-cce6-491a-ef51-3e7e2560f107"
+      },
+      "outputs": [],
+      "source": [
+        "inferencer = DetInferencer(model='rtmdet_tiny_8xb32-300e_coco', device='cuda:0')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "h3pgIACHUXEv"
+      },
+      "source": [
+        "To create an Inferencer on CPU:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "JsAotaiRUXWH",
+        "outputId": "531b1cb0-e986-4e0a-91c9-6d3ad65544e7"
+      },
+      "outputs": [],
+      "source": [
+        "inferencer = DetInferencer(model='rtmdet_tiny_8xb32-300e_coco', device='cpu')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "0a4Zw5plUisX"
+      },
+      "source": [
+        "### Inference\n",
+        "\n",
+        "Once the Inferencer is initialized, you can directly pass in the raw data to be inferred and get the inference results from return values.\n",
+        "\n",
+        "#### Input\n",
+        "\n",
+        "Input can be either of these types:\n",
+        "\n",
+        "- str: Path/URL to the image."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000,
+          "referenced_widgets": [
+            "2abd7eef6f1f4b9c865a466b3dd5ef24",
+            "8951ec1ee7164f7ca7239a37e80e98ea"
+          ]
+        },
+        "id": "C4McAmYdUnCL",
+        "outputId": "50bea3e2-a912-497e-cee9-26109dccdc12"
+      },
+      "outputs": [],
+      "source": [
+        "inferencer = DetInferencer(model='rtmdet_tiny_8xb32-300e_coco', device='cuda:0')\n",
+        "inferencer('demo/demo.jpg')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "3G_TPKrMUp2T"
+      },
+      "source": [
+        "- array: Image in numpy array. It should be in BGR order."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000,
+          "referenced_widgets": [
+            "59bfd22c751f4ed4baefa466e7653315",
+            "0164804ae2f842fe8d2a4c5414c4a0c2"
+          ]
+        },
+        "id": "-M1qGlfaUpha",
+        "outputId": "5a06cfe8-e056-4d56-c8e9-489e8f6633a0"
+      },
+      "outputs": [],
+      "source": [
+        "import mmcv\n",
+        "array = mmcv.imread('demo/demo.jpg')\n",
+        "inferencer(array)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "I45B_CtzUuh2"
+      },
+      "source": [
+        "- list: A list of basic types above. Each element in the list will be processed separately."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000,
+          "referenced_widgets": [
+            "a64a6eb038c44236b80579b2bfc4b8e3",
+            "eef25a0509854f98883395a2c0fc2134",
+            "f87f0b153b0342ad99dcd320a1302c92",
+            "f6634888109048069b6844e9f9b4ec13"
+          ]
+        },
+        "id": "k1IXIWXHUwKP",
+        "outputId": "0af73b0b-d703-4cbc-91ad-052f0b521d50"
+      },
+      "outputs": [],
+      "source": [
+        "inferencer(['tests/data/color.jpg', 'tests/data/gray.jpg'])\n",
+        "# You can even mix the types\n",
+        "inferencer(['tests/data/color.jpg', array])"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "hUGrTtxrVBAS"
+      },
+      "source": [
+        "- str: Path to the directory. All images in the directory will be processed."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000,
+          "referenced_widgets": [
+            "07ed8efcd87a40059af36f0c43ef5147",
+            "69ce7e58e27f4e1186ab0afcb99d37c3"
+          ]
+        },
+        "id": "JWK10ZD6VDDE",
+        "outputId": "91418597-d9ea-4613-b141-16bc8bcc8caf"
+      },
+      "outputs": [],
+      "source": [
+        "inferencer('tests/data/')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "BQxEVr2pVGen"
+      },
+      "source": [
+        "### Output\n",
+        "\n",
+        "By default, each `Inferencer` returns the prediction results in a dictionary format.\n",
+        "\n",
+        "- `visualization` contains the visualized predictions.\n",
+        "\n",
+        "- `predictions` contains the predictions results in a json-serializable format. But it's an empty list by default unless `return_vis=True`."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 306,
+          "referenced_widgets": [
+            "95674a6baa1842d2981fe60b31ab6cad",
+            "7e62816d1f6c441fb98c1f8e942fff1d"
+          ]
+        },
+        "id": "m6a8T4goU8Sq",
+        "outputId": "6f74098f-a3d3-4897-c58f-68fae88889af"
+      },
+      "outputs": [],
+      "source": [
+        "# Show the structure of result dict\n",
+        "from rich.pretty import pprint\n",
+        "\n",
+        "result = inferencer('demo/demo.jpg')\n",
+        "pprint(result, max_length=4)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "a93hFT0jVkrR"
+      },
+      "source": [
+        "If you wish to get the raw outputs from the model, you can set `return_datasamples` to `True` to get the original `DataSample`, which will be stored in `predictions`."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000,
+          "referenced_widgets": [
+            "060f510b5bda498583d7212060bb528c",
+            "1bb724cb12c240a18f651dd99842e5b0"
+          ]
+        },
+        "id": "U5DFI7QAVbnP",
+        "outputId": "effaf3ec-2476-4b64-dcbd-802a18a26479"
+      },
+      "outputs": [],
+      "source": [
+        "result = inferencer('demo/demo.jpg', return_datasamples=True)\n",
+        "pprint(result, max_length=4)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "JHdcUnGzVsk1"
+      },
+      "source": [
+        "#### Dumping Results\n",
+        "\n",
+        "Apart from obtaining predictions from the return value, you can also export the predictions/visualizations to files by setting `out_dir` and `no_save_pred`/`no_save_vis` arguments."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000,
+          "referenced_widgets": [
+            "38083c2f29604d1d9a7dcf9845dfbf33",
+            "54cdfe55e0f04df9ab844961a089fe2f"
+          ]
+        },
+        "id": "0dr-ixmfVtng",
+        "outputId": "af22d458-9aed-41e2-f675-e017a0cb588b"
+      },
+      "outputs": [],
+      "source": [
+        "inferencer('demo/demo.jpg', out_dir='outputs/', no_save_pred=False)"
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "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.8.13"
+    },
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "0164804ae2f842fe8d2a4c5414c4a0c2": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "0226fedc26044ab2abdccc4fcbe226f8": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "060f510b5bda498583d7212060bb528c": {
+          "model_module": "@jupyter-widgets/output",
+          "model_module_version": "1.0.0",
+          "model_name": "OutputModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/output",
+            "_model_module_version": "1.0.0",
+            "_model_name": "OutputModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/output",
+            "_view_module_version": "1.0.0",
+            "_view_name": "OutputView",
+            "layout": "IPY_MODEL_1bb724cb12c240a18f651dd99842e5b0",
+            "msg_id": "",
+            "outputs": [
+              {
+                "data": {
+                  "text/html": "
    Inference ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━   \n
    \n",
+                  "text/plain": "Inference \u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;58;58;58m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;249;38;114m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;58;58;58m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;249;38;114m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m  \u001b[36m \u001b[0m\n"
+                },
+                "metadata": {},
+                "output_type": "display_data"
+              }
+            ]
+          }
+        },
+        "07ed8efcd87a40059af36f0c43ef5147": {
+          "model_module": "@jupyter-widgets/output",
+          "model_module_version": "1.0.0",
+          "model_name": "OutputModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/output",
+            "_model_module_version": "1.0.0",
+            "_model_name": "OutputModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/output",
+            "_view_module_version": "1.0.0",
+            "_view_name": "OutputView",
+            "layout": "IPY_MODEL_69ce7e58e27f4e1186ab0afcb99d37c3",
+            "msg_id": "",
+            "outputs": [
+              {
+                "data": {
+                  "text/html": "
    Inference ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 13.5 it/s  \n
    \n",
+                  "text/plain": "Inference \u001b[38;2;249;38;114m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;58;58;58m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;249;38;114m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;58;58;58m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m \u001b[35m13.5 it/s\u001b[0m \u001b[36m \u001b[0m\n"
+                },
+                "metadata": {},
+                "output_type": "display_data"
+              }
+            ]
+          }
+        },
+        "1bb724cb12c240a18f651dd99842e5b0": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "2abd7eef6f1f4b9c865a466b3dd5ef24": {
+          "model_module": "@jupyter-widgets/output",
+          "model_module_version": "1.0.0",
+          "model_name": "OutputModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/output",
+            "_model_module_version": "1.0.0",
+            "_model_name": "OutputModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/output",
+            "_view_module_version": "1.0.0",
+            "_view_name": "OutputView",
+            "layout": "IPY_MODEL_8951ec1ee7164f7ca7239a37e80e98ea",
+            "msg_id": "",
+            "outputs": [
+              {
+                "data": {
+                  "text/html": "
    Inference ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━   \n
    \n",
+                  "text/plain": "Inference \u001b[38;2;58;58;58m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;249;38;114m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;58;58;58m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;249;38;114m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m  \u001b[36m \u001b[0m\n"
+                },
+                "metadata": {},
+                "output_type": "display_data"
+              }
+            ]
+          }
+        },
+        "38083c2f29604d1d9a7dcf9845dfbf33": {
+          "model_module": "@jupyter-widgets/output",
+          "model_module_version": "1.0.0",
+          "model_name": "OutputModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/output",
+            "_model_module_version": "1.0.0",
+            "_model_name": "OutputModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/output",
+            "_view_module_version": "1.0.0",
+            "_view_name": "OutputView",
+            "layout": "IPY_MODEL_54cdfe55e0f04df9ab844961a089fe2f",
+            "msg_id": "",
+            "outputs": [
+              {
+                "data": {
+                  "text/html": "
    Inference ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━   \n
    \n",
+                  "text/plain": "Inference \u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;58;58;58m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;249;38;114m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;58;58;58m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;249;38;114m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m  \u001b[36m \u001b[0m\n"
+                },
+                "metadata": {},
+                "output_type": "display_data"
+              }
+            ]
+          }
+        },
+        "54cdfe55e0f04df9ab844961a089fe2f": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "59bfd22c751f4ed4baefa466e7653315": {
+          "model_module": "@jupyter-widgets/output",
+          "model_module_version": "1.0.0",
+          "model_name": "OutputModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/output",
+            "_model_module_version": "1.0.0",
+            "_model_name": "OutputModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/output",
+            "_view_module_version": "1.0.0",
+            "_view_name": "OutputView",
+            "layout": "IPY_MODEL_0164804ae2f842fe8d2a4c5414c4a0c2",
+            "msg_id": "",
+            "outputs": [
+              {
+                "data": {
+                  "text/html": "
    Inference ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━   \n
    \n",
+                  "text/plain": "Inference \u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;58;58;58m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;249;38;114m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;58;58;58m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;249;38;114m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m  \u001b[36m \u001b[0m\n"
+                },
+                "metadata": {},
+                "output_type": "display_data"
+              }
+            ]
+          }
+        },
+        "69ce7e58e27f4e1186ab0afcb99d37c3": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "6fa2cda48fda43f9bf53a0f533392eba": {
+          "model_module": "@jupyter-widgets/output",
+          "model_module_version": "1.0.0",
+          "model_name": "OutputModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/output",
+            "_model_module_version": "1.0.0",
+            "_model_name": "OutputModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/output",
+            "_view_module_version": "1.0.0",
+            "_view_name": "OutputView",
+            "layout": "IPY_MODEL_0226fedc26044ab2abdccc4fcbe226f8",
+            "msg_id": "",
+            "outputs": [
+              {
+                "data": {
+                  "text/html": "
    Inference ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━   \n
    \n",
+                  "text/plain": "Inference \u001b[38;2;249;38;114m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;58;58;58m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;249;38;114m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;58;58;58m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m  \u001b[36m \u001b[0m\n"
+                },
+                "metadata": {},
+                "output_type": "display_data"
+              }
+            ]
+          }
+        },
+        "7e62816d1f6c441fb98c1f8e942fff1d": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "8951ec1ee7164f7ca7239a37e80e98ea": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "95674a6baa1842d2981fe60b31ab6cad": {
+          "model_module": "@jupyter-widgets/output",
+          "model_module_version": "1.0.0",
+          "model_name": "OutputModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/output",
+            "_model_module_version": "1.0.0",
+            "_model_name": "OutputModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/output",
+            "_view_module_version": "1.0.0",
+            "_view_name": "OutputView",
+            "layout": "IPY_MODEL_7e62816d1f6c441fb98c1f8e942fff1d",
+            "msg_id": "",
+            "outputs": [
+              {
+                "data": {
+                  "text/html": "
    Inference ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━   \n
    \n",
+                  "text/plain": "Inference \u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;58;58;58m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;249;38;114m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;58;58;58m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;249;38;114m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m  \u001b[36m \u001b[0m\n"
+                },
+                "metadata": {},
+                "output_type": "display_data"
+              }
+            ]
+          }
+        },
+        "a64a6eb038c44236b80579b2bfc4b8e3": {
+          "model_module": "@jupyter-widgets/output",
+          "model_module_version": "1.0.0",
+          "model_name": "OutputModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/output",
+            "_model_module_version": "1.0.0",
+            "_model_name": "OutputModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/output",
+            "_view_module_version": "1.0.0",
+            "_view_name": "OutputView",
+            "layout": "IPY_MODEL_eef25a0509854f98883395a2c0fc2134",
+            "msg_id": "",
+            "outputs": [
+              {
+                "data": {
+                  "text/html": "
    Inference ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 9.7 it/s  \n
    \n",
+                  "text/plain": "Inference \u001b[38;2;249;38;114m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;58;58;58m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;249;38;114m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;58;58;58m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m \u001b[35m9.7 it/s\u001b[0m \u001b[36m \u001b[0m\n"
+                },
+                "metadata": {},
+                "output_type": "display_data"
+              }
+            ]
+          }
+        },
+        "eef25a0509854f98883395a2c0fc2134": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "f6634888109048069b6844e9f9b4ec13": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "f87f0b153b0342ad99dcd320a1302c92": {
+          "model_module": "@jupyter-widgets/output",
+          "model_module_version": "1.0.0",
+          "model_name": "OutputModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/output",
+            "_model_module_version": "1.0.0",
+            "_model_name": "OutputModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/output",
+            "_view_module_version": "1.0.0",
+            "_view_name": "OutputView",
+            "layout": "IPY_MODEL_f6634888109048069b6844e9f9b4ec13",
+            "msg_id": "",
+            "outputs": [
+              {
+                "data": {
+                  "text/html": "
    Inference ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 9.0 it/s  \n
    \n",
+                  "text/plain": "Inference \u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;249;38;114m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;58;58;58m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;249;38;114m━\u001b[0m\u001b[38;2;244;38;112m━\u001b[0m\u001b[38;2;230;39;108m━\u001b[0m\u001b[38;2;209;42;102m━\u001b[0m\u001b[38;2;183;44;94m━\u001b[0m\u001b[38;2;153;48;86m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;58;58;58m━\u001b[0m\u001b[38;2;62;57;59m━\u001b[0m\u001b[38;2;76;56;63m━\u001b[0m\u001b[38;2;97;53;69m━\u001b[0m\u001b[38;2;123;51;77m━\u001b[0m \u001b[35m9.0 it/s\u001b[0m \u001b[36m \u001b[0m\n"
+                },
+                "metadata": {},
+                "output_type": "display_data"
+              }
+            ]
+          }
+        }
+      }
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
diff --git a/mmdetection/demo/large_image.jpg b/mmdetection/demo/large_image.jpg
new file mode 100644
index 00000000..1abbc5d9
Binary files /dev/null and b/mmdetection/demo/large_image.jpg differ
diff --git a/mmdetection/demo/large_image_demo.py b/mmdetection/demo/large_image_demo.py
new file mode 100644
index 00000000..f3d8d22f
--- /dev/null
+++ b/mmdetection/demo/large_image_demo.py
@@ -0,0 +1,282 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+"""Perform MMDET inference on large images (as satellite imagery) as:
+
+```shell
+wget -P checkpoint https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r101_fpn_2x_coco/faster_rcnn_r101_fpn_2x_coco_bbox_mAP-0.398_20200504_210455-1d2dac9c.pth # noqa: E501, E261.
+
+python demo/large_image_demo.py \
+    demo/large_image.jpg \
+    configs/faster_rcnn/faster-rcnn_r101_fpn_2x_coco.py \
+    checkpoint/faster_rcnn_r101_fpn_2x_coco_bbox_mAP-0.398_20200504_210455-1d2dac9c.pth
+```
+"""
+
+import os
+import random
+from argparse import ArgumentParser
+from pathlib import Path
+
+import mmcv
+import numpy as np
+from mmengine.config import Config, ConfigDict
+from mmengine.logging import print_log
+from mmengine.utils import ProgressBar
+
+from mmdet.apis import inference_detector, init_detector
+
+try:
+    from sahi.slicing import slice_image
+except ImportError:
+    raise ImportError('Please run "pip install -U sahi" '
+                      'to install sahi first for large image inference.')
+
+from mmdet.registry import VISUALIZERS
+from mmdet.utils.large_image import merge_results_by_nms, shift_predictions
+from mmdet.utils.misc import get_file_list
+
+
+def parse_args():
+    parser = ArgumentParser(
+        description='Perform MMDET inference on large images.')
+    parser.add_argument(
+        'img', help='Image path, include image file, dir and URL.')
+    parser.add_argument('config', help='Config file')
+    parser.add_argument('checkpoint', help='Checkpoint file')
+    parser.add_argument(
+        '--out-dir', default='./output', help='Path to output file')
+    parser.add_argument(
+        '--device', default='cuda:0', help='Device used for inference')
+    parser.add_argument(
+        '--show', action='store_true', help='Show the detection results')
+    parser.add_argument(
+        '--tta',
+        action='store_true',
+        help='Whether to use test time augmentation')
+    parser.add_argument(
+        '--score-thr', type=float, default=0.3, help='Bbox score threshold')
+    parser.add_argument(
+        '--patch-size', type=int, default=640, help='The size of patches')
+    parser.add_argument(
+        '--patch-overlap-ratio',
+        type=float,
+        default=0.25,
+        help='Ratio of overlap between two patches')
+    parser.add_argument(
+        '--merge-iou-thr',
+        type=float,
+        default=0.25,
+        help='IoU threshould for merging results')
+    parser.add_argument(
+        '--merge-nms-type',
+        type=str,
+        default='nms',
+        help='NMS type for merging results')
+    parser.add_argument(
+        '--batch-size',
+        type=int,
+        default=1,
+        help='Batch size, must greater than or equal to 1')
+    parser.add_argument(
+        '--debug',
+        action='store_true',
+        help='Export debug results before merging')
+    parser.add_argument(
+        '--save-patch',
+        action='store_true',
+        help='Save the results of each patch. '
+        'The `--debug` must be enabled.')
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+
+    config = args.config
+
+    if isinstance(config, (str, Path)):
+        config = Config.fromfile(config)
+    elif not isinstance(config, Config):
+        raise TypeError('config must be a filename or Config object, '
+                        f'but got {type(config)}')
+    if 'init_cfg' in config.model.backbone:
+        config.model.backbone.init_cfg = None
+
+    if args.tta:
+        assert 'tta_model' in config, 'Cannot find ``tta_model`` in config.' \
+                                      " Can't use tta !"
+        assert 'tta_pipeline' in config, 'Cannot find ``tta_pipeline`` ' \
+                                         "in config. Can't use tta !"
+        config.model = ConfigDict(**config.tta_model, module=config.model)
+        test_data_cfg = config.test_dataloader.dataset
+        while 'dataset' in test_data_cfg:
+            test_data_cfg = test_data_cfg['dataset']
+
+        test_data_cfg.pipeline = config.tta_pipeline
+
+    # TODO: TTA mode will error if cfg_options is not set.
+    #  This is an mmdet issue and needs to be fixed later.
+    # build the model from a config file and a checkpoint file
+    model = init_detector(
+        config, args.checkpoint, device=args.device, cfg_options={})
+
+    if not os.path.exists(args.out_dir) and not args.show:
+        os.mkdir(args.out_dir)
+
+    # init visualizer
+    visualizer = VISUALIZERS.build(model.cfg.visualizer)
+    visualizer.dataset_meta = model.dataset_meta
+
+    # get file list
+    files, source_type = get_file_list(args.img)
+
+    # start detector inference
+    print(f'Performing inference on {len(files)} images.... '
+          'This may take a while.')
+    progress_bar = ProgressBar(len(files))
+    for file in files:
+        # read image
+        img = mmcv.imread(file)
+
+        # arrange slices
+        height, width = img.shape[:2]
+        sliced_image_object = slice_image(
+            img,
+            slice_height=args.patch_size,
+            slice_width=args.patch_size,
+            auto_slice_resolution=False,
+            overlap_height_ratio=args.patch_overlap_ratio,
+            overlap_width_ratio=args.patch_overlap_ratio,
+        )
+        # perform sliced inference
+        slice_results = []
+        start = 0
+        while True:
+            # prepare batch slices
+            end = min(start + args.batch_size, len(sliced_image_object))
+            images = []
+            for sliced_image in sliced_image_object.images[start:end]:
+                images.append(sliced_image)
+
+            # forward the model
+            slice_results.extend(inference_detector(model, images))
+
+            if end >= len(sliced_image_object):
+                break
+            start += args.batch_size
+
+        if source_type['is_dir']:
+            filename = os.path.relpath(file, args.img).replace('/', '_')
+        else:
+            filename = os.path.basename(file)
+
+        img = mmcv.imconvert(img, 'bgr', 'rgb')
+        out_file = None if args.show else os.path.join(args.out_dir, filename)
+
+        # export debug images
+        if args.debug:
+            # export sliced image results
+            name, suffix = os.path.splitext(filename)
+
+            shifted_instances = shift_predictions(
+                slice_results,
+                sliced_image_object.starting_pixels,
+                src_image_shape=(height, width))
+            merged_result = slice_results[0].clone()
+            merged_result.pred_instances = shifted_instances
+
+            debug_file_name = name + '_debug' + suffix
+            debug_out_file = None if args.show else os.path.join(
+                args.out_dir, debug_file_name)
+            visualizer.set_image(img.copy())
+
+            debug_grids = []
+            for starting_point in sliced_image_object.starting_pixels:
+                start_point_x = starting_point[0]
+                start_point_y = starting_point[1]
+                end_point_x = start_point_x + args.patch_size
+                end_point_y = start_point_y + args.patch_size
+                debug_grids.append(
+                    [start_point_x, start_point_y, end_point_x, end_point_y])
+            debug_grids = np.array(debug_grids)
+            debug_grids[:, 0::2] = np.clip(debug_grids[:, 0::2], 1,
+                                           img.shape[1] - 1)
+            debug_grids[:, 1::2] = np.clip(debug_grids[:, 1::2], 1,
+                                           img.shape[0] - 1)
+
+            palette = np.random.randint(0, 256, size=(len(debug_grids), 3))
+            palette = [tuple(c) for c in palette]
+            line_styles = random.choices(['-', '-.', ':'], k=len(debug_grids))
+            visualizer.draw_bboxes(
+                debug_grids,
+                edge_colors=palette,
+                alpha=1,
+                line_styles=line_styles)
+            visualizer.draw_bboxes(
+                debug_grids, face_colors=palette, alpha=0.15)
+
+            visualizer.draw_texts(
+                list(range(len(debug_grids))),
+                debug_grids[:, :2] + 5,
+                colors='w')
+
+            visualizer.add_datasample(
+                debug_file_name,
+                visualizer.get_image(),
+                data_sample=merged_result,
+                draw_gt=False,
+                show=args.show,
+                wait_time=0,
+                out_file=debug_out_file,
+                pred_score_thr=args.score_thr,
+            )
+
+            if args.save_patch:
+                debug_patch_out_dir = os.path.join(args.out_dir,
+                                                   f'{name}_patch')
+                for i, slice_result in enumerate(slice_results):
+                    patch_out_file = os.path.join(
+                        debug_patch_out_dir,
+                        f'{filename}_slice_{i}_result.jpg')
+                    image = mmcv.imconvert(sliced_image_object.images[i],
+                                           'bgr', 'rgb')
+
+                    visualizer.add_datasample(
+                        'patch_result',
+                        image,
+                        data_sample=slice_result,
+                        draw_gt=False,
+                        show=False,
+                        wait_time=0,
+                        out_file=patch_out_file,
+                        pred_score_thr=args.score_thr,
+                    )
+
+        image_result = merge_results_by_nms(
+            slice_results,
+            sliced_image_object.starting_pixels,
+            src_image_shape=(height, width),
+            nms_cfg={
+                'type': args.merge_nms_type,
+                'iou_threshold': args.merge_iou_thr
+            })
+
+        visualizer.add_datasample(
+            filename,
+            img,
+            data_sample=image_result,
+            draw_gt=False,
+            show=args.show,
+            wait_time=0,
+            out_file=out_file,
+            pred_score_thr=args.score_thr,
+        )
+        progress_bar.update()
+
+    if not args.show or (args.debug and args.save_patch):
+        print_log(
+            f'\nResults have been saved at {os.path.abspath(args.out_dir)}')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmdetection/demo/mot_demo.py b/mmdetection/demo/mot_demo.py
new file mode 100644
index 00000000..4595cdc5
--- /dev/null
+++ b/mmdetection/demo/mot_demo.py
@@ -0,0 +1,130 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os
+import os.path as osp
+import tempfile
+from argparse import ArgumentParser
+
+import mmcv
+import mmengine
+from mmengine.registry import init_default_scope
+
+from mmdet.apis import inference_mot, init_track_model
+from mmdet.registry import VISUALIZERS
+
+IMG_EXTENSIONS = ('.jpg', '.jpeg', '.png')
+
+
+def parse_args():
+    parser = ArgumentParser()
+    parser.add_argument(
+        'inputs', type=str, help='Input image file or folder path.')
+    parser.add_argument('config', help='config file')
+    parser.add_argument('--checkpoint', help='checkpoint file')
+    parser.add_argument('--detector', help='det checkpoint file')
+    parser.add_argument('--reid', help='reid checkpoint file')
+    parser.add_argument(
+        '--device', default='cuda:0', help='device used for inference')
+    parser.add_argument(
+        '--score-thr',
+        type=float,
+        default=0.0,
+        help='The threshold of score to filter bboxes.')
+    parser.add_argument(
+        '--out', help='output video file (mp4 format) or folder')
+    parser.add_argument(
+        '--show',
+        action='store_true',
+        help='whether show the results on the fly')
+    parser.add_argument('--fps', help='FPS of the output video')
+    args = parser.parse_args()
+    return args
+
+
+def main(args):
+    assert args.out or args.show
+    # load images
+    if osp.isdir(args.inputs):
+        imgs = sorted(
+            filter(lambda x: x.endswith(IMG_EXTENSIONS),
+                   os.listdir(args.inputs)),
+            key=lambda x: int(x.split('.')[0]))
+        in_video = False
+    else:
+        imgs = mmcv.VideoReader(args.inputs)
+        in_video = True
+
+    # define output
+    out_video = False
+    if args.out is not None:
+        if args.out.endswith('.mp4'):
+            out_video = True
+            out_dir = tempfile.TemporaryDirectory()
+            out_path = out_dir.name
+            _out = args.out.rsplit(os.sep, 1)
+            if len(_out) > 1:
+                os.makedirs(_out[0], exist_ok=True)
+        else:
+            out_path = args.out
+            os.makedirs(out_path, exist_ok=True)
+
+    fps = args.fps
+    if args.show or out_video:
+        if fps is None and in_video:
+            fps = imgs.fps
+        if not fps:
+            raise ValueError('Please set the FPS for the output video.')
+        fps = int(fps)
+
+    init_default_scope('mmdet')
+
+    # build the model from a config file and a checkpoint file
+    model = init_track_model(
+        args.config,
+        args.checkpoint,
+        args.detector,
+        args.reid,
+        device=args.device)
+
+    # build the visualizer
+    visualizer = VISUALIZERS.build(model.cfg.visualizer)
+    visualizer.dataset_meta = model.dataset_meta
+
+    prog_bar = mmengine.ProgressBar(len(imgs))
+    # test and show/save the images
+    for i, img in enumerate(imgs):
+        if isinstance(img, str):
+            img_path = osp.join(args.inputs, img)
+            img = mmcv.imread(img_path)
+        # result [TrackDataSample]
+        result = inference_mot(model, img, frame_id=i, video_len=len(imgs))
+        if args.out is not None:
+            if in_video or out_video:
+                out_file = osp.join(out_path, f'{i:06d}.jpg')
+            else:
+                out_file = osp.join(out_path, img.rsplit(os.sep, 1)[-1])
+        else:
+            out_file = None
+
+        # show the results
+        visualizer.add_datasample(
+            'mot',
+            img[..., ::-1],
+            data_sample=result[0],
+            show=args.show,
+            draw_gt=False,
+            out_file=out_file,
+            wait_time=float(1 / int(fps)) if fps else 0,
+            pred_score_thr=args.score_thr,
+            step=i)
+
+        prog_bar.update()
+
+    if args.out and out_video:
+        print(f'making the output video at {args.out} with a FPS of {fps}')
+        mmcv.frames2video(out_path, args.out, fps=fps, fourcc='mp4v')
+        out_dir.cleanup()
+
+
+if __name__ == '__main__':
+    args = parse_args()
+    main(args)
diff --git a/mmdetection/demo/video_demo.py b/mmdetection/demo/video_demo.py
new file mode 100644
index 00000000..f72d6176
--- /dev/null
+++ b/mmdetection/demo/video_demo.py
@@ -0,0 +1,84 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+
+import cv2
+import mmcv
+from mmcv.transforms import Compose
+from mmengine.utils import track_iter_progress
+
+from mmdet.apis import inference_detector, init_detector
+from mmdet.registry import VISUALIZERS
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='MMDetection video demo')
+    parser.add_argument('video', help='Video file')
+    parser.add_argument('config', help='Config file')
+    parser.add_argument('checkpoint', help='Checkpoint file')
+    parser.add_argument(
+        '--device', default='cuda:0', help='Device used for inference')
+    parser.add_argument(
+        '--score-thr', type=float, default=0.3, help='Bbox score threshold')
+    parser.add_argument('--out', type=str, help='Output video file')
+    parser.add_argument('--show', action='store_true', help='Show video')
+    parser.add_argument(
+        '--wait-time',
+        type=float,
+        default=1,
+        help='The interval of show (s), 0 is block')
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    assert args.out or args.show, \
+        ('Please specify at least one operation (save/show the '
+         'video) with the argument "--out" or "--show"')
+
+    # build the model from a config file and a checkpoint file
+    model = init_detector(args.config, args.checkpoint, device=args.device)
+
+    # build test pipeline
+    model.cfg.test_dataloader.dataset.pipeline[
+        0].type = 'mmdet.LoadImageFromNDArray'
+    test_pipeline = Compose(model.cfg.test_dataloader.dataset.pipeline)
+
+    # init visualizer
+    visualizer = VISUALIZERS.build(model.cfg.visualizer)
+    # the dataset_meta is loaded from the checkpoint and
+    # then pass to the model in init_detector
+    visualizer.dataset_meta = model.dataset_meta
+
+    video_reader = mmcv.VideoReader(args.video)
+    video_writer = None
+    if args.out:
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        video_writer = cv2.VideoWriter(
+            args.out, fourcc, video_reader.fps,
+            (video_reader.width, video_reader.height))
+
+    for frame in track_iter_progress((video_reader, len(video_reader))):
+        result = inference_detector(model, frame, test_pipeline=test_pipeline)
+        visualizer.add_datasample(
+            name='video',
+            image=frame,
+            data_sample=result,
+            draw_gt=False,
+            show=False,
+            pred_score_thr=args.score_thr)
+        frame = visualizer.get_image()
+
+        if args.show:
+            cv2.namedWindow('video', 0)
+            mmcv.imshow(frame, 'video', args.wait_time)
+        if args.out:
+            video_writer.write(frame)
+
+    if video_writer:
+        video_writer.release()
+    cv2.destroyAllWindows()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmdetection/demo/video_gpuaccel_demo.py b/mmdetection/demo/video_gpuaccel_demo.py
new file mode 100644
index 00000000..3b091647
--- /dev/null
+++ b/mmdetection/demo/video_gpuaccel_demo.py
@@ -0,0 +1,144 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+from typing import Tuple
+
+import cv2
+import mmcv
+import numpy as np
+import torch
+import torch.nn as nn
+from mmcv.transforms import Compose
+from mmengine.utils import track_iter_progress
+
+from mmdet.apis import init_detector
+from mmdet.registry import VISUALIZERS
+from mmdet.structures import DetDataSample
+
+try:
+    import ffmpegcv
+except ImportError:
+    raise ImportError(
+        'Please install ffmpegcv with:\n\n    pip install ffmpegcv')
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='MMDetection video demo with GPU acceleration')
+    parser.add_argument('video', help='Video file')
+    parser.add_argument('config', help='Config file')
+    parser.add_argument('checkpoint', help='Checkpoint file')
+    parser.add_argument(
+        '--device', default='cuda:0', help='Device used for inference')
+    parser.add_argument(
+        '--score-thr', type=float, default=0.3, help='Bbox score threshold')
+    parser.add_argument('--out', type=str, help='Output video file')
+    parser.add_argument('--show', action='store_true', help='Show video')
+    parser.add_argument(
+        '--nvdecode', action='store_true', help='Use NVIDIA decoder')
+    parser.add_argument(
+        '--wait-time',
+        type=float,
+        default=1,
+        help='The interval of show (s), 0 is block')
+    args = parser.parse_args()
+    return args
+
+
+def prefetch_batch_input_shape(model: nn.Module, ori_wh: Tuple[int,
+                                                               int]) -> dict:
+    cfg = model.cfg
+    w, h = ori_wh
+    cfg.test_dataloader.dataset.pipeline[0].type = 'LoadImageFromNDArray'
+    test_pipeline = Compose(cfg.test_dataloader.dataset.pipeline)
+    data = {'img': np.zeros((h, w, 3), dtype=np.uint8), 'img_id': 0}
+    data = test_pipeline(data)
+    data['inputs'] = [data['inputs']]
+    data['data_samples'] = [data['data_samples']]
+    data_sample = model.data_preprocessor(data, False)['data_samples']
+    batch_input_shape = data_sample[0].batch_input_shape
+    return batch_input_shape
+
+
+def pack_data(frame_resize: np.ndarray, batch_input_shape: Tuple[int, int],
+              ori_shape: Tuple[int, int]) -> dict:
+    assert frame_resize.shape[:2] == batch_input_shape
+    data_sample = DetDataSample()
+    data_sample.set_metainfo({
+        'img_shape':
+        batch_input_shape,
+        'ori_shape':
+        ori_shape,
+        'scale_factor': (batch_input_shape[0] / ori_shape[0],
+                         batch_input_shape[1] / ori_shape[1])
+    })
+    frame_resize = torch.from_numpy(frame_resize).permute((2, 0, 1)).cuda()
+    data = {'inputs': [frame_resize], 'data_samples': [data_sample]}
+    return data
+
+
+def main():
+    args = parse_args()
+    assert args.out or args.show, \
+        ('Please specify at least one operation (save/show the '
+         'video) with the argument "--out" or "--show"')
+
+    model = init_detector(args.config, args.checkpoint, device=args.device)
+
+    # init visualizer
+    visualizer = VISUALIZERS.build(model.cfg.visualizer)
+    # the dataset_meta is loaded from the checkpoint and
+    # then pass to the model in init_detector
+    visualizer.dataset_meta = model.dataset_meta
+
+    if args.nvdecode:
+        VideoCapture = ffmpegcv.VideoCaptureNV
+    else:
+        VideoCapture = ffmpegcv.VideoCapture
+    video_origin = VideoCapture(args.video)
+
+    batch_input_shape = prefetch_batch_input_shape(
+        model, (video_origin.width, video_origin.height))
+    ori_shape = (video_origin.height, video_origin.width)
+    resize_wh = batch_input_shape[::-1]
+    video_resize = VideoCapture(
+        args.video,
+        resize=resize_wh,
+        resize_keepratio=True,
+        resize_keepratioalign='topleft')
+
+    video_writer = None
+    if args.out:
+        video_writer = ffmpegcv.VideoWriter(args.out, fps=video_origin.fps)
+
+    with torch.no_grad():
+        for i, (frame_resize, frame_origin) in enumerate(
+                zip(track_iter_progress(video_resize), video_origin)):
+            data = pack_data(frame_resize, batch_input_shape, ori_shape)
+            result = model.test_step(data)[0]
+
+            visualizer.add_datasample(
+                name='video',
+                image=frame_origin,
+                data_sample=result,
+                draw_gt=False,
+                show=False,
+                pred_score_thr=args.score_thr)
+
+            frame_mask = visualizer.get_image()
+
+            if args.show:
+                cv2.namedWindow('video', 0)
+                mmcv.imshow(frame_mask, 'video', args.wait_time)
+            if args.out:
+                video_writer.write(frame_mask)
+
+    if video_writer:
+        video_writer.release()
+    video_origin.release()
+    video_resize.release()
+
+    cv2.destroyAllWindows()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmdetection/demo/webcam_demo.py b/mmdetection/demo/webcam_demo.py
new file mode 100644
index 00000000..d0900303
--- /dev/null
+++ b/mmdetection/demo/webcam_demo.py
@@ -0,0 +1,65 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+
+import cv2
+import mmcv
+import torch
+
+from mmdet.apis import inference_detector, init_detector
+from mmdet.registry import VISUALIZERS
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='MMDetection webcam demo')
+    parser.add_argument('config', help='test config file path')
+    parser.add_argument('checkpoint', help='checkpoint file')
+    parser.add_argument(
+        '--device', type=str, default='cuda:0', help='CPU/CUDA device option')
+    parser.add_argument(
+        '--camera-id', type=int, default=0, help='camera device id')
+    parser.add_argument(
+        '--score-thr', type=float, default=0.5, help='bbox score threshold')
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+
+    # build the model from a config file and a checkpoint file
+    device = torch.device(args.device)
+    model = init_detector(args.config, args.checkpoint, device=device)
+
+    # init visualizer
+    visualizer = VISUALIZERS.build(model.cfg.visualizer)
+    # the dataset_meta is loaded from the checkpoint and
+    # then pass to the model in init_detector
+    visualizer.dataset_meta = model.dataset_meta
+
+    camera = cv2.VideoCapture(args.camera_id)
+
+    print('Press "Esc", "q" or "Q" to exit.')
+    while True:
+        ret_val, img = camera.read()
+        result = inference_detector(model, img)
+
+        img = mmcv.imconvert(img, 'bgr', 'rgb')
+        visualizer.add_datasample(
+            name='result',
+            image=img,
+            data_sample=result,
+            draw_gt=False,
+            pred_score_thr=args.score_thr,
+            show=False)
+
+        img = visualizer.get_image()
+        img = mmcv.imconvert(img, 'bgr', 'rgb')
+        cv2.imshow('result', img)
+
+        ch = cv2.waitKey(1)
+        if ch == 27 or ch == ord('q') or ch == ord('Q'):
+            break
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmdetection/docker/Dockerfile b/mmdetection/docker/Dockerfile
new file mode 100644
index 00000000..2737ec0e
--- /dev/null
+++ b/mmdetection/docker/Dockerfile
@@ -0,0 +1,40 @@
+ARG PYTORCH="1.9.0"
+ARG CUDA="11.1"
+ARG CUDNN="8"
+
+FROM pytorch/pytorch:${PYTORCH}-cuda${CUDA}-cudnn${CUDNN}-devel
+
+ENV TORCH_CUDA_ARCH_LIST="6.0 6.1 7.0 7.5 8.0 8.6+PTX" \
+    TORCH_NVCC_FLAGS="-Xfatbin -compress-all" \
+    CMAKE_PREFIX_PATH="$(dirname $(which conda))/../" \
+    FORCE_CUDA="1"
+
+# Avoid Public GPG key error
+# https://github.com/NVIDIA/nvidia-docker/issues/1631
+RUN rm /etc/apt/sources.list.d/cuda.list \
+    && rm /etc/apt/sources.list.d/nvidia-ml.list \
+    && apt-key del 7fa2af80 \
+    && apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/3bf863cc.pub \
+    && apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64/7fa2af80.pub
+
+# (Optional, use Mirror to speed up downloads)
+# RUN sed -i 's/http:\/\/archive.ubuntu.com\/ubuntu\//http:\/\/mirrors.aliyun.com\/ubuntu\//g' /etc/apt/sources.list && \
+#    pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
+
+# Install the required packages
+RUN apt-get update \
+    && apt-get install -y ffmpeg libsm6 libxext6 git ninja-build libglib2.0-0 libsm6 libxrender-dev libxext6 \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install MMEngine and MMCV
+RUN pip install openmim && \
+    mim install "mmengine>=0.7.1" "mmcv>=2.0.0rc4"
+
+# Install MMDetection
+RUN conda clean --all \
+    && git clone https://github.com/open-mmlab/mmdetection.git /mmdetection \
+    && cd /mmdetection \
+    && pip install --no-cache-dir -e .
+
+WORKDIR /mmdetection
diff --git a/mmdetection/docker/serve/Dockerfile b/mmdetection/docker/serve/Dockerfile
new file mode 100644
index 00000000..aa307cf6
--- /dev/null
+++ b/mmdetection/docker/serve/Dockerfile
@@ -0,0 +1,62 @@
+ARG PYTORCH="1.9.0"
+ARG CUDA="11.1"
+ARG CUDNN="8"
+FROM pytorch/pytorch:${PYTORCH}-cuda${CUDA}-cudnn${CUDNN}-devel
+
+ARG MMCV="2.0.0rc4"
+ARG MMDET="3.3.0"
+
+ENV PYTHONUNBUFFERED TRUE
+
+# Avoid Public GPG key error
+# https://github.com/NVIDIA/nvidia-docker/issues/1631
+RUN rm /etc/apt/sources.list.d/cuda.list \
+    && rm /etc/apt/sources.list.d/nvidia-ml.list \
+    && apt-key del 7fa2af80 \
+    && apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/3bf863cc.pub \
+    && apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64/7fa2af80.pub
+
+# (Optional, use Mirror to speed up downloads)
+# RUN sed -i 's/http:\/\/archive.ubuntu.com\/ubuntu\//http:\/\/mirrors.aliyun.com\/ubuntu\//g' /etc/apt/sources.list
+
+# Install the required packages
+RUN apt-get update && \
+    DEBIAN_FRONTEND=noninteractive apt-get install --no-install-recommends -y \
+    ca-certificates \
+    g++ \
+    openjdk-11-jre-headless \
+    # MMDet Requirements
+    ffmpeg libsm6 libxext6 git ninja-build libglib2.0-0 libsm6 libxrender-dev libxext6 \
+    && rm -rf /var/lib/apt/lists/*
+
+ENV PATH="/opt/conda/bin:$PATH" \
+    FORCE_CUDA="1"
+
+# TORCHSEVER
+RUN pip install torchserve torch-model-archiver
+
+# MMLAB
+ARG PYTORCH
+ARG CUDA
+RUN pip install mmengine
+RUN ["/bin/bash", "-c", "pip install mmcv==${MMCV} -f https://download.openmmlab.com/mmcv/dist/cu${CUDA//./}/torch${PYTORCH}/index.html"]
+RUN pip install mmdet==${MMDET}
+
+RUN useradd -m model-server \
+    && mkdir -p /home/model-server/tmp
+
+COPY entrypoint.sh /usr/local/bin/entrypoint.sh
+
+RUN chmod +x /usr/local/bin/entrypoint.sh \
+    && chown -R model-server /home/model-server
+
+COPY config.properties /home/model-server/config.properties
+RUN mkdir /home/model-server/model-store && chown -R model-server /home/model-server/model-store
+
+EXPOSE 8080 8081 8082
+
+USER model-server
+WORKDIR /home/model-server
+ENV TEMP=/home/model-server/tmp
+ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]
+CMD ["serve"]
diff --git a/mmdetection/docker/serve/config.properties b/mmdetection/docker/serve/config.properties
new file mode 100644
index 00000000..efb9c47e
--- /dev/null
+++ b/mmdetection/docker/serve/config.properties
@@ -0,0 +1,5 @@
+inference_address=http://0.0.0.0:8080
+management_address=http://0.0.0.0:8081
+metrics_address=http://0.0.0.0:8082
+model_store=/home/model-server/model-store
+load_models=all
diff --git a/mmdetection/docker/serve/entrypoint.sh b/mmdetection/docker/serve/entrypoint.sh
new file mode 100644
index 00000000..41ba00b0
--- /dev/null
+++ b/mmdetection/docker/serve/entrypoint.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+set -e
+
+if [[ "$1" = "serve" ]]; then
+    shift 1
+    torchserve --start --ts-config /home/model-server/config.properties
+else
+    eval "$@"
+fi
+
+# prevent docker exit
+tail -f /dev/null
diff --git a/mmdetection/docker/serve_cn/Dockerfile b/mmdetection/docker/serve_cn/Dockerfile
new file mode 100644
index 00000000..894e15dd
--- /dev/null
+++ b/mmdetection/docker/serve_cn/Dockerfile
@@ -0,0 +1,65 @@
+ARG PYTORCH="1.9.0"
+ARG CUDA="11.1"
+ARG CUDNN="8"
+FROM pytorch/pytorch:${PYTORCH}-cuda${CUDA}-cudnn${CUDNN}-devel
+
+ARG MMCV="2.0.0rc4"
+ARG MMDET="3.3.0"
+
+ENV PYTHONUNBUFFERED TRUE
+
+# Avoid Public GPG key error
+# - https://github.com/NVIDIA/nvidia-docker/issues/1631
+RUN rm /etc/apt/sources.list.d/cuda.list \
+  && rm /etc/apt/sources.list.d/nvidia-ml.list \
+  && apt-get update \
+  && apt-get install -y wget \
+  && rm -rf /var/lib/apt/lists/* \
+  && apt-key del 7fa2af80 \
+  && apt-get update && apt-get install -y --no-install-recommends wget \
+  && wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/cuda-keyring_1.0-1_all.deb \
+  && dpkg -i cuda-keyring_1.0-1_all.deb
+# (Optional, use Mirror to speed up downloads)
+# RUN sed -i 's/http:\/\/archive.ubuntu.com\/ubuntu\//http:\/\/mirrors.aliyun.com\/ubuntu\//g' /etc/apt/sources.list
+
+# Install the required packages
+RUN apt-get update && \
+    DEBIAN_FRONTEND=noninteractive apt-get install --no-install-recommends -y \
+    ca-certificates \
+    g++ \
+    openjdk-11-jre-headless \
+    # MMDet Requirements
+    ffmpeg libsm6 libxext6 git ninja-build libglib2.0-0 libsm6 libxrender-dev libxext6 \
+    && rm -rf /var/lib/apt/lists/*
+
+ENV PATH="/opt/conda/bin:$PATH" \
+    FORCE_CUDA="1"
+
+# TORCHSEVER
+RUN pip install torchserve torch-model-archiver nvgpu -i https://pypi.mirrors.ustc.edu.cn/simple/
+
+# MMLAB
+ARG PYTORCH
+ARG CUDA
+RUN pip install mmengine -i https://pypi.mirrors.ustc.edu.cn/simple/
+RUN ["/bin/bash", "-c", "pip install mmcv==${MMCV} -f https://download.openmmlab.com/mmcv/dist/cu${CUDA//./}/torch${PYTORCH}/index.html"]
+RUN pip install mmdet==${MMDET} -i https://pypi.mirrors.ustc.edu.cn/simple/
+
+RUN useradd -m model-server \
+    && mkdir -p /home/model-server/tmp
+
+COPY entrypoint.sh /usr/local/bin/entrypoint.sh
+
+RUN chmod +x /usr/local/bin/entrypoint.sh \
+    && chown -R model-server /home/model-server
+
+COPY config.properties /home/model-server/config.properties
+RUN mkdir /home/model-server/model-store && chown -R model-server /home/model-server/model-store
+
+EXPOSE 8080 8081 8082
+
+USER model-server
+WORKDIR /home/model-server
+ENV TEMP=/home/model-server/tmp
+ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]
+CMD ["serve"]
diff --git a/mmdetection/docs/en/Makefile b/mmdetection/docs/en/Makefile
new file mode 100644
index 00000000..d4bb2cbb
--- /dev/null
+++ b/mmdetection/docs/en/Makefile
@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = .
+BUILDDIR      = _build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
diff --git a/mmdetection/docs/en/_static/css/readthedocs.css b/mmdetection/docs/en/_static/css/readthedocs.css
new file mode 100644
index 00000000..57ed0ad0
--- /dev/null
+++ b/mmdetection/docs/en/_static/css/readthedocs.css
@@ -0,0 +1,6 @@
+.header-logo {
+    background-image: url("../image/mmdet-logo.png");
+    background-size: 156px 40px;
+    height: 40px;
+    width: 156px;
+}
diff --git a/mmdetection/docs/en/_static/image/mmdet-logo.png b/mmdetection/docs/en/_static/image/mmdet-logo.png
new file mode 100644
index 00000000..58e2b5e6
Binary files /dev/null and b/mmdetection/docs/en/_static/image/mmdet-logo.png differ
diff --git a/mmdetection/docs/en/advanced_guides/conventions.md b/mmdetection/docs/en/advanced_guides/conventions.md
new file mode 100644
index 00000000..da159ac6
--- /dev/null
+++ b/mmdetection/docs/en/advanced_guides/conventions.md
@@ -0,0 +1,111 @@
+# Conventions
+
+Please check the following conventions if you would like to modify MMDetection as your own project.
+
+## About the order of image shape
+
+In OpenMMLab 2.0, to be consistent with the input argument of OpenCV, the argument about image shape in the data transformation pipeline is always in the `(width, height)` order. On the contrary, for computation convenience, the order of the field going through the data pipeline and the model is `(height, width)`. Specifically, in the results processed by each data transform pipeline, the fields and their value meaning is as below:
+
+- img_shape: (height, width)
+- ori_shape: (height, width)
+- pad_shape: (height, width)
+- batch_input_shape: (height, width)
+
+As an example, the initialization arguments of `Mosaic` are as below:
+
+```python
+@TRANSFORMS.register_module()
+class Mosaic(BaseTransform):
+    def __init__(self,
+                img_scale: Tuple[int, int] = (640, 640),
+                center_ratio_range: Tuple[float, float] = (0.5, 1.5),
+                bbox_clip_border: bool = True,
+                pad_val: float = 114.0,
+                prob: float = 1.0) -> None:
+       ...
+
+       # img_scale order should be (width, height)
+       self.img_scale = img_scale
+
+    def transform(self, results: dict) -> dict:
+        ...
+
+        results['img'] = mosaic_img
+        # (height, width)
+        results['img_shape'] = mosaic_img.shape[:2]
+```
+
+## Loss
+
+In MMDetection, a `dict` containing losses and metrics will be returned by `model(**data)`.
+
+For example, in bbox head,
+
+```python
+class BBoxHead(nn.Module):
+    ...
+    def loss(self, ...):
+        losses = dict()
+        # classification loss
+        losses['loss_cls'] = self.loss_cls(...)
+        # classification accuracy
+        losses['acc'] = accuracy(...)
+        # bbox regression loss
+        losses['loss_bbox'] = self.loss_bbox(...)
+        return losses
+```
+
+`bbox_head.loss()` will be called during model forward.
+The returned dict contains `'loss_bbox'`, `'loss_cls'`, `'acc'` .
+Only `'loss_bbox'`, `'loss_cls'` will be used during back propagation,
+`'acc'` will only be used as a metric to monitor training process.
+
+By default, only values whose keys contain `'loss'` will be back propagated.
+This behavior could be changed by modifying `BaseDetector.train_step()`.
+
+## Empty Proposals
+
+In MMDetection, We have added special handling and unit test for empty proposals of two-stage. We need to deal with the empty proposals of the entire batch and single image at the same time. For example, in CascadeRoIHead,
+
+```python
+# simple_test method
+...
+# There is no proposal in the whole batch
+if rois.shape[0] == 0:
+    bbox_results = [[
+        np.zeros((0, 5), dtype=np.float32)
+        for _ in range(self.bbox_head[-1].num_classes)
+    ]] * num_imgs
+    if self.with_mask:
+        mask_classes = self.mask_head[-1].num_classes
+        segm_results = [[[] for _ in range(mask_classes)]
+                        for _ in range(num_imgs)]
+        results = list(zip(bbox_results, segm_results))
+    else:
+        results = bbox_results
+    return results
+...
+
+# There is no proposal in the single image
+for i in range(self.num_stages):
+    ...
+    if i < self.num_stages - 1:
+          for j in range(num_imgs):
+                # Handle empty proposal
+                if rois[j].shape[0] > 0:
+                    bbox_label = cls_score[j][:, :-1].argmax(dim=1)
+                    refine_roi = self.bbox_head[i].regress_by_class(
+                         rois[j], bbox_label, bbox_pred[j], img_metas[j])
+                    refine_roi_list.append(refine_roi)
+```
+
+If you have customized `RoIHead`, you can refer to the above method to deal with empty proposals.
+
+## Coco Panoptic Dataset
+
+In MMDetection, we have supported COCO Panoptic dataset. We clarify a few conventions about the implementation of `CocoPanopticDataset` here.
+
+1. For mmdet\<=2.16.0, the range of foreground and background labels in semantic segmentation are different from the default setting of MMDetection. The label `0` stands for `VOID` label and the category labels start from `1`.
+   Since mmdet=2.17.0, the category labels of semantic segmentation start from `0` and label `255` stands for `VOID` for consistency with labels of bounding boxes.
+   To achieve that, the `Pad` pipeline supports setting the padding value for `seg`.
+2. In the evaluation, the panoptic result is a map with the same shape as the original image. Each value in the result map has the format of `instance_id * INSTANCE_OFFSET + category_id`.
diff --git a/mmdetection/docs/en/advanced_guides/customize_dataset.md b/mmdetection/docs/en/advanced_guides/customize_dataset.md
new file mode 100644
index 00000000..3d63d12c
--- /dev/null
+++ b/mmdetection/docs/en/advanced_guides/customize_dataset.md
@@ -0,0 +1,433 @@
+# Customize Datasets
+
+## Support new data format
+
+To support a new data format, you can either convert them to existing formats (COCO format or PASCAL format) or directly convert them to the middle format. You could also choose to convert them offline (before training by a script) or online (implement a new dataset and do the conversion at training). In MMDetection, we recommend to convert the data into COCO formats and do the conversion offline, thus you only need to modify the config's data annotation paths and classes after the conversion of your data.
+
+### Reorganize new data formats to existing format
+
+The simplest way is to convert your dataset to existing dataset formats (COCO or PASCAL VOC).
+
+The annotation JSON files in COCO format has the following necessary keys:
+
+```python
+'images': [
+    {
+        'file_name': 'COCO_val2014_000000001268.jpg',
+        'height': 427,
+        'width': 640,
+        'id': 1268
+    },
+    ...
+],
+
+'annotations': [
+    {
+        'segmentation': [[192.81,
+            247.09,
+            ...
+            219.03,
+            249.06]],  # If you have mask labels, and it is in polygon XY point coordinate format, you need to ensure that at least 3 point coordinates are included. Otherwise, it is an invalid polygon.
+        'area': 1035.749,
+        'iscrowd': 0,
+        'image_id': 1268,
+        'bbox': [192.81, 224.8, 74.73, 33.43],
+        'category_id': 16,
+        'id': 42986
+    },
+    ...
+],
+
+'categories': [
+    {'id': 0, 'name': 'car'},
+ ]
+```
+
+There are three necessary keys in the JSON file:
+
+- `images`: contains a list of images with their information like `file_name`, `height`, `width`, and `id`.
+- `annotations`: contains the list of instance annotations.
+- `categories`: contains the list of categories names and their ID.
+
+After the data pre-processing, there are two steps for users to train the customized new dataset with existing format (e.g. COCO format):
+
+1. Modify the config file for using the customized dataset.
+2. Check the annotations of the customized dataset.
+
+Here we give an example to show the above two steps, which uses a customized dataset of 5 classes with COCO format to train an existing Cascade Mask R-CNN R50-FPN detector.
+
+#### 1. Modify the config file for using the customized dataset
+
+There are two aspects involved in the modification of config file:
+
+1. The `data` field. Specifically, you need to explicitly add the `metainfo=dict(classes=classes)` fields in `train_dataloader.dataset`, `val_dataloader.dataset` and `test_dataloader.dataset` and `classes` must be a tuple type.
+2. The `num_classes` field in the `model` part. Explicitly over-write all the `num_classes` from default value (e.g. 80 in COCO) to your classes number.
+
+In `configs/my_custom_config.py`:
+
+```python
+
+# the new config inherits the base configs to highlight the necessary modification
+_base_ = './cascade_mask_rcnn_r50_fpn_1x_coco.py'
+
+# 1. dataset settings
+dataset_type = 'CocoDataset'
+classes = ('a', 'b', 'c', 'd', 'e')
+data_root='path/to/your/'
+
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=2,
+    dataset=dict(
+        type=dataset_type,
+        # explicitly add your class names to the field `metainfo`
+        metainfo=dict(classes=classes),
+        data_root=data_root,
+        ann_file='train/annotation_data',
+        data_prefix=dict(img='train/image_data')
+        )
+    )
+
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+    dataset=dict(
+        type=dataset_type,
+        test_mode=True,
+        # explicitly add your class names to the field `metainfo`
+        metainfo=dict(classes=classes),
+        data_root=data_root,
+        ann_file='val/annotation_data',
+        data_prefix=dict(img='val/image_data')
+        )
+    )
+
+test_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+    dataset=dict(
+        type=dataset_type,
+        test_mode=True,
+        # explicitly add your class names to the field `metainfo`
+        metainfo=dict(classes=classes),
+        data_root=data_root,
+        ann_file='test/annotation_data',
+        data_prefix=dict(img='test/image_data')
+        )
+    )
+
+# 2. model settings
+
+# explicitly over-write all the `num_classes` field from default 80 to 5.
+model = dict(
+    roi_head=dict(
+        bbox_head=[
+            dict(
+                type='Shared2FCBBoxHead',
+                # explicitly over-write all the `num_classes` field from default 80 to 5.
+                num_classes=5),
+            dict(
+                type='Shared2FCBBoxHead',
+                # explicitly over-write all the `num_classes` field from default 80 to 5.
+                num_classes=5),
+            dict(
+                type='Shared2FCBBoxHead',
+                # explicitly over-write all the `num_classes` field from default 80 to 5.
+                num_classes=5)],
+    # explicitly over-write all the `num_classes` field from default 80 to 5.
+    mask_head=dict(num_classes=5)))
+```
+
+#### 2. Check the annotations of the customized dataset
+
+Assuming your customized dataset is COCO format, make sure you have the correct annotations in the customized dataset:
+
+1. The length for `categories` field in annotations should exactly equal the tuple length of `classes` fields in your config, meaning the number of classes (e.g. 5 in this example).
+2. The `classes` fields in your config file should have exactly the same elements and the same order with the `name` in `categories` of annotations. MMDetection automatically maps the uncontinuous `id` in `categories` to the continuous label indices, so the string order of `name` in `categories` field affects the order of label indices. Meanwhile, the string order of `classes` in config affects the label text during visualization of predicted bounding boxes.
+3. The `category_id` in `annotations` field should be valid, i.e., all values in `category_id` should belong to `id` in `categories`.
+
+Here is a valid example of annotations:
+
+```python
+
+'annotations': [
+    {
+        'segmentation': [[192.81,
+            247.09,
+            ...
+            219.03,
+            249.06]],  # if you have mask labels
+        'area': 1035.749,
+        'iscrowd': 0,
+        'image_id': 1268,
+        'bbox': [192.81, 224.8, 74.73, 33.43],
+        'category_id': 16,
+        'id': 42986
+    },
+    ...
+],
+
+# MMDetection automatically maps the uncontinuous `id` to the continuous label indices.
+'categories': [
+    {'id': 1, 'name': 'a'}, {'id': 3, 'name': 'b'}, {'id': 4, 'name': 'c'}, {'id': 16, 'name': 'd'}, {'id': 17, 'name': 'e'},
+ ]
+```
+
+We use this way to support CityScapes dataset. The script is in [cityscapes.py](../../../tools/dataset_converters/cityscapes.py) and we also provide the finetuning [configs](../../../configs/cityscapes).
+
+**Note**
+
+1. For instance segmentation datasets, **MMDetection only supports evaluating mask AP of dataset in COCO format for now**.
+2. It is recommended to convert the data offline before training, thus you can still use `CocoDataset` and only need to modify the path of annotations and the training classes.
+
+### Reorganize new data format to middle format
+
+It is also fine if you do not want to convert the annotation format to COCO or PASCAL format.
+Actually, we define a simple annotation format in MMEninge's [BaseDataset](https://github.com/open-mmlab/mmengine/blob/main/mmengine/dataset/base_dataset.py#L116) and all existing datasets are
+processed to be compatible with it, either online or offline.
+
+The annotation of the dataset must be in `json` or `yaml`, `yml` or `pickle`, `pkl` format; the dictionary stored in the annotation file must contain two fields `metainfo` and `data_list`.  The `metainfo` is a dictionary, which contains the metadata of the dataset, such as class information; `data_list` is a list, each element in the list is a dictionary, the dictionary defines the raw data of one image, and each raw data contains a or several training/testing samples.
+
+Here is an example.
+
+```python
+{
+    'metainfo':
+        {
+            'classes': ('person', 'bicycle', 'car', 'motorcycle'),
+            ...
+        },
+    'data_list':
+        [
+            {
+                "img_path": "xxx/xxx_1.jpg",
+                "height": 604,
+                "width": 640,
+                "instances":
+                [
+                  {
+                    "bbox": [0, 0, 10, 20],
+                    "bbox_label": 1,
+                    "ignore_flag": 0
+                  },
+                  {
+                    "bbox": [10, 10, 110, 120],
+                    "bbox_label": 2,
+                    "ignore_flag": 0
+                  }
+                ]
+              },
+            {
+                "img_path": "xxx/xxx_2.jpg",
+                "height": 320,
+                "width": 460,
+                "instances":
+                [
+                  {
+                    "bbox": [10, 0, 20, 20],
+                    "bbox_label": 3,
+                    "ignore_flag": 1,
+                  }
+                ]
+              },
+            ...
+        ]
+}
+```
+
+Some datasets may provide annotations like crowd/difficult/ignored bboxes, we use `ignore_flag`to cover them.
+
+After obtaining the above standard data annotation format, you can directly use [BaseDetDataset](../../../mmdet/datasets/base_det_dataset.py#L13) of MMDetection in the configuration , without conversion.
+
+### An example of customized dataset
+
+Assume the annotation is in a new format in text files.
+The bounding boxes annotations are stored in text file `annotation.txt` as the following
+
+```
+#
+000001.jpg
+1280 720
+2
+10 20 40 60 1
+20 40 50 60 2
+#
+000002.jpg
+1280 720
+3
+50 20 40 60 2
+20 40 30 45 2
+30 40 50 60 3
+```
+
+We can create a new dataset in `mmdet/datasets/my_dataset.py` to load the data.
+
+```python
+import mmengine
+
+from mmdet.base_det_dataset import BaseDetDataset
+from mmdet.registry import DATASETS
+
+
+@DATASETS.register_module()
+class MyDataset(BaseDetDataset):
+
+    METAINFO = {
+       'classes': ('person', 'bicycle', 'car', 'motorcycle'),
+        'palette': [(220, 20, 60), (119, 11, 32), (0, 0, 142), (0, 0, 230)]
+    }
+
+    def load_data_list(self, ann_file):
+        ann_list = mmengine.list_from_file(ann_file)
+
+        data_infos = []
+        for i, ann_line in enumerate(ann_list):
+            if ann_line != '#':
+                continue
+
+            img_shape = ann_list[i + 2].split(' ')
+            width = int(img_shape[0])
+            height = int(img_shape[1])
+            bbox_number = int(ann_list[i + 3])
+
+            instances = []
+            for anns in ann_list[i + 4:i + 4 + bbox_number]:
+                instance = {}
+                instance['bbox'] = [float(ann) for ann in anns.split(' ')[:4]]
+                instance['bbox_label']=int(anns[4])
+ 				instances.append(instance)
+
+            data_infos.append(
+                dict(
+                    img_path=ann_list[i + 1],
+                    img_id=i,
+                    width=width,
+                    height=height,
+                    instances=instances
+                ))
+
+        return data_infos
+```
+
+Then in the config, to use `MyDataset` you can modify the config as the following
+
+```python
+dataset_A_train = dict(
+    type='MyDataset',
+    ann_file = 'image_list.txt',
+    pipeline=train_pipeline
+)
+```
+
+## Customize datasets by dataset wrappers
+
+MMEngine also supports many dataset wrappers to mix the dataset or modify the dataset distribution for training.
+Currently it supports to three dataset wrappers as below:
+
+- `RepeatDataset`: simply repeat the whole dataset.
+- `ClassBalancedDataset`: repeat dataset in a class balanced manner.
+- `ConcatDataset`: concat datasets.
+
+For detailed usage, see [MMEngine Dataset Wrapper](#TODO).
+
+## Modify Dataset Classes
+
+With existing dataset types, we can modify the metainfo of them to train subset of the annotations.
+For example, if you want to train only three classes of the current dataset,
+you can modify the classes of dataset.
+The dataset will filter out the ground truth boxes of other classes automatically.
+
+```python
+classes = ('person', 'bicycle', 'car')
+train_dataloader = dict(
+    dataset=dict(
+        metainfo=dict(classes=classes))
+    )
+val_dataloader = dict(
+    dataset=dict(
+        metainfo=dict(classes=classes))
+    )
+test_dataloader = dict(
+    dataset=dict(
+        metainfo=dict(classes=classes))
+    )
+```
+
+**Note**:
+
+- Before MMDetection v2.5.0, the dataset will filter out the empty GT images automatically if the classes are set and there is no way to disable that through config. This is an undesirable behavior and introduces confusion because if the classes are not set, the dataset only filter the empty GT images when `filter_empty_gt=True` and `test_mode=False`. After MMDetection v2.5.0, we decouple the image filtering process and the classes modification, i.e., the dataset will only filter empty GT images when `filter_cfg=dict(filter_empty_gt=True)` and `test_mode=False`, no matter whether the classes are set. Thus, setting the classes only influences the annotations of classes used for training and users could decide whether to filter empty GT images by themselves.
+- When directly using `BaseDataset` in MMEngine or `BaseDetDataset` in MMDetection, users cannot filter images without GT by modifying the configuration, but it can be solved in an offline way.
+- Please remember to modify the `num_classes` in the head when specifying `classes` in dataset. We implemented [NumClassCheckHook](../../../mmdet/engine/hooks/num_class_check_hook.py) to check whether the numbers are consistent since v2.9.0(after PR#4508).
+
+## COCO Panoptic Dataset
+
+Now we support COCO Panoptic Dataset, the format of panoptic annotations is different from COCO format.
+Both the foreground and the background will exist in the annotation file.
+The annotation json files in COCO Panoptic format has the following necessary keys:
+
+```python
+'images': [
+    {
+        'file_name': '000000001268.jpg',
+        'height': 427,
+        'width': 640,
+        'id': 1268
+    },
+    ...
+]
+
+'annotations': [
+    {
+        'filename': '000000001268.jpg',
+        'image_id': 1268,
+        'segments_info': [
+            {
+                'id':8345037,  # One-to-one correspondence with the id in the annotation map.
+                'category_id': 51,
+                'iscrowd': 0,
+                'bbox': (x1, y1, w, h),  # The bbox of the background is the outer rectangle of its mask.
+                'area': 24315
+            },
+            ...
+        ]
+    },
+    ...
+]
+
+'categories': [  # including both foreground categories and background categories
+    {'id': 0, 'name': 'person'},
+    ...
+ ]
+```
+
+Moreover, the `seg` must be set to the path of the panoptic annotation images.
+
+```python
+dataset_type = 'CocoPanopticDataset'
+data_root='path/to/your/'
+
+train_dataloader = dict(
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img='train/image_data/', seg='train/panoptic/image_annotation_data/')
+    )
+)
+val_dataloader = dict(
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img='val/image_data/', seg='val/panoptic/image_annotation_data/')
+    )
+)
+test_dataloader = dict(
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img='test/image_data/', seg='test/panoptic/image_annotation_data/')
+    )
+)
+```
diff --git a/mmdetection/docs/en/advanced_guides/customize_losses.md b/mmdetection/docs/en/advanced_guides/customize_losses.md
new file mode 100644
index 00000000..3120dc01
--- /dev/null
+++ b/mmdetection/docs/en/advanced_guides/customize_losses.md
@@ -0,0 +1,126 @@
+# Customize Losses
+
+MMDetection provides users with different loss functions. But the default configuration may be not applicable for different datasets or models, so users may want to modify a specific loss to adapt the new situation.
+
+This tutorial first elaborate the computation pipeline of losses, then give some instructions about how to modify each step. The modification can be categorized as tweaking and weighting.
+
+## Computation pipeline of a loss
+
+Given the input prediction and target, as well as the weights, a loss function maps the input tensor to the final loss scalar. The mapping can be divided into five steps:
+
+1. Set the sampling method to sample positive and negative samples.
+
+2. Get **element-wise** or **sample-wise** loss by the loss kernel function.
+
+3. Weighting the loss with a weight tensor **element-wisely**.
+
+4. Reduce the loss tensor to a **scalar**.
+
+5. Weighting the loss with a **scalar**.
+
+## Set sampling method (step 1)
+
+For some loss functions, sampling strategies are needed to avoid imbalance between positive and negative samples.
+
+For example, when using `CrossEntropyLoss` in RPN head, we need to set `RandomSampler` in `train_cfg`
+
+```python
+train_cfg=dict(
+    rpn=dict(
+        sampler=dict(
+            type='RandomSampler',
+            num=256,
+            pos_fraction=0.5,
+            neg_pos_ub=-1,
+            add_gt_as_proposals=False))
+```
+
+For some other losses which have positive and negative sample balance mechanism such as Focal Loss, GHMC, and QualityFocalLoss, the sampler is no more necessary.
+
+## Tweaking loss
+
+Tweaking a loss is more related with step 2, 4, 5, and most modifications can be specified in the config.
+Here we take [Focal Loss (FL)](../../../mmdet/models/losses/focal_loss.py) as an example.
+The following code sniper are the construction method and config of FL respectively, they are actually one to one correspondence.
+
+```python
+@LOSSES.register_module()
+class FocalLoss(nn.Module):
+
+    def __init__(self,
+                 use_sigmoid=True,
+                 gamma=2.0,
+                 alpha=0.25,
+                 reduction='mean',
+                 loss_weight=1.0):
+```
+
+```python
+loss_cls=dict(
+    type='FocalLoss',
+    use_sigmoid=True,
+    gamma=2.0,
+    alpha=0.25,
+    loss_weight=1.0)
+```
+
+### Tweaking hyper-parameters (step 2)
+
+`gamma` and `beta` are two hyper-parameters in the Focal Loss. Say if we want to change the value of `gamma` to be 1.5 and `alpha` to be 0.5, then we can specify them in the config as follows:
+
+```python
+loss_cls=dict(
+    type='FocalLoss',
+    use_sigmoid=True,
+    gamma=1.5,
+    alpha=0.5,
+    loss_weight=1.0)
+```
+
+### Tweaking the way of reduction (step 3)
+
+The default way of reduction is `mean` for FL. Say if we want to change the reduction from `mean` to `sum`, we can specify it in the config as follows:
+
+```python
+loss_cls=dict(
+    type='FocalLoss',
+    use_sigmoid=True,
+    gamma=2.0,
+    alpha=0.25,
+    loss_weight=1.0,
+    reduction='sum')
+```
+
+### Tweaking loss weight (step 5)
+
+The loss weight here is a scalar which controls the weight of different losses in multi-task learning, e.g. classification loss and regression loss. Say if we want to change to loss weight of classification loss to be 0.5, we can specify it in the config as follows:
+
+```python
+loss_cls=dict(
+    type='FocalLoss',
+    use_sigmoid=True,
+    gamma=2.0,
+    alpha=0.25,
+    loss_weight=0.5)
+```
+
+## Weighting loss (step 3)
+
+Weighting loss means we re-weight the loss element-wisely. To be more specific, we multiply the loss tensor with a weight tensor which has the same shape. As a result, different entries of the loss can be scaled differently, and so called element-wisely.
+The loss weight varies across different models and highly context related, but overall there are two kinds of loss weights, `label_weights` for classification loss and `bbox_weights` for bbox regression loss. You can find them in the `get_target` method of the corresponding head. Here we take [ATSSHead](../../../mmdet/models/dense_heads/atss_head.py#L322) as an example, which inherit [AnchorHead](../../../mmdet/models/dense_heads/anchor_head.py) but overwrite its `get_targets` method which yields different `label_weights` and `bbox_weights`.
+
+```
+class ATSSHead(AnchorHead):
+
+    ...
+
+    def get_targets(self,
+                    anchor_list,
+                    valid_flag_list,
+                    gt_bboxes_list,
+                    img_metas,
+                    gt_bboxes_ignore_list=None,
+                    gt_labels_list=None,
+                    label_channels=1,
+                    unmap_outputs=True):
+```
diff --git a/mmdetection/docs/en/advanced_guides/customize_models.md b/mmdetection/docs/en/advanced_guides/customize_models.md
new file mode 100644
index 00000000..1779aeb1
--- /dev/null
+++ b/mmdetection/docs/en/advanced_guides/customize_models.md
@@ -0,0 +1,412 @@
+# Customize Models
+
+We basically categorize model components into 5 types.
+
+- backbone: usually an FCN network to extract feature maps, e.g., ResNet, MobileNet.
+- neck: the component between backbones and heads, e.g., FPN, PAFPN.
+- head: the component for specific tasks, e.g., bbox prediction and mask prediction.
+- roi extractor: the part for extracting RoI features from feature maps, e.g., RoI Align.
+- loss: the component in head for calculating losses, e.g., FocalLoss, L1Loss, and GHMLoss.
+
+## Develop new components
+
+### Add a new backbone
+
+Here we show how to develop new components with an example of MobileNet.
+
+#### 1. Define a new backbone (e.g. MobileNet)
+
+Create a new file `mmdet/models/backbones/mobilenet.py`.
+
+```python
+import torch.nn as nn
+
+from mmdet.registry import MODELS
+
+
+@MODELS.register_module()
+class MobileNet(nn.Module):
+
+    def __init__(self, arg1, arg2):
+        pass
+
+    def forward(self, x):  # should return a tuple
+        pass
+```
+
+#### 2. Import the module
+
+You can either add the following line to `mmdet/models/backbones/__init__.py`
+
+```python
+from .mobilenet import MobileNet
+```
+
+or alternatively add
+
+```python
+custom_imports = dict(
+    imports=['mmdet.models.backbones.mobilenet'],
+    allow_failed_imports=False)
+```
+
+to the config file to avoid modifying the original code.
+
+#### 3. Use the backbone in your config file
+
+```python
+model = dict(
+    ...
+    backbone=dict(
+        type='MobileNet',
+        arg1=xxx,
+        arg2=xxx),
+    ...
+```
+
+### Add new necks
+
+#### 1. Define a neck (e.g. PAFPN)
+
+Create a new file `mmdet/models/necks/pafpn.py`.
+
+```python
+import torch.nn as nn
+
+from mmdet.registry import MODELS
+
+@MODELS.register_module()
+class PAFPN(nn.Module):
+
+    def __init__(self,
+                in_channels,
+                out_channels,
+                num_outs,
+                start_level=0,
+                end_level=-1,
+                add_extra_convs=False):
+        pass
+
+    def forward(self, inputs):
+        # implementation is ignored
+        pass
+```
+
+#### 2. Import the module
+
+You can either add the following line to `mmdet/models/necks/__init__.py`,
+
+```python
+from .pafpn import PAFPN
+```
+
+or alternatively add
+
+```python
+custom_imports = dict(
+    imports=['mmdet.models.necks.pafpn'],
+    allow_failed_imports=False)
+```
+
+to the config file and avoid modifying the original code.
+
+#### 3. Modify the config file
+
+```python
+neck=dict(
+    type='PAFPN',
+    in_channels=[256, 512, 1024, 2048],
+    out_channels=256,
+    num_outs=5)
+```
+
+### Add new heads
+
+Here we show how to develop a new head with the example of [Double Head R-CNN](https://arxiv.org/abs/1904.06493) as the following.
+
+First, add a new bbox head in `mmdet/models/roi_heads/bbox_heads/double_bbox_head.py`.
+Double Head R-CNN implements a new bbox head for object detection.
+To implement a bbox head, basically we need to implement three functions of the new module as the following.
+
+```python
+from typing import Tuple
+
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule, ModuleList
+from torch import Tensor
+
+from mmdet.models.backbones.resnet import Bottleneck
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, MultiConfig, OptConfigType, OptMultiConfig
+from .bbox_head import BBoxHead
+
+@MODELS.register_module()
+class DoubleConvFCBBoxHead(BBoxHead):
+    r"""Bbox head used in Double-Head R-CNN
+
+    .. code-block:: none
+
+                                          /-> cls
+                      /-> shared convs ->
+                                          \-> reg
+        roi features
+                                          /-> cls
+                      \-> shared fc    ->
+                                          \-> reg
+    """  # noqa: W605
+
+    def __init__(self,
+                 num_convs: int = 0,
+                 num_fcs: int = 0,
+                 conv_out_channels: int = 1024,
+                 fc_out_channels: int = 1024,
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: ConfigType = dict(type='BN'),
+                 init_cfg: MultiConfig = dict(
+                     type='Normal',
+                     override=[
+                         dict(type='Normal', name='fc_cls', std=0.01),
+                         dict(type='Normal', name='fc_reg', std=0.001),
+                         dict(
+                             type='Xavier',
+                             name='fc_branch',
+                             distribution='uniform')
+                     ]),
+                 **kwargs) -> None:
+        kwargs.setdefault('with_avg_pool', True)
+        super().__init__(init_cfg=init_cfg, **kwargs)
+
+    def forward(self, x_cls: Tensor, x_reg: Tensor) -> Tuple[Tensor]:
+
+```
+
+Second, implement a new RoI Head if it is necessary. We plan to inherit the new `DoubleHeadRoIHead` from `StandardRoIHead`. We can find that a `StandardRoIHead` already implements the following functions.
+
+```python
+from typing import List, Optional, Tuple
+
+import torch
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.structures import DetDataSample
+from mmdet.structures.bbox import bbox2roi
+from mmdet.utils import ConfigType, InstanceList
+from ..task_modules.samplers import SamplingResult
+from ..utils import empty_instances, unpack_gt_instances
+from .base_roi_head import BaseRoIHead
+
+
+@MODELS.register_module()
+class StandardRoIHead(BaseRoIHead):
+    """Simplest base roi head including one bbox head and one mask head."""
+
+    def init_assigner_sampler(self) -> None:
+
+    def init_bbox_head(self, bbox_roi_extractor: ConfigType,
+                       bbox_head: ConfigType) -> None:
+
+    def init_mask_head(self, mask_roi_extractor: ConfigType,
+                       mask_head: ConfigType) -> None:
+
+    def forward(self, x: Tuple[Tensor],
+                rpn_results_list: InstanceList) -> tuple:
+
+    def loss(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
+             batch_data_samples: List[DetDataSample]) -> dict:
+
+    def _bbox_forward(self, x: Tuple[Tensor], rois: Tensor) -> dict:
+
+    def bbox_loss(self, x: Tuple[Tensor],
+                  sampling_results: List[SamplingResult]) -> dict:
+
+    def mask_loss(self, x: Tuple[Tensor],
+                  sampling_results: List[SamplingResult], bbox_feats: Tensor,
+                  batch_gt_instances: InstanceList) -> dict:
+
+    def _mask_forward(self,
+                      x: Tuple[Tensor],
+                      rois: Tensor = None,
+                      pos_inds: Optional[Tensor] = None,
+                      bbox_feats: Optional[Tensor] = None) -> dict:
+
+    def predict_bbox(self,
+                     x: Tuple[Tensor],
+                     batch_img_metas: List[dict],
+                     rpn_results_list: InstanceList,
+                     rcnn_test_cfg: ConfigType,
+                     rescale: bool = False) -> InstanceList:
+
+    def predict_mask(self,
+                     x: Tuple[Tensor],
+                     batch_img_metas: List[dict],
+                     results_list: InstanceList,
+                     rescale: bool = False) -> InstanceList:
+
+```
+
+Double Head's modification is mainly in the `bbox_forward` logic, and it inherits other logics from the `StandardRoIHead`. In the `mmdet/models/roi_heads/double_roi_head.py`, we implement the new RoI Head as the following:
+
+```python
+from typing import Tuple
+
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from .standard_roi_head import StandardRoIHead
+
+
+@MODELS.register_module()
+class DoubleHeadRoIHead(StandardRoIHead):
+    """RoI head for `Double Head RCNN `_.
+
+    Args:
+        reg_roi_scale_factor (float): The scale factor to extend the rois
+            used to extract the regression features.
+    """
+
+    def __init__(self, reg_roi_scale_factor: float, **kwargs):
+        super().__init__(**kwargs)
+        self.reg_roi_scale_factor = reg_roi_scale_factor
+
+    def _bbox_forward(self, x: Tuple[Tensor], rois: Tensor) -> dict:
+        """Box head forward function used in both training and testing.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            rois (Tensor): RoIs with the shape (n, 5) where the first
+                column indicates batch id of each RoI.
+
+        Returns:
+             dict[str, Tensor]: Usually returns a dictionary with keys:
+
+                - `cls_score` (Tensor): Classification scores.
+                - `bbox_pred` (Tensor): Box energies / deltas.
+                - `bbox_feats` (Tensor): Extract bbox RoI features.
+        """
+        bbox_cls_feats = self.bbox_roi_extractor(
+            x[:self.bbox_roi_extractor.num_inputs], rois)
+        bbox_reg_feats = self.bbox_roi_extractor(
+            x[:self.bbox_roi_extractor.num_inputs],
+            rois,
+            roi_scale_factor=self.reg_roi_scale_factor)
+        if self.with_shared_head:
+            bbox_cls_feats = self.shared_head(bbox_cls_feats)
+            bbox_reg_feats = self.shared_head(bbox_reg_feats)
+        cls_score, bbox_pred = self.bbox_head(bbox_cls_feats, bbox_reg_feats)
+
+        bbox_results = dict(
+            cls_score=cls_score,
+            bbox_pred=bbox_pred,
+            bbox_feats=bbox_cls_feats)
+        return bbox_results
+```
+
+Last, the users need to add the module in
+`mmdet/models/bbox_heads/__init__.py` and `mmdet/models/roi_heads/__init__.py` thus the corresponding registry could find and load them.
+
+Alternatively, the users can add
+
+```python
+custom_imports=dict(
+    imports=['mmdet.models.roi_heads.double_roi_head', 'mmdet.models.roi_heads.bbox_heads.double_bbox_head'])
+```
+
+to the config file and achieve the same goal.
+
+The config file of Double Head R-CNN is as the following
+
+```python
+_base_ = '../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py'
+model = dict(
+    roi_head=dict(
+        type='DoubleHeadRoIHead',
+        reg_roi_scale_factor=1.3,
+        bbox_head=dict(
+            _delete_=True,
+            type='DoubleConvFCBBoxHead',
+            num_convs=4,
+            num_fcs=2,
+            in_channels=256,
+            conv_out_channels=1024,
+            fc_out_channels=1024,
+            roi_feat_size=7,
+            num_classes=80,
+            bbox_coder=dict(
+                type='DeltaXYWHBBoxCoder',
+                target_means=[0., 0., 0., 0.],
+                target_stds=[0.1, 0.1, 0.2, 0.2]),
+            reg_class_agnostic=False,
+            loss_cls=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=2.0),
+            loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=2.0))))
+
+```
+
+Since MMDetection 2.0, the config system supports to inherit configs such that the users can focus on the modification.
+The Double Head R-CNN mainly uses a new `DoubleHeadRoIHead` and a new `DoubleConvFCBBoxHead `, the arguments are set according to the `__init__` function of each module.
+
+### Add new loss
+
+Assume you want to add a new loss as `MyLoss`, for bounding box regression.
+To add a new loss function, the users need implement it in `mmdet/models/losses/my_loss.py`.
+The decorator `weighted_loss` enable the loss to be weighted for each element.
+
+```python
+import torch
+import torch.nn as nn
+
+from mmdet.registry import MODELS
+from .utils import weighted_loss
+
+@weighted_loss
+def my_loss(pred, target):
+    assert pred.size() == target.size() and target.numel() > 0
+    loss = torch.abs(pred - target)
+    return loss
+
+@MODELS.register_module()
+class MyLoss(nn.Module):
+
+    def __init__(self, reduction='mean', loss_weight=1.0):
+        super(MyLoss, self).__init__()
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+
+    def forward(self,
+                pred,
+                target,
+                weight=None,
+                avg_factor=None,
+                reduction_override=None):
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        loss_bbox = self.loss_weight * my_loss(
+            pred, target, weight, reduction=reduction, avg_factor=avg_factor)
+        return loss_bbox
+```
+
+Then the users need to add it in the `mmdet/models/losses/__init__.py`.
+
+```python
+from .my_loss import MyLoss, my_loss
+
+```
+
+Alternatively, you can add
+
+```python
+custom_imports=dict(
+    imports=['mmdet.models.losses.my_loss'])
+```
+
+to the config file and achieve the same goal.
+
+To use it, modify the `loss_xxx` field.
+Since MyLoss is for regression, you need to modify the `loss_bbox` field in the head.
+
+```python
+loss_bbox=dict(type='MyLoss', loss_weight=1.0))
+```
diff --git a/mmdetection/docs/en/advanced_guides/customize_runtime.md b/mmdetection/docs/en/advanced_guides/customize_runtime.md
new file mode 100644
index 00000000..e6ce740a
--- /dev/null
+++ b/mmdetection/docs/en/advanced_guides/customize_runtime.md
@@ -0,0 +1,391 @@
+# Customize Runtime Settings
+
+## Customize optimization settings
+
+Optimization related configuration is now all managed by `optim_wrapper` which usually has three fields: `optimizer`, `paramwise_cfg`, `clip_grad`, refer to [OptimWrapper](https://mmengine.readthedocs.io/en/latest/tutorials/optim_wrapper.md) for more detail. See the example below, where `Adamw` is used as an `optimizer`, the learning rate of the backbone is reduced by a factor of 10, and gradient clipping is added.
+
+```python
+optim_wrapper = dict(
+    type='OptimWrapper',
+    # optimizer
+    optimizer=dict(
+        type='AdamW',
+        lr=0.0001,
+        weight_decay=0.05,
+        eps=1e-8,
+        betas=(0.9, 0.999)),
+
+    # Parameter-level learning rate and weight decay settings
+    paramwise_cfg=dict(
+        custom_keys={
+            'backbone': dict(lr_mult=0.1, decay_mult=1.0),
+        },
+        norm_decay_mult=0.0),
+
+    # gradient clipping
+    clip_grad=dict(max_norm=0.01, norm_type=2))
+```
+
+### Customize optimizer supported by Pytorch
+
+We already support to use all the optimizers implemented by PyTorch, and the only modification is to change the `optimizer` field in `optim_wrapper` field of config files. For example, if you want to use `ADAM` (note that the performance could drop a lot), the modification could be as the following.
+
+```python
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='Adam', lr=0.0003, weight_decay=0.0001))
+```
+
+To modify the learning rate of the model, the users only need to modify the `lr` in `optimizer`. The users can directly set arguments following the [API doc](https://pytorch.org/docs/stable/optim.html?highlight=optim#module-torch.optim) of PyTorch.
+
+### Customize self-implemented optimizer
+
+#### 1. Define a new optimizer
+
+A customized optimizer could be defined as following.
+
+Assume you want to add a optimizer named `MyOptimizer`, which has arguments `a`, `b`, and `c`.
+You need to create a new directory named `mmdet/engine/optimizers`. And then implement the new optimizer in a file, e.g., in `mmdet/engine/optimizers/my_optimizer.py`:
+
+```python
+from mmdet.registry import OPTIMIZERS
+from torch.optim import Optimizer
+
+
+@OPTIMIZERS.register_module()
+class MyOptimizer(Optimizer):
+
+    def __init__(self, a, b, c)
+
+```
+
+#### 2. Add the optimizer to registry
+
+To find the above module defined above, this module should be imported into the main namespace at first. There are two options to achieve it.
+
+- Modify `mmdet/engine/optimizers/__init__.py` to import it.
+
+  The newly defined module should be imported in `mmdet/engine/optimizers/__init__.py` so that the registry will find the new module and add it:
+
+```python
+from .my_optimizer import MyOptimizer
+```
+
+- Use `custom_imports` in the config to manually import it
+
+```python
+custom_imports = dict(imports=['mmdet.engine.optimizers.my_optimizer'], allow_failed_imports=False)
+```
+
+The module `mmdet.engine.optimizers.my_optimizer` will be imported at the beginning of the program and the class `MyOptimizer` is then automatically registered.
+Note that only the package containing the class `MyOptimizer` should be imported.
+`mmdet.engine.optimizers.my_optimizer.MyOptimizer` **cannot** be imported directly.
+
+Actually users can use a totally different file directory structure using this importing method, as long as the module root can be located in `PYTHONPATH`.
+
+#### 3. Specify the optimizer in the config file
+
+Then you can use `MyOptimizer` in `optimizer` field in `optim_wrapper` field of config files. In the configs, the optimizers are defined by the field `optimizer` like the following:
+
+```python
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001))
+```
+
+To use your own optimizer, the field can be changed to
+
+```python
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='MyOptimizer', a=a_value, b=b_value, c=c_value))
+```
+
+### Customize optimizer wrapper constructor
+
+Some models may have some parameter-specific settings for optimization, e.g. weight decay for BatchNorm layers.
+The users can do those fine-grained parameter tuning through customizing optimizer wrapper constructor.
+
+```python
+from mmengine.optim import DefaultOptiWrapperConstructor
+
+from mmdet.registry import OPTIM_WRAPPER_CONSTRUCTORS
+from .my_optimizer import MyOptimizer
+
+
+@OPTIM_WRAPPER_CONSTRUCTORS.register_module()
+class MyOptimizerWrapperConstructor(DefaultOptimWrapperConstructor):
+
+    def __init__(self,
+                 optim_wrapper_cfg: dict,
+                 paramwise_cfg: Optional[dict] = None):
+
+    def __call__(self, model: nn.Module) -> OptimWrapper:
+
+        return optim_wrapper
+
+```
+
+The default optimizer wrapper constructor is implemented [here](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/default_constructor.py#L18), which could also serve as a template for the new optimizer wrapper constructor.
+
+### Additional settings
+
+Tricks not implemented by the optimizer should be implemented through optimizer wrapper constructor (e.g., set parameter-wise learning rates) or hooks. We list some common settings that could stabilize the training or accelerate the training. Feel free to create PR, issue for more settings.
+
+- __Use gradient clip to stabilize training__:
+  Some models need gradient clip to clip the gradients to stabilize the training process. An example is as below:
+
+  ```python
+  optim_wrapper = dict(
+      _delete_=True, clip_grad=dict(max_norm=35, norm_type=2))
+  ```
+
+  If your config inherits the base config which already sets the `optim_wrapper`, you might need `_delete_=True` to override the unnecessary settings. See the [config documentation](../user_guides/config.md) for more details.
+
+- __Use momentum schedule to accelerate model convergence__:
+  We support momentum scheduler to modify model's momentum according to learning rate, which could make the model converge in a faster way.
+  Momentum scheduler is usually used with LR scheduler, for example, the following config is used in [3D detection](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/configs/_base_/schedules/cyclic-20e.py) to accelerate convergence.
+  For more details, please refer to the implementation of [CosineAnnealingLR](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/scheduler/lr_scheduler.py#L43) and [CosineAnnealingMomentum](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/scheduler/momentum_scheduler.py#L71).
+
+  ```python
+  param_scheduler = [
+      # learning rate scheduler
+      # During the first 8 epochs, learning rate increases from 0 to lr * 10
+      # during the next 12 epochs, learning rate decreases from lr * 10 to lr * 1e-4
+      dict(
+          type='CosineAnnealingLR',
+          T_max=8,
+          eta_min=lr * 10,
+          begin=0,
+          end=8,
+          by_epoch=True,
+          convert_to_iter_based=True),
+      dict(
+          type='CosineAnnealingLR',
+          T_max=12,
+          eta_min=lr * 1e-4,
+          begin=8,
+          end=20,
+          by_epoch=True,
+          convert_to_iter_based=True),
+      # momentum scheduler
+      # During the first 8 epochs, momentum increases from 0 to 0.85 / 0.95
+      # during the next 12 epochs, momentum increases from 0.85 / 0.95 to 1
+      dict(
+          type='CosineAnnealingMomentum',
+          T_max=8,
+          eta_min=0.85 / 0.95,
+          begin=0,
+          end=8,
+          by_epoch=True,
+          convert_to_iter_based=True),
+      dict(
+          type='CosineAnnealingMomentum',
+          T_max=12,
+          eta_min=1,
+          begin=8,
+          end=20,
+          by_epoch=True,
+          convert_to_iter_based=True)
+  ]
+  ```
+
+## Customize training schedules
+
+By default we use step learning rate with 1x schedule, this calls [MultiStepLR](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/scheduler/lr_scheduler.py#L139) in MMEngine.
+We support many other learning rate schedule [here](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/scheduler/lr_scheduler.py), such as `CosineAnnealingLR` and `PolyLR` schedule. Here are some examples
+
+- Poly schedule:
+
+  ```python
+  param_scheduler = [
+      dict(
+          type='PolyLR',
+          power=0.9,
+          eta_min=1e-4,
+          begin=0,
+          end=8,
+          by_epoch=True)]
+  ```
+
+- ConsineAnnealing schedule:
+
+  ```python
+  param_scheduler = [
+      dict(
+          type='CosineAnnealingLR',
+          T_max=8,
+          eta_min=lr * 1e-5,
+          begin=0,
+          end=8,
+          by_epoch=True)]
+
+  ```
+
+## Customize train loop
+
+By default, `EpochBasedTrainLoop` is used in `train_cfg` and validation is done after every train epoch, as follows.
+
+```python
+train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=12, val_begin=1, val_interval=1)
+```
+
+Actually, both [`IterBasedTrainLoop`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py#L183%5D) and [`EpochBasedTrainLoop`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py#L18) support dynamical interval, see the following example.
+
+```python
+# Before 365001th iteration, we do evaluation every 5000 iterations.
+# After 365000th iteration, we do evaluation every 368750 iterations,
+# which means that we do evaluation at the end of training.
+
+interval = 5000
+max_iters = 368750
+dynamic_intervals = [(max_iters // interval * interval + 1, max_iters)]
+train_cfg = dict(
+    type='IterBasedTrainLoop',
+    max_iters=max_iters,
+    val_interval=interval,
+    dynamic_intervals=dynamic_intervals)
+```
+
+## Customize hooks
+
+### Customize self-implemented hooks
+
+#### 1. Implement a new hook
+
+MMEngine provides many useful [hooks](https://mmengine.readthedocs.io/en/latest/tutorials/hooks.html), but there are some occasions when the users might need to implement a new hook. MMDetection supports customized hooks in training in v3.0 . Thus the users could implement a hook directly in mmdet or their mmdet-based codebases and use the hook by only modifying the config in training.
+Here we give an example of creating a new hook in mmdet and using it in training.
+
+```python
+from mmengine.hooks import Hook
+from mmdet.registry import HOOKS
+
+
+@HOOKS.register_module()
+class MyHook(Hook):
+
+    def __init__(self, a, b):
+
+    def before_run(self, runner) -> None:
+
+    def after_run(self, runner) -> None:
+
+    def before_train(self, runner) -> None:
+
+    def after_train(self, runner) -> None:
+
+    def before_train_epoch(self, runner) -> None:
+
+    def after_train_epoch(self, runner) -> None:
+
+    def before_train_iter(self,
+                          runner,
+                          batch_idx: int,
+                          data_batch: DATA_BATCH = None) -> None:
+
+    def after_train_iter(self,
+                         runner,
+                         batch_idx: int,
+                         data_batch: DATA_BATCH = None,
+                         outputs: Optional[dict] = None) -> None:
+```
+
+Depending on the functionality of the hook, the users need to specify what the hook will do at each stage of the training in `before_run`, `after_run`, `before_train`, `after_train` , `before_train_epoch`, `after_train_epoch`, `before_train_iter`, and `after_train_iter`.  There are more points where hooks can be inserted, refer to [base hook class](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/hook.py#L9) for more detail.
+
+#### 2. Register the new hook
+
+Then we need to make `MyHook` imported. Assuming the file is in `mmdet/engine/hooks/my_hook.py` there are two ways to do that:
+
+- Modify `mmdet/engine/hooks/__init__.py` to import it.
+
+  The newly defined module should be imported in `mmdet/engine/hooks/__init__.py` so that the registry will find the new module and add it:
+
+```python
+from .my_hook import MyHook
+```
+
+- Use `custom_imports` in the config to manually import it
+
+```python
+custom_imports = dict(imports=['mmdet.engine.hooks.my_hook'], allow_failed_imports=False)
+```
+
+#### 3. Modify the config
+
+```python
+custom_hooks = [
+    dict(type='MyHook', a=a_value, b=b_value)
+]
+```
+
+You can also set the priority of the hook by adding key `priority` to `'NORMAL'` or `'HIGHEST'` as below
+
+```python
+custom_hooks = [
+    dict(type='MyHook', a=a_value, b=b_value, priority='NORMAL')
+]
+```
+
+By default the hook's priority is set as `NORMAL` during registration.
+
+### Use hooks implemented in MMDetection
+
+If the hook is already implemented in MMDectection, you can directly modify the config to use the hook as below
+
+#### Example: `NumClassCheckHook`
+
+We implement a customized hook named [NumClassCheckHook](../../../mmdet/engine/hooks/num_class_check_hook.py) to check whether the `num_classes` in head matches the length of `classes` in the metainfo of `dataset`.
+
+We set it in [default_runtime.py](../../../configs/_base_/default_runtime.py).
+
+```python
+custom_hooks = [dict(type='NumClassCheckHook')]
+```
+
+### Modify default runtime hooks
+
+There are some common hooks that are registered through `default_hooks`, they are
+
+- `IterTimerHook`: A hook that logs 'data_time' for loading data and 'time' for a model train step.
+- `LoggerHook`: A hook that Collect logs from different components of `Runner` and write them to terminal, JSON file, tensorboard and wandb .etc.
+- `ParamSchedulerHook`: A hook to update some hyper-parameters in optimizer, e.g., learning rate and momentum.
+- `CheckpointHook`: A hook that saves checkpoints periodically.
+- `DistSamplerSeedHook`: A hook that sets the seed for sampler and batch_sampler.
+- `DetVisualizationHook`: A hook used to visualize validation and testing process prediction results.
+
+`IterTimerHook`, `ParamSchedulerHook` and `DistSamplerSeedHook` are simple and no need to be modified usually, so here we reveals how what we can do with `LoggerHook`, `CheckpointHook` and `DetVisualizationHook`.
+
+#### CheckpointHook
+
+Except saving checkpoints periodically, [`CheckpointHook`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/checkpoint_hook.py#L19) provides other options such as `max_keep_ckpts`, `save_optimizer` and etc. The users could set `max_keep_ckpts` to only save small number of checkpoints or decide whether to store state dict of optimizer by `save_optimizer`. More details of the arguments are [here](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/checkpoint_hook.py#L19)
+
+```python
+default_hooks = dict(
+    checkpoint=dict(
+        type='CheckpointHook',
+        interval=1,
+        max_keep_ckpts=3,
+        save_optimizer=True))
+```
+
+#### LoggerHook
+
+The `LoggerHook` enables to set intervals. And the detail usages can be found in the [docstring](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/logger_hook.py#L18).
+
+```python
+default_hooks = dict(logger=dict(type='LoggerHook', interval=50))
+```
+
+#### DetVisualizationHook
+
+`DetVisualizationHook` use `DetLocalVisualizer` to visualize prediction results, and `DetLocalVisualizer` current supports different backends, e.g., `TensorboardVisBackend` and `WandbVisBackend` (see [docstring](https://github.com/open-mmlab/mmengine/blob/main/mmengine/visualization/vis_backend.py) for more detail). The users could add multi backbends to do visualization, as follows.
+
+```python
+default_hooks = dict(
+    visualization=dict(type='DetVisualizationHook', draw=True))
+
+vis_backends = [dict(type='LocalVisBackend'),
+                dict(type='TensorboardVisBackend')]
+visualizer = dict(
+    type='DetLocalVisualizer', vis_backends=vis_backends, name='visualizer')
+```
diff --git a/mmdetection/docs/en/advanced_guides/customize_transforms.md b/mmdetection/docs/en/advanced_guides/customize_transforms.md
new file mode 100644
index 00000000..5fe84e9f
--- /dev/null
+++ b/mmdetection/docs/en/advanced_guides/customize_transforms.md
@@ -0,0 +1,49 @@
+# Customize Data Pipelines
+
+1. Write a new transform in a file, e.g., in `my_pipeline.py`. It takes a dict as input and returns a dict.
+
+   ```python
+   import random
+   from mmcv.transforms import BaseTransform
+   from mmdet.registry import TRANSFORMS
+
+
+   @TRANSFORMS.register_module()
+   class MyTransform(BaseTransform):
+       """Add your transform
+
+       Args:
+           p (float): Probability of shifts. Default 0.5.
+       """
+
+       def __init__(self, prob=0.5):
+           self.prob = prob
+
+       def transform(self, results):
+           if random.random() > self.prob:
+               results['dummy'] = True
+           return results
+   ```
+
+2. Import and use the pipeline in your config file.
+   Make sure the import is relative to where your train script is located.
+
+   ```python
+   custom_imports = dict(imports=['path.to.my_pipeline'], allow_failed_imports=False)
+
+   train_pipeline = [
+       dict(type='LoadImageFromFile'),
+       dict(type='LoadAnnotations', with_bbox=True),
+       dict(type='Resize', scale=(1333, 800), keep_ratio=True),
+       dict(type='RandomFlip', prob=0.5),
+       dict(type='MyTransform', prob=0.2),
+       dict(type='PackDetInputs')
+   ]
+   ```
+
+3. Visualize the output of your transforms pipeline
+
+   To visualize the output of your transforms pipeline, `tools/misc/browse_dataset.py`
+   can help the user to browse a detection dataset (both images and bounding box annotations)
+   visually, or save the image to a designated directory. More details can refer to
+   [visualization documentation](../user_guides/visualization.md)
diff --git a/mmdetection/docs/en/advanced_guides/data_flow.md b/mmdetection/docs/en/advanced_guides/data_flow.md
new file mode 100644
index 00000000..59e7ca32
--- /dev/null
+++ b/mmdetection/docs/en/advanced_guides/data_flow.md
@@ -0,0 +1 @@
+# Data Flow
diff --git a/mmdetection/docs/en/advanced_guides/datasets.md b/mmdetection/docs/en/advanced_guides/datasets.md
new file mode 100644
index 00000000..157ea3aa
--- /dev/null
+++ b/mmdetection/docs/en/advanced_guides/datasets.md
@@ -0,0 +1 @@
+# Datasets
diff --git a/mmdetection/docs/en/advanced_guides/engine.md b/mmdetection/docs/en/advanced_guides/engine.md
new file mode 100644
index 00000000..eaa55b0c
--- /dev/null
+++ b/mmdetection/docs/en/advanced_guides/engine.md
@@ -0,0 +1 @@
+# Engine
diff --git a/mmdetection/docs/en/advanced_guides/evaluation.md b/mmdetection/docs/en/advanced_guides/evaluation.md
new file mode 100644
index 00000000..b394c769
--- /dev/null
+++ b/mmdetection/docs/en/advanced_guides/evaluation.md
@@ -0,0 +1 @@
+# Evaluation
diff --git a/mmdetection/docs/en/advanced_guides/how_to.md b/mmdetection/docs/en/advanced_guides/how_to.md
new file mode 100644
index 00000000..7eb41cee
--- /dev/null
+++ b/mmdetection/docs/en/advanced_guides/how_to.md
@@ -0,0 +1,222 @@
+This tutorial collects answers to any `How to xxx with MMDetection`. Feel free to update this doc if you meet new questions about `How to` and find the answers!
+
+# Use backbone network through MMPretrain
+
+The model registry in MMDet, MMPreTrain, MMSeg all inherit from the root registry in MMEngine. This allows these repositories to directly use the modules already implemented by each other. Therefore, users can use backbone networks from MMPretrain in MMDetection without implementing a network that already exists in MMPretrain.
+
+## Use backbone network implemented in MMPretrain
+
+Suppose you want to use `MobileNetV3-small` as the backbone network of `RetinaNet`, the example config is as the following.
+
+```python
+_base_ = [
+    '../_base_/models/retinanet_r50_fpn.py',
+    '../_base_/datasets/coco_detection.py',
+    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
+]
+# please install mmpretrain
+# import mmpretrain.models to trigger register_module in mmpretrain
+custom_imports = dict(imports=['mmpretrain.models'], allow_failed_imports=False)
+pretrained = 'https://download.openmmlab.com/mmclassification/v0/mobilenet_v3/convert/mobilenet_v3_small-8427ecf0.pth'
+model = dict(
+    backbone=dict(
+        _delete_=True, # Delete the backbone field in _base_
+        type='mmpretrain.MobileNetV3', # Using MobileNetV3 from mmpretrain
+        arch='small',
+        out_indices=(3, 8, 11), # Modify out_indices
+        init_cfg=dict(
+            type='Pretrained',
+            checkpoint=pretrained,
+            prefix='backbone.')), # The pre-trained weights of backbone network in mmpretrain have prefix='backbone.'. The prefix in the keys will be removed so that these weights can be normally loaded.
+    # Modify in_channels
+    neck=dict(in_channels=[24, 48, 96], start_level=0))
+```
+
+## Use backbone network in TIMM through MMPretrain
+
+MMPretrain also provides a wrapper for the PyTorch Image Models (timm) backbone network, users can directly use the backbone network in timm through MMPretrain. Suppose you want to use [EfficientNet-B1](../../../configs/timm_example/retinanet_timm-efficientnet-b1_fpn_1x_coco.py) as the backbone network of RetinaNet, the example config is as the following.
+
+```python
+# https://github.com/open-mmlab/mmdetection/blob/main/configs/timm_example/retinanet_timm-efficientnet-b1_fpn_1x_coco.py
+
+_base_ = [
+    '../_base_/models/retinanet_r50_fpn.py',
+    '../_base_/datasets/coco_detection.py',
+    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
+]
+
+# please install mmpretrain
+# import mmpretrain.models to trigger register_module in mmpretrain
+custom_imports = dict(imports=['mmpretrain.models'], allow_failed_imports=False)
+model = dict(
+    backbone=dict(
+        _delete_=True, # Delete the backbone field in _base_
+        type='mmpretrain.TIMMBackbone', # Using timm from mmpretrain
+        model_name='efficientnet_b1',
+        features_only=True,
+        pretrained=True,
+        out_indices=(1, 2, 3, 4)), # Modify out_indices
+    neck=dict(in_channels=[24, 40, 112, 320])) # Modify in_channels
+
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)
+```
+
+`type='mmpretrain.TIMMBackbone'` means use the `TIMMBackbone` class from MMPretrain in MMDetection, and the model used is `EfficientNet-B1`, where `mmpretrain` means the MMPretrain repo and `TIMMBackbone` means the TIMMBackbone wrapper implemented in MMPretrain.
+
+For the principle of the Hierarchy Registry, please refer to the [MMEngine document](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/config.md). For how to use other backbones in MMPretrain, you can refer to the [MMPretrain document](https://mmpretrain.readthedocs.io/en/latest/user_guides/config.html).
+
+# Use Mosaic augmentation
+
+If you want to use `Mosaic` in training, please make sure that you use `MultiImageMixDataset` at the same time. Taking the 'Faster R-CNN' algorithm as an example, you should modify the values of `train_pipeline` and `train_dataset` in the config as below:
+
+```python
+# Open configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py directly and add the following fields
+data_root = 'data/coco/'
+dataset_type = 'CocoDataset'
+img_scale=(1333, 800)
+
+train_pipeline = [
+    dict(type='Mosaic', img_scale=img_scale, pad_val=114.0),
+    dict(
+        type='RandomAffine',
+        scaling_ratio_range=(0.1, 2),
+        border=(-img_scale[0] // 2, -img_scale[1] // 2)), # The image will be enlarged by 4 times after Mosaic processing,so we use affine transformation to restore the image size.
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs')
+]
+
+train_dataset = dict(
+    _delete_ = True, # remove unnecessary Settings
+    type='MultiImageMixDataset',
+    dataset=dict(
+        type=dataset_type,
+        ann_file=data_root + 'annotations/instances_train2017.json',
+        img_prefix=data_root + 'train2017/',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations', with_bbox=True)
+        ],
+        filter_empty_gt=False,
+    ),
+    pipeline=train_pipeline
+    )
+
+data = dict(
+    train=train_dataset
+    )
+```
+
+# Unfreeze backbone network after freezing the backbone in the config
+
+If you have freezed the backbone network in the config and want to unfreeze it after some epoches, you can write a hook function to do it.  Taking the Faster R-CNN with the resnet backbone as an example, you can freeze one stage of the backbone network and  add a `custom_hooks` in the config as below:
+
+```python
+_base_ = [
+    '../_base_/models/faster-rcnn_r50_fpn.py',
+    '../_base_/datasets/coco_detection.py',
+    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
+]
+model = dict(
+    # freeze one stage of the backbone network.
+    backbone=dict(frozen_stages=1),
+)
+custom_hooks = [dict(type="UnfreezeBackboneEpochBasedHook", unfreeze_epoch=1)]
+```
+
+Meanwhile write the hook class `UnfreezeBackboneEpochBasedHook` in `mmdet/core/hook/unfreeze_backbone_epoch_based_hook.py`
+
+```python
+from mmengine.model import is_model_wrapper
+from mmengine.hooks import Hook
+from mmdet.registry import HOOKS
+
+
+@HOOKS.register_module()
+class UnfreezeBackboneEpochBasedHook(Hook):
+    """Unfreeze backbone network Hook.
+
+    Args:
+        unfreeze_epoch (int): The epoch unfreezing the backbone network.
+    """
+
+    def __init__(self, unfreeze_epoch=1):
+        self.unfreeze_epoch = unfreeze_epoch
+
+    def before_train_epoch(self, runner):
+        # Unfreeze the backbone network.
+        # Only valid for resnet.
+        if runner.epoch == self.unfreeze_epoch:
+            model = runner.model
+            if is_model_wrapper(model):
+                model = model.module
+            backbone = model.backbone
+            if backbone.frozen_stages >= 0:
+                if backbone.deep_stem:
+                    backbone.stem.train()
+                    for param in backbone.stem.parameters():
+                        param.requires_grad = True
+                else:
+                    backbone.norm1.train()
+                    for m in [backbone.conv1, backbone.norm1]:
+                        for param in m.parameters():
+                            param.requires_grad = True
+
+            for i in range(1, backbone.frozen_stages + 1):
+                m = getattr(backbone, f'layer{i}')
+                m.train()
+                for param in m.parameters():
+                    param.requires_grad = True
+```
+
+# Get the channels of a new backbone
+
+If you want to get the channels of a new backbone, you can build this backbone alone and input a pseudo image to get each stage output.
+
+Take `ResNet` as an example:
+
+```python
+from mmdet.models import ResNet
+import torch
+self = ResNet(depth=18)
+self.eval()
+inputs = torch.rand(1, 3, 32, 32)
+level_outputs = self.forward(inputs)
+for level_out in level_outputs:
+    print(tuple(level_out.shape))
+
+```
+
+Output of the above script is as below:
+
+```python
+(1, 64, 8, 8)
+(1, 128, 4, 4)
+(1, 256, 2, 2)
+(1, 512, 1, 1)
+```
+
+Users can get the channels of the new backbone by Replacing the `ResNet(depth=18)` in this script with their customized backbone.
+
+# Use Detectron2 Model in MMDetection
+
+Users can use Detectron2Wrapper to run Detectron2's model in MMDetection. We provide examples of [Faster R-CNN](../../../configs/misc/d2_faster-rcnn_r50-caffe_fpn_ms-90k_coco.py),
+[Mask R-CNN](../../../configs/misc/d2_mask-rcnn_r50-caffe_fpn_ms-90k_coco.py), and [RetinaNet](../../../configs/misc/d2_retinanet_r50-caffe_fpn_ms-90k_coco.py) in MMDetection.
+
+The algorithm components in config file should be the same as those of in Detectron2. During setup, we will first initialize the default settings, which can be found in [Detectron2](https://github.com/facebookresearch/detectron2/blob/main/detectron2/config/defaults.py).
+Then, the settings in config file will overwrite the default settings and the model will be built with these settings.
+The input data will first convert to Detectron2's type and feed into Detectron2's model.
+During inference the results calculate from Detectron2's model will reconvert back to the MMDetection's type.
+
+## Use Detectron2's pre-trained weights
+
+The weight initialization in `Detectron2Wrapper` will not use the logic of MMDetection. Users can set `model.d2_detector.weights=xxx` to load pre-trained weights.
+For example, we can use `model.d2_detector.weights='detectron2://ImageNetPretrained/MSRA/R-50.pkl'` to load the pre-trained ResNet-50 or use
+`model.d2_detector.weights='detectron2://COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_1x/137260431/model_final_a54504.pkl'` to load the pre-trained Mask R-CNN weights proposed in Detectron2.
+
+**Note:** Detectron2's pretrained model cannot be loaded directly by using `load_from`, it should be first converted via `tools/model_converters/detectron2_to_mmdet.py`
+
+For inference of released detectron2 checkpoints, users should first use `tools/model_converters/detectron2_to_mmdet.py` to convert Detectron2 checkpoint to MMDetection.
+
+```shell
+python tools/model_converters/detectron2_to_mmdet.py ${Detectron2 ckpt path} ${MMDetectron ckpt path}
+```
diff --git a/mmdetection/docs/en/advanced_guides/index.rst b/mmdetection/docs/en/advanced_guides/index.rst
new file mode 100644
index 00000000..20d81774
--- /dev/null
+++ b/mmdetection/docs/en/advanced_guides/index.rst
@@ -0,0 +1,34 @@
+Basic Concepts
+***************
+
+.. toctree::
+   :maxdepth: 1
+
+   data_flow.md
+   structures.md
+   models.md
+   datasets.md
+   transforms.md
+   evaluation.md
+   engine.md
+   conventions.md
+
+Component Customization
+************************
+
+.. toctree::
+   :maxdepth: 1
+
+   customize_models.md
+   customize_losses.md
+   customize_dataset.md
+   customize_transforms.md
+   customize_runtime.md
+
+How to
+************************
+
+.. toctree::
+   :maxdepth: 1
+
+   how_to.md
diff --git a/mmdetection/docs/en/advanced_guides/models.md b/mmdetection/docs/en/advanced_guides/models.md
new file mode 100644
index 00000000..91361720
--- /dev/null
+++ b/mmdetection/docs/en/advanced_guides/models.md
@@ -0,0 +1 @@
+# Models
diff --git a/mmdetection/docs/en/advanced_guides/structures.md b/mmdetection/docs/en/advanced_guides/structures.md
new file mode 100644
index 00000000..98528617
--- /dev/null
+++ b/mmdetection/docs/en/advanced_guides/structures.md
@@ -0,0 +1 @@
+# Structures
diff --git a/mmdetection/docs/en/advanced_guides/transforms.md b/mmdetection/docs/en/advanced_guides/transforms.md
new file mode 100644
index 00000000..4db036ae
--- /dev/null
+++ b/mmdetection/docs/en/advanced_guides/transforms.md
@@ -0,0 +1,42 @@
+# Data Transforms (Need to update)
+
+## Design of Data transforms pipeline
+
+Following typical conventions, we use `Dataset` and `DataLoader` for data loading
+with multiple workers. `Dataset` returns a dict of data items corresponding
+the arguments of models' forward method.
+
+The data transforms pipeline and the dataset is decomposed. Usually a dataset
+defines how to process the annotations and a data transforms pipeline defines all the steps to prepare a data dict.
+A pipeline consists of a sequence of data transforms. Each operation takes a dict as input and also output a dict for the next transform.
+
+We present a classical pipeline in the following figure. The blue blocks are pipeline operations. With the pipeline going on, each operator can add new keys (marked as green) to the result dict or update the existing keys (marked as orange).
+![pipeline figure](../../../resources/data_pipeline.png)
+
+Here is a pipeline example for Faster R-CNN.
+
+```python
+train_pipeline = [  # Training data processing pipeline
+    dict(type='LoadImageFromFile', backend_args=backend_args),  # First pipeline to load images from file path
+    dict(
+        type='LoadAnnotations',  # Second pipeline to load annotations for current image
+        with_bbox=True),  # Whether to use bounding box, True for detection
+    dict(
+        type='Resize',  # Pipeline that resize the images and their annotations
+        scale=(1333, 800),  # The largest scale of image
+        keep_ratio=True  # Whether to keep the ratio between height and width
+        ),
+    dict(
+        type='RandomFlip',  # Augmentation pipeline that flip the images and their annotations
+        prob=0.5),  # The probability to flip
+    dict(type='PackDetInputs')  # Pipeline that formats the annotation data and decides which keys in the data should be packed into data_samples
+]
+test_pipeline = [  # Testing data processing pipeline
+    dict(type='LoadImageFromFile', backend_args=backend_args),  # First pipeline to load images from file path
+    dict(type='Resize', scale=(1333, 800), keep_ratio=True),  # Pipeline that resize the images
+    dict(
+        type='PackDetInputs',  # Pipeline that formats the annotation data and decides which keys in the data should be packed into data_samples
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+```
diff --git a/mmdetection/docs/en/api.rst b/mmdetection/docs/en/api.rst
new file mode 100644
index 00000000..1b127321
--- /dev/null
+++ b/mmdetection/docs/en/api.rst
@@ -0,0 +1,161 @@
+mmdet.apis
+--------------
+.. automodule:: mmdet.apis
+    :members:
+
+mmdet.datasets
+--------------
+
+datasets
+^^^^^^^^^^
+.. automodule:: mmdet.datasets
+    :members:
+
+api_wrappers
+^^^^^^^^^^^^^^^^^
+.. automodule:: mmdet.datasets.api_wrappers
+    :members:
+
+samplers
+^^^^^^^^^^
+.. automodule:: mmdet.datasets.samplers
+    :members:
+
+transforms
+^^^^^^^^^^^^
+.. automodule:: mmdet.datasets.transforms
+    :members:
+
+mmdet.engine
+--------------
+
+hooks
+^^^^^^^^^^
+.. automodule:: mmdet.engine.hooks
+    :members:
+
+optimizers
+^^^^^^^^^^^^^^^
+.. automodule:: mmdet.engine.optimizers
+    :members:
+
+runner
+^^^^^^^^^^
+.. automodule:: mmdet.engine.runner
+    :members:
+
+schedulers
+^^^^^^^^^^^^^^^^^
+.. automodule:: mmdet.engine.schedulers
+    :members:
+
+mmdet.evaluation
+--------------------
+
+functional
+^^^^^^^^^^^^^^^^^
+.. automodule:: mmdet.evaluation.functional
+    :members:
+
+metrics
+^^^^^^^^^^
+.. automodule:: mmdet.evaluation.metrics
+    :members:
+
+
+mmdet.models
+--------------
+
+backbones
+^^^^^^^^^^^^^^^^^^
+.. automodule:: mmdet.models.backbones
+    :members:
+
+data_preprocessors
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+.. automodule:: mmdet.models.data_preprocessors
+    :members:
+
+dense_heads
+^^^^^^^^^^^^^^^
+.. automodule:: mmdet.models.dense_heads
+    :members:
+
+detectors
+^^^^^^^^^^
+.. automodule:: mmdet.models.detectors
+    :members:
+
+layers
+^^^^^^^^^^
+.. automodule:: mmdet.models.layers
+    :members:
+
+losses
+^^^^^^^^^^
+.. automodule:: mmdet.models.losses
+    :members:
+
+necks
+^^^^^^^^^^^^
+.. automodule:: mmdet.models.necks
+    :members:
+
+roi_heads
+^^^^^^^^^^^^^
+.. automodule:: mmdet.models.roi_heads
+    :members:
+
+seg_heads
+^^^^^^^^^^^^^
+.. automodule:: mmdet.models.seg_heads
+    :members:
+
+task_modules
+^^^^^^^^^^^^^
+.. automodule:: mmdet.models.task_modules
+    :members:
+
+test_time_augs
+^^^^^^^^^^^^^^^^^^^^
+.. automodule:: mmdet.models.test_time_augs
+    :members:
+
+utils
+^^^^^^^^^^
+.. automodule:: mmdet.models.utils
+    :members:
+
+
+mmdet.structures
+--------------------
+
+structures
+^^^^^^^^^^^^^^^^^
+.. automodule:: mmdet.structures
+    :members:
+
+bbox
+^^^^^^^^^^
+.. automodule:: mmdet.structures.bbox
+    :members:
+
+mask
+^^^^^^^^^^
+.. automodule:: mmdet.structures.mask
+    :members:
+
+mmdet.testing
+----------------
+.. automodule:: mmdet.testing
+    :members:
+
+mmdet.visualization
+--------------------
+.. automodule:: mmdet.visualization
+    :members:
+
+mmdet.utils
+--------------
+.. automodule:: mmdet.utils
+    :members:
diff --git a/mmdetection/docs/en/conf.py b/mmdetection/docs/en/conf.py
new file mode 100644
index 00000000..d2beaf1e
--- /dev/null
+++ b/mmdetection/docs/en/conf.py
@@ -0,0 +1,116 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/main/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+import os
+import subprocess
+import sys
+
+import pytorch_sphinx_theme
+
+sys.path.insert(0, os.path.abspath('../..'))
+
+# -- Project information -----------------------------------------------------
+
+project = 'MMDetection'
+copyright = '2018-2021, OpenMMLab'
+author = 'MMDetection Authors'
+version_file = '../../mmdet/version.py'
+
+
+def get_version():
+    with open(version_file, 'r') as f:
+        exec(compile(f.read(), version_file, 'exec'))
+    return locals()['__version__']
+
+
+# The full version, including alpha/beta/rc tags
+release = get_version()
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    'sphinx.ext.autodoc',
+    'sphinx.ext.napoleon',
+    'sphinx.ext.viewcode',
+    'myst_parser',
+    'sphinx_markdown_tables',
+    'sphinx_copybutton',
+]
+
+myst_enable_extensions = ['colon_fence']
+myst_heading_anchors = 3
+
+autodoc_mock_imports = [
+    'matplotlib', 'pycocotools', 'terminaltables', 'mmdet.version', 'mmcv.ops'
+]
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+#
+source_suffix = {
+    '.rst': 'restructuredtext',
+    '.md': 'markdown',
+}
+
+# The main toctree document.
+master_doc = 'index'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+# html_theme = 'sphinx_rtd_theme'
+html_theme = 'pytorch_sphinx_theme'
+html_theme_path = [pytorch_sphinx_theme.get_html_theme_path()]
+
+html_theme_options = {
+    'menu': [
+        {
+            'name': 'GitHub',
+            'url': 'https://github.com/open-mmlab/mmdetection'
+        },
+    ],
+    # Specify the language of shared menu
+    'menu_lang':
+    'en'
+}
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+html_css_files = ['css/readthedocs.css']
+
+# -- Extension configuration -------------------------------------------------
+# Ignore >>> when copying code
+copybutton_prompt_text = r'>>> |\.\.\. '
+copybutton_prompt_is_regexp = True
+
+
+def builder_inited_handler(app):
+    subprocess.run(['./stat.py'])
+
+
+def setup(app):
+    app.connect('builder-inited', builder_inited_handler)
diff --git a/mmdetection/docs/en/dataset_zoo.md b/mmdetection/docs/en/dataset_zoo.md
new file mode 100644
index 00000000..c35cc220
--- /dev/null
+++ b/mmdetection/docs/en/dataset_zoo.md
@@ -0,0 +1 @@
+# Dataset Zoo
diff --git a/mmdetection/docs/en/get_started.md b/mmdetection/docs/en/get_started.md
new file mode 100644
index 00000000..f65878b6
--- /dev/null
+++ b/mmdetection/docs/en/get_started.md
@@ -0,0 +1,297 @@
+# GET STARTED
+
+## Prerequisites
+
+In this section, we demonstrate how to prepare an environment with PyTorch.
+
+MMDetection works on Linux, Windows, and macOS. It requires Python 3.7+, CUDA 9.2+, and PyTorch 1.8+.
+
+```{note}
+If you are experienced with PyTorch and have already installed it, just skip this part and jump to the [next section](#installation). Otherwise, you can follow these steps for the preparation.
+```
+
+**Step 0.** Download and install Miniconda from the [official website](https://docs.conda.io/en/latest/miniconda.html).
+
+**Step 1.** Create a conda environment and activate it.
+
+```shell
+conda create --name openmmlab python=3.8 -y
+conda activate openmmlab
+```
+
+**Step 2.** Install PyTorch following [official instructions](https://pytorch.org/get-started/locally/), e.g.
+
+On GPU platforms:
+
+```shell
+conda install pytorch torchvision -c pytorch
+```
+
+On CPU platforms:
+
+```shell
+conda install pytorch torchvision cpuonly -c pytorch
+```
+
+## Installation
+
+We recommend that users follow our best practices to install MMDetection. However, the whole process is highly customizable. See [Customize Installation](#customize-installation) section for more information.
+
+### Best Practices
+
+**Step 0.** Install [MMEngine](https://github.com/open-mmlab/mmengine) and [MMCV](https://github.com/open-mmlab/mmcv) using [MIM](https://github.com/open-mmlab/mim).
+
+```shell
+pip install -U openmim
+mim install mmengine
+mim install "mmcv>=2.0.0"
+```
+
+**Note:** In MMCV-v2.x, `mmcv-full` is rename to `mmcv`, if you want to install `mmcv` without CUDA ops, you can use `mim install "mmcv-lite>=2.0.0rc1"` to install the lite version.
+
+**Step 1.** Install MMDetection.
+
+Case a: If you develop and run mmdet directly, install it from source:
+
+```shell
+git clone https://github.com/open-mmlab/mmdetection.git
+cd mmdetection
+pip install -v -e .
+# "-v" means verbose, or more output
+# "-e" means installing a project in editable mode,
+# thus any local modifications made to the code will take effect without reinstallation.
+```
+
+Case b: If you use mmdet as a dependency or third-party package, install it with MIM:
+
+```shell
+mim install mmdet
+```
+
+## Verify the installation
+
+To verify whether MMDetection is installed correctly, we provide some sample codes to run an inference demo.
+
+**Step 1.** We need to download config and checkpoint files.
+
+```shell
+mim download mmdet --config rtmdet_tiny_8xb32-300e_coco --dest .
+```
+
+The downloading will take several seconds or more, depending on your network environment. When it is done, you will find two files `rtmdet_tiny_8xb32-300e_coco.py` and `rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth` in your current folder.
+
+**Step 2.** Verify the inference demo.
+
+Case a: If you install MMDetection from source, just run the following command.
+
+```shell
+python demo/image_demo.py demo/demo.jpg rtmdet_tiny_8xb32-300e_coco.py --weights rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth --device cpu
+```
+
+You will see a new image `demo.jpg` on your `./outputs/vis` folder, where bounding boxes are plotted on cars, benches, etc.
+
+Case b: If you install MMDetection with MIM, open your python interpreter and copy&paste the following codes.
+
+```python
+from mmdet.apis import init_detector, inference_detector
+
+config_file = 'rtmdet_tiny_8xb32-300e_coco.py'
+checkpoint_file = 'rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth'
+model = init_detector(config_file, checkpoint_file, device='cpu')  # or device='cuda:0'
+inference_detector(model, 'demo/demo.jpg')
+```
+
+You will see a list of `DetDataSample`, and the predictions are in the `pred_instance`, indicating the detected bounding boxes, labels, and scores.
+
+## Tracking Installation
+
+We recommend that users follow our best practices to install MMDetection for tracking task.
+
+### Best Practices
+
+**Step 0.** Install [MMEngine](https://github.com/open-mmlab/mmengine) and [MMCV](https://github.com/open-mmlab/mmcv) using [MIM](https://github.com/open-mmlab/mim).
+
+```shell
+pip install -U openmim
+mim install mmengine
+mim install "mmcv>=2.0.0"
+```
+
+**Step 1.** Install MMDetection.
+
+Case a: If you develop and run mmdet directly, install it from source:
+
+```shell
+git clone https://github.com/open-mmlab/mmdetection.git
+cd mmdetection
+pip install -v -e . -r requirements/tracking.txt
+# "-v" means verbose, or more output
+# "-e" means installing a project in editable mode,
+# thus any local modifications made to the code will take effect without reinstallation.
+```
+
+Case b: If you use mmdet as a dependency or third-party package, install it with MIM:
+
+```shell
+mim install mmdet[tracking]
+```
+
+**Step 2.** Install TrackEval.
+
+```shell
+pip install git+https://github.com/JonathonLuiten/TrackEval.git
+```
+
+## Verify the installation
+
+To verify whether MMDetection is installed correctly, we provide some sample codes to run an inference demo.
+
+**Step 1.** We need to download config and checkpoint files.
+
+```shell
+mim download mmdet --config bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval --dest .
+```
+
+The downloading will take several seconds or more, depending on your network environment. When it is done, you will find two files `bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval.py` and `bytetrack_yolox_x_crowdhuman_mot17-private-half_20211218_205500-1985c9f0.pth` in your current folder.
+
+**Step 2.** Verify the inference demo.
+
+Case a: If you install MMDetection from source, just run the following command.
+
+```shell
+python demo/mot_demo.py demo/demo_mot.mp4 bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval.py --checkpoint bytetrack_yolox_x_crowdhuman_mot17-private-half_20211218_205500-1985c9f0.pth --out mot.mp4
+```
+
+You will see a new video `mot.mp4` on your folder, where bounding boxes are plotted on person.
+
+Case b: If you install MMDetection with MIM, open your python interpreter and demo/mot_demo.py, then run it like Case a.
+
+### Customize Installation
+
+#### CUDA versions
+
+When installing PyTorch, you need to specify the version of CUDA. If you are not clear on which to choose, follow our recommendations:
+
+- For Ampere-based NVIDIA GPUs, such as GeForce 30 series and NVIDIA A100, CUDA 11 is a must.
+- For older NVIDIA GPUs, CUDA 11 is backward compatible, but CUDA 10.2 offers better compatibility and is more lightweight.
+
+Please make sure the GPU driver satisfies the minimum version requirements. See [this table](https://docs.nvidia.com/cuda/cuda-toolkit-release-notes/index.html#cuda-major-component-versions__table-cuda-toolkit-driver-versions) for more information.
+
+```{note}
+Installing CUDA runtime libraries is enough if you follow our best practices, because no CUDA code will be compiled locally. However, if you hope to compile MMCV from source or develop other CUDA operators, you need to install the complete CUDA toolkit from NVIDIA's [website](https://developer.nvidia.com/cuda-downloads), and its version should match the CUDA version of PyTorch. i.e., the specified version of cudatoolkit in the `conda install` command.
+```
+
+#### Install MMEngine without MIM
+
+To install MMEngine with pip instead of MIM, please follow [MMEngine installation guides](https://mmengine.readthedocs.io/en/latest/get_started/installation.html).
+
+For example, you can install MMEngine by the following command.
+
+```shell
+pip install mmengine
+```
+
+#### Install MMCV without MIM
+
+MMCV contains C++ and CUDA extensions, thus depending on PyTorch in a complex way. MIM solves such dependencies automatically and makes the installation easier. However, it is not a must.
+
+To install MMCV with pip instead of MIM, please follow [MMCV installation guides](https://mmcv.readthedocs.io/en/2.x/get_started/installation.html). This requires manually specifying a find-url based on the PyTorch version and its CUDA version.
+
+For example, the following command installs MMCV built for PyTorch 1.12.x and CUDA 11.6.
+
+```shell
+pip install "mmcv>=2.0.0" -f https://download.openmmlab.com/mmcv/dist/cu116/torch1.12.0/index.html
+```
+
+#### Install on CPU-only platforms
+
+MMDetection can be built for CPU-only environments. In CPU mode you can train (requires MMCV version >= 2.0.0rc1), test, or infer a model.
+
+However, some functionalities are gone in this mode:
+
+- Deformable Convolution
+- Modulated Deformable Convolution
+- ROI pooling
+- Deformable ROI pooling
+- CARAFE
+- SyncBatchNorm
+- CrissCrossAttention
+- MaskedConv2d
+- Temporal Interlace Shift
+- nms_cuda
+- sigmoid_focal_loss_cuda
+- bbox_overlaps
+
+If you try to train/test/infer a model containing the above ops, an error will be raised.
+The following table lists affected algorithms.
+
+|                        Operator                         |                                          Model                                           |
+| :-----------------------------------------------------: | :--------------------------------------------------------------------------------------: |
+| Deformable Convolution/Modulated Deformable Convolution | DCN, Guided Anchoring, RepPoints, CentripetalNet, VFNet, CascadeRPN, NAS-FCOS, DetectoRS |
+|                      MaskedConv2d                       |                                     Guided Anchoring                                     |
+|                         CARAFE                          |                                          CARAFE                                          |
+|                      SyncBatchNorm                      |                                         ResNeSt                                          |
+
+#### Install on Google Colab
+
+[Google Colab](https://colab.research.google.com/) usually has PyTorch installed,
+thus we only need to install MMEngine, MMCV, and MMDetection with the following commands.
+
+**Step 1.** Install [MMEngine](https://github.com/open-mmlab/mmengine) and [MMCV](https://github.com/open-mmlab/mmcv) using [MIM](https://github.com/open-mmlab/mim).
+
+```shell
+!pip3 install openmim
+!mim install mmengine
+!mim install "mmcv>=2.0.0,<2.1.0"
+```
+
+**Step 2.** Install MMDetection from the source.
+
+```shell
+!git clone https://github.com/open-mmlab/mmdetection.git
+%cd mmdetection
+!pip install -e .
+```
+
+**Step 3.** Verification.
+
+```python
+import mmdet
+print(mmdet.__version__)
+# Example output: 3.0.0, or an another version.
+```
+
+```{note}
+Within Jupyter, the exclamation mark `!` is used to call external executables and `%cd` is a [magic command](https://ipython.readthedocs.io/en/stable/interactive/magics.html#magic-cd) to change the current working directory of Python.
+```
+
+#### Use MMDetection with Docker
+
+We provide a [Dockerfile](../../docker/Dockerfile) to build an image. Ensure that your [docker version](https://docs.docker.com/engine/install/) >=19.03.
+
+```shell
+# build an image with PyTorch 1.9, CUDA 11.1
+# If you prefer other versions, just modified the Dockerfile
+docker build -t mmdetection docker/
+```
+
+Run it with
+
+```shell
+docker run --gpus all --shm-size=8g -it -v {DATA_DIR}:/mmdetection/data mmdetection
+```
+
+### Troubleshooting
+
+If you have some issues during the installation, please first view the [FAQ](notes/faq.md) page.
+You may [open an issue](https://github.com/open-mmlab/mmdetection/issues/new/choose) on GitHub if no solution is found.
+
+### Use Multiple Versions of MMDetection in Development
+
+Training and testing scripts have already been modified in `PYTHONPATH` in order to make sure the scripts are using their own versions of MMDetection.
+
+To install the default version of MMDetection in your environment, you can exclude the follow code in the relative scripts:
+
+```shell
+PYTHONPATH="$(dirname $0)/..":$PYTHONPATH
+```
diff --git a/mmdetection/docs/en/index.rst b/mmdetection/docs/en/index.rst
new file mode 100644
index 00000000..32c5952a
--- /dev/null
+++ b/mmdetection/docs/en/index.rst
@@ -0,0 +1,63 @@
+Welcome to MMDetection's documentation!
+=======================================
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Get Started
+
+   overview.md
+   get_started.md
+
+.. toctree::
+   :maxdepth: 2
+   :caption: User Guides
+
+   user_guides/index.rst
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Advanced Guides
+
+   advanced_guides/index.rst
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Migration
+
+   migration/migration.md
+
+.. toctree::
+   :maxdepth: 1
+   :caption: API Reference
+
+   api.rst
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Model Zoo
+
+   model_zoo.md
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Notes
+
+   notes/contribution_guide.md
+   notes/projects.md
+   notes/changelog.md
+   notes/changelog_v2.x.md
+   notes/faq.md
+   notes/compatibility.md
+
+.. toctree::
+   :caption: Switch Language
+
+   switch_language.md
+
+
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`search`
diff --git a/mmdetection/docs/en/make.bat b/mmdetection/docs/en/make.bat
new file mode 100644
index 00000000..922152e9
--- /dev/null
+++ b/mmdetection/docs/en/make.bat
@@ -0,0 +1,35 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=.
+set BUILDDIR=_build
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.http://sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd
diff --git a/mmdetection/docs/en/migration.md b/mmdetection/docs/en/migration.md
new file mode 100644
index 00000000..689e8d24
--- /dev/null
+++ b/mmdetection/docs/en/migration.md
@@ -0,0 +1 @@
+# Migration
diff --git a/mmdetection/docs/en/migration/api_and_registry_migration.md b/mmdetection/docs/en/migration/api_and_registry_migration.md
new file mode 100644
index 00000000..72bfd3ae
--- /dev/null
+++ b/mmdetection/docs/en/migration/api_and_registry_migration.md
@@ -0,0 +1 @@
+# Migrate API and Registry from MMDetection 2.x to 3.x
diff --git a/mmdetection/docs/en/migration/config_migration.md b/mmdetection/docs/en/migration/config_migration.md
new file mode 100644
index 00000000..1177fa9f
--- /dev/null
+++ b/mmdetection/docs/en/migration/config_migration.md
@@ -0,0 +1,819 @@
+# Migrate Configuration File from MMDetection 2.x to 3.x
+
+The configuration file of MMDetection 3.x has undergone significant changes in comparison to the 2.x version. This document explains how to migrate 2.x configuration files to 3.x.
+
+In the previous tutorial [Learn about Configs](../user_guides/config.md), we used Mask R-CNN as an example to introduce the configuration file structure of MMDetection 3.x. Here, we will follow the same structure to demonstrate how to migrate 2.x configuration files to 3.x.
+
+## Model Configuration
+
+There have been no major changes to the model configuration in 3.x compared to 2.x. For the model's backbone, neck, head, as well as train_cfg and test_cfg, the parameters remain the same as in version 2.x.
+
+On the other hand, we have added the `DataPreprocessor` module in MMDetection 3.x. The configuration for the `DataPreprocessor` module is located in `model.data_preprocessor`. It is used to preprocess the input data, such as normalizing input images and padding images of different sizes into batches, and loading images from memory to VRAM. This configuration replaces the `Normalize` and `Pad` modules in `train_pipeline` and `test_pipeline` of the earlier version.
+
+
+
+
+
+
+
+
+
+
    2.x Config
+
+```python
+# Image normalization parameters
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    to_rgb=True)
+pipeline=[
+    ...,
+    dict(type='Normalize', **img_norm_cfg),
+    dict(type='Pad', size_divisor=32),  # Padding the image to multiples of 32
+    ...
+]
+```
+
+
    3.x Config
+
+```python
+model = dict(
+    data_preprocessor=dict(
+        type='DetDataPreprocessor',
+        # Image normalization parameters
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        bgr_to_rgb=True,
+        # Image padding parameters
+        pad_mask=True,  # In instance segmentation, the mask needs to be padded
+        pad_size_divisor=32)  # Padding the image to multiples of 32
+)
+
+```
+
+
    
+
+## Dataset and Evaluator Configuration
+
+The dataset and evaluator configurations have undergone major changes compared to version 2.x. We will introduce how to migrate from version 2.x to version 3.x from three aspects: Dataloader and Dataset, Data transform pipeline, and Evaluator configuration.
+
+### Dataloader and Dataset Configuration
+
+In the new version, we set the data loading settings consistent with PyTorch's official DataLoader,
+making it easier for users to understand and get started with.
+We put the data loading settings for training, validation, and testing separately in `train_dataloader`, `val_dataloader`, and `test_dataloader`.
+Users can set different parameters for these dataloaders.
+The input parameters are basically the same as those required by [PyTorch DataLoader](https://pytorch.org/docs/stable/data.html?highlight=dataloader#torch.utils.data.DataLoader).
+
+This way, we put the unconfigurable parameters in version 2.x, such as `sampler`, `batch_sampler`, and `persistent_workers`, in the configuration file, so that users can set dataloader parameters more flexibly.
+
+Users can set the dataset configuration through `train_dataloader.dataset`, `val_dataloader.dataset`, and `test_dataloader.dataset`, which correspond to `data.train`, `data.val`, and `data.test` in version 2.x.
+
+
+
+
+
+
+
+
+
+
    2.x Config
+
+```python
+data = dict(
+    samples_per_gpu=2,
+    workers_per_gpu=2,
+    train=dict(
+        type=dataset_type,
+        ann_file=data_root + 'annotations/instances_train2017.json',
+        img_prefix=data_root + 'train2017/',
+        pipeline=train_pipeline),
+    val=dict(
+        type=dataset_type,
+        ann_file=data_root + 'annotations/instances_val2017.json',
+        img_prefix=data_root + 'val2017/',
+        pipeline=test_pipeline),
+    test=dict(
+        type=dataset_type,
+        ann_file=data_root + 'annotations/instances_val2017.json',
+        img_prefix=data_root + 'val2017/',
+        pipeline=test_pipeline))
+```
+
+
    3.x Config
+
+```python
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=2,
+    persistent_workers=True,  # Avoid recreating subprocesses after each iteration
+    sampler=dict(type='DefaultSampler', shuffle=True),  # Default sampler, supports both distributed and non-distributed training
+    batch_sampler=dict(type='AspectRatioBatchSampler'),  # Default batch_sampler, used to ensure that images in the batch have similar aspect ratios, so as to better utilize graphics memory
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='annotations/instances_train2017.json',
+        data_prefix=dict(img='train2017/'),
+        filter_cfg=dict(filter_empty_gt=True, min_size=32),
+        pipeline=train_pipeline))
+# In version 3.x, validation and test dataloaders can be configured independently
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='annotations/instances_val2017.json',
+        data_prefix=dict(img='val2017/'),
+        test_mode=True,
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader  # The configuration of the testing dataloader is the same as that of the validation dataloader, which is omitted here
+
+```
+
+
    
+
+### Data Transform Pipeline Configuration
+
+As mentioned earlier, we have separated the normalization and padding configurations for images from the `train_pipeline` and `test_pipeline`, and have placed them in `model.data_preprocessor` instead. Hence, in the 3.x version of the pipeline, we no longer require the `Normalize` and `Pad` transforms.
+
+At the same time, we have also refactored the transform responsible for packing the data format, and have merged the `Collect` and `DefaultFormatBundle` transforms into `PackDetInputs`. This transform is responsible for packing the data from the data pipeline into the input format of the model. For more details on the input format conversion, please refer to the [data flow documentation](../advanced_guides/data_flow.md).
+
+Below, we will use the `train_pipeline` of Mask R-CNN as an example, to demonstrate how to migrate from the 2.x configuration to the 3.x configuration:
+
+
+
+
+
+
+
+
+
+
    2.x Config
+
+```python
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(type='Resize', img_scale=(1333, 800), keep_ratio=True),
+    dict(type='RandomFlip', flip_ratio=0.5),
+    dict(type='Normalize', **img_norm_cfg),
+    dict(type='Pad', size_divisor=32),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']),
+]
+```
+
+
    3.x Config
+
+```python
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(type='Resize', scale=(1333, 800), keep_ratio=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs')
+]
+```
+
+
    
+
+For the `test_pipeline`, apart from removing the `Normalize` and `Pad` transforms, we have also separated the data augmentation for testing (TTA) from the normal testing process, and have removed `MultiScaleFlipAug`. For more information on how to use the new TTA version, please refer to the [TTA documentation](../advanced_guides/tta.md).
+
+Below, we will again use the `test_pipeline` of Mask R-CNN as an example, to demonstrate how to migrate from the 2.x configuration to the 3.x configuration:
+
+
+
+
+
+
+
+
+
+
    2.x Config
+
+```python
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(1333, 800),
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(type='Normalize', **img_norm_cfg),
+            dict(type='Pad', size_divisor=32),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img']),
+        ])
+]
+```
+
+
    3.x Config
+
+```python
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(1333, 800), keep_ratio=True),
+    dict(
+        type='PackDetInputs',
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+```
+
+
    
+
+In addition, we have also refactored some data augmentation transforms. The following table lists the mapping between the transforms used in the 2.x version and the 3.x version:
+
+
+
+  
+    
+    
+    
+  
+
+
+  
+    
+
+
+
+  
+  
+    
+
+
+  
+  
+    
+
+
+  
+
+
+    
+
+
+  
+
+
+
    Name2.x Config3.x Config
    Resize
+
+```python
+dict(type='Resize',
+     img_scale=(1333, 800),
+     keep_ratio=True)
+```
+
+
+
+```python
+dict(type='Resize',
+     scale=(1333, 800),
+     keep_ratio=True)
+```
+
+
    RandomResize
+
+```python
+dict(
+    type='Resize',
+    img_scale=[
+        (1333, 640), (1333, 800)],
+    multiscale_mode='range',
+    keep_ratio=True)
+```
+
+
+
+```python
+dict(
+    type='RandomResize',
+    scale=[
+        (1333, 640), (1333, 800)],
+    keep_ratio=True)
+```
+
+
    RandomChoiceResize
+
+```python
+dict(
+    type='Resize',
+    img_scale=[
+        (1333, 640), (1333, 672),
+        (1333, 704), (1333, 736),
+        (1333, 768), (1333, 800)],
+    multiscale_mode='value',
+    keep_ratio=True)
+```
+
+
+
+```python
+dict(
+    type='RandomChoiceResize',
+    scales=[
+        (1333, 640), (1333, 672),
+        (1333, 704), (1333, 736),
+        (1333, 768), (1333, 800)],
+    keep_ratio=True)
+```
+
+
    RandomFlip
+
+```python
+dict(type='RandomFlip', flip_ratio=0.5)
+```
+
+
+
+```python
+dict(type='RandomFlip', prob=0.5)
+```
+
+
    
+
+### 评测器配置
+
+In version 3.x, model accuracy evaluation is no longer tied to the dataset, but is instead accomplished through the use of an Evaluator.
+The Evaluator configuration is divided into two parts: `val_evaluator` and `test_evaluator`. The `val_evaluator` is used for validation dataset evaluation, while the `test_evaluator` is used for testing dataset evaluation.
+This corresponds to the `evaluation` field in version 2.x.
+
+The following table shows the corresponding relationship between Evaluators in version 2.x and 3.x.
+
+
+
+  
+    
+    
+    
+  
+
+
+  
+    
+
+
+
+  
+  
+    
+
+
+  
+  
+    
+
+
+  
+
+
+    
+
+
+  
+
+
+
    Metric Name2.x Config3.x Config
    COCO
+
+```python
+data = dict(
+    val=dict(
+        type='CocoDataset',
+        ann_file=data_root + 'annotations/instances_val2017.json'))
+evaluation = dict(metric=['bbox', 'segm'])
+```
+
+
+
+```python
+val_evaluator = dict(
+    type='CocoMetric',
+    ann_file=data_root + 'annotations/instances_val2017.json',
+    metric=['bbox', 'segm'],
+    format_only=False)
+```
+
+
    Pascal VOC
+
+```python
+data = dict(
+    val=dict(
+        type=dataset_type,
+        ann_file=data_root + 'VOC2007/ImageSets/Main/test.txt'))
+evaluation = dict(metric='mAP')
+```
+
+
+
+```python
+val_evaluator = dict(
+    type='VOCMetric',
+    metric='mAP',
+    eval_mode='11points')
+```
+
+
    OpenImages
+
+```python
+data = dict(
+    val=dict(
+        type='OpenImagesDataset',
+        ann_file=data_root + 'annotations/validation-annotations-bbox.csv',
+        img_prefix=data_root + 'OpenImages/validation/',
+        label_file=data_root + 'annotations/class-descriptions-boxable.csv',
+        hierarchy_file=data_root +
+        'annotations/bbox_labels_600_hierarchy.json',
+        meta_file=data_root + 'annotations/validation-image-metas.pkl',
+        image_level_ann_file=data_root +
+        'annotations/validation-annotations-human-imagelabels-boxable.csv'))
+evaluation = dict(interval=1, metric='mAP')
+```
+
+
+
+```python
+val_evaluator = dict(
+    type='OpenImagesMetric',
+    iou_thrs=0.5,
+    ioa_thrs=0.5,
+    use_group_of=True,
+    get_supercategory=True)
+```
+
+
    CityScapes
+
+```python
+data = dict(
+    val=dict(
+        type='CityScapesDataset',
+        ann_file=data_root +
+        'annotations/instancesonly_filtered_gtFine_val.json',
+        img_prefix=data_root + 'leftImg8bit/val/',
+        pipeline=test_pipeline))
+evaluation = dict(metric=['bbox', 'segm'])
+```
+
+
+
+```python
+val_evaluator = [
+    dict(
+        type='CocoMetric',
+        ann_file=data_root +
+        'annotations/instancesonly_filtered_gtFine_val.json',
+        metric=['bbox', 'segm']),
+    dict(
+        type='CityScapesMetric',
+        ann_file=data_root +
+        'annotations/instancesonly_filtered_gtFine_val.json',
+        seg_prefix=data_root + '/gtFine/val',
+        outfile_prefix='./work_dirs/cityscapes_metric/instance')
+]
+```
+
+
    
+
+## Configuration for Training and Testing
+
+
+
+
+
+
+
+
+
+
    2.x Config
+
+```python
+runner = dict(
+    type='EpochBasedRunner',  # Type of training loop
+    max_epochs=12)  # Maximum number of training epochs
+evaluation = dict(interval=2)  # Interval for evaluation, check the performance every 2 epochs
+```
+
+
    3.x Config
+
+```python
+train_cfg = dict(
+    type='EpochBasedTrainLoop',  # Type of training loop, please refer to https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py
+    max_epochs=12,  # Maximum number of training epochs
+    val_interval=2)  # Interval for validation, check the performance every 2 epochs
+val_cfg = dict(type='ValLoop')  # Type of validation loop
+test_cfg = dict(type='TestLoop')  # Type of testing loop
+```
+
+
    
+
+## Optimization Configuration
+
+The configuration for optimizer and gradient clipping is moved to the `optim_wrapper` field.
+The following table shows the correspondences for optimizer configuration between 2.x version and 3.x version:
+
+
+
+
+
+
+
+
+
+
    2.x Config
+
+```python
+optimizer = dict(
+    type='SGD',  # Optimizer: Stochastic Gradient Descent
+    lr=0.02,  # Base learning rate
+    momentum=0.9,  # SGD with momentum
+    weight_decay=0.0001)  # Weight decay
+optimizer_config = dict(grad_clip=None)  # Configuration for gradient clipping, set to None to disable
+```
+
+
    3.x Config
+
+```python
+optim_wrapper = dict(  # Configuration for the optimizer wrapper
+    type='OptimWrapper',  # Type of optimizer wrapper, you can switch to AmpOptimWrapper to enable mixed precision training
+    optimizer=dict(  # Optimizer configuration, supports various PyTorch optimizers, please refer to https://pytorch.org/docs/stable/optim.html#algorithms
+        type='SGD',  # SGD
+        lr=0.02,  # Base learning rate
+        momentum=0.9,  # SGD with momentum
+        weight_decay=0.0001),  # Weight decay
+    clip_grad=None,  # Configuration for gradient clipping, set to None to disable. For usage, please see https://mmengine.readthedocs.io/en/latest/tutorials/optimizer.html
+    )
+```
+
+
    
+
+The configuration for learning rate is also moved from the `lr_config` field to the `param_scheduler` field. The `param_scheduler` configuration is more similar to PyTorch's learning rate scheduler and more flexible. The following table shows the correspondences for learning rate configuration between 2.x version and 3.x version:
+
+
+
+
+
+
+
+
+
+
    2.x Config
+
+```python
+lr_config = dict(
+    policy='step',  # Use multi-step learning rate strategy during training
+    warmup='linear',  # Use linear learning rate warmup
+    warmup_iters=500,  # End warmup at iteration 500
+    warmup_ratio=0.001,  # Coefficient for learning rate warmup
+    step=[8, 11],  # Learning rate decay at which epochs
+    gamma=0.1)  # Learning rate decay coefficient
+
+```
+
+
    3.x Config
+
+```python
+param_scheduler = [
+    dict(
+        type='LinearLR',  # Use linear learning rate warmup
+        start_factor=0.001, # Coefficient for learning rate warmup
+        by_epoch=False,  # Update the learning rate during warmup at each iteration
+        begin=0,  # Starting from the first iteration
+        end=500),  # End at the 500th iteration
+    dict(
+        type='MultiStepLR',  # Use multi-step learning rate strategy during training
+        by_epoch=True,  # Update the learning rate at each epoch
+        begin=0,   # Starting from the first epoch
+        end=12,  # Ending at the 12th epoch
+        milestones=[8, 11],  # Learning rate decay at which epochs
+        gamma=0.1)  # Learning rate decay coefficient
+]
+
+```
+
+
    
+
+For information on how to migrate other learning rate adjustment policies, please refer to the [learning rate migration document of MMEngine](https://mmengine.readthedocs.io/zh_CN/latest/migration/param_scheduler.html).
+
+## Migration of Other Configurations
+
+### Configuration for Saving Checkpoints
+
+
+
+  
+    
+    
+    
+  
+
+
+  
+    
+
+
+
+  
+
+
+    
+
+
+  
+
+
+    
+
+
+  
+
+
+
    Function2.x Config3.x Config
    Set Save Interval
+
+```python
+checkpoint_config = dict(
+    interval=1)
+```
+
+
+
+```python
+default_hooks = dict(
+    checkpoint=dict(
+        type='CheckpointHook',
+        interval=1))
+```
+
+
    Save Best Model
+
+```python
+evaluation = dict(
+    save_best='auto')
+```
+
+
+
+```python
+default_hooks = dict(
+    checkpoint=dict(
+        type='CheckpointHook',
+        save_best='auto'))
+```
+
+
    Keep Latest Model
+
+```python
+checkpoint_config = dict(
+    max_keep_ckpts=3)
+```
+
+
+
+```python
+default_hooks = dict(
+    checkpoint=dict(
+        type='CheckpointHook',
+        max_keep_ckpts=3))
+```
+
+
    
+
+### Logging Configuration
+
+In MMDetection 3.x, the logging and visualization of the log are carried out respectively by the logger and visualizer in MMEngine. The following table shows the comparison between the configuration of printing logs and visualizing logs in MMDetection 2.x and 3.x.
+
+
+
+  
+    
+    
+    
+  
+
+
+  
+    
+
+
+
+  
+
+
+    
+
+
+  
+
+
+
    Function2.x Config3.x Config
    Set Log Printing Interval
+
+```python
+log_config = dict(interval=50)
+```
+
+
+
+```python
+default_hooks = dict(
+    logger=dict(type='LoggerHook', interval=50))
+# Optional: set moving average window size
+log_processor = dict(
+    type='LogProcessor', window_size=50)
+```
+
+
    Use TensorBoard or WandB to visualize logs
+
+```python
+log_config = dict(
+    interval=50,
+    hooks=[
+        dict(type='TextLoggerHook'),
+        dict(type='TensorboardLoggerHook'),
+        dict(type='MMDetWandbHook',
+             init_kwargs={
+                'project': 'mmdetection',
+                'group': 'maskrcnn-r50-fpn-1x-coco'
+             },
+             interval=50,
+             log_checkpoint=True,
+             log_checkpoint_metadata=True,
+             num_eval_images=100)
+    ])
+```
+
+
+
+```python
+vis_backends = [
+    dict(type='LocalVisBackend'),
+    dict(type='TensorboardVisBackend'),
+    dict(type='WandbVisBackend',
+         init_kwargs={
+            'project': 'mmdetection',
+            'group': 'maskrcnn-r50-fpn-1x-coco'
+         })
+]
+visualizer = dict(
+    type='DetLocalVisualizer',
+    vis_backends=vis_backends,
+    name='visualizer')
+```
+
+
    
+
+For visualization-related tutorials, please refer to [Visualization Tutorial](../user_guides/visualization.md) of MMDetection.
+
+### Runtime Configuration
+
+The runtime configuration fields in version 3.x have been adjusted, and the specific correspondence is as follows:
+
+
+
+  
+    
+    
+  
+
+
+
+
+
+
+  
+
+
+
    2.x Config3.x Config
    
+
+```python
+cudnn_benchmark = False
+opencv_num_threads = 0
+mp_start_method = 'fork'
+dist_params = dict(backend='nccl')
+log_level = 'INFO'
+load_from = None
+resume_from = None
+
+
+```
+
+
+
+```python
+env_cfg = dict(
+    cudnn_benchmark=False,
+    mp_cfg=dict(mp_start_method='fork',
+                opencv_num_threads=0),
+    dist_cfg=dict(backend='nccl'))
+log_level = 'INFO'
+load_from = None
+resume = False
+```
+
+
    
diff --git a/mmdetection/docs/en/migration/dataset_migration.md b/mmdetection/docs/en/migration/dataset_migration.md
new file mode 100644
index 00000000..75d09329
--- /dev/null
+++ b/mmdetection/docs/en/migration/dataset_migration.md
@@ -0,0 +1 @@
+# Migrate dataset from MMDetection 2.x to 3.x
diff --git a/mmdetection/docs/en/migration/migration.md b/mmdetection/docs/en/migration/migration.md
new file mode 100644
index 00000000..ec6a2f89
--- /dev/null
+++ b/mmdetection/docs/en/migration/migration.md
@@ -0,0 +1,12 @@
+# Migrating from MMDetection 2.x to 3.x
+
+MMDetection 3.x is a significant update that includes many changes to API and configuration files. This document aims to help users migrate from MMDetection 2.x to 3.x.
+We divided the migration guide into the following sections:
+
+- [Configuration file migration](./config_migration.md)
+- [API and Registry migration](./api_and_registry_migration.md)
+- [Dataset migration](./dataset_migration.md)
+- [Model migration](./model_migration.md)
+- [Frequently Asked Questions](./migration_faq.md)
+
+If you encounter any problems during the migration process, feel free to raise an issue. We also welcome contributions to this document.
diff --git a/mmdetection/docs/en/migration/migration_faq.md b/mmdetection/docs/en/migration/migration_faq.md
new file mode 100644
index 00000000..a6e3c356
--- /dev/null
+++ b/mmdetection/docs/en/migration/migration_faq.md
@@ -0,0 +1 @@
+# Migration FAQ
diff --git a/mmdetection/docs/en/migration/model_migration.md b/mmdetection/docs/en/migration/model_migration.md
new file mode 100644
index 00000000..04e28087
--- /dev/null
+++ b/mmdetection/docs/en/migration/model_migration.md
@@ -0,0 +1 @@
+# Migrate models from MMDetection 2.x to 3.x
diff --git a/mmdetection/docs/en/model_zoo.md b/mmdetection/docs/en/model_zoo.md
new file mode 100644
index 00000000..15dd7b2f
--- /dev/null
+++ b/mmdetection/docs/en/model_zoo.md
@@ -0,0 +1,358 @@
+# Benchmark and Model Zoo
+
+## Mirror sites
+
+We only use aliyun to maintain the model zoo since MMDetection V2.0. The model zoo of V1.x has been deprecated.
+
+## Common settings
+
+- All models were trained on `coco_2017_train`, and tested on the `coco_2017_val`.
+- We use distributed training.
+- All pytorch-style pretrained backbones on ImageNet are from PyTorch model zoo, caffe-style pretrained backbones are converted from the newly released model from detectron2.
+- For fair comparison with other codebases, we report the GPU memory as the maximum value of `torch.cuda.max_memory_allocated()` for all 8 GPUs. Note that this value is usually less than what `nvidia-smi` shows.
+- We report the inference time as the total time of network forwarding and post-processing, excluding the data loading time. Results are obtained with the script [benchmark.py](https://github.com/open-mmlab/mmdetection/blob/main/tools/analysis_tools/benchmark.py) which computes the average time on 2000 images.
+
+## ImageNet Pretrained Models
+
+It is common to initialize from backbone models pre-trained on ImageNet classification task. All pre-trained  model links can be found at [open_mmlab](https://github.com/open-mmlab/mmcv/blob/master/mmcv/model_zoo/open_mmlab.json).  According to `img_norm_cfg` and source of weight, we can divide all the ImageNet  pre-trained  model weights into some cases:
+
+- TorchVision:  Corresponding to torchvision weight, including ResNet50, ResNet101. The `img_norm_cfg` is `dict(mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)`.
+- Pycls:  Corresponding to [pycls](https://github.com/facebookresearch/pycls) weight, including RegNetX. The `img_norm_cfg` is `dict(   mean=[103.530, 116.280, 123.675], std=[57.375, 57.12, 58.395], to_rgb=False)`.
+- MSRA styles: Corresponding to [MSRA](https://github.com/KaimingHe/deep-residual-networks) weights, including ResNet50_Caffe and ResNet101_Caffe. The `img_norm_cfg` is `dict(   mean=[103.530, 116.280, 123.675], std=[1.0, 1.0, 1.0], to_rgb=False)`.
+- Caffe2 styles:  Currently only contains ResNext101_32x8d. The `img_norm_cfg` is `dict(mean=[103.530, 116.280, 123.675], std=[57.375, 57.120, 58.395], to_rgb=False)`.
+- Other styles: E.g SSD which corresponds to `img_norm_cfg` is `dict(mean=[123.675, 116.28, 103.53], std=[1, 1, 1], to_rgb=True)` and YOLOv3 which corresponds to `img_norm_cfg` is `dict(mean=[0, 0, 0], std=[255., 255., 255.], to_rgb=True)`.
+
+The detailed table of the commonly used backbone models in MMDetection is listed below :
+
+| model            | source      | link                                                                                                                                                                                                   | description                                                                                                                                                                                                                                      |
+| ---------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ResNet50         | TorchVision | [torchvision's ResNet-50](https://download.pytorch.org/models/resnet50-19c8e357.pth)                                                                                                                   | From [torchvision's ResNet-50](https://download.pytorch.org/models/resnet50-19c8e357.pth).                                                                                                                                                       |
+| ResNet101        | TorchVision | [torchvision's ResNet-101](https://download.pytorch.org/models/resnet101-5d3b4d8f.pth)                                                                                                                 | From [torchvision's ResNet-101](https://download.pytorch.org/models/resnet101-5d3b4d8f.pth).                                                                                                                                                     |
+| RegNetX          | Pycls       | [RegNetX_3.2gf](https://download.openmmlab.com/pretrain/third_party/regnetx_3.2gf-c2599b0f.pth), [RegNetX_800mf](https://download.openmmlab.com/pretrain/third_party/regnetx_800mf-1f4be4c7.pth). etc. | From [pycls](https://github.com/facebookresearch/pycls).                                                                                                                                                                                         |
+| ResNet50_Caffe   | MSRA        | [MSRA's ResNet-50](https://download.openmmlab.com/pretrain/third_party/resnet50_caffe-788b5fa3.pth)                                                                                                    | Converted copy of [Detectron2's R-50.pkl](https://dl.fbaipublicfiles.com/detectron2/ImageNetPretrained/MSRA/R-50.pkl) model. The original weight comes from [MSRA's original ResNet-50](https://github.com/KaimingHe/deep-residual-networks).    |
+| ResNet101_Caffe  | MSRA        | [MSRA's ResNet-101](https://download.openmmlab.com/pretrain/third_party/resnet101_caffe-3ad79236.pth)                                                                                                  | Converted copy of [Detectron2's R-101.pkl](https://dl.fbaipublicfiles.com/detectron2/ImageNetPretrained/MSRA/R-101.pkl) model. The original weight comes from [MSRA's original ResNet-101](https://github.com/KaimingHe/deep-residual-networks). |
+| ResNext101_32x8d | Caffe2      | [Caffe2 ResNext101_32x8d](https://download.openmmlab.com/pretrain/third_party/resnext101_32x8d-1516f1aa.pth)                                                                                           | Converted copy of [Detectron2's X-101-32x8d.pkl](https://dl.fbaipublicfiles.com/detectron2/ImageNetPretrained/FAIR/X-101-32x8d.pkl) model. The ResNeXt-101-32x8d model trained with Caffe2 at FB.                                                |
+
+## Baselines
+
+### RPN
+
+Please refer to [RPN](https://github.com/open-mmlab/mmdetection/blob/main/configs/rpn) for details.
+
+### Faster R-CNN
+
+Please refer to [Faster R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/faster_rcnn) for details.
+
+### Mask R-CNN
+
+Please refer to [Mask R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/mask_rcnn) for details.
+
+### Fast R-CNN (with pre-computed proposals)
+
+Please refer to [Fast R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/fast_rcnn) for details.
+
+### RetinaNet
+
+Please refer to [RetinaNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/retinanet) for details.
+
+### Cascade R-CNN and Cascade Mask R-CNN
+
+Please refer to [Cascade R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/cascade_rcnn) for details.
+
+### Hybrid Task Cascade (HTC)
+
+Please refer to [HTC](https://github.com/open-mmlab/mmdetection/blob/main/configs/htc) for details.
+
+### SSD
+
+Please refer to [SSD](https://github.com/open-mmlab/mmdetection/blob/main/configs/ssd) for details.
+
+### Group Normalization (GN)
+
+Please refer to [Group Normalization](https://github.com/open-mmlab/mmdetection/blob/main/configs/gn) for details.
+
+### Weight Standardization
+
+Please refer to [Weight Standardization](https://github.com/open-mmlab/mmdetection/blob/main/configs/gn+ws) for details.
+
+### Deformable Convolution v2
+
+Please refer to [Deformable Convolutional Networks](https://github.com/open-mmlab/mmdetection/blob/main/configs/dcn) for details.
+
+### CARAFE: Content-Aware ReAssembly of FEatures
+
+Please refer to [CARAFE](https://github.com/open-mmlab/mmdetection/blob/main/configs/carafe) for details.
+
+### Instaboost
+
+Please refer to [Instaboost](https://github.com/open-mmlab/mmdetection/blob/main/configs/instaboost) for details.
+
+### Libra R-CNN
+
+Please refer to [Libra R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/libra_rcnn) for details.
+
+### Guided Anchoring
+
+Please refer to [Guided Anchoring](https://github.com/open-mmlab/mmdetection/blob/main/configs/guided_anchoring) for details.
+
+### FCOS
+
+Please refer to [FCOS](https://github.com/open-mmlab/mmdetection/blob/main/configs/fcos) for details.
+
+### FoveaBox
+
+Please refer to [FoveaBox](https://github.com/open-mmlab/mmdetection/blob/main/configs/foveabox) for details.
+
+### RepPoints
+
+Please refer to [RepPoints](https://github.com/open-mmlab/mmdetection/blob/main/configs/reppoints) for details.
+
+### FreeAnchor
+
+Please refer to [FreeAnchor](https://github.com/open-mmlab/mmdetection/blob/main/configs/free_anchor) for details.
+
+### Grid R-CNN (plus)
+
+Please refer to [Grid R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/grid_rcnn) for details.
+
+### GHM
+
+Please refer to [GHM](https://github.com/open-mmlab/mmdetection/blob/main/configs/ghm) for details.
+
+### GCNet
+
+Please refer to [GCNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/gcnet) for details.
+
+### HRNet
+
+Please refer to [HRNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/hrnet) for details.
+
+### Mask Scoring R-CNN
+
+Please refer to [Mask Scoring R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/ms_rcnn) for details.
+
+### Train from Scratch
+
+Please refer to [Rethinking ImageNet Pre-training](https://github.com/open-mmlab/mmdetection/blob/main/configs/scratch) for details.
+
+### NAS-FPN
+
+Please refer to [NAS-FPN](https://github.com/open-mmlab/mmdetection/blob/main/configs/nas_fpn) for details.
+
+### ATSS
+
+Please refer to [ATSS](https://github.com/open-mmlab/mmdetection/blob/main/configs/atss) for details.
+
+### FSAF
+
+Please refer to [FSAF](https://github.com/open-mmlab/mmdetection/blob/main/configs/fsaf) for details.
+
+### RegNetX
+
+Please refer to [RegNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/regnet) for details.
+
+### Res2Net
+
+Please refer to [Res2Net](https://github.com/open-mmlab/mmdetection/blob/main/configs/res2net) for details.
+
+### GRoIE
+
+Please refer to [GRoIE](https://github.com/open-mmlab/mmdetection/blob/main/configs/groie) for details.
+
+### Dynamic R-CNN
+
+Please refer to [Dynamic R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/dynamic_rcnn) for details.
+
+### PointRend
+
+Please refer to [PointRend](https://github.com/open-mmlab/mmdetection/blob/main/configs/point_rend) for details.
+
+### DetectoRS
+
+Please refer to [DetectoRS](https://github.com/open-mmlab/mmdetection/blob/main/configs/detectors) for details.
+
+### Generalized Focal Loss
+
+Please refer to [Generalized Focal Loss](https://github.com/open-mmlab/mmdetection/blob/main/configs/gfl) for details.
+
+### CornerNet
+
+Please refer to [CornerNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/cornernet) for details.
+
+### YOLOv3
+
+Please refer to [YOLOv3](https://github.com/open-mmlab/mmdetection/blob/main/configs/yolo) for details.
+
+### PAA
+
+Please refer to [PAA](https://github.com/open-mmlab/mmdetection/blob/main/configs/paa) for details.
+
+### SABL
+
+Please refer to [SABL](https://github.com/open-mmlab/mmdetection/blob/main/configs/sabl) for details.
+
+### CentripetalNet
+
+Please refer to [CentripetalNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/centripetalnet) for details.
+
+### ResNeSt
+
+Please refer to [ResNeSt](https://github.com/open-mmlab/mmdetection/blob/main/configs/resnest) for details.
+
+### DETR
+
+Please refer to [DETR](https://github.com/open-mmlab/mmdetection/blob/main/configs/detr) for details.
+
+### Deformable DETR
+
+Please refer to [Deformable DETR](https://github.com/open-mmlab/mmdetection/blob/main/configs/deformable_detr) for details.
+
+### AutoAssign
+
+Please refer to [AutoAssign](https://github.com/open-mmlab/mmdetection/blob/main/configs/autoassign) for details.
+
+### YOLOF
+
+Please refer to [YOLOF](https://github.com/open-mmlab/mmdetection/blob/main/configs/yolof) for details.
+
+### Seesaw Loss
+
+Please refer to [Seesaw Loss](https://github.com/open-mmlab/mmdetection/blob/main/configs/seesaw_loss) for details.
+
+### CenterNet
+
+Please refer to [CenterNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/centernet) for details.
+
+### YOLOX
+
+Please refer to [YOLOX](https://github.com/open-mmlab/mmdetection/blob/main/configs/yolox) for details.
+
+### PVT
+
+Please refer to [PVT](https://github.com/open-mmlab/mmdetection/blob/main/configs/pvt) for details.
+
+### SOLO
+
+Please refer to [SOLO](https://github.com/open-mmlab/mmdetection/blob/main/configs/solo) for details.
+
+### QueryInst
+
+Please refer to [QueryInst](https://github.com/open-mmlab/mmdetection/blob/main/configs/queryinst) for details.
+
+### PanopticFPN
+
+Please refer to [PanopticFPN](https://github.com/open-mmlab/mmdetection/blob/main/configs/panoptic_fpn) for details.
+
+### MaskFormer
+
+Please refer to [MaskFormer](https://github.com/open-mmlab/mmdetection/blob/main/configs/maskformer) for details.
+
+### DyHead
+
+Please refer to [DyHead](https://github.com/open-mmlab/mmdetection/blob/main/configs/dyhead) for details.
+
+### Mask2Former
+
+Please refer to [Mask2Former](https://github.com/open-mmlab/mmdetection/blob/main/configs/mask2former) for details.
+
+### Efficientnet
+
+Please refer to [Efficientnet](https://github.com/open-mmlab/mmdetection/blob/main/configs/efficientnet) for details.
+
+### Other datasets
+
+We also benchmark some methods on [PASCAL VOC](https://github.com/open-mmlab/mmdetection/blob/main/configs/pascal_voc), [Cityscapes](https://github.com/open-mmlab/mmdetection/blob/main/configs/cityscapes), [OpenImages](https://github.com/open-mmlab/mmdetection/blob/main/configs/openimages) and [WIDER FACE](https://github.com/open-mmlab/mmdetection/blob/main/configs/wider_face).
+
+### Pre-trained Models
+
+We also train [Faster R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/faster_rcnn) and [Mask R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/mask_rcnn) using ResNet-50 and [RegNetX-3.2G](https://github.com/open-mmlab/mmdetection/blob/main/configs/regnet) with multi-scale training and longer schedules. These models serve as strong pre-trained models for downstream tasks for convenience.
+
+## Speed benchmark
+
+### Training Speed benchmark
+
+We provide [analyze_logs.py](https://github.com/open-mmlab/mmdetection/blob/main/tools/analysis_tools/analyze_logs.py) to get average time of iteration in training. You can find examples in [Log Analysis](https://mmdetection.readthedocs.io/en/latest/useful_tools.html#log-analysis).
+
+We compare the training speed of Mask R-CNN with some other popular frameworks (The data is copied from [detectron2](https://github.com/facebookresearch/detectron2/blob/main/docs/notes/benchmarks.md/)).
+For mmdetection, we benchmark with [mask-rcnn_r50-caffe_fpn_poly-1x_coco_v1.py](https://github.com/open-mmlab/mmdetection/blob/main/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_poly-1x_coco_v1.py), which should have the same setting with [mask_rcnn_R_50_FPN_noaug_1x.yaml](https://github.com/facebookresearch/detectron2/blob/main/configs/Detectron1-Comparisons/mask_rcnn_R_50_FPN_noaug_1x.yaml) of detectron2.
+We also provide the [checkpoint](https://download.openmmlab.com/mmdetection/v2.0/benchmark/mask_rcnn_r50_caffe_fpn_poly_1x_coco_no_aug/mask_rcnn_r50_caffe_fpn_poly_1x_coco_no_aug_compare_20200518-10127928.pth) and [training log](https://download.openmmlab.com/mmdetection/v2.0/benchmark/mask_rcnn_r50_caffe_fpn_poly_1x_coco_no_aug/mask_rcnn_r50_caffe_fpn_poly_1x_coco_no_aug_20200518_105755.log.json) for reference. The throughput is computed as the average throughput in iterations 100-500 to skip GPU warmup time.
+
+| Implementation                                                                         | Throughput (img/s) |
+| -------------------------------------------------------------------------------------- | ------------------ |
+| [Detectron2](https://github.com/facebookresearch/detectron2)                           | 62                 |
+| [MMDetection](https://github.com/open-mmlab/mmdetection)                               | 61                 |
+| [maskrcnn-benchmark](https://github.com/facebookresearch/maskrcnn-benchmark/)          | 53                 |
+| [tensorpack](https://github.com/tensorpack/tensorpack/tree/master/examples/FasterRCNN) | 50                 |
+| [simpledet](https://github.com/TuSimple/simpledet/)                                    | 39                 |
+| [Detectron](https://github.com/facebookresearch/Detectron)                             | 19                 |
+| [matterport/Mask_RCNN](https://github.com/matterport/Mask_RCNN/)                       | 14                 |
+
+### Inference Speed Benchmark
+
+We provide [benchmark.py](https://github.com/open-mmlab/mmdetection/blob/main/tools/analysis_tools/benchmark.py) to benchmark the inference latency.
+The script benchmarkes the model with 2000 images and calculates the average time ignoring first 5 times. You can change the output log interval (defaults: 50) by setting `LOG-INTERVAL`.
+
+```shell
+python tools/benchmark.py ${CONFIG} ${CHECKPOINT} [--log-interval $[LOG-INTERVAL]] [--fuse-conv-bn]
+```
+
+The latency of all models in our model zoo is benchmarked without setting `fuse-conv-bn`, you can get a lower latency by setting it.
+
+## Comparison with Detectron2
+
+We compare mmdetection with [Detectron2](https://github.com/facebookresearch/detectron2.git) in terms of speed and performance.
+We use the commit id [185c27e](https://github.com/facebookresearch/detectron2/tree/185c27e4b4d2d4c68b5627b3765420c6d7f5a659)(30/4/2020) of detectron.
+For fair comparison, we install and run both frameworks on the same machine.
+
+### Hardware
+
+- 8 NVIDIA Tesla V100 (32G) GPUs
+- Intel(R) Xeon(R) Gold 6148 CPU @ 2.40GHz
+
+### Software environment
+
+- Python 3.7
+- PyTorch 1.4
+- CUDA 10.1
+- CUDNN 7.6.03
+- NCCL 2.4.08
+
+### Performance
+
+| Type                                                                                                                            | Lr schd | Detectron2                                                                                                                           | mmdetection | Download                                                                                                                                                                                                                                                                                                                                                         |
+| ------------------------------------------------------------------------------------------------------------------------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------ | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [Faster R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_ms-1x_coco.py) | 1x      | [37.9](https://github.com/facebookresearch/detectron2/blob/main/configs/COCO-Detection/faster_rcnn_R_50_FPN_1x.yaml)                 | 38.0        | [model](https://download.openmmlab.com/mmdetection/v2.0/benchmark/faster_rcnn_r50_caffe_fpn_mstrain_1x_coco/faster_rcnn_r50_caffe_fpn_mstrain_1x_coco-5324cff8.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/benchmark/faster_rcnn_r50_caffe_fpn_mstrain_1x_coco/faster_rcnn_r50_caffe_fpn_mstrain_1x_coco_20200429_234554.log.json)             |
+| [Mask R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco.py)  | 1x      | [38.6 & 35.2](https://github.com/facebookresearch/detectron2/blob/main/configs/COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_1x.yaml) | 38.8 & 35.4 | [model](https://download.openmmlab.com/mmdetection/v2.0/benchmark/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_coco/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_coco-dbecf295.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/benchmark/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_coco/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_coco_20200430_054239.log.json) |
+| [Retinanet](https://github.com/open-mmlab/mmdetection/blob/main/configs/retinanet/retinanet_r50-caffe_fpn_ms-1x_coco.py)        | 1x      | [36.5](https://github.com/facebookresearch/detectron2/blob/master/configs/COCO-Detection/retinanet_R_50_FPN_1x.yaml)                 | 37.0        | [model](https://download.openmmlab.com/mmdetection/v2.0/benchmark/retinanet_r50_caffe_fpn_mstrain_1x_coco/retinanet_r50_caffe_fpn_mstrain_1x_coco-586977a0.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/benchmark/retinanet_r50_caffe_fpn_mstrain_1x_coco/retinanet_r50_caffe_fpn_mstrain_1x_coco_20200430_014748.log.json)                     |
+
+### Training Speed
+
+The training speed is measure with s/iter. The lower, the better.
+
+| Type         | Detectron2 | mmdetection |
+| ------------ | ---------- | ----------- |
+| Faster R-CNN | 0.210      | 0.216       |
+| Mask R-CNN   | 0.261      | 0.265       |
+| Retinanet    | 0.200      | 0.205       |
+
+### Inference Speed
+
+The inference speed is measured with fps (img/s) on a single GPU, the higher, the better.
+To be consistent with Detectron2, we report the pure inference speed (without the time of data loading).
+For Mask R-CNN, we exclude the time of RLE encoding in post-processing.
+We also include the officially reported speed in the parentheses, which is slightly higher
+than the results tested on our server due to differences of hardwares.
+
+| Type         | Detectron2  | mmdetection |
+| ------------ | ----------- | ----------- |
+| Faster R-CNN | 25.6 (26.3) | 22.2        |
+| Mask R-CNN   | 22.5 (23.3) | 19.6        |
+| Retinanet    | 17.8 (18.2) | 20.6        |
+
+### Training memory
+
+| Type         | Detectron2 | mmdetection |
+| ------------ | ---------- | ----------- |
+| Faster R-CNN | 3.0        | 3.8         |
+| Mask R-CNN   | 3.4        | 3.9         |
+| Retinanet    | 3.9        | 3.4         |
diff --git a/mmdetection/docs/en/notes/changelog.md b/mmdetection/docs/en/notes/changelog.md
new file mode 100644
index 00000000..00ed8f1c
--- /dev/null
+++ b/mmdetection/docs/en/notes/changelog.md
@@ -0,0 +1,631 @@
+# Changelog of v3.x
+
+## v3.3.0 (05/01/2024)
+
+### Highlights
+
+Grounding-DINO is a state-of-the-art open-set detection model that tackles multiple vision tasks including Open-Vocabulary Detection (OVD), Phrase Grounding (PG), and Referring Expression Comprehension (REC). Its effectiveness has led to its widespread adoption as a mainstream architecture for various downstream applications. However, despite its significance, the original Grounding-DINO model lacks comprehensive public technical details due to the unavailability of its training code. To bridge this gap, we present MM-Grounding-DINO, an open-source, comprehensive, and user-friendly baseline, which is built with the MMDetection toolbox. It adopts abundant vision datasets for pre-training and various detection and grounding datasets for fine-tuning. We give a comprehensive analysis of each reported result and detailed settings for reproduction. The extensive experiments on the benchmarks mentioned demonstrate that our MM-Grounding-DINO-Tiny outperforms the Grounding-DINO-Tiny baseline. We release all our models to the research community.
+
+### New Features
+
+- Add RTMDet Swin / ConvNeXt backbone and results (#11259)
+- Add `odinw` configs and evaluation results of `GLIP` (#11175)
+- Add optional score threshold option to `coco_error_analysis.py` (#11117)
+- Add new configs for `panoptic_fpn` (#11109)
+- Replace partially weighted download links with OpenXLab for the `Faster-RCNN` (#11173)
+
+### Bug Fixes
+
+- Fix `Grounding DINO` nan when class tokens exceeds 256 (#11066)
+- Fix the `CO-DETR` config files error (#11325)
+- Fix `CO-DETR` load_from url in config (#11220)
+- Fixed mask shape after Albu postprocess (#11280)
+- Fix bug in `convert_coco_format`  and `youtubevis2coco` (#11251, #11086)
+
+### Contributors
+
+A total of 15 developers contributed to this release.
+
+Thank @adnan-mujagic, @Cycyes, @ilcopione, @returnL, @honeybadger78, @okotaku, @xushilin1, @keyhsw, @guyleaf, @Crescent-Saturn, @LRJKD, @aaronzs, @Divadi, @AwePhD, @hhaAndroid
+
+## v3.2.0 (12/10/2023)
+
+### Highlights
+
+**(1) Detection Transformer SOTA Model Collection**
+
+- Supported four updated and stronger SOTA Transformer models: DDQ, CO-DETR, AlignDETR, and H-DINO.
+- Based on CO-DETR, MMDet released a model with a COCO performance of 64.1 mAP.
+- Algorithms such as DINO support AMP/Checkpoint/FrozenBN, which can effectively reduce memory usage.
+
+**(2) Comprehensive Performance Comparison between CNN and Transformer**
+
+RF100 consists of a dataset collection of 100 real-world datasets, including 7 domains. It can be used to assess the performance differences of Transformer models like DINO and CNN-based algorithms under different scenarios and data volumes. Users can utilize this benchmark to quickly evaluate the robustness of their algorithms in various scenarios.
+
+**(3) Support for GLIP and Grounding DINO fine-tuning, the only algorithm library that supports Grounding DINO fine-tuning**
+
+The Grounding DINO algorithm in MMDet is the only library that supports fine-tuning. Its performance is one point higher than the official version, and of course, GLIP also outperforms the official version.
+We also provide a detailed process for training and evaluating Grounding DINO on custom datasets. Everyone is welcome to give it a try.
+
+**(4) Support for the open-vocabulary detection algorithm Detic and multi-dataset joint training.**
+
+**(5) Training detection models using FSDP and DeepSpeed.**
+
+**(6) Support for the V3Det dataset, a large-scale detection dataset with over 13,000 categories.**
+
+### New Features
+
+- Support CO-DETR/DDQ/AlignDETR/H-DINO
+- Support GLIP and Grounding DINO fine-tuning
+- Support Detic and Multi-Datasets training (#10926)
+- Support V3Det and benchmark (#10938)
+- Support Roboflow 100 Benchmark (#10915)
+- Add custom dataset of grounding dino (#11012)
+- Release RTMDet-X p6 (#10993)
+- Support AMP of DINO (#10827)
+- Support FrozenBN (#10845)
+- Add new configuration files for `QDTrack/DETR/RTMDet/MaskRCNN/DINO/DeformableDETR/MaskFormer` algorithm
+- Add a new script to support the WBF (#10808)
+- Add `large_image_demo` (#10719)
+- Support download dataset from OpenXLab (#10799)
+- Update to support torch2onnx for DETR series models (#10910)
+- Translation into Chinese of an English document (#10744, #10756, #10805, #10848)
+
+### Bug Fixes
+
+- Fix name error in DETR metafile.yml (#10595)
+- Fix device of the tensors in `set_nms` (#10574)
+- Remove some unicode chars from `en/` docs (#10648)
+- Fix download dataset with mim script. (#10727)
+- Fix export to torchserve (#10694)
+- Fix typo in `mask-rcnn_r50_fpn_1x-wandb_coco` (#10757)
+- Fix `eval_recalls` error in `voc_metric` (#10770)
+- Fix torch version comparison (#10934)
+- Fix incorrect behavior to access train pipeline from ConcatDataset in `analyze_results.py` (#11004)
+
+### Improvements
+
+- Update `useful_tools.md` (#10587)
+- Update Instance segmentation Tutorial (#10711)
+- Update `train.py` to compat with new config (#11025)
+- Support `torch2onnx` for maskformer series (#10782)
+
+### Contributors
+
+A total of 36 developers contributed to this release.
+
+Thank @YQisme, @nskostas, @max-unfinity, @evdcush, @Xiangxu-0103, @ZhaoCake, @RangeKing, @captainIT, @ODAncona, @aaronzs, @zeyuanyin, @gotjd709, @Musiyuan, @YanxingLiu, @RunningLeon, @ytzfhqs, @zhangzhidaSunny, @yeungkong, @crazysteeaam, @timerring, @okotaku, @apatsekin, @Morty-Xu, @Markson-Young, @ZhaoQiiii, @Kuro96, @PhoenixZ810, @yhcao6, @myownskyW7, @jiongjiongli, @Johnson-Wang, @ryylcc, @guyleaf, @agpeshal, @SimonGuoNjust, @hhaAndroid
+
+## v3.1.0 (30/6/2023)
+
+### Highlights
+
+- Supports tracking algorithms including multi-object tracking (MOT) algorithms SORT, DeepSORT, StrongSORT, OCSORT, ByteTrack, QDTrack, and video instance segmentation (VIS) algorithm MaskTrackRCNN, Mask2Former-VIS.
+- Support [ViTDet](../../../projects/ViTDet)
+- Supports inference and evaluation of multimodal algorithms [GLIP](../../../configs/glip) and [XDecoder](../../../projects/XDecoder), and also supports datasets such as COCO semantic segmentation, COCO Caption, ADE20k general segmentation, and RefCOCO. GLIP fine-tuning will be supported in the future.
+- Provides a [gradio demo](https://github.com/open-mmlab/mmdetection/blob/dev-3.x/projects/gradio_demo/README.md) for image type tasks of MMDetection, making it easy for users to experience.
+
+### New Features
+
+- Support DSDL Dataset (#9801)
+- Support iSAID dataset (#10028)
+- Support VISION dataset (#10530)
+- Release SoftTeacher checkpoints (#10119)
+- Release `centernet-update_r50-caffe_fpn_ms-1x_coco` checkpoints  (#10327)
+- Support SIoULoss (#10290)
+- Support Eqlv2 loss (#10120)
+- Support CopyPaste when mask is not available (#10509)
+- Support MIM to download ODL dataset (#10460)
+- Support new config (#10566)
+
+### Bug Fixes
+
+- Fix benchmark scripts error in windows (#10128)
+- Fix error of `YOLOXModeSwitchHook` does not switch the mode when resumed from the checkpoint after switched (#10116)
+- Fix pred and weight dims unmatch in SmoothL1Loss (#10423)
+
+### Improvements
+
+- Update MMDet_Tutorial.ipynb (#10081)
+- Support to hide inference progress (#10519)
+- Replace mmcls with mmpretrain  (#10545)
+
+### Contributors
+
+A total of 29 developers contributed to this release.
+
+Thanks @lovelykite, @minato-ellie, @freepoet, @wufan-tb, @yalibian, @keyakiluo, @gihanjayatilaka, @i-aki-y, @xin-li-67, @RangeKing, @JingweiZhang12, @MambaWong, @lucianovk, @tall-josh, @xiuqhou, @jamiechoi1995, @YQisme, @yechenzhi, @bjzhb666, @xiexinch, @jamiechoi1995, @yarkable, @Renzhihan, @nijkah, @amaizr, @Lum1104, @zwhus, @Czm369, @hhaAndroid
+
+## v3.0.0 (6/4/2023)
+
+### Highlights
+
+- Support Semi-automatic annotation Base [Label-Studio](../../../projects/LabelStudio) (#10039)
+- Support [EfficientDet](../../../projects/EfficientDet) in projects (#9810)
+
+### New Features
+
+- File I/O migration and reconstruction (#9709)
+- Release DINO Swin-L 36e model (#9927)
+
+### Bug Fixes
+
+- Fix benchmark script (#9865)
+- Fix the crop method of PolygonMasks (#9858)
+- Fix Albu augmentation with the mask shape (#9918)
+- Fix `RTMDetIns` prior generator device error (#9964)
+- Fix `img_shape` in data pipeline (#9966)
+- Fix cityscapes import error (#9984)
+- Fix `solov2_r50_fpn_ms-3x_coco.py` config error (#10030)
+- Fix Conditional DETR AP and Log (#9889)
+- Fix accepting an unexpected argument local-rank in PyTorch 2.0 (#10050)
+- Fix `common/ms_3x_coco-instance.py` config error (#10056)
+- Fix compute flops error (#10051)
+- Delete `data_root` in `CocoOccludedSeparatedMetric` to fix bug (#9969)
+- Unifying metafile.yml (#9849)
+
+### Improvements
+
+- Added BoxInst r101 config (#9967)
+- Added config migration guide (#9960)
+- Added more social networking links (#10021)
+- Added RTMDet config introduce (#10042)
+- Added visualization docs (#9938, #10058)
+- Refined data_prepare docs (#9935)
+- Added support for setting the cache_size_limit parameter of dynamo in PyTorch 2.0 (#10054)
+- Updated coco_metric.py (#10033)
+- Update type hint (#10040)
+
+### Contributors
+
+A total of 19 developers contributed to this release.
+
+Thanks @IRONICBo, @vansin, @RangeKing, @Ghlerrix, @okotaku, @JosonChan1998, @zgzhengSE, @bobo0810, @yechenzh, @Zheng-LinXiao, @LYMDLUT, @yarkable, @xiejiajiannb, @chhluo, @BIGWangYuDong, @RangiLy, @zwhus, @hhaAndroid, @ZwwWayne
+
+## v3.0.0rc6 (24/2/2023)
+
+### Highlights
+
+- Support [Boxinst](../../../configs/boxinst), [Objects365 Dataset](../../../configs/objects365), and [Separated and Occluded COCO metric](../user_guides/useful_tools.md#COCO-Separated-&-Occluded-Mask-Metric)
+- Support [ConvNeXt-V2](../../../projects/ConvNeXt-V2), [DiffusionDet](../../../projects/DiffusionDet), and inference of [EfficientDet](../../../projects/EfficientDet) and [Detic](../../../projects/Detic) in `Projects`
+- Refactor [DETR](../../../configs/detr) series and support [Conditional-DETR](../../../configs/conditional_detr), [DAB-DETR](../../../configs/dab_detr), and [DINO](../../../configs/detr)
+- Support `DetInferencer` for inference, Test Time Augmentation, and automatically importing modules from registry
+- Support RTMDet-Ins ONNXRuntime and TensorRT [deployment](../../../configs/rtmdet/README.md#deployment-tutorial)
+- Support [calculating FLOPs of detectors](../user_guides/useful_tools.md#Model-Complexity)
+
+### New Features
+
+- Support [Boxinst](https://arxiv.org/abs/2012.02310) (#9525)
+- Support [Objects365 Dataset](https://openaccess.thecvf.com/content_ICCV_2019/papers/Shao_Objects365_A_Large-Scale_High-Quality_Dataset_for_Object_Detection_ICCV_2019_paper.pdf) (#9600)
+- Support [ConvNeXt-V2](http://arxiv.org/abs/2301.00808) in `Projects` (#9619)
+- Support [DiffusionDet](https://arxiv.org/abs/2211.09788) in `Projects` (#9639, #9768)
+- Support [Detic](http://arxiv.org/abs/2201.02605) inference in `Projects` (#9645)
+- Support [EfficientDet](https://arxiv.org/abs/1911.09070) inference in `Projects` (#9645)
+- Support [Separated and Occluded COCO metric](https://arxiv.org/abs/2210.10046) (#9710)
+- Support auto import modules from registry (#9143)
+- Refactor DETR series and support Conditional-DETR, DAB-DETR and DINO (#9646)
+- Support `DetInferencer` for inference (#9561)
+- Support Test Time Augmentation (#9452)
+- Support calculating FLOPs of detectors (#9777)
+
+### Bug Fixes
+
+- Fix deprecating old type alias due to new version of numpy (#9625, #9537)
+- Fix VOC metrics (#9784)
+- Fix the wrong link of RTMDet-x log (#9549)
+- Fix RTMDet link in README (#9575)
+- Fix MMDet get flops error (#9589)
+- Fix `use_depthwise` in RTMDet (#9624)
+- Fix `albumentations` augmentation post process with masks (#9551)
+- Fix DETR series Unit Test (#9647)
+- Fix `LoadPanopticAnnotations` bug (#9703)
+- Fix `isort` CI (#9680)
+- Fix amp pooling overflow (#9670)
+- Fix docstring about noise in DINO (#9747)
+- Fix potential bug in `MultiImageMixDataset` (#9764)
+
+### Improvements
+
+- Replace NumPy transpose with PyTorch permute to speed-up (#9762)
+- Deprecate `sklearn` (#9725)
+- Add RTMDet-Ins deployment guide (#9823)
+- Update RTMDet config and README (#9603)
+- Replace the models used in the tutorial document with RTMDet (#9843)
+- Adjust the minimum supported python version to 3.7 (#9602)
+- Support modifying palette through configuration (#9445)
+- Update README document in `Project` (#9599)
+- Replace `github` with `gitee` in `.pre-commit-config-zh-cn.yaml` file (#9586)
+- Use official `isort` in `.pre-commit-config.yaml` file (#9701)
+- Change MMCV minimum version to `2.0.0rc4` for `dev-3.x` (#9695)
+- Add Chinese version of single_stage_as_rpn.md and test_results_submission.md (#9434)
+- Add OpenDataLab download link (#9605, #9738)
+- Add type hints of several layers (#9346)
+- Add typehint for `DarknetBottleneck` (#9591)
+- Add dockerfile (#9659)
+- Add twitter, discord, medium, and youtube link (#9775)
+- Prepare for merging refactor-detr (#9656)
+- Add metafile to ConditionalDETR, DABDETR and DINO (#9715)
+- Support to modify `non_blocking` parameters (#9723)
+- Comment repeater visualizer register (#9740)
+- Update user guide: `finetune.md` and `inference.md` (#9578)
+
+### New Contributors
+
+- @NoFish-528 made their first contribution in 
+- @137208 made their first contribution in 
+- @lyviva made their first contribution in 
+- @zwhus made their first contribution in 
+- @zylo117 made their first contribution in 
+- @chg0901 made their first contribution in 
+- @DanShouzhu made their first contribution in https://github.com/open-mmlab/mmdetection/pull/9578
+
+### Contributors
+
+A total of 27 developers contributed to this release.
+
+Thanks @JosonChan1998, @RangeKing, @NoFish-528, @likyoo, @Xiangxu-0103, @137208, @PeterH0323, @tianleiSHI, @wufan-tb, @lyviva, @zwhus, @jshilong, @Li-Qingyun, @sanbuphy, @zylo117, @triple-Mu, @KeiChiTse, @LYMDLUT, @nijkah, @chg0901, @DanShouzhu, @zytx121, @vansin, @BIGWangYuDong, @hhaAndroid, @RangiLyu, @ZwwWayne
+
+## v3.0.0rc5 (26/12/2022)
+
+### Highlights
+
+- Support [RTMDet](https://arxiv.org/abs/2212.07784) instance segmentation models. The technical report of RTMDet is on [arxiv](https://arxiv.org/abs/2212.07784)
+- Support SSHContextModule in paper [SSH: Single Stage Headless Face Detector](https://arxiv.org/abs/1708.03979).
+
+### New Features
+
+- Support [RTMDet](https://arxiv.org/abs/2212.07784) instance segmentation models and improve RTMDet test config (#9494)
+- Support SSHContextModule in paper [SSH: Single Stage Headless Face Detector](https://arxiv.org/abs/1708.03979) (#8953)
+- Release [CondInst](https://arxiv.org/abs/2003.05664) pre-trained model (#9406)
+
+### Bug Fixes
+
+- Fix CondInst predict error when `batch_size` is greater than 1 in inference (#9400)
+- Fix the bug of visualization when the dtype of the pipeline output image is not uint8 in browse dataset (#9401)
+- Fix `analyze_logs.py` to plot mAP and calculate train time correctly (#9409)
+- Fix backward inplace error with `PAFPN` (#9450)
+- Fix config import links in model converters (#9441)
+- Fix `DeformableDETRHead` object has no attribute `loss_single` (#9477)
+- Fix the logic of pseudo bboxes predicted by teacher model in SemiBaseDetector (#9414)
+- Fix demo API in instance segmentation tutorial (#9226)
+- Fix `analyze_results` (#9380)
+- Fix the error that Readthedocs API cannot be displayed (#9510)
+- Fix the error when there are no prediction results and support visualize the groundtruth of TTA (#9840)
+
+### Improvements
+
+- Remove legacy `builder.py` (#9479)
+- Make sure the pipeline argument shape is in `(width, height)` order (#9324)
+- Add `.pre-commit-config-zh-cn.yaml` file (#9388)
+- Refactor dataset metainfo to lowercase (#9469)
+- Add PyTorch 1.13 checking in CI (#9478)
+- Adjust `FocalLoss` and `QualityFocalLoss` to allow different kinds of targets (#9481)
+- Refactor `setup.cfg` (#9370)
+- Clip saturation value to valid range `[0, 1]` (#9391)
+- Only keep meta and state_dict when publishing model (#9356)
+- Add segm evaluator in ms-poly_3x_coco_instance config (#9524)
+- Update deployment guide (#9527)
+- Update zh_cn `faq.md` (#9396)
+- Update `get_started` (#9480)
+- Update the zh_cn user_guides of `useful_tools.md` and `useful_hooks.md` (#9453)
+- Add type hints for `bfp` and `channel_mapper` (#9410)
+- Add type hints of several losses (#9397)
+- Add type hints and update docstring for task modules (#9468)
+
+### New Contributors
+
+- @lihua199710 made their first contribution in 
+- @twmht made their first contribution in 
+- @tianleiSHI made their first contribution in 
+- @kitecats made their first contribution in 
+- @QJC123654 made their first contribution in 
+
+### Contributors
+
+A total of 20 developers contributed to this release.
+
+Thanks @liuyanyi, @RangeKing, @lihua199710, @MambaWong, @sanbuphy, @Xiangxu-0103, @twmht, @JunyaoHu, @Chan-Sun, @tianleiSHI, @zytx121, @kitecats, @QJC123654, @JosonChan1998, @lvhan028, @Czm369, @BIGWangYuDong, @RangiLyu, @hhaAndroid, @ZwwWayne
+
+## v3.0.0rc4 (23/11/2022)
+
+### Highlights
+
+- Support [CondInst](https://arxiv.org/abs/2003.05664)
+- Add `projects/` folder, which will be a place for some experimental models/features.
+- Support [SparseInst](https://arxiv.org/abs/2203.12827) in [`projects`](./projects/SparseInst/README.md)
+
+### New Features
+
+- Support [CondInst](https://arxiv.org/abs/2003.05664) (#9223)
+- Add `projects/` folder, which will be a place for some experimental models/features (#9341)
+- Support [SparseInst](https://arxiv.org/abs/2203.12827) in [`projects`](./projects/SparseInst/README.md) (#9377)
+
+### Bug Fixes
+
+- Fix `pixel_decoder_type` discrimination in MaskFormer Head. (#9176)
+- Fix wrong padding value in cached MixUp (#9259)
+- Rename `utils/typing.py` to `utils/typing_utils.py` to fix `collect_env` error (#9265)
+- Fix resume arg conflict (#9287)
+- Fix the configs of Faster R-CNN with caffe backbone (#9319)
+- Fix torchserve and update related documentation (#9343)
+- Fix bbox refine bug with sigmooid activation (#9538)
+
+### Improvements
+
+- Update the docs of GIoU Loss in README (#8810)
+- Handle dataset wrapper in `inference_detector` (#9144)
+- Update the type of `counts` in COCO's compressed RLE (#9274)
+- Support saving config file in `print_config` (#9276)
+- Update docs about video inference (#9305)
+- Update guide about model deployment (#9344)
+- Fix doc typos of useful tools (#9177)
+- Allow to resume from specific checkpoint in CLI (#9284)
+- Update FAQ about windows installation issues of pycocotools (#9292)
+
+### New Contributors
+
+- @Daa98 made their first contribution in 
+- @lvhan028 made their first contribution in 
+
+### Contributors
+
+A total of 12 developers contributed to this release.
+
+Thanks @sanbuphy, @Czm369, @Daa98, @jbwang1997, @BIGWangYuDong, @JosonChan1998, @lvhan028, @RunningLeon, @RangiLyu, @Daa98, @ZwwWayne, @hhaAndroid
+
+## v3.0.0rc3 (4/11/2022)
+
+Upgrade the minimum version requirement of MMEngine to 0.3.0 to use `ignore_key` of `ConcatDataset` for training VOC datasets (#9058)
+
+### Highlights
+
+- Support [CrowdDet](https://arxiv.org/abs/2003.09163) and [EIoU Loss](https://ieeexplore.ieee.org/document/9429909)
+- Support training detection models in Detectron2
+- Refactor Fast R-CNN
+
+### New Features
+
+- Support [CrowdDet](https://arxiv.org/abs/2003.09163) (#8744)
+- Support training detection models in Detectron2 with examples of Mask R-CNN, Faster R-CNN, and RetinaNet (#8672)
+- Support [EIoU Loss](https://ieeexplore.ieee.org/document/9429909) (#9086)
+
+### Bug Fixes
+
+- Fix `XMLDataset` image size error (#9216)
+- Fix bugs of empty_instances when predicting without nms in roi_head (#9015)
+- Fix the config file of DETR (#9158)
+- Fix SOLOv2 cannot dealing with empty gt image (#9192)
+- Fix inference demo (#9153)
+- Add `ignore_key` in VOC `ConcatDataset` (#9058)
+- Fix dumping results issue in test scripts. (#9241)
+- Fix configs of training coco subsets on MMDet 3.x (#9225)
+- Fix corner2hbox of HorizontalBoxes for supporting empty bboxes (#9140)
+
+### Improvements
+
+- Refactor Fast R-CNN (#9132)
+- Clean requirements of mmcv-full due to SyncBN (#9207)
+- Support training detection models in detectron2 (#8672)
+- Add `box_type` support for `DynamicSoftLabelAssigner` (#9179)
+- Make scipy as a default dependency in runtime (#9187)
+- Update eval_metric (#9062)
+- Add `seg_map_suffix` in `BaseDetDataset` (#9088)
+
+### New Contributors
+
+- @Wwupup made their first contribution in 
+- @sanbuphy made their first contribution in 
+- @cxiang26 made their first contribution in 
+- @JosonChan1998 made their first contribution in 
+
+### Contributors
+
+A total of 13 developers contributed to this release.
+
+Thanks @wanghonglie, @Wwupup, @sanbuphy, @BIGWangYuDong, @liuyanyi, @cxiang26, @jbwang1997, @ZwwWayne, @yuyoujiang, @RangiLyu, @hhaAndroid, @JosonChan1998, @Czm369
+
+## v3.0.0rc2 (21/10/2022)
+
+### Highlights
+
+- Support [imagenet pre-training](configs/rtmdet/cspnext_imagenet_pretrain) for RTMDet's backbone
+
+### New Features
+
+- Support [imagenet pre-training](configs/rtmdet/cspnext_imagenet_pretrain) for RTMDet's backbone (#8887)
+- Add `CrowdHumanDataset` and Metric (#8430)
+- Add `FixShapeResize` to support resize of fixed shape (#8665)
+
+### Bug Fixes
+
+- Fix `ConcatDataset` Import Error (#8909)
+- Fix `CircleCI` and `readthedoc` build failed (#8980, #8963)
+- Fix bitmap mask translate when `out_shape` is different (#8993)
+- Fix inconsistency in `Conv2d` weight channels (#8948)
+- Fix bugs when plotting loss curve by analyze_logs.py (#8944)
+- Fix type change of labels in `albumentations` (#9074)
+- Fix some docs and types error (#8818)
+- Update memory occupation of `RTMDet` in metafile (#9098)
+- Fix wrong arguments of `OpenImageMetrics` in the config (#9061)
+
+### Improvements
+
+- Refactor standard roi head with `box type` (#8658)
+- Support mask concatenation in `BitmapMasks` and `PolygonMasks` (#9006)
+- Update PyTorch and dependencies' version in dockerfile (#8845)
+- Update `robustness_eval.py` and `print_config` (#8452)
+- Make compatible with `ConfigDict` and `dict` in `dense_heads` (#8942)
+- Support logging coco metric copypaste (#9012)
+- Remove `Normalize` transform (#8913)
+- Support jittering the color of different instances of the same class (#8988)
+- Add assertion for missing key in `PackDetInputs` (#8982)
+
+### New Contributors
+
+- @Chan-Sun made their first contribution in 
+- @MambaWong made their first contribution in 
+- @yuyoujiang made their first contribution in 
+- @sltlls made their first contribution in 
+- @Nioolek made their first contribution in 
+- @wufan-tb made their first contribution in 
+
+### Contributors
+
+A total of 13 developers contributed to this release.
+
+Thanks @RangiLyu, @jbwang1997, @wanghonglie, @Chan-Sun, @RangeKing, @chhluo, @MambaWong, @yuyoujiang, @hhaAndroid, @sltlls, @Nioolek, @ZwwWayne, @wufan-tb
+
+## v3.0.0rc1 (26/9/2022)
+
+### Highlights
+
+- Release a high-precision, low-latency single-stage object detector [RTMDet](configs/rtmdet).
+
+### Bug Fixes
+
+- Fix UT to be compatible with PyTorch 1.6 (#8707)
+- Fix `NumClassCheckHook` bug when model is wrapped (#8794)
+- Update the right URL of R-50-FPN with BoundedIoULoss (#8805)
+- Fix potential bug of indices in RandAugment (#8826)
+- Fix some types and links (#8839, #8820, #8793, #8868)
+- Fix incorrect background fill values in `FSAF` and `RepPoints` Head (#8813)
+
+### Improvements
+
+- Refactored anchor head and base head with `box type` (#8625)
+- Refactored `SemiBaseDetector` and `SoftTeacher` (#8786)
+- Add list to dict keys to avoid modify loss dict (#8828)
+- Update `analyze_results.py` , `analyze_logs.py` and `loading.py` (#8430, #8402, #8784)
+- Support dump results in `test.py` (#8814)
+- Check empty predictions in `DetLocalVisualizer._draw_instances` (#8830)
+- Fix `floordiv` warning in `SOLO` (#8738)
+
+### Contributors
+
+A total of 16 developers contributed to this release.
+
+Thanks @ZwwWayne, @jbwang1997, @Czm369, @ice-tong, @Zheng-LinXiao, @chhluo, @RangiLyu, @liuyanyi, @wanghonglie, @levan92, @JiayuXu0, @nye0, @hhaAndroid, @xin-li-67, @shuxp, @zytx121
+
+## v3.0.0rc0 (31/8/2022)
+
+We are excited to announce the release of MMDetection 3.0.0rc0. MMDet 3.0.0rc0 is the first version of MMDetection 3.x, a part of the OpenMMLab 2.0 projects. Built upon the new [training engine](https://github.com/open-mmlab/mmengine), MMDet 3.x unifies the interfaces of the dataset, models, evaluation, and visualization with faster training and testing speed. It also provides a general semi-supervised object detection framework and strong baselines.
+
+### Highlights
+
+1. **New engine**. MMDet 3.x is based on [MMEngine](https://github.com/open-mmlab/mmengine), which provides a universal and powerful runner that allows more flexible customizations and significantly simplifies the entry points of high-level interfaces.
+
+2. **Unified interfaces**. As a part of the OpenMMLab 2.0 projects, MMDet 3.x unifies and refactors the interfaces and internal logic of training, testing, datasets, models, evaluation, and visualization. All the OpenMMLab 2.0 projects share the same design in those interfaces and logic to allow the emergence of multi-task/modality algorithms.
+
+3. **Faster speed**. We optimize the training and inference speed for common models and configurations, achieving a faster or similar speed than [Detection2](https://github.com/facebookresearch/detectron2/). Model details of benchmark will be updated in [this note](./benchmark.md#comparison-with-detectron2).
+
+4. **General semi-supervised object detection**. Benefitting from the unified interfaces, we support a general semi-supervised learning framework that works with all the object detectors supported in MMDet 3.x. Please refer to [semi-supervised object detection](../user_guides/semi_det.md) for details.
+
+5. **Strong baselines**. We release strong baselines of many popular models to enable fair comparisons among state-of-the-art models.
+
+6. **New features and algorithms**:
+
+   - Enable all the single-stage detectors to serve as region proposal networks
+   - [SoftTeacher](https://arxiv.org/abs/2106.09018)
+   - [the updated CenterNet](https://arxiv.org/abs/2103.07461)
+
+7. **More documentation and tutorials**. We add a bunch of documentation and tutorials to help users get started more smoothly. Read it [here](https://mmdetection.readthedocs.io/en/3.x/).
+
+### Breaking Changes
+
+MMDet 3.x has undergone significant changes for better design, higher efficiency, more flexibility, and more unified interfaces.
+Besides the changes in API, we briefly list the major breaking changes in this section.
+We will update the [migration guide](../migration.md) to provide complete details and migration instructions.
+Users can also refer to the [API doc](https://mmdetection.readthedocs.io/en/3.x/) for more details.
+
+#### Dependencies
+
+- MMDet 3.x runs on PyTorch>=1.6. We have deprecated the support of PyTorch 1.5 to embrace mixed precision training and other new features since PyTorch 1.6. Some models can still run on PyTorch 1.5, but the full functionality of MMDet 3.x is not guaranteed.
+- MMDet 3.x relies on MMEngine to run. MMEngine is a new foundational library for training deep learning models of OpenMMLab and is the core dependency of OpenMMLab 2.0 projects. The dependencies of file IO and training are migrated from MMCV 1.x to MMEngine.
+- MMDet 3.x relies on MMCV>=2.0.0rc0. Although MMCV no longer maintains the training functionalities since 2.0.0rc0, MMDet 3.x relies on the data transforms, CUDA operators, and image processing interfaces in MMCV. Note that the package `mmcv` is the version that provides pre-built CUDA operators and `mmcv-lite` does not since MMCV 2.0.0rc0, while `mmcv-full` has been deprecated since 2.0.0rc0.
+
+#### Training and testing
+
+- MMDet 3.x uses Runner in [MMEngine](https://github.com/open-mmlab/mmengine) rather than that in MMCV. The new Runner implements and unifies the building logic of the dataset, model, evaluation, and visualizer. Therefore, MMDet 3.x no longer maintains the building logic of those modules in `mmdet.train.apis` and `tools/train.py`. Those codes have been migrated into [MMEngine](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py). Please refer to the [migration guide of Runner in MMEngine](https://mmengine.readthedocs.io/en/latest/migration/runner.html) for more details.
+- The Runner in MMEngine also supports testing and validation. The testing scripts are also simplified, which has similar logic to that in training scripts to build the runner.
+- The execution points of hooks in the new Runner have been enriched to allow more flexible customization. Please refer to the [migration guide of Hook in MMEngine](https://mmengine.readthedocs.io/en/latest/migration/hook.html) for more details.
+- Learning rate and momentum schedules have been migrated from Hook to [Parameter Scheduler in MMEngine](https://mmengine.readthedocs.io/en/latest/tutorials/param_scheduler.html). Please refer to the [migration guide of Parameter Scheduler in MMEngine](https://mmengine.readthedocs.io/en/latest/migration/param_scheduler.html) for more details.
+
+#### Configs
+
+- The [Runner in MMEngine](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py) uses a different config structure to ease the understanding of the components in the runner. Users can read the [config example of MMDet 3.x](../user_guides/config.md) or refer to the [migration guide in MMEngine](https://mmengine.readthedocs.io/en/latest/migration/runner.html) for migration details.
+- The file names of configs and models are also refactored to follow the new rules unified across OpenMMLab 2.0 projects. The names of checkpoints are not updated for now as there is no BC-breaking of model weights between MMDet 3.x and 2.x. We will progressively replace all the model weights with those trained in MMDet 3.x. Please refer to the [user guides of config](../user_guides/config.md) for more details.
+
+#### Dataset
+
+The Dataset classes implemented in MMDet 3.x all inherit from the `BaseDetDataset`, which inherits from the [BaseDataset in MMEngine](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/basedataset.html). In addition to the changes in interfaces, there are several changes in Dataset in MMDet 3.x.
+
+- All the datasets support serializing the internal data list to reduce the memory when multiple workers are built for data loading.
+- The internal data structure in the dataset is changed to be self-contained (without losing information like class names in MMDet 2.x) while keeping simplicity.
+- The evaluation functionality of each dataset has been removed from the dataset so that some specific evaluation metrics like COCO AP can be used to evaluate the prediction on other datasets.
+
+#### Data Transforms
+
+The data transforms in MMDet 3.x all inherits from `BaseTransform` in MMCV>=2.0.0rc0, which defines a new convention in OpenMMLab 2.0 projects.
+Besides the interface changes, there are several changes listed below:
+
+- The functionality of some data transforms (e.g., `Resize`) are decomposed into several transforms to simplify and clarify the usages.
+- The format of data dict processed by each data transform is changed according to the new data structure of dataset.
+- Some inefficient data transforms (e.g., normalization and padding) are moved into data preprocessor of model to improve data loading and training speed.
+- The same data transforms in different OpenMMLab 2.0 libraries have the same augmentation implementation and the logic given the same arguments, i.e., `Resize` in MMDet 3.x and MMSeg 1.x will resize the image in the exact same manner given the same arguments.
+
+#### Model
+
+The models in MMDet 3.x all inherit from `BaseModel` in MMEngine, which defines a new convention of models in OpenMMLab 2.0 projects.
+Users can refer to [the tutorial of the model in MMengine](https://mmengine.readthedocs.io/en/latest/tutorials/model.html) for more details.
+Accordingly, there are several changes as the following:
+
+- The model interfaces, including the input and output formats, are significantly simplified and unified following the new convention in MMDet 3.x.
+  Specifically, all the input data in training and testing are packed into `inputs` and `data_samples`, where `inputs` contains model inputs like a list of image tensors, and `data_samples` contains other information of the current data sample such as ground truths, region proposals, and model predictions. In this way, different tasks in MMDet 3.x can share the same input arguments, which makes the models more general and suitable for multi-task learning and some flexible training paradigms like semi-supervised learning.
+- The model has a data preprocessor module, which is used to pre-process the input data of the model. In MMDet 3.x, the data preprocessor usually does the necessary steps to form the input images into a batch, such as padding. It can also serve as a place for some special data augmentations or more efficient data transformations like normalization.
+- The internal logic of the model has been changed. In MMdet 2.x, model uses `forward_train`, `forward_test`, `simple_test`, and `aug_test` to deal with different model forward logics. In MMDet 3.x and OpenMMLab 2.0, the forward function has three modes: 'loss', 'predict', and 'tensor' for training, inference, and tracing or other purposes, respectively.
+  The forward function calls `self.loss`, `self.predict`, and `self._forward` given the modes 'loss', 'predict', and 'tensor', respectively.
+
+#### Evaluation
+
+The evaluation in MMDet 2.x strictly binds with the dataset. In contrast, MMDet 3.x decomposes the evaluation from dataset so that all the detection datasets can evaluate with COCO AP and other metrics implemented in MMDet 3.x.
+MMDet 3.x mainly implements corresponding metrics for each dataset, which are manipulated by [Evaluator](https://mmengine.readthedocs.io/en/latest/design/evaluator.html) to complete the evaluation.
+Users can build an evaluator in MMDet 3.x to conduct offline evaluation, i.e., evaluate predictions that may not produce in MMDet 3.x with the dataset as long as the dataset and the prediction follow the dataset conventions. More details can be found in the [tutorial in mmengine](https://mmengine.readthedocs.io/en/latest/tutorials/evaluation.html).
+
+#### Visualization
+
+The functions of visualization in MMDet 2.x are removed. Instead, in OpenMMLab 2.0 projects, we use [Visualizer](https://mmengine.readthedocs.io/en/latest/design/visualization.html) to visualize data. MMDet 3.x implements `DetLocalVisualizer` to allow visualization of ground truths, model predictions, feature maps, etc., at any place. It also supports sending the visualization data to any external visualization backends such as Tensorboard.
+
+### Improvements
+
+- Optimized training and testing speed of FCOS, RetinaNet, Faster R-CNN, Mask R-CNN, and Cascade R-CNN. The training speed of those models with some common training strategies is also optimized, including those with synchronized batch normalization and mixed precision training.
+- Support mixed precision training of all the models. However, some models may get undesirable performance due to some numerical issues. We will update the documentation and list the results (accuracy of failure) of mixed precision training.
+- Release strong baselines of some popular object detectors. Their accuracy and pre-trained checkpoints will be released.
+
+### Bug Fixes
+
+- DeepFashion dataset: the config and results have been updated.
+
+### New Features
+
+1. Support a general semi-supervised learning framework that works with all the object detectors supported in MMDet 3.x. Please refer to [semi-supervised object detection](../user_guides/semi_det.md) for details.
+2. Enable all the single-stage detectors to serve as region proposal networks. We give [an example of using FCOS as RPN](../user_guides/single_stage_as_rpn.md).
+3. Support a semi-supervised object detection algorithm: [SoftTeacher](https://arxiv.org/abs/2106.09018).
+4. Support [the updated CenterNet](https://arxiv.org/abs/2103.07461).
+5. Support data structures `HorizontalBoxes` and `BaseBoxes` to encapsulate different kinds of bounding boxes. We are migrating to use data structures of boxes to replace the use of pure tensor boxes. This will unify the usages of different kinds of bounding boxes in MMDet 3.x and MMRotate 1.x to simplify the implementation and reduce redundant codes.
+
+### Planned changes
+
+We list several planned changes of MMDet 3.0.0rc0 so that the community could more comprehensively know the progress of MMDet 3.x. Feel free to create a PR, issue, or discussion if you are interested, have any suggestions and feedback, or want to participate.
+
+1. Test-time augmentation: which is supported in MMDet 2.x, is not implemented in this version due to the limited time slot. We will support it in the following releases with a new and simplified design.
+2. Inference interfaces: unified inference interfaces will be supported in the future to ease the use of released models.
+3. Interfaces of useful tools that can be used in Jupyter Notebook or Colab: more useful tools that are implemented in the `tools` directory will have their python interfaces so that they can be used in Jupyter Notebook, Colab, and downstream libraries.
+4. Documentation: we will add more design docs, tutorials, and migration guidance so that the community can deep dive into our new design, participate the future development, and smoothly migrate downstream libraries to MMDet 3.x.
+5. Wandb visualization: MMDet 2.x supports data visualization since v2.25.0, which has not been migrated to MMDet 3.x for now. Since WandB provides strong visualization and experiment management capabilities, a `DetWandBVisualizer` and maybe a hook are planned to fully migrate those functionalities from MMDet 2.x.
+6. Full support of WiderFace dataset (#8508) and Fast R-CNN: we are verifying their functionalities and will fix related issues soon.
+7. Migrate DETR-series algorithms (#8655, #8533) and YOLOv3 on IPU (#8552) from MMDet 2.x.
+
+### Contributors
+
+A total of 11 developers contributed to this release.
+Thanks @shuxp, @wanghonglie, @Czm369, @BIGWangYuDong, @zytx121, @jbwang1997, @chhluo, @jshilong, @RangiLyu, @hhaAndroid, @ZwwWayne
diff --git a/mmdetection/docs/en/notes/changelog_v2.x.md b/mmdetection/docs/en/notes/changelog_v2.x.md
new file mode 100644
index 00000000..2b3a230c
--- /dev/null
+++ b/mmdetection/docs/en/notes/changelog_v2.x.md
@@ -0,0 +1,1681 @@
+# Changelog v2.x
+
+### v2.25.0 (31/5/2022)
+
+#### Highlights
+
+- Support dedicated `WandbLogger` hook
+- Support [ConvNeXt](configs/convnext), [DDOD](configs/ddod), [SOLOv2](configs/solov2)
+- Support [Mask2Former](configs/mask2former) for instance segmentation
+- Rename [config files of Mask2Former](configs/mask2former)
+
+#### Backwards incompatible changes
+
+- Rename [config files of Mask2Former](configs/mask2former) (#7571)
+
+  
+    
+        
+            
+            
+        
+    
+    
+    
+    
+  
    before v2.25.0after v2.25.0
    
+
+  - `mask2former_xxx_coco.py` represents config files for **panoptic segmentation**.
+
+  
+
+  - `mask2former_xxx_coco.py` represents config files for **instance segmentation**.
+  - `mask2former_xxx_coco-panoptic.py` represents config files for **panoptic segmentation**.
+
+  
    
+
+#### New Features
+
+- Support [ConvNeXt](https://arxiv.org/abs/2201.03545) (#7281)
+- Support [DDOD](https://arxiv.org/abs/2107.02963) (#7279)
+- Support [SOLOv2](https://arxiv.org/abs/2003.10152) (#7441)
+- Support [Mask2Former](https://arxiv.org/abs/2112.01527) for instance segmentation (#7571, #8032)
+
+#### Bug Fixes
+
+- Enable YOLOX training on different devices (#7912)
+- Fix the log plot error when evaluation with `interval != 1` (#7784)
+- Fix RuntimeError of HTC (#8083)
+
+#### Improvements
+
+- Support dedicated `WandbLogger` hook (#7459)
+
+  Users can set
+
+  ```python
+  cfg.log_config.hooks = [
+    dict(type='MMDetWandbHook',
+         init_kwargs={'project': 'MMDetection-tutorial'},
+         interval=10,
+         log_checkpoint=True,
+         log_checkpoint_metadata=True,
+         num_eval_images=10)]
+  ```
+
+  in the config to use `MMDetWandbHook`. Example can be found in this [colab tutorial](https://colab.research.google.com/drive/1RCSXHZwDZvakFh3eo9RuNrJbCGqD0dru?usp=sharing#scrollTo=WTEdPDRaBz2C)
+
+- Add `AvoidOOM` to avoid OOM (#7434, #8091)
+
+  Try to use `AvoidCUDAOOM` to avoid GPU out of memory. It will first retry after calling `torch.cuda.empty_cache()`. If it still fails, it will then retry by converting the type of inputs to FP16 format. If it still fails, it will try to copy inputs from GPUs to CPUs to continue computing. Try AvoidOOM in code to make the code continue to run when GPU memory runs out:
+
+  ```python
+  from mmdet.utils import AvoidCUDAOOM
+
+  output = AvoidCUDAOOM.retry_if_cuda_oom(some_function)(input1, input2)
+  ```
+
+  Users can also try `AvoidCUDAOOM` as a decorator to make the code continue to run when GPU memory runs out:
+
+  ```python
+  from mmdet.utils import AvoidCUDAOOM
+
+  @AvoidCUDAOOM.retry_if_cuda_oom
+  def function(*args, **kwargs):
+      ...
+      return xxx
+  ```
+
+- Support reading `gpu_collect` from `cfg.evaluation.gpu_collect` (#7672)
+
+- Speedup the Video Inference by Accelerating data-loading Stage (#7832)
+
+- Support replacing the `${key}` with the value of `cfg.key` (#7492)
+
+- Accelerate result analysis in `analyze_result.py`. The evaluation time is speedup by 10 ~ 15 times and only tasks 10 ~ 15 minutes now. (#7891)
+
+- Support to set `block_dilations` in `DilatedEncoder` (#7812)
+
+- Support panoptic segmentation result analysis (#7922)
+
+- Release DyHead with Swin-Large backbone (#7733)
+
+- Documentations updating and adding
+
+  - Fix wrong default type of `act_cfg` in `SwinTransformer` (#7794)
+  - Fix text errors in the tutorials (#7959)
+  - Rewrite the [installation guide](docs/en/get_started.md) (#7897)
+  - [Useful hooks](docs/en/tutorials/useful_hooks.md) (#7810)
+  - Fix heading anchor in documentation  (#8006)
+  - Replace `markdownlint` with `mdformat` for avoiding installing ruby (#8009)
+
+#### Contributors
+
+A total of 20 developers contributed to this release.
+
+Thanks @ZwwWayne, @DarthThomas, @solyaH, @LutingWang, @chenxinfeng4, @Czm369, @Chenastron, @chhluo, @austinmw, @Shanyaliux @hellock, @Y-M-Y, @jbwang1997, @hhaAndroid, @Irvingao, @zhanggefan, @BIGWangYuDong, @Keiku, @PeterVennerstrom, @ayulockin
+
+### v2.24.0 (26/4/2022)
+
+#### Highlights
+
+- Support [Simple Copy-Paste is a Strong Data Augmentation Method for Instance Segmentation](https://arxiv.org/abs/2012.07177)
+- Support automatically scaling LR according to GPU number and samples per GPU
+- Support Class Aware Sampler that improves performance on OpenImages Dataset
+
+#### New Features
+
+- Support [Simple Copy-Paste is a Strong Data Augmentation Method for Instance Segmentation](https://arxiv.org/abs/2012.07177), see [example configs](configs/simple_copy_paste/mask_rcnn_r50_fpn_syncbn-all_rpn-2conv_ssj_scp_32x2_270k_coco.py) (#7501)
+
+- Support Class Aware Sampler, users can set
+
+  ```python
+  data=dict(train_dataloader=dict(class_aware_sampler=dict(num_sample_class=1))))
+  ```
+
+  in the config to use `ClassAwareSampler`. Examples can be found in [the configs of OpenImages Dataset](https://github.com/open-mmlab/mmdetection/tree/main/configs/openimages/faster_rcnn_r50_fpn_32x2_cas_1x_openimages.py).  (#7436)
+
+- Support automatically scaling LR according to GPU number and samples per GPU. (#7482)
+  In each config, there is a corresponding config of auto-scaling LR as below,
+
+  ```python
+  auto_scale_lr = dict(enable=True, base_batch_size=N)
+  ```
+
+  where `N` is the batch size used for the current learning rate in the config (also equals to `samples_per_gpu` * gpu number to train this config).
+  By default, we set `enable=False` so that the original usages will not be affected. Users can set `enable=True` in each config or add `--auto-scale-lr` after the command line to enable this feature and should check the correctness of `base_batch_size` in customized configs.
+
+- Support setting dataloader arguments in config and add functions to handle config compatibility. (#7668)
+  The comparison between the old and new usages is as below.
+
+  
+    
+        
+            
+            
+        
+    
+    
+    
+    
+  
    v2.23.0v2.24.0
    
+
+  ```python
+  data = dict(
+      samples_per_gpu=64, workers_per_gpu=4,
+      train=dict(type='xxx', ...),
+      val=dict(type='xxx', samples_per_gpu=4, ...),
+      test=dict(type='xxx', ...),
+  )
+  ```
+
+  
+
+  ```python
+  # A recommended config that is clear
+  data = dict(
+      train=dict(type='xxx', ...),
+      val=dict(type='xxx', ...),
+      test=dict(type='xxx', ...),
+      # Use different batch size during inference.
+      train_dataloader=dict(samples_per_gpu=64, workers_per_gpu=4),
+      val_dataloader=dict(samples_per_gpu=8, workers_per_gpu=2),
+      test_dataloader=dict(samples_per_gpu=8, workers_per_gpu=2),
+  )
+
+  # Old style still works but allows to set more arguments about data loaders
+  data = dict(
+      samples_per_gpu=64,  # only works for train_dataloader
+      workers_per_gpu=4,  # only works for train_dataloader
+      train=dict(type='xxx', ...),
+      val=dict(type='xxx', ...),
+      test=dict(type='xxx', ...),
+      # Use different batch size during inference.
+      val_dataloader=dict(samples_per_gpu=8, workers_per_gpu=2),
+      test_dataloader=dict(samples_per_gpu=8, workers_per_gpu=2),
+  )
+  ```
+
+  
    
+
+- Support memory profile hook. Users can use it to monitor the memory usages during training as below (#7560)
+
+  ```python
+  custom_hooks = [
+      dict(type='MemoryProfilerHook', interval=50)
+  ]
+  ```
+
+- Support to run on PyTorch with MLU chip (#7578)
+
+- Support re-spliting data batch with tag (#7641)
+
+- Support the `DiceCost` used by [K-Net](https://arxiv.org/abs/2106.14855) in `MaskHungarianAssigner` (#7716)
+
+- Support splitting COCO data for Semi-supervised object detection (#7431)
+
+- Support Pathlib for Config.fromfile (#7685)
+
+- Support to use file client in OpenImages dataset (#7433)
+
+- Add a probability parameter to Mosaic transformation (#7371)
+
+- Support specifying interpolation mode in `Resize` pipeline (#7585)
+
+#### Bug Fixes
+
+- Avoid invalid bbox after deform_sampling (#7567)
+- Fix the issue that argument color_theme does not take effect when exporting confusion matrix (#7701)
+- Fix the `end_level` in Necks, which should be the index of the end input backbone level (#7502)
+- Fix the bug that `mix_results` may be None in `MultiImageMixDataset` (#7530)
+- Fix the bug in ResNet plugin when two plugins are used (#7797)
+
+#### Improvements
+
+- Enhance `load_json_logs` of analyze_logs.py for resumed training logs (#7732)
+- Add argument `out_file` in image_demo.py (#7676)
+- Allow mixed precision training with `SimOTAAssigner` (#7516)
+- Updated INF to 100000.0 to be the same as that in the official YOLOX (#7778)
+- Add documentations of:
+  - how to get channels of a new backbone (#7642)
+  - how to unfreeze the backbone network (#7570)
+  - how to train fast_rcnn model (#7549)
+  - proposals in Deformable DETR (#7690)
+  - from-scratch install script in get_started.md (#7575)
+- Release pre-trained models of
+  - [Mask2Former](configs/mask2former) (#7595, #7709)
+  - RetinaNet with ResNet-18 and release models (#7387)
+  - RetinaNet with EfficientNet backbone (#7646)
+
+#### Contributors
+
+A total of 27 developers contributed to this release.
+Thanks @jovialio, @zhangsanfeng2022, @HarryZJ, @jamiechoi1995, @nestiank, @PeterH0323, @RangeKing, @Y-M-Y, @mattcasey02, @weiji14, @Yulv-git, @xiefeifeihu, @FANG-MING, @meng976537406, @nijkah, @sudz123, @CCODING04, @SheffieldCao, @Czm369, @BIGWangYuDong, @zytx121, @jbwang1997, @chhluo, @jshilong, @RangiLyu, @hhaAndroid, @ZwwWayne
+
+### v2.23.0 (28/3/2022)
+
+#### Highlights
+
+- Support Mask2Former: [Masked-attention Mask Transformer for Universal Image Segmentation](https://arxiv.org/abs/2112.01527)
+- Support EfficientNet: [EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks](https://arxiv.org/abs/1905.11946)
+- Support setting data root through environment variable `MMDET_DATASETS`, users don't have to modify the corresponding path in config files anymore.
+- Find a good recipe for fine-tuning high precision ResNet backbone pre-trained by Torchvision.
+
+#### New Features
+
+- Support [Mask2Former](configs/mask2former)(#6938)(#7466)(#7471)
+- Support [EfficientNet](configs/efficientnet) (#7514)
+- Support setting data root through environment variable `MMDET_DATASETS`, users don't have to modify the corresponding path in config files anymore. (#7386)
+- Support setting different seeds to different ranks (#7432)
+- Update the `dist_train.sh` so that the script can be used to support launching multi-node training on machines without slurm (#7415)
+- Find a good recipe for fine-tuning high precision ResNet backbone pre-trained by Torchvision (#7489)
+
+#### Bug Fixes
+
+- Fix bug in VOC unit test which removes the data directory (#7270)
+- Adjust the order of `get_classes` and `FileClient` (#7276)
+- Force the inputs of `get_bboxes` in yolox_head to float32 (#7324)
+- Fix misplaced arguments in LoadPanopticAnnotations (#7388)
+- Fix reduction=mean in CELoss. (#7449)
+- Update unit test of CrossEntropyCost (#7537)
+- Fix memory leaking in panpotic segmentation evaluation (#7538)
+- Fix the bug of shape broadcast in YOLOv3 (#7551)
+
+#### Improvements
+
+- Add Chinese version of onnx2tensorrt.md (#7219)
+- Update colab tutorials (#7310)
+- Update information about Localization Distillation (#7350)
+- Add Chinese version of `finetune.md` (#7178)
+- Update YOLOX log for non square input (#7235)
+- Add `nproc` in `coco_panoptic.py` for panoptic quality computing (#7315)
+- Allow to set channel_order in LoadImageFromFile (#7258)
+- Take point sample related functions out of mask_point_head (#7353)
+- Add instance evaluation for coco_panoptic (#7313)
+- Enhance the robustness of analyze_logs.py (#7407)
+- Supplementary notes of sync_random_seed (#7440)
+- Update docstring of cross entropy loss (#7472)
+- Update pascal voc result (#7503)
+- We create How-to documentation to record any questions about How to xxx. In this version, we added
+  - How to use Mosaic augmentation (#7507)
+  - How to use backbone in mmcls (#7438)
+  - How to produce and submit the prediction results of panoptic segmentation models on COCO test-dev set (#7430))
+
+#### Contributors
+
+A total of 27 developers contributed to this release.
+Thanks @ZwwWayne, @haofanwang, @shinya7y, @chhluo, @yangrisheng, @triple-Mu, @jbwang1997, @HikariTJU, @imflash217, @274869388, @zytx121, @matrixgame2018, @jamiechoi1995, @BIGWangYuDong, @JingweiZhang12, @Xiangxu-0103, @hhaAndroid, @jshilong, @osbm, @ceroytres, @bunge-bedstraw-herb, @Youth-Got, @daavoo, @jiangyitong, @RangiLyu, @CCODING04, @yarkable
+
+### v2.22.0 (24/2/2022)
+
+#### Highlights
+
+- Support MaskFormer: [Per-Pixel Classification is Not All You Need for Semantic Segmentation](https://arxiv.org/abs/2107.06278) (#7212)
+- Support DyHead: [Dynamic Head: Unifying Object Detection Heads with Attentions](https://arxiv.org/abs/2106.08322) (#6823)
+- Release a good recipe of using ResNet in object detectors pre-trained by [ResNet Strikes Back](https://arxiv.org/abs/2110.00476), which consistently brings about 3~4 mAP improvements over RetinaNet, Faster/Mask/Cascade Mask R-CNN (#7001)
+- Support [Open Images Dataset](https://storage.googleapis.com/openimages/web/index.html) (#6331)
+- Support TIMM backbone: [PyTorch Image Models](https://github.com/rwightman/pytorch-image-models) (#7020)
+
+#### New Features
+
+- Support [MaskFormer](configs/maskformer) (#7212)
+- Support [DyHead](configs/dyhead) (#6823)
+- Support [ResNet Strikes Back](configs/resnet_strikes_back) (#7001)
+- Support [OpenImages Dataset](configs/openimages) (#6331)
+- Support [TIMM backbone](configs/timm_example) (#7020)
+- Support visualization for Panoptic Segmentation (#7041)
+
+#### Breaking Changes
+
+In order to support the visualization for Panoptic Segmentation, the `num_classes` can not be `None` when using the `get_palette` function to determine whether to use the panoptic palette.
+
+#### Bug Fixes
+
+- Fix bug for the best checkpoints can not be saved when the `key_score` is None (#7101)
+- Fix MixUp transform filter boxes failing case (#7080)
+- Add missing properties in SABLHead (#7091)
+- Fix bug when NaNs exist in confusion matrix (#7147)
+- Fix PALETTE AttributeError in downstream task (#7230)
+
+#### Improvements
+
+- Speed up SimOTA matching (#7098)
+- Add Chinese translation of `docs_zh-CN/tutorials/init_cfg.md` (#7188)
+
+#### Contributors
+
+A total of 20 developers contributed to this release.
+Thanks @ZwwWayne, @hhaAndroid, @RangiLyu, @AronLin, @BIGWangYuDong, @jbwang1997, @zytx121, @chhluo, @shinya7y, @LuooChen, @dvansa, @siatwangmin, @del-zhenwu, @vikashranjan26, @haofanwang, @jamiechoi1995, @HJoonKwon, @yarkable, @zhijian-liu, @RangeKing
+
+### v2.21.0 (8/2/2022)
+
+### Breaking Changes
+
+To standardize the contents in config READMEs and meta files of OpenMMLab projects, the READMEs and meta files in each config directory have been significantly changed. The template will be released in the future, for now, you can refer to the examples of README for [algorithm](https://github.com/open-mmlab/mmdetection/blob/master/configs/faster_rcnn/README.md), [dataset](https://github.com/open-mmlab/mmdetection/blob/master/configs/deepfashion/README.md) and [backbone](https://github.com/open-mmlab/mmdetection/blob/master/configs/regnet/README.md). To align with the standard, the configs in dcn are put into to two directories named `dcn` and `dcnv2`.
+
+#### New Features
+
+- Allow to customize colors of different classes during visualization (#6716)
+- Support CPU training (#7016)
+- Add download script of COCO, LVIS, and VOC dataset (#7015)
+
+#### Bug Fixes
+
+- Fix weight conversion issue of RetinaNet with Swin-S (#6973)
+- Update `__repr__` of `Compose` (#6951)
+- Fix BadZipFile Error when build docker (#6966)
+- Fix bug in non-distributed multi-gpu training/testing (#7019)
+- Fix bbox clamp in PyTorch 1.10 (#7074)
+- Relax the requirement of PALETTE in dataset wrappers (#7085)
+- Keep the same weights before reassign in the PAA head (#7032)
+- Update code demo in doc (#7092)
+
+#### Improvements
+
+- Speed-up training by allow to set variables of multi-processing (#6974, #7036)
+- Add links of Chinese tutorials in readme (#6897)
+- Disable cv2 multiprocessing by default for acceleration (#6867)
+- Deprecate the support for "python setup.py test" (#6998)
+- Re-organize metafiles and config readmes (#7051)
+- Fix None grad problem during training TOOD by adding `SigmoidGeometricMean` (#7090)
+
+#### Contributors
+
+A total of 26 developers contributed to this release.
+Thanks @del-zhenwu, @zimoqingfeng, @srishilesh, @imyhxy, @jenhaoyang, @jliu-ac, @kimnamu, @ShengliLiu, @garvan2021, @ciusji, @DIYer22, @kimnamu, @q3394101, @zhouzaida, @gaotongxiao, @topsy404, @AntoAndGar, @jbwang1997, @nijkah, @ZwwWayne, @Czm369, @jshilong, @RangiLyu, @BIGWangYuDong, @hhaAndroid, @AronLin
+
+### v2.20.0 (27/12/2021)
+
+#### New Features
+
+- Support [TOOD](configs/tood/README.md): Task-aligned One-stage Object Detection (ICCV 2021 Oral) (#6746)
+- Support resuming from the latest checkpoint automatically (#6727)
+
+#### Bug Fixes
+
+- Fix wrong bbox `loss_weight` of the PAA head (#6744)
+- Fix the padding value of `gt_semantic_seg` in batch collating (#6837)
+- Fix test error of lvis when using `classwise` (#6845)
+- Avoid BC-breaking of `get_local_path`  (#6719)
+- Fix bug in `sync_norm_hook` when the BN layer does not exist (#6852)
+- Use pycocotools directly no matter what platform it is (#6838)
+
+#### Improvements
+
+- Add unit test for SimOTA with no valid bbox (#6770)
+- Use precommit to check readme (#6802)
+- Support selecting GPU-ids in non-distributed testing time (#6781)
+
+#### Contributors
+
+A total of 16 developers contributed to this release.
+Thanks @ZwwWayne, @Czm369, @jshilong, @RangiLyu, @BIGWangYuDong, @hhaAndroid, @jamiechoi1995, @AronLin, @Keiku, @gkagkos, @fcakyon, @www516717402, @vansin, @zactodd, @kimnamu, @jenhaoyang
+
+### v2.19.1 (14/12/2021)
+
+#### New Features
+
+- Release [YOLOX](configs/yolox/README.md) COCO pretrained models (#6698)
+
+#### Bug Fixes
+
+- Fix DCN initialization in DenseHead (#6625)
+- Fix initialization of ConvFCHead (#6624)
+- Fix PseudoSampler in RCNN (#6622)
+- Fix weight initialization in Swin and PVT (#6663)
+- Fix dtype bug in BaseDenseHead (#6767)
+- Fix SimOTA with no valid bbox (#6733)
+
+#### Improvements
+
+- Add an example of combining swin and one-stage models (#6621)
+- Add `get_ann_info` to dataset_wrappers (#6526)
+- Support keeping image ratio in the multi-scale training of YOLOX (#6732)
+- Support `bbox_clip_border` for the augmentations of YOLOX (#6730)
+
+#### Documents
+
+- Update metafile (#6717)
+- Add mmhuman3d in readme (#6699)
+- Update FAQ docs (#6587)
+- Add doc for `detect_anomalous_params` (#6697)
+
+#### Contributors
+
+A total of 11 developers contributed to this release.
+Thanks @ZwwWayne, @LJoson, @Czm369, @jshilong, @ZCMax, @RangiLyu, @BIGWangYuDong, @hhaAndroid, @zhaoxin111, @GT9505, @shinya7y
+
+### v2.19.0 (29/11/2021)
+
+#### Highlights
+
+- Support [Label Assignment Distillation](https://arxiv.org/abs/2108.10520)
+- Support `persistent_workers` for Pytorch >= 1.7
+- Align accuracy to the updated official YOLOX
+
+#### New Features
+
+- Support [Label Assignment Distillation](https://arxiv.org/abs/2108.10520) (#6342)
+- Support `persistent_workers` for Pytorch >= 1.7 (#6435)
+
+#### Bug Fixes
+
+- Fix repeatedly output warning message (#6584)
+- Avoid infinite GPU waiting in dist training (#6501)
+- Fix SSD512 config error (#6574)
+- Fix MMDetection model to ONNX command (#6558)
+
+#### Improvements
+
+- Refactor configs of FP16 models (#6592)
+- Align accuracy to the updated official YOLOX (#6443)
+- Speed up training and reduce memory cost when using PhotoMetricDistortion. (#6442)
+- Make OHEM work with seesaw loss (#6514)
+
+#### Documents
+
+- Update README.md (#6567)
+
+#### Contributors
+
+A total of 11 developers contributed to this release.
+Thanks @FloydHsiu, @RangiLyu, @ZwwWayne, @AndreaPi, @st9007a, @hachreak, @BIGWangYuDong, @hhaAndroid, @AronLin, @chhluo, @vealocia, @HarborYuan, @st9007a, @jshilong
+
+### v2.18.1 (15/11/2021)
+
+#### Highlights
+
+- Release [QueryInst](http://arxiv.org/abs/2105.01928) pre-trained weights (#6460)
+- Support plot confusion matrix (#6344)
+
+#### New Features
+
+- Release [QueryInst](http://arxiv.org/abs/2105.01928) pre-trained weights (#6460)
+- Support plot confusion matrix (#6344)
+
+#### Bug Fixes
+
+- Fix aug test error when the number of prediction bboxes is 0 (#6398)
+- Fix SpatialReductionAttention in PVT (#6488)
+- Fix wrong use of `trunc_normal_init` in PVT and Swin-Transformer (#6432)
+
+#### Improvements
+
+- Save the printed AP information of COCO API to logger (#6505)
+- Always map location to cpu when load checkpoint (#6405)
+- Set a random seed when the user does not set a seed (#6457)
+
+#### Documents
+
+- Chinese version of [Corruption Benchmarking](robustness_benchmarking.md) (#6375)
+- Fix config path in docs (#6396)
+- Update GRoIE readme (#6401)
+
+#### Contributors
+
+A total of 11 developers contributed to this release.
+Thanks @st9007a, @hachreak, @HarborYuan, @vealocia, @chhluo, @AndreaPi, @AronLin, @BIGWangYuDong, @hhaAndroid, @RangiLyu, @ZwwWayne
+
+### v2.18.0 (27/10/2021)
+
+#### Highlights
+
+- Support [QueryInst](http://arxiv.org/abs/2105.01928) (#6050)
+- Refactor dense heads to decouple onnx export logics from `get_bboxes` and speed up inference (#5317, #6003, #6369, #6268, #6315)
+
+#### New Features
+
+- Support [QueryInst](http://arxiv.org/abs/2105.01928) (#6050)
+- Support infinite sampler (#5996)
+
+#### Bug Fixes
+
+- Fix init_weight in fcn_mask_head (#6378)
+- Fix type error in imshow_bboxes of RPN (#6386)
+- Fix broken colab link in MMDetection Tutorial (#6382)
+- Make sure the device and dtype of scale_factor are the same as bboxes (#6374)
+- Remove sampling hardcode (#6317)
+- Fix RandomAffine bbox coordinate recorrection (#6293)
+- Fix init bug of final cls/reg layer in convfc head (#6279)
+- Fix img_shape broken in auto_augment (#6259)
+- Fix kwargs parameter missing error in two_stage (#6256)
+
+#### Improvements
+
+- Unify the interface of stuff head and panoptic head (#6308)
+- Polish readme (#6243)
+- Add code-spell pre-commit hook and fix a typo (#6306)
+- Fix typo (#6245, #6190)
+- Fix sampler unit test (#6284)
+- Fix `forward_dummy` of YOLACT to enable `get_flops` (#6079)
+- Fix link error in the config documentation (#6252)
+- Adjust the order to beautify the document (#6195)
+
+#### Refactors
+
+- Refactor one-stage get_bboxes logic (#5317)
+- Refactor ONNX export of One-Stage models (#6003, #6369)
+- Refactor dense_head and speedup (#6268)
+- Migrate to use prior_generator in training of dense heads (#6315)
+
+#### Contributors
+
+A total of 18 developers contributed to this release.
+Thanks @Boyden, @onnkeat, @st9007a, @vealocia, @yhcao6, @DapangpangX, @yellowdolphin, @cclauss, @kennymckormick,
+@pingguokiller, @collinzrj, @AndreaPi, @AronLin, @BIGWangYuDong, @hhaAndroid, @jshilong, @RangiLyu, @ZwwWayne
+
+### v2.17.0 (28/9/2021)
+
+#### Highlights
+
+- Support [PVT](https://arxiv.org/abs/2102.12122) and [PVTv2](https://arxiv.org/abs/2106.13797)
+- Support [SOLO](https://arxiv.org/abs/1912.04488)
+- Support large scale jittering and New Mask R-CNN baselines
+- Speed up `YOLOv3` inference
+
+#### New Features
+
+- Support [PVT](https://arxiv.org/abs/2102.12122) and [PVTv2](https://arxiv.org/abs/2106.13797) (#5780)
+- Support [SOLO](https://arxiv.org/abs/1912.04488) (#5832)
+- Support large scale jittering and New Mask R-CNN baselines (#6132)
+- Add a general data structure for the results of models (#5508)
+- Added a base class for one-stage instance segmentation (#5904)
+- Speed up `YOLOv3` inference (#5991)
+- Release Swin Transformer pre-trained models (#6100)
+- Support mixed precision training in `YOLOX` (#5983)
+- Support `val` workflow in `YOLACT` (#5986)
+- Add script to test `torchserve` (#5936)
+- Support `onnxsim` with dynamic input shape (#6117)
+
+#### Bug Fixes
+
+- Fix the function naming errors in `model_wrappers` (#5975)
+- Fix regression loss bug when the input is an empty tensor (#5976)
+- Fix scores not contiguous error in `centernet_head` (#6016)
+- Fix missing parameters bug in `imshow_bboxes` (#6034)
+- Fix bug in `aug_test` of `HTC` when the length of `det_bboxes` is 0 (#6088)
+- Fix empty proposal errors in the training of some two-stage models (#5941)
+- Fix `dynamic_axes` parameter error in `ONNX` dynamic shape export (#6104)
+- Fix `dynamic_shape` bug of `SyncRandomSizeHook` (#6144)
+- Fix the Swin Transformer config link error in the configuration (#6172)
+
+#### Improvements
+
+- Add filter rules in `Mosaic` transform (#5897)
+- Add size divisor in get flops to avoid some potential bugs (#6076)
+- Add Chinese translation of `docs_zh-CN/tutorials/customize_dataset.md` (#5915)
+- Add Chinese translation of `conventions.md` (#5825)
+- Add description of the output of data pipeline (#5886)
+- Add dataset information in the README file for `PanopticFPN` (#5996)
+- Add `extra_repr` for `DropBlock` layer to get details in the model printing (#6140)
+- Fix CI out of memory and add PyTorch1.9 Python3.9 unit tests (#5862)
+- Fix download links error of some model (#6069)
+- Improve the generalization of XML dataset (#5943)
+- Polish assertion error messages (#6017)
+- Remove `opencv-python-headless` dependency by `albumentations` (#5868)
+- Check dtype in transform unit tests (#5969)
+- Replace the default theme of documentation with PyTorch Sphinx Theme (#6146)
+- Update the paper and code fields in the metafile (#6043)
+- Support to customize padding value of segmentation map (#6152)
+- Support to resize multiple segmentation maps (#5747)
+
+#### Contributors
+
+A total of 24 developers contributed to this release.
+Thanks @morkovka1337, @HarborYuan, @guillaumefrd, @guigarfr, @www516717402, @gaotongxiao, @ypwhs, @MartaYang, @shinya7y, @justiceeem, @zhaojinjian0000, @VVsssssk, @aravind-anantha, @wangbo-zhao, @czczup, @whai362, @czczup, @marijnl, @AronLin, @BIGWangYuDong, @hhaAndroid, @jshilong, @RangiLyu, @ZwwWayne
+
+### v2.16.0 (30/8/2021)
+
+#### Highlights
+
+- Support [Panoptic FPN](https://arxiv.org/abs/1901.02446) and [Swin Transformer](https://arxiv.org/abs/2103.14030)
+
+#### New Features
+
+- Support [Panoptic FPN](https://arxiv.org/abs/1901.02446) and release models (#5577, #5902)
+- Support Swin Transformer backbone (#5748)
+- Release RetinaNet models pre-trained with multi-scale 3x schedule (#5636)
+- Add script to convert unlabeled image list to coco format (#5643)
+- Add hook to check whether the loss value is valid (#5674)
+- Add YOLO anchor optimizing tool (#5644)
+- Support export onnx models without post process. (#5851)
+- Support classwise evaluation in CocoPanopticDataset (#5896)
+- Adapt browse_dataset for concatenated datasets. (#5935)
+- Add `PatchEmbed` and `PatchMerging` with `AdaptivePadding` (#5952)
+
+#### Bug Fixes
+
+- Fix unit tests of YOLOX (#5859)
+- Fix lose randomness in `imshow_det_bboxes` (#5845)
+- Make output result of `ImageToTensor` contiguous (#5756)
+- Fix inference bug when calling `regress_by_class` in RoIHead in some cases (#5884)
+- Fix bug in CIoU loss where alpha should not have gradient. (#5835)
+- Fix the bug that `multiscale_output` is defined but not used in HRNet (#5887)
+- Set the priority of EvalHook to LOW. (#5882)
+- Fix a YOLOX bug when applying bbox rescaling in test mode (#5899)
+- Fix mosaic coordinate error (#5947)
+- Fix dtype of bbox in RandomAffine. (#5930)
+
+#### Improvements
+
+- Add Chinese version of `data_pipeline` and  (#5662)
+- Support to remove state dicts of EMA when publishing models. (#5858)
+- Refactor the loss function in HTC and SCNet (#5881)
+- Use warnings instead of logger.warning (#5540)
+- Use legacy coordinate in metric of VOC (#5627)
+- Add Chinese version of customize_losses (#5826)
+- Add Chinese version of model_zoo (#5827)
+
+#### Contributors
+
+A total of 19 developers contributed to this release.
+Thanks @ypwhs, @zywvvd, @collinzrj, @OceanPang, @ddonatien, @@haotian-liu, @viibridges, @Muyun99, @guigarfr, @zhaojinjian0000, @jbwang1997,@wangbo-zhao, @xvjiarui, @RangiLyu, @jshilong, @AronLin, @BIGWangYuDong, @hhaAndroid, @ZwwWayne
+
+### v2.15.1 (11/8/2021)
+
+#### Highlights
+
+- Support [YOLOX](https://arxiv.org/abs/2107.08430)
+
+#### New Features
+
+- Support [YOLOX](https://arxiv.org/abs/2107.08430)(#5756, #5758, #5760, #5767, #5770, #5774, #5777, #5808, #5828, #5848)
+
+#### Bug Fixes
+
+- Update correct SSD models. (#5789)
+- Fix casting error in mask structure (#5820)
+- Fix MMCV deployment documentation links. (#5790)
+
+#### Improvements
+
+- Use dynamic MMCV download link in TorchServe dockerfile (#5779)
+- Rename the function `upsample_like` to `interpolate_as` for more general usage (#5788)
+
+#### Contributors
+
+A total of 14 developers contributed to this release.
+Thanks @HAOCHENYE, @xiaohu2015, @HsLOL, @zhiqwang, @Adamdad, @shinya7y, @Johnson-Wang, @RangiLyu, @jshilong, @mmeendez8, @AronLin, @BIGWangYuDong, @hhaAndroid, @ZwwWayne
+
+### v2.15.0 (02/8/2021)
+
+#### Highlights
+
+- Support adding [MIM](https://github.com/open-mmlab/mim) dependencies during pip installation
+- Support MobileNetV2 for SSD-Lite and YOLOv3
+- Support Chinese Documentation
+
+#### New Features
+
+- Add function `upsample_like` (#5732)
+- Support to output pdf and epub format documentation (#5738)
+- Support and release Cascade Mask R-CNN 3x pre-trained models (#5645)
+- Add `ignore_index` to CrossEntropyLoss (#5646)
+- Support adding [MIM](https://github.com/open-mmlab/mim) dependencies during pip installation (#5676)
+- Add MobileNetV2 config and models for YOLOv3 (#5510)
+- Support COCO Panoptic Dataset (#5231)
+- Support ONNX export of cascade models (#5486)
+- Support DropBlock with RetinaNet (#5544)
+- Support MobileNetV2 SSD-Lite (#5526)
+
+#### Bug Fixes
+
+- Fix the device of label in multiclass_nms (#5673)
+- Fix error of backbone initialization from pre-trained checkpoint in config file (#5603, #5550)
+- Fix download links of RegNet pretrained weights (#5655)
+- Fix two-stage runtime error given empty proposal (#5559)
+- Fix flops count error in DETR (#5654)
+- Fix unittest for `NumClassCheckHook` when it is not used. (#5626)
+- Fix description bug of using custom dataset (#5546)
+- Fix bug of `multiclass_nms` that returns the global indices (#5592)
+- Fix `valid_mask` logic error in RPNHead (#5562)
+- Fix unit test error of pretrained configs (#5561)
+- Fix typo error in anchor_head.py (#5555)
+- Fix bug when using dataset wrappers (#5552)
+- Fix a typo error in demo/MMDet_Tutorial.ipynb (#5511)
+- Fixing crash in `get_root_logger` when `cfg.log_level` is not None (#5521)
+- Fix docker version (#5502)
+- Fix optimizer parameter error when using `IterBasedRunner` (#5490)
+
+#### Improvements
+
+- Add unit tests for MMTracking (#5620)
+- Add Chinese translation of documentation (#5718, #5618, #5558, #5423, #5593, #5421, #5408. #5369, #5419, #5530, #5531)
+- Update resource limit (#5697)
+- Update docstring for InstaBoost (#5640)
+- Support key `reduction_override` in all loss functions (#5515)
+- Use repeatdataset to accelerate CenterNet training (#5509)
+- Remove unnecessary code in autoassign (#5519)
+- Add documentation about `init_cfg` (#5273)
+
+#### Contributors
+
+A total of 18 developers contributed to this release.
+Thanks @OceanPang, @AronLin, @hellock, @Outsider565, @RangiLyu, @ElectronicElephant, @likyoo, @BIGWangYuDong, @hhaAndroid, @noobying, @yyz561, @likyoo,
+@zeakey, @ZwwWayne, @ChenyangLiu, @johnson-magic, @qingswu, @BuxianChen
+
+### v2.14.0 (29/6/2021)
+
+#### Highlights
+
+- Add `simple_test` to dense heads to improve the consistency of single-stage and two-stage detectors
+- Revert the `test_mixins` to single image test to improve efficiency and readability
+- Add Faster R-CNN and Mask R-CNN config using multi-scale training with 3x schedule
+
+#### New Features
+
+- Support pretrained models from MoCo v2 and SwAV (#5286)
+- Add Faster R-CNN and Mask R-CNN config using multi-scale training with 3x schedule (#5179, #5233)
+- Add `reduction_override` in MSELoss (#5437)
+- Stable support of exporting DETR to ONNX with dynamic shapes and batch inference (#5168)
+- Stable support of exporting PointRend to ONNX with dynamic shapes and batch inference (#5440)
+
+#### Bug Fixes
+
+- Fix size mismatch bug in `multiclass_nms` (#4980)
+- Fix the import path of `MultiScaleDeformableAttention` (#5338)
+- Fix errors in config of GCNet ResNext101 models (#5360)
+- Fix Grid-RCNN error when there is no bbox result (#5357)
+- Fix errors in `onnx_export` of bbox_head when setting reg_class_agnostic (#5468)
+- Fix type error of AutoAssign in the document (#5478)
+- Fix web links ending with `.md` (#5315)
+
+#### Improvements
+
+- Add `simple_test` to dense heads to improve the consistency of single-stage and two-stage detectors (#5264)
+- Add support for mask diagonal flip in TTA (#5403)
+- Revert the `test_mixins` to single image test to improve efficiency and readability (#5249)
+- Make YOLOv3 Neck more flexible (#5218)
+- Refactor SSD to make it more general (#5291)
+- Refactor `anchor_generator` and `point_generator` (#5349)
+- Allow to configure out the `mask_head` of the HTC algorithm (#5389)
+- Delete deprecated warning in FPN (#5311)
+- Move `model.pretrained` to `model.backbone.init_cfg` (#5370)
+- Make deployment tools more friendly to use (#5280)
+- Clarify installation documentation (#5316)
+- Add ImageNet Pretrained Models docs (#5268)
+- Add FAQ about training loss=nan solution and COCO AP or AR =-1 (# 5312, #5313)
+- Change all weight links of http to https (#5328)
+
+### v2.13.0 (01/6/2021)
+
+#### Highlights
+
+- Support new methods: [CenterNet](https://arxiv.org/abs/1904.07850), [Seesaw Loss](https://arxiv.org/abs/2008.10032), [MobileNetV2](https://arxiv.org/abs/1801.04381)
+
+#### New Features
+
+- Support paper [Objects as Points](https://arxiv.org/abs/1904.07850) (#4602)
+- Support paper [Seesaw Loss for Long-Tailed Instance Segmentation (CVPR 2021)](https://arxiv.org/abs/2008.10032) (#5128)
+- Support [MobileNetV2](https://arxiv.org/abs/1801.04381) backbone and inverted residual block (#5122)
+- Support [MIM](https://github.com/open-mmlab/mim) (#5143)
+- ONNX exportation with dynamic shapes of CornerNet (#5136)
+- Add `mask_soft` config option to allow non-binary masks (#4615)
+- Add PWC metafile (#5135)
+
+#### Bug Fixes
+
+- Fix YOLOv3 FP16 training error (#5172)
+- Fix Cacscade R-CNN TTA test error when `det_bboxes` length is 0  (#5221)
+- Fix `iou_thr` variable naming errors in VOC recall calculation function (#5195)
+- Fix Faster R-CNN performance dropped in ONNX Runtime (#5197)
+- Fix DETR dict changed error when using python 3.8 during iteration  (#5226)
+
+#### Improvements
+
+- Refactor ONNX export of two stage detector (#5205)
+- Replace MMDetection's EvalHook with MMCV's EvalHook for consistency  (#4806)
+- Update RoI extractor for ONNX (#5194)
+- Use better parameter initialization in YOLOv3 head for higher performance (#5181)
+- Release new DCN models of Mask R-CNN by mixed-precision training (#5201)
+- Update YOLOv3 model weights (#5229)
+- Add DetectoRS ResNet-101 model weights (#4960)
+- Discard bboxes with sizes equals to `min_bbox_size` (#5011)
+- Remove duplicated code in DETR head (#5129)
+- Remove unnecessary object in class definition (#5180)
+- Fix doc link (#5192)
+
+### v2.12.0 (01/5/2021)
+
+#### Highlights
+
+- Support new methods: [AutoAssign](https://arxiv.org/abs/2007.03496), [YOLOF](https://arxiv.org/abs/2103.09460), and [Deformable DETR](https://arxiv.org/abs/2010.04159)
+- Stable support of exporting models to ONNX with batched images and dynamic shape (#5039)
+
+#### Backwards Incompatible Changes
+
+MMDetection is going through big refactoring for more general and convenient usages during the releases from v2.12.0 to v2.15.0 (maybe longer).
+In v2.12.0 MMDetection inevitably brings some BC-breakings, including the MMCV dependency, model initialization, model registry, and mask AP evaluation.
+
+- MMCV version. MMDetection v2.12.0 relies on the newest features in MMCV 1.3.3, including `BaseModule` for unified parameter initialization, model registry, and the CUDA operator `MultiScaleDeformableAttn` for [Deformable DETR](https://arxiv.org/abs/2010.04159). Note that MMCV 1.3.2 already contains all the features used by MMDet but has known issues. Therefore, we recommend users skip MMCV v1.3.2 and use v1.3.3, though v1.3.2 might work for most cases.
+- Unified model initialization (#4750). To unify the parameter initialization in OpenMMLab projects, MMCV supports `BaseModule` that accepts `init_cfg` to allow the modules' parameters initialized in a flexible and unified manner. Now the users need to explicitly call `model.init_weights()` in the training script to initialize the model (as in [here](https://github.com/open-mmlab/mmdetection/blob/master/tools/train.py#L162), previously this was handled by the detector. The models in MMDetection have been re-benchmarked to ensure accuracy based on PR #4750. __The downstream projects should update their code accordingly to use MMDetection v2.12.0__.
+- Unified model registry (#5059). To easily use backbones implemented in other OpenMMLab projects, MMDetection migrates to inherit the model registry created in MMCV (#760). In this way, as long as the backbone is supported in an OpenMMLab project and that project also uses the registry in MMCV, users can use that backbone in MMDetection by simply modifying the config without copying the code of that backbone into MMDetection.
+- Mask AP evaluation (#4898). Previous versions calculate the areas of masks through the bounding boxes when calculating the mask AP of small, medium, and large instances. To indeed use the areas of masks, we pop the key `bbox` during mask AP calculation. This change does not affect the overall mask AP evaluation and aligns the mask AP of similar models in other projects like Detectron2.
+
+#### New Features
+
+- Support paper [AutoAssign: Differentiable Label Assignment for Dense Object Detection](https://arxiv.org/abs/2007.03496) (#4295)
+- Support paper [You Only Look One-level Feature](https://arxiv.org/abs/2103.09460) (#4295)
+- Support paper [Deformable DETR: Deformable Transformers for End-to-End Object Detection](https://arxiv.org/abs/2010.04159) (#4778)
+- Support calculating IoU with FP16 tensor in `bbox_overlaps` to save memory and keep speed (#4889)
+- Add `__repr__` in custom dataset to count the number of instances (#4756)
+- Add windows support by updating requirements.txt (#5052)
+- Stable support of exporting models to ONNX with batched images and dynamic shape, including SSD, FSAF,FCOS, YOLOv3, RetinaNet, Faster R-CNN, and Mask R-CNN (#5039)
+
+#### Improvements
+
+- Use MMCV `MODEL_REGISTRY` (#5059)
+- Unified parameter initialization for more flexible usage (#4750)
+- Rename variable names and fix docstring in anchor head (#4883)
+- Support training with empty GT in Cascade RPN (#4928)
+- Add more details of usage of `test_robustness` in documentation (#4917)
+- Changing to use `pycocotools` instead of `mmpycocotools` to fully support Detectron2 and MMDetection in one environment (#4939)
+- Update torch serve dockerfile to support dockers of more versions (#4954)
+- Add check for training with single class dataset (#4973)
+- Refactor transformer and DETR Head (#4763)
+- Update FPG model zoo (#5079)
+- More accurate mask AP of small/medium/large instances (#4898)
+
+#### Bug Fixes
+
+- Fix bug in mean_ap.py when calculating mAP by 11 points (#4875)
+- Fix error when key `meta` is not in old checkpoints (#4936)
+- Fix hanging bug when training with empty GT in VFNet, GFL, and FCOS by changing the place of `reduce_mean` (#4923, #4978, #5058)
+- Fix asyncronized inference error and provide related demo (#4941)
+- Fix IoU losses dimensionality unmatch error (#4982)
+- Fix torch.randperm whtn using PyTorch 1.8 (#5014)
+- Fix empty bbox error in `mask_head` when using CARAFE (#5062)
+- Fix `supplement_mask` bug when there are zero-size RoIs (#5065)
+- Fix testing with empty rois in RoI Heads (#5081)
+
+### v2.11.0 (01/4/2021)
+
+__Highlights__
+
+- Support new method: [Localization Distillation for Object Detection](https://arxiv.org/pdf/2102.12252.pdf)
+- Support Pytorch2ONNX with batch inference and dynamic shape
+
+__New Features__
+
+- Support [Localization Distillation for Object Detection](https://arxiv.org/pdf/2102.12252.pdf) (#4758)
+- Support Pytorch2ONNX with batch inference and dynamic shape for Faster-RCNN and mainstream one-stage detectors (#4796)
+
+__Improvements__
+
+- Support batch inference in head of RetinaNet (#4699)
+- Add batch dimension in second stage of Faster-RCNN (#4785)
+- Support batch inference in bbox coder (#4721)
+- Add check for `ann_ids` in `COCODataset` to ensure it is unique (#4789)
+- support for showing the FPN results (#4716)
+- support dynamic shape for grid_anchor (#4684)
+- Move pycocotools version check to when it is used (#4880)
+
+__Bug Fixes__
+
+- Fix a bug of TridentNet when doing the batch inference (#4717)
+- Fix a bug of Pytorch2ONNX in FASF (#4735)
+- Fix a bug when show the image with float type (#4732)
+
+### v2.10.0 (01/03/2021)
+
+#### Highlights
+
+- Support new methods: [FPG](https://arxiv.org/abs/2004.03580)
+- Support ONNX2TensorRT for SSD, FSAF, FCOS, YOLOv3, and Faster R-CNN.
+
+#### New Features
+
+- Support ONNX2TensorRT for SSD, FSAF, FCOS, YOLOv3, and Faster R-CNN (#4569)
+- Support [Feature Pyramid Grids (FPG)](https://arxiv.org/abs/2004.03580) (#4645)
+- Support video demo (#4420)
+- Add seed option for sampler (#4665)
+- Support to customize type of runner (#4570, #4669)
+- Support synchronizing BN buffer in `EvalHook` (#4582)
+- Add script for GIF demo (#4573)
+
+#### Bug Fixes
+
+- Fix ConfigDict AttributeError and add Colab link (#4643)
+- Avoid crash in empty gt training of GFL head (#4631)
+- Fix `iou_thrs` bug in RPN evaluation (#4581)
+- Fix syntax error of config when upgrading model version (#4584)
+
+#### Improvements
+
+- Refactor unit test file structures (#4600)
+- Refactor nms config (#4636)
+- Get loading pipeline by checking the class directly rather than through config strings (#4619)
+- Add doctests for mask target generation and mask structures (#4614)
+- Use deep copy when copying pipeline arguments (#4621)
+- Update documentations (#4642, #4650, #4620, #4630)
+- Remove redundant code calling `import_modules_from_strings` (#4601)
+- Clean deprecated FP16 API (#4571)
+- Check whether `CLASSES` is correctly initialized in the initialization of `XMLDataset` (#4555)
+- Support batch inference in the inference API (#4462, #4526)
+- Clean deprecated warning and fix 'meta' error (#4695)
+
+### v2.9.0 (01/02/2021)
+
+#### Highlights
+
+- Support new methods: [SCNet](https://arxiv.org/abs/2012.10150), [Sparse R-CNN](https://arxiv.org/abs/2011.12450)
+- Move `train_cfg` and `test_cfg` into model in configs
+- Support to visualize results based on prediction quality
+
+#### New Features
+
+- Support [SCNet](https://arxiv.org/abs/2012.10150) (#4356)
+- Support [Sparse R-CNN](https://arxiv.org/abs/2011.12450) (#4219)
+- Support evaluate mAP by multiple IoUs (#4398)
+- Support concatenate dataset for testing (#4452)
+- Support to visualize results based on prediction quality (#4441)
+- Add ONNX simplify option to Pytorch2ONNX script (#4468)
+- Add hook for checking compatibility of class numbers in heads and datasets (#4508)
+
+#### Bug Fixes
+
+- Fix CPU inference bug of Cascade RPN (#4410)
+- Fix NMS error of CornerNet when there is no prediction box (#4409)
+- Fix TypeError in CornerNet inference (#4411)
+- Fix bug of PAA when training with background images (#4391)
+- Fix the error that the window data is not destroyed when `out_file is not None` and `show==False` (#4442)
+- Fix order of NMS `score_factor` that will decrease the performance of YOLOv3 (#4473)
+- Fix bug in HTC TTA when the number of detection boxes is 0 (#4516)
+- Fix resize error in mask data structures (#4520)
+
+#### Improvements
+
+- Allow to customize classes in LVIS dataset (#4382)
+- Add tutorials for building new models with existing datasets (#4396)
+- Add CPU compatibility information in documentation (#4405)
+- Add documentation of deprecated `ImageToTensor` for batch inference (#4408)
+- Add more details in documentation for customizing dataset (#4430)
+- Switch `imshow_det_bboxes` visualization backend from OpenCV to Matplotlib (#4389)
+- Deprecate `ImageToTensor` in `image_demo.py` (#4400)
+- Move train_cfg/test_cfg into model (#4347, #4489)
+- Update docstring for `reg_decoded_bbox` option in bbox heads (#4467)
+- Update dataset information in documentation (#4525)
+- Release pre-trained R50 and R101 PAA detectors with multi-scale 3x training schedules (#4495)
+- Add guidance for speed benchmark (#4537)
+
+### v2.8.0 (04/01/2021)
+
+#### Highlights
+
+- Support new methods: [Cascade RPN](https://arxiv.org/abs/1909.06720), [TridentNet](https://arxiv.org/abs/1901.01892)
+
+#### New Features
+
+- Support [Cascade RPN](https://arxiv.org/abs/1909.06720) (#1900)
+- Support [TridentNet](https://arxiv.org/abs/1901.01892) (#3313)
+
+#### Bug Fixes
+
+- Fix bug of show result in async_benchmark (#4367)
+- Fix scale factor in MaskTestMixin (#4366)
+- Fix but when returning indices in `multiclass_nms` (#4362)
+- Fix bug of empirical attention in resnext backbone error (#4300)
+- Fix bug of `img_norm_cfg` in FCOS-HRNet models with updated performance and models (#4250)
+- Fix invalid checkpoint and log in Mask R-CNN models on Cityscapes dataset (#4287)
+- Fix bug in distributed sampler when dataset is too small (#4257)
+- Fix bug of 'PAFPN has no attribute extra_convs_on_inputs' (#4235)
+
+#### Improvements
+
+- Update model url from aws to aliyun (#4349)
+- Update ATSS for PyTorch 1.6+ (#4359)
+- Update script to install ruby in pre-commit installation (#4360)
+- Delete deprecated `mmdet.ops` (#4325)
+- Refactor hungarian assigner for more general usage in Sparse R-CNN (#4259)
+- Handle scipy import in DETR to reduce package dependencies (#4339)
+- Update documentation of usages for config options after MMCV (1.2.3) supports overriding list in config (#4326)
+- Update pre-train models of faster rcnn trained on COCO subsets (#4307)
+- Avoid zero or too small value for beta in Dynamic R-CNN (#4303)
+- Add doccumentation for Pytorch2ONNX (#4271)
+- Add deprecated warning FPN arguments (#4264)
+- Support returning indices of kept bboxes when using nms (#4251)
+- Update type and device requirements when creating tensors `GFLHead` (#4210)
+- Update device requirements when creating tensors in `CrossEntropyLoss` (#4224)
+
+### v2.7.0 (30/11/2020)
+
+- Support new method: [DETR](https://arxiv.org/abs/2005.12872), [ResNest](https://arxiv.org/abs/2004.08955), Faster R-CNN DC5.
+- Support YOLO, Mask R-CNN, and Cascade R-CNN models exportable to ONNX.
+
+#### New Features
+
+- Support [DETR](https://arxiv.org/abs/2005.12872) (#4201, #4206)
+- Support to link the best checkpoint in training (#3773)
+- Support to override config through options in inference.py (#4175)
+- Support YOLO, Mask R-CNN, and Cascade R-CNN models exportable to ONNX (#4087, #4083)
+- Support [ResNeSt](https://arxiv.org/abs/2004.08955) backbone (#2959)
+- Support unclip border bbox regression (#4076)
+- Add tpfp func in evaluating AP (#4069)
+- Support mixed precision training of SSD detector with other backbones (#4081)
+- Add Faster R-CNN DC5 models (#4043)
+
+#### Bug Fixes
+
+- Fix bug of `gpu_id` in distributed training mode (#4163)
+- Support Albumentations with version higher than 0.5 (#4032)
+- Fix num_classes bug in faster rcnn config (#4088)
+- Update code in docs/2_new_data_model.md (#4041)
+
+#### Improvements
+
+- Ensure DCN offset to have similar type as features in VFNet (#4198)
+- Add config links in README files of models (#4190)
+- Add tutorials for loss conventions (#3818)
+- Add solution to installation issues in 30-series GPUs (#4176)
+- Update docker version in get_started.md (#4145)
+- Add model statistics and polish some titles in configs README (#4140)
+- Clamp neg probability in FreeAnchor (#4082)
+- Speed up expanding large images (#4089)
+- Fix Pytorch 1.7 incompatibility issues (#4103)
+- Update trouble shooting page to resolve segmentation fault (#4055)
+- Update aLRP-Loss in project page (#4078)
+- Clean duplicated `reduce_mean` function (#4056)
+- Refactor Q&A (#4045)
+
+### v2.6.0 (1/11/2020)
+
+- Support new method: [VarifocalNet](https://arxiv.org/abs/2008.13367).
+- Refactored documentation with more tutorials.
+
+#### New Features
+
+- Support GIoU calculation in `BboxOverlaps2D`, and re-implement `giou_loss` using `bbox_overlaps` (#3936)
+- Support random sampling in CPU mode (#3948)
+- Support VarifocalNet (#3666, #4024)
+
+#### Bug Fixes
+
+- Fix SABL validating bug in Cascade R-CNN (#3913)
+- Avoid division by zero in PAA head when num_pos=0 (#3938)
+- Fix temporary directory bug of multi-node testing error (#4034, #4017)
+- Fix `--show-dir` option in test script (#4025)
+- Fix GA-RetinaNet r50 model url (#3983)
+- Update code in docs and fix broken urls (#3947)
+
+#### Improvements
+
+- Refactor pytorch2onnx API into `mmdet.core.export` and use `generate_inputs_and_wrap_model` for pytorch2onnx (#3857, #3912)
+- Update RPN upgrade scripts for v2.5.0 compatibility (#3986)
+- Use mmcv `tensor2imgs` (#4010)
+- Update test robustness (#4000)
+- Update trouble shooting page (#3994)
+- Accelerate PAA training speed (#3985)
+- Support batch_size > 1 in validation (#3966)
+- Use RoIAlign implemented in MMCV for inference in CPU mode (#3930)
+- Documentation refactoring (#4031)
+
+### v2.5.0 (5/10/2020)
+
+#### Highlights
+
+- Support new methods: [YOLACT](https://arxiv.org/abs/1904.02689), [CentripetalNet](https://arxiv.org/abs/2003.09119).
+- Add more documentations for easier and more clear usage.
+
+#### Backwards Incompatible Changes
+
+__FP16 related methods are imported from mmcv instead of mmdet. (#3766, #3822)__
+Mixed precision training utils in `mmdet.core.fp16` are moved to `mmcv.runner`, including `force_fp32`, `auto_fp16`, `wrap_fp16_model`, and `Fp16OptimizerHook`. A deprecation warning will be raised if users attempt to import those methods from `mmdet.core.fp16`, and will be finally removed in V2.10.0.
+
+__\[0, N-1\] represents foreground classes and N indicates background classes for all models. (#3221)__
+Before v2.5.0, the background label for RPN is 0, and N for other heads. Now the behavior is consistent for all models. Thus `self.background_labels` in `dense_heads` is removed and all heads use `self.num_classes` to indicate the class index of background labels.
+This change has no effect on the pre-trained models in the v2.x model zoo, but will affect the training of all models with RPN heads. Two-stage detectors whose RPN head uses softmax will be affected because the order of categories is changed.
+
+**Only call `get_subset_by_classes` when `test_mode=True` and `self.filter_empty_gt=True` (#3695)**
+Function `get_subset_by_classes` in dataset is refactored and only filters out images when `test_mode=True` and `self.filter_empty_gt=True`.
+In the original implementation, `get_subset_by_classes` is not related to the flag `self.filter_empty_gt` and will only be called when the classes is set during initialization no matter `test_mode` is `True` or `False`. This brings ambiguous behavior and potential bugs in many cases. After v2.5.0, if `filter_empty_gt=False`, no matter whether the classes are specified in a dataset, the dataset will use all the images in the annotations. If `filter_empty_gt=True` and `test_mode=True`, no matter whether the classes are specified, the dataset will call \`\`get_subset_by_classes\` to check the images and filter out images containing no GT boxes. Therefore, the users should be responsible for the data filtering/cleaning process for the test dataset.
+
+#### New Features
+
+- Test time augmentation for single stage detectors (#3844, #3638)
+- Support to show the name of experiments during training (#3764)
+- Add `Shear`, `Rotate`, `Translate` Augmentation (#3656, #3619, #3687)
+- Add image-only transformations including `Constrast`, `Equalize`, `Color`, and `Brightness`. (#3643)
+- Support [YOLACT](https://arxiv.org/abs/1904.02689) (#3456)
+- Support [CentripetalNet](https://arxiv.org/abs/2003.09119) (#3390)
+- Support PyTorch 1.6 in docker (#3905)
+
+#### Bug Fixes
+
+- Fix the bug of training ATSS when there is no ground truth boxes (#3702)
+- Fix the bug of using Focal Loss when there is `num_pos` is 0 (#3702)
+- Fix the label index mapping in dataset browser (#3708)
+- Fix Mask R-CNN training stuck problem when their is no positive rois (#3713)
+- Fix the bug of `self.rpn_head.test_cfg` in `RPNTestMixin` by using `self.rpn_head` in rpn head (#3808)
+- Fix deprecated `Conv2d` from mmcv.ops (#3791)
+- Fix device bug in RepPoints (#3836)
+- Fix SABL validating bug (#3849)
+- Use `https://download.openmmlab.com/mmcv/dist/index.html` for installing MMCV (#3840)
+- Fix nonzero in NMS for PyTorch 1.6.0 (#3867)
+- Fix the API change bug of PAA (#3883)
+- Fix typo in bbox_flip (#3886)
+- Fix cv2 import error of ligGL.so.1 in Dockerfile (#3891)
+
+#### Improvements
+
+- Change to use `mmcv.utils.collect_env` for collecting environment information to avoid duplicate codes (#3779)
+- Update checkpoint file names to v2.0 models in documentation (#3795)
+- Update tutorials for changing runtime settings (#3778), modifying loss (#3777)
+- Improve the function of `simple_test_bboxes` in SABL (#3853)
+- Convert mask to bool before using it as img's index for robustness and speedup (#3870)
+- Improve documentation of modules and dataset customization (#3821)
+
+### v2.4.0 (5/9/2020)
+
+__Highlights__
+
+- Fix lots of issues/bugs and reorganize the trouble shooting page
+- Support new methods [SABL](https://arxiv.org/abs/1912.04260), [YOLOv3](https://arxiv.org/abs/1804.02767), and [PAA Assign](https://arxiv.org/abs/2007.08103)
+- Support Batch Inference
+- Start to publish `mmdet` package to PyPI since v2.3.0
+- Switch model zoo to download.openmmlab.com
+
+__Backwards Incompatible Changes__
+
+- Support Batch Inference (#3564, #3686, #3705): Since v2.4.0, MMDetection could inference model with multiple images in a single GPU.
+  This change influences all the test APIs in MMDetection and downstream codebases. To help the users migrate their code, we use `replace_ImageToTensor` (#3686) to convert legacy test data pipelines during dataset initialization.
+- Support RandomFlip with horizontal/vertical/diagonal direction (#3608): Since v2.4.0, MMDetection supports horizontal/vertical/diagonal flip in the data augmentation. This influences bounding box, mask, and image transformations in data augmentation process and the process that will map those data back to the original format.
+- Migrate to use `mmlvis` and `mmpycocotools` for COCO and LVIS dataset (#3727). The APIs are fully compatible with the original `lvis` and `pycocotools`. Users need to uninstall the existing pycocotools and lvis packages in their environment first and install `mmlvis` & `mmpycocotools`.
+
+__Bug Fixes__
+
+- Fix default mean/std for onnx (#3491)
+- Fix coco evaluation and add metric items (#3497)
+- Fix typo for install.md (#3516)
+- Fix atss when sampler per gpu is 1 (#3528)
+- Fix import of fuse_conv_bn (#3529)
+- Fix bug of gaussian_target, update unittest of heatmap (#3543)
+- Fixed VOC2012 evaluate (#3553)
+- Fix scale factor bug of rescale (#3566)
+- Fix with_xxx_attributes in base detector (#3567)
+- Fix boxes scaling when number is 0 (#3575)
+- Fix rfp check when neck config is a list (#3591)
+- Fix import of fuse conv bn in benchmark.py (#3606)
+- Fix webcam demo (#3634)
+- Fix typo and itemize issues in tutorial (#3658)
+- Fix error in distributed training when some levels of FPN are not assigned with bounding boxes (#3670)
+- Fix the width and height orders of stride in valid flag generation (#3685)
+- Fix weight initialization bug in Res2Net DCN (#3714)
+- Fix bug in OHEMSampler (#3677)
+
+__New Features__
+
+- Support Cutout augmentation (#3521)
+- Support evaluation on multiple datasets through ConcatDataset (#3522)
+- Support [PAA assign](https://arxiv.org/abs/2007.08103) #(3547)
+- Support eval metric with pickle results (#3607)
+- Support [YOLOv3](https://arxiv.org/abs/1804.02767) (#3083)
+- Support [SABL](https://arxiv.org/abs/1912.04260) (#3603)
+- Support to publish to Pypi in github-action (#3510)
+- Support custom imports (#3641)
+
+__Improvements__
+
+- Refactor common issues in documentation (#3530)
+- Add pytorch 1.6 to CI config (#3532)
+- Add config to runner meta (#3534)
+- Add eval-option flag for testing (#3537)
+- Add init_eval to evaluation hook (#3550)
+- Add include_bkg in ClassBalancedDataset (#3577)
+- Using config's loading in inference_detector (#3611)
+- Add ATSS ResNet-101 models in model zoo (#3639)
+- Update urls to download.openmmlab.com (#3665)
+- Support non-mask training for CocoDataset (#3711)
+
+### v2.3.0 (5/8/2020)
+
+__Highlights__
+
+- The CUDA/C++ operators have been moved to `mmcv.ops`. For backward compatibility `mmdet.ops` is kept as warppers of `mmcv.ops`.
+- Support new methods [CornerNet](https://arxiv.org/abs/1808.01244), [DIOU](https://arxiv.org/abs/1911.08287)/[CIOU](https://arxiv.org/abs/2005.03572) loss, and new dataset: [LVIS V1](https://arxiv.org/abs/1908.03195)
+- Provide more detailed colab training tutorials and more complete documentation.
+- Support to convert RetinaNet from Pytorch to ONNX.
+
+__Bug Fixes__
+
+- Fix the model initialization bug of DetectoRS (#3187)
+- Fix the bug of module names in NASFCOSHead (#3205)
+- Fix the filename bug in publish_model.py (#3237)
+- Fix the dimensionality bug when `inside_flags.any()` is `False` in dense heads (#3242)
+- Fix the bug of forgetting to pass flip directions in `MultiScaleFlipAug` (#3262)
+- Fixed the bug caused by default value of `stem_channels` (#3333)
+- Fix the bug of model checkpoint loading for CPU inference (#3318, #3316)
+- Fix topk bug when box number is smaller than the expected topk number in ATSSAssigner (#3361)
+- Fix the gt priority bug in center_region_assigner.py (#3208)
+- Fix NaN issue of iou calculation in iou_loss.py (#3394)
+- Fix the bug that `iou_thrs` is not actually used during evaluation in coco.py (#3407)
+- Fix test-time augmentation of RepPoints (#3435)
+- Fix runtimeError caused by incontiguous tensor in Res2Net+DCN (#3412)
+
+__New Features__
+
+- Support [CornerNet](https://arxiv.org/abs/1808.01244) (#3036)
+- Support [DIOU](https://arxiv.org/abs/1911.08287)/[CIOU](https://arxiv.org/abs/2005.03572) loss (#3151)
+- Support [LVIS V1](https://arxiv.org/abs/1908.03195) dataset (#)
+- Support customized hooks in training (#3395)
+- Support fp16 training of generalized focal loss (#3410)
+- Support to convert RetinaNet from Pytorch to ONNX (#3075)
+
+__Improvements__
+
+- Support to process ignore boxes in ATSS assigner (#3082)
+- Allow to crop images without ground truth in `RandomCrop` (#3153)
+- Enable the the `Accuracy` module to set threshold (#3155)
+- Refactoring unit tests (#3206)
+- Unify the training settings of `to_float32` and `norm_cfg` in RegNets configs (#3210)
+- Add colab training tutorials for beginners (#3213, #3273)
+- Move CUDA/C++ operators into `mmcv.ops` and keep `mmdet.ops` as warppers for backward compatibility (#3232)(#3457)
+- Update installation scripts in documentation (#3290) and dockerfile (#3320)
+- Support to set image resize backend (#3392)
+- Remove git hash in version file (#3466)
+- Check mmcv version to force version compatibility (#3460)
+
+### v2.2.0 (1/7/2020)
+
+__Highlights__
+
+- Support new methods: [DetectoRS](https://arxiv.org/abs/2006.02334), [PointRend](https://arxiv.org/abs/1912.08193), [Generalized Focal Loss](https://arxiv.org/abs/2006.04388), [Dynamic R-CNN](https://arxiv.org/abs/2004.06002)
+
+__Bug Fixes__
+
+- Fix FreeAnchor when no gt in image (#3176)
+- Clean up deprecated usage of `register_module()` (#3092, #3161)
+- Fix pretrain bug in NAS FCOS (#3145)
+- Fix `num_classes` in SSD (#3142)
+- Fix FCOS warmup (#3119)
+- Fix `rstrip` in `tools/publish_model.py`
+- Fix `flip_ratio` default value in RandomFLip pipeline (#3106)
+- Fix cityscapes eval with ms_rcnn (#3112)
+- Fix RPN softmax (#3056)
+- Fix filename of LVIS@v0.5 (#2998)
+- Fix nan loss by filtering out-of-frame gt_bboxes in COCO (#2999)
+- Fix bug in FSAF (#3018)
+- Add FocalLoss `num_classes` check (#2964)
+- Fix PISA Loss when there are no gts (#2992)
+- Avoid nan in `iou_calculator` (#2975)
+- Prevent possible bugs in loading and transforms caused by shallow copy (#2967)
+
+__New Features__
+
+- Add DetectoRS (#3064)
+- Support Generalize Focal Loss (#3097)
+- Support PointRend (#2752)
+- Support Dynamic R-CNN (#3040)
+- Add DeepFashion dataset (#2968)
+- Implement FCOS training tricks (#2935)
+- Use BaseDenseHead as base class for anchor-base heads (#2963)
+- Add `with_cp` for BasicBlock (#2891)
+- Add `stem_channels` argument for ResNet (#2954)
+
+__Improvements__
+
+- Add anchor free base head (#2867)
+- Migrate to github action (#3137)
+- Add docstring for datasets, pipelines, core modules and methods (#3130, #3125, #3120)
+- Add VOC benchmark (#3060)
+- Add `concat` mode in GRoI (#3098)
+- Remove cmd arg `autorescale-lr` (#3080)
+- Use `len(data['img_metas'])` to indicate `num_samples` (#3073, #3053)
+- Switch to EpochBasedRunner (#2976)
+
+### v2.1.0 (8/6/2020)
+
+__Highlights__
+
+- Support new backbones: [RegNetX](https://arxiv.org/abs/2003.13678), [Res2Net](https://arxiv.org/abs/1904.01169)
+- Support new methods: [NASFCOS](https://arxiv.org/abs/1906.04423), [PISA](https://arxiv.org/abs/1904.04821), [GRoIE](https://arxiv.org/abs/2004.13665)
+- Support new dataset: [LVIS](https://arxiv.org/abs/1908.03195)
+
+__Bug Fixes__
+
+- Change the CLI argument `--validate` to `--no-validate` to enable validation after training epochs by default. (#2651)
+- Add missing cython to docker file (#2713)
+- Fix bug in nms cpu implementation (#2754)
+- Fix bug when showing mask results (#2763)
+- Fix gcc requirement (#2806)
+- Fix bug in async test (#2820)
+- Fix mask encoding-decoding bugs in test API (#2824)
+- Fix bug in test time augmentation (#2858, #2921, #2944)
+- Fix a typo in comment of apis/train (#2877)
+- Fix the bug of returning None when no gt bboxes are in the original image in `RandomCrop`. Fix the bug that misses to handle `gt_bboxes_ignore`, `gt_label_ignore`, and `gt_masks_ignore` in `RandomCrop`, `MinIoURandomCrop` and `Expand` modules. (#2810)
+- Fix bug of `base_channels` of regnet (#2917)
+- Fix the bug of logger when loading pre-trained weights in base detector (#2936)
+
+__New Features__
+
+- Add IoU models (#2666)
+- Add colab demo for inference
+- Support class agnostic nms (#2553)
+- Add benchmark gathering scripts for development only (#2676)
+- Add mmdet-based project links (#2736, #2767, #2895)
+- Add config dump in training (#2779)
+- Add ClassBalancedDataset (#2721)
+- Add res2net backbone (#2237)
+- Support RegNetX models (#2710)
+- Use `mmcv.FileClient` to support different storage backends (#2712)
+- Add ClassBalancedDataset (#2721)
+- Code Release: Prime Sample Attention in Object Detection (CVPR 2020) (#2626)
+- Implement NASFCOS (#2682)
+- Add class weight in CrossEntropyLoss (#2797)
+- Support LVIS dataset (#2088)
+- Support GRoIE (#2584)
+
+__Improvements__
+
+- Allow different x and y strides in anchor heads. (#2629)
+- Make FSAF loss more robust to no gt (#2680)
+- Compute pure inference time instead (#2657) and update inference speed (#2730)
+- Avoided the possibility that a patch with 0 area is cropped. (#2704)
+- Add warnings when deprecated `imgs_per_gpu` is used. (#2700)
+- Add a mask rcnn example for config (#2645)
+- Update model zoo (#2762, #2866, #2876, #2879, #2831)
+- Add `ori_filename` to img_metas and use it in test show-dir (#2612)
+- Use `img_fields` to handle multiple images during image transform (#2800)
+- Add upsample_cfg support in FPN (#2787)
+- Add `['img']` as default `img_fields` for back compatibility (#2809)
+- Rename the pretrained model from `open-mmlab://resnet50_caffe` and `open-mmlab://resnet50_caffe_bgr` to `open-mmlab://detectron/resnet50_caffe` and `open-mmlab://detectron2/resnet50_caffe`. (#2832)
+- Added sleep(2) in test.py to reduce hanging problem (#2847)
+- Support `c10::half` in CARAFE (#2890)
+- Improve documentations (#2918, #2714)
+- Use optimizer constructor in mmcv and clean the original implementation in `mmdet.core.optimizer` (#2947)
+
+### v2.0.0 (6/5/2020)
+
+In this release, we made lots of major refactoring and modifications.
+
+1. __Faster speed__. We optimize the training and inference speed for common models, achieving up to 30% speedup for training and 25% for inference. Please refer to [model zoo](model_zoo.md#comparison-with-detectron2) for details.
+
+2. __Higher performance__. We change some default hyperparameters with no additional cost, which leads to a gain of performance for most models. Please refer to [compatibility](compatibility.md#training-hyperparameters) for details.
+
+3. __More documentation and tutorials__. We add a bunch of documentation and tutorials to help users get started more smoothly. Read it [here](https://mmdetection.readthedocs.io/en/latest/).
+
+4. __Support PyTorch 1.5__. The support for 1.1 and 1.2 is dropped, and we switch to some new APIs.
+
+5. __Better configuration system__. Inheritance is supported to reduce the redundancy of configs.
+
+6. __Better modular design__. Towards the goal of simplicity and flexibility, we simplify some encapsulation while add more other configurable modules like BBoxCoder, IoUCalculator, OptimizerConstructor, RoIHead. Target computation is also included in heads and the call hierarchy is simpler.
+
+7. Support new methods: [FSAF](https://arxiv.org/abs/1903.00621) and PAFPN (part of [PAFPN](https://arxiv.org/abs/1803.01534)).
+
+__Breaking Changes__
+Models training with MMDetection 1.x are not fully compatible with 2.0, please refer to the [compatibility doc](compatibility.md) for the details and how to migrate to the new version.
+
+__Improvements__
+
+- Unify cuda and cpp API for custom ops. (#2277)
+- New config files with inheritance. (#2216)
+- Encapsulate the second stage into RoI heads. (#1999)
+- Refactor GCNet/EmpericalAttention into plugins. (#2345)
+- Set low quality match as an option in IoU-based bbox assigners. (#2375)
+- Change the codebase's coordinate system. (#2380)
+- Refactor the category order in heads. 0 means the first positive class instead of background now. (#2374)
+- Add bbox sampler and assigner registry. (#2419)
+- Speed up the inference of RPN. (#2420)
+- Add `train_cfg` and `test_cfg` as class members in all anchor heads. (#2422)
+- Merge target computation methods into heads. (#2429)
+- Add bbox coder to support different bbox encoding and losses. (#2480)
+- Unify the API for regression loss. (#2156)
+- Refactor Anchor Generator. (#2474)
+- Make `lr` an optional argument for optimizers. (#2509)
+- Migrate to modules and methods in MMCV. (#2502, #2511, #2569, #2572)
+- Support PyTorch 1.5. (#2524)
+- Drop the support for Python 3.5 and use F-string in the codebase. (#2531)
+
+__Bug Fixes__
+
+- Fix the scale factors for resized images without keep the aspect ratio. (#2039)
+- Check if max_num > 0 before slicing in NMS. (#2486)
+- Fix Deformable RoIPool when there is no instance. (#2490)
+- Fix the default value of assigned labels. (#2536)
+- Fix the evaluation of Cityscapes. (#2578)
+
+__New Features__
+
+- Add deep_stem and avg_down option to ResNet, i.e., support ResNetV1d. (#2252)
+- Add L1 loss. (#2376)
+- Support both polygon and bitmap for instance masks. (#2353, #2540)
+- Support CPU mode for inference. (#2385)
+- Add optimizer constructor for complicated configuration of optimizers. (#2397, #2488)
+- Implement PAFPN. (#2392)
+- Support empty tensor input for some modules. (#2280)
+- Support for custom dataset classes without overriding it. (#2408, #2443)
+- Support to train subsets of coco dataset. (#2340)
+- Add iou_calculator to potentially support more IoU calculation methods. (2405)
+- Support class wise mean AP (was removed in the last version). (#2459)
+- Add option to save the testing result images. (#2414)
+- Support MomentumUpdaterHook. (#2571)
+- Add a demo to inference a single image. (#2605)
+
+### v1.1.0 (24/2/2020)
+
+__Highlights__
+
+- Dataset evaluation is rewritten with a unified api, which is used by both evaluation hooks and test scripts.
+- Support new methods: [CARAFE](https://arxiv.org/abs/1905.02188).
+
+__Breaking Changes__
+
+- The new MMDDP inherits from the official DDP, thus the `__init__` api is changed to be the same as official DDP.
+- The `mask_head` field in HTC config files is modified.
+- The evaluation and testing script is updated.
+- In all transforms, instance masks are stored as a numpy array shaped (n, h, w) instead of a list of (h, w) arrays, where n is the number of instances.
+
+__Bug Fixes__
+
+- Fix IOU assigners when ignore_iof_thr > 0 and there is no pred boxes. (#2135)
+- Fix mAP evaluation when there are no ignored boxes. (#2116)
+- Fix the empty RoI input for Deformable RoI Pooling. (#2099)
+- Fix the dataset settings for multiple workflows. (#2103)
+- Fix the warning related to `torch.uint8` in PyTorch 1.4. (#2105)
+- Fix the inference demo on devices other than gpu:0. (#2098)
+- Fix Dockerfile. (#2097)
+- Fix the bug that `pad_val` is unused in Pad transform. (#2093)
+- Fix the albumentation transform when there is no ground truth bbox. (#2032)
+
+__Improvements__
+
+- Use torch instead of numpy for random sampling. (#2094)
+- Migrate to the new MMDDP implementation in MMCV v0.3. (#2090)
+- Add meta information in logs. (#2086)
+- Rewrite Soft NMS with pytorch extension and remove cython as a dependency. (#2056)
+- Rewrite dataset evaluation. (#2042, #2087, #2114, #2128)
+- Use numpy array for masks in transforms. (#2030)
+
+__New Features__
+
+- Implement "CARAFE: Content-Aware ReAssembly of FEatures". (#1583)
+- Add `worker_init_fn()` in data_loader when seed is set. (#2066, #2111)
+- Add logging utils. (#2035)
+
+### v1.0.0 (30/1/2020)
+
+This release mainly improves the code quality and add more docstrings.
+
+__Highlights__
+
+- Documentation is online now: .
+- Support new models: [ATSS](https://arxiv.org/abs/1912.02424).
+- DCN is now available with the api `build_conv_layer` and `ConvModule` like the normal conv layer.
+- A tool to collect environment information is available for trouble shooting.
+
+__Bug Fixes__
+
+- Fix the incompatibility of the latest numpy and pycocotools. (#2024)
+- Fix the case when distributed package is unavailable, e.g., on Windows. (#1985)
+- Fix the dimension issue for `refine_bboxes()`. (#1962)
+- Fix the typo when `seg_prefix` is a list. (#1906)
+- Add segmentation map cropping to RandomCrop. (#1880)
+- Fix the return value of `ga_shape_target_single()`. (#1853)
+- Fix the loaded shape of empty proposals. (#1819)
+- Fix the mask data type when using albumentation. (#1818)
+
+__Improvements__
+
+- Enhance AssignResult and SamplingResult. (#1995)
+- Add ability to overwrite existing module in Registry. (#1982)
+- Reorganize requirements and make albumentations and imagecorruptions optional. (#1969)
+- Check NaN in `SSDHead`. (#1935)
+- Encapsulate the DCN in ResNe(X)t into a ConvModule & Conv_layers. (#1894)
+- Refactoring for mAP evaluation and support multiprocessing and logging. (#1889)
+- Init the root logger before constructing Runner to log more information. (#1865)
+- Split `SegResizeFlipPadRescale` into different existing transforms. (#1852)
+- Move `init_dist()` to MMCV. (#1851)
+- Documentation and docstring improvements. (#1971, #1938, #1869, #1838)
+- Fix the color of the same class for mask visualization. (#1834)
+- Remove the option `keep_all_stages` in HTC and Cascade R-CNN. (#1806)
+
+__New Features__
+
+- Add two test-time options `crop_mask` and `rle_mask_encode` for mask heads. (#2013)
+- Support loading grayscale images as single channel. (#1975)
+- Implement "Bridging the Gap Between Anchor-based and Anchor-free Detection via Adaptive Training Sample Selection". (#1872)
+- Add sphinx generated docs. (#1859, #1864)
+- Add GN support for flops computation. (#1850)
+- Collect env info for trouble shooting. (#1812)
+
+### v1.0rc1 (13/12/2019)
+
+The RC1 release mainly focuses on improving the user experience, and fixing bugs.
+
+__Highlights__
+
+- Support new models: [FoveaBox](https://arxiv.org/abs/1904.03797), [RepPoints](https://arxiv.org/abs/1904.11490) and [FreeAnchor](https://arxiv.org/abs/1909.02466).
+- Add a Dockerfile.
+- Add a jupyter notebook demo and a webcam demo.
+- Setup the code style and CI.
+- Add lots of docstrings and unit tests.
+- Fix lots of bugs.
+
+__Breaking Changes__
+
+- There was a bug for computing COCO-style mAP w.r.t different scales (AP_s, AP_m, AP_l), introduced by #621. (#1679)
+
+__Bug Fixes__
+
+- Fix a sampling interval bug in Libra R-CNN. (#1800)
+- Fix the learning rate in SSD300 WIDER FACE. (#1781)
+- Fix the scaling issue when `keep_ratio=False`. (#1730)
+- Fix typos. (#1721, #1492, #1242, #1108, #1107)
+- Fix the shuffle argument in `build_dataloader`. (#1693)
+- Clip the proposal when computing mask targets. (#1688)
+- Fix the "index out of range" bug for samplers in some corner cases. (#1610, #1404)
+- Fix the NMS issue on devices other than GPU:0. (#1603)
+- Fix SSD Head and GHM Loss on CPU. (#1578)
+- Fix the OOM error when there are too many gt bboxes. (#1575)
+- Fix the wrong keyword argument `nms_cfg` in HTC. (#1573)
+- Process masks and semantic segmentation in Expand and MinIoUCrop transforms. (#1550, #1361)
+- Fix a scale bug in the Non Local op. (#1528)
+- Fix a bug in transforms when `gt_bboxes_ignore` is None. (#1498)
+- Fix a bug when `img_prefix` is None. (#1497)
+- Pass the device argument to `grid_anchors` and `valid_flags`. (#1478)
+- Fix the data pipeline for test_robustness. (#1476)
+- Fix the argument type of deformable pooling. (#1390)
+- Fix the coco_eval when there are only two classes. (#1376)
+- Fix a bug in Modulated DeformableConv when deformable_group>1. (#1359)
+- Fix the mask cropping in RandomCrop. (#1333)
+- Fix zero outputs in DeformConv when not running on cuda:0. (#1326)
+- Fix the type issue in Expand. (#1288)
+- Fix the inference API. (#1255)
+- Fix the inplace operation in Expand. (#1249)
+- Fix the from-scratch training config. (#1196)
+- Fix inplace add in RoIExtractor which cause an error in PyTorch 1.2. (#1160)
+- Fix FCOS when input images has no positive sample. (#1136)
+- Fix recursive imports. (#1099)
+
+__Improvements__
+
+- Print the config file and mmdet version in the log. (#1721)
+- Lint the code before compiling in travis CI. (#1715)
+- Add a probability argument for the `Expand` transform. (#1651)
+- Update the PyTorch and CUDA version in the docker file. (#1615)
+- Raise a warning when specifying `--validate` in non-distributed training. (#1624, #1651)
+- Beautify the mAP printing. (#1614)
+- Add pre-commit hook. (#1536)
+- Add the argument `in_channels` to backbones. (#1475)
+- Add lots of docstrings and unit tests, thanks to [@Erotemic](https://github.com/Erotemic). (#1603, #1517, #1506, #1505, #1491, #1479, #1477, #1475, #1474)
+- Add support for multi-node distributed test when there is no shared storage. (#1399)
+- Optimize Dockerfile to reduce the image size. (#1306)
+- Update new results of HRNet. (#1284, #1182)
+- Add an argument `no_norm_on_lateral` in FPN. (#1240)
+- Test the compiling in CI. (#1235)
+- Move docs to a separate folder. (#1233)
+- Add a jupyter notebook demo. (#1158)
+- Support different type of dataset for training. (#1133)
+- Use int64_t instead of long in cuda kernels. (#1131)
+- Support unsquare RoIs for bbox and mask heads. (#1128)
+- Manually add type promotion to make compatible to PyTorch 1.2. (#1114)
+- Allowing validation dataset for computing validation loss. (#1093)
+- Use `.scalar_type()` instead of `.type()` to suppress some warnings. (#1070)
+
+__New Features__
+
+- Add an option `--with_ap` to compute the AP for each class. (#1549)
+- Implement "FreeAnchor: Learning to Match Anchors for Visual Object Detection". (#1391)
+- Support [Albumentations](https://github.com/albumentations-team/albumentations) for augmentations in the data pipeline. (#1354)
+- Implement "FoveaBox: Beyond Anchor-based Object Detector". (#1339)
+- Support horizontal and vertical flipping. (#1273, #1115)
+- Implement "RepPoints: Point Set Representation for Object Detection". (#1265)
+- Add test-time augmentation to HTC and Cascade R-CNN. (#1251)
+- Add a COCO result analysis tool. (#1228)
+- Add Dockerfile. (#1168)
+- Add a webcam demo. (#1155, #1150)
+- Add FLOPs counter. (#1127)
+- Allow arbitrary layer order for ConvModule. (#1078)
+
+### v1.0rc0 (27/07/2019)
+
+- Implement lots of new methods and components (Mixed Precision Training, HTC, Libra R-CNN, Guided Anchoring, Empirical Attention, Mask Scoring R-CNN, Grid R-CNN (Plus), GHM, GCNet, FCOS, HRNet, Weight Standardization, etc.). Thank all collaborators!
+- Support two additional datasets: WIDER FACE and Cityscapes.
+- Refactoring for loss APIs and make it more flexible to adopt different losses and related hyper-parameters.
+- Speed up multi-gpu testing.
+- Integrate all compiling and installing in a single script.
+
+### v0.6.0 (14/04/2019)
+
+- Up to 30% speedup compared to the model zoo.
+- Support both PyTorch stable and nightly version.
+- Replace NMS and SigmoidFocalLoss with Pytorch CUDA extensions.
+
+### v0.6rc0(06/02/2019)
+
+- Migrate to PyTorch 1.0.
+
+### v0.5.7 (06/02/2019)
+
+- Add support for Deformable ConvNet v2. (Many thanks to the authors and [@chengdazhi](https://github.com/chengdazhi))
+- This is the last release based on PyTorch 0.4.1.
+
+### v0.5.6 (17/01/2019)
+
+- Add support for Group Normalization.
+- Unify RPNHead and single stage heads (RetinaHead, SSDHead) with AnchorHead.
+
+### v0.5.5 (22/12/2018)
+
+- Add SSD for COCO and PASCAL VOC.
+- Add ResNeXt backbones and detection models.
+- Refactoring for Samplers/Assigners and add OHEM.
+- Add VOC dataset and evaluation scripts.
+
+### v0.5.4 (27/11/2018)
+
+- Add SingleStageDetector and RetinaNet.
+
+### v0.5.3 (26/11/2018)
+
+- Add Cascade R-CNN and Cascade Mask R-CNN.
+- Add support for Soft-NMS in config files.
+
+### v0.5.2 (21/10/2018)
+
+- Add support for custom datasets.
+- Add a script to convert PASCAL VOC annotations to the expected format.
+
+### v0.5.1 (20/10/2018)
+
+- Add BBoxAssigner and BBoxSampler, the `train_cfg` field in config files are restructured.
+- `ConvFCRoIHead` / `SharedFCRoIHead` are renamed to `ConvFCBBoxHead` / `SharedFCBBoxHead` for consistency.
diff --git a/mmdetection/docs/en/notes/compatibility.md b/mmdetection/docs/en/notes/compatibility.md
new file mode 100644
index 00000000..26325e24
--- /dev/null
+++ b/mmdetection/docs/en/notes/compatibility.md
@@ -0,0 +1,178 @@
+# Compatibility of MMDetection 2.x
+
+## MMDetection 2.25.0
+
+In order to support Mask2Former for instance segmentation, the original config files of Mask2Former for panpotic segmentation need to be renamed [PR #7571](https://github.com/open-mmlab/mmdetection/pull/7571).
+
+
+    
+        
+            
+            
+        
+    
+    
+    
+    
+  
    before v2.25.0after v2.25.0
    
+
+```
+'mask2former_xxx_coco.py' represents config files for **panoptic segmentation**.
+```
+
+
+
+```
+'mask2former_xxx_coco.py' represents config files for **instance segmentation**.
+'mask2former_xxx_coco-panoptic.py' represents config files for **panoptic segmentation**.
+```
+
+
    
+
+## MMDetection 2.21.0
+
+In order to support CPU training, the logic of scatter in batch collating has been changed. We recommend to use
+MMCV v1.4.4 or higher. For more details, please refer to [MMCV PR #1621](https://github.com/open-mmlab/mmcv/pull/1621).
+
+## MMDetection 2.18.1
+
+### MMCV compatibility
+
+In order to fix the wrong weight reference bug in BaseTransformerLayer, the logic in batch first mode of MultiheadAttention has been changed.
+We recommend to use MMCV v1.3.17 or higher. For more details, please refer to [MMCV PR #1418](https://github.com/open-mmlab/mmcv/pull/1418).
+
+## MMDetection 2.18.0
+
+### DIIHead compatibility
+
+In order to support QueryInst, attn_feats is added into the returned tuple of DIIHead.
+
+## MMDetection 2.14.0
+
+### MMCV Version
+
+In order to fix the problem that the priority of EvalHook is too low, all hook priorities have been re-adjusted in 1.3.8, so MMDetection 2.14.0 needs to rely on the latest MMCV 1.3.8 version. For related information, please refer to [#1120](https://github.com/open-mmlab/mmcv/pull/1120), for related issues, please refer to [#5343](https://github.com/open-mmlab/mmdetection/issues/5343).
+
+### SSD compatibility
+
+In v2.14.0, to make SSD more flexible to use, [PR5291](https://github.com/open-mmlab/mmdetection/pull/5291) refactored its backbone, neck and head. The users can use the script `tools/model_converters/upgrade_ssd_version.py` to convert their models.
+
+```bash
+python tools/model_converters/upgrade_ssd_version.py ${OLD_MODEL_PATH} ${NEW_MODEL_PATH}
+```
+
+- OLD_MODEL_PATH: the path to load the old version SSD model.
+- NEW_MODEL_PATH: the path to save the converted model weights.
+
+## MMDetection 2.12.0
+
+MMDetection is going through big refactoring for more general and convenient usages during the releases from v2.12.0 to v2.18.0 (maybe longer).
+In v2.12.0 MMDetection inevitably brings some BC-breakings, including the MMCV dependency, model initialization, model registry, and mask AP evaluation.
+
+### MMCV Version
+
+MMDetection v2.12.0 relies on the newest features in MMCV 1.3.3, including `BaseModule` for unified parameter initialization, model registry, and the CUDA operator `MultiScaleDeformableAttn` for [Deformable DETR](https://arxiv.org/abs/2010.04159). Note that MMCV 1.3.2 already contains all the features used by MMDet but has known issues. Therefore, we recommend users to skip MMCV v1.3.2 and use v1.3.2, though v1.3.2 might work for most of the cases.
+
+### Unified model initialization
+
+To unify the parameter initialization in OpenMMLab projects, MMCV supports `BaseModule` that accepts `init_cfg` to allow the modules' parameters initialized in a flexible and unified manner. Now the users need to explicitly call `model.init_weights()` in the training script to initialize the model (as in [here](https://github.com/open-mmlab/mmdetection/blob/main/tools/train.py#L162), previously this was handled by the detector. **The downstream projects must update their model initialization accordingly to use MMDetection v2.12.0**. Please refer to PR #4750 for details.
+
+### Unified model registry
+
+To easily use backbones implemented in other OpenMMLab projects, MMDetection v2.12.0 inherits the model registry created in MMCV (#760). In this way, as long as the backbone is supported in an OpenMMLab project and that project also uses the registry in MMCV, users can use that backbone in MMDetection by simply modifying the config without copying the code of that backbone into MMDetection. Please refer to PR #5059 for more details.
+
+### Mask AP evaluation
+
+Before [PR 4898](https://github.com/open-mmlab/mmdetection/pull/4898) and V2.12.0, the mask AP of small, medium, and large instances is calculated based on the bounding box area rather than the real mask area. This leads to higher `APs` and `APm` but lower `APl` but will not affect the overall mask AP. [PR 4898](https://github.com/open-mmlab/mmdetection/pull/4898) change it to use mask areas by deleting `bbox` in mask AP calculation.
+The new calculation does not affect the overall mask AP evaluation and is consistent with [Detectron2](https://github.com/facebookresearch/detectron2/).
+
+## Compatibility with MMDetection 1.x
+
+MMDetection 2.0 goes through a big refactoring and addresses many legacy issues. It is not compatible with the 1.x version, i.e., running inference with the same model weights in these two versions will produce different results. Thus, MMDetection 2.0 re-benchmarks all the models and provides their links and logs in the model zoo.
+
+The major differences are in four folds: coordinate system, codebase conventions, training hyperparameters, and modular design.
+
+### Coordinate System
+
+The new coordinate system is consistent with [Detectron2](https://github.com/facebookresearch/detectron2/) and treats the center of the most left-top pixel as (0, 0) rather than the left-top corner of that pixel.
+Accordingly, the system interprets the coordinates in COCO bounding box and segmentation annotations as coordinates in range `[0, width]` or `[0, height]`.
+This modification affects all the computation related to the bbox and pixel selection,
+which is more natural and accurate.
+
+- The height and width of a box with corners (x1, y1) and (x2, y2) in the new coordinate system is computed as `width = x2 - x1` and `height = y2 - y1`.
+  In MMDetection 1.x and previous version, a "+ 1" was added both height and width.
+  This modification are in three folds:
+
+  1. Box transformation and encoding/decoding in regression.
+  2. IoU calculation. This affects the matching process between ground truth and bounding box and the NMS process. The effect to compatibility is very negligible, though.
+  3. The corners of bounding box is in float type and no longer quantized. This should provide more accurate bounding box results. This also makes the bounding box and RoIs not required to have minimum size of 1, whose effect is small, though.
+
+- The anchors are center-aligned to feature grid points and in float type.
+  In MMDetection 1.x and previous version, the anchors are in `int` type and not center-aligned.
+  This affects the anchor generation in RPN and all the anchor-based methods.
+
+- ROIAlign is better aligned with the image coordinate system. The new implementation is adopted from [Detectron2](https://github.com/facebookresearch/detectron2/tree/master/detectron2/layers/csrc/ROIAlign).
+  The RoIs are shifted by half a pixel by default when they are used to cropping RoI features, compared to MMDetection 1.x.
+  The old behavior is still available by setting `aligned=False` instead of `aligned=True`.
+
+- Mask cropping and pasting are more accurate.
+
+  1. We use the new RoIAlign to crop mask targets. In MMDetection 1.x, the bounding box is quantized before it is used to crop mask target, and the crop process is implemented by numpy. In new implementation, the bounding box for crop is not quantized and sent to RoIAlign. This implementation accelerates the training speed by a large margin (~0.1s per iter, ~2 hour when training Mask R50 for 1x schedule) and should be more accurate.
+
+  2. In MMDetection 2.0, the "`paste_mask()`" function is different and should be more accurate than those in previous versions. This change follows the modification in [Detectron2](https://github.com/facebookresearch/detectron2/blob/master/detectron2/structures/masks.py) and can improve mask AP on COCO by ~0.5% absolute.
+
+### Codebase Conventions
+
+- MMDetection 2.0 changes the order of class labels to reduce unused parameters in regression and mask branch more naturally (without +1 and -1).
+  This effect all the classification layers of the model to have a different ordering of class labels. The final layers of regression branch and mask head no longer keep K+1 channels for K categories, and their class orders are consistent with the classification branch.
+
+  - In MMDetection 2.0, label "K" means background, and labels \[0, K-1\] correspond to the K = num_categories object categories.
+
+  - In MMDetection 1.x and previous version, label "0" means background, and labels \[1, K\] correspond to the K categories.
+
+  - **Note**: The class order of softmax RPN is still the same as that in 1.x in versions\<=2.4.0 while sigmoid RPN is not affected. The class orders in all heads are unified since MMDetection v2.5.0.
+
+- Low quality matching in R-CNN is not used. In MMDetection 1.x and previous versions, the `max_iou_assigner` will match low quality boxes for each ground truth box in both RPN and R-CNN training. We observe this sometimes does not assign the most perfect GT box to some bounding boxes,
+  thus MMDetection 2.0 do not allow low quality matching by default in R-CNN training in the new system. This sometimes may slightly improve the box AP (~0.1% absolute).
+
+- Separate scale factors for width and height. In MMDetection 1.x and previous versions, the scale factor is a single float in mode `keep_ratio=True`. This is slightly inaccurate because the scale factors for width and height have slight difference. MMDetection 2.0 adopts separate scale factors for width and height, the improvement on AP ~0.1% absolute.
+
+- Configs name conventions are changed. MMDetection V2.0 adopts the new name convention to maintain the gradually growing model zoo as the following:
+
+  ```shell
+  [model]_(model setting)_[backbone]_[neck]_(norm setting)_(misc)_(gpu x batch)_[schedule]_[dataset].py,
+  ```
+
+  where the (`misc`) includes DCN and GCBlock, etc. More details are illustrated in the [documentation for config](tutorials/config)
+
+- MMDetection V2.0 uses new ResNet Caffe backbones to reduce warnings when loading pre-trained models. Most of the new backbones' weights are the same as the former ones but do not have `conv.bias`, except that they use a different `img_norm_cfg`. Thus, the new backbone will not cause warning of unexpected keys.
+
+### Training Hyperparameters
+
+The change in training hyperparameters does not affect
+model-level compatibility but slightly improves the performance. The major ones are:
+
+- The number of proposals after nms is changed from 2000 to 1000 by setting `nms_post=1000` and `max_num=1000`.
+  This slightly improves both mask AP and bbox AP by ~0.2% absolute.
+
+- The default box regression losses for Mask R-CNN, Faster R-CNN and RetinaNet are changed from smooth L1 Loss to L1 loss. This leads to an overall improvement in box AP (~0.6% absolute). However, using L1-loss for other methods such as Cascade R-CNN and HTC does not improve the performance, so we keep the original settings for these methods.
+
+- The sample num of RoIAlign layer is set to be 0 for simplicity. This leads to slightly improvement on mask AP (~0.2% absolute).
+
+- The default setting does not use gradient clipping anymore during training for faster training speed. This does not degrade performance of the most of models. For some models such as RepPoints we keep using gradient clipping to stabilize the training process and to obtain better performance.
+
+- The default warmup ratio is changed from 1/3 to 0.001 for a more smooth warming up process since the gradient clipping is usually not used. The effect is found negligible during our re-benchmarking, though.
+
+### Upgrade Models from 1.x to 2.0
+
+To convert the models trained by MMDetection V1.x to MMDetection V2.0, the users can use the script `tools/model_converters/upgrade_model_version.py` to convert
+their models. The converted models can be run in MMDetection V2.0 with slightly dropped performance (less than 1% AP absolute).
+Details can be found in `configs/legacy`.
+
+## pycocotools compatibility
+
+`mmpycocotools` is the OpenMMlab's fork of official `pycocotools`, which works for both MMDetection and Detectron2.
+Before [PR 4939](https://github.com/open-mmlab/mmdetection/pull/4939), since `pycocotools` and `mmpycocotool` have the same package name, if users already installed `pycocotools` (installed Detectron2 first under the same environment), then the setup of MMDetection will skip installing `mmpycocotool`. Thus MMDetection fails due to the missing `mmpycocotools`.
+If MMDetection is installed before Detectron2, they could work under the same environment.
+[PR 4939](https://github.com/open-mmlab/mmdetection/pull/4939) deprecates mmpycocotools in favor of official pycocotools.
+Users may install MMDetection and Detectron2 under the same environment after [PR 4939](https://github.com/open-mmlab/mmdetection/pull/4939), no matter what the installation order is.
diff --git a/mmdetection/docs/en/notes/contribution_guide.md b/mmdetection/docs/en/notes/contribution_guide.md
new file mode 100644
index 00000000..d622c0ab
--- /dev/null
+++ b/mmdetection/docs/en/notes/contribution_guide.md
@@ -0,0 +1 @@
+# Contribution
diff --git a/mmdetection/docs/en/notes/faq.md b/mmdetection/docs/en/notes/faq.md
new file mode 100644
index 00000000..f1a176e4
--- /dev/null
+++ b/mmdetection/docs/en/notes/faq.md
@@ -0,0 +1,241 @@
+# Frequently Asked Questions
+
+We list some common troubles faced by many users and their corresponding solutions here. Feel free to enrich the list if you find any frequent issues and have ways to help others to solve them. If the contents here do not cover your issue, please create an issue using the [provided templates](https://github.com/open-mmlab/mmdetection/blob/main/.github/ISSUE_TEMPLATE/error-report.md/) and make sure you fill in all required information in the template.
+
+## PyTorch 2.0 Support
+
+The vast majority of algorithms in MMDetection now support PyTorch 2.0 and its `torch.compile` function. Users only need to install MMDetection 3.0.0rc7 or later versions to enjoy this feature. If any unsupported algorithms are found during use, please feel free to give us feedback. We also welcome contributions from the community to benchmark the speed improvement brought by using the `torch.compile` function.
+
+To enable the `torch.compile` function, simply add `--cfg-options compile=True` after `train.py` or `test.py`. For example, to enable `torch.compile` for RTMDet, you can use the following command:
+
+```shell
+# Single GPU
+python tools/train.py configs/rtmdet/rtmdet_s_8xb32-300e_coco.py  --cfg-options compile=True
+
+# Single node multiple GPUs
+./tools/dist_train.sh configs/rtmdet/rtmdet_s_8xb32-300e_coco.py 8 --cfg-options compile=True
+
+# Single node multiple GPUs + AMP
+./tools/dist_train.sh configs/rtmdet/rtmdet_s_8xb32-300e_coco.py 8 --cfg-options compile=True --amp
+```
+
+It is important to note that PyTorch 2.0's support for dynamic shapes is not yet fully developed. In most object detection algorithms, not only are the input shapes dynamic, but the loss calculation and post-processing parts are also dynamic. This can lead to slower training speeds when using the `torch.compile` function. Therefore, if you wish to enable the `torch.compile` function, you should follow these principles:
+
+1. Input images to the network are fixed shape, not multi-scale
+2. set `torch._dynamo.config.cache_size_limit` parameter. TorchDynamo will convert and cache the Python bytecode, and the compiled functions will be stored in the cache. When the next check finds that the function needs to be recompiled, the function will be recompiled and cached. However, if the number of recompilations exceeds the maximum value set (64), the function will no longer be cached or recompiled. As mentioned above, the loss calculation and post-processing parts of the object detection algorithm are also dynamically calculated, and these functions need to be recompiled every time. Therefore, setting the `torch._dynamo.config.cache_size_limit` parameter to a smaller value can effectively reduce the compilation time
+
+In MMDetection, you can set the `torch._dynamo.config.cache_size_limit` parameter through the environment variable `DYNAMO_CACHE_SIZE_LIMIT`. For example, the command is as follows:
+
+```shell
+# Single GPU
+export DYNAMO_CACHE_SIZE_LIMIT = 4
+python tools/train.py configs/rtmdet/rtmdet_s_8xb32-300e_coco.py  --cfg-options compile=True
+
+# Single node multiple GPUs
+export DYNAMO_CACHE_SIZE_LIMIT = 4
+./tools/dist_train.sh configs/rtmdet/rtmdet_s_8xb32-300e_coco.py 8 --cfg-options compile=True
+```
+
+About the common questions about PyTorch 2.0's dynamo, you can refer to [here](https://pytorch.org/docs/stable/dynamo/faq.html)
+
+## Installation
+
+Compatibility issue between MMCV and MMDetection; "ConvWS is already registered in conv layer"; "AssertionError: MMCV==xxx is used but incompatible. Please install mmcv>=xxx, \<=xxx."
+
+Compatible MMDetection, MMEngine, and MMCV versions are shown as below. Please choose the correct version of MMCV to avoid installation issues.
+
+| MMDetection version |      MMCV version       |     MMEngine version     |
+| :-----------------: | :---------------------: | :----------------------: |
+|        main         |  mmcv>=2.0.0, \<2.2.0   | mmengine>=0.7.1, \<1.0.0 |
+|        3.3.0        |  mmcv>=2.0.0, \<2.2.0   | mmengine>=0.7.1, \<1.0.0 |
+|        3.2.0        |  mmcv>=2.0.0, \<2.2.0   | mmengine>=0.7.1, \<1.0.0 |
+|        3.1.0        |  mmcv>=2.0.0, \<2.1.0   | mmengine>=0.7.1, \<1.0.0 |
+|        3.0.0        |  mmcv>=2.0.0, \<2.1.0   | mmengine>=0.7.1, \<1.0.0 |
+|      3.0.0rc6       | mmcv>=2.0.0rc4, \<2.1.0 | mmengine>=0.6.0, \<1.0.0 |
+|      3.0.0rc5       | mmcv>=2.0.0rc1, \<2.1.0 | mmengine>=0.3.0, \<1.0.0 |
+|      3.0.0rc4       | mmcv>=2.0.0rc1, \<2.1.0 | mmengine>=0.3.0, \<1.0.0 |
+|      3.0.0rc3       | mmcv>=2.0.0rc1, \<2.1.0 | mmengine>=0.3.0, \<1.0.0 |
+|      3.0.0rc2       | mmcv>=2.0.0rc1, \<2.1.0 | mmengine>=0.1.0, \<1.0.0 |
+|      3.0.0rc1       | mmcv>=2.0.0rc1, \<2.1.0 | mmengine>=0.1.0, \<1.0.0 |
+|      3.0.0rc0       | mmcv>=2.0.0rc1, \<2.1.0 | mmengine>=0.1.0, \<1.0.0 |
+
+**Note:**
+
+1. If you want to install mmdet-v2.x, the compatible MMDetection and MMCV versions table can be found at [here](https://mmdetection.readthedocs.io/en/stable/faq.html#installation). Please choose the correct version of MMCV to avoid installation issues.
+2. In MMCV-v2.x, `mmcv-full` is rename to `mmcv`, if you want to install `mmcv` without CUDA ops, you can install `mmcv-lite`.
+
+- "No module named 'mmcv.ops'"; "No module named 'mmcv.\_ext'".
+
+  1. Uninstall existing `mmcv-lite` in the environment using `pip uninstall mmcv-lite`.
+  2. Install `mmcv` following the [installation instruction](https://mmcv.readthedocs.io/en/2.x/get_started/installation.html).
+
+- "Microsoft Visual C++ 14.0 or graeter is required" during installation on Windows.
+
+  This error happens when building the 'pycocotools.\_mask' extension of pycocotools and the environment lacks corresponding C++ compilation dependencies. You need to download it at Microsoft officials [visual-cpp-build-tools](https://visualstudio.microsoft.com/zh-hans/visual-cpp-build-tools/),  select the "Use C ++ Desktop Development" option to install the minimum dependencies, and then reinstall pycocotools.
+
+- Using Albumentations
+
+  If you would like to use `albumentations`, we suggest using `pip install -r requirements/albu.txt` or
+  `pip install -U albumentations --no-binary qudida,albumentations`.
+  If you simply use `pip install albumentations>=0.3.2`, it will install `opencv-python-headless` simultaneously (even though you have already installed `opencv-python`).
+  Please refer to the [official documentation](https://albumentations.ai/docs/getting_started/installation/#note-on-opencv-dependencies) for details.
+
+- ModuleNotFoundError is raised when using some algorithms
+
+  Some extra dependencies are required for Instaboost, Panoptic Segmentation, LVIS dataset, etc. Please note the error message and install corresponding packages, e.g.,
+
+  ```shell
+  # for instaboost
+  pip install instaboostfast
+  # for panoptic segmentation
+  pip install git+https://github.com/cocodataset/panopticapi.git
+  # for LVIS dataset
+  pip install git+https://github.com/lvis-dataset/lvis-api.git
+  ```
+
+## Coding
+
+- Do I need to reinstall mmdet after some code modifications
+
+  If you follow the best practice and install mmdet with `pip install -e .`, any local modifications made to the code will take effect without reinstallation.
+
+- How to develop with multiple MMDetection versions
+
+  You can have multiple folders like mmdet-3.0, mmdet-3.1.
+  When you run the train or test script, it will adopt the mmdet package in the current folder.
+
+  To use the default MMDetection installed in the environment rather than the one you are working with, you can remove the following line in those scripts:
+
+  ```shell
+  PYTHONPATH="$(dirname $0)/..":$PYTHONPATH
+  ```
+
+## PyTorch/CUDA Environment
+
+- "RTX 30 series card fails when building MMCV or MMDet"
+
+  1. Temporary work-around: do `MMCV_WITH_OPS=1 MMCV_CUDA_ARGS='-gencode=arch=compute_80,code=sm_80' pip install -e .`.
+     The common issue is `nvcc fatal : Unsupported gpu architecture 'compute_86'`. This means that the compiler should optimize for sm_86, i.e., nvidia 30 series card, but such optimizations have not been supported by CUDA toolkit 11.0.
+     This work-around modifies the compile flag by adding `MMCV_CUDA_ARGS='-gencode=arch=compute_80,code=sm_80'`, which tells `nvcc` to optimize for **sm_80**, i.e., Nvidia A100. Although A100 is different from the 30 series card, they use similar ampere architecture. This may hurt the performance but it works.
+  2. PyTorch developers have updated that the default compiler flags should be fixed by [pytorch/pytorch#47585](https://github.com/pytorch/pytorch/pull/47585). So using PyTorch-nightly may also be able to solve the problem, though we have not tested it yet.
+
+- "invalid device function" or "no kernel image is available for execution".
+
+  1. Check if your cuda runtime version (under `/usr/local/`), `nvcc --version` and `conda list cudatoolkit` version match.
+  2. Run `python mmdet/utils/collect_env.py` to check whether PyTorch, torchvision, and MMCV are built for the correct GPU architecture.
+     You may need to set `TORCH_CUDA_ARCH_LIST` to reinstall MMCV.
+     The GPU arch table could be found [here](https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html#gpu-feature-list),
+     i.e. run `TORCH_CUDA_ARCH_LIST=7.0 pip install mmcv` to build MMCV for Volta GPUs.
+     The compatibility issue could happen when using old GPUS, e.g., Tesla K80 (3.7) on colab.
+  3. Check whether the running environment is the same as that when mmcv/mmdet has compiled.
+     For example, you may compile mmcv using CUDA 10.0 but run it on CUDA 9.0 environments.
+
+- "undefined symbol" or "cannot open xxx.so".
+
+  1. If those symbols are CUDA/C++ symbols (e.g., libcudart.so or GLIBCXX), check whether the CUDA/GCC runtimes are the same as those used for compiling mmcv,
+     i.e. run `python mmdet/utils/collect_env.py` to see if `"MMCV Compiler"`/`"MMCV CUDA Compiler"` is the same as `"GCC"`/`"CUDA_HOME"`.
+  2. If those symbols are PyTorch symbols (e.g., symbols containing caffe, aten, and TH), check whether the PyTorch version is the same as that used for compiling mmcv.
+  3. Run `python mmdet/utils/collect_env.py` to check whether PyTorch, torchvision, and MMCV are built by and running on the same environment.
+
+- setuptools.sandbox.UnpickleableException: DistutilsSetupError("each element of 'ext_modules' option must be an Extension instance or 2-tuple")
+
+  1. If you are using miniconda rather than anaconda, check whether Cython is installed as indicated in [#3379](https://github.com/open-mmlab/mmdetection/issues/3379).
+     You need to manually install Cython first and then run command `pip install -r requirements.txt`.
+  2. You may also need to check the compatibility between the `setuptools`, `Cython`, and `PyTorch` in your environment.
+
+- "Segmentation fault".
+
+  1. Check you GCC version and use GCC 5.4. This usually caused by the incompatibility between PyTorch and the environment (e.g., GCC \< 4.9 for PyTorch). We also recommend the users to avoid using GCC 5.5 because many feedbacks report that GCC 5.5 will cause "segmentation fault" and simply changing it to GCC 5.4 could solve the problem.
+
+  2. Check whether PyTorch is correctly installed and could use CUDA op, e.g. type the following command in your terminal.
+
+     ```shell
+     python -c 'import torch; print(torch.cuda.is_available())'
+     ```
+
+     And see whether they could correctly output results.
+
+  3. If Pytorch is correctly installed, check whether MMCV is correctly installed.
+
+     ```shell
+     python -c 'import mmcv; import mmcv.ops'
+     ```
+
+     If MMCV is correctly installed, then there will be no issue of the above two commands.
+
+  4. If MMCV and Pytorch is correctly installed, you man use `ipdb`, `pdb` to set breakpoints or directly add 'print' in mmdetection code and see which part leads the segmentation fault.
+
+## Training
+
+- "Loss goes Nan"
+
+  1. Check if the dataset annotations are valid: zero-size bounding boxes will cause the regression loss to be Nan due to the commonly used transformation for box regression. Some small size (width or height are smaller than 1) boxes will also cause this problem after data augmentation (e.g., instaboost). So check the data and try to filter out those zero-size boxes and skip some risky augmentations on the small-size boxes when you face the problem.
+  2. Reduce the learning rate: the learning rate might be too large due to some reasons, e.g., change of batch size. You can rescale them to the value that could stably train the model.
+  3. Extend the warmup iterations: some models are sensitive to the learning rate at the start of the training. You can extend the warmup iterations, e.g., change the `warmup_iters` from 500 to 1000 or 2000.
+  4. Add gradient clipping: some models requires gradient clipping to stabilize the training process. The default of `grad_clip` is `None`, you can add gradient clippint to avoid gradients that are too large, i.e., set `optim_wrapper=dict(clip_grad=dict(max_norm=35, norm_type=2))` in your config file.
+
+- "GPU out of memory"
+
+  1. There are some scenarios when there are large amount of ground truth boxes, which may cause OOM during target assignment. You can set `gpu_assign_thr=N` in the config of assigner thus the assigner will calculate box overlaps through CPU when there are more than N GT boxes.
+
+  2. Set `with_cp=True` in the backbone. This uses the sublinear strategy in PyTorch to reduce GPU memory cost in the backbone.
+
+  3. Try mixed precision training using following the examples in `config/fp16`. The `loss_scale` might need further tuning for different models.
+
+  4. Try to use `AvoidCUDAOOM` to avoid GPU out of memory. It will first retry after calling `torch.cuda.empty_cache()`. If it still fails, it will then retry by converting the type of inputs to FP16 format. If it still fails, it will try to copy inputs from GPUs to CPUs to continue computing. Try AvoidOOM in you code to make the code continue to run when GPU memory runs out:
+
+     ```python
+     from mmdet.utils import AvoidCUDAOOM
+
+     output = AvoidCUDAOOM.retry_if_cuda_oom(some_function)(input1, input2)
+     ```
+
+     You can also try `AvoidCUDAOOM` as a decorator to make the code continue to run when GPU memory runs out:
+
+     ```python
+     from mmdet.utils import AvoidCUDAOOM
+
+     @AvoidCUDAOOM.retry_if_cuda_oom
+     def function(*args, **kwargs):
+         ...
+         return xxx
+     ```
+
+- "RuntimeError: Expected to have finished reduction in the prior iteration before starting a new one"
+
+  1. This error indicates that your module has parameters that were not used in producing loss. This phenomenon may be caused by running different branches in your code in DDP mode.
+  2. You can set `find_unused_parameters = True` in the config to solve the above problems, but this will slow down the training speed.
+  3. You can set `detect_anomalous_params = True` in the config or `model_wrapper_cfg = dict(type='MMDistributedDataParallel', detect_anomalous_params=True)` (More details please refer to [MMEngine](https://github.com/open-mmlab/mmengine/blob/main/mmengine/model/wrappers/distributed.py#L91)) to get the name of those unused parameters. Note `detect_anomalous_params = True` will slow down the training speed, so it is recommended for debugging only.
+
+- Save the best model
+
+  It can be turned on by configuring `default_hooks = dict(checkpoint=dict(type='CheckpointHook', interval=1, save_best='auto'),`. In the case of the `auto` parameter, the first key in the returned evaluation result will be used as the basis for selecting the best model. You can also directly set the key in the evaluation result to manually set it, for example, `save_best='coco/bbox_mAP'`.
+
+## Evaluation
+
+- COCO Dataset, AP or AR = -1
+  1. According to the definition of COCO dataset, the small and medium areas in an image are less than 1024 (32\*32), 9216 (96\*96), respectively.
+  2. If the corresponding area has no object, the result of AP and AR will set to -1.
+
+## Model
+
+- `style` in ResNet
+
+  The `style` parameter in ResNet allows either `pytorch` or `caffe` style. It indicates the difference in the Bottleneck module. Bottleneck is a stacking structure of `1x1-3x3-1x1` convolutional layers. In the case of `caffe` mode, the convolution layer with `stride=2` is the first `1x1` convolution, while in `pyorch` mode, it is the second `3x3` convolution has `stride=2`. A sample code is as below:
+
+  ```python
+  if self.style == 'pytorch':
+        self.conv1_stride = 1
+        self.conv2_stride = stride
+  else:
+        self.conv1_stride = stride
+        self.conv2_stride = 1
+  ```
+
+- ResNeXt parameter description
+
+  ResNeXt comes from the paper [`Aggregated Residual Transformations for Deep Neural Networks`](https://arxiv.org/abs/1611.05431). It introduces  group and uses “cardinality” to control the number of groups to achieve a balance between accuracy and complexity. It controls the basic width and grouping parameters of the internal Bottleneck module through two hyperparameters `baseWidth` and `cardinality`. An example configuration name in MMDetection is `mask_rcnn_x101_64x4d_fpn_mstrain-poly_3x_coco.py`, where `mask_rcnn` represents the algorithm using Mask R-CNN, `x101` represents the backbone network using ResNeXt-101, and `64x4d` represents that the bottleneck block has 64 group and each group has basic width of 4.
+
+- `norm_eval` in backbone
+
+  Since the detection model is usually large and the input image resolution is high, this will result in a small batch of the detection model, which will make the variance of the statistics calculated by BatchNorm during the training process very large and not as stable as the statistics obtained during the pre-training of the backbone network . Therefore, the `norm_eval=True` mode is generally used in training, and the BatchNorm statistics in the pre-trained backbone network are directly used. The few algorithms that use large batches are the `norm_eval=False` mode, such as NASFPN. For the backbone network without ImageNet pre-training and the batch is relatively small, you can consider using `SyncBN`.
diff --git a/mmdetection/docs/en/notes/projects.md b/mmdetection/docs/en/notes/projects.md
new file mode 100644
index 00000000..3123e2b0
--- /dev/null
+++ b/mmdetection/docs/en/notes/projects.md
@@ -0,0 +1,57 @@
+# Projects based on MMDetection
+
+There are many projects built upon MMDetection.
+We list some of them as examples of how to extend MMDetection for your own projects.
+As the page might not be completed, please feel free to create a PR to update this page.
+
+## Projects as an extension
+
+Some projects extend the boundary of MMDetection for deployment or other research fields.
+They reveal the potential of what MMDetection can do. We list several of them as below.
+
+- [OTEDetection](https://github.com/opencv/mmdetection): OpenVINO training extensions for object detection.
+- [MMDetection3d](https://github.com/open-mmlab/mmdetection3d): OpenMMLab's next-generation platform for general 3D object detection.
+
+## Projects of papers
+
+There are also projects released with papers.
+Some of the papers are published in top-tier conferences (CVPR, ICCV, and ECCV), the others are also highly influential.
+To make this list also a reference for the community to develop and compare new object detection algorithms, we list them following the time order of top-tier conferences.
+Methods already supported and maintained by MMDetection are not listed.
+
+- Involution: Inverting the Inherence of Convolution for Visual Recognition, CVPR21. [\[paper\]](https://arxiv.org/abs/2103.06255)[\[github\]](https://github.com/d-li14/involution)
+- Multiple Instance Active Learning for Object Detection, CVPR 2021. [\[paper\]](https://openaccess.thecvf.com/content/CVPR2021/papers/Yuan_Multiple_Instance_Active_Learning_for_Object_Detection_CVPR_2021_paper.pdf)[\[github\]](https://github.com/yuantn/MI-AOD)
+- Adaptive Class Suppression Loss for Long-Tail Object Detection, CVPR 2021. [\[paper\]](https://arxiv.org/abs/2104.00885)[\[github\]](https://github.com/CASIA-IVA-Lab/ACSL)
+- Generalizable Pedestrian Detection: The Elephant In The Room, CVPR2021. [\[paper\]](https://arxiv.org/abs/2003.08799)[\[github\]](https://github.com/hasanirtiza/Pedestron)
+- Group Fisher Pruning for Practical Network Compression, ICML2021. [\[paper\]](https://github.com/jshilong/FisherPruning/blob/main/resources/paper.pdf)[\[github\]](https://github.com/jshilong/FisherPruning)
+- Overcoming Classifier Imbalance for Long-tail Object Detection with Balanced Group Softmax, CVPR2020. [\[paper\]](http://openaccess.thecvf.com/content_CVPR_2020/papers/Li_Overcoming_Classifier_Imbalance_for_Long-Tail_Object_Detection_With_Balanced_Group_CVPR_2020_paper.pdf)[\[github\]](https://github.com/FishYuLi/BalancedGroupSoftmax)
+- Coherent Reconstruction of Multiple Humans from a Single Image, CVPR2020. [\[paper\]](https://jiangwenpl.github.io/multiperson/)[\[github\]](https://github.com/JiangWenPL/multiperson)
+- Look-into-Object: Self-supervised Structure Modeling for Object Recognition, CVPR 2020. [\[paper\]](http://openaccess.thecvf.com/content_CVPR_2020/papers/Zhou_Look-Into-Object_Self-Supervised_Structure_Modeling_for_Object_Recognition_CVPR_2020_paper.pdf)[\[github\]](https://github.com/JDAI-CV/LIO)
+- Video Panoptic Segmentation, CVPR2020. [\[paper\]](https://arxiv.org/abs/2006.11339)[\[github\]](https://github.com/mcahny/vps)
+- D2Det: Towards High Quality Object Detection and Instance Segmentation, CVPR2020. [\[paper\]](http://openaccess.thecvf.com/content_CVPR_2020/html/Cao_D2Det_Towards_High_Quality_Object_Detection_and_Instance_Segmentation_CVPR_2020_paper.html)[\[github\]](https://github.com/JialeCao001/D2Det)
+- CentripetalNet: Pursuing High-quality Keypoint Pairs for Object Detection, CVPR2020. [\[paper\]](https://arxiv.org/abs/2003.09119)[\[github\]](https://github.com/KiveeDong/CentripetalNet)
+- Learning a Unified Sample Weighting Network for Object Detection, CVPR 2020. [\[paper\]](http://openaccess.thecvf.com/content_CVPR_2020/html/Cai_Learning_a_Unified_Sample_Weighting_Network_for_Object_Detection_CVPR_2020_paper.html)[\[github\]](https://github.com/caiqi/sample-weighting-network)
+- Scale-equalizing Pyramid Convolution for Object Detection, CVPR2020. [\[paper\]](https://arxiv.org/abs/2005.03101) [\[github\]](https://github.com/jshilong/SEPC)
+- Revisiting the Sibling Head in Object Detector, CVPR2020. [\[paper\]](https://arxiv.org/abs/2003.07540)[\[github\]](https://github.com/Sense-X/TSD)
+- PolarMask: Single Shot Instance Segmentation with Polar Representation, CVPR2020. [\[paper\]](https://arxiv.org/abs/1909.13226)[\[github\]](https://github.com/xieenze/PolarMask)
+- Hit-Detector: Hierarchical Trinity Architecture Search for Object Detection, CVPR2020. [\[paper\]](https://arxiv.org/abs/2003.11818)[\[github\]](https://github.com/ggjy/HitDet.pytorch)
+- ZeroQ: A Novel Zero Shot Quantization Framework, CVPR2020. [\[paper\]](https://arxiv.org/abs/2001.00281)[\[github\]](https://github.com/amirgholami/ZeroQ)
+- CBNet: A Novel Composite Backbone Network Architecture for Object Detection, AAAI2020. [\[paper\]](https://aaai.org/Papers/AAAI/2020GB/AAAI-LiuY.1833.pdf)[\[github\]](https://github.com/VDIGPKU/CBNet)
+- RDSNet: A New Deep Architecture for Reciprocal Object Detection and Instance Segmentation, AAAI2020. [\[paper\]](https://arxiv.org/abs/1912.05070)[\[github\]](https://github.com/wangsr126/RDSNet)
+- Training-Time-Friendly Network for Real-Time Object Detection, AAAI2020. [\[paper\]](https://arxiv.org/abs/1909.00700)[\[github\]](https://github.com/ZJULearning/ttfnet)
+- Cascade RPN: Delving into High-Quality Region Proposal Network with Adaptive Convolution, NeurIPS 2019. [\[paper\]](https://arxiv.org/abs/1909.06720)[\[github\]](https://github.com/thangvubk/Cascade-RPN)
+- Reasoning R-CNN: Unifying Adaptive Global Reasoning into Large-scale Object Detection, CVPR2019. [\[paper\]](http://openaccess.thecvf.com/content_CVPR_2019/papers/Xu_Reasoning-RCNN_Unifying_Adaptive_Global_Reasoning_Into_Large-Scale_Object_Detection_CVPR_2019_paper.pdf)[\[github\]](https://github.com/chanyn/Reasoning-RCNN)
+- Learning RoI Transformer for Oriented Object Detection in Aerial Images, CVPR2019. [\[paper\]](https://arxiv.org/abs/1812.00155)[\[github\]](https://github.com/dingjiansw101/AerialDetection)
+- SOLO: Segmenting Objects by Locations. [\[paper\]](https://arxiv.org/abs/1912.04488)[\[github\]](https://github.com/WXinlong/SOLO)
+- SOLOv2: Dynamic, Faster and Stronger. [\[paper\]](https://arxiv.org/abs/2003.10152)[\[github\]](https://github.com/WXinlong/SOLO)
+- Dense Peppoints: Representing Visual Objects with Dense Point Sets. [\[paper\]](https://arxiv.org/abs/1912.11473)[\[github\]](https://github.com/justimyhxu/Dense-RepPoints)
+- IterDet: Iterative Scheme for Object Detection in Crowded Environments. [\[paper\]](https://arxiv.org/abs/2005.05708)[\[github\]](https://github.com/saic-vul/iterdet)
+- Cross-Iteration Batch Normalization. [\[paper\]](https://arxiv.org/abs/2002.05712)[\[github\]](https://github.com/Howal/Cross-iterationBatchNorm)
+- A Ranking-based, Balanced Loss Function Unifying Classification and Localisation in Object Detection, NeurIPS2020 [\[paper\]](https://arxiv.org/abs/2009.13592)[\[github\]](https://github.com/kemaloksuz/aLRPLoss)
+- RelationNet++: Bridging Visual Representations for Object Detection via Transformer Decoder, NeurIPS2020 [\[paper\]](https://arxiv.org/abs/2010.15831)[\[github\]](https://github.com/microsoft/RelationNet2)
+- Generalized Focal Loss V2: Learning Reliable Localization Quality Estimation for Dense Object Detection, CVPR2021[\[paper\]](https://arxiv.org/abs/2011.12885)[\[github\]](https://github.com/implus/GFocalV2)
+- Swin Transformer: Hierarchical Vision Transformer using Shifted Windows, ICCV2021[\[paper\]](https://arxiv.org/abs/2103.14030)[\[github\]](https://github.com/SwinTransformer/)
+- Focal Transformer: Focal Self-attention for Local-Global Interactions in Vision Transformers, NeurIPS2021[\[paper\]](https://arxiv.org/abs/2107.00641)[\[github\]](https://github.com/microsoft/Focal-Transformer)
+- End-to-End Semi-Supervised Object Detection with Soft Teacher, ICCV2021[\[paper\]](https://arxiv.org/abs/2106.09018)[\[github\]](https://github.com/microsoft/SoftTeacher)
+- CBNetV2: A Novel Composite Backbone Network Architecture for Object Detection [\[paper\]](http://arxiv.org/abs/2107.00420)[\[github\]](https://github.com/VDIGPKU/CBNetV2)
+- Instances as Queries, ICCV2021 [\[paper\]](https://openaccess.thecvf.com/content/ICCV2021/papers/Fang_Instances_As_Queries_ICCV_2021_paper.pdf)[\[github\]](https://github.com/hustvl/QueryInst)
diff --git a/mmdetection/docs/en/overview.md b/mmdetection/docs/en/overview.md
new file mode 100644
index 00000000..7c7d96b7
--- /dev/null
+++ b/mmdetection/docs/en/overview.md
@@ -0,0 +1,54 @@
+# OVERVIEW
+
+This chapter introduces you to the framework of MMDetection, and provides links to detailed tutorials about MMDetection.
+
+## What is MMDetection
+
+![image](https://user-images.githubusercontent.com/12907710/137271636-56ba1cd2-b110-4812-8221-b4c120320aa9.png)
+
+MMDetection is an object detection toolbox that contains a rich set of object detection, instance segmentation, and panoptic segmentation methods as well as related components and modules, and below is its whole framework:
+
+MMDetection consists of 7 main parts, apis, structures, datasets, models, engine, evaluation and visualization.
+
+- **apis** provides high-level APIs for model inference.
+- **structures** provides data structures like bbox, mask, and DetDataSample.
+- **datasets** supports various dataset for object detection, instance segmentation, and panoptic segmentation.
+  - **transforms** contains a lot of useful data augmentation transforms.
+  - **samplers** defines different data loader sampling strategy.
+- **models** is the most vital part for detectors and contains different components of a detector.
+  - **detectors** defines all of the detection model classes.
+  - **data_preprocessors** is for preprocessing the input data of the model.
+  - **backbones** contains various backbone networks.
+  - **necks** contains various neck components.
+  - **dense_heads** contains various detection heads that perform dense predictions.
+  - **roi_heads** contains various detection heads that predict from RoIs.
+  - **seg_heads** contains various segmentation heads.
+  - **losses** contains various loss functions.
+  - **task_modules** provides modules for detection tasks. E.g. assigners, samplers, box coders, and prior generators.
+  - **layers** provides some basic neural network layers.
+- **engine** is a part for runtime components.
+  - **runner** provides extensions for [MMEngine's runner](https://mmengine.readthedocs.io/en/latest/tutorials/runner.html).
+  - **schedulers** provides schedulers for adjusting optimization hyperparameters.
+  - **optimizers** provides optimizers and optimizer wrappers.
+  - **hooks** provides various hooks of the runner.
+- **evaluation** provides different metrics for evaluating model performance.
+- **visualization** is for visualizing detection results.
+
+## How to Use this Guide
+
+Here is a detailed step-by-step guide to learn more about MMDetection:
+
+1. For installation instructions, please see [get_started](get_started.md).
+
+2. Refer to the below tutorials for the basic usage of MMDetection.
+
+   - [Train and Test](https://mmdetection.readthedocs.io/en/latest/user_guides/index.html#train-test)
+
+   - [Useful Tools](https://mmdetection.readthedocs.io/en/latest/user_guides/index.html#useful-tools)
+
+3. Refer to the below tutorials to dive deeper:
+
+   - [Basic Concepts](https://mmdetection.readthedocs.io/en/latest/advanced_guides/index.html#basic-concepts)
+   - [Component Customization](https://mmdetection.readthedocs.io/en/latest/advanced_guides/index.html#component-customization)
+
+4. For users of MMDetection 2.x version, we provide a guide to help you adapt to the new version. You can find it in the [migration guide](./migration/migration.md).
diff --git a/mmdetection/docs/en/stat.py b/mmdetection/docs/en/stat.py
new file mode 100644
index 00000000..f0589e33
--- /dev/null
+++ b/mmdetection/docs/en/stat.py
@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+import functools as func
+import glob
+import os.path as osp
+import re
+
+import numpy as np
+
+url_prefix = 'https://github.com/open-mmlab/mmdetection/blob/main/configs'
+
+files = sorted(glob.glob('../../configs/*/README.md'))
+
+stats = []
+titles = []
+num_ckpts = 0
+
+for f in files:
+    url = osp.dirname(f.replace('../../configs', url_prefix))
+
+    with open(f, 'r') as content_file:
+        content = content_file.read()
+
+    title = content.split('\n')[0].replace('# ', '').strip()
+    ckpts = set(x.lower().strip()
+                for x in re.findall(r'\[model\]\((https?.*)\)', content))
+
+    if len(ckpts) == 0:
+        continue
+
+    _papertype = [x for x in re.findall(r'\[([A-Z]+)\]', content)]
+    assert len(_papertype) > 0
+    papertype = _papertype[0]
+
+    paper = set([(papertype, title)])
+
+    titles.append(title)
+    num_ckpts += len(ckpts)
+
+    statsmsg = f"""
+\t* [{papertype}] [{title}]({url}) ({len(ckpts)} ckpts)
+"""
+    stats.append((paper, ckpts, statsmsg))
+
+allpapers = func.reduce(lambda a, b: a.union(b), [p for p, _, _ in stats])
+msglist = '\n'.join(x for _, _, x in stats)
+
+papertypes, papercounts = np.unique([t for t, _ in allpapers],
+                                    return_counts=True)
+countstr = '\n'.join(
+    [f'   - {t}: {c}' for t, c in zip(papertypes, papercounts)])
+
+modelzoo = f"""
+# Model Zoo Statistics
+
+* Number of papers: {len(set(titles))}
+{countstr}
+
+* Number of checkpoints: {num_ckpts}
+
+{msglist}
+"""
+
+with open('modelzoo_statistics.md', 'w') as f:
+    f.write(modelzoo)
diff --git a/mmdetection/docs/en/switch_language.md b/mmdetection/docs/en/switch_language.md
new file mode 100644
index 00000000..b2c4ad9d
--- /dev/null
+++ b/mmdetection/docs/en/switch_language.md
@@ -0,0 +1,3 @@
+## English
+
+## 简体中文
diff --git a/mmdetection/docs/en/user_guides/config.md b/mmdetection/docs/en/user_guides/config.md
new file mode 100644
index 00000000..69bd9119
--- /dev/null
+++ b/mmdetection/docs/en/user_guides/config.md
@@ -0,0 +1,612 @@
+# Learn about Configs
+
+MMDetection and other OpenMMLab repositories use [MMEngine's config system](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html). It has a modular and inheritance design, which is convenient to conduct various experiments.
+
+## Config file content
+
+MMDetection uses a modular design, all modules with different functions can be configured through the config. Taking Mask R-CNN as an example, we will introduce each field in the config according to different function modules:
+
+### Model config
+
+In MMDetection's config, we use `model` to set up detection algorithm components. In addition to neural network components such as `backbone`, `neck`, etc, it also requires `data_preprocessor`, `train_cfg`, and `test_cfg`. `data_preprocessor` is responsible for processing a batch of data output by dataloader. `train_cfg`, and `test_cfg` in the model config are for training and testing hyperparameters of the components.
+
+```python
+model = dict(
+    type='MaskRCNN',  # The name of detector
+    data_preprocessor=dict(  # The config of data preprocessor, usually includes image normalization and padding
+        type='DetDataPreprocessor',  # The type of the data preprocessor, refer to https://mmdetection.readthedocs.io/en/latest/api.html#mmdet.models.data_preprocessors.DetDataPreprocessor
+        mean=[123.675, 116.28, 103.53],  # Mean values used to pre-training the pre-trained backbone models, ordered in R, G, B
+        std=[58.395, 57.12, 57.375],  # Standard variance used to pre-training the pre-trained backbone models, ordered in R, G, B
+        bgr_to_rgb=True,  # whether to convert image from BGR to RGB
+        pad_mask=True,  # whether to pad instance masks
+        pad_size_divisor=32),  # The size of padded image should be divisible by ``pad_size_divisor``
+    backbone=dict(  # The config of backbone
+        type='ResNet',  # The type of backbone network. Refer to https://mmdetection.readthedocs.io/en/latest/api.html#mmdet.models.backbones.ResNet
+        depth=50,  # The depth of backbone, usually it is 50 or 101 for ResNet and ResNext backbones.
+        num_stages=4,  # Number of stages of the backbone.
+        out_indices=(0, 1, 2, 3),  # The index of output feature maps produced in each stage
+        frozen_stages=1,  # The weights in the first stage are frozen
+        norm_cfg=dict(  # The config of normalization layers.
+            type='BN',  # Type of norm layer, usually it is BN or GN
+            requires_grad=True),  # Whether to train the gamma and beta in BN
+        norm_eval=True,  # Whether to freeze the statistics in BN
+        style='pytorch', # The style of backbone, 'pytorch' means that stride 2 layers are in 3x3 Conv, 'caffe' means stride 2 layers are in 1x1 Convs.
+    	init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),  # The ImageNet pretrained backbone to be loaded
+    neck=dict(
+        type='FPN',  # The neck of detector is FPN. We also support 'NASFPN', 'PAFPN', etc. Refer to https://mmdetection.readthedocs.io/en/latest/api.html#mmdet.models.necks.FPN for more details.
+        in_channels=[256, 512, 1024, 2048],  # The input channels, this is consistent with the output channels of backbone
+        out_channels=256,  # The output channels of each level of the pyramid feature map
+        num_outs=5),  # The number of output scales
+    rpn_head=dict(
+        type='RPNHead',  # The type of RPN head is 'RPNHead', we also support 'GARPNHead', etc. Refer to https://mmdetection.readthedocs.io/en/latest/api.html#mmdet.models.dense_heads.RPNHead for more details.
+        in_channels=256,  # The input channels of each input feature map, this is consistent with the output channels of neck
+        feat_channels=256,  # Feature channels of convolutional layers in the head.
+        anchor_generator=dict(  # The config of anchor generator
+            type='AnchorGenerator',  # Most of methods use AnchorGenerator, SSD Detectors uses `SSDAnchorGenerator`. Refer to https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/task_modules/prior_generators/anchor_generator.py#L18 for more details
+            scales=[8],  # Basic scale of the anchor, the area of the anchor in one position of a feature map will be scale * base_sizes
+            ratios=[0.5, 1.0, 2.0],  # The ratio between height and width.
+            strides=[4, 8, 16, 32, 64]),  # The strides of the anchor generator. This is consistent with the FPN feature strides. The strides will be taken as base_sizes if base_sizes is not set.
+        bbox_coder=dict(  # Config of box coder to encode and decode the boxes during training and testing
+            type='DeltaXYWHBBoxCoder',  # Type of box coder. 'DeltaXYWHBBoxCoder' is applied for most of the methods. Refer to https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/task_modules/coders/delta_xywh_bbox_coder.py#L13 for more details.
+            target_means=[0.0, 0.0, 0.0, 0.0],  # The target means used to encode and decode boxes
+            target_stds=[1.0, 1.0, 1.0, 1.0]),  # The standard variance used to encode and decode boxes
+        loss_cls=dict(  # Config of loss function for the classification branch
+            type='CrossEntropyLoss',  # Type of loss for classification branch, we also support FocalLoss etc. Refer to https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/losses/cross_entropy_loss.py#L201 for more details
+            use_sigmoid=True,  # RPN usually performs two-class classification, so it usually uses the sigmoid function.
+            loss_weight=1.0),  # Loss weight of the classification branch.
+        loss_bbox=dict(  # Config of loss function for the regression branch.
+            type='L1Loss',  # Type of loss, we also support many IoU Losses and smooth L1-loss, etc. Refer to https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/losses/smooth_l1_loss.py#L56 for implementation.
+            loss_weight=1.0)),  # Loss weight of the regression branch.
+    roi_head=dict(  # RoIHead encapsulates the second stage of two-stage/cascade detectors.
+        type='StandardRoIHead',
+        bbox_roi_extractor=dict(  # RoI feature extractor for bbox regression.
+            type='SingleRoIExtractor',  # Type of the RoI feature extractor, most of methods uses SingleRoIExtractor. Refer to https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/roi_heads/roi_extractors/single_level_roi_extractor.py#L13 for details.
+            roi_layer=dict(  # Config of RoI Layer
+                type='RoIAlign',  # Type of RoI Layer, DeformRoIPoolingPack and ModulatedDeformRoIPoolingPack are also supported. Refer to https://mmcv.readthedocs.io/en/latest/api.html#mmcv.ops.RoIAlign for details.
+                output_size=7,  # The output size of feature maps.
+                sampling_ratio=0),  # Sampling ratio when extracting the RoI features. 0 means adaptive ratio.
+            out_channels=256,  # output channels of the extracted feature.
+            featmap_strides=[4, 8, 16, 32]),  # Strides of multi-scale feature maps. It should be consistent with the architecture of the backbone.
+        bbox_head=dict(  # Config of box head in the RoIHead.
+            type='Shared2FCBBoxHead',  # Type of the bbox head, Refer to https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/roi_heads/bbox_heads/convfc_bbox_head.py#L220 for implementation details.
+            in_channels=256,  # Input channels for bbox head. This is consistent with the out_channels in roi_extractor
+            fc_out_channels=1024,  # Output feature channels of FC layers.
+            roi_feat_size=7,  # Size of RoI features
+            num_classes=80,  # Number of classes for classification
+            bbox_coder=dict(  # Box coder used in the second stage.
+                type='DeltaXYWHBBoxCoder',  # Type of box coder. 'DeltaXYWHBBoxCoder' is applied for most of the methods.
+                target_means=[0.0, 0.0, 0.0, 0.0],  # Means used to encode and decode box
+                target_stds=[0.1, 0.1, 0.2, 0.2]),  # Standard variance for encoding and decoding. It is smaller since the boxes are more accurate. [0.1, 0.1, 0.2, 0.2] is a conventional setting.
+            reg_class_agnostic=False,  # Whether the regression is class agnostic.
+            loss_cls=dict(  # Config of loss function for the classification branch
+                type='CrossEntropyLoss',  # Type of loss for classification branch, we also support FocalLoss etc.
+                use_sigmoid=False,  # Whether to use sigmoid.
+                loss_weight=1.0),  # Loss weight of the classification branch.
+            loss_bbox=dict(  # Config of loss function for the regression branch.
+                type='L1Loss',  # Type of loss, we also support many IoU Losses and smooth L1-loss, etc.
+                loss_weight=1.0)),  # Loss weight of the regression branch.
+        mask_roi_extractor=dict(  # RoI feature extractor for mask generation.
+            type='SingleRoIExtractor',  # Type of the RoI feature extractor, most of methods uses SingleRoIExtractor.
+            roi_layer=dict(  # Config of RoI Layer that extracts features for instance segmentation
+                type='RoIAlign',  # Type of RoI Layer, DeformRoIPoolingPack and ModulatedDeformRoIPoolingPack are also supported
+                output_size=14,  # The output size of feature maps.
+                sampling_ratio=0),  # Sampling ratio when extracting the RoI features.
+            out_channels=256,  # Output channels of the extracted feature.
+            featmap_strides=[4, 8, 16, 32]),  # Strides of multi-scale feature maps.
+        mask_head=dict(  # Mask prediction head
+            type='FCNMaskHead',  # Type of mask head, refer to https://mmdetection.readthedocs.io/en/latest/api.html#mmdet.models.roi_heads.FCNMaskHead for implementation details.
+            num_convs=4,  # Number of convolutional layers in mask head.
+            in_channels=256,  # Input channels, should be consistent with the output channels of mask roi extractor.
+            conv_out_channels=256,  # Output channels of the convolutional layer.
+            num_classes=80,  # Number of class to be segmented.
+            loss_mask=dict(  # Config of loss function for the mask branch.
+                type='CrossEntropyLoss',  # Type of loss used for segmentation
+                use_mask=True,  # Whether to only train the mask in the correct class.
+                loss_weight=1.0))),  # Loss weight of mask branch.
+    train_cfg = dict(  # Config of training hyperparameters for rpn and rcnn
+        rpn=dict(  # Training config of rpn
+            assigner=dict(  # Config of assigner
+                type='MaxIoUAssigner',  # Type of assigner, MaxIoUAssigner is used for many common detectors. Refer to https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/task_modules/assigners/max_iou_assigner.py#L14 for more details.
+                pos_iou_thr=0.7,  # IoU >= threshold 0.7 will be taken as positive samples
+                neg_iou_thr=0.3,  # IoU < threshold 0.3 will be taken as negative samples
+                min_pos_iou=0.3,  # The minimal IoU threshold to take boxes as positive samples
+                match_low_quality=True,  # Whether to match the boxes under low quality (see API doc for more details).
+                ignore_iof_thr=-1),  # IoF threshold for ignoring bboxes
+            sampler=dict(  # Config of positive/negative sampler
+                type='RandomSampler',  # Type of sampler, PseudoSampler and other samplers are also supported. Refer to https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/task_modules/samplers/random_sampler.py#L14 for implementation details.
+                num=256,  # Number of samples
+                pos_fraction=0.5,  # The ratio of positive samples in the total samples.
+                neg_pos_ub=-1,  # The upper bound of negative samples based on the number of positive samples.
+                add_gt_as_proposals=False),  # Whether add GT as proposals after sampling.
+            allowed_border=-1,  # The border allowed after padding for valid anchors.
+            pos_weight=-1,  # The weight of positive samples during training.
+            debug=False),  # Whether to set the debug mode
+        rpn_proposal=dict(  # The config to generate proposals during training
+            nms_across_levels=False,  # Whether to do NMS for boxes across levels. Only work in `GARPNHead`, naive rpn does not support do nms cross levels.
+            nms_pre=2000,  # The number of boxes before NMS
+            nms_post=1000,  # The number of boxes to be kept by NMS. Only work in `GARPNHead`.
+            max_per_img=1000,  # The number of boxes to be kept after NMS.
+            nms=dict( # Config of NMS
+                type='nms',  # Type of NMS
+                iou_threshold=0.7 # NMS threshold
+                ),
+            min_bbox_size=0),  # The allowed minimal box size
+        rcnn=dict(  # The config for the roi heads.
+            assigner=dict(  # Config of assigner for second stage, this is different for that in rpn
+                type='MaxIoUAssigner',  # Type of assigner, MaxIoUAssigner is used for all roi_heads for now. Refer to https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/task_modules/assigners/max_iou_assigner.py#L14 for more details.
+                pos_iou_thr=0.5,  # IoU >= threshold 0.5 will be taken as positive samples
+                neg_iou_thr=0.5,  # IoU < threshold 0.5 will be taken as negative samples
+                min_pos_iou=0.5,  # The minimal IoU threshold to take boxes as positive samples
+                match_low_quality=False,  # Whether to match the boxes under low quality (see API doc for more details).
+                ignore_iof_thr=-1),  # IoF threshold for ignoring bboxes
+            sampler=dict(
+                type='RandomSampler',  # Type of sampler, PseudoSampler and other samplers are also supported. Refer to https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/task_modules/samplers/random_sampler.py#L14 for implementation details.
+                num=512,  # Number of samples
+                pos_fraction=0.25,  # The ratio of positive samples in the total samples.
+                neg_pos_ub=-1,  # The upper bound of negative samples based on the number of positive samples.
+                add_gt_as_proposals=True
+            ),  # Whether add GT as proposals after sampling.
+            mask_size=28,  # Size of mask
+            pos_weight=-1,  # The weight of positive samples during training.
+            debug=False)),  # Whether to set the debug mode
+    test_cfg = dict(  # Config for testing hyperparameters for rpn and rcnn
+        rpn=dict(  # The config to generate proposals during testing
+            nms_across_levels=False,  # Whether to do NMS for boxes across levels. Only work in `GARPNHead`, naive rpn does not support do nms cross levels.
+            nms_pre=1000,  # The number of boxes before NMS
+            nms_post=1000,  # The number of boxes to be kept by NMS. Only work in `GARPNHead`.
+            max_per_img=1000,  # The number of boxes to be kept after NMS.
+            nms=dict( # Config of NMS
+                type='nms',  #Type of NMS
+                iou_threshold=0.7 # NMS threshold
+                ),
+            min_bbox_size=0),  # The allowed minimal box size
+        rcnn=dict(  # The config for the roi heads.
+            score_thr=0.05,  # Threshold to filter out boxes
+            nms=dict(  # Config of NMS in the second stage
+                type='nms',  # Type of NMS
+                iou_thr=0.5),  # NMS threshold
+            max_per_img=100,  # Max number of detections of each image
+            mask_thr_binary=0.5)))  # Threshold of mask prediction
+```
+
+### Dataset and evaluator config
+
+[Dataloaders](https://mmengine.readthedocs.io/en/latest/tutorials/dataset.html) are required for the training, validation, and testing of the [runner](https://mmengine.readthedocs.io/en/latest/tutorials/runner.html). Dataset and data pipeline need to be set to build the dataloader. Due to the complexity of this part, we use intermediate variables to simplify the writing of dataloader configs.
+
+```python
+dataset_type = 'CocoDataset'  # Dataset type, this will be used to define the dataset
+data_root = 'data/coco/'  # Root path of data
+backend_args = None # Arguments to instantiate the corresponding file backend
+
+train_pipeline = [  # Training data processing pipeline
+    dict(type='LoadImageFromFile', backend_args=backend_args),  # First pipeline to load images from file path
+    dict(
+        type='LoadAnnotations',  # Second pipeline to load annotations for current image
+        with_bbox=True,  # Whether to use bounding box, True for detection
+        with_mask=True,  # Whether to use instance mask, True for instance segmentation
+        poly2mask=True),  # Whether to convert the polygon mask to instance mask, set False for acceleration and to save memory
+    dict(
+        type='Resize',  # Pipeline that resizes the images and their annotations
+        scale=(1333, 800),  # The largest scale of the images
+        keep_ratio=True  # Whether to keep the ratio between height and width
+        ),
+    dict(
+        type='RandomFlip',  # Augmentation pipeline that flips the images and their annotations
+        prob=0.5),  # The probability to flip
+    dict(type='PackDetInputs')  # Pipeline that formats the annotation data and decides which keys in the data should be packed into data_samples
+]
+test_pipeline = [  # Testing data processing pipeline
+    dict(type='LoadImageFromFile', backend_args=backend_args),  # First pipeline to load images from file path
+    dict(type='Resize', scale=(1333, 800), keep_ratio=True),  # Pipeline that resizes the images
+    dict(
+        type='PackDetInputs',  # Pipeline that formats the annotation data and decides which keys in the data should be packed into data_samples
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+train_dataloader = dict(   # Train dataloader config
+    batch_size=2,  # Batch size of a single GPU
+    num_workers=2,  # Worker to pre-fetch data for each single GPU
+    persistent_workers=True,  # If ``True``, the dataloader will not shut down the worker processes after an epoch end, which can accelerate training speed.
+    sampler=dict(  # training data sampler
+        type='DefaultSampler',  # DefaultSampler which supports both distributed and non-distributed training. Refer to https://mmengine.readthedocs.io/en/latest/api/generated/mmengine.dataset.DefaultSampler.html#mmengine.dataset.DefaultSampler
+        shuffle=True),  # randomly shuffle the training data in each epoch
+    batch_sampler=dict(type='AspectRatioBatchSampler'),  # Batch sampler for grouping images with similar aspect ratio into a same batch. It can reduce GPU memory cost.
+    dataset=dict(  # Train dataset config
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='annotations/instances_train2017.json',  # Path of annotation file
+        data_prefix=dict(img='train2017/'),  # Prefix of image path
+        filter_cfg=dict(filter_empty_gt=True, min_size=32),  # Config of filtering images and annotations
+        pipeline=train_pipeline,
+        backend_args=backend_args))
+val_dataloader = dict(  # Validation dataloader config
+    batch_size=1,  # Batch size of a single GPU. If batch-size > 1, the extra padding area may influence the performance.
+    num_workers=2,  # Worker to pre-fetch data for each single GPU
+    persistent_workers=True,  # If ``True``, the dataloader will not shut down the worker processes after an epoch end, which can accelerate training speed.
+    drop_last=False,  # Whether to drop the last incomplete batch, if the dataset size is not divisible by the batch size
+    sampler=dict(
+        type='DefaultSampler',
+        shuffle=False),  # not shuffle during validation and testing
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='annotations/instances_val2017.json',
+        data_prefix=dict(img='val2017/'),
+        test_mode=True,  # Turn on the test mode of the dataset to avoid filtering annotations or images
+        pipeline=test_pipeline,
+        backend_args=backend_args))
+test_dataloader = val_dataloader  # Testing dataloader config
+```
+
+[Evaluators](https://mmengine.readthedocs.io/en/latest/tutorials/evaluation.html) are used to compute the metrics of the trained model on the validation and testing datasets. The config of evaluators consists of one or a list of metric configs:
+
+```python
+val_evaluator = dict(  # Validation evaluator config
+    type='CocoMetric',  # The coco metric used to evaluate AR, AP, and mAP for detection and instance segmentation
+    ann_file=data_root + 'annotations/instances_val2017.json',  # Annotation file path
+    metric=['bbox', 'segm'],  # Metrics to be evaluated, `bbox` for detection and `segm` for instance segmentation
+    format_only=False,
+    backend_args=backend_args)
+test_evaluator = val_evaluator  # Testing evaluator config
+```
+
+Since the test dataset has no annotation files, the test_dataloader and test_evaluator config in MMDetection are generally equal to the val's. If you want to save the detection results on the test dataset, you can write the config like this:
+
+```python
+# inference on test dataset and
+# format the output results for submission.
+test_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file=data_root + 'annotations/image_info_test-dev2017.json',
+        data_prefix=dict(img='test2017/'),
+        test_mode=True,
+        pipeline=test_pipeline))
+test_evaluator = dict(
+    type='CocoMetric',
+    ann_file=data_root + 'annotations/image_info_test-dev2017.json',
+    metric=['bbox', 'segm'],  # Metrics to be evaluated
+    format_only=True,  # Only format and save the results to coco json file
+    outfile_prefix='./work_dirs/coco_detection/test')  # The prefix of output json files
+```
+
+### Training and testing config
+
+MMEngine's runner uses Loop to control the training, validation, and testing processes.
+Users can set the maximum training epochs and validation intervals with these fields.
+
+```python
+train_cfg = dict(
+    type='EpochBasedTrainLoop',  # The training loop type. Refer to https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py
+    max_epochs=12,  # Maximum training epochs
+    val_interval=1)  # Validation intervals. Run validation every epoch.
+val_cfg = dict(type='ValLoop')  # The validation loop type
+test_cfg = dict(type='TestLoop')  # The testing loop type
+```
+
+### Optimization config
+
+`optim_wrapper` is the field to configure optimization-related settings. The optimizer wrapper not only provides the functions of the optimizer, but also supports functions such as gradient clipping, mixed precision training, etc. Find more in [optimizer wrapper tutorial](https://mmengine.readthedocs.io/en/latest/tutorials/optim_wrapper.html).
+
+```python
+optim_wrapper = dict(  # Optimizer wrapper config
+    type='OptimWrapper',  # Optimizer wrapper type, switch to AmpOptimWrapper to enable mixed precision training.
+    optimizer=dict(  # Optimizer config. Support all kinds of optimizers in PyTorch. Refer to https://pytorch.org/docs/stable/optim.html#algorithms
+        type='SGD',  # Stochastic gradient descent optimizer
+        lr=0.02,  # The base learning rate
+        momentum=0.9,  # Stochastic gradient descent with momentum
+        weight_decay=0.0001),  # Weight decay of SGD
+    clip_grad=None,  # Gradient clip option. Set None to disable gradient clip. Find usage in https://mmengine.readthedocs.io/en/latest/tutorials/optimizer.html
+    )
+```
+
+`param_scheduler` is a field that configures methods of adjusting optimization hyperparameters such as learning rate and momentum. Users can combine multiple schedulers to create a desired parameter adjustment strategy. Find more in [parameter scheduler tutorial](https://mmengine.readthedocs.io/en/latest/tutorials/param_scheduler.html) and [parameter scheduler API documents](https://mmengine.readthedocs.io/en/latest/api/generated/mmengine.optim._ParamScheduler.html#mmengine.optim._ParamScheduler)
+
+```python
+param_scheduler = [
+    # Linear learning rate warm-up scheduler
+    dict(
+        type='LinearLR',  # Use linear policy to warmup learning rate
+        start_factor=0.001, # The ratio of the starting learning rate used for warmup
+        by_epoch=False,  # The warmup learning rate is updated by iteration
+        begin=0,  # Start from the first iteration
+        end=500),  # End the warmup at the 500th iteration
+    # The main LRScheduler
+    dict(
+        type='MultiStepLR',  # Use multi-step learning rate policy during training
+        by_epoch=True,  # The learning rate is updated by epoch
+        begin=0,   # Start from the first epoch
+        end=12,  # End at the 12th epoch
+        milestones=[8, 11],  # Epochs to decay the learning rate
+        gamma=0.1)  # The learning rate decay ratio
+]
+```
+
+### Hook config
+
+Users can attach Hooks to training, validation, and testing loops to insert some operations during running. There are two different hook fields, one is `default_hooks` and the other is `custom_hooks`.
+
+`default_hooks` is a dict of hook configs, and they are the hooks must be required at the runtime. They have default priority which should not be modified. If not set, runner will use the default values. To disable a default hook, users can set its config to `None`. Find more in [HOOK](https://mmengine.readthedocs.io/en/latest/tutorials/hook.html).
+
+```python
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),  # Update the time spent during iteration into message hub
+    logger=dict(type='LoggerHook', interval=50),  # Collect logs from different components of Runner and write them to terminal, JSON file, tensorboard and wandb .etc
+    param_scheduler=dict(type='ParamSchedulerHook'), # update some hyper-parameters of optimizer
+    checkpoint=dict(type='CheckpointHook', interval=1), # Save checkpoints periodically
+    sampler_seed=dict(type='DistSamplerSeedHook'),  # Ensure distributed Sampler shuffle is active
+    visualization=dict(type='DetVisualizationHook'))  # Detection Visualization Hook. Used to visualize validation and testing process prediction results
+```
+
+`custom_hooks` is a list of all other hook configs. Users can develop their own hooks and insert them in this field.
+
+```python
+custom_hooks = []
+```
+
+### Runtime config
+
+```python
+default_scope = 'mmdet'  # The default registry scope to find modules. Refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/registry.html
+
+env_cfg = dict(
+    cudnn_benchmark=False,  # Whether to enable cudnn benchmark
+    mp_cfg=dict(  # Multi-processing config
+        mp_start_method='fork',  # Use fork to start multi-processing threads. 'fork' usually faster than 'spawn' but maybe unsafe. See discussion in https://github.com/pytorch/pytorch/issues/1355
+        opencv_num_threads=0),  # Disable opencv multi-threads to avoid system being overloaded
+    dist_cfg=dict(backend='nccl'),  # Distribution configs
+)
+
+vis_backends = [dict(type='LocalVisBackend')]  # Visualization backends. Refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/visualization.html
+visualizer = dict(
+    type='DetLocalVisualizer', vis_backends=vis_backends, name='visualizer')
+log_processor = dict(
+    type='LogProcessor',  # Log processor to process runtime logs
+    window_size=50,  # Smooth interval of log values
+    by_epoch=True)  # Whether to format logs with epoch type. Should be consistent with the train loop's type.
+
+log_level = 'INFO'  # The level of logging.
+load_from = None  # Load model checkpoint as a pre-trained model from a given path. This will not resume training.
+resume = False  # Whether to resume from the checkpoint defined in `load_from`. If `load_from` is None, it will resume the latest checkpoint in the `work_dir`.
+```
+
+## Iter-based config
+
+MMEngine's Runner also provides an iter-based training loop except for epoch-based.
+To use iter-based training, users should modify the `train_cfg`, `param_scheduler`, `train_dataloader`, `default_hooks`, and `log_processor`.
+Here is an example of changing an epoch-based RetinaNet config to iter-based: `configs/retinanet/retinanet_r50_fpn_90k_coco.py`
+
+```python
+# Iter-based training config
+train_cfg = dict(
+    _delete_=True,  # Ignore the base config setting (optional)
+    type='IterBasedTrainLoop',  # Use iter-based training loop
+    max_iters=90000,  # Maximum iterations
+    val_interval=10000)  # Validation interval
+
+
+# Change the scheduler to iter-based
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500),
+    dict(
+        type='MultiStepLR',
+        begin=0,
+        end=90000,
+        by_epoch=False,
+        milestones=[60000, 80000],
+        gamma=0.1)
+]
+
+# Switch to InfiniteSampler to avoid dataloader restart
+train_dataloader = dict(sampler=dict(type='InfiniteSampler'))
+
+# Change the checkpoint saving interval to iter-based
+default_hooks = dict(checkpoint=dict(by_epoch=False, interval=10000))
+
+# Change the log format to iter-based
+log_processor = dict(by_epoch=False)
+```
+
+## Config file inheritance
+
+There are 4 basic component types under `config/_base_`, dataset, model, schedule, default_runtime.
+Many methods could be easily constructed with one of these models like Faster R-CNN, Mask R-CNN, Cascade R-CNN, RPN, SSD.
+The configs that are composed by components from `_base_` are called the _primitive_.
+
+For all configs under the same folder, it is recommended to have only **one** _primitive_ config. All other configs should inherit from the _primitive_ config. In this way, the maximum of inheritance level is 3.
+
+For easy understanding, we recommend contributors to inherit from existing methods.
+For example, if some modification is made based on Faster R-CNN, users may first inherit the basic Faster R-CNN structure by specifying `_base_ = ../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py`, then modify the necessary fields in the config files.
+
+If you are building an entirely new method that does not share the structure with any of the existing methods, you may create a folder `xxx_rcnn` under `configs`,
+
+Please refer to [mmengine config tutorial](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html) for detailed documentation.
+
+By setting the `_base_` field, we can set which files the current configuration file inherits from.
+
+When `_base_` is a string of a file path, it means inheriting the contents from one config file.
+
+```python
+_base_ = './mask-rcnn_r50_fpn_1x_coco.py'
+```
+
+When `_base_` is a list of multiple file paths, it means inheriting from multiple files.
+
+```python
+_base_ = [
+    '../_base_/models/mask-rcnn_r50_fpn.py',
+    '../_base_/datasets/coco_instance.py',
+    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
+]
+```
+
+If you wish to inspect the config file, you may run `python tools/misc/print_config.py /PATH/TO/CONFIG` to see the complete config.
+
+### Ignore some fields in the base configs
+
+Sometimes, you may set `_delete_=True` to ignore some of the fields in base configs.
+You may refer to [mmengine config tutorial](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html) for a simple illustration.
+
+In MMDetection, for example, to change the backbone of Mask R-CNN with the following config.
+
+```python
+model = dict(
+    type='MaskRCNN',
+    backbone=dict(
+        type='ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type='BN', requires_grad=True),
+        norm_eval=True,
+        style='pytorch',
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),
+    neck=dict(...),
+    rpn_head=dict(...),
+    roi_head=dict(...))
+```
+
+`ResNet` and `HRNet` use different keywords to construct.
+
+```python
+_base_ = '../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py'
+model = dict(
+    backbone=dict(
+        _delete_=True,
+        type='HRNet',
+        extra=dict(
+            stage1=dict(
+                num_modules=1,
+                num_branches=1,
+                block='BOTTLENECK',
+                num_blocks=(4, ),
+                num_channels=(64, )),
+            stage2=dict(
+                num_modules=1,
+                num_branches=2,
+                block='BASIC',
+                num_blocks=(4, 4),
+                num_channels=(32, 64)),
+            stage3=dict(
+                num_modules=4,
+                num_branches=3,
+                block='BASIC',
+                num_blocks=(4, 4, 4),
+                num_channels=(32, 64, 128)),
+            stage4=dict(
+                num_modules=3,
+                num_branches=4,
+                block='BASIC',
+                num_blocks=(4, 4, 4, 4),
+                num_channels=(32, 64, 128, 256))),
+        init_cfg=dict(type='Pretrained', checkpoint='open-mmlab://msra/hrnetv2_w32')),
+    neck=dict(...))
+```
+
+The `_delete_=True` would replace all old keys in `backbone` field with new keys.
+
+### Use intermediate variables in configs
+
+Some intermediate variables are used in the configs files, like `train_pipeline`/`test_pipeline` in datasets.
+It's worth noting that when modifying intermediate variables in the children configs, users need to pass the intermediate variables into corresponding fields again.
+For example, we would like to use a multi-scale strategy to train a Mask R-CNN. `train_pipeline`/`test_pipeline` are intermediate variables we would like to modify.
+
+```python
+_base_ = './mask-rcnn_r50_fpn_1x_coco.py'
+
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
+    dict(
+        type='RandomResize', scale=[(1333, 640), (1333, 800)],
+        keep_ratio=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(1333, 800), keep_ratio=True),
+    dict(
+        type='PackDetInputs',
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
+val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+test_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+```
+
+We first define the new `train_pipeline`/`test_pipeline` and pass them into dataloader fields.
+
+Similarly, if we would like to switch from `SyncBN` to `BN` or `MMSyncBN`, we need to substitute every `norm_cfg` in the config.
+
+```python
+_base_ = './mask-rcnn_r50_fpn_1x_coco.py'
+norm_cfg = dict(type='BN', requires_grad=True)
+model = dict(
+    backbone=dict(norm_cfg=norm_cfg),
+    neck=dict(norm_cfg=norm_cfg),
+    ...)
+```
+
+### Reuse variables in \_base\_ file
+
+If the users want to reuse the variables in the base file, they can get a copy of the corresponding variable by using `{{_base_.xxx}}`. E.g:
+
+```python
+_base_ = './mask-rcnn_r50_fpn_1x_coco.py'
+
+a = {{_base_.model}} # Variable `a` is equal to the `model` defined in `_base_`
+```
+
+## Modify config through script arguments
+
+When submitting jobs using `tools/train.py` or `tools/test.py`, you may specify `--cfg-options` to in-place modify the config.
+
+- Update config keys of dict chains.
+
+  The config options can be specified following the order of the dict keys in the original config.
+  For example, `--cfg-options model.backbone.norm_eval=False` changes the all BN modules in model backbones to `train` mode.
+
+- Update keys inside a list of configs.
+
+  Some config dicts are composed as a list in your config. For example, the training pipeline `train_dataloader.dataset.pipeline` is normally a list
+  e.g. `[dict(type='LoadImageFromFile'), ...]`. If you want to change `'LoadImageFromFile'` to `'LoadImageFromNDArray'` in the pipeline,
+  you may specify `--cfg-options data.train.pipeline.0.type=LoadImageFromNDArray`.
+
+- Update values of list/tuples.
+
+  If the value to be updated is a list or a tuple. For example, the config file normally sets `model.data_preprocessor.mean=[123.675, 116.28, 103.53]`. If you want to
+  change the mean values, you may specify `--cfg-options model.data_preprocessor.mean="[127,127,127]"`. Note that the quotation mark `"` is necessary to
+  support list/tuple data types, and **NO** white space is allowed inside the quotation marks in the specified value.
+
+## Config name style
+
+We follow the below style to name config files. Contributors are advised to follow the same style.
+
+```
+{algorithm name}_{model component names [component1]_[component2]_[...]}_{training settings}_{training dataset information}_{testing dataset information}.py
+```
+
+The file name is divided into five parts. All parts and components are connected with `_` and words of each part or component should be connected with `-`.
+
+- `{algorithm name}`: The name of the algorithm. It can be a detector name such as `faster-rcnn`, `mask-rcnn`, etc. Or can be a semi-supervised or knowledge-distillation algorithm such as `soft-teacher`, `lad`. etc.
+- `{model component names}`: Names of the components used in the algorithm such as backbone, neck, etc. For example, `r50-caffe_fpn_gn-head` means using caffe-style ResNet50, FPN and detection head with Group Norm in the algorithm.
+- `{training settings}`: Information of training settings such as batch size, augmentations, loss trick, scheduler, and epochs/iterations. For example: `4xb4-mixup-giou-coslr-100e` means using 8-gpus x 4-images-per-gpu, mixup augmentation, GIoU loss, cosine annealing learning rate, and train 100 epochs.
+  Some abbreviations:
+  - `{gpu x batch_per_gpu}`: GPUs and samples per GPU. `bN` indicates N batch size per GPU. E.g. `4xb4` is the short term of 4-GPUs x 4-images-per-GPU. And `8xb2` is used by default if not mentioned.
+  - `{schedule}`: training schedule, options are `1x`, `2x`, `20e`, etc.
+    `1x` and `2x` means 12 epochs and 24 epochs respectively.
+    `20e` is adopted in cascade models, which denotes 20 epochs.
+    For `1x`/`2x`, the initial learning rate decays by a factor of 10 at the 8/16th and 11/22th epochs.
+    For `20e`, the initial learning rate decays by a factor of 10 at the 16th and 19th epochs.
+- `{training dataset information}`: Training dataset names like `coco`, `coco-panoptic`, `cityscapes`, `voc-0712`, `wider-face`.
+- `{testing dataset information}` (optional): Testing dataset name for models trained on one dataset but tested on another. If not mentioned, it means the model was trained and tested on the same dataset type.
diff --git a/mmdetection/docs/en/user_guides/dataset_prepare.md b/mmdetection/docs/en/user_guides/dataset_prepare.md
new file mode 100644
index 00000000..1e0259a1
--- /dev/null
+++ b/mmdetection/docs/en/user_guides/dataset_prepare.md
@@ -0,0 +1,310 @@
+# Dataset Prepare
+
+### Basic Detection Dataset Preparation
+
+MMDetection supports multiple public datasets including COCO, Pascal VOC, CityScapes, and [more](../../../configs/_base_/datasets).
+
+Public datasets like [Pascal VOC](http://host.robots.ox.ac.uk/pascal/VOC/index.html) or mirror and [COCO](https://cocodataset.org/#download) are available from official websites or mirrors. Note: In the detection task, Pascal VOC 2012 is an extension of Pascal VOC 2007 without overlap, and we usually use them together.
+It is recommended to download and extract the dataset somewhere outside the project directory and symlink the dataset root to `$MMDETECTION/data` as below.
+If your folder structure is different, you may need to change the corresponding paths in config files.
+
+We provide a script to download datasets such as COCO, you can run `python tools/misc/download_dataset.py --dataset-name coco2017` to download COCO dataset.
+For users in China, more datasets can be downloaded from the opensource dataset platform: [OpenDataLab](https://opendatalab.com/?source=OpenMMLab%20GitHub).
+
+For more usage please refer to [dataset-download](./useful_tools.md#dataset-download)
+
+```text
+mmdetection
+├── mmdet
+├── tools
+├── configs
+├── data
+│   ├── coco
+│   │   ├── annotations
+│   │   ├── train2017
+│   │   ├── val2017
+│   │   ├── test2017
+│   ├── cityscapes
+│   │   ├── annotations
+│   │   ├── leftImg8bit
+│   │   │   ├── train
+│   │   │   ├── val
+│   │   ├── gtFine
+│   │   │   ├── train
+│   │   │   ├── val
+│   ├── VOCdevkit
+│   │   ├── VOC2007
+│   │   ├── VOC2012
+```
+
+Some models require additional [COCO-stuff](http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/stuffthingmaps_trainval2017.zip) datasets, such as HTC, DetectoRS and SCNet, you can download, unzip, and then move them to the coco folder. The directory should be like this.
+
+```text
+mmdetection
+├── data
+│   ├── coco
+│   │   ├── annotations
+│   │   ├── train2017
+│   │   ├── val2017
+│   │   ├── test2017
+│   │   ├── stuffthingmaps
+```
+
+Panoptic segmentation models like PanopticFPN require additional [COCO Panoptic](http://images.cocodataset.org/annotations/panoptic_annotations_trainval2017.zip) datasets, you can download, unzip, and then move them to the coco annotation folder. The directory should be like this.
+
+```text
+mmdetection
+├── data
+│   ├── coco
+│   │   ├── annotations
+│   │   │   ├── panoptic_train2017.json
+│   │   │   ├── panoptic_train2017
+│   │   │   ├── panoptic_val2017.json
+│   │   │   ├── panoptic_val2017
+│   │   ├── train2017
+│   │   ├── val2017
+│   │   ├── test2017
+```
+
+The [cityscapes](https://www.cityscapes-dataset.com/) annotations need to be converted into the coco format using `tools/dataset_converters/cityscapes.py`:
+
+```shell
+pip install cityscapesscripts
+
+python tools/dataset_converters/cityscapes.py \
+    ./data/cityscapes \
+    --nproc 8 \
+    --out-dir ./data/cityscapes/annotations
+```
+
+### COCO Caption Dataset Preparation
+
+COCO Caption uses the COCO2014 dataset image and uses the annotation of karpathy.
+
+At first, you need to download the COCO2014 dataset.
+
+```shell
+python tools/misc/download_dataset.py --dataset-name coco2014 --unzip
+```
+
+The dataset will be downloaded to `data/coco` under the current path. Then download the annotation of karpathy.
+
+```shell
+cd data/coco/annotations
+wget https://storage.googleapis.com/sfr-vision-language-research/datasets/coco_karpathy_train.json
+wget https://storage.googleapis.com/sfr-vision-language-research/datasets/coco_karpathy_val.json
+wget https://storage.googleapis.com/sfr-vision-language-research/datasets/coco_karpathy_test.json
+wget https://storage.googleapis.com/sfr-vision-language-research/datasets/coco_karpathy_val_gt.json
+wget https://storage.googleapis.com/sfr-vision-language-research/datasets/coco_karpathy_test_gt.json
+```
+
+The final directory structure of the dataset folder that can be directly used for training and testing is as follows:
+
+```text
+mmdetection
+├── data
+│   ├── coco
+│   │   ├── annotations
+│   │   │   ├── coco_karpathy_train.json
+│   │   │   ├── coco_karpathy_test.json
+│   │   │   ├── coco_karpathy_val.json
+│   │   │   ├── coco_karpathy_val_gt.json
+│   │   │   ├── coco_karpathy_test_gt.json
+│   │   ├── train2014
+│   │   ├── val2014
+│   │   ├── test2014
+```
+
+### COCO Semantic Dataset Preparation
+
+There are two types of annotations for COCO semantic segmentation, which differ mainly in the definition of category names, so there are two ways to handle them. The first is to directly use the stuffthingmaps dataset, and the second is to use the panoptic dataset.
+
+**(1) Use stuffthingmaps dataset**
+
+The download link for this dataset is [stuffthingmaps_trainval2017](http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/stuffthingmaps_trainval2017.zip). Please download and extract it to the `data/coco` folder.
+
+```text
+mmdetection
+├── data
+│   ├── coco
+│   │   ├── annotations
+│   │   ├── train2017
+│   │   ├── val2017
+│   │   ├── test2017
+│   │   ├── stuffthingmaps
+```
+
+This dataset is different from the standard COCO category annotation in that it includes 172 classes: 80 "thing" classes, 91 "stuff" classes, and 1 "unlabeled" class. The description of each class can be found at https://github.com/nightrome/cocostuff/blob/master/labels.md.
+
+Although only 172 categories are annotated, the maximum label ID in `stuffthingmaps` is 182, and some categories in the middle are not annotated. In addition, the "unlabeled" category of class 0 is removed. Therefore, the relationship between the value at each position in the final `stuffthingmaps` image can be found at https://github.com/kazuto1011/deeplab-pytorch/blob/master/data/datasets/cocostuff/labels.txt.
+
+To train efficiently and conveniently for users, we need to remove 12 unannotated classes before starting training or evaluation. The names of these 12 classes are: `street sign, hat, shoe, eye glasses, plate, mirror, window, desk, door, blender, hair brush`. The category information that can be used for training and evaluation can be found in `mmdet/datasets/coco_semantic.py`.
+
+You can use `tools/dataset_converters/coco_stuff164k.py` to convert the downloaded `stuffthingmaps` to a dataset that can be directly used for training and evaluation. The directory structure of the converted dataset is as follows:
+
+```text
+mmdetection
+├── data
+│   ├── coco
+│   │   ├── annotations
+│   │   ├── train2017
+│   │   ├── val2017
+│   │   ├── test2017
+│   │   ├── stuffthingmaps
+│   │   ├── stuffthingmaps_semseg
+```
+
+`stuffthingmaps_semseg` is the newly generated COCO semantic segmentation dataset that can be directly used for training and testing.
+
+**(2) use panoptic dataset**
+
+The number of categories in the semantic segmentation dataset generated through panoptic annotation will be less than that generated using the `stuffthingmaps` dataset. First, you need to prepare the panoptic segmentation annotations, and then use the following script to complete the conversion.
+
+```shell
+python tools/dataset_converters/prepare_coco_semantic_annos_from_panoptic_annos.py data/coco
+```
+
+The directory structure of the converted dataset is as follows:
+
+```text
+mmdetection
+├── data
+│   ├── coco
+│   │   ├── annotations
+│   │   │   ├── panoptic_train2017.json
+│   │   │   ├── panoptic_train2017
+│   │   │   ├── panoptic_val2017.json
+│   │   │   ├── panoptic_val2017
+│   │   │   ├── panoptic_semseg_train2017
+│   │   │   ├── panoptic_semseg_val2017
+│   │   ├── train2017
+│   │   ├── val2017
+│   │   ├── test2017
+```
+
+`panoptic_semseg_train2017` and `panoptic_semseg_val2017` are the newly generated COCO semantic segmentation datasets that can be directly used for training and testing. Note that their category information is the same as that of COCO panoptic segmentation, including both "thing" and "stuff" categories.
+
+### RefCOCO Dataset Preparation
+
+The images and annotations of [RefCOCO](https://github.com/lichengunc/refer) series datasets can be download by running `tools/misc/download_dataset.py`:
+
+```shell
+python tools/misc/download_dataset.py --dataset-name refcoco --save-dir data/coco --unzip
+```
+
+Then the directory should be like this:
+
+```text
+data
+├── coco
+│   ├── refcoco
+│   │   ├── instances.json
+│   │   ├── refs(google).p
+│   │   └── refs(unc).p
+│   ├── refcoco+
+│   │   ├── instances.json
+│   │   └── refs(unc).p
+│   ├── refcocog
+│   │   ├── instances.json
+│   │   ├── refs(google).p
+│   │   └── refs(umd).p
+│   │── train2014
+```
+
+### ADE20K 2016 Dataset Preparation
+
+The images and annotations of [ADE20K](https://groups.csail.mit.edu/vision/datasets/ADE20K/) dataset can be download by running `tools/misc/download_dataset.py`:
+
+```shell
+python tools/misc/download_dataset.py --dataset-name ade20k_2016 --save-dir data --unzip
+```
+
+Then move the annotations to the `data/ADEChallengeData2016` directory and run the preprocess script to produce the coco format annotations:
+
+```shell
+mv data/annotations_instance data/ADEChallengeData2016/
+mv data/categoryMapping.txt data/ADEChallengeData2016/
+mv data/imgCatIds.json data/ADEChallengeData2016/
+python tools/dataset_converters/ade20k2coco.py data/ADEChallengeData2016 --task panoptic
+python tools/dataset_converters/ade20k2coco.py data/ADEChallengeData2016 --task instance
+```
+
+The directory should be like this.
+
+```text
+data
+├── ADEChallengeData2016
+│   ├── ade20k_instance_train.json
+│   ├── ade20k_instance_val.json
+│   ├── ade20k_panoptic_train
+│   │   ├── ADE_train_00000001.png
+│   │   ├── ADE_train_00000002.png
+│   │   ├── ...
+│   ├── ade20k_panoptic_train.json
+│   ├── ade20k_panoptic_val
+│   │   ├── ADE_val_00000001.png
+│   │   ├── ADE_val_00000002.png
+│   │   ├── ...
+│   ├── ade20k_panoptic_val.json
+│   ├── annotations
+│   │   ├── training
+│   │   │   ├── ADE_train_00000001.png
+│   │   │   ├── ADE_train_00000002.png
+│   │   │   ├── ...
+│   │   ├── validation
+│   │   │   ├── ADE_val_00000001.png
+│   │   │   ├── ADE_val_00000002.png
+│   │   │   ├── ...
+│   ├── annotations_instance
+│   │   ├── training
+│   │   │   ├── ADE_train_00000001.png
+│   │   │   ├── ADE_train_00000002.png
+│   │   │   ├── ...
+│   │   ├── validation
+│   │   │   ├── ADE_val_00000001.png
+│   │   │   ├── ADE_val_00000002.png
+│   │   │   ├── ...
+│   ├── categoryMapping.txt
+│   ├── images
+│   │   ├── training
+│   │   │   ├── ADE_train_00000001.jpg
+│   │   │   ├── ADE_train_00000002.jpg
+│   │   │   ├── ...
+│   │   ├── validation
+│   │   │   ├── ADE_val_00000001.jpg
+│   │   │   ├── ADE_val_00000002.jpg
+│   │   │   ├── ...
+│   ├── imgCatIds.json
+│   ├── objectInfo150.txt
+│   │── sceneCategories.txt
+```
+
+The above folders include all data of ADE20K's semantic segmentation, instance segmentation, and panoptic segmentation.
+
+### Download from OpenDataLab
+
+By using [OpenDataLab](https://opendatalab.com/), researchers can obtain free formatted datasets in various fields. Through the search function of the platform, researchers may address the dataset they look for quickly and easily. Using the formatted datasets from the platform, researchers can efficiently conduct tasks across datasets.
+
+Currently, MIM supports downloading VOC and COCO datasets from OpenDataLab with one command line. More datasets will be supported in the future. You can also directly download the datasets you need from the OpenDataLab platform and then convert them to the format required by MMDetection.
+
+If you use MIM to download, make sure that the version is greater than v0.3.8. You can use the following command to update:
+
+```Bash
+pip install -U openmim
+```
+
+```Bash
+# install OpenXLab CLI tools
+pip install -U openxlab
+# log in OpenXLab, registry
+openxlab login
+
+# download voc2007 and preprocess by MIM
+mim download mmdet --dataset voc2007
+
+# download voc2012 and preprocess by MIM
+mim download mmdet --dataset voc2012
+
+# download coco2017 and preprocess by MIM
+mim download mmdet --dataset coco2017
+```
diff --git a/mmdetection/docs/en/user_guides/deploy.md b/mmdetection/docs/en/user_guides/deploy.md
new file mode 100644
index 00000000..db320d14
--- /dev/null
+++ b/mmdetection/docs/en/user_guides/deploy.md
@@ -0,0 +1,173 @@
+# Model Deployment
+
+The deployment of OpenMMLab codebases, including MMDetection, MMPretrain and so on are supported by [MMDeploy](https://github.com/open-mmlab/mmdeploy).
+The latest deployment guide for MMDetection can be found from [here](https://mmdeploy.readthedocs.io/en/dev-1.x/04-supported-codebases/mmdet.html).
+
+This tutorial is organized as follows:
+
+- [Installation](#installation)
+- [Convert model](#convert-model)
+- [Model specification](#model-specification)
+- [Model inference](#model-inference)
+  - [Backend model inference](#backend-model-inference)
+  - [SDK model inference](#sdk-model-inference)
+- [Supported models](#supported-models)
+
+## Installation
+
+Please follow the [guide](https://mmdetection.readthedocs.io/en/latest/get_started.html) to install mmdet. And then install mmdeploy from source by following [this](https://mmdeploy.readthedocs.io/en/1.x/get_started.html#installation) guide.
+
+```{note}
+If you install mmdeploy prebuilt package, please also clone its repository by 'git clone https://github.com/open-mmlab/mmdeploy.git --depth=1' to get the deployment config files.
+```
+
+## Convert model
+
+Suppose mmdetection and mmdeploy repositories are in the same directory, and the working directory is the root path of mmdetection.
+
+Take [Faster R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py) model as an example. You can download its checkpoint from [here](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth), and then convert it to onnx model as follows:
+
+```python
+from mmdeploy.apis import torch2onnx
+from mmdeploy.backend.sdk.export_info import export2SDK
+
+img = 'demo/demo.jpg'
+work_dir = 'mmdeploy_models/mmdet/onnx'
+save_file = 'end2end.onnx'
+deploy_cfg = '../mmdeploy/configs/mmdet/detection/detection_onnxruntime_dynamic.py'
+model_cfg = 'configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py'
+model_checkpoint = 'faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth'
+device = 'cpu'
+
+# 1. convert model to onnx
+torch2onnx(img, work_dir, save_file, deploy_cfg, model_cfg,
+           model_checkpoint, device)
+
+# 2. extract pipeline info for inference by MMDeploy SDK
+export2SDK(deploy_cfg, model_cfg, work_dir, pth=model_checkpoint,
+           device=device)
+```
+
+It is crucial to specify the correct deployment config during model conversion. MMDeploy has already provided builtin deployment config [files](https://github.com/open-mmlab/mmdeploy/tree/1.x/configs/mmdet) of all supported backends for mmdetection, under which the config file path follows the pattern:
+
+```
+{task}/{task}_{backend}-{precision}_{static | dynamic}_{shape}.py
+```
+
+- **{task}:** task in mmdetection.
+
+  There are two of them. One is `detection` and the other is `instance-seg`, indicating instance segmentation.
+
+  mmdet models like `RetinaNet`, `Faster R-CNN` and `DETR` and so on belongs to `detection` task. While `Mask R-CNN` is one of `instance-seg` models.
+
+  **DO REMEMBER TO USE** `detection/detection_*.py` deployment config file when trying to convert detection models and use `instance-seg/instance-seg_*.py` to deploy instance segmentation models.
+
+- **{backend}:** inference backend, such as onnxruntime, tensorrt, pplnn, ncnn, openvino, coreml etc.
+
+- **{precision}:** fp16, int8. When it's empty, it means fp32
+
+- **{static | dynamic}:** static shape or dynamic shape
+
+- **{shape}:** input shape or shape range of a model
+
+Therefore, in the above example, you can also convert `Faster R-CNN` to tensorrt-fp16 model by `detection_tensorrt-fp16_dynamic-320x320-1344x1344.py`.
+
+```{tip}
+When converting mmdet models to tensorrt models, --device should be set to "cuda"
+```
+
+## Model specification
+
+Before moving on to model inference chapter, let's know more about the converted model structure which is very important for model inference.
+
+The converted model locates in the working directory like `mmdeploy_models/mmdet/onnx` in the previous example. It includes:
+
+```
+mmdeploy_models/mmdet/onnx
+├── deploy.json
+├── detail.json
+├── end2end.onnx
+└── pipeline.json
+```
+
+in which,
+
+- **end2end.onnx**: backend model which can be inferred by ONNX Runtime
+- ***xxx*.json**: the necessary information for mmdeploy SDK
+
+The whole package **mmdeploy_models/mmdet/onnx** is defined as **mmdeploy SDK model**, i.e., **mmdeploy SDK model** includes both backend model and inference meta information.
+
+## Model inference
+
+### Backend model inference
+
+Take the previous converted `end2end.onnx` model as an example, you can use the following code to inference the model and visualize the results.
+
+```python
+from mmdeploy.apis.utils import build_task_processor
+from mmdeploy.utils import get_input_shape, load_config
+import torch
+
+deploy_cfg = '../mmdeploy/configs/mmdet/detection/detection_onnxruntime_dynamic.py'
+model_cfg = 'configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py'
+device = 'cpu'
+backend_model = ['mmdeploy_models/mmdet/onnx/end2end.onnx']
+image = 'demo/demo.jpg'
+
+# read deploy_cfg and model_cfg
+deploy_cfg, model_cfg = load_config(deploy_cfg, model_cfg)
+
+# build task and backend model
+task_processor = build_task_processor(model_cfg, deploy_cfg, device)
+model = task_processor.build_backend_model(backend_model)
+
+# process input image
+input_shape = get_input_shape(deploy_cfg)
+model_inputs, _ = task_processor.create_input(image, input_shape)
+
+# do model inference
+with torch.no_grad():
+    result = model.test_step(model_inputs)
+
+# visualize results
+task_processor.visualize(
+    image=image,
+    model=model,
+    result=result[0],
+    window_name='visualize',
+    output_file='output_detection.png')
+```
+
+### SDK model inference
+
+You can also perform SDK model inference like following,
+
+```python
+from mmdeploy_python import Detector
+import cv2
+
+img = cv2.imread('demo/demo.jpg')
+
+# create a detector
+detector = Detector(model_path='mmdeploy_models/mmdet/onnx',
+                    device_name='cpu', device_id=0)
+# perform inference
+bboxes, labels, masks = detector(img)
+
+# visualize inference result
+indices = [i for i in range(len(bboxes))]
+for index, bbox, label_id in zip(indices, bboxes, labels):
+    [left, top, right, bottom], score = bbox[0:4].astype(int), bbox[4]
+    if score < 0.3:
+        continue
+
+    cv2.rectangle(img, (left, top), (right, bottom), (0, 255, 0))
+
+cv2.imwrite('output_detection.png', img)
+```
+
+Besides python API, mmdeploy SDK also provides other FFI (Foreign Function Interface), such as C, C++, C#, Java and so on. You can learn their usage from [demos](https://github.com/open-mmlab/mmdeploy/tree/1.x/demo).
+
+## Supported models
+
+Please refer to [here](https://mmdeploy.readthedocs.io/en/1.x/04-supported-codebases/mmdet.html#supported-models) for the supported model list.
diff --git a/mmdetection/docs/en/user_guides/finetune.md b/mmdetection/docs/en/user_guides/finetune.md
new file mode 100644
index 00000000..e181ebae
--- /dev/null
+++ b/mmdetection/docs/en/user_guides/finetune.md
@@ -0,0 +1,96 @@
+# Finetuning Models
+
+Detectors pre-trained on the COCO dataset can serve as a good pre-trained model for other datasets, e.g., CityScapes and KITTI Dataset.
+This tutorial provides instructions for users to use the models provided in the [Model Zoo](../model_zoo.md) for other datasets to obtain better performance.
+
+There are two steps to finetune a model on a new dataset.
+
+- Add support for the new dataset following [Customize Datasets](../advanced_guides/customize_dataset.md).
+- Modify the configs as will be discussed in this tutorial.
+
+Take the finetuning process on Cityscapes Dataset as an example, the users need to modify five parts in the config.
+
+## Inherit base configs
+
+To release the burden and reduce bugs in writing the whole configs, MMDetection V3.0 support inheriting configs from multiple existing configs. To finetune a Mask RCNN model, the new config needs to inherit
+`_base_/models/mask-rcnn_r50_fpn.py` to build the basic structure of the model. To use the Cityscapes Dataset, the new config can also simply inherit `_base_/datasets/cityscapes_instance.py`. For runtime settings such as logger settings, the new config needs to inherit `_base_/default_runtime.py`. For training schedules, the new config can to inherit `_base_/schedules/schedule_1x.py`. These configs are in the `configs` directory and the users can also choose to write the whole contents rather than use inheritance.
+
+```python
+_base_ = [
+    '../_base_/models/mask-rcnn_r50_fpn.py',
+    '../_base_/datasets/cityscapes_instance.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_1x.py'
+]
+```
+
+## Modify head
+
+Then the new config needs to modify the head according to the class numbers of the new datasets. By only changing `num_classes` in the roi_head, the weights of the pre-trained models are mostly reused except for the final prediction head.
+
+```python
+model = dict(
+    roi_head=dict(
+        bbox_head=dict(
+            type='Shared2FCBBoxHead',
+            in_channels=256,
+            fc_out_channels=1024,
+            roi_feat_size=7,
+            num_classes=8,
+            bbox_coder=dict(
+                type='DeltaXYWHBBoxCoder',
+                target_means=[0., 0., 0., 0.],
+                target_stds=[0.1, 0.1, 0.2, 0.2]),
+            reg_class_agnostic=False,
+            loss_cls=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
+            loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0)),
+        mask_head=dict(
+            type='FCNMaskHead',
+            num_convs=4,
+            in_channels=256,
+            conv_out_channels=256,
+            num_classes=8,
+            loss_mask=dict(
+                type='CrossEntropyLoss', use_mask=True, loss_weight=1.0))))
+```
+
+## Modify dataset
+
+The users may also need to prepare the dataset and write the configs about dataset, refer to [Customize Datasets](../advanced_guides/customize_dataset.md) for more detail. MMDetection V3.0 already supports VOC, WIDERFACE, COCO, LIVS, OpenImages, DeepFashion, Objects365, and Cityscapes Dataset.
+
+## Modify training schedule
+
+The finetuning hyperparameters vary from the default schedule. It usually requires a smaller learning rate and fewer training epochs
+
+```python
+# optimizer
+# lr is set for a batch size of 8
+optim_wrapper = dict(optimizer=dict(lr=0.01))
+
+# learning rate
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500),
+    dict(
+        type='MultiStepLR',
+        begin=0,
+        end=8,
+        by_epoch=True,
+        milestones=[7],
+        gamma=0.1)
+]
+
+# max_epochs
+train_cfg = dict(max_epochs=8)
+
+# log config
+default_hooks = dict(logger=dict(interval=100)),
+```
+
+## Use pre-trained model
+
+To use the pre-trained model, the new config adds the link of pre-trained models in the `load_from`. The users might need to download the model weights before training to avoid the download time during training.
+
+```python
+load_from = 'https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth'  # noqa
+```
diff --git a/mmdetection/docs/en/user_guides/index.rst b/mmdetection/docs/en/user_guides/index.rst
new file mode 100644
index 00000000..e74fc5fb
--- /dev/null
+++ b/mmdetection/docs/en/user_guides/index.rst
@@ -0,0 +1,41 @@
+Train & Test
+**************
+
+MMDetection provides hundreds of pretrained detection models in `Model Zoo `_,
+and supports multiple standard datasets, including Pascal VOC, COCO, CityScapes, LVIS, etc. This note will show how to perform common tasks on these existing models and standard datasets:
+
+
+.. toctree::
+   :maxdepth: 1
+
+   config.md
+   inference.md
+   dataset_prepare.md
+   test.md
+   train.md
+   new_model.md
+   finetune.md
+   test_results_submission.md
+   init_cfg.md
+   single_stage_as_rpn.md
+   semi_det.md
+
+
+Useful Tools
+************
+
+.. toctree::
+   :maxdepth: 1
+
+   useful_tools.md
+   useful_hooks.md
+   visualization.md
+   robustness_benchmarking.md
+   deploy.md
+   label_studio.md
+   tracking_analysis_tools.md
+   tracking_config.md
+   tracking_dataset_prepare.md
+   tracking_inference.md
+   tracking_train_test.md
+   tracking_visualization.md
diff --git a/mmdetection/docs/en/user_guides/inference.md b/mmdetection/docs/en/user_guides/inference.md
new file mode 100644
index 00000000..49186d23
--- /dev/null
+++ b/mmdetection/docs/en/user_guides/inference.md
@@ -0,0 +1,440 @@
+# Inference with existing models
+
+MMDetection provides hundreds of pre-trained detection models in [Model Zoo](https://mmdetection.readthedocs.io/en/latest/model_zoo.html).
+This note will show how to inference, which means using trained models to detect objects on images.
+
+In MMDetection, a model is defined by a [configuration file](https://mmdetection.readthedocs.io/en/latest/user_guides/config.html) and existing model parameters are saved in a checkpoint file.
+
+To start with, we recommend [RTMDet](https://github.com/open-mmlab/mmdetection/tree/main/configs/rtmdet) with this [configuration file](https://github.com/open-mmlab/mmdetection/blob/main/configs/rtmdet/rtmdet_l_8xb32-300e_coco.py) and this [checkpoint file](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_l_8xb32-300e_coco/rtmdet_l_8xb32-300e_coco_20220719_112030-5a0be7c4.pth). It is recommended to download the checkpoint file to `checkpoints` directory.
+
+## High-level APIs for inference - `Inferencer`
+
+In OpenMMLab, all the inference operations are unified into a new interface - Inferencer. Inferencer is designed to expose a neat and simple API to users, and shares very similar interface across different OpenMMLab libraries.
+A notebook demo can be found in [demo/inference_demo.ipynb](https://github.com/open-mmlab/mmdetection/blob/main/demo/inference_demo.ipynb).
+
+### Basic Usage
+
+You can get inference results for an image with only 3 lines of code.
+
+```python
+from mmdet.apis import DetInferencer
+
+# Initialize the DetInferencer
+inferencer = DetInferencer('rtmdet_tiny_8xb32-300e_coco')
+
+# Perform inference
+inferencer('demo/demo.jpg', show=True)
+```
+
+The resulting output will be displayed in a new window:.
+
+
    
+    
+
    
+
+```{note}
+If you are running MMDetection on a server without GUI or via SSH tunnel with X11 forwarding disabled, the `show` option will not work. However, you can still save visualizations to files by setting `out_dir` arguments. Read [Dumping Results](#dumping-results) for details.
+```
+
+### Initialization
+
+Each Inferencer must be initialized with a model. You can also choose the inference device during initialization.
+
+#### Model Initialization
+
+- To infer with MMDetection's pre-trained model, passing its name to the argument `model` can work. The weights will be automatically downloaded and loaded from OpenMMLab's model zoo.
+
+  ```python
+  inferencer = DetInferencer(model='rtmdet_tiny_8xb32-300e_coco')
+  ```
+
+  There is a very easy to list all model names in MMDetection.
+
+  ```python
+  # models is a list of model names, and them will print automatically
+  models = DetInferencer.list_models('mmdet')
+  ```
+
+  You can load another weight by passing its path/url to `weights`.
+
+  ```python
+  inferencer = DetInferencer(model='rtmdet_tiny_8xb32-300e_coco', weights='path/to/rtmdet.pth')
+  ```
+
+- To load custom config and weight, you can pass the path to the config file to `model` and the path to the weight to `weights`.
+
+  ```python
+  inferencer = DetInferencer(model='path/to/rtmdet_config.py', weights='path/to/rtmdet.pth')
+  ```
+
+- By default, [MMEngine](https://github.com/open-mmlab/mmengine/) dumps config to the weight. If you have a weight trained on MMEngine, you can also pass the path to the weight file to `weights` without specifying `model`:
+
+  ```python
+  # It will raise an error if the config file cannot be found in the weight. Currently, within the MMDetection model repository, only the weights of ddq-detr-4scale_r50 can be loaded in this manner.
+  inferencer = DetInferencer(weights='https://download.openmmlab.com/mmdetection/v3.0/ddq/ddq-detr-4scale_r50_8xb2-12e_coco/ddq-detr-4scale_r50_8xb2-12e_coco_20230809_170711-42528127.pth')
+  ```
+
+- Passing config file to `model` without specifying `weight` will result in a randomly initialized model.
+
+### Device
+
+Each Inferencer instance is bound to a device.
+By default, the best device is automatically decided by [MMEngine](https://github.com/open-mmlab/mmengine/). You can also alter the device by specifying the `device` argument. For example, you can use the following code to create an Inferencer on GPU 1.
+
+```python
+inferencer = DetInferencer(model='rtmdet_tiny_8xb32-300e_coco', device='cuda:1')
+```
+
+To create an Inferencer on CPU:
+
+```python
+inferencer = DetInferencer(model='rtmdet_tiny_8xb32-300e_coco', device='cpu')
+```
+
+Refer to [torch.device](https://pytorch.org/docs/stable/tensor_attributes.html#torch.device) for all the supported forms.
+
+### Inference
+
+Once the Inferencer is initialized, you can directly pass in the raw data to be inferred and get the inference results from return values.
+
+#### Input
+
+Input can be either of these types:
+
+- str: Path/URL to the image.
+
+  ```python
+  inferencer('demo/demo.jpg')
+  ```
+
+- array: Image in numpy array. It should be in BGR order.
+
+  ```python
+  import mmcv
+  array = mmcv.imread('demo/demo.jpg')
+  inferencer(array)
+  ```
+
+- list: A list of basic types above. Each element in the list will be processed separately.
+
+  ```python
+  inferencer(['img_1.jpg', 'img_2.jpg])
+  # You can even mix the types
+  inferencer(['img_1.jpg', array])
+  ```
+
+- str: Path to the directory. All images in the directory will be processed.
+
+  ```python
+  inferencer('path/to/your_imgs/')
+  ```
+
+### Output
+
+By default, each `Inferencer` returns the prediction results in a dictionary format.
+
+- `visualization` contains the visualized predictions.
+
+- `predictions` contains the predictions results in a json-serializable format. But it's an empty list by default unless `return_vis=True`.
+
+```python
+{
+      'predictions' : [
+        # Each instance corresponds to an input image
+        {
+          'labels': [...],  # int list of length (N, )
+          'scores': [...],  # float list of length (N, )
+          'bboxes': [...],  # 2d list of shape (N, 4), format: [min_x, min_y, max_x, max_y]
+        },
+        ...
+      ],
+      'visualization' : [
+        array(..., dtype=uint8),
+      ]
+  }
+```
+
+If you wish to get the raw outputs from the model, you can set `return_datasamples` to `True` to get the original [DataSample](advanced_guides/structures.md), which will be stored in `predictions`.
+
+#### Dumping Results
+
+Apart from obtaining predictions from the return value, you can also export the predictions/visualizations to files by setting `out_dir` and `no_save_pred`/`no_save_vis` arguments.
+
+```python
+inferencer('demo/demo.jpg', out_dir='outputs/', no_save_pred=False)
+```
+
+Results in the directory structure like:
+
+```text
+outputs
+├── preds
+│   └── demo.json
+└── vis
+    └── demo.jpg
+```
+
+The filename of each file is the same as the corresponding input image filename. If the input image is an array, the filename will be a number starting from 0.
+
+#### Batch Inference
+
+You can customize the batch size by setting `batch_size`. The default batch size is 1.
+
+### API
+
+Here are extensive lists of parameters that you can use.
+
+- **DetInferencer.\_\_init\_\_():**
+
+| Arguments       | Type          | Type    | Description                                                                                                                                                                                                                                                                                              |
+| --------------- | ------------- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `model`         | str, optional | None    | Path to the config file or the model name defined in metafile. For example, it could be 'rtmdet-s' or 'rtmdet_s_8xb32-300e_coco' or 'configs/rtmdet/rtmdet_s_8xb32-300e_coco.py'. If the model is not specified, the user must provide the `weights` saved by MMEngine which contains the config string. |
+| `weights`       | str, optional | None    | Path to the checkpoint. If it is not specified and `model` is a model name of metafile, the weights will be loaded from metafile.                                                                                                                                                                        |
+| `device`        | str, optional | None    | Device used for inference, accepting all allowed strings by `torch.device`. E.g., 'cuda:0' or 'cpu'. If None, the available device will be automatically used.                                                                                                                                           |
+| `scope`         | str, optional | 'mmdet' | The scope of the model.                                                                                                                                                                                                                                                                                  |
+| `palette`       | str           | 'none'  | Color palette used for visualization. The order of priority is palette -> config -> checkpoint.                                                                                                                                                                                                          |
+| `show_progress` | bool          | True    | Control whether to display the progress bar during the inference process.                                                                                                                                                                                                                                |
+
+- **DetInferencer.\_\_call\_\_()**
+
+| Arguments            | Type                      | Default      | Description                                                                                                                                                                                                                                                    |
+| -------------------- | ------------------------- | ------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `inputs`             | str/list/tuple/np.array   | **required** | It can be a path to an image/a folder, an np array or a list/tuple (with img paths or np arrays)                                                                                                                                                               |
+| `batch_size`         | int                       | 1            | Inference batch size.                                                                                                                                                                                                                                          |
+| `print_result`       | bool                      | False        | Whether to print the inference result to the console.                                                                                                                                                                                                          |
+| `show`               | bool                      | False        | Whether to display the visualization results in a popup window.                                                                                                                                                                                                |
+| `wait_time`          | float                     | 0            | The interval of show(s).                                                                                                                                                                                                                                       |
+| `no_save_vis`        | bool                      | False        | Whether to force not to save prediction vis results.                                                                                                                                                                                                           |
+| `draw_pred`          | bool                      | True         | Whether to draw predicted bounding boxes.                                                                                                                                                                                                                      |
+| `pred_score_thr`     | float                     | 0.3          | Minimum score of bboxes to draw.                                                                                                                                                                                                                               |
+| `return_datasamples` | bool                      | False        | Whether to return results as DataSamples. If False, the results will be packed into a dict.                                                                                                                                                                    |
+| `print_result`       | bool                      | False        | Whether to print the inference result to the console.                                                                                                                                                                                                          |
+| `no_save_pred`       | bool                      | True         | Whether to force not to save prediction results.                                                                                                                                                                                                               |
+| `out_dir`            | str                       | ''           | Output directory of results.                                                                                                                                                                                                                                   |
+| `texts`              | str/list\[str\], optional | None         | Text prompts.                                                                                                                                                                                                                                                  |
+| `stuff_texts`        | str/list\[str\], optional | None         | Stuff text prompts of open panoptic task.                                                                                                                                                                                                                      |
+| `custom_entities`    | bool                      | False        | Whether to use custom entities. Only used in GLIP.                                                                                                                                                                                                             |
+| \*\*kwargs           |                           |              | Other keyword arguments passed to :meth:`preprocess`, :meth:`forward`, :meth:`visualize` and :meth:`postprocess`. Each key in kwargs should be in the corresponding set of `preprocess_kwargs`, `forward_kwargs`, `visualize_kwargs` and `postprocess_kwargs`. |
+
+## Demos
+
+We also provide four demo scripts, implemented with high-level APIs and supporting functionality codes.
+Source codes are available [here](https://github.com/open-mmlab/mmdetection/blob/main/demo).
+
+### Image demo
+
+This script performs inference on a single image.
+
+```shell
+python demo/image_demo.py \
+    ${IMAGE_FILE} \
+    ${CONFIG_FILE} \
+    [--weights ${WEIGHTS}] \
+    [--device ${GPU_ID}] \
+    [--pred-score-thr ${SCORE_THR}]
+```
+
+Examples:
+
+```shell
+python demo/image_demo.py demo/demo.jpg \
+    configs/rtmdet/rtmdet_l_8xb32-300e_coco.py \
+    --weights checkpoints/rtmdet_l_8xb32-300e_coco_20220719_112030-5a0be7c4.pth \
+    --device cpu
+```
+
+### Webcam demo
+
+This is a live demo from a webcam.
+
+```shell
+python demo/webcam_demo.py \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    [--device ${GPU_ID}] \
+    [--camera-id ${CAMERA-ID}] \
+    [--score-thr ${SCORE_THR}]
+```
+
+Examples:
+
+```shell
+python demo/webcam_demo.py \
+    configs/rtmdet/rtmdet_l_8xb32-300e_coco.py \
+    checkpoints/rtmdet_l_8xb32-300e_coco_20220719_112030-5a0be7c4.pth
+```
+
+### Video demo
+
+This script performs inference on a video.
+
+```shell
+python demo/video_demo.py \
+    ${VIDEO_FILE} \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    [--device ${GPU_ID}] \
+    [--score-thr ${SCORE_THR}] \
+    [--out ${OUT_FILE}] \
+    [--show] \
+    [--wait-time ${WAIT_TIME}]
+```
+
+Examples:
+
+```shell
+python demo/video_demo.py demo/demo.mp4 \
+    configs/rtmdet/rtmdet_l_8xb32-300e_coco.py \
+    checkpoints/rtmdet_l_8xb32-300e_coco_20220719_112030-5a0be7c4.pth \
+    --out result.mp4
+```
+
+#### Video demo with GPU acceleration
+
+This script performs inference on a video with GPU acceleration.
+
+```shell
+python demo/video_gpuaccel_demo.py \
+    ${VIDEO_FILE} \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    [--device ${GPU_ID}] \
+    [--score-thr ${SCORE_THR}] \
+    [--nvdecode] \
+    [--out ${OUT_FILE}] \
+    [--show] \
+    [--wait-time ${WAIT_TIME}]
+```
+
+Examples:
+
+```shell
+python demo/video_gpuaccel_demo.py demo/demo.mp4 \
+    configs/rtmdet/rtmdet_l_8xb32-300e_coco.py \
+    checkpoints/rtmdet_l_8xb32-300e_coco_20220719_112030-5a0be7c4.pth \
+    --nvdecode --out result.mp4
+```
+
+### Large-image inference demo
+
+This is a script for slicing inference on large images.
+
+```
+python demo/large_image_demo.py \
+	${IMG_PATH} \
+	${CONFIG_FILE} \
+	${CHECKPOINT_FILE} \
+	--device ${GPU_ID}  \
+	--show \
+	--tta  \
+	--score-thr ${SCORE_THR} \
+	--patch-size ${PATCH_SIZE} \
+	--patch-overlap-ratio ${PATCH_OVERLAP_RATIO} \
+	--merge-iou-thr ${MERGE_IOU_THR} \
+	--merge-nms-type ${MERGE_NMS_TYPE} \
+	--batch-size ${BATCH_SIZE} \
+	--debug \
+	--save-patch
+```
+
+Examples:
+
+```shell
+# inferecnce without tta
+wget -P checkpoint https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r101_fpn_2x_coco/faster_rcnn_r101_fpn_2x_coco_bbox_mAP-0.398_20200504_210455-1d2dac9c.pth
+
+python demo/large_image_demo.py \
+    demo/large_image.jpg \
+    configs/faster_rcnn/faster-rcnn_r101_fpn_2x_coco.py \
+    checkpoint/faster_rcnn_r101_fpn_2x_coco_bbox_mAP-0.398_20200504_210455-1d2dac9c.pth
+
+# inference with tta
+wget -P checkpoint https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r50_fpn_1x_coco/retinanet_r50_fpn_1x_coco_20200130-c2398f9e.pth
+
+python demo/large_image_demo.py \
+    demo/large_image.jpg \
+    configs/retinanet/retinanet_r50_fpn_1x_coco.py \
+    checkpoint/retinanet_r50_fpn_1x_coco_20200130-c2398f9e.pth --tta
+
+```
+
+## Multi-modal algorithm inference demo and evaluation
+
+As multimodal vision algorithms continue to evolve, MMDetection has also supported such algorithms. This section demonstrates how to use the demo and eval scripts corresponding to multimodal algorithms using the GLIP algorithm and model as the example. Moreover, MMDetection integrated a [gradio_demo project](../../../projects/gradio_demo/), which allows developers to quickly play with all image input tasks in MMDetection on their local devices. Check the [document](../../../projects/gradio_demo/README.md) for more details.
+
+### Preparation
+
+Please first make sure that you have the correct dependencies installed:
+
+```shell
+# if source
+pip install -r requirements/multimodal.txt
+
+# if wheel
+mim install mmdet[multimodal]
+```
+
+MMDetection has already implemented GLIP algorithms and provided the weights, you can download directly from urls:
+
+```shell
+cd mmdetection
+wget https://download.openmmlab.com/mmdetection/v3.0/glip/glip_tiny_a_mmdet-b3654169.pth
+```
+
+### Inference
+
+Once the model is successfully downloaded, you can use the `demo/image_demo.py` script to run the inference.
+
+```shell
+python demo/image_demo.py demo/demo.jpg glip_tiny_a_mmdet-b3654169.pth --texts bench
+```
+
+Demo result will be similar to this:
+
+
    
+
+
    
+
+If users would like to detect multiple targets, please declare them in the format of `xx. xx` after the `--texts`.
+
+```shell
+python demo/image_demo.py demo/demo.jpg glip_tiny_a_mmdet-b3654169.pth --texts 'bench. car'
+```
+
+And the result will be like this one:
+
+
    
+
+
    
+
+You can also use a sentence as the input prompt for the `--texts` field, for example:
+
+```shell
+python demo/image_demo.py demo/demo.jpg glip_tiny_a_mmdet-b3654169.pth --texts 'There are a lot of cars here.'
+```
+
+The result will be similar to this:
+
+
    
+
+
    
+
+### Evaluation
+
+The GLIP implementation in MMDetection does not have any performance degradation, our benchmark is as follows:
+
+| Model                   | official mAP | mmdet mAP |
+| ----------------------- | :----------: | :-------: |
+| glip_A_Swin_T_O365.yaml |     42.9     |   43.0    |
+| glip_Swin_T_O365.yaml   |     44.9     |   44.9    |
+| glip_Swin_L.yaml        |     51.4     |   51.3    |
+
+Users can use the test script we provided to run evaluation as well. Here is a basic example:
+
+```shell
+# 1 gpu
+python tools/test.py configs/glip/glip_atss_swin-t_fpn_dyhead_pretrain_obj365.py glip_tiny_a_mmdet-b3654169.pth
+
+# 8 GPU
+./tools/dist_test.sh configs/glip/glip_atss_swin-t_fpn_dyhead_pretrain_obj365.py glip_tiny_a_mmdet-b3654169.pth 8
+```
diff --git a/mmdetection/docs/en/user_guides/init_cfg.md b/mmdetection/docs/en/user_guides/init_cfg.md
new file mode 100644
index 00000000..312b67a8
--- /dev/null
+++ b/mmdetection/docs/en/user_guides/init_cfg.md
@@ -0,0 +1,161 @@
+# Weight initialization
+
+During training, a proper initialization strategy is beneficial to speeding up the training or obtaining a higher performance. [MMCV](https://github.com/open-mmlab/mmcv/blob/master/mmcv/cnn/utils/weight_init.py) provide some commonly used methods for initializing modules like `nn.Conv2d`. Model initialization in MMdetection mainly uses `init_cfg`. Users can initialize models with following two steps:
+
+1. Define `init_cfg` for a model or its components in `model_cfg`,  but `init_cfg` of children components have higher priority and will override `init_cfg` of parents modules.
+2. Build model as usual, but call `model.init_weights()` method explicitly, and model parameters will be initialized as configuration.
+
+The high-level workflow of initialization in MMdetection is :
+
+model_cfg(init_cfg) -> build_from_cfg -> model -> init_weight() -> initialize(self, self.init_cfg) -> children's init_weight()
+
+### Description
+
+It is dict or list\[dict\], and contains the following keys and values:
+
+- `type` (str), containing the initializer name in `INTIALIZERS`, and followed by arguments of the initializer.
+- `layer` (str or list\[str\]), containing the names of basic layers in Pytorch or MMCV with learnable parameters that will be initialized, e.g. `'Conv2d'`,`'DeformConv2d'`.
+- `override` (dict or list\[dict\]),  containing the sub-modules that not inherit from BaseModule and whose initialization configuration is different from other layers' which are in `'layer'` key. Initializer defined in `type` will work for all layers defined in `layer`, so if sub-modules are not derived Classes of `BaseModule` but can be initialized as same ways of layers in `layer`, it does not need to use `override`. `override` contains:
+  - `type` followed by arguments of initializer;
+  - `name` to indicate sub-module which will be initialized.
+
+### Initialize parameters
+
+Inherit a new model from `mmcv.runner.BaseModule` or `mmdet.models`  Here we show an example of FooModel.
+
+```python
+import torch.nn as nn
+from mmcv.runner import BaseModule
+
+class FooModel(BaseModule)
+	def __init__(self,
+                 arg1,
+                 arg2,
+                 init_cfg=None):
+    	super(FooModel, self).__init__(init_cfg)
+		...
+```
+
+- Initialize model by using `init_cfg` directly in code
+
+  ```python
+  import torch.nn as nn
+  from mmcv.runner import BaseModule
+  # or directly inherit mmdet models
+
+  class FooModel(BaseModule)
+  	def __init__(self,
+                  arg1,
+                  arg2,
+                  init_cfg=XXX):
+  		super(FooModel, self).__init__(init_cfg)
+  	    ...
+  ```
+
+- Initialize model by using `init_cfg` directly in `mmcv.Sequential` or `mmcv.ModuleList` code
+
+  ```python
+  from mmcv.runner import BaseModule, ModuleList
+
+  class FooModel(BaseModule)
+  	def __init__(self,
+              	arg1,
+              	arg2,
+              	init_cfg=None):
+  		super(FooModel, self).__init__(init_cfg)
+      	...
+      	self.conv1 = ModuleList(init_cfg=XXX)
+  ```
+
+- Initialize model by using `init_cfg` in config file
+
+  ```python
+  model = dict(
+  	...
+  	model = dict(
+      	type='FooModel',
+      	arg1=XXX,
+      	arg2=XXX,
+      	init_cfg=XXX),
+          ...
+  ```
+
+### Usage of init_cfg
+
+1. Initialize model by `layer` key
+
+   If we only define `layer`, it just initialize the layer in `layer` key.
+
+   NOTE: Value of `layer` key is the class name with attributes weights and bias of Pytorch, (so such as  `MultiheadAttention layer` is not supported).
+
+- Define `layer` key for initializing module with same configuration.
+
+  ```python
+  init_cfg = dict(type='Constant', layer=['Conv1d', 'Conv2d', 'Linear'], val=1)
+  # initialize whole module with same configuration
+  ```
+
+- Define `layer` key for initializing layer with different configurations.
+
+```python
+init_cfg = [dict(type='Constant', layer='Conv1d', val=1),
+            dict(type='Constant', layer='Conv2d', val=2),
+            dict(type='Constant', layer='Linear', val=3)]
+# nn.Conv1d will be initialized with dict(type='Constant', val=1)
+# nn.Conv2d will be initialized with dict(type='Constant', val=2)
+# nn.Linear will be initialized with dict(type='Constant', val=3)
+```
+
+2. Initialize model by `override` key
+
+- When initializing some specific part with its attribute name, we can use `override` key, and the value in `override` will ignore the value in init_cfg.
+
+  ```python
+  # layers:
+  # self.feat = nn.Conv1d(3, 1, 3)
+  # self.reg = nn.Conv2d(3, 3, 3)
+  # self.cls = nn.Linear(1,2)
+
+  init_cfg = dict(type='Constant',
+                  layer=['Conv1d','Conv2d'], val=1, bias=2,
+                  override=dict(type='Constant', name='reg', val=3, bias=4))
+  # self.feat and self.cls will be initialized with 	dict(type='Constant', val=1, bias=2)
+  # The module called 'reg' will be initialized with dict(type='Constant', val=3, bias=4)
+  ```
+
+- If `layer` is None in init_cfg, only sub-module with the name in override will be initialized, and type and other args in override can be omitted.
+
+  ```python
+  # layers:
+  # self.feat = nn.Conv1d(3, 1, 3)
+  # self.reg = nn.Conv2d(3, 3, 3)
+  # self.cls = nn.Linear(1,2)
+
+  init_cfg = dict(type='Constant', val=1, bias=2, 	override=dict(name='reg'))
+
+  # self.feat and self.cls will be initialized by Pytorch
+  # The module called 'reg' will be initialized with dict(type='Constant', val=1, bias=2)
+  ```
+
+- If we don't define `layer` key or `override` key, it will not initialize anything.
+
+- Invalid usage
+
+  ```python
+  # It is invalid that override don't have name key
+  init_cfg = dict(type='Constant', layer=['Conv1d','Conv2d'], val=1, bias=2,
+              	override=dict(type='Constant', val=3, bias=4))
+
+  # It is also invalid that override has name and other args except type
+  init_cfg = dict(type='Constant', layer=['Conv1d','Conv2d'], val=1, bias=2,
+                  override=dict(name='reg', val=3, bias=4))
+  ```
+
+3. Initialize model with the pretrained model
+
+   ```python
+   init_cfg = dict(type='Pretrained',
+               checkpoint='torchvision://resnet50')
+   ```
+
+More details can refer to the documentation in [MMEngine](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/initialize.html)
diff --git a/mmdetection/docs/en/user_guides/label_studio.md b/mmdetection/docs/en/user_guides/label_studio.md
new file mode 100644
index 00000000..d4b37447
--- /dev/null
+++ b/mmdetection/docs/en/user_guides/label_studio.md
@@ -0,0 +1,256 @@
+# Semi-automatic Object Detection Annotation with MMDetection and Label-Studio
+
+Annotation data is a time-consuming and laborious task. This article introduces how to perform semi-automatic annotation using the RTMDet algorithm in MMDetection in conjunction with Label-Studio software. Specifically, using RTMDet to predict image annotations and then refining the annotations with Label-Studio. Community users can refer to this process and methodology and apply it to other fields.
+
+- RTMDet: RTMDet is a high-precision single-stage object detection algorithm developed by OpenMMLab, open-sourced in the MMDetection object detection toolbox. Its open-source license is Apache 2.0, and it can be used freely without restrictions by industrial users.
+
+- [Label Studio](https://github.com/heartexlabs/label-studio) is an excellent annotation software covering the functionality of dataset annotation in areas such as image classification, object detection, and segmentation.
+
+In this article, we will use [cat](https://download.openmmlab.com/mmyolo/data/cat_dataset.zip) images for semi-automatic annotation.
+
+## Environment Configuration
+
+To begin with, you need to create a virtual environment and then install PyTorch and MMCV. In this article, we will specify the versions of PyTorch and MMCV. Next, you can install MMDetection, Label-Studio, and label-studio-ml-backend using the following steps:
+
+Create a virtual environment:
+
+```shell
+conda create -n rtmdet python=3.9 -y
+conda activate rtmdet
+```
+
+Install PyTorch:
+
+```shell
+# Linux and Windows CPU only
+pip install torch==1.10.1+cpu torchvision==0.11.2+cpu torchaudio==0.10.1 -f https://download.pytorch.org/whl/cpu/torch_stable.html
+# Linux and Windows CUDA 11.3
+pip install torch==1.10.1+cu113 torchvision==0.11.2+cu113 torchaudio==0.10.1 -f https://download.pytorch.org/whl/cu113/torch_stable.html
+# OSX
+pip install torch==1.10.1 torchvision==0.11.2 torchaudio==0.10.1
+```
+
+Install MMCV:
+
+```shell
+pip install -U openmim
+mim install "mmcv>=2.0.0"
+# Installing mmcv will automatically install mmengine
+```
+
+Install MMDetection:
+
+```shell
+git clone https://github.com/open-mmlab/mmdetection
+cd mmdetection
+pip install -v -e .
+```
+
+Install Label-Studio and label-studio-ml-backend:
+
+```shell
+# Installing Label-Studio may take some time, if the version is not found, please use the official source
+pip install label-studio==1.7.2
+pip install label-studio-ml==1.0.9
+```
+
+Download the rtmdet weights:
+
+```shell
+cd path/to/mmetection
+mkdir work_dirs
+cd work_dirs
+wget https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_m_8xb32-300e_coco/rtmdet_m_8xb32-300e_coco_20220719_112220-229f527c.pth
+```
+
+## Start the Service
+
+Start the RTMDet backend inference service:
+
+```shell
+cd path/to/mmetection
+
+label-studio-ml start projects/LabelStudio/backend_template --with \
+config_file=configs/rtmdet/rtmdet_m_8xb32-300e_coco.py \
+checkpoint_file=./work_dirs/rtmdet_m_8xb32-300e_coco_20220719_112220-229f527c.pth \
+device=cpu \
+--port 8003
+# Set device=cpu to use CPU inference, and replace cpu with cuda:0 to use GPU inference.
+```
+
+![](https://cdn.vansin.top/picgo20230330131601.png)
+
+The RTMDet backend inference service has now been started. To configure it in the Label-Studio web system, use http://localhost:8003 as the backend inference service.
+
+Now, start the Label-Studio web service:
+
+```shell
+label-studio start
+```
+
+![](https://cdn.vansin.top/picgo20230330132913.png)
+
+Open your web browser and go to http://localhost:8080/ to see the Label-Studio interface.
+
+![](https://cdn.vansin.top/picgo20230330133118.png)
+
+Register a user and then create an RTMDet-Semiautomatic-Label project.
+
+![](https://cdn.vansin.top/picgo20230330133333.png)
+
+Download the example cat images by running the following command and import them using the Data Import button:
+
+```shell
+cd path/to/mmetection
+mkdir data && cd data
+
+wget https://download.openmmlab.com/mmyolo/data/cat_dataset.zip && unzip cat_dataset.zip
+```
+
+![](https://cdn.vansin.top/picgo20230330133628.png)
+
+![](https://cdn.vansin.top/picgo20230330133715.png)
+
+Then, select the Object Detection With Bounding Boxes template.
+
+![](https://cdn.vansin.top/picgo20230330133807.png)
+
+```shell
+airplane
+apple
+backpack
+banana
+baseball_bat
+baseball_glove
+bear
+bed
+bench
+bicycle
+bird
+boat
+book
+bottle
+bowl
+broccoli
+bus
+cake
+car
+carrot
+cat
+cell_phone
+chair
+clock
+couch
+cow
+cup
+dining_table
+dog
+donut
+elephant
+fire_hydrant
+fork
+frisbee
+giraffe
+hair_drier
+handbag
+horse
+hot_dog
+keyboard
+kite
+knife
+laptop
+microwave
+motorcycle
+mouse
+orange
+oven
+parking_meter
+person
+pizza
+potted_plant
+refrigerator
+remote
+sandwich
+scissors
+sheep
+sink
+skateboard
+skis
+snowboard
+spoon
+sports_ball
+stop_sign
+suitcase
+surfboard
+teddy_bear
+tennis_racket
+tie
+toaster
+toilet
+toothbrush
+traffic_light
+train
+truck
+tv
+umbrella
+vase
+wine_glass
+zebra
+```
+
+Then, copy and add the above categories to Label-Studio and click Save.
+
+![](https://cdn.vansin.top/picgo20230330134027.png)
+
+In the Settings, click Add Model to add the RTMDet backend inference service.
+
+![](https://cdn.vansin.top/picgo20230330134320.png)
+
+Click Validate and Save, and then click Start Labeling.
+
+![](https://cdn.vansin.top/picgo20230330134424.png)
+
+If you see Connected as shown below, the backend inference service has been successfully added.
+
+![](https://cdn.vansin.top/picgo20230330134554.png)
+
+## Start Semi-Automatic Labeling
+
+Click on Label to start labeling.
+
+![](https://cdn.vansin.top/picgo20230330134804.png)
+
+We can see that the RTMDet backend inference service has successfully returned the predicted results and displayed them on the image. However, we noticed that the predicted bounding boxes for the cats are a bit too large and not very accurate.
+
+![](https://cdn.vansin.top/picgo20230403104419.png)
+
+We manually adjust the position of the cat bounding box, and then click Submit to complete the annotation of this image.
+
+![](https://cdn.vansin.top/picgo/20230403105923.png)
+
+After submitting all images, click export to export the labeled dataset in COCO format.
+
+![](https://cdn.vansin.top/picgo20230330135921.png)
+
+Use VS Code to open the unzipped folder to see the labeled dataset, which includes the images and the annotation files in JSON format.
+
+![](https://cdn.vansin.top/picgo20230330140321.png)
+
+At this point, the semi-automatic labeling is complete. We can use this dataset to train a more accurate model in MMDetection and then continue semi-automatic labeling on newly collected images with this model. This way, we can iteratively expand the high-quality dataset and improve the accuracy of the model.
+
+## Use MMYOLO as the Backend Inference Service
+
+If you want to use Label-Studio in MMYOLO, you can refer to replacing the config_file and checkpoint_file with the configuration file and weight file of MMYOLO when starting the backend inference service.
+
+```shell
+cd path/to/mmetection
+
+label-studio-ml start projects/LabelStudio/backend_template --with \
+config_file= path/to/mmyolo_config.py \
+checkpoint_file= path/to/mmyolo_weights.pth \
+device=cpu \
+--port 8003
+# device=cpu is for using CPU inference. If using GPU inference, replace cpu with cuda:0.
+```
+
+Rotation object detection and instance segmentation are still under development, please stay tuned.
diff --git a/mmdetection/docs/en/user_guides/new_model.md b/mmdetection/docs/en/user_guides/new_model.md
new file mode 100644
index 00000000..c7af855a
--- /dev/null
+++ b/mmdetection/docs/en/user_guides/new_model.md
@@ -0,0 +1,290 @@
+# Train with customized models and standard datasets
+
+In this note, you will know how to train, test and inference your own customized models under standard datasets. We use the cityscapes dataset to train a customized Cascade Mask R-CNN R50 model as an example to demonstrate the whole process, which using [`AugFPN`](https://github.com/Gus-Guo/AugFPN) to replace the default `FPN` as neck, and add `Rotate` or `TranslateX` as training-time auto augmentation.
+
+The basic steps are as below:
+
+1. Prepare the standard dataset
+2. Prepare your own customized model
+3. Prepare a config
+4. Train, test, and inference models on the standard dataset.
+
+## Prepare the standard dataset
+
+In this note, as we use the standard cityscapes dataset as an example.
+
+It is recommended to symlink the dataset root to `$MMDETECTION/data`.
+If your folder structure is different, you may need to change the corresponding paths in config files.
+
+```none
+mmdetection
+├── mmdet
+├── tools
+├── configs
+├── data
+│   ├── coco
+│   │   ├── annotations
+│   │   ├── train2017
+│   │   ├── val2017
+│   │   ├── test2017
+│   ├── cityscapes
+│   │   ├── annotations
+│   │   ├── leftImg8bit
+│   │   │   ├── train
+│   │   │   ├── val
+│   │   ├── gtFine
+│   │   │   ├── train
+│   │   │   ├── val
+│   ├── VOCdevkit
+│   │   ├── VOC2007
+│   │   ├── VOC2012
+
+```
+
+Or you can set your dataset root through
+
+```bash
+export MMDET_DATASETS=$data_root
+```
+
+We will replace dataset root with `$MMDET_DATASETS`, so you don't have to modify the corresponding path in config files.
+
+The cityscapes annotations have to be converted into the coco format using `tools/dataset_converters/cityscapes.py`:
+
+```shell
+pip install cityscapesscripts
+python tools/dataset_converters/cityscapes.py ./data/cityscapes --nproc 8 --out-dir ./data/cityscapes/annotations
+```
+
+Currently, the config files in `cityscapes` use COCO pre-trained weights to initialize.
+You could download the pre-trained models in advance if the network is unavailable or slow, otherwise, it would cause errors at the beginning of training.
+
+## Prepare your own customized model
+
+The second step is to use your own module or training setting. Assume that we want to implement a new neck called `AugFPN` to replace with the default `FPN` under the existing detector Cascade Mask R-CNN R50. The following implements `AugFPN` under MMDetection.
+
+### 1. Define a new neck (e.g. AugFPN)
+
+Firstly create a new file `mmdet/models/necks/augfpn.py`.
+
+```python
+import torch.nn as nn
+from mmdet.registry import MODELS
+
+
+@MODELS.register_module()
+class AugFPN(nn.Module):
+
+    def __init__(self,
+                in_channels,
+                out_channels,
+                num_outs,
+                start_level=0,
+                end_level=-1,
+                add_extra_convs=False):
+        pass
+
+    def forward(self, inputs):
+        # implementation is ignored
+        pass
+```
+
+### 2. Import the module
+
+You can either add the following line to `mmdet/models/necks/__init__.py`,
+
+```python
+from .augfpn import AugFPN
+```
+
+or alternatively add
+
+```python
+custom_imports = dict(
+    imports=['mmdet.models.necks.augfpn'],
+    allow_failed_imports=False)
+```
+
+to the config file and avoid modifying the original code.
+
+### 3. Modify the config file
+
+```python
+neck=dict(
+    type='AugFPN',
+    in_channels=[256, 512, 1024, 2048],
+    out_channels=256,
+    num_outs=5)
+```
+
+For more detailed usages about customizing your own models (e.g. implement a new backbone, head, loss, etc) and runtime training settings (e.g. define a new optimizer, use gradient clip, customize training schedules and hooks, etc), please refer to the guideline [Customize Models](../advanced_guides/customize_models.md) and [Customize Runtime Settings](../advanced_guides/customize_runtime.md) respectively.
+
+## Prepare a config
+
+The third step is to prepare a config for your own training setting. Assume that we want to add `AugFPN` and `Rotate` or `Translate` augmentation to existing Cascade Mask R-CNN R50 to train the cityscapes dataset, and assume the config is under directory `configs/cityscapes/` and named as `cascade-mask-rcnn_r50_augfpn_autoaug-10e_cityscapes.py`, the config is as below.
+
+```python
+# The new config inherits the base configs to highlight the necessary modification
+_base_ = [
+    '../_base_/models/cascade-mask-rcnn_r50_fpn.py',
+    '../_base_/datasets/cityscapes_instance.py', '../_base_/default_runtime.py'
+]
+
+model = dict(
+    # set None to avoid loading ImageNet pre-trained backbone,
+    # instead here we set `load_from` to load from COCO pre-trained detectors.
+    backbone=dict(init_cfg=None),
+    # replace neck from defaultly `FPN` to our new implemented module `AugFPN`
+    neck=dict(
+        type='AugFPN',
+        in_channels=[256, 512, 1024, 2048],
+        out_channels=256,
+        num_outs=5),
+    # We also need to change the num_classes in head from 80 to 8, to match the
+    # cityscapes dataset's annotation. This modification involves `bbox_head` and `mask_head`.
+    roi_head=dict(
+        bbox_head=[
+            dict(
+                type='Shared2FCBBoxHead',
+                in_channels=256,
+                fc_out_channels=1024,
+                roi_feat_size=7,
+                # change the number of classes from defaultly COCO to cityscapes
+                num_classes=8,
+                bbox_coder=dict(
+                    type='DeltaXYWHBBoxCoder',
+                    target_means=[0., 0., 0., 0.],
+                    target_stds=[0.1, 0.1, 0.2, 0.2]),
+                reg_class_agnostic=True,
+                loss_cls=dict(
+                    type='CrossEntropyLoss',
+                    use_sigmoid=False,
+                    loss_weight=1.0),
+                loss_bbox=dict(type='SmoothL1Loss', beta=1.0,
+                               loss_weight=1.0)),
+            dict(
+                type='Shared2FCBBoxHead',
+                in_channels=256,
+                fc_out_channels=1024,
+                roi_feat_size=7,
+                # change the number of classes from defaultly COCO to cityscapes
+                num_classes=8,
+                bbox_coder=dict(
+                    type='DeltaXYWHBBoxCoder',
+                    target_means=[0., 0., 0., 0.],
+                    target_stds=[0.05, 0.05, 0.1, 0.1]),
+                reg_class_agnostic=True,
+                loss_cls=dict(
+                    type='CrossEntropyLoss',
+                    use_sigmoid=False,
+                    loss_weight=1.0),
+                loss_bbox=dict(type='SmoothL1Loss', beta=1.0,
+                               loss_weight=1.0)),
+            dict(
+                type='Shared2FCBBoxHead',
+                in_channels=256,
+                fc_out_channels=1024,
+                roi_feat_size=7,
+                # change the number of classes from defaultly COCO to cityscapes
+                num_classes=8,
+                bbox_coder=dict(
+                    type='DeltaXYWHBBoxCoder',
+                    target_means=[0., 0., 0., 0.],
+                    target_stds=[0.033, 0.033, 0.067, 0.067]),
+                reg_class_agnostic=True,
+                loss_cls=dict(
+                    type='CrossEntropyLoss',
+                    use_sigmoid=False,
+                    loss_weight=1.0),
+                loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0))
+        ],
+        mask_head=dict(
+            type='FCNMaskHead',
+            num_convs=4,
+            in_channels=256,
+            conv_out_channels=256,
+            # change the number of classes from default COCO to cityscapes
+            num_classes=8,
+            loss_mask=dict(
+                type='CrossEntropyLoss', use_mask=True, loss_weight=1.0))))
+
+# over-write `train_pipeline` for new added `AutoAugment` training setting
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
+    dict(
+        type='AutoAugment',
+        policies=[
+            [dict(
+                 type='Rotate',
+                 level=5,
+                 img_border_value=(124, 116, 104),
+                 prob=0.5)
+            ],
+            [dict(type='Rotate', level=7, img_border_value=(124, 116, 104)),
+             dict(
+                 type='TranslateX',
+                 level=5,
+                 prob=0.5,
+                 img_border_value=(124, 116, 104))
+            ],
+        ]),
+    dict(
+        type='RandomResize',
+        scale=[(2048, 800), (2048, 1024)],
+        keep_ratio=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs'),
+]
+
+# set batch_size per gpu, and set new training pipeline
+train_dataloader = dict(
+    batch_size=1,
+    num_workers=3,
+    # over-write `pipeline` with new training pipeline setting
+    dataset=dict(pipeline=train_pipeline))
+
+# Set optimizer
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001))
+
+# Set customized learning policy
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500),
+    dict(
+        type='MultiStepLR',
+        begin=0,
+        end=10,
+        by_epoch=True,
+        milestones=[8],
+        gamma=0.1)
+]
+
+# train, val, test loop config
+train_cfg = dict(max_epochs=10, val_interval=1)
+
+# We can use the COCO pre-trained Cascade Mask R-CNN R50 model for a more stable performance initialization
+load_from = 'https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco/cascade_mask_rcnn_r50_fpn_1x_coco_20200203-9d4dcb24.pth'
+```
+
+## Train a new model
+
+To train a model with the new config, you can simply run
+
+```shell
+python tools/train.py configs/cityscapes/cascade-mask-rcnn_r50_augfpn_autoaug-10e_cityscapes.py
+```
+
+For more detailed usages, please refer to the [training guide](train.md).
+
+## Test and inference
+
+To test the trained model, you can simply run
+
+```shell
+python tools/test.py configs/cityscapes/cascade-mask-rcnn_r50_augfpn_autoaug-10e_cityscapes.py work_dirs/cascade-mask-rcnn_r50_augfpn_autoaug-10e_cityscapes/epoch_10.pth
+```
+
+For more detailed usages, please refer to the [testing guide](test.md).
diff --git a/mmdetection/docs/en/user_guides/robustness_benchmarking.md b/mmdetection/docs/en/user_guides/robustness_benchmarking.md
new file mode 100644
index 00000000..f6579564
--- /dev/null
+++ b/mmdetection/docs/en/user_guides/robustness_benchmarking.md
@@ -0,0 +1,110 @@
+# Corruption Benchmarking
+
+## Introduction
+
+We provide tools to test object detection and instance segmentation models on the image corruption benchmark defined in [Benchmarking Robustness in Object Detection: Autonomous Driving when Winter is Coming](https://arxiv.org/abs/1907.07484).
+This page provides basic tutorials how to use the benchmark.
+
+```latex
+@article{michaelis2019winter,
+  title={Benchmarking Robustness in Object Detection:
+    Autonomous Driving when Winter is Coming},
+  author={Michaelis, Claudio and Mitzkus, Benjamin and
+    Geirhos, Robert and Rusak, Evgenia and
+    Bringmann, Oliver and Ecker, Alexander S. and
+    Bethge, Matthias and Brendel, Wieland},
+  journal={arXiv:1907.07484},
+  year={2019}
+}
+```
+
+![image corruption example](../../../resources/corruptions_sev_3.png)
+
+## About the benchmark
+
+To submit results to the benchmark please visit the [benchmark homepage](https://github.com/bethgelab/robust-detection-benchmark)
+
+The benchmark is modelled after the [imagenet-c benchmark](https://github.com/hendrycks/robustness) which was originally
+published in [Benchmarking Neural Network Robustness to Common Corruptions and Perturbations](https://arxiv.org/abs/1903.12261) (ICLR 2019) by Dan Hendrycks and Thomas Dietterich.
+
+The image corruption functions are included in this library but can be installed separately using:
+
+```shell
+pip install imagecorruptions
+```
+
+Compared to imagenet-c a few changes had to be made to handle images of arbitrary size and greyscale images.
+We also modified the 'motion blur' and 'snow' corruptions to remove dependency from a linux specific library,
+which would have to be installed separately otherwise. For details please refer to the [imagecorruptions repository](https://github.com/bethgelab/imagecorruptions).
+
+## Inference with pretrained models
+
+We provide a testing script to evaluate a models performance on any combination of the corruptions provided in the benchmark.
+
+### Test a dataset
+
+- [x] single GPU testing
+- [ ] multiple GPU testing
+- [ ] visualize detection results
+
+You can use the following commands to test a models performance under the 15 corruptions used in the benchmark.
+
+```shell
+# single-gpu testing
+python tools/analysis_tools/test_robustness.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}]
+```
+
+Alternatively different group of corruptions can be selected.
+
+```shell
+# noise
+python tools/analysis_tools/test_robustness.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] --corruptions noise
+
+# blur
+python tools/analysis_tools/test_robustness.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] --corruptions blur
+
+# wetaher
+python tools/analysis_tools/test_robustness.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] --corruptions weather
+
+# digital
+python tools/analysis_tools/test_robustness.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] --corruptions digital
+```
+
+Or a costom set of corruptions e.g.:
+
+```shell
+# gaussian noise, zoom blur and snow
+python tools/analysis_tools/test_robustness.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] [--eval ${EVAL_METRICS}] --corruptions gaussian_noise zoom_blur snow
+```
+
+Finally the corruption severities to evaluate can be chosen.
+Severity 0 corresponds to clean data and the effect increases from 1 to 5.
+
+```shell
+# severity 1
+python tools/analysis_tools/test_robustness.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] [--eval ${EVAL_METRICS}] --severities 1
+
+# severities 0,2,4
+python tools/analysis_tools/test_robustness.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] [--eval ${EVAL_METRICS}] --severities 0 2 4
+```
+
+## Results for modelzoo models
+
+The results on COCO 2017val are shown in the below table.
+
+|        Model        |      Backbone       |  Style  | Lr schd | box AP clean | box AP corr. | box % | mask AP clean | mask AP corr. | mask % |
+| :-----------------: | :-----------------: | :-----: | :-----: | :----------: | :----------: | :---: | :-----------: | :-----------: | :----: |
+|    Faster R-CNN     |      R-50-FPN       | pytorch |   1x    |     36.3     |     18.2     | 50.2  |       -       |       -       |   -    |
+|    Faster R-CNN     |      R-101-FPN      | pytorch |   1x    |     38.5     |     20.9     | 54.2  |       -       |       -       |   -    |
+|    Faster R-CNN     |   X-101-32x4d-FPN   | pytorch |   1x    |     40.1     |     22.3     | 55.5  |       -       |       -       |   -    |
+|    Faster R-CNN     |   X-101-64x4d-FPN   | pytorch |   1x    |     41.3     |     23.4     | 56.6  |       -       |       -       |   -    |
+|    Faster R-CNN     |    R-50-FPN-DCN     | pytorch |   1x    |     40.0     |     22.4     | 56.1  |       -       |       -       |   -    |
+|    Faster R-CNN     | X-101-32x4d-FPN-DCN | pytorch |   1x    |     43.4     |     26.7     | 61.6  |       -       |       -       |   -    |
+|     Mask R-CNN      |      R-50-FPN       | pytorch |   1x    |     37.3     |     18.7     | 50.1  |     34.2      |     16.8      |  49.1  |
+|     Mask R-CNN      |    R-50-FPN-DCN     | pytorch |   1x    |     41.1     |     23.3     | 56.7  |     37.2      |     20.7      |  55.7  |
+|    Cascade R-CNN    |      R-50-FPN       | pytorch |   1x    |     40.4     |     20.1     | 49.7  |       -       |       -       |   -    |
+| Cascade Mask R-CNN  |      R-50-FPN       | pytorch |   1x    |     41.2     |     20.7     | 50.2  |     35.7      |     17.6      |  49.3  |
+|      RetinaNet      |      R-50-FPN       | pytorch |   1x    |     35.6     |     17.8     | 50.1  |       -       |       -       |   -    |
+| Hybrid Task Cascade | X-101-64x4d-FPN-DCN | pytorch |   1x    |     50.6     |     32.7     | 64.7  |     43.8      |     28.1      |  64.0  |
+
+Results may vary slightly due to the stochastic application of the corruptions.
diff --git a/mmdetection/docs/en/user_guides/semi_det.md b/mmdetection/docs/en/user_guides/semi_det.md
new file mode 100644
index 00000000..ee86c302
--- /dev/null
+++ b/mmdetection/docs/en/user_guides/semi_det.md
@@ -0,0 +1,325 @@
+# Semi-supervised Object Detection
+
+Semi-supervised object detection uses both labeled data and unlabeled data for training. It not only reduces the annotation burden for training high-performance object detectors but also further improves the object detector by using a large number of unlabeled data.
+
+A typical procedure to train a semi-supervised object detector is as below:
+
+- [Semi-supervised Object Detection](#semi-supervised-object-detection)
+  - [Prepare and split dataset](#prepare-and-split-dataset)
+  - [Configure multi-branch pipeline](#configure-multi-branch-pipeline)
+  - [Configure semi-supervised dataloader](#configure-semi-supervised-dataloader)
+  - [Configure semi-supervised model](#configure-semi-supervised-model)
+  - [Configure MeanTeacherHook](#configure-meanteacherhook)
+  - [Configure TeacherStudentValLoop](#configure-teacherstudentvalloop)
+
+## Prepare and split dataset
+
+We provide a dataset download script, which downloads the coco2017 dataset by default and decompresses it automatically.
+
+```shell
+python tools/misc/download_dataset.py
+```
+
+The decompressed dataset directory structure is as below:
+
+```plain
+mmdetection
+├── data
+│   ├── coco
+│   │   ├── annotations
+│   │   │   ├── image_info_unlabeled2017.json
+│   │   │   ├── instances_train2017.json
+│   │   │   ├── instances_val2017.json
+│   │   ├── test2017
+│   │   ├── train2017
+│   │   ├── unlabeled2017
+│   │   ├── val2017
+```
+
+There are two common experimental settings for semi-supervised object detection on the coco2017 dataset:
+
+(1) Split `train2017` according to a fixed percentage (1%, 2%, 5% and 10%) as a labeled dataset, and the rest of `train2017` as an unlabeled dataset. Because the different splits of `train2017` as labeled datasets will cause significant fluctuation on the accuracy of the semi-supervised detectors, five-fold cross-validation is used in practice to evaluate the algorithm. We provide the dataset split script:
+
+```shell
+python tools/misc/split_coco.py
+```
+
+By default, the script will split `train2017` according to the labeled data ratio  1%, 2%, 5% and 10%, and each split will be randomly repeated 5 times for cross-validation. The generated semi-supervised annotation file name format is as below:
+
+- the name format of labeled dataset: `instances_train2017.{fold}@{percent}.json`
+- the name format of unlabeled dataset: `instances_train2017.{fold}@{percent}-unlabeled.json`
+
+Here, `fold` is used for cross-validation, and `percent` represents the ratio of labeled data. The directory structure of the divided dataset is as below:
+
+```plain
+mmdetection
+├── data
+│   ├── coco
+│   │   ├── annotations
+│   │   │   ├── image_info_unlabeled2017.json
+│   │   │   ├── instances_train2017.json
+│   │   │   ├── instances_val2017.json
+│   │   ├── semi_anns
+│   │   │   ├── instances_train2017.1@1.json
+│   │   │   ├── instances_train2017.1@1-unlabeled.json
+│   │   │   ├── instances_train2017.1@2.json
+│   │   │   ├── instances_train2017.1@2-unlabeled.json
+│   │   │   ├── instances_train2017.1@5.json
+│   │   │   ├── instances_train2017.1@5-unlabeled.json
+│   │   │   ├── instances_train2017.1@10.json
+│   │   │   ├── instances_train2017.1@10-unlabeled.json
+│   │   │   ├── instances_train2017.2@1.json
+│   │   │   ├── instances_train2017.2@1-unlabeled.json
+│   │   ├── test2017
+│   │   ├── train2017
+│   │   ├── unlabeled2017
+│   │   ├── val2017
+```
+
+(2) Use `train2017` as the labeled dataset and `unlabeled2017` as the unlabeled dataset. Since `image_info_unlabeled2017.json` does not contain `categories` information, the `CocoDataset` cannot be initialized, so you need to write the `categories` of `instances_train2017.json` into `image_info_unlabeled2017.json` and save it as `instances_unlabeled2017.json`, the relevant script is as below:
+
+```python
+from mmengine.fileio import load, dump
+
+anns_train = load('instances_train2017.json')
+anns_unlabeled = load('image_info_unlabeled2017.json')
+anns_unlabeled['categories'] = anns_train['categories']
+dump(anns_unlabeled, 'instances_unlabeled2017.json')
+```
+
+The processed dataset directory is as below:
+
+```plain
+mmdetection
+├── data
+│   ├── coco
+│   │   ├── annotations
+│   │   │   ├── image_info_unlabeled2017.json
+│   │   │   ├── instances_train2017.json
+│   │   │   ├── instances_unlabeled2017.json
+│   │   │   ├── instances_val2017.json
+│   │   ├── test2017
+│   │   ├── train2017
+│   │   ├── unlabeled2017
+│   │   ├── val2017
+```
+
+## Configure multi-branch pipeline
+
+There are two main approaches to semi-supervised learning,
+[consistency regularization](https://research.nvidia.com/sites/default/files/publications/laine2017iclr_paper.pdf)
+and [pseudo label](https://www.researchgate.net/profile/Dong-Hyun-Lee/publication/280581078_Pseudo-Label_The_Simple_and_Efficient_Semi-Supervised_Learning_Method_for_Deep_Neural_Networks/links/55bc4ada08ae092e9660b776/Pseudo-Label-The-Simple-and-Efficient-Semi-Supervised-Learning-Method-for-Deep-Neural-Networks.pdf).
+Consistency regularization often requires some careful design, while pseudo label have a simpler form and are easier to extend to downstream tasks.
+We adopt a teacher-student joint training semi-supervised object detection framework based on pseudo label, so labeled data and unlabeled data need to configure different data pipeline:
+
+(1) Pipeline for labeled data:
+
+```python
+# pipeline used to augment labeled data,
+# which will be sent to student model for supervised training.
+sup_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=backend_args),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(type='RandomResize', scale=scale, keep_ratio=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='RandAugment', aug_space=color_space, aug_num=1),
+    dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)),
+    dict(type='MultiBranch', sup=dict(type='PackDetInputs'))
+]
+```
+
+(2) Pipeline for unlabeled data:
+
+```python
+# pipeline used to augment unlabeled data weakly,
+# which will be sent to teacher model for predicting pseudo instances.
+weak_pipeline = [
+    dict(type='RandomResize', scale=scale, keep_ratio=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(
+        type='PackDetInputs',
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor', 'flip', 'flip_direction',
+                   'homography_matrix')),
+]
+
+# pipeline used to augment unlabeled data strongly,
+# which will be sent to student model for unsupervised training.
+strong_pipeline = [
+    dict(type='RandomResize', scale=scale, keep_ratio=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(
+        type='RandomOrder',
+        transforms=[
+            dict(type='RandAugment', aug_space=color_space, aug_num=1),
+            dict(type='RandAugment', aug_space=geometric, aug_num=1),
+        ]),
+    dict(type='RandomErasing', n_patches=(1, 5), ratio=(0, 0.2)),
+    dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)),
+    dict(
+        type='PackDetInputs',
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor', 'flip', 'flip_direction',
+                   'homography_matrix')),
+]
+
+# pipeline used to augment unlabeled data into different views
+unsup_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=backend_args),
+    dict(type='LoadEmptyAnnotations'),
+    dict(
+        type='MultiBranch',
+        unsup_teacher=weak_pipeline,
+        unsup_student=strong_pipeline,
+    )
+]
+```
+
+## Configure semi-supervised dataloader
+
+(1) Build a semi-supervised dataset. Use `ConcatDataset` to concatenate labeled and unlabeled datasets.
+
+```python
+labeled_dataset = dict(
+    type=dataset_type,
+    data_root=data_root,
+    ann_file='annotations/instances_train2017.json',
+    data_prefix=dict(img='train2017/'),
+    filter_cfg=dict(filter_empty_gt=True, min_size=32),
+    pipeline=sup_pipeline)
+
+unlabeled_dataset = dict(
+    type=dataset_type,
+    data_root=data_root,
+    ann_file='annotations/instances_unlabeled2017.json',
+    data_prefix=dict(img='unlabeled2017/'),
+    filter_cfg=dict(filter_empty_gt=False),
+    pipeline=unsup_pipeline)
+
+train_dataloader = dict(
+    batch_size=batch_size,
+    num_workers=num_workers,
+    persistent_workers=True,
+    sampler=dict(
+        type='GroupMultiSourceSampler',
+        batch_size=batch_size,
+        source_ratio=[1, 4]),
+    dataset=dict(
+        type='ConcatDataset', datasets=[labeled_dataset, unlabeled_dataset]))
+```
+
+(2) Use multi-source dataset sampler. Use `GroupMultiSourceSampler` to sample data form batches from `labeled_dataset` and `labeled_dataset`, `source_ratio` controls the proportion of labeled data and unlabeled data in the batch. `GroupMultiSourceSampler` also ensures that the images in the same batch have similar aspect ratios. If you don't need to guarantee the aspect ratio of the images in the batch, you can use `MultiSourceSampler`. The sampling diagram of `GroupMultiSourceSampler` is as below:
+
+
    
+
+
    
+
+`sup=1000` indicates that the scale of the labeled dataset is 1000, `sup_h=200` indicates that the scale of the images with an aspect ratio greater than or equal to 1 in the labeled dataset is 200, and `sup_w=800` indicates that the scale of the images with an aspect ratio less than 1 in the labeled dataset is 800,
+`unsup=9000` indicates that the scale of the unlabeled dataset is 9000, `unsup_h=1800` indicates that the scale of the images with an aspect ratio greater than or equal to 1 in the unlabeled dataset is 1800, and `unsup_w=7200` indicates the scale of the images with an aspect ratio less than 1 in the unlabeled dataset is 7200.
+`GroupMultiSourceSampler` randomly selects a group according to the overall aspect ratio distribution of the images in the labeled dataset and the unlabeled dataset, and then sample data to form batches from the two datasets according to `source_ratio`, so labeled datasets and unlabeled datasets have different repetitions.
+
+## Configure semi-supervised model
+
+We choose `Faster R-CNN` as `detector` for semi-supervised training. Take the semi-supervised object detection algorithm `SoftTeacher` as an example,
+the model configuration can be inherited from `_base_/models/faster-rcnn_r50_fpn.py`, replacing the backbone network of the detector with `caffe` style.
+Note that unlike the supervised training configs, `Faster R-CNN` as `detector` is an attribute of `model`, not `model` .
+In addition, `data_preprocessor` needs to be set to `MultiBranchDataPreprocessor`, which is used to pad and normalize images from different pipelines.
+Finally, parameters required for semi-supervised training and testing can be configured via `semi_train_cfg` and `semi_test_cfg`.
+
+```python
+_base_ = [
+    '../_base_/models/faster-rcnn_r50_fpn.py', '../_base_/default_runtime.py',
+    '../_base_/datasets/semi_coco_detection.py'
+]
+
+detector = _base_.model
+detector.data_preprocessor = dict(
+    type='DetDataPreprocessor',
+    mean=[103.530, 116.280, 123.675],
+    std=[1.0, 1.0, 1.0],
+    bgr_to_rgb=False,
+    pad_size_divisor=32)
+detector.backbone = dict(
+    type='ResNet',
+    depth=50,
+    num_stages=4,
+    out_indices=(0, 1, 2, 3),
+    frozen_stages=1,
+    norm_cfg=dict(type='BN', requires_grad=False),
+    norm_eval=True,
+    style='caffe',
+    init_cfg=dict(
+        type='Pretrained',
+        checkpoint='open-mmlab://detectron2/resnet50_caffe'))
+
+model = dict(
+    _delete_=True,
+    type='SoftTeacher',
+    detector=detector,
+    data_preprocessor=dict(
+        type='MultiBranchDataPreprocessor',
+        data_preprocessor=detector.data_preprocessor),
+    semi_train_cfg=dict(
+        freeze_teacher=True,
+        sup_weight=1.0,
+        unsup_weight=4.0,
+        pseudo_label_initial_score_thr=0.5,
+        rpn_pseudo_thr=0.9,
+        cls_pseudo_thr=0.9,
+        reg_pseudo_thr=0.02,
+        jitter_times=10,
+        jitter_scale=0.06,
+        min_pseudo_bbox_wh=(1e-2, 1e-2)),
+    semi_test_cfg=dict(predict_on='teacher'))
+```
+
+In addition, we also support semi-supervised training for other detection models, such as `RetinaNet` and `Cascade R-CNN`. Since `SoftTeacher` only supports `Faster R-CNN`, it needs to be replaced with `SemiBaseDetector`, example is as below:
+
+```python
+_base_ = [
+    '../_base_/models/retinanet_r50_fpn.py', '../_base_/default_runtime.py',
+    '../_base_/datasets/semi_coco_detection.py'
+]
+
+detector = _base_.model
+
+model = dict(
+    _delete_=True,
+    type='SemiBaseDetector',
+    detector=detector,
+    data_preprocessor=dict(
+        type='MultiBranchDataPreprocessor',
+        data_preprocessor=detector.data_preprocessor),
+    semi_train_cfg=dict(
+        freeze_teacher=True,
+        sup_weight=1.0,
+        unsup_weight=1.0,
+        cls_pseudo_thr=0.9,
+        min_pseudo_bbox_wh=(1e-2, 1e-2)),
+    semi_test_cfg=dict(predict_on='teacher'))
+```
+
+Following the semi-supervised training configuration of `SoftTeacher`, change `batch_size` to 2 and `source_ratio` to `[1, 1]`, the experimental results of supervised and semi-supervised training of `RetinaNet`, `Faster R-CNN`, `Cascade R-CNN` and `SoftTeacher` on the 10% coco `train2017` are as below:
+
+|      Model       |   Detector    | BackBone | Style | sup-0.1-coco mAP | semi-0.1-coco mAP |
+| :--------------: | :-----------: | :------: | :---: | :--------------: | :---------------: |
+| SemiBaseDetector |   RetinaNet   | R-50-FPN | caffe |       23.5       |       27.7        |
+| SemiBaseDetector | Faster R-CNN  | R-50-FPN | caffe |       26.7       |       28.4        |
+| SemiBaseDetector | Cascade R-CNN | R-50-FPN | caffe |       28.0       |       29.7        |
+|   SoftTeacher    | Faster R-CNN  | R-50-FPN | caffe |       26.7       |       31.1        |
+
+## Configure MeanTeacherHook
+
+Usually, the teacher model is updated by Exponential Moving Average (EMA) the student model, and then the teacher model is optimized with the optimization of the student model, which can be achieved by configuring `custom_hooks`:
+
+```python
+custom_hooks = [dict(type='MeanTeacherHook')]
+```
+
+## Configure TeacherStudentValLoop
+
+Since there are two models in the teacher-student joint training framework, we can replace `ValLoop` with `TeacherStudentValLoop` to test the accuracy of both models during the training process.
+
+```python
+val_cfg = dict(type='TeacherStudentValLoop')
+```
diff --git a/mmdetection/docs/en/user_guides/single_stage_as_rpn.md b/mmdetection/docs/en/user_guides/single_stage_as_rpn.md
new file mode 100644
index 00000000..93a48dd7
--- /dev/null
+++ b/mmdetection/docs/en/user_guides/single_stage_as_rpn.md
@@ -0,0 +1,176 @@
+# Use a single stage detector as RPN
+
+Region proposal network (RPN) is a submodule in [Faster R-CNN](https://arxiv.org/abs/1506.01497), which generates proposals for the second stage of Faster R-CNN. Most two-stage detectors in MMDetection use [`RPNHead`](../../../mmdet/models/dense_heads/rpn_head.py) to generate proposals as RPN. However, any single-stage detector can serve as an RPN since their bounding box predictions can also be regarded as region proposals and thus be refined in the R-CNN. Therefore, MMDetection v3.0 supports that.
+
+To illustrate the whole process, here we give an example of how to use an anchor-free single-stage model [FCOS](../../../configs/fcos/fcos_r50-caffe_fpn_gn-head_1x_coco.py) as an RPN in [Faster R-CNN](../../../configs/faster_rcnn/faster-rcnn_r50_fpn_fcos-rpn_1x_coco.py).
+
+The outline of this tutorial is as below:
+
+1. Use `FCOSHead` as an `RPNHead` in Faster R-CNN
+2. Evaluate proposals
+3. Train the customized Faster R-CNN with pre-trained FCOS
+
+## Use `FCOSHead` as an `RPNHead` in Faster R-CNN
+
+To set `FCOSHead` as an `RPNHead` in Faster R-CNN, we should create a new config file named `configs/faster_rcnn/faster-rcnn_r50_fpn_fcos-rpn_1x_coco.py`, and replace with the setting of `rpn_head` with the setting of `bbox_head` in `configs/fcos/fcos_r50-caffe_fpn_gn-head_1x_coco.py`. Besides, we still use the neck setting of FCOS with strides of `[8, 16, 32, 64, 128]`, and update `featmap_strides` of `bbox_roi_extractor` to `[8, 16, 32, 64, 128]`. To avoid loss goes NAN, we apply warmup during the first 1000 iterations instead of the first 500 iterations, which means that the lr increases more slowly. The config is as follows:
+
+```python
+_base_ = [
+    '../_base_/models/faster-rcnn_r50_fpn.py',
+    '../_base_/datasets/coco_detection.py',
+    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
+]
+
+model = dict(
+    # copied from configs/fcos/fcos_r50-caffe_fpn_gn-head_1x_coco.py
+    neck=dict(
+        start_level=1,
+        add_extra_convs='on_output',  # use P5
+        relu_before_extra_convs=True),
+    rpn_head=dict(
+        _delete_=True,  # ignore the unused old settings
+        type='FCOSHead',
+        num_classes=1,  # num_classes = 1 for rpn, if num_classes > 1, it will be set to 1 in TwoStageDetector automatically
+        in_channels=256,
+        stacked_convs=4,
+        feat_channels=256,
+        strides=[8, 16, 32, 64, 128],
+        loss_cls=dict(
+            type='FocalLoss',
+            use_sigmoid=True,
+            gamma=2.0,
+            alpha=0.25,
+            loss_weight=1.0),
+        loss_bbox=dict(type='IoULoss', loss_weight=1.0),
+        loss_centerness=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)),
+    roi_head=dict(  # update featmap_strides due to the strides in neck
+        bbox_roi_extractor=dict(featmap_strides=[8, 16, 32, 64, 128])))
+
+# learning rate
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0,
+        end=1000),  # Slowly increase lr, otherwise loss becomes NAN
+    dict(
+        type='MultiStepLR',
+        begin=0,
+        end=12,
+        by_epoch=True,
+        milestones=[8, 11],
+        gamma=0.1)
+]
+```
+
+Then, we could use the following command to train our customized model. For more training commands, please refer to [here](train.md).
+
+```python
+# training with 8 GPUS
+bash tools/dist_train.sh configs/faster_rcnn/faster-rcnn_r50_fpn_fcos-rpn_1x_coco.py \
+    8 \
+    --work-dir ./work_dirs/faster-rcnn_r50_fpn_fcos-rpn_1x_coco
+```
+
+## Evaluate proposals
+
+The quality of proposals is of great importance to the performance of detector, therefore, we also provide a way to evaluate proposals. Same as above, create a new config file named `configs/rpn/fcos-rpn_r50_fpn_1x_coco.py`, and replace with setting of `rpn_head` with the setting of `bbox_head` in `configs/fcos/fcos_r50-caffe_fpn_gn-head_1x_coco.py`.
+
+```python
+_base_ = [
+    '../_base_/models/rpn_r50_fpn.py', '../_base_/datasets/coco_detection.py',
+    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
+]
+
+val_evaluator = dict(metric='proposal_fast')
+test_evaluator = val_evaluator
+
+model = dict(
+    # copied from configs/fcos/fcos_r50-caffe_fpn_gn-head_1x_coco.py
+    neck=dict(
+        start_level=1,
+        add_extra_convs='on_output',  # use P5
+        relu_before_extra_convs=True),
+    rpn_head=dict(
+        _delete_=True,  # ignore the unused old settings
+        type='FCOSHead',
+        num_classes=1,  # num_classes = 1 for rpn, if num_classes > 1, it will be set to 1 in RPN automatically
+        in_channels=256,
+        stacked_convs=4,
+        feat_channels=256,
+        strides=[8, 16, 32, 64, 128],
+        loss_cls=dict(
+            type='FocalLoss',
+            use_sigmoid=True,
+            gamma=2.0,
+            alpha=0.25,
+            loss_weight=1.0),
+        loss_bbox=dict(type='IoULoss', loss_weight=1.0),
+        loss_centerness=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)))
+```
+
+Suppose we have the checkpoint `./work_dirs/faster-rcnn_r50_fpn_fcos-rpn_1x_coco/epoch_12.pth` after training, then we can evaluate the quality of proposals with the following command.
+
+```python
+# testing with 8 GPUs
+bash tools/dist_test.sh \
+    configs/rpn/fcos-rpn_r50_fpn_1x_coco.py \
+    ./work_dirs/faster-rcnn_r50_fpn_fcos-rpn_1x_coco/epoch_12.pth \
+    8
+```
+
+## Train the customized Faster R-CNN with pre-trained FCOS
+
+Pre-training not only speeds up convergence of training, but also improves the performance of the detector. Therefore, here we give an example to illustrate how to do use a pre-trained FCOS as an RPN to accelerate training and improve the accuracy. Suppose we want to use `FCOSHead` as an rpn head in Faster R-CNN and train with the pre-trained [`fcos_r50-caffe_fpn_gn-head_1x_coco`](https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_r50_caffe_fpn_gn-head_1x_coco/fcos_r50_caffe_fpn_gn-head_1x_coco-821213aa.pth). The content of config file named `configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_fcos-rpn_1x_coco.py` is as the following. Note that `fcos_r50-caffe_fpn_gn-head_1x_coco` uses a caffe version of ResNet50, the pixel mean and std in `data_preprocessor` thus need to be updated.
+
+```python
+_base_ = [
+    '../_base_/models/faster-rcnn_r50_fpn.py',
+    '../_base_/datasets/coco_detection.py',
+    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
+]
+
+model = dict(
+    data_preprocessor=dict(
+        mean=[103.530, 116.280, 123.675],
+        std=[1.0, 1.0, 1.0],
+        bgr_to_rgb=False),
+    backbone=dict(
+        norm_cfg=dict(type='BN', requires_grad=False),
+        style='caffe',
+        init_cfg=None),  # the checkpoint in ``load_from`` contains the weights of backbone
+    neck=dict(
+        start_level=1,
+        add_extra_convs='on_output',  # use P5
+        relu_before_extra_convs=True),
+    rpn_head=dict(
+        _delete_=True,  # ignore the unused old settings
+        type='FCOSHead',
+        num_classes=1,  # num_classes = 1 for rpn, if num_classes > 1, it will be set to 1 in TwoStageDetector automatically
+        in_channels=256,
+        stacked_convs=4,
+        feat_channels=256,
+        strides=[8, 16, 32, 64, 128],
+        loss_cls=dict(
+            type='FocalLoss',
+            use_sigmoid=True,
+            gamma=2.0,
+            alpha=0.25,
+            loss_weight=1.0),
+        loss_bbox=dict(type='IoULoss', loss_weight=1.0),
+        loss_centerness=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)),
+    roi_head=dict(  # update featmap_strides due to the strides in neck
+        bbox_roi_extractor=dict(featmap_strides=[8, 16, 32, 64, 128])))
+
+load_from = 'https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_r50_caffe_fpn_gn-head_1x_coco/fcos_r50_caffe_fpn_gn-head_1x_coco-821213aa.pth'
+```
+
+The command for training is as below.
+
+```python
+bash tools/dist_train.sh \
+    configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_fcos-rpn_1x_coco.py \
+    8 \
+    --work-dir ./work_dirs/faster-rcnn_r50-caffe_fpn_fcos-rpn_1x_coco
+```
diff --git a/mmdetection/docs/en/user_guides/test.md b/mmdetection/docs/en/user_guides/test.md
new file mode 100644
index 00000000..129a2409
--- /dev/null
+++ b/mmdetection/docs/en/user_guides/test.md
@@ -0,0 +1,303 @@
+# Test existing models on standard datasets
+
+To evaluate a model's accuracy, one usually tests the model on some standard datasets, please refer to [dataset prepare guide](dataset_prepare.md) to prepare the dataset.
+
+This section will show how to test existing models on supported datasets.
+
+## Test existing models
+
+We provide testing scripts for evaluating an existing model on the whole dataset (COCO, PASCAL VOC, Cityscapes, etc.).
+The following testing environments are supported:
+
+- single GPU
+- CPU
+- single node multiple GPUs
+- multiple nodes
+
+Choose the proper script to perform testing depending on the testing environment.
+
+```shell
+# Single-gpu testing
+python tools/test.py \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    [--out ${RESULT_FILE}] \
+    [--show]
+
+# CPU: disable GPUs and run single-gpu testing script
+export CUDA_VISIBLE_DEVICES=-1
+python tools/test.py \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    [--out ${RESULT_FILE}] \
+    [--show]
+
+# Multi-gpu testing
+bash tools/dist_test.sh \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    ${GPU_NUM} \
+    [--out ${RESULT_FILE}]
+```
+
+`tools/dist_test.sh` also supports multi-node testing, but relies on PyTorch's [launch utility](https://pytorch.org/docs/stable/distributed.html#launch-utility).
+
+Optional arguments:
+
+- `RESULT_FILE`: Filename of the output results in pickle format. If not specified, the results will not be saved to a file.
+- `--show`: If specified, detection results will be plotted on the images and shown in a new window. It is only applicable to single GPU testing and used for debugging and visualization. Please make sure that GUI is available in your environment. Otherwise, you may encounter an error like `cannot connect to X server`.
+- `--show-dir`: If specified, detection results will be plotted on the images and saved to the specified directory. It is only applicable to single GPU testing and used for debugging and visualization. You do NOT need a GUI available in your environment for using this option.
+- `--work-dir`: If specified, detection results containing evaluation metrics will be saved to the specified directory.
+- `--cfg-options`:  If specified, the key-value pair optional cfg will be merged into config file
+
+## Examples
+
+Assuming that you have already downloaded the checkpoints to the directory `checkpoints/`.
+
+1. Test RTMDet and visualize the results. Press any key for the next image.
+   Config and checkpoint files are available [here](https://github.com/open-mmlab/mmdetection/tree/main/configs/rtmdet).
+
+   ```shell
+   python tools/test.py \
+       configs/rtmdet/rtmdet_l_8xb32-300e_coco.py \
+       checkpoints/rtmdet_l_8xb32-300e_coco_20220719_112030-5a0be7c4.pth \
+       --show
+   ```
+
+2. Test RTMDet and save the painted images for future visualization.
+   Config and checkpoint files are available [here](https://github.com/open-mmlab/mmdetection/tree/main/configs/rtmdet).
+
+   ```shell
+   python tools/test.py \
+       configs/rtmdet/rtmdet_l_8xb32-300e_coco.py \
+       checkpoints/rtmdet_l_8xb32-300e_coco_20220719_112030-5a0be7c4.pth \
+       --show-dir faster_rcnn_r50_fpn_1x_results
+   ```
+
+3. Test Faster R-CNN on PASCAL VOC (without saving the test results).
+   Config and checkpoint files are available [here](../../../configs/pascal_voc).
+
+   ```shell
+   python tools/test.py \
+       configs/pascal_voc/faster-rcnn_r50_fpn_1x_voc0712.py \
+       checkpoints/faster_rcnn_r50_fpn_1x_voc0712_20200624-c9895d40.pth
+   ```
+
+4. Test Mask R-CNN with 8 GPUs, and evaluate.
+   Config and checkpoint files are available [here](../../../configs/mask_rcnn).
+
+   ```shell
+   ./tools/dist_test.sh \
+       configs/mask-rcnn_r50_fpn_1x_coco.py \
+       checkpoints/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth \
+       8 \
+       --out results.pkl
+   ```
+
+5. Test Mask R-CNN with 8 GPUs, and evaluate the metric **class-wise**.
+   Config and checkpoint files are available [here](../../../configs/mask_rcnn).
+
+   ```shell
+   ./tools/dist_test.sh \
+       configs/mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py \
+       checkpoints/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth \
+       8 \
+       --out results.pkl \
+       --cfg-options test_evaluator.classwise=True
+   ```
+
+6. Test Mask R-CNN on COCO test-dev with 8 GPUs, and generate JSON files for submitting to the official evaluation server.
+   Config and checkpoint files are available [here](../../../configs/mask_rcnn).
+
+   Replace the original test_evaluator and test_dataloader with test_evaluator and test_dataloader in the comment in [config](../../../configs/_base_/datasets/coco_instance.py) and run:
+
+   ```shell
+   ./tools/dist_test.sh \
+       configs/mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py \
+       checkpoints/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth \
+       8
+   ```
+
+   This command generates two JSON files `./work_dirs/coco_instance/test.bbox.json` and `./work_dirs/coco_instance/test.segm.json`.
+
+7. Test Mask R-CNN on Cityscapes test with 8 GPUs, and generate txt and png files for submitting to the official evaluation server.
+   Config and checkpoint files are available [here](../../../configs/cityscapes).
+
+   Replace the original test_evaluator and test_dataloader with test_evaluator and test_dataloader in the comment in [config](../../../configs/_base_/datasets/cityscapes_instance.py) and run:
+
+   ```shell
+   ./tools/dist_test.sh \
+       configs/cityscapes/mask-rcnn_r50_fpn_1x_cityscapes.py \
+       checkpoints/mask_rcnn_r50_fpn_1x_cityscapes_20200227-afe51d5a.pth \
+       8
+   ```
+
+   The generated png and txt would be under `./work_dirs/cityscapes_metric/` directory.
+
+## Test without Ground Truth Annotations
+
+MMDetection supports to test models without ground-truth annotations using `CocoDataset`. If your dataset format is not in COCO format, please convert them to COCO format. For example, if your dataset format is VOC, you can directly convert it to COCO format by the [script in tools.](../../../tools/dataset_converters/pascal_voc.py) If your dataset format is Cityscapes, you can directly convert it to COCO format by the [script in tools.](../../../tools/dataset_converters/cityscapes.py) The rest of the formats can be converted using [this script](../../../tools/dataset_converters/images2coco.py).
+
+```shell
+python tools/dataset_converters/images2coco.py \
+    ${IMG_PATH} \
+    ${CLASSES} \
+    ${OUT} \
+    [--exclude-extensions]
+```
+
+arguments:
+
+- `IMG_PATH`: The root path of images.
+- `CLASSES`: The text file with a list of categories.
+- `OUT`: The output annotation json file name. The save dir is in the same directory as `IMG_PATH`.
+- `exclude-extensions`: The suffix of images to be excluded, such as 'png' and 'bmp'.
+
+After the conversion is complete, you need to replace the original test_evaluator and test_dataloader with test_evaluator and test_dataloader in the comment in [config](../../../configs/_base_/datasets/coco_detection.py)(find which dataset in 'configs/_base_/datasets' the current config corresponds to) and run:
+
+```shell
+# Single-gpu testing
+python tools/test.py \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    [--show]
+
+# CPU: disable GPUs and run single-gpu testing script
+export CUDA_VISIBLE_DEVICES=-1
+python tools/test.py \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    [--out ${RESULT_FILE}] \
+    [--show]
+
+# Multi-gpu testing
+bash tools/dist_test.sh \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    ${GPU_NUM} \
+    [--show]
+```
+
+Assuming that the checkpoints in the [model zoo](https://mmdetection.readthedocs.io/en/latest/modelzoo_statistics.html) have been downloaded to the directory `checkpoints/`, we can test Mask R-CNN on COCO test-dev with 8 GPUs, and generate JSON files using the following command.
+
+```sh
+./tools/dist_test.sh \
+    configs/mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py \
+    checkpoints/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth \
+    8
+```
+
+This command generates two JSON files `./work_dirs/coco_instance/test.bbox.json` and `./work_dirs/coco_instance/test.segm.json`.
+
+## Batch Inference
+
+MMDetection supports inference with a single image or batched images in test mode. By default, we use single-image inference and you can use batch inference by modifying `samples_per_gpu` in the config of test data. You can do that either by modifying the config as below.
+
+```shell
+data = dict(train_dataloader=dict(...), val_dataloader=dict(...), test_dataloader=dict(batch_size=2, ...))
+```
+
+Or you can set it through `--cfg-options` as `--cfg-options test_dataloader.batch_size=2`
+
+## Test Time Augmentation (TTA)
+
+Test time augmentation (TTA) is a data augmentation strategy used during the test phase. It applies different augmentations, such as flipping and scaling, to the same image for model inference, and then merges the predictions of each augmented image to obtain more accurate predictions. To make it easier for users to use TTA, MMEngine provides [BaseTTAModel](https://mmengine.readthedocs.io/en/latest/api/generated/mmengine.model.BaseTTAModel.html#mmengine.model.BaseTTAModel) class, which allows users to implement different TTA strategies by simply extending the BaseTTAModel class according to their needs.
+
+In MMDetection, we provides [DetTTAModel](../../../mmdet/models/test_time_augs/det_tta.py) class, which inherits from BaseTTAModel.
+
+### Use case
+
+Using TTA requires two steps. First, you need to add `tta_model` and `tta_pipeline` in the configuration file:
+
+```shell
+tta_model = dict(
+    type='DetTTAModel',
+    tta_cfg=dict(nms=dict(
+                   type='nms',
+                   iou_threshold=0.5),
+                   max_per_img=100))
+
+tta_pipeline = [
+    dict(type='LoadImageFromFile',
+        backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[[
+            dict(type='Resize', scale=(1333, 800), keep_ratio=True)
+        ], [ # It uses 2 flipping transformations (flipping and not flipping).
+            dict(type='RandomFlip', prob=1.),
+            dict(type='RandomFlip', prob=0.)
+        ], [
+            dict(
+               type='PackDetInputs',
+               meta_keys=('img_id', 'img_path', 'ori_shape',
+                       'img_shape', 'scale_factor', 'flip',
+                       'flip_direction'))
+       ]])]
+```
+
+Second, set `--tta` when running the test scripts as examples below:
+
+```shell
+# Single-gpu testing
+python tools/test.py \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    [--tta]
+
+# CPU: disable GPUs and run single-gpu testing script
+export CUDA_VISIBLE_DEVICES=-1
+python tools/test.py \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    [--out ${RESULT_FILE}] \
+    [--tta]
+
+# Multi-gpu testing
+bash tools/dist_test.sh \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    ${GPU_NUM} \
+    [--tta]
+```
+
+You can also modify the TTA config by yourself, such as adding scaling enhancement:
+
+```shell
+tta_model = dict(
+    type='DetTTAModel',
+    tta_cfg=dict(nms=dict(
+                   type='nms',
+                   iou_threshold=0.5),
+                   max_per_img=100))
+
+img_scales = [(1333, 800), (666, 400), (2000, 1200)]
+tta_pipeline = [
+    dict(type='LoadImageFromFile',
+         backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[[
+            dict(type='Resize', scale=s, keep_ratio=True) for s in img_scales
+        ], [
+            dict(type='RandomFlip', prob=1.),
+            dict(type='RandomFlip', prob=0.)
+        ], [
+            dict(
+               type='PackDetInputs',
+               meta_keys=('img_id', 'img_path', 'ori_shape',
+                       'img_shape', 'scale_factor', 'flip',
+                       'flip_direction'))
+       ]])]
+```
+
+The above data augmentation pipeline will first perform 3 multi-scaling transformations on the image, followed by 2 flipping transformations (flipping and not flipping). Finally, the image is packaged into the final result using PackDetInputs.
+
+Here are more TTA use cases for your reference:
+
+- [RetinaNet](../../../configs/retinanet/retinanet_tta.py)
+- [CenterNet](../../../configs/centernet/centernet_tta.py)
+- [YOLOX](../../../configs/rtmdet/rtmdet_tta.py)
+- [RTMDet](../../../configs/yolox/yolox_tta.py)
+
+For more advanced usage and data flow of TTA, please refer to [MMEngine](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/test_time_augmentation.html#data-flow). We will support instance segmentation TTA latter.
diff --git a/mmdetection/docs/en/user_guides/test_results_submission.md b/mmdetection/docs/en/user_guides/test_results_submission.md
new file mode 100644
index 00000000..721347ea
--- /dev/null
+++ b/mmdetection/docs/en/user_guides/test_results_submission.md
@@ -0,0 +1,182 @@
+# Test Results Submission
+
+## Panoptic segmentation test results submission
+
+The following sections introduce how to produce the prediction results of panoptic segmentation models on the COCO test-dev set and submit the predictions to [COCO evaluation server](https://competitions.codalab.org/competitions/19507).
+
+### Prerequisites
+
+- Download [COCO test dataset images](http://images.cocodataset.org/zips/test2017.zip), [testing image info](http://images.cocodataset.org/annotations/image_info_test2017.zip), and [panoptic train/val annotations](http://images.cocodataset.org/annotations/panoptic_annotations_trainval2017.zip), then unzip them, put 'test2017' to `data/coco/`, put json files and annotation files to `data/coco/annotations/`.
+
+```shell
+# suppose data/coco/ does not exist
+mkdir -pv data/coco/
+
+# download test2017
+wget -P data/coco/ http://images.cocodataset.org/zips/test2017.zip
+wget -P data/coco/ http://images.cocodataset.org/annotations/image_info_test2017.zip
+wget -P data/coco/ http://images.cocodataset.org/annotations/panoptic_annotations_trainval2017.zip
+
+# unzip them
+unzip data/coco/test2017.zip -d data/coco/
+unzip data/coco/image_info_test2017.zip -d data/coco/
+unzip data/coco/panoptic_annotations_trainval2017.zip -d data/coco/
+
+# remove zip files (optional)
+rm -rf data/coco/test2017.zip data/coco/image_info_test2017.zip data/coco/panoptic_annotations_trainval2017.zip
+```
+
+- Run the following code to update category information in testing image info. Since the attribute `isthing` is missing in category information of 'image_info_test-dev2017.json', we need to update it with the category information in 'panoptic_val2017.json'.
+
+```shell
+python tools/misc/gen_coco_panoptic_test_info.py data/coco/annotations
+```
+
+After completing the above preparations, your directory structure of `data` should be like this:
+
+```text
+data
+`-- coco
+    |-- annotations
+    |   |-- image_info_test-dev2017.json
+    |   |-- image_info_test2017.json
+    |   |-- panoptic_image_info_test-dev2017.json
+    |   |-- panoptic_train2017.json
+    |   |-- panoptic_train2017.zip
+    |   |-- panoptic_val2017.json
+    |   `-- panoptic_val2017.zip
+    `-- test2017
+```
+
+### Inference on coco test-dev
+
+To do inference on coco test-dev, we should update the setting of `test_dataloder` and `test_evaluator` first. There two ways to do this: 1. update them in config file; 2. update them in command line.
+
+#### Update them in config file
+
+The relevant settings are provided at the end of `configs/_base_/datasets/coco_panoptic.py`, as below.
+
+```python
+test_dataloader = dict(
+    batch_size=1,
+    num_workers=1,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='annotations/panoptic_image_info_test-dev2017.json',
+        data_prefix=dict(img='test2017/'),
+        test_mode=True,
+        pipeline=test_pipeline))
+test_evaluator = dict(
+    type='CocoPanopticMetric',
+    format_only=True,
+    ann_file=data_root + 'annotations/panoptic_image_info_test-dev2017.json',
+    outfile_prefix='./work_dirs/coco_panoptic/test')
+```
+
+Any of the following way can be used to update the setting for inference on coco test-dev set.
+
+Case 1: Directly uncomment the setting in `configs/_base_/datasets/coco_panoptic.py`.
+
+Case 2: Copy the following setting to the config file you used now.
+
+```python
+test_dataloader = dict(
+    dataset=dict(
+        ann_file='annotations/panoptic_image_info_test-dev2017.json',
+        data_prefix=dict(img='test2017/', _delete_=True)))
+test_evaluator = dict(
+    format_only=True,
+    ann_file=data_root + 'annotations/panoptic_image_info_test-dev2017.json',
+    outfile_prefix='./work_dirs/coco_panoptic/test')
+```
+
+Then infer on coco test-dev et by the following command.
+
+```shell
+python tools/test.py \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE}
+```
+
+#### Update them in command line
+
+The command for update of the related settings and inference on coco test-dev are as below.
+
+```shell
+# test with single gpu
+CUDA_VISIBLE_DEVICES=0 python tools/test.py \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    --cfg-options \
+    test_dataloader.dataset.ann_file=annotations/panoptic_image_info_test-dev2017.json \
+    test_dataloader.dataset.data_prefix.img=test2017 \
+    test_dataloader.dataset.data_prefix._delete_=True \
+    test_evaluator.format_only=True \
+    test_evaluator.ann_file=data/coco/annotations/panoptic_image_info_test-dev2017.json \
+    test_evaluator.outfile_prefix=${WORK_DIR}/results
+
+# test with four gpus
+CUDA_VISIBLE_DEVICES=0,1,3,4 bash tools/dist_test.sh \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    8 \  # eights gpus
+    --cfg-options \
+    test_dataloader.dataset.ann_file=annotations/panoptic_image_info_test-dev2017.json \
+    test_dataloader.dataset.data_prefix.img=test2017 \
+    test_dataloader.dataset.data_prefix._delete_=True \
+    test_evaluator.format_only=True \
+    test_evaluator.ann_file=data/coco/annotations/panoptic_image_info_test-dev2017.json \
+    test_evaluator.outfile_prefix=${WORK_DIR}/results
+
+# test with slurm
+GPUS=8 tools/slurm_test.sh \
+    ${Partition} \
+    ${JOB_NAME} \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    --cfg-options \
+    test_dataloader.dataset.ann_file=annotations/panoptic_image_info_test-dev2017.json \
+    test_dataloader.dataset.data_prefix.img=test2017 \
+    test_dataloader.dataset.data_prefix._delete_=True \
+    test_evaluator.format_only=True \
+    test_evaluator.ann_file=data/coco/annotations/panoptic_image_info_test-dev2017.json \
+    test_evaluator.outfile_prefix=${WORK_DIR}/results
+```
+
+Example
+
+Suppose we perform inference on `test2017` using pretrained MaskFormer with ResNet-50 backbone.
+
+```shell
+# test with single gpu
+CUDA_VISIBLE_DEVICES=0 python tools/test.py \
+    configs/maskformer/maskformer_r50_mstrain_16x1_75e_coco.py \
+    checkpoints/maskformer_r50_mstrain_16x1_75e_coco_20220221_141956-bc2699cb.pth \
+    --cfg-options \
+    test_dataloader.dataset.ann_file=annotations/panoptic_image_info_test-dev2017.json \
+    test_dataloader.dataset.data_prefix.img=test2017 \
+    test_dataloader.dataset.data_prefix._delete_=True \
+    test_evaluator.format_only=True \
+    test_evaluator.ann_file=data/coco/annotations/panoptic_image_info_test-dev2017.json \
+    test_evaluator.outfile_prefix=work_dirs/maskformer/results
+```
+
+### Rename files and zip results
+
+After inference, the panoptic segmentation results (a json file and a directory where the masks are stored) will be in `WORK_DIR`. We should rename them according to the naming convention described on [COCO's Website](https://cocodataset.org/#upload). Finally, we need to compress the json and the directory where the masks are stored into a zip file, and rename the zip file according to the naming convention. Note that the zip file should **directly** contains the above two files.
+
+The commands to rename files and zip results:
+
+```shell
+# In WORK_DIR, we have panoptic segmentation results: 'panoptic' and 'results.panoptic.json'.
+cd ${WORK_DIR}
+
+# replace '[algorithm_name]' with the name of algorithm you used.
+mv ./panoptic ./panoptic_test-dev2017_[algorithm_name]_results
+mv ./results.panoptic.json ./panoptic_test-dev2017_[algorithm_name]_results.json
+zip panoptic_test-dev2017_[algorithm_name]_results.zip -ur panoptic_test-dev2017_[algorithm_name]_results panoptic_test-dev2017_[algorithm_name]_results.json
+```
diff --git a/mmdetection/docs/en/user_guides/tracking_analysis_tools.md b/mmdetection/docs/en/user_guides/tracking_analysis_tools.md
new file mode 100644
index 00000000..acced58d
--- /dev/null
+++ b/mmdetection/docs/en/user_guides/tracking_analysis_tools.md
@@ -0,0 +1,86 @@
+**We provide lots of useful tools under the `tools/` directory.**
+
+## MOT Test-time Parameter Search
+
+`tools/analysis_tools/mot/mot_param_search.py` can search the parameters of the `tracker` in MOT models.
+It is used as the same manner with `tools/test.py` but **different** in the configs.
+
+Here is an example that shows how to modify the configs:
+
+1. Define the desirable evaluation metrics to record.
+
+   For example, you can define the `evaluator` as
+
+   ```python
+   test_evaluator=dict(type='MOTChallengeMetrics', metric=['HOTA', 'CLEAR', 'Identity'])
+   ```
+
+   Of course, you can also customize the content of `metric` in `test_evaluator`. You are free to choose one or more of `['HOTA', 'CLEAR', 'Identity']`.
+
+2. Define the parameters and the values to search.
+
+   Assume you have a tracker like
+
+   ```python
+   model=dict(
+       tracker=dict(
+           type='BaseTracker',
+           obj_score_thr=0.5,
+           match_iou_thr=0.5
+       )
+   )
+   ```
+
+   If you want to search the parameters of the tracker, just change the value to a list as follow
+
+   ```python
+   model=dict(
+       tracker=dict(
+           type='BaseTracker',
+           obj_score_thr=[0.4, 0.5, 0.6],
+           match_iou_thr=[0.4, 0.5, 0.6, 0.7]
+       )
+   )
+   ```
+
+   Then the script will test the totally 12 cases and log the results.
+
+## MOT Error Visualize
+
+`tools/analysis_tools/mot/mot_error_visualize.py` can visualize errors for multiple object tracking.
+This script needs the result of inference. By Default, the **red** bounding box denotes false positive, the **yellow** bounding box denotes the false negative and the **blue** bounding box denotes ID switch.
+
+```
+python tools/analysis_tools/mot/mot_error_visualize.py \
+    ${CONFIG_FILE}\
+    --input ${INPUT} \
+    --result-dir ${RESULT_DIR} \
+    [--output-dir ${OUTPUT}] \
+    [--fps ${FPS}] \
+    [--show] \
+    [--backend ${BACKEND}]
+```
+
+The `RESULT_DIR` contains the inference results of all videos and the inference result is a `txt` file.
+
+Optional arguments:
+
+- `OUTPUT`: Output of the visualized demo. If not specified, the `--show` is obligate to show the video on the fly.
+- `FPS`: FPS of the output video.
+- `--show`: Whether show the video on the fly.
+- `BACKEND`: The backend to visualize the boxes. Options are `cv2` and `plt`.
+
+## Browse dataset
+
+`tools/analysis_tools/mot/browse_dataset.py` can visualize the training dataset to check whether the dataset configuration is correct.
+
+**Examples:**
+
+```shell
+python tools/analysis_tools/browse_dataset.py ${CONFIG_FILE} [--show-interval ${SHOW_INTERVAL}]
+```
+
+Optional arguments:
+
+- `SHOW_INTERVAL`: The interval of show (s).
+- `--show`: Whether show the images on the fly.
diff --git a/mmdetection/docs/en/user_guides/tracking_config.md b/mmdetection/docs/en/user_guides/tracking_config.md
new file mode 100644
index 00000000..fa8aeea0
--- /dev/null
+++ b/mmdetection/docs/en/user_guides/tracking_config.md
@@ -0,0 +1,112 @@
+# Learn about Configs
+
+We use python files as our config system. You can find all the provided configs under $MMDetection/configs.
+
+We incorporate modular and inheritance design into our config system,
+which is convenient to conduct various experiments.
+If you wish to inspect the config file,
+you may run `python tools/misc/print_config.py /PATH/TO/CONFIG` to see the complete config.
+
+## A brief description of a complete config
+
+A complete config usually contains the following primary fields:
+
+- `model`: the basic config of model, which may contain `data_preprocessor`, modules (e.g., `detector`, `motion`),`train_cfg`, `test_cfg`, etc.
+- `train_dataloader`: the config of training dataloader, which usually contains `batch_size`, `num_workers`, `sampler`, `dataset`, etc.
+- `val_dataloader`: the config of validation dataloader, which is similar with `train_dataloader`.
+- `test_dataloader`: the config of testing dataloader, which is similar with `train_dataloader`.
+- `val_evaluator`: the config of validation evaluator. For example,`type='MOTChallengeMetrics'` for MOT task on the MOTChallenge benchmarks.
+- `test_evaluator`: the config of testing evaluator, which is similar with `val_evaluator`.
+- `train_cfg`: the config of training loop. For example, `type='EpochBasedTrainLoop'`.
+- `val_cfg`: the config of validation loop. For example, `type='VideoValLoop'`.
+- `test_cfg`: the config of testing loop. For example, `type='VideoTestLoop'`.
+- `default_hooks`: the config of default hooks, which may include hooks for timer, logger, param_scheduler, checkpoint, sampler_seed, visualization, etc.
+- `vis_backends`: the config of visualization backends, which uses `type='LocalVisBackend'` as default.
+- `visualizer`: the config of visualizer.  `type='TrackLocalVisualizer'` for MOT tasks.
+- `param_scheduler`: the config of parameter scheduler, which usually sets the learning rate scheduler.
+- `optim_wrapper`: the config of optimizer wrapper, which contains optimization-related information, for example optimizer, gradient clipping, etc.
+- `load_from`: load models as a pre-trained model from a given path.
+- `resume`: If `True`, resume checkpoints from `load_from`, and the training will be resumed from the epoch when the checkpoint is saved.
+
+## Modify config through script arguments
+
+When submitting jobs using `tools/train.py` or `tools/test_tracking.py`,
+you may specify `--cfg-options` to in-place modify the config.
+We present several examples as follows.
+For more details, please refer to [MMEngine](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/config.md).
+
+- **Update config keys of dict chains.**
+
+  The config options can be specified following the order of the dict keys in the original config.
+  For example, `--cfg-options model.detector.backbone.norm_eval=False` changes the all BN modules in model backbones to train mode.
+
+- **Update keys inside a list of configs.**
+
+  Some config dicts are composed as a list in your config.
+  For example, the testing pipeline `test_dataloader.dataset.pipeline` is normally a list e.g. `[dict(type='LoadImageFromFile'), ...]`.
+  If you want to change `LoadImageFromFile` to `LoadImageFromWebcam` in the pipeline,
+  you may specify `--cfg-options test_dataloader.dataset.pipeline.0.type=LoadImageFromWebcam`.
+
+- **Update values of list/tuples.**
+
+  Maybe the value to be updated is a list or a tuple.
+  For example, you can change the key `mean` of `data_preprocessor` by specifying `--cfg-options model.data_preprocessor.mean=[0,0,0]`.
+  Note that **NO** white space is allowed inside the specified value.
+
+## Config File Structure
+
+There are 3 basic component types under `config/_base_`, i.e., dataset, model and default_runtime.
+Many methods could be easily constructed with one of each like SORT, DeepSORT.
+The configs that are composed by components from `_base_` are called *primitive*.
+
+For all configs under the same folder, it is recommended to have only **one** *primitive* config.
+All other configs should inherit from the *primitive* config.
+In this way, the maximum of inheritance level is 3.
+
+For easy understanding, we recommend contributors to inherit from exiting methods.
+For example, if some modification is made base on Faster R-CNN,
+user may first inherit the basic Faster R-CNN structure
+by specifying `_base_ = ../_base_/models/faster-rcnn_r50-dc5.py`,
+then modify the necessary fields in the config files.
+
+If you are building an entirely new method that does not share the structure with any of the existing methods,
+you may create a folder `method_name` under `configs`.
+
+Please refer to [MMEngine](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/config.md) for detailed documentation.
+
+## Config Name Style
+
+We follow the below style to name config files. Contributors are advised to follow the same style.
+
+```shell
+{method}_{module}_{train_cfg}_{train_data}_{test_data}
+```
+
+- `{method}`: method name, like `sort`.
+- `{module}`: basic modules of the method, like `faster-rcnn_r50_fpn`.
+- `{train_cfg}`: training config which usually contains batch size, epochs, etc, like `8xb4-80e`.
+- `{train_data}`: training data, like `mot17halftrain`.
+- `{test_data}`: testing data, like `test-mot17halfval`.
+
+## FAQ
+
+**Ignore some fields in the base configs**
+
+Sometimes, you may set `_delete_=True` to ignore some of fields in base configs.
+You may refer to [MMEngine](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/config.md) for simple illustration.
+
+## Tracking Data Structure Introduction
+
+### Advantages and new features
+
+In mmdetection tracking task, we employ videos to organize the dataset and use
+TrackDataSample to descirbe dataset info.
+
+- Based on video organization, we provide transform `UniformRefFrameSample` to sample key frames and ref frames and use `TransformBroadcaster` for for clip training.
+- TrackDataSample can be viewd as a wrapper of multiple DetDataSample to some extent. It contains a property `video_data_samples` which is a list of DetDataSample, each of which corresponds to a single frame. In addition, it's metainfo includes key_frames_inds and ref_frames_inds to apply clip training way.
+- Thanks to video-based data organization, the entire video can be directly tested. This way is more concise and intuitive. We also provide image_based test method, if your GPU mmemory cannot fit the entire video.
+
+### TODO
+
+- Some algorithms like StrongSORT, Mask2Former can not support video_based testing. These algorithms pose a challenge to GPU memory. we will optimize this problem in the future.
+- Now we do not support joint training of video_based dataset like MOT Challenge Dataset and image_based dataset like Crowdhuman for the algorithm QDTrack. we will optimize this problem in the future.
diff --git a/mmdetection/docs/en/user_guides/tracking_dataset_prepare.md b/mmdetection/docs/en/user_guides/tracking_dataset_prepare.md
new file mode 100644
index 00000000..56a4b77f
--- /dev/null
+++ b/mmdetection/docs/en/user_guides/tracking_dataset_prepare.md
@@ -0,0 +1,247 @@
+## Dataset Preparation
+
+This page provides the instructions for dataset preparation on existing benchmarks, include
+
+- Multiple Object Tracking
+
+  - [MOT Challenge](https://motchallenge.net/)
+  - [CrowdHuman](https://www.crowdhuman.org/)
+
+- Video Instance Segmentation
+
+  - [YouTube-VIS](https://youtube-vos.org/dataset/vis/)
+
+### 1. Download Datasets
+
+Please download the datasets from the official websites. It is recommended to symlink the root of the datasets to `$MMDETECTION/data`.
+
+#### 1.1 Multiple Object Tracking
+
+- For the training and testing of multi object tracking task, one of the MOT Challenge datasets (e.g. MOT17, MOT20) are needed, CrowdHuman can be served as comlementary dataset.
+
+- For users in China, the following datasets can be downloaded from [OpenDataLab](https://opendatalab.com/) with high speed:
+
+  - [MOT17](https://opendatalab.com/MOT17/download)
+  - [MOT20](https://opendatalab.com/MOT20/download)
+  - [CrowdHuman](https://opendatalab.com/CrowdHuman/download)
+
+#### 1.2 Video Instance Segmentation
+
+- For the training and testing of video instance segmetatioon task, only one of YouTube-VIS datasets (e.g. YouTube-VIS 2019, YouTube-VIS 2021) is needed.
+
+- YouTube-VIS 2019 dataset can be download from [YouTubeVOS](https://codalab.lisn.upsaclay.fr/competitions/6064)
+
+- YouTube-VIS 2021 dataset can be download from [YouTubeVOS](https://codalab.lisn.upsaclay.fr/competitions/7680)
+
+#### 1.3 Data Structure
+
+If your folder structure is different from the following, you may need to change the corresponding paths in config files.
+
+```
+mmdetection
+├── mmdet
+├── tools
+├── configs
+├── data
+│   ├── coco
+│   │   ├── train2017
+│   │   ├── val2017
+│   │   ├── test2017
+│   │   ├── annotations
+│   │
+|   ├── MOT15/MOT16/MOT17/MOT20
+|   |   ├── train
+|   |   |   ├── MOT17-02-DPM
+|   |   |   |   ├── det
+|   │   │   │   ├── gt
+|   │   │   │   ├── img1
+|   │   │   │   ├── seqinfo.ini
+│   │   │   ├── ......
+|   |   ├── test
+|   |   |   ├── MOT17-01-DPM
+|   |   |   |   ├── det
+|   │   │   │   ├── img1
+|   │   │   │   ├── seqinfo.ini
+│   │   │   ├── ......
+│   │
+│   ├── crowdhuman
+│   │   ├── annotation_train.odgt
+│   │   ├── annotation_val.odgt
+│   │   ├── train
+│   │   │   ├── Images
+│   │   │   ├── CrowdHuman_train01.zip
+│   │   │   ├── CrowdHuman_train02.zip
+│   │   │   ├── CrowdHuman_train03.zip
+│   │   ├── val
+│   │   │   ├── Images
+│   │   │   ├── CrowdHuman_val.zip
+│   │
+```
+
+### 2. Convert Annotations
+
+In this case, you need to convert the official annotations to coco style. We provide scripts and the usages are as following:
+
+```shell
+# MOT17
+# The processing of other MOT Challenge dataset is the same as MOT17
+python ./tools/dataset_converters/mot2coco.py -i ./data/MOT17/ -o ./data/MOT17/annotations --split-train --convert-det
+python ./tools/dataset_converters/mot2reid.py -i ./data/MOT17/ -o ./data/MOT17/reid --val-split 0.2 --vis-threshold 0.3
+
+# CrowdHuman
+python ./tools/dataset_converters/crowdhuman2coco.py -i ./data/crowdhuman -o ./data/crowdhuman/annotations
+
+# YouTube-VIS 2019
+python ./tools/dataset_converters/youtubevis2coco.py -i ./data/youtube_vis_2019 -o ./data/youtube_vis_2019/annotations --version 2019
+
+# YouTube-VIS 2021
+python ./tools/dataset_converters/youtubevis2coco.py -i ./data/youtube_vis_2021 -o ./data/youtube_vis_2021/annotations --version 2021
+
+```
+
+The folder structure will be as following after your run these scripts:
+
+```
+mmdetection
+├── mmtrack
+├── tools
+├── configs
+├── data
+│   ├── coco
+│   │   ├── train2017
+│   │   ├── val2017
+│   │   ├── test2017
+│   │   ├── annotations
+│   │
+|   ├── MOT15/MOT16/MOT17/MOT20
+|   |   ├── train
+|   |   |   ├── MOT17-02-DPM
+|   |   |   |   ├── det
+|   │   │   │   ├── gt
+|   │   │   │   ├── img1
+|   │   │   │   ├── seqinfo.ini
+│   │   │   ├── ......
+|   |   ├── test
+|   |   |   ├── MOT17-01-DPM
+|   |   |   |   ├── det
+|   │   │   │   ├── img1
+|   │   │   │   ├── seqinfo.ini
+│   │   │   ├── ......
+|   |   ├── annotations
+|   |   ├── reid
+│   │   │   ├── imgs
+│   │   │   ├── meta
+│   │
+│   ├── crowdhuman
+│   │   ├── annotation_train.odgt
+│   │   ├── annotation_val.odgt
+│   │   ├── train
+│   │   │   ├── Images
+│   │   │   ├── CrowdHuman_train01.zip
+│   │   │   ├── CrowdHuman_train02.zip
+│   │   │   ├── CrowdHuman_train03.zip
+│   │   ├── val
+│   │   │   ├── Images
+│   │   │   ├── CrowdHuman_val.zip
+│   │   ├── annotations
+│   │   │   ├── crowdhuman_train.json
+│   │   │   ├── crowdhuman_val.json
+│   │
+│   ├── youtube_vis_2019
+│   │   │── train
+│   │   │   │── JPEGImages
+│   │   │   │── ......
+│   │   │── valid
+│   │   │   │── JPEGImages
+│   │   │   │── ......
+│   │   │── test
+│   │   │   │── JPEGImages
+│   │   │   │── ......
+│   │   │── train.json (the official annotation files)
+│   │   │── valid.json (the official annotation files)
+│   │   │── test.json (the official annotation files)
+│   │   │── annotations (the converted annotation file)
+│   │
+│   ├── youtube_vis_2021
+│   │   │── train
+│   │   │   │── JPEGImages
+│   │   │   │── instances.json (the official annotation files)
+│   │   │   │── ......
+│   │   │── valid
+│   │   │   │── JPEGImages
+│   │   │   │── instances.json (the official annotation files)
+│   │   │   │── ......
+│   │   │── test
+│   │   │   │── JPEGImages
+│   │   │   │── instances.json (the official annotation files)
+│   │   │   │── ......
+│   │   │── annotations (the converted annotation file)
+```
+
+#### The folder of annotations and reid in MOT15/MOT16/MOT17/MOT20
+
+We take MOT17 dataset as examples, the other datasets share similar structure.
+
+There are 8 JSON files in `data/MOT17/annotations`:
+
+`train_cocoformat.json`: JSON file containing the annotations information of the training set in MOT17 dataset.
+
+`train_detections.pkl`: Pickle file containing the public detections of the training set in MOT17 dataset.
+
+`test_cocoformat.json`: JSON file containing the annotations information of the testing set in MOT17 dataset.
+
+`test_detections.pkl`: Pickle file containing the public detections of the testing set in MOT17 dataset.
+
+`half-train_cocoformat.json`, `half-train_detections.pkl`, `half-val_cocoformat.json`and `half-val_detections.pkl` share similar meaning with `train_cocoformat.json` and `train_detections.pkl`. The `half` means we split each video in the training set into half. The first half videos are denoted as `half-train` set, and the second half videos are denoted as`half-val` set.
+
+The structure of `data/MOT17/reid` is as follows:
+
+```
+reid
+├── imgs
+│   ├── MOT17-02-FRCNN_000002
+│   │   ├── 000000.jpg
+│   │   ├── 000001.jpg
+│   │   ├── ...
+│   ├── MOT17-02-FRCNN_000003
+│   │   ├── 000000.jpg
+│   │   ├── 000001.jpg
+│   │   ├── ...
+├── meta
+│   ├── train_80.txt
+│   ├── val_20.txt
+```
+
+The `80` in `train_80.txt` means the proportion of the training dataset to the whole ReID dataset is 80%. While the proportion of the validation dataset is 20%.
+
+For training, we provide a annotation list `train_80.txt`. Each line of the list contains a filename and its corresponding ground-truth labels. The format is as follows:
+
+```
+MOT17-05-FRCNN_000110/000018.jpg 0
+MOT17-13-FRCNN_000146/000014.jpg 1
+MOT17-05-FRCNN_000088/000004.jpg 2
+MOT17-02-FRCNN_000009/000081.jpg 3
+```
+
+`MOT17-05-FRCNN_000110` denotes the 110-th person in `MOT17-05-FRCNN` video.
+
+For validation, The annotation list `val_20.txt` remains the same as format above.
+
+Images in `reid/imgs` are cropped from raw images in `MOT17/train` by the corresponding `gt.txt`. The value of ground-truth labels should fall in range `[0, num_classes - 1]`.
+
+#### The folder of annotations in crowdhuman
+
+There are 2 JSON files in `data/crowdhuman/annotations`:
+
+`crowdhuman_train.json`:  JSON file containing the annotations information of the training set in CrowdHuman dataset.
+`crowdhuman_val.json`:  JSON file containing the annotations information of the validation set in CrowdHuman dataset.
+
+#### The folder of annotations in youtube_vis_2019/youtube_vis2021
+
+There are 3 JSON files in `data/youtube_vis_2019/annotations` or `data/youtube_vis_2021/annotations`:
+
+`youtube_vis_2019_train.json`/`youtube_vis_2021_train.json`: JSON file containing the annotations information of the training set in youtube_vis_2019/youtube_vis2021 dataset.
+
+`youtube_vis_2019_valid.json`/`youtube_vis_2021_valid.json`: JSON file containing the annotations information of the validation set in youtube_vis_2019/youtube_vis2021 dataset.
+
+`youtube_vis_2019_test.json`/`youtube_vis_2021_test.json`: JSON file containing the annotations information of the testing set in youtube_vis_2019/youtube_vis2021 dataset.
diff --git a/mmdetection/docs/en/user_guides/tracking_inference.md b/mmdetection/docs/en/user_guides/tracking_inference.md
new file mode 100644
index 00000000..06a6912a
--- /dev/null
+++ b/mmdetection/docs/en/user_guides/tracking_inference.md
@@ -0,0 +1,55 @@
+# Inference
+
+We provide demo scripts to inference a given video or a folder that contains continuous images. The source codes are available [here](https://github.com/open-mmlab/mmdetection/tree/tracking/demo).
+
+Note that if you use a folder as the input, the image names there must be  **sortable** , which means we can re-order the images according to the numbers contained in the filenames. We now only support reading the images whose filenames end with `.jpg`, `.jpeg` and `.png`.
+
+## Inference MOT models
+
+This script can inference an input video / images with a multiple object tracking or video instance segmentation model.
+
+```shell
+python demo/mot_demo.py \
+    ${INPUTS}
+    ${CONFIG_FILE} \
+    [--checkpoint ${CHECKPOINT_FILE}] \
+    [--detector ${DETECTOR_FILE}] \
+    [--reid ${REID_FILE}] \
+    [--score-thr ${SCORE_THR}] \
+    [--device ${DEVICE}] \
+    [--out ${OUTPUT}] \
+    [--show]
+```
+
+The `INPUT` and `OUTPUT` support both _mp4 video_ format and the _folder_ format.
+
+**Important:** For `DeepSORT`, `SORT`, `StrongSORT`, they need load the weight of the `reid` and the weight of the `detector` separately. Therefore, we use `--detector` and `--reid` to load weights. Other algorithms such as `ByteTrack`, `OCSORT` `QDTrack` `MaskTrackRCNN` and `Mask2Former` use `--checkpoint` to load weights.
+
+Optional arguments:
+
+- `CHECKPOINT_FILE`: The checkpoint is optional.
+- `DETECTOR_FILE`: The detector is optional.
+- `REID_FILE`: The reid is optional.
+- `SCORE_THR`: The threshold of score to filter bboxes.
+- `DEVICE`: The device for inference. Options are `cpu` or `cuda:0`, etc.
+- `OUTPUT`: Output of the visualized demo. If not specified, the `--show` is obligate to show the video on the fly.
+- `--show`: Whether show the video on the fly.
+
+**Examples of running mot model:**
+
+```shell
+# Example 1: do not specify --checkpoint to use --detector
+python demo/mot_demo.py \
+    demo/demo_mot.mp4 \
+    configs/sort/sort_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py \
+    --detector \
+    https://download.openmmlab.com/mmtracking/mot/faster_rcnn/faster-rcnn_r50_fpn_4e_mot17-half-64ee2ed4.pth \
+    --out mot.mp4
+
+# Example 2: use --checkpoint
+python demo/mot_demo.py \
+    demo/demo_mot.mp4 \
+    configs/qdtrack/qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py \
+    --checkpoint https://download.openmmlab.com/mmtracking/mot/qdtrack/mot_dataset/qdtrack_faster-rcnn_r50_fpn_4e_mot17_20220315_145635-76f295ef.pth \
+    --out mot.mp4
+```
diff --git a/mmdetection/docs/en/user_guides/tracking_train_test.md b/mmdetection/docs/en/user_guides/tracking_train_test.md
new file mode 100644
index 00000000..1a6871d7
--- /dev/null
+++ b/mmdetection/docs/en/user_guides/tracking_train_test.md
@@ -0,0 +1,229 @@
+# Learn to train and test
+
+## Train
+
+This section will show how to train existing models on supported datasets.
+The following training environments are supported:
+
+- CPU
+- single GPU
+- single node multiple GPUs
+- multiple nodes
+
+You can also manage jobs with Slurm.
+
+Important:
+
+- You can change the evaluation interval during training by modifying the `train_cfg` as
+  `train_cfg = dict(val_interval=10)`. That means evaluating the model every 10 epochs.
+- The default learning rate in all config files is for 8 GPUs.
+  According to the [Linear Scaling Rule](https://arxiv.org/abs/1706.02677),
+  you need to set the learning rate proportional to the batch size if you use different GPUs or images per GPU,
+  e.g., `lr=0.01` for 8 GPUs * 1 img/gpu and lr=0.04 for 16 GPUs * 2 imgs/gpu.
+- During training, log files and checkpoints will be saved to the working directory,
+  which is specified by CLI argument `--work-dir`. It uses `./work_dirs/CONFIG_NAME` as default.
+- If you want the mixed precision training, simply specify CLI argument `--amp`.
+
+#### 1. Train on CPU
+
+The model is default put on cuda device.
+Only if there are no cuda devices, the model will be put on cpu.
+So if you want to train the model on CPU, you need to `export CUDA_VISIBLE_DEVICES=-1` to disable GPU visibility first.
+More details in [MMEngine](https://github.com/open-mmlab/mmengine/blob/ca282aee9e402104b644494ca491f73d93a9544f/mmengine/runner/runner.py#L849-L850).
+
+```shell script
+CUDA_VISIBLE_DEVICES=-1 python tools/train.py ${CONFIG_FILE} [optional arguments]
+```
+
+An example of training the MOT model QDTrack on CPU:
+
+```shell script
+CUDA_VISIBLE_DEVICES=-1 python tools/train.py configs/qdtrack/qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py
+```
+
+#### 2. Train on single GPU
+
+If you want to train the model on single GPU, you can directly use the `tools/train.py` as follows.
+
+```shell script
+python tools/train.py ${CONFIG_FILE} [optional arguments]
+```
+
+You can use `export CUDA_VISIBLE_DEVICES=$GPU_ID` to select the GPU.
+
+An example of training the MOT model QDTrack on single GPU:
+
+```shell script
+CUDA_VISIBLE_DEVICES=2 python tools/train.py configs/qdtrack/qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py
+```
+
+#### 3. Train on single node multiple GPUs
+
+We provide `tools/dist_train.sh` to launch training on multiple GPUs.
+The basic usage is as follows.
+
+```shell script
+bash ./tools/dist_train.sh ${CONFIG_FILE} ${GPU_NUM} [optional arguments]
+```
+
+If you would like to launch multiple jobs on a single machine,
+e.g., 2 jobs of 4-GPU training on a machine with 8 GPUs,
+you need to specify different ports (29500 by default) for each job to avoid communication conflict.
+
+For example, you can set the port in commands as follows.
+
+```shell script
+CUDA_VISIBLE_DEVICES=0,1,2,3 PORT=29500 ./tools/dist_train.sh ${CONFIG_FILE} 4
+CUDA_VISIBLE_DEVICES=4,5,6,7 PORT=29501 ./tools/dist_train.sh ${CONFIG_FILE} 4
+```
+
+An example of training the MOT model QDTrack on single node multiple GPUs:
+
+```shell script
+bash ./tools/dist_train.sh configs/qdtrack/qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py 8
+```
+
+#### 4. Train on multiple nodes
+
+If you launch with multiple machines simply connected with ethernet, you can simply run following commands:
+
+On the first machine:
+
+```shell script
+NNODES=2 NODE_RANK=0 PORT=$MASTER_PORT MASTER_ADDR=$MASTER_ADDR bash tools/dist_train.sh $CONFIG $GPUS
+```
+
+On the second machine:
+
+```shell script
+NNODES=2 NODE_RANK=1 PORT=$MASTER_PORT MASTER_ADDR=$MASTER_ADDR bash tools/dist_train.sh $CONFIG $GPUS
+```
+
+Usually it is slow if you do not have high speed networking like InfiniBand.
+
+#### 5. Train with Slurm
+
+[Slurm](https://slurm.schedmd.com/) is a good job scheduling system for computing clusters.
+On a cluster managed by Slurm, you can use `slurm_train.sh` to spawn training jobs.
+It supports both single-node and multi-node training.
+
+The basic usage is as follows.
+
+```shell script
+bash ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} ${CONFIG_FILE} ${WORK_DIR} ${GPUS}
+```
+
+An example of training the MOT model QDTrack with Slurm:
+
+```shell script
+PORT=29501 \
+GPUS_PER_NODE=8 \
+SRUN_ARGS="--quotatype=reserved" \
+bash ./tools/slurm_train.sh \
+mypartition \
+mottrack
+configs/qdtrack/qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py
+./work_dirs/QDTrack \
+8
+```
+
+## Test
+
+This section will show how to test existing models on supported datasets.
+The following testing environments are supported:
+
+- CPU
+- single GPU
+- single node multiple GPUs
+- multiple nodes
+
+You can also manage jobs with Slurm.
+
+Important:
+
+- In MOT, some algorithms like `DeepSORT`, `SORT`, `StrongSORT` need load the weight of the `reid` and the weight of the `detector` separately.
+  Other algorithms such as `ByteTrack`, `OCSORT` and `QDTrack` don't need. So we provide `--checkpoint`, `--detector` and `--reid` to load weights.
+- We provide two ways to evaluate and test models, video_basede test and image_based test. some algorithms like `StrongSORT`, `Mask2former` only support
+  video_based test. if your GPU memory can't fit the entire video, you can switch test way by set sampler type.
+  For example:
+  video_based test: `sampler=dict(type='DefaultSampler', shuffle=False, round_up=False)`
+  image_based test: `sampler=dict(type='TrackImgSampler')`
+- You can set the results saving path by modifying the key `outfile_prefix` in evaluator.
+  For example, `val_evaluator = dict(outfile_prefix='results/sort_mot17')`.
+  Otherwise, a temporal file will be created and will be removed after evaluation.
+- If you just want the formatted results without evaluation, you can set `format_only=True`.
+  For example, `test_evaluator = dict(type='MOTChallengeMetric', metric=['HOTA', 'CLEAR', 'Identity'], outfile_prefix='sort_mot17_results', format_only=True)`
+
+#### 1. Test on CPU
+
+The model is default put on cuda device.
+Only if there are no cuda devices, the model will be put on cpu.
+So if you want to test the model on CPU, you need to `export CUDA_VISIBLE_DEVICES=-1` to disable GPU visibility first.
+More details in [MMEngine](https://github.com/open-mmlab/mmengine/blob/ca282aee9e402104b644494ca491f73d93a9544f/mmengine/runner/runner.py#L849-L850).
+
+```shell script
+CUDA_VISIBLE_DEVICES=-1 python tools/test_tracking.py ${CONFIG_FILE} [optional arguments]
+```
+
+An example of testing the MOT model SORT on CPU:
+
+```shell script
+CUDA_VISIBLE_DEVICES=-1 python tools/test_tracking.py configs/sort/sort_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py --detector ${CHECKPOINT_FILE}
+```
+
+#### 2. Test on single GPU
+
+If you want to test the model on single GPU, you can directly use the `tools/test_tracking.py` as follows.
+
+```shell script
+python tools/test_tracking.py ${CONFIG_FILE} [optional arguments]
+```
+
+You can use `export CUDA_VISIBLE_DEVICES=$GPU_ID` to select the GPU.
+
+An example of testing the MOT model QDTrack on single GPU:
+
+```shell script
+CUDA_VISIBLE_DEVICES=2 python tools/test_tracking.py configs/qdtrack/qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py --detector ${CHECKPOINT_FILE}
+```
+
+#### 3. Test on single node multiple GPUs
+
+We provide `tools/dist_test_tracking.sh` to launch testing on multiple GPUs.
+The basic usage is as follows.
+
+```shell script
+bash ./tools/dist_test_tracking.sh ${CONFIG_FILE} ${GPU_NUM} [optional arguments]
+```
+
+An example of testing the MOT model DeepSort on single node multiple GPUs:
+
+```shell script
+bash ./tools/dist_test_tracking.sh configs/qdtrack/qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py 8 --detector ${CHECKPOINT_FILE} --reid ${CHECKPOINT_FILE}
+```
+
+#### 4. Test on multiple nodes
+
+You can test on multiple nodes, which is similar with "Train on multiple nodes".
+
+#### 5. Test with Slurm
+
+On a cluster managed by Slurm, you can use `slurm_test_tracking.sh` to spawn testing jobs.
+It supports both single-node and multi-node testing.
+
+The basic usage is as follows.
+
+```shell script
+[GPUS=${GPUS}] bash tools/slurm_test_tracking.sh ${PARTITION} ${JOB_NAME} ${CONFIG_FILE} [optional arguments]
+```
+
+An example of testing the VIS model Mask2former with Slurm:
+
+```shell script
+GPUS=8
+bash tools/slurm_test_tracking.sh \
+mypartition \
+vis \
+configs/mask2former_vis/mask2former_r50_8xb2-8e_youtubevis2021.py \
+--checkpoint ${CHECKPOINT_FILE}
+```
diff --git a/mmdetection/docs/en/user_guides/tracking_visualization.md b/mmdetection/docs/en/user_guides/tracking_visualization.md
new file mode 100644
index 00000000..28953256
--- /dev/null
+++ b/mmdetection/docs/en/user_guides/tracking_visualization.md
@@ -0,0 +1,47 @@
+# Learn about Visualization
+
+## Local Visualization
+
+This section will present how to visualize the detection/tracking results with local visualizer.
+
+If you want to draw prediction results, you can turn this feature on by setting `draw=True` in `TrackVisualizationHook` as follows.
+
+```shell script
+default_hooks = dict(visualization=dict(type='TrackVisualizationHook', draw=True))
+```
+
+Specifically, the `TrackVisualizationHook` has the following arguments:
+
+- `draw`: whether to draw prediction results. If it is False, it means that no drawing will be done. Defaults to False.
+- `interval`: The interval of visualization. Defaults to 30.
+- `score_thr`: The threshold to visualize the bboxes and masks. Defaults to 0.3.
+- `show`: Whether to display the drawn image. Default to False.
+- `wait_time`: The interval of show (s). Defaults to 0.
+- `test_out_dir`: directory where painted images will be saved in testing process.
+- `backend_args`: Arguments to instantiate a file client. Defaults to `None`.
+
+In the `TrackVisualizationHook`, `TrackLocalVisualizer` will be called to implement visualization for MOT and VIS tasks.
+We will present the details below.
+You can refer to MMEngine for more details about [Visualization](https://github.com/open-mmlab/mmengine/blob/main/docs/en/advanced_tutorials/visualization.md) and [Hook](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/hook.md).
+
+#### Tracking Visualization
+
+We realize the tracking visualization with class `TrackLocalVisualizer`.
+You can call it as follows.
+
+```python
+visualizer = dict(type='TrackLocalVisualizer')
+```
+
+It has the following arguments:
+
+- `name`: Name of the instance. Defaults to 'visualizer'.
+- `image`: The origin image to draw. The format should be RGB. Defaults to None.
+- `vis_backends`: Visual backend config list. Defaults to None.
+- `save_dir`: Save file dir for all storage backends. If it is None, the backend storage will not save any data.
+- `line_width`: The linewidth of lines. Defaults to 3.
+- `alpha`: The transparency of bboxes or mask. Defaults to 0.8.
+
+Here is a visualization example of DeepSORT:
+
+![test_img_89](https://user-images.githubusercontent.com/99722489/186062929-6d0e4663-0d8e-4045-9ec8-67e0e41da876.png)
diff --git a/mmdetection/docs/en/user_guides/train.md b/mmdetection/docs/en/user_guides/train.md
new file mode 100644
index 00000000..a68d5e4f
--- /dev/null
+++ b/mmdetection/docs/en/user_guides/train.md
@@ -0,0 +1,456 @@
+# Train predefined models on standard datasets
+
+MMDetection also provides out-of-the-box tools for training detection models.
+This section will show how to train _predefined_ models (under [configs](../../../configs)) on standard datasets i.e. COCO.
+
+## Prepare datasets
+
+Preparing datasets is also necessary for training. See section [Prepare datasets](#prepare-datasets) above for details.
+
+**Note**:
+Currently, the config files under `configs/cityscapes` use COCO pre-trained weights to initialize.
+If your network connection is slow or unavailable, it's advisable to download existing models before beginning training to avoid errors.
+
+## Learning rate auto scaling
+
+**Important**: The default learning rate in config files is for 8 GPUs and 2 sample per GPU (batch size = 8 * 2 = 16). And it had been set to `auto_scale_lr.base_batch_size` in `config/_base_/schedules/schedule_1x.py`. The learning rate will be automatically scaled based on the value at a batch size of 16. Meanwhile, to avoid affecting other codebases that use mmdet, the default setting for the `auto_scale_lr.enable` flag is `False`.
+
+If you want to enable this feature, you need to add argument `--auto-scale-lr`. And you need to check the config name which you want to use before you process the command, because the config name indicates the default batch size.
+By default, it is `8 x 2 = 16 batch size`, like `faster_rcnn_r50_caffe_fpn_90k_coco.py` or `pisa_faster_rcnn_x101_32x4d_fpn_1x_coco.py`. In other cases, you will see the config file name have `_NxM_` in dictating, like `cornernet_hourglass104_mstest_32x3_210e_coco.py` which batch size is `32 x 3 = 96`, or `scnet_x101_64x4d_fpn_8x1_20e_coco.py` which batch size is `8 x 1 = 8`.
+
+**Please remember to check the bottom of the specific config file you want to use, it will have `auto_scale_lr.base_batch_size` if the batch size is not `16`. If you can't find those values, check the config file which in `_base_=[xxx]` and you will find it. Please do not modify its values if you want to automatically scale the LR.**
+
+The basic usage of learning rate auto scaling is as follows.
+
+```shell
+python tools/train.py \
+    ${CONFIG_FILE} \
+    --auto-scale-lr \
+    [optional arguments]
+```
+
+If you enabled this feature, the learning rate will be automatically scaled according to the number of GPUs on the machine and the batch size of training. See [linear scaling rule](https://arxiv.org/abs/1706.02677) for details. For example, If there are 4 GPUs and 2 pictures on each GPU, `lr = 0.01`, then if there are 16 GPUs and 4 pictures on each GPU, it will automatically scale to `lr = 0.08`.
+
+If you don't want to use it, you need to calculate the learning rate according to the [linear scaling rule](https://arxiv.org/abs/1706.02677) manually then change `optimizer.lr` in specific config file.
+
+## Training on a single GPU
+
+We provide `tools/train.py` to launch training jobs on a single GPU.
+The basic usage is as follows.
+
+```shell
+python tools/train.py \
+    ${CONFIG_FILE} \
+    [optional arguments]
+```
+
+During training, log files and checkpoints will be saved to the working directory, which is specified by `work_dir` in the config file or via CLI argument `--work-dir`.
+
+By default, the model is evaluated on the validation set every epoch, the evaluation interval can be specified in the config file as shown below.
+
+```python
+# evaluate the model every 12 epochs.
+train_cfg = dict(val_interval=12)
+```
+
+This tool accepts several optional arguments, including:
+
+- `--work-dir ${WORK_DIR}`: Override the working directory.
+- `--resume`: resume from the latest checkpoint in the work_dir automatically.
+- `--resume ${CHECKPOINT_FILE}`: resume from the specific checkpoint.
+- `--cfg-options 'Key=value'`: Overrides other settings in the used config.
+
+**Note:**
+
+There is a difference between `resume` and `load-from`:
+
+`resume` loads both the weights of the model and the state of the optimizer, and it inherits the iteration number from the specified checkpoint, so training does not start again from scratch. `load-from`, on the other hand, only loads the weights of the model, and its training starts from scratch. It is often used for fine-tuning a model. `load-from` needs to be written in the config file, while `resume` is passed as a command line argument.
+
+## Training on CPU
+
+The process of training on the CPU is consistent with single GPU training. We just need to disable GPUs before the training process.
+
+```shell
+export CUDA_VISIBLE_DEVICES=-1
+```
+
+And then run the script [above](#training-on-a-single-GPU).
+
+**Note**:
+
+We do not recommend users to use the CPU for training because it is too slow. We support this feature to allow users to debug on machines without GPU for convenience.
+
+## Training on multiple GPUs
+
+We provide `tools/dist_train.sh` to launch training on multiple GPUs.
+The basic usage is as follows.
+
+```shell
+bash ./tools/dist_train.sh \
+    ${CONFIG_FILE} \
+    ${GPU_NUM} \
+    [optional arguments]
+```
+
+Optional arguments remain the same as stated [above](#training-on-a-single-GPU).
+
+### Launch multiple jobs simultaneously
+
+If you would like to launch multiple jobs on a single machine, e.g., 2 jobs of 4-GPU training on a machine with 8 GPUs,
+you need to specify different ports (29500 by default) for each job to avoid communication conflict.
+
+If you use `dist_train.sh` to launch training jobs, you can set the port in the commands.
+
+```shell
+CUDA_VISIBLE_DEVICES=0,1,2,3 PORT=29500 ./tools/dist_train.sh ${CONFIG_FILE} 4
+CUDA_VISIBLE_DEVICES=4,5,6,7 PORT=29501 ./tools/dist_train.sh ${CONFIG_FILE} 4
+```
+
+## Train with multiple machines
+
+If you launch with multiple machines simply connected with ethernet, you can simply run the following commands:
+
+On the first machine:
+
+```shell
+NNODES=2 NODE_RANK=0 PORT=$MASTER_PORT MASTER_ADDR=$MASTER_ADDR sh tools/dist_train.sh $CONFIG $GPUS
+```
+
+On the second machine:
+
+```shell
+NNODES=2 NODE_RANK=1 PORT=$MASTER_PORT MASTER_ADDR=$MASTER_ADDR sh tools/dist_train.sh $CONFIG $GPUS
+```
+
+Usually, it is slow if you do not have high-speed networking like InfiniBand.
+
+## Manage jobs with Slurm
+
+[Slurm](https://slurm.schedmd.com/) is a good job scheduling system for computing clusters.
+On a cluster managed by Slurm, you can use `slurm_train.sh` to spawn training jobs. It supports both single-node and multi-node training.
+
+The basic usage is as follows.
+
+```shell
+[GPUS=${GPUS}] ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} ${CONFIG_FILE} ${WORK_DIR}
+```
+
+Below is an example of using 16 GPUs to train Mask R-CNN on a Slurm partition named _dev_, and set the work-dir to some shared file systems.
+
+```shell
+GPUS=16 ./tools/slurm_train.sh dev mask_r50_1x configs/mask-rcnn_r50_fpn_1x_coco.py /nfs/xxxx/mask_rcnn_r50_fpn_1x
+```
+
+You can check [the source code](../../../tools/slurm_train.sh) to review full arguments and environment variables.
+
+When using Slurm, the port option needs to be set in one of the following ways:
+
+1. Set the port through `--options`. This is more recommended since it does not change the original configs.
+
+   ```shell
+   CUDA_VISIBLE_DEVICES=0,1,2,3 GPUS=4 ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config1.py ${WORK_DIR} --cfg-options 'dist_params.port=29500'
+   CUDA_VISIBLE_DEVICES=4,5,6,7 GPUS=4 ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config2.py ${WORK_DIR} --cfg-options 'dist_params.port=29501'
+   ```
+
+2. Modify the config files to set different communication ports.
+
+   In `config1.py`, set
+
+   ```python
+   dist_params = dict(backend='nccl', port=29500)
+   ```
+
+   In `config2.py`, set
+
+   ```python
+   dist_params = dict(backend='nccl', port=29501)
+   ```
+
+   Then you can launch two jobs with `config1.py` and `config2.py`.
+
+   ```shell
+   CUDA_VISIBLE_DEVICES=0,1,2,3 GPUS=4 ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config1.py ${WORK_DIR}
+   CUDA_VISIBLE_DEVICES=4,5,6,7 GPUS=4 ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config2.py ${WORK_DIR}
+   ```
+
+# Train with customized datasets
+
+In this part, you will know how to train predefined models with customized datasets and then test it. We use the [balloon dataset](https://github.com/matterport/Mask_RCNN/tree/master/samples/balloon) as an example to describe the whole process.
+
+The basic steps are as below:
+
+1. Prepare the customized dataset
+2. Prepare a config
+3. Train, test, and infer models on the customized dataset.
+
+## Prepare the customized dataset
+
+There are three ways to support a new dataset in MMDetection:
+
+1. Reorganize the dataset into COCO format.
+2. Reorganize the dataset into a middle format.
+3. Implement a new dataset.
+
+Usually, we recommend using the first two methods which are usually easier than the third.
+
+In this note, we give an example of converting the data into COCO format.
+
+**Note**: Datasets and metrics have been decoupled except CityScapes since MMDetection 3.0. Therefore, users can use any kind of evaluation metrics for any format of datasets during validation. For example: evaluate on COCO dataset with VOC metric, or evaluate on OpenImages dataset with both VOC and COCO metrics.
+
+### COCO annotation format
+
+The necessary keys of COCO format for instance segmentation are as below, for the complete details, please refer [here](https://cocodataset.org/#format-data).
+
+```json
+{
+    "images": [image],
+    "annotations": [annotation],
+    "categories": [category]
+}
+
+image = {
+    "id": int,
+    "width": int,
+    "height": int,
+    "file_name": str,
+}
+
+annotation = {
+    "id": int,
+    "image_id": int,
+    "category_id": int,
+    "segmentation": RLE or [polygon],
+    "area": float,
+    "bbox": [x,y,width,height], # (x, y) are the coordinates of the upper left corner of the bbox
+    "iscrowd": 0 or 1,
+}
+
+categories = [{
+    "id": int,
+    "name": str,
+    "supercategory": str,
+}]
+```
+
+Assume we use the balloon dataset.
+After downloading the data, we need to implement a function to convert the annotation format into the COCO format. Then we can use implemented `CocoDataset` to load the data and perform training and evaluation.
+
+If you take a look at the dataset, you will find the dataset format is as below:
+
+```json
+{'base64_img_data': '',
+ 'file_attributes': {},
+ 'filename': '34020010494_e5cb88e1c4_k.jpg',
+ 'fileref': '',
+ 'regions': {'0': {'region_attributes': {},
+   'shape_attributes': {'all_points_x': [1020,
+     1000,
+     994,
+     1003,
+     1023,
+     1050,
+     1089,
+     1134,
+     1190,
+     1265,
+     1321,
+     1361,
+     1403,
+     1428,
+     1442,
+     1445,
+     1441,
+     1427,
+     1400,
+     1361,
+     1316,
+     1269,
+     1228,
+     1198,
+     1207,
+     1210,
+     1190,
+     1177,
+     1172,
+     1174,
+     1170,
+     1153,
+     1127,
+     1104,
+     1061,
+     1032,
+     1020],
+    'all_points_y': [963,
+     899,
+     841,
+     787,
+     738,
+     700,
+     663,
+     638,
+     621,
+     619,
+     643,
+     672,
+     720,
+     765,
+     800,
+     860,
+     896,
+     942,
+     990,
+     1035,
+     1079,
+     1112,
+     1129,
+     1134,
+     1144,
+     1153,
+     1166,
+     1166,
+     1150,
+     1136,
+     1129,
+     1122,
+     1112,
+     1084,
+     1037,
+     989,
+     963],
+    'name': 'polygon'}}},
+ 'size': 1115004}
+```
+
+The annotation is a JSON file where each key indicates an image's all annotations.
+The code to convert the balloon dataset into coco format is as below.
+
+```python
+import os.path as osp
+
+import mmcv
+
+from mmengine.fileio import dump, load
+from mmengine.utils import track_iter_progress
+
+
+def convert_balloon_to_coco(ann_file, out_file, image_prefix):
+    data_infos = load(ann_file)
+
+    annotations = []
+    images = []
+    obj_count = 0
+    for idx, v in enumerate(track_iter_progress(data_infos.values())):
+        filename = v['filename']
+        img_path = osp.join(image_prefix, filename)
+        height, width = mmcv.imread(img_path).shape[:2]
+
+        images.append(
+            dict(id=idx, file_name=filename, height=height, width=width))
+
+        for _, obj in v['regions'].items():
+            assert not obj['region_attributes']
+            obj = obj['shape_attributes']
+            px = obj['all_points_x']
+            py = obj['all_points_y']
+            poly = [(x + 0.5, y + 0.5) for x, y in zip(px, py)]
+            poly = [p for x in poly for p in x]
+
+            x_min, y_min, x_max, y_max = (min(px), min(py), max(px), max(py))
+
+            data_anno = dict(
+                image_id=idx,
+                id=obj_count,
+                category_id=0,
+                bbox=[x_min, y_min, x_max - x_min, y_max - y_min],
+                area=(x_max - x_min) * (y_max - y_min),
+                segmentation=[poly],
+                iscrowd=0)
+            annotations.append(data_anno)
+            obj_count += 1
+
+    coco_format_json = dict(
+        images=images,
+        annotations=annotations,
+        categories=[{
+            'id': 0,
+            'name': 'balloon'
+        }])
+    dump(coco_format_json, out_file)
+
+
+if __name__ == '__main__':
+    convert_balloon_to_coco(ann_file='data/balloon/train/via_region_data.json',
+                            out_file='data/balloon/train/annotation_coco.json',
+                            image_prefix='data/balloon/train')
+    convert_balloon_to_coco(ann_file='data/balloon/val/via_region_data.json',
+                            out_file='data/balloon/val/annotation_coco.json',
+                            image_prefix='data/balloon/val')
+
+```
+
+Using the function above, users can successfully convert the annotation file into json format, then we can use `CocoDataset` to train and evaluate the model with `CocoMetric`.
+
+## Prepare a config
+
+The second step is to prepare a config thus the dataset could be successfully loaded. Assume that we want to use Mask R-CNN with FPN, the config to train the detector on balloon dataset is as below. Assume the config is under directory `configs/balloon/` and named as `mask-rcnn_r50-caffe_fpn_ms-poly-1x_balloon.py`, the config is as below. Please refer [Learn about Configs - MMDetection 3.0.0 documentation](https://mmdetection.readthedocs.io/en/latest/user_guides/config.html) to get detailed information about config files.
+
+```python
+# The new config inherits a base config to highlight the necessary modification
+_base_ = '../mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco.py'
+
+# We also need to change the num_classes in head to match the dataset's annotation
+model = dict(
+    roi_head=dict(
+        bbox_head=dict(num_classes=1), mask_head=dict(num_classes=1)))
+
+# Modify dataset related settings
+data_root = 'data/balloon/'
+metainfo = {
+    'classes': ('balloon', ),
+    'palette': [
+        (220, 20, 60),
+    ]
+}
+train_dataloader = dict(
+    batch_size=1,
+    dataset=dict(
+        data_root=data_root,
+        metainfo=metainfo,
+        ann_file='train/annotation_coco.json',
+        data_prefix=dict(img='train/')))
+val_dataloader = dict(
+    dataset=dict(
+        data_root=data_root,
+        metainfo=metainfo,
+        ann_file='val/annotation_coco.json',
+        data_prefix=dict(img='val/')))
+test_dataloader = val_dataloader
+
+# Modify metric related settings
+val_evaluator = dict(ann_file=data_root + 'val/annotation_coco.json')
+test_evaluator = val_evaluator
+
+# We can use the pre-trained Mask RCNN model to obtain higher performance
+load_from = 'https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth'
+
+```
+
+## Train a new model
+
+To train a model with the new config, you can simply run
+
+```shell
+python tools/train.py configs/balloon/mask-rcnn_r50-caffe_fpn_ms-poly-1x_balloon.py
+```
+
+For more detailed usages, please refer to the [training guide](https://mmdetection.readthedocs.io/en/latest/user_guides/train.html#train-predefined-models-on-standard-datasets).
+
+## Test and inference
+
+To test the trained model, you can simply run
+
+```shell
+python tools/test.py configs/balloon/mask-rcnn_r50-caffe_fpn_ms-poly-1x_balloon.py work_dirs/mask-rcnn_r50-caffe_fpn_ms-poly-1x_balloon/epoch_12.pth
+```
+
+For more detailed usages, please refer to the [testing guide](https://mmdetection.readthedocs.io/en/latest/user_guides/test.html).
diff --git a/mmdetection/docs/en/user_guides/useful_hooks.md b/mmdetection/docs/en/user_guides/useful_hooks.md
new file mode 100644
index 00000000..4c30686d
--- /dev/null
+++ b/mmdetection/docs/en/user_guides/useful_hooks.md
@@ -0,0 +1,105 @@
+# Useful Hooks
+
+MMDetection and MMEngine provide users with various useful hooks including log hooks, `NumClassCheckHook`, etc. This tutorial introduces the functionalities and usages of hooks implemented in MMDetection. For using hooks in MMEngine, please read the [API documentation in MMEngine](https://github.com/open-mmlab/mmengine/tree/main/docs/en/tutorials/hook.md).
+
+## CheckInvalidLossHook
+
+## NumClassCheckHook
+
+## MemoryProfilerHook
+
+[Memory profiler hook](https://github.com/open-mmlab/mmdetection/blob/main/mmdet/engine/hooks/memory_profiler_hook.py) records memory information including virtual memory, swap memory, and the memory of the current process. This hook helps grasp the memory usage of the system and discover potential memory leak bugs. To use this hook, users should install `memory_profiler` and `psutil` by `pip install memory_profiler psutil` first.
+
+### Usage
+
+To use this hook, users should add the following code to the config file.
+
+```python
+custom_hooks = [
+    dict(type='MemoryProfilerHook', interval=50)
+]
+```
+
+### Result
+
+During training, you can see the messages in the log recorded by `MemoryProfilerHook` as below.
+
+```text
+The system has 250 GB (246360 MB + 9407 MB) of memory and 8 GB (5740 MB + 2452 MB) of swap memory in total. Currently 9407 MB (4.4%) of memory and 5740 MB (29.9%) of swap memory were consumed. And the current training process consumed 5434 MB of memory.
+```
+
+```text
+2022-04-21 08:49:56,881 - mmengine - INFO - Memory information available_memory: 246360 MB, used_memory: 9407 MB, memory_utilization: 4.4 %, available_swap_memory: 5740 MB, used_swap_memory: 2452 MB, swap_memory_utilization: 29.9 %, current_process_memory: 5434 MB
+```
+
+## SetEpochInfoHook
+
+## SyncNormHook
+
+## SyncRandomSizeHook
+
+## YOLOXLrUpdaterHook
+
+## YOLOXModeSwitchHook
+
+## How to implement a custom hook
+
+In general, there are 20 points where hooks can be inserted from the beginning to the end of model training. The users can implement custom hooks and insert them at different points in the process of training to do what they want.
+
+- global points: `before_run`, `after_run`
+- points in training: `before_train`, `before_train_epoch`, `before_train_iter`, `after_train_iter`, `after_train_epoch`, `after_train`
+- points in validation: `before_val`, `before_val_epoch`, `before_val_iter`, `after_val_iter`, `after_val_epoch`, `after_val`
+- points at testing: `before_test`, `before_test_epoch`, `before_test_iter`, `after_test_iter`, `after_test_epoch`,  `after_test`
+- other points: `before_save_checkpoint`, `after_save_checkpoint`
+
+For example, users can implement a hook to check loss and terminate training when loss goes NaN. To achieve that, there are three steps to go:
+
+1. Implement a new hook that inherits the `Hook` class in MMEngine, and implement `after_train_iter` method which checks whether loss goes NaN after every `n` training iterations.
+2. The implemented hook should be registered in `HOOKS` by `@HOOKS.register_module()` as shown in the code below.
+3. Add `custom_hooks = [dict(type='MemoryProfilerHook', interval=50)]` in the config file.
+
+```python
+from typing import Optional
+
+import torch
+from mmengine.hooks import Hook
+from mmengine.runner import Runner
+
+from mmdet.registry import HOOKS
+
+
+@HOOKS.register_module()
+class CheckInvalidLossHook(Hook):
+    """Check invalid loss hook.
+
+    This hook will regularly check whether the loss is valid
+    during training.
+
+    Args:
+        interval (int): Checking interval (every k iterations).
+            Default: 50.
+    """
+
+    def __init__(self, interval: int = 50) -> None:
+        self.interval = interval
+
+    def after_train_iter(self,
+                         runner: Runner,
+                         batch_idx: int,
+                         data_batch: Optional[dict] = None,
+                         outputs: Optional[dict] = None) -> None:
+        """Regularly check whether the loss is valid every n iterations.
+
+        Args:
+            runner (:obj:`Runner`): The runner of the training process.
+            batch_idx (int): The index of the current batch in the train loop.
+            data_batch (dict, Optional): Data from dataloader.
+                Defaults to None.
+            outputs (dict, Optional): Outputs from model. Defaults to None.
+        """
+        if self.every_n_train_iters(runner, self.interval):
+            assert torch.isfinite(outputs['loss']), \
+                runner.logger.info('loss become infinite or NaN!')
+```
+
+Please read [customize_runtime](../advanced_guides/customize_runtime.md) for more about implementing a custom hook.
diff --git a/mmdetection/docs/en/user_guides/useful_tools.md b/mmdetection/docs/en/user_guides/useful_tools.md
new file mode 100644
index 00000000..8a79f0c2
--- /dev/null
+++ b/mmdetection/docs/en/user_guides/useful_tools.md
@@ -0,0 +1,660 @@
+Apart from training/testing scripts, We provide lots of useful tools under the
+`tools/` directory.
+
+## Log Analysis
+
+`tools/analysis_tools/analyze_logs.py` plots loss/mAP curves given a training
+log file. Run `pip install seaborn` first to install the dependency.
+
+```shell
+python tools/analysis_tools/analyze_logs.py plot_curve [--keys ${KEYS}] [--eval-interval ${EVALUATION_INTERVAL}] [--title ${TITLE}] [--legend ${LEGEND}] [--backend ${BACKEND}] [--style ${STYLE}] [--out ${OUT_FILE}]
+```
+
+![loss curve image](../../../resources/loss_curve.png)
+
+Examples:
+
+- Plot the classification loss of some run.
+
+  ```shell
+  python tools/analysis_tools/analyze_logs.py plot_curve log.json --keys loss_cls --legend loss_cls
+  ```
+
+- Plot the classification and regression loss of some run, and save the figure to a pdf.
+
+  ```shell
+  python tools/analysis_tools/analyze_logs.py plot_curve log.json --keys loss_cls loss_bbox --out losses.pdf
+  ```
+
+- Compare the bbox mAP of two runs in the same figure.
+
+  ```shell
+  python tools/analysis_tools/analyze_logs.py plot_curve log1.json log2.json --keys bbox_mAP --legend run1 run2
+  ```
+
+- Compute the average training speed.
+
+  ```shell
+  python tools/analysis_tools/analyze_logs.py cal_train_time log.json [--include-outliers]
+  ```
+
+  The output is expected to be like the following.
+
+  ```text
+  -----Analyze train time of work_dirs/some_exp/20190611_192040.log.json-----
+  slowest epoch 11, average time is 1.2024
+  fastest epoch 1, average time is 1.1909
+  time std over epochs is 0.0028
+  average iter time: 1.1959 s/iter
+  ```
+
+## Result Analysis
+
+`tools/analysis_tools/analyze_results.py` calculates single image mAP and saves or shows the topk images with the highest and lowest scores based on prediction results.
+
+**Usage**
+
+```shell
+python tools/analysis_tools/analyze_results.py \
+      ${CONFIG} \
+      ${PREDICTION_PATH} \
+      ${SHOW_DIR} \
+      [--show] \
+      [--wait-time ${WAIT_TIME}] \
+      [--topk ${TOPK}] \
+      [--show-score-thr ${SHOW_SCORE_THR}] \
+      [--cfg-options ${CFG_OPTIONS}]
+```
+
+Description of all arguments:
+
+- `config` : The path of a model config file.
+- `prediction_path`:  Output result file in pickle format from `tools/test.py`
+- `show_dir`: Directory where painted GT and detection images will be saved
+- `--show`: Determines whether to show painted images, If not specified, it will be set to `False`
+- `--wait-time`: The interval of show (s), 0 is block
+- `--topk`: The number of saved images that have the highest and lowest `topk` scores after sorting. If not specified, it will be set to `20`.
+- `--show-score-thr`:  Show score threshold. If not specified, it will be set to `0`.
+- `--cfg-options`: If specified, the key-value pair optional cfg will be merged into config file
+
+**Examples**:
+
+Assume that you have got result file in pickle format from `tools/test.py`  in the path './result.pkl'.
+
+1. Test Faster R-CNN and visualize the results, save images to the directory `results/`
+
+```shell
+python tools/analysis_tools/analyze_results.py \
+       configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py \
+       result.pkl \
+       results \
+       --show
+```
+
+2. Test Faster R-CNN and specified topk to 50, save images to the directory `results/`
+
+```shell
+python tools/analysis_tools/analyze_results.py \
+       configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py \
+       result.pkl \
+       results \
+       --topk 50
+```
+
+3. If you want to filter the low score prediction results, you can specify the `show-score-thr` parameter
+
+```shell
+python tools/analysis_tools/analyze_results.py \
+       configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py \
+       result.pkl \
+       results \
+       --show-score-thr 0.3
+```
+
+## Fusing results from multiple models
+
+`tools/analysis_tools/fusion_results.py` can fusing predictions using Weighted Boxes Fusion(WBF) from different object detection models. (Currently support coco format only)
+
+**Usage**
+
+```shell
+python tools/analysis_tools/fuse_results.py \
+       ${PRED_RESULTS} \
+       [--annotation ${ANNOTATION}] \
+       [--weights ${WEIGHTS}] \
+       [--fusion-iou-thr ${FUSION_IOU_THR}] \
+       [--skip-box-thr ${SKIP_BOX_THR}] \
+       [--conf-type ${CONF_TYPE}] \
+       [--eval-single ${EVAL_SINGLE}] \
+       [--save-fusion-results ${SAVE_FUSION_RESULTS}] \
+       [--out-dir ${OUT_DIR}]
+```
+
+Description of all arguments:
+
+- `pred-results`: Paths of detection results from different models.(Currently support coco format only)
+- `--annotation`: Path of ground-truth.
+- `--weights`: List of weights for each model. Default: `None`, which means weight == 1 for each model.
+- `--fusion-iou-thr`: IoU value for boxes to be a match。Default: `0.55`。
+- `--skip-box-thr`: The confidence threshold that needs to be excluded in the WBF algorithm. bboxes whose confidence is less than this value will be excluded.。Default: `0`。
+- `--conf-type`: How to calculate confidence in weighted boxes.
+  - `avg`: average value，default.
+  - `max`: maximum value.
+  - `box_and_model_avg`: box and model wise hybrid weighted average.
+  - `absent_model_aware_avg`: weighted average that takes into account the absent model.
+- `--eval-single`: Whether evaluate every single model. Default: `False`.
+- `--save-fusion-results`: Whether save fusion results. Default: `False`.
+- `--out-dir`: Path of fusion results.
+
+**Examples**:
+Assume that you have got 3 result files from corresponding models through `tools/test.py`, which paths are './faster-rcnn_r50-caffe_fpn_1x_coco.json', './retinanet_r50-caffe_fpn_1x_coco.json', './cascade-rcnn_r50-caffe_fpn_1x_coco.json' respectively. The ground-truth file path is './annotation.json'.
+
+1. Fusion of predictions from three models and evaluation of their effectiveness
+
+```shell
+python tools/analysis_tools/fuse_results.py \
+       ./faster-rcnn_r50-caffe_fpn_1x_coco.json \
+       ./retinanet_r50-caffe_fpn_1x_coco.json \
+       ./cascade-rcnn_r50-caffe_fpn_1x_coco.json \
+       --annotation ./annotation.json \
+       --weights 1 2 3 \
+```
+
+2. Simultaneously evaluate each single model and fusion results
+
+```shell
+python tools/analysis_tools/fuse_results.py \
+       ./faster-rcnn_r50-caffe_fpn_1x_coco.json \
+       ./retinanet_r50-caffe_fpn_1x_coco.json \
+       ./cascade-rcnn_r50-caffe_fpn_1x_coco.json \
+       --annotation ./annotation.json \
+       --weights 1 2 3 \
+       --eval-single
+```
+
+3. Fusion of prediction results from three models and save
+
+```shell
+python tools/analysis_tools/fuse_results.py \
+       ./faster-rcnn_r50-caffe_fpn_1x_coco.json \
+       ./retinanet_r50-caffe_fpn_1x_coco.json \
+       ./cascade-rcnn_r50-caffe_fpn_1x_coco.json \
+       --annotation ./annotation.json \
+       --weights 1 2 3 \
+       --save-fusion-results \
+       --out-dir outputs/fusion
+```
+
+## Visualization
+
+### Visualize Datasets
+
+`tools/analysis_tools/browse_dataset.py` helps the user to browse a detection dataset (both
+images and bounding box annotations) visually, or save the image to a
+designated directory.
+
+```shell
+python tools/analysis_tools/browse_dataset.py ${CONFIG} [-h] [--skip-type ${SKIP_TYPE[SKIP_TYPE...]}] [--output-dir ${OUTPUT_DIR}] [--not-show] [--show-interval ${SHOW_INTERVAL}]
+```
+
+### Visualize Models
+
+First, convert the model to ONNX as described
+[here](#convert-mmdetection-model-to-onnx-experimental).
+Note that currently only RetinaNet is supported, support for other models
+will be coming in later versions.
+The converted model could be visualized by tools like [Netron](https://github.com/lutzroeder/netron).
+
+### Visualize Predictions
+
+If you need a lightweight GUI for visualizing the detection results, you can refer [DetVisGUI project](https://github.com/Chien-Hung/DetVisGUI/tree/mmdetection).
+
+## Error Analysis
+
+`tools/analysis_tools/coco_error_analysis.py` analyzes COCO results per category and by
+different criterion. It can also make a plot to provide useful information.
+
+```shell
+python tools/analysis_tools/coco_error_analysis.py ${RESULT} ${OUT_DIR} [-h] [--ann ${ANN}] [--types ${TYPES[TYPES...]}]
+```
+
+Example:
+
+Assume that you have got [Mask R-CNN checkpoint file](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_fpn_1x_coco/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth) in the path 'checkpoint'. For other checkpoints, please refer to our [model zoo](./model_zoo.md).
+
+You can modify the test_evaluator to save the results bbox by:
+
+1. Find which dataset in 'configs/base/datasets' the current config corresponds to.
+2. Replace the original test_evaluator and test_dataloader with test_evaluator and test_dataloader in the comment in dataset config.
+3. Use the following command to get the results bbox and segmentation json file.
+
+```shell
+python tools/test.py \
+       configs/mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py \
+       checkpoint/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth \
+```
+
+1. Get COCO bbox error results per category , save analyze result images to the directory(In  [config](../../../configs/_base_/datasets/coco_instance.py) the default directory is './work_dirs/coco_instance/test')
+
+```shell
+python tools/analysis_tools/coco_error_analysis.py \
+       results.bbox.json \
+       results \
+       --ann=data/coco/annotations/instances_val2017.json \
+```
+
+2. Get COCO segmentation error results per category , save analyze result images to the directory
+
+```shell
+python tools/analysis_tools/coco_error_analysis.py \
+       results.segm.json \
+       results \
+       --ann=data/coco/annotations/instances_val2017.json \
+       --types='segm'
+```
+
+## Model Serving
+
+In order to serve an `MMDetection` model with [`TorchServe`](https://pytorch.org/serve/), you can follow the steps:
+
+### 1. Install TorchServe
+
+Suppose you have a `Python` environment with `PyTorch` and `MMDetection` successfully installed,
+then you could run the following command to install `TorchServe` and its dependencies.
+For more other installation options, please refer to the [quick start](https://github.com/pytorch/serve/blob/master/README.md#serve-a-model).
+
+```shell
+python -m pip install torchserve torch-model-archiver torch-workflow-archiver nvgpu
+```
+
+**Note**: Please refer to [torchserve docker](https://github.com/pytorch/serve/blob/master/docker/README.md) if you want to use `TorchServe` in docker.
+
+### 2. Convert model from MMDetection to TorchServe
+
+```shell
+python tools/deployment/mmdet2torchserve.py ${CONFIG_FILE} ${CHECKPOINT_FILE} \
+--output-folder ${MODEL_STORE} \
+--model-name ${MODEL_NAME}
+```
+
+### 3. Start `TorchServe`
+
+```shell
+torchserve --start --ncs \
+  --model-store ${MODEL_STORE} \
+  --models  ${MODEL_NAME}.mar
+```
+
+### 4. Test deployment
+
+```shell
+curl -O curl -O https://raw.githubusercontent.com/pytorch/serve/master/docs/images/3dogs.jpg
+curl http://127.0.0.1:8080/predictions/${MODEL_NAME} -T 3dogs.jpg
+```
+
+You should obtain a response similar to:
+
+```json
+[
+  {
+    "class_label": 16,
+    "class_name": "dog",
+    "bbox": [
+      294.63409423828125,
+      203.99111938476562,
+      417.048583984375,
+      281.62744140625
+    ],
+    "score": 0.9987992644309998
+  },
+  {
+    "class_label": 16,
+    "class_name": "dog",
+    "bbox": [
+      404.26019287109375,
+      126.0080795288086,
+      574.5091552734375,
+      293.6662292480469
+    ],
+    "score": 0.9979367256164551
+  },
+  {
+    "class_label": 16,
+    "class_name": "dog",
+    "bbox": [
+      197.2144775390625,
+      93.3067855834961,
+      307.8505554199219,
+      276.7560119628906
+    ],
+    "score": 0.993338406085968
+  }
+]
+```
+
+#### Compare results
+
+And you can use `test_torchserver.py` to compare result of `TorchServe` and `PyTorch`, and visualize them.
+
+```shell
+python tools/deployment/test_torchserver.py ${IMAGE_FILE} ${CONFIG_FILE} ${CHECKPOINT_FILE} ${MODEL_NAME}
+[--inference-addr ${INFERENCE_ADDR}] [--device ${DEVICE}] [--score-thr ${SCORE_THR}] [--work-dir ${WORK_DIR}]
+```
+
+Example:
+
+```shell
+python tools/deployment/test_torchserver.py \
+demo/demo.jpg \
+configs/yolo/yolov3_d53_8xb8-320-273e_coco.py \
+checkpoint/yolov3_d53_320_273e_coco-421362b6.pth \
+yolov3 \
+--work-dir ./work-dir
+```
+
+### 5. Stop `TorchServe`
+
+```shell
+torchserve --stop
+```
+
+## Model Complexity
+
+`tools/analysis_tools/get_flops.py` is a script adapted from [flops-counter.pytorch](https://github.com/sovrasov/flops-counter.pytorch) to compute the FLOPs and params of a given model.
+
+```shell
+python tools/analysis_tools/get_flops.py ${CONFIG_FILE} [--shape ${INPUT_SHAPE}]
+```
+
+You will get the results like this.
+
+```text
+==============================
+Input shape: (3, 1280, 800)
+Flops: 239.32 GFLOPs
+Params: 37.74 M
+==============================
+```
+
+**Note**: This tool is still experimental and we do not guarantee that the
+number is absolutely correct. You may well use the result for simple
+comparisons, but double check it before you adopt it in technical reports or papers.
+
+1. FLOPs are related to the input shape while parameters are not. The default
+   input shape is (1, 3, 1280, 800).
+2. Some operators are not counted into FLOPs like GN and custom operators. Refer to [`mmcv.cnn.get_model_complexity_info()`](https://github.com/open-mmlab/mmcv/blob/2.x/mmcv/cnn/utils/flops_counter.py) for details.
+3. The FLOPs of two-stage detectors is dependent on the number of proposals.
+
+## Model conversion
+
+### MMDetection model to ONNX
+
+We provide a script to convert model to [ONNX](https://github.com/onnx/onnx) format. We also support comparing the output results between Pytorch and ONNX model for verification. More details can refer to [mmdeploy](https://github.com/open-mmlab/mmdeploy)
+
+### MMDetection 1.x model to MMDetection 2.x
+
+`tools/model_converters/upgrade_model_version.py` upgrades a previous MMDetection checkpoint
+to the new version. Note that this script is not guaranteed to work as some
+breaking changes are introduced in the new version. It is recommended to
+directly use the new checkpoints.
+
+```shell
+python tools/model_converters/upgrade_model_version.py ${IN_FILE} ${OUT_FILE} [-h] [--num-classes NUM_CLASSES]
+```
+
+### RegNet model to MMDetection
+
+`tools/model_converters/regnet2mmdet.py` convert keys in pycls pretrained RegNet models to
+MMDetection style.
+
+```shell
+python tools/model_converters/regnet2mmdet.py ${SRC} ${DST} [-h]
+```
+
+### Detectron ResNet to Pytorch
+
+`tools/model_converters/detectron2pytorch.py` converts keys in the original detectron pretrained
+ResNet models to PyTorch style.
+
+```shell
+python tools/model_converters/detectron2pytorch.py ${SRC} ${DST} ${DEPTH} [-h]
+```
+
+### Prepare a model for publishing
+
+`tools/model_converters/publish_model.py` helps users to prepare their model for publishing.
+
+Before you upload a model to AWS, you may want to
+
+1. convert model weights to CPU tensors
+2. delete the optimizer states and
+3. compute the hash of the checkpoint file and append the hash id to the
+   filename.
+
+```shell
+python tools/model_converters/publish_model.py ${INPUT_FILENAME} ${OUTPUT_FILENAME}
+```
+
+E.g.,
+
+```shell
+python tools/model_converters/publish_model.py work_dirs/faster_rcnn/latest.pth faster_rcnn_r50_fpn_1x_20190801.pth
+```
+
+The final output filename will be `faster_rcnn_r50_fpn_1x_20190801-{hash id}.pth`.
+
+## Dataset Conversion
+
+`tools/data_converters/` contains tools to convert the Cityscapes dataset
+and Pascal VOC dataset to the COCO format.
+
+```shell
+python tools/dataset_converters/cityscapes.py ${CITYSCAPES_PATH} [-h] [--img-dir ${IMG_DIR}] [--gt-dir ${GT_DIR}] [-o ${OUT_DIR}] [--nproc ${NPROC}]
+python tools/dataset_converters/pascal_voc.py ${DEVKIT_PATH} [-h] [-o ${OUT_DIR}]
+```
+
+## Dataset Download
+
+`tools/misc/download_dataset.py` supports downloading datasets such as COCO, VOC, and LVIS.
+
+```shell
+python tools/misc/download_dataset.py --dataset-name coco2017
+python tools/misc/download_dataset.py --dataset-name voc2007
+python tools/misc/download_dataset.py --dataset-name lvis
+```
+
+For users in China, these datasets can also be downloaded from [OpenDataLab](https://opendatalab.com/?source=OpenMMLab%20GitHub) with high speed:
+
+- [COCO2017](https://opendatalab.com/COCO_2017/download?source=OpenMMLab%20GitHub)
+- [VOC2007](https://opendatalab.com/PASCAL_VOC2007/download?source=OpenMMLab%20GitHub)
+- [VOC2012](https://opendatalab.com/PASCAL_VOC2012/download?source=OpenMMLab%20GitHub)
+- [LVIS](https://opendatalab.com/LVIS/download?source=OpenMMLab%20GitHub)
+
+## Benchmark
+
+### Robust Detection Benchmark
+
+`tools/analysis_tools/test_robustness.py` and`tools/analysis_tools/robustness_eval.py`  helps users to evaluate model robustness. The core idea comes from [Benchmarking Robustness in Object Detection: Autonomous Driving when Winter is Coming](https://arxiv.org/abs/1907.07484). For more information how to evaluate models on corrupted images and results for a set of standard models please refer to [robustness_benchmarking.md](robustness_benchmarking.md).
+
+### FPS Benchmark
+
+`tools/analysis_tools/benchmark.py` helps users to calculate FPS. The FPS value includes model forward and post-processing. In order to get a more accurate value, currently only supports single GPU distributed startup mode.
+
+```shell
+python -m torch.distributed.launch --nproc_per_node=1 --master_port=${PORT} tools/analysis_tools/benchmark.py \
+    ${CONFIG} \
+    [--checkpoint ${CHECKPOINT}] \
+    [--repeat-num ${REPEAT_NUM}] \
+    [--max-iter ${MAX_ITER}] \
+    [--log-interval ${LOG_INTERVAL}] \
+    --launcher pytorch
+```
+
+Examples: Assuming that you have already downloaded the `Faster R-CNN` model checkpoint to the directory `checkpoints/`.
+
+```shell
+python -m torch.distributed.launch --nproc_per_node=1 --master_port=29500 tools/analysis_tools/benchmark.py \
+       configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py \
+       checkpoints/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth \
+       --launcher pytorch
+```
+
+## Miscellaneous
+
+### Evaluating a metric
+
+`tools/analysis_tools/eval_metric.py` evaluates certain metrics of a pkl result file
+according to a config file.
+
+```shell
+python tools/analysis_tools/eval_metric.py ${CONFIG} ${PKL_RESULTS} [-h] [--format-only] [--eval ${EVAL[EVAL ...]}]
+                      [--cfg-options ${CFG_OPTIONS [CFG_OPTIONS ...]}]
+                      [--eval-options ${EVAL_OPTIONS [EVAL_OPTIONS ...]}]
+```
+
+### Print the entire config
+
+`tools/misc/print_config.py` prints the whole config verbatim, expanding all its
+imports.
+
+```shell
+python tools/misc/print_config.py ${CONFIG} [-h] [--options ${OPTIONS [OPTIONS...]}]
+```
+
+## Hyper-parameter Optimization
+
+### YOLO Anchor Optimization
+
+`tools/analysis_tools/optimize_anchors.py` provides two method to optimize YOLO anchors.
+
+One is k-means anchor cluster which refers from [darknet](https://github.com/AlexeyAB/darknet/blob/master/src/detector.c#L1421).
+
+```shell
+python tools/analysis_tools/optimize_anchors.py ${CONFIG} --algorithm k-means --input-shape ${INPUT_SHAPE [WIDTH HEIGHT]} --output-dir ${OUTPUT_DIR}
+```
+
+Another is using differential evolution to optimize anchors.
+
+```shell
+python tools/analysis_tools/optimize_anchors.py ${CONFIG} --algorithm differential_evolution --input-shape ${INPUT_SHAPE [WIDTH HEIGHT]} --output-dir ${OUTPUT_DIR}
+```
+
+E.g.,
+
+```shell
+python tools/analysis_tools/optimize_anchors.py configs/yolo/yolov3_d53_8xb8-320-273e_coco.py --algorithm differential_evolution --input-shape 608 608 --device cuda --output-dir work_dirs
+```
+
+You will get:
+
+```
+loading annotations into memory...
+Done (t=9.70s)
+creating index...
+index created!
+2021-07-19 19:37:20,951 - mmdet - INFO - Collecting bboxes from annotation...
+[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 117266/117266, 15874.5 task/s, elapsed: 7s, ETA:     0s
+
+2021-07-19 19:37:28,753 - mmdet - INFO - Collected 849902 bboxes.
+differential_evolution step 1: f(x)= 0.506055
+differential_evolution step 2: f(x)= 0.506055
+......
+
+differential_evolution step 489: f(x)= 0.386625
+2021-07-19 19:46:40,775 - mmdet - INFO Anchor evolution finish. Average IOU: 0.6133754253387451
+2021-07-19 19:46:40,776 - mmdet - INFO Anchor differential evolution result:[[10, 12], [15, 30], [32, 22], [29, 59], [61, 46], [57, 116], [112, 89], [154, 198], [349, 336]]
+2021-07-19 19:46:40,798 - mmdet - INFO Result saved in work_dirs/anchor_optimize_result.json
+```
+
+## Confusion Matrix
+
+A confusion matrix is a summary of prediction results.
+
+`tools/analysis_tools/confusion_matrix.py` can analyze the prediction results and plot a confusion matrix table.
+
+First, run `tools/test.py` to save the `.pkl` detection results.
+
+Then, run
+
+```
+python tools/analysis_tools/confusion_matrix.py ${CONFIG}  ${DETECTION_RESULTS}  ${SAVE_DIR} --show
+```
+
+And you will get a confusion matrix like this:
+
+![confusion_matrix_example](https://user-images.githubusercontent.com/12907710/140513068-994cdbf4-3a4a-48f0-8fd8-2830d93fd963.png)
+
+## COCO Separated & Occluded Mask Metric
+
+Detecting occluded objects still remains a challenge for state-of-the-art object detectors.
+We implemented the metric presented in paper [A Tri-Layer Plugin to Improve Occluded Detection](https://arxiv.org/abs/2210.10046) to calculate the recall of separated and occluded masks.
+
+There are two ways to use this metric:
+
+### Offline evaluation
+
+We provide a script to calculate the metric with a dumped prediction file.
+
+First, use the `tools/test.py` script to dump the detection results:
+
+```shell
+python tools/test.py ${CONFIG} ${MODEL_PATH} --out results.pkl
+```
+
+Then, run the `tools/analysis_tools/coco_occluded_separated_recall.py` script to get the recall of separated and occluded masks:
+
+```shell
+python tools/analysis_tools/coco_occluded_separated_recall.py results.pkl --out occluded_separated_recall.json
+```
+
+The output should be like this:
+
+```
+loading annotations into memory...
+Done (t=0.51s)
+creating index...
+index created!
+processing detection results...
+[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 5000/5000, 109.3 task/s, elapsed: 46s, ETA:     0s
+computing occluded mask recall...
+[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 5550/5550, 780.5 task/s, elapsed: 7s, ETA:     0s
+COCO occluded mask recall: 58.79%
+COCO occluded mask success num: 3263
+computing separated mask recall...
+[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 3522/3522, 778.3 task/s, elapsed: 5s, ETA:     0s
+COCO separated mask recall: 31.94%
+COCO separated mask success num: 1125
+
++-----------+--------+-------------+
+| mask type | recall | num correct |
++-----------+--------+-------------+
+| occluded  | 58.79% | 3263        |
+| separated | 31.94% | 1125        |
++-----------+--------+-------------+
+Evaluation results have been saved to occluded_separated_recall.json.
+```
+
+### Online evaluation
+
+We implement `CocoOccludedSeparatedMetric` which inherits from the `CocoMetic`.
+To evaluate the recall of separated and occluded masks during training, just replace the evaluator metric type with `'CocoOccludedSeparatedMetric'` in your config:
+
+```python
+val_evaluator = dict(
+    type='CocoOccludedSeparatedMetric',  # modify this
+    ann_file=data_root + 'annotations/instances_val2017.json',
+    metric=['bbox', 'segm'],
+    format_only=False)
+test_evaluator = val_evaluator
+```
+
+Please cite the paper if you use this metric:
+
+```latex
+@article{zhan2022triocc,
+    title={A Tri-Layer Plugin to Improve Occluded Detection},
+    author={Zhan, Guanqi and Xie, Weidi and Zisserman, Andrew},
+    journal={British Machine Vision Conference},
+    year={2022}
+}
+```
diff --git a/mmdetection/docs/en/user_guides/visualization.md b/mmdetection/docs/en/user_guides/visualization.md
new file mode 100644
index 00000000..dade26ed
--- /dev/null
+++ b/mmdetection/docs/en/user_guides/visualization.md
@@ -0,0 +1,91 @@
+# Visualization
+
+Before reading this tutorial, it is recommended to read MMEngine's [Visualization](https://github.com/open-mmlab/mmengine/blob/main/docs/en/advanced_tutorials/visualization.md) documentation to get a first glimpse of the `Visualizer` definition and usage.
+
+In brief, the [`Visualizer`](mmengine.visualization.Visualizer) is implemented in MMEngine to meet the daily visualization needs, and contains three main functions:
+
+- Implement common drawing APIs, such as [`draw_bboxes`](mmengine.visualization.Visualizer.draw_bboxes) which implements bounding box drawing functions, [`draw_lines`](mmengine.visualization.Visualizer.draw_lines) implements the line drawing function.
+- Support writing visualization results, learning rate curves, loss function curves, and verification accuracy curves to various backends, including local disks and common deep learning training logging tools such as [TensorBoard](https://www.tensorflow.org/tensorboard) and [Wandb](https://wandb.ai/site).
+- Support calling anywhere in the code to visualize or record intermediate states of the model during training or testing, such as feature maps and validation results.
+
+Based on MMEngine's Visualizer, MMDet comes with a variety of pre-built visualization tools that can be used by the user by simply modifying the following configuration files.
+
+- The `tools/analysis_tools/browse_dataset.py` script provides a dataset visualization function that draws images and corresponding annotations after Data Transforms, as described in [`browse_dataset.py`](useful_tools.md#Visualization).
+- MMEngine implements `LoggerHook`, which uses `Visualizer` to write the learning rate, loss and evaluation results to the backend set by `Visualizer`. Therefore, by modifying the `Visualizer` backend in the configuration file, for example to ` TensorBoardVISBackend` or `WandbVISBackend`, you can implement logging to common training logging tools such as `TensorBoard` or `WandB`, thus making it easy for users to use these visualization tools to analyze and monitor the training process.
+- The `VisualizerHook` is implemented in MMDet, which uses the `Visualizer` to visualize or store the prediction results of the validation or prediction phase into the backend set by the `Visualizer`, so by modifying the `Visualizer` backend in the configuration file, for example, to ` TensorBoardVISBackend` or `WandbVISBackend`, you can implement storing the predicted images to `TensorBoard` or `Wandb`.
+
+## Configuration
+
+Thanks to the use of the registration mechanism, in MMDet we can set the behavior of the `Visualizer` by modifying the configuration file. Usually, we define the default configuration for the visualizer in `configs/_base_/default_runtime.py`, see [configuration tutorial](config.md) for details.
+
+```Python
+vis_backends = [dict(type='LocalVisBackend')]
+visualizer = dict(
+    type='DetLocalVisualizer',
+    vis_backends=vis_backends,
+    name='visualizer')
+```
+
+Based on the above example, we can see that the configuration of `Visualizer` consists of two main parts, namely, the type of `Visualizer` and the visualization backend `vis_backends` it uses.
+
+- Users can directly use `DetLocalVisualizer` to visualize labels or predictions for support tasks.
+- MMDet sets the visualization backend `vis_backend` to the local visualization backend `LocalVisBackend` by default, saving all visualization results and other training information in a local folder.
+
+## Storage
+
+MMDet uses the local visualization backend [`LocalVisBackend`](mmengine.visualization.LocalVisBackend) by default, and the model loss, learning rate, model evaluation accuracy and visualization The information stored in `VisualizerHook` and `LoggerHook`, including loss, learning rate, evaluation accuracy will be saved to the `{work_dir}/{config_name}/{time}/{vis_data}` folder by default. In addition, MMDet also supports other common visualization backends, such as `TensorboardVisBackend` and `WandbVisBackend`, and you only need to change the `vis_backends` type in the configuration file to the corresponding visualization backend. For example, you can store data to `TensorBoard` and `Wandb` by simply inserting the following code block into the configuration file.
+
+```Python
+# https://mmengine.readthedocs.io/en/latest/api/visualization.html
+_base_.visualizer.vis_backends = [
+    dict(type='LocalVisBackend'), #
+    dict(type='TensorboardVisBackend'),
+    dict(type='WandbVisBackend'),]
+```
+
+## Plot
+
+### Plot the prediction results
+
+MMDet mainly uses [`DetVisualizationHook`](mmdet.engine.hooks.DetVisualizationHook) to plot the prediction results of validation and test, by default `DetVisualizationHook` is off, and the default configuration is as follows.
+
+```Python
+visualization=dict( # user visualization of validation and test results
+    type='DetVisualizationHook',
+    draw=False,
+    interval=1,
+    show=False)
+```
+
+The following table shows the parameters supported by `DetVisualizationHook`.
+
+| Parameters |                                                  Description                                                  |
+| :--------: | :-----------------------------------------------------------------------------------------------------------: |
+|    draw    |      The DetVisualizationHook is turned on and off by the enable parameter, which is the default state.       |
+|  interval  | Controls how much iteration to store or display the results of a val or test if VisualizationHook is enabled. |
+|    show    |                           Controls whether to visualize the results of val or test.                           |
+
+If you want to enable `DetVisualizationHook` related functions and configurations during training or testing, you only need to modify the configuration, take `configs/rtmdet/rtmdet_tiny_8xb32-300e_coco.py` as an example, draw annotations and predictions at the same time, and display the images, the configuration can be modified as follows
+
+```Python
+visualization = _base_.default_hooks.visualization
+visualization.update(dict(draw=True, show=True))
+```
+
+
    
+
+
    
+
+The `test.py` procedure is further simplified by providing the  `--show` and `--show-dir` parameters to visualize the annotation and prediction results during the test without modifying the configuration.
+
+```Shell
+# Show test results
+python tools/test.py configs/rtmdet/rtmdet_tiny_8xb32-300e_coco.py https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_tiny_8xb32-300e_coco/rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth --show
+
+# Specify where to store the prediction results
+python tools/test.py configs/rtmdet/rtmdet_tiny_8xb32-300e_coco.py https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_tiny_8xb32-300e_coco/rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth --show-dir imgs/
+```
+
+
    
+
+
    
diff --git a/mmdetection/docs/zh_cn/Makefile b/mmdetection/docs/zh_cn/Makefile
new file mode 100644
index 00000000..d4bb2cbb
--- /dev/null
+++ b/mmdetection/docs/zh_cn/Makefile
@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = .
+BUILDDIR      = _build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
diff --git a/mmdetection/docs/zh_cn/_static/css/readthedocs.css b/mmdetection/docs/zh_cn/_static/css/readthedocs.css
new file mode 100644
index 00000000..57ed0ad0
--- /dev/null
+++ b/mmdetection/docs/zh_cn/_static/css/readthedocs.css
@@ -0,0 +1,6 @@
+.header-logo {
+    background-image: url("../image/mmdet-logo.png");
+    background-size: 156px 40px;
+    height: 40px;
+    width: 156px;
+}
diff --git a/mmdetection/docs/zh_cn/_static/image/mmdet-logo.png b/mmdetection/docs/zh_cn/_static/image/mmdet-logo.png
new file mode 100644
index 00000000..58e2b5e6
Binary files /dev/null and b/mmdetection/docs/zh_cn/_static/image/mmdet-logo.png differ
diff --git a/mmdetection/docs/zh_cn/advanced_guides/conventions.md b/mmdetection/docs/zh_cn/advanced_guides/conventions.md
new file mode 100644
index 00000000..9fb1f14c
--- /dev/null
+++ b/mmdetection/docs/zh_cn/advanced_guides/conventions.md
@@ -0,0 +1,109 @@
+# 默认约定
+
+如果你想把 MMDetection 修改为自己的项目，请遵循下面的约定。
+
+## 关于图片 shape 顺序的说明
+
+在OpenMMLab 2.0中， 为了与 OpenCV 的输入参数相一致，图片处理 pipeline 中关于图像 shape 的输入参数总是以 `(width, height)` 的顺序排列。
+相反，为了计算方便，经过 pipeline 和 model 的字段的顺序是 `(height, width)`。具体来说在每个数据 pipeline 处理的结果中，字段和它们的值含义如下：
+
+- img_shape: (height, width)
+- ori_shape: (height, width)
+- pad_shape: (height, width)
+- batch_input_shape: (height, width)
+
+以 `Mosaic` 为例，其初始化参数如下所示：
+
+```python
+@TRANSFORMS.register_module()
+class Mosaic(BaseTransform):
+    def __init__(self,
+                img_scale: Tuple[int, int] = (640, 640),
+                center_ratio_range: Tuple[float, float] = (0.5, 1.5),
+                bbox_clip_border: bool = True,
+                pad_val: float = 114.0,
+                prob: float = 1.0) -> None:
+       ...
+
+       # img_scale 顺序应该是 (width, height)
+       self.img_scale = img_scale
+
+    def transform(self, results: dict) -> dict:
+        ...
+
+        results['img'] = mosaic_img
+        # (height, width)
+        results['img_shape'] = mosaic_img.shape[:2]
+```
+
+## 损失
+
+在 MMDetection 中，`model(**data)` 的返回值是一个字典，包含着所有的损失和评价指标，他们将会由 `model(**data)` 返回。
+
+例如，在 bbox head 中，
+
+```python
+class BBoxHead(nn.Module):
+    ...
+    def loss(self, ...):
+        losses = dict()
+        # 分类损失
+        losses['loss_cls'] = self.loss_cls(...)
+        # 分类准确率
+        losses['acc'] = accuracy(...)
+        # 边界框损失
+        losses['loss_bbox'] = self.loss_bbox(...)
+        return losses
+```
+
+`'bbox_head.loss()'` 在模型 forward 阶段会被调用。返回的字典中包含了 `'loss_bbox'`,`'loss_cls'`,`'acc'`。只有 `'loss_bbox'`, `'loss_cls'` 会被用于反向传播，`'acc'` 只会被作为评价指标来监控训练过程。
+
+我们默认，只有那些键的名称中包含 `'loss'` 的值会被用于反向传播。这个行为可以通过修改 `BaseDetector.train_step()` 来改变。
+
+## 空 proposals
+
+在 MMDetection 中，我们为两阶段方法中空 proposals 的情况增加了特殊处理和单元测试。我们同时需要处理整个 batch 和单一图片中空 proposals 的情况。例如，在 CascadeRoIHead 中，
+
+```python
+# 简单的测试
+...
+
+# 在整个 batch中 都没有 proposals
+if rois.shape[0] == 0:
+    bbox_results = [[
+        np.zeros((0, 5), dtype=np.float32)
+        for _ in range(self.bbox_head[-1].num_classes)
+    ]] * num_imgs
+    if self.with_mask:
+        mask_classes = self.mask_head[-1].num_classes
+        segm_results = [[[] for _ in range(mask_classes)]
+                        for _ in range(num_imgs)]
+        results = list(zip(bbox_results, segm_results))
+    else:
+        results = bbox_results
+    return results
+...
+
+# 在单张图片中没有 proposals
+for i in range(self.num_stages):
+    ...
+    if i < self.num_stages - 1:
+          for j in range(num_imgs):
+                # 处理空 proposals
+                if rois[j].shape[0] > 0:
+                    bbox_label = cls_score[j][:, :-1].argmax(dim=1)
+                    refine_roi = self.bbox_head[i].regress_by_class(
+                         rois[j], bbox_label[j], bbox_pred[j], img_metas[j])
+                    refine_roi_list.append(refine_roi)
+```
+
+如果你有自定义的 `RoIHead`, 你可以参考上面的方法来处理空 proposals 的情况。
+
+## 全景分割数据集
+
+在 MMDetection 中，我们支持了 COCO 全景分割数据集 `CocoPanopticDataset`。对于它的实现，我们在这里声明一些默认约定。
+
+1. 在 mmdet\<=2.16.0 时，语义分割标注中的前景和背景标签范围与 MMDetection 中的默认规定有所不同。标签 `0` 代表 `VOID` 标签。
+   从 mmdet=2.17.0 开始，为了和框的类别标注保持一致，语义分割标注的类别标签也改为从 `0` 开始，标签 `255` 代表 `VOID` 类。
+   为了达成这一目标，我们在流程 `Pad` 里支持了设置 `seg` 的填充值的功能。
+2. 在评估中，全景分割结果必须是一个与原图大小相同的图。结果图中每个像素的值有如此形式：`instance_id * INSTANCE_OFFSET + category_id`。
diff --git a/mmdetection/docs/zh_cn/advanced_guides/customize_dataset.md b/mmdetection/docs/zh_cn/advanced_guides/customize_dataset.md
new file mode 100644
index 00000000..e845f37f
--- /dev/null
+++ b/mmdetection/docs/zh_cn/advanced_guides/customize_dataset.md
@@ -0,0 +1,425 @@
+# 自定义数据集
+
+## 支持新的数据格式
+
+为了支持新的数据格式，可以选择将数据转换成现成的格式（COCO 或者 PASCAL）或将其转换成中间格式。当然也可以选择以离线的形式（在训练之前使用脚本转换）或者在线的形式（实现一个新的 dataset 在训练中进行转换）来转换数据。
+
+在 MMDetection 中，建议将数据转换成 COCO 格式并以离线的方式进行，因此在完成数据转换后只需修改配置文件中的标注数据的路径和类别即可。
+
+### 将新的数据格式转换为现有的数据格式
+
+最简单的方法就是将你的数据集转换成现有的数据格式（COCO 或者 PASCAL VOC）
+
+COCO 格式的 JSON 标注文件有如下必要的字段：
+
+```python
+'images': [
+    {
+        'file_name': 'COCO_val2014_000000001268.jpg',
+        'height': 427,
+        'width': 640,
+        'id': 1268
+    },
+    ...
+],
+
+'annotations': [
+    {
+        'segmentation': [[192.81,
+            247.09,
+            ...
+            219.03,
+            249.06]],  # 如果有 mask 标签且为多边形 XY 点坐标格式，则需要保证至少包括 3 个点坐标，否则为无效多边形
+        'area': 1035.749,
+        'iscrowd': 0,
+        'image_id': 1268,
+        'bbox': [192.81, 224.8, 74.73, 33.43],
+        'category_id': 16,
+        'id': 42986
+    },
+    ...
+],
+
+'categories': [
+    {'id': 0, 'name': 'car'},
+ ]
+```
+
+在 JSON 文件中有三个必要的键：
+
+- `images`: 包含多个图片以及它们的信息的数组，例如 `file_name`、`height`、`width` 和 `id`。
+- `annotations`: 包含多个实例标注信息的数组。
+- `categories`: 包含多个类别名字和 ID 的数组。
+
+在数据预处理之后，使用现有的数据格式来训练自定义的新数据集有如下两步（以 COCO 为例）：
+
+1. 为自定义数据集修改配置文件。
+2. 检查自定义数据集的标注。
+
+这里我们举一个例子来展示上面的两个步骤，这个例子使用包括 5 个类别的 COCO 格式的数据集来训练一个现有的 Cascade Mask R-CNN R50-FPN 检测器
+
+#### 1. 为自定义数据集修改配置文件
+
+配置文件的修改涉及两个方面：
+
+1. `dataloaer` 部分。需要在 `train_dataloader.dataset`、`val_dataloader.dataset` 和 `test_dataloader.dataset` 中添加 `metainfo=dict(classes=classes)`, 其中 classes 必须是 tuple 类型。
+2. `model` 部分中的 `num_classes`。需要将默认值（COCO 数据集中为 80）修改为自定义数据集中的类别数。
+
+`configs/my_custom_config.py` 内容如下：
+
+```python
+
+# 新的配置来自基础的配置以更好地说明需要修改的地方
+_base_ = './cascade_mask_rcnn_r50_fpn_1x_coco.py'
+
+# 1. 数据集设定
+dataset_type = 'CocoDataset'
+classes = ('a', 'b', 'c', 'd', 'e')
+data_root='path/to/your/'
+
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=2,
+    dataset=dict(
+        type=dataset_type,
+        # 将类别名字添加至 `metainfo` 字段中
+        metainfo=dict(classes=classes),
+        data_root=data_root,
+        ann_file='train/annotation_data',
+        data_prefix=dict(img='train/image_data')
+        )
+    )
+
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+    dataset=dict(
+        type=dataset_type,
+        test_mode=True,
+        # 将类别名字添加至 `metainfo` 字段中
+        metainfo=dict(classes=classes),
+        data_root=data_root,
+        ann_file='val/annotation_data',
+        data_prefix=dict(img='val/image_data')
+    )
+
+test_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+    dataset=dict(
+        type=dataset_type,
+        test_mode=True,
+        # 将类别名字添加至 `metainfo` 字段中
+        metainfo=dict(classes=classes),
+        data_root=data_root,
+        ann_file='test/annotation_data',
+        data_prefix=dict(img='test/image_data')
+        )
+    )
+
+# 2. 模型设置
+
+# 将所有的 `num_classes` 默认值修改为 5（原来为80）
+model = dict(
+    roi_head=dict(
+        bbox_head=[
+            dict(
+                type='Shared2FCBBoxHead',
+                # 将所有的 `num_classes` 默认值修改为 5（原来为 80）
+                num_classes=5),
+            dict(
+                type='Shared2FCBBoxHead',
+                # 将所有的 `num_classes` 默认值修改为 5（原来为 80）
+                num_classes=5),
+            dict(
+                type='Shared2FCBBoxHead',
+                # 将所有的 `num_classes` 默认值修改为 5（原来为 80）
+                num_classes=5)],
+    # 将所有的 `num_classes` 默认值修改为 5（原来为 80）
+    mask_head=dict(num_classes=5)))
+```
+
+#### 2. 检查自定义数据集的标注
+
+假设你自己的数据集是 COCO 格式，那么需要保证数据的标注没有问题：
+
+1. 标注文件中 `categories` 的长度要与配置中的 `classes` 元组长度相匹配，它们都表示有几类。（如例子中有 5 个类别）
+2. 配置文件中 `classes` 字段应与标注文件里 `categories` 下的 `name` 有相同的元素且顺序一致。MMDetection 会自动将 `categories` 中不连续的 `id` 映射成连续的索引，因此 `categories` 下的 `name`的字符串顺序会影响标签的索引。同时，配置文件中的 `classes` 的字符串顺序也会影响到预测框可视化时的标签。
+3. `annotations` 中的 `category_id` 必须是有效的值。比如所有 `category_id` 的值都应该属于 `categories` 中的 `id`。
+
+下面是一个有效标注的例子：
+
+```python
+
+'annotations': [
+    {
+        'segmentation': [[192.81,
+            247.09,
+            ...
+            219.03,
+            249.06]],  # 如果有 mask 标签。
+        'area': 1035.749,
+        'iscrowd': 0,
+        'image_id': 1268,
+        'bbox': [192.81, 224.8, 74.73, 33.43],
+        'category_id': 16,
+        'id': 42986
+    },
+    ...
+],
+
+# MMDetection 会自动将 `categories` 中不连续的 `id` 映射成连续的索引。
+'categories': [
+    {'id': 1, 'name': 'a'}, {'id': 3, 'name': 'b'}, {'id': 4, 'name': 'c'}, {'id': 16, 'name': 'd'}, {'id': 17, 'name': 'e'},
+ ]
+```
+
+我们使用这种方式来支持 CityScapes 数据集。脚本在 [cityscapes.py](https://github.com/open-mmlab/mmdetection/blob/main/tools/dataset_converters/cityscapes.py) 并且我们提供了微调的 [configs](https://github.com/open-mmlab/mmdetection/blob/main/configs/cityscapes).
+
+**注意**
+
+1. 对于实例分割数据集, **MMDetection 目前只支持评估 COCO 格式的 mask AP**.
+2. 推荐训练之前进行离线转换，这样就可以继续使用 `CocoDataset` 且只需修改标注文件的路径以及训练的种类。
+
+### 调整新的数据格式为中间格式
+
+如果不想将标注格式转换为 COCO 或者 PASCAL 格式也是可行的。实际上，我们在 MMEngine 的 [BaseDataset](https://github.com/open-mmlab/mmengine/blob/main/mmengine/dataset/base_dataset.py#L116) 中定义了一种简单的标注格式并且与所有现有的数据格式兼容，也能进行离线或者在线转换。
+
+数据集的标注必须为 `json` 或 `yaml`，`yml` 或 `pickle`，`pkl` 格式；标注文件中存储的字典必须包含 `metainfo` 和 `data_list` 两个字段。其中 `metainfo` 是一个字典，里面包含数据集的元信息，例如类别信息；`data_list` 是一个列表，列表中每个元素是一个字典，该字典定义了一个原始数据（raw data），每个原始数据包含一个或若干个训练/测试样本。
+
+以下是一个 JSON 标注文件的例子:
+
+```json
+{
+    'metainfo':
+        {
+            'classes': ('person', 'bicycle', 'car', 'motorcycle'),
+            ...
+        },
+    'data_list':
+        [
+            {
+                "img_path": "xxx/xxx_1.jpg",
+                "height": 604,
+                "width": 640,
+                "instances":
+                [
+                  {
+                    "bbox": [0, 0, 10, 20],
+                    "bbox_label": 1,
+                    "ignore_flag": 0
+                  },
+                  {
+                    "bbox": [10, 10, 110, 120],
+                    "bbox_label": 2,
+                    "ignore_flag": 0
+                  }
+                ]
+              },
+            {
+                "img_path": "xxx/xxx_2.jpg",
+                "height": 320,
+                "width": 460,
+                "instances":
+                [
+                  {
+                    "bbox": [10, 0, 20, 20],
+                    "bbox_label": 3,
+                    "ignore_flag": 1
+                  }
+                ]
+              },
+            ...
+        ]
+}
+```
+
+有些数据集可能会提供如：crowd/difficult/ignored bboxes 标注，那么我们使用 `ignore_flag`来包含它们。
+
+在得到上述标准的数据标注格式后，可以直接在配置中使用 MMDetection 的 [BaseDetDataset](https://github.com/open-mmlab/mmdetection/blob/main/mmdet/datasets/base_det_dataset.py#L13) ，而无需进行转换。
+
+### 自定义数据集例子
+
+假设文本文件中表示的是一种全新的标注格式。边界框的标注信息保存在 `annotation.txt` 中，内容如下：
+
+```
+#
+000001.jpg
+1280 720
+2
+10 20 40 60 1
+20 40 50 60 2
+#
+000002.jpg
+1280 720
+3
+50 20 40 60 2
+20 40 30 45 2
+30 40 50 60 3
+```
+
+我们可以在 `mmdet/datasets/my_dataset.py` 中创建一个新的 dataset 用以加载数据。
+
+```python
+import mmengine
+from mmdet.base_det_dataset import BaseDetDataset
+from mmdet.registry import DATASETS
+
+
+@DATASETS.register_module()
+class MyDataset(BaseDetDataset):
+
+    METAINFO = {
+       'classes': ('person', 'bicycle', 'car', 'motorcycle'),
+        'palette': [(220, 20, 60), (119, 11, 32), (0, 0, 142), (0, 0, 230)]
+    }
+
+    def load_data_list(self, ann_file):
+        ann_list = mmengine.list_from_file(ann_file)
+
+        data_infos = []
+        for i, ann_line in enumerate(ann_list):
+            if ann_line != '#':
+                continue
+
+            img_shape = ann_list[i + 2].split(' ')
+            width = int(img_shape[0])
+            height = int(img_shape[1])
+            bbox_number = int(ann_list[i + 3])
+
+            instances = []
+            for anns in ann_list[i + 4:i + 4 + bbox_number]:
+                instance = {}
+                instance['bbox'] = [float(ann) for ann in anns.split(' ')[:4]]
+                instance['bbox_label']=int(anns[4])
+ 				instances.append(instance)
+
+            data_infos.append(
+                dict(
+                    img_path=ann_list[i + 1],
+                    img_id=i,
+                    width=width,
+                    height=height,
+                    instances=instances
+                ))
+
+        return data_infos
+```
+
+配置文件中，可以使用 `MyDataset` 进行如下修改
+
+```python
+dataset_A_train = dict(
+    type='MyDataset',
+    ann_file = 'image_list.txt',
+    pipeline=train_pipeline
+)
+```
+
+## 使用 dataset 包装器自定义数据集
+
+MMEngine 也支持非常多的数据集包装器（wrapper）来混合数据集或在训练时修改数据集的分布，其支持如下三种数据集包装：
+
+- `RepeatDataset`：将整个数据集简单地重复。
+- `ClassBalancedDataset`：以类别均衡的方式重复数据集。
+- `ConcatDataset`：合并数据集。
+
+具体使用方式见 [MMEngine 数据集包装器](#TODO)。
+
+## 修改数据集的类别
+
+根据现有数据集的类型，我们可以修改它们的类别名称来训练其标注的子集。
+例如，如果只想训练当前数据集中的三个类别，那么就可以修改数据集的 `metainfo` 字典，数据集就会自动屏蔽掉其他类别的真实框。
+
+```python
+classes = ('person', 'bicycle', 'car')
+train_dataloader = dict(
+    dataset=dict(
+        metainfo=dict(classes=classes))
+    )
+val_dataloader = dict(
+    dataset=dict(
+        metainfo=dict(classes=classes))
+    )
+test_dataloader = dict(
+    dataset=dict(
+        metainfo=dict(classes=classes))
+    )
+```
+
+**注意**
+
+- 在 MMDetection v2.5.0 之前，如果类别为集合时数据集将自动过滤掉不包含 GT 的图片，且没办法通过修改配置将其关闭。这是一种不可取的行为而且会引起混淆，因为当类别不是集合时数据集时，只有在 `filter_empty_gt=True` 以及 `test_mode=False` 的情况下才会过滤掉不包含 GT 的图片。在 MMDetection v2.5.0 之后，我们将图片的过滤以及类别的修改进行解耦，数据集只有在 `filter_cfg=dict(filter_empty_gt=True)` 和 `test_mode=False` 的情况下才会过滤掉不包含 GT 的图片，无论类别是否为集合。设置类别只会影响用于训练的标注类别，用户可以自行决定是否过滤不包含 GT 的图片。
+- 直接使用 MMEngine 中的 `BaseDataset` 或者 MMDetection 中的 `BaseDetDataset` 时用户不能通过修改配置来过滤不含 GT 的图片，但是可以通过离线的方式来解决。
+- 当设置数据集中的 `classes` 时，记得修改 `num_classes`。从 v2.9.0 (PR#4508) 之后，我们实现了 [NumClassCheckHook](https://github.com/open-mmlab/mmdetection/blob/main/mmdet/engine/hooks/num_class_check_hook.py) 来检查类别数是否一致。
+
+## COCO 全景分割数据集
+
+现在我们也支持 COCO Panoptic Dataset，全景注释的格式与 COCO 格式不同，其前景和背景都将存在于注释文件中。COCO Panoptic 格式的注释 JSON 文件具有以下必要的键：
+
+```python
+'images': [
+    {
+        'file_name': '000000001268.jpg',
+        'height': 427,
+        'width': 640,
+        'id': 1268
+    },
+    ...
+]
+
+'annotations': [
+    {
+        'filename': '000000001268.jpg',
+        'image_id': 1268,
+        'segments_info': [
+            {
+                'id':8345037,  # One-to-one correspondence with the id in the annotation map.
+                'category_id': 51,
+                'iscrowd': 0,
+                'bbox': (x1, y1, w, h),  # The bbox of the background is the outer rectangle of its mask.
+                'area': 24315
+            },
+            ...
+        ]
+    },
+    ...
+]
+
+'categories': [  # including both foreground categories and background categories
+    {'id': 0, 'name': 'person'},
+    ...
+ ]
+```
+
+此外，`seg` 必须设置为全景注释图像的路径。
+
+```python
+dataset_type = 'CocoPanopticDataset'
+data_root='path/to/your/'
+
+train_dataloader = dict(
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img='train/image_data/', seg='train/panoptic/image_annotation_data/')
+    )
+)
+val_dataloader = dict(
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img='val/image_data/', seg='val/panoptic/image_annotation_data/')
+    )
+)
+test_dataloader = dict(
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img='test/image_data/', seg='test/panoptic/image_annotation_data/')
+    )
+)
+```
diff --git a/mmdetection/docs/zh_cn/advanced_guides/customize_losses.md b/mmdetection/docs/zh_cn/advanced_guides/customize_losses.md
new file mode 100644
index 00000000..07ccccda
--- /dev/null
+++ b/mmdetection/docs/zh_cn/advanced_guides/customize_losses.md
@@ -0,0 +1,125 @@
+# 自定义损失函数
+
+MMDetection 为用户提供了不同的损失函数。但是默认的配置可能无法适应不同的数据和模型，所以用户可能会希望修改某一个损失函数来适应新的情况。
+
+本教程首先详细的解释计算损失的过程然后给出一些关于如何修改每一个步骤的指导。对损失的修改可以被分为微调和加权。
+
+## 一个损失的计算过程
+
+给定输入（包括预测和目标，以及权重），损失函数会把输入的张量映射到最后的损失标量。映射过程可以分为下面五个步骤：
+
+1. 设置采样方法为对正负样本进行采样。
+
+2. 通过损失核函数获取**元素**或者**样本**损失。
+
+3. 通过权重张量来给损失**逐元素**权重。
+
+4. 把损失张量归纳为一个**标量**。
+
+5. 用一个**张量**给当前损失一个权重。
+
+## 设置采样方法（步骤 1）
+
+对于一些损失函数，需要采样策略来避免正负样本之间的不平衡。
+
+例如，在RPN head中使用`CrossEntropyLoss`时，我们需要在`train_cfg`中设置`RandomSampler`
+
+```python
+train_cfg=dict(
+    rpn=dict(
+        sampler=dict(
+            type='RandomSampler',
+            num=256,
+            pos_fraction=0.5,
+            neg_pos_ub=-1,
+            add_gt_as_proposals=False))
+```
+
+对于其他一些具有正负样本平衡机制的损失，例如 Focal Loss、GHMC 和 QualityFocalLoss，不再需要进行采样。
+
+## 微调损失
+
+微调一个损失主要与步骤 2，4，5 有关，大部分的修改可以在配置文件中指定。这里我们用 [Focal Loss (FL)](https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/losses/focal_loss.py) 作为例子。
+下面的代码分别是构建 FL 的方法和它的配置文件，他们是一一对应的。
+
+```python
+@LOSSES.register_module()
+class FocalLoss(nn.Module):
+
+    def __init__(self,
+                 use_sigmoid=True,
+                 gamma=2.0,
+                 alpha=0.25,
+                 reduction='mean',
+                 loss_weight=1.0):
+```
+
+```python
+loss_cls=dict(
+    type='FocalLoss',
+    use_sigmoid=True,
+    gamma=2.0,
+    alpha=0.25,
+    loss_weight=1.0)
+```
+
+### 微调超参数（步骤2）
+
+`gamma` 和 `beta` 是 Focal Loss 中的两个超参数。如果我们想把 `gamma` 的值设为 1.5，把 `alpha` 的值设为 0.5，我们可以在配置文件中按照如下指定：
+
+```python
+loss_cls=dict(
+    type='FocalLoss',
+    use_sigmoid=True,
+    gamma=1.5,
+    alpha=0.5,
+    loss_weight=1.0)
+```
+
+### 微调归纳方式（步骤4）
+
+Focal Loss 默认的归纳方式是 `mean`。如果我们想把归纳方式从 `mean` 改成 `sum`，我们可以在配置文件中按照如下指定：
+
+```python
+loss_cls=dict(
+    type='FocalLoss',
+    use_sigmoid=True,
+    gamma=2.0,
+    alpha=0.25,
+    loss_weight=1.0,
+    reduction='sum')
+```
+
+### 微调损失权重（步骤5）
+
+这里的损失权重是一个标量，他用来控制多任务学习中不同损失的重要程度，例如，分类损失和回归损失。如果我们想把分类损失的权重设为 0.5，我们可以在配置文件中如下指定：
+
+```python
+loss_cls=dict(
+    type='FocalLoss',
+    use_sigmoid=True,
+    gamma=2.0,
+    alpha=0.25,
+    loss_weight=0.5)
+```
+
+## 加权损失（步骤3）
+
+加权损失就是我们逐元素修改损失权重。更具体来说，我们给损失张量乘以一个与他有相同形状的权重张量。所以，损失中不同的元素可以被赋予不同的比例，所以这里叫做逐元素。损失的权重在不同模型中变化很大，而且与上下文相关，但是总的来说主要有两种损失权重：分类损失的 `label_weights` 和边界框的 `bbox_weights`。你可以在相应的头中的 `get_target` 方法中找到他们。这里我们使用 [ATSSHead](https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/dense_heads/atss_head.py#L322) 作为一个例子。它继承了 [AnchorHead](https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/dense_heads/anchor_head.py) ，但是我们重写它的
+`get_targets` 方法来产生不同的 `label_weights` 和 `bbox_weights`。
+
+```
+class ATSSHead(AnchorHead):
+
+    ...
+
+    def get_targets(self,
+                    anchor_list,
+                    valid_flag_list,
+                    gt_bboxes_list,
+                    img_metas,
+                    gt_bboxes_ignore_list=None,
+                    gt_labels_list=None,
+                    label_channels=1,
+                    unmap_outputs=True):
+```
diff --git a/mmdetection/docs/zh_cn/advanced_guides/customize_models.md b/mmdetection/docs/zh_cn/advanced_guides/customize_models.md
new file mode 100644
index 00000000..5fa77e41
--- /dev/null
+++ b/mmdetection/docs/zh_cn/advanced_guides/customize_models.md
@@ -0,0 +1,412 @@
+# 自定义模型
+
+我们简单地把模型的各个组件分为五类：
+
+- 主干网络 (backbone)：通常是一个用来提取特征图 (feature map) 的全卷积网络 (FCN network)，例如：ResNet, MobileNet。
+- Neck：主干网络和 Head 之间的连接部分，例如：FPN, PAFPN。
+- Head：用于具体任务的组件，例如：边界框预测和掩码预测。
+- 区域提取器 (roi extractor)：从特征图中提取 RoI 特征，例如：RoI Align。
+- 损失 (loss)：在 Head 组件中用于计算损失的部分，例如：FocalLoss, L1Loss, GHMLoss.
+
+## 开发新的组件
+
+### 添加一个新的主干网络
+
+这里，我们以 MobileNet 为例来展示如何开发新组件。
+
+#### 1. 定义一个新的主干网络（以 MobileNet 为例）
+
+新建一个文件 `mmdet/models/backbones/mobilenet.py`
+
+```python
+import torch.nn as nn
+
+from mmdet.registry import MODELS
+
+
+@MODELS.register_module()
+class MobileNet(nn.Module):
+
+    def __init__(self, arg1, arg2):
+        pass
+
+    def forward(self, x):  # should return a tuple
+        pass
+```
+
+#### 2. 导入该模块
+
+你可以添加下述代码到 `mmdet/models/backbones/__init__.py`
+
+```python
+from .mobilenet import MobileNet
+```
+
+或添加：
+
+```python
+custom_imports = dict(
+    imports=['mmdet.models.backbones.mobilenet'],
+    allow_failed_imports=False)
+```
+
+到配置文件以避免原始代码被修改。
+
+#### 3. 在你的配置文件中使用该主干网络
+
+```python
+model = dict(
+    ...
+    backbone=dict(
+        type='MobileNet',
+        arg1=xxx,
+        arg2=xxx),
+    ...
+```
+
+### 添加新的 Neck
+
+#### 1. 定义一个 Neck（以 PAFPN 为例）
+
+新建一个文件 `mmdet/models/necks/pafpn.py`
+
+```python
+import torch.nn as nn
+
+from mmdet.registry import MODELS
+
+
+@MODELS.register_module()
+class PAFPN(nn.Module):
+
+    def __init__(self,
+                in_channels,
+                out_channels,
+                num_outs,
+                start_level=0,
+                end_level=-1,
+                add_extra_convs=False):
+        pass
+
+    def forward(self, inputs):
+        # implementation is ignored
+        pass
+```
+
+#### 2. 导入该模块
+
+你可以添加下述代码到 `mmdet/models/necks/__init__.py`
+
+```python
+from .pafpn import PAFPN
+```
+
+或添加：
+
+```python
+custom_imports = dict(
+    imports=['mmdet.models.necks.pafpn'],
+    allow_failed_imports=False)
+```
+
+到配置文件以避免原始代码被修改。
+
+#### 3. 修改配置文件
+
+```python
+neck=dict(
+    type='PAFPN',
+    in_channels=[256, 512, 1024, 2048],
+    out_channels=256,
+    num_outs=5)
+```
+
+### 添加新的 Head
+
+我们以 [Double Head R-CNN](https://arxiv.org/abs/1904.06493) 为例来展示如何添加一个新的 Head。
+
+首先，添加一个新的 bbox head 到 `mmdet/models/roi_heads/bbox_heads/double_bbox_head.py`。
+Double Head R-CNN 在目标检测上实现了一个新的 bbox head。为了实现 bbox head，我们需要使用如下的新模块中三个函数。
+
+```python
+from typing import Tuple
+
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule, ModuleList
+from torch import Tensor
+
+from mmdet.models.backbones.resnet import Bottleneck
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, MultiConfig, OptConfigType, OptMultiConfig
+from .bbox_head import BBoxHead
+
+
+@MODELS.register_module()
+class DoubleConvFCBBoxHead(BBoxHead):
+    r"""Bbox head used in Double-Head R-CNN
+
+    .. code-block:: none
+
+                                          /-> cls
+                      /-> shared convs ->
+                                          \-> reg
+        roi features
+                                          /-> cls
+                      \-> shared fc    ->
+                                          \-> reg
+    """  # noqa: W605
+
+    def __init__(self,
+                 num_convs: int = 0,
+                 num_fcs: int = 0,
+                 conv_out_channels: int = 1024,
+                 fc_out_channels: int = 1024,
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: ConfigType = dict(type='BN'),
+                 init_cfg: MultiConfig = dict(
+                     type='Normal',
+                     override=[
+                         dict(type='Normal', name='fc_cls', std=0.01),
+                         dict(type='Normal', name='fc_reg', std=0.001),
+                         dict(
+                             type='Xavier',
+                             name='fc_branch',
+                             distribution='uniform')
+                     ]),
+                 **kwargs) -> None:
+        kwargs.setdefault('with_avg_pool', True)
+        super().__init__(init_cfg=init_cfg, **kwargs)
+
+    def forward(self, x_cls: Tensor, x_reg: Tensor) -> Tuple[Tensor]:
+
+```
+
+然后，如有必要，实现一个新的 bbox head。我们打算从 `StandardRoIHead` 来继承新的 `DoubleHeadRoIHead`。我们可以发现 `StandardRoIHead` 已经实现了下述函数。
+
+```python
+from typing import List, Optional, Tuple
+
+import torch
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.structures import DetDataSample
+from mmdet.structures.bbox import bbox2roi
+from mmdet.utils import ConfigType, InstanceList
+from ..task_modules.samplers import SamplingResult
+from ..utils import empty_instances, unpack_gt_instances
+from .base_roi_head import BaseRoIHead
+
+
+@MODELS.register_module()
+class StandardRoIHead(BaseRoIHead):
+    """Simplest base roi head including one bbox head and one mask head."""
+
+    def init_assigner_sampler(self) -> None:
+
+    def init_bbox_head(self, bbox_roi_extractor: ConfigType,
+                       bbox_head: ConfigType) -> None:
+
+    def init_mask_head(self, mask_roi_extractor: ConfigType,
+                       mask_head: ConfigType) -> None:
+
+    def forward(self, x: Tuple[Tensor],
+                rpn_results_list: InstanceList) -> tuple:
+
+    def loss(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
+             batch_data_samples: List[DetDataSample]) -> dict:
+
+    def _bbox_forward(self, x: Tuple[Tensor], rois: Tensor) -> dict:
+
+    def bbox_loss(self, x: Tuple[Tensor],
+                  sampling_results: List[SamplingResult]) -> dict:
+
+    def mask_loss(self, x: Tuple[Tensor],
+                  sampling_results: List[SamplingResult], bbox_feats: Tensor,
+                  batch_gt_instances: InstanceList) -> dict:
+
+    def _mask_forward(self,
+                      x: Tuple[Tensor],
+                      rois: Tensor = None,
+                      pos_inds: Optional[Tensor] = None,
+                      bbox_feats: Optional[Tensor] = None) -> dict:
+
+    def predict_bbox(self,
+                     x: Tuple[Tensor],
+                     batch_img_metas: List[dict],
+                     rpn_results_list: InstanceList,
+                     rcnn_test_cfg: ConfigType,
+                     rescale: bool = False) -> InstanceList:
+
+    def predict_mask(self,
+                     x: Tuple[Tensor],
+                     batch_img_metas: List[dict],
+                     results_list: InstanceList,
+                     rescale: bool = False) -> InstanceList:
+
+```
+
+Double Head 的修改主要在 bbox_forward 的逻辑中，且它从 `StandardRoIHead` 中继承了其他逻辑。在 `mmdet/models/roi_heads/double_roi_head.py` 中，我们用下述代码实现新的 bbox head：
+
+```python
+from typing import Tuple
+
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from .standard_roi_head import StandardRoIHead
+
+
+@MODELS.register_module()
+class DoubleHeadRoIHead(StandardRoIHead):
+    """RoI head for `Double Head RCNN `_.
+
+    Args:
+        reg_roi_scale_factor (float): The scale factor to extend the rois
+            used to extract the regression features.
+    """
+
+    def __init__(self, reg_roi_scale_factor: float, **kwargs):
+        super().__init__(**kwargs)
+        self.reg_roi_scale_factor = reg_roi_scale_factor
+
+    def _bbox_forward(self, x: Tuple[Tensor], rois: Tensor) -> dict:
+        """Box head forward function used in both training and testing.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            rois (Tensor): RoIs with the shape (n, 5) where the first
+                column indicates batch id of each RoI.
+
+        Returns:
+             dict[str, Tensor]: Usually returns a dictionary with keys:
+
+                - `cls_score` (Tensor): Classification scores.
+                - `bbox_pred` (Tensor): Box energies / deltas.
+                - `bbox_feats` (Tensor): Extract bbox RoI features.
+        """
+        bbox_cls_feats = self.bbox_roi_extractor(
+            x[:self.bbox_roi_extractor.num_inputs], rois)
+        bbox_reg_feats = self.bbox_roi_extractor(
+            x[:self.bbox_roi_extractor.num_inputs],
+            rois,
+            roi_scale_factor=self.reg_roi_scale_factor)
+        if self.with_shared_head:
+            bbox_cls_feats = self.shared_head(bbox_cls_feats)
+            bbox_reg_feats = self.shared_head(bbox_reg_feats)
+        cls_score, bbox_pred = self.bbox_head(bbox_cls_feats, bbox_reg_feats)
+
+        bbox_results = dict(
+            cls_score=cls_score,
+            bbox_pred=bbox_pred,
+            bbox_feats=bbox_cls_feats)
+        return bbox_results
+```
+
+最终，用户需要把该模块添加到 `mmdet/models/bbox_heads/__init__.py` 和 `mmdet/models/roi_heads/__init__.py` 以使相关的注册表可以找到并加载他们。
+
+或者，用户可以添加：
+
+```python
+custom_imports=dict(
+    imports=['mmdet.models.roi_heads.double_roi_head', 'mmdet.models.roi_heads.bbox_heads.double_bbox_head'])
+```
+
+到配置文件并实现相同的目的。
+
+Double Head R-CNN 的配置文件如下：
+
+```python
+_base_ = '../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py'
+model = dict(
+    roi_head=dict(
+        type='DoubleHeadRoIHead',
+        reg_roi_scale_factor=1.3,
+        bbox_head=dict(
+            _delete_=True,
+            type='DoubleConvFCBBoxHead',
+            num_convs=4,
+            num_fcs=2,
+            in_channels=256,
+            conv_out_channels=1024,
+            fc_out_channels=1024,
+            roi_feat_size=7,
+            num_classes=80,
+            bbox_coder=dict(
+                type='DeltaXYWHBBoxCoder',
+                target_means=[0., 0., 0., 0.],
+                target_stds=[0.1, 0.1, 0.2, 0.2]),
+            reg_class_agnostic=False,
+            loss_cls=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=2.0),
+            loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=2.0))))
+
+```
+
+从 MMDetection 2.0 版本起，配置系统支持继承配置以使用户可以专注于修改。
+Double Head R-CNN 主要使用了一个新的 `DoubleHeadRoIHead` 和一个新的 `DoubleConvFCBBoxHead`，参数需要根据每个模块的 `__init__` 函数来设置。
+
+### 添加新的损失
+
+假设你想添加一个新的损失 `MyLoss` 用于边界框回归。
+为了添加一个新的损失函数，用户需要在 `mmdet/models/losses/my_loss.py` 中实现。
+装饰器 `weighted_loss` 可以使损失每个部分加权。
+
+```python
+import torch
+import torch.nn as nn
+
+from mmdet.registry import LOSSES
+from .utils import weighted_loss
+
+
+@weighted_loss
+def my_loss(pred, target):
+    assert pred.size() == target.size() and target.numel() > 0
+    loss = torch.abs(pred - target)
+    return loss
+
+@LOSSES.register_module()
+class MyLoss(nn.Module):
+
+    def __init__(self, reduction='mean', loss_weight=1.0):
+        super(MyLoss, self).__init__()
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+
+    def forward(self,
+                pred,
+                target,
+                weight=None,
+                avg_factor=None,
+                reduction_override=None):
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        loss_bbox = self.loss_weight * my_loss(
+            pred, target, weight, reduction=reduction, avg_factor=avg_factor)
+        return loss_bbox
+```
+
+然后，用户需要把它加到 `mmdet/models/losses/__init__.py`。
+
+```python
+from .my_loss import MyLoss, my_loss
+```
+
+或者，你可以添加：
+
+```python
+custom_imports=dict(
+    imports=['mmdet.models.losses.my_loss'])
+```
+
+到配置文件来实现相同的目的。
+
+如使用，请修改 `loss_xxx` 字段。
+因为 MyLoss 是用于回归的，你需要在 Head 中修改 `loss_xxx` 字段。
+
+```python
+loss_bbox=dict(type='MyLoss', loss_weight=1.0))
+```
diff --git a/mmdetection/docs/zh_cn/advanced_guides/customize_runtime.md b/mmdetection/docs/zh_cn/advanced_guides/customize_runtime.md
new file mode 100644
index 00000000..d4a19098
--- /dev/null
+++ b/mmdetection/docs/zh_cn/advanced_guides/customize_runtime.md
@@ -0,0 +1,387 @@
+# 自定义训练配置
+
+## 自定义优化相关的配置
+
+优化相关的配置现在已全部集成到 `optim_wrapper` 中，通常包含三个域：`optimizer`, `paramwise_cfg`，`clip_grad`，具体细节见 [OptimWrapper](https://mmengine.readthedocs.io/en/latest/tutorials/optim_wrapper.md)。下面这个例子中，使用了 `AdamW` 作为优化器，主干部分的学习率缩小到原来的十分之一，以及添加了梯度裁剪。
+
+```python
+optim_wrapper = dict(
+    type='OptimWrapper',
+    # 优化器
+    optimizer=dict(
+        type='AdamW',
+        lr=0.0001,
+        weight_decay=0.05,
+        eps=1e-8,
+        betas=(0.9, 0.999)),
+
+    # 参数层面的学习率和正则化设置
+    paramwise_cfg=dict(
+        custom_keys={
+            'backbone': dict(lr_mult=0.1, decay_mult=1.0),
+        },
+        norm_decay_mult=0.0),
+
+    # 梯度裁剪
+    clip_grad=dict(max_norm=0.01, norm_type=2))
+```
+
+### 自定义 Pytorch 中优化器设置
+
+我们已经支持了 Pytorch 中实现的所有优化器，要使用这些优化器唯一要做就是修改配置文件中的 `optimi_wrapper` 中的 `optimzer` 域。比如，如果想要使用 `ADAM` 作为优化器（可能会导致性能下降），所需要做的修改如下。
+
+```python
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='Adam', lr=0.0003, weight_decay=0.0001))
+```
+
+要修改模型的学习率，用户只需要修改 `optimizer` 中的 `lr` 域。用户可以直接参考 PyToch 的 [API doc](https://pytorch.org/docs/stable/optim.html?highlight=optim#module-torch.optim) 来进行参数的设置。
+
+### 自定义优化器
+
+#### 1. 定义一个新优化器
+
+自定义优化器可以定义的方式如下：
+
+假设你想要添加一个名为 `MyOptimizer` 的优化器，它包含三个参数 `a`，`b`，`c`。你需要新建一个名为
+`mmdet/engine/optimizers` 的文件夹。然后在文件（比如，`mmdet/engine/optimizers/my_optimizer.py`）实现一个新的优化器。
+
+```python
+from mmdet.registry import OPTIMIZERS
+from torch.optim import Optimizer
+
+
+@OPTIMIZERS.register_module()
+class MyOptimizer(Optimizer):
+
+    def __init__(self, a, b, c)
+
+```
+
+#### 2. 导入自定义的优化器
+
+为了能找到上面的所定义的模块，这个模块必须要先导入到主命名空间中。有两种方式可以实现这一点。
+
+- 修改 `mmdet/engine/optimizers/__init__.py` 来导入模块。
+
+  新定义的模块必须导入到 `mmdet/engine/optimizers/__init__.py`，这样注册器才能找到该模块并添加它。
+
+```python
+from .my_optimizer import MyOptimizer
+```
+
+- 在配置文件使用 `custom_imports` 来手动导入模块。
+
+```python
+custom_imports = dict(imports=['mmdet.engine.optimizers.my_optimizer'], allow_failed_imports=False)
+```
+
+`mmdet.engine.optimizers.my_optimizer` 模块将在程序开始时导入，之后 `MyOptimizer` 类会被自动注册。注意：应该导入 `MyOptimizer` 所在的文件，即 `mmdet.engine.optimizers.my_optimizer`，而不是 `mmdet.engine.optimizers.my_optimizer.MyOptimizer`。
+
+实际上，用户也可以在别的目录结构下来进行导入模块，只要改模块可以在 `PYTHONPATH` 中找到。
+
+#### 3. 在配置文件中指定优化器
+
+接下来，你可以在配置文件中的 `optim_wrapper` 域中的中 `optimizer` 域中设置你实现的优化器 `MyOptimizer`。在配置文件中，优化器在 `optimizer` 域中的配置方式如下：
+
+```python
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001))
+```
+
+为了使用你的优化器，可以进行如下修改
+
+```python
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='MyOptimizer', a=a_value, b=b_value, c=c_value))
+```
+
+### 自定义优化器包装构造类
+
+一些模型可能存在一些特定参数的优化设置，比如，BN 层的权重衰减。用户可以通过自定义优化器包装构造类来实现这些精细化的参数调整。
+
+```python
+from mmengine.optim import DefaultOptiWrapperConstructor
+
+from mmdet.registry import OPTIM_WRAPPER_CONSTRUCTORS
+from .my_optimizer import MyOptimizer
+
+
+@OPTIM_WRAPPER_CONSTRUCTORS.register_module()
+class MyOptimizerWrapperConstructor(DefaultOptimWrapperConstructor):
+
+    def __init__(self,
+                 optim_wrapper_cfg: dict,
+                 paramwise_cfg: Optional[dict] = None):
+
+    def __call__(self, model: nn.Module) -> OptimWrapper:
+
+        return optim_wrapper
+
+```
+
+优化器包装构造类的具体实现见[这里](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/optimizer/default_constructor.py#L18)，用户以它为模板，来实现新的优化器包装构造类。
+
+### 额外的设置
+
+一些没有被优化器实现的技巧（比如，参数层面的学习率设置）应该通过优化器包装构造类来实现或者钩子。我们列出了一些常用的设置用于稳定训练或者加速训练。请随意创建 PR，发布更多设置。
+
+- __使用梯度裁剪来稳定训练__:
+  一些模型需要进行梯度裁剪来稳定训练过程，例子如下：
+
+  ```python
+  optim_wrapper = dict(
+      _delete_=True, clip_grad=dict(max_norm=35, norm_type=2))
+  ```
+
+  如果你的配置已经集成了基础配置（包含了 `optim_wrapper` 的配置），那么你需要添加 `_delete_=True` 来覆盖掉不需要的设置。具体见[配置相关的文档](https://mmdetection.readthedocs.io/en/latest/tutorials/config.html)。
+
+- __使用动量调度加速模型收敛__:
+  我们支持动量调度器根据学习率修改模型的动量，这可以使模型以更快的方式收敛。动量调度器通常与学习率调度器一起使用，例如 [3D 检测](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/configs/_base_/schedules/cyclic-20e.py) 中使用以下配置以加速收敛。
+  更多细节请参考 [CosineAnnealingLR](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/scheduler/lr_scheduler.py#L43) 和 [CosineAnnealingMomentum](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/scheduler/momentum_scheduler.py#L71) 的具体实现。
+
+  ```python
+  param_scheduler = [
+      # 学习率调度器
+      # 在前 8 个 epoch, 学习率从 0 增大到 lr * 10
+      # 在接下来 12 个 epoch, 学习率从 lr * 10 减小到 lr * 1e-4
+      dict(
+          type='CosineAnnealingLR',
+          T_max=8,
+          eta_min=lr * 10,
+          begin=0,
+          end=8,
+          by_epoch=True,
+          convert_to_iter_based=True),
+      dict(
+          type='CosineAnnealingLR',
+          T_max=12,
+          eta_min=lr * 1e-4,
+          begin=8,
+          end=20,
+          by_epoch=True,
+          convert_to_iter_based=True),
+      # 动量调度器
+      # 在前 8 个 epoch, 动量从 0 增大到 0.85 / 0.95
+      # 在接下来 12 个 epoch, 学习率从 0.85 / 0.95 增大到 1
+      dict(
+          type='CosineAnnealingMomentum',
+          T_max=8,
+          eta_min=0.85 / 0.95,
+          begin=0,
+          end=8,
+          by_epoch=True,
+          convert_to_iter_based=True),
+      dict(
+          type='CosineAnnealingMomentum',
+          T_max=12,
+          eta_min=1,
+          begin=8,
+          end=20,
+          by_epoch=True,
+          convert_to_iter_based=True)
+  ]
+  ```
+
+## 自定义训练策略
+
+默认情况下，我们使用 1x 的学习率调整策略，这会条用 MMEngine 中的 [MultiStepLR](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/scheduler/lr_scheduler.py#L139)。
+我们支持许多其他学习率调整策略，具体见[这里](https://github.com/open-mmlab/mmengine/blob/main/mmengine/optim/scheduler/lr_scheduler.py)，例如 `CosineAnnealingLR` 和 `PolyLR` 策略。下面有些例子
+
+- 多项式学习率调整策略:
+
+  ```python
+  param_scheduler = [
+      dict(
+          type='PolyLR',
+          power=0.9,
+          eta_min=1e-4,
+          begin=0,
+          end=8,
+          by_epoch=True)]
+  ```
+
+- 余弦退火学习率调整策略
+
+  ```python
+  param_scheduler = [
+      dict(
+          type='CosineAnnealingLR',
+          T_max=8,
+          eta_min=lr * 1e-5,
+          begin=0,
+          end=8,
+          by_epoch=True)]
+
+  ```
+
+## 自定义训练循环
+
+默认情况下，在 `train_cfg` 中使用 `EpochBasedTrainLoop`，并且在每个 epoch 训练之后进行验证，如下所示。
+
+```python
+train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=12, val_begin=1, val_interval=1)
+```
+
+实际上，[`IterBasedTrainLoop`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py#L183%5D) 和\[`EpochBasedTrainLoop`\](https:// github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py#L18) 支持动态区间的方式进行验证，见下例。
+
+```python
+# 在第 365001 次迭代之前，我们每 5000 次迭代进行一次评估。
+# 在第 365000 次迭代后，我们每 368750 次迭代进行一次评估，
+# 这意味着我们在训练结束时进行评估。
+
+interval = 5000
+max_iters = 368750
+dynamic_intervals = [(max_iters // interval * interval + 1, max_iters)]
+train_cfg = dict(
+    type='IterBasedTrainLoop',
+    max_iters=max_iters,
+    val_interval=interval,
+    dynamic_intervals=dynamic_intervals)
+```
+
+## 自定义钩子
+
+### 自定义自行实现的钩子
+
+#### 1. 实现一个新的钩子
+
+MMEngine 提供了许多有用的[钩子](https://mmdetection.readthedocs.io/en/latest/tutorials/hooks.html)，但在某些情况下用户可能需要实现新的钩子。MMDetection 在 v3.0 中支持自定义钩子。因此，用户可以直接在 mmdet 或其基于 mmdet 的代码库中实现钩子，并通过仅在训练中修改配置来使用钩子。
+这里我们给出一个在 mmdet 中创建一个新的钩子并在训练中使用它的例子。
+
+```python
+from mmengine.hooks import Hook
+from mmdet.registry import HOOKS
+
+
+@HOOKS.register_module()
+class MyHook(Hook):
+
+    def __init__(self, a, b):
+
+    def before_run(self, runner) -> None:
+
+    def after_run(self, runner) -> None:
+
+    def before_train(self, runner) -> None:
+
+    def after_train(self, runner) -> None:
+
+    def before_train_epoch(self, runner) -> None:
+
+    def after_train_epoch(self, runner) -> None:
+
+    def before_train_iter(self,
+                          runner,
+                          batch_idx: int,
+                          data_batch: DATA_BATCH = None) -> None:
+
+    def after_train_iter(self,
+                         runner,
+                         batch_idx: int,
+                         data_batch: DATA_BATCH = None,
+                         outputs: Optional[dict] = None) -> None:
+```
+
+根据钩子的功能，用户需要在 `before_run`、`after_run`、`before_train`、`after_train`、`before_train_epoch`、`after_train_epoch`、`before_train_iter` 和 `after_train_iter`。还有更多可以插入钩子的点，更多细节请参考 [base hook class](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/hook.py#L9)。
+
+#### 2. 注册新钩子
+
+然后我们需要导入 `MyHook`。假设该文件位于 `mmdet/engine/hooks/my_hook.py` 中，有两种方法可以做到这一点：
+
+- 修改 `mmdet/engine/hooks/__init__.py` 以导入它。
+
+  新定义的模块应该在 `mmdet/engine/hooks/__init__.py` 中导入，以便注册表找到新模块并添加它：
+
+```python
+from .my_hook import MyHook
+```
+
+- 在配置中使用 `custom_imports` 手动导入它
+
+```python
+custom_imports = dict(imports=['mmdet.engine.hooks.my_hook'], allow_failed_imports=False)
+```
+
+#### 3. 修改配置
+
+```python
+custom_hooks = [
+    dict(type='MyHook', a=a_value, b=b_value)
+]
+```
+
+你还可以通过修改键 `priority` 的值为 `NORMAL` 或 `HIGHEST` 来设置挂钩的优先级，如下所示
+
+```python
+custom_hooks = [
+    dict(type='MyHook', a=a_value, b=b_value, priority='NORMAL')
+]
+```
+
+默认情况下，钩子的优先级在注册期间设置为 `NORMAL`。
+
+### 使用 MMDetection 中实现的钩子
+
+如果 MMDetection 中已经实现了该钩子，你可以直接修改配置以使用该钩子，如下所示
+
+#### 例子: `NumClassCheckHook`
+
+我们实现了一个名为 [NumClassCheckHook](https://github.com/open-mmlab/mmdetection/blob/main/mmdet/engine/hooks/num_class_check_hook.py) 的自定义钩子来检查 `num_classes` 是否在 head 中和 `dataset` 中的 `classes` 的长度相匹配。
+
+我们在 [default_runtime.py](https://github.com/open-mmlab/mmdetection/blob/main/configs/_base_/default_runtime.py) 中设置它。
+
+```python
+custom_hooks = [dict(type='NumClassCheckHook')]
+```
+
+### 修改默认运行时钩子
+
+有一些常见的钩子是通过 `default_hooks` 注册的，它们是
+
+- `IterTimerHook`：记录 “data_time” 用于加载数据和 “time” 用于模型训练步骤的钩子。
+- `LoggerHook`：从`Runner`的不同组件收集日志并将它们写入终端、JSON文件、tensorboard和 wandb 等的钩子。
+- `ParamSchedulerHook`：更新优化器中一些超参数的钩子，例如学习率和动量。
+- `CheckpointHook`：定期保存检查点的钩子。
+- `DistSamplerSeedHook`：为采样器和批处理采样器设置种子的钩子。
+- `DetVisualizationHook`：用于可视化验证和测试过程预测结果的钩子。
+
+`IterTimerHook`、`ParamSchedulerHook` 和 `DistSamplerSeedHook` 很简单，通常不需要修改，所以这里我们将展示如何使用 `LoggerHook`、`CheckpointHook` 和 `DetVisualizationHook`。
+
+#### CheckpointHook
+
+除了定期保存检查点，[`CheckpointHook`](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/checkpoint_hook.py#L19) 提供了其他选项，例如`max_keep_ckpts`、`save_optimizer ` 等。用户可以设置 `max_keep_ckpts` 只保存少量检查点或通过 `save_optimizer` 决定是否存储优化器的状态字典。参数的更多细节在[这里](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/checkpoint_hook.py#L19)可以找到。
+
+```python
+default_hooks = dict(
+    checkpoint=dict(
+        type='CheckpointHook',
+        interval=1,
+        max_keep_ckpts=3,
+        save_optimizer=True))
+```
+
+#### LoggerHook
+
+`LoggerHook` 可以设置间隔。详细用法可以在 [docstring](https://github.com/open-mmlab/mmengine/blob/main/mmengine/hooks/logger_hook.py#L18) 中找到。
+
+```python
+default_hooks = dict(logger=dict(type='LoggerHook', interval=50))
+```
+
+#### DetVisualizationHook
+
+`DetVisualizationHook` 使用 `DetLocalVisualizer` 来可视化预测结果，`DetLocalVisualizer` 支持不同的后端，例如 `TensorboardVisBackend` 和 `WandbVisBackend` （见 [docstring](https://github.com/open-mmlab/mmengine/blob/main/mmengine/visualization/vis_backend.py) 了解更多细节）。用户可以添加多个后端来进行可视化，如下所示。
+
+```python
+default_hooks = dict(
+    visualization=dict(type='DetVisualizationHook', draw=True))
+
+vis_backends = [dict(type='LocalVisBackend'),
+                dict(type='TensorboardVisBackend')]
+visualizer = dict(
+    type='DetLocalVisualizer', vis_backends=vis_backends, name='visualizer')
+```
diff --git a/mmdetection/docs/zh_cn/advanced_guides/customize_transforms.md b/mmdetection/docs/zh_cn/advanced_guides/customize_transforms.md
new file mode 100644
index 00000000..aa407179
--- /dev/null
+++ b/mmdetection/docs/zh_cn/advanced_guides/customize_transforms.md
@@ -0,0 +1,47 @@
+# 自定义数据预处理流程
+
+1. 在任意文件里写一个新的流程，例如在 `my_pipeline.py`，它以一个字典作为输入并且输出一个字典：
+
+   ```python
+   import random
+   from mmcv.transforms import BaseTransform
+   from mmdet.registry import TRANSFORMS
+
+
+   @TRANSFORMS.register_module()
+   class MyTransform(BaseTransform):
+       """Add your transform
+
+       Args:
+           p (float): Probability of shifts. Default 0.5.
+       """
+
+       def __init__(self, prob=0.5):
+           self.prob = prob
+
+       def transform(self, results):
+           if random.random() > self.prob:
+               results['dummy'] = True
+           return results
+   ```
+
+2. 在配置文件里调用并使用你写的数据处理流程，需要确保你的训练脚本能够正确导入新增模块：
+
+   ```python
+   custom_imports = dict(imports=['path.to.my_pipeline'], allow_failed_imports=False)
+
+   train_pipeline = [
+       dict(type='LoadImageFromFile'),
+       dict(type='LoadAnnotations', with_bbox=True),
+       dict(type='Resize', scale=(1333, 800), keep_ratio=True),
+       dict(type='RandomFlip', prob=0.5),
+       dict(type='MyTransform', prob=0.2),
+       dict(type='PackDetInputs')
+   ]
+   ```
+
+3. 可视化数据增强处理流程的结果
+
+   如果想要可视化数据增强处理流程的结果，可以使用 `tools/misc/browse_dataset.py` 直观
+   地浏览检测数据集（图像和标注信息），或将图像保存到指定目录。
+   使用方法请参考[可视化文档](../user_guides/visualization.md)
diff --git a/mmdetection/docs/zh_cn/advanced_guides/data_flow.md b/mmdetection/docs/zh_cn/advanced_guides/data_flow.md
new file mode 100644
index 00000000..ccc734f7
--- /dev/null
+++ b/mmdetection/docs/zh_cn/advanced_guides/data_flow.md
@@ -0,0 +1 @@
+# 数据流（待更新）
diff --git a/mmdetection/docs/zh_cn/advanced_guides/datasets.md b/mmdetection/docs/zh_cn/advanced_guides/datasets.md
new file mode 100644
index 00000000..16cc9bfc
--- /dev/null
+++ b/mmdetection/docs/zh_cn/advanced_guides/datasets.md
@@ -0,0 +1 @@
+# 数据集（待更新）
diff --git a/mmdetection/docs/zh_cn/advanced_guides/engine.md b/mmdetection/docs/zh_cn/advanced_guides/engine.md
new file mode 100644
index 00000000..fa1a2561
--- /dev/null
+++ b/mmdetection/docs/zh_cn/advanced_guides/engine.md
@@ -0,0 +1 @@
+# 执行引擎（待更新）
diff --git a/mmdetection/docs/zh_cn/advanced_guides/evaluation.md b/mmdetection/docs/zh_cn/advanced_guides/evaluation.md
new file mode 100644
index 00000000..0b495448
--- /dev/null
+++ b/mmdetection/docs/zh_cn/advanced_guides/evaluation.md
@@ -0,0 +1 @@
+# 精度评测（待更新）
diff --git a/mmdetection/docs/zh_cn/advanced_guides/how_to.md b/mmdetection/docs/zh_cn/advanced_guides/how_to.md
new file mode 100644
index 00000000..6705dafd
--- /dev/null
+++ b/mmdetection/docs/zh_cn/advanced_guides/how_to.md
@@ -0,0 +1,220 @@
+本教程收集了任何如何使用 MMDetection 进行 xxx 的答案。 如果您遇到有关`如何做`的问题及答案，请随时更新此文档！
+
+## 使用 MMPretrain 的骨干网络
+
+MMDet、MMPretrain、MMSeg 中的模型注册表都继承自 MMEngine 中的根注册表，允许这些存储库直接使用彼此已经实现的模块。 因此用户可以在 MMDetection 中使用来自 MMPretrain 的骨干网络，而无需实现MMPretrain 中已经存在的网络。
+
+### 使用在 MMPretrain 中实现的骨干网络
+
+假设想将 `MobileNetV3-small` 作为 `RetinaNet` 的骨干网络，则配置文件如下。
+
+```python
+_base_ = [
+    '../_base_/models/retinanet_r50_fpn.py',
+    '../_base_/datasets/coco_detection.py',
+    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
+]
+# please install mmpretrain
+# import mmpretrain.models to trigger register_module in mmpretrain
+custom_imports = dict(imports=['mmpretrain.models'], allow_failed_imports=False)
+pretrained = 'https://download.openmmlab.com/mmclassification/v0/mobilenet_v3/convert/mobilenet_v3_small-8427ecf0.pth'
+model = dict(
+    backbone=dict(
+        _delete_=True, # 将 _base_ 中关于 backbone 的字段删除
+        type='mmpretrain.MobileNetV3', # 使用 mmpretrain 中的 MobileNetV3
+        arch='small',
+        out_indices=(3, 8, 11), # 修改 out_indices
+        init_cfg=dict(
+            type='Pretrained',
+            checkpoint=pretrained,
+            prefix='backbone.')), # mmpretrain 中骨干网络的预训练权重含义 prefix='backbone.'，为了正常加载权重，需要把这个 prefix 去掉。
+    # 修改 in_channels
+    neck=dict(in_channels=[24, 48, 96], start_level=0))
+```
+
+### 通过 MMPretrain 使用 TIMM 中实现的骨干网络
+
+由于 MMPretrain 提供了 Py**T**orch **Im**age **M**odels (`timm`) 骨干网络的封装，用户也可以通过 MMPretrain 直接使用 `timm` 中的骨干网络。假设想将 [`EfficientNet-B1`](../../../configs/timm_example/retinanet_timm-efficientnet-b1_fpn_1x_coco.py) 作为 `RetinaNet` 的骨干网络，则配置文件如下。
+
+```python
+# https://github.com/open-mmlab/mmdetection/blob/main/configs/timm_example/retinanet_timm_efficientnet_b1_fpn_1x_coco.py
+_base_ = [
+    '../_base_/models/retinanet_r50_fpn.py',
+    '../_base_/datasets/coco_detection.py',
+    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
+]
+
+# please install mmpretrain
+# import mmpretrain.models to trigger register_module in mmpretrain
+custom_imports = dict(imports=['mmpretrain.models'], allow_failed_imports=False)
+model = dict(
+    backbone=dict(
+        _delete_=True, # 将 _base_ 中关于 backbone 的字段删除
+        type='mmpretrain.TIMMBackbone', # 使用 mmpretrain 中 timm 骨干网络
+        model_name='efficientnet_b1',
+        features_only=True,
+        pretrained=True,
+        out_indices=(1, 2, 3, 4)), # 修改 out_indices
+    neck=dict(in_channels=[24, 40, 112, 320])) # 修改 in_channels
+
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)
+```
+
+`type='mmpretrain.TIMMBackbone'` 表示在 MMDetection 中使用 MMPretrain 中的 `TIMMBackbone` 类，并且使用的模型为` EfficientNet-B1`，其中 `mmpretrain` 表示 MMPretrain 库，而 `TIMMBackbone ` 表示 MMPretrain 中实现的 TIMMBackbone 包装器。
+
+关于层次注册器的具体原理可以参考 [MMEngine 文档](https://mmengine.readthedocs.io/zh_cn/latest/tutorials/config.md#跨项目继承配置文件)，关于如何使用 MMPretrain 中的其他 backbone，可以参考 [MMPretrain 文档](https://mmpretrain.readthedocs.io/en/latest/user_guides/config.html)。
+
+## 使用马赛克数据增强
+
+如果你想在训练中使用 `Mosaic`，那么请确保你同时使用 `MultiImageMixDataset`。以 `Faster R-CNN` 算法为例，你可以通过如下做法实现：
+
+```python
+# 直接打开 configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py ,增添如下字段
+data_root = 'data/coco/'
+dataset_type = 'CocoDataset'
+img_scale=(1333, 800)
+
+train_pipeline = [
+    dict(type='Mosaic', img_scale=img_scale, pad_val=114.0),
+    dict(
+        type='RandomAffine',
+        scaling_ratio_range=(0.1, 2),
+        border=(-img_scale[0] // 2, -img_scale[1] // 2)), # 图像经过马赛克处理后会放大4倍，所以我们使用仿射变换来恢复图像的大小。
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs'))
+]
+
+train_dataset = dict(
+    _delete_ = True, # 删除不必要的设置
+    type='MultiImageMixDataset',
+    dataset=dict(
+        type=dataset_type,
+        ann_file=data_root + 'annotations/instances_train2017.json',
+        img_prefix=data_root + 'train2017/',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations', with_bbox=True)
+        ],
+        filter_empty_gt=False,
+    ),
+    pipeline=train_pipeline
+    )
+
+data = dict(
+    train=train_dataset
+    )
+```
+
+## 在配置文件中冻结骨干网络后在训练中解冻骨干网络
+
+如果你在配置文件中已经冻结了骨干网络并希望在几个训练周期后解冻它，你可以通过 hook 来实现这个功能。以用 ResNet 为骨干网络的 Faster R-CNN 为例，你可以冻结一个骨干网络的一个层并在配置文件中添加如下 `custom_hooks`:
+
+```python
+_base_ = [
+    '../_base_/models/faster-rcnn_r50_fpn.py',
+    '../_base_/datasets/coco_detection.py',
+    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
+]
+model = dict(
+    # freeze one stage of the backbone network.
+    backbone=dict(frozen_stages=1),
+)
+custom_hooks = [dict(type="UnfreezeBackboneEpochBasedHook", unfreeze_epoch=1)]
+```
+
+同时在 `mmdet/core/hook/unfreeze_backbone_epoch_based_hook.py` 当中书写 `UnfreezeBackboneEpochBasedHook` 类
+
+```python
+from mmengine.model import is_model_wrapper
+from mmengine.hooks import Hook
+from mmdet.registry import HOOKS
+
+
+@HOOKS.register_module()
+class UnfreezeBackboneEpochBasedHook(Hook):
+    """Unfreeze backbone network Hook.
+
+    Args:
+        unfreeze_epoch (int): The epoch unfreezing the backbone network.
+    """
+
+    def __init__(self, unfreeze_epoch=1):
+        self.unfreeze_epoch = unfreeze_epoch
+
+    def before_train_epoch(self, runner):
+        # Unfreeze the backbone network.
+        # Only valid for resnet.
+        if runner.epoch == self.unfreeze_epoch:
+            model = runner.model
+            if is_module_wrapper(model):
+                model = model.module
+            backbone = model.backbone
+            if backbone.frozen_stages >= 0:
+                if backbone.deep_stem:
+                    backbone.stem.train()
+                    for param in backbone.stem.parameters():
+                        param.requires_grad = True
+                else:
+                    backbone.norm1.train()
+                    for m in [backbone.conv1, backbone.norm1]:
+                        for param in m.parameters():
+                            param.requires_grad = True
+
+            for i in range(1, backbone.frozen_stages + 1):
+                m = getattr(backbone, f'layer{i}')
+                m.train()
+                for param in m.parameters():
+                    param.requires_grad = True
+```
+
+## 获得新的骨干网络的通道数
+
+如果你想获得一个新骨干网络的通道数，你可以单独构建这个骨干网络并输入一个伪造的图片来获取每一个阶段的输出。
+
+以 `ResNet` 为例：
+
+```python
+from mmdet.models import ResNet
+import torch
+self = ResNet(depth=18)
+self.eval()
+inputs = torch.rand(1, 3, 32, 32)
+level_outputs = self.forward(inputs)
+for level_out in level_outputs:
+    print(tuple(level_out.shape))
+
+```
+
+以上脚本的输出为:
+
+```python
+(1, 64, 8, 8)
+(1, 128, 4, 4)
+(1, 256, 2, 2)
+(1, 512, 1, 1)
+```
+
+用户可以通过将脚本中的 `ResNet(depth=18)` 替换为自己的骨干网络配置来得到新的骨干网络的通道数。
+
+# MMDetection 中训练 Detectron2 的模型
+
+用户可以使用 `Detectron2Wrapper` 从而在 MMDetection 中使用 Detectron2 的模型。
+我们提供了 [Faster R-CNN](../../../configs/misc/d2_faster-rcnn_r50-caffe_fpn_ms-90k_coco.py),
+[Mask R-CNN](../../../configs/misc/d2_mask-rcnn_r50-caffe_fpn_ms-90k_coco.py) 和 [RetinaNet](../../../configs/misc/d2_retinanet_r50-caffe_fpn_ms-90k_coco.py) 的示例来在 MMDetection 中训练/测试 Detectron2 的模型。
+
+使用过程中需要注意配置文件中算法组件要和 Detectron2 中的相同。模型初始化时，我们首先初始化 [Detectron2](https://github.com/facebookresearch/detectron2/blob/main/detectron2/config/defaults.py) 的默认设置，然后配置文件中的设置将覆盖默认设置，模型将基于更新过的设置来建立。
+输入数据首先转换成 Detectron2 的类型并输入进 Detectron2 的模型中。在推理阶段，Detectron2 的模型结果将会转换回 MMDetection 的类型。
+
+## 使用 Detectron2 的预训练权重
+
+`Detectron2Wrapper` 中的权重初始化将不使用 MMDetection 的逻辑。用户可以设置 `model.d2_detector.weights=xxx` 来加载预训练的权重。
+例如，我们可以使用 `model.d2_detector.weights='detectron2://ImageNetPretrained/MSRA/R-50.pkl'` 来加载 ResNet-50 的预训练权重，或者使用
+`model.d2_detector.weights='detectron2://COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_1x/137260431/model_final_a54504.pkl'` 来加载 Detectron2 中提出的预训练的Mask R-CNN权重。
+
+**注意：** 不能直接使用 `load_from` 来加载 Detectron2 的预训练模型，但可以通过 `tools/model_converters/detectron2_to_mmdet.py` 先对该预训练模型进行转换。
+
+在测试时，用户应该首先使用 `tools/model_converters/detectron2_to_mmdet.py` 将 Detectron2 的预训练权重转换为 MMDetection 可读取的结构。
+
+```shell
+python tools/model_converters/detectron2_to_mmdet.py ${Detectron2 ckpt path} ${MMDetectron ckpt path}。
+```
diff --git a/mmdetection/docs/zh_cn/advanced_guides/index.rst b/mmdetection/docs/zh_cn/advanced_guides/index.rst
new file mode 100644
index 00000000..8e925394
--- /dev/null
+++ b/mmdetection/docs/zh_cn/advanced_guides/index.rst
@@ -0,0 +1,34 @@
+基础概念
+***************
+
+.. toctree::
+   :maxdepth: 1
+
+   data_flow.md
+   structures.md
+   models.md
+   datasets.md
+   transforms.md
+   evaluation.md
+   engine.md
+   conventions.md
+
+组件定制
+************************
+
+.. toctree::
+   :maxdepth: 1
+
+   customize_models.md
+   customize_losses.md
+   customize_dataset.md
+   customize_transforms.md
+   customize_runtime.md
+
+How to
+************************
+
+.. toctree::
+   :maxdepth: 1
+
+   how_to.md
diff --git a/mmdetection/docs/zh_cn/advanced_guides/models.md b/mmdetection/docs/zh_cn/advanced_guides/models.md
new file mode 100644
index 00000000..c5119d06
--- /dev/null
+++ b/mmdetection/docs/zh_cn/advanced_guides/models.md
@@ -0,0 +1 @@
+# 模型（待更新）
diff --git a/mmdetection/docs/zh_cn/advanced_guides/structures.md b/mmdetection/docs/zh_cn/advanced_guides/structures.md
new file mode 100644
index 00000000..c2118c34
--- /dev/null
+++ b/mmdetection/docs/zh_cn/advanced_guides/structures.md
@@ -0,0 +1 @@
+# 数据结构（待更新）
diff --git a/mmdetection/docs/zh_cn/advanced_guides/transforms.md b/mmdetection/docs/zh_cn/advanced_guides/transforms.md
new file mode 100644
index 00000000..07d7db24
--- /dev/null
+++ b/mmdetection/docs/zh_cn/advanced_guides/transforms.md
@@ -0,0 +1,43 @@
+# 数据变换（待更新）
+
+按照惯例，我们使用 `Dataset` 和 `DataLoader` 进行多进程的数据加载。`Dataset` 返回字典类型的数据，数据内容为模型 `forward` 方法的各个参数。由于在目标检测中，输入的图像数据具有不同的大小，我们在 `MMCV` 里引入一个新的 `DataContainer` 类去收集和分发不同大小的输入数据。更多细节请参考[这里](https://github.com/open-mmlab/mmcv/blob/master/mmcv/parallel/data_container.py)。
+
+数据的准备流程和数据集是解耦的。通常一个数据集定义了如何处理标注数据（annotations）信息，而一个数据流程定义了准备一个数据字典的所有步骤。一个流程包括一系列的操作，每个操作都把一个字典作为输入，然后再输出一个新的字典给下一个变换操作。
+
+我们在下图展示了一个经典的数据处理流程。蓝色块是数据处理操作，随着数据流程的处理，每个操作都可以在结果字典中加入新的键（标记为绿色）或更新现有的键（标记为橙色）。
+
+![pipeline figure](../../../resources/data_pipeline.png)
+
+这些操作可以分为数据加载（data loading）、预处理（pre-processing）、格式变化（formatting）和测试时数据增强（test-time augmentation）。
+
+下面的例子是 `Faster R-CNN` 的一个流程：
+
+```python
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(type='Resize', img_scale=(1333, 800), keep_ratio=True),
+    dict(type='RandomFlip', flip_ratio=0.5),
+    dict(type='Normalize', **img_norm_cfg),
+    dict(type='Pad', size_divisor=32),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']),
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(1333, 800),
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(type='Normalize', **img_norm_cfg),
+            dict(type='Pad', size_divisor=32),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img']),
+        ])
+]
+```
diff --git a/mmdetection/docs/zh_cn/api.rst b/mmdetection/docs/zh_cn/api.rst
new file mode 100644
index 00000000..1b127321
--- /dev/null
+++ b/mmdetection/docs/zh_cn/api.rst
@@ -0,0 +1,161 @@
+mmdet.apis
+--------------
+.. automodule:: mmdet.apis
+    :members:
+
+mmdet.datasets
+--------------
+
+datasets
+^^^^^^^^^^
+.. automodule:: mmdet.datasets
+    :members:
+
+api_wrappers
+^^^^^^^^^^^^^^^^^
+.. automodule:: mmdet.datasets.api_wrappers
+    :members:
+
+samplers
+^^^^^^^^^^
+.. automodule:: mmdet.datasets.samplers
+    :members:
+
+transforms
+^^^^^^^^^^^^
+.. automodule:: mmdet.datasets.transforms
+    :members:
+
+mmdet.engine
+--------------
+
+hooks
+^^^^^^^^^^
+.. automodule:: mmdet.engine.hooks
+    :members:
+
+optimizers
+^^^^^^^^^^^^^^^
+.. automodule:: mmdet.engine.optimizers
+    :members:
+
+runner
+^^^^^^^^^^
+.. automodule:: mmdet.engine.runner
+    :members:
+
+schedulers
+^^^^^^^^^^^^^^^^^
+.. automodule:: mmdet.engine.schedulers
+    :members:
+
+mmdet.evaluation
+--------------------
+
+functional
+^^^^^^^^^^^^^^^^^
+.. automodule:: mmdet.evaluation.functional
+    :members:
+
+metrics
+^^^^^^^^^^
+.. automodule:: mmdet.evaluation.metrics
+    :members:
+
+
+mmdet.models
+--------------
+
+backbones
+^^^^^^^^^^^^^^^^^^
+.. automodule:: mmdet.models.backbones
+    :members:
+
+data_preprocessors
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+.. automodule:: mmdet.models.data_preprocessors
+    :members:
+
+dense_heads
+^^^^^^^^^^^^^^^
+.. automodule:: mmdet.models.dense_heads
+    :members:
+
+detectors
+^^^^^^^^^^
+.. automodule:: mmdet.models.detectors
+    :members:
+
+layers
+^^^^^^^^^^
+.. automodule:: mmdet.models.layers
+    :members:
+
+losses
+^^^^^^^^^^
+.. automodule:: mmdet.models.losses
+    :members:
+
+necks
+^^^^^^^^^^^^
+.. automodule:: mmdet.models.necks
+    :members:
+
+roi_heads
+^^^^^^^^^^^^^
+.. automodule:: mmdet.models.roi_heads
+    :members:
+
+seg_heads
+^^^^^^^^^^^^^
+.. automodule:: mmdet.models.seg_heads
+    :members:
+
+task_modules
+^^^^^^^^^^^^^
+.. automodule:: mmdet.models.task_modules
+    :members:
+
+test_time_augs
+^^^^^^^^^^^^^^^^^^^^
+.. automodule:: mmdet.models.test_time_augs
+    :members:
+
+utils
+^^^^^^^^^^
+.. automodule:: mmdet.models.utils
+    :members:
+
+
+mmdet.structures
+--------------------
+
+structures
+^^^^^^^^^^^^^^^^^
+.. automodule:: mmdet.structures
+    :members:
+
+bbox
+^^^^^^^^^^
+.. automodule:: mmdet.structures.bbox
+    :members:
+
+mask
+^^^^^^^^^^
+.. automodule:: mmdet.structures.mask
+    :members:
+
+mmdet.testing
+----------------
+.. automodule:: mmdet.testing
+    :members:
+
+mmdet.visualization
+--------------------
+.. automodule:: mmdet.visualization
+    :members:
+
+mmdet.utils
+--------------
+.. automodule:: mmdet.utils
+    :members:
diff --git a/mmdetection/docs/zh_cn/article.md b/mmdetection/docs/zh_cn/article.md
new file mode 100644
index 00000000..3b698308
--- /dev/null
+++ b/mmdetection/docs/zh_cn/article.md
@@ -0,0 +1,53 @@
+## 中文解读文案汇总（待更新）
+
+### 1 官方解读文案（v2.x）
+
+#### 1.1 框架解读
+
+- **[轻松掌握 MMDetection 整体构建流程(一)](https://zhuanlan.zhihu.com/p/337375549)**
+- **[轻松掌握 MMDetection 整体构建流程(二)](https://zhuanlan.zhihu.com/p/341954021)**
+- **[轻松掌握 MMDetection 中 Head 流程](https://zhuanlan.zhihu.com/p/343433169)**
+
+#### 1.2 算法解读
+
+- **[轻松掌握 MMDetection 中常用算法(一)：RetinaNet 及配置详解](https://zhuanlan.zhihu.com/p/346198300)**
+- **[轻松掌握 MMDetection 中常用算法(二)：Faster R-CNN|Mask R-CNN](https://zhuanlan.zhihu.com/p/349807581)**
+- [轻松掌握 MMDetection 中常用算法(三)：FCOS](https://zhuanlan.zhihu.com/p/358056615)
+- [轻松掌握 MMDetection 中常用算法(四)：ATSS](https://zhuanlan.zhihu.com/p/358125611)
+- [轻松掌握 MMDetection 中常用算法(五)：Cascade R-CNN](https://zhuanlan.zhihu.com/p/360952172)
+- [轻松掌握 MMDetection 中常用算法(六)：YOLOF](https://zhuanlan.zhihu.com/p/370758213)
+- [轻松掌握 MMDetection 中常用算法(七)：CenterNet](https://zhuanlan.zhihu.com/p/374891478)
+- [轻松掌握 MMDetection 中常用算法(八)：YOLACT](https://zhuanlan.zhihu.com/p/376347955)
+- [轻松掌握 MMDetection 中常用算法(九)：AutoAssign](https://zhuanlan.zhihu.com/p/378581552)
+- [YOLOX 在 MMDetection 中复现全流程解析](https://zhuanlan.zhihu.com/p/398545304)
+- [喂喂喂！你可以减重了！小模型 - MMDetection 新增SSDLite 、 MobileNetV2YOLOV3 两大经典算法](https://zhuanlan.zhihu.com/p/402781143)
+
+#### 1.3 工具解读
+
+- [OpenMMLab 中混合精度训练 AMP 的正确打开方式](https://zhuanlan.zhihu.com/p/375224982)
+- [小白都能看懂！手把手教你使用混淆矩阵分析目标检测](https://zhuanlan.zhihu.com/p/443499860)
+- [MMDetection 图像缩放 Resize 详细说明 OpenMMLab](https://zhuanlan.zhihu.com/p/381117525)
+- [拿什么拯救我的 4G 显卡](https://zhuanlan.zhihu.com/p/430123077)
+- [MMDet居然能用MMCls的Backbone？论配置文件的打开方式](https://zhuanlan.zhihu.com/p/436865195)
+
+#### 1.4 知乎问答
+
+- [COCO数据集上1x模式下为什么不采用多尺度训练?](https://www.zhihu.com/question/462170786/answer/1915119662)
+- [MMDetection中SOTA论文源码中将训练过程中BN层的eval打开?](https://www.zhihu.com/question/471189603/answer/2195540892)
+- [基于PyTorch的MMDetection中训练的随机性来自何处？](https://www.zhihu.com/question/453511684/answer/1839683634)
+- [单阶段、双阶段、anchor-based、anchor-free 这四者之间有什么联系吗？](https://www.zhihu.com/question/428972054/answer/1619925296)
+- [目标检测的深度学习方法，有推荐的书籍或资料吗？](https://www.zhihu.com/question/391577080/answer/1612593817)
+- [大佬们，刚入学研究生，想入门目标检测，有什么学习路线可以入门的？](https://www.zhihu.com/question/343768934/answer/1612580715)
+- [目标检测领域还有什么可以做的？](https://www.zhihu.com/question/280703314/answer/1627885518)
+- [如何看待Transformer在CV上的应用前景，未来有可能替代CNN吗？](https://www.zhihu.com/question/437495132/answer/1686380553)
+- [MMDetection如何学习源码？](https://www.zhihu.com/question/451585041/answer/1832498963)
+- [如何具体上手实现目标检测呢？](https://www.zhihu.com/question/341401981/answer/1848561187)
+
+#### 1.5 其他
+
+- **[不得不知的 MMDetection 学习路线(个人经验版)](https://zhuanlan.zhihu.com/p/369826931)**
+- [OpenMMLab 社区专访之 YOLOX 复现篇](https://zhuanlan.zhihu.com/p/405913343)
+
+### 2 社区解读文案（v2.x）
+
+- [手把手带你实现经典检测网络 Mask R-CNN 的推理](https://zhuanlan.zhihu.com/p/414082071)
diff --git a/mmdetection/docs/zh_cn/conf.py b/mmdetection/docs/zh_cn/conf.py
new file mode 100644
index 00000000..e6878408
--- /dev/null
+++ b/mmdetection/docs/zh_cn/conf.py
@@ -0,0 +1,118 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+import os
+import subprocess
+import sys
+
+import pytorch_sphinx_theme
+
+sys.path.insert(0, os.path.abspath('../../'))
+
+# -- Project information -----------------------------------------------------
+
+project = 'MMDetection'
+copyright = '2018-2021, OpenMMLab'
+author = 'MMDetection Authors'
+version_file = '../../mmdet/version.py'
+
+
+def get_version():
+    with open(version_file, 'r') as f:
+        exec(compile(f.read(), version_file, 'exec'))
+    return locals()['__version__']
+
+
+# The full version, including alpha/beta/rc tags
+release = get_version()
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    'sphinx.ext.autodoc',
+    'sphinx.ext.napoleon',
+    'sphinx.ext.viewcode',
+    'myst_parser',
+    'sphinx_markdown_tables',
+    'sphinx_copybutton',
+]
+
+myst_enable_extensions = ['colon_fence']
+myst_heading_anchors = 3
+
+autodoc_mock_imports = [
+    'matplotlib', 'pycocotools', 'terminaltables', 'mmdet.version', 'mmcv.ops'
+]
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+#
+source_suffix = {
+    '.rst': 'restructuredtext',
+    '.md': 'markdown',
+}
+
+# The main toctree document.
+master_doc = 'index'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+# html_theme = 'sphinx_rtd_theme'
+html_theme = 'pytorch_sphinx_theme'
+html_theme_path = [pytorch_sphinx_theme.get_html_theme_path()]
+
+html_theme_options = {
+    'menu': [
+        {
+            'name': 'GitHub',
+            'url': 'https://github.com/open-mmlab/mmdetection'
+        },
+    ],
+    # Specify the language of shared menu
+    'menu_lang':
+    'cn',
+}
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+html_css_files = ['css/readthedocs.css']
+
+language = 'zh_CN'
+
+# -- Extension configuration -------------------------------------------------
+# Ignore >>> when copying code
+copybutton_prompt_text = r'>>> |\.\.\. '
+copybutton_prompt_is_regexp = True
+
+
+def builder_inited_handler(app):
+    subprocess.run(['./stat.py'])
+
+
+def setup(app):
+    app.connect('builder-inited', builder_inited_handler)
diff --git a/mmdetection/docs/zh_cn/get_started.md b/mmdetection/docs/zh_cn/get_started.md
new file mode 100644
index 00000000..52d061ef
--- /dev/null
+++ b/mmdetection/docs/zh_cn/get_started.md
@@ -0,0 +1,230 @@
+# 开始你的第一步
+
+## 依赖
+
+本节中，我们将演示如何用 PyTorch 准备一个环境。
+
+MMDetection 支持在 Linux，Windows 和 macOS 上运行。它需要 Python 3.7 以上，CUDA 9.2 以上和 PyTorch 1.8 及其以上。
+
+```{note}
+如果你对 PyTorch 有经验并且已经安装了它，你可以直接跳转到[下一小节](#安装流程)。否则，你可以按照下述步骤进行准备。
+```
+
+**步骤 0.** 从[官方网站](https://docs.conda.io/en/latest/miniconda.html)下载并安装 Miniconda。
+
+**步骤 1.** 创建并激活一个 conda 环境。
+
+```shell
+conda create --name openmmlab python=3.8 -y
+conda activate openmmlab
+```
+
+**步骤 2.** 基于 [PyTorch 官方说明](https://pytorch.org/get-started/locally/)安装 PyTorch。
+
+在 GPU 平台上：
+
+```shell
+conda install pytorch torchvision -c pytorch
+```
+
+在 CPU 平台上：
+
+```shell
+conda install pytorch torchvision cpuonly -c pytorch
+```
+
+## 安装流程
+
+我们推荐用户参照我们的最佳实践安装 MMDetection。不过，整个过程也是可定制化的，更多信息请参考[自定义安装](#自定义安装)章节。
+
+### 最佳实践
+
+**步骤 0.** 使用 [MIM](https://github.com/open-mmlab/mim) 安装 [MMEngine](https://github.com/open-mmlab/mmengine) 和 [MMCV](https://github.com/open-mmlab/mmcv)。
+
+```shell
+pip install -U openmim
+mim install mmengine
+mim install "mmcv>=2.0.0"
+```
+
+**注意：** 在 MMCV-v2.x 中，`mmcv-full` 改名为 `mmcv`，如果你想安装不包含 CUDA 算子精简版，可以通过 `mim install "mmcv-lite>=2.0.0rc1"` 来安装。
+
+**步骤 1.** 安装 MMDetection。
+
+方案 a：如果你开发并直接运行 mmdet，从源码安装它：
+
+```shell
+git clone https://github.com/open-mmlab/mmdetection.git
+cd mmdetection
+pip install -v -e .
+# "-v" 指详细说明，或更多的输出
+# "-e" 表示在可编辑模式下安装项目，因此对代码所做的任何本地修改都会生效，从而无需重新安装。
+```
+
+方案 b：如果你将 mmdet 作为依赖或第三方 Python 包，使用 MIM 安装：
+
+```shell
+mim install mmdet
+```
+
+## 验证安装
+
+为了验证 MMDetection 是否安装正确，我们提供了一些示例代码来执行模型推理。
+
+**步骤 1.** 我们需要下载配置文件和模型权重文件。
+
+```shell
+mim download mmdet --config rtmdet_tiny_8xb32-300e_coco --dest .
+```
+
+下载将需要几秒钟或更长时间，这取决于你的网络环境。完成后，你会在当前文件夹中发现两个文件 `rtmdet_tiny_8xb32-300e_coco.py` 和 `rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth`。
+
+**步骤 2.** 推理验证。
+
+方案 a：如果你通过源码安装的 MMDetection，那么直接运行以下命令进行验证：
+
+```shell
+python demo/image_demo.py demo/demo.jpg rtmdet_tiny_8xb32-300e_coco.py --weights rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth --device cpu
+```
+
+你会在当前文件夹中的 `outputs/vis` 文件夹中看到一个新的图像 `demo.jpg`，图像中包含有网络预测的检测框。
+
+方案 b：如果你通过 MIM 安装的 MMDetection，那么可以打开你的 Python 解析器，复制并粘贴以下代码：
+
+```python
+from mmdet.apis import init_detector, inference_detector
+
+config_file = 'rtmdet_tiny_8xb32-300e_coco.py'
+checkpoint_file = 'rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth'
+model = init_detector(config_file, checkpoint_file, device='cpu')  # or device='cuda:0'
+inference_detector(model, 'demo/demo.jpg')
+```
+
+你将会看到一个包含 `DetDataSample` 的列表，预测结果在 `pred_instance` 里，包含有检测框，类别和得分。
+
+### 自定义安装
+
+#### CUDA 版本
+
+在安装 PyTorch 时，你需要指定 CUDA 的版本。如果你不清楚应该选择哪一个，请遵循我们的建议：
+
+- 对于 Ampere 架构的 NVIDIA GPU，例如 GeForce 30 系列以及 NVIDIA A100，CUDA 11 是必需的。
+- 对于更早的 NVIDIA GPU，CUDA 11 是向后兼容 (backward compatible) 的，但 CUDA 10.2 能够提供更好的兼容性，也更加轻量。
+
+请确保你的 GPU 驱动版本满足最低的版本需求，参阅 NVIDIA 官方的 [CUDA 工具箱和相应的驱动版本关系表](https://docs.nvidia.com/cuda/cuda-toolkit-release-notes/index.html#cuda-major-component-versions__table-cuda-toolkit-driver-versions)。
+
+```{note}
+如果按照我们的最佳实践，安装 CUDA 运行时库就足够了，这是因为不需要在本地编译 CUDA 代码。但如果你希望从源码编译 MMCV，或是开发其他 CUDA 算子，那么就必须安装完整的 CUDA 工具链，参见 [NVIDIA 官网](https://developer.nvidia.com/cuda-downloads)，另外还需要确保该 CUDA 工具链的版本与 PyTorch 安装时的配置相匹配（如用 `conda install` 安装 PyTorch 时指定的 cudatoolkit 版本）。
+```
+
+#### 不使用 MIM 安装 MMEngine
+
+要使用 pip 而不是 MIM 来安装 MMEngine，请遵照 [MMEngine 安装指南](https://mmengine.readthedocs.io/zh_CN/latest/get_started/installation.html)。
+
+例如，你可以通过以下命令安装 MMEngine。
+
+```shell
+pip install mmengine
+```
+
+#### 不使用 MIM 安装 MMCV
+
+MMCV 包含 C++ 和 CUDA 扩展，因此其对 PyTorch 的依赖比较复杂。MIM 会自动解析这些依赖，选择合适的 MMCV 预编译包，使安装更简单，但它并不是必需的。
+
+要使用 pip 而不是 MIM 来安装 MMCV，请遵照 [MMCV 安装指南](https://mmcv.readthedocs.io/zh_CN/2.x/get_started/installation.html)。它需要您用指定 url 的形式手动指定对应的 PyTorch 和 CUDA 版本。
+
+例如，下述命令将会安装基于 PyTorch 1.12.x 和 CUDA 11.6 编译的 MMCV。
+
+```shell
+pip install "mmcv>=2.0.0" -f https://download.openmmlab.com/mmcv/dist/cu116/torch1.12.0/index.html
+```
+
+#### 在 CPU 环境中安装
+
+MMDetection 可以在 CPU 环境中构建。在 CPU 模式下，可以进行模型训练（需要 MMCV 版本 >= 2.0.0rc1）、测试或者推理。
+
+但是，以下功能在该模式下不能使用：
+
+- Deformable Convolution
+- Modulated Deformable Convolution
+- ROI pooling
+- Deformable ROI pooling
+- CARAFE
+- SyncBatchNorm
+- CrissCrossAttention
+- MaskedConv2d
+- Temporal Interlace Shift
+- nms_cuda
+- sigmoid_focal_loss_cuda
+- bbox_overlaps
+
+因此，如果尝试训练/测试/推理包含上述算子的模型，将会报错。下表列出了将会受影响的相关算法。
+
+|                          操作                           |                                           模型                                           |
+| :-----------------------------------------------------: | :--------------------------------------------------------------------------------------: |
+| Deformable Convolution/Modulated Deformable Convolution | DCN、Guided Anchoring、RepPoints、CentripetalNet、VFNet、CascadeRPN、NAS-FCOS、DetectoRS |
+|                      MaskedConv2d                       |                                     Guided Anchoring                                     |
+|                         CARAFE                          |                                          CARAFE                                          |
+|                      SyncBatchNorm                      |                                         ResNeSt                                          |
+
+#### 在 Google Colab 中安装
+
+[Google Colab](https://colab.research.google.com/) 通常已经包含了 PyTorch 环境，因此我们只需要安装 MMEngine，MMCV 和 MMDetection 即可，命令如下：
+
+**步骤 1.** 使用 [MIM](https://github.com/open-mmlab/mim) 安装 [MMEngine](https://github.com/open-mmlab/mmengine) 和 [MMCV](https://github.com/open-mmlab/mmcv)。
+
+```shell
+!pip3 install openmim
+!mim install mmengine
+!mim install "mmcv>=2.0.0,<2.1.0"
+```
+
+**步骤 2.** 使用源码安装 MMDetection。
+
+```shell
+!git clone https://github.com/open-mmlab/mmdetection.git
+%cd mmdetection
+!pip install -e .
+```
+
+**步骤 3.** 验证安装是否成功。
+
+```python
+import mmdet
+print(mmdet.__version__)
+# 预期输出：3.0.0 或其他版本号
+```
+
+```{note}
+在 Jupyter Notebook 中，感叹号 `!` 用于执行外部命令，而 `%cd` 是一个[魔术命令](https://ipython.readthedocs.io/en/stable/interactive/magics.html#magic-cd)，用于切换 Python 的工作路径。
+```
+
+#### 通过 Docker 使用 MMDetection
+
+我们提供了一个 [Dockerfile](../../docker/Dockerfile) 来构建一个镜像。请确保你的 [docker 版本](https://docs.docker.com/engine/install/) >=19.03。
+
+```shell
+# 基于 PyTorch 1.9，CUDA 11.1 构建镜像
+# 如果你想要其他版本，只需要修改 Dockerfile
+docker build -t mmdetection docker/
+```
+
+用以下命令运行 Docker 镜像：
+
+```shell
+docker run --gpus all --shm-size=8g -it -v {DATA_DIR}:/mmdetection/data mmdetection
+```
+
+### 排除故障
+
+如果你在安装过程中遇到一些问题，请先查看 [FAQ](notes/faq.md) 页面。如果没有找到解决方案，你也可以在 GitHub 上[提出一个问题](https://github.com/open-mmlab/mmdetection/issues/new/choose)。
+
+### 使用多个 MMDetection 版本进行开发
+
+训练和测试的脚本已经在 `PYTHONPATH` 中进行了修改，以确保脚本使用当前目录中的 MMDetection。
+
+要使环境中安装默认版本的 MMDetection 而不是当前正在使用的，可以删除出现在相关脚本中的代码：
+
+```shell
+PYTHONPATH="$(dirname $0)/..":$PYTHONPATH
+```
diff --git a/mmdetection/docs/zh_cn/index.rst b/mmdetection/docs/zh_cn/index.rst
new file mode 100644
index 00000000..58a4d8a5
--- /dev/null
+++ b/mmdetection/docs/zh_cn/index.rst
@@ -0,0 +1,67 @@
+Welcome to MMDetection's documentation!
+=======================================
+
+.. toctree::
+   :maxdepth: 1
+   :caption: 开始你的第一步
+
+   overview.md
+   get_started.md
+
+.. toctree::
+   :maxdepth: 2
+   :caption: 使用指南
+
+   user_guides/index.rst
+
+.. toctree::
+   :maxdepth: 2
+   :caption: 进阶教程
+
+   advanced_guides/index.rst
+
+.. toctree::
+   :maxdepth: 1
+   :caption: 迁移版本
+
+   migration/migration.md
+
+.. toctree::
+   :maxdepth: 1
+   :caption: 接口文档（英文）
+
+   api.rst
+
+.. toctree::
+   :maxdepth: 1
+   :caption: 模型仓库
+
+   model_zoo.md
+
+.. toctree::
+   :maxdepth: 1
+   :caption: 说明
+
+   notes/contribution_guide.md
+   notes/projects.md
+   notes/faq.md
+   notes/compatibility.md
+
+.. toctree::
+   :maxdepth: 1
+   :caption: 文章
+
+   article.md
+
+.. toctree::
+   :caption: 语言切换
+
+   switch_language.md
+
+
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`search`
diff --git a/mmdetection/docs/zh_cn/make.bat b/mmdetection/docs/zh_cn/make.bat
new file mode 100644
index 00000000..922152e9
--- /dev/null
+++ b/mmdetection/docs/zh_cn/make.bat
@@ -0,0 +1,35 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=.
+set BUILDDIR=_build
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.http://sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd
diff --git a/mmdetection/docs/zh_cn/migration/api_and_registry_migration.md b/mmdetection/docs/zh_cn/migration/api_and_registry_migration.md
new file mode 100644
index 00000000..66e1c340
--- /dev/null
+++ b/mmdetection/docs/zh_cn/migration/api_and_registry_migration.md
@@ -0,0 +1 @@
+# 将 API 和注册器从 MMDetection 2.x 迁移至 3.x
diff --git a/mmdetection/docs/zh_cn/migration/config_migration.md b/mmdetection/docs/zh_cn/migration/config_migration.md
new file mode 100644
index 00000000..c4f9c8e3
--- /dev/null
+++ b/mmdetection/docs/zh_cn/migration/config_migration.md
@@ -0,0 +1,814 @@
+# 将配置文件从 MMDetection 2.x 迁移至 3.x
+
+MMDetection 3.x 的配置文件与 2.x 相比有较大变化，这篇文档将介绍如何将 2.x 的配置文件迁移到 3.x。
+
+在前面的[配置文件教程](../user_guides/config.md)中，我们以 Mask R-CNN 为例介绍了 MMDetection 3.x 的配置文件结构，这里我们将按同样的结构介绍如何将 2.x 的配置文件迁移至 3.x。
+
+## 模型配置
+
+模型的配置与 2.x 相比并没有太大变化，对于模型的 backbone，neck，head，以及 train_cfg 和 test_cfg，它们的参数与 2.x 版本的参数保持一致。
+
+不同的是，我们在 3.x 版本的模型中新增了 `DataPreprocessor` 模块。
+`DataPreprocessor` 模块的配置位于 `model.data_preprocessor` 中，它用于对输入数据进行预处理，例如对输入图像进行归一化，将不同大小的图片进行 padding 从而组成 batch，将图像从内存中读取到显存中等。这部分配置取代了原本存在于 train_pipeline 和 test_pipeline 中的 `Normalize` 和 `Pad`。
+
+
+
+
+
+
+
+
+
+
    原配置
+
+```python
+# 图像归一化参数
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    to_rgb=True)
+pipeline=[
+    ...,
+    dict(type='Normalize', **img_norm_cfg),
+    dict(type='Pad', size_divisor=32),  # 图像 padding 到 32 的倍数
+    ...
+]
+```
+
+
    新配置
+
+```python
+model = dict(
+    data_preprocessor=dict(
+        type='DetDataPreprocessor',
+        # 图像归一化参数
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        bgr_to_rgb=True,
+        # 图像 padding 参数
+        pad_mask=True,  # 在实例分割中，需要将 mask 也进行 padding
+        pad_size_divisor=32)  # 图像 padding 到 32 的倍数
+)
+```
+
+
    
+
+## 数据集和评测器配置
+
+数据集和评测部分的配置相比 2.x 版本有较大的变化。我们将从 Dataloader 和 Dataset，Data transform pipeline，以及评测器配置三个方面介绍如何将 2.x 版本的配置迁移到 3.x 版本。
+
+### Dataloader 和 Dataset 配置
+
+在新版本中，我们将数据加载的设置与 PyTorch 官方的 DataLoader 保持一致，这样可以使用户更容易理解和上手。
+我们将训练、验证和测试的数据加载设置分别放在 `train_dataloader`，`val_dataloader` 和 `test_dataloader` 中，用户可以分别对这些 dataloader 设置不同的参数，其输入参数与 [PyTorch 的 Dataloader](https://pytorch.org/docs/stable/data.html?highlight=dataloader#torch.utils.data.DataLoader) 所需要的参数基本一致。
+
+通过这种方式，我们将 2.x 版本中不可配置的 `sampler`，`batch_sampler`，`persistent_workers` 等参数都放到了配置文件中，使得用户可以更加灵活地设置数据加载的参数。
+
+用户可以通过 `train_dataloader.dataset`，`val_dataloader.dataset` 和 `test_dataloader.dataset` 来设置数据集的配置，它们分别对应 2.x 版本中的 `data.train`，`data.val` 和 `data.test`。
+
+
+
+
+
+
+
+
+
+
    原配置
+
+```python
+data = dict(
+    samples_per_gpu=2,
+    workers_per_gpu=2,
+    train=dict(
+        type=dataset_type,
+        ann_file=data_root + 'annotations/instances_train2017.json',
+        img_prefix=data_root + 'train2017/',
+        pipeline=train_pipeline),
+    val=dict(
+        type=dataset_type,
+        ann_file=data_root + 'annotations/instances_val2017.json',
+        img_prefix=data_root + 'val2017/',
+        pipeline=test_pipeline),
+    test=dict(
+        type=dataset_type,
+        ann_file=data_root + 'annotations/instances_val2017.json',
+        img_prefix=data_root + 'val2017/',
+        pipeline=test_pipeline))
+```
+
+
    新配置
+
+```python
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=2,
+    persistent_workers=True,  # 避免每次迭代后 dataloader 重新创建子进程
+    sampler=dict(type='DefaultSampler', shuffle=True),  # 默认的 sampler，同时支持分布式训练和非分布式训练
+    batch_sampler=dict(type='AspectRatioBatchSampler'),  # 默认的 batch_sampler，用于保证 batch 中的图片具有相似的长宽比，从而可以更好地利用显存
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='annotations/instances_train2017.json',
+        data_prefix=dict(img='train2017/'),
+        filter_cfg=dict(filter_empty_gt=True, min_size=32),
+        pipeline=train_pipeline))
+# 在 3.x 版本中可以独立配置验证和测试的 dataloader
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='annotations/instances_val2017.json',
+        data_prefix=dict(img='val2017/'),
+        test_mode=True,
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader  # 测试 dataloader 的配置与验证 dataloader 的配置相同，这里省略
+```
+
+
    
+
+### Data transform pipeline 配置
+
+上文中提到，我们将图像 normalize 和 padding 的配置从 `train_pipeline` 和 `test_pipeline` 中独立出来，放到了 `model.data_preprocessor` 中，因此在 3.x 版本的 pipeline 中，我们不再需要 `Normalize` 和 `Pad` 这两个 transform。
+
+同时，我们也对负责数据格式打包的 transform 进行了重构，将 `Collect` 和 `DefaultFormatBundle` 这两个 transform 合并为了 `PackDetInputs`，它负责将 data pipeline 中的数据打包成模型的输入格式，关于输入格式的转换，详见[数据流文档](../advanced_guides/data_flow.md)。
+
+下面以 Mask R-CNN 1x 的 train_pipeline 为例，介绍如何将 2.x 版本的配置迁移到 3.x 版本：
+
+
+
+
+
+
+
+
+
+
    原配置
+
+```python
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(type='Resize', img_scale=(1333, 800), keep_ratio=True),
+    dict(type='RandomFlip', flip_ratio=0.5),
+    dict(type='Normalize', **img_norm_cfg),
+    dict(type='Pad', size_divisor=32),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']),
+]
+```
+
+
    新配置
+
+```python
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(type='Resize', scale=(1333, 800), keep_ratio=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs')
+]
+```
+
+
    
+
+对于 test_pipeline，除了将 `Normalize` 和 `Pad` 这两个 transform 去掉之外，我们也将测试时的数据增强（TTA）与普通的测试流程分开，移除了 `MultiScaleFlipAug`。关于新版的 TTA 如何使用，详见[TTA 文档](../advanced_guides/tta.md)。
+
+下面同样以 Mask R-CNN 1x 的 test_pipeline 为例，介绍如何将 2.x 版本的配置迁移到 3.x 版本：
+
+
+
+
+
+
+
+
+
+
    原配置
+
+```python
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(1333, 800),
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(type='Normalize', **img_norm_cfg),
+            dict(type='Pad', size_divisor=32),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img']),
+        ])
+]
+```
+
+
    新配置
+
+```python
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(1333, 800), keep_ratio=True),
+    dict(
+        type='PackDetInputs',
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+```
+
+
    
+
+除此之外，我们还对一些数据增强进行了重构，下表列出了 2.x 版本中的 transform 与 3.x 版本中的 transform 的对应关系：
+
+
+
+  
+    
+    
+    
+  
+
+
+  
+    
+
+
+
+  
+  
+    
+
+
+  
+  
+    
+
+
+  
+
+
+    
+
+
+  
+
+
+
    名称原配置新配置
    Resize
+
+```python
+dict(type='Resize',
+     img_scale=(1333, 800),
+     keep_ratio=True)
+```
+
+
+
+```python
+dict(type='Resize',
+     scale=(1333, 800),
+     keep_ratio=True)
+```
+
+
    RandomResize
+
+```python
+dict(
+    type='Resize',
+    img_scale=[
+        (1333, 640), (1333, 800)],
+    multiscale_mode='range',
+    keep_ratio=True)
+```
+
+
+
+```python
+dict(
+    type='RandomResize',
+    scale=[
+        (1333, 640), (1333, 800)],
+    keep_ratio=True)
+```
+
+
    RandomChoiceResize
+
+```python
+dict(
+    type='Resize',
+    img_scale=[
+        (1333, 640), (1333, 672),
+        (1333, 704), (1333, 736),
+        (1333, 768), (1333, 800)],
+    multiscale_mode='value',
+    keep_ratio=True)
+```
+
+
+
+```python
+dict(
+    type='RandomChoiceResize',
+    scales=[
+        (1333, 640), (1333, 672),
+        (1333, 704), (1333, 736),
+        (1333, 768), (1333, 800)],
+    keep_ratio=True)
+```
+
+
    RandomFlip
+
+```python
+dict(type='RandomFlip',
+     flip_ratio=0.5)
+```
+
+
+
+```python
+dict(type='RandomFlip',
+     prob=0.5)
+```
+
+
    
+
+### 评测器配置
+
+在 3.x 版本中，模型精度评测不再与数据集绑定，而是通过评测器（Evaluator）来完成。
+评测器配置分为 val_evaluator 和 test_evaluator 两部分，其中 val_evaluator 用于验证集评测，test_evaluator 用于测试集评测，对应 2.x 版本中的 evaluation 字段。
+下表列出了 2.x 版本与 3.x 版本中的评测器的对应关系：
+
+
+
+  
+    
+    
+    
+  
+
+
+  
+    
+
+
+
+  
+  
+    
+
+
+  
+  
+    
+
+
+  
+
+
+    
+
+
+  
+
+
+
    评测指标名称原配置新配置
    COCO
+
+```python
+data = dict(
+    val=dict(
+        type='CocoDataset',
+        ann_file=data_root + 'annotations/instances_val2017.json'))
+evaluation = dict(metric=['bbox', 'segm'])
+```
+
+
+
+```python
+val_evaluator = dict(
+    type='CocoMetric',
+    ann_file=data_root + 'annotations/instances_val2017.json',
+    metric=['bbox', 'segm'],
+    format_only=False)
+```
+
+
    Pascal VOC
+
+```python
+data = dict(
+    val=dict(
+        type=dataset_type,
+        ann_file=data_root + 'VOC2007/ImageSets/Main/test.txt'))
+evaluation = dict(metric='mAP')
+```
+
+
+
+```python
+val_evaluator = dict(
+    type='VOCMetric',
+    metric='mAP',
+    eval_mode='11points')
+```
+
+
    OpenImages
+
+```python
+data = dict(
+    val=dict(
+        type='OpenImagesDataset',
+        ann_file=data_root + 'annotations/validation-annotations-bbox.csv',
+        img_prefix=data_root + 'OpenImages/validation/',
+        label_file=data_root + 'annotations/class-descriptions-boxable.csv',
+        hierarchy_file=data_root +
+        'annotations/bbox_labels_600_hierarchy.json',
+        meta_file=data_root + 'annotations/validation-image-metas.pkl',
+        image_level_ann_file=data_root +
+        'annotations/validation-annotations-human-imagelabels-boxable.csv'))
+evaluation = dict(interval=1, metric='mAP')
+```
+
+
+
+```python
+val_evaluator = dict(
+    type='OpenImagesMetric',
+    iou_thrs=0.5,
+    ioa_thrs=0.5,
+    use_group_of=True,
+    get_supercategory=True)
+```
+
+
    CityScapes
+
+```python
+data = dict(
+    val=dict(
+        type='CityScapesDataset',
+        ann_file=data_root +
+        'annotations/instancesonly_filtered_gtFine_val.json',
+        img_prefix=data_root + 'leftImg8bit/val/',
+        pipeline=test_pipeline))
+evaluation = dict(metric=['bbox', 'segm'])
+```
+
+
+
+```python
+val_evaluator = [
+    dict(
+        type='CocoMetric',
+        ann_file=data_root +
+        'annotations/instancesonly_filtered_gtFine_val.json',
+        metric=['bbox', 'segm']),
+    dict(
+        type='CityScapesMetric',
+        ann_file=data_root +
+        'annotations/instancesonly_filtered_gtFine_val.json',
+        seg_prefix=data_root + '/gtFine/val',
+        outfile_prefix='./work_dirs/cityscapes_metric/instance')
+]
+```
+
+
    
+
+## 训练和测试的配置
+
+
+
+
+
+
+
+
+
+
    原配置
+
+```python
+runner = dict(
+    type='EpochBasedRunner',  # 训练循环的类型
+    max_epochs=12)  # 最大训练轮次
+evaluation = dict(interval=2)  # 验证间隔。每 2 个 epoch 验证一次
+```
+
+
    新配置
+
+```python
+train_cfg = dict(
+    type='EpochBasedTrainLoop',  # 训练循环的类型，请参考 https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py
+    max_epochs=12,  # 最大训练轮次
+    val_interval=2)  # 验证间隔。每 2 个 epoch 验证一次
+val_cfg = dict(type='ValLoop')  # 验证循环的类型
+test_cfg = dict(type='TestLoop')  # 测试循环的类型
+```
+
+
    
+
+## 优化相关配置
+
+优化器以及梯度裁剪的配置都移至 optim_wrapper 字段中。下表列出了 2.x 版本与 3.x 版本中的优化器配置的对应关系：
+
+
+
+
+
+
+
+
+
+
    原配置
+
+```python
+optimizer = dict(
+    type='SGD',  # 随机梯度下降优化器
+    lr=0.02,  # 基础学习率
+    momentum=0.9,  # 带动量的随机梯度下降
+    weight_decay=0.0001)  # 权重衰减
+optimizer_config = dict(grad_clip=None)  # 梯度裁剪的配置，设置为 None 关闭梯度裁剪
+```
+
+
    新配置
+
+```python
+optim_wrapper = dict(  # 优化器封装的配置
+    type='OptimWrapper',  # 优化器封装的类型。可以切换至 AmpOptimWrapper 来启用混合精度训练
+    optimizer=dict(  # 优化器配置。支持 PyTorch 的各种优化器。请参考 https://pytorch.org/docs/stable/optim.html#algorithms
+        type='SGD',  # 随机梯度下降优化器
+        lr=0.02,  # 基础学习率
+        momentum=0.9,  # 带动量的随机梯度下降
+        weight_decay=0.0001),  # 权重衰减
+    clip_grad=None,  # 梯度裁剪的配置，设置为 None 关闭梯度裁剪。使用方法请见 https://mmengine.readthedocs.io/en/latest/tutorials/optimizer.html
+    )
+```
+
+
    
+
+学习率的配置也从 lr_config 字段中移至 param_scheduler 字段中。param_scheduler 的配置更贴近 PyTorch 的学习率调整策略，更加灵活。下表列出了 2.x 版本与 3.x 版本中的学习率配置的对应关系：
+
+
+
+
+
+
+
+
+
+
    原配置
+
+```python
+lr_config = dict(
+    policy='step',  # 在训练过程中使用 multi step 学习率策略
+    warmup='linear',  # 使用线性学习率预热
+    warmup_iters=500,  # 到第 500 个 iteration 结束预热
+    warmup_ratio=0.001,  # 学习率预热的系数
+    step=[8, 11],  # 在哪几个 epoch 进行学习率衰减
+    gamma=0.1)  # 学习率衰减系数
+```
+
+
    新配置
+
+```python
+param_scheduler = [
+    dict(
+        type='LinearLR',  # 使用线性学习率预热
+        start_factor=0.001, # 学习率预热的系数
+        by_epoch=False,  # 按 iteration 更新预热学习率
+        begin=0,  # 从第一个 iteration 开始
+        end=500),  # 到第 500 个 iteration 结束
+    dict(
+        type='MultiStepLR',  # 在训练过程中使用 multi step 学习率策略
+        by_epoch=True,  # 按 epoch 更新学习率
+        begin=0,   # 从第一个 epoch 开始
+        end=12,  # 到第 12 个 epoch 结束
+        milestones=[8, 11],  # 在哪几个 epoch 进行学习率衰减
+        gamma=0.1)  # 学习率衰减系数
+]
+```
+
+
    
+
+关于其他的学习率调整策略的迁移，请参考 MMEngine 的[学习率迁移文档](https://mmengine.readthedocs.io/zh_CN/latest/migration/param_scheduler.html)。
+
+## 其他配置的迁移
+
+### 保存 checkpoint 的配置
+
+
+
+  
+    
+    
+    
+  
+
+
+  
+    
+
+
+
+  
+
+
+    
+
+
+  
+
+
+    
+
+
+  
+
+
+
    功能原配置新配置
    设置保存间隔
+
+```python
+checkpoint_config = dict(
+    interval=1)
+```
+
+
+
+```python
+default_hooks = dict(
+    checkpoint=dict(
+        type='CheckpointHook',
+        interval=1))
+```
+
+
    保存最佳模型
+
+```python
+evaluation = dict(
+    save_best='auto')
+```
+
+
+
+```python
+default_hooks = dict(
+    checkpoint=dict(
+        type='CheckpointHook',
+        save_best='auto'))
+```
+
+
    只保留最新的几个模型
+
+```python
+checkpoint_config = dict(
+    max_keep_ckpts=3)
+```
+
+
+
+```python
+default_hooks = dict(
+    checkpoint=dict(
+        type='CheckpointHook',
+        max_keep_ckpts=3))
+```
+
+
    
+
+### 日志的配置
+
+3.x 版本中，日志的打印和可视化由 MMEngine 中的 logger 和 visualizer 分别完成。下表列出了 2.x 版本与 3.x 版本中的日志配置的对应关系：
+
+
+
+  
+    
+    
+    
+  
+
+
+  
+    
+
+
+
+  
+
+
+    
+
+
+  
+
+
+
    功能原配置新配置
    设置日志打印间隔
+
+```python
+log_config = dict(
+    interval=50)
+```
+
+
+
+```python
+default_hooks = dict(
+    logger=dict(
+        type='LoggerHook',
+        interval=50))
+# 可选： 配置日志打印数值的平滑窗口大小
+log_processor = dict(
+    type='LogProcessor',
+    window_size=50)
+```
+
+
    使用 TensorBoard 或 WandB 可视化日志
+
+```python
+log_config = dict(
+    interval=50,
+    hooks=[
+        dict(type='TextLoggerHook'),
+        dict(type='TensorboardLoggerHook'),
+        dict(type='MMDetWandbHook',
+             init_kwargs={
+                'project': 'mmdetection',
+                'group': 'maskrcnn-r50-fpn-1x-coco'
+             },
+             interval=50,
+             log_checkpoint=True,
+             log_checkpoint_metadata=True,
+             num_eval_images=100)
+    ])
+```
+
+
+
+```python
+vis_backends = [
+    dict(type='LocalVisBackend'),
+    dict(type='TensorboardVisBackend'),
+    dict(type='WandbVisBackend',
+         init_kwargs={
+            'project': 'mmdetection',
+            'group': 'maskrcnn-r50-fpn-1x-coco'
+         })
+]
+visualizer = dict(
+    type='DetLocalVisualizer', vis_backends=vis_backends, name='visualizer')
+```
+
+
    
+
+关于可视化相关的教程，请参考 MMDetection 的[可视化教程](../user_guides/visualization.md)。
+
+### Runtime 的配置
+
+3.x 版本中 runtime 的配置字段有所调整，具体的对应关系如下：
+
+
+
+  
+    
+    
+  
+
+
+
+
+
+
+  
+
+
+
    原配置新配置
    
+
+```python
+cudnn_benchmark = False
+opencv_num_threads = 0
+mp_start_method = 'fork'
+dist_params = dict(backend='nccl')
+log_level = 'INFO'
+load_from = None
+resume_from = None
+
+
+```
+
+
+
+```python
+env_cfg = dict(
+    cudnn_benchmark=False,
+    mp_cfg=dict(mp_start_method='fork',
+                opencv_num_threads=0),
+    dist_cfg=dict(backend='nccl'))
+log_level = 'INFO'
+load_from = None
+resume = False
+```
+
+
    
diff --git a/mmdetection/docs/zh_cn/migration/dataset_migration.md b/mmdetection/docs/zh_cn/migration/dataset_migration.md
new file mode 100644
index 00000000..c379b9f1
--- /dev/null
+++ b/mmdetection/docs/zh_cn/migration/dataset_migration.md
@@ -0,0 +1 @@
+# 将数据集从 MMDetection 2.x 迁移至 3.x
diff --git a/mmdetection/docs/zh_cn/migration/migration.md b/mmdetection/docs/zh_cn/migration/migration.md
new file mode 100644
index 00000000..d706856f
--- /dev/null
+++ b/mmdetection/docs/zh_cn/migration/migration.md
@@ -0,0 +1,12 @@
+# 从 MMDetection 2.x 迁移至 3.x
+
+MMDetection 3.x 版本是一个重大更新，包含了许多 API 和配置文件的变化。本文档旨在帮助用户从 MMDetection 2.x 版本迁移到 3.x 版本。
+我们将迁移指南分为以下几个部分：
+
+- [配置文件迁移](./config_migration.md)
+- [API 和 Registry 迁移](./api_and_registry_migration.md)
+- [数据集迁移](./dataset_migration.md)
+- [模型迁移](./model_migration.md)
+- [常见问题](./migration_faq.md)
+
+如果您在迁移过程中遇到任何问题，欢迎在 issue 中提出。我们也欢迎您为本文档做出贡献。
diff --git a/mmdetection/docs/zh_cn/migration/migration_faq.md b/mmdetection/docs/zh_cn/migration/migration_faq.md
new file mode 100644
index 00000000..208a138b
--- /dev/null
+++ b/mmdetection/docs/zh_cn/migration/migration_faq.md
@@ -0,0 +1 @@
+# 迁移 FAQ
diff --git a/mmdetection/docs/zh_cn/migration/model_migration.md b/mmdetection/docs/zh_cn/migration/model_migration.md
new file mode 100644
index 00000000..d7992440
--- /dev/null
+++ b/mmdetection/docs/zh_cn/migration/model_migration.md
@@ -0,0 +1 @@
+# 将模型从 MMDetection 2.x 迁移至 3.x
diff --git a/mmdetection/docs/zh_cn/model_zoo.md b/mmdetection/docs/zh_cn/model_zoo.md
new file mode 100644
index 00000000..b5376152
--- /dev/null
+++ b/mmdetection/docs/zh_cn/model_zoo.md
@@ -0,0 +1,333 @@
+# 模型库
+
+## 镜像地址
+
+从 MMDetection V2.0 起，我们只通过阿里云维护模型库。V1.x 版本的模型已经弃用。
+
+## 共同设置
+
+- 所有模型都是在 `coco_2017_train` 上训练，在 `coco_2017_val` 上测试。
+- 我们使用分布式训练。
+- 所有 pytorch-style 的 ImageNet 预训练主干网络来自 PyTorch 的模型库，caffe-style 的预训练主干网络来自 detectron2 最新开源的模型。
+- 为了与其他代码库公平比较，文档中所写的 GPU 内存是8个 GPU 的 `torch.cuda.max_memory_allocated()` 的最大值，此值通常小于 nvidia-smi 显示的值。
+- 我们以网络 forward 和后处理的时间加和作为推理时间，不包含数据加载时间。所有结果通过 [benchmark.py](https://github.com/open-mmlab/mmdetection/blob/main/tools/analysis_tools/benchmark.py) 脚本计算所得。该脚本会计算推理 2000 张图像的平均时间。
+
+## ImageNet 预训练模型
+
+通过 ImageNet 分类任务预训练的主干网络进行初始化是很常见的操作。所有预训练模型的链接都可以在 [open_mmlab](https://github.com/open-mmlab/mmcv/blob/master/mmcv/model_zoo/open_mmlab.json) 中找到。根据 `img_norm_cfg` 和原始权重，我们可以将所有 ImageNet 预训练模型分为以下几种情况：
+
+- TorchVision：torchvision 模型权重，包含 ResNet50, ResNet101。`img_norm_cfg` 为 `dict(mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)`。
+- Pycls：[pycls](https://github.com/facebookresearch/pycls) 模型权重，包含 RegNetX。`img_norm_cfg` 为 `dict(   mean=[103.530, 116.280, 123.675], std=[57.375, 57.12, 58.395], to_rgb=False)`。
+- MSRA styles：[MSRA](https://github.com/KaimingHe/deep-residual-networks) 模型权重，包含 ResNet50_Caffe，ResNet101_Caffe。`img_norm_cfg` 为 `dict(   mean=[103.530, 116.280, 123.675], std=[1.0, 1.0, 1.0], to_rgb=False)`。
+- Caffe2 styles：现阶段只包含 ResNext101_32x8d。`img_norm_cfg` 为 `dict(mean=[103.530, 116.280, 123.675], std=[57.375, 57.120, 58.395], to_rgb=False)`。
+- Other styles: SSD 的 `img_norm_cfg` 为 `dict(mean=[123.675, 116.28, 103.53], std=[1, 1, 1], to_rgb=True)`，YOLOv3 的 `img_norm_cfg` 为 `dict(mean=[0, 0, 0], std=[255., 255., 255.], to_rgb=True)`。
+
+MMdetection 常用到的主干网络细节如下表所示：
+
+| 模型             | 来源        | 链接                                                                                                                                                                                                | 描述                                                                                                                                                                                                                       |
+| ---------------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ResNet50         | TorchVision | [torchvision 中的 ResNet-50](https://download.pytorch.org/models/resnet50-19c8e357.pth)                                                                                                             | 来自 [torchvision 中的 ResNet-50](https://download.pytorch.org/models/resnet50-19c8e357.pth)。                                                                                                                             |
+| ResNet101        | TorchVision | [torchvision 中的 ResNet-101](https://download.pytorch.org/models/resnet101-5d3b4d8f.pth)                                                                                                           | 来自 [torchvision 中的 ResNet-101](https://download.pytorch.org/models/resnet101-5d3b4d8f.pth)。                                                                                                                           |
+| RegNetX          | Pycls       | [RegNetX_3.2gf](https://download.openmmlab.com/pretrain/third_party/regnetx_3.2gf-c2599b0f.pth)，[RegNetX_800mf](https://download.openmmlab.com/pretrain/third_party/regnetx_800mf-1f4be4c7.pth) 等 | 来自 [pycls](https://github.com/facebookresearch/pycls)。                                                                                                                                                                  |
+| ResNet50_Caffe   | MSRA        | [MSRA 中的 ResNet-50](https://download.openmmlab.com/pretrain/third_party/resnet50_caffe-788b5fa3.pth)                                                                                              | 由 [Detectron2 中的 R-50.pkl](https://dl.fbaipublicfiles.com/detectron2/ImageNetPretrained/MSRA/R-50.pkl) 转化的副本。原始权重文件来自 [MSRA 中的原始 ResNet-50](https://github.com/KaimingHe/deep-residual-networks)。    |
+| ResNet101_Caffe  | MSRA        | [MSRA 中的 ResNet-101](https://download.openmmlab.com/pretrain/third_party/resnet101_caffe-3ad79236.pth)                                                                                            | 由 [Detectron2 中的 R-101.pkl](https://dl.fbaipublicfiles.com/detectron2/ImageNetPretrained/MSRA/R-101.pkl) 转化的副本。原始权重文件来自 [MSRA 中的原始 ResNet-101](https://github.com/KaimingHe/deep-residual-networks)。 |
+| ResNext101_32x8d | Caffe2      | [Caffe2 ResNext101_32x8d](https://download.openmmlab.com/pretrain/third_party/resnext101_32x8d-1516f1aa.pth)                                                                                        | 由 [Detectron2 中的 X-101-32x8d.pkl](https://dl.fbaipublicfiles.com/detectron2/ImageNetPretrained/FAIR/X-101-32x8d.pkl) 转化的副本。原始 ResNeXt-101-32x8d 由 FB 使用 Caffe2 训练。                                        |
+
+## Baselines
+
+### RPN
+
+请参考 [RPN](https://github.com/open-mmlab/mmdetection/blob/main/configs/rpn)。
+
+### Faster R-CNN
+
+请参考 [Faster R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/faster_rcnn)。
+
+### Mask R-CNN
+
+请参考 [Mask R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/mask_rcnn)。
+
+### Fast R-CNN (使用提前计算的 proposals)
+
+请参考 [Fast R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/fast_rcnn)。
+
+### RetinaNet
+
+请参考 [RetinaNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/retinanet)。
+
+### Cascade R-CNN and Cascade Mask R-CNN
+
+请参考 [Cascade R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/cascade_rcnn)。
+
+### Hybrid Task Cascade (HTC)
+
+请参考 [HTC](https://github.com/open-mmlab/mmdetection/blob/main/configs/htc)。
+
+### SSD
+
+请参考 [SSD](https://github.com/open-mmlab/mmdetection/blob/main/configs/ssd)。
+
+### Group Normalization (GN)
+
+请参考 [Group Normalization](https://github.com/open-mmlab/mmdetection/blob/main/configs/gn)。
+
+### Weight Standardization
+
+请参考 [Weight Standardization](https://github.com/open-mmlab/mmdetection/blob/main/configs/gn+ws)。
+
+### Deformable Convolution v2
+
+请参考 [Deformable Convolutional Networks](https://github.com/open-mmlab/mmdetection/blob/main/configs/dcn)。
+
+### CARAFE: Content-Aware ReAssembly of FEatures
+
+请参考 [CARAFE](https://github.com/open-mmlab/mmdetection/blob/main/configs/carafe)。
+
+### Instaboost
+
+请参考 [Instaboost](https://github.com/open-mmlab/mmdetection/blob/main/configs/instaboost)。
+
+### Libra R-CNN
+
+请参考 [Libra R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/libra_rcnn)。
+
+### Guided Anchoring
+
+请参考 [Guided Anchoring](https://github.com/open-mmlab/mmdetection/blob/main/configs/guided_anchoring)。
+
+### FCOS
+
+请参考 [FCOS](https://github.com/open-mmlab/mmdetection/blob/main/configs/fcos)。
+
+### FoveaBox
+
+请参考 [FoveaBox](https://github.com/open-mmlab/mmdetection/blob/main/configs/foveabox)。
+
+### RepPoints
+
+请参考 [RepPoints](https://github.com/open-mmlab/mmdetection/blob/main/configs/reppoints)。
+
+### FreeAnchor
+
+请参考 [FreeAnchor](https://github.com/open-mmlab/mmdetection/blob/main/configs/free_anchor)。
+
+### Grid R-CNN (plus)
+
+请参考 [Grid R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/grid_rcnn)。
+
+### GHM
+
+请参考 [GHM](https://github.com/open-mmlab/mmdetection/blob/main/configs/ghm)。
+
+### GCNet
+
+请参考 [GCNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/gcnet)。
+
+### HRNet
+
+请参考 [HRNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/hrnet)。
+
+### Mask Scoring R-CNN
+
+请参考 [Mask Scoring R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/ms_rcnn)。
+
+### Train from Scratch
+
+请参考 [Rethinking ImageNet Pre-training](https://github.com/open-mmlab/mmdetection/blob/main/configs/scratch)。
+
+### NAS-FPN
+
+请参考 [NAS-FPN](https://github.com/open-mmlab/mmdetection/blob/main/configs/nas_fpn)。
+
+### ATSS
+
+请参考 [ATSS](https://github.com/open-mmlab/mmdetection/blob/main/configs/atss)。
+
+### FSAF
+
+请参考 [FSAF](https://github.com/open-mmlab/mmdetection/blob/main/configs/fsaf)。
+
+### RegNetX
+
+请参考 [RegNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/regnet)。
+
+### Res2Net
+
+请参考 [Res2Net](https://github.com/open-mmlab/mmdetection/blob/main/configs/res2net)。
+
+### GRoIE
+
+请参考 [GRoIE](https://github.com/open-mmlab/mmdetection/blob/main/configs/groie)。
+
+### Dynamic R-CNN
+
+请参考 [Dynamic R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/dynamic_rcnn)。
+
+### PointRend
+
+请参考 [PointRend](https://github.com/open-mmlab/mmdetection/blob/main/configs/point_rend)。
+
+### DetectoRS
+
+请参考 [DetectoRS](https://github.com/open-mmlab/mmdetection/blob/main/configs/detectors)。
+
+### Generalized Focal Loss
+
+请参考 [Generalized Focal Loss](https://github.com/open-mmlab/mmdetection/blob/main/configs/gfl)。
+
+### CornerNet
+
+请参考 [CornerNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/cornernet)。
+
+### YOLOv3
+
+请参考 [YOLOv3](https://github.com/open-mmlab/mmdetection/blob/main/configs/yolo)。
+
+### PAA
+
+请参考 [PAA](https://github.com/open-mmlab/mmdetection/blob/main/configs/paa)。
+
+### SABL
+
+请参考 [SABL](https://github.com/open-mmlab/mmdetection/blob/main/configs/sabl)。
+
+### CentripetalNet
+
+请参考 [CentripetalNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/centripetalnet)。
+
+### ResNeSt
+
+请参考 [ResNeSt](https://github.com/open-mmlab/mmdetection/blob/main/configs/resnest)。
+
+### DETR
+
+请参考 [DETR](https://github.com/open-mmlab/mmdetection/blob/main/configs/detr)。
+
+### Deformable DETR
+
+请参考 [Deformable DETR](https://github.com/open-mmlab/mmdetection/blob/main/configs/deformable_detr)。
+
+### AutoAssign
+
+请参考 [AutoAssign](https://github.com/open-mmlab/mmdetection/blob/main/configs/autoassign)。
+
+### YOLOF
+
+请参考 [YOLOF](https://github.com/open-mmlab/mmdetection/blob/main/configs/yolof)。
+
+### Seesaw Loss
+
+请参考 [Seesaw Loss](https://github.com/open-mmlab/mmdetection/blob/main/configs/seesaw_loss)。
+
+### CenterNet
+
+请参考 [CenterNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/centernet)。
+
+### YOLOX
+
+请参考 [YOLOX](https://github.com/open-mmlab/mmdetection/blob/main/configs/yolox)。
+
+### PVT
+
+请参考 [PVT](https://github.com/open-mmlab/mmdetection/blob/main/configs/pvt)。
+
+### SOLO
+
+请参考 [SOLO](https://github.com/open-mmlab/mmdetection/blob/main/configs/solo)。
+
+### QueryInst
+
+请参考 [QueryInst](https://github.com/open-mmlab/mmdetection/blob/main/configs/queryinst)。
+
+### Other datasets
+
+我们还在 [PASCAL VOC](https://github.com/open-mmlab/mmdetection/blob/main/configs/pascal_voc)，[Cityscapes](https://github.com/open-mmlab/mmdetection/blob/main/configs/cityscapes) 和 [WIDER FACE](https://github.com/open-mmlab/mmdetection/blob/main/configs/wider_face) 上对一些方法进行了基准测试。
+
+### Pre-trained Models
+
+我们还通过多尺度训练和更长的训练策略来训练用 ResNet-50 和 [RegNetX-3.2G](https://github.com/open-mmlab/mmdetection/blob/main/configs/regnet) 作为主干网络的 [Faster R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/faster_rcnn) 和 [Mask R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/mask_rcnn)。这些模型可以作为下游任务的预训练模型。
+
+## 速度基准
+
+### 训练速度基准
+
+我们提供 [analyze_logs.py](https://github.com/open-mmlab/mmdetection/blob/main/tools/analysis_tools/analyze_logs.py) 来得到训练中每一次迭代的平均时间。示例请参考 [Log Analysis](https://mmdetection.readthedocs.io/en/latest/useful_tools.html#log-analysis)。
+
+我们与其他流行框架的 Mask R-CNN 训练速度进行比较（数据是从 [detectron2](https://github.com/facebookresearch/detectron2/blob/main/docs/notes/benchmarks.md/) 复制而来）。在 mmdetection 中，我们使用 [mask-rcnn_r50-caffe_fpn_poly-1x_coco_v1.py](https://github.com/open-mmlab/mmdetection/blob/main/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_poly-1x_coco_v1.py) 进行基准测试。它与 detectron2 的 [mask_rcnn_R_50_FPN_noaug_1x.yaml](https://github.com/facebookresearch/detectron2/blob/main/configs/Detectron1-Comparisons/mask_rcnn_R_50_FPN_noaug_1x.yaml) 设置完全一样。同时，我们还提供了[模型权重](https://download.openmmlab.com/mmdetection/v2.0/benchmark/mask_rcnn_r50_caffe_fpn_poly_1x_coco_no_aug/mask_rcnn_r50_caffe_fpn_poly_1x_coco_no_aug_compare_20200518-10127928.pth)和[训练 log](https://download.openmmlab.com/mmdetection/v2.0/benchmark/mask_rcnn_r50_caffe_fpn_poly_1x_coco_no_aug/mask_rcnn_r50_caffe_fpn_poly_1x_coco_no_aug_20200518_105755.log.json) 作为参考。为了跳过 GPU 预热时间，吞吐量按照100-500次迭代之间的平均吞吐量来计算。
+
+| 框架                                                                                   | 吞吐量 (img/s) |
+| -------------------------------------------------------------------------------------- | -------------- |
+| [Detectron2](https://github.com/facebookresearch/detectron2)                           | 62             |
+| [MMDetection](https://github.com/open-mmlab/mmdetection)                               | 61             |
+| [maskrcnn-benchmark](https://github.com/facebookresearch/maskrcnn-benchmark/)          | 53             |
+| [tensorpack](https://github.com/tensorpack/tensorpack/tree/master/examples/FasterRCNN) | 50             |
+| [simpledet](https://github.com/TuSimple/simpledet/)                                    | 39             |
+| [Detectron](https://github.com/facebookresearch/Detectron)                             | 19             |
+| [matterport/Mask_RCNN](https://github.com/matterport/Mask_RCNN/)                       | 14             |
+
+### 推理时间基准
+
+我们提供 [benchmark.py](https://github.com/open-mmlab/mmdetection/blob/main/tools/analysis_tools/benchmark.py) 对推理时间进行基准测试。此脚本将推理 2000 张图片并计算忽略前 5 次推理的平均推理时间。可以通过设置 `LOG-INTERVAL` 来改变 log 输出间隔（默认为 50）。
+
+```shell
+python tools/benchmark.py ${CONFIG} ${CHECKPOINT} [--log-interval $[LOG-INTERVAL]] [--fuse-conv-bn]
+```
+
+模型库中，所有模型在基准测量推理时间时都没设置 `fuse-conv-bn`, 此设置可以使推理时间更短。
+
+## 与 Detectron2 对比
+
+我们在速度和精度方面对 mmdetection 和 [Detectron2](https://github.com/facebookresearch/detectron2.git) 进行对比。对比所使用的 detectron2 的 commit id 为 [185c27e](https://github.com/facebookresearch/detectron2/tree/185c27e4b4d2d4c68b5627b3765420c6d7f5a659)(30/4/2020)。
+为了公平对比，我们所有的实验都在同一机器下进行。
+
+### 硬件
+
+- 8 NVIDIA Tesla V100 (32G) GPUs
+- Intel(R) Xeon(R) Gold 6148 CPU @ 2.40GHz
+
+### 软件环境
+
+- Python 3.7
+- PyTorch 1.4
+- CUDA 10.1
+- CUDNN 7.6.03
+- NCCL 2.4.08
+
+### 精度
+
+| 模型                                                                                                                            | 训练策略 | Detectron2                                                                                                                             | mmdetection | 下载                                                                                                                                                                                                                                                                                                                                                             |
+| ------------------------------------------------------------------------------------------------------------------------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [Faster R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_ms-1x_coco.py) | 1x       | [37.9](https://github.com/facebookresearch/detectron2/blob/main/configs/COCO-Detection/faster_rcnn_R_50_FPN_1x.yaml)                   | 38.0        | [model](https://download.openmmlab.com/mmdetection/v2.0/benchmark/faster_rcnn_r50_caffe_fpn_mstrain_1x_coco/faster_rcnn_r50_caffe_fpn_mstrain_1x_coco-5324cff8.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/benchmark/faster_rcnn_r50_caffe_fpn_mstrain_1x_coco/faster_rcnn_r50_caffe_fpn_mstrain_1x_coco_20200429_234554.log.json)             |
+| [Mask R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco.py)  | 1x       | [38.6 & 35.2](https://github.com/facebookresearch/detectron2/blob/master/configs/COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_1x.yaml) | 38.8 & 35.4 | [model](https://download.openmmlab.com/mmdetection/v2.0/benchmark/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_coco/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_coco-dbecf295.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/benchmark/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_coco/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_coco_20200430_054239.log.json) |
+| [Retinanet](https://github.com/open-mmlab/mmdetection/blob/main/configs/retinanet/retinanet_r50-caffe_fpn_ms-1x_coco.py)        | 1x       | [36.5](https://github.com/facebookresearch/detectron2/blob/master/configs/COCO-Detection/retinanet_R_50_FPN_1x.yaml)                   | 37.0        | [model](https://download.openmmlab.com/mmdetection/v2.0/benchmark/retinanet_r50_caffe_fpn_mstrain_1x_coco/retinanet_r50_caffe_fpn_mstrain_1x_coco-586977a0.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/benchmark/retinanet_r50_caffe_fpn_mstrain_1x_coco/retinanet_r50_caffe_fpn_mstrain_1x_coco_20200430_014748.log.json)                     |
+
+### 训练速度
+
+训练速度使用 s/iter 来度量。结果越低越好。
+
+| 模型         | Detectron2 | mmdetection |
+| ------------ | ---------- | ----------- |
+| Faster R-CNN | 0.210      | 0.216       |
+| Mask R-CNN   | 0.261      | 0.265       |
+| Retinanet    | 0.200      | 0.205       |
+
+### 推理速度
+
+推理速度通过单张 GPU 下的 fps(img/s) 来度量，越高越好。
+为了与 Detectron2 保持一致，我们所写的推理时间除去了数据加载时间。
+对于 Mask RCNN，我们去除了后处理中 RLE 编码的时间。
+我们在括号中给出了官方给出的速度。由于硬件差异，官方给出的速度会比我们所测试得到的速度快一些。
+
+| 模型         | Detectron2  | mmdetection |
+| ------------ | ----------- | ----------- |
+| Faster R-CNN | 25.6 (26.3) | 22.2        |
+| Mask R-CNN   | 22.5 (23.3) | 19.6        |
+| Retinanet    | 17.8 (18.2) | 20.6        |
+
+### 训练内存
+
+| 模型         | Detectron2 | mmdetection |
+| ------------ | ---------- | ----------- |
+| Faster R-CNN | 3.0        | 3.8         |
+| Mask R-CNN   | 3.4        | 3.9         |
+| Retinanet    | 3.9        | 3.4         |
diff --git a/mmdetection/docs/zh_cn/notes/compatibility.md b/mmdetection/docs/zh_cn/notes/compatibility.md
new file mode 100644
index 00000000..e9ebdd97
--- /dev/null
+++ b/mmdetection/docs/zh_cn/notes/compatibility.md
@@ -0,0 +1,177 @@
+# MMDetection v2.x 兼容性说明
+
+## MMDetection 2.25.0
+
+为了加入 Mask2Former 实例分割模型，对 Mask2Former 的配置文件进行了重命名 [PR #7571](https://github.com/open-mmlab/mmdetection/pull/7571)：
+
+
+    
+        
+            
+            
+        
+    
+    
+    
+    
+  
    在 v2.25.0 之前v2.25.0 及之后
    
+
+```
+'mask2former_xxx_coco.py' 代表全景分割的配置文件
+```
+
+
+
+```
+'mask2former_xxx_coco.py' 代表实例分割的配置文件
+'mask2former_xxx_coco-panoptic.py' 代表全景分割的配置文件
+```
+
+
    
+
+## MMDetection 2.21.0
+
+为了支持 CPU 训练，MMCV 中进行批处理的 scatter 的代码逻辑已经被修改。我们推荐使用 MMCV v1.4.4 或更高版本，
+更多信息请参考 [MMCV PR #1621](https://github.com/open-mmlab/mmcv/pull/1621).
+
+## MMDetection 2.18.1
+
+### MMCV compatibility
+
+为了修复 BaseTransformerLayer 中的权重引用问题, MultiheadAttention 中 batch first 的逻辑有所改变。
+我们推荐使用 MMCV v1.3.17 或更高版本。 更多信息请参考 [MMCV PR #1418](https://github.com/open-mmlab/mmcv/pull/1418) 。
+
+## MMDetection 2.18.0
+
+### DIIHead 兼容性
+
+为了支持 QueryInst，在 DIIHead 的返回元组中加入了 attn_feats。
+
+## MMDetection v2.14.0
+
+### MMCV 版本
+
+为了修复 EvalHook 优先级过低的问题，MMCV v1.3.8 中所有 hook 的优先级都重新进行了调整，因此 MMDetection v2.14.0 需要依赖最新的 MMCV v1.3.8 版本。 相关信息请参考[PR #1120](https://github.com/open-mmlab/mmcv/pull/1120) ，相关问题请参考[#5343](https://github.com/open-mmlab/mmdetection/issues/5343) 。
+
+### SSD 兼容性
+
+在 v2.14.0 中，为了使 SSD 能够被更灵活地使用，[PR #5291](https://github.com/open-mmlab/mmdetection/pull/5291) 重构了 SSD 的 backbone、neck 和 head。用户可以使用 tools/model_converters/upgrade_ssd_version.py 转换旧版本训练的模型。
+
+```shell
+python tools/model_converters/upgrade_ssd_version.py ${OLD_MODEL_PATH} ${NEW_MODEL_PATH}
+
+```
+
+- OLD_MODEL_PATH：旧版 SSD 模型的路径。
+- NEW_MODEL_PATH：保存转换后模型权重的路径。
+
+## MMDetection v2.12.0
+
+在 v2.12.0 到 v2.18.0（或以上）版本的这段时间，为了提升通用性和便捷性，MMDetection 正在进行大规模重构。在升级到 v2.12.0 后 MMDetection 不可避免地带来了一些 BC Breaking，包括 MMCV 的版本依赖、模型初始化方式、模型 registry 和 mask AP 的评估。
+
+### MMCV 版本
+
+MMDetection v2.12.0 依赖 MMCV v1.3.3 中新增加的功能，包括：使用 `BaseModule` 统一参数初始化，模型 registry，以及[Deformable DETR](https://arxiv.org/abs/2010.04159) 中的 `MultiScaleDeformableAttn` CUDA 算子。
+注意，尽管 MMCV v1.3.2 已经包含了 MMDet 所需的功能，但是存在一些已知的问题。我们建议用户跳过 MMCV v1.3.2 使用 v1.3.3 版本。
+
+### 统一模型初始化
+
+为了统一 OpenMMLab 项目中的参数初始化方式，MMCV 新增加了 `BaseModule` 类，使用 `init_cfg` 参数对模块进行统一且灵活的初始化配置管理。
+现在用户需要在训练脚本中显式调用 `model.init_weights()` 来初始化模型（例如 [这行代码](https://github.com/open-mmlab/mmdetection/blob/master/tools/train.py#L162) ，在这之前则是在 detector 中进行处理的。
+**下游项目必须相应地更新模型初始化方式才能使用 MMDetection v2.12.0**。请参阅 [PR #4750](https://github.com/open-mmlab/mmdetection/pull/4750) 了解详情。
+
+### 统一模型 registry
+
+为了能够使用在其他 OpenMMLab 项目中实现的 backbone，MMDetection v2.12.0 继承了在 MMCV (#760) 中创建的模型 registry。
+这样，只要 OpenMMLab 项目实现了某个 backbone，并且该项目也使用 MMCV 中的 registry，那么用户只需修改配置即可在 MMDetection 中使用该 backbone，不再需要将代码复制到 MMDetection 中。 更多详细信息，请参阅 [PR #5059](https://github.com/open-mmlab/mmdetection/pull/5059) 。
+
+### Mask AP 评估
+
+在 [PR #4898](https://github.com/open-mmlab/mmdetection/pull/4898) 和 v2.12.0 之前，对小、中、大目标的 mask AP 的评估是基于其边界框区域而不是真正的 mask 区域。
+这导致 `APs` 和 `APm` 变得更高但 `APl` 变得更低，但是不会影响整体的 mask AP。 [PR #4898](https://github.com/open-mmlab/mmdetection/pull/4898) 删除了 mask AP 计算中的 `bbox` ，改为使用 mask 区域。
+新的计算方式不会影响整体的 mask AP 评估，与 [Detectron2](https://github.com/facebookresearch/detectron2/)一致。
+
+## 与 MMDetection v1.x 的兼容性
+
+MMDetection v2.0 经过了大规模重构并解决了许多遗留问题。 MMDetection v2.0 不兼容 v1.x 版本，在这两个版本中使用相同的模型权重运行推理会产生不同的结果。 因此，MMDetection v2.0 重新对所有模型进行了 benchmark，并在 model zoo 中提供了新模型的权重和训练记录。
+
+新旧版本的主要的区别有四方面：坐标系、代码库约定、训练超参和模块设计。
+
+### 坐标系
+
+新坐标系与 [Detectron2](https://github.com/facebookresearch/detectron2/) 一致，
+将最左上角的像素的中心视为坐标原点 (0, 0) 而不是最左上角像素的左上角。 因此 COCO 边界框和分割标注中的坐标被解析为范围 `[0，width]` 和 `[0，height]` 中的坐标。 这个修改影响了所有与 bbox 及像素选择相关的计算，变得更加自然且更加准确。
+
+- 在新坐标系中，左上角和右下角为 (x1, y1) (x2, y2) 的框的宽度及高度计算公式为 `width = x2 - x1` 和 `height = y2 - y1`。
+  在 MMDetection v1.x 和之前的版本中，高度和宽度都多了 `+ 1` 的操作。
+  本次修改包括三部分：
+
+  1. box 回归中的检测框变换以及编码/解码。
+  2. IoU 计算。这会影响 ground truth 和检测框之间的匹配以及 NMS 。但对兼容性的影响可以忽略不计。
+  3. Box 的角点坐标为浮点型，不再取整。这能使得检测结果更为准确，也使得检测框和 RoI 的最小尺寸不再为 1，但影响很小。
+
+- Anchor 的中心与特征图的网格点对齐，类型变为 float。
+  在 MMDetection v1.x 和之前的版本中，anchors 是 `int` 类型且没有居中对齐。
+  这会影响 RPN 中的 Anchor 生成和所有基于 Anchor 的方法。
+
+- ROIAlign 更好地与图像坐标系对齐。新的实现来自 [Detectron2](https://github.com/facebookresearch/detectron2/tree/master/detectron2/layers/csrc/ROIAlign) 。
+  当 RoI 用于提取 RoI 特征时，与 MMDetection v1.x 相比默认情况下相差半个像素。
+  能够通过设置 `aligned=False` 而不是 `aligned=True` 来维持旧版本的设置。
+
+- Mask 的裁剪和粘贴更准确。
+
+  1. 我们使用新的 RoIAlign 来提取 mask 目标。 在 MMDetection v1.x 中，bounding box 在提取 mask 目标之前被取整，裁剪过程是 numpy 实现的。 而在新版本中，裁剪的边界框不经过取整直接输入 RoIAlign。 此实现大大加快了训练速度（每次迭代约加速 0.1 秒，1x schedule 训练 Mask R50 时加速约 2 小时）并且理论上会更准确。
+  2. 在 MMDetection v2.0 中，修改后的 `paste_mask()` 函数应该比之前版本更准确。 此更改参考了 [Detectron2](https://github.com/facebookresearch/detectron2/blob/master/detectron2/structures/masks.py) 中的修改，可以将 COCO 上的 mask AP 提高约 0.5%。
+
+### 代码库约定
+
+- MMDetection v2.0 更改了类别标签的顺序，减少了回归和 mask 分支里的无用参数并使得顺序更加自然（没有 +1 和 -1）。
+  这会影响模型的所有分类层，使其输出的类别标签顺序发生改变。回归分支和 mask head 的最后一层不再为 K 个类别保留 K+1 个通道，类别顺序与分类分支一致。
+
+  - 在 MMDetection v2.0 中，标签 “K” 表示背景，标签 \[0, K-1\] 对应于 K = num_categories 个对象类别。
+
+  - 在 MMDetection v1.x 及之前的版本中，标签 “0” 表示背景，标签 \[1, K\] 对应 K 个类别。
+
+  - **注意**：softmax RPN 的类顺序在 version\<=2.4.0 中仍然和 1.x 中的一样，而 sigmoid RPN 不受影响。从 MMDetection v2.5.0 开始，所有 head 中的类顺序是统一的。
+
+- 不使用 R-CNN 中的低质量匹配。在 MMDetection v1.x 和之前的版本中，`max_iou_assigner` 会在 RPN 和 R-CNN 训练时给每个 ground truth 匹配低质量框。我们发现这会导致最佳的 GT 框不会被分配给某些边界框，
+  因此，在MMDetection v2.0 的 R-CNN 训练中默认不允许低质量匹配。这有时可能会稍微改善 box AP（约为 0.1%）。
+
+- 单独的宽高比例系数。在 MMDetection v1.x 和以前的版本中，`keep_ratio=True` 时比例系数是单个浮点数，这并不准确，因为宽度和高度的比例系数会有一定的差异。 MMDetection v2.0 对宽度和高度使用单独的比例系数，对 AP 的提升约为 0.1%。
+
+- 修改了 config 文件名称的规范。 由于 model zoo 中模型不断增多， MMDetection v2.0 采用新的命名规则：
+
+  ```shell
+  [model]_(model setting)_[backbone]_[neck]_(norm setting)_(misc)_(gpu x batch)_[schedule]_[dataset].py
+  ```
+
+  其中 (`misc`) 包括 DCN 和 GCBlock 等。更多详细信息在 [配置文件说明文档](config.md) 中说明
+
+- MMDetection v2.0 使用新的 ResNet Caffe backbone 来减少加载预训练模型时的警告。新 backbone 中的大部分权重与以前的相同，但没有 `conv.bias`，且它们使用不同的 `img_norm_cfg`。因此，新的 backbone 不会报 `unexpected keys` 的警告。
+
+### 训练超参
+
+训练超参的调整不会影响模型的兼容性，但会略微提高性能。主要有：
+
+- 通过设置 `nms_post=1000` 和 `max_num=1000`，将 nms 之后的 proposal 数量从 2000 更改为 1000。使 mask AP 和 bbox AP 提高了约 0.2%。
+
+- Mask R-CNN、Faster R-CNN 和 RetinaNet 的默认回归损失从 smooth L1 损失更改为 L1 损失，使得 box AP 整体上都有所提升（约 0.6%）。但是，将 L1-loss 用在 Cascade R-CNN 和 HTC 等其他方法上并不能提高性能，因此我们保留这些方法的原始设置。
+
+- 为简单起见，RoIAlign 层的 `sampling_ratio` 设置为 0。略微提升了 AP（约 0.2% 绝对值）。
+
+- 为了提升训练速度，默认设置在训练过程中不再使用梯度裁剪。大多数模型的性能不会受到影响。对于某些模型（例如 RepPoints），我们依旧使用梯度裁剪来稳定训练过程从而获得更好的性能。
+
+- 因为不再默认使用梯度裁剪，默认 warmup 比率从 1/3 更改为 0.001，以使模型训练预热更加平缓。不过我们重新进行基准测试时发现这种影响可以忽略不计。
+
+### 将模型从 v1.x 升级至 v2.0
+
+用户可以使用脚本 `tools/model_converters/upgrade_model_version.py` 来将 MMDetection 1.x 训练的模型转换为 MMDetection v2.0。转换后的模型可以在 MMDetection v2.0 中运行，但性能略有下降（小于 1% AP）。
+详细信息可以在 `configs/legacy` 中找到。
+
+## pycocotools 兼容性
+
+`mmpycocotools` 是 OpenMMLab 维护的 `pycocotools` 的复刻版，适用于 MMDetection 和 Detectron2。
+在 [PR #4939](https://github.com/open-mmlab/mmdetection/pull/4939) 之前，由于 `pycocotools` 和 `mmpycocotool` 具有相同的包名，如果用户已经安装了 `pyccocotools`（在相同环境下先安装了 Detectron2 ），那么 MMDetection 的安装过程会跳过安装 `mmpycocotool`。 导致 MMDetection 缺少 `mmpycocotools` 而报错。
+但如果在 Detectron2 之前安装 MMDetection，则可以在相同的环境下工作。
+[PR #4939](https://github.com/open-mmlab/mmdetection/pull/4939) 弃用 mmpycocotools，使用官方 pycocotools。
+在 [PR #4939](https://github.com/open-mmlab/mmdetection/pull/4939) 之后，用户能够在相同环境下安装 MMDetection 和 Detectron2，不再需要关注安装顺序。
diff --git a/mmdetection/docs/zh_cn/notes/faq.md b/mmdetection/docs/zh_cn/notes/faq.md
new file mode 100644
index 00000000..2b4237c7
--- /dev/null
+++ b/mmdetection/docs/zh_cn/notes/faq.md
@@ -0,0 +1,260 @@
+# 常见问题解答
+
+我们在这里列出了使用时的一些常见问题及其相应的解决方案。 如果您发现有一些问题被遗漏，请随时提 PR 丰富这个列表。 如果您无法在此获得帮助，请使用 [issue模板](https://github.com/open-mmlab/mmdetection/blob/main/.github/ISSUE_TEMPLATE/error-report.md/)创建问题，但是请在模板中填写所有必填信息，这有助于我们更快定位问题。
+
+## PyTorch 2.0 支持
+
+MMDetection 目前绝大部分算法已经支持了 PyTorch 2.0 及其 `torch.compile` 功能, 用户只需要安装 MMDetection 3.0.0rc7 及其以上版本即可。如果你在使用中发现有不支持的算法，欢迎给我们反馈。我们也非常欢迎社区贡献者来 benchmark 对比 `torch.compile` 功能所带来的速度提升。
+
+如果你想启动 `torch.compile` 功能，只需要在 `train.py` 或者 `test.py` 后面加上 `--cfg-options compile=True`。 以 RTMDet 为例，你可以使用以下命令启动 `torch.compile` 功能：
+
+```shell
+# 单卡
+python tools/train.py configs/rtmdet/rtmdet_s_8xb32-300e_coco.py  --cfg-options compile=True
+
+# 单机 8 卡
+./tools/dist_train.sh configs/rtmdet/rtmdet_s_8xb32-300e_coco.py 8 --cfg-options compile=True
+
+# 单机 8 卡 + AMP 混合精度训练
+./tools/dist_train.sh configs/rtmdet/rtmdet_s_8xb32-300e_coco.py 8 --cfg-options compile=True --amp
+```
+
+需要特别注意的是，PyTorch 2.0 对于动态 shape 支持不是非常完善，目标检测算法中大部分不仅输入 shape 是动态的，而且 loss 计算和后处理过程中也是动态的，这会导致在开启 `torch.compile` 功能后训练速度会变慢。基于此，如果你想启动 `torch.compile` 功能，则应该遵循如下原则：
+
+1. 输入到网络的图片是固定 shape 的，而非多尺度的
+2. 设置 `torch._dynamo.config.cache_size_limit` 参数。TorchDynamo 会将 Python 字节码转换并缓存，已编译的函数会被存入缓存中。当下一次检查发现需要重新编译时，该函数会被重新编译并缓存。但是如果重编译次数超过预设的最大值（64），则该函数将不再被缓存或重新编译。前面说过目标检测算法中的 loss 计算和后处理部分也是动态计算的，这些函数需要在每次迭代中重新编译。因此将 `torch._dynamo.config.cache_size_limit` 参数设置得更小一些可以有效减少编译时间
+
+在 MMDetection 中可以通过环境变量 `DYNAMO_CACHE_SIZE_LIMIT` 设置 `torch._dynamo.config.cache_size_limit` 参数，以 RTMDet 为例，命令如下所示：
+
+```shell
+# 单卡
+export DYNAMO_CACHE_SIZE_LIMIT = 4
+python tools/train.py configs/rtmdet/rtmdet_s_8xb32-300e_coco.py  --cfg-options compile=True
+
+# 单机 8 卡
+export DYNAMO_CACHE_SIZE_LIMIT = 4
+./tools/dist_train.sh configs/rtmdet/rtmdet_s_8xb32-300e_coco.py 8 --cfg-options compile=True
+```
+
+关于 PyTorch 2.0 的 dynamo 常见问题，可以参考 [这里](https://pytorch.org/docs/stable/dynamo/faq.html)
+
+## 安装
+
+- MMCV 与 MMDetection 的兼容问题: "ConvWS is already registered in conv layer"; "AssertionError: MMCV==xxx is used but incompatible. Please install mmcv>=xxx, \<=xxx."
+
+  MMDetection，MMEngine 和 MMCV 的版本兼容关系如下。请选择合适的版本避免安装错误 。
+
+  | MMDetection 版本 |        MMCV 版本        |      MMEngine 版本       |
+  | :--------------: | :---------------------: | :----------------------: |
+  |       main       |  mmcv>=2.0.0, \<2.2.0   | mmengine>=0.7.1, \<1.0.0 |
+  |      3.3.0       |  mmcv>=2.0.0, \<2.2.0   | mmengine>=0.7.1, \<1.0.0 |
+  |      3.2.0       |  mmcv>=2.0.0, \<2.2.0   | mmengine>=0.7.1, \<1.0.0 |
+  |      3.1.0       |  mmcv>=2.0.0, \<2.1.0   | mmengine>=0.7.1, \<1.0.0 |
+  |      3.0.0       |  mmcv>=2.0.0, \<2.1.0   | mmengine>=0.7.1, \<1.0.0 |
+  |     3.0.0rc6     | mmcv>=2.0.0rc4, \<2.1.0 | mmengine>=0.6.0, \<1.0.0 |
+  |     3.0.0rc5     | mmcv>=2.0.0rc1, \<2.1.0 | mmengine>=0.3.0, \<1.0.0 |
+  |     3.0.0rc4     | mmcv>=2.0.0rc1, \<2.1.0 | mmengine>=0.3.0, \<1.0.0 |
+  |     3.0.0rc3     | mmcv>=2.0.0rc1, \<2.1.0 | mmengine>=0.3.0, \<1.0.0 |
+  |     3.0.0rc2     | mmcv>=2.0.0rc1, \<2.1.0 | mmengine>=0.1.0, \<1.0.0 |
+  |     3.0.0rc1     | mmcv>=2.0.0rc1, \<2.1.0 | mmengine>=0.1.0, \<1.0.0 |
+  |     3.0.0rc0     | mmcv>=2.0.0rc1, \<2.1.0 | mmengine>=0.1.0, \<1.0.0 |
+
+  **注意：**
+
+  1. 如果你希望安装 mmdet-v2.x, MMDetection 和 MMCV 版本兼容表可以在 [这里](https://mmdetection.readthedocs.io/en/stable/faq.html#installation) 找到，请选择合适的版本避免安装错误。
+  2. 在 MMCV-v2.x 中，`mmcv-full` 改名为 `mmcv`，如果你想安装不包含 CUDA 算子的版本，可以选择安装 MMCV 精简版 `mmcv-lite`。
+
+- "No module named 'mmcv.ops'"; "No module named 'mmcv.\_ext'".
+
+  原因是安装了 `mmcv-lite` 而不是 `mmcv`。
+
+  1. `pip uninstall mmcv-lite` 卸载安装的 `mmcv-lite`
+
+  2. 安装 `mmcv` 根据 [安装说明](https://mmcv.readthedocs.io/zh_CN/2.x/get_started/installation.html)。
+
+- 在 Windows 环境下安装过程中遇到 "Microsoft Visual C++ 14.0 or graeter is required" error .
+
+  这个错误发生在 pycotools 的 'pycocotools.\_mask' 扩展构建过程，其原因是缺少了对应 C++ 环境依赖。你需要到微软官方下载[对应工具](https://visualstudio.microsoft.com/zh-hans/visual-cpp-build-tools/)，选择“使用 C++ 的桌面开发”选项安装最小依赖，随后重新安装 pycocotools。
+
+- 使用 albumentations
+
+如果你希望使用 `albumentations`，我们建议使用 `pip install -r requirements/albu.txt`
+或者 `pip install -U albumentations --no-binary qudida,albumentations` 进行安装。
+如果简单地使用 `pip install albumentations>=0.3.2` 进行安装，
+则会同时安装 `opencv-python-headless`（即便已经安装了 `opencv-python` 也会再次安装）。
+我们建议在安装 `albumentations` 后检查环境，以确保没有同时安装 `opencv-python` 和 `opencv-python-headless`，
+因为同时安装可能会导致一些问题。更多细节请参考[官方文档](https://albumentations.ai/docs/getting_started/installation/#note-on-opencv-dependencies) 。
+
+- 在某些算法中出现 ModuleNotFoundError 错误
+
+一些算法或者数据需要额外的依赖，例如 Instaboost、 Panoptic Segmentation、 LVIS dataset 等。请注意错误信息并安装相应的包，例如：
+
+```shell
+# 安装 instaboost 依赖
+pip install instaboostfast
+# 安装 panoptic segmentation 依赖
+pip install git+https://github.com/cocodataset/panopticapi.git
+# 安装 LVIS dataset 依赖
+pip install git+https://github.com/lvis-dataset/lvis-api.git
+```
+
+## 代码
+
+- 修改一些代码后是否需要重新安装 mmdet
+
+如果你遵循最佳实践，即使用 `pip install -v -e .` 安装的 mmdet，则对本地代码所作的任何修改都会生效，无需重新安装
+
+- 如何使用多个 MMDetection 版本进行开发
+
+你可以拥有多个文件夹，例如 mmdet-3.0，mmdet-3.1。
+
+要使环境中安装默认的 MMDetection 而不是当前正在在使用的，可以删除出现在相关脚本中的代码：
+
+```shell
+PYTHONPATH="$(dirname $0)/..":$PYTHONPATH
+```
+
+## PyTorch/CUDA 环境相关
+
+- "RTX 30 series card fails when building MMCV or MMDet"
+
+  1. 临时解决方案为使用命令 `MMCV_WITH_OPS=1 MMCV_CUDA_ARGS='-gencode=arch=compute_80,code=sm_80' pip install -e .` 进行编译。 常见报错信息为 `nvcc fatal : Unsupported gpu architecture 'compute_86'` 意思是你的编译器不支持 sm_86 架构(包括英伟达 30 系列的显卡)的优化，至 CUDA toolkit 11.0 依旧未支持. 这个命令是通过增加宏 `MMCV_CUDA_ARGS='-gencode=arch=compute_80,code=sm_80` 让 nvcc 编译器为英伟达 30 系列显卡进行 `sm_80` 的优化，虽然这有可能会无法发挥出显卡所有性能。
+
+  2. 有开发者已经在 [pytorch/pytorch#47585](https://github.com/pytorch/pytorch/pull/47585) 更新了 PyTorch 默认的编译 flag， 但是我们对此并没有进行测试。
+
+- "invalid device function" 或者 "no kernel image is available for execution".
+
+  1. 检查您正常安装了 CUDA runtime (一般在`/usr/local/`)，或者使用 `nvcc --version` 检查本地版本，有时安装 PyTorch 会顺带安装一个 CUDA runtime，并且实际优先使用 conda 环境中的版本，你可以使用 `conda list cudatoolkit` 查看其版本。
+
+  2. 编译 extension 的 CUDA Toolkit 版本与运行时的 CUDA Toolkit 版本是否相符，
+
+     - 如果您从源码自己编译的，使用 `python mmdet/utils/collect_env.py` 检查编译编译 extension 的 CUDA Toolkit 版本，然后使用 `conda list cudatoolkit` 检查当前 conda 环境是否有 CUDA Toolkit，若有检查版本是否匹配， 如不匹配，更换 conda 环境的 CUDA Toolkit，或者使用匹配的 CUDA Toolkit 中的 nvcc 编译即可，如环境中无 CUDA Toolkit，可以使用 `nvcc -V`。
+
+       等命令查看当前使用的 CUDA runtime。
+
+     - 如果您是通过 pip 下载的预编译好的版本，请确保与当前 CUDA runtime 一致。
+
+  3. 运行 `python mmdet/utils/collect_env.py` 检查是否为正确的 GPU 架构编译的 PyTorch， torchvision， 与 MMCV。 你或许需要设置 `TORCH_CUDA_ARCH_LIST` 来重新安装 MMCV，可以参考 [GPU 架构表](https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html#gpu-feature-list),
+     例如， 运行 `TORCH_CUDA_ARCH_LIST=7.0 pip install mmcv` 为 Volta GPU 编译 MMCV。这种架构不匹配的问题一般会出现在使用一些旧型号的 GPU 时候出现， 例如， Tesla K80。
+
+- "undefined symbol" 或者 "cannot open xxx.so".
+
+  1. 如果这些 symbol 属于 CUDA/C++ (如 libcudart.so 或者 GLIBCXX)，使用 `python mmdet/utils/collect_env.py`检查 CUDA/GCC runtime 与编译 MMCV 的 CUDA 版本是否相同。
+  2. 如果这些 symbols 属于 PyTorch，(例如, symbols containing caffe, aten, and TH), 检查当前 Pytorch 版本是否与编译 MMCV 的版本一致。
+  3. 运行 `python mmdet/utils/collect_env.py` 检查 PyTorch， torchvision， MMCV 等的编译环境与运行环境一致。
+
+- setuptools.sandbox.UnpickleableException: DistutilsSetupError("each element of 'ext_modules' option must be an Extension instance or 2-tuple")
+
+  1. 如果你在使用 miniconda 而不是 anaconda，检查是否正确的安装了 Cython 如 [#3379](https://github.com/open-mmlab/mmdetection/issues/3379).
+  2. 检查环境中的 `setuptools`, `Cython`, and `PyTorch` 相互之间版本是否匹配。
+
+- "Segmentation fault".
+
+  1. 检查 GCC 的版本，通常是因为 PyTorch 版本与 GCC 版本不匹配 （例如 GCC \< 4.9 )，我们推荐用户使用 GCC 5.4，我们也不推荐使用 GCC 5.5， 因为有反馈 GCC 5.5 会导致 "segmentation fault" 并且切换到 GCC 5.4 就可以解决问题。
+
+  2. 检查是否正确安装了 CUDA 版本的 PyTorch 。
+
+     ```shell
+     python -c 'import torch; print(torch.cuda.is_available())'
+     ```
+
+     是否返回True。
+
+  3. 如果 `torch` 的安装是正确的，检查是否正确编译了 MMCV。
+
+     ```shell
+     python -c 'import mmcv; import mmcv.ops'
+     ```
+
+  4. 如果 MMCV 与 PyTorch 都被正确安装了，则使用 `ipdb`, `pdb` 设置断点，直接查找哪一部分的代码导致了 `segmentation fault`。
+
+## Training 相关
+
+- "Loss goes Nan"
+
+  1. 检查数据的标注是否正常， 长或宽为 0 的框可能会导致回归 loss 变为 nan，一些小尺寸（宽度或高度小于 1）的框在数据增强（例如，instaboost）后也会导致此问题。 因此，可以检查标注并过滤掉那些特别小甚至面积为 0 的框，并关闭一些可能会导致 0 面积框出现数据增强。
+  2. 降低学习率：由于某些原因，例如 batch size 大小的变化， 导致当前学习率可能太大。 您可以降低为可以稳定训练模型的值。
+  3. 延长 warm up 的时间：一些模型在训练初始时对学习率很敏感，您可以把 `warmup_iters` 从 500 更改为 1000 或 2000。
+  4. 添加 gradient clipping: 一些模型需要梯度裁剪来稳定训练过程。 默认的 `grad_clip` 是 `None`,  你可以在 config 设置 `optimizer_config=dict(_delete_=True, grad_clip=dict(max_norm=35, norm_type=2))`  如果你的 config 没有继承任何包含 `optimizer_config=dict(grad_clip=None)`,  你可以直接设置`optimizer_config=dict(grad_clip=dict(max_norm=35, norm_type=2))`.
+
+- "GPU out of memory"
+
+  1. 存在大量 ground truth boxes 或者大量 anchor 的场景，可能在 assigner 会 OOM。 您可以在 assigner 的配置中设置 `gpu_assign_thr=N`，这样当超过 N 个 GT boxes 时，assigner 会通过 CPU 计算 IOU。
+
+  2. 在 backbone 中设置 `with_cp=True`。 这使用 PyTorch 中的 `sublinear strategy` 来降低 backbone 占用的 GPU 显存。
+
+  3. 使用 `config/fp16` 中的示例尝试混合精度训练。`loss_scale` 可能需要针对不同模型进行调整。
+
+  4. 你也可以尝试使用 `AvoidCUDAOOM` 来避免该问题。首先它将尝试调用 `torch.cuda.empty_cache()`。如果失败，将会尝试把输入类型转换到 FP16。如果仍然失败，将会把输入从 GPUs 转换到 CPUs 进行计算。这里提供了两个使用的例子：
+
+     ```python
+     from mmdet.utils import AvoidCUDAOOM
+
+     output = AvoidCUDAOOM.retry_if_cuda_oom(some_function)(input1, input2)
+     ```
+
+     你也可也使用 `AvoidCUDAOOM` 作为装饰器让代码遇到 OOM 的时候继续运行：
+
+     ```python
+     from mmdet.utils import AvoidCUDAOOM
+
+     @AvoidCUDAOOM.retry_if_cuda_oom
+     def function(*args, **kwargs):
+         ...
+         return xxx
+     ```
+
+- "RuntimeError: Expected to have finished reduction in the prior iteration before starting a new one"
+
+  1. 这个错误出现在存在参数没有在 forward 中使用，容易在 DDP 中运行不同分支时发生。
+  2. 你可以在 config 设置 `find_unused_parameters = True` 进行训练 (会降低训练速度)。
+  3. 你也可以通过在 config 中的 `optimizer_config` 里设置 `detect_anomalous_params=True` 查找哪些参数没有用到，但是需要 MMCV 的版本 >= 1.4.1。
+
+- 训练中保存最好模型
+
+  可以通过配置 `default_hooks = dict(checkpoint=dict(type='CheckpointHook', interval=1, save_best='auto')`开启。在 `auto` 参数情况下会根据返回的验证结果中的第一个 key 作为选择最优模型的依据，你也可以直接设置评估结果中的 key 来手动设置，例如 `save_best='coco/bbox_mAP'`。
+
+- 在 Resume 训练中使用 `ExpMomentumEMAHook`
+
+  如果在训练中使用了 `ExpMomentumEMAHook`，那么 resume 时候不能仅仅通过命令行参数 `--resume-from` 或 `--cfg-options resume_from` 实现恢复模型参数功能例如 `python tools/train.py configs/yolox/yolox_s_8x8_300e_coco.py --resume-from ./work_dir/yolox_s_8x8_300e_coco/epoch_x.pth`。以 `yolox_s` 算法为例，由于 `ExpMomentumEMAHook` 需要重新加载权重，你可以通过如下做法实现：
+
+  ```python
+  # 直接打开 configs/yolox/yolox_s_8x8_300e_coco.py 修改所有 resume_from 字段
+  resume_from=./work_dir/yolox_s_8x8_300e_coco/epoch_x.pth
+  custom_hooks=[...
+      dict(
+          type='ExpMomentumEMAHook',
+          resume_from=./work_dir/yolox_s_8x8_300e_coco/epoch_x.pth,
+          momentum=0.0001,
+          priority=49)
+      ]
+  ```
+
+## Evaluation 相关
+
+- 使用 COCO Dataset 的测评接口时, 测评结果中 AP 或者 AR = -1
+  1. 根据COCO数据集的定义，一张图像中的中等物体与小物体面积的阈值分别为 9216（96\*96）与 1024（32\*32）。
+  2. 如果在某个区间没有检测框 AP 与 AR 认定为 -1.
+
+## Model 相关
+
+- **ResNet style 参数说明**
+
+  ResNet style 可选参数允许 `pytorch` 和 `caffe`，其差别在于 Bottleneck 模块。Bottleneck 是 `1x1-3x3-1x1` 堆叠结构，在 `caffe` 模式模式下 stride=2 参数放置在第一个 `1x1` 卷积处，而 `pyorch` 模式下 stride=2 放在第二个 `3x3` 卷积处。一个简单示例如下：
+
+  ```python
+  if self.style == 'pytorch':
+        self.conv1_stride = 1
+        self.conv2_stride = stride
+  else:
+        self.conv1_stride = stride
+        self.conv2_stride = 1
+  ```
+
+- **ResNeXt 参数说明**
+
+  ResNeXt 来自论文 [`Aggregated Residual Transformations for Deep Neural Networks`](https://arxiv.org/abs/1611.05431). 其引入分组卷积，并且通过变量基数来控制组的数量达到精度和复杂度的平衡，其有两个超参 `baseWidth` 和 `cardinality `来控制内部 Bottleneck 模块的基本宽度和分组数参数。以 MMDetection 中配置名为 `mask_rcnn_x101_64x4d_fpn_mstrain-poly_3x_coco.py` 为例，其中 `mask_rcnn` 代表算法采用 Mask R-CNN，`x101` 代表骨架网络采用 ResNeXt-101，`64x4d`代表 Bottleneck 一共分成 64 组，每组的基本宽度是 4。
+
+- **骨架网络 eval 模式说明**
+
+  因为检测模型通常比较大且输入图片分辨率很高，这会导致检测模型的 batch 很小，通常是 2，这会使得 BatchNorm 在训练过程计算的统计量方差非常大，不如主干网络预训练时得到的统计量稳定，因此在训练是一般都会使用 `norm_eval=True` 模式，直接使用预训练主干网络中的 BatchNorm 统计量，少数使用大 batch 的算法是 `norm_eval=False` 模式，例如 NASFPN。对于没有 ImageNet 预训练的骨架网络，如果 batch 比较小，可以考虑使用 `SyncBN`。
diff --git a/mmdetection/docs/zh_cn/notes/projects.md b/mmdetection/docs/zh_cn/notes/projects.md
new file mode 100644
index 00000000..6b9d300d
--- /dev/null
+++ b/mmdetection/docs/zh_cn/notes/projects.md
@@ -0,0 +1,48 @@
+# 基于 MMDetection 的项目
+
+有许多开源项目都是基于 MMDetection 搭建的，我们在这里列举一部分作为样例，展示如何基于 MMDetection 搭建您自己的项目。
+由于这个页面列举的项目并不完全，我们欢迎社区提交 Pull Request 来更新这个文档。
+
+## MMDetection 的拓展项目
+
+一些项目拓展了 MMDetection 的边界，如将 MMDetection 拓展支持 3D 检测或者将 MMDetection 用于部署。
+它们展示了 MMDetection 的许多可能性，所以我们在这里也列举一些。
+
+- [OTEDetection](https://github.com/opencv/mmdetection): OpenVINO training extensions for object detection.
+- [MMDetection3d](https://github.com/open-mmlab/mmdetection3d): OpenMMLab's next-generation platform for general 3D object detection.
+
+## 研究项目
+
+同样有许多研究论文是基于 MMDetection 进行的。许多论文都发表在了顶级的会议或期刊上，或者对社区产生了深远的影响。
+为了向社区提供一个可以参考的论文列表，帮助大家开发或者比较新的前沿算法，我们在这里也遵循会议的时间顺序列举了一些论文。
+MMDetection 中已经支持的算法不在此列。
+
+- Involution: Inverting the Inherence of Convolution for Visual Recognition, CVPR21. [\[paper\]](https://arxiv.org/abs/2103.06255)[\[github\]](https://github.com/d-li14/involution)
+- Multiple Instance Active Learning for Object Detection, CVPR 2021. [\[paper\]](https://openaccess.thecvf.com/content/CVPR2021/papers/Yuan_Multiple_Instance_Active_Learning_for_Object_Detection_CVPR_2021_paper.pdf)[\[github\]](https://github.com/yuantn/MI-AOD)
+- Adaptive Class Suppression Loss for Long-Tail Object Detection, CVPR 2021. [\[paper\]](https://arxiv.org/abs/2104.00885)[\[github\]](https://github.com/CASIA-IVA-Lab/ACSL)
+- Generalizable Pedestrian Detection: The Elephant In The Room, CVPR2021. [\[paper\]](https://arxiv.org/abs/2003.08799)[\[github\]](https://github.com/hasanirtiza/Pedestron)
+- Group Fisher Pruning for Practical Network Compression, ICML2021. [\[paper\]](https://github.com/jshilong/FisherPruning/blob/main/resources/paper.pdf)[\[github\]](https://github.com/jshilong/FisherPruning)
+- Overcoming Classifier Imbalance for Long-tail Object Detection with Balanced Group Softmax, CVPR2020. [\[paper\]](http://openaccess.thecvf.com/content_CVPR_2020/papers/Li_Overcoming_Classifier_Imbalance_for_Long-Tail_Object_Detection_With_Balanced_Group_CVPR_2020_paper.pdf)[\[github\]](https://github.com/FishYuLi/BalancedGroupSoftmax)
+- Coherent Reconstruction of Multiple Humans from a Single Image, CVPR2020. [\[paper\]](https://jiangwenpl.github.io/multiperson/)[\[github\]](https://github.com/JiangWenPL/multiperson)
+- Look-into-Object: Self-supervised Structure Modeling for Object Recognition, CVPR 2020. [\[paper\]](http://openaccess.thecvf.com/content_CVPR_2020/papers/Zhou_Look-Into-Object_Self-Supervised_Structure_Modeling_for_Object_Recognition_CVPR_2020_paper.pdf)[\[github\]](https://github.com/JDAI-CV/LIO)
+- Video Panoptic Segmentation, CVPR2020. [\[paper\]](https://arxiv.org/abs/2006.11339)[\[github\]](https://github.com/mcahny/vps)
+- D2Det: Towards High Quality Object Detection and Instance Segmentation, CVPR2020. [\[paper\]](http://openaccess.thecvf.com/content_CVPR_2020/html/Cao_D2Det_Towards_High_Quality_Object_Detection_and_Instance_Segmentation_CVPR_2020_paper.html)[\[github\]](https://github.com/JialeCao001/D2Det)
+- CentripetalNet: Pursuing High-quality Keypoint Pairs for Object Detection, CVPR2020. [\[paper\]](https://arxiv.org/abs/2003.09119)[\[github\]](https://github.com/KiveeDong/CentripetalNet)
+- Learning a Unified Sample Weighting Network for Object Detection, CVPR 2020. [\[paper\]](http://openaccess.thecvf.com/content_CVPR_2020/html/Cai_Learning_a_Unified_Sample_Weighting_Network_for_Object_Detection_CVPR_2020_paper.html)[\[github\]](https://github.com/caiqi/sample-weighting-network)
+- Scale-equalizing Pyramid Convolution for Object Detection, CVPR2020. [\[paper\]](https://arxiv.org/abs/2005.03101) [\[github\]](https://github.com/jshilong/SEPC)
+- Revisiting the Sibling Head in Object Detector, CVPR2020. [\[paper\]](https://arxiv.org/abs/2003.07540)[\[github\]](https://github.com/Sense-X/TSD)
+- PolarMask: Single Shot Instance Segmentation with Polar Representation, CVPR2020. [\[paper\]](https://arxiv.org/abs/1909.13226)[\[github\]](https://github.com/xieenze/PolarMask)
+- Hit-Detector: Hierarchical Trinity Architecture Search for Object Detection, CVPR2020. [\[paper\]](https://arxiv.org/abs/2003.11818)[\[github\]](https://github.com/ggjy/HitDet.pytorch)
+- ZeroQ: A Novel Zero Shot Quantization Framework, CVPR2020. [\[paper\]](https://arxiv.org/abs/2001.00281)[\[github\]](https://github.com/amirgholami/ZeroQ)
+- CBNet: A Novel Composite Backbone Network Architecture for Object Detection, AAAI2020. [\[paper\]](https://aaai.org/Papers/AAAI/2020GB/AAAI-LiuY.1833.pdf)[\[github\]](https://github.com/VDIGPKU/CBNet)
+- RDSNet: A New Deep Architecture for Reciprocal Object Detection and Instance Segmentation, AAAI2020. [\[paper\]](https://arxiv.org/abs/1912.05070)[\[github\]](https://github.com/wangsr126/RDSNet)
+- Training-Time-Friendly Network for Real-Time Object Detection, AAAI2020. [\[paper\]](https://arxiv.org/abs/1909.00700)[\[github\]](https://github.com/ZJULearning/ttfnet)
+- Cascade RPN: Delving into High-Quality Region Proposal Network with Adaptive Convolution, NeurIPS 2019. [\[paper\]](https://arxiv.org/abs/1909.06720)[\[github\]](https://github.com/thangvubk/Cascade-RPN)
+- Reasoning R-CNN: Unifying Adaptive Global Reasoning into Large-scale Object Detection, CVPR2019. [\[paper\]](http://openaccess.thecvf.com/content_CVPR_2019/papers/Xu_Reasoning-RCNN_Unifying_Adaptive_Global_Reasoning_Into_Large-Scale_Object_Detection_CVPR_2019_paper.pdf)[\[github\]](https://github.com/chanyn/Reasoning-RCNN)
+- Learning RoI Transformer for Oriented Object Detection in Aerial Images, CVPR2019. [\[paper\]](https://arxiv.org/abs/1812.00155)[\[github\]](https://github.com/dingjiansw101/AerialDetection)
+- SOLO: Segmenting Objects by Locations. [\[paper\]](https://arxiv.org/abs/1912.04488)[\[github\]](https://github.com/WXinlong/SOLO)
+- SOLOv2: Dynamic, Faster and Stronger. [\[paper\]](https://arxiv.org/abs/2003.10152)[\[github\]](https://github.com/WXinlong/SOLO)
+- Dense Peppoints: Representing Visual Objects with Dense Point Sets. [\[paper\]](https://arxiv.org/abs/1912.11473)[\[github\]](https://github.com/justimyhxu/Dense-RepPoints)
+- IterDet: Iterative Scheme for Object Detection in Crowded Environments. [\[paper\]](https://arxiv.org/abs/2005.05708)[\[github\]](https://github.com/saic-vul/iterdet)
+- Cross-Iteration Batch Normalization. [\[paper\]](https://arxiv.org/abs/2002.05712)[\[github\]](https://github.com/Howal/Cross-iterationBatchNorm)
+- A Ranking-based, Balanced Loss Function Unifying Classification and Localisation in Object Detection, NeurIPS2020 [\[paper\]](https://arxiv.org/abs/2009.13592)[\[github\]](https://github.com/kemaloksuz/aLRPLoss)
diff --git a/mmdetection/docs/zh_cn/overview.md b/mmdetection/docs/zh_cn/overview.md
new file mode 100644
index 00000000..5269aed8
--- /dev/null
+++ b/mmdetection/docs/zh_cn/overview.md
@@ -0,0 +1,54 @@
+# 概述
+
+本章向您介绍 MMDetection 的整体框架，并提供详细的教程链接。
+
+## 什么是 MMDetection
+
+![图片](https://user-images.githubusercontent.com/12907710/137271636-56ba1cd2-b110-4812-8221-b4c120320aa9.png)
+
+MMDetection 是一个目标检测工具箱，包含了丰富的目标检测、实例分割、全景分割算法以及相关的组件和模块，下面是它的整体框架：
+
+MMDetection 由 7 个主要部分组成，apis、structures、datasets、models、engine、evaluation 和 visualization。
+
+- **apis** 为模型推理提供高级 API。
+- **structures** 提供 bbox、mask 和 DetDataSample 等数据结构。
+- **datasets** 支持用于目标检测、实例分割和全景分割的各种数据集。
+  - **transforms** 包含各种数据增强变换。
+  - **samplers** 定义了不同的数据加载器采样策略。
+- **models** 是检测器最重要的部分，包含检测器的不同组件。
+  - **detectors** 定义所有检测模型类。
+  - **data_preprocessors** 用于预处理模型的输入数据。
+  - **backbones** 包含各种骨干网络。
+  - **necks** 包含各种模型颈部组件。
+  - **dense_heads** 包含执行密集预测的各种检测头。
+  - **roi_heads** 包含从 RoI 预测的各种检测头。
+  - **seg_heads** 包含各种分割头。
+  - **losses** 包含各种损失函数。
+  - **task_modules** 为检测任务提供模块，例如 assigners、samplers、box coders 和 prior generators。
+  - **layers** 提供了一些基本的神经网络层。
+- **engine** 是运行时组件的一部分。
+  - **runner** 为 [MMEngine 的执行器](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/runner.html)提供扩展。
+  - **schedulers** 提供用于调整优化超参数的调度程序。
+  - **optimizers** 提供优化器和优化器封装。
+  - **hooks** 提供执行器的各种钩子。
+- **evaluation** 为评估模型性能提供不同的指标。
+- **visualization** 用于可视化检测结果。
+
+## 如何使用本指南
+
+以下是 MMDetection 的详细指南：
+
+1. 安装说明见[开始你的第一步](get_started.md)。
+
+2. MMDetection 的基本使用方法请参考以下教程。
+
+   - [训练和测试](https://mmdetection.readthedocs.io/zh_CN/latest/user_guides/index.html#train-test)
+
+   - [实用工具](https://mmdetection.readthedocs.io/zh_CN/latest/user_guides/index.html#useful-tools)
+
+3. 参考以下教程深入了解：
+
+   - [基础概念](https://mmdetection.readthedocs.io/zh_CN/latest/advanced_guides/index.html#basic-concepts)
+   - [组件定制](https://mmdetection.readthedocs.io/zh_CN/latest/advanced_guides/index.html#component-customization)
+
+4. 对于 MMDetection 2.x 版本的用户，我们提供了[迁移指南](./migration/migration.md)，帮助您完成新版本的适配。
diff --git a/mmdetection/docs/zh_cn/stat.py b/mmdetection/docs/zh_cn/stat.py
new file mode 100644
index 00000000..1ea5fbd2
--- /dev/null
+++ b/mmdetection/docs/zh_cn/stat.py
@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+import functools as func
+import glob
+import os.path as osp
+import re
+
+import numpy as np
+
+url_prefix = 'https://github.com/open-mmlab/mmdetection/blob/main/'
+
+files = sorted(glob.glob('../configs/*/README.md'))
+
+stats = []
+titles = []
+num_ckpts = 0
+
+for f in files:
+    url = osp.dirname(f.replace('../', url_prefix))
+
+    with open(f, 'r') as content_file:
+        content = content_file.read()
+
+    title = content.split('\n')[0].replace('# ', '').strip()
+    ckpts = set(x.lower().strip()
+                for x in re.findall(r'\[model\]\((https?.*)\)', content))
+
+    if len(ckpts) == 0:
+        continue
+
+    _papertype = [x for x in re.findall(r'\[([A-Z]+)\]', content)]
+    assert len(_papertype) > 0
+    papertype = _papertype[0]
+
+    paper = set([(papertype, title)])
+
+    titles.append(title)
+    num_ckpts += len(ckpts)
+
+    statsmsg = f"""
+\t* [{papertype}] [{title}]({url}) ({len(ckpts)} ckpts)
+"""
+    stats.append((paper, ckpts, statsmsg))
+
+allpapers = func.reduce(lambda a, b: a.union(b), [p for p, _, _ in stats])
+msglist = '\n'.join(x for _, _, x in stats)
+
+papertypes, papercounts = np.unique([t for t, _ in allpapers],
+                                    return_counts=True)
+countstr = '\n'.join(
+    [f'   - {t}: {c}' for t, c in zip(papertypes, papercounts)])
+
+modelzoo = f"""
+# Model Zoo Statistics
+
+* Number of papers: {len(set(titles))}
+{countstr}
+
+* Number of checkpoints: {num_ckpts}
+
+{msglist}
+"""
+
+with open('modelzoo_statistics.md', 'w') as f:
+    f.write(modelzoo)
diff --git a/mmdetection/docs/zh_cn/switch_language.md b/mmdetection/docs/zh_cn/switch_language.md
new file mode 100644
index 00000000..b2c4ad9d
--- /dev/null
+++ b/mmdetection/docs/zh_cn/switch_language.md
@@ -0,0 +1,3 @@
+## English
+
+## 简体中文
diff --git a/mmdetection/docs/zh_cn/user_guides/config.md b/mmdetection/docs/zh_cn/user_guides/config.md
new file mode 100644
index 00000000..3a670bf8
--- /dev/null
+++ b/mmdetection/docs/zh_cn/user_guides/config.md
@@ -0,0 +1,589 @@
+# 学习配置文件
+
+MMDetection 和其他 OpenMMLab 仓库使用 [MMEngine 的配置文件系统](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/config.html)。 配置文件使用了模块化和继承设计，以便于进行各类实验。
+
+## 配置文件的内容
+
+MMDetection 采用模块化设计，所有功能的模块都可以通过配置文件进行配置。 以 Mask R-CNN 为例，我们将根据不同的功能模块介绍配置文件中的各个字段：
+
+### 模型配置
+
+在 mmdetection 的配置中，我们使用 `model` 字段来配置检测算法的组件。 除了 `backbone`、`neck` 等神经网络组件外，还需要 `data_preprocessor`、`train_cfg` 和 `test_cfg`。 `data_preprocessor` 负责对 dataloader 输出的每一批数据进行预处理。 模型配置中的 `train_cfg` 和 `test_cfg` 用于设置训练和测试组件的超参数。
+
+```python
+model = dict(
+    type='MaskRCNN',  # 检测器名
+    data_preprocessor=dict(  # 数据预处理器的配置，通常包括图像归一化和 padding
+        type='DetDataPreprocessor',  # 数据预处理器的类型，参考 https://mmdetection.readthedocs.io/en/latest/api.html#mmdet.models.data_preprocessors.DetDataPreprocessor
+        mean=[123.675, 116.28, 103.53],  # 用于预训练骨干网络的图像归一化通道均值，按 R、G、B 排序
+        std=[58.395, 57.12, 57.375],  # 用于预训练骨干网络的图像归一化通道标准差，按 R、G、B 排序
+        bgr_to_rgb=True,  # 是否将图片通道从 BGR 转为 RGB
+        pad_mask=True,  # 是否填充实例分割掩码
+        pad_size_divisor=32),  # padding 后的图像的大小应该可以被 ``pad_size_divisor`` 整除
+    backbone=dict(  # 主干网络的配置文件
+        type='ResNet',  # 主干网络的类别，可用选项请参考 https://mmdetection.readthedocs.io/en/latest/api.html#mmdet.models.backbones.ResNet
+        depth=50,  # 主干网络的深度，对于 ResNet 和 ResNext 通常设置为 50 或 101
+        num_stages=4,  # 主干网络状态(stages)的数目，这些状态产生的特征图作为后续的 head 的输入
+        out_indices=(0, 1, 2, 3),  # 每个状态产生的特征图输出的索引
+        frozen_stages=1,  # 第一个状态的权重被冻结
+        norm_cfg=dict(  # 归一化层(norm layer)的配置项
+            type='BN',  # 归一化层的类别，通常是 BN 或 GN
+            requires_grad=True),  # 是否训练归一化里的 gamma 和 beta
+        norm_eval=True,  # 是否冻结 BN 里的统计项
+        style='pytorch',  # 主干网络的风格，'pytorch' 意思是步长为2的层为 3x3 卷积， 'caffe' 意思是步长为2的层为 1x1 卷积
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),  # 加载通过 ImageNet 预训练的模型
+    neck=dict(
+        type='FPN',  # 检测器的 neck 是 FPN，我们同样支持 'NASFPN', 'PAFPN' 等，更多细节可以参考 https://mmdetection.readthedocs.io/en/latest/api.html#mmdet.models.necks.FPN
+        in_channels=[256, 512, 1024, 2048],  # 输入通道数，这与主干网络的输出通道一致
+        out_channels=256,  # 金字塔特征图每一层的输出通道
+        num_outs=5),  # 输出的范围(scales)
+    rpn_head=dict(
+        type='RPNHead',  # rpn_head 的类型是 'RPNHead', 我们也支持 'GARPNHead' 等，更多细节可以参考 https://mmdetection.readthedocs.io/en/latest/api.html#mmdet.models.dense_heads.RPNHead
+        in_channels=256,  # 每个输入特征图的输入通道，这与 neck 的输出通道一致
+        feat_channels=256,  # head 卷积层的特征通道
+        anchor_generator=dict(  # 锚点(Anchor)生成器的配置
+            type='AnchorGenerator',  # 大多数方法使用 AnchorGenerator 作为锚点生成器, SSD 检测器使用 `SSDAnchorGenerator`。更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/task_modules/prior_generators/anchor_generator.py#L18
+            scales=[8],  # 锚点的基本比例，特征图某一位置的锚点面积为 scale * base_sizes
+            ratios=[0.5, 1.0, 2.0],  # 高度和宽度之间的比率
+            strides=[4, 8, 16, 32, 64]),  # 锚生成器的步幅。这与 FPN 特征步幅一致。 如果未设置 base_sizes，则当前步幅值将被视为 base_sizes
+        bbox_coder=dict(  # 在训练和测试期间对框进行编码和解码
+            type='DeltaXYWHBBoxCoder',  # 框编码器的类别，'DeltaXYWHBBoxCoder' 是最常用的，更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/task_modules/coders/delta_xywh_bbox_coder.py#L13
+            target_means=[0.0, 0.0, 0.0, 0.0],  # 用于编码和解码框的目标均值
+            target_stds=[1.0, 1.0, 1.0, 1.0]),  # 用于编码和解码框的标准差
+        loss_cls=dict(  # 分类分支的损失函数配置
+            type='CrossEntropyLoss',  # 分类分支的损失类型，我们也支持 FocalLoss 等，更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/losses/cross_entropy_loss.py#L201
+            use_sigmoid=True,  # RPN 通常进行二分类，所以通常使用 sigmoid 函数
+            los_weight=1.0),  # 分类分支的损失权重
+        loss_bbox=dict(  # 回归分支的损失函数配置
+            type='L1Loss',  # 损失类型，我们还支持许多 IoU Losses 和 Smooth L1-loss 等，更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/losses/smooth_l1_loss.py#L56
+            loss_weight=1.0)),  # 回归分支的损失权重
+    roi_head=dict(  # RoIHead 封装了两步(two-stage)/级联(cascade)检测器的第二步
+        type='StandardRoIHead',  # RoI head 的类型，更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/roi_heads/standard_roi_head.py#L17
+        bbox_roi_extractor=dict(  # 用于 bbox 回归的 RoI 特征提取器
+            type='SingleRoIExtractor',  # RoI 特征提取器的类型，大多数方法使用 SingleRoIExtractor，更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/roi_heads/roi_extractors/single_level_roi_extractor.py#L13
+            roi_layer=dict(  # RoI 层的配置
+                type='RoIAlign',  # RoI 层的类别, 也支持 DeformRoIPoolingPack 和 ModulatedDeformRoIPoolingPack，更多细节请参考 https://mmcv.readthedocs.io/en/latest/api.html#mmcv.ops.RoIAlign
+                output_size=7,  # 特征图的输出大小
+                sampling_ratio=0),  # 提取 RoI 特征时的采样率。0 表示自适应比率
+            out_channels=256,  # 提取特征的输出通道
+            featmap_strides=[4, 8, 16, 32]),  # 多尺度特征图的步幅，应该与主干的架构保持一致
+        bbox_head=dict(  # RoIHead 中 box head 的配置
+            type='Shared2FCBBoxHead',  # bbox head 的类别，更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/roi_heads/bbox_heads/convfc_bbox_head.py#L220
+            in_channels=256,  # bbox head 的输入通道。 这与 roi_extractor 中的 out_channels 一致
+            fc_out_channels=1024,  # FC 层的输出特征通道
+            roi_feat_size=7,  # 候选区域(Region of Interest)特征的大小
+            num_classes=80,  # 分类的类别数量
+            bbox_coder=dict(  # 第二阶段使用的框编码器
+                type='DeltaXYWHBBoxCoder',  # 框编码器的类别，大多数情况使用 'DeltaXYWHBBoxCoder'
+                target_means=[0.0, 0.0, 0.0, 0.0],  # 用于编码和解码框的均值
+                target_stds=[0.1, 0.1, 0.2, 0.2]),  # 编码和解码的标准差。因为框更准确，所以值更小，常规设置时 [0.1, 0.1, 0.2, 0.2]。
+            reg_class_agnostic=False,  # 回归是否与类别无关
+            loss_cls=dict(  # 分类分支的损失函数配
+                type='CrossEntropyLoss',  # 分类分支的损失类型，我们也支持 FocalLoss 等
+                use_sigmoid=False,  # 是否使用 sigmoid
+                loss_weight=1.0),  # 分类分支的损失权重
+            loss_bbox=dict(  # 回归分支的损失函数配置
+                type='L1Loss',  # 损失类型，我们还支持许多 IoU Losses 和 Smooth L1-loss 等
+                loss_weight=1.0)),  # 回归分支的损失权重
+        mask_roi_extractor=dict(  # 用于 mask 生成的 RoI 特征提取器
+            type='SingleRoIExtractor',  # RoI 特征提取器的类型，大多数方法使用 SingleRoIExtractor
+            roi_layer=dict(  # 提取实例分割特征的 RoI 层配置
+                type='RoIAlign',  # RoI 层的类型，也支持 DeformRoIPoolingPack 和 ModulatedDeformRoIPoolingPack
+                output_size=14,  # 特征图的输出大小
+                sampling_ratio=0),  # 提取 RoI 特征时的采样率
+            out_channels=256,  # 提取特征的输出通道
+            featmap_strides=[4, 8, 16, 32]),  # 多尺度特征图的步幅
+        mask_head=dict(  # mask 预测 head 模型
+            type='FCNMaskHead',  # mask head 的类型，更多细节请参考 https://mmdetection.readthedocs.io/en/latest/api.html#mmdet.models.roi_heads.FCNMaskHead
+            num_convs=4,  # mask head 中的卷积层数
+            in_channels=256,  # 输入通道，应与 mask roi extractor 的输出通道一致
+            conv_out_channels=256,  # 卷积层的输出通道
+            num_classes=80,  # 要分割的类别数
+            loss_mask=dict(  # mask 分支的损失函数配置
+                type='CrossEntropyLoss',  # 用于分割的损失类型
+                use_mask=True,  # 是否只在正确的类中训练 mask
+                loss_weight=1.0))),  # mask 分支的损失权重
+    train_cfg = dict(  # rpn 和 rcnn 训练超参数的配置
+        rpn=dict(  # rpn 的训练配置
+            assigner=dict(  # 分配器(assigner)的配置
+                type='MaxIoUAssigner',  # 分配器的类型，MaxIoUAssigner 用于许多常见的检测器，更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/task_modules/assigners/max_iou_assigner.py#L14
+                pos_iou_thr=0.7,  # IoU >= 0.7(阈值) 被视为正样本
+                neg_iou_thr=0.3,  # IoU < 0.3(阈值) 被视为负样本
+                min_pos_iou=0.3,  # 将框作为正样本的最小 IoU 阈值
+                match_low_quality=True,  # 是否匹配低质量的框(更多细节见 API 文档)
+                ignore_iof_thr=-1),  # 忽略 bbox 的 IoF 阈值
+            sampler=dict(  # 正/负采样器(sampler)的配置
+                type='RandomSampler',  # 采样器类型，还支持 PseudoSampler 和其他采样器，更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/task_modules/samplers/random_sampler.py#L14
+                num=256,  # 样本数量。
+                pos_fraction=0.5,  # 正样本占总样本的比例
+                neg_pos_ub=-1,  # 基于正样本数量的负样本上限
+                add_gt_as_proposals=False),  # 采样后是否添加 GT 作为 proposal
+            allowed_border=-1,  # 填充有效锚点后允许的边框
+            pos_weight=-1,  # 训练期间正样本的权重
+            debug=False),  # 是否设置调试(debug)模式
+        rpn_proposal=dict(  # 在训练期间生成 proposals 的配置
+            nms_across_levels=False,  # 是否对跨层的 box 做 NMS。仅适用于 `GARPNHead` ，naive rpn 不支持 nms cross levels
+            nms_pre=2000,  # NMS 前的 box 数
+            nms_post=1000,  # NMS 要保留的 box 的数量，只在 GARPNHHead 中起作用
+            max_per_img=1000,  # NMS 后要保留的 box 数量
+            nms=dict( # NMS 的配置
+                type='nms',  # NMS 的类别
+                iou_threshold=0.7 # NMS 的阈值
+                ),
+            min_bbox_size=0),  # 允许的最小 box 尺寸
+        rcnn=dict(  # roi head 的配置。
+            assigner=dict(  # 第二阶段分配器的配置，这与 rpn 中的不同
+                type='MaxIoUAssigner',  # 分配器的类型，MaxIoUAssigner 目前用于所有 roi_heads。更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/task_modules/assigners/max_iou_assigner.py#L14
+                pos_iou_thr=0.5,  # IoU >= 0.5(阈值)被认为是正样本
+                neg_iou_thr=0.5,  # IoU < 0.5(阈值)被认为是负样本
+                min_pos_iou=0.5,  # 将 box 作为正样本的最小 IoU 阈值
+                match_low_quality=False,  # 是否匹配低质量下的 box(有关更多详细信息，请参阅 API 文档)
+                ignore_iof_thr=-1),  # 忽略 bbox 的 IoF 阈值
+            sampler=dict(
+                type='RandomSampler',  # 采样器的类型，还支持 PseudoSampler 和其他采样器，更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/main/mmdet/models/task_modules/samplers/random_sampler.py#L14
+                num=512,  # 样本数量
+                pos_fraction=0.25,  # 正样本占总样本的比例
+                neg_pos_ub=-1,  # 基于正样本数量的负样本上限
+                add_gt_as_proposals=True
+            ),  # 采样后是否添加 GT 作为 proposal
+            mask_size=28,  # mask 的大小
+            pos_weight=-1,  # 训练期间正样本的权重
+            debug=False)),  # 是否设置调试模式
+    test_cfg = dict(  # 用于测试 rpn 和 rcnn 超参数的配置
+        rpn=dict(  # 测试阶段生成 proposals 的配置
+            nms_across_levels=False,  # 是否对跨层的 box 做 NMS。仅适用于 `GARPNHead`，naive rpn 不支持做 NMS cross levels
+            nms_pre=1000,  # NMS 前的 box 数
+            nms_post=1000,  # NMS 要保留的 box 的数量，只在 `GARPNHHead` 中起作用
+            max_per_img=1000,  # NMS 后要保留的 box 数量
+            nms=dict( # NMS 的配置
+                type='nms',  # NMS 的类型
+                iou_threshold=0.7 # NMS 阈值
+                ),
+            min_bbox_size=0),  # box 允许的最小尺寸
+        rcnn=dict(  # roi heads 的配置
+            score_thr=0.05,  # bbox 的分数阈值
+            nms=dict(  # 第二步的 NMS 配置
+                type='nms',  # NMS 的类型
+                iou_thr=0.5),  # NMS 的阈值
+            max_per_img=100,  # 每张图像的最大检测次数
+            mask_thr_binary=0.5)))  # mask 预处的阈值
+```
+
+### 数据集和评测器配置
+
+在使用[执行器](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/runner.html) 进行训练、测试、验证时，我们需要配置 [Dataloader](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/dataset.html)。构建数据 dataloader 需要设置数据集（dataset）和数据处理流程（data pipeline）。 由于这部分的配置较为复杂，我们使用中间变量来简化 dataloader 配置的编写。
+
+```python
+dataset_type = 'CocoDataset'  # 数据集类型，这将被用来定义数据集。
+data_root = 'data/coco/'  # 数据的根路径。
+
+train_pipeline = [  # 训练数据处理流程
+    dict(type='LoadImageFromFile'),  # 第 1 个流程，从文件路径里加载图像。
+    dict(
+        type='LoadAnnotations',  # 第 2 个流程，对于当前图像，加载它的注释信息。
+        with_bbox=True,  # 是否使用标注框(bounding box)， 目标检测需要设置为 True。
+        with_mask=True,  # 是否使用 instance mask，实例分割需要设置为 True。
+        poly2mask=False),  # 是否将 polygon mask 转化为 instance mask, 设置为 False 以加速和节省内存。
+    dict(
+        type='Resize',  # 变化图像和其标注大小的流程。
+        scale=(1333, 800),  # 图像的最大尺寸
+        keep_ratio=True  # 是否保持图像的长宽比。
+        ),
+    dict(
+        type='RandomFlip',  # 翻转图像和其标注的数据增广流程。
+        prob=0.5),  # 翻转图像的概率。
+    dict(type='PackDetInputs')  # 将数据转换为检测器输入格式的流程
+]
+test_pipeline = [  # 测试数据处理流程
+    dict(type='LoadImageFromFile'),  # 第 1 个流程，从文件路径里加载图像。
+    dict(type='Resize', scale=(1333, 800), keep_ratio=True),  # 变化图像大小的流程。
+    dict(
+        type='PackDetInputs',  # 将数据转换为检测器输入格式的流程
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+train_dataloader = dict(  # 训练 dataloader 配置
+    batch_size=2,  # 单个 GPU 的 batch size
+    num_workers=2,  # 单个 GPU 分配的数据加载线程数
+    persistent_workers=True,  # 如果设置为 True，dataloader 在迭代完一轮之后不会关闭数据读取的子进程，可以加速训练
+    sampler=dict(  # 训练数据的采样器
+        type='DefaultSampler',  # 默认的采样器，同时支持分布式和非分布式训练。请参考 https://mmengine.readthedocs.io/zh_CN/latest/api/generated/mmengine.dataset.DefaultSampler.html#mmengine.dataset.DefaultSampler
+        shuffle=True),  # 随机打乱每个轮次训练数据的顺序
+    batch_sampler=dict(type='AspectRatioBatchSampler'),  # 批数据采样器，用于确保每一批次内的数据拥有相似的长宽比，可用于节省显存
+    dataset=dict(  # 训练数据集的配置
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='annotations/instances_train2017.json',  # 标注文件路径
+        data_prefix=dict(img='train2017/'),  # 图片路径前缀
+        filter_cfg=dict(filter_empty_gt=True, min_size=32),  # 图片和标注的过滤配置
+        pipeline=train_pipeline))  # 这是由之前创建的 train_pipeline 定义的数据处理流程。
+val_dataloader = dict(  # 验证 dataloader 配置
+    batch_size=1,  # 单个 GPU 的 Batch size。如果 batch-szie > 1，组成 batch 时的额外填充会影响模型推理精度
+    num_workers=2,  # 单个 GPU 分配的数据加载线程数
+    persistent_workers=True,  # 如果设置为 True，dataloader 在迭代完一轮之后不会关闭数据读取的子进程，可以加速训练
+    drop_last=False,  # 是否丢弃最后未能组成一个批次的数据
+    sampler=dict(
+        type='DefaultSampler',
+        shuffle=False),  # 验证和测试时不打乱数据顺序
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='annotations/instances_val2017.json',
+        data_prefix=dict(img='val2017/'),
+        test_mode=True,  # 开启测试模式，避免数据集过滤图片和标注
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader  # 测试 dataloader 配置
+```
+
+[评测器](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/evaluation.html) 用于计算训练模型在验证和测试数据集上的指标。评测器的配置由一个或一组评价指标（Metric）配置组成：
+
+```python
+val_evaluator = dict(  # 验证过程使用的评测器
+    type='CocoMetric',  # 用于评估检测和实例分割的 AR、AP 和 mAP 的 coco 评价指标
+    ann_file=data_root + 'annotations/instances_val2017.json',  # 标注文件路径
+    metric=['bbox', 'segm'],  # 需要计算的评价指标，`bbox` 用于检测，`segm` 用于实例分割
+    format_only=False)
+test_evaluator = val_evaluator  # 测试过程使用的评测器
+```
+
+由于测试数据集没有标注文件，因此 MMDetection 中的 test_dataloader 和 test_evaluator 配置通常等于val。 如果要保存在测试数据集上的检测结果，则可以像这样编写配置：
+
+```python
+# 在测试集上推理，
+# 并将检测结果转换格式以用于提交结果
+test_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file=data_root + 'annotations/image_info_test-dev2017.json',
+        data_prefix=dict(img='test2017/'),
+        test_mode=True,
+        pipeline=test_pipeline))
+test_evaluator = dict(
+    type='CocoMetric',
+    ann_file=data_root + 'annotations/image_info_test-dev2017.json',
+    metric=['bbox', 'segm'],
+    format_only=True,  # 只将模型输出转换为 coco 的 JSON 格式并保存
+    outfile_prefix='./work_dirs/coco_detection/test')  # 要保存的 JSON 文件的前缀
+```
+
+### 训练和测试的配置
+
+MMEngine 的 Runner 使用 Loop 来控制训练，验证和测试过程。
+用户可以使用这些字段设置最大训练轮次和验证间隔。
+
+```python
+train_cfg = dict(
+    type='EpochBasedTrainLoop',  # 训练循环的类型，请参考 https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py
+    max_epochs=12,  # 最大训练轮次
+    val_interval=1)  # 验证间隔。每个 epoch 验证一次
+val_cfg = dict(type='ValLoop')  # 验证循环的类型
+test_cfg = dict(type='TestLoop')  # 测试循环的类型
+```
+
+### 优化相关配置
+
+`optim_wrapper` 是配置优化相关设置的字段。优化器封装（OptimWrapper）不仅提供了优化器的功能，还支持梯度裁剪、混合精度训练等功能。更多内容请看[优化器封装教程](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/optim_wrapper.html) 。
+
+```python
+optim_wrapper = dict(  # 优化器封装的配置
+    type='OptimWrapper',  # 优化器封装的类型。可以切换至 AmpOptimWrapper 来启用混合精度训练
+    optimizer=dict(  # 优化器配置。支持 PyTorch 的各种优化器。请参考 https://pytorch.org/docs/stable/optim.html#algorithms
+        type='SGD',  # 随机梯度下降优化器
+        lr=0.02,  # 基础学习率
+        momentum=0.9,  # 带动量的随机梯度下降
+        weight_decay=0.0001),  # 权重衰减
+    clip_grad=None,  # 梯度裁剪的配置，设置为 None 关闭梯度裁剪。使用方法请见 https://mmengine.readthedocs.io/en/latest/tutorials/optimizer.html
+    )
+```
+
+`param_scheduler` 字段用于配置参数调度器（Parameter Scheduler）来调整优化器的超参数（例如学习率和动量）。 用户可以组合多个调度器来创建所需的参数调整策略。 在 [参数调度器教程](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/param_scheduler.html) 和 [参数调度器 API 文档](https://mmengine.readthedocs.io/zh_CN/latest/api/generated/mmengine.optim._ParamScheduler.html#mmengine.optim._ParamScheduler) 中查找更多信息。
+
+```python
+param_scheduler = [
+    dict(
+        type='LinearLR',  # 使用线性学习率预热
+        start_factor=0.001, # 学习率预热的系数
+        by_epoch=False,  # 按 iteration 更新预热学习率
+        begin=0,  # 从第一个 iteration 开始
+        end=500),  # 到第 500 个 iteration 结束
+    dict(
+        type='MultiStepLR',  # 在训练过程中使用 multi step 学习率策略
+        by_epoch=True,  # 按 epoch 更新学习率
+        begin=0,   # 从第一个 epoch 开始
+        end=12,  # 到第 12 个 epoch 结束
+        milestones=[8, 11],  # 在哪几个 epoch 进行学习率衰减
+        gamma=0.1)  # 学习率衰减系数
+]
+```
+
+### 钩子配置
+
+用户可以在训练、验证和测试循环上添加钩子，以便在运行期间插入一些操作。配置中有两种不同的钩子字段，一种是 `default_hooks`，另一种是 `custom_hooks`。
+
+`default_hooks` 是一个字典，用于配置运行时必须使用的钩子。这些钩子具有默认优先级，如果未设置，runner 将使用默认值。如果要禁用默认钩子，用户可以将其配置设置为 `None`。更多内容请看 [钩子教程](https://mmengine.readthedocs.io/zh_CN/latest/tutorials/hook.html) 。
+
+```python
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', interval=1),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='DetVisualizationHook'))
+```
+
+`custom_hooks` 是一个列表。用户可以在这个字段中加入自定义的钩子。
+
+```python
+custom_hooks = []
+```
+
+### 运行相关配置
+
+```python
+default_scope = 'mmdet'  # 默认的注册器域名，默认从此注册器域中寻找模块。请参考 https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/registry.html
+
+env_cfg = dict(
+    cudnn_benchmark=False,  # 是否启用 cudnn benchmark
+    mp_cfg=dict(  # 多进程设置
+        mp_start_method='fork',  # 使用 fork 来启动多进程。'fork' 通常比 'spawn' 更快，但可能存在隐患。请参考 https://github.com/pytorch/pytorch/issues/1355
+        opencv_num_threads=0),  # 关闭 opencv 的多线程以避免系统超负荷
+    dist_cfg=dict(backend='nccl'),  # 分布式相关设置
+)
+
+vis_backends = [dict(type='LocalVisBackend')]  # 可视化后端，请参考 https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/visualization.html
+visualizer = dict(
+    type='DetLocalVisualizer', vis_backends=vis_backends, name='visualizer')
+log_processor = dict(
+    type='LogProcessor',  # 日志处理器用于处理运行时日志
+    window_size=50,  # 日志数值的平滑窗口
+    by_epoch=True)  # 是否使用 epoch 格式的日志。需要与训练循环的类型保存一致。
+
+log_level = 'INFO'  # 日志等级
+load_from = None  # 从给定路径加载模型检查点作为预训练模型。这不会恢复训练。
+resume = False  # 是否从 `load_from` 中定义的检查点恢复。 如果 `load_from` 为 None，它将恢复 `work_dir` 中的最新检查点。
+```
+
+## Iter-based 配置
+
+MMEngine 的 Runner 除了基于轮次的训练循环（epoch）外，还提供了基于迭代（iteration）的训练循环。
+要使用基于迭代的训练，用户应该修改 `train_cfg`、`param_scheduler`、`train_dataloader`、`default_hooks` 和 `log_processor`。
+以下是将基于 epoch 的 RetinaNet 配置更改为基于 iteration 的示例：configs/retinanet/retinanet_r50_fpn_90k_coco.py
+
+```python
+# iter-based 训练配置
+train_cfg = dict(
+    _delete_=True,  # 忽略继承的配置文件中的值（可选）
+    type='IterBasedTrainLoop',  # iter-based 训练循环
+    max_iters=90000,  # 最大迭代次数
+    val_interval=10000)  # 每隔多少次进行一次验证
+
+
+# 将参数调度器修改为 iter-based
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500),
+    dict(
+        type='MultiStepLR',
+        begin=0,
+        end=90000,
+        by_epoch=False,
+        milestones=[60000, 80000],
+        gamma=0.1)
+]
+
+# 切换至 InfiniteSampler 来避免 dataloader 重启
+train_dataloader = dict(sampler=dict(type='InfiniteSampler'))
+
+# 将模型检查点保存间隔设置为按 iter 保存
+default_hooks = dict(checkpoint=dict(by_epoch=False, interval=10000))
+
+# 将日志格式修改为 iter-based
+log_processor = dict(by_epoch=False)
+```
+
+## 配置文件继承
+
+在 `config/_base_` 文件夹下有 4 个基本组件类型，分别是：数据集(dataset)，模型(model)，训练策略(schedule)和运行时的默认设置(default runtime)。许多方法，例如 Faster R-CNN、Mask R-CNN、Cascade R-CNN、RPN、SSD 能够很容易地构建出来。由 `_base_` 下的组件组成的配置，被我们称为 _原始配置(primitive)_。
+
+对于同一文件夹下的所有配置，推荐**只有一个**对应的**原始配置**文件。所有其他的配置文件都应该继承自这个**原始配置**文件。这样就能保证配置文件的最大继承深度为 3。
+
+为了便于理解，我们建议贡献者继承现有方法。例如，如果在 Faster R-CNN 的基础上做了一些修改，用户首先可以通过指定 `_base_ = ../faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py` 来继承基础的 Faster R-CNN 结构，然后修改配置文件中的必要参数以完成继承。
+
+如果你在构建一个与任何现有方法不共享结构的全新方法，那么可以在 `configs` 文件夹下创建一个新的例如 `xxx_rcnn` 文件夹。
+
+更多细节请参考 [MMEngine 配置文件教程](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/config.html) 。
+
+通过设置 `_base_` 字段，我们可以设置当前配置文件继承自哪些文件。
+
+当 `_base_` 为文件路径字符串时，表示继承一个配置文件的内容。
+
+```python
+_base_ = './mask-rcnn_r50_fpn_1x_coco.py'
+```
+
+当 `_base_` 是多个文件路径的列表时，表示继承多个文件。
+
+```python
+_base_ = [
+    '../_base_/models/mask-rcnn_r50_fpn.py',
+    '../_base_/datasets/coco_instance.py',
+    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
+]
+```
+
+如果需要检查配置文件，可以通过运行 `python tools/misc/print_config.py /PATH/TO/CONFIG` 来查看完整的配置。
+
+### 忽略基础配置文件里的部分内容
+
+有时，您也许会设置 `_delete_=True` 去忽略基础配置文件里的一些域内容。 您也许可以参照 [MMEngine 配置文件教程](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/config.html) 来获得一些简单的指导。
+
+在 MMDetection 里，例如为了改变  Mask R-CNN 的主干网络的某些内容：
+
+```python
+model = dict(
+    type='MaskRCNN',
+    backbone=dict(
+        type='ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type='BN', requires_grad=True),
+        norm_eval=True,
+        style='pytorch',
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),
+    neck=dict(...),
+    rpn_head=dict(...),
+    roi_head=dict(...))
+```
+
+基础配置的 `Mask R-CNN` 使用 `ResNet-50`，在需要将主干网络改成 `HRNet` 的时候，因为 `HRNet` 和 `ResNet` 中有不同的字段，需要使用 `_delete_=True` 将新的键去替换 `backbone` 域内所有老的键。
+
+```python
+_base_ = '../mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py'
+model = dict(
+    backbone=dict(
+        _delete_=True,
+        type='HRNet',
+        extra=dict(
+            stage1=dict(
+                num_modules=1,
+                num_branches=1,
+                block='BOTTLENECK',
+                num_blocks=(4, ),
+                num_channels=(64, )),
+            stage2=dict(
+                num_modules=1,
+                num_branches=2,
+                block='BASIC',
+                num_blocks=(4, 4),
+                num_channels=(32, 64)),
+            stage3=dict(
+                num_modules=4,
+                num_branches=3,
+                block='BASIC',
+                num_blocks=(4, 4, 4),
+                num_channels=(32, 64, 128)),
+            stage4=dict(
+                num_modules=3,
+                num_branches=4,
+                block='BASIC',
+                num_blocks=(4, 4, 4, 4),
+                num_channels=(32, 64, 128, 256))),
+        init_cfg=dict(type='Pretrained', checkpoint='open-mmlab://msra/hrnetv2_w32')),
+    neck=dict(...))
+```
+
+### 使用配置文件里的中间变量
+
+配置文件里会使用一些中间变量，例如数据集里的 `train_pipeline`/`test_pipeline`。我们在定义新的 `train_pipeline`/`test_pipeline` 之后，需要将它们传递到 `data` 里。例如，我们想在训练或测试时，改变 Mask R-CNN 的多尺度策略 (multi scale strategy)，`train_pipeline`/`test_pipeline` 是我们想要修改的中间变量。
+
+```python
+_base_ = './mask-rcnn_r50_fpn_1x_coco.py'
+
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
+    dict(
+        type='RandomResize', scale=[(1333, 640), (1333, 800)],
+        keep_ratio=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(1333, 800), keep_ratio=True),
+    dict(
+        type='PackDetInputs',
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
+val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+test_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+```
+
+我们首先定义新的 `train_pipeline`/`test_pipeline` 然后传递到 `data` 里。
+
+同样的，如果我们想从 `SyncBN` 切换到 `BN` 或者 `MMSyncBN`，我们需要修改配置文件里的每一个  `norm_cfg`。
+
+```python
+_base_ = './mask-rcnn_r50_fpn_1x_coco.py'
+norm_cfg = dict(type='BN', requires_grad=True)
+model = dict(
+    backbone=dict(norm_cfg=norm_cfg),
+    neck=dict(norm_cfg=norm_cfg),
+    ...)
+```
+
+### 复用 \_base\_ 文件中的变量
+
+如果用户希望在当前配置中复用 base 文件中的变量，则可以通过使用 `{{_base_.xxx}}` 的方式来获取对应变量的拷贝。例如：
+
+```python
+_base_ = './mask-rcnn_r50_fpn_1x_coco.py'
+
+a = {{_base_.model}}  # 变量 a 等于 _base_ 中定义的 model
+```
+
+## 通过脚本参数修改配置
+
+当运行 `tools/train.py` 和 `tools/test.py` 时，可以通过 `--cfg-options` 来修改配置文件。
+
+- 更新字典链中的配置
+
+  可以按照原始配置文件中的 dict 键顺序地指定配置预选项。例如，使用 `--cfg-options model.backbone.norm_eval=False` 将模型主干网络中的所有 BN 模块都改为 `train` 模式。
+
+- 更新配置列表中的键
+
+  在配置文件里，一些字典型的配置被包含在列表中。例如，数据训练流程 `data.train.pipeline` 通常是一个列表，比如 `[dict(type='LoadImageFromFile'), ...]`。如果需要将 `'LoadImageFromFile'` 改成 `'LoadImageFromWebcam'`，需要写成下述形式： `--cfg-options data.train.pipeline.0.type=LoadImageFromNDArray`.
+
+- 更新列表或元组的值
+
+  如果要更新的值是列表或元组。例如，配置文件通常设置 `model.data_preprocessor.mean=[123.675, 116.28, 103.53]`. 如果需要改变这个键，可以通过 `--cfg-options model.data_preprocessor.mean="[127,127,127]"` 来重新设置。需要注意，引号 " 是支持列表或元组数据类型所必需的，并且在指定值的引号内**不允许**有空格。
+
+## 配置文件名称风格
+
+我们遵循以下样式来命名配置文件。建议贡献者遵循相同的风格。
+
+```
+{algorithm name}_{model component names [component1]_[component2]_[...]}_{training settings}_{training dataset information}_{testing dataset information}.py
+```
+
+文件名分为五个部分。 每个部分用`_`连接，每个部分内的单词应该用`-`连接。
+
+- `{algorithm name}`: 算法的名称。 它可以是检测器名称，例如 `faster-rcnn`、`mask-rcnn` 等。也可以是半监督或知识蒸馏算法，例如 `soft-teacher`、`lad` 等等
+- `{component names}`: 算法中使用的组件名称，如 backbone、neck 等。例如 `r50-caffe_fpn_gn-head` 表示在算法中使用 caffe 版本的 ResNet50、FPN 和 使用了 Group Norm 的检测头。
+- `{training settings}`: 训练设置的信息，例如 batch 大小、数据增强、损失、参数调度方式和训练最大轮次/迭代。 例如：`4xb4-mixup-giou-coslr-100e` 表示使用 8 个 gpu 每个 gpu 4 张图、mixup 数据增强、GIoU loss、余弦退火学习率，并训练 100 个 epoch。
+  缩写介绍:
+  - `{gpu x batch_per_gpu}`: GPU 数和每个 GPU 的样本数。`bN` 表示每个 GPU 上的 batch 大小为 N。例如 `4x4b` 是 4 个 GPU 每个 GPU 4 张图的缩写。如果没有注明，默认为 8 卡每卡 2 张图。
+  - `{schedule}`: 训练方案，选项是 `1x`、 `2x`、 `20e` 等。`1x`  和 `2x` 分别代表 12 epoch 和 24 epoch，`20e` 在级联模型中使用，表示 20 epoch。对于 `1x`/`2x`，初始学习率在第 8/16 和第 11/22 epoch 衰减 10 倍；对于 `20e` ，初始学习率在第 16 和第 19 epoch 衰减 10 倍。
+- `{training dataset information}`: 训练数据集，例如 `coco`, `coco-panoptic`, `cityscapes`, `voc-0712`, `wider-face`。
+- `{testing dataset information}` (可选): 测试数据集，用于训练和测试在不同数据集上的模型配置。 如果没有注明，则表示训练和测试的数据集类型相同。
diff --git a/mmdetection/docs/zh_cn/user_guides/dataset_prepare.md b/mmdetection/docs/zh_cn/user_guides/dataset_prepare.md
new file mode 100644
index 00000000..1caad856
--- /dev/null
+++ b/mmdetection/docs/zh_cn/user_guides/dataset_prepare.md
@@ -0,0 +1,362 @@
+## 数据集准备
+
+### 基础检测数据集准备
+
+MMDetection 支持多个公共数据集，包括 [COCO](https://cocodataset.org/)， [Pascal VOC](http://host.robots.ox.ac.uk/pascal/VOC)， [Cityscapes](https://www.cityscapes-dataset.com/) 和 [其他更多数据集](https://github.com/open-mmlab/mmdetection/tree/main/configs/_base_/datasets)。
+
+一些公共数据集，比如 Pascal VOC 及其镜像数据集，或者 COCO 等数据集都可以从官方网站或者镜像网站获取。注意：在检测任务中，Pascal VOC 2012 是 Pascal VOC 2007 的无交集扩展，我们通常将两者一起使用。 我们建议将数据集下载，然后解压到项目外部的某个文件夹内，然后通过符号链接的方式，将数据集根目录链接到 `$MMDETECTION/data` 文件夹下， 如果你的文件夹结构和下方不同的话，你需要在配置文件中改变对应的路径。
+
+我们提供了下载 COCO 等数据集的脚本，你可以运行 `python tools/misc/download_dataset.py --dataset-name coco2017` 下载 COCO 数据集。 对于中国境内的用户，我们也推荐通过开源数据平台 [OpenDataLab](https://opendatalab.com/?source=OpenMMLab%20GitHub) 来下载数据，以获得更好的下载体验。
+
+更多用法请参考[数据集下载](./useful_tools.md#dataset-download)
+
+```text
+mmdetection
+├── mmdet
+├── tools
+├── configs
+├── data
+│   ├── coco
+│   │   ├── annotations
+│   │   ├── train2017
+│   │   ├── val2017
+│   │   ├── test2017
+│   ├── cityscapes
+│   │   ├── annotations
+│   │   ├── leftImg8bit
+│   │   │   ├── train
+│   │   │   ├── val
+│   │   ├── gtFine
+│   │   │   ├── train
+│   │   │   ├── val
+│   ├── VOCdevkit
+│   │   ├── VOC2007
+│   │   ├── VOC2012
+```
+
+有些模型需要额外的 [COCO-stuff](http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/stuffthingmaps_trainval2017.zip) 数据集，比如 HTC，DetectoRS 和 SCNet，你可以下载并解压它们到 `coco` 文件夹下。文件夹会是如下结构：
+
+```text
+mmdetection
+├── data
+│   ├── coco
+│   │   ├── annotations
+│   │   ├── train2017
+│   │   ├── val2017
+│   │   ├── test2017
+│   │   ├── stuffthingmaps
+```
+
+PanopticFPN 等全景分割模型需要额外的 [COCO Panoptic](http://images.cocodataset.org/annotations/panoptic_annotations_trainval2017.zip) 数据集，你可以下载并解压它们到 `coco/annotations` 文件夹下。文件夹会是如下结构：
+
+```text
+mmdetection
+├── data
+│   ├── coco
+│   │   ├── annotations
+│   │   │   ├── panoptic_train2017.json
+│   │   │   ├── panoptic_train2017
+│   │   │   ├── panoptic_val2017.json
+│   │   │   ├── panoptic_val2017
+│   │   ├── train2017
+│   │   ├── val2017
+│   │   ├── test2017
+```
+
+Cityscape 数据集的标注格式需要转换，以与 COCO 数据集标注格式保持一致，使用 `tools/dataset_converters/cityscapes.py` 来完成转换：
+
+```shell
+pip install cityscapesscripts
+
+python tools/dataset_converters/cityscapes.py \
+    ./data/cityscapes \
+    --nproc 8 \
+    --out-dir ./data/cityscapes/annotations
+```
+
+### COCO Caption 数据集准备
+
+COCO Caption 采用的是 COCO2014 数据集作为图片，并且使用了 karpathy 的标注，
+
+首先你需要下载 COCO2014 数据集
+
+```shell
+python tools/misc/download_dataset.py --dataset-name coco2014 --unzip
+```
+
+数据集会下载到当前路径的 `data/coco` 下。然后下载 karpathy 的标注
+
+```shell
+cd data/coco/annotations
+wget https://storage.googleapis.com/sfr-vision-language-research/datasets/coco_karpathy_train.json
+wget https://storage.googleapis.com/sfr-vision-language-research/datasets/coco_karpathy_val.json
+wget https://storage.googleapis.com/sfr-vision-language-research/datasets/coco_karpathy_test.json
+wget https://storage.googleapis.com/sfr-vision-language-research/datasets/coco_karpathy_val_gt.json
+wget https://storage.googleapis.com/sfr-vision-language-research/datasets/coco_karpathy_test_gt.json
+```
+
+最终直接可用于训练和测试的数据集文件夹结构如下：
+
+```text
+mmdetection
+├── data
+│   ├── coco
+│   │   ├── annotations
+│   │   │   ├── coco_karpathy_train.json
+│   │   │   ├── coco_karpathy_test.json
+│   │   │   ├── coco_karpathy_val.json
+│   │   │   ├── coco_karpathy_val_gt.json
+│   │   │   ├── coco_karpathy_test_gt.json
+│   │   ├── train2014
+│   │   ├── val2014
+│   │   ├── test2014
+```
+
+### COCO semantic 数据集准备
+
+COCO 语义分割有两种类型标注，主要差别在于类别名定义不一样，因此处理方式也有两种，第一种是直接使用 stuffthingmaps 数据集，第二种是使用 panoptic 数据集。
+
+**(1) 使用 stuffthingmaps 数据集**
+
+该数据集的下载地址为 [stuffthingmaps_trainval2017](http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/stuffthingmaps_trainval2017.zip)，请下载后解压到 `data/coco` 文件夹下。
+
+```text
+mmdetection
+├── data
+│   ├── coco
+│   │   ├── annotations
+│   │   ├── train2017
+│   │   ├── val2017
+│   │   ├── test2017
+│   │   ├── stuffthingmaps
+```
+
+该数据集不同于标准的 COCO 类别标注，其包括 172 个类： 80 thing 类、91 stuff 类和 1 个 'unlabeled'，其每个类别的说明见 https://github.com/nightrome/cocostuff/blob/master/labels.md
+
+虽然只标注了 172 个类别，但是 `stuffthingmaps` 中最大标签 id 是 182，中间有些类别是没有标注的，并且第 0 类的 `unlabeled` 类别被移除。因此最终的 `stuffthingmaps` 图片中每个位置的值对应的类别关系见 https://github.com/kazuto1011/deeplab-pytorch/blob/master/data/datasets/cocostuff/labels.txt
+
+考虑到训练高效和方便用户，在开启训练或者评估前，我们需要将没有标注的 12 个类移除，这 12 个类的名字为： `street sign、hat、shoe、eye glasses、plate、mirror、window、desk、door、blender、hair brush`，最终可用于训练和评估的类别信息见 `mmdet/datasets/coco_semantic.py`
+
+你可以使用 `tools/dataset_converters/coco_stuff164k.py` 来完成将下载的 `stuffthingmaps` 转换为直接可以训练和评估的数据集，转换后的数据集文件夹结构如下：
+
+```text
+mmdetection
+├── data
+│   ├── coco
+│   │   ├── annotations
+│   │   ├── train2017
+│   │   ├── val2017
+│   │   ├── test2017
+│   │   ├── stuffthingmaps
+│   │   ├── stuffthingmaps_semseg
+```
+
+`stuffthingmaps_semseg` 即为新生成的可以直接训练和测试的 COCO 语义分割数据集。
+
+**(2) 使用 panoptic 数据集**
+
+通过 panoptic 标注生成的语义分割数据集类别数相比使用 `stuffthingmaps` 数据集生成的会少一些。首先你需要准备全景分割标注，然后使用如下脚本完成转换
+
+```shell
+python tools/dataset_converters/prepare_coco_semantic_annos_from_panoptic_annos.py data/coco
+```
+
+转换后的数据集文件夹结构如下：
+
+```text
+mmdetection
+├── data
+│   ├── coco
+│   │   ├── annotations
+│   │   │   ├── panoptic_train2017.json
+│   │   │   ├── panoptic_train2017
+│   │   │   ├── panoptic_val2017.json
+│   │   │   ├── panoptic_val2017
+│   │   │   ├── panoptic_semseg_train2017
+│   │   │   ├── panoptic_semseg_val2017
+│   │   ├── train2017
+│   │   ├── val2017
+│   │   ├── test2017
+```
+
+`panoptic_semseg_train2017` 和 `panoptic_semseg_val2017` 即为新生成的可以直接训练和测试的 COCO 语义分割数据集。注意其类别信息就是 COCO 全景分割的类别信息，包括 thing 和 stuff。
+
+### RefCOCO 数据集准备
+
+[RefCOCO](https://github.com/lichengunc/refer)系列数据集的图像和注释可以通过运行 `tools/misc/download_dataset.py` 下载:
+
+```shell
+python tools/misc/download_dataset.py --dataset-name refcoco --save-dir data/coco --unzip
+```
+
+然后，目录应该是这样的：
+
+```text
+data
+├── coco
+│   ├── refcoco
+│   │   ├── instances.json
+│   │   ├── refs(google).p
+│   │   └── refs(unc).p
+│   ├── refcoco+
+│   │   ├── instances.json
+│   │   └── refs(unc).p
+│   ├── refcocog
+│   │   ├── instances.json
+│   │   ├── refs(google).p
+│   │   └── refs(umd).p
+|   |── train2014
+```
+
+### ADE20K 数据集准备
+
+[ADE20K](http://groups.csail.mit.edu/vision/datasets/ADE20K/)数据集的图像和注释可以通过运行 `tools/misc/download_dataset.py` 下载:
+
+```shell
+python tools/misc/download_dataset.py --dataset-name ade20k_2016 --save-dir data --unzip
+```
+
+然后将注释移至`data/ADEChallengeData2016`目录，并运行预处理脚本以产生coco格式注释：
+
+```shell
+mv data/annotations_instance data/ADEChallengeData2016/
+mv data/categoryMapping.txt data/ADEChallengeData2016/
+mv data/imgCatIds.json data/ADEChallengeData2016/
+python tools/dataset_converters/ade20k2coco.py data/ADEChallengeData2016 --task panoptic
+python tools/dataset_converters/ade20k2coco.py data/ADEChallengeData2016 --task instance
+```
+
+然后，目录应该是这样的：
+
+```text
+data
+├── ADEChallengeData2016
+│   ├── ade20k_instance_train.json
+│   ├── ade20k_instance_val.json
+│   ├── ade20k_panoptic_train
+|   |   ├── ADE_train_00000001.png
+|   |   ├── ADE_train_00000002.png
+|   |   ├── ...
+│   ├── ade20k_panoptic_train.json
+│   ├── ade20k_panoptic_val
+|   |   ├── ADE_val_00000001.png
+|   |   ├── ADE_val_00000002.png
+|   |   ├── ...
+│   ├── ade20k_panoptic_val.json
+│   ├── annotations
+|   |   ├── training
+|   |   |   ├── ADE_train_00000001.png
+|   |   |   ├── ADE_train_00000002.png
+|   |   |   ├── ...
+|   |   ├── validation
+|   |   |   ├── ADE_val_00000001.png
+|   |   |   ├── ADE_val_00000002.png
+|   |   |   ├── ...
+│   ├── annotations_instance
+|   |   ├── training
+|   |   |   ├── ADE_train_00000001.png
+|   |   |   ├── ADE_train_00000002.png
+|   |   |   ├── ...
+|   |   ├── validation
+|   |   |   ├── ADE_val_00000001.png
+|   |   |   ├── ADE_val_00000002.png
+|   |   |   ├── ...
+│   ├── categoryMapping.txt
+│   ├── images
+│   |   ├── training
+|   |   |   ├── ADE_train_00000001.jpg
+|   |   |   ├── ADE_train_00000002.jpg
+|   |   |   ├── ...
+|   |   ├── validation
+|   |   |   ├── ADE_val_00000001.jpg
+|   |   |   ├── ADE_val_00000002.jpg
+|   |   |   ├── ...
+│   ├── imgCatIds.json
+│   ├── objectInfo150.txt
+|   |── sceneCategories.txt
+```
+
+上述文件夹包括ADE20K的语义分割、实例分割和泛在分割的所有数据。
+
+### 从 OpenDataLab 中下载
+
+[OpenDataLab](https://opendatalab.com/) 为人工智能研究者提供免费开源的数据集，通过 OpenDataLab，研究者可以获得格式统一的各领域经典数据集。通过平台的搜索功能，研究者可以迅速便捷地找到自己所需数据集；通过平台的统一格式，研究者可以便捷地对跨数据集任务进行开发。
+
+目前，MIM 支持使用一条命令行从 OpenDataLab 中下载 VOC 和 COCO 数据集，后续将支持更多数据集。你也可以直接访问 OpenDataLab 平台下载你所需的数据集，然后将其转化为 MMDetection 所要求的格式。
+
+如果使用 MIM 下载，请确保版本大于 v0.3.8，你可以使用如下命令更新:
+
+```Bash
+pip install -U openmim
+```
+
+```Bash
+# install OpenXLab CLI tools
+pip install -U openxlab
+# log in OpenXLab, registry
+openxlab login
+
+# download voc2007 and preprocess by MIM
+mim download mmdet --dataset voc2007
+
+# download voc2012 and preprocess by MIM
+mim download mmdet --dataset voc2012
+
+# download coco2017 and preprocess by MIM
+mim download mmdet --dataset coco2017
+```
+
+### ODinW 数据集准备
+
+ODinW 数据集来自 GLIP 论文，用于评估预训练模型泛化性能。一共包括 ODinW-13 和 ODinW-35 两个版本，其中 ODinW-35 包括了 ODinW-13 的所有数据。 目前数据托管在 [huggingface](https://huggingface.co/GLIPModel/GLIP)
+
+请确保你提前安装好了 [git lfs](https://git-lfs.com), 然后按照如下命令下载
+
+```shell
+cd mmdetection
+
+git lfs install
+# 我们不需要下载权重
+GIT_LFS_SKIP_SMUDGE=1 git clone https://huggingface.co/GLIPModel/GLIP
+
+cd GLIP
+git lfs pull --include="odinw_35"
+```
+
+下载完成后，目录结构如下所示：
+
+```text
+mmdetection
+├── GLIP
+|     ├── odinw_35
+|     |   ├── AerialMaritimeDrone.zip
+|     |   ├── AmericanSignLanguageLetters.zip
+...
+```
+
+你可以采用如下命令全部解压并移动到 `mmdetection/data` 路径下：
+
+```shell
+#!/bin/bash
+
+folder="./GLIP/odinw_35/"
+
+find "$folder" -type f -name "*.zip" | while read -r file; do
+    unzip "$file" -d "$(dirname "$file")"
+done
+
+mv GLIP/odinw_35 data/
+```
+
+最终结构如下所示：
+
+```text
+mmdetection
+├── tools
+├── configs
+├── data
+|   ├── odinw_35
+|   |   ├── AerialMaritimeDrone
+...
+│   ├── coco
+```
diff --git a/mmdetection/docs/zh_cn/user_guides/deploy.md b/mmdetection/docs/zh_cn/user_guides/deploy.md
new file mode 100644
index 00000000..f796b004
--- /dev/null
+++ b/mmdetection/docs/zh_cn/user_guides/deploy.md
@@ -0,0 +1,174 @@
+# 模型部署
+
+[MMDeploy](https://github.com/open-mmlab/mmdeploy) 是 OpenMMLab 的部署仓库，负责包括 MMPretrain、MMDetection 等在内的各算法库的部署工作。
+你可以从[这里](https://mmdeploy.readthedocs.io/zh_CN/1.x/04-supported-codebases/mmdet.html)获取 MMDeploy 对 MMDetection 部署支持的最新文档。
+
+本文的结构如下：
+
+- [安装](#安装)
+- [模型转换](#模型转换)
+- [模型规范](#模型规范)
+- [模型推理](#模型推理)
+  - [后端模型推理](#后端模型推理)
+  - [SDK 模型推理](#sdk-模型推理)
+- [模型支持列表](#模型支持列表)
+-
+
+## 安装
+
+请参考[此处](https://mmdetection.readthedocs.io/en/latest/get_started.html)安装 mmdet。然后，按照[说明](https://mmdeploy.readthedocs.io/zh_CN/1.x/get_started.html#mmdeploy)安装 mmdeploy。
+
+```{note}
+如果安装的是 mmdeploy 预编译包，那么也请通过 'git clone https://github.com/open-mmlab/mmdeploy.git --depth=1' 下载 mmdeploy 源码。因为它包含了部署时要用到的配置文件
+```
+
+## 模型转换
+
+假设在安装步骤中，mmdetection 和 mmdeploy 代码库在同级目录下，并且当前的工作目录为 mmdetection 的根目录，那么以 [Faster R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py) 模型为例，你可以从[此处](https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth)下载对应的 checkpoint，并使用以下代码将之转换为 onnx 模型：
+
+```python
+from mmdeploy.apis import torch2onnx
+from mmdeploy.backend.sdk.export_info import export2SDK
+
+img = 'demo/demo.jpg'
+work_dir = 'mmdeploy_models/mmdet/onnx'
+save_file = 'end2end.onnx'
+deploy_cfg = '../mmdeploy/configs/mmdet/detection/detection_onnxruntime_dynamic.py'
+model_cfg = 'configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py'
+model_checkpoint = 'faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth'
+device = 'cpu'
+
+# 1. convert model to onnx
+torch2onnx(img, work_dir, save_file, deploy_cfg, model_cfg,
+           model_checkpoint, device)
+
+# 2. extract pipeline info for inference by MMDeploy SDK
+export2SDK(deploy_cfg, model_cfg, work_dir, pth=model_checkpoint,
+           device=device)
+```
+
+转换的关键之一是使用正确的配置文件。项目中已内置了各后端部署[配置文件](https://github.com/open-mmlab/mmdeploy/tree/1.x/configs/mmdet)。
+文件的命名模式是：
+
+```
+{task}/{task}_{backend}-{precision}_{static | dynamic}_{shape}.py
+```
+
+其中：
+
+- **{task}:** mmdet 中的任务
+
+  mmdet 任务有2种：物体检测（detection）、实例分割（instance-seg）。例如，`RetinaNet`、`Faster R-CNN`、`DETR`等属于前者。`Mask R-CNN`、`SOLO`等属于后者。更多`模型-任务`的划分，请参考章节[模型支持列表](#模型支持列表)。
+
+  **请务必**使用 `detection/detection_*.py` 转换检测模型，使用 `instance-seg/instance-seg_*.py` 转换实例分割模型。
+
+- **{backend}:** 推理后端名称。比如，onnxruntime、tensorrt、pplnn、ncnn、openvino、coreml 等等
+
+- **{precision}:** 推理精度。比如，fp16、int8。不填表示 fp32
+
+- **{static | dynamic}:** 动态、静态 shape
+
+- **{shape}:** 模型输入的 shape 或者 shape 范围
+
+在上例中，你也可以把 `Faster R-CNN` 转为其他后端模型。比如使用`detection_tensorrt-fp16_dynamic-320x320-1344x1344.py`，把模型转为 tensorrt-fp16 模型。
+
+```{tip}
+当转 tensorrt 模型时, --device 需要被设置为 "cuda"
+```
+
+## 模型规范
+
+在使用转换后的模型进行推理之前，有必要了解转换结果的结构。 它存放在 `--work-dir` 指定的路路径下。
+
+上例中的`mmdeploy_models/mmdet/onnx`，结构如下：
+
+```
+mmdeploy_models/mmdet/onnx
+├── deploy.json
+├── detail.json
+├── end2end.onnx
+└── pipeline.json
+```
+
+重要的是：
+
+- **end2end.onnx**: 推理引擎文件。可用 ONNX Runtime 推理
+- ***xxx*.json**:  mmdeploy SDK 推理所需的 meta 信息
+
+整个文件夹被定义为**mmdeploy SDK model**。换言之，**mmdeploy SDK model**既包括推理引擎，也包括推理 meta 信息。
+
+## 模型推理
+
+## 后端模型推理
+
+以上述模型转换后的 `end2end.onnx` 为例，你可以使用如下代码进行推理：
+
+```python
+from mmdeploy.apis.utils import build_task_processor
+from mmdeploy.utils import get_input_shape, load_config
+import torch
+
+deploy_cfg = '../mmdeploy/configs/mmdet/detection/detection_onnxruntime_dynamic.py'
+model_cfg = 'configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py'
+device = 'cpu'
+backend_model = ['mmdeploy_models/mmdet/onnx/end2end.onnx']
+image = 'demo/demo.jpg'
+
+# read deploy_cfg and model_cfg
+deploy_cfg, model_cfg = load_config(deploy_cfg, model_cfg)
+
+# build task and backend model
+task_processor = build_task_processor(model_cfg, deploy_cfg, device)
+model = task_processor.build_backend_model(backend_model)
+
+# process input image
+input_shape = get_input_shape(deploy_cfg)
+model_inputs, _ = task_processor.create_input(image, input_shape)
+
+# do model inference
+with torch.no_grad():
+    result = model.test_step(model_inputs)
+
+# visualize results
+task_processor.visualize(
+    image=image,
+    model=model,
+    result=result[0],
+    window_name='visualize',
+    output_file='output_detection.png')
+```
+
+## SDK 模型推理
+
+你也可以参考如下代码，对 SDK model 进行推理：
+
+```python
+from mmdeploy_python import Detector
+import cv2
+
+img = cv2.imread('demo/demo.jpg')
+
+# create a detector
+detector = Detector(model_path='mmdeploy_models/mmdet/onnx',
+                    device_name='cpu', device_id=0)
+# perform inference
+bboxes, labels, masks = detector(img)
+
+# visualize inference result
+indices = [i for i in range(len(bboxes))]
+for index, bbox, label_id in zip(indices, bboxes, labels):
+    [left, top, right, bottom], score = bbox[0:4].astype(int), bbox[4]
+    if score < 0.3:
+        continue
+
+    cv2.rectangle(img, (left, top), (right, bottom), (0, 255, 0))
+
+cv2.imwrite('output_detection.png', img)
+```
+
+除了python API，mmdeploy SDK 还提供了诸如 C、C++、C#、Java等多语言接口。
+你可以参考[样例](https://github.com/open-mmlab/mmdeploy/tree/1.x/demo)学习其他语言接口的使用方法。
+
+## 模型支持列表
+
+请参考[这里](https://mmdeploy.readthedocs.io/zh_CN/1.x/04-supported-codebases/mmdet.html#id6)
diff --git a/mmdetection/docs/zh_cn/user_guides/finetune.md b/mmdetection/docs/zh_cn/user_guides/finetune.md
new file mode 100644
index 00000000..66bad94e
--- /dev/null
+++ b/mmdetection/docs/zh_cn/user_guides/finetune.md
@@ -0,0 +1,96 @@
+# 模型微调
+
+在 COCO 数据集上预训练的检测器可以作为其他数据集（例如 CityScapes 和 KITTI 数据集）优质的预训练模型。
+本教程将指导用户如何把 [ModelZoo](../model_zoo.md) 中提供的模型用于其他数据集中并使得当前所训练的模型获得更好性能。
+
+以下是在新数据集中微调模型需要的两个步骤。
+
+- 按 [教程2：自定义数据集](../advanced_guides/customize_dataset.md) 中的方法对新数据集添加支持中的方法对新数据集添加支持
+- 按照本教程中所讨论方法，修改配置信息
+
+接下来将会以 Cityscapes Dataset 上的微调过程作为例子，具体讲述用户需要在配置中修改的五个部分。
+
+## 继承基础配置
+
+为了减轻编写整个配置的负担并减少漏洞的数量， MMDetection V3.0 支持从多个现有配置中继承配置信息。微调 MaskRCNN 模型的时候，新的配置信息需要使用从 `_base_/models/mask_rcnn_r50_fpn.py` 中继承的配置信息来构建模型的基本结构。当使用 Cityscapes 数据集时，新的配置信息可以简便地从`_base_/datasets/cityscapes_instance.py` 中继承。对于训练过程的运行设置部分，例如 `logger settings`，配置文件可以从 `_base_/default_runtime.py` 中继承。对于训练计划的配置则可以从`_base_/schedules/schedule_1x.py` 中继承。这些配置文件存放于 `configs` 目录下，用户可以选择全部内容的重新编写而不是使用继承方法。
+
+```python
+_base_ = [
+    '../_base_/models/mask_rcnn_r50_fpn.py',
+    '../_base_/datasets/cityscapes_instance.py', '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_1x.py'
+]
+```
+
+## Head 的修改
+
+接下来新的配置还需要根据新数据集的类别数量对 Head 进行修改。只需要对 roi_head 中的 `num_classes`进行修改。修改后除了最后的预测模型的 Head 之外，预训练模型的权重的大部分都会被重新使用。
+
+```python
+model = dict(
+    roi_head=dict(
+        bbox_head=dict(
+            type='Shared2FCBBoxHead',
+            in_channels=256,
+            fc_out_channels=1024,
+            roi_feat_size=7,
+            num_classes=8,
+            bbox_coder=dict(
+                type='DeltaXYWHBBoxCoder',
+                target_means=[0., 0., 0., 0.],
+                target_stds=[0.1, 0.1, 0.2, 0.2]),
+            reg_class_agnostic=False,
+            loss_cls=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
+            loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0)),
+        mask_head=dict(
+            type='FCNMaskHead',
+            num_convs=4,
+            in_channels=256,
+            conv_out_channels=256,
+            num_classes=8,
+            loss_mask=dict(
+                type='CrossEntropyLoss', use_mask=True, loss_weight=1.0))))
+```
+
+## 数据集的修改
+
+用户可能还需要准备数据集并编写有关数据集的配置，可在 [Customize Datasets](../advanced_guides/customize_dataset.md) 中获取更多信息。目前 MMDetection V3.0 的配置文件已经支持 VOC、WIDERFACE、COCO、LIVS、OpenImages、DeepFashion、Objects365 和 Cityscapes Dataset 的数据集信息。
+
+## 训练策略的修改
+
+微调超参数与默认的训练策略不同。它通常需要更小的学习率和更少的训练回合。
+
+```python
+# 优化器
+# batch size 为 8 时的 lr 配置
+optim_wrapper = dict(optimizer=dict(lr=0.01))
+
+# 学习率
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500),
+    dict(
+        type='MultiStepLR',
+        begin=0,
+        end=8,
+        by_epoch=True,
+        milestones=[7],
+        gamma=0.1)
+]
+
+# 设置 max epoch
+train_cfg = dict(max_epochs=8)
+
+# 设置 log config
+default_hooks = dict(logger=dict(interval=100)),
+
+```
+
+## 使用预训练模型
+
+如果要使用预训练模型，可以在 `load_from` 中查阅新的配置信息，用户需要在训练开始之前下载好需要的模型权重，从而避免在训练过程中浪费了宝贵时间。
+
+```python
+load_from = 'https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth'  # noqa
+```
diff --git a/mmdetection/docs/zh_cn/user_guides/index.rst b/mmdetection/docs/zh_cn/user_guides/index.rst
new file mode 100644
index 00000000..5abc50ad
--- /dev/null
+++ b/mmdetection/docs/zh_cn/user_guides/index.rst
@@ -0,0 +1,34 @@
+训练 & 测试
+**************
+
+MMDetection 在 `Model Zoo `_ 中提供了数百个预训练的检测模型，
+并支持多种标准数据集格式，包括 Pascal VOC、COCO、CityScapes、LVIS 等。本文档将展示如何使用这些模型和数据集来执行常见的训练和测试任务：
+
+.. toctree::
+   :maxdepth: 1
+
+   config.md
+   inference.md
+   dataset_prepare.md
+   test.md
+   train.md
+   new_model.md
+   finetune.md
+   test_results_submission.md
+   init_cfg.md
+   single_stage_as_rpn.md
+   semi_det.md
+
+
+实用工具
+************
+
+.. toctree::
+   :maxdepth: 1
+
+   useful_tools.md
+   useful_hooks.md
+   visualization.md
+   robustness_benchmarking.md
+   deploy.md
+   label_studio.md
diff --git a/mmdetection/docs/zh_cn/user_guides/inference.md b/mmdetection/docs/zh_cn/user_guides/inference.md
new file mode 100644
index 00000000..a0fb08fa
--- /dev/null
+++ b/mmdetection/docs/zh_cn/user_guides/inference.md
@@ -0,0 +1,438 @@
+# 使用已有模型在标准数据集上进行推理
+
+MMDetection 提供了许多预训练好的检测模型，可以在 [Model Zoo](https://mmdetection.readthedocs.io/zh_CN/latest/model_zoo.html) 查看具体有哪些模型。
+
+推理具体指使用训练好的模型来检测图像上的目标，本文将会展示具体步骤。
+
+在 MMDetection 中，一个模型被定义为一个[配置文件](https://mmdetection.readthedocs.io/zh_CN/latest/user_guides/config.html) 和对应被存储在 checkpoint 文件内的模型参数的集合。
+
+首先，我们建议从 [RTMDet](https://github.com/open-mmlab/mmdetection/tree/main/configs/rtmdet) 开始，其 [配置](https://github.com/open-mmlab/mmdetection/blob/main/configs/rtmdet/rtmdet_l_8xb32-300e_coco.py) 文件和 [checkpoint](https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_l_8xb32-300e_coco/rtmdet_l_8xb32-300e_coco_20220719_112030-5a0be7c4.pth) 文件在此。
+我们建议将 checkpoint 文件下载到 `checkpoints` 文件夹内。
+
+## 推理的高层编程接口——推理器
+
+在 OpenMMLab 中，所有的推理操作都被统一到了推理器 `Inferencer` 中。推理器被设计成为一个简洁易用的 API，它在不同的 OpenMMLab 库中都有着非常相似的接口。
+下面介绍的演示样例都放在 [demo/inference_demo.ipynb](https://github.com/open-mmlab/mmdetection/blob/main/demo/inference_demo.ipynb) 中方便大家尝试。
+
+### 基础用法
+
+使用 `DetInferencer`，您只需 3 行代码就可以获得推理结果。
+
+```python
+from mmdet.apis import DetInferencer
+
+# 初始化模型
+inferencer = DetInferencer('rtmdet_tiny_8xb32-300e_coco')
+
+# 推理示例图片
+inferencer('demo/demo.jpg', show=True)
+```
+
+可视化结果将被显示在一个新窗口中：
+
+
    
+    
+
    
+
+```{note}
+如果你在没有 GUI 的服务器上，或者通过禁用 X11 转发的 SSH 隧道运行以上命令，`show` 选项将不起作用。然而，你仍然可以通过设置 `out_dir` 参数将可视化数据保存到文件。阅读 [储存结果](#储存结果) 了解详情。
+```
+
+### 初始化
+
+每个推理器必须使用一个模型进行初始化。初始化时，可以手动选择推理设备。
+
+#### 模型初始化
+
+- 要用 MMDetection 的预训练模型进行推理，只需要把它的名字传给参数 `model`，权重将自动从 OpenMMLab 的模型库中下载和加载。
+
+  ```python
+  inferencer = DetInferencer(model='rtmdet_tiny_8xb32-300e_coco')
+  ```
+
+  在 MMDetection 中有一个非常容易的方法，可以列出所有模型名称。
+
+  ```python
+  # models 是一个模型名称列表，它们将自动打印
+  models = DetInferencer.list_models('mmdet')
+  ```
+
+  你可以通过将权重的路径或 URL 传递给 `weights` 来让推理器加载自定义的权重。
+
+  ```python
+  inferencer = DetInferencer(model='rtmdet_tiny_8xb32-300e_coco', weights='path/to/rtmdet.pth')
+  ```
+
+- 要加载自定义的配置和权重，你可以把配置文件的路径传给 `model`，把权重的路径传给 `weights`。
+
+  ```python
+  inferencer = DetInferencer(model='path/to/rtmdet_config.py', weights='path/to/rtmdet.pth')
+  ```
+
+- 默认情况下，[MMEngine](https://github.com/open-mmlab/mmengine/) 会在训练模型时自动将配置文件转储到权重文件中。如果你有一个在 MMEngine 上训练的权重，你也可以将权重文件的路径传递给 `weights`，而不需要指定 `model`：
+
+  ```python
+  # 如果无法在权重中找到配置文件，则会引发错误。目前 MMDetection 模型库中只有 ddq-detr-4scale_r50 的权重可以这样加载。
+  inferencer = DetInferencer(weights='https://download.openmmlab.com/mmdetection/v3.0/ddq/ddq-detr-4scale_r50_8xb2-12e_coco/ddq-detr-4scale_r50_8xb2-12e_coco_20230809_170711-42528127.pth')
+  ```
+
+- 传递配置文件到 `model` 而不指定 `weights` 则会产生一个随机初始化的模型。
+
+#### 推理设备
+
+每个推理器实例都会跟一个设备绑定。默认情况下，最佳设备是由 [MMEngine](https://github.com/open-mmlab/mmengine/) 自动决定的。你也可以通过指定 `device` 参数来改变设备。例如，你可以使用以下代码在 GPU 1 上创建一个推理器。
+
+```python
+inferencer = DetInferencer(model='rtmdet_tiny_8xb32-300e_coco', device='cuda:1')
+```
+
+如要在 CPU 上创建一个推理器：
+
+```python
+inferencer = DetInferencer(model='rtmdet_tiny_8xb32-300e_coco', device='cpu')
+```
+
+请参考 [torch.device](https://pytorch.org/docs/stable/tensor_attributes.html#torch.device) 了解 `device` 参数支持的所有形式。
+
+### 推理
+
+当推理器初始化后，你可以直接传入要推理的原始数据，从返回值中获取推理结果。
+
+#### 输入
+
+输入可以是以下任意一种格式：
+
+- str: 图像的路径/URL。
+
+  ```python
+  inferencer('demo/demo.jpg')
+  ```
+
+- array: 图像的 numpy 数组。它应该是 BGR 格式。
+
+  ```python
+  import mmcv
+  array = mmcv.imread('demo/demo.jpg')
+  inferencer(array)
+  ```
+
+- list: 基本类型的列表。列表中的每个元素都将单独处理。
+
+  ```python
+  inferencer(['img_1.jpg', 'img_2.jpg])
+  # 列表内混合类型也是允许的
+  inferencer(['img_1.jpg', array])
+  ```
+
+- str: 目录的路径。目录中的所有图像都将被处理。
+
+  ```python
+  inferencer('path/to/your_imgs/')
+  ```
+
+#### 输出
+
+默认情况下，每个推理器都以字典格式返回预测结果。
+
+- `visualization` 包含可视化的预测结果。但默认情况下，它是一个空列表，除非 `return_vis=True`。
+
+- `predictions` 包含以 json-可序列化格式返回的预测结果。
+
+```python
+{
+      'predictions' : [
+        # 每个实例都对应于一个输入图像
+        {
+          'labels': [...],  # 整数列表，长度为 (N, )
+          'scores': [...],  # 浮点列表，长度为 (N, )
+          'bboxes': [...],  # 2d 列表，形状为 (N, 4)，格式为 [min_x, min_y, max_x, max_y]
+        },
+        ...
+      ],
+      'visualization' : [
+        array(..., dtype=uint8),
+      ]
+  }
+```
+
+如果你想要从模型中获取原始输出，可以将 `return_datasamples` 设置为 `True` 来获取原始的 [DataSample](advanced_guides/structures.md)，它将存储在 `predictions` 中。
+
+#### 储存结果
+
+除了从返回值中获取预测结果，你还可以通过设置 `out_dir` 和 `no_save_pred`/`no_save_vis` 参数将预测结果和可视化结果导出到文件中。
+
+```python
+inferencer('demo/demo.jpg', out_dir='outputs/', no_save_pred=False)
+```
+
+结果目录结构如下：
+
+```text
+outputs
+├── preds
+│   └── demo.json
+└── vis
+    └── demo.jpg
+```
+
+#### 批量推理
+
+你可以通过设置 `batch_size` 来自定义批量推理的批大小。默认批大小为 1。
+
+### API
+
+这里列出了推理器详尽的参数列表。
+
+- **DetInferencer.\_\_init\_\_():**
+
+| 参数            | 类型       | 默认值  | 描述                                                                                                                                                                                                                        |
+| --------------- | ---------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `model`         | str , 可选 | None    | 配置文件的路径或 metafile 中定义的模型名称。例如，可以是 'rtmdet-s' 或 'rtmdet_s_8xb32-300e_coco' 或 'configs/rtmdet/rtmdet_s_8xb32-300e_coco.py'。如果未指定模型，用户必须提供 MMEngine 保存的包含配置字符串的 "weights"。 |
+| `weights`       | str, 可选  | None    | 模型权重文件的路径。如果未指定且 `model` 是 metafile 中的模型名称，权重将从 metafile 中加载。                                                                                                                               |
+| `device`        | str, 可选  | None    | 推理使用的设备，接受 `torch.device` 允许的所有字符串。例如，'cuda:0' 或 'cpu'。如果为 None，将自动使用可用设备。 默认为 None。                                                                                              |
+| `scope`         | str, 可选  | 'mmdet' | 模型的”域名“。                                                                                                                                                                                                              |
+| `palette`       | str        | 'none'  | 用于可视化的配色。优先顺序为 palette -> config -> checkpoint。                                                                                                                                                              |
+| `show_progress` | bool       | True    | 控制是否在推理过程中显示进度条。                                                                                                                                                                                            |
+
+- **DetInferencer.\_\_call\_\_()**
+
+| 参数                 | 类型                    | 默认值   | 描述                                                                                                                                                                                                                            |
+| -------------------- | ----------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `inputs`             | str/list/tuple/np.array | **必需** | 它可以是一个图片/文件夹的路径，一个 numpy 数组，或者是一个包含图片路径或 numpy 数组的列表/元组                                                                                                                                  |
+| `batch_size`         | int                     | 1        | 推理的批大小。                                                                                                                                                                                                                  |
+| `return_vis`         | bool                    | False    | 是否返回可视化结果。                                                                                                                                                                                                            |
+| `show`               | bool                    | False    | 是否在弹出窗口中显示可视化结果。                                                                                                                                                                                                |
+| `wait_time`          | float                   | 0        | 弹窗展示可视化结果的时间间隔。                                                                                                                                                                                                  |
+| `no_save_vis`        | bool                    | False    | 是否将可视化结果保存到 `out_dir`。默认为保存。                                                                                                                                                                                  |
+| `draw_pred`          | bool                    | True     | 是否绘制预测的边界框。                                                                                                                                                                                                          |
+| `pred_score_thr`     | float                   | 0.3      | 显示预测框的最低置信度。                                                                                                                                                                                                        |
+| `return_datasamples` | bool                    | False    | 是否将结果作为 `DetDataSample` 返回。 如果为 False，则结果将被打包到一个 dict 中。                                                                                                                                              |
+| `print_result`       | bool                    | False    | 是否将推理结果打印到控制台。                                                                                                                                                                                                    |
+| `no_save_pred`       | bool                    | True     | 是否将推理结果保存到 `out_dir`。默认为不保存。                                                                                                                                                                                  |
+| `out_dir`            | str                     | ''       | 结果的输出目录。                                                                                                                                                                                                                |
+| `texts`              | str/list\[str\]，可选   | None     | 文本提示词。                                                                                                                                                                                                                    |
+| `stuff_texts`        | str/list\[str\]，可选   | None     | 物体文本提示词。                                                                                                                                                                                                                |
+| `custom_entities`    | bool                    | False    | 是否使用自定义实体。只用于 GLIP 算法。                                                                                                                                                                                          |
+| \*\*kwargs           |                         |          | 传递给 :meth:`preprocess`、:meth:`forward`、:meth:`visualize` 和 :meth:`postprocess` 的其他关键字参数。kwargs 中的每个关键字都应在相应的 `preprocess_kwargs`、`forward_kwargs`、`visualize_kwargs` 和 `postprocess_kwargs` 中。 |
+
+## 演示脚本样例
+
+我们还提供了四个演示脚本，它们是使用高层编程接口实现的。[源码在此](https://github.com/open-mmlab/mmdetection/blob/main/demo) 。
+
+### 图片样例
+
+这是在单张图片上进行推理的脚本。
+
+```shell
+python demo/image_demo.py \
+    ${IMAGE_FILE} \
+    ${CONFIG_FILE} \
+    [--weights ${WEIGHTS}] \
+    [--device ${GPU_ID}] \
+    [--pred-score-thr ${SCORE_THR}]
+```
+
+运行样例：
+
+```shell
+python demo/image_demo.py demo/demo.jpg \
+    configs/rtmdet/rtmdet_l_8xb32-300e_coco.py \
+    --weights checkpoints/rtmdet_l_8xb32-300e_coco_20220719_112030-5a0be7c4.pth \
+    --device cpu
+```
+
+### 摄像头样例
+
+这是使用摄像头实时图片的推理脚本。
+
+```shell
+python demo/webcam_demo.py \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    [--device ${GPU_ID}] \
+    [--camera-id ${CAMERA-ID}] \
+    [--score-thr ${SCORE_THR}]
+```
+
+运行样例：
+
+```shell
+python demo/webcam_demo.py \
+    configs/rtmdet/rtmdet_l_8xb32-300e_coco.py \
+    checkpoints/rtmdet_l_8xb32-300e_coco_20220719_112030-5a0be7c4.pth
+```
+
+### 视频样例
+
+这是在视频样例上进行推理的脚本。
+
+```shell
+python demo/video_demo.py \
+    ${VIDEO_FILE} \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    [--device ${GPU_ID}] \
+    [--score-thr ${SCORE_THR}] \
+    [--out ${OUT_FILE}] \
+    [--show] \
+    [--wait-time ${WAIT_TIME}]
+```
+
+运行样例：
+
+```shell
+python demo/video_demo.py demo/demo.mp4 \
+    configs/rtmdet/rtmdet_l_8xb32-300e_coco.py \
+    checkpoints/rtmdet_l_8xb32-300e_coco_20220719_112030-5a0be7c4.pth \
+    --out result.mp4
+```
+
+#### 视频样例，显卡加速版本
+
+这是在视频样例上进行推理的脚本，使用显卡加速。
+
+```shell
+python demo/video_gpuaccel_demo.py \
+     ${VIDEO_FILE} \
+     ${CONFIG_FILE} \
+     ${CHECKPOINT_FILE} \
+     [--device ${GPU_ID}] \
+     [--score-thr ${SCORE_THR}] \
+     [--nvdecode] \
+     [--out ${OUT_FILE}] \
+     [--show] \
+     [--wait-time ${WAIT_TIME}]
+
+```
+
+运行样例：
+
+```shell
+python demo/video_gpuaccel_demo.py demo/demo.mp4 \
+    configs/rtmdet/rtmdet_l_8xb32-300e_coco.py \
+    checkpoints/rtmdet_l_8xb32-300e_coco_20220719_112030-5a0be7c4.pth \
+    --nvdecode --out result.mp4
+```
+
+### 大图推理样例
+
+这是在大图上进行切片推理的脚本。
+
+```shell
+python demo/large_image_demo.py \
+	${IMG_PATH} \
+	${CONFIG_FILE} \
+	${CHECKPOINT_FILE} \
+	--device ${GPU_ID}  \
+	--show \
+	--tta  \
+	--score-thr ${SCORE_THR} \
+	--patch-size ${PATCH_SIZE} \
+	--patch-overlap-ratio ${PATCH_OVERLAP_RATIO} \
+	--merge-iou-thr ${MERGE_IOU_THR} \
+	--merge-nms-type ${MERGE_NMS_TYPE} \
+	--batch-size ${BATCH_SIZE} \
+	--debug \
+	--save-patch
+```
+
+运行样例:
+
+```shell
+# inferecnce without tta
+wget -P checkpoint https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r101_fpn_2x_coco/faster_rcnn_r101_fpn_2x_coco_bbox_mAP-0.398_20200504_210455-1d2dac9c.pth
+
+python demo/large_image_demo.py \
+    demo/large_image.jpg \
+    configs/faster_rcnn/faster-rcnn_r101_fpn_2x_coco.py \
+    checkpoint/faster_rcnn_r101_fpn_2x_coco_bbox_mAP-0.398_20200504_210455-1d2dac9c.pth
+
+# inference with tta
+wget -P checkpoint https://download.openmmlab.com/mmdetection/v2.0/retinanet/retinanet_r50_fpn_1x_coco/retinanet_r50_fpn_1x_coco_20200130-c2398f9e.pth
+
+python demo/large_image_demo.py \
+    demo/large_image.jpg \
+    configs/retinanet/retinanet_r50_fpn_1x_coco.py \
+    checkpoint/retinanet_r50_fpn_1x_coco_20200130-c2398f9e.pth --tta
+```
+
+## 多模态算法的推理和验证
+
+随着多模态视觉算法的不断发展，MMDetection 也完成了对这类算法的支持。这一小节我们通过 GLIP 算法和模型来演示如何使用对应多模态算法的 demo 和 eval 脚本。同时 MMDetection 也在 projects 下完成了 [gradio_demo 项目](../../../projects/gradio_demo/)，用户可以参照[文档](../../../projects/gradio_demo/README.md)在本地快速体验 MMDetection 中支持的各类图片输入的任务。
+
+### 模型准备
+
+首先需要安装多模态依赖：
+
+```shell
+# if source
+pip install -r requirements/multimodal.txt
+
+# if wheel
+mim install mmdet[multimodal]
+```
+
+MMDetection 已经集成了 glip 算法和模型，可以直接使用链接下载使用：
+
+```shell
+cd mmdetection
+wget https://download.openmmlab.com/mmdetection/v3.0/glip/glip_tiny_a_mmdet-b3654169.pth
+```
+
+### 推理演示
+
+下载完成后我们就可以利用 `demo` 下的多模态推理脚本完成推理：
+
+```shell
+python demo/image_demo.py demo/demo.jpg glip_tiny_a_mmdet-b3654169.pth --texts bench
+```
+
+demo 效果如下图所示：
+
+
    
+
+
    
+
+如果想进行多种类型的识别，需要使用 `xx. xx` 的格式在 `--texts` 字段后声明目标类型:
+
+```shell
+python demo/image_demo.py demo/demo.jpg glip_tiny_a_mmdet-b3654169.pth --texts 'bench. car'
+```
+
+结果如下图所示：
+
+
    
+
+
    
+
+推理脚本还支持输入一个句子作为 `--texts` 字段的输入：
+
+```shell
+python demo/image_demo.py demo/demo.jpg glip_tiny_a_mmdet-b3654169.pth --texts 'There are a lot of cars here.'
+```
+
+结果可以参考下图：
+
+
    
+
+
    
+
+### 验证演示
+
+MMDetection 支持后的 GLIP 算法对比官方版本没有精度上的损失， benchmark 如下所示：
+
+| Model                   | official mAP | mmdet mAP |
+| ----------------------- | :----------: | :-------: |
+| glip_A_Swin_T_O365.yaml |     42.9     |   43.0    |
+| glip_Swin_T_O365.yaml   |     44.9     |   44.9    |
+| glip_Swin_L.yaml        |     51.4     |   51.3    |
+
+用户可以使用 `test.py` 脚本对模型精度进行验证，使用如下所示：
+
+```shell
+# 1 gpu
+python tools/test.py configs/glip/glip_atss_swin-t_fpn_dyhead_pretrain_obj365.py glip_tiny_a_mmdet-b3654169.pth
+
+# 8 GPU
+./tools/dist_test.sh configs/glip/glip_atss_swin-t_fpn_dyhead_pretrain_obj365.py glip_tiny_a_mmdet-b3654169.pth 8
+```
diff --git a/mmdetection/docs/zh_cn/user_guides/init_cfg.md b/mmdetection/docs/zh_cn/user_guides/init_cfg.md
new file mode 100644
index 00000000..b58b19d5
--- /dev/null
+++ b/mmdetection/docs/zh_cn/user_guides/init_cfg.md
@@ -0,0 +1,161 @@
+# 权重初始化
+
+在训练过程中，适当的初始化策略有利于加快训练速度或获得更⾼的性能。 [MMCV](https://github.com/open-mmlab/mmcv/blob/master/mmcv/cnn/utils/weight_init.py) 提供了一些常⽤的初始化模块的⽅法，如 `nn.Conv2d`。 MMdetection 中的模型初始化主要使⽤ `init_cfg`。⽤⼾可以通过以下两个步骤来初始化模型：
+
+1. 在 `model_cfg` 中为模型或其组件定义 `init_cfg`，但⼦组件的 `init_cfg` 优先级更⾼，会覆盖⽗模块的 `init_cfg` 。
+2. 像往常一样构建模型，然后显式调⽤ `model.init_weights()` ⽅法，此时模型参数将会被按照配置文件写法进行初始化。
+
+MMdetection 初始化工作流的高层 API 调用流程是：
+
+model_cfg(init_cfg) -> build_from_cfg -> model -> init_weight() -> initialize(self, self.init_cfg) -> children's init_weight()
+
+### 描述
+
+它的数据类型是 dict 或者 list\[dict\]，包含了下列键值:
+
+- `type` (str)，包含 `INTIALIZERS` 中的初始化器名称，后面跟着初始化器的参数。
+- `layer`（str 或 list\[str\]），包含 Pytorch 或 MMCV 中基本层的名称，以及将被初始化的可学习参数，例如 `'Conv2d'`，`'DeformConv2d'`。
+- `override` (dict 或 list\[dict\])，包含不继承⾃ `BaseModule` 且其初始化配置与 `layer` 键中的其他层不同的⼦模块。 `type` 中定义的初始化器将适⽤于 `layer` 中定义的所有层，因此如果⼦模块不是 `BaseModule` 的派⽣类但可以与 `layer` 中的层相同的⽅式初始化，则不需要使⽤ `override`。`override` 包含了：
+  - `type` 后跟初始化器的参数；
+  - `name` 用以指⽰将被初始化的⼦模块。
+
+### 初始化参数
+
+从 `mmcv.runner.BaseModule` 或 `mmdet.models` 继承一个新模型。这里我们用 FooModel 来举个例子。
+
+```python
+import torch.nn as nn
+from mmcv.runner import BaseModule
+
+class FooModel(BaseModule)
+	def __init__(self,
+                 arg1,
+                 arg2,
+                 init_cfg=None):
+    	super(FooModel, self).__init__(init_cfg)
+		...
+```
+
+- 直接在代码中使⽤ `init_cfg` 初始化模型
+
+  ```python
+  import torch.nn as nn
+  from mmcv.runner import BaseModule
+  # or directly inherit mmdet models
+
+  class FooModel(BaseModule)
+  	def __init__(self,
+                  arg1,
+                  arg2,
+                  init_cfg=XXX):
+    		super(FooModel, self).__init__(init_cfg)
+    	    ...
+  ```
+
+- 在 `mmcv.Sequential` 或 `mmcv.ModuleList` 代码中直接使⽤ `init_cfg` 初始化模型
+
+  ```python
+  from mmcv.runner import BaseModule, ModuleList
+
+  class FooModel(BaseModule)
+  	def __init__(self,
+                	arg1,
+                	arg2,
+                	init_cfg=None):
+    		super(FooModel, self).__init__(init_cfg)
+        	...
+        	self.conv1 = ModuleList(init_cfg=XXX)
+  ```
+
+- 使⽤配置⽂件中的 `init_cfg` 初始化模型
+
+  ```python
+  model = dict(
+  	...
+    	model = dict(
+        	type='FooModel',
+        	arg1=XXX,
+        	arg2=XXX,
+        	init_cfg=XXX),
+            ...
+  ```
+
+### init_cfg 的使用
+
+1. 用 `layer` 键初始化模型
+
+   如果我们只定义了 `layer`, 它只会在 `layer` 键中初始化网络层。
+
+   注意： `layer` 键对应的值是 Pytorch 的带有 weights 和 bias 属性的类名（因此不⽀持 `MultiheadAttention` 层）。
+
+- 定义⽤于初始化具有相同配置的模块的 `layer` 键。
+
+  ```python
+  init_cfg = dict(type='Constant', layer=['Conv1d', 'Conv2d', 'Linear'], val=1)
+  # ⽤相同的配置初始化整个模块
+  ```
+
+- 定义⽤于初始化具有不同配置的层的 `layer` 键。
+
+  ```python
+  init_cfg = [dict(type='Constant', layer='Conv1d', val=1),
+              dict(type='Constant', layer='Conv2d', val=2),
+              dict(type='Constant', layer='Linear', val=3)]
+  # nn.Conv1d 将被初始化为 dict(type='Constant', val=1)
+  # nn.Conv2d 将被初始化为 dict(type='Constant', val=2)
+  # nn.Linear 将被初始化为 dict(type='Constant', val=3)
+  ```
+
+2. 使⽤ `override` 键初始化模型
+
+- 当使⽤属性名初始化某些特定部分时，我们可以使⽤ `override` 键， `override` 中的值将忽略 init_cfg 中的值。
+
+  ```python
+  # layers：
+  # self.feat = nn.Conv1d(3, 1, 3)
+  # self.reg = nn.Conv2d(3, 3, 3)
+  # self.cls = nn.Linear(1,2)
+
+  init_cfg = dict(type='Constant',
+                  layer=['Conv1d','Conv2d'], val=1, bias=2,
+                  override=dict(type='Constant', name='reg', val=3, bias=4))
+  # self.feat and self.cls 将被初始化为 dict(type='Constant', val=1, bias=2)
+  # 叫 'reg' 的模块将被初始化为 dict(type='Constant', val=3, bias=4)
+  ```
+
+- 如果 init_cfg 中的 `layer` 为 None，则只会初始化 override 中有 name 的⼦模块，⽽ override 中的 type 和其他参数可以省略。
+
+  ```python
+  # layers：
+  # self.feat = nn.Conv1d(3, 1, 3)
+  # self.reg = nn.Conv2d(3, 3, 3)
+  # self.cls = nn.Linear(1,2)
+
+  init_cfg = dict(type='Constant', val=1, bias=2, 	override=dict(name='reg'))
+
+  # self.feat and self.cls 将被 Pytorch 初始化
+  # 叫 'reg' 的模块将被 dict(type='Constant', val=1, bias=2) 初始化
+  ```
+
+- 如果我们不定义 `layer` 或 `override` 键，它不会初始化任何东西。
+
+- 无效的使用
+
+  ```python
+  # override 没有 name 键的话是无效的
+  init_cfg = dict(type='Constant', layer=['Conv1d','Conv2d'], val=1, bias=2,
+              	override=dict(type='Constant', val=3, bias=4))
+
+  # override 有 name 键和其他参数但是没有 type 键也是无效的
+  init_cfg = dict(type='Constant', layer=['Conv1d','Conv2d'], val=1, bias=2,
+                  override=dict(name='reg', val=3, bias=4))
+  ```
+
+3. 使⽤预训练模型初始化模型
+
+   ```python
+   init_cfg = dict(type='Pretrained',
+                checkpoint='torchvision://resnet50')
+   ```
+
+更多细节可以参考 [MMEngine](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/initialize.html) 的文档
diff --git a/mmdetection/docs/zh_cn/user_guides/label_studio.md b/mmdetection/docs/zh_cn/user_guides/label_studio.md
new file mode 100644
index 00000000..202122f6
--- /dev/null
+++ b/mmdetection/docs/zh_cn/user_guides/label_studio.md
@@ -0,0 +1,255 @@
+# 使用 MMDetection 和 Label-Studio 进行半自动化目标检测标注
+
+标注数据是一个费时费力的任务，本文介绍了如何使用 MMDetection 中的 RTMDet 算法联合 Label-Studio 软件进行半自动化标注。具体来说，使用 RTMDet 预测图片生成标注，然后使用 Label-Studio 进行微调标注，社区用户可以参考此流程和方法，将其应用到其他领域。
+
+- RTMDet：RTMDet 是 OpenMMLab 自研的高精度单阶段的目标检测算法，开源于 MMDetection 目标检测工具箱中，其开源协议为 Apache 2.0，工业界的用户可以不受限的免费使用。
+- [Label Studio](https://github.com/heartexlabs/label-studio) 是一款优秀的标注软件，覆盖图像分类、目标检测、分割等领域数据集标注的功能。
+
+本文将使用[喵喵数据集](https://download.openmmlab.com/mmyolo/data/cat_dataset.zip)的图片，进行半自动化标注。
+
+## 环境配置
+
+首先需要创建一个虚拟环境，然后安装 PyTorch 和 MMCV。在本文中，我们将指定 PyTorch 和 MMCV 的版本。接下来安装 MMDetection、Label-Studio 和 label-studio-ml-backend，具体步骤如下：
+
+创建虚拟环境：
+
+```shell
+conda create -n rtmdet python=3.9 -y
+conda activate rtmdet
+```
+
+安装 PyTorch
+
+```shell
+# Linux and Windows CPU only
+pip install torch==1.10.1+cpu torchvision==0.11.2+cpu torchaudio==0.10.1 -f https://download.pytorch.org/whl/cpu/torch_stable.html
+# Linux and Windows CUDA 11.3
+pip install torch==1.10.1+cu113 torchvision==0.11.2+cu113 torchaudio==0.10.1 -f https://download.pytorch.org/whl/cu113/torch_stable.html
+# OSX
+pip install torch==1.10.1 torchvision==0.11.2 torchaudio==0.10.1
+```
+
+安装 MMCV
+
+```shell
+pip install -U openmim
+mim install "mmcv>=2.0.0"
+# 安装 mmcv 的过程中会自动安装 mmengine
+```
+
+安装 MMDetection
+
+```shell
+git clone https://github.com/open-mmlab/mmdetection
+cd mmdetection
+pip install -v -e .
+```
+
+安装 Label-Studio 和 label-studio-ml-backend
+
+```shell
+# 安装 label-studio 需要一段时间,如果找不到版本请使用官方源
+pip install label-studio==1.7.2
+pip install label-studio-ml==1.0.9
+```
+
+下载rtmdet权重
+
+```shell
+cd path/to/mmetection
+mkdir work_dirs
+cd work_dirs
+wget https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_m_8xb32-300e_coco/rtmdet_m_8xb32-300e_coco_20220719_112220-229f527c.pth
+```
+
+## 启动服务
+
+启动 RTMDet 后端推理服务：
+
+```shell
+cd path/to/mmetection
+
+label-studio-ml start projects/LabelStudio/backend_template --with \
+config_file=configs/rtmdet/rtmdet_m_8xb32-300e_coco.py \
+checkpoint_file=./work_dirs/rtmdet_m_8xb32-300e_coco_20220719_112220-229f527c.pth \
+device=cpu \
+--port 8003
+# device=cpu 为使用 CPU 推理，如果使用 GPU 推理，将 cpu 替换为 cuda:0
+```
+
+![](https://cdn.vansin.top/picgo20230330131601.png)
+
+此时，RTMDet 后端推理服务已经启动，后续在 Label-Studio Web 系统中配置 http://localhost:8003 后端推理服务即可。
+
+现在启动 Label-Studio 网页服务：
+
+```shell
+label-studio start
+```
+
+![](https://cdn.vansin.top/picgo20230330132913.png)
+
+打开浏览器访问 [http://localhost:8080/](http://localhost:8080/) 即可看到 Label-Studio 的界面。
+
+![](https://cdn.vansin.top/picgo20230330133118.png)
+
+我们注册一个用户，然后创建一个 RTMDet-Semiautomatic-Label 项目。
+
+![](https://cdn.vansin.top/picgo20230330133333.png)
+
+我们通过下面的方式下载好示例的喵喵图片，点击 Data Import 导入需要标注的猫图片。
+
+```shell
+cd path/to/mmetection
+mkdir data && cd data
+
+wget https://download.openmmlab.com/mmyolo/data/cat_dataset.zip && unzip cat_dataset.zip
+```
+
+![](https://cdn.vansin.top/picgo20230330133628.png)
+
+![](https://cdn.vansin.top/picgo20230330133715.png)
+
+然后选择 Object Detection With Bounding Boxes 模板
+
+![](https://cdn.vansin.top/picgo20230330133807.png)
+
+```shell
+airplane
+apple
+backpack
+banana
+baseball_bat
+baseball_glove
+bear
+bed
+bench
+bicycle
+bird
+boat
+book
+bottle
+bowl
+broccoli
+bus
+cake
+car
+carrot
+cat
+cell_phone
+chair
+clock
+couch
+cow
+cup
+dining_table
+dog
+donut
+elephant
+fire_hydrant
+fork
+frisbee
+giraffe
+hair_drier
+handbag
+horse
+hot_dog
+keyboard
+kite
+knife
+laptop
+microwave
+motorcycle
+mouse
+orange
+oven
+parking_meter
+person
+pizza
+potted_plant
+refrigerator
+remote
+sandwich
+scissors
+sheep
+sink
+skateboard
+skis
+snowboard
+spoon
+sports_ball
+stop_sign
+suitcase
+surfboard
+teddy_bear
+tennis_racket
+tie
+toaster
+toilet
+toothbrush
+traffic_light
+train
+truck
+tv
+umbrella
+vase
+wine_glass
+zebra
+```
+
+然后将上述类别复制添加到 Label-Studio，然后点击 Save。
+
+![](https://cdn.vansin.top/picgo20230330134027.png)
+
+然后在设置中点击 Add Model 添加 RTMDet 后端推理服务。
+
+![](https://cdn.vansin.top/picgo20230330134320.png)
+
+点击 Validate and Save，然后点击 Start Labeling。
+
+![](https://cdn.vansin.top/picgo20230330134424.png)
+
+看到如下 Connected 就说明后端推理服务添加成功。
+
+![](https://cdn.vansin.top/picgo20230330134554.png)
+
+## 开始半自动化标注
+
+点击 Label 开始标注
+
+![](https://cdn.vansin.top/picgo20230330134804.png)
+
+我们可以看到 RTMDet 后端推理服务已经成功返回了预测结果并显示在图片上，我们可以发现这个喵喵预测的框有点大。
+
+![](https://cdn.vansin.top/picgo20230403104419.png)
+
+我们手工拖动框，修正一下框的位置，得到以下修正过后的标注，然后点击 Submit，本张图片就标注完毕了。
+
+![](https://cdn.vansin.top/picgo/20230403105923.png)
+
+我们 submit 完毕所有图片后，点击 exprot 导出 COCO 格式的数据集，就能把标注好的数据集的压缩包导出来了。
+
+![](https://cdn.vansin.top/picgo20230330135921.png)
+
+用 vscode 打开解压后的文件夹，可以看到标注好的数据集，包含了图片和 json 格式的标注文件。
+
+![](https://cdn.vansin.top/picgo20230330140321.png)
+
+到此半自动化标注就完成了，我们可以用这个数据集在 MMDetection 训练精度更高的模型了，训练出更好的模型，然后再用这个模型继续半自动化标注新采集的图片，这样就可以不断迭代，扩充高质量数据集，提高模型的精度。
+
+## 使用 MMYOLO 作为后端推理服务
+
+如果想在 MMYOLO 中使用 Label-Studio，可以参考在启动后端推理服务时，将 config_file 和 checkpoint_file 替换为 MMYOLO 的配置文件和权重文件即可。
+
+```shell
+cd path/to/mmetection
+
+label-studio-ml start projects/LabelStudio/backend_template --with \
+config_file= path/to/mmyolo_config.py \
+checkpoint_file= path/to/mmyolo_weights.pth \
+device=cpu \
+--port 8003
+# device=cpu 为使用 CPU 推理，如果使用 GPU 推理，将 cpu 替换为 cuda:0
+```
+
+旋转目标检测和实例分割还在支持中，敬请期待。
diff --git a/mmdetection/docs/zh_cn/user_guides/new_model.md b/mmdetection/docs/zh_cn/user_guides/new_model.md
new file mode 100644
index 00000000..424c4f90
--- /dev/null
+++ b/mmdetection/docs/zh_cn/user_guides/new_model.md
@@ -0,0 +1,289 @@
+# 在标准数据集上训练自定义模型（待更新）
+
+在本文中，你将知道如何在标准数据集上训练、测试和推理自定义模型。我们将在 cityscapes 数据集上以自定义 Cascade Mask R-CNN R50 模型为例演示整个过程，为了方便说明，我们将 neck 模块中的 `FPN` 替换为 `AugFPN`，并且在训练中的自动增强类中增加 `Rotate` 或 `TranslateX`。
+
+基本步骤如下所示：
+
+1. 准备标准数据集
+2. 准备你的自定义模型
+3. 准备配置文件
+4. 在标准数据集上对模型进行训练、测试和推理
+
+## 准备标准数据集
+
+在本文中，我们使用 cityscapes 标准数据集为例进行说明。
+
+推荐将数据集根路径采用符号链接方式链接到 `$MMDETECTION/data`。
+
+如果你的文件结构不同，你可能需要在配置文件中进行相应的路径更改。标准的文件组织格式如下所示：
+
+```none
+mmdetection
+├── mmdet
+├── tools
+├── configs
+├── data
+│   ├── coco
+│   │   ├── annotations
+│   │   ├── train2017
+│   │   ├── val2017
+│   │   ├── test2017
+│   ├── cityscapes
+│   │   ├── annotations
+│   │   ├── leftImg8bit
+│   │   │   ├── train
+│   │   │   ├── val
+│   │   ├── gtFine
+│   │   │   ├── train
+│   │   │   ├── val
+│   ├── VOCdevkit
+│   │   ├── VOC2007
+│   │   ├── VOC2012
+```
+
+你也可以通过如下方式设定数据集根路径
+
+```bash
+export MMDET_DATASETS=$data_root
+```
+
+我们将会使用环境便变量 `$MMDET_DATASETS` 作为数据集的根目录，因此你无需再修改相应配置文件的路径信息。
+
+你需要使用脚本 `tools/dataset_converters/cityscapes.py` 将 cityscapes 标注转化为 coco 标注格式。
+
+```shell
+pip install cityscapesscripts
+python tools/dataset_converters/cityscapes.py ./data/cityscapes --nproc 8 --out-dir ./data/cityscapes/annotations
+```
+
+目前在 `cityscapes `文件夹中的配置文件所对应模型是采用 COCO 预训练权重进行初始化的。
+
+如果你的网络不可用或者比较慢，建议你先手动下载对应的预训练权重，否则可能在训练开始时候出现错误。
+
+## 准备你的自定义模型
+
+第二步是准备你的自定义模型或者训练相关配置。假设你想在已有的  Cascade Mask R-CNN R50 检测模型基础上，新增一个新的 neck 模块 `AugFPN` 去代替默认的 `FPN`，以下是具体实现：
+
+### 1 定义新的 neck (例如 AugFPN)
+
+首先创建新文件  `mmdet/models/necks/augfpn.py`.
+
+```python
+import torch.nn as nn
+from mmdet.registry import MODELS
+
+@MODELS.register_module()
+class AugFPN(nn.Module):
+
+    def __init__(self,
+                in_channels,
+                out_channels,
+                num_outs,
+                start_level=0,
+                end_level=-1,
+                add_extra_convs=False):
+        pass
+
+    def forward(self, inputs):
+        # implementation is ignored
+        pass
+```
+
+### 2 导入模块
+
+你可以采用两种方式导入模块，第一种是在  `mmdet/models/necks/__init__.py` 中添加如下内容
+
+```python
+from .augfpn import AugFPN
+```
+
+第二种是增加如下代码到对应配置中，这种方式的好处是不需要改动代码
+
+```python
+custom_imports = dict(
+    imports=['mmdet.models.necks.augfpn'],
+    allow_failed_imports=False)
+```
+
+### 3 修改配置
+
+```python
+neck=dict(
+    type='AugFPN',
+    in_channels=[256, 512, 1024, 2048],
+    out_channels=256,
+    num_outs=5)
+```
+
+关于自定义模型其余相关细节例如实现新的骨架网络，头部网络、损失函数，以及运行时训练配置例如定义新的优化器、使用梯度裁剪、定制训练调度策略和钩子等，请参考文档 [自定义模型](tutorials/customize_models.md) 和 [自定义运行时训练配置](tutorials/customize_runtime.md)。
+
+## 准备配置文件
+
+第三步是准备训练配置所需要的配置文件。假设你打算基于 cityscapes 数据集，在 Cascade Mask R-CNN R50 中新增 `AugFPN` 模块，同时增加 `Rotate` 或者 `Translate` 数据增强策略，假设你的配置文件位于 `configs/cityscapes/` 目录下，并且取名为 `cascade-mask-rcnn_r50_augfpn_autoaug-10e_cityscapes.py`，则配置信息如下：
+
+```python
+# 继承 base 配置，然后进行针对性修改
+_base_ = [
+    '../_base_/models/cascade-mask-rcnn_r50_fpn.py',
+    '../_base_/datasets/cityscapes_instance.py', '../_base_/default_runtime.py'
+]
+
+model = dict(
+    # 设置 `init_cfg` 为 None，表示不加载 ImageNet 预训练权重，
+    # 后续可以设置 `load_from` 参数用来加载 COCO 预训练权重
+    backbone=dict(init_cfg=None),
+    # 使用新增的 `AugFPN` 模块代替默认的 `FPN`
+    neck=dict(
+        type='AugFPN',
+        in_channels=[256, 512, 1024, 2048],
+        out_channels=256,
+        num_outs=5),
+    # 我们也需要将 num_classes 从 80 修改为 8 来匹配 cityscapes 数据集标注
+    # 这个修改包括 `bbox_head` 和 `mask_head`.
+    roi_head=dict(
+        bbox_head=[
+            dict(
+                type='Shared2FCBBoxHead',
+                in_channels=256,
+                fc_out_channels=1024,
+                roi_feat_size=7,
+                # 将 COCO 类别修改为 cityscapes 类别
+                num_classes=8,
+                bbox_coder=dict(
+                    type='DeltaXYWHBBoxCoder',
+                    target_means=[0., 0., 0., 0.],
+                    target_stds=[0.1, 0.1, 0.2, 0.2]),
+                reg_class_agnostic=True,
+                loss_cls=dict(
+                    type='CrossEntropyLoss',
+                    use_sigmoid=False,
+                    loss_weight=1.0),
+                loss_bbox=dict(type='SmoothL1Loss', beta=1.0,
+                               loss_weight=1.0)),
+            dict(
+                type='Shared2FCBBoxHead',
+                in_channels=256,
+                fc_out_channels=1024,
+                roi_feat_size=7,
+                # 将 COCO 类别修改为 cityscapes 类别
+                num_classes=8,
+                bbox_coder=dict(
+                    type='DeltaXYWHBBoxCoder',
+                    target_means=[0., 0., 0., 0.],
+                    target_stds=[0.05, 0.05, 0.1, 0.1]),
+                reg_class_agnostic=True,
+                loss_cls=dict(
+                    type='CrossEntropyLoss',
+                    use_sigmoid=False,
+                    loss_weight=1.0),
+                loss_bbox=dict(type='SmoothL1Loss', beta=1.0,
+                               loss_weight=1.0)),
+            dict(
+                type='Shared2FCBBoxHead',
+                in_channels=256,
+                fc_out_channels=1024,
+                roi_feat_size=7,
+                # 将 COCO 类别修改为 cityscapes 类别
+                num_classes=8,
+                bbox_coder=dict(
+                    type='DeltaXYWHBBoxCoder',
+                    target_means=[0., 0., 0., 0.],
+                    target_stds=[0.033, 0.033, 0.067, 0.067]),
+                reg_class_agnostic=True,
+                loss_cls=dict(
+                    type='CrossEntropyLoss',
+                    use_sigmoid=False,
+                    loss_weight=1.0),
+                loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0))
+        ],
+        mask_head=dict(
+            type='FCNMaskHead',
+            num_convs=4,
+            in_channels=256,
+            conv_out_channels=256,
+            # 将 COCO 类别修改为 cityscapes 类别
+            num_classes=8,
+            loss_mask=dict(
+                type='CrossEntropyLoss', use_mask=True, loss_weight=1.0))))
+
+# 覆写 `train_pipeline`，然后新增 `AutoAugment` 训练配置
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
+    dict(
+        type='AutoAugment',
+        policies=[
+            [dict(
+                 type='Rotate',
+                 level=5,
+                 img_border_value=(124, 116, 104),
+                 prob=0.5)
+            ],
+            [dict(type='Rotate', level=7, img_border_value=(124, 116, 104)),
+             dict(
+                 type='TranslateX',
+                 level=5,
+                 prob=0.5,
+                 img_border_value=(124, 116, 104))
+            ],
+        ]),
+    dict(
+        type='RandomResize',
+        scale=[(2048, 800), (2048, 1024)],
+        keep_ratio=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs'),
+]
+
+# 设置每张显卡的批处理大小，同时设置新的训练 pipeline
+data = dict(
+    samples_per_gpu=1,
+    workers_per_gpu=3,
+    train=dict(dataset=dict(pipeline=train_pipeline)))
+
+# 设置优化器
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001))
+
+# 设置定制的学习率策略
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500),
+    dict(
+        type='MultiStepLR',
+        begin=0,
+        end=10,
+        by_epoch=True,
+        milestones=[8],
+        gamma=0.1)
+]
+
+# 训练，验证，测试配置
+train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=10, val_interval=1)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+
+# 我们采用 COCO 预训练过的 Cascade Mask R-CNN R50 模型权重作为初始化权重，可以得到更加稳定的性能
+load_from = 'https://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco/cascade_mask_rcnn_r50_fpn_1x_coco_20200203-9d4dcb24.pth'
+```
+
+## 训练新模型
+
+为了能够使用新增配置来训练模型，你可以运行如下命令：
+
+```shell
+python tools/train.py configs/cityscapes/cascade-mask-rcnn_r50_augfpn_autoaug-10e_cityscapes.py
+```
+
+如果想了解更多用法，可以参考 [例子1](1_exist_data_model.md)。
+
+## 测试和推理
+
+为了能够测试训练好的模型，你可以运行如下命令：
+
+```shell
+python tools/test.py configs/cityscapes/cascade-mask-rcnn_r50_augfpn_autoaug-10e_cityscapes.py work_dirs/cascade-mask-rcnn_r50_augfpn_autoaug-10e_cityscapes/epoch_10.pth
+```
+
+如果想了解更多用法，可以参考 [例子1](1_exist_data_model.md)。
diff --git a/mmdetection/docs/zh_cn/user_guides/robustness_benchmarking.md b/mmdetection/docs/zh_cn/user_guides/robustness_benchmarking.md
new file mode 100644
index 00000000..e95c79a9
--- /dev/null
+++ b/mmdetection/docs/zh_cn/user_guides/robustness_benchmarking.md
@@ -0,0 +1,109 @@
+# 检测器鲁棒性检查
+
+## 介绍
+
+我们提供了在 [Benchmarking Robustness in Object Detection: Autonomous Driving when Winter is Coming](https://arxiv.org/abs/1907.07484) 中定义的「图像损坏基准测试」上测试目标检测和实例分割模型的工具。
+此页面提供了如何使用该基准测试的基本教程。
+
+```latex
+@article{michaelis2019winter,
+  title={Benchmarking Robustness in Object Detection:
+    Autonomous Driving when Winter is Coming},
+  author={Michaelis, Claudio and Mitzkus, Benjamin and
+    Geirhos, Robert and Rusak, Evgenia and
+    Bringmann, Oliver and Ecker, Alexander S. and
+    Bethge, Matthias and Brendel, Wieland},
+  journal={arXiv:1907.07484},
+  year={2019}
+}
+```
+
+![image corruption example](../../../resources/corruptions_sev_3.png)
+
+## 关于基准测试
+
+要将结果提交到基准测试，请访问[基准测试主页](https://github.com/bethgelab/robust-detection-benchmark)
+
+基准测试是仿照 [imagenet-c 基准测试](https://github.com/hendrycks/robustness)，由 Dan Hendrycks 和 Thomas Dietterich 在[Benchmarking Neural Network Robustness to Common Corruptions and Perturbations](https://arxiv.org/abs/1903.12261)(ICLR 2019)中发表。
+
+图像损坏变换功能包含在此库中，但可以使用以下方法单独安装：
+
+```shell
+pip install imagecorruptions
+```
+
+与 imagenet-c 相比，我们必须进行一些更改以处理任意大小的图像和灰度图像。
+我们还修改了“运动模糊”和“雪”损坏，以解除对于 linux 特定库的依赖，
+否则必须单独安装这些库。有关详细信息，请参阅 [imagecorruptions](https://github.com/bethgelab/imagecorruptions)。
+
+## 使用预训练模型进行推理
+
+我们提供了一个测试脚本来评估模型在基准测试中提供的各种损坏变换组合下的性能。
+
+### 在数据集上测试
+
+- [x] 单张 GPU 测试
+- [ ] 多张 GPU 测试
+- [ ] 可视化检测结果
+
+您可以使用以下命令在基准测试中使用 15 种损坏变换来测试模型性能。
+
+```shell
+# single-gpu testing
+python tools/analysis_tools/test_robustness.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] [--eval ${EVAL_METRICS}]
+```
+
+也可以选择其它不同类型的损坏变换。
+
+```shell
+# noise
+python tools/analysis_tools/test_robustness.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] [--eval ${EVAL_METRICS}] --corruptions noise
+
+# blur
+python tools/analysis_tools/test_robustness.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] [--eval ${EVAL_METRICS}] --corruptions blur
+
+# wetaher
+python tools/analysis_tools/test_robustness.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] [--eval ${EVAL_METRICS}] --corruptions weather
+
+# digital
+python tools/analysis_tools/test_robustness.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] [--eval ${EVAL_METRICS}] --corruptions digital
+```
+
+或者使用一组自定义的损坏变换，例如：
+
+```shell
+# gaussian noise, zoom blur and snow
+python tools/analysis_tools/test_robustness.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] [--eval ${EVAL_METRICS}] --corruptions gaussian_noise zoom_blur snow
+```
+
+最后，我们也可以选择施加在图像上的损坏变换的严重程度。
+严重程度从 1 到 5 逐级增强，0 表示不对图像施加损坏变换，即原始图像数据。
+
+```shell
+# severity 1
+python tools/analysis_tools/test_robustness.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] [--eval ${EVAL_METRICS}] --severities 1
+
+# severities 0,2,4
+python tools/analysis_tools/test_robustness.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] [--eval ${EVAL_METRICS}] --severities 0 2 4
+```
+
+## 模型测试结果
+
+下表是各模型在 COCO 2017val 上的测试结果。
+
+|        Model        |      Backbone       |  Style  | Lr schd | box AP clean | box AP corr. | box % | mask AP clean | mask AP corr. | mask % |
+| :-----------------: | :-----------------: | :-----: | :-----: | :----------: | :----------: | :---: | :-----------: | :-----------: | :----: |
+|    Faster R-CNN     |      R-50-FPN       | pytorch |   1x    |     36.3     |     18.2     | 50.2  |       -       |       -       |   -    |
+|    Faster R-CNN     |      R-101-FPN      | pytorch |   1x    |     38.5     |     20.9     | 54.2  |       -       |       -       |   -    |
+|    Faster R-CNN     |   X-101-32x4d-FPN   | pytorch |   1x    |     40.1     |     22.3     | 55.5  |       -       |       -       |   -    |
+|    Faster R-CNN     |   X-101-64x4d-FPN   | pytorch |   1x    |     41.3     |     23.4     | 56.6  |       -       |       -       |   -    |
+|    Faster R-CNN     |    R-50-FPN-DCN     | pytorch |   1x    |     40.0     |     22.4     | 56.1  |       -       |       -       |   -    |
+|    Faster R-CNN     | X-101-32x4d-FPN-DCN | pytorch |   1x    |     43.4     |     26.7     | 61.6  |       -       |       -       |   -    |
+|     Mask R-CNN      |      R-50-FPN       | pytorch |   1x    |     37.3     |     18.7     | 50.1  |     34.2      |     16.8      |  49.1  |
+|     Mask R-CNN      |    R-50-FPN-DCN     | pytorch |   1x    |     41.1     |     23.3     | 56.7  |     37.2      |     20.7      |  55.7  |
+|    Cascade R-CNN    |      R-50-FPN       | pytorch |   1x    |     40.4     |     20.1     | 49.7  |       -       |       -       |   -    |
+| Cascade Mask R-CNN  |      R-50-FPN       | pytorch |   1x    |     41.2     |     20.7     | 50.2  |     35.7      |     17.6      |  49.3  |
+|      RetinaNet      |      R-50-FPN       | pytorch |   1x    |     35.6     |     17.8     | 50.1  |       -       |       -       |   -    |
+| Hybrid Task Cascade | X-101-64x4d-FPN-DCN | pytorch |   1x    |     50.6     |     32.7     | 64.7  |     43.8      |     28.1      |  64.0  |
+
+由于对图像的损坏变换存在随机性，测试结果可能略有不同。
diff --git a/mmdetection/docs/zh_cn/user_guides/semi_det.md b/mmdetection/docs/zh_cn/user_guides/semi_det.md
new file mode 100644
index 00000000..a2235237
--- /dev/null
+++ b/mmdetection/docs/zh_cn/user_guides/semi_det.md
@@ -0,0 +1,320 @@
+# 半监督目标检测
+
+半监督目标检测同时利用标签数据和无标签数据进行训练，一方面可以减少模型对检测框数量的依赖，另一方面也可以利用大量的未标记数据进一步提高模型。
+
+按照以下流程进行半监督目标检测：
+
+- [半监督目标检测](#半监督目标检测)
+  - [准备和拆分数据集](#准备和拆分数据集)
+  - [配置多分支数据流程](#配置多分支数据流程)
+  - [配置半监督数据加载](#配置半监督数据加载)
+  - [配置半监督模型](#配置半监督模型)
+  - [配置MeanTeacherHook](#配置meanteacherhook)
+  - [配置TeacherStudentValLoop](#配置teacherstudentvalloop)
+
+## 准备和拆分数据集
+
+我们提供了数据集下载脚本，默认下载 coco2017 数据集，并且自动解压。
+
+```shell
+python tools/misc/download_dataset.py
+```
+
+解压后的数据集目录如下：
+
+```plain
+mmdetection
+├── data
+│   ├── coco
+│   │   ├── annotations
+│   │   │   ├── image_info_unlabeled2017.json
+│   │   │   ├── instances_train2017.json
+│   │   │   ├── instances_val2017.json
+│   │   ├── test2017
+│   │   ├── train2017
+│   │   ├── unlabeled2017
+│   │   ├── val2017
+```
+
+半监督目标检测在 coco 数据集上有两种比较通用的实验设置：
+
+（1）将 `train2017` 按照固定百分比（1%，2%，5% 和 10%）划分出一部分数据作为标签数据集，剩余的训练集数据作为无标签数据集，同时考虑划分不同的训练集数据作为标签数据集对半监督训练的结果影响较大，所以采用五折交叉验证来评估算法性能。我们提供了数据集划分脚本：
+
+```shell
+python tools/misc/split_coco.py
+```
+
+该脚本默认会按照 1%，2%，5% 和 10% 的标签数据占比划分 `train2017`，每一种划分会随机重复 5 次，用于交叉验证。生成的半监督标注文件名称格式如下：
+
+- 标签数据集标注名称格式：`instances_train2017.{fold}@{percent}.json`
+
+- 无标签数据集名称标注：`instances_train2017.{fold}@{percent}-unlabeled.json`
+
+其中，`fold` 用于交叉验证，`percent` 表示标签数据的占比。 划分后的数据集目录结构如下：
+
+```plain
+mmdetection
+├── data
+│   ├── coco
+│   │   ├── annotations
+│   │   │   ├── image_info_unlabeled2017.json
+│   │   │   ├── instances_train2017.json
+│   │   │   ├── instances_val2017.json
+│   │   ├── semi_anns
+│   │   │   ├── instances_train2017.1@1.json
+│   │   │   ├── instances_train2017.1@1-unlabeled.json
+│   │   │   ├── instances_train2017.1@2.json
+│   │   │   ├── instances_train2017.1@2-unlabeled.json
+│   │   │   ├── instances_train2017.1@5.json
+│   │   │   ├── instances_train2017.1@5-unlabeled.json
+│   │   │   ├── instances_train2017.1@10.json
+│   │   │   ├── instances_train2017.1@10-unlabeled.json
+│   │   │   ├── instances_train2017.2@1.json
+│   │   │   ├── instances_train2017.2@1-unlabeled.json
+│   │   ├── test2017
+│   │   ├── train2017
+│   │   ├── unlabeled2017
+│   │   ├── val2017
+```
+
+（2）将 `train2017` 作为标签数据集，`unlabeled2017` 作为无标签数据集。由于 `image_info_unlabeled2017.json` 没有 `categories` 信息，无法初始化 `CocoDataset` ，所以需要将 `instances_train2017.json` 的 `categories` 写入 `image_info_unlabeled2017.json` ，另存为 `instances_unlabeled2017.json`，相关脚本如下：
+
+```python
+from mmengine.fileio import load, dump
+
+anns_train = load('instances_train2017.json')
+anns_unlabeled = load('image_info_unlabeled2017.json')
+anns_unlabeled['categories'] = anns_train['categories']
+dump(anns_unlabeled, 'instances_unlabeled2017.json')
+```
+
+处理后的数据集目录如下：
+
+```plain
+mmdetection
+├── data
+│   ├── coco
+│   │   ├── annotations
+│   │   │   ├── image_info_unlabeled2017.json
+│   │   │   ├── instances_train2017.json
+│   │   │   ├── instances_unlabeled2017.json
+│   │   │   ├── instances_val2017.json
+│   │   ├── test2017
+│   │   ├── train2017
+│   │   ├── unlabeled2017
+│   │   ├── val2017
+```
+
+## 配置多分支数据流程
+
+半监督学习有两个主要的方法，分别是
+[一致性正则化](https://research.nvidia.com/sites/default/files/publications/laine2017iclr_paper.pdf)
+和[伪标签](https://www.researchgate.net/profile/Dong-Hyun-Lee/publication/280581078_Pseudo-Label_The_Simple_and_Efficient_Semi-Supervised_Learning_Method_for_Deep_Neural_Networks/links/55bc4ada08ae092e9660b776/Pseudo-Label-The-Simple-and-Efficient-Semi-Supervised-Learning-Method-for-Deep-Neural-Networks.pdf) 。
+一致性正则化往往需要一些精心的设计，而伪标签的形式比较简单，更容易拓展到下游任务。我们主要采用了基于伪标签的教师学生联合训练的半监督目标检测框架，对于标签数据和无标签数据需要配置不同的数据流程：
+（1）标签数据的数据流程：
+
+```python
+# pipeline used to augment labeled data,
+# which will be sent to student model for supervised training.
+sup_pipeline = [
+    dict(type='LoadImageFromFile',backend_args = backend_args),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(type='RandomResize', scale=scale, keep_ratio=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='RandAugment', aug_space=color_space, aug_num=1),
+    dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)),
+    dict(type='MultiBranch', sup=dict(type='PackDetInputs'))
+]
+```
+
+（2）无标签的数据流程：
+
+```python
+# pipeline used to augment unlabeled data weakly,
+# which will be sent to teacher model for predicting pseudo instances.
+weak_pipeline = [
+    dict(type='RandomResize', scale=scale, keep_ratio=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(
+        type='PackDetInputs',
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor', 'flip', 'flip_direction',
+                   'homography_matrix')),
+]
+
+# pipeline used to augment unlabeled data strongly,
+# which will be sent to student model for unsupervised training.
+strong_pipeline = [
+    dict(type='RandomResize', scale=scale, keep_ratio=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(
+        type='RandomOrder',
+        transforms=[
+            dict(type='RandAugment', aug_space=color_space, aug_num=1),
+            dict(type='RandAugment', aug_space=geometric, aug_num=1),
+        ]),
+    dict(type='RandomErasing', n_patches=(1, 5), ratio=(0, 0.2)),
+    dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)),
+    dict(
+        type='PackDetInputs',
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor', 'flip', 'flip_direction',
+                   'homography_matrix')),
+]
+
+# pipeline used to augment unlabeled data into different views
+unsup_pipeline = [
+    dict(type='LoadImageFromFile', backend_args = backend_args),
+    dict(type='LoadEmptyAnnotations'),
+    dict(
+        type='MultiBranch',
+        unsup_teacher=weak_pipeline,
+        unsup_student=strong_pipeline,
+    )
+]
+```
+
+## 配置半监督数据加载
+
+（1）构建半监督数据集。使用 `ConcatDataset` 拼接标签数据集和无标签数据集。
+
+```python
+labeled_dataset = dict(
+    type=dataset_type,
+    data_root=data_root,
+    ann_file='annotations/instances_train2017.json',
+    data_prefix=dict(img='train2017/'),
+    filter_cfg=dict(filter_empty_gt=True, min_size=32),
+    pipeline=sup_pipeline)
+
+unlabeled_dataset = dict(
+    type=dataset_type,
+    data_root=data_root,
+    ann_file='annotations/instances_unlabeled2017.json',
+    data_prefix=dict(img='unlabeled2017/'),
+    filter_cfg=dict(filter_empty_gt=False),
+    pipeline=unsup_pipeline)
+
+train_dataloader = dict(
+    batch_size=batch_size,
+    num_workers=num_workers,
+    persistent_workers=True,
+    sampler=dict(
+        type='GroupMultiSourceSampler',
+        batch_size=batch_size,
+        source_ratio=[1, 4]),
+    dataset=dict(
+        type='ConcatDataset', datasets=[labeled_dataset, unlabeled_dataset]))
+```
+
+（2）使用多源数据集采样器。 使用 `GroupMultiSourceSampler` 从 `labeled_dataset` 和 `labeled_dataset` 采样数据组成 batch , `source_ratio` 控制 batch 中标签数据和无标签数据的占比。`GroupMultiSourceSampler` 还保证了同一个 batch 中的图片具有相近的长宽比例，如果不需要保证batch内图片的长宽比例，可以使用 `MultiSourceSampler`。`GroupMultiSourceSampler` 采样示意图如下：
+
+
    
+
+
    
+
+`sup=1000` 表示标签数据集的规模为 1000 ，`sup_h=200` 表示标签数据集中长宽比大于等于1的图片规模为 200，`sup_w=800` 表示标签数据集中长宽比小于1的图片规模为 800 ，`unsup=9000` 表示无标签数据集的规模为 9000 ，`unsup_h=1800` 表示无标签数据集中长宽比大于等于1的图片规模为 1800，`unsup_w=7200` 表示标签数据集中长宽比小于1的图片规模为 7200 ，`GroupMultiSourceSampler` 每次按照标签数据集和无标签数据集的图片的总体长宽比分布随机选择一组，然后按照 `source_ratio` 从两个数据集中采样组成 batch ，因此标签数据集和无标签数据集重复采样次数不同。
+
+## 配置半监督模型
+
+我们选择 `Faster R-CNN` 作为 `detector` 进行半监督训练，以半监督目标检测算法 `SoftTeacher` 为例，模型的配置可以继承 `_base_/models/faster-rcnn_r50_fpn.py`，将检测器的骨干网络替换成 `caffe` 风格。
+注意，与监督训练的配置文件不同的是，`Faster R-CNN` 作为 `detector`，是作为 `model`的一个属性，而不是 `model` 。此外，还需要将`data_preprocessor`设置为`MultiBranchDataPreprocessor`，用于处理不同数据流程图片的填充和归一化。
+最后，可以通过 `semi_train_cfg` 和 `semi_test_cfg` 配置半监督训练和测试需要的参数。
+
+```python
+_base_ = [
+    '../_base_/models/faster-rcnn_r50_fpn.py', '../_base_/default_runtime.py',
+    '../_base_/datasets/semi_coco_detection.py'
+]
+
+detector = _base_.model
+detector.data_preprocessor = dict(
+    type='DetDataPreprocessor',
+    mean=[103.530, 116.280, 123.675],
+    std=[1.0, 1.0, 1.0],
+    bgr_to_rgb=False,
+    pad_size_divisor=32)
+detector.backbone = dict(
+    type='ResNet',
+    depth=50,
+    num_stages=4,
+    out_indices=(0, 1, 2, 3),
+    frozen_stages=1,
+    norm_cfg=dict(type='BN', requires_grad=False),
+    norm_eval=True,
+    style='caffe',
+    init_cfg=dict(
+        type='Pretrained',
+        checkpoint='open-mmlab://detectron2/resnet50_caffe'))
+
+model = dict(
+    _delete_=True,
+    type='SoftTeacher',
+    detector=detector,
+    data_preprocessor=dict(
+        type='MultiBranchDataPreprocessor',
+        data_preprocessor=detector.data_preprocessor),
+    semi_train_cfg=dict(
+        freeze_teacher=True,
+        sup_weight=1.0,
+        unsup_weight=4.0,
+        pseudo_label_initial_score_thr=0.5,
+        rpn_pseudo_thr=0.9,
+        cls_pseudo_thr=0.9,
+        reg_pseudo_thr=0.02,
+        jitter_times=10,
+        jitter_scale=0.06,
+        min_pseudo_bbox_wh=(1e-2, 1e-2)),
+    semi_test_cfg=dict(predict_on='teacher'))
+```
+
+此外，我们也支持其他检测模型进行半监督训练，比如，`RetinaNet` 和 `Cascade R-CNN`。由于 `SoftTeacher` 仅支持 `Faster R-CNN`，所以需要将其替换为 `SemiBaseDetector`，示例如下：
+
+```python
+_base_ = [
+    '../_base_/models/retinanet_r50_fpn.py', '../_base_/default_runtime.py',
+    '../_base_/datasets/semi_coco_detection.py'
+]
+
+detector = _base_.model
+
+model = dict(
+    _delete_=True,
+    type='SemiBaseDetector',
+    detector=detector,
+    data_preprocessor=dict(
+        type='MultiBranchDataPreprocessor',
+        data_preprocessor=detector.data_preprocessor),
+    semi_train_cfg=dict(
+        freeze_teacher=True,
+        sup_weight=1.0,
+        unsup_weight=1.0,
+        cls_pseudo_thr=0.9,
+        min_pseudo_bbox_wh=(1e-2, 1e-2)),
+    semi_test_cfg=dict(predict_on='teacher'))
+```
+
+沿用 `SoftTeacher` 的半监督训练配置，将 `batch_size` 改为 2 ，`source_ratio` 改为 `[1, 1]`，`RetinaNet`，`Faster R-CNN`， `Cascade R-CNN` 以及 `SoftTeacher` 在 10% coco 训练集上的监督训练和半监督训练的实验结果如下：
+
+|      Model       |   Detector    | BackBone | Style | sup-0.1-coco mAP | semi-0.1-coco mAP |
+| :--------------: | :-----------: | :------: | :---: | :--------------: | :---------------: |
+| SemiBaseDetector |   RetinaNet   | R-50-FPN | caffe |       23.5       |       27.7        |
+| SemiBaseDetector | Faster R-CNN  | R-50-FPN | caffe |       26.7       |       28.4        |
+| SemiBaseDetector | Cascade R-CNN | R-50-FPN | caffe |       28.0       |       29.7        |
+|   SoftTeacher    | Faster R-CNN  | R-50-FPN | caffe |       26.7       |       31.1        |
+
+## 配置MeanTeacherHook
+
+通常，教师模型采用对学生模型指数滑动平均（EMA）的方式进行更新，进而教师模型随着学生模型的优化而优化，可以通过配置 `custom_hooks` 实现：
+
+```python
+custom_hooks = [dict(type='MeanTeacherHook')]
+```
+
+## 配置TeacherStudentValLoop
+
+由于教师学生联合训练框架存在两个模型，我们可以用 `TeacherStudentValLoop` 替换 `ValLoop`，在训练的过程中同时检验两个模型的精度。
+
+```python
+val_cfg = dict(type='TeacherStudentValLoop')
+```
diff --git a/mmdetection/docs/zh_cn/user_guides/single_stage_as_rpn.md b/mmdetection/docs/zh_cn/user_guides/single_stage_as_rpn.md
new file mode 100644
index 00000000..39db35c2
--- /dev/null
+++ b/mmdetection/docs/zh_cn/user_guides/single_stage_as_rpn.md
@@ -0,0 +1,171 @@
+# 将单阶段检测器作为 RPN
+
+候选区域网络 (Region Proposal Network, RPN) 作为 [Faster R-CNN](https://arxiv.org/abs/1506.01497) 的一个子模块，将为 Faster R-CNN 的第二阶段产生候选区域。在 MMDetection 里大多数的二阶段检测器使用 [`RPNHead`](../../../mmdet/models/dense_heads/rpn_head.py)作为候选区域网络来产生候选区域。然而，任何的单阶段检测器都可以作为候选区域网络，是因为他们对边界框的预测可以被视为是一种候选区域，并且因此能够在 R-CNN 中得到改进。因此在 MMDetection v3.0 中会支持将单阶段检测器作为 RPN 使用。
+
+接下来我们通过一个例子，即如何在 [Faster R-CNN](../../../configs/faster_rcnn/faster-rcnn_r50_fpn_fcos-rpn_1x_coco.py) 中使用一个无锚框的单阶段的检测器模型 [FCOS](../../../configs/fcos/fcos_r50-caffe_fpn_gn-head_1x_coco.py) 作为 RPN ，详细阐述具体的全部流程。
+
+主要流程如下:
+
+1. 在 Faster R-CNN 中使用 `FCOSHead` 作为 `RPNHead`
+2. 评估候选区域
+3. 用预先训练的 FCOS 训练定制的 Faster R-CNN
+
+## 在 Faster R-CNN 中使用 `FCOSHead` 作为` RPNHead`
+
+为了在 Faster R-CNN 中使用 `FCOSHead` 作为 `RPNHead` ，我们应该创建一个名为 `configs/faster_rcnn/faster-rcnn_r50_fpn_fcos-rpn_1x_coco.py` 的配置文件，并且在 `configs/faster_rcnn/faster-rcnn_r50_fpn_fcos-rpn_1x_coco.py` 中将 `rpn_head` 的设置替换为 `bbox_head` 的设置，此外我们仍然使用 FCOS 的瓶颈设置，步幅为`[8,16,32,64,128]`，并且更新 `bbox_roi_extractor` 的 `featmap_stride` 为 ` [8,16,32,64,128]`。为了避免损失变慢，我们在前1000次迭代而不是前500次迭代中应用预热，这意味着 lr 增长得更慢。相关配置如下:
+
+```python
+_base_ = [
+    '../_base_/models/faster-rcnn_r50_fpn.py',
+    '../_base_/datasets/coco_detection.py',
+    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
+]
+model = dict(
+    # 从 configs/fcos/fcos_r50-caffe_fpn_gn-head_1x_coco.py 复制
+    neck=dict(
+        start_level=1,
+        add_extra_convs='on_output',  # 使用 P5
+        relu_before_extra_convs=True),
+    rpn_head=dict(
+        _delete_=True,  # 忽略未使用的旧设置
+        type='FCOSHead',
+        num_classes=1,  # 对于 rpn, num_classes = 1，如果 num_classes > 1，它将在 TwoStageDetector 中自动设置为1
+        in_channels=256,
+        stacked_convs=4,
+        feat_channels=256,
+        strides=[8, 16, 32, 64, 128],
+        loss_cls=dict(
+            type='FocalLoss',
+            use_sigmoid=True,
+            gamma=2.0,
+            alpha=0.25,
+            loss_weight=1.0),
+        loss_bbox=dict(type='IoULoss', loss_weight=1.0),
+        loss_centerness=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)),
+    roi_head=dict(  # featmap_strides 的更新取决于于颈部的步伐
+        bbox_roi_extractor=dict(featmap_strides=[8, 16, 32, 64, 128])))
+# 学习率
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0,
+        end=1000),  # 慢慢增加 lr，否则损失变成 NAN
+    dict(
+        type='MultiStepLR',
+        begin=0,
+        end=12,
+        by_epoch=True,
+        milestones=[8, 11],
+        gamma=0.1)
+]
+```
+
+然后，我们可以使用下面的命令来训练我们的定制模型。更多训练命令，请参考[这里](train.md)。
+
+```python
+# 使用8个 GPU 进行训练
+bash
+tools/dist_train.sh
+configs/faster_rcnn/faster-rcnn_r50_fpn_fcos-rpn_1x_coco.py
+--work-dir  /work_dirs/faster-rcnn_r50_fpn_fcos-rpn_1x_coco
+```
+
+## 评估候选区域
+
+候选区域的质量对检测器的性能有重要影响，因此，我们也提供了一种评估候选区域的方法。和上面一样创建一个新的名为 `configs/rpn/fcos-rpn_r50_fpn_1x_coco.py` 的配置文件，并且在 `configs/rpn/fcos-rpn_r50_fpn_1x_coco.py` 中将 `rpn_head` 的设置替换为 `bbox_head` 的设置。
+
+```python
+_base_ = [
+    '../_base_/models/rpn_r50_fpn.py', '../_base_/datasets/coco_detection.py',
+    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
+]
+val_evaluator = dict(metric='proposal_fast')
+test_evaluator = val_evaluator
+model = dict(
+    # 从 configs/fcos/fcos_r50-caffe_fpn_gn-head_1x_coco.py 复制
+    neck=dict(
+        start_level=1,
+        add_extra_convs='on_output',  # 使用 P5
+        relu_before_extra_convs=True),
+    rpn_head=dict(
+        _delete_=True,  # 忽略未使用的旧设置
+        type='FCOSHead',
+        num_classes=1,  # 对于 rpn, num_classes = 1，如果 num_classes >为1，它将在 rpn 中自动设置为1
+        in_channels=256,
+        stacked_convs=4,
+        feat_channels=256,
+        strides=[8, 16, 32, 64, 128],
+        loss_cls=dict(
+            type='FocalLoss',
+            use_sigmoid=True,
+            gamma=2.0,
+            alpha=0.25,
+            loss_weight=1.0),
+        loss_bbox=dict(type='IoULoss', loss_weight=1.0),
+        loss_centerness=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)))
+```
+
+假设我们在训练之后有检查点 `./work_dirs/faster-rcnn_r50_fpn_fcos-rpn_1x_coco/epoch_12.pth` ，然后，我们可以使用下面的命令来评估建议的质量。
+
+```python
+# 使用8个 GPU 进行测试
+bash
+tools/dist_test.sh
+configs/rpn/fcos-rpn_r50_fpn_1x_coco.py
+--work_dirs /faster-rcnn_r50_fpn_fcos-rpn_1x_coco/epoch_12.pth
+```
+
+## 用预先训练的 FCOS 训练定制的 Faster R-CNN
+
+预训练不仅加快了训练的收敛速度，而且提高了检测器的性能。因此，我们在这里给出一个例子来说明如何使用预先训练的 FCOS 作为 RPN 来加速训练和提高精度。假设我们想在 Faster R-CNN 中使用 `FCOSHead` 作为 `rpn_head`，并加载预先训练权重来进行训练 [`fcos_r50-caffe_fpn_gn-head_1x_coco`](https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_r50_caffe_fpn_gn-head_1x_coco/fcos_r50_caffe_fpn_gn-head_1x_coco-821213aa.pth)。 配置文件 `configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_fcos- rpn_1x_copy .py` 的内容如下所示。注意，`fcos_r50-caffe_fpn_gn-head_1x_coco` 使用 ResNet50 的 caffe 版本，因此需要更新 `data_preprocessor` 中的像素平均值和 std。
+
+```python
+_base_ = [
+    '../_base_/models/faster-rcnn_r50_fpn.py',
+    '../_base_/datasets/coco_detection.py',
+    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
+]
+model = dict(
+    data_preprocessor=dict(
+        mean=[103.530, 116.280, 123.675],
+        std=[1.0, 1.0, 1.0],
+        bgr_to_rgb=False),
+    backbone=dict(
+        norm_cfg=dict(type='BN', requires_grad=False),
+        style='caffe',
+        init_cfg=None),  # the checkpoint in ``load_from`` contains the weights of backbone
+    neck=dict(
+        start_level=1,
+        add_extra_convs='on_output',  # 使用 P5
+        relu_before_extra_convs=True),
+    rpn_head=dict(
+        _delete_=True,  # 忽略未使用的旧设置
+        type='FCOSHead',
+        num_classes=1,  # 对于 rpn, num_classes = 1，如果 num_classes > 1，它将在 TwoStageDetector 中自动设置为1
+        in_channels=256,
+        stacked_convs=4,
+        feat_channels=256,
+        strides=[8, 16, 32, 64, 128],
+        loss_cls=dict(
+            type='FocalLoss',
+            use_sigmoid=True,
+            gamma=2.0,
+            alpha=0.25,
+            loss_weight=1.0),
+        loss_bbox=dict(type='IoULoss', loss_weight=1.0),
+        loss_centerness=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0)),
+    roi_head=dict(  # update featmap_strides due to the strides in neck
+        bbox_roi_extractor=dict(featmap_strides=[8, 16, 32, 64, 128])))
+load_from = 'https://download.openmmlab.com/mmdetection/v2.0/fcos/fcos_r50_caffe_fpn_gn-head_1x_coco/fcos_r50_caffe_fpn_gn-head_1x_coco-821213aa.pth'
+```
+
+训练命令如下。
+
+```python
+bash
+tools/dist_train.sh
+configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_fcos-rpn_1x_coco.py  \
+--work-dir /work_dirs/faster-rcnn_r50-caffe_fpn_fcos-rpn_1x_coco
+```
diff --git a/mmdetection/docs/zh_cn/user_guides/test.md b/mmdetection/docs/zh_cn/user_guides/test.md
new file mode 100644
index 00000000..2ada04d2
--- /dev/null
+++ b/mmdetection/docs/zh_cn/user_guides/test.md
@@ -0,0 +1,285 @@
+# 测试现有模型
+
+我们提供了测试脚本，能够测试一个现有模型在所有数据集（COCO，Pascal VOC，Cityscapes 等）上的性能。我们支持在如下环境下测试：
+
+- 单 GPU 测试
+- CPU 测试
+- 单节点多 GPU 测试
+- 多节点测试
+
+根据以上测试环境，选择合适的脚本来执行测试过程。
+
+```shell
+# 单 GPU 测试
+python tools/test.py \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    [--out ${RESULT_FILE}] \
+    [--show]
+
+# CPU 测试：禁用 GPU 并运行单 GPU 测试脚本
+export CUDA_VISIBLE_DEVICES=-1
+python tools/test.py \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    [--out ${RESULT_FILE}] \
+    [--show]
+
+# 单节点多 GPU 测试
+bash tools/dist_test.sh \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    ${GPU_NUM} \
+    [--out ${RESULT_FILE}]
+```
+
+`tools/dist_test.sh` 也支持多节点测试，不过需要依赖 PyTorch 的 [启动工具](https://pytorch.org/docs/stable/distributed.html#launch-utility) 。
+
+可选参数：
+
+- `RESULT_FILE`: 结果文件名称，需以 .pkl 形式存储。如果没有声明，则不将结果存储到文件。
+- `--show`: 如果开启，检测结果将被绘制在图像上，以一个新窗口的形式展示。它只适用于单 GPU 的测试，是用于调试和可视化的。请确保使用此功能时，你的 GUI 可以在环境中打开。否则，你可能会遇到这么一个错误 `cannot connect to X server`。
+- `--show-dir`: 如果指明，检测结果将会被绘制在图像上并保存到指定目录。它只适用于单 GPU 的测试，是用于调试和可视化的。即使你的环境中没有 GUI，这个选项也可使用。
+- `--cfg-options`:  如果指明，这里的键值对将会被合并到配置文件中。
+
+### 样例
+
+假设你已经下载了 checkpoint 文件到 `checkpoints/` 文件下了。
+
+1. 测试 RTMDet 并可视化其结果。按任意键继续下张图片的测试。配置文件和 checkpoint 文件 [在此](https://github.com/open-mmlab/mmdetection/tree/main/configs/rtmdet) 。
+
+   ```shell
+   python tools/test.py \
+       configs/rtmdet/rtmdet_l_8xb32-300e_coco.py \
+       checkpoints/rtmdet_l_8xb32-300e_coco_20220719_112030-5a0be7c4.pth \
+       --show
+   ```
+
+2. 测试 RTMDet，并为了之后的可视化保存绘制的图像。配置文件和 checkpoint 文件 [在此](https://github.com/open-mmlab/mmdetection/tree/main/configs/rtmdet) 。
+
+   ```shell
+   python tools/test.py \
+       configs/rtmdet/rtmdet_l_8xb32-300e_coco.py \
+       checkpoints/rtmdet_l_8xb32-300e_coco_20220719_112030-5a0be7c4.pth \
+       --show-dir rtmdet_l_8xb32-300e_coco_results
+   ```
+
+3. 在 Pascal VOC 数据集上测试 Faster R-CNN，不保存测试结果，测试 `mAP`。配置文件和 checkpoint 文件 [在此](../../../configs/pascal_voc) 。
+
+   ```shell
+   python tools/test.py \
+       configs/pascal_voc/faster-rcnn_r50_fpn_1x_voc0712.py \
+       checkpoints/faster_rcnn_r50_fpn_1x_voc0712_20200624-c9895d40.pth
+   ```
+
+4. 使用 8 块 GPU 测试 Mask R-CNN，测试 `bbox` 和 `mAP` 。配置文件和 checkpoint 文件 [在此](../../../configs/mask_rcnn) 。
+
+   ```shell
+   ./tools/dist_test.sh \
+       configs/mask-rcnn_r50_fpn_1x_coco.py \
+       checkpoints/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth \
+       8 \
+       --out results.pkl
+   ```
+
+5. 使用 8 块 GPU 测试 Mask R-CNN，测试**每类**的 `bbox` 和 `mAP`。配置文件和 checkpoint 文件 [在此](../../../configs/mask_rcnn) 。
+
+   ```shell
+   ./tools/dist_test.sh \
+       configs/mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py \
+       checkpoints/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth \
+       8
+   ```
+
+   该命令生成两个JSON文件 `./work_dirs/coco_instance/test.bbox.json` 和 `./work_dirs/coco_instance/test.segm.json`。
+
+6. 在 COCO test-dev 数据集上，使用 8 块 GPU 测试 Mask R-CNN，并生成 JSON 文件提交到官方评测服务器，配置文件和 checkpoint 文件 [在此](../../../configs/mask_rcnnn) 。你可以在 [config](./././configs/_base_/datasets/coco_instance.py) 的注释中用 test_evaluator 和 test_dataloader 替换原来的 test_evaluator 和 test_dataloader，然后运行：
+
+   ```shell
+   ./tools/dist_test.sh \
+       configs/cityscapes/mask-rcnn_r50_fpn_1x_cityscapes.py \
+       checkpoints/mask_rcnn_r50_fpn_1x_cityscapes_20200227-afe51d5a.pth \
+       8
+   ```
+
+   这行命令生成两个 JSON 文件 `mask_rcnn_test-dev_results.bbox.json` 和 `mask_rcnn_test-dev_results.segm.json`。
+
+7. 在 Cityscapes 数据集上，使用 8 块 GPU 测试 Mask R-CNN，生成 txt 和 png 文件，并上传到官方评测服务器。配置文件和 checkpoint 文件 [在此](../../../configs/cityscapes) 。 你可以在 [config](./././configs/_base_/datasets/cityscapes_instance.py) 的注释中用 test_evaluator 和 test_dataloader 替换原来的 test_evaluator 和 test_dataloader，然后运行：
+
+   ```shell
+   ./tools/dist_test.sh \
+       configs/cityscapes/mask-rcnn_r50_fpn_1x_cityscapes.py \
+       checkpoints/mask_rcnn_r50_fpn_1x_cityscapes_20200227-afe51d5a.pth \
+       8
+   ```
+
+   生成的 png 和 txt 文件在 `./work_dirs/cityscapes_metric` 文件夹下。
+
+### 不使用 Ground Truth 标注进行测试
+
+MMDetection 支持在不使用 ground-truth 标注的情况下对模型进行测试，这需要用到 `CocoDataset`。如果你的数据集格式不是 COCO 格式的，请将其转化成 COCO 格式。如果你的数据集格式是 VOC 或者 Cityscapes，你可以使用 [tools/dataset_converters](https://github.com/open-mmlab/mmdetection/tree/main/tools/dataset_converters) 内的脚本直接将其转化成 COCO 格式。如果是其他格式，可以使用 [images2coco 脚本](https://github.com/open-mmlab/mmdetection/tree/master/tools/dataset_converters/images2coco.py) 进行转换。
+
+```shell
+python tools/dataset_converters/images2coco.py \
+    ${IMG_PATH} \
+    ${CLASSES} \
+    ${OUT} \
+    [--exclude-extensions]
+```
+
+参数：
+
+- `IMG_PATH`: 图片根路径。
+- `CLASSES`: 类列表文本文件名。文本中每一行存储一个类别。
+- `OUT`: 输出 json 文件名。 默认保存目录和 `IMG_PATH` 在同一级。
+- `exclude-extensions`: 待排除的文件后缀名。
+
+在转换完成后，使用如下命令进行测试
+
+```shell
+# 单 GPU 测试
+python tools/test.py \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    [--show]
+
+# CPU 测试：禁用 GPU 并运行单 GPU 测试脚本
+export CUDA_VISIBLE_DEVICES=-1
+python tools/test.py \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    [--out ${RESULT_FILE}] \
+    [--show]
+
+# 单节点多 GPU 测试
+bash tools/dist_test.sh \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    ${GPU_NUM} \
+    [--show]
+```
+
+假设 [model zoo](https://mmdetection.readthedocs.io/en/latest/modelzoo_statistics.html) 中的 checkpoint 文件被下载到了 `checkpoints/` 文件夹下，
+我们可以使用以下命令，用 8 块 GPU 在 COCO test-dev 数据集上测试 Mask R-CNN，并且生成 JSON 文件。
+
+```sh
+./tools/dist_test.sh \
+    configs/mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py \
+    checkpoints/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth \
+    8
+```
+
+这行命令生成两个 JSON 文件 `./work_dirs/coco_instance/test.bbox.json` 和 `./work_dirs/coco_instance/test.segm.json`。
+
+### 批量推理
+
+MMDetection 在测试模式下，既支持单张图片的推理，也支持对图像进行批量推理。默认情况下，我们使用单张图片的测试，你可以通过修改测试数据配置文件中的 `samples_per_gpu` 来开启批量测试。
+开启批量推理的配置文件修改方法为：
+
+```shell
+data = dict(train_dataloader=dict(...), val_dataloader=dict(...), test_dataloader=dict(batch_size=2, ...))
+```
+
+或者你可以通过将 `--cfg-options` 设置为 `--cfg-options test_dataloader.batch_size=` 来开启它。
+
+## 测试时增强 (TTA)
+
+测试时增强 (TTA) 是一种在测试阶段使用的数据增强策略。它对同一张图片应用不同的增强，例如翻转和缩放，用于模型推理，然后将每个增强后的图像的预测结果合并，以获得更准确的预测结果。为了让用户更容易使用 TTA，MMEngine 提供了 [BaseTTAModel](https://mmengine.readthedocs.io/en/latest/api/generated/mmengine.model.BaseTTAModel.html#mmengine.model.BaseTTAModel) 类，允许用户根据自己的需求通过简单地扩展 BaseTTAModel 类来实现不同的 TTA 策略。
+
+在 MMDetection 中，我们提供了 [DetTTAModel](../../../mmdet/models/test_time_augs/det_tta.py) 类，它继承自 BaseTTAModel。
+
+### 使用案例
+
+使用 TTA 需要两个步骤。首先，你需要在配置文件中添加 `tta_model` 和 `tta_pipeline`：
+
+```shell
+tta_model = dict(
+    type='DetTTAModel',
+    tta_cfg=dict(nms=dict(
+                   type='nms',
+                   iou_threshold=0.5),
+                   max_per_img=100))
+
+tta_pipeline = [
+    dict(type='LoadImageFromFile',
+        backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[[
+            dict(type='Resize', scale=(1333, 800), keep_ratio=True)
+        ], [ # It uses 2 flipping transformations (flipping and not flipping).
+            dict(type='RandomFlip', prob=1.),
+            dict(type='RandomFlip', prob=0.)
+        ], [
+            dict(
+               type='PackDetInputs',
+               meta_keys=('img_id', 'img_path', 'ori_shape',
+                       'img_shape', 'scale_factor', 'flip',
+                       'flip_direction'))
+       ]])]
+```
+
+第二步，运行测试脚本时，设置 `--tta` 参数，如下所示：
+
+```shell
+# 单 GPU 测试
+python tools/test.py \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    [--tta]
+
+# CPU 测试：禁用 GPU 并运行单 GPU 测试脚本
+export CUDA_VISIBLE_DEVICES=-1
+python tools/test.py \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    [--out ${RESULT_FILE}] \
+    [--tta]
+
+# 多 GPU 测试
+bash tools/dist_test.sh \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    ${GPU_NUM} \
+    [--tta]
+```
+
+你也可以自己修改 TTA 配置，例如添加缩放增强：
+
+```shell
+tta_model = dict(
+    type='DetTTAModel',
+    tta_cfg=dict(nms=dict(
+                   type='nms',
+                   iou_threshold=0.5),
+                   max_per_img=100))
+
+img_scales = [(1333, 800), (666, 400), (2000, 1200)]
+tta_pipeline = [
+    dict(type='LoadImageFromFile',
+         backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[[
+            dict(type='Resize', scale=s, keep_ratio=True) for s in img_scales
+        ], [
+            dict(type='RandomFlip', prob=1.),
+            dict(type='RandomFlip', prob=0.)
+        ], [
+            dict(
+               type='PackDetInputs',
+               meta_keys=('img_id', 'img_path', 'ori_shape',
+                       'img_shape', 'scale_factor', 'flip',
+                       'flip_direction'))
+       ]])]
+```
+
+以上数据增强管道将首先对图像执行 3 个多尺度转换，然后执行 2 个翻转转换（翻转和不翻转），最后使用 PackDetInputs 将图像打包到最终结果中。
+这里有更多的 TTA 使用案例供您参考：
+
+- [RetinaNet](../../../configs/retinanet/retinanet_tta.py)
+- [CenterNet](../../../configs/centernet/centernet_tta.py)
+- [YOLOX](../../../configs/rtmdet/rtmdet_tta.py)
+- [RTMDet](../../../configs/yolox/yolox_tta.py)
+
+更多高级用法和 TTA 的数据流，请参考 [MMEngine](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/test_time_augmentation.html#data-flow)。我们将在后续支持实例分割 TTA。
diff --git a/mmdetection/docs/zh_cn/user_guides/test_results_submission.md b/mmdetection/docs/zh_cn/user_guides/test_results_submission.md
new file mode 100644
index 00000000..7a076585
--- /dev/null
+++ b/mmdetection/docs/zh_cn/user_guides/test_results_submission.md
@@ -0,0 +1,174 @@
+# 提交测试结果
+
+## 全景分割测试结果提交
+
+下面几节介绍如何在 COCO 测试开发集上生成泛视分割模型的预测结果，并将预测提交到 [COCO评估服务器](https://competitions.codalab.org/competitions/19507)
+
+### 前提条件
+
+- 下载 [COCO测试数据集图像](http://images.cocodataset.org/zips/test2017.zip)，[测试图像信息](http://images.cocodataset.org/annotations/image_info_test2017.zip)，和[全景训练/相关注释](http://images.cocodataset.org/annotations/panoptic_annotations_trainval2017.zip)，然后解压缩它们，把 `test2017` 放到 `data/coco/`，把 json 文件和注释文件放到 `data/coco/annotations/` 。
+
+```shell
+# 假设 data/coco/ 不存在
+mkdir -pv data/coco/
+# 下载 test2017
+wget -P data/coco/ http://images.cocodataset.org/zips/test2017.zip
+wget -P data/coco/ http://images.cocodataset.org/annotations/image_info_test2017.zip
+wget -P data/coco/ http://images.cocodataset.org/annotations/panoptic_annotations_trainval2017.zip
+# 解压缩它们
+unzip data/coco/test2017.zip -d data/coco/
+unzip data/coco/image_info_test2017.zip -d data/coco/
+unzip data/coco/panoptic_annotations_trainval2017.zip -d data/coco/
+# 删除 zip 文件(可选)
+rm -rf data/coco/test2017.zip data/coco/image_info_test2017.zip data/coco/panoptic_annotations_trainval2017.zip
+```
+
+- 运行以下代码更新测试图像信息中的类别信息。由于 `image_info_test-dev2017.json` 的类别信息中缺少属性 `isthing` ，我们需要用 `panoptic_val2017.json` 中的类别信息更新它。
+
+```shell
+python tools/misc/gen_coco_panoptic_test_info.py data/coco/annotations
+```
+
+在完成上述准备之后，你的 `data` 目录结构应该是这样:
+
+```text
+data
+`-- coco
+    |-- annotations
+    |   |-- image_info_test-dev2017.json
+    |   |-- image_info_test2017.json
+    |   |-- panoptic_image_info_test-dev2017.json
+    |   |-- panoptic_train2017.json
+    |   |-- panoptic_train2017.zip
+    |   |-- panoptic_val2017.json
+    |   `-- panoptic_val2017.zip
+    `-- test2017
+```
+
+### coco 测试开发的推理
+
+要在 coco test-dev 上进行推断，我们应该首先更新 `test_dataloder` 和 `test_evaluator` 的设置。有两种方法可以做到这一点:1. 在配置文件中更新它们;2. 在命令行中更新它们。
+
+#### 在配置文件中更新它们
+
+相关的设置在 `configs/_base_/datasets/ coco_panoptical .py` 的末尾，如下所示。
+
+```python
+test_dataloader = dict(
+    batch_size=1,
+    num_workers=1,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='annotations/panoptic_image_info_test-dev2017.json',
+        data_prefix=dict(img='test2017/'),
+        test_mode=True,
+        pipeline=test_pipeline))
+test_evaluator = dict(
+    type='CocoPanopticMetric',
+    format_only=True,
+    ann_file=data_root + 'annotations/panoptic_image_info_test-dev2017.json',
+    outfile_prefix='./work_dirs/coco_panoptic/test')
+```
+
+以下任何一种方法都可以用于更新 coco test-dev 集上的推理设置
+
+情况1:直接取消注释 `configs/_base_/datasets/ coco_panoptical .py` 中的设置。
+
+情况2:将以下设置复制到您现在使用的配置文件中。
+
+```python
+test_dataloader = dict(
+    dataset=dict(
+        ann_file='annotations/panoptic_image_info_test-dev2017.json',
+        data_prefix=dict(img='test2017/', _delete_=True)))
+test_evaluator = dict(
+    format_only=True,
+    ann_file=data_root + 'annotations/panoptic_image_info_test-dev2017.json',
+    outfile_prefix='./work_dirs/coco_panoptic/test')
+```
+
+然后通过以下命令对 coco test-dev et 进行推断。
+
+```shell
+python tools/test.py \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE}
+```
+
+#### 在命令行中更新它们
+
+coco test-dev 上更新相关设置和推理的命令如下所示。
+
+```shell
+# 用一个 gpu 测试
+CUDA_VISIBLE_DEVICES=0 python tools/test.py \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    --cfg-options \
+    test_dataloader.dataset.ann_file=annotations/panoptic_image_info_test-dev2017.json \
+    test_dataloader.dataset.data_prefix.img=test2017 \
+    test_dataloader.dataset.data_prefix._delete_=True \
+    test_evaluator.format_only=True \
+    test_evaluator.ann_file=data/coco/annotations/panoptic_image_info_test-dev2017.json \
+    test_evaluator.outfile_prefix=${WORK_DIR}/results
+# 用四个 gpu 测试
+CUDA_VISIBLE_DEVICES=0,1,3,4 bash tools/dist_test.sh \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    8 \  # eights gpus
+    --cfg-options \
+    test_dataloader.dataset.ann_file=annotations/panoptic_image_info_test-dev2017.json \
+    test_dataloader.dataset.data_prefix.img=test2017 \
+    test_dataloader.dataset.data_prefix._delete_=True \
+    test_evaluator.format_only=True \
+    test_evaluator.ann_file=data/coco/annotations/panoptic_image_info_test-dev2017.json \
+    test_evaluator.outfile_prefix=${WORK_DIR}/results
+# 用 slurm 测试
+GPUS=8 tools/slurm_test.sh \
+    ${Partition} \
+    ${JOB_NAME} \
+    ${CONFIG_FILE} \
+    ${CHECKPOINT_FILE} \
+    --cfg-options \
+    test_dataloader.dataset.ann_file=annotations/panoptic_image_info_test-dev2017.json \
+    test_dataloader.dataset.data_prefix.img=test2017 \
+    test_dataloader.dataset.data_prefix._delete_=True \
+    test_evaluator.format_only=True \
+    test_evaluator.ann_file=data/coco/annotations/panoptic_image_info_test-dev2017.json \
+    test_evaluator.outfile_prefix=${WORK_DIR}/results
+```
+
+例子:假设我们使用预先训练的带有 ResNet-50 骨干网的 MaskFormer 对 `test2017` 执行推断。
+
+```shell
+# 单 gpu 测试
+CUDA_VISIBLE_DEVICES=0 python tools/test.py \
+    configs/maskformer/maskformer_r50_mstrain_16x1_75e_coco.py \
+    checkpoints/maskformer_r50_mstrain_16x1_75e_coco_20220221_141956-bc2699cb.pth \
+    --cfg-options \
+    test_dataloader.dataset.ann_file=annotations/panoptic_image_info_test-dev2017.json \
+    test_dataloader.dataset.data_prefix.img=test2017 \
+    test_dataloader.dataset.data_prefix._delete_=True \
+    test_evaluator.format_only=True \
+    test_evaluator.ann_file=data/coco/annotations/panoptic_image_info_test-dev2017.json \
+    test_evaluator.outfile_prefix=work_dirs/maskformer/results
+```
+
+### 重命名文件并压缩结果
+
+推理之后，全景分割结果(一个 json 文件和一个存储掩码的目录)将在 `WORK_DIR` 中。我们应该按照 [COCO's Website](https://cocodataset.org/#upload)上的命名约定重新命名它们。最后，我们需要将 json 和存储掩码的目录压缩到 zip 文件中，并根据命名约定重命名该 zip 文件。注意， zip 文件应该**直接**包含上述两个文件。
+
+重命名文件和压缩结果的命令:
+
+```shell
+# 在 WORK_DIR 中，我们有 panoptic 分割结果: 'panoptic' 和 'results. panoptical .json'。
+cd ${WORK_DIR}
+# 将 '[algorithm_name]' 替换为您使用的算法名称
+mv ./panoptic ./panoptic_test-dev2017_[algorithm_name]_results
+mv ./results.panoptic.json ./panoptic_test-dev2017_[algorithm_name]_results.json
+zip panoptic_test-dev2017_[algorithm_name]_results.zip -ur panoptic_test-dev2017_[algorithm_name]_results panoptic_test-dev2017_[algorithm_name]_results.json
+```
diff --git a/mmdetection/docs/zh_cn/user_guides/tracking_analysis_tools.md b/mmdetection/docs/zh_cn/user_guides/tracking_analysis_tools.md
new file mode 100644
index 00000000..5330af1d
--- /dev/null
+++ b/mmdetection/docs/zh_cn/user_guides/tracking_analysis_tools.md
@@ -0,0 +1,87 @@
+**我们在 `tools/` 目录下提供了很多有用的工具。**
+
+## MOT 测试时参数搜索
+
+`tools/analysis_tools/mot/mot_param_search.py` 可以搜索 MOT 模型中 `tracker` 的参数。
+它与 `tools/test.py` 的使用方式相同，但配置上**有所不同**。
+
+下面是修改配置的示例：
+
+1. 定义要记录的期望评估指标。
+
+   例如，你可以将 `evaluator` 定义为：
+
+   ```python
+   test_evaluator=dict(type='MOTChallengeMetrics', metric=['HOTA', 'CLEAR', 'Identity'])
+   ```
+
+   当然，你也可以自定义 `test_evaluator` 中 `metric` 的内容。你可以自由选择 `['HOTA', 'CLEAR', 'Identity']` 中的一个或多个指标。
+
+2. 定义要搜索的参数及其取值。
+
+   假设你有一个 `tracker` 的配置如下：
+
+   ```python
+   model=dict(
+       tracker=dict(
+           type='BaseTracker',
+           obj_score_thr=0.5,
+           match_iou_thr=0.5
+       )
+   )
+   ```
+
+   如果你想要搜索 `tracker` 的参数，只需将其值改为一个列表，如下所示：
+
+   ```python
+   model=dict(
+       tracker=dict(
+           type='BaseTracker',
+           obj_score_thr=[0.4, 0.5, 0.6],
+           match_iou_thr=[0.4, 0.5, 0.6, 0.7]
+       )
+   )
+   ```
+
+   然后，脚本将测试一共12种情况并且记录结果。
+
+## MOT 误差可视化
+
+`tools/analysis_tools/mot/mot_error_visualize.py` 可以为多目标跟踪可视化错误。
+
+该脚本需要推断的结果作为输入。默认情况下，**红色**边界框表示误检（false positive），**黄色**边界框表示漏检（false negative），**蓝色**边界框表示ID切换（ID switch）。
+
+```
+python tools/analysis_tools/mot/mot_error_visualize.py \
+    ${CONFIG_FILE}\
+    --input ${INPUT} \
+    --result-dir ${RESULT_DIR} \
+    [--output-dir ${OUTPUT}] \
+    [--fps ${FPS}] \
+    [--show] \
+    [--backend ${BACKEND}]
+```
+
+`RESULT_DIR` 中包含了所有视频的推断结果，推断结果是一个 `txt` 文件。
+
+可选参数：
+
+- `OUTPUT`：可视化演示的输出。如果未指定，`--show` 是必选的，用于即时显示视频。
+- `FPS`：输出视频的帧率。
+- `--show`：是否即时显示视频。
+- `BACKEND`：用于可视化边界框的后端。选项包括 `cv2` 和 `plt`。
+
+## 浏览数据集
+
+`tools/analysis_tools/mot/browse_dataset.py` 可以可视化训练数据集，以检查数据集配置是否正确。
+
+**示例：**
+
+```shell
+python tools/analysis_tools/browse_dataset.py ${CONFIG_FILE} [--show-interval ${SHOW_INTERVAL}]
+```
+
+可选参数：
+
+- `SHOW_INTERVAL`: 显示的间隔时间（秒）。
+- `--show`: 是否即时显示图像。
diff --git a/mmdetection/docs/zh_cn/user_guides/tracking_config.md b/mmdetection/docs/zh_cn/user_guides/tracking_config.md
new file mode 100644
index 00000000..4a20da77
--- /dev/null
+++ b/mmdetection/docs/zh_cn/user_guides/tracking_config.md
@@ -0,0 +1,109 @@
+# 学习更多与配置相关的事
+
+我们用 python 文档作为我们的配置系统。你可以在 `MMDetection/configs` 底下找到所有已提供的配置文件。
+
+我们把模块化和继承化设计融入我们的配置系统，这使我们很方便去进行各种实验。如果你想查看相关的配置文件，你可以跑 `python tools/misc/print_config.py /PATH/TO/CONFIG` 去看完整的详细配置。
+
+## 完整配置的简要说明
+
+一个完整的配置通常包含以下主要的字段：
+
+`model`：一个模型的基本配置，包含 `data_preprocessor`、`detector`、`motion` 之类的模块，还有 `train_cfg`、`test_cfg` 等等；
+
+`train_dataloader`：训练数据集的配置，通常包含 `batch_size`、 `num_workers`、 `sampler`、 `dataset` 等等；
+
+`val_dataloader`：验证数据集的配置，与训练数据集的配置类似；
+
+`test_dataloader`：测试数据集的配置，与训练数据集的配置类似；
+
+`val_evaluator`：验证评估器的配置，例如 `type='MOTChallengeMetrics'` 是 MOT 任务里面的测量标准；
+
+`test_evaluator`：测试评估器的配置，与验证评估器的配置类似；
+
+`train_cfg`：训练循环的配置，例如 `type='EpochBasedTrainLoop'` ；
+
+`val_cfg`：验证循环的配置，例如 `type='VideoValLoop'` ；
+
+`test_cfg`：测试循环的配置，例如 `type='VideoTestLoop'` ；
+
+`default_hooks`：默认鱼钩的配置，包含计时器、日志、参数调度程序、检查点、样本种子、可视化；
+
+`vis_backends`：可视化后端的配置，默认使用 `type='LocalVisBackend'` ；
+
+`visualizer`：可视化工具的配置，例如MOT任务使用 `type='TrackLocalVisualizer'` ；
+
+`param_scheduler`：参数调度程序的配置，通常里面设置学习率调度程序；
+
+`optim_wrapper`：优化器封装的配置，包含优化相关的信息，例如优化器、梯度剪裁等；
+
+`load_from`：加载预训练模型的路径；
+
+`resume`：布尔值，如果是 `True` ，会从 `load_from` 加载模型的检查点，训练会恢复至检查点的迭代次数。
+
+## 通过脚本参数修改配置
+
+当使用 `tools/train.py` 或 `tools/test_trackin.py` 执行任务时，可以指定 `--cfg-options` 来就地修改配置。我们举几个例子如下。有关更多详细信息，请参阅[MMEngine](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/config.html)。
+
+### 更新 dict 链的配置键
+
+可以按照原始配置中 `dict` 键的顺序指定配置选项，例如，设置 `--cfg-options model.detector.backbone.norm_eval=False` 会将模型主干中的所有 `BN` 模块更改为训练模式。
+
+### 更新配置列表中的关键字
+
+一些配置的 `dict` 关键字会以列表的形式组成，例如，测试管道中的 `test_dataloader.dataset.pipeline` 以列表形式出现，即 `[dict(type='LoadImageFromFile'), ...]`。如果你想在测试管道中将 `LoadImageFromFile` 更改为 `LoadImageFromWebcam`，可以设置 `--cfg-options test_dataloader.dataset.pipeline.0.type=LoadImageFromWebcam`。
+
+### 更新列表/元组的值
+
+要被更新的可能是一个列表或一个元组，例如，你可以通过指定 `--cfg options model.data_processor.mean=[0,0,0]` 来更改 `data_preprocessor` 的平均值的关键字。请注意，指定值内不允许有空格。
+
+## 配置文件结构
+
+`config/_base_` 下有三种基本组件类型，即数据集、模型和默认运行时间。可以用它们来轻松构建许多方法，例如 `SORT`，`DeepSORT`。由 `_base_` 中的组件组成的配置称为基元。
+
+对于同一文件夹下的配置文件，建议只有一个基元配置文件。其他配置文件都应该从基元配置文件继承基本结构，这样，继承级别的最大值为 3。
+
+为了便于理解，我们建议贡献者继承现有的方法。例如，如果在 `Faster R-CNN` 的基础上进行了一些修改，用户可以首先通过指定 `_base_ = ../_base_/models/faster-rcnn_r50-dc5.py` 来继承基本的 `Faster R-CNN` 结构，然后修改配置文件中的必要字段。
+
+如果你正在构建一个与任何现有方法都不共享结构的全新方法，则可以在 `configs` 下创建一个新文件夹 method_name。
+
+有关详细文档，请参阅[MMEngine](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/config.html)。
+
+## 配置命名风格
+
+我们根据以下风格去命名配置文件，建议贡献者遵从相同风格。
+
+`{method}_{module}_{train_cfg}_{train_data}_{test_data}`
+
+`{method}`: 方法名称，例如 `sort`；
+
+`{module}`: 方法的基本模块，例如 `faster-rcnn_r50_fpn`；
+
+`{train_cfg}`: 训练配置通常包含批量大小、迭代次数等，例如 `8xb4-80e`；
+
+`{train_data}`: 训练数据集，例如 `mot17halftrain`；
+
+`{test_data}`: 测试数据集，例如 `test-mot17halfval`。
+
+## 常问问题
+
+### 忽略基本配置中的某些字段
+
+有时候你可以设置 `_delete_=True` 去忽略基本配置中的一些字段，你可以参考[MMEngine](https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/config.html)进行简单说明。
+
+### 跟踪数据结构介绍
+
+#### 优点和新功能
+
+在 `mmdetection` 跟踪任务中，我们使用视频来组织数据集，并使用 `TrackDataSample` 来描述数据集信息。
+
+基于视频组织，我们提供了 `transform UniformRefFrameSample` 来对关键帧和参考帧进行采样，并使用 `TransformBroadcaster` 进行剪辑训练。
+
+在某种程度上，`TrackDataSample` 可以被视为多个 `DetDataSample` 的包装器。它包含一个 `video_data_samples`，这是一个以 `DetDataSample` 组成的列表，里面每个 `DetDataSample` 对应一个帧。此外，它的元信息包括关键帧的索引和参考帧的索引，用与剪辑训练。
+
+得益于基于视频的数据组织，整个视频可以直接被测试。这种方式更简洁直观。如果你的 GPU 内存无法容纳整个视频，我们还提供基于图像的测试方法。
+
+## 要做的事
+
+`StrongSORT`、`Mask2Former` 等算法不支持基于视频的测试，这些算法对 GPU 内存提出了挑战，我们将来会优化这个问题。
+
+现在，我们不支持像 `MOT Challenge dataset` 这样的基于视频的数据集和像 `Crowdhuman` 用于 `QDTrack` 算法这样的基于图像的数据集进行联合训练。我们将来会优化这个问题。
diff --git a/mmdetection/docs/zh_cn/user_guides/tracking_dataset_prepare.md b/mmdetection/docs/zh_cn/user_guides/tracking_dataset_prepare.md
new file mode 100644
index 00000000..0db495b5
--- /dev/null
+++ b/mmdetection/docs/zh_cn/user_guides/tracking_dataset_prepare.md
@@ -0,0 +1,245 @@
+## 数据集准备
+
+本页面提供了现有基准数据集的准备说明，包括：
+
+- 多目标跟踪
+
+  - [MOT Challenge](https://motchallenge.net/)
+  - [CrowdHuman](https://www.crowdhuman.org/)
+
+- 视频实例分割
+
+  - [YouTube-VIS](https://youtube-vos.org/dataset/vis/)
+
+### 1. 下载数据集
+
+请从官方网站下载数据集，并将数据集的根目录建立软链接到 `$MMDETECTION/data` 目录下。
+
+#### 1.1 多目标跟踪
+
+- 对于多目标跟踪任务的训练和测试，需要下载MOT Challenge数据集之一（例如MOT17、MOT20），CrowdHuman数据集可以作为补充数据集。
+
+- 对于中国的用户，可以从 [OpenDataLab](https://opendatalab.com/) 上高速下载如下数据集：
+
+  - [MOT17](https://opendatalab.com/MOT17/download)
+  - [MOT20](https://opendatalab.com/MOT20/download)
+  - [CrowdHuman](https://opendatalab.com/CrowdHuman/download)
+
+#### 1.2 视频实例分割
+
+- 对于视频实例分割任务的训练和测试，只需要选择一个YouTube-VIS数据集（例如YouTube-VIS 2019、YouTube-VIS 2021）即可。
+- 可以从 [YouTubeVOS](https://codalab.lisn.upsaclay.fr/competitions/6064) 上下载YouTube-VIS 2019数据集。
+- 可以从 [YouTubeVOS](https://codalab.lisn.upsaclay.fr/competitions/7680) 上下载YouTube-VIS 2021数据集。
+
+#### 1.3 数据结构
+
+如果您的文件夹结构与以下结构不同，则可能需要在配置文件中更改相应的路径。
+
+```
+mmdetection
+├── mmdet
+├── tools
+├── configs
+├── data
+│   ├── coco
+│   │   ├── train2017
+│   │   ├── val2017
+│   │   ├── test2017
+│   │   ├── annotations
+│   │
+|   ├── MOT15/MOT16/MOT17/MOT20
+|   |   ├── train
+|   |   |   ├── MOT17-02-DPM
+|   |   |   |   ├── det
+|   │   │   │   ├── gt
+|   │   │   │   ├── img1
+|   │   │   │   ├── seqinfo.ini
+│   │   │   ├── ......
+|   |   ├── test
+|   |   |   ├── MOT17-01-DPM
+|   |   |   |   ├── det
+|   │   │   │   ├── img1
+|   │   │   │   ├── seqinfo.ini
+│   │   │   ├── ......
+│   │
+│   ├── crowdhuman
+│   │   ├── annotation_train.odgt
+│   │   ├── annotation_val.odgt
+│   │   ├── train
+│   │   │   ├── Images
+│   │   │   ├── CrowdHuman_train01.zip
+│   │   │   ├── CrowdHuman_train02.zip
+│   │   │   ├── CrowdHuman_train03.zip
+│   │   ├── val
+│   │   │   ├── Images
+│   │   │   ├── CrowdHuman_val.zip
+│   │
+```
+
+### 2. 转换注释
+
+在这种情况下，您需要将官方注释（Annotations）转换为COCO格式。我们提供了相应的脚本，使用方法如下：
+
+```shell
+# MOT17
+# 其他 MOT Challenge 数据集的处理方式与 MOT17 相同。
+python ./tools/dataset_converters/mot2coco.py -i ./data/MOT17/ -o ./data/MOT17/annotations --split-train --convert-det
+python ./tools/dataset_converters/mot2reid.py -i ./data/MOT17/ -o ./data/MOT17/reid --val-split 0.2 --vis-threshold 0.3
+
+# CrowdHuman
+python ./tools/dataset_converters/crowdhuman2coco.py -i ./data/crowdhuman -o ./data/crowdhuman/annotations
+
+# YouTube-VIS 2019
+python ./tools/dataset_converters/youtubevis2coco.py -i ./data/youtube_vis_2019 -o ./data/youtube_vis_2019/annotations --version 2019
+
+# YouTube-VIS 2021
+python ./tools/dataset_converters/youtubevis2coco.py -i ./data/youtube_vis_2021 -o ./data/youtube_vis_2021/annotations --version 2021
+
+```
+
+运行这些脚本后，文件夹结构将如下所示：
+
+```
+mmdetection
+├── mmtrack
+├── tools
+├── configs
+├── data
+│   ├── coco
+│   │   ├── train2017
+│   │   ├── val2017
+│   │   ├── test2017
+│   │   ├── annotations
+│   │
+|   ├── MOT15/MOT16/MOT17/MOT20
+|   |   ├── train
+|   |   |   ├── MOT17-02-DPM
+|   |   |   |   ├── det
+|   │   │   │   ├── gt
+|   │   │   │   ├── img1
+|   │   │   │   ├── seqinfo.ini
+│   │   │   ├── ......
+|   |   ├── test
+|   |   |   ├── MOT17-01-DPM
+|   |   |   |   ├── det
+|   │   │   │   ├── img1
+|   │   │   │   ├── seqinfo.ini
+│   │   │   ├── ......
+|   |   ├── annotations
+|   |   ├── reid
+│   │   │   ├── imgs
+│   │   │   ├── meta
+│   │
+│   ├── crowdhuman
+│   │   ├── annotation_train.odgt
+│   │   ├── annotation_val.odgt
+│   │   ├── train
+│   │   │   ├── Images
+│   │   │   ├── CrowdHuman_train01.zip
+│   │   │   ├── CrowdHuman_train02.zip
+│   │   │   ├── CrowdHuman_train03.zip
+│   │   ├── val
+│   │   │   ├── Images
+│   │   │   ├── CrowdHuman_val.zip
+│   │   ├── annotations
+│   │   │   ├── crowdhuman_train.json
+│   │   │   ├── crowdhuman_val.json
+│   │
+│   ├── youtube_vis_2019
+│   │   │── train
+│   │   │   │── JPEGImages
+│   │   │   │── ......
+│   │   │── valid
+│   │   │   │── JPEGImages
+│   │   │   │── ......
+│   │   │── test
+│   │   │   │── JPEGImages
+│   │   │   │── ......
+│   │   │── train.json (the official annotation files)
+│   │   │── valid.json (the official annotation files)
+│   │   │── test.json (the official annotation files)
+│   │   │── annotations (the converted annotation file)
+│   │
+│   ├── youtube_vis_2021
+│   │   │── train
+│   │   │   │── JPEGImages
+│   │   │   │── instances.json (the official annotation files)
+│   │   │   │── ......
+│   │   │── valid
+│   │   │   │── JPEGImages
+│   │   │   │── instances.json (the official annotation files)
+│   │   │   │── ......
+│   │   │── test
+│   │   │   │── JPEGImages
+│   │   │   │── instances.json (the official annotation files)
+│   │   │   │── ......
+│   │   │── annotations (the converted annotation file)
+```
+
+#### MOT15/MOT16/MOT17/MOT20中的注释和reid文件夹
+
+以 MOT17 数据集为例，其他数据集的结构类似。
+
+在 `data/MOT17/annotations` 文件夹中有8个JSON文件：
+
+`train_cocoformat.json`: 包含MOT17数据集训练集的注释信息的JSON文件。
+
+`train_detections.pkl`: 包含MOT17数据集训练集的公共检测结果的Pickle文件。
+
+`test_cocoformat.json`: 包含MOT17数据集测试集的注释信息的JSON文件。
+
+`test_detections.pkl`: 包含MOT17数据集测试集的公共检测结果的Pickle文件。
+
+`half-train_cocoformat.json`、`half-train_detections.pkl`、`half-val_cocoformat.json` 和 `half-val_detections.pkl` 与 `train_cocoformat.json` 和 `train_detections.pkl` 具有类似的含义。`half` 表示将训练集中的每个视频分成两半。前一半的视频被标记为 `half-train` 集，后一半的视频被标记为 `half-val` 集。
+
+`data/MOT17/reid` 文件夹的结构如下所示：
+
+```
+reid
+├── imgs
+│   ├── MOT17-02-FRCNN_000002
+│   │   ├── 000000.jpg
+│   │   ├── 000001.jpg
+│   │   ├── ...
+│   ├── MOT17-02-FRCNN_000003
+│   │   ├── 000000.jpg
+│   │   ├── 000001.jpg
+│   │   ├── ...
+├── meta
+│   ├── train_80.txt
+│   ├── val_20.txt
+```
+
+`train_80.txt` 中的 `80` 表示训练数据集在整个ReID数据集中的比例为80%。而验证数据集的比例为20%。
+
+关于训练，我们提供了一个注释列表 `train_80.txt`。列表中的每一行包含一个文件名及其对应的真实标签。格式如下所示：
+
+```
+MOT17-05-FRCNN_000110/000018.jpg 0
+MOT17-13-FRCNN_000146/000014.jpg 1
+MOT17-05-FRCNN_000088/000004.jpg 2
+MOT17-02-FRCNN_000009/000081.jpg 3
+```
+
+`MOT17-05-FRCNN_000110` 表示 `MOT17-05-FRCNN` 视频中的第110个人。
+
+对于验证集，注释列表 `val_20.txt` 的格式与上述相同。
+
+`reid/imgs` 中的图像是通过相应的 `gt.txt` 从 `MOT17/train` 中的原始图像中裁剪而来。真实标签的值应在 `[0, num_classes - 1]` 的范围内。
+
+#### CrowdHuman 中的 annotations 文件夹
+
+`data/crowdhuman/annotations` 文件夹下有两个JSON文件：
+
+`crowdhuman_train.json`：包含 CrowdHuman 数据集训练集的注释信息的JSON文件。
+`crowdhuman_val.json`：包含 CrowdHuman 数据集验证集的注释信息的JSON文件。
+
+#### youtube_vis_2019/youtube_vis2021 中的 annotations 文件夹
+
+There are 3 JSON files in `data/youtube_vis_2019/annotations` or `data/youtube_vis_2021/annotations`：
+
+`youtube_vis_2019_train.json`/`youtube_vis_2021_train.json`：包含 youtube_vis_2019/youtube_vis2021 数据集训练集的注释信息的JSON文件。
+
+`youtube_vis_2019_valid.json`/`youtube_vis_2021_valid.json`：包含 youtube_vis_2019/youtube_vis2021 数据集验证集的注释信息的JSON文件。
+
+`youtube_vis_2019_test.json`/`youtube_vis_2021_test.json`：包含 youtube_vis_2019/youtube_vis2021 数据集测试集的注释信息的JSON文件。
diff --git a/mmdetection/docs/zh_cn/user_guides/tracking_interference.md b/mmdetection/docs/zh_cn/user_guides/tracking_interference.md
new file mode 100644
index 00000000..1b1fc08a
--- /dev/null
+++ b/mmdetection/docs/zh_cn/user_guides/tracking_interference.md
@@ -0,0 +1,55 @@
+# 推理
+
+我们提供了一些演示脚本去推理一个给出的视频，或者是推理包含一系列连续照片的文件夹。想要获取该代码资源，请点击 [这里](https://github.com/open-mmlab/mmdetection/tree/tracking/demo)。
+
+若输入为文件夹格式，你需要标明这点。并且，图片命名应该**易于整理**，以便于你根据文件名字中包含的数字信息来重新调整图片的顺序。我们现在只支持 `.jpg`，`.jpeg` 和 `.png` 格式的图片。
+
+## MOT models 的推理
+
+该脚本能够使用多任务跟踪或者视频实例分割方法来推理一段输入的视频/一张图片。
+
+```shell
+python demo/mot_demo.py \
+    ${INPUTS}
+    ${CONFIG_FILE} \
+    [--checkpoint ${CHECKPOINT_FILE}] \
+    [--detector ${DETECTOR_FILE}] \
+    [--reid ${REID_FILE}] \
+    [--score-thr ${SCORE_THR}] \
+    [--device ${DEVICE}] \
+    [--out ${OUTPUT}] \
+    [--show]
+```
+
+`INPUTS` 和 `OUTPUT` 参数支持 _mp4 视频_ 格式和_文件夹_格式。
+
+**特别注意**：对于 `DeepSORT`、`SORT`、`StrongSORT`，他们需要单独加载 `reid` 和 `detector` 的权重。因此，我们会使用 `--detector` 和 `--reid` 来加载权重参数。其他的例如 `ByteTrack`、`OCSORT`、`QDTrack`、`MaskTrackRCNN` 以及 `Mask2Former` 这样的算法则使用 `--checkpoint` 来加载权重参数。
+
+可选参数：
+
+- `CHECKPOINT_FILE`： 可选择 checkpoint。
+- `DETECTOR_FILE`： 可选择 detector。
+- `REID_FILE`： 可选择 reid。
+- `SCORE_THR`： bboxes 的得分阈值。
+- `DEVICE`： 推理所需配置。可以选择 `cpu`，`cuda:0`,或者其他。
+- `OUTPUT`： 输出结果可视化的示例。如果未指定， `--show` 将强制显示动态视频。
+- `--show`： 是否即时显示视频。
+
+**运行 mot model 的示例:**
+
+```shell
+# 示例 1：不指定 --checkpoint 使用 --detector
+python demo/mot_demo.py \
+    demo/demo_mot.mp4 \
+    configs/sort/sort_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py \
+    --detector \
+    https://download.openmmlab.com/mmtracking/mot/faster_rcnn/faster-rcnn_r50_fpn_4e_mot17-half-64ee2ed4.pth \
+    --out mot.mp4
+
+# 示例 2：使用 --checkpoint
+python demo/mot_demo.py \
+    demo/demo_mot.mp4 \
+    configs/qdtrack/qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py \
+    --checkpoint https://download.openmmlab.com/mmtracking/mot/qdtrack/mot_dataset/qdtrack_faster-rcnn_r50_fpn_4e_mot17_20220315_145635-76f295ef.pth \
+    --out mot.mp4
+```
diff --git a/mmdetection/docs/zh_cn/user_guides/tracking_train_test_zh_cn.md b/mmdetection/docs/zh_cn/user_guides/tracking_train_test_zh_cn.md
new file mode 100644
index 00000000..0542b9af
--- /dev/null
+++ b/mmdetection/docs/zh_cn/user_guides/tracking_train_test_zh_cn.md
@@ -0,0 +1,229 @@
+# 学习训练和测试
+
+## 训练
+
+本节将介绍如何在支持的数据集上训练现有模型。
+支持以下训练环境：
+
+- CPU
+- 单 GPU
+- 单节点多 GPU
+- 多节点
+
+您还可以使用 Slurm 管理作业。
+
+重要：
+
+- 在训练过程中，您可以通过修改 `train_cfg` 来改变评估间隔。
+  `train_cfg = dict(val_interval=10)`。这意味着每 10 个 epoch 对模型进行一次评估。
+- 所有配置文件中的默认学习率为 8 个 GPU。
+  根据[线性扩展规则](https://arxiv.org/abs/1706.02677)、
+  如果在每个 GPU 上使用不同的 GPU 或图像，则需要设置与批次大小成比例的学习率、
+  例如，8 个 GPU * 1 个图像/GPU 的学习率为 `lr=0.01`，16 个 GPU * 2 个图像/GPU 的学习率为 lr=0.04。
+- 在训练过程中，日志文件和检查点将保存到工作目录、
+  该目录由 CLI 参数 `--work-dir`指定。它默认使用 `./work_dirs/CONFIG_NAME`。
+- 如果需要混合精度训练，只需指定 CLI 参数 `--amp`。
+
+#### 1.在 CPU 上训练
+
+该模型默认放在 cuda 设备上。
+仅当没有 cuda 设备时，该模型才会放在 CPU 上。
+因此，如果要在 CPU 上训练模型，则需要先 `export CUDA_VISIBLE_DEVICES=-1` 以禁用 GPU 可见性。
+更多细节参见 [MMEngine](https://github.com/open-mmlab/mmengine/blob/ca282aee9e402104b644494ca491f73d93a9544f/mmengine/runner/runner.py#L849-L850).
+
+```shell 脚本
+CUDA_VISIBLE_DEVICES=-1 python tools/train.py ${CONFIG_FILE} [optional arguments]
+```
+
+在 CPU 上训练 MOT 模型 QDTrack 的示例：
+
+```shell 脚本
+CUDA_VISIBLE_DEVICES=-1 python tools/train.py configs/qdtrack/qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py
+```
+
+#### 2. 在单 GPU 上训练
+
+如果您想在单 GPU 上训练模型, 您可以按照如下方法直接使用 `tools/train.py`.
+
+```shell 脚本
+python tools/train.py ${CONFIG_FILE} [optional arguments]
+```
+
+您可以使用 `export CUDA_VISIBLE_DEVICES=$GPU_ID` 命令选择GPU.
+
+在单 GPU 上训练 MOT 模型 QDTrack 的示例：
+
+```shell 脚本
+CUDA_VISIBLE_DEVICES=2 python tools/train.py configs/qdtrack/qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py
+```
+
+#### 3. 在单节点多 GPU 上进行训练
+
+我们提供了 `tools/dist_train.sh`，用于在多个 GPU 上启动训练。
+基本用法如下。
+
+```shell 脚本
+bash ./tools/dist_train.sh ${CONFIG_FILE} ${GPU_NUM} [optional arguments]
+```
+
+如果您想在一台机器上启动多个作业、
+例如，在拥有 8 个 GPU 的机器上启动 2 个 4-GPU 训练作业、
+需要为每个作业指定不同的端口（默认为 29500），以避免通信冲突。
+
+例如，可以在命令中设置端口如下。
+
+```shell 脚本
+CUDA_VISIBLE_DEVICES=0,1,2,3 PORT=29500 ./tools/dist_train.sh ${CONFIG_FILE} 4
+CUDA_VISIBLE_DEVICES=4,5,6,7 PORT=29501 ./tools/dist_train.sh ${CONFIG_FILE} 4
+```
+
+在单节点多 GPU 上训练 MOT 模型 QDTrack 的示例：
+
+```shell脚本
+bash ./tools/dist_train.sh configs/qdtrack/qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py 8
+```
+
+#### 4. 在多个节点上训练
+
+如果使用以太网连接多台机器，只需运行以下命令即可：
+
+在第一台机器上
+
+```shell 脚本
+NNODES=2 NODE_RANK=0 PORT=$MASTER_PORT MASTER_ADDR=$MASTER_ADDR bash tools/dist_train.sh $CONFIG $GPUS
+```
+
+在第二台机器上:
+
+```shell script
+NNODES=2 NODE_RANK=1 PORT=$MASTER_PORT MASTER_ADDR=$MASTER_ADDR bash tools/dist_train.sh $CONFIG $GPUS
+```
+
+如果没有 InfiniBand 等高速网络，速度通常会很慢。
+
+#### 5. 使用 Slurm 进行训练
+
+[Slurm](https://slurm.schedmd.com/)是一个用于计算集群的优秀作业调度系统。
+在 Slurm 管理的集群上，您可以使用 `slurm_train.sh` 生成训练作业。
+它支持单节点和多节点训练。
+
+基本用法如下。
+
+```shell 脚本
+bash ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} ${CONFIG_FILE} ${WORK_DIR} ${GPUS}
+```
+
+使用 Slurm 训练 MOT 模型 QDTrack 的示例：
+
+```shell脚本
+PORT=29501 \
+GPUS_PER_NODE=8 \
+SRUN_ARGS="--quotatype=reserved" \
+bash ./tools/slurm_train.sh \
+mypartition \
+mottrack
+configs/qdtrack/qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py
+./work_dirs/QDTrack \
+8
+```
+
+## 测试
+
+本节将介绍如何在支持的数据集上测试现有模型。
+支持以下测试环境：
+
+- CPU
+- 单 GPU
+- 单节点多 GPU
+- 多节点
+
+您还可以使用 Slurm 管理作业。
+
+重要：
+
+- 在 MOT 中，某些算法（如 `DeepSORT`、`SORT`、`StrongSORT`）需要分别加载 `reid` 的权重和 `detector` 的权重。
+  其他算法，如`ByteTrack`、`OCSORT`和`QDTrack`则不需要。因此，我们提供了 `--checkpoint`、`--detector` 和 `--reid`来加载权重。
+- 我们提供了两种评估和测试模型的方法，即基于视频的测试和基于图像的测试。 有些算法如 `StrongSORT`, `Mask2former` 只支持基于视频的测试. 如果您的 GPU 内存无法容纳整个视频，您可以通过设置采样器类型来切换测试方式。
+  例如
+  基于视频的测试：`sampler=dict(type='DefaultSampler', shuffle=False, round_up=False)`
+  基于图像的测试：`sampler=dict（type='TrackImgSampler'）`
+- 您可以通过修改 evaluator 中的关键字 `outfile_prefix` 来设置结果保存路径。
+  例如，`val_evaluator = dict(outfile_prefix='results/sort_mot17')`。
+  否则，将创建一个临时文件，并在评估后删除。
+- 如果您只想要格式化的结果而不需要评估，可以设置 `format_only=True`。
+  例如，`test_evaluator = dict(type='MOTChallengeMetric', metric=['HOTA', 'CLEAR', 'Identity'], outfile_prefix='sort_mot17_results', format_only=True)`
+
+#### 1. 在 CPU 上测试
+
+模型默认在 cuda 设备上运行。
+只有在没有 cuda 设备的情况下，模型才会在 CPU 上运行。
+因此，如果要在 CPU 上测试模型，您需要 `export CUDA_VISIBLE_DEVICES=-1` 先禁用 GPU 可见性。
+
+更多细节请参考[MMEngine](https://github.com/open-mmlab/mmengine/blob/ca282aee9e402104b644494ca491f73d93a9544f/mmengine/runner/runner.py#L849-L850).
+
+```shell 脚本
+CUDA_VISIBLE_DEVICES=-1 python tools/test_tracking.py ${CONFIG_FILE} [optional arguments]
+```
+
+在 CPU 上测试 MOT 模型 SORT 的示例：
+
+```shell 脚本
+CUDA_VISIBLE_DEVICES=-1 python tools/test_tracking.py configs/sort/sort_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py --detector ${CHECKPOINT_FILE}
+```
+
+#### 2. 在单 GPU 上测试
+
+如果您想在单 GPU 上测试模型，可以直接使用 `tools/test_tracking.py`，如下所示。
+
+```shell 脚本
+python tools/test_tracking.py ${CONFIG_FILE} [optional arguments]
+```
+
+您可以使用 `export CUDA_VISIBLE_DEVICES=$GPU_ID` 来选择 GPU。
+
+在单 GPU 上测试 MOT 模型 QDTrack 的示例：
+
+```shell 脚本
+CUDA_VISIBLE_DEVICES=2 python tools/test_tracking.py configs/qdtrack/qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py --detector ${CHECKPOINT_FILE}
+```
+
+#### 3. 在单节点多 GPU 上进行测试
+
+我们提供了 `tools/dist_test_tracking.sh`，用于在多个 GPU 上启动测试。
+基本用法如下。
+
+```shell 脚本
+bash ./tools/dist_test_tracking.sh ${CONFIG_FILE} ${GPU_NUM} [optional arguments]
+```
+
+在单节点多 GPU 上测试 MOT 模型 DeepSort 的示例：
+
+```shell 脚本
+bash ./tools/dist_test_tracking.sh configs/qdtrack/qdtrack_faster-rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py 8 --detector ${CHECKPOINT_FILE} --reid ${CHECKPOINT_FILE}
+```
+
+#### 4. 在多个节点上测试
+
+您可以在多个节点上进行测试，这与 "在多个节点上进行训练 "类似。
+
+#### 5. 使用 Slurm 进行测试
+
+在 Slurm 管理的集群上，您可以使用 `slurm_test_tracking.sh` 生成测试作业。
+它支持单节点和多节点测试。
+
+基本用法如下。
+
+```shell 脚本
+[GPUS=${GPUS}] bash tools/slurm_test_tracking.sh ${PARTITION} ${JOB_NAME} ${CONFIG_FILE} [optional arguments]
+```
+
+使用 Slurm 测试 VIS 模型 Mask2former 的示例：
+
+```shell 脚本
+GPUS=8
+bash tools/slurm_test_tracking.sh \
+mypartition \
+vis \
+configs/mask2former_vis/mask2former_r50_8xb2-8e_youtubevis2021.py \
+--checkpoint ${CHECKPOINT_FILE}
+```
diff --git a/mmdetection/docs/zh_cn/user_guides/tracking_visualization.md b/mmdetection/docs/zh_cn/user_guides/tracking_visualization.md
new file mode 100644
index 00000000..0d10952a
--- /dev/null
+++ b/mmdetection/docs/zh_cn/user_guides/tracking_visualization.md
@@ -0,0 +1,51 @@
+# 了解可视化
+
+## 本地的可视化
+
+这一节将会展示如何使用本地的工具可视化 detection/tracking 的运行结果。
+
+如果你想要画出预测结果的图像，你可以如下示例，将 `TrackVisualizationHook` 中的 draw 的参数设置为 `draw=True`。
+
+```shell
+default_hooks = dict(visualization=dict(type='TrackVisualizationHook', draw=True))
+```
+
+`TrackVisualizationHook` 共有如下参数：
+
+- `draw`： 是否绘制预测结果。如果选择 False，将不会显示图像。该参数默认设置为 False。
+- `interval`： 可视化的间隔。默认值为 30。
+- `score_thr`： 确定是否可视化边界框和掩码的阈值。默认值是 0.3。
+- `show`： 是否展示绘制的图像。默认不显示。
+- `wait_time`： 展示的时间间隔(秒)。默认为 0。
+- `test_out_dir`： 测试过程中绘制图像保存的目录。
+- `backend_args`： 用于实例化文件客户端的参数。默认值为 `None `。
+
+在 `TrackVisualizationHook` 中，将调用 `TrackLocalVisualizer` 来实现 MOT 和 VIS 任务的可视化。具体细节如下。
+
+你可以通过 MMEngine 获取  [Visualization](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/advanced_tutorials/visualization.md) 和  [Hook](https://github.com/open-mmlab/mmengine/blob/main/docs/zh_cn/tutorials/hook.md) 的更多细节。
+
+### Tracking 的可视化
+
+我们使用 `TrackLocalVisualizer` 这个类以实现跟踪任务可视化。调用方式如下：
+
+```python
+visualizer = dict(type='TrackLocalVisualizer')
+```
+
+visualizer 共有如下的参数：
+
+- `name`： 所选实例的名称。默认值为 ‘visualizer’。
+
+- `image`： 用于绘制的原始图像。格式需要为 RGB。默认为 None。
+
+- `vis_backends`： 可视化后端配置列表。默认为 None。
+
+- `save_dir`： 所有后端存储的保存文件目录。如果为 None，后端将不会保存任何数据。
+
+- `line_width`： 边框宽度。默认值为 3。
+
+- `alpha`： 边界框和掩码的透明度。默认为 0.8。
+
+这里提供了一个 DeepSORT 的可视化示例：
+
+![test_img_89](https://user-images.githubusercontent.com/99722489/186062929-6d0e4663-0d8e-4045-9ec8-67e0e41da876.png)
diff --git a/mmdetection/docs/zh_cn/user_guides/train.md b/mmdetection/docs/zh_cn/user_guides/train.md
new file mode 100644
index 00000000..8feb1aa6
--- /dev/null
+++ b/mmdetection/docs/zh_cn/user_guides/train.md
@@ -0,0 +1,451 @@
+# 在标准数据集上训练预定义的模型
+
+MMDetection 也为训练检测模型提供了开盖即食的工具。本节将展示在标准数据集（比如 COCO）上如何训练一个预定义的模型。
+
+### 数据集
+
+训练需要准备好数据集，细节请参考 [数据集准备](#%E6%95%B0%E6%8D%AE%E9%9B%86%E5%87%86%E5%A4%87) 。
+
+**注意**：
+目前，`configs/cityscapes` 文件夹下的配置文件都是使用 COCO 预训练权值进行初始化的。如果网络连接不可用或者速度很慢，你可以提前下载现存的模型。否则可能在训练的开始会有错误发生。
+
+### 学习率自动缩放
+
+**注意**：在配置文件中的学习率是在 8 块 GPU，每块 GPU 有 2 张图像（批大小为 8\*2=16）的情况下设置的。其已经设置在 `config/_base_/schedules/schedule_1x.py` 中的 `auto_scale_lr.base_batch_size`。学习率会基于批次大小为 `16`时的值进行自动缩放。同时，为了不影响其他基于 mmdet 的 codebase，启用自动缩放标志 `auto_scale_lr.enable` 默认设置为 `False`。
+
+如果要启用此功能，需在命令添加参数 `--auto-scale-lr`。并且在启动命令之前，请检查下即将使用的配置文件的名称，因为配置名称指示默认的批处理大小。
+在默认情况下，批次大小是 `8 x 2 = 16`，例如：`faster_rcnn_r50_caffe_fpn_90k_coco.py` 或者 `pisa_faster_rcnn_x101_32x4d_fpn_1x_coco.py`；若不是默认批次，你可以在配置文件看到像 `_NxM_` 字样的，例如：`cornernet_hourglass104_mstest_32x3_210e_coco.py` 的批次大小是 `32 x 3 = 96`, 或者 `scnet_x101_64x4d_fpn_8x1_20e_coco.py` 的批次大小是 `8 x 1 = 8`。
+
+**请记住：如果使用不是默认批次大小为 `16`的配置文件，请检查配置文件中的底部，会有 `auto_scale_lr.base_batch_size`。如果找不到，可以在其继承的 `_base_=[xxx]` 文件中找到。另外，如果想使用自动缩放学习率的功能，请不要修改这些值。**
+
+学习率自动缩放基本用法如下：
+
+```shell
+python tools/train.py \
+    ${CONFIG_FILE} \
+    --auto-scale-lr \
+    [optional arguments]
+```
+
+执行命令之后，会根据机器的GPU数量和训练的批次大小对学习率进行自动缩放，缩放方式详见 [线性扩展规则](https://arxiv.org/abs/1706.02677) ，比如：在 4 块 GPU 并且每张 GPU 上有 2 张图片的情况下 `lr=0.01`，那么在 16 块 GPU 并且每张 GPU 上有 4 张图片的情况下, LR 会自动缩放至 `lr=0.08`。
+
+如果不启用该功能，则需要根据 [线性扩展规则](https://arxiv.org/abs/1706.02677) 来手动计算并修改配置文件里面 `optimizer.lr` 的值。
+
+### 使用单 GPU 训练
+
+我们提供了 `tools/train.py` 来开启在单张 GPU 上的训练任务。基本使用如下：
+
+```shell
+python tools/train.py \
+    ${CONFIG_FILE} \
+    [optional arguments]
+```
+
+在训练期间，日志文件和 checkpoint 文件将会被保存在工作目录下，它需要通过配置文件中的 `work_dir` 或者 CLI 参数中的 `--work-dir` 来指定。
+
+默认情况下，模型将在每轮训练之后在 validation 集上进行测试，测试的频率可以通过设置配置文件来指定：
+
+```python
+# 每 12 轮迭代进行一次测试评估
+train_cfg = dict(val_interval=12)
+```
+
+这个工具接受以下参数：
+
+- `--work-dir ${WORK_DIR}`: 覆盖工作目录.
+- `--resume`：自动从work_dir中的最新检查点恢复.
+- `--resume ${CHECKPOINT_FILE}`: 从某个 checkpoint 文件继续训练.
+- `--cfg-options 'Key=value'`: 覆盖使用的配置文件中的其他设置.
+
+**注意**：
+`resume` 和 `load-from` 的区别：
+
+`resume` 既加载了模型的权重和优化器的状态，也会继承指定 checkpoint 的迭代次数，不会重新开始训练。`load-from` 则是只加载模型的权重，它的训练是从头开始的，经常被用于微调模型。其中load-from需要写入配置文件中，而resume作为命令行参数传入。
+
+### 使用 CPU 训练
+
+使用 CPU 训练的流程和使用单 GPU 训练的流程一致，我们仅需要在训练流程开始前禁用 GPU。
+
+```shell
+export CUDA_VISIBLE_DEVICES=-1
+```
+
+之后运行单 GPU 训练脚本即可。
+
+**注意**：
+
+我们不推荐用户使用 CPU 进行训练，这太过缓慢。我们支持这个功能是为了方便用户在没有 GPU 的机器上进行调试。
+
+### 在多 GPU 上训练
+
+我们提供了 `tools/dist_train.sh` 来开启在多 GPU 上的训练。基本使用如下：
+
+```shell
+bash ./tools/dist_train.sh \
+    ${CONFIG_FILE} \
+    ${GPU_NUM} \
+    [optional arguments]
+```
+
+可选参数和单 GPU 训练的可选参数一致。
+
+#### 同时启动多个任务
+
+如果你想在一台机器上启动多个任务的话，比如在一个有 8 块 GPU 的机器上启动 2 个需要 4 块GPU的任务，你需要给不同的训练任务指定不同的端口（默认为 29500）来避免冲突。
+
+如果你使用 `dist_train.sh` 来启动训练任务，你可以使用命令来设置端口。
+
+```shell
+CUDA_VISIBLE_DEVICES=0,1,2,3 PORT=29500 ./tools/dist_train.sh ${CONFIG_FILE} 4
+CUDA_VISIBLE_DEVICES=4,5,6,7 PORT=29501 ./tools/dist_train.sh ${CONFIG_FILE} 4
+```
+
+### 使用多台机器训练
+
+如果您想使用由 ethernet 连接起来的多台机器， 您可以使用以下命令:
+
+在第一台机器上:
+
+```shell
+NNODES=2 NODE_RANK=0 PORT=$MASTER_PORT MASTER_ADDR=$MASTER_ADDR sh tools/dist_train.sh $CONFIG $GPUS
+```
+
+在第二台机器上:
+
+```shell
+NNODES=2 NODE_RANK=1 PORT=$MASTER_PORT MASTER_ADDR=$MASTER_ADDR sh tools/dist_train.sh $CONFIG $GPUS
+```
+
+但是，如果您不使用高速网路连接这几台机器的话，训练将会非常慢。
+
+### 使用 Slurm 来管理任务
+
+Slurm 是一个常见的计算集群调度系统。在 Slurm 管理的集群上，你可以使用 `slurm.sh` 来开启训练任务。它既支持单节点训练也支持多节点训练。
+
+基本使用如下：
+
+```shell
+[GPUS=${GPUS}] ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} ${CONFIG_FILE} ${WORK_DIR}
+```
+
+以下是在一个名称为 _dev_ 的 Slurm 分区上，使用 16 块 GPU 来训练 Mask R-CNN 的例子，并且将 `work-dir` 设置在了某些共享文件系统下。
+
+```shell
+GPUS=16 ./tools/slurm_train.sh dev mask_r50_1x configs/mask_rcnn_r50_fpn_1x_coco.py /nfs/xxxx/mask_rcnn_r50_fpn_1x
+```
+
+你可以查看 [源码](https://github.com/open-mmlab/mmdetection/blob/main/tools/slurm_train.sh) 来检查全部的参数和环境变量.
+
+在使用 Slurm 时，端口需要以下方的某个方法之一来设置。
+
+1. 通过 `--options` 来设置端口。我们非常建议用这种方法，因为它无需改变原始的配置文件。
+
+   ```shell
+   CUDA_VISIBLE_DEVICES=0,1,2,3 GPUS=4 ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config1.py ${WORK_DIR} --cfg-options 'dist_params.port=29500'
+   CUDA_VISIBLE_DEVICES=4,5,6,7 GPUS=4 ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config2.py ${WORK_DIR} --cfg-options 'dist_params.port=29501'
+   ```
+
+2. 修改配置文件来设置不同的交流端口。
+
+   在 `config1.py` 中，设置：
+
+   ```python
+   dist_params = dict(backend='nccl', port=29500)
+   ```
+
+   在 `config2.py` 中，设置：
+
+   ```python
+   dist_params = dict(backend='nccl', port=29501)
+   ```
+
+   然后你可以使用 `config1.py` 和 `config2.py` 来启动两个任务了。
+
+   ```shell
+   CUDA_VISIBLE_DEVICES=0,1,2,3 GPUS=4 ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config1.py ${WORK_DIR}
+   CUDA_VISIBLE_DEVICES=4,5,6,7 GPUS=4 ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config2.py ${WORK_DIR}
+   ```
+
+# 在自定义数据集上进行训练
+
+通过本文档，你将会知道如何使用自定义数据集对预先定义好的模型进行推理，测试以及训练。我们使用 [balloon dataset](https://github.com/matterport/Mask_RCNN/tree/master/samples/balloon) 作为例子来描述整个过程。
+
+基本步骤如下：
+
+1. 准备自定义数据集
+2. 准备配置文件
+3. 在自定义数据集上进行训练，测试和推理。
+
+## 准备自定义数据集
+
+MMDetection 一共支持三种形式应用新数据集：
+
+1. 将数据集重新组织为 COCO 格式。
+2. 将数据集重新组织为一个中间格式。
+3. 实现一个新的数据集。
+
+我们通常建议使用前面两种方法，因为它们通常来说比第三种方法要简单。
+
+在本文档中，我们展示一个例子来说明如何将数据转化为 COCO 格式。
+
+**注意**：在 MMDetection 3.0 之后，数据集和指标已经解耦（除了 CityScapes）。因此，用户在验证阶段使用任意的评价指标来评价模型在任意数据集上的性能。比如，用 VOC 评价指标来评价模型在 COCO 数据集的性能，或者同时使用 VOC 评价指标和 COCO 评价指标来评价模型在 OpenImages 数据集上的性能。
+
+### COCO标注格式
+
+用于实例分割的 COCO 数据集格式如下所示，其中的键（key）都是必要的，参考[这里](https://cocodataset.org/#format-data)来获取更多细节。
+
+```json
+{
+    "images": [image],
+    "annotations": [annotation],
+    "categories": [category]
+}
+
+
+image = {
+    "id": int,
+    "width": int,
+    "height": int,
+    "file_name": str,
+}
+
+annotation = {
+    "id": int,
+    "image_id": int,
+    "category_id": int,
+    "segmentation": RLE or [polygon],
+    "area": float,
+    "bbox": [x,y,width,height], # (x, y) 为 bbox 左上角的坐标
+    "iscrowd": 0 or 1,
+}
+
+categories = [{
+    "id": int,
+    "name": str,
+    "supercategory": str,
+}]
+```
+
+现在假设我们使用 balloon dataset。
+
+下载了数据集之后，我们需要实现一个函数将标注格式转化为 COCO 格式。然后我们就可以使用已经实现的 `CocoDataset` 类来加载数据并进行训练以及评测。
+
+如果你浏览过新数据集，你会发现格式如下：
+
+```json
+{'base64_img_data': '',
+ 'file_attributes': {},
+ 'filename': '34020010494_e5cb88e1c4_k.jpg',
+ 'fileref': '',
+ 'regions': {'0': {'region_attributes': {},
+   'shape_attributes': {'all_points_x': [1020,
+     1000,
+     994,
+     1003,
+     1023,
+     1050,
+     1089,
+     1134,
+     1190,
+     1265,
+     1321,
+     1361,
+     1403,
+     1428,
+     1442,
+     1445,
+     1441,
+     1427,
+     1400,
+     1361,
+     1316,
+     1269,
+     1228,
+     1198,
+     1207,
+     1210,
+     1190,
+     1177,
+     1172,
+     1174,
+     1170,
+     1153,
+     1127,
+     1104,
+     1061,
+     1032,
+     1020],
+    'all_points_y': [963,
+     899,
+     841,
+     787,
+     738,
+     700,
+     663,
+     638,
+     621,
+     619,
+     643,
+     672,
+     720,
+     765,
+     800,
+     860,
+     896,
+     942,
+     990,
+     1035,
+     1079,
+     1112,
+     1129,
+     1134,
+     1144,
+     1153,
+     1166,
+     1166,
+     1150,
+     1136,
+     1129,
+     1122,
+     1112,
+     1084,
+     1037,
+     989,
+     963],
+    'name': 'polygon'}}},
+ 'size': 1115004}
+```
+
+标注文件时是 JSON 格式的，其中所有键（key）组成了一张图片的所有标注。
+
+其中将 balloon dataset 转化为 COCO 格式的代码如下所示。
+
+```python
+import os.path as osp
+
+import mmcv
+
+from mmengine.fileio import dump, load
+from mmengine.utils import track_iter_progress
+
+
+def convert_balloon_to_coco(ann_file, out_file, image_prefix):
+    data_infos = load(ann_file)
+
+    annotations = []
+    images = []
+    obj_count = 0
+    for idx, v in enumerate(track_iter_progress(data_infos.values())):
+        filename = v['filename']
+        img_path = osp.join(image_prefix, filename)
+        height, width = mmcv.imread(img_path).shape[:2]
+
+        images.append(
+            dict(id=idx, file_name=filename, height=height, width=width))
+
+        for _, obj in v['regions'].items():
+            assert not obj['region_attributes']
+            obj = obj['shape_attributes']
+            px = obj['all_points_x']
+            py = obj['all_points_y']
+            poly = [(x + 0.5, y + 0.5) for x, y in zip(px, py)]
+            poly = [p for x in poly for p in x]
+
+            x_min, y_min, x_max, y_max = (min(px), min(py), max(px), max(py))
+
+            data_anno = dict(
+                image_id=idx,
+                id=obj_count,
+                category_id=0,
+                bbox=[x_min, y_min, x_max - x_min, y_max - y_min],
+                area=(x_max - x_min) * (y_max - y_min),
+                segmentation=[poly],
+                iscrowd=0)
+            annotations.append(data_anno)
+            obj_count += 1
+
+    coco_format_json = dict(
+        images=images,
+        annotations=annotations,
+        categories=[{
+            'id': 0,
+            'name': 'balloon'
+        }])
+    dump(coco_format_json, out_file)
+
+
+if __name__ == '__main__':
+    convert_balloon_to_coco(ann_file='data/balloon/train/via_region_data.json',
+                            out_file='data/balloon/train/annotation_coco.json',
+                            image_prefix='data/balloon/train')
+    convert_balloon_to_coco(ann_file='data/balloon/val/via_region_data.json',
+                            out_file='data/balloon/val/annotation_coco.json',
+                            image_prefix='data/balloon/val')
+```
+
+使用如上的函数，用户可以成功将标注文件转化为 JSON 格式，之后可以使用 `CocoDataset` 对模型进行训练，并用 `CocoMetric` 评测。
+
+## 准备配置文件
+
+第二步需要准备一个配置文件来成功加载数据集。假设我们想要用 balloon dataset 来训练配备了 FPN 的 Mask R-CNN ，如下是我们的配置文件。假设配置文件命名为 `mask-rcnn_r50-caffe_fpn_ms-poly-1x_balloon.py`，相应保存路径为 `configs/balloon/`，配置文件内容如下所示。详细的配置文件方法可以参考[学习配置文件 — MMDetection 3.0.0 文档](https://mmdetection.readthedocs.io/zh_CN/latest/user_guides/config.html#base)。
+
+```python
+# 新配置继承了基本配置，并做了必要的修改
+_base_ = '../mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco.py'
+
+# 我们还需要更改 head 中的 num_classes 以匹配数据集中的类别数
+model = dict(
+    roi_head=dict(
+        bbox_head=dict(num_classes=1), mask_head=dict(num_classes=1)))
+
+# 修改数据集相关配置
+data_root = 'data/balloon/'
+metainfo = {
+    'classes': ('balloon', ),
+    'palette': [
+        (220, 20, 60),
+    ]
+}
+train_dataloader = dict(
+    batch_size=1,
+    dataset=dict(
+        data_root=data_root,
+        metainfo=metainfo,
+        ann_file='train/annotation_coco.json',
+        data_prefix=dict(img='train/')))
+val_dataloader = dict(
+    dataset=dict(
+        data_root=data_root,
+        metainfo=metainfo,
+        ann_file='val/annotation_coco.json',
+        data_prefix=dict(img='val/')))
+test_dataloader = val_dataloader
+
+# 修改评价指标相关配置
+val_evaluator = dict(ann_file=data_root + 'val/annotation_coco.json')
+test_evaluator = val_evaluator
+
+# 使用预训练的 Mask R-CNN 模型权重来做初始化，可以提高模型性能
+load_from = 'https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth'
+
+```
+
+## 训练一个新的模型
+
+为了使用新的配置方法来对模型进行训练，你只需要运行如下命令。
+
+```shell
+python tools/train.py configs/balloon/mask-rcnn_r50-caffe_fpn_ms-poly-1x_balloon.py
+```
+
+参考 [在标准数据集上训练预定义的模型](https://mmdetection.readthedocs.io/zh_CN/latest/user_guides/train.html#id1) 来获取更多详细的使用方法。
+
+## 测试以及推理
+
+为了测试训练完毕的模型，你只需要运行如下命令。
+
+```shell
+python tools/test.py configs/balloon/mask-rcnn_r50-caffe_fpn_ms-poly-1x_balloon.py work_dirs/mask-rcnn_r50-caffe_fpn_ms-poly-1x_balloon/epoch_12.pth
+```
+
+参考 [测试现有模型](https://mmdetection.readthedocs.io/zh_CN/latest/user_guides/test.html) 来获取更多详细的使用方法。
diff --git a/mmdetection/docs/zh_cn/user_guides/useful_hooks.md b/mmdetection/docs/zh_cn/user_guides/useful_hooks.md
new file mode 100644
index 00000000..07a59df2
--- /dev/null
+++ b/mmdetection/docs/zh_cn/user_guides/useful_hooks.md
@@ -0,0 +1,107 @@
+# 实用的钩子
+
+MMDetection 和 MMEngine 为用户提供了多种多样实用的钩子（Hook），包括 `MemoryProfilerHook`、`NumClassCheckHook` 等等。
+这篇教程介绍了 MMDetection 中实现的钩子功能及使用方式。若使用 MMEngine 定义的钩子请参考 [MMEngine 的钩子API文档](https://github.com/open-mmlab/mmengine/tree/main/docs/en/tutorials/hook.md).
+
+## CheckInvalidLossHook
+
+## NumClassCheckHook
+
+## MemoryProfilerHook
+
+[内存分析钩子](https://github.com/open-mmlab/mmdetection/blob/main/mmdet/engine/hooks/memory_profiler_hook.py)
+记录了包括虚拟内存、交换内存、当前进程在内的所有内存信息，它能够帮助捕捉系统的使用状况与发现隐藏的内存泄露问题。为了使用这个钩子，你需要先通过 `pip install memory_profiler psutil` 命令安装 `memory_profiler` 和 `psutil`。
+
+### 使用
+
+为了使用这个钩子，使用者需要添加如下代码至 config 文件
+
+```python
+custom_hooks = [
+    dict(type='MemoryProfilerHook', interval=50)
+]
+```
+
+### 结果
+
+在训练中，你会看到 `MemoryProfilerHook` 记录的如下信息：
+
+```text
+The system has 250 GB (246360 MB + 9407 MB) of memory and 8 GB (5740 MB + 2452 MB) of swap memory in total. Currently 9407 MB (4.4%) of memory and 5740 MB (29.9%) of swap memory were consumed. And the current training process consumed 5434 MB of memory.
+```
+
+```text
+2022-04-21 08:49:56,881 - mmengine - INFO - Memory information available_memory: 246360 MB, used_memory: 9407 MB, memory_utilization: 4.4 %, available_swap_memory: 5740 MB, used_swap_memory: 2452 MB, swap_memory_utilization: 29.9 %, current_process_memory: 5434 MB
+```
+
+## SetEpochInfoHook
+
+## SyncNormHook
+
+## SyncRandomSizeHook
+
+## YOLOXLrUpdaterHook
+
+## YOLOXModeSwitchHook
+
+## 如何实现自定义钩子
+
+通常，从模型训练的开始到结束，共有20个点位可以执行钩子。我们可以实现自定义钩子在不同点位执行，以便在训练中实现自定义操作。
+
+- global points: `before_run`, `after_run`
+- points in training: `before_train`, `before_train_epoch`, `before_train_iter`, `after_train_iter`, `after_train_epoch`, `after_train`
+- points in validation: `before_val`, `before_val_epoch`, `before_val_iter`, `after_val_iter`, `after_val_epoch`, `after_val`
+- points at testing: `before_test`, `before_test_epoch`, `before_test_iter`, `after_test_iter`, `after_test_epoch`,  `after_test`
+- other points: `before_save_checkpoint`, `after_save_checkpoint`
+
+比如，我们要实现一个检查 loss 的钩子，当损失为 NaN 时自动结束训练。我们可以把这个过程分为三步：
+
+1. 在 MMEngine 实现一个继承于 `Hook` 类的新钩子，并实现 `after_train_iter` 方法用于检查每 `n` 次训练迭代后损失是否变为 NaN 。
+2. 使用 `@HOOKS.register_module()` 注册实现好了的自定义钩子，如下列代码所示。
+3. 在配置文件中添加 `custom_hooks = [dict(type='MemoryProfilerHook', interval=50)]`
+
+```python
+from typing import Optional
+
+import torch
+from mmengine.hooks import Hook
+from mmengine.runner import Runner
+
+from mmdet.registry import HOOKS
+
+
+@HOOKS.register_module()
+class CheckInvalidLossHook(Hook):
+    """Check invalid loss hook.
+
+    This hook will regularly check whether the loss is valid
+    during training.
+
+    Args:
+        interval (int): Checking interval (every k iterations).
+            Default: 50.
+    """
+
+    def __init__(self, interval: int = 50) -> None:
+        self.interval = interval
+
+    def after_train_iter(self,
+                         runner: Runner,
+                         batch_idx: int,
+                         data_batch: Optional[dict] = None,
+                         outputs: Optional[dict] = None) -> None:
+        """Regularly check whether the loss is valid every n iterations.
+
+        Args:
+            runner (:obj:`Runner`): The runner of the training process.
+            batch_idx (int): The index of the current batch in the train loop.
+            data_batch (dict, Optional): Data from dataloader.
+                Defaults to None.
+            outputs (dict, Optional): Outputs from model. Defaults to None.
+        """
+        if self.every_n_train_iters(runner, self.interval):
+            assert torch.isfinite(outputs['loss']), \
+                runner.logger.info('loss become infinite or NaN!')
+```
+
+请参考 [自定义训练配置](../advanced_guides/customize_runtime.md) 了解更多与自定义钩子相关的内容。
diff --git a/mmdetection/docs/zh_cn/user_guides/useful_tools.md b/mmdetection/docs/zh_cn/user_guides/useful_tools.md
new file mode 100644
index 00000000..8416472c
--- /dev/null
+++ b/mmdetection/docs/zh_cn/user_guides/useful_tools.md
@@ -0,0 +1,636 @@
+除了训练和测试脚本，我们还在 `tools/` 目录下提供了许多有用的工具。
+
+## 日志分析
+
+`tools/analysis_tools/analyze_logs.py` 可利用指定的训练 log 文件绘制 loss/mAP 曲线图，
+第一次运行前请先运行 `pip install seaborn` 安装必要依赖.
+
+```shell
+python tools/analysis_tools/analyze_logs.py plot_curve [--keys ${KEYS}] [--eval-interval ${EVALUATION_INTERVAL}] [--title ${TITLE}] [--legend ${LEGEND}] [--backend ${BACKEND}] [--style ${STYLE}] [--out ${OUT_FILE}]
+```
+
+![loss curve image](../../../resources/loss_curve.png)
+
+样例:
+
+- 绘制分类损失曲线图
+
+  ```shell
+  python tools/analysis_tools/analyze_logs.py plot_curve log.json --keys loss_cls --legend loss_cls
+  ```
+
+- 绘制分类损失、回归损失曲线图，保存图片为对应的 pdf 文件
+
+  ```shell
+  python tools/analysis_tools/analyze_logs.py plot_curve log.json --keys loss_cls loss_bbox --out losses.pdf
+  ```
+
+- 在相同图像中比较两次运行结果的 bbox mAP
+
+  ```shell
+  python tools/analysis_tools/analyze_logs.py plot_curve log1.json log2.json --keys bbox_mAP --legend run1 run2
+  ```
+
+- 计算平均训练速度
+
+  ```shell
+  python tools/analysis_tools/analyze_logs.py cal_train_time log.json [--include-outliers]
+  ```
+
+  输出以如下形式展示
+
+  ```text
+  -----Analyze train time of work_dirs/some_exp/20190611_192040.log.json-----
+  slowest epoch 11, average time is 1.2024
+  fastest epoch 1, average time is 1.1909
+  time std over epochs is 0.0028
+  average iter time: 1.1959 s/iter
+  ```
+
+## 结果分析
+
+使用 `tools/analysis_tools/analyze_results.py` 可计算每个图像 mAP，随后根据真实标注框与预测框的比较结果，展示或保存最高与最低 top-k 得分的预测图像。
+
+**使用方法**
+
+```shell
+python tools/analysis_tools/analyze_results.py \
+      ${CONFIG} \
+      ${PREDICTION_PATH} \
+      ${SHOW_DIR} \
+      [--show] \
+      [--wait-time ${WAIT_TIME}] \
+      [--topk ${TOPK}] \
+      [--show-score-thr ${SHOW_SCORE_THR}] \
+      [--cfg-options ${CFG_OPTIONS}]
+```
+
+各个参数选项的作用:
+
+- `config`: model config 文件的路径。
+- `prediction_path`:  使用 `tools/test.py` 输出的 pickle 格式结果文件。
+- `show_dir`: 绘制真实标注框与预测框的图像存放目录。
+- `--show`：决定是否展示绘制 box 后的图片，默认值为 `False`。
+- `--wait-time`: show 时间的间隔，若为 0 表示持续显示。
+- `--topk`: 根据最高或最低 `topk` 概率排序保存的图片数量，若不指定，默认设置为 `20`。
+- `--show-score-thr`: 能够展示的概率阈值，默认为 `0`。
+- `--cfg-options`: 如果指定，可根据指定键值对覆盖更新配置文件的对应选项
+
+**样例**:
+假设你已经通过 `tools/test.py` 得到了 pickle 格式的结果文件，路径为 './result.pkl'。
+
+1. 测试 Faster R-CNN 并可视化结果，保存图片至 `results/`
+
+```shell
+python tools/analysis_tools/analyze_results.py \
+       configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py \
+       result.pkl \
+       results \
+       --show
+```
+
+2. 测试 Faster R-CNN 并指定 top-k 参数为 50，保存结果图片至 `results/`
+
+```shell
+python tools/analysis_tools/analyze_results.py \
+       configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py \
+       result.pkl \
+       results \
+       --topk 50
+```
+
+3. 如果你想过滤低概率的预测结果，指定 `show-score-thr` 参数
+
+```shell
+python tools/analysis_tools/analyze_results.py \
+       configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py \
+       result.pkl \
+       results \
+       --show-score-thr 0.3
+```
+
+## 多模型检测结果融合
+
+`tools/analysis_tools/fuse_results.py` 可使用 Weighted Boxes Fusion(WBF) 方法将多个模型的检测结果进行融合。（当前仅支持 COCO 格式）
+
+**使用方法**
+
+```shell
+python tools/analysis_tools/fuse_results.py \
+       ${PRED_RESULTS} \
+       [--annotation ${ANNOTATION}] \
+       [--weights ${WEIGHTS}] \
+       [--fusion-iou-thr ${FUSION_IOU_THR}] \
+       [--skip-box-thr ${SKIP_BOX_THR}] \
+       [--conf-type ${CONF_TYPE}] \
+       [--eval-single ${EVAL_SINGLE}] \
+       [--save-fusion-results ${SAVE_FUSION_RESULTS}] \
+       [--out-dir ${OUT_DIR}]
+```
+
+各个参数选项的作用:
+
+- `pred-results`: 多模型测试结果的保存路径。（目前仅支持 json 格式）
+- `--annotation`: 真实标注框的保存路径。
+- `--weights`: 模型融合权重。默认设置下，每个模型的权重均为1。
+- `--fusion-iou-thr`: 在WBF算法中，匹配成功的 IoU 阈值，默认值为`0.55`。
+- `--skip-box-thr`: WBF算法中需剔除的置信度阈值，置信度小于该值的 bbox 会被剔除，默认值为`0`。
+- `--conf-type`: 如何计算融合后 bbox 的置信度。有以下四种选项：
+  - `avg`: 取平均值，默认为此选项。
+  - `max`: 取最大值。
+  - `box_and_model_avg`: box和模型尺度的加权平均值。
+  - `absent_model_aware_avg`: 考虑缺失模型的加权平均值。
+- `--eval-single`: 是否评估每个单一模型，默认值为`False`。
+- `--save-fusion-results`: 是否保存融合结果，默认值为`False`。
+- `--out-dir`: 融合结果保存的路径。
+
+**样例**:
+假设你已经通过 `tools/test.py` 得到了3个模型的 json 格式的结果文件，路径分别为 './faster-rcnn_r50-caffe_fpn_1x_coco.json', './retinanet_r50-caffe_fpn_1x_coco.json', './cascade-rcnn_r50-caffe_fpn_1x_coco.json'，真实标注框的文件路径为'./annotation.json'。
+
+1. 融合三个模型的预测结果并评估其效果
+
+```shell
+python tools/analysis_tools/fuse_results.py \
+       ./faster-rcnn_r50-caffe_fpn_1x_coco.json \
+       ./retinanet_r50-caffe_fpn_1x_coco.json \
+       ./cascade-rcnn_r50-caffe_fpn_1x_coco.json \
+       --annotation ./annotation.json \
+       --weights 1 2 3 \
+```
+
+2. 同时评估每个单一模型与融合结果
+
+```shell
+python tools/analysis_tools/fuse_results.py \
+       ./faster-rcnn_r50-caffe_fpn_1x_coco.json \
+       ./retinanet_r50-caffe_fpn_1x_coco.json \
+       ./cascade-rcnn_r50-caffe_fpn_1x_coco.json \
+       --annotation ./annotation.json \
+       --weights 1 2 3 \
+       --eval-single
+```
+
+3. 融合三个模型的预测结果并保存
+
+```shell
+python tools/analysis_tools/fuse_results.py \
+       ./faster-rcnn_r50-caffe_fpn_1x_coco.json \
+       ./retinanet_r50-caffe_fpn_1x_coco.json \
+       ./cascade-rcnn_r50-caffe_fpn_1x_coco.json \
+       --annotation ./annotation.json \
+       --weights 1 2 3 \
+       --save-fusion-results \
+       --out-dir outputs/fusion
+```
+
+## 可视化
+
+### 可视化数据集
+
+`tools/analysis_tools/browse_dataset.py` 可帮助使用者检查所使用的检测数据集（包括图像和标注），或保存图像至指定目录。
+
+```shell
+python tools/analysis_tools/browse_dataset.py ${CONFIG} [-h] [--skip-type ${SKIP_TYPE[SKIP_TYPE...]}] [--output-dir ${OUTPUT_DIR}] [--not-show] [--show-interval ${SHOW_INTERVAL}]
+```
+
+### 可视化模型
+
+在可视化之前，需要先转换模型至 ONNX 格式，[可参考此处](#convert-mmdetection-model-to-onnx-experimental)。
+注意，现在只支持 RetinaNet，之后的版本将会支持其他模型
+转换后的模型可以被其他工具可视化[Netron](https://github.com/lutzroeder/netron)。
+
+### 可视化预测结果
+
+如果你想要一个轻量 GUI 可视化检测结果，你可以参考 [DetVisGUI project](https://github.com/Chien-Hung/DetVisGUI/tree/mmdetection)。
+
+## 误差分析
+
+`tools/analysis_tools/coco_error_analysis.py` 使用不同标准分析每个类别的 COCO 评估结果。同时将一些有帮助的信息体现在图表上。
+
+```shell
+python tools/analysis_tools/coco_error_analysis.py ${RESULT} ${OUT_DIR} [-h] [--ann ${ANN}] [--types ${TYPES[TYPES...]}]
+```
+
+样例:
+
+假设你已经把 [Mask R-CNN checkpoint file](https://download.openmmlab.com/mmdetection/v2.0/mask_rcnn/mask_rcnn_r50_fpn_1x_coco/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth) 放置在文件夹 'checkpoint' 中（其他模型请在 [model zoo](./model_zoo.md) 中获取）。
+
+为了保存 bbox 结果信息，我们需要用下列方式修改 `test_evaluator` :
+
+1. 查找当前 config 文件相对应的  'configs/base/datasets' 数据集信息。
+2. 用当前数据集 config 中的 test_evaluator 以及 test_dataloader 替换原始文件的 test_evaluator 以及 test_dataloader。
+3. 使用以下命令得到 bbox 或 segmentation 的 json 格式文件。
+
+```shell
+python tools/test.py \
+       configs/mask_rcnn/mask-rcnn_r50_fpn_1x_coco.py \
+       checkpoint/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth \
+```
+
+1. 得到每一类的 COCO bbox 误差结果，并保存分析结果图像至指定目录。（在 [config](../../../configs/_base_/datasets/coco_instance.py) 中默认目录是 './work_dirs/coco_instance/test')
+
+```shell
+python tools/analysis_tools/coco_error_analysis.py \
+       results.bbox.json \
+       results \
+       --ann=data/coco/annotations/instances_val2017.json \
+```
+
+2. 得到每一类的 COCO 分割误差结果，并保存分析结果图像至指定目录。
+
+```shell
+python tools/analysis_tools/coco_error_analysis.py \
+       results.segm.json \
+       results \
+       --ann=data/coco/annotations/instances_val2017.json \
+       --types='segm'
+```
+
+## 模型服务部署
+
+如果你想使用 [`TorchServe`](https://pytorch.org/serve/) 搭建一个 `MMDetection` 模型服务，可以参考以下步骤：
+
+### 1. 安装 TorchServe
+
+假设你已经成功安装了包含 `PyTorch` 和 `MMDetection` 的 `Python` 环境，那么你可以运行以下命令来安装 `TorchServe` 及其依赖项。有关更多其他安装选项，请参考[快速入门](https://github.com/pytorch/serve/blob/master/README.md#serve-a-model)。
+
+```shell
+python -m pip install torchserve torch-model-archiver torch-workflow-archiver nvgpu
+```
+
+**注意**: 如果你想在 docker 中使用`TorchServe`，请参考[torchserve docker](https://github.com/pytorch/serve/blob/master/docker/README.md)。
+
+### 2. 把 MMDetection 模型转换至 TorchServe
+
+```shell
+python tools/deployment/mmdet2torchserve.py ${CONFIG_FILE} ${CHECKPOINT_FILE} \
+--output-folder ${MODEL_STORE} \
+--model-name ${MODEL_NAME}
+```
+
+### 3. 启动 `TorchServe`
+
+```shell
+torchserve --start --ncs \
+  --model-store ${MODEL_STORE} \
+  --models  ${MODEL_NAME}.mar
+```
+
+### 4. 测试部署效果
+
+```shell
+curl -O curl -O https://raw.githubusercontent.com/pytorch/serve/master/docs/images/3dogs.jpg
+curl http://127.0.0.1:8080/predictions/${MODEL_NAME} -T 3dogs.jpg
+```
+
+你可以得到下列 json 信息：
+
+```json
+[
+  {
+    "class_label": 16,
+    "class_name": "dog",
+    "bbox": [
+      294.63409423828125,
+      203.99111938476562,
+      417.048583984375,
+      281.62744140625
+    ],
+    "score": 0.9987992644309998
+  },
+  {
+    "class_label": 16,
+    "class_name": "dog",
+    "bbox": [
+      404.26019287109375,
+      126.0080795288086,
+      574.5091552734375,
+      293.6662292480469
+    ],
+    "score": 0.9979367256164551
+  },
+  {
+    "class_label": 16,
+    "class_name": "dog",
+    "bbox": [
+      197.2144775390625,
+      93.3067855834961,
+      307.8505554199219,
+      276.7560119628906
+    ],
+    "score": 0.993338406085968
+  }
+]
+```
+
+#### 结果对比
+
+你也可以使用 `test_torchserver.py` 来比较 `TorchServe` 和 `PyTorch` 的结果，并可视化：
+
+```shell
+python tools/deployment/test_torchserver.py ${IMAGE_FILE} ${CONFIG_FILE} ${CHECKPOINT_FILE} ${MODEL_NAME}
+[--inference-addr ${INFERENCE_ADDR}] [--device ${DEVICE}] [--score-thr ${SCORE_THR}] [--work-dir ${WORK_DIR}]
+```
+
+样例:
+
+```shell
+python tools/deployment/test_torchserver.py \
+demo/demo.jpg \
+configs/yolo/yolov3_d53_8xb8-320-273e_coco.py \
+checkpoint/yolov3_d53_320_273e_coco-421362b6.pth \
+yolov3 \
+--work-dir ./work-dir
+```
+
+### 5. 停止 `TorchServe`
+
+```shell
+torchserve --stop
+```
+
+## 模型复杂度
+
+`tools/analysis_tools/get_flops.py` 工具可用于计算指定模型的 FLOPs、参数量大小（改编自 [flops-counter.pytorch](https://github.com/sovrasov/flops-counter.pytorch) ）。
+
+```shell
+python tools/analysis_tools/get_flops.py ${CONFIG_FILE} [--shape ${INPUT_SHAPE}]
+```
+
+获得的结果如下：
+
+```text
+==============================
+Input shape: (3, 1280, 800)
+Flops: 239.32 GFLOPs
+Params: 37.74 M
+==============================
+```
+
+**注意**：这个工具还只是实验性质，我们不保证这个数值是绝对正确的。你可以将他用于简单的比较，但如果用于科技论文报告需要再三检查确认。
+
+1. FLOPs 与输入的形状大小相关，参数量没有这个关系，默认的输入形状大小为 (1, 3, 1280, 800) 。
+2. 一些算子并不计入 FLOPs，比如 GN 或其他自定义的算子。你可以参考 [`mmcv.cnn.get_model_complexity_info()`](https://github.com/open-mmlab/mmcv/blob/2.x/mmcv/cnn/utils/flops_counter.py) 查看更详细的说明。
+3. 两阶段检测的 FLOPs 大小取决于 proposal 的数量。
+
+## 模型转换
+
+### MMDetection 模型转换至 ONNX 格式
+
+我们提供了一个脚本用于转换模型至 [ONNX](https://github.com/onnx/onnx) 格式。同时还支持比较 Pytorch 与 ONNX 模型的输出结果以便对照。更详细的内容可以参考 [mmdeploy](https://github.com/open-mmlab/mmdeploy)。
+
+### MMDetection 1.x 模型转换至 MMDetection 2.x 模型
+
+`tools/model_converters/upgrade_model_version.py` 可将旧版本的 MMDetection checkpoints 转换至新版本。但要注意此脚本不保证在新版本加入非兼容更新后还能正常转换，建议您直接使用新版本的 checkpoints。
+
+```shell
+python tools/model_converters/upgrade_model_version.py ${IN_FILE} ${OUT_FILE} [-h] [--num-classes NUM_CLASSES]
+```
+
+### RegNet 模型转换至 MMDetection 模型
+
+`tools/model_converters/regnet2mmdet.py` 将 pycls 编码的预训练 RegNet 模型转换为 MMDetection 风格。
+
+```shell
+python tools/model_converters/regnet2mmdet.py ${SRC} ${DST} [-h]
+```
+
+### Detectron ResNet 模型转换至 Pytorch 模型
+
+`tools/model_converters/detectron2pytorch.py` 将 detectron 的原始预训练 RegNet 模型转换为 MMDetection 风格。
+
+```shell
+python tools/model_converters/detectron2pytorch.py ${SRC} ${DST} ${DEPTH} [-h]
+```
+
+### 制作发布用模型
+
+`tools/model_converters/publish_model.py` 可用来制作一个发布用的模型。
+
+在发布模型至 AWS 之前，你可能需要：
+
+1. 将模型转换至 CPU 张量
+2. 删除优化器状态
+3. 计算 checkpoint 文件的 hash 值，并将 hash 号码记录至文件名。
+
+```shell
+python tools/model_converters/publish_model.py ${INPUT_FILENAME} ${OUTPUT_FILENAME}
+```
+
+样例：
+
+```shell
+python tools/model_converters/publish_model.py work_dirs/faster_rcnn/latest.pth faster_rcnn_r50_fpn_1x_20190801.pth
+```
+
+最后输出的文件名如下所示： `faster_rcnn_r50_fpn_1x_20190801-{hash id}.pth`.
+
+## 数据集转换
+
+`tools/data_converters/` 提供了将 Cityscapes 数据集与 Pascal VOC 数据集转换至 COCO 数据集格式的工具
+
+```shell
+python tools/dataset_converters/cityscapes.py ${CITYSCAPES_PATH} [-h] [--img-dir ${IMG_DIR}] [--gt-dir ${GT_DIR}] [-o ${OUT_DIR}] [--nproc ${NPROC}]
+python tools/dataset_converters/pascal_voc.py ${DEVKIT_PATH} [-h] [-o ${OUT_DIR}]
+```
+
+## 数据集下载
+
+`tools/misc/download_dataset.py` 可以下载各类形如 COCO， VOC， LVIS 数据集。
+
+```shell
+python tools/misc/download_dataset.py --dataset-name coco2017
+python tools/misc/download_dataset.py --dataset-name voc2007
+python tools/misc/download_dataset.py --dataset-name lvis
+```
+
+对于中国境内的用户，我们也推荐使用开源数据平台 [OpenDataLab](https://opendatalab.com/?source=OpenMMLab%20GitHub) 来获取这些数据集，以获得更好的下载体验:
+
+- [COCO2017](https://opendatalab.com/COCO_2017/download?source=OpenMMLab%20GitHub)
+- [VOC2007](https://opendatalab.com/PASCAL_VOC2007/download?source=OpenMMLab%20GitHub)
+- [VOC2012](https://opendatalab.com/PASCAL_VOC2012/download?source=OpenMMLab%20GitHub)
+- [LVIS](https://opendatalab.com/LVIS/download?source=OpenMMLab%20GitHub)
+
+## 基准测试
+
+### 鲁棒性测试基准
+
+`tools/analysis_tools/test_robustness.py` 及 `tools/analysis_tools/robustness_eval.py` 帮助使用者衡量模型的鲁棒性。其核心思想来源于 [Benchmarking Robustness in Object Detection: Autonomous Driving when Winter is Coming](https://arxiv.org/abs/1907.07484)。如果你想了解如何在污损图像上评估模型的效果，以及参考该基准的一组标准模型，请参照 [robustness_benchmarking.md](robustness_benchmarking.md)。
+
+### FPS 测试基准
+
+`tools/analysis_tools/benchmark.py` 可帮助使用者计算 FPS，FPS 计算包括了模型向前传播与后处理过程。为了得到更精确的计算值，现在的分布式计算模式只支持一个 GPU。
+
+```shell
+python -m torch.distributed.launch --nproc_per_node=1 --master_port=${PORT} tools/analysis_tools/benchmark.py \
+    ${CONFIG} \
+    [--checkpoint ${CHECKPOINT}] \
+    [--repeat-num ${REPEAT_NUM}] \
+    [--max-iter ${MAX_ITER}] \
+    [--log-interval ${LOG_INTERVAL}] \
+    --launcher pytorch
+```
+
+样例：假设你已经下载了 `Faster R-CNN` 模型 checkpoint 并放置在 `checkpoints/` 目录下。
+
+```shell
+python -m torch.distributed.launch --nproc_per_node=1 --master_port=29500 tools/analysis_tools/benchmark.py \
+       configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py \
+       checkpoints/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth \
+       --launcher pytorch
+```
+
+## 更多工具
+
+### 以某个评估标准进行评估
+
+`tools/analysis_tools/eval_metric.py` 根据配置文件中的评估方式对 pkl 结果文件进行评估。
+
+```shell
+python tools/analysis_tools/eval_metric.py ${CONFIG} ${PKL_RESULTS} [-h] [--format-only] [--eval ${EVAL[EVAL ...]}]
+                      [--cfg-options ${CFG_OPTIONS [CFG_OPTIONS ...]}]
+                      [--eval-options ${EVAL_OPTIONS [EVAL_OPTIONS ...]}]
+```
+
+### 打印全部 config
+
+`tools/misc/print_config.py` 可将所有配置继承关系展开，完全打印相应的配置文件。
+
+```shell
+python tools/misc/print_config.py ${CONFIG} [-h] [--options ${OPTIONS [OPTIONS...]}]
+```
+
+## 超参数优化
+
+### YOLO Anchor 优化
+
+`tools/analysis_tools/optimize_anchors.py` 提供了两种方法优化 YOLO 的 anchors。
+
+其中一种方法使用 K 均值 anchor 聚类（k-means anchor cluster），源自 [darknet](https://github.com/AlexeyAB/darknet/blob/master/src/detector.c#L1421)。
+
+```shell
+python tools/analysis_tools/optimize_anchors.py ${CONFIG} --algorithm k-means --input-shape ${INPUT_SHAPE [WIDTH HEIGHT]} --output-dir ${OUTPUT_DIR}
+```
+
+另一种方法使用差分进化算法优化 anchors。
+
+```shell
+python tools/analysis_tools/optimize_anchors.py ${CONFIG} --algorithm differential_evolution --input-shape ${INPUT_SHAPE [WIDTH HEIGHT]} --output-dir ${OUTPUT_DIR}
+```
+
+样例：
+
+```shell
+python tools/analysis_tools/optimize_anchors.py configs/yolo/yolov3_d53_8xb8-320-273e_coco.py --algorithm differential_evolution --input-shape 608 608 --device cuda --output-dir work_dirs
+```
+
+你可能会看到如下结果：
+
+```
+loading annotations into memory...
+Done (t=9.70s)
+creating index...
+index created!
+2021-07-19 19:37:20,951 - mmdet - INFO - Collecting bboxes from annotation...
+[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 117266/117266, 15874.5 task/s, elapsed: 7s, ETA:     0s
+
+2021-07-19 19:37:28,753 - mmdet - INFO - Collected 849902 bboxes.
+differential_evolution step 1: f(x)= 0.506055
+differential_evolution step 2: f(x)= 0.506055
+......
+
+differential_evolution step 489: f(x)= 0.386625
+2021-07-19 19:46:40,775 - mmdet - INFO Anchor evolution finish. Average IOU: 0.6133754253387451
+2021-07-19 19:46:40,776 - mmdet - INFO Anchor differential evolution result:[[10, 12], [15, 30], [32, 22], [29, 59], [61, 46], [57, 116], [112, 89], [154, 198], [349, 336]]
+2021-07-19 19:46:40,798 - mmdet - INFO Result saved in work_dirs/anchor_optimize_result.json
+```
+
+## 混淆矩阵
+
+混淆矩阵是对检测结果的概览。
+`tools/analysis_tools/confusion_matrix.py` 可对预测结果进行分析，绘制成混淆矩阵表。
+首先，运行 `tools/test.py` 保存 `.pkl` 预测结果。
+之后再运行：
+
+```
+python tools/analysis_tools/confusion_matrix.py ${CONFIG}  ${DETECTION_RESULTS}  ${SAVE_DIR} --show
+```
+
+最后你可以得到如图的混淆矩阵：
+
+![confusion_matrix_example](https://user-images.githubusercontent.com/12907710/140513068-994cdbf4-3a4a-48f0-8fd8-2830d93fd963.png)
+
+## COCO 分离和遮挡实例分割性能评估
+
+对于最先进的目标检测器来说，检测被遮挡的物体仍然是一个挑战。
+我们实现了论文 [A Tri-Layer Plugin to Improve Occluded Detection](https://arxiv.org/abs/2210.10046) 中提出的指标来计算分离和遮挡目标的召回率。
+
+使用此评价指标有两种方法：
+
+### 离线评测
+
+我们提供了一个脚本对存储后的检测结果文件计算指标。
+
+首先，使用 `tools/test.py` 脚本存储检测结果：
+
+```shell
+python tools/test.py ${CONFIG} ${MODEL_PATH} --out results.pkl
+```
+
+然后，运行 `tools/analysis_tools/coco_occluded_separated_recall.py` 脚本来计算分离和遮挡目标的掩码的召回率:
+
+```shell
+python tools/analysis_tools/coco_occluded_separated_recall.py results.pkl --out occluded_separated_recall.json
+```
+
+输出如下：
+
+```
+loading annotations into memory...
+Done (t=0.51s)
+creating index...
+index created!
+processing detection results...
+[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 5000/5000, 109.3 task/s, elapsed: 46s, ETA:     0s
+computing occluded mask recall...
+[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 5550/5550, 780.5 task/s, elapsed: 7s, ETA:     0s
+COCO occluded mask recall: 58.79%
+COCO occluded mask success num: 3263
+computing separated mask recall...
+[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 3522/3522, 778.3 task/s, elapsed: 5s, ETA:     0s
+COCO separated mask recall: 31.94%
+COCO separated mask success num: 1125
+
++-----------+--------+-------------+
+| mask type | recall | num correct |
++-----------+--------+-------------+
+| occluded  | 58.79% | 3263        |
+| separated | 31.94% | 1125        |
++-----------+--------+-------------+
+Evaluation results have been saved to occluded_separated_recall.json.
+```
+
+### 在线评测
+
+我们实现继承自 `CocoMetic` 的 `CocoOccludedSeparatedMetric`。
+要在训练期间评估分离和遮挡掩码的召回率，只需在配置中将 evaluator 类型替换为 `CocoOccludedSeparatedMetric`：
+
+```python
+val_evaluator = dict(
+    type='CocoOccludedSeparatedMetric',  # 修改此处
+    ann_file=data_root + 'annotations/instances_val2017.json',
+    metric=['bbox', 'segm'],
+    format_only=False)
+test_evaluator = val_evaluator
+```
+
+如果您使用了此指标，请引用论文：
+
+```latex
+@article{zhan2022triocc,
+    title={A Tri-Layer Plugin to Improve Occluded Detection},
+    author={Zhan, Guanqi and Xie, Weidi and Zisserman, Andrew},
+    journal={British Machine Vision Conference},
+    year={2022}
+}
+```
diff --git a/mmdetection/docs/zh_cn/user_guides/visualization.md b/mmdetection/docs/zh_cn/user_guides/visualization.md
new file mode 100644
index 00000000..f90ab6d4
--- /dev/null
+++ b/mmdetection/docs/zh_cn/user_guides/visualization.md
@@ -0,0 +1,93 @@
+# 可视化
+
+在阅读本教程之前，建议先阅读 MMEngine 的 [Visualization](https://github.com/open-mmlab/mmengine/blob/main/docs/en/advanced_tutorials/visualization.md) 文档，以对 `Visualizer` 的定义和用法有一个初步的了解。
+
+简而言之，`Visualizer` 在 MMEngine 中实现以满足日常可视化需求，并包含以下三个主要功能：
+
+- 实现通用的绘图 API，例如 [`draw_bboxes`](mmengine.visualization.Visualizer.draw_bboxes) 实现了绘制边界框的功能，[`draw_lines`](mmengine.visualization.Visualizer.draw_lines) 实现了绘制线条的功能。
+- 支持将可视化结果、学习率曲线、损失函数曲线以及验证精度曲线写入到各种后端中，包括本地磁盘以及常见的深度学习训练日志工具，例如 [TensorBoard](https://www.tensorflow.org/tensorboard) 和 [Wandb](https://wandb.ai/site)。
+- 支持在代码的任何位置调用以可视化或记录模型在训练或测试期间的中间状态，例如特征图和验证结果。
+
+基于 MMEngine 的 `Visualizer`，MMDet 提供了各种预构建的可视化工具，用户可以通过简单地修改以下配置文件来使用它们。
+
+- `tools/analysis_tools/browse_dataset.py` 脚本提供了一个数据集可视化功能，可以在数据经过数据转换后绘制图像和相应的注释，具体描述请参见[`browse_dataset.py`](useful_tools.md#Visualization)。
+
+- MMEngine实现了`LoggerHook`，使用`Visualizer`将学习率、损失和评估结果写入由`Visualizer`设置的后端。因此，通过修改配置文件中的`Visualizer`后端，例如修改为`TensorBoardVISBackend`或`WandbVISBackend`，可以实现日志记录到常用的训练日志工具，如`TensorBoard`或`WandB`，从而方便用户使用这些可视化工具来分析和监控训练过程。
+
+- 在MMDet中实现了`VisualizerHook`，它使用`Visualizer`将验证或预测阶段的预测结果可视化或存储到由`Visualizer`设置的后端。因此，通过修改配置文件中的`Visualizer`后端，例如修改为`TensorBoardVISBackend`或`WandbVISBackend`，可以将预测图像存储到`TensorBoard`或`Wandb`中。
+
+## 配置
+
+由于使用了注册机制，在MMDet中我们可以通过修改配置文件来设置`Visualizer`的行为。通常，我们会在`configs/_base_/default_runtime.py`中为可视化器定义默认配置，详细信息请参见[配置教程](config.md)。
+
+```Python
+vis_backends = [dict(type='LocalVisBackend')]
+visualizer = dict(
+    type='DetLocalVisualizer',
+    vis_backends=vis_backends,
+    name='visualizer')
+```
+
+基于上面的例子，我们可以看到`Visualizer`的配置由两个主要部分组成，即`Visualizer`类型和其使用的可视化后端`vis_backends`。
+
+- 用户可直接使用`DetLocalVisualizer`来可视化支持任务的标签或预测结果。
+- MMDet默认将可视化后端`vis_backend`设置为本地可视化后端`LocalVisBackend`，将所有可视化结果和其他训练信息保存在本地文件夹中。
+
+## 存储
+
+MMDet默认使用本地可视化后端[`LocalVisBackend`](mmengine.visualization.LocalVisBackend)，`VisualizerHook`和`LoggerHook`中存储的模型损失、学习率、模型评估精度和可视化信息，包括损失、学习率、评估精度将默认保存到`{work_dir}/{config_name}/{time}/{vis_data}`文件夹中。此外，MMDet还支持其他常见的可视化后端，例如`TensorboardVisBackend`和`WandbVisBackend`，您只需要在配置文件中更改`vis_backends`类型为相应的可视化后端即可。例如，只需在配置文件中插入以下代码块即可将数据存储到`TensorBoard`和`Wandb`中。
+
+```Python
+# https://mmengine.readthedocs.io/en/latest/api/visualization.html
+_base_.visualizer.vis_backends = [
+    dict(type='LocalVisBackend'), #
+    dict(type='TensorboardVisBackend'),
+    dict(type='WandbVisBackend'),]
+```
+
+## 绘图
+
+### 绘制预测结果
+
+MMDet主要使用[`DetVisualizationHook`](mmdet.engine.hooks.DetVisualizationHook)来绘制验证和测试的预测结果，默认情况下`DetVisualizationHook`是关闭的，其默认配置如下。
+
+```Python
+visualization=dict( #用户可视化验证和测试结果
+    type='DetVisualizationHook',
+    draw=False,
+    interval=1,
+    show=False)
+```
+
+以下表格展示了`DetVisualizationHook`支持的参数。
+
+|   参数   |                                       描述                                       |
+| :------: | :------------------------------------------------------------------------------: |
+|   draw   |          DetVisualizationHook通过enable参数打开和关闭，默认状态为关闭。          |
+| interval | 控制在DetVisualizationHook启用时存储或显示验证或测试结果的间隔，单位为迭代次数。 |
+|   show   |                         控制是否可视化验证或测试的结果。                         |
+
+如果您想在训练或测试期间启用 `DetVisualizationHook` 相关功能和配置，您只需要修改配置文件，以 `configs/rtmdet/rtmdet_tiny_8xb32-300e_coco.py` 为例，同时绘制注释和预测，并显示图像，配置文件可以修改如下：
+
+```Python
+visualization = _base_.default_hooks.visualization
+visualization.update(dict(draw=True, show=True))
+```
+
+
    
+
+
    
+
+`test.py`程序提供了`--show`和`--show-dir`参数，可以在测试过程中可视化注释和预测结果，而不需要修改配置文件，从而进一步简化了测试过程。
+
+```Shell
+# 展示测试结果
+python tools/test.py configs/rtmdet/rtmdet_tiny_8xb32-300e_coco.py https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_tiny_8xb32-300e_coco/rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth --show
+
+# 指定存储预测结果的位置
+python tools/test.py configs/rtmdet/rtmdet_tiny_8xb32-300e_coco.py https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_tiny_8xb32-300e_coco/rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth --show-dir imgs/
+```
+
+
    
+
+
    
diff --git a/mmdetection/mmdet/__init__.py b/mmdetection/mmdet/__init__.py
new file mode 100644
index 00000000..3ac884ac
--- /dev/null
+++ b/mmdetection/mmdet/__init__.py
@@ -0,0 +1,27 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import mmcv
+import mmengine
+from mmengine.utils import digit_version
+
+from .version import __version__, version_info
+
+mmcv_minimum_version = '2.0.0rc4'
+mmcv_maximum_version = '2.2.0'
+mmcv_version = digit_version(mmcv.__version__)
+
+mmengine_minimum_version = '0.7.1'
+mmengine_maximum_version = '1.0.0'
+mmengine_version = digit_version(mmengine.__version__)
+
+assert (mmcv_version >= digit_version(mmcv_minimum_version)
+        and mmcv_version < digit_version(mmcv_maximum_version)), \
+    f'MMCV=={mmcv.__version__} is used but incompatible. ' \
+    f'Please install mmcv>={mmcv_minimum_version}, <{mmcv_maximum_version}.'
+
+assert (mmengine_version >= digit_version(mmengine_minimum_version)
+        and mmengine_version < digit_version(mmengine_maximum_version)), \
+    f'MMEngine=={mmengine.__version__} is used but incompatible. ' \
+    f'Please install mmengine>={mmengine_minimum_version}, ' \
+    f'<{mmengine_maximum_version}.'
+
+__all__ = ['__version__', 'version_info', 'digit_version']
diff --git a/mmdetection/mmdet/apis/__init__.py b/mmdetection/mmdet/apis/__init__.py
new file mode 100644
index 00000000..c89dc729
--- /dev/null
+++ b/mmdetection/mmdet/apis/__init__.py
@@ -0,0 +1,9 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .det_inferencer import DetInferencer
+from .inference import (async_inference_detector, inference_detector,
+                        inference_mot, init_detector, init_track_model)
+
+__all__ = [
+    'init_detector', 'async_inference_detector', 'inference_detector',
+    'DetInferencer', 'inference_mot', 'init_track_model'
+]
diff --git a/mmdetection/mmdet/apis/det_inferencer.py b/mmdetection/mmdet/apis/det_inferencer.py
new file mode 100644
index 00000000..ce8532eb
--- /dev/null
+++ b/mmdetection/mmdet/apis/det_inferencer.py
@@ -0,0 +1,652 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import os.path as osp
+import warnings
+from typing import Dict, Iterable, List, Optional, Sequence, Tuple, Union
+
+import mmcv
+import mmengine
+import numpy as np
+import torch.nn as nn
+from mmcv.transforms import LoadImageFromFile
+from mmengine.dataset import Compose
+from mmengine.fileio import (get_file_backend, isdir, join_path,
+                             list_dir_or_file)
+from mmengine.infer.infer import BaseInferencer, ModelType
+from mmengine.model.utils import revert_sync_batchnorm
+from mmengine.registry import init_default_scope
+from mmengine.runner.checkpoint import _load_checkpoint_to_model
+from mmengine.visualization import Visualizer
+from rich.progress import track
+
+from mmdet.evaluation import INSTANCE_OFFSET
+from mmdet.registry import DATASETS
+from mmdet.structures import DetDataSample
+from mmdet.structures.mask import encode_mask_results, mask2bbox
+from mmdet.utils import ConfigType
+from ..evaluation import get_classes
+
+try:
+    from panopticapi.evaluation import VOID
+    from panopticapi.utils import id2rgb
+except ImportError:
+    id2rgb = None
+    VOID = None
+
+InputType = Union[str, np.ndarray]
+InputsType = Union[InputType, Sequence[InputType]]
+PredType = List[DetDataSample]
+ImgType = Union[np.ndarray, Sequence[np.ndarray]]
+
+IMG_EXTENSIONS = ('.jpg', '.jpeg', '.png', '.ppm', '.bmp', '.pgm', '.tif',
+                  '.tiff', '.webp')
+
+
+class DetInferencer(BaseInferencer):
+    """Object Detection Inferencer.
+
+    Args:
+        model (str, optional): Path to the config file or the model name
+            defined in metafile. For example, it could be
+            "rtmdet-s" or 'rtmdet_s_8xb32-300e_coco' or
+            "configs/rtmdet/rtmdet_s_8xb32-300e_coco.py".
+            If model is not specified, user must provide the
+            `weights` saved by MMEngine which contains the config string.
+            Defaults to None.
+        weights (str, optional): Path to the checkpoint. If it is not specified
+            and model is a model name of metafile, the weights will be loaded
+            from metafile. Defaults to None.
+        device (str, optional): Device to run inference. If None, the available
+            device will be automatically used. Defaults to None.
+        scope (str, optional): The scope of the model. Defaults to mmdet.
+        palette (str): Color palette used for visualization. The order of
+            priority is palette -> config -> checkpoint. Defaults to 'none'.
+        show_progress (bool): Control whether to display the progress
+            bar during the inference process. Defaults to True.
+    """
+
+    preprocess_kwargs: set = set()
+    forward_kwargs: set = set()
+    visualize_kwargs: set = {
+        'return_vis',
+        'show',
+        'wait_time',
+        'draw_pred',
+        'pred_score_thr',
+        'img_out_dir',
+        'no_save_vis',
+    }
+    postprocess_kwargs: set = {
+        'print_result',
+        'pred_out_dir',
+        'return_datasamples',
+        'no_save_pred',
+    }
+
+    def __init__(self,
+                 model: Optional[Union[ModelType, str]] = None,
+                 weights: Optional[str] = None,
+                 device: Optional[str] = None,
+                 scope: Optional[str] = 'mmdet',
+                 palette: str = 'none',
+                 show_progress: bool = True) -> None:
+        # A global counter tracking the number of images processed, for
+        # naming of the output images
+        self.num_visualized_imgs = 0
+        self.num_predicted_imgs = 0
+        self.palette = palette
+        init_default_scope(scope)
+        super().__init__(
+            model=model, weights=weights, device=device, scope=scope)
+        self.model = revert_sync_batchnorm(self.model)
+        self.show_progress = show_progress
+
+    def _load_weights_to_model(self, model: nn.Module,
+                               checkpoint: Optional[dict],
+                               cfg: Optional[ConfigType]) -> None:
+        """Loading model weights and meta information from cfg and checkpoint.
+
+        Args:
+            model (nn.Module): Model to load weights and meta information.
+            checkpoint (dict, optional): The loaded checkpoint.
+            cfg (Config or ConfigDict, optional): The loaded config.
+        """
+
+        if checkpoint is not None:
+            _load_checkpoint_to_model(model, checkpoint)
+            checkpoint_meta = checkpoint.get('meta', {})
+            # save the dataset_meta in the model for convenience
+            if 'dataset_meta' in checkpoint_meta:
+                # mmdet 3.x, all keys should be lowercase
+                model.dataset_meta = {
+                    k.lower(): v
+                    for k, v in checkpoint_meta['dataset_meta'].items()
+                }
+            elif 'CLASSES' in checkpoint_meta:
+                # < mmdet 3.x
+                classes = checkpoint_meta['CLASSES']
+                model.dataset_meta = {'classes': classes}
+            else:
+                warnings.warn(
+                    'dataset_meta or class names are not saved in the '
+                    'checkpoint\'s meta data, use COCO classes by default.')
+                model.dataset_meta = {'classes': get_classes('coco')}
+        else:
+            warnings.warn('Checkpoint is not loaded, and the inference '
+                          'result is calculated by the randomly initialized '
+                          'model!')
+            warnings.warn('weights is None, use COCO classes by default.')
+            model.dataset_meta = {'classes': get_classes('coco')}
+
+        # Priority:  args.palette -> config -> checkpoint
+        if self.palette != 'none':
+            model.dataset_meta['palette'] = self.palette
+        else:
+            test_dataset_cfg = copy.deepcopy(cfg.test_dataloader.dataset)
+            # lazy init. We only need the metainfo.
+            test_dataset_cfg['lazy_init'] = True
+            metainfo = DATASETS.build(test_dataset_cfg).metainfo
+            cfg_palette = metainfo.get('palette', None)
+            if cfg_palette is not None:
+                model.dataset_meta['palette'] = cfg_palette
+            else:
+                if 'palette' not in model.dataset_meta:
+                    warnings.warn(
+                        'palette does not exist, random is used by default. '
+                        'You can also set the palette to customize.')
+                    model.dataset_meta['palette'] = 'random'
+
+    def _init_pipeline(self, cfg: ConfigType) -> Compose:
+        """Initialize the test pipeline."""
+        pipeline_cfg = cfg.test_dataloader.dataset.pipeline
+
+        # For inference, the key of ``img_id`` is not used.
+        if 'meta_keys' in pipeline_cfg[-1]:
+            pipeline_cfg[-1]['meta_keys'] = tuple(
+                meta_key for meta_key in pipeline_cfg[-1]['meta_keys']
+                if meta_key != 'img_id')
+
+        load_img_idx = self._get_transform_idx(
+            pipeline_cfg, ('LoadImageFromFile', LoadImageFromFile))
+        if load_img_idx == -1:
+            raise ValueError(
+                'LoadImageFromFile is not found in the test pipeline')
+        pipeline_cfg[load_img_idx]['type'] = 'mmdet.InferencerLoader'
+        return Compose(pipeline_cfg)
+
+    def _get_transform_idx(self, pipeline_cfg: ConfigType,
+                           name: Union[str, Tuple[str, type]]) -> int:
+        """Returns the index of the transform in a pipeline.
+
+        If the transform is not found, returns -1.
+        """
+        for i, transform in enumerate(pipeline_cfg):
+            if transform['type'] in name:
+                return i
+        return -1
+
+    def _init_visualizer(self, cfg: ConfigType) -> Optional[Visualizer]:
+        """Initialize visualizers.
+
+        Args:
+            cfg (ConfigType): Config containing the visualizer information.
+
+        Returns:
+            Visualizer or None: Visualizer initialized with config.
+        """
+        visualizer = super()._init_visualizer(cfg)
+        visualizer.dataset_meta = self.model.dataset_meta
+        return visualizer
+
+    def _inputs_to_list(self, inputs: InputsType) -> list:
+        """Preprocess the inputs to a list.
+
+        Preprocess inputs to a list according to its type:
+
+        - list or tuple: return inputs
+        - str:
+            - Directory path: return all files in the directory
+            - other cases: return a list containing the string. The string
+              could be a path to file, a url or other types of string according
+              to the task.
+
+        Args:
+            inputs (InputsType): Inputs for the inferencer.
+
+        Returns:
+            list: List of input for the :meth:`preprocess`.
+        """
+        if isinstance(inputs, str):
+            backend = get_file_backend(inputs)
+            if hasattr(backend, 'isdir') and isdir(inputs):
+                # Backends like HttpsBackend do not implement `isdir`, so only
+                # those backends that implement `isdir` could accept the inputs
+                # as a directory
+                filename_list = list_dir_or_file(
+                    inputs, list_dir=False, suffix=IMG_EXTENSIONS)
+                inputs = [
+                    join_path(inputs, filename) for filename in filename_list
+                ]
+
+        if not isinstance(inputs, (list, tuple)):
+            inputs = [inputs]
+
+        return list(inputs)
+
+    def preprocess(self, inputs: InputsType, batch_size: int = 1, **kwargs):
+        """Process the inputs into a model-feedable format.
+
+        Customize your preprocess by overriding this method. Preprocess should
+        return an iterable object, of which each item will be used as the
+        input of ``model.test_step``.
+
+        ``BaseInferencer.preprocess`` will return an iterable chunked data,
+        which will be used in __call__ like this:
+
+        .. code-block:: python
+
+            def __call__(self, inputs, batch_size=1, **kwargs):
+                chunked_data = self.preprocess(inputs, batch_size, **kwargs)
+                for batch in chunked_data:
+                    preds = self.forward(batch, **kwargs)
+
+        Args:
+            inputs (InputsType): Inputs given by user.
+            batch_size (int): batch size. Defaults to 1.
+
+        Yields:
+            Any: Data processed by the ``pipeline`` and ``collate_fn``.
+        """
+        chunked_data = self._get_chunk_data(inputs, batch_size)
+        yield from map(self.collate_fn, chunked_data)
+
+    def _get_chunk_data(self, inputs: Iterable, chunk_size: int):
+        """Get batch data from inputs.
+
+        Args:
+            inputs (Iterable): An iterable dataset.
+            chunk_size (int): Equivalent to batch size.
+
+        Yields:
+            list: batch data.
+        """
+        inputs_iter = iter(inputs)
+        while True:
+            try:
+                chunk_data = []
+                for _ in range(chunk_size):
+                    inputs_ = next(inputs_iter)
+                    if isinstance(inputs_, dict):
+                        if 'img' in inputs_:
+                            ori_inputs_ = inputs_['img']
+                        else:
+                            ori_inputs_ = inputs_['img_path']
+                        chunk_data.append(
+                            (ori_inputs_,
+                             self.pipeline(copy.deepcopy(inputs_))))
+                    else:
+                        chunk_data.append((inputs_, self.pipeline(inputs_)))
+                yield chunk_data
+            except StopIteration:
+                if chunk_data:
+                    yield chunk_data
+                break
+
+    # TODO: Video and Webcam are currently not supported and
+    #  may consume too much memory if your input folder has a lot of images.
+    #  We will be optimized later.
+    def __call__(
+            self,
+            inputs: InputsType,
+            batch_size: int = 1,
+            return_vis: bool = False,
+            show: bool = False,
+            wait_time: int = 0,
+            no_save_vis: bool = False,
+            draw_pred: bool = True,
+            pred_score_thr: float = 0.3,
+            return_datasamples: bool = False,
+            print_result: bool = False,
+            no_save_pred: bool = True,
+            out_dir: str = '',
+            # by open image task
+            texts: Optional[Union[str, list]] = None,
+            # by open panoptic task
+            stuff_texts: Optional[Union[str, list]] = None,
+            # by GLIP and Grounding DINO
+            custom_entities: bool = False,
+            # by Grounding DINO
+            tokens_positive: Optional[Union[int, list]] = None,
+            **kwargs) -> dict:
+        """Call the inferencer.
+
+        Args:
+            inputs (InputsType): Inputs for the inferencer.
+            batch_size (int): Inference batch size. Defaults to 1.
+            show (bool): Whether to display the visualization results in a
+                popup window. Defaults to False.
+            wait_time (float): The interval of show (s). Defaults to 0.
+            no_save_vis (bool): Whether to force not to save prediction
+                vis results. Defaults to False.
+            draw_pred (bool): Whether to draw predicted bounding boxes.
+                Defaults to True.
+            pred_score_thr (float): Minimum score of bboxes to draw.
+                Defaults to 0.3.
+            return_datasamples (bool): Whether to return results as
+                :obj:`DetDataSample`. Defaults to False.
+            print_result (bool): Whether to print the inference result w/o
+                visualization to the console. Defaults to False.
+            no_save_pred (bool): Whether to force not to save prediction
+                results. Defaults to True.
+            out_dir: Dir to save the inference results or
+                visualization. If left as empty, no file will be saved.
+                Defaults to ''.
+            texts (str | list[str]): Text prompts. Defaults to None.
+            stuff_texts (str | list[str]): Stuff text prompts of open
+                panoptic task. Defaults to None.
+            custom_entities (bool): Whether to use custom entities.
+                Defaults to False. Only used in GLIP and Grounding DINO.
+            **kwargs: Other keyword arguments passed to :meth:`preprocess`,
+                :meth:`forward`, :meth:`visualize` and :meth:`postprocess`.
+                Each key in kwargs should be in the corresponding set of
+                ``preprocess_kwargs``, ``forward_kwargs``, ``visualize_kwargs``
+                and ``postprocess_kwargs``.
+
+        Returns:
+            dict: Inference and visualization results.
+        """
+        (
+            preprocess_kwargs,
+            forward_kwargs,
+            visualize_kwargs,
+            postprocess_kwargs,
+        ) = self._dispatch_kwargs(**kwargs)
+
+        ori_inputs = self._inputs_to_list(inputs)
+
+        if texts is not None and isinstance(texts, str):
+            texts = [texts] * len(ori_inputs)
+        if stuff_texts is not None and isinstance(stuff_texts, str):
+            stuff_texts = [stuff_texts] * len(ori_inputs)
+
+        # Currently only supports bs=1
+        tokens_positive = [tokens_positive] * len(ori_inputs)
+
+        if texts is not None:
+            assert len(texts) == len(ori_inputs)
+            for i in range(len(texts)):
+                if isinstance(ori_inputs[i], str):
+                    ori_inputs[i] = {
+                        'text': texts[i],
+                        'img_path': ori_inputs[i],
+                        'custom_entities': custom_entities,
+                        'tokens_positive': tokens_positive[i]
+                    }
+                else:
+                    ori_inputs[i] = {
+                        'text': texts[i],
+                        'img': ori_inputs[i],
+                        'custom_entities': custom_entities,
+                        'tokens_positive': tokens_positive[i]
+                    }
+        if stuff_texts is not None:
+            assert len(stuff_texts) == len(ori_inputs)
+            for i in range(len(stuff_texts)):
+                ori_inputs[i]['stuff_text'] = stuff_texts[i]
+
+        inputs = self.preprocess(
+            ori_inputs, batch_size=batch_size, **preprocess_kwargs)
+
+        results_dict = {'predictions': [], 'visualization': []}
+        for ori_imgs, data in (track(inputs, description='Inference')
+                               if self.show_progress else inputs):
+            preds = self.forward(data, **forward_kwargs)
+            visualization = self.visualize(
+                ori_imgs,
+                preds,
+                return_vis=return_vis,
+                show=show,
+                wait_time=wait_time,
+                draw_pred=draw_pred,
+                pred_score_thr=pred_score_thr,
+                no_save_vis=no_save_vis,
+                img_out_dir=out_dir,
+                **visualize_kwargs)
+            results = self.postprocess(
+                preds,
+                visualization,
+                return_datasamples=return_datasamples,
+                print_result=print_result,
+                no_save_pred=no_save_pred,
+                pred_out_dir=out_dir,
+                **postprocess_kwargs)
+            results_dict['predictions'].extend(results['predictions'])
+            if results['visualization'] is not None:
+                results_dict['visualization'].extend(results['visualization'])
+        return results_dict
+
+    def visualize(self,
+                  inputs: InputsType,
+                  preds: PredType,
+                  return_vis: bool = False,
+                  show: bool = False,
+                  wait_time: int = 0,
+                  draw_pred: bool = True,
+                  pred_score_thr: float = 0.3,
+                  no_save_vis: bool = False,
+                  img_out_dir: str = '',
+                  **kwargs) -> Union[List[np.ndarray], None]:
+        """Visualize predictions.
+
+        Args:
+            inputs (List[Union[str, np.ndarray]]): Inputs for the inferencer.
+            preds (List[:obj:`DetDataSample`]): Predictions of the model.
+            return_vis (bool): Whether to return the visualization result.
+                Defaults to False.
+            show (bool): Whether to display the image in a popup window.
+                Defaults to False.
+            wait_time (float): The interval of show (s). Defaults to 0.
+            draw_pred (bool): Whether to draw predicted bounding boxes.
+                Defaults to True.
+            pred_score_thr (float): Minimum score of bboxes to draw.
+                Defaults to 0.3.
+            no_save_vis (bool): Whether to force not to save prediction
+                vis results. Defaults to False.
+            img_out_dir (str): Output directory of visualization results.
+                If left as empty, no file will be saved. Defaults to ''.
+
+        Returns:
+            List[np.ndarray] or None: Returns visualization results only if
+            applicable.
+        """
+        if no_save_vis is True:
+            img_out_dir = ''
+
+        if not show and img_out_dir == '' and not return_vis:
+            return None
+
+        if self.visualizer is None:
+            raise ValueError('Visualization needs the "visualizer" term'
+                             'defined in the config, but got None.')
+
+        results = []
+
+        for single_input, pred in zip(inputs, preds):
+            if isinstance(single_input, str):
+                img_bytes = mmengine.fileio.get(single_input)
+                img = mmcv.imfrombytes(img_bytes)
+                img = img[:, :, ::-1]
+                img_name = osp.basename(single_input)
+            elif isinstance(single_input, np.ndarray):
+                img = single_input.copy()
+                img_num = str(self.num_visualized_imgs).zfill(8)
+                img_name = f'{img_num}.jpg'
+            else:
+                raise ValueError('Unsupported input type: '
+                                 f'{type(single_input)}')
+
+            out_file = osp.join(img_out_dir, 'vis',
+                                img_name) if img_out_dir != '' else None
+
+            self.visualizer.add_datasample(
+                img_name,
+                img,
+                pred,
+                show=show,
+                wait_time=wait_time,
+                draw_gt=False,
+                draw_pred=draw_pred,
+                pred_score_thr=pred_score_thr,
+                out_file=out_file,
+            )
+            results.append(self.visualizer.get_image())
+            self.num_visualized_imgs += 1
+
+        return results
+
+    def postprocess(
+        self,
+        preds: PredType,
+        visualization: Optional[List[np.ndarray]] = None,
+        return_datasamples: bool = False,
+        print_result: bool = False,
+        no_save_pred: bool = False,
+        pred_out_dir: str = '',
+        **kwargs,
+    ) -> Dict:
+        """Process the predictions and visualization results from ``forward``
+        and ``visualize``.
+
+        This method should be responsible for the following tasks:
+
+        1. Convert datasamples into a json-serializable dict if needed.
+        2. Pack the predictions and visualization results and return them.
+        3. Dump or log the predictions.
+
+        Args:
+            preds (List[:obj:`DetDataSample`]): Predictions of the model.
+            visualization (Optional[np.ndarray]): Visualized predictions.
+            return_datasamples (bool): Whether to use Datasample to store
+                inference results. If False, dict will be used.
+            print_result (bool): Whether to print the inference result w/o
+                visualization to the console. Defaults to False.
+            no_save_pred (bool): Whether to force not to save prediction
+                results. Defaults to False.
+            pred_out_dir: Dir to save the inference results w/o
+                visualization. If left as empty, no file will be saved.
+                Defaults to ''.
+
+        Returns:
+            dict: Inference and visualization results with key ``predictions``
+            and ``visualization``.
+
+            - ``visualization`` (Any): Returned by :meth:`visualize`.
+            - ``predictions`` (dict or DataSample): Returned by
+                :meth:`forward` and processed in :meth:`postprocess`.
+                If ``return_datasamples=False``, it usually should be a
+                json-serializable dict containing only basic data elements such
+                as strings and numbers.
+        """
+        if no_save_pred is True:
+            pred_out_dir = ''
+
+        result_dict = {}
+        results = preds
+        if not return_datasamples:
+            results = []
+            for pred in preds:
+                result = self.pred2dict(pred, pred_out_dir)
+                results.append(result)
+        elif pred_out_dir != '':
+            warnings.warn('Currently does not support saving datasample '
+                          'when return_datasamples is set to True. '
+                          'Prediction results are not saved!')
+        # Add img to the results after printing and dumping
+        result_dict['predictions'] = results
+        if print_result:
+            print(result_dict)
+        result_dict['visualization'] = visualization
+        return result_dict
+
+    # TODO: The data format and fields saved in json need further discussion.
+    #  Maybe should include model name, timestamp, filename, image info etc.
+    def pred2dict(self,
+                  data_sample: DetDataSample,
+                  pred_out_dir: str = '') -> Dict:
+        """Extract elements necessary to represent a prediction into a
+        dictionary.
+
+        It's better to contain only basic data elements such as strings and
+        numbers in order to guarantee it's json-serializable.
+
+        Args:
+            data_sample (:obj:`DetDataSample`): Predictions of the model.
+            pred_out_dir: Dir to save the inference results w/o
+                visualization. If left as empty, no file will be saved.
+                Defaults to ''.
+
+        Returns:
+            dict: Prediction results.
+        """
+        is_save_pred = True
+        if pred_out_dir == '':
+            is_save_pred = False
+
+        if is_save_pred and 'img_path' in data_sample:
+            img_path = osp.basename(data_sample.img_path)
+            img_path = osp.splitext(img_path)[0]
+            out_img_path = osp.join(pred_out_dir, 'preds',
+                                    img_path + '_panoptic_seg.png')
+            out_json_path = osp.join(pred_out_dir, 'preds', img_path + '.json')
+        elif is_save_pred:
+            out_img_path = osp.join(
+                pred_out_dir, 'preds',
+                f'{self.num_predicted_imgs}_panoptic_seg.png')
+            out_json_path = osp.join(pred_out_dir, 'preds',
+                                     f'{self.num_predicted_imgs}.json')
+            self.num_predicted_imgs += 1
+
+        result = {}
+        if 'pred_instances' in data_sample:
+            masks = data_sample.pred_instances.get('masks')
+            pred_instances = data_sample.pred_instances.numpy()
+            result = {
+                'labels': pred_instances.labels.tolist(),
+                'scores': pred_instances.scores.tolist()
+            }
+            if 'bboxes' in pred_instances:
+                result['bboxes'] = pred_instances.bboxes.tolist()
+            if masks is not None:
+                if 'bboxes' not in pred_instances or pred_instances.bboxes.sum(
+                ) == 0:
+                    # Fake bbox, such as the SOLO.
+                    bboxes = mask2bbox(masks.cpu()).numpy().tolist()
+                    result['bboxes'] = bboxes
+                encode_masks = encode_mask_results(pred_instances.masks)
+                for encode_mask in encode_masks:
+                    if isinstance(encode_mask['counts'], bytes):
+                        encode_mask['counts'] = encode_mask['counts'].decode()
+                result['masks'] = encode_masks
+
+        if 'pred_panoptic_seg' in data_sample:
+            if VOID is None:
+                raise RuntimeError(
+                    'panopticapi is not installed, please install it by: '
+                    'pip install git+https://github.com/cocodataset/'
+                    'panopticapi.git.')
+
+            pan = data_sample.pred_panoptic_seg.sem_seg.cpu().numpy()[0]
+            pan[pan % INSTANCE_OFFSET == len(
+                self.model.dataset_meta['classes'])] = VOID
+            pan = id2rgb(pan).astype(np.uint8)
+
+            if is_save_pred:
+                mmcv.imwrite(pan[:, :, ::-1], out_img_path)
+                result['panoptic_seg_path'] = out_img_path
+            else:
+                result['panoptic_seg'] = pan
+
+        if is_save_pred:
+            mmengine.dump(result, out_json_path)
+
+        return result
diff --git a/mmdetection/mmdet/apis/inference.py b/mmdetection/mmdet/apis/inference.py
new file mode 100644
index 00000000..7e6f914e
--- /dev/null
+++ b/mmdetection/mmdet/apis/inference.py
@@ -0,0 +1,372 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import warnings
+from pathlib import Path
+from typing import Optional, Sequence, Union
+
+import numpy as np
+import torch
+import torch.nn as nn
+from mmcv.ops import RoIPool
+from mmcv.transforms import Compose
+from mmengine.config import Config
+from mmengine.dataset import default_collate
+from mmengine.model.utils import revert_sync_batchnorm
+from mmengine.registry import init_default_scope
+from mmengine.runner import load_checkpoint
+
+from mmdet.registry import DATASETS
+from mmdet.utils import ConfigType
+from ..evaluation import get_classes
+from ..registry import MODELS
+from ..structures import DetDataSample, SampleList
+from ..utils import get_test_pipeline_cfg
+
+
+def init_detector(
+    config: Union[str, Path, Config],
+    checkpoint: Optional[str] = None,
+    palette: str = 'none',
+    device: str = 'cuda:0',
+    cfg_options: Optional[dict] = None,
+) -> nn.Module:
+    """Initialize a detector from config file.
+
+    Args:
+        config (str, :obj:`Path`, or :obj:`mmengine.Config`): Config file path,
+            :obj:`Path`, or the config object.
+        checkpoint (str, optional): Checkpoint path. If left as None, the model
+            will not load any weights.
+        palette (str): Color palette used for visualization. If palette
+            is stored in checkpoint, use checkpoint's palette first, otherwise
+            use externally passed palette. Currently, supports 'coco', 'voc',
+            'citys' and 'random'. Defaults to none.
+        device (str): The device where the anchors will be put on.
+            Defaults to cuda:0.
+        cfg_options (dict, optional): Options to override some settings in
+            the used config.
+
+    Returns:
+        nn.Module: The constructed detector.
+    """
+    if isinstance(config, (str, Path)):
+        config = Config.fromfile(config)
+    elif not isinstance(config, Config):
+        raise TypeError('config must be a filename or Config object, '
+                        f'but got {type(config)}')
+    if cfg_options is not None:
+        config.merge_from_dict(cfg_options)
+    elif 'init_cfg' in config.model.backbone:
+        config.model.backbone.init_cfg = None
+
+    scope = config.get('default_scope', 'mmdet')
+    if scope is not None:
+        init_default_scope(config.get('default_scope', 'mmdet'))
+
+    model = MODELS.build(config.model)
+    model = revert_sync_batchnorm(model)
+    if checkpoint is None:
+        warnings.simplefilter('once')
+        warnings.warn('checkpoint is None, use COCO classes by default.')
+        model.dataset_meta = {'classes': get_classes('coco')}
+    else:
+        checkpoint = load_checkpoint(model, checkpoint, map_location='cpu')
+        # Weights converted from elsewhere may not have meta fields.
+        checkpoint_meta = checkpoint.get('meta', {})
+
+        # save the dataset_meta in the model for convenience
+        if 'dataset_meta' in checkpoint_meta:
+            # mmdet 3.x, all keys should be lowercase
+            model.dataset_meta = {
+                k.lower(): v
+                for k, v in checkpoint_meta['dataset_meta'].items()
+            }
+        elif 'CLASSES' in checkpoint_meta:
+            # < mmdet 3.x
+            classes = checkpoint_meta['CLASSES']
+            model.dataset_meta = {'classes': classes}
+        else:
+            warnings.simplefilter('once')
+            warnings.warn(
+                'dataset_meta or class names are not saved in the '
+                'checkpoint\'s meta data, use COCO classes by default.')
+            model.dataset_meta = {'classes': get_classes('coco')}
+
+    # Priority:  args.palette -> config -> checkpoint
+    if palette != 'none':
+        model.dataset_meta['palette'] = palette
+    else:
+        test_dataset_cfg = copy.deepcopy(config.test_dataloader.dataset)
+        # lazy init. We only need the metainfo.
+        test_dataset_cfg['lazy_init'] = True
+        metainfo = DATASETS.build(test_dataset_cfg).metainfo
+        cfg_palette = metainfo.get('palette', None)
+        if cfg_palette is not None:
+            model.dataset_meta['palette'] = cfg_palette
+        else:
+            if 'palette' not in model.dataset_meta:
+                warnings.warn(
+                    'palette does not exist, random is used by default. '
+                    'You can also set the palette to customize.')
+                model.dataset_meta['palette'] = 'random'
+
+    model.cfg = config  # save the config in the model for convenience
+    model.to(device)
+    model.eval()
+    return model
+
+
+ImagesType = Union[str, np.ndarray, Sequence[str], Sequence[np.ndarray]]
+
+
+def inference_detector(
+    model: nn.Module,
+    imgs: ImagesType,
+    test_pipeline: Optional[Compose] = None,
+    text_prompt: Optional[str] = None,
+    custom_entities: bool = False,
+) -> Union[DetDataSample, SampleList]:
+    """Inference image(s) with the detector.
+
+    Args:
+        model (nn.Module): The loaded detector.
+        imgs (str, ndarray, Sequence[str/ndarray]):
+           Either image files or loaded images.
+        test_pipeline (:obj:`Compose`): Test pipeline.
+
+    Returns:
+        :obj:`DetDataSample` or list[:obj:`DetDataSample`]:
+        If imgs is a list or tuple, the same length list type results
+        will be returned, otherwise return the detection results directly.
+    """
+
+    if isinstance(imgs, (list, tuple)):
+        is_batch = True
+    else:
+        imgs = [imgs]
+        is_batch = False
+
+    cfg = model.cfg
+
+    if test_pipeline is None:
+        cfg = cfg.copy()
+        test_pipeline = get_test_pipeline_cfg(cfg)
+        if isinstance(imgs[0], np.ndarray):
+            # Calling this method across libraries will result
+            # in module unregistered error if not prefixed with mmdet.
+            test_pipeline[0].type = 'mmdet.LoadImageFromNDArray'
+
+        test_pipeline = Compose(test_pipeline)
+
+    if model.data_preprocessor.device.type == 'cpu':
+        for m in model.modules():
+            assert not isinstance(
+                m, RoIPool
+            ), 'CPU inference with RoIPool is not supported currently.'
+
+    result_list = []
+    for i, img in enumerate(imgs):
+        # prepare data
+        if isinstance(img, np.ndarray):
+            # TODO: remove img_id.
+            data_ = dict(img=img, img_id=0)
+        else:
+            # TODO: remove img_id.
+            data_ = dict(img_path=img, img_id=0)
+
+        if text_prompt:
+            data_['text'] = text_prompt
+            data_['custom_entities'] = custom_entities
+
+        # build the data pipeline
+        data_ = test_pipeline(data_)
+
+        data_['inputs'] = [data_['inputs']]
+        data_['data_samples'] = [data_['data_samples']]
+
+        # forward the model
+        with torch.no_grad():
+            results = model.test_step(data_)[0]
+
+        result_list.append(results)
+
+    if not is_batch:
+        return result_list[0]
+    else:
+        return result_list
+
+
+# TODO: Awaiting refactoring
+async def async_inference_detector(model, imgs):
+    """Async inference image(s) with the detector.
+
+    Args:
+        model (nn.Module): The loaded detector.
+        img (str | ndarray): Either image files or loaded images.
+
+    Returns:
+        Awaitable detection results.
+    """
+    if not isinstance(imgs, (list, tuple)):
+        imgs = [imgs]
+
+    cfg = model.cfg
+
+    if isinstance(imgs[0], np.ndarray):
+        cfg = cfg.copy()
+        # set loading pipeline type
+        cfg.data.test.pipeline[0].type = 'LoadImageFromNDArray'
+
+    # cfg.data.test.pipeline = replace_ImageToTensor(cfg.data.test.pipeline)
+    test_pipeline = Compose(cfg.data.test.pipeline)
+
+    datas = []
+    for img in imgs:
+        # prepare data
+        if isinstance(img, np.ndarray):
+            # directly add img
+            data = dict(img=img)
+        else:
+            # add information into dict
+            data = dict(img_info=dict(filename=img), img_prefix=None)
+        # build the data pipeline
+        data = test_pipeline(data)
+        datas.append(data)
+
+    for m in model.modules():
+        assert not isinstance(
+            m,
+            RoIPool), 'CPU inference with RoIPool is not supported currently.'
+
+    # We don't restore `torch.is_grad_enabled()` value during concurrent
+    # inference since execution can overlap
+    torch.set_grad_enabled(False)
+    results = await model.aforward_test(data, rescale=True)
+    return results
+
+
+def build_test_pipeline(cfg: ConfigType) -> ConfigType:
+    """Build test_pipeline for mot/vis demo. In mot/vis infer, original
+    test_pipeline should remove the "LoadImageFromFile" and
+    "LoadTrackAnnotations".
+
+    Args:
+         cfg (ConfigDict): The loaded config.
+    Returns:
+         ConfigType: new test_pipeline
+    """
+    # remove the "LoadImageFromFile" and "LoadTrackAnnotations" in pipeline
+    transform_broadcaster = cfg.test_dataloader.dataset.pipeline[0].copy()
+    for transform in transform_broadcaster['transforms']:
+        if transform['type'] == 'Resize':
+            transform_broadcaster['transforms'] = transform
+    pack_track_inputs = cfg.test_dataloader.dataset.pipeline[-1].copy()
+    test_pipeline = Compose([transform_broadcaster, pack_track_inputs])
+
+    return test_pipeline
+
+
+def inference_mot(model: nn.Module, img: np.ndarray, frame_id: int,
+                  video_len: int) -> SampleList:
+    """Inference image(s) with the mot model.
+
+    Args:
+        model (nn.Module): The loaded mot model.
+        img (np.ndarray): Loaded image.
+        frame_id (int): frame id.
+        video_len (int): demo video length
+    Returns:
+        SampleList: The tracking data samples.
+    """
+    cfg = model.cfg
+    data = dict(
+        img=[img.astype(np.float32)],
+        frame_id=[frame_id],
+        ori_shape=[img.shape[:2]],
+        img_id=[frame_id + 1],
+        ori_video_length=[video_len])
+
+    test_pipeline = build_test_pipeline(cfg)
+    data = test_pipeline(data)
+
+    if not next(model.parameters()).is_cuda:
+        for m in model.modules():
+            assert not isinstance(
+                m, RoIPool
+            ), 'CPU inference with RoIPool is not supported currently.'
+
+    # forward the model
+    with torch.no_grad():
+        data = default_collate([data])
+        result = model.test_step(data)[0]
+    return result
+
+
+def init_track_model(config: Union[str, Config],
+                     checkpoint: Optional[str] = None,
+                     detector: Optional[str] = None,
+                     reid: Optional[str] = None,
+                     device: str = 'cuda:0',
+                     cfg_options: Optional[dict] = None) -> nn.Module:
+    """Initialize a model from config file.
+
+    Args:
+        config (str or :obj:`mmengine.Config`): Config file path or the config
+            object.
+        checkpoint (Optional[str], optional): Checkpoint path. Defaults to
+            None.
+        detector (Optional[str], optional): Detector Checkpoint path, use in
+            some tracking algorithms like sort.  Defaults to None.
+        reid (Optional[str], optional): Reid checkpoint path. use in
+            some tracking algorithms like sort. Defaults to None.
+        device (str, optional): The device that the model inferences on.
+            Defaults to `cuda:0`.
+        cfg_options (Optional[dict], optional): Options to override some
+            settings in the used config. Defaults to None.
+
+    Returns:
+        nn.Module: The constructed model.
+    """
+    if isinstance(config, str):
+        config = Config.fromfile(config)
+    elif not isinstance(config, Config):
+        raise TypeError('config must be a filename or Config object, '
+                        f'but got {type(config)}')
+    if cfg_options is not None:
+        config.merge_from_dict(cfg_options)
+
+    model = MODELS.build(config.model)
+
+    if checkpoint is not None:
+        checkpoint = load_checkpoint(model, checkpoint, map_location='cpu')
+        # Weights converted from elsewhere may not have meta fields.
+        checkpoint_meta = checkpoint.get('meta', {})
+        # save the dataset_meta in the model for convenience
+        if 'dataset_meta' in checkpoint_meta:
+            if 'CLASSES' in checkpoint_meta['dataset_meta']:
+                value = checkpoint_meta['dataset_meta'].pop('CLASSES')
+                checkpoint_meta['dataset_meta']['classes'] = value
+            model.dataset_meta = checkpoint_meta['dataset_meta']
+
+    if detector is not None:
+        assert not (checkpoint and detector), \
+            'Error: checkpoint and detector checkpoint cannot both exist'
+        load_checkpoint(model.detector, detector, map_location='cpu')
+
+    if reid is not None:
+        assert not (checkpoint and reid), \
+            'Error: checkpoint and reid checkpoint cannot both exist'
+        load_checkpoint(model.reid, reid, map_location='cpu')
+
+    # Some methods don't load checkpoints or checkpoints don't contain
+    # 'dataset_meta'
+    # VIS need dataset_meta, MOT don't need dataset_meta
+    if not hasattr(model, 'dataset_meta'):
+        warnings.warn('dataset_meta or class names are missed, '
+                      'use None by default.')
+        model.dataset_meta = {'classes': None}
+
+    model.cfg = config  # save the config in the model for convenience
+    model.to(device)
+    model.eval()
+    return model
diff --git a/mmdetection/mmdet/configs/_base_/datasets/coco_detection.py b/mmdetection/mmdet/configs/_base_/datasets/coco_detection.py
new file mode 100644
index 00000000..45041f6d
--- /dev/null
+++ b/mmdetection/mmdet/configs/_base_/datasets/coco_detection.py
@@ -0,0 +1,104 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.transforms import LoadImageFromFile
+from mmengine.dataset.sampler import DefaultSampler
+
+from mmdet.datasets import AspectRatioBatchSampler, CocoDataset
+from mmdet.datasets.transforms import (LoadAnnotations, PackDetInputs,
+                                       RandomFlip, Resize)
+from mmdet.evaluation import CocoMetric
+
+# dataset settings
+dataset_type = CocoDataset
+data_root = 'data/coco/'
+
+# Example to use different file client
+# Method 1: simply set the data root and let the file I/O module
+# automatically infer from prefix (not support LMDB and Memcache yet)
+
+# data_root = 's3://openmmlab/datasets/detection/coco/'
+
+# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6
+# backend_args = dict(
+#     backend='petrel',
+#     path_mapping=dict({
+#         './data/': 's3://openmmlab/datasets/detection/',
+#         'data/': 's3://openmmlab/datasets/detection/'
+#     }))
+backend_args = None
+
+train_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=LoadAnnotations, with_bbox=True),
+    dict(type=Resize, scale=(1333, 800), keep_ratio=True),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=PackDetInputs)
+]
+test_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=Resize, scale=(1333, 800), keep_ratio=True),
+    # If you don't have a gt annotation, delete the pipeline
+    dict(type=LoadAnnotations, with_bbox=True),
+    dict(
+        type=PackDetInputs,
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type=DefaultSampler, shuffle=True),
+    batch_sampler=dict(type=AspectRatioBatchSampler),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='annotations/instances_train2017.json',
+        data_prefix=dict(img='train2017/'),
+        filter_cfg=dict(filter_empty_gt=True, min_size=32),
+        pipeline=train_pipeline,
+        backend_args=backend_args))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type=DefaultSampler, shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='annotations/instances_val2017.json',
+        data_prefix=dict(img='val2017/'),
+        test_mode=True,
+        pipeline=test_pipeline,
+        backend_args=backend_args))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(
+    type=CocoMetric,
+    ann_file=data_root + 'annotations/instances_val2017.json',
+    metric='bbox',
+    format_only=False,
+    backend_args=backend_args)
+test_evaluator = val_evaluator
+
+# inference on test dataset and
+# format the output results for submission.
+# test_dataloader = dict(
+#     batch_size=1,
+#     num_workers=2,
+#     persistent_workers=True,
+#     drop_last=False,
+#     sampler=dict(type=DefaultSampler, shuffle=False),
+#     dataset=dict(
+#         type=dataset_type,
+#         data_root=data_root,
+#         ann_file=data_root + 'annotations/image_info_test-dev2017.json',
+#         data_prefix=dict(img='test2017/'),
+#         test_mode=True,
+#         pipeline=test_pipeline))
+# test_evaluator = dict(
+#     type=CocoMetric,
+#     metric='bbox',
+#     format_only=True,
+#     ann_file=data_root + 'annotations/image_info_test-dev2017.json',
+#     outfile_prefix='./work_dirs/coco_detection/test')
diff --git a/mmdetection/mmdet/configs/_base_/datasets/coco_instance.py b/mmdetection/mmdet/configs/_base_/datasets/coco_instance.py
new file mode 100644
index 00000000..b9575432
--- /dev/null
+++ b/mmdetection/mmdet/configs/_base_/datasets/coco_instance.py
@@ -0,0 +1,106 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.transforms.loading import LoadImageFromFile
+from mmengine.dataset.sampler import DefaultSampler
+
+from mmdet.datasets.coco import CocoDataset
+from mmdet.datasets.samplers.batch_sampler import AspectRatioBatchSampler
+from mmdet.datasets.transforms.formatting import PackDetInputs
+from mmdet.datasets.transforms.loading import LoadAnnotations
+from mmdet.datasets.transforms.transforms import RandomFlip, Resize
+from mmdet.evaluation.metrics.coco_metric import CocoMetric
+
+# dataset settings
+dataset_type = 'CocoDataset'
+data_root = 'data/coco/'
+
+# Example to use different file client
+# Method 1: simply set the data root and let the file I/O module
+# automatically infer from prefix (not support LMDB and Memcache yet)
+
+# data_root = 's3://openmmlab/datasets/detection/coco/'
+
+# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6
+# backend_args = dict(
+#     backend='petrel',
+#     path_mapping=dict({
+#         './data/': 's3://openmmlab/datasets/detection/',
+#         'data/': 's3://openmmlab/datasets/detection/'
+#     }))
+backend_args = None
+
+train_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=LoadAnnotations, with_bbox=True, with_mask=True),
+    dict(type=Resize, scale=(1333, 800), keep_ratio=True),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=PackDetInputs)
+]
+test_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=Resize, scale=(1333, 800), keep_ratio=True),
+    # If you don't have a gt annotation, delete the pipeline
+    dict(type=LoadAnnotations, with_bbox=True, with_mask=True),
+    dict(
+        type=PackDetInputs,
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type=DefaultSampler, shuffle=True),
+    batch_sampler=dict(type=AspectRatioBatchSampler),
+    dataset=dict(
+        type=CocoDataset,
+        data_root=data_root,
+        ann_file='annotations/instances_train2017.json',
+        data_prefix=dict(img='train2017/'),
+        filter_cfg=dict(filter_empty_gt=True, min_size=32),
+        pipeline=train_pipeline,
+        backend_args=backend_args))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type=DefaultSampler, shuffle=False),
+    dataset=dict(
+        type=CocoDataset,
+        data_root=data_root,
+        ann_file='annotations/instances_val2017.json',
+        data_prefix=dict(img='val2017/'),
+        test_mode=True,
+        pipeline=test_pipeline,
+        backend_args=backend_args))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(
+    type=CocoMetric,
+    ann_file=data_root + 'annotations/instances_val2017.json',
+    metric=['bbox', 'segm'],
+    format_only=False,
+    backend_args=backend_args)
+test_evaluator = val_evaluator
+
+# inference on test dataset and
+# format the output results for submission.
+# test_dataloader = dict(
+#     batch_size=1,
+#     num_workers=2,
+#     persistent_workers=True,
+#     drop_last=False,
+#     sampler=dict(type=DefaultSampler, shuffle=False),
+#     dataset=dict(
+#         type=CocoDataset,
+#         data_root=data_root,
+#         ann_file=data_root + 'annotations/image_info_test-dev2017.json',
+#         data_prefix=dict(img='test2017/'),
+#         test_mode=True,
+#         pipeline=test_pipeline))
+# test_evaluator = dict(
+#     type=CocoMetric,
+#     metric=['bbox', 'segm'],
+#     format_only=True,
+#     ann_file=data_root + 'annotations/image_info_test-dev2017.json',
+#     outfile_prefix='./work_dirs/coco_instance/test')
diff --git a/mmdetection/mmdet/configs/_base_/datasets/coco_instance_semantic.py b/mmdetection/mmdet/configs/_base_/datasets/coco_instance_semantic.py
new file mode 100644
index 00000000..7cf5b2cf
--- /dev/null
+++ b/mmdetection/mmdet/configs/_base_/datasets/coco_instance_semantic.py
@@ -0,0 +1,87 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.transforms.loading import LoadImageFromFile
+from mmengine.dataset.sampler import DefaultSampler
+
+from mmdet.datasets.coco import CocoDataset
+from mmdet.datasets.samplers.batch_sampler import AspectRatioBatchSampler
+from mmdet.datasets.transforms.formatting import PackDetInputs
+from mmdet.datasets.transforms.loading import LoadAnnotations
+from mmdet.datasets.transforms.transforms import RandomFlip, Resize
+from mmdet.evaluation.metrics.coco_metric import CocoMetric
+
+# dataset settings
+dataset_type = 'CocoDataset'
+data_root = 'data/coco/'
+
+# Example to use different file client
+# Method 1: simply set the data root and let the file I/O module
+# automatically infer from prefix (not support LMDB and Memcache yet)
+
+# data_root = 's3://openmmlab/datasets/detection/coco/'
+
+# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6
+# backend_args = dict(
+#     backend='petrel',
+#     path_mapping=dict({
+#         './data/': 's3://openmmlab/datasets/detection/',
+#         'data/': 's3://openmmlab/datasets/detection/'
+#     }))
+backend_args = None
+
+train_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=LoadAnnotations, with_bbox=True, with_mask=True, with_seg=True),
+    dict(type=Resize, scale=(1333, 800), keep_ratio=True),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=PackDetInputs)
+]
+test_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=Resize, scale=(1333, 800), keep_ratio=True),
+    # If you don't have a gt annotation, delete the pipeline
+    dict(type=LoadAnnotations, with_bbox=True, with_mask=True, with_seg=True),
+    dict(
+        type=PackDetInputs,
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type=DefaultSampler, shuffle=True),
+    batch_sampler=dict(type=AspectRatioBatchSampler),
+    dataset=dict(
+        type=CocoDataset,
+        data_root=data_root,
+        ann_file='annotations/instances_train2017.json',
+        data_prefix=dict(img='train2017/', seg='stuffthingmaps/train2017/'),
+        filter_cfg=dict(filter_empty_gt=True, min_size=32),
+        pipeline=train_pipeline,
+        backend_args=backend_args))
+
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type=DefaultSampler, shuffle=False),
+    dataset=dict(
+        type=CocoDataset,
+        data_root=data_root,
+        ann_file='annotations/instances_val2017.json',
+        data_prefix=dict(img='val2017/'),
+        test_mode=True,
+        pipeline=test_pipeline,
+        backend_args=backend_args))
+
+test_dataloader = val_dataloader
+
+val_evaluator = dict(
+    type=CocoMetric,
+    ann_file=data_root + 'annotations/instances_val2017.json',
+    metric=['bbox', 'segm'],
+    format_only=False,
+    backend_args=backend_args)
+test_evaluator = val_evaluator
diff --git a/mmdetection/mmdet/configs/_base_/datasets/coco_panoptic.py b/mmdetection/mmdet/configs/_base_/datasets/coco_panoptic.py
new file mode 100644
index 00000000..29d655ff
--- /dev/null
+++ b/mmdetection/mmdet/configs/_base_/datasets/coco_panoptic.py
@@ -0,0 +1,105 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.transforms.loading import LoadImageFromFile
+from mmengine.dataset.sampler import DefaultSampler
+
+from mmdet.datasets.coco_panoptic import CocoPanopticDataset
+from mmdet.datasets.samplers.batch_sampler import AspectRatioBatchSampler
+from mmdet.datasets.transforms.formatting import PackDetInputs
+from mmdet.datasets.transforms.loading import LoadPanopticAnnotations
+from mmdet.datasets.transforms.transforms import RandomFlip, Resize
+from mmdet.evaluation.metrics.coco_panoptic_metric import CocoPanopticMetric
+
+# dataset settings
+dataset_type = 'CocoPanopticDataset'
+data_root = 'data/coco/'
+
+# Example to use different file client
+# Method 1: simply set the data root and let the file I/O module
+# automatically infer from prefix (not support LMDB and Memcache yet)
+
+# data_root = 's3://openmmlab/datasets/detection/coco/'
+
+# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6
+# backend_args = dict(
+#     backend='petrel',
+#     path_mapping=dict({
+#         './data/': 's3://openmmlab/datasets/detection/',
+#         'data/': 's3://openmmlab/datasets/detection/'
+#     }))
+backend_args = None
+
+train_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=LoadPanopticAnnotations, backend_args=backend_args),
+    dict(type=Resize, scale=(1333, 800), keep_ratio=True),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=PackDetInputs)
+]
+test_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=Resize, scale=(1333, 800), keep_ratio=True),
+    dict(type=LoadPanopticAnnotations, backend_args=backend_args),
+    dict(
+        type=PackDetInputs,
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type=DefaultSampler, shuffle=True),
+    batch_sampler=dict(type=AspectRatioBatchSampler),
+    dataset=dict(
+        type=CocoPanopticDataset,
+        data_root=data_root,
+        ann_file='annotations/panoptic_train2017.json',
+        data_prefix=dict(
+            img='train2017/', seg='annotations/panoptic_train2017/'),
+        filter_cfg=dict(filter_empty_gt=True, min_size=32),
+        pipeline=train_pipeline,
+        backend_args=backend_args))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type=DefaultSampler, shuffle=False),
+    dataset=dict(
+        type=CocoPanopticDataset,
+        data_root=data_root,
+        ann_file='annotations/panoptic_val2017.json',
+        data_prefix=dict(img='val2017/', seg='annotations/panoptic_val2017/'),
+        test_mode=True,
+        pipeline=test_pipeline,
+        backend_args=backend_args))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(
+    type=CocoPanopticMetric,
+    ann_file=data_root + 'annotations/panoptic_val2017.json',
+    seg_prefix=data_root + 'annotations/panoptic_val2017/',
+    backend_args=backend_args)
+test_evaluator = val_evaluator
+
+# inference on test dataset and
+# format the output results for submission.
+# test_dataloader = dict(
+#     batch_size=1,
+#     num_workers=1,
+#     persistent_workers=True,
+#     drop_last=False,
+#     sampler=dict(type=DefaultSampler, shuffle=False),
+#     dataset=dict(
+#         type=CocoPanopticDataset,
+#         data_root=data_root,
+#         ann_file='annotations/panoptic_image_info_test-dev2017.json',
+#         data_prefix=dict(img='test2017/'),
+#         test_mode=True,
+#         pipeline=test_pipeline))
+# test_evaluator = dict(
+#     type=CocoPanopticMetric,
+#     format_only=True,
+#     ann_file=data_root + 'annotations/panoptic_image_info_test-dev2017.json',
+#     outfile_prefix='./work_dirs/coco_panoptic/test')
diff --git a/mmdetection/mmdet/configs/_base_/datasets/mot_challenge.py b/mmdetection/mmdet/configs/_base_/datasets/mot_challenge.py
new file mode 100644
index 00000000..a71520a8
--- /dev/null
+++ b/mmdetection/mmdet/configs/_base_/datasets/mot_challenge.py
@@ -0,0 +1,101 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.transforms import (LoadImageFromFile, RandomResize,
+                             TransformBroadcaster)
+
+from mmdet.datasets import MOTChallengeDataset
+from mmdet.datasets.samplers import TrackImgSampler
+from mmdet.datasets.transforms import (LoadTrackAnnotations, PackTrackInputs,
+                                       PhotoMetricDistortion, RandomCrop,
+                                       RandomFlip, Resize,
+                                       UniformRefFrameSample)
+from mmdet.evaluation import MOTChallengeMetric
+
+# dataset settings
+dataset_type = MOTChallengeDataset
+data_root = 'data/MOT17/'
+img_scale = (1088, 1088)
+
+backend_args = None
+# data pipeline
+train_pipeline = [
+    dict(
+        type=UniformRefFrameSample,
+        num_ref_imgs=1,
+        frame_range=10,
+        filter_key_img=True),
+    dict(
+        type=TransformBroadcaster,
+        share_random_params=True,
+        transforms=[
+            dict(type=LoadImageFromFile, backend_args=backend_args),
+            dict(type=LoadTrackAnnotations),
+            dict(
+                type=RandomResize,
+                scale=img_scale,
+                ratio_range=(0.8, 1.2),
+                keep_ratio=True,
+                clip_object_border=False),
+            dict(type=PhotoMetricDistortion)
+        ]),
+    dict(
+        type=TransformBroadcaster,
+        # different cropped positions for different frames
+        share_random_params=False,
+        transforms=[
+            dict(type=RandomCrop, crop_size=img_scale, bbox_clip_border=False)
+        ]),
+    dict(
+        type=TransformBroadcaster,
+        share_random_params=True,
+        transforms=[
+            dict(type=RandomFlip, prob=0.5),
+        ]),
+    dict(type=PackTrackInputs)
+]
+
+test_pipeline = [
+    dict(
+        type=TransformBroadcaster,
+        transforms=[
+            dict(type=LoadImageFromFile, backend_args=backend_args),
+            dict(type=Resize, scale=img_scale, keep_ratio=True),
+            dict(type=LoadTrackAnnotations)
+        ]),
+    dict(type=PackTrackInputs)
+]
+
+# dataloader
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type=TrackImgSampler),  # image-based sampling
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        visibility_thr=-1,
+        ann_file='annotations/half-train_cocoformat.json',
+        data_prefix=dict(img_path='train'),
+        metainfo=dict(classes=('pedestrian', )),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+    persistent_workers=True,
+    # Now we support two ways to test, image_based and video_based
+    # if you want to use video_based sampling, you can use as follows
+    # sampler=dict(type='DefaultSampler', shuffle=False, round_up=False),
+    sampler=dict(type=TrackImgSampler),  # image-based sampling
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='annotations/half-val_cocoformat.json',
+        data_prefix=dict(img_path='train'),
+        test_mode=True,
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+# evaluator
+val_evaluator = dict(
+    type=MOTChallengeMetric, metric=['HOTA', 'CLEAR', 'Identity'])
+test_evaluator = val_evaluator
diff --git a/mmdetection/mmdet/configs/_base_/default_runtime.py b/mmdetection/mmdet/configs/_base_/default_runtime.py
new file mode 100644
index 00000000..ff96dbf2
--- /dev/null
+++ b/mmdetection/mmdet/configs/_base_/default_runtime.py
@@ -0,0 +1,33 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.hooks import (CheckpointHook, DistSamplerSeedHook, IterTimerHook,
+                            LoggerHook, ParamSchedulerHook)
+from mmengine.runner import LogProcessor
+from mmengine.visualization import LocalVisBackend
+
+from mmdet.engine.hooks import DetVisualizationHook
+from mmdet.visualization import DetLocalVisualizer
+
+default_scope = None
+
+default_hooks = dict(
+    timer=dict(type=IterTimerHook),
+    logger=dict(type=LoggerHook, interval=50),
+    param_scheduler=dict(type=ParamSchedulerHook),
+    checkpoint=dict(type=CheckpointHook, interval=1),
+    sampler_seed=dict(type=DistSamplerSeedHook),
+    visualization=dict(type=DetVisualizationHook))
+
+env_cfg = dict(
+    cudnn_benchmark=False,
+    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+    dist_cfg=dict(backend='nccl'),
+)
+
+vis_backends = [dict(type=LocalVisBackend)]
+visualizer = dict(
+    type=DetLocalVisualizer, vis_backends=vis_backends, name='visualizer')
+log_processor = dict(type=LogProcessor, window_size=50, by_epoch=True)
+
+log_level = 'INFO'
+load_from = None
+resume = False
diff --git a/mmdetection/mmdet/configs/_base_/models/cascade_mask_rcnn_r50_fpn.py b/mmdetection/mmdet/configs/_base_/models/cascade_mask_rcnn_r50_fpn.py
new file mode 100644
index 00000000..b9132ac4
--- /dev/null
+++ b/mmdetection/mmdet/configs/_base_/models/cascade_mask_rcnn_r50_fpn.py
@@ -0,0 +1,220 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.ops import RoIAlign, nms
+from torch.nn import BatchNorm2d
+
+from mmdet.models.backbones.resnet import ResNet
+from mmdet.models.data_preprocessors.data_preprocessor import \
+    DetDataPreprocessor
+from mmdet.models.dense_heads.rpn_head import RPNHead
+from mmdet.models.detectors.cascade_rcnn import CascadeRCNN
+from mmdet.models.losses.cross_entropy_loss import CrossEntropyLoss
+from mmdet.models.losses.smooth_l1_loss import SmoothL1Loss
+from mmdet.models.necks.fpn import FPN
+from mmdet.models.roi_heads.bbox_heads.convfc_bbox_head import \
+    Shared2FCBBoxHead
+from mmdet.models.roi_heads.cascade_roi_head import CascadeRoIHead
+from mmdet.models.roi_heads.mask_heads.fcn_mask_head import FCNMaskHead
+from mmdet.models.roi_heads.roi_extractors.single_level_roi_extractor import \
+    SingleRoIExtractor
+from mmdet.models.task_modules.assigners.max_iou_assigner import MaxIoUAssigner
+from mmdet.models.task_modules.coders.delta_xywh_bbox_coder import \
+    DeltaXYWHBBoxCoder
+from mmdet.models.task_modules.prior_generators.anchor_generator import \
+    AnchorGenerator
+from mmdet.models.task_modules.samplers.random_sampler import RandomSampler
+
+# model settings
+model = dict(
+    type=CascadeRCNN,
+    data_preprocessor=dict(
+        type=DetDataPreprocessor,
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        bgr_to_rgb=True,
+        pad_mask=True,
+        pad_size_divisor=32),
+    backbone=dict(
+        type=ResNet,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type=BatchNorm2d, requires_grad=True),
+        norm_eval=True,
+        style='pytorch',
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),
+    neck=dict(
+        type=FPN,
+        in_channels=[256, 512, 1024, 2048],
+        out_channels=256,
+        num_outs=5),
+    rpn_head=dict(
+        type=RPNHead,
+        in_channels=256,
+        feat_channels=256,
+        anchor_generator=dict(
+            type=AnchorGenerator,
+            scales=[8],
+            ratios=[0.5, 1.0, 2.0],
+            strides=[4, 8, 16, 32, 64]),
+        bbox_coder=dict(
+            type=DeltaXYWHBBoxCoder,
+            target_means=[.0, .0, .0, .0],
+            target_stds=[1.0, 1.0, 1.0, 1.0]),
+        loss_cls=dict(
+            type=CrossEntropyLoss, use_sigmoid=True, loss_weight=1.0),
+        loss_bbox=dict(type=SmoothL1Loss, beta=1.0 / 9.0, loss_weight=1.0)),
+    roi_head=dict(
+        type=CascadeRoIHead,
+        num_stages=3,
+        stage_loss_weights=[1, 0.5, 0.25],
+        bbox_roi_extractor=dict(
+            type=SingleRoIExtractor,
+            roi_layer=dict(type=RoIAlign, output_size=7, sampling_ratio=0),
+            out_channels=256,
+            featmap_strides=[4, 8, 16, 32]),
+        bbox_head=[
+            dict(
+                type=Shared2FCBBoxHead,
+                in_channels=256,
+                fc_out_channels=1024,
+                roi_feat_size=7,
+                num_classes=80,
+                bbox_coder=dict(
+                    type=DeltaXYWHBBoxCoder,
+                    target_means=[0., 0., 0., 0.],
+                    target_stds=[0.1, 0.1, 0.2, 0.2]),
+                reg_class_agnostic=True,
+                loss_cls=dict(
+                    type=CrossEntropyLoss, use_sigmoid=False, loss_weight=1.0),
+                loss_bbox=dict(type=SmoothL1Loss, beta=1.0, loss_weight=1.0)),
+            dict(
+                type=Shared2FCBBoxHead,
+                in_channels=256,
+                fc_out_channels=1024,
+                roi_feat_size=7,
+                num_classes=80,
+                bbox_coder=dict(
+                    type=DeltaXYWHBBoxCoder,
+                    target_means=[0., 0., 0., 0.],
+                    target_stds=[0.05, 0.05, 0.1, 0.1]),
+                reg_class_agnostic=True,
+                loss_cls=dict(
+                    type=CrossEntropyLoss, use_sigmoid=False, loss_weight=1.0),
+                loss_bbox=dict(type=SmoothL1Loss, beta=1.0, loss_weight=1.0)),
+            dict(
+                type=Shared2FCBBoxHead,
+                in_channels=256,
+                fc_out_channels=1024,
+                roi_feat_size=7,
+                num_classes=80,
+                bbox_coder=dict(
+                    type=DeltaXYWHBBoxCoder,
+                    target_means=[0., 0., 0., 0.],
+                    target_stds=[0.033, 0.033, 0.067, 0.067]),
+                reg_class_agnostic=True,
+                loss_cls=dict(
+                    type=CrossEntropyLoss, use_sigmoid=False, loss_weight=1.0),
+                loss_bbox=dict(type=SmoothL1Loss, beta=1.0, loss_weight=1.0))
+        ],
+        mask_roi_extractor=dict(
+            type=SingleRoIExtractor,
+            roi_layer=dict(type=RoIAlign, output_size=14, sampling_ratio=0),
+            out_channels=256,
+            featmap_strides=[4, 8, 16, 32]),
+        mask_head=dict(
+            type=FCNMaskHead,
+            num_convs=4,
+            in_channels=256,
+            conv_out_channels=256,
+            num_classes=80,
+            loss_mask=dict(
+                type=CrossEntropyLoss, use_mask=True, loss_weight=1.0))),
+    # model training and testing settings
+    train_cfg=dict(
+        rpn=dict(
+            assigner=dict(
+                type=MaxIoUAssigner,
+                pos_iou_thr=0.7,
+                neg_iou_thr=0.3,
+                min_pos_iou=0.3,
+                match_low_quality=True,
+                ignore_iof_thr=-1),
+            sampler=dict(
+                type=RandomSampler,
+                num=256,
+                pos_fraction=0.5,
+                neg_pos_ub=-1,
+                add_gt_as_proposals=False),
+            allowed_border=0,
+            pos_weight=-1,
+            debug=False),
+        rpn_proposal=dict(
+            nms_pre=2000,
+            max_per_img=2000,
+            nms=dict(type=nms, iou_threshold=0.7),
+            min_bbox_size=0),
+        rcnn=[
+            dict(
+                assigner=dict(
+                    type=MaxIoUAssigner,
+                    pos_iou_thr=0.5,
+                    neg_iou_thr=0.5,
+                    min_pos_iou=0.5,
+                    match_low_quality=False,
+                    ignore_iof_thr=-1),
+                sampler=dict(
+                    type=RandomSampler,
+                    num=512,
+                    pos_fraction=0.25,
+                    neg_pos_ub=-1,
+                    add_gt_as_proposals=True),
+                mask_size=28,
+                pos_weight=-1,
+                debug=False),
+            dict(
+                assigner=dict(
+                    type=MaxIoUAssigner,
+                    pos_iou_thr=0.6,
+                    neg_iou_thr=0.6,
+                    min_pos_iou=0.6,
+                    match_low_quality=False,
+                    ignore_iof_thr=-1),
+                sampler=dict(
+                    type=RandomSampler,
+                    num=512,
+                    pos_fraction=0.25,
+                    neg_pos_ub=-1,
+                    add_gt_as_proposals=True),
+                mask_size=28,
+                pos_weight=-1,
+                debug=False),
+            dict(
+                assigner=dict(
+                    type=MaxIoUAssigner,
+                    pos_iou_thr=0.7,
+                    neg_iou_thr=0.7,
+                    min_pos_iou=0.7,
+                    match_low_quality=False,
+                    ignore_iof_thr=-1),
+                sampler=dict(
+                    type=RandomSampler,
+                    num=512,
+                    pos_fraction=0.25,
+                    neg_pos_ub=-1,
+                    add_gt_as_proposals=True),
+                mask_size=28,
+                pos_weight=-1,
+                debug=False)
+        ]),
+    test_cfg=dict(
+        rpn=dict(
+            nms_pre=1000,
+            max_per_img=1000,
+            nms=dict(type=nms, iou_threshold=0.7),
+            min_bbox_size=0),
+        rcnn=dict(
+            score_thr=0.05,
+            nms=dict(type=nms, iou_threshold=0.5),
+            max_per_img=100,
+            mask_thr_binary=0.5)))
diff --git a/mmdetection/mmdet/configs/_base_/models/cascade_rcnn_r50_fpn.py b/mmdetection/mmdet/configs/_base_/models/cascade_rcnn_r50_fpn.py
new file mode 100644
index 00000000..8e6654f3
--- /dev/null
+++ b/mmdetection/mmdet/configs/_base_/models/cascade_rcnn_r50_fpn.py
@@ -0,0 +1,201 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.ops import RoIAlign, nms
+from torch.nn import BatchNorm2d
+
+from mmdet.models.backbones.resnet import ResNet
+from mmdet.models.data_preprocessors.data_preprocessor import \
+    DetDataPreprocessor
+from mmdet.models.dense_heads.rpn_head import RPNHead
+from mmdet.models.detectors.cascade_rcnn import CascadeRCNN
+from mmdet.models.losses.cross_entropy_loss import CrossEntropyLoss
+from mmdet.models.losses.smooth_l1_loss import SmoothL1Loss
+from mmdet.models.necks.fpn import FPN
+from mmdet.models.roi_heads.bbox_heads.convfc_bbox_head import \
+    Shared2FCBBoxHead
+from mmdet.models.roi_heads.cascade_roi_head import CascadeRoIHead
+from mmdet.models.roi_heads.roi_extractors.single_level_roi_extractor import \
+    SingleRoIExtractor
+from mmdet.models.task_modules.assigners.max_iou_assigner import MaxIoUAssigner
+from mmdet.models.task_modules.coders.delta_xywh_bbox_coder import \
+    DeltaXYWHBBoxCoder
+from mmdet.models.task_modules.prior_generators.anchor_generator import \
+    AnchorGenerator
+from mmdet.models.task_modules.samplers.random_sampler import RandomSampler
+
+# model settings
+model = dict(
+    type=CascadeRCNN,
+    data_preprocessor=dict(
+        type=DetDataPreprocessor,
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        bgr_to_rgb=True,
+        pad_size_divisor=32),
+    backbone=dict(
+        type=ResNet,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type=BatchNorm2d, requires_grad=True),
+        norm_eval=True,
+        style='pytorch',
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),
+    neck=dict(
+        type=FPN,
+        in_channels=[256, 512, 1024, 2048],
+        out_channels=256,
+        num_outs=5),
+    rpn_head=dict(
+        type=RPNHead,
+        in_channels=256,
+        feat_channels=256,
+        anchor_generator=dict(
+            type=AnchorGenerator,
+            scales=[8],
+            ratios=[0.5, 1.0, 2.0],
+            strides=[4, 8, 16, 32, 64]),
+        bbox_coder=dict(
+            type=DeltaXYWHBBoxCoder,
+            target_means=[.0, .0, .0, .0],
+            target_stds=[1.0, 1.0, 1.0, 1.0]),
+        loss_cls=dict(
+            type=CrossEntropyLoss, use_sigmoid=True, loss_weight=1.0),
+        loss_bbox=dict(type=SmoothL1Loss, beta=1.0 / 9.0, loss_weight=1.0)),
+    roi_head=dict(
+        type=CascadeRoIHead,
+        num_stages=3,
+        stage_loss_weights=[1, 0.5, 0.25],
+        bbox_roi_extractor=dict(
+            type=SingleRoIExtractor,
+            roi_layer=dict(type=RoIAlign, output_size=7, sampling_ratio=0),
+            out_channels=256,
+            featmap_strides=[4, 8, 16, 32]),
+        bbox_head=[
+            dict(
+                type=Shared2FCBBoxHead,
+                in_channels=256,
+                fc_out_channels=1024,
+                roi_feat_size=7,
+                num_classes=80,
+                bbox_coder=dict(
+                    type=DeltaXYWHBBoxCoder,
+                    target_means=[0., 0., 0., 0.],
+                    target_stds=[0.1, 0.1, 0.2, 0.2]),
+                reg_class_agnostic=True,
+                loss_cls=dict(
+                    type=CrossEntropyLoss, use_sigmoid=False, loss_weight=1.0),
+                loss_bbox=dict(type=SmoothL1Loss, beta=1.0, loss_weight=1.0)),
+            dict(
+                type=Shared2FCBBoxHead,
+                in_channels=256,
+                fc_out_channels=1024,
+                roi_feat_size=7,
+                num_classes=80,
+                bbox_coder=dict(
+                    type=DeltaXYWHBBoxCoder,
+                    target_means=[0., 0., 0., 0.],
+                    target_stds=[0.05, 0.05, 0.1, 0.1]),
+                reg_class_agnostic=True,
+                loss_cls=dict(
+                    type=CrossEntropyLoss, use_sigmoid=False, loss_weight=1.0),
+                loss_bbox=dict(type=SmoothL1Loss, beta=1.0, loss_weight=1.0)),
+            dict(
+                type=Shared2FCBBoxHead,
+                in_channels=256,
+                fc_out_channels=1024,
+                roi_feat_size=7,
+                num_classes=80,
+                bbox_coder=dict(
+                    type=DeltaXYWHBBoxCoder,
+                    target_means=[0., 0., 0., 0.],
+                    target_stds=[0.033, 0.033, 0.067, 0.067]),
+                reg_class_agnostic=True,
+                loss_cls=dict(
+                    type=CrossEntropyLoss, use_sigmoid=False, loss_weight=1.0),
+                loss_bbox=dict(type=SmoothL1Loss, beta=1.0, loss_weight=1.0))
+        ]),
+    # model training and testing settings
+    train_cfg=dict(
+        rpn=dict(
+            assigner=dict(
+                type=MaxIoUAssigner,
+                pos_iou_thr=0.7,
+                neg_iou_thr=0.3,
+                min_pos_iou=0.3,
+                match_low_quality=True,
+                ignore_iof_thr=-1),
+            sampler=dict(
+                type=RandomSampler,
+                num=256,
+                pos_fraction=0.5,
+                neg_pos_ub=-1,
+                add_gt_as_proposals=False),
+            allowed_border=0,
+            pos_weight=-1,
+            debug=False),
+        rpn_proposal=dict(
+            nms_pre=2000,
+            max_per_img=2000,
+            nms=dict(type=nms, iou_threshold=0.7),
+            min_bbox_size=0),
+        rcnn=[
+            dict(
+                assigner=dict(
+                    type=MaxIoUAssigner,
+                    pos_iou_thr=0.5,
+                    neg_iou_thr=0.5,
+                    min_pos_iou=0.5,
+                    match_low_quality=False,
+                    ignore_iof_thr=-1),
+                sampler=dict(
+                    type=RandomSampler,
+                    num=512,
+                    pos_fraction=0.25,
+                    neg_pos_ub=-1,
+                    add_gt_as_proposals=True),
+                pos_weight=-1,
+                debug=False),
+            dict(
+                assigner=dict(
+                    type=MaxIoUAssigner,
+                    pos_iou_thr=0.6,
+                    neg_iou_thr=0.6,
+                    min_pos_iou=0.6,
+                    match_low_quality=False,
+                    ignore_iof_thr=-1),
+                sampler=dict(
+                    type=RandomSampler,
+                    num=512,
+                    pos_fraction=0.25,
+                    neg_pos_ub=-1,
+                    add_gt_as_proposals=True),
+                pos_weight=-1,
+                debug=False),
+            dict(
+                assigner=dict(
+                    type=MaxIoUAssigner,
+                    pos_iou_thr=0.7,
+                    neg_iou_thr=0.7,
+                    min_pos_iou=0.7,
+                    match_low_quality=False,
+                    ignore_iof_thr=-1),
+                sampler=dict(
+                    type=RandomSampler,
+                    num=512,
+                    pos_fraction=0.25,
+                    neg_pos_ub=-1,
+                    add_gt_as_proposals=True),
+                pos_weight=-1,
+                debug=False)
+        ]),
+    test_cfg=dict(
+        rpn=dict(
+            nms_pre=1000,
+            max_per_img=1000,
+            nms=dict(type=nms, iou_threshold=0.7),
+            min_bbox_size=0),
+        rcnn=dict(
+            score_thr=0.05,
+            nms=dict(type=nms, iou_threshold=0.5),
+            max_per_img=100)))
diff --git a/mmdetection/mmdet/configs/_base_/models/faster_rcnn_r50_fpn.py b/mmdetection/mmdet/configs/_base_/models/faster_rcnn_r50_fpn.py
new file mode 100644
index 00000000..7e18de22
--- /dev/null
+++ b/mmdetection/mmdet/configs/_base_/models/faster_rcnn_r50_fpn.py
@@ -0,0 +1,138 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.ops import RoIAlign, nms
+from torch.nn import BatchNorm2d
+
+from mmdet.models.backbones.resnet import ResNet
+from mmdet.models.data_preprocessors.data_preprocessor import \
+    DetDataPreprocessor
+from mmdet.models.dense_heads.rpn_head import RPNHead
+from mmdet.models.detectors.faster_rcnn import FasterRCNN
+from mmdet.models.losses.cross_entropy_loss import CrossEntropyLoss
+from mmdet.models.losses.smooth_l1_loss import L1Loss
+from mmdet.models.necks.fpn import FPN
+from mmdet.models.roi_heads.bbox_heads.convfc_bbox_head import \
+    Shared2FCBBoxHead
+from mmdet.models.roi_heads.roi_extractors.single_level_roi_extractor import \
+    SingleRoIExtractor
+from mmdet.models.roi_heads.standard_roi_head import StandardRoIHead
+from mmdet.models.task_modules.assigners.max_iou_assigner import MaxIoUAssigner
+from mmdet.models.task_modules.coders.delta_xywh_bbox_coder import \
+    DeltaXYWHBBoxCoder
+from mmdet.models.task_modules.prior_generators.anchor_generator import \
+    AnchorGenerator
+from mmdet.models.task_modules.samplers.random_sampler import RandomSampler
+
+# model settings
+model = dict(
+    type=FasterRCNN,
+    data_preprocessor=dict(
+        type=DetDataPreprocessor,
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        bgr_to_rgb=True,
+        pad_size_divisor=32),
+    backbone=dict(
+        type=ResNet,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type=BatchNorm2d, requires_grad=True),
+        norm_eval=True,
+        style='pytorch',
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),
+    neck=dict(
+        type=FPN,
+        in_channels=[256, 512, 1024, 2048],
+        out_channels=256,
+        num_outs=5),
+    rpn_head=dict(
+        type=RPNHead,
+        in_channels=256,
+        feat_channels=256,
+        anchor_generator=dict(
+            type=AnchorGenerator,
+            scales=[8],
+            ratios=[0.5, 1.0, 2.0],
+            strides=[4, 8, 16, 32, 64]),
+        bbox_coder=dict(
+            type=DeltaXYWHBBoxCoder,
+            target_means=[.0, .0, .0, .0],
+            target_stds=[1.0, 1.0, 1.0, 1.0]),
+        loss_cls=dict(
+            type=CrossEntropyLoss, use_sigmoid=True, loss_weight=1.0),
+        loss_bbox=dict(type=L1Loss, loss_weight=1.0)),
+    roi_head=dict(
+        type=StandardRoIHead,
+        bbox_roi_extractor=dict(
+            type=SingleRoIExtractor,
+            roi_layer=dict(type=RoIAlign, output_size=7, sampling_ratio=0),
+            out_channels=256,
+            featmap_strides=[4, 8, 16, 32]),
+        bbox_head=dict(
+            type=Shared2FCBBoxHead,
+            in_channels=256,
+            fc_out_channels=1024,
+            roi_feat_size=7,
+            num_classes=80,
+            bbox_coder=dict(
+                type=DeltaXYWHBBoxCoder,
+                target_means=[0., 0., 0., 0.],
+                target_stds=[0.1, 0.1, 0.2, 0.2]),
+            reg_class_agnostic=False,
+            loss_cls=dict(
+                type=CrossEntropyLoss, use_sigmoid=False, loss_weight=1.0),
+            loss_bbox=dict(type=L1Loss, loss_weight=1.0))),
+    # model training and testing settings
+    train_cfg=dict(
+        rpn=dict(
+            assigner=dict(
+                type=MaxIoUAssigner,
+                pos_iou_thr=0.7,
+                neg_iou_thr=0.3,
+                min_pos_iou=0.3,
+                match_low_quality=True,
+                ignore_iof_thr=-1),
+            sampler=dict(
+                type=RandomSampler,
+                num=256,
+                pos_fraction=0.5,
+                neg_pos_ub=-1,
+                add_gt_as_proposals=False),
+            allowed_border=-1,
+            pos_weight=-1,
+            debug=False),
+        rpn_proposal=dict(
+            nms_pre=2000,
+            max_per_img=1000,
+            nms=dict(type=nms, iou_threshold=0.7),
+            min_bbox_size=0),
+        rcnn=dict(
+            assigner=dict(
+                type=MaxIoUAssigner,
+                pos_iou_thr=0.5,
+                neg_iou_thr=0.5,
+                min_pos_iou=0.5,
+                match_low_quality=False,
+                ignore_iof_thr=-1),
+            sampler=dict(
+                type=RandomSampler,
+                num=512,
+                pos_fraction=0.25,
+                neg_pos_ub=-1,
+                add_gt_as_proposals=True),
+            pos_weight=-1,
+            debug=False)),
+    test_cfg=dict(
+        rpn=dict(
+            nms_pre=1000,
+            max_per_img=1000,
+            nms=dict(type=nms, iou_threshold=0.7),
+            min_bbox_size=0),
+        rcnn=dict(
+            score_thr=0.05,
+            nms=dict(type=nms, iou_threshold=0.5),
+            max_per_img=100)
+        # soft-nms is also supported for rcnn testing
+        # e.g., nms=dict(type='soft_nms', iou_threshold=0.5, min_score=0.05)
+    ))
diff --git a/mmdetection/mmdet/configs/_base_/models/mask_rcnn_r50_caffe_c4.py b/mmdetection/mmdet/configs/_base_/models/mask_rcnn_r50_caffe_c4.py
new file mode 100644
index 00000000..30548183
--- /dev/null
+++ b/mmdetection/mmdet/configs/_base_/models/mask_rcnn_r50_caffe_c4.py
@@ -0,0 +1,158 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.ops import RoIAlign, nms
+from mmengine.model.weight_init import PretrainedInit
+from torch.nn import BatchNorm2d
+
+from mmdet.models.backbones.resnet import ResNet
+from mmdet.models.data_preprocessors.data_preprocessor import \
+    DetDataPreprocessor
+from mmdet.models.dense_heads.rpn_head import RPNHead
+from mmdet.models.detectors.mask_rcnn import MaskRCNN
+from mmdet.models.layers import ResLayer
+from mmdet.models.losses.cross_entropy_loss import CrossEntropyLoss
+from mmdet.models.losses.smooth_l1_loss import L1Loss
+from mmdet.models.roi_heads.bbox_heads.bbox_head import BBoxHead
+from mmdet.models.roi_heads.mask_heads.fcn_mask_head import FCNMaskHead
+from mmdet.models.roi_heads.roi_extractors.single_level_roi_extractor import \
+    SingleRoIExtractor
+from mmdet.models.roi_heads.standard_roi_head import StandardRoIHead
+from mmdet.models.task_modules.assigners.max_iou_assigner import MaxIoUAssigner
+from mmdet.models.task_modules.coders.delta_xywh_bbox_coder import \
+    DeltaXYWHBBoxCoder
+from mmdet.models.task_modules.prior_generators.anchor_generator import \
+    AnchorGenerator
+from mmdet.models.task_modules.samplers.random_sampler import RandomSampler
+
+# model settings
+norm_cfg = dict(type=BatchNorm2d, requires_grad=False)
+# model settings
+model = dict(
+    type=MaskRCNN,
+    data_preprocessor=dict(
+        type=DetDataPreprocessor,
+        mean=[103.530, 116.280, 123.675],
+        std=[1.0, 1.0, 1.0],
+        bgr_to_rgb=False,
+        pad_mask=True,
+        pad_size_divisor=32),
+    backbone=dict(
+        type=ResNet,
+        depth=50,
+        num_stages=3,
+        strides=(1, 2, 2),
+        dilations=(1, 1, 1),
+        out_indices=(2, ),
+        frozen_stages=1,
+        norm_cfg=dict(type=BatchNorm2d, requires_grad=True),
+        norm_eval=True,
+        style='caffe',
+        init_cfg=dict(
+            type=PretrainedInit,
+            checkpoint='open-mmlab://detectron2/resnet50_caffe')),
+    rpn_head=dict(
+        type=RPNHead,
+        in_channels=1024,
+        feat_channels=1024,
+        anchor_generator=dict(
+            type=AnchorGenerator,
+            scales=[2, 4, 8, 16, 32],
+            ratios=[0.5, 1.0, 2.0],
+            strides=[16]),
+        bbox_coder=dict(
+            type=DeltaXYWHBBoxCoder,
+            target_means=[.0, .0, .0, .0],
+            target_stds=[1.0, 1.0, 1.0, 1.0]),
+        loss_cls=dict(
+            type=CrossEntropyLoss, use_sigmoid=True, loss_weight=1.0),
+        loss_bbox=dict(type=L1Loss, loss_weight=1.0)),
+    roi_head=dict(
+        type=StandardRoIHead,
+        shared_head=dict(
+            type=ResLayer,
+            depth=50,
+            stage=3,
+            stride=2,
+            dilation=1,
+            style='caffe',
+            norm_cfg=norm_cfg,
+            norm_eval=True),
+        bbox_roi_extractor=dict(
+            type=SingleRoIExtractor,
+            roi_layer=dict(type=RoIAlign, output_size=14, sampling_ratio=0),
+            out_channels=1024,
+            featmap_strides=[16]),
+        bbox_head=dict(
+            type=BBoxHead,
+            with_avg_pool=True,
+            roi_feat_size=7,
+            in_channels=2048,
+            num_classes=80,
+            bbox_coder=dict(
+                type=DeltaXYWHBBoxCoder,
+                target_means=[0., 0., 0., 0.],
+                target_stds=[0.1, 0.1, 0.2, 0.2]),
+            reg_class_agnostic=False,
+            loss_cls=dict(
+                type=CrossEntropyLoss, use_sigmoid=False, loss_weight=1.0),
+            loss_bbox=dict(type=L1Loss, loss_weight=1.0)),
+        mask_roi_extractor=None,
+        mask_head=dict(
+            type=FCNMaskHead,
+            num_convs=0,
+            in_channels=2048,
+            conv_out_channels=256,
+            num_classes=80,
+            loss_mask=dict(
+                type=CrossEntropyLoss, use_mask=True, loss_weight=1.0))),
+    # model training and testing settings
+    train_cfg=dict(
+        rpn=dict(
+            assigner=dict(
+                type=MaxIoUAssigner,
+                pos_iou_thr=0.7,
+                neg_iou_thr=0.3,
+                min_pos_iou=0.3,
+                match_low_quality=True,
+                ignore_iof_thr=-1),
+            sampler=dict(
+                type=RandomSampler,
+                num=256,
+                pos_fraction=0.5,
+                neg_pos_ub=-1,
+                add_gt_as_proposals=False),
+            allowed_border=0,
+            pos_weight=-1,
+            debug=False),
+        rpn_proposal=dict(
+            nms_pre=12000,
+            max_per_img=2000,
+            nms=dict(type=nms, iou_threshold=0.7),
+            min_bbox_size=0),
+        rcnn=dict(
+            assigner=dict(
+                type=MaxIoUAssigner,
+                pos_iou_thr=0.5,
+                neg_iou_thr=0.5,
+                min_pos_iou=0.5,
+                match_low_quality=False,
+                ignore_iof_thr=-1),
+            sampler=dict(
+                type=RandomSampler,
+                num=512,
+                pos_fraction=0.25,
+                neg_pos_ub=-1,
+                add_gt_as_proposals=True),
+            mask_size=14,
+            pos_weight=-1,
+            debug=False)),
+    test_cfg=dict(
+        rpn=dict(
+            nms_pre=6000,
+            max_per_img=1000,
+            nms=dict(type=nms, iou_threshold=0.7),
+            min_bbox_size=0),
+        rcnn=dict(
+            score_thr=0.05,
+            nms=dict(type=nms, iou_threshold=0.5),
+            max_per_img=100,
+            mask_thr_binary=0.5)))
diff --git a/mmdetection/mmdet/configs/_base_/models/mask_rcnn_r50_fpn.py b/mmdetection/mmdet/configs/_base_/models/mask_rcnn_r50_fpn.py
new file mode 100644
index 00000000..c8a0b031
--- /dev/null
+++ b/mmdetection/mmdet/configs/_base_/models/mask_rcnn_r50_fpn.py
@@ -0,0 +1,154 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.ops import RoIAlign, nms
+from mmengine.model.weight_init import PretrainedInit
+from torch.nn import BatchNorm2d
+
+from mmdet.models.backbones.resnet import ResNet
+from mmdet.models.data_preprocessors.data_preprocessor import \
+    DetDataPreprocessor
+from mmdet.models.dense_heads.rpn_head import RPNHead
+from mmdet.models.detectors.mask_rcnn import MaskRCNN
+from mmdet.models.losses.cross_entropy_loss import CrossEntropyLoss
+from mmdet.models.losses.smooth_l1_loss import L1Loss
+from mmdet.models.necks.fpn import FPN
+from mmdet.models.roi_heads.bbox_heads.convfc_bbox_head import \
+    Shared2FCBBoxHead
+from mmdet.models.roi_heads.mask_heads.fcn_mask_head import FCNMaskHead
+from mmdet.models.roi_heads.roi_extractors.single_level_roi_extractor import \
+    SingleRoIExtractor
+from mmdet.models.roi_heads.standard_roi_head import StandardRoIHead
+from mmdet.models.task_modules.assigners.max_iou_assigner import MaxIoUAssigner
+from mmdet.models.task_modules.coders.delta_xywh_bbox_coder import \
+    DeltaXYWHBBoxCoder
+from mmdet.models.task_modules.prior_generators.anchor_generator import \
+    AnchorGenerator
+from mmdet.models.task_modules.samplers.random_sampler import RandomSampler
+
+# model settings
+model = dict(
+    type=MaskRCNN,
+    data_preprocessor=dict(
+        type=DetDataPreprocessor,
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        bgr_to_rgb=True,
+        pad_mask=True,
+        pad_size_divisor=32),
+    backbone=dict(
+        type=ResNet,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type=BatchNorm2d, requires_grad=True),
+        norm_eval=True,
+        style='pytorch',
+        init_cfg=dict(
+            type=PretrainedInit, checkpoint='torchvision://resnet50')),
+    neck=dict(
+        type=FPN,
+        in_channels=[256, 512, 1024, 2048],
+        out_channels=256,
+        num_outs=5),
+    rpn_head=dict(
+        type=RPNHead,
+        in_channels=256,
+        feat_channels=256,
+        anchor_generator=dict(
+            type=AnchorGenerator,
+            scales=[8],
+            ratios=[0.5, 1.0, 2.0],
+            strides=[4, 8, 16, 32, 64]),
+        bbox_coder=dict(
+            type=DeltaXYWHBBoxCoder,
+            target_means=[.0, .0, .0, .0],
+            target_stds=[1.0, 1.0, 1.0, 1.0]),
+        loss_cls=dict(
+            type=CrossEntropyLoss, use_sigmoid=True, loss_weight=1.0),
+        loss_bbox=dict(type=L1Loss, loss_weight=1.0)),
+    roi_head=dict(
+        type=StandardRoIHead,
+        bbox_roi_extractor=dict(
+            type=SingleRoIExtractor,
+            roi_layer=dict(type=RoIAlign, output_size=7, sampling_ratio=0),
+            out_channels=256,
+            featmap_strides=[4, 8, 16, 32]),
+        bbox_head=dict(
+            type=Shared2FCBBoxHead,
+            in_channels=256,
+            fc_out_channels=1024,
+            roi_feat_size=7,
+            num_classes=80,
+            bbox_coder=dict(
+                type=DeltaXYWHBBoxCoder,
+                target_means=[0., 0., 0., 0.],
+                target_stds=[0.1, 0.1, 0.2, 0.2]),
+            reg_class_agnostic=False,
+            loss_cls=dict(
+                type=CrossEntropyLoss, use_sigmoid=False, loss_weight=1.0),
+            loss_bbox=dict(type=L1Loss, loss_weight=1.0)),
+        mask_roi_extractor=dict(
+            type=SingleRoIExtractor,
+            roi_layer=dict(type=RoIAlign, output_size=14, sampling_ratio=0),
+            out_channels=256,
+            featmap_strides=[4, 8, 16, 32]),
+        mask_head=dict(
+            type=FCNMaskHead,
+            num_convs=4,
+            in_channels=256,
+            conv_out_channels=256,
+            num_classes=80,
+            loss_mask=dict(
+                type=CrossEntropyLoss, use_mask=True, loss_weight=1.0))),
+    # model training and testing settings
+    train_cfg=dict(
+        rpn=dict(
+            assigner=dict(
+                type=MaxIoUAssigner,
+                pos_iou_thr=0.7,
+                neg_iou_thr=0.3,
+                min_pos_iou=0.3,
+                match_low_quality=True,
+                ignore_iof_thr=-1),
+            sampler=dict(
+                type=RandomSampler,
+                num=256,
+                pos_fraction=0.5,
+                neg_pos_ub=-1,
+                add_gt_as_proposals=False),
+            allowed_border=-1,
+            pos_weight=-1,
+            debug=False),
+        rpn_proposal=dict(
+            nms_pre=2000,
+            max_per_img=1000,
+            nms=dict(type=nms, iou_threshold=0.7),
+            min_bbox_size=0),
+        rcnn=dict(
+            assigner=dict(
+                type=MaxIoUAssigner,
+                pos_iou_thr=0.5,
+                neg_iou_thr=0.5,
+                min_pos_iou=0.5,
+                match_low_quality=True,
+                ignore_iof_thr=-1),
+            sampler=dict(
+                type=RandomSampler,
+                num=512,
+                pos_fraction=0.25,
+                neg_pos_ub=-1,
+                add_gt_as_proposals=True),
+            mask_size=28,
+            pos_weight=-1,
+            debug=False)),
+    test_cfg=dict(
+        rpn=dict(
+            nms_pre=1000,
+            max_per_img=1000,
+            nms=dict(type=nms, iou_threshold=0.7),
+            min_bbox_size=0),
+        rcnn=dict(
+            score_thr=0.05,
+            nms=dict(type=nms, iou_threshold=0.5),
+            max_per_img=100,
+            mask_thr_binary=0.5)))
diff --git a/mmdetection/mmdet/configs/_base_/models/retinanet_r50_fpn.py b/mmdetection/mmdet/configs/_base_/models/retinanet_r50_fpn.py
new file mode 100644
index 00000000..33e5cc4f
--- /dev/null
+++ b/mmdetection/mmdet/configs/_base_/models/retinanet_r50_fpn.py
@@ -0,0 +1,77 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.ops import nms
+from torch.nn import BatchNorm2d
+
+from mmdet.models import (FPN, DetDataPreprocessor, FocalLoss, L1Loss, ResNet,
+                          RetinaHead, RetinaNet)
+from mmdet.models.task_modules import (AnchorGenerator, DeltaXYWHBBoxCoder,
+                                       MaxIoUAssigner, PseudoSampler)
+
+# model settings
+model = dict(
+    type=RetinaNet,
+    data_preprocessor=dict(
+        type=DetDataPreprocessor,
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        bgr_to_rgb=True,
+        pad_size_divisor=32),
+    backbone=dict(
+        type=ResNet,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type=BatchNorm2d, requires_grad=True),
+        norm_eval=True,
+        style='pytorch',
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),
+    neck=dict(
+        type=FPN,
+        in_channels=[256, 512, 1024, 2048],
+        out_channels=256,
+        start_level=1,
+        add_extra_convs='on_input',
+        num_outs=5),
+    bbox_head=dict(
+        type=RetinaHead,
+        num_classes=80,
+        in_channels=256,
+        stacked_convs=4,
+        feat_channels=256,
+        anchor_generator=dict(
+            type=AnchorGenerator,
+            octave_base_scale=4,
+            scales_per_octave=3,
+            ratios=[0.5, 1.0, 2.0],
+            strides=[8, 16, 32, 64, 128]),
+        bbox_coder=dict(
+            type=DeltaXYWHBBoxCoder,
+            target_means=[.0, .0, .0, .0],
+            target_stds=[1.0, 1.0, 1.0, 1.0]),
+        loss_cls=dict(
+            type=FocalLoss,
+            use_sigmoid=True,
+            gamma=2.0,
+            alpha=0.25,
+            loss_weight=1.0),
+        loss_bbox=dict(type=L1Loss, loss_weight=1.0)),
+    # model training and testing settings
+    train_cfg=dict(
+        assigner=dict(
+            type=MaxIoUAssigner,
+            pos_iou_thr=0.5,
+            neg_iou_thr=0.4,
+            min_pos_iou=0,
+            ignore_iof_thr=-1),
+        sampler=dict(
+            type=PseudoSampler),  # Focal loss should use PseudoSampler
+        allowed_border=-1,
+        pos_weight=-1,
+        debug=False),
+    test_cfg=dict(
+        nms_pre=1000,
+        min_bbox_size=0,
+        score_thr=0.05,
+        nms=dict(type=nms, iou_threshold=0.5),
+        max_per_img=100))
diff --git a/mmdetection/mmdet/configs/_base_/schedules/schedule_1x.py b/mmdetection/mmdet/configs/_base_/schedules/schedule_1x.py
new file mode 100644
index 00000000..47d1fa6a
--- /dev/null
+++ b/mmdetection/mmdet/configs/_base_/schedules/schedule_1x.py
@@ -0,0 +1,33 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.optim.optimizer.optimizer_wrapper import OptimWrapper
+from mmengine.optim.scheduler.lr_scheduler import LinearLR, MultiStepLR
+from mmengine.runner.loops import EpochBasedTrainLoop, TestLoop, ValLoop
+from torch.optim.sgd import SGD
+
+# training schedule for 1x
+train_cfg = dict(type=EpochBasedTrainLoop, max_epochs=12, val_interval=1)
+val_cfg = dict(type=ValLoop)
+test_cfg = dict(type=TestLoop)
+
+# learning rate
+param_scheduler = [
+    dict(type=LinearLR, start_factor=0.001, by_epoch=False, begin=0, end=500),
+    dict(
+        type=MultiStepLR,
+        begin=0,
+        end=12,
+        by_epoch=True,
+        milestones=[8, 11],
+        gamma=0.1)
+]
+
+# optimizer
+optim_wrapper = dict(
+    type=OptimWrapper,
+    optimizer=dict(type=SGD, lr=0.02, momentum=0.9, weight_decay=0.0001))
+
+# Default setting for scaling LR automatically
+#   - `enable` means enable scaling LR automatically
+#       or not by default.
+#   - `base_batch_size` = (8 GPUs) x (2 samples per GPU).
+auto_scale_lr = dict(enable=False, base_batch_size=16)
diff --git a/mmdetection/mmdet/configs/_base_/schedules/schedule_2x.py b/mmdetection/mmdet/configs/_base_/schedules/schedule_2x.py
new file mode 100644
index 00000000..51ba09a4
--- /dev/null
+++ b/mmdetection/mmdet/configs/_base_/schedules/schedule_2x.py
@@ -0,0 +1,33 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.optim.optimizer.optimizer_wrapper import OptimWrapper
+from mmengine.optim.scheduler.lr_scheduler import LinearLR, MultiStepLR
+from mmengine.runner.loops import EpochBasedTrainLoop, TestLoop, ValLoop
+from torch.optim.sgd import SGD
+
+# training schedule for 1x
+train_cfg = dict(type=EpochBasedTrainLoop, max_epochs=24, val_interval=1)
+val_cfg = dict(type=ValLoop)
+test_cfg = dict(type=TestLoop)
+
+# learning rate
+param_scheduler = [
+    dict(type=LinearLR, start_factor=0.001, by_epoch=False, begin=0, end=500),
+    dict(
+        type=MultiStepLR,
+        begin=0,
+        end=24,
+        by_epoch=True,
+        milestones=[16, 22],
+        gamma=0.1)
+]
+
+# optimizer
+optim_wrapper = dict(
+    type=OptimWrapper,
+    optimizer=dict(type=SGD, lr=0.02, momentum=0.9, weight_decay=0.0001))
+
+# Default setting for scaling LR automatically
+#   - `enable` means enable scaling LR automatically
+#       or not by default.
+#   - `base_batch_size` = (8 GPUs) x (2 samples per GPU).
+auto_scale_lr = dict(enable=False, base_batch_size=16)
diff --git a/mmdetection/mmdet/configs/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco.py b/mmdetection/mmdet/configs/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco.py
new file mode 100644
index 00000000..a81c25af
--- /dev/null
+++ b/mmdetection/mmdet/configs/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco.py
@@ -0,0 +1,13 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .._base_.datasets.coco_instance import *
+    from .._base_.default_runtime import *
+    from .._base_.models.cascade_mask_rcnn_r50_fpn import *
+    from .._base_.schedules.schedule_1x import *
diff --git a/mmdetection/mmdet/configs/cascade_rcnn/cascade_rcnn_r50_fpn_1x_coco.py b/mmdetection/mmdet/configs/cascade_rcnn/cascade_rcnn_r50_fpn_1x_coco.py
new file mode 100644
index 00000000..883f09be
--- /dev/null
+++ b/mmdetection/mmdet/configs/cascade_rcnn/cascade_rcnn_r50_fpn_1x_coco.py
@@ -0,0 +1,13 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .._base_.datasets.coco_detection import *
+    from .._base_.default_runtime import *
+    from .._base_.models.cascade_rcnn_r50_fpn import *
+    from .._base_.schedules.schedule_1x import *
diff --git a/mmdetection/mmdet/configs/common/lsj_100e_coco_detection.py b/mmdetection/mmdet/configs/common/lsj_100e_coco_detection.py
new file mode 100644
index 00000000..ea2d6bad
--- /dev/null
+++ b/mmdetection/mmdet/configs/common/lsj_100e_coco_detection.py
@@ -0,0 +1,134 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .._base_.default_runtime import *
+
+from mmengine.dataset.sampler import DefaultSampler
+from mmengine.optim import OptimWrapper
+from mmengine.optim.scheduler.lr_scheduler import LinearLR, MultiStepLR
+from mmengine.runner.loops import EpochBasedTrainLoop, TestLoop, ValLoop
+from torch.optim import SGD
+
+from mmdet.datasets import CocoDataset, RepeatDataset
+from mmdet.datasets.transforms.formatting import PackDetInputs
+from mmdet.datasets.transforms.loading import (FilterAnnotations,
+                                               LoadAnnotations,
+                                               LoadImageFromFile)
+from mmdet.datasets.transforms.transforms import (CachedMixUp, CachedMosaic,
+                                                  Pad, RandomCrop, RandomFlip,
+                                                  RandomResize, Resize)
+from mmdet.evaluation import CocoMetric
+
+# dataset settings
+dataset_type = CocoDataset
+data_root = 'data/coco/'
+image_size = (1024, 1024)
+
+backend_args = None
+
+train_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=LoadAnnotations, with_bbox=True, with_mask=True),
+    dict(
+        type=RandomResize,
+        scale=image_size,
+        ratio_range=(0.1, 2.0),
+        keep_ratio=True),
+    dict(
+        type=RandomCrop,
+        crop_type='absolute_range',
+        crop_size=image_size,
+        recompute_bbox=True,
+        allow_negative_crop=True),
+    dict(type=FilterAnnotations, min_gt_bbox_wh=(1e-2, 1e-2)),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=PackDetInputs)
+]
+test_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=Resize, scale=(1333, 800), keep_ratio=True),
+    dict(type=LoadAnnotations, with_bbox=True),
+    dict(
+        type=PackDetInputs,
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+
+# Use RepeatDataset to speed up training
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type=DefaultSampler, shuffle=True),
+    dataset=dict(
+        type=RepeatDataset,
+        times=4,  # simply change this from 2 to 16 for 50e - 400e training.
+        dataset=dict(
+            type=dataset_type,
+            data_root=data_root,
+            ann_file='annotations/instances_train2017.json',
+            data_prefix=dict(img='train2017/'),
+            filter_cfg=dict(filter_empty_gt=True, min_size=32),
+            pipeline=train_pipeline,
+            backend_args=backend_args)))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type=DefaultSampler, shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='annotations/instances_val2017.json',
+        data_prefix=dict(img='val2017/'),
+        test_mode=True,
+        pipeline=test_pipeline,
+        backend_args=backend_args))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(
+    type=CocoMetric,
+    ann_file=data_root + 'annotations/instances_val2017.json',
+    metric=['bbox', 'segm'],
+    format_only=False,
+    backend_args=backend_args)
+test_evaluator = val_evaluator
+
+max_epochs = 25
+
+train_cfg = dict(
+    type=EpochBasedTrainLoop, max_epochs=max_epochs, val_interval=5)
+val_cfg = dict(type=ValLoop)
+test_cfg = dict(type=TestLoop)
+
+# optimizer assumes bs=64
+optim_wrapper = dict(
+    type=OptimWrapper,
+    optimizer=dict(type=SGD, lr=0.1, momentum=0.9, weight_decay=0.00004))
+
+# learning rate
+param_scheduler = [
+    dict(type=LinearLR, start_factor=0.067, by_epoch=False, begin=0, end=500),
+    dict(
+        type=MultiStepLR,
+        begin=0,
+        end=max_epochs,
+        by_epoch=True,
+        milestones=[22, 24],
+        gamma=0.1)
+]
+
+# only keep latest 2 checkpoints
+default_hooks.update(dict(checkpoint=dict(max_keep_ckpts=2)))
+
+# NOTE: `auto_scale_lr` is for automatically scaling LR,
+# USER SHOULD NOT CHANGE ITS VALUES.
+# base_batch_size = (32 GPUs) x (2 samples per GPU)
+auto_scale_lr = dict(base_batch_size=64)
diff --git a/mmdetection/mmdet/configs/common/lsj_100e_coco_instance.py b/mmdetection/mmdet/configs/common/lsj_100e_coco_instance.py
new file mode 100644
index 00000000..90104ee5
--- /dev/null
+++ b/mmdetection/mmdet/configs/common/lsj_100e_coco_instance.py
@@ -0,0 +1,134 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .._base_.default_runtime import *
+
+from mmengine.dataset.sampler import DefaultSampler
+from mmengine.optim import OptimWrapper
+from mmengine.optim.scheduler.lr_scheduler import LinearLR, MultiStepLR
+from mmengine.runner.loops import EpochBasedTrainLoop, TestLoop, ValLoop
+from torch.optim import SGD
+
+from mmdet.datasets import CocoDataset, RepeatDataset
+from mmdet.datasets.transforms.formatting import PackDetInputs
+from mmdet.datasets.transforms.loading import (FilterAnnotations,
+                                               LoadAnnotations,
+                                               LoadImageFromFile)
+from mmdet.datasets.transforms.transforms import (CachedMixUp, CachedMosaic,
+                                                  Pad, RandomCrop, RandomFlip,
+                                                  RandomResize, Resize)
+from mmdet.evaluation import CocoMetric
+
+# dataset settings
+dataset_type = CocoDataset
+data_root = 'data/coco/'
+image_size = (1024, 1024)
+
+backend_args = None
+
+train_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=LoadAnnotations, with_bbox=True, with_mask=True),
+    dict(
+        type=RandomResize,
+        scale=image_size,
+        ratio_range=(0.1, 2.0),
+        keep_ratio=True),
+    dict(
+        type=RandomCrop,
+        crop_type='absolute_range',
+        crop_size=image_size,
+        recompute_bbox=True,
+        allow_negative_crop=True),
+    dict(type=FilterAnnotations, min_gt_bbox_wh=(1e-2, 1e-2)),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=PackDetInputs)
+]
+test_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=Resize, scale=(1333, 800), keep_ratio=True),
+    dict(type=LoadAnnotations, with_bbox=True, with_mask=True),
+    dict(
+        type=PackDetInputs,
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+
+# Use RepeatDataset to speed up training
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type=DefaultSampler, shuffle=True),
+    dataset=dict(
+        type=RepeatDataset,
+        times=4,  # simply change this from 2 to 16 for 50e - 400e training.
+        dataset=dict(
+            type=dataset_type,
+            data_root=data_root,
+            ann_file='annotations/instances_train2017.json',
+            data_prefix=dict(img='train2017/'),
+            filter_cfg=dict(filter_empty_gt=True, min_size=32),
+            pipeline=train_pipeline,
+            backend_args=backend_args)))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type=DefaultSampler, shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='annotations/instances_val2017.json',
+        data_prefix=dict(img='val2017/'),
+        test_mode=True,
+        pipeline=test_pipeline,
+        backend_args=backend_args))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(
+    type=CocoMetric,
+    ann_file=data_root + 'annotations/instances_val2017.json',
+    metric=['bbox', 'segm'],
+    format_only=False,
+    backend_args=backend_args)
+test_evaluator = val_evaluator
+
+max_epochs = 25
+
+train_cfg = dict(
+    type=EpochBasedTrainLoop, max_epochs=max_epochs, val_interval=5)
+val_cfg = dict(type=ValLoop)
+test_cfg = dict(type=TestLoop)
+
+# optimizer assumes bs=64
+optim_wrapper = dict(
+    type=OptimWrapper,
+    optimizer=dict(type=SGD, lr=0.1, momentum=0.9, weight_decay=0.00004))
+
+# learning rate
+param_scheduler = [
+    dict(type=LinearLR, start_factor=0.067, by_epoch=False, begin=0, end=500),
+    dict(
+        type=MultiStepLR,
+        begin=0,
+        end=max_epochs,
+        by_epoch=True,
+        milestones=[22, 24],
+        gamma=0.1)
+]
+
+# only keep latest 2 checkpoints
+default_hooks.update(dict(checkpoint=dict(max_keep_ckpts=2)))
+
+# NOTE: `auto_scale_lr` is for automatically scaling LR,
+# USER SHOULD NOT CHANGE ITS VALUES.
+# base_batch_size = (32 GPUs) x (2 samples per GPU)
+auto_scale_lr = dict(base_batch_size=64)
diff --git a/mmdetection/mmdet/configs/common/lsj_200e_coco_detection.py b/mmdetection/mmdet/configs/common/lsj_200e_coco_detection.py
new file mode 100644
index 00000000..5759499e
--- /dev/null
+++ b/mmdetection/mmdet/configs/common/lsj_200e_coco_detection.py
@@ -0,0 +1,25 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .lsj_100e_coco_detection import *
+
+# 8x25=200e
+train_dataloader.update(dict(dataset=dict(times=8)))
+
+# learning rate
+param_scheduler = [
+    dict(type=LinearLR, start_factor=0.067, by_epoch=False, begin=0, end=1000),
+    dict(
+        type=MultiStepLR,
+        begin=0,
+        end=25,
+        by_epoch=True,
+        milestones=[22, 24],
+        gamma=0.1)
+]
diff --git a/mmdetection/mmdet/configs/common/lsj_200e_coco_instance.py b/mmdetection/mmdet/configs/common/lsj_200e_coco_instance.py
new file mode 100644
index 00000000..77c5cdd4
--- /dev/null
+++ b/mmdetection/mmdet/configs/common/lsj_200e_coco_instance.py
@@ -0,0 +1,25 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .lsj_100e_coco_instance import *
+
+# 8x25=200e
+train_dataloader.update(dict(dataset=dict(times=8)))
+
+# learning rate
+param_scheduler = [
+    dict(type=LinearLR, start_factor=0.067, by_epoch=False, begin=0, end=1000),
+    dict(
+        type=MultiStepLR,
+        begin=0,
+        end=25,
+        by_epoch=True,
+        milestones=[22, 24],
+        gamma=0.1)
+]
diff --git a/mmdetection/mmdet/configs/common/ms_3x_coco.py b/mmdetection/mmdet/configs/common/ms_3x_coco.py
new file mode 100644
index 00000000..c32b24d9
--- /dev/null
+++ b/mmdetection/mmdet/configs/common/ms_3x_coco.py
@@ -0,0 +1,130 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .._base_.default_runtime import *
+
+from mmcv.transforms import RandomResize
+from mmengine.dataset import RepeatDataset
+from mmengine.dataset.sampler import DefaultSampler
+from mmengine.optim import OptimWrapper
+from mmengine.optim.scheduler.lr_scheduler import LinearLR, MultiStepLR
+from mmengine.runner.loops import EpochBasedTrainLoop, TestLoop, ValLoop
+from torch.optim import SGD
+
+from mmdet.datasets import AspectRatioBatchSampler, CocoDataset
+from mmdet.datasets.transforms.formatting import PackDetInputs
+from mmdet.datasets.transforms.loading import (LoadAnnotations,
+                                               LoadImageFromFile)
+from mmdet.datasets.transforms.transforms import RandomFlip, Resize
+from mmdet.evaluation import CocoMetric
+
+# dataset settings
+dataset_type = CocoDataset
+data_root = 'data/coco/'
+
+# Example to use different file client
+# Method 1: simply set the data root and let the file I/O module
+# automatically infer from prefix (not support LMDB and Memcache yet)
+
+# data_root = 's3://openmmlab/datasets/detection/coco/'
+
+# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6
+# backend_args = dict(
+#     backend='petrel',
+#     path_mapping=dict({
+#         './data/': 's3://openmmlab/datasets/detection/',
+#         'data/': 's3://openmmlab/datasets/detection/'
+#     }))
+backend_args = None
+
+# In mstrain 3x config, img_scale=[(1333, 640), (1333, 800)],
+# multiscale_mode='range'
+train_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=LoadAnnotations, with_bbox=True),
+    dict(type=RandomResize, scale=[(1333, 640), (1333, 800)], keep_ratio=True),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=PackDetInputs)
+]
+test_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=Resize, scale=(1333, 800), keep_ratio=True),
+    dict(type=LoadAnnotations, with_bbox=True),
+    dict(
+        type=PackDetInputs,
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=2,
+    persistent_workers=True,
+    pin_memory=True,
+    sampler=dict(type=DefaultSampler, shuffle=True),
+    batch_sampler=dict(type=AspectRatioBatchSampler),
+    dataset=dict(
+        type=RepeatDataset,
+        times=3,
+        dataset=dict(
+            type=dataset_type,
+            data_root=data_root,
+            ann_file='annotations/instances_train2017.json',
+            data_prefix=dict(img='train2017/'),
+            filter_cfg=dict(filter_empty_gt=True, min_size=32),
+            pipeline=train_pipeline,
+            backend_args=backend_args)))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type=DefaultSampler, shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='annotations/instances_val2017.json',
+        data_prefix=dict(img='val2017/'),
+        test_mode=True,
+        pipeline=test_pipeline,
+        backend_args=backend_args))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(
+    type=CocoMetric,
+    ann_file=data_root + 'annotations/instances_val2017.json',
+    metric='bbox',
+    backend_args=backend_args)
+test_evaluator = val_evaluator
+
+# training schedule for 3x with `RepeatDataset`
+train_cfg = dict(type=EpochBasedTrainLoop, max_iters=12, val_interval=1)
+val_cfg = dict(type=ValLoop)
+test_cfg = dict(type=TestLoop)
+
+# learning rate
+param_scheduler = [
+    dict(type=LinearLR, start_factor=0.001, by_epoch=False, begin=0, end=500),
+    dict(
+        type=MultiStepLR,
+        begin=0,
+        end=12,
+        by_epoch=False,
+        milestones=[9, 11],
+        gamma=0.1)
+]
+
+# optimizer
+optim_wrapper = dict(
+    type=OptimWrapper,
+    optimizer=dict(type=SGD, lr=0.02, momentum=0.9, weight_decay=0.0001))
+# Default setting for scaling LR automatically
+#   - `enable` means enable scaling LR automatically
+#       or not by default.
+#   - `base_batch_size` = (8 GPUs) x (2 samples per GPU).
+auto_scale_lr = dict(enable=False, base_batch_size=16)
diff --git a/mmdetection/mmdet/configs/common/ms_3x_coco_instance.py b/mmdetection/mmdet/configs/common/ms_3x_coco_instance.py
new file mode 100644
index 00000000..3c78909d
--- /dev/null
+++ b/mmdetection/mmdet/configs/common/ms_3x_coco_instance.py
@@ -0,0 +1,136 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .._base_.default_runtime import *
+
+from mmcv.transforms import RandomChoiceResize
+from mmengine.dataset import RepeatDataset
+from mmengine.dataset.sampler import DefaultSampler, InfiniteSampler
+from mmengine.optim import OptimWrapper
+from mmengine.optim.scheduler.lr_scheduler import LinearLR, MultiStepLR
+from mmengine.runner.loops import IterBasedTrainLoop, TestLoop, ValLoop
+from torch.optim import SGD
+
+from mmdet.datasets import AspectRatioBatchSampler, CocoDataset
+from mmdet.datasets.transforms.formatting import PackDetInputs
+from mmdet.datasets.transforms.loading import (FilterAnnotations,
+                                               LoadAnnotations,
+                                               LoadImageFromFile)
+from mmdet.datasets.transforms.transforms import (CachedMixUp, CachedMosaic,
+                                                  Pad, RandomCrop, RandomFlip,
+                                                  RandomResize, Resize)
+from mmdet.evaluation import CocoMetric
+
+# dataset settings
+dataset_type = CocoDataset
+data_root = 'data/coco/'
+
+# Example to use different file client
+# Method 1: simply set the data root and let the file I/O module
+# automatically infer from prefix (not support LMDB and Memcache yet)
+
+# data_root = 's3://openmmlab/datasets/detection/coco/'
+
+# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6
+# backend_args = dict(
+#     backend='petrel',
+#     path_mapping=dict({
+#         './data/': 's3://openmmlab/datasets/detection/',
+#         'data/': 's3://openmmlab/datasets/detection/'
+#     }))
+backend_args = None
+
+train_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=LoadAnnotations, with_bbox=True, with_mask=True),
+    dict(
+        type='RandomResize', scale=[(1333, 640), (1333, 800)],
+        keep_ratio=True),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=PackDetInputs)
+]
+test_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=Resize, scale=(1333, 800), keep_ratio=True),
+    dict(type=LoadAnnotations, with_bbox=True, with_mask=True),
+    dict(
+        type=PackDetInputs,
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+train_dataloader.update(
+    dict(
+        batch_size=2,
+        num_workers=2,
+        persistent_workers=True,
+        sampler=dict(type=DefaultSampler, shuffle=True),
+        batch_sampler=dict(type=AspectRatioBatchSampler),
+        dataset=dict(
+            type=RepeatDataset,
+            times=3,
+            dataset=dict(
+                type=dataset_type,
+                data_root=data_root,
+                ann_file='annotations/instances_train2017.json',
+                data_prefix=dict(img='train2017/'),
+                filter_cfg=dict(filter_empty_gt=True, min_size=32),
+                pipeline=train_pipeline,
+                backend_args=backend_args))))
+val_dataloader.update(
+    dict(
+        batch_size=1,
+        num_workers=2,
+        persistent_workers=True,
+        drop_last=False,
+        sampler=dict(type=DefaultSampler, shuffle=False),
+        dataset=dict(
+            type=dataset_type,
+            data_root=data_root,
+            ann_file='annotations/instances_val2017.json',
+            data_prefix=dict(img='val2017/'),
+            test_mode=True,
+            pipeline=test_pipeline,
+            backend_args=backend_args)))
+test_dataloader = val_dataloader
+
+val_evaluator.update(
+    dict(
+        type=CocoMetric,
+        ann_file=data_root + 'annotations/instances_val2017.json',
+        metric='bbox',
+        backend_args=backend_args))
+test_evaluator = val_evaluator
+
+# training schedule for 3x with `RepeatDataset`
+train_cfg.update(dict(type=EpochBasedTrainLoop, max_epochs=12, val_interval=1))
+val_cfg.update(dict(type=ValLoop))
+test_cfg.update(dict(type=TestLoop))
+
+# learning rate
+param_scheduler = [
+    dict(type=LinearLR, start_factor=0.001, by_epoch=False, begin=0, end=500),
+    dict(
+        type=MultiStepLR,
+        begin=0,
+        end=12,
+        by_epoch=False,
+        milestones=[9, 11],
+        gamma=0.1)
+]
+
+# optimizer
+optim_wrapper.update(
+    dict(
+        type=OptimWrapper,
+        optimizer=dict(type=SGD, lr=0.02, momentum=0.9, weight_decay=0.0001)))
+# Default setting for scaling LR automatically
+#   - `enable` means enable scaling LR automatically
+#       or not by default.
+#   - `base_batch_size` = (8 GPUs) x (2 samples per GPU).
+auto_scale_lr.update(dict(enable=False, base_batch_size=16))
diff --git a/mmdetection/mmdet/configs/common/ms_90k_coco.py b/mmdetection/mmdet/configs/common/ms_90k_coco.py
new file mode 100644
index 00000000..3abf1d4a
--- /dev/null
+++ b/mmdetection/mmdet/configs/common/ms_90k_coco.py
@@ -0,0 +1,151 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .._base_.default_runtime import *
+
+from mmcv.transforms import RandomChoiceResize
+from mmengine.dataset import RepeatDataset
+from mmengine.dataset.sampler import DefaultSampler, InfiniteSampler
+from mmengine.optim import OptimWrapper
+from mmengine.optim.scheduler.lr_scheduler import LinearLR, MultiStepLR
+from mmengine.runner.loops import IterBasedTrainLoop, TestLoop, ValLoop
+from torch.optim import SGD
+
+from mmdet.datasets import AspectRatioBatchSampler, CocoDataset
+from mmdet.datasets.transforms.formatting import PackDetInputs
+from mmdet.datasets.transforms.loading import (FilterAnnotations,
+                                               LoadAnnotations,
+                                               LoadImageFromFile)
+from mmdet.datasets.transforms.transforms import (CachedMixUp, CachedMosaic,
+                                                  Pad, RandomCrop, RandomFlip,
+                                                  RandomResize, Resize)
+from mmdet.evaluation import CocoMetric
+
+# dataset settings
+dataset_type = CocoDataset
+data_root = 'data/coco/'
+# Example to use different file client
+# Method 1: simply set the data root and let the file I/O module
+# automatically infer from prefix (not support LMDB and Memcache yet)
+
+# data_root = 's3://openmmlab/datasets/detection/coco/'
+
+# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6
+# backend_args = dict(
+#     backend='petrel',
+#     path_mapping=dict({
+#         './data/': 's3://openmmlab/datasets/detection/',
+#         'data/': 's3://openmmlab/datasets/detection/'
+#     }))
+backend_args = None
+
+# Align with Detectron2
+backend = 'pillow'
+train_pipeline = [
+    dict(
+        type=LoadImageFromFile,
+        backend_args=backend_args,
+        imdecode_backend=backend),
+    dict(type=LoadAnnotations, with_bbox=True),
+    dict(
+        type=RandomChoiceResize,
+        scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736),
+                (1333, 768), (1333, 800)],
+        keep_ratio=True,
+        backend=backend),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=PackDetInputs)
+]
+test_pipeline = [
+    dict(
+        type=LoadImageFromFile,
+        backend_args=backend_args,
+        imdecode_backend=backend),
+    dict(type=Resize, scale=(1333, 800), keep_ratio=True, backend=backend),
+    dict(type=LoadAnnotations, with_bbox=True),
+    dict(
+        type=PackDetInputs,
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+train_dataloader.update(
+    dict(
+        batch_size=2,
+        num_workers=2,
+        persistent_workers=True,
+        pin_memory=True,
+        sampler=dict(type=InfiniteSampler, shuffle=True),
+        batch_sampler=dict(type=AspectRatioBatchSampler),
+        dataset=dict(
+            type=dataset_type,
+            data_root=data_root,
+            ann_file='annotations/instances_train2017.json',
+            data_prefix=dict(img='train2017/'),
+            filter_cfg=dict(filter_empty_gt=True, min_size=32),
+            pipeline=train_pipeline,
+            backend_args=backend_args)))
+val_dataloader.update(
+    dict(
+        batch_size=1,
+        num_workers=2,
+        persistent_workers=True,
+        drop_last=False,
+        pin_memory=True,
+        sampler=dict(type=DefaultSampler, shuffle=False),
+        dataset=dict(
+            type=dataset_type,
+            data_root=data_root,
+            ann_file='annotations/instances_val2017.json',
+            data_prefix=dict(img='val2017/'),
+            test_mode=True,
+            pipeline=test_pipeline,
+            backend_args=backend_args)))
+test_dataloader = val_dataloader
+
+val_evaluator.update(
+    dict(
+        type=CocoMetric,
+        ann_file=data_root + 'annotations/instances_val2017.json',
+        metric='bbox',
+        format_only=False,
+        backend_args=backend_args))
+test_evaluator = val_evaluator
+
+# training schedule for 90k
+max_iter = 90000
+train_cfg.update(
+    dict(type=IterBasedTrainLoop, max_iters=max_iter, val_interval=10000))
+val_cfg.update(dict(type=ValLoop))
+test_cfg.update(dict(type=TestLoop))
+
+# learning rate
+param_scheduler = [
+    dict(type=LinearLR, start_factor=0.001, by_epoch=False, begin=0, end=1000),
+    dict(
+        type=MultiStepLR,
+        begin=0,
+        end=max_iter,
+        by_epoch=False,
+        milestones=[60000, 80000],
+        gamma=0.1)
+]
+
+# optimizer
+optim_wrapper.update(
+    dict(
+        type=OptimWrapper,
+        optimizer=dict(type=SGD, lr=0.02, momentum=0.9, weight_decay=0.0001)))
+# Default setting for scaling LR automatically
+#   - `enable` means enable scaling LR automatically
+#       or not by default.
+#   - `base_batch_size` = (8 GPUs) x (2 samples per GPU).
+auto_scale_lr.update(dict(enable=False, base_batch_size=16))
+
+default_hooks.update(dict(checkpoint=dict(by_epoch=False, interval=10000)))
+log_processor.update(dict(by_epoch=False))
diff --git a/mmdetection/mmdet/configs/common/ms_poly_3x_coco_instance.py b/mmdetection/mmdet/configs/common/ms_poly_3x_coco_instance.py
new file mode 100644
index 00000000..53913a05
--- /dev/null
+++ b/mmdetection/mmdet/configs/common/ms_poly_3x_coco_instance.py
@@ -0,0 +1,138 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .._base_.default_runtime import *
+
+from mmcv.transforms import RandomChoiceResize
+from mmengine.dataset import RepeatDataset
+from mmengine.dataset.sampler import DefaultSampler, InfiniteSampler
+from mmengine.optim import OptimWrapper
+from mmengine.optim.scheduler.lr_scheduler import LinearLR, MultiStepLR
+from mmengine.runner.loops import IterBasedTrainLoop, TestLoop, ValLoop
+from torch.optim import SGD
+
+from mmdet.datasets import AspectRatioBatchSampler, CocoDataset
+from mmdet.datasets.transforms.formatting import PackDetInputs
+from mmdet.datasets.transforms.loading import (FilterAnnotations,
+                                               LoadAnnotations,
+                                               LoadImageFromFile)
+from mmdet.datasets.transforms.transforms import (CachedMixUp, CachedMosaic,
+                                                  Pad, RandomCrop, RandomFlip,
+                                                  RandomResize, Resize)
+from mmdet.evaluation import CocoMetric
+
+# dataset settings
+dataset_type = CocoDataset
+data_root = 'data/coco/'
+# Example to use different file client
+# Method 1: simply set the data root and let the file I/O module
+# automatically infer from prefix (not support LMDB and Memcache yet)
+
+# data_root = 's3://openmmlab/datasets/detection/coco/'
+
+# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6
+# backend_args = dict(
+#     backend='petrel',
+#     path_mapping=dict({
+#         './data/': 's3://openmmlab/datasets/detection/',
+#         'data/': 's3://openmmlab/datasets/detection/'
+#     }))
+backend_args = None
+
+# In mstrain 3x config, img_scale=[(1333, 640), (1333, 800)],
+# multiscale_mode='range'
+train_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(
+        type=LoadAnnotations, with_bbox=True, with_mask=True, poly2mask=False),
+    dict(
+        type='RandomResize', scale=[(1333, 640), (1333, 800)],
+        keep_ratio=True),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=PackDetInputs)
+]
+test_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=Resize, scale=(1333, 800), keep_ratio=True),
+    dict(
+        type=LoadAnnotations, with_bbox=True, with_mask=True, poly2mask=False),
+    dict(
+        type=PackDetInputs,
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+train_dataloader.update(
+    dict(
+        batch_size=2,
+        num_workers=2,
+        persistent_workers=True,
+        pin_memory=True,
+        sampler=dict(type=DefaultSampler, shuffle=True),
+        batch_sampler=dict(type=AspectRatioBatchSampler),
+        dataset=dict(
+            type=RepeatDataset,
+            data_root=data_root,
+            ann_file='annotations/instances_train2017.json',
+            data_prefix=dict(img='train2017/'),
+            filter_cfg=dict(filter_empty_gt=True, min_size=32),
+            pipeline=train_pipeline,
+            backend_args=backend_args)))
+val_dataloader.update(
+    dict(
+        batch_size=2,
+        num_workers=2,
+        persistent_workers=True,
+        drop_last=False,
+        pin_memory=True,
+        sampler=dict(type=DefaultSampler, shuffle=False),
+        dataset=dict(
+            type=dataset_type,
+            data_root=data_root,
+            ann_file='annotations/instances_val2017.json',
+            data_prefix=dict(img='val2017/'),
+            test_mode=True,
+            pipeline=test_pipeline,
+            backend_args=backend_args)))
+test_dataloader = val_dataloader
+
+val_evaluator.update(
+    dict(
+        type=CocoMetric,
+        ann_file=data_root + 'annotations/instances_val2017.json',
+        metric=['bbox', 'segm'],
+        backend_args=backend_args))
+test_evaluator = val_evaluator
+
+# training schedule for 3x with `RepeatDataset`
+train_cfg.update(dict(type=EpochBasedTrainLoop, max_iters=12, val_interval=1))
+val_cfg.update(dict(type=ValLoop))
+test_cfg.update(dict(type=TestLoop))
+
+# learning rate
+param_scheduler = [
+    dict(type=LinearLR, start_factor=0.001, by_epoch=False, begin=0, end=500),
+    dict(
+        type=MultiStepLR,
+        begin=0,
+        end=12,
+        by_epoch=False,
+        milestones=[9, 11],
+        gamma=0.1)
+]
+
+# optimizer
+optim_wrapper.update(
+    dict(
+        type=OptimWrapper,
+        optimizer=dict(type=SGD, lr=0.02, momentum=0.9, weight_decay=0.0001)))
+# Default setting for scaling LR automatically
+#   - `enable` means enable scaling LR automatically
+#       or not by default.
+#   - `base_batch_size` = (8 GPUs) x (2 samples per GPU).
+auto_scale_lr.update(dict(enable=False, base_batch_size=16))
diff --git a/mmdetection/mmdet/configs/common/ms_poly_90k_coco_instance.py b/mmdetection/mmdet/configs/common/ms_poly_90k_coco_instance.py
new file mode 100644
index 00000000..52367350
--- /dev/null
+++ b/mmdetection/mmdet/configs/common/ms_poly_90k_coco_instance.py
@@ -0,0 +1,153 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .._base_.default_runtime import *
+
+from mmcv.transforms import RandomChoiceResize
+from mmengine.dataset import RepeatDataset
+from mmengine.dataset.sampler import DefaultSampler, InfiniteSampler
+from mmengine.optim import OptimWrapper
+from mmengine.optim.scheduler.lr_scheduler import LinearLR, MultiStepLR
+from mmengine.runner.loops import IterBasedTrainLoop, TestLoop, ValLoop
+from torch.optim import SGD
+
+from mmdet.datasets import AspectRatioBatchSampler, CocoDataset
+from mmdet.datasets.transforms.formatting import PackDetInputs
+from mmdet.datasets.transforms.loading import (FilterAnnotations,
+                                               LoadAnnotations,
+                                               LoadImageFromFile)
+from mmdet.datasets.transforms.transforms import (CachedMixUp, CachedMosaic,
+                                                  Pad, RandomCrop, RandomFlip,
+                                                  RandomResize, Resize)
+from mmdet.evaluation import CocoMetric
+
+# dataset settings
+dataset_type = CocoDataset
+data_root = 'data/coco/'
+# Example to use different file client
+# Method 1: simply set the data root and let the file I/O module
+# automatically infer from prefix (not support LMDB and Memcache yet)
+
+# data_root = 's3://openmmlab/datasets/detection/coco/'
+
+# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6
+# backend_args = dict(
+#     backend='petrel',
+#     path_mapping=dict({
+#         './data/': 's3://openmmlab/datasets/detection/',
+#         'data/': 's3://openmmlab/datasets/detection/'
+#     }))
+backend_args = None
+
+# Align with Detectron2
+backend = 'pillow'
+train_pipeline = [
+    dict(
+        type=LoadImageFromFile,
+        backend_args=backend_args,
+        imdecode_backend=backend),
+    dict(
+        type=LoadAnnotations, with_bbox=True, with_mask=True, poly2mask=False),
+    dict(
+        type=RandomChoiceResize,
+        scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736),
+                (1333, 768), (1333, 800)],
+        keep_ratio=True,
+        backend=backend),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=PackDetInputs)
+]
+test_pipeline = [
+    dict(
+        type=LoadImageFromFile,
+        backend_args=backend_args,
+        imdecode_backend=backend),
+    dict(type=Resize, scale=(1333, 800), keep_ratio=True, backend=backend),
+    dict(
+        type=LoadAnnotations, with_bbox=True, with_mask=True, poly2mask=False),
+    dict(
+        type=PackDetInputs,
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+train_dataloader.update(
+    dict(
+        batch_size=2,
+        num_workers=2,
+        persistent_workers=True,
+        pin_memory=True,
+        sampler=dict(type=InfiniteSampler, shuffle=True),
+        batch_sampler=dict(type=AspectRatioBatchSampler),
+        dataset=dict(
+            type=dataset_type,
+            data_root=data_root,
+            ann_file='annotations/instances_train2017.json',
+            data_prefix=dict(img='train2017/'),
+            filter_cfg=dict(filter_empty_gt=True, min_size=32),
+            pipeline=train_pipeline,
+            backend_args=backend_args)))
+val_dataloader.update(
+    dict(
+        batch_size=1,
+        num_workers=2,
+        persistent_workers=True,
+        drop_last=False,
+        pin_memory=True,
+        sampler=dict(type=DefaultSampler, shuffle=False),
+        dataset=dict(
+            type=dataset_type,
+            data_root=data_root,
+            ann_file='annotations/instances_val2017.json',
+            data_prefix=dict(img='val2017/'),
+            test_mode=True,
+            pipeline=test_pipeline,
+            backend_args=backend_args)))
+test_dataloader = val_dataloader
+
+val_evaluator.update(
+    dict(
+        type=CocoMetric,
+        ann_file=data_root + 'annotations/instances_val2017.json',
+        metric=['bbox', 'segm'],
+        format_only=False,
+        backend_args=backend_args))
+test_evaluator = val_evaluator
+
+# training schedule for 90k
+max_iter = 90000
+train_cfg.update(
+    dict(type=IterBasedTrainLoop, max_iters=max_iter, val_interval=10000))
+val_cfg.update(dict(type=ValLoop))
+test_cfg.update(dict(type=TestLoop))
+
+# learning rate
+param_scheduler = [
+    dict(type=LinearLR, start_factor=0.001, by_epoch=False, begin=0, end=1000),
+    dict(
+        type=MultiStepLR,
+        begin=0,
+        end=max_iter,
+        by_epoch=False,
+        milestones=[60000, 80000],
+        gamma=0.1)
+]
+
+# optimizer
+optim_wrapper.update(
+    dict(
+        type=OptimWrapper,
+        optimizer=dict(type=SGD, lr=0.02, momentum=0.9, weight_decay=0.0001)))
+# Default setting for scaling LR automatically
+#   - `enable` means enable scaling LR automatically
+#       or not by default.
+#   - `base_batch_size` = (8 GPUs) x (2 samples per GPU).
+auto_scale_lr.update(dict(enable=False, base_batch_size=16))
+
+default_hooks.update(dict(checkpoint=dict(by_epoch=False, interval=10000)))
+log_processor.update(dict(by_epoch=False))
diff --git a/mmdetection/mmdet/configs/common/ssj_270_coco_instance.py b/mmdetection/mmdet/configs/common/ssj_270_coco_instance.py
new file mode 100644
index 00000000..ee86fdad
--- /dev/null
+++ b/mmdetection/mmdet/configs/common/ssj_270_coco_instance.py
@@ -0,0 +1,158 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .._base_.default_runtime import *
+
+from mmcv.transforms import RandomChoiceResize
+from mmengine.dataset import RepeatDataset
+from mmengine.dataset.sampler import DefaultSampler, InfiniteSampler
+from mmengine.optim import OptimWrapper
+from mmengine.optim.scheduler.lr_scheduler import LinearLR, MultiStepLR
+from mmengine.runner.loops import IterBasedTrainLoop, TestLoop, ValLoop
+from torch.optim import SGD
+
+from mmdet.datasets import AspectRatioBatchSampler, CocoDataset
+from mmdet.datasets.transforms.formatting import PackDetInputs
+from mmdet.datasets.transforms.loading import (FilterAnnotations,
+                                               LoadAnnotations,
+                                               LoadImageFromFile)
+from mmdet.datasets.transforms.transforms import (CachedMixUp, CachedMosaic,
+                                                  Pad, RandomCrop, RandomFlip,
+                                                  RandomResize, Resize)
+from mmdet.evaluation import CocoMetric
+
+# dataset settings
+dataset_type = CocoDataset
+data_root = 'data/coco/'
+# Example to use different file client
+# Method 1: simply set the data root and let the file I/O module
+# automatically infer from prefix (not support LMDB and Memcache yet)
+
+# data_root = 's3://openmmlab/datasets/detection/coco/'
+
+# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6
+# backend_args = dict(
+#     backend='petrel',
+#     path_mapping=dict({
+#         './data/': 's3://openmmlab/datasets/detection/',
+#         'data/': 's3://openmmlab/datasets/detection/'
+#     }))
+backend_args = None
+
+# Standard Scale Jittering (SSJ) resizes and crops an image
+# with a resize range of 0.8 to 1.25 of the original image size.
+train_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=LoadAnnotations, with_bbox=True, with_mask=True),
+    dict(
+        type=RandomResize,
+        scale=image_size,
+        ratio_range=(0.8, 1.25),
+        keep_ratio=True),
+    dict(
+        type='RandomCrop',
+        crop_type='absolute_range',
+        crop_size=image_size,
+        recompute_bbox=True,
+        allow_negative_crop=True),
+    dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=PackDetInputs)
+]
+test_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=Resize, scale=(1333, 800), keep_ratio=True),
+    dict(type=LoadAnnotations, with_bbox=True, with_mask=True),
+    dict(
+        type=PackDetInputs,
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+train_dataloader.update(
+    dict(
+        batch_size=2,
+        num_workers=2,
+        persistent_workers=True,
+        sampler=dict(type=InfiniteSampler),
+        dataset=dict(
+            type=dataset_type,
+            data_root=data_root,
+            ann_file='annotations/instances_train2017.json',
+            data_prefix=dict(img='train2017/'),
+            filter_cfg=dict(filter_empty_gt=True, min_size=32),
+            pipeline=train_pipeline,
+            backend_args=backend_args)))
+val_dataloader.update(
+    dict(
+        batch_size=1,
+        num_workers=2,
+        persistent_workers=True,
+        drop_last=False,
+        sampler=dict(type=DefaultSampler, shuffle=False),
+        dataset=dict(
+            type=dataset_type,
+            data_root=data_root,
+            ann_file='annotations/instances_val2017.json',
+            data_prefix=dict(img='val2017/'),
+            test_mode=True,
+            pipeline=test_pipeline,
+            backend_args=backend_args)))
+test_dataloader = val_dataloader
+
+val_evaluator.update(
+    dict(
+        type=CocoMetric,
+        ann_file=data_root + 'annotations/instances_val2017.json',
+        metric=['bbox', 'segm'],
+        format_only=False,
+        backend_args=backend_args))
+test_evaluator = val_evaluator
+
+val_evaluator = dict(
+    type=CocoMetric,
+    ann_file=data_root + 'annotations/instances_val2017.json',
+    metric=['bbox', 'segm'],
+    format_only=False,
+    backend_args=backend_args)
+test_evaluator = val_evaluator
+
+# The model is trained by 270k iterations with batch_size 64,
+# which is roughly equivalent to 144 epochs.
+
+max_iter = 270000
+train_cfg.update(
+    dict(type=IterBasedTrainLoop, max_iters=max_iter, val_interval=10000))
+val_cfg.update(dict(type=ValLoop))
+test_cfg.update(dict(type=TestLoop))
+
+# learning rate
+param_scheduler = [
+    dict(type=LinearLR, start_factor=0.001, by_epoch=False, begin=0, end=1000),
+    dict(
+        type=MultiStepLR,
+        begin=0,
+        end=max_iter,
+        by_epoch=False,
+        milestones=[243000, 256500, 263250],
+        gamma=0.1)
+]
+
+# optimizer
+optim_wrapper.update(
+    dict(
+        type=OptimWrapper,
+        optimizer=dict(type=SGD, lr=0.1, momentum=0.9, weight_decay=0.00004)))
+# Default setting for scaling LR automatically
+#   - `enable` means enable scaling LR automatically
+#       or not by default.
+#   - `base_batch_size` = (8 GPUs) x (2 samples per GPU).
+auto_scale_lr.update(dict(base_batch_size=64))
+
+default_hooks.update(dict(checkpoint=dict(by_epoch=False, interval=10000)))
+log_processor.update(dict(by_epoch=False))
diff --git a/mmdetection/mmdet/configs/common/ssj_scp_270k_coco_instance.py b/mmdetection/mmdet/configs/common/ssj_scp_270k_coco_instance.py
new file mode 100644
index 00000000..68bb1f09
--- /dev/null
+++ b/mmdetection/mmdet/configs/common/ssj_scp_270k_coco_instance.py
@@ -0,0 +1,70 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .ssj_270_coco_instance import *
+
+from mmdet.datasets import MultiImageMixDataset
+from mmdet.datasets.transforms import CopyPaste
+
+# dataset settings
+dataset_type = CocoDataset
+data_root = 'data/coco/'
+image_size = (1024, 1024)
+# Example to use different file client
+# Method 1: simply set the data root and let the file I/O module
+# automatically infer from prefix (not support LMDB and Memcache yet)
+
+# data_root = 's3://openmmlab/datasets/detection/coco/'
+
+# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6
+# backend_args = dict(
+#     backend='petrel',
+#     path_mapping=dict({
+#         './data/': 's3://openmmlab/datasets/detection/',
+#         'data/': 's3://openmmlab/datasets/detection/'
+#     }))
+backend_args = None
+
+# Standard Scale Jittering (SSJ) resizes and crops an image
+# with a resize range of 0.8 to 1.25 of the original image size.
+load_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=LoadAnnotations, with_bbox=True, with_mask=True),
+    dict(
+        type=RandomResize,
+        scale=image_size,
+        ratio_range=(0.8, 1.25),
+        keep_ratio=True),
+    dict(
+        type='RandomCrop',
+        crop_type='absolute_range',
+        crop_size=image_size,
+        recompute_bbox=True,
+        allow_negative_crop=True),
+    dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=Pad, size=image_size),
+]
+train_pipeline = [
+    dict(type=CopyPaste, max_num_pasted=100),
+    dict(type=PackDetInputs)
+]
+
+train_dataloader.update(
+    dict(
+        type=MultiImageMixDataset,
+        dataset=dict(
+            type=dataset_type,
+            data_root=data_root,
+            ann_file='annotations/instances_train2017.json',
+            data_prefix=dict(img='train2017/'),
+            filter_cfg=dict(filter_empty_gt=True, min_size=32),
+            pipeline=load_pipeline,
+            backend_args=backend_args),
+        pipeline=train_pipeline))
diff --git a/mmdetection/mmdet/configs/deformable_detr/deformable_detr_r50_16xb2_50e_coco.py b/mmdetection/mmdet/configs/deformable_detr/deformable_detr_r50_16xb2_50e_coco.py
new file mode 100644
index 00000000..ee2a4163
--- /dev/null
+++ b/mmdetection/mmdet/configs/deformable_detr/deformable_detr_r50_16xb2_50e_coco.py
@@ -0,0 +1,186 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .._base_.datasets.coco_detection import *
+    from .._base_.default_runtime import *
+
+from mmcv.transforms import LoadImageFromFile, RandomChoice, RandomChoiceResize
+from mmengine.optim.optimizer import OptimWrapper
+from mmengine.optim.scheduler import MultiStepLR
+from mmengine.runner.loops import EpochBasedTrainLoop, TestLoop, ValLoop
+from torch.optim.adamw import AdamW
+
+from mmdet.datasets.transforms import (LoadAnnotations, PackDetInputs,
+                                       RandomCrop, RandomFlip, Resize)
+from mmdet.models.backbones import ResNet
+from mmdet.models.data_preprocessors import DetDataPreprocessor
+from mmdet.models.dense_heads import DeformableDETRHead
+from mmdet.models.detectors import DeformableDETR
+from mmdet.models.losses import FocalLoss, GIoULoss, L1Loss
+from mmdet.models.necks import ChannelMapper
+from mmdet.models.task_modules import (BBoxL1Cost, FocalLossCost,
+                                       HungarianAssigner, IoUCost)
+
+model = dict(
+    type=DeformableDETR,
+    num_queries=300,
+    num_feature_levels=4,
+    with_box_refine=False,
+    as_two_stage=False,
+    data_preprocessor=dict(
+        type=DetDataPreprocessor,
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        bgr_to_rgb=True,
+        pad_size_divisor=1),
+    backbone=dict(
+        type=ResNet,
+        depth=50,
+        num_stages=4,
+        out_indices=(1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type='BN', requires_grad=False),
+        norm_eval=True,
+        style='pytorch',
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),
+    neck=dict(
+        type=ChannelMapper,
+        in_channels=[512, 1024, 2048],
+        kernel_size=1,
+        out_channels=256,
+        act_cfg=None,
+        norm_cfg=dict(type='GN', num_groups=32),
+        num_outs=4),
+    encoder=dict(  # DeformableDetrTransformerEncoder
+        num_layers=6,
+        layer_cfg=dict(  # DeformableDetrTransformerEncoderLayer
+            self_attn_cfg=dict(  # MultiScaleDeformableAttention
+                embed_dims=256,
+                batch_first=True),
+            ffn_cfg=dict(
+                embed_dims=256, feedforward_channels=1024, ffn_drop=0.1))),
+    decoder=dict(  # DeformableDetrTransformerDecoder
+        num_layers=6,
+        return_intermediate=True,
+        layer_cfg=dict(  # DeformableDetrTransformerDecoderLayer
+            self_attn_cfg=dict(  # MultiheadAttention
+                embed_dims=256,
+                num_heads=8,
+                dropout=0.1,
+                batch_first=True),
+            cross_attn_cfg=dict(  # MultiScaleDeformableAttention
+                embed_dims=256,
+                batch_first=True),
+            ffn_cfg=dict(
+                embed_dims=256, feedforward_channels=1024, ffn_drop=0.1)),
+        post_norm_cfg=None),
+    positional_encoding=dict(num_feats=128, normalize=True, offset=-0.5),
+    bbox_head=dict(
+        type=DeformableDETRHead,
+        num_classes=80,
+        sync_cls_avg_factor=True,
+        loss_cls=dict(
+            type=FocalLoss,
+            use_sigmoid=True,
+            gamma=2.0,
+            alpha=0.25,
+            loss_weight=2.0),
+        loss_bbox=dict(type=L1Loss, loss_weight=5.0),
+        loss_iou=dict(type=GIoULoss, loss_weight=2.0)),
+    # training and testing settings
+    train_cfg=dict(
+        assigner=dict(
+            type=HungarianAssigner,
+            match_costs=[
+                dict(type=FocalLossCost, weight=2.0),
+                dict(type=BBoxL1Cost, weight=5.0, box_format='xywh'),
+                dict(type=IoUCost, iou_mode='giou', weight=2.0)
+            ])),
+    test_cfg=dict(max_per_img=100))
+
+# train_pipeline, NOTE the img_scale and the Pad's size_divisor is different
+# from the default setting in mmdet.
+train_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=LoadAnnotations, with_bbox=True),
+    dict(type=RandomFlip, prob=0.5),
+    dict(
+        type=RandomChoice,
+        transforms=[
+            [
+                dict(
+                    type=RandomChoiceResize,
+                    scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333),
+                            (608, 1333), (640, 1333), (672, 1333), (704, 1333),
+                            (736, 1333), (768, 1333), (800, 1333)],
+                    resize_type=Resize,
+                    keep_ratio=True)
+            ],
+            [
+                dict(
+                    type=RandomChoiceResize,
+                    # The radio of all image in train dataset < 7
+                    # follow the original implement
+                    scales=[(400, 4200), (500, 4200), (600, 4200)],
+                    resize_type=Resize,
+                    keep_ratio=True),
+                dict(
+                    type=RandomCrop,
+                    crop_type='absolute_range',
+                    crop_size=(384, 600),
+                    allow_negative_crop=True),
+                dict(
+                    type=RandomChoiceResize,
+                    scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333),
+                            (608, 1333), (640, 1333), (672, 1333), (704, 1333),
+                            (736, 1333), (768, 1333), (800, 1333)],
+                    resize_type=Resize,
+                    keep_ratio=True)
+            ]
+        ]),
+    dict(type=PackDetInputs)
+]
+train_dataloader.update(
+    dict(
+        dataset=dict(
+            filter_cfg=dict(filter_empty_gt=False), pipeline=train_pipeline)))
+
+# optimizer
+optim_wrapper = dict(
+    type=OptimWrapper,
+    optimizer=dict(type=AdamW, lr=0.0002, weight_decay=0.0001),
+    clip_grad=dict(max_norm=0.1, norm_type=2),
+    paramwise_cfg=dict(
+        custom_keys={
+            'backbone': dict(lr_mult=0.1),
+            'sampling_offsets': dict(lr_mult=0.1),
+            'reference_points': dict(lr_mult=0.1)
+        }))
+
+# learning policy
+max_epochs = 50
+train_cfg = dict(
+    type=EpochBasedTrainLoop, max_epochs=max_epochs, val_interval=1)
+val_cfg = dict(type=ValLoop)
+test_cfg = dict(type=TestLoop)
+
+param_scheduler = [
+    dict(
+        type=MultiStepLR,
+        begin=0,
+        end=max_epochs,
+        by_epoch=True,
+        milestones=[40],
+        gamma=0.1)
+]
+
+# NOTE: `auto_scale_lr` is for automatically scaling LR,
+# USER SHOULD NOT CHANGE ITS VALUES.
+# base_batch_size = (16 GPUs) x (2 samples per GPU)
+auto_scale_lr = dict(base_batch_size=32)
diff --git a/mmdetection/mmdet/configs/deformable_detr/deformable_detr_refine_r50_16xb2_50e_coco.py b/mmdetection/mmdet/configs/deformable_detr/deformable_detr_refine_r50_16xb2_50e_coco.py
new file mode 100644
index 00000000..4f232d61
--- /dev/null
+++ b/mmdetection/mmdet/configs/deformable_detr/deformable_detr_refine_r50_16xb2_50e_coco.py
@@ -0,0 +1,12 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .deformable_detr_r50_16xb2_50e_coco import *
+
+model.update(dict(with_box_refine=True))
diff --git a/mmdetection/mmdet/configs/deformable_detr/deformable_detr_refine_twostage_r50_16xb2_50e_coco.py b/mmdetection/mmdet/configs/deformable_detr/deformable_detr_refine_twostage_r50_16xb2_50e_coco.py
new file mode 100644
index 00000000..1fac4d8c
--- /dev/null
+++ b/mmdetection/mmdet/configs/deformable_detr/deformable_detr_refine_twostage_r50_16xb2_50e_coco.py
@@ -0,0 +1,12 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .deformable_detr_refine_r50_16xb2_50e_coco import *
+
+model.update(dict(as_two_stage=True))
diff --git a/mmdetection/mmdet/configs/detr/detr_r101_8xb2_500e_coco.py b/mmdetection/mmdet/configs/detr/detr_r101_8xb2_500e_coco.py
new file mode 100644
index 00000000..b9614681
--- /dev/null
+++ b/mmdetection/mmdet/configs/detr/detr_r101_8xb2_500e_coco.py
@@ -0,0 +1,13 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.config import read_base
+from mmengine.model.weight_init import PretrainedInit
+
+with read_base():
+    from .detr_r50_8xb2_500e_coco import *
+
+model.update(
+    dict(
+        backbone=dict(
+            depth=101,
+            init_cfg=dict(
+                type=PretrainedInit, checkpoint='torchvision://resnet101'))))
diff --git a/mmdetection/mmdet/configs/detr/detr_r18_8xb2_500e_coco.py b/mmdetection/mmdet/configs/detr/detr_r18_8xb2_500e_coco.py
new file mode 100644
index 00000000..11360af1
--- /dev/null
+++ b/mmdetection/mmdet/configs/detr/detr_r18_8xb2_500e_coco.py
@@ -0,0 +1,14 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.config import read_base
+from mmengine.model.weight_init import PretrainedInit
+
+with read_base():
+    from .detr_r50_8xb2_500e_coco import *
+
+model.update(
+    dict(
+        backbone=dict(
+            depth=18,
+            init_cfg=dict(
+                type=PretrainedInit, checkpoint='torchvision://resnet18')),
+        neck=dict(in_channels=[512])))
diff --git a/mmdetection/mmdet/configs/detr/detr_r50_8xb2_150e_coco.py b/mmdetection/mmdet/configs/detr/detr_r50_8xb2_150e_coco.py
new file mode 100644
index 00000000..c50726c7
--- /dev/null
+++ b/mmdetection/mmdet/configs/detr/detr_r50_8xb2_150e_coco.py
@@ -0,0 +1,182 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.transforms import RandomChoice, RandomChoiceResize
+from mmcv.transforms.loading import LoadImageFromFile
+from mmengine.config import read_base
+from mmengine.model.weight_init import PretrainedInit
+from mmengine.optim.optimizer.optimizer_wrapper import OptimWrapper
+from mmengine.optim.scheduler.lr_scheduler import MultiStepLR
+from mmengine.runner.loops import EpochBasedTrainLoop, TestLoop, ValLoop
+from torch.nn.modules.activation import ReLU
+from torch.nn.modules.batchnorm import BatchNorm2d
+from torch.optim.adamw import AdamW
+
+from mmdet.datasets.transforms import (LoadAnnotations, PackDetInputs,
+                                       RandomCrop, RandomFlip, Resize)
+from mmdet.models import (DETR, ChannelMapper, DetDataPreprocessor, DETRHead,
+                          ResNet)
+from mmdet.models.losses.cross_entropy_loss import CrossEntropyLoss
+from mmdet.models.losses.iou_loss import GIoULoss
+from mmdet.models.losses.smooth_l1_loss import L1Loss
+from mmdet.models.task_modules import (BBoxL1Cost, ClassificationCost,
+                                       HungarianAssigner, IoUCost)
+
+with read_base():
+    from .._base_.datasets.coco_detection import *
+    from .._base_.default_runtime import *
+
+model = dict(
+    type=DETR,
+    num_queries=100,
+    data_preprocessor=dict(
+        type=DetDataPreprocessor,
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        bgr_to_rgb=True,
+        pad_size_divisor=1),
+    backbone=dict(
+        type=ResNet,
+        depth=50,
+        num_stages=4,
+        out_indices=(3, ),
+        frozen_stages=1,
+        norm_cfg=dict(type=BatchNorm2d, requires_grad=False),
+        norm_eval=True,
+        style='pytorch',
+        init_cfg=dict(
+            type=PretrainedInit, checkpoint='torchvision://resnet50')),
+    neck=dict(
+        type=ChannelMapper,
+        in_channels=[2048],
+        kernel_size=1,
+        out_channels=256,
+        act_cfg=None,
+        norm_cfg=None,
+        num_outs=1),
+    encoder=dict(  # DetrTransformerEncoder
+        num_layers=6,
+        layer_cfg=dict(  # DetrTransformerEncoderLayer
+            self_attn_cfg=dict(  # MultiheadAttention
+                embed_dims=256,
+                num_heads=8,
+                dropout=0.1,
+                batch_first=True),
+            ffn_cfg=dict(
+                embed_dims=256,
+                feedforward_channels=2048,
+                num_fcs=2,
+                ffn_drop=0.1,
+                act_cfg=dict(type=ReLU, inplace=True)))),
+    decoder=dict(  # DetrTransformerDecoder
+        num_layers=6,
+        layer_cfg=dict(  # DetrTransformerDecoderLayer
+            self_attn_cfg=dict(  # MultiheadAttention
+                embed_dims=256,
+                num_heads=8,
+                dropout=0.1,
+                batch_first=True),
+            cross_attn_cfg=dict(  # MultiheadAttention
+                embed_dims=256,
+                num_heads=8,
+                dropout=0.1,
+                batch_first=True),
+            ffn_cfg=dict(
+                embed_dims=256,
+                feedforward_channels=2048,
+                num_fcs=2,
+                ffn_drop=0.1,
+                act_cfg=dict(type=ReLU, inplace=True))),
+        return_intermediate=True),
+    positional_encoding=dict(num_feats=128, normalize=True),
+    bbox_head=dict(
+        type=DETRHead,
+        num_classes=80,
+        embed_dims=256,
+        loss_cls=dict(
+            type=CrossEntropyLoss,
+            bg_cls_weight=0.1,
+            use_sigmoid=False,
+            loss_weight=1.0,
+            class_weight=1.0),
+        loss_bbox=dict(type=L1Loss, loss_weight=5.0),
+        loss_iou=dict(type=GIoULoss, loss_weight=2.0)),
+    # training and testing settings
+    train_cfg=dict(
+        assigner=dict(
+            type=HungarianAssigner,
+            match_costs=[
+                dict(type=ClassificationCost, weight=1.),
+                dict(type=BBoxL1Cost, weight=5.0, box_format='xywh'),
+                dict(type=IoUCost, iou_mode='giou', weight=2.0)
+            ])),
+    test_cfg=dict(max_per_img=100))
+
+# train_pipeline, NOTE the img_scale and the Pad's size_divisor is different
+# from the default setting in mmdet.
+train_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=LoadAnnotations, with_bbox=True),
+    dict(type=RandomFlip, prob=0.5),
+    dict(
+        type=RandomChoice,
+        transforms=[[
+            dict(
+                type=RandomChoiceResize,
+                resize_type=Resize,
+                scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333),
+                        (608, 1333), (640, 1333), (672, 1333), (704, 1333),
+                        (736, 1333), (768, 1333), (800, 1333)],
+                keep_ratio=True)
+        ],
+                    [
+                        dict(
+                            type=RandomChoiceResize,
+                            resize_type=Resize,
+                            scales=[(400, 1333), (500, 1333), (600, 1333)],
+                            keep_ratio=True),
+                        dict(
+                            type=RandomCrop,
+                            crop_type='absolute_range',
+                            crop_size=(384, 600),
+                            allow_negative_crop=True),
+                        dict(
+                            type=RandomChoiceResize,
+                            resize_type=Resize,
+                            scales=[(480, 1333), (512, 1333), (544, 1333),
+                                    (576, 1333), (608, 1333), (640, 1333),
+                                    (672, 1333), (704, 1333), (736, 1333),
+                                    (768, 1333), (800, 1333)],
+                            keep_ratio=True)
+                    ]]),
+    dict(type=PackDetInputs)
+]
+train_dataloader.update(dataset=dict(pipeline=train_pipeline))
+
+# optimizer
+optim_wrapper = dict(
+    type=OptimWrapper,
+    optimizer=dict(type=AdamW, lr=0.0001, weight_decay=0.0001),
+    clip_grad=dict(max_norm=0.1, norm_type=2),
+    paramwise_cfg=dict(
+        custom_keys={'backbone': dict(lr_mult=0.1, decay_mult=1.0)}))
+
+# learning policy
+max_epochs = 150
+train_cfg = dict(
+    type=EpochBasedTrainLoop, max_epochs=max_epochs, val_interval=1)
+val_cfg = dict(type=ValLoop)
+test_cfg = dict(type=TestLoop)
+
+param_scheduler = [
+    dict(
+        type=MultiStepLR,
+        begin=0,
+        end=max_epochs,
+        by_epoch=True,
+        milestones=[100],
+        gamma=0.1)
+]
+
+# NOTE: `auto_scale_lr` is for automatically scaling LR,
+# USER SHOULD NOT CHANGE ITS VALUES.
+# base_batch_size = (8 GPUs) x (2 samples per GPU)
+auto_scale_lr = dict(base_batch_size=16)
diff --git a/mmdetection/mmdet/configs/detr/detr_r50_8xb2_500e_coco.py b/mmdetection/mmdet/configs/detr/detr_r50_8xb2_500e_coco.py
new file mode 100644
index 00000000..d7d08177
--- /dev/null
+++ b/mmdetection/mmdet/configs/detr/detr_r50_8xb2_500e_coco.py
@@ -0,0 +1,25 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.config import read_base
+from mmengine.optim.scheduler.lr_scheduler import MultiStepLR
+from mmengine.runner.loops import EpochBasedTrainLoop
+
+with read_base():
+    from .detr_r50_8xb2_150e_coco import *
+
+# learning policy
+max_epochs = 500
+train_cfg.update(
+    type=EpochBasedTrainLoop, max_epochs=max_epochs, val_interval=10)
+
+param_scheduler = [
+    dict(
+        type=MultiStepLR,
+        begin=0,
+        end=max_epochs,
+        by_epoch=True,
+        milestones=[334],
+        gamma=0.1)
+]
+
+# only keep latest 2 checkpoints
+default_hooks.update(checkpoint=dict(max_keep_ckpts=2))
diff --git a/mmdetection/mmdet/configs/dino/dino_4scale_r50_8xb2_12e_coco.py b/mmdetection/mmdet/configs/dino/dino_4scale_r50_8xb2_12e_coco.py
new file mode 100644
index 00000000..ab8e95a9
--- /dev/null
+++ b/mmdetection/mmdet/configs/dino/dino_4scale_r50_8xb2_12e_coco.py
@@ -0,0 +1,190 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.transforms import RandomChoice, RandomChoiceResize
+from mmcv.transforms.loading import LoadImageFromFile
+from mmengine.config import read_base
+from mmengine.model.weight_init import PretrainedInit
+from mmengine.optim.optimizer.optimizer_wrapper import OptimWrapper
+from mmengine.optim.scheduler.lr_scheduler import MultiStepLR
+from mmengine.runner.loops import EpochBasedTrainLoop, TestLoop, ValLoop
+from torch.nn.modules.batchnorm import BatchNorm2d
+from torch.nn.modules.normalization import GroupNorm
+from torch.optim.adamw import AdamW
+
+from mmdet.datasets.transforms import (LoadAnnotations, PackDetInputs,
+                                       RandomCrop, RandomFlip, Resize)
+from mmdet.models import (DINO, ChannelMapper, DetDataPreprocessor, DINOHead,
+                          ResNet)
+from mmdet.models.losses.focal_loss import FocalLoss
+from mmdet.models.losses.iou_loss import GIoULoss
+from mmdet.models.losses.smooth_l1_loss import L1Loss
+from mmdet.models.task_modules import (BBoxL1Cost, FocalLossCost,
+                                       HungarianAssigner, IoUCost)
+
+with read_base():
+    from .._base_.datasets.coco_detection import *
+    from .._base_.default_runtime import *
+
+model = dict(
+    type=DINO,
+    num_queries=900,  # num_matching_queries
+    with_box_refine=True,
+    as_two_stage=True,
+    data_preprocessor=dict(
+        type=DetDataPreprocessor,
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        bgr_to_rgb=True,
+        pad_size_divisor=1),
+    backbone=dict(
+        type=ResNet,
+        depth=50,
+        num_stages=4,
+        out_indices=(1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type=BatchNorm2d, requires_grad=False),
+        norm_eval=True,
+        style='pytorch',
+        init_cfg=dict(
+            type=PretrainedInit, checkpoint='torchvision://resnet50')),
+    neck=dict(
+        type=ChannelMapper,
+        in_channels=[512, 1024, 2048],
+        kernel_size=1,
+        out_channels=256,
+        act_cfg=None,
+        norm_cfg=dict(type=GroupNorm, num_groups=32),
+        num_outs=4),
+    encoder=dict(
+        num_layers=6,
+        layer_cfg=dict(
+            self_attn_cfg=dict(embed_dims=256, num_levels=4,
+                               dropout=0.0),  # 0.1 for DeformDETR
+            ffn_cfg=dict(
+                embed_dims=256,
+                feedforward_channels=2048,  # 1024 for DeformDETR
+                ffn_drop=0.0))),  # 0.1 for DeformDETR
+    decoder=dict(
+        num_layers=6,
+        return_intermediate=True,
+        layer_cfg=dict(
+            self_attn_cfg=dict(embed_dims=256, num_heads=8,
+                               dropout=0.0),  # 0.1 for DeformDETR
+            cross_attn_cfg=dict(embed_dims=256, num_levels=4,
+                                dropout=0.0),  # 0.1 for DeformDETR
+            ffn_cfg=dict(
+                embed_dims=256,
+                feedforward_channels=2048,  # 1024 for DeformDETR
+                ffn_drop=0.0)),  # 0.1 for DeformDETR
+        post_norm_cfg=None),
+    positional_encoding=dict(
+        num_feats=128,
+        normalize=True,
+        offset=0.0,  # -0.5 for DeformDETR
+        temperature=20),  # 10000 for DeformDETR
+    bbox_head=dict(
+        type=DINOHead,
+        num_classes=80,
+        sync_cls_avg_factor=True,
+        loss_cls=dict(
+            type=FocalLoss,
+            use_sigmoid=True,
+            gamma=2.0,
+            alpha=0.25,
+            loss_weight=1.0),  # 2.0 in DeformDETR
+        loss_bbox=dict(type=L1Loss, loss_weight=5.0),
+        loss_iou=dict(type=GIoULoss, loss_weight=2.0)),
+    dn_cfg=dict(  # TODO: Move to model.train_cfg ?
+        label_noise_scale=0.5,
+        box_noise_scale=1.0,  # 0.4 for DN-DETR
+        group_cfg=dict(dynamic=True, num_groups=None,
+                       num_dn_queries=100)),  # TODO: half num_dn_queries
+    # training and testing settings
+    train_cfg=dict(
+        assigner=dict(
+            type=HungarianAssigner,
+            match_costs=[
+                dict(type=FocalLossCost, weight=2.0),
+                dict(type=BBoxL1Cost, weight=5.0, box_format='xywh'),
+                dict(type=IoUCost, iou_mode='giou', weight=2.0)
+            ])),
+    test_cfg=dict(max_per_img=300))  # 100 for DeformDETR
+
+# train_pipeline, NOTE the img_scale and the Pad's size_divisor is different
+# from the default setting in mmdet.
+train_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=LoadAnnotations, with_bbox=True),
+    dict(type=RandomFlip, prob=0.5),
+    dict(
+        type=RandomChoice,
+        transforms=[
+            [
+                dict(
+                    type=RandomChoiceResize,
+                    resize_type=Resize,
+                    scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333),
+                            (608, 1333), (640, 1333), (672, 1333), (704, 1333),
+                            (736, 1333), (768, 1333), (800, 1333)],
+                    keep_ratio=True)
+            ],
+            [
+                dict(
+                    type=RandomChoiceResize,
+                    resize_type=Resize,
+                    # The radio of all image in train dataset < 7
+                    # follow the original implement
+                    scales=[(400, 4200), (500, 4200), (600, 4200)],
+                    keep_ratio=True),
+                dict(
+                    type=RandomCrop,
+                    crop_type='absolute_range',
+                    crop_size=(384, 600),
+                    allow_negative_crop=True),
+                dict(
+                    type=RandomChoiceResize,
+                    resize_type=Resize,
+                    scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333),
+                            (608, 1333), (640, 1333), (672, 1333), (704, 1333),
+                            (736, 1333), (768, 1333), (800, 1333)],
+                    keep_ratio=True)
+            ]
+        ]),
+    dict(type=PackDetInputs)
+]
+train_dataloader.update(
+    dataset=dict(
+        filter_cfg=dict(filter_empty_gt=False), pipeline=train_pipeline))
+
+# optimizer
+optim_wrapper = dict(
+    type=OptimWrapper,
+    optimizer=dict(
+        type=AdamW,
+        lr=0.0001,  # 0.0002 for DeformDETR
+        weight_decay=0.0001),
+    clip_grad=dict(max_norm=0.1, norm_type=2),
+    paramwise_cfg=dict(custom_keys={'backbone': dict(lr_mult=0.1)})
+)  # custom_keys contains sampling_offsets and reference_points in DeformDETR  # noqa
+
+# learning policy
+max_epochs = 12
+train_cfg = dict(
+    type=EpochBasedTrainLoop, max_epochs=max_epochs, val_interval=1)
+
+val_cfg = dict(type=ValLoop)
+test_cfg = dict(type=TestLoop)
+
+param_scheduler = [
+    dict(
+        type=MultiStepLR,
+        begin=0,
+        end=max_epochs,
+        by_epoch=True,
+        milestones=[11],
+        gamma=0.1)
+]
+
+# NOTE: `auto_scale_lr` is for automatically scaling LR,
+# USER SHOULD NOT CHANGE ITS VALUES.
+# base_batch_size = (8 GPUs) x (2 samples per GPU)
+auto_scale_lr = dict(base_batch_size=16)
diff --git a/mmdetection/mmdet/configs/dino/dino_4scale_r50_8xb2_24e_coco.py b/mmdetection/mmdet/configs/dino/dino_4scale_r50_8xb2_24e_coco.py
new file mode 100644
index 00000000..c10cc218
--- /dev/null
+++ b/mmdetection/mmdet/configs/dino/dino_4scale_r50_8xb2_24e_coco.py
@@ -0,0 +1,12 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.config import read_base
+from mmengine.runner.loops import EpochBasedTrainLoop
+
+with read_base():
+    from .dino_4scale_r50_8xb2_12e_coco import *
+
+max_epochs = 24
+train_cfg.update(
+    dict(type=EpochBasedTrainLoop, max_epochs=max_epochs, val_interval=1))
+
+param_scheduler[0].update(dict(milestones=[20]))
diff --git a/mmdetection/mmdet/configs/dino/dino_4scale_r50_8xb2_36e_coco.py b/mmdetection/mmdet/configs/dino/dino_4scale_r50_8xb2_36e_coco.py
new file mode 100644
index 00000000..37797443
--- /dev/null
+++ b/mmdetection/mmdet/configs/dino/dino_4scale_r50_8xb2_36e_coco.py
@@ -0,0 +1,12 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.config import read_base
+from mmengine.runner.loops import EpochBasedTrainLoop
+
+with read_base():
+    from .dino_4scale_r50_8xb2_12e_coco import *
+
+max_epochs = 36
+train_cfg.update(
+    dict(type=EpochBasedTrainLoop, max_epochs=max_epochs, val_interval=1))
+
+param_scheduler[0].update(dict(milestones=[30]))
diff --git a/mmdetection/mmdet/configs/dino/dino_4scale_r50_improved_8xb2_12e_coco.py b/mmdetection/mmdet/configs/dino/dino_4scale_r50_improved_8xb2_12e_coco.py
new file mode 100644
index 00000000..43c07201
--- /dev/null
+++ b/mmdetection/mmdet/configs/dino/dino_4scale_r50_improved_8xb2_12e_coco.py
@@ -0,0 +1,24 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.config import read_base
+
+with read_base():
+    from .dino_4scale_r50_8xb2_12e_coco import *
+
+# from deformable detr hyper
+model.update(
+    dict(
+        backbone=dict(frozen_stages=-1),
+        bbox_head=dict(loss_cls=dict(loss_weight=2.0)),
+        positional_encoding=dict(offset=-0.5, temperature=10000),
+        dn_cfg=dict(group_cfg=dict(num_dn_queries=300))))
+
+# optimizer
+optim_wrapper.update(
+    dict(
+        optimizer=dict(lr=0.0002),
+        paramwise_cfg=dict(
+            custom_keys={
+                'backbone': dict(lr_mult=0.1),
+                'sampling_offsets': dict(lr_mult=0.1),
+                'reference_points': dict(lr_mult=0.1)
+            })))
diff --git a/mmdetection/mmdet/configs/dino/dino_5scale_swin_l_8xb2_12e_coco.py b/mmdetection/mmdet/configs/dino/dino_5scale_swin_l_8xb2_12e_coco.py
new file mode 100644
index 00000000..25aac018
--- /dev/null
+++ b/mmdetection/mmdet/configs/dino/dino_5scale_swin_l_8xb2_12e_coco.py
@@ -0,0 +1,40 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.config import read_base
+from mmengine.model.weight_init import PretrainedInit
+
+from mmdet.models import SwinTransformer
+
+with read_base():
+    from .dino_4scale_r50_8xb2_12e_coco import *
+
+pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_large_patch4_window12_384_22k.pth'  # noqa
+num_levels = 5
+model.merge(
+    dict(
+        num_feature_levels=num_levels,
+        backbone=dict(
+            _delete_=True,
+            type=SwinTransformer,
+            pretrain_img_size=384,
+            embed_dims=192,
+            depths=[2, 2, 18, 2],
+            num_heads=[6, 12, 24, 48],
+            window_size=12,
+            mlp_ratio=4,
+            qkv_bias=True,
+            qk_scale=None,
+            drop_rate=0.,
+            attn_drop_rate=0.,
+            drop_path_rate=0.2,
+            patch_norm=True,
+            out_indices=(0, 1, 2, 3),
+            # Please only add indices that would be used
+            # in FPN, otherwise some parameter will not be used
+            with_cp=True,
+            convert_weights=True,
+            init_cfg=dict(type=PretrainedInit, checkpoint=pretrained)),
+        neck=dict(in_channels=[192, 384, 768, 1536], num_outs=num_levels),
+        encoder=dict(
+            layer_cfg=dict(self_attn_cfg=dict(num_levels=num_levels))),
+        decoder=dict(
+            layer_cfg=dict(cross_attn_cfg=dict(num_levels=num_levels)))))
diff --git a/mmdetection/mmdet/configs/dino/dino_5scale_swin_l_8xb2_36e_coco.py b/mmdetection/mmdet/configs/dino/dino_5scale_swin_l_8xb2_36e_coco.py
new file mode 100644
index 00000000..494acf59
--- /dev/null
+++ b/mmdetection/mmdet/configs/dino/dino_5scale_swin_l_8xb2_36e_coco.py
@@ -0,0 +1,12 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.config import read_base
+from mmengine.runner.loops import EpochBasedTrainLoop
+
+with read_base():
+    from .dino_5scale_swin_l_8xb2_12e_coco import *
+
+max_epochs = 36
+train_cfg.update(
+    dict(type=EpochBasedTrainLoop, max_epochs=max_epochs, val_interval=1))
+
+param_scheduler[0].update(dict(milestones=[27, 33]))
diff --git a/mmdetection/mmdet/configs/faster_rcnn/faster_rcnn_r50_fpn_1x_coco.py b/mmdetection/mmdet/configs/faster_rcnn/faster_rcnn_r50_fpn_1x_coco.py
new file mode 100644
index 00000000..f0a6d5a2
--- /dev/null
+++ b/mmdetection/mmdet/configs/faster_rcnn/faster_rcnn_r50_fpn_1x_coco.py
@@ -0,0 +1,13 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .._base_.datasets.coco_detection import *
+    from .._base_.default_runtime import *
+    from .._base_.models.faster_rcnn_r50_fpn import *
+    from .._base_.schedules.schedule_1x import *
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r101_caffe_fpn_1x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r101_caffe_fpn_1x_coco.py
new file mode 100644
index 00000000..2780f4af
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r101_caffe_fpn_1x_coco.py
@@ -0,0 +1,19 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .mask_rcnn_r50_fpn_poly_1x_coco import *
+
+from mmengine.model.weight_init import PretrainedInit
+
+model = dict(
+    backbone=dict(
+        depth=101,
+        init_cfg=dict(
+            type=PretrainedInit,
+            checkpoint='open-mmlab://detectron2/resnet101_caffe')))
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r101_caffe_fpn_ms_poly_3x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r101_caffe_fpn_ms_poly_3x_coco.py
new file mode 100644
index 00000000..8a1badfc
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r101_caffe_fpn_ms_poly_3x_coco.py
@@ -0,0 +1,28 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from ..common.ms_poly_3x_coco_instance import *
+    from .._base_.models.mask_rcnn_r50_fpn import *
+
+from mmengine.model.weight_init import PretrainedInit
+
+model = dict(
+    # use caffe img_norm
+    data_preprocessor=dict(
+        mean=[103.530, 116.280, 123.675],
+        std=[1.0, 1.0, 1.0],
+        bgr_to_rgb=False),
+    backbone=dict(
+        depth=101,
+        norm_cfg=dict(requires_grad=False),
+        norm_eval=True,
+        style='caffe',
+        init_cfg=dict(
+            type=PretrainedInit,
+            checkpoint='open-mmlab://detectron2/resnet101_caffe')))
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r101_fpn_1x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r101_fpn_1x_coco.py
new file mode 100644
index 00000000..6770cec8
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r101_fpn_1x_coco.py
@@ -0,0 +1,18 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .._base_.models.mask_rcnn_r50_fpn import *
+
+from mmengine.model.weight_init import PretrainedInit
+
+model = dict(
+    backbone=dict(
+        depth=101,
+        init_cfg=dict(
+            type=PretrainedInit, checkpoint='torchvision://resnet101')))
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r101_fpn_2x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r101_fpn_2x_coco.py
new file mode 100644
index 00000000..fd2aafb9
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r101_fpn_2x_coco.py
@@ -0,0 +1,18 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .mask_rcnn_r50_fpn_2x_coco import *
+
+from mmengine.model.weight_init import PretrainedInit
+
+model = dict(
+    backbone=dict(
+        depth=101,
+        init_cfg=dict(
+            type=PretrainedInit, checkpoint='torchvision://resnet101')))
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r101_fpn_8xb8_amp_lsj_200e_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r101_fpn_8xb8_amp_lsj_200e_coco.py
new file mode 100644
index 00000000..665808d5
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r101_fpn_8xb8_amp_lsj_200e_coco.py
@@ -0,0 +1,18 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .mask_rcnn_r18_fpn_8xb8_amp_lsj_200e_coco import *
+
+from mmengine.model.weight_init import PretrainedInit
+
+model = dict(
+    backbone=dict(
+        depth=101,
+        init_cfg=dict(
+            type=PretrainedInit, checkpoint='torchvision://resnet101')))
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r101_fpn_ms_poly_3x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r101_fpn_ms_poly_3x_coco.py
new file mode 100644
index 00000000..14688795
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r101_fpn_ms_poly_3x_coco.py
@@ -0,0 +1,19 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from ..common.ms_poly_3x_coco_instance import *
+    from .._base_.models.mask_rcnn_r50_fpn import *
+
+from mmengine.model.weight_init import PretrainedInit
+
+model = dict(
+    backbone=dict(
+        depth=101,
+        init_cfg=dict(
+            type=PretrainedInit, checkpoint='torchvision://resnet101')))
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r18_fpn_8xb8_amp_lsj_200e_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r18_fpn_8xb8_amp_lsj_200e_coco.py
new file mode 100644
index 00000000..67bd86fa
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r18_fpn_8xb8_amp_lsj_200e_coco.py
@@ -0,0 +1,19 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .mask_rcnn_r50_fpn_8xb8_amp_lsj_200e_coco import *
+
+from mmengine.model.weight_init import PretrainedInit
+
+model = dict(
+    backbone=dict(
+        depth=18,
+        init_cfg=dict(
+            type=PretrainedInit, checkpoint='torchvision://resnet18')),
+    neck=dict(in_channels=[64, 128, 256, 512]))
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_caffe_c4_1x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_caffe_c4_1x_coco.py
new file mode 100644
index 00000000..494e6ba5
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_caffe_c4_1x_coco.py
@@ -0,0 +1,13 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .._base_.datasets.coco_instance import *
+    from .._base_.default_runtime import *
+    from .._base_.models.mask_rcnn_r50_caffe_c4 import *
+    from .._base_.schedules.schedule_1x import *
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_1x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_1x_coco.py
new file mode 100644
index 00000000..6481fcfd
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_1x_coco.py
@@ -0,0 +1,25 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .mask_rcnn_r50_fpn_1x_coco import *
+
+from mmengine.model.weight_init import PretrainedInit
+
+model = dict(
+    # use caffe img_norm
+    data_preprocessor=dict(
+        mean=[103.530, 116.280, 123.675],
+        std=[1.0, 1.0, 1.0],
+        bgr_to_rgb=False),
+    backbone=dict(
+        norm_cfg=dict(requires_grad=False),
+        style='caffe',
+        init_cfg=dict(
+            type=PretrainedInit,
+            checkpoint='open-mmlab://detectron2/resnet50_caffe')))
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_ms_1x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_ms_1x_coco.py
new file mode 100644
index 00000000..5952ed58
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_ms_1x_coco.py
@@ -0,0 +1,40 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .mask_rcnn_r50_fpn_1x_coco import *
+
+from mmcv.transforms import RandomChoiceResize
+from mmengine.model.weight_init import PretrainedInit
+
+model = dict(
+    # use caffe img_norm
+    data_preprocessor=dict(
+        mean=[103.530, 116.280, 123.675],
+        std=[1.0, 1.0, 1.0],
+        bgr_to_rgb=False),
+    backbone=dict(
+        norm_cfg=dict(requires_grad=False),
+        style='caffe',
+        init_cfg=dict(
+            type=PretrainedInit,
+            checkpoint='open-mmlab://detectron2/resnet50_caffe')))
+
+train_pipeline = [
+    dict(type=LoadImageFromFile, backend_args={{_base_.backend_args}}),
+    dict(type=LoadAnnotations, with_bbox=True, with_mask=True),
+    dict(
+        type=RandomChoiceResize,
+        scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736),
+                (1333, 768), (1333, 800)],
+        keep_ratio=True),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=PackDetInputs),
+]
+
+train_dataloader.update(dict(dataset=dict(pipeline=train_pipeline)))
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_ms_poly_1x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_ms_poly_1x_coco.py
new file mode 100644
index 00000000..d62b9ebe
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_ms_poly_1x_coco.py
@@ -0,0 +1,40 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .mask_rcnn_r50_fpn_1x_coco import *
+
+from mmcv.transforms import RandomChoiceResize
+from mmengine.model.weight_init import PretrainedInit
+
+model = dict(
+    # use caffe img_norm
+    data_preprocessor=dict(
+        mean=[103.530, 116.280, 123.675],
+        std=[1.0, 1.0, 1.0],
+        bgr_to_rgb=False),
+    backbone=dict(
+        norm_cfg=dict(requires_grad=False),
+        style='caffe',
+        init_cfg=dict(
+            type=PretrainedInit,
+            checkpoint='open-mmlab://detectron2/resnet50_caffe')))
+train_pipeline = [
+    dict(type=LoadImageFromFile, backend_args={{_base_.backend_args}}),
+    dict(
+        type=LoadAnnotations, with_bbox=True, with_mask=True, poly2mask=False),
+    dict(
+        type=RandomChoiceResize,
+        scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736),
+                (1333, 768), (1333, 800)],
+        keep_ratio=True),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=PackDetInputs)
+]
+
+train_dataloader.update(dict(dataset=dict(pipeline=train_pipeline)))
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_ms_poly_2x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_ms_poly_2x_coco.py
new file mode 100644
index 00000000..fa41b7e0
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_ms_poly_2x_coco.py
@@ -0,0 +1,23 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .mask_rcnn_r50_caffe_fpn_ms_poly_1x_coco import *
+
+train_cfg = dict(max_epochs=24)
+# learning rate
+param_scheduler = [
+    dict(type=LinearLR, start_factor=0.001, by_epoch=False, begin=0, end=500),
+    dict(
+        type=MultiStepLR,
+        begin=0,
+        end=24,
+        by_epoch=True,
+        milestones=[16, 22],
+        gamma=0.1)
+]
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_ms_poly_3x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_ms_poly_3x_coco.py
new file mode 100644
index 00000000..c5f9b977
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_ms_poly_3x_coco.py
@@ -0,0 +1,23 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .mask_rcnn_r50_caffe_fpn_ms_poly_1x_coco import *
+
+train_cfg = dict(max_epochs=36)
+# learning rate
+param_scheduler = [
+    dict(type=LinearLR, start_factor=0.001, by_epoch=False, begin=0, end=500),
+    dict(
+        type=MultiStepLR,
+        begin=0,
+        end=24,
+        by_epoch=True,
+        milestones=[28, 34],
+        gamma=0.1)
+]
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_poly_1x_coco_v1.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_poly_1x_coco_v1.py
new file mode 100644
index 00000000..28ba7c77
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_poly_1x_coco_v1.py
@@ -0,0 +1,40 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .mask_rcnn_r50_fpn_1x_coco import *
+
+from mmengine.model.weight_init import PretrainedInit
+
+from mmdet.models.losses import SmoothL1Loss
+
+model = dict(
+    # use caffe img_norm
+    data_preprocessor=dict(
+        mean=[103.530, 116.280, 123.675],
+        std=[1.0, 1.0, 1.0],
+        bgr_to_rgb=False),
+    backbone=dict(
+        norm_cfg=dict(requires_grad=False),
+        style='caffe',
+        init_cfg=dict(
+            type=PretrainedInit,
+            checkpoint='open-mmlab://detectron2/resnet50_caffe')),
+    rpn_head=dict(
+        loss_bbox=dict(type=SmoothL1Loss, beta=1.0 / 9.0, loss_weight=1.0)),
+    roi_head=dict(
+        bbox_roi_extractor=dict(
+            roi_layer=dict(
+                type=RoIAlign, output_size=7, sampling_ratio=2,
+                aligned=False)),
+        bbox_head=dict(
+            loss_bbox=dict(type=SmoothL1Loss, beta=1.0, loss_weight=1.0)),
+        mask_roi_extractor=dict(
+            roi_layer=dict(
+                type=RoIAlign, output_size=14, sampling_ratio=2,
+                aligned=False))))
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_fpn_1x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_fpn_1x_coco.py
new file mode 100644
index 00000000..8145d08f
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_fpn_1x_coco.py
@@ -0,0 +1,13 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .._base_.datasets.coco_instance import *
+    from .._base_.default_runtime import *
+    from .._base_.models.mask_rcnn_r50_fpn import *
+    from .._base_.schedules.schedule_1x import *
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_fpn_1x_wandb_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_fpn_1x_wandb_coco.py
new file mode 100644
index 00000000..d2c08765
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_fpn_1x_wandb_coco.py
@@ -0,0 +1,31 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .._base_.datasets.coco_instance import *
+    from .._base_.default_runtime import *
+    from .._base_.models.mask_rcnn_r50_fpn import *
+    from .._base_.schedules.schedule_1x import *
+
+from mmengine.visualization import LocalVisBackend, WandbVisBackend
+
+vis_backends.update(dict(type=WandbVisBackend))
+vis_backends.update(dict(type=LocalVisBackend))
+visualizer.update(dict(vis_backends=vis_backends))
+
+# MMEngine support the following two ways, users can choose
+# according to convenience
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+default_hooks.update(dict(checkpoint=dict(interval=4)))
+
+train_cfg.update(dict(val_interval=2))
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_fpn_2x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_fpn_2x_coco.py
new file mode 100644
index 00000000..6be010b4
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_fpn_2x_coco.py
@@ -0,0 +1,13 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .._base_.datasets.coco_instance import *
+    from .._base_.default_runtime import *
+    from .._base_.models.mask_rcnn_r50_fpn import *
+    from .._base_.schedules.schedule_2x import *
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_fpn_8xb8_amp_lsj_200e_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_fpn_8xb8_amp_lsj_200e_coco.py
new file mode 100644
index 00000000..ef101fec
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_fpn_8xb8_amp_lsj_200e_coco.py
@@ -0,0 +1 @@
+# Copyright (c) OpenMMLab. All rights reserved.
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_fpn_amp_1x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_fpn_amp_1x_coco.py
new file mode 100644
index 00000000..110c3c47
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_fpn_amp_1x_coco.py
@@ -0,0 +1,14 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .mask_rcnn_r50_fpn_1x_coco import *
+
+from mmengine.optim.optimizer.amp_optimizer_wrapper import AmpOptimWrapper
+
+optim_wrapper.update(dict(type=AmpOptimWrapper))
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_fpn_ms_poly_-3x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_fpn_ms_poly_-3x_coco.py
new file mode 100644
index 00000000..ff4eec6d
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_fpn_ms_poly_-3x_coco.py
@@ -0,0 +1,11 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .._base_.models.mask_rcnn_r50_fpn import *
+    from ..common.ms_poly_3x_coco_instance import *
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_fpn_poly_1x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_fpn_poly_1x_coco.py
new file mode 100644
index 00000000..012e711c
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_r50_fpn_poly_1x_coco.py
@@ -0,0 +1,23 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .._base_.datasets.coco_instance import *
+    from .._base_.default_runtime import *
+    from .._base_.models.mask_rcnn_r50_fpn import *
+    from .._base_.schedules.schedule_1x import *
+
+train_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(
+        type=LoadAnnotations, with_bbox=True, with_mask=True, poly2mask=False),
+    dict(type=Resize, scale=(1333, 800), keep_ratio=True),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=PackDetInputs),
+]
+train_dataloader.update(dict(dataset=dict(pipeline=train_pipeline)))
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_32x4d_fpn_1x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_32x4d_fpn_1x_coco.py
new file mode 100644
index 00000000..5429b1bd
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_32x4d_fpn_1x_coco.py
@@ -0,0 +1,28 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .mask_rcnn_r101_fpn_1x_coco import *
+
+from mmengine.model.weight_init import PretrainedInit
+
+from mmdet.models.backbones.resnext import ResNeXt
+
+model = dict(
+    backbone=dict(
+        type=ResNeXt,
+        depth=101,
+        groups=32,
+        base_width=4,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type=BatchNorm2d, requires_grad=True),
+        style='pytorch',
+        init_cfg=dict(
+            type=PretrainedInit, checkpoint='open-mmlab://resnext101_32x4d')))
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_32x4d_fpn_2x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_32x4d_fpn_2x_coco.py
new file mode 100644
index 00000000..ebae6c1d
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_32x4d_fpn_2x_coco.py
@@ -0,0 +1,28 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .mask_rcnn_r50_fpn_2x_coco import *
+
+from mmengine.model.weight_init import PretrainedInit
+
+from mmdet.models import ResNeXt
+
+model = dict(
+    backbone=dict(
+        type=ResNeXt,
+        depth=101,
+        groups=32,
+        base_width=4,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type=BatchNorm2d, requires_grad=True),
+        style='pytorch',
+        init_cfg=dict(
+            type=PretrainedInit, checkpoint='open-mmlab://resnext101_32x4d')))
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_32x4d_fpn_ms_poly_3x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_32x4d_fpn_ms_poly_3x_coco.py
new file mode 100644
index 00000000..aff45d89
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_32x4d_fpn_ms_poly_3x_coco.py
@@ -0,0 +1,29 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from ..common.ms_poly_3x_coco_instance import *
+    from .._base_.models.mask_rcnn_r50_fpn import *
+
+from mmengine.model.weight_init import PretrainedInit
+
+from mmdet.models.backbones import ResNeXt
+
+model = dict(
+    backbone=dict(
+        type=ResNeXt,
+        depth=101,
+        groups=32,
+        base_width=4,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type=BatchNorm2d, requires_grad=True),
+        style='pytorch',
+        init_cfg=dict(
+            type=PretrainedInit, checkpoint='open-mmlab://resnext101_32x4d')))
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_32x8d_fpn_1x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_32x8d_fpn_1x_coco.py
new file mode 100644
index 00000000..d9f2095d
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_32x8d_fpn_1x_coco.py
@@ -0,0 +1,31 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .mask_rcnn_x101_32x4d_fpn_1x_coco import *
+
+model = dict(
+    # ResNeXt-101-32x8d model trained with Caffe2 at FB,
+    # so the mean and std need to be changed.
+    data_preprocessor=dict(
+        mean=[103.530, 116.280, 123.675],
+        std=[57.375, 57.120, 58.395],
+        bgr_to_rgb=False),
+    backbone=dict(
+        type=ResNeXt,
+        depth=101,
+        groups=32,
+        base_width=8,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type=BatchNorm2d, requires_grad=False),
+        style='pytorch',
+        init_cfg=dict(
+            type=PretrainedInit,
+            checkpoint='open-mmlab://detectron2/resnext101_32x8d')))
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_32x8d_fpn_ms_poly_1x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_32x8d_fpn_ms_poly_1x_coco.py
new file mode 100644
index 00000000..8eded941
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_32x8d_fpn_ms_poly_1x_coco.py
@@ -0,0 +1,54 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .mask_rcnn_r101_fpn_1x_coco import *
+
+from mmcv.transforms import RandomChoiceResize, RandomFlip
+from mmcv.transforms.loading import LoadImageFromFile
+
+from mmdet.datasets.transforms.formatting import PackDetInputs
+from mmdet.datasets.transforms.loading import LoadAnnotations
+from mmdet.models.backbones import ResNeXt
+
+model = dict(
+    # ResNeXt-101-32x8d model trained with Caffe2 at FB,
+    # so the mean and std need to be changed.
+    data_preprocessor=dict(
+        mean=[103.530, 116.280, 123.675],
+        std=[57.375, 57.120, 58.395],
+        bgr_to_rgb=False),
+    backbone=dict(
+        type=ResNeXt,
+        depth=101,
+        groups=32,
+        base_width=8,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type=BatchNorm2d, requires_grad=False),
+        style='pytorch',
+        init_cfg=dict(
+            type=PretrainedInit,
+            checkpoint='open-mmlab://detectron2/resnext101_32x8d')))
+
+backend_args = None
+train_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(
+        type=LoadAnnotations, with_bbox=True, with_mask=True, poly2mask=False),
+    dict(
+        type=RandomChoiceResize,
+        scales=[(1333, 640), (1333, 672), (1333, 704), (1333, 736),
+                (1333, 768), (1333, 800)],
+        keep_ratio=True),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=PackDetInputs),
+]
+
+train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_32x8d_fpn_ms_poly_3x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_32x8d_fpn_ms_poly_3x_coco.py
new file mode 100644
index 00000000..b3f58467
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_32x8d_fpn_ms_poly_3x_coco.py
@@ -0,0 +1,34 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from ..common.ms_poly_3x_coco_instance import *
+    from .._base_.models.mask_rcnn_r50_fpn import *
+
+from mmdet.models.backbones import ResNeXt
+
+model = dict(
+    # ResNeXt-101-32x8d model trained with Caffe2 at FB,
+    # so the mean and std need to be changed.
+    data_preprocessor=dict(
+        mean=[103.530, 116.280, 123.675],
+        std=[57.375, 57.120, 58.395],
+        bgr_to_rgb=False),
+    backbone=dict(
+        type=ResNeXt,
+        depth=101,
+        groups=32,
+        base_width=8,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type=BatchNorm2d, requires_grad=False),
+        style='pytorch',
+        init_cfg=dict(
+            type=PretrainedInit,
+            checkpoint='open-mmlab://detectron2/resnext101_32x8d')))
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_64_4d_fpn_1x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_64_4d_fpn_1x_coco.py
new file mode 100644
index 00000000..8bb6f636
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_64_4d_fpn_1x_coco.py
@@ -0,0 +1,24 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .mask_rcnn_x101_32x4d_fpn_1x_coco import *
+
+model = dict(
+    backbone=dict(
+        type=ResNeXt,
+        depth=101,
+        groups=64,
+        base_width=4,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type=BatchNorm2d, requires_grad=True),
+        style='pytorch',
+        init_cfg=dict(
+            type=PretrainedInit, checkpoint='open-mmlab://resnext101_64x4d')))
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_64x4d_fpn_2x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_64x4d_fpn_2x_coco.py
new file mode 100644
index 00000000..d661076d
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_64x4d_fpn_2x_coco.py
@@ -0,0 +1,24 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .mask_rcnn_x101_32x4d_fpn_2x_coco import *
+
+model = dict(
+    backbone=dict(
+        type=ResNeXt,
+        depth=101,
+        groups=64,
+        base_width=4,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type=BatchNorm2d, requires_grad=True),
+        style='pytorch',
+        init_cfg=dict(
+            type=PretrainedInit, checkpoint='open-mmlab://resnext101_64x4d')))
diff --git a/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_64x4d_fpn_ms_poly_3x_coco.py b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_64x4d_fpn_ms_poly_3x_coco.py
new file mode 100644
index 00000000..d9ab3643
--- /dev/null
+++ b/mmdetection/mmdet/configs/mask_rcnn/mask_rcnn_x101_64x4d_fpn_ms_poly_3x_coco.py
@@ -0,0 +1,27 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from ..common.ms_poly_3x_coco_instance import *
+    from .._base_.models.mask_rcnn_r50_fpn import *
+
+from mmdet.models.backbones import ResNeXt
+
+model = dict(
+    backbone=dict(
+        type=ResNeXt,
+        depth=101,
+        groups=64,
+        base_width=4,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type=BatchNorm2d, requires_grad=True),
+        style='pytorch',
+        init_cfg=dict(
+            type=PretrainedInit, checkpoint='open-mmlab://resnext101_64x4d')))
diff --git a/mmdetection/mmdet/configs/maskformer/maskformer_r50_ms_16xb1_75e_coco.py b/mmdetection/mmdet/configs/maskformer/maskformer_r50_ms_16xb1_75e_coco.py
new file mode 100644
index 00000000..70744013
--- /dev/null
+++ b/mmdetection/mmdet/configs/maskformer/maskformer_r50_ms_16xb1_75e_coco.py
@@ -0,0 +1,249 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.transforms import RandomChoice, RandomChoiceResize
+from mmengine.config import read_base
+from mmengine.model.weight_init import PretrainedInit
+from mmengine.optim.optimizer import OptimWrapper
+from mmengine.optim.scheduler import MultiStepLR
+from mmengine.runner import EpochBasedTrainLoop, TestLoop, ValLoop
+from torch.nn.modules.activation import ReLU
+from torch.nn.modules.batchnorm import BatchNorm2d
+from torch.nn.modules.normalization import GroupNorm
+from torch.optim.adamw import AdamW
+
+from mmdet.datasets.transforms.transforms import RandomCrop
+from mmdet.models import MaskFormer
+from mmdet.models.backbones import ResNet
+from mmdet.models.data_preprocessors.data_preprocessor import \
+    DetDataPreprocessor
+from mmdet.models.dense_heads.maskformer_head import MaskFormerHead
+from mmdet.models.layers.pixel_decoder import TransformerEncoderPixelDecoder
+from mmdet.models.losses import CrossEntropyLoss, DiceLoss, FocalLoss
+from mmdet.models.seg_heads.panoptic_fusion_heads import MaskFormerFusionHead
+from mmdet.models.task_modules.assigners.hungarian_assigner import \
+    HungarianAssigner
+from mmdet.models.task_modules.assigners.match_cost import (ClassificationCost,
+                                                            DiceCost,
+                                                            FocalLossCost)
+from mmdet.models.task_modules.samplers import MaskPseudoSampler
+
+with read_base():
+    from .._base_.datasets.coco_panoptic import *
+    from .._base_.default_runtime import *
+
+data_preprocessor = dict(
+    type=DetDataPreprocessor,
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_size_divisor=1,
+    pad_mask=True,
+    mask_pad_value=0,
+    pad_seg=True,
+    seg_pad_value=255)
+
+num_things_classes = 80
+num_stuff_classes = 53
+num_classes = num_things_classes + num_stuff_classes
+model = dict(
+    type=MaskFormer,
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type=ResNet,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=-1,
+        norm_cfg=dict(type=BatchNorm2d, requires_grad=False),
+        norm_eval=True,
+        style='pytorch',
+        init_cfg=dict(
+            type=PretrainedInit, checkpoint='torchvision://resnet50')),
+    panoptic_head=dict(
+        type=MaskFormerHead,
+        in_channels=[256, 512, 1024, 2048],  # pass to pixel_decoder inside
+        feat_channels=256,
+        out_channels=256,
+        num_things_classes=num_things_classes,
+        num_stuff_classes=num_stuff_classes,
+        num_queries=100,
+        pixel_decoder=dict(
+            type=TransformerEncoderPixelDecoder,
+            norm_cfg=dict(type=GroupNorm, num_groups=32),
+            act_cfg=dict(type=ReLU),
+            encoder=dict(  # DetrTransformerEncoder
+                num_layers=6,
+                layer_cfg=dict(  # DetrTransformerEncoderLayer
+                    self_attn_cfg=dict(  # MultiheadAttention
+                        embed_dims=256,
+                        num_heads=8,
+                        dropout=0.1,
+                        batch_first=True),
+                    ffn_cfg=dict(
+                        embed_dims=256,
+                        feedforward_channels=2048,
+                        num_fcs=2,
+                        ffn_drop=0.1,
+                        act_cfg=dict(type=ReLU, inplace=True)))),
+            positional_encoding=dict(num_feats=128, normalize=True)),
+        enforce_decoder_input_project=False,
+        positional_encoding=dict(num_feats=128, normalize=True),
+        transformer_decoder=dict(  # DetrTransformerDecoder
+            num_layers=6,
+            layer_cfg=dict(  # DetrTransformerDecoderLayer
+                self_attn_cfg=dict(  # MultiheadAttention
+                    embed_dims=256,
+                    num_heads=8,
+                    dropout=0.1,
+                    batch_first=True),
+                cross_attn_cfg=dict(  # MultiheadAttention
+                    embed_dims=256,
+                    num_heads=8,
+                    dropout=0.1,
+                    batch_first=True),
+                ffn_cfg=dict(
+                    embed_dims=256,
+                    feedforward_channels=2048,
+                    num_fcs=2,
+                    ffn_drop=0.1,
+                    act_cfg=dict(type=ReLU, inplace=True))),
+            return_intermediate=True),
+        loss_cls=dict(
+            type=CrossEntropyLoss,
+            use_sigmoid=False,
+            loss_weight=1.0,
+            reduction='mean',
+            class_weight=[1.0] * num_classes + [0.1]),
+        loss_mask=dict(
+            type=FocalLoss,
+            use_sigmoid=True,
+            gamma=2.0,
+            alpha=0.25,
+            reduction='mean',
+            loss_weight=20.0),
+        loss_dice=dict(
+            type=DiceLoss,
+            use_sigmoid=True,
+            activate=True,
+            reduction='mean',
+            naive_dice=True,
+            eps=1.0,
+            loss_weight=1.0)),
+    panoptic_fusion_head=dict(
+        type=MaskFormerFusionHead,
+        num_things_classes=num_things_classes,
+        num_stuff_classes=num_stuff_classes,
+        loss_panoptic=None,
+        init_cfg=None),
+    train_cfg=dict(
+        assigner=dict(
+            type=HungarianAssigner,
+            match_costs=[
+                dict(type=ClassificationCost, weight=1.0),
+                dict(type=FocalLossCost, weight=20.0, binary_input=True),
+                dict(type=DiceCost, weight=1.0, pred_act=True, eps=1.0)
+            ]),
+        sampler=dict(type=MaskPseudoSampler)),
+    test_cfg=dict(
+        panoptic_on=True,
+        # For now, the dataset does not support
+        # evaluating semantic segmentation metric.
+        semantic_on=False,
+        instance_on=False,
+        # max_per_image is for instance segmentation.
+        max_per_image=100,
+        object_mask_thr=0.8,
+        iou_thr=0.8,
+        # In MaskFormer's panoptic postprocessing,
+        # it will not filter masks whose score is smaller than 0.5 .
+        filter_low_score=False),
+    init_cfg=None)
+
+# dataset settings
+train_pipeline = [
+    dict(type=LoadImageFromFile),
+    dict(
+        type=LoadPanopticAnnotations,
+        with_bbox=True,
+        with_mask=True,
+        with_seg=True),
+    dict(type=RandomFlip, prob=0.5),
+    # dict(type=Resize, scale=(1333, 800), keep_ratio=True),
+    dict(
+        type=RandomChoice,
+        transforms=[[
+            dict(
+                type=RandomChoiceResize,
+                scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333),
+                        (608, 1333), (640, 1333), (672, 1333), (704, 1333),
+                        (736, 1333), (768, 1333), (800, 1333)],
+                resize_type=Resize,
+                keep_ratio=True)
+        ],
+                    [
+                        dict(
+                            type=RandomChoiceResize,
+                            scales=[(400, 1333), (500, 1333), (600, 1333)],
+                            resize_type=Resize,
+                            keep_ratio=True),
+                        dict(
+                            type=RandomCrop,
+                            crop_type='absolute_range',
+                            crop_size=(384, 600),
+                            allow_negative_crop=True),
+                        dict(
+                            type=RandomChoiceResize,
+                            scales=[(480, 1333), (512, 1333), (544, 1333),
+                                    (576, 1333), (608, 1333), (640, 1333),
+                                    (672, 1333), (704, 1333), (736, 1333),
+                                    (768, 1333), (800, 1333)],
+                            resize_type=Resize,
+                            keep_ratio=True)
+                    ]]),
+    dict(type=PackDetInputs)
+]
+
+train_dataloader.update(
+    dict(batch_size=1, num_workers=1, dataset=dict(pipeline=train_pipeline)))
+
+val_dataloader.update(dict(batch_size=1, num_workers=1))
+
+test_dataloader = val_dataloader
+
+# optimizer
+optim_wrapper = dict(
+    type=OptimWrapper,
+    optimizer=dict(
+        type=AdamW,
+        lr=0.0001,
+        weight_decay=0.0001,
+        eps=1e-8,
+        betas=(0.9, 0.999)),
+    paramwise_cfg=dict(
+        custom_keys={
+            'backbone': dict(lr_mult=0.1, decay_mult=1.0),
+            'query_embed': dict(lr_mult=1.0, decay_mult=0.0)
+        },
+        norm_decay_mult=0.0),
+    clip_grad=dict(max_norm=0.01, norm_type=2))
+
+max_epochs = 75
+
+# learning rate
+param_scheduler = dict(
+    type=MultiStepLR,
+    begin=0,
+    end=max_epochs,
+    by_epoch=True,
+    milestones=[50],
+    gamma=0.1)
+
+train_cfg = dict(
+    type=EpochBasedTrainLoop, max_epochs=max_epochs, val_interval=1)
+val_cfg = dict(type=ValLoop)
+test_cfg = dict(type=TestLoop)
+
+# Default setting for scaling LR automatically
+#   - `enable` means enable scaling LR automatically
+#       or not by default.
+#   - `base_batch_size` = (16 GPUs) x (1 samples per GPU).
+auto_scale_lr = dict(enable=False, base_batch_size=16)
diff --git a/mmdetection/mmdet/configs/maskformer/maskformer_swin_l_p4_w12_64xb1_ms_300e_coco.py b/mmdetection/mmdet/configs/maskformer/maskformer_swin_l_p4_w12_64xb1_ms_300e_coco.py
new file mode 100644
index 00000000..2affe520
--- /dev/null
+++ b/mmdetection/mmdet/configs/maskformer/maskformer_swin_l_p4_w12_64xb1_ms_300e_coco.py
@@ -0,0 +1,82 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.config import read_base
+from mmengine.optim.scheduler import LinearLR
+
+from mmdet.models.backbones import SwinTransformer
+from mmdet.models.layers import PixelDecoder
+
+with read_base():
+    from .maskformer_r50_ms_16xb1_75e_coco import *
+
+pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_large_patch4_window12_384_22k.pth'  # noqa
+depths = [2, 2, 18, 2]
+model.update(
+    dict(
+        backbone=dict(
+            _delete_=True,
+            type=SwinTransformer,
+            pretrain_img_size=384,
+            embed_dims=192,
+            patch_size=4,
+            window_size=12,
+            mlp_ratio=4,
+            depths=depths,
+            num_heads=[6, 12, 24, 48],
+            qkv_bias=True,
+            qk_scale=None,
+            drop_rate=0.,
+            attn_drop_rate=0.,
+            drop_path_rate=0.3,
+            patch_norm=True,
+            out_indices=(0, 1, 2, 3),
+            with_cp=False,
+            convert_weights=True,
+            init_cfg=dict(type=PretrainedInit, checkpoint=pretrained)),
+        panoptic_head=dict(
+            in_channels=[192, 384, 768, 1536],  # pass to pixel_decoder inside
+            pixel_decoder=dict(
+                _delete_=True,
+                type=PixelDecoder,
+                norm_cfg=dict(type=GroupNorm, num_groups=32),
+                act_cfg=dict(type=ReLU)),
+            enforce_decoder_input_project=True)))
+
+# optimizer
+
+# weight_decay = 0.01
+# norm_weight_decay = 0.0
+# embed_weight_decay = 0.0
+embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
+norm_multi = dict(lr_mult=1.0, decay_mult=0.0)
+custom_keys = {
+    'norm': norm_multi,
+    'absolute_pos_embed': embed_multi,
+    'relative_position_bias_table': embed_multi,
+    'query_embed': embed_multi
+}
+
+optim_wrapper.update(
+    dict(
+        optimizer=dict(lr=6e-5, weight_decay=0.01),
+        paramwise_cfg=dict(custom_keys=custom_keys, norm_decay_mult=0.0)))
+
+max_epochs = 300
+
+# learning rate
+param_scheduler = [
+    dict(type=LinearLR, start_factor=1e-6, by_epoch=False, begin=0, end=1500),
+    dict(
+        type=MultiStepLR,
+        begin=0,
+        end=max_epochs,
+        by_epoch=True,
+        milestones=[250],
+        gamma=0.1)
+]
+
+train_cfg.update(dict(max_epochs=max_epochs))
+
+# NOTE: `auto_scale_lr` is for automatically scaling LR,
+# USER SHOULD NOT CHANGE ITS VALUES.
+# base_batch_size = (64 GPUs) x (1 samples per GPU)
+auto_scale_lr.update(dict(base_batch_size=64))
diff --git a/mmdetection/mmdet/configs/panoptic_fpn/panoptic_fpn_r101_fpn_1x_coco.py b/mmdetection/mmdet/configs/panoptic_fpn/panoptic_fpn_r101_fpn_1x_coco.py
new file mode 100644
index 00000000..c6059780
--- /dev/null
+++ b/mmdetection/mmdet/configs/panoptic_fpn/panoptic_fpn_r101_fpn_1x_coco.py
@@ -0,0 +1,13 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.config import read_base
+from mmengine.model.weight_init import PretrainedInit
+
+with read_base():
+    from .panoptic_fpn_r50_fpn_1x_coco import *
+
+model.update(
+    dict(
+        backbone=dict(
+            depth=101,
+            init_cfg=dict(
+                type=PretrainedInit, checkpoint='torchvision://resnet101'))))
diff --git a/mmdetection/mmdet/configs/panoptic_fpn/panoptic_fpn_r101_fpn_ms_3x_coco.py b/mmdetection/mmdet/configs/panoptic_fpn/panoptic_fpn_r101_fpn_ms_3x_coco.py
new file mode 100644
index 00000000..c02c3237
--- /dev/null
+++ b/mmdetection/mmdet/configs/panoptic_fpn/panoptic_fpn_r101_fpn_ms_3x_coco.py
@@ -0,0 +1,13 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.config import read_base
+from mmengine.model.weight_init import PretrainedInit
+
+with read_base():
+    from .panoptic_fpn_r50_fpn_ms_3x_coco import *
+
+model.update(
+    dict(
+        backbone=dict(
+            depth=101,
+            init_cfg=dict(
+                type=PretrainedInit, checkpoint='torchvision://resnet101'))))
diff --git a/mmdetection/mmdet/configs/panoptic_fpn/panoptic_fpn_r50_fpn_1x_coco.py b/mmdetection/mmdet/configs/panoptic_fpn/panoptic_fpn_r50_fpn_1x_coco.py
new file mode 100644
index 00000000..fc893280
--- /dev/null
+++ b/mmdetection/mmdet/configs/panoptic_fpn/panoptic_fpn_r50_fpn_1x_coco.py
@@ -0,0 +1,64 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .._base_.models.mask_rcnn_r50_fpn import *
+    from .._base_.datasets.coco_panoptic import *
+    from .._base_.schedules.schedule_1x import *
+    from .._base_.default_runtime import *
+
+from mmcv.ops import nms
+from torch.nn import GroupNorm
+
+from mmdet.models.data_preprocessors.data_preprocessor import \
+    DetDataPreprocessor
+from mmdet.models.detectors.panoptic_fpn import PanopticFPN
+from mmdet.models.losses.cross_entropy_loss import CrossEntropyLoss
+from mmdet.models.seg_heads.panoptic_fpn_head import PanopticFPNHead
+from mmdet.models.seg_heads.panoptic_fusion_heads import HeuristicFusionHead
+
+model.update(
+    dict(
+        type=PanopticFPN,
+        data_preprocessor=dict(
+            type=DetDataPreprocessor,
+            mean=[123.675, 116.28, 103.53],
+            std=[58.395, 57.12, 57.375],
+            bgr_to_rgb=True,
+            pad_size_divisor=32,
+            pad_mask=True,
+            mask_pad_value=0,
+            pad_seg=True,
+            seg_pad_value=255),
+        semantic_head=dict(
+            type=PanopticFPNHead,
+            num_things_classes=80,
+            num_stuff_classes=53,
+            in_channels=256,
+            inner_channels=128,
+            start_level=0,
+            end_level=4,
+            norm_cfg=dict(type=GroupNorm, num_groups=32, requires_grad=True),
+            conv_cfg=None,
+            loss_seg=dict(
+                type=CrossEntropyLoss, ignore_index=255, loss_weight=0.5)),
+        panoptic_fusion_head=dict(
+            type=HeuristicFusionHead,
+            num_things_classes=80,
+            num_stuff_classes=53),
+        test_cfg=dict(
+            rcnn=dict(
+                score_thr=0.6,
+                nms=dict(type=nms, iou_threshold=0.5, class_agnostic=True),
+                max_per_img=100,
+                mask_thr_binary=0.5),
+            # used in HeuristicFusionHead
+            panoptic=dict(mask_overlap=0.5, stuff_area_limit=4096))))
+
+# Forced to remove NumClassCheckHook
+custom_hooks = []
diff --git a/mmdetection/mmdet/configs/panoptic_fpn/panoptic_fpn_r50_fpn_ms_3x_coco.py b/mmdetection/mmdet/configs/panoptic_fpn/panoptic_fpn_r50_fpn_ms_3x_coco.py
new file mode 100644
index 00000000..25ebe5d6
--- /dev/null
+++ b/mmdetection/mmdet/configs/panoptic_fpn/panoptic_fpn_r50_fpn_ms_3x_coco.py
@@ -0,0 +1,45 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.config import read_base
+from mmengine.optim.scheduler.lr_scheduler import LinearLR, MultiStepLR
+
+with read_base():
+    from .panoptic_fpn_r50_fpn_1x_coco import *
+
+from mmcv.transforms import RandomResize
+from mmcv.transforms.loading import LoadImageFromFile
+
+from mmdet.datasets.transforms.formatting import PackDetInputs
+from mmdet.datasets.transforms.loading import LoadPanopticAnnotations
+from mmdet.datasets.transforms.transforms import RandomFlip
+
+# In mstrain 3x config, img_scale=[(1333, 640), (1333, 800)],
+# multiscale_mode='range'
+train_pipeline = [
+    dict(type=LoadImageFromFile),
+    dict(
+        type=LoadPanopticAnnotations,
+        with_bbox=True,
+        with_mask=True,
+        with_seg=True),
+    dict(type=RandomResize, scale=[(1333, 640), (1333, 800)], keep_ratio=True),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=PackDetInputs)
+]
+
+train_dataloader.update(dict(dataset=dict(pipeline=train_pipeline)))
+
+# TODO: Use RepeatDataset to speed up training
+# training schedule for 3x
+train_cfg.update(dict(max_epochs=36, val_interval=3))
+
+# learning rate
+param_scheduler = [
+    dict(type=LinearLR, start_factor=0.001, by_epoch=False, begin=0, end=500),
+    dict(
+        type=MultiStepLR,
+        begin=0,
+        end=36,
+        by_epoch=True,
+        milestones=[24, 33],
+        gamma=0.1)
+]
diff --git a/mmdetection/mmdet/configs/qdtrack/qdtrack_faster_rcnn_r50_fpn_4e_base.py b/mmdetection/mmdet/configs/qdtrack/qdtrack_faster_rcnn_r50_fpn_4e_base.py
new file mode 100644
index 00000000..c672e82c
--- /dev/null
+++ b/mmdetection/mmdet/configs/qdtrack/qdtrack_faster_rcnn_r50_fpn_4e_base.py
@@ -0,0 +1,141 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.config import read_base
+
+with read_base():
+    from .._base_.models.faster_rcnn_r50_fpn import *
+    from .._base_.models.faster_rcnn_r50_fpn import model
+    from .._base_.default_runtime import *
+
+from mmcv.ops import RoIAlign
+from mmengine.hooks import LoggerHook, SyncBuffersHook
+from mmengine.model.weight_init import PretrainedInit
+from mmengine.optim import MultiStepLR, OptimWrapper
+from mmengine.runner.runner import EpochBasedTrainLoop, TestLoop, ValLoop
+from torch.nn.modules.batchnorm import BatchNorm2d
+from torch.nn.modules.normalization import GroupNorm
+from torch.optim import SGD
+
+from mmdet.engine.hooks import TrackVisualizationHook
+from mmdet.models import (QDTrack, QuasiDenseEmbedHead, QuasiDenseTracker,
+                          QuasiDenseTrackHead, SingleRoIExtractor,
+                          TrackDataPreprocessor)
+from mmdet.models.losses import (L1Loss, MarginL2Loss,
+                                 MultiPosCrossEntropyLoss, SmoothL1Loss)
+from mmdet.models.task_modules import (CombinedSampler,
+                                       InstanceBalancedPosSampler,
+                                       MaxIoUAssigner, RandomSampler)
+from mmdet.visualization import TrackLocalVisualizer
+
+detector = model
+detector.pop('data_preprocessor')
+
+detector['backbone'].update(
+    dict(
+        norm_cfg=dict(type=BatchNorm2d, requires_grad=False),
+        style='caffe',
+        init_cfg=dict(
+            type=PretrainedInit,
+            checkpoint='open-mmlab://detectron2/resnet50_caffe')))
+detector.rpn_head.loss_bbox.update(
+    dict(type=SmoothL1Loss, beta=1.0 / 9.0, loss_weight=1.0))
+detector.rpn_head.bbox_coder.update(dict(clip_border=False))
+detector.roi_head.bbox_head.update(dict(num_classes=1))
+detector.roi_head.bbox_head.bbox_coder.update(dict(clip_border=False))
+detector['init_cfg'] = dict(
+    type=PretrainedInit,
+    checkpoint=  # noqa: E251
+    'https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/'
+    'faster_rcnn_r50_fpn_1x_coco-person/'
+    'faster_rcnn_r50_fpn_1x_coco-person_20201216_175929-d022e227.pth'
+    # noqa: E501
+)
+del model
+
+model = dict(
+    type=QDTrack,
+    data_preprocessor=dict(
+        type=TrackDataPreprocessor,
+        mean=[103.530, 116.280, 123.675],
+        std=[1.0, 1.0, 1.0],
+        bgr_to_rgb=False,
+        pad_size_divisor=32),
+    detector=detector,
+    track_head=dict(
+        type=QuasiDenseTrackHead,
+        roi_extractor=dict(
+            type=SingleRoIExtractor,
+            roi_layer=dict(type=RoIAlign, output_size=7, sampling_ratio=0),
+            out_channels=256,
+            featmap_strides=[4, 8, 16, 32]),
+        embed_head=dict(
+            type=QuasiDenseEmbedHead,
+            num_convs=4,
+            num_fcs=1,
+            embed_channels=256,
+            norm_cfg=dict(type=GroupNorm, num_groups=32),
+            loss_track=dict(type=MultiPosCrossEntropyLoss, loss_weight=0.25),
+            loss_track_aux=dict(
+                type=MarginL2Loss,
+                neg_pos_ub=3,
+                pos_margin=0,
+                neg_margin=0.1,
+                hard_mining=True,
+                loss_weight=1.0)),
+        loss_bbox=dict(type=L1Loss, loss_weight=1.0),
+        train_cfg=dict(
+            assigner=dict(
+                type=MaxIoUAssigner,
+                pos_iou_thr=0.7,
+                neg_iou_thr=0.5,
+                min_pos_iou=0.5,
+                match_low_quality=False,
+                ignore_iof_thr=-1),
+            sampler=dict(
+                type=CombinedSampler,
+                num=256,
+                pos_fraction=0.5,
+                neg_pos_ub=3,
+                add_gt_as_proposals=True,
+                pos_sampler=dict(type=InstanceBalancedPosSampler),
+                neg_sampler=dict(type=RandomSampler)))),
+    tracker=dict(
+        type=QuasiDenseTracker,
+        init_score_thr=0.9,
+        obj_score_thr=0.5,
+        match_score_thr=0.5,
+        memo_tracklet_frames=30,
+        memo_backdrop_frames=1,
+        memo_momentum=0.8,
+        nms_conf_thr=0.5,
+        nms_backdrop_iou_thr=0.3,
+        nms_class_iou_thr=0.7,
+        with_cats=True,
+        match_metric='bisoftmax'))
+# optimizer
+optim_wrapper = dict(
+    type=OptimWrapper,
+    optimizer=dict(type=SGD, lr=0.02, momentum=0.9, weight_decay=0.0001),
+    clip_grad=dict(max_norm=35, norm_type=2))
+# learning policy
+param_scheduler = [
+    dict(type=MultiStepLR, begin=0, end=4, by_epoch=True, milestones=[3])
+]
+
+# runtime settings
+train_cfg = dict(type=EpochBasedTrainLoop, max_epochs=4, val_interval=4)
+val_cfg = dict(type=ValLoop)
+test_cfg = dict(type=TestLoop)
+
+default_hooks.update(
+    logger=dict(type=LoggerHook, interval=50),
+    visualization=dict(type=TrackVisualizationHook, draw=False))
+
+visualizer.update(
+    type=TrackLocalVisualizer, vis_backends=vis_backends, name='visualizer')
+
+# custom hooks
+custom_hooks = [
+    # Synchronize model buffers such as running_mean and running_var in BN
+    # at the end of each epoch
+    dict(type=SyncBuffersHook)
+]
diff --git a/mmdetection/mmdet/configs/qdtrack/qdtrack_faster_rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py b/mmdetection/mmdet/configs/qdtrack/qdtrack_faster_rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py
new file mode 100644
index 00000000..2fa715e1
--- /dev/null
+++ b/mmdetection/mmdet/configs/qdtrack/qdtrack_faster_rcnn_r50_fpn_8xb2-4e_mot17halftrain_test-mot17halfval.py
@@ -0,0 +1,14 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.config import read_base
+
+with read_base():
+    from .._base_.datasets.mot_challenge import *
+    from .qdtrack_faster_rcnn_r50_fpn_4e_base import *
+
+from mmdet.evaluation import CocoVideoMetric, MOTChallengeMetric
+
+# evaluator
+val_evaluator = [
+    dict(type=CocoVideoMetric, metric=['bbox'], classwise=True),
+    dict(type=MOTChallengeMetric, metric=['HOTA', 'CLEAR', 'Identity'])
+]
diff --git a/mmdetection/mmdet/configs/retinanet/retinanet_r50_fpn_1x_coco.py b/mmdetection/mmdet/configs/retinanet/retinanet_r50_fpn_1x_coco.py
new file mode 100644
index 00000000..847600e6
--- /dev/null
+++ b/mmdetection/mmdet/configs/retinanet/retinanet_r50_fpn_1x_coco.py
@@ -0,0 +1,20 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .._base_.models.retinanet_r50_fpn import *
+    from .._base_.datasets.coco_detection import *
+    from .._base_.schedules.schedule_1x import *
+    from .._base_.default_runtime import *
+    from .retinanet_tta import *
+
+from torch.optim.sgd import SGD
+
+# optimizer
+optim_wrapper.update(
+    dict(optimizer=dict(type=SGD, lr=0.01, momentum=0.9, weight_decay=0.0001)))
diff --git a/mmdetection/mmdet/configs/retinanet/retinanet_tta.py b/mmdetection/mmdet/configs/retinanet/retinanet_tta.py
new file mode 100644
index 00000000..4e340e58
--- /dev/null
+++ b/mmdetection/mmdet/configs/retinanet/retinanet_tta.py
@@ -0,0 +1,31 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.transforms.loading import LoadImageFromFile
+from mmcv.transforms.processing import TestTimeAug
+
+from mmdet.datasets.transforms.formatting import PackDetInputs
+from mmdet.datasets.transforms.loading import LoadAnnotations
+from mmdet.datasets.transforms.transforms import RandomFlip, Resize
+from mmdet.models.test_time_augs.det_tta import DetTTAModel
+
+tta_model = dict(
+    type=DetTTAModel,
+    tta_cfg=dict(nms=dict(type='nms', iou_threshold=0.5), max_per_img=100))
+
+img_scales = [(1333, 800), (666, 400), (2000, 1200)]
+tta_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=None),
+    dict(
+        type=TestTimeAug,
+        transforms=[
+            [dict(type=Resize, scale=s, keep_ratio=True) for s in img_scales],
+            [dict(type=RandomFlip, prob=1.),
+             dict(type=RandomFlip, prob=0.)],
+            [dict(type=LoadAnnotations, with_bbox=True)],
+            [
+                dict(
+                    type=PackDetInputs,
+                    meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                               'scale_factor', 'flip', 'flip_direction'))
+            ]
+        ])
+]
diff --git a/mmdetection/mmdet/configs/rtmdet/rtmdet_ins_l_8xb32_300e_coco.py b/mmdetection/mmdet/configs/rtmdet/rtmdet_ins_l_8xb32_300e_coco.py
new file mode 100644
index 00000000..302d7cda
--- /dev/null
+++ b/mmdetection/mmdet/configs/rtmdet/rtmdet_ins_l_8xb32_300e_coco.py
@@ -0,0 +1,134 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .rtmdet_l_8xb32_300e_coco import *
+
+from mmcv.transforms.loading import LoadImageFromFile
+from mmcv.transforms.processing import RandomResize
+from mmengine.hooks.ema_hook import EMAHook
+from torch.nn.modules.activation import SiLU
+
+from mmdet.datasets.transforms.formatting import PackDetInputs
+from mmdet.datasets.transforms.loading import (FilterAnnotations,
+                                               LoadAnnotations)
+from mmdet.datasets.transforms.transforms import (CachedMixUp, CachedMosaic,
+                                                  Pad, RandomCrop, RandomFlip,
+                                                  Resize, YOLOXHSVRandomAug)
+from mmdet.engine.hooks.pipeline_switch_hook import PipelineSwitchHook
+from mmdet.models.dense_heads.rtmdet_ins_head import RTMDetInsSepBNHead
+from mmdet.models.layers.ema import ExpMomentumEMA
+from mmdet.models.losses.dice_loss import DiceLoss
+from mmdet.models.losses.gfocal_loss import QualityFocalLoss
+from mmdet.models.losses.iou_loss import GIoULoss
+from mmdet.models.task_modules.coders.distance_point_bbox_coder import \
+    DistancePointBBoxCoder
+from mmdet.models.task_modules.prior_generators.point_generator import \
+    MlvlPointGenerator
+
+model.merge(
+    dict(
+        bbox_head=dict(
+            _delete_=True,
+            type=RTMDetInsSepBNHead,
+            num_classes=80,
+            in_channels=256,
+            stacked_convs=2,
+            share_conv=True,
+            pred_kernel_size=1,
+            feat_channels=256,
+            act_cfg=dict(type=SiLU, inplace=True),
+            norm_cfg=dict(type='SyncBN', requires_grad=True),
+            anchor_generator=dict(
+                type=MlvlPointGenerator, offset=0, strides=[8, 16, 32]),
+            bbox_coder=dict(type=DistancePointBBoxCoder),
+            loss_cls=dict(
+                type=QualityFocalLoss,
+                use_sigmoid=True,
+                beta=2.0,
+                loss_weight=1.0),
+            loss_bbox=dict(type=GIoULoss, loss_weight=2.0),
+            loss_mask=dict(
+                type=DiceLoss, loss_weight=2.0, eps=5e-6, reduction='mean')),
+        test_cfg=dict(
+            nms_pre=1000,
+            min_bbox_size=0,
+            score_thr=0.05,
+            nms=dict(type='nms', iou_threshold=0.6),
+            max_per_img=100,
+            mask_thr_binary=0.5),
+    ))
+
+train_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(
+        type=LoadAnnotations, with_bbox=True, with_mask=True, poly2mask=False),
+    dict(type=CachedMosaic, img_scale=(640, 640), pad_val=114.0),
+    dict(
+        type=RandomResize,
+        scale=(1280, 1280),
+        ratio_range=(0.1, 2.0),
+        resize_type=Resize,
+        keep_ratio=True),
+    dict(
+        type=RandomCrop,
+        crop_size=(640, 640),
+        recompute_bbox=True,
+        allow_negative_crop=True),
+    dict(type=YOLOXHSVRandomAug),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=Pad, size=(640, 640), pad_val=dict(img=(114, 114, 114))),
+    dict(
+        type=CachedMixUp,
+        img_scale=(640, 640),
+        ratio_range=(1.0, 1.0),
+        max_cached_images=20,
+        pad_val=(114, 114, 114)),
+    dict(type=FilterAnnotations, min_gt_bbox_wh=(1, 1)),
+    dict(type=PackDetInputs)
+]
+
+train_dataloader.update(
+    dict(pin_memory=True, dataset=dict(pipeline=train_pipeline)))
+
+train_pipeline_stage2 = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(
+        type=LoadAnnotations, with_bbox=True, with_mask=True, poly2mask=False),
+    dict(
+        type=RandomResize,
+        scale=(640, 640),
+        ratio_range=(0.1, 2.0),
+        resize_type=Resize,
+        keep_ratio=True),
+    dict(
+        type=RandomCrop,
+        crop_size=(640, 640),
+        recompute_bbox=True,
+        allow_negative_crop=True),
+    dict(type=FilterAnnotations, min_gt_bbox_wh=(1, 1)),
+    dict(type=YOLOXHSVRandomAug),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=Pad, size=(640, 640), pad_val=dict(img=(114, 114, 114))),
+    dict(type=PackDetInputs)
+]
+custom_hooks = [
+    dict(
+        type=EMAHook,
+        ema_type=ExpMomentumEMA,
+        momentum=0.0002,
+        update_buffers=True,
+        priority=49),
+    dict(
+        type=PipelineSwitchHook,
+        switch_epoch=280,
+        switch_pipeline=train_pipeline_stage2)
+]
+
+val_evaluator.update(dict(metric=['bbox', 'segm']))
+test_evaluator = val_evaluator
diff --git a/mmdetection/mmdet/configs/rtmdet/rtmdet_ins_m_8xb32_300e_coco.py b/mmdetection/mmdet/configs/rtmdet/rtmdet_ins_m_8xb32_300e_coco.py
new file mode 100644
index 00000000..d90be929
--- /dev/null
+++ b/mmdetection/mmdet/configs/rtmdet/rtmdet_ins_m_8xb32_300e_coco.py
@@ -0,0 +1,17 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .rtmdet_ins_l_8xb32_300e_coco import *
+
+model.update(
+    dict(
+        backbone=dict(deepen_factor=0.67, widen_factor=0.75),
+        neck=dict(
+            in_channels=[192, 384, 768], out_channels=192, num_csp_blocks=2),
+        bbox_head=dict(in_channels=192, feat_channels=192)))
diff --git a/mmdetection/mmdet/configs/rtmdet/rtmdet_ins_s_8xb32_300e_coco.py b/mmdetection/mmdet/configs/rtmdet/rtmdet_ins_s_8xb32_300e_coco.py
new file mode 100644
index 00000000..58b5b1af
--- /dev/null
+++ b/mmdetection/mmdet/configs/rtmdet/rtmdet_ins_s_8xb32_300e_coco.py
@@ -0,0 +1,101 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .rtmdet_ins_l_8xb32_300e_coco import *
+
+from mmcv.transforms.loading import LoadImageFromFile
+from mmcv.transforms.processing import RandomResize
+from mmengine.hooks.ema_hook import EMAHook
+
+from mmdet.datasets.transforms.formatting import PackDetInputs
+from mmdet.datasets.transforms.loading import (FilterAnnotations,
+                                               LoadAnnotations)
+from mmdet.datasets.transforms.transforms import (CachedMixUp, CachedMosaic,
+                                                  Pad, RandomCrop, RandomFlip,
+                                                  Resize, YOLOXHSVRandomAug)
+from mmdet.engine.hooks.pipeline_switch_hook import PipelineSwitchHook
+from mmdet.models.layers.ema import ExpMomentumEMA
+
+checkpoint = 'https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-s_imagenet_600e.pth'  # noqa
+model.update(
+    dict(
+        backbone=dict(
+            deepen_factor=0.33,
+            widen_factor=0.5,
+            init_cfg=dict(
+                type='Pretrained', prefix='backbone.', checkpoint=checkpoint)),
+        neck=dict(
+            in_channels=[128, 256, 512], out_channels=128, num_csp_blocks=1),
+        bbox_head=dict(in_channels=128, feat_channels=128)))
+
+train_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(
+        type=LoadAnnotations, with_bbox=True, with_mask=True, poly2mask=False),
+    dict(type=CachedMosaic, img_scale=(640, 640), pad_val=114.0),
+    dict(
+        type=RandomResize,
+        scale=(1280, 1280),
+        ratio_range=(0.5, 2.0),
+        resize_type=Resize,
+        keep_ratio=True),
+    dict(
+        type=RandomCrop,
+        crop_size=(640, 640),
+        recompute_bbox=True,
+        allow_negative_crop=True),
+    dict(type=YOLOXHSVRandomAug),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=Pad, size=(640, 640), pad_val=dict(img=(114, 114, 114))),
+    dict(
+        type=CachedMixUp,
+        img_scale=(640, 640),
+        ratio_range=(1.0, 1.0),
+        max_cached_images=20,
+        pad_val=(114, 114, 114)),
+    dict(type=FilterAnnotations, min_gt_bbox_wh=(1, 1)),
+    dict(type=PackDetInputs)
+]
+
+train_pipeline_stage2 = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(
+        type=LoadAnnotations, with_bbox=True, with_mask=True, poly2mask=False),
+    dict(
+        type=RandomResize,
+        scale=(640, 640),
+        ratio_range=(0.5, 2.0),
+        resize_type=Resize,
+        keep_ratio=True),
+    dict(
+        type=RandomCrop,
+        crop_size=(640, 640),
+        recompute_bbox=True,
+        allow_negative_crop=True),
+    dict(type=FilterAnnotations, min_gt_bbox_wh=(1, 1)),
+    dict(type=YOLOXHSVRandomAug),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=Pad, size=(640, 640), pad_val=dict(img=(114, 114, 114))),
+    dict(type=PackDetInputs)
+]
+
+train_dataloader.update(dict(dataset=dict(pipeline=train_pipeline)))
+
+custom_hooks = [
+    dict(
+        type=EMAHook,
+        ema_type=ExpMomentumEMA,
+        momentum=0.0002,
+        update_buffers=True,
+        priority=49),
+    dict(
+        type=PipelineSwitchHook,
+        switch_epoch=280,
+        switch_pipeline=train_pipeline_stage2)
+]
diff --git a/mmdetection/mmdet/configs/rtmdet/rtmdet_ins_tiny_8xb32_300e_coco.py b/mmdetection/mmdet/configs/rtmdet/rtmdet_ins_tiny_8xb32_300e_coco.py
new file mode 100644
index 00000000..0356b195
--- /dev/null
+++ b/mmdetection/mmdet/configs/rtmdet/rtmdet_ins_tiny_8xb32_300e_coco.py
@@ -0,0 +1,67 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .rtmdet_ins_s_8xb32_300e_coco import *
+
+from mmcv.transforms.loading import LoadImageFromFile
+from mmcv.transforms.processing import RandomResize
+
+from mmdet.datasets.transforms.formatting import PackDetInputs
+from mmdet.datasets.transforms.loading import (FilterAnnotations,
+                                               LoadAnnotations)
+from mmdet.datasets.transforms.transforms import (CachedMixUp, CachedMosaic,
+                                                  Pad, RandomCrop, RandomFlip,
+                                                  Resize, YOLOXHSVRandomAug)
+
+checkpoint = 'https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-tiny_imagenet_600e.pth'  # noqa
+
+model.update(
+    dict(
+        backbone=dict(
+            deepen_factor=0.167,
+            widen_factor=0.375,
+            init_cfg=dict(
+                type='Pretrained', prefix='backbone.', checkpoint=checkpoint)),
+        neck=dict(
+            in_channels=[96, 192, 384], out_channels=96, num_csp_blocks=1),
+        bbox_head=dict(in_channels=96, feat_channels=96)))
+
+train_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(
+        type=LoadAnnotations, with_bbox=True, with_mask=True, poly2mask=False),
+    dict(
+        type=CachedMosaic,
+        img_scale=(640, 640),
+        pad_val=114.0,
+        max_cached_images=20,
+        random_pop=False),
+    dict(
+        type=RandomResize,
+        scale=(1280, 1280),
+        ratio_range=(0.5, 2.0),
+        resize_type=Resize,
+        keep_ratio=True),
+    dict(type=RandomCrop, crop_size=(640, 640)),
+    dict(type=YOLOXHSVRandomAug),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=Pad, size=(640, 640), pad_val=dict(img=(114, 114, 114))),
+    dict(
+        type=CachedMixUp,
+        img_scale=(640, 640),
+        ratio_range=(1.0, 1.0),
+        max_cached_images=10,
+        random_pop=False,
+        pad_val=(114, 114, 114),
+        prob=0.5),
+    dict(type=FilterAnnotations, min_gt_bbox_wh=(1, 1)),
+    dict(type=PackDetInputs)
+]
+
+train_dataloader.update(dict(dataset=dict(pipeline=train_pipeline)))
diff --git a/mmdetection/mmdet/configs/rtmdet/rtmdet_ins_x_8xb16_300e_coco.py b/mmdetection/mmdet/configs/rtmdet/rtmdet_ins_x_8xb16_300e_coco.py
new file mode 100644
index 00000000..555b1010
--- /dev/null
+++ b/mmdetection/mmdet/configs/rtmdet/rtmdet_ins_x_8xb16_300e_coco.py
@@ -0,0 +1,38 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .rtmdet_ins_l_8xb32_300e_coco import *
+from mmengine.optim.scheduler.lr_scheduler import CosineAnnealingLR, LinearLR
+
+model.update(
+    dict(
+        backbone=dict(deepen_factor=1.33, widen_factor=1.25),
+        neck=dict(
+            in_channels=[320, 640, 1280], out_channels=320, num_csp_blocks=4),
+        bbox_head=dict(in_channels=320, feat_channels=320)))
+
+base_lr = 0.002
+
+# optimizer
+optim_wrapper.update(dict(optimizer=dict(lr=base_lr)))
+
+# learning rate
+param_scheduler = [
+    dict(
+        type=LinearLR, start_factor=1.0e-5, by_epoch=False, begin=0, end=1000),
+    dict(
+        # use cosine lr from 150 to 300 epoch
+        type=CosineAnnealingLR,
+        eta_min=base_lr * 0.05,
+        begin=max_epochs // 2,
+        end=max_epochs,
+        T_max=max_epochs // 2,
+        by_epoch=True,
+        convert_to_iter_based=True),
+]
diff --git a/mmdetection/mmdet/configs/rtmdet/rtmdet_l_8xb32_300e_coco.py b/mmdetection/mmdet/configs/rtmdet/rtmdet_l_8xb32_300e_coco.py
new file mode 100644
index 00000000..5dcda7bf
--- /dev/null
+++ b/mmdetection/mmdet/configs/rtmdet/rtmdet_l_8xb32_300e_coco.py
@@ -0,0 +1,220 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .._base_.default_runtime import *
+    from .._base_.schedules.schedule_1x import *
+    from .._base_.datasets.coco_detection import *
+    from .rtmdet_tta import *
+
+from mmcv.ops import nms
+from mmcv.transforms.loading import LoadImageFromFile
+from mmcv.transforms.processing import RandomResize
+from mmengine.hooks.ema_hook import EMAHook
+from mmengine.optim.optimizer.optimizer_wrapper import OptimWrapper
+from mmengine.optim.scheduler.lr_scheduler import CosineAnnealingLR, LinearLR
+from torch.nn import SyncBatchNorm
+from torch.nn.modules.activation import SiLU
+from torch.optim.adamw import AdamW
+
+from mmdet.datasets.transforms.formatting import PackDetInputs
+from mmdet.datasets.transforms.loading import LoadAnnotations
+from mmdet.datasets.transforms.transforms import (CachedMixUp, CachedMosaic,
+                                                  Pad, RandomCrop, RandomFlip,
+                                                  Resize, YOLOXHSVRandomAug)
+from mmdet.engine.hooks.pipeline_switch_hook import PipelineSwitchHook
+from mmdet.models.backbones.cspnext import CSPNeXt
+from mmdet.models.data_preprocessors.data_preprocessor import \
+    DetDataPreprocessor
+from mmdet.models.dense_heads.rtmdet_head import RTMDetSepBNHead
+from mmdet.models.detectors.rtmdet import RTMDet
+from mmdet.models.layers.ema import ExpMomentumEMA
+from mmdet.models.losses.gfocal_loss import QualityFocalLoss
+from mmdet.models.losses.iou_loss import GIoULoss
+from mmdet.models.necks.cspnext_pafpn import CSPNeXtPAFPN
+from mmdet.models.task_modules.assigners.dynamic_soft_label_assigner import \
+    DynamicSoftLabelAssigner
+from mmdet.models.task_modules.coders.distance_point_bbox_coder import \
+    DistancePointBBoxCoder
+from mmdet.models.task_modules.prior_generators.point_generator import \
+    MlvlPointGenerator
+
+model = dict(
+    type=RTMDet,
+    data_preprocessor=dict(
+        type=DetDataPreprocessor,
+        mean=[103.53, 116.28, 123.675],
+        std=[57.375, 57.12, 58.395],
+        bgr_to_rgb=False,
+        batch_augments=None),
+    backbone=dict(
+        type=CSPNeXt,
+        arch='P5',
+        expand_ratio=0.5,
+        deepen_factor=1,
+        widen_factor=1,
+        channel_attention=True,
+        norm_cfg=dict(type=SyncBatchNorm),
+        act_cfg=dict(type=SiLU, inplace=True)),
+    neck=dict(
+        type=CSPNeXtPAFPN,
+        in_channels=[256, 512, 1024],
+        out_channels=256,
+        num_csp_blocks=3,
+        expand_ratio=0.5,
+        norm_cfg=dict(type=SyncBatchNorm),
+        act_cfg=dict(type=SiLU, inplace=True)),
+    bbox_head=dict(
+        type=RTMDetSepBNHead,
+        num_classes=80,
+        in_channels=256,
+        stacked_convs=2,
+        feat_channels=256,
+        anchor_generator=dict(
+            type=MlvlPointGenerator, offset=0, strides=[8, 16, 32]),
+        bbox_coder=dict(type=DistancePointBBoxCoder),
+        loss_cls=dict(
+            type=QualityFocalLoss, use_sigmoid=True, beta=2.0,
+            loss_weight=1.0),
+        loss_bbox=dict(type=GIoULoss, loss_weight=2.0),
+        with_objectness=False,
+        exp_on_reg=True,
+        share_conv=True,
+        pred_kernel_size=1,
+        norm_cfg=dict(type=SyncBatchNorm),
+        act_cfg=dict(type=SiLU, inplace=True)),
+    train_cfg=dict(
+        assigner=dict(type=DynamicSoftLabelAssigner, topk=13),
+        allowed_border=-1,
+        pos_weight=-1,
+        debug=False),
+    test_cfg=dict(
+        nms_pre=30000,
+        min_bbox_size=0,
+        score_thr=0.001,
+        nms=dict(type=nms, iou_threshold=0.65),
+        max_per_img=300),
+)
+
+train_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=LoadAnnotations, with_bbox=True),
+    dict(type=CachedMosaic, img_scale=(640, 640), pad_val=114.0),
+    dict(
+        type=RandomResize,
+        scale=(1280, 1280),
+        ratio_range=(0.1, 2.0),
+        resize_type=Resize,
+        keep_ratio=True),
+    dict(type=RandomCrop, crop_size=(640, 640)),
+    dict(type=YOLOXHSVRandomAug),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=Pad, size=(640, 640), pad_val=dict(img=(114, 114, 114))),
+    dict(
+        type=CachedMixUp,
+        img_scale=(640, 640),
+        ratio_range=(1.0, 1.0),
+        max_cached_images=20,
+        pad_val=(114, 114, 114)),
+    dict(type=PackDetInputs)
+]
+
+train_pipeline_stage2 = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=LoadAnnotations, with_bbox=True),
+    dict(
+        type=RandomResize,
+        scale=(640, 640),
+        ratio_range=(0.1, 2.0),
+        resize_type=Resize,
+        keep_ratio=True),
+    dict(type=RandomCrop, crop_size=(640, 640)),
+    dict(type=YOLOXHSVRandomAug),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=Pad, size=(640, 640), pad_val=dict(img=(114, 114, 114))),
+    dict(type=PackDetInputs)
+]
+
+test_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=Resize, scale=(640, 640), keep_ratio=True),
+    dict(type=Pad, size=(640, 640), pad_val=dict(img=(114, 114, 114))),
+    dict(type=LoadAnnotations, with_bbox=True),
+    dict(
+        type=PackDetInputs,
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+
+train_dataloader.update(
+    dict(
+        batch_size=32,
+        num_workers=10,
+        batch_sampler=None,
+        pin_memory=True,
+        dataset=dict(pipeline=train_pipeline)))
+val_dataloader.update(
+    dict(batch_size=5, num_workers=10, dataset=dict(pipeline=test_pipeline)))
+test_dataloader = val_dataloader
+
+max_epochs = 300
+stage2_num_epochs = 20
+base_lr = 0.004
+interval = 10
+
+train_cfg.update(
+    dict(
+        max_epochs=max_epochs,
+        val_interval=interval,
+        dynamic_intervals=[(max_epochs - stage2_num_epochs, 1)]))
+
+val_evaluator.update(dict(proposal_nums=(100, 1, 10)))
+test_evaluator = val_evaluator
+
+# optimizer
+optim_wrapper = dict(
+    type=OptimWrapper,
+    optimizer=dict(type=AdamW, lr=base_lr, weight_decay=0.05),
+    paramwise_cfg=dict(
+        norm_decay_mult=0, bias_decay_mult=0, bypass_duplicate=True))
+
+# learning rate
+param_scheduler = [
+    dict(
+        type=LinearLR, start_factor=1.0e-5, by_epoch=False, begin=0, end=1000),
+    dict(
+        # use cosine lr from 150 to 300 epoch
+        type=CosineAnnealingLR,
+        eta_min=base_lr * 0.05,
+        begin=max_epochs // 2,
+        end=max_epochs,
+        T_max=max_epochs // 2,
+        by_epoch=True,
+        convert_to_iter_based=True),
+]
+
+# hooks
+default_hooks.update(
+    dict(
+        checkpoint=dict(
+            interval=interval,
+            max_keep_ckpts=3  # only keep latest 3 checkpoints
+        )))
+
+custom_hooks = [
+    dict(
+        type=EMAHook,
+        ema_type=ExpMomentumEMA,
+        momentum=0.0002,
+        update_buffers=True,
+        priority=49),
+    dict(
+        type=PipelineSwitchHook,
+        switch_epoch=max_epochs - stage2_num_epochs,
+        switch_pipeline=train_pipeline_stage2)
+]
diff --git a/mmdetection/mmdet/configs/rtmdet/rtmdet_m_8xb32_300e_coco.py b/mmdetection/mmdet/configs/rtmdet/rtmdet_m_8xb32_300e_coco.py
new file mode 100644
index 00000000..e741d822
--- /dev/null
+++ b/mmdetection/mmdet/configs/rtmdet/rtmdet_m_8xb32_300e_coco.py
@@ -0,0 +1,17 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .rtmdet_l_8xb32_300e_coco import *
+
+model.update(
+    dict(
+        backbone=dict(deepen_factor=0.67, widen_factor=0.75),
+        neck=dict(
+            in_channels=[192, 384, 768], out_channels=192, num_csp_blocks=2),
+        bbox_head=dict(in_channels=192, feat_channels=192)))
diff --git a/mmdetection/mmdet/configs/rtmdet/rtmdet_s_8xb32_300e_coco.py b/mmdetection/mmdet/configs/rtmdet/rtmdet_s_8xb32_300e_coco.py
new file mode 100644
index 00000000..db21b747
--- /dev/null
+++ b/mmdetection/mmdet/configs/rtmdet/rtmdet_s_8xb32_300e_coco.py
@@ -0,0 +1,88 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .rtmdet_l_8xb32_300e_coco import *
+
+from mmcv.transforms.loading import LoadImageFromFile
+from mmcv.transforms.processing import RandomResize
+from mmengine.hooks.ema_hook import EMAHook
+
+from mmdet.datasets.transforms.formatting import PackDetInputs
+from mmdet.datasets.transforms.loading import LoadAnnotations
+from mmdet.datasets.transforms.transforms import (CachedMixUp, CachedMosaic,
+                                                  Pad, RandomCrop, RandomFlip,
+                                                  Resize, YOLOXHSVRandomAug)
+from mmdet.engine.hooks.pipeline_switch_hook import PipelineSwitchHook
+from mmdet.models.layers.ema import ExpMomentumEMA
+
+checkpoint = 'https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-s_imagenet_600e.pth'  # noqa
+model.update(
+    dict(
+        backbone=dict(
+            deepen_factor=0.33,
+            widen_factor=0.5,
+            init_cfg=dict(
+                type='Pretrained', prefix='backbone.', checkpoint=checkpoint)),
+        neck=dict(
+            in_channels=[128, 256, 512], out_channels=128, num_csp_blocks=1),
+        bbox_head=dict(in_channels=128, feat_channels=128, exp_on_reg=False)))
+
+train_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=LoadAnnotations, with_bbox=True),
+    dict(type=CachedMosaic, img_scale=(640, 640), pad_val=114.0),
+    dict(
+        type=RandomResize,
+        scale=(1280, 1280),
+        ratio_range=(0.5, 2.0),
+        resize_type=Resize,
+        keep_ratio=True),
+    dict(type=RandomCrop, crop_size=(640, 640)),
+    dict(type=YOLOXHSVRandomAug),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=Pad, size=(640, 640), pad_val=dict(img=(114, 114, 114))),
+    dict(
+        type=CachedMixUp,
+        img_scale=(640, 640),
+        ratio_range=(1.0, 1.0),
+        max_cached_images=20,
+        pad_val=(114, 114, 114)),
+    dict(type=PackDetInputs)
+]
+
+train_pipeline_stage2 = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=LoadAnnotations, with_bbox=True),
+    dict(
+        type=RandomResize,
+        scale=(640, 640),
+        ratio_range=(0.5, 2.0),
+        resize_type=Resize,
+        keep_ratio=True),
+    dict(type=RandomCrop, crop_size=(640, 640)),
+    dict(type=YOLOXHSVRandomAug),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=Pad, size=(640, 640), pad_val=dict(img=(114, 114, 114))),
+    dict(type=PackDetInputs)
+]
+
+train_dataloader.update(dict(dataset=dict(pipeline=train_pipeline)))
+
+custom_hooks = [
+    dict(
+        type=EMAHook,
+        ema_type=ExpMomentumEMA,
+        momentum=0.0002,
+        update_buffers=True,
+        priority=49),
+    dict(
+        type=PipelineSwitchHook,
+        switch_epoch=280,
+        switch_pipeline=train_pipeline_stage2)
+]
diff --git a/mmdetection/mmdet/configs/rtmdet/rtmdet_tiny_8xb32_300e_coco.py b/mmdetection/mmdet/configs/rtmdet/rtmdet_tiny_8xb32_300e_coco.py
new file mode 100644
index 00000000..949d056f
--- /dev/null
+++ b/mmdetection/mmdet/configs/rtmdet/rtmdet_tiny_8xb32_300e_coco.py
@@ -0,0 +1,64 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .rtmdet_s_8xb32_300e_coco import *
+
+from mmcv.transforms.loading import LoadImageFromFile
+from mmcv.transforms.processing import RandomResize
+
+from mmdet.datasets.transforms.formatting import PackDetInputs
+from mmdet.datasets.transforms.loading import LoadAnnotations
+from mmdet.datasets.transforms.transforms import (CachedMixUp, CachedMosaic,
+                                                  Pad, RandomCrop, RandomFlip,
+                                                  Resize, YOLOXHSVRandomAug)
+
+checkpoint = 'https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-tiny_imagenet_600e.pth'  # noqa
+
+model.update(
+    dict(
+        backbone=dict(
+            deepen_factor=0.167,
+            widen_factor=0.375,
+            init_cfg=dict(
+                type='Pretrained', prefix='backbone.', checkpoint=checkpoint)),
+        neck=dict(
+            in_channels=[96, 192, 384], out_channels=96, num_csp_blocks=1),
+        bbox_head=dict(in_channels=96, feat_channels=96, exp_on_reg=False)))
+
+train_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=backend_args),
+    dict(type=LoadAnnotations, with_bbox=True),
+    dict(
+        type=CachedMosaic,
+        img_scale=(640, 640),
+        pad_val=114.0,
+        max_cached_images=20,
+        random_pop=False),
+    dict(
+        type=RandomResize,
+        scale=(1280, 1280),
+        ratio_range=(0.5, 2.0),
+        resize_type=Resize,
+        keep_ratio=True),
+    dict(type=RandomCrop, crop_size=(640, 640)),
+    dict(type=YOLOXHSVRandomAug),
+    dict(type=RandomFlip, prob=0.5),
+    dict(type=Pad, size=(640, 640), pad_val=dict(img=(114, 114, 114))),
+    dict(
+        type=CachedMixUp,
+        img_scale=(640, 640),
+        ratio_range=(1.0, 1.0),
+        max_cached_images=10,
+        random_pop=False,
+        pad_val=(114, 114, 114),
+        prob=0.5),
+    dict(type=PackDetInputs)
+]
+
+train_dataloader.update(dict(dataset=dict(pipeline=train_pipeline)))
diff --git a/mmdetection/mmdet/configs/rtmdet/rtmdet_tta.py b/mmdetection/mmdet/configs/rtmdet/rtmdet_tta.py
new file mode 100644
index 00000000..f27b7aa4
--- /dev/null
+++ b/mmdetection/mmdet/configs/rtmdet/rtmdet_tta.py
@@ -0,0 +1,43 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.transforms.loading import LoadImageFromFile
+from mmcv.transforms.processing import TestTimeAug
+
+from mmdet.datasets.transforms.formatting import PackDetInputs
+from mmdet.datasets.transforms.loading import LoadAnnotations
+from mmdet.datasets.transforms.transforms import Pad, RandomFlip, Resize
+from mmdet.models.test_time_augs.det_tta import DetTTAModel
+
+tta_model = dict(
+    type=DetTTAModel,
+    tta_cfg=dict(nms=dict(type='nms', iou_threshold=0.6), max_per_img=100))
+
+img_scales = [(640, 640), (320, 320), (960, 960)]
+
+tta_pipeline = [
+    dict(type=LoadImageFromFile, backend_args=None),
+    dict(
+        type=TestTimeAug,
+        transforms=[
+            [dict(type=Resize, scale=s, keep_ratio=True) for s in img_scales],
+            [
+                # ``RandomFlip`` must be placed before ``Pad``, otherwise
+                # bounding box coordinates after flipping cannot be
+                # recovered correctly.
+                dict(type=RandomFlip, prob=1.),
+                dict(type=RandomFlip, prob=0.)
+            ],
+            [
+                dict(
+                    type=Pad,
+                    size=(960, 960),
+                    pad_val=dict(img=(114, 114, 114))),
+            ],
+            [dict(type=LoadAnnotations, with_bbox=True)],
+            [
+                dict(
+                    type=PackDetInputs,
+                    meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                               'scale_factor', 'flip', 'flip_direction'))
+            ]
+        ])
+]
diff --git a/mmdetection/mmdet/configs/rtmdet/rtmdet_x_8xb32_300e_coco.py b/mmdetection/mmdet/configs/rtmdet/rtmdet_x_8xb32_300e_coco.py
new file mode 100644
index 00000000..04d67d0c
--- /dev/null
+++ b/mmdetection/mmdet/configs/rtmdet/rtmdet_x_8xb32_300e_coco.py
@@ -0,0 +1,17 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Please refer to https://mmengine.readthedocs.io/en/latest/advanced_tutorials/config.html#a-pure-python-style-configuration-file-beta for more details. # noqa
+# mmcv >= 2.0.1
+# mmengine >= 0.8.0
+
+from mmengine.config import read_base
+
+with read_base():
+    from .rtmdet_l_8xb32_300e_coco import *
+
+model.update(
+    dict(
+        backbone=dict(deepen_factor=1.33, widen_factor=1.25),
+        neck=dict(
+            in_channels=[320, 640, 1280], out_channels=320, num_csp_blocks=4),
+        bbox_head=dict(in_channels=320, feat_channels=320)))
diff --git a/mmdetection/mmdet/datasets/__init__.py b/mmdetection/mmdet/datasets/__init__.py
new file mode 100644
index 00000000..670c207c
--- /dev/null
+++ b/mmdetection/mmdet/datasets/__init__.py
@@ -0,0 +1,53 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .ade20k import (ADE20KInstanceDataset, ADE20KPanopticDataset,
+                     ADE20KSegDataset)
+from .base_det_dataset import BaseDetDataset
+from .base_semseg_dataset import BaseSegDataset
+from .base_video_dataset import BaseVideoDataset
+from .cityscapes import CityscapesDataset
+from .coco import CocoDataset
+from .coco_caption import CocoCaptionDataset
+from .coco_panoptic import CocoPanopticDataset
+from .coco_semantic import CocoSegDataset
+from .crowdhuman import CrowdHumanDataset
+from .dataset_wrappers import ConcatDataset, MultiImageMixDataset
+from .deepfashion import DeepFashionDataset
+from .dod import DODDataset
+from .dsdl import DSDLDetDataset
+from .flickr30k import Flickr30kDataset
+from .isaid import iSAIDDataset
+from .lvis import LVISDataset, LVISV1Dataset, LVISV05Dataset
+from .mdetr_style_refcoco import MDETRStyleRefCocoDataset
+from .mot_challenge_dataset import MOTChallengeDataset
+from .objects365 import Objects365V1Dataset, Objects365V2Dataset
+from .odvg import ODVGDataset
+from .openimages import OpenImagesChallengeDataset, OpenImagesDataset
+from .refcoco import RefCocoDataset
+from .reid_dataset import ReIDDataset
+from .samplers import (AspectRatioBatchSampler, ClassAwareSampler,
+                       CustomSampleSizeSampler, GroupMultiSourceSampler,
+                       MultiSourceSampler, TrackAspectRatioBatchSampler,
+                       TrackImgSampler)
+from .utils import get_loading_pipeline
+from .v3det import V3DetDataset
+from .voc import VOCDataset
+from .wider_face import WIDERFaceDataset
+from .xml_style import XMLDataset
+from .youtube_vis_dataset import YouTubeVISDataset
+
+__all__ = [
+    'XMLDataset', 'CocoDataset', 'DeepFashionDataset', 'VOCDataset',
+    'CityscapesDataset', 'LVISDataset', 'LVISV05Dataset', 'LVISV1Dataset',
+    'WIDERFaceDataset', 'get_loading_pipeline', 'CocoPanopticDataset',
+    'MultiImageMixDataset', 'OpenImagesDataset', 'OpenImagesChallengeDataset',
+    'AspectRatioBatchSampler', 'ClassAwareSampler', 'MultiSourceSampler',
+    'GroupMultiSourceSampler', 'BaseDetDataset', 'CrowdHumanDataset',
+    'Objects365V1Dataset', 'Objects365V2Dataset', 'DSDLDetDataset',
+    'BaseVideoDataset', 'MOTChallengeDataset', 'TrackImgSampler',
+    'ReIDDataset', 'YouTubeVISDataset', 'TrackAspectRatioBatchSampler',
+    'ADE20KPanopticDataset', 'CocoCaptionDataset', 'RefCocoDataset',
+    'BaseSegDataset', 'ADE20KSegDataset', 'CocoSegDataset',
+    'ADE20KInstanceDataset', 'iSAIDDataset', 'V3DetDataset', 'ConcatDataset',
+    'ODVGDataset', 'MDETRStyleRefCocoDataset', 'DODDataset',
+    'CustomSampleSizeSampler', 'Flickr30kDataset'
+]
diff --git a/mmdetection/mmdet/datasets/ade20k.py b/mmdetection/mmdet/datasets/ade20k.py
new file mode 100644
index 00000000..573271cb
--- /dev/null
+++ b/mmdetection/mmdet/datasets/ade20k.py
@@ -0,0 +1,260 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+from typing import List
+
+from mmengine import fileio
+
+from mmdet.registry import DATASETS
+from .base_semseg_dataset import BaseSegDataset
+from .coco import CocoDataset
+from .coco_panoptic import CocoPanopticDataset
+
+ADE_PALETTE = [(120, 120, 120), (180, 120, 120), (6, 230, 230), (80, 50, 50),
+               (4, 200, 3), (120, 120, 80), (140, 140, 140), (204, 5, 255),
+               (230, 230, 230), (4, 250, 7), (224, 5, 255), (235, 255, 7),
+               (150, 5, 61), (120, 120, 70), (8, 255, 51), (255, 6, 82),
+               (143, 255, 140), (204, 255, 4), (255, 51, 7), (204, 70, 3),
+               (0, 102, 200), (61, 230, 250), (255, 6, 51), (11, 102, 255),
+               (255, 7, 71), (255, 9, 224), (9, 7, 230), (220, 220, 220),
+               (255, 9, 92), (112, 9, 255), (8, 255, 214), (7, 255, 224),
+               (255, 184, 6), (10, 255, 71), (255, 41, 10), (7, 255, 255),
+               (224, 255, 8), (102, 8, 255), (255, 61, 6), (255, 194, 7),
+               (255, 122, 8), (0, 255, 20), (255, 8, 41), (255, 5, 153),
+               (6, 51, 255), (235, 12, 255), (160, 150, 20), (0, 163, 255),
+               (140, 140, 140), (250, 10, 15), (20, 255, 0), (31, 255, 0),
+               (255, 31, 0), (255, 224, 0), (153, 255, 0), (0, 0, 255),
+               (255, 71, 0), (0, 235, 255), (0, 173, 255), (31, 0, 255),
+               (11, 200, 200), (255, 82, 0), (0, 255, 245), (0, 61, 255),
+               (0, 255, 112), (0, 255, 133), (255, 0, 0), (255, 163, 0),
+               (255, 102, 0), (194, 255, 0), (0, 143, 255), (51, 255, 0),
+               (0, 82, 255), (0, 255, 41), (0, 255, 173), (10, 0, 255),
+               (173, 255, 0), (0, 255, 153), (255, 92, 0), (255, 0, 255),
+               (255, 0, 245), (255, 0, 102), (255, 173, 0), (255, 0, 20),
+               (255, 184, 184), (0, 31, 255), (0, 255, 61), (0, 71, 255),
+               (255, 0, 204), (0, 255, 194), (0, 255, 82), (0, 10, 255),
+               (0, 112, 255), (51, 0, 255), (0, 194, 255), (0, 122, 255),
+               (0, 255, 163), (255, 153, 0), (0, 255, 10), (255, 112, 0),
+               (143, 255, 0), (82, 0, 255), (163, 255, 0), (255, 235, 0),
+               (8, 184, 170), (133, 0, 255), (0, 255, 92), (184, 0, 255),
+               (255, 0, 31), (0, 184, 255), (0, 214, 255), (255, 0, 112),
+               (92, 255, 0), (0, 224, 255), (112, 224, 255), (70, 184, 160),
+               (163, 0, 255), (153, 0, 255), (71, 255, 0), (255, 0, 163),
+               (255, 204, 0), (255, 0, 143), (0, 255, 235), (133, 255, 0),
+               (255, 0, 235), (245, 0, 255), (255, 0, 122), (255, 245, 0),
+               (10, 190, 212), (214, 255, 0), (0, 204, 255), (20, 0, 255),
+               (255, 255, 0), (0, 153, 255), (0, 41, 255), (0, 255, 204),
+               (41, 0, 255), (41, 255, 0), (173, 0, 255), (0, 245, 255),
+               (71, 0, 255), (122, 0, 255), (0, 255, 184), (0, 92, 255),
+               (184, 255, 0), (0, 133, 255), (255, 214, 0), (25, 194, 194),
+               (102, 255, 0), (92, 0, 255)]
+
+
+@DATASETS.register_module()
+class ADE20KPanopticDataset(CocoPanopticDataset):
+    METAINFO = {
+        'classes':
+        ('bed', 'window', 'cabinet', 'person', 'door', 'table', 'curtain',
+         'chair', 'car', 'painting, picture', 'sofa', 'shelf', 'mirror',
+         'armchair', 'seat', 'fence', 'desk', 'wardrobe, closet, press',
+         'lamp', 'tub', 'rail', 'cushion', 'box', 'column, pillar',
+         'signboard, sign', 'chest of drawers, chest, bureau, dresser',
+         'counter', 'sink', 'fireplace', 'refrigerator, icebox', 'stairs',
+         'case, display case, showcase, vitrine',
+         'pool table, billiard table, snooker table', 'pillow',
+         'screen door, screen', 'bookcase', 'coffee table',
+         'toilet, can, commode, crapper, pot, potty, stool, throne', 'flower',
+         'book', 'bench', 'countertop', 'stove', 'palm, palm tree',
+         'kitchen island', 'computer', 'swivel chair', 'boat',
+         'arcade machine', 'bus', 'towel', 'light', 'truck', 'chandelier',
+         'awning, sunshade, sunblind', 'street lamp', 'booth', 'tv',
+         'airplane', 'clothes', 'pole',
+         'bannister, banister, balustrade, balusters, handrail',
+         'ottoman, pouf, pouffe, puff, hassock', 'bottle', 'van', 'ship',
+         'fountain', 'washer, automatic washer, washing machine',
+         'plaything, toy', 'stool', 'barrel, cask', 'basket, handbasket',
+         'bag', 'minibike, motorbike', 'oven', 'ball', 'food, solid food',
+         'step, stair', 'trade name', 'microwave', 'pot', 'animal', 'bicycle',
+         'dishwasher', 'screen', 'sculpture', 'hood, exhaust hood', 'sconce',
+         'vase', 'traffic light', 'tray', 'trash can', 'fan', 'plate',
+         'monitor', 'bulletin board', 'radiator', 'glass, drinking glass',
+         'clock', 'flag', 'wall', 'building', 'sky', 'floor', 'tree',
+         'ceiling', 'road, route', 'grass', 'sidewalk, pavement',
+         'earth, ground', 'mountain, mount', 'plant', 'water', 'house', 'sea',
+         'rug', 'field', 'rock, stone', 'base, pedestal, stand', 'sand',
+         'skyscraper', 'grandstand, covered stand', 'path', 'runway',
+         'stairway, staircase', 'river', 'bridge, span', 'blind, screen',
+         'hill', 'bar', 'hovel, hut, hutch, shack, shanty', 'tower',
+         'dirt track', 'land, ground, soil',
+         'escalator, moving staircase, moving stairway',
+         'buffet, counter, sideboard',
+         'poster, posting, placard, notice, bill, card', 'stage',
+         'conveyer belt, conveyor belt, conveyer, conveyor, transporter',
+         'canopy', 'pool', 'falls', 'tent', 'cradle', 'tank, storage tank',
+         'lake', 'blanket, cover', 'pier', 'crt screen', 'shower'),
+        'thing_classes':
+        ('bed', 'window', 'cabinet', 'person', 'door', 'table', 'curtain',
+         'chair', 'car', 'painting, picture', 'sofa', 'shelf', 'mirror',
+         'armchair', 'seat', 'fence', 'desk', 'wardrobe, closet, press',
+         'lamp', 'tub', 'rail', 'cushion', 'box', 'column, pillar',
+         'signboard, sign', 'chest of drawers, chest, bureau, dresser',
+         'counter', 'sink', 'fireplace', 'refrigerator, icebox', 'stairs',
+         'case, display case, showcase, vitrine',
+         'pool table, billiard table, snooker table', 'pillow',
+         'screen door, screen', 'bookcase', 'coffee table',
+         'toilet, can, commode, crapper, pot, potty, stool, throne', 'flower',
+         'book', 'bench', 'countertop', 'stove', 'palm, palm tree',
+         'kitchen island', 'computer', 'swivel chair', 'boat',
+         'arcade machine', 'bus', 'towel', 'light', 'truck', 'chandelier',
+         'awning, sunshade, sunblind', 'street lamp', 'booth', 'tv',
+         'airplane', 'clothes', 'pole',
+         'bannister, banister, balustrade, balusters, handrail',
+         'ottoman, pouf, pouffe, puff, hassock', 'bottle', 'van', 'ship',
+         'fountain', 'washer, automatic washer, washing machine',
+         'plaything, toy', 'stool', 'barrel, cask', 'basket, handbasket',
+         'bag', 'minibike, motorbike', 'oven', 'ball', 'food, solid food',
+         'step, stair', 'trade name', 'microwave', 'pot', 'animal', 'bicycle',
+         'dishwasher', 'screen', 'sculpture', 'hood, exhaust hood', 'sconce',
+         'vase', 'traffic light', 'tray', 'trash can', 'fan', 'plate',
+         'monitor', 'bulletin board', 'radiator', 'glass, drinking glass',
+         'clock', 'flag'),
+        'stuff_classes':
+        ('wall', 'building', 'sky', 'floor', 'tree', 'ceiling', 'road, route',
+         'grass', 'sidewalk, pavement', 'earth, ground', 'mountain, mount',
+         'plant', 'water', 'house', 'sea', 'rug', 'field', 'rock, stone',
+         'base, pedestal, stand', 'sand', 'skyscraper',
+         'grandstand, covered stand', 'path', 'runway', 'stairway, staircase',
+         'river', 'bridge, span', 'blind, screen', 'hill', 'bar',
+         'hovel, hut, hutch, shack, shanty', 'tower', 'dirt track',
+         'land, ground, soil', 'escalator, moving staircase, moving stairway',
+         'buffet, counter, sideboard',
+         'poster, posting, placard, notice, bill, card', 'stage',
+         'conveyer belt, conveyor belt, conveyer, conveyor, transporter',
+         'canopy', 'pool', 'falls', 'tent', 'cradle', 'tank, storage tank',
+         'lake', 'blanket, cover', 'pier', 'crt screen', 'shower'),
+        'palette':
+        ADE_PALETTE
+    }
+
+
+@DATASETS.register_module()
+class ADE20KInstanceDataset(CocoDataset):
+    METAINFO = {
+        'classes':
+        ('bed', 'windowpane', 'cabinet', 'person', 'door', 'table', 'curtain',
+         'chair', 'car', 'painting', 'sofa', 'shelf', 'mirror', 'armchair',
+         'seat', 'fence', 'desk', 'wardrobe', 'lamp', 'bathtub', 'railing',
+         'cushion', 'box', 'column', 'signboard', 'chest of drawers',
+         'counter', 'sink', 'fireplace', 'refrigerator', 'stairs', 'case',
+         'pool table', 'pillow', 'screen door', 'bookcase', 'coffee table',
+         'toilet', 'flower', 'book', 'bench', 'countertop', 'stove', 'palm',
+         'kitchen island', 'computer', 'swivel chair', 'boat',
+         'arcade machine', 'bus', 'towel', 'light', 'truck', 'chandelier',
+         'awning', 'streetlight', 'booth', 'television receiver', 'airplane',
+         'apparel', 'pole', 'bannister', 'ottoman', 'bottle', 'van', 'ship',
+         'fountain', 'washer', 'plaything', 'stool', 'barrel', 'basket', 'bag',
+         'minibike', 'oven', 'ball', 'food', 'step', 'trade name', 'microwave',
+         'pot', 'animal', 'bicycle', 'dishwasher', 'screen', 'sculpture',
+         'hood', 'sconce', 'vase', 'traffic light', 'tray', 'ashcan', 'fan',
+         'plate', 'monitor', 'bulletin board', 'radiator', 'glass', 'clock',
+         'flag'),
+        'palette': [(204, 5, 255), (230, 230, 230), (224, 5, 255),
+                    (150, 5, 61), (8, 255, 51), (255, 6, 82), (255, 51, 7),
+                    (204, 70, 3), (0, 102, 200), (255, 6, 51), (11, 102, 255),
+                    (255, 7, 71), (220, 220, 220), (8, 255, 214),
+                    (7, 255, 224), (255, 184, 6), (10, 255, 71), (7, 255, 255),
+                    (224, 255, 8), (102, 8, 255), (255, 61, 6), (255, 194, 7),
+                    (0, 255, 20), (255, 8, 41), (255, 5, 153), (6, 51, 255),
+                    (235, 12, 255), (0, 163, 255), (250, 10, 15), (20, 255, 0),
+                    (255, 224, 0), (0, 0, 255), (255, 71, 0), (0, 235, 255),
+                    (0, 173, 255), (0, 255, 245), (0, 255, 112), (0, 255, 133),
+                    (255, 0, 0), (255, 163, 0), (194, 255, 0), (0, 143, 255),
+                    (51, 255, 0), (0, 82, 255), (0, 255, 41), (0, 255, 173),
+                    (10, 0, 255), (173, 255, 0), (255, 92, 0), (255, 0, 245),
+                    (255, 0, 102), (255, 173, 0), (255, 0, 20), (0, 31, 255),
+                    (0, 255, 61), (0, 71, 255), (255, 0, 204), (0, 255, 194),
+                    (0, 255, 82), (0, 112, 255), (51, 0, 255), (0, 122, 255),
+                    (255, 153, 0), (0, 255, 10), (163, 255, 0), (255, 235, 0),
+                    (8, 184, 170), (184, 0, 255), (255, 0, 31), (0, 214, 255),
+                    (255, 0, 112), (92, 255, 0), (70, 184, 160), (163, 0, 255),
+                    (71, 255, 0), (255, 0, 163), (255, 204, 0), (255, 0, 143),
+                    (133, 255, 0), (255, 0, 235), (245, 0, 255), (255, 0, 122),
+                    (255, 245, 0), (214, 255, 0), (0, 204, 255), (255, 255, 0),
+                    (0, 153, 255), (0, 41, 255), (0, 255, 204), (41, 0, 255),
+                    (41, 255, 0), (173, 0, 255), (0, 245, 255), (0, 255, 184),
+                    (0, 92, 255), (184, 255, 0), (255, 214, 0), (25, 194, 194),
+                    (102, 255, 0), (92, 0, 255)],
+    }
+
+
+@DATASETS.register_module()
+class ADE20KSegDataset(BaseSegDataset):
+    """ADE20K dataset.
+
+    In segmentation map annotation for ADE20K, 0 stands for background, which
+    is not included in 150 categories. The ``img_suffix`` is fixed to '.jpg',
+    and ``seg_map_suffix`` is fixed to '.png'.
+    """
+    METAINFO = dict(
+        classes=('wall', 'building', 'sky', 'floor', 'tree', 'ceiling', 'road',
+                 'bed ', 'windowpane', 'grass', 'cabinet', 'sidewalk',
+                 'person', 'earth', 'door', 'table', 'mountain', 'plant',
+                 'curtain', 'chair', 'car', 'water', 'painting', 'sofa',
+                 'shelf', 'house', 'sea', 'mirror', 'rug', 'field', 'armchair',
+                 'seat', 'fence', 'desk', 'rock', 'wardrobe', 'lamp',
+                 'bathtub', 'railing', 'cushion', 'base', 'box', 'column',
+                 'signboard', 'chest of drawers', 'counter', 'sand', 'sink',
+                 'skyscraper', 'fireplace', 'refrigerator', 'grandstand',
+                 'path', 'stairs', 'runway', 'case', 'pool table', 'pillow',
+                 'screen door', 'stairway', 'river', 'bridge', 'bookcase',
+                 'blind', 'coffee table', 'toilet', 'flower', 'book', 'hill',
+                 'bench', 'countertop', 'stove', 'palm', 'kitchen island',
+                 'computer', 'swivel chair', 'boat', 'bar', 'arcade machine',
+                 'hovel', 'bus', 'towel', 'light', 'truck', 'tower',
+                 'chandelier', 'awning', 'streetlight', 'booth',
+                 'television receiver', 'airplane', 'dirt track', 'apparel',
+                 'pole', 'land', 'bannister', 'escalator', 'ottoman', 'bottle',
+                 'buffet', 'poster', 'stage', 'van', 'ship', 'fountain',
+                 'conveyer belt', 'canopy', 'washer', 'plaything',
+                 'swimming pool', 'stool', 'barrel', 'basket', 'waterfall',
+                 'tent', 'bag', 'minibike', 'cradle', 'oven', 'ball', 'food',
+                 'step', 'tank', 'trade name', 'microwave', 'pot', 'animal',
+                 'bicycle', 'lake', 'dishwasher', 'screen', 'blanket',
+                 'sculpture', 'hood', 'sconce', 'vase', 'traffic light',
+                 'tray', 'ashcan', 'fan', 'pier', 'crt screen', 'plate',
+                 'monitor', 'bulletin board', 'shower', 'radiator', 'glass',
+                 'clock', 'flag'),
+        palette=ADE_PALETTE)
+
+    def __init__(self,
+                 img_suffix='.jpg',
+                 seg_map_suffix='.png',
+                 return_classes=False,
+                 **kwargs) -> None:
+        self.return_classes = return_classes
+        super().__init__(
+            img_suffix=img_suffix, seg_map_suffix=seg_map_suffix, **kwargs)
+
+    def load_data_list(self) -> List[dict]:
+        """Load annotation from directory or annotation file.
+
+        Returns:
+            List[dict]: All data info of dataset.
+        """
+        data_list = []
+        img_dir = self.data_prefix.get('img_path', None)
+        ann_dir = self.data_prefix.get('seg_map_path', None)
+        for img in fileio.list_dir_or_file(
+                dir_path=img_dir,
+                list_dir=False,
+                suffix=self.img_suffix,
+                recursive=True,
+                backend_args=self.backend_args):
+            data_info = dict(img_path=osp.join(img_dir, img))
+            if ann_dir is not None:
+                seg_map = img.replace(self.img_suffix, self.seg_map_suffix)
+                data_info['seg_map_path'] = osp.join(ann_dir, seg_map)
+            data_info['label_map'] = self.label_map
+            if self.return_classes:
+                data_info['text'] = list(self._metainfo['classes'])
+            data_list.append(data_info)
+        return data_list
diff --git a/mmdetection/mmdet/datasets/api_wrappers/__init__.py b/mmdetection/mmdet/datasets/api_wrappers/__init__.py
new file mode 100644
index 00000000..8e3c41a2
--- /dev/null
+++ b/mmdetection/mmdet/datasets/api_wrappers/__init__.py
@@ -0,0 +1,5 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .coco_api import COCO, COCOeval, COCOPanoptic
+from .cocoeval_mp import COCOevalMP
+
+__all__ = ['COCO', 'COCOeval', 'COCOPanoptic', 'COCOevalMP']
diff --git a/mmdetection/mmdet/datasets/api_wrappers/coco_api.py b/mmdetection/mmdet/datasets/api_wrappers/coco_api.py
new file mode 100644
index 00000000..b2d11a12
--- /dev/null
+++ b/mmdetection/mmdet/datasets/api_wrappers/coco_api.py
@@ -0,0 +1,137 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# This file add snake case alias for coco api
+
+import warnings
+from collections import defaultdict
+from typing import List, Optional, Union
+
+import pycocotools
+from pycocotools.coco import COCO as _COCO
+from pycocotools.cocoeval import COCOeval as _COCOeval
+
+
+class COCO(_COCO):
+    """This class is almost the same as official pycocotools package.
+
+    It implements some snake case function aliases. So that the COCO class has
+    the same interface as LVIS class.
+    """
+
+    def __init__(self, annotation_file=None):
+        if getattr(pycocotools, '__version__', '0') >= '12.0.2':
+            warnings.warn(
+                'mmpycocotools is deprecated. Please install official pycocotools by "pip install pycocotools"',  # noqa: E501
+                UserWarning)
+        super().__init__(annotation_file=annotation_file)
+        self.img_ann_map = self.imgToAnns
+        self.cat_img_map = self.catToImgs
+
+    def get_ann_ids(self, img_ids=[], cat_ids=[], area_rng=[], iscrowd=None):
+        return self.getAnnIds(img_ids, cat_ids, area_rng, iscrowd)
+
+    def get_cat_ids(self, cat_names=[], sup_names=[], cat_ids=[]):
+        return self.getCatIds(cat_names, sup_names, cat_ids)
+
+    def get_img_ids(self, img_ids=[], cat_ids=[]):
+        return self.getImgIds(img_ids, cat_ids)
+
+    def load_anns(self, ids):
+        return self.loadAnns(ids)
+
+    def load_cats(self, ids):
+        return self.loadCats(ids)
+
+    def load_imgs(self, ids):
+        return self.loadImgs(ids)
+
+
+# just for the ease of import
+COCOeval = _COCOeval
+
+
+class COCOPanoptic(COCO):
+    """This wrapper is for loading the panoptic style annotation file.
+
+    The format is shown in the CocoPanopticDataset class.
+
+    Args:
+        annotation_file (str, optional): Path of annotation file.
+            Defaults to None.
+    """
+
+    def __init__(self, annotation_file: Optional[str] = None) -> None:
+        super(COCOPanoptic, self).__init__(annotation_file)
+
+    def createIndex(self) -> None:
+        """Create index."""
+        # create index
+        print('creating index...')
+        # anns stores 'segment_id -> annotation'
+        anns, cats, imgs = {}, {}, {}
+        img_to_anns, cat_to_imgs = defaultdict(list), defaultdict(list)
+        if 'annotations' in self.dataset:
+            for ann in self.dataset['annotations']:
+                for seg_ann in ann['segments_info']:
+                    # to match with instance.json
+                    seg_ann['image_id'] = ann['image_id']
+                    img_to_anns[ann['image_id']].append(seg_ann)
+                    # segment_id is not unique in coco dataset orz...
+                    # annotations from different images but
+                    # may have same segment_id
+                    if seg_ann['id'] in anns.keys():
+                        anns[seg_ann['id']].append(seg_ann)
+                    else:
+                        anns[seg_ann['id']] = [seg_ann]
+
+            # filter out annotations from other images
+            img_to_anns_ = defaultdict(list)
+            for k, v in img_to_anns.items():
+                img_to_anns_[k] = [x for x in v if x['image_id'] == k]
+            img_to_anns = img_to_anns_
+
+        if 'images' in self.dataset:
+            for img_info in self.dataset['images']:
+                img_info['segm_file'] = img_info['file_name'].replace(
+                    '.jpg', '.png')
+                imgs[img_info['id']] = img_info
+
+        if 'categories' in self.dataset:
+            for cat in self.dataset['categories']:
+                cats[cat['id']] = cat
+
+        if 'annotations' in self.dataset and 'categories' in self.dataset:
+            for ann in self.dataset['annotations']:
+                for seg_ann in ann['segments_info']:
+                    cat_to_imgs[seg_ann['category_id']].append(ann['image_id'])
+
+        print('index created!')
+
+        self.anns = anns
+        self.imgToAnns = img_to_anns
+        self.catToImgs = cat_to_imgs
+        self.imgs = imgs
+        self.cats = cats
+
+    def load_anns(self,
+                  ids: Union[List[int], int] = []) -> Optional[List[dict]]:
+        """Load anns with the specified ids.
+
+        ``self.anns`` is a list of annotation lists instead of a
+        list of annotations.
+
+        Args:
+            ids (Union[List[int], int]): Integer ids specifying anns.
+
+        Returns:
+            anns (List[dict], optional): Loaded ann objects.
+        """
+        anns = []
+
+        if hasattr(ids, '__iter__') and hasattr(ids, '__len__'):
+            # self.anns is a list of annotation lists instead of
+            # a list of annotations
+            for id in ids:
+                anns += self.anns[id]
+            return anns
+        elif type(ids) == int:
+            return self.anns[ids]
diff --git a/mmdetection/mmdet/datasets/api_wrappers/cocoeval_mp.py b/mmdetection/mmdet/datasets/api_wrappers/cocoeval_mp.py
new file mode 100644
index 00000000..b3673ea7
--- /dev/null
+++ b/mmdetection/mmdet/datasets/api_wrappers/cocoeval_mp.py
@@ -0,0 +1,296 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import itertools
+import time
+from collections import defaultdict
+
+import numpy as np
+import torch.multiprocessing as mp
+from mmengine.logging import MMLogger
+from pycocotools.cocoeval import COCOeval
+from tqdm import tqdm
+
+
+class COCOevalMP(COCOeval):
+
+    def _prepare(self):
+        '''
+        Prepare ._gts and ._dts for evaluation based on params
+        :return: None
+        '''
+
+        def _toMask(anns, coco):
+            # modify ann['segmentation'] by reference
+            for ann in anns:
+                rle = coco.annToRLE(ann)
+                ann['segmentation'] = rle
+
+        p = self.params
+        if p.useCats:
+            gts = []
+            dts = []
+            img_ids = set(p.imgIds)
+            cat_ids = set(p.catIds)
+            for gt in self.cocoGt.dataset['annotations']:
+                if (gt['category_id'] in cat_ids) and (gt['image_id']
+                                                       in img_ids):
+                    gts.append(gt)
+            for dt in self.cocoDt.dataset['annotations']:
+                if (dt['category_id'] in cat_ids) and (dt['image_id']
+                                                       in img_ids):
+                    dts.append(dt)
+            # gts=self.cocoGt.loadAnns(self.cocoGt.getAnnIds(imgIds=p.imgIds, catIds=p.catIds)) # noqa
+            # dts=self.cocoDt.loadAnns(self.cocoDt.getAnnIds(imgIds=p.imgIds, catIds=p.catIds)) # noqa
+            # gts=self.cocoGt.dataset['annotations']
+            # dts=self.cocoDt.dataset['annotations']
+        else:
+            gts = self.cocoGt.loadAnns(self.cocoGt.getAnnIds(imgIds=p.imgIds))
+            dts = self.cocoDt.loadAnns(self.cocoDt.getAnnIds(imgIds=p.imgIds))
+
+        # convert ground truth to mask if iouType == 'segm'
+        if p.iouType == 'segm':
+            _toMask(gts, self.cocoGt)
+            _toMask(dts, self.cocoDt)
+        # set ignore flag
+        for gt in gts:
+            gt['ignore'] = gt['ignore'] if 'ignore' in gt else 0
+            gt['ignore'] = 'iscrowd' in gt and gt['iscrowd']
+            if p.iouType == 'keypoints':
+                gt['ignore'] = (gt['num_keypoints'] == 0) or gt['ignore']
+        self._gts = defaultdict(list)  # gt for evaluation
+        self._dts = defaultdict(list)  # dt for evaluation
+        for gt in gts:
+            self._gts[gt['image_id'], gt['category_id']].append(gt)
+        for dt in dts:
+            self._dts[dt['image_id'], dt['category_id']].append(dt)
+        self.evalImgs = defaultdict(
+            list)  # per-image per-category evaluation results
+        self.eval = {}  # accumulated evaluation results
+
+    def evaluate(self):
+        """Run per image evaluation on given images and store results (a list
+        of dict) in self.evalImgs.
+
+        :return: None
+        """
+        tic = time.time()
+        print('Running per image evaluation...')
+        p = self.params
+        # add backward compatibility if useSegm is specified in params
+        if p.useSegm is not None:
+            p.iouType = 'segm' if p.useSegm == 1 else 'bbox'
+            print('useSegm (deprecated) is not None. Running {} evaluation'.
+                  format(p.iouType))
+        print('Evaluate annotation type *{}*'.format(p.iouType))
+        p.imgIds = list(np.unique(p.imgIds))
+        if p.useCats:
+            p.catIds = list(np.unique(p.catIds))
+        p.maxDets = sorted(p.maxDets)
+        self.params = p
+
+        # loop through images, area range, max detection number
+        catIds = p.catIds if p.useCats else [-1]
+
+        nproc = 8
+        split_size = len(catIds) // nproc
+        mp_params = []
+        for i in range(nproc):
+            begin = i * split_size
+            end = (i + 1) * split_size
+            if i == nproc - 1:
+                end = len(catIds)
+            mp_params.append((catIds[begin:end], ))
+
+        MMLogger.get_current_instance().info(
+            'start multi processing evaluation ...')
+        with mp.Pool(nproc) as pool:
+            self.evalImgs = pool.starmap(self._evaluateImg, mp_params)
+
+        self.evalImgs = list(itertools.chain(*self.evalImgs))
+
+        self._paramsEval = copy.deepcopy(self.params)
+        toc = time.time()
+        print('DONE (t={:0.2f}s).'.format(toc - tic))
+
+    def _evaluateImg(self, catids_chunk):
+        self._prepare()
+        p = self.params
+        maxDet = max(p.maxDets)
+        all_params = []
+        for catId in catids_chunk:
+            for areaRng in p.areaRng:
+                for imgId in p.imgIds:
+                    all_params.append((catId, areaRng, imgId))
+        evalImgs = [
+            self.evaluateImg(imgId, catId, areaRng, maxDet)
+            for catId, areaRng, imgId in tqdm(all_params)
+        ]
+        return evalImgs
+
+    def evaluateImg(self, imgId, catId, aRng, maxDet):
+        p = self.params
+        if p.useCats:
+            gt = self._gts[imgId, catId]
+            dt = self._dts[imgId, catId]
+        else:
+            gt = [_ for cId in p.catIds for _ in self._gts[imgId, cId]]
+            dt = [_ for cId in p.catIds for _ in self._dts[imgId, cId]]
+        if len(gt) == 0 and len(dt) == 0:
+            return None
+
+        for g in gt:
+            if g['ignore'] or (g['area'] < aRng[0] or g['area'] > aRng[1]):
+                g['_ignore'] = 1
+            else:
+                g['_ignore'] = 0
+
+        # sort dt highest score first, sort gt ignore last
+        gtind = np.argsort([g['_ignore'] for g in gt], kind='mergesort')
+        gt = [gt[i] for i in gtind]
+        dtind = np.argsort([-d['score'] for d in dt], kind='mergesort')
+        dt = [dt[i] for i in dtind[0:maxDet]]
+        iscrowd = [int(o['iscrowd']) for o in gt]
+        # load computed ious
+        # ious = self.ious[imgId, catId][:, gtind] if len(self.ious[imgId, catId]) > 0 else self.ious[imgId, catId] # noqa
+        ious = self.computeIoU(imgId, catId)
+        ious = ious[:, gtind] if len(ious) > 0 else ious
+
+        T = len(p.iouThrs)
+        G = len(gt)
+        D = len(dt)
+        gtm = np.zeros((T, G))
+        dtm = np.zeros((T, D))
+        gtIg = np.array([g['_ignore'] for g in gt])
+        dtIg = np.zeros((T, D))
+        if not len(ious) == 0:
+            for tind, t in enumerate(p.iouThrs):
+                for dind, d in enumerate(dt):
+                    # information about best match so far (m=-1 -> unmatched)
+                    iou = min([t, 1 - 1e-10])
+                    m = -1
+                    for gind, g in enumerate(gt):
+                        # if this gt already matched, and not a crowd, continue
+                        if gtm[tind, gind] > 0 and not iscrowd[gind]:
+                            continue
+                        # if dt matched to reg gt, and on ignore gt, stop
+                        if m > -1 and gtIg[m] == 0 and gtIg[gind] == 1:
+                            break
+                        # continue to next gt unless better match made
+                        if ious[dind, gind] < iou:
+                            continue
+                        # if match successful and best so far,
+                        # store appropriately
+                        iou = ious[dind, gind]
+                        m = gind
+                    # if match made store id of match for both dt and gt
+                    if m == -1:
+                        continue
+                    dtIg[tind, dind] = gtIg[m]
+                    dtm[tind, dind] = gt[m]['id']
+                    gtm[tind, m] = d['id']
+        # set unmatched detections outside of area range to ignore
+        a = np.array([d['area'] < aRng[0] or d['area'] > aRng[1]
+                      for d in dt]).reshape((1, len(dt)))
+        dtIg = np.logical_or(dtIg, np.logical_and(dtm == 0, np.repeat(a, T,
+                                                                      0)))
+        # store results for given image and category
+
+        return {
+            'image_id': imgId,
+            'category_id': catId,
+            'aRng': aRng,
+            'maxDet': maxDet,
+            'dtIds': [d['id'] for d in dt],
+            'gtIds': [g['id'] for g in gt],
+            'dtMatches': dtm,
+            'gtMatches': gtm,
+            'dtScores': [d['score'] for d in dt],
+            'gtIgnore': gtIg,
+            'dtIgnore': dtIg,
+        }
+
+    def summarize(self):
+        """Compute and display summary metrics for evaluation results.
+
+        Note this function can *only* be applied on the default parameter
+        setting
+        """
+
+        def _summarize(ap=1, iouThr=None, areaRng='all', maxDets=100):
+            p = self.params
+            iStr = ' {:<18} {} @[ IoU={:<9} | area={:>6s} | maxDets={:>3d} ] = {:0.3f}'  # noqa
+            titleStr = 'Average Precision' if ap == 1 else 'Average Recall'
+            typeStr = '(AP)' if ap == 1 else '(AR)'
+            iouStr = '{:0.2f}:{:0.2f}'.format(p.iouThrs[0], p.iouThrs[-1]) \
+                if iouThr is None else '{:0.2f}'.format(iouThr)
+
+            aind = [
+                i for i, aRng in enumerate(p.areaRngLbl) if aRng == areaRng
+            ]
+            mind = [i for i, mDet in enumerate(p.maxDets) if mDet == maxDets]
+            if ap == 1:
+                # dimension of precision: [TxRxKxAxM]
+                s = self.eval['precision']
+                # IoU
+                if iouThr is not None:
+                    t = np.where(iouThr == p.iouThrs)[0]
+                    s = s[t]
+                s = s[:, :, :, aind, mind]
+            else:
+                # dimension of recall: [TxKxAxM]
+                s = self.eval['recall']
+                if iouThr is not None:
+                    t = np.where(iouThr == p.iouThrs)[0]
+                    s = s[t]
+                s = s[:, :, aind, mind]
+            if len(s[s > -1]) == 0:
+                mean_s = -1
+            else:
+                mean_s = np.mean(s[s > -1])
+            print(
+                iStr.format(titleStr, typeStr, iouStr, areaRng, maxDets,
+                            mean_s))
+            return mean_s
+
+        def _summarizeDets():
+            stats = []
+            stats.append(_summarize(1, maxDets=self.params.maxDets[-1]))
+            stats.append(
+                _summarize(1, iouThr=.5, maxDets=self.params.maxDets[-1]))
+            stats.append(
+                _summarize(1, iouThr=.75, maxDets=self.params.maxDets[-1]))
+            for area_rng in ('small', 'medium', 'large'):
+                stats.append(
+                    _summarize(
+                        1, areaRng=area_rng, maxDets=self.params.maxDets[-1]))
+            for max_det in self.params.maxDets:
+                stats.append(_summarize(0, maxDets=max_det))
+            for area_rng in ('small', 'medium', 'large'):
+                stats.append(
+                    _summarize(
+                        0, areaRng=area_rng, maxDets=self.params.maxDets[-1]))
+            stats = np.array(stats)
+            return stats
+
+        def _summarizeKps():
+            stats = np.zeros((10, ))
+            stats[0] = _summarize(1, maxDets=20)
+            stats[1] = _summarize(1, maxDets=20, iouThr=.5)
+            stats[2] = _summarize(1, maxDets=20, iouThr=.75)
+            stats[3] = _summarize(1, maxDets=20, areaRng='medium')
+            stats[4] = _summarize(1, maxDets=20, areaRng='large')
+            stats[5] = _summarize(0, maxDets=20)
+            stats[6] = _summarize(0, maxDets=20, iouThr=.5)
+            stats[7] = _summarize(0, maxDets=20, iouThr=.75)
+            stats[8] = _summarize(0, maxDets=20, areaRng='medium')
+            stats[9] = _summarize(0, maxDets=20, areaRng='large')
+            return stats
+
+        if not self.eval:
+            raise Exception('Please run accumulate() first')
+        iouType = self.params.iouType
+        if iouType == 'segm' or iouType == 'bbox':
+            summarize = _summarizeDets
+        elif iouType == 'keypoints':
+            summarize = _summarizeKps
+        self.stats = summarize()
diff --git a/mmdetection/mmdet/datasets/base_det_dataset.py b/mmdetection/mmdet/datasets/base_det_dataset.py
new file mode 100644
index 00000000..8b3876d5
--- /dev/null
+++ b/mmdetection/mmdet/datasets/base_det_dataset.py
@@ -0,0 +1,131 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+from typing import List, Optional
+
+from mmengine.dataset import BaseDataset
+from mmengine.fileio import load
+from mmengine.utils import is_abs
+
+from ..registry import DATASETS
+
+
+@DATASETS.register_module()
+class BaseDetDataset(BaseDataset):
+    """Base dataset for detection.
+
+    Args:
+        proposal_file (str, optional): Proposals file path. Defaults to None.
+        file_client_args (dict): Arguments to instantiate the
+            corresponding backend in mmdet <= 3.0.0rc6. Defaults to None.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+        return_classes (bool): Whether to return class information
+            for open vocabulary-based algorithms. Defaults to False.
+        caption_prompt (dict, optional): Prompt for captioning.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 *args,
+                 seg_map_suffix: str = '.png',
+                 proposal_file: Optional[str] = None,
+                 file_client_args: dict = None,
+                 backend_args: dict = None,
+                 return_classes: bool = False,
+                 caption_prompt: Optional[dict] = None,
+                 **kwargs) -> None:
+        self.seg_map_suffix = seg_map_suffix
+        self.proposal_file = proposal_file
+        self.backend_args = backend_args
+        self.return_classes = return_classes
+        self.caption_prompt = caption_prompt
+        if self.caption_prompt is not None:
+            assert self.return_classes, \
+                'return_classes must be True when using caption_prompt'
+        if file_client_args is not None:
+            raise RuntimeError(
+                'The `file_client_args` is deprecated, '
+                'please use `backend_args` instead, please refer to'
+                'https://github.com/open-mmlab/mmdetection/blob/main/configs/_base_/datasets/coco_detection.py'  # noqa: E501
+            )
+        super().__init__(*args, **kwargs)
+
+    def full_init(self) -> None:
+        """Load annotation file and set ``BaseDataset._fully_initialized`` to
+        True.
+
+        If ``lazy_init=False``, ``full_init`` will be called during the
+        instantiation and ``self._fully_initialized`` will be set to True. If
+        ``obj._fully_initialized=False``, the class method decorated by
+        ``force_full_init`` will call ``full_init`` automatically.
+
+        Several steps to initialize annotation:
+
+            - load_data_list: Load annotations from annotation file.
+            - load_proposals: Load proposals from proposal file, if
+              `self.proposal_file` is not None.
+            - filter data information: Filter annotations according to
+              filter_cfg.
+            - slice_data: Slice dataset according to ``self._indices``
+            - serialize_data: Serialize ``self.data_list`` if
+            ``self.serialize_data`` is True.
+        """
+        if self._fully_initialized:
+            return
+        # load data information
+        self.data_list = self.load_data_list()
+        # get proposals from file
+        if self.proposal_file is not None:
+            self.load_proposals()
+        # filter illegal data, such as data that has no annotations.
+        self.data_list = self.filter_data()
+
+        # Get subset data according to indices.
+        if self._indices is not None:
+            self.data_list = self._get_unserialized_subset(self._indices)
+
+        # serialize data_list
+        if self.serialize_data:
+            self.data_bytes, self.data_address = self._serialize_data()
+
+        self._fully_initialized = True
+
+    def load_proposals(self) -> None:
+        """Load proposals from proposals file.
+
+        The `proposals_list` should be a dict[img_path: proposals]
+        with the same length as `data_list`. And the `proposals` should be
+        a `dict` or :obj:`InstanceData` usually contains following keys.
+
+            - bboxes (np.ndarry): Has a shape (num_instances, 4),
+              the last dimension 4 arrange as (x1, y1, x2, y2).
+            - scores (np.ndarry): Classification scores, has a shape
+              (num_instance, ).
+        """
+        # TODO: Add Unit Test after fully support Dump-Proposal Metric
+        if not is_abs(self.proposal_file):
+            self.proposal_file = osp.join(self.data_root, self.proposal_file)
+        proposals_list = load(
+            self.proposal_file, backend_args=self.backend_args)
+        assert len(self.data_list) == len(proposals_list)
+        for data_info in self.data_list:
+            img_path = data_info['img_path']
+            # `file_name` is the key to obtain the proposals from the
+            # `proposals_list`.
+            file_name = osp.join(
+                osp.split(osp.split(img_path)[0])[-1],
+                osp.split(img_path)[-1])
+            proposals = proposals_list[file_name]
+            data_info['proposals'] = proposals
+
+    def get_cat_ids(self, idx: int) -> List[int]:
+        """Get COCO category ids by index.
+
+        Args:
+            idx (int): Index of data.
+
+        Returns:
+            List[int]: All categories in the image of specified index.
+        """
+        instances = self.get_data_info(idx)['instances']
+        return [instance['bbox_label'] for instance in instances]
diff --git a/mmdetection/mmdet/datasets/base_semseg_dataset.py b/mmdetection/mmdet/datasets/base_semseg_dataset.py
new file mode 100644
index 00000000..d10f762a
--- /dev/null
+++ b/mmdetection/mmdet/datasets/base_semseg_dataset.py
@@ -0,0 +1,265 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import os.path as osp
+from typing import Callable, Dict, List, Optional, Sequence, Union
+
+import mmengine
+import mmengine.fileio as fileio
+import numpy as np
+from mmengine.dataset import BaseDataset, Compose
+
+from mmdet.registry import DATASETS
+
+
+@DATASETS.register_module()
+class BaseSegDataset(BaseDataset):
+    """Custom dataset for semantic segmentation. An example of file structure
+    is as followed.
+
+    .. code-block:: none
+
+        ├── data
+        │   ├── my_dataset
+        │   │   ├── img_dir
+        │   │   │   ├── train
+        │   │   │   │   ├── xxx{img_suffix}
+        │   │   │   │   ├── yyy{img_suffix}
+        │   │   │   │   ├── zzz{img_suffix}
+        │   │   │   ├── val
+        │   │   ├── ann_dir
+        │   │   │   ├── train
+        │   │   │   │   ├── xxx{seg_map_suffix}
+        │   │   │   │   ├── yyy{seg_map_suffix}
+        │   │   │   │   ├── zzz{seg_map_suffix}
+        │   │   │   ├── val
+
+    The img/gt_semantic_seg pair of BaseSegDataset should be of the same
+    except suffix. A valid img/gt_semantic_seg filename pair should be like
+    ``xxx{img_suffix}`` and ``xxx{seg_map_suffix}`` (extension is also included
+    in the suffix). If split is given, then ``xxx`` is specified in txt file.
+    Otherwise, all files in ``img_dir/``and ``ann_dir`` will be loaded.
+    Please refer to ``docs/en/tutorials/new_dataset.md`` for more details.
+
+
+    Args:
+        ann_file (str): Annotation file path. Defaults to ''.
+        metainfo (dict, optional): Meta information for dataset, such as
+            specify classes to load. Defaults to None.
+        data_root (str, optional): The root directory for ``data_prefix`` and
+            ``ann_file``. Defaults to None.
+        data_prefix (dict, optional): Prefix for training data. Defaults to
+            dict(img_path=None, seg_map_path=None).
+        img_suffix (str): Suffix of images. Default: '.jpg'
+        seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
+        filter_cfg (dict, optional): Config for filter data. Defaults to None.
+        indices (int or Sequence[int], optional): Support using first few
+            data in annotation file to facilitate training/testing on a smaller
+            dataset. Defaults to None which means using all ``data_infos``.
+        serialize_data (bool, optional): Whether to hold memory using
+            serialized objects, when enabled, data loader workers can use
+            shared RAM from master process instead of making a copy. Defaults
+            to True.
+        pipeline (list, optional): Processing pipeline. Defaults to [].
+        test_mode (bool, optional): ``test_mode=True`` means in test phase.
+            Defaults to False.
+        lazy_init (bool, optional): Whether to load annotation during
+            instantiation. In some cases, such as visualization, only the meta
+            information of the dataset is needed, which is not necessary to
+            load annotation file. ``Basedataset`` can skip load annotations to
+            save time by set ``lazy_init=True``. Defaults to False.
+        use_label_map (bool, optional): Whether to use label map.
+            Defaults to False.
+        max_refetch (int, optional): If ``Basedataset.prepare_data`` get a
+            None img. The maximum extra number of cycles to get a valid
+            image. Defaults to 1000.
+        backend_args (dict, Optional): Arguments to instantiate a file backend.
+            See https://mmengine.readthedocs.io/en/latest/api/fileio.htm
+            for details. Defaults to None.
+            Notes: mmcv>=2.0.0rc4 required.
+    """
+    METAINFO: dict = dict()
+
+    def __init__(self,
+                 ann_file: str = '',
+                 img_suffix='.jpg',
+                 seg_map_suffix='.png',
+                 metainfo: Optional[dict] = None,
+                 data_root: Optional[str] = None,
+                 data_prefix: dict = dict(img_path='', seg_map_path=''),
+                 filter_cfg: Optional[dict] = None,
+                 indices: Optional[Union[int, Sequence[int]]] = None,
+                 serialize_data: bool = True,
+                 pipeline: List[Union[dict, Callable]] = [],
+                 test_mode: bool = False,
+                 lazy_init: bool = False,
+                 use_label_map: bool = False,
+                 max_refetch: int = 1000,
+                 backend_args: Optional[dict] = None) -> None:
+
+        self.img_suffix = img_suffix
+        self.seg_map_suffix = seg_map_suffix
+        self.backend_args = backend_args.copy() if backend_args else None
+
+        self.data_root = data_root
+        self.data_prefix = copy.copy(data_prefix)
+        self.ann_file = ann_file
+        self.filter_cfg = copy.deepcopy(filter_cfg)
+        self._indices = indices
+        self.serialize_data = serialize_data
+        self.test_mode = test_mode
+        self.max_refetch = max_refetch
+        self.data_list: List[dict] = []
+        self.data_bytes: np.ndarray
+
+        # Set meta information.
+        self._metainfo = self._load_metainfo(copy.deepcopy(metainfo))
+
+        # Get label map for custom classes
+        new_classes = self._metainfo.get('classes', None)
+        self.label_map = self.get_label_map(
+            new_classes) if use_label_map else None
+        self._metainfo.update(dict(label_map=self.label_map))
+
+        # Update palette based on label map or generate palette
+        # if it is not defined
+        updated_palette = self._update_palette()
+        self._metainfo.update(dict(palette=updated_palette))
+
+        # Join paths.
+        if self.data_root is not None:
+            self._join_prefix()
+
+        # Build pipeline.
+        self.pipeline = Compose(pipeline)
+        # Full initialize the dataset.
+        if not lazy_init:
+            self.full_init()
+
+        if test_mode:
+            assert self._metainfo.get('classes') is not None, \
+                'dataset metainfo `classes` should be specified when testing'
+
+    @classmethod
+    def get_label_map(cls,
+                      new_classes: Optional[Sequence] = None
+                      ) -> Union[Dict, None]:
+        """Require label mapping.
+
+        The ``label_map`` is a dictionary, its keys are the old label ids and
+        its values are the new label ids, and is used for changing pixel
+        labels in load_annotations. If and only if old classes in cls.METAINFO
+        is not equal to new classes in self._metainfo and nether of them is not
+        None, `label_map` is not None.
+
+        Args:
+            new_classes (list, tuple, optional): The new classes name from
+                metainfo. Default to None.
+
+
+        Returns:
+            dict, optional: The mapping from old classes in cls.METAINFO to
+                new classes in self._metainfo
+        """
+        old_classes = cls.METAINFO.get('classes', None)
+        if (new_classes is not None and old_classes is not None
+                and list(new_classes) != list(old_classes)):
+
+            label_map = {}
+            if not set(new_classes).issubset(cls.METAINFO['classes']):
+                raise ValueError(
+                    f'new classes {new_classes} is not a '
+                    f'subset of classes {old_classes} in METAINFO.')
+            for i, c in enumerate(old_classes):
+                if c not in new_classes:
+                    # 0 is background
+                    label_map[i] = 0
+                else:
+                    label_map[i] = new_classes.index(c)
+            return label_map
+        else:
+            return None
+
+    def _update_palette(self) -> list:
+        """Update palette after loading metainfo.
+
+        If length of palette is equal to classes, just return the palette.
+        If palette is not defined, it will randomly generate a palette.
+        If classes is updated by customer, it will return the subset of
+        palette.
+
+        Returns:
+            Sequence: Palette for current dataset.
+        """
+        palette = self._metainfo.get('palette', [])
+        classes = self._metainfo.get('classes', [])
+        # palette does match classes
+        if len(palette) == len(classes):
+            return palette
+
+        if len(palette) == 0:
+            # Get random state before set seed, and restore
+            # random state later.
+            # It will prevent loss of randomness, as the palette
+            # may be different in each iteration if not specified.
+            # See: https://github.com/open-mmlab/mmdetection/issues/5844
+            state = np.random.get_state()
+            np.random.seed(42)
+            # random palette
+            new_palette = np.random.randint(
+                0, 255, size=(len(classes), 3)).tolist()
+            np.random.set_state(state)
+        elif len(palette) >= len(classes) and self.label_map is not None:
+            new_palette = []
+            # return subset of palette
+            for old_id, new_id in sorted(
+                    self.label_map.items(), key=lambda x: x[1]):
+                # 0 is background
+                if new_id != 0:
+                    new_palette.append(palette[old_id])
+            new_palette = type(palette)(new_palette)
+        elif len(palette) >= len(classes):
+            # Allow palette length is greater than classes.
+            return palette
+        else:
+            raise ValueError('palette does not match classes '
+                             f'as metainfo is {self._metainfo}.')
+        return new_palette
+
+    def load_data_list(self) -> List[dict]:
+        """Load annotation from directory or annotation file.
+
+        Returns:
+            list[dict]: All data info of dataset.
+        """
+        data_list = []
+        img_dir = self.data_prefix.get('img_path', None)
+        ann_dir = self.data_prefix.get('seg_map_path', None)
+        if not osp.isdir(self.ann_file) and self.ann_file:
+            assert osp.isfile(self.ann_file), \
+                f'Failed to load `ann_file` {self.ann_file}'
+            lines = mmengine.list_from_file(
+                self.ann_file, backend_args=self.backend_args)
+            for line in lines:
+                img_name = line.strip()
+                data_info = dict(
+                    img_path=osp.join(img_dir, img_name + self.img_suffix))
+                if ann_dir is not None:
+                    seg_map = img_name + self.seg_map_suffix
+                    data_info['seg_map_path'] = osp.join(ann_dir, seg_map)
+                data_info['label_map'] = self.label_map
+                data_list.append(data_info)
+        else:
+            for img in fileio.list_dir_or_file(
+                    dir_path=img_dir,
+                    list_dir=False,
+                    suffix=self.img_suffix,
+                    recursive=True,
+                    backend_args=self.backend_args):
+                data_info = dict(img_path=osp.join(img_dir, img))
+                if ann_dir is not None:
+                    seg_map = img.replace(self.img_suffix, self.seg_map_suffix)
+                    data_info['seg_map_path'] = osp.join(ann_dir, seg_map)
+                data_info['label_map'] = self.label_map
+                data_list.append(data_info)
+            data_list = sorted(data_list, key=lambda x: x['img_path'])
+        return data_list
diff --git a/mmdetection/mmdet/datasets/base_video_dataset.py b/mmdetection/mmdet/datasets/base_video_dataset.py
new file mode 100644
index 00000000..0a4a7a25
--- /dev/null
+++ b/mmdetection/mmdet/datasets/base_video_dataset.py
@@ -0,0 +1,304 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import os.path as osp
+from collections import defaultdict
+from typing import Any, List, Tuple
+
+import mmengine.fileio as fileio
+from mmengine.dataset import BaseDataset
+from mmengine.logging import print_log
+
+from mmdet.datasets.api_wrappers import COCO
+from mmdet.registry import DATASETS
+
+
+@DATASETS.register_module()
+class BaseVideoDataset(BaseDataset):
+    """Base video dataset for VID, MOT and VIS tasks."""
+
+    META = dict(classes=None)
+    # ann_id is unique in coco dataset.
+    ANN_ID_UNIQUE = True
+
+    def __init__(self, *args, backend_args: dict = None, **kwargs):
+        self.backend_args = backend_args
+        super().__init__(*args, **kwargs)
+
+    def load_data_list(self) -> Tuple[List[dict], List]:
+        """Load annotations from an annotation file named as ``self.ann_file``.
+
+        Returns:
+            tuple(list[dict], list): A list of annotation and a list of
+            valid data indices.
+        """
+        with fileio.get_local_path(self.ann_file) as local_path:
+            self.coco = COCO(local_path)
+        # The order of returned `cat_ids` will not
+        # change with the order of the classes
+        self.cat_ids = self.coco.get_cat_ids(
+            cat_names=self.metainfo['classes'])
+        self.cat2label = {cat_id: i for i, cat_id in enumerate(self.cat_ids)}
+        self.cat_img_map = copy.deepcopy(self.coco.cat_img_map)
+        # used in `filter_data`
+        self.img_ids_with_ann = set()
+
+        img_ids = self.coco.get_img_ids()
+        total_ann_ids = []
+        # if ``video_id`` is not in the annotation file, we will assign a big
+        # unique video_id for this video.
+        single_video_id = 100000
+        videos = {}
+        for img_id in img_ids:
+            raw_img_info = self.coco.load_imgs([img_id])[0]
+            raw_img_info['img_id'] = img_id
+            if 'video_id' not in raw_img_info:
+                single_video_id = single_video_id + 1
+                video_id = single_video_id
+            else:
+                video_id = raw_img_info['video_id']
+
+            if video_id not in videos:
+                videos[video_id] = {
+                    'video_id': video_id,
+                    'images': [],
+                    'video_length': 0
+                }
+
+            videos[video_id]['video_length'] += 1
+            ann_ids = self.coco.get_ann_ids(
+                img_ids=[img_id], cat_ids=self.cat_ids)
+            raw_ann_info = self.coco.load_anns(ann_ids)
+            total_ann_ids.extend(ann_ids)
+
+            parsed_data_info = self.parse_data_info(
+                dict(raw_img_info=raw_img_info, raw_ann_info=raw_ann_info))
+
+            if len(parsed_data_info['instances']) > 0:
+                self.img_ids_with_ann.add(parsed_data_info['img_id'])
+
+            videos[video_id]['images'].append(parsed_data_info)
+
+        data_list = [v for v in videos.values()]
+
+        if self.ANN_ID_UNIQUE:
+            assert len(set(total_ann_ids)) == len(
+                total_ann_ids
+            ), f"Annotation ids in '{self.ann_file}' are not unique!"
+
+        del self.coco
+
+        return data_list
+
+    def parse_data_info(self, raw_data_info: dict) -> dict:
+        """Parse raw annotation to target format.
+
+        Args:
+            raw_data_info (dict): Raw data information loaded from
+                ``ann_file``.
+
+        Returns:
+            dict: Parsed annotation.
+        """
+        img_info = raw_data_info['raw_img_info']
+        ann_info = raw_data_info['raw_ann_info']
+        data_info = {}
+
+        data_info.update(img_info)
+        if self.data_prefix.get('img_path', None) is not None:
+            img_path = osp.join(self.data_prefix['img_path'],
+                                img_info['file_name'])
+        else:
+            img_path = img_info['file_name']
+        data_info['img_path'] = img_path
+
+        instances = []
+        for i, ann in enumerate(ann_info):
+            instance = {}
+
+            if ann.get('ignore', False):
+                continue
+            x1, y1, w, h = ann['bbox']
+            inter_w = max(0, min(x1 + w, img_info['width']) - max(x1, 0))
+            inter_h = max(0, min(y1 + h, img_info['height']) - max(y1, 0))
+            if inter_w * inter_h == 0:
+                continue
+            if ann['area'] <= 0 or w < 1 or h < 1:
+                continue
+            if ann['category_id'] not in self.cat_ids:
+                continue
+            bbox = [x1, y1, x1 + w, y1 + h]
+
+            if ann.get('iscrowd', False):
+                instance['ignore_flag'] = 1
+            else:
+                instance['ignore_flag'] = 0
+            instance['bbox'] = bbox
+            instance['bbox_label'] = self.cat2label[ann['category_id']]
+            if ann.get('segmentation', None):
+                instance['mask'] = ann['segmentation']
+            if ann.get('instance_id', None):
+                instance['instance_id'] = ann['instance_id']
+            else:
+                # image dataset usually has no `instance_id`.
+                # Therefore, we set it to `i`.
+                instance['instance_id'] = i
+            instances.append(instance)
+        data_info['instances'] = instances
+        return data_info
+
+    def filter_data(self) -> List[int]:
+        """Filter image annotations according to filter_cfg.
+
+        Returns:
+            list[int]: Filtered results.
+        """
+        if self.test_mode:
+            return self.data_list
+
+        num_imgs_before_filter = sum(
+            [len(info['images']) for info in self.data_list])
+        num_imgs_after_filter = 0
+
+        # obtain images that contain annotations of the required categories
+        ids_in_cat = set()
+        for i, class_id in enumerate(self.cat_ids):
+            ids_in_cat |= set(self.cat_img_map[class_id])
+        # merge the image id sets of the two conditions and use the merged set
+        # to filter out images if self.filter_empty_gt=True
+        ids_in_cat &= self.img_ids_with_ann
+
+        new_data_list = []
+        for video_data_info in self.data_list:
+            imgs_data_info = video_data_info['images']
+            valid_imgs_data_info = []
+
+            for data_info in imgs_data_info:
+                img_id = data_info['img_id']
+                width = data_info['width']
+                height = data_info['height']
+                # TODO: simplify these conditions
+                if self.filter_cfg is None:
+                    if img_id not in ids_in_cat:
+                        video_data_info['video_length'] -= 1
+                        continue
+                    if min(width, height) >= 32:
+                        valid_imgs_data_info.append(data_info)
+                        num_imgs_after_filter += 1
+                    else:
+                        video_data_info['video_length'] -= 1
+                else:
+                    if self.filter_cfg.get('filter_empty_gt',
+                                           True) and img_id not in ids_in_cat:
+                        video_data_info['video_length'] -= 1
+                        continue
+                    if min(width, height) >= self.filter_cfg.get(
+                            'min_size', 32):
+                        valid_imgs_data_info.append(data_info)
+                        num_imgs_after_filter += 1
+                    else:
+                        video_data_info['video_length'] -= 1
+                video_data_info['images'] = valid_imgs_data_info
+            new_data_list.append(video_data_info)
+
+        print_log(
+            'The number of samples before and after filtering: '
+            f'{num_imgs_before_filter} / {num_imgs_after_filter}', 'current')
+        return new_data_list
+
+    def prepare_data(self, idx) -> Any:
+        """Get date processed by ``self.pipeline``. Note that ``idx`` is a
+        video index in default since the base element of video dataset is a
+        video. However, in some cases, we need to specific both the video index
+        and frame index. For example, in traing mode, we may want to sample the
+        specific frames and all the frames must be sampled once in a epoch; in
+        test mode, we may want to output data of a single image rather than the
+        whole video for saving memory.
+
+        Args:
+            idx (int): The index of ``data_info``.
+
+        Returns:
+            Any: Depends on ``self.pipeline``.
+        """
+        if isinstance(idx, tuple):
+            assert len(idx) == 2, 'The length of idx must be 2: '
+            '(video_index, frame_index)'
+            video_idx, frame_idx = idx[0], idx[1]
+        else:
+            video_idx, frame_idx = idx, None
+
+        data_info = self.get_data_info(video_idx)
+        if self.test_mode:
+            # Support two test_mode: frame-level and video-level
+            final_data_info = defaultdict(list)
+            if frame_idx is None:
+                frames_idx_list = list(range(data_info['video_length']))
+            else:
+                frames_idx_list = [frame_idx]
+            for index in frames_idx_list:
+                frame_ann = data_info['images'][index]
+                frame_ann['video_id'] = data_info['video_id']
+                # Collate data_list (list of dict to dict of list)
+                for key, value in frame_ann.items():
+                    final_data_info[key].append(value)
+                # copy the info in video-level into img-level
+                # TODO: the value of this key is the same as that of
+                # `video_length` in test mode
+                final_data_info['ori_video_length'].append(
+                    data_info['video_length'])
+
+            final_data_info['video_length'] = [len(frames_idx_list)
+                                               ] * len(frames_idx_list)
+            return self.pipeline(final_data_info)
+        else:
+            # Specify `key_frame_id` for the frame sampling in the pipeline
+            if frame_idx is not None:
+                data_info['key_frame_id'] = frame_idx
+            return self.pipeline(data_info)
+
+    def get_cat_ids(self, index) -> List[int]:
+        """Following image detection, we provide this interface function. Get
+        category ids by video index and frame index.
+
+        Args:
+            index: The index of the dataset. It support two kinds of inputs:
+                Tuple:
+                    video_idx (int): Index of video.
+                    frame_idx (int): Index of frame.
+                Int: Index of video.
+
+        Returns:
+            List[int]: All categories in the image of specified video index
+            and frame index.
+        """
+        if isinstance(index, tuple):
+            assert len(
+                index
+            ) == 2, f'Expect the length of index is 2, but got {len(index)}'
+            video_idx, frame_idx = index
+            instances = self.get_data_info(
+                video_idx)['images'][frame_idx]['instances']
+            return [instance['bbox_label'] for instance in instances]
+        else:
+            cat_ids = []
+            for img in self.get_data_info(index)['images']:
+                for instance in img['instances']:
+                    cat_ids.append(instance['bbox_label'])
+            return cat_ids
+
+    @property
+    def num_all_imgs(self):
+        """Get the number of all the images in this video dataset."""
+        return sum(
+            [len(self.get_data_info(i)['images']) for i in range(len(self))])
+
+    def get_len_per_video(self, idx):
+        """Get length of one video.
+
+        Args:
+            idx (int): Index of video.
+
+        Returns:
+            int (int): The length of the video.
+        """
+        return len(self.get_data_info(idx)['images'])
diff --git a/mmdetection/mmdet/datasets/cityscapes.py b/mmdetection/mmdet/datasets/cityscapes.py
new file mode 100644
index 00000000..09755eb1
--- /dev/null
+++ b/mmdetection/mmdet/datasets/cityscapes.py
@@ -0,0 +1,61 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# Modified from https://github.com/facebookresearch/detectron2/blob/master/detectron2/data/datasets/cityscapes.py # noqa
+# and https://github.com/mcordts/cityscapesScripts/blob/master/cityscapesscripts/evaluation/evalInstanceLevelSemanticLabeling.py # noqa
+
+from typing import List
+
+from mmdet.registry import DATASETS
+from .coco import CocoDataset
+
+
+@DATASETS.register_module()
+class CityscapesDataset(CocoDataset):
+    """Dataset for Cityscapes."""
+
+    METAINFO = {
+        'classes': ('person', 'rider', 'car', 'truck', 'bus', 'train',
+                    'motorcycle', 'bicycle'),
+        'palette': [(220, 20, 60), (255, 0, 0), (0, 0, 142), (0, 0, 70),
+                    (0, 60, 100), (0, 80, 100), (0, 0, 230), (119, 11, 32)]
+    }
+
+    def filter_data(self) -> List[dict]:
+        """Filter annotations according to filter_cfg.
+
+        Returns:
+            List[dict]: Filtered results.
+        """
+        if self.test_mode:
+            return self.data_list
+
+        if self.filter_cfg is None:
+            return self.data_list
+
+        filter_empty_gt = self.filter_cfg.get('filter_empty_gt', False)
+        min_size = self.filter_cfg.get('min_size', 0)
+
+        # obtain images that contain annotation
+        ids_with_ann = set(data_info['img_id'] for data_info in self.data_list)
+        # obtain images that contain annotations of the required categories
+        ids_in_cat = set()
+        for i, class_id in enumerate(self.cat_ids):
+            ids_in_cat |= set(self.cat_img_map[class_id])
+        # merge the image id sets of the two conditions and use the merged set
+        # to filter out images if self.filter_empty_gt=True
+        ids_in_cat &= ids_with_ann
+
+        valid_data_infos = []
+        for i, data_info in enumerate(self.data_list):
+            img_id = data_info['img_id']
+            width = data_info['width']
+            height = data_info['height']
+            all_is_crowd = all([
+                instance['ignore_flag'] == 1
+                for instance in data_info['instances']
+            ])
+            if filter_empty_gt and (img_id not in ids_in_cat or all_is_crowd):
+                continue
+            if min(width, height) >= min_size:
+                valid_data_infos.append(data_info)
+
+        return valid_data_infos
diff --git a/mmdetection/mmdet/datasets/coco.py b/mmdetection/mmdet/datasets/coco.py
new file mode 100644
index 00000000..1cf21c4e
--- /dev/null
+++ b/mmdetection/mmdet/datasets/coco.py
@@ -0,0 +1,201 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import os.path as osp
+from typing import List, Union
+
+from mmengine.fileio import get_local_path
+
+from mmdet.registry import DATASETS
+from .api_wrappers import COCO
+from .base_det_dataset import BaseDetDataset
+
+
+@DATASETS.register_module()
+class CocoDataset(BaseDetDataset):
+    """Dataset for COCO."""
+
+    METAINFO = {
+        'classes':
+        ('person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train',
+         'truck', 'boat', 'traffic light', 'fire hydrant', 'stop sign',
+         'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep',
+         'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella',
+         'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard',
+         'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard',
+         'surfboard', 'tennis racket', 'bottle', 'wine glass', 'cup', 'fork',
+         'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich', 'orange',
+         'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair',
+         'couch', 'potted plant', 'bed', 'dining table', 'toilet', 'tv',
+         'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',
+         'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',
+         'scissors', 'teddy bear', 'hair drier', 'toothbrush'),
+        # palette is a list of color tuples, which is used for visualization.
+        'palette':
+        [(220, 20, 60), (119, 11, 32), (0, 0, 142), (0, 0, 230), (106, 0, 228),
+         (0, 60, 100), (0, 80, 100), (0, 0, 70), (0, 0, 192), (250, 170, 30),
+         (100, 170, 30), (220, 220, 0), (175, 116, 175), (250, 0, 30),
+         (165, 42, 42), (255, 77, 255), (0, 226, 252), (182, 182, 255),
+         (0, 82, 0), (120, 166, 157), (110, 76, 0), (174, 57, 255),
+         (199, 100, 0), (72, 0, 118), (255, 179, 240), (0, 125, 92),
+         (209, 0, 151), (188, 208, 182), (0, 220, 176), (255, 99, 164),
+         (92, 0, 73), (133, 129, 255), (78, 180, 255), (0, 228, 0),
+         (174, 255, 243), (45, 89, 255), (134, 134, 103), (145, 148, 174),
+         (255, 208, 186), (197, 226, 255), (171, 134, 1), (109, 63, 54),
+         (207, 138, 255), (151, 0, 95), (9, 80, 61), (84, 105, 51),
+         (74, 65, 105), (166, 196, 102), (208, 195, 210), (255, 109, 65),
+         (0, 143, 149), (179, 0, 194), (209, 99, 106), (5, 121, 0),
+         (227, 255, 205), (147, 186, 208), (153, 69, 1), (3, 95, 161),
+         (163, 255, 0), (119, 0, 170), (0, 182, 199), (0, 165, 120),
+         (183, 130, 88), (95, 32, 0), (130, 114, 135), (110, 129, 133),
+         (166, 74, 118), (219, 142, 185), (79, 210, 114), (178, 90, 62),
+         (65, 70, 15), (127, 167, 115), (59, 105, 106), (142, 108, 45),
+         (196, 172, 0), (95, 54, 80), (128, 76, 255), (201, 57, 1),
+         (246, 0, 122), (191, 162, 208)]
+    }
+    COCOAPI = COCO
+    # ann_id is unique in coco dataset.
+    ANN_ID_UNIQUE = True
+
+    def load_data_list(self) -> List[dict]:
+        """Load annotations from an annotation file named as ``self.ann_file``
+
+        Returns:
+            List[dict]: A list of annotation.
+        """  # noqa: E501
+        with get_local_path(
+                self.ann_file, backend_args=self.backend_args) as local_path:
+            self.coco = self.COCOAPI(local_path)
+        # The order of returned `cat_ids` will not
+        # change with the order of the `classes`
+        self.cat_ids = self.coco.get_cat_ids(
+            cat_names=self.metainfo['classes'])
+        self.cat2label = {cat_id: i for i, cat_id in enumerate(self.cat_ids)}
+        self.cat_img_map = copy.deepcopy(self.coco.cat_img_map)
+
+        img_ids = self.coco.get_img_ids()
+        data_list = []
+        total_ann_ids = []
+        for img_id in img_ids:
+            raw_img_info = self.coco.load_imgs([img_id])[0]
+            raw_img_info['img_id'] = img_id
+
+            ann_ids = self.coco.get_ann_ids(img_ids=[img_id])
+            raw_ann_info = self.coco.load_anns(ann_ids)
+            total_ann_ids.extend(ann_ids)
+
+            parsed_data_info = self.parse_data_info({
+                'raw_ann_info':
+                raw_ann_info,
+                'raw_img_info':
+                raw_img_info
+            })
+            data_list.append(parsed_data_info)
+        if self.ANN_ID_UNIQUE:
+            assert len(set(total_ann_ids)) == len(
+                total_ann_ids
+            ), f"Annotation ids in '{self.ann_file}' are not unique!"
+
+        del self.coco
+
+        return data_list
+
+    def parse_data_info(self, raw_data_info: dict) -> Union[dict, List[dict]]:
+        """Parse raw annotation to target format.
+
+        Args:
+            raw_data_info (dict): Raw data information load from ``ann_file``
+
+        Returns:
+            Union[dict, List[dict]]: Parsed annotation.
+        """
+        img_info = raw_data_info['raw_img_info']
+        ann_info = raw_data_info['raw_ann_info']
+
+        data_info = {}
+
+        # TODO: need to change data_prefix['img'] to data_prefix['img_path']
+        img_path = osp.join(self.data_prefix['img'], img_info['file_name'])
+        if self.data_prefix.get('seg', None):
+            seg_map_path = osp.join(
+                self.data_prefix['seg'],
+                img_info['file_name'].rsplit('.', 1)[0] + self.seg_map_suffix)
+        else:
+            seg_map_path = None
+        data_info['img_path'] = img_path
+        data_info['img_id'] = img_info['img_id']
+        data_info['seg_map_path'] = seg_map_path
+        data_info['height'] = img_info['height']
+        data_info['width'] = img_info['width']
+
+        if self.return_classes:
+            data_info['text'] = self.metainfo['classes']
+            data_info['caption_prompt'] = self.caption_prompt
+            data_info['custom_entities'] = True
+
+        instances = []
+        for i, ann in enumerate(ann_info):
+            instance = {}
+
+            if ann.get('ignore', False):
+                continue
+            x1, y1, w, h = ann['bbox']
+            inter_w = max(0, min(x1 + w, img_info['width']) - max(x1, 0))
+            inter_h = max(0, min(y1 + h, img_info['height']) - max(y1, 0))
+            if inter_w * inter_h == 0:
+                continue
+            if ann['area'] <= 0 or w < 1 or h < 1:
+                continue
+            if ann['category_id'] not in self.cat_ids:
+                continue
+            bbox = [x1, y1, x1 + w, y1 + h]
+
+            if ann.get('iscrowd', False):
+                instance['ignore_flag'] = 1
+            else:
+                instance['ignore_flag'] = 0
+            instance['bbox'] = bbox
+            instance['bbox_label'] = self.cat2label[ann['category_id']]
+
+            if ann.get('segmentation', None):
+                instance['mask'] = ann['segmentation']
+
+            instances.append(instance)
+        data_info['instances'] = instances
+        return data_info
+
+    def filter_data(self) -> List[dict]:
+        """Filter annotations according to filter_cfg.
+
+        Returns:
+            List[dict]: Filtered results.
+        """
+        if self.test_mode:
+            return self.data_list
+
+        if self.filter_cfg is None:
+            return self.data_list
+
+        filter_empty_gt = self.filter_cfg.get('filter_empty_gt', False)
+        min_size = self.filter_cfg.get('min_size', 0)
+
+        # obtain images that contain annotation
+        ids_with_ann = set(data_info['img_id'] for data_info in self.data_list)
+        # obtain images that contain annotations of the required categories
+        ids_in_cat = set()
+        for i, class_id in enumerate(self.cat_ids):
+            ids_in_cat |= set(self.cat_img_map[class_id])
+        # merge the image id sets of the two conditions and use the merged set
+        # to filter out images if self.filter_empty_gt=True
+        ids_in_cat &= ids_with_ann
+
+        valid_data_infos = []
+        for i, data_info in enumerate(self.data_list):
+            img_id = data_info['img_id']
+            width = data_info['width']
+            height = data_info['height']
+            if filter_empty_gt and img_id not in ids_in_cat:
+                continue
+            if min(width, height) >= min_size:
+                valid_data_infos.append(data_info)
+
+        return valid_data_infos
diff --git a/mmdetection/mmdet/datasets/coco_caption.py b/mmdetection/mmdet/datasets/coco_caption.py
new file mode 100644
index 00000000..ee695fe9
--- /dev/null
+++ b/mmdetection/mmdet/datasets/coco_caption.py
@@ -0,0 +1,32 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from pathlib import Path
+from typing import List
+
+import mmengine
+from mmengine.dataset import BaseDataset
+from mmengine.fileio import get_file_backend
+
+from mmdet.registry import DATASETS
+
+
+@DATASETS.register_module()
+class CocoCaptionDataset(BaseDataset):
+    """COCO2014 Caption dataset."""
+
+    def load_data_list(self) -> List[dict]:
+        """Load data list."""
+        img_prefix = self.data_prefix['img_path']
+        annotations = mmengine.load(self.ann_file)
+        file_backend = get_file_backend(img_prefix)
+
+        data_list = []
+        for ann in annotations:
+            data_info = {
+                'img_id': Path(ann['image']).stem.split('_')[-1],
+                'img_path': file_backend.join_path(img_prefix, ann['image']),
+                'gt_caption': ann['caption'],
+            }
+
+            data_list.append(data_info)
+
+        return data_list
diff --git a/mmdetection/mmdet/datasets/coco_panoptic.py b/mmdetection/mmdet/datasets/coco_panoptic.py
new file mode 100644
index 00000000..b7a200e0
--- /dev/null
+++ b/mmdetection/mmdet/datasets/coco_panoptic.py
@@ -0,0 +1,292 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+from typing import Callable, List, Optional, Sequence, Union
+
+from mmdet.registry import DATASETS
+from .api_wrappers import COCOPanoptic
+from .coco import CocoDataset
+
+
+@DATASETS.register_module()
+class CocoPanopticDataset(CocoDataset):
+    """Coco dataset for Panoptic segmentation.
+
+    The annotation format is shown as follows. The `ann` field is optional
+    for testing.
+
+    .. code-block:: none
+
+        [
+            {
+                'filename': f'{image_id:012}.png',
+                'image_id':9
+                'segments_info':
+                [
+                    {
+                        'id': 8345037, (segment_id in panoptic png,
+                                        convert from rgb)
+                        'category_id': 51,
+                        'iscrowd': 0,
+                        'bbox': (x1, y1, w, h),
+                        'area': 24315
+                    },
+                    ...
+                ]
+            },
+            ...
+        ]
+
+    Args:
+        ann_file (str): Annotation file path. Defaults to ''.
+        metainfo (dict, optional): Meta information for dataset, such as class
+            information. Defaults to None.
+        data_root (str, optional): The root directory for ``data_prefix`` and
+            ``ann_file``. Defaults to None.
+        data_prefix (dict, optional): Prefix for training data. Defaults to
+            ``dict(img=None, ann=None, seg=None)``. The prefix ``seg`` which is
+            for panoptic segmentation map must be not None.
+        filter_cfg (dict, optional): Config for filter data. Defaults to None.
+        indices (int or Sequence[int], optional): Support using first few
+            data in annotation file to facilitate training/testing on a smaller
+            dataset. Defaults to None which means using all ``data_infos``.
+        serialize_data (bool, optional): Whether to hold memory using
+            serialized objects, when enabled, data loader workers can use
+            shared RAM from master process instead of making a copy. Defaults
+            to True.
+        pipeline (list, optional): Processing pipeline. Defaults to [].
+        test_mode (bool, optional): ``test_mode=True`` means in test phase.
+            Defaults to False.
+        lazy_init (bool, optional): Whether to load annotation during
+            instantiation. In some cases, such as visualization, only the meta
+            information of the dataset is needed, which is not necessary to
+            load annotation file. ``Basedataset`` can skip load annotations to
+            save time by set ``lazy_init=False``. Defaults to False.
+        max_refetch (int, optional): If ``Basedataset.prepare_data`` get a
+            None img. The maximum extra number of cycles to get a valid
+            image. Defaults to 1000.
+    """
+
+    METAINFO = {
+        'classes':
+        ('person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train',
+         'truck', 'boat', 'traffic light', 'fire hydrant', 'stop sign',
+         'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep',
+         'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella',
+         'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard',
+         'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard',
+         'surfboard', 'tennis racket', 'bottle', 'wine glass', 'cup', 'fork',
+         'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich', 'orange',
+         'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair',
+         'couch', 'potted plant', 'bed', 'dining table', 'toilet', 'tv',
+         'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',
+         'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',
+         'scissors', 'teddy bear', 'hair drier', 'toothbrush', 'banner',
+         'blanket', 'bridge', 'cardboard', 'counter', 'curtain', 'door-stuff',
+         'floor-wood', 'flower', 'fruit', 'gravel', 'house', 'light',
+         'mirror-stuff', 'net', 'pillow', 'platform', 'playingfield',
+         'railroad', 'river', 'road', 'roof', 'sand', 'sea', 'shelf', 'snow',
+         'stairs', 'tent', 'towel', 'wall-brick', 'wall-stone', 'wall-tile',
+         'wall-wood', 'water-other', 'window-blind', 'window-other',
+         'tree-merged', 'fence-merged', 'ceiling-merged', 'sky-other-merged',
+         'cabinet-merged', 'table-merged', 'floor-other-merged',
+         'pavement-merged', 'mountain-merged', 'grass-merged', 'dirt-merged',
+         'paper-merged', 'food-other-merged', 'building-other-merged',
+         'rock-merged', 'wall-other-merged', 'rug-merged'),
+        'thing_classes':
+        ('person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train',
+         'truck', 'boat', 'traffic light', 'fire hydrant', 'stop sign',
+         'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep',
+         'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella',
+         'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard',
+         'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard',
+         'surfboard', 'tennis racket', 'bottle', 'wine glass', 'cup', 'fork',
+         'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich', 'orange',
+         'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair',
+         'couch', 'potted plant', 'bed', 'dining table', 'toilet', 'tv',
+         'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',
+         'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',
+         'scissors', 'teddy bear', 'hair drier', 'toothbrush'),
+        'stuff_classes':
+        ('banner', 'blanket', 'bridge', 'cardboard', 'counter', 'curtain',
+         'door-stuff', 'floor-wood', 'flower', 'fruit', 'gravel', 'house',
+         'light', 'mirror-stuff', 'net', 'pillow', 'platform', 'playingfield',
+         'railroad', 'river', 'road', 'roof', 'sand', 'sea', 'shelf', 'snow',
+         'stairs', 'tent', 'towel', 'wall-brick', 'wall-stone', 'wall-tile',
+         'wall-wood', 'water-other', 'window-blind', 'window-other',
+         'tree-merged', 'fence-merged', 'ceiling-merged', 'sky-other-merged',
+         'cabinet-merged', 'table-merged', 'floor-other-merged',
+         'pavement-merged', 'mountain-merged', 'grass-merged', 'dirt-merged',
+         'paper-merged', 'food-other-merged', 'building-other-merged',
+         'rock-merged', 'wall-other-merged', 'rug-merged'),
+        'palette':
+        [(220, 20, 60), (119, 11, 32), (0, 0, 142), (0, 0, 230), (106, 0, 228),
+         (0, 60, 100), (0, 80, 100), (0, 0, 70), (0, 0, 192), (250, 170, 30),
+         (100, 170, 30), (220, 220, 0), (175, 116, 175), (250, 0, 30),
+         (165, 42, 42), (255, 77, 255), (0, 226, 252), (182, 182, 255),
+         (0, 82, 0), (120, 166, 157), (110, 76, 0), (174, 57, 255),
+         (199, 100, 0), (72, 0, 118), (255, 179, 240), (0, 125, 92),
+         (209, 0, 151), (188, 208, 182), (0, 220, 176), (255, 99, 164),
+         (92, 0, 73), (133, 129, 255), (78, 180, 255), (0, 228, 0),
+         (174, 255, 243), (45, 89, 255), (134, 134, 103), (145, 148, 174),
+         (255, 208, 186), (197, 226, 255), (171, 134, 1), (109, 63, 54),
+         (207, 138, 255), (151, 0, 95), (9, 80, 61), (84, 105, 51),
+         (74, 65, 105), (166, 196, 102), (208, 195, 210), (255, 109, 65),
+         (0, 143, 149), (179, 0, 194), (209, 99, 106), (5, 121, 0),
+         (227, 255, 205), (147, 186, 208), (153, 69, 1), (3, 95, 161),
+         (163, 255, 0), (119, 0, 170), (0, 182, 199), (0, 165, 120),
+         (183, 130, 88), (95, 32, 0), (130, 114, 135), (110, 129, 133),
+         (166, 74, 118), (219, 142, 185), (79, 210, 114), (178, 90, 62),
+         (65, 70, 15), (127, 167, 115), (59, 105, 106), (142, 108, 45),
+         (196, 172, 0), (95, 54, 80), (128, 76, 255), (201, 57, 1),
+         (246, 0, 122), (191, 162, 208), (255, 255, 128), (147, 211, 203),
+         (150, 100, 100), (168, 171, 172), (146, 112, 198), (210, 170, 100),
+         (92, 136, 89), (218, 88, 184), (241, 129, 0), (217, 17, 255),
+         (124, 74, 181), (70, 70, 70), (255, 228, 255), (154, 208, 0),
+         (193, 0, 92), (76, 91, 113), (255, 180, 195), (106, 154, 176),
+         (230, 150, 140), (60, 143, 255), (128, 64, 128), (92, 82, 55),
+         (254, 212, 124), (73, 77, 174), (255, 160, 98), (255, 255, 255),
+         (104, 84, 109), (169, 164, 131), (225, 199, 255), (137, 54, 74),
+         (135, 158, 223), (7, 246, 231), (107, 255, 200), (58, 41, 149),
+         (183, 121, 142), (255, 73, 97), (107, 142, 35), (190, 153, 153),
+         (146, 139, 141), (70, 130, 180), (134, 199, 156), (209, 226, 140),
+         (96, 36, 108), (96, 96, 96), (64, 170, 64), (152, 251, 152),
+         (208, 229, 228), (206, 186, 171), (152, 161, 64), (116, 112, 0),
+         (0, 114, 143), (102, 102, 156), (250, 141, 255)]
+    }
+    COCOAPI = COCOPanoptic
+    # ann_id is not unique in coco panoptic dataset.
+    ANN_ID_UNIQUE = False
+
+    def __init__(self,
+                 ann_file: str = '',
+                 metainfo: Optional[dict] = None,
+                 data_root: Optional[str] = None,
+                 data_prefix: dict = dict(img=None, ann=None, seg=None),
+                 filter_cfg: Optional[dict] = None,
+                 indices: Optional[Union[int, Sequence[int]]] = None,
+                 serialize_data: bool = True,
+                 pipeline: List[Union[dict, Callable]] = [],
+                 test_mode: bool = False,
+                 lazy_init: bool = False,
+                 max_refetch: int = 1000,
+                 backend_args: dict = None,
+                 **kwargs) -> None:
+        super().__init__(
+            ann_file=ann_file,
+            metainfo=metainfo,
+            data_root=data_root,
+            data_prefix=data_prefix,
+            filter_cfg=filter_cfg,
+            indices=indices,
+            serialize_data=serialize_data,
+            pipeline=pipeline,
+            test_mode=test_mode,
+            lazy_init=lazy_init,
+            max_refetch=max_refetch,
+            backend_args=backend_args,
+            **kwargs)
+
+    def parse_data_info(self, raw_data_info: dict) -> dict:
+        """Parse raw annotation to target format.
+
+        Args:
+            raw_data_info (dict): Raw data information load from ``ann_file``.
+
+        Returns:
+            dict: Parsed annotation.
+        """
+        img_info = raw_data_info['raw_img_info']
+        ann_info = raw_data_info['raw_ann_info']
+        # filter out unmatched annotations which have
+        # same segment_id but belong to other image
+        ann_info = [
+            ann for ann in ann_info if ann['image_id'] == img_info['img_id']
+        ]
+        data_info = {}
+
+        img_path = osp.join(self.data_prefix['img'], img_info['file_name'])
+        if self.data_prefix.get('seg', None):
+            seg_map_path = osp.join(
+                self.data_prefix['seg'],
+                img_info['file_name'].replace('.jpg', '.png'))
+        else:
+            seg_map_path = None
+        data_info['img_path'] = img_path
+        data_info['img_id'] = img_info['img_id']
+        data_info['seg_map_path'] = seg_map_path
+        data_info['height'] = img_info['height']
+        data_info['width'] = img_info['width']
+
+        if self.return_classes:
+            data_info['text'] = self.metainfo['thing_classes']
+            data_info['stuff_text'] = self.metainfo['stuff_classes']
+            data_info['custom_entities'] = True  # no important
+
+        instances = []
+        segments_info = []
+        for ann in ann_info:
+            instance = {}
+            x1, y1, w, h = ann['bbox']
+            if ann['area'] <= 0 or w < 1 or h < 1:
+                continue
+            bbox = [x1, y1, x1 + w, y1 + h]
+            category_id = ann['category_id']
+            contiguous_cat_id = self.cat2label[category_id]
+
+            is_thing = self.coco.load_cats(ids=category_id)[0]['isthing']
+            if is_thing:
+                is_crowd = ann.get('iscrowd', False)
+                instance['bbox'] = bbox
+                instance['bbox_label'] = contiguous_cat_id
+                if not is_crowd:
+                    instance['ignore_flag'] = 0
+                else:
+                    instance['ignore_flag'] = 1
+                    is_thing = False
+
+            segment_info = {
+                'id': ann['id'],
+                'category': contiguous_cat_id,
+                'is_thing': is_thing
+            }
+            segments_info.append(segment_info)
+            if len(instance) > 0 and is_thing:
+                instances.append(instance)
+        data_info['instances'] = instances
+        data_info['segments_info'] = segments_info
+        return data_info
+
+    def filter_data(self) -> List[dict]:
+        """Filter images too small or without ground truth.
+
+        Returns:
+            List[dict]: ``self.data_list`` after filtering.
+        """
+        if self.test_mode:
+            return self.data_list
+
+        if self.filter_cfg is None:
+            return self.data_list
+
+        filter_empty_gt = self.filter_cfg.get('filter_empty_gt', False)
+        min_size = self.filter_cfg.get('min_size', 0)
+
+        ids_with_ann = set()
+        # check whether images have legal thing annotations.
+        for data_info in self.data_list:
+            for segment_info in data_info['segments_info']:
+                if not segment_info['is_thing']:
+                    continue
+                ids_with_ann.add(data_info['img_id'])
+
+        valid_data_list = []
+        for data_info in self.data_list:
+            img_id = data_info['img_id']
+            width = data_info['width']
+            height = data_info['height']
+            if filter_empty_gt and img_id not in ids_with_ann:
+                continue
+            if min(width, height) >= min_size:
+                valid_data_list.append(data_info)
+
+        return valid_data_list
diff --git a/mmdetection/mmdet/datasets/coco_semantic.py b/mmdetection/mmdet/datasets/coco_semantic.py
new file mode 100644
index 00000000..75256845
--- /dev/null
+++ b/mmdetection/mmdet/datasets/coco_semantic.py
@@ -0,0 +1,90 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import DATASETS
+from .ade20k import ADE20KSegDataset
+
+
+@DATASETS.register_module()
+class CocoSegDataset(ADE20KSegDataset):
+    """COCO dataset.
+
+    In segmentation map annotation for COCO. The ``img_suffix`` is fixed to
+    '.jpg',  and ``seg_map_suffix`` is fixed to '.png'.
+    """
+
+    METAINFO = dict(
+        classes=(
+            'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',
+            'train', 'truck', 'boat', 'traffic light', 'fire hydrant',
+            'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog',
+            'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe',
+            'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee',
+            'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat',
+            'baseball glove', 'skateboard', 'surfboard', 'tennis racket',
+            'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl',
+            'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot',
+            'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch',
+            'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop',
+            'mouse', 'remote', 'keyboard', 'cell phone', 'microwave', 'oven',
+            'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',
+            'scissors', 'teddy bear', 'hair drier', 'toothbrush', 'banner',
+            'blanket', 'branch', 'bridge', 'building-other', 'bush', 'cabinet',
+            'cage', 'cardboard', 'carpet', 'ceiling-other', 'ceiling-tile',
+            'cloth', 'clothes', 'clouds', 'counter', 'cupboard', 'curtain',
+            'desk-stuff', 'dirt', 'door-stuff', 'fence', 'floor-marble',
+            'floor-other', 'floor-stone', 'floor-tile', 'floor-wood', 'flower',
+            'fog', 'food-other', 'fruit', 'furniture-other', 'grass', 'gravel',
+            'ground-other', 'hill', 'house', 'leaves', 'light', 'mat', 'metal',
+            'mirror-stuff', 'moss', 'mountain', 'mud', 'napkin', 'net',
+            'paper', 'pavement', 'pillow', 'plant-other', 'plastic',
+            'platform', 'playingfield', 'railing', 'railroad', 'river', 'road',
+            'rock', 'roof', 'rug', 'salad', 'sand', 'sea', 'shelf',
+            'sky-other', 'skyscraper', 'snow', 'solid-other', 'stairs',
+            'stone', 'straw', 'structural-other', 'table', 'tent',
+            'textile-other', 'towel', 'tree', 'vegetable', 'wall-brick',
+            'wall-concrete', 'wall-other', 'wall-panel', 'wall-stone',
+            'wall-tile', 'wall-wood', 'water-other', 'waterdrops',
+            'window-blind', 'window-other', 'wood'),
+        palette=[(120, 120, 120), (180, 120, 120), (6, 230, 230), (80, 50, 50),
+                 (4, 200, 3), (120, 120, 80), (140, 140, 140), (204, 5, 255),
+                 (230, 230, 230), (4, 250, 7), (224, 5, 255), (235, 255, 7),
+                 (150, 5, 61), (120, 120, 70), (8, 255, 51), (255, 6, 82),
+                 (143, 255, 140), (204, 255, 4), (255, 51, 7), (204, 70, 3),
+                 (0, 102, 200), (61, 230, 250), (255, 6, 51), (11, 102, 255),
+                 (255, 7, 71), (255, 9, 224), (9, 7, 230), (220, 220, 220),
+                 (255, 9, 92), (112, 9, 255), (8, 255, 214), (7, 255, 224),
+                 (255, 184, 6), (10, 255, 71), (255, 41, 10), (7, 255, 255),
+                 (224, 255, 8), (102, 8, 255), (255, 61, 6), (255, 194, 7),
+                 (255, 122, 8), (0, 255, 20), (255, 8, 41), (255, 5, 153),
+                 (6, 51, 255), (235, 12, 255), (160, 150, 20), (0, 163, 255),
+                 (140, 140, 140), (250, 10, 15), (20, 255, 0), (31, 255, 0),
+                 (255, 31, 0), (255, 224, 0), (153, 255, 0), (0, 0, 255),
+                 (255, 71, 0), (0, 235, 255), (0, 173, 255), (31, 0, 255),
+                 (11, 200, 200), (255, 82, 0), (0, 255, 245), (0, 61, 255),
+                 (0, 255, 112), (0, 255, 133), (255, 0, 0), (255, 163, 0),
+                 (255, 102, 0), (194, 255, 0), (0, 143, 255), (51, 255, 0),
+                 (0, 82, 255), (0, 255, 41), (0, 255, 173), (10, 0, 255),
+                 (173, 255, 0), (0, 255, 153), (255, 92, 0), (255, 0, 255),
+                 (255, 0, 245), (255, 0, 102), (255, 173, 0), (255, 0, 20),
+                 (255, 184, 184), (0, 31, 255), (0, 255, 61), (0, 71, 255),
+                 (255, 0, 204), (0, 255, 194), (0, 255, 82), (0, 10, 255),
+                 (0, 112, 255), (51, 0, 255), (0, 194, 255), (0, 122, 255),
+                 (0, 255, 163), (255, 153, 0), (0, 255, 10), (255, 112, 0),
+                 (143, 255, 0), (82, 0, 255), (163, 255, 0), (255, 235, 0),
+                 (8, 184, 170), (133, 0, 255), (0, 255, 92), (184, 0, 255),
+                 (255, 0, 31), (0, 184, 255), (0, 214, 255), (255, 0, 112),
+                 (92, 255, 0), (0, 224, 255), (112, 224, 255), (70, 184, 160),
+                 (163, 0, 255), (153, 0, 255), (71, 255, 0), (255, 0, 163),
+                 (255, 204, 0), (255, 0, 143), (0, 255, 235), (133, 255, 0),
+                 (255, 0, 235), (245, 0, 255), (255, 0, 122), (255, 245, 0),
+                 (10, 190, 212), (214, 255, 0), (0, 204, 255), (20, 0, 255),
+                 (255, 255, 0), (0, 153, 255), (0, 41, 255), (0, 255, 204),
+                 (41, 0, 255), (41, 255, 0), (173, 0, 255), (0, 245, 255),
+                 (71, 0, 255), (122, 0, 255), (0, 255, 184), (0, 92, 255),
+                 (184, 255, 0), (0, 133, 255), (255, 214, 0), (25, 194, 194),
+                 (102, 255, 0), (92, 0, 255), (107, 255, 200), (58, 41, 149),
+                 (183, 121, 142), (255, 73, 97), (107, 142, 35),
+                 (190, 153, 153), (146, 139, 141), (70, 130, 180),
+                 (134, 199, 156), (209, 226, 140), (96, 36, 108), (96, 96, 96),
+                 (64, 170, 64), (152, 251, 152), (208, 229, 228),
+                 (206, 186, 171), (152, 161, 64), (116, 112, 0), (0, 114, 143),
+                 (102, 102, 156), (250, 141, 255)])
diff --git a/mmdetection/mmdet/datasets/crowdhuman.py b/mmdetection/mmdet/datasets/crowdhuman.py
new file mode 100644
index 00000000..650176ee
--- /dev/null
+++ b/mmdetection/mmdet/datasets/crowdhuman.py
@@ -0,0 +1,159 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import json
+import logging
+import os.path as osp
+import warnings
+from typing import List, Union
+
+import mmcv
+from mmengine.dist import get_rank
+from mmengine.fileio import dump, get, get_text, load
+from mmengine.logging import print_log
+from mmengine.utils import ProgressBar
+
+from mmdet.registry import DATASETS
+from .base_det_dataset import BaseDetDataset
+
+
+@DATASETS.register_module()
+class CrowdHumanDataset(BaseDetDataset):
+    r"""Dataset for CrowdHuman.
+
+    Args:
+        data_root (str): The root directory for
+            ``data_prefix`` and ``ann_file``.
+        ann_file (str): Annotation file path.
+        extra_ann_file (str | optional):The path of extra image metas
+            for CrowdHuman. It can be created by CrowdHumanDataset
+            automatically or by tools/misc/get_crowdhuman_id_hw.py
+            manually. Defaults to None.
+    """
+
+    METAINFO = {
+        'classes': ('person', ),
+        # palette is a list of color tuples, which is used for visualization.
+        'palette': [(220, 20, 60)]
+    }
+
+    def __init__(self, data_root, ann_file, extra_ann_file=None, **kwargs):
+        # extra_ann_file record the size of each image. This file is
+        # automatically created when you first load the CrowdHuman
+        # dataset by mmdet.
+        if extra_ann_file is not None:
+            self.extra_ann_exist = True
+            self.extra_anns = load(extra_ann_file)
+        else:
+            ann_file_name = osp.basename(ann_file)
+            if 'train' in ann_file_name:
+                self.extra_ann_file = osp.join(data_root, 'id_hw_train.json')
+            elif 'val' in ann_file_name:
+                self.extra_ann_file = osp.join(data_root, 'id_hw_val.json')
+            self.extra_ann_exist = False
+            if not osp.isfile(self.extra_ann_file):
+                print_log(
+                    'extra_ann_file does not exist, prepare to collect '
+                    'image height and width...',
+                    level=logging.INFO)
+                self.extra_anns = {}
+            else:
+                self.extra_ann_exist = True
+                self.extra_anns = load(self.extra_ann_file)
+        super().__init__(data_root=data_root, ann_file=ann_file, **kwargs)
+
+    def load_data_list(self) -> List[dict]:
+        """Load annotations from an annotation file named as ``self.ann_file``
+
+        Returns:
+            List[dict]: A list of annotation.
+        """  # noqa: E501
+        anno_strs = get_text(
+            self.ann_file, backend_args=self.backend_args).strip().split('\n')
+        print_log('loading CrowdHuman annotation...', level=logging.INFO)
+        data_list = []
+        prog_bar = ProgressBar(len(anno_strs))
+        for i, anno_str in enumerate(anno_strs):
+            anno_dict = json.loads(anno_str)
+            parsed_data_info = self.parse_data_info(anno_dict)
+            data_list.append(parsed_data_info)
+            prog_bar.update()
+        if not self.extra_ann_exist and get_rank() == 0:
+            #  TODO: support file client
+            try:
+                dump(self.extra_anns, self.extra_ann_file, file_format='json')
+            except:  # noqa
+                warnings.warn(
+                    'Cache files can not be saved automatically! To speed up'
+                    'loading the dataset, please manually generate the cache'
+                    ' file by file tools/misc/get_crowdhuman_id_hw.py')
+
+            print_log(
+                f'\nsave extra_ann_file in {self.data_root}',
+                level=logging.INFO)
+
+        del self.extra_anns
+        print_log('\nDone', level=logging.INFO)
+        return data_list
+
+    def parse_data_info(self, raw_data_info: dict) -> Union[dict, List[dict]]:
+        """Parse raw annotation to target format.
+
+        Args:
+            raw_data_info (dict): Raw data information load from ``ann_file``
+
+        Returns:
+            Union[dict, List[dict]]: Parsed annotation.
+        """
+        data_info = {}
+        img_path = osp.join(self.data_prefix['img'],
+                            f"{raw_data_info['ID']}.jpg")
+        data_info['img_path'] = img_path
+        data_info['img_id'] = raw_data_info['ID']
+
+        if not self.extra_ann_exist:
+            img_bytes = get(img_path, backend_args=self.backend_args)
+            img = mmcv.imfrombytes(img_bytes, backend='cv2')
+            data_info['height'], data_info['width'] = img.shape[:2]
+            self.extra_anns[raw_data_info['ID']] = img.shape[:2]
+            del img, img_bytes
+        else:
+            data_info['height'], data_info['width'] = self.extra_anns[
+                raw_data_info['ID']]
+
+        instances = []
+        for i, ann in enumerate(raw_data_info['gtboxes']):
+            instance = {}
+            if ann['tag'] not in self.metainfo['classes']:
+                instance['bbox_label'] = -1
+                instance['ignore_flag'] = 1
+            else:
+                instance['bbox_label'] = self.metainfo['classes'].index(
+                    ann['tag'])
+                instance['ignore_flag'] = 0
+            if 'extra' in ann:
+                if 'ignore' in ann['extra']:
+                    if ann['extra']['ignore'] != 0:
+                        instance['bbox_label'] = -1
+                        instance['ignore_flag'] = 1
+
+            x1, y1, w, h = ann['fbox']
+            bbox = [x1, y1, x1 + w, y1 + h]
+            instance['bbox'] = bbox
+
+            # Record the full bbox(fbox), head bbox(hbox) and visible
+            # bbox(vbox) as additional information. If you need to use
+            # this information, you just need to design the pipeline
+            # instead of overriding the CrowdHumanDataset.
+            instance['fbox'] = bbox
+            hbox = ann['hbox']
+            instance['hbox'] = [
+                hbox[0], hbox[1], hbox[0] + hbox[2], hbox[1] + hbox[3]
+            ]
+            vbox = ann['vbox']
+            instance['vbox'] = [
+                vbox[0], vbox[1], vbox[0] + vbox[2], vbox[1] + vbox[3]
+            ]
+
+            instances.append(instance)
+
+        data_info['instances'] = instances
+        return data_info
diff --git a/mmdetection/mmdet/datasets/dataset_wrappers.py b/mmdetection/mmdet/datasets/dataset_wrappers.py
new file mode 100644
index 00000000..d4e26e07
--- /dev/null
+++ b/mmdetection/mmdet/datasets/dataset_wrappers.py
@@ -0,0 +1,260 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import collections
+import copy
+from typing import List, Sequence, Union
+
+from mmengine.dataset import BaseDataset
+from mmengine.dataset import ConcatDataset as MMENGINE_ConcatDataset
+from mmengine.dataset import force_full_init
+
+from mmdet.registry import DATASETS, TRANSFORMS
+
+
+@DATASETS.register_module()
+class MultiImageMixDataset:
+    """A wrapper of multiple images mixed dataset.
+
+    Suitable for training on multiple images mixed data augmentation like
+    mosaic and mixup. For the augmentation pipeline of mixed image data,
+    the `get_indexes` method needs to be provided to obtain the image
+    indexes, and you can set `skip_flags` to change the pipeline running
+    process. At the same time, we provide the `dynamic_scale` parameter
+    to dynamically change the output image size.
+
+    Args:
+        dataset (:obj:`CustomDataset`): The dataset to be mixed.
+        pipeline (Sequence[dict]): Sequence of transform object or
+            config dict to be composed.
+        dynamic_scale (tuple[int], optional): The image scale can be changed
+            dynamically. Default to None. It is deprecated.
+        skip_type_keys (list[str], optional): Sequence of type string to
+            be skip pipeline. Default to None.
+        max_refetch (int): The maximum number of retry iterations for getting
+            valid results from the pipeline. If the number of iterations is
+            greater than `max_refetch`, but results is still None, then the
+            iteration is terminated and raise the error. Default: 15.
+    """
+
+    def __init__(self,
+                 dataset: Union[BaseDataset, dict],
+                 pipeline: Sequence[str],
+                 skip_type_keys: Union[Sequence[str], None] = None,
+                 max_refetch: int = 15,
+                 lazy_init: bool = False) -> None:
+        assert isinstance(pipeline, collections.abc.Sequence)
+        if skip_type_keys is not None:
+            assert all([
+                isinstance(skip_type_key, str)
+                for skip_type_key in skip_type_keys
+            ])
+        self._skip_type_keys = skip_type_keys
+
+        self.pipeline = []
+        self.pipeline_types = []
+        for transform in pipeline:
+            if isinstance(transform, dict):
+                self.pipeline_types.append(transform['type'])
+                transform = TRANSFORMS.build(transform)
+                self.pipeline.append(transform)
+            else:
+                raise TypeError('pipeline must be a dict')
+
+        self.dataset: BaseDataset
+        if isinstance(dataset, dict):
+            self.dataset = DATASETS.build(dataset)
+        elif isinstance(dataset, BaseDataset):
+            self.dataset = dataset
+        else:
+            raise TypeError(
+                'elements in datasets sequence should be config or '
+                f'`BaseDataset` instance, but got {type(dataset)}')
+
+        self._metainfo = self.dataset.metainfo
+        if hasattr(self.dataset, 'flag'):
+            self.flag = self.dataset.flag
+        self.num_samples = len(self.dataset)
+        self.max_refetch = max_refetch
+
+        self._fully_initialized = False
+        if not lazy_init:
+            self.full_init()
+
+    @property
+    def metainfo(self) -> dict:
+        """Get the meta information of the multi-image-mixed dataset.
+
+        Returns:
+            dict: The meta information of multi-image-mixed dataset.
+        """
+        return copy.deepcopy(self._metainfo)
+
+    def full_init(self):
+        """Loop to ``full_init`` each dataset."""
+        if self._fully_initialized:
+            return
+
+        self.dataset.full_init()
+        self._ori_len = len(self.dataset)
+        self._fully_initialized = True
+
+    @force_full_init
+    def get_data_info(self, idx: int) -> dict:
+        """Get annotation by index.
+
+        Args:
+            idx (int): Global index of ``ConcatDataset``.
+
+        Returns:
+            dict: The idx-th annotation of the datasets.
+        """
+        return self.dataset.get_data_info(idx)
+
+    @force_full_init
+    def __len__(self):
+        return self.num_samples
+
+    def __getitem__(self, idx):
+        results = copy.deepcopy(self.dataset[idx])
+        for (transform, transform_type) in zip(self.pipeline,
+                                               self.pipeline_types):
+            if self._skip_type_keys is not None and \
+                    transform_type in self._skip_type_keys:
+                continue
+
+            if hasattr(transform, 'get_indexes'):
+                for i in range(self.max_refetch):
+                    # Make sure the results passed the loading pipeline
+                    # of the original dataset is not None.
+                    indexes = transform.get_indexes(self.dataset)
+                    if not isinstance(indexes, collections.abc.Sequence):
+                        indexes = [indexes]
+                    mix_results = [
+                        copy.deepcopy(self.dataset[index]) for index in indexes
+                    ]
+                    if None not in mix_results:
+                        results['mix_results'] = mix_results
+                        break
+                else:
+                    raise RuntimeError(
+                        'The loading pipeline of the original dataset'
+                        ' always return None. Please check the correctness '
+                        'of the dataset and its pipeline.')
+
+            for i in range(self.max_refetch):
+                # To confirm the results passed the training pipeline
+                # of the wrapper is not None.
+                updated_results = transform(copy.deepcopy(results))
+                if updated_results is not None:
+                    results = updated_results
+                    break
+            else:
+                raise RuntimeError(
+                    'The training pipeline of the dataset wrapper'
+                    ' always return None.Please check the correctness '
+                    'of the dataset and its pipeline.')
+
+            if 'mix_results' in results:
+                results.pop('mix_results')
+
+        return results
+
+    def update_skip_type_keys(self, skip_type_keys):
+        """Update skip_type_keys. It is called by an external hook.
+
+        Args:
+            skip_type_keys (list[str], optional): Sequence of type
+                string to be skip pipeline.
+        """
+        assert all([
+            isinstance(skip_type_key, str) for skip_type_key in skip_type_keys
+        ])
+        self._skip_type_keys = skip_type_keys
+
+
+@DATASETS.register_module()
+class ConcatDataset(MMENGINE_ConcatDataset):
+    """A wrapper of concatenated dataset.
+
+    Same as ``torch.utils.data.dataset.ConcatDataset``, support
+    lazy_init and get_dataset_source.
+
+    Note:
+        ``ConcatDataset`` should not inherit from ``BaseDataset`` since
+        ``get_subset`` and ``get_subset_`` could produce ambiguous meaning
+        sub-dataset which conflicts with original dataset. If you want to use
+        a sub-dataset of ``ConcatDataset``, you should set ``indices``
+        arguments for wrapped dataset which inherit from ``BaseDataset``.
+
+    Args:
+        datasets (Sequence[BaseDataset] or Sequence[dict]): A list of datasets
+            which will be concatenated.
+        lazy_init (bool, optional): Whether to load annotation during
+            instantiation. Defaults to False.
+        ignore_keys (List[str] or str): Ignore the keys that can be
+            unequal in `dataset.metainfo`. Defaults to None.
+            `New in version 0.3.0.`
+    """
+
+    def __init__(self,
+                 datasets: Sequence[Union[BaseDataset, dict]],
+                 lazy_init: bool = False,
+                 ignore_keys: Union[str, List[str], None] = None):
+        self.datasets: List[BaseDataset] = []
+        for i, dataset in enumerate(datasets):
+            if isinstance(dataset, dict):
+                self.datasets.append(DATASETS.build(dataset))
+            elif isinstance(dataset, BaseDataset):
+                self.datasets.append(dataset)
+            else:
+                raise TypeError(
+                    'elements in datasets sequence should be config or '
+                    f'`BaseDataset` instance, but got {type(dataset)}')
+        if ignore_keys is None:
+            self.ignore_keys = []
+        elif isinstance(ignore_keys, str):
+            self.ignore_keys = [ignore_keys]
+        elif isinstance(ignore_keys, list):
+            self.ignore_keys = ignore_keys
+        else:
+            raise TypeError('ignore_keys should be a list or str, '
+                            f'but got {type(ignore_keys)}')
+
+        meta_keys: set = set()
+        for dataset in self.datasets:
+            meta_keys |= dataset.metainfo.keys()
+        # if the metainfo of multiple datasets are the same, use metainfo
+        # of the first dataset, else the metainfo is a list with metainfo
+        # of all the datasets
+        is_all_same = True
+        self._metainfo_first = self.datasets[0].metainfo
+        for i, dataset in enumerate(self.datasets, 1):
+            for key in meta_keys:
+                if key in self.ignore_keys:
+                    continue
+                if key not in dataset.metainfo:
+                    is_all_same = False
+                    break
+                if self._metainfo_first[key] != dataset.metainfo[key]:
+                    is_all_same = False
+                    break
+
+        if is_all_same:
+            self._metainfo = self.datasets[0].metainfo
+        else:
+            self._metainfo = [dataset.metainfo for dataset in self.datasets]
+
+        self._fully_initialized = False
+        if not lazy_init:
+            self.full_init()
+
+            if is_all_same:
+                self._metainfo.update(
+                    dict(cumulative_sizes=self.cumulative_sizes))
+            else:
+                for i, dataset in enumerate(self.datasets):
+                    self._metainfo[i].update(
+                        dict(cumulative_sizes=self.cumulative_sizes))
+
+    def get_dataset_source(self, idx: int) -> int:
+        dataset_idx, _ = self._get_ori_dataset_idx(idx)
+        return dataset_idx
diff --git a/mmdetection/mmdet/datasets/deepfashion.py b/mmdetection/mmdet/datasets/deepfashion.py
new file mode 100644
index 00000000..f853fc63
--- /dev/null
+++ b/mmdetection/mmdet/datasets/deepfashion.py
@@ -0,0 +1,19 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import DATASETS
+from .coco import CocoDataset
+
+
+@DATASETS.register_module()
+class DeepFashionDataset(CocoDataset):
+    """Dataset for DeepFashion."""
+
+    METAINFO = {
+        'classes': ('top', 'skirt', 'leggings', 'dress', 'outer', 'pants',
+                    'bag', 'neckwear', 'headwear', 'eyeglass', 'belt',
+                    'footwear', 'hair', 'skin', 'face'),
+        # palette is a list of color tuples, which is used for visualization.
+        'palette': [(0, 192, 64), (0, 64, 96), (128, 192, 192), (0, 64, 64),
+                    (0, 192, 224), (0, 192, 192), (128, 192, 64), (0, 192, 96),
+                    (128, 32, 192), (0, 0, 224), (0, 0, 64), (0, 160, 192),
+                    (128, 0, 96), (128, 0, 192), (0, 32, 192)]
+    }
diff --git a/mmdetection/mmdet/datasets/dod.py b/mmdetection/mmdet/datasets/dod.py
new file mode 100644
index 00000000..152d32aa
--- /dev/null
+++ b/mmdetection/mmdet/datasets/dod.py
@@ -0,0 +1,78 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+from typing import List, Optional
+
+import numpy as np
+
+from mmdet.registry import DATASETS
+from .base_det_dataset import BaseDetDataset
+
+try:
+    from d_cube import D3
+except ImportError:
+    D3 = None
+from .api_wrappers import COCO
+
+
+@DATASETS.register_module()
+class DODDataset(BaseDetDataset):
+
+    def __init__(self,
+                 *args,
+                 data_root: Optional[str] = '',
+                 data_prefix: dict = dict(img_path=''),
+                 **kwargs) -> None:
+        if D3 is None:
+            raise ImportError(
+                'Please install d3 by `pip install ddd-dataset`.')
+        pkl_anno_path = osp.join(data_root, data_prefix['anno'])
+        self.img_root = osp.join(data_root, data_prefix['img'])
+        self.d3 = D3(self.img_root, pkl_anno_path)
+
+        sent_infos = self.d3.load_sents()
+        classes = tuple([sent_info['raw_sent'] for sent_info in sent_infos])
+        super().__init__(
+            *args,
+            data_root=data_root,
+            data_prefix=data_prefix,
+            metainfo={'classes': classes},
+            **kwargs)
+
+    def load_data_list(self) -> List[dict]:
+        coco = COCO(self.ann_file)
+        data_list = []
+        img_ids = self.d3.get_img_ids()
+        for img_id in img_ids:
+            data_info = {}
+
+            img_info = self.d3.load_imgs(img_id)[0]
+            file_name = img_info['file_name']
+            img_path = osp.join(self.img_root, file_name)
+            data_info['img_path'] = img_path
+            data_info['img_id'] = img_id
+            data_info['height'] = img_info['height']
+            data_info['width'] = img_info['width']
+
+            group_ids = self.d3.get_group_ids(img_ids=[img_id])
+            sent_ids = self.d3.get_sent_ids(group_ids=group_ids)
+            sent_list = self.d3.load_sents(sent_ids=sent_ids)
+            text_list = [sent['raw_sent'] for sent in sent_list]
+            ann_ids = coco.get_ann_ids(img_ids=[img_id])
+            anno = coco.load_anns(ann_ids)
+
+            data_info['text'] = text_list
+            data_info['sent_ids'] = np.array([s for s in sent_ids])
+            data_info['custom_entities'] = True
+
+            instances = []
+            for i, ann in enumerate(anno):
+                instance = {}
+                x1, y1, w, h = ann['bbox']
+                bbox = [x1, y1, x1 + w, y1 + h]
+                instance['ignore_flag'] = 0
+                instance['bbox'] = bbox
+                instance['bbox_label'] = ann['category_id'] - 1
+                instances.append(instance)
+            data_info['instances'] = instances
+            data_list.append(data_info)
+        return data_list
diff --git a/mmdetection/mmdet/datasets/dsdl.py b/mmdetection/mmdet/datasets/dsdl.py
new file mode 100644
index 00000000..75570a2a
--- /dev/null
+++ b/mmdetection/mmdet/datasets/dsdl.py
@@ -0,0 +1,192 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os
+from typing import List
+
+from mmdet.registry import DATASETS
+from .base_det_dataset import BaseDetDataset
+
+try:
+    from dsdl.dataset import DSDLDataset
+except ImportError:
+    DSDLDataset = None
+
+
+@DATASETS.register_module()
+class DSDLDetDataset(BaseDetDataset):
+    """Dataset for dsdl detection.
+
+    Args:
+        with_bbox(bool): Load bbox or not, defaults to be True.
+        with_polygon(bool): Load polygon or not, defaults to be False.
+        with_mask(bool): Load seg map mask or not, defaults to be False.
+        with_imagelevel_label(bool): Load image level label or not,
+            defaults to be False.
+        with_hierarchy(bool): Load hierarchy information or not,
+            defaults to be False.
+        specific_key_path(dict): Path of specific key which can not
+            be loaded by it's field name.
+        pre_transform(dict): pre-transform functions before loading.
+    """
+
+    METAINFO = {}
+
+    def __init__(self,
+                 with_bbox: bool = True,
+                 with_polygon: bool = False,
+                 with_mask: bool = False,
+                 with_imagelevel_label: bool = False,
+                 with_hierarchy: bool = False,
+                 specific_key_path: dict = {},
+                 pre_transform: dict = {},
+                 **kwargs) -> None:
+
+        if DSDLDataset is None:
+            raise RuntimeError(
+                'Package dsdl is not installed. Please run "pip install dsdl".'
+            )
+
+        self.with_hierarchy = with_hierarchy
+        self.specific_key_path = specific_key_path
+
+        loc_config = dict(type='LocalFileReader', working_dir='')
+        if kwargs.get('data_root'):
+            kwargs['ann_file'] = os.path.join(kwargs['data_root'],
+                                              kwargs['ann_file'])
+        self.required_fields = ['Image', 'ImageShape', 'Label', 'ignore_flag']
+        if with_bbox:
+            self.required_fields.append('Bbox')
+        if with_polygon:
+            self.required_fields.append('Polygon')
+        if with_mask:
+            self.required_fields.append('LabelMap')
+        if with_imagelevel_label:
+            self.required_fields.append('image_level_labels')
+            assert 'image_level_labels' in specific_key_path.keys(
+            ), '`image_level_labels` not specified in `specific_key_path` !'
+
+        self.extra_keys = [
+            key for key in self.specific_key_path.keys()
+            if key not in self.required_fields
+        ]
+
+        self.dsdldataset = DSDLDataset(
+            dsdl_yaml=kwargs['ann_file'],
+            location_config=loc_config,
+            required_fields=self.required_fields,
+            specific_key_path=specific_key_path,
+            transform=pre_transform,
+        )
+
+        BaseDetDataset.__init__(self, **kwargs)
+
+    def load_data_list(self) -> List[dict]:
+        """Load data info from an dsdl yaml file named as ``self.ann_file``
+
+        Returns:
+            List[dict]: A list of data info.
+        """
+        if self.with_hierarchy:
+            # get classes_names and relation_matrix
+            classes_names, relation_matrix = \
+                self.dsdldataset.class_dom.get_hierarchy_info()
+            self._metainfo['classes'] = tuple(classes_names)
+            self._metainfo['RELATION_MATRIX'] = relation_matrix
+
+        else:
+            self._metainfo['classes'] = tuple(self.dsdldataset.class_names)
+
+        data_list = []
+
+        for i, data in enumerate(self.dsdldataset):
+            # basic image info, including image id, path and size.
+            datainfo = dict(
+                img_id=i,
+                img_path=os.path.join(self.data_prefix['img_path'],
+                                      data['Image'][0].location),
+                width=data['ImageShape'][0].width,
+                height=data['ImageShape'][0].height,
+            )
+
+            # get image label info
+            if 'image_level_labels' in data.keys():
+                if self.with_hierarchy:
+                    # get leaf node name when using hierarchy classes
+                    datainfo['image_level_labels'] = [
+                        self._metainfo['classes'].index(i.leaf_node_name)
+                        for i in data['image_level_labels']
+                    ]
+                else:
+                    datainfo['image_level_labels'] = [
+                        self._metainfo['classes'].index(i.name)
+                        for i in data['image_level_labels']
+                    ]
+
+            # get semantic segmentation info
+            if 'LabelMap' in data.keys():
+                datainfo['seg_map_path'] = data['LabelMap']
+
+            # load instance info
+            instances = []
+            if 'Bbox' in data.keys():
+                for idx in range(len(data['Bbox'])):
+                    bbox = data['Bbox'][idx]
+                    if self.with_hierarchy:
+                        # get leaf node name when using hierarchy classes
+                        label = data['Label'][idx].leaf_node_name
+                        label_index = self._metainfo['classes'].index(label)
+                    else:
+                        label = data['Label'][idx].name
+                        label_index = self._metainfo['classes'].index(label)
+
+                    instance = {}
+                    instance['bbox'] = bbox.xyxy
+                    instance['bbox_label'] = label_index
+
+                    if 'ignore_flag' in data.keys():
+                        # get ignore flag
+                        instance['ignore_flag'] = data['ignore_flag'][idx]
+                    else:
+                        instance['ignore_flag'] = 0
+
+                    if 'Polygon' in data.keys():
+                        # get polygon info
+                        polygon = data['Polygon'][idx]
+                        instance['mask'] = polygon.openmmlabformat
+
+                    for key in self.extra_keys:
+                        # load extra instance info
+                        instance[key] = data[key][idx]
+
+                    instances.append(instance)
+
+            datainfo['instances'] = instances
+            # append a standard sample in data list
+            if len(datainfo['instances']) > 0:
+                data_list.append(datainfo)
+
+        return data_list
+
+    def filter_data(self) -> List[dict]:
+        """Filter annotations according to filter_cfg.
+
+        Returns:
+            List[dict]: Filtered results.
+        """
+        if self.test_mode:
+            return self.data_list
+
+        filter_empty_gt = self.filter_cfg.get('filter_empty_gt', False) \
+            if self.filter_cfg is not None else False
+        min_size = self.filter_cfg.get('min_size', 0) \
+            if self.filter_cfg is not None else 0
+
+        valid_data_list = []
+        for i, data_info in enumerate(self.data_list):
+            width = data_info['width']
+            height = data_info['height']
+            if filter_empty_gt and len(data_info['instances']) == 0:
+                continue
+            if min(width, height) >= min_size:
+                valid_data_list.append(data_info)
+
+        return valid_data_list
diff --git a/mmdetection/mmdet/datasets/flickr30k.py b/mmdetection/mmdet/datasets/flickr30k.py
new file mode 100644
index 00000000..0c76a41b
--- /dev/null
+++ b/mmdetection/mmdet/datasets/flickr30k.py
@@ -0,0 +1,81 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+from typing import List
+
+from pycocotools.coco import COCO
+
+from mmdet.registry import DATASETS
+from .base_det_dataset import BaseDetDataset
+
+
+def convert_phrase_ids(phrase_ids: list) -> list:
+    unique_elements = sorted(set(phrase_ids))
+    element_to_new_label = {
+        element: label
+        for label, element in enumerate(unique_elements)
+    }
+    phrase_ids = [element_to_new_label[element] for element in phrase_ids]
+    return phrase_ids
+
+
+@DATASETS.register_module()
+class Flickr30kDataset(BaseDetDataset):
+    """Flickr30K Dataset."""
+
+    def load_data_list(self) -> List[dict]:
+
+        self.coco = COCO(self.ann_file)
+
+        self.ids = sorted(list(self.coco.imgs.keys()))
+
+        data_list = []
+        for img_id in self.ids:
+            if isinstance(img_id, str):
+                ann_ids = self.coco.getAnnIds(imgIds=[img_id], iscrowd=None)
+            else:
+                ann_ids = self.coco.getAnnIds(imgIds=img_id, iscrowd=None)
+
+            coco_img = self.coco.loadImgs(img_id)[0]
+
+            caption = coco_img['caption']
+            file_name = coco_img['file_name']
+            img_path = osp.join(self.data_prefix['img'], file_name)
+            width = coco_img['width']
+            height = coco_img['height']
+            tokens_positive = coco_img['tokens_positive_eval']
+            phrases = [caption[i[0][0]:i[0][1]] for i in tokens_positive]
+            phrase_ids = []
+
+            instances = []
+            annos = self.coco.loadAnns(ann_ids)
+            for anno in annos:
+                instance = {
+                    'bbox': [
+                        anno['bbox'][0], anno['bbox'][1],
+                        anno['bbox'][0] + anno['bbox'][2],
+                        anno['bbox'][1] + anno['bbox'][3]
+                    ],
+                    'bbox_label':
+                    anno['category_id'],
+                    'ignore_flag':
+                    anno['iscrowd']
+                }
+                phrase_ids.append(anno['phrase_ids'])
+                instances.append(instance)
+
+            phrase_ids = convert_phrase_ids(phrase_ids)
+
+            data_list.append(
+                dict(
+                    img_path=img_path,
+                    img_id=img_id,
+                    height=height,
+                    width=width,
+                    instances=instances,
+                    text=caption,
+                    phrase_ids=phrase_ids,
+                    tokens_positive=tokens_positive,
+                    phrases=phrases,
+                ))
+
+        return data_list
diff --git a/mmdetection/mmdet/datasets/isaid.py b/mmdetection/mmdet/datasets/isaid.py
new file mode 100644
index 00000000..87067d84
--- /dev/null
+++ b/mmdetection/mmdet/datasets/isaid.py
@@ -0,0 +1,25 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import DATASETS
+from .coco import CocoDataset
+
+
+@DATASETS.register_module()
+class iSAIDDataset(CocoDataset):
+    """Dataset for iSAID instance segmentation.
+
+    iSAID: A Large-scale Dataset for Instance Segmentation
+    in Aerial Images.
+
+    For more detail, please refer to "projects/iSAID/README.md"
+    """
+
+    METAINFO = dict(
+        classes=('background', 'ship', 'store_tank', 'baseball_diamond',
+                 'tennis_court', 'basketball_court', 'Ground_Track_Field',
+                 'Bridge', 'Large_Vehicle', 'Small_Vehicle', 'Helicopter',
+                 'Swimming_pool', 'Roundabout', 'Soccer_ball_field', 'plane',
+                 'Harbor'),
+        palette=[(0, 0, 0), (0, 0, 63), (0, 63, 63), (0, 63, 0), (0, 63, 127),
+                 (0, 63, 191), (0, 63, 255), (0, 127, 63), (0, 127, 127),
+                 (0, 0, 127), (0, 0, 191), (0, 0, 255), (0, 191, 127),
+                 (0, 127, 191), (0, 127, 255), (0, 100, 155)])
diff --git a/mmdetection/mmdet/datasets/lvis.py b/mmdetection/mmdet/datasets/lvis.py
new file mode 100644
index 00000000..b9629f5d
--- /dev/null
+++ b/mmdetection/mmdet/datasets/lvis.py
@@ -0,0 +1,638 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import warnings
+from typing import List
+
+from mmengine.fileio import get_local_path
+
+from mmdet.registry import DATASETS
+from .coco import CocoDataset
+
+
+@DATASETS.register_module()
+class LVISV05Dataset(CocoDataset):
+    """LVIS v0.5 dataset for detection."""
+
+    METAINFO = {
+        'classes':
+        ('acorn', 'aerosol_can', 'air_conditioner', 'airplane', 'alarm_clock',
+         'alcohol', 'alligator', 'almond', 'ambulance', 'amplifier', 'anklet',
+         'antenna', 'apple', 'apple_juice', 'applesauce', 'apricot', 'apron',
+         'aquarium', 'armband', 'armchair', 'armoire', 'armor', 'artichoke',
+         'trash_can', 'ashtray', 'asparagus', 'atomizer', 'avocado', 'award',
+         'awning', 'ax', 'baby_buggy', 'basketball_backboard', 'backpack',
+         'handbag', 'suitcase', 'bagel', 'bagpipe', 'baguet', 'bait', 'ball',
+         'ballet_skirt', 'balloon', 'bamboo', 'banana', 'Band_Aid', 'bandage',
+         'bandanna', 'banjo', 'banner', 'barbell', 'barge', 'barrel',
+         'barrette', 'barrow', 'baseball_base', 'baseball', 'baseball_bat',
+         'baseball_cap', 'baseball_glove', 'basket', 'basketball_hoop',
+         'basketball', 'bass_horn', 'bat_(animal)', 'bath_mat', 'bath_towel',
+         'bathrobe', 'bathtub', 'batter_(food)', 'battery', 'beachball',
+         'bead', 'beaker', 'bean_curd', 'beanbag', 'beanie', 'bear', 'bed',
+         'bedspread', 'cow', 'beef_(food)', 'beeper', 'beer_bottle',
+         'beer_can', 'beetle', 'bell', 'bell_pepper', 'belt', 'belt_buckle',
+         'bench', 'beret', 'bib', 'Bible', 'bicycle', 'visor', 'binder',
+         'binoculars', 'bird', 'birdfeeder', 'birdbath', 'birdcage',
+         'birdhouse', 'birthday_cake', 'birthday_card', 'biscuit_(bread)',
+         'pirate_flag', 'black_sheep', 'blackboard', 'blanket', 'blazer',
+         'blender', 'blimp', 'blinker', 'blueberry', 'boar', 'gameboard',
+         'boat', 'bobbin', 'bobby_pin', 'boiled_egg', 'bolo_tie', 'deadbolt',
+         'bolt', 'bonnet', 'book', 'book_bag', 'bookcase', 'booklet',
+         'bookmark', 'boom_microphone', 'boot', 'bottle', 'bottle_opener',
+         'bouquet', 'bow_(weapon)', 'bow_(decorative_ribbons)', 'bow-tie',
+         'bowl', 'pipe_bowl', 'bowler_hat', 'bowling_ball', 'bowling_pin',
+         'boxing_glove', 'suspenders', 'bracelet', 'brass_plaque', 'brassiere',
+         'bread-bin', 'breechcloth', 'bridal_gown', 'briefcase',
+         'bristle_brush', 'broccoli', 'broach', 'broom', 'brownie',
+         'brussels_sprouts', 'bubble_gum', 'bucket', 'horse_buggy', 'bull',
+         'bulldog', 'bulldozer', 'bullet_train', 'bulletin_board',
+         'bulletproof_vest', 'bullhorn', 'corned_beef', 'bun', 'bunk_bed',
+         'buoy', 'burrito', 'bus_(vehicle)', 'business_card', 'butcher_knife',
+         'butter', 'butterfly', 'button', 'cab_(taxi)', 'cabana', 'cabin_car',
+         'cabinet', 'locker', 'cake', 'calculator', 'calendar', 'calf',
+         'camcorder', 'camel', 'camera', 'camera_lens', 'camper_(vehicle)',
+         'can', 'can_opener', 'candelabrum', 'candle', 'candle_holder',
+         'candy_bar', 'candy_cane', 'walking_cane', 'canister', 'cannon',
+         'canoe', 'cantaloup', 'canteen', 'cap_(headwear)', 'bottle_cap',
+         'cape', 'cappuccino', 'car_(automobile)', 'railcar_(part_of_a_train)',
+         'elevator_car', 'car_battery', 'identity_card', 'card', 'cardigan',
+         'cargo_ship', 'carnation', 'horse_carriage', 'carrot', 'tote_bag',
+         'cart', 'carton', 'cash_register', 'casserole', 'cassette', 'cast',
+         'cat', 'cauliflower', 'caviar', 'cayenne_(spice)', 'CD_player',
+         'celery', 'cellular_telephone', 'chain_mail', 'chair',
+         'chaise_longue', 'champagne', 'chandelier', 'chap', 'checkbook',
+         'checkerboard', 'cherry', 'chessboard',
+         'chest_of_drawers_(furniture)', 'chicken_(animal)', 'chicken_wire',
+         'chickpea', 'Chihuahua', 'chili_(vegetable)', 'chime', 'chinaware',
+         'crisp_(potato_chip)', 'poker_chip', 'chocolate_bar',
+         'chocolate_cake', 'chocolate_milk', 'chocolate_mousse', 'choker',
+         'chopping_board', 'chopstick', 'Christmas_tree', 'slide', 'cider',
+         'cigar_box', 'cigarette', 'cigarette_case', 'cistern', 'clarinet',
+         'clasp', 'cleansing_agent', 'clementine', 'clip', 'clipboard',
+         'clock', 'clock_tower', 'clothes_hamper', 'clothespin', 'clutch_bag',
+         'coaster', 'coat', 'coat_hanger', 'coatrack', 'cock', 'coconut',
+         'coffee_filter', 'coffee_maker', 'coffee_table', 'coffeepot', 'coil',
+         'coin', 'colander', 'coleslaw', 'coloring_material',
+         'combination_lock', 'pacifier', 'comic_book', 'computer_keyboard',
+         'concrete_mixer', 'cone', 'control', 'convertible_(automobile)',
+         'sofa_bed', 'cookie', 'cookie_jar', 'cooking_utensil',
+         'cooler_(for_food)', 'cork_(bottle_plug)', 'corkboard', 'corkscrew',
+         'edible_corn', 'cornbread', 'cornet', 'cornice', 'cornmeal', 'corset',
+         'romaine_lettuce', 'costume', 'cougar', 'coverall', 'cowbell',
+         'cowboy_hat', 'crab_(animal)', 'cracker', 'crape', 'crate', 'crayon',
+         'cream_pitcher', 'credit_card', 'crescent_roll', 'crib', 'crock_pot',
+         'crossbar', 'crouton', 'crow', 'crown', 'crucifix', 'cruise_ship',
+         'police_cruiser', 'crumb', 'crutch', 'cub_(animal)', 'cube',
+         'cucumber', 'cufflink', 'cup', 'trophy_cup', 'cupcake', 'hair_curler',
+         'curling_iron', 'curtain', 'cushion', 'custard', 'cutting_tool',
+         'cylinder', 'cymbal', 'dachshund', 'dagger', 'dartboard',
+         'date_(fruit)', 'deck_chair', 'deer', 'dental_floss', 'desk',
+         'detergent', 'diaper', 'diary', 'die', 'dinghy', 'dining_table',
+         'tux', 'dish', 'dish_antenna', 'dishrag', 'dishtowel', 'dishwasher',
+         'dishwasher_detergent', 'diskette', 'dispenser', 'Dixie_cup', 'dog',
+         'dog_collar', 'doll', 'dollar', 'dolphin', 'domestic_ass', 'eye_mask',
+         'doorbell', 'doorknob', 'doormat', 'doughnut', 'dove', 'dragonfly',
+         'drawer', 'underdrawers', 'dress', 'dress_hat', 'dress_suit',
+         'dresser', 'drill', 'drinking_fountain', 'drone', 'dropper',
+         'drum_(musical_instrument)', 'drumstick', 'duck', 'duckling',
+         'duct_tape', 'duffel_bag', 'dumbbell', 'dumpster', 'dustpan',
+         'Dutch_oven', 'eagle', 'earphone', 'earplug', 'earring', 'easel',
+         'eclair', 'eel', 'egg', 'egg_roll', 'egg_yolk', 'eggbeater',
+         'eggplant', 'electric_chair', 'refrigerator', 'elephant', 'elk',
+         'envelope', 'eraser', 'escargot', 'eyepatch', 'falcon', 'fan',
+         'faucet', 'fedora', 'ferret', 'Ferris_wheel', 'ferry', 'fig_(fruit)',
+         'fighter_jet', 'figurine', 'file_cabinet', 'file_(tool)',
+         'fire_alarm', 'fire_engine', 'fire_extinguisher', 'fire_hose',
+         'fireplace', 'fireplug', 'fish', 'fish_(food)', 'fishbowl',
+         'fishing_boat', 'fishing_rod', 'flag', 'flagpole', 'flamingo',
+         'flannel', 'flash', 'flashlight', 'fleece', 'flip-flop_(sandal)',
+         'flipper_(footwear)', 'flower_arrangement', 'flute_glass', 'foal',
+         'folding_chair', 'food_processor', 'football_(American)',
+         'football_helmet', 'footstool', 'fork', 'forklift', 'freight_car',
+         'French_toast', 'freshener', 'frisbee', 'frog', 'fruit_juice',
+         'fruit_salad', 'frying_pan', 'fudge', 'funnel', 'futon', 'gag',
+         'garbage', 'garbage_truck', 'garden_hose', 'gargle', 'gargoyle',
+         'garlic', 'gasmask', 'gazelle', 'gelatin', 'gemstone', 'giant_panda',
+         'gift_wrap', 'ginger', 'giraffe', 'cincture',
+         'glass_(drink_container)', 'globe', 'glove', 'goat', 'goggles',
+         'goldfish', 'golf_club', 'golfcart', 'gondola_(boat)', 'goose',
+         'gorilla', 'gourd', 'surgical_gown', 'grape', 'grasshopper', 'grater',
+         'gravestone', 'gravy_boat', 'green_bean', 'green_onion', 'griddle',
+         'grillroom', 'grinder_(tool)', 'grits', 'grizzly', 'grocery_bag',
+         'guacamole', 'guitar', 'gull', 'gun', 'hair_spray', 'hairbrush',
+         'hairnet', 'hairpin', 'ham', 'hamburger', 'hammer', 'hammock',
+         'hamper', 'hamster', 'hair_dryer', 'hand_glass', 'hand_towel',
+         'handcart', 'handcuff', 'handkerchief', 'handle', 'handsaw',
+         'hardback_book', 'harmonium', 'hat', 'hatbox', 'hatch', 'veil',
+         'headband', 'headboard', 'headlight', 'headscarf', 'headset',
+         'headstall_(for_horses)', 'hearing_aid', 'heart', 'heater',
+         'helicopter', 'helmet', 'heron', 'highchair', 'hinge', 'hippopotamus',
+         'hockey_stick', 'hog', 'home_plate_(baseball)', 'honey', 'fume_hood',
+         'hook', 'horse', 'hose', 'hot-air_balloon', 'hotplate', 'hot_sauce',
+         'hourglass', 'houseboat', 'hummingbird', 'hummus', 'polar_bear',
+         'icecream', 'popsicle', 'ice_maker', 'ice_pack', 'ice_skate',
+         'ice_tea', 'igniter', 'incense', 'inhaler', 'iPod',
+         'iron_(for_clothing)', 'ironing_board', 'jacket', 'jam', 'jean',
+         'jeep', 'jelly_bean', 'jersey', 'jet_plane', 'jewelry', 'joystick',
+         'jumpsuit', 'kayak', 'keg', 'kennel', 'kettle', 'key', 'keycard',
+         'kilt', 'kimono', 'kitchen_sink', 'kitchen_table', 'kite', 'kitten',
+         'kiwi_fruit', 'knee_pad', 'knife', 'knight_(chess_piece)',
+         'knitting_needle', 'knob', 'knocker_(on_a_door)', 'koala', 'lab_coat',
+         'ladder', 'ladle', 'ladybug', 'lamb_(animal)', 'lamb-chop', 'lamp',
+         'lamppost', 'lampshade', 'lantern', 'lanyard', 'laptop_computer',
+         'lasagna', 'latch', 'lawn_mower', 'leather', 'legging_(clothing)',
+         'Lego', 'lemon', 'lemonade', 'lettuce', 'license_plate', 'life_buoy',
+         'life_jacket', 'lightbulb', 'lightning_rod', 'lime', 'limousine',
+         'linen_paper', 'lion', 'lip_balm', 'lipstick', 'liquor', 'lizard',
+         'Loafer_(type_of_shoe)', 'log', 'lollipop', 'lotion',
+         'speaker_(stereo_equipment)', 'loveseat', 'machine_gun', 'magazine',
+         'magnet', 'mail_slot', 'mailbox_(at_home)', 'mallet', 'mammoth',
+         'mandarin_orange', 'manger', 'manhole', 'map', 'marker', 'martini',
+         'mascot', 'mashed_potato', 'masher', 'mask', 'mast',
+         'mat_(gym_equipment)', 'matchbox', 'mattress', 'measuring_cup',
+         'measuring_stick', 'meatball', 'medicine', 'melon', 'microphone',
+         'microscope', 'microwave_oven', 'milestone', 'milk', 'minivan',
+         'mint_candy', 'mirror', 'mitten', 'mixer_(kitchen_tool)', 'money',
+         'monitor_(computer_equipment) computer_monitor', 'monkey', 'motor',
+         'motor_scooter', 'motor_vehicle', 'motorboat', 'motorcycle',
+         'mound_(baseball)', 'mouse_(animal_rodent)',
+         'mouse_(computer_equipment)', 'mousepad', 'muffin', 'mug', 'mushroom',
+         'music_stool', 'musical_instrument', 'nailfile', 'nameplate',
+         'napkin', 'neckerchief', 'necklace', 'necktie', 'needle', 'nest',
+         'newsstand', 'nightshirt', 'nosebag_(for_animals)',
+         'noseband_(for_animals)', 'notebook', 'notepad', 'nut', 'nutcracker',
+         'oar', 'octopus_(food)', 'octopus_(animal)', 'oil_lamp', 'olive_oil',
+         'omelet', 'onion', 'orange_(fruit)', 'orange_juice', 'oregano',
+         'ostrich', 'ottoman', 'overalls_(clothing)', 'owl', 'packet',
+         'inkpad', 'pad', 'paddle', 'padlock', 'paintbox', 'paintbrush',
+         'painting', 'pajamas', 'palette', 'pan_(for_cooking)',
+         'pan_(metal_container)', 'pancake', 'pantyhose', 'papaya',
+         'paperclip', 'paper_plate', 'paper_towel', 'paperback_book',
+         'paperweight', 'parachute', 'parakeet', 'parasail_(sports)',
+         'parchment', 'parka', 'parking_meter', 'parrot',
+         'passenger_car_(part_of_a_train)', 'passenger_ship', 'passport',
+         'pastry', 'patty_(food)', 'pea_(food)', 'peach', 'peanut_butter',
+         'pear', 'peeler_(tool_for_fruit_and_vegetables)', 'pegboard',
+         'pelican', 'pen', 'pencil', 'pencil_box', 'pencil_sharpener',
+         'pendulum', 'penguin', 'pennant', 'penny_(coin)', 'pepper',
+         'pepper_mill', 'perfume', 'persimmon', 'baby', 'pet', 'petfood',
+         'pew_(church_bench)', 'phonebook', 'phonograph_record', 'piano',
+         'pickle', 'pickup_truck', 'pie', 'pigeon', 'piggy_bank', 'pillow',
+         'pin_(non_jewelry)', 'pineapple', 'pinecone', 'ping-pong_ball',
+         'pinwheel', 'tobacco_pipe', 'pipe', 'pistol', 'pita_(bread)',
+         'pitcher_(vessel_for_liquid)', 'pitchfork', 'pizza', 'place_mat',
+         'plate', 'platter', 'playing_card', 'playpen', 'pliers',
+         'plow_(farm_equipment)', 'pocket_watch', 'pocketknife',
+         'poker_(fire_stirring_tool)', 'pole', 'police_van', 'polo_shirt',
+         'poncho', 'pony', 'pool_table', 'pop_(soda)', 'portrait',
+         'postbox_(public)', 'postcard', 'poster', 'pot', 'flowerpot',
+         'potato', 'potholder', 'pottery', 'pouch', 'power_shovel', 'prawn',
+         'printer', 'projectile_(weapon)', 'projector', 'propeller', 'prune',
+         'pudding', 'puffer_(fish)', 'puffin', 'pug-dog', 'pumpkin', 'puncher',
+         'puppet', 'puppy', 'quesadilla', 'quiche', 'quilt', 'rabbit',
+         'race_car', 'racket', 'radar', 'radiator', 'radio_receiver', 'radish',
+         'raft', 'rag_doll', 'raincoat', 'ram_(animal)', 'raspberry', 'rat',
+         'razorblade', 'reamer_(juicer)', 'rearview_mirror', 'receipt',
+         'recliner', 'record_player', 'red_cabbage', 'reflector',
+         'remote_control', 'rhinoceros', 'rib_(food)', 'rifle', 'ring',
+         'river_boat', 'road_map', 'robe', 'rocking_chair', 'roller_skate',
+         'Rollerblade', 'rolling_pin', 'root_beer',
+         'router_(computer_equipment)', 'rubber_band', 'runner_(carpet)',
+         'plastic_bag', 'saddle_(on_an_animal)', 'saddle_blanket', 'saddlebag',
+         'safety_pin', 'sail', 'salad', 'salad_plate', 'salami',
+         'salmon_(fish)', 'salmon_(food)', 'salsa', 'saltshaker',
+         'sandal_(type_of_shoe)', 'sandwich', 'satchel', 'saucepan', 'saucer',
+         'sausage', 'sawhorse', 'saxophone', 'scale_(measuring_instrument)',
+         'scarecrow', 'scarf', 'school_bus', 'scissors', 'scoreboard',
+         'scrambled_eggs', 'scraper', 'scratcher', 'screwdriver',
+         'scrubbing_brush', 'sculpture', 'seabird', 'seahorse', 'seaplane',
+         'seashell', 'seedling', 'serving_dish', 'sewing_machine', 'shaker',
+         'shampoo', 'shark', 'sharpener', 'Sharpie', 'shaver_(electric)',
+         'shaving_cream', 'shawl', 'shears', 'sheep', 'shepherd_dog',
+         'sherbert', 'shield', 'shirt', 'shoe', 'shopping_bag',
+         'shopping_cart', 'short_pants', 'shot_glass', 'shoulder_bag',
+         'shovel', 'shower_head', 'shower_curtain', 'shredder_(for_paper)',
+         'sieve', 'signboard', 'silo', 'sink', 'skateboard', 'skewer', 'ski',
+         'ski_boot', 'ski_parka', 'ski_pole', 'skirt', 'sled', 'sleeping_bag',
+         'sling_(bandage)', 'slipper_(footwear)', 'smoothie', 'snake',
+         'snowboard', 'snowman', 'snowmobile', 'soap', 'soccer_ball', 'sock',
+         'soda_fountain', 'carbonated_water', 'sofa', 'softball',
+         'solar_array', 'sombrero', 'soup', 'soup_bowl', 'soupspoon',
+         'sour_cream', 'soya_milk', 'space_shuttle', 'sparkler_(fireworks)',
+         'spatula', 'spear', 'spectacles', 'spice_rack', 'spider', 'sponge',
+         'spoon', 'sportswear', 'spotlight', 'squirrel',
+         'stapler_(stapling_machine)', 'starfish', 'statue_(sculpture)',
+         'steak_(food)', 'steak_knife', 'steamer_(kitchen_appliance)',
+         'steering_wheel', 'stencil', 'stepladder', 'step_stool',
+         'stereo_(sound_system)', 'stew', 'stirrer', 'stirrup',
+         'stockings_(leg_wear)', 'stool', 'stop_sign', 'brake_light', 'stove',
+         'strainer', 'strap', 'straw_(for_drinking)', 'strawberry',
+         'street_sign', 'streetlight', 'string_cheese', 'stylus', 'subwoofer',
+         'sugar_bowl', 'sugarcane_(plant)', 'suit_(clothing)', 'sunflower',
+         'sunglasses', 'sunhat', 'sunscreen', 'surfboard', 'sushi', 'mop',
+         'sweat_pants', 'sweatband', 'sweater', 'sweatshirt', 'sweet_potato',
+         'swimsuit', 'sword', 'syringe', 'Tabasco_sauce', 'table-tennis_table',
+         'table', 'table_lamp', 'tablecloth', 'tachometer', 'taco', 'tag',
+         'taillight', 'tambourine', 'army_tank', 'tank_(storage_vessel)',
+         'tank_top_(clothing)', 'tape_(sticky_cloth_or_paper)', 'tape_measure',
+         'tapestry', 'tarp', 'tartan', 'tassel', 'tea_bag', 'teacup',
+         'teakettle', 'teapot', 'teddy_bear', 'telephone', 'telephone_booth',
+         'telephone_pole', 'telephoto_lens', 'television_camera',
+         'television_set', 'tennis_ball', 'tennis_racket', 'tequila',
+         'thermometer', 'thermos_bottle', 'thermostat', 'thimble', 'thread',
+         'thumbtack', 'tiara', 'tiger', 'tights_(clothing)', 'timer',
+         'tinfoil', 'tinsel', 'tissue_paper', 'toast_(food)', 'toaster',
+         'toaster_oven', 'toilet', 'toilet_tissue', 'tomato', 'tongs',
+         'toolbox', 'toothbrush', 'toothpaste', 'toothpick', 'cover',
+         'tortilla', 'tow_truck', 'towel', 'towel_rack', 'toy',
+         'tractor_(farm_equipment)', 'traffic_light', 'dirt_bike',
+         'trailer_truck', 'train_(railroad_vehicle)', 'trampoline', 'tray',
+         'tree_house', 'trench_coat', 'triangle_(musical_instrument)',
+         'tricycle', 'tripod', 'trousers', 'truck', 'truffle_(chocolate)',
+         'trunk', 'vat', 'turban', 'turkey_(bird)', 'turkey_(food)', 'turnip',
+         'turtle', 'turtleneck_(clothing)', 'typewriter', 'umbrella',
+         'underwear', 'unicycle', 'urinal', 'urn', 'vacuum_cleaner', 'valve',
+         'vase', 'vending_machine', 'vent', 'videotape', 'vinegar', 'violin',
+         'vodka', 'volleyball', 'vulture', 'waffle', 'waffle_iron', 'wagon',
+         'wagon_wheel', 'walking_stick', 'wall_clock', 'wall_socket', 'wallet',
+         'walrus', 'wardrobe', 'wasabi', 'automatic_washer', 'watch',
+         'water_bottle', 'water_cooler', 'water_faucet', 'water_filter',
+         'water_heater', 'water_jug', 'water_gun', 'water_scooter',
+         'water_ski', 'water_tower', 'watering_can', 'watermelon',
+         'weathervane', 'webcam', 'wedding_cake', 'wedding_ring', 'wet_suit',
+         'wheel', 'wheelchair', 'whipped_cream', 'whiskey', 'whistle', 'wick',
+         'wig', 'wind_chime', 'windmill', 'window_box_(for_plants)',
+         'windshield_wiper', 'windsock', 'wine_bottle', 'wine_bucket',
+         'wineglass', 'wing_chair', 'blinder_(for_horses)', 'wok', 'wolf',
+         'wooden_spoon', 'wreath', 'wrench', 'wristband', 'wristlet', 'yacht',
+         'yak', 'yogurt', 'yoke_(animal_equipment)', 'zebra', 'zucchini'),
+        'palette':
+        None
+    }
+
+    def load_data_list(self) -> List[dict]:
+        """Load annotations from an annotation file named as ``self.ann_file``
+
+        Returns:
+            List[dict]: A list of annotation.
+        """  # noqa: E501
+        try:
+            import lvis
+            if getattr(lvis, '__version__', '0') >= '10.5.3':
+                warnings.warn(
+                    'mmlvis is deprecated, please install official lvis-api by "pip install git+https://github.com/lvis-dataset/lvis-api.git"',  # noqa: E501
+                    UserWarning)
+            from lvis import LVIS
+        except ImportError:
+            raise ImportError(
+                'Package lvis is not installed. Please run "pip install git+https://github.com/lvis-dataset/lvis-api.git".'  # noqa: E501
+            )
+        with get_local_path(
+                self.ann_file, backend_args=self.backend_args) as local_path:
+            self.lvis = LVIS(local_path)
+        self.cat_ids = self.lvis.get_cat_ids()
+        self.cat2label = {cat_id: i for i, cat_id in enumerate(self.cat_ids)}
+        self.cat_img_map = copy.deepcopy(self.lvis.cat_img_map)
+
+        img_ids = self.lvis.get_img_ids()
+        data_list = []
+        total_ann_ids = []
+        for img_id in img_ids:
+            raw_img_info = self.lvis.load_imgs([img_id])[0]
+            raw_img_info['img_id'] = img_id
+            if raw_img_info['file_name'].startswith('COCO'):
+                # Convert form the COCO 2014 file naming convention of
+                # COCO_[train/val/test]2014_000000000000.jpg to the 2017
+                # naming convention of 000000000000.jpg
+                # (LVIS v1 will fix this naming issue)
+                raw_img_info['file_name'] = raw_img_info['file_name'][-16:]
+            ann_ids = self.lvis.get_ann_ids(img_ids=[img_id])
+            raw_ann_info = self.lvis.load_anns(ann_ids)
+            total_ann_ids.extend(ann_ids)
+
+            parsed_data_info = self.parse_data_info({
+                'raw_ann_info':
+                raw_ann_info,
+                'raw_img_info':
+                raw_img_info
+            })
+            data_list.append(parsed_data_info)
+        if self.ANN_ID_UNIQUE:
+            assert len(set(total_ann_ids)) == len(
+                total_ann_ids
+            ), f"Annotation ids in '{self.ann_file}' are not unique!"
+
+        del self.lvis
+
+        return data_list
+
+
+LVISDataset = LVISV05Dataset
+DATASETS.register_module(name='LVISDataset', module=LVISDataset)
+
+
+@DATASETS.register_module()
+class LVISV1Dataset(LVISDataset):
+    """LVIS v1 dataset for detection."""
+
+    METAINFO = {
+        'classes':
+        ('aerosol_can', 'air_conditioner', 'airplane', 'alarm_clock',
+         'alcohol', 'alligator', 'almond', 'ambulance', 'amplifier', 'anklet',
+         'antenna', 'apple', 'applesauce', 'apricot', 'apron', 'aquarium',
+         'arctic_(type_of_shoe)', 'armband', 'armchair', 'armoire', 'armor',
+         'artichoke', 'trash_can', 'ashtray', 'asparagus', 'atomizer',
+         'avocado', 'award', 'awning', 'ax', 'baboon', 'baby_buggy',
+         'basketball_backboard', 'backpack', 'handbag', 'suitcase', 'bagel',
+         'bagpipe', 'baguet', 'bait', 'ball', 'ballet_skirt', 'balloon',
+         'bamboo', 'banana', 'Band_Aid', 'bandage', 'bandanna', 'banjo',
+         'banner', 'barbell', 'barge', 'barrel', 'barrette', 'barrow',
+         'baseball_base', 'baseball', 'baseball_bat', 'baseball_cap',
+         'baseball_glove', 'basket', 'basketball', 'bass_horn', 'bat_(animal)',
+         'bath_mat', 'bath_towel', 'bathrobe', 'bathtub', 'batter_(food)',
+         'battery', 'beachball', 'bead', 'bean_curd', 'beanbag', 'beanie',
+         'bear', 'bed', 'bedpan', 'bedspread', 'cow', 'beef_(food)', 'beeper',
+         'beer_bottle', 'beer_can', 'beetle', 'bell', 'bell_pepper', 'belt',
+         'belt_buckle', 'bench', 'beret', 'bib', 'Bible', 'bicycle', 'visor',
+         'billboard', 'binder', 'binoculars', 'bird', 'birdfeeder', 'birdbath',
+         'birdcage', 'birdhouse', 'birthday_cake', 'birthday_card',
+         'pirate_flag', 'black_sheep', 'blackberry', 'blackboard', 'blanket',
+         'blazer', 'blender', 'blimp', 'blinker', 'blouse', 'blueberry',
+         'gameboard', 'boat', 'bob', 'bobbin', 'bobby_pin', 'boiled_egg',
+         'bolo_tie', 'deadbolt', 'bolt', 'bonnet', 'book', 'bookcase',
+         'booklet', 'bookmark', 'boom_microphone', 'boot', 'bottle',
+         'bottle_opener', 'bouquet', 'bow_(weapon)',
+         'bow_(decorative_ribbons)', 'bow-tie', 'bowl', 'pipe_bowl',
+         'bowler_hat', 'bowling_ball', 'box', 'boxing_glove', 'suspenders',
+         'bracelet', 'brass_plaque', 'brassiere', 'bread-bin', 'bread',
+         'breechcloth', 'bridal_gown', 'briefcase', 'broccoli', 'broach',
+         'broom', 'brownie', 'brussels_sprouts', 'bubble_gum', 'bucket',
+         'horse_buggy', 'bull', 'bulldog', 'bulldozer', 'bullet_train',
+         'bulletin_board', 'bulletproof_vest', 'bullhorn', 'bun', 'bunk_bed',
+         'buoy', 'burrito', 'bus_(vehicle)', 'business_card', 'butter',
+         'butterfly', 'button', 'cab_(taxi)', 'cabana', 'cabin_car', 'cabinet',
+         'locker', 'cake', 'calculator', 'calendar', 'calf', 'camcorder',
+         'camel', 'camera', 'camera_lens', 'camper_(vehicle)', 'can',
+         'can_opener', 'candle', 'candle_holder', 'candy_bar', 'candy_cane',
+         'walking_cane', 'canister', 'canoe', 'cantaloup', 'canteen',
+         'cap_(headwear)', 'bottle_cap', 'cape', 'cappuccino',
+         'car_(automobile)', 'railcar_(part_of_a_train)', 'elevator_car',
+         'car_battery', 'identity_card', 'card', 'cardigan', 'cargo_ship',
+         'carnation', 'horse_carriage', 'carrot', 'tote_bag', 'cart', 'carton',
+         'cash_register', 'casserole', 'cassette', 'cast', 'cat',
+         'cauliflower', 'cayenne_(spice)', 'CD_player', 'celery',
+         'cellular_telephone', 'chain_mail', 'chair', 'chaise_longue',
+         'chalice', 'chandelier', 'chap', 'checkbook', 'checkerboard',
+         'cherry', 'chessboard', 'chicken_(animal)', 'chickpea',
+         'chili_(vegetable)', 'chime', 'chinaware', 'crisp_(potato_chip)',
+         'poker_chip', 'chocolate_bar', 'chocolate_cake', 'chocolate_milk',
+         'chocolate_mousse', 'choker', 'chopping_board', 'chopstick',
+         'Christmas_tree', 'slide', 'cider', 'cigar_box', 'cigarette',
+         'cigarette_case', 'cistern', 'clarinet', 'clasp', 'cleansing_agent',
+         'cleat_(for_securing_rope)', 'clementine', 'clip', 'clipboard',
+         'clippers_(for_plants)', 'cloak', 'clock', 'clock_tower',
+         'clothes_hamper', 'clothespin', 'clutch_bag', 'coaster', 'coat',
+         'coat_hanger', 'coatrack', 'cock', 'cockroach', 'cocoa_(beverage)',
+         'coconut', 'coffee_maker', 'coffee_table', 'coffeepot', 'coil',
+         'coin', 'colander', 'coleslaw', 'coloring_material',
+         'combination_lock', 'pacifier', 'comic_book', 'compass',
+         'computer_keyboard', 'condiment', 'cone', 'control',
+         'convertible_(automobile)', 'sofa_bed', 'cooker', 'cookie',
+         'cooking_utensil', 'cooler_(for_food)', 'cork_(bottle_plug)',
+         'corkboard', 'corkscrew', 'edible_corn', 'cornbread', 'cornet',
+         'cornice', 'cornmeal', 'corset', 'costume', 'cougar', 'coverall',
+         'cowbell', 'cowboy_hat', 'crab_(animal)', 'crabmeat', 'cracker',
+         'crape', 'crate', 'crayon', 'cream_pitcher', 'crescent_roll', 'crib',
+         'crock_pot', 'crossbar', 'crouton', 'crow', 'crowbar', 'crown',
+         'crucifix', 'cruise_ship', 'police_cruiser', 'crumb', 'crutch',
+         'cub_(animal)', 'cube', 'cucumber', 'cufflink', 'cup', 'trophy_cup',
+         'cupboard', 'cupcake', 'hair_curler', 'curling_iron', 'curtain',
+         'cushion', 'cylinder', 'cymbal', 'dagger', 'dalmatian', 'dartboard',
+         'date_(fruit)', 'deck_chair', 'deer', 'dental_floss', 'desk',
+         'detergent', 'diaper', 'diary', 'die', 'dinghy', 'dining_table',
+         'tux', 'dish', 'dish_antenna', 'dishrag', 'dishtowel', 'dishwasher',
+         'dishwasher_detergent', 'dispenser', 'diving_board', 'Dixie_cup',
+         'dog', 'dog_collar', 'doll', 'dollar', 'dollhouse', 'dolphin',
+         'domestic_ass', 'doorknob', 'doormat', 'doughnut', 'dove',
+         'dragonfly', 'drawer', 'underdrawers', 'dress', 'dress_hat',
+         'dress_suit', 'dresser', 'drill', 'drone', 'dropper',
+         'drum_(musical_instrument)', 'drumstick', 'duck', 'duckling',
+         'duct_tape', 'duffel_bag', 'dumbbell', 'dumpster', 'dustpan', 'eagle',
+         'earphone', 'earplug', 'earring', 'easel', 'eclair', 'eel', 'egg',
+         'egg_roll', 'egg_yolk', 'eggbeater', 'eggplant', 'electric_chair',
+         'refrigerator', 'elephant', 'elk', 'envelope', 'eraser', 'escargot',
+         'eyepatch', 'falcon', 'fan', 'faucet', 'fedora', 'ferret',
+         'Ferris_wheel', 'ferry', 'fig_(fruit)', 'fighter_jet', 'figurine',
+         'file_cabinet', 'file_(tool)', 'fire_alarm', 'fire_engine',
+         'fire_extinguisher', 'fire_hose', 'fireplace', 'fireplug',
+         'first-aid_kit', 'fish', 'fish_(food)', 'fishbowl', 'fishing_rod',
+         'flag', 'flagpole', 'flamingo', 'flannel', 'flap', 'flash',
+         'flashlight', 'fleece', 'flip-flop_(sandal)', 'flipper_(footwear)',
+         'flower_arrangement', 'flute_glass', 'foal', 'folding_chair',
+         'food_processor', 'football_(American)', 'football_helmet',
+         'footstool', 'fork', 'forklift', 'freight_car', 'French_toast',
+         'freshener', 'frisbee', 'frog', 'fruit_juice', 'frying_pan', 'fudge',
+         'funnel', 'futon', 'gag', 'garbage', 'garbage_truck', 'garden_hose',
+         'gargle', 'gargoyle', 'garlic', 'gasmask', 'gazelle', 'gelatin',
+         'gemstone', 'generator', 'giant_panda', 'gift_wrap', 'ginger',
+         'giraffe', 'cincture', 'glass_(drink_container)', 'globe', 'glove',
+         'goat', 'goggles', 'goldfish', 'golf_club', 'golfcart',
+         'gondola_(boat)', 'goose', 'gorilla', 'gourd', 'grape', 'grater',
+         'gravestone', 'gravy_boat', 'green_bean', 'green_onion', 'griddle',
+         'grill', 'grits', 'grizzly', 'grocery_bag', 'guitar', 'gull', 'gun',
+         'hairbrush', 'hairnet', 'hairpin', 'halter_top', 'ham', 'hamburger',
+         'hammer', 'hammock', 'hamper', 'hamster', 'hair_dryer', 'hand_glass',
+         'hand_towel', 'handcart', 'handcuff', 'handkerchief', 'handle',
+         'handsaw', 'hardback_book', 'harmonium', 'hat', 'hatbox', 'veil',
+         'headband', 'headboard', 'headlight', 'headscarf', 'headset',
+         'headstall_(for_horses)', 'heart', 'heater', 'helicopter', 'helmet',
+         'heron', 'highchair', 'hinge', 'hippopotamus', 'hockey_stick', 'hog',
+         'home_plate_(baseball)', 'honey', 'fume_hood', 'hook', 'hookah',
+         'hornet', 'horse', 'hose', 'hot-air_balloon', 'hotplate', 'hot_sauce',
+         'hourglass', 'houseboat', 'hummingbird', 'hummus', 'polar_bear',
+         'icecream', 'popsicle', 'ice_maker', 'ice_pack', 'ice_skate',
+         'igniter', 'inhaler', 'iPod', 'iron_(for_clothing)', 'ironing_board',
+         'jacket', 'jam', 'jar', 'jean', 'jeep', 'jelly_bean', 'jersey',
+         'jet_plane', 'jewel', 'jewelry', 'joystick', 'jumpsuit', 'kayak',
+         'keg', 'kennel', 'kettle', 'key', 'keycard', 'kilt', 'kimono',
+         'kitchen_sink', 'kitchen_table', 'kite', 'kitten', 'kiwi_fruit',
+         'knee_pad', 'knife', 'knitting_needle', 'knob', 'knocker_(on_a_door)',
+         'koala', 'lab_coat', 'ladder', 'ladle', 'ladybug', 'lamb_(animal)',
+         'lamb-chop', 'lamp', 'lamppost', 'lampshade', 'lantern', 'lanyard',
+         'laptop_computer', 'lasagna', 'latch', 'lawn_mower', 'leather',
+         'legging_(clothing)', 'Lego', 'legume', 'lemon', 'lemonade',
+         'lettuce', 'license_plate', 'life_buoy', 'life_jacket', 'lightbulb',
+         'lightning_rod', 'lime', 'limousine', 'lion', 'lip_balm', 'liquor',
+         'lizard', 'log', 'lollipop', 'speaker_(stereo_equipment)', 'loveseat',
+         'machine_gun', 'magazine', 'magnet', 'mail_slot', 'mailbox_(at_home)',
+         'mallard', 'mallet', 'mammoth', 'manatee', 'mandarin_orange',
+         'manger', 'manhole', 'map', 'marker', 'martini', 'mascot',
+         'mashed_potato', 'masher', 'mask', 'mast', 'mat_(gym_equipment)',
+         'matchbox', 'mattress', 'measuring_cup', 'measuring_stick',
+         'meatball', 'medicine', 'melon', 'microphone', 'microscope',
+         'microwave_oven', 'milestone', 'milk', 'milk_can', 'milkshake',
+         'minivan', 'mint_candy', 'mirror', 'mitten', 'mixer_(kitchen_tool)',
+         'money', 'monitor_(computer_equipment) computer_monitor', 'monkey',
+         'motor', 'motor_scooter', 'motor_vehicle', 'motorcycle',
+         'mound_(baseball)', 'mouse_(computer_equipment)', 'mousepad',
+         'muffin', 'mug', 'mushroom', 'music_stool', 'musical_instrument',
+         'nailfile', 'napkin', 'neckerchief', 'necklace', 'necktie', 'needle',
+         'nest', 'newspaper', 'newsstand', 'nightshirt',
+         'nosebag_(for_animals)', 'noseband_(for_animals)', 'notebook',
+         'notepad', 'nut', 'nutcracker', 'oar', 'octopus_(food)',
+         'octopus_(animal)', 'oil_lamp', 'olive_oil', 'omelet', 'onion',
+         'orange_(fruit)', 'orange_juice', 'ostrich', 'ottoman', 'oven',
+         'overalls_(clothing)', 'owl', 'packet', 'inkpad', 'pad', 'paddle',
+         'padlock', 'paintbrush', 'painting', 'pajamas', 'palette',
+         'pan_(for_cooking)', 'pan_(metal_container)', 'pancake', 'pantyhose',
+         'papaya', 'paper_plate', 'paper_towel', 'paperback_book',
+         'paperweight', 'parachute', 'parakeet', 'parasail_(sports)',
+         'parasol', 'parchment', 'parka', 'parking_meter', 'parrot',
+         'passenger_car_(part_of_a_train)', 'passenger_ship', 'passport',
+         'pastry', 'patty_(food)', 'pea_(food)', 'peach', 'peanut_butter',
+         'pear', 'peeler_(tool_for_fruit_and_vegetables)', 'wooden_leg',
+         'pegboard', 'pelican', 'pen', 'pencil', 'pencil_box',
+         'pencil_sharpener', 'pendulum', 'penguin', 'pennant', 'penny_(coin)',
+         'pepper', 'pepper_mill', 'perfume', 'persimmon', 'person', 'pet',
+         'pew_(church_bench)', 'phonebook', 'phonograph_record', 'piano',
+         'pickle', 'pickup_truck', 'pie', 'pigeon', 'piggy_bank', 'pillow',
+         'pin_(non_jewelry)', 'pineapple', 'pinecone', 'ping-pong_ball',
+         'pinwheel', 'tobacco_pipe', 'pipe', 'pistol', 'pita_(bread)',
+         'pitcher_(vessel_for_liquid)', 'pitchfork', 'pizza', 'place_mat',
+         'plate', 'platter', 'playpen', 'pliers', 'plow_(farm_equipment)',
+         'plume', 'pocket_watch', 'pocketknife', 'poker_(fire_stirring_tool)',
+         'pole', 'polo_shirt', 'poncho', 'pony', 'pool_table', 'pop_(soda)',
+         'postbox_(public)', 'postcard', 'poster', 'pot', 'flowerpot',
+         'potato', 'potholder', 'pottery', 'pouch', 'power_shovel', 'prawn',
+         'pretzel', 'printer', 'projectile_(weapon)', 'projector', 'propeller',
+         'prune', 'pudding', 'puffer_(fish)', 'puffin', 'pug-dog', 'pumpkin',
+         'puncher', 'puppet', 'puppy', 'quesadilla', 'quiche', 'quilt',
+         'rabbit', 'race_car', 'racket', 'radar', 'radiator', 'radio_receiver',
+         'radish', 'raft', 'rag_doll', 'raincoat', 'ram_(animal)', 'raspberry',
+         'rat', 'razorblade', 'reamer_(juicer)', 'rearview_mirror', 'receipt',
+         'recliner', 'record_player', 'reflector', 'remote_control',
+         'rhinoceros', 'rib_(food)', 'rifle', 'ring', 'river_boat', 'road_map',
+         'robe', 'rocking_chair', 'rodent', 'roller_skate', 'Rollerblade',
+         'rolling_pin', 'root_beer', 'router_(computer_equipment)',
+         'rubber_band', 'runner_(carpet)', 'plastic_bag',
+         'saddle_(on_an_animal)', 'saddle_blanket', 'saddlebag', 'safety_pin',
+         'sail', 'salad', 'salad_plate', 'salami', 'salmon_(fish)',
+         'salmon_(food)', 'salsa', 'saltshaker', 'sandal_(type_of_shoe)',
+         'sandwich', 'satchel', 'saucepan', 'saucer', 'sausage', 'sawhorse',
+         'saxophone', 'scale_(measuring_instrument)', 'scarecrow', 'scarf',
+         'school_bus', 'scissors', 'scoreboard', 'scraper', 'screwdriver',
+         'scrubbing_brush', 'sculpture', 'seabird', 'seahorse', 'seaplane',
+         'seashell', 'sewing_machine', 'shaker', 'shampoo', 'shark',
+         'sharpener', 'Sharpie', 'shaver_(electric)', 'shaving_cream', 'shawl',
+         'shears', 'sheep', 'shepherd_dog', 'sherbert', 'shield', 'shirt',
+         'shoe', 'shopping_bag', 'shopping_cart', 'short_pants', 'shot_glass',
+         'shoulder_bag', 'shovel', 'shower_head', 'shower_cap',
+         'shower_curtain', 'shredder_(for_paper)', 'signboard', 'silo', 'sink',
+         'skateboard', 'skewer', 'ski', 'ski_boot', 'ski_parka', 'ski_pole',
+         'skirt', 'skullcap', 'sled', 'sleeping_bag', 'sling_(bandage)',
+         'slipper_(footwear)', 'smoothie', 'snake', 'snowboard', 'snowman',
+         'snowmobile', 'soap', 'soccer_ball', 'sock', 'sofa', 'softball',
+         'solar_array', 'sombrero', 'soup', 'soup_bowl', 'soupspoon',
+         'sour_cream', 'soya_milk', 'space_shuttle', 'sparkler_(fireworks)',
+         'spatula', 'spear', 'spectacles', 'spice_rack', 'spider', 'crawfish',
+         'sponge', 'spoon', 'sportswear', 'spotlight', 'squid_(food)',
+         'squirrel', 'stagecoach', 'stapler_(stapling_machine)', 'starfish',
+         'statue_(sculpture)', 'steak_(food)', 'steak_knife', 'steering_wheel',
+         'stepladder', 'step_stool', 'stereo_(sound_system)', 'stew',
+         'stirrer', 'stirrup', 'stool', 'stop_sign', 'brake_light', 'stove',
+         'strainer', 'strap', 'straw_(for_drinking)', 'strawberry',
+         'street_sign', 'streetlight', 'string_cheese', 'stylus', 'subwoofer',
+         'sugar_bowl', 'sugarcane_(plant)', 'suit_(clothing)', 'sunflower',
+         'sunglasses', 'sunhat', 'surfboard', 'sushi', 'mop', 'sweat_pants',
+         'sweatband', 'sweater', 'sweatshirt', 'sweet_potato', 'swimsuit',
+         'sword', 'syringe', 'Tabasco_sauce', 'table-tennis_table', 'table',
+         'table_lamp', 'tablecloth', 'tachometer', 'taco', 'tag', 'taillight',
+         'tambourine', 'army_tank', 'tank_(storage_vessel)',
+         'tank_top_(clothing)', 'tape_(sticky_cloth_or_paper)', 'tape_measure',
+         'tapestry', 'tarp', 'tartan', 'tassel', 'tea_bag', 'teacup',
+         'teakettle', 'teapot', 'teddy_bear', 'telephone', 'telephone_booth',
+         'telephone_pole', 'telephoto_lens', 'television_camera',
+         'television_set', 'tennis_ball', 'tennis_racket', 'tequila',
+         'thermometer', 'thermos_bottle', 'thermostat', 'thimble', 'thread',
+         'thumbtack', 'tiara', 'tiger', 'tights_(clothing)', 'timer',
+         'tinfoil', 'tinsel', 'tissue_paper', 'toast_(food)', 'toaster',
+         'toaster_oven', 'toilet', 'toilet_tissue', 'tomato', 'tongs',
+         'toolbox', 'toothbrush', 'toothpaste', 'toothpick', 'cover',
+         'tortilla', 'tow_truck', 'towel', 'towel_rack', 'toy',
+         'tractor_(farm_equipment)', 'traffic_light', 'dirt_bike',
+         'trailer_truck', 'train_(railroad_vehicle)', 'trampoline', 'tray',
+         'trench_coat', 'triangle_(musical_instrument)', 'tricycle', 'tripod',
+         'trousers', 'truck', 'truffle_(chocolate)', 'trunk', 'vat', 'turban',
+         'turkey_(food)', 'turnip', 'turtle', 'turtleneck_(clothing)',
+         'typewriter', 'umbrella', 'underwear', 'unicycle', 'urinal', 'urn',
+         'vacuum_cleaner', 'vase', 'vending_machine', 'vent', 'vest',
+         'videotape', 'vinegar', 'violin', 'vodka', 'volleyball', 'vulture',
+         'waffle', 'waffle_iron', 'wagon', 'wagon_wheel', 'walking_stick',
+         'wall_clock', 'wall_socket', 'wallet', 'walrus', 'wardrobe',
+         'washbasin', 'automatic_washer', 'watch', 'water_bottle',
+         'water_cooler', 'water_faucet', 'water_heater', 'water_jug',
+         'water_gun', 'water_scooter', 'water_ski', 'water_tower',
+         'watering_can', 'watermelon', 'weathervane', 'webcam', 'wedding_cake',
+         'wedding_ring', 'wet_suit', 'wheel', 'wheelchair', 'whipped_cream',
+         'whistle', 'wig', 'wind_chime', 'windmill', 'window_box_(for_plants)',
+         'windshield_wiper', 'windsock', 'wine_bottle', 'wine_bucket',
+         'wineglass', 'blinder_(for_horses)', 'wok', 'wolf', 'wooden_spoon',
+         'wreath', 'wrench', 'wristband', 'wristlet', 'yacht', 'yogurt',
+         'yoke_(animal_equipment)', 'zebra', 'zucchini'),
+        'palette':
+        None
+    }
+
+    def load_data_list(self) -> List[dict]:
+        """Load annotations from an annotation file named as ``self.ann_file``
+
+        Returns:
+            List[dict]: A list of annotation.
+        """  # noqa: E501
+        try:
+            import lvis
+            if getattr(lvis, '__version__', '0') >= '10.5.3':
+                warnings.warn(
+                    'mmlvis is deprecated, please install official lvis-api by "pip install git+https://github.com/lvis-dataset/lvis-api.git"',  # noqa: E501
+                    UserWarning)
+            from lvis import LVIS
+        except ImportError:
+            raise ImportError(
+                'Package lvis is not installed. Please run "pip install git+https://github.com/lvis-dataset/lvis-api.git".'  # noqa: E501
+            )
+        with get_local_path(
+                self.ann_file, backend_args=self.backend_args) as local_path:
+            self.lvis = LVIS(local_path)
+        self.cat_ids = self.lvis.get_cat_ids()
+        self.cat2label = {cat_id: i for i, cat_id in enumerate(self.cat_ids)}
+        self.cat_img_map = copy.deepcopy(self.lvis.cat_img_map)
+
+        img_ids = self.lvis.get_img_ids()
+        data_list = []
+        total_ann_ids = []
+        for img_id in img_ids:
+            raw_img_info = self.lvis.load_imgs([img_id])[0]
+            raw_img_info['img_id'] = img_id
+            # coco_url is used in LVISv1 instead of file_name
+            # e.g. http://images.cocodataset.org/train2017/000000391895.jpg
+            # train/val split in specified in url
+            raw_img_info['file_name'] = raw_img_info['coco_url'].replace(
+                'http://images.cocodataset.org/', '')
+            ann_ids = self.lvis.get_ann_ids(img_ids=[img_id])
+            raw_ann_info = self.lvis.load_anns(ann_ids)
+            total_ann_ids.extend(ann_ids)
+            parsed_data_info = self.parse_data_info({
+                'raw_ann_info':
+                raw_ann_info,
+                'raw_img_info':
+                raw_img_info
+            })
+            data_list.append(parsed_data_info)
+        if self.ANN_ID_UNIQUE:
+            assert len(set(total_ann_ids)) == len(
+                total_ann_ids
+            ), f"Annotation ids in '{self.ann_file}' are not unique!"
+
+        del self.lvis
+
+        return data_list
diff --git a/mmdetection/mmdet/datasets/mdetr_style_refcoco.py b/mmdetection/mmdet/datasets/mdetr_style_refcoco.py
new file mode 100644
index 00000000..cc56dec4
--- /dev/null
+++ b/mmdetection/mmdet/datasets/mdetr_style_refcoco.py
@@ -0,0 +1,57 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+from typing import List
+
+from mmengine.fileio import get_local_path
+
+from mmdet.datasets import BaseDetDataset
+from mmdet.registry import DATASETS
+from .api_wrappers import COCO
+
+
+@DATASETS.register_module()
+class MDETRStyleRefCocoDataset(BaseDetDataset):
+    """RefCOCO dataset.
+
+    Only support evaluation now.
+    """
+
+    def load_data_list(self) -> List[dict]:
+        with get_local_path(
+                self.ann_file, backend_args=self.backend_args) as local_path:
+            coco = COCO(local_path)
+
+        img_ids = coco.get_img_ids()
+
+        data_infos = []
+        for img_id in img_ids:
+            raw_img_info = coco.load_imgs([img_id])[0]
+            ann_ids = coco.get_ann_ids(img_ids=[img_id])
+            raw_ann_info = coco.load_anns(ann_ids)
+
+            data_info = {}
+            img_path = osp.join(self.data_prefix['img'],
+                                raw_img_info['file_name'])
+            data_info['img_path'] = img_path
+            data_info['img_id'] = img_id
+            data_info['height'] = raw_img_info['height']
+            data_info['width'] = raw_img_info['width']
+            data_info['dataset_mode'] = raw_img_info['dataset_name']
+
+            data_info['text'] = raw_img_info['caption']
+            data_info['custom_entities'] = False
+            data_info['tokens_positive'] = -1
+
+            instances = []
+            for i, ann in enumerate(raw_ann_info):
+                instance = {}
+                x1, y1, w, h = ann['bbox']
+                bbox = [x1, y1, x1 + w, y1 + h]
+                instance['bbox'] = bbox
+                instance['bbox_label'] = ann['category_id']
+                instance['ignore_flag'] = 0
+                instances.append(instance)
+
+            data_info['instances'] = instances
+            data_infos.append(data_info)
+        return data_infos
diff --git a/mmdetection/mmdet/datasets/mot_challenge_dataset.py b/mmdetection/mmdet/datasets/mot_challenge_dataset.py
new file mode 100644
index 00000000..ffbdc48e
--- /dev/null
+++ b/mmdetection/mmdet/datasets/mot_challenge_dataset.py
@@ -0,0 +1,88 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+from typing import List, Union
+
+from mmdet.registry import DATASETS
+from .base_video_dataset import BaseVideoDataset
+
+
+@DATASETS.register_module()
+class MOTChallengeDataset(BaseVideoDataset):
+    """Dataset for MOTChallenge.
+
+    Args:
+        visibility_thr (float, optional): The minimum visibility
+            for the objects during training. Default to -1.
+    """
+
+    METAINFO = {
+        'classes':
+        ('pedestrian', 'person_on_vehicle', 'car', 'bicycle', 'motorbike',
+         'non_mot_vehicle', 'static_person', 'distractor', 'occluder',
+         'occluder_on_ground', 'occluder_full', 'reflection', 'crowd')
+    }
+
+    def __init__(self, visibility_thr: float = -1, *args, **kwargs):
+        self.visibility_thr = visibility_thr
+        super().__init__(*args, **kwargs)
+
+    def parse_data_info(self, raw_data_info: dict) -> Union[dict, List[dict]]:
+        """Parse raw annotation to target format. The difference between this
+        function and the one in ``BaseVideoDataset`` is that the parsing here
+        adds ``visibility`` and ``mot_conf``.
+
+        Args:
+            raw_data_info (dict): Raw data information load from ``ann_file``
+
+        Returns:
+            Union[dict, List[dict]]: Parsed annotation.
+        """
+        img_info = raw_data_info['raw_img_info']
+        ann_info = raw_data_info['raw_ann_info']
+        data_info = {}
+
+        data_info.update(img_info)
+        if self.data_prefix.get('img_path', None) is not None:
+            img_path = osp.join(self.data_prefix['img_path'],
+                                img_info['file_name'])
+        else:
+            img_path = img_info['file_name']
+        data_info['img_path'] = img_path
+
+        instances = []
+        for i, ann in enumerate(ann_info):
+            instance = {}
+
+            if (not self.test_mode) and (ann['visibility'] <
+                                         self.visibility_thr):
+                continue
+            if ann.get('ignore', False):
+                continue
+            x1, y1, w, h = ann['bbox']
+            inter_w = max(0, min(x1 + w, img_info['width']) - max(x1, 0))
+            inter_h = max(0, min(y1 + h, img_info['height']) - max(y1, 0))
+            if inter_w * inter_h == 0:
+                continue
+            if ann['area'] <= 0 or w < 1 or h < 1:
+                continue
+            if ann['category_id'] not in self.cat_ids:
+                continue
+            bbox = [x1, y1, x1 + w, y1 + h]
+
+            if ann.get('iscrowd', False):
+                instance['ignore_flag'] = 1
+            else:
+                instance['ignore_flag'] = 0
+            instance['bbox'] = bbox
+            instance['bbox_label'] = self.cat2label[ann['category_id']]
+            instance['instance_id'] = ann['instance_id']
+            instance['category_id'] = ann['category_id']
+            instance['mot_conf'] = ann['mot_conf']
+            instance['visibility'] = ann['visibility']
+            if len(instance) > 0:
+                instances.append(instance)
+        if not self.test_mode:
+            assert len(instances) > 0, f'No valid instances found in ' \
+                f'image {data_info["img_path"]}!'
+        data_info['instances'] = instances
+        return data_info
diff --git a/mmdetection/mmdet/datasets/objects365.py b/mmdetection/mmdet/datasets/objects365.py
new file mode 100644
index 00000000..e99869bf
--- /dev/null
+++ b/mmdetection/mmdet/datasets/objects365.py
@@ -0,0 +1,284 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import os.path as osp
+from typing import List
+
+from mmengine.fileio import get_local_path
+
+from mmdet.registry import DATASETS
+from .api_wrappers import COCO
+from .coco import CocoDataset
+
+# images exist in annotations but not in image folder.
+objv2_ignore_list = [
+    osp.join('patch16', 'objects365_v2_00908726.jpg'),
+    osp.join('patch6', 'objects365_v1_00320532.jpg'),
+    osp.join('patch6', 'objects365_v1_00320534.jpg'),
+]
+
+
+@DATASETS.register_module()
+class Objects365V1Dataset(CocoDataset):
+    """Objects365 v1 dataset for detection."""
+
+    METAINFO = {
+        'classes':
+        ('person', 'sneakers', 'chair', 'hat', 'lamp', 'bottle',
+         'cabinet/shelf', 'cup', 'car', 'glasses', 'picture/frame', 'desk',
+         'handbag', 'street lights', 'book', 'plate', 'helmet',
+         'leather shoes', 'pillow', 'glove', 'potted plant', 'bracelet',
+         'flower', 'tv', 'storage box', 'vase', 'bench', 'wine glass', 'boots',
+         'bowl', 'dining table', 'umbrella', 'boat', 'flag', 'speaker',
+         'trash bin/can', 'stool', 'backpack', 'couch', 'belt', 'carpet',
+         'basket', 'towel/napkin', 'slippers', 'barrel/bucket', 'coffee table',
+         'suv', 'toy', 'tie', 'bed', 'traffic light', 'pen/pencil',
+         'microphone', 'sandals', 'canned', 'necklace', 'mirror', 'faucet',
+         'bicycle', 'bread', 'high heels', 'ring', 'van', 'watch', 'sink',
+         'horse', 'fish', 'apple', 'camera', 'candle', 'teddy bear', 'cake',
+         'motorcycle', 'wild bird', 'laptop', 'knife', 'traffic sign',
+         'cell phone', 'paddle', 'truck', 'cow', 'power outlet', 'clock',
+         'drum', 'fork', 'bus', 'hanger', 'nightstand', 'pot/pan', 'sheep',
+         'guitar', 'traffic cone', 'tea pot', 'keyboard', 'tripod', 'hockey',
+         'fan', 'dog', 'spoon', 'blackboard/whiteboard', 'balloon',
+         'air conditioner', 'cymbal', 'mouse', 'telephone', 'pickup truck',
+         'orange', 'banana', 'airplane', 'luggage', 'skis', 'soccer',
+         'trolley', 'oven', 'remote', 'baseball glove', 'paper towel',
+         'refrigerator', 'train', 'tomato', 'machinery vehicle', 'tent',
+         'shampoo/shower gel', 'head phone', 'lantern', 'donut',
+         'cleaning products', 'sailboat', 'tangerine', 'pizza', 'kite',
+         'computer box', 'elephant', 'toiletries', 'gas stove', 'broccoli',
+         'toilet', 'stroller', 'shovel', 'baseball bat', 'microwave',
+         'skateboard', 'surfboard', 'surveillance camera', 'gun', 'life saver',
+         'cat', 'lemon', 'liquid soap', 'zebra', 'duck', 'sports car',
+         'giraffe', 'pumpkin', 'piano', 'stop sign', 'radiator', 'converter',
+         'tissue ', 'carrot', 'washing machine', 'vent', 'cookies',
+         'cutting/chopping board', 'tennis racket', 'candy',
+         'skating and skiing shoes', 'scissors', 'folder', 'baseball',
+         'strawberry', 'bow tie', 'pigeon', 'pepper', 'coffee machine',
+         'bathtub', 'snowboard', 'suitcase', 'grapes', 'ladder', 'pear',
+         'american football', 'basketball', 'potato', 'paint brush', 'printer',
+         'billiards', 'fire hydrant', 'goose', 'projector', 'sausage',
+         'fire extinguisher', 'extension cord', 'facial mask', 'tennis ball',
+         'chopsticks', 'electronic stove and gas stove', 'pie', 'frisbee',
+         'kettle', 'hamburger', 'golf club', 'cucumber', 'clutch', 'blender',
+         'tong', 'slide', 'hot dog', 'toothbrush', 'facial cleanser', 'mango',
+         'deer', 'egg', 'violin', 'marker', 'ship', 'chicken', 'onion',
+         'ice cream', 'tape', 'wheelchair', 'plum', 'bar soap', 'scale',
+         'watermelon', 'cabbage', 'router/modem', 'golf ball', 'pine apple',
+         'crane', 'fire truck', 'peach', 'cello', 'notepaper', 'tricycle',
+         'toaster', 'helicopter', 'green beans', 'brush', 'carriage', 'cigar',
+         'earphone', 'penguin', 'hurdle', 'swing', 'radio', 'CD',
+         'parking meter', 'swan', 'garlic', 'french fries', 'horn', 'avocado',
+         'saxophone', 'trumpet', 'sandwich', 'cue', 'kiwi fruit', 'bear',
+         'fishing rod', 'cherry', 'tablet', 'green vegetables', 'nuts', 'corn',
+         'key', 'screwdriver', 'globe', 'broom', 'pliers', 'volleyball',
+         'hammer', 'eggplant', 'trophy', 'dates', 'board eraser', 'rice',
+         'tape measure/ruler', 'dumbbell', 'hamimelon', 'stapler', 'camel',
+         'lettuce', 'goldfish', 'meat balls', 'medal', 'toothpaste',
+         'antelope', 'shrimp', 'rickshaw', 'trombone', 'pomegranate',
+         'coconut', 'jellyfish', 'mushroom', 'calculator', 'treadmill',
+         'butterfly', 'egg tart', 'cheese', 'pig', 'pomelo', 'race car',
+         'rice cooker', 'tuba', 'crosswalk sign', 'papaya', 'hair drier',
+         'green onion', 'chips', 'dolphin', 'sushi', 'urinal', 'donkey',
+         'electric drill', 'spring rolls', 'tortoise/turtle', 'parrot',
+         'flute', 'measuring cup', 'shark', 'steak', 'poker card',
+         'binoculars', 'llama', 'radish', 'noodles', 'yak', 'mop', 'crab',
+         'microscope', 'barbell', 'bread/bun', 'baozi', 'lion', 'red cabbage',
+         'polar bear', 'lighter', 'seal', 'mangosteen', 'comb', 'eraser',
+         'pitaya', 'scallop', 'pencil case', 'saw', 'table tennis paddle',
+         'okra', 'starfish', 'eagle', 'monkey', 'durian', 'game board',
+         'rabbit', 'french horn', 'ambulance', 'asparagus', 'hoverboard',
+         'pasta', 'target', 'hotair balloon', 'chainsaw', 'lobster', 'iron',
+         'flashlight'),
+        'palette':
+        None
+    }
+
+    COCOAPI = COCO
+    # ann_id is unique in coco dataset.
+    ANN_ID_UNIQUE = True
+
+    def load_data_list(self) -> List[dict]:
+        """Load annotations from an annotation file named as ``self.ann_file``
+
+        Returns:
+            List[dict]: A list of annotation.
+        """  # noqa: E501
+        with get_local_path(
+                self.ann_file, backend_args=self.backend_args) as local_path:
+            self.coco = self.COCOAPI(local_path)
+
+        # 'categories' list in objects365_train.json and objects365_val.json
+        # is inconsistent, need sort list(or dict) before get cat_ids.
+        cats = self.coco.cats
+        sorted_cats = {i: cats[i] for i in sorted(cats)}
+        self.coco.cats = sorted_cats
+        categories = self.coco.dataset['categories']
+        sorted_categories = sorted(categories, key=lambda i: i['id'])
+        self.coco.dataset['categories'] = sorted_categories
+        # The order of returned `cat_ids` will not
+        # change with the order of the `classes`
+        self.cat_ids = self.coco.get_cat_ids(
+            cat_names=self.metainfo['classes'])
+        self.cat2label = {cat_id: i for i, cat_id in enumerate(self.cat_ids)}
+        self.cat_img_map = copy.deepcopy(self.coco.cat_img_map)
+
+        img_ids = self.coco.get_img_ids()
+        data_list = []
+        total_ann_ids = []
+        for img_id in img_ids:
+            raw_img_info = self.coco.load_imgs([img_id])[0]
+            raw_img_info['img_id'] = img_id
+
+            ann_ids = self.coco.get_ann_ids(img_ids=[img_id])
+            raw_ann_info = self.coco.load_anns(ann_ids)
+            total_ann_ids.extend(ann_ids)
+
+            parsed_data_info = self.parse_data_info({
+                'raw_ann_info':
+                raw_ann_info,
+                'raw_img_info':
+                raw_img_info
+            })
+            data_list.append(parsed_data_info)
+        if self.ANN_ID_UNIQUE:
+            assert len(set(total_ann_ids)) == len(
+                total_ann_ids
+            ), f"Annotation ids in '{self.ann_file}' are not unique!"
+
+        del self.coco
+
+        return data_list
+
+
+@DATASETS.register_module()
+class Objects365V2Dataset(CocoDataset):
+    """Objects365 v2 dataset for detection."""
+    METAINFO = {
+        'classes':
+        ('Person', 'Sneakers', 'Chair', 'Other Shoes', 'Hat', 'Car', 'Lamp',
+         'Glasses', 'Bottle', 'Desk', 'Cup', 'Street Lights', 'Cabinet/shelf',
+         'Handbag/Satchel', 'Bracelet', 'Plate', 'Picture/Frame', 'Helmet',
+         'Book', 'Gloves', 'Storage box', 'Boat', 'Leather Shoes', 'Flower',
+         'Bench', 'Potted Plant', 'Bowl/Basin', 'Flag', 'Pillow', 'Boots',
+         'Vase', 'Microphone', 'Necklace', 'Ring', 'SUV', 'Wine Glass', 'Belt',
+         'Moniter/TV', 'Backpack', 'Umbrella', 'Traffic Light', 'Speaker',
+         'Watch', 'Tie', 'Trash bin Can', 'Slippers', 'Bicycle', 'Stool',
+         'Barrel/bucket', 'Van', 'Couch', 'Sandals', 'Bakset', 'Drum',
+         'Pen/Pencil', 'Bus', 'Wild Bird', 'High Heels', 'Motorcycle',
+         'Guitar', 'Carpet', 'Cell Phone', 'Bread', 'Camera', 'Canned',
+         'Truck', 'Traffic cone', 'Cymbal', 'Lifesaver', 'Towel',
+         'Stuffed Toy', 'Candle', 'Sailboat', 'Laptop', 'Awning', 'Bed',
+         'Faucet', 'Tent', 'Horse', 'Mirror', 'Power outlet', 'Sink', 'Apple',
+         'Air Conditioner', 'Knife', 'Hockey Stick', 'Paddle', 'Pickup Truck',
+         'Fork', 'Traffic Sign', 'Ballon', 'Tripod', 'Dog', 'Spoon', 'Clock',
+         'Pot', 'Cow', 'Cake', 'Dinning Table', 'Sheep', 'Hanger',
+         'Blackboard/Whiteboard', 'Napkin', 'Other Fish', 'Orange/Tangerine',
+         'Toiletry', 'Keyboard', 'Tomato', 'Lantern', 'Machinery Vehicle',
+         'Fan', 'Green Vegetables', 'Banana', 'Baseball Glove', 'Airplane',
+         'Mouse', 'Train', 'Pumpkin', 'Soccer', 'Skiboard', 'Luggage',
+         'Nightstand', 'Tea pot', 'Telephone', 'Trolley', 'Head Phone',
+         'Sports Car', 'Stop Sign', 'Dessert', 'Scooter', 'Stroller', 'Crane',
+         'Remote', 'Refrigerator', 'Oven', 'Lemon', 'Duck', 'Baseball Bat',
+         'Surveillance Camera', 'Cat', 'Jug', 'Broccoli', 'Piano', 'Pizza',
+         'Elephant', 'Skateboard', 'Surfboard', 'Gun',
+         'Skating and Skiing shoes', 'Gas stove', 'Donut', 'Bow Tie', 'Carrot',
+         'Toilet', 'Kite', 'Strawberry', 'Other Balls', 'Shovel', 'Pepper',
+         'Computer Box', 'Toilet Paper', 'Cleaning Products', 'Chopsticks',
+         'Microwave', 'Pigeon', 'Baseball', 'Cutting/chopping Board',
+         'Coffee Table', 'Side Table', 'Scissors', 'Marker', 'Pie', 'Ladder',
+         'Snowboard', 'Cookies', 'Radiator', 'Fire Hydrant', 'Basketball',
+         'Zebra', 'Grape', 'Giraffe', 'Potato', 'Sausage', 'Tricycle',
+         'Violin', 'Egg', 'Fire Extinguisher', 'Candy', 'Fire Truck',
+         'Billards', 'Converter', 'Bathtub', 'Wheelchair', 'Golf Club',
+         'Briefcase', 'Cucumber', 'Cigar/Cigarette ', 'Paint Brush', 'Pear',
+         'Heavy Truck', 'Hamburger', 'Extractor', 'Extention Cord', 'Tong',
+         'Tennis Racket', 'Folder', 'American Football', 'earphone', 'Mask',
+         'Kettle', 'Tennis', 'Ship', 'Swing', 'Coffee Machine', 'Slide',
+         'Carriage', 'Onion', 'Green beans', 'Projector', 'Frisbee',
+         'Washing Machine/Drying Machine', 'Chicken', 'Printer', 'Watermelon',
+         'Saxophone', 'Tissue', 'Toothbrush', 'Ice cream', 'Hotair ballon',
+         'Cello', 'French Fries', 'Scale', 'Trophy', 'Cabbage', 'Hot dog',
+         'Blender', 'Peach', 'Rice', 'Wallet/Purse', 'Volleyball', 'Deer',
+         'Goose', 'Tape', 'Tablet', 'Cosmetics', 'Trumpet', 'Pineapple',
+         'Golf Ball', 'Ambulance', 'Parking meter', 'Mango', 'Key', 'Hurdle',
+         'Fishing Rod', 'Medal', 'Flute', 'Brush', 'Penguin', 'Megaphone',
+         'Corn', 'Lettuce', 'Garlic', 'Swan', 'Helicopter', 'Green Onion',
+         'Sandwich', 'Nuts', 'Speed Limit Sign', 'Induction Cooker', 'Broom',
+         'Trombone', 'Plum', 'Rickshaw', 'Goldfish', 'Kiwi fruit',
+         'Router/modem', 'Poker Card', 'Toaster', 'Shrimp', 'Sushi', 'Cheese',
+         'Notepaper', 'Cherry', 'Pliers', 'CD', 'Pasta', 'Hammer', 'Cue',
+         'Avocado', 'Hamimelon', 'Flask', 'Mushroon', 'Screwdriver', 'Soap',
+         'Recorder', 'Bear', 'Eggplant', 'Board Eraser', 'Coconut',
+         'Tape Measur/ Ruler', 'Pig', 'Showerhead', 'Globe', 'Chips', 'Steak',
+         'Crosswalk Sign', 'Stapler', 'Campel', 'Formula 1 ', 'Pomegranate',
+         'Dishwasher', 'Crab', 'Hoverboard', 'Meat ball', 'Rice Cooker',
+         'Tuba', 'Calculator', 'Papaya', 'Antelope', 'Parrot', 'Seal',
+         'Buttefly', 'Dumbbell', 'Donkey', 'Lion', 'Urinal', 'Dolphin',
+         'Electric Drill', 'Hair Dryer', 'Egg tart', 'Jellyfish', 'Treadmill',
+         'Lighter', 'Grapefruit', 'Game board', 'Mop', 'Radish', 'Baozi',
+         'Target', 'French', 'Spring Rolls', 'Monkey', 'Rabbit', 'Pencil Case',
+         'Yak', 'Red Cabbage', 'Binoculars', 'Asparagus', 'Barbell', 'Scallop',
+         'Noddles', 'Comb', 'Dumpling', 'Oyster', 'Table Teniis paddle',
+         'Cosmetics Brush/Eyeliner Pencil', 'Chainsaw', 'Eraser', 'Lobster',
+         'Durian', 'Okra', 'Lipstick', 'Cosmetics Mirror', 'Curling',
+         'Table Tennis '),
+        'palette':
+        None
+    }
+
+    COCOAPI = COCO
+    # ann_id is unique in coco dataset.
+    ANN_ID_UNIQUE = True
+
+    def load_data_list(self) -> List[dict]:
+        """Load annotations from an annotation file named as ``self.ann_file``
+
+        Returns:
+            List[dict]: A list of annotation.
+        """  # noqa: E501
+        with get_local_path(
+                self.ann_file, backend_args=self.backend_args) as local_path:
+            self.coco = self.COCOAPI(local_path)
+        # The order of returned `cat_ids` will not
+        # change with the order of the `classes`
+        self.cat_ids = self.coco.get_cat_ids(
+            cat_names=self.metainfo['classes'])
+        self.cat2label = {cat_id: i for i, cat_id in enumerate(self.cat_ids)}
+        self.cat_img_map = copy.deepcopy(self.coco.cat_img_map)
+
+        img_ids = self.coco.get_img_ids()
+        data_list = []
+        total_ann_ids = []
+        for img_id in img_ids:
+            raw_img_info = self.coco.load_imgs([img_id])[0]
+            raw_img_info['img_id'] = img_id
+
+            ann_ids = self.coco.get_ann_ids(img_ids=[img_id])
+            raw_ann_info = self.coco.load_anns(ann_ids)
+            total_ann_ids.extend(ann_ids)
+
+            # file_name should be `patchX/xxx.jpg`
+            file_name = osp.join(
+                osp.split(osp.split(raw_img_info['file_name'])[0])[-1],
+                osp.split(raw_img_info['file_name'])[-1])
+
+            if file_name in objv2_ignore_list:
+                continue
+
+            raw_img_info['file_name'] = file_name
+            parsed_data_info = self.parse_data_info({
+                'raw_ann_info':
+                raw_ann_info,
+                'raw_img_info':
+                raw_img_info
+            })
+            data_list.append(parsed_data_info)
+        if self.ANN_ID_UNIQUE:
+            assert len(set(total_ann_ids)) == len(
+                total_ann_ids
+            ), f"Annotation ids in '{self.ann_file}' are not unique!"
+
+        del self.coco
+
+        return data_list
diff --git a/mmdetection/mmdet/datasets/odvg.py b/mmdetection/mmdet/datasets/odvg.py
new file mode 100644
index 00000000..c73865f2
--- /dev/null
+++ b/mmdetection/mmdet/datasets/odvg.py
@@ -0,0 +1,106 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import json
+import os.path as osp
+from typing import List, Optional
+
+from mmengine.fileio import get_local_path
+
+from mmdet.registry import DATASETS
+from .base_det_dataset import BaseDetDataset
+
+
+@DATASETS.register_module()
+class ODVGDataset(BaseDetDataset):
+    """object detection and visual grounding dataset."""
+
+    def __init__(self,
+                 *args,
+                 data_root: str = '',
+                 label_map_file: Optional[str] = None,
+                 need_text: bool = True,
+                 **kwargs) -> None:
+        self.dataset_mode = 'VG'
+        self.need_text = need_text
+        if label_map_file:
+            label_map_file = osp.join(data_root, label_map_file)
+            with open(label_map_file, 'r') as file:
+                self.label_map = json.load(file)
+            self.dataset_mode = 'OD'
+        super().__init__(*args, data_root=data_root, **kwargs)
+        assert self.return_classes is True
+
+    def load_data_list(self) -> List[dict]:
+        with get_local_path(
+                self.ann_file, backend_args=self.backend_args) as local_path:
+            with open(local_path, 'r') as f:
+                data_list = [json.loads(line) for line in f]
+
+        out_data_list = []
+        for data in data_list:
+            data_info = {}
+            img_path = osp.join(self.data_prefix['img'], data['filename'])
+            data_info['img_path'] = img_path
+            data_info['height'] = data['height']
+            data_info['width'] = data['width']
+            if self.dataset_mode == 'OD':
+                if self.need_text:
+                    data_info['text'] = self.label_map
+                anno = data.get('detection', {})
+                instances = [obj for obj in anno.get('instances', [])]
+                bboxes = [obj['bbox'] for obj in instances]
+                bbox_labels = [str(obj['label']) for obj in instances]
+
+                instances = []
+                for bbox, label in zip(bboxes, bbox_labels):
+                    instance = {}
+                    x1, y1, x2, y2 = bbox
+                    inter_w = max(0, min(x2, data['width']) - max(x1, 0))
+                    inter_h = max(0, min(y2, data['height']) - max(y1, 0))
+                    if inter_w * inter_h == 0:
+                        continue
+                    if (x2 - x1) < 1 or (y2 - y1) < 1:
+                        continue
+                    instance['ignore_flag'] = 0
+                    instance['bbox'] = bbox
+                    instance['bbox_label'] = int(label)
+                    instances.append(instance)
+                data_info['instances'] = instances
+                data_info['dataset_mode'] = self.dataset_mode
+                out_data_list.append(data_info)
+            else:
+                anno = data['grounding']
+                data_info['text'] = anno['caption']
+                regions = anno['regions']
+
+                instances = []
+                phrases = {}
+                for i, region in enumerate(regions):
+                    bbox = region['bbox']
+                    phrase = region['phrase']
+                    tokens_positive = region['tokens_positive']
+                    if not isinstance(bbox[0], list):
+                        bbox = [bbox]
+                    for box in bbox:
+                        instance = {}
+                        x1, y1, x2, y2 = box
+                        inter_w = max(0, min(x2, data['width']) - max(x1, 0))
+                        inter_h = max(0, min(y2, data['height']) - max(y1, 0))
+                        if inter_w * inter_h == 0:
+                            continue
+                        if (x2 - x1) < 1 or (y2 - y1) < 1:
+                            continue
+                        instance['ignore_flag'] = 0
+                        instance['bbox'] = box
+                        instance['bbox_label'] = i
+                        phrases[i] = {
+                            'phrase': phrase,
+                            'tokens_positive': tokens_positive
+                        }
+                        instances.append(instance)
+                data_info['instances'] = instances
+                data_info['phrases'] = phrases
+                data_info['dataset_mode'] = self.dataset_mode
+                out_data_list.append(data_info)
+
+        del data_list
+        return out_data_list
diff --git a/mmdetection/mmdet/datasets/openimages.py b/mmdetection/mmdet/datasets/openimages.py
new file mode 100644
index 00000000..a3c6c8ec
--- /dev/null
+++ b/mmdetection/mmdet/datasets/openimages.py
@@ -0,0 +1,484 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import csv
+import os.path as osp
+from collections import defaultdict
+from typing import Dict, List, Optional
+
+import numpy as np
+from mmengine.fileio import get_local_path, load
+from mmengine.utils import is_abs
+
+from mmdet.registry import DATASETS
+from .base_det_dataset import BaseDetDataset
+
+
+@DATASETS.register_module()
+class OpenImagesDataset(BaseDetDataset):
+    """Open Images dataset for detection.
+
+    Args:
+        ann_file (str): Annotation file path.
+        label_file (str): File path of the label description file that
+            maps the classes names in MID format to their short
+            descriptions.
+        meta_file (str): File path to get image metas.
+        hierarchy_file (str): The file path of the class hierarchy.
+        image_level_ann_file (str): Human-verified image level annotation,
+            which is used in evaluation.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+    """
+
+    METAINFO: dict = dict(dataset_type='oid_v6')
+
+    def __init__(self,
+                 label_file: str,
+                 meta_file: str,
+                 hierarchy_file: str,
+                 image_level_ann_file: Optional[str] = None,
+                 **kwargs) -> None:
+        self.label_file = label_file
+        self.meta_file = meta_file
+        self.hierarchy_file = hierarchy_file
+        self.image_level_ann_file = image_level_ann_file
+        super().__init__(**kwargs)
+
+    def load_data_list(self) -> List[dict]:
+        """Load annotations from an annotation file named as ``self.ann_file``
+
+        Returns:
+            List[dict]: A list of annotation.
+        """
+        classes_names, label_id_mapping = self._parse_label_file(
+            self.label_file)
+        self._metainfo['classes'] = classes_names
+        self.label_id_mapping = label_id_mapping
+
+        if self.image_level_ann_file is not None:
+            img_level_anns = self._parse_img_level_ann(
+                self.image_level_ann_file)
+        else:
+            img_level_anns = None
+
+        # OpenImagesMetric can get the relation matrix from the dataset meta
+        relation_matrix = self._get_relation_matrix(self.hierarchy_file)
+        self._metainfo['RELATION_MATRIX'] = relation_matrix
+
+        data_list = []
+        with get_local_path(
+                self.ann_file, backend_args=self.backend_args) as local_path:
+            with open(local_path, 'r') as f:
+                reader = csv.reader(f)
+                last_img_id = None
+                instances = []
+                for i, line in enumerate(reader):
+                    if i == 0:
+                        continue
+                    img_id = line[0]
+                    if last_img_id is None:
+                        last_img_id = img_id
+                    label_id = line[2]
+                    assert label_id in self.label_id_mapping
+                    label = int(self.label_id_mapping[label_id])
+                    bbox = [
+                        float(line[4]),  # xmin
+                        float(line[6]),  # ymin
+                        float(line[5]),  # xmax
+                        float(line[7])  # ymax
+                    ]
+                    is_occluded = True if int(line[8]) == 1 else False
+                    is_truncated = True if int(line[9]) == 1 else False
+                    is_group_of = True if int(line[10]) == 1 else False
+                    is_depiction = True if int(line[11]) == 1 else False
+                    is_inside = True if int(line[12]) == 1 else False
+
+                    instance = dict(
+                        bbox=bbox,
+                        bbox_label=label,
+                        ignore_flag=0,
+                        is_occluded=is_occluded,
+                        is_truncated=is_truncated,
+                        is_group_of=is_group_of,
+                        is_depiction=is_depiction,
+                        is_inside=is_inside)
+                    last_img_path = osp.join(self.data_prefix['img'],
+                                             f'{last_img_id}.jpg')
+                    if img_id != last_img_id:
+                        # switch to a new image, record previous image's data.
+                        data_info = dict(
+                            img_path=last_img_path,
+                            img_id=last_img_id,
+                            instances=instances,
+                        )
+                        data_list.append(data_info)
+                        instances = []
+                    instances.append(instance)
+                    last_img_id = img_id
+                data_list.append(
+                    dict(
+                        img_path=last_img_path,
+                        img_id=last_img_id,
+                        instances=instances,
+                    ))
+
+        # add image metas to data list
+        img_metas = load(
+            self.meta_file, file_format='pkl', backend_args=self.backend_args)
+        assert len(img_metas) == len(data_list)
+        for i, meta in enumerate(img_metas):
+            img_id = data_list[i]['img_id']
+            assert f'{img_id}.jpg' == osp.split(meta['filename'])[-1]
+            h, w = meta['ori_shape'][:2]
+            data_list[i]['height'] = h
+            data_list[i]['width'] = w
+            # denormalize bboxes
+            for j in range(len(data_list[i]['instances'])):
+                data_list[i]['instances'][j]['bbox'][0] *= w
+                data_list[i]['instances'][j]['bbox'][2] *= w
+                data_list[i]['instances'][j]['bbox'][1] *= h
+                data_list[i]['instances'][j]['bbox'][3] *= h
+            # add image-level annotation
+            if img_level_anns is not None:
+                img_labels = []
+                confidences = []
+                img_ann_list = img_level_anns.get(img_id, [])
+                for ann in img_ann_list:
+                    img_labels.append(int(ann['image_level_label']))
+                    confidences.append(float(ann['confidence']))
+                data_list[i]['image_level_labels'] = np.array(
+                    img_labels, dtype=np.int64)
+                data_list[i]['confidences'] = np.array(
+                    confidences, dtype=np.float32)
+        return data_list
+
+    def _parse_label_file(self, label_file: str) -> tuple:
+        """Get classes name and index mapping from cls-label-description file.
+
+        Args:
+            label_file (str): File path of the label description file that
+                maps the classes names in MID format to their short
+                descriptions.
+
+        Returns:
+            tuple: Class name of OpenImages.
+        """
+
+        index_list = []
+        classes_names = []
+        with get_local_path(
+                label_file, backend_args=self.backend_args) as local_path:
+            with open(local_path, 'r') as f:
+                reader = csv.reader(f)
+                for line in reader:
+                    # self.cat2label[line[0]] = line[1]
+                    classes_names.append(line[1])
+                    index_list.append(line[0])
+        index_mapping = {index: i for i, index in enumerate(index_list)}
+        return classes_names, index_mapping
+
+    def _parse_img_level_ann(self,
+                             img_level_ann_file: str) -> Dict[str, List[dict]]:
+        """Parse image level annotations from csv style ann_file.
+
+        Args:
+            img_level_ann_file (str): CSV style image level annotation
+                file path.
+
+        Returns:
+            Dict[str, List[dict]]: Annotations where item of the defaultdict
+            indicates an image, each of which has (n) dicts.
+            Keys of dicts are:
+
+                - `image_level_label` (int): Label id.
+                - `confidence` (float): Labels that are human-verified to be
+                  present in an image have confidence = 1 (positive labels).
+                  Labels that are human-verified to be absent from an image
+                  have confidence = 0 (negative labels). Machine-generated
+                  labels have fractional confidences, generally >= 0.5.
+                  The higher the confidence, the smaller the chance for
+                  the label to be a false positive.
+        """
+
+        item_lists = defaultdict(list)
+        with get_local_path(
+                img_level_ann_file,
+                backend_args=self.backend_args) as local_path:
+            with open(local_path, 'r') as f:
+                reader = csv.reader(f)
+                for i, line in enumerate(reader):
+                    if i == 0:
+                        continue
+                    img_id = line[0]
+                    item_lists[img_id].append(
+                        dict(
+                            image_level_label=int(
+                                self.label_id_mapping[line[2]]),
+                            confidence=float(line[3])))
+        return item_lists
+
+    def _get_relation_matrix(self, hierarchy_file: str) -> np.ndarray:
+        """Get the matrix of class hierarchy from the hierarchy file. Hierarchy
+        for 600 classes can be found at https://storage.googleapis.com/openimag
+        es/2018_04/bbox_labels_600_hierarchy_visualizer/circle.html.
+
+        Args:
+            hierarchy_file (str): File path to the hierarchy for classes.
+
+        Returns:
+            np.ndarray: The matrix of the corresponding relationship between
+            the parent class and the child class, of shape
+            (class_num, class_num).
+        """  # noqa
+
+        hierarchy = load(
+            hierarchy_file, file_format='json', backend_args=self.backend_args)
+        class_num = len(self._metainfo['classes'])
+        relation_matrix = np.eye(class_num, class_num)
+        relation_matrix = self._convert_hierarchy_tree(hierarchy,
+                                                       relation_matrix)
+        return relation_matrix
+
+    def _convert_hierarchy_tree(self,
+                                hierarchy_map: dict,
+                                relation_matrix: np.ndarray,
+                                parents: list = [],
+                                get_all_parents: bool = True) -> np.ndarray:
+        """Get matrix of the corresponding relationship between the parent
+        class and the child class.
+
+        Args:
+            hierarchy_map (dict): Including label name and corresponding
+                subcategory. Keys of dicts are:
+
+                - `LabeName` (str): Name of the label.
+                - `Subcategory` (dict | list): Corresponding subcategory(ies).
+            relation_matrix (ndarray): The matrix of the corresponding
+                relationship between the parent class and the child class,
+                of shape (class_num, class_num).
+            parents (list): Corresponding parent class.
+            get_all_parents (bool): Whether get all parent names.
+                Default: True
+
+        Returns:
+            ndarray: The matrix of the corresponding relationship between
+            the parent class and the child class, of shape
+            (class_num, class_num).
+        """
+
+        if 'Subcategory' in hierarchy_map:
+            for node in hierarchy_map['Subcategory']:
+                if 'LabelName' in node:
+                    children_name = node['LabelName']
+                    children_index = self.label_id_mapping[children_name]
+                    children = [children_index]
+                else:
+                    continue
+                if len(parents) > 0:
+                    for parent_index in parents:
+                        if get_all_parents:
+                            children.append(parent_index)
+                        relation_matrix[children_index, parent_index] = 1
+                relation_matrix = self._convert_hierarchy_tree(
+                    node, relation_matrix, parents=children)
+        return relation_matrix
+
+    def _join_prefix(self):
+        """Join ``self.data_root`` with annotation path."""
+        super()._join_prefix()
+        if not is_abs(self.label_file) and self.label_file:
+            self.label_file = osp.join(self.data_root, self.label_file)
+        if not is_abs(self.meta_file) and self.meta_file:
+            self.meta_file = osp.join(self.data_root, self.meta_file)
+        if not is_abs(self.hierarchy_file) and self.hierarchy_file:
+            self.hierarchy_file = osp.join(self.data_root, self.hierarchy_file)
+        if self.image_level_ann_file and not is_abs(self.image_level_ann_file):
+            self.image_level_ann_file = osp.join(self.data_root,
+                                                 self.image_level_ann_file)
+
+
+@DATASETS.register_module()
+class OpenImagesChallengeDataset(OpenImagesDataset):
+    """Open Images Challenge dataset for detection.
+
+    Args:
+        ann_file (str): Open Images Challenge box annotation in txt format.
+    """
+
+    METAINFO: dict = dict(dataset_type='oid_challenge')
+
+    def __init__(self, ann_file: str, **kwargs) -> None:
+        if not ann_file.endswith('txt'):
+            raise TypeError('The annotation file of Open Images Challenge '
+                            'should be a txt file.')
+
+        super().__init__(ann_file=ann_file, **kwargs)
+
+    def load_data_list(self) -> List[dict]:
+        """Load annotations from an annotation file named as ``self.ann_file``
+
+        Returns:
+            List[dict]: A list of annotation.
+        """
+        classes_names, label_id_mapping = self._parse_label_file(
+            self.label_file)
+        self._metainfo['classes'] = classes_names
+        self.label_id_mapping = label_id_mapping
+
+        if self.image_level_ann_file is not None:
+            img_level_anns = self._parse_img_level_ann(
+                self.image_level_ann_file)
+        else:
+            img_level_anns = None
+
+        # OpenImagesMetric can get the relation matrix from the dataset meta
+        relation_matrix = self._get_relation_matrix(self.hierarchy_file)
+        self._metainfo['RELATION_MATRIX'] = relation_matrix
+
+        data_list = []
+        with get_local_path(
+                self.ann_file, backend_args=self.backend_args) as local_path:
+            with open(local_path, 'r') as f:
+                lines = f.readlines()
+        i = 0
+        while i < len(lines):
+            instances = []
+            filename = lines[i].rstrip()
+            i += 2
+            img_gt_size = int(lines[i])
+            i += 1
+            for j in range(img_gt_size):
+                sp = lines[i + j].split()
+                instances.append(
+                    dict(
+                        bbox=[
+                            float(sp[1]),
+                            float(sp[2]),
+                            float(sp[3]),
+                            float(sp[4])
+                        ],
+                        bbox_label=int(sp[0]) - 1,  # labels begin from 1
+                        ignore_flag=0,
+                        is_group_ofs=True if int(sp[5]) == 1 else False))
+            i += img_gt_size
+            data_list.append(
+                dict(
+                    img_path=osp.join(self.data_prefix['img'], filename),
+                    instances=instances,
+                ))
+
+        # add image metas to data list
+        img_metas = load(
+            self.meta_file, file_format='pkl', backend_args=self.backend_args)
+        assert len(img_metas) == len(data_list)
+        for i, meta in enumerate(img_metas):
+            img_id = osp.split(data_list[i]['img_path'])[-1][:-4]
+            assert img_id == osp.split(meta['filename'])[-1][:-4]
+            h, w = meta['ori_shape'][:2]
+            data_list[i]['height'] = h
+            data_list[i]['width'] = w
+            data_list[i]['img_id'] = img_id
+            # denormalize bboxes
+            for j in range(len(data_list[i]['instances'])):
+                data_list[i]['instances'][j]['bbox'][0] *= w
+                data_list[i]['instances'][j]['bbox'][2] *= w
+                data_list[i]['instances'][j]['bbox'][1] *= h
+                data_list[i]['instances'][j]['bbox'][3] *= h
+            # add image-level annotation
+            if img_level_anns is not None:
+                img_labels = []
+                confidences = []
+                img_ann_list = img_level_anns.get(img_id, [])
+                for ann in img_ann_list:
+                    img_labels.append(int(ann['image_level_label']))
+                    confidences.append(float(ann['confidence']))
+                data_list[i]['image_level_labels'] = np.array(
+                    img_labels, dtype=np.int64)
+                data_list[i]['confidences'] = np.array(
+                    confidences, dtype=np.float32)
+        return data_list
+
+    def _parse_label_file(self, label_file: str) -> tuple:
+        """Get classes name and index mapping from cls-label-description file.
+
+        Args:
+            label_file (str): File path of the label description file that
+                maps the classes names in MID format to their short
+                descriptions.
+
+        Returns:
+            tuple: Class name of OpenImages.
+        """
+        label_list = []
+        id_list = []
+        index_mapping = {}
+        with get_local_path(
+                label_file, backend_args=self.backend_args) as local_path:
+            with open(local_path, 'r') as f:
+                reader = csv.reader(f)
+                for line in reader:
+                    label_name = line[0]
+                    label_id = int(line[2])
+                    label_list.append(line[1])
+                    id_list.append(label_id)
+                    index_mapping[label_name] = label_id - 1
+        indexes = np.argsort(id_list)
+        classes_names = []
+        for index in indexes:
+            classes_names.append(label_list[index])
+        return classes_names, index_mapping
+
+    def _parse_img_level_ann(self, image_level_ann_file):
+        """Parse image level annotations from csv style ann_file.
+
+        Args:
+            image_level_ann_file (str): CSV style image level annotation
+                file path.
+
+        Returns:
+            defaultdict[list[dict]]: Annotations where item of the defaultdict
+            indicates an image, each of which has (n) dicts.
+            Keys of dicts are:
+
+                - `image_level_label` (int): of shape 1.
+                - `confidence` (float): of shape 1.
+        """
+
+        item_lists = defaultdict(list)
+        with get_local_path(
+                image_level_ann_file,
+                backend_args=self.backend_args) as local_path:
+            with open(local_path, 'r') as f:
+                reader = csv.reader(f)
+                i = -1
+                for line in reader:
+                    i += 1
+                    if i == 0:
+                        continue
+                    else:
+                        img_id = line[0]
+                        label_id = line[1]
+                        assert label_id in self.label_id_mapping
+                        image_level_label = int(
+                            self.label_id_mapping[label_id])
+                        confidence = float(line[2])
+                        item_lists[img_id].append(
+                            dict(
+                                image_level_label=image_level_label,
+                                confidence=confidence))
+        return item_lists
+
+    def _get_relation_matrix(self, hierarchy_file: str) -> np.ndarray:
+        """Get the matrix of class hierarchy from the hierarchy file.
+
+        Args:
+            hierarchy_file (str): File path to the hierarchy for classes.
+
+        Returns:
+            np.ndarray: The matrix of the corresponding
+            relationship between the parent class and the child class,
+            of shape (class_num, class_num).
+        """
+        with get_local_path(
+                hierarchy_file, backend_args=self.backend_args) as local_path:
+            class_label_tree = np.load(local_path, allow_pickle=True)
+        return class_label_tree[1:, 1:]
diff --git a/mmdetection/mmdet/datasets/refcoco.py b/mmdetection/mmdet/datasets/refcoco.py
new file mode 100644
index 00000000..0dae75fd
--- /dev/null
+++ b/mmdetection/mmdet/datasets/refcoco.py
@@ -0,0 +1,163 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import collections
+import os.path as osp
+import random
+from typing import Dict, List
+
+import mmengine
+from mmengine.dataset import BaseDataset
+
+from mmdet.registry import DATASETS
+
+
+@DATASETS.register_module()
+class RefCocoDataset(BaseDataset):
+    """RefCOCO dataset.
+
+    The `Refcoco` and `Refcoco+` dataset is based on
+    `ReferItGame: Referring to Objects in Photographs of Natural Scenes
+    `_.
+
+    The `Refcocog` dataset is based on
+    `Generation and Comprehension of Unambiguous Object Descriptions
+    `_.
+
+    Args:
+        ann_file (str): Annotation file path.
+        data_root (str): The root directory for ``data_prefix`` and
+            ``ann_file``. Defaults to ''.
+        data_prefix (str): Prefix for training data.
+        split_file (str): Split file path.
+        split (str): Split name. Defaults to 'train'.
+        text_mode (str): Text mode. Defaults to 'random'.
+        **kwargs: Other keyword arguments in :class:`BaseDataset`.
+    """
+
+    def __init__(self,
+                 data_root: str,
+                 ann_file: str,
+                 split_file: str,
+                 data_prefix: Dict,
+                 split: str = 'train',
+                 text_mode: str = 'random',
+                 **kwargs):
+        self.split_file = split_file
+        self.split = split
+
+        assert text_mode in ['original', 'random', 'concat', 'select_first']
+        self.text_mode = text_mode
+        super().__init__(
+            data_root=data_root,
+            data_prefix=data_prefix,
+            ann_file=ann_file,
+            **kwargs,
+        )
+
+    def _join_prefix(self):
+        if not mmengine.is_abs(self.split_file) and self.split_file:
+            self.split_file = osp.join(self.data_root, self.split_file)
+
+        return super()._join_prefix()
+
+    def _init_refs(self):
+        """Initialize the refs for RefCOCO."""
+        anns, imgs = {}, {}
+        for ann in self.instances['annotations']:
+            anns[ann['id']] = ann
+        for img in self.instances['images']:
+            imgs[img['id']] = img
+
+        refs, ref_to_ann = {}, {}
+        for ref in self.splits:
+            # ids
+            ref_id = ref['ref_id']
+            ann_id = ref['ann_id']
+            # add mapping related to ref
+            refs[ref_id] = ref
+            ref_to_ann[ref_id] = anns[ann_id]
+
+        self.refs = refs
+        self.ref_to_ann = ref_to_ann
+
+    def load_data_list(self) -> List[dict]:
+        """Load data list."""
+        self.splits = mmengine.load(self.split_file, file_format='pkl')
+        self.instances = mmengine.load(self.ann_file, file_format='json')
+        self._init_refs()
+        img_prefix = self.data_prefix['img_path']
+
+        ref_ids = [
+            ref['ref_id'] for ref in self.splits if ref['split'] == self.split
+        ]
+        full_anno = []
+        for ref_id in ref_ids:
+            ref = self.refs[ref_id]
+            ann = self.ref_to_ann[ref_id]
+            ann.update(ref)
+            full_anno.append(ann)
+
+        image_id_list = []
+        final_anno = {}
+        for anno in full_anno:
+            image_id_list.append(anno['image_id'])
+            final_anno[anno['ann_id']] = anno
+        annotations = [value for key, value in final_anno.items()]
+
+        coco_train_id = []
+        image_annot = {}
+        for i in range(len(self.instances['images'])):
+            coco_train_id.append(self.instances['images'][i]['id'])
+            image_annot[self.instances['images'][i]
+                        ['id']] = self.instances['images'][i]
+
+        images = []
+        for image_id in list(set(image_id_list)):
+            images += [image_annot[image_id]]
+
+        data_list = []
+
+        grounding_dict = collections.defaultdict(list)
+        for anno in annotations:
+            image_id = int(anno['image_id'])
+            grounding_dict[image_id].append(anno)
+
+        join_path = mmengine.fileio.get_file_backend(img_prefix).join_path
+        for image in images:
+            img_id = image['id']
+            instances = []
+            sentences = []
+            for grounding_anno in grounding_dict[img_id]:
+                texts = [x['raw'].lower() for x in grounding_anno['sentences']]
+                # random select one text
+                if self.text_mode == 'random':
+                    idx = random.randint(0, len(texts) - 1)
+                    text = [texts[idx]]
+                # concat all texts
+                elif self.text_mode == 'concat':
+                    text = [''.join(texts)]
+                # select the first text
+                elif self.text_mode == 'select_first':
+                    text = [texts[0]]
+                # use all texts
+                elif self.text_mode == 'original':
+                    text = texts
+                else:
+                    raise ValueError(f'Invalid text mode "{self.text_mode}".')
+                ins = [{
+                    'mask': grounding_anno['segmentation'],
+                    'ignore_flag': 0
+                }] * len(text)
+                instances.extend(ins)
+                sentences.extend(text)
+            data_info = {
+                'img_path': join_path(img_prefix, image['file_name']),
+                'img_id': img_id,
+                'instances': instances,
+                'text': sentences
+            }
+            data_list.append(data_info)
+
+        if len(data_list) == 0:
+            raise ValueError(f'No sample in split "{self.split}".')
+
+        return data_list
diff --git a/mmdetection/mmdet/datasets/reid_dataset.py b/mmdetection/mmdet/datasets/reid_dataset.py
new file mode 100644
index 00000000..1eed3ee4
--- /dev/null
+++ b/mmdetection/mmdet/datasets/reid_dataset.py
@@ -0,0 +1,127 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import os.path as osp
+from collections import defaultdict
+from typing import Any, Dict, List
+
+import numpy as np
+from mmengine.dataset import BaseDataset
+from mmengine.utils import check_file_exist
+
+from mmdet.registry import DATASETS
+
+
+@DATASETS.register_module()
+class ReIDDataset(BaseDataset):
+    """Dataset for ReID.
+
+    Args:
+        triplet_sampler (dict, optional): The sampler for hard mining
+            triplet loss. Defaults to None.
+        keys: num_ids (int): The number of person ids.
+              ins_per_id (int): The number of image for each person.
+    """
+
+    def __init__(self, triplet_sampler: dict = None, *args, **kwargs):
+        self.triplet_sampler = triplet_sampler
+        super().__init__(*args, **kwargs)
+
+    def load_data_list(self) -> List[dict]:
+        """Load annotations from an annotation file named as ''self.ann_file''.
+
+        Returns:
+              list[dict]: A list of annotation.
+        """
+        assert isinstance(self.ann_file, str)
+        check_file_exist(self.ann_file)
+        data_list = []
+        with open(self.ann_file) as f:
+            samples = [x.strip().split(' ') for x in f.readlines()]
+            for filename, gt_label in samples:
+                info = dict(img_prefix=self.data_prefix)
+                if self.data_prefix['img_path'] is not None:
+                    info['img_path'] = osp.join(self.data_prefix['img_path'],
+                                                filename)
+                else:
+                    info['img_path'] = filename
+                info['gt_label'] = np.array(gt_label, dtype=np.int64)
+                data_list.append(info)
+        self._parse_ann_info(data_list)
+        return data_list
+
+    def _parse_ann_info(self, data_list: List[dict]):
+        """Parse person id annotations."""
+        index_tmp_dic = defaultdict(list)  # pid->[idx1,...,idxN]
+        self.index_dic = dict()  # pid->array([idx1,...,idxN])
+        for idx, info in enumerate(data_list):
+            pid = info['gt_label']
+            index_tmp_dic[int(pid)].append(idx)
+        for pid, idxs in index_tmp_dic.items():
+            self.index_dic[pid] = np.asarray(idxs, dtype=np.int64)
+        self.pids = np.asarray(list(self.index_dic.keys()), dtype=np.int64)
+
+    def prepare_data(self, idx: int) -> Any:
+        """Get data processed by ''self.pipeline''.
+
+        Args:
+            idx (int): The index of ''data_info''
+
+        Returns:
+            Any: Depends on ''self.pipeline''
+        """
+        data_info = self.get_data_info(idx)
+        if self.triplet_sampler is not None:
+            img_info = self.triplet_sampling(data_info['gt_label'],
+                                             **self.triplet_sampler)
+            data_info = copy.deepcopy(img_info)  # triplet -> list
+        else:
+            data_info = copy.deepcopy(data_info)  # no triplet -> dict
+        return self.pipeline(data_info)
+
+    def triplet_sampling(self,
+                         pos_pid,
+                         num_ids: int = 8,
+                         ins_per_id: int = 4) -> Dict:
+        """Triplet sampler for hard mining triplet loss. First, for one
+        pos_pid, random sample ins_per_id images with same person id.
+
+        Then, random sample num_ids - 1 images for each negative id.
+        Finally, random sample ins_per_id images for each negative id.
+
+        Args:
+            pos_pid (ndarray): The person id of the anchor.
+            num_ids (int): The number of person ids.
+            ins_per_id (int): The number of images for each person.
+
+        Returns:
+            Dict: Annotation information of num_ids X ins_per_id images.
+        """
+        assert len(self.pids) >= num_ids, \
+            'The number of person ids in the training set must ' \
+            'be greater than the number of person ids in the sample.'
+
+        pos_idxs = self.index_dic[int(
+            pos_pid)]  # all positive idxs for pos_pid
+        idxs_list = []
+        # select positive samplers
+        idxs_list.extend(pos_idxs[np.random.choice(
+            pos_idxs.shape[0], ins_per_id, replace=True)])
+        # select negative ids
+        neg_pids = np.random.choice(
+            [i for i, _ in enumerate(self.pids) if i != pos_pid],
+            num_ids - 1,
+            replace=False)
+        # select negative samplers for each negative id
+        for neg_pid in neg_pids:
+            neg_idxs = self.index_dic[neg_pid]
+            idxs_list.extend(neg_idxs[np.random.choice(
+                neg_idxs.shape[0], ins_per_id, replace=True)])
+        # return the final triplet batch
+        triplet_img_infos = []
+        for idx in idxs_list:
+            triplet_img_infos.append(copy.deepcopy(self.get_data_info(idx)))
+        # Collect data_list scatters (list of dict -> dict of list)
+        out = dict()
+        for key in triplet_img_infos[0].keys():
+            out[key] = [_info[key] for _info in triplet_img_infos]
+        return out
diff --git a/mmdetection/mmdet/datasets/samplers/__init__.py b/mmdetection/mmdet/datasets/samplers/__init__.py
new file mode 100644
index 00000000..9ea0e4cb
--- /dev/null
+++ b/mmdetection/mmdet/datasets/samplers/__init__.py
@@ -0,0 +1,16 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .batch_sampler import (AspectRatioBatchSampler,
+                            MultiDataAspectRatioBatchSampler,
+                            TrackAspectRatioBatchSampler)
+from .class_aware_sampler import ClassAwareSampler
+from .custom_sample_size_sampler import CustomSampleSizeSampler
+from .multi_data_sampler import MultiDataSampler
+from .multi_source_sampler import GroupMultiSourceSampler, MultiSourceSampler
+from .track_img_sampler import TrackImgSampler
+
+__all__ = [
+    'ClassAwareSampler', 'AspectRatioBatchSampler', 'MultiSourceSampler',
+    'GroupMultiSourceSampler', 'TrackImgSampler',
+    'TrackAspectRatioBatchSampler', 'MultiDataSampler',
+    'MultiDataAspectRatioBatchSampler', 'CustomSampleSizeSampler'
+]
diff --git a/mmdetection/mmdet/datasets/samplers/batch_sampler.py b/mmdetection/mmdet/datasets/samplers/batch_sampler.py
new file mode 100644
index 00000000..c17789c4
--- /dev/null
+++ b/mmdetection/mmdet/datasets/samplers/batch_sampler.py
@@ -0,0 +1,193 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Sequence
+
+from torch.utils.data import BatchSampler, Sampler
+
+from mmdet.datasets.samplers.track_img_sampler import TrackImgSampler
+from mmdet.registry import DATA_SAMPLERS
+
+
+# TODO: maybe replace with a data_loader wrapper
+@DATA_SAMPLERS.register_module()
+class AspectRatioBatchSampler(BatchSampler):
+    """A sampler wrapper for grouping images with similar aspect ratio (< 1 or.
+
+    >= 1) into a same batch.
+
+    Args:
+        sampler (Sampler): Base sampler.
+        batch_size (int): Size of mini-batch.
+        drop_last (bool): If ``True``, the sampler will drop the last batch if
+            its size would be less than ``batch_size``.
+    """
+
+    def __init__(self,
+                 sampler: Sampler,
+                 batch_size: int,
+                 drop_last: bool = False) -> None:
+        if not isinstance(sampler, Sampler):
+            raise TypeError('sampler should be an instance of ``Sampler``, '
+                            f'but got {sampler}')
+        if not isinstance(batch_size, int) or batch_size <= 0:
+            raise ValueError('batch_size should be a positive integer value, '
+                             f'but got batch_size={batch_size}')
+        self.sampler = sampler
+        self.batch_size = batch_size
+        self.drop_last = drop_last
+        # two groups for w < h and w >= h
+        self._aspect_ratio_buckets = [[] for _ in range(2)]
+
+    def __iter__(self) -> Sequence[int]:
+        for idx in self.sampler:
+            data_info = self.sampler.dataset.get_data_info(idx)
+            width, height = data_info['width'], data_info['height']
+            bucket_id = 0 if width < height else 1
+            bucket = self._aspect_ratio_buckets[bucket_id]
+            bucket.append(idx)
+            # yield a batch of indices in the same aspect ratio group
+            if len(bucket) == self.batch_size:
+                yield bucket[:]
+                del bucket[:]
+
+        # yield the rest data and reset the bucket
+        left_data = self._aspect_ratio_buckets[0] + self._aspect_ratio_buckets[
+            1]
+        self._aspect_ratio_buckets = [[] for _ in range(2)]
+        while len(left_data) > 0:
+            if len(left_data) <= self.batch_size:
+                if not self.drop_last:
+                    yield left_data[:]
+                left_data = []
+            else:
+                yield left_data[:self.batch_size]
+                left_data = left_data[self.batch_size:]
+
+    def __len__(self) -> int:
+        if self.drop_last:
+            return len(self.sampler) // self.batch_size
+        else:
+            return (len(self.sampler) + self.batch_size - 1) // self.batch_size
+
+
+@DATA_SAMPLERS.register_module()
+class TrackAspectRatioBatchSampler(AspectRatioBatchSampler):
+    """A sampler wrapper for grouping images with similar aspect ratio (< 1 or.
+
+    >= 1) into a same batch.
+
+    Args:
+        sampler (Sampler): Base sampler.
+        batch_size (int): Size of mini-batch.
+        drop_last (bool): If ``True``, the sampler will drop the last batch if
+            its size would be less than ``batch_size``.
+    """
+
+    def __iter__(self) -> Sequence[int]:
+        for idx in self.sampler:
+            # hard code to solve TrackImgSampler
+            if isinstance(self.sampler, TrackImgSampler):
+                video_idx, _ = idx
+            else:
+                video_idx = idx
+            # video_idx
+            data_info = self.sampler.dataset.get_data_info(video_idx)
+            # data_info {video_id, images, video_length}
+            img_data_info = data_info['images'][0]
+            width, height = img_data_info['width'], img_data_info['height']
+            bucket_id = 0 if width < height else 1
+            bucket = self._aspect_ratio_buckets[bucket_id]
+            bucket.append(idx)
+            # yield a batch of indices in the same aspect ratio group
+            if len(bucket) == self.batch_size:
+                yield bucket[:]
+                del bucket[:]
+
+        # yield the rest data and reset the bucket
+        left_data = self._aspect_ratio_buckets[0] + self._aspect_ratio_buckets[
+            1]
+        self._aspect_ratio_buckets = [[] for _ in range(2)]
+        while len(left_data) > 0:
+            if len(left_data) <= self.batch_size:
+                if not self.drop_last:
+                    yield left_data[:]
+                left_data = []
+            else:
+                yield left_data[:self.batch_size]
+                left_data = left_data[self.batch_size:]
+
+
+@DATA_SAMPLERS.register_module()
+class MultiDataAspectRatioBatchSampler(BatchSampler):
+    """A sampler wrapper for grouping images with similar aspect ratio (< 1 or.
+
+    >= 1) into a same batch for multi-source datasets.
+
+    Args:
+        sampler (Sampler): Base sampler.
+        batch_size (Sequence(int)): Size of mini-batch for multi-source
+        datasets.
+        num_datasets(int): Number of multi-source datasets.
+        drop_last (bool): If ``True``, the sampler will drop the last batch if
+        its size would be less than ``batch_size``.
+    """
+
+    def __init__(self,
+                 sampler: Sampler,
+                 batch_size: Sequence[int],
+                 num_datasets: int,
+                 drop_last: bool = True) -> None:
+        if not isinstance(sampler, Sampler):
+            raise TypeError('sampler should be an instance of ``Sampler``, '
+                            f'but got {sampler}')
+        self.sampler = sampler
+        self.batch_size = batch_size
+        self.num_datasets = num_datasets
+        self.drop_last = drop_last
+        # two groups for w < h and w >= h for each dataset --> 2 * num_datasets
+        self._buckets = [[] for _ in range(2 * self.num_datasets)]
+
+    def __iter__(self) -> Sequence[int]:
+        for idx in self.sampler:
+            data_info = self.sampler.dataset.get_data_info(idx)
+            width, height = data_info['width'], data_info['height']
+            dataset_source_idx = self.sampler.dataset.get_dataset_source(idx)
+            aspect_ratio_bucket_id = 0 if width < height else 1
+            bucket_id = dataset_source_idx * 2 + aspect_ratio_bucket_id
+            bucket = self._buckets[bucket_id]
+            bucket.append(idx)
+            # yield a batch of indices in the same aspect ratio group
+            if len(bucket) == self.batch_size[dataset_source_idx]:
+                yield bucket[:]
+                del bucket[:]
+
+        # yield the rest data and reset the bucket
+        for i in range(self.num_datasets):
+            left_data = self._buckets[i * 2 + 0] + self._buckets[i * 2 + 1]
+            while len(left_data) > 0:
+                if len(left_data) <= self.batch_size[i]:
+                    if not self.drop_last:
+                        yield left_data[:]
+                    left_data = []
+                else:
+                    yield left_data[:self.batch_size[i]]
+                    left_data = left_data[self.batch_size[i]:]
+
+        self._buckets = [[] for _ in range(2 * self.num_datasets)]
+
+    def __len__(self) -> int:
+        sizes = [0 for _ in range(self.num_datasets)]
+        for idx in self.sampler:
+            dataset_source_idx = self.sampler.dataset.get_dataset_source(idx)
+            sizes[dataset_source_idx] += 1
+
+        if self.drop_last:
+            lens = 0
+            for i in range(self.num_datasets):
+                lens += sizes[i] // self.batch_size[i]
+            return lens
+        else:
+            lens = 0
+            for i in range(self.num_datasets):
+                lens += (sizes[i] + self.batch_size[i] -
+                         1) // self.batch_size[i]
+            return lens
diff --git a/mmdetection/mmdet/datasets/samplers/class_aware_sampler.py b/mmdetection/mmdet/datasets/samplers/class_aware_sampler.py
new file mode 100644
index 00000000..6ca2f9b3
--- /dev/null
+++ b/mmdetection/mmdet/datasets/samplers/class_aware_sampler.py
@@ -0,0 +1,192 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+from typing import Dict, Iterator, Optional, Union
+
+import numpy as np
+import torch
+from mmengine.dataset import BaseDataset
+from mmengine.dist import get_dist_info, sync_random_seed
+from torch.utils.data import Sampler
+
+from mmdet.registry import DATA_SAMPLERS
+
+
+@DATA_SAMPLERS.register_module()
+class ClassAwareSampler(Sampler):
+    r"""Sampler that restricts data loading to the label of the dataset.
+
+    A class-aware sampling strategy to effectively tackle the
+    non-uniform class distribution. The length of the training data is
+    consistent with source data. Simple improvements based on `Relay
+    Backpropagation for Effective Learning of Deep Convolutional
+    Neural Networks `_
+
+    The implementation logic is referred to
+    https://github.com/Sense-X/TSD/blob/master/mmdet/datasets/samplers/distributed_classaware_sampler.py
+
+    Args:
+        dataset: Dataset used for sampling.
+        seed (int, optional): random seed used to shuffle the sampler.
+            This number should be identical across all
+            processes in the distributed group. Defaults to None.
+        num_sample_class (int): The number of samples taken from each
+            per-label list. Defaults to 1.
+    """
+
+    def __init__(self,
+                 dataset: BaseDataset,
+                 seed: Optional[int] = None,
+                 num_sample_class: int = 1) -> None:
+        rank, world_size = get_dist_info()
+        self.rank = rank
+        self.world_size = world_size
+
+        self.dataset = dataset
+        self.epoch = 0
+        # Must be the same across all workers. If None, will use a
+        # random seed shared among workers
+        # (require synchronization among all workers)
+        if seed is None:
+            seed = sync_random_seed()
+        self.seed = seed
+
+        # The number of samples taken from each per-label list
+        assert num_sample_class > 0 and isinstance(num_sample_class, int)
+        self.num_sample_class = num_sample_class
+        # Get per-label image list from dataset
+        self.cat_dict = self.get_cat2imgs()
+
+        self.num_samples = int(math.ceil(len(self.dataset) * 1.0 / world_size))
+        self.total_size = self.num_samples * self.world_size
+
+        # get number of images containing each category
+        self.num_cat_imgs = [len(x) for x in self.cat_dict.values()]
+        # filter labels without images
+        self.valid_cat_inds = [
+            i for i, length in enumerate(self.num_cat_imgs) if length != 0
+        ]
+        self.num_classes = len(self.valid_cat_inds)
+
+    def get_cat2imgs(self) -> Dict[int, list]:
+        """Get a dict with class as key and img_ids as values.
+
+        Returns:
+            dict[int, list]: A dict of per-label image list,
+            the item of the dict indicates a label index,
+            corresponds to the image index that contains the label.
+        """
+        classes = self.dataset.metainfo.get('classes', None)
+        if classes is None:
+            raise ValueError('dataset metainfo must contain `classes`')
+        # sort the label index
+        cat2imgs = {i: [] for i in range(len(classes))}
+        for i in range(len(self.dataset)):
+            cat_ids = set(self.dataset.get_cat_ids(i))
+            for cat in cat_ids:
+                cat2imgs[cat].append(i)
+        return cat2imgs
+
+    def __iter__(self) -> Iterator[int]:
+        # deterministically shuffle based on epoch
+        g = torch.Generator()
+        g.manual_seed(self.epoch + self.seed)
+
+        # initialize label list
+        label_iter_list = RandomCycleIter(self.valid_cat_inds, generator=g)
+        # initialize each per-label image list
+        data_iter_dict = dict()
+        for i in self.valid_cat_inds:
+            data_iter_dict[i] = RandomCycleIter(self.cat_dict[i], generator=g)
+
+        def gen_cat_img_inds(cls_list, data_dict, num_sample_cls):
+            """Traverse the categories and extract `num_sample_cls` image
+            indexes of the corresponding categories one by one."""
+            id_indices = []
+            for _ in range(len(cls_list)):
+                cls_idx = next(cls_list)
+                for _ in range(num_sample_cls):
+                    id = next(data_dict[cls_idx])
+                    id_indices.append(id)
+            return id_indices
+
+        # deterministically shuffle based on epoch
+        num_bins = int(
+            math.ceil(self.total_size * 1.0 / self.num_classes /
+                      self.num_sample_class))
+        indices = []
+        for i in range(num_bins):
+            indices += gen_cat_img_inds(label_iter_list, data_iter_dict,
+                                        self.num_sample_class)
+
+        # fix extra samples to make it evenly divisible
+        if len(indices) >= self.total_size:
+            indices = indices[:self.total_size]
+        else:
+            indices += indices[:(self.total_size - len(indices))]
+        assert len(indices) == self.total_size
+
+        # subsample
+        offset = self.num_samples * self.rank
+        indices = indices[offset:offset + self.num_samples]
+        assert len(indices) == self.num_samples
+
+        return iter(indices)
+
+    def __len__(self) -> int:
+        """The number of samples in this rank."""
+        return self.num_samples
+
+    def set_epoch(self, epoch: int) -> None:
+        """Sets the epoch for this sampler.
+
+        When :attr:`shuffle=True`, this ensures all replicas use a different
+        random ordering for each epoch. Otherwise, the next iteration of this
+        sampler will yield the same ordering.
+
+        Args:
+            epoch (int): Epoch number.
+        """
+        self.epoch = epoch
+
+
+class RandomCycleIter:
+    """Shuffle the list and do it again after the list have traversed.
+
+    The implementation logic is referred to
+    https://github.com/wutong16/DistributionBalancedLoss/blob/master/mllt/datasets/loader/sampler.py
+
+    Example:
+        >>> label_list = [0, 1, 2, 4, 5]
+        >>> g = torch.Generator()
+        >>> g.manual_seed(0)
+        >>> label_iter_list = RandomCycleIter(label_list, generator=g)
+        >>> index = next(label_iter_list)
+    Args:
+        data (list or ndarray): The data that needs to be shuffled.
+        generator: An torch.Generator object, which is used in setting the seed
+            for generating random numbers.
+    """  # noqa: W605
+
+    def __init__(self,
+                 data: Union[list, np.ndarray],
+                 generator: torch.Generator = None) -> None:
+        self.data = data
+        self.length = len(data)
+        self.index = torch.randperm(self.length, generator=generator).numpy()
+        self.i = 0
+        self.generator = generator
+
+    def __iter__(self) -> Iterator:
+        return self
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+    def __next__(self):
+        if self.i == self.length:
+            self.index = torch.randperm(
+                self.length, generator=self.generator).numpy()
+            self.i = 0
+        idx = self.data[self.index[self.i]]
+        self.i += 1
+        return idx
diff --git a/mmdetection/mmdet/datasets/samplers/custom_sample_size_sampler.py b/mmdetection/mmdet/datasets/samplers/custom_sample_size_sampler.py
new file mode 100644
index 00000000..6bedf6c6
--- /dev/null
+++ b/mmdetection/mmdet/datasets/samplers/custom_sample_size_sampler.py
@@ -0,0 +1,111 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+from typing import Iterator, Optional, Sequence, Sized
+
+import torch
+from mmengine.dist import get_dist_info, sync_random_seed
+from torch.utils.data import Sampler
+
+from mmdet.registry import DATA_SAMPLERS
+from .class_aware_sampler import RandomCycleIter
+
+
+@DATA_SAMPLERS.register_module()
+class CustomSampleSizeSampler(Sampler):
+
+    def __init__(self,
+                 dataset: Sized,
+                 dataset_size: Sequence[int],
+                 ratio_mode: bool = False,
+                 seed: Optional[int] = None,
+                 round_up: bool = True) -> None:
+        assert len(dataset.datasets) == len(dataset_size)
+        rank, world_size = get_dist_info()
+        self.rank = rank
+        self.world_size = world_size
+
+        self.dataset = dataset
+        if seed is None:
+            seed = sync_random_seed()
+        self.seed = seed
+        self.epoch = 0
+        self.round_up = round_up
+
+        total_size = 0
+        total_size_fake = 0
+        self.dataset_index = []
+        self.dataset_cycle_iter = []
+        new_dataset_size = []
+        for dataset, size in zip(dataset.datasets, dataset_size):
+            self.dataset_index.append(
+                list(range(total_size_fake,
+                           len(dataset) + total_size_fake)))
+            total_size_fake += len(dataset)
+            if size == -1:
+                total_size += len(dataset)
+                self.dataset_cycle_iter.append(None)
+                new_dataset_size.append(-1)
+            else:
+                if ratio_mode:
+                    size = int(size * len(dataset))
+                assert size <= len(
+                    dataset
+                ), f'dataset size {size} is larger than ' \
+                   f'dataset length {len(dataset)}'
+                total_size += size
+                new_dataset_size.append(size)
+
+                g = torch.Generator()
+                g.manual_seed(self.seed)
+                self.dataset_cycle_iter.append(
+                    RandomCycleIter(self.dataset_index[-1], generator=g))
+        self.dataset_size = new_dataset_size
+
+        if self.round_up:
+            self.num_samples = math.ceil(total_size / world_size)
+            self.total_size = self.num_samples * self.world_size
+        else:
+            self.num_samples = math.ceil((total_size - rank) / world_size)
+            self.total_size = total_size
+
+    def __iter__(self) -> Iterator[int]:
+        """Iterate the indices."""
+        # deterministically shuffle based on epoch and seed
+        g = torch.Generator()
+        g.manual_seed(self.seed + self.epoch)
+
+        out_index = []
+        for data_size, data_index, cycle_iter in zip(self.dataset_size,
+                                                     self.dataset_index,
+                                                     self.dataset_cycle_iter):
+            if data_size == -1:
+                out_index += data_index
+            else:
+                index = [next(cycle_iter) for _ in range(data_size)]
+                out_index += index
+
+        index = torch.randperm(len(out_index), generator=g).numpy().tolist()
+        indices = [out_index[i] for i in index]
+
+        if self.round_up:
+            indices = (
+                indices *
+                int(self.total_size / len(indices) + 1))[:self.total_size]
+        indices = indices[self.rank:self.total_size:self.world_size]
+        return iter(indices)
+
+    def __len__(self) -> int:
+        """The number of samples in this rank."""
+        return self.num_samples
+
+    def set_epoch(self, epoch: int) -> None:
+        """Sets the epoch for this sampler.
+
+        When :attr:`shuffle=True`, this ensures all replicas use a different
+        random ordering for each epoch. Otherwise, the next iteration of this
+        sampler will yield the same ordering.
+
+        Args:
+            epoch (int): Epoch number.
+        """
+        self.epoch = epoch
diff --git a/mmdetection/mmdet/datasets/samplers/multi_data_sampler.py b/mmdetection/mmdet/datasets/samplers/multi_data_sampler.py
new file mode 100644
index 00000000..c3a4b60d
--- /dev/null
+++ b/mmdetection/mmdet/datasets/samplers/multi_data_sampler.py
@@ -0,0 +1,110 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+from typing import Iterator, Optional, Sequence, Sized
+
+import torch
+from mmengine.dist import get_dist_info, sync_random_seed
+from mmengine.registry import DATA_SAMPLERS
+from torch.utils.data import Sampler
+
+
+@DATA_SAMPLERS.register_module()
+class MultiDataSampler(Sampler):
+    """The default data sampler for both distributed and non-distributed
+    environment.
+
+    It has several differences from the PyTorch ``DistributedSampler`` as
+    below:
+
+    1. This sampler supports non-distributed environment.
+
+    2. The round up behaviors are a little different.
+
+       - If ``round_up=True``, this sampler will add extra samples to make the
+         number of samples is evenly divisible by the world size. And
+         this behavior is the same as the ``DistributedSampler`` with
+         ``drop_last=False``.
+       - If ``round_up=False``, this sampler won't remove or add any samples
+         while the ``DistributedSampler`` with ``drop_last=True`` will remove
+         tail samples.
+
+    Args:
+        dataset (Sized): The dataset.
+        dataset_ratio (Sequence(int)) The ratios of different datasets.
+        seed (int, optional): Random seed used to shuffle the sampler if
+            :attr:`shuffle=True`. This number should be identical across all
+            processes in the distributed group. Defaults to None.
+        round_up (bool): Whether to add extra samples to make the number of
+            samples evenly divisible by the world size. Defaults to True.
+    """
+
+    def __init__(self,
+                 dataset: Sized,
+                 dataset_ratio: Sequence[int],
+                 seed: Optional[int] = None,
+                 round_up: bool = True) -> None:
+        rank, world_size = get_dist_info()
+        self.rank = rank
+        self.world_size = world_size
+
+        self.dataset = dataset
+        self.dataset_ratio = dataset_ratio
+
+        if seed is None:
+            seed = sync_random_seed()
+        self.seed = seed
+        self.epoch = 0
+        self.round_up = round_up
+
+        if self.round_up:
+            self.num_samples = math.ceil(len(self.dataset) / world_size)
+            self.total_size = self.num_samples * self.world_size
+        else:
+            self.num_samples = math.ceil(
+                (len(self.dataset) - rank) / world_size)
+            self.total_size = len(self.dataset)
+
+        self.sizes = [len(dataset) for dataset in self.dataset.datasets]
+
+        dataset_weight = [
+            torch.ones(s) * max(self.sizes) / s * r / sum(self.dataset_ratio)
+            for i, (r, s) in enumerate(zip(self.dataset_ratio, self.sizes))
+        ]
+        self.weights = torch.cat(dataset_weight)
+
+    def __iter__(self) -> Iterator[int]:
+        """Iterate the indices."""
+        # deterministically shuffle based on epoch and seed
+        g = torch.Generator()
+        g.manual_seed(self.seed + self.epoch)
+
+        indices = torch.multinomial(
+            self.weights, len(self.weights), generator=g,
+            replacement=True).tolist()
+
+        # add extra samples to make it evenly divisible
+        if self.round_up:
+            indices = (
+                indices *
+                int(self.total_size / len(indices) + 1))[:self.total_size]
+
+        # subsample
+        indices = indices[self.rank:self.total_size:self.world_size]
+
+        return iter(indices)
+
+    def __len__(self) -> int:
+        """The number of samples in this rank."""
+        return self.num_samples
+
+    def set_epoch(self, epoch: int) -> None:
+        """Sets the epoch for this sampler.
+
+        When :attr:`shuffle=True`, this ensures all replicas use a different
+        random ordering for each epoch. Otherwise, the next iteration of this
+        sampler will yield the same ordering.
+
+        Args:
+            epoch (int): Epoch number.
+        """
+        self.epoch = epoch
diff --git a/mmdetection/mmdet/datasets/samplers/multi_source_sampler.py b/mmdetection/mmdet/datasets/samplers/multi_source_sampler.py
new file mode 100644
index 00000000..6efcde35
--- /dev/null
+++ b/mmdetection/mmdet/datasets/samplers/multi_source_sampler.py
@@ -0,0 +1,214 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import itertools
+from typing import Iterator, List, Optional, Sized, Union
+
+import numpy as np
+import torch
+from mmengine.dataset import BaseDataset
+from mmengine.dist import get_dist_info, sync_random_seed
+from torch.utils.data import Sampler
+
+from mmdet.registry import DATA_SAMPLERS
+
+
+@DATA_SAMPLERS.register_module()
+class MultiSourceSampler(Sampler):
+    r"""Multi-Source Infinite Sampler.
+
+    According to the sampling ratio, sample data from different
+    datasets to form batches.
+
+    Args:
+        dataset (Sized): The dataset.
+        batch_size (int): Size of mini-batch.
+        source_ratio (list[int | float]): The sampling ratio of different
+            source datasets in a mini-batch.
+        shuffle (bool): Whether shuffle the dataset or not. Defaults to True.
+        seed (int, optional): Random seed. If None, set a random seed.
+            Defaults to None.
+
+    Examples:
+        >>> dataset_type = 'ConcatDataset'
+        >>> sub_dataset_type = 'CocoDataset'
+        >>> data_root = 'data/coco/'
+        >>> sup_ann = '../coco_semi_annos/instances_train2017.1@10.json'
+        >>> unsup_ann = '../coco_semi_annos/' \
+        >>>             'instances_train2017.1@10-unlabeled.json'
+        >>> dataset = dict(type=dataset_type,
+        >>>     datasets=[
+        >>>         dict(
+        >>>             type=sub_dataset_type,
+        >>>             data_root=data_root,
+        >>>             ann_file=sup_ann,
+        >>>             data_prefix=dict(img='train2017/'),
+        >>>             filter_cfg=dict(filter_empty_gt=True, min_size=32),
+        >>>             pipeline=sup_pipeline),
+        >>>         dict(
+        >>>             type=sub_dataset_type,
+        >>>             data_root=data_root,
+        >>>             ann_file=unsup_ann,
+        >>>             data_prefix=dict(img='train2017/'),
+        >>>             filter_cfg=dict(filter_empty_gt=True, min_size=32),
+        >>>             pipeline=unsup_pipeline),
+        >>>         ])
+        >>>     train_dataloader = dict(
+        >>>         batch_size=5,
+        >>>         num_workers=5,
+        >>>         persistent_workers=True,
+        >>>         sampler=dict(type='MultiSourceSampler',
+        >>>             batch_size=5, source_ratio=[1, 4]),
+        >>>         batch_sampler=None,
+        >>>         dataset=dataset)
+    """
+
+    def __init__(self,
+                 dataset: Sized,
+                 batch_size: int,
+                 source_ratio: List[Union[int, float]],
+                 shuffle: bool = True,
+                 seed: Optional[int] = None) -> None:
+
+        assert hasattr(dataset, 'cumulative_sizes'),\
+            f'The dataset must be ConcatDataset, but get {dataset}'
+        assert isinstance(batch_size, int) and batch_size > 0, \
+            'batch_size must be a positive integer value, ' \
+            f'but got batch_size={batch_size}'
+        assert isinstance(source_ratio, list), \
+            f'source_ratio must be a list, but got source_ratio={source_ratio}'
+        assert len(source_ratio) == len(dataset.cumulative_sizes), \
+            'The length of source_ratio must be equal to ' \
+            f'the number of datasets, but got source_ratio={source_ratio}'
+
+        rank, world_size = get_dist_info()
+        self.rank = rank
+        self.world_size = world_size
+
+        self.dataset = dataset
+        self.cumulative_sizes = [0] + dataset.cumulative_sizes
+        self.batch_size = batch_size
+        self.source_ratio = source_ratio
+
+        self.num_per_source = [
+            int(batch_size * sr / sum(source_ratio)) for sr in source_ratio
+        ]
+        self.num_per_source[0] = batch_size - sum(self.num_per_source[1:])
+
+        assert sum(self.num_per_source) == batch_size, \
+            'The sum of num_per_source must be equal to ' \
+            f'batch_size, but get {self.num_per_source}'
+
+        self.seed = sync_random_seed() if seed is None else seed
+        self.shuffle = shuffle
+        self.source2inds = {
+            source: self._indices_of_rank(len(ds))
+            for source, ds in enumerate(dataset.datasets)
+        }
+
+    def _infinite_indices(self, sample_size: int) -> Iterator[int]:
+        """Infinitely yield a sequence of indices."""
+        g = torch.Generator()
+        g.manual_seed(self.seed)
+        while True:
+            if self.shuffle:
+                yield from torch.randperm(sample_size, generator=g).tolist()
+            else:
+                yield from torch.arange(sample_size).tolist()
+
+    def _indices_of_rank(self, sample_size: int) -> Iterator[int]:
+        """Slice the infinite indices by rank."""
+        yield from itertools.islice(
+            self._infinite_indices(sample_size), self.rank, None,
+            self.world_size)
+
+    def __iter__(self) -> Iterator[int]:
+        batch_buffer = []
+        while True:
+            for source, num in enumerate(self.num_per_source):
+                batch_buffer_per_source = []
+                for idx in self.source2inds[source]:
+                    idx += self.cumulative_sizes[source]
+                    batch_buffer_per_source.append(idx)
+                    if len(batch_buffer_per_source) == num:
+                        batch_buffer += batch_buffer_per_source
+                        break
+            yield from batch_buffer
+            batch_buffer = []
+
+    def __len__(self) -> int:
+        return len(self.dataset)
+
+    def set_epoch(self, epoch: int) -> None:
+        """Not supported in `epoch-based runner."""
+        pass
+
+
+@DATA_SAMPLERS.register_module()
+class GroupMultiSourceSampler(MultiSourceSampler):
+    r"""Group Multi-Source Infinite Sampler.
+
+    According to the sampling ratio, sample data from different
+    datasets but the same group to form batches.
+
+    Args:
+        dataset (Sized): The dataset.
+        batch_size (int): Size of mini-batch.
+        source_ratio (list[int | float]): The sampling ratio of different
+            source datasets in a mini-batch.
+        shuffle (bool): Whether shuffle the dataset or not. Defaults to True.
+        seed (int, optional): Random seed. If None, set a random seed.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 dataset: BaseDataset,
+                 batch_size: int,
+                 source_ratio: List[Union[int, float]],
+                 shuffle: bool = True,
+                 seed: Optional[int] = None) -> None:
+        super().__init__(
+            dataset=dataset,
+            batch_size=batch_size,
+            source_ratio=source_ratio,
+            shuffle=shuffle,
+            seed=seed)
+
+        self._get_source_group_info()
+        self.group_source2inds = [{
+            source:
+            self._indices_of_rank(self.group2size_per_source[source][group])
+            for source in range(len(dataset.datasets))
+        } for group in range(len(self.group_ratio))]
+
+    def _get_source_group_info(self) -> None:
+        self.group2size_per_source = [{0: 0, 1: 0}, {0: 0, 1: 0}]
+        self.group2inds_per_source = [{0: [], 1: []}, {0: [], 1: []}]
+        for source, dataset in enumerate(self.dataset.datasets):
+            for idx in range(len(dataset)):
+                data_info = dataset.get_data_info(idx)
+                width, height = data_info['width'], data_info['height']
+                group = 0 if width < height else 1
+                self.group2size_per_source[source][group] += 1
+                self.group2inds_per_source[source][group].append(idx)
+
+        self.group_sizes = np.zeros(2, dtype=np.int64)
+        for group2size in self.group2size_per_source:
+            for group, size in group2size.items():
+                self.group_sizes[group] += size
+        self.group_ratio = self.group_sizes / sum(self.group_sizes)
+
+    def __iter__(self) -> Iterator[int]:
+        batch_buffer = []
+        while True:
+            group = np.random.choice(
+                list(range(len(self.group_ratio))), p=self.group_ratio)
+            for source, num in enumerate(self.num_per_source):
+                batch_buffer_per_source = []
+                for idx in self.group_source2inds[group][source]:
+                    idx = self.group2inds_per_source[source][group][
+                        idx] + self.cumulative_sizes[source]
+                    batch_buffer_per_source.append(idx)
+                    if len(batch_buffer_per_source) == num:
+                        batch_buffer += batch_buffer_per_source
+                        break
+            yield from batch_buffer
+            batch_buffer = []
diff --git a/mmdetection/mmdet/datasets/samplers/track_img_sampler.py b/mmdetection/mmdet/datasets/samplers/track_img_sampler.py
new file mode 100644
index 00000000..d7db629f
--- /dev/null
+++ b/mmdetection/mmdet/datasets/samplers/track_img_sampler.py
@@ -0,0 +1,146 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+import random
+from typing import Iterator, Optional, Sized
+
+import numpy as np
+from mmengine.dataset import ClassBalancedDataset, ConcatDataset
+from mmengine.dist import get_dist_info, sync_random_seed
+from torch.utils.data import Sampler
+
+from mmdet.registry import DATA_SAMPLERS
+from ..base_video_dataset import BaseVideoDataset
+
+
+@DATA_SAMPLERS.register_module()
+class TrackImgSampler(Sampler):
+    """Sampler that providing image-level sampling outputs for video datasets
+    in tracking tasks. It could be both used in both distributed and
+    non-distributed environment.
+    If using the default sampler in pytorch, the subsequent data receiver will
+    get one video, which is not desired in some cases:
+    (Take a non-distributed environment as an example)
+    1. In test mode, we want only one image is fed into the data pipeline. This
+    is in consideration of memory usage since feeding the whole video commonly
+    requires a large amount of memory (>=20G on MOTChallenge17 dataset), which
+    is not available in some machines.
+    2. In training mode, we may want to make sure all the images in one video
+    are randomly sampled once in one epoch and this can not be guaranteed in
+    the default sampler in pytorch.
+
+    Args:
+        dataset (Sized): Dataset used for sampling.
+        seed (int, optional): random seed used to shuffle the sampler. This
+            number should be identical across all processes in the distributed
+            group. Defaults to None.
+    """
+
+    def __init__(
+        self,
+        dataset: Sized,
+        seed: Optional[int] = None,
+    ) -> None:
+        rank, world_size = get_dist_info()
+        self.rank = rank
+        self.world_size = world_size
+        self.epoch = 0
+        if seed is None:
+            self.seed = sync_random_seed()
+        else:
+            self.seed = seed
+
+        self.dataset = dataset
+        self.indices = []
+        # Hard code here to handle different dataset wrapper
+        if isinstance(self.dataset, ConcatDataset):
+            cat_datasets = self.dataset.datasets
+            assert isinstance(
+                cat_datasets[0], BaseVideoDataset
+            ), f'expected BaseVideoDataset, but got {type(cat_datasets[0])}'
+            self.test_mode = cat_datasets[0].test_mode
+            assert not self.test_mode, "'ConcatDataset' should not exist in "
+            'test mode'
+            for dataset in cat_datasets:
+                num_videos = len(dataset)
+                for video_ind in range(num_videos):
+                    self.indices.extend([
+                        (video_ind, frame_ind) for frame_ind in range(
+                            dataset.get_len_per_video(video_ind))
+                    ])
+        elif isinstance(self.dataset, ClassBalancedDataset):
+            ori_dataset = self.dataset.dataset
+            assert isinstance(
+                ori_dataset, BaseVideoDataset
+            ), f'expected BaseVideoDataset, but got {type(ori_dataset)}'
+            self.test_mode = ori_dataset.test_mode
+            assert not self.test_mode, "'ClassBalancedDataset' should not "
+            'exist in test mode'
+            video_indices = self.dataset.repeat_indices
+            for index in video_indices:
+                self.indices.extend([(index, frame_ind) for frame_ind in range(
+                    ori_dataset.get_len_per_video(index))])
+        else:
+            assert isinstance(
+                self.dataset, BaseVideoDataset
+            ), 'TrackImgSampler is only supported in BaseVideoDataset or '
+            'dataset wrapper: ClassBalancedDataset and ConcatDataset, but '
+            f'got {type(self.dataset)} '
+            self.test_mode = self.dataset.test_mode
+            num_videos = len(self.dataset)
+
+            if self.test_mode:
+                # in test mode, the images belong to the same video must be put
+                # on the same device.
+                if num_videos < self.world_size:
+                    raise ValueError(f'only {num_videos} videos loaded,'
+                                     f'but {self.world_size} gpus were given.')
+                chunks = np.array_split(
+                    list(range(num_videos)), self.world_size)
+                for videos_inds in chunks:
+                    indices_chunk = []
+                    for video_ind in videos_inds:
+                        indices_chunk.extend([
+                            (video_ind, frame_ind) for frame_ind in range(
+                                self.dataset.get_len_per_video(video_ind))
+                        ])
+                    self.indices.append(indices_chunk)
+            else:
+                for video_ind in range(num_videos):
+                    self.indices.extend([
+                        (video_ind, frame_ind) for frame_ind in range(
+                            self.dataset.get_len_per_video(video_ind))
+                    ])
+
+        if self.test_mode:
+            self.num_samples = len(self.indices[self.rank])
+            self.total_size = sum(
+                [len(index_list) for index_list in self.indices])
+        else:
+            self.num_samples = int(
+                math.ceil(len(self.indices) * 1.0 / self.world_size))
+            self.total_size = self.num_samples * self.world_size
+
+    def __iter__(self) -> Iterator:
+        if self.test_mode:
+            # in test mode, the order of frames can not be shuffled.
+            indices = self.indices[self.rank]
+        else:
+            # deterministically shuffle based on epoch
+            rng = random.Random(self.epoch + self.seed)
+            indices = rng.sample(self.indices, len(self.indices))
+
+            # add extra samples to make it evenly divisible
+            indices += indices[:(self.total_size - len(indices))]
+            assert len(indices) == self.total_size
+
+            # subsample
+            indices = indices[self.rank:self.total_size:self.world_size]
+            assert len(indices) == self.num_samples
+
+        return iter(indices)
+
+    def __len__(self):
+        return self.num_samples
+
+    def set_epoch(self, epoch):
+        self.epoch = epoch
diff --git a/mmdetection/mmdet/datasets/transforms/__init__.py b/mmdetection/mmdet/datasets/transforms/__init__.py
new file mode 100644
index 00000000..ab3478fe
--- /dev/null
+++ b/mmdetection/mmdet/datasets/transforms/__init__.py
@@ -0,0 +1,45 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .augment_wrappers import AutoAugment, RandAugment
+from .colorspace import (AutoContrast, Brightness, Color, ColorTransform,
+                         Contrast, Equalize, Invert, Posterize, Sharpness,
+                         Solarize, SolarizeAdd)
+from .formatting import (ImageToTensor, PackDetInputs, PackReIDInputs,
+                         PackTrackInputs, ToTensor, Transpose)
+from .frame_sampling import BaseFrameSample, UniformRefFrameSample
+from .geometric import (GeomTransform, Rotate, ShearX, ShearY, TranslateX,
+                        TranslateY)
+from .instaboost import InstaBoost
+from .loading import (FilterAnnotations, InferencerLoader, LoadAnnotations,
+                      LoadEmptyAnnotations, LoadImageFromNDArray,
+                      LoadMultiChannelImageFromFiles, LoadPanopticAnnotations,
+                      LoadProposals, LoadTrackAnnotations)
+from .text_transformers import LoadTextAnnotations, RandomSamplingNegPos
+from .transformers_glip import GTBoxSubOne_GLIP, RandomFlip_GLIP
+from .transforms import (Albu, CachedMixUp, CachedMosaic, CopyPaste, CutOut,
+                         Expand, FixScaleResize, FixShapeResize,
+                         MinIoURandomCrop, MixUp, Mosaic, Pad,
+                         PhotoMetricDistortion, RandomAffine,
+                         RandomCenterCropPad, RandomCrop, RandomErasing,
+                         RandomFlip, RandomShift, Resize, ResizeShortestEdge,
+                         SegRescale, YOLOXHSVRandomAug)
+from .wrappers import MultiBranch, ProposalBroadcaster, RandomOrder
+
+__all__ = [
+    'PackDetInputs', 'ToTensor', 'ImageToTensor', 'Transpose',
+    'LoadImageFromNDArray', 'LoadAnnotations', 'LoadPanopticAnnotations',
+    'LoadMultiChannelImageFromFiles', 'LoadProposals', 'Resize', 'RandomFlip',
+    'RandomCrop', 'SegRescale', 'MinIoURandomCrop', 'Expand',
+    'PhotoMetricDistortion', 'Albu', 'InstaBoost', 'RandomCenterCropPad',
+    'AutoAugment', 'CutOut', 'ShearX', 'ShearY', 'Rotate', 'Color', 'Equalize',
+    'Brightness', 'Contrast', 'TranslateX', 'TranslateY', 'RandomShift',
+    'Mosaic', 'MixUp', 'RandomAffine', 'YOLOXHSVRandomAug', 'CopyPaste',
+    'FilterAnnotations', 'Pad', 'GeomTransform', 'ColorTransform',
+    'RandAugment', 'Sharpness', 'Solarize', 'SolarizeAdd', 'Posterize',
+    'AutoContrast', 'Invert', 'MultiBranch', 'RandomErasing',
+    'LoadEmptyAnnotations', 'RandomOrder', 'CachedMosaic', 'CachedMixUp',
+    'FixShapeResize', 'ProposalBroadcaster', 'InferencerLoader',
+    'LoadTrackAnnotations', 'BaseFrameSample', 'UniformRefFrameSample',
+    'PackTrackInputs', 'PackReIDInputs', 'FixScaleResize',
+    'ResizeShortestEdge', 'GTBoxSubOne_GLIP', 'RandomFlip_GLIP',
+    'RandomSamplingNegPos', 'LoadTextAnnotations'
+]
diff --git a/mmdetection/mmdet/datasets/transforms/augment_wrappers.py b/mmdetection/mmdet/datasets/transforms/augment_wrappers.py
new file mode 100644
index 00000000..19fae6ef
--- /dev/null
+++ b/mmdetection/mmdet/datasets/transforms/augment_wrappers.py
@@ -0,0 +1,264 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Union
+
+import numpy as np
+from mmcv.transforms import RandomChoice
+from mmcv.transforms.utils import cache_randomness
+from mmengine.config import ConfigDict
+
+from mmdet.registry import TRANSFORMS
+
+# AutoAugment uses reinforcement learning to search for
+# some widely useful data augmentation strategies,
+# here we provide AUTOAUG_POLICIES_V0.
+# For AUTOAUG_POLICIES_V0, each tuple is an augmentation
+# operation of the form (operation, probability, magnitude).
+# Each element in policies is a policy that will be applied
+# sequentially on the image.
+
+# RandAugment defines a data augmentation search space, RANDAUG_SPACE,
+# sampling 1~3 data augmentations each time, and
+# setting the magnitude of each data augmentation randomly,
+# which will be applied sequentially on the image.
+
+_MAX_LEVEL = 10
+
+AUTOAUG_POLICIES_V0 = [
+    [('Equalize', 0.8, 1), ('ShearY', 0.8, 4)],
+    [('Color', 0.4, 9), ('Equalize', 0.6, 3)],
+    [('Color', 0.4, 1), ('Rotate', 0.6, 8)],
+    [('Solarize', 0.8, 3), ('Equalize', 0.4, 7)],
+    [('Solarize', 0.4, 2), ('Solarize', 0.6, 2)],
+    [('Color', 0.2, 0), ('Equalize', 0.8, 8)],
+    [('Equalize', 0.4, 8), ('SolarizeAdd', 0.8, 3)],
+    [('ShearX', 0.2, 9), ('Rotate', 0.6, 8)],
+    [('Color', 0.6, 1), ('Equalize', 1.0, 2)],
+    [('Invert', 0.4, 9), ('Rotate', 0.6, 0)],
+    [('Equalize', 1.0, 9), ('ShearY', 0.6, 3)],
+    [('Color', 0.4, 7), ('Equalize', 0.6, 0)],
+    [('Posterize', 0.4, 6), ('AutoContrast', 0.4, 7)],
+    [('Solarize', 0.6, 8), ('Color', 0.6, 9)],
+    [('Solarize', 0.2, 4), ('Rotate', 0.8, 9)],
+    [('Rotate', 1.0, 7), ('TranslateY', 0.8, 9)],
+    [('ShearX', 0.0, 0), ('Solarize', 0.8, 4)],
+    [('ShearY', 0.8, 0), ('Color', 0.6, 4)],
+    [('Color', 1.0, 0), ('Rotate', 0.6, 2)],
+    [('Equalize', 0.8, 4), ('Equalize', 0.0, 8)],
+    [('Equalize', 1.0, 4), ('AutoContrast', 0.6, 2)],
+    [('ShearY', 0.4, 7), ('SolarizeAdd', 0.6, 7)],
+    [('Posterize', 0.8, 2), ('Solarize', 0.6, 10)],
+    [('Solarize', 0.6, 8), ('Equalize', 0.6, 1)],
+    [('Color', 0.8, 6), ('Rotate', 0.4, 5)],
+]
+
+
+def policies_v0():
+    """Autoaugment policies that was used in AutoAugment Paper."""
+    policies = list()
+    for policy_args in AUTOAUG_POLICIES_V0:
+        policy = list()
+        for args in policy_args:
+            policy.append(dict(type=args[0], prob=args[1], level=args[2]))
+        policies.append(policy)
+    return policies
+
+
+RANDAUG_SPACE = [[dict(type='AutoContrast')], [dict(type='Equalize')],
+                 [dict(type='Invert')], [dict(type='Rotate')],
+                 [dict(type='Posterize')], [dict(type='Solarize')],
+                 [dict(type='SolarizeAdd')], [dict(type='Color')],
+                 [dict(type='Contrast')], [dict(type='Brightness')],
+                 [dict(type='Sharpness')], [dict(type='ShearX')],
+                 [dict(type='ShearY')], [dict(type='TranslateX')],
+                 [dict(type='TranslateY')]]
+
+
+def level_to_mag(level: Optional[int], min_mag: float,
+                 max_mag: float) -> float:
+    """Map from level to magnitude."""
+    if level is None:
+        return round(np.random.rand() * (max_mag - min_mag) + min_mag, 1)
+    else:
+        return round(level / _MAX_LEVEL * (max_mag - min_mag) + min_mag, 1)
+
+
+@TRANSFORMS.register_module()
+class AutoAugment(RandomChoice):
+    """Auto augmentation.
+
+    This data augmentation is proposed in `AutoAugment: Learning
+    Augmentation Policies from Data `_
+    and in `Learning Data Augmentation Strategies for Object Detection
+    `_.
+
+    Required Keys:
+
+    - img
+    - gt_bboxes (BaseBoxes[torch.float32]) (optional)
+    - gt_bboxes_labels (np.int64) (optional)
+    - gt_masks (BitmapMasks | PolygonMasks) (optional)
+    - gt_ignore_flags (bool) (optional)
+    - gt_seg_map (np.uint8) (optional)
+
+    Modified Keys:
+
+    - img
+    - img_shape
+    - gt_bboxes
+    - gt_bboxes_labels
+    - gt_masks
+    - gt_ignore_flags
+    - gt_seg_map
+
+    Added Keys:
+
+    - homography_matrix
+
+    Args:
+        policies (List[List[Union[dict, ConfigDict]]]):
+            The policies of auto augmentation.Each policy in ``policies``
+            is a specific augmentation policy, and is composed by several
+            augmentations. When AutoAugment is called, a random policy in
+            ``policies`` will be selected to augment images.
+            Defaults to policy_v0().
+        prob (list[float], optional): The probabilities associated
+            with each policy. The length should be equal to the policy
+            number and the sum should be 1. If not given, a uniform
+            distribution will be assumed. Defaults to None.
+
+    Examples:
+        >>> policies = [
+        >>>     [
+        >>>         dict(type='Sharpness', prob=0.0, level=8),
+        >>>         dict(type='ShearX', prob=0.4, level=0,)
+        >>>     ],
+        >>>     [
+        >>>         dict(type='Rotate', prob=0.6, level=10),
+        >>>         dict(type='Color', prob=1.0, level=6)
+        >>>     ]
+        >>> ]
+        >>> augmentation = AutoAugment(policies)
+        >>> img = np.ones(100, 100, 3)
+        >>> gt_bboxes = np.ones(10, 4)
+        >>> results = dict(img=img, gt_bboxes=gt_bboxes)
+        >>> results = augmentation(results)
+    """
+
+    def __init__(self,
+                 policies: List[List[Union[dict, ConfigDict]]] = policies_v0(),
+                 prob: Optional[List[float]] = None) -> None:
+        assert isinstance(policies, list) and len(policies) > 0, \
+            'Policies must be a non-empty list.'
+        for policy in policies:
+            assert isinstance(policy, list) and len(policy) > 0, \
+                'Each policy in policies must be a non-empty list.'
+            for augment in policy:
+                assert isinstance(augment, dict) and 'type' in augment, \
+                    'Each specific augmentation must be a dict with key' \
+                    ' "type".'
+        super().__init__(transforms=policies, prob=prob)
+        self.policies = policies
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}(policies={self.policies}, ' \
+               f'prob={self.prob})'
+
+
+@TRANSFORMS.register_module()
+class RandAugment(RandomChoice):
+    """Rand augmentation.
+
+    This data augmentation is proposed in `RandAugment:
+    Practical automated data augmentation with a reduced
+    search space `_.
+
+    Required Keys:
+
+    - img
+    - gt_bboxes (BaseBoxes[torch.float32]) (optional)
+    - gt_bboxes_labels (np.int64) (optional)
+    - gt_masks (BitmapMasks | PolygonMasks) (optional)
+    - gt_ignore_flags (bool) (optional)
+    - gt_seg_map (np.uint8) (optional)
+
+    Modified Keys:
+
+    - img
+    - img_shape
+    - gt_bboxes
+    - gt_bboxes_labels
+    - gt_masks
+    - gt_ignore_flags
+    - gt_seg_map
+
+    Added Keys:
+
+    - homography_matrix
+
+    Args:
+        aug_space (List[List[Union[dict, ConfigDict]]]): The augmentation space
+            of rand augmentation. Each augmentation transform in ``aug_space``
+            is a specific transform, and is composed by several augmentations.
+            When RandAugment is called, a random transform in ``aug_space``
+            will be selected to augment images. Defaults to aug_space.
+        aug_num (int): Number of augmentation to apply equentially.
+            Defaults to 2.
+        prob (list[float], optional): The probabilities associated with
+            each augmentation. The length should be equal to the
+            augmentation space and the sum should be 1. If not given,
+            a uniform distribution will be assumed. Defaults to None.
+
+    Examples:
+        >>> aug_space = [
+        >>>     dict(type='Sharpness'),
+        >>>     dict(type='ShearX'),
+        >>>     dict(type='Color'),
+        >>>     ],
+        >>> augmentation = RandAugment(aug_space)
+        >>> img = np.ones(100, 100, 3)
+        >>> gt_bboxes = np.ones(10, 4)
+        >>> results = dict(img=img, gt_bboxes=gt_bboxes)
+        >>> results = augmentation(results)
+    """
+
+    def __init__(self,
+                 aug_space: List[Union[dict, ConfigDict]] = RANDAUG_SPACE,
+                 aug_num: int = 2,
+                 prob: Optional[List[float]] = None) -> None:
+        assert isinstance(aug_space, list) and len(aug_space) > 0, \
+            'Augmentation space must be a non-empty list.'
+        for aug in aug_space:
+            assert isinstance(aug, list) and len(aug) == 1, \
+                'Each augmentation in aug_space must be a list.'
+            for transform in aug:
+                assert isinstance(transform, dict) and 'type' in transform, \
+                    'Each specific transform must be a dict with key' \
+                    ' "type".'
+        super().__init__(transforms=aug_space, prob=prob)
+        self.aug_space = aug_space
+        self.aug_num = aug_num
+
+    @cache_randomness
+    def random_pipeline_index(self):
+        indices = np.arange(len(self.transforms))
+        return np.random.choice(
+            indices, self.aug_num, p=self.prob, replace=False)
+
+    def transform(self, results: dict) -> dict:
+        """Transform function to use RandAugment.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Result dict with RandAugment.
+        """
+        for idx in self.random_pipeline_index():
+            results = self.transforms[idx](results)
+        return results
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}(' \
+               f'aug_space={self.aug_space}, '\
+               f'aug_num={self.aug_num}, ' \
+               f'prob={self.prob})'
diff --git a/mmdetection/mmdet/datasets/transforms/colorspace.py b/mmdetection/mmdet/datasets/transforms/colorspace.py
new file mode 100644
index 00000000..e0ba2e97
--- /dev/null
+++ b/mmdetection/mmdet/datasets/transforms/colorspace.py
@@ -0,0 +1,493 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+from typing import Optional
+
+import mmcv
+import numpy as np
+from mmcv.transforms import BaseTransform
+from mmcv.transforms.utils import cache_randomness
+
+from mmdet.registry import TRANSFORMS
+from .augment_wrappers import _MAX_LEVEL, level_to_mag
+
+
+@TRANSFORMS.register_module()
+class ColorTransform(BaseTransform):
+    """Base class for color transformations. All color transformations need to
+    inherit from this base class. ``ColorTransform`` unifies the class
+    attributes and class functions of color transformations (Color, Brightness,
+    Contrast, Sharpness, Solarize, SolarizeAdd, Equalize, AutoContrast, Invert,
+    and Posterize), and only distort color channels, without impacting the
+    locations of the instances.
+
+    Required Keys:
+
+    - img
+
+    Modified Keys:
+
+    - img
+
+    Args:
+        prob (float): The probability for performing the geometric
+            transformation and should be in range [0, 1]. Defaults to 1.0.
+        level (int, optional): The level should be in range [0, _MAX_LEVEL].
+            If level is None, it will generate from [0, _MAX_LEVEL] randomly.
+            Defaults to None.
+        min_mag (float): The minimum magnitude for color transformation.
+            Defaults to 0.1.
+        max_mag (float): The maximum magnitude for color transformation.
+            Defaults to 1.9.
+    """
+
+    def __init__(self,
+                 prob: float = 1.0,
+                 level: Optional[int] = None,
+                 min_mag: float = 0.1,
+                 max_mag: float = 1.9) -> None:
+        assert 0 <= prob <= 1.0, f'The probability of the transformation ' \
+                                 f'should be in range [0,1], got {prob}.'
+        assert level is None or isinstance(level, int), \
+            f'The level should be None or type int, got {type(level)}.'
+        assert level is None or 0 <= level <= _MAX_LEVEL, \
+            f'The level should be in range [0,{_MAX_LEVEL}], got {level}.'
+        assert isinstance(min_mag, float), \
+            f'min_mag should be type float, got {type(min_mag)}.'
+        assert isinstance(max_mag, float), \
+            f'max_mag should be type float, got {type(max_mag)}.'
+        assert min_mag <= max_mag, \
+            f'min_mag should smaller than max_mag, ' \
+            f'got min_mag={min_mag} and max_mag={max_mag}'
+        self.prob = prob
+        self.level = level
+        self.min_mag = min_mag
+        self.max_mag = max_mag
+
+    def _transform_img(self, results: dict, mag: float) -> None:
+        """Transform the image."""
+        pass
+
+    @cache_randomness
+    def _random_disable(self):
+        """Randomly disable the transform."""
+        return np.random.rand() > self.prob
+
+    @cache_randomness
+    def _get_mag(self):
+        """Get the magnitude of the transform."""
+        return level_to_mag(self.level, self.min_mag, self.max_mag)
+
+    def transform(self, results: dict) -> dict:
+        """Transform function for images.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Transformed results.
+        """
+
+        if self._random_disable():
+            return results
+        mag = self._get_mag()
+        self._transform_img(results, mag)
+        return results
+
+    def __repr__(self) -> str:
+        repr_str = self.__class__.__name__
+        repr_str += f'(prob={self.prob}, '
+        repr_str += f'level={self.level}, '
+        repr_str += f'min_mag={self.min_mag}, '
+        repr_str += f'max_mag={self.max_mag})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class Color(ColorTransform):
+    """Adjust the color balance of the image, in a manner similar to the
+    controls on a colour TV set. A magnitude=0 gives a black & white image,
+    whereas magnitude=1 gives the original image. The bboxes, masks and
+    segmentations are not modified.
+
+    Required Keys:
+
+    - img
+
+    Modified Keys:
+
+    - img
+
+    Args:
+        prob (float): The probability for performing Color transformation.
+            Defaults to 1.0.
+        level (int, optional): Should be in range [0,_MAX_LEVEL].
+            If level is None, it will generate from [0, _MAX_LEVEL] randomly.
+            Defaults to None.
+        min_mag (float): The minimum magnitude for Color transformation.
+            Defaults to 0.1.
+        max_mag (float): The maximum magnitude for Color transformation.
+            Defaults to 1.9.
+    """
+
+    def __init__(self,
+                 prob: float = 1.0,
+                 level: Optional[int] = None,
+                 min_mag: float = 0.1,
+                 max_mag: float = 1.9) -> None:
+        assert 0. <= min_mag <= 2.0, \
+            f'min_mag for Color should be in range [0,2], got {min_mag}.'
+        assert 0. <= max_mag <= 2.0, \
+            f'max_mag for Color should be in range [0,2], got {max_mag}.'
+        super().__init__(
+            prob=prob, level=level, min_mag=min_mag, max_mag=max_mag)
+
+    def _transform_img(self, results: dict, mag: float) -> None:
+        """Apply Color transformation to image."""
+        # NOTE defaultly the image should be BGR format
+        img = results['img']
+        results['img'] = mmcv.adjust_color(img, mag).astype(img.dtype)
+
+
+@TRANSFORMS.register_module()
+class Brightness(ColorTransform):
+    """Adjust the brightness of the image. A magnitude=0 gives a black image,
+    whereas magnitude=1 gives the original image. The bboxes, masks and
+    segmentations are not modified.
+
+    Required Keys:
+
+    - img
+
+    Modified Keys:
+
+    - img
+
+    Args:
+        prob (float): The probability for performing Brightness transformation.
+            Defaults to 1.0.
+        level (int, optional): Should be in range [0,_MAX_LEVEL].
+            If level is None, it will generate from [0, _MAX_LEVEL] randomly.
+            Defaults to None.
+        min_mag (float): The minimum magnitude for Brightness transformation.
+            Defaults to 0.1.
+        max_mag (float): The maximum magnitude for Brightness transformation.
+            Defaults to 1.9.
+    """
+
+    def __init__(self,
+                 prob: float = 1.0,
+                 level: Optional[int] = None,
+                 min_mag: float = 0.1,
+                 max_mag: float = 1.9) -> None:
+        assert 0. <= min_mag <= 2.0, \
+            f'min_mag for Brightness should be in range [0,2], got {min_mag}.'
+        assert 0. <= max_mag <= 2.0, \
+            f'max_mag for Brightness should be in range [0,2], got {max_mag}.'
+        super().__init__(
+            prob=prob, level=level, min_mag=min_mag, max_mag=max_mag)
+
+    def _transform_img(self, results: dict, mag: float) -> None:
+        """Adjust the brightness of image."""
+        img = results['img']
+        results['img'] = mmcv.adjust_brightness(img, mag).astype(img.dtype)
+
+
+@TRANSFORMS.register_module()
+class Contrast(ColorTransform):
+    """Control the contrast of the image. A magnitude=0 gives a gray image,
+    whereas magnitude=1 gives the original imageThe bboxes, masks and
+    segmentations are not modified.
+
+    Required Keys:
+
+    - img
+
+    Modified Keys:
+
+    - img
+
+    Args:
+        prob (float): The probability for performing Contrast transformation.
+            Defaults to 1.0.
+        level (int, optional): Should be in range [0,_MAX_LEVEL].
+            If level is None, it will generate from [0, _MAX_LEVEL] randomly.
+            Defaults to None.
+        min_mag (float): The minimum magnitude for Contrast transformation.
+            Defaults to 0.1.
+        max_mag (float): The maximum magnitude for Contrast transformation.
+            Defaults to 1.9.
+    """
+
+    def __init__(self,
+                 prob: float = 1.0,
+                 level: Optional[int] = None,
+                 min_mag: float = 0.1,
+                 max_mag: float = 1.9) -> None:
+        assert 0. <= min_mag <= 2.0, \
+            f'min_mag for Contrast should be in range [0,2], got {min_mag}.'
+        assert 0. <= max_mag <= 2.0, \
+            f'max_mag for Contrast should be in range [0,2], got {max_mag}.'
+        super().__init__(
+            prob=prob, level=level, min_mag=min_mag, max_mag=max_mag)
+
+    def _transform_img(self, results: dict, mag: float) -> None:
+        """Adjust the image contrast."""
+        img = results['img']
+        results['img'] = mmcv.adjust_contrast(img, mag).astype(img.dtype)
+
+
+@TRANSFORMS.register_module()
+class Sharpness(ColorTransform):
+    """Adjust images sharpness. A positive magnitude would enhance the
+    sharpness and a negative magnitude would make the image blurry. A
+    magnitude=0 gives the origin img.
+
+    Required Keys:
+
+    - img
+
+    Modified Keys:
+
+    - img
+
+    Args:
+        prob (float): The probability for performing Sharpness transformation.
+            Defaults to 1.0.
+        level (int, optional): Should be in range [0,_MAX_LEVEL].
+            If level is None, it will generate from [0, _MAX_LEVEL] randomly.
+            Defaults to None.
+        min_mag (float): The minimum magnitude for Sharpness transformation.
+            Defaults to 0.1.
+        max_mag (float): The maximum magnitude for Sharpness transformation.
+            Defaults to 1.9.
+    """
+
+    def __init__(self,
+                 prob: float = 1.0,
+                 level: Optional[int] = None,
+                 min_mag: float = 0.1,
+                 max_mag: float = 1.9) -> None:
+        assert 0. <= min_mag <= 2.0, \
+            f'min_mag for Sharpness should be in range [0,2], got {min_mag}.'
+        assert 0. <= max_mag <= 2.0, \
+            f'max_mag for Sharpness should be in range [0,2], got {max_mag}.'
+        super().__init__(
+            prob=prob, level=level, min_mag=min_mag, max_mag=max_mag)
+
+    def _transform_img(self, results: dict, mag: float) -> None:
+        """Adjust the image sharpness."""
+        img = results['img']
+        results['img'] = mmcv.adjust_sharpness(img, mag).astype(img.dtype)
+
+
+@TRANSFORMS.register_module()
+class Solarize(ColorTransform):
+    """Solarize images (Invert all pixels above a threshold value of
+    magnitude.).
+
+    Required Keys:
+
+    - img
+
+    Modified Keys:
+
+    - img
+
+    Args:
+        prob (float): The probability for performing Solarize transformation.
+            Defaults to 1.0.
+        level (int, optional): Should be in range [0,_MAX_LEVEL].
+            If level is None, it will generate from [0, _MAX_LEVEL] randomly.
+            Defaults to None.
+        min_mag (float): The minimum magnitude for Solarize transformation.
+            Defaults to 0.0.
+        max_mag (float): The maximum magnitude for Solarize transformation.
+            Defaults to 256.0.
+    """
+
+    def __init__(self,
+                 prob: float = 1.0,
+                 level: Optional[int] = None,
+                 min_mag: float = 0.0,
+                 max_mag: float = 256.0) -> None:
+        assert 0. <= min_mag <= 256.0, f'min_mag for Solarize should be ' \
+                                       f'in range [0, 256], got {min_mag}.'
+        assert 0. <= max_mag <= 256.0, f'max_mag for Solarize should be ' \
+                                       f'in range [0, 256], got {max_mag}.'
+        super().__init__(
+            prob=prob, level=level, min_mag=min_mag, max_mag=max_mag)
+
+    def _transform_img(self, results: dict, mag: float) -> None:
+        """Invert all pixel values above magnitude."""
+        img = results['img']
+        results['img'] = mmcv.solarize(img, mag).astype(img.dtype)
+
+
+@TRANSFORMS.register_module()
+class SolarizeAdd(ColorTransform):
+    """SolarizeAdd images. For each pixel in the image that is less than 128,
+    add an additional amount to it decided by the magnitude.
+
+    Required Keys:
+
+    - img
+
+    Modified Keys:
+
+    - img
+
+    Args:
+        prob (float): The probability for performing SolarizeAdd
+            transformation. Defaults to 1.0.
+        level (int, optional): Should be in range [0,_MAX_LEVEL].
+            If level is None, it will generate from [0, _MAX_LEVEL] randomly.
+            Defaults to None.
+        min_mag (float): The minimum magnitude for SolarizeAdd transformation.
+            Defaults to 0.0.
+        max_mag (float): The maximum magnitude for SolarizeAdd transformation.
+            Defaults to 110.0.
+    """
+
+    def __init__(self,
+                 prob: float = 1.0,
+                 level: Optional[int] = None,
+                 min_mag: float = 0.0,
+                 max_mag: float = 110.0) -> None:
+        assert 0. <= min_mag <= 110.0, f'min_mag for SolarizeAdd should be ' \
+                                       f'in range [0, 110], got {min_mag}.'
+        assert 0. <= max_mag <= 110.0, f'max_mag for SolarizeAdd should be ' \
+                                       f'in range [0, 110], got {max_mag}.'
+        super().__init__(
+            prob=prob, level=level, min_mag=min_mag, max_mag=max_mag)
+
+    def _transform_img(self, results: dict, mag: float) -> None:
+        """SolarizeAdd the image."""
+        img = results['img']
+        img_solarized = np.where(img < 128, np.minimum(img + mag, 255), img)
+        results['img'] = img_solarized.astype(img.dtype)
+
+
+@TRANSFORMS.register_module()
+class Posterize(ColorTransform):
+    """Posterize images (reduce the number of bits for each color channel).
+
+    Required Keys:
+
+    - img
+
+    Modified Keys:
+
+    - img
+
+    Args:
+        prob (float): The probability for performing Posterize
+            transformation. Defaults to 1.0.
+        level (int, optional): Should be in range [0,_MAX_LEVEL].
+            If level is None, it will generate from [0, _MAX_LEVEL] randomly.
+            Defaults to None.
+        min_mag (float): The minimum magnitude for Posterize transformation.
+            Defaults to 0.0.
+        max_mag (float): The maximum magnitude for Posterize transformation.
+            Defaults to 4.0.
+    """
+
+    def __init__(self,
+                 prob: float = 1.0,
+                 level: Optional[int] = None,
+                 min_mag: float = 0.0,
+                 max_mag: float = 4.0) -> None:
+        assert 0. <= min_mag <= 8.0, f'min_mag for Posterize should be ' \
+                                     f'in range [0, 8], got {min_mag}.'
+        assert 0. <= max_mag <= 8.0, f'max_mag for Posterize should be ' \
+                                     f'in range [0, 8], got {max_mag}.'
+        super().__init__(
+            prob=prob, level=level, min_mag=min_mag, max_mag=max_mag)
+
+    def _transform_img(self, results: dict, mag: float) -> None:
+        """Posterize the image."""
+        img = results['img']
+        results['img'] = mmcv.posterize(img, math.ceil(mag)).astype(img.dtype)
+
+
+@TRANSFORMS.register_module()
+class Equalize(ColorTransform):
+    """Equalize the image histogram. The bboxes, masks and segmentations are
+    not modified.
+
+    Required Keys:
+
+    - img
+
+    Modified Keys:
+
+    - img
+
+    Args:
+        prob (float): The probability for performing Equalize transformation.
+            Defaults to 1.0.
+        level (int, optional): No use for Equalize transformation.
+            Defaults to None.
+        min_mag (float): No use for Equalize transformation. Defaults to 0.1.
+        max_mag (float): No use for Equalize transformation. Defaults to 1.9.
+    """
+
+    def _transform_img(self, results: dict, mag: float) -> None:
+        """Equalizes the histogram of one image."""
+        img = results['img']
+        results['img'] = mmcv.imequalize(img).astype(img.dtype)
+
+
+@TRANSFORMS.register_module()
+class AutoContrast(ColorTransform):
+    """Auto adjust image contrast.
+
+    Required Keys:
+
+    - img
+
+    Modified Keys:
+
+    - img
+
+    Args:
+        prob (float): The probability for performing AutoContrast should
+             be in range [0, 1]. Defaults to 1.0.
+        level (int, optional): No use for AutoContrast transformation.
+            Defaults to None.
+        min_mag (float): No use for AutoContrast transformation.
+            Defaults to 0.1.
+        max_mag (float): No use for AutoContrast transformation.
+            Defaults to 1.9.
+    """
+
+    def _transform_img(self, results: dict, mag: float) -> None:
+        """Auto adjust image contrast."""
+        img = results['img']
+        results['img'] = mmcv.auto_contrast(img).astype(img.dtype)
+
+
+@TRANSFORMS.register_module()
+class Invert(ColorTransform):
+    """Invert images.
+
+    Required Keys:
+
+    - img
+
+    Modified Keys:
+
+    - img
+
+    Args:
+        prob (float): The probability for performing invert therefore should
+             be in range [0, 1]. Defaults to 1.0.
+        level (int, optional): No use for Invert transformation.
+            Defaults to None.
+        min_mag (float): No use for Invert transformation. Defaults to 0.1.
+        max_mag (float): No use for Invert transformation. Defaults to 1.9.
+    """
+
+    def _transform_img(self, results: dict, mag: float) -> None:
+        """Invert the image."""
+        img = results['img']
+        results['img'] = mmcv.iminvert(img).astype(img.dtype)
diff --git a/mmdetection/mmdet/datasets/transforms/formatting.py b/mmdetection/mmdet/datasets/transforms/formatting.py
new file mode 100644
index 00000000..05263807
--- /dev/null
+++ b/mmdetection/mmdet/datasets/transforms/formatting.py
@@ -0,0 +1,512 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Sequence
+
+import numpy as np
+from mmcv.transforms import to_tensor
+from mmcv.transforms.base import BaseTransform
+from mmengine.structures import InstanceData, PixelData
+
+from mmdet.registry import TRANSFORMS
+from mmdet.structures import DetDataSample, ReIDDataSample, TrackDataSample
+from mmdet.structures.bbox import BaseBoxes
+
+
+@TRANSFORMS.register_module()
+class PackDetInputs(BaseTransform):
+    """Pack the inputs data for the detection / semantic segmentation /
+    panoptic segmentation.
+
+    The ``img_meta`` item is always populated.  The contents of the
+    ``img_meta`` dictionary depends on ``meta_keys``. By default this includes:
+
+        - ``img_id``: id of the image
+
+        - ``img_path``: path to the image file
+
+        - ``ori_shape``: original shape of the image as a tuple (h, w)
+
+        - ``img_shape``: shape of the image input to the network as a tuple \
+            (h, w).  Note that images may be zero padded on the \
+            bottom/right if the batch tensor is larger than this shape.
+
+        - ``scale_factor``: a float indicating the preprocessing scale
+
+        - ``flip``: a boolean indicating if image flip transform was used
+
+        - ``flip_direction``: the flipping direction
+
+    Args:
+        meta_keys (Sequence[str], optional): Meta keys to be converted to
+            ``mmcv.DataContainer`` and collected in ``data[img_metas]``.
+            Default: ``('img_id', 'img_path', 'ori_shape', 'img_shape',
+            'scale_factor', 'flip', 'flip_direction')``
+    """
+    mapping_table = {
+        'gt_bboxes': 'bboxes',
+        'gt_bboxes_labels': 'labels',
+        'gt_masks': 'masks'
+    }
+
+    def __init__(self,
+                 meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                            'scale_factor', 'flip', 'flip_direction')):
+        self.meta_keys = meta_keys
+
+    def transform(self, results: dict) -> dict:
+        """Method to pack the input data.
+
+        Args:
+            results (dict): Result dict from the data pipeline.
+
+        Returns:
+            dict:
+
+            - 'inputs' (obj:`torch.Tensor`): The forward data of models.
+            - 'data_sample' (obj:`DetDataSample`): The annotation info of the
+                sample.
+        """
+        packed_results = dict()
+        if 'img' in results:
+            img = results['img']
+            if len(img.shape) < 3:
+                img = np.expand_dims(img, -1)
+            # To improve the computational speed by by 3-5 times, apply:
+            # If image is not contiguous, use
+            # `numpy.transpose()` followed by `numpy.ascontiguousarray()`
+            # If image is already contiguous, use
+            # `torch.permute()` followed by `torch.contiguous()`
+            # Refer to https://github.com/open-mmlab/mmdetection/pull/9533
+            # for more details
+            if not img.flags.c_contiguous:
+                img = np.ascontiguousarray(img.transpose(2, 0, 1))
+                img = to_tensor(img)
+            else:
+                img = to_tensor(img).permute(2, 0, 1).contiguous()
+
+            packed_results['inputs'] = img
+
+        if 'gt_ignore_flags' in results:
+            valid_idx = np.where(results['gt_ignore_flags'] == 0)[0]
+            ignore_idx = np.where(results['gt_ignore_flags'] == 1)[0]
+
+        data_sample = DetDataSample()
+        instance_data = InstanceData()
+        ignore_instance_data = InstanceData()
+
+        for key in self.mapping_table.keys():
+            if key not in results:
+                continue
+            if key == 'gt_masks' or isinstance(results[key], BaseBoxes):
+                if 'gt_ignore_flags' in results:
+                    instance_data[
+                        self.mapping_table[key]] = results[key][valid_idx]
+                    ignore_instance_data[
+                        self.mapping_table[key]] = results[key][ignore_idx]
+                else:
+                    instance_data[self.mapping_table[key]] = results[key]
+            else:
+                if 'gt_ignore_flags' in results:
+                    instance_data[self.mapping_table[key]] = to_tensor(
+                        results[key][valid_idx])
+                    ignore_instance_data[self.mapping_table[key]] = to_tensor(
+                        results[key][ignore_idx])
+                else:
+                    instance_data[self.mapping_table[key]] = to_tensor(
+                        results[key])
+        data_sample.gt_instances = instance_data
+        data_sample.ignored_instances = ignore_instance_data
+
+        if 'proposals' in results:
+            proposals = InstanceData(
+                bboxes=to_tensor(results['proposals']),
+                scores=to_tensor(results['proposals_scores']))
+            data_sample.proposals = proposals
+
+        if 'gt_seg_map' in results:
+            gt_sem_seg_data = dict(
+                sem_seg=to_tensor(results['gt_seg_map'][None, ...].copy()))
+            gt_sem_seg_data = PixelData(**gt_sem_seg_data)
+            if 'ignore_index' in results:
+                metainfo = dict(ignore_index=results['ignore_index'])
+                gt_sem_seg_data.set_metainfo(metainfo)
+            data_sample.gt_sem_seg = gt_sem_seg_data
+
+        img_meta = {}
+        for key in self.meta_keys:
+            if key in results:
+                img_meta[key] = results[key]
+        data_sample.set_metainfo(img_meta)
+        packed_results['data_samples'] = data_sample
+
+        return packed_results
+
+    def __repr__(self) -> str:
+        repr_str = self.__class__.__name__
+        repr_str += f'(meta_keys={self.meta_keys})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class ToTensor:
+    """Convert some results to :obj:`torch.Tensor` by given keys.
+
+    Args:
+        keys (Sequence[str]): Keys that need to be converted to Tensor.
+    """
+
+    def __init__(self, keys):
+        self.keys = keys
+
+    def __call__(self, results):
+        """Call function to convert data in results to :obj:`torch.Tensor`.
+
+        Args:
+            results (dict): Result dict contains the data to convert.
+
+        Returns:
+            dict: The result dict contains the data converted
+                to :obj:`torch.Tensor`.
+        """
+        for key in self.keys:
+            results[key] = to_tensor(results[key])
+        return results
+
+    def __repr__(self):
+        return self.__class__.__name__ + f'(keys={self.keys})'
+
+
+@TRANSFORMS.register_module()
+class ImageToTensor:
+    """Convert image to :obj:`torch.Tensor` by given keys.
+
+    The dimension order of input image is (H, W, C). The pipeline will convert
+    it to (C, H, W). If only 2 dimension (H, W) is given, the output would be
+    (1, H, W).
+
+    Args:
+        keys (Sequence[str]): Key of images to be converted to Tensor.
+    """
+
+    def __init__(self, keys):
+        self.keys = keys
+
+    def __call__(self, results):
+        """Call function to convert image in results to :obj:`torch.Tensor` and
+        transpose the channel order.
+
+        Args:
+            results (dict): Result dict contains the image data to convert.
+
+        Returns:
+            dict: The result dict contains the image converted
+                to :obj:`torch.Tensor` and permuted to (C, H, W) order.
+        """
+        for key in self.keys:
+            img = results[key]
+            if len(img.shape) < 3:
+                img = np.expand_dims(img, -1)
+            results[key] = to_tensor(img).permute(2, 0, 1).contiguous()
+
+        return results
+
+    def __repr__(self):
+        return self.__class__.__name__ + f'(keys={self.keys})'
+
+
+@TRANSFORMS.register_module()
+class Transpose:
+    """Transpose some results by given keys.
+
+    Args:
+        keys (Sequence[str]): Keys of results to be transposed.
+        order (Sequence[int]): Order of transpose.
+    """
+
+    def __init__(self, keys, order):
+        self.keys = keys
+        self.order = order
+
+    def __call__(self, results):
+        """Call function to transpose the channel order of data in results.
+
+        Args:
+            results (dict): Result dict contains the data to transpose.
+
+        Returns:
+            dict: The result dict contains the data transposed to \
+                ``self.order``.
+        """
+        for key in self.keys:
+            results[key] = results[key].transpose(self.order)
+        return results
+
+    def __repr__(self):
+        return self.__class__.__name__ + \
+            f'(keys={self.keys}, order={self.order})'
+
+
+@TRANSFORMS.register_module()
+class WrapFieldsToLists:
+    """Wrap fields of the data dictionary into lists for evaluation.
+
+    This class can be used as a last step of a test or validation
+    pipeline for single image evaluation or inference.
+
+    Example:
+        >>> test_pipeline = [
+        >>>    dict(type='LoadImageFromFile'),
+        >>>    dict(type='Normalize',
+                    mean=[123.675, 116.28, 103.53],
+                    std=[58.395, 57.12, 57.375],
+                    to_rgb=True),
+        >>>    dict(type='Pad', size_divisor=32),
+        >>>    dict(type='ImageToTensor', keys=['img']),
+        >>>    dict(type='Collect', keys=['img']),
+        >>>    dict(type='WrapFieldsToLists')
+        >>> ]
+    """
+
+    def __call__(self, results):
+        """Call function to wrap fields into lists.
+
+        Args:
+            results (dict): Result dict contains the data to wrap.
+
+        Returns:
+            dict: The result dict where value of ``self.keys`` are wrapped \
+                into list.
+        """
+
+        # Wrap dict fields into lists
+        for key, val in results.items():
+            results[key] = [val]
+        return results
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}()'
+
+
+@TRANSFORMS.register_module()
+class PackTrackInputs(BaseTransform):
+    """Pack the inputs data for the multi object tracking and video instance
+    segmentation. All the information of images are packed to ``inputs``. All
+    the information except images are packed to ``data_samples``. In order to
+    get the original annotaiton and meta info, we add `instances` key into meta
+    keys.
+
+    Args:
+        meta_keys (Sequence[str]): Meta keys to be collected in
+            ``data_sample.metainfo``. Defaults to None.
+        default_meta_keys (tuple): Default meta keys. Defaults to ('img_id',
+            'img_path', 'ori_shape', 'img_shape', 'scale_factor',
+            'flip', 'flip_direction', 'frame_id', 'is_video_data',
+            'video_id', 'video_length', 'instances').
+    """
+    mapping_table = {
+        'gt_bboxes': 'bboxes',
+        'gt_bboxes_labels': 'labels',
+        'gt_masks': 'masks',
+        'gt_instances_ids': 'instances_ids'
+    }
+
+    def __init__(self,
+                 meta_keys: Optional[dict] = None,
+                 default_meta_keys: tuple = ('img_id', 'img_path', 'ori_shape',
+                                             'img_shape', 'scale_factor',
+                                             'flip', 'flip_direction',
+                                             'frame_id', 'video_id',
+                                             'video_length',
+                                             'ori_video_length', 'instances')):
+        self.meta_keys = default_meta_keys
+        if meta_keys is not None:
+            if isinstance(meta_keys, str):
+                meta_keys = (meta_keys, )
+            else:
+                assert isinstance(meta_keys, tuple), \
+                    'meta_keys must be str or tuple'
+            self.meta_keys += meta_keys
+
+    def transform(self, results: dict) -> dict:
+        """Method to pack the input data.
+        Args:
+            results (dict): Result dict from the data pipeline.
+        Returns:
+            dict:
+            - 'inputs' (dict[Tensor]): The forward data of models.
+            - 'data_samples' (obj:`TrackDataSample`): The annotation info of
+                the samples.
+        """
+        packed_results = dict()
+        packed_results['inputs'] = dict()
+
+        # 1. Pack images
+        if 'img' in results:
+            imgs = results['img']
+            imgs = np.stack(imgs, axis=0)
+            imgs = imgs.transpose(0, 3, 1, 2)
+            packed_results['inputs'] = to_tensor(imgs)
+
+        # 2. Pack InstanceData
+        if 'gt_ignore_flags' in results:
+            gt_ignore_flags_list = results['gt_ignore_flags']
+            valid_idx_list, ignore_idx_list = [], []
+            for gt_ignore_flags in gt_ignore_flags_list:
+                valid_idx = np.where(gt_ignore_flags == 0)[0]
+                ignore_idx = np.where(gt_ignore_flags == 1)[0]
+                valid_idx_list.append(valid_idx)
+                ignore_idx_list.append(ignore_idx)
+
+        assert 'img_id' in results, "'img_id' must contained in the results "
+        'for counting the number of images'
+
+        num_imgs = len(results['img_id'])
+        instance_data_list = [InstanceData() for _ in range(num_imgs)]
+        ignore_instance_data_list = [InstanceData() for _ in range(num_imgs)]
+
+        for key in self.mapping_table.keys():
+            if key not in results:
+                continue
+            if key == 'gt_masks':
+                mapped_key = self.mapping_table[key]
+                gt_masks_list = results[key]
+                if 'gt_ignore_flags' in results:
+                    for i, gt_mask in enumerate(gt_masks_list):
+                        valid_idx, ignore_idx = valid_idx_list[
+                            i], ignore_idx_list[i]
+                        instance_data_list[i][mapped_key] = gt_mask[valid_idx]
+                        ignore_instance_data_list[i][mapped_key] = gt_mask[
+                            ignore_idx]
+
+                else:
+                    for i, gt_mask in enumerate(gt_masks_list):
+                        instance_data_list[i][mapped_key] = gt_mask
+
+            else:
+                anns_list = results[key]
+                if 'gt_ignore_flags' in results:
+                    for i, ann in enumerate(anns_list):
+                        valid_idx, ignore_idx = valid_idx_list[
+                            i], ignore_idx_list[i]
+                        instance_data_list[i][
+                            self.mapping_table[key]] = to_tensor(
+                                ann[valid_idx])
+                        ignore_instance_data_list[i][
+                            self.mapping_table[key]] = to_tensor(
+                                ann[ignore_idx])
+                else:
+                    for i, ann in enumerate(anns_list):
+                        instance_data_list[i][
+                            self.mapping_table[key]] = to_tensor(ann)
+
+        det_data_samples_list = []
+        for i in range(num_imgs):
+            det_data_sample = DetDataSample()
+            det_data_sample.gt_instances = instance_data_list[i]
+            det_data_sample.ignored_instances = ignore_instance_data_list[i]
+            det_data_samples_list.append(det_data_sample)
+
+        # 3. Pack metainfo
+        for key in self.meta_keys:
+            if key not in results:
+                continue
+            img_metas_list = results[key]
+            for i, img_meta in enumerate(img_metas_list):
+                det_data_samples_list[i].set_metainfo({f'{key}': img_meta})
+
+        track_data_sample = TrackDataSample()
+        track_data_sample.video_data_samples = det_data_samples_list
+        if 'key_frame_flags' in results:
+            key_frame_flags = np.asarray(results['key_frame_flags'])
+            key_frames_inds = np.where(key_frame_flags)[0].tolist()
+            ref_frames_inds = np.where(~key_frame_flags)[0].tolist()
+            track_data_sample.set_metainfo(
+                dict(key_frames_inds=key_frames_inds))
+            track_data_sample.set_metainfo(
+                dict(ref_frames_inds=ref_frames_inds))
+
+        packed_results['data_samples'] = track_data_sample
+        return packed_results
+
+    def __repr__(self) -> str:
+        repr_str = self.__class__.__name__
+        repr_str += f'meta_keys={self.meta_keys}, '
+        repr_str += f'default_meta_keys={self.default_meta_keys})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class PackReIDInputs(BaseTransform):
+    """Pack the inputs data for the ReID. The ``meta_info`` item is always
+    populated. The contents of the ``meta_info`` dictionary depends on
+    ``meta_keys``. By default this includes:
+
+        - ``img_path``: path to the image file.
+        - ``ori_shape``: original shape of the image as a tuple (H, W).
+        - ``img_shape``: shape of the image input to the network as a tuple
+            (H, W). Note that images may be zero padded on the bottom/right
+          if the batch tensor is larger than this shape.
+        - ``scale``: scale of the image as a tuple (W, H).
+        - ``scale_factor``: a float indicating the pre-processing scale.
+        -  ``flip``: a boolean indicating if image flip transform was used.
+        - ``flip_direction``: the flipping direction.
+    Args:
+        meta_keys (Sequence[str], optional): The meta keys to saved in the
+            ``metainfo`` of the packed ``data_sample``.
+    """
+    default_meta_keys = ('img_path', 'ori_shape', 'img_shape', 'scale',
+                         'scale_factor')
+
+    def __init__(self, meta_keys: Sequence[str] = ()) -> None:
+        self.meta_keys = self.default_meta_keys
+        if meta_keys is not None:
+            if isinstance(meta_keys, str):
+                meta_keys = (meta_keys, )
+            else:
+                assert isinstance(meta_keys, tuple), \
+                    'meta_keys must be str or tuple.'
+            self.meta_keys += meta_keys
+
+    def transform(self, results: dict) -> dict:
+        """Method to pack the input data.
+        Args:
+            results (dict): Result dict from the data pipeline.
+        Returns:
+            dict:
+            - 'inputs' (dict[Tensor]): The forward data of models.
+            - 'data_samples' (obj:`ReIDDataSample`): The meta info of the
+                sample.
+        """
+        packed_results = dict(inputs=dict(), data_samples=None)
+        assert 'img' in results, 'Missing the key ``img``.'
+        _type = type(results['img'])
+        label = results['gt_label']
+
+        if _type == list:
+            img = results['img']
+            label = np.stack(label, axis=0)  # (N,)
+            assert all([type(v) == _type for v in results.values()]), \
+                'All items in the results must have the same type.'
+        else:
+            img = [results['img']]
+
+        img = np.stack(img, axis=3)  # (H, W, C, N)
+        img = img.transpose(3, 2, 0, 1)  # (N, C, H, W)
+        img = np.ascontiguousarray(img)
+
+        packed_results['inputs'] = to_tensor(img)
+
+        data_sample = ReIDDataSample()
+        data_sample.set_gt_label(label)
+
+        meta_info = dict()
+        for key in self.meta_keys:
+            meta_info[key] = results[key]
+        data_sample.set_metainfo(meta_info)
+        packed_results['data_samples'] = data_sample
+
+        return packed_results
+
+    def __repr__(self) -> str:
+        repr_str = self.__class__.__name__
+        repr_str += f'(meta_keys={self.meta_keys})'
+        return repr_str
diff --git a/mmdetection/mmdet/datasets/transforms/frame_sampling.py b/mmdetection/mmdet/datasets/transforms/frame_sampling.py
new file mode 100644
index 00000000..a91f1e78
--- /dev/null
+++ b/mmdetection/mmdet/datasets/transforms/frame_sampling.py
@@ -0,0 +1,177 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import random
+from collections import defaultdict
+from typing import Dict, List, Optional, Union
+
+from mmcv.transforms import BaseTransform
+
+from mmdet.registry import TRANSFORMS
+
+
+@TRANSFORMS.register_module()
+class BaseFrameSample(BaseTransform):
+    """Directly get the key frame, no reference frames.
+
+    Args:
+        collect_video_keys (list[str]): The keys of video info to be
+            collected.
+    """
+
+    def __init__(self,
+                 collect_video_keys: List[str] = ['video_id', 'video_length']):
+        self.collect_video_keys = collect_video_keys
+
+    def prepare_data(self, video_infos: dict,
+                     sampled_inds: List[int]) -> Dict[str, List]:
+        """Prepare data for the subsequent pipeline.
+
+        Args:
+            video_infos (dict): The whole video information.
+            sampled_inds (list[int]): The sampled frame indices.
+
+        Returns:
+            dict: The processed data information.
+        """
+        frames_anns = video_infos['images']
+        final_data_info = defaultdict(list)
+        # for data in frames_anns:
+        for index in sampled_inds:
+            data = frames_anns[index]
+            # copy the info in video-level into img-level
+            for key in self.collect_video_keys:
+                if key == 'video_length':
+                    data['ori_video_length'] = video_infos[key]
+                    data['video_length'] = len(sampled_inds)
+                else:
+                    data[key] = video_infos[key]
+            # Collate data_list (list of dict to dict of list)
+            for key, value in data.items():
+                final_data_info[key].append(value)
+
+        return final_data_info
+
+    def transform(self, video_infos: dict) -> Optional[Dict[str, List]]:
+        """Transform the video information.
+
+        Args:
+            video_infos (dict): The whole video information.
+
+        Returns:
+            dict: The data information of the key frames.
+        """
+        if 'key_frame_id' in video_infos:
+            key_frame_id = video_infos['key_frame_id']
+            assert isinstance(video_infos['key_frame_id'], int)
+        else:
+            key_frame_id = random.sample(
+                list(range(video_infos['video_length'])), 1)[0]
+        results = self.prepare_data(video_infos, [key_frame_id])
+
+        return results
+
+    def __repr__(self) -> str:
+        repr_str = self.__class__.__name__
+        repr_str += f'(collect_video_keys={self.collect_video_keys})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class UniformRefFrameSample(BaseFrameSample):
+    """Uniformly sample reference frames.
+
+    Args:
+        num_ref_imgs (int): Number of reference frames to be sampled.
+        frame_range (int | list[int]): Range of frames to be sampled around
+            key frame. If int, the range is [-frame_range, frame_range].
+            Defaults to 10.
+        filter_key_img (bool): Whether to filter the key frame when
+            sampling reference frames. Defaults to True.
+        collect_video_keys (list[str]): The keys of video info to be
+            collected.
+    """
+
+    def __init__(self,
+                 num_ref_imgs: int = 1,
+                 frame_range: Union[int, List[int]] = 10,
+                 filter_key_img: bool = True,
+                 collect_video_keys: List[str] = ['video_id', 'video_length']):
+        self.num_ref_imgs = num_ref_imgs
+        self.filter_key_img = filter_key_img
+        if isinstance(frame_range, int):
+            assert frame_range >= 0, 'frame_range can not be a negative value.'
+            frame_range = [-frame_range, frame_range]
+        elif isinstance(frame_range, list):
+            assert len(frame_range) == 2, 'The length must be 2.'
+            assert frame_range[0] <= 0 and frame_range[1] >= 0
+            for i in frame_range:
+                assert isinstance(i, int), 'Each element must be int.'
+        else:
+            raise TypeError('The type of frame_range must be int or list.')
+        self.frame_range = frame_range
+        super().__init__(collect_video_keys=collect_video_keys)
+
+    def sampling_frames(self, video_length: int, key_frame_id: int):
+        """Sampling frames.
+
+        Args:
+            video_length (int): The length of the video.
+            key_frame_id (int): The key frame id.
+
+        Returns:
+            list[int]: The sampled frame indices.
+        """
+        if video_length > 1:
+            left = max(0, key_frame_id + self.frame_range[0])
+            right = min(key_frame_id + self.frame_range[1], video_length - 1)
+            frame_ids = list(range(0, video_length))
+
+            valid_ids = frame_ids[left:right + 1]
+            if self.filter_key_img and key_frame_id in valid_ids:
+                valid_ids.remove(key_frame_id)
+            assert len(
+                valid_ids
+            ) > 0, 'After filtering key frame, there are no valid frames'
+            if len(valid_ids) < self.num_ref_imgs:
+                valid_ids = valid_ids * self.num_ref_imgs
+            ref_frame_ids = random.sample(valid_ids, self.num_ref_imgs)
+        else:
+            ref_frame_ids = [key_frame_id] * self.num_ref_imgs
+
+        sampled_frames_ids = [key_frame_id] + ref_frame_ids
+        sampled_frames_ids = sorted(sampled_frames_ids)
+
+        key_frames_ind = sampled_frames_ids.index(key_frame_id)
+        key_frame_flags = [False] * len(sampled_frames_ids)
+        key_frame_flags[key_frames_ind] = True
+        return sampled_frames_ids, key_frame_flags
+
+    def transform(self, video_infos: dict) -> Optional[Dict[str, List]]:
+        """Transform the video information.
+
+        Args:
+            video_infos (dict): The whole video information.
+
+        Returns:
+            dict: The data information of the sampled frames.
+        """
+        if 'key_frame_id' in video_infos:
+            key_frame_id = video_infos['key_frame_id']
+            assert isinstance(video_infos['key_frame_id'], int)
+        else:
+            key_frame_id = random.sample(
+                list(range(video_infos['video_length'])), 1)[0]
+
+        (sampled_frames_ids, key_frame_flags) = self.sampling_frames(
+            video_infos['video_length'], key_frame_id=key_frame_id)
+        results = self.prepare_data(video_infos, sampled_frames_ids)
+        results['key_frame_flags'] = key_frame_flags
+
+        return results
+
+    def __repr__(self) -> str:
+        repr_str = self.__class__.__name__
+        repr_str += f'(num_ref_imgs={self.num_ref_imgs}, '
+        repr_str += f'frame_range={self.frame_range}, '
+        repr_str += f'filter_key_img={self.filter_key_img}, '
+        repr_str += f'collect_video_keys={self.collect_video_keys})'
+        return repr_str
diff --git a/mmdetection/mmdet/datasets/transforms/geometric.py b/mmdetection/mmdet/datasets/transforms/geometric.py
new file mode 100644
index 00000000..d2cd6be2
--- /dev/null
+++ b/mmdetection/mmdet/datasets/transforms/geometric.py
@@ -0,0 +1,754 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+from typing import Optional, Union
+
+import cv2
+import mmcv
+import numpy as np
+from mmcv.transforms import BaseTransform
+from mmcv.transforms.utils import cache_randomness
+
+from mmdet.registry import TRANSFORMS
+from mmdet.structures.bbox import autocast_box_type
+from .augment_wrappers import _MAX_LEVEL, level_to_mag
+
+
+@TRANSFORMS.register_module()
+class GeomTransform(BaseTransform):
+    """Base class for geometric transformations. All geometric transformations
+    need to inherit from this base class. ``GeomTransform`` unifies the class
+    attributes and class functions of geometric transformations (ShearX,
+    ShearY, Rotate, TranslateX, and TranslateY), and records the homography
+    matrix.
+
+    Required Keys:
+
+    - img
+    - gt_bboxes (BaseBoxes[torch.float32]) (optional)
+    - gt_masks (BitmapMasks | PolygonMasks) (optional)
+    - gt_seg_map (np.uint8) (optional)
+
+    Modified Keys:
+
+    - img
+    - gt_bboxes
+    - gt_masks
+    - gt_seg_map
+
+    Added Keys:
+
+    - homography_matrix
+
+    Args:
+        prob (float): The probability for performing the geometric
+            transformation and should be in range [0, 1]. Defaults to 1.0.
+        level (int, optional): The level should be in range [0, _MAX_LEVEL].
+            If level is None, it will generate from [0, _MAX_LEVEL] randomly.
+            Defaults to None.
+        min_mag (float): The minimum magnitude for geometric transformation.
+            Defaults to 0.0.
+        max_mag (float): The maximum magnitude for geometric transformation.
+            Defaults to 1.0.
+        reversal_prob (float): The probability that reverses the geometric
+            transformation magnitude. Should be in range [0,1].
+            Defaults to 0.5.
+        img_border_value (int | float | tuple): The filled values for
+            image border. If float, the same fill value will be used for
+            all the three channels of image. If tuple, it should be 3 elements.
+            Defaults to 128.
+        mask_border_value (int): The fill value used for masks. Defaults to 0.
+        seg_ignore_label (int): The fill value used for segmentation map.
+            Note this value must equals ``ignore_label`` in ``semantic_head``
+            of the corresponding config. Defaults to 255.
+        interpolation (str): Interpolation method, accepted values are
+            "nearest", "bilinear", "bicubic", "area", "lanczos" for 'cv2'
+            backend, "nearest", "bilinear" for 'pillow' backend. Defaults
+            to 'bilinear'.
+    """
+
+    def __init__(self,
+                 prob: float = 1.0,
+                 level: Optional[int] = None,
+                 min_mag: float = 0.0,
+                 max_mag: float = 1.0,
+                 reversal_prob: float = 0.5,
+                 img_border_value: Union[int, float, tuple] = 128,
+                 mask_border_value: int = 0,
+                 seg_ignore_label: int = 255,
+                 interpolation: str = 'bilinear') -> None:
+        assert 0 <= prob <= 1.0, f'The probability of the transformation ' \
+                                 f'should be in range [0,1], got {prob}.'
+        assert level is None or isinstance(level, int), \
+            f'The level should be None or type int, got {type(level)}.'
+        assert level is None or 0 <= level <= _MAX_LEVEL, \
+            f'The level should be in range [0,{_MAX_LEVEL}], got {level}.'
+        assert isinstance(min_mag, float), \
+            f'min_mag should be type float, got {type(min_mag)}.'
+        assert isinstance(max_mag, float), \
+            f'max_mag should be type float, got {type(max_mag)}.'
+        assert min_mag <= max_mag, \
+            f'min_mag should smaller than max_mag, ' \
+            f'got min_mag={min_mag} and max_mag={max_mag}'
+        assert isinstance(reversal_prob, float), \
+            f'reversal_prob should be type float, got {type(max_mag)}.'
+        assert 0 <= reversal_prob <= 1.0, \
+            f'The reversal probability of the transformation magnitude ' \
+            f'should be type float, got {type(reversal_prob)}.'
+        if isinstance(img_border_value, (float, int)):
+            img_border_value = tuple([float(img_border_value)] * 3)
+        elif isinstance(img_border_value, tuple):
+            assert len(img_border_value) == 3, \
+                f'img_border_value as tuple must have 3 elements, ' \
+                f'got {len(img_border_value)}.'
+            img_border_value = tuple([float(val) for val in img_border_value])
+        else:
+            raise ValueError(
+                'img_border_value must be float or tuple with 3 elements.')
+        assert np.all([0 <= val <= 255 for val in img_border_value]), 'all ' \
+            'elements of img_border_value should between range [0,255].' \
+            f'got {img_border_value}.'
+        self.prob = prob
+        self.level = level
+        self.min_mag = min_mag
+        self.max_mag = max_mag
+        self.reversal_prob = reversal_prob
+        self.img_border_value = img_border_value
+        self.mask_border_value = mask_border_value
+        self.seg_ignore_label = seg_ignore_label
+        self.interpolation = interpolation
+
+    def _transform_img(self, results: dict, mag: float) -> None:
+        """Transform the image."""
+        pass
+
+    def _transform_masks(self, results: dict, mag: float) -> None:
+        """Transform the masks."""
+        pass
+
+    def _transform_seg(self, results: dict, mag: float) -> None:
+        """Transform the segmentation map."""
+        pass
+
+    def _get_homography_matrix(self, results: dict, mag: float) -> np.ndarray:
+        """Get the homography matrix for the geometric transformation."""
+        return np.eye(3, dtype=np.float32)
+
+    def _transform_bboxes(self, results: dict, mag: float) -> None:
+        """Transform the bboxes."""
+        results['gt_bboxes'].project_(self.homography_matrix)
+        results['gt_bboxes'].clip_(results['img_shape'])
+
+    def _record_homography_matrix(self, results: dict) -> None:
+        """Record the homography matrix for the geometric transformation."""
+        if results.get('homography_matrix', None) is None:
+            results['homography_matrix'] = self.homography_matrix
+        else:
+            results['homography_matrix'] = self.homography_matrix @ results[
+                'homography_matrix']
+
+    @cache_randomness
+    def _random_disable(self):
+        """Randomly disable the transform."""
+        return np.random.rand() > self.prob
+
+    @cache_randomness
+    def _get_mag(self):
+        """Get the magnitude of the transform."""
+        mag = level_to_mag(self.level, self.min_mag, self.max_mag)
+        return -mag if np.random.rand() > self.reversal_prob else mag
+
+    @autocast_box_type()
+    def transform(self, results: dict) -> dict:
+        """Transform function for images, bounding boxes, masks and semantic
+        segmentation map.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Transformed results.
+        """
+
+        if self._random_disable():
+            return results
+        mag = self._get_mag()
+        self.homography_matrix = self._get_homography_matrix(results, mag)
+        self._record_homography_matrix(results)
+        self._transform_img(results, mag)
+        if results.get('gt_bboxes', None) is not None:
+            self._transform_bboxes(results, mag)
+        if results.get('gt_masks', None) is not None:
+            self._transform_masks(results, mag)
+        if results.get('gt_seg_map', None) is not None:
+            self._transform_seg(results, mag)
+        return results
+
+    def __repr__(self) -> str:
+        repr_str = self.__class__.__name__
+        repr_str += f'(prob={self.prob}, '
+        repr_str += f'level={self.level}, '
+        repr_str += f'min_mag={self.min_mag}, '
+        repr_str += f'max_mag={self.max_mag}, '
+        repr_str += f'reversal_prob={self.reversal_prob}, '
+        repr_str += f'img_border_value={self.img_border_value}, '
+        repr_str += f'mask_border_value={self.mask_border_value}, '
+        repr_str += f'seg_ignore_label={self.seg_ignore_label}, '
+        repr_str += f'interpolation={self.interpolation})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class ShearX(GeomTransform):
+    """Shear the images, bboxes, masks and segmentation map horizontally.
+
+    Required Keys:
+
+    - img
+    - gt_bboxes (BaseBoxes[torch.float32]) (optional)
+    - gt_masks (BitmapMasks | PolygonMasks) (optional)
+    - gt_seg_map (np.uint8) (optional)
+
+    Modified Keys:
+
+    - img
+    - gt_bboxes
+    - gt_masks
+    - gt_seg_map
+
+    Added Keys:
+
+    - homography_matrix
+
+    Args:
+        prob (float): The probability for performing Shear and should be in
+            range [0, 1]. Defaults to 1.0.
+        level (int, optional): The level should be in range [0, _MAX_LEVEL].
+            If level is None, it will generate from [0, _MAX_LEVEL] randomly.
+            Defaults to None.
+        min_mag (float): The minimum angle for the horizontal shear.
+            Defaults to 0.0.
+        max_mag (float): The maximum angle for the horizontal shear.
+            Defaults to 30.0.
+        reversal_prob (float): The probability that reverses the horizontal
+            shear magnitude. Should be in range [0,1]. Defaults to 0.5.
+        img_border_value (int | float | tuple): The filled values for
+            image border. If float, the same fill value will be used for
+            all the three channels of image. If tuple, it should be 3 elements.
+            Defaults to 128.
+        mask_border_value (int): The fill value used for masks. Defaults to 0.
+        seg_ignore_label (int): The fill value used for segmentation map.
+            Note this value must equals ``ignore_label`` in ``semantic_head``
+            of the corresponding config. Defaults to 255.
+        interpolation (str): Interpolation method, accepted values are
+            "nearest", "bilinear", "bicubic", "area", "lanczos" for 'cv2'
+            backend, "nearest", "bilinear" for 'pillow' backend. Defaults
+            to 'bilinear'.
+    """
+
+    def __init__(self,
+                 prob: float = 1.0,
+                 level: Optional[int] = None,
+                 min_mag: float = 0.0,
+                 max_mag: float = 30.0,
+                 reversal_prob: float = 0.5,
+                 img_border_value: Union[int, float, tuple] = 128,
+                 mask_border_value: int = 0,
+                 seg_ignore_label: int = 255,
+                 interpolation: str = 'bilinear') -> None:
+        assert 0. <= min_mag <= 90., \
+            f'min_mag angle for ShearX should be ' \
+            f'in range [0, 90], got {min_mag}.'
+        assert 0. <= max_mag <= 90., \
+            f'max_mag angle for ShearX should be ' \
+            f'in range [0, 90], got {max_mag}.'
+        super().__init__(
+            prob=prob,
+            level=level,
+            min_mag=min_mag,
+            max_mag=max_mag,
+            reversal_prob=reversal_prob,
+            img_border_value=img_border_value,
+            mask_border_value=mask_border_value,
+            seg_ignore_label=seg_ignore_label,
+            interpolation=interpolation)
+
+    @cache_randomness
+    def _get_mag(self):
+        """Get the magnitude of the transform."""
+        mag = level_to_mag(self.level, self.min_mag, self.max_mag)
+        mag = np.tan(mag * np.pi / 180)
+        return -mag if np.random.rand() > self.reversal_prob else mag
+
+    def _get_homography_matrix(self, results: dict, mag: float) -> np.ndarray:
+        """Get the homography matrix for ShearX."""
+        return np.array([[1, mag, 0], [0, 1, 0], [0, 0, 1]], dtype=np.float32)
+
+    def _transform_img(self, results: dict, mag: float) -> None:
+        """Shear the image horizontally."""
+        results['img'] = mmcv.imshear(
+            results['img'],
+            mag,
+            direction='horizontal',
+            border_value=self.img_border_value,
+            interpolation=self.interpolation)
+
+    def _transform_masks(self, results: dict, mag: float) -> None:
+        """Shear the masks horizontally."""
+        results['gt_masks'] = results['gt_masks'].shear(
+            results['img_shape'],
+            mag,
+            direction='horizontal',
+            border_value=self.mask_border_value,
+            interpolation=self.interpolation)
+
+    def _transform_seg(self, results: dict, mag: float) -> None:
+        """Shear the segmentation map horizontally."""
+        results['gt_seg_map'] = mmcv.imshear(
+            results['gt_seg_map'],
+            mag,
+            direction='horizontal',
+            border_value=self.seg_ignore_label,
+            interpolation='nearest')
+
+
+@TRANSFORMS.register_module()
+class ShearY(GeomTransform):
+    """Shear the images, bboxes, masks and segmentation map vertically.
+
+    Required Keys:
+
+    - img
+    - gt_bboxes (BaseBoxes[torch.float32]) (optional)
+    - gt_masks (BitmapMasks | PolygonMasks) (optional)
+    - gt_seg_map (np.uint8) (optional)
+
+    Modified Keys:
+
+    - img
+    - gt_bboxes
+    - gt_masks
+    - gt_seg_map
+
+    Added Keys:
+
+    - homography_matrix
+
+    Args:
+        prob (float): The probability for performing ShearY and should be in
+            range [0, 1]. Defaults to 1.0.
+        level (int, optional): The level should be in range [0,_MAX_LEVEL].
+            If level is None, it will generate from [0, _MAX_LEVEL] randomly.
+            Defaults to None.
+        min_mag (float): The minimum angle for the vertical shear.
+            Defaults to 0.0.
+        max_mag (float): The maximum angle for the vertical shear.
+            Defaults to 30.0.
+        reversal_prob (float): The probability that reverses the vertical
+            shear magnitude. Should be in range [0,1]. Defaults to 0.5.
+        img_border_value (int | float | tuple): The filled values for
+            image border. If float, the same fill value will be used for
+            all the three channels of image. If tuple, it should be 3 elements.
+            Defaults to 128.
+        mask_border_value (int): The fill value used for masks. Defaults to 0.
+        seg_ignore_label (int): The fill value used for segmentation map.
+            Note this value must equals ``ignore_label`` in ``semantic_head``
+            of the corresponding config. Defaults to 255.
+        interpolation (str): Interpolation method, accepted values are
+            "nearest", "bilinear", "bicubic", "area", "lanczos" for 'cv2'
+            backend, "nearest", "bilinear" for 'pillow' backend. Defaults
+            to 'bilinear'.
+    """
+
+    def __init__(self,
+                 prob: float = 1.0,
+                 level: Optional[int] = None,
+                 min_mag: float = 0.0,
+                 max_mag: float = 30.,
+                 reversal_prob: float = 0.5,
+                 img_border_value: Union[int, float, tuple] = 128,
+                 mask_border_value: int = 0,
+                 seg_ignore_label: int = 255,
+                 interpolation: str = 'bilinear') -> None:
+        assert 0. <= min_mag <= 90., \
+            f'min_mag angle for ShearY should be ' \
+            f'in range [0, 90], got {min_mag}.'
+        assert 0. <= max_mag <= 90., \
+            f'max_mag angle for ShearY should be ' \
+            f'in range [0, 90], got {max_mag}.'
+        super().__init__(
+            prob=prob,
+            level=level,
+            min_mag=min_mag,
+            max_mag=max_mag,
+            reversal_prob=reversal_prob,
+            img_border_value=img_border_value,
+            mask_border_value=mask_border_value,
+            seg_ignore_label=seg_ignore_label,
+            interpolation=interpolation)
+
+    @cache_randomness
+    def _get_mag(self):
+        """Get the magnitude of the transform."""
+        mag = level_to_mag(self.level, self.min_mag, self.max_mag)
+        mag = np.tan(mag * np.pi / 180)
+        return -mag if np.random.rand() > self.reversal_prob else mag
+
+    def _get_homography_matrix(self, results: dict, mag: float) -> np.ndarray:
+        """Get the homography matrix for ShearY."""
+        return np.array([[1, 0, 0], [mag, 1, 0], [0, 0, 1]], dtype=np.float32)
+
+    def _transform_img(self, results: dict, mag: float) -> None:
+        """Shear the image vertically."""
+        results['img'] = mmcv.imshear(
+            results['img'],
+            mag,
+            direction='vertical',
+            border_value=self.img_border_value,
+            interpolation=self.interpolation)
+
+    def _transform_masks(self, results: dict, mag: float) -> None:
+        """Shear the masks vertically."""
+        results['gt_masks'] = results['gt_masks'].shear(
+            results['img_shape'],
+            mag,
+            direction='vertical',
+            border_value=self.mask_border_value,
+            interpolation=self.interpolation)
+
+    def _transform_seg(self, results: dict, mag: float) -> None:
+        """Shear the segmentation map vertically."""
+        results['gt_seg_map'] = mmcv.imshear(
+            results['gt_seg_map'],
+            mag,
+            direction='vertical',
+            border_value=self.seg_ignore_label,
+            interpolation='nearest')
+
+
+@TRANSFORMS.register_module()
+class Rotate(GeomTransform):
+    """Rotate the images, bboxes, masks and segmentation map.
+
+    Required Keys:
+
+    - img
+    - gt_bboxes (BaseBoxes[torch.float32]) (optional)
+    - gt_masks (BitmapMasks | PolygonMasks) (optional)
+    - gt_seg_map (np.uint8) (optional)
+
+    Modified Keys:
+
+    - img
+    - gt_bboxes
+    - gt_masks
+    - gt_seg_map
+
+    Added Keys:
+
+    - homography_matrix
+
+    Args:
+        prob (float): The probability for perform transformation and
+            should be in range 0 to 1. Defaults to 1.0.
+        level (int, optional): The level should be in range [0, _MAX_LEVEL].
+            If level is None, it will generate from [0, _MAX_LEVEL] randomly.
+            Defaults to None.
+        min_mag (float): The maximum angle for rotation.
+            Defaults to 0.0.
+        max_mag (float): The maximum angle for rotation.
+            Defaults to 30.0.
+        reversal_prob (float): The probability that reverses the rotation
+            magnitude. Should be in range [0,1]. Defaults to 0.5.
+        img_border_value (int | float | tuple): The filled values for
+            image border. If float, the same fill value will be used for
+            all the three channels of image. If tuple, it should be 3 elements.
+            Defaults to 128.
+        mask_border_value (int): The fill value used for masks. Defaults to 0.
+        seg_ignore_label (int): The fill value used for segmentation map.
+            Note this value must equals ``ignore_label`` in ``semantic_head``
+            of the corresponding config. Defaults to 255.
+        interpolation (str): Interpolation method, accepted values are
+            "nearest", "bilinear", "bicubic", "area", "lanczos" for 'cv2'
+            backend, "nearest", "bilinear" for 'pillow' backend. Defaults
+            to 'bilinear'.
+    """
+
+    def __init__(self,
+                 prob: float = 1.0,
+                 level: Optional[int] = None,
+                 min_mag: float = 0.0,
+                 max_mag: float = 30.0,
+                 reversal_prob: float = 0.5,
+                 img_border_value: Union[int, float, tuple] = 128,
+                 mask_border_value: int = 0,
+                 seg_ignore_label: int = 255,
+                 interpolation: str = 'bilinear') -> None:
+        assert 0. <= min_mag <= 180., \
+            f'min_mag for Rotate should be in range [0,180], got {min_mag}.'
+        assert 0. <= max_mag <= 180., \
+            f'max_mag for Rotate should be in range [0,180], got {max_mag}.'
+        super().__init__(
+            prob=prob,
+            level=level,
+            min_mag=min_mag,
+            max_mag=max_mag,
+            reversal_prob=reversal_prob,
+            img_border_value=img_border_value,
+            mask_border_value=mask_border_value,
+            seg_ignore_label=seg_ignore_label,
+            interpolation=interpolation)
+
+    def _get_homography_matrix(self, results: dict, mag: float) -> np.ndarray:
+        """Get the homography matrix for Rotate."""
+        img_shape = results['img_shape']
+        center = ((img_shape[1] - 1) * 0.5, (img_shape[0] - 1) * 0.5)
+        cv2_rotation_matrix = cv2.getRotationMatrix2D(center, -mag, 1.0)
+        return np.concatenate(
+            [cv2_rotation_matrix,
+             np.array([0, 0, 1]).reshape((1, 3))]).astype(np.float32)
+
+    def _transform_img(self, results: dict, mag: float) -> None:
+        """Rotate the image."""
+        results['img'] = mmcv.imrotate(
+            results['img'],
+            mag,
+            border_value=self.img_border_value,
+            interpolation=self.interpolation)
+
+    def _transform_masks(self, results: dict, mag: float) -> None:
+        """Rotate the masks."""
+        results['gt_masks'] = results['gt_masks'].rotate(
+            results['img_shape'],
+            mag,
+            border_value=self.mask_border_value,
+            interpolation=self.interpolation)
+
+    def _transform_seg(self, results: dict, mag: float) -> None:
+        """Rotate the segmentation map."""
+        results['gt_seg_map'] = mmcv.imrotate(
+            results['gt_seg_map'],
+            mag,
+            border_value=self.seg_ignore_label,
+            interpolation='nearest')
+
+
+@TRANSFORMS.register_module()
+class TranslateX(GeomTransform):
+    """Translate the images, bboxes, masks and segmentation map horizontally.
+
+    Required Keys:
+
+    - img
+    - gt_bboxes (BaseBoxes[torch.float32]) (optional)
+    - gt_masks (BitmapMasks | PolygonMasks) (optional)
+    - gt_seg_map (np.uint8) (optional)
+
+    Modified Keys:
+
+    - img
+    - gt_bboxes
+    - gt_masks
+    - gt_seg_map
+
+    Added Keys:
+
+    - homography_matrix
+
+    Args:
+        prob (float): The probability for perform transformation and
+            should be in range 0 to 1. Defaults to 1.0.
+        level (int, optional): The level should be in range [0, _MAX_LEVEL].
+            If level is None, it will generate from [0, _MAX_LEVEL] randomly.
+            Defaults to None.
+        min_mag (float): The minimum pixel's offset ratio for horizontal
+            translation. Defaults to 0.0.
+        max_mag (float): The maximum pixel's offset ratio for horizontal
+            translation. Defaults to 0.1.
+        reversal_prob (float): The probability that reverses the horizontal
+            translation magnitude. Should be in range [0,1]. Defaults to 0.5.
+        img_border_value (int | float | tuple): The filled values for
+            image border. If float, the same fill value will be used for
+            all the three channels of image. If tuple, it should be 3 elements.
+            Defaults to 128.
+        mask_border_value (int): The fill value used for masks. Defaults to 0.
+        seg_ignore_label (int): The fill value used for segmentation map.
+            Note this value must equals ``ignore_label`` in ``semantic_head``
+            of the corresponding config. Defaults to 255.
+        interpolation (str): Interpolation method, accepted values are
+            "nearest", "bilinear", "bicubic", "area", "lanczos" for 'cv2'
+            backend, "nearest", "bilinear" for 'pillow' backend. Defaults
+            to 'bilinear'.
+    """
+
+    def __init__(self,
+                 prob: float = 1.0,
+                 level: Optional[int] = None,
+                 min_mag: float = 0.0,
+                 max_mag: float = 0.1,
+                 reversal_prob: float = 0.5,
+                 img_border_value: Union[int, float, tuple] = 128,
+                 mask_border_value: int = 0,
+                 seg_ignore_label: int = 255,
+                 interpolation: str = 'bilinear') -> None:
+        assert 0. <= min_mag <= 1., \
+            f'min_mag ratio for TranslateX should be ' \
+            f'in range [0, 1], got {min_mag}.'
+        assert 0. <= max_mag <= 1., \
+            f'max_mag ratio for TranslateX should be ' \
+            f'in range [0, 1], got {max_mag}.'
+        super().__init__(
+            prob=prob,
+            level=level,
+            min_mag=min_mag,
+            max_mag=max_mag,
+            reversal_prob=reversal_prob,
+            img_border_value=img_border_value,
+            mask_border_value=mask_border_value,
+            seg_ignore_label=seg_ignore_label,
+            interpolation=interpolation)
+
+    def _get_homography_matrix(self, results: dict, mag: float) -> np.ndarray:
+        """Get the homography matrix for TranslateX."""
+        mag = int(results['img_shape'][1] * mag)
+        return np.array([[1, 0, mag], [0, 1, 0], [0, 0, 1]], dtype=np.float32)
+
+    def _transform_img(self, results: dict, mag: float) -> None:
+        """Translate the image horizontally."""
+        mag = int(results['img_shape'][1] * mag)
+        results['img'] = mmcv.imtranslate(
+            results['img'],
+            mag,
+            direction='horizontal',
+            border_value=self.img_border_value,
+            interpolation=self.interpolation)
+
+    def _transform_masks(self, results: dict, mag: float) -> None:
+        """Translate the masks horizontally."""
+        mag = int(results['img_shape'][1] * mag)
+        results['gt_masks'] = results['gt_masks'].translate(
+            results['img_shape'],
+            mag,
+            direction='horizontal',
+            border_value=self.mask_border_value,
+            interpolation=self.interpolation)
+
+    def _transform_seg(self, results: dict, mag: float) -> None:
+        """Translate the segmentation map horizontally."""
+        mag = int(results['img_shape'][1] * mag)
+        results['gt_seg_map'] = mmcv.imtranslate(
+            results['gt_seg_map'],
+            mag,
+            direction='horizontal',
+            border_value=self.seg_ignore_label,
+            interpolation='nearest')
+
+
+@TRANSFORMS.register_module()
+class TranslateY(GeomTransform):
+    """Translate the images, bboxes, masks and segmentation map vertically.
+
+    Required Keys:
+
+    - img
+    - gt_bboxes (BaseBoxes[torch.float32]) (optional)
+    - gt_masks (BitmapMasks | PolygonMasks) (optional)
+    - gt_seg_map (np.uint8) (optional)
+
+    Modified Keys:
+
+    - img
+    - gt_bboxes
+    - gt_masks
+    - gt_seg_map
+
+    Added Keys:
+
+    - homography_matrix
+
+    Args:
+        prob (float): The probability for perform transformation and
+            should be in range 0 to 1. Defaults to 1.0.
+        level (int, optional): The level should be in range [0, _MAX_LEVEL].
+            If level is None, it will generate from [0, _MAX_LEVEL] randomly.
+            Defaults to None.
+        min_mag (float): The minimum pixel's offset ratio for vertical
+            translation. Defaults to 0.0.
+        max_mag (float): The maximum pixel's offset ratio for vertical
+            translation. Defaults to 0.1.
+        reversal_prob (float): The probability that reverses the vertical
+            translation magnitude. Should be in range [0,1]. Defaults to 0.5.
+        img_border_value (int | float | tuple): The filled values for
+            image border. If float, the same fill value will be used for
+            all the three channels of image. If tuple, it should be 3 elements.
+            Defaults to 128.
+        mask_border_value (int): The fill value used for masks. Defaults to 0.
+        seg_ignore_label (int): The fill value used for segmentation map.
+            Note this value must equals ``ignore_label`` in ``semantic_head``
+            of the corresponding config. Defaults to 255.
+        interpolation (str): Interpolation method, accepted values are
+            "nearest", "bilinear", "bicubic", "area", "lanczos" for 'cv2'
+            backend, "nearest", "bilinear" for 'pillow' backend. Defaults
+            to 'bilinear'.
+    """
+
+    def __init__(self,
+                 prob: float = 1.0,
+                 level: Optional[int] = None,
+                 min_mag: float = 0.0,
+                 max_mag: float = 0.1,
+                 reversal_prob: float = 0.5,
+                 img_border_value: Union[int, float, tuple] = 128,
+                 mask_border_value: int = 0,
+                 seg_ignore_label: int = 255,
+                 interpolation: str = 'bilinear') -> None:
+        assert 0. <= min_mag <= 1., \
+            f'min_mag ratio for TranslateY should be ' \
+            f'in range [0,1], got {min_mag}.'
+        assert 0. <= max_mag <= 1., \
+            f'max_mag ratio for TranslateY should be ' \
+            f'in range [0,1], got {max_mag}.'
+        super().__init__(
+            prob=prob,
+            level=level,
+            min_mag=min_mag,
+            max_mag=max_mag,
+            reversal_prob=reversal_prob,
+            img_border_value=img_border_value,
+            mask_border_value=mask_border_value,
+            seg_ignore_label=seg_ignore_label,
+            interpolation=interpolation)
+
+    def _get_homography_matrix(self, results: dict, mag: float) -> np.ndarray:
+        """Get the homography matrix for TranslateY."""
+        mag = int(results['img_shape'][0] * mag)
+        return np.array([[1, 0, 0], [0, 1, mag], [0, 0, 1]], dtype=np.float32)
+
+    def _transform_img(self, results: dict, mag: float) -> None:
+        """Translate the image vertically."""
+        mag = int(results['img_shape'][0] * mag)
+        results['img'] = mmcv.imtranslate(
+            results['img'],
+            mag,
+            direction='vertical',
+            border_value=self.img_border_value,
+            interpolation=self.interpolation)
+
+    def _transform_masks(self, results: dict, mag: float) -> None:
+        """Translate masks vertically."""
+        mag = int(results['img_shape'][0] * mag)
+        results['gt_masks'] = results['gt_masks'].translate(
+            results['img_shape'],
+            mag,
+            direction='vertical',
+            border_value=self.mask_border_value,
+            interpolation=self.interpolation)
+
+    def _transform_seg(self, results: dict, mag: float) -> None:
+        """Translate segmentation map vertically."""
+        mag = int(results['img_shape'][0] * mag)
+        results['gt_seg_map'] = mmcv.imtranslate(
+            results['gt_seg_map'],
+            mag,
+            direction='vertical',
+            border_value=self.seg_ignore_label,
+            interpolation='nearest')
diff --git a/mmdetection/mmdet/datasets/transforms/instaboost.py b/mmdetection/mmdet/datasets/transforms/instaboost.py
new file mode 100644
index 00000000..30dc1603
--- /dev/null
+++ b/mmdetection/mmdet/datasets/transforms/instaboost.py
@@ -0,0 +1,150 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Tuple
+
+import numpy as np
+from mmcv.transforms import BaseTransform
+
+from mmdet.registry import TRANSFORMS
+
+
+@TRANSFORMS.register_module()
+class InstaBoost(BaseTransform):
+    r"""Data augmentation method in `InstaBoost: Boosting Instance
+    Segmentation Via Probability Map Guided Copy-Pasting
+    `_.
+
+    Refer to https://github.com/GothicAi/Instaboost for implementation details.
+
+
+    Required Keys:
+
+    - img (np.uint8)
+    - instances
+
+    Modified Keys:
+
+    - img (np.uint8)
+    - instances
+
+    Args:
+        action_candidate (tuple): Action candidates. "normal", "horizontal", \
+            "vertical", "skip" are supported. Defaults to ('normal', \
+            'horizontal', 'skip').
+        action_prob (tuple): Corresponding action probabilities. Should be \
+            the same length as action_candidate. Defaults to (1, 0, 0).
+        scale (tuple): (min scale, max scale). Defaults to (0.8, 1.2).
+        dx (int): The maximum x-axis shift will be (instance width) / dx.
+            Defaults to 15.
+        dy (int): The maximum y-axis shift will be (instance height) / dy.
+            Defaults to 15.
+        theta (tuple): (min rotation degree, max rotation degree). \
+            Defaults to (-1, 1).
+        color_prob (float): Probability of images for color augmentation.
+            Defaults to 0.5.
+        hflag (bool): Whether to use heatmap guided. Defaults to False.
+        aug_ratio (float): Probability of applying this transformation. \
+            Defaults to 0.5.
+    """
+
+    def __init__(self,
+                 action_candidate: tuple = ('normal', 'horizontal', 'skip'),
+                 action_prob: tuple = (1, 0, 0),
+                 scale: tuple = (0.8, 1.2),
+                 dx: int = 15,
+                 dy: int = 15,
+                 theta: tuple = (-1, 1),
+                 color_prob: float = 0.5,
+                 hflag: bool = False,
+                 aug_ratio: float = 0.5) -> None:
+
+        import matplotlib
+        import matplotlib.pyplot as plt
+        default_backend = plt.get_backend()
+
+        try:
+            import instaboostfast as instaboost
+        except ImportError:
+            raise ImportError(
+                'Please run "pip install instaboostfast" '
+                'to install instaboostfast first for instaboost augmentation.')
+
+        # instaboost will modify the default backend
+        # and cause visualization to fail.
+        matplotlib.use(default_backend)
+
+        self.cfg = instaboost.InstaBoostConfig(action_candidate, action_prob,
+                                               scale, dx, dy, theta,
+                                               color_prob, hflag)
+        self.aug_ratio = aug_ratio
+
+    def _load_anns(self, results: dict) -> Tuple[list, list]:
+        """Convert raw anns to instaboost expected input format."""
+        anns = []
+        ignore_anns = []
+        for instance in results['instances']:
+            label = instance['bbox_label']
+            bbox = instance['bbox']
+            mask = instance['mask']
+            x1, y1, x2, y2 = bbox
+            # assert (x2 - x1) >= 1 and (y2 - y1) >= 1
+            bbox = [x1, y1, x2 - x1, y2 - y1]
+
+            if instance['ignore_flag'] == 0:
+                anns.append({
+                    'category_id': label,
+                    'segmentation': mask,
+                    'bbox': bbox
+                })
+            else:
+                # Ignore instances without data augmentation
+                ignore_anns.append(instance)
+        return anns, ignore_anns
+
+    def _parse_anns(self, results: dict, anns: list, ignore_anns: list,
+                    img: np.ndarray) -> dict:
+        """Restore the result of instaboost processing to the original anns
+        format."""
+        instances = []
+        for ann in anns:
+            x1, y1, w, h = ann['bbox']
+            # TODO: more essential bug need to be fixed in instaboost
+            if w <= 0 or h <= 0:
+                continue
+            bbox = [x1, y1, x1 + w, y1 + h]
+            instances.append(
+                dict(
+                    bbox=bbox,
+                    bbox_label=ann['category_id'],
+                    mask=ann['segmentation'],
+                    ignore_flag=0))
+
+        instances.extend(ignore_anns)
+        results['img'] = img
+        results['instances'] = instances
+        return results
+
+    def transform(self, results) -> dict:
+        """The transform function."""
+        img = results['img']
+        ori_type = img.dtype
+        if 'instances' not in results or len(results['instances']) == 0:
+            return results
+
+        anns, ignore_anns = self._load_anns(results)
+        if np.random.choice([0, 1], p=[1 - self.aug_ratio, self.aug_ratio]):
+            try:
+                import instaboostfast as instaboost
+            except ImportError:
+                raise ImportError('Please run "pip install instaboostfast" '
+                                  'to install instaboostfast first.')
+            anns, img = instaboost.get_new_data(
+                anns, img.astype(np.uint8), self.cfg, background=None)
+
+        results = self._parse_anns(results, anns, ignore_anns,
+                                   img.astype(ori_type))
+        return results
+
+    def __repr__(self) -> str:
+        repr_str = self.__class__.__name__
+        repr_str += f'(aug_ratio={self.aug_ratio})'
+        return repr_str
diff --git a/mmdetection/mmdet/datasets/transforms/loading.py b/mmdetection/mmdet/datasets/transforms/loading.py
new file mode 100644
index 00000000..722d4b0e
--- /dev/null
+++ b/mmdetection/mmdet/datasets/transforms/loading.py
@@ -0,0 +1,1074 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Tuple, Union
+
+import mmcv
+import numpy as np
+import pycocotools.mask as maskUtils
+import torch
+from mmcv.transforms import BaseTransform
+from mmcv.transforms import LoadAnnotations as MMCV_LoadAnnotations
+from mmcv.transforms import LoadImageFromFile
+from mmengine.fileio import get
+from mmengine.structures import BaseDataElement
+
+from mmdet.registry import TRANSFORMS
+from mmdet.structures.bbox import get_box_type
+from mmdet.structures.bbox.box_type import autocast_box_type
+from mmdet.structures.mask import BitmapMasks, PolygonMasks
+
+
+@TRANSFORMS.register_module()
+class LoadImageFromNDArray(LoadImageFromFile):
+    """Load an image from ``results['img']``.
+
+    Similar with :obj:`LoadImageFromFile`, but the image has been loaded as
+    :obj:`np.ndarray` in ``results['img']``. Can be used when loading image
+    from webcam.
+
+    Required Keys:
+
+    - img
+
+    Modified Keys:
+
+    - img
+    - img_path
+    - img_shape
+    - ori_shape
+
+    Args:
+        to_float32 (bool): Whether to convert the loaded image to a float32
+            numpy array. If set to False, the loaded image is an uint8 array.
+            Defaults to False.
+    """
+
+    def transform(self, results: dict) -> dict:
+        """Transform function to add image meta information.
+
+        Args:
+            results (dict): Result dict with Webcam read image in
+                ``results['img']``.
+
+        Returns:
+            dict: The dict contains loaded image and meta information.
+        """
+
+        img = results['img']
+        if self.to_float32:
+            img = img.astype(np.float32)
+
+        results['img_path'] = None
+        results['img'] = img
+        results['img_shape'] = img.shape[:2]
+        results['ori_shape'] = img.shape[:2]
+        return results
+
+
+@TRANSFORMS.register_module()
+class LoadMultiChannelImageFromFiles(BaseTransform):
+    """Load multi-channel images from a list of separate channel files.
+
+    Required Keys:
+
+    - img_path
+
+    Modified Keys:
+
+    - img
+    - img_shape
+    - ori_shape
+
+    Args:
+        to_float32 (bool): Whether to convert the loaded image to a float32
+            numpy array. If set to False, the loaded image is an uint8 array.
+            Defaults to False.
+        color_type (str): The flag argument for :func:``mmcv.imfrombytes``.
+            Defaults to 'unchanged'.
+        imdecode_backend (str): The image decoding backend type. The backend
+            argument for :func:``mmcv.imfrombytes``.
+            See :func:``mmcv.imfrombytes`` for details.
+            Defaults to 'cv2'.
+        file_client_args (dict): Arguments to instantiate the
+            corresponding backend in mmdet <= 3.0.0rc6. Defaults to None.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend in mmdet >= 3.0.0rc7. Defaults to None.
+    """
+
+    def __init__(
+        self,
+        to_float32: bool = False,
+        color_type: str = 'unchanged',
+        imdecode_backend: str = 'cv2',
+        file_client_args: dict = None,
+        backend_args: dict = None,
+    ) -> None:
+        self.to_float32 = to_float32
+        self.color_type = color_type
+        self.imdecode_backend = imdecode_backend
+        self.backend_args = backend_args
+        if file_client_args is not None:
+            raise RuntimeError(
+                'The `file_client_args` is deprecated, '
+                'please use `backend_args` instead, please refer to'
+                'https://github.com/open-mmlab/mmdetection/blob/main/configs/_base_/datasets/coco_detection.py'  # noqa: E501
+            )
+
+    def transform(self, results: dict) -> dict:
+        """Transform functions to load multiple images and get images meta
+        information.
+
+        Args:
+            results (dict): Result dict from :obj:`mmdet.CustomDataset`.
+
+        Returns:
+            dict: The dict contains loaded images and meta information.
+        """
+
+        assert isinstance(results['img_path'], list)
+        img = []
+        for name in results['img_path']:
+            img_bytes = get(name, backend_args=self.backend_args)
+            img.append(
+                mmcv.imfrombytes(
+                    img_bytes,
+                    flag=self.color_type,
+                    backend=self.imdecode_backend))
+        img = np.stack(img, axis=-1)
+        if self.to_float32:
+            img = img.astype(np.float32)
+
+        results['img'] = img
+        results['img_shape'] = img.shape[:2]
+        results['ori_shape'] = img.shape[:2]
+        return results
+
+    def __repr__(self):
+        repr_str = (f'{self.__class__.__name__}('
+                    f'to_float32={self.to_float32}, '
+                    f"color_type='{self.color_type}', "
+                    f"imdecode_backend='{self.imdecode_backend}', "
+                    f'backend_args={self.backend_args})')
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class LoadAnnotations(MMCV_LoadAnnotations):
+    """Load and process the ``instances`` and ``seg_map`` annotation provided
+    by dataset.
+
+    The annotation format is as the following:
+
+    .. code-block:: python
+
+        {
+            'instances':
+            [
+                {
+                # List of 4 numbers representing the bounding box of the
+                # instance, in (x1, y1, x2, y2) order.
+                'bbox': [x1, y1, x2, y2],
+
+                # Label of image classification.
+                'bbox_label': 1,
+
+                # Used in instance/panoptic segmentation. The segmentation mask
+                # of the instance or the information of segments.
+                # 1. If list[list[float]], it represents a list of polygons,
+                # one for each connected component of the object. Each
+                # list[float] is one simple polygon in the format of
+                # [x1, y1, ..., xn, yn] (n >= 3). The Xs and Ys are absolute
+                # coordinates in unit of pixels.
+                # 2. If dict, it represents the per-pixel segmentation mask in
+                # COCO's compressed RLE format. The dict should have keys
+                # “size” and “counts”.  Can be loaded by pycocotools
+                'mask': list[list[float]] or dict,
+
+                }
+            ]
+            # Filename of semantic or panoptic segmentation ground truth file.
+            'seg_map_path': 'a/b/c'
+        }
+
+    After this module, the annotation has been changed to the format below:
+
+    .. code-block:: python
+
+        {
+            # In (x1, y1, x2, y2) order, float type. N is the number of bboxes
+            # in an image
+            'gt_bboxes': BaseBoxes(N, 4)
+             # In int type.
+            'gt_bboxes_labels': np.ndarray(N, )
+             # In built-in class
+            'gt_masks': PolygonMasks (H, W) or BitmapMasks (H, W)
+             # In uint8 type.
+            'gt_seg_map': np.ndarray (H, W)
+             # in (x, y, v) order, float type.
+        }
+
+    Required Keys:
+
+    - height
+    - width
+    - instances
+
+      - bbox (optional)
+      - bbox_label
+      - mask (optional)
+      - ignore_flag
+
+    - seg_map_path (optional)
+
+    Added Keys:
+
+    - gt_bboxes (BaseBoxes[torch.float32])
+    - gt_bboxes_labels (np.int64)
+    - gt_masks (BitmapMasks | PolygonMasks)
+    - gt_seg_map (np.uint8)
+    - gt_ignore_flags (bool)
+
+    Args:
+        with_bbox (bool): Whether to parse and load the bbox annotation.
+            Defaults to True.
+        with_label (bool): Whether to parse and load the label annotation.
+            Defaults to True.
+        with_mask (bool): Whether to parse and load the mask annotation.
+             Default: False.
+        with_seg (bool): Whether to parse and load the semantic segmentation
+            annotation. Defaults to False.
+        poly2mask (bool): Whether to convert mask to bitmap. Default: True.
+        box_type (str): The box type used to wrap the bboxes. If ``box_type``
+            is None, gt_bboxes will keep being np.ndarray. Defaults to 'hbox'.
+        reduce_zero_label (bool): Whether reduce all label value
+            by 1. Usually used for datasets where 0 is background label.
+            Defaults to False.
+        ignore_index (int): The label index to be ignored.
+            Valid only if reduce_zero_label is true. Defaults is 255.
+        imdecode_backend (str): The image decoding backend type. The backend
+            argument for :func:``mmcv.imfrombytes``.
+            See :fun:``mmcv.imfrombytes`` for details.
+            Defaults to 'cv2'.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+    """
+
+    def __init__(
+            self,
+            with_mask: bool = False,
+            poly2mask: bool = True,
+            box_type: str = 'hbox',
+            # use for semseg
+            reduce_zero_label: bool = False,
+            ignore_index: int = 255,
+            **kwargs) -> None:
+        super(LoadAnnotations, self).__init__(**kwargs)
+        self.with_mask = with_mask
+        self.poly2mask = poly2mask
+        self.box_type = box_type
+        self.reduce_zero_label = reduce_zero_label
+        self.ignore_index = ignore_index
+
+    def _load_bboxes(self, results: dict) -> None:
+        """Private function to load bounding box annotations.
+
+        Args:
+            results (dict): Result dict from :obj:``mmengine.BaseDataset``.
+        Returns:
+            dict: The dict contains loaded bounding box annotations.
+        """
+        gt_bboxes = []
+        gt_ignore_flags = []
+        for instance in results.get('instances', []):
+            gt_bboxes.append(instance['bbox'])
+            gt_ignore_flags.append(instance['ignore_flag'])
+        if self.box_type is None:
+            results['gt_bboxes'] = np.array(
+                gt_bboxes, dtype=np.float32).reshape((-1, 4))
+        else:
+            _, box_type_cls = get_box_type(self.box_type)
+            results['gt_bboxes'] = box_type_cls(gt_bboxes, dtype=torch.float32)
+        results['gt_ignore_flags'] = np.array(gt_ignore_flags, dtype=bool)
+
+    def _load_labels(self, results: dict) -> None:
+        """Private function to load label annotations.
+
+        Args:
+            results (dict): Result dict from :obj:``mmengine.BaseDataset``.
+
+        Returns:
+            dict: The dict contains loaded label annotations.
+        """
+        gt_bboxes_labels = []
+        for instance in results.get('instances', []):
+            gt_bboxes_labels.append(instance['bbox_label'])
+        # TODO: Inconsistent with mmcv, consider how to deal with it later.
+        results['gt_bboxes_labels'] = np.array(
+            gt_bboxes_labels, dtype=np.int64)
+
+    def _poly2mask(self, mask_ann: Union[list, dict], img_h: int,
+                   img_w: int) -> np.ndarray:
+        """Private function to convert masks represented with polygon to
+        bitmaps.
+
+        Args:
+            mask_ann (list | dict): Polygon mask annotation input.
+            img_h (int): The height of output mask.
+            img_w (int): The width of output mask.
+
+        Returns:
+            np.ndarray: The decode bitmap mask of shape (img_h, img_w).
+        """
+
+        if isinstance(mask_ann, list):
+            # polygon -- a single object might consist of multiple parts
+            # we merge all parts into one mask rle code
+            rles = maskUtils.frPyObjects(mask_ann, img_h, img_w)
+            rle = maskUtils.merge(rles)
+        elif isinstance(mask_ann['counts'], list):
+            # uncompressed RLE
+            rle = maskUtils.frPyObjects(mask_ann, img_h, img_w)
+        else:
+            # rle
+            rle = mask_ann
+        mask = maskUtils.decode(rle)
+        return mask
+
+    def _process_masks(self, results: dict) -> list:
+        """Process gt_masks and filter invalid polygons.
+
+        Args:
+            results (dict): Result dict from :obj:``mmengine.BaseDataset``.
+
+        Returns:
+            list: Processed gt_masks.
+        """
+        gt_masks = []
+        gt_ignore_flags = []
+        for instance in results.get('instances', []):
+            gt_mask = instance['mask']
+            # If the annotation of segmentation mask is invalid,
+            # ignore the whole instance.
+            if isinstance(gt_mask, list):
+                gt_mask = [
+                    np.array(polygon) for polygon in gt_mask
+                    if len(polygon) % 2 == 0 and len(polygon) >= 6
+                ]
+                if len(gt_mask) == 0:
+                    # ignore this instance and set gt_mask to a fake mask
+                    instance['ignore_flag'] = 1
+                    gt_mask = [np.zeros(6)]
+            elif not self.poly2mask:
+                # `PolygonMasks` requires a ploygon of format List[np.array],
+                # other formats are invalid.
+                instance['ignore_flag'] = 1
+                gt_mask = [np.zeros(6)]
+            elif isinstance(gt_mask, dict) and \
+                    not (gt_mask.get('counts') is not None and
+                         gt_mask.get('size') is not None and
+                         isinstance(gt_mask['counts'], (list, str))):
+                # if gt_mask is a dict, it should include `counts` and `size`,
+                # so that `BitmapMasks` can uncompressed RLE
+                instance['ignore_flag'] = 1
+                gt_mask = [np.zeros(6)]
+            gt_masks.append(gt_mask)
+            # re-process gt_ignore_flags
+            gt_ignore_flags.append(instance['ignore_flag'])
+        results['gt_ignore_flags'] = np.array(gt_ignore_flags, dtype=bool)
+        return gt_masks
+
+    def _load_masks(self, results: dict) -> None:
+        """Private function to load mask annotations.
+
+        Args:
+            results (dict): Result dict from :obj:``mmengine.BaseDataset``.
+        """
+        h, w = results['ori_shape']
+        gt_masks = self._process_masks(results)
+        if self.poly2mask:
+            gt_masks = BitmapMasks(
+                [self._poly2mask(mask, h, w) for mask in gt_masks], h, w)
+        else:
+            # fake polygon masks will be ignored in `PackDetInputs`
+            gt_masks = PolygonMasks([mask for mask in gt_masks], h, w)
+        results['gt_masks'] = gt_masks
+
+    def _load_seg_map(self, results: dict) -> None:
+        """Private function to load semantic segmentation annotations.
+
+        Args:
+            results (dict): Result dict from :obj:``mmcv.BaseDataset``.
+
+        Returns:
+            dict: The dict contains loaded semantic segmentation annotations.
+        """
+        if results.get('seg_map_path', None) is None:
+            return
+
+        img_bytes = get(
+            results['seg_map_path'], backend_args=self.backend_args)
+        gt_semantic_seg = mmcv.imfrombytes(
+            img_bytes, flag='unchanged',
+            backend=self.imdecode_backend).squeeze()
+
+        if self.reduce_zero_label:
+            # avoid using underflow conversion
+            gt_semantic_seg[gt_semantic_seg == 0] = self.ignore_index
+            gt_semantic_seg = gt_semantic_seg - 1
+            gt_semantic_seg[gt_semantic_seg == self.ignore_index -
+                            1] = self.ignore_index
+
+        # modify if custom classes
+        if results.get('label_map', None) is not None:
+            # Add deep copy to solve bug of repeatedly
+            # replace `gt_semantic_seg`, which is reported in
+            # https://github.com/open-mmlab/mmsegmentation/pull/1445/
+            gt_semantic_seg_copy = gt_semantic_seg.copy()
+            for old_id, new_id in results['label_map'].items():
+                gt_semantic_seg[gt_semantic_seg_copy == old_id] = new_id
+        results['gt_seg_map'] = gt_semantic_seg
+        results['ignore_index'] = self.ignore_index
+
+    def transform(self, results: dict) -> dict:
+        """Function to load multiple types annotations.
+
+        Args:
+            results (dict): Result dict from :obj:``mmengine.BaseDataset``.
+
+        Returns:
+            dict: The dict contains loaded bounding box, label and
+            semantic segmentation.
+        """
+
+        if self.with_bbox:
+            self._load_bboxes(results)
+        if self.with_label:
+            self._load_labels(results)
+        if self.with_mask:
+            self._load_masks(results)
+        if self.with_seg:
+            self._load_seg_map(results)
+        return results
+
+    def __repr__(self) -> str:
+        repr_str = self.__class__.__name__
+        repr_str += f'(with_bbox={self.with_bbox}, '
+        repr_str += f'with_label={self.with_label}, '
+        repr_str += f'with_mask={self.with_mask}, '
+        repr_str += f'with_seg={self.with_seg}, '
+        repr_str += f'poly2mask={self.poly2mask}, '
+        repr_str += f"imdecode_backend='{self.imdecode_backend}', "
+        repr_str += f'backend_args={self.backend_args})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class LoadPanopticAnnotations(LoadAnnotations):
+    """Load multiple types of panoptic annotations.
+
+    The annotation format is as the following:
+
+    .. code-block:: python
+
+        {
+            'instances':
+            [
+                {
+                # List of 4 numbers representing the bounding box of the
+                # instance, in (x1, y1, x2, y2) order.
+                'bbox': [x1, y1, x2, y2],
+
+                # Label of image classification.
+                'bbox_label': 1,
+                },
+                ...
+            ]
+            'segments_info':
+            [
+                {
+                # id = cls_id + instance_id * INSTANCE_OFFSET
+                'id': int,
+
+                # Contiguous category id defined in dataset.
+                'category': int
+
+                # Thing flag.
+                'is_thing': bool
+                },
+                ...
+            ]
+
+            # Filename of semantic or panoptic segmentation ground truth file.
+            'seg_map_path': 'a/b/c'
+        }
+
+    After this module, the annotation has been changed to the format below:
+
+    .. code-block:: python
+
+        {
+            # In (x1, y1, x2, y2) order, float type. N is the number of bboxes
+            # in an image
+            'gt_bboxes': BaseBoxes(N, 4)
+             # In int type.
+            'gt_bboxes_labels': np.ndarray(N, )
+             # In built-in class
+            'gt_masks': PolygonMasks (H, W) or BitmapMasks (H, W)
+             # In uint8 type.
+            'gt_seg_map': np.ndarray (H, W)
+             # in (x, y, v) order, float type.
+        }
+
+    Required Keys:
+
+    - height
+    - width
+    - instances
+      - bbox
+      - bbox_label
+      - ignore_flag
+    - segments_info
+      - id
+      - category
+      - is_thing
+    - seg_map_path
+
+    Added Keys:
+
+    - gt_bboxes (BaseBoxes[torch.float32])
+    - gt_bboxes_labels (np.int64)
+    - gt_masks (BitmapMasks | PolygonMasks)
+    - gt_seg_map (np.uint8)
+    - gt_ignore_flags (bool)
+
+    Args:
+        with_bbox (bool): Whether to parse and load the bbox annotation.
+            Defaults to True.
+        with_label (bool): Whether to parse and load the label annotation.
+            Defaults to True.
+        with_mask (bool): Whether to parse and load the mask annotation.
+             Defaults to True.
+        with_seg (bool): Whether to parse and load the semantic segmentation
+            annotation. Defaults to False.
+        box_type (str): The box mode used to wrap the bboxes.
+        imdecode_backend (str): The image decoding backend type. The backend
+            argument for :func:``mmcv.imfrombytes``.
+            See :fun:``mmcv.imfrombytes`` for details.
+            Defaults to 'cv2'.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend in mmdet >= 3.0.0rc7. Defaults to None.
+    """
+
+    def __init__(self,
+                 with_bbox: bool = True,
+                 with_label: bool = True,
+                 with_mask: bool = True,
+                 with_seg: bool = True,
+                 box_type: str = 'hbox',
+                 imdecode_backend: str = 'cv2',
+                 backend_args: dict = None) -> None:
+        try:
+            from panopticapi import utils
+        except ImportError:
+            raise ImportError(
+                'panopticapi is not installed, please install it by: '
+                'pip install git+https://github.com/cocodataset/'
+                'panopticapi.git.')
+        self.rgb2id = utils.rgb2id
+
+        super(LoadPanopticAnnotations, self).__init__(
+            with_bbox=with_bbox,
+            with_label=with_label,
+            with_mask=with_mask,
+            with_seg=with_seg,
+            with_keypoints=False,
+            box_type=box_type,
+            imdecode_backend=imdecode_backend,
+            backend_args=backend_args)
+
+    def _load_masks_and_semantic_segs(self, results: dict) -> None:
+        """Private function to load mask and semantic segmentation annotations.
+
+        In gt_semantic_seg, the foreground label is from ``0`` to
+        ``num_things - 1``, the background label is from ``num_things`` to
+        ``num_things + num_stuff - 1``, 255 means the ignored label (``VOID``).
+
+        Args:
+            results (dict): Result dict from :obj:``mmdet.CustomDataset``.
+        """
+        # seg_map_path is None, when inference on the dataset without gts.
+        if results.get('seg_map_path', None) is None:
+            return
+
+        img_bytes = get(
+            results['seg_map_path'], backend_args=self.backend_args)
+        pan_png = mmcv.imfrombytes(
+            img_bytes, flag='color', channel_order='rgb').squeeze()
+        pan_png = self.rgb2id(pan_png)
+
+        gt_masks = []
+        gt_seg = np.zeros_like(pan_png) + 255  # 255 as ignore
+
+        for segment_info in results['segments_info']:
+            mask = (pan_png == segment_info['id'])
+            gt_seg = np.where(mask, segment_info['category'], gt_seg)
+
+            # The legal thing masks
+            if segment_info.get('is_thing'):
+                gt_masks.append(mask.astype(np.uint8))
+
+        if self.with_mask:
+            h, w = results['ori_shape']
+            gt_masks = BitmapMasks(gt_masks, h, w)
+            results['gt_masks'] = gt_masks
+
+        if self.with_seg:
+            results['gt_seg_map'] = gt_seg
+
+    def transform(self, results: dict) -> dict:
+        """Function to load multiple types panoptic annotations.
+
+        Args:
+            results (dict): Result dict from :obj:``mmdet.CustomDataset``.
+
+        Returns:
+            dict: The dict contains loaded bounding box, label, mask and
+                semantic segmentation annotations.
+        """
+
+        if self.with_bbox:
+            self._load_bboxes(results)
+        if self.with_label:
+            self._load_labels(results)
+        if self.with_mask or self.with_seg:
+            # The tasks completed by '_load_masks' and '_load_semantic_segs'
+            # in LoadAnnotations are merged to one function.
+            self._load_masks_and_semantic_segs(results)
+
+        return results
+
+
+@TRANSFORMS.register_module()
+class LoadProposals(BaseTransform):
+    """Load proposal pipeline.
+
+    Required Keys:
+
+    - proposals
+
+    Modified Keys:
+
+    - proposals
+
+    Args:
+        num_max_proposals (int, optional): Maximum number of proposals to load.
+            If not specified, all proposals will be loaded.
+    """
+
+    def __init__(self, num_max_proposals: Optional[int] = None) -> None:
+        self.num_max_proposals = num_max_proposals
+
+    def transform(self, results: dict) -> dict:
+        """Transform function to load proposals from file.
+
+        Args:
+            results (dict): Result dict from :obj:`mmdet.CustomDataset`.
+
+        Returns:
+            dict: The dict contains loaded proposal annotations.
+        """
+
+        proposals = results['proposals']
+        # the type of proposals should be `dict` or `InstanceData`
+        assert isinstance(proposals, dict) \
+               or isinstance(proposals, BaseDataElement)
+        bboxes = proposals['bboxes'].astype(np.float32)
+        assert bboxes.shape[1] == 4, \
+            f'Proposals should have shapes (n, 4), but found {bboxes.shape}'
+
+        if 'scores' in proposals:
+            scores = proposals['scores'].astype(np.float32)
+            assert bboxes.shape[0] == scores.shape[0]
+        else:
+            scores = np.zeros(bboxes.shape[0], dtype=np.float32)
+
+        if self.num_max_proposals is not None:
+            # proposals should sort by scores during dumping the proposals
+            bboxes = bboxes[:self.num_max_proposals]
+            scores = scores[:self.num_max_proposals]
+
+        if len(bboxes) == 0:
+            bboxes = np.zeros((0, 4), dtype=np.float32)
+            scores = np.zeros(0, dtype=np.float32)
+
+        results['proposals'] = bboxes
+        results['proposals_scores'] = scores
+        return results
+
+    def __repr__(self):
+        return self.__class__.__name__ + \
+               f'(num_max_proposals={self.num_max_proposals})'
+
+
+@TRANSFORMS.register_module()
+class FilterAnnotations(BaseTransform):
+    """Filter invalid annotations.
+
+    Required Keys:
+
+    - gt_bboxes (BaseBoxes[torch.float32]) (optional)
+    - gt_bboxes_labels (np.int64) (optional)
+    - gt_masks (BitmapMasks | PolygonMasks) (optional)
+    - gt_ignore_flags (bool) (optional)
+
+    Modified Keys:
+
+    - gt_bboxes (optional)
+    - gt_bboxes_labels (optional)
+    - gt_masks (optional)
+    - gt_ignore_flags (optional)
+
+    Args:
+        min_gt_bbox_wh (tuple[float]): Minimum width and height of ground truth
+            boxes. Default: (1., 1.)
+        min_gt_mask_area (int): Minimum foreground area of ground truth masks.
+            Default: 1
+        by_box (bool): Filter instances with bounding boxes not meeting the
+            min_gt_bbox_wh threshold. Default: True
+        by_mask (bool): Filter instances with masks not meeting
+            min_gt_mask_area threshold. Default: False
+        keep_empty (bool): Whether to return None when it
+            becomes an empty bbox after filtering. Defaults to True.
+    """
+
+    def __init__(self,
+                 min_gt_bbox_wh: Tuple[int, int] = (1, 1),
+                 min_gt_mask_area: int = 1,
+                 by_box: bool = True,
+                 by_mask: bool = False,
+                 keep_empty: bool = True) -> None:
+        # TODO: add more filter options
+        assert by_box or by_mask
+        self.min_gt_bbox_wh = min_gt_bbox_wh
+        self.min_gt_mask_area = min_gt_mask_area
+        self.by_box = by_box
+        self.by_mask = by_mask
+        self.keep_empty = keep_empty
+
+    @autocast_box_type()
+    def transform(self, results: dict) -> Union[dict, None]:
+        """Transform function to filter annotations.
+
+        Args:
+            results (dict): Result dict.
+
+        Returns:
+            dict: Updated result dict.
+        """
+        assert 'gt_bboxes' in results
+        gt_bboxes = results['gt_bboxes']
+        if gt_bboxes.shape[0] == 0:
+            return results
+
+        tests = []
+        if self.by_box:
+            tests.append(
+                ((gt_bboxes.widths > self.min_gt_bbox_wh[0]) &
+                 (gt_bboxes.heights > self.min_gt_bbox_wh[1])).numpy())
+        if self.by_mask:
+            assert 'gt_masks' in results
+            gt_masks = results['gt_masks']
+            tests.append(gt_masks.areas >= self.min_gt_mask_area)
+
+        keep = tests[0]
+        for t in tests[1:]:
+            keep = keep & t
+
+        if not keep.any():
+            if self.keep_empty:
+                return None
+
+        keys = ('gt_bboxes', 'gt_bboxes_labels', 'gt_masks', 'gt_ignore_flags')
+        for key in keys:
+            if key in results:
+                results[key] = results[key][keep]
+
+        return results
+
+    def __repr__(self):
+        return self.__class__.__name__ + \
+               f'(min_gt_bbox_wh={self.min_gt_bbox_wh}, ' \
+               f'keep_empty={self.keep_empty})'
+
+
+@TRANSFORMS.register_module()
+class LoadEmptyAnnotations(BaseTransform):
+    """Load Empty Annotations for unlabeled images.
+
+    Added Keys:
+    - gt_bboxes (np.float32)
+    - gt_bboxes_labels (np.int64)
+    - gt_masks (BitmapMasks | PolygonMasks)
+    - gt_seg_map (np.uint8)
+    - gt_ignore_flags (bool)
+
+    Args:
+        with_bbox (bool): Whether to load the pseudo bbox annotation.
+            Defaults to True.
+        with_label (bool): Whether to load the pseudo label annotation.
+            Defaults to True.
+        with_mask (bool): Whether to load the pseudo mask annotation.
+             Default: False.
+        with_seg (bool): Whether to load the pseudo semantic segmentation
+            annotation. Defaults to False.
+        seg_ignore_label (int): The fill value used for segmentation map.
+            Note this value must equals ``ignore_label`` in ``semantic_head``
+            of the corresponding config. Defaults to 255.
+    """
+
+    def __init__(self,
+                 with_bbox: bool = True,
+                 with_label: bool = True,
+                 with_mask: bool = False,
+                 with_seg: bool = False,
+                 seg_ignore_label: int = 255) -> None:
+        self.with_bbox = with_bbox
+        self.with_label = with_label
+        self.with_mask = with_mask
+        self.with_seg = with_seg
+        self.seg_ignore_label = seg_ignore_label
+
+    def transform(self, results: dict) -> dict:
+        """Transform function to load empty annotations.
+
+        Args:
+            results (dict): Result dict.
+        Returns:
+            dict: Updated result dict.
+        """
+        if self.with_bbox:
+            results['gt_bboxes'] = np.zeros((0, 4), dtype=np.float32)
+            results['gt_ignore_flags'] = np.zeros((0, ), dtype=bool)
+        if self.with_label:
+            results['gt_bboxes_labels'] = np.zeros((0, ), dtype=np.int64)
+        if self.with_mask:
+            # TODO: support PolygonMasks
+            h, w = results['img_shape']
+            gt_masks = np.zeros((0, h, w), dtype=np.uint8)
+            results['gt_masks'] = BitmapMasks(gt_masks, h, w)
+        if self.with_seg:
+            h, w = results['img_shape']
+            results['gt_seg_map'] = self.seg_ignore_label * np.ones(
+                (h, w), dtype=np.uint8)
+        return results
+
+    def __repr__(self) -> str:
+        repr_str = self.__class__.__name__
+        repr_str += f'(with_bbox={self.with_bbox}, '
+        repr_str += f'with_label={self.with_label}, '
+        repr_str += f'with_mask={self.with_mask}, '
+        repr_str += f'with_seg={self.with_seg}, '
+        repr_str += f'seg_ignore_label={self.seg_ignore_label})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class InferencerLoader(BaseTransform):
+    """Load an image from ``results['img']``.
+
+    Similar with :obj:`LoadImageFromFile`, but the image has been loaded as
+    :obj:`np.ndarray` in ``results['img']``. Can be used when loading image
+    from webcam.
+
+    Required Keys:
+
+    - img
+
+    Modified Keys:
+
+    - img
+    - img_path
+    - img_shape
+    - ori_shape
+
+    Args:
+        to_float32 (bool): Whether to convert the loaded image to a float32
+            numpy array. If set to False, the loaded image is an uint8 array.
+            Defaults to False.
+    """
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__()
+        self.from_file = TRANSFORMS.build(
+            dict(type='LoadImageFromFile', **kwargs))
+        self.from_ndarray = TRANSFORMS.build(
+            dict(type='mmdet.LoadImageFromNDArray', **kwargs))
+
+    def transform(self, results: Union[str, np.ndarray, dict]) -> dict:
+        """Transform function to add image meta information.
+
+        Args:
+            results (str, np.ndarray or dict): The result.
+
+        Returns:
+            dict: The dict contains loaded image and meta information.
+        """
+        if isinstance(results, str):
+            inputs = dict(img_path=results)
+        elif isinstance(results, np.ndarray):
+            inputs = dict(img=results)
+        elif isinstance(results, dict):
+            inputs = results
+        else:
+            raise NotImplementedError
+
+        if 'img' in inputs:
+            return self.from_ndarray(inputs)
+        return self.from_file(inputs)
+
+
+@TRANSFORMS.register_module()
+class LoadTrackAnnotations(LoadAnnotations):
+    """Load and process the ``instances`` and ``seg_map`` annotation provided
+    by dataset. It must load ``instances_ids`` which is only used in the
+    tracking tasks. The annotation format is as the following:
+
+    .. code-block:: python
+        {
+            'instances':
+            [
+                {
+                # List of 4 numbers representing the bounding box of the
+                # instance, in (x1, y1, x2, y2) order.
+                'bbox': [x1, y1, x2, y2],
+                # Label of image classification.
+                'bbox_label': 1,
+                # Used in tracking.
+                # Id of instances.
+                'instance_id': 100,
+                # Used in instance/panoptic segmentation. The segmentation mask
+                # of the instance or the information of segments.
+                # 1. If list[list[float]], it represents a list of polygons,
+                # one for each connected component of the object. Each
+                # list[float] is one simple polygon in the format of
+                # [x1, y1, ..., xn, yn] (n >= 3). The Xs and Ys are absolute
+                # coordinates in unit of pixels.
+                # 2. If dict, it represents the per-pixel segmentation mask in
+                # COCO's compressed RLE format. The dict should have keys
+                # “size” and “counts”.  Can be loaded by pycocotools
+                'mask': list[list[float]] or dict,
+                }
+            ]
+            # Filename of semantic or panoptic segmentation ground truth file.
+            'seg_map_path': 'a/b/c'
+        }
+
+    After this module, the annotation has been changed to the format below:
+    .. code-block:: python
+        {
+            # In (x1, y1, x2, y2) order, float type. N is the number of bboxes
+            # in an image
+            'gt_bboxes': np.ndarray(N, 4)
+             # In int type.
+            'gt_bboxes_labels': np.ndarray(N, )
+             # In built-in class
+            'gt_masks': PolygonMasks (H, W) or BitmapMasks (H, W)
+             # In uint8 type.
+            'gt_seg_map': np.ndarray (H, W)
+             # in (x, y, v) order, float type.
+        }
+
+    Required Keys:
+
+    - height (optional)
+    - width (optional)
+    - instances
+      - bbox (optional)
+      - bbox_label
+      - instance_id (optional)
+      - mask (optional)
+      - ignore_flag (optional)
+    - seg_map_path (optional)
+
+    Added Keys:
+
+    - gt_bboxes (np.float32)
+    - gt_bboxes_labels (np.int32)
+    - gt_instances_ids (np.int32)
+    - gt_masks (BitmapMasks | PolygonMasks)
+    - gt_seg_map (np.uint8)
+    - gt_ignore_flags (np.bool)
+    """
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+
+    def _load_bboxes(self, results: dict) -> None:
+        """Private function to load bounding box annotations.
+
+        Args:
+            results (dict): Result dict from :obj:``mmcv.BaseDataset``.
+
+        Returns:
+            dict: The dict contains loaded bounding box annotations.
+        """
+        gt_bboxes = []
+        gt_ignore_flags = []
+        # TODO: use bbox_type
+        for instance in results['instances']:
+            # The datasets which are only format in evaluation don't have
+            # groundtruth boxes.
+            if 'bbox' in instance:
+                gt_bboxes.append(instance['bbox'])
+            if 'ignore_flag' in instance:
+                gt_ignore_flags.append(instance['ignore_flag'])
+
+        # TODO: check this case
+        if len(gt_bboxes) != len(gt_ignore_flags):
+            # There may be no ``gt_ignore_flags`` in some cases, we treat them
+            # as all False in order to keep the length of ``gt_bboxes`` and
+            # ``gt_ignore_flags`` the same
+            gt_ignore_flags = [False] * len(gt_bboxes)
+
+        results['gt_bboxes'] = np.array(
+            gt_bboxes, dtype=np.float32).reshape(-1, 4)
+        results['gt_ignore_flags'] = np.array(gt_ignore_flags, dtype=bool)
+
+    def _load_instances_ids(self, results: dict) -> None:
+        """Private function to load instances id annotations.
+
+        Args:
+            results (dict): Result dict from :obj :obj:``mmcv.BaseDataset``.
+
+        Returns:
+            dict: The dict containing instances id annotations.
+        """
+        gt_instances_ids = []
+        for instance in results['instances']:
+            gt_instances_ids.append(instance['instance_id'])
+        results['gt_instances_ids'] = np.array(
+            gt_instances_ids, dtype=np.int32)
+
+    def transform(self, results: dict) -> dict:
+        """Function to load multiple types annotations.
+
+        Args:
+            results (dict): Result dict from :obj:``mmcv.BaseDataset``.
+
+        Returns:
+            dict: The dict contains loaded bounding box, label, instances id
+            and semantic segmentation and keypoints annotations.
+        """
+        results = super().transform(results)
+        self._load_instances_ids(results)
+        return results
+
+    def __repr__(self) -> str:
+        repr_str = self.__class__.__name__
+        repr_str += f'(with_bbox={self.with_bbox}, '
+        repr_str += f'with_label={self.with_label}, '
+        repr_str += f'with_mask={self.with_mask}, '
+        repr_str += f'with_seg={self.with_seg}, '
+        repr_str += f'poly2mask={self.poly2mask}, '
+        repr_str += f"imdecode_backend='{self.imdecode_backend}', "
+        repr_str += f'file_client_args={self.file_client_args})'
+        return repr_str
diff --git a/mmdetection/mmdet/datasets/transforms/text_transformers.py b/mmdetection/mmdet/datasets/transforms/text_transformers.py
new file mode 100644
index 00000000..12a0e57d
--- /dev/null
+++ b/mmdetection/mmdet/datasets/transforms/text_transformers.py
@@ -0,0 +1,255 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import json
+
+from mmcv.transforms import BaseTransform
+
+from mmdet.registry import TRANSFORMS
+from mmdet.structures.bbox import BaseBoxes
+
+try:
+    from transformers import AutoTokenizer
+    from transformers import BertModel as HFBertModel
+except ImportError:
+    AutoTokenizer = None
+    HFBertModel = None
+
+import random
+import re
+
+import numpy as np
+
+
+def clean_name(name):
+    name = re.sub(r'\(.*\)', '', name)
+    name = re.sub(r'_', ' ', name)
+    name = re.sub(r'  ', ' ', name)
+    name = name.lower()
+    return name
+
+
+def check_for_positive_overflow(gt_bboxes, gt_labels, text, tokenizer,
+                                max_tokens):
+    # Check if we have too many positive labels
+    # generate a caption by appending the positive labels
+    positive_label_list = np.unique(gt_labels).tolist()
+    # random shuffule so we can sample different annotations
+    # at different epochs
+    random.shuffle(positive_label_list)
+
+    kept_lables = []
+    length = 0
+
+    for index, label in enumerate(positive_label_list):
+
+        label_text = clean_name(text[str(label)]) + '. '
+
+        tokenized = tokenizer.tokenize(label_text)
+
+        length += len(tokenized)
+
+        if length > max_tokens:
+            break
+        else:
+            kept_lables.append(label)
+
+    keep_box_index = []
+    keep_gt_labels = []
+    for i in range(len(gt_labels)):
+        if gt_labels[i] in kept_lables:
+            keep_box_index.append(i)
+            keep_gt_labels.append(gt_labels[i])
+
+    return gt_bboxes[keep_box_index], np.array(
+        keep_gt_labels, dtype=np.long), length
+
+
+def generate_senetence_given_labels(positive_label_list, negative_label_list,
+                                    text):
+    label_to_positions = {}
+
+    label_list = negative_label_list + positive_label_list
+
+    random.shuffle(label_list)
+
+    pheso_caption = ''
+
+    label_remap_dict = {}
+    for index, label in enumerate(label_list):
+
+        start_index = len(pheso_caption)
+
+        pheso_caption += clean_name(text[str(label)])
+
+        end_index = len(pheso_caption)
+
+        if label in positive_label_list:
+            label_to_positions[index] = [[start_index, end_index]]
+            label_remap_dict[int(label)] = index
+
+        # if index != len(label_list) - 1:
+        #     pheso_caption += '. '
+        pheso_caption += '. '
+
+    return label_to_positions, pheso_caption, label_remap_dict
+
+
+@TRANSFORMS.register_module()
+class RandomSamplingNegPos(BaseTransform):
+
+    def __init__(self,
+                 tokenizer_name,
+                 num_sample_negative=85,
+                 max_tokens=256,
+                 full_sampling_prob=0.5,
+                 label_map_file=None):
+        if AutoTokenizer is None:
+            raise RuntimeError(
+                'transformers is not installed, please install it by: '
+                'pip install transformers.')
+
+        self.tokenizer = AutoTokenizer.from_pretrained(tokenizer_name)
+        self.num_sample_negative = num_sample_negative
+        self.full_sampling_prob = full_sampling_prob
+        self.max_tokens = max_tokens
+        self.label_map = None
+        if label_map_file:
+            with open(label_map_file, 'r') as file:
+                self.label_map = json.load(file)
+
+    def transform(self, results: dict) -> dict:
+        if 'phrases' in results:
+            return self.vg_aug(results)
+        else:
+            return self.od_aug(results)
+
+    def vg_aug(self, results):
+        gt_bboxes = results['gt_bboxes']
+        if isinstance(gt_bboxes, BaseBoxes):
+            gt_bboxes = gt_bboxes.tensor
+        gt_labels = results['gt_bboxes_labels']
+        text = results['text'].lower().strip()
+        if not text.endswith('.'):
+            text = text + '. '
+
+        phrases = results['phrases']
+        # TODO: add neg
+        positive_label_list = np.unique(gt_labels).tolist()
+        label_to_positions = {}
+        for label in positive_label_list:
+            label_to_positions[label] = phrases[label]['tokens_positive']
+
+        results['gt_bboxes'] = gt_bboxes
+        results['gt_bboxes_labels'] = gt_labels
+
+        results['text'] = text
+        results['tokens_positive'] = label_to_positions
+        return results
+
+    def od_aug(self, results):
+        gt_bboxes = results['gt_bboxes']
+        if isinstance(gt_bboxes, BaseBoxes):
+            gt_bboxes = gt_bboxes.tensor
+        gt_labels = results['gt_bboxes_labels']
+
+        if 'text' not in results:
+            assert self.label_map is not None
+            text = self.label_map
+        else:
+            text = results['text']
+
+        original_box_num = len(gt_labels)
+        # If the category name is in the format of 'a/b' (in object365),
+        # we randomly select one of them.
+        for key, value in text.items():
+            if '/' in value:
+                text[key] = random.choice(value.split('/')).strip()
+
+        gt_bboxes, gt_labels, positive_caption_length = \
+            check_for_positive_overflow(gt_bboxes, gt_labels,
+                                        text, self.tokenizer, self.max_tokens)
+
+        if len(gt_bboxes) < original_box_num:
+            print('WARNING: removed {} boxes due to positive caption overflow'.
+                  format(original_box_num - len(gt_bboxes)))
+
+        valid_negative_indexes = list(text.keys())
+
+        positive_label_list = np.unique(gt_labels).tolist()
+        full_negative = self.num_sample_negative
+
+        if full_negative > len(valid_negative_indexes):
+            full_negative = len(valid_negative_indexes)
+
+        outer_prob = random.random()
+
+        if outer_prob < self.full_sampling_prob:
+            # c. probability_full: add both all positive and all negatives
+            num_negatives = full_negative
+        else:
+            if random.random() < 1.0:
+                num_negatives = np.random.choice(max(1, full_negative)) + 1
+            else:
+                num_negatives = full_negative
+
+        # Keep some negatives
+        negative_label_list = set()
+        if num_negatives != -1:
+            if num_negatives > len(valid_negative_indexes):
+                num_negatives = len(valid_negative_indexes)
+
+            for i in np.random.choice(
+                    valid_negative_indexes, size=num_negatives, replace=False):
+                if int(i) not in positive_label_list:
+                    negative_label_list.add(i)
+
+        random.shuffle(positive_label_list)
+
+        negative_label_list = list(negative_label_list)
+        random.shuffle(negative_label_list)
+
+        negative_max_length = self.max_tokens - positive_caption_length
+        screened_negative_label_list = []
+
+        for negative_label in negative_label_list:
+            label_text = clean_name(text[str(negative_label)]) + '. '
+
+            tokenized = self.tokenizer.tokenize(label_text)
+
+            negative_max_length -= len(tokenized)
+
+            if negative_max_length > 0:
+                screened_negative_label_list.append(negative_label)
+            else:
+                break
+        negative_label_list = screened_negative_label_list
+        label_to_positions, pheso_caption, label_remap_dict = \
+            generate_senetence_given_labels(positive_label_list,
+                                            negative_label_list, text)
+
+        # label remap
+        if len(gt_labels) > 0:
+            gt_labels = np.vectorize(lambda x: label_remap_dict[x])(gt_labels)
+
+        results['gt_bboxes'] = gt_bboxes
+        results['gt_bboxes_labels'] = gt_labels
+
+        results['text'] = pheso_caption
+        results['tokens_positive'] = label_to_positions
+
+        return results
+
+
+@TRANSFORMS.register_module()
+class LoadTextAnnotations(BaseTransform):
+
+    def transform(self, results: dict) -> dict:
+        if 'phrases' in results:
+            tokens_positive = [
+                phrase['tokens_positive']
+                for phrase in results['phrases'].values()
+            ]
+            results['tokens_positive'] = tokens_positive
+        else:
+            text = results['text']
+            results['text'] = list(text.values())
+        return results
diff --git a/mmdetection/mmdet/datasets/transforms/transformers_glip.py b/mmdetection/mmdet/datasets/transforms/transformers_glip.py
new file mode 100644
index 00000000..60c4f87d
--- /dev/null
+++ b/mmdetection/mmdet/datasets/transforms/transformers_glip.py
@@ -0,0 +1,66 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import mmcv
+import numpy as np
+from mmcv.transforms import BaseTransform
+
+from mmdet.registry import TRANSFORMS
+from mmdet.structures.bbox import HorizontalBoxes, autocast_box_type
+from .transforms import RandomFlip
+
+
+@TRANSFORMS.register_module()
+class GTBoxSubOne_GLIP(BaseTransform):
+    """Subtract 1 from the x2 and y2 coordinates of the gt_bboxes."""
+
+    def transform(self, results: dict) -> dict:
+        if 'gt_bboxes' in results:
+            gt_bboxes = results['gt_bboxes']
+            if isinstance(gt_bboxes, np.ndarray):
+                gt_bboxes[:, 2:] -= 1
+                results['gt_bboxes'] = gt_bboxes
+            elif isinstance(gt_bboxes, HorizontalBoxes):
+                gt_bboxes = results['gt_bboxes'].tensor
+                gt_bboxes[:, 2:] -= 1
+                results['gt_bboxes'] = HorizontalBoxes(gt_bboxes)
+            else:
+                raise NotImplementedError
+        return results
+
+
+@TRANSFORMS.register_module()
+class RandomFlip_GLIP(RandomFlip):
+    """Flip the image & bboxes & masks & segs horizontally or vertically.
+
+    When using horizontal flipping, the corresponding bbox x-coordinate needs
+    to be additionally subtracted by one.
+    """
+
+    @autocast_box_type()
+    def _flip(self, results: dict) -> None:
+        """Flip images, bounding boxes, and semantic segmentation map."""
+        # flip image
+        results['img'] = mmcv.imflip(
+            results['img'], direction=results['flip_direction'])
+
+        img_shape = results['img'].shape[:2]
+
+        # flip bboxes
+        if results.get('gt_bboxes', None) is not None:
+            results['gt_bboxes'].flip_(img_shape, results['flip_direction'])
+            # Only change this line
+            if results['flip_direction'] == 'horizontal':
+                results['gt_bboxes'].translate_([-1, 0])
+
+        # TODO: check it
+        # flip masks
+        if results.get('gt_masks', None) is not None:
+            results['gt_masks'] = results['gt_masks'].flip(
+                results['flip_direction'])
+
+        # flip segs
+        if results.get('gt_seg_map', None) is not None:
+            results['gt_seg_map'] = mmcv.imflip(
+                results['gt_seg_map'], direction=results['flip_direction'])
+
+        # record homography matrix for flip
+        self._record_homography_matrix(results)
diff --git a/mmdetection/mmdet/datasets/transforms/transforms.py b/mmdetection/mmdet/datasets/transforms/transforms.py
new file mode 100644
index 00000000..c50b987d
--- /dev/null
+++ b/mmdetection/mmdet/datasets/transforms/transforms.py
@@ -0,0 +1,3856 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import inspect
+import math
+import warnings
+from typing import List, Optional, Sequence, Tuple, Union
+
+import cv2
+import mmcv
+import numpy as np
+from mmcv.image import imresize
+from mmcv.image.geometric import _scale_size
+from mmcv.transforms import BaseTransform
+from mmcv.transforms import Pad as MMCV_Pad
+from mmcv.transforms import RandomFlip as MMCV_RandomFlip
+from mmcv.transforms import Resize as MMCV_Resize
+from mmcv.transforms.utils import avoid_cache_randomness, cache_randomness
+from mmengine.dataset import BaseDataset
+from mmengine.utils import is_str
+from numpy import random
+
+from mmdet.registry import TRANSFORMS
+from mmdet.structures.bbox import HorizontalBoxes, autocast_box_type
+from mmdet.structures.mask import BitmapMasks, PolygonMasks
+from mmdet.utils import log_img_scale
+
+try:
+    from imagecorruptions import corrupt
+except ImportError:
+    corrupt = None
+
+try:
+    import albumentations
+    from albumentations import Compose
+except ImportError:
+    albumentations = None
+    Compose = None
+
+Number = Union[int, float]
+
+
+def _fixed_scale_size(
+    size: Tuple[int, int],
+    scale: Union[float, int, tuple],
+) -> Tuple[int, int]:
+    """Rescale a size by a ratio.
+
+    Args:
+        size (tuple[int]): (w, h).
+        scale (float | tuple(float)): Scaling factor.
+
+    Returns:
+        tuple[int]: scaled size.
+    """
+    if isinstance(scale, (float, int)):
+        scale = (scale, scale)
+    w, h = size
+    # don't need o.5 offset
+    return int(w * float(scale[0])), int(h * float(scale[1]))
+
+
+def rescale_size(old_size: tuple,
+                 scale: Union[float, int, tuple],
+                 return_scale: bool = False) -> tuple:
+    """Calculate the new size to be rescaled to.
+
+    Args:
+        old_size (tuple[int]): The old size (w, h) of image.
+        scale (float | tuple[int]): The scaling factor or maximum size.
+            If it is a float number, then the image will be rescaled by this
+            factor, else if it is a tuple of 2 integers, then the image will
+            be rescaled as large as possible within the scale.
+        return_scale (bool): Whether to return the scaling factor besides the
+            rescaled image size.
+
+    Returns:
+        tuple[int]: The new rescaled image size.
+    """
+    w, h = old_size
+    if isinstance(scale, (float, int)):
+        if scale <= 0:
+            raise ValueError(f'Invalid scale {scale}, must be positive.')
+        scale_factor = scale
+    elif isinstance(scale, tuple):
+        max_long_edge = max(scale)
+        max_short_edge = min(scale)
+        scale_factor = min(max_long_edge / max(h, w),
+                           max_short_edge / min(h, w))
+    else:
+        raise TypeError(
+            f'Scale must be a number or tuple of int, but got {type(scale)}')
+    # only change this
+    new_size = _fixed_scale_size((w, h), scale_factor)
+
+    if return_scale:
+        return new_size, scale_factor
+    else:
+        return new_size
+
+
+def imrescale(
+    img: np.ndarray,
+    scale: Union[float, Tuple[int, int]],
+    return_scale: bool = False,
+    interpolation: str = 'bilinear',
+    backend: Optional[str] = None
+) -> Union[np.ndarray, Tuple[np.ndarray, float]]:
+    """Resize image while keeping the aspect ratio.
+
+    Args:
+        img (ndarray): The input image.
+        scale (float | tuple[int]): The scaling factor or maximum size.
+            If it is a float number, then the image will be rescaled by this
+            factor, else if it is a tuple of 2 integers, then the image will
+            be rescaled as large as possible within the scale.
+        return_scale (bool): Whether to return the scaling factor besides the
+            rescaled image.
+        interpolation (str): Same as :func:`resize`.
+        backend (str | None): Same as :func:`resize`.
+
+    Returns:
+        ndarray: The rescaled image.
+    """
+    h, w = img.shape[:2]
+    new_size, scale_factor = rescale_size((w, h), scale, return_scale=True)
+    rescaled_img = imresize(
+        img, new_size, interpolation=interpolation, backend=backend)
+    if return_scale:
+        return rescaled_img, scale_factor
+    else:
+        return rescaled_img
+
+
+@TRANSFORMS.register_module()
+class Resize(MMCV_Resize):
+    """Resize images & bbox & seg.
+
+    This transform resizes the input image according to ``scale`` or
+    ``scale_factor``. Bboxes, masks, and seg map are then resized
+    with the same scale factor.
+    if ``scale`` and ``scale_factor`` are both set, it will use ``scale`` to
+    resize.
+
+    Required Keys:
+
+    - img
+    - gt_bboxes (BaseBoxes[torch.float32]) (optional)
+    - gt_masks (BitmapMasks | PolygonMasks) (optional)
+    - gt_seg_map (np.uint8) (optional)
+
+    Modified Keys:
+
+    - img
+    - img_shape
+    - gt_bboxes
+    - gt_masks
+    - gt_seg_map
+
+
+    Added Keys:
+
+    - scale
+    - scale_factor
+    - keep_ratio
+    - homography_matrix
+
+    Args:
+        scale (int or tuple): Images scales for resizing. Defaults to None
+        scale_factor (float or tuple[float]): Scale factors for resizing.
+            Defaults to None.
+        keep_ratio (bool): Whether to keep the aspect ratio when resizing the
+            image. Defaults to False.
+        clip_object_border (bool): Whether to clip the objects
+            outside the border of the image. In some dataset like MOT17, the gt
+            bboxes are allowed to cross the border of images. Therefore, we
+            don't need to clip the gt bboxes in these cases. Defaults to True.
+        backend (str): Image resize backend, choices are 'cv2' and 'pillow'.
+            These two backends generates slightly different results. Defaults
+            to 'cv2'.
+        interpolation (str): Interpolation method, accepted values are
+            "nearest", "bilinear", "bicubic", "area", "lanczos" for 'cv2'
+            backend, "nearest", "bilinear" for 'pillow' backend. Defaults
+            to 'bilinear'.
+    """
+
+    def _resize_masks(self, results: dict) -> None:
+        """Resize masks with ``results['scale']``"""
+        if results.get('gt_masks', None) is not None:
+            if self.keep_ratio:
+                results['gt_masks'] = results['gt_masks'].rescale(
+                    results['scale'])
+            else:
+                results['gt_masks'] = results['gt_masks'].resize(
+                    results['img_shape'])
+
+    def _resize_bboxes(self, results: dict) -> None:
+        """Resize bounding boxes with ``results['scale_factor']``."""
+        if results.get('gt_bboxes', None) is not None:
+            results['gt_bboxes'].rescale_(results['scale_factor'])
+            if self.clip_object_border:
+                results['gt_bboxes'].clip_(results['img_shape'])
+
+    def _record_homography_matrix(self, results: dict) -> None:
+        """Record the homography matrix for the Resize."""
+        w_scale, h_scale = results['scale_factor']
+        homography_matrix = np.array(
+            [[w_scale, 0, 0], [0, h_scale, 0], [0, 0, 1]], dtype=np.float32)
+        if results.get('homography_matrix', None) is None:
+            results['homography_matrix'] = homography_matrix
+        else:
+            results['homography_matrix'] = homography_matrix @ results[
+                'homography_matrix']
+
+    @autocast_box_type()
+    def transform(self, results: dict) -> dict:
+        """Transform function to resize images, bounding boxes and semantic
+        segmentation map.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+        Returns:
+            dict: Resized results, 'img', 'gt_bboxes', 'gt_seg_map',
+            'scale', 'scale_factor', 'height', 'width', and 'keep_ratio' keys
+            are updated in result dict.
+        """
+        if self.scale:
+            results['scale'] = self.scale
+        else:
+            img_shape = results['img'].shape[:2]
+            results['scale'] = _scale_size(img_shape[::-1], self.scale_factor)
+        self._resize_img(results)
+        self._resize_bboxes(results)
+        self._resize_masks(results)
+        self._resize_seg(results)
+        self._record_homography_matrix(results)
+        return results
+
+    def __repr__(self) -> str:
+        repr_str = self.__class__.__name__
+        repr_str += f'(scale={self.scale}, '
+        repr_str += f'scale_factor={self.scale_factor}, '
+        repr_str += f'keep_ratio={self.keep_ratio}, '
+        repr_str += f'clip_object_border={self.clip_object_border}), '
+        repr_str += f'backend={self.backend}), '
+        repr_str += f'interpolation={self.interpolation})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class FixScaleResize(Resize):
+    """Compared to Resize, FixScaleResize fixes the scaling issue when
+    `keep_ratio=true`."""
+
+    def _resize_img(self, results):
+        """Resize images with ``results['scale']``."""
+        if results.get('img', None) is not None:
+            if self.keep_ratio:
+                img, scale_factor = imrescale(
+                    results['img'],
+                    results['scale'],
+                    interpolation=self.interpolation,
+                    return_scale=True,
+                    backend=self.backend)
+                new_h, new_w = img.shape[:2]
+                h, w = results['img'].shape[:2]
+                w_scale = new_w / w
+                h_scale = new_h / h
+            else:
+                img, w_scale, h_scale = mmcv.imresize(
+                    results['img'],
+                    results['scale'],
+                    interpolation=self.interpolation,
+                    return_scale=True,
+                    backend=self.backend)
+            results['img'] = img
+            results['img_shape'] = img.shape[:2]
+            results['scale_factor'] = (w_scale, h_scale)
+            results['keep_ratio'] = self.keep_ratio
+
+
+@TRANSFORMS.register_module()
+class ResizeShortestEdge(BaseTransform):
+    """Resize the image and mask while keeping the aspect ratio unchanged.
+
+    Modified from https://github.com/facebookresearch/detectron2/blob/main/detectron2/data/transforms/augmentation_impl.py#L130 # noqa:E501
+
+    This transform attempts to scale the shorter edge to the given
+    `scale`, as long as the longer edge does not exceed `max_size`.
+    If `max_size` is reached, then downscale so that the longer
+    edge does not exceed `max_size`.
+
+    Required Keys:
+        - img
+        - gt_seg_map (optional)
+    Modified Keys:
+        - img
+        - img_shape
+        - gt_seg_map (optional))
+    Added Keys:
+        - scale
+        - scale_factor
+        - keep_ratio
+
+    Args:
+        scale (Union[int, Tuple[int, int]]): The target short edge length.
+            If it's tuple, will select the min value as the short edge length.
+        max_size (int): The maximum allowed longest edge length.
+    """
+
+    def __init__(self,
+                 scale: Union[int, Tuple[int, int]],
+                 max_size: Optional[int] = None,
+                 resize_type: str = 'Resize',
+                 **resize_kwargs) -> None:
+        super().__init__()
+        self.scale = scale
+        self.max_size = max_size
+
+        self.resize_cfg = dict(type=resize_type, **resize_kwargs)
+        self.resize = TRANSFORMS.build({'scale': 0, **self.resize_cfg})
+
+    def _get_output_shape(
+            self, img: np.ndarray,
+            short_edge_length: Union[int, Tuple[int, int]]) -> Tuple[int, int]:
+        """Compute the target image shape with the given `short_edge_length`.
+
+        Args:
+            img (np.ndarray): The input image.
+            short_edge_length (Union[int, Tuple[int, int]]): The target short
+                edge length. If it's tuple, will select the min value as the
+                short edge length.
+        """
+        h, w = img.shape[:2]
+        if isinstance(short_edge_length, int):
+            size = short_edge_length * 1.0
+        elif isinstance(short_edge_length, tuple):
+            size = min(short_edge_length) * 1.0
+        scale = size / min(h, w)
+        if h < w:
+            new_h, new_w = size, scale * w
+        else:
+            new_h, new_w = scale * h, size
+
+        if self.max_size and max(new_h, new_w) > self.max_size:
+            scale = self.max_size * 1.0 / max(new_h, new_w)
+            new_h *= scale
+            new_w *= scale
+
+        new_h = int(new_h + 0.5)
+        new_w = int(new_w + 0.5)
+        return new_w, new_h
+
+    def transform(self, results: dict) -> dict:
+        self.resize.scale = self._get_output_shape(results['img'], self.scale)
+        return self.resize(results)
+
+
+@TRANSFORMS.register_module()
+class FixShapeResize(Resize):
+    """Resize images & bbox & seg to the specified size.
+
+    This transform resizes the input image according to ``width`` and
+    ``height``. Bboxes, masks, and seg map are then resized
+    with the same parameters.
+
+    Required Keys:
+
+    - img
+    - gt_bboxes (BaseBoxes[torch.float32]) (optional)
+    - gt_masks (BitmapMasks | PolygonMasks) (optional)
+    - gt_seg_map (np.uint8) (optional)
+
+    Modified Keys:
+
+    - img
+    - img_shape
+    - gt_bboxes
+    - gt_masks
+    - gt_seg_map
+
+
+    Added Keys:
+
+    - scale
+    - scale_factor
+    - keep_ratio
+    - homography_matrix
+
+    Args:
+        width (int): width for resizing.
+        height (int): height for resizing.
+            Defaults to None.
+        pad_val (Number | dict[str, Number], optional): Padding value for if
+            the pad_mode is "constant".  If it is a single number, the value
+            to pad the image is the number and to pad the semantic
+            segmentation map is 255. If it is a dict, it should have the
+            following keys:
+
+            - img: The value to pad the image.
+            - seg: The value to pad the semantic segmentation map.
+            Defaults to dict(img=0, seg=255).
+        keep_ratio (bool): Whether to keep the aspect ratio when resizing the
+            image. Defaults to False.
+        clip_object_border (bool): Whether to clip the objects
+            outside the border of the image. In some dataset like MOT17, the gt
+            bboxes are allowed to cross the border of images. Therefore, we
+            don't need to clip the gt bboxes in these cases. Defaults to True.
+        backend (str): Image resize backend, choices are 'cv2' and 'pillow'.
+            These two backends generates slightly different results. Defaults
+            to 'cv2'.
+        interpolation (str): Interpolation method, accepted values are
+            "nearest", "bilinear", "bicubic", "area", "lanczos" for 'cv2'
+            backend, "nearest", "bilinear" for 'pillow' backend. Defaults
+            to 'bilinear'.
+    """
+
+    def __init__(self,
+                 width: int,
+                 height: int,
+                 pad_val: Union[Number, dict] = dict(img=0, seg=255),
+                 keep_ratio: bool = False,
+                 clip_object_border: bool = True,
+                 backend: str = 'cv2',
+                 interpolation: str = 'bilinear') -> None:
+        assert width is not None and height is not None, (
+            '`width` and'
+            '`height` can not be `None`')
+
+        self.width = width
+        self.height = height
+        self.scale = (width, height)
+
+        self.backend = backend
+        self.interpolation = interpolation
+        self.keep_ratio = keep_ratio
+        self.clip_object_border = clip_object_border
+
+        if keep_ratio is True:
+            # padding to the fixed size when keep_ratio=True
+            self.pad_transform = Pad(size=self.scale, pad_val=pad_val)
+
+    @autocast_box_type()
+    def transform(self, results: dict) -> dict:
+        """Transform function to resize images, bounding boxes and semantic
+        segmentation map.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+        Returns:
+            dict: Resized results, 'img', 'gt_bboxes', 'gt_seg_map',
+            'scale', 'scale_factor', 'height', 'width', and 'keep_ratio' keys
+            are updated in result dict.
+        """
+        img = results['img']
+        h, w = img.shape[:2]
+        if self.keep_ratio:
+            scale_factor = min(self.width / w, self.height / h)
+            results['scale_factor'] = (scale_factor, scale_factor)
+            real_w, real_h = int(w * float(scale_factor) +
+                                 0.5), int(h * float(scale_factor) + 0.5)
+            img, scale_factor = mmcv.imrescale(
+                results['img'], (real_w, real_h),
+                interpolation=self.interpolation,
+                return_scale=True,
+                backend=self.backend)
+            # the w_scale and h_scale has minor difference
+            # a real fix should be done in the mmcv.imrescale in the future
+            results['img'] = img
+            results['img_shape'] = img.shape[:2]
+            results['keep_ratio'] = self.keep_ratio
+            results['scale'] = (real_w, real_h)
+        else:
+            results['scale'] = (self.width, self.height)
+            results['scale_factor'] = (self.width / w, self.height / h)
+            super()._resize_img(results)
+
+        self._resize_bboxes(results)
+        self._resize_masks(results)
+        self._resize_seg(results)
+        self._record_homography_matrix(results)
+        if self.keep_ratio:
+            self.pad_transform(results)
+        return results
+
+    def __repr__(self) -> str:
+        repr_str = self.__class__.__name__
+        repr_str += f'(width={self.width}, height={self.height}, '
+        repr_str += f'keep_ratio={self.keep_ratio}, '
+        repr_str += f'clip_object_border={self.clip_object_border}), '
+        repr_str += f'backend={self.backend}), '
+        repr_str += f'interpolation={self.interpolation})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class RandomFlip(MMCV_RandomFlip):
+    """Flip the image & bbox & mask & segmentation map. Added or Updated keys:
+    flip, flip_direction, img, gt_bboxes, and gt_seg_map. There are 3 flip
+    modes:
+
+     - ``prob`` is float, ``direction`` is string: the image will be
+         ``direction``ly flipped with probability of ``prob`` .
+         E.g., ``prob=0.5``, ``direction='horizontal'``,
+         then image will be horizontally flipped with probability of 0.5.
+     - ``prob`` is float, ``direction`` is list of string: the image will
+         be ``direction[i]``ly flipped with probability of
+         ``prob/len(direction)``.
+         E.g., ``prob=0.5``, ``direction=['horizontal', 'vertical']``,
+         then image will be horizontally flipped with probability of 0.25,
+         vertically with probability of 0.25.
+     - ``prob`` is list of float, ``direction`` is list of string:
+         given ``len(prob) == len(direction)``, the image will
+         be ``direction[i]``ly flipped with probability of ``prob[i]``.
+         E.g., ``prob=[0.3, 0.5]``, ``direction=['horizontal',
+         'vertical']``, then image will be horizontally flipped with
+         probability of 0.3, vertically with probability of 0.5.
+
+
+    Required Keys:
+
+    - img
+    - gt_bboxes (BaseBoxes[torch.float32]) (optional)
+    - gt_masks (BitmapMasks | PolygonMasks) (optional)
+    - gt_seg_map (np.uint8) (optional)
+
+    Modified Keys:
+
+    - img
+    - gt_bboxes
+    - gt_masks
+    - gt_seg_map
+
+    Added Keys:
+
+    - flip
+    - flip_direction
+    - homography_matrix
+
+
+    Args:
+         prob (float | list[float], optional): The flipping probability.
+             Defaults to None.
+         direction(str | list[str]): The flipping direction. Options
+             If input is a list, the length must equal ``prob``. Each
+             element in ``prob`` indicates the flip probability of
+             corresponding direction. Defaults to 'horizontal'.
+    """
+
+    def _record_homography_matrix(self, results: dict) -> None:
+        """Record the homography matrix for the RandomFlip."""
+        cur_dir = results['flip_direction']
+        h, w = results['img'].shape[:2]
+
+        if cur_dir == 'horizontal':
+            homography_matrix = np.array([[-1, 0, w], [0, 1, 0], [0, 0, 1]],
+                                         dtype=np.float32)
+        elif cur_dir == 'vertical':
+            homography_matrix = np.array([[1, 0, 0], [0, -1, h], [0, 0, 1]],
+                                         dtype=np.float32)
+        elif cur_dir == 'diagonal':
+            homography_matrix = np.array([[-1, 0, w], [0, -1, h], [0, 0, 1]],
+                                         dtype=np.float32)
+        else:
+            homography_matrix = np.eye(3, dtype=np.float32)
+
+        if results.get('homography_matrix', None) is None:
+            results['homography_matrix'] = homography_matrix
+        else:
+            results['homography_matrix'] = homography_matrix @ results[
+                'homography_matrix']
+
+    @autocast_box_type()
+    def _flip(self, results: dict) -> None:
+        """Flip images, bounding boxes, and semantic segmentation map."""
+        # flip image
+        results['img'] = mmcv.imflip(
+            results['img'], direction=results['flip_direction'])
+
+        img_shape = results['img'].shape[:2]
+
+        # flip bboxes
+        if results.get('gt_bboxes', None) is not None:
+            results['gt_bboxes'].flip_(img_shape, results['flip_direction'])
+
+        # flip masks
+        if results.get('gt_masks', None) is not None:
+            results['gt_masks'] = results['gt_masks'].flip(
+                results['flip_direction'])
+
+        # flip segs
+        if results.get('gt_seg_map', None) is not None:
+            results['gt_seg_map'] = mmcv.imflip(
+                results['gt_seg_map'], direction=results['flip_direction'])
+
+        # record homography matrix for flip
+        self._record_homography_matrix(results)
+
+
+@TRANSFORMS.register_module()
+class RandomShift(BaseTransform):
+    """Shift the image and box given shift pixels and probability.
+
+    Required Keys:
+
+    - img
+    - gt_bboxes (BaseBoxes[torch.float32])
+    - gt_bboxes_labels (np.int64)
+    - gt_ignore_flags (bool) (optional)
+
+    Modified Keys:
+
+    - img
+    - gt_bboxes
+    - gt_bboxes_labels
+    - gt_ignore_flags (bool) (optional)
+
+    Args:
+        prob (float): Probability of shifts. Defaults to 0.5.
+        max_shift_px (int): The max pixels for shifting. Defaults to 32.
+        filter_thr_px (int): The width and height threshold for filtering.
+            The bbox and the rest of the targets below the width and
+            height threshold will be filtered. Defaults to 1.
+    """
+
+    def __init__(self,
+                 prob: float = 0.5,
+                 max_shift_px: int = 32,
+                 filter_thr_px: int = 1) -> None:
+        assert 0 <= prob <= 1
+        assert max_shift_px >= 0
+        self.prob = prob
+        self.max_shift_px = max_shift_px
+        self.filter_thr_px = int(filter_thr_px)
+
+    @cache_randomness
+    def _random_prob(self) -> float:
+        return random.uniform(0, 1)
+
+    @autocast_box_type()
+    def transform(self, results: dict) -> dict:
+        """Transform function to random shift images, bounding boxes.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Shift results.
+        """
+        if self._random_prob() < self.prob:
+            img_shape = results['img'].shape[:2]
+
+            random_shift_x = random.randint(-self.max_shift_px,
+                                            self.max_shift_px)
+            random_shift_y = random.randint(-self.max_shift_px,
+                                            self.max_shift_px)
+            new_x = max(0, random_shift_x)
+            ori_x = max(0, -random_shift_x)
+            new_y = max(0, random_shift_y)
+            ori_y = max(0, -random_shift_y)
+
+            # TODO: support mask and semantic segmentation maps.
+            bboxes = results['gt_bboxes'].clone()
+            bboxes.translate_([random_shift_x, random_shift_y])
+
+            # clip border
+            bboxes.clip_(img_shape)
+
+            # remove invalid bboxes
+            valid_inds = (bboxes.widths > self.filter_thr_px).numpy() & (
+                bboxes.heights > self.filter_thr_px).numpy()
+            # If the shift does not contain any gt-bbox area, skip this
+            # image.
+            if not valid_inds.any():
+                return results
+            bboxes = bboxes[valid_inds]
+            results['gt_bboxes'] = bboxes
+            results['gt_bboxes_labels'] = results['gt_bboxes_labels'][
+                valid_inds]
+
+            if results.get('gt_ignore_flags', None) is not None:
+                results['gt_ignore_flags'] = \
+                    results['gt_ignore_flags'][valid_inds]
+
+            # shift img
+            img = results['img']
+            new_img = np.zeros_like(img)
+            img_h, img_w = img.shape[:2]
+            new_h = img_h - np.abs(random_shift_y)
+            new_w = img_w - np.abs(random_shift_x)
+            new_img[new_y:new_y + new_h, new_x:new_x + new_w] \
+                = img[ori_y:ori_y + new_h, ori_x:ori_x + new_w]
+            results['img'] = new_img
+
+        return results
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'(prob={self.prob}, '
+        repr_str += f'max_shift_px={self.max_shift_px}, '
+        repr_str += f'filter_thr_px={self.filter_thr_px})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class Pad(MMCV_Pad):
+    """Pad the image & segmentation map.
+
+    There are three padding modes: (1) pad to a fixed size and (2) pad to the
+    minimum size that is divisible by some number. and (3)pad to square. Also,
+    pad to square and pad to the minimum size can be used as the same time.
+
+    Required Keys:
+
+    - img
+    - gt_bboxes (BaseBoxes[torch.float32]) (optional)
+    - gt_masks (BitmapMasks | PolygonMasks) (optional)
+    - gt_seg_map (np.uint8) (optional)
+
+    Modified Keys:
+
+    - img
+    - img_shape
+    - gt_masks
+    - gt_seg_map
+
+    Added Keys:
+
+    - pad_shape
+    - pad_fixed_size
+    - pad_size_divisor
+
+    Args:
+        size (tuple, optional): Fixed padding size.
+            Expected padding shape (width, height). Defaults to None.
+        size_divisor (int, optional): The divisor of padded size. Defaults to
+            None.
+        pad_to_square (bool): Whether to pad the image into a square.
+            Currently only used for YOLOX. Defaults to False.
+        pad_val (Number | dict[str, Number], optional) - Padding value for if
+            the pad_mode is "constant".  If it is a single number, the value
+            to pad the image is the number and to pad the semantic
+            segmentation map is 255. If it is a dict, it should have the
+            following keys:
+
+            - img: The value to pad the image.
+            - seg: The value to pad the semantic segmentation map.
+            Defaults to dict(img=0, seg=255).
+        padding_mode (str): Type of padding. Should be: constant, edge,
+            reflect or symmetric. Defaults to 'constant'.
+
+            - constant: pads with a constant value, this value is specified
+              with pad_val.
+            - edge: pads with the last value at the edge of the image.
+            - reflect: pads with reflection of image without repeating the last
+              value on the edge. For example, padding [1, 2, 3, 4] with 2
+              elements on both sides in reflect mode will result in
+              [3, 2, 1, 2, 3, 4, 3, 2].
+            - symmetric: pads with reflection of image repeating the last value
+              on the edge. For example, padding [1, 2, 3, 4] with 2 elements on
+              both sides in symmetric mode will result in
+              [2, 1, 1, 2, 3, 4, 4, 3]
+    """
+
+    def _pad_masks(self, results: dict) -> None:
+        """Pad masks according to ``results['pad_shape']``."""
+        if results.get('gt_masks', None) is not None:
+            pad_val = self.pad_val.get('masks', 0)
+            pad_shape = results['pad_shape'][:2]
+            results['gt_masks'] = results['gt_masks'].pad(
+                pad_shape, pad_val=pad_val)
+
+    def transform(self, results: dict) -> dict:
+        """Call function to pad images, masks, semantic segmentation maps.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Updated result dict.
+        """
+        self._pad_img(results)
+        self._pad_seg(results)
+        self._pad_masks(results)
+        return results
+
+
+@TRANSFORMS.register_module()
+class RandomCrop(BaseTransform):
+    """Random crop the image & bboxes & masks.
+
+    The absolute ``crop_size`` is sampled based on ``crop_type`` and
+    ``image_size``, then the cropped results are generated.
+
+    Required Keys:
+
+    - img
+    - gt_bboxes (BaseBoxes[torch.float32]) (optional)
+    - gt_bboxes_labels (np.int64) (optional)
+    - gt_masks (BitmapMasks | PolygonMasks) (optional)
+    - gt_ignore_flags (bool) (optional)
+    - gt_seg_map (np.uint8) (optional)
+
+    Modified Keys:
+
+    - img
+    - img_shape
+    - gt_bboxes (optional)
+    - gt_bboxes_labels (optional)
+    - gt_masks (optional)
+    - gt_ignore_flags (optional)
+    - gt_seg_map (optional)
+    - gt_instances_ids (options, only used in MOT/VIS)
+
+    Added Keys:
+
+    - homography_matrix
+
+    Args:
+        crop_size (tuple): The relative ratio or absolute pixels of
+            (width, height).
+        crop_type (str, optional): One of "relative_range", "relative",
+            "absolute", "absolute_range". "relative" randomly crops
+            (h * crop_size[0], w * crop_size[1]) part from an input of size
+            (h, w). "relative_range" uniformly samples relative crop size from
+            range [crop_size[0], 1] and [crop_size[1], 1] for height and width
+            respectively. "absolute" crops from an input with absolute size
+            (crop_size[0], crop_size[1]). "absolute_range" uniformly samples
+            crop_h in range [crop_size[0], min(h, crop_size[1])] and crop_w
+            in range [crop_size[0], min(w, crop_size[1])].
+            Defaults to "absolute".
+        allow_negative_crop (bool, optional): Whether to allow a crop that does
+            not contain any bbox area. Defaults to False.
+        recompute_bbox (bool, optional): Whether to re-compute the boxes based
+            on cropped instance masks. Defaults to False.
+        bbox_clip_border (bool, optional): Whether clip the objects outside
+            the border of the image. Defaults to True.
+
+    Note:
+        - If the image is smaller than the absolute crop size, return the
+            original image.
+        - The keys for bboxes, labels and masks must be aligned. That is,
+          ``gt_bboxes`` corresponds to ``gt_labels`` and ``gt_masks``, and
+          ``gt_bboxes_ignore`` corresponds to ``gt_labels_ignore`` and
+          ``gt_masks_ignore``.
+        - If the crop does not contain any gt-bbox region and
+          ``allow_negative_crop`` is set to False, skip this image.
+    """
+
+    def __init__(self,
+                 crop_size: tuple,
+                 crop_type: str = 'absolute',
+                 allow_negative_crop: bool = False,
+                 recompute_bbox: bool = False,
+                 bbox_clip_border: bool = True) -> None:
+        if crop_type not in [
+                'relative_range', 'relative', 'absolute', 'absolute_range'
+        ]:
+            raise ValueError(f'Invalid crop_type {crop_type}.')
+        if crop_type in ['absolute', 'absolute_range']:
+            assert crop_size[0] > 0 and crop_size[1] > 0
+            assert isinstance(crop_size[0], int) and isinstance(
+                crop_size[1], int)
+            if crop_type == 'absolute_range':
+                assert crop_size[0] <= crop_size[1]
+        else:
+            assert 0 < crop_size[0] <= 1 and 0 < crop_size[1] <= 1
+        self.crop_size = crop_size
+        self.crop_type = crop_type
+        self.allow_negative_crop = allow_negative_crop
+        self.bbox_clip_border = bbox_clip_border
+        self.recompute_bbox = recompute_bbox
+
+    def _crop_data(self, results: dict, crop_size: Tuple[int, int],
+                   allow_negative_crop: bool) -> Union[dict, None]:
+        """Function to randomly crop images, bounding boxes, masks, semantic
+        segmentation maps.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+            crop_size (Tuple[int, int]): Expected absolute size after
+                cropping, (h, w).
+            allow_negative_crop (bool): Whether to allow a crop that does not
+                contain any bbox area.
+
+        Returns:
+            results (Union[dict, None]): Randomly cropped results, 'img_shape'
+                key in result dict is updated according to crop size. None will
+                be returned when there is no valid bbox after cropping.
+        """
+        assert crop_size[0] > 0 and crop_size[1] > 0
+        img = results['img']
+        margin_h = max(img.shape[0] - crop_size[0], 0)
+        margin_w = max(img.shape[1] - crop_size[1], 0)
+        offset_h, offset_w = self._rand_offset((margin_h, margin_w))
+        crop_y1, crop_y2 = offset_h, offset_h + crop_size[0]
+        crop_x1, crop_x2 = offset_w, offset_w + crop_size[1]
+
+        # Record the homography matrix for the RandomCrop
+        homography_matrix = np.array(
+            [[1, 0, -offset_w], [0, 1, -offset_h], [0, 0, 1]],
+            dtype=np.float32)
+        if results.get('homography_matrix', None) is None:
+            results['homography_matrix'] = homography_matrix
+        else:
+            results['homography_matrix'] = homography_matrix @ results[
+                'homography_matrix']
+
+        # crop the image
+        img = img[crop_y1:crop_y2, crop_x1:crop_x2, ...]
+        img_shape = img.shape
+        results['img'] = img
+        results['img_shape'] = img_shape[:2]
+
+        # crop bboxes accordingly and clip to the image boundary
+        if results.get('gt_bboxes', None) is not None:
+            bboxes = results['gt_bboxes']
+            bboxes.translate_([-offset_w, -offset_h])
+            if self.bbox_clip_border:
+                bboxes.clip_(img_shape[:2])
+            valid_inds = bboxes.is_inside(img_shape[:2]).numpy()
+            # If the crop does not contain any gt-bbox area and
+            # allow_negative_crop is False, skip this image.
+            if (not valid_inds.any() and not allow_negative_crop):
+                return None
+
+            results['gt_bboxes'] = bboxes[valid_inds]
+
+            if results.get('gt_ignore_flags', None) is not None:
+                results['gt_ignore_flags'] = \
+                    results['gt_ignore_flags'][valid_inds]
+
+            if results.get('gt_bboxes_labels', None) is not None:
+                results['gt_bboxes_labels'] = \
+                    results['gt_bboxes_labels'][valid_inds]
+
+            if results.get('gt_masks', None) is not None:
+                results['gt_masks'] = results['gt_masks'][
+                    valid_inds.nonzero()[0]].crop(
+                        np.asarray([crop_x1, crop_y1, crop_x2, crop_y2]))
+                if self.recompute_bbox:
+                    results['gt_bboxes'] = results['gt_masks'].get_bboxes(
+                        type(results['gt_bboxes']))
+
+            # We should remove the instance ids corresponding to invalid boxes.
+            if results.get('gt_instances_ids', None) is not None:
+                results['gt_instances_ids'] = \
+                    results['gt_instances_ids'][valid_inds]
+
+        # crop semantic seg
+        if results.get('gt_seg_map', None) is not None:
+            results['gt_seg_map'] = results['gt_seg_map'][crop_y1:crop_y2,
+                                                          crop_x1:crop_x2]
+
+        return results
+
+    @cache_randomness
+    def _rand_offset(self, margin: Tuple[int, int]) -> Tuple[int, int]:
+        """Randomly generate crop offset.
+
+        Args:
+            margin (Tuple[int, int]): The upper bound for the offset generated
+                randomly.
+
+        Returns:
+            Tuple[int, int]: The random offset for the crop.
+        """
+        margin_h, margin_w = margin
+        offset_h = np.random.randint(0, margin_h + 1)
+        offset_w = np.random.randint(0, margin_w + 1)
+
+        return offset_h, offset_w
+
+    @cache_randomness
+    def _get_crop_size(self, image_size: Tuple[int, int]) -> Tuple[int, int]:
+        """Randomly generates the absolute crop size based on `crop_type` and
+        `image_size`.
+
+        Args:
+            image_size (Tuple[int, int]): (h, w).
+
+        Returns:
+            crop_size (Tuple[int, int]): (crop_h, crop_w) in absolute pixels.
+        """
+        h, w = image_size
+        if self.crop_type == 'absolute':
+            return min(self.crop_size[1], h), min(self.crop_size[0], w)
+        elif self.crop_type == 'absolute_range':
+            crop_h = np.random.randint(
+                min(h, self.crop_size[0]),
+                min(h, self.crop_size[1]) + 1)
+            crop_w = np.random.randint(
+                min(w, self.crop_size[0]),
+                min(w, self.crop_size[1]) + 1)
+            return crop_h, crop_w
+        elif self.crop_type == 'relative':
+            crop_w, crop_h = self.crop_size
+            return int(h * crop_h + 0.5), int(w * crop_w + 0.5)
+        else:
+            # 'relative_range'
+            crop_size = np.asarray(self.crop_size, dtype=np.float32)
+            crop_h, crop_w = crop_size + np.random.rand(2) * (1 - crop_size)
+            return int(h * crop_h + 0.5), int(w * crop_w + 0.5)
+
+    @autocast_box_type()
+    def transform(self, results: dict) -> Union[dict, None]:
+        """Transform function to randomly crop images, bounding boxes, masks,
+        semantic segmentation maps.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            results (Union[dict, None]): Randomly cropped results, 'img_shape'
+                key in result dict is updated according to crop size. None will
+                be returned when there is no valid bbox after cropping.
+        """
+        image_size = results['img'].shape[:2]
+        crop_size = self._get_crop_size(image_size)
+        results = self._crop_data(results, crop_size, self.allow_negative_crop)
+        return results
+
+    def __repr__(self) -> str:
+        repr_str = self.__class__.__name__
+        repr_str += f'(crop_size={self.crop_size}, '
+        repr_str += f'crop_type={self.crop_type}, '
+        repr_str += f'allow_negative_crop={self.allow_negative_crop}, '
+        repr_str += f'recompute_bbox={self.recompute_bbox}, '
+        repr_str += f'bbox_clip_border={self.bbox_clip_border})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class SegRescale(BaseTransform):
+    """Rescale semantic segmentation maps.
+
+    This transform rescale the ``gt_seg_map`` according to ``scale_factor``.
+
+    Required Keys:
+
+    - gt_seg_map
+
+    Modified Keys:
+
+    - gt_seg_map
+
+    Args:
+        scale_factor (float): The scale factor of the final output. Defaults
+            to 1.
+        backend (str): Image rescale backend, choices are 'cv2' and 'pillow'.
+            These two backends generates slightly different results. Defaults
+            to 'cv2'.
+    """
+
+    def __init__(self, scale_factor: float = 1, backend: str = 'cv2') -> None:
+        self.scale_factor = scale_factor
+        self.backend = backend
+
+    def transform(self, results: dict) -> dict:
+        """Transform function to scale the semantic segmentation map.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Result dict with semantic segmentation map scaled.
+        """
+        if self.scale_factor != 1:
+            results['gt_seg_map'] = mmcv.imrescale(
+                results['gt_seg_map'],
+                self.scale_factor,
+                interpolation='nearest',
+                backend=self.backend)
+
+        return results
+
+    def __repr__(self) -> str:
+        repr_str = self.__class__.__name__
+        repr_str += f'(scale_factor={self.scale_factor}, '
+        repr_str += f'backend={self.backend})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class PhotoMetricDistortion(BaseTransform):
+    """Apply photometric distortion to image sequentially, every transformation
+    is applied with a probability of 0.5. The position of random contrast is in
+    second or second to last.
+
+    1. random brightness
+    2. random contrast (mode 0)
+    3. convert color from BGR to HSV
+    4. random saturation
+    5. random hue
+    6. convert color from HSV to BGR
+    7. random contrast (mode 1)
+    8. randomly swap channels
+
+    Required Keys:
+
+    - img (np.uint8)
+
+    Modified Keys:
+
+    - img (np.float32)
+
+    Args:
+        brightness_delta (int): delta of brightness.
+        contrast_range (sequence): range of contrast.
+        saturation_range (sequence): range of saturation.
+        hue_delta (int): delta of hue.
+    """
+
+    def __init__(self,
+                 brightness_delta: int = 32,
+                 contrast_range: Sequence[Number] = (0.5, 1.5),
+                 saturation_range: Sequence[Number] = (0.5, 1.5),
+                 hue_delta: int = 18) -> None:
+        self.brightness_delta = brightness_delta
+        self.contrast_lower, self.contrast_upper = contrast_range
+        self.saturation_lower, self.saturation_upper = saturation_range
+        self.hue_delta = hue_delta
+
+    @cache_randomness
+    def _random_flags(self) -> Sequence[Number]:
+        mode = random.randint(2)
+        brightness_flag = random.randint(2)
+        contrast_flag = random.randint(2)
+        saturation_flag = random.randint(2)
+        hue_flag = random.randint(2)
+        swap_flag = random.randint(2)
+        delta_value = random.uniform(-self.brightness_delta,
+                                     self.brightness_delta)
+        alpha_value = random.uniform(self.contrast_lower, self.contrast_upper)
+        saturation_value = random.uniform(self.saturation_lower,
+                                          self.saturation_upper)
+        hue_value = random.uniform(-self.hue_delta, self.hue_delta)
+        swap_value = random.permutation(3)
+
+        return (mode, brightness_flag, contrast_flag, saturation_flag,
+                hue_flag, swap_flag, delta_value, alpha_value,
+                saturation_value, hue_value, swap_value)
+
+    def transform(self, results: dict) -> dict:
+        """Transform function to perform photometric distortion on images.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Result dict with images distorted.
+        """
+        assert 'img' in results, '`img` is not found in results'
+        img = results['img']
+        img = img.astype(np.float32)
+
+        (mode, brightness_flag, contrast_flag, saturation_flag, hue_flag,
+         swap_flag, delta_value, alpha_value, saturation_value, hue_value,
+         swap_value) = self._random_flags()
+
+        # random brightness
+        if brightness_flag:
+            img += delta_value
+
+        # mode == 0 --> do random contrast first
+        # mode == 1 --> do random contrast last
+        if mode == 1:
+            if contrast_flag:
+                img *= alpha_value
+
+        # convert color from BGR to HSV
+        img = mmcv.bgr2hsv(img)
+
+        # random saturation
+        if saturation_flag:
+            img[..., 1] *= saturation_value
+            # For image(type=float32), after convert bgr to hsv by opencv,
+            # valid saturation value range is [0, 1]
+            if saturation_value > 1:
+                img[..., 1] = img[..., 1].clip(0, 1)
+
+        # random hue
+        if hue_flag:
+            img[..., 0] += hue_value
+            img[..., 0][img[..., 0] > 360] -= 360
+            img[..., 0][img[..., 0] < 0] += 360
+
+        # convert color from HSV to BGR
+        img = mmcv.hsv2bgr(img)
+
+        # random contrast
+        if mode == 0:
+            if contrast_flag:
+                img *= alpha_value
+
+        # randomly swap channels
+        if swap_flag:
+            img = img[..., swap_value]
+
+        results['img'] = img
+        return results
+
+    def __repr__(self) -> str:
+        repr_str = self.__class__.__name__
+        repr_str += f'(brightness_delta={self.brightness_delta}, '
+        repr_str += 'contrast_range='
+        repr_str += f'{(self.contrast_lower, self.contrast_upper)}, '
+        repr_str += 'saturation_range='
+        repr_str += f'{(self.saturation_lower, self.saturation_upper)}, '
+        repr_str += f'hue_delta={self.hue_delta})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class Expand(BaseTransform):
+    """Random expand the image & bboxes & masks & segmentation map.
+
+    Randomly place the original image on a canvas of ``ratio`` x original image
+    size filled with mean values. The ratio is in the range of ratio_range.
+
+    Required Keys:
+
+    - img
+    - img_shape
+    - gt_bboxes (BaseBoxes[torch.float32]) (optional)
+    - gt_masks (BitmapMasks | PolygonMasks) (optional)
+    - gt_seg_map (np.uint8) (optional)
+
+    Modified Keys:
+
+    - img
+    - img_shape
+    - gt_bboxes
+    - gt_masks
+    - gt_seg_map
+
+
+    Args:
+        mean (sequence): mean value of dataset.
+        to_rgb (bool): if need to convert the order of mean to align with RGB.
+        ratio_range (sequence)): range of expand ratio.
+        seg_ignore_label (int): label of ignore segmentation map.
+        prob (float): probability of applying this transformation
+    """
+
+    def __init__(self,
+                 mean: Sequence[Number] = (0, 0, 0),
+                 to_rgb: bool = True,
+                 ratio_range: Sequence[Number] = (1, 4),
+                 seg_ignore_label: int = None,
+                 prob: float = 0.5) -> None:
+        self.to_rgb = to_rgb
+        self.ratio_range = ratio_range
+        if to_rgb:
+            self.mean = mean[::-1]
+        else:
+            self.mean = mean
+        self.min_ratio, self.max_ratio = ratio_range
+        self.seg_ignore_label = seg_ignore_label
+        self.prob = prob
+
+    @cache_randomness
+    def _random_prob(self) -> float:
+        return random.uniform(0, 1)
+
+    @cache_randomness
+    def _random_ratio(self) -> float:
+        return random.uniform(self.min_ratio, self.max_ratio)
+
+    @cache_randomness
+    def _random_left_top(self, ratio: float, h: int,
+                         w: int) -> Tuple[int, int]:
+        left = int(random.uniform(0, w * ratio - w))
+        top = int(random.uniform(0, h * ratio - h))
+        return left, top
+
+    @autocast_box_type()
+    def transform(self, results: dict) -> dict:
+        """Transform function to expand images, bounding boxes, masks,
+        segmentation map.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Result dict with images, bounding boxes, masks, segmentation
+                map expanded.
+        """
+        if self._random_prob() > self.prob:
+            return results
+        assert 'img' in results, '`img` is not found in results'
+        img = results['img']
+        h, w, c = img.shape
+        ratio = self._random_ratio()
+        # speedup expand when meets large image
+        if np.all(self.mean == self.mean[0]):
+            expand_img = np.empty((int(h * ratio), int(w * ratio), c),
+                                  img.dtype)
+            expand_img.fill(self.mean[0])
+        else:
+            expand_img = np.full((int(h * ratio), int(w * ratio), c),
+                                 self.mean,
+                                 dtype=img.dtype)
+        left, top = self._random_left_top(ratio, h, w)
+        expand_img[top:top + h, left:left + w] = img
+        results['img'] = expand_img
+        results['img_shape'] = expand_img.shape[:2]
+
+        # expand bboxes
+        if results.get('gt_bboxes', None) is not None:
+            results['gt_bboxes'].translate_([left, top])
+
+        # expand masks
+        if results.get('gt_masks', None) is not None:
+            results['gt_masks'] = results['gt_masks'].expand(
+                int(h * ratio), int(w * ratio), top, left)
+
+        # expand segmentation map
+        if results.get('gt_seg_map', None) is not None:
+            gt_seg = results['gt_seg_map']
+            expand_gt_seg = np.full((int(h * ratio), int(w * ratio)),
+                                    self.seg_ignore_label,
+                                    dtype=gt_seg.dtype)
+            expand_gt_seg[top:top + h, left:left + w] = gt_seg
+            results['gt_seg_map'] = expand_gt_seg
+
+        return results
+
+    def __repr__(self) -> str:
+        repr_str = self.__class__.__name__
+        repr_str += f'(mean={self.mean}, to_rgb={self.to_rgb}, '
+        repr_str += f'ratio_range={self.ratio_range}, '
+        repr_str += f'seg_ignore_label={self.seg_ignore_label}, '
+        repr_str += f'prob={self.prob})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class MinIoURandomCrop(BaseTransform):
+    """Random crop the image & bboxes & masks & segmentation map, the cropped
+    patches have minimum IoU requirement with original image & bboxes & masks.
+
+    & segmentation map, the IoU threshold is randomly selected from min_ious.
+
+
+    Required Keys:
+
+    - img
+    - img_shape
+    - gt_bboxes (BaseBoxes[torch.float32]) (optional)
+    - gt_bboxes_labels (np.int64) (optional)
+    - gt_masks (BitmapMasks | PolygonMasks) (optional)
+    - gt_ignore_flags (bool) (optional)
+    - gt_seg_map (np.uint8) (optional)
+
+    Modified Keys:
+
+    - img
+    - img_shape
+    - gt_bboxes
+    - gt_bboxes_labels
+    - gt_masks
+    - gt_ignore_flags
+    - gt_seg_map
+
+
+    Args:
+        min_ious (Sequence[float]): minimum IoU threshold for all intersections
+            with bounding boxes.
+        min_crop_size (float): minimum crop's size (i.e. h,w := a*h, a*w,
+        where a >= min_crop_size).
+        bbox_clip_border (bool, optional): Whether clip the objects outside
+            the border of the image. Defaults to True.
+    """
+
+    def __init__(self,
+                 min_ious: Sequence[float] = (0.1, 0.3, 0.5, 0.7, 0.9),
+                 min_crop_size: float = 0.3,
+                 bbox_clip_border: bool = True) -> None:
+
+        self.min_ious = min_ious
+        self.sample_mode = (1, *min_ious, 0)
+        self.min_crop_size = min_crop_size
+        self.bbox_clip_border = bbox_clip_border
+
+    @cache_randomness
+    def _random_mode(self) -> Number:
+        return random.choice(self.sample_mode)
+
+    @autocast_box_type()
+    def transform(self, results: dict) -> dict:
+        """Transform function to crop images and bounding boxes with minimum
+        IoU constraint.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Result dict with images and bounding boxes cropped, \
+                'img_shape' key is updated.
+        """
+        assert 'img' in results, '`img` is not found in results'
+        assert 'gt_bboxes' in results, '`gt_bboxes` is not found in results'
+        img = results['img']
+        boxes = results['gt_bboxes']
+        h, w, c = img.shape
+        while True:
+            mode = self._random_mode()
+            self.mode = mode
+            if mode == 1:
+                return results
+
+            min_iou = self.mode
+            for i in range(50):
+                new_w = random.uniform(self.min_crop_size * w, w)
+                new_h = random.uniform(self.min_crop_size * h, h)
+
+                # h / w in [0.5, 2]
+                if new_h / new_w < 0.5 or new_h / new_w > 2:
+                    continue
+
+                left = random.uniform(w - new_w)
+                top = random.uniform(h - new_h)
+
+                patch = np.array(
+                    (int(left), int(top), int(left + new_w), int(top + new_h)))
+                # Line or point crop is not allowed
+                if patch[2] == patch[0] or patch[3] == patch[1]:
+                    continue
+                overlaps = boxes.overlaps(
+                    HorizontalBoxes(patch.reshape(-1, 4).astype(np.float32)),
+                    boxes).numpy().reshape(-1)
+                if len(overlaps) > 0 and overlaps.min() < min_iou:
+                    continue
+
+                # center of boxes should inside the crop img
+                # only adjust boxes and instance masks when the gt is not empty
+                if len(overlaps) > 0:
+                    # adjust boxes
+                    def is_center_of_bboxes_in_patch(boxes, patch):
+                        centers = boxes.centers.numpy()
+                        mask = ((centers[:, 0] > patch[0]) *
+                                (centers[:, 1] > patch[1]) *
+                                (centers[:, 0] < patch[2]) *
+                                (centers[:, 1] < patch[3]))
+                        return mask
+
+                    mask = is_center_of_bboxes_in_patch(boxes, patch)
+                    if not mask.any():
+                        continue
+                    if results.get('gt_bboxes', None) is not None:
+                        boxes = results['gt_bboxes']
+                        mask = is_center_of_bboxes_in_patch(boxes, patch)
+                        boxes = boxes[mask]
+                        boxes.translate_([-patch[0], -patch[1]])
+                        if self.bbox_clip_border:
+                            boxes.clip_(
+                                [patch[3] - patch[1], patch[2] - patch[0]])
+                        results['gt_bboxes'] = boxes
+
+                        # ignore_flags
+                        if results.get('gt_ignore_flags', None) is not None:
+                            results['gt_ignore_flags'] = \
+                                results['gt_ignore_flags'][mask]
+
+                        # labels
+                        if results.get('gt_bboxes_labels', None) is not None:
+                            results['gt_bboxes_labels'] = results[
+                                'gt_bboxes_labels'][mask]
+
+                        # mask fields
+                        if results.get('gt_masks', None) is not None:
+                            results['gt_masks'] = results['gt_masks'][
+                                mask.nonzero()[0]].crop(patch)
+                # adjust the img no matter whether the gt is empty before crop
+                img = img[patch[1]:patch[3], patch[0]:patch[2]]
+                results['img'] = img
+                results['img_shape'] = img.shape[:2]
+
+                # seg fields
+                if results.get('gt_seg_map', None) is not None:
+                    results['gt_seg_map'] = results['gt_seg_map'][
+                        patch[1]:patch[3], patch[0]:patch[2]]
+                return results
+
+    def __repr__(self) -> str:
+        repr_str = self.__class__.__name__
+        repr_str += f'(min_ious={self.min_ious}, '
+        repr_str += f'min_crop_size={self.min_crop_size}, '
+        repr_str += f'bbox_clip_border={self.bbox_clip_border})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class Corrupt(BaseTransform):
+    """Corruption augmentation.
+
+    Corruption transforms implemented based on
+    `imagecorruptions `_.
+
+    Required Keys:
+
+    - img (np.uint8)
+
+
+    Modified Keys:
+
+    - img (np.uint8)
+
+
+    Args:
+        corruption (str): Corruption name.
+        severity (int): The severity of corruption. Defaults to 1.
+    """
+
+    def __init__(self, corruption: str, severity: int = 1) -> None:
+        self.corruption = corruption
+        self.severity = severity
+
+    def transform(self, results: dict) -> dict:
+        """Call function to corrupt image.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Result dict with images corrupted.
+        """
+
+        if corrupt is None:
+            raise RuntimeError('imagecorruptions is not installed')
+        results['img'] = corrupt(
+            results['img'].astype(np.uint8),
+            corruption_name=self.corruption,
+            severity=self.severity)
+        return results
+
+    def __repr__(self) -> str:
+        repr_str = self.__class__.__name__
+        repr_str += f'(corruption={self.corruption}, '
+        repr_str += f'severity={self.severity})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+@avoid_cache_randomness
+class Albu(BaseTransform):
+    """Albumentation augmentation.
+
+    Adds custom transformations from Albumentations library.
+    Please, visit `https://albumentations.readthedocs.io`
+    to get more information.
+
+    Required Keys:
+
+    - img (np.uint8)
+    - gt_bboxes (HorizontalBoxes[torch.float32]) (optional)
+    - gt_masks (BitmapMasks | PolygonMasks) (optional)
+
+    Modified Keys:
+
+    - img (np.uint8)
+    - gt_bboxes (HorizontalBoxes[torch.float32]) (optional)
+    - gt_masks (BitmapMasks | PolygonMasks) (optional)
+    - img_shape (tuple)
+
+    An example of ``transforms`` is as followed:
+
+    .. code-block::
+
+        [
+            dict(
+                type='ShiftScaleRotate',
+                shift_limit=0.0625,
+                scale_limit=0.0,
+                rotate_limit=0,
+                interpolation=1,
+                p=0.5),
+            dict(
+                type='RandomBrightnessContrast',
+                brightness_limit=[0.1, 0.3],
+                contrast_limit=[0.1, 0.3],
+                p=0.2),
+            dict(type='ChannelShuffle', p=0.1),
+            dict(
+                type='OneOf',
+                transforms=[
+                    dict(type='Blur', blur_limit=3, p=1.0),
+                    dict(type='MedianBlur', blur_limit=3, p=1.0)
+                ],
+                p=0.1),
+        ]
+
+    Args:
+        transforms (list[dict]): A list of albu transformations
+        bbox_params (dict, optional): Bbox_params for albumentation `Compose`
+        keymap (dict, optional): Contains
+            {'input key':'albumentation-style key'}
+        skip_img_without_anno (bool): Whether to skip the image if no ann left
+            after aug. Defaults to False.
+    """
+
+    def __init__(self,
+                 transforms: List[dict],
+                 bbox_params: Optional[dict] = None,
+                 keymap: Optional[dict] = None,
+                 skip_img_without_anno: bool = False) -> None:
+        if Compose is None:
+            raise RuntimeError('albumentations is not installed')
+
+        # Args will be modified later, copying it will be safer
+        transforms = copy.deepcopy(transforms)
+        if bbox_params is not None:
+            bbox_params = copy.deepcopy(bbox_params)
+        if keymap is not None:
+            keymap = copy.deepcopy(keymap)
+        self.transforms = transforms
+        self.filter_lost_elements = False
+        self.skip_img_without_anno = skip_img_without_anno
+
+        # A simple workaround to remove masks without boxes
+        if (isinstance(bbox_params, dict) and 'label_fields' in bbox_params
+                and 'filter_lost_elements' in bbox_params):
+            self.filter_lost_elements = True
+            self.origin_label_fields = bbox_params['label_fields']
+            bbox_params['label_fields'] = ['idx_mapper']
+            del bbox_params['filter_lost_elements']
+
+        self.bbox_params = (
+            self.albu_builder(bbox_params) if bbox_params else None)
+        self.aug = Compose([self.albu_builder(t) for t in self.transforms],
+                           bbox_params=self.bbox_params)
+
+        if not keymap:
+            self.keymap_to_albu = {
+                'img': 'image',
+                'gt_masks': 'masks',
+                'gt_bboxes': 'bboxes'
+            }
+        else:
+            self.keymap_to_albu = keymap
+        self.keymap_back = {v: k for k, v in self.keymap_to_albu.items()}
+
+    def albu_builder(self, cfg: dict) -> albumentations:
+        """Import a module from albumentations.
+
+        It inherits some of :func:`build_from_cfg` logic.
+
+        Args:
+            cfg (dict): Config dict. It should at least contain the key "type".
+
+        Returns:
+            obj: The constructed object.
+        """
+
+        assert isinstance(cfg, dict) and 'type' in cfg
+        args = cfg.copy()
+        obj_type = args.pop('type')
+        if is_str(obj_type):
+            if albumentations is None:
+                raise RuntimeError('albumentations is not installed')
+            obj_cls = getattr(albumentations, obj_type)
+        elif inspect.isclass(obj_type):
+            obj_cls = obj_type
+        else:
+            raise TypeError(
+                f'type must be a str or valid type, but got {type(obj_type)}')
+
+        if 'transforms' in args:
+            args['transforms'] = [
+                self.albu_builder(transform)
+                for transform in args['transforms']
+            ]
+
+        return obj_cls(**args)
+
+    @staticmethod
+    def mapper(d: dict, keymap: dict) -> dict:
+        """Dictionary mapper. Renames keys according to keymap provided.
+
+        Args:
+            d (dict): old dict
+            keymap (dict): {'old_key':'new_key'}
+        Returns:
+            dict: new dict.
+        """
+        updated_dict = {}
+        for k, v in zip(d.keys(), d.values()):
+            new_k = keymap.get(k, k)
+            updated_dict[new_k] = d[k]
+        return updated_dict
+
+    @autocast_box_type()
+    def transform(self, results: dict) -> Union[dict, None]:
+        """Transform function of Albu."""
+        # TODO: gt_seg_map is not currently supported
+        # dict to albumentations format
+        results = self.mapper(results, self.keymap_to_albu)
+        results, ori_masks = self._preprocess_results(results)
+        results = self.aug(**results)
+        results = self._postprocess_results(results, ori_masks)
+        if results is None:
+            return None
+        # back to the original format
+        results = self.mapper(results, self.keymap_back)
+        results['img_shape'] = results['img'].shape[:2]
+        return results
+
+    def _preprocess_results(self, results: dict) -> tuple:
+        """Pre-processing results to facilitate the use of Albu."""
+        if 'bboxes' in results:
+            # to list of boxes
+            if not isinstance(results['bboxes'], HorizontalBoxes):
+                raise NotImplementedError(
+                    'Albu only supports horizontal boxes now')
+            bboxes = results['bboxes'].numpy()
+            results['bboxes'] = [x for x in bboxes]
+            # add pseudo-field for filtration
+            if self.filter_lost_elements:
+                results['idx_mapper'] = np.arange(len(results['bboxes']))
+
+        # TODO: Support mask structure in albu
+        ori_masks = None
+        if 'masks' in results:
+            if isinstance(results['masks'], PolygonMasks):
+                raise NotImplementedError(
+                    'Albu only supports BitMap masks now')
+            ori_masks = results['masks']
+            if albumentations.__version__ < '0.5':
+                results['masks'] = results['masks'].masks
+            else:
+                results['masks'] = [mask for mask in results['masks'].masks]
+
+        return results, ori_masks
+
+    def _postprocess_results(
+            self,
+            results: dict,
+            ori_masks: Optional[Union[BitmapMasks,
+                                      PolygonMasks]] = None) -> dict:
+        """Post-processing Albu output."""
+        # albumentations may return np.array or list on different versions
+        if 'gt_bboxes_labels' in results and isinstance(
+                results['gt_bboxes_labels'], list):
+            results['gt_bboxes_labels'] = np.array(
+                results['gt_bboxes_labels'], dtype=np.int64)
+        if 'gt_ignore_flags' in results and isinstance(
+                results['gt_ignore_flags'], list):
+            results['gt_ignore_flags'] = np.array(
+                results['gt_ignore_flags'], dtype=bool)
+
+        if 'bboxes' in results:
+            if isinstance(results['bboxes'], list):
+                results['bboxes'] = np.array(
+                    results['bboxes'], dtype=np.float32)
+            results['bboxes'] = results['bboxes'].reshape(-1, 4)
+            results['bboxes'] = HorizontalBoxes(results['bboxes'])
+
+            # filter label_fields
+            if self.filter_lost_elements:
+
+                for label in self.origin_label_fields:
+                    results[label] = np.array(
+                        [results[label][i] for i in results['idx_mapper']])
+                if 'masks' in results:
+                    assert ori_masks is not None
+                    results['masks'] = np.array(
+                        [results['masks'][i] for i in results['idx_mapper']])
+                    results['masks'] = ori_masks.__class__(
+                        results['masks'],
+                        results['masks'][0].shape[0],
+                        results['masks'][0].shape[1],
+                    )
+                if (not len(results['idx_mapper'])
+                        and self.skip_img_without_anno):
+                    return None
+            elif 'masks' in results:
+                results['masks'] = ori_masks.__class__(results['masks'],
+                                                       ori_masks.height,
+                                                       ori_masks.width)
+
+        return results
+
+    def __repr__(self) -> str:
+        repr_str = self.__class__.__name__ + f'(transforms={self.transforms})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+@avoid_cache_randomness
+class RandomCenterCropPad(BaseTransform):
+    """Random center crop and random around padding for CornerNet.
+
+    This operation generates randomly cropped image from the original image and
+    pads it simultaneously. Different from :class:`RandomCrop`, the output
+    shape may not equal to ``crop_size`` strictly. We choose a random value
+    from ``ratios`` and the output shape could be larger or smaller than
+    ``crop_size``. The padding operation is also different from :class:`Pad`,
+    here we use around padding instead of right-bottom padding.
+
+    The relation between output image (padding image) and original image:
+
+    .. code:: text
+
+                        output image
+
+               +----------------------------+
+               |          padded area       |
+        +------|----------------------------|----------+
+        |      |         cropped area       |          |
+        |      |         +---------------+  |          |
+        |      |         |    .   center |  |          | original image
+        |      |         |        range  |  |          |
+        |      |         +---------------+  |          |
+        +------|----------------------------|----------+
+               |          padded area       |
+               +----------------------------+
+
+    There are 5 main areas in the figure:
+
+    - output image: output image of this operation, also called padding
+      image in following instruction.
+    - original image: input image of this operation.
+    - padded area: non-intersect area of output image and original image.
+    - cropped area: the overlap of output image and original image.
+    - center range: a smaller area where random center chosen from.
+      center range is computed by ``border`` and original image's shape
+      to avoid our random center is too close to original image's border.
+
+    Also this operation act differently in train and test mode, the summary
+    pipeline is listed below.
+
+    Train pipeline:
+
+    1. Choose a ``random_ratio`` from ``ratios``, the shape of padding image
+       will be ``random_ratio * crop_size``.
+    2. Choose a ``random_center`` in center range.
+    3. Generate padding image with center matches the ``random_center``.
+    4. Initialize the padding image with pixel value equals to ``mean``.
+    5. Copy the cropped area to padding image.
+    6. Refine annotations.
+
+    Test pipeline:
+
+    1. Compute output shape according to ``test_pad_mode``.
+    2. Generate padding image with center matches the original image
+       center.
+    3. Initialize the padding image with pixel value equals to ``mean``.
+    4. Copy the ``cropped area`` to padding image.
+
+    Required Keys:
+
+    - img (np.float32)
+    - img_shape (tuple)
+    - gt_bboxes (BaseBoxes[torch.float32]) (optional)
+    - gt_bboxes_labels (np.int64) (optional)
+    - gt_ignore_flags (bool) (optional)
+
+    Modified Keys:
+
+    - img (np.float32)
+    - img_shape (tuple)
+    - gt_bboxes (BaseBoxes[torch.float32]) (optional)
+    - gt_bboxes_labels (np.int64) (optional)
+    - gt_ignore_flags (bool) (optional)
+
+    Args:
+        crop_size (tuple, optional): expected size after crop, final size will
+            computed according to ratio. Requires  (width, height)
+            in train mode, and None in test mode.
+        ratios (tuple, optional): random select a ratio from tuple and crop
+            image to (crop_size[0] * ratio) * (crop_size[1] * ratio).
+            Only available in train mode. Defaults to (0.9, 1.0, 1.1).
+        border (int, optional): max distance from center select area to image
+            border. Only available in train mode. Defaults to 128.
+        mean (sequence, optional): Mean values of 3 channels.
+        std (sequence, optional): Std values of 3 channels.
+        to_rgb (bool, optional): Whether to convert the image from BGR to RGB.
+        test_mode (bool): whether involve random variables in transform.
+            In train mode, crop_size is fixed, center coords and ratio is
+            random selected from predefined lists. In test mode, crop_size
+            is image's original shape, center coords and ratio is fixed.
+            Defaults to False.
+        test_pad_mode (tuple, optional): padding method and padding shape
+            value, only available in test mode. Default is using
+            'logical_or' with 127 as padding shape value.
+
+            - 'logical_or': final_shape = input_shape | padding_shape_value
+            - 'size_divisor': final_shape = int(
+              ceil(input_shape / padding_shape_value) * padding_shape_value)
+
+            Defaults to ('logical_or', 127).
+        test_pad_add_pix (int): Extra padding pixel in test mode.
+            Defaults to 0.
+        bbox_clip_border (bool): Whether clip the objects outside
+            the border of the image. Defaults to True.
+    """
+
+    def __init__(self,
+                 crop_size: Optional[tuple] = None,
+                 ratios: Optional[tuple] = (0.9, 1.0, 1.1),
+                 border: Optional[int] = 128,
+                 mean: Optional[Sequence] = None,
+                 std: Optional[Sequence] = None,
+                 to_rgb: Optional[bool] = None,
+                 test_mode: bool = False,
+                 test_pad_mode: Optional[tuple] = ('logical_or', 127),
+                 test_pad_add_pix: int = 0,
+                 bbox_clip_border: bool = True) -> None:
+        if test_mode:
+            assert crop_size is None, 'crop_size must be None in test mode'
+            assert ratios is None, 'ratios must be None in test mode'
+            assert border is None, 'border must be None in test mode'
+            assert isinstance(test_pad_mode, (list, tuple))
+            assert test_pad_mode[0] in ['logical_or', 'size_divisor']
+        else:
+            assert isinstance(crop_size, (list, tuple))
+            assert crop_size[0] > 0 and crop_size[1] > 0, (
+                'crop_size must > 0 in train mode')
+            assert isinstance(ratios, (list, tuple))
+            assert test_pad_mode is None, (
+                'test_pad_mode must be None in train mode')
+
+        self.crop_size = crop_size
+        self.ratios = ratios
+        self.border = border
+        # We do not set default value to mean, std and to_rgb because these
+        # hyper-parameters are easy to forget but could affect the performance.
+        # Please use the same setting as Normalize for performance assurance.
+        assert mean is not None and std is not None and to_rgb is not None
+        self.to_rgb = to_rgb
+        self.input_mean = mean
+        self.input_std = std
+        if to_rgb:
+            self.mean = mean[::-1]
+            self.std = std[::-1]
+        else:
+            self.mean = mean
+            self.std = std
+        self.test_mode = test_mode
+        self.test_pad_mode = test_pad_mode
+        self.test_pad_add_pix = test_pad_add_pix
+        self.bbox_clip_border = bbox_clip_border
+
+    def _get_border(self, border, size):
+        """Get final border for the target size.
+
+        This function generates a ``final_border`` according to image's shape.
+        The area between ``final_border`` and ``size - final_border`` is the
+        ``center range``. We randomly choose center from the ``center range``
+        to avoid our random center is too close to original image's border.
+        Also ``center range`` should be larger than 0.
+
+        Args:
+            border (int): The initial border, default is 128.
+            size (int): The width or height of original image.
+        Returns:
+            int: The final border.
+        """
+        k = 2 * border / size
+        i = pow(2, np.ceil(np.log2(np.ceil(k))) + (k == int(k)))
+        return border // i
+
+    def _filter_boxes(self, patch, boxes):
+        """Check whether the center of each box is in the patch.
+
+        Args:
+            patch (list[int]): The cropped area, [left, top, right, bottom].
+            boxes (numpy array, (N x 4)): Ground truth boxes.
+
+        Returns:
+            mask (numpy array, (N,)): Each box is inside or outside the patch.
+        """
+        center = boxes.centers.numpy()
+        mask = (center[:, 0] > patch[0]) * (center[:, 1] > patch[1]) * (
+            center[:, 0] < patch[2]) * (
+                center[:, 1] < patch[3])
+        return mask
+
+    def _crop_image_and_paste(self, image, center, size):
+        """Crop image with a given center and size, then paste the cropped
+        image to a blank image with two centers align.
+
+        This function is equivalent to generating a blank image with ``size``
+        as its shape. Then cover it on the original image with two centers (
+        the center of blank image and the random center of original image)
+        aligned. The overlap area is paste from the original image and the
+        outside area is filled with ``mean pixel``.
+
+        Args:
+            image (np array, H x W x C): Original image.
+            center (list[int]): Target crop center coord.
+            size (list[int]): Target crop size. [target_h, target_w]
+
+        Returns:
+            cropped_img (np array, target_h x target_w x C): Cropped image.
+            border (np array, 4): The distance of four border of
+                ``cropped_img`` to the original image area, [top, bottom,
+                left, right]
+            patch (list[int]): The cropped area, [left, top, right, bottom].
+        """
+        center_y, center_x = center
+        target_h, target_w = size
+        img_h, img_w, img_c = image.shape
+
+        x0 = max(0, center_x - target_w // 2)
+        x1 = min(center_x + target_w // 2, img_w)
+        y0 = max(0, center_y - target_h // 2)
+        y1 = min(center_y + target_h // 2, img_h)
+        patch = np.array((int(x0), int(y0), int(x1), int(y1)))
+
+        left, right = center_x - x0, x1 - center_x
+        top, bottom = center_y - y0, y1 - center_y
+
+        cropped_center_y, cropped_center_x = target_h // 2, target_w // 2
+        cropped_img = np.zeros((target_h, target_w, img_c), dtype=image.dtype)
+        for i in range(img_c):
+            cropped_img[:, :, i] += self.mean[i]
+        y_slice = slice(cropped_center_y - top, cropped_center_y + bottom)
+        x_slice = slice(cropped_center_x - left, cropped_center_x + right)
+        cropped_img[y_slice, x_slice, :] = image[y0:y1, x0:x1, :]
+
+        border = np.array([
+            cropped_center_y - top, cropped_center_y + bottom,
+            cropped_center_x - left, cropped_center_x + right
+        ],
+                          dtype=np.float32)
+
+        return cropped_img, border, patch
+
+    def _train_aug(self, results):
+        """Random crop and around padding the original image.
+
+        Args:
+            results (dict): Image infomations in the augment pipeline.
+
+        Returns:
+            results (dict): The updated dict.
+        """
+        img = results['img']
+        h, w, c = img.shape
+        gt_bboxes = results['gt_bboxes']
+        while True:
+            scale = random.choice(self.ratios)
+            new_h = int(self.crop_size[1] * scale)
+            new_w = int(self.crop_size[0] * scale)
+            h_border = self._get_border(self.border, h)
+            w_border = self._get_border(self.border, w)
+
+            for i in range(50):
+                center_x = random.randint(low=w_border, high=w - w_border)
+                center_y = random.randint(low=h_border, high=h - h_border)
+
+                cropped_img, border, patch = self._crop_image_and_paste(
+                    img, [center_y, center_x], [new_h, new_w])
+
+                if len(gt_bboxes) == 0:
+                    results['img'] = cropped_img
+                    results['img_shape'] = cropped_img.shape[:2]
+                    return results
+
+                # if image do not have valid bbox, any crop patch is valid.
+                mask = self._filter_boxes(patch, gt_bboxes)
+                if not mask.any():
+                    continue
+
+                results['img'] = cropped_img
+                results['img_shape'] = cropped_img.shape[:2]
+
+                x0, y0, x1, y1 = patch
+
+                left_w, top_h = center_x - x0, center_y - y0
+                cropped_center_x, cropped_center_y = new_w // 2, new_h // 2
+
+                # crop bboxes accordingly and clip to the image boundary
+                gt_bboxes = gt_bboxes[mask]
+                gt_bboxes.translate_([
+                    cropped_center_x - left_w - x0,
+                    cropped_center_y - top_h - y0
+                ])
+                if self.bbox_clip_border:
+                    gt_bboxes.clip_([new_h, new_w])
+                keep = gt_bboxes.is_inside([new_h, new_w]).numpy()
+                gt_bboxes = gt_bboxes[keep]
+
+                results['gt_bboxes'] = gt_bboxes
+
+                # ignore_flags
+                if results.get('gt_ignore_flags', None) is not None:
+                    gt_ignore_flags = results['gt_ignore_flags'][mask]
+                    results['gt_ignore_flags'] = \
+                        gt_ignore_flags[keep]
+
+                # labels
+                if results.get('gt_bboxes_labels', None) is not None:
+                    gt_labels = results['gt_bboxes_labels'][mask]
+                    results['gt_bboxes_labels'] = gt_labels[keep]
+
+                if 'gt_masks' in results or 'gt_seg_map' in results:
+                    raise NotImplementedError(
+                        'RandomCenterCropPad only supports bbox.')
+
+                return results
+
+    def _test_aug(self, results):
+        """Around padding the original image without cropping.
+
+        The padding mode and value are from ``test_pad_mode``.
+
+        Args:
+            results (dict): Image infomations in the augment pipeline.
+
+        Returns:
+            results (dict): The updated dict.
+        """
+        img = results['img']
+        h, w, c = img.shape
+        if self.test_pad_mode[0] in ['logical_or']:
+            # self.test_pad_add_pix is only used for centernet
+            target_h = (h | self.test_pad_mode[1]) + self.test_pad_add_pix
+            target_w = (w | self.test_pad_mode[1]) + self.test_pad_add_pix
+        elif self.test_pad_mode[0] in ['size_divisor']:
+            divisor = self.test_pad_mode[1]
+            target_h = int(np.ceil(h / divisor)) * divisor
+            target_w = int(np.ceil(w / divisor)) * divisor
+        else:
+            raise NotImplementedError(
+                'RandomCenterCropPad only support two testing pad mode:'
+                'logical-or and size_divisor.')
+
+        cropped_img, border, _ = self._crop_image_and_paste(
+            img, [h // 2, w // 2], [target_h, target_w])
+        results['img'] = cropped_img
+        results['img_shape'] = cropped_img.shape[:2]
+        results['border'] = border
+        return results
+
+    @autocast_box_type()
+    def transform(self, results: dict) -> dict:
+        img = results['img']
+        assert img.dtype == np.float32, (
+            'RandomCenterCropPad needs the input image of dtype np.float32,'
+            ' please set "to_float32=True" in "LoadImageFromFile" pipeline')
+        h, w, c = img.shape
+        assert c == len(self.mean)
+        if self.test_mode:
+            return self._test_aug(results)
+        else:
+            return self._train_aug(results)
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'(crop_size={self.crop_size}, '
+        repr_str += f'ratios={self.ratios}, '
+        repr_str += f'border={self.border}, '
+        repr_str += f'mean={self.input_mean}, '
+        repr_str += f'std={self.input_std}, '
+        repr_str += f'to_rgb={self.to_rgb}, '
+        repr_str += f'test_mode={self.test_mode}, '
+        repr_str += f'test_pad_mode={self.test_pad_mode}, '
+        repr_str += f'bbox_clip_border={self.bbox_clip_border})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class CutOut(BaseTransform):
+    """CutOut operation.
+
+    Randomly drop some regions of image used in
+    `Cutout `_.
+
+    Required Keys:
+
+    - img
+
+    Modified Keys:
+
+    - img
+
+    Args:
+        n_holes (int or tuple[int, int]): Number of regions to be dropped.
+            If it is given as a list, number of holes will be randomly
+            selected from the closed interval [``n_holes[0]``, ``n_holes[1]``].
+        cutout_shape (tuple[int, int] or list[tuple[int, int]], optional):
+            The candidate shape of dropped regions. It can be
+            ``tuple[int, int]`` to use a fixed cutout shape, or
+            ``list[tuple[int, int]]`` to randomly choose shape
+            from the list. Defaults to None.
+        cutout_ratio (tuple[float, float] or list[tuple[float, float]],
+            optional): The candidate ratio of dropped regions. It can be
+            ``tuple[float, float]`` to use a fixed ratio or
+            ``list[tuple[float, float]]`` to randomly choose ratio
+            from the list. Please note that ``cutout_shape`` and
+            ``cutout_ratio`` cannot be both given at the same time.
+            Defaults to None.
+        fill_in (tuple[float, float, float] or tuple[int, int, int]): The value
+            of pixel to fill in the dropped regions. Defaults to (0, 0, 0).
+    """
+
+    def __init__(
+        self,
+        n_holes: Union[int, Tuple[int, int]],
+        cutout_shape: Optional[Union[Tuple[int, int],
+                                     List[Tuple[int, int]]]] = None,
+        cutout_ratio: Optional[Union[Tuple[float, float],
+                                     List[Tuple[float, float]]]] = None,
+        fill_in: Union[Tuple[float, float, float], Tuple[int, int,
+                                                         int]] = (0, 0, 0)
+    ) -> None:
+
+        assert (cutout_shape is None) ^ (cutout_ratio is None), \
+            'Either cutout_shape or cutout_ratio should be specified.'
+        assert (isinstance(cutout_shape, (list, tuple))
+                or isinstance(cutout_ratio, (list, tuple)))
+        if isinstance(n_holes, tuple):
+            assert len(n_holes) == 2 and 0 <= n_holes[0] < n_holes[1]
+        else:
+            n_holes = (n_holes, n_holes)
+        self.n_holes = n_holes
+        self.fill_in = fill_in
+        self.with_ratio = cutout_ratio is not None
+        self.candidates = cutout_ratio if self.with_ratio else cutout_shape
+        if not isinstance(self.candidates, list):
+            self.candidates = [self.candidates]
+
+    @autocast_box_type()
+    def transform(self, results: dict) -> dict:
+        """Call function to drop some regions of image."""
+        h, w, c = results['img'].shape
+        n_holes = np.random.randint(self.n_holes[0], self.n_holes[1] + 1)
+        for _ in range(n_holes):
+            x1 = np.random.randint(0, w)
+            y1 = np.random.randint(0, h)
+            index = np.random.randint(0, len(self.candidates))
+            if not self.with_ratio:
+                cutout_w, cutout_h = self.candidates[index]
+            else:
+                cutout_w = int(self.candidates[index][0] * w)
+                cutout_h = int(self.candidates[index][1] * h)
+
+            x2 = np.clip(x1 + cutout_w, 0, w)
+            y2 = np.clip(y1 + cutout_h, 0, h)
+            results['img'][y1:y2, x1:x2, :] = self.fill_in
+
+        return results
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'(n_holes={self.n_holes}, '
+        repr_str += (f'cutout_ratio={self.candidates}, ' if self.with_ratio
+                     else f'cutout_shape={self.candidates}, ')
+        repr_str += f'fill_in={self.fill_in})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class Mosaic(BaseTransform):
+    """Mosaic augmentation.
+
+    Given 4 images, mosaic transform combines them into
+    one output image. The output image is composed of the parts from each sub-
+    image.
+
+    .. code:: text
+
+                        mosaic transform
+                           center_x
+                +------------------------------+
+                |       pad        |  pad      |
+                |      +-----------+           |
+                |      |           |           |
+                |      |  image1   |--------+  |
+                |      |           |        |  |
+                |      |           | image2 |  |
+     center_y   |----+-------------+-----------|
+                |    |   cropped   |           |
+                |pad |   image3    |  image4   |
+                |    |             |           |
+                +----|-------------+-----------+
+                     |             |
+                     +-------------+
+
+     The mosaic transform steps are as follows:
+
+         1. Choose the mosaic center as the intersections of 4 images
+         2. Get the left top image according to the index, and randomly
+            sample another 3 images from the custom dataset.
+         3. Sub image will be cropped if image is larger than mosaic patch
+
+    Required Keys:
+
+    - img
+    - gt_bboxes (BaseBoxes[torch.float32]) (optional)
+    - gt_bboxes_labels (np.int64) (optional)
+    - gt_ignore_flags (bool) (optional)
+    - mix_results (List[dict])
+
+    Modified Keys:
+
+    - img
+    - img_shape
+    - gt_bboxes (optional)
+    - gt_bboxes_labels (optional)
+    - gt_ignore_flags (optional)
+
+    Args:
+        img_scale (Sequence[int]): Image size before mosaic pipeline of single
+            image. The shape order should be (width, height).
+            Defaults to (640, 640).
+        center_ratio_range (Sequence[float]): Center ratio range of mosaic
+            output. Defaults to (0.5, 1.5).
+        bbox_clip_border (bool, optional): Whether to clip the objects outside
+            the border of the image. In some dataset like MOT17, the gt bboxes
+            are allowed to cross the border of images. Therefore, we don't
+            need to clip the gt bboxes in these cases. Defaults to True.
+        pad_val (int): Pad value. Defaults to 114.
+        prob (float): Probability of applying this transformation.
+            Defaults to 1.0.
+    """
+
+    def __init__(self,
+                 img_scale: Tuple[int, int] = (640, 640),
+                 center_ratio_range: Tuple[float, float] = (0.5, 1.5),
+                 bbox_clip_border: bool = True,
+                 pad_val: float = 114.0,
+                 prob: float = 1.0) -> None:
+        assert isinstance(img_scale, tuple)
+        assert 0 <= prob <= 1.0, 'The probability should be in range [0,1]. ' \
+                                 f'got {prob}.'
+
+        log_img_scale(img_scale, skip_square=True, shape_order='wh')
+        self.img_scale = img_scale
+        self.center_ratio_range = center_ratio_range
+        self.bbox_clip_border = bbox_clip_border
+        self.pad_val = pad_val
+        self.prob = prob
+
+    @cache_randomness
+    def get_indexes(self, dataset: BaseDataset) -> int:
+        """Call function to collect indexes.
+
+        Args:
+            dataset (:obj:`MultiImageMixDataset`): The dataset.
+
+        Returns:
+            list: indexes.
+        """
+
+        indexes = [random.randint(0, len(dataset)) for _ in range(3)]
+        return indexes
+
+    @autocast_box_type()
+    def transform(self, results: dict) -> dict:
+        """Mosaic transform function.
+
+        Args:
+            results (dict): Result dict.
+
+        Returns:
+            dict: Updated result dict.
+        """
+        if random.uniform(0, 1) > self.prob:
+            return results
+
+        assert 'mix_results' in results
+        mosaic_bboxes = []
+        mosaic_bboxes_labels = []
+        mosaic_ignore_flags = []
+        if len(results['img'].shape) == 3:
+            mosaic_img = np.full(
+                (int(self.img_scale[1] * 2), int(self.img_scale[0] * 2), 3),
+                self.pad_val,
+                dtype=results['img'].dtype)
+        else:
+            mosaic_img = np.full(
+                (int(self.img_scale[1] * 2), int(self.img_scale[0] * 2)),
+                self.pad_val,
+                dtype=results['img'].dtype)
+
+        # mosaic center x, y
+        center_x = int(
+            random.uniform(*self.center_ratio_range) * self.img_scale[0])
+        center_y = int(
+            random.uniform(*self.center_ratio_range) * self.img_scale[1])
+        center_position = (center_x, center_y)
+
+        loc_strs = ('top_left', 'top_right', 'bottom_left', 'bottom_right')
+        for i, loc in enumerate(loc_strs):
+            if loc == 'top_left':
+                results_patch = copy.deepcopy(results)
+            else:
+                results_patch = copy.deepcopy(results['mix_results'][i - 1])
+
+            img_i = results_patch['img']
+            h_i, w_i = img_i.shape[:2]
+            # keep_ratio resize
+            scale_ratio_i = min(self.img_scale[1] / h_i,
+                                self.img_scale[0] / w_i)
+            img_i = mmcv.imresize(
+                img_i, (int(w_i * scale_ratio_i), int(h_i * scale_ratio_i)))
+
+            # compute the combine parameters
+            paste_coord, crop_coord = self._mosaic_combine(
+                loc, center_position, img_i.shape[:2][::-1])
+            x1_p, y1_p, x2_p, y2_p = paste_coord
+            x1_c, y1_c, x2_c, y2_c = crop_coord
+
+            # crop and paste image
+            mosaic_img[y1_p:y2_p, x1_p:x2_p] = img_i[y1_c:y2_c, x1_c:x2_c]
+
+            # adjust coordinate
+            gt_bboxes_i = results_patch['gt_bboxes']
+            gt_bboxes_labels_i = results_patch['gt_bboxes_labels']
+            gt_ignore_flags_i = results_patch['gt_ignore_flags']
+
+            padw = x1_p - x1_c
+            padh = y1_p - y1_c
+            gt_bboxes_i.rescale_([scale_ratio_i, scale_ratio_i])
+            gt_bboxes_i.translate_([padw, padh])
+            mosaic_bboxes.append(gt_bboxes_i)
+            mosaic_bboxes_labels.append(gt_bboxes_labels_i)
+            mosaic_ignore_flags.append(gt_ignore_flags_i)
+
+        mosaic_bboxes = mosaic_bboxes[0].cat(mosaic_bboxes, 0)
+        mosaic_bboxes_labels = np.concatenate(mosaic_bboxes_labels, 0)
+        mosaic_ignore_flags = np.concatenate(mosaic_ignore_flags, 0)
+
+        if self.bbox_clip_border:
+            mosaic_bboxes.clip_([2 * self.img_scale[1], 2 * self.img_scale[0]])
+        # remove outside bboxes
+        inside_inds = mosaic_bboxes.is_inside(
+            [2 * self.img_scale[1], 2 * self.img_scale[0]]).numpy()
+        mosaic_bboxes = mosaic_bboxes[inside_inds]
+        mosaic_bboxes_labels = mosaic_bboxes_labels[inside_inds]
+        mosaic_ignore_flags = mosaic_ignore_flags[inside_inds]
+
+        results['img'] = mosaic_img
+        results['img_shape'] = mosaic_img.shape[:2]
+        results['gt_bboxes'] = mosaic_bboxes
+        results['gt_bboxes_labels'] = mosaic_bboxes_labels
+        results['gt_ignore_flags'] = mosaic_ignore_flags
+        return results
+
+    def _mosaic_combine(
+            self, loc: str, center_position_xy: Sequence[float],
+            img_shape_wh: Sequence[int]) -> Tuple[Tuple[int], Tuple[int]]:
+        """Calculate global coordinate of mosaic image and local coordinate of
+        cropped sub-image.
+
+        Args:
+            loc (str): Index for the sub-image, loc in ('top_left',
+              'top_right', 'bottom_left', 'bottom_right').
+            center_position_xy (Sequence[float]): Mixing center for 4 images,
+                (x, y).
+            img_shape_wh (Sequence[int]): Width and height of sub-image
+
+        Returns:
+            tuple[tuple[float]]: Corresponding coordinate of pasting and
+                cropping
+                - paste_coord (tuple): paste corner coordinate in mosaic image.
+                - crop_coord (tuple): crop corner coordinate in mosaic image.
+        """
+        assert loc in ('top_left', 'top_right', 'bottom_left', 'bottom_right')
+        if loc == 'top_left':
+            # index0 to top left part of image
+            x1, y1, x2, y2 = max(center_position_xy[0] - img_shape_wh[0], 0), \
+                             max(center_position_xy[1] - img_shape_wh[1], 0), \
+                             center_position_xy[0], \
+                             center_position_xy[1]
+            crop_coord = img_shape_wh[0] - (x2 - x1), img_shape_wh[1] - (
+                y2 - y1), img_shape_wh[0], img_shape_wh[1]
+
+        elif loc == 'top_right':
+            # index1 to top right part of image
+            x1, y1, x2, y2 = center_position_xy[0], \
+                             max(center_position_xy[1] - img_shape_wh[1], 0), \
+                             min(center_position_xy[0] + img_shape_wh[0],
+                                 self.img_scale[0] * 2), \
+                             center_position_xy[1]
+            crop_coord = 0, img_shape_wh[1] - (y2 - y1), min(
+                img_shape_wh[0], x2 - x1), img_shape_wh[1]
+
+        elif loc == 'bottom_left':
+            # index2 to bottom left part of image
+            x1, y1, x2, y2 = max(center_position_xy[0] - img_shape_wh[0], 0), \
+                             center_position_xy[1], \
+                             center_position_xy[0], \
+                             min(self.img_scale[1] * 2, center_position_xy[1] +
+                                 img_shape_wh[1])
+            crop_coord = img_shape_wh[0] - (x2 - x1), 0, img_shape_wh[0], min(
+                y2 - y1, img_shape_wh[1])
+
+        else:
+            # index3 to bottom right part of image
+            x1, y1, x2, y2 = center_position_xy[0], \
+                             center_position_xy[1], \
+                             min(center_position_xy[0] + img_shape_wh[0],
+                                 self.img_scale[0] * 2), \
+                             min(self.img_scale[1] * 2, center_position_xy[1] +
+                                 img_shape_wh[1])
+            crop_coord = 0, 0, min(img_shape_wh[0],
+                                   x2 - x1), min(y2 - y1, img_shape_wh[1])
+
+        paste_coord = x1, y1, x2, y2
+        return paste_coord, crop_coord
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'(img_scale={self.img_scale}, '
+        repr_str += f'center_ratio_range={self.center_ratio_range}, '
+        repr_str += f'pad_val={self.pad_val}, '
+        repr_str += f'prob={self.prob})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class MixUp(BaseTransform):
+    """MixUp data augmentation.
+
+    .. code:: text
+
+                         mixup transform
+                +------------------------------+
+                | mixup image   |              |
+                |      +--------|--------+     |
+                |      |        |        |     |
+                |---------------+        |     |
+                |      |                 |     |
+                |      |      image      |     |
+                |      |                 |     |
+                |      |                 |     |
+                |      |-----------------+     |
+                |             pad              |
+                +------------------------------+
+
+     The mixup transform steps are as follows:
+
+        1. Another random image is picked by dataset and embedded in
+           the top left patch(after padding and resizing)
+        2. The target of mixup transform is the weighted average of mixup
+           image and origin image.
+
+    Required Keys:
+
+    - img
+    - gt_bboxes (BaseBoxes[torch.float32]) (optional)
+    - gt_bboxes_labels (np.int64) (optional)
+    - gt_ignore_flags (bool) (optional)
+    - mix_results (List[dict])
+
+
+    Modified Keys:
+
+    - img
+    - img_shape
+    - gt_bboxes (optional)
+    - gt_bboxes_labels (optional)
+    - gt_ignore_flags (optional)
+
+
+    Args:
+        img_scale (Sequence[int]): Image output size after mixup pipeline.
+            The shape order should be (width, height). Defaults to (640, 640).
+        ratio_range (Sequence[float]): Scale ratio of mixup image.
+            Defaults to (0.5, 1.5).
+        flip_ratio (float): Horizontal flip ratio of mixup image.
+            Defaults to 0.5.
+        pad_val (int): Pad value. Defaults to 114.
+        max_iters (int): The maximum number of iterations. If the number of
+            iterations is greater than `max_iters`, but gt_bbox is still
+            empty, then the iteration is terminated. Defaults to 15.
+        bbox_clip_border (bool, optional): Whether to clip the objects outside
+            the border of the image. In some dataset like MOT17, the gt bboxes
+            are allowed to cross the border of images. Therefore, we don't
+            need to clip the gt bboxes in these cases. Defaults to True.
+    """
+
+    def __init__(self,
+                 img_scale: Tuple[int, int] = (640, 640),
+                 ratio_range: Tuple[float, float] = (0.5, 1.5),
+                 flip_ratio: float = 0.5,
+                 pad_val: float = 114.0,
+                 max_iters: int = 15,
+                 bbox_clip_border: bool = True) -> None:
+        assert isinstance(img_scale, tuple)
+        log_img_scale(img_scale, skip_square=True, shape_order='wh')
+        self.dynamic_scale = img_scale
+        self.ratio_range = ratio_range
+        self.flip_ratio = flip_ratio
+        self.pad_val = pad_val
+        self.max_iters = max_iters
+        self.bbox_clip_border = bbox_clip_border
+
+    @cache_randomness
+    def get_indexes(self, dataset: BaseDataset) -> int:
+        """Call function to collect indexes.
+
+        Args:
+            dataset (:obj:`MultiImageMixDataset`): The dataset.
+
+        Returns:
+            list: indexes.
+        """
+
+        for i in range(self.max_iters):
+            index = random.randint(0, len(dataset))
+            gt_bboxes_i = dataset[index]['gt_bboxes']
+            if len(gt_bboxes_i) != 0:
+                break
+
+        return index
+
+    @autocast_box_type()
+    def transform(self, results: dict) -> dict:
+        """MixUp transform function.
+
+        Args:
+            results (dict): Result dict.
+
+        Returns:
+            dict: Updated result dict.
+        """
+
+        assert 'mix_results' in results
+        assert len(
+            results['mix_results']) == 1, 'MixUp only support 2 images now !'
+
+        if results['mix_results'][0]['gt_bboxes'].shape[0] == 0:
+            # empty bbox
+            return results
+
+        retrieve_results = results['mix_results'][0]
+        retrieve_img = retrieve_results['img']
+
+        jit_factor = random.uniform(*self.ratio_range)
+        is_flip = random.uniform(0, 1) > self.flip_ratio
+
+        if len(retrieve_img.shape) == 3:
+            out_img = np.ones(
+                (self.dynamic_scale[1], self.dynamic_scale[0], 3),
+                dtype=retrieve_img.dtype) * self.pad_val
+        else:
+            out_img = np.ones(
+                self.dynamic_scale[::-1],
+                dtype=retrieve_img.dtype) * self.pad_val
+
+        # 1. keep_ratio resize
+        scale_ratio = min(self.dynamic_scale[1] / retrieve_img.shape[0],
+                          self.dynamic_scale[0] / retrieve_img.shape[1])
+        retrieve_img = mmcv.imresize(
+            retrieve_img, (int(retrieve_img.shape[1] * scale_ratio),
+                           int(retrieve_img.shape[0] * scale_ratio)))
+
+        # 2. paste
+        out_img[:retrieve_img.shape[0], :retrieve_img.shape[1]] = retrieve_img
+
+        # 3. scale jit
+        scale_ratio *= jit_factor
+        out_img = mmcv.imresize(out_img, (int(out_img.shape[1] * jit_factor),
+                                          int(out_img.shape[0] * jit_factor)))
+
+        # 4. flip
+        if is_flip:
+            out_img = out_img[:, ::-1, :]
+
+        # 5. random crop
+        ori_img = results['img']
+        origin_h, origin_w = out_img.shape[:2]
+        target_h, target_w = ori_img.shape[:2]
+        padded_img = np.ones((max(origin_h, target_h), max(
+            origin_w, target_w), 3)) * self.pad_val
+        padded_img = padded_img.astype(np.uint8)
+        padded_img[:origin_h, :origin_w] = out_img
+
+        x_offset, y_offset = 0, 0
+        if padded_img.shape[0] > target_h:
+            y_offset = random.randint(0, padded_img.shape[0] - target_h)
+        if padded_img.shape[1] > target_w:
+            x_offset = random.randint(0, padded_img.shape[1] - target_w)
+        padded_cropped_img = padded_img[y_offset:y_offset + target_h,
+                                        x_offset:x_offset + target_w]
+
+        # 6. adjust bbox
+        retrieve_gt_bboxes = retrieve_results['gt_bboxes']
+        retrieve_gt_bboxes.rescale_([scale_ratio, scale_ratio])
+        if self.bbox_clip_border:
+            retrieve_gt_bboxes.clip_([origin_h, origin_w])
+
+        if is_flip:
+            retrieve_gt_bboxes.flip_([origin_h, origin_w],
+                                     direction='horizontal')
+
+        # 7. filter
+        cp_retrieve_gt_bboxes = retrieve_gt_bboxes.clone()
+        cp_retrieve_gt_bboxes.translate_([-x_offset, -y_offset])
+        if self.bbox_clip_border:
+            cp_retrieve_gt_bboxes.clip_([target_h, target_w])
+
+        # 8. mix up
+        ori_img = ori_img.astype(np.float32)
+        mixup_img = 0.5 * ori_img + 0.5 * padded_cropped_img.astype(np.float32)
+
+        retrieve_gt_bboxes_labels = retrieve_results['gt_bboxes_labels']
+        retrieve_gt_ignore_flags = retrieve_results['gt_ignore_flags']
+
+        mixup_gt_bboxes = cp_retrieve_gt_bboxes.cat(
+            (results['gt_bboxes'], cp_retrieve_gt_bboxes), dim=0)
+        mixup_gt_bboxes_labels = np.concatenate(
+            (results['gt_bboxes_labels'], retrieve_gt_bboxes_labels), axis=0)
+        mixup_gt_ignore_flags = np.concatenate(
+            (results['gt_ignore_flags'], retrieve_gt_ignore_flags), axis=0)
+
+        # remove outside bbox
+        inside_inds = mixup_gt_bboxes.is_inside([target_h, target_w]).numpy()
+        mixup_gt_bboxes = mixup_gt_bboxes[inside_inds]
+        mixup_gt_bboxes_labels = mixup_gt_bboxes_labels[inside_inds]
+        mixup_gt_ignore_flags = mixup_gt_ignore_flags[inside_inds]
+
+        results['img'] = mixup_img.astype(np.uint8)
+        results['img_shape'] = mixup_img.shape[:2]
+        results['gt_bboxes'] = mixup_gt_bboxes
+        results['gt_bboxes_labels'] = mixup_gt_bboxes_labels
+        results['gt_ignore_flags'] = mixup_gt_ignore_flags
+
+        return results
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'(dynamic_scale={self.dynamic_scale}, '
+        repr_str += f'ratio_range={self.ratio_range}, '
+        repr_str += f'flip_ratio={self.flip_ratio}, '
+        repr_str += f'pad_val={self.pad_val}, '
+        repr_str += f'max_iters={self.max_iters}, '
+        repr_str += f'bbox_clip_border={self.bbox_clip_border})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class RandomAffine(BaseTransform):
+    """Random affine transform data augmentation.
+
+    This operation randomly generates affine transform matrix which including
+    rotation, translation, shear and scaling transforms.
+
+    Required Keys:
+
+    - img
+    - gt_bboxes (BaseBoxes[torch.float32]) (optional)
+    - gt_bboxes_labels (np.int64) (optional)
+    - gt_ignore_flags (bool) (optional)
+
+    Modified Keys:
+
+    - img
+    - img_shape
+    - gt_bboxes (optional)
+    - gt_bboxes_labels (optional)
+    - gt_ignore_flags (optional)
+
+    Args:
+        max_rotate_degree (float): Maximum degrees of rotation transform.
+            Defaults to 10.
+        max_translate_ratio (float): Maximum ratio of translation.
+            Defaults to 0.1.
+        scaling_ratio_range (tuple[float]): Min and max ratio of
+            scaling transform. Defaults to (0.5, 1.5).
+        max_shear_degree (float): Maximum degrees of shear
+            transform. Defaults to 2.
+        border (tuple[int]): Distance from width and height sides of input
+            image to adjust output shape. Only used in mosaic dataset.
+            Defaults to (0, 0).
+        border_val (tuple[int]): Border padding values of 3 channels.
+            Defaults to (114, 114, 114).
+        bbox_clip_border (bool, optional): Whether to clip the objects outside
+            the border of the image. In some dataset like MOT17, the gt bboxes
+            are allowed to cross the border of images. Therefore, we don't
+            need to clip the gt bboxes in these cases. Defaults to True.
+    """
+
+    def __init__(self,
+                 max_rotate_degree: float = 10.0,
+                 max_translate_ratio: float = 0.1,
+                 scaling_ratio_range: Tuple[float, float] = (0.5, 1.5),
+                 max_shear_degree: float = 2.0,
+                 border: Tuple[int, int] = (0, 0),
+                 border_val: Tuple[int, int, int] = (114, 114, 114),
+                 bbox_clip_border: bool = True) -> None:
+        assert 0 <= max_translate_ratio <= 1
+        assert scaling_ratio_range[0] <= scaling_ratio_range[1]
+        assert scaling_ratio_range[0] > 0
+        self.max_rotate_degree = max_rotate_degree
+        self.max_translate_ratio = max_translate_ratio
+        self.scaling_ratio_range = scaling_ratio_range
+        self.max_shear_degree = max_shear_degree
+        self.border = border
+        self.border_val = border_val
+        self.bbox_clip_border = bbox_clip_border
+
+    @cache_randomness
+    def _get_random_homography_matrix(self, height, width):
+        # Rotation
+        rotation_degree = random.uniform(-self.max_rotate_degree,
+                                         self.max_rotate_degree)
+        rotation_matrix = self._get_rotation_matrix(rotation_degree)
+
+        # Scaling
+        scaling_ratio = random.uniform(self.scaling_ratio_range[0],
+                                       self.scaling_ratio_range[1])
+        scaling_matrix = self._get_scaling_matrix(scaling_ratio)
+
+        # Shear
+        x_degree = random.uniform(-self.max_shear_degree,
+                                  self.max_shear_degree)
+        y_degree = random.uniform(-self.max_shear_degree,
+                                  self.max_shear_degree)
+        shear_matrix = self._get_shear_matrix(x_degree, y_degree)
+
+        # Translation
+        trans_x = random.uniform(-self.max_translate_ratio,
+                                 self.max_translate_ratio) * width
+        trans_y = random.uniform(-self.max_translate_ratio,
+                                 self.max_translate_ratio) * height
+        translate_matrix = self._get_translation_matrix(trans_x, trans_y)
+
+        warp_matrix = (
+            translate_matrix @ shear_matrix @ rotation_matrix @ scaling_matrix)
+        return warp_matrix
+
+    @autocast_box_type()
+    def transform(self, results: dict) -> dict:
+        img = results['img']
+        height = img.shape[0] + self.border[1] * 2
+        width = img.shape[1] + self.border[0] * 2
+
+        warp_matrix = self._get_random_homography_matrix(height, width)
+
+        img = cv2.warpPerspective(
+            img,
+            warp_matrix,
+            dsize=(width, height),
+            borderValue=self.border_val)
+        results['img'] = img
+        results['img_shape'] = img.shape[:2]
+
+        bboxes = results['gt_bboxes']
+        num_bboxes = len(bboxes)
+        if num_bboxes:
+            bboxes.project_(warp_matrix)
+            if self.bbox_clip_border:
+                bboxes.clip_([height, width])
+            # remove outside bbox
+            valid_index = bboxes.is_inside([height, width]).numpy()
+            results['gt_bboxes'] = bboxes[valid_index]
+            results['gt_bboxes_labels'] = results['gt_bboxes_labels'][
+                valid_index]
+            results['gt_ignore_flags'] = results['gt_ignore_flags'][
+                valid_index]
+
+            if 'gt_masks' in results:
+                raise NotImplementedError('RandomAffine only supports bbox.')
+        return results
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'(max_rotate_degree={self.max_rotate_degree}, '
+        repr_str += f'max_translate_ratio={self.max_translate_ratio}, '
+        repr_str += f'scaling_ratio_range={self.scaling_ratio_range}, '
+        repr_str += f'max_shear_degree={self.max_shear_degree}, '
+        repr_str += f'border={self.border}, '
+        repr_str += f'border_val={self.border_val}, '
+        repr_str += f'bbox_clip_border={self.bbox_clip_border})'
+        return repr_str
+
+    @staticmethod
+    def _get_rotation_matrix(rotate_degrees: float) -> np.ndarray:
+        radian = math.radians(rotate_degrees)
+        rotation_matrix = np.array(
+            [[np.cos(radian), -np.sin(radian), 0.],
+             [np.sin(radian), np.cos(radian), 0.], [0., 0., 1.]],
+            dtype=np.float32)
+        return rotation_matrix
+
+    @staticmethod
+    def _get_scaling_matrix(scale_ratio: float) -> np.ndarray:
+        scaling_matrix = np.array(
+            [[scale_ratio, 0., 0.], [0., scale_ratio, 0.], [0., 0., 1.]],
+            dtype=np.float32)
+        return scaling_matrix
+
+    @staticmethod
+    def _get_shear_matrix(x_shear_degrees: float,
+                          y_shear_degrees: float) -> np.ndarray:
+        x_radian = math.radians(x_shear_degrees)
+        y_radian = math.radians(y_shear_degrees)
+        shear_matrix = np.array([[1, np.tan(x_radian), 0.],
+                                 [np.tan(y_radian), 1, 0.], [0., 0., 1.]],
+                                dtype=np.float32)
+        return shear_matrix
+
+    @staticmethod
+    def _get_translation_matrix(x: float, y: float) -> np.ndarray:
+        translation_matrix = np.array([[1, 0., x], [0., 1, y], [0., 0., 1.]],
+                                      dtype=np.float32)
+        return translation_matrix
+
+
+@TRANSFORMS.register_module()
+class YOLOXHSVRandomAug(BaseTransform):
+    """Apply HSV augmentation to image sequentially. It is referenced from
+    https://github.com/Megvii-
+    BaseDetection/YOLOX/blob/main/yolox/data/data_augment.py#L21.
+
+    Required Keys:
+
+    - img
+
+    Modified Keys:
+
+    - img
+
+    Args:
+        hue_delta (int): delta of hue. Defaults to 5.
+        saturation_delta (int): delta of saturation. Defaults to 30.
+        value_delta (int): delat of value. Defaults to 30.
+    """
+
+    def __init__(self,
+                 hue_delta: int = 5,
+                 saturation_delta: int = 30,
+                 value_delta: int = 30) -> None:
+        self.hue_delta = hue_delta
+        self.saturation_delta = saturation_delta
+        self.value_delta = value_delta
+
+    @cache_randomness
+    def _get_hsv_gains(self):
+        hsv_gains = np.random.uniform(-1, 1, 3) * [
+            self.hue_delta, self.saturation_delta, self.value_delta
+        ]
+        # random selection of h, s, v
+        hsv_gains *= np.random.randint(0, 2, 3)
+        # prevent overflow
+        hsv_gains = hsv_gains.astype(np.int16)
+        return hsv_gains
+
+    def transform(self, results: dict) -> dict:
+        img = results['img']
+        hsv_gains = self._get_hsv_gains()
+        img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV).astype(np.int16)
+
+        img_hsv[..., 0] = (img_hsv[..., 0] + hsv_gains[0]) % 180
+        img_hsv[..., 1] = np.clip(img_hsv[..., 1] + hsv_gains[1], 0, 255)
+        img_hsv[..., 2] = np.clip(img_hsv[..., 2] + hsv_gains[2], 0, 255)
+        cv2.cvtColor(img_hsv.astype(img.dtype), cv2.COLOR_HSV2BGR, dst=img)
+
+        results['img'] = img
+        return results
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'(hue_delta={self.hue_delta}, '
+        repr_str += f'saturation_delta={self.saturation_delta}, '
+        repr_str += f'value_delta={self.value_delta})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class CopyPaste(BaseTransform):
+    """Simple Copy-Paste is a Strong Data Augmentation Method for Instance
+    Segmentation The simple copy-paste transform steps are as follows:
+
+    1. The destination image is already resized with aspect ratio kept,
+       cropped and padded.
+    2. Randomly select a source image, which is also already resized
+       with aspect ratio kept, cropped and padded in a similar way
+       as the destination image.
+    3. Randomly select some objects from the source image.
+    4. Paste these source objects to the destination image directly,
+       due to the source and destination image have the same size.
+    5. Update object masks of the destination image, for some origin objects
+       may be occluded.
+    6. Generate bboxes from the updated destination masks and
+       filter some objects which are totally occluded, and adjust bboxes
+       which are partly occluded.
+    7. Append selected source bboxes, masks, and labels.
+
+    Required Keys:
+
+    - img
+    - gt_bboxes (BaseBoxes[torch.float32]) (optional)
+    - gt_bboxes_labels (np.int64) (optional)
+    - gt_ignore_flags (bool) (optional)
+    - gt_masks (BitmapMasks) (optional)
+
+    Modified Keys:
+
+    - img
+    - gt_bboxes (optional)
+    - gt_bboxes_labels (optional)
+    - gt_ignore_flags (optional)
+    - gt_masks (optional)
+
+    Args:
+        max_num_pasted (int): The maximum number of pasted objects.
+            Defaults to 100.
+        bbox_occluded_thr (int): The threshold of occluded bbox.
+            Defaults to 10.
+        mask_occluded_thr (int): The threshold of occluded mask.
+            Defaults to 300.
+        selected (bool): Whether select objects or not. If select is False,
+            all objects of the source image will be pasted to the
+            destination image.
+            Defaults to True.
+        paste_by_box (bool): Whether use boxes as masks when masks are not
+            available.
+            Defaults to False.
+    """
+
+    def __init__(
+        self,
+        max_num_pasted: int = 100,
+        bbox_occluded_thr: int = 10,
+        mask_occluded_thr: int = 300,
+        selected: bool = True,
+        paste_by_box: bool = False,
+    ) -> None:
+        self.max_num_pasted = max_num_pasted
+        self.bbox_occluded_thr = bbox_occluded_thr
+        self.mask_occluded_thr = mask_occluded_thr
+        self.selected = selected
+        self.paste_by_box = paste_by_box
+
+    @cache_randomness
+    def get_indexes(self, dataset: BaseDataset) -> int:
+        """Call function to collect indexes.s.
+
+        Args:
+            dataset (:obj:`MultiImageMixDataset`): The dataset.
+        Returns:
+            list: Indexes.
+        """
+        return random.randint(0, len(dataset))
+
+    @autocast_box_type()
+    def transform(self, results: dict) -> dict:
+        """Transform function to make a copy-paste of image.
+
+        Args:
+            results (dict): Result dict.
+        Returns:
+            dict: Result dict with copy-paste transformed.
+        """
+
+        assert 'mix_results' in results
+        num_images = len(results['mix_results'])
+        assert num_images == 1, \
+            f'CopyPaste only supports processing 2 images, got {num_images}'
+        if self.selected:
+            selected_results = self._select_object(results['mix_results'][0])
+        else:
+            selected_results = results['mix_results'][0]
+        return self._copy_paste(results, selected_results)
+
+    @cache_randomness
+    def _get_selected_inds(self, num_bboxes: int) -> np.ndarray:
+        max_num_pasted = min(num_bboxes + 1, self.max_num_pasted)
+        num_pasted = np.random.randint(0, max_num_pasted)
+        return np.random.choice(num_bboxes, size=num_pasted, replace=False)
+
+    def get_gt_masks(self, results: dict) -> BitmapMasks:
+        """Get gt_masks originally or generated based on bboxes.
+
+        If gt_masks is not contained in results,
+        it will be generated based on gt_bboxes.
+        Args:
+            results (dict): Result dict.
+        Returns:
+            BitmapMasks: gt_masks, originally or generated based on bboxes.
+        """
+        if results.get('gt_masks', None) is not None:
+            if self.paste_by_box:
+                warnings.warn('gt_masks is already contained in results, '
+                              'so paste_by_box is disabled.')
+            return results['gt_masks']
+        else:
+            if not self.paste_by_box:
+                raise RuntimeError('results does not contain masks.')
+            return results['gt_bboxes'].create_masks(results['img'].shape[:2])
+
+    def _select_object(self, results: dict) -> dict:
+        """Select some objects from the source results."""
+        bboxes = results['gt_bboxes']
+        labels = results['gt_bboxes_labels']
+        masks = self.get_gt_masks(results)
+        ignore_flags = results['gt_ignore_flags']
+
+        selected_inds = self._get_selected_inds(bboxes.shape[0])
+
+        selected_bboxes = bboxes[selected_inds]
+        selected_labels = labels[selected_inds]
+        selected_masks = masks[selected_inds]
+        selected_ignore_flags = ignore_flags[selected_inds]
+
+        results['gt_bboxes'] = selected_bboxes
+        results['gt_bboxes_labels'] = selected_labels
+        results['gt_masks'] = selected_masks
+        results['gt_ignore_flags'] = selected_ignore_flags
+        return results
+
+    def _copy_paste(self, dst_results: dict, src_results: dict) -> dict:
+        """CopyPaste transform function.
+
+        Args:
+            dst_results (dict): Result dict of the destination image.
+            src_results (dict): Result dict of the source image.
+        Returns:
+            dict: Updated result dict.
+        """
+        dst_img = dst_results['img']
+        dst_bboxes = dst_results['gt_bboxes']
+        dst_labels = dst_results['gt_bboxes_labels']
+        dst_masks = self.get_gt_masks(dst_results)
+        dst_ignore_flags = dst_results['gt_ignore_flags']
+
+        src_img = src_results['img']
+        src_bboxes = src_results['gt_bboxes']
+        src_labels = src_results['gt_bboxes_labels']
+        src_masks = src_results['gt_masks']
+        src_ignore_flags = src_results['gt_ignore_flags']
+
+        if len(src_bboxes) == 0:
+            return dst_results
+
+        # update masks and generate bboxes from updated masks
+        composed_mask = np.where(np.any(src_masks.masks, axis=0), 1, 0)
+        updated_dst_masks = self._get_updated_masks(dst_masks, composed_mask)
+        updated_dst_bboxes = updated_dst_masks.get_bboxes(type(dst_bboxes))
+        assert len(updated_dst_bboxes) == len(updated_dst_masks)
+
+        # filter totally occluded objects
+        l1_distance = (updated_dst_bboxes.tensor - dst_bboxes.tensor).abs()
+        bboxes_inds = (l1_distance <= self.bbox_occluded_thr).all(
+            dim=-1).numpy()
+        masks_inds = updated_dst_masks.masks.sum(
+            axis=(1, 2)) > self.mask_occluded_thr
+        valid_inds = bboxes_inds | masks_inds
+
+        # Paste source objects to destination image directly
+        img = dst_img * (1 - composed_mask[..., np.newaxis]
+                         ) + src_img * composed_mask[..., np.newaxis]
+        bboxes = src_bboxes.cat([updated_dst_bboxes[valid_inds], src_bboxes])
+        labels = np.concatenate([dst_labels[valid_inds], src_labels])
+        masks = np.concatenate(
+            [updated_dst_masks.masks[valid_inds], src_masks.masks])
+        ignore_flags = np.concatenate(
+            [dst_ignore_flags[valid_inds], src_ignore_flags])
+
+        dst_results['img'] = img
+        dst_results['gt_bboxes'] = bboxes
+        dst_results['gt_bboxes_labels'] = labels
+        dst_results['gt_masks'] = BitmapMasks(masks, masks.shape[1],
+                                              masks.shape[2])
+        dst_results['gt_ignore_flags'] = ignore_flags
+
+        return dst_results
+
+    def _get_updated_masks(self, masks: BitmapMasks,
+                           composed_mask: np.ndarray) -> BitmapMasks:
+        """Update masks with composed mask."""
+        assert masks.masks.shape[-2:] == composed_mask.shape[-2:], \
+            'Cannot compare two arrays of different size'
+        masks.masks = np.where(composed_mask, 0, masks.masks)
+        return masks
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'(max_num_pasted={self.max_num_pasted}, '
+        repr_str += f'bbox_occluded_thr={self.bbox_occluded_thr}, '
+        repr_str += f'mask_occluded_thr={self.mask_occluded_thr}, '
+        repr_str += f'selected={self.selected}), '
+        repr_str += f'paste_by_box={self.paste_by_box})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class RandomErasing(BaseTransform):
+    """RandomErasing operation.
+
+    Random Erasing randomly selects a rectangle region
+    in an image and erases its pixels with random values.
+    `RandomErasing `_.
+
+    Required Keys:
+
+    - img
+    - gt_bboxes (HorizontalBoxes[torch.float32]) (optional)
+    - gt_bboxes_labels (np.int64) (optional)
+    - gt_ignore_flags (bool) (optional)
+    - gt_masks (BitmapMasks) (optional)
+
+    Modified Keys:
+    - img
+    - gt_bboxes (optional)
+    - gt_bboxes_labels (optional)
+    - gt_ignore_flags (optional)
+    - gt_masks (optional)
+
+    Args:
+        n_patches (int or tuple[int, int]): Number of regions to be dropped.
+            If it is given as a tuple, number of patches will be randomly
+            selected from the closed interval [``n_patches[0]``,
+            ``n_patches[1]``].
+        ratio (float or tuple[float, float]): The ratio of erased regions.
+            It can be ``float`` to use a fixed ratio or ``tuple[float, float]``
+            to randomly choose ratio from the interval.
+        squared (bool): Whether to erase square region. Defaults to True.
+        bbox_erased_thr (float): The threshold for the maximum area proportion
+            of the bbox to be erased. When the proportion of the area where the
+            bbox is erased is greater than the threshold, the bbox will be
+            removed. Defaults to 0.9.
+        img_border_value (int or float or tuple): The filled values for
+            image border. If float, the same fill value will be used for
+            all the three channels of image. If tuple, it should be 3 elements.
+            Defaults to 128.
+        mask_border_value (int): The fill value used for masks. Defaults to 0.
+        seg_ignore_label (int): The fill value used for segmentation map.
+            Note this value must equals ``ignore_label`` in ``semantic_head``
+            of the corresponding config. Defaults to 255.
+    """
+
+    def __init__(
+        self,
+        n_patches: Union[int, Tuple[int, int]],
+        ratio: Union[float, Tuple[float, float]],
+        squared: bool = True,
+        bbox_erased_thr: float = 0.9,
+        img_border_value: Union[int, float, tuple] = 128,
+        mask_border_value: int = 0,
+        seg_ignore_label: int = 255,
+    ) -> None:
+        if isinstance(n_patches, tuple):
+            assert len(n_patches) == 2 and 0 <= n_patches[0] < n_patches[1]
+        else:
+            n_patches = (n_patches, n_patches)
+        if isinstance(ratio, tuple):
+            assert len(ratio) == 2 and 0 <= ratio[0] < ratio[1] <= 1
+        else:
+            ratio = (ratio, ratio)
+
+        self.n_patches = n_patches
+        self.ratio = ratio
+        self.squared = squared
+        self.bbox_erased_thr = bbox_erased_thr
+        self.img_border_value = img_border_value
+        self.mask_border_value = mask_border_value
+        self.seg_ignore_label = seg_ignore_label
+
+    @cache_randomness
+    def _get_patches(self, img_shape: Tuple[int, int]) -> List[list]:
+        """Get patches for random erasing."""
+        patches = []
+        n_patches = np.random.randint(self.n_patches[0], self.n_patches[1] + 1)
+        for _ in range(n_patches):
+            if self.squared:
+                ratio = np.random.random() * (self.ratio[1] -
+                                              self.ratio[0]) + self.ratio[0]
+                ratio = (ratio, ratio)
+            else:
+                ratio = (np.random.random() * (self.ratio[1] - self.ratio[0]) +
+                         self.ratio[0], np.random.random() *
+                         (self.ratio[1] - self.ratio[0]) + self.ratio[0])
+            ph, pw = int(img_shape[0] * ratio[0]), int(img_shape[1] * ratio[1])
+            px1, py1 = np.random.randint(0,
+                                         img_shape[1] - pw), np.random.randint(
+                                             0, img_shape[0] - ph)
+            px2, py2 = px1 + pw, py1 + ph
+            patches.append([px1, py1, px2, py2])
+        return np.array(patches)
+
+    def _transform_img(self, results: dict, patches: List[list]) -> None:
+        """Random erasing the image."""
+        for patch in patches:
+            px1, py1, px2, py2 = patch
+            results['img'][py1:py2, px1:px2, :] = self.img_border_value
+
+    def _transform_bboxes(self, results: dict, patches: List[list]) -> None:
+        """Random erasing the bboxes."""
+        bboxes = results['gt_bboxes']
+        # TODO: unify the logic by using operators in BaseBoxes.
+        assert isinstance(bboxes, HorizontalBoxes)
+        bboxes = bboxes.numpy()
+        left_top = np.maximum(bboxes[:, None, :2], patches[:, :2])
+        right_bottom = np.minimum(bboxes[:, None, 2:], patches[:, 2:])
+        wh = np.maximum(right_bottom - left_top, 0)
+        inter_areas = wh[:, :, 0] * wh[:, :, 1]
+        bbox_areas = (bboxes[:, 2] - bboxes[:, 0]) * (
+            bboxes[:, 3] - bboxes[:, 1])
+        bboxes_erased_ratio = inter_areas.sum(-1) / (bbox_areas + 1e-7)
+        valid_inds = bboxes_erased_ratio < self.bbox_erased_thr
+        results['gt_bboxes'] = HorizontalBoxes(bboxes[valid_inds])
+        results['gt_bboxes_labels'] = results['gt_bboxes_labels'][valid_inds]
+        results['gt_ignore_flags'] = results['gt_ignore_flags'][valid_inds]
+        if results.get('gt_masks', None) is not None:
+            results['gt_masks'] = results['gt_masks'][valid_inds]
+
+    def _transform_masks(self, results: dict, patches: List[list]) -> None:
+        """Random erasing the masks."""
+        for patch in patches:
+            px1, py1, px2, py2 = patch
+            results['gt_masks'].masks[:, py1:py2,
+                                      px1:px2] = self.mask_border_value
+
+    def _transform_seg(self, results: dict, patches: List[list]) -> None:
+        """Random erasing the segmentation map."""
+        for patch in patches:
+            px1, py1, px2, py2 = patch
+            results['gt_seg_map'][py1:py2, px1:px2] = self.seg_ignore_label
+
+    @autocast_box_type()
+    def transform(self, results: dict) -> dict:
+        """Transform function to erase some regions of image."""
+        patches = self._get_patches(results['img_shape'])
+        self._transform_img(results, patches)
+        if results.get('gt_bboxes', None) is not None:
+            self._transform_bboxes(results, patches)
+        if results.get('gt_masks', None) is not None:
+            self._transform_masks(results, patches)
+        if results.get('gt_seg_map', None) is not None:
+            self._transform_seg(results, patches)
+        return results
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'(n_patches={self.n_patches}, '
+        repr_str += f'ratio={self.ratio}, '
+        repr_str += f'squared={self.squared}, '
+        repr_str += f'bbox_erased_thr={self.bbox_erased_thr}, '
+        repr_str += f'img_border_value={self.img_border_value}, '
+        repr_str += f'mask_border_value={self.mask_border_value}, '
+        repr_str += f'seg_ignore_label={self.seg_ignore_label})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class CachedMosaic(Mosaic):
+    """Cached mosaic augmentation.
+
+    Cached mosaic transform will random select images from the cache
+    and combine them into one output image.
+
+    .. code:: text
+
+                        mosaic transform
+                           center_x
+                +------------------------------+
+                |       pad        |  pad      |
+                |      +-----------+           |
+                |      |           |           |
+                |      |  image1   |--------+  |
+                |      |           |        |  |
+                |      |           | image2 |  |
+     center_y   |----+-------------+-----------|
+                |    |   cropped   |           |
+                |pad |   image3    |  image4   |
+                |    |             |           |
+                +----|-------------+-----------+
+                     |             |
+                     +-------------+
+
+     The cached mosaic transform steps are as follows:
+
+         1. Append the results from the last transform into the cache.
+         2. Choose the mosaic center as the intersections of 4 images
+         3. Get the left top image according to the index, and randomly
+            sample another 3 images from the result cache.
+         4. Sub image will be cropped if image is larger than mosaic patch
+
+    Required Keys:
+
+    - img
+    - gt_bboxes (np.float32) (optional)
+    - gt_bboxes_labels (np.int64) (optional)
+    - gt_ignore_flags (bool) (optional)
+
+    Modified Keys:
+
+    - img
+    - img_shape
+    - gt_bboxes (optional)
+    - gt_bboxes_labels (optional)
+    - gt_ignore_flags (optional)
+
+    Args:
+        img_scale (Sequence[int]): Image size before mosaic pipeline of single
+            image. The shape order should be (width, height).
+            Defaults to (640, 640).
+        center_ratio_range (Sequence[float]): Center ratio range of mosaic
+            output. Defaults to (0.5, 1.5).
+        bbox_clip_border (bool, optional): Whether to clip the objects outside
+            the border of the image. In some dataset like MOT17, the gt bboxes
+            are allowed to cross the border of images. Therefore, we don't
+            need to clip the gt bboxes in these cases. Defaults to True.
+        pad_val (int): Pad value. Defaults to 114.
+        prob (float): Probability of applying this transformation.
+            Defaults to 1.0.
+        max_cached_images (int): The maximum length of the cache. The larger
+            the cache, the stronger the randomness of this transform. As a
+            rule of thumb, providing 10 caches for each image suffices for
+            randomness. Defaults to 40.
+        random_pop (bool): Whether to randomly pop a result from the cache
+            when the cache is full. If set to False, use FIFO popping method.
+            Defaults to True.
+    """
+
+    def __init__(self,
+                 *args,
+                 max_cached_images: int = 40,
+                 random_pop: bool = True,
+                 **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.results_cache = []
+        self.random_pop = random_pop
+        assert max_cached_images >= 4, 'The length of cache must >= 4, ' \
+                                       f'but got {max_cached_images}.'
+        self.max_cached_images = max_cached_images
+
+    @cache_randomness
+    def get_indexes(self, cache: list) -> list:
+        """Call function to collect indexes.
+
+        Args:
+            cache (list): The results cache.
+
+        Returns:
+            list: indexes.
+        """
+
+        indexes = [random.randint(0, len(cache) - 1) for _ in range(3)]
+        return indexes
+
+    @autocast_box_type()
+    def transform(self, results: dict) -> dict:
+        """Mosaic transform function.
+
+        Args:
+            results (dict): Result dict.
+
+        Returns:
+            dict: Updated result dict.
+        """
+        # cache and pop images
+        self.results_cache.append(copy.deepcopy(results))
+        if len(self.results_cache) > self.max_cached_images:
+            if self.random_pop:
+                index = random.randint(0, len(self.results_cache) - 1)
+            else:
+                index = 0
+            self.results_cache.pop(index)
+
+        if len(self.results_cache) <= 4:
+            return results
+
+        if random.uniform(0, 1) > self.prob:
+            return results
+        indices = self.get_indexes(self.results_cache)
+        mix_results = [copy.deepcopy(self.results_cache[i]) for i in indices]
+
+        # TODO: refactor mosaic to reuse these code.
+        mosaic_bboxes = []
+        mosaic_bboxes_labels = []
+        mosaic_ignore_flags = []
+        mosaic_masks = []
+        with_mask = True if 'gt_masks' in results else False
+
+        if len(results['img'].shape) == 3:
+            mosaic_img = np.full(
+                (int(self.img_scale[1] * 2), int(self.img_scale[0] * 2), 3),
+                self.pad_val,
+                dtype=results['img'].dtype)
+        else:
+            mosaic_img = np.full(
+                (int(self.img_scale[1] * 2), int(self.img_scale[0] * 2)),
+                self.pad_val,
+                dtype=results['img'].dtype)
+
+        # mosaic center x, y
+        center_x = int(
+            random.uniform(*self.center_ratio_range) * self.img_scale[0])
+        center_y = int(
+            random.uniform(*self.center_ratio_range) * self.img_scale[1])
+        center_position = (center_x, center_y)
+
+        loc_strs = ('top_left', 'top_right', 'bottom_left', 'bottom_right')
+        for i, loc in enumerate(loc_strs):
+            if loc == 'top_left':
+                results_patch = copy.deepcopy(results)
+            else:
+                results_patch = copy.deepcopy(mix_results[i - 1])
+
+            img_i = results_patch['img']
+            h_i, w_i = img_i.shape[:2]
+            # keep_ratio resize
+            scale_ratio_i = min(self.img_scale[1] / h_i,
+                                self.img_scale[0] / w_i)
+            img_i = mmcv.imresize(
+                img_i, (int(w_i * scale_ratio_i), int(h_i * scale_ratio_i)))
+
+            # compute the combine parameters
+            paste_coord, crop_coord = self._mosaic_combine(
+                loc, center_position, img_i.shape[:2][::-1])
+            x1_p, y1_p, x2_p, y2_p = paste_coord
+            x1_c, y1_c, x2_c, y2_c = crop_coord
+
+            # crop and paste image
+            mosaic_img[y1_p:y2_p, x1_p:x2_p] = img_i[y1_c:y2_c, x1_c:x2_c]
+
+            # adjust coordinate
+            gt_bboxes_i = results_patch['gt_bboxes']
+            gt_bboxes_labels_i = results_patch['gt_bboxes_labels']
+            gt_ignore_flags_i = results_patch['gt_ignore_flags']
+
+            padw = x1_p - x1_c
+            padh = y1_p - y1_c
+            gt_bboxes_i.rescale_([scale_ratio_i, scale_ratio_i])
+            gt_bboxes_i.translate_([padw, padh])
+            mosaic_bboxes.append(gt_bboxes_i)
+            mosaic_bboxes_labels.append(gt_bboxes_labels_i)
+            mosaic_ignore_flags.append(gt_ignore_flags_i)
+            if with_mask and results_patch.get('gt_masks', None) is not None:
+                gt_masks_i = results_patch['gt_masks']
+                gt_masks_i = gt_masks_i.rescale(float(scale_ratio_i))
+                gt_masks_i = gt_masks_i.translate(
+                    out_shape=(int(self.img_scale[0] * 2),
+                               int(self.img_scale[1] * 2)),
+                    offset=padw,
+                    direction='horizontal')
+                gt_masks_i = gt_masks_i.translate(
+                    out_shape=(int(self.img_scale[0] * 2),
+                               int(self.img_scale[1] * 2)),
+                    offset=padh,
+                    direction='vertical')
+                mosaic_masks.append(gt_masks_i)
+
+        mosaic_bboxes = mosaic_bboxes[0].cat(mosaic_bboxes, 0)
+        mosaic_bboxes_labels = np.concatenate(mosaic_bboxes_labels, 0)
+        mosaic_ignore_flags = np.concatenate(mosaic_ignore_flags, 0)
+
+        if self.bbox_clip_border:
+            mosaic_bboxes.clip_([2 * self.img_scale[1], 2 * self.img_scale[0]])
+        # remove outside bboxes
+        inside_inds = mosaic_bboxes.is_inside(
+            [2 * self.img_scale[1], 2 * self.img_scale[0]]).numpy()
+        mosaic_bboxes = mosaic_bboxes[inside_inds]
+        mosaic_bboxes_labels = mosaic_bboxes_labels[inside_inds]
+        mosaic_ignore_flags = mosaic_ignore_flags[inside_inds]
+
+        results['img'] = mosaic_img
+        results['img_shape'] = mosaic_img.shape[:2]
+        results['gt_bboxes'] = mosaic_bboxes
+        results['gt_bboxes_labels'] = mosaic_bboxes_labels
+        results['gt_ignore_flags'] = mosaic_ignore_flags
+
+        if with_mask:
+            mosaic_masks = mosaic_masks[0].cat(mosaic_masks)
+            results['gt_masks'] = mosaic_masks[inside_inds]
+        return results
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'(img_scale={self.img_scale}, '
+        repr_str += f'center_ratio_range={self.center_ratio_range}, '
+        repr_str += f'pad_val={self.pad_val}, '
+        repr_str += f'prob={self.prob}, '
+        repr_str += f'max_cached_images={self.max_cached_images}, '
+        repr_str += f'random_pop={self.random_pop})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class CachedMixUp(BaseTransform):
+    """Cached mixup data augmentation.
+
+    .. code:: text
+
+                         mixup transform
+                +------------------------------+
+                | mixup image   |              |
+                |      +--------|--------+     |
+                |      |        |        |     |
+                |---------------+        |     |
+                |      |                 |     |
+                |      |      image      |     |
+                |      |                 |     |
+                |      |                 |     |
+                |      |-----------------+     |
+                |             pad              |
+                +------------------------------+
+
+     The cached mixup transform steps are as follows:
+
+        1. Append the results from the last transform into the cache.
+        2. Another random image is picked from the cache and embedded in
+           the top left patch(after padding and resizing)
+        3. The target of mixup transform is the weighted average of mixup
+           image and origin image.
+
+    Required Keys:
+
+    - img
+    - gt_bboxes (np.float32) (optional)
+    - gt_bboxes_labels (np.int64) (optional)
+    - gt_ignore_flags (bool) (optional)
+    - mix_results (List[dict])
+
+
+    Modified Keys:
+
+    - img
+    - img_shape
+    - gt_bboxes (optional)
+    - gt_bboxes_labels (optional)
+    - gt_ignore_flags (optional)
+
+
+    Args:
+        img_scale (Sequence[int]): Image output size after mixup pipeline.
+            The shape order should be (width, height). Defaults to (640, 640).
+        ratio_range (Sequence[float]): Scale ratio of mixup image.
+            Defaults to (0.5, 1.5).
+        flip_ratio (float): Horizontal flip ratio of mixup image.
+            Defaults to 0.5.
+        pad_val (int): Pad value. Defaults to 114.
+        max_iters (int): The maximum number of iterations. If the number of
+            iterations is greater than `max_iters`, but gt_bbox is still
+            empty, then the iteration is terminated. Defaults to 15.
+        bbox_clip_border (bool, optional): Whether to clip the objects outside
+            the border of the image. In some dataset like MOT17, the gt bboxes
+            are allowed to cross the border of images. Therefore, we don't
+            need to clip the gt bboxes in these cases. Defaults to True.
+        max_cached_images (int): The maximum length of the cache. The larger
+            the cache, the stronger the randomness of this transform. As a
+            rule of thumb, providing 10 caches for each image suffices for
+            randomness. Defaults to 20.
+        random_pop (bool): Whether to randomly pop a result from the cache
+            when the cache is full. If set to False, use FIFO popping method.
+            Defaults to True.
+        prob (float): Probability of applying this transformation.
+            Defaults to 1.0.
+    """
+
+    def __init__(self,
+                 img_scale: Tuple[int, int] = (640, 640),
+                 ratio_range: Tuple[float, float] = (0.5, 1.5),
+                 flip_ratio: float = 0.5,
+                 pad_val: float = 114.0,
+                 max_iters: int = 15,
+                 bbox_clip_border: bool = True,
+                 max_cached_images: int = 20,
+                 random_pop: bool = True,
+                 prob: float = 1.0) -> None:
+        assert isinstance(img_scale, tuple)
+        assert max_cached_images >= 2, 'The length of cache must >= 2, ' \
+                                       f'but got {max_cached_images}.'
+        assert 0 <= prob <= 1.0, 'The probability should be in range [0,1]. ' \
+                                 f'got {prob}.'
+        self.dynamic_scale = img_scale
+        self.ratio_range = ratio_range
+        self.flip_ratio = flip_ratio
+        self.pad_val = pad_val
+        self.max_iters = max_iters
+        self.bbox_clip_border = bbox_clip_border
+        self.results_cache = []
+
+        self.max_cached_images = max_cached_images
+        self.random_pop = random_pop
+        self.prob = prob
+
+    @cache_randomness
+    def get_indexes(self, cache: list) -> int:
+        """Call function to collect indexes.
+
+        Args:
+            cache (list): The result cache.
+
+        Returns:
+            int: index.
+        """
+
+        for i in range(self.max_iters):
+            index = random.randint(0, len(cache) - 1)
+            gt_bboxes_i = cache[index]['gt_bboxes']
+            if len(gt_bboxes_i) != 0:
+                break
+        return index
+
+    @autocast_box_type()
+    def transform(self, results: dict) -> dict:
+        """MixUp transform function.
+
+        Args:
+            results (dict): Result dict.
+
+        Returns:
+            dict: Updated result dict.
+        """
+        # cache and pop images
+        self.results_cache.append(copy.deepcopy(results))
+        if len(self.results_cache) > self.max_cached_images:
+            if self.random_pop:
+                index = random.randint(0, len(self.results_cache) - 1)
+            else:
+                index = 0
+            self.results_cache.pop(index)
+
+        if len(self.results_cache) <= 1:
+            return results
+
+        if random.uniform(0, 1) > self.prob:
+            return results
+
+        index = self.get_indexes(self.results_cache)
+        retrieve_results = copy.deepcopy(self.results_cache[index])
+
+        # TODO: refactor mixup to reuse these code.
+        if retrieve_results['gt_bboxes'].shape[0] == 0:
+            # empty bbox
+            return results
+
+        retrieve_img = retrieve_results['img']
+        with_mask = True if 'gt_masks' in results else False
+
+        jit_factor = random.uniform(*self.ratio_range)
+        is_flip = random.uniform(0, 1) > self.flip_ratio
+
+        if len(retrieve_img.shape) == 3:
+            out_img = np.ones(
+                (self.dynamic_scale[1], self.dynamic_scale[0], 3),
+                dtype=retrieve_img.dtype) * self.pad_val
+        else:
+            out_img = np.ones(
+                self.dynamic_scale[::-1],
+                dtype=retrieve_img.dtype) * self.pad_val
+
+        # 1. keep_ratio resize
+        scale_ratio = min(self.dynamic_scale[1] / retrieve_img.shape[0],
+                          self.dynamic_scale[0] / retrieve_img.shape[1])
+        retrieve_img = mmcv.imresize(
+            retrieve_img, (int(retrieve_img.shape[1] * scale_ratio),
+                           int(retrieve_img.shape[0] * scale_ratio)))
+
+        # 2. paste
+        out_img[:retrieve_img.shape[0], :retrieve_img.shape[1]] = retrieve_img
+
+        # 3. scale jit
+        scale_ratio *= jit_factor
+        out_img = mmcv.imresize(out_img, (int(out_img.shape[1] * jit_factor),
+                                          int(out_img.shape[0] * jit_factor)))
+
+        # 4. flip
+        if is_flip:
+            out_img = out_img[:, ::-1, :]
+
+        # 5. random crop
+        ori_img = results['img']
+        origin_h, origin_w = out_img.shape[:2]
+        target_h, target_w = ori_img.shape[:2]
+        padded_img = np.ones((max(origin_h, target_h), max(
+            origin_w, target_w), 3)) * self.pad_val
+        padded_img = padded_img.astype(np.uint8)
+        padded_img[:origin_h, :origin_w] = out_img
+
+        x_offset, y_offset = 0, 0
+        if padded_img.shape[0] > target_h:
+            y_offset = random.randint(0, padded_img.shape[0] - target_h)
+        if padded_img.shape[1] > target_w:
+            x_offset = random.randint(0, padded_img.shape[1] - target_w)
+        padded_cropped_img = padded_img[y_offset:y_offset + target_h,
+                                        x_offset:x_offset + target_w]
+
+        # 6. adjust bbox
+        retrieve_gt_bboxes = retrieve_results['gt_bboxes']
+        retrieve_gt_bboxes.rescale_([scale_ratio, scale_ratio])
+        if with_mask:
+            retrieve_gt_masks = retrieve_results['gt_masks'].rescale(
+                scale_ratio)
+
+        if self.bbox_clip_border:
+            retrieve_gt_bboxes.clip_([origin_h, origin_w])
+
+        if is_flip:
+            retrieve_gt_bboxes.flip_([origin_h, origin_w],
+                                     direction='horizontal')
+            if with_mask:
+                retrieve_gt_masks = retrieve_gt_masks.flip()
+
+        # 7. filter
+        cp_retrieve_gt_bboxes = retrieve_gt_bboxes.clone()
+        cp_retrieve_gt_bboxes.translate_([-x_offset, -y_offset])
+        if with_mask:
+            retrieve_gt_masks = retrieve_gt_masks.translate(
+                out_shape=(target_h, target_w),
+                offset=-x_offset,
+                direction='horizontal')
+            retrieve_gt_masks = retrieve_gt_masks.translate(
+                out_shape=(target_h, target_w),
+                offset=-y_offset,
+                direction='vertical')
+
+        if self.bbox_clip_border:
+            cp_retrieve_gt_bboxes.clip_([target_h, target_w])
+
+        # 8. mix up
+        ori_img = ori_img.astype(np.float32)
+        mixup_img = 0.5 * ori_img + 0.5 * padded_cropped_img.astype(np.float32)
+
+        retrieve_gt_bboxes_labels = retrieve_results['gt_bboxes_labels']
+        retrieve_gt_ignore_flags = retrieve_results['gt_ignore_flags']
+
+        mixup_gt_bboxes = cp_retrieve_gt_bboxes.cat(
+            (results['gt_bboxes'], cp_retrieve_gt_bboxes), dim=0)
+        mixup_gt_bboxes_labels = np.concatenate(
+            (results['gt_bboxes_labels'], retrieve_gt_bboxes_labels), axis=0)
+        mixup_gt_ignore_flags = np.concatenate(
+            (results['gt_ignore_flags'], retrieve_gt_ignore_flags), axis=0)
+        if with_mask:
+            mixup_gt_masks = retrieve_gt_masks.cat(
+                [results['gt_masks'], retrieve_gt_masks])
+
+        # remove outside bbox
+        inside_inds = mixup_gt_bboxes.is_inside([target_h, target_w]).numpy()
+        mixup_gt_bboxes = mixup_gt_bboxes[inside_inds]
+        mixup_gt_bboxes_labels = mixup_gt_bboxes_labels[inside_inds]
+        mixup_gt_ignore_flags = mixup_gt_ignore_flags[inside_inds]
+        if with_mask:
+            mixup_gt_masks = mixup_gt_masks[inside_inds]
+
+        results['img'] = mixup_img.astype(np.uint8)
+        results['img_shape'] = mixup_img.shape[:2]
+        results['gt_bboxes'] = mixup_gt_bboxes
+        results['gt_bboxes_labels'] = mixup_gt_bboxes_labels
+        results['gt_ignore_flags'] = mixup_gt_ignore_flags
+        if with_mask:
+            results['gt_masks'] = mixup_gt_masks
+        return results
+
+    def __repr__(self):
+        repr_str = self.__class__.__name__
+        repr_str += f'(dynamic_scale={self.dynamic_scale}, '
+        repr_str += f'ratio_range={self.ratio_range}, '
+        repr_str += f'flip_ratio={self.flip_ratio}, '
+        repr_str += f'pad_val={self.pad_val}, '
+        repr_str += f'max_iters={self.max_iters}, '
+        repr_str += f'bbox_clip_border={self.bbox_clip_border}, '
+        repr_str += f'max_cached_images={self.max_cached_images}, '
+        repr_str += f'random_pop={self.random_pop}, '
+        repr_str += f'prob={self.prob})'
+        return repr_str
diff --git a/mmdetection/mmdet/datasets/transforms/wrappers.py b/mmdetection/mmdet/datasets/transforms/wrappers.py
new file mode 100644
index 00000000..3a17711c
--- /dev/null
+++ b/mmdetection/mmdet/datasets/transforms/wrappers.py
@@ -0,0 +1,277 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+from typing import Callable, Dict, List, Optional, Union
+
+import numpy as np
+from mmcv.transforms import BaseTransform, Compose
+from mmcv.transforms.utils import cache_random_params, cache_randomness
+
+from mmdet.registry import TRANSFORMS
+
+
+@TRANSFORMS.register_module()
+class MultiBranch(BaseTransform):
+    r"""Multiple branch pipeline wrapper.
+
+    Generate multiple data-augmented versions of the same image.
+    `MultiBranch` needs to specify the branch names of all
+    pipelines of the dataset, perform corresponding data augmentation
+    for the current branch, and return None for other branches,
+    which ensures the consistency of return format across
+    different samples.
+
+    Args:
+        branch_field (list): List of branch names.
+        branch_pipelines (dict): Dict of different pipeline configs
+            to be composed.
+
+    Examples:
+        >>> branch_field = ['sup', 'unsup_teacher', 'unsup_student']
+        >>> sup_pipeline = [
+        >>>     dict(type='LoadImageFromFile'),
+        >>>     dict(type='LoadAnnotations', with_bbox=True),
+        >>>     dict(type='Resize', scale=(1333, 800), keep_ratio=True),
+        >>>     dict(type='RandomFlip', prob=0.5),
+        >>>     dict(
+        >>>         type='MultiBranch',
+        >>>         branch_field=branch_field,
+        >>>         sup=dict(type='PackDetInputs'))
+        >>>     ]
+        >>> weak_pipeline = [
+        >>>     dict(type='LoadImageFromFile'),
+        >>>     dict(type='LoadAnnotations', with_bbox=True),
+        >>>     dict(type='Resize', scale=(1333, 800), keep_ratio=True),
+        >>>     dict(type='RandomFlip', prob=0.0),
+        >>>     dict(
+        >>>         type='MultiBranch',
+        >>>         branch_field=branch_field,
+        >>>         sup=dict(type='PackDetInputs'))
+        >>>     ]
+        >>> strong_pipeline = [
+        >>>     dict(type='LoadImageFromFile'),
+        >>>     dict(type='LoadAnnotations', with_bbox=True),
+        >>>     dict(type='Resize', scale=(1333, 800), keep_ratio=True),
+        >>>     dict(type='RandomFlip', prob=1.0),
+        >>>     dict(
+        >>>         type='MultiBranch',
+        >>>         branch_field=branch_field,
+        >>>         sup=dict(type='PackDetInputs'))
+        >>>     ]
+        >>> unsup_pipeline = [
+        >>>     dict(type='LoadImageFromFile'),
+        >>>     dict(type='LoadEmptyAnnotations'),
+        >>>     dict(
+        >>>         type='MultiBranch',
+        >>>         branch_field=branch_field,
+        >>>         unsup_teacher=weak_pipeline,
+        >>>         unsup_student=strong_pipeline)
+        >>>     ]
+        >>> from mmcv.transforms import Compose
+        >>> sup_branch = Compose(sup_pipeline)
+        >>> unsup_branch = Compose(unsup_pipeline)
+        >>> print(sup_branch)
+        >>> Compose(
+        >>>     LoadImageFromFile(ignore_empty=False, to_float32=False, color_type='color', imdecode_backend='cv2') # noqa
+        >>>     LoadAnnotations(with_bbox=True, with_label=True, with_mask=False, with_seg=False, poly2mask=True, imdecode_backend='cv2') # noqa
+        >>>     Resize(scale=(1333, 800), scale_factor=None, keep_ratio=True, clip_object_border=True), backend=cv2), interpolation=bilinear) # noqa
+        >>>     RandomFlip(prob=0.5, direction=horizontal)
+        >>>     MultiBranch(branch_pipelines=['sup'])
+        >>> )
+        >>> print(unsup_branch)
+        >>> Compose(
+        >>>     LoadImageFromFile(ignore_empty=False, to_float32=False, color_type='color', imdecode_backend='cv2') # noqa
+        >>>     LoadEmptyAnnotations(with_bbox=True, with_label=True, with_mask=False, with_seg=False, seg_ignore_label=255) # noqa
+        >>>     MultiBranch(branch_pipelines=['unsup_teacher', 'unsup_student'])
+        >>> )
+    """
+
+    def __init__(self, branch_field: List[str],
+                 **branch_pipelines: dict) -> None:
+        self.branch_field = branch_field
+        self.branch_pipelines = {
+            branch: Compose(pipeline)
+            for branch, pipeline in branch_pipelines.items()
+        }
+
+    def transform(self, results: dict) -> dict:
+        """Transform function to apply transforms sequentially.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict:
+
+            - 'inputs' (Dict[str, obj:`torch.Tensor`]): The forward data of
+                models from different branches.
+            - 'data_sample' (Dict[str,obj:`DetDataSample`]): The annotation
+                info of the sample from different branches.
+        """
+
+        multi_results = {}
+        for branch in self.branch_field:
+            multi_results[branch] = {'inputs': None, 'data_samples': None}
+        for branch, pipeline in self.branch_pipelines.items():
+            branch_results = pipeline(copy.deepcopy(results))
+            # If one branch pipeline returns None,
+            # it will sample another data from dataset.
+            if branch_results is None:
+                return None
+            multi_results[branch] = branch_results
+
+        format_results = {}
+        for branch, results in multi_results.items():
+            for key in results.keys():
+                if format_results.get(key, None) is None:
+                    format_results[key] = {branch: results[key]}
+                else:
+                    format_results[key][branch] = results[key]
+        return format_results
+
+    def __repr__(self) -> str:
+        repr_str = self.__class__.__name__
+        repr_str += f'(branch_pipelines={list(self.branch_pipelines.keys())})'
+        return repr_str
+
+
+@TRANSFORMS.register_module()
+class RandomOrder(Compose):
+    """Shuffle the transform Sequence."""
+
+    @cache_randomness
+    def _random_permutation(self):
+        return np.random.permutation(len(self.transforms))
+
+    def transform(self, results: Dict) -> Optional[Dict]:
+        """Transform function to apply transforms in random order.
+
+        Args:
+            results (dict): A result dict contains the results to transform.
+
+        Returns:
+            dict or None: Transformed results.
+        """
+        inds = self._random_permutation()
+        for idx in inds:
+            t = self.transforms[idx]
+            results = t(results)
+            if results is None:
+                return None
+        return results
+
+    def __repr__(self):
+        """Compute the string representation."""
+        format_string = self.__class__.__name__ + '('
+        for t in self.transforms:
+            format_string += f'{t.__class__.__name__}, '
+        format_string += ')'
+        return format_string
+
+
+@TRANSFORMS.register_module()
+class ProposalBroadcaster(BaseTransform):
+    """A transform wrapper to apply the wrapped transforms to process both
+    `gt_bboxes` and `proposals` without adding any codes. It will do the
+    following steps:
+
+        1. Scatter the broadcasting targets to a list of inputs of the wrapped
+           transforms. The type of the list should be list[dict, dict], which
+           the first is the original inputs, the second is the processing
+           results that `gt_bboxes` being rewritten by the `proposals`.
+        2. Apply ``self.transforms``, with same random parameters, which is
+           sharing with a context manager. The type of the outputs is a
+           list[dict, dict].
+        3. Gather the outputs, update the `proposals` in the first item of
+           the outputs with the `gt_bboxes` in the second .
+
+    Args:
+         transforms (list, optional): Sequence of transform
+            object or config dict to be wrapped. Defaults to [].
+
+    Note: The `TransformBroadcaster` in MMCV can achieve the same operation as
+          `ProposalBroadcaster`, but need to set more complex parameters.
+
+    Examples:
+        >>> pipeline = [
+        >>>     dict(type='LoadImageFromFile'),
+        >>>     dict(type='LoadProposals', num_max_proposals=2000),
+        >>>     dict(type='LoadAnnotations', with_bbox=True),
+        >>>     dict(
+        >>>         type='ProposalBroadcaster',
+        >>>         transforms=[
+        >>>             dict(type='Resize', scale=(1333, 800),
+        >>>                  keep_ratio=True),
+        >>>             dict(type='RandomFlip', prob=0.5),
+        >>>         ]),
+        >>>     dict(type='PackDetInputs')]
+    """
+
+    def __init__(self, transforms: List[Union[dict, Callable]] = []) -> None:
+        self.transforms = Compose(transforms)
+
+    def transform(self, results: dict) -> dict:
+        """Apply wrapped transform functions to process both `gt_bboxes` and
+        `proposals`.
+
+        Args:
+            results (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Updated result dict.
+        """
+        assert results.get('proposals', None) is not None, \
+            '`proposals` should be in the results, please delete ' \
+            '`ProposalBroadcaster` in your configs, or check whether ' \
+            'you have load proposals successfully.'
+
+        inputs = self._process_input(results)
+        outputs = self._apply_transforms(inputs)
+        outputs = self._process_output(outputs)
+        return outputs
+
+    def _process_input(self, data: dict) -> list:
+        """Scatter the broadcasting targets to a list of inputs of the wrapped
+        transforms.
+
+        Args:
+            data (dict): The original input data.
+
+        Returns:
+            list[dict]: A list of input data.
+        """
+        cp_data = copy.deepcopy(data)
+        cp_data['gt_bboxes'] = cp_data['proposals']
+        scatters = [data, cp_data]
+        return scatters
+
+    def _apply_transforms(self, inputs: list) -> list:
+        """Apply ``self.transforms``.
+
+        Args:
+            inputs (list[dict, dict]): list of input data.
+
+        Returns:
+            list[dict]: The output of the wrapped pipeline.
+        """
+        assert len(inputs) == 2
+        ctx = cache_random_params
+        with ctx(self.transforms):
+            output_scatters = [self.transforms(_input) for _input in inputs]
+        return output_scatters
+
+    def _process_output(self, output_scatters: list) -> dict:
+        """Gathering and renaming data items.
+
+        Args:
+            output_scatters (list[dict, dict]): The output of the wrapped
+                pipeline.
+
+        Returns:
+            dict: Updated result dict.
+        """
+        assert isinstance(output_scatters, list) and \
+               isinstance(output_scatters[0], dict) and \
+               len(output_scatters) == 2
+        outputs = output_scatters[0]
+        outputs['proposals'] = output_scatters[1]['gt_bboxes']
+        return outputs
diff --git a/mmdetection/mmdet/datasets/utils.py b/mmdetection/mmdet/datasets/utils.py
new file mode 100644
index 00000000..d794eb4b
--- /dev/null
+++ b/mmdetection/mmdet/datasets/utils.py
@@ -0,0 +1,48 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+from mmcv.transforms import LoadImageFromFile
+
+from mmdet.datasets.transforms import LoadAnnotations, LoadPanopticAnnotations
+from mmdet.registry import TRANSFORMS
+
+
+def get_loading_pipeline(pipeline):
+    """Only keep loading image and annotations related configuration.
+
+    Args:
+        pipeline (list[dict]): Data pipeline configs.
+
+    Returns:
+        list[dict]: The new pipeline list with only keep
+            loading image and annotations related configuration.
+
+    Examples:
+        >>> pipelines = [
+        ...    dict(type='LoadImageFromFile'),
+        ...    dict(type='LoadAnnotations', with_bbox=True),
+        ...    dict(type='Resize', img_scale=(1333, 800), keep_ratio=True),
+        ...    dict(type='RandomFlip', flip_ratio=0.5),
+        ...    dict(type='Normalize', **img_norm_cfg),
+        ...    dict(type='Pad', size_divisor=32),
+        ...    dict(type='DefaultFormatBundle'),
+        ...    dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels'])
+        ...    ]
+        >>> expected_pipelines = [
+        ...    dict(type='LoadImageFromFile'),
+        ...    dict(type='LoadAnnotations', with_bbox=True)
+        ...    ]
+        >>> assert expected_pipelines ==\
+        ...        get_loading_pipeline(pipelines)
+    """
+    loading_pipeline_cfg = []
+    for cfg in pipeline:
+        obj_cls = TRANSFORMS.get(cfg['type'])
+        # TODO:use more elegant way to distinguish loading modules
+        if obj_cls is not None and obj_cls in (LoadImageFromFile,
+                                               LoadAnnotations,
+                                               LoadPanopticAnnotations):
+            loading_pipeline_cfg.append(cfg)
+    assert len(loading_pipeline_cfg) == 2, \
+        'The data pipeline in your config file must include ' \
+        'loading image and annotations related pipeline.'
+    return loading_pipeline_cfg
diff --git a/mmdetection/mmdet/datasets/v3det.py b/mmdetection/mmdet/datasets/v3det.py
new file mode 100644
index 00000000..25bfe3bc
--- /dev/null
+++ b/mmdetection/mmdet/datasets/v3det.py
@@ -0,0 +1,32 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path
+from typing import Optional
+
+import mmengine
+
+from mmdet.registry import DATASETS
+from .coco import CocoDataset
+
+
+@DATASETS.register_module()
+class V3DetDataset(CocoDataset):
+    """Dataset for V3Det."""
+
+    METAINFO = {
+        'classes': None,
+        'palette': None,
+    }
+
+    def __init__(
+            self,
+            *args,
+            metainfo: Optional[dict] = None,
+            data_root: str = '',
+            label_file='annotations/category_name_13204_v3det_2023_v1.txt',  # noqa
+            **kwargs) -> None:
+        class_names = tuple(
+            mmengine.list_from_file(os.path.join(data_root, label_file)))
+        if metainfo is None:
+            metainfo = {'classes': class_names}
+        super().__init__(
+            *args, data_root=data_root, metainfo=metainfo, **kwargs)
diff --git a/mmdetection/mmdet/datasets/voc.py b/mmdetection/mmdet/datasets/voc.py
new file mode 100644
index 00000000..65e73f2f
--- /dev/null
+++ b/mmdetection/mmdet/datasets/voc.py
@@ -0,0 +1,31 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import DATASETS
+from .xml_style import XMLDataset
+
+
+@DATASETS.register_module()
+class VOCDataset(XMLDataset):
+    """Dataset for PASCAL VOC."""
+
+    METAINFO = {
+        'classes':
+        ('aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat',
+         'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person',
+         'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor'),
+        # palette is a list of color tuples, which is used for visualization.
+        'palette': [(106, 0, 228), (119, 11, 32), (165, 42, 42), (0, 0, 192),
+                    (197, 226, 255), (0, 60, 100), (0, 0, 142), (255, 77, 255),
+                    (153, 69, 1), (120, 166, 157), (0, 182, 199),
+                    (0, 226, 252), (182, 182, 255), (0, 0, 230), (220, 20, 60),
+                    (163, 255, 0), (0, 82, 0), (3, 95, 161), (0, 80, 100),
+                    (183, 130, 88)]
+    }
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        if 'VOC2007' in self.sub_data_root:
+            self._metainfo['dataset_type'] = 'VOC2007'
+        elif 'VOC2012' in self.sub_data_root:
+            self._metainfo['dataset_type'] = 'VOC2012'
+        else:
+            self._metainfo['dataset_type'] = None
diff --git a/mmdetection/mmdet/datasets/wider_face.py b/mmdetection/mmdet/datasets/wider_face.py
new file mode 100644
index 00000000..62c7fff8
--- /dev/null
+++ b/mmdetection/mmdet/datasets/wider_face.py
@@ -0,0 +1,90 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+import xml.etree.ElementTree as ET
+
+from mmengine.dist import is_main_process
+from mmengine.fileio import get_local_path, list_from_file
+from mmengine.utils import ProgressBar
+
+from mmdet.registry import DATASETS
+from mmdet.utils.typing_utils import List, Union
+from .xml_style import XMLDataset
+
+
+@DATASETS.register_module()
+class WIDERFaceDataset(XMLDataset):
+    """Reader for the WIDER Face dataset in PASCAL VOC format.
+
+    Conversion scripts can be found in
+    https://github.com/sovrasov/wider-face-pascal-voc-annotations
+    """
+    METAINFO = {'classes': ('face', ), 'palette': [(0, 255, 0)]}
+
+    def load_data_list(self) -> List[dict]:
+        """Load annotation from XML style ann_file.
+
+        Returns:
+            list[dict]: Annotation info from XML file.
+        """
+        assert self._metainfo.get('classes', None) is not None, \
+            'classes in `XMLDataset` can not be None.'
+        self.cat2label = {
+            cat: i
+            for i, cat in enumerate(self._metainfo['classes'])
+        }
+
+        data_list = []
+        img_ids = list_from_file(self.ann_file, backend_args=self.backend_args)
+
+        # loading process takes around 10 mins
+        if is_main_process():
+            prog_bar = ProgressBar(len(img_ids))
+
+        for img_id in img_ids:
+            raw_img_info = {}
+            raw_img_info['img_id'] = img_id
+            raw_img_info['file_name'] = f'{img_id}.jpg'
+            parsed_data_info = self.parse_data_info(raw_img_info)
+            data_list.append(parsed_data_info)
+
+            if is_main_process():
+                prog_bar.update()
+        return data_list
+
+    def parse_data_info(self, img_info: dict) -> Union[dict, List[dict]]:
+        """Parse raw annotation to target format.
+
+        Args:
+            img_info (dict): Raw image information, usually it includes
+                `img_id`, `file_name`, and `xml_path`.
+
+        Returns:
+            Union[dict, List[dict]]: Parsed annotation.
+        """
+        data_info = {}
+        img_id = img_info['img_id']
+        xml_path = osp.join(self.data_prefix['img'], 'Annotations',
+                            f'{img_id}.xml')
+        data_info['img_id'] = img_id
+        data_info['xml_path'] = xml_path
+
+        # deal with xml file
+        with get_local_path(
+                xml_path, backend_args=self.backend_args) as local_path:
+            raw_ann_info = ET.parse(local_path)
+        root = raw_ann_info.getroot()
+        size = root.find('size')
+        width = int(size.find('width').text)
+        height = int(size.find('height').text)
+        folder = root.find('folder').text
+        img_path = osp.join(self.data_prefix['img'], folder,
+                            img_info['file_name'])
+        data_info['img_path'] = img_path
+
+        data_info['height'] = height
+        data_info['width'] = width
+
+        # Coordinates are in range [0, width - 1 or height - 1]
+        data_info['instances'] = self._parse_instance_info(
+            raw_ann_info, minus_one=False)
+        return data_info
diff --git a/mmdetection/mmdet/datasets/xml_style.py b/mmdetection/mmdet/datasets/xml_style.py
new file mode 100644
index 00000000..06045ea0
--- /dev/null
+++ b/mmdetection/mmdet/datasets/xml_style.py
@@ -0,0 +1,186 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+import xml.etree.ElementTree as ET
+from typing import List, Optional, Union
+
+import mmcv
+from mmengine.fileio import get, get_local_path, list_from_file
+
+from mmdet.registry import DATASETS
+from .base_det_dataset import BaseDetDataset
+
+
+@DATASETS.register_module()
+class XMLDataset(BaseDetDataset):
+    """XML dataset for detection.
+
+    Args:
+        img_subdir (str): Subdir where images are stored. Default: JPEGImages.
+        ann_subdir (str): Subdir where annotations are. Default: Annotations.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+    """
+
+    def __init__(self,
+                 img_subdir: str = 'JPEGImages',
+                 ann_subdir: str = 'Annotations',
+                 **kwargs) -> None:
+        self.img_subdir = img_subdir
+        self.ann_subdir = ann_subdir
+        super().__init__(**kwargs)
+
+    @property
+    def sub_data_root(self) -> str:
+        """Return the sub data root."""
+        return self.data_prefix.get('sub_data_root', '')
+
+    def load_data_list(self) -> List[dict]:
+        """Load annotation from XML style ann_file.
+
+        Returns:
+            list[dict]: Annotation info from XML file.
+        """
+        assert self._metainfo.get('classes', None) is not None, \
+            '`classes` in `XMLDataset` can not be None.'
+        self.cat2label = {
+            cat: i
+            for i, cat in enumerate(self._metainfo['classes'])
+        }
+
+        data_list = []
+        img_ids = list_from_file(self.ann_file, backend_args=self.backend_args)
+        for img_id in img_ids:
+            file_name = osp.join(self.img_subdir, f'{img_id}.jpg')
+            xml_path = osp.join(self.sub_data_root, self.ann_subdir,
+                                f'{img_id}.xml')
+
+            raw_img_info = {}
+            raw_img_info['img_id'] = img_id
+            raw_img_info['file_name'] = file_name
+            raw_img_info['xml_path'] = xml_path
+
+            parsed_data_info = self.parse_data_info(raw_img_info)
+            data_list.append(parsed_data_info)
+        return data_list
+
+    @property
+    def bbox_min_size(self) -> Optional[int]:
+        """Return the minimum size of bounding boxes in the images."""
+        if self.filter_cfg is not None:
+            return self.filter_cfg.get('bbox_min_size', None)
+        else:
+            return None
+
+    def parse_data_info(self, img_info: dict) -> Union[dict, List[dict]]:
+        """Parse raw annotation to target format.
+
+        Args:
+            img_info (dict): Raw image information, usually it includes
+                `img_id`, `file_name`, and `xml_path`.
+
+        Returns:
+            Union[dict, List[dict]]: Parsed annotation.
+        """
+        data_info = {}
+        img_path = osp.join(self.sub_data_root, img_info['file_name'])
+        data_info['img_path'] = img_path
+        data_info['img_id'] = img_info['img_id']
+        data_info['xml_path'] = img_info['xml_path']
+
+        # deal with xml file
+        with get_local_path(
+                img_info['xml_path'],
+                backend_args=self.backend_args) as local_path:
+            raw_ann_info = ET.parse(local_path)
+        root = raw_ann_info.getroot()
+        size = root.find('size')
+        if size is not None:
+            width = int(size.find('width').text)
+            height = int(size.find('height').text)
+        else:
+            img_bytes = get(img_path, backend_args=self.backend_args)
+            img = mmcv.imfrombytes(img_bytes, backend='cv2')
+            height, width = img.shape[:2]
+            del img, img_bytes
+
+        data_info['height'] = height
+        data_info['width'] = width
+
+        data_info['instances'] = self._parse_instance_info(
+            raw_ann_info, minus_one=True)
+
+        return data_info
+
+    def _parse_instance_info(self,
+                             raw_ann_info: ET,
+                             minus_one: bool = True) -> List[dict]:
+        """parse instance information.
+
+        Args:
+            raw_ann_info (ElementTree): ElementTree object.
+            minus_one (bool): Whether to subtract 1 from the coordinates.
+                Defaults to True.
+
+        Returns:
+            List[dict]: List of instances.
+        """
+        instances = []
+        for obj in raw_ann_info.findall('object'):
+            instance = {}
+            name = obj.find('name').text
+            if name not in self._metainfo['classes']:
+                continue
+            difficult = obj.find('difficult')
+            difficult = 0 if difficult is None else int(difficult.text)
+            bnd_box = obj.find('bndbox')
+            bbox = [
+                int(float(bnd_box.find('xmin').text)),
+                int(float(bnd_box.find('ymin').text)),
+                int(float(bnd_box.find('xmax').text)),
+                int(float(bnd_box.find('ymax').text))
+            ]
+
+            # VOC needs to subtract 1 from the coordinates
+            if minus_one:
+                bbox = [x - 1 for x in bbox]
+
+            ignore = False
+            if self.bbox_min_size is not None:
+                assert not self.test_mode
+                w = bbox[2] - bbox[0]
+                h = bbox[3] - bbox[1]
+                if w < self.bbox_min_size or h < self.bbox_min_size:
+                    ignore = True
+            if difficult or ignore:
+                instance['ignore_flag'] = 1
+            else:
+                instance['ignore_flag'] = 0
+            instance['bbox'] = bbox
+            instance['bbox_label'] = self.cat2label[name]
+            instances.append(instance)
+        return instances
+
+    def filter_data(self) -> List[dict]:
+        """Filter annotations according to filter_cfg.
+
+        Returns:
+            List[dict]: Filtered results.
+        """
+        if self.test_mode:
+            return self.data_list
+
+        filter_empty_gt = self.filter_cfg.get('filter_empty_gt', False) \
+            if self.filter_cfg is not None else False
+        min_size = self.filter_cfg.get('min_size', 0) \
+            if self.filter_cfg is not None else 0
+
+        valid_data_infos = []
+        for i, data_info in enumerate(self.data_list):
+            width = data_info['width']
+            height = data_info['height']
+            if filter_empty_gt and len(data_info['instances']) == 0:
+                continue
+            if min(width, height) >= min_size:
+                valid_data_infos.append(data_info)
+
+        return valid_data_infos
diff --git a/mmdetection/mmdet/datasets/youtube_vis_dataset.py b/mmdetection/mmdet/datasets/youtube_vis_dataset.py
new file mode 100644
index 00000000..38c3d390
--- /dev/null
+++ b/mmdetection/mmdet/datasets/youtube_vis_dataset.py
@@ -0,0 +1,52 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import DATASETS
+from .base_video_dataset import BaseVideoDataset
+
+
+@DATASETS.register_module()
+class YouTubeVISDataset(BaseVideoDataset):
+    """YouTube VIS dataset for video instance segmentation.
+
+    Args:
+        dataset_version (str): Select dataset year version.
+    """
+
+    def __init__(self, dataset_version: str, *args, **kwargs):
+        self.set_dataset_classes(dataset_version)
+        super().__init__(*args, **kwargs)
+
+    @classmethod
+    def set_dataset_classes(cls, dataset_version: str) -> None:
+        """Pass the category of the corresponding year to metainfo.
+
+        Args:
+            dataset_version (str): Select dataset year version.
+        """
+        classes_2019_version = ('person', 'giant_panda', 'lizard', 'parrot',
+                                'skateboard', 'sedan', 'ape', 'dog', 'snake',
+                                'monkey', 'hand', 'rabbit', 'duck', 'cat',
+                                'cow', 'fish', 'train', 'horse', 'turtle',
+                                'bear', 'motorbike', 'giraffe', 'leopard',
+                                'fox', 'deer', 'owl', 'surfboard', 'airplane',
+                                'truck', 'zebra', 'tiger', 'elephant',
+                                'snowboard', 'boat', 'shark', 'mouse', 'frog',
+                                'eagle', 'earless_seal', 'tennis_racket')
+
+        classes_2021_version = ('airplane', 'bear', 'bird', 'boat', 'car',
+                                'cat', 'cow', 'deer', 'dog', 'duck',
+                                'earless_seal', 'elephant', 'fish',
+                                'flying_disc', 'fox', 'frog', 'giant_panda',
+                                'giraffe', 'horse', 'leopard', 'lizard',
+                                'monkey', 'motorbike', 'mouse', 'parrot',
+                                'person', 'rabbit', 'shark', 'skateboard',
+                                'snake', 'snowboard', 'squirrel', 'surfboard',
+                                'tennis_racket', 'tiger', 'train', 'truck',
+                                'turtle', 'whale', 'zebra')
+
+        if dataset_version == '2019':
+            cls.METAINFO = dict(classes=classes_2019_version)
+        elif dataset_version == '2021':
+            cls.METAINFO = dict(classes=classes_2021_version)
+        else:
+            raise NotImplementedError('Not supported YouTubeVIS dataset'
+                                      f'version: {dataset_version}')
diff --git a/mmdetection/mmdet/engine/__init__.py b/mmdetection/mmdet/engine/__init__.py
new file mode 100644
index 00000000..c91ace6f
--- /dev/null
+++ b/mmdetection/mmdet/engine/__init__.py
@@ -0,0 +1,5 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .hooks import *  # noqa: F401, F403
+from .optimizers import *  # noqa: F401, F403
+from .runner import *  # noqa: F401, F403
+from .schedulers import *  # noqa: F401, F403
diff --git a/mmdetection/mmdet/engine/hooks/__init__.py b/mmdetection/mmdet/engine/hooks/__init__.py
new file mode 100644
index 00000000..889fa557
--- /dev/null
+++ b/mmdetection/mmdet/engine/hooks/__init__.py
@@ -0,0 +1,21 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .checkloss_hook import CheckInvalidLossHook
+from .mean_teacher_hook import MeanTeacherHook
+from .memory_profiler_hook import MemoryProfilerHook
+from .num_class_check_hook import NumClassCheckHook
+from .pipeline_switch_hook import PipelineSwitchHook
+from .set_epoch_info_hook import SetEpochInfoHook
+from .sync_norm_hook import SyncNormHook
+from .utils import trigger_visualization_hook
+from .visualization_hook import (DetVisualizationHook,
+                                 GroundingVisualizationHook,
+                                 TrackVisualizationHook)
+from .yolox_mode_switch_hook import YOLOXModeSwitchHook
+
+__all__ = [
+    'YOLOXModeSwitchHook', 'SyncNormHook', 'CheckInvalidLossHook',
+    'SetEpochInfoHook', 'MemoryProfilerHook', 'DetVisualizationHook',
+    'NumClassCheckHook', 'MeanTeacherHook', 'trigger_visualization_hook',
+    'PipelineSwitchHook', 'TrackVisualizationHook',
+    'GroundingVisualizationHook'
+]
diff --git a/mmdetection/mmdet/engine/hooks/checkloss_hook.py b/mmdetection/mmdet/engine/hooks/checkloss_hook.py
new file mode 100644
index 00000000..3ebfcd5d
--- /dev/null
+++ b/mmdetection/mmdet/engine/hooks/checkloss_hook.py
@@ -0,0 +1,42 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional
+
+import torch
+from mmengine.hooks import Hook
+from mmengine.runner import Runner
+
+from mmdet.registry import HOOKS
+
+
+@HOOKS.register_module()
+class CheckInvalidLossHook(Hook):
+    """Check invalid loss hook.
+
+    This hook will regularly check whether the loss is valid
+    during training.
+
+    Args:
+        interval (int): Checking interval (every k iterations).
+            Default: 50.
+    """
+
+    def __init__(self, interval: int = 50) -> None:
+        self.interval = interval
+
+    def after_train_iter(self,
+                         runner: Runner,
+                         batch_idx: int,
+                         data_batch: Optional[dict] = None,
+                         outputs: Optional[dict] = None) -> None:
+        """Regularly check whether the loss is valid every n iterations.
+
+        Args:
+            runner (:obj:`Runner`): The runner of the training process.
+            batch_idx (int): The index of the current batch in the train loop.
+            data_batch (dict, Optional): Data from dataloader.
+                Defaults to None.
+            outputs (dict, Optional): Outputs from model. Defaults to None.
+        """
+        if self.every_n_train_iters(runner, self.interval):
+            assert torch.isfinite(outputs['loss']), \
+                runner.logger.info('loss become infinite or NaN!')
diff --git a/mmdetection/mmdet/engine/hooks/mean_teacher_hook.py b/mmdetection/mmdet/engine/hooks/mean_teacher_hook.py
new file mode 100644
index 00000000..b924c0a5
--- /dev/null
+++ b/mmdetection/mmdet/engine/hooks/mean_teacher_hook.py
@@ -0,0 +1,87 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional
+
+import torch.nn as nn
+from mmengine.hooks import Hook
+from mmengine.model import is_model_wrapper
+from mmengine.runner import Runner
+
+from mmdet.registry import HOOKS
+
+
+@HOOKS.register_module()
+class MeanTeacherHook(Hook):
+    """Mean Teacher Hook.
+
+    Mean Teacher is an efficient semi-supervised learning method in
+    `Mean Teacher `_.
+    This method requires two models with exactly the same structure,
+    as the student model and the teacher model, respectively.
+    The student model updates the parameters through gradient descent,
+    and the teacher model updates the parameters through
+    exponential moving average of the student model.
+    Compared with the student model, the teacher model
+    is smoother and accumulates more knowledge.
+
+    Args:
+        momentum (float): The momentum used for updating teacher's parameter.
+            Teacher's parameter are updated with the formula:
+           `teacher = (1-momentum) * teacher + momentum * student`.
+            Defaults to 0.001.
+        interval (int): Update teacher's parameter every interval iteration.
+            Defaults to 1.
+        skip_buffers (bool): Whether to skip the model buffers, such as
+            batchnorm running stats (running_mean, running_var), it does not
+            perform the ema operation. Default to True.
+    """
+
+    def __init__(self,
+                 momentum: float = 0.001,
+                 interval: int = 1,
+                 skip_buffer=True) -> None:
+        assert 0 < momentum < 1
+        self.momentum = momentum
+        self.interval = interval
+        self.skip_buffers = skip_buffer
+
+    def before_train(self, runner: Runner) -> None:
+        """To check that teacher model and student model exist."""
+        model = runner.model
+        if is_model_wrapper(model):
+            model = model.module
+        assert hasattr(model, 'teacher')
+        assert hasattr(model, 'student')
+        # only do it at initial stage
+        if runner.iter == 0:
+            self.momentum_update(model, 1)
+
+    def after_train_iter(self,
+                         runner: Runner,
+                         batch_idx: int,
+                         data_batch: Optional[dict] = None,
+                         outputs: Optional[dict] = None) -> None:
+        """Update teacher's parameter every self.interval iterations."""
+        if (runner.iter + 1) % self.interval != 0:
+            return
+        model = runner.model
+        if is_model_wrapper(model):
+            model = model.module
+        self.momentum_update(model, self.momentum)
+
+    def momentum_update(self, model: nn.Module, momentum: float) -> None:
+        """Compute the moving average of the parameters using exponential
+        moving average."""
+        if self.skip_buffers:
+            for (src_name, src_parm), (dst_name, dst_parm) in zip(
+                    model.student.named_parameters(),
+                    model.teacher.named_parameters()):
+                dst_parm.data.mul_(1 - momentum).add_(
+                    src_parm.data, alpha=momentum)
+        else:
+            for (src_parm,
+                 dst_parm) in zip(model.student.state_dict().values(),
+                                  model.teacher.state_dict().values()):
+                # exclude num_tracking
+                if dst_parm.dtype.is_floating_point:
+                    dst_parm.data.mul_(1 - momentum).add_(
+                        src_parm.data, alpha=momentum)
diff --git a/mmdetection/mmdet/engine/hooks/memory_profiler_hook.py b/mmdetection/mmdet/engine/hooks/memory_profiler_hook.py
new file mode 100644
index 00000000..3dcdcae0
--- /dev/null
+++ b/mmdetection/mmdet/engine/hooks/memory_profiler_hook.py
@@ -0,0 +1,121 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Sequence
+
+from mmengine.hooks import Hook
+from mmengine.runner import Runner
+
+from mmdet.registry import HOOKS
+from mmdet.structures import DetDataSample
+
+
+@HOOKS.register_module()
+class MemoryProfilerHook(Hook):
+    """Memory profiler hook recording memory information including virtual
+    memory, swap memory, and the memory of the current process.
+
+    Args:
+        interval (int): Checking interval (every k iterations).
+            Default: 50.
+    """
+
+    def __init__(self, interval: int = 50) -> None:
+        try:
+            from psutil import swap_memory, virtual_memory
+            self._swap_memory = swap_memory
+            self._virtual_memory = virtual_memory
+        except ImportError:
+            raise ImportError('psutil is not installed, please install it by: '
+                              'pip install psutil')
+
+        try:
+            from memory_profiler import memory_usage
+            self._memory_usage = memory_usage
+        except ImportError:
+            raise ImportError(
+                'memory_profiler is not installed, please install it by: '
+                'pip install memory_profiler')
+
+        self.interval = interval
+
+    def _record_memory_information(self, runner: Runner) -> None:
+        """Regularly record memory information.
+
+        Args:
+            runner (:obj:`Runner`): The runner of the training or evaluation
+                process.
+        """
+        # in Byte
+        virtual_memory = self._virtual_memory()
+        swap_memory = self._swap_memory()
+        # in MB
+        process_memory = self._memory_usage()[0]
+        factor = 1024 * 1024
+        runner.logger.info(
+            'Memory information '
+            'available_memory: '
+            f'{round(virtual_memory.available / factor)} MB, '
+            'used_memory: '
+            f'{round(virtual_memory.used / factor)} MB, '
+            f'memory_utilization: {virtual_memory.percent} %, '
+            'available_swap_memory: '
+            f'{round((swap_memory.total - swap_memory.used) / factor)}'
+            ' MB, '
+            f'used_swap_memory: {round(swap_memory.used / factor)} MB, '
+            f'swap_memory_utilization: {swap_memory.percent} %, '
+            'current_process_memory: '
+            f'{round(process_memory)} MB')
+
+    def after_train_iter(self,
+                         runner: Runner,
+                         batch_idx: int,
+                         data_batch: Optional[dict] = None,
+                         outputs: Optional[dict] = None) -> None:
+        """Regularly record memory information.
+
+        Args:
+            runner (:obj:`Runner`): The runner of the training process.
+            batch_idx (int): The index of the current batch in the train loop.
+            data_batch (dict, optional): Data from dataloader.
+                Defaults to None.
+            outputs (dict, optional): Outputs from model. Defaults to None.
+        """
+        if self.every_n_inner_iters(batch_idx, self.interval):
+            self._record_memory_information(runner)
+
+    def after_val_iter(
+            self,
+            runner: Runner,
+            batch_idx: int,
+            data_batch: Optional[dict] = None,
+            outputs: Optional[Sequence[DetDataSample]] = None) -> None:
+        """Regularly record memory information.
+
+        Args:
+            runner (:obj:`Runner`): The runner of the validation process.
+            batch_idx (int): The index of the current batch in the val loop.
+            data_batch (dict, optional): Data from dataloader.
+                Defaults to None.
+            outputs (Sequence[:obj:`DetDataSample`], optional):
+                Outputs from model. Defaults to None.
+        """
+        if self.every_n_inner_iters(batch_idx, self.interval):
+            self._record_memory_information(runner)
+
+    def after_test_iter(
+            self,
+            runner: Runner,
+            batch_idx: int,
+            data_batch: Optional[dict] = None,
+            outputs: Optional[Sequence[DetDataSample]] = None) -> None:
+        """Regularly record memory information.
+
+        Args:
+            runner (:obj:`Runner`): The runner of the testing process.
+            batch_idx (int): The index of the current batch in the test loop.
+            data_batch (dict, optional): Data from dataloader.
+                Defaults to None.
+            outputs (Sequence[:obj:`DetDataSample`], optional):
+                Outputs from model. Defaults to None.
+        """
+        if self.every_n_inner_iters(batch_idx, self.interval):
+            self._record_memory_information(runner)
diff --git a/mmdetection/mmdet/engine/hooks/num_class_check_hook.py b/mmdetection/mmdet/engine/hooks/num_class_check_hook.py
new file mode 100644
index 00000000..6588473a
--- /dev/null
+++ b/mmdetection/mmdet/engine/hooks/num_class_check_hook.py
@@ -0,0 +1,68 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.cnn import VGG
+from mmengine.hooks import Hook
+from mmengine.runner import Runner
+
+from mmdet.registry import HOOKS
+
+
+@HOOKS.register_module()
+class NumClassCheckHook(Hook):
+    """Check whether the `num_classes` in head matches the length of `classes`
+    in `dataset.metainfo`."""
+
+    def _check_head(self, runner: Runner, mode: str) -> None:
+        """Check whether the `num_classes` in head matches the length of
+        `classes` in `dataset.metainfo`.
+
+        Args:
+            runner (:obj:`Runner`): The runner of the training or evaluation
+                process.
+        """
+        assert mode in ['train', 'val']
+        model = runner.model
+        dataset = runner.train_dataloader.dataset if mode == 'train' else \
+            runner.val_dataloader.dataset
+        if dataset.metainfo.get('classes', None) is None:
+            runner.logger.warning(
+                f'Please set `classes` '
+                f'in the {dataset.__class__.__name__} `metainfo` and'
+                f'check if it is consistent with the `num_classes` '
+                f'of head')
+        else:
+            classes = dataset.metainfo['classes']
+            assert type(classes) is not str, \
+                (f'`classes` in {dataset.__class__.__name__}'
+                 f'should be a tuple of str.'
+                 f'Add comma if number of classes is 1 as '
+                 f'classes = ({classes},)')
+            from mmdet.models.roi_heads.mask_heads import FusedSemanticHead
+            for name, module in model.named_modules():
+                if hasattr(module, 'num_classes') and not name.endswith(
+                        'rpn_head') and not isinstance(
+                            module, (VGG, FusedSemanticHead)):
+                    assert module.num_classes == len(classes), \
+                        (f'The `num_classes` ({module.num_classes}) in '
+                         f'{module.__class__.__name__} of '
+                         f'{model.__class__.__name__} does not matches '
+                         f'the length of `classes` '
+                         f'{len(classes)}) in '
+                         f'{dataset.__class__.__name__}')
+
+    def before_train_epoch(self, runner: Runner) -> None:
+        """Check whether the training dataset is compatible with head.
+
+        Args:
+            runner (:obj:`Runner`): The runner of the training or evaluation
+                process.
+        """
+        self._check_head(runner, 'train')
+
+    def before_val_epoch(self, runner: Runner) -> None:
+        """Check whether the dataset in val epoch is compatible with head.
+
+        Args:
+            runner (:obj:`Runner`): The runner of the training or evaluation
+                process.
+        """
+        self._check_head(runner, 'val')
diff --git a/mmdetection/mmdet/engine/hooks/pipeline_switch_hook.py b/mmdetection/mmdet/engine/hooks/pipeline_switch_hook.py
new file mode 100644
index 00000000..a5abd897
--- /dev/null
+++ b/mmdetection/mmdet/engine/hooks/pipeline_switch_hook.py
@@ -0,0 +1,43 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.transforms import Compose
+from mmengine.hooks import Hook
+
+from mmdet.registry import HOOKS
+
+
+@HOOKS.register_module()
+class PipelineSwitchHook(Hook):
+    """Switch data pipeline at switch_epoch.
+
+    Args:
+        switch_epoch (int): switch pipeline at this epoch.
+        switch_pipeline (list[dict]): the pipeline to switch to.
+    """
+
+    def __init__(self, switch_epoch, switch_pipeline):
+        self.switch_epoch = switch_epoch
+        self.switch_pipeline = switch_pipeline
+        self._restart_dataloader = False
+        self._has_switched = False
+
+    def before_train_epoch(self, runner):
+        """switch pipeline."""
+        epoch = runner.epoch
+        train_loader = runner.train_dataloader
+        if epoch >= self.switch_epoch and not self._has_switched:
+            runner.logger.info('Switch pipeline now!')
+            # The dataset pipeline cannot be updated when persistent_workers
+            # is True, so we need to force the dataloader's multi-process
+            # restart. This is a very hacky approach.
+            train_loader.dataset.pipeline = Compose(self.switch_pipeline)
+            if hasattr(train_loader, 'persistent_workers'
+                       ) and train_loader.persistent_workers is True:
+                train_loader._DataLoader__initialized = False
+                train_loader._iterator = None
+                self._restart_dataloader = True
+            self._has_switched = True
+        else:
+            # Once the restart is complete, we need to restore
+            # the initialization flag.
+            if self._restart_dataloader:
+                train_loader._DataLoader__initialized = True
diff --git a/mmdetection/mmdet/engine/hooks/set_epoch_info_hook.py b/mmdetection/mmdet/engine/hooks/set_epoch_info_hook.py
new file mode 100644
index 00000000..183f3167
--- /dev/null
+++ b/mmdetection/mmdet/engine/hooks/set_epoch_info_hook.py
@@ -0,0 +1,17 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.hooks import Hook
+from mmengine.model.wrappers import is_model_wrapper
+
+from mmdet.registry import HOOKS
+
+
+@HOOKS.register_module()
+class SetEpochInfoHook(Hook):
+    """Set runner's epoch information to the model."""
+
+    def before_train_epoch(self, runner):
+        epoch = runner.epoch
+        model = runner.model
+        if is_model_wrapper(model):
+            model = model.module
+        model.set_epoch(epoch)
diff --git a/mmdetection/mmdet/engine/hooks/sync_norm_hook.py b/mmdetection/mmdet/engine/hooks/sync_norm_hook.py
new file mode 100644
index 00000000..a1734380
--- /dev/null
+++ b/mmdetection/mmdet/engine/hooks/sync_norm_hook.py
@@ -0,0 +1,37 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from collections import OrderedDict
+
+from mmengine.dist import get_dist_info
+from mmengine.hooks import Hook
+from torch import nn
+
+from mmdet.registry import HOOKS
+from mmdet.utils import all_reduce_dict
+
+
+def get_norm_states(module: nn.Module) -> OrderedDict:
+    """Get the state_dict of batch norms in the module."""
+    async_norm_states = OrderedDict()
+    for name, child in module.named_modules():
+        if isinstance(child, nn.modules.batchnorm._NormBase):
+            for k, v in child.state_dict().items():
+                async_norm_states['.'.join([name, k])] = v
+    return async_norm_states
+
+
+@HOOKS.register_module()
+class SyncNormHook(Hook):
+    """Synchronize Norm states before validation, currently used in YOLOX."""
+
+    def before_val_epoch(self, runner):
+        """Synchronizing norm."""
+        module = runner.model
+        _, world_size = get_dist_info()
+        if world_size == 1:
+            return
+        norm_states = get_norm_states(module)
+        if len(norm_states) == 0:
+            return
+        # TODO: use `all_reduce_dict` in mmengine
+        norm_states = all_reduce_dict(norm_states, op='mean')
+        module.load_state_dict(norm_states, strict=False)
diff --git a/mmdetection/mmdet/engine/hooks/utils.py b/mmdetection/mmdet/engine/hooks/utils.py
new file mode 100644
index 00000000..d267cfe7
--- /dev/null
+++ b/mmdetection/mmdet/engine/hooks/utils.py
@@ -0,0 +1,19 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+def trigger_visualization_hook(cfg, args):
+    default_hooks = cfg.default_hooks
+    if 'visualization' in default_hooks:
+        visualization_hook = default_hooks['visualization']
+        # Turn on visualization
+        visualization_hook['draw'] = True
+        if args.show:
+            visualization_hook['show'] = True
+            visualization_hook['wait_time'] = args.wait_time
+        if args.show_dir:
+            visualization_hook['test_out_dir'] = args.show_dir
+    else:
+        raise RuntimeError(
+            'VisualizationHook must be included in default_hooks.'
+            'refer to usage '
+            '"visualization=dict(type=\'VisualizationHook\')"')
+
+    return cfg
diff --git a/mmdetection/mmdet/engine/hooks/visualization_hook.py b/mmdetection/mmdet/engine/hooks/visualization_hook.py
new file mode 100644
index 00000000..3408186b
--- /dev/null
+++ b/mmdetection/mmdet/engine/hooks/visualization_hook.py
@@ -0,0 +1,515 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+import warnings
+from typing import Optional, Sequence
+
+import mmcv
+import numpy as np
+from mmengine.fileio import get
+from mmengine.hooks import Hook
+from mmengine.runner import Runner
+from mmengine.utils import mkdir_or_exist
+from mmengine.visualization import Visualizer
+
+from mmdet.datasets.samplers import TrackImgSampler
+from mmdet.registry import HOOKS
+from mmdet.structures import DetDataSample, TrackDataSample
+from mmdet.structures.bbox import BaseBoxes
+from mmdet.visualization.palette import _get_adaptive_scales
+
+
+@HOOKS.register_module()
+class DetVisualizationHook(Hook):
+    """Detection Visualization Hook. Used to visualize validation and testing
+    process prediction results.
+
+    In the testing phase:
+
+    1. If ``show`` is True, it means that only the prediction results are
+        visualized without storing data, so ``vis_backends`` needs to
+        be excluded.
+    2. If ``test_out_dir`` is specified, it means that the prediction results
+        need to be saved to ``test_out_dir``. In order to avoid vis_backends
+        also storing data, so ``vis_backends`` needs to be excluded.
+    3. ``vis_backends`` takes effect if the user does not specify ``show``
+        and `test_out_dir``. You can set ``vis_backends`` to WandbVisBackend or
+        TensorboardVisBackend to store the prediction result in Wandb or
+        Tensorboard.
+
+    Args:
+        draw (bool): whether to draw prediction results. If it is False,
+            it means that no drawing will be done. Defaults to False.
+        interval (int): The interval of visualization. Defaults to 50.
+        score_thr (float): The threshold to visualize the bboxes
+            and masks. Defaults to 0.3.
+        show (bool): Whether to display the drawn image. Default to False.
+        wait_time (float): The interval of show (s). Defaults to 0.
+        test_out_dir (str, optional): directory where painted images
+            will be saved in testing process.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+    """
+
+    def __init__(self,
+                 draw: bool = False,
+                 interval: int = 50,
+                 score_thr: float = 0.3,
+                 show: bool = False,
+                 wait_time: float = 0.,
+                 test_out_dir: Optional[str] = None,
+                 backend_args: dict = None):
+        self._visualizer: Visualizer = Visualizer.get_current_instance()
+        self.interval = interval
+        self.score_thr = score_thr
+        self.show = show
+        if self.show:
+            # No need to think about vis backends.
+            self._visualizer._vis_backends = {}
+            warnings.warn('The show is True, it means that only '
+                          'the prediction results are visualized '
+                          'without storing data, so vis_backends '
+                          'needs to be excluded.')
+
+        self.wait_time = wait_time
+        self.backend_args = backend_args
+        self.draw = draw
+        self.test_out_dir = test_out_dir
+        self._test_index = 0
+
+    def after_val_iter(self, runner: Runner, batch_idx: int, data_batch: dict,
+                       outputs: Sequence[DetDataSample]) -> None:
+        """Run after every ``self.interval`` validation iterations.
+
+        Args:
+            runner (:obj:`Runner`): The runner of the validation process.
+            batch_idx (int): The index of the current batch in the val loop.
+            data_batch (dict): Data from dataloader.
+            outputs (Sequence[:obj:`DetDataSample`]]): A batch of data samples
+                that contain annotations and predictions.
+        """
+        if self.draw is False:
+            return
+
+        # There is no guarantee that the same batch of images
+        # is visualized for each evaluation.
+        total_curr_iter = runner.iter + batch_idx
+
+        # Visualize only the first data
+        img_path = outputs[0].img_path
+        img_bytes = get(img_path, backend_args=self.backend_args)
+        img = mmcv.imfrombytes(img_bytes, channel_order='rgb')
+
+        if total_curr_iter % self.interval == 0:
+            self._visualizer.add_datasample(
+                osp.basename(img_path) if self.show else 'val_img',
+                img,
+                data_sample=outputs[0],
+                show=self.show,
+                wait_time=self.wait_time,
+                pred_score_thr=self.score_thr,
+                step=total_curr_iter)
+
+    def after_test_iter(self, runner: Runner, batch_idx: int, data_batch: dict,
+                        outputs: Sequence[DetDataSample]) -> None:
+        """Run after every testing iterations.
+
+        Args:
+            runner (:obj:`Runner`): The runner of the testing process.
+            batch_idx (int): The index of the current batch in the val loop.
+            data_batch (dict): Data from dataloader.
+            outputs (Sequence[:obj:`DetDataSample`]): A batch of data samples
+                that contain annotations and predictions.
+        """
+        if self.draw is False:
+            return
+
+        if self.test_out_dir is not None:
+            self.test_out_dir = osp.join(runner.work_dir, runner.timestamp,
+                                         self.test_out_dir)
+            mkdir_or_exist(self.test_out_dir)
+
+        for data_sample in outputs:
+            self._test_index += 1
+
+            img_path = data_sample.img_path
+            img_bytes = get(img_path, backend_args=self.backend_args)
+            img = mmcv.imfrombytes(img_bytes, channel_order='rgb')
+
+            out_file = None
+            if self.test_out_dir is not None:
+                out_file = osp.basename(img_path)
+                out_file = osp.join(self.test_out_dir, out_file)
+
+            self._visualizer.add_datasample(
+                osp.basename(img_path) if self.show else 'test_img',
+                img,
+                data_sample=data_sample,
+                show=self.show,
+                wait_time=self.wait_time,
+                pred_score_thr=self.score_thr,
+                out_file=out_file,
+                step=self._test_index)
+
+
+@HOOKS.register_module()
+class TrackVisualizationHook(Hook):
+    """Tracking Visualization Hook. Used to visualize validation and testing
+    process prediction results.
+
+    In the testing phase:
+
+    1. If ``show`` is True, it means that only the prediction results are
+        visualized without storing data, so ``vis_backends`` needs to
+        be excluded.
+    2. If ``test_out_dir`` is specified, it means that the prediction results
+        need to be saved to ``test_out_dir``. In order to avoid vis_backends
+        also storing data, so ``vis_backends`` needs to be excluded.
+    3. ``vis_backends`` takes effect if the user does not specify ``show``
+        and `test_out_dir``. You can set ``vis_backends`` to WandbVisBackend or
+        TensorboardVisBackend to store the prediction result in Wandb or
+        Tensorboard.
+
+    Args:
+        draw (bool): whether to draw prediction results. If it is False,
+            it means that no drawing will be done. Defaults to False.
+        frame_interval (int): The interval of visualization. Defaults to 30.
+        score_thr (float): The threshold to visualize the bboxes
+            and masks. Defaults to 0.3.
+        show (bool): Whether to display the drawn image. Default to False.
+        wait_time (float): The interval of show (s). Defaults to 0.
+        test_out_dir (str, optional): directory where painted images
+            will be saved in testing process.
+        backend_args (dict): Arguments to instantiate a file client.
+            Defaults to ``None``.
+    """
+
+    def __init__(self,
+                 draw: bool = False,
+                 frame_interval: int = 30,
+                 score_thr: float = 0.3,
+                 show: bool = False,
+                 wait_time: float = 0.,
+                 test_out_dir: Optional[str] = None,
+                 backend_args: dict = None) -> None:
+        self._visualizer: Visualizer = Visualizer.get_current_instance()
+        self.frame_interval = frame_interval
+        self.score_thr = score_thr
+        self.show = show
+        if self.show:
+            # No need to think about vis backends.
+            self._visualizer._vis_backends = {}
+            warnings.warn('The show is True, it means that only '
+                          'the prediction results are visualized '
+                          'without storing data, so vis_backends '
+                          'needs to be excluded.')
+
+        self.wait_time = wait_time
+        self.backend_args = backend_args
+        self.draw = draw
+        self.test_out_dir = test_out_dir
+        self.image_idx = 0
+
+    def after_val_iter(self, runner: Runner, batch_idx: int, data_batch: dict,
+                       outputs: Sequence[TrackDataSample]) -> None:
+        """Run after every ``self.interval`` validation iteration.
+
+        Args:
+            runner (:obj:`Runner`): The runner of the validation process.
+            batch_idx (int): The index of the current batch in the val loop.
+            data_batch (dict): Data from dataloader.
+            outputs (Sequence[:obj:`TrackDataSample`]): Outputs from model.
+        """
+        if self.draw is False:
+            return
+
+        assert len(outputs) == 1, \
+            'only batch_size=1 is supported while validating.'
+
+        sampler = runner.val_dataloader.sampler
+        if isinstance(sampler, TrackImgSampler):
+            if self.every_n_inner_iters(batch_idx, self.frame_interval):
+                total_curr_iter = runner.iter + batch_idx
+                track_data_sample = outputs[0]
+                self.visualize_single_image(track_data_sample[0],
+                                            total_curr_iter)
+        else:
+            # video visualization DefaultSampler
+            if self.every_n_inner_iters(batch_idx, 1):
+                track_data_sample = outputs[0]
+                video_length = len(track_data_sample)
+
+                for frame_id in range(video_length):
+                    if frame_id % self.frame_interval == 0:
+                        total_curr_iter = runner.iter + self.image_idx + \
+                                          frame_id
+                        img_data_sample = track_data_sample[frame_id]
+                        self.visualize_single_image(img_data_sample,
+                                                    total_curr_iter)
+                self.image_idx = self.image_idx + video_length
+
+    def after_test_iter(self, runner: Runner, batch_idx: int, data_batch: dict,
+                        outputs: Sequence[TrackDataSample]) -> None:
+        """Run after every testing iteration.
+
+        Args:
+            runner (:obj:`Runner`): The runner of the testing process.
+            batch_idx (int): The index of the current batch in the test loop.
+            data_batch (dict): Data from dataloader.
+            outputs (Sequence[:obj:`TrackDataSample`]): Outputs from model.
+        """
+        if self.draw is False:
+            return
+
+        assert len(outputs) == 1, \
+            'only batch_size=1 is supported while testing.'
+
+        if self.test_out_dir is not None:
+            self.test_out_dir = osp.join(runner.work_dir, runner.timestamp,
+                                         self.test_out_dir)
+            mkdir_or_exist(self.test_out_dir)
+
+        sampler = runner.test_dataloader.sampler
+        if isinstance(sampler, TrackImgSampler):
+            if self.every_n_inner_iters(batch_idx, self.frame_interval):
+                track_data_sample = outputs[0]
+                self.visualize_single_image(track_data_sample[0], batch_idx)
+        else:
+            # video visualization DefaultSampler
+            if self.every_n_inner_iters(batch_idx, 1):
+                track_data_sample = outputs[0]
+                video_length = len(track_data_sample)
+
+                for frame_id in range(video_length):
+                    if frame_id % self.frame_interval == 0:
+                        img_data_sample = track_data_sample[frame_id]
+                        self.visualize_single_image(img_data_sample,
+                                                    self.image_idx + frame_id)
+                self.image_idx = self.image_idx + video_length
+
+    def visualize_single_image(self, img_data_sample: DetDataSample,
+                               step: int) -> None:
+        """
+        Args:
+            img_data_sample (DetDataSample): single image output.
+            step (int): The index of the current image.
+        """
+        img_path = img_data_sample.img_path
+        img_bytes = get(img_path, backend_args=self.backend_args)
+        img = mmcv.imfrombytes(img_bytes, channel_order='rgb')
+
+        out_file = None
+        if self.test_out_dir is not None:
+            video_name = img_path.split('/')[-3]
+            mkdir_or_exist(osp.join(self.test_out_dir, video_name))
+            out_file = osp.join(self.test_out_dir, video_name,
+                                osp.basename(img_path))
+
+        self._visualizer.add_datasample(
+            osp.basename(img_path) if self.show else 'test_img',
+            img,
+            data_sample=img_data_sample,
+            show=self.show,
+            wait_time=self.wait_time,
+            pred_score_thr=self.score_thr,
+            out_file=out_file,
+            step=step)
+
+
+def draw_all_character(visualizer, characters, w):
+    start_index = 2
+    y_index = 5
+    for char in characters:
+        if isinstance(char, str):
+            visualizer.draw_texts(
+                str(char),
+                positions=np.array([start_index, y_index]),
+                colors=(0, 0, 0),
+                font_families='monospace')
+            start_index += len(char) * 8
+        else:
+            visualizer.draw_texts(
+                str(char[0]),
+                positions=np.array([start_index, y_index]),
+                colors=char[1],
+                font_families='monospace')
+            start_index += len(char[0]) * 8
+
+        if start_index > w - 10:
+            start_index = 2
+            y_index += 15
+
+    drawn_text = visualizer.get_image()
+    return drawn_text
+
+
+@HOOKS.register_module()
+class GroundingVisualizationHook(DetVisualizationHook):
+
+    def after_test_iter(self, runner: Runner, batch_idx: int, data_batch: dict,
+                        outputs: Sequence[DetDataSample]) -> None:
+        """Run after every testing iterations.
+
+        Args:
+            runner (:obj:`Runner`): The runner of the testing process.
+            batch_idx (int): The index of the current batch in the val loop.
+            data_batch (dict): Data from dataloader.
+            outputs (Sequence[:obj:`DetDataSample`]): A batch of data samples
+                that contain annotations and predictions.
+        """
+        if self.draw is False:
+            return
+
+        if self.test_out_dir is not None:
+            self.test_out_dir = osp.join(runner.work_dir, runner.timestamp,
+                                         self.test_out_dir)
+            mkdir_or_exist(self.test_out_dir)
+
+        for data_sample in outputs:
+            data_sample = data_sample.cpu()
+
+            self._test_index += 1
+
+            img_path = data_sample.img_path
+            img_bytes = get(img_path, backend_args=self.backend_args)
+            img = mmcv.imfrombytes(img_bytes, channel_order='rgb')
+
+            out_file = None
+            if self.test_out_dir is not None:
+                out_file = osp.basename(img_path)
+                out_file = osp.join(self.test_out_dir, out_file)
+
+            text = data_sample.text
+            if isinstance(text, str):  # VG
+                gt_instances = data_sample.gt_instances
+                tokens_positive = data_sample.tokens_positive
+                if 'phrase_ids' in data_sample:
+                    # flickr30k
+                    gt_labels = data_sample.phrase_ids
+                else:
+                    gt_labels = gt_instances.labels
+                gt_bboxes = gt_instances.get('bboxes', None)
+                if gt_bboxes is not None and isinstance(gt_bboxes, BaseBoxes):
+                    gt_instances.bboxes = gt_bboxes.tensor
+                print(gt_labels, tokens_positive, gt_bboxes, img_path)
+                pred_instances = data_sample.pred_instances
+                pred_instances = pred_instances[
+                    pred_instances.scores > self.score_thr]
+                pred_labels = pred_instances.labels
+                pred_bboxes = pred_instances.bboxes
+                pred_scores = pred_instances.scores
+
+                max_label = 0
+                if len(gt_labels) > 0:
+                    max_label = max(gt_labels)
+                if len(pred_labels) > 0:
+                    max_label = max(max(pred_labels), max_label)
+
+                max_label = int(max(max_label, 0))
+                palette = np.random.randint(0, 256, size=(max_label + 1, 3))
+                bbox_palette = [tuple(c) for c in palette]
+                # bbox_palette = get_palette('random', max_label + 1)
+                if len(gt_labels) >= len(pred_labels):
+                    colors = [bbox_palette[label] for label in gt_labels]
+                else:
+                    colors = [bbox_palette[label] for label in pred_labels]
+
+                self._visualizer.set_image(img)
+
+                for label, bbox, color in zip(gt_labels, gt_bboxes, colors):
+                    self._visualizer.draw_bboxes(
+                        bbox, edge_colors=color, face_colors=color, alpha=0.3)
+                    self._visualizer.draw_bboxes(
+                        bbox, edge_colors=color, alpha=1)
+
+                drawn_img = self._visualizer.get_image()
+
+                new_image = np.ones(
+                    (100, img.shape[1], 3), dtype=np.uint8) * 255
+                self._visualizer.set_image(new_image)
+
+                if tokens_positive == -1:  # REC
+                    gt_tokens_positive = [[]]
+                else:  # Phrase Grounding
+                    gt_tokens_positive = [
+                        tokens_positive[label] for label in gt_labels
+                    ]
+                split_by_character = [char for char in text]
+                characters = []
+                start_index = 0
+                end_index = 0
+                for w in split_by_character:
+                    end_index += len(w)
+                    is_find = False
+                    for i, positive in enumerate(gt_tokens_positive):
+                        for p in positive:
+                            if start_index >= p[0] and end_index <= p[1]:
+                                characters.append([w, colors[i]])
+                                is_find = True
+                                break
+                        if is_find:
+                            break
+                    if not is_find:
+                        characters.append([w, (0, 0, 0)])
+                    start_index = end_index
+
+                drawn_text = draw_all_character(self._visualizer, characters,
+                                                img.shape[1])
+                drawn_gt_img = np.concatenate((drawn_img, drawn_text), axis=0)
+
+                self._visualizer.set_image(img)
+
+                for label, bbox, color in zip(pred_labels, pred_bboxes,
+                                              colors):
+                    self._visualizer.draw_bboxes(
+                        bbox, edge_colors=color, face_colors=color, alpha=0.3)
+                    self._visualizer.draw_bboxes(
+                        bbox, edge_colors=color, alpha=1)
+                print(pred_labels, pred_bboxes, pred_scores, colors)
+                areas = (pred_bboxes[:, 3] - pred_bboxes[:, 1]) * (
+                    pred_bboxes[:, 2] - pred_bboxes[:, 0])
+                scales = _get_adaptive_scales(areas)
+                score = [str(round(s.item(), 2)) for s in pred_scores]
+                font_sizes = [int(13 * scales[i]) for i in range(len(scales))]
+                self._visualizer.draw_texts(
+                    score,
+                    pred_bboxes[:, :2].int(),
+                    colors=(255, 255, 255),
+                    font_sizes=font_sizes,
+                    bboxes=[{
+                        'facecolor': 'black',
+                        'alpha': 0.8,
+                        'pad': 0.7,
+                        'edgecolor': 'none'
+                    }] * len(pred_bboxes))
+
+                drawn_img = self._visualizer.get_image()
+
+                new_image = np.ones(
+                    (100, img.shape[1], 3), dtype=np.uint8) * 255
+                self._visualizer.set_image(new_image)
+                drawn_text = draw_all_character(self._visualizer, characters,
+                                                img.shape[1])
+                drawn_pred_img = np.concatenate((drawn_img, drawn_text),
+                                                axis=0)
+                drawn_img = np.concatenate((drawn_gt_img, drawn_pred_img),
+                                           axis=1)
+
+                if self.show:
+                    self._visualizer.show(
+                        drawn_img,
+                        win_name=osp.basename(img_path),
+                        wait_time=self.wait_time)
+                if out_file is not None:
+                    mmcv.imwrite(drawn_img[..., ::-1], out_file)
+                else:
+                    self.add_image('test_img', drawn_img, self._test_index)
+            else:  # OD
+                self._visualizer.add_datasample(
+                    osp.basename(img_path) if self.show else 'test_img',
+                    img,
+                    data_sample=data_sample,
+                    show=self.show,
+                    wait_time=self.wait_time,
+                    pred_score_thr=self.score_thr,
+                    out_file=out_file,
+                    step=self._test_index)
diff --git a/mmdetection/mmdet/engine/hooks/yolox_mode_switch_hook.py b/mmdetection/mmdet/engine/hooks/yolox_mode_switch_hook.py
new file mode 100644
index 00000000..05a2c690
--- /dev/null
+++ b/mmdetection/mmdet/engine/hooks/yolox_mode_switch_hook.py
@@ -0,0 +1,66 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Sequence
+
+from mmengine.hooks import Hook
+from mmengine.model import is_model_wrapper
+
+from mmdet.registry import HOOKS
+
+
+@HOOKS.register_module()
+class YOLOXModeSwitchHook(Hook):
+    """Switch the mode of YOLOX during training.
+
+    This hook turns off the mosaic and mixup data augmentation and switches
+    to use L1 loss in bbox_head.
+
+    Args:
+        num_last_epochs (int): The number of latter epochs in the end of the
+            training to close the data augmentation and switch to L1 loss.
+            Defaults to 15.
+       skip_type_keys (Sequence[str], optional): Sequence of type string to be
+            skip pipeline. Defaults to ('Mosaic', 'RandomAffine', 'MixUp').
+    """
+
+    def __init__(
+        self,
+        num_last_epochs: int = 15,
+        skip_type_keys: Sequence[str] = ('Mosaic', 'RandomAffine', 'MixUp')
+    ) -> None:
+        self.num_last_epochs = num_last_epochs
+        self.skip_type_keys = skip_type_keys
+        self._restart_dataloader = False
+        self._has_switched = False
+
+    def before_train_epoch(self, runner) -> None:
+        """Close mosaic and mixup augmentation and switches to use L1 loss."""
+        epoch = runner.epoch
+        train_loader = runner.train_dataloader
+        model = runner.model
+        # TODO: refactor after mmengine using model wrapper
+        if is_model_wrapper(model):
+            model = model.module
+        epoch_to_be_switched = ((epoch + 1) >=
+                                runner.max_epochs - self.num_last_epochs)
+        if epoch_to_be_switched and not self._has_switched:
+            runner.logger.info('No mosaic and mixup aug now!')
+            # The dataset pipeline cannot be updated when persistent_workers
+            # is True, so we need to force the dataloader's multi-process
+            # restart. This is a very hacky approach.
+            train_loader.dataset.update_skip_type_keys(self.skip_type_keys)
+            if hasattr(train_loader, 'persistent_workers'
+                       ) and train_loader.persistent_workers is True:
+                train_loader._DataLoader__initialized = False
+                train_loader._iterator = None
+                self._restart_dataloader = True
+            runner.logger.info('Add additional L1 loss now!')
+            if hasattr(model, 'detector'):
+                model.detector.bbox_head.use_l1 = True
+            else:
+                model.bbox_head.use_l1 = True
+            self._has_switched = True
+        else:
+            # Once the restart is complete, we need to restore
+            # the initialization flag.
+            if self._restart_dataloader:
+                train_loader._DataLoader__initialized = True
diff --git a/mmdetection/mmdet/engine/optimizers/__init__.py b/mmdetection/mmdet/engine/optimizers/__init__.py
new file mode 100644
index 00000000..83db069e
--- /dev/null
+++ b/mmdetection/mmdet/engine/optimizers/__init__.py
@@ -0,0 +1,5 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .layer_decay_optimizer_constructor import \
+    LearningRateDecayOptimizerConstructor
+
+__all__ = ['LearningRateDecayOptimizerConstructor']
diff --git a/mmdetection/mmdet/engine/optimizers/layer_decay_optimizer_constructor.py b/mmdetection/mmdet/engine/optimizers/layer_decay_optimizer_constructor.py
new file mode 100644
index 00000000..73028a0a
--- /dev/null
+++ b/mmdetection/mmdet/engine/optimizers/layer_decay_optimizer_constructor.py
@@ -0,0 +1,158 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import json
+from typing import List
+
+import torch.nn as nn
+from mmengine.dist import get_dist_info
+from mmengine.logging import MMLogger
+from mmengine.optim import DefaultOptimWrapperConstructor
+
+from mmdet.registry import OPTIM_WRAPPER_CONSTRUCTORS
+
+
+def get_layer_id_for_convnext(var_name, max_layer_id):
+    """Get the layer id to set the different learning rates in ``layer_wise``
+    decay_type.
+
+    Args:
+        var_name (str): The key of the model.
+        max_layer_id (int): Maximum layer id.
+
+    Returns:
+        int: The id number corresponding to different learning rate in
+        ``LearningRateDecayOptimizerConstructor``.
+    """
+
+    if var_name in ('backbone.cls_token', 'backbone.mask_token',
+                    'backbone.pos_embed'):
+        return 0
+    elif var_name.startswith('backbone.downsample_layers'):
+        stage_id = int(var_name.split('.')[2])
+        if stage_id == 0:
+            layer_id = 0
+        elif stage_id == 1:
+            layer_id = 2
+        elif stage_id == 2:
+            layer_id = 3
+        elif stage_id == 3:
+            layer_id = max_layer_id
+        return layer_id
+    elif var_name.startswith('backbone.stages'):
+        stage_id = int(var_name.split('.')[2])
+        block_id = int(var_name.split('.')[3])
+        if stage_id == 0:
+            layer_id = 1
+        elif stage_id == 1:
+            layer_id = 2
+        elif stage_id == 2:
+            layer_id = 3 + block_id // 3
+        elif stage_id == 3:
+            layer_id = max_layer_id
+        return layer_id
+    else:
+        return max_layer_id + 1
+
+
+def get_stage_id_for_convnext(var_name, max_stage_id):
+    """Get the stage id to set the different learning rates in ``stage_wise``
+    decay_type.
+
+    Args:
+        var_name (str): The key of the model.
+        max_stage_id (int): Maximum stage id.
+
+    Returns:
+        int: The id number corresponding to different learning rate in
+        ``LearningRateDecayOptimizerConstructor``.
+    """
+
+    if var_name in ('backbone.cls_token', 'backbone.mask_token',
+                    'backbone.pos_embed'):
+        return 0
+    elif var_name.startswith('backbone.downsample_layers'):
+        return 0
+    elif var_name.startswith('backbone.stages'):
+        stage_id = int(var_name.split('.')[2])
+        return stage_id + 1
+    else:
+        return max_stage_id - 1
+
+
+@OPTIM_WRAPPER_CONSTRUCTORS.register_module()
+class LearningRateDecayOptimizerConstructor(DefaultOptimWrapperConstructor):
+    # Different learning rates are set for different layers of backbone.
+    # Note: Currently, this optimizer constructor is built for ConvNeXt.
+
+    def add_params(self, params: List[dict], module: nn.Module,
+                   **kwargs) -> None:
+        """Add all parameters of module to the params list.
+
+        The parameters of the given module will be added to the list of param
+        groups, with specific rules defined by paramwise_cfg.
+
+        Args:
+            params (list[dict]): A list of param groups, it will be modified
+                in place.
+            module (nn.Module): The module to be added.
+        """
+        logger = MMLogger.get_current_instance()
+
+        parameter_groups = {}
+        logger.info(f'self.paramwise_cfg is {self.paramwise_cfg}')
+        num_layers = self.paramwise_cfg.get('num_layers') + 2
+        decay_rate = self.paramwise_cfg.get('decay_rate')
+        decay_type = self.paramwise_cfg.get('decay_type', 'layer_wise')
+        logger.info('Build LearningRateDecayOptimizerConstructor  '
+                    f'{decay_type} {decay_rate} - {num_layers}')
+        weight_decay = self.base_wd
+        for name, param in module.named_parameters():
+            if not param.requires_grad:
+                continue  # frozen weights
+            if len(param.shape) == 1 or name.endswith('.bias') or name in (
+                    'pos_embed', 'cls_token'):
+                group_name = 'no_decay'
+                this_weight_decay = 0.
+            else:
+                group_name = 'decay'
+                this_weight_decay = weight_decay
+            if 'layer_wise' in decay_type:
+                if 'ConvNeXt' in module.backbone.__class__.__name__:
+                    layer_id = get_layer_id_for_convnext(
+                        name, self.paramwise_cfg.get('num_layers'))
+                    logger.info(f'set param {name} as id {layer_id}')
+                else:
+                    raise NotImplementedError()
+            elif decay_type == 'stage_wise':
+                if 'ConvNeXt' in module.backbone.__class__.__name__:
+                    layer_id = get_stage_id_for_convnext(name, num_layers)
+                    logger.info(f'set param {name} as id {layer_id}')
+                else:
+                    raise NotImplementedError()
+            group_name = f'layer_{layer_id}_{group_name}'
+
+            if group_name not in parameter_groups:
+                scale = decay_rate**(num_layers - layer_id - 1)
+
+                parameter_groups[group_name] = {
+                    'weight_decay': this_weight_decay,
+                    'params': [],
+                    'param_names': [],
+                    'lr_scale': scale,
+                    'group_name': group_name,
+                    'lr': scale * self.base_lr,
+                }
+
+            parameter_groups[group_name]['params'].append(param)
+            parameter_groups[group_name]['param_names'].append(name)
+        rank, _ = get_dist_info()
+        if rank == 0:
+            to_display = {}
+            for key in parameter_groups:
+                to_display[key] = {
+                    'param_names': parameter_groups[key]['param_names'],
+                    'lr_scale': parameter_groups[key]['lr_scale'],
+                    'lr': parameter_groups[key]['lr'],
+                    'weight_decay': parameter_groups[key]['weight_decay'],
+                }
+            logger.info(f'Param groups = {json.dumps(to_display, indent=2)}')
+        params.extend(parameter_groups.values())
diff --git a/mmdetection/mmdet/engine/runner/__init__.py b/mmdetection/mmdet/engine/runner/__init__.py
new file mode 100644
index 00000000..e8bcce44
--- /dev/null
+++ b/mmdetection/mmdet/engine/runner/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .loops import TeacherStudentValLoop
+
+__all__ = ['TeacherStudentValLoop']
diff --git a/mmdetection/mmdet/engine/runner/loops.py b/mmdetection/mmdet/engine/runner/loops.py
new file mode 100644
index 00000000..afe53afa
--- /dev/null
+++ b/mmdetection/mmdet/engine/runner/loops.py
@@ -0,0 +1,38 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.model import is_model_wrapper
+from mmengine.runner import ValLoop
+
+from mmdet.registry import LOOPS
+
+
+@LOOPS.register_module()
+class TeacherStudentValLoop(ValLoop):
+    """Loop for validation of model teacher and student."""
+
+    def run(self):
+        """Launch validation for model teacher and student."""
+        self.runner.call_hook('before_val')
+        self.runner.call_hook('before_val_epoch')
+        self.runner.model.eval()
+
+        model = self.runner.model
+        if is_model_wrapper(model):
+            model = model.module
+        assert hasattr(model, 'teacher')
+        assert hasattr(model, 'student')
+
+        predict_on = model.semi_test_cfg.get('predict_on', None)
+        multi_metrics = dict()
+        for _predict_on in ['teacher', 'student']:
+            model.semi_test_cfg['predict_on'] = _predict_on
+            for idx, data_batch in enumerate(self.dataloader):
+                self.run_iter(idx, data_batch)
+            # compute metrics
+            metrics = self.evaluator.evaluate(len(self.dataloader.dataset))
+            multi_metrics.update(
+                {'/'.join((_predict_on, k)): v
+                 for k, v in metrics.items()})
+        model.semi_test_cfg['predict_on'] = predict_on
+
+        self.runner.call_hook('after_val_epoch', metrics=multi_metrics)
+        self.runner.call_hook('after_val')
diff --git a/mmdetection/mmdet/engine/schedulers/__init__.py b/mmdetection/mmdet/engine/schedulers/__init__.py
new file mode 100644
index 00000000..01261646
--- /dev/null
+++ b/mmdetection/mmdet/engine/schedulers/__init__.py
@@ -0,0 +1,8 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .quadratic_warmup import (QuadraticWarmupLR, QuadraticWarmupMomentum,
+                               QuadraticWarmupParamScheduler)
+
+__all__ = [
+    'QuadraticWarmupParamScheduler', 'QuadraticWarmupMomentum',
+    'QuadraticWarmupLR'
+]
diff --git a/mmdetection/mmdet/engine/schedulers/quadratic_warmup.py b/mmdetection/mmdet/engine/schedulers/quadratic_warmup.py
new file mode 100644
index 00000000..639b4785
--- /dev/null
+++ b/mmdetection/mmdet/engine/schedulers/quadratic_warmup.py
@@ -0,0 +1,131 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.optim.scheduler.lr_scheduler import LRSchedulerMixin
+from mmengine.optim.scheduler.momentum_scheduler import MomentumSchedulerMixin
+from mmengine.optim.scheduler.param_scheduler import INF, _ParamScheduler
+from torch.optim import Optimizer
+
+from mmdet.registry import PARAM_SCHEDULERS
+
+
+@PARAM_SCHEDULERS.register_module()
+class QuadraticWarmupParamScheduler(_ParamScheduler):
+    r"""Warm up the parameter value of each parameter group by quadratic
+    formula:
+
+    .. math::
+
+        X_{t} = X_{t-1} + \frac{2t+1}{{(end-begin)}^{2}} \times X_{base}
+
+    Args:
+        optimizer (Optimizer): Wrapped optimizer.
+        param_name (str): Name of the parameter to be adjusted, such as
+            ``lr``, ``momentum``.
+        begin (int): Step at which to start updating the parameters.
+            Defaults to 0.
+        end (int): Step at which to stop updating the parameters.
+            Defaults to INF.
+        last_step (int): The index of last step. Used for resume without
+            state dict. Defaults to -1.
+        by_epoch (bool): Whether the scheduled parameters are updated by
+            epochs. Defaults to True.
+        verbose (bool): Whether to print the value for each update.
+            Defaults to False.
+    """
+
+    def __init__(self,
+                 optimizer: Optimizer,
+                 param_name: str,
+                 begin: int = 0,
+                 end: int = INF,
+                 last_step: int = -1,
+                 by_epoch: bool = True,
+                 verbose: bool = False):
+        if end >= INF:
+            raise ValueError('``end`` must be less than infinity,'
+                             'Please set ``end`` parameter of '
+                             '``QuadraticWarmupScheduler`` as the '
+                             'number of warmup end.')
+        self.total_iters = end - begin
+        super().__init__(
+            optimizer=optimizer,
+            param_name=param_name,
+            begin=begin,
+            end=end,
+            last_step=last_step,
+            by_epoch=by_epoch,
+            verbose=verbose)
+
+    @classmethod
+    def build_iter_from_epoch(cls,
+                              *args,
+                              begin=0,
+                              end=INF,
+                              by_epoch=True,
+                              epoch_length=None,
+                              **kwargs):
+        """Build an iter-based instance of this scheduler from an epoch-based
+        config."""
+        assert by_epoch, 'Only epoch-based kwargs whose `by_epoch=True` can ' \
+                         'be converted to iter-based.'
+        assert epoch_length is not None and epoch_length > 0, \
+            f'`epoch_length` must be a positive integer, ' \
+            f'but got {epoch_length}.'
+        by_epoch = False
+        begin = begin * epoch_length
+        if end != INF:
+            end = end * epoch_length
+        return cls(*args, begin=begin, end=end, by_epoch=by_epoch, **kwargs)
+
+    def _get_value(self):
+        """Compute value using chainable form of the scheduler."""
+        if self.last_step == 0:
+            return [
+                base_value * (2 * self.last_step + 1) / self.total_iters**2
+                for base_value in self.base_values
+            ]
+
+        return [
+            group[self.param_name] + base_value *
+            (2 * self.last_step + 1) / self.total_iters**2
+            for base_value, group in zip(self.base_values,
+                                         self.optimizer.param_groups)
+        ]
+
+
+@PARAM_SCHEDULERS.register_module()
+class QuadraticWarmupLR(LRSchedulerMixin, QuadraticWarmupParamScheduler):
+    """Warm up the learning rate of each parameter group by quadratic formula.
+
+    Args:
+        optimizer (Optimizer): Wrapped optimizer.
+        begin (int): Step at which to start updating the parameters.
+            Defaults to 0.
+        end (int): Step at which to stop updating the parameters.
+            Defaults to INF.
+        last_step (int): The index of last step. Used for resume without
+            state dict. Defaults to -1.
+        by_epoch (bool): Whether the scheduled parameters are updated by
+            epochs. Defaults to True.
+        verbose (bool): Whether to print the value for each update.
+            Defaults to False.
+    """
+
+
+@PARAM_SCHEDULERS.register_module()
+class QuadraticWarmupMomentum(MomentumSchedulerMixin,
+                              QuadraticWarmupParamScheduler):
+    """Warm up the momentum value of each parameter group by quadratic formula.
+
+    Args:
+        optimizer (Optimizer): Wrapped optimizer.
+        begin (int): Step at which to start updating the parameters.
+            Defaults to 0.
+        end (int): Step at which to stop updating the parameters.
+            Defaults to INF.
+        last_step (int): The index of last step. Used for resume without
+            state dict. Defaults to -1.
+        by_epoch (bool): Whether the scheduled parameters are updated by
+            epochs. Defaults to True.
+        verbose (bool): Whether to print the value for each update.
+            Defaults to False.
+    """
diff --git a/mmdetection/mmdet/evaluation/__init__.py b/mmdetection/mmdet/evaluation/__init__.py
new file mode 100644
index 00000000..126dea09
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .evaluator import *  # noqa: F401,F403
+from .functional import *  # noqa: F401,F403
+from .metrics import *  # noqa: F401,F403
diff --git a/mmdetection/mmdet/evaluation/evaluator/__init__.py b/mmdetection/mmdet/evaluation/evaluator/__init__.py
new file mode 100644
index 00000000..6b13fe99
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/evaluator/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .multi_datasets_evaluator import MultiDatasetsEvaluator
+
+__all__ = ['MultiDatasetsEvaluator']
diff --git a/mmdetection/mmdet/evaluation/evaluator/multi_datasets_evaluator.py b/mmdetection/mmdet/evaluation/evaluator/multi_datasets_evaluator.py
new file mode 100644
index 00000000..5cff1cf2
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/evaluator/multi_datasets_evaluator.py
@@ -0,0 +1,111 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+from collections import OrderedDict
+from typing import Sequence, Union
+
+from mmengine.dist import (broadcast_object_list, collect_results,
+                           is_main_process)
+from mmengine.evaluator import BaseMetric, Evaluator
+from mmengine.evaluator.metric import _to_cpu
+from mmengine.registry import EVALUATOR
+
+from mmdet.utils import ConfigType
+
+
+@EVALUATOR.register_module()
+class MultiDatasetsEvaluator(Evaluator):
+    """Wrapper class to compose class: `ConcatDataset` and multiple
+    :class:`BaseMetric` instances.
+    The metrics will be evaluated on each dataset slice separately. The name of
+    the each metric is the concatenation of the dataset prefix, the metric
+    prefix and the key of metric - e.g.
+    `dataset_prefix/metric_prefix/accuracy`.
+
+    Args:
+        metrics (dict or BaseMetric or Sequence): The config of metrics.
+        dataset_prefixes (Sequence[str]): The prefix of each dataset. The
+            length of this sequence should be the same as the length of the
+            datasets.
+    """
+
+    def __init__(self, metrics: Union[ConfigType, BaseMetric, Sequence],
+                 dataset_prefixes: Sequence[str]) -> None:
+        super().__init__(metrics)
+        self.dataset_prefixes = dataset_prefixes
+        self._setups = False
+
+    def _get_cumulative_sizes(self):
+        # ConcatDataset have a property `cumulative_sizes`
+        if isinstance(self.dataset_meta, Sequence):
+            dataset_slices = self.dataset_meta[0]['cumulative_sizes']
+            if not self._setups:
+                self._setups = True
+                for dataset_meta, metric in zip(self.dataset_meta,
+                                                self.metrics):
+                    metric.dataset_meta = dataset_meta
+        else:
+            dataset_slices = self.dataset_meta['cumulative_sizes']
+        return dataset_slices
+
+    def evaluate(self, size: int) -> dict:
+        """Invoke ``evaluate`` method of each metric and collect the metrics
+        dictionary.
+
+        Args:
+            size (int): Length of the entire validation dataset. When batch
+                size > 1, the dataloader may pad some data samples to make
+                sure all ranks have the same length of dataset slice. The
+                ``collect_results`` function will drop the padded data based on
+                this size.
+
+        Returns:
+            dict: Evaluation results of all metrics. The keys are the names
+            of the metrics, and the values are corresponding results.
+        """
+        metrics_results = OrderedDict()
+        dataset_slices = self._get_cumulative_sizes()
+        assert len(dataset_slices) == len(self.dataset_prefixes)
+
+        for dataset_prefix, start, end, metric in zip(
+                self.dataset_prefixes, [0] + dataset_slices[:-1],
+                dataset_slices, self.metrics):
+            if len(metric.results) == 0:
+                warnings.warn(
+                    f'{metric.__class__.__name__} got empty `self.results`.'
+                    'Please ensure that the processed results are properly '
+                    'added into `self.results` in `process` method.')
+
+            results = collect_results(metric.results, size,
+                                      metric.collect_device)
+
+            if is_main_process():
+                # cast all tensors in results list to cpu
+                results = _to_cpu(results)
+                _metrics = metric.compute_metrics(
+                    results[start:end])  # type: ignore
+
+                if metric.prefix:
+                    final_prefix = '/'.join((dataset_prefix, metric.prefix))
+                else:
+                    final_prefix = dataset_prefix
+                print(f'================{final_prefix}================')
+                metric_results = {
+                    '/'.join((final_prefix, k)): v
+                    for k, v in _metrics.items()
+                }
+
+                # Check metric name conflicts
+                for name in metric_results.keys():
+                    if name in metrics_results:
+                        raise ValueError(
+                            'There are multiple evaluation results with '
+                            f'the same metric name {name}. Please make '
+                            'sure all metrics have different prefixes.')
+                metrics_results.update(metric_results)
+            metric.results.clear()
+        if is_main_process():
+            metrics_results = [metrics_results]
+        else:
+            metrics_results = [None]  # type: ignore
+        broadcast_object_list(metrics_results)
+        return metrics_results[0]
diff --git a/mmdetection/mmdet/evaluation/functional/__init__.py b/mmdetection/mmdet/evaluation/functional/__init__.py
new file mode 100644
index 00000000..96d58ebd
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/functional/__init__.py
@@ -0,0 +1,26 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .bbox_overlaps import bbox_overlaps
+from .cityscapes_utils import evaluateImgLists
+from .class_names import (cityscapes_classes, coco_classes,
+                          coco_panoptic_classes, dataset_aliases, get_classes,
+                          imagenet_det_classes, imagenet_vid_classes,
+                          objects365v1_classes, objects365v2_classes,
+                          oid_challenge_classes, oid_v6_classes, voc_classes)
+from .mean_ap import average_precision, eval_map, print_map_summary
+from .panoptic_utils import (INSTANCE_OFFSET, pq_compute_multi_core,
+                             pq_compute_single_core)
+from .recall import (eval_recalls, plot_iou_recall, plot_num_recall,
+                     print_recall_summary)
+from .ytvis import YTVIS
+from .ytviseval import YTVISeval
+
+__all__ = [
+    'voc_classes', 'imagenet_det_classes', 'imagenet_vid_classes',
+    'coco_classes', 'cityscapes_classes', 'dataset_aliases', 'get_classes',
+    'average_precision', 'eval_map', 'print_map_summary', 'eval_recalls',
+    'print_recall_summary', 'plot_num_recall', 'plot_iou_recall',
+    'oid_v6_classes', 'oid_challenge_classes', 'INSTANCE_OFFSET',
+    'pq_compute_single_core', 'pq_compute_multi_core', 'bbox_overlaps',
+    'objects365v1_classes', 'objects365v2_classes', 'coco_panoptic_classes',
+    'evaluateImgLists', 'YTVIS', 'YTVISeval'
+]
diff --git a/mmdetection/mmdet/evaluation/functional/bbox_overlaps.py b/mmdetection/mmdet/evaluation/functional/bbox_overlaps.py
new file mode 100644
index 00000000..5d6eb82f
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/functional/bbox_overlaps.py
@@ -0,0 +1,65 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import numpy as np
+
+
+def bbox_overlaps(bboxes1,
+                  bboxes2,
+                  mode='iou',
+                  eps=1e-6,
+                  use_legacy_coordinate=False):
+    """Calculate the ious between each bbox of bboxes1 and bboxes2.
+
+    Args:
+        bboxes1 (ndarray): Shape (n, 4)
+        bboxes2 (ndarray): Shape (k, 4)
+        mode (str): IOU (intersection over union) or IOF (intersection
+            over foreground)
+        use_legacy_coordinate (bool): Whether to use coordinate system in
+            mmdet v1.x. which means width, height should be
+            calculated as 'x2 - x1 + 1` and 'y2 - y1 + 1' respectively.
+            Note when function is used in `VOCDataset`, it should be
+            True to align with the official implementation
+            `http://host.robots.ox.ac.uk/pascal/VOC/voc2012/VOCdevkit_18-May-2011.tar`
+            Default: False.
+
+    Returns:
+        ious (ndarray): Shape (n, k)
+    """
+
+    assert mode in ['iou', 'iof']
+    if not use_legacy_coordinate:
+        extra_length = 0.
+    else:
+        extra_length = 1.
+    bboxes1 = bboxes1.astype(np.float32)
+    bboxes2 = bboxes2.astype(np.float32)
+    rows = bboxes1.shape[0]
+    cols = bboxes2.shape[0]
+    ious = np.zeros((rows, cols), dtype=np.float32)
+    if rows * cols == 0:
+        return ious
+    exchange = False
+    if bboxes1.shape[0] > bboxes2.shape[0]:
+        bboxes1, bboxes2 = bboxes2, bboxes1
+        ious = np.zeros((cols, rows), dtype=np.float32)
+        exchange = True
+    area1 = (bboxes1[:, 2] - bboxes1[:, 0] + extra_length) * (
+        bboxes1[:, 3] - bboxes1[:, 1] + extra_length)
+    area2 = (bboxes2[:, 2] - bboxes2[:, 0] + extra_length) * (
+        bboxes2[:, 3] - bboxes2[:, 1] + extra_length)
+    for i in range(bboxes1.shape[0]):
+        x_start = np.maximum(bboxes1[i, 0], bboxes2[:, 0])
+        y_start = np.maximum(bboxes1[i, 1], bboxes2[:, 1])
+        x_end = np.minimum(bboxes1[i, 2], bboxes2[:, 2])
+        y_end = np.minimum(bboxes1[i, 3], bboxes2[:, 3])
+        overlap = np.maximum(x_end - x_start + extra_length, 0) * np.maximum(
+            y_end - y_start + extra_length, 0)
+        if mode == 'iou':
+            union = area1[i] + area2 - overlap
+        else:
+            union = area1[i] if not exchange else area2
+        union = np.maximum(union, eps)
+        ious[i, :] = overlap / union
+    if exchange:
+        ious = ious.T
+    return ious
diff --git a/mmdetection/mmdet/evaluation/functional/cityscapes_utils.py b/mmdetection/mmdet/evaluation/functional/cityscapes_utils.py
new file mode 100644
index 00000000..5ced3680
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/functional/cityscapes_utils.py
@@ -0,0 +1,302 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# Copyright (c) https://github.com/mcordts/cityscapesScripts
+# A wrapper of `cityscapesscripts` which supports loading groundtruth
+# image from `backend_args`.
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Optional, Union
+
+import mmcv
+import numpy as np
+from mmengine.fileio import get
+
+try:
+    import cityscapesscripts.evaluation.evalInstanceLevelSemanticLabeling as CSEval  # noqa: E501
+    from cityscapesscripts.evaluation.evalInstanceLevelSemanticLabeling import \
+        CArgs  # noqa: E501
+    from cityscapesscripts.evaluation.instance import Instance
+    from cityscapesscripts.helpers.csHelpers import (id2label, labels,
+                                                     writeDict2JSON)
+    HAS_CITYSCAPESAPI = True
+except ImportError:
+    CArgs = object
+    HAS_CITYSCAPESAPI = False
+
+
+def evaluateImgLists(prediction_list: list,
+                     groundtruth_list: list,
+                     args: CArgs,
+                     backend_args: Optional[dict] = None,
+                     dump_matches: bool = False) -> dict:
+    """A wrapper of obj:``cityscapesscripts.evaluation.
+
+    evalInstanceLevelSemanticLabeling.evaluateImgLists``. Support loading
+    groundtruth image from file backend.
+    Args:
+        prediction_list (list): A list of prediction txt file.
+        groundtruth_list (list): A list of groundtruth image file.
+        args (CArgs): A global object setting in
+            obj:``cityscapesscripts.evaluation.
+            evalInstanceLevelSemanticLabeling``
+        backend_args (dict, optional): Arguments to instantiate the
+            preifx of uri corresponding backend. Defaults to None.
+        dump_matches (bool): whether dump matches.json. Defaults to False.
+    Returns:
+        dict: The computed metric.
+    """
+    if not HAS_CITYSCAPESAPI:
+        raise RuntimeError('Failed to import `cityscapesscripts`.'
+                           'Please try to install official '
+                           'cityscapesscripts by '
+                           '"pip install cityscapesscripts"')
+    # determine labels of interest
+    CSEval.setInstanceLabels(args)
+    # get dictionary of all ground truth instances
+    gt_instances = getGtInstances(
+        groundtruth_list, args, backend_args=backend_args)
+    # match predictions and ground truth
+    matches = matchGtWithPreds(prediction_list, groundtruth_list, gt_instances,
+                               args, backend_args)
+    if dump_matches:
+        CSEval.writeDict2JSON(matches, 'matches.json')
+    # evaluate matches
+    apScores = CSEval.evaluateMatches(matches, args)
+    # averages
+    avgDict = CSEval.computeAverages(apScores, args)
+    # result dict
+    resDict = CSEval.prepareJSONDataForResults(avgDict, apScores, args)
+    if args.JSONOutput:
+        # create output folder if necessary
+        path = os.path.dirname(args.exportFile)
+        CSEval.ensurePath(path)
+        # Write APs to JSON
+        CSEval.writeDict2JSON(resDict, args.exportFile)
+
+    CSEval.printResults(avgDict, args)
+
+    return resDict
+
+
+def matchGtWithPreds(prediction_list: list,
+                     groundtruth_list: list,
+                     gt_instances: dict,
+                     args: CArgs,
+                     backend_args=None):
+    """A wrapper of obj:``cityscapesscripts.evaluation.
+
+    evalInstanceLevelSemanticLabeling.matchGtWithPreds``. Support loading
+    groundtruth image from file backend.
+    Args:
+        prediction_list (list): A list of prediction txt file.
+        groundtruth_list (list): A list of groundtruth image file.
+        gt_instances (dict): Groundtruth dict.
+        args (CArgs): A global object setting in
+            obj:``cityscapesscripts.evaluation.
+            evalInstanceLevelSemanticLabeling``
+        backend_args (dict, optional): Arguments to instantiate the
+            preifx of uri corresponding backend. Defaults to None.
+    Returns:
+        dict: The processed prediction and groundtruth result.
+    """
+    if not HAS_CITYSCAPESAPI:
+        raise RuntimeError('Failed to import `cityscapesscripts`.'
+                           'Please try to install official '
+                           'cityscapesscripts by '
+                           '"pip install cityscapesscripts"')
+    matches: dict = dict()
+    if not args.quiet:
+        print(f'Matching {len(prediction_list)} pairs of images...')
+
+    count = 0
+    for (pred, gt) in zip(prediction_list, groundtruth_list):
+        # Read input files
+        gt_image = readGTImage(gt, backend_args)
+        pred_info = readPredInfo(pred)
+        # Get and filter ground truth instances
+        unfiltered_instances = gt_instances[gt]
+        cur_gt_instances_orig = CSEval.filterGtInstances(
+            unfiltered_instances, args)
+
+        # Try to assign all predictions
+        (cur_gt_instances,
+         cur_pred_instances) = CSEval.assignGt2Preds(cur_gt_instances_orig,
+                                                     gt_image, pred_info, args)
+
+        # append to global dict
+        matches[gt] = {}
+        matches[gt]['groundTruth'] = cur_gt_instances
+        matches[gt]['prediction'] = cur_pred_instances
+
+        count += 1
+        if not args.quiet:
+            print(f'\rImages Processed: {count}', end=' ')
+            sys.stdout.flush()
+
+    if not args.quiet:
+        print('')
+
+    return matches
+
+
+def readGTImage(image_file: Union[str, Path],
+                backend_args: Optional[dict] = None) -> np.ndarray:
+    """Read an image from path.
+
+    Same as obj:``cityscapesscripts.evaluation.
+    evalInstanceLevelSemanticLabeling.readGTImage``, but support loading
+    groundtruth image from file backend.
+    Args:
+        image_file (str or Path): Either a str or pathlib.Path.
+        backend_args (dict, optional): Instantiates the corresponding file
+            backend. It may contain `backend` key to specify the file
+            backend. If it contains, the file backend corresponding to this
+            value will be used and initialized with the remaining values,
+            otherwise the corresponding file backend will be selected
+            based on the prefix of the file path. Defaults to None.
+    Returns:
+        np.ndarray: The groundtruth image.
+    """
+    img_bytes = get(image_file, backend_args=backend_args)
+    img = mmcv.imfrombytes(img_bytes, flag='unchanged', backend='pillow')
+    return img
+
+
+def readPredInfo(prediction_file: str) -> dict:
+    """A wrapper of obj:``cityscapesscripts.evaluation.
+
+    evalInstanceLevelSemanticLabeling.readPredInfo``.
+    Args:
+        prediction_file (str): The prediction txt file.
+    Returns:
+        dict: The processed prediction results.
+    """
+    if not HAS_CITYSCAPESAPI:
+        raise RuntimeError('Failed to import `cityscapesscripts`.'
+                           'Please try to install official '
+                           'cityscapesscripts by '
+                           '"pip install cityscapesscripts"')
+    printError = CSEval.printError
+
+    predInfo = {}
+    if (not os.path.isfile(prediction_file)):
+        printError(f"Infofile '{prediction_file}' "
+                   'for the predictions not found.')
+    with open(prediction_file) as f:
+        for line in f:
+            splittedLine = line.split(' ')
+            if len(splittedLine) != 3:
+                printError('Invalid prediction file. Expected content: '
+                           'relPathPrediction1 labelIDPrediction1 '
+                           'confidencePrediction1')
+            if os.path.isabs(splittedLine[0]):
+                printError('Invalid prediction file. First entry in each '
+                           'line must be a relative path.')
+
+            filename = os.path.join(
+                os.path.dirname(prediction_file), splittedLine[0])
+
+            imageInfo = {}
+            imageInfo['labelID'] = int(float(splittedLine[1]))
+            imageInfo['conf'] = float(splittedLine[2])  # type: ignore
+            predInfo[filename] = imageInfo
+
+    return predInfo
+
+
+def getGtInstances(groundtruth_list: list,
+                   args: CArgs,
+                   backend_args: Optional[dict] = None) -> dict:
+    """A wrapper of obj:``cityscapesscripts.evaluation.
+
+    evalInstanceLevelSemanticLabeling.getGtInstances``. Support loading
+    groundtruth image from file backend.
+    Args:
+        groundtruth_list (list): A list of groundtruth image file.
+        args (CArgs): A global object setting in
+            obj:``cityscapesscripts.evaluation.
+            evalInstanceLevelSemanticLabeling``
+        backend_args (dict, optional): Arguments to instantiate the
+            preifx of uri corresponding backend. Defaults to None.
+    Returns:
+        dict: The computed metric.
+    """
+    if not HAS_CITYSCAPESAPI:
+        raise RuntimeError('Failed to import `cityscapesscripts`.'
+                           'Please try to install official '
+                           'cityscapesscripts by '
+                           '"pip install cityscapesscripts"')
+    # if there is a global statistics json, then load it
+    if (os.path.isfile(args.gtInstancesFile)):
+        if not args.quiet:
+            print('Loading ground truth instances from JSON.')
+        with open(args.gtInstancesFile) as json_file:
+            gt_instances = json.load(json_file)
+    # otherwise create it
+    else:
+        if (not args.quiet):
+            print('Creating ground truth instances from png files.')
+        gt_instances = instances2dict(
+            groundtruth_list, args, backend_args=backend_args)
+        writeDict2JSON(gt_instances, args.gtInstancesFile)
+
+    return gt_instances
+
+
+def instances2dict(image_list: list,
+                   args: CArgs,
+                   backend_args: Optional[dict] = None) -> dict:
+    """A wrapper of obj:``cityscapesscripts.evaluation.
+
+    evalInstanceLevelSemanticLabeling.instances2dict``. Support loading
+    groundtruth image from file backend.
+    Args:
+        image_list (list): A list of image file.
+        args (CArgs): A global object setting in
+            obj:``cityscapesscripts.evaluation.
+            evalInstanceLevelSemanticLabeling``
+        backend_args (dict, optional): Arguments to instantiate the
+            preifx of uri corresponding backend. Defaults to None.
+    Returns:
+        dict: The processed groundtruth results.
+    """
+    if not HAS_CITYSCAPESAPI:
+        raise RuntimeError('Failed to import `cityscapesscripts`.'
+                           'Please try to install official '
+                           'cityscapesscripts by '
+                           '"pip install cityscapesscripts"')
+    imgCount = 0
+    instanceDict = {}
+
+    if not isinstance(image_list, list):
+        image_list = [image_list]
+
+    if not args.quiet:
+        print(f'Processing {len(image_list)} images...')
+
+    for image_name in image_list:
+        # Load image
+        img_bytes = get(image_name, backend_args=backend_args)
+        imgNp = mmcv.imfrombytes(img_bytes, flag='unchanged', backend='pillow')
+
+        # Initialize label categories
+        instances: dict = {}
+        for label in labels:
+            instances[label.name] = []
+
+        # Loop through all instance ids in instance image
+        for instanceId in np.unique(imgNp):
+            instanceObj = Instance(imgNp, instanceId)
+
+            instances[id2label[instanceObj.labelID].name].append(
+                instanceObj.toDict())
+
+        instanceDict[image_name] = instances
+        imgCount += 1
+
+        if not args.quiet:
+            print(f'\rImages Processed: {imgCount}', end=' ')
+            sys.stdout.flush()
+
+    return instanceDict
diff --git a/mmdetection/mmdet/evaluation/functional/class_names.py b/mmdetection/mmdet/evaluation/functional/class_names.py
new file mode 100644
index 00000000..623a89cf
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/functional/class_names.py
@@ -0,0 +1,762 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.utils import is_str
+
+
+def wider_face_classes() -> list:
+    """Class names of WIDERFace."""
+    return ['face']
+
+
+def voc_classes() -> list:
+    """Class names of PASCAL VOC."""
+    return [
+        'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat',
+        'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person',
+        'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor'
+    ]
+
+
+def imagenet_det_classes() -> list:
+    """Class names of ImageNet Det."""
+    return [
+        'accordion', 'airplane', 'ant', 'antelope', 'apple', 'armadillo',
+        'artichoke', 'axe', 'baby_bed', 'backpack', 'bagel', 'balance_beam',
+        'banana', 'band_aid', 'banjo', 'baseball', 'basketball', 'bathing_cap',
+        'beaker', 'bear', 'bee', 'bell_pepper', 'bench', 'bicycle', 'binder',
+        'bird', 'bookshelf', 'bow_tie', 'bow', 'bowl', 'brassiere', 'burrito',
+        'bus', 'butterfly', 'camel', 'can_opener', 'car', 'cart', 'cattle',
+        'cello', 'centipede', 'chain_saw', 'chair', 'chime', 'cocktail_shaker',
+        'coffee_maker', 'computer_keyboard', 'computer_mouse', 'corkscrew',
+        'cream', 'croquet_ball', 'crutch', 'cucumber', 'cup_or_mug', 'diaper',
+        'digital_clock', 'dishwasher', 'dog', 'domestic_cat', 'dragonfly',
+        'drum', 'dumbbell', 'electric_fan', 'elephant', 'face_powder', 'fig',
+        'filing_cabinet', 'flower_pot', 'flute', 'fox', 'french_horn', 'frog',
+        'frying_pan', 'giant_panda', 'goldfish', 'golf_ball', 'golfcart',
+        'guacamole', 'guitar', 'hair_dryer', 'hair_spray', 'hamburger',
+        'hammer', 'hamster', 'harmonica', 'harp', 'hat_with_a_wide_brim',
+        'head_cabbage', 'helmet', 'hippopotamus', 'horizontal_bar', 'horse',
+        'hotdog', 'iPod', 'isopod', 'jellyfish', 'koala_bear', 'ladle',
+        'ladybug', 'lamp', 'laptop', 'lemon', 'lion', 'lipstick', 'lizard',
+        'lobster', 'maillot', 'maraca', 'microphone', 'microwave', 'milk_can',
+        'miniskirt', 'monkey', 'motorcycle', 'mushroom', 'nail', 'neck_brace',
+        'oboe', 'orange', 'otter', 'pencil_box', 'pencil_sharpener', 'perfume',
+        'person', 'piano', 'pineapple', 'ping-pong_ball', 'pitcher', 'pizza',
+        'plastic_bag', 'plate_rack', 'pomegranate', 'popsicle', 'porcupine',
+        'power_drill', 'pretzel', 'printer', 'puck', 'punching_bag', 'purse',
+        'rabbit', 'racket', 'ray', 'red_panda', 'refrigerator',
+        'remote_control', 'rubber_eraser', 'rugby_ball', 'ruler',
+        'salt_or_pepper_shaker', 'saxophone', 'scorpion', 'screwdriver',
+        'seal', 'sheep', 'ski', 'skunk', 'snail', 'snake', 'snowmobile',
+        'snowplow', 'soap_dispenser', 'soccer_ball', 'sofa', 'spatula',
+        'squirrel', 'starfish', 'stethoscope', 'stove', 'strainer',
+        'strawberry', 'stretcher', 'sunglasses', 'swimming_trunks', 'swine',
+        'syringe', 'table', 'tape_player', 'tennis_ball', 'tick', 'tie',
+        'tiger', 'toaster', 'traffic_light', 'train', 'trombone', 'trumpet',
+        'turtle', 'tv_or_monitor', 'unicycle', 'vacuum', 'violin',
+        'volleyball', 'waffle_iron', 'washer', 'water_bottle', 'watercraft',
+        'whale', 'wine_bottle', 'zebra'
+    ]
+
+
+def imagenet_vid_classes() -> list:
+    """Class names of ImageNet VID."""
+    return [
+        'airplane', 'antelope', 'bear', 'bicycle', 'bird', 'bus', 'car',
+        'cattle', 'dog', 'domestic_cat', 'elephant', 'fox', 'giant_panda',
+        'hamster', 'horse', 'lion', 'lizard', 'monkey', 'motorcycle', 'rabbit',
+        'red_panda', 'sheep', 'snake', 'squirrel', 'tiger', 'train', 'turtle',
+        'watercraft', 'whale', 'zebra'
+    ]
+
+
+def coco_classes() -> list:
+    """Class names of COCO."""
+    return [
+        'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train',
+        'truck', 'boat', 'traffic_light', 'fire_hydrant', 'stop_sign',
+        'parking_meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep',
+        'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella',
+        'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard',
+        'sports_ball', 'kite', 'baseball_bat', 'baseball_glove', 'skateboard',
+        'surfboard', 'tennis_racket', 'bottle', 'wine_glass', 'cup', 'fork',
+        'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich', 'orange',
+        'broccoli', 'carrot', 'hot_dog', 'pizza', 'donut', 'cake', 'chair',
+        'couch', 'potted_plant', 'bed', 'dining_table', 'toilet', 'tv',
+        'laptop', 'mouse', 'remote', 'keyboard', 'cell_phone', 'microwave',
+        'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',
+        'scissors', 'teddy_bear', 'hair_drier', 'toothbrush'
+    ]
+
+
+def coco_panoptic_classes() -> list:
+    """Class names of COCO panoptic."""
+    return [
+        'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train',
+        'truck', 'boat', 'traffic light', 'fire hydrant', 'stop sign',
+        'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep',
+        'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella',
+        'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard',
+        'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard',
+        'surfboard', 'tennis racket', 'bottle', 'wine glass', 'cup', 'fork',
+        'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich', 'orange',
+        'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair',
+        'couch', 'potted plant', 'bed', 'dining table', 'toilet', 'tv',
+        'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',
+        'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',
+        'scissors', 'teddy bear', 'hair drier', 'toothbrush', 'banner',
+        'blanket', 'bridge', 'cardboard', 'counter', 'curtain', 'door-stuff',
+        'floor-wood', 'flower', 'fruit', 'gravel', 'house', 'light',
+        'mirror-stuff', 'net', 'pillow', 'platform', 'playingfield',
+        'railroad', 'river', 'road', 'roof', 'sand', 'sea', 'shelf', 'snow',
+        'stairs', 'tent', 'towel', 'wall-brick', 'wall-stone', 'wall-tile',
+        'wall-wood', 'water-other', 'window-blind', 'window-other',
+        'tree-merged', 'fence-merged', 'ceiling-merged', 'sky-other-merged',
+        'cabinet-merged', 'table-merged', 'floor-other-merged',
+        'pavement-merged', 'mountain-merged', 'grass-merged', 'dirt-merged',
+        'paper-merged', 'food-other-merged', 'building-other-merged',
+        'rock-merged', 'wall-other-merged', 'rug-merged'
+    ]
+
+
+def cityscapes_classes() -> list:
+    """Class names of Cityscapes."""
+    return [
+        'person', 'rider', 'car', 'truck', 'bus', 'train', 'motorcycle',
+        'bicycle'
+    ]
+
+
+def oid_challenge_classes() -> list:
+    """Class names of Open Images Challenge."""
+    return [
+        'Footwear', 'Jeans', 'House', 'Tree', 'Woman', 'Man', 'Land vehicle',
+        'Person', 'Wheel', 'Bus', 'Human face', 'Bird', 'Dress', 'Girl',
+        'Vehicle', 'Building', 'Cat', 'Car', 'Belt', 'Elephant', 'Dessert',
+        'Butterfly', 'Train', 'Guitar', 'Poster', 'Book', 'Boy', 'Bee',
+        'Flower', 'Window', 'Hat', 'Human head', 'Dog', 'Human arm', 'Drink',
+        'Human mouth', 'Human hair', 'Human nose', 'Human hand', 'Table',
+        'Marine invertebrates', 'Fish', 'Sculpture', 'Rose', 'Street light',
+        'Glasses', 'Fountain', 'Skyscraper', 'Swimwear', 'Brassiere', 'Drum',
+        'Duck', 'Countertop', 'Furniture', 'Ball', 'Human leg', 'Boat',
+        'Balloon', 'Bicycle helmet', 'Goggles', 'Door', 'Human eye', 'Shirt',
+        'Toy', 'Teddy bear', 'Pasta', 'Tomato', 'Human ear',
+        'Vehicle registration plate', 'Microphone', 'Musical keyboard',
+        'Tower', 'Houseplant', 'Flowerpot', 'Fruit', 'Vegetable',
+        'Musical instrument', 'Suit', 'Motorcycle', 'Bagel', 'French fries',
+        'Hamburger', 'Chair', 'Salt and pepper shakers', 'Snail', 'Airplane',
+        'Horse', 'Laptop', 'Computer keyboard', 'Football helmet', 'Cocktail',
+        'Juice', 'Tie', 'Computer monitor', 'Human beard', 'Bottle',
+        'Saxophone', 'Lemon', 'Mouse', 'Sock', 'Cowboy hat', 'Sun hat',
+        'Football', 'Porch', 'Sunglasses', 'Lobster', 'Crab', 'Picture frame',
+        'Van', 'Crocodile', 'Surfboard', 'Shorts', 'Helicopter', 'Helmet',
+        'Sports uniform', 'Taxi', 'Swan', 'Goose', 'Coat', 'Jacket', 'Handbag',
+        'Flag', 'Skateboard', 'Television', 'Tire', 'Spoon', 'Palm tree',
+        'Stairs', 'Salad', 'Castle', 'Oven', 'Microwave oven', 'Wine',
+        'Ceiling fan', 'Mechanical fan', 'Cattle', 'Truck', 'Box', 'Ambulance',
+        'Desk', 'Wine glass', 'Reptile', 'Tank', 'Traffic light', 'Billboard',
+        'Tent', 'Insect', 'Spider', 'Treadmill', 'Cupboard', 'Shelf',
+        'Seat belt', 'Human foot', 'Bicycle', 'Bicycle wheel', 'Couch',
+        'Bookcase', 'Fedora', 'Backpack', 'Bench', 'Oyster',
+        'Moths and butterflies', 'Lavender', 'Waffle', 'Fork', 'Animal',
+        'Accordion', 'Mobile phone', 'Plate', 'Coffee cup', 'Saucer',
+        'Platter', 'Dagger', 'Knife', 'Bull', 'Tortoise', 'Sea turtle', 'Deer',
+        'Weapon', 'Apple', 'Ski', 'Taco', 'Traffic sign', 'Beer', 'Necklace',
+        'Sunflower', 'Piano', 'Organ', 'Harpsichord', 'Bed', 'Cabinetry',
+        'Nightstand', 'Curtain', 'Chest of drawers', 'Drawer', 'Parrot',
+        'Sandal', 'High heels', 'Tableware', 'Cart', 'Mushroom', 'Kite',
+        'Missile', 'Seafood', 'Camera', 'Paper towel', 'Toilet paper',
+        'Sombrero', 'Radish', 'Lighthouse', 'Segway', 'Pig', 'Watercraft',
+        'Golf cart', 'studio couch', 'Dolphin', 'Whale', 'Earrings', 'Otter',
+        'Sea lion', 'Whiteboard', 'Monkey', 'Gondola', 'Zebra',
+        'Baseball glove', 'Scarf', 'Adhesive tape', 'Trousers', 'Scoreboard',
+        'Lily', 'Carnivore', 'Power plugs and sockets', 'Office building',
+        'Sandwich', 'Swimming pool', 'Headphones', 'Tin can', 'Crown', 'Doll',
+        'Cake', 'Frog', 'Beetle', 'Ant', 'Gas stove', 'Canoe', 'Falcon',
+        'Blue jay', 'Egg', 'Fire hydrant', 'Raccoon', 'Muffin', 'Wall clock',
+        'Coffee', 'Mug', 'Tea', 'Bear', 'Waste container', 'Home appliance',
+        'Candle', 'Lion', 'Mirror', 'Starfish', 'Marine mammal', 'Wheelchair',
+        'Umbrella', 'Alpaca', 'Violin', 'Cello', 'Brown bear', 'Canary', 'Bat',
+        'Ruler', 'Plastic bag', 'Penguin', 'Watermelon', 'Harbor seal', 'Pen',
+        'Pumpkin', 'Harp', 'Kitchen appliance', 'Roller skates', 'Bust',
+        'Coffee table', 'Tennis ball', 'Tennis racket', 'Ladder', 'Boot',
+        'Bowl', 'Stop sign', 'Volleyball', 'Eagle', 'Paddle', 'Chicken',
+        'Skull', 'Lamp', 'Beehive', 'Maple', 'Sink', 'Goldfish', 'Tripod',
+        'Coconut', 'Bidet', 'Tap', 'Bathroom cabinet', 'Toilet',
+        'Filing cabinet', 'Pretzel', 'Table tennis racket', 'Bronze sculpture',
+        'Rocket', 'Mouse', 'Hamster', 'Lizard', 'Lifejacket', 'Goat',
+        'Washing machine', 'Trumpet', 'Horn', 'Trombone', 'Sheep',
+        'Tablet computer', 'Pillow', 'Kitchen & dining room table',
+        'Parachute', 'Raven', 'Glove', 'Loveseat', 'Christmas tree',
+        'Shellfish', 'Rifle', 'Shotgun', 'Sushi', 'Sparrow', 'Bread',
+        'Toaster', 'Watch', 'Asparagus', 'Artichoke', 'Suitcase', 'Antelope',
+        'Broccoli', 'Ice cream', 'Racket', 'Banana', 'Cookie', 'Cucumber',
+        'Dragonfly', 'Lynx', 'Caterpillar', 'Light bulb', 'Office supplies',
+        'Miniskirt', 'Skirt', 'Fireplace', 'Potato', 'Light switch',
+        'Croissant', 'Cabbage', 'Ladybug', 'Handgun', 'Luggage and bags',
+        'Window blind', 'Snowboard', 'Baseball bat', 'Digital clock',
+        'Serving tray', 'Infant bed', 'Sofa bed', 'Guacamole', 'Fox', 'Pizza',
+        'Snowplow', 'Jet ski', 'Refrigerator', 'Lantern', 'Convenience store',
+        'Sword', 'Rugby ball', 'Owl', 'Ostrich', 'Pancake', 'Strawberry',
+        'Carrot', 'Tart', 'Dice', 'Turkey', 'Rabbit', 'Invertebrate', 'Vase',
+        'Stool', 'Swim cap', 'Shower', 'Clock', 'Jellyfish', 'Aircraft',
+        'Chopsticks', 'Orange', 'Snake', 'Sewing machine', 'Kangaroo', 'Mixer',
+        'Food processor', 'Shrimp', 'Towel', 'Porcupine', 'Jaguar', 'Cannon',
+        'Limousine', 'Mule', 'Squirrel', 'Kitchen knife', 'Tiara', 'Tiger',
+        'Bow and arrow', 'Candy', 'Rhinoceros', 'Shark', 'Cricket ball',
+        'Doughnut', 'Plumbing fixture', 'Camel', 'Polar bear', 'Coin',
+        'Printer', 'Blender', 'Giraffe', 'Billiard table', 'Kettle',
+        'Dinosaur', 'Pineapple', 'Zucchini', 'Jug', 'Barge', 'Teapot',
+        'Golf ball', 'Binoculars', 'Scissors', 'Hot dog', 'Door handle',
+        'Seahorse', 'Bathtub', 'Leopard', 'Centipede', 'Grapefruit', 'Snowman',
+        'Cheetah', 'Alarm clock', 'Grape', 'Wrench', 'Wok', 'Bell pepper',
+        'Cake stand', 'Barrel', 'Woodpecker', 'Flute', 'Corded phone',
+        'Willow', 'Punching bag', 'Pomegranate', 'Telephone', 'Pear',
+        'Common fig', 'Bench', 'Wood-burning stove', 'Burrito', 'Nail',
+        'Turtle', 'Submarine sandwich', 'Drinking straw', 'Peach', 'Popcorn',
+        'Frying pan', 'Picnic basket', 'Honeycomb', 'Envelope', 'Mango',
+        'Cutting board', 'Pitcher', 'Stationary bicycle', 'Dumbbell',
+        'Personal care', 'Dog bed', 'Snowmobile', 'Oboe', 'Briefcase',
+        'Squash', 'Tick', 'Slow cooker', 'Coffeemaker', 'Measuring cup',
+        'Crutch', 'Stretcher', 'Screwdriver', 'Flashlight', 'Spatula',
+        'Pressure cooker', 'Ring binder', 'Beaker', 'Torch', 'Winter melon'
+    ]
+
+
+def oid_v6_classes() -> list:
+    """Class names of Open Images V6."""
+    return [
+        'Tortoise', 'Container', 'Magpie', 'Sea turtle', 'Football',
+        'Ambulance', 'Ladder', 'Toothbrush', 'Syringe', 'Sink', 'Toy',
+        'Organ (Musical Instrument)', 'Cassette deck', 'Apple', 'Human eye',
+        'Cosmetics', 'Paddle', 'Snowman', 'Beer', 'Chopsticks', 'Human beard',
+        'Bird', 'Parking meter', 'Traffic light', 'Croissant', 'Cucumber',
+        'Radish', 'Towel', 'Doll', 'Skull', 'Washing machine', 'Glove', 'Tick',
+        'Belt', 'Sunglasses', 'Banjo', 'Cart', 'Ball', 'Backpack', 'Bicycle',
+        'Home appliance', 'Centipede', 'Boat', 'Surfboard', 'Boot',
+        'Headphones', 'Hot dog', 'Shorts', 'Fast food', 'Bus', 'Boy',
+        'Screwdriver', 'Bicycle wheel', 'Barge', 'Laptop', 'Miniskirt',
+        'Drill (Tool)', 'Dress', 'Bear', 'Waffle', 'Pancake', 'Brown bear',
+        'Woodpecker', 'Blue jay', 'Pretzel', 'Bagel', 'Tower', 'Teapot',
+        'Person', 'Bow and arrow', 'Swimwear', 'Beehive', 'Brassiere', 'Bee',
+        'Bat (Animal)', 'Starfish', 'Popcorn', 'Burrito', 'Chainsaw',
+        'Balloon', 'Wrench', 'Tent', 'Vehicle registration plate', 'Lantern',
+        'Toaster', 'Flashlight', 'Billboard', 'Tiara', 'Limousine', 'Necklace',
+        'Carnivore', 'Scissors', 'Stairs', 'Computer keyboard', 'Printer',
+        'Traffic sign', 'Chair', 'Shirt', 'Poster', 'Cheese', 'Sock',
+        'Fire hydrant', 'Land vehicle', 'Earrings', 'Tie', 'Watercraft',
+        'Cabinetry', 'Suitcase', 'Muffin', 'Bidet', 'Snack', 'Snowmobile',
+        'Clock', 'Medical equipment', 'Cattle', 'Cello', 'Jet ski', 'Camel',
+        'Coat', 'Suit', 'Desk', 'Cat', 'Bronze sculpture', 'Juice', 'Gondola',
+        'Beetle', 'Cannon', 'Computer mouse', 'Cookie', 'Office building',
+        'Fountain', 'Coin', 'Calculator', 'Cocktail', 'Computer monitor',
+        'Box', 'Stapler', 'Christmas tree', 'Cowboy hat', 'Hiking equipment',
+        'Studio couch', 'Drum', 'Dessert', 'Wine rack', 'Drink', 'Zucchini',
+        'Ladle', 'Human mouth', 'Dairy Product', 'Dice', 'Oven', 'Dinosaur',
+        'Ratchet (Device)', 'Couch', 'Cricket ball', 'Winter melon', 'Spatula',
+        'Whiteboard', 'Pencil sharpener', 'Door', 'Hat', 'Shower', 'Eraser',
+        'Fedora', 'Guacamole', 'Dagger', 'Scarf', 'Dolphin', 'Sombrero',
+        'Tin can', 'Mug', 'Tap', 'Harbor seal', 'Stretcher', 'Can opener',
+        'Goggles', 'Human body', 'Roller skates', 'Coffee cup',
+        'Cutting board', 'Blender', 'Plumbing fixture', 'Stop sign',
+        'Office supplies', 'Volleyball (Ball)', 'Vase', 'Slow cooker',
+        'Wardrobe', 'Coffee', 'Whisk', 'Paper towel', 'Personal care', 'Food',
+        'Sun hat', 'Tree house', 'Flying disc', 'Skirt', 'Gas stove',
+        'Salt and pepper shakers', 'Mechanical fan', 'Face powder', 'Fax',
+        'Fruit', 'French fries', 'Nightstand', 'Barrel', 'Kite', 'Tart',
+        'Treadmill', 'Fox', 'Flag', 'French horn', 'Window blind',
+        'Human foot', 'Golf cart', 'Jacket', 'Egg (Food)', 'Street light',
+        'Guitar', 'Pillow', 'Human leg', 'Isopod', 'Grape', 'Human ear',
+        'Power plugs and sockets', 'Panda', 'Giraffe', 'Woman', 'Door handle',
+        'Rhinoceros', 'Bathtub', 'Goldfish', 'Houseplant', 'Goat',
+        'Baseball bat', 'Baseball glove', 'Mixing bowl',
+        'Marine invertebrates', 'Kitchen utensil', 'Light switch', 'House',
+        'Horse', 'Stationary bicycle', 'Hammer', 'Ceiling fan', 'Sofa bed',
+        'Adhesive tape', 'Harp', 'Sandal', 'Bicycle helmet', 'Saucer',
+        'Harpsichord', 'Human hair', 'Heater', 'Harmonica', 'Hamster',
+        'Curtain', 'Bed', 'Kettle', 'Fireplace', 'Scale', 'Drinking straw',
+        'Insect', 'Hair dryer', 'Kitchenware', 'Indoor rower', 'Invertebrate',
+        'Food processor', 'Bookcase', 'Refrigerator', 'Wood-burning stove',
+        'Punching bag', 'Common fig', 'Cocktail shaker', 'Jaguar (Animal)',
+        'Golf ball', 'Fashion accessory', 'Alarm clock', 'Filing cabinet',
+        'Artichoke', 'Table', 'Tableware', 'Kangaroo', 'Koala', 'Knife',
+        'Bottle', 'Bottle opener', 'Lynx', 'Lavender (Plant)', 'Lighthouse',
+        'Dumbbell', 'Human head', 'Bowl', 'Humidifier', 'Porch', 'Lizard',
+        'Billiard table', 'Mammal', 'Mouse', 'Motorcycle',
+        'Musical instrument', 'Swim cap', 'Frying pan', 'Snowplow',
+        'Bathroom cabinet', 'Missile', 'Bust', 'Man', 'Waffle iron', 'Milk',
+        'Ring binder', 'Plate', 'Mobile phone', 'Baked goods', 'Mushroom',
+        'Crutch', 'Pitcher (Container)', 'Mirror', 'Personal flotation device',
+        'Table tennis racket', 'Pencil case', 'Musical keyboard', 'Scoreboard',
+        'Briefcase', 'Kitchen knife', 'Nail (Construction)', 'Tennis ball',
+        'Plastic bag', 'Oboe', 'Chest of drawers', 'Ostrich', 'Piano', 'Girl',
+        'Plant', 'Potato', 'Hair spray', 'Sports equipment', 'Pasta',
+        'Penguin', 'Pumpkin', 'Pear', 'Infant bed', 'Polar bear', 'Mixer',
+        'Cupboard', 'Jacuzzi', 'Pizza', 'Digital clock', 'Pig', 'Reptile',
+        'Rifle', 'Lipstick', 'Skateboard', 'Raven', 'High heels', 'Red panda',
+        'Rose', 'Rabbit', 'Sculpture', 'Saxophone', 'Shotgun', 'Seafood',
+        'Submarine sandwich', 'Snowboard', 'Sword', 'Picture frame', 'Sushi',
+        'Loveseat', 'Ski', 'Squirrel', 'Tripod', 'Stethoscope', 'Submarine',
+        'Scorpion', 'Segway', 'Training bench', 'Snake', 'Coffee table',
+        'Skyscraper', 'Sheep', 'Television', 'Trombone', 'Tea', 'Tank', 'Taco',
+        'Telephone', 'Torch', 'Tiger', 'Strawberry', 'Trumpet', 'Tree',
+        'Tomato', 'Train', 'Tool', 'Picnic basket', 'Cooking spray',
+        'Trousers', 'Bowling equipment', 'Football helmet', 'Truck',
+        'Measuring cup', 'Coffeemaker', 'Violin', 'Vehicle', 'Handbag',
+        'Paper cutter', 'Wine', 'Weapon', 'Wheel', 'Worm', 'Wok', 'Whale',
+        'Zebra', 'Auto part', 'Jug', 'Pizza cutter', 'Cream', 'Monkey', 'Lion',
+        'Bread', 'Platter', 'Chicken', 'Eagle', 'Helicopter', 'Owl', 'Duck',
+        'Turtle', 'Hippopotamus', 'Crocodile', 'Toilet', 'Toilet paper',
+        'Squid', 'Clothing', 'Footwear', 'Lemon', 'Spider', 'Deer', 'Frog',
+        'Banana', 'Rocket', 'Wine glass', 'Countertop', 'Tablet computer',
+        'Waste container', 'Swimming pool', 'Dog', 'Book', 'Elephant', 'Shark',
+        'Candle', 'Leopard', 'Axe', 'Hand dryer', 'Soap dispenser',
+        'Porcupine', 'Flower', 'Canary', 'Cheetah', 'Palm tree', 'Hamburger',
+        'Maple', 'Building', 'Fish', 'Lobster', 'Garden Asparagus',
+        'Furniture', 'Hedgehog', 'Airplane', 'Spoon', 'Otter', 'Bull',
+        'Oyster', 'Horizontal bar', 'Convenience store', 'Bomb', 'Bench',
+        'Ice cream', 'Caterpillar', 'Butterfly', 'Parachute', 'Orange',
+        'Antelope', 'Beaker', 'Moths and butterflies', 'Window', 'Closet',
+        'Castle', 'Jellyfish', 'Goose', 'Mule', 'Swan', 'Peach', 'Coconut',
+        'Seat belt', 'Raccoon', 'Chisel', 'Fork', 'Lamp', 'Camera',
+        'Squash (Plant)', 'Racket', 'Human face', 'Human arm', 'Vegetable',
+        'Diaper', 'Unicycle', 'Falcon', 'Chime', 'Snail', 'Shellfish',
+        'Cabbage', 'Carrot', 'Mango', 'Jeans', 'Flowerpot', 'Pineapple',
+        'Drawer', 'Stool', 'Envelope', 'Cake', 'Dragonfly', 'Common sunflower',
+        'Microwave oven', 'Honeycomb', 'Marine mammal', 'Sea lion', 'Ladybug',
+        'Shelf', 'Watch', 'Candy', 'Salad', 'Parrot', 'Handgun', 'Sparrow',
+        'Van', 'Grinder', 'Spice rack', 'Light bulb', 'Corded phone',
+        'Sports uniform', 'Tennis racket', 'Wall clock', 'Serving tray',
+        'Kitchen & dining room table', 'Dog bed', 'Cake stand',
+        'Cat furniture', 'Bathroom accessory', 'Facial tissue holder',
+        'Pressure cooker', 'Kitchen appliance', 'Tire', 'Ruler',
+        'Luggage and bags', 'Microphone', 'Broccoli', 'Umbrella', 'Pastry',
+        'Grapefruit', 'Band-aid', 'Animal', 'Bell pepper', 'Turkey', 'Lily',
+        'Pomegranate', 'Doughnut', 'Glasses', 'Human nose', 'Pen', 'Ant',
+        'Car', 'Aircraft', 'Human hand', 'Skunk', 'Teddy bear', 'Watermelon',
+        'Cantaloupe', 'Dishwasher', 'Flute', 'Balance beam', 'Sandwich',
+        'Shrimp', 'Sewing machine', 'Binoculars', 'Rays and skates', 'Ipod',
+        'Accordion', 'Willow', 'Crab', 'Crown', 'Seahorse', 'Perfume',
+        'Alpaca', 'Taxi', 'Canoe', 'Remote control', 'Wheelchair',
+        'Rugby ball', 'Armadillo', 'Maracas', 'Helmet'
+    ]
+
+
+def objects365v1_classes() -> list:
+    """Class names of Objects365 V1."""
+    return [
+        'person', 'sneakers', 'chair', 'hat', 'lamp', 'bottle',
+        'cabinet/shelf', 'cup', 'car', 'glasses', 'picture/frame', 'desk',
+        'handbag', 'street lights', 'book', 'plate', 'helmet', 'leather shoes',
+        'pillow', 'glove', 'potted plant', 'bracelet', 'flower', 'tv',
+        'storage box', 'vase', 'bench', 'wine glass', 'boots', 'bowl',
+        'dining table', 'umbrella', 'boat', 'flag', 'speaker', 'trash bin/can',
+        'stool', 'backpack', 'couch', 'belt', 'carpet', 'basket',
+        'towel/napkin', 'slippers', 'barrel/bucket', 'coffee table', 'suv',
+        'toy', 'tie', 'bed', 'traffic light', 'pen/pencil', 'microphone',
+        'sandals', 'canned', 'necklace', 'mirror', 'faucet', 'bicycle',
+        'bread', 'high heels', 'ring', 'van', 'watch', 'sink', 'horse', 'fish',
+        'apple', 'camera', 'candle', 'teddy bear', 'cake', 'motorcycle',
+        'wild bird', 'laptop', 'knife', 'traffic sign', 'cell phone', 'paddle',
+        'truck', 'cow', 'power outlet', 'clock', 'drum', 'fork', 'bus',
+        'hanger', 'nightstand', 'pot/pan', 'sheep', 'guitar', 'traffic cone',
+        'tea pot', 'keyboard', 'tripod', 'hockey', 'fan', 'dog', 'spoon',
+        'blackboard/whiteboard', 'balloon', 'air conditioner', 'cymbal',
+        'mouse', 'telephone', 'pickup truck', 'orange', 'banana', 'airplane',
+        'luggage', 'skis', 'soccer', 'trolley', 'oven', 'remote',
+        'baseball glove', 'paper towel', 'refrigerator', 'train', 'tomato',
+        'machinery vehicle', 'tent', 'shampoo/shower gel', 'head phone',
+        'lantern', 'donut', 'cleaning products', 'sailboat', 'tangerine',
+        'pizza', 'kite', 'computer box', 'elephant', 'toiletries', 'gas stove',
+        'broccoli', 'toilet', 'stroller', 'shovel', 'baseball bat',
+        'microwave', 'skateboard', 'surfboard', 'surveillance camera', 'gun',
+        'life saver', 'cat', 'lemon', 'liquid soap', 'zebra', 'duck',
+        'sports car', 'giraffe', 'pumpkin', 'piano', 'stop sign', 'radiator',
+        'converter', 'tissue ', 'carrot', 'washing machine', 'vent', 'cookies',
+        'cutting/chopping board', 'tennis racket', 'candy',
+        'skating and skiing shoes', 'scissors', 'folder', 'baseball',
+        'strawberry', 'bow tie', 'pigeon', 'pepper', 'coffee machine',
+        'bathtub', 'snowboard', 'suitcase', 'grapes', 'ladder', 'pear',
+        'american football', 'basketball', 'potato', 'paint brush', 'printer',
+        'billiards', 'fire hydrant', 'goose', 'projector', 'sausage',
+        'fire extinguisher', 'extension cord', 'facial mask', 'tennis ball',
+        'chopsticks', 'electronic stove and gas stove', 'pie', 'frisbee',
+        'kettle', 'hamburger', 'golf club', 'cucumber', 'clutch', 'blender',
+        'tong', 'slide', 'hot dog', 'toothbrush', 'facial cleanser', 'mango',
+        'deer', 'egg', 'violin', 'marker', 'ship', 'chicken', 'onion',
+        'ice cream', 'tape', 'wheelchair', 'plum', 'bar soap', 'scale',
+        'watermelon', 'cabbage', 'router/modem', 'golf ball', 'pine apple',
+        'crane', 'fire truck', 'peach', 'cello', 'notepaper', 'tricycle',
+        'toaster', 'helicopter', 'green beans', 'brush', 'carriage', 'cigar',
+        'earphone', 'penguin', 'hurdle', 'swing', 'radio', 'CD',
+        'parking meter', 'swan', 'garlic', 'french fries', 'horn', 'avocado',
+        'saxophone', 'trumpet', 'sandwich', 'cue', 'kiwi fruit', 'bear',
+        'fishing rod', 'cherry', 'tablet', 'green vegetables', 'nuts', 'corn',
+        'key', 'screwdriver', 'globe', 'broom', 'pliers', 'volleyball',
+        'hammer', 'eggplant', 'trophy', 'dates', 'board eraser', 'rice',
+        'tape measure/ruler', 'dumbbell', 'hamimelon', 'stapler', 'camel',
+        'lettuce', 'goldfish', 'meat balls', 'medal', 'toothpaste', 'antelope',
+        'shrimp', 'rickshaw', 'trombone', 'pomegranate', 'coconut',
+        'jellyfish', 'mushroom', 'calculator', 'treadmill', 'butterfly',
+        'egg tart', 'cheese', 'pig', 'pomelo', 'race car', 'rice cooker',
+        'tuba', 'crosswalk sign', 'papaya', 'hair drier', 'green onion',
+        'chips', 'dolphin', 'sushi', 'urinal', 'donkey', 'electric drill',
+        'spring rolls', 'tortoise/turtle', 'parrot', 'flute', 'measuring cup',
+        'shark', 'steak', 'poker card', 'binoculars', 'llama', 'radish',
+        'noodles', 'yak', 'mop', 'crab', 'microscope', 'barbell', 'bread/bun',
+        'baozi', 'lion', 'red cabbage', 'polar bear', 'lighter', 'seal',
+        'mangosteen', 'comb', 'eraser', 'pitaya', 'scallop', 'pencil case',
+        'saw', 'table tennis paddle', 'okra', 'starfish', 'eagle', 'monkey',
+        'durian', 'game board', 'rabbit', 'french horn', 'ambulance',
+        'asparagus', 'hoverboard', 'pasta', 'target', 'hotair balloon',
+        'chainsaw', 'lobster', 'iron', 'flashlight'
+    ]
+
+
+def objects365v2_classes() -> list:
+    """Class names of Objects365 V2."""
+    return [
+        'Person', 'Sneakers', 'Chair', 'Other Shoes', 'Hat', 'Car', 'Lamp',
+        'Glasses', 'Bottle', 'Desk', 'Cup', 'Street Lights', 'Cabinet/shelf',
+        'Handbag/Satchel', 'Bracelet', 'Plate', 'Picture/Frame', 'Helmet',
+        'Book', 'Gloves', 'Storage box', 'Boat', 'Leather Shoes', 'Flower',
+        'Bench', 'Potted Plant', 'Bowl/Basin', 'Flag', 'Pillow', 'Boots',
+        'Vase', 'Microphone', 'Necklace', 'Ring', 'SUV', 'Wine Glass', 'Belt',
+        'Moniter/TV', 'Backpack', 'Umbrella', 'Traffic Light', 'Speaker',
+        'Watch', 'Tie', 'Trash bin Can', 'Slippers', 'Bicycle', 'Stool',
+        'Barrel/bucket', 'Van', 'Couch', 'Sandals', 'Bakset', 'Drum',
+        'Pen/Pencil', 'Bus', 'Wild Bird', 'High Heels', 'Motorcycle', 'Guitar',
+        'Carpet', 'Cell Phone', 'Bread', 'Camera', 'Canned', 'Truck',
+        'Traffic cone', 'Cymbal', 'Lifesaver', 'Towel', 'Stuffed Toy',
+        'Candle', 'Sailboat', 'Laptop', 'Awning', 'Bed', 'Faucet', 'Tent',
+        'Horse', 'Mirror', 'Power outlet', 'Sink', 'Apple', 'Air Conditioner',
+        'Knife', 'Hockey Stick', 'Paddle', 'Pickup Truck', 'Fork',
+        'Traffic Sign', 'Ballon', 'Tripod', 'Dog', 'Spoon', 'Clock', 'Pot',
+        'Cow', 'Cake', 'Dinning Table', 'Sheep', 'Hanger',
+        'Blackboard/Whiteboard', 'Napkin', 'Other Fish', 'Orange/Tangerine',
+        'Toiletry', 'Keyboard', 'Tomato', 'Lantern', 'Machinery Vehicle',
+        'Fan', 'Green Vegetables', 'Banana', 'Baseball Glove', 'Airplane',
+        'Mouse', 'Train', 'Pumpkin', 'Soccer', 'Skiboard', 'Luggage',
+        'Nightstand', 'Tea pot', 'Telephone', 'Trolley', 'Head Phone',
+        'Sports Car', 'Stop Sign', 'Dessert', 'Scooter', 'Stroller', 'Crane',
+        'Remote', 'Refrigerator', 'Oven', 'Lemon', 'Duck', 'Baseball Bat',
+        'Surveillance Camera', 'Cat', 'Jug', 'Broccoli', 'Piano', 'Pizza',
+        'Elephant', 'Skateboard', 'Surfboard', 'Gun',
+        'Skating and Skiing shoes', 'Gas stove', 'Donut', 'Bow Tie', 'Carrot',
+        'Toilet', 'Kite', 'Strawberry', 'Other Balls', 'Shovel', 'Pepper',
+        'Computer Box', 'Toilet Paper', 'Cleaning Products', 'Chopsticks',
+        'Microwave', 'Pigeon', 'Baseball', 'Cutting/chopping Board',
+        'Coffee Table', 'Side Table', 'Scissors', 'Marker', 'Pie', 'Ladder',
+        'Snowboard', 'Cookies', 'Radiator', 'Fire Hydrant', 'Basketball',
+        'Zebra', 'Grape', 'Giraffe', 'Potato', 'Sausage', 'Tricycle', 'Violin',
+        'Egg', 'Fire Extinguisher', 'Candy', 'Fire Truck', 'Billards',
+        'Converter', 'Bathtub', 'Wheelchair', 'Golf Club', 'Briefcase',
+        'Cucumber', 'Cigar/Cigarette ', 'Paint Brush', 'Pear', 'Heavy Truck',
+        'Hamburger', 'Extractor', 'Extention Cord', 'Tong', 'Tennis Racket',
+        'Folder', 'American Football', 'earphone', 'Mask', 'Kettle', 'Tennis',
+        'Ship', 'Swing', 'Coffee Machine', 'Slide', 'Carriage', 'Onion',
+        'Green beans', 'Projector', 'Frisbee',
+        'Washing Machine/Drying Machine', 'Chicken', 'Printer', 'Watermelon',
+        'Saxophone', 'Tissue', 'Toothbrush', 'Ice cream', 'Hotair ballon',
+        'Cello', 'French Fries', 'Scale', 'Trophy', 'Cabbage', 'Hot dog',
+        'Blender', 'Peach', 'Rice', 'Wallet/Purse', 'Volleyball', 'Deer',
+        'Goose', 'Tape', 'Tablet', 'Cosmetics', 'Trumpet', 'Pineapple',
+        'Golf Ball', 'Ambulance', 'Parking meter', 'Mango', 'Key', 'Hurdle',
+        'Fishing Rod', 'Medal', 'Flute', 'Brush', 'Penguin', 'Megaphone',
+        'Corn', 'Lettuce', 'Garlic', 'Swan', 'Helicopter', 'Green Onion',
+        'Sandwich', 'Nuts', 'Speed Limit Sign', 'Induction Cooker', 'Broom',
+        'Trombone', 'Plum', 'Rickshaw', 'Goldfish', 'Kiwi fruit',
+        'Router/modem', 'Poker Card', 'Toaster', 'Shrimp', 'Sushi', 'Cheese',
+        'Notepaper', 'Cherry', 'Pliers', 'CD', 'Pasta', 'Hammer', 'Cue',
+        'Avocado', 'Hamimelon', 'Flask', 'Mushroon', 'Screwdriver', 'Soap',
+        'Recorder', 'Bear', 'Eggplant', 'Board Eraser', 'Coconut',
+        'Tape Measur/ Ruler', 'Pig', 'Showerhead', 'Globe', 'Chips', 'Steak',
+        'Crosswalk Sign', 'Stapler', 'Campel', 'Formula 1 ', 'Pomegranate',
+        'Dishwasher', 'Crab', 'Hoverboard', 'Meat ball', 'Rice Cooker', 'Tuba',
+        'Calculator', 'Papaya', 'Antelope', 'Parrot', 'Seal', 'Buttefly',
+        'Dumbbell', 'Donkey', 'Lion', 'Urinal', 'Dolphin', 'Electric Drill',
+        'Hair Dryer', 'Egg tart', 'Jellyfish', 'Treadmill', 'Lighter',
+        'Grapefruit', 'Game board', 'Mop', 'Radish', 'Baozi', 'Target',
+        'French', 'Spring Rolls', 'Monkey', 'Rabbit', 'Pencil Case', 'Yak',
+        'Red Cabbage', 'Binoculars', 'Asparagus', 'Barbell', 'Scallop',
+        'Noddles', 'Comb', 'Dumpling', 'Oyster', 'Table Teniis paddle',
+        'Cosmetics Brush/Eyeliner Pencil', 'Chainsaw', 'Eraser', 'Lobster',
+        'Durian', 'Okra', 'Lipstick', 'Cosmetics Mirror', 'Curling',
+        'Table Tennis '
+    ]
+
+
+def lvis_classes() -> list:
+    """Class names of LVIS."""
+    return [
+        'aerosol_can', 'air_conditioner', 'airplane', 'alarm_clock', 'alcohol',
+        'alligator', 'almond', 'ambulance', 'amplifier', 'anklet', 'antenna',
+        'apple', 'applesauce', 'apricot', 'apron', 'aquarium',
+        'arctic_(type_of_shoe)', 'armband', 'armchair', 'armoire', 'armor',
+        'artichoke', 'trash_can', 'ashtray', 'asparagus', 'atomizer',
+        'avocado', 'award', 'awning', 'ax', 'baboon', 'baby_buggy',
+        'basketball_backboard', 'backpack', 'handbag', 'suitcase', 'bagel',
+        'bagpipe', 'baguet', 'bait', 'ball', 'ballet_skirt', 'balloon',
+        'bamboo', 'banana', 'Band_Aid', 'bandage', 'bandanna', 'banjo',
+        'banner', 'barbell', 'barge', 'barrel', 'barrette', 'barrow',
+        'baseball_base', 'baseball', 'baseball_bat', 'baseball_cap',
+        'baseball_glove', 'basket', 'basketball', 'bass_horn', 'bat_(animal)',
+        'bath_mat', 'bath_towel', 'bathrobe', 'bathtub', 'batter_(food)',
+        'battery', 'beachball', 'bead', 'bean_curd', 'beanbag', 'beanie',
+        'bear', 'bed', 'bedpan', 'bedspread', 'cow', 'beef_(food)', 'beeper',
+        'beer_bottle', 'beer_can', 'beetle', 'bell', 'bell_pepper', 'belt',
+        'belt_buckle', 'bench', 'beret', 'bib', 'Bible', 'bicycle', 'visor',
+        'billboard', 'binder', 'binoculars', 'bird', 'birdfeeder', 'birdbath',
+        'birdcage', 'birdhouse', 'birthday_cake', 'birthday_card',
+        'pirate_flag', 'black_sheep', 'blackberry', 'blackboard', 'blanket',
+        'blazer', 'blender', 'blimp', 'blinker', 'blouse', 'blueberry',
+        'gameboard', 'boat', 'bob', 'bobbin', 'bobby_pin', 'boiled_egg',
+        'bolo_tie', 'deadbolt', 'bolt', 'bonnet', 'book', 'bookcase',
+        'booklet', 'bookmark', 'boom_microphone', 'boot', 'bottle',
+        'bottle_opener', 'bouquet', 'bow_(weapon)', 'bow_(decorative_ribbons)',
+        'bow-tie', 'bowl', 'pipe_bowl', 'bowler_hat', 'bowling_ball', 'box',
+        'boxing_glove', 'suspenders', 'bracelet', 'brass_plaque', 'brassiere',
+        'bread-bin', 'bread', 'breechcloth', 'bridal_gown', 'briefcase',
+        'broccoli', 'broach', 'broom', 'brownie', 'brussels_sprouts',
+        'bubble_gum', 'bucket', 'horse_buggy', 'bull', 'bulldog', 'bulldozer',
+        'bullet_train', 'bulletin_board', 'bulletproof_vest', 'bullhorn',
+        'bun', 'bunk_bed', 'buoy', 'burrito', 'bus_(vehicle)', 'business_card',
+        'butter', 'butterfly', 'button', 'cab_(taxi)', 'cabana', 'cabin_car',
+        'cabinet', 'locker', 'cake', 'calculator', 'calendar', 'calf',
+        'camcorder', 'camel', 'camera', 'camera_lens', 'camper_(vehicle)',
+        'can', 'can_opener', 'candle', 'candle_holder', 'candy_bar',
+        'candy_cane', 'walking_cane', 'canister', 'canoe', 'cantaloup',
+        'canteen', 'cap_(headwear)', 'bottle_cap', 'cape', 'cappuccino',
+        'car_(automobile)', 'railcar_(part_of_a_train)', 'elevator_car',
+        'car_battery', 'identity_card', 'card', 'cardigan', 'cargo_ship',
+        'carnation', 'horse_carriage', 'carrot', 'tote_bag', 'cart', 'carton',
+        'cash_register', 'casserole', 'cassette', 'cast', 'cat', 'cauliflower',
+        'cayenne_(spice)', 'CD_player', 'celery', 'cellular_telephone',
+        'chain_mail', 'chair', 'chaise_longue', 'chalice', 'chandelier',
+        'chap', 'checkbook', 'checkerboard', 'cherry', 'chessboard',
+        'chicken_(animal)', 'chickpea', 'chili_(vegetable)', 'chime',
+        'chinaware', 'crisp_(potato_chip)', 'poker_chip', 'chocolate_bar',
+        'chocolate_cake', 'chocolate_milk', 'chocolate_mousse', 'choker',
+        'chopping_board', 'chopstick', 'Christmas_tree', 'slide', 'cider',
+        'cigar_box', 'cigarette', 'cigarette_case', 'cistern', 'clarinet',
+        'clasp', 'cleansing_agent', 'cleat_(for_securing_rope)', 'clementine',
+        'clip', 'clipboard', 'clippers_(for_plants)', 'cloak', 'clock',
+        'clock_tower', 'clothes_hamper', 'clothespin', 'clutch_bag', 'coaster',
+        'coat', 'coat_hanger', 'coatrack', 'cock', 'cockroach',
+        'cocoa_(beverage)', 'coconut', 'coffee_maker', 'coffee_table',
+        'coffeepot', 'coil', 'coin', 'colander', 'coleslaw',
+        'coloring_material', 'combination_lock', 'pacifier', 'comic_book',
+        'compass', 'computer_keyboard', 'condiment', 'cone', 'control',
+        'convertible_(automobile)', 'sofa_bed', 'cooker', 'cookie',
+        'cooking_utensil', 'cooler_(for_food)', 'cork_(bottle_plug)',
+        'corkboard', 'corkscrew', 'edible_corn', 'cornbread', 'cornet',
+        'cornice', 'cornmeal', 'corset', 'costume', 'cougar', 'coverall',
+        'cowbell', 'cowboy_hat', 'crab_(animal)', 'crabmeat', 'cracker',
+        'crape', 'crate', 'crayon', 'cream_pitcher', 'crescent_roll', 'crib',
+        'crock_pot', 'crossbar', 'crouton', 'crow', 'crowbar', 'crown',
+        'crucifix', 'cruise_ship', 'police_cruiser', 'crumb', 'crutch',
+        'cub_(animal)', 'cube', 'cucumber', 'cufflink', 'cup', 'trophy_cup',
+        'cupboard', 'cupcake', 'hair_curler', 'curling_iron', 'curtain',
+        'cushion', 'cylinder', 'cymbal', 'dagger', 'dalmatian', 'dartboard',
+        'date_(fruit)', 'deck_chair', 'deer', 'dental_floss', 'desk',
+        'detergent', 'diaper', 'diary', 'die', 'dinghy', 'dining_table', 'tux',
+        'dish', 'dish_antenna', 'dishrag', 'dishtowel', 'dishwasher',
+        'dishwasher_detergent', 'dispenser', 'diving_board', 'Dixie_cup',
+        'dog', 'dog_collar', 'doll', 'dollar', 'dollhouse', 'dolphin',
+        'domestic_ass', 'doorknob', 'doormat', 'doughnut', 'dove', 'dragonfly',
+        'drawer', 'underdrawers', 'dress', 'dress_hat', 'dress_suit',
+        'dresser', 'drill', 'drone', 'dropper', 'drum_(musical_instrument)',
+        'drumstick', 'duck', 'duckling', 'duct_tape', 'duffel_bag', 'dumbbell',
+        'dumpster', 'dustpan', 'eagle', 'earphone', 'earplug', 'earring',
+        'easel', 'eclair', 'eel', 'egg', 'egg_roll', 'egg_yolk', 'eggbeater',
+        'eggplant', 'electric_chair', 'refrigerator', 'elephant', 'elk',
+        'envelope', 'eraser', 'escargot', 'eyepatch', 'falcon', 'fan',
+        'faucet', 'fedora', 'ferret', 'Ferris_wheel', 'ferry', 'fig_(fruit)',
+        'fighter_jet', 'figurine', 'file_cabinet', 'file_(tool)', 'fire_alarm',
+        'fire_engine', 'fire_extinguisher', 'fire_hose', 'fireplace',
+        'fireplug', 'first-aid_kit', 'fish', 'fish_(food)', 'fishbowl',
+        'fishing_rod', 'flag', 'flagpole', 'flamingo', 'flannel', 'flap',
+        'flash', 'flashlight', 'fleece', 'flip-flop_(sandal)',
+        'flipper_(footwear)', 'flower_arrangement', 'flute_glass', 'foal',
+        'folding_chair', 'food_processor', 'football_(American)',
+        'football_helmet', 'footstool', 'fork', 'forklift', 'freight_car',
+        'French_toast', 'freshener', 'frisbee', 'frog', 'fruit_juice',
+        'frying_pan', 'fudge', 'funnel', 'futon', 'gag', 'garbage',
+        'garbage_truck', 'garden_hose', 'gargle', 'gargoyle', 'garlic',
+        'gasmask', 'gazelle', 'gelatin', 'gemstone', 'generator',
+        'giant_panda', 'gift_wrap', 'ginger', 'giraffe', 'cincture',
+        'glass_(drink_container)', 'globe', 'glove', 'goat', 'goggles',
+        'goldfish', 'golf_club', 'golfcart', 'gondola_(boat)', 'goose',
+        'gorilla', 'gourd', 'grape', 'grater', 'gravestone', 'gravy_boat',
+        'green_bean', 'green_onion', 'griddle', 'grill', 'grits', 'grizzly',
+        'grocery_bag', 'guitar', 'gull', 'gun', 'hairbrush', 'hairnet',
+        'hairpin', 'halter_top', 'ham', 'hamburger', 'hammer', 'hammock',
+        'hamper', 'hamster', 'hair_dryer', 'hand_glass', 'hand_towel',
+        'handcart', 'handcuff', 'handkerchief', 'handle', 'handsaw',
+        'hardback_book', 'harmonium', 'hat', 'hatbox', 'veil', 'headband',
+        'headboard', 'headlight', 'headscarf', 'headset',
+        'headstall_(for_horses)', 'heart', 'heater', 'helicopter', 'helmet',
+        'heron', 'highchair', 'hinge', 'hippopotamus', 'hockey_stick', 'hog',
+        'home_plate_(baseball)', 'honey', 'fume_hood', 'hook', 'hookah',
+        'hornet', 'horse', 'hose', 'hot-air_balloon', 'hotplate', 'hot_sauce',
+        'hourglass', 'houseboat', 'hummingbird', 'hummus', 'polar_bear',
+        'icecream', 'popsicle', 'ice_maker', 'ice_pack', 'ice_skate',
+        'igniter', 'inhaler', 'iPod', 'iron_(for_clothing)', 'ironing_board',
+        'jacket', 'jam', 'jar', 'jean', 'jeep', 'jelly_bean', 'jersey',
+        'jet_plane', 'jewel', 'jewelry', 'joystick', 'jumpsuit', 'kayak',
+        'keg', 'kennel', 'kettle', 'key', 'keycard', 'kilt', 'kimono',
+        'kitchen_sink', 'kitchen_table', 'kite', 'kitten', 'kiwi_fruit',
+        'knee_pad', 'knife', 'knitting_needle', 'knob', 'knocker_(on_a_door)',
+        'koala', 'lab_coat', 'ladder', 'ladle', 'ladybug', 'lamb_(animal)',
+        'lamb-chop', 'lamp', 'lamppost', 'lampshade', 'lantern', 'lanyard',
+        'laptop_computer', 'lasagna', 'latch', 'lawn_mower', 'leather',
+        'legging_(clothing)', 'Lego', 'legume', 'lemon', 'lemonade', 'lettuce',
+        'license_plate', 'life_buoy', 'life_jacket', 'lightbulb',
+        'lightning_rod', 'lime', 'limousine', 'lion', 'lip_balm', 'liquor',
+        'lizard', 'log', 'lollipop', 'speaker_(stereo_equipment)', 'loveseat',
+        'machine_gun', 'magazine', 'magnet', 'mail_slot', 'mailbox_(at_home)',
+        'mallard', 'mallet', 'mammoth', 'manatee', 'mandarin_orange', 'manger',
+        'manhole', 'map', 'marker', 'martini', 'mascot', 'mashed_potato',
+        'masher', 'mask', 'mast', 'mat_(gym_equipment)', 'matchbox',
+        'mattress', 'measuring_cup', 'measuring_stick', 'meatball', 'medicine',
+        'melon', 'microphone', 'microscope', 'microwave_oven', 'milestone',
+        'milk', 'milk_can', 'milkshake', 'minivan', 'mint_candy', 'mirror',
+        'mitten', 'mixer_(kitchen_tool)', 'money',
+        'monitor_(computer_equipment) computer_monitor', 'monkey', 'motor',
+        'motor_scooter', 'motor_vehicle', 'motorcycle', 'mound_(baseball)',
+        'mouse_(computer_equipment)', 'mousepad', 'muffin', 'mug', 'mushroom',
+        'music_stool', 'musical_instrument', 'nailfile', 'napkin',
+        'neckerchief', 'necklace', 'necktie', 'needle', 'nest', 'newspaper',
+        'newsstand', 'nightshirt', 'nosebag_(for_animals)',
+        'noseband_(for_animals)', 'notebook', 'notepad', 'nut', 'nutcracker',
+        'oar', 'octopus_(food)', 'octopus_(animal)', 'oil_lamp', 'olive_oil',
+        'omelet', 'onion', 'orange_(fruit)', 'orange_juice', 'ostrich',
+        'ottoman', 'oven', 'overalls_(clothing)', 'owl', 'packet', 'inkpad',
+        'pad', 'paddle', 'padlock', 'paintbrush', 'painting', 'pajamas',
+        'palette', 'pan_(for_cooking)', 'pan_(metal_container)', 'pancake',
+        'pantyhose', 'papaya', 'paper_plate', 'paper_towel', 'paperback_book',
+        'paperweight', 'parachute', 'parakeet', 'parasail_(sports)', 'parasol',
+        'parchment', 'parka', 'parking_meter', 'parrot',
+        'passenger_car_(part_of_a_train)', 'passenger_ship', 'passport',
+        'pastry', 'patty_(food)', 'pea_(food)', 'peach', 'peanut_butter',
+        'pear', 'peeler_(tool_for_fruit_and_vegetables)', 'wooden_leg',
+        'pegboard', 'pelican', 'pen', 'pencil', 'pencil_box',
+        'pencil_sharpener', 'pendulum', 'penguin', 'pennant', 'penny_(coin)',
+        'pepper', 'pepper_mill', 'perfume', 'persimmon', 'person', 'pet',
+        'pew_(church_bench)', 'phonebook', 'phonograph_record', 'piano',
+        'pickle', 'pickup_truck', 'pie', 'pigeon', 'piggy_bank', 'pillow',
+        'pin_(non_jewelry)', 'pineapple', 'pinecone', 'ping-pong_ball',
+        'pinwheel', 'tobacco_pipe', 'pipe', 'pistol', 'pita_(bread)',
+        'pitcher_(vessel_for_liquid)', 'pitchfork', 'pizza', 'place_mat',
+        'plate', 'platter', 'playpen', 'pliers', 'plow_(farm_equipment)',
+        'plume', 'pocket_watch', 'pocketknife', 'poker_(fire_stirring_tool)',
+        'pole', 'polo_shirt', 'poncho', 'pony', 'pool_table', 'pop_(soda)',
+        'postbox_(public)', 'postcard', 'poster', 'pot', 'flowerpot', 'potato',
+        'potholder', 'pottery', 'pouch', 'power_shovel', 'prawn', 'pretzel',
+        'printer', 'projectile_(weapon)', 'projector', 'propeller', 'prune',
+        'pudding', 'puffer_(fish)', 'puffin', 'pug-dog', 'pumpkin', 'puncher',
+        'puppet', 'puppy', 'quesadilla', 'quiche', 'quilt', 'rabbit',
+        'race_car', 'racket', 'radar', 'radiator', 'radio_receiver', 'radish',
+        'raft', 'rag_doll', 'raincoat', 'ram_(animal)', 'raspberry', 'rat',
+        'razorblade', 'reamer_(juicer)', 'rearview_mirror', 'receipt',
+        'recliner', 'record_player', 'reflector', 'remote_control',
+        'rhinoceros', 'rib_(food)', 'rifle', 'ring', 'river_boat', 'road_map',
+        'robe', 'rocking_chair', 'rodent', 'roller_skate', 'Rollerblade',
+        'rolling_pin', 'root_beer', 'router_(computer_equipment)',
+        'rubber_band', 'runner_(carpet)', 'plastic_bag',
+        'saddle_(on_an_animal)', 'saddle_blanket', 'saddlebag', 'safety_pin',
+        'sail', 'salad', 'salad_plate', 'salami', 'salmon_(fish)',
+        'salmon_(food)', 'salsa', 'saltshaker', 'sandal_(type_of_shoe)',
+        'sandwich', 'satchel', 'saucepan', 'saucer', 'sausage', 'sawhorse',
+        'saxophone', 'scale_(measuring_instrument)', 'scarecrow', 'scarf',
+        'school_bus', 'scissors', 'scoreboard', 'scraper', 'screwdriver',
+        'scrubbing_brush', 'sculpture', 'seabird', 'seahorse', 'seaplane',
+        'seashell', 'sewing_machine', 'shaker', 'shampoo', 'shark',
+        'sharpener', 'Sharpie', 'shaver_(electric)', 'shaving_cream', 'shawl',
+        'shears', 'sheep', 'shepherd_dog', 'sherbert', 'shield', 'shirt',
+        'shoe', 'shopping_bag', 'shopping_cart', 'short_pants', 'shot_glass',
+        'shoulder_bag', 'shovel', 'shower_head', 'shower_cap',
+        'shower_curtain', 'shredder_(for_paper)', 'signboard', 'silo', 'sink',
+        'skateboard', 'skewer', 'ski', 'ski_boot', 'ski_parka', 'ski_pole',
+        'skirt', 'skullcap', 'sled', 'sleeping_bag', 'sling_(bandage)',
+        'slipper_(footwear)', 'smoothie', 'snake', 'snowboard', 'snowman',
+        'snowmobile', 'soap', 'soccer_ball', 'sock', 'sofa', 'softball',
+        'solar_array', 'sombrero', 'soup', 'soup_bowl', 'soupspoon',
+        'sour_cream', 'soya_milk', 'space_shuttle', 'sparkler_(fireworks)',
+        'spatula', 'spear', 'spectacles', 'spice_rack', 'spider', 'crawfish',
+        'sponge', 'spoon', 'sportswear', 'spotlight', 'squid_(food)',
+        'squirrel', 'stagecoach', 'stapler_(stapling_machine)', 'starfish',
+        'statue_(sculpture)', 'steak_(food)', 'steak_knife', 'steering_wheel',
+        'stepladder', 'step_stool', 'stereo_(sound_system)', 'stew', 'stirrer',
+        'stirrup', 'stool', 'stop_sign', 'brake_light', 'stove', 'strainer',
+        'strap', 'straw_(for_drinking)', 'strawberry', 'street_sign',
+        'streetlight', 'string_cheese', 'stylus', 'subwoofer', 'sugar_bowl',
+        'sugarcane_(plant)', 'suit_(clothing)', 'sunflower', 'sunglasses',
+        'sunhat', 'surfboard', 'sushi', 'mop', 'sweat_pants', 'sweatband',
+        'sweater', 'sweatshirt', 'sweet_potato', 'swimsuit', 'sword',
+        'syringe', 'Tabasco_sauce', 'table-tennis_table', 'table',
+        'table_lamp', 'tablecloth', 'tachometer', 'taco', 'tag', 'taillight',
+        'tambourine', 'army_tank', 'tank_(storage_vessel)',
+        'tank_top_(clothing)', 'tape_(sticky_cloth_or_paper)', 'tape_measure',
+        'tapestry', 'tarp', 'tartan', 'tassel', 'tea_bag', 'teacup',
+        'teakettle', 'teapot', 'teddy_bear', 'telephone', 'telephone_booth',
+        'telephone_pole', 'telephoto_lens', 'television_camera',
+        'television_set', 'tennis_ball', 'tennis_racket', 'tequila',
+        'thermometer', 'thermos_bottle', 'thermostat', 'thimble', 'thread',
+        'thumbtack', 'tiara', 'tiger', 'tights_(clothing)', 'timer', 'tinfoil',
+        'tinsel', 'tissue_paper', 'toast_(food)', 'toaster', 'toaster_oven',
+        'toilet', 'toilet_tissue', 'tomato', 'tongs', 'toolbox', 'toothbrush',
+        'toothpaste', 'toothpick', 'cover', 'tortilla', 'tow_truck', 'towel',
+        'towel_rack', 'toy', 'tractor_(farm_equipment)', 'traffic_light',
+        'dirt_bike', 'trailer_truck', 'train_(railroad_vehicle)', 'trampoline',
+        'tray', 'trench_coat', 'triangle_(musical_instrument)', 'tricycle',
+        'tripod', 'trousers', 'truck', 'truffle_(chocolate)', 'trunk', 'vat',
+        'turban', 'turkey_(food)', 'turnip', 'turtle', 'turtleneck_(clothing)',
+        'typewriter', 'umbrella', 'underwear', 'unicycle', 'urinal', 'urn',
+        'vacuum_cleaner', 'vase', 'vending_machine', 'vent', 'vest',
+        'videotape', 'vinegar', 'violin', 'vodka', 'volleyball', 'vulture',
+        'waffle', 'waffle_iron', 'wagon', 'wagon_wheel', 'walking_stick',
+        'wall_clock', 'wall_socket', 'wallet', 'walrus', 'wardrobe',
+        'washbasin', 'automatic_washer', 'watch', 'water_bottle',
+        'water_cooler', 'water_faucet', 'water_heater', 'water_jug',
+        'water_gun', 'water_scooter', 'water_ski', 'water_tower',
+        'watering_can', 'watermelon', 'weathervane', 'webcam', 'wedding_cake',
+        'wedding_ring', 'wet_suit', 'wheel', 'wheelchair', 'whipped_cream',
+        'whistle', 'wig', 'wind_chime', 'windmill', 'window_box_(for_plants)',
+        'windshield_wiper', 'windsock', 'wine_bottle', 'wine_bucket',
+        'wineglass', 'blinder_(for_horses)', 'wok', 'wolf', 'wooden_spoon',
+        'wreath', 'wrench', 'wristband', 'wristlet', 'yacht', 'yogurt',
+        'yoke_(animal_equipment)', 'zebra', 'zucchini'
+    ]
+
+
+dataset_aliases = {
+    'voc': ['voc', 'pascal_voc', 'voc07', 'voc12'],
+    'imagenet_det': ['det', 'imagenet_det', 'ilsvrc_det'],
+    'imagenet_vid': ['vid', 'imagenet_vid', 'ilsvrc_vid'],
+    'coco': ['coco', 'mscoco', 'ms_coco'],
+    'coco_panoptic': ['coco_panoptic', 'panoptic'],
+    'wider_face': ['WIDERFaceDataset', 'wider_face', 'WIDERFace'],
+    'cityscapes': ['cityscapes'],
+    'oid_challenge': ['oid_challenge', 'openimages_challenge'],
+    'oid_v6': ['oid_v6', 'openimages_v6'],
+    'objects365v1': ['objects365v1', 'obj365v1'],
+    'objects365v2': ['objects365v2', 'obj365v2'],
+    'lvis': ['lvis', 'lvis_v1'],
+}
+
+
+def get_classes(dataset) -> list:
+    """Get class names of a dataset."""
+    alias2name = {}
+    for name, aliases in dataset_aliases.items():
+        for alias in aliases:
+            alias2name[alias] = name
+
+    if is_str(dataset):
+        if dataset in alias2name:
+            labels = eval(alias2name[dataset] + '_classes()')
+        else:
+            raise ValueError(f'Unrecognized dataset: {dataset}')
+    else:
+        raise TypeError(f'dataset must a str, but got {type(dataset)}')
+    return labels
diff --git a/mmdetection/mmdet/evaluation/functional/mean_ap.py b/mmdetection/mmdet/evaluation/functional/mean_ap.py
new file mode 100644
index 00000000..989972a4
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/functional/mean_ap.py
@@ -0,0 +1,792 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from multiprocessing import Pool
+
+import numpy as np
+from mmengine.logging import print_log
+from mmengine.utils import is_str
+from terminaltables import AsciiTable
+
+from .bbox_overlaps import bbox_overlaps
+from .class_names import get_classes
+
+
+def average_precision(recalls, precisions, mode='area'):
+    """Calculate average precision (for single or multiple scales).
+
+    Args:
+        recalls (ndarray): shape (num_scales, num_dets) or (num_dets, )
+        precisions (ndarray): shape (num_scales, num_dets) or (num_dets, )
+        mode (str): 'area' or '11points', 'area' means calculating the area
+            under precision-recall curve, '11points' means calculating
+            the average precision of recalls at [0, 0.1, ..., 1]
+
+    Returns:
+        float or ndarray: calculated average precision
+    """
+    no_scale = False
+    if recalls.ndim == 1:
+        no_scale = True
+        recalls = recalls[np.newaxis, :]
+        precisions = precisions[np.newaxis, :]
+    assert recalls.shape == precisions.shape and recalls.ndim == 2
+    num_scales = recalls.shape[0]
+    ap = np.zeros(num_scales, dtype=np.float32)
+    if mode == 'area':
+        zeros = np.zeros((num_scales, 1), dtype=recalls.dtype)
+        ones = np.ones((num_scales, 1), dtype=recalls.dtype)
+        mrec = np.hstack((zeros, recalls, ones))
+        mpre = np.hstack((zeros, precisions, zeros))
+        for i in range(mpre.shape[1] - 1, 0, -1):
+            mpre[:, i - 1] = np.maximum(mpre[:, i - 1], mpre[:, i])
+        for i in range(num_scales):
+            ind = np.where(mrec[i, 1:] != mrec[i, :-1])[0]
+            ap[i] = np.sum(
+                (mrec[i, ind + 1] - mrec[i, ind]) * mpre[i, ind + 1])
+    elif mode == '11points':
+        for i in range(num_scales):
+            for thr in np.arange(0, 1 + 1e-3, 0.1):
+                precs = precisions[i, recalls[i, :] >= thr]
+                prec = precs.max() if precs.size > 0 else 0
+                ap[i] += prec
+        ap /= 11
+    else:
+        raise ValueError(
+            'Unrecognized mode, only "area" and "11points" are supported')
+    if no_scale:
+        ap = ap[0]
+    return ap
+
+
+def tpfp_imagenet(det_bboxes,
+                  gt_bboxes,
+                  gt_bboxes_ignore=None,
+                  default_iou_thr=0.5,
+                  area_ranges=None,
+                  use_legacy_coordinate=False,
+                  **kwargs):
+    """Check if detected bboxes are true positive or false positive.
+
+    Args:
+        det_bbox (ndarray): Detected bboxes of this image, of shape (m, 5).
+        gt_bboxes (ndarray): GT bboxes of this image, of shape (n, 4).
+        gt_bboxes_ignore (ndarray): Ignored gt bboxes of this image,
+            of shape (k, 4). Defaults to None
+        default_iou_thr (float): IoU threshold to be considered as matched for
+            medium and large bboxes (small ones have special rules).
+            Defaults to 0.5.
+        area_ranges (list[tuple] | None): Range of bbox areas to be evaluated,
+            in the format [(min1, max1), (min2, max2), ...]. Defaults to None.
+        use_legacy_coordinate (bool): Whether to use coordinate system in
+            mmdet v1.x. which means width, height should be
+            calculated as 'x2 - x1 + 1` and 'y2 - y1 + 1' respectively.
+            Defaults to False.
+
+    Returns:
+        tuple[np.ndarray]: (tp, fp) whose elements are 0 and 1. The shape of
+        each array is (num_scales, m).
+    """
+
+    if not use_legacy_coordinate:
+        extra_length = 0.
+    else:
+        extra_length = 1.
+
+    # an indicator of ignored gts
+    gt_ignore_inds = np.concatenate(
+        (np.zeros(gt_bboxes.shape[0],
+                  dtype=bool), np.ones(gt_bboxes_ignore.shape[0], dtype=bool)))
+    # stack gt_bboxes and gt_bboxes_ignore for convenience
+    gt_bboxes = np.vstack((gt_bboxes, gt_bboxes_ignore))
+
+    num_dets = det_bboxes.shape[0]
+    num_gts = gt_bboxes.shape[0]
+    if area_ranges is None:
+        area_ranges = [(None, None)]
+    num_scales = len(area_ranges)
+    # tp and fp are of shape (num_scales, num_gts), each row is tp or fp
+    # of a certain scale.
+    tp = np.zeros((num_scales, num_dets), dtype=np.float32)
+    fp = np.zeros((num_scales, num_dets), dtype=np.float32)
+    if gt_bboxes.shape[0] == 0:
+        if area_ranges == [(None, None)]:
+            fp[...] = 1
+        else:
+            det_areas = (
+                det_bboxes[:, 2] - det_bboxes[:, 0] + extra_length) * (
+                    det_bboxes[:, 3] - det_bboxes[:, 1] + extra_length)
+            for i, (min_area, max_area) in enumerate(area_ranges):
+                fp[i, (det_areas >= min_area) & (det_areas < max_area)] = 1
+        return tp, fp
+    ious = bbox_overlaps(
+        det_bboxes, gt_bboxes - 1, use_legacy_coordinate=use_legacy_coordinate)
+    gt_w = gt_bboxes[:, 2] - gt_bboxes[:, 0] + extra_length
+    gt_h = gt_bboxes[:, 3] - gt_bboxes[:, 1] + extra_length
+    iou_thrs = np.minimum((gt_w * gt_h) / ((gt_w + 10.0) * (gt_h + 10.0)),
+                          default_iou_thr)
+    # sort all detections by scores in descending order
+    sort_inds = np.argsort(-det_bboxes[:, -1])
+    for k, (min_area, max_area) in enumerate(area_ranges):
+        gt_covered = np.zeros(num_gts, dtype=bool)
+        # if no area range is specified, gt_area_ignore is all False
+        if min_area is None:
+            gt_area_ignore = np.zeros_like(gt_ignore_inds, dtype=bool)
+        else:
+            gt_areas = gt_w * gt_h
+            gt_area_ignore = (gt_areas < min_area) | (gt_areas >= max_area)
+        for i in sort_inds:
+            max_iou = -1
+            matched_gt = -1
+            # find best overlapped available gt
+            for j in range(num_gts):
+                # different from PASCAL VOC: allow finding other gts if the
+                # best overlapped ones are already matched by other det bboxes
+                if gt_covered[j]:
+                    continue
+                elif ious[i, j] >= iou_thrs[j] and ious[i, j] > max_iou:
+                    max_iou = ious[i, j]
+                    matched_gt = j
+            # there are 4 cases for a det bbox:
+            # 1. it matches a gt, tp = 1, fp = 0
+            # 2. it matches an ignored gt, tp = 0, fp = 0
+            # 3. it matches no gt and within area range, tp = 0, fp = 1
+            # 4. it matches no gt but is beyond area range, tp = 0, fp = 0
+            if matched_gt >= 0:
+                gt_covered[matched_gt] = 1
+                if not (gt_ignore_inds[matched_gt]
+                        or gt_area_ignore[matched_gt]):
+                    tp[k, i] = 1
+            elif min_area is None:
+                fp[k, i] = 1
+            else:
+                bbox = det_bboxes[i, :4]
+                area = (bbox[2] - bbox[0] + extra_length) * (
+                    bbox[3] - bbox[1] + extra_length)
+                if area >= min_area and area < max_area:
+                    fp[k, i] = 1
+    return tp, fp
+
+
+def tpfp_default(det_bboxes,
+                 gt_bboxes,
+                 gt_bboxes_ignore=None,
+                 iou_thr=0.5,
+                 area_ranges=None,
+                 use_legacy_coordinate=False,
+                 **kwargs):
+    """Check if detected bboxes are true positive or false positive.
+
+    Args:
+        det_bbox (ndarray): Detected bboxes of this image, of shape (m, 5).
+        gt_bboxes (ndarray): GT bboxes of this image, of shape (n, 4).
+        gt_bboxes_ignore (ndarray): Ignored gt bboxes of this image,
+            of shape (k, 4). Defaults to None
+        iou_thr (float): IoU threshold to be considered as matched.
+            Defaults to 0.5.
+        area_ranges (list[tuple] | None): Range of bbox areas to be
+            evaluated, in the format [(min1, max1), (min2, max2), ...].
+            Defaults to None.
+        use_legacy_coordinate (bool): Whether to use coordinate system in
+            mmdet v1.x. which means width, height should be
+            calculated as 'x2 - x1 + 1` and 'y2 - y1 + 1' respectively.
+            Defaults to False.
+
+    Returns:
+        tuple[np.ndarray]: (tp, fp) whose elements are 0 and 1. The shape of
+        each array is (num_scales, m).
+    """
+
+    if not use_legacy_coordinate:
+        extra_length = 0.
+    else:
+        extra_length = 1.
+
+    # an indicator of ignored gts
+    gt_ignore_inds = np.concatenate(
+        (np.zeros(gt_bboxes.shape[0],
+                  dtype=bool), np.ones(gt_bboxes_ignore.shape[0], dtype=bool)))
+    # stack gt_bboxes and gt_bboxes_ignore for convenience
+    gt_bboxes = np.vstack((gt_bboxes, gt_bboxes_ignore))
+
+    num_dets = det_bboxes.shape[0]
+    num_gts = gt_bboxes.shape[0]
+    if area_ranges is None:
+        area_ranges = [(None, None)]
+    num_scales = len(area_ranges)
+    # tp and fp are of shape (num_scales, num_gts), each row is tp or fp of
+    # a certain scale
+    tp = np.zeros((num_scales, num_dets), dtype=np.float32)
+    fp = np.zeros((num_scales, num_dets), dtype=np.float32)
+
+    # if there is no gt bboxes in this image, then all det bboxes
+    # within area range are false positives
+    if gt_bboxes.shape[0] == 0:
+        if area_ranges == [(None, None)]:
+            fp[...] = 1
+        else:
+            det_areas = (
+                det_bboxes[:, 2] - det_bboxes[:, 0] + extra_length) * (
+                    det_bboxes[:, 3] - det_bboxes[:, 1] + extra_length)
+            for i, (min_area, max_area) in enumerate(area_ranges):
+                fp[i, (det_areas >= min_area) & (det_areas < max_area)] = 1
+        return tp, fp
+
+    ious = bbox_overlaps(
+        det_bboxes, gt_bboxes, use_legacy_coordinate=use_legacy_coordinate)
+    # for each det, the max iou with all gts
+    ious_max = ious.max(axis=1)
+    # for each det, which gt overlaps most with it
+    ious_argmax = ious.argmax(axis=1)
+    # sort all dets in descending order by scores
+    sort_inds = np.argsort(-det_bboxes[:, -1])
+    for k, (min_area, max_area) in enumerate(area_ranges):
+        gt_covered = np.zeros(num_gts, dtype=bool)
+        # if no area range is specified, gt_area_ignore is all False
+        if min_area is None:
+            gt_area_ignore = np.zeros_like(gt_ignore_inds, dtype=bool)
+        else:
+            gt_areas = (gt_bboxes[:, 2] - gt_bboxes[:, 0] + extra_length) * (
+                gt_bboxes[:, 3] - gt_bboxes[:, 1] + extra_length)
+            gt_area_ignore = (gt_areas < min_area) | (gt_areas >= max_area)
+        for i in sort_inds:
+            if ious_max[i] >= iou_thr:
+                matched_gt = ious_argmax[i]
+                if not (gt_ignore_inds[matched_gt]
+                        or gt_area_ignore[matched_gt]):
+                    if not gt_covered[matched_gt]:
+                        gt_covered[matched_gt] = True
+                        tp[k, i] = 1
+                    else:
+                        fp[k, i] = 1
+                # otherwise ignore this detected bbox, tp = 0, fp = 0
+            elif min_area is None:
+                fp[k, i] = 1
+            else:
+                bbox = det_bboxes[i, :4]
+                area = (bbox[2] - bbox[0] + extra_length) * (
+                    bbox[3] - bbox[1] + extra_length)
+                if area >= min_area and area < max_area:
+                    fp[k, i] = 1
+    return tp, fp
+
+
+def tpfp_openimages(det_bboxes,
+                    gt_bboxes,
+                    gt_bboxes_ignore=None,
+                    iou_thr=0.5,
+                    area_ranges=None,
+                    use_legacy_coordinate=False,
+                    gt_bboxes_group_of=None,
+                    use_group_of=True,
+                    ioa_thr=0.5,
+                    **kwargs):
+    """Check if detected bboxes are true positive or false positive.
+
+    Args:
+        det_bbox (ndarray): Detected bboxes of this image, of shape (m, 5).
+        gt_bboxes (ndarray): GT bboxes of this image, of shape (n, 4).
+        gt_bboxes_ignore (ndarray): Ignored gt bboxes of this image,
+            of shape (k, 4). Defaults to None
+        iou_thr (float): IoU threshold to be considered as matched.
+            Defaults to 0.5.
+        area_ranges (list[tuple] | None): Range of bbox areas to be
+            evaluated, in the format [(min1, max1), (min2, max2), ...].
+            Defaults to None.
+        use_legacy_coordinate (bool): Whether to use coordinate system in
+            mmdet v1.x. which means width, height should be
+            calculated as 'x2 - x1 + 1` and 'y2 - y1 + 1' respectively.
+            Defaults to False.
+        gt_bboxes_group_of (ndarray): GT group_of of this image, of shape
+            (k, 1). Defaults to None
+        use_group_of (bool): Whether to use group of when calculate TP and FP,
+            which only used in OpenImages evaluation. Defaults to True.
+        ioa_thr (float | None): IoA threshold to be considered as matched,
+            which only used in OpenImages evaluation. Defaults to 0.5.
+
+    Returns:
+        tuple[np.ndarray]: Returns a tuple (tp, fp, det_bboxes), where
+        (tp, fp) whose elements are 0 and 1. The shape of each array is
+        (num_scales, m). (det_bboxes) whose will filter those are not
+        matched by group of gts when processing Open Images evaluation.
+        The shape is (num_scales, m).
+    """
+
+    if not use_legacy_coordinate:
+        extra_length = 0.
+    else:
+        extra_length = 1.
+
+    # an indicator of ignored gts
+    gt_ignore_inds = np.concatenate(
+        (np.zeros(gt_bboxes.shape[0],
+                  dtype=bool), np.ones(gt_bboxes_ignore.shape[0], dtype=bool)))
+    # stack gt_bboxes and gt_bboxes_ignore for convenience
+    gt_bboxes = np.vstack((gt_bboxes, gt_bboxes_ignore))
+
+    num_dets = det_bboxes.shape[0]
+    num_gts = gt_bboxes.shape[0]
+    if area_ranges is None:
+        area_ranges = [(None, None)]
+    num_scales = len(area_ranges)
+    # tp and fp are of shape (num_scales, num_gts), each row is tp or fp of
+    # a certain scale
+    tp = np.zeros((num_scales, num_dets), dtype=np.float32)
+    fp = np.zeros((num_scales, num_dets), dtype=np.float32)
+
+    # if there is no gt bboxes in this image, then all det bboxes
+    # within area range are false positives
+    if gt_bboxes.shape[0] == 0:
+        if area_ranges == [(None, None)]:
+            fp[...] = 1
+        else:
+            det_areas = (
+                det_bboxes[:, 2] - det_bboxes[:, 0] + extra_length) * (
+                    det_bboxes[:, 3] - det_bboxes[:, 1] + extra_length)
+            for i, (min_area, max_area) in enumerate(area_ranges):
+                fp[i, (det_areas >= min_area) & (det_areas < max_area)] = 1
+        return tp, fp, det_bboxes
+
+    if gt_bboxes_group_of is not None and use_group_of:
+        # if handle group-of boxes, divided gt boxes into two parts:
+        # non-group-of and group-of.Then calculate ious and ioas through
+        # non-group-of group-of gts respectively. This only used in
+        # OpenImages evaluation.
+        assert gt_bboxes_group_of.shape[0] == gt_bboxes.shape[0]
+        non_group_gt_bboxes = gt_bboxes[~gt_bboxes_group_of]
+        group_gt_bboxes = gt_bboxes[gt_bboxes_group_of]
+        num_gts_group = group_gt_bboxes.shape[0]
+        ious = bbox_overlaps(det_bboxes, non_group_gt_bboxes)
+        ioas = bbox_overlaps(det_bboxes, group_gt_bboxes, mode='iof')
+    else:
+        # if not consider group-of boxes, only calculate ious through gt boxes
+        ious = bbox_overlaps(
+            det_bboxes, gt_bboxes, use_legacy_coordinate=use_legacy_coordinate)
+        ioas = None
+
+    if ious.shape[1] > 0:
+        # for each det, the max iou with all gts
+        ious_max = ious.max(axis=1)
+        # for each det, which gt overlaps most with it
+        ious_argmax = ious.argmax(axis=1)
+        # sort all dets in descending order by scores
+        sort_inds = np.argsort(-det_bboxes[:, -1])
+        for k, (min_area, max_area) in enumerate(area_ranges):
+            gt_covered = np.zeros(num_gts, dtype=bool)
+            # if no area range is specified, gt_area_ignore is all False
+            if min_area is None:
+                gt_area_ignore = np.zeros_like(gt_ignore_inds, dtype=bool)
+            else:
+                gt_areas = (
+                    gt_bboxes[:, 2] - gt_bboxes[:, 0] + extra_length) * (
+                        gt_bboxes[:, 3] - gt_bboxes[:, 1] + extra_length)
+                gt_area_ignore = (gt_areas < min_area) | (gt_areas >= max_area)
+            for i in sort_inds:
+                if ious_max[i] >= iou_thr:
+                    matched_gt = ious_argmax[i]
+                    if not (gt_ignore_inds[matched_gt]
+                            or gt_area_ignore[matched_gt]):
+                        if not gt_covered[matched_gt]:
+                            gt_covered[matched_gt] = True
+                            tp[k, i] = 1
+                        else:
+                            fp[k, i] = 1
+                    # otherwise ignore this detected bbox, tp = 0, fp = 0
+                elif min_area is None:
+                    fp[k, i] = 1
+                else:
+                    bbox = det_bboxes[i, :4]
+                    area = (bbox[2] - bbox[0] + extra_length) * (
+                        bbox[3] - bbox[1] + extra_length)
+                    if area >= min_area and area < max_area:
+                        fp[k, i] = 1
+    else:
+        # if there is no no-group-of gt bboxes in this image,
+        # then all det bboxes within area range are false positives.
+        # Only used in OpenImages evaluation.
+        if area_ranges == [(None, None)]:
+            fp[...] = 1
+        else:
+            det_areas = (
+                det_bboxes[:, 2] - det_bboxes[:, 0] + extra_length) * (
+                    det_bboxes[:, 3] - det_bboxes[:, 1] + extra_length)
+            for i, (min_area, max_area) in enumerate(area_ranges):
+                fp[i, (det_areas >= min_area) & (det_areas < max_area)] = 1
+
+    if ioas is None or ioas.shape[1] <= 0:
+        return tp, fp, det_bboxes
+    else:
+        # The evaluation of group-of TP and FP are done in two stages:
+        # 1. All detections are first matched to non group-of boxes; true
+        #    positives are determined.
+        # 2. Detections that are determined as false positives are matched
+        #    against group-of boxes and calculated group-of TP and FP.
+        # Only used in OpenImages evaluation.
+        det_bboxes_group = np.zeros(
+            (num_scales, ioas.shape[1], det_bboxes.shape[1]), dtype=float)
+        match_group_of = np.zeros((num_scales, num_dets), dtype=bool)
+        tp_group = np.zeros((num_scales, num_gts_group), dtype=np.float32)
+        ioas_max = ioas.max(axis=1)
+        # for each det, which gt overlaps most with it
+        ioas_argmax = ioas.argmax(axis=1)
+        # sort all dets in descending order by scores
+        sort_inds = np.argsort(-det_bboxes[:, -1])
+        for k, (min_area, max_area) in enumerate(area_ranges):
+            box_is_covered = tp[k]
+            # if no area range is specified, gt_area_ignore is all False
+            if min_area is None:
+                gt_area_ignore = np.zeros_like(gt_ignore_inds, dtype=bool)
+            else:
+                gt_areas = (gt_bboxes[:, 2] - gt_bboxes[:, 0]) * (
+                    gt_bboxes[:, 3] - gt_bboxes[:, 1])
+                gt_area_ignore = (gt_areas < min_area) | (gt_areas >= max_area)
+            for i in sort_inds:
+                matched_gt = ioas_argmax[i]
+                if not box_is_covered[i]:
+                    if ioas_max[i] >= ioa_thr:
+                        if not (gt_ignore_inds[matched_gt]
+                                or gt_area_ignore[matched_gt]):
+                            if not tp_group[k, matched_gt]:
+                                tp_group[k, matched_gt] = 1
+                                match_group_of[k, i] = True
+                            else:
+                                match_group_of[k, i] = True
+
+                            if det_bboxes_group[k, matched_gt, -1] < \
+                                    det_bboxes[i, -1]:
+                                det_bboxes_group[k, matched_gt] = \
+                                    det_bboxes[i]
+
+        fp_group = (tp_group <= 0).astype(float)
+        tps = []
+        fps = []
+        # concatenate tp, fp, and det-boxes which not matched group of
+        # gt boxes and tp_group, fp_group, and det_bboxes_group which
+        # matched group of boxes respectively.
+        for i in range(num_scales):
+            tps.append(
+                np.concatenate((tp[i][~match_group_of[i]], tp_group[i])))
+            fps.append(
+                np.concatenate((fp[i][~match_group_of[i]], fp_group[i])))
+            det_bboxes = np.concatenate(
+                (det_bboxes[~match_group_of[i]], det_bboxes_group[i]))
+
+        tp = np.vstack(tps)
+        fp = np.vstack(fps)
+        return tp, fp, det_bboxes
+
+
+def get_cls_results(det_results, annotations, class_id):
+    """Get det results and gt information of a certain class.
+
+    Args:
+        det_results (list[list]): Same as `eval_map()`.
+        annotations (list[dict]): Same as `eval_map()`.
+        class_id (int): ID of a specific class.
+
+    Returns:
+        tuple[list[np.ndarray]]: detected bboxes, gt bboxes, ignored gt bboxes
+    """
+    cls_dets = [img_res[class_id] for img_res in det_results]
+    cls_gts = []
+    cls_gts_ignore = []
+    for ann in annotations:
+        gt_inds = ann['labels'] == class_id
+        cls_gts.append(ann['bboxes'][gt_inds, :])
+
+        if ann.get('labels_ignore', None) is not None:
+            ignore_inds = ann['labels_ignore'] == class_id
+            cls_gts_ignore.append(ann['bboxes_ignore'][ignore_inds, :])
+        else:
+            cls_gts_ignore.append(np.empty((0, 4), dtype=np.float32))
+
+    return cls_dets, cls_gts, cls_gts_ignore
+
+
+def get_cls_group_ofs(annotations, class_id):
+    """Get `gt_group_of` of a certain class, which is used in Open Images.
+
+    Args:
+        annotations (list[dict]): Same as `eval_map()`.
+        class_id (int): ID of a specific class.
+
+    Returns:
+        list[np.ndarray]: `gt_group_of` of a certain class.
+    """
+    gt_group_ofs = []
+    for ann in annotations:
+        gt_inds = ann['labels'] == class_id
+        if ann.get('gt_is_group_ofs', None) is not None:
+            gt_group_ofs.append(ann['gt_is_group_ofs'][gt_inds])
+        else:
+            gt_group_ofs.append(np.empty((0, 1), dtype=bool))
+
+    return gt_group_ofs
+
+
+def eval_map(det_results,
+             annotations,
+             scale_ranges=None,
+             iou_thr=0.5,
+             ioa_thr=None,
+             dataset=None,
+             logger=None,
+             tpfp_fn=None,
+             nproc=4,
+             use_legacy_coordinate=False,
+             use_group_of=False,
+             eval_mode='area'):
+    """Evaluate mAP of a dataset.
+
+    Args:
+        det_results (list[list]): [[cls1_det, cls2_det, ...], ...].
+            The outer list indicates images, and the inner list indicates
+            per-class detected bboxes.
+        annotations (list[dict]): Ground truth annotations where each item of
+            the list indicates an image. Keys of annotations are:
+
+            - `bboxes`: numpy array of shape (n, 4)
+            - `labels`: numpy array of shape (n, )
+            - `bboxes_ignore` (optional): numpy array of shape (k, 4)
+            - `labels_ignore` (optional): numpy array of shape (k, )
+        scale_ranges (list[tuple] | None): Range of scales to be evaluated,
+            in the format [(min1, max1), (min2, max2), ...]. A range of
+            (32, 64) means the area range between (32**2, 64**2).
+            Defaults to None.
+        iou_thr (float): IoU threshold to be considered as matched.
+            Defaults to 0.5.
+        ioa_thr (float | None): IoA threshold to be considered as matched,
+            which only used in OpenImages evaluation. Defaults to None.
+        dataset (list[str] | str | None): Dataset name or dataset classes,
+            there are minor differences in metrics for different datasets, e.g.
+            "voc", "imagenet_det", etc. Defaults to None.
+        logger (logging.Logger | str | None): The way to print the mAP
+            summary. See `mmengine.logging.print_log()` for details.
+            Defaults to None.
+        tpfp_fn (callable | None): The function used to determine true/
+            false positives. If None, :func:`tpfp_default` is used as default
+            unless dataset is 'det' or 'vid' (:func:`tpfp_imagenet` in this
+            case). If it is given as a function, then this function is used
+            to evaluate tp & fp. Default None.
+        nproc (int): Processes used for computing TP and FP.
+            Defaults to 4.
+        use_legacy_coordinate (bool): Whether to use coordinate system in
+            mmdet v1.x. which means width, height should be
+            calculated as 'x2 - x1 + 1` and 'y2 - y1 + 1' respectively.
+            Defaults to False.
+        use_group_of (bool): Whether to use group of when calculate TP and FP,
+            which only used in OpenImages evaluation. Defaults to False.
+        eval_mode (str): 'area' or '11points', 'area' means calculating the
+            area under precision-recall curve, '11points' means calculating
+            the average precision of recalls at [0, 0.1, ..., 1],
+            PASCAL VOC2007 uses `11points` as default evaluate mode, while
+            others are 'area'. Defaults to 'area'.
+
+    Returns:
+        tuple: (mAP, [dict, dict, ...])
+    """
+    assert len(det_results) == len(annotations)
+    assert eval_mode in ['area', '11points'], \
+        f'Unrecognized {eval_mode} mode, only "area" and "11points" ' \
+        'are supported'
+    if not use_legacy_coordinate:
+        extra_length = 0.
+    else:
+        extra_length = 1.
+
+    num_imgs = len(det_results)
+    num_scales = len(scale_ranges) if scale_ranges is not None else 1
+    num_classes = len(det_results[0])  # positive class num
+    area_ranges = ([(rg[0]**2, rg[1]**2) for rg in scale_ranges]
+                   if scale_ranges is not None else None)
+
+    # There is no need to use multi processes to process
+    # when num_imgs = 1 .
+    if num_imgs > 1:
+        assert nproc > 0, 'nproc must be at least one.'
+        nproc = min(nproc, num_imgs)
+        pool = Pool(nproc)
+
+    eval_results = []
+    for i in range(num_classes):
+        # get gt and det bboxes of this class
+        cls_dets, cls_gts, cls_gts_ignore = get_cls_results(
+            det_results, annotations, i)
+        # choose proper function according to datasets to compute tp and fp
+        if tpfp_fn is None:
+            if dataset in ['det', 'vid']:
+                tpfp_fn = tpfp_imagenet
+            elif dataset in ['oid_challenge', 'oid_v6'] \
+                    or use_group_of is True:
+                tpfp_fn = tpfp_openimages
+            else:
+                tpfp_fn = tpfp_default
+        if not callable(tpfp_fn):
+            raise ValueError(
+                f'tpfp_fn has to be a function or None, but got {tpfp_fn}')
+
+        if num_imgs > 1:
+            # compute tp and fp for each image with multiple processes
+            args = []
+            if use_group_of:
+                # used in Open Images Dataset evaluation
+                gt_group_ofs = get_cls_group_ofs(annotations, i)
+                args.append(gt_group_ofs)
+                args.append([use_group_of for _ in range(num_imgs)])
+            if ioa_thr is not None:
+                args.append([ioa_thr for _ in range(num_imgs)])
+
+            tpfp = pool.starmap(
+                tpfp_fn,
+                zip(cls_dets, cls_gts, cls_gts_ignore,
+                    [iou_thr for _ in range(num_imgs)],
+                    [area_ranges for _ in range(num_imgs)],
+                    [use_legacy_coordinate for _ in range(num_imgs)], *args))
+        else:
+            tpfp = tpfp_fn(
+                cls_dets[0],
+                cls_gts[0],
+                cls_gts_ignore[0],
+                iou_thr,
+                area_ranges,
+                use_legacy_coordinate,
+                gt_bboxes_group_of=(get_cls_group_ofs(annotations, i)[0]
+                                    if use_group_of else None),
+                use_group_of=use_group_of,
+                ioa_thr=ioa_thr)
+            tpfp = [tpfp]
+
+        if use_group_of:
+            tp, fp, cls_dets = tuple(zip(*tpfp))
+        else:
+            tp, fp = tuple(zip(*tpfp))
+        # calculate gt number of each scale
+        # ignored gts or gts beyond the specific scale are not counted
+        num_gts = np.zeros(num_scales, dtype=int)
+        for j, bbox in enumerate(cls_gts):
+            if area_ranges is None:
+                num_gts[0] += bbox.shape[0]
+            else:
+                gt_areas = (bbox[:, 2] - bbox[:, 0] + extra_length) * (
+                    bbox[:, 3] - bbox[:, 1] + extra_length)
+                for k, (min_area, max_area) in enumerate(area_ranges):
+                    num_gts[k] += np.sum((gt_areas >= min_area)
+                                         & (gt_areas < max_area))
+        # sort all det bboxes by score, also sort tp and fp
+        cls_dets = np.vstack(cls_dets)
+        num_dets = cls_dets.shape[0]
+        sort_inds = np.argsort(-cls_dets[:, -1])
+        tp = np.hstack(tp)[:, sort_inds]
+        fp = np.hstack(fp)[:, sort_inds]
+        # calculate recall and precision with tp and fp
+        tp = np.cumsum(tp, axis=1)
+        fp = np.cumsum(fp, axis=1)
+        eps = np.finfo(np.float32).eps
+        recalls = tp / np.maximum(num_gts[:, np.newaxis], eps)
+        precisions = tp / np.maximum((tp + fp), eps)
+        # calculate AP
+        if scale_ranges is None:
+            recalls = recalls[0, :]
+            precisions = precisions[0, :]
+            num_gts = num_gts.item()
+        ap = average_precision(recalls, precisions, eval_mode)
+        eval_results.append({
+            'num_gts': num_gts,
+            'num_dets': num_dets,
+            'recall': recalls,
+            'precision': precisions,
+            'ap': ap
+        })
+
+    if num_imgs > 1:
+        pool.close()
+
+    if scale_ranges is not None:
+        # shape (num_classes, num_scales)
+        all_ap = np.vstack([cls_result['ap'] for cls_result in eval_results])
+        all_num_gts = np.vstack(
+            [cls_result['num_gts'] for cls_result in eval_results])
+        mean_ap = []
+        for i in range(num_scales):
+            if np.any(all_num_gts[:, i] > 0):
+                mean_ap.append(all_ap[all_num_gts[:, i] > 0, i].mean())
+            else:
+                mean_ap.append(0.0)
+    else:
+        aps = []
+        for cls_result in eval_results:
+            if cls_result['num_gts'] > 0:
+                aps.append(cls_result['ap'])
+        mean_ap = np.array(aps).mean().item() if aps else 0.0
+
+    print_map_summary(
+        mean_ap, eval_results, dataset, area_ranges, logger=logger)
+
+    return mean_ap, eval_results
+
+
+def print_map_summary(mean_ap,
+                      results,
+                      dataset=None,
+                      scale_ranges=None,
+                      logger=None):
+    """Print mAP and results of each class.
+
+    A table will be printed to show the gts/dets/recall/AP of each class and
+    the mAP.
+
+    Args:
+        mean_ap (float): Calculated from `eval_map()`.
+        results (list[dict]): Calculated from `eval_map()`.
+        dataset (list[str] | str | None): Dataset name or dataset classes.
+        scale_ranges (list[tuple] | None): Range of scales to be evaluated.
+        logger (logging.Logger | str | None): The way to print the mAP
+            summary. See `mmengine.logging.print_log()` for details.
+            Defaults to None.
+    """
+
+    if logger == 'silent':
+        return
+
+    if isinstance(results[0]['ap'], np.ndarray):
+        num_scales = len(results[0]['ap'])
+    else:
+        num_scales = 1
+
+    if scale_ranges is not None:
+        assert len(scale_ranges) == num_scales
+
+    num_classes = len(results)
+
+    recalls = np.zeros((num_scales, num_classes), dtype=np.float32)
+    aps = np.zeros((num_scales, num_classes), dtype=np.float32)
+    num_gts = np.zeros((num_scales, num_classes), dtype=int)
+    for i, cls_result in enumerate(results):
+        if cls_result['recall'].size > 0:
+            recalls[:, i] = np.array(cls_result['recall'], ndmin=2)[:, -1]
+        aps[:, i] = cls_result['ap']
+        num_gts[:, i] = cls_result['num_gts']
+
+    if dataset is None:
+        label_names = [str(i) for i in range(num_classes)]
+    elif is_str(dataset):
+        label_names = get_classes(dataset)
+    else:
+        label_names = dataset
+
+    if not isinstance(mean_ap, list):
+        mean_ap = [mean_ap]
+
+    header = ['class', 'gts', 'dets', 'recall', 'ap']
+    for i in range(num_scales):
+        if scale_ranges is not None:
+            print_log(f'Scale range {scale_ranges[i]}', logger=logger)
+        table_data = [header]
+        for j in range(num_classes):
+            row_data = [
+                label_names[j], num_gts[i, j], results[j]['num_dets'],
+                f'{recalls[i, j]:.3f}', f'{aps[i, j]:.3f}'
+            ]
+            table_data.append(row_data)
+        table_data.append(['mAP', '', '', '', f'{mean_ap[i]:.3f}'])
+        table = AsciiTable(table_data)
+        table.inner_footing_row_border = True
+        print_log('\n' + table.table, logger=logger)
diff --git a/mmdetection/mmdet/evaluation/functional/panoptic_utils.py b/mmdetection/mmdet/evaluation/functional/panoptic_utils.py
new file mode 100644
index 00000000..6faa8ed5
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/functional/panoptic_utils.py
@@ -0,0 +1,228 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Copyright (c) 2018, Alexander Kirillov
+# This file supports `backend_args` for `panopticapi`,
+# the source code is copied from `panopticapi`,
+# only the way to load the gt images is modified.
+import multiprocessing
+import os
+
+import mmcv
+import numpy as np
+from mmengine.fileio import get
+
+# A custom value to distinguish instance ID and category ID; need to
+# be greater than the number of categories.
+# For a pixel in the panoptic result map:
+#   pan_id = ins_id * INSTANCE_OFFSET + cat_id
+INSTANCE_OFFSET = 1000
+
+try:
+    from panopticapi.evaluation import OFFSET, VOID, PQStat
+    from panopticapi.utils import rgb2id
+except ImportError:
+    PQStat = None
+    rgb2id = None
+    VOID = 0
+    OFFSET = 256 * 256 * 256
+
+
+def pq_compute_single_core(proc_id,
+                           annotation_set,
+                           gt_folder,
+                           pred_folder,
+                           categories,
+                           backend_args=None,
+                           print_log=False):
+    """The single core function to evaluate the metric of Panoptic
+    Segmentation.
+
+    Same as the function with the same name in `panopticapi`. Only the function
+    to load the images is changed to use the file client.
+
+    Args:
+        proc_id (int): The id of the mini process.
+        gt_folder (str): The path of the ground truth images.
+        pred_folder (str): The path of the prediction images.
+        categories (str): The categories of the dataset.
+        backend_args (object): The Backend of the dataset. If None,
+            the backend will be set to `local`.
+        print_log (bool): Whether to print the log. Defaults to False.
+    """
+    if PQStat is None:
+        raise RuntimeError(
+            'panopticapi is not installed, please install it by: '
+            'pip install git+https://github.com/cocodataset/'
+            'panopticapi.git.')
+
+    pq_stat = PQStat()
+
+    idx = 0
+    for gt_ann, pred_ann in annotation_set:
+        if print_log and idx % 100 == 0:
+            print('Core: {}, {} from {} images processed'.format(
+                proc_id, idx, len(annotation_set)))
+        idx += 1
+        # The gt images can be on the local disk or `ceph`, so we use
+        # backend here.
+        img_bytes = get(
+            os.path.join(gt_folder, gt_ann['file_name']),
+            backend_args=backend_args)
+        pan_gt = mmcv.imfrombytes(img_bytes, flag='color', channel_order='rgb')
+        pan_gt = rgb2id(pan_gt)
+
+        # The predictions can only be on the local dist now.
+        pan_pred = mmcv.imread(
+            os.path.join(pred_folder, pred_ann['file_name']),
+            flag='color',
+            channel_order='rgb')
+        pan_pred = rgb2id(pan_pred)
+
+        gt_segms = {el['id']: el for el in gt_ann['segments_info']}
+        pred_segms = {el['id']: el for el in pred_ann['segments_info']}
+
+        # predicted segments area calculation + prediction sanity checks
+        pred_labels_set = set(el['id'] for el in pred_ann['segments_info'])
+        labels, labels_cnt = np.unique(pan_pred, return_counts=True)
+        for label, label_cnt in zip(labels, labels_cnt):
+            if label not in pred_segms:
+                if label == VOID:
+                    continue
+                raise KeyError(
+                    'In the image with ID {} segment with ID {} is '
+                    'presented in PNG and not presented in JSON.'.format(
+                        gt_ann['image_id'], label))
+            pred_segms[label]['area'] = label_cnt
+            pred_labels_set.remove(label)
+            if pred_segms[label]['category_id'] not in categories:
+                raise KeyError(
+                    'In the image with ID {} segment with ID {} has '
+                    'unknown category_id {}.'.format(
+                        gt_ann['image_id'], label,
+                        pred_segms[label]['category_id']))
+        if len(pred_labels_set) != 0:
+            raise KeyError(
+                'In the image with ID {} the following segment IDs {} '
+                'are presented in JSON and not presented in PNG.'.format(
+                    gt_ann['image_id'], list(pred_labels_set)))
+
+        # confusion matrix calculation
+        pan_gt_pred = pan_gt.astype(np.uint64) * OFFSET + pan_pred.astype(
+            np.uint64)
+        gt_pred_map = {}
+        labels, labels_cnt = np.unique(pan_gt_pred, return_counts=True)
+        for label, intersection in zip(labels, labels_cnt):
+            gt_id = label // OFFSET
+            pred_id = label % OFFSET
+            gt_pred_map[(gt_id, pred_id)] = intersection
+
+        # count all matched pairs
+        gt_matched = set()
+        pred_matched = set()
+        for label_tuple, intersection in gt_pred_map.items():
+            gt_label, pred_label = label_tuple
+            if gt_label not in gt_segms:
+                continue
+            if pred_label not in pred_segms:
+                continue
+            if gt_segms[gt_label]['iscrowd'] == 1:
+                continue
+            if gt_segms[gt_label]['category_id'] != pred_segms[pred_label][
+                    'category_id']:
+                continue
+
+            union = pred_segms[pred_label]['area'] + gt_segms[gt_label][
+                'area'] - intersection - gt_pred_map.get((VOID, pred_label), 0)
+            iou = intersection / union
+            if iou > 0.5:
+                pq_stat[gt_segms[gt_label]['category_id']].tp += 1
+                pq_stat[gt_segms[gt_label]['category_id']].iou += iou
+                gt_matched.add(gt_label)
+                pred_matched.add(pred_label)
+
+        # count false positives
+        crowd_labels_dict = {}
+        for gt_label, gt_info in gt_segms.items():
+            if gt_label in gt_matched:
+                continue
+            # crowd segments are ignored
+            if gt_info['iscrowd'] == 1:
+                crowd_labels_dict[gt_info['category_id']] = gt_label
+                continue
+            pq_stat[gt_info['category_id']].fn += 1
+
+        # count false positives
+        for pred_label, pred_info in pred_segms.items():
+            if pred_label in pred_matched:
+                continue
+            # intersection of the segment with VOID
+            intersection = gt_pred_map.get((VOID, pred_label), 0)
+            # plus intersection with corresponding CROWD region if it exists
+            if pred_info['category_id'] in crowd_labels_dict:
+                intersection += gt_pred_map.get(
+                    (crowd_labels_dict[pred_info['category_id']], pred_label),
+                    0)
+            # predicted segment is ignored if more than half of
+            # the segment correspond to VOID and CROWD regions
+            if intersection / pred_info['area'] > 0.5:
+                continue
+            pq_stat[pred_info['category_id']].fp += 1
+
+    if print_log:
+        print('Core: {}, all {} images processed'.format(
+            proc_id, len(annotation_set)))
+    return pq_stat
+
+
+def pq_compute_multi_core(matched_annotations_list,
+                          gt_folder,
+                          pred_folder,
+                          categories,
+                          backend_args=None,
+                          nproc=32):
+    """Evaluate the metrics of Panoptic Segmentation with multithreading.
+
+    Same as the function with the same name in `panopticapi`.
+
+    Args:
+        matched_annotations_list (list): The matched annotation list. Each
+            element is a tuple of annotations of the same image with the
+            format (gt_anns, pred_anns).
+        gt_folder (str): The path of the ground truth images.
+        pred_folder (str): The path of the prediction images.
+        categories (str): The categories of the dataset.
+        backend_args (object): The file client of the dataset. If None,
+            the backend will be set to `local`.
+        nproc (int): Number of processes for panoptic quality computing.
+            Defaults to 32. When `nproc` exceeds the number of cpu cores,
+            the number of cpu cores is used.
+    """
+    if PQStat is None:
+        raise RuntimeError(
+            'panopticapi is not installed, please install it by: '
+            'pip install git+https://github.com/cocodataset/'
+            'panopticapi.git.')
+
+    cpu_num = min(nproc, multiprocessing.cpu_count())
+
+    annotations_split = np.array_split(matched_annotations_list, cpu_num)
+    print('Number of cores: {}, images per core: {}'.format(
+        cpu_num, len(annotations_split[0])))
+    workers = multiprocessing.Pool(processes=cpu_num)
+    processes = []
+    for proc_id, annotation_set in enumerate(annotations_split):
+        p = workers.apply_async(pq_compute_single_core,
+                                (proc_id, annotation_set, gt_folder,
+                                 pred_folder, categories, backend_args))
+        processes.append(p)
+
+    # Close the process pool, otherwise it will lead to memory
+    # leaking problems.
+    workers.close()
+    workers.join()
+
+    pq_stat = PQStat()
+    for p in processes:
+        pq_stat += p.get()
+
+    return pq_stat
diff --git a/mmdetection/mmdet/evaluation/functional/recall.py b/mmdetection/mmdet/evaluation/functional/recall.py
new file mode 100644
index 00000000..4bce2bf3
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/functional/recall.py
@@ -0,0 +1,199 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from collections.abc import Sequence
+
+import numpy as np
+from mmengine.logging import print_log
+from terminaltables import AsciiTable
+
+from .bbox_overlaps import bbox_overlaps
+
+
+def _recalls(all_ious, proposal_nums, thrs):
+
+    img_num = all_ious.shape[0]
+    total_gt_num = sum([ious.shape[0] for ious in all_ious])
+
+    _ious = np.zeros((proposal_nums.size, total_gt_num), dtype=np.float32)
+    for k, proposal_num in enumerate(proposal_nums):
+        tmp_ious = np.zeros(0)
+        for i in range(img_num):
+            ious = all_ious[i][:, :proposal_num].copy()
+            gt_ious = np.zeros((ious.shape[0]))
+            if ious.size == 0:
+                tmp_ious = np.hstack((tmp_ious, gt_ious))
+                continue
+            for j in range(ious.shape[0]):
+                gt_max_overlaps = ious.argmax(axis=1)
+                max_ious = ious[np.arange(0, ious.shape[0]), gt_max_overlaps]
+                gt_idx = max_ious.argmax()
+                gt_ious[j] = max_ious[gt_idx]
+                box_idx = gt_max_overlaps[gt_idx]
+                ious[gt_idx, :] = -1
+                ious[:, box_idx] = -1
+            tmp_ious = np.hstack((tmp_ious, gt_ious))
+        _ious[k, :] = tmp_ious
+
+    _ious = np.fliplr(np.sort(_ious, axis=1))
+    recalls = np.zeros((proposal_nums.size, thrs.size))
+    for i, thr in enumerate(thrs):
+        recalls[:, i] = (_ious >= thr).sum(axis=1) / float(total_gt_num)
+
+    return recalls
+
+
+def set_recall_param(proposal_nums, iou_thrs):
+    """Check proposal_nums and iou_thrs and set correct format."""
+    if isinstance(proposal_nums, Sequence):
+        _proposal_nums = np.array(proposal_nums)
+    elif isinstance(proposal_nums, int):
+        _proposal_nums = np.array([proposal_nums])
+    else:
+        _proposal_nums = proposal_nums
+
+    if iou_thrs is None:
+        _iou_thrs = np.array([0.5])
+    elif isinstance(iou_thrs, Sequence):
+        _iou_thrs = np.array(iou_thrs)
+    elif isinstance(iou_thrs, float):
+        _iou_thrs = np.array([iou_thrs])
+    else:
+        _iou_thrs = iou_thrs
+
+    return _proposal_nums, _iou_thrs
+
+
+def eval_recalls(gts,
+                 proposals,
+                 proposal_nums=None,
+                 iou_thrs=0.5,
+                 logger=None,
+                 use_legacy_coordinate=False):
+    """Calculate recalls.
+
+    Args:
+        gts (list[ndarray]): a list of arrays of shape (n, 4)
+        proposals (list[ndarray]): a list of arrays of shape (k, 4) or (k, 5)
+        proposal_nums (int | Sequence[int]): Top N proposals to be evaluated.
+        iou_thrs (float | Sequence[float]): IoU thresholds. Default: 0.5.
+        logger (logging.Logger | str | None): The way to print the recall
+            summary. See `mmengine.logging.print_log()` for details.
+            Default: None.
+        use_legacy_coordinate (bool): Whether use coordinate system
+            in mmdet v1.x. "1" was added to both height and width
+            which means w, h should be
+            computed as 'x2 - x1 + 1` and 'y2 - y1 + 1'. Default: False.
+
+
+    Returns:
+        ndarray: recalls of different ious and proposal nums
+    """
+
+    img_num = len(gts)
+    assert img_num == len(proposals)
+    proposal_nums, iou_thrs = set_recall_param(proposal_nums, iou_thrs)
+    all_ious = []
+    for i in range(img_num):
+        if proposals[i].ndim == 2 and proposals[i].shape[1] == 5:
+            scores = proposals[i][:, 4]
+            sort_idx = np.argsort(scores)[::-1]
+            img_proposal = proposals[i][sort_idx, :]
+        else:
+            img_proposal = proposals[i]
+        prop_num = min(img_proposal.shape[0], proposal_nums[-1])
+        if gts[i] is None or gts[i].shape[0] == 0:
+            ious = np.zeros((0, img_proposal.shape[0]), dtype=np.float32)
+        else:
+            ious = bbox_overlaps(
+                gts[i],
+                img_proposal[:prop_num, :4],
+                use_legacy_coordinate=use_legacy_coordinate)
+        all_ious.append(ious)
+    all_ious = np.array(all_ious)
+    recalls = _recalls(all_ious, proposal_nums, iou_thrs)
+
+    print_recall_summary(recalls, proposal_nums, iou_thrs, logger=logger)
+    return recalls
+
+
+def print_recall_summary(recalls,
+                         proposal_nums,
+                         iou_thrs,
+                         row_idxs=None,
+                         col_idxs=None,
+                         logger=None):
+    """Print recalls in a table.
+
+    Args:
+        recalls (ndarray): calculated from `bbox_recalls`
+        proposal_nums (ndarray or list): top N proposals
+        iou_thrs (ndarray or list): iou thresholds
+        row_idxs (ndarray): which rows(proposal nums) to print
+        col_idxs (ndarray): which cols(iou thresholds) to print
+        logger (logging.Logger | str | None): The way to print the recall
+            summary. See `mmengine.logging.print_log()` for details.
+            Default: None.
+    """
+    proposal_nums = np.array(proposal_nums, dtype=np.int32)
+    iou_thrs = np.array(iou_thrs)
+    if row_idxs is None:
+        row_idxs = np.arange(proposal_nums.size)
+    if col_idxs is None:
+        col_idxs = np.arange(iou_thrs.size)
+    row_header = [''] + iou_thrs[col_idxs].tolist()
+    table_data = [row_header]
+    for i, num in enumerate(proposal_nums[row_idxs]):
+        row = [f'{val:.3f}' for val in recalls[row_idxs[i], col_idxs].tolist()]
+        row.insert(0, num)
+        table_data.append(row)
+    table = AsciiTable(table_data)
+    print_log('\n' + table.table, logger=logger)
+
+
+def plot_num_recall(recalls, proposal_nums):
+    """Plot Proposal_num-Recalls curve.
+
+    Args:
+        recalls(ndarray or list): shape (k,)
+        proposal_nums(ndarray or list): same shape as `recalls`
+    """
+    if isinstance(proposal_nums, np.ndarray):
+        _proposal_nums = proposal_nums.tolist()
+    else:
+        _proposal_nums = proposal_nums
+    if isinstance(recalls, np.ndarray):
+        _recalls = recalls.tolist()
+    else:
+        _recalls = recalls
+
+    import matplotlib.pyplot as plt
+    f = plt.figure()
+    plt.plot([0] + _proposal_nums, [0] + _recalls)
+    plt.xlabel('Proposal num')
+    plt.ylabel('Recall')
+    plt.axis([0, proposal_nums.max(), 0, 1])
+    f.show()
+
+
+def plot_iou_recall(recalls, iou_thrs):
+    """Plot IoU-Recalls curve.
+
+    Args:
+        recalls(ndarray or list): shape (k,)
+        iou_thrs(ndarray or list): same shape as `recalls`
+    """
+    if isinstance(iou_thrs, np.ndarray):
+        _iou_thrs = iou_thrs.tolist()
+    else:
+        _iou_thrs = iou_thrs
+    if isinstance(recalls, np.ndarray):
+        _recalls = recalls.tolist()
+    else:
+        _recalls = recalls
+
+    import matplotlib.pyplot as plt
+    f = plt.figure()
+    plt.plot(_iou_thrs + [1.0], _recalls + [0.])
+    plt.xlabel('IoU')
+    plt.ylabel('Recall')
+    plt.axis([iou_thrs.min(), 1, 0, 1])
+    f.show()
diff --git a/mmdetection/mmdet/evaluation/functional/ytvis.py b/mmdetection/mmdet/evaluation/functional/ytvis.py
new file mode 100644
index 00000000..c65a7e9b
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/functional/ytvis.py
@@ -0,0 +1,305 @@
+# Copyright (c) Github URL
+# Copied from
+# https://github.com/youtubevos/cocoapi/blob/master/PythonAPI/pycocotools/ytvos.py
+__author__ = 'ychfan'
+# Interface for accessing the YouTubeVIS dataset.
+
+# The following API functions are defined:
+#  YTVIS       - YTVIS api class that loads YouTubeVIS annotation file
+#  and prepare data structures.
+#  decodeMask - Decode binary mask M encoded via run-length encoding.
+#  encodeMask - Encode binary mask M using run-length encoding.
+#  getAnnIds  - Get ann ids that satisfy given filter conditions.
+#  getCatIds  - Get cat ids that satisfy given filter conditions.
+#  getImgIds  - Get img ids that satisfy given filter conditions.
+#  loadAnns   - Load anns with the specified ids.
+#  loadCats   - Load cats with the specified ids.
+#  loadImgs   - Load imgs with the specified ids.
+#  annToMask  - Convert segmentation in an annotation to binary mask.
+#  loadRes    - Load algorithm results and create API for accessing them.
+
+# Microsoft COCO Toolbox.      version 2.0
+# Data, paper, and tutorials available at:  http://mscoco.org/
+# Code written by Piotr Dollar and Tsung-Yi Lin, 2014.
+# Licensed under the Simplified BSD License [see bsd.txt]
+
+import copy
+import itertools
+import json
+import sys
+import time
+from collections import defaultdict
+
+import numpy as np
+from pycocotools import mask as maskUtils
+
+PYTHON_VERSION = sys.version_info[0]
+
+
+def _isArrayLike(obj):
+    return hasattr(obj, '__iter__') and hasattr(obj, '__len__')
+
+
+class YTVIS:
+
+    def __init__(self, annotation_file=None):
+        """Constructor of Microsoft COCO helper class for reading and
+        visualizing annotations.
+
+        :param annotation_file (str | dict): location of annotation file or
+            dict results.
+        :param image_folder (str): location to the folder that hosts images.
+        :return:
+        """
+        # load dataset
+        self.dataset, self.anns, self.cats, self.vids = dict(), dict(), dict(
+        ), dict()
+        self.vidToAnns, self.catToVids = defaultdict(list), defaultdict(list)
+        if annotation_file is not None:
+            print('loading annotations into memory...')
+            tic = time.time()
+            if type(annotation_file) == str:
+                dataset = json.load(open(annotation_file, 'r'))
+            else:
+                dataset = annotation_file
+            assert type(
+                dataset
+            ) == dict, 'annotation file format {} not supported'.format(
+                type(dataset))
+            print('Done (t={:0.2f}s)'.format(time.time() - tic))
+            self.dataset = dataset
+            self.createIndex()
+
+    def createIndex(self):
+        # create index
+        print('creating index...')
+        anns, cats, vids = {}, {}, {}
+        vidToAnns, catToVids = defaultdict(list), defaultdict(list)
+        if 'annotations' in self.dataset:
+            for ann in self.dataset['annotations']:
+                vidToAnns[ann['video_id']].append(ann)
+                anns[ann['id']] = ann
+
+        if 'videos' in self.dataset:
+            for vid in self.dataset['videos']:
+                vids[vid['id']] = vid
+
+        if 'categories' in self.dataset:
+            for cat in self.dataset['categories']:
+                cats[cat['id']] = cat
+
+        if 'annotations' in self.dataset and 'categories' in self.dataset:
+            for ann in self.dataset['annotations']:
+                catToVids[ann['category_id']].append(ann['video_id'])
+
+        print('index created!')
+
+        # create class members
+        self.anns = anns
+        self.vidToAnns = vidToAnns
+        self.catToVids = catToVids
+        self.vids = vids
+        self.cats = cats
+
+    def getAnnIds(self, vidIds=[], catIds=[], areaRng=[], iscrowd=None):
+        """Get ann ids that satisfy given filter conditions. default skips that
+        filter.
+
+        :param vidIds  (int array)     : get anns for given vids
+               catIds  (int array)     : get anns for given cats
+               areaRng (float array)   : get anns for given area range
+               iscrowd (boolean)       : get anns for given crowd label
+        :return: ids (int array)       : integer array of ann ids
+        """
+        vidIds = vidIds if _isArrayLike(vidIds) else [vidIds]
+        catIds = catIds if _isArrayLike(catIds) else [catIds]
+
+        if len(vidIds) == len(catIds) == len(areaRng) == 0:
+            anns = self.dataset['annotations']
+        else:
+            if not len(vidIds) == 0:
+                lists = [
+                    self.vidToAnns[vidId] for vidId in vidIds
+                    if vidId in self.vidToAnns
+                ]
+                anns = list(itertools.chain.from_iterable(lists))
+            else:
+                anns = self.dataset['annotations']
+            anns = anns if len(catIds) == 0 else [
+                ann for ann in anns if ann['category_id'] in catIds
+            ]
+            anns = anns if len(areaRng) == 0 else [
+                ann for ann in anns if ann['avg_area'] > areaRng[0]
+                and ann['avg_area'] < areaRng[1]
+            ]
+        if iscrowd is not None:
+            ids = [ann['id'] for ann in anns if ann['iscrowd'] == iscrowd]
+        else:
+            ids = [ann['id'] for ann in anns]
+        return ids
+
+    def getCatIds(self, catNms=[], supNms=[], catIds=[]):
+        """filtering parameters. default skips that filter.
+
+        :param catNms (str array)  : get cats for given cat names
+        :param supNms (str array)  : get cats for given supercategory names
+        :param catIds (int array)  : get cats for given cat ids
+        :return: ids (int array)   : integer array of cat ids
+        """
+        catNms = catNms if _isArrayLike(catNms) else [catNms]
+        supNms = supNms if _isArrayLike(supNms) else [supNms]
+        catIds = catIds if _isArrayLike(catIds) else [catIds]
+
+        if len(catNms) == len(supNms) == len(catIds) == 0:
+            cats = self.dataset['categories']
+        else:
+            cats = self.dataset['categories']
+            cats = cats if len(catNms) == 0 else [
+                cat for cat in cats if cat['name'] in catNms
+            ]
+            cats = cats if len(supNms) == 0 else [
+                cat for cat in cats if cat['supercategory'] in supNms
+            ]
+            cats = cats if len(catIds) == 0 else [
+                cat for cat in cats if cat['id'] in catIds
+            ]
+        ids = [cat['id'] for cat in cats]
+        return ids
+
+    def getVidIds(self, vidIds=[], catIds=[]):
+        """Get vid ids that satisfy given filter conditions.
+
+        :param vidIds (int array) : get vids for given ids
+        :param catIds (int array) : get vids with all given cats
+        :return: ids (int array)  : integer array of vid ids
+        """
+        vidIds = vidIds if _isArrayLike(vidIds) else [vidIds]
+        catIds = catIds if _isArrayLike(catIds) else [catIds]
+
+        if len(vidIds) == len(catIds) == 0:
+            ids = self.vids.keys()
+        else:
+            ids = set(vidIds)
+            for i, catId in enumerate(catIds):
+                if i == 0 and len(ids) == 0:
+                    ids = set(self.catToVids[catId])
+                else:
+                    ids &= set(self.catToVids[catId])
+        return list(ids)
+
+    def loadAnns(self, ids=[]):
+        """Load anns with the specified ids.
+
+        :param ids (int array)       : integer ids specifying anns
+        :return: anns (object array) : loaded ann objects
+        """
+        if _isArrayLike(ids):
+            return [self.anns[id] for id in ids]
+        elif type(ids) == int:
+            return [self.anns[ids]]
+
+    def loadCats(self, ids=[]):
+        """Load cats with the specified ids.
+
+        :param ids (int array)       : integer ids specifying cats
+        :return: cats (object array) : loaded cat objects
+        """
+        if _isArrayLike(ids):
+            return [self.cats[id] for id in ids]
+        elif type(ids) == int:
+            return [self.cats[ids]]
+
+    def loadVids(self, ids=[]):
+        """Load anns with the specified ids.
+
+        :param ids (int array)       : integer ids specifying vid
+        :return: vids (object array) : loaded vid objects
+        """
+        if _isArrayLike(ids):
+            return [self.vids[id] for id in ids]
+        elif type(ids) == int:
+            return [self.vids[ids]]
+
+    def loadRes(self, resFile):
+        """Load result file and return a result api object.
+
+        :param   resFile (str)     : file name of result file
+        :return: res (obj)         : result api object
+        """
+        res = YTVIS()
+        res.dataset['videos'] = [img for img in self.dataset['videos']]
+
+        print('Loading and preparing results...')
+        tic = time.time()
+        if type(resFile) == str or (PYTHON_VERSION == 2
+                                    and type(resFile) == str):
+            anns = json.load(open(resFile))
+        elif type(resFile) == np.ndarray:
+            anns = self.loadNumpyAnnotations(resFile)
+        else:
+            anns = resFile
+        assert type(anns) == list, 'results in not an array of objects'
+        annsVidIds = [ann['video_id'] for ann in anns]
+        assert set(annsVidIds) == (set(annsVidIds) & set(self.getVidIds())), \
+               'Results do not correspond to current coco set'
+        if 'segmentations' in anns[0]:
+            res.dataset['categories'] = copy.deepcopy(
+                self.dataset['categories'])
+            for id, ann in enumerate(anns):
+                ann['areas'] = []
+                if 'bboxes' not in ann:
+                    ann['bboxes'] = []
+                for seg in ann['segmentations']:
+                    # now only support compressed RLE format
+                    # as segmentation results
+                    if seg:
+                        ann['areas'].append(maskUtils.area(seg))
+                        if len(ann['bboxes']) < len(ann['areas']):
+                            ann['bboxes'].append(maskUtils.toBbox(seg))
+                    else:
+                        ann['areas'].append(None)
+                        if len(ann['bboxes']) < len(ann['areas']):
+                            ann['bboxes'].append(None)
+                ann['id'] = id + 1
+                l_ori = [a for a in ann['areas'] if a]
+                if len(l_ori) == 0:
+                    ann['avg_area'] = 0
+                else:
+                    ann['avg_area'] = np.array(l_ori).mean()
+                ann['iscrowd'] = 0
+        print('DONE (t={:0.2f}s)'.format(time.time() - tic))
+
+        res.dataset['annotations'] = anns
+        res.createIndex()
+        return res
+
+    def annToRLE(self, ann, frameId):
+        """Convert annotation which can be polygons, uncompressed RLE to RLE.
+
+        :return: binary mask (numpy 2D array)
+        """
+        t = self.vids[ann['video_id']]
+        h, w = t['height'], t['width']
+        segm = ann['segmentations'][frameId]
+        if type(segm) == list:
+            # polygon -- a single object might consist of multiple parts
+            # we merge all parts into one mask rle code
+            rles = maskUtils.frPyObjects(segm, h, w)
+            rle = maskUtils.merge(rles)
+        elif type(segm['counts']) == list:
+            # uncompressed RLE
+            rle = maskUtils.frPyObjects(segm, h, w)
+        else:
+            # rle
+            rle = segm
+        return rle
+
+    def annToMask(self, ann, frameId):
+        """Convert annotation which can be polygons, uncompressed RLE, or RLE
+        to binary mask.
+
+        :return: binary mask (numpy 2D array)
+        """
+        rle = self.annToRLE(ann, frameId)
+        m = maskUtils.decode(rle)
+        return m
diff --git a/mmdetection/mmdet/evaluation/functional/ytviseval.py b/mmdetection/mmdet/evaluation/functional/ytviseval.py
new file mode 100644
index 00000000..fdaf110d
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/functional/ytviseval.py
@@ -0,0 +1,623 @@
+# Copyright (c) Github URL
+# Copied from
+# https://github.com/youtubevos/cocoapi/blob/master/PythonAPI/pycocotools/ytvoseval.py
+__author__ = 'ychfan'
+
+import copy
+import datetime
+import time
+from collections import defaultdict
+
+import numpy as np
+from pycocotools import mask as maskUtils
+
+
+class YTVISeval:
+    # Interface for evaluating video instance segmentation on
+    # the YouTubeVIS dataset.
+    #
+    # The usage for YTVISeval is as follows:
+    #  cocoGt=..., cocoDt=...       # load dataset and results
+    #  E = YTVISeval(cocoGt,cocoDt); # initialize YTVISeval object
+    #  E.params.recThrs = ...;      # set parameters as desired
+    #  E.evaluate();                # run per image evaluation
+    #  E.accumulate();              # accumulate per image results
+    #  E.summarize();               # display summary metrics of results
+    # For example usage see evalDemo.m and http://mscoco.org/.
+    #
+    # The evaluation parameters are as follows (defaults in brackets):
+    #  imgIds     - [all] N img ids to use for evaluation
+    #  catIds     - [all] K cat ids to use for evaluation
+    #  iouThrs    - [.5:.05:.95] T=10 IoU thresholds for evaluation
+    #  recThrs    - [0:.01:1] R=101 recall thresholds for evaluation
+    #  areaRng    - [...] A=4 object area ranges for evaluation
+    #  maxDets    - [1 10 100] M=3 thresholds on max detections per image
+    #  iouType    - ['segm'] set iouType to 'segm', 'bbox' or 'keypoints'
+    #  iouType replaced the now DEPRECATED useSegm parameter.
+    #  useCats    - [1] if true use category labels for evaluation
+    # Note: if useCats=0 category labels are ignored as in proposal scoring.
+    # Note: multiple areaRngs [Ax2] and maxDets [Mx1] can be specified.
+    #
+    # evaluate(): evaluates detections on every image and every category and
+    # concats the results into the "evalImgs" with fields:
+    #  dtIds      - [1xD] id for each of the D detections (dt)
+    #  gtIds      - [1xG] id for each of the G ground truths (gt)
+    #  dtMatches  - [TxD] matching gt id at each IoU or 0
+    #  gtMatches  - [TxG] matching dt id at each IoU or 0
+    #  dtScores   - [1xD] confidence of each dt
+    #  gtIgnore   - [1xG] ignore flag for each gt
+    #  dtIgnore   - [TxD] ignore flag for each dt at each IoU
+    #
+    # accumulate(): accumulates the per-image, per-category evaluation
+    # results in "evalImgs" into the dictionary "eval" with fields:
+    #  params     - parameters used for evaluation
+    #  date       - date evaluation was performed
+    #  counts     - [T,R,K,A,M] parameter dimensions (see above)
+    #  precision  - [TxRxKxAxM] precision for every evaluation setting
+    #  recall     - [TxKxAxM] max recall for every evaluation setting
+    # Note: precision and recall==-1 for settings with no gt objects.
+    #
+    # See also coco, mask, pycocoDemo, pycocoEvalDemo
+    #
+    # Microsoft COCO Toolbox.      version 2.0
+    # Data, paper, and tutorials available at:  http://mscoco.org/
+    # Code written by Piotr Dollar and Tsung-Yi Lin, 2015.
+    # Licensed under the Simplified BSD License [see coco/license.txt]
+    def __init__(self, cocoGt=None, cocoDt=None, iouType='segm'):
+        """Initialize CocoEval using coco APIs for gt and dt.
+
+        :param cocoGt: coco object with ground truth annotations
+        :param cocoDt: coco object with detection results
+        :return: None
+        """
+        if not iouType:
+            print('iouType not specified. use default iouType segm')
+        self.cocoGt = cocoGt  # ground truth COCO API
+        self.cocoDt = cocoDt  # detections COCO API
+        self.params = {}  # evaluation parameters
+        self.evalVids = defaultdict(
+            list)  # per-image per-category evaluation results [KxAxI] elements
+        self.eval = {}  # accumulated evaluation results
+        self._gts = defaultdict(list)  # gt for evaluation
+        self._dts = defaultdict(list)  # dt for evaluation
+        self.params = Params(iouType=iouType)  # parameters
+        self._paramsEval = {}  # parameters for evaluation
+        self.stats = []  # result summarization
+        self.ious = {}  # ious between all gts and dts
+        if cocoGt is not None:
+            self.params.vidIds = sorted(cocoGt.getVidIds())
+            self.params.catIds = sorted(cocoGt.getCatIds())
+
+    def _prepare(self):
+        '''
+        Prepare ._gts and ._dts for evaluation based on params
+        :return: None
+        '''
+
+        def _toMask(anns, coco):
+            # modify ann['segmentation'] by reference
+            for ann in anns:
+                for i, a in enumerate(ann['segmentations']):
+                    if a:
+                        rle = coco.annToRLE(ann, i)
+                        ann['segmentations'][i] = rle
+                l_ori = [a for a in ann['areas'] if a]
+                if len(l_ori) == 0:
+                    ann['avg_area'] = 0
+                else:
+                    ann['avg_area'] = np.array(l_ori).mean()
+
+        p = self.params
+        if p.useCats:
+            gts = self.cocoGt.loadAnns(
+                self.cocoGt.getAnnIds(vidIds=p.vidIds, catIds=p.catIds))
+            dts = self.cocoDt.loadAnns(
+                self.cocoDt.getAnnIds(vidIds=p.vidIds, catIds=p.catIds))
+        else:
+            gts = self.cocoGt.loadAnns(self.cocoGt.getAnnIds(vidIds=p.vidIds))
+            dts = self.cocoDt.loadAnns(self.cocoDt.getAnnIds(vidIds=p.vidIds))
+
+        # convert ground truth to mask if iouType == 'segm'
+        if p.iouType == 'segm':
+            _toMask(gts, self.cocoGt)
+            _toMask(dts, self.cocoDt)
+        # set ignore flag
+        for gt in gts:
+            gt['ignore'] = gt['ignore'] if 'ignore' in gt else 0
+            gt['ignore'] = 'iscrowd' in gt and gt['iscrowd']
+            if p.iouType == 'keypoints':
+                gt['ignore'] = (gt['num_keypoints'] == 0) or gt['ignore']
+        self._gts = defaultdict(list)  # gt for evaluation
+        self._dts = defaultdict(list)  # dt for evaluation
+        for gt in gts:
+            self._gts[gt['video_id'], gt['category_id']].append(gt)
+        for dt in dts:
+            self._dts[dt['video_id'], dt['category_id']].append(dt)
+        self.evalVids = defaultdict(
+            list)  # per-image per-category evaluation results
+        self.eval = {}  # accumulated evaluation results
+
+    def evaluate(self):
+        '''
+        Run per image evaluation on given images and store
+        results (a list of dict) in self.evalVids
+        :return: None
+        '''
+        tic = time.time()
+        print('Running per image evaluation...')
+        p = self.params
+        # add backward compatibility if useSegm is specified in params
+        if p.useSegm is not None:
+            p.iouType = 'segm' if p.useSegm == 1 else 'bbox'
+            print('useSegm (deprecated) is not None. Running {} evaluation'.
+                  format(p.iouType))
+        print('Evaluate annotation type *{}*'.format(p.iouType))
+        p.vidIds = list(np.unique(p.vidIds))
+        if p.useCats:
+            p.catIds = list(np.unique(p.catIds))
+        p.maxDets = sorted(p.maxDets)
+        self.params = p
+
+        self._prepare()
+        # loop through images, area range, max detection number
+        catIds = p.catIds if p.useCats else [-1]
+
+        if p.iouType == 'segm' or p.iouType == 'bbox':
+            computeIoU = self.computeIoU
+        elif p.iouType == 'keypoints':
+            computeIoU = self.computeOks
+        self.ious = {(vidId, catId): computeIoU(vidId, catId)
+                     for vidId in p.vidIds for catId in catIds}
+
+        evaluateVid = self.evaluateVid
+        maxDet = p.maxDets[-1]
+
+        self.evalImgs = [
+            evaluateVid(vidId, catId, areaRng, maxDet) for catId in catIds
+            for areaRng in p.areaRng for vidId in p.vidIds
+        ]
+        self._paramsEval = copy.deepcopy(self.params)
+        toc = time.time()
+        print('DONE (t={:0.2f}s).'.format(toc - tic))
+
+    def computeIoU(self, vidId, catId):
+        p = self.params
+        if p.useCats:
+            gt = self._gts[vidId, catId]
+            dt = self._dts[vidId, catId]
+        else:
+            gt = [_ for cId in p.catIds for _ in self._gts[vidId, cId]]
+            dt = [_ for cId in p.catIds for _ in self._dts[vidId, cId]]
+        if len(gt) == 0 and len(dt) == 0:
+            return []
+        inds = np.argsort([-d['score'] for d in dt], kind='mergesort')
+        dt = [dt[i] for i in inds]
+        if len(dt) > p.maxDets[-1]:
+            dt = dt[0:p.maxDets[-1]]
+
+        if p.iouType == 'segm':
+            g = [g['segmentations'] for g in gt]
+            d = [d['segmentations'] for d in dt]
+        elif p.iouType == 'bbox':
+            g = [g['bboxes'] for g in gt]
+            d = [d['bboxes'] for d in dt]
+        else:
+            raise Exception('unknown iouType for iou computation')
+
+        # compute iou between each dt and gt region
+
+        def iou_seq(d_seq, g_seq):
+            i = .0
+            u = .0
+            for d, g in zip(d_seq, g_seq):
+                if d and g:
+                    i += maskUtils.area(maskUtils.merge([d, g], True))
+                    u += maskUtils.area(maskUtils.merge([d, g], False))
+                elif not d and g:
+                    u += maskUtils.area(g)
+                elif d and not g:
+                    u += maskUtils.area(d)
+            if not u > .0:
+                print('Mask sizes in video {} and category {} may not match!'.
+                      format(vidId, catId))
+            iou = i / u if u > .0 else .0
+            return iou
+
+        ious = np.zeros([len(d), len(g)])
+        for i, j in np.ndindex(ious.shape):
+            ious[i, j] = iou_seq(d[i], g[j])
+
+        return ious
+
+    def computeOks(self, imgId, catId):
+        p = self.params
+
+        gts = self._gts[imgId, catId]
+        dts = self._dts[imgId, catId]
+        inds = np.argsort([-d['score'] for d in dts], kind='mergesort')
+        dts = [dts[i] for i in inds]
+        if len(dts) > p.maxDets[-1]:
+            dts = dts[0:p.maxDets[-1]]
+        # if len(gts) == 0 and len(dts) == 0:
+        if len(gts) == 0 or len(dts) == 0:
+            return []
+        ious = np.zeros((len(dts), len(gts)))
+        sigmas = np.array([
+            .26, .25, .25, .35, .35, .79, .79, .72, .72, .62, .62, 1.07, 1.07,
+            .87, .87, .89, .89
+        ]) / 10.0
+        vars = (sigmas * 2)**2
+        k = len(sigmas)
+        # compute oks between each detection and ground truth object
+        for j, gt in enumerate(gts):
+            # create bounds for ignore regions(double the gt bbox)
+            g = np.array(gt['keypoints'])
+            xg = g[0::3]
+            yg = g[1::3]
+            vg = g[2::3]
+            k1 = np.count_nonzero(vg > 0)
+            bb = gt['bbox']
+            x0 = bb[0] - bb[2]
+            x1 = bb[0] + bb[2] * 2
+            y0 = bb[1] - bb[3]
+            y1 = bb[1] + bb[3] * 2
+            for i, dt in enumerate(dts):
+                d = np.array(dt['keypoints'])
+                xd = d[0::3]
+                yd = d[1::3]
+                if k1 > 0:
+                    # measure the per-keypoint distance if keypoints visible
+                    dx = xd - xg
+                    dy = yd - yg
+                else:
+                    # measure minimum distance to keypoints
+                    z = np.zeros((k))
+                    dx = np.max((z, x0 - xd), axis=0) + np.max(
+                        (z, xd - x1), axis=0)
+                    dy = np.max((z, y0 - yd), axis=0) + np.max(
+                        (z, yd - y1), axis=0)
+                e = (dx**2 + dy**2) / vars / (gt['avg_area'] +
+                                              np.spacing(1)) / 2
+                if k1 > 0:
+                    e = e[vg > 0]
+                ious[i, j] = np.sum(np.exp(-e)) / e.shape[0]
+        return ious
+
+    def evaluateVid(self, vidId, catId, aRng, maxDet):
+        '''
+        perform evaluation for single category and image
+        :return: dict (single image results)
+        '''
+        p = self.params
+        if p.useCats:
+            gt = self._gts[vidId, catId]
+            dt = self._dts[vidId, catId]
+        else:
+            gt = [_ for cId in p.catIds for _ in self._gts[vidId, cId]]
+            dt = [_ for cId in p.catIds for _ in self._dts[vidId, cId]]
+        if len(gt) == 0 and len(dt) == 0:
+            return None
+
+        for g in gt:
+            if g['ignore'] or (g['avg_area'] < aRng[0]
+                               or g['avg_area'] > aRng[1]):
+                g['_ignore'] = 1
+            else:
+                g['_ignore'] = 0
+
+        # sort dt highest score first, sort gt ignore last
+        gtind = np.argsort([g['_ignore'] for g in gt], kind='mergesort')
+        gt = [gt[i] for i in gtind]
+        dtind = np.argsort([-d['score'] for d in dt], kind='mergesort')
+        dt = [dt[i] for i in dtind[0:maxDet]]
+        iscrowd = [int(o['iscrowd']) for o in gt]
+        # load computed ious
+        ious = self.ious[vidId, catId][:, gtind] if len(
+            self.ious[vidId, catId]) > 0 else self.ious[vidId, catId]
+
+        T = len(p.iouThrs)
+        G = len(gt)
+        D = len(dt)
+        gtm = np.zeros((T, G))
+        dtm = np.zeros((T, D))
+        gtIg = np.array([g['_ignore'] for g in gt])
+        dtIg = np.zeros((T, D))
+        if not len(ious) == 0:
+            for tind, t in enumerate(p.iouThrs):
+                for dind, d in enumerate(dt):
+                    # information about best match so far (m=-1 -> unmatched)
+                    iou = min([t, 1 - 1e-10])
+                    m = -1
+                    for gind, g in enumerate(gt):
+                        # if this gt already matched, and not a crowd, continue
+                        if gtm[tind, gind] > 0 and not iscrowd[gind]:
+                            continue
+                        # if dt matched to reg gt, and on ignore gt, stop
+                        if m > -1 and gtIg[m] == 0 and gtIg[gind] == 1:
+                            break
+                        # continue to next gt unless better match made
+                        if ious[dind, gind] < iou:
+                            continue
+                        # if match successful and best so far,
+                        # store appropriately
+                        iou = ious[dind, gind]
+                        m = gind
+                    # if match made store id of match for both dt and gt
+                    if m == -1:
+                        continue
+                    dtIg[tind, dind] = gtIg[m]
+                    dtm[tind, dind] = gt[m]['id']
+                    gtm[tind, m] = d['id']
+        # set unmatched detections outside of area range to ignore
+        a = np.array([
+            d['avg_area'] < aRng[0] or d['avg_area'] > aRng[1] for d in dt
+        ]).reshape((1, len(dt)))
+        dtIg = np.logical_or(dtIg, np.logical_and(dtm == 0, np.repeat(a, T,
+                                                                      0)))
+        # store results for given image and category
+        return {
+            'video_id': vidId,
+            'category_id': catId,
+            'aRng': aRng,
+            'maxDet': maxDet,
+            'dtIds': [d['id'] for d in dt],
+            'gtIds': [g['id'] for g in gt],
+            'dtMatches': dtm,
+            'gtMatches': gtm,
+            'dtScores': [d['score'] for d in dt],
+            'gtIgnore': gtIg,
+            'dtIgnore': dtIg,
+        }
+
+    def accumulate(self, p=None):
+        """Accumulate per image evaluation results and store the result in
+        self.eval.
+
+        :param p: input params for evaluation
+        :return: None
+        """
+        print('Accumulating evaluation results...')
+        tic = time.time()
+        if not self.evalImgs:
+            print('Please run evaluate() first')
+        # allows input customized parameters
+        if p is None:
+            p = self.params
+        p.catIds = p.catIds if p.useCats == 1 else [-1]
+        T = len(p.iouThrs)
+        R = len(p.recThrs)
+        K = len(p.catIds) if p.useCats else 1
+        A = len(p.areaRng)
+        M = len(p.maxDets)
+        precision = -np.ones(
+            (T, R, K, A, M))  # -1 for the precision of absent categories
+        recall = -np.ones((T, K, A, M))
+        scores = -np.ones((T, R, K, A, M))
+
+        # create dictionary for future indexing
+        _pe = self._paramsEval
+        catIds = _pe.catIds if _pe.useCats else [-1]
+        setK = set(catIds)
+        setA = set(map(tuple, _pe.areaRng))
+        setM = set(_pe.maxDets)
+        setI = set(_pe.vidIds)
+        # get inds to evaluate
+        k_list = [n for n, k in enumerate(p.catIds) if k in setK]
+        m_list = [m for n, m in enumerate(p.maxDets) if m in setM]
+        a_list = [
+            n for n, a in enumerate(map(lambda x: tuple(x), p.areaRng))
+            if a in setA
+        ]
+        i_list = [n for n, i in enumerate(p.vidIds) if i in setI]
+        I0 = len(_pe.vidIds)
+        A0 = len(_pe.areaRng)
+        # retrieve E at each category, area range, and max number of detections
+        for k, k0 in enumerate(k_list):
+            Nk = k0 * A0 * I0
+            for a, a0 in enumerate(a_list):
+                Na = a0 * I0
+                for m, maxDet in enumerate(m_list):
+                    E = [self.evalImgs[Nk + Na + i] for i in i_list]
+                    E = [e for e in E if e is not None]
+                    if len(E) == 0:
+                        continue
+                    dtScores = np.concatenate(
+                        [e['dtScores'][0:maxDet] for e in E])
+
+                    inds = np.argsort(-dtScores, kind='mergesort')
+                    dtScoresSorted = dtScores[inds]
+
+                    dtm = np.concatenate(
+                        [e['dtMatches'][:, 0:maxDet] for e in E], axis=1)[:,
+                                                                          inds]
+                    dtIg = np.concatenate(
+                        [e['dtIgnore'][:, 0:maxDet] for e in E], axis=1)[:,
+                                                                         inds]
+                    gtIg = np.concatenate([e['gtIgnore'] for e in E])
+                    npig = np.count_nonzero(gtIg == 0)
+                    if npig == 0:
+                        continue
+                    tps = np.logical_and(dtm, np.logical_not(dtIg))
+                    fps = np.logical_and(
+                        np.logical_not(dtm), np.logical_not(dtIg))
+
+                    tp_sum = np.cumsum(tps, axis=1).astype(dtype=np.float)
+                    fp_sum = np.cumsum(fps, axis=1).astype(dtype=np.float)
+                    for t, (tp, fp) in enumerate(zip(tp_sum, fp_sum)):
+                        tp = np.array(tp)
+                        fp = np.array(fp)
+                        nd_ori = len(tp)
+                        rc = tp / npig
+                        pr = tp / (fp + tp + np.spacing(1))
+                        q = np.zeros((R, ))
+                        ss = np.zeros((R, ))
+
+                        if nd_ori:
+                            recall[t, k, a, m] = rc[-1]
+                        else:
+                            recall[t, k, a, m] = 0
+
+                        # use python array gets significant speed improvement
+                        pr = pr.tolist()
+                        q = q.tolist()
+
+                        for i in range(nd_ori - 1, 0, -1):
+                            if pr[i] > pr[i - 1]:
+                                pr[i - 1] = pr[i]
+
+                        inds = np.searchsorted(rc, p.recThrs, side='left')
+                        try:
+                            for ri, pi in enumerate(inds):
+                                q[ri] = pr[pi]
+                                ss[ri] = dtScoresSorted[pi]
+                        except Exception:
+                            pass
+                        precision[t, :, k, a, m] = np.array(q)
+                        scores[t, :, k, a, m] = np.array(ss)
+        self.eval = {
+            'params': p,
+            'counts': [T, R, K, A, M],
+            'date': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+            'precision': precision,
+            'recall': recall,
+            'scores': scores,
+        }
+        toc = time.time()
+        print('DONE (t={:0.2f}s).'.format(toc - tic))
+
+    def summarize(self):
+        """Compute and display summary metrics for evaluation results.
+
+        Note this function can *only* be applied on the default parameter
+        setting
+        """
+
+        def _summarize(ap=1, iouThr=None, areaRng='all', maxDets=100):
+            p = self.params
+            iStr = ' {:<18} {} @[ IoU={:<9} | area={:>6s} | ' \
+                   'maxDets={:>3d} ] = {:0.3f}'
+            titleStr = 'Average Precision' if ap == 1 else 'Average Recall'
+            typeStr = '(AP)' if ap == 1 else '(AR)'
+            iouStr = '{:0.2f}:{:0.2f}'.format(p.iouThrs[0], p.iouThrs[-1]) \
+                if iouThr is None else '{:0.2f}'.format(iouThr)
+
+            aind = [
+                i for i, aRng in enumerate(p.areaRngLbl) if aRng == areaRng
+            ]
+            mind = [i for i, mDet in enumerate(p.maxDets) if mDet == maxDets]
+            if ap == 1:
+                # dimension of precision: [TxRxKxAxM]
+                s = self.eval['precision']
+                # IoU
+                if iouThr is not None:
+                    t = np.where(iouThr == p.iouThrs)[0]
+                    s = s[t]
+                s = s[:, :, :, aind, mind]
+            else:
+                # dimension of recall: [TxKxAxM]
+                s = self.eval['recall']
+                if iouThr is not None:
+                    t = np.where(iouThr == p.iouThrs)[0]
+                    s = s[t]
+                s = s[:, :, aind, mind]
+            if len(s[s > -1]) == 0:
+                mean_s = -1
+            else:
+                mean_s = np.mean(s[s > -1])
+            print(
+                iStr.format(titleStr, typeStr, iouStr, areaRng, maxDets,
+                            mean_s))
+            return mean_s
+
+        def _summarizeDets():
+            stats = np.zeros((12, ))
+            stats[0] = _summarize(1)
+            stats[1] = _summarize(1, iouThr=.5, maxDets=self.params.maxDets[2])
+            stats[2] = _summarize(
+                1, iouThr=.75, maxDets=self.params.maxDets[2])
+            stats[3] = _summarize(
+                1, areaRng='small', maxDets=self.params.maxDets[2])
+            stats[4] = _summarize(
+                1, areaRng='medium', maxDets=self.params.maxDets[2])
+            stats[5] = _summarize(
+                1, areaRng='large', maxDets=self.params.maxDets[2])
+            stats[6] = _summarize(0, maxDets=self.params.maxDets[0])
+            stats[7] = _summarize(0, maxDets=self.params.maxDets[1])
+            stats[8] = _summarize(0, maxDets=self.params.maxDets[2])
+            stats[9] = _summarize(
+                0, areaRng='small', maxDets=self.params.maxDets[2])
+            stats[10] = _summarize(
+                0, areaRng='medium', maxDets=self.params.maxDets[2])
+            stats[11] = _summarize(
+                0, areaRng='large', maxDets=self.params.maxDets[2])
+            return stats
+
+        def _summarizeKps():
+            stats = np.zeros((10, ))
+            stats[0] = _summarize(1, maxDets=20)
+            stats[1] = _summarize(1, maxDets=20, iouThr=.5)
+            stats[2] = _summarize(1, maxDets=20, iouThr=.75)
+            stats[3] = _summarize(1, maxDets=20, areaRng='medium')
+            stats[4] = _summarize(1, maxDets=20, areaRng='large')
+            stats[5] = _summarize(0, maxDets=20)
+            stats[6] = _summarize(0, maxDets=20, iouThr=.5)
+            stats[7] = _summarize(0, maxDets=20, iouThr=.75)
+            stats[8] = _summarize(0, maxDets=20, areaRng='medium')
+            stats[9] = _summarize(0, maxDets=20, areaRng='large')
+            return stats
+
+        if not self.eval:
+            raise Exception('Please run accumulate() first')
+        iouType = self.params.iouType
+        if iouType == 'segm' or iouType == 'bbox':
+            summarize = _summarizeDets
+        elif iouType == 'keypoints':
+            summarize = _summarizeKps
+        self.stats = summarize()
+
+    def __str__(self):
+        self.summarize()
+
+
+class Params:
+    """Params for coco evaluation api."""
+
+    def setDetParams(self):
+        self.vidIds = []
+        self.catIds = []
+        # np.arange causes trouble.  the data point on arange
+        # is slightly larger than the true value
+        self.iouThrs = np.linspace(
+            .5, 0.95, int(np.round((0.95 - .5) / .05)) + 1, endpoint=True)
+        self.recThrs = np.linspace(
+            .0, 1.00, int(np.round((1.00 - .0) / .01)) + 1, endpoint=True)
+        self.maxDets = [1, 10, 100]
+        self.areaRng = [[0**2, 1e5**2], [0**2, 128**2], [128**2, 256**2],
+                        [256**2, 1e5**2]]
+        self.areaRngLbl = ['all', 'small', 'medium', 'large']
+        self.useCats = 1
+
+    def setKpParams(self):
+        self.vidIds = []
+        self.catIds = []
+        # np.arange causes trouble.  the data point on arange
+        # is slightly larger than the true value
+        self.iouThrs = np.linspace(
+            .5, 0.95, int(np.round((0.95 - .5) / .05)) + 1, endpoint=True)
+        self.recThrs = np.linspace(
+            .0, 1.00, int(np.round((1.00 - .0) / .01)) + 1, endpoint=True)
+        self.maxDets = [20]
+        self.areaRng = [[0**2, 1e5**2], [32**2, 96**2], [96**2, 1e5**2]]
+        self.areaRngLbl = ['all', 'medium', 'large']
+        self.useCats = 1
+
+    def __init__(self, iouType='segm'):
+        if iouType == 'segm' or iouType == 'bbox':
+            self.setDetParams()
+        elif iouType == 'keypoints':
+            self.setKpParams()
+        else:
+            raise Exception('iouType not supported')
+        self.iouType = iouType
+        # useSegm is deprecated
+        self.useSegm = None
diff --git a/mmdetection/mmdet/evaluation/metrics/__init__.py b/mmdetection/mmdet/evaluation/metrics/__init__.py
new file mode 100644
index 00000000..f91f1c06
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/__init__.py
@@ -0,0 +1,36 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .base_video_metric import BaseVideoMetric
+from .cityscapes_metric import CityScapesMetric
+from .coco_caption_metric import COCOCaptionMetric
+from .coco_metric import CocoMetric
+from .coco_occluded_metric import CocoOccludedSeparatedMetric
+from .coco_panoptic_metric import CocoPanopticMetric
+from .coco_video_metric import CocoVideoMetric
+from .crowdhuman_metric import CrowdHumanMetric
+from .dod_metric import DODCocoMetric
+from .dump_det_results import DumpDetResults
+from .dump_odvg_results import DumpODVGResults
+from .dump_proposals_metric import DumpProposals
+from .flickr30k_metric import Flickr30kMetric
+from .grefcoco_metric import gRefCOCOMetric
+from .lvis_metric import LVISMetric
+from .mot_challenge_metric import MOTChallengeMetric
+from .openimages_metric import OpenImagesMetric
+from .ov_coco_metric import OVCocoMetric
+from .refexp_metric import RefExpMetric
+from .refseg_metric import RefSegMetric
+from .reid_metric import ReIDMetrics
+from .semseg_metric import SemSegMetric
+from .voc_metric import VOCMetric
+from .youtube_vis_metric import YouTubeVISMetric
+from.custom_metric import CustomResultDumping
+
+__all__ = [
+    'CityScapesMetric', 'CocoMetric', 'CocoPanopticMetric', 'OpenImagesMetric',
+    'VOCMetric', 'LVISMetric', 'CrowdHumanMetric', 'DumpProposals',
+    'CocoOccludedSeparatedMetric', 'DumpDetResults', 'BaseVideoMetric',
+    'MOTChallengeMetric', 'CocoVideoMetric', 'ReIDMetrics', 'YouTubeVISMetric',
+    'COCOCaptionMetric', 'SemSegMetric', 'RefSegMetric', 'RefExpMetric',
+    'gRefCOCOMetric', 'DODCocoMetric', 'DumpODVGResults', 'Flickr30kMetric',
+    'OVCocoMetric', 'CustomResultDumping'
+]
diff --git a/mmdetection/mmdet/evaluation/metrics/base_video_metric.py b/mmdetection/mmdet/evaluation/metrics/base_video_metric.py
new file mode 100644
index 00000000..90c7cdcb
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/base_video_metric.py
@@ -0,0 +1,173 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+import pickle
+import shutil
+import tempfile
+import warnings
+from typing import Optional, Sequence
+
+import torch
+from mmengine.dist import (barrier, broadcast, broadcast_object_list,
+                           get_dist_info, is_main_process)
+from mmengine.evaluator import BaseMetric
+from mmengine.utils import mkdir_or_exist
+
+
+class BaseVideoMetric(BaseMetric):
+    """Base class for a metric in video task.
+
+    The metric first processes each batch of data_samples and predictions,
+    and appends the processed results to the results list. Then it
+    collects all results together from all ranks if distributed training
+    is used. Finally, it computes the metrics of the entire dataset.
+
+    A subclass of class:`BaseVideoMetric` should assign a meaningful value
+    to the class attribute `default_prefix`. See the argument `prefix` for
+    details.
+    """
+
+    def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
+        """Process one batch of data samples and predictions.
+
+        The processed results should be stored in ``self.results``, which will
+        be used to compute the metrics when all batches have been processed.
+
+        Args:
+            data_batch (dict): A batch of data from the dataloader.
+            data_samples (Sequence[dict]): A batch of data samples that
+                contain annotations and predictions.
+        """
+        for track_data_sample in data_samples:
+            video_data_samples = track_data_sample['video_data_samples']
+            ori_video_len = video_data_samples[0].ori_video_length
+            if ori_video_len == len(video_data_samples):
+                # video process
+                self.process_video(video_data_samples)
+            else:
+                # image process
+                self.process_image(video_data_samples, ori_video_len)
+
+    def evaluate(self, size: int = 1) -> dict:
+        """Evaluate the model performance of the whole dataset after processing
+        all batches.
+
+        Args:
+            size (int): Length of the entire validation dataset.
+
+        Returns:
+            dict: Evaluation metrics dict on the val dataset. The keys are the
+            names of the metrics, and the values are corresponding results.
+        """
+        if len(self.results) == 0:
+            warnings.warn(
+                f'{self.__class__.__name__} got empty `self.results`. Please '
+                'ensure that the processed results are properly added into '
+                '`self.results` in `process` method.')
+
+        results = collect_tracking_results(self.results, self.collect_device)
+
+        if is_main_process():
+            _metrics = self.compute_metrics(results)  # type: ignore
+            # Add prefix to metric names
+            if self.prefix:
+                _metrics = {
+                    '/'.join((self.prefix, k)): v
+                    for k, v in _metrics.items()
+                }
+            metrics = [_metrics]
+        else:
+            metrics = [None]  # type: ignore
+
+        broadcast_object_list(metrics)
+
+        # reset the results list
+        self.results.clear()
+        return metrics[0]
+
+
+def collect_tracking_results(results: list,
+                             device: str = 'cpu',
+                             tmpdir: Optional[str] = None) -> Optional[list]:
+    """Collected results in distributed environments. different from the
+    function mmengine.dist.collect_results, tracking compute metrics don't use
+    paramenter size, which means length of the entire validation dataset.
+    because it's equal to video num, but compute metrics need image num.
+
+    Args:
+        results (list): Result list containing result parts to be
+            collected. Each item of ``result_part`` should be a picklable
+            object.
+        device (str): Device name. Optional values are 'cpu' and 'gpu'.
+        tmpdir (str | None): Temporal directory for collected results to
+            store. If set to None, it will create a temporal directory for it.
+            ``tmpdir`` should be None when device is 'gpu'. Defaults to None.
+
+    Returns:
+        list or None: The collected results.
+    """
+    if device not in ['gpu', 'cpu']:
+        raise NotImplementedError(
+            f"device must be 'cpu' or 'gpu', but got {device}")
+
+    if device == 'gpu':
+        assert tmpdir is None, 'tmpdir should be None when device is "gpu"'
+        raise NotImplementedError('GPU collecting has not been supported yet')
+    else:
+        return collect_tracking_results_cpu(results, tmpdir)
+
+
+def collect_tracking_results_cpu(result_part: list,
+                                 tmpdir: Optional[str] = None
+                                 ) -> Optional[list]:
+    """Collect results on cpu mode.
+
+    Saves the results on different gpus to 'tmpdir' and collects them by the
+    rank 0 worker.
+
+    Args:
+        result_part (list): The part of prediction results.
+        tmpdir (str): Path of directory to save the temporary results from
+            different gpus under cpu mode. If is None, use `tempfile.mkdtemp()`
+            to make a temporary path. Defaults to None.
+
+    Returns:
+        list or None: The collected results.
+    """
+    rank, world_size = get_dist_info()
+    if world_size == 1:
+        return result_part
+
+    # create a tmp dir if it is not specified
+    if tmpdir is None:
+        MAX_LEN = 512
+        # 32 is whitespace
+        dir_tensor = torch.full((MAX_LEN, ), 32, dtype=torch.uint8)
+        if rank == 0:
+            mkdir_or_exist('.dist_test')
+            tmpdir = tempfile.mkdtemp(dir='.dist_test')
+            tmpdir = torch.tensor(
+                bytearray(tmpdir.encode()), dtype=torch.uint8)
+            dir_tensor[:len(tmpdir)] = tmpdir
+        broadcast(dir_tensor, 0)
+        tmpdir = dir_tensor.numpy().tobytes().decode().rstrip()
+    else:
+        mkdir_or_exist(tmpdir)
+
+    # dump the part result to the dir
+    with open(osp.join(tmpdir, f'part_{rank}.pkl'), 'wb') as f:  # type: ignore
+        pickle.dump(result_part, f, protocol=2)
+
+    barrier()
+
+    # collect all parts
+    if rank != 0:
+        return None
+    else:
+        # load results of all parts from tmp dir
+        part_list = []
+        for i in range(world_size):
+            path = osp.join(tmpdir, f'part_{i}.pkl')  # type: ignore
+            with open(path, 'rb') as f:
+                part_list.extend(pickle.load(f))
+        shutil.rmtree(tmpdir)
+        return part_list
diff --git a/mmdetection/mmdet/evaluation/metrics/cityscapes_metric.py b/mmdetection/mmdet/evaluation/metrics/cityscapes_metric.py
new file mode 100644
index 00000000..e5cdc179
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/cityscapes_metric.py
@@ -0,0 +1,205 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os
+import os.path as osp
+import shutil
+import tempfile
+from collections import OrderedDict
+from typing import Dict, Optional, Sequence
+
+import mmcv
+import numpy as np
+from mmengine.dist import is_main_process
+from mmengine.evaluator import BaseMetric
+from mmengine.logging import MMLogger
+
+from mmdet.registry import METRICS
+
+try:
+    import cityscapesscripts.evaluation.evalInstanceLevelSemanticLabeling as CSEval  # noqa: E501
+    import cityscapesscripts.helpers.labels as CSLabels
+
+    from mmdet.evaluation.functional import evaluateImgLists
+    HAS_CITYSCAPESAPI = True
+except ImportError:
+    HAS_CITYSCAPESAPI = False
+
+
+@METRICS.register_module()
+class CityScapesMetric(BaseMetric):
+    """CityScapes metric for instance segmentation.
+
+    Args:
+        outfile_prefix (str): The prefix of txt and png files. The txt and
+            png file will be save in a directory whose path is
+            "outfile_prefix.results/".
+        seg_prefix (str, optional): Path to the directory which contains the
+            cityscapes instance segmentation masks. It's necessary when
+            training and validation. It could be None when infer on test
+            dataset. Defaults to None.
+        format_only (bool): Format the output results without perform
+            evaluation. It is useful when you want to format the result
+            to a specific format and submit it to the test server.
+            Defaults to False.
+        collect_device (str): Device name used for collecting results from
+            different ranks during distributed training. Must be 'cpu' or
+            'gpu'. Defaults to 'cpu'.
+        prefix (str, optional): The prefix that will be added in the metric
+            names to disambiguate homonymous metrics of different evaluators.
+            If prefix is not provided in the argument, self.default_prefix
+            will be used instead. Defaults to None.
+        dump_matches (bool): Whether dump matches.json file during evaluating.
+            Defaults to False.
+        file_client_args (dict, optional): Arguments to instantiate the
+            corresponding backend in mmdet <= 3.0.0rc6. Defaults to None.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+    """
+    default_prefix: Optional[str] = 'cityscapes'
+
+    def __init__(self,
+                 outfile_prefix: str,
+                 seg_prefix: Optional[str] = None,
+                 format_only: bool = False,
+                 collect_device: str = 'cpu',
+                 prefix: Optional[str] = None,
+                 dump_matches: bool = False,
+                 file_client_args: dict = None,
+                 backend_args: dict = None) -> None:
+
+        if not HAS_CITYSCAPESAPI:
+            raise RuntimeError('Failed to import `cityscapesscripts`.'
+                               'Please try to install official '
+                               'cityscapesscripts by '
+                               '"pip install cityscapesscripts"')
+        super().__init__(collect_device=collect_device, prefix=prefix)
+
+        self.tmp_dir = None
+        self.format_only = format_only
+        if self.format_only:
+            assert outfile_prefix is not None, 'outfile_prefix must be not'
+            'None when format_only is True, otherwise the result files will'
+            'be saved to a temp directory which will be cleaned up at the end.'
+        else:
+            assert seg_prefix is not None, '`seg_prefix` is necessary when '
+            'computing the CityScapes metrics'
+
+        if outfile_prefix is None:
+            self.tmp_dir = tempfile.TemporaryDirectory()
+            self.outfile_prefix = osp.join(self.tmp_dir.name, 'results')
+        else:
+            # the directory to save predicted panoptic segmentation mask
+            self.outfile_prefix = osp.join(outfile_prefix, 'results')  # type: ignore # yapf: disable # noqa: E501
+
+        dir_name = osp.expanduser(self.outfile_prefix)
+
+        if osp.exists(dir_name) and is_main_process():
+            logger: MMLogger = MMLogger.get_current_instance()
+            logger.info('remove previous results.')
+            shutil.rmtree(dir_name)
+        os.makedirs(dir_name, exist_ok=True)
+
+        self.backend_args = backend_args
+        if file_client_args is not None:
+            raise RuntimeError(
+                'The `file_client_args` is deprecated, '
+                'please use `backend_args` instead, please refer to'
+                'https://github.com/open-mmlab/mmdetection/blob/main/configs/_base_/datasets/coco_detection.py'  # noqa: E501
+            )
+
+        self.seg_prefix = seg_prefix
+        self.dump_matches = dump_matches
+
+    def __del__(self) -> None:
+        """Clean up the results if necessary."""
+        if self.tmp_dir is not None:
+            self.tmp_dir.cleanup()
+
+    # TODO: data_batch is no longer needed, consider adjusting the
+    #  parameter position
+    def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
+        """Process one batch of data samples and predictions. The processed
+        results should be stored in ``self.results``, which will be used to
+        compute the metrics when all batches have been processed.
+
+        Args:
+            data_batch (dict): A batch of data from the dataloader.
+            data_samples (Sequence[dict]): A batch of data samples that
+                contain annotations and predictions.
+        """
+        for data_sample in data_samples:
+            # parse pred
+            result = dict()
+            pred = data_sample['pred_instances']
+            filename = data_sample['img_path']
+            basename = osp.splitext(osp.basename(filename))[0]
+            pred_txt = osp.join(self.outfile_prefix, basename + '_pred.txt')
+            result['pred_txt'] = pred_txt
+            labels = pred['labels'].cpu().numpy()
+            masks = pred['masks'].cpu().numpy().astype(np.uint8)
+            if 'mask_scores' in pred:
+                # some detectors use different scores for bbox and mask
+                mask_scores = pred['mask_scores'].cpu().numpy()
+            else:
+                mask_scores = pred['scores'].cpu().numpy()
+
+            with open(pred_txt, 'w') as f:
+                for i, (label, mask, mask_score) in enumerate(
+                        zip(labels, masks, mask_scores)):
+                    class_name = self.dataset_meta['classes'][label]
+                    class_id = CSLabels.name2label[class_name].id
+                    png_filename = osp.join(
+                        self.outfile_prefix,
+                        basename + f'_{i}_{class_name}.png')
+                    mmcv.imwrite(mask, png_filename)
+                    f.write(f'{osp.basename(png_filename)} '
+                            f'{class_id} {mask_score}\n')
+
+            # parse gt
+            gt = dict()
+            img_path = filename.replace('leftImg8bit.png',
+                                        'gtFine_instanceIds.png')
+            gt['file_name'] = img_path.replace('leftImg8bit', 'gtFine')
+
+            self.results.append((gt, result))
+
+    def compute_metrics(self, results: list) -> Dict[str, float]:
+        """Compute the metrics from processed results.
+
+        Args:
+            results (list): The processed results of each batch.
+
+        Returns:
+            Dict[str, float]: The computed metrics. The keys are the names of
+                the metrics, and the values are corresponding results.
+        """
+        logger: MMLogger = MMLogger.get_current_instance()
+
+        if self.format_only:
+            logger.info(
+                f'results are saved to {osp.dirname(self.outfile_prefix)}')
+            return OrderedDict()
+        logger.info('starts to compute metric')
+
+        gts, preds = zip(*results)
+        # set global states in cityscapes evaluation API
+        gt_instances_file = osp.join(self.outfile_prefix, 'gtInstances.json')  # type: ignore # yapf: disable # noqa: E501
+        # split gt and prediction list
+        gts, preds = zip(*results)
+        CSEval.args.JSONOutput = False
+        CSEval.args.colorized = False
+        CSEval.args.gtInstancesFile = gt_instances_file
+
+        groundTruthImgList = [gt['file_name'] for gt in gts]
+        predictionImgList = [pred['pred_txt'] for pred in preds]
+        CSEval_results = evaluateImgLists(
+            predictionImgList,
+            groundTruthImgList,
+            CSEval.args,
+            self.backend_args,
+            dump_matches=self.dump_matches)['averages']
+
+        eval_results = OrderedDict()
+        eval_results['mAP'] = CSEval_results['allAp']
+        eval_results['AP@50'] = CSEval_results['allAp50%']
+
+        return eval_results
diff --git a/mmdetection/mmdet/evaluation/metrics/coco_caption_metric.py b/mmdetection/mmdet/evaluation/metrics/coco_caption_metric.py
new file mode 100644
index 00000000..d8c73501
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/coco_caption_metric.py
@@ -0,0 +1,135 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import json
+import os
+import tempfile
+from typing import List, Optional
+
+from mmengine.evaluator import BaseMetric
+from mmengine.utils import track_iter_progress
+from pycocotools.coco import COCO
+
+from mmdet.registry import METRICS
+
+try:
+    from pycocoevalcap.eval import COCOEvalCap
+except ImportError:
+    COCOEvalCap = None
+
+
+@METRICS.register_module()
+class COCOCaptionMetric(BaseMetric):
+    """Coco Caption evaluation wrapper.
+
+    Save the generated captions and transform into coco format.
+    Calling COCO API for caption metrics.
+
+    Args:
+        ann_file (str): the path for the COCO format caption ground truth
+            json file, load for evaluations.
+        collect_device (str): Device name used for collecting results from
+            different ranks during distributed training. Must be 'cpu' or
+            'gpu'. Defaults to 'cpu'.
+        prefix (str, optional): The prefix that will be added in the metric
+            names to disambiguate homonymous metrics of different evaluators.
+            If prefix is not provided in the argument, self.default_prefix
+            will be used instead. Should be modified according to the
+            `retrieval_type` for unambiguous results. Defaults to TR.
+    """
+
+    def __init__(self,
+                 ann_file: str,
+                 collect_device: str = 'cpu',
+                 prefix: Optional[str] = None):
+        if COCOEvalCap is None:
+            raise RuntimeError(
+                'COCOEvalCap is not installed, please install it by: '
+                'pip install pycocoevalcap')
+
+        super().__init__(collect_device=collect_device, prefix=prefix)
+        self.ann_file = ann_file
+
+    def process(self, data_batch, data_samples):
+        """Process one batch of data samples.
+
+        The processed results should be stored in ``self.results``, which will
+        be used to computed the metrics when all batches have been processed.
+
+        Args:
+            data_batch: A batch of data from the dataloader.
+            data_samples (Sequence[dict]): A batch of outputs from the model.
+        """
+
+        for data_sample in data_samples:
+            result = dict()
+
+            result['caption'] = data_sample['pred_caption']
+            result['image_id'] = int(data_sample['img_id'])
+
+            # Save the result to `self.results`.
+            self.results.append(result)
+
+    def compute_metrics(self, results: List):
+        """Compute the metrics from processed results.
+
+        Args:
+            results (dict): The processed results of each batch.
+
+        Returns:
+            Dict: The computed metrics. The keys are the names of the metrics,
+            and the values are corresponding results.
+        """
+        # NOTICE: don't access `self.results` from the method.
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+
+            eval_result_file = save_result(
+                result=results,
+                result_dir=temp_dir,
+                filename='caption_pred',
+                remove_duplicate='image_id',
+            )
+
+            coco_val = coco_caption_eval(eval_result_file, self.ann_file)
+
+        return coco_val
+
+
+def save_result(result, result_dir, filename, remove_duplicate=''):
+    """Saving predictions as json file for evaluation."""
+    # combine results from all processes
+    if remove_duplicate:
+        result_new = []
+        id_list = []
+        for res in track_iter_progress(result):
+            if res[remove_duplicate] not in id_list:
+                id_list.append(res[remove_duplicate])
+                result_new.append(res)
+        result = result_new
+
+    final_result_file_url = os.path.join(result_dir, '%s.json' % filename)
+    print(f'result file saved to {final_result_file_url}')
+    json.dump(result, open(final_result_file_url, 'w'))
+
+    return final_result_file_url
+
+
+def coco_caption_eval(results_file, ann_file):
+    """Evaluation between gt json and prediction json files."""
+    # create coco object and coco_result object
+    coco = COCO(ann_file)
+    coco_result = coco.loadRes(results_file)
+
+    # create coco_eval object by taking coco and coco_result
+    coco_eval = COCOEvalCap(coco, coco_result)
+
+    # make sure the image ids are the same
+    coco_eval.params['image_id'] = coco_result.getImgIds()
+
+    # This will take some times at the first run
+    coco_eval.evaluate()
+
+    # print output evaluation scores
+    for metric, score in coco_eval.eval.items():
+        print(f'{metric}: {score:.3f}')
+
+    return coco_eval.eval
diff --git a/mmdetection/mmdet/evaluation/metrics/coco_metric.py b/mmdetection/mmdet/evaluation/metrics/coco_metric.py
new file mode 100644
index 00000000..cfdc66e0
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/coco_metric.py
@@ -0,0 +1,597 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import datetime
+import itertools
+import os.path as osp
+import tempfile
+from collections import OrderedDict
+from typing import Dict, List, Optional, Sequence, Union
+
+import numpy as np
+import torch
+from mmengine.evaluator import BaseMetric
+from mmengine.fileio import dump, get_local_path, load
+from mmengine.logging import MMLogger
+from terminaltables import AsciiTable
+
+from mmdet.datasets.api_wrappers import COCO, COCOeval, COCOevalMP
+from mmdet.registry import METRICS
+from mmdet.structures.mask import encode_mask_results
+from ..functional import eval_recalls
+
+
+@METRICS.register_module()
+class CocoMetric(BaseMetric):
+    """COCO evaluation metric.
+
+    Evaluate AR, AP, and mAP for detection tasks including proposal/box
+    detection and instance segmentation. Please refer to
+    https://cocodataset.org/#detection-eval for more details.
+
+    Args:
+        ann_file (str, optional): Path to the coco format annotation file.
+            If not specified, ground truth annotations from the dataset will
+            be converted to coco format. Defaults to None.
+        metric (str | List[str]): Metrics to be evaluated. Valid metrics
+            include 'bbox', 'segm', 'proposal', and 'proposal_fast'.
+            Defaults to 'bbox'.
+        classwise (bool): Whether to evaluate the metric class-wise.
+            Defaults to False.
+        proposal_nums (Sequence[int]): Numbers of proposals to be evaluated.
+            Defaults to (100, 300, 1000).
+        iou_thrs (float | List[float], optional): IoU threshold to compute AP
+            and AR. If not specified, IoUs from 0.5 to 0.95 will be used.
+            Defaults to None.
+        metric_items (List[str], optional): Metric result names to be
+            recorded in the evaluation result. Defaults to None.
+        format_only (bool): Format the output results without perform
+            evaluation. It is useful when you want to format the result
+            to a specific format and submit it to the test server.
+            Defaults to False.
+        outfile_prefix (str, optional): The prefix of json files. It includes
+            the file path and the prefix of filename, e.g., "a/b/prefix".
+            If not specified, a temp file will be created. Defaults to None.
+        file_client_args (dict, optional): Arguments to instantiate the
+            corresponding backend in mmdet <= 3.0.0rc6. Defaults to None.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+        collect_device (str): Device name used for collecting results from
+            different ranks during distributed training. Must be 'cpu' or
+            'gpu'. Defaults to 'cpu'.
+        prefix (str, optional): The prefix that will be added in the metric
+            names to disambiguate homonymous metrics of different evaluators.
+            If prefix is not provided in the argument, self.default_prefix
+            will be used instead. Defaults to None.
+        sort_categories (bool): Whether sort categories in annotations. Only
+            used for `Objects365V1Dataset`. Defaults to False.
+        use_mp_eval (bool): Whether to use mul-processing evaluation
+    """
+    default_prefix: Optional[str] = 'coco'
+
+    def __init__(self,
+                 ann_file: Optional[str] = None,
+                 metric: Union[str, List[str]] = 'bbox',
+                 classwise: bool = False,
+                 proposal_nums: Sequence[int] = (100, 300, 1000),
+                 iou_thrs: Optional[Union[float, Sequence[float]]] = None,
+                 metric_items: Optional[Sequence[str]] = None,
+                 format_only: bool = False,
+                 outfile_prefix: Optional[str] = None,
+                 file_client_args: dict = None,
+                 backend_args: dict = None,
+                 collect_device: str = 'cpu',
+                 prefix: Optional[str] = None,
+                 sort_categories: bool = False,
+                 use_mp_eval: bool = False) -> None:
+        super().__init__(collect_device=collect_device, prefix=prefix)
+        # coco evaluation metrics
+        self.metrics = metric if isinstance(metric, list) else [metric]
+        allowed_metrics = ['bbox', 'segm', 'proposal', 'proposal_fast']
+        for metric in self.metrics:
+            if metric not in allowed_metrics:
+                raise KeyError(
+                    "metric should be one of 'bbox', 'segm', 'proposal', "
+                    f"'proposal_fast', but got {metric}.")
+
+        # do class wise evaluation, default False
+        self.classwise = classwise
+        # whether to use multi processing evaluation, default False
+        self.use_mp_eval = use_mp_eval
+
+        # proposal_nums used to compute recall or precision.
+        self.proposal_nums = list(proposal_nums)
+
+        # iou_thrs used to compute recall or precision.
+        if iou_thrs is None:
+            iou_thrs = np.linspace(
+                .5, 0.95, int(np.round((0.95 - .5) / .05)) + 1, endpoint=True)
+        self.iou_thrs = iou_thrs
+        self.metric_items = metric_items
+        self.format_only = format_only
+        if self.format_only:
+            assert outfile_prefix is not None, 'outfile_prefix must be not'
+            'None when format_only is True, otherwise the result files will'
+            'be saved to a temp directory which will be cleaned up at the end.'
+
+        self.outfile_prefix = outfile_prefix
+
+        self.backend_args = backend_args
+        if file_client_args is not None:
+            raise RuntimeError(
+                'The `file_client_args` is deprecated, '
+                'please use `backend_args` instead, please refer to'
+                'https://github.com/open-mmlab/mmdetection/blob/main/configs/_base_/datasets/coco_detection.py'  # noqa: E501
+            )
+
+        # if ann_file is not specified,
+        # initialize coco api with the converted dataset
+        if ann_file is not None:
+            with get_local_path(
+                    ann_file, backend_args=self.backend_args) as local_path:
+                self._coco_api = COCO(local_path)
+                if sort_categories:
+                    # 'categories' list in objects365_train.json and
+                    # objects365_val.json is inconsistent, need sort
+                    # list(or dict) before get cat_ids.
+                    cats = self._coco_api.cats
+                    sorted_cats = {i: cats[i] for i in sorted(cats)}
+                    self._coco_api.cats = sorted_cats
+                    categories = self._coco_api.dataset['categories']
+                    sorted_categories = sorted(
+                        categories, key=lambda i: i['id'])
+                    self._coco_api.dataset['categories'] = sorted_categories
+        else:
+            self._coco_api = None
+
+        # handle dataset lazy init
+        self.cat_ids = None
+        self.img_ids = None
+
+    def fast_eval_recall(self,
+                         results: List[dict],
+                         proposal_nums: Sequence[int],
+                         iou_thrs: Sequence[float],
+                         logger: Optional[MMLogger] = None) -> np.ndarray:
+        """Evaluate proposal recall with COCO's fast_eval_recall.
+
+        Args:
+            results (List[dict]): Results of the dataset.
+            proposal_nums (Sequence[int]): Proposal numbers used for
+                evaluation.
+            iou_thrs (Sequence[float]): IoU thresholds used for evaluation.
+            logger (MMLogger, optional): Logger used for logging the recall
+                summary.
+        Returns:
+            np.ndarray: Averaged recall results.
+        """
+        gt_bboxes = []
+        pred_bboxes = [result['bboxes'] for result in results]
+        for i in range(len(self.img_ids)):
+            ann_ids = self._coco_api.get_ann_ids(img_ids=self.img_ids[i])
+            ann_info = self._coco_api.load_anns(ann_ids)
+            if len(ann_info) == 0:
+                gt_bboxes.append(np.zeros((0, 4)))
+                continue
+            bboxes = []
+            for ann in ann_info:
+                if ann.get('ignore', False) or ann['iscrowd']:
+                    continue
+                x1, y1, w, h = ann['bbox']
+                bboxes.append([x1, y1, x1 + w, y1 + h])
+            bboxes = np.array(bboxes, dtype=np.float32)
+            if bboxes.shape[0] == 0:
+                bboxes = np.zeros((0, 4))
+            gt_bboxes.append(bboxes)
+
+        recalls = eval_recalls(
+            gt_bboxes, pred_bboxes, proposal_nums, iou_thrs, logger=logger)
+        ar = recalls.mean(axis=1)
+        return ar
+
+    def xyxy2xywh(self, bbox: np.ndarray) -> list:
+        """Convert ``xyxy`` style bounding boxes to ``xywh`` style for COCO
+        evaluation.
+
+        Args:
+            bbox (numpy.ndarray): The bounding boxes, shape (4, ), in
+                ``xyxy`` order.
+
+        Returns:
+            list[float]: The converted bounding boxes, in ``xywh`` order.
+        """
+
+        _bbox: List = bbox.tolist()
+        return [
+            _bbox[0],
+            _bbox[1],
+            _bbox[2] - _bbox[0],
+            _bbox[3] - _bbox[1],
+        ]
+
+    def results2json(self, results: Sequence[dict],
+                     outfile_prefix: str) -> dict:
+        """Dump the detection results to a COCO style json file.
+
+        There are 3 types of results: proposals, bbox predictions, mask
+        predictions, and they have different data types. This method will
+        automatically recognize the type, and dump them to json files.
+
+        Args:
+            results (Sequence[dict]): Testing results of the
+                dataset.
+            outfile_prefix (str): The filename prefix of the json files. If the
+                prefix is "somepath/xxx", the json files will be named
+                "somepath/xxx.bbox.json", "somepath/xxx.segm.json",
+                "somepath/xxx.proposal.json".
+
+        Returns:
+            dict: Possible keys are "bbox", "segm", "proposal", and
+            values are corresponding filenames.
+        """
+        bbox_json_results = []
+        segm_json_results = [] if 'masks' in results[0] else None
+        for idx, result in enumerate(results):
+            image_id = result.get('img_id', idx)
+            labels = result['labels']
+            bboxes = result['bboxes']
+            scores = result['scores']
+            # bbox results
+            for i, label in enumerate(labels):
+                data = dict()
+                data['image_id'] = image_id
+                data['bbox'] = self.xyxy2xywh(bboxes[i])
+                data['score'] = float(scores[i])
+                data['category_id'] = self.cat_ids[label]
+                bbox_json_results.append(data)
+
+            if segm_json_results is None:
+                continue
+
+            # segm results
+            masks = result['masks']
+            mask_scores = result.get('mask_scores', scores)
+            for i, label in enumerate(labels):
+                data = dict()
+                data['image_id'] = image_id
+                data['bbox'] = self.xyxy2xywh(bboxes[i])
+                data['score'] = float(mask_scores[i])
+                data['category_id'] = self.cat_ids[label]
+                if isinstance(masks[i]['counts'], bytes):
+                    masks[i]['counts'] = masks[i]['counts'].decode()
+                data['segmentation'] = masks[i]
+                segm_json_results.append(data)
+
+        result_files = dict()
+        result_files['bbox'] = f'{outfile_prefix}.bbox.json'
+        result_files['proposal'] = f'{outfile_prefix}.bbox.json'
+        dump(bbox_json_results, result_files['bbox'])
+
+        if segm_json_results is not None:
+            result_files['segm'] = f'{outfile_prefix}.segm.json'
+            dump(segm_json_results, result_files['segm'])
+
+        return result_files
+
+    def gt_to_coco_json(self, gt_dicts: Sequence[dict],
+                        outfile_prefix: str) -> str:
+        """Convert ground truth to coco format json file.
+
+        Args:
+            gt_dicts (Sequence[dict]): Ground truth of the dataset.
+            outfile_prefix (str): The filename prefix of the json files. If the
+                prefix is "somepath/xxx", the json file will be named
+                "somepath/xxx.gt.json".
+        Returns:
+            str: The filename of the json file.
+        """
+        categories = [
+            dict(id=id, name=name)
+            for id, name in enumerate(self.dataset_meta['classes'])
+        ]
+        image_infos = []
+        annotations = []
+
+        for idx, gt_dict in enumerate(gt_dicts):
+            img_id = gt_dict.get('img_id', idx)
+            image_info = dict(
+                id=img_id,
+                width=gt_dict['width'],
+                height=gt_dict['height'],
+                file_name='')
+            image_infos.append(image_info)
+            for ann in gt_dict['anns']:
+                label = ann['bbox_label']
+                bbox = ann['bbox']
+                coco_bbox = [
+                    bbox[0],
+                    bbox[1],
+                    bbox[2] - bbox[0],
+                    bbox[3] - bbox[1],
+                ]
+
+                annotation = dict(
+                    id=len(annotations) +
+                    1,  # coco api requires id starts with 1
+                    image_id=img_id,
+                    bbox=coco_bbox,
+                    iscrowd=ann.get('ignore_flag', 0),
+                    category_id=int(label),
+                    area=coco_bbox[2] * coco_bbox[3])
+                if ann.get('mask', None):
+                    mask = ann['mask']
+                    # area = mask_util.area(mask)
+                    if isinstance(mask, dict) and isinstance(
+                            mask['counts'], bytes):
+                        mask['counts'] = mask['counts'].decode()
+                    annotation['segmentation'] = mask
+                    # annotation['area'] = float(area)
+                annotations.append(annotation)
+
+        info = dict(
+            date_created=str(datetime.datetime.now()),
+            description='Coco json file converted by mmdet CocoMetric.')
+        coco_json = dict(
+            info=info,
+            images=image_infos,
+            categories=categories,
+            licenses=None,
+        )
+        if len(annotations) > 0:
+            coco_json['annotations'] = annotations
+        converted_json_path = f'{outfile_prefix}.gt.json'
+        dump(coco_json, converted_json_path)
+        return converted_json_path
+
+    # TODO: data_batch is no longer needed, consider adjusting the
+    #  parameter position
+    def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
+        """Process one batch of data samples and predictions. The processed
+        results should be stored in ``self.results``, which will be used to
+        compute the metrics when all batches have been processed.
+
+        Args:
+            data_batch (dict): A batch of data from the dataloader.
+            data_samples (Sequence[dict]): A batch of data samples that
+                contain annotations and predictions.
+        """
+        for data_sample in data_samples:
+            result = dict()
+            pred = data_sample['pred_instances']
+            result['img_id'] = data_sample['img_id']
+            result['bboxes'] = pred['bboxes'].cpu().numpy()
+            result['scores'] = pred['scores'].cpu().numpy()
+            result['labels'] = pred['labels'].cpu().numpy()
+            # encode mask to RLE
+            if 'masks' in pred:
+                result['masks'] = encode_mask_results(
+                    pred['masks'].detach().cpu().numpy()) if isinstance(
+                        pred['masks'], torch.Tensor) else pred['masks']
+            # some detectors use different scores for bbox and mask
+            if 'mask_scores' in pred:
+                result['mask_scores'] = pred['mask_scores'].cpu().numpy()
+
+            # parse gt
+            gt = dict()
+            gt['width'] = data_sample['ori_shape'][1]
+            gt['height'] = data_sample['ori_shape'][0]
+            gt['img_id'] = data_sample['img_id']
+            if self._coco_api is None:
+                # TODO: Need to refactor to support LoadAnnotations
+                assert 'instances' in data_sample, \
+                    'ground truth is required for evaluation when ' \
+                    '`ann_file` is not provided'
+                gt['anns'] = data_sample['instances']
+            # add converted result to the results list
+            self.results.append((gt, result))
+
+    def compute_metrics(self, results: list) -> Dict[str, float]:
+        """Compute the metrics from processed results.
+
+        Args:
+            results (list): The processed results of each batch.
+
+        Returns:
+            Dict[str, float]: The computed metrics. The keys are the names of
+            the metrics, and the values are corresponding results.
+        """
+        logger: MMLogger = MMLogger.get_current_instance()
+
+        # split gt and prediction list
+        gts, preds = zip(*results)
+
+        tmp_dir = None
+        if self.outfile_prefix is None:
+            tmp_dir = tempfile.TemporaryDirectory()
+            outfile_prefix = osp.join(tmp_dir.name, 'results')
+        else:
+            outfile_prefix = self.outfile_prefix
+
+        if self._coco_api is None:
+            # use converted gt json file to initialize coco api
+            logger.info('Converting ground truth to coco format...')
+            coco_json_path = self.gt_to_coco_json(
+                gt_dicts=gts, outfile_prefix=outfile_prefix)
+            self._coco_api = COCO(coco_json_path)
+
+        # handle lazy init
+        if self.cat_ids is None:
+            self.cat_ids = self._coco_api.get_cat_ids(
+                cat_names=self.dataset_meta['classes'])
+        if self.img_ids is None:
+            self.img_ids = self._coco_api.get_img_ids()
+
+        # convert predictions to coco format and dump to json file
+        result_files = self.results2json(preds, outfile_prefix)
+
+        eval_results = OrderedDict()
+        if self.format_only:
+            logger.info('results are saved in '
+                        f'{osp.dirname(outfile_prefix)}')
+            return eval_results
+
+        for metric in self.metrics:
+            logger.info(f'Evaluating {metric}...')
+
+            # TODO: May refactor fast_eval_recall to an independent metric?
+            # fast eval recall
+            if metric == 'proposal_fast':
+                ar = self.fast_eval_recall(
+                    preds, self.proposal_nums, self.iou_thrs, logger=logger)
+                log_msg = []
+                for i, num in enumerate(self.proposal_nums):
+                    eval_results[f'AR@{num}'] = ar[i]
+                    log_msg.append(f'\nAR@{num}\t{ar[i]:.4f}')
+                log_msg = ''.join(log_msg)
+                logger.info(log_msg)
+                continue
+
+            # evaluate proposal, bbox and segm
+            iou_type = 'bbox' if metric == 'proposal' else metric
+            if metric not in result_files:
+                raise KeyError(f'{metric} is not in results')
+            try:
+                predictions = load(result_files[metric])
+                if iou_type == 'segm':
+                    # Refer to https://github.com/cocodataset/cocoapi/blob/master/PythonAPI/pycocotools/coco.py#L331  # noqa
+                    # When evaluating mask AP, if the results contain bbox,
+                    # cocoapi will use the box area instead of the mask area
+                    # for calculating the instance area. Though the overall AP
+                    # is not affected, this leads to different
+                    # small/medium/large mask AP results.
+                    for x in predictions:
+                        x.pop('bbox')
+                coco_dt = self._coco_api.loadRes(predictions)
+
+            except IndexError:
+                logger.error(
+                    'The testing results of the whole dataset is empty.')
+                break
+
+            if self.use_mp_eval:
+                coco_eval = COCOevalMP(self._coco_api, coco_dt, iou_type)
+            else:
+                coco_eval = COCOeval(self._coco_api, coco_dt, iou_type)
+
+            coco_eval.params.catIds = self.cat_ids
+            coco_eval.params.imgIds = self.img_ids
+            coco_eval.params.maxDets = list(self.proposal_nums)
+            coco_eval.params.iouThrs = self.iou_thrs
+
+            # mapping of cocoEval.stats
+            coco_metric_names = {
+                'mAP': 0,
+                'mAP_50': 1,
+                'mAP_75': 2,
+                'mAP_s': 3,
+                'mAP_m': 4,
+                'mAP_l': 5,
+                'AR@100': 6,
+                'AR@300': 7,
+                'AR@1000': 8,
+                'AR_s@1000': 9,
+                'AR_m@1000': 10,
+                'AR_l@1000': 11
+            }
+            metric_items = self.metric_items
+            if metric_items is not None:
+                for metric_item in metric_items:
+                    if metric_item not in coco_metric_names:
+                        raise KeyError(
+                            f'metric item "{metric_item}" is not supported')
+
+            if metric == 'proposal':
+                coco_eval.params.useCats = 0
+                coco_eval.evaluate()
+                coco_eval.accumulate()
+                coco_eval.summarize()
+                if metric_items is None:
+                    metric_items = [
+                        'AR@100', 'AR@300', 'AR@1000', 'AR_s@1000',
+                        'AR_m@1000', 'AR_l@1000'
+                    ]
+
+                for item in metric_items:
+                    val = float(
+                        f'{coco_eval.stats[coco_metric_names[item]]:.3f}')
+                    eval_results[item] = val
+            else:
+                coco_eval.evaluate()
+                coco_eval.accumulate()
+                coco_eval.summarize()
+                if self.classwise:  # Compute per-category AP
+                    # Compute per-category AP
+                    # from https://github.com/facebookresearch/detectron2/
+                    precisions = coco_eval.eval['precision']
+                    # precision: (iou, recall, cls, area range, max dets)
+                    assert len(self.cat_ids) == precisions.shape[2]
+
+                    results_per_category = []
+                    for idx, cat_id in enumerate(self.cat_ids):
+                        t = []
+                        # area range index 0: all area ranges
+                        # max dets index -1: typically 100 per image
+                        nm = self._coco_api.loadCats(cat_id)[0]
+                        precision = precisions[:, :, idx, 0, -1]
+                        precision = precision[precision > -1]
+                        if precision.size:
+                            ap = np.mean(precision)
+                        else:
+                            ap = float('nan')
+                        t.append(f'{nm["name"]}')
+                        t.append(f'{round(ap, 3)}')
+                        eval_results[f'{nm["name"]}_precision'] = round(ap, 3)
+
+                        # indexes of IoU  @50 and @75
+                        for iou in [0, 5]:
+                            precision = precisions[iou, :, idx, 0, -1]
+                            precision = precision[precision > -1]
+                            if precision.size:
+                                ap = np.mean(precision)
+                            else:
+                                ap = float('nan')
+                            t.append(f'{round(ap, 3)}')
+
+                        # indexes of area of small, median and large
+                        for area in [1, 2, 3]:
+                            precision = precisions[:, :, idx, area, -1]
+                            precision = precision[precision > -1]
+                            if precision.size:
+                                ap = np.mean(precision)
+                            else:
+                                ap = float('nan')
+                            t.append(f'{round(ap, 3)}')
+                        results_per_category.append(tuple(t))
+
+                    num_columns = len(results_per_category[0])
+                    results_flatten = list(
+                        itertools.chain(*results_per_category))
+                    headers = [
+                        'category', 'mAP', 'mAP_50', 'mAP_75', 'mAP_s',
+                        'mAP_m', 'mAP_l'
+                    ]
+                    results_2d = itertools.zip_longest(*[
+                        results_flatten[i::num_columns]
+                        for i in range(num_columns)
+                    ])
+                    table_data = [headers]
+                    table_data += [result for result in results_2d]
+                    table = AsciiTable(table_data)
+                    logger.info('\n' + table.table)
+
+                if metric_items is None:
+                    metric_items = [
+                        'mAP', 'mAP_50', 'mAP_75', 'mAP_s', 'mAP_m', 'mAP_l'
+                    ]
+
+                for metric_item in metric_items:
+                    key = f'{metric}_{metric_item}'
+                    val = coco_eval.stats[coco_metric_names[metric_item]]
+                    eval_results[key] = float(f'{round(val, 3)}')
+
+                ap = coco_eval.stats[:6]
+                logger.info(f'{metric}_mAP_copypaste: {ap[0]:.3f} '
+                            f'{ap[1]:.3f} {ap[2]:.3f} {ap[3]:.3f} '
+                            f'{ap[4]:.3f} {ap[5]:.3f}')
+
+        if tmp_dir is not None:
+            tmp_dir.cleanup()
+        return eval_results
diff --git a/mmdetection/mmdet/evaluation/metrics/coco_occluded_metric.py b/mmdetection/mmdet/evaluation/metrics/coco_occluded_metric.py
new file mode 100644
index 00000000..81235a04
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/coco_occluded_metric.py
@@ -0,0 +1,204 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, List, Optional, Union
+
+import mmengine
+import numpy as np
+from mmengine.fileio import load
+from mmengine.logging import print_log
+from pycocotools import mask as coco_mask
+from terminaltables import AsciiTable
+
+from mmdet.registry import METRICS
+from .coco_metric import CocoMetric
+
+
+@METRICS.register_module()
+class CocoOccludedSeparatedMetric(CocoMetric):
+    """Metric of separated and occluded masks which presented in paper `A Tri-
+    Layer Plugin to Improve Occluded Detection.
+
+    `_.
+
+    Separated COCO and Occluded COCO are automatically generated subsets of
+    COCO val dataset, collecting separated objects and partially occluded
+    objects for a large variety of categories. In this way, we define
+    occlusion into two major categories: separated and partially occluded.
+
+    - Separation: target object segmentation mask is separated into distinct
+      regions by the occluder.
+    - Partial Occlusion: target object is partially occluded but the
+      segmentation mask is connected.
+
+    These two new scalable real-image datasets are to benchmark a model's
+    capability to detect occluded objects of 80 common categories.
+
+    Please cite the paper if you use this dataset:
+
+    @article{zhan2022triocc,
+        title={A Tri-Layer Plugin to Improve Occluded Detection},
+        author={Zhan, Guanqi and Xie, Weidi and Zisserman, Andrew},
+        journal={British Machine Vision Conference},
+        year={2022}
+    }
+
+    Args:
+        occluded_ann (str): Path to the occluded coco annotation file.
+        separated_ann (str): Path to the separated coco annotation file.
+        score_thr (float): Score threshold of the detection masks.
+            Defaults to 0.3.
+        iou_thr (float): IoU threshold for the recall calculation.
+            Defaults to 0.75.
+        metric (str | List[str]): Metrics to be evaluated. Valid metrics
+            include 'bbox', 'segm', 'proposal', and 'proposal_fast'.
+            Defaults to 'bbox'.
+    """
+    default_prefix: Optional[str] = 'coco'
+
+    def __init__(
+            self,
+            *args,
+            occluded_ann:
+        str = 'https://www.robots.ox.ac.uk/~vgg/research/tpod/datasets/occluded_coco.pkl',  # noqa
+            separated_ann:
+        str = 'https://www.robots.ox.ac.uk/~vgg/research/tpod/datasets/separated_coco.pkl',  # noqa
+            score_thr: float = 0.3,
+            iou_thr: float = 0.75,
+            metric: Union[str, List[str]] = ['bbox', 'segm'],
+            **kwargs) -> None:
+        super().__init__(*args, metric=metric, **kwargs)
+        self.occluded_ann = load(occluded_ann)
+        self.separated_ann = load(separated_ann)
+        self.score_thr = score_thr
+        self.iou_thr = iou_thr
+
+    def compute_metrics(self, results: list) -> Dict[str, float]:
+        """Compute the metrics from processed results.
+
+        Args:
+            results (list): The processed results of each batch.
+
+        Returns:
+            Dict[str, float]: The computed metrics. The keys are the names of
+            the metrics, and the values are corresponding results.
+        """
+        coco_metric_res = super().compute_metrics(results)
+        eval_res = self.evaluate_occluded_separated(results)
+        coco_metric_res.update(eval_res)
+        return coco_metric_res
+
+    def evaluate_occluded_separated(self, results: List[tuple]) -> dict:
+        """Compute the recall of occluded and separated masks.
+
+        Args:
+            results (list[tuple]): Testing results of the dataset.
+
+        Returns:
+            dict[str, float]: The recall of occluded and separated masks.
+        """
+        dict_det = {}
+        print_log('processing detection results...')
+        prog_bar = mmengine.ProgressBar(len(results))
+        for i in range(len(results)):
+            gt, dt = results[i]
+            img_id = dt['img_id']
+            cur_img_name = self._coco_api.imgs[img_id]['file_name']
+            if cur_img_name not in dict_det.keys():
+                dict_det[cur_img_name] = []
+
+            for bbox, score, label, mask in zip(dt['bboxes'], dt['scores'],
+                                                dt['labels'], dt['masks']):
+                cur_binary_mask = coco_mask.decode(mask)
+                dict_det[cur_img_name].append([
+                    score, self.dataset_meta['classes'][label],
+                    cur_binary_mask, bbox
+                ])
+            dict_det[cur_img_name].sort(
+                key=lambda x: (-x[0], x[3][0], x[3][1])
+            )  # rank by confidence from high to low, avoid same confidence
+            prog_bar.update()
+        print_log('\ncomputing occluded mask recall...', logger='current')
+        occluded_correct_num, occluded_recall = self.compute_recall(
+            dict_det, gt_ann=self.occluded_ann, is_occ=True)
+        print_log(
+            f'\nCOCO occluded mask recall: {occluded_recall:.2f}%',
+            logger='current')
+        print_log(
+            f'COCO occluded mask success num: {occluded_correct_num}',
+            logger='current')
+        print_log('computing separated mask recall...', logger='current')
+        separated_correct_num, separated_recall = self.compute_recall(
+            dict_det, gt_ann=self.separated_ann, is_occ=False)
+        print_log(
+            f'\nCOCO separated mask recall: {separated_recall:.2f}%',
+            logger='current')
+        print_log(
+            f'COCO separated mask success num: {separated_correct_num}',
+            logger='current')
+        table_data = [
+            ['mask type', 'recall', 'num correct'],
+            ['occluded', f'{occluded_recall:.2f}%', occluded_correct_num],
+            ['separated', f'{separated_recall:.2f}%', separated_correct_num]
+        ]
+        table = AsciiTable(table_data)
+        print_log('\n' + table.table, logger='current')
+        return dict(
+            occluded_recall=occluded_recall, separated_recall=separated_recall)
+
+    def compute_recall(self,
+                       result_dict: dict,
+                       gt_ann: list,
+                       is_occ: bool = True) -> tuple:
+        """Compute the recall of occluded or separated masks.
+
+        Args:
+            result_dict (dict): Processed mask results.
+            gt_ann (list): Occluded or separated coco annotations.
+            is_occ (bool): Whether the annotation is occluded mask.
+                Defaults to True.
+        Returns:
+            tuple: number of correct masks and the recall.
+        """
+        correct = 0
+        prog_bar = mmengine.ProgressBar(len(gt_ann))
+        for iter_i in range(len(gt_ann)):
+            cur_item = gt_ann[iter_i]
+            cur_img_name = cur_item[0]
+            cur_gt_bbox = cur_item[3]
+            if is_occ:
+                cur_gt_bbox = [
+                    cur_gt_bbox[0], cur_gt_bbox[1],
+                    cur_gt_bbox[0] + cur_gt_bbox[2],
+                    cur_gt_bbox[1] + cur_gt_bbox[3]
+                ]
+            cur_gt_class = cur_item[1]
+            cur_gt_mask = coco_mask.decode(cur_item[4])
+
+            assert cur_img_name in result_dict.keys()
+            cur_detections = result_dict[cur_img_name]
+
+            correct_flag = False
+            for i in range(len(cur_detections)):
+                cur_det_confidence = cur_detections[i][0]
+                if cur_det_confidence < self.score_thr:
+                    break
+                cur_det_class = cur_detections[i][1]
+                if cur_det_class != cur_gt_class:
+                    continue
+                cur_det_mask = cur_detections[i][2]
+                cur_iou = self.mask_iou(cur_det_mask, cur_gt_mask)
+                if cur_iou >= self.iou_thr:
+                    correct_flag = True
+                    break
+            if correct_flag:
+                correct += 1
+            prog_bar.update()
+        recall = correct / len(gt_ann) * 100
+        return correct, recall
+
+    def mask_iou(self, mask1: np.ndarray, mask2: np.ndarray) -> np.ndarray:
+        """Compute IoU between two masks."""
+        mask1_area = np.count_nonzero(mask1 == 1)
+        mask2_area = np.count_nonzero(mask2 == 1)
+        intersection = np.count_nonzero(np.logical_and(mask1 == 1, mask2 == 1))
+        iou = intersection / (mask1_area + mask2_area - intersection)
+        return iou
diff --git a/mmdetection/mmdet/evaluation/metrics/coco_panoptic_metric.py b/mmdetection/mmdet/evaluation/metrics/coco_panoptic_metric.py
new file mode 100644
index 00000000..f86be916
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/coco_panoptic_metric.py
@@ -0,0 +1,618 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import datetime
+import itertools
+import os.path as osp
+import tempfile
+from typing import Dict, Optional, Sequence, Tuple, Union
+
+import mmcv
+import numpy as np
+from mmengine.evaluator import BaseMetric
+from mmengine.fileio import dump, get_local_path, load
+from mmengine.logging import MMLogger, print_log
+from terminaltables import AsciiTable
+
+from mmdet.datasets.api_wrappers import COCOPanoptic
+from mmdet.registry import METRICS
+from ..functional import (INSTANCE_OFFSET, pq_compute_multi_core,
+                          pq_compute_single_core)
+
+try:
+    import panopticapi
+    from panopticapi.evaluation import VOID, PQStat
+    from panopticapi.utils import id2rgb, rgb2id
+except ImportError:
+    panopticapi = None
+    id2rgb = None
+    rgb2id = None
+    VOID = None
+    PQStat = None
+
+
+@METRICS.register_module()
+class CocoPanopticMetric(BaseMetric):
+    """COCO panoptic segmentation evaluation metric.
+
+    Evaluate PQ, SQ RQ for panoptic segmentation tasks. Please refer to
+    https://cocodataset.org/#panoptic-eval for more details.
+
+    Args:
+        ann_file (str, optional): Path to the coco format annotation file.
+            If not specified, ground truth annotations from the dataset will
+            be converted to coco format. Defaults to None.
+        seg_prefix (str, optional): Path to the directory which contains the
+            coco panoptic segmentation mask. It should be specified when
+            evaluate. Defaults to None.
+        classwise (bool): Whether to evaluate the metric class-wise.
+            Defaults to False.
+        outfile_prefix (str, optional): The prefix of json files. It includes
+            the file path and the prefix of filename, e.g., "a/b/prefix".
+            If not specified, a temp file will be created.
+            It should be specified when format_only is True. Defaults to None.
+        format_only (bool): Format the output results without perform
+            evaluation. It is useful when you want to format the result
+            to a specific format and submit it to the test server.
+            Defaults to False.
+        nproc (int): Number of processes for panoptic quality computing.
+            Defaults to 32. When ``nproc`` exceeds the number of cpu cores,
+            the number of cpu cores is used.
+        file_client_args (dict, optional): Arguments to instantiate the
+            corresponding backend in mmdet <= 3.0.0rc6. Defaults to None.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+        collect_device (str): Device name used for collecting results from
+            different ranks during distributed training. Must be 'cpu' or
+            'gpu'. Defaults to 'cpu'.
+        prefix (str, optional): The prefix that will be added in the metric
+            names to disambiguate homonymous metrics of different evaluators.
+            If prefix is not provided in the argument, self.default_prefix
+            will be used instead. Defaults to None.
+    """
+    default_prefix: Optional[str] = 'coco_panoptic'
+
+    def __init__(self,
+                 ann_file: Optional[str] = None,
+                 seg_prefix: Optional[str] = None,
+                 classwise: bool = False,
+                 format_only: bool = False,
+                 outfile_prefix: Optional[str] = None,
+                 nproc: int = 32,
+                 file_client_args: dict = None,
+                 backend_args: dict = None,
+                 collect_device: str = 'cpu',
+                 prefix: Optional[str] = None) -> None:
+        if panopticapi is None:
+            raise RuntimeError(
+                'panopticapi is not installed, please install it by: '
+                'pip install git+https://github.com/cocodataset/'
+                'panopticapi.git.')
+
+        super().__init__(collect_device=collect_device, prefix=prefix)
+        self.classwise = classwise
+        self.format_only = format_only
+        if self.format_only:
+            assert outfile_prefix is not None, 'outfile_prefix must be not'
+            'None when format_only is True, otherwise the result files will'
+            'be saved to a temp directory which will be cleaned up at the end.'
+
+        self.tmp_dir = None
+        # outfile_prefix should be a prefix of a path which points to a shared
+        # storage when train or test with multi nodes.
+        self.outfile_prefix = outfile_prefix
+        if outfile_prefix is None:
+            self.tmp_dir = tempfile.TemporaryDirectory()
+            self.outfile_prefix = osp.join(self.tmp_dir.name, 'results')
+        # the directory to save predicted panoptic segmentation mask
+        self.seg_out_dir = f'{self.outfile_prefix}.panoptic'
+        self.nproc = nproc
+        self.seg_prefix = seg_prefix
+
+        self.cat_ids = None
+        self.cat2label = None
+
+        self.backend_args = backend_args
+        if file_client_args is not None:
+            raise RuntimeError(
+                'The `file_client_args` is deprecated, '
+                'please use `backend_args` instead, please refer to'
+                'https://github.com/open-mmlab/mmdetection/blob/main/configs/_base_/datasets/coco_detection.py'  # noqa: E501
+            )
+
+        if ann_file:
+            with get_local_path(
+                    ann_file, backend_args=self.backend_args) as local_path:
+                self._coco_api = COCOPanoptic(local_path)
+            self.categories = self._coco_api.cats
+        else:
+            self._coco_api = None
+            self.categories = None
+
+    def __del__(self) -> None:
+        """Clean up."""
+        if self.tmp_dir is not None:
+            self.tmp_dir.cleanup()
+
+    def gt_to_coco_json(self, gt_dicts: Sequence[dict],
+                        outfile_prefix: str) -> Tuple[str, str]:
+        """Convert ground truth to coco panoptic segmentation format json file.
+
+        Args:
+            gt_dicts (Sequence[dict]): Ground truth of the dataset.
+            outfile_prefix (str): The filename prefix of the json file. If the
+                prefix is "somepath/xxx", the json file will be named
+                "somepath/xxx.gt.json".
+
+        Returns:
+            Tuple[str, str]: The filename of the json file and the name of the\
+                directory which contains panoptic segmentation masks.
+        """
+        assert len(gt_dicts) > 0, 'gt_dicts is empty.'
+        gt_folder = osp.dirname(gt_dicts[0]['seg_map_path'])
+        converted_json_path = f'{outfile_prefix}.gt.json'
+
+        categories = []
+        for id, name in enumerate(self.dataset_meta['classes']):
+            isthing = 1 if name in self.dataset_meta['thing_classes'] else 0
+            categories.append({'id': id, 'name': name, 'isthing': isthing})
+
+        image_infos = []
+        annotations = []
+        for gt_dict in gt_dicts:
+            img_id = gt_dict['image_id']
+            image_info = {
+                'id': img_id,
+                'width': gt_dict['width'],
+                'height': gt_dict['height'],
+                'file_name': osp.split(gt_dict['seg_map_path'])[-1]
+            }
+            image_infos.append(image_info)
+
+            pan_png = mmcv.imread(gt_dict['seg_map_path']).squeeze()
+            pan_png = pan_png[:, :, ::-1]
+            pan_png = rgb2id(pan_png)
+            segments_info = []
+            for segment_info in gt_dict['segments_info']:
+                id = segment_info['id']
+                label = segment_info['category']
+                mask = pan_png == id
+                isthing = categories[label]['isthing']
+                if isthing:
+                    iscrowd = 1 if not segment_info['is_thing'] else 0
+                else:
+                    iscrowd = 0
+
+                new_segment_info = {
+                    'id': id,
+                    'category_id': label,
+                    'isthing': isthing,
+                    'iscrowd': iscrowd,
+                    'area': mask.sum()
+                }
+                segments_info.append(new_segment_info)
+
+            segm_file = image_info['file_name'].replace('.jpg', '.png')
+            annotation = dict(
+                image_id=img_id,
+                segments_info=segments_info,
+                file_name=segm_file)
+            annotations.append(annotation)
+            pan_png = id2rgb(pan_png)
+
+        info = dict(
+            date_created=str(datetime.datetime.now()),
+            description='Coco json file converted by mmdet CocoPanopticMetric.'
+        )
+        coco_json = dict(
+            info=info,
+            images=image_infos,
+            categories=categories,
+            licenses=None,
+        )
+        if len(annotations) > 0:
+            coco_json['annotations'] = annotations
+        dump(coco_json, converted_json_path)
+        return converted_json_path, gt_folder
+
+    def result2json(self, results: Sequence[dict],
+                    outfile_prefix: str) -> Tuple[str, str]:
+        """Dump the panoptic results to a COCO style json file and a directory.
+
+        Args:
+            results (Sequence[dict]): Testing results of the dataset.
+            outfile_prefix (str): The filename prefix of the json files and the
+                directory.
+
+        Returns:
+            Tuple[str, str]: The json file and the directory which contains \
+                panoptic segmentation masks. The filename of the json is
+                "somepath/xxx.panoptic.json" and name of the directory is
+                "somepath/xxx.panoptic".
+        """
+        label2cat = dict((v, k) for (k, v) in self.cat2label.items())
+        pred_annotations = []
+        for idx in range(len(results)):
+            result = results[idx]
+            for segment_info in result['segments_info']:
+                sem_label = segment_info['category_id']
+                # convert sem_label to json label
+                cat_id = label2cat[sem_label]
+                segment_info['category_id'] = label2cat[sem_label]
+                is_thing = self.categories[cat_id]['isthing']
+                segment_info['isthing'] = is_thing
+            pred_annotations.append(result)
+        pan_json_results = dict(annotations=pred_annotations)
+        json_filename = f'{outfile_prefix}.panoptic.json'
+        dump(pan_json_results, json_filename)
+        return json_filename, (
+            self.seg_out_dir
+            if self.tmp_dir is None else tempfile.gettempdir())
+
+    def _parse_predictions(self,
+                           pred: dict,
+                           img_id: int,
+                           segm_file: str,
+                           label2cat=None) -> dict:
+        """Parse panoptic segmentation predictions.
+
+        Args:
+            pred (dict): Panoptic segmentation predictions.
+            img_id (int): Image id.
+            segm_file (str): Segmentation file name.
+            label2cat (dict): Mapping from label to category id.
+                Defaults to None.
+
+        Returns:
+            dict: Parsed predictions.
+        """
+        result = dict()
+        result['img_id'] = img_id
+        # shape (1, H, W) -> (H, W)
+        pan = pred['pred_panoptic_seg']['sem_seg'].cpu().numpy()[0]
+        ignore_index = pred['pred_panoptic_seg'].get(
+            'ignore_index', len(self.dataset_meta['classes']))
+        pan_labels = np.unique(pan)
+        segments_info = []
+        for pan_label in pan_labels:
+            sem_label = pan_label % INSTANCE_OFFSET
+            # We reserve the length of dataset_meta['classes']
+            # and ignore_index for VOID label
+            if sem_label == len(
+                    self.dataset_meta['classes']) or sem_label == ignore_index:
+                continue
+            mask = pan == pan_label
+            area = mask.sum()
+            segments_info.append({
+                'id':
+                int(pan_label),
+                # when ann_file provided, sem_label should be cat_id, otherwise
+                # sem_label should be a continuous id, not the cat_id
+                # defined in dataset
+                'category_id':
+                label2cat[sem_label] if label2cat else sem_label,
+                'area':
+                int(area)
+            })
+        # evaluation script uses 0 for VOID label.
+        pan[pan % INSTANCE_OFFSET == len(self.dataset_meta['classes'])] = VOID
+        pan[pan % INSTANCE_OFFSET == ignore_index] = VOID
+
+        pan = id2rgb(pan).astype(np.uint8)
+        mmcv.imwrite(pan[:, :, ::-1], osp.join(self.seg_out_dir, segm_file))
+        result = {
+            'image_id': img_id,
+            'segments_info': segments_info,
+            'file_name': segm_file
+        }
+
+        return result
+
+    def _compute_batch_pq_stats(self, data_samples: Sequence[dict]):
+        """Process gts and predictions when ``outfile_prefix`` is not set, gts
+        are from dataset or a json file which is defined by ``ann_file``.
+
+        Intermediate results, ``pq_stats``, are computed here and put into
+        ``self.results``.
+        """
+        if self._coco_api is None:
+            categories = dict()
+            for id, name in enumerate(self.dataset_meta['classes']):
+                isthing = 1 if name in self.dataset_meta['thing_classes']\
+                    else 0
+                categories[id] = {'id': id, 'name': name, 'isthing': isthing}
+            label2cat = None
+        else:
+            categories = self.categories
+            cat_ids = self._coco_api.get_cat_ids(
+                cat_names=self.dataset_meta['classes'])
+            label2cat = {i: cat_id for i, cat_id in enumerate(cat_ids)}
+
+        for data_sample in data_samples:
+            # parse pred
+            img_id = data_sample['img_id']
+            segm_file = osp.basename(data_sample['img_path']).replace(
+                '.jpg', '.png')
+            result = self._parse_predictions(
+                pred=data_sample,
+                img_id=img_id,
+                segm_file=segm_file,
+                label2cat=label2cat)
+
+            # parse gt
+            gt = dict()
+            gt['image_id'] = img_id
+            gt['width'] = data_sample['ori_shape'][1]
+            gt['height'] = data_sample['ori_shape'][0]
+            gt['file_name'] = segm_file
+
+            if self._coco_api is None:
+                # get segments_info from data_sample
+                seg_map_path = osp.join(self.seg_prefix, segm_file)
+                pan_png = mmcv.imread(seg_map_path).squeeze()
+                pan_png = pan_png[:, :, ::-1]
+                pan_png = rgb2id(pan_png)
+                segments_info = []
+
+                for segment_info in data_sample['segments_info']:
+                    id = segment_info['id']
+                    label = segment_info['category']
+                    mask = pan_png == id
+                    isthing = categories[label]['isthing']
+                    if isthing:
+                        iscrowd = 1 if not segment_info['is_thing'] else 0
+                    else:
+                        iscrowd = 0
+
+                    new_segment_info = {
+                        'id': id,
+                        'category_id': label,
+                        'isthing': isthing,
+                        'iscrowd': iscrowd,
+                        'area': mask.sum()
+                    }
+                    segments_info.append(new_segment_info)
+            else:
+                # get segments_info from annotation file
+                segments_info = self._coco_api.imgToAnns[img_id]
+
+            gt['segments_info'] = segments_info
+
+            pq_stats = pq_compute_single_core(
+                proc_id=0,
+                annotation_set=[(gt, result)],
+                gt_folder=self.seg_prefix,
+                pred_folder=self.seg_out_dir,
+                categories=categories,
+                backend_args=self.backend_args)
+
+            self.results.append(pq_stats)
+
+    def _process_gt_and_predictions(self, data_samples: Sequence[dict]):
+        """Process gts and predictions when ``outfile_prefix`` is set.
+
+        The predictions will be saved to directory specified by
+        ``outfile_predfix``. The matched pair (gt, result) will be put into
+        ``self.results``.
+        """
+        for data_sample in data_samples:
+            # parse pred
+            img_id = data_sample['img_id']
+            segm_file = osp.basename(data_sample['img_path']).replace(
+                '.jpg', '.png')
+            result = self._parse_predictions(
+                pred=data_sample, img_id=img_id, segm_file=segm_file)
+
+            # parse gt
+            gt = dict()
+            gt['image_id'] = img_id
+            gt['width'] = data_sample['ori_shape'][1]
+            gt['height'] = data_sample['ori_shape'][0]
+
+            if self._coco_api is None:
+                # get segments_info from dataset
+                gt['segments_info'] = data_sample['segments_info']
+                gt['seg_map_path'] = data_sample['seg_map_path']
+
+            self.results.append((gt, result))
+
+    # TODO: data_batch is no longer needed, consider adjusting the
+    #  parameter position
+    def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
+        """Process one batch of data samples and predictions. The processed
+        results should be stored in ``self.results``, which will be used to
+        compute the metrics when all batches have been processed.
+
+        Args:
+            data_batch (dict): A batch of data from the dataloader.
+            data_samples (Sequence[dict]): A batch of data samples that
+                contain annotations and predictions.
+        """
+        # If ``self.tmp_dir`` is none, it will save gt and predictions to
+        # self.results, otherwise, it will compute pq_stats here.
+        if self.tmp_dir is None:
+            self._process_gt_and_predictions(data_samples)
+        else:
+            self._compute_batch_pq_stats(data_samples)
+
+    def compute_metrics(self, results: list) -> Dict[str, float]:
+        """Compute the metrics from processed results.
+
+        Args:
+            results (list): The processed results of each batch. There
+                are two cases:
+
+                - When ``outfile_prefix`` is not provided, the elements in
+                  results are pq_stats which can be summed directly to get PQ.
+                - When ``outfile_prefix`` is provided, the elements in
+                  results are tuples like (gt, pred).
+
+        Returns:
+            Dict[str, float]: The computed metrics. The keys are the names of
+                the metrics, and the values are corresponding results.
+        """
+        logger: MMLogger = MMLogger.get_current_instance()
+
+        if self.tmp_dir is None:
+            # do evaluation after collect all the results
+
+            # split gt and prediction list
+            gts, preds = zip(*results)
+
+            if self._coco_api is None:
+                # use converted gt json file to initialize coco api
+                logger.info('Converting ground truth to coco format...')
+                coco_json_path, gt_folder = self.gt_to_coco_json(
+                    gt_dicts=gts, outfile_prefix=self.outfile_prefix)
+                self._coco_api = COCOPanoptic(coco_json_path)
+            else:
+                gt_folder = self.seg_prefix
+
+            self.cat_ids = self._coco_api.get_cat_ids(
+                cat_names=self.dataset_meta['classes'])
+            self.cat2label = {
+                cat_id: i
+                for i, cat_id in enumerate(self.cat_ids)
+            }
+            self.img_ids = self._coco_api.get_img_ids()
+            self.categories = self._coco_api.cats
+
+            # convert predictions to coco format and dump to json file
+            json_filename, pred_folder = self.result2json(
+                results=preds, outfile_prefix=self.outfile_prefix)
+
+            if self.format_only:
+                logger.info('results are saved in '
+                            f'{osp.dirname(self.outfile_prefix)}')
+                return dict()
+
+            imgs = self._coco_api.imgs
+            gt_json = self._coco_api.img_ann_map
+            gt_json = [{
+                'image_id': k,
+                'segments_info': v,
+                'file_name': imgs[k]['segm_file']
+            } for k, v in gt_json.items()]
+            pred_json = load(json_filename)
+            pred_json = dict(
+                (el['image_id'], el) for el in pred_json['annotations'])
+
+            # match the gt_anns and pred_anns in the same image
+            matched_annotations_list = []
+            for gt_ann in gt_json:
+                img_id = gt_ann['image_id']
+                if img_id not in pred_json.keys():
+                    raise Exception('no prediction for the image'
+                                    ' with id: {}'.format(img_id))
+                matched_annotations_list.append((gt_ann, pred_json[img_id]))
+
+            pq_stat = pq_compute_multi_core(
+                matched_annotations_list,
+                gt_folder,
+                pred_folder,
+                self.categories,
+                backend_args=self.backend_args,
+                nproc=self.nproc)
+
+        else:
+            # aggregate the results generated in process
+            if self._coco_api is None:
+                categories = dict()
+                for id, name in enumerate(self.dataset_meta['classes']):
+                    isthing = 1 if name in self.dataset_meta[
+                        'thing_classes'] else 0
+                    categories[id] = {
+                        'id': id,
+                        'name': name,
+                        'isthing': isthing
+                    }
+                self.categories = categories
+
+            pq_stat = PQStat()
+            for result in results:
+                pq_stat += result
+
+        metrics = [('All', None), ('Things', True), ('Stuff', False)]
+        pq_results = {}
+
+        for name, isthing in metrics:
+            pq_results[name], classwise_results = pq_stat.pq_average(
+                self.categories, isthing=isthing)
+            if name == 'All':
+                pq_results['classwise'] = classwise_results
+
+        classwise_results = None
+        if self.classwise:
+            classwise_results = {
+                k: v
+                for k, v in zip(self.dataset_meta['classes'],
+                                pq_results['classwise'].values())
+            }
+
+        print_panoptic_table(pq_results, classwise_results, logger=logger)
+        results = parse_pq_results(pq_results)
+
+        return results
+
+
+def parse_pq_results(pq_results: dict) -> dict:
+    """Parse the Panoptic Quality results.
+
+    Args:
+        pq_results (dict): Panoptic Quality results.
+
+    Returns:
+        dict: Panoptic Quality results parsed.
+    """
+    result = dict()
+    result['PQ'] = 100 * pq_results['All']['pq']
+    result['SQ'] = 100 * pq_results['All']['sq']
+    result['RQ'] = 100 * pq_results['All']['rq']
+    result['PQ_th'] = 100 * pq_results['Things']['pq']
+    result['SQ_th'] = 100 * pq_results['Things']['sq']
+    result['RQ_th'] = 100 * pq_results['Things']['rq']
+    result['PQ_st'] = 100 * pq_results['Stuff']['pq']
+    result['SQ_st'] = 100 * pq_results['Stuff']['sq']
+    result['RQ_st'] = 100 * pq_results['Stuff']['rq']
+    return result
+
+
+def print_panoptic_table(
+        pq_results: dict,
+        classwise_results: Optional[dict] = None,
+        logger: Optional[Union['MMLogger', str]] = None) -> None:
+    """Print the panoptic evaluation results table.
+
+    Args:
+        pq_results(dict): The Panoptic Quality results.
+        classwise_results(dict, optional): The classwise Panoptic Quality.
+            results. The keys are class names and the values are metrics.
+            Defaults to None.
+        logger (:obj:`MMLogger` | str, optional): Logger used for printing
+            related information during evaluation. Default: None.
+    """
+
+    headers = ['', 'PQ', 'SQ', 'RQ', 'categories']
+    data = [headers]
+    for name in ['All', 'Things', 'Stuff']:
+        numbers = [
+            f'{(pq_results[name][k] * 100):0.3f}' for k in ['pq', 'sq', 'rq']
+        ]
+        row = [name] + numbers + [pq_results[name]['n']]
+        data.append(row)
+    table = AsciiTable(data)
+    print_log('Panoptic Evaluation Results:\n' + table.table, logger=logger)
+
+    if classwise_results is not None:
+        class_metrics = [(name, ) + tuple(f'{(metrics[k] * 100):0.3f}'
+                                          for k in ['pq', 'sq', 'rq'])
+                         for name, metrics in classwise_results.items()]
+        num_columns = min(8, len(class_metrics) * 4)
+        results_flatten = list(itertools.chain(*class_metrics))
+        headers = ['category', 'PQ', 'SQ', 'RQ'] * (num_columns // 4)
+        results_2d = itertools.zip_longest(
+            *[results_flatten[i::num_columns] for i in range(num_columns)])
+        data = [headers]
+        data += [result for result in results_2d]
+        table = AsciiTable(data)
+        print_log(
+            'Classwise Panoptic Evaluation Results:\n' + table.table,
+            logger=logger)
diff --git a/mmdetection/mmdet/evaluation/metrics/coco_video_metric.py b/mmdetection/mmdet/evaluation/metrics/coco_video_metric.py
new file mode 100644
index 00000000..b5c75d02
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/coco_video_metric.py
@@ -0,0 +1,80 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+from typing import Sequence
+
+from mmengine.dist import broadcast_object_list, is_main_process
+
+from mmdet.registry import METRICS
+from .base_video_metric import collect_tracking_results
+from .coco_metric import CocoMetric
+
+
+@METRICS.register_module()
+class CocoVideoMetric(CocoMetric):
+    """COCO evaluation metric.
+
+    Evaluate AR, AP, and mAP for detection tasks including proposal/box
+    detection and instance segmentation. Please refer to
+    https://cocodataset.org/#detection-eval for more details.
+    """
+
+    def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
+        """Process one batch of data samples and predictions.
+
+        The processed results should be stored in ``self.results``, which will
+        be used to compute the metrics when all batches have been processed.
+
+        Args:
+            data_batch (dict): A batch of data from the dataloader.
+            data_samples (Sequence[dict]): A batch of data samples that
+                contain annotations and predictions.
+        """
+        for track_data_sample in data_samples:
+            video_data_samples = track_data_sample['video_data_samples']
+            ori_video_len = video_data_samples[0].ori_video_length
+            video_len = len(video_data_samples)
+            if ori_video_len == video_len:
+                # video process
+                for frame_id in range(video_len):
+                    img_data_sample = video_data_samples[frame_id].to_dict()
+                    super().process(None, [img_data_sample])
+            else:
+                # image process
+                img_data_sample = video_data_samples[0].to_dict()
+                super().process(None, [img_data_sample])
+
+    def evaluate(self, size: int = 1) -> dict:
+        """Evaluate the model performance of the whole dataset after processing
+        all batches.
+
+        Args:
+            size (int): Length of the entire validation dataset.
+        Returns:
+            dict: Evaluation metrics dict on the val dataset. The keys are the
+            names of the metrics, and the values are corresponding results.
+        """
+        if len(self.results) == 0:
+            warnings.warn(
+                f'{self.__class__.__name__} got empty `self.results`. Please '
+                'ensure that the processed results are properly added into '
+                '`self.results` in `process` method.')
+
+        results = collect_tracking_results(self.results, self.collect_device)
+
+        if is_main_process():
+            _metrics = self.compute_metrics(results)  # type: ignore
+            # Add prefix to metric names
+            if self.prefix:
+                _metrics = {
+                    '/'.join((self.prefix, k)): v
+                    for k, v in _metrics.items()
+                }
+            metrics = [_metrics]
+        else:
+            metrics = [None]  # type: ignore
+
+        broadcast_object_list(metrics)
+
+        # reset the results list
+        self.results.clear()
+        return metrics[0]
diff --git a/mmdetection/mmdet/evaluation/metrics/crowdhuman_metric.py b/mmdetection/mmdet/evaluation/metrics/crowdhuman_metric.py
new file mode 100644
index 00000000..50ac210a
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/crowdhuman_metric.py
@@ -0,0 +1,824 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import json
+import os.path as osp
+import tempfile
+from collections import OrderedDict
+from multiprocessing import Process, Queue
+from typing import Dict, List, Optional, Sequence, Union
+
+import numpy as np
+from mmengine.evaluator import BaseMetric
+from mmengine.fileio import dump, get_text, load
+from mmengine.logging import MMLogger
+from scipy.sparse import csr_matrix
+from scipy.sparse.csgraph import maximum_bipartite_matching
+
+from mmdet.evaluation.functional.bbox_overlaps import bbox_overlaps
+from mmdet.registry import METRICS
+
+PERSON_CLASSES = ['background', 'person']
+
+
+@METRICS.register_module()
+class CrowdHumanMetric(BaseMetric):
+    """CrowdHuman evaluation metric.
+
+    Evaluate Average Precision (AP), Miss Rate (MR) and Jaccard Index (JI)
+    for detection tasks.
+
+    Args:
+        ann_file (str): Path to the annotation file.
+        metric (str | List[str]): Metrics to be evaluated. Valid metrics
+            include 'AP', 'MR' and 'JI'. Defaults to 'AP'.
+        format_only (bool): Format the output results without perform
+            evaluation. It is useful when you want to format the result
+            to a specific format and submit it to the test server.
+            Defaults to False.
+        outfile_prefix (str, optional): The prefix of json files. It includes
+            the file path and the prefix of filename, e.g., "a/b/prefix".
+            If not specified, a temp file will be created. Defaults to None.
+        file_client_args (dict, optional): Arguments to instantiate the
+            corresponding backend in mmdet <= 3.0.0rc6. Defaults to None.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+        collect_device (str): Device name used for collecting results from
+            different ranks during distributed training. Must be 'cpu' or
+            'gpu'. Defaults to 'cpu'.
+        prefix (str, optional): The prefix that will be added in the metric
+            names to disambiguate homonymous metrics of different evaluators.
+            If prefix is not provided in the argument, self.default_prefix
+            will be used instead. Defaults to None.
+        eval_mode (int): Select the mode of evaluate. Valid mode include
+            0(just body box), 1(just head box) and 2(both of them).
+            Defaults to 0.
+        iou_thres (float): IoU threshold. Defaults to 0.5.
+        compare_matching_method (str, optional): Matching method to compare
+            the detection results with the ground_truth when compute 'AP'
+            and 'MR'.Valid method include VOC and None(CALTECH). Default to
+            None.
+        mr_ref (str): Different parameter selection to calculate MR. Valid
+            ref include CALTECH_-2 and CALTECH_-4. Defaults to CALTECH_-2.
+        num_ji_process (int): The number of processes to evaluation JI.
+            Defaults to 10.
+    """
+    default_prefix: Optional[str] = 'crowd_human'
+
+    def __init__(self,
+                 ann_file: str,
+                 metric: Union[str, List[str]] = ['AP', 'MR', 'JI'],
+                 format_only: bool = False,
+                 outfile_prefix: Optional[str] = None,
+                 file_client_args: dict = None,
+                 backend_args: dict = None,
+                 collect_device: str = 'cpu',
+                 prefix: Optional[str] = None,
+                 eval_mode: int = 0,
+                 iou_thres: float = 0.5,
+                 compare_matching_method: Optional[str] = None,
+                 mr_ref: str = 'CALTECH_-2',
+                 num_ji_process: int = 10) -> None:
+        super().__init__(collect_device=collect_device, prefix=prefix)
+
+        self.ann_file = ann_file
+        # crowdhuman evaluation metrics
+        self.metrics = metric if isinstance(metric, list) else [metric]
+        allowed_metrics = ['MR', 'AP', 'JI']
+        for metric in self.metrics:
+            if metric not in allowed_metrics:
+                raise KeyError(f"metric should be one of 'MR', 'AP', 'JI',"
+                               f'but got {metric}.')
+
+        self.format_only = format_only
+        if self.format_only:
+            assert outfile_prefix is not None, 'outfile_prefix must be not'
+            'None when format_only is True, otherwise the result files will'
+            'be saved to a temp directory which will be cleaned up at the end.'
+        self.outfile_prefix = outfile_prefix
+        self.backend_args = backend_args
+        if file_client_args is not None:
+            raise RuntimeError(
+                'The `file_client_args` is deprecated, '
+                'please use `backend_args` instead, please refer to'
+                'https://github.com/open-mmlab/mmdetection/blob/main/configs/_base_/datasets/coco_detection.py'  # noqa: E501
+            )
+
+        assert eval_mode in [0, 1, 2], \
+            "Unknown eval mode. mr_ref should be one of '0', '1', '2'."
+        assert compare_matching_method is None or \
+               compare_matching_method == 'VOC', \
+               'The alternative compare_matching_method is VOC.' \
+               'This parameter defaults to CALTECH(None)'
+        assert mr_ref == 'CALTECH_-2' or mr_ref == 'CALTECH_-4', \
+            "mr_ref should be one of 'CALTECH_-2', 'CALTECH_-4'."
+        self.eval_mode = eval_mode
+        self.iou_thres = iou_thres
+        self.compare_matching_method = compare_matching_method
+        self.mr_ref = mr_ref
+        self.num_ji_process = num_ji_process
+
+    @staticmethod
+    def results2json(results: Sequence[dict], outfile_prefix: str) -> str:
+        """Dump the detection results to a json file."""
+        result_file_path = f'{outfile_prefix}.json'
+        bbox_json_results = []
+        for i, result in enumerate(results):
+            ann, pred = result
+            dump_dict = dict()
+            dump_dict['ID'] = ann['ID']
+            dump_dict['width'] = ann['width']
+            dump_dict['height'] = ann['height']
+            dtboxes = []
+            bboxes = pred.tolist()
+            for _, single_bbox in enumerate(bboxes):
+                temp_dict = dict()
+                x1, y1, x2, y2, score = single_bbox
+                temp_dict['box'] = [x1, y1, x2 - x1, y2 - y1]
+                temp_dict['score'] = score
+                temp_dict['tag'] = 1
+                dtboxes.append(temp_dict)
+            dump_dict['dtboxes'] = dtboxes
+            bbox_json_results.append(dump_dict)
+        dump(bbox_json_results, result_file_path)
+        return result_file_path
+
+    def process(self, data_batch: Sequence[dict],
+                data_samples: Sequence[dict]) -> None:
+        """Process one batch of data samples and predictions. The processed
+        results should be stored in ``self.results``, which will be used to
+        compute the metrics when all batches have been processed.
+
+        Args:
+            data_batch (dict): A batch of data from the dataloader.
+            data_samples (Sequence[dict]): A batch of data samples that
+                contain annotations and predictions.
+        """
+        for data_sample in data_samples:
+            ann = dict()
+            ann['ID'] = data_sample['img_id']
+            ann['width'] = data_sample['ori_shape'][1]
+            ann['height'] = data_sample['ori_shape'][0]
+            pred_bboxes = data_sample['pred_instances']['bboxes'].cpu().numpy()
+            pred_scores = data_sample['pred_instances']['scores'].cpu().numpy()
+
+            pred_bbox_scores = np.hstack(
+                [pred_bboxes, pred_scores.reshape((-1, 1))])
+
+            self.results.append((ann, pred_bbox_scores))
+
+    def compute_metrics(self, results: list) -> Dict[str, float]:
+        """Compute the metrics from processed results.
+
+        Args:
+            results (list): The processed results of each batch.
+
+        Returns:
+            eval_results(Dict[str, float]): The computed metrics.
+            The keys are the names of the metrics, and the values
+            are corresponding results.
+        """
+        logger: MMLogger = MMLogger.get_current_instance()
+
+        tmp_dir = None
+        if self.outfile_prefix is None:
+            tmp_dir = tempfile.TemporaryDirectory()
+            outfile_prefix = osp.join(tmp_dir.name, 'result')
+        else:
+            outfile_prefix = self.outfile_prefix
+
+        # convert predictions to coco format and dump to json file
+        result_file = self.results2json(results, outfile_prefix)
+        eval_results = OrderedDict()
+        if self.format_only:
+            logger.info(f'results are saved in {osp.dirname(outfile_prefix)}')
+            return eval_results
+
+        # load evaluation samples
+        eval_samples = self.load_eval_samples(result_file)
+
+        if 'AP' in self.metrics or 'MR' in self.metrics:
+            score_list = self.compare(eval_samples)
+            gt_num = sum([eval_samples[i].gt_num for i in eval_samples])
+            ign_num = sum([eval_samples[i].ign_num for i in eval_samples])
+            gt_num = gt_num - ign_num
+            img_num = len(eval_samples)
+
+        for metric in self.metrics:
+            logger.info(f'Evaluating {metric}...')
+            if metric == 'AP':
+                AP = self.eval_ap(score_list, gt_num, img_num)
+                eval_results['mAP'] = float(f'{round(AP, 4)}')
+            if metric == 'MR':
+                MR = self.eval_mr(score_list, gt_num, img_num)
+                eval_results['mMR'] = float(f'{round(MR, 4)}')
+            if metric == 'JI':
+                JI = self.eval_ji(eval_samples)
+                eval_results['JI'] = float(f'{round(JI, 4)}')
+        if tmp_dir is not None:
+            tmp_dir.cleanup()
+
+        return eval_results
+
+    def load_eval_samples(self, result_file):
+        """Load data from annotations file and detection results.
+
+        Args:
+            result_file (str): The file path of the saved detection results.
+
+        Returns:
+            Dict[Image]: The detection result packaged by Image
+        """
+        gt_str = get_text(
+            self.ann_file, backend_args=self.backend_args).strip().split('\n')
+        gt_records = [json.loads(line) for line in gt_str]
+
+        pred_records = load(result_file, backend_args=self.backend_args)
+        eval_samples = dict()
+        for gt_record, pred_record in zip(gt_records, pred_records):
+            assert gt_record['ID'] == pred_record['ID'], \
+                'please set val_dataloader.sampler.shuffle=False and try again'
+            eval_samples[pred_record['ID']] = Image(self.eval_mode)
+            eval_samples[pred_record['ID']].load(gt_record, 'box', None,
+                                                 PERSON_CLASSES, True)
+            eval_samples[pred_record['ID']].load(pred_record, 'box', None,
+                                                 PERSON_CLASSES, False)
+            eval_samples[pred_record['ID']].clip_all_boader()
+        return eval_samples
+
+    def compare(self, samples):
+        """Match the detection results with the ground_truth.
+
+        Args:
+            samples (dict[Image]): The detection result packaged by Image.
+
+        Returns:
+            score_list(list[tuple[ndarray, int, str]]): Matching result.
+            a list of tuples (dtbox, label, imgID) in the descending
+            sort of dtbox.score.
+        """
+        score_list = list()
+        for id in samples:
+            if self.compare_matching_method == 'VOC':
+                result = samples[id].compare_voc(self.iou_thres)
+            else:
+                result = samples[id].compare_caltech(self.iou_thres)
+            score_list.extend(result)
+        # In the descending sort of dtbox score.
+        score_list.sort(key=lambda x: x[0][-1], reverse=True)
+        return score_list
+
+    @staticmethod
+    def eval_ap(score_list, gt_num, img_num):
+        """Evaluate by average precision.
+
+        Args:
+            score_list(list[tuple[ndarray, int, str]]): Matching result.
+                a list of tuples (dtbox, label, imgID) in the descending
+                sort of dtbox.score.
+            gt_num(int): The number of gt boxes in the entire dataset.
+            img_num(int): The number of images in the entire dataset.
+
+        Returns:
+            ap(float): result of average precision.
+        """
+
+        # calculate general ap score
+        def _calculate_map(_recall, _precision):
+            assert len(_recall) == len(_precision)
+            area = 0
+            for k in range(1, len(_recall)):
+                delta_h = (_precision[k - 1] + _precision[k]) / 2
+                delta_w = _recall[k] - _recall[k - 1]
+                area += delta_w * delta_h
+            return area
+
+        tp, fp = 0.0, 0.0
+        rpX, rpY = list(), list()
+
+        fpn = []
+        recalln = []
+        thr = []
+        fppi = []
+        for i, item in enumerate(score_list):
+            if item[1] == 1:
+                tp += 1.0
+            elif item[1] == 0:
+                fp += 1.0
+            fn = gt_num - tp
+            recall = tp / (tp + fn)
+            precision = tp / (tp + fp)
+            rpX.append(recall)
+            rpY.append(precision)
+            fpn.append(fp)
+            recalln.append(tp)
+            thr.append(item[0][-1])
+            fppi.append(fp / img_num)
+
+        ap = _calculate_map(rpX, rpY)
+        return ap
+
+    def eval_mr(self, score_list, gt_num, img_num):
+        """Evaluate by Caltech-style log-average miss rate.
+
+        Args:
+            score_list(list[tuple[ndarray, int, str]]): Matching result.
+                a list of tuples (dtbox, label, imgID) in the descending
+                sort of dtbox.score.
+            gt_num(int): The number of gt boxes in the entire dataset.
+            img_num(int): The number of image in the entire dataset.
+
+        Returns:
+            mr(float): result of miss rate.
+        """
+
+        # find greater_than
+        def _find_gt(lst, target):
+            for idx, _item in enumerate(lst):
+                if _item >= target:
+                    return idx
+            return len(lst) - 1
+
+        if self.mr_ref == 'CALTECH_-2':
+            # CALTECH_MRREF_2: anchor points (from 10^-2 to 1) as in
+            # P.Dollar's paper
+            ref = [
+                0.0100, 0.0178, 0.03160, 0.0562, 0.1000, 0.1778, 0.3162,
+                0.5623, 1.000
+            ]
+        else:
+            # CALTECH_MRREF_4: anchor points (from 10^-4 to 1) as in
+            # S.Zhang's paper
+            ref = [
+                0.0001, 0.0003, 0.00100, 0.0032, 0.0100, 0.0316, 0.1000,
+                0.3162, 1.000
+            ]
+
+        tp, fp = 0.0, 0.0
+        fppiX, fppiY = list(), list()
+        for i, item in enumerate(score_list):
+            if item[1] == 1:
+                tp += 1.0
+            elif item[1] == 0:
+                fp += 1.0
+
+            fn = gt_num - tp
+            recall = tp / (tp + fn)
+            missrate = 1.0 - recall
+            fppi = fp / img_num
+            fppiX.append(fppi)
+            fppiY.append(missrate)
+
+        score = list()
+        for pos in ref:
+            argmin = _find_gt(fppiX, pos)
+            if argmin >= 0:
+                score.append(fppiY[argmin])
+        score = np.array(score)
+        mr = np.exp(np.log(score).mean())
+        return mr
+
+    def eval_ji(self, samples):
+        """Evaluate by JI using multi_process.
+
+        Args:
+            samples(Dict[str, Image]): The detection result packaged by Image.
+
+        Returns:
+            ji(float): result of jaccard index.
+        """
+        import math
+        res_line = []
+        res_ji = []
+        for i in range(10):
+            score_thr = 1e-1 * i
+            total = len(samples)
+            stride = math.ceil(total / self.num_ji_process)
+            result_queue = Queue(10000)
+            results, procs = [], []
+            records = list(samples.items())
+            for i in range(self.num_ji_process):
+                start = i * stride
+                end = np.min([start + stride, total])
+                sample_data = dict(records[start:end])
+                p = Process(
+                    target=self.compute_ji_with_ignore,
+                    args=(result_queue, sample_data, score_thr))
+                p.start()
+                procs.append(p)
+            for i in range(total):
+                t = result_queue.get()
+                results.append(t)
+            for p in procs:
+                p.join()
+            line, mean_ratio = self.gather(results)
+            line = 'score_thr:{:.1f}, {}'.format(score_thr, line)
+            res_line.append(line)
+            res_ji.append(mean_ratio)
+        return max(res_ji)
+
+    def compute_ji_with_ignore(self, result_queue, dt_result, score_thr):
+        """Compute JI with ignore.
+
+        Args:
+            result_queue(Queue): The Queue for save compute result when
+                multi_process.
+            dt_result(dict[Image]): Detection result packaged by Image.
+            score_thr(float): The threshold of detection score.
+        Returns:
+            dict: compute result.
+        """
+        for ID, record in dt_result.items():
+            gt_boxes = record.gt_boxes
+            dt_boxes = record.dt_boxes
+            keep = dt_boxes[:, -1] > score_thr
+            dt_boxes = dt_boxes[keep][:, :-1]
+
+            gt_tag = np.array(gt_boxes[:, -1] != -1)
+            matches = self.compute_ji_matching(dt_boxes, gt_boxes[gt_tag, :4])
+            # get the unmatched_indices
+            matched_indices = np.array([j for (j, _) in matches])
+            unmatched_indices = list(
+                set(np.arange(dt_boxes.shape[0])) - set(matched_indices))
+            num_ignore_dt = self.get_ignores(dt_boxes[unmatched_indices],
+                                             gt_boxes[~gt_tag, :4])
+            matched_indices = np.array([j for (_, j) in matches])
+            unmatched_indices = list(
+                set(np.arange(gt_boxes[gt_tag].shape[0])) -
+                set(matched_indices))
+            num_ignore_gt = self.get_ignores(
+                gt_boxes[gt_tag][unmatched_indices], gt_boxes[~gt_tag, :4])
+            # compute results
+            eps = 1e-6
+            k = len(matches)
+            m = gt_tag.sum() - num_ignore_gt
+            n = dt_boxes.shape[0] - num_ignore_dt
+            ratio = k / (m + n - k + eps)
+            recall = k / (m + eps)
+            cover = k / (n + eps)
+            noise = 1 - cover
+            result_dict = dict(
+                ratio=ratio,
+                recall=recall,
+                cover=cover,
+                noise=noise,
+                k=k,
+                m=m,
+                n=n)
+            result_queue.put_nowait(result_dict)
+
+    @staticmethod
+    def gather(results):
+        """Integrate test results."""
+        assert len(results)
+        img_num = 0
+        for result in results:
+            if result['n'] != 0 or result['m'] != 0:
+                img_num += 1
+        mean_ratio = np.sum([rb['ratio'] for rb in results]) / img_num
+        valids = np.sum([rb['k'] for rb in results])
+        total = np.sum([rb['n'] for rb in results])
+        gtn = np.sum([rb['m'] for rb in results])
+        line = 'mean_ratio:{:.4f}, valids:{}, total:{}, gtn:{}'\
+            .format(mean_ratio, valids, total, gtn)
+        return line, mean_ratio
+
+    def compute_ji_matching(self, dt_boxes, gt_boxes):
+        """Match the annotation box for each detection box.
+
+        Args:
+            dt_boxes(ndarray): Detection boxes.
+            gt_boxes(ndarray): Ground_truth boxes.
+
+        Returns:
+            matches_(list[tuple[int, int]]): Match result.
+        """
+        assert dt_boxes.shape[-1] > 3 and gt_boxes.shape[-1] > 3
+        if dt_boxes.shape[0] < 1 or gt_boxes.shape[0] < 1:
+            return list()
+
+        ious = bbox_overlaps(dt_boxes, gt_boxes, mode='iou')
+        input_ = copy.deepcopy(ious)
+        input_[input_ < self.iou_thres] = 0
+        match_scipy = maximum_bipartite_matching(
+            csr_matrix(input_), perm_type='column')
+        matches_ = []
+        for i in range(len(match_scipy)):
+            if match_scipy[i] != -1:
+                matches_.append((i, int(match_scipy[i])))
+        return matches_
+
+    def get_ignores(self, dt_boxes, gt_boxes):
+        """Get the number of ignore bboxes."""
+        if gt_boxes.size:
+            ioas = bbox_overlaps(dt_boxes, gt_boxes, mode='iof')
+            ioas = np.max(ioas, axis=1)
+            rows = np.where(ioas > self.iou_thres)[0]
+            return len(rows)
+        else:
+            return 0
+
+
+class Image(object):
+    """Data structure for evaluation of CrowdHuman.
+
+    Note:
+        This implementation is modified from https://github.com/Purkialo/
+        CrowdDet/blob/master/lib/evaluate/APMRToolkits/image.py
+
+    Args:
+        mode (int): Select the mode of evaluate. Valid mode include
+            0(just body box), 1(just head box) and 2(both of them).
+            Defaults to 0.
+    """
+
+    def __init__(self, mode):
+        self.ID = None
+        self.width = None
+        self.height = None
+        self.dt_boxes = None
+        self.gt_boxes = None
+        self.eval_mode = mode
+
+        self.ign_num = None
+        self.gt_num = None
+        self.dt_num = None
+
+    def load(self, record, body_key, head_key, class_names, gt_flag):
+        """Loading information for evaluation.
+
+        Args:
+            record (dict): Label information or test results.
+                The format might look something like this:
+                {
+                    'ID': '273271,c9db000d5146c15',
+                    'gtboxes': [
+                        {'fbox': [72, 202, 163, 503], 'tag': 'person', ...},
+                        {'fbox': [199, 180, 144, 499], 'tag': 'person', ...},
+                        ...
+                    ]
+                }
+                or:
+                {
+                    'ID': '273271,c9db000d5146c15',
+                    'width': 800,
+                    'height': 1067,
+                    'dtboxes': [
+                        {
+                            'box': [306.22, 205.95, 164.05, 394.04],
+                            'score': 0.99,
+                            'tag': 1
+                        },
+                        {
+                            'box': [403.60, 178.66, 157.15, 421.33],
+                            'score': 0.99,
+                            'tag': 1
+                        },
+                        ...
+                    ]
+                }
+            body_key (str, None): key of detection body box.
+                Valid when loading detection results and self.eval_mode!=1.
+            head_key (str, None): key of detection head box.
+                Valid when loading detection results and self.eval_mode!=0.
+            class_names (list[str]):class names of data set.
+                Defaults to ['background', 'person'].
+            gt_flag (bool): Indicate whether record is ground truth
+                or predicting the outcome.
+        """
+        if 'ID' in record and self.ID is None:
+            self.ID = record['ID']
+        if 'width' in record and self.width is None:
+            self.width = record['width']
+        if 'height' in record and self.height is None:
+            self.height = record['height']
+        if gt_flag:
+            self.gt_num = len(record['gtboxes'])
+            body_bbox, head_bbox = self.load_gt_boxes(record, 'gtboxes',
+                                                      class_names)
+            if self.eval_mode == 0:
+                self.gt_boxes = body_bbox
+                self.ign_num = (body_bbox[:, -1] == -1).sum()
+            elif self.eval_mode == 1:
+                self.gt_boxes = head_bbox
+                self.ign_num = (head_bbox[:, -1] == -1).sum()
+            else:
+                gt_tag = np.array([
+                    body_bbox[i, -1] != -1 and head_bbox[i, -1] != -1
+                    for i in range(len(body_bbox))
+                ])
+                self.ign_num = (gt_tag == 0).sum()
+                self.gt_boxes = np.hstack(
+                    (body_bbox[:, :-1], head_bbox[:, :-1],
+                     gt_tag.reshape(-1, 1)))
+
+        if not gt_flag:
+            self.dt_num = len(record['dtboxes'])
+            if self.eval_mode == 0:
+                self.dt_boxes = self.load_det_boxes(record, 'dtboxes',
+                                                    body_key, 'score')
+            elif self.eval_mode == 1:
+                self.dt_boxes = self.load_det_boxes(record, 'dtboxes',
+                                                    head_key, 'score')
+            else:
+                body_dtboxes = self.load_det_boxes(record, 'dtboxes', body_key,
+                                                   'score')
+                head_dtboxes = self.load_det_boxes(record, 'dtboxes', head_key,
+                                                   'score')
+                self.dt_boxes = np.hstack((body_dtboxes, head_dtboxes))
+
+    @staticmethod
+    def load_gt_boxes(dict_input, key_name, class_names):
+        """load ground_truth and transform [x, y, w, h] to [x1, y1, x2, y2]"""
+        assert key_name in dict_input
+        if len(dict_input[key_name]) < 1:
+            return np.empty([0, 5])
+        head_bbox = []
+        body_bbox = []
+        for rb in dict_input[key_name]:
+            if rb['tag'] in class_names:
+                body_tag = class_names.index(rb['tag'])
+                head_tag = copy.deepcopy(body_tag)
+            else:
+                body_tag = -1
+                head_tag = -1
+            if 'extra' in rb:
+                if 'ignore' in rb['extra']:
+                    if rb['extra']['ignore'] != 0:
+                        body_tag = -1
+                        head_tag = -1
+            if 'head_attr' in rb:
+                if 'ignore' in rb['head_attr']:
+                    if rb['head_attr']['ignore'] != 0:
+                        head_tag = -1
+            head_bbox.append(np.hstack((rb['hbox'], head_tag)))
+            body_bbox.append(np.hstack((rb['fbox'], body_tag)))
+        head_bbox = np.array(head_bbox)
+        head_bbox[:, 2:4] += head_bbox[:, :2]
+        body_bbox = np.array(body_bbox)
+        body_bbox[:, 2:4] += body_bbox[:, :2]
+        return body_bbox, head_bbox
+
+    @staticmethod
+    def load_det_boxes(dict_input, key_name, key_box, key_score, key_tag=None):
+        """load detection boxes."""
+        assert key_name in dict_input
+        if len(dict_input[key_name]) < 1:
+            return np.empty([0, 5])
+        else:
+            assert key_box in dict_input[key_name][0]
+            if key_score:
+                assert key_score in dict_input[key_name][0]
+            if key_tag:
+                assert key_tag in dict_input[key_name][0]
+        if key_score:
+            if key_tag:
+                bboxes = np.vstack([
+                    np.hstack((rb[key_box], rb[key_score], rb[key_tag]))
+                    for rb in dict_input[key_name]
+                ])
+            else:
+                bboxes = np.vstack([
+                    np.hstack((rb[key_box], rb[key_score]))
+                    for rb in dict_input[key_name]
+                ])
+        else:
+            if key_tag:
+                bboxes = np.vstack([
+                    np.hstack((rb[key_box], rb[key_tag]))
+                    for rb in dict_input[key_name]
+                ])
+            else:
+                bboxes = np.vstack(
+                    [rb[key_box] for rb in dict_input[key_name]])
+        bboxes[:, 2:4] += bboxes[:, :2]
+        return bboxes
+
+    def clip_all_boader(self):
+        """Make sure boxes are within the image range."""
+
+        def _clip_boundary(boxes, height, width):
+            assert boxes.shape[-1] >= 4
+            boxes[:, 0] = np.minimum(np.maximum(boxes[:, 0], 0), width - 1)
+            boxes[:, 1] = np.minimum(np.maximum(boxes[:, 1], 0), height - 1)
+            boxes[:, 2] = np.maximum(np.minimum(boxes[:, 2], width), 0)
+            boxes[:, 3] = np.maximum(np.minimum(boxes[:, 3], height), 0)
+            return boxes
+
+        assert self.dt_boxes.shape[-1] >= 4
+        assert self.gt_boxes.shape[-1] >= 4
+        assert self.width is not None and self.height is not None
+        if self.eval_mode == 2:
+            self.dt_boxes[:, :4] = _clip_boundary(self.dt_boxes[:, :4],
+                                                  self.height, self.width)
+            self.gt_boxes[:, :4] = _clip_boundary(self.gt_boxes[:, :4],
+                                                  self.height, self.width)
+            self.dt_boxes[:, 4:8] = _clip_boundary(self.dt_boxes[:, 4:8],
+                                                   self.height, self.width)
+            self.gt_boxes[:, 4:8] = _clip_boundary(self.gt_boxes[:, 4:8],
+                                                   self.height, self.width)
+        else:
+            self.dt_boxes = _clip_boundary(self.dt_boxes, self.height,
+                                           self.width)
+            self.gt_boxes = _clip_boundary(self.gt_boxes, self.height,
+                                           self.width)
+
+    def compare_voc(self, thres):
+        """Match the detection results with the ground_truth by VOC.
+
+        Args:
+            thres (float): IOU threshold.
+
+        Returns:
+            score_list(list[tuple[ndarray, int, str]]): Matching result.
+            a list of tuples (dtbox, label, imgID) in the descending
+            sort of dtbox.score.
+        """
+        if self.dt_boxes is None:
+            return list()
+        dtboxes = self.dt_boxes
+        gtboxes = self.gt_boxes if self.gt_boxes is not None else list()
+        dtboxes.sort(key=lambda x: x.score, reverse=True)
+        gtboxes.sort(key=lambda x: x.ign)
+
+        score_list = list()
+        for i, dt in enumerate(dtboxes):
+            maxpos = -1
+            maxiou = thres
+
+            for j, gt in enumerate(gtboxes):
+                overlap = dt.iou(gt)
+                if overlap > maxiou:
+                    maxiou = overlap
+                    maxpos = j
+
+            if maxpos >= 0:
+                if gtboxes[maxpos].ign == 0:
+                    gtboxes[maxpos].matched = 1
+                    dtboxes[i].matched = 1
+                    score_list.append((dt, self.ID))
+                else:
+                    dtboxes[i].matched = -1
+            else:
+                dtboxes[i].matched = 0
+                score_list.append((dt, self.ID))
+        return score_list
+
+    def compare_caltech(self, thres):
+        """Match the detection results with the ground_truth by Caltech
+        matching strategy.
+
+        Args:
+            thres (float): IOU threshold.
+
+        Returns:
+            score_list(list[tuple[ndarray, int, str]]): Matching result.
+            a list of tuples (dtbox, label, imgID) in the descending
+            sort of dtbox.score.
+        """
+        if self.dt_boxes is None or self.gt_boxes is None:
+            return list()
+
+        dtboxes = self.dt_boxes if self.dt_boxes is not None else list()
+        gtboxes = self.gt_boxes if self.gt_boxes is not None else list()
+        dt_matched = np.zeros(dtboxes.shape[0])
+        gt_matched = np.zeros(gtboxes.shape[0])
+
+        dtboxes = np.array(sorted(dtboxes, key=lambda x: x[-1], reverse=True))
+        gtboxes = np.array(sorted(gtboxes, key=lambda x: x[-1], reverse=True))
+        if len(dtboxes):
+            overlap_iou = bbox_overlaps(dtboxes, gtboxes, mode='iou')
+            overlap_ioa = bbox_overlaps(dtboxes, gtboxes, mode='iof')
+        else:
+            return list()
+
+        score_list = list()
+        for i, dt in enumerate(dtboxes):
+            maxpos = -1
+            maxiou = thres
+            for j, gt in enumerate(gtboxes):
+                if gt_matched[j] == 1:
+                    continue
+                if gt[-1] > 0:
+                    overlap = overlap_iou[i][j]
+                    if overlap > maxiou:
+                        maxiou = overlap
+                        maxpos = j
+                else:
+                    if maxpos >= 0:
+                        break
+                    else:
+                        overlap = overlap_ioa[i][j]
+                        if overlap > thres:
+                            maxiou = overlap
+                            maxpos = j
+            if maxpos >= 0:
+                if gtboxes[maxpos, -1] > 0:
+                    gt_matched[maxpos] = 1
+                    dt_matched[i] = 1
+                    score_list.append((dt, 1, self.ID))
+                else:
+                    dt_matched[i] = -1
+            else:
+                dt_matched[i] = 0
+                score_list.append((dt, 0, self.ID))
+        return score_list
diff --git a/mmdetection/mmdet/evaluation/metrics/custom_metric.py b/mmdetection/mmdet/evaluation/metrics/custom_metric.py
new file mode 100644
index 00000000..ad13bbce
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/custom_metric.py
@@ -0,0 +1,110 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Any, Optional, Sequence
+
+from mmcv.ops import batched_nms
+from mmengine.evaluator import BaseMetric
+from mmengine.logging import print_log
+
+from mmdet.registry import METRICS
+
+import os
+import pandas as pd
+from tqdm.auto import tqdm as tqdm_auto
+
+try:
+    import jsonlines
+except ImportError:
+    jsonlines = None
+
+
+@METRICS.register_module()
+class CustomResultDumping(BaseMetric):
+    default_prefix: Optional[str] = 'pl_odvg'
+
+    def __init__(self,
+                 outfile_path,
+                 img_prefix: str,
+                 classes: list,
+                 collect_device: str = 'cpu',
+                 prefix: Optional[str] = None) -> None:
+        super().__init__(collect_device=collect_device, prefix=prefix)
+        self.outfile_path = outfile_path
+        self.img_prefix = img_prefix
+        self.classes=classes
+        
+        if not os.path.exists(outfile_path):
+            os.makedirs(outfile_path)
+            print(f"Created directories for the path: {outfile_path}")
+        else:
+            print(f"Path already exists: {outfile_path}")
+
+        if jsonlines is None:
+            raise ImportError('Please run "pip install jsonlines" to install '
+                              'this package.')
+
+    def process(self, data_batch: Any, data_samples: Sequence[dict]) -> None:
+        for data_sample in data_samples:
+            result = {}
+
+            filename = data_sample['img_path']
+            filename = filename.replace(self.img_prefix, '')
+            if filename.startswith('/'):
+                filename = filename[1:]
+            result['filename'] = filename
+
+            height = data_sample['ori_shape'][0]
+            width = data_sample['ori_shape'][1]
+            result['height'] = height
+            result['width'] = width
+
+            pred_instances = data_sample['pred_instances']
+
+            pred_instances['bboxes'] = pred_instances['bboxes']
+            pred_instances['scores'] = pred_instances['scores']
+            pred_instances['labels'] = pred_instances['labels']
+
+
+            result['pred_instances'] = pred_instances
+            self.results.append(result)
+                
+
+    def compute_metrics(self, results: list) -> dict:
+        prediction_strings = []
+        file_names = []
+        
+        for result in tqdm_auto(results, desc="making csv file"):
+            prediction_string = ''
+            file_name = result['filename']
+            if 'pred_instances' in result:
+                pred_instances = result["pred_instances"]
+                if pred_instances['bboxes'].numel() > 0:
+                    bboxes = pred_instances['bboxes'].cpu().numpy()
+                    scores = pred_instances['scores'].cpu().numpy()
+                    labels = pred_instances['labels'].cpu().numpy()
+                    
+                    # 클래스별로 결과 정리
+                    class_results = [[] for _ in range(len(self.classes))]
+                    for label, score, bbox in zip(labels, scores, bboxes):
+                        class_results[label].append((score, bbox))
+                    
+                    # Pascal VOC 형식으로 문자열 생성
+                    for class_id, class_result in enumerate(class_results):
+                        if class_result:  # 해당 클래스의 결과가 있는 경우만
+                            for score, bbox in class_result:
+                                prediction_string += f"{class_id} {score:.4f} {bbox[0]:.2f} {bbox[1]:.2f} {bbox[2]:.2f} {bbox[3]:.2f} "
+            
+            prediction_strings.append(prediction_string)
+            file_names.append(file_name)
+        
+        # submission 파일 생성
+        submission = pd.DataFrame()
+        submission['PredictionString'] = prediction_strings
+        submission['image_id'] = file_names
+        submission.to_csv(os.path.join(self.outfile_path, 'submission.csv'), index=None)
+        
+        
+        print(submission.head())
+        print_log(
+            f'Results has been saved to {self.outfile_path}.',
+            logger='current')
+        return {}
diff --git a/mmdetection/mmdet/evaluation/metrics/dod_metric.py b/mmdetection/mmdet/evaluation/metrics/dod_metric.py
new file mode 100644
index 00000000..b47d0721
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/dod_metric.py
@@ -0,0 +1,169 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from collections import defaultdict
+from typing import List, Optional, Sequence
+
+import numpy as np
+from mmengine.evaluator import BaseMetric
+from mmengine.fileio import get_local_path
+from mmengine.logging import MMLogger
+
+from mmdet.datasets.api_wrappers import COCO, COCOeval
+from mmdet.registry import METRICS
+
+
+@METRICS.register_module()
+class DODCocoMetric(BaseMetric):
+
+    default_prefix: Optional[str] = 'dod'
+
+    def __init__(self,
+                 ann_file: Optional[str] = None,
+                 collect_device: str = 'cpu',
+                 outfile_prefix: Optional[str] = None,
+                 backend_args: dict = None,
+                 prefix: Optional[str] = None) -> None:
+        super().__init__(collect_device=collect_device, prefix=prefix)
+        self.outfile_prefix = outfile_prefix
+        with get_local_path(ann_file, backend_args=backend_args) as local_path:
+            self._coco_api = COCO(local_path)
+
+    def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
+        for data_sample in data_samples:
+            result = dict()
+            pred = data_sample['pred_instances']
+            result['img_id'] = data_sample['img_id']
+            result['bboxes'] = pred['bboxes'].cpu().numpy()
+            result['scores'] = pred['scores'].cpu().numpy()
+
+            result['labels'] = pred['labels'].cpu().numpy()
+            result['labels'] = data_sample['sent_ids'][result['labels']]
+            self.results.append(result)
+
+    def xyxy2xywh(self, bbox: np.ndarray) -> list:
+        """Convert ``xyxy`` style bounding boxes to ``xywh`` style for COCO
+        evaluation.
+
+        Args:
+            bbox (numpy.ndarray): The bounding boxes, shape (4, ), in
+                ``xyxy`` order.
+
+        Returns:
+            list[float]: The converted bounding boxes, in ``xywh`` order.
+        """
+
+        _bbox: List = bbox.tolist()
+        return [
+            _bbox[0],
+            _bbox[1],
+            _bbox[2] - _bbox[0],
+            _bbox[3] - _bbox[1],
+        ]
+
+    def results2json(self, results: Sequence[dict]) -> list:
+        """Dump the detection results to a COCO style json file.
+
+        There are 3 types of results: proposals, bbox predictions, mask
+        predictions, and they have different data types. This method will
+        automatically recognize the type, and dump them to json files.
+
+        Args:
+            results (Sequence[dict]): Testing results of the
+                dataset.
+
+        Returns:
+            dict: Possible keys are "bbox", "segm", "proposal", and
+            values are corresponding filenames.
+        """
+        bbox_json_results = []
+        for idx, result in enumerate(results):
+            image_id = result.get('img_id', idx)
+            labels = result['labels']
+            bboxes = result['bboxes']
+            scores = result['scores']
+            for i, label in enumerate(labels):
+                data = dict()
+                data['image_id'] = image_id
+                data['bbox'] = self.xyxy2xywh(bboxes[i])
+                data['score'] = float(scores[i])
+                data['category_id'] = label
+                bbox_json_results.append(data)
+        return bbox_json_results
+
+    def compute_metrics(self, results: list) -> dict:
+        logger: MMLogger = MMLogger.get_current_instance()
+        result_files = self.results2json(results)
+        d3_res = self._coco_api.loadRes(result_files)
+        cocoEval = COCOeval(self._coco_api, d3_res, 'bbox')
+        cocoEval.evaluate()
+        cocoEval.accumulate()
+        cocoEval.summarize()
+
+        aps = cocoEval.eval['precision'][:, :, :, 0, -1]
+        category_ids = self._coco_api.getCatIds()
+        category_names = [
+            cat['name'] for cat in self._coco_api.loadCats(category_ids)
+        ]
+
+        aps_lens = defaultdict(list)
+        counter_lens = defaultdict(int)
+        for i in range(len(category_names)):
+            ap = aps[:, :, i]
+            ap_value = ap[ap > -1].mean()
+            if not np.isnan(ap_value):
+                len_ref = len(category_names[i].split(' '))
+                aps_lens[len_ref].append(ap_value)
+                counter_lens[len_ref] += 1
+
+        ap_sum_short = sum([sum(aps_lens[i]) for i in range(0, 4)])
+        ap_sum_mid = sum([sum(aps_lens[i]) for i in range(4, 7)])
+        ap_sum_long = sum([sum(aps_lens[i]) for i in range(7, 10)])
+        ap_sum_very_long = sum([
+            sum(aps_lens[i]) for i in range(10,
+                                            max(counter_lens.keys()) + 1)
+        ])
+        c_sum_short = sum([counter_lens[i] for i in range(1, 4)])
+        c_sum_mid = sum([counter_lens[i] for i in range(4, 7)])
+        c_sum_long = sum([counter_lens[i] for i in range(7, 10)])
+        c_sum_very_long = sum(
+            [counter_lens[i] for i in range(10,
+                                            max(counter_lens.keys()) + 1)])
+        map_short = ap_sum_short / c_sum_short
+        map_mid = ap_sum_mid / c_sum_mid
+        map_long = ap_sum_long / c_sum_long
+        map_very_long = ap_sum_very_long / c_sum_very_long
+
+        coco_metric_names = {
+            'mAP': 0,
+            'mAP_50': 1,
+            'mAP_75': 2,
+            'mAP_s': 3,
+            'mAP_m': 4,
+            'mAP_l': 5,
+            'AR@100': 6,
+            'AR@300': 7,
+            'AR@1000': 8,
+            'AR_s@1000': 9,
+            'AR_m@1000': 10,
+            'AR_l@1000': 11
+        }
+        metric_items = ['mAP', 'mAP_50', 'mAP_75', 'mAP_s', 'mAP_m', 'mAP_l']
+
+        eval_results = {}
+        for metric_item in metric_items:
+            key = f'{metric_item}'
+            val = cocoEval.stats[coco_metric_names[metric_item]]
+            eval_results[key] = float(f'{round(val, 3)}')
+
+        ap = cocoEval.stats[:6]
+        logger.info(f'mAP_copypaste: {ap[0]:.3f} '
+                    f'{ap[1]:.3f} {ap[2]:.3f} {ap[3]:.3f} '
+                    f'{ap[4]:.3f} {ap[5]:.3f}')
+
+        logger.info(f'mAP over reference length: short - {map_short:.4f}, '
+                    f'mid - {map_mid:.4f}, long - {map_long:.4f}, '
+                    f'very long - {map_very_long:.4f}')
+        eval_results['mAP_short'] = float(f'{round(map_short, 3)}')
+        eval_results['mAP_mid'] = float(f'{round(map_mid, 3)}')
+        eval_results['mAP_long'] = float(f'{round(map_long, 3)}')
+        eval_results['mAP_very_long'] = float(f'{round(map_very_long, 3)}')
+        return eval_results
diff --git a/mmdetection/mmdet/evaluation/metrics/dump_det_results.py b/mmdetection/mmdet/evaluation/metrics/dump_det_results.py
new file mode 100644
index 00000000..f3071d19
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/dump_det_results.py
@@ -0,0 +1,47 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+from typing import Sequence
+
+from mmengine.evaluator import DumpResults
+from mmengine.evaluator.metric import _to_cpu
+
+from mmdet.registry import METRICS
+from mmdet.structures.mask import encode_mask_results
+
+
+@METRICS.register_module()
+class DumpDetResults(DumpResults):
+    """Dump model predictions to a pickle file for offline evaluation.
+
+    Different from `DumpResults` in MMEngine, it compresses instance
+    segmentation masks into RLE format.
+
+    Args:
+        out_file_path (str): Path of the dumped file. Must end with '.pkl'
+            or '.pickle'.
+        collect_device (str): Device name used for collecting results from
+            different ranks during distributed training. Must be 'cpu' or
+            'gpu'. Defaults to 'cpu'.
+    """
+
+    def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
+        """transfer tensors in predictions to CPU."""
+        data_samples = _to_cpu(data_samples)
+        for data_sample in data_samples:
+            # remove gt
+            data_sample.pop('gt_instances', None)
+            data_sample.pop('ignored_instances', None)
+            data_sample.pop('gt_panoptic_seg', None)
+
+            if 'pred_instances' in data_sample:
+                pred = data_sample['pred_instances']
+                # encode mask to RLE
+                if 'masks' in pred:
+                    pred['masks'] = encode_mask_results(pred['masks'].numpy())
+            if 'pred_panoptic_seg' in data_sample:
+                warnings.warn(
+                    'Panoptic segmentation map will not be compressed. '
+                    'The dumped file will be extremely large! '
+                    'Suggest using `CocoPanopticMetric` to save the coco '
+                    'format json and segmentation png files directly.')
+        self.results.extend(data_samples)
diff --git a/mmdetection/mmdet/evaluation/metrics/dump_odvg_results.py b/mmdetection/mmdet/evaluation/metrics/dump_odvg_results.py
new file mode 100644
index 00000000..a1446b05
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/dump_odvg_results.py
@@ -0,0 +1,138 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Any, Optional, Sequence
+
+from mmcv.ops import batched_nms
+from mmengine.evaluator import BaseMetric
+from mmengine.logging import print_log
+
+from mmdet.registry import METRICS
+
+try:
+    import jsonlines
+except ImportError:
+    jsonlines = None
+
+
+@METRICS.register_module()
+class DumpODVGResults(BaseMetric):
+    default_prefix: Optional[str] = 'pl_odvg'
+
+    def __init__(self,
+                 outfile_path,
+                 img_prefix: str,
+                 score_thr: float = 0.1,
+                 collect_device: str = 'cpu',
+                 nms_thr: float = 0.5,
+                 prefix: Optional[str] = None) -> None:
+        super().__init__(collect_device=collect_device, prefix=prefix)
+        self.outfile_path = outfile_path
+        self.score_thr = score_thr
+        self.img_prefix = img_prefix
+        self.nms_thr = nms_thr
+
+        if jsonlines is None:
+            raise ImportError('Please run "pip install jsonlines" to install '
+                              'this package.')
+
+    def process(self, data_batch: Any, data_samples: Sequence[dict]) -> None:
+        for data_sample in data_samples:
+            result = {}
+
+            filename = data_sample['img_path']
+            filename = filename.replace(self.img_prefix, '')
+            if filename.startswith('/'):
+                filename = filename[1:]
+            result['filename'] = filename
+
+            height = data_sample['ori_shape'][0]
+            width = data_sample['ori_shape'][1]
+            result['height'] = height
+            result['width'] = width
+
+            pred_instances = data_sample['pred_instances']
+
+            bboxes = pred_instances['bboxes'].cpu()
+            scores = pred_instances['scores'].cpu()
+            labels = pred_instances['labels'].cpu()
+
+            bboxes = bboxes[scores > self.score_thr]
+            labels = labels[scores > self.score_thr]
+            scores = scores[scores > self.score_thr]
+
+            if 'tokens_positive' in data_sample:
+                task = 'vg'
+            else:
+                task = 'od'
+
+            if task == 'od':
+                classes_name = data_sample['text']
+                result['detection'] = {}
+
+                if len(bboxes) > 0:
+                    det_bboxes, keep = batched_nms(
+                        bboxes, scores, labels,
+                        dict(type='nms', iou_threshold=self.nms_thr))
+                    _scores = det_bboxes[:, -1]
+                    _bboxes = det_bboxes[:, :-1]
+                    _labels = labels[keep]
+
+                    instances = []
+                    _bboxes = _bboxes.numpy().tolist()
+                    _scores = _scores.numpy().tolist()
+                    _labels = _labels.numpy().tolist()
+                    for bbox, score, label in zip(_bboxes, _scores, _labels):
+                        round_bbox = [round(b, 2) for b in bbox]
+                        round_score = round(score, 2)
+                        instances.append({
+                            'bbox': round_bbox,
+                            'score': round_score,
+                            'label': label,
+                            'category': classes_name[label]
+                        })
+                    result['detection']['instances'] = instances
+                else:
+                    result['detection']['instances'] = []
+                self.results.append(result)
+            else:
+                caption = data_sample['text']
+                result['grounding'] = {}
+                result['grounding']['caption'] = caption
+
+                tokens_positive = data_sample['tokens_positive']
+
+                region_list = []
+                for label, positive in enumerate(tokens_positive):
+                    phrase = [caption[pos[0]:pos[1]] for pos in positive]
+
+                    _bboxes = bboxes[labels == label]
+                    _scores = scores[labels == label]
+                    det_bboxes, _ = batched_nms(
+                        _bboxes,
+                        _scores,
+                        None,
+                        dict(type='nms', iou_threshold=self.nms_thr),
+                        class_agnostic=True)
+                    _scores = det_bboxes[:, -1].numpy().tolist()
+                    _bboxes = det_bboxes[:, :-1].numpy().tolist()
+
+                    round_bboxes = []
+                    for bbox in _bboxes:
+                        round_bboxes.append([round(b, 2) for b in bbox])
+                    _scores = [[round(s, 2) for s in _scores]]
+                    region = {
+                        'phrase': phrase,
+                        'bbox': round_bboxes,
+                        'score': _scores,
+                        'tokens_positive': positive
+                    }
+                    region_list.append(region)
+                result['grounding']['regions'] = region_list
+                self.results.append(result)
+
+    def compute_metrics(self, results: list) -> dict:
+        with jsonlines.open(self.outfile_path, mode='w') as writer:
+            writer.write_all(results)
+        print_log(
+            f'Results has been saved to {self.outfile_path}.',
+            logger='current')
+        return {}
diff --git a/mmdetection/mmdet/evaluation/metrics/dump_proposals_metric.py b/mmdetection/mmdet/evaluation/metrics/dump_proposals_metric.py
new file mode 100644
index 00000000..9e9c5365
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/dump_proposals_metric.py
@@ -0,0 +1,119 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os
+import os.path as osp
+from typing import Optional, Sequence
+
+from mmengine.dist import is_main_process
+from mmengine.evaluator import BaseMetric
+from mmengine.fileio import dump
+from mmengine.logging import MMLogger
+from mmengine.structures import InstanceData
+
+from mmdet.registry import METRICS
+
+
+@METRICS.register_module()
+class DumpProposals(BaseMetric):
+    """Dump proposals pseudo metric.
+
+    Args:
+        output_dir (str): The root directory for ``proposals_file``.
+            Defaults to ''.
+        proposals_file (str): Proposals file path. Defaults to 'proposals.pkl'.
+        num_max_proposals (int, optional): Maximum number of proposals to dump.
+            If not specified, all proposals will be dumped.
+        file_client_args (dict, optional): Arguments to instantiate the
+            corresponding backend in mmdet <= 3.0.0rc6. Defaults to None.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+        collect_device (str): Device name used for collecting results from
+            different ranks during distributed training. Must be 'cpu' or
+            'gpu'. Defaults to 'cpu'.
+        prefix (str, optional): The prefix that will be added in the metric
+            names to disambiguate homonymous metrics of different evaluators.
+            If prefix is not provided in the argument, self.default_prefix
+            will be used instead. Defaults to None.
+    """
+
+    default_prefix: Optional[str] = 'dump_proposals'
+
+    def __init__(self,
+                 output_dir: str = '',
+                 proposals_file: str = 'proposals.pkl',
+                 num_max_proposals: Optional[int] = None,
+                 file_client_args: dict = None,
+                 backend_args: dict = None,
+                 collect_device: str = 'cpu',
+                 prefix: Optional[str] = None) -> None:
+        super().__init__(collect_device=collect_device, prefix=prefix)
+        self.num_max_proposals = num_max_proposals
+        # TODO: update after mmengine finish refactor fileio.
+        self.backend_args = backend_args
+        if file_client_args is not None:
+            raise RuntimeError(
+                'The `file_client_args` is deprecated, '
+                'please use `backend_args` instead, please refer to'
+                'https://github.com/open-mmlab/mmdetection/blob/main/configs/_base_/datasets/coco_detection.py'  # noqa: E501
+            )
+        self.output_dir = output_dir
+        assert proposals_file.endswith(('.pkl', '.pickle')), \
+            'The output file must be a pkl file.'
+
+        self.proposals_file = os.path.join(self.output_dir, proposals_file)
+        if is_main_process():
+            os.makedirs(self.output_dir, exist_ok=True)
+
+    def process(self, data_batch: Sequence[dict],
+                data_samples: Sequence[dict]) -> None:
+        """Process one batch of data samples and predictions. The processed
+        results should be stored in ``self.results``, which will be used to
+        compute the metrics when all batches have been processed.
+
+        Args:
+            data_batch (dict): A batch of data from the dataloader.
+            data_samples (Sequence[dict]): A batch of data samples that
+                contain annotations and predictions.
+        """
+        for data_sample in data_samples:
+            pred = data_sample['pred_instances']
+            # `bboxes` is sorted by `scores`
+            ranked_scores, rank_inds = pred['scores'].sort(descending=True)
+            ranked_bboxes = pred['bboxes'][rank_inds, :]
+
+            ranked_bboxes = ranked_bboxes.cpu().numpy()
+            ranked_scores = ranked_scores.cpu().numpy()
+
+            pred_instance = InstanceData()
+            pred_instance.bboxes = ranked_bboxes
+            pred_instance.scores = ranked_scores
+            if self.num_max_proposals is not None:
+                pred_instance = pred_instance[:self.num_max_proposals]
+
+            img_path = data_sample['img_path']
+            # `file_name` is the key to obtain the proposals from the
+            # `proposals_list`.
+            file_name = osp.join(
+                osp.split(osp.split(img_path)[0])[-1],
+                osp.split(img_path)[-1])
+            result = {file_name: pred_instance}
+            self.results.append(result)
+
+    def compute_metrics(self, results: list) -> dict:
+        """Dump the processed results.
+
+        Args:
+            results (list): The processed results of each batch.
+
+        Returns:
+            dict: An empty dict.
+        """
+        logger: MMLogger = MMLogger.get_current_instance()
+        dump_results = {}
+        for result in results:
+            dump_results.update(result)
+        dump(
+            dump_results,
+            file=self.proposals_file,
+            backend_args=self.backend_args)
+        logger.info(f'Results are saved at {self.proposals_file}')
+        return {}
diff --git a/mmdetection/mmdet/evaluation/metrics/flickr30k_metric.py b/mmdetection/mmdet/evaluation/metrics/flickr30k_metric.py
new file mode 100644
index 00000000..f8b64bfd
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/flickr30k_metric.py
@@ -0,0 +1,165 @@
+# Copyright (c) OpenMMLab. All rights reserved
+from collections import defaultdict
+from typing import Dict, List, Optional, Sequence
+
+import numpy as np
+from mmengine.evaluator import BaseMetric
+from mmengine.logging import MMLogger
+
+from mmdet.registry import METRICS
+from ..functional import bbox_overlaps
+
+
+class RecallTracker:
+    """Utility class to track recall@k for various k, split by categories."""
+
+    def __init__(self, topk: Sequence[int]):
+        """
+        Parameters:
+           - topk : tuple of ints corresponding to the recalls being
+           tracked (eg, recall@1, recall@10, ...)
+        """
+
+        self.total_byk_bycat: Dict[int, Dict[str, int]] = {
+            k: defaultdict(int)
+            for k in topk
+        }
+        self.positives_byk_bycat: Dict[int, Dict[str, int]] = {
+            k: defaultdict(int)
+            for k in topk
+        }
+
+    def add_positive(self, k: int, category: str):
+        """Log a positive hit @k for given category."""
+        if k not in self.total_byk_bycat:
+            raise RuntimeError(f'{k} is not a valid recall threshold')
+        self.total_byk_bycat[k][category] += 1
+        self.positives_byk_bycat[k][category] += 1
+
+    def add_negative(self, k: int, category: str):
+        """Log a negative hit @k for given category."""
+        if k not in self.total_byk_bycat:
+            raise RuntimeError(f'{k} is not a valid recall threshold')
+        self.total_byk_bycat[k][category] += 1
+
+    def report(self) -> Dict[str, Dict[str, float]]:
+        """Return a condensed report of the results as a dict of dict.
+
+        report[k][cat] is the recall@k for the given category
+        """
+        report: Dict[str, Dict[str, float]] = {}
+        for k in self.total_byk_bycat:
+            assert k in self.positives_byk_bycat
+            report[str(k)] = {
+                cat:
+                self.positives_byk_bycat[k][cat] / self.total_byk_bycat[k][cat]
+                for cat in self.total_byk_bycat[k]
+            }
+        return report
+
+
+@METRICS.register_module()
+class Flickr30kMetric(BaseMetric):
+    """Phrase Grounding Metric."""
+
+    def __init__(
+        self,
+        topk: Sequence[int] = (1, 5, 10, -1),
+        iou_thrs: float = 0.5,
+        merge_boxes: bool = False,
+        collect_device: str = 'cpu',
+        prefix: Optional[str] = None,
+    ) -> None:
+        super().__init__(collect_device=collect_device, prefix=prefix)
+
+        self.iou_thrs = iou_thrs
+        self.topk = topk
+        self.merge = merge_boxes
+
+    def merge_boxes(self, boxes: List[List[int]]) -> List[List[int]]:
+        """Return the boxes corresponding to the smallest enclosing box
+        containing all the provided boxes The boxes are expected in [x1, y1,
+        x2, y2] format."""
+        if len(boxes) == 1:
+            return boxes
+
+        np_boxes = np.asarray(boxes)
+
+        return [[
+            np.boxes[:, 0].min(), np_boxes[:, 1].min(), np_boxes[:, 2].max(),
+            np_boxes[:, 3].max()
+        ]]
+
+    def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
+        """Process one batch of data samples and predictions.
+
+        The processed
+        results should be stored in ``self.results``, which will be used to
+        compute the metrics when all batches have been processed.
+        Args:
+            data_batch (dict): A batch of data from the dataloader.
+            data_samples (Sequence[dict]): A batch of data samples that
+                contain annotations and predictions.
+        """
+        for data_sample in data_samples:
+            pred = data_sample['pred_instances']
+            gt = data_sample['gt_instances']['bboxes']
+            gt_label = data_sample['phrase_ids']
+            phrases = data_sample['phrases']
+            assert len(gt) == len(gt_label)
+
+            self.results.append((pred, gt, gt_label, phrases))
+
+    def compute_metrics(self, results: list) -> Dict[str, float]:
+        """Compute the metrics from processed results.
+
+        Args:
+            results (list): The processed results of each batch.
+        Returns:
+            Dict[str, float]: The computed metrics. The keys are the names of
+            the metrics, and the values are corresponding results.
+        """
+        logger: MMLogger = MMLogger.get_current_instance()
+
+        pred_list, gt_list, gt_label_list, phrase_list = zip(*results)
+
+        recall_tracker = RecallTracker(self.topk)
+
+        for pred, gt_boxes, gt_labels, phrases in zip(pred_list, gt_list,
+                                                      gt_label_list,
+                                                      phrase_list):
+            pred_boxes = pred['bboxes'].cpu().numpy()
+            pred_labels = pred['labels'].cpu().numpy()
+            for i, phrase in enumerate(phrases):
+                cur_index = pred_labels == i
+                cur_boxes = pred_boxes[cur_index]
+                tar_index = [
+                    index for index, value in enumerate(gt_labels)
+                    if value == i
+                ]
+                tar_boxes = gt_boxes[tar_index]
+                if self.merge:
+                    tar_boxes = self.merge_boxes(tar_boxes)
+                if len(cur_boxes) == 0:
+                    cur_boxes = [[0., 0., 0., 0.]]
+                ious = bbox_overlaps(
+                    np.asarray(cur_boxes), np.asarray(tar_boxes))
+                for k in self.topk:
+                    if k == -1:
+                        maxi = ious.max()
+                    else:
+                        assert k > 0
+                        maxi = ious[:k].max()
+                    if maxi >= self.iou_thrs:
+                        recall_tracker.add_positive(k, 'all')
+                        # TODO: do not support class-wise evaluation yet
+                        # for phrase_type in phrase['phrase_type']:
+                        #     recall_tracker.add_positive(k, phrase_type)
+                    else:
+                        recall_tracker.add_negative(k, 'all')
+                        # for phrase_type in phrase['phrase_type']:
+                        #     recall_tracker.add_negative(k, phrase_type)
+
+        results = recall_tracker.report()
+        logger.info(results)
+        return results
diff --git a/mmdetection/mmdet/evaluation/metrics/grefcoco_metric.py b/mmdetection/mmdet/evaluation/metrics/grefcoco_metric.py
new file mode 100644
index 00000000..55cc638c
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/grefcoco_metric.py
@@ -0,0 +1,122 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, Optional, Sequence
+
+import numpy as np
+import torch
+from mmengine.evaluator import BaseMetric
+from mmengine.fileio import get_local_path
+from mmengine.logging import MMLogger
+
+from mmdet.datasets.api_wrappers import COCO
+from mmdet.registry import METRICS
+from ..functional import bbox_overlaps
+
+
+# refer from https://github.com/henghuiding/gRefCOCO/blob/main/mdetr/datasets/refexp.py # noqa
+@METRICS.register_module()
+class gRefCOCOMetric(BaseMetric):
+    default_prefix: Optional[str] = 'grefcoco'
+
+    def __init__(self,
+                 ann_file: Optional[str] = None,
+                 metric: str = 'bbox',
+                 iou_thrs: float = 0.5,
+                 thresh_score: float = 0.7,
+                 thresh_f1: float = 1.0,
+                 **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.metric = metric
+        self.iou_thrs = iou_thrs
+        self.thresh_score = thresh_score
+        self.thresh_f1 = thresh_f1
+
+        with get_local_path(ann_file) as local_path:
+            self.coco = COCO(local_path)
+
+    def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
+        for data_sample in data_samples:
+            result = dict()
+            pred = data_sample['pred_instances']
+            result['img_id'] = data_sample['img_id']
+            result['bboxes'] = pred['bboxes'].cpu()
+            result['scores'] = pred['scores'].cpu()
+            self.results.append(result)
+
+    def compute_metrics(self, results: list) -> Dict[str, float]:
+        logger: MMLogger = MMLogger.get_current_instance()
+
+        correct_image = 0
+        num_image = 0
+        nt = {'TP': 0, 'TN': 0, 'FP': 0, 'FN': 0}
+
+        for result in results:
+            img_id = result['img_id']
+            TP = 0
+
+            ann_ids = self.coco.getAnnIds(imgIds=img_id)
+            target = self.coco.loadAnns(ann_ids[0])
+
+            converted_bbox_all = []
+            no_target_flag = False
+            for one_target in target:
+                if one_target['category_id'] == -1:
+                    no_target_flag = True
+                target_bbox = one_target['bbox']
+                converted_bbox = [
+                    target_bbox[0],
+                    target_bbox[1],
+                    target_bbox[2] + target_bbox[0],
+                    target_bbox[3] + target_bbox[1],
+                ]
+                converted_bbox_all.append(
+                    np.array(converted_bbox).reshape(-1, 4))
+            gt_bbox_all = np.concatenate(converted_bbox_all, axis=0)
+
+            idx = result['scores'] >= self.thresh_score
+            filtered_boxes = result['bboxes'][idx]
+
+            iou = bbox_overlaps(filtered_boxes.numpy(), gt_bbox_all)
+            iou = torch.from_numpy(iou)
+
+            num_prediction = filtered_boxes.shape[0]
+            num_gt = gt_bbox_all.shape[0]
+            if no_target_flag:
+                if num_prediction >= 1:
+                    nt['FN'] += 1
+                else:
+                    nt['TP'] += 1
+                if num_prediction >= 1:
+                    f_1 = 0.
+                else:
+                    f_1 = 1.0
+            else:
+                if num_prediction >= 1:
+                    nt['TN'] += 1
+                else:
+                    nt['FP'] += 1
+                for i in range(min(num_prediction, num_gt)):
+                    top_value, top_index = torch.topk(iou.flatten(0, 1), 1)
+                    if top_value < self.iou_thrs:
+                        break
+                    else:
+                        top_index_x = top_index // num_gt
+                        top_index_y = top_index % num_gt
+                        TP += 1
+                        iou[top_index_x[0], :] = 0.0
+                        iou[:, top_index_y[0]] = 0.0
+                FP = num_prediction - TP
+                FN = num_gt - TP
+                f_1 = 2 * TP / (2 * TP + FP + FN)
+
+            if f_1 >= self.thresh_f1:
+                correct_image += 1
+            num_image += 1
+
+        score = correct_image / max(num_image, 1)
+        results = {
+            'F1_score': score,
+            'T_acc': nt['TN'] / (nt['TN'] + nt['FP']),
+            'N_acc': nt['TP'] / (nt['TP'] + nt['FN'])
+        }
+        logger.info(results)
+        return results
diff --git a/mmdetection/mmdet/evaluation/metrics/lvis_metric.py b/mmdetection/mmdet/evaluation/metrics/lvis_metric.py
new file mode 100644
index 00000000..a861c6ee
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/lvis_metric.py
@@ -0,0 +1,534 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import itertools
+import logging
+import os.path as osp
+import tempfile
+import warnings
+from collections import OrderedDict, defaultdict
+from typing import Dict, List, Optional, Sequence, Union
+
+import numpy as np
+import torch
+from mmengine.dist import (all_gather_object, broadcast_object_list,
+                           is_main_process)
+from mmengine.evaluator import BaseMetric
+from mmengine.evaluator.metric import _to_cpu
+from mmengine.fileio import get_local_path
+from mmengine.logging import MMLogger, print_log
+from terminaltables import AsciiTable
+
+from mmdet.registry import METRICS
+from mmdet.structures.mask import encode_mask_results
+from ..functional import eval_recalls
+from .coco_metric import CocoMetric
+
+try:
+    import lvis
+
+    if getattr(lvis, '__version__', '0') >= '10.5.3':
+        warnings.warn(
+            'mmlvis is deprecated, please install official lvis-api by "pip install git+https://github.com/lvis-dataset/lvis-api.git"',  # noqa: E501
+            UserWarning)
+    from lvis import LVIS, LVISEval, LVISResults
+except ImportError:
+    lvis = None
+    LVISEval = None
+    LVISResults = None
+
+
+@METRICS.register_module()
+class LVISMetric(CocoMetric):
+    """LVIS evaluation metric.
+
+    Args:
+        ann_file (str, optional): Path to the coco format annotation file.
+            If not specified, ground truth annotations from the dataset will
+            be converted to coco format. Defaults to None.
+        metric (str | List[str]): Metrics to be evaluated. Valid metrics
+            include 'bbox', 'segm', 'proposal', and 'proposal_fast'.
+            Defaults to 'bbox'.
+        classwise (bool): Whether to evaluate the metric class-wise.
+            Defaults to False.
+        proposal_nums (Sequence[int]): Numbers of proposals to be evaluated.
+            Defaults to (100, 300, 1000).
+        iou_thrs (float | List[float], optional): IoU threshold to compute AP
+            and AR. If not specified, IoUs from 0.5 to 0.95 will be used.
+            Defaults to None.
+        metric_items (List[str], optional): Metric result names to be
+            recorded in the evaluation result. Defaults to None.
+        format_only (bool): Format the output results without perform
+            evaluation. It is useful when you want to format the result
+            to a specific format and submit it to the test server.
+            Defaults to False.
+        outfile_prefix (str, optional): The prefix of json files. It includes
+            the file path and the prefix of filename, e.g., "a/b/prefix".
+            If not specified, a temp file will be created. Defaults to None.
+        collect_device (str): Device name used for collecting results from
+            different ranks during distributed training. Must be 'cpu' or
+            'gpu'. Defaults to 'cpu'.
+        prefix (str, optional): The prefix that will be added in the metric
+            names to disambiguate homonymous metrics of different evaluators.
+            If prefix is not provided in the argument, self.default_prefix
+            will be used instead. Defaults to None.
+        file_client_args (dict, optional): Arguments to instantiate the
+            corresponding backend in mmdet <= 3.0.0rc6. Defaults to None.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+    """
+
+    default_prefix: Optional[str] = 'lvis'
+
+    def __init__(self,
+                 ann_file: Optional[str] = None,
+                 metric: Union[str, List[str]] = 'bbox',
+                 classwise: bool = False,
+                 proposal_nums: Sequence[int] = (100, 300, 1000),
+                 iou_thrs: Optional[Union[float, Sequence[float]]] = None,
+                 metric_items: Optional[Sequence[str]] = None,
+                 format_only: bool = False,
+                 outfile_prefix: Optional[str] = None,
+                 collect_device: str = 'cpu',
+                 prefix: Optional[str] = None,
+                 file_client_args: dict = None,
+                 backend_args: dict = None) -> None:
+        if lvis is None:
+            raise RuntimeError(
+                'Package lvis is not installed. Please run "pip install '
+                'git+https://github.com/lvis-dataset/lvis-api.git".')
+        super().__init__(collect_device=collect_device, prefix=prefix)
+        # coco evaluation metrics
+        self.metrics = metric if isinstance(metric, list) else [metric]
+        allowed_metrics = ['bbox', 'segm', 'proposal', 'proposal_fast']
+        for metric in self.metrics:
+            if metric not in allowed_metrics:
+                raise KeyError(
+                    "metric should be one of 'bbox', 'segm', 'proposal', "
+                    f"'proposal_fast', but got {metric}.")
+
+        # do class wise evaluation, default False
+        self.classwise = classwise
+
+        # proposal_nums used to compute recall or precision.
+        self.proposal_nums = list(proposal_nums)
+
+        # iou_thrs used to compute recall or precision.
+        if iou_thrs is None:
+            iou_thrs = np.linspace(
+                .5, 0.95, int(np.round((0.95 - .5) / .05)) + 1, endpoint=True)
+        self.iou_thrs = iou_thrs
+        self.metric_items = metric_items
+        self.format_only = format_only
+        if self.format_only:
+            assert outfile_prefix is not None, 'outfile_prefix must be not'
+            'None when format_only is True, otherwise the result files will'
+            'be saved to a temp directory which will be cleaned up at the end.'
+
+        self.outfile_prefix = outfile_prefix
+        self.backend_args = backend_args
+        if file_client_args is not None:
+            raise RuntimeError(
+                'The `file_client_args` is deprecated, '
+                'please use `backend_args` instead, please refer to'
+                'https://github.com/open-mmlab/mmdetection/blob/main/configs/_base_/datasets/coco_detection.py'  # noqa: E501
+            )
+
+        # if ann_file is not specified,
+        # initialize lvis api with the converted dataset
+        if ann_file is not None:
+            with get_local_path(
+                    ann_file, backend_args=self.backend_args) as local_path:
+                self._lvis_api = LVIS(local_path)
+        else:
+            self._lvis_api = None
+
+        # handle dataset lazy init
+        self.cat_ids = None
+        self.img_ids = None
+
+    def fast_eval_recall(self,
+                         results: List[dict],
+                         proposal_nums: Sequence[int],
+                         iou_thrs: Sequence[float],
+                         logger: Optional[MMLogger] = None) -> np.ndarray:
+        """Evaluate proposal recall with LVIS's fast_eval_recall.
+
+        Args:
+            results (List[dict]): Results of the dataset.
+            proposal_nums (Sequence[int]): Proposal numbers used for
+                evaluation.
+            iou_thrs (Sequence[float]): IoU thresholds used for evaluation.
+            logger (MMLogger, optional): Logger used for logging the recall
+                summary.
+        Returns:
+            np.ndarray: Averaged recall results.
+        """
+        gt_bboxes = []
+        pred_bboxes = [result['bboxes'] for result in results]
+        for i in range(len(self.img_ids)):
+            ann_ids = self._lvis_api.get_ann_ids(img_ids=[self.img_ids[i]])
+            ann_info = self._lvis_api.load_anns(ann_ids)
+            if len(ann_info) == 0:
+                gt_bboxes.append(np.zeros((0, 4)))
+                continue
+            bboxes = []
+            for ann in ann_info:
+                x1, y1, w, h = ann['bbox']
+                bboxes.append([x1, y1, x1 + w, y1 + h])
+            bboxes = np.array(bboxes, dtype=np.float32)
+            if bboxes.shape[0] == 0:
+                bboxes = np.zeros((0, 4))
+            gt_bboxes.append(bboxes)
+
+        recalls = eval_recalls(
+            gt_bboxes, pred_bboxes, proposal_nums, iou_thrs, logger=logger)
+        ar = recalls.mean(axis=1)
+        return ar
+
+    # TODO: data_batch is no longer needed, consider adjusting the
+    #  parameter position
+    def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
+        """Process one batch of data samples and predictions. The processed
+        results should be stored in ``self.results``, which will be used to
+        compute the metrics when all batches have been processed.
+
+        Args:
+            data_batch (dict): A batch of data from the dataloader.
+            data_samples (Sequence[dict]): A batch of data samples that
+                contain annotations and predictions.
+        """
+        for data_sample in data_samples:
+            result = dict()
+            pred = data_sample['pred_instances']
+            result['img_id'] = data_sample['img_id']
+            result['bboxes'] = pred['bboxes'].cpu().numpy()
+            result['scores'] = pred['scores'].cpu().numpy()
+            result['labels'] = pred['labels'].cpu().numpy()
+            # encode mask to RLE
+            if 'masks' in pred:
+                result['masks'] = encode_mask_results(
+                    pred['masks'].detach().cpu().numpy())
+            # some detectors use different scores for bbox and mask
+            if 'mask_scores' in pred:
+                result['mask_scores'] = pred['mask_scores'].cpu().numpy()
+
+            # parse gt
+            gt = dict()
+            gt['width'] = data_sample['ori_shape'][1]
+            gt['height'] = data_sample['ori_shape'][0]
+            gt['img_id'] = data_sample['img_id']
+            if self._lvis_api is None:
+                # TODO: Need to refactor to support LoadAnnotations
+                assert 'instances' in data_sample, \
+                    'ground truth is required for evaluation when ' \
+                    '`ann_file` is not provided'
+                gt['anns'] = data_sample['instances']
+            # add converted result to the results list
+            self.results.append((gt, result))
+
+    def compute_metrics(self, results: list) -> Dict[str, float]:
+        """Compute the metrics from processed results.
+
+        Args:
+            results (list): The processed results of each batch.
+
+        Returns:
+            Dict[str, float]: The computed metrics. The keys are the names of
+            the metrics, and the values are corresponding results.
+        """
+        logger: MMLogger = MMLogger.get_current_instance()
+
+        # split gt and prediction list
+        gts, preds = zip(*results)
+
+        tmp_dir = None
+        if self.outfile_prefix is None:
+            tmp_dir = tempfile.TemporaryDirectory()
+            outfile_prefix = osp.join(tmp_dir.name, 'results')
+        else:
+            outfile_prefix = self.outfile_prefix
+
+        if self._lvis_api is None:
+            # use converted gt json file to initialize coco api
+            logger.info('Converting ground truth to coco format...')
+            coco_json_path = self.gt_to_coco_json(
+                gt_dicts=gts, outfile_prefix=outfile_prefix)
+            self._lvis_api = LVIS(coco_json_path)
+
+        # handle lazy init
+        if self.cat_ids is None:
+            self.cat_ids = self._lvis_api.get_cat_ids()
+        if self.img_ids is None:
+            self.img_ids = self._lvis_api.get_img_ids()
+
+        # convert predictions to coco format and dump to json file
+        result_files = self.results2json(preds, outfile_prefix)
+
+        eval_results = OrderedDict()
+        if self.format_only:
+            logger.info('results are saved in '
+                        f'{osp.dirname(outfile_prefix)}')
+            return eval_results
+
+        lvis_gt = self._lvis_api
+
+        for metric in self.metrics:
+            logger.info(f'Evaluating {metric}...')
+
+            # TODO: May refactor fast_eval_recall to an independent metric?
+            # fast eval recall
+            if metric == 'proposal_fast':
+                ar = self.fast_eval_recall(
+                    preds, self.proposal_nums, self.iou_thrs, logger=logger)
+                log_msg = []
+                for i, num in enumerate(self.proposal_nums):
+                    eval_results[f'AR@{num}'] = ar[i]
+                    log_msg.append(f'\nAR@{num}\t{ar[i]:.4f}')
+                log_msg = ''.join(log_msg)
+                logger.info(log_msg)
+                continue
+
+            try:
+                lvis_dt = LVISResults(lvis_gt, result_files[metric])
+            except IndexError:
+                logger.info(
+                    'The testing results of the whole dataset is empty.')
+                break
+
+            iou_type = 'bbox' if metric == 'proposal' else metric
+            lvis_eval = LVISEval(lvis_gt, lvis_dt, iou_type)
+            lvis_eval.params.imgIds = self.img_ids
+            metric_items = self.metric_items
+            if metric == 'proposal':
+                lvis_eval.params.useCats = 0
+                lvis_eval.params.maxDets = list(self.proposal_nums)
+                lvis_eval.evaluate()
+                lvis_eval.accumulate()
+                lvis_eval.summarize()
+                if metric_items is None:
+                    metric_items = ['AR@300', 'ARs@300', 'ARm@300', 'ARl@300']
+                for k, v in lvis_eval.get_results().items():
+                    if k in metric_items:
+                        val = float('{:.3f}'.format(float(v)))
+                        eval_results[k] = val
+
+            else:
+                lvis_eval.evaluate()
+                lvis_eval.accumulate()
+                lvis_eval.summarize()
+                lvis_results = lvis_eval.get_results()
+                if self.classwise:  # Compute per-category AP
+                    # Compute per-category AP
+                    # from https://github.com/facebookresearch/detectron2/
+                    precisions = lvis_eval.eval['precision']
+                    # precision: (iou, recall, cls, area range, max dets)
+                    assert len(self.cat_ids) == precisions.shape[2]
+
+                    results_per_category = []
+                    for idx, catId in enumerate(self.cat_ids):
+                        # area range index 0: all area ranges
+                        # max dets index -1: typically 100 per image
+                        # the dimensions of precisions are
+                        # [num_thrs, num_recalls, num_cats, num_area_rngs]
+                        nm = self._lvis_api.load_cats([catId])[0]
+                        precision = precisions[:, :, idx, 0]
+                        precision = precision[precision > -1]
+                        if precision.size:
+                            ap = np.mean(precision)
+                        else:
+                            ap = float('nan')
+                        results_per_category.append(
+                            (f'{nm["name"]}', f'{float(ap):0.3f}'))
+                        eval_results[f'{nm["name"]}_precision'] = round(ap, 3)
+
+                    num_columns = min(6, len(results_per_category) * 2)
+                    results_flatten = list(
+                        itertools.chain(*results_per_category))
+                    headers = ['category', 'AP'] * (num_columns // 2)
+                    results_2d = itertools.zip_longest(*[
+                        results_flatten[i::num_columns]
+                        for i in range(num_columns)
+                    ])
+                    table_data = [headers]
+                    table_data += [result for result in results_2d]
+                    table = AsciiTable(table_data)
+                    logger.info('\n' + table.table)
+
+                if metric_items is None:
+                    metric_items = [
+                        'AP', 'AP50', 'AP75', 'APs', 'APm', 'APl', 'APr',
+                        'APc', 'APf'
+                    ]
+
+                for k, v in lvis_results.items():
+                    if k in metric_items:
+                        key = '{}_{}'.format(metric, k)
+                        val = float('{:.3f}'.format(float(v)))
+                        eval_results[key] = val
+
+            lvis_eval.print_results()
+        if tmp_dir is not None:
+            tmp_dir.cleanup()
+        return eval_results
+
+
+def _merge_lists(listA, listB, maxN, key):
+    result = []
+    indA, indB = 0, 0
+    while (indA < len(listA) or indB < len(listB)) and len(result) < maxN:
+        if (indB < len(listB)) and (indA >= len(listA)
+                                    or key(listA[indA]) < key(listB[indB])):
+            result.append(listB[indB])
+            indB += 1
+        else:
+            result.append(listA[indA])
+            indA += 1
+    return result
+
+
+@METRICS.register_module()
+class LVISFixedAPMetric(BaseMetric):
+    default_prefix: Optional[str] = 'lvis_fixed_ap'
+
+    def __init__(self,
+                 ann_file: str,
+                 topk: int = 10000,
+                 format_only: bool = False,
+                 outfile_prefix: Optional[str] = None,
+                 collect_device: str = 'cpu',
+                 prefix: Optional[str] = None,
+                 backend_args: dict = None) -> None:
+
+        if lvis is None:
+            raise RuntimeError(
+                'Package lvis is not installed. Please run "pip install '
+                'git+https://github.com/lvis-dataset/lvis-api.git".')
+        super().__init__(collect_device=collect_device, prefix=prefix)
+
+        self.format_only = format_only
+        if self.format_only:
+            assert outfile_prefix is not None, 'outfile_prefix must be not'
+            'None when format_only is True, otherwise the result files will'
+            'be saved to a temp directory which will be cleaned up at the end.'
+
+        self.outfile_prefix = outfile_prefix
+        self.backend_args = backend_args
+
+        with get_local_path(
+                ann_file, backend_args=self.backend_args) as local_path:
+            self._lvis_api = LVIS(local_path)
+
+        self.cat_ids = self._lvis_api.get_cat_ids()
+
+        self.results = {}
+        self.topk = topk
+
+    def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
+        """Process one batch of data samples and predictions. The processed
+        results should be stored in ``self.results``, which will be used to
+        compute the metrics when all batches have been processed.
+
+        Args:
+            data_batch (dict): A batch of data from the dataloader.
+            data_samples (Sequence[dict]): A batch of data samples that
+                contain annotations and predictions.
+        """
+        cur_results = []
+        for data_sample in data_samples:
+            pred = data_sample['pred_instances']
+            xmin, ymin, xmax, ymax = pred['bboxes'].cpu().unbind(1)
+            boxes = torch.stack((xmin, ymin, xmax - xmin, ymax - ymin),
+                                dim=1).tolist()
+
+            scores = pred['scores'].cpu().numpy()
+            labels = pred['labels'].cpu().numpy()
+
+            if len(boxes) == 0:
+                continue
+
+            cur_results.extend([{
+                'image_id': data_sample['img_id'],
+                'category_id': self.cat_ids[labels[k]],
+                'bbox': box,
+                'score': scores[k],
+            } for k, box in enumerate(boxes)])
+
+        by_cat = defaultdict(list)
+        for ann in cur_results:
+            by_cat[ann['category_id']].append(ann)
+
+        for cat, cat_anns in by_cat.items():
+            if cat not in self.results:
+                self.results[cat] = []
+
+            cur = sorted(
+                cat_anns, key=lambda x: x['score'], reverse=True)[:self.topk]
+            self.results[cat] = _merge_lists(
+                self.results[cat], cur, self.topk, key=lambda x: x['score'])
+
+    def compute_metrics(self, results: dict) -> dict:
+        logger: MMLogger = MMLogger.get_current_instance()
+
+        new_results = []
+
+        missing_dets_cats = set()
+        for cat, cat_anns in results.items():
+            if len(cat_anns) < self.topk:
+                missing_dets_cats.add(cat)
+            new_results.extend(
+                sorted(cat_anns, key=lambda x: x['score'],
+                       reverse=True)[:self.topk])
+
+        if missing_dets_cats:
+            logger.info(
+                f'\n===\n'
+                f'{len(missing_dets_cats)} classes had less than {self.topk} '
+                f'detections!\n Outputting {self.topk} detections for each '
+                f'class will improve AP further.\n ===')
+
+        new_results = LVISResults(self._lvis_api, new_results, max_dets=-1)
+        lvis_eval = LVISEval(self._lvis_api, new_results, iou_type='bbox')
+        params = lvis_eval.params
+        params.max_dets = -1  # No limit on detections per image.
+        lvis_eval.run()
+        lvis_eval.print_results()
+        metrics = {
+            k: v
+            for k, v in lvis_eval.results.items() if k.startswith('AP')
+        }
+        logger.info(f'mAP_copypaste: {metrics}')
+        return metrics
+
+    def evaluate(self, size: int) -> dict:
+        if len(self.results) == 0:
+            print_log(
+                f'{self.__class__.__name__} got empty `self.results`. Please '
+                'ensure that the processed results are properly added into '
+                '`self.results` in `process` method.',
+                logger='current',
+                level=logging.WARNING)
+
+        all_cats = all_gather_object(self.results)
+        results = defaultdict(list)
+        for cats in all_cats:
+            for cat, cat_anns in cats.items():
+                results[cat].extend(cat_anns)
+
+        if is_main_process():
+            # cast all tensors in results list to cpu
+            results = _to_cpu(results)
+            _metrics = self.compute_metrics(results)  # type: ignore
+            # Add prefix to metric names
+            if self.prefix:
+                _metrics = {
+                    '/'.join((self.prefix, k)): v
+                    for k, v in _metrics.items()
+                }
+            metrics = [_metrics]
+        else:
+            metrics = [None]  # type: ignore
+
+        broadcast_object_list(metrics)
+
+        # reset the results
+        self.results = {}
+        return metrics[0]
diff --git a/mmdetection/mmdet/evaluation/metrics/mot_challenge_metric.py b/mmdetection/mmdet/evaluation/metrics/mot_challenge_metric.py
new file mode 100644
index 00000000..a5513c44
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/mot_challenge_metric.py
@@ -0,0 +1,443 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os
+import os.path as osp
+import shutil
+import tempfile
+from collections import defaultdict
+from typing import List, Optional, Union
+
+import numpy as np
+import torch
+
+try:
+    import trackeval
+except ImportError:
+    trackeval = None
+from mmengine.dist import (all_gather_object, barrier, broadcast,
+                           broadcast_object_list, get_dist_info,
+                           is_main_process)
+from mmengine.logging import MMLogger
+
+from mmdet.registry import METRICS, TASK_UTILS
+from .base_video_metric import BaseVideoMetric
+
+
+def get_tmpdir() -> str:
+    """return the same tmpdir for all processes."""
+    rank, world_size = get_dist_info()
+    MAX_LEN = 512
+    # 32 is whitespace
+    dir_tensor = torch.full((MAX_LEN, ), 32, dtype=torch.uint8)
+    if rank == 0:
+        tmpdir = tempfile.mkdtemp()
+        tmpdir = torch.tensor(bytearray(tmpdir.encode()), dtype=torch.uint8)
+        dir_tensor[:len(tmpdir)] = tmpdir
+    broadcast(dir_tensor, 0)
+    tmpdir = dir_tensor.cpu().numpy().tobytes().decode().rstrip()
+    return tmpdir
+
+
+@METRICS.register_module()
+class MOTChallengeMetric(BaseVideoMetric):
+    """Evaluation metrics for MOT Challenge.
+
+    Args:
+        metric (str | list[str]): Metrics to be evaluated. Options are
+            'HOTA', 'CLEAR', 'Identity'.
+            Defaults to ['HOTA', 'CLEAR', 'Identity'].
+        outfile_prefix (str, optional): Path to save the formatted results.
+            Defaults to None.
+        track_iou_thr (float): IoU threshold for tracking evaluation.
+            Defaults to 0.5.
+        benchmark (str): Benchmark to be evaluated. Defaults to 'MOT17'.
+        format_only (bool): If True, only formatting the results to the
+            official format and not performing evaluation. Defaults to False.
+        postprocess_tracklet_cfg (List[dict], optional): configs for tracklets
+            postprocessing methods. `InterpolateTracklets` is supported.
+            Defaults to []
+            - InterpolateTracklets:
+                - min_num_frames (int, optional): The minimum length of a
+                    track that will be interpolated. Defaults to 5.
+                - max_num_frames (int, optional): The maximum disconnected
+                    length in a track. Defaults to 20.
+                - use_gsi (bool, optional): Whether to use the GSI (Gaussian-
+                    smoothed interpolation) method. Defaults to False.
+                - smooth_tau (int, optional): smoothing parameter in GSI.
+                    Defaults to 10.
+        collect_device (str): Device name used for collecting results from
+            different ranks during distributed training. Must be 'cpu' or
+            'gpu'. Defaults to 'cpu'.
+        prefix (str, optional): The prefix that will be added in the metric
+            names to disambiguate homonymous metrics of different evaluators.
+            If prefix is not provided in the argument, self.default_prefix
+            will be used instead. Default: None
+    Returns:
+    """
+    TRACKER = 'default-tracker'
+    allowed_metrics = ['HOTA', 'CLEAR', 'Identity']
+    allowed_benchmarks = ['MOT15', 'MOT16', 'MOT17', 'MOT20', 'DanceTrack']
+    default_prefix: Optional[str] = 'motchallenge-metric'
+
+    def __init__(self,
+                 metric: Union[str, List[str]] = ['HOTA', 'CLEAR', 'Identity'],
+                 outfile_prefix: Optional[str] = None,
+                 track_iou_thr: float = 0.5,
+                 benchmark: str = 'MOT17',
+                 format_only: bool = False,
+                 use_postprocess: bool = False,
+                 postprocess_tracklet_cfg: Optional[List[dict]] = [],
+                 collect_device: str = 'cpu',
+                 prefix: Optional[str] = None) -> None:
+        super().__init__(collect_device=collect_device, prefix=prefix)
+        if trackeval is None:
+            raise RuntimeError(
+                'trackeval is not installed,'
+                'please install it by: pip install'
+                'git+https://github.com/JonathonLuiten/TrackEval.git'
+                'trackeval need low version numpy, please install it'
+                'by: pip install -U numpy==1.23.5')
+        if isinstance(metric, list):
+            metrics = metric
+        elif isinstance(metric, str):
+            metrics = [metric]
+        else:
+            raise TypeError('metric must be a list or a str.')
+        for metric in metrics:
+            if metric not in self.allowed_metrics:
+                raise KeyError(f'metric {metric} is not supported.')
+        self.metrics = metrics
+        self.format_only = format_only
+        if self.format_only:
+            assert outfile_prefix is not None, 'outfile_prefix must be not'
+            'None when format_only is True, otherwise the result files will'
+            'be saved to a temp directory which will be cleaned up at the end.'
+        self.use_postprocess = use_postprocess
+        self.postprocess_tracklet_cfg = postprocess_tracklet_cfg.copy()
+        self.postprocess_tracklet_methods = [
+            TASK_UTILS.build(cfg) for cfg in self.postprocess_tracklet_cfg
+        ]
+        assert benchmark in self.allowed_benchmarks
+        self.benchmark = benchmark
+        self.track_iou_thr = track_iou_thr
+        self.tmp_dir = tempfile.TemporaryDirectory()
+        self.tmp_dir.name = get_tmpdir()
+        self.seq_info = defaultdict(
+            lambda: dict(seq_length=-1, gt_tracks=[], pred_tracks=[]))
+        self.gt_dir = self._get_gt_dir()
+        self.pred_dir = self._get_pred_dir(outfile_prefix)
+        self.seqmap = osp.join(self.pred_dir, 'videoseq.txt')
+        with open(self.seqmap, 'w') as f:
+            f.write('name\n')
+
+    def __del__(self):
+        # To avoid tmpdir being cleaned up too early, because in multiple
+        # consecutive ValLoops, the value of `self.tmp_dir.name` is unchanged,
+        # and calling `tmp_dir.cleanup()` in compute_metrics will cause errors.
+        self.tmp_dir.cleanup()
+
+    def _get_pred_dir(self, outfile_prefix):
+        """Get directory to save the prediction results."""
+        logger: MMLogger = MMLogger.get_current_instance()
+
+        if outfile_prefix is None:
+            outfile_prefix = self.tmp_dir.name
+        else:
+            if osp.exists(outfile_prefix) and is_main_process():
+                logger.info('remove previous results.')
+                shutil.rmtree(outfile_prefix)
+        pred_dir = osp.join(outfile_prefix, self.TRACKER)
+        os.makedirs(pred_dir, exist_ok=True)
+        return pred_dir
+
+    def _get_gt_dir(self):
+        """Get directory to save the gt files."""
+        output_dir = osp.join(self.tmp_dir.name, 'gt')
+        os.makedirs(output_dir, exist_ok=True)
+        return output_dir
+
+    def transform_gt_and_pred(self, img_data_sample, video, frame_id):
+
+        video = img_data_sample['img_path'].split(os.sep)[-3]
+        # load gts
+        if 'instances' in img_data_sample:
+            gt_instances = img_data_sample['instances']
+            gt_tracks = [
+                np.array([
+                    frame_id + 1, gt_instances[i]['instance_id'],
+                    gt_instances[i]['bbox'][0], gt_instances[i]['bbox'][1],
+                    gt_instances[i]['bbox'][2] - gt_instances[i]['bbox'][0],
+                    gt_instances[i]['bbox'][3] - gt_instances[i]['bbox'][1],
+                    gt_instances[i]['mot_conf'],
+                    gt_instances[i]['category_id'],
+                    gt_instances[i]['visibility']
+                ]) for i in range(len(gt_instances))
+            ]
+            self.seq_info[video]['gt_tracks'].extend(gt_tracks)
+
+        # load predictions
+        assert 'pred_track_instances' in img_data_sample
+        if self.use_postprocess:
+            pred_instances = img_data_sample['pred_track_instances']
+            pred_tracks = [
+                pred_instances['bboxes'][i]
+                for i in range(len(pred_instances['bboxes']))
+            ]
+        else:
+            pred_instances = img_data_sample['pred_track_instances']
+            pred_tracks = [
+                np.array([
+                    frame_id + 1, pred_instances['instances_id'][i].cpu(),
+                    pred_instances['bboxes'][i][0].cpu(),
+                    pred_instances['bboxes'][i][1].cpu(),
+                    (pred_instances['bboxes'][i][2] -
+                     pred_instances['bboxes'][i][0]).cpu(),
+                    (pred_instances['bboxes'][i][3] -
+                     pred_instances['bboxes'][i][1]).cpu(),
+                    pred_instances['scores'][i].cpu()
+                ]) for i in range(len(pred_instances['instances_id']))
+            ]
+        self.seq_info[video]['pred_tracks'].extend(pred_tracks)
+
+    def process_image(self, data_samples, video_len):
+
+        img_data_sample = data_samples[0].to_dict()
+        video = img_data_sample['img_path'].split(os.sep)[-3]
+        frame_id = img_data_sample['frame_id']
+        if self.seq_info[video]['seq_length'] == -1:
+            self.seq_info[video]['seq_length'] = video_len
+        self.transform_gt_and_pred(img_data_sample, video, frame_id)
+
+        if frame_id == video_len - 1:
+            # postprocessing
+            if self.postprocess_tracklet_cfg:
+                info = self.seq_info[video]
+                pred_tracks = np.array(info['pred_tracks'])
+                for postprocess_tracklet_methods in \
+                        self.postprocess_tracklet_methods:
+                    pred_tracks = postprocess_tracklet_methods\
+                        .forward(pred_tracks)
+                info['pred_tracks'] = pred_tracks
+            self._save_one_video_gts_preds(video)
+
+    def process_video(self, data_samples):
+
+        video_len = len(data_samples)
+        for frame_id in range(video_len):
+            img_data_sample = data_samples[frame_id].to_dict()
+            # load basic info
+            video = img_data_sample['img_path'].split(os.sep)[-3]
+            if self.seq_info[video]['seq_length'] == -1:
+                self.seq_info[video]['seq_length'] = video_len
+            self.transform_gt_and_pred(img_data_sample, video, frame_id)
+
+        if self.postprocess_tracklet_cfg:
+            info = self.seq_info[video]
+            pred_tracks = np.array(info['pred_tracks'])
+            for postprocess_tracklet_methods in \
+                    self.postprocess_tracklet_methods:
+                pred_tracks = postprocess_tracklet_methods \
+                    .forward(pred_tracks)
+            info['pred_tracks'] = pred_tracks
+        self._save_one_video_gts_preds(video)
+
+    def _save_one_video_gts_preds(self, seq: str) -> None:
+        """Save the gt and prediction results."""
+        info = self.seq_info[seq]
+        # save predictions
+        pred_file = osp.join(self.pred_dir, seq + '.txt')
+
+        pred_tracks = np.array(info['pred_tracks'])
+
+        with open(pred_file, 'wt') as f:
+            for tracks in pred_tracks:
+                line = '%d,%d,%.3f,%.3f,%.3f,%.3f,%.3f,-1,-1,-1\n' % (
+                    tracks[0], tracks[1], tracks[2], tracks[3], tracks[4],
+                    tracks[5], tracks[6])
+                f.writelines(line)
+
+        info['pred_tracks'] = []
+        # save gts
+        if info['gt_tracks']:
+            gt_file = osp.join(self.gt_dir, seq + '.txt')
+            with open(gt_file, 'wt') as f:
+                for tracks in info['gt_tracks']:
+                    line = '%d,%d,%d,%d,%d,%d,%d,%d,%.5f\n' % (
+                        tracks[0], tracks[1], tracks[2], tracks[3], tracks[4],
+                        tracks[5], tracks[6], tracks[7], tracks[8])
+                    f.writelines(line)
+            info['gt_tracks'].clear()
+        # save seq info
+        with open(self.seqmap, 'a') as f:
+            f.write(seq + '\n')
+            f.close()
+
+    def compute_metrics(self, results: list = None) -> dict:
+        """Compute the metrics from processed results.
+
+        Args:
+            results (list): The processed results of each batch.
+                Defaults to None.
+
+        Returns:
+            dict: The computed metrics. The keys are the names of the metrics,
+            and the values are corresponding results.
+        """
+        logger: MMLogger = MMLogger.get_current_instance()
+
+        # NOTICE: don't access `self.results` from the method.
+        eval_results = dict()
+
+        if self.format_only:
+            return eval_results
+
+        eval_config = trackeval.Evaluator.get_default_eval_config()
+
+        # need to split out the tracker name
+        # caused by the implementation of TrackEval
+        pred_dir_tmp = self.pred_dir.rsplit(osp.sep, 1)[0]
+        dataset_config = self.get_dataset_cfg(self.gt_dir, pred_dir_tmp)
+
+        evaluator = trackeval.Evaluator(eval_config)
+        dataset = [trackeval.datasets.MotChallenge2DBox(dataset_config)]
+        metrics = [
+            getattr(trackeval.metrics,
+                    metric)(dict(METRICS=[metric], THRESHOLD=0.5))
+            for metric in self.metrics
+        ]
+        output_res, _ = evaluator.evaluate(dataset, metrics)
+        output_res = output_res['MotChallenge2DBox'][
+            self.TRACKER]['COMBINED_SEQ']['pedestrian']
+
+        if 'HOTA' in self.metrics:
+            logger.info('Evaluating HOTA Metrics...')
+            eval_results['HOTA'] = np.average(output_res['HOTA']['HOTA'])
+            eval_results['AssA'] = np.average(output_res['HOTA']['AssA'])
+            eval_results['DetA'] = np.average(output_res['HOTA']['DetA'])
+
+        if 'CLEAR' in self.metrics:
+            logger.info('Evaluating CLEAR Metrics...')
+            eval_results['MOTA'] = np.average(output_res['CLEAR']['MOTA'])
+            eval_results['MOTP'] = np.average(output_res['CLEAR']['MOTP'])
+            eval_results['IDSW'] = np.average(output_res['CLEAR']['IDSW'])
+            eval_results['TP'] = np.average(output_res['CLEAR']['CLR_TP'])
+            eval_results['FP'] = np.average(output_res['CLEAR']['CLR_FP'])
+            eval_results['FN'] = np.average(output_res['CLEAR']['CLR_FN'])
+            eval_results['Frag'] = np.average(output_res['CLEAR']['Frag'])
+            eval_results['MT'] = np.average(output_res['CLEAR']['MT'])
+            eval_results['ML'] = np.average(output_res['CLEAR']['ML'])
+
+        if 'Identity' in self.metrics:
+            logger.info('Evaluating Identity Metrics...')
+            eval_results['IDF1'] = np.average(output_res['Identity']['IDF1'])
+            eval_results['IDTP'] = np.average(output_res['Identity']['IDTP'])
+            eval_results['IDFN'] = np.average(output_res['Identity']['IDFN'])
+            eval_results['IDFP'] = np.average(output_res['Identity']['IDFP'])
+            eval_results['IDP'] = np.average(output_res['Identity']['IDP'])
+            eval_results['IDR'] = np.average(output_res['Identity']['IDR'])
+
+        return eval_results
+
+    def evaluate(self, size: int = 1) -> dict:
+        """Evaluate the model performance of the whole dataset after processing
+        all batches.
+
+        Args:
+            size (int): Length of the entire validation dataset.
+                Defaults to None.
+
+        Returns:
+            dict: Evaluation metrics dict on the val dataset. The keys are the
+            names of the metrics, and the values are corresponding results.
+        """
+        # wait for all processes to complete prediction.
+        barrier()
+
+        # gather seq_info and convert the list of dict to a dict.
+        # convert self.seq_info to dict first to make it picklable.
+        gathered_seq_info = all_gather_object(dict(self.seq_info))
+        all_seq_info = dict()
+        for _seq_info in gathered_seq_info:
+            all_seq_info.update(_seq_info)
+        self.seq_info = all_seq_info
+
+        if is_main_process():
+            _metrics = self.compute_metrics()  # type: ignore
+            # Add prefix to metric names
+            if self.prefix:
+                _metrics = {
+                    '/'.join((self.prefix, k)): v
+                    for k, v in _metrics.items()
+                }
+            metrics = [_metrics]
+        else:
+            metrics = [None]  # type: ignore
+
+        broadcast_object_list(metrics)
+
+        # reset the results list
+        self.results.clear()
+        return metrics[0]
+
+    def get_dataset_cfg(self, gt_folder: str, tracker_folder: str):
+        """Get default configs for trackeval.datasets.MotChallenge2DBox.
+
+        Args:
+            gt_folder (str): the name of the GT folder
+            tracker_folder (str): the name of the tracker folder
+
+        Returns:
+            Dataset Configs for MotChallenge2DBox.
+        """
+        dataset_config = dict(
+            # Location of GT data
+            GT_FOLDER=gt_folder,
+            # Trackers location
+            TRACKERS_FOLDER=tracker_folder,
+            # Where to save eval results
+            # (if None, same as TRACKERS_FOLDER)
+            OUTPUT_FOLDER=None,
+            # Use self.TRACKER as the default tracker
+            TRACKERS_TO_EVAL=[self.TRACKER],
+            # Option values: ['pedestrian']
+            CLASSES_TO_EVAL=['pedestrian'],
+            # Option Values: 'MOT15', 'MOT16', 'MOT17', 'MOT20', 'DanceTrack'
+            BENCHMARK=self.benchmark,
+            # Option Values: 'train', 'test'
+            SPLIT_TO_EVAL='val' if self.benchmark == 'DanceTrack' else 'train',
+            # Whether tracker input files are zipped
+            INPUT_AS_ZIP=False,
+            # Whether to print current config
+            PRINT_CONFIG=True,
+            # Whether to perform preprocessing
+            # (never done for MOT15)
+            DO_PREPROC=False if self.benchmark == 'MOT15' else True,
+            # Tracker files are in
+            # TRACKER_FOLDER/tracker_name/TRACKER_SUB_FOLDER
+            TRACKER_SUB_FOLDER='',
+            # Output files are saved in
+            # OUTPUT_FOLDER/tracker_name/OUTPUT_SUB_FOLDER
+            OUTPUT_SUB_FOLDER='',
+            # Names of trackers to display
+            # (if None: TRACKERS_TO_EVAL)
+            TRACKER_DISPLAY_NAMES=None,
+            # Where seqmaps are found
+            # (if None: GT_FOLDER/seqmaps)
+            SEQMAP_FOLDER=None,
+            # Directly specify seqmap file
+            # (if none use seqmap_folder/benchmark-split_to_eval)
+            SEQMAP_FILE=self.seqmap,
+            # If not None, specify sequences to eval
+            # and their number of timesteps
+            SEQ_INFO={
+                seq: info['seq_length']
+                for seq, info in self.seq_info.items()
+            },
+            # '{gt_folder}/{seq}.txt'
+            GT_LOC_FORMAT='{gt_folder}/{seq}.txt',
+            # If False, data is in GT_FOLDER/BENCHMARK-SPLIT_TO_EVAL/ and in
+            # TRACKERS_FOLDER/BENCHMARK-SPLIT_TO_EVAL/tracker/
+            # If True, the middle 'benchmark-split' folder is skipped for both.
+            SKIP_SPLIT_FOL=True,
+        )
+
+        return dataset_config
diff --git a/mmdetection/mmdet/evaluation/metrics/openimages_metric.py b/mmdetection/mmdet/evaluation/metrics/openimages_metric.py
new file mode 100644
index 00000000..d75c59e0
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/openimages_metric.py
@@ -0,0 +1,237 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+from collections import OrderedDict
+from typing import List, Optional, Sequence, Union
+
+import numpy as np
+from mmengine.evaluator import BaseMetric
+from mmengine.logging import MMLogger, print_log
+
+from mmdet.registry import METRICS
+from ..functional import eval_map
+
+
+@METRICS.register_module()
+class OpenImagesMetric(BaseMetric):
+    """OpenImages evaluation metric.
+
+    Evaluate detection mAP for OpenImages. Please refer to
+    https://storage.googleapis.com/openimages/web/evaluation.html for more
+    details.
+
+    Args:
+        iou_thrs (float or List[float]): IoU threshold. Defaults to 0.5.
+        ioa_thrs (float or List[float]): IoA threshold. Defaults to 0.5.
+        scale_ranges (List[tuple], optional): Scale ranges for evaluating
+            mAP. If not specified, all bounding boxes would be included in
+            evaluation. Defaults to None
+        use_group_of (bool): Whether consider group of groud truth bboxes
+            during evaluating. Defaults to True.
+        get_supercategory (bool): Whether to get parent class of the
+            current class. Default: True.
+        filter_labels (bool): Whether filter unannotated classes.
+            Default: True.
+        collect_device (str): Device name used for collecting results from
+            different ranks during distributed training. Must be 'cpu' or
+            'gpu'. Defaults to 'cpu'.
+        prefix (str, optional): The prefix that will be added in the metric
+            names to disambiguate homonymous metrics of different evaluators.
+            If prefix is not provided in the argument, self.default_prefix
+            will be used instead. Defaults to None.
+    """
+    default_prefix: Optional[str] = 'openimages'
+
+    def __init__(self,
+                 iou_thrs: Union[float, List[float]] = 0.5,
+                 ioa_thrs: Union[float, List[float]] = 0.5,
+                 scale_ranges: Optional[List[tuple]] = None,
+                 use_group_of: bool = True,
+                 get_supercategory: bool = True,
+                 filter_labels: bool = True,
+                 collect_device: str = 'cpu',
+                 prefix: Optional[str] = None) -> None:
+        super().__init__(collect_device=collect_device, prefix=prefix)
+        self.iou_thrs = [iou_thrs] if isinstance(iou_thrs, float) else iou_thrs
+        self.ioa_thrs = [ioa_thrs] if (isinstance(ioa_thrs, float)
+                                       or ioa_thrs is None) else ioa_thrs
+        assert isinstance(self.iou_thrs, list) and isinstance(
+            self.ioa_thrs, list)
+        assert len(self.iou_thrs) == len(self.ioa_thrs)
+
+        self.scale_ranges = scale_ranges
+        self.use_group_of = use_group_of
+        self.get_supercategory = get_supercategory
+        self.filter_labels = filter_labels
+
+    def _get_supercategory_ann(self, instances: List[dict]) -> List[dict]:
+        """Get parent classes's annotation of the corresponding class.
+
+        Args:
+            instances (List[dict]): A list of annotations of the instances.
+
+        Returns:
+            List[dict]: Annotations extended with super-category.
+        """
+        supercat_instances = []
+        relation_matrix = self.dataset_meta['RELATION_MATRIX']
+        for instance in instances:
+            labels = np.where(relation_matrix[instance['bbox_label']])[0]
+            for label in labels:
+                if label == instance['bbox_label']:
+                    continue
+                new_instance = copy.deepcopy(instance)
+                new_instance['bbox_label'] = label
+                supercat_instances.append(new_instance)
+        return supercat_instances
+
+    def _process_predictions(self, pred_bboxes: np.ndarray,
+                             pred_scores: np.ndarray, pred_labels: np.ndarray,
+                             gt_instances: list,
+                             image_level_labels: np.ndarray) -> tuple:
+        """Process results of the corresponding class of the detection bboxes.
+
+        Note: It will choose to do the following two processing according to
+        the parameters:
+
+        1. Whether to add parent classes of the corresponding class of the
+        detection bboxes.
+
+        2. Whether to ignore the classes that unannotated on that image.
+
+        Args:
+            pred_bboxes (np.ndarray): bboxes predicted by the model
+            pred_scores (np.ndarray): scores predicted by the model
+            pred_labels (np.ndarray): labels predicted by the model
+            gt_instances (list): ground truth annotations
+            image_level_labels (np.ndarray): human-verified image level labels
+
+        Returns:
+            tuple: Processed bboxes, scores, and labels.
+        """
+        processed_bboxes = copy.deepcopy(pred_bboxes)
+        processed_scores = copy.deepcopy(pred_scores)
+        processed_labels = copy.deepcopy(pred_labels)
+        gt_labels = np.array([ins['bbox_label'] for ins in gt_instances],
+                             dtype=np.int64)
+        if image_level_labels is not None:
+            allowed_classes = np.unique(
+                np.append(gt_labels, image_level_labels))
+        else:
+            allowed_classes = np.unique(gt_labels)
+        relation_matrix = self.dataset_meta['RELATION_MATRIX']
+        pred_classes = np.unique(pred_labels)
+        for pred_class in pred_classes:
+            classes = np.where(relation_matrix[pred_class])[0]
+            for cls in classes:
+                if (cls in allowed_classes and cls != pred_class
+                        and self.get_supercategory):
+                    # add super-supercategory preds
+                    index = np.where(pred_labels == pred_class)[0]
+                    processed_scores = np.concatenate(
+                        [processed_scores, pred_scores[index]])
+                    processed_bboxes = np.concatenate(
+                        [processed_bboxes, pred_bboxes[index]])
+                    extend_labels = np.full(index.shape, cls, dtype=np.int64)
+                    processed_labels = np.concatenate(
+                        [processed_labels, extend_labels])
+                elif cls not in allowed_classes and self.filter_labels:
+                    # remove unannotated preds
+                    index = np.where(processed_labels != cls)[0]
+                    processed_scores = processed_scores[index]
+                    processed_bboxes = processed_bboxes[index]
+                    processed_labels = processed_labels[index]
+        return processed_bboxes, processed_scores, processed_labels
+
+    # TODO: data_batch is no longer needed, consider adjusting the
+    #  parameter position
+    def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
+        """Process one batch of data samples and predictions. The processed
+        results should be stored in ``self.results``, which will be used to
+        compute the metrics when all batches have been processed.
+
+        Args:
+            data_batch (dict): A batch of data from the dataloader.
+            data_samples (Sequence[dict]): A batch of data samples that
+                contain annotations and predictions.
+        """
+        for data_sample in data_samples:
+            gt = copy.deepcopy(data_sample)
+            # add super-category instances
+            # TODO: Need to refactor to support LoadAnnotations
+            instances = gt['instances']
+            if self.get_supercategory:
+                supercat_instances = self._get_supercategory_ann(instances)
+                instances.extend(supercat_instances)
+            gt_labels = []
+            gt_bboxes = []
+            is_group_ofs = []
+            for ins in instances:
+                gt_labels.append(ins['bbox_label'])
+                gt_bboxes.append(ins['bbox'])
+                is_group_ofs.append(ins['is_group_of'])
+            ann = dict(
+                labels=np.array(gt_labels, dtype=np.int64),
+                bboxes=np.array(gt_bboxes, dtype=np.float32).reshape((-1, 4)),
+                gt_is_group_ofs=np.array(is_group_ofs, dtype=bool))
+
+            image_level_labels = gt.get('image_level_labels', None)
+            pred = data_sample['pred_instances']
+            pred_bboxes = pred['bboxes'].cpu().numpy()
+            pred_scores = pred['scores'].cpu().numpy()
+            pred_labels = pred['labels'].cpu().numpy()
+
+            pred_bboxes, pred_scores, pred_labels = self._process_predictions(
+                pred_bboxes, pred_scores, pred_labels, instances,
+                image_level_labels)
+
+            dets = []
+            for label in range(len(self.dataset_meta['classes'])):
+                index = np.where(pred_labels == label)[0]
+                pred_bbox_scores = np.hstack(
+                    [pred_bboxes[index], pred_scores[index].reshape((-1, 1))])
+                dets.append(pred_bbox_scores)
+            self.results.append((ann, dets))
+
+    def compute_metrics(self, results: list) -> dict:
+        """Compute the metrics from processed results.
+
+        Args:
+            results (list): The processed results of each batch.
+
+        Returns:
+            dict: The computed metrics. The keys are the names of the metrics,
+            and the values are corresponding results.
+        """
+        logger = MMLogger.get_current_instance()
+        gts, preds = zip(*results)
+        eval_results = OrderedDict()
+        # get dataset type
+        dataset_type = self.dataset_meta.get('dataset_type')
+        if dataset_type not in ['oid_challenge', 'oid_v6']:
+            dataset_type = 'oid_v6'
+            print_log(
+                'Cannot infer dataset type from the length of the'
+                ' classes. Set `oid_v6` as dataset type.',
+                logger='current')
+        mean_aps = []
+        for i, (iou_thr,
+                ioa_thr) in enumerate(zip(self.iou_thrs, self.ioa_thrs)):
+            if self.use_group_of:
+                assert ioa_thr is not None, 'ioa_thr must have value when' \
+                                            ' using group_of in evaluation.'
+            print_log(f'\n{"-" * 15}iou_thr, ioa_thr: {iou_thr}, {ioa_thr}'
+                      f'{"-" * 15}')
+            mean_ap, _ = eval_map(
+                preds,
+                gts,
+                scale_ranges=self.scale_ranges,
+                iou_thr=iou_thr,
+                ioa_thr=ioa_thr,
+                dataset=dataset_type,
+                logger=logger,
+                use_group_of=self.use_group_of)
+
+            mean_aps.append(mean_ap)
+            eval_results[f'AP{int(iou_thr * 100):02d}'] = round(mean_ap, 3)
+        eval_results['mAP'] = sum(mean_aps) / len(mean_aps)
+        return eval_results
diff --git a/mmdetection/mmdet/evaluation/metrics/ov_coco_metric.py b/mmdetection/mmdet/evaluation/metrics/ov_coco_metric.py
new file mode 100644
index 00000000..08cb9025
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/ov_coco_metric.py
@@ -0,0 +1,266 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import itertools
+import os.path as osp
+import tempfile
+from collections import OrderedDict
+from typing import Dict
+
+import numpy as np
+from mmengine.fileio import load
+from mmengine.logging import MMLogger
+from terminaltables import AsciiTable
+
+from mmdet.datasets.api_wrappers import COCO, COCOeval, COCOevalMP
+from mmdet.registry import METRICS
+from .coco_metric import CocoMetric
+
+
+@METRICS.register_module()
+class OVCocoMetric(CocoMetric):
+
+    def compute_metrics(self, results: list) -> Dict[str, float]:
+        """Compute the metrics from processed results.
+
+        Args:
+            results (list): The processed results of each batch.
+
+        Returns:
+            Dict[str, float]: The computed metrics. The keys are the names of
+            the metrics, and the values are corresponding results.
+        """
+        logger: MMLogger = MMLogger.get_current_instance()
+
+        # split gt and prediction list
+        gts, preds = zip(*results)
+
+        tmp_dir = None
+        if self.outfile_prefix is None:
+            tmp_dir = tempfile.TemporaryDirectory()
+            outfile_prefix = osp.join(tmp_dir.name, 'results')
+        else:
+            outfile_prefix = self.outfile_prefix
+
+        if self._coco_api is None:
+            # use converted gt json file to initialize coco api
+            logger.info('Converting ground truth to coco format...')
+            coco_json_path = self.gt_to_coco_json(
+                gt_dicts=gts, outfile_prefix=outfile_prefix)
+            self._coco_api = COCO(coco_json_path)
+
+        # handle lazy init
+        if self.cat_ids is None:
+            self.cat_ids = self._coco_api.get_cat_ids(
+                cat_names=self.dataset_meta['classes'])
+            self.base_cat_ids = self._coco_api.get_cat_ids(
+                cat_names=self.dataset_meta['base_classes'])
+            self.novel_cat_ids = self._coco_api.get_cat_ids(
+                cat_names=self.dataset_meta['novel_classes'])
+
+        if self.img_ids is None:
+            self.img_ids = self._coco_api.get_img_ids()
+
+        # convert predictions to coco format and dump to json file
+        result_files = self.results2json(preds, outfile_prefix)
+
+        eval_results = OrderedDict()
+        if self.format_only:
+            logger.info('results are saved in '
+                        f'{osp.dirname(outfile_prefix)}')
+            return eval_results
+
+        for metric in self.metrics:
+            logger.info(f'Evaluating {metric}...')
+
+            # TODO: May refactor fast_eval_recall to an independent metric?
+            # fast eval recall
+            if metric == 'proposal_fast':
+                ar = self.fast_eval_recall(
+                    preds, self.proposal_nums, self.iou_thrs, logger=logger)
+                log_msg = []
+                for i, num in enumerate(self.proposal_nums):
+                    eval_results[f'AR@{num}'] = ar[i]
+                    log_msg.append(f'\nAR@{num}\t{ar[i]:.4f}')
+                log_msg = ''.join(log_msg)
+                logger.info(log_msg)
+                continue
+
+            # evaluate proposal, bbox and segm
+            iou_type = 'bbox' if metric == 'proposal' else metric
+            if metric not in result_files:
+                raise KeyError(f'{metric} is not in results')
+            try:
+                predictions = load(result_files[metric])
+                if iou_type == 'segm':
+                    # Refer to https://github.com/cocodataset/cocoapi/blob/master/PythonAPI/pycocotools/coco.py#L331  # noqa
+                    # When evaluating mask AP, if the results contain bbox,
+                    # cocoapi will use the box area instead of the mask area
+                    # for calculating the instance area. Though the overall AP
+                    # is not affected, this leads to different
+                    # small/medium/large mask AP results.
+                    for x in predictions:
+                        x.pop('bbox')
+                coco_dt = self._coco_api.loadRes(predictions)
+
+            except IndexError:
+                logger.error(
+                    'The testing results of the whole dataset is empty.')
+                break
+
+            if self.use_mp_eval:
+                coco_eval = COCOevalMP(self._coco_api, coco_dt, iou_type)
+            else:
+                coco_eval = COCOeval(self._coco_api, coco_dt, iou_type)
+
+            coco_eval.params.catIds = self.cat_ids
+            coco_eval.params.imgIds = self.img_ids
+            coco_eval.params.maxDets = list(self.proposal_nums)
+            coco_eval.params.iouThrs = self.iou_thrs
+
+            # mapping of cocoEval.stats
+            coco_metric_names = {
+                'mAP': 0,
+                'mAP_50': 1,
+                'mAP_75': 2,
+                'mAP_s': 3,
+                'mAP_m': 4,
+                'mAP_l': 5,
+                'AR@100': 6,
+                'AR@300': 7,
+                'AR@1000': 8,
+                'AR_s@1000': 9,
+                'AR_m@1000': 10,
+                'AR_l@1000': 11
+            }
+            metric_items = self.metric_items
+            if metric_items is not None:
+                for metric_item in metric_items:
+                    if metric_item not in coco_metric_names:
+                        raise KeyError(
+                            f'metric item "{metric_item}" is not supported')
+
+            if metric == 'proposal':
+                coco_eval.params.useCats = 0
+                coco_eval.evaluate()
+                coco_eval.accumulate()
+                coco_eval.summarize()
+                if metric_items is None:
+                    metric_items = [
+                        'AR@100', 'AR@300', 'AR@1000', 'AR_s@1000',
+                        'AR_m@1000', 'AR_l@1000'
+                    ]
+
+                for item in metric_items:
+                    val = float(
+                        f'{coco_eval.stats[coco_metric_names[item]]:.3f}')
+                    eval_results[item] = val
+            else:
+                coco_eval.evaluate()
+                coco_eval.accumulate()
+                coco_eval.summarize()
+                if self.classwise:  # Compute per-category AP
+                    # Compute per-category AP
+                    # from https://github.com/facebookresearch/detectron2/
+                    precisions = coco_eval.eval['precision']
+                    # precision: (iou, recall, cls, area range, max dets)
+                    assert len(self.cat_ids) == precisions.shape[2]
+
+                    results_per_category = []
+                    for idx, cat_id in enumerate(self.cat_ids):
+                        t = []
+                        # area range index 0: all area ranges
+                        # max dets index -1: typically 100 per image
+                        nm = self._coco_api.loadCats(cat_id)[0]
+                        precision = precisions[:, :, idx, 0, -1]
+                        precision = precision[precision > -1]
+                        if precision.size:
+                            ap = np.mean(precision)
+                        else:
+                            ap = float('nan')
+                        t.append(f'{nm["name"]}')
+                        t.append(f'{round(ap, 3)}')
+                        eval_results[f'{nm["name"]}_precision'] = round(ap, 3)
+
+                        # indexes of IoU  @50 and @75
+                        for iou in [0, 5]:
+                            precision = precisions[iou, :, idx, 0, -1]
+                            precision = precision[precision > -1]
+                            if precision.size:
+                                ap = np.mean(precision)
+                            else:
+                                ap = float('nan')
+                            t.append(f'{round(ap, 3)}')
+
+                        # indexes of area of small, median and large
+                        for area in [1, 2, 3]:
+                            precision = precisions[:, :, idx, area, -1]
+                            precision = precision[precision > -1]
+                            if precision.size:
+                                ap = np.mean(precision)
+                            else:
+                                ap = float('nan')
+                            t.append(f'{round(ap, 3)}')
+                        results_per_category.append(tuple(t))
+
+                    num_columns = len(results_per_category[0])
+                    results_flatten = list(
+                        itertools.chain(*results_per_category))
+                    headers = [
+                        'category', 'mAP', 'mAP_50', 'mAP_75', 'mAP_s',
+                        'mAP_m', 'mAP_l'
+                    ]
+                    results_2d = itertools.zip_longest(*[
+                        results_flatten[i::num_columns]
+                        for i in range(num_columns)
+                    ])
+                    table_data = [headers]
+                    table_data += [result for result in results_2d]
+                    table = AsciiTable(table_data)
+                    logger.info('\n' + table.table)
+
+                # ------------get novel_ap50 and base_ap50---------
+                precisions = coco_eval.eval['precision']
+                assert len(self.cat_ids) == precisions.shape[2]
+                base_inds, novel_inds = [], []
+
+                for idx, catId in enumerate(self.cat_ids):
+                    if catId in self.base_cat_ids:
+                        base_inds.append(idx)
+                    if catId in self.novel_cat_ids:
+                        novel_inds.append(idx)
+
+                base_ap = precisions[:, :, base_inds, 0, -1]
+                novel_ap = precisions[:, :, novel_inds, 0, -1]
+                base_ap50 = precisions[0, :, base_inds, 0, -1]
+                novel_ap50 = precisions[0, :, novel_inds, 0, -1]
+
+                eval_results['base_ap'] = np.mean(
+                    base_ap[base_ap > -1]) if len(
+                        base_ap[base_ap > -1]) else -1
+                eval_results['novel_ap'] = np.mean(
+                    novel_ap[novel_ap > -1]) if len(
+                        novel_ap[novel_ap > -1]) else -1
+                eval_results['base_ap50'] = np.mean(
+                    base_ap50[base_ap50 > -1]) if len(
+                        base_ap50[base_ap50 > -1]) else -1
+                eval_results['novel_ap50'] = np.mean(
+                    novel_ap50[novel_ap50 > -1]) if len(
+                        novel_ap50[novel_ap50 > -1]) else -1
+                # ------------get novel_ap50 and base_ap50---------
+                if metric_items is None:
+                    metric_items = [
+                        'mAP', 'mAP_50', 'mAP_75', 'mAP_s', 'mAP_m', 'mAP_l'
+                    ]
+
+                for metric_item in metric_items:
+                    key = f'{metric}_{metric_item}'
+                    val = coco_eval.stats[coco_metric_names[metric_item]]
+                    eval_results[key] = float(f'{round(val, 3)}')
+
+                ap = coco_eval.stats[:6]
+                logger.info(f'{metric}_mAP_copypaste: {ap[0]:.3f} '
+                            f'{ap[1]:.3f} {ap[2]:.3f} {ap[3]:.3f} '
+                            f'{ap[4]:.3f} {ap[5]:.3f}')
+
+        if tmp_dir is not None:
+            tmp_dir.cleanup()
+        return eval_results
diff --git a/mmdetection/mmdet/evaluation/metrics/refexp_metric.py b/mmdetection/mmdet/evaluation/metrics/refexp_metric.py
new file mode 100644
index 00000000..8bcdf162
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/refexp_metric.py
@@ -0,0 +1,100 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, Optional, Sequence
+
+import numpy as np
+from mmengine.evaluator import BaseMetric
+from mmengine.fileio import get_local_path
+from mmengine.logging import MMLogger
+
+from mmdet.datasets.api_wrappers import COCO
+from mmdet.registry import METRICS
+from ..functional import bbox_overlaps
+
+
+@METRICS.register_module()
+class RefExpMetric(BaseMetric):
+    default_prefix: Optional[str] = 'refexp'
+
+    def __init__(self,
+                 ann_file: Optional[str] = None,
+                 metric: str = 'bbox',
+                 topk=(1, 5, 10),
+                 iou_thrs: float = 0.5,
+                 **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.metric = metric
+        self.topk = topk
+        self.iou_thrs = iou_thrs
+
+        with get_local_path(ann_file) as local_path:
+            self.coco = COCO(local_path)
+
+    def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
+        for data_sample in data_samples:
+            result = dict()
+            pred = data_sample['pred_instances']
+            result['img_id'] = data_sample['img_id']
+            result['bboxes'] = pred['bboxes'].cpu().numpy()
+            result['scores'] = pred['scores'].cpu().numpy()
+            self.results.append(result)
+
+    def compute_metrics(self, results: list) -> Dict[str, float]:
+        logger: MMLogger = MMLogger.get_current_instance()
+
+        dataset2score = {
+            'refcoco': {k: 0.0
+                        for k in self.topk},
+            'refcoco+': {k: 0.0
+                         for k in self.topk},
+            'refcocog': {k: 0.0
+                         for k in self.topk},
+        }
+        dataset2count = {'refcoco': 0.0, 'refcoco+': 0.0, 'refcocog': 0.0}
+
+        for result in results:
+            img_id = result['img_id']
+
+            ann_ids = self.coco.getAnnIds(imgIds=img_id)
+            assert len(ann_ids) == 1
+            img_info = self.coco.loadImgs(img_id)[0]
+            target = self.coco.loadAnns(ann_ids[0])
+
+            target_bbox = target[0]['bbox']
+            converted_bbox = [
+                target_bbox[0],
+                target_bbox[1],
+                target_bbox[2] + target_bbox[0],
+                target_bbox[3] + target_bbox[1],
+            ]
+            iou = bbox_overlaps(result['bboxes'],
+                                np.array(converted_bbox).reshape(-1, 4))
+            for k in self.topk:
+                if max(iou[:k]) >= self.iou_thrs:
+                    dataset2score[img_info['dataset_name']][k] += 1.0
+            dataset2count[img_info['dataset_name']] += 1.0
+
+        for key, value in dataset2score.items():
+            for k in self.topk:
+                try:
+                    value[k] /= dataset2count[key]
+                except Exception as e:
+                    print(e)
+
+        results = {}
+        mean_precision = 0.0
+        for key, value in dataset2score.items():
+            results[key] = sorted([v for k, v in value.items()])
+            mean_precision += sum(results[key])
+            logger.info(
+                f' Dataset: {key} - Precision @ 1, 5, 10: {results[key]}')
+
+        # `mean_precision` key is used for saving the best checkpoint
+        out_results = {'mean_precision': mean_precision / 9.0}
+
+        for i, k in enumerate(self.topk):
+            out_results[f'refcoco_precision@{k}'] = results['refcoco'][i]
+        for i, k in enumerate(self.topk):
+            out_results[f'refcoco+_precision@{k}'] = results['refcoco+'][i]
+        for i, k in enumerate(self.topk):
+            out_results[f'refcocog_precision@{k}'] = results['refcocog'][i]
+        return out_results
diff --git a/mmdetection/mmdet/evaluation/metrics/refseg_metric.py b/mmdetection/mmdet/evaluation/metrics/refseg_metric.py
new file mode 100644
index 00000000..0faee070
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/refseg_metric.py
@@ -0,0 +1,63 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Sequence
+
+import torch
+from mmengine.evaluator import BaseMetric
+
+from mmdet.registry import METRICS
+
+
+@METRICS.register_module()
+class RefSegMetric(BaseMetric):
+    """Referring Expression Segmentation Metric."""
+
+    def __init__(self, metric: Sequence = ('cIoU', 'mIoU'), **kwargs):
+        super().__init__(**kwargs)
+        assert set(metric).issubset(['cIoU', 'mIoU']), \
+            f'Only support cIoU and mIoU, but got {metric}'
+        assert len(metric) > 0, 'metrics should not be empty'
+        self.metrics = metric
+
+    def compute_iou(self, pred_seg: torch.Tensor,
+                    gt_seg: torch.Tensor) -> tuple:
+        overlap = pred_seg & gt_seg
+        union = pred_seg | gt_seg
+        return overlap, union
+
+    def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
+        """Process one batch of data and data_samples.
+
+        The processed results should be stored in ``self.results``, which will
+        be used to compute the metrics when all batches have been processed.
+
+        Args:
+            data_batch (dict): A batch of data from the dataloader.
+            data_samples (Sequence[dict]): A batch of outputs from the model.
+        """
+        for data_sample in data_samples:
+            pred_label = data_sample['pred_instances']['masks'].bool()
+            label = data_sample['gt_masks'].to_tensor(
+                pred_label.dtype, pred_label.device).bool()
+            # calculate iou
+            overlap, union = self.compute_iou(pred_label, label)
+
+            bs = len(pred_label)
+            iou = overlap.reshape(bs, -1).sum(-1) * 1.0 / union.reshape(
+                bs, -1).sum(-1)
+            iou = torch.nan_to_num_(iou, nan=0.0)
+            self.results.append((overlap.sum(), union.sum(), iou.sum(), bs))
+
+    def compute_metrics(self, results: list) -> dict:
+        results = tuple(zip(*results))
+        assert len(results) == 4
+        cum_i = sum(results[0])
+        cum_u = sum(results[1])
+        iou = sum(results[2])
+        seg_total = sum(results[3])
+
+        metrics = {}
+        if 'cIoU' in self.metrics:
+            metrics['cIoU'] = cum_i * 100 / cum_u
+        if 'mIoU' in self.metrics:
+            metrics['mIoU'] = iou * 100 / seg_total
+        return metrics
diff --git a/mmdetection/mmdet/evaluation/metrics/reid_metric.py b/mmdetection/mmdet/evaluation/metrics/reid_metric.py
new file mode 100644
index 00000000..d74df143
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/reid_metric.py
@@ -0,0 +1,138 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Sequence, Union
+
+import numpy as np
+import torch
+from mmengine.evaluator import BaseMetric
+
+from mmdet.registry import METRICS
+
+
+@METRICS.register_module()
+class ReIDMetrics(BaseMetric):
+    """mAP and CMC evaluation metrics for the ReID task.
+
+    Args:
+        metric (str | list[str]): Metrics to be evaluated.
+            Default value is `mAP`.
+        metric_options: (dict, optional): Options for calculating metrics.
+            Allowed keys are 'rank_list' and 'max_rank'. Defaults to None.
+        collect_device (str): Device name used for collecting results from
+            different ranks during distributed training. Must be 'cpu' or
+            'gpu'. Defaults to 'cpu'.
+        prefix (str, optional): The prefix that will be added in the metric
+            names to disambiguate homonymous metrics of different evaluators.
+            If prefix is not provided in the argument, self.default_prefix
+            will be used instead. Default: None
+    """
+    allowed_metrics = ['mAP', 'CMC']
+    default_prefix: Optional[str] = 'reid-metric'
+
+    def __init__(self,
+                 metric: Union[str, Sequence[str]] = 'mAP',
+                 metric_options: Optional[dict] = None,
+                 collect_device: str = 'cpu',
+                 prefix: Optional[str] = None) -> None:
+        super().__init__(collect_device, prefix)
+
+        if isinstance(metric, list):
+            metrics = metric
+        elif isinstance(metric, str):
+            metrics = [metric]
+        else:
+            raise TypeError('metric must be a list or a str.')
+        for metric in metrics:
+            if metric not in self.allowed_metrics:
+                raise KeyError(f'metric {metric} is not supported.')
+        self.metrics = metrics
+
+        self.metric_options = metric_options or dict(
+            rank_list=[1, 5, 10, 20], max_rank=20)
+        for rank in self.metric_options['rank_list']:
+            assert 1 <= rank <= self.metric_options['max_rank']
+
+    def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
+        """Process one batch of data samples and predictions.
+
+        The processed results should be stored in ``self.results``, which will
+        be used to compute the metrics when all batches have been processed.
+
+        Args:
+            data_batch (dict): A batch of data from the dataloader.
+            data_samples (Sequence[dict]): A batch of data samples that
+                contain annotations and predictions.
+        """
+        for data_sample in data_samples:
+            pred_feature = data_sample['pred_feature']
+            assert isinstance(pred_feature, torch.Tensor)
+            gt_label = data_sample.get('gt_label', data_sample['gt_label'])
+            assert isinstance(gt_label['label'], torch.Tensor)
+            result = dict(
+                pred_feature=pred_feature.data.cpu(),
+                gt_label=gt_label['label'].cpu())
+            self.results.append(result)
+
+    def compute_metrics(self, results: list) -> dict:
+        """Compute the metrics from processed results.
+
+        Args:
+            results (list): The processed results of each batch.
+
+        Returns:
+            dict: The computed metrics. The keys are the names of the metrics,
+            and the values are corresponding results.
+        """
+        # NOTICE: don't access `self.results` from the method.
+        metrics = {}
+
+        pids = torch.cat([result['gt_label'] for result in results]).numpy()
+        features = torch.stack([result['pred_feature'] for result in results])
+
+        n, c = features.size()
+        mat = torch.pow(features, 2).sum(dim=1, keepdim=True).expand(n, n)
+        distmat = mat + mat.t()
+        distmat.addmm_(features, features.t(), beta=1, alpha=-2)
+        distmat = distmat.numpy()
+
+        indices = np.argsort(distmat, axis=1)
+        matches = (pids[indices] == pids[:, np.newaxis]).astype(np.int32)
+
+        all_cmc = []
+        all_AP = []
+        num_valid_q = 0.
+        for q_idx in range(n):
+            # remove self
+            raw_cmc = matches[q_idx][1:]
+            if not np.any(raw_cmc):
+                # this condition is true when query identity
+                # does not appear in gallery
+                continue
+
+            cmc = raw_cmc.cumsum()
+            cmc[cmc > 1] = 1
+
+            all_cmc.append(cmc[:self.metric_options['max_rank']])
+            num_valid_q += 1.
+
+            # compute average precision
+            num_rel = raw_cmc.sum()
+            tmp_cmc = raw_cmc.cumsum()
+            tmp_cmc = [x / (i + 1.) for i, x in enumerate(tmp_cmc)]
+            tmp_cmc = np.asarray(tmp_cmc) * raw_cmc
+            AP = tmp_cmc.sum() / num_rel
+            all_AP.append(AP)
+
+        assert num_valid_q > 0, \
+            'Error: all query identities do not appear in gallery'
+
+        all_cmc = np.asarray(all_cmc)
+        all_cmc = all_cmc.sum(0) / num_valid_q
+        mAP = np.mean(all_AP)
+
+        if 'mAP' in self.metrics:
+            metrics['mAP'] = np.around(mAP, decimals=3)
+        if 'CMC' in self.metrics:
+            for rank in self.metric_options['rank_list']:
+                metrics[f'R{rank}'] = np.around(all_cmc[rank - 1], decimals=3)
+
+        return metrics
diff --git a/mmdetection/mmdet/evaluation/metrics/semseg_metric.py b/mmdetection/mmdet/evaluation/metrics/semseg_metric.py
new file mode 100644
index 00000000..3215f678
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/semseg_metric.py
@@ -0,0 +1,279 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+from collections import OrderedDict
+from typing import Dict, Optional, Sequence, Union
+
+import numpy as np
+import torch
+from mmcv import imwrite
+from mmengine.dist import is_main_process
+from mmengine.evaluator import BaseMetric
+from mmengine.logging import MMLogger, print_log
+from mmengine.utils import mkdir_or_exist
+from PIL import Image
+
+try:
+    from prettytable import PrettyTable
+except ImportError:
+    PrettyTable = None
+
+from mmdet.registry import METRICS
+
+
+@METRICS.register_module()
+class SemSegMetric(BaseMetric):
+    """mIoU evaluation metric.
+
+    Args:
+        iou_metrics (list[str] | str): Metrics to be calculated, the options
+            includes 'mIoU', 'mDice' and 'mFscore'.
+        beta (int): Determines the weight of recall in the combined score.
+            Default: 1.
+        collect_device (str): Device name used for collecting results from
+            different ranks during distributed training. Must be 'cpu' or
+            'gpu'. Defaults to 'cpu'.
+        output_dir (str): The directory for output prediction. Defaults to
+            None.
+        format_only (bool): Only format result for results commit without
+            perform evaluation. It is useful when you want to save the result
+            to a specific format and submit it to the test server.
+            Defaults to False.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+        prefix (str, optional): The prefix that will be added in the metric
+            names to disambiguate homonymous metrics of different evaluators.
+            If prefix is not provided in the argument, self.default_prefix
+            will be used instead. Defaults to None.
+    """
+
+    def __init__(self,
+                 iou_metrics: Sequence[str] = ['mIoU'],
+                 beta: int = 1,
+                 collect_device: str = 'cpu',
+                 output_dir: Optional[str] = None,
+                 format_only: bool = False,
+                 backend_args: dict = None,
+                 prefix: Optional[str] = None) -> None:
+        super().__init__(collect_device=collect_device, prefix=prefix)
+
+        if isinstance(iou_metrics, str):
+            iou_metrics = [iou_metrics]
+        if not set(iou_metrics).issubset(set(['mIoU', 'mDice', 'mFscore'])):
+            raise KeyError(f'metrics {iou_metrics} is not supported. '
+                           f'Only supports mIoU/mDice/mFscore.')
+        self.metrics = iou_metrics
+        self.beta = beta
+        self.output_dir = output_dir
+        if self.output_dir and is_main_process():
+            mkdir_or_exist(self.output_dir)
+        self.format_only = format_only
+        self.backend_args = backend_args
+
+    def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
+        """Process one batch of data and data_samples.
+
+        The processed results should be stored in ``self.results``, which will
+        be used to compute the metrics when all batches have been processed.
+
+        Args:
+            data_batch (dict): A batch of data from the dataloader.
+            data_samples (Sequence[dict]): A batch of outputs from the model.
+        """
+        num_classes = len(self.dataset_meta['classes'])
+        for data_sample in data_samples:
+            pred_label = data_sample['pred_sem_seg']['sem_seg'].squeeze()
+            # format_only always for test dataset without ground truth
+            if not self.format_only:
+                label = data_sample['gt_sem_seg']['sem_seg'].squeeze().to(
+                    pred_label)
+                ignore_index = data_sample['pred_sem_seg'].get(
+                    'ignore_index', 255)
+                self.results.append(
+                    self._compute_pred_stats(pred_label, label, num_classes,
+                                             ignore_index))
+
+            # format_result
+            if self.output_dir is not None:
+                basename = osp.splitext(osp.basename(
+                    data_sample['img_path']))[0]
+                png_filename = osp.abspath(
+                    osp.join(self.output_dir, f'{basename}.png'))
+                output_mask = pred_label.cpu().numpy()
+                output = Image.fromarray(output_mask.astype(np.uint8))
+                imwrite(output, png_filename, backend_args=self.backend_args)
+
+    def compute_metrics(self, results: list) -> Dict[str, float]:
+        """Compute the metrics from processed results.
+
+        Args:
+            results (list): The processed results of each batch.
+
+        Returns:
+            Dict[str, float]: The computed metrics. The keys are the names of
+                the metrics, and the values are corresponding results. The key
+                mainly includes aAcc, mIoU, mAcc, mDice, mFscore, mPrecision,
+                mRecall.
+        """
+        logger: MMLogger = MMLogger.get_current_instance()
+        if self.format_only:
+            logger.info(f'results are saved to {osp.dirname(self.output_dir)}')
+            return OrderedDict()
+
+        ret_metrics = self.get_return_metrics(results)
+
+        # summary table
+        ret_metrics_summary = OrderedDict({
+            ret_metric: np.round(np.nanmean(ret_metric_value) * 100, 2)
+            for ret_metric, ret_metric_value in ret_metrics.items()
+        })
+        metrics = dict()
+        for key, val in ret_metrics_summary.items():
+            if key == 'aAcc':
+                metrics[key] = val
+            else:
+                metrics['m' + key] = val
+
+        print_semantic_table(ret_metrics, self.dataset_meta['classes'], logger)
+
+        return metrics
+
+    def _compute_pred_stats(self, pred_label: torch.tensor,
+                            label: torch.tensor, num_classes: int,
+                            ignore_index: int):
+        """Parse semantic segmentation predictions.
+
+        Args:
+            pred_label (torch.tensor): Prediction segmentation map
+                or predict result filename. The shape is (H, W).
+            label (torch.tensor): Ground truth segmentation map
+                or label filename. The shape is (H, W).
+            num_classes (int): Number of categories.
+
+        Returns:
+            torch.Tensor: The intersection of prediction and ground truth
+                histogram on all classes.
+            torch.Tensor: The union of prediction and ground truth histogram on
+                all classes.
+            torch.Tensor: The prediction histogram on all classes.
+            torch.Tensor: The ground truth histogram on all classes.
+        """
+        assert pred_label.shape == label.shape
+        mask = label != ignore_index
+        label, pred_label = label[mask], pred_label[mask]
+
+        intersect = pred_label[pred_label == label]
+        area_intersect = torch.histc(
+            intersect.float(), bins=num_classes, min=0, max=num_classes - 1)
+        area_pred_label = torch.histc(
+            pred_label.float(), bins=num_classes, min=0, max=num_classes - 1)
+        area_label = torch.histc(
+            label.float(), bins=num_classes, min=0, max=num_classes - 1)
+        area_union = area_pred_label + area_label - area_intersect
+        result = dict(
+            area_intersect=area_intersect,
+            area_union=area_union,
+            area_pred_label=area_pred_label,
+            area_label=area_label)
+        return result
+
+    def get_return_metrics(self, results: list) -> dict:
+        """Calculate evaluation metrics.
+
+        Args:
+            results (list): The processed results of each batch.
+
+        Returns:
+            Dict[str, np.ndarray]: per category evaluation metrics,
+                shape (num_classes, ).
+        """
+
+        def f_score(precision, recall, beta=1):
+            """calculate the f-score value.
+
+            Args:
+                precision (float | torch.Tensor): The precision value.
+                recall (float | torch.Tensor): The recall value.
+                beta (int): Determines the weight of recall in the combined
+                    score. Default: 1.
+
+            Returns:
+                [torch.tensor]: The f-score value.
+            """
+            score = (1 + beta**2) * (precision * recall) / (
+                (beta**2 * precision) + recall)
+            return score
+
+        total_area_intersect = sum([r['area_intersect'] for r in results])
+        total_area_union = sum([r['area_union'] for r in results])
+        total_area_pred_label = sum([r['area_pred_label'] for r in results])
+        total_area_label = sum([r['area_label'] for r in results])
+
+        all_acc = total_area_intersect / total_area_label
+        ret_metrics = OrderedDict({'aAcc': all_acc})
+        for metric in self.metrics:
+            if metric == 'mIoU':
+                iou = total_area_intersect / total_area_union
+                acc = total_area_intersect / total_area_label
+                ret_metrics['IoU'] = iou
+                ret_metrics['Acc'] = acc
+            elif metric == 'mDice':
+                dice = 2 * total_area_intersect / (
+                    total_area_pred_label + total_area_label)
+                acc = total_area_intersect / total_area_label
+                ret_metrics['Dice'] = dice
+                ret_metrics['Acc'] = acc
+            elif metric == 'mFscore':
+                precision = total_area_intersect / total_area_pred_label
+                recall = total_area_intersect / total_area_label
+                f_value = torch.tensor([
+                    f_score(x[0], x[1], self.beta)
+                    for x in zip(precision, recall)
+                ])
+                ret_metrics['Fscore'] = f_value
+                ret_metrics['Precision'] = precision
+                ret_metrics['Recall'] = recall
+
+        ret_metrics = {
+            metric: value.cpu().numpy()
+            for metric, value in ret_metrics.items()
+        }
+
+        return ret_metrics
+
+
+def print_semantic_table(
+        results: dict,
+        class_names: list,
+        logger: Optional[Union['MMLogger', str]] = None) -> None:
+    """Print semantic segmentation evaluation results table.
+
+    Args:
+        results (dict): The evaluation results.
+        class_names (list): Class names.
+        logger (MMLogger | str, optional): Logger used for printing.
+            Default: None.
+    """
+    # each class table
+    results.pop('aAcc', None)
+    ret_metrics_class = OrderedDict({
+        ret_metric: np.round(ret_metric_value * 100, 2)
+        for ret_metric, ret_metric_value in results.items()
+    })
+
+    print_log('per class results:', logger)
+    if PrettyTable:
+        class_table_data = PrettyTable()
+        ret_metrics_class.update({'Class': class_names})
+        ret_metrics_class.move_to_end('Class', last=False)
+        for key, val in ret_metrics_class.items():
+            class_table_data.add_column(key, val)
+        print_log('\n' + class_table_data.get_string(), logger=logger)
+    else:
+        logger.warning(
+            '`prettytable` is not installed, for better table format, '
+            'please consider installing it with "pip install prettytable"')
+        print_result = {}
+        for class_name, iou, acc in zip(class_names, ret_metrics_class['IoU'],
+                                        ret_metrics_class['Acc']):
+            print_result[class_name] = {'IoU': iou, 'Acc': acc}
+        print_log(print_result, logger)
diff --git a/mmdetection/mmdet/evaluation/metrics/voc_metric.py b/mmdetection/mmdet/evaluation/metrics/voc_metric.py
new file mode 100644
index 00000000..32d8c075
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/voc_metric.py
@@ -0,0 +1,176 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import warnings
+from collections import OrderedDict
+from typing import List, Optional, Sequence, Union
+
+import numpy as np
+from mmengine.evaluator import BaseMetric
+from mmengine.logging import MMLogger
+
+from mmdet.registry import METRICS
+from ..functional import eval_map, eval_recalls
+
+
+@METRICS.register_module()
+class VOCMetric(BaseMetric):
+    """Pascal VOC evaluation metric.
+
+    Args:
+        iou_thrs (float or List[float]): IoU threshold. Defaults to 0.5.
+        scale_ranges (List[tuple], optional): Scale ranges for evaluating
+            mAP. If not specified, all bounding boxes would be included in
+            evaluation. Defaults to None.
+        metric (str | list[str]): Metrics to be evaluated. Options are
+            'mAP', 'recall'. If is list, the first setting in the list will
+             be used to evaluate metric.
+        proposal_nums (Sequence[int]): Proposal number used for evaluating
+            recalls, such as recall@100, recall@1000.
+            Default: (100, 300, 1000).
+        eval_mode (str): 'area' or '11points', 'area' means calculating the
+            area under precision-recall curve, '11points' means calculating
+            the average precision of recalls at [0, 0.1, ..., 1].
+            The PASCAL VOC2007 defaults to use '11points', while PASCAL
+            VOC2012 defaults to use 'area'.
+        collect_device (str): Device name used for collecting results from
+            different ranks during distributed training. Must be 'cpu' or
+            'gpu'. Defaults to 'cpu'.
+        prefix (str, optional): The prefix that will be added in the metric
+            names to disambiguate homonymous metrics of different evaluators.
+            If prefix is not provided in the argument, self.default_prefix
+            will be used instead. Defaults to None.
+    """
+
+    default_prefix: Optional[str] = 'pascal_voc'
+
+    def __init__(self,
+                 iou_thrs: Union[float, List[float]] = 0.5,
+                 scale_ranges: Optional[List[tuple]] = None,
+                 metric: Union[str, List[str]] = 'mAP',
+                 proposal_nums: Sequence[int] = (100, 300, 1000),
+                 eval_mode: str = '11points',
+                 collect_device: str = 'cpu',
+                 prefix: Optional[str] = None) -> None:
+        super().__init__(collect_device=collect_device, prefix=prefix)
+        self.iou_thrs = [iou_thrs] if isinstance(iou_thrs, float) \
+            else iou_thrs
+        self.scale_ranges = scale_ranges
+        # voc evaluation metrics
+        if not isinstance(metric, str):
+            assert len(metric) == 1
+            metric = metric[0]
+        allowed_metrics = ['recall', 'mAP']
+        if metric not in allowed_metrics:
+            raise KeyError(
+                f"metric should be one of 'recall', 'mAP', but got {metric}.")
+        self.metric = metric
+        self.proposal_nums = proposal_nums
+        assert eval_mode in ['area', '11points'], \
+            'Unrecognized mode, only "area" and "11points" are supported'
+        self.eval_mode = eval_mode
+
+    # TODO: data_batch is no longer needed, consider adjusting the
+    #  parameter position
+    def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
+        """Process one batch of data samples and predictions. The processed
+        results should be stored in ``self.results``, which will be used to
+        compute the metrics when all batches have been processed.
+
+        Args:
+            data_batch (dict): A batch of data from the dataloader.
+            data_samples (Sequence[dict]): A batch of data samples that
+                contain annotations and predictions.
+        """
+        for data_sample in data_samples:
+            gt = copy.deepcopy(data_sample)
+            # TODO: Need to refactor to support LoadAnnotations
+            gt_instances = gt['gt_instances']
+            gt_ignore_instances = gt['ignored_instances']
+            ann = dict(
+                labels=gt_instances['labels'].cpu().numpy(),
+                bboxes=gt_instances['bboxes'].cpu().numpy(),
+                bboxes_ignore=gt_ignore_instances['bboxes'].cpu().numpy(),
+                labels_ignore=gt_ignore_instances['labels'].cpu().numpy())
+
+            pred = data_sample['pred_instances']
+            pred_bboxes = pred['bboxes'].cpu().numpy()
+            pred_scores = pred['scores'].cpu().numpy()
+            pred_labels = pred['labels'].cpu().numpy()
+
+            dets = []
+            for label in range(len(self.dataset_meta['classes'])):
+                index = np.where(pred_labels == label)[0]
+                pred_bbox_scores = np.hstack(
+                    [pred_bboxes[index], pred_scores[index].reshape((-1, 1))])
+                dets.append(pred_bbox_scores)
+
+            self.results.append((ann, dets))
+
+    def compute_metrics(self, results: list) -> dict:
+        """Compute the metrics from processed results.
+
+        Args:
+            results (list): The processed results of each batch.
+
+        Returns:
+            dict: The computed metrics. The keys are the names of the metrics,
+            and the values are corresponding results.
+        """
+        logger: MMLogger = MMLogger.get_current_instance()
+        gts, preds = zip(*results)
+        eval_results = OrderedDict()
+        if self.metric == 'mAP':
+            assert isinstance(self.iou_thrs, list)
+            dataset_type = self.dataset_meta.get('dataset_type')
+            if dataset_type in ['VOC2007', 'VOC2012']:
+                dataset_name = 'voc'
+                if dataset_type == 'VOC2007' and self.eval_mode != '11points':
+                    warnings.warn('Pascal VOC2007 uses `11points` as default '
+                                  'evaluate mode, but you are using '
+                                  f'{self.eval_mode}.')
+                elif dataset_type == 'VOC2012' and self.eval_mode != 'area':
+                    warnings.warn('Pascal VOC2012 uses `area` as default '
+                                  'evaluate mode, but you are using '
+                                  f'{self.eval_mode}.')
+            else:
+                dataset_name = self.dataset_meta['classes']
+
+            mean_aps = []
+            for iou_thr in self.iou_thrs:
+                logger.info(f'\n{"-" * 15}iou_thr: {iou_thr}{"-" * 15}')
+                # Follow the official implementation,
+                # http://host.robots.ox.ac.uk/pascal/VOC/voc2012/VOCdevkit_18-May-2011.tar
+                # we should use the legacy coordinate system in mmdet 1.x,
+                # which means w, h should be computed as 'x2 - x1 + 1` and
+                # `y2 - y1 + 1`
+                mean_ap, _ = eval_map(
+                    preds,
+                    gts,
+                    scale_ranges=self.scale_ranges,
+                    iou_thr=iou_thr,
+                    dataset=dataset_name,
+                    logger=logger,
+                    eval_mode=self.eval_mode,
+                    use_legacy_coordinate=True)
+                mean_aps.append(mean_ap)
+                eval_results[f'AP{int(iou_thr * 100):02d}'] = round(mean_ap, 3)
+            eval_results['mAP'] = sum(mean_aps) / len(mean_aps)
+            eval_results.move_to_end('mAP', last=False)
+        elif self.metric == 'recall':
+            gt_bboxes = [gt['bboxes'] for gt in gts]
+            pr_bboxes = [pred[0] for pred in preds]
+            recalls = eval_recalls(
+                gt_bboxes,
+                pr_bboxes,
+                self.proposal_nums,
+                self.iou_thrs,
+                logger=logger,
+                use_legacy_coordinate=True)
+            for i, num in enumerate(self.proposal_nums):
+                for j, iou_thr in enumerate(self.iou_thrs):
+                    eval_results[f'recall@{num}@{iou_thr}'] = recalls[i, j]
+            if recalls.shape[1] > 1:
+                ar = recalls.mean(axis=1)
+                for i, num in enumerate(self.proposal_nums):
+                    eval_results[f'AR@{num}'] = ar[i]
+        return eval_results
diff --git a/mmdetection/mmdet/evaluation/metrics/youtube_vis_metric.py b/mmdetection/mmdet/evaluation/metrics/youtube_vis_metric.py
new file mode 100644
index 00000000..5abc77a5
--- /dev/null
+++ b/mmdetection/mmdet/evaluation/metrics/youtube_vis_metric.py
@@ -0,0 +1,426 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+import tempfile
+import warnings
+import zipfile
+from collections import OrderedDict, defaultdict
+from typing import Dict, List, Optional, Sequence, Tuple, Union
+
+import mmengine
+import numpy as np
+from mmengine.dist import (all_gather_object, barrier, broadcast_object_list,
+                           is_main_process)
+from mmengine.logging import MMLogger
+
+from mmdet.registry import METRICS
+from mmdet.structures.mask import encode_mask_results
+from ..functional import YTVIS, YTVISeval
+from .base_video_metric import BaseVideoMetric, collect_tracking_results
+
+
+@METRICS.register_module()
+class YouTubeVISMetric(BaseVideoMetric):
+    """mAP evaluation metrics for the VIS task.
+
+    Args:
+        metric (str | list[str]): Metrics to be evaluated.
+            Default value is `youtube_vis_ap`.
+        metric_items (List[str], optional): Metric result names to be
+            recorded in the evaluation result. Defaults to None.
+        outfile_prefix (str | None): The prefix of json files. It includes
+            the file path and the prefix of filename, e.g., "a/b/prefix".
+            If not specified, a temp file will be created. Defaults to None.
+        collect_device (str): Device name used for collecting results from
+            different ranks during distributed training. Must be 'cpu' or
+            'gpu'. Defaults to 'cpu'.
+        prefix (str, optional): The prefix that will be added in the metric
+            names to disambiguate homonyms metrics of different evaluators.
+            If prefix is not provided in the argument, self.default_prefix
+            will be used instead. Default: None
+        format_only (bool): If True, only formatting the results to the
+            official format and not performing evaluation. Defaults to False.
+    """
+
+    default_prefix: Optional[str] = 'youtube_vis'
+
+    def __init__(self,
+                 metric: Union[str, List[str]] = 'youtube_vis_ap',
+                 metric_items: Optional[Sequence[str]] = None,
+                 outfile_prefix: Optional[str] = None,
+                 collect_device: str = 'cpu',
+                 prefix: Optional[str] = None,
+                 format_only: bool = False) -> None:
+        super().__init__(collect_device=collect_device, prefix=prefix)
+        # vis evaluation metrics
+        self.metrics = metric if isinstance(metric, list) else [metric]
+        self.format_only = format_only
+        allowed_metrics = ['youtube_vis_ap']
+        for metric in self.metrics:
+            if metric not in allowed_metrics:
+                raise KeyError(
+                    f"metric should be 'youtube_vis_ap', but got {metric}.")
+
+        self.metric_items = metric_items
+        self.outfile_prefix = outfile_prefix
+        self.per_video_res = []
+        self.categories = []
+        self._vis_meta_info = defaultdict(list)  # record video and image infos
+
+    def process_video(self, data_samples):
+
+        video_length = len(data_samples)
+        for frame_id in range(video_length):
+            result = dict()
+            img_data_sample = data_samples[frame_id].to_dict()
+            pred = img_data_sample['pred_track_instances']
+            video_id = img_data_sample['video_id']
+
+            result['img_id'] = img_data_sample['img_id']
+            result['bboxes'] = pred['bboxes'].cpu().numpy()
+            result['scores'] = pred['scores'].cpu().numpy()
+            result['labels'] = pred['labels'].cpu().numpy()
+            result['instances_id'] = pred['instances_id'].cpu().numpy()
+            # encode mask to RLE
+            assert 'masks' in pred, \
+                'masks must exist in YouTube-VIS metric'
+            result['masks'] = encode_mask_results(
+                pred['masks'].detach().cpu().numpy())
+
+            # parse gt
+            gt = dict()
+            gt['width'] = img_data_sample['ori_shape'][1]
+            gt['height'] = img_data_sample['ori_shape'][0]
+            gt['img_id'] = img_data_sample['img_id']
+            gt['frame_id'] = frame_id
+            gt['video_id'] = video_id
+            gt['video_length'] = video_length
+
+            if 'instances' in img_data_sample:
+                gt['anns'] = img_data_sample['instances']
+            else:
+                gt['anns'] = dict()
+            self.per_video_res.append((result, gt))
+
+        preds, gts = zip(*self.per_video_res)
+        # format the results
+        # we must format gts first to update self._vis_meta_info
+        gt_results = self._format_one_video_gts(gts)
+        pred_results = self._format_one_video_preds(preds)
+        self.per_video_res.clear()
+        # add converted result to the results list
+        self.results.append((pred_results, gt_results))
+
+    def compute_metrics(self, results: List) -> Dict[str, float]:
+        """Compute the metrics from processed results.
+
+        Args:
+            results (List): The processed results of each batch.
+
+        Returns:
+            Dict[str, float]: The computed metrics. The keys are the names of
+            the metrics, and the values are corresponding results.
+        """
+        # split gt and prediction list
+        tmp_pred_results, tmp_gt_results = zip(*results)
+        gt_results = self.format_gts(tmp_gt_results)
+        pred_results = self.format_preds(tmp_pred_results)
+
+        if self.format_only:
+            self.save_pred_results(pred_results)
+            return dict()
+
+        ytvis = YTVIS(gt_results)
+
+        ytvis_dets = ytvis.loadRes(pred_results)
+        vid_ids = ytvis.getVidIds()
+
+        iou_type = metric = 'segm'
+        eval_results = OrderedDict()
+        ytvisEval = YTVISeval(ytvis, ytvis_dets, iou_type)
+        ytvisEval.params.vidIds = vid_ids
+        ytvisEval.evaluate()
+        ytvisEval.accumulate()
+        ytvisEval.summarize()
+
+        coco_metric_names = {
+            'mAP': 0,
+            'mAP_50': 1,
+            'mAP_75': 2,
+            'mAP_s': 3,
+            'mAP_m': 4,
+            'mAP_l': 5,
+            'AR@1': 6,
+            'AR@10': 7,
+            'AR@100': 8,
+            'AR_s@100': 9,
+            'AR_m@100': 10,
+            'AR_l@100': 11
+        }
+        metric_items = self.metric_items
+        if metric_items is not None:
+            for metric_item in metric_items:
+                if metric_item not in coco_metric_names:
+                    raise KeyError(
+                        f'metric item "{metric_item}" is not supported')
+
+        if metric_items is None:
+            metric_items = [
+                'mAP', 'mAP_50', 'mAP_75', 'mAP_s', 'mAP_m', 'mAP_l'
+            ]
+        for metric_item in metric_items:
+            key = f'{metric}_{metric_item}'
+            val = float(
+                f'{ytvisEval.stats[coco_metric_names[metric_item]]:.3f}')
+            eval_results[key] = val
+
+        return eval_results
+
+    def format_gts(self, gts: Tuple[List]) -> dict:
+        """Gather all ground-truth from self.results."""
+        self.categories = [
+            dict(id=id + 1, name=name)
+            for id, name in enumerate(self.dataset_meta['classes'])
+        ]
+        gt_results = dict(
+            categories=self.categories,
+            videos=self._vis_meta_info['videos'],
+            annotations=[])
+        for gt_result in gts:
+            gt_results['annotations'].extend(gt_result)
+        return gt_results
+
+    def format_preds(self, preds: Tuple[List]) -> List:
+        """Gather all predictions from self.results."""
+        pred_results = []
+        for pred_result in preds:
+            pred_results.extend(pred_result)
+        return pred_results
+
+    def _format_one_video_preds(self, pred_dicts: Tuple[dict]) -> List:
+        """Convert the annotation to the format of YouTube-VIS.
+
+        This operation is to make it easier to use the official eval API.
+
+        Args:
+            pred_dicts (Tuple[dict]): Prediction of the dataset.
+
+        Returns:
+            List: The formatted predictions.
+        """
+        # Collate preds scatters (tuple of dict to dict of list)
+        preds = defaultdict(list)
+        for pred in pred_dicts:
+            for key in pred.keys():
+                preds[key].append(pred[key])
+
+        img_infos = self._vis_meta_info['images']
+        vid_infos = self._vis_meta_info['videos']
+        inds = [i for i, _ in enumerate(img_infos) if _['frame_id'] == 0]
+        inds.append(len(img_infos))
+        json_results = []
+        video_id = vid_infos[-1]['id']
+        # collect data for each instances in a video.
+        collect_data = dict()
+        for frame_id, (masks, scores, labels, ids) in enumerate(
+                zip(preds['masks'], preds['scores'], preds['labels'],
+                    preds['instances_id'])):
+
+            assert len(masks) == len(labels)
+            for j, id in enumerate(ids):
+                if id not in collect_data:
+                    collect_data[id] = dict(
+                        category_ids=[], scores=[], segmentations=dict())
+                collect_data[id]['category_ids'].append(labels[j])
+                collect_data[id]['scores'].append(scores[j])
+                if isinstance(masks[j]['counts'], bytes):
+                    masks[j]['counts'] = masks[j]['counts'].decode()
+                collect_data[id]['segmentations'][frame_id] = masks[j]
+
+        # transform the collected data into official format
+        for id, id_data in collect_data.items():
+            output = dict()
+            output['video_id'] = video_id
+            output['score'] = np.array(id_data['scores']).mean().item()
+            # majority voting for sequence category
+            output['category_id'] = np.bincount(
+                np.array(id_data['category_ids'])).argmax().item() + 1
+            output['segmentations'] = []
+            for frame_id in range(inds[-1] - inds[-2]):
+                if frame_id in id_data['segmentations']:
+                    output['segmentations'].append(
+                        id_data['segmentations'][frame_id])
+                else:
+                    output['segmentations'].append(None)
+            json_results.append(output)
+
+        return json_results
+
+    def _format_one_video_gts(self, gt_dicts: Tuple[dict]) -> List:
+        """Convert the annotation to the format of YouTube-VIS.
+
+        This operation is to make it easier to use the official eval API.
+
+        Args:
+            gt_dicts (Tuple[dict]): Ground truth of the dataset.
+
+        Returns:
+            list: The formatted gts.
+        """
+        video_infos = []
+        image_infos = []
+        instance_infos = defaultdict(list)
+        len_videos = dict()  # mapping from instance_id to video_length
+        vis_anns = []
+
+        # get video infos
+        for gt_dict in gt_dicts:
+            frame_id = gt_dict['frame_id']
+            video_id = gt_dict['video_id']
+            img_id = gt_dict['img_id']
+            image_info = dict(
+                id=img_id,
+                width=gt_dict['width'],
+                height=gt_dict['height'],
+                frame_id=frame_id,
+                file_name='')
+            image_infos.append(image_info)
+            if frame_id == 0:
+                video_info = dict(
+                    id=video_id,
+                    width=gt_dict['width'],
+                    height=gt_dict['height'],
+                    file_name='')
+                video_infos.append(video_info)
+
+            for ann in gt_dict['anns']:
+                label = ann['bbox_label']
+                bbox = ann['bbox']
+                instance_id = ann['instance_id']
+                # update video length
+                len_videos[instance_id] = gt_dict['video_length']
+                coco_bbox = [
+                    bbox[0],
+                    bbox[1],
+                    bbox[2] - bbox[0],
+                    bbox[3] - bbox[1],
+                ]
+
+                annotation = dict(
+                    video_id=video_id,
+                    frame_id=frame_id,
+                    bbox=coco_bbox,
+                    instance_id=instance_id,
+                    iscrowd=ann.get('ignore_flag', 0),
+                    category_id=int(label) + 1,
+                    area=coco_bbox[2] * coco_bbox[3])
+                if ann.get('mask', None):
+                    mask = ann['mask']
+                    # area = mask_util.area(mask)
+                    if isinstance(mask, dict) and isinstance(
+                            mask['counts'], bytes):
+                        mask['counts'] = mask['counts'].decode()
+                    annotation['segmentation'] = mask
+
+                instance_infos[instance_id].append(annotation)
+
+        # update vis meta info
+        self._vis_meta_info['images'].extend(image_infos)
+        self._vis_meta_info['videos'].extend(video_infos)
+
+        for instance_id, ann_infos in instance_infos.items():
+            cur_video_len = len_videos[instance_id]
+            segm = [None] * cur_video_len
+            bbox = [None] * cur_video_len
+            area = [None] * cur_video_len
+            # In the official format, no instances are represented by
+            # 'None', however, only images with instances are recorded
+            # in the current annotations, so we need to use 'None' to
+            # initialize these lists.
+            for ann_info in ann_infos:
+                frame_id = ann_info['frame_id']
+                segm[frame_id] = ann_info['segmentation']
+                bbox[frame_id] = ann_info['bbox']
+                area[frame_id] = ann_info['area']
+            instance = dict(
+                category_id=ann_infos[0]['category_id'],
+                segmentations=segm,
+                bboxes=bbox,
+                video_id=ann_infos[0]['video_id'],
+                areas=area,
+                id=instance_id,
+                iscrowd=ann_infos[0]['iscrowd'])
+            vis_anns.append(instance)
+        return vis_anns
+
+    def save_pred_results(self, pred_results: List) -> None:
+        """Save the results to a zip file (standard format for YouTube-VIS
+        Challenge).
+
+        Args:
+            pred_results (list): Testing results of the
+                dataset.
+        """
+        logger: MMLogger = MMLogger.get_current_instance()
+        if self.outfile_prefix is None:
+            tmp_dir = tempfile.TemporaryDirectory()
+            outfile_prefix = osp.join(tmp_dir.name, 'results')
+        else:
+            outfile_prefix = self.outfile_prefix
+        mmengine.dump(pred_results, f'{outfile_prefix}.json')
+        # zip the json file in order to submit to the test server.
+        zip_file_name = f'{outfile_prefix}.submission_file.zip'
+        zf = zipfile.ZipFile(zip_file_name, 'w', zipfile.ZIP_DEFLATED)
+        logger.info(f"zip the 'results.json' into '{zip_file_name}', "
+                    'please submmit the zip file to the test server')
+        zf.write(f'{outfile_prefix}.json', 'results.json')
+        zf.close()
+
+    def evaluate(self, size: int) -> dict:
+        """Evaluate the model performance of the whole dataset after processing
+        all batches.
+
+        Args:
+            size (int): Length of the entire validation dataset.
+
+        Returns:
+            dict: Evaluation metrics dict on the val dataset. The keys are the
+            names of the metrics, and the values are corresponding results.
+        """
+        # wait for all processes to complete prediction.
+        barrier()
+
+        if len(self.results) == 0:
+            warnings.warn(
+                f'{self.__class__.__name__} got empty `self.results`. Please '
+                'ensure that the processed results are properly added into '
+                '`self.results` in `process` method.')
+
+        results = collect_tracking_results(self.results, self.collect_device)
+
+        # gather seq_info
+        gathered_seq_info = all_gather_object(self._vis_meta_info['videos'])
+        all_seq_info = []
+        for _seq_info in gathered_seq_info:
+            all_seq_info.extend(_seq_info)
+        # update self._vis_meta_info
+        self._vis_meta_info = dict(videos=all_seq_info)
+
+        if is_main_process():
+            _metrics = self.compute_metrics(results)  # type: ignore
+            # Add prefix to metric names
+            if self.prefix:
+                _metrics = {
+                    '/'.join((self.prefix, k)): v
+                    for k, v in _metrics.items()
+                }
+            metrics = [_metrics]
+        else:
+            metrics = [None]  # type: ignore
+
+        broadcast_object_list(metrics)
+
+        # reset the results list
+        self.results.clear()
+        # reset the vis_meta_info
+        self._vis_meta_info.clear()
+        return metrics[0]
diff --git a/mmdetection/mmdet/models/__init__.py b/mmdetection/mmdet/models/__init__.py
new file mode 100644
index 00000000..c0a0d5e8
--- /dev/null
+++ b/mmdetection/mmdet/models/__init__.py
@@ -0,0 +1,18 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .backbones import *  # noqa: F401,F403
+from .data_preprocessors import *  # noqa: F401,F403
+from .dense_heads import *  # noqa: F401,F403
+from .detectors import *  # noqa: F401,F403
+from .language_models import *  # noqa: F401,F403
+from .layers import *  # noqa: F401,F403
+from .losses import *  # noqa: F401,F403
+from .mot import *  # noqa: F401,F403
+from .necks import *  # noqa: F401,F403
+from .reid import *  # noqa: F401,F403
+from .roi_heads import *  # noqa: F401,F403
+from .seg_heads import *  # noqa: F401,F403
+from .task_modules import *  # noqa: F401,F403
+from .test_time_augs import *  # noqa: F401,F403
+from .trackers import *  # noqa: F401,F403
+from .tracking_heads import *  # noqa: F401,F403
+from .vis import *  # noqa: F401,F403
diff --git a/mmdetection/mmdet/models/backbones/__init__.py b/mmdetection/mmdet/models/backbones/__init__.py
new file mode 100644
index 00000000..e16ff85f
--- /dev/null
+++ b/mmdetection/mmdet/models/backbones/__init__.py
@@ -0,0 +1,27 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .csp_darknet import CSPDarknet
+from .cspnext import CSPNeXt
+from .darknet import Darknet
+from .detectors_resnet import DetectoRS_ResNet
+from .detectors_resnext import DetectoRS_ResNeXt
+from .efficientnet import EfficientNet
+from .hourglass import HourglassNet
+from .hrnet import HRNet
+from .mobilenet_v2 import MobileNetV2
+from .pvt import PyramidVisionTransformer, PyramidVisionTransformerV2
+from .regnet import RegNet
+from .res2net import Res2Net
+from .resnest import ResNeSt
+from .resnet import ResNet, ResNetV1d
+from .resnext import ResNeXt
+from .ssd_vgg import SSDVGG
+from .swin import SwinTransformer
+from .trident_resnet import TridentResNet
+
+__all__ = [
+    'RegNet', 'ResNet', 'ResNetV1d', 'ResNeXt', 'SSDVGG', 'HRNet',
+    'MobileNetV2', 'Res2Net', 'HourglassNet', 'DetectoRS_ResNet',
+    'DetectoRS_ResNeXt', 'Darknet', 'ResNeSt', 'TridentResNet', 'CSPDarknet',
+    'SwinTransformer', 'PyramidVisionTransformer',
+    'PyramidVisionTransformerV2', 'EfficientNet', 'CSPNeXt'
+]
diff --git a/mmdetection/mmdet/models/backbones/csp_darknet.py b/mmdetection/mmdet/models/backbones/csp_darknet.py
new file mode 100644
index 00000000..a890b486
--- /dev/null
+++ b/mmdetection/mmdet/models/backbones/csp_darknet.py
@@ -0,0 +1,286 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule, DepthwiseSeparableConvModule
+from mmengine.model import BaseModule
+from torch.nn.modules.batchnorm import _BatchNorm
+
+from mmdet.registry import MODELS
+from ..layers import CSPLayer
+
+
+class Focus(nn.Module):
+    """Focus width and height information into channel space.
+
+    Args:
+        in_channels (int): The input channels of this Module.
+        out_channels (int): The output channels of this Module.
+        kernel_size (int): The kernel size of the convolution. Default: 1
+        stride (int): The stride of the convolution. Default: 1
+        conv_cfg (dict): Config dict for convolution layer. Default: None,
+            which means using conv2d.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN', momentum=0.03, eps=0.001).
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='Swish').
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 kernel_size=1,
+                 stride=1,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN', momentum=0.03, eps=0.001),
+                 act_cfg=dict(type='Swish')):
+        super().__init__()
+        self.conv = ConvModule(
+            in_channels * 4,
+            out_channels,
+            kernel_size,
+            stride,
+            padding=(kernel_size - 1) // 2,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+
+    def forward(self, x):
+        # shape of x (b,c,w,h) -> y(b,4c,w/2,h/2)
+        patch_top_left = x[..., ::2, ::2]
+        patch_top_right = x[..., ::2, 1::2]
+        patch_bot_left = x[..., 1::2, ::2]
+        patch_bot_right = x[..., 1::2, 1::2]
+        x = torch.cat(
+            (
+                patch_top_left,
+                patch_bot_left,
+                patch_top_right,
+                patch_bot_right,
+            ),
+            dim=1,
+        )
+        return self.conv(x)
+
+
+class SPPBottleneck(BaseModule):
+    """Spatial pyramid pooling layer used in YOLOv3-SPP.
+
+    Args:
+        in_channels (int): The input channels of this Module.
+        out_channels (int): The output channels of this Module.
+        kernel_sizes (tuple[int]): Sequential of kernel sizes of pooling
+            layers. Default: (5, 9, 13).
+        conv_cfg (dict): Config dict for convolution layer. Default: None,
+            which means using conv2d.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN').
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='Swish').
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 kernel_sizes=(5, 9, 13),
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN', momentum=0.03, eps=0.001),
+                 act_cfg=dict(type='Swish'),
+                 init_cfg=None):
+        super().__init__(init_cfg)
+        mid_channels = in_channels // 2
+        self.conv1 = ConvModule(
+            in_channels,
+            mid_channels,
+            1,
+            stride=1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        self.poolings = nn.ModuleList([
+            nn.MaxPool2d(kernel_size=ks, stride=1, padding=ks // 2)
+            for ks in kernel_sizes
+        ])
+        conv2_channels = mid_channels * (len(kernel_sizes) + 1)
+        self.conv2 = ConvModule(
+            conv2_channels,
+            out_channels,
+            1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        with torch.cuda.amp.autocast(enabled=False):
+            x = torch.cat(
+                [x] + [pooling(x) for pooling in self.poolings], dim=1)
+        x = self.conv2(x)
+        return x
+
+
+@MODELS.register_module()
+class CSPDarknet(BaseModule):
+    """CSP-Darknet backbone used in YOLOv5 and YOLOX.
+
+    Args:
+        arch (str): Architecture of CSP-Darknet, from {P5, P6}.
+            Default: P5.
+        deepen_factor (float): Depth multiplier, multiply number of
+            blocks in CSP layer by this amount. Default: 1.0.
+        widen_factor (float): Width multiplier, multiply number of
+            channels in each layer by this amount. Default: 1.0.
+        out_indices (Sequence[int]): Output from which stages.
+            Default: (2, 3, 4).
+        frozen_stages (int): Stages to be frozen (stop grad and set eval
+            mode). -1 means not freezing any parameters. Default: -1.
+        use_depthwise (bool): Whether to use depthwise separable convolution.
+            Default: False.
+        arch_ovewrite(list): Overwrite default arch settings. Default: None.
+        spp_kernal_sizes: (tuple[int]): Sequential of kernel sizes of SPP
+            layers. Default: (5, 9, 13).
+        conv_cfg (dict): Config dict for convolution layer. Default: None.
+        norm_cfg (dict): Dictionary to construct and config norm layer.
+            Default: dict(type='BN', requires_grad=True).
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='LeakyReLU', negative_slope=0.1).
+        norm_eval (bool): Whether to set norm layers to eval mode, namely,
+            freeze running stats (mean and var). Note: Effect on Batch Norm
+            and its variants only.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    Example:
+        >>> from mmdet.models import CSPDarknet
+        >>> import torch
+        >>> self = CSPDarknet(depth=53)
+        >>> self.eval()
+        >>> inputs = torch.rand(1, 3, 416, 416)
+        >>> level_outputs = self.forward(inputs)
+        >>> for level_out in level_outputs:
+        ...     print(tuple(level_out.shape))
+        ...
+        (1, 256, 52, 52)
+        (1, 512, 26, 26)
+        (1, 1024, 13, 13)
+    """
+    # From left to right:
+    # in_channels, out_channels, num_blocks, add_identity, use_spp
+    arch_settings = {
+        'P5': [[64, 128, 3, True, False], [128, 256, 9, True, False],
+               [256, 512, 9, True, False], [512, 1024, 3, False, True]],
+        'P6': [[64, 128, 3, True, False], [128, 256, 9, True, False],
+               [256, 512, 9, True, False], [512, 768, 3, True, False],
+               [768, 1024, 3, False, True]]
+    }
+
+    def __init__(self,
+                 arch='P5',
+                 deepen_factor=1.0,
+                 widen_factor=1.0,
+                 out_indices=(2, 3, 4),
+                 frozen_stages=-1,
+                 use_depthwise=False,
+                 arch_ovewrite=None,
+                 spp_kernal_sizes=(5, 9, 13),
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN', momentum=0.03, eps=0.001),
+                 act_cfg=dict(type='Swish'),
+                 norm_eval=False,
+                 init_cfg=dict(
+                     type='Kaiming',
+                     layer='Conv2d',
+                     a=math.sqrt(5),
+                     distribution='uniform',
+                     mode='fan_in',
+                     nonlinearity='leaky_relu')):
+        super().__init__(init_cfg)
+        arch_setting = self.arch_settings[arch]
+        if arch_ovewrite:
+            arch_setting = arch_ovewrite
+        assert set(out_indices).issubset(
+            i for i in range(len(arch_setting) + 1))
+        if frozen_stages not in range(-1, len(arch_setting) + 1):
+            raise ValueError('frozen_stages must be in range(-1, '
+                             'len(arch_setting) + 1). But received '
+                             f'{frozen_stages}')
+
+        self.out_indices = out_indices
+        self.frozen_stages = frozen_stages
+        self.use_depthwise = use_depthwise
+        self.norm_eval = norm_eval
+        conv = DepthwiseSeparableConvModule if use_depthwise else ConvModule
+
+        self.stem = Focus(
+            3,
+            int(arch_setting[0][0] * widen_factor),
+            kernel_size=3,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        self.layers = ['stem']
+
+        for i, (in_channels, out_channels, num_blocks, add_identity,
+                use_spp) in enumerate(arch_setting):
+            in_channels = int(in_channels * widen_factor)
+            out_channels = int(out_channels * widen_factor)
+            num_blocks = max(round(num_blocks * deepen_factor), 1)
+            stage = []
+            conv_layer = conv(
+                in_channels,
+                out_channels,
+                3,
+                stride=2,
+                padding=1,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg)
+            stage.append(conv_layer)
+            if use_spp:
+                spp = SPPBottleneck(
+                    out_channels,
+                    out_channels,
+                    kernel_sizes=spp_kernal_sizes,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg)
+                stage.append(spp)
+            csp_layer = CSPLayer(
+                out_channels,
+                out_channels,
+                num_blocks=num_blocks,
+                add_identity=add_identity,
+                use_depthwise=use_depthwise,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg)
+            stage.append(csp_layer)
+            self.add_module(f'stage{i + 1}', nn.Sequential(*stage))
+            self.layers.append(f'stage{i + 1}')
+
+    def _freeze_stages(self):
+        if self.frozen_stages >= 0:
+            for i in range(self.frozen_stages + 1):
+                m = getattr(self, self.layers[i])
+                m.eval()
+                for param in m.parameters():
+                    param.requires_grad = False
+
+    def train(self, mode=True):
+        super(CSPDarknet, self).train(mode)
+        self._freeze_stages()
+        if mode and self.norm_eval:
+            for m in self.modules():
+                if isinstance(m, _BatchNorm):
+                    m.eval()
+
+    def forward(self, x):
+        outs = []
+        for i, layer_name in enumerate(self.layers):
+            layer = getattr(self, layer_name)
+            x = layer(x)
+            if i in self.out_indices:
+                outs.append(x)
+        return tuple(outs)
diff --git a/mmdetection/mmdet/models/backbones/cspnext.py b/mmdetection/mmdet/models/backbones/cspnext.py
new file mode 100644
index 00000000..269725a7
--- /dev/null
+++ b/mmdetection/mmdet/models/backbones/cspnext.py
@@ -0,0 +1,195 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+from typing import Sequence, Tuple
+
+import torch.nn as nn
+from mmcv.cnn import ConvModule, DepthwiseSeparableConvModule
+from mmengine.model import BaseModule
+from torch import Tensor
+from torch.nn.modules.batchnorm import _BatchNorm
+
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from ..layers import CSPLayer
+from .csp_darknet import SPPBottleneck
+
+
+@MODELS.register_module()
+class CSPNeXt(BaseModule):
+    """CSPNeXt backbone used in RTMDet.
+
+    Args:
+        arch (str): Architecture of CSPNeXt, from {P5, P6}.
+            Defaults to P5.
+        expand_ratio (float): Ratio to adjust the number of channels of the
+            hidden layer. Defaults to 0.5.
+        deepen_factor (float): Depth multiplier, multiply number of
+            blocks in CSP layer by this amount. Defaults to 1.0.
+        widen_factor (float): Width multiplier, multiply number of
+            channels in each layer by this amount. Defaults to 1.0.
+        out_indices (Sequence[int]): Output from which stages.
+            Defaults to (2, 3, 4).
+        frozen_stages (int): Stages to be frozen (stop grad and set eval
+            mode). -1 means not freezing any parameters. Defaults to -1.
+        use_depthwise (bool): Whether to use depthwise separable convolution.
+            Defaults to False.
+        arch_ovewrite (list): Overwrite default arch settings.
+            Defaults to None.
+        spp_kernel_sizes: (tuple[int]): Sequential of kernel sizes of SPP
+            layers. Defaults to (5, 9, 13).
+        channel_attention (bool): Whether to add channel attention in each
+            stage. Defaults to True.
+        conv_cfg (:obj:`ConfigDict` or dict, optional): Config dict for
+            convolution layer. Defaults to None.
+        norm_cfg (:obj:`ConfigDict` or dict): Dictionary to construct and
+            config norm layer. Defaults to dict(type='BN', requires_grad=True).
+        act_cfg (:obj:`ConfigDict` or dict): Config dict for activation layer.
+            Defaults to dict(type='SiLU').
+        norm_eval (bool): Whether to set norm layers to eval mode, namely,
+            freeze running stats (mean and var). Note: Effect on Batch Norm
+            and its variants only.
+        init_cfg (:obj:`ConfigDict` or dict or list[dict] or
+            list[:obj:`ConfigDict`]): Initialization config dict.
+    """
+    # From left to right:
+    # in_channels, out_channels, num_blocks, add_identity, use_spp
+    arch_settings = {
+        'P5': [[64, 128, 3, True, False], [128, 256, 6, True, False],
+               [256, 512, 6, True, False], [512, 1024, 3, False, True]],
+        'P6': [[64, 128, 3, True, False], [128, 256, 6, True, False],
+               [256, 512, 6, True, False], [512, 768, 3, True, False],
+               [768, 1024, 3, False, True]]
+    }
+
+    def __init__(
+        self,
+        arch: str = 'P5',
+        deepen_factor: float = 1.0,
+        widen_factor: float = 1.0,
+        out_indices: Sequence[int] = (2, 3, 4),
+        frozen_stages: int = -1,
+        use_depthwise: bool = False,
+        expand_ratio: float = 0.5,
+        arch_ovewrite: dict = None,
+        spp_kernel_sizes: Sequence[int] = (5, 9, 13),
+        channel_attention: bool = True,
+        conv_cfg: OptConfigType = None,
+        norm_cfg: ConfigType = dict(type='BN', momentum=0.03, eps=0.001),
+        act_cfg: ConfigType = dict(type='SiLU'),
+        norm_eval: bool = False,
+        init_cfg: OptMultiConfig = dict(
+            type='Kaiming',
+            layer='Conv2d',
+            a=math.sqrt(5),
+            distribution='uniform',
+            mode='fan_in',
+            nonlinearity='leaky_relu')
+    ) -> None:
+        super().__init__(init_cfg=init_cfg)
+        arch_setting = self.arch_settings[arch]
+        if arch_ovewrite:
+            arch_setting = arch_ovewrite
+        assert set(out_indices).issubset(
+            i for i in range(len(arch_setting) + 1))
+        if frozen_stages not in range(-1, len(arch_setting) + 1):
+            raise ValueError('frozen_stages must be in range(-1, '
+                             'len(arch_setting) + 1). But received '
+                             f'{frozen_stages}')
+
+        self.out_indices = out_indices
+        self.frozen_stages = frozen_stages
+        self.use_depthwise = use_depthwise
+        self.norm_eval = norm_eval
+        conv = DepthwiseSeparableConvModule if use_depthwise else ConvModule
+        self.stem = nn.Sequential(
+            ConvModule(
+                3,
+                int(arch_setting[0][0] * widen_factor // 2),
+                3,
+                padding=1,
+                stride=2,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg),
+            ConvModule(
+                int(arch_setting[0][0] * widen_factor // 2),
+                int(arch_setting[0][0] * widen_factor // 2),
+                3,
+                padding=1,
+                stride=1,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg),
+            ConvModule(
+                int(arch_setting[0][0] * widen_factor // 2),
+                int(arch_setting[0][0] * widen_factor),
+                3,
+                padding=1,
+                stride=1,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg))
+        self.layers = ['stem']
+
+        for i, (in_channels, out_channels, num_blocks, add_identity,
+                use_spp) in enumerate(arch_setting):
+            in_channels = int(in_channels * widen_factor)
+            out_channels = int(out_channels * widen_factor)
+            num_blocks = max(round(num_blocks * deepen_factor), 1)
+            stage = []
+            conv_layer = conv(
+                in_channels,
+                out_channels,
+                3,
+                stride=2,
+                padding=1,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg)
+            stage.append(conv_layer)
+            if use_spp:
+                spp = SPPBottleneck(
+                    out_channels,
+                    out_channels,
+                    kernel_sizes=spp_kernel_sizes,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg)
+                stage.append(spp)
+            csp_layer = CSPLayer(
+                out_channels,
+                out_channels,
+                num_blocks=num_blocks,
+                add_identity=add_identity,
+                use_depthwise=use_depthwise,
+                use_cspnext_block=True,
+                expand_ratio=expand_ratio,
+                channel_attention=channel_attention,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg)
+            stage.append(csp_layer)
+            self.add_module(f'stage{i + 1}', nn.Sequential(*stage))
+            self.layers.append(f'stage{i + 1}')
+
+    def _freeze_stages(self) -> None:
+        if self.frozen_stages >= 0:
+            for i in range(self.frozen_stages + 1):
+                m = getattr(self, self.layers[i])
+                m.eval()
+                for param in m.parameters():
+                    param.requires_grad = False
+
+    def train(self, mode=True) -> None:
+        super().train(mode)
+        self._freeze_stages()
+        if mode and self.norm_eval:
+            for m in self.modules():
+                if isinstance(m, _BatchNorm):
+                    m.eval()
+
+    def forward(self, x: Tuple[Tensor, ...]) -> Tuple[Tensor, ...]:
+        outs = []
+        for i, layer_name in enumerate(self.layers):
+            layer = getattr(self, layer_name)
+            x = layer(x)
+            if i in self.out_indices:
+                outs.append(x)
+        return tuple(outs)
diff --git a/mmdetection/mmdet/models/backbones/darknet.py b/mmdetection/mmdet/models/backbones/darknet.py
new file mode 100644
index 00000000..1d44da1e
--- /dev/null
+++ b/mmdetection/mmdet/models/backbones/darknet.py
@@ -0,0 +1,213 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# Copyright (c) 2019 Western Digital Corporation or its affiliates.
+
+import warnings
+
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule
+from torch.nn.modules.batchnorm import _BatchNorm
+
+from mmdet.registry import MODELS
+
+
+class ResBlock(BaseModule):
+    """The basic residual block used in Darknet. Each ResBlock consists of two
+    ConvModules and the input is added to the final output. Each ConvModule is
+    composed of Conv, BN, and LeakyReLU. In YoloV3 paper, the first convLayer
+    has half of the number of the filters as much as the second convLayer. The
+    first convLayer has filter size of 1x1 and the second one has the filter
+    size of 3x3.
+
+    Args:
+        in_channels (int): The input channels. Must be even.
+        conv_cfg (dict): Config dict for convolution layer. Default: None.
+        norm_cfg (dict): Dictionary to construct and config norm layer.
+            Default: dict(type='BN', requires_grad=True)
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='LeakyReLU', negative_slope=0.1).
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None
+    """
+
+    def __init__(self,
+                 in_channels,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN', requires_grad=True),
+                 act_cfg=dict(type='LeakyReLU', negative_slope=0.1),
+                 init_cfg=None):
+        super(ResBlock, self).__init__(init_cfg)
+        assert in_channels % 2 == 0  # ensure the in_channels is even
+        half_in_channels = in_channels // 2
+
+        # shortcut
+        cfg = dict(conv_cfg=conv_cfg, norm_cfg=norm_cfg, act_cfg=act_cfg)
+
+        self.conv1 = ConvModule(in_channels, half_in_channels, 1, **cfg)
+        self.conv2 = ConvModule(
+            half_in_channels, in_channels, 3, padding=1, **cfg)
+
+    def forward(self, x):
+        residual = x
+        out = self.conv1(x)
+        out = self.conv2(out)
+        out = out + residual
+
+        return out
+
+
+@MODELS.register_module()
+class Darknet(BaseModule):
+    """Darknet backbone.
+
+    Args:
+        depth (int): Depth of Darknet. Currently only support 53.
+        out_indices (Sequence[int]): Output from which stages.
+        frozen_stages (int): Stages to be frozen (stop grad and set eval mode).
+            -1 means not freezing any parameters. Default: -1.
+        conv_cfg (dict): Config dict for convolution layer. Default: None.
+        norm_cfg (dict): Dictionary to construct and config norm layer.
+            Default: dict(type='BN', requires_grad=True)
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='LeakyReLU', negative_slope=0.1).
+        norm_eval (bool): Whether to set norm layers to eval mode, namely,
+            freeze running stats (mean and var). Note: Effect on Batch Norm
+            and its variants only.
+        pretrained (str, optional): model pretrained path. Default: None
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None
+
+    Example:
+        >>> from mmdet.models import Darknet
+        >>> import torch
+        >>> self = Darknet(depth=53)
+        >>> self.eval()
+        >>> inputs = torch.rand(1, 3, 416, 416)
+        >>> level_outputs = self.forward(inputs)
+        >>> for level_out in level_outputs:
+        ...     print(tuple(level_out.shape))
+        ...
+        (1, 256, 52, 52)
+        (1, 512, 26, 26)
+        (1, 1024, 13, 13)
+    """
+
+    # Dict(depth: (layers, channels))
+    arch_settings = {
+        53: ((1, 2, 8, 8, 4), ((32, 64), (64, 128), (128, 256), (256, 512),
+                               (512, 1024)))
+    }
+
+    def __init__(self,
+                 depth=53,
+                 out_indices=(3, 4, 5),
+                 frozen_stages=-1,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN', requires_grad=True),
+                 act_cfg=dict(type='LeakyReLU', negative_slope=0.1),
+                 norm_eval=True,
+                 pretrained=None,
+                 init_cfg=None):
+        super(Darknet, self).__init__(init_cfg)
+        if depth not in self.arch_settings:
+            raise KeyError(f'invalid depth {depth} for darknet')
+
+        self.depth = depth
+        self.out_indices = out_indices
+        self.frozen_stages = frozen_stages
+        self.layers, self.channels = self.arch_settings[depth]
+
+        cfg = dict(conv_cfg=conv_cfg, norm_cfg=norm_cfg, act_cfg=act_cfg)
+
+        self.conv1 = ConvModule(3, 32, 3, padding=1, **cfg)
+
+        self.cr_blocks = ['conv1']
+        for i, n_layers in enumerate(self.layers):
+            layer_name = f'conv_res_block{i + 1}'
+            in_c, out_c = self.channels[i]
+            self.add_module(
+                layer_name,
+                self.make_conv_res_block(in_c, out_c, n_layers, **cfg))
+            self.cr_blocks.append(layer_name)
+
+        self.norm_eval = norm_eval
+
+        assert not (init_cfg and pretrained), \
+            'init_cfg and pretrained cannot be specified at the same time'
+        if isinstance(pretrained, str):
+            warnings.warn('DeprecationWarning: pretrained is deprecated, '
+                          'please use "init_cfg" instead')
+            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
+        elif pretrained is None:
+            if init_cfg is None:
+                self.init_cfg = [
+                    dict(type='Kaiming', layer='Conv2d'),
+                    dict(
+                        type='Constant',
+                        val=1,
+                        layer=['_BatchNorm', 'GroupNorm'])
+                ]
+        else:
+            raise TypeError('pretrained must be a str or None')
+
+    def forward(self, x):
+        outs = []
+        for i, layer_name in enumerate(self.cr_blocks):
+            cr_block = getattr(self, layer_name)
+            x = cr_block(x)
+            if i in self.out_indices:
+                outs.append(x)
+
+        return tuple(outs)
+
+    def _freeze_stages(self):
+        if self.frozen_stages >= 0:
+            for i in range(self.frozen_stages):
+                m = getattr(self, self.cr_blocks[i])
+                m.eval()
+                for param in m.parameters():
+                    param.requires_grad = False
+
+    def train(self, mode=True):
+        super(Darknet, self).train(mode)
+        self._freeze_stages()
+        if mode and self.norm_eval:
+            for m in self.modules():
+                if isinstance(m, _BatchNorm):
+                    m.eval()
+
+    @staticmethod
+    def make_conv_res_block(in_channels,
+                            out_channels,
+                            res_repeat,
+                            conv_cfg=None,
+                            norm_cfg=dict(type='BN', requires_grad=True),
+                            act_cfg=dict(type='LeakyReLU',
+                                         negative_slope=0.1)):
+        """In Darknet backbone, ConvLayer is usually followed by ResBlock. This
+        function will make that. The Conv layers always have 3x3 filters with
+        stride=2. The number of the filters in Conv layer is the same as the
+        out channels of the ResBlock.
+
+        Args:
+            in_channels (int): The number of input channels.
+            out_channels (int): The number of output channels.
+            res_repeat (int): The number of ResBlocks.
+            conv_cfg (dict): Config dict for convolution layer. Default: None.
+            norm_cfg (dict): Dictionary to construct and config norm layer.
+                Default: dict(type='BN', requires_grad=True)
+            act_cfg (dict): Config dict for activation layer.
+                Default: dict(type='LeakyReLU', negative_slope=0.1).
+        """
+
+        cfg = dict(conv_cfg=conv_cfg, norm_cfg=norm_cfg, act_cfg=act_cfg)
+
+        model = nn.Sequential()
+        model.add_module(
+            'conv',
+            ConvModule(
+                in_channels, out_channels, 3, stride=2, padding=1, **cfg))
+        for idx in range(res_repeat):
+            model.add_module('res{}'.format(idx),
+                             ResBlock(out_channels, **cfg))
+        return model
diff --git a/mmdetection/mmdet/models/backbones/detectors_resnet.py b/mmdetection/mmdet/models/backbones/detectors_resnet.py
new file mode 100644
index 00000000..f33424fc
--- /dev/null
+++ b/mmdetection/mmdet/models/backbones/detectors_resnet.py
@@ -0,0 +1,353 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch.nn as nn
+import torch.utils.checkpoint as cp
+from mmcv.cnn import build_conv_layer, build_norm_layer
+from mmengine.logging import MMLogger
+from mmengine.model import Sequential, constant_init, kaiming_init
+from mmengine.runner.checkpoint import load_checkpoint
+from torch.nn.modules.batchnorm import _BatchNorm
+
+from mmdet.registry import MODELS
+from .resnet import BasicBlock
+from .resnet import Bottleneck as _Bottleneck
+from .resnet import ResNet
+
+
+class Bottleneck(_Bottleneck):
+    r"""Bottleneck for the ResNet backbone in `DetectoRS
+    `_.
+
+    This bottleneck allows the users to specify whether to use
+    SAC (Switchable Atrous Convolution) and RFP (Recursive Feature Pyramid).
+
+    Args:
+         inplanes (int): The number of input channels.
+         planes (int): The number of output channels before expansion.
+         rfp_inplanes (int, optional): The number of channels from RFP.
+             Default: None. If specified, an additional conv layer will be
+             added for ``rfp_feat``. Otherwise, the structure is the same as
+             base class.
+         sac (dict, optional): Dictionary to construct SAC. Default: None.
+         init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None
+    """
+    expansion = 4
+
+    def __init__(self,
+                 inplanes,
+                 planes,
+                 rfp_inplanes=None,
+                 sac=None,
+                 init_cfg=None,
+                 **kwargs):
+        super(Bottleneck, self).__init__(
+            inplanes, planes, init_cfg=init_cfg, **kwargs)
+
+        assert sac is None or isinstance(sac, dict)
+        self.sac = sac
+        self.with_sac = sac is not None
+        if self.with_sac:
+            self.conv2 = build_conv_layer(
+                self.sac,
+                planes,
+                planes,
+                kernel_size=3,
+                stride=self.conv2_stride,
+                padding=self.dilation,
+                dilation=self.dilation,
+                bias=False)
+
+        self.rfp_inplanes = rfp_inplanes
+        if self.rfp_inplanes:
+            self.rfp_conv = build_conv_layer(
+                None,
+                self.rfp_inplanes,
+                planes * self.expansion,
+                1,
+                stride=1,
+                bias=True)
+            if init_cfg is None:
+                self.init_cfg = dict(
+                    type='Constant', val=0, override=dict(name='rfp_conv'))
+
+    def rfp_forward(self, x, rfp_feat):
+        """The forward function that also takes the RFP features as input."""
+
+        def _inner_forward(x):
+            identity = x
+
+            out = self.conv1(x)
+            out = self.norm1(out)
+            out = self.relu(out)
+
+            if self.with_plugins:
+                out = self.forward_plugin(out, self.after_conv1_plugin_names)
+
+            out = self.conv2(out)
+            out = self.norm2(out)
+            out = self.relu(out)
+
+            if self.with_plugins:
+                out = self.forward_plugin(out, self.after_conv2_plugin_names)
+
+            out = self.conv3(out)
+            out = self.norm3(out)
+
+            if self.with_plugins:
+                out = self.forward_plugin(out, self.after_conv3_plugin_names)
+
+            if self.downsample is not None:
+                identity = self.downsample(x)
+
+            out += identity
+
+            return out
+
+        if self.with_cp and x.requires_grad:
+            out = cp.checkpoint(_inner_forward, x)
+        else:
+            out = _inner_forward(x)
+
+        if self.rfp_inplanes:
+            rfp_feat = self.rfp_conv(rfp_feat)
+            out = out + rfp_feat
+
+        out = self.relu(out)
+
+        return out
+
+
+class ResLayer(Sequential):
+    """ResLayer to build ResNet style backbone for RPF in detectoRS.
+
+    The difference between this module and base class is that we pass
+    ``rfp_inplanes`` to the first block.
+
+    Args:
+        block (nn.Module): block used to build ResLayer.
+        inplanes (int): inplanes of block.
+        planes (int): planes of block.
+        num_blocks (int): number of blocks.
+        stride (int): stride of the first block. Default: 1
+        avg_down (bool): Use AvgPool instead of stride conv when
+            downsampling in the bottleneck. Default: False
+        conv_cfg (dict): dictionary to construct and config conv layer.
+            Default: None
+        norm_cfg (dict): dictionary to construct and config norm layer.
+            Default: dict(type='BN')
+        downsample_first (bool): Downsample at the first block or last block.
+            False for Hourglass, True for ResNet. Default: True
+        rfp_inplanes (int, optional): The number of channels from RFP.
+            Default: None. If specified, an additional conv layer will be
+            added for ``rfp_feat``. Otherwise, the structure is the same as
+            base class.
+    """
+
+    def __init__(self,
+                 block,
+                 inplanes,
+                 planes,
+                 num_blocks,
+                 stride=1,
+                 avg_down=False,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 downsample_first=True,
+                 rfp_inplanes=None,
+                 **kwargs):
+        self.block = block
+        assert downsample_first, f'downsample_first={downsample_first} is ' \
+                                 'not supported in DetectoRS'
+
+        downsample = None
+        if stride != 1 or inplanes != planes * block.expansion:
+            downsample = []
+            conv_stride = stride
+            if avg_down and stride != 1:
+                conv_stride = 1
+                downsample.append(
+                    nn.AvgPool2d(
+                        kernel_size=stride,
+                        stride=stride,
+                        ceil_mode=True,
+                        count_include_pad=False))
+            downsample.extend([
+                build_conv_layer(
+                    conv_cfg,
+                    inplanes,
+                    planes * block.expansion,
+                    kernel_size=1,
+                    stride=conv_stride,
+                    bias=False),
+                build_norm_layer(norm_cfg, planes * block.expansion)[1]
+            ])
+            downsample = nn.Sequential(*downsample)
+
+        layers = []
+        layers.append(
+            block(
+                inplanes=inplanes,
+                planes=planes,
+                stride=stride,
+                downsample=downsample,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                rfp_inplanes=rfp_inplanes,
+                **kwargs))
+        inplanes = planes * block.expansion
+        for _ in range(1, num_blocks):
+            layers.append(
+                block(
+                    inplanes=inplanes,
+                    planes=planes,
+                    stride=1,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    **kwargs))
+
+        super(ResLayer, self).__init__(*layers)
+
+
+@MODELS.register_module()
+class DetectoRS_ResNet(ResNet):
+    """ResNet backbone for DetectoRS.
+
+    Args:
+        sac (dict, optional): Dictionary to construct SAC (Switchable Atrous
+            Convolution). Default: None.
+        stage_with_sac (list): Which stage to use sac. Default: (False, False,
+            False, False).
+        rfp_inplanes (int, optional): The number of channels from RFP.
+            Default: None. If specified, an additional conv layer will be
+            added for ``rfp_feat``. Otherwise, the structure is the same as
+            base class.
+        output_img (bool): If ``True``, the input image will be inserted into
+            the starting position of output. Default: False.
+    """
+
+    arch_settings = {
+        50: (Bottleneck, (3, 4, 6, 3)),
+        101: (Bottleneck, (3, 4, 23, 3)),
+        152: (Bottleneck, (3, 8, 36, 3))
+    }
+
+    def __init__(self,
+                 sac=None,
+                 stage_with_sac=(False, False, False, False),
+                 rfp_inplanes=None,
+                 output_img=False,
+                 pretrained=None,
+                 init_cfg=None,
+                 **kwargs):
+        assert not (init_cfg and pretrained), \
+            'init_cfg and pretrained cannot be specified at the same time'
+        self.pretrained = pretrained
+        if init_cfg is not None:
+            assert isinstance(init_cfg, dict), \
+                f'init_cfg must be a dict, but got {type(init_cfg)}'
+            if 'type' in init_cfg:
+                assert init_cfg.get('type') == 'Pretrained', \
+                    'Only can initialize module by loading a pretrained model'
+            else:
+                raise KeyError('`init_cfg` must contain the key "type"')
+            self.pretrained = init_cfg.get('checkpoint')
+        self.sac = sac
+        self.stage_with_sac = stage_with_sac
+        self.rfp_inplanes = rfp_inplanes
+        self.output_img = output_img
+        super(DetectoRS_ResNet, self).__init__(**kwargs)
+
+        self.inplanes = self.stem_channels
+        self.res_layers = []
+        for i, num_blocks in enumerate(self.stage_blocks):
+            stride = self.strides[i]
+            dilation = self.dilations[i]
+            dcn = self.dcn if self.stage_with_dcn[i] else None
+            sac = self.sac if self.stage_with_sac[i] else None
+            if self.plugins is not None:
+                stage_plugins = self.make_stage_plugins(self.plugins, i)
+            else:
+                stage_plugins = None
+            planes = self.base_channels * 2**i
+            res_layer = self.make_res_layer(
+                block=self.block,
+                inplanes=self.inplanes,
+                planes=planes,
+                num_blocks=num_blocks,
+                stride=stride,
+                dilation=dilation,
+                style=self.style,
+                avg_down=self.avg_down,
+                with_cp=self.with_cp,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg,
+                dcn=dcn,
+                sac=sac,
+                rfp_inplanes=rfp_inplanes if i > 0 else None,
+                plugins=stage_plugins)
+            self.inplanes = planes * self.block.expansion
+            layer_name = f'layer{i + 1}'
+            self.add_module(layer_name, res_layer)
+            self.res_layers.append(layer_name)
+
+        self._freeze_stages()
+
+    # In order to be properly initialized by RFP
+    def init_weights(self):
+        # Calling this method will cause parameter initialization exception
+        # super(DetectoRS_ResNet, self).init_weights()
+
+        if isinstance(self.pretrained, str):
+            logger = MMLogger.get_current_instance()
+            load_checkpoint(self, self.pretrained, strict=False, logger=logger)
+        elif self.pretrained is None:
+            for m in self.modules():
+                if isinstance(m, nn.Conv2d):
+                    kaiming_init(m)
+                elif isinstance(m, (_BatchNorm, nn.GroupNorm)):
+                    constant_init(m, 1)
+
+            if self.dcn is not None:
+                for m in self.modules():
+                    if isinstance(m, Bottleneck) and hasattr(
+                            m.conv2, 'conv_offset'):
+                        constant_init(m.conv2.conv_offset, 0)
+
+            if self.zero_init_residual:
+                for m in self.modules():
+                    if isinstance(m, Bottleneck):
+                        constant_init(m.norm3, 0)
+                    elif isinstance(m, BasicBlock):
+                        constant_init(m.norm2, 0)
+        else:
+            raise TypeError('pretrained must be a str or None')
+
+    def make_res_layer(self, **kwargs):
+        """Pack all blocks in a stage into a ``ResLayer`` for DetectoRS."""
+        return ResLayer(**kwargs)
+
+    def forward(self, x):
+        """Forward function."""
+        outs = list(super(DetectoRS_ResNet, self).forward(x))
+        if self.output_img:
+            outs.insert(0, x)
+        return tuple(outs)
+
+    def rfp_forward(self, x, rfp_feats):
+        """Forward function for RFP."""
+        if self.deep_stem:
+            x = self.stem(x)
+        else:
+            x = self.conv1(x)
+            x = self.norm1(x)
+            x = self.relu(x)
+        x = self.maxpool(x)
+        outs = []
+        for i, layer_name in enumerate(self.res_layers):
+            res_layer = getattr(self, layer_name)
+            rfp_feat = rfp_feats[i] if i > 0 else None
+            for layer in res_layer:
+                x = layer.rfp_forward(x, rfp_feat)
+            if i in self.out_indices:
+                outs.append(x)
+        return tuple(outs)
diff --git a/mmdetection/mmdet/models/backbones/detectors_resnext.py b/mmdetection/mmdet/models/backbones/detectors_resnext.py
new file mode 100644
index 00000000..4bbd6315
--- /dev/null
+++ b/mmdetection/mmdet/models/backbones/detectors_resnext.py
@@ -0,0 +1,123 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+
+from mmcv.cnn import build_conv_layer, build_norm_layer
+
+from mmdet.registry import MODELS
+from .detectors_resnet import Bottleneck as _Bottleneck
+from .detectors_resnet import DetectoRS_ResNet
+
+
+class Bottleneck(_Bottleneck):
+    expansion = 4
+
+    def __init__(self,
+                 inplanes,
+                 planes,
+                 groups=1,
+                 base_width=4,
+                 base_channels=64,
+                 **kwargs):
+        """Bottleneck block for ResNeXt.
+
+        If style is "pytorch", the stride-two layer is the 3x3 conv layer, if
+        it is "caffe", the stride-two layer is the first 1x1 conv layer.
+        """
+        super(Bottleneck, self).__init__(inplanes, planes, **kwargs)
+
+        if groups == 1:
+            width = self.planes
+        else:
+            width = math.floor(self.planes *
+                               (base_width / base_channels)) * groups
+
+        self.norm1_name, norm1 = build_norm_layer(
+            self.norm_cfg, width, postfix=1)
+        self.norm2_name, norm2 = build_norm_layer(
+            self.norm_cfg, width, postfix=2)
+        self.norm3_name, norm3 = build_norm_layer(
+            self.norm_cfg, self.planes * self.expansion, postfix=3)
+
+        self.conv1 = build_conv_layer(
+            self.conv_cfg,
+            self.inplanes,
+            width,
+            kernel_size=1,
+            stride=self.conv1_stride,
+            bias=False)
+        self.add_module(self.norm1_name, norm1)
+        fallback_on_stride = False
+        self.with_modulated_dcn = False
+        if self.with_dcn:
+            fallback_on_stride = self.dcn.pop('fallback_on_stride', False)
+        if self.with_sac:
+            self.conv2 = build_conv_layer(
+                self.sac,
+                width,
+                width,
+                kernel_size=3,
+                stride=self.conv2_stride,
+                padding=self.dilation,
+                dilation=self.dilation,
+                groups=groups,
+                bias=False)
+        elif not self.with_dcn or fallback_on_stride:
+            self.conv2 = build_conv_layer(
+                self.conv_cfg,
+                width,
+                width,
+                kernel_size=3,
+                stride=self.conv2_stride,
+                padding=self.dilation,
+                dilation=self.dilation,
+                groups=groups,
+                bias=False)
+        else:
+            assert self.conv_cfg is None, 'conv_cfg must be None for DCN'
+            self.conv2 = build_conv_layer(
+                self.dcn,
+                width,
+                width,
+                kernel_size=3,
+                stride=self.conv2_stride,
+                padding=self.dilation,
+                dilation=self.dilation,
+                groups=groups,
+                bias=False)
+
+        self.add_module(self.norm2_name, norm2)
+        self.conv3 = build_conv_layer(
+            self.conv_cfg,
+            width,
+            self.planes * self.expansion,
+            kernel_size=1,
+            bias=False)
+        self.add_module(self.norm3_name, norm3)
+
+
+@MODELS.register_module()
+class DetectoRS_ResNeXt(DetectoRS_ResNet):
+    """ResNeXt backbone for DetectoRS.
+
+    Args:
+        groups (int): The number of groups in ResNeXt.
+        base_width (int): The base width of ResNeXt.
+    """
+
+    arch_settings = {
+        50: (Bottleneck, (3, 4, 6, 3)),
+        101: (Bottleneck, (3, 4, 23, 3)),
+        152: (Bottleneck, (3, 8, 36, 3))
+    }
+
+    def __init__(self, groups=1, base_width=4, **kwargs):
+        self.groups = groups
+        self.base_width = base_width
+        super(DetectoRS_ResNeXt, self).__init__(**kwargs)
+
+    def make_res_layer(self, **kwargs):
+        return super().make_res_layer(
+            groups=self.groups,
+            base_width=self.base_width,
+            base_channels=self.base_channels,
+            **kwargs)
diff --git a/mmdetection/mmdet/models/backbones/efficientnet.py b/mmdetection/mmdet/models/backbones/efficientnet.py
new file mode 100644
index 00000000..8484afe2
--- /dev/null
+++ b/mmdetection/mmdet/models/backbones/efficientnet.py
@@ -0,0 +1,418 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import math
+from functools import partial
+
+import torch
+import torch.nn as nn
+import torch.utils.checkpoint as cp
+from mmcv.cnn.bricks import ConvModule, DropPath
+from mmengine.model import BaseModule, Sequential
+
+from mmdet.registry import MODELS
+from ..layers import InvertedResidual, SELayer
+from ..utils import make_divisible
+
+
+class EdgeResidual(BaseModule):
+    """Edge Residual Block.
+
+    Args:
+        in_channels (int): The input channels of this module.
+        out_channels (int): The output channels of this module.
+        mid_channels (int): The input channels of the second convolution.
+        kernel_size (int): The kernel size of the first convolution.
+            Defaults to 3.
+        stride (int): The stride of the first convolution. Defaults to 1.
+        se_cfg (dict, optional): Config dict for se layer. Defaults to None,
+            which means no se layer.
+        with_residual (bool): Use residual connection. Defaults to True.
+        conv_cfg (dict, optional): Config dict for convolution layer.
+            Defaults to None, which means using conv2d.
+        norm_cfg (dict): Config dict for normalization layer.
+            Defaults to ``dict(type='BN')``.
+        act_cfg (dict): Config dict for activation layer.
+            Defaults to ``dict(type='ReLU')``.
+        drop_path_rate (float): stochastic depth rate. Defaults to 0.
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save some
+            memory while slowing down the training speed. Defaults to False.
+        init_cfg (dict | list[dict], optional): Initialization config dict.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 mid_channels,
+                 kernel_size=3,
+                 stride=1,
+                 se_cfg=None,
+                 with_residual=True,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 drop_path_rate=0.,
+                 with_cp=False,
+                 init_cfg=None,
+                 **kwargs):
+        super(EdgeResidual, self).__init__(init_cfg=init_cfg)
+        assert stride in [1, 2]
+        self.with_cp = with_cp
+        self.drop_path = DropPath(
+            drop_path_rate) if drop_path_rate > 0 else nn.Identity()
+        self.with_se = se_cfg is not None
+        self.with_residual = (
+            stride == 1 and in_channels == out_channels and with_residual)
+
+        if self.with_se:
+            assert isinstance(se_cfg, dict)
+
+        self.conv1 = ConvModule(
+            in_channels=in_channels,
+            out_channels=mid_channels,
+            kernel_size=kernel_size,
+            stride=1,
+            padding=kernel_size // 2,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+
+        if self.with_se:
+            self.se = SELayer(**se_cfg)
+
+        self.conv2 = ConvModule(
+            in_channels=mid_channels,
+            out_channels=out_channels,
+            kernel_size=1,
+            stride=stride,
+            padding=0,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=None)
+
+    def forward(self, x):
+
+        def _inner_forward(x):
+            out = x
+            out = self.conv1(out)
+
+            if self.with_se:
+                out = self.se(out)
+
+            out = self.conv2(out)
+
+            if self.with_residual:
+                return x + self.drop_path(out)
+            else:
+                return out
+
+        if self.with_cp and x.requires_grad:
+            out = cp.checkpoint(_inner_forward, x)
+        else:
+            out = _inner_forward(x)
+
+        return out
+
+
+def model_scaling(layer_setting, arch_setting):
+    """Scaling operation to the layer's parameters according to the
+    arch_setting."""
+    # scale width
+    new_layer_setting = copy.deepcopy(layer_setting)
+    for layer_cfg in new_layer_setting:
+        for block_cfg in layer_cfg:
+            block_cfg[1] = make_divisible(block_cfg[1] * arch_setting[0], 8)
+
+    # scale depth
+    split_layer_setting = [new_layer_setting[0]]
+    for layer_cfg in new_layer_setting[1:-1]:
+        tmp_index = [0]
+        for i in range(len(layer_cfg) - 1):
+            if layer_cfg[i + 1][1] != layer_cfg[i][1]:
+                tmp_index.append(i + 1)
+        tmp_index.append(len(layer_cfg))
+        for i in range(len(tmp_index) - 1):
+            split_layer_setting.append(layer_cfg[tmp_index[i]:tmp_index[i +
+                                                                        1]])
+    split_layer_setting.append(new_layer_setting[-1])
+
+    num_of_layers = [len(layer_cfg) for layer_cfg in split_layer_setting[1:-1]]
+    new_layers = [
+        int(math.ceil(arch_setting[1] * num)) for num in num_of_layers
+    ]
+
+    merge_layer_setting = [split_layer_setting[0]]
+    for i, layer_cfg in enumerate(split_layer_setting[1:-1]):
+        if new_layers[i] <= num_of_layers[i]:
+            tmp_layer_cfg = layer_cfg[:new_layers[i]]
+        else:
+            tmp_layer_cfg = copy.deepcopy(layer_cfg) + [layer_cfg[-1]] * (
+                new_layers[i] - num_of_layers[i])
+        if tmp_layer_cfg[0][3] == 1 and i != 0:
+            merge_layer_setting[-1] += tmp_layer_cfg.copy()
+        else:
+            merge_layer_setting.append(tmp_layer_cfg.copy())
+    merge_layer_setting.append(split_layer_setting[-1])
+
+    return merge_layer_setting
+
+
+@MODELS.register_module()
+class EfficientNet(BaseModule):
+    """EfficientNet backbone.
+
+    Args:
+        arch (str): Architecture of efficientnet. Defaults to b0.
+        out_indices (Sequence[int]): Output from which stages.
+            Defaults to (6, ).
+        frozen_stages (int): Stages to be frozen (all param fixed).
+            Defaults to 0, which means not freezing any parameters.
+        conv_cfg (dict): Config dict for convolution layer.
+            Defaults to None, which means using conv2d.
+        norm_cfg (dict): Config dict for normalization layer.
+            Defaults to dict(type='BN').
+        act_cfg (dict): Config dict for activation layer.
+            Defaults to dict(type='Swish').
+        norm_eval (bool): Whether to set norm layers to eval mode, namely,
+            freeze running stats (mean and var). Note: Effect on Batch Norm
+            and its variants only. Defaults to False.
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save some
+            memory while slowing down the training speed. Defaults to False.
+    """
+
+    # Parameters to build layers.
+    # 'b' represents the architecture of normal EfficientNet family includes
+    # 'b0', 'b1', 'b2', 'b3', 'b4', 'b5', 'b6', 'b7', 'b8'.
+    # 'e' represents the architecture of EfficientNet-EdgeTPU including 'es',
+    # 'em', 'el'.
+    # 6 parameters are needed to construct a layer, From left to right:
+    # - kernel_size: The kernel size of the block
+    # - out_channel: The number of out_channels of the block
+    # - se_ratio: The sequeeze ratio of SELayer.
+    # - stride: The stride of the block
+    # - expand_ratio: The expand_ratio of the mid_channels
+    # - block_type: -1: Not a block, 0: InvertedResidual, 1: EdgeResidual
+    layer_settings = {
+        'b': [[[3, 32, 0, 2, 0, -1]],
+              [[3, 16, 4, 1, 1, 0]],
+              [[3, 24, 4, 2, 6, 0],
+               [3, 24, 4, 1, 6, 0]],
+              [[5, 40, 4, 2, 6, 0],
+               [5, 40, 4, 1, 6, 0]],
+              [[3, 80, 4, 2, 6, 0],
+               [3, 80, 4, 1, 6, 0],
+               [3, 80, 4, 1, 6, 0],
+               [5, 112, 4, 1, 6, 0],
+               [5, 112, 4, 1, 6, 0],
+               [5, 112, 4, 1, 6, 0]],
+              [[5, 192, 4, 2, 6, 0],
+               [5, 192, 4, 1, 6, 0],
+               [5, 192, 4, 1, 6, 0],
+               [5, 192, 4, 1, 6, 0],
+               [3, 320, 4, 1, 6, 0]],
+              [[1, 1280, 0, 1, 0, -1]]
+              ],
+        'e': [[[3, 32, 0, 2, 0, -1]],
+              [[3, 24, 0, 1, 3, 1]],
+              [[3, 32, 0, 2, 8, 1],
+               [3, 32, 0, 1, 8, 1]],
+              [[3, 48, 0, 2, 8, 1],
+               [3, 48, 0, 1, 8, 1],
+               [3, 48, 0, 1, 8, 1],
+               [3, 48, 0, 1, 8, 1]],
+              [[5, 96, 0, 2, 8, 0],
+               [5, 96, 0, 1, 8, 0],
+               [5, 96, 0, 1, 8, 0],
+               [5, 96, 0, 1, 8, 0],
+               [5, 96, 0, 1, 8, 0],
+               [5, 144, 0, 1, 8, 0],
+               [5, 144, 0, 1, 8, 0],
+               [5, 144, 0, 1, 8, 0],
+               [5, 144, 0, 1, 8, 0]],
+              [[5, 192, 0, 2, 8, 0],
+               [5, 192, 0, 1, 8, 0]],
+              [[1, 1280, 0, 1, 0, -1]]
+              ]
+    }  # yapf: disable
+
+    # Parameters to build different kinds of architecture.
+    # From left to right: scaling factor for width, scaling factor for depth,
+    # resolution.
+    arch_settings = {
+        'b0': (1.0, 1.0, 224),
+        'b1': (1.0, 1.1, 240),
+        'b2': (1.1, 1.2, 260),
+        'b3': (1.2, 1.4, 300),
+        'b4': (1.4, 1.8, 380),
+        'b5': (1.6, 2.2, 456),
+        'b6': (1.8, 2.6, 528),
+        'b7': (2.0, 3.1, 600),
+        'b8': (2.2, 3.6, 672),
+        'es': (1.0, 1.0, 224),
+        'em': (1.0, 1.1, 240),
+        'el': (1.2, 1.4, 300)
+    }
+
+    def __init__(self,
+                 arch='b0',
+                 drop_path_rate=0.,
+                 out_indices=(6, ),
+                 frozen_stages=0,
+                 conv_cfg=dict(type='Conv2dAdaptivePadding'),
+                 norm_cfg=dict(type='BN', eps=1e-3),
+                 act_cfg=dict(type='Swish'),
+                 norm_eval=False,
+                 with_cp=False,
+                 init_cfg=[
+                     dict(type='Kaiming', layer='Conv2d'),
+                     dict(
+                         type='Constant',
+                         layer=['_BatchNorm', 'GroupNorm'],
+                         val=1)
+                 ]):
+        super(EfficientNet, self).__init__(init_cfg)
+        assert arch in self.arch_settings, \
+            f'"{arch}" is not one of the arch_settings ' \
+            f'({", ".join(self.arch_settings.keys())})'
+        self.arch_setting = self.arch_settings[arch]
+        self.layer_setting = self.layer_settings[arch[:1]]
+        for index in out_indices:
+            if index not in range(0, len(self.layer_setting)):
+                raise ValueError('the item in out_indices must in '
+                                 f'range(0, {len(self.layer_setting)}). '
+                                 f'But received {index}')
+
+        if frozen_stages not in range(len(self.layer_setting) + 1):
+            raise ValueError('frozen_stages must be in range(0, '
+                             f'{len(self.layer_setting) + 1}). '
+                             f'But received {frozen_stages}')
+        self.drop_path_rate = drop_path_rate
+        self.out_indices = out_indices
+        self.frozen_stages = frozen_stages
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+        self.norm_eval = norm_eval
+        self.with_cp = with_cp
+
+        self.layer_setting = model_scaling(self.layer_setting,
+                                           self.arch_setting)
+        block_cfg_0 = self.layer_setting[0][0]
+        block_cfg_last = self.layer_setting[-1][0]
+        self.in_channels = make_divisible(block_cfg_0[1], 8)
+        self.out_channels = block_cfg_last[1]
+        self.layers = nn.ModuleList()
+        self.layers.append(
+            ConvModule(
+                in_channels=3,
+                out_channels=self.in_channels,
+                kernel_size=block_cfg_0[0],
+                stride=block_cfg_0[3],
+                padding=block_cfg_0[0] // 2,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg))
+        self.make_layer()
+        # Avoid building unused layers in mmdetection.
+        if len(self.layers) < max(self.out_indices) + 1:
+            self.layers.append(
+                ConvModule(
+                    in_channels=self.in_channels,
+                    out_channels=self.out_channels,
+                    kernel_size=block_cfg_last[0],
+                    stride=block_cfg_last[3],
+                    padding=block_cfg_last[0] // 2,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg,
+                    act_cfg=self.act_cfg))
+
+    def make_layer(self):
+        # Without the first and the final conv block.
+        layer_setting = self.layer_setting[1:-1]
+
+        total_num_blocks = sum([len(x) for x in layer_setting])
+        block_idx = 0
+        dpr = [
+            x.item()
+            for x in torch.linspace(0, self.drop_path_rate, total_num_blocks)
+        ]  # stochastic depth decay rule
+
+        for i, layer_cfg in enumerate(layer_setting):
+            # Avoid building unused layers in mmdetection.
+            if i > max(self.out_indices) - 1:
+                break
+            layer = []
+            for i, block_cfg in enumerate(layer_cfg):
+                (kernel_size, out_channels, se_ratio, stride, expand_ratio,
+                 block_type) = block_cfg
+
+                mid_channels = int(self.in_channels * expand_ratio)
+                out_channels = make_divisible(out_channels, 8)
+                if se_ratio <= 0:
+                    se_cfg = None
+                else:
+                    # In mmdetection, the `divisor` is deleted to align
+                    # the logic of SELayer with mmpretrain.
+                    se_cfg = dict(
+                        channels=mid_channels,
+                        ratio=expand_ratio * se_ratio,
+                        act_cfg=(self.act_cfg, dict(type='Sigmoid')))
+                if block_type == 1:  # edge tpu
+                    if i > 0 and expand_ratio == 3:
+                        with_residual = False
+                        expand_ratio = 4
+                    else:
+                        with_residual = True
+                    mid_channels = int(self.in_channels * expand_ratio)
+                    if se_cfg is not None:
+                        # In mmdetection, the `divisor` is deleted to align
+                        # the logic of SELayer with mmpretrain.
+                        se_cfg = dict(
+                            channels=mid_channels,
+                            ratio=se_ratio * expand_ratio,
+                            act_cfg=(self.act_cfg, dict(type='Sigmoid')))
+                    block = partial(EdgeResidual, with_residual=with_residual)
+                else:
+                    block = InvertedResidual
+                layer.append(
+                    block(
+                        in_channels=self.in_channels,
+                        out_channels=out_channels,
+                        mid_channels=mid_channels,
+                        kernel_size=kernel_size,
+                        stride=stride,
+                        se_cfg=se_cfg,
+                        conv_cfg=self.conv_cfg,
+                        norm_cfg=self.norm_cfg,
+                        act_cfg=self.act_cfg,
+                        drop_path_rate=dpr[block_idx],
+                        with_cp=self.with_cp,
+                        # In mmdetection, `with_expand_conv` is set to align
+                        # the logic of InvertedResidual with mmpretrain.
+                        with_expand_conv=(mid_channels != self.in_channels)))
+                self.in_channels = out_channels
+                block_idx += 1
+            self.layers.append(Sequential(*layer))
+
+    def forward(self, x):
+        outs = []
+        for i, layer in enumerate(self.layers):
+            x = layer(x)
+            if i in self.out_indices:
+                outs.append(x)
+
+        return tuple(outs)
+
+    def _freeze_stages(self):
+        for i in range(self.frozen_stages):
+            m = self.layers[i]
+            m.eval()
+            for param in m.parameters():
+                param.requires_grad = False
+
+    def train(self, mode=True):
+        super(EfficientNet, self).train(mode)
+        self._freeze_stages()
+        if mode and self.norm_eval:
+            for m in self.modules():
+                if isinstance(m, nn.BatchNorm2d):
+                    m.eval()
diff --git a/mmdetection/mmdet/models/backbones/hourglass.py b/mmdetection/mmdet/models/backbones/hourglass.py
new file mode 100644
index 00000000..bb58799f
--- /dev/null
+++ b/mmdetection/mmdet/models/backbones/hourglass.py
@@ -0,0 +1,225 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Sequence
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule
+
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptMultiConfig
+from ..layers import ResLayer
+from .resnet import BasicBlock
+
+
+class HourglassModule(BaseModule):
+    """Hourglass Module for HourglassNet backbone.
+
+    Generate module recursively and use BasicBlock as the base unit.
+
+    Args:
+        depth (int): Depth of current HourglassModule.
+        stage_channels (list[int]): Feature channels of sub-modules in current
+            and follow-up HourglassModule.
+        stage_blocks (list[int]): Number of sub-modules stacked in current and
+            follow-up HourglassModule.
+        norm_cfg (ConfigType): Dictionary to construct and config norm layer.
+            Defaults to `dict(type='BN', requires_grad=True)`
+        upsample_cfg (ConfigType): Config dict for interpolate layer.
+            Defaults to `dict(mode='nearest')`
+       init_cfg (dict or ConfigDict, optional): the config to control the
+           initialization.
+    """
+
+    def __init__(self,
+                 depth: int,
+                 stage_channels: List[int],
+                 stage_blocks: List[int],
+                 norm_cfg: ConfigType = dict(type='BN', requires_grad=True),
+                 upsample_cfg: ConfigType = dict(mode='nearest'),
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(init_cfg)
+
+        self.depth = depth
+
+        cur_block = stage_blocks[0]
+        next_block = stage_blocks[1]
+
+        cur_channel = stage_channels[0]
+        next_channel = stage_channels[1]
+
+        self.up1 = ResLayer(
+            BasicBlock, cur_channel, cur_channel, cur_block, norm_cfg=norm_cfg)
+
+        self.low1 = ResLayer(
+            BasicBlock,
+            cur_channel,
+            next_channel,
+            cur_block,
+            stride=2,
+            norm_cfg=norm_cfg)
+
+        if self.depth > 1:
+            self.low2 = HourglassModule(depth - 1, stage_channels[1:],
+                                        stage_blocks[1:])
+        else:
+            self.low2 = ResLayer(
+                BasicBlock,
+                next_channel,
+                next_channel,
+                next_block,
+                norm_cfg=norm_cfg)
+
+        self.low3 = ResLayer(
+            BasicBlock,
+            next_channel,
+            cur_channel,
+            cur_block,
+            norm_cfg=norm_cfg,
+            downsample_first=False)
+
+        self.up2 = F.interpolate
+        self.upsample_cfg = upsample_cfg
+
+    def forward(self, x: torch.Tensor) -> nn.Module:
+        """Forward function."""
+        up1 = self.up1(x)
+        low1 = self.low1(x)
+        low2 = self.low2(low1)
+        low3 = self.low3(low2)
+        # Fixing `scale factor` (e.g. 2) is common for upsampling, but
+        # in some cases the spatial size is mismatched and error will arise.
+        if 'scale_factor' in self.upsample_cfg:
+            up2 = self.up2(low3, **self.upsample_cfg)
+        else:
+            shape = up1.shape[2:]
+            up2 = self.up2(low3, size=shape, **self.upsample_cfg)
+        return up1 + up2
+
+
+@MODELS.register_module()
+class HourglassNet(BaseModule):
+    """HourglassNet backbone.
+
+    Stacked Hourglass Networks for Human Pose Estimation.
+    More details can be found in the `paper
+    `_ .
+
+    Args:
+        downsample_times (int): Downsample times in a HourglassModule.
+        num_stacks (int): Number of HourglassModule modules stacked,
+            1 for Hourglass-52, 2 for Hourglass-104.
+        stage_channels (Sequence[int]): Feature channel of each sub-module in a
+            HourglassModule.
+        stage_blocks (Sequence[int]): Number of sub-modules stacked in a
+            HourglassModule.
+        feat_channel (int): Feature channel of conv after a HourglassModule.
+        norm_cfg (norm_cfg): Dictionary to construct and config norm layer.
+       init_cfg (dict or ConfigDict, optional): the config to control the
+           initialization.
+
+    Example:
+        >>> from mmdet.models import HourglassNet
+        >>> import torch
+        >>> self = HourglassNet()
+        >>> self.eval()
+        >>> inputs = torch.rand(1, 3, 511, 511)
+        >>> level_outputs = self.forward(inputs)
+        >>> for level_output in level_outputs:
+        ...     print(tuple(level_output.shape))
+        (1, 256, 128, 128)
+        (1, 256, 128, 128)
+    """
+
+    def __init__(self,
+                 downsample_times: int = 5,
+                 num_stacks: int = 2,
+                 stage_channels: Sequence = (256, 256, 384, 384, 384, 512),
+                 stage_blocks: Sequence = (2, 2, 2, 2, 2, 4),
+                 feat_channel: int = 256,
+                 norm_cfg: ConfigType = dict(type='BN', requires_grad=True),
+                 init_cfg: OptMultiConfig = None) -> None:
+        assert init_cfg is None, 'To prevent abnormal initialization ' \
+                                 'behavior, init_cfg is not allowed to be set'
+        super().__init__(init_cfg)
+
+        self.num_stacks = num_stacks
+        assert self.num_stacks >= 1
+        assert len(stage_channels) == len(stage_blocks)
+        assert len(stage_channels) > downsample_times
+
+        cur_channel = stage_channels[0]
+
+        self.stem = nn.Sequential(
+            ConvModule(
+                3, cur_channel // 2, 7, padding=3, stride=2,
+                norm_cfg=norm_cfg),
+            ResLayer(
+                BasicBlock,
+                cur_channel // 2,
+                cur_channel,
+                1,
+                stride=2,
+                norm_cfg=norm_cfg))
+
+        self.hourglass_modules = nn.ModuleList([
+            HourglassModule(downsample_times, stage_channels, stage_blocks)
+            for _ in range(num_stacks)
+        ])
+
+        self.inters = ResLayer(
+            BasicBlock,
+            cur_channel,
+            cur_channel,
+            num_stacks - 1,
+            norm_cfg=norm_cfg)
+
+        self.conv1x1s = nn.ModuleList([
+            ConvModule(
+                cur_channel, cur_channel, 1, norm_cfg=norm_cfg, act_cfg=None)
+            for _ in range(num_stacks - 1)
+        ])
+
+        self.out_convs = nn.ModuleList([
+            ConvModule(
+                cur_channel, feat_channel, 3, padding=1, norm_cfg=norm_cfg)
+            for _ in range(num_stacks)
+        ])
+
+        self.remap_convs = nn.ModuleList([
+            ConvModule(
+                feat_channel, cur_channel, 1, norm_cfg=norm_cfg, act_cfg=None)
+            for _ in range(num_stacks - 1)
+        ])
+
+        self.relu = nn.ReLU(inplace=True)
+
+    def init_weights(self) -> None:
+        """Init module weights."""
+        # Training Centripetal Model needs to reset parameters for Conv2d
+        super().init_weights()
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                m.reset_parameters()
+
+    def forward(self, x: torch.Tensor) -> List[torch.Tensor]:
+        """Forward function."""
+        inter_feat = self.stem(x)
+        out_feats = []
+
+        for ind in range(self.num_stacks):
+            single_hourglass = self.hourglass_modules[ind]
+            out_conv = self.out_convs[ind]
+
+            hourglass_feat = single_hourglass(inter_feat)
+            out_feat = out_conv(hourglass_feat)
+            out_feats.append(out_feat)
+
+            if ind < self.num_stacks - 1:
+                inter_feat = self.conv1x1s[ind](
+                    inter_feat) + self.remap_convs[ind](
+                        out_feat)
+                inter_feat = self.inters[ind](self.relu(inter_feat))
+
+        return out_feats
diff --git a/mmdetection/mmdet/models/backbones/hrnet.py b/mmdetection/mmdet/models/backbones/hrnet.py
new file mode 100644
index 00000000..77bd3cc7
--- /dev/null
+++ b/mmdetection/mmdet/models/backbones/hrnet.py
@@ -0,0 +1,589 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+
+import torch.nn as nn
+from mmcv.cnn import build_conv_layer, build_norm_layer
+from mmengine.model import BaseModule, ModuleList, Sequential
+from torch.nn.modules.batchnorm import _BatchNorm
+
+from mmdet.registry import MODELS
+from .resnet import BasicBlock, Bottleneck
+
+
+class HRModule(BaseModule):
+    """High-Resolution Module for HRNet.
+
+    In this module, every branch has 4 BasicBlocks/Bottlenecks. Fusion/Exchange
+    is in this module.
+    """
+
+    def __init__(self,
+                 num_branches,
+                 blocks,
+                 num_blocks,
+                 in_channels,
+                 num_channels,
+                 multiscale_output=True,
+                 with_cp=False,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 block_init_cfg=None,
+                 init_cfg=None):
+        super(HRModule, self).__init__(init_cfg)
+        self.block_init_cfg = block_init_cfg
+        self._check_branches(num_branches, num_blocks, in_channels,
+                             num_channels)
+
+        self.in_channels = in_channels
+        self.num_branches = num_branches
+
+        self.multiscale_output = multiscale_output
+        self.norm_cfg = norm_cfg
+        self.conv_cfg = conv_cfg
+        self.with_cp = with_cp
+        self.branches = self._make_branches(num_branches, blocks, num_blocks,
+                                            num_channels)
+        self.fuse_layers = self._make_fuse_layers()
+        self.relu = nn.ReLU(inplace=False)
+
+    def _check_branches(self, num_branches, num_blocks, in_channels,
+                        num_channels):
+        if num_branches != len(num_blocks):
+            error_msg = f'NUM_BRANCHES({num_branches}) ' \
+                        f'!= NUM_BLOCKS({len(num_blocks)})'
+            raise ValueError(error_msg)
+
+        if num_branches != len(num_channels):
+            error_msg = f'NUM_BRANCHES({num_branches}) ' \
+                        f'!= NUM_CHANNELS({len(num_channels)})'
+            raise ValueError(error_msg)
+
+        if num_branches != len(in_channels):
+            error_msg = f'NUM_BRANCHES({num_branches}) ' \
+                        f'!= NUM_INCHANNELS({len(in_channels)})'
+            raise ValueError(error_msg)
+
+    def _make_one_branch(self,
+                         branch_index,
+                         block,
+                         num_blocks,
+                         num_channels,
+                         stride=1):
+        downsample = None
+        if stride != 1 or \
+                self.in_channels[branch_index] != \
+                num_channels[branch_index] * block.expansion:
+            downsample = nn.Sequential(
+                build_conv_layer(
+                    self.conv_cfg,
+                    self.in_channels[branch_index],
+                    num_channels[branch_index] * block.expansion,
+                    kernel_size=1,
+                    stride=stride,
+                    bias=False),
+                build_norm_layer(self.norm_cfg, num_channels[branch_index] *
+                                 block.expansion)[1])
+
+        layers = []
+        layers.append(
+            block(
+                self.in_channels[branch_index],
+                num_channels[branch_index],
+                stride,
+                downsample=downsample,
+                with_cp=self.with_cp,
+                norm_cfg=self.norm_cfg,
+                conv_cfg=self.conv_cfg,
+                init_cfg=self.block_init_cfg))
+        self.in_channels[branch_index] = \
+            num_channels[branch_index] * block.expansion
+        for i in range(1, num_blocks[branch_index]):
+            layers.append(
+                block(
+                    self.in_channels[branch_index],
+                    num_channels[branch_index],
+                    with_cp=self.with_cp,
+                    norm_cfg=self.norm_cfg,
+                    conv_cfg=self.conv_cfg,
+                    init_cfg=self.block_init_cfg))
+
+        return Sequential(*layers)
+
+    def _make_branches(self, num_branches, block, num_blocks, num_channels):
+        branches = []
+
+        for i in range(num_branches):
+            branches.append(
+                self._make_one_branch(i, block, num_blocks, num_channels))
+
+        return ModuleList(branches)
+
+    def _make_fuse_layers(self):
+        if self.num_branches == 1:
+            return None
+
+        num_branches = self.num_branches
+        in_channels = self.in_channels
+        fuse_layers = []
+        num_out_branches = num_branches if self.multiscale_output else 1
+        for i in range(num_out_branches):
+            fuse_layer = []
+            for j in range(num_branches):
+                if j > i:
+                    fuse_layer.append(
+                        nn.Sequential(
+                            build_conv_layer(
+                                self.conv_cfg,
+                                in_channels[j],
+                                in_channels[i],
+                                kernel_size=1,
+                                stride=1,
+                                padding=0,
+                                bias=False),
+                            build_norm_layer(self.norm_cfg, in_channels[i])[1],
+                            nn.Upsample(
+                                scale_factor=2**(j - i), mode='nearest')))
+                elif j == i:
+                    fuse_layer.append(None)
+                else:
+                    conv_downsamples = []
+                    for k in range(i - j):
+                        if k == i - j - 1:
+                            conv_downsamples.append(
+                                nn.Sequential(
+                                    build_conv_layer(
+                                        self.conv_cfg,
+                                        in_channels[j],
+                                        in_channels[i],
+                                        kernel_size=3,
+                                        stride=2,
+                                        padding=1,
+                                        bias=False),
+                                    build_norm_layer(self.norm_cfg,
+                                                     in_channels[i])[1]))
+                        else:
+                            conv_downsamples.append(
+                                nn.Sequential(
+                                    build_conv_layer(
+                                        self.conv_cfg,
+                                        in_channels[j],
+                                        in_channels[j],
+                                        kernel_size=3,
+                                        stride=2,
+                                        padding=1,
+                                        bias=False),
+                                    build_norm_layer(self.norm_cfg,
+                                                     in_channels[j])[1],
+                                    nn.ReLU(inplace=False)))
+                    fuse_layer.append(nn.Sequential(*conv_downsamples))
+            fuse_layers.append(nn.ModuleList(fuse_layer))
+
+        return nn.ModuleList(fuse_layers)
+
+    def forward(self, x):
+        """Forward function."""
+        if self.num_branches == 1:
+            return [self.branches[0](x[0])]
+
+        for i in range(self.num_branches):
+            x[i] = self.branches[i](x[i])
+
+        x_fuse = []
+        for i in range(len(self.fuse_layers)):
+            y = 0
+            for j in range(self.num_branches):
+                if i == j:
+                    y += x[j]
+                else:
+                    y += self.fuse_layers[i][j](x[j])
+            x_fuse.append(self.relu(y))
+        return x_fuse
+
+
+@MODELS.register_module()
+class HRNet(BaseModule):
+    """HRNet backbone.
+
+    `High-Resolution Representations for Labeling Pixels and Regions
+    arXiv: `_.
+
+    Args:
+        extra (dict): Detailed configuration for each stage of HRNet.
+            There must be 4 stages, the configuration for each stage must have
+            5 keys:
+
+                - num_modules(int): The number of HRModule in this stage.
+                - num_branches(int): The number of branches in the HRModule.
+                - block(str): The type of convolution block.
+                - num_blocks(tuple): The number of blocks in each branch.
+                    The length must be equal to num_branches.
+                - num_channels(tuple): The number of channels in each branch.
+                    The length must be equal to num_branches.
+        in_channels (int): Number of input image channels. Default: 3.
+        conv_cfg (dict): Dictionary to construct and config conv layer.
+        norm_cfg (dict): Dictionary to construct and config norm layer.
+        norm_eval (bool): Whether to set norm layers to eval mode, namely,
+            freeze running stats (mean and var). Note: Effect on Batch Norm
+            and its variants only. Default: True.
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save some
+            memory while slowing down the training speed. Default: False.
+        zero_init_residual (bool): Whether to use zero init for last norm layer
+            in resblocks to let them behave as identity. Default: False.
+        multiscale_output (bool): Whether to output multi-level features
+            produced by multiple branches. If False, only the first level
+            feature will be output. Default: True.
+        pretrained (str, optional): Model pretrained path. Default: None.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+
+    Example:
+        >>> from mmdet.models import HRNet
+        >>> import torch
+        >>> extra = dict(
+        >>>     stage1=dict(
+        >>>         num_modules=1,
+        >>>         num_branches=1,
+        >>>         block='BOTTLENECK',
+        >>>         num_blocks=(4, ),
+        >>>         num_channels=(64, )),
+        >>>     stage2=dict(
+        >>>         num_modules=1,
+        >>>         num_branches=2,
+        >>>         block='BASIC',
+        >>>         num_blocks=(4, 4),
+        >>>         num_channels=(32, 64)),
+        >>>     stage3=dict(
+        >>>         num_modules=4,
+        >>>         num_branches=3,
+        >>>         block='BASIC',
+        >>>         num_blocks=(4, 4, 4),
+        >>>         num_channels=(32, 64, 128)),
+        >>>     stage4=dict(
+        >>>         num_modules=3,
+        >>>         num_branches=4,
+        >>>         block='BASIC',
+        >>>         num_blocks=(4, 4, 4, 4),
+        >>>         num_channels=(32, 64, 128, 256)))
+        >>> self = HRNet(extra, in_channels=1)
+        >>> self.eval()
+        >>> inputs = torch.rand(1, 1, 32, 32)
+        >>> level_outputs = self.forward(inputs)
+        >>> for level_out in level_outputs:
+        ...     print(tuple(level_out.shape))
+        (1, 32, 8, 8)
+        (1, 64, 4, 4)
+        (1, 128, 2, 2)
+        (1, 256, 1, 1)
+    """
+
+    blocks_dict = {'BASIC': BasicBlock, 'BOTTLENECK': Bottleneck}
+
+    def __init__(self,
+                 extra,
+                 in_channels=3,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 norm_eval=True,
+                 with_cp=False,
+                 zero_init_residual=False,
+                 multiscale_output=True,
+                 pretrained=None,
+                 init_cfg=None):
+        super(HRNet, self).__init__(init_cfg)
+
+        self.pretrained = pretrained
+        assert not (init_cfg and pretrained), \
+            'init_cfg and pretrained cannot be specified at the same time'
+        if isinstance(pretrained, str):
+            warnings.warn('DeprecationWarning: pretrained is deprecated, '
+                          'please use "init_cfg" instead')
+            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
+        elif pretrained is None:
+            if init_cfg is None:
+                self.init_cfg = [
+                    dict(type='Kaiming', layer='Conv2d'),
+                    dict(
+                        type='Constant',
+                        val=1,
+                        layer=['_BatchNorm', 'GroupNorm'])
+                ]
+        else:
+            raise TypeError('pretrained must be a str or None')
+
+        # Assert configurations of 4 stages are in extra
+        assert 'stage1' in extra and 'stage2' in extra \
+               and 'stage3' in extra and 'stage4' in extra
+        # Assert whether the length of `num_blocks` and `num_channels` are
+        # equal to `num_branches`
+        for i in range(4):
+            cfg = extra[f'stage{i + 1}']
+            assert len(cfg['num_blocks']) == cfg['num_branches'] and \
+                   len(cfg['num_channels']) == cfg['num_branches']
+
+        self.extra = extra
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.norm_eval = norm_eval
+        self.with_cp = with_cp
+        self.zero_init_residual = zero_init_residual
+
+        # stem net
+        self.norm1_name, norm1 = build_norm_layer(self.norm_cfg, 64, postfix=1)
+        self.norm2_name, norm2 = build_norm_layer(self.norm_cfg, 64, postfix=2)
+
+        self.conv1 = build_conv_layer(
+            self.conv_cfg,
+            in_channels,
+            64,
+            kernel_size=3,
+            stride=2,
+            padding=1,
+            bias=False)
+
+        self.add_module(self.norm1_name, norm1)
+        self.conv2 = build_conv_layer(
+            self.conv_cfg,
+            64,
+            64,
+            kernel_size=3,
+            stride=2,
+            padding=1,
+            bias=False)
+
+        self.add_module(self.norm2_name, norm2)
+        self.relu = nn.ReLU(inplace=True)
+
+        # stage 1
+        self.stage1_cfg = self.extra['stage1']
+        num_channels = self.stage1_cfg['num_channels'][0]
+        block_type = self.stage1_cfg['block']
+        num_blocks = self.stage1_cfg['num_blocks'][0]
+
+        block = self.blocks_dict[block_type]
+        stage1_out_channels = num_channels * block.expansion
+        self.layer1 = self._make_layer(block, 64, num_channels, num_blocks)
+
+        # stage 2
+        self.stage2_cfg = self.extra['stage2']
+        num_channels = self.stage2_cfg['num_channels']
+        block_type = self.stage2_cfg['block']
+
+        block = self.blocks_dict[block_type]
+        num_channels = [channel * block.expansion for channel in num_channels]
+        self.transition1 = self._make_transition_layer([stage1_out_channels],
+                                                       num_channels)
+        self.stage2, pre_stage_channels = self._make_stage(
+            self.stage2_cfg, num_channels)
+
+        # stage 3
+        self.stage3_cfg = self.extra['stage3']
+        num_channels = self.stage3_cfg['num_channels']
+        block_type = self.stage3_cfg['block']
+
+        block = self.blocks_dict[block_type]
+        num_channels = [channel * block.expansion for channel in num_channels]
+        self.transition2 = self._make_transition_layer(pre_stage_channels,
+                                                       num_channels)
+        self.stage3, pre_stage_channels = self._make_stage(
+            self.stage3_cfg, num_channels)
+
+        # stage 4
+        self.stage4_cfg = self.extra['stage4']
+        num_channels = self.stage4_cfg['num_channels']
+        block_type = self.stage4_cfg['block']
+
+        block = self.blocks_dict[block_type]
+        num_channels = [channel * block.expansion for channel in num_channels]
+        self.transition3 = self._make_transition_layer(pre_stage_channels,
+                                                       num_channels)
+        self.stage4, pre_stage_channels = self._make_stage(
+            self.stage4_cfg, num_channels, multiscale_output=multiscale_output)
+
+    @property
+    def norm1(self):
+        """nn.Module: the normalization layer named "norm1" """
+        return getattr(self, self.norm1_name)
+
+    @property
+    def norm2(self):
+        """nn.Module: the normalization layer named "norm2" """
+        return getattr(self, self.norm2_name)
+
+    def _make_transition_layer(self, num_channels_pre_layer,
+                               num_channels_cur_layer):
+        num_branches_cur = len(num_channels_cur_layer)
+        num_branches_pre = len(num_channels_pre_layer)
+
+        transition_layers = []
+        for i in range(num_branches_cur):
+            if i < num_branches_pre:
+                if num_channels_cur_layer[i] != num_channels_pre_layer[i]:
+                    transition_layers.append(
+                        nn.Sequential(
+                            build_conv_layer(
+                                self.conv_cfg,
+                                num_channels_pre_layer[i],
+                                num_channels_cur_layer[i],
+                                kernel_size=3,
+                                stride=1,
+                                padding=1,
+                                bias=False),
+                            build_norm_layer(self.norm_cfg,
+                                             num_channels_cur_layer[i])[1],
+                            nn.ReLU(inplace=True)))
+                else:
+                    transition_layers.append(None)
+            else:
+                conv_downsamples = []
+                for j in range(i + 1 - num_branches_pre):
+                    in_channels = num_channels_pre_layer[-1]
+                    out_channels = num_channels_cur_layer[i] \
+                        if j == i - num_branches_pre else in_channels
+                    conv_downsamples.append(
+                        nn.Sequential(
+                            build_conv_layer(
+                                self.conv_cfg,
+                                in_channels,
+                                out_channels,
+                                kernel_size=3,
+                                stride=2,
+                                padding=1,
+                                bias=False),
+                            build_norm_layer(self.norm_cfg, out_channels)[1],
+                            nn.ReLU(inplace=True)))
+                transition_layers.append(nn.Sequential(*conv_downsamples))
+
+        return nn.ModuleList(transition_layers)
+
+    def _make_layer(self, block, inplanes, planes, blocks, stride=1):
+        downsample = None
+        if stride != 1 or inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                build_conv_layer(
+                    self.conv_cfg,
+                    inplanes,
+                    planes * block.expansion,
+                    kernel_size=1,
+                    stride=stride,
+                    bias=False),
+                build_norm_layer(self.norm_cfg, planes * block.expansion)[1])
+
+        layers = []
+        block_init_cfg = None
+        if self.pretrained is None and not hasattr(
+                self, 'init_cfg') and self.zero_init_residual:
+            if block is BasicBlock:
+                block_init_cfg = dict(
+                    type='Constant', val=0, override=dict(name='norm2'))
+            elif block is Bottleneck:
+                block_init_cfg = dict(
+                    type='Constant', val=0, override=dict(name='norm3'))
+        layers.append(
+            block(
+                inplanes,
+                planes,
+                stride,
+                downsample=downsample,
+                with_cp=self.with_cp,
+                norm_cfg=self.norm_cfg,
+                conv_cfg=self.conv_cfg,
+                init_cfg=block_init_cfg,
+            ))
+        inplanes = planes * block.expansion
+        for i in range(1, blocks):
+            layers.append(
+                block(
+                    inplanes,
+                    planes,
+                    with_cp=self.with_cp,
+                    norm_cfg=self.norm_cfg,
+                    conv_cfg=self.conv_cfg,
+                    init_cfg=block_init_cfg))
+
+        return Sequential(*layers)
+
+    def _make_stage(self, layer_config, in_channels, multiscale_output=True):
+        num_modules = layer_config['num_modules']
+        num_branches = layer_config['num_branches']
+        num_blocks = layer_config['num_blocks']
+        num_channels = layer_config['num_channels']
+        block = self.blocks_dict[layer_config['block']]
+
+        hr_modules = []
+        block_init_cfg = None
+        if self.pretrained is None and not hasattr(
+                self, 'init_cfg') and self.zero_init_residual:
+            if block is BasicBlock:
+                block_init_cfg = dict(
+                    type='Constant', val=0, override=dict(name='norm2'))
+            elif block is Bottleneck:
+                block_init_cfg = dict(
+                    type='Constant', val=0, override=dict(name='norm3'))
+
+        for i in range(num_modules):
+            # multi_scale_output is only used for the last module
+            if not multiscale_output and i == num_modules - 1:
+                reset_multiscale_output = False
+            else:
+                reset_multiscale_output = True
+
+            hr_modules.append(
+                HRModule(
+                    num_branches,
+                    block,
+                    num_blocks,
+                    in_channels,
+                    num_channels,
+                    reset_multiscale_output,
+                    with_cp=self.with_cp,
+                    norm_cfg=self.norm_cfg,
+                    conv_cfg=self.conv_cfg,
+                    block_init_cfg=block_init_cfg))
+
+        return Sequential(*hr_modules), in_channels
+
+    def forward(self, x):
+        """Forward function."""
+        x = self.conv1(x)
+        x = self.norm1(x)
+        x = self.relu(x)
+        x = self.conv2(x)
+        x = self.norm2(x)
+        x = self.relu(x)
+        x = self.layer1(x)
+
+        x_list = []
+        for i in range(self.stage2_cfg['num_branches']):
+            if self.transition1[i] is not None:
+                x_list.append(self.transition1[i](x))
+            else:
+                x_list.append(x)
+        y_list = self.stage2(x_list)
+
+        x_list = []
+        for i in range(self.stage3_cfg['num_branches']):
+            if self.transition2[i] is not None:
+                x_list.append(self.transition2[i](y_list[-1]))
+            else:
+                x_list.append(y_list[i])
+        y_list = self.stage3(x_list)
+
+        x_list = []
+        for i in range(self.stage4_cfg['num_branches']):
+            if self.transition3[i] is not None:
+                x_list.append(self.transition3[i](y_list[-1]))
+            else:
+                x_list.append(y_list[i])
+        y_list = self.stage4(x_list)
+
+        return y_list
+
+    def train(self, mode=True):
+        """Convert the model into training mode will keeping the normalization
+        layer freezed."""
+        super(HRNet, self).train(mode)
+        if mode and self.norm_eval:
+            for m in self.modules():
+                # trick: eval have effect on BatchNorm only
+                if isinstance(m, _BatchNorm):
+                    m.eval()
diff --git a/mmdetection/mmdet/models/backbones/mobilenet_v2.py b/mmdetection/mmdet/models/backbones/mobilenet_v2.py
new file mode 100644
index 00000000..a4fd0519
--- /dev/null
+++ b/mmdetection/mmdet/models/backbones/mobilenet_v2.py
@@ -0,0 +1,198 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule
+from torch.nn.modules.batchnorm import _BatchNorm
+
+from mmdet.registry import MODELS
+from ..layers import InvertedResidual
+from ..utils import make_divisible
+
+
+@MODELS.register_module()
+class MobileNetV2(BaseModule):
+    """MobileNetV2 backbone.
+
+    Args:
+        widen_factor (float): Width multiplier, multiply number of
+            channels in each layer by this amount. Default: 1.0.
+        out_indices (Sequence[int], optional): Output from which stages.
+            Default: (1, 2, 4, 7).
+        frozen_stages (int): Stages to be frozen (all param fixed).
+            Default: -1, which means not freezing any parameters.
+        conv_cfg (dict, optional): Config dict for convolution layer.
+            Default: None, which means using conv2d.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN').
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='ReLU6').
+        norm_eval (bool): Whether to set norm layers to eval mode, namely,
+            freeze running stats (mean and var). Note: Effect on Batch Norm
+            and its variants only. Default: False.
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save some
+            memory while slowing down the training speed. Default: False.
+        pretrained (str, optional): model pretrained path. Default: None
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None
+    """
+
+    # Parameters to build layers. 4 parameters are needed to construct a
+    # layer, from left to right: expand_ratio, channel, num_blocks, stride.
+    arch_settings = [[1, 16, 1, 1], [6, 24, 2, 2], [6, 32, 3, 2],
+                     [6, 64, 4, 2], [6, 96, 3, 1], [6, 160, 3, 2],
+                     [6, 320, 1, 1]]
+
+    def __init__(self,
+                 widen_factor=1.,
+                 out_indices=(1, 2, 4, 7),
+                 frozen_stages=-1,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU6'),
+                 norm_eval=False,
+                 with_cp=False,
+                 pretrained=None,
+                 init_cfg=None):
+        super(MobileNetV2, self).__init__(init_cfg)
+
+        self.pretrained = pretrained
+        assert not (init_cfg and pretrained), \
+            'init_cfg and pretrained cannot be specified at the same time'
+        if isinstance(pretrained, str):
+            warnings.warn('DeprecationWarning: pretrained is deprecated, '
+                          'please use "init_cfg" instead')
+            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
+        elif pretrained is None:
+            if init_cfg is None:
+                self.init_cfg = [
+                    dict(type='Kaiming', layer='Conv2d'),
+                    dict(
+                        type='Constant',
+                        val=1,
+                        layer=['_BatchNorm', 'GroupNorm'])
+                ]
+        else:
+            raise TypeError('pretrained must be a str or None')
+
+        self.widen_factor = widen_factor
+        self.out_indices = out_indices
+        if not set(out_indices).issubset(set(range(0, 8))):
+            raise ValueError('out_indices must be a subset of range'
+                             f'(0, 8). But received {out_indices}')
+
+        if frozen_stages not in range(-1, 8):
+            raise ValueError('frozen_stages must be in range(-1, 8). '
+                             f'But received {frozen_stages}')
+        self.out_indices = out_indices
+        self.frozen_stages = frozen_stages
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+        self.norm_eval = norm_eval
+        self.with_cp = with_cp
+
+        self.in_channels = make_divisible(32 * widen_factor, 8)
+
+        self.conv1 = ConvModule(
+            in_channels=3,
+            out_channels=self.in_channels,
+            kernel_size=3,
+            stride=2,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+
+        self.layers = []
+
+        for i, layer_cfg in enumerate(self.arch_settings):
+            expand_ratio, channel, num_blocks, stride = layer_cfg
+            out_channels = make_divisible(channel * widen_factor, 8)
+            inverted_res_layer = self.make_layer(
+                out_channels=out_channels,
+                num_blocks=num_blocks,
+                stride=stride,
+                expand_ratio=expand_ratio)
+            layer_name = f'layer{i + 1}'
+            self.add_module(layer_name, inverted_res_layer)
+            self.layers.append(layer_name)
+
+        if widen_factor > 1.0:
+            self.out_channel = int(1280 * widen_factor)
+        else:
+            self.out_channel = 1280
+
+        layer = ConvModule(
+            in_channels=self.in_channels,
+            out_channels=self.out_channel,
+            kernel_size=1,
+            stride=1,
+            padding=0,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+        self.add_module('conv2', layer)
+        self.layers.append('conv2')
+
+    def make_layer(self, out_channels, num_blocks, stride, expand_ratio):
+        """Stack InvertedResidual blocks to build a layer for MobileNetV2.
+
+        Args:
+            out_channels (int): out_channels of block.
+            num_blocks (int): number of blocks.
+            stride (int): stride of the first block. Default: 1
+            expand_ratio (int): Expand the number of channels of the
+                hidden layer in InvertedResidual by this ratio. Default: 6.
+        """
+        layers = []
+        for i in range(num_blocks):
+            if i >= 1:
+                stride = 1
+            layers.append(
+                InvertedResidual(
+                    self.in_channels,
+                    out_channels,
+                    mid_channels=int(round(self.in_channels * expand_ratio)),
+                    stride=stride,
+                    with_expand_conv=expand_ratio != 1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg,
+                    act_cfg=self.act_cfg,
+                    with_cp=self.with_cp))
+            self.in_channels = out_channels
+
+        return nn.Sequential(*layers)
+
+    def _freeze_stages(self):
+        if self.frozen_stages >= 0:
+            for param in self.conv1.parameters():
+                param.requires_grad = False
+        for i in range(1, self.frozen_stages + 1):
+            layer = getattr(self, f'layer{i}')
+            layer.eval()
+            for param in layer.parameters():
+                param.requires_grad = False
+
+    def forward(self, x):
+        """Forward function."""
+        x = self.conv1(x)
+        outs = []
+        for i, layer_name in enumerate(self.layers):
+            layer = getattr(self, layer_name)
+            x = layer(x)
+            if i in self.out_indices:
+                outs.append(x)
+        return tuple(outs)
+
+    def train(self, mode=True):
+        """Convert the model into training mode while keep normalization layer
+        frozen."""
+        super(MobileNetV2, self).train(mode)
+        self._freeze_stages()
+        if mode and self.norm_eval:
+            for m in self.modules():
+                # trick: eval have effect on BatchNorm only
+                if isinstance(m, _BatchNorm):
+                    m.eval()
diff --git a/mmdetection/mmdet/models/backbones/pvt.py b/mmdetection/mmdet/models/backbones/pvt.py
new file mode 100644
index 00000000..8b250f63
--- /dev/null
+++ b/mmdetection/mmdet/models/backbones/pvt.py
@@ -0,0 +1,665 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+import warnings
+from collections import OrderedDict
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import Conv2d, build_activation_layer, build_norm_layer
+from mmcv.cnn.bricks.drop import build_dropout
+from mmcv.cnn.bricks.transformer import MultiheadAttention
+from mmengine.logging import MMLogger
+from mmengine.model import (BaseModule, ModuleList, Sequential, constant_init,
+                            normal_init, trunc_normal_init)
+from mmengine.model.weight_init import trunc_normal_
+from mmengine.runner.checkpoint import CheckpointLoader, load_state_dict
+from torch.nn.modules.utils import _pair as to_2tuple
+
+from mmdet.registry import MODELS
+from ..layers import PatchEmbed, nchw_to_nlc, nlc_to_nchw
+
+
+class MixFFN(BaseModule):
+    """An implementation of MixFFN of PVT.
+
+    The differences between MixFFN & FFN:
+        1. Use 1X1 Conv to replace Linear layer.
+        2. Introduce 3X3 Depth-wise Conv to encode positional information.
+
+    Args:
+        embed_dims (int): The feature dimension. Same as
+            `MultiheadAttention`.
+        feedforward_channels (int): The hidden dimension of FFNs.
+        act_cfg (dict, optional): The activation config for FFNs.
+            Default: dict(type='GELU').
+        ffn_drop (float, optional): Probability of an element to be
+            zeroed in FFN. Default 0.0.
+        dropout_layer (obj:`ConfigDict`): The dropout_layer used
+            when adding the shortcut.
+            Default: None.
+        use_conv (bool): If True, add 3x3 DWConv between two Linear layers.
+            Defaults: False.
+        init_cfg (obj:`mmengine.ConfigDict`): The Config for initialization.
+            Default: None.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 feedforward_channels,
+                 act_cfg=dict(type='GELU'),
+                 ffn_drop=0.,
+                 dropout_layer=None,
+                 use_conv=False,
+                 init_cfg=None):
+        super(MixFFN, self).__init__(init_cfg=init_cfg)
+
+        self.embed_dims = embed_dims
+        self.feedforward_channels = feedforward_channels
+        self.act_cfg = act_cfg
+        activate = build_activation_layer(act_cfg)
+
+        in_channels = embed_dims
+        fc1 = Conv2d(
+            in_channels=in_channels,
+            out_channels=feedforward_channels,
+            kernel_size=1,
+            stride=1,
+            bias=True)
+        if use_conv:
+            # 3x3 depth wise conv to provide positional encode information
+            dw_conv = Conv2d(
+                in_channels=feedforward_channels,
+                out_channels=feedforward_channels,
+                kernel_size=3,
+                stride=1,
+                padding=(3 - 1) // 2,
+                bias=True,
+                groups=feedforward_channels)
+        fc2 = Conv2d(
+            in_channels=feedforward_channels,
+            out_channels=in_channels,
+            kernel_size=1,
+            stride=1,
+            bias=True)
+        drop = nn.Dropout(ffn_drop)
+        layers = [fc1, activate, drop, fc2, drop]
+        if use_conv:
+            layers.insert(1, dw_conv)
+        self.layers = Sequential(*layers)
+        self.dropout_layer = build_dropout(
+            dropout_layer) if dropout_layer else torch.nn.Identity()
+
+    def forward(self, x, hw_shape, identity=None):
+        out = nlc_to_nchw(x, hw_shape)
+        out = self.layers(out)
+        out = nchw_to_nlc(out)
+        if identity is None:
+            identity = x
+        return identity + self.dropout_layer(out)
+
+
+class SpatialReductionAttention(MultiheadAttention):
+    """An implementation of Spatial Reduction Attention of PVT.
+
+    This module is modified from MultiheadAttention which is a module from
+    mmcv.cnn.bricks.transformer.
+
+    Args:
+        embed_dims (int): The embedding dimension.
+        num_heads (int): Parallel attention heads.
+        attn_drop (float): A Dropout layer on attn_output_weights.
+            Default: 0.0.
+        proj_drop (float): A Dropout layer after `nn.MultiheadAttention`.
+            Default: 0.0.
+        dropout_layer (obj:`ConfigDict`): The dropout_layer used
+            when adding the shortcut. Default: None.
+        batch_first (bool): Key, Query and Value are shape of
+            (batch, n, embed_dim)
+            or (n, batch, embed_dim). Default: False.
+        qkv_bias (bool): enable bias for qkv if True. Default: True.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='LN').
+        sr_ratio (int): The ratio of spatial reduction of Spatial Reduction
+            Attention of PVT. Default: 1.
+        init_cfg (obj:`mmengine.ConfigDict`): The Config for initialization.
+            Default: None.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 num_heads,
+                 attn_drop=0.,
+                 proj_drop=0.,
+                 dropout_layer=None,
+                 batch_first=True,
+                 qkv_bias=True,
+                 norm_cfg=dict(type='LN'),
+                 sr_ratio=1,
+                 init_cfg=None):
+        super().__init__(
+            embed_dims,
+            num_heads,
+            attn_drop,
+            proj_drop,
+            batch_first=batch_first,
+            dropout_layer=dropout_layer,
+            bias=qkv_bias,
+            init_cfg=init_cfg)
+
+        self.sr_ratio = sr_ratio
+        if sr_ratio > 1:
+            self.sr = Conv2d(
+                in_channels=embed_dims,
+                out_channels=embed_dims,
+                kernel_size=sr_ratio,
+                stride=sr_ratio)
+            # The ret[0] of build_norm_layer is norm name.
+            self.norm = build_norm_layer(norm_cfg, embed_dims)[1]
+
+        # handle the BC-breaking from https://github.com/open-mmlab/mmcv/pull/1418 # noqa
+        from mmdet import digit_version, mmcv_version
+        if mmcv_version < digit_version('1.3.17'):
+            warnings.warn('The legacy version of forward function in'
+                          'SpatialReductionAttention is deprecated in'
+                          'mmcv>=1.3.17 and will no longer support in the'
+                          'future. Please upgrade your mmcv.')
+            self.forward = self.legacy_forward
+
+    def forward(self, x, hw_shape, identity=None):
+
+        x_q = x
+        if self.sr_ratio > 1:
+            x_kv = nlc_to_nchw(x, hw_shape)
+            x_kv = self.sr(x_kv)
+            x_kv = nchw_to_nlc(x_kv)
+            x_kv = self.norm(x_kv)
+        else:
+            x_kv = x
+
+        if identity is None:
+            identity = x_q
+
+        # Because the dataflow('key', 'query', 'value') of
+        # ``torch.nn.MultiheadAttention`` is (num_queries, batch,
+        # embed_dims), We should adjust the shape of dataflow from
+        # batch_first (batch, num_queries, embed_dims) to num_queries_first
+        # (num_queries ,batch, embed_dims), and recover ``attn_output``
+        # from num_queries_first to batch_first.
+        if self.batch_first:
+            x_q = x_q.transpose(0, 1)
+            x_kv = x_kv.transpose(0, 1)
+
+        out = self.attn(query=x_q, key=x_kv, value=x_kv)[0]
+
+        if self.batch_first:
+            out = out.transpose(0, 1)
+
+        return identity + self.dropout_layer(self.proj_drop(out))
+
+    def legacy_forward(self, x, hw_shape, identity=None):
+        """multi head attention forward in mmcv version < 1.3.17."""
+        x_q = x
+        if self.sr_ratio > 1:
+            x_kv = nlc_to_nchw(x, hw_shape)
+            x_kv = self.sr(x_kv)
+            x_kv = nchw_to_nlc(x_kv)
+            x_kv = self.norm(x_kv)
+        else:
+            x_kv = x
+
+        if identity is None:
+            identity = x_q
+
+        out = self.attn(query=x_q, key=x_kv, value=x_kv)[0]
+
+        return identity + self.dropout_layer(self.proj_drop(out))
+
+
+class PVTEncoderLayer(BaseModule):
+    """Implements one encoder layer in PVT.
+
+    Args:
+        embed_dims (int): The feature dimension.
+        num_heads (int): Parallel attention heads.
+        feedforward_channels (int): The hidden dimension for FFNs.
+        drop_rate (float): Probability of an element to be zeroed.
+            after the feed forward layer. Default: 0.0.
+        attn_drop_rate (float): The drop out rate for attention layer.
+            Default: 0.0.
+        drop_path_rate (float): stochastic depth rate. Default: 0.0.
+        qkv_bias (bool): enable bias for qkv if True.
+            Default: True.
+        act_cfg (dict): The activation config for FFNs.
+            Default: dict(type='GELU').
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='LN').
+        sr_ratio (int): The ratio of spatial reduction of Spatial Reduction
+            Attention of PVT. Default: 1.
+        use_conv_ffn (bool): If True, use Convolutional FFN to replace FFN.
+            Default: False.
+        init_cfg (dict, optional): Initialization config dict.
+            Default: None.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 num_heads,
+                 feedforward_channels,
+                 drop_rate=0.,
+                 attn_drop_rate=0.,
+                 drop_path_rate=0.,
+                 qkv_bias=True,
+                 act_cfg=dict(type='GELU'),
+                 norm_cfg=dict(type='LN'),
+                 sr_ratio=1,
+                 use_conv_ffn=False,
+                 init_cfg=None):
+        super(PVTEncoderLayer, self).__init__(init_cfg=init_cfg)
+
+        # The ret[0] of build_norm_layer is norm name.
+        self.norm1 = build_norm_layer(norm_cfg, embed_dims)[1]
+
+        self.attn = SpatialReductionAttention(
+            embed_dims=embed_dims,
+            num_heads=num_heads,
+            attn_drop=attn_drop_rate,
+            proj_drop=drop_rate,
+            dropout_layer=dict(type='DropPath', drop_prob=drop_path_rate),
+            qkv_bias=qkv_bias,
+            norm_cfg=norm_cfg,
+            sr_ratio=sr_ratio)
+
+        # The ret[0] of build_norm_layer is norm name.
+        self.norm2 = build_norm_layer(norm_cfg, embed_dims)[1]
+
+        self.ffn = MixFFN(
+            embed_dims=embed_dims,
+            feedforward_channels=feedforward_channels,
+            ffn_drop=drop_rate,
+            dropout_layer=dict(type='DropPath', drop_prob=drop_path_rate),
+            use_conv=use_conv_ffn,
+            act_cfg=act_cfg)
+
+    def forward(self, x, hw_shape):
+        x = self.attn(self.norm1(x), hw_shape, identity=x)
+        x = self.ffn(self.norm2(x), hw_shape, identity=x)
+
+        return x
+
+
+class AbsolutePositionEmbedding(BaseModule):
+    """An implementation of the absolute position embedding in PVT.
+
+    Args:
+        pos_shape (int): The shape of the absolute position embedding.
+        pos_dim (int): The dimension of the absolute position embedding.
+        drop_rate (float): Probability of an element to be zeroed.
+            Default: 0.0.
+    """
+
+    def __init__(self, pos_shape, pos_dim, drop_rate=0., init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+
+        if isinstance(pos_shape, int):
+            pos_shape = to_2tuple(pos_shape)
+        elif isinstance(pos_shape, tuple):
+            if len(pos_shape) == 1:
+                pos_shape = to_2tuple(pos_shape[0])
+            assert len(pos_shape) == 2, \
+                f'The size of image should have length 1 or 2, ' \
+                f'but got {len(pos_shape)}'
+        self.pos_shape = pos_shape
+        self.pos_dim = pos_dim
+
+        self.pos_embed = nn.Parameter(
+            torch.zeros(1, pos_shape[0] * pos_shape[1], pos_dim))
+        self.drop = nn.Dropout(p=drop_rate)
+
+    def init_weights(self):
+        trunc_normal_(self.pos_embed, std=0.02)
+
+    def resize_pos_embed(self, pos_embed, input_shape, mode='bilinear'):
+        """Resize pos_embed weights.
+
+        Resize pos_embed using bilinear interpolate method.
+
+        Args:
+            pos_embed (torch.Tensor): Position embedding weights.
+            input_shape (tuple): Tuple for (downsampled input image height,
+                downsampled input image width).
+            mode (str): Algorithm used for upsampling:
+                ``'nearest'`` | ``'linear'`` | ``'bilinear'`` | ``'bicubic'`` |
+                ``'trilinear'``. Default: ``'bilinear'``.
+
+        Return:
+            torch.Tensor: The resized pos_embed of shape [B, L_new, C].
+        """
+        assert pos_embed.ndim == 3, 'shape of pos_embed must be [B, L, C]'
+        pos_h, pos_w = self.pos_shape
+        pos_embed_weight = pos_embed[:, (-1 * pos_h * pos_w):]
+        pos_embed_weight = pos_embed_weight.reshape(
+            1, pos_h, pos_w, self.pos_dim).permute(0, 3, 1, 2).contiguous()
+        pos_embed_weight = F.interpolate(
+            pos_embed_weight, size=input_shape, mode=mode)
+        pos_embed_weight = torch.flatten(pos_embed_weight,
+                                         2).transpose(1, 2).contiguous()
+        pos_embed = pos_embed_weight
+
+        return pos_embed
+
+    def forward(self, x, hw_shape, mode='bilinear'):
+        pos_embed = self.resize_pos_embed(self.pos_embed, hw_shape, mode)
+        return self.drop(x + pos_embed)
+
+
+@MODELS.register_module()
+class PyramidVisionTransformer(BaseModule):
+    """Pyramid Vision Transformer (PVT)
+
+    Implementation of `Pyramid Vision Transformer: A Versatile Backbone for
+    Dense Prediction without Convolutions
+    `_.
+
+    Args:
+        pretrain_img_size (int | tuple[int]): The size of input image when
+            pretrain. Defaults: 224.
+        in_channels (int): Number of input channels. Default: 3.
+        embed_dims (int): Embedding dimension. Default: 64.
+        num_stags (int): The num of stages. Default: 4.
+        num_layers (Sequence[int]): The layer number of each transformer encode
+            layer. Default: [3, 4, 6, 3].
+        num_heads (Sequence[int]): The attention heads of each transformer
+            encode layer. Default: [1, 2, 5, 8].
+        patch_sizes (Sequence[int]): The patch_size of each patch embedding.
+            Default: [4, 2, 2, 2].
+        strides (Sequence[int]): The stride of each patch embedding.
+            Default: [4, 2, 2, 2].
+        paddings (Sequence[int]): The padding of each patch embedding.
+            Default: [0, 0, 0, 0].
+        sr_ratios (Sequence[int]): The spatial reduction rate of each
+            transformer encode layer. Default: [8, 4, 2, 1].
+        out_indices (Sequence[int] | int): Output from which stages.
+            Default: (0, 1, 2, 3).
+        mlp_ratios (Sequence[int]): The ratio of the mlp hidden dim to the
+            embedding dim of each transformer encode layer.
+            Default: [8, 8, 4, 4].
+        qkv_bias (bool): Enable bias for qkv if True. Default: True.
+        drop_rate (float): Probability of an element to be zeroed.
+            Default 0.0.
+        attn_drop_rate (float): The drop out rate for attention layer.
+            Default 0.0.
+        drop_path_rate (float): stochastic depth rate. Default 0.1.
+        use_abs_pos_embed (bool): If True, add absolute position embedding to
+            the patch embedding. Defaults: True.
+        use_conv_ffn (bool): If True, use Convolutional FFN to replace FFN.
+            Default: False.
+        act_cfg (dict): The activation config for FFNs.
+            Default: dict(type='GELU').
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='LN').
+        pretrained (str, optional): model pretrained path. Default: None.
+        convert_weights (bool): The flag indicates whether the
+            pre-trained model is from the original repo. We may need
+            to convert some keys to make it compatible.
+            Default: True.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    """
+
+    def __init__(self,
+                 pretrain_img_size=224,
+                 in_channels=3,
+                 embed_dims=64,
+                 num_stages=4,
+                 num_layers=[3, 4, 6, 3],
+                 num_heads=[1, 2, 5, 8],
+                 patch_sizes=[4, 2, 2, 2],
+                 strides=[4, 2, 2, 2],
+                 paddings=[0, 0, 0, 0],
+                 sr_ratios=[8, 4, 2, 1],
+                 out_indices=(0, 1, 2, 3),
+                 mlp_ratios=[8, 8, 4, 4],
+                 qkv_bias=True,
+                 drop_rate=0.,
+                 attn_drop_rate=0.,
+                 drop_path_rate=0.1,
+                 use_abs_pos_embed=True,
+                 norm_after_stage=False,
+                 use_conv_ffn=False,
+                 act_cfg=dict(type='GELU'),
+                 norm_cfg=dict(type='LN', eps=1e-6),
+                 pretrained=None,
+                 convert_weights=True,
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+
+        self.convert_weights = convert_weights
+        if isinstance(pretrain_img_size, int):
+            pretrain_img_size = to_2tuple(pretrain_img_size)
+        elif isinstance(pretrain_img_size, tuple):
+            if len(pretrain_img_size) == 1:
+                pretrain_img_size = to_2tuple(pretrain_img_size[0])
+            assert len(pretrain_img_size) == 2, \
+                f'The size of image should have length 1 or 2, ' \
+                f'but got {len(pretrain_img_size)}'
+
+        assert not (init_cfg and pretrained), \
+            'init_cfg and pretrained cannot be setting at the same time'
+        if isinstance(pretrained, str):
+            warnings.warn('DeprecationWarning: pretrained is deprecated, '
+                          'please use "init_cfg" instead')
+            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
+        elif pretrained is None:
+            self.init_cfg = init_cfg
+        else:
+            raise TypeError('pretrained must be a str or None')
+
+        self.embed_dims = embed_dims
+
+        self.num_stages = num_stages
+        self.num_layers = num_layers
+        self.num_heads = num_heads
+        self.patch_sizes = patch_sizes
+        self.strides = strides
+        self.sr_ratios = sr_ratios
+        assert num_stages == len(num_layers) == len(num_heads) \
+               == len(patch_sizes) == len(strides) == len(sr_ratios)
+
+        self.out_indices = out_indices
+        assert max(out_indices) < self.num_stages
+        self.pretrained = pretrained
+
+        # transformer encoder
+        dpr = [
+            x.item()
+            for x in torch.linspace(0, drop_path_rate, sum(num_layers))
+        ]  # stochastic num_layer decay rule
+
+        cur = 0
+        self.layers = ModuleList()
+        for i, num_layer in enumerate(num_layers):
+            embed_dims_i = embed_dims * num_heads[i]
+            patch_embed = PatchEmbed(
+                in_channels=in_channels,
+                embed_dims=embed_dims_i,
+                kernel_size=patch_sizes[i],
+                stride=strides[i],
+                padding=paddings[i],
+                bias=True,
+                norm_cfg=norm_cfg)
+
+            layers = ModuleList()
+            if use_abs_pos_embed:
+                pos_shape = pretrain_img_size // np.prod(patch_sizes[:i + 1])
+                pos_embed = AbsolutePositionEmbedding(
+                    pos_shape=pos_shape,
+                    pos_dim=embed_dims_i,
+                    drop_rate=drop_rate)
+                layers.append(pos_embed)
+            layers.extend([
+                PVTEncoderLayer(
+                    embed_dims=embed_dims_i,
+                    num_heads=num_heads[i],
+                    feedforward_channels=mlp_ratios[i] * embed_dims_i,
+                    drop_rate=drop_rate,
+                    attn_drop_rate=attn_drop_rate,
+                    drop_path_rate=dpr[cur + idx],
+                    qkv_bias=qkv_bias,
+                    act_cfg=act_cfg,
+                    norm_cfg=norm_cfg,
+                    sr_ratio=sr_ratios[i],
+                    use_conv_ffn=use_conv_ffn) for idx in range(num_layer)
+            ])
+            in_channels = embed_dims_i
+            # The ret[0] of build_norm_layer is norm name.
+            if norm_after_stage:
+                norm = build_norm_layer(norm_cfg, embed_dims_i)[1]
+            else:
+                norm = nn.Identity()
+            self.layers.append(ModuleList([patch_embed, layers, norm]))
+            cur += num_layer
+
+    def init_weights(self):
+        logger = MMLogger.get_current_instance()
+        if self.init_cfg is None:
+            logger.warn(f'No pre-trained weights for '
+                        f'{self.__class__.__name__}, '
+                        f'training start from scratch')
+            for m in self.modules():
+                if isinstance(m, nn.Linear):
+                    trunc_normal_init(m, std=.02, bias=0.)
+                elif isinstance(m, nn.LayerNorm):
+                    constant_init(m, 1.0)
+                elif isinstance(m, nn.Conv2d):
+                    fan_out = m.kernel_size[0] * m.kernel_size[
+                        1] * m.out_channels
+                    fan_out //= m.groups
+                    normal_init(m, 0, math.sqrt(2.0 / fan_out))
+                elif isinstance(m, AbsolutePositionEmbedding):
+                    m.init_weights()
+        else:
+            assert 'checkpoint' in self.init_cfg, f'Only support ' \
+                                                  f'specify `Pretrained` in ' \
+                                                  f'`init_cfg` in ' \
+                                                  f'{self.__class__.__name__} '
+            checkpoint = CheckpointLoader.load_checkpoint(
+                self.init_cfg.checkpoint, logger=logger, map_location='cpu')
+            logger.warn(f'Load pre-trained model for '
+                        f'{self.__class__.__name__} from original repo')
+            if 'state_dict' in checkpoint:
+                state_dict = checkpoint['state_dict']
+            elif 'model' in checkpoint:
+                state_dict = checkpoint['model']
+            else:
+                state_dict = checkpoint
+            if self.convert_weights:
+                # Because pvt backbones are not supported by mmpretrain,
+                # so we need to convert pre-trained weights to match this
+                # implementation.
+                state_dict = pvt_convert(state_dict)
+            load_state_dict(self, state_dict, strict=False, logger=logger)
+
+    def forward(self, x):
+        outs = []
+
+        for i, layer in enumerate(self.layers):
+            x, hw_shape = layer[0](x)
+
+            for block in layer[1]:
+                x = block(x, hw_shape)
+            x = layer[2](x)
+            x = nlc_to_nchw(x, hw_shape)
+            if i in self.out_indices:
+                outs.append(x)
+
+        return outs
+
+
+@MODELS.register_module()
+class PyramidVisionTransformerV2(PyramidVisionTransformer):
+    """Implementation of `PVTv2: Improved Baselines with Pyramid Vision
+    Transformer `_."""
+
+    def __init__(self, **kwargs):
+        super(PyramidVisionTransformerV2, self).__init__(
+            patch_sizes=[7, 3, 3, 3],
+            paddings=[3, 1, 1, 1],
+            use_abs_pos_embed=False,
+            norm_after_stage=True,
+            use_conv_ffn=True,
+            **kwargs)
+
+
+def pvt_convert(ckpt):
+    new_ckpt = OrderedDict()
+    # Process the concat between q linear weights and kv linear weights
+    use_abs_pos_embed = False
+    use_conv_ffn = False
+    for k in ckpt.keys():
+        if k.startswith('pos_embed'):
+            use_abs_pos_embed = True
+        if k.find('dwconv') >= 0:
+            use_conv_ffn = True
+    for k, v in ckpt.items():
+        if k.startswith('head'):
+            continue
+        if k.startswith('norm.'):
+            continue
+        if k.startswith('cls_token'):
+            continue
+        if k.startswith('pos_embed'):
+            stage_i = int(k.replace('pos_embed', ''))
+            new_k = k.replace(f'pos_embed{stage_i}',
+                              f'layers.{stage_i - 1}.1.0.pos_embed')
+            if stage_i == 4 and v.size(1) == 50:  # 1 (cls token) + 7 * 7
+                new_v = v[:, 1:, :]  # remove cls token
+            else:
+                new_v = v
+        elif k.startswith('patch_embed'):
+            stage_i = int(k.split('.')[0].replace('patch_embed', ''))
+            new_k = k.replace(f'patch_embed{stage_i}',
+                              f'layers.{stage_i - 1}.0')
+            new_v = v
+            if 'proj.' in new_k:
+                new_k = new_k.replace('proj.', 'projection.')
+        elif k.startswith('block'):
+            stage_i = int(k.split('.')[0].replace('block', ''))
+            layer_i = int(k.split('.')[1])
+            new_layer_i = layer_i + use_abs_pos_embed
+            new_k = k.replace(f'block{stage_i}.{layer_i}',
+                              f'layers.{stage_i - 1}.1.{new_layer_i}')
+            new_v = v
+            if 'attn.q.' in new_k:
+                sub_item_k = k.replace('q.', 'kv.')
+                new_k = new_k.replace('q.', 'attn.in_proj_')
+                new_v = torch.cat([v, ckpt[sub_item_k]], dim=0)
+            elif 'attn.kv.' in new_k:
+                continue
+            elif 'attn.proj.' in new_k:
+                new_k = new_k.replace('proj.', 'attn.out_proj.')
+            elif 'attn.sr.' in new_k:
+                new_k = new_k.replace('sr.', 'sr.')
+            elif 'mlp.' in new_k:
+                string = f'{new_k}-'
+                new_k = new_k.replace('mlp.', 'ffn.layers.')
+                if 'fc1.weight' in new_k or 'fc2.weight' in new_k:
+                    new_v = v.reshape((*v.shape, 1, 1))
+                new_k = new_k.replace('fc1.', '0.')
+                new_k = new_k.replace('dwconv.dwconv.', '1.')
+                if use_conv_ffn:
+                    new_k = new_k.replace('fc2.', '4.')
+                else:
+                    new_k = new_k.replace('fc2.', '3.')
+                string += f'{new_k} {v.shape}-{new_v.shape}'
+        elif k.startswith('norm'):
+            stage_i = int(k[4])
+            new_k = k.replace(f'norm{stage_i}', f'layers.{stage_i - 1}.2')
+            new_v = v
+        else:
+            new_k = k
+            new_v = v
+        new_ckpt[new_k] = new_v
+
+    return new_ckpt
diff --git a/mmdetection/mmdet/models/backbones/regnet.py b/mmdetection/mmdet/models/backbones/regnet.py
new file mode 100644
index 00000000..55d3ce07
--- /dev/null
+++ b/mmdetection/mmdet/models/backbones/regnet.py
@@ -0,0 +1,356 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+
+import numpy as np
+import torch.nn as nn
+from mmcv.cnn import build_conv_layer, build_norm_layer
+
+from mmdet.registry import MODELS
+from .resnet import ResNet
+from .resnext import Bottleneck
+
+
+@MODELS.register_module()
+class RegNet(ResNet):
+    """RegNet backbone.
+
+    More details can be found in `paper `_ .
+
+    Args:
+        arch (dict): The parameter of RegNets.
+
+            - w0 (int): initial width
+            - wa (float): slope of width
+            - wm (float): quantization parameter to quantize the width
+            - depth (int): depth of the backbone
+            - group_w (int): width of group
+            - bot_mul (float): bottleneck ratio, i.e. expansion of bottleneck.
+        strides (Sequence[int]): Strides of the first block of each stage.
+        base_channels (int): Base channels after stem layer.
+        in_channels (int): Number of input image channels. Default: 3.
+        dilations (Sequence[int]): Dilation of each stage.
+        out_indices (Sequence[int]): Output from which stages.
+        style (str): `pytorch` or `caffe`. If set to "pytorch", the stride-two
+            layer is the 3x3 conv layer, otherwise the stride-two layer is
+            the first 1x1 conv layer.
+        frozen_stages (int): Stages to be frozen (all param fixed). -1 means
+            not freezing any parameters.
+        norm_cfg (dict): dictionary to construct and config norm layer.
+        norm_eval (bool): Whether to set norm layers to eval mode, namely,
+            freeze running stats (mean and var). Note: Effect on Batch Norm
+            and its variants only.
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save some
+            memory while slowing down the training speed.
+        zero_init_residual (bool): whether to use zero init for last norm layer
+            in resblocks to let them behave as identity.
+        pretrained (str, optional): model pretrained path. Default: None
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None
+
+    Example:
+        >>> from mmdet.models import RegNet
+        >>> import torch
+        >>> self = RegNet(
+                arch=dict(
+                    w0=88,
+                    wa=26.31,
+                    wm=2.25,
+                    group_w=48,
+                    depth=25,
+                    bot_mul=1.0))
+        >>> self.eval()
+        >>> inputs = torch.rand(1, 3, 32, 32)
+        >>> level_outputs = self.forward(inputs)
+        >>> for level_out in level_outputs:
+        ...     print(tuple(level_out.shape))
+        (1, 96, 8, 8)
+        (1, 192, 4, 4)
+        (1, 432, 2, 2)
+        (1, 1008, 1, 1)
+    """
+    arch_settings = {
+        'regnetx_400mf':
+        dict(w0=24, wa=24.48, wm=2.54, group_w=16, depth=22, bot_mul=1.0),
+        'regnetx_800mf':
+        dict(w0=56, wa=35.73, wm=2.28, group_w=16, depth=16, bot_mul=1.0),
+        'regnetx_1.6gf':
+        dict(w0=80, wa=34.01, wm=2.25, group_w=24, depth=18, bot_mul=1.0),
+        'regnetx_3.2gf':
+        dict(w0=88, wa=26.31, wm=2.25, group_w=48, depth=25, bot_mul=1.0),
+        'regnetx_4.0gf':
+        dict(w0=96, wa=38.65, wm=2.43, group_w=40, depth=23, bot_mul=1.0),
+        'regnetx_6.4gf':
+        dict(w0=184, wa=60.83, wm=2.07, group_w=56, depth=17, bot_mul=1.0),
+        'regnetx_8.0gf':
+        dict(w0=80, wa=49.56, wm=2.88, group_w=120, depth=23, bot_mul=1.0),
+        'regnetx_12gf':
+        dict(w0=168, wa=73.36, wm=2.37, group_w=112, depth=19, bot_mul=1.0),
+    }
+
+    def __init__(self,
+                 arch,
+                 in_channels=3,
+                 stem_channels=32,
+                 base_channels=32,
+                 strides=(2, 2, 2, 2),
+                 dilations=(1, 1, 1, 1),
+                 out_indices=(0, 1, 2, 3),
+                 style='pytorch',
+                 deep_stem=False,
+                 avg_down=False,
+                 frozen_stages=-1,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN', requires_grad=True),
+                 norm_eval=True,
+                 dcn=None,
+                 stage_with_dcn=(False, False, False, False),
+                 plugins=None,
+                 with_cp=False,
+                 zero_init_residual=True,
+                 pretrained=None,
+                 init_cfg=None):
+        super(ResNet, self).__init__(init_cfg)
+
+        # Generate RegNet parameters first
+        if isinstance(arch, str):
+            assert arch in self.arch_settings, \
+                f'"arch": "{arch}" is not one of the' \
+                ' arch_settings'
+            arch = self.arch_settings[arch]
+        elif not isinstance(arch, dict):
+            raise ValueError('Expect "arch" to be either a string '
+                             f'or a dict, got {type(arch)}')
+
+        widths, num_stages = self.generate_regnet(
+            arch['w0'],
+            arch['wa'],
+            arch['wm'],
+            arch['depth'],
+        )
+        # Convert to per stage format
+        stage_widths, stage_blocks = self.get_stages_from_blocks(widths)
+        # Generate group widths and bot muls
+        group_widths = [arch['group_w'] for _ in range(num_stages)]
+        self.bottleneck_ratio = [arch['bot_mul'] for _ in range(num_stages)]
+        # Adjust the compatibility of stage_widths and group_widths
+        stage_widths, group_widths = self.adjust_width_group(
+            stage_widths, self.bottleneck_ratio, group_widths)
+
+        # Group params by stage
+        self.stage_widths = stage_widths
+        self.group_widths = group_widths
+        self.depth = sum(stage_blocks)
+        self.stem_channels = stem_channels
+        self.base_channels = base_channels
+        self.num_stages = num_stages
+        assert num_stages >= 1 and num_stages <= 4
+        self.strides = strides
+        self.dilations = dilations
+        assert len(strides) == len(dilations) == num_stages
+        self.out_indices = out_indices
+        assert max(out_indices) < num_stages
+        self.style = style
+        self.deep_stem = deep_stem
+        self.avg_down = avg_down
+        self.frozen_stages = frozen_stages
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.with_cp = with_cp
+        self.norm_eval = norm_eval
+        self.dcn = dcn
+        self.stage_with_dcn = stage_with_dcn
+        if dcn is not None:
+            assert len(stage_with_dcn) == num_stages
+        self.plugins = plugins
+        self.zero_init_residual = zero_init_residual
+        self.block = Bottleneck
+        expansion_bak = self.block.expansion
+        self.block.expansion = 1
+        self.stage_blocks = stage_blocks[:num_stages]
+
+        self._make_stem_layer(in_channels, stem_channels)
+
+        block_init_cfg = None
+        assert not (init_cfg and pretrained), \
+            'init_cfg and pretrained cannot be specified at the same time'
+        if isinstance(pretrained, str):
+            warnings.warn('DeprecationWarning: pretrained is deprecated, '
+                          'please use "init_cfg" instead')
+            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
+        elif pretrained is None:
+            if init_cfg is None:
+                self.init_cfg = [
+                    dict(type='Kaiming', layer='Conv2d'),
+                    dict(
+                        type='Constant',
+                        val=1,
+                        layer=['_BatchNorm', 'GroupNorm'])
+                ]
+                if self.zero_init_residual:
+                    block_init_cfg = dict(
+                        type='Constant', val=0, override=dict(name='norm3'))
+        else:
+            raise TypeError('pretrained must be a str or None')
+
+        self.inplanes = stem_channels
+        self.res_layers = []
+        for i, num_blocks in enumerate(self.stage_blocks):
+            stride = self.strides[i]
+            dilation = self.dilations[i]
+            group_width = self.group_widths[i]
+            width = int(round(self.stage_widths[i] * self.bottleneck_ratio[i]))
+            stage_groups = width // group_width
+
+            dcn = self.dcn if self.stage_with_dcn[i] else None
+            if self.plugins is not None:
+                stage_plugins = self.make_stage_plugins(self.plugins, i)
+            else:
+                stage_plugins = None
+
+            res_layer = self.make_res_layer(
+                block=self.block,
+                inplanes=self.inplanes,
+                planes=self.stage_widths[i],
+                num_blocks=num_blocks,
+                stride=stride,
+                dilation=dilation,
+                style=self.style,
+                avg_down=self.avg_down,
+                with_cp=self.with_cp,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg,
+                dcn=dcn,
+                plugins=stage_plugins,
+                groups=stage_groups,
+                base_width=group_width,
+                base_channels=self.stage_widths[i],
+                init_cfg=block_init_cfg)
+            self.inplanes = self.stage_widths[i]
+            layer_name = f'layer{i + 1}'
+            self.add_module(layer_name, res_layer)
+            self.res_layers.append(layer_name)
+
+        self._freeze_stages()
+
+        self.feat_dim = stage_widths[-1]
+        self.block.expansion = expansion_bak
+
+    def _make_stem_layer(self, in_channels, base_channels):
+        self.conv1 = build_conv_layer(
+            self.conv_cfg,
+            in_channels,
+            base_channels,
+            kernel_size=3,
+            stride=2,
+            padding=1,
+            bias=False)
+        self.norm1_name, norm1 = build_norm_layer(
+            self.norm_cfg, base_channels, postfix=1)
+        self.add_module(self.norm1_name, norm1)
+        self.relu = nn.ReLU(inplace=True)
+
+    def generate_regnet(self,
+                        initial_width,
+                        width_slope,
+                        width_parameter,
+                        depth,
+                        divisor=8):
+        """Generates per block width from RegNet parameters.
+
+        Args:
+            initial_width ([int]): Initial width of the backbone
+            width_slope ([float]): Slope of the quantized linear function
+            width_parameter ([int]): Parameter used to quantize the width.
+            depth ([int]): Depth of the backbone.
+            divisor (int, optional): The divisor of channels. Defaults to 8.
+
+        Returns:
+            list, int: return a list of widths of each stage and the number \
+                of stages
+        """
+        assert width_slope >= 0
+        assert initial_width > 0
+        assert width_parameter > 1
+        assert initial_width % divisor == 0
+        widths_cont = np.arange(depth) * width_slope + initial_width
+        ks = np.round(
+            np.log(widths_cont / initial_width) / np.log(width_parameter))
+        widths = initial_width * np.power(width_parameter, ks)
+        widths = np.round(np.divide(widths, divisor)) * divisor
+        num_stages = len(np.unique(widths))
+        widths, widths_cont = widths.astype(int).tolist(), widths_cont.tolist()
+        return widths, num_stages
+
+    @staticmethod
+    def quantize_float(number, divisor):
+        """Converts a float to closest non-zero int divisible by divisor.
+
+        Args:
+            number (int): Original number to be quantized.
+            divisor (int): Divisor used to quantize the number.
+
+        Returns:
+            int: quantized number that is divisible by devisor.
+        """
+        return int(round(number / divisor) * divisor)
+
+    def adjust_width_group(self, widths, bottleneck_ratio, groups):
+        """Adjusts the compatibility of widths and groups.
+
+        Args:
+            widths (list[int]): Width of each stage.
+            bottleneck_ratio (float): Bottleneck ratio.
+            groups (int): number of groups in each stage
+
+        Returns:
+            tuple(list): The adjusted widths and groups of each stage.
+        """
+        bottleneck_width = [
+            int(w * b) for w, b in zip(widths, bottleneck_ratio)
+        ]
+        groups = [min(g, w_bot) for g, w_bot in zip(groups, bottleneck_width)]
+        bottleneck_width = [
+            self.quantize_float(w_bot, g)
+            for w_bot, g in zip(bottleneck_width, groups)
+        ]
+        widths = [
+            int(w_bot / b)
+            for w_bot, b in zip(bottleneck_width, bottleneck_ratio)
+        ]
+        return widths, groups
+
+    def get_stages_from_blocks(self, widths):
+        """Gets widths/stage_blocks of network at each stage.
+
+        Args:
+            widths (list[int]): Width in each stage.
+
+        Returns:
+            tuple(list): width and depth of each stage
+        """
+        width_diff = [
+            width != width_prev
+            for width, width_prev in zip(widths + [0], [0] + widths)
+        ]
+        stage_widths = [
+            width for width, diff in zip(widths, width_diff[:-1]) if diff
+        ]
+        stage_blocks = np.diff([
+            depth for depth, diff in zip(range(len(width_diff)), width_diff)
+            if diff
+        ]).tolist()
+        return stage_widths, stage_blocks
+
+    def forward(self, x):
+        """Forward function."""
+        x = self.conv1(x)
+        x = self.norm1(x)
+        x = self.relu(x)
+
+        outs = []
+        for i, layer_name in enumerate(self.res_layers):
+            res_layer = getattr(self, layer_name)
+            x = res_layer(x)
+            if i in self.out_indices:
+                outs.append(x)
+        return tuple(outs)
diff --git a/mmdetection/mmdet/models/backbones/res2net.py b/mmdetection/mmdet/models/backbones/res2net.py
new file mode 100644
index 00000000..958fc884
--- /dev/null
+++ b/mmdetection/mmdet/models/backbones/res2net.py
@@ -0,0 +1,327 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+
+import torch
+import torch.nn as nn
+import torch.utils.checkpoint as cp
+from mmcv.cnn import build_conv_layer, build_norm_layer
+from mmengine.model import Sequential
+
+from mmdet.registry import MODELS
+from .resnet import Bottleneck as _Bottleneck
+from .resnet import ResNet
+
+
+class Bottle2neck(_Bottleneck):
+    expansion = 4
+
+    def __init__(self,
+                 inplanes,
+                 planes,
+                 scales=4,
+                 base_width=26,
+                 base_channels=64,
+                 stage_type='normal',
+                 **kwargs):
+        """Bottle2neck block for Res2Net.
+
+        If style is "pytorch", the stride-two layer is the 3x3 conv layer, if
+        it is "caffe", the stride-two layer is the first 1x1 conv layer.
+        """
+        super(Bottle2neck, self).__init__(inplanes, planes, **kwargs)
+        assert scales > 1, 'Res2Net degenerates to ResNet when scales = 1.'
+        width = int(math.floor(self.planes * (base_width / base_channels)))
+
+        self.norm1_name, norm1 = build_norm_layer(
+            self.norm_cfg, width * scales, postfix=1)
+        self.norm3_name, norm3 = build_norm_layer(
+            self.norm_cfg, self.planes * self.expansion, postfix=3)
+
+        self.conv1 = build_conv_layer(
+            self.conv_cfg,
+            self.inplanes,
+            width * scales,
+            kernel_size=1,
+            stride=self.conv1_stride,
+            bias=False)
+        self.add_module(self.norm1_name, norm1)
+
+        if stage_type == 'stage' and self.conv2_stride != 1:
+            self.pool = nn.AvgPool2d(
+                kernel_size=3, stride=self.conv2_stride, padding=1)
+        convs = []
+        bns = []
+
+        fallback_on_stride = False
+        if self.with_dcn:
+            fallback_on_stride = self.dcn.pop('fallback_on_stride', False)
+        if not self.with_dcn or fallback_on_stride:
+            for i in range(scales - 1):
+                convs.append(
+                    build_conv_layer(
+                        self.conv_cfg,
+                        width,
+                        width,
+                        kernel_size=3,
+                        stride=self.conv2_stride,
+                        padding=self.dilation,
+                        dilation=self.dilation,
+                        bias=False))
+                bns.append(
+                    build_norm_layer(self.norm_cfg, width, postfix=i + 1)[1])
+            self.convs = nn.ModuleList(convs)
+            self.bns = nn.ModuleList(bns)
+        else:
+            assert self.conv_cfg is None, 'conv_cfg must be None for DCN'
+            for i in range(scales - 1):
+                convs.append(
+                    build_conv_layer(
+                        self.dcn,
+                        width,
+                        width,
+                        kernel_size=3,
+                        stride=self.conv2_stride,
+                        padding=self.dilation,
+                        dilation=self.dilation,
+                        bias=False))
+                bns.append(
+                    build_norm_layer(self.norm_cfg, width, postfix=i + 1)[1])
+            self.convs = nn.ModuleList(convs)
+            self.bns = nn.ModuleList(bns)
+
+        self.conv3 = build_conv_layer(
+            self.conv_cfg,
+            width * scales,
+            self.planes * self.expansion,
+            kernel_size=1,
+            bias=False)
+        self.add_module(self.norm3_name, norm3)
+
+        self.stage_type = stage_type
+        self.scales = scales
+        self.width = width
+        delattr(self, 'conv2')
+        delattr(self, self.norm2_name)
+
+    def forward(self, x):
+        """Forward function."""
+
+        def _inner_forward(x):
+            identity = x
+
+            out = self.conv1(x)
+            out = self.norm1(out)
+            out = self.relu(out)
+
+            if self.with_plugins:
+                out = self.forward_plugin(out, self.after_conv1_plugin_names)
+
+            spx = torch.split(out, self.width, 1)
+            sp = self.convs[0](spx[0].contiguous())
+            sp = self.relu(self.bns[0](sp))
+            out = sp
+            for i in range(1, self.scales - 1):
+                if self.stage_type == 'stage':
+                    sp = spx[i]
+                else:
+                    sp = sp + spx[i]
+                sp = self.convs[i](sp.contiguous())
+                sp = self.relu(self.bns[i](sp))
+                out = torch.cat((out, sp), 1)
+
+            if self.stage_type == 'normal' or self.conv2_stride == 1:
+                out = torch.cat((out, spx[self.scales - 1]), 1)
+            elif self.stage_type == 'stage':
+                out = torch.cat((out, self.pool(spx[self.scales - 1])), 1)
+
+            if self.with_plugins:
+                out = self.forward_plugin(out, self.after_conv2_plugin_names)
+
+            out = self.conv3(out)
+            out = self.norm3(out)
+
+            if self.with_plugins:
+                out = self.forward_plugin(out, self.after_conv3_plugin_names)
+
+            if self.downsample is not None:
+                identity = self.downsample(x)
+
+            out += identity
+
+            return out
+
+        if self.with_cp and x.requires_grad:
+            out = cp.checkpoint(_inner_forward, x)
+        else:
+            out = _inner_forward(x)
+
+        out = self.relu(out)
+
+        return out
+
+
+class Res2Layer(Sequential):
+    """Res2Layer to build Res2Net style backbone.
+
+    Args:
+        block (nn.Module): block used to build ResLayer.
+        inplanes (int): inplanes of block.
+        planes (int): planes of block.
+        num_blocks (int): number of blocks.
+        stride (int): stride of the first block. Default: 1
+        avg_down (bool): Use AvgPool instead of stride conv when
+            downsampling in the bottle2neck. Default: False
+        conv_cfg (dict): dictionary to construct and config conv layer.
+            Default: None
+        norm_cfg (dict): dictionary to construct and config norm layer.
+            Default: dict(type='BN')
+        scales (int): Scales used in Res2Net. Default: 4
+        base_width (int): Basic width of each scale. Default: 26
+    """
+
+    def __init__(self,
+                 block,
+                 inplanes,
+                 planes,
+                 num_blocks,
+                 stride=1,
+                 avg_down=True,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 scales=4,
+                 base_width=26,
+                 **kwargs):
+        self.block = block
+
+        downsample = None
+        if stride != 1 or inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                nn.AvgPool2d(
+                    kernel_size=stride,
+                    stride=stride,
+                    ceil_mode=True,
+                    count_include_pad=False),
+                build_conv_layer(
+                    conv_cfg,
+                    inplanes,
+                    planes * block.expansion,
+                    kernel_size=1,
+                    stride=1,
+                    bias=False),
+                build_norm_layer(norm_cfg, planes * block.expansion)[1],
+            )
+
+        layers = []
+        layers.append(
+            block(
+                inplanes=inplanes,
+                planes=planes,
+                stride=stride,
+                downsample=downsample,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                scales=scales,
+                base_width=base_width,
+                stage_type='stage',
+                **kwargs))
+        inplanes = planes * block.expansion
+        for i in range(1, num_blocks):
+            layers.append(
+                block(
+                    inplanes=inplanes,
+                    planes=planes,
+                    stride=1,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    scales=scales,
+                    base_width=base_width,
+                    **kwargs))
+        super(Res2Layer, self).__init__(*layers)
+
+
+@MODELS.register_module()
+class Res2Net(ResNet):
+    """Res2Net backbone.
+
+    Args:
+        scales (int): Scales used in Res2Net. Default: 4
+        base_width (int): Basic width of each scale. Default: 26
+        depth (int): Depth of res2net, from {50, 101, 152}.
+        in_channels (int): Number of input image channels. Default: 3.
+        num_stages (int): Res2net stages. Default: 4.
+        strides (Sequence[int]): Strides of the first block of each stage.
+        dilations (Sequence[int]): Dilation of each stage.
+        out_indices (Sequence[int]): Output from which stages.
+        style (str): `pytorch` or `caffe`. If set to "pytorch", the stride-two
+            layer is the 3x3 conv layer, otherwise the stride-two layer is
+            the first 1x1 conv layer.
+        deep_stem (bool): Replace 7x7 conv in input stem with 3 3x3 conv
+        avg_down (bool): Use AvgPool instead of stride conv when
+            downsampling in the bottle2neck.
+        frozen_stages (int): Stages to be frozen (stop grad and set eval mode).
+            -1 means not freezing any parameters.
+        norm_cfg (dict): Dictionary to construct and config norm layer.
+        norm_eval (bool): Whether to set norm layers to eval mode, namely,
+            freeze running stats (mean and var). Note: Effect on Batch Norm
+            and its variants only.
+        plugins (list[dict]): List of plugins for stages, each dict contains:
+
+            - cfg (dict, required): Cfg dict to build plugin.
+            - position (str, required): Position inside block to insert
+              plugin, options are 'after_conv1', 'after_conv2', 'after_conv3'.
+            - stages (tuple[bool], optional): Stages to apply plugin, length
+              should be same as 'num_stages'.
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save some
+            memory while slowing down the training speed.
+        zero_init_residual (bool): Whether to use zero init for last norm layer
+            in resblocks to let them behave as identity.
+        pretrained (str, optional): model pretrained path. Default: None
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None
+
+    Example:
+        >>> from mmdet.models import Res2Net
+        >>> import torch
+        >>> self = Res2Net(depth=50, scales=4, base_width=26)
+        >>> self.eval()
+        >>> inputs = torch.rand(1, 3, 32, 32)
+        >>> level_outputs = self.forward(inputs)
+        >>> for level_out in level_outputs:
+        ...     print(tuple(level_out.shape))
+        (1, 256, 8, 8)
+        (1, 512, 4, 4)
+        (1, 1024, 2, 2)
+        (1, 2048, 1, 1)
+    """
+
+    arch_settings = {
+        50: (Bottle2neck, (3, 4, 6, 3)),
+        101: (Bottle2neck, (3, 4, 23, 3)),
+        152: (Bottle2neck, (3, 8, 36, 3))
+    }
+
+    def __init__(self,
+                 scales=4,
+                 base_width=26,
+                 style='pytorch',
+                 deep_stem=True,
+                 avg_down=True,
+                 pretrained=None,
+                 init_cfg=None,
+                 **kwargs):
+        self.scales = scales
+        self.base_width = base_width
+        super(Res2Net, self).__init__(
+            style='pytorch',
+            deep_stem=True,
+            avg_down=True,
+            pretrained=pretrained,
+            init_cfg=init_cfg,
+            **kwargs)
+
+    def make_res_layer(self, **kwargs):
+        return Res2Layer(
+            scales=self.scales,
+            base_width=self.base_width,
+            base_channels=self.base_channels,
+            **kwargs)
diff --git a/mmdetection/mmdet/models/backbones/resnest.py b/mmdetection/mmdet/models/backbones/resnest.py
new file mode 100644
index 00000000..d4466c4c
--- /dev/null
+++ b/mmdetection/mmdet/models/backbones/resnest.py
@@ -0,0 +1,322 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.checkpoint as cp
+from mmcv.cnn import build_conv_layer, build_norm_layer
+from mmengine.model import BaseModule
+
+from mmdet.registry import MODELS
+from ..layers import ResLayer
+from .resnet import Bottleneck as _Bottleneck
+from .resnet import ResNetV1d
+
+
+class RSoftmax(nn.Module):
+    """Radix Softmax module in ``SplitAttentionConv2d``.
+
+    Args:
+        radix (int): Radix of input.
+        groups (int): Groups of input.
+    """
+
+    def __init__(self, radix, groups):
+        super().__init__()
+        self.radix = radix
+        self.groups = groups
+
+    def forward(self, x):
+        batch = x.size(0)
+        if self.radix > 1:
+            x = x.view(batch, self.groups, self.radix, -1).transpose(1, 2)
+            x = F.softmax(x, dim=1)
+            x = x.reshape(batch, -1)
+        else:
+            x = torch.sigmoid(x)
+        return x
+
+
+class SplitAttentionConv2d(BaseModule):
+    """Split-Attention Conv2d in ResNeSt.
+
+    Args:
+        in_channels (int): Number of channels in the input feature map.
+        channels (int): Number of intermediate channels.
+        kernel_size (int | tuple[int]): Size of the convolution kernel.
+        stride (int | tuple[int]): Stride of the convolution.
+        padding (int | tuple[int]): Zero-padding added to both sides of
+        dilation (int | tuple[int]): Spacing between kernel elements.
+        groups (int): Number of blocked connections from input channels to
+            output channels.
+        groups (int): Same as nn.Conv2d.
+        radix (int): Radix of SpltAtConv2d. Default: 2
+        reduction_factor (int): Reduction factor of inter_channels. Default: 4.
+        conv_cfg (dict): Config dict for convolution layer. Default: None,
+            which means using conv2d.
+        norm_cfg (dict): Config dict for normalization layer. Default: None.
+        dcn (dict): Config dict for DCN. Default: None.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None
+    """
+
+    def __init__(self,
+                 in_channels,
+                 channels,
+                 kernel_size,
+                 stride=1,
+                 padding=0,
+                 dilation=1,
+                 groups=1,
+                 radix=2,
+                 reduction_factor=4,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 dcn=None,
+                 init_cfg=None):
+        super(SplitAttentionConv2d, self).__init__(init_cfg)
+        inter_channels = max(in_channels * radix // reduction_factor, 32)
+        self.radix = radix
+        self.groups = groups
+        self.channels = channels
+        self.with_dcn = dcn is not None
+        self.dcn = dcn
+        fallback_on_stride = False
+        if self.with_dcn:
+            fallback_on_stride = self.dcn.pop('fallback_on_stride', False)
+        if self.with_dcn and not fallback_on_stride:
+            assert conv_cfg is None, 'conv_cfg must be None for DCN'
+            conv_cfg = dcn
+        self.conv = build_conv_layer(
+            conv_cfg,
+            in_channels,
+            channels * radix,
+            kernel_size,
+            stride=stride,
+            padding=padding,
+            dilation=dilation,
+            groups=groups * radix,
+            bias=False)
+        # To be consistent with original implementation, starting from 0
+        self.norm0_name, norm0 = build_norm_layer(
+            norm_cfg, channels * radix, postfix=0)
+        self.add_module(self.norm0_name, norm0)
+        self.relu = nn.ReLU(inplace=True)
+        self.fc1 = build_conv_layer(
+            None, channels, inter_channels, 1, groups=self.groups)
+        self.norm1_name, norm1 = build_norm_layer(
+            norm_cfg, inter_channels, postfix=1)
+        self.add_module(self.norm1_name, norm1)
+        self.fc2 = build_conv_layer(
+            None, inter_channels, channels * radix, 1, groups=self.groups)
+        self.rsoftmax = RSoftmax(radix, groups)
+
+    @property
+    def norm0(self):
+        """nn.Module: the normalization layer named "norm0" """
+        return getattr(self, self.norm0_name)
+
+    @property
+    def norm1(self):
+        """nn.Module: the normalization layer named "norm1" """
+        return getattr(self, self.norm1_name)
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = self.norm0(x)
+        x = self.relu(x)
+
+        batch, rchannel = x.shape[:2]
+        batch = x.size(0)
+        if self.radix > 1:
+            splits = x.view(batch, self.radix, -1, *x.shape[2:])
+            gap = splits.sum(dim=1)
+        else:
+            gap = x
+        gap = F.adaptive_avg_pool2d(gap, 1)
+        gap = self.fc1(gap)
+
+        gap = self.norm1(gap)
+        gap = self.relu(gap)
+
+        atten = self.fc2(gap)
+        atten = self.rsoftmax(atten).view(batch, -1, 1, 1)
+
+        if self.radix > 1:
+            attens = atten.view(batch, self.radix, -1, *atten.shape[2:])
+            out = torch.sum(attens * splits, dim=1)
+        else:
+            out = atten * x
+        return out.contiguous()
+
+
+class Bottleneck(_Bottleneck):
+    """Bottleneck block for ResNeSt.
+
+    Args:
+        inplane (int): Input planes of this block.
+        planes (int): Middle planes of this block.
+        groups (int): Groups of conv2.
+        base_width (int): Base of width in terms of base channels. Default: 4.
+        base_channels (int): Base of channels for calculating width.
+            Default: 64.
+        radix (int): Radix of SpltAtConv2d. Default: 2
+        reduction_factor (int): Reduction factor of inter_channels in
+            SplitAttentionConv2d. Default: 4.
+        avg_down_stride (bool): Whether to use average pool for stride in
+            Bottleneck. Default: True.
+        kwargs (dict): Key word arguments for base class.
+    """
+    expansion = 4
+
+    def __init__(self,
+                 inplanes,
+                 planes,
+                 groups=1,
+                 base_width=4,
+                 base_channels=64,
+                 radix=2,
+                 reduction_factor=4,
+                 avg_down_stride=True,
+                 **kwargs):
+        """Bottleneck block for ResNeSt."""
+        super(Bottleneck, self).__init__(inplanes, planes, **kwargs)
+
+        if groups == 1:
+            width = self.planes
+        else:
+            width = math.floor(self.planes *
+                               (base_width / base_channels)) * groups
+
+        self.avg_down_stride = avg_down_stride and self.conv2_stride > 1
+
+        self.norm1_name, norm1 = build_norm_layer(
+            self.norm_cfg, width, postfix=1)
+        self.norm3_name, norm3 = build_norm_layer(
+            self.norm_cfg, self.planes * self.expansion, postfix=3)
+
+        self.conv1 = build_conv_layer(
+            self.conv_cfg,
+            self.inplanes,
+            width,
+            kernel_size=1,
+            stride=self.conv1_stride,
+            bias=False)
+        self.add_module(self.norm1_name, norm1)
+        self.with_modulated_dcn = False
+        self.conv2 = SplitAttentionConv2d(
+            width,
+            width,
+            kernel_size=3,
+            stride=1 if self.avg_down_stride else self.conv2_stride,
+            padding=self.dilation,
+            dilation=self.dilation,
+            groups=groups,
+            radix=radix,
+            reduction_factor=reduction_factor,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            dcn=self.dcn)
+        delattr(self, self.norm2_name)
+
+        if self.avg_down_stride:
+            self.avd_layer = nn.AvgPool2d(3, self.conv2_stride, padding=1)
+
+        self.conv3 = build_conv_layer(
+            self.conv_cfg,
+            width,
+            self.planes * self.expansion,
+            kernel_size=1,
+            bias=False)
+        self.add_module(self.norm3_name, norm3)
+
+    def forward(self, x):
+
+        def _inner_forward(x):
+            identity = x
+
+            out = self.conv1(x)
+            out = self.norm1(out)
+            out = self.relu(out)
+
+            if self.with_plugins:
+                out = self.forward_plugin(out, self.after_conv1_plugin_names)
+
+            out = self.conv2(out)
+
+            if self.avg_down_stride:
+                out = self.avd_layer(out)
+
+            if self.with_plugins:
+                out = self.forward_plugin(out, self.after_conv2_plugin_names)
+
+            out = self.conv3(out)
+            out = self.norm3(out)
+
+            if self.with_plugins:
+                out = self.forward_plugin(out, self.after_conv3_plugin_names)
+
+            if self.downsample is not None:
+                identity = self.downsample(x)
+
+            out += identity
+
+            return out
+
+        if self.with_cp and x.requires_grad:
+            out = cp.checkpoint(_inner_forward, x)
+        else:
+            out = _inner_forward(x)
+
+        out = self.relu(out)
+
+        return out
+
+
+@MODELS.register_module()
+class ResNeSt(ResNetV1d):
+    """ResNeSt backbone.
+
+    Args:
+        groups (int): Number of groups of Bottleneck. Default: 1
+        base_width (int): Base width of Bottleneck. Default: 4
+        radix (int): Radix of SplitAttentionConv2d. Default: 2
+        reduction_factor (int): Reduction factor of inter_channels in
+            SplitAttentionConv2d. Default: 4.
+        avg_down_stride (bool): Whether to use average pool for stride in
+            Bottleneck. Default: True.
+        kwargs (dict): Keyword arguments for ResNet.
+    """
+
+    arch_settings = {
+        50: (Bottleneck, (3, 4, 6, 3)),
+        101: (Bottleneck, (3, 4, 23, 3)),
+        152: (Bottleneck, (3, 8, 36, 3)),
+        200: (Bottleneck, (3, 24, 36, 3))
+    }
+
+    def __init__(self,
+                 groups=1,
+                 base_width=4,
+                 radix=2,
+                 reduction_factor=4,
+                 avg_down_stride=True,
+                 **kwargs):
+        self.groups = groups
+        self.base_width = base_width
+        self.radix = radix
+        self.reduction_factor = reduction_factor
+        self.avg_down_stride = avg_down_stride
+        super(ResNeSt, self).__init__(**kwargs)
+
+    def make_res_layer(self, **kwargs):
+        """Pack all blocks in a stage into a ``ResLayer``."""
+        return ResLayer(
+            groups=self.groups,
+            base_width=self.base_width,
+            base_channels=self.base_channels,
+            radix=self.radix,
+            reduction_factor=self.reduction_factor,
+            avg_down_stride=self.avg_down_stride,
+            **kwargs)
diff --git a/mmdetection/mmdet/models/backbones/resnet.py b/mmdetection/mmdet/models/backbones/resnet.py
new file mode 100644
index 00000000..1d6f48f9
--- /dev/null
+++ b/mmdetection/mmdet/models/backbones/resnet.py
@@ -0,0 +1,672 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+
+import torch.nn as nn
+import torch.utils.checkpoint as cp
+from mmcv.cnn import build_conv_layer, build_norm_layer, build_plugin_layer
+from mmengine.model import BaseModule
+from torch.nn.modules.batchnorm import _BatchNorm
+
+from mmdet.registry import MODELS
+from ..layers import ResLayer
+
+
+class BasicBlock(BaseModule):
+    expansion = 1
+
+    def __init__(self,
+                 inplanes,
+                 planes,
+                 stride=1,
+                 dilation=1,
+                 downsample=None,
+                 style='pytorch',
+                 with_cp=False,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 dcn=None,
+                 plugins=None,
+                 init_cfg=None):
+        super(BasicBlock, self).__init__(init_cfg)
+        assert dcn is None, 'Not implemented yet.'
+        assert plugins is None, 'Not implemented yet.'
+
+        self.norm1_name, norm1 = build_norm_layer(norm_cfg, planes, postfix=1)
+        self.norm2_name, norm2 = build_norm_layer(norm_cfg, planes, postfix=2)
+
+        self.conv1 = build_conv_layer(
+            conv_cfg,
+            inplanes,
+            planes,
+            3,
+            stride=stride,
+            padding=dilation,
+            dilation=dilation,
+            bias=False)
+        self.add_module(self.norm1_name, norm1)
+        self.conv2 = build_conv_layer(
+            conv_cfg, planes, planes, 3, padding=1, bias=False)
+        self.add_module(self.norm2_name, norm2)
+
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+        self.dilation = dilation
+        self.with_cp = with_cp
+
+    @property
+    def norm1(self):
+        """nn.Module: normalization layer after the first convolution layer"""
+        return getattr(self, self.norm1_name)
+
+    @property
+    def norm2(self):
+        """nn.Module: normalization layer after the second convolution layer"""
+        return getattr(self, self.norm2_name)
+
+    def forward(self, x):
+        """Forward function."""
+
+        def _inner_forward(x):
+            identity = x
+
+            out = self.conv1(x)
+            out = self.norm1(out)
+            out = self.relu(out)
+
+            out = self.conv2(out)
+            out = self.norm2(out)
+
+            if self.downsample is not None:
+                identity = self.downsample(x)
+
+            out += identity
+
+            return out
+
+        if self.with_cp and x.requires_grad:
+            out = cp.checkpoint(_inner_forward, x)
+        else:
+            out = _inner_forward(x)
+
+        out = self.relu(out)
+
+        return out
+
+
+class Bottleneck(BaseModule):
+    expansion = 4
+
+    def __init__(self,
+                 inplanes,
+                 planes,
+                 stride=1,
+                 dilation=1,
+                 downsample=None,
+                 style='pytorch',
+                 with_cp=False,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 dcn=None,
+                 plugins=None,
+                 init_cfg=None):
+        """Bottleneck block for ResNet.
+
+        If style is "pytorch", the stride-two layer is the 3x3 conv layer, if
+        it is "caffe", the stride-two layer is the first 1x1 conv layer.
+        """
+        super(Bottleneck, self).__init__(init_cfg)
+        assert style in ['pytorch', 'caffe']
+        assert dcn is None or isinstance(dcn, dict)
+        assert plugins is None or isinstance(plugins, list)
+        if plugins is not None:
+            allowed_position = ['after_conv1', 'after_conv2', 'after_conv3']
+            assert all(p['position'] in allowed_position for p in plugins)
+
+        self.inplanes = inplanes
+        self.planes = planes
+        self.stride = stride
+        self.dilation = dilation
+        self.style = style
+        self.with_cp = with_cp
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.dcn = dcn
+        self.with_dcn = dcn is not None
+        self.plugins = plugins
+        self.with_plugins = plugins is not None
+
+        if self.with_plugins:
+            # collect plugins for conv1/conv2/conv3
+            self.after_conv1_plugins = [
+                plugin['cfg'] for plugin in plugins
+                if plugin['position'] == 'after_conv1'
+            ]
+            self.after_conv2_plugins = [
+                plugin['cfg'] for plugin in plugins
+                if plugin['position'] == 'after_conv2'
+            ]
+            self.after_conv3_plugins = [
+                plugin['cfg'] for plugin in plugins
+                if plugin['position'] == 'after_conv3'
+            ]
+
+        if self.style == 'pytorch':
+            self.conv1_stride = 1
+            self.conv2_stride = stride
+        else:
+            self.conv1_stride = stride
+            self.conv2_stride = 1
+
+        self.norm1_name, norm1 = build_norm_layer(norm_cfg, planes, postfix=1)
+        self.norm2_name, norm2 = build_norm_layer(norm_cfg, planes, postfix=2)
+        self.norm3_name, norm3 = build_norm_layer(
+            norm_cfg, planes * self.expansion, postfix=3)
+
+        self.conv1 = build_conv_layer(
+            conv_cfg,
+            inplanes,
+            planes,
+            kernel_size=1,
+            stride=self.conv1_stride,
+            bias=False)
+        self.add_module(self.norm1_name, norm1)
+        fallback_on_stride = False
+        if self.with_dcn:
+            fallback_on_stride = dcn.pop('fallback_on_stride', False)
+        if not self.with_dcn or fallback_on_stride:
+            self.conv2 = build_conv_layer(
+                conv_cfg,
+                planes,
+                planes,
+                kernel_size=3,
+                stride=self.conv2_stride,
+                padding=dilation,
+                dilation=dilation,
+                bias=False)
+        else:
+            assert self.conv_cfg is None, 'conv_cfg must be None for DCN'
+            self.conv2 = build_conv_layer(
+                dcn,
+                planes,
+                planes,
+                kernel_size=3,
+                stride=self.conv2_stride,
+                padding=dilation,
+                dilation=dilation,
+                bias=False)
+
+        self.add_module(self.norm2_name, norm2)
+        self.conv3 = build_conv_layer(
+            conv_cfg,
+            planes,
+            planes * self.expansion,
+            kernel_size=1,
+            bias=False)
+        self.add_module(self.norm3_name, norm3)
+
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+
+        if self.with_plugins:
+            self.after_conv1_plugin_names = self.make_block_plugins(
+                planes, self.after_conv1_plugins)
+            self.after_conv2_plugin_names = self.make_block_plugins(
+                planes, self.after_conv2_plugins)
+            self.after_conv3_plugin_names = self.make_block_plugins(
+                planes * self.expansion, self.after_conv3_plugins)
+
+    def make_block_plugins(self, in_channels, plugins):
+        """make plugins for block.
+
+        Args:
+            in_channels (int): Input channels of plugin.
+            plugins (list[dict]): List of plugins cfg to build.
+
+        Returns:
+            list[str]: List of the names of plugin.
+        """
+        assert isinstance(plugins, list)
+        plugin_names = []
+        for plugin in plugins:
+            plugin = plugin.copy()
+            name, layer = build_plugin_layer(
+                plugin,
+                in_channels=in_channels,
+                postfix=plugin.pop('postfix', ''))
+            assert not hasattr(self, name), f'duplicate plugin {name}'
+            self.add_module(name, layer)
+            plugin_names.append(name)
+        return plugin_names
+
+    def forward_plugin(self, x, plugin_names):
+        out = x
+        for name in plugin_names:
+            out = getattr(self, name)(out)
+        return out
+
+    @property
+    def norm1(self):
+        """nn.Module: normalization layer after the first convolution layer"""
+        return getattr(self, self.norm1_name)
+
+    @property
+    def norm2(self):
+        """nn.Module: normalization layer after the second convolution layer"""
+        return getattr(self, self.norm2_name)
+
+    @property
+    def norm3(self):
+        """nn.Module: normalization layer after the third convolution layer"""
+        return getattr(self, self.norm3_name)
+
+    def forward(self, x):
+        """Forward function."""
+
+        def _inner_forward(x):
+            identity = x
+            out = self.conv1(x)
+            out = self.norm1(out)
+            out = self.relu(out)
+
+            if self.with_plugins:
+                out = self.forward_plugin(out, self.after_conv1_plugin_names)
+
+            out = self.conv2(out)
+            out = self.norm2(out)
+            out = self.relu(out)
+
+            if self.with_plugins:
+                out = self.forward_plugin(out, self.after_conv2_plugin_names)
+
+            out = self.conv3(out)
+            out = self.norm3(out)
+
+            if self.with_plugins:
+                out = self.forward_plugin(out, self.after_conv3_plugin_names)
+
+            if self.downsample is not None:
+                identity = self.downsample(x)
+
+            out += identity
+
+            return out
+
+        if self.with_cp and x.requires_grad:
+            out = cp.checkpoint(_inner_forward, x)
+        else:
+            out = _inner_forward(x)
+
+        out = self.relu(out)
+
+        return out
+
+
+@MODELS.register_module()
+class ResNet(BaseModule):
+    """ResNet backbone.
+
+    Args:
+        depth (int): Depth of resnet, from {18, 34, 50, 101, 152}.
+        stem_channels (int | None): Number of stem channels. If not specified,
+            it will be the same as `base_channels`. Default: None.
+        base_channels (int): Number of base channels of res layer. Default: 64.
+        in_channels (int): Number of input image channels. Default: 3.
+        num_stages (int): Resnet stages. Default: 4.
+        strides (Sequence[int]): Strides of the first block of each stage.
+        dilations (Sequence[int]): Dilation of each stage.
+        out_indices (Sequence[int]): Output from which stages.
+        style (str): `pytorch` or `caffe`. If set to "pytorch", the stride-two
+            layer is the 3x3 conv layer, otherwise the stride-two layer is
+            the first 1x1 conv layer.
+        deep_stem (bool): Replace 7x7 conv in input stem with 3 3x3 conv
+        avg_down (bool): Use AvgPool instead of stride conv when
+            downsampling in the bottleneck.
+        frozen_stages (int): Stages to be frozen (stop grad and set eval mode).
+            -1 means not freezing any parameters.
+        norm_cfg (dict): Dictionary to construct and config norm layer.
+        norm_eval (bool): Whether to set norm layers to eval mode, namely,
+            freeze running stats (mean and var). Note: Effect on Batch Norm
+            and its variants only.
+        plugins (list[dict]): List of plugins for stages, each dict contains:
+
+            - cfg (dict, required): Cfg dict to build plugin.
+            - position (str, required): Position inside block to insert
+              plugin, options are 'after_conv1', 'after_conv2', 'after_conv3'.
+            - stages (tuple[bool], optional): Stages to apply plugin, length
+              should be same as 'num_stages'.
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save some
+            memory while slowing down the training speed.
+        zero_init_residual (bool): Whether to use zero init for last norm layer
+            in resblocks to let them behave as identity.
+        pretrained (str, optional): model pretrained path. Default: None
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None
+
+    Example:
+        >>> from mmdet.models import ResNet
+        >>> import torch
+        >>> self = ResNet(depth=18)
+        >>> self.eval()
+        >>> inputs = torch.rand(1, 3, 32, 32)
+        >>> level_outputs = self.forward(inputs)
+        >>> for level_out in level_outputs:
+        ...     print(tuple(level_out.shape))
+        (1, 64, 8, 8)
+        (1, 128, 4, 4)
+        (1, 256, 2, 2)
+        (1, 512, 1, 1)
+    """
+
+    arch_settings = {
+        18: (BasicBlock, (2, 2, 2, 2)),
+        34: (BasicBlock, (3, 4, 6, 3)),
+        50: (Bottleneck, (3, 4, 6, 3)),
+        101: (Bottleneck, (3, 4, 23, 3)),
+        152: (Bottleneck, (3, 8, 36, 3))
+    }
+
+    def __init__(self,
+                 depth,
+                 in_channels=3,
+                 stem_channels=None,
+                 base_channels=64,
+                 num_stages=4,
+                 strides=(1, 2, 2, 2),
+                 dilations=(1, 1, 1, 1),
+                 out_indices=(0, 1, 2, 3),
+                 style='pytorch',
+                 deep_stem=False,
+                 avg_down=False,
+                 frozen_stages=-1,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN', requires_grad=True),
+                 norm_eval=True,
+                 dcn=None,
+                 stage_with_dcn=(False, False, False, False),
+                 plugins=None,
+                 with_cp=False,
+                 zero_init_residual=True,
+                 pretrained=None,
+                 init_cfg=None):
+        super(ResNet, self).__init__(init_cfg)
+        self.zero_init_residual = zero_init_residual
+        if depth not in self.arch_settings:
+            raise KeyError(f'invalid depth {depth} for resnet')
+
+        block_init_cfg = None
+        assert not (init_cfg and pretrained), \
+            'init_cfg and pretrained cannot be specified at the same time'
+        if isinstance(pretrained, str):
+            warnings.warn('DeprecationWarning: pretrained is deprecated, '
+                          'please use "init_cfg" instead')
+            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
+        elif pretrained is None:
+            if init_cfg is None:
+                self.init_cfg = [
+                    dict(type='Kaiming', layer='Conv2d'),
+                    dict(
+                        type='Constant',
+                        val=1,
+                        layer=['_BatchNorm', 'GroupNorm'])
+                ]
+                block = self.arch_settings[depth][0]
+                if self.zero_init_residual:
+                    if block is BasicBlock:
+                        block_init_cfg = dict(
+                            type='Constant',
+                            val=0,
+                            override=dict(name='norm2'))
+                    elif block is Bottleneck:
+                        block_init_cfg = dict(
+                            type='Constant',
+                            val=0,
+                            override=dict(name='norm3'))
+        else:
+            raise TypeError('pretrained must be a str or None')
+
+        self.depth = depth
+        if stem_channels is None:
+            stem_channels = base_channels
+        self.stem_channels = stem_channels
+        self.base_channels = base_channels
+        self.num_stages = num_stages
+        assert num_stages >= 1 and num_stages <= 4
+        self.strides = strides
+        self.dilations = dilations
+        assert len(strides) == len(dilations) == num_stages
+        self.out_indices = out_indices
+        assert max(out_indices) < num_stages
+        self.style = style
+        self.deep_stem = deep_stem
+        self.avg_down = avg_down
+        self.frozen_stages = frozen_stages
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.with_cp = with_cp
+        self.norm_eval = norm_eval
+        self.dcn = dcn
+        self.stage_with_dcn = stage_with_dcn
+        if dcn is not None:
+            assert len(stage_with_dcn) == num_stages
+        self.plugins = plugins
+        self.block, stage_blocks = self.arch_settings[depth]
+        self.stage_blocks = stage_blocks[:num_stages]
+        self.inplanes = stem_channels
+
+        self._make_stem_layer(in_channels, stem_channels)
+
+        self.res_layers = []
+        for i, num_blocks in enumerate(self.stage_blocks):
+            stride = strides[i]
+            dilation = dilations[i]
+            dcn = self.dcn if self.stage_with_dcn[i] else None
+            if plugins is not None:
+                stage_plugins = self.make_stage_plugins(plugins, i)
+            else:
+                stage_plugins = None
+            planes = base_channels * 2**i
+            res_layer = self.make_res_layer(
+                block=self.block,
+                inplanes=self.inplanes,
+                planes=planes,
+                num_blocks=num_blocks,
+                stride=stride,
+                dilation=dilation,
+                style=self.style,
+                avg_down=self.avg_down,
+                with_cp=with_cp,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                dcn=dcn,
+                plugins=stage_plugins,
+                init_cfg=block_init_cfg)
+            self.inplanes = planes * self.block.expansion
+            layer_name = f'layer{i + 1}'
+            self.add_module(layer_name, res_layer)
+            self.res_layers.append(layer_name)
+
+        self._freeze_stages()
+
+        self.feat_dim = self.block.expansion * base_channels * 2**(
+            len(self.stage_blocks) - 1)
+
+    def make_stage_plugins(self, plugins, stage_idx):
+        """Make plugins for ResNet ``stage_idx`` th stage.
+
+        Currently we support to insert ``context_block``,
+        ``empirical_attention_block``, ``nonlocal_block`` into the backbone
+        like ResNet/ResNeXt. They could be inserted after conv1/conv2/conv3 of
+        Bottleneck.
+
+        An example of plugins format could be:
+
+        Examples:
+            >>> plugins=[
+            ...     dict(cfg=dict(type='xxx', arg1='xxx'),
+            ...          stages=(False, True, True, True),
+            ...          position='after_conv2'),
+            ...     dict(cfg=dict(type='yyy'),
+            ...          stages=(True, True, True, True),
+            ...          position='after_conv3'),
+            ...     dict(cfg=dict(type='zzz', postfix='1'),
+            ...          stages=(True, True, True, True),
+            ...          position='after_conv3'),
+            ...     dict(cfg=dict(type='zzz', postfix='2'),
+            ...          stages=(True, True, True, True),
+            ...          position='after_conv3')
+            ... ]
+            >>> self = ResNet(depth=18)
+            >>> stage_plugins = self.make_stage_plugins(plugins, 0)
+            >>> assert len(stage_plugins) == 3
+
+        Suppose ``stage_idx=0``, the structure of blocks in the stage would be:
+
+        .. code-block:: none
+
+            conv1-> conv2->conv3->yyy->zzz1->zzz2
+
+        Suppose 'stage_idx=1', the structure of blocks in the stage would be:
+
+        .. code-block:: none
+
+            conv1-> conv2->xxx->conv3->yyy->zzz1->zzz2
+
+        If stages is missing, the plugin would be applied to all stages.
+
+        Args:
+            plugins (list[dict]): List of plugins cfg to build. The postfix is
+                required if multiple same type plugins are inserted.
+            stage_idx (int): Index of stage to build
+
+        Returns:
+            list[dict]: Plugins for current stage
+        """
+        stage_plugins = []
+        for plugin in plugins:
+            plugin = plugin.copy()
+            stages = plugin.pop('stages', None)
+            assert stages is None or len(stages) == self.num_stages
+            # whether to insert plugin into current stage
+            if stages is None or stages[stage_idx]:
+                stage_plugins.append(plugin)
+
+        return stage_plugins
+
+    def make_res_layer(self, **kwargs):
+        """Pack all blocks in a stage into a ``ResLayer``."""
+        return ResLayer(**kwargs)
+
+    @property
+    def norm1(self):
+        """nn.Module: the normalization layer named "norm1" """
+        return getattr(self, self.norm1_name)
+
+    def _make_stem_layer(self, in_channels, stem_channels):
+        if self.deep_stem:
+            self.stem = nn.Sequential(
+                build_conv_layer(
+                    self.conv_cfg,
+                    in_channels,
+                    stem_channels // 2,
+                    kernel_size=3,
+                    stride=2,
+                    padding=1,
+                    bias=False),
+                build_norm_layer(self.norm_cfg, stem_channels // 2)[1],
+                nn.ReLU(inplace=True),
+                build_conv_layer(
+                    self.conv_cfg,
+                    stem_channels // 2,
+                    stem_channels // 2,
+                    kernel_size=3,
+                    stride=1,
+                    padding=1,
+                    bias=False),
+                build_norm_layer(self.norm_cfg, stem_channels // 2)[1],
+                nn.ReLU(inplace=True),
+                build_conv_layer(
+                    self.conv_cfg,
+                    stem_channels // 2,
+                    stem_channels,
+                    kernel_size=3,
+                    stride=1,
+                    padding=1,
+                    bias=False),
+                build_norm_layer(self.norm_cfg, stem_channels)[1],
+                nn.ReLU(inplace=True))
+        else:
+            self.conv1 = build_conv_layer(
+                self.conv_cfg,
+                in_channels,
+                stem_channels,
+                kernel_size=7,
+                stride=2,
+                padding=3,
+                bias=False)
+            self.norm1_name, norm1 = build_norm_layer(
+                self.norm_cfg, stem_channels, postfix=1)
+            self.add_module(self.norm1_name, norm1)
+            self.relu = nn.ReLU(inplace=True)
+        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+
+    def _freeze_stages(self):
+        if self.frozen_stages >= 0:
+            if self.deep_stem:
+                self.stem.eval()
+                for param in self.stem.parameters():
+                    param.requires_grad = False
+            else:
+                self.norm1.eval()
+                for m in [self.conv1, self.norm1]:
+                    for param in m.parameters():
+                        param.requires_grad = False
+
+        for i in range(1, self.frozen_stages + 1):
+            m = getattr(self, f'layer{i}')
+            m.eval()
+            for param in m.parameters():
+                param.requires_grad = False
+
+    def forward(self, x):
+        """Forward function."""
+        if self.deep_stem:
+            x = self.stem(x)
+        else:
+            x = self.conv1(x)
+            x = self.norm1(x)
+            x = self.relu(x)
+        x = self.maxpool(x)
+        outs = []
+        for i, layer_name in enumerate(self.res_layers):
+            res_layer = getattr(self, layer_name)
+            x = res_layer(x)
+            if i in self.out_indices:
+                outs.append(x)
+        return tuple(outs)
+
+    def train(self, mode=True):
+        """Convert the model into training mode while keep normalization layer
+        freezed."""
+        super(ResNet, self).train(mode)
+        self._freeze_stages()
+        if mode and self.norm_eval:
+            for m in self.modules():
+                # trick: eval have effect on BatchNorm only
+                if isinstance(m, _BatchNorm):
+                    m.eval()
+
+
+@MODELS.register_module()
+class ResNetV1d(ResNet):
+    r"""ResNetV1d variant described in `Bag of Tricks
+    `_.
+
+    Compared with default ResNet(ResNetV1b), ResNetV1d replaces the 7x7 conv in
+    the input stem with three 3x3 convs. And in the downsampling block, a 2x2
+    avg_pool with stride 2 is added before conv, whose stride is changed to 1.
+    """
+
+    def __init__(self, **kwargs):
+        super(ResNetV1d, self).__init__(
+            deep_stem=True, avg_down=True, **kwargs)
diff --git a/mmdetection/mmdet/models/backbones/resnext.py b/mmdetection/mmdet/models/backbones/resnext.py
new file mode 100644
index 00000000..df3d79e0
--- /dev/null
+++ b/mmdetection/mmdet/models/backbones/resnext.py
@@ -0,0 +1,154 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+
+from mmcv.cnn import build_conv_layer, build_norm_layer
+
+from mmdet.registry import MODELS
+from ..layers import ResLayer
+from .resnet import Bottleneck as _Bottleneck
+from .resnet import ResNet
+
+
+class Bottleneck(_Bottleneck):
+    expansion = 4
+
+    def __init__(self,
+                 inplanes,
+                 planes,
+                 groups=1,
+                 base_width=4,
+                 base_channels=64,
+                 **kwargs):
+        """Bottleneck block for ResNeXt.
+
+        If style is "pytorch", the stride-two layer is the 3x3 conv layer, if
+        it is "caffe", the stride-two layer is the first 1x1 conv layer.
+        """
+        super(Bottleneck, self).__init__(inplanes, planes, **kwargs)
+
+        if groups == 1:
+            width = self.planes
+        else:
+            width = math.floor(self.planes *
+                               (base_width / base_channels)) * groups
+
+        self.norm1_name, norm1 = build_norm_layer(
+            self.norm_cfg, width, postfix=1)
+        self.norm2_name, norm2 = build_norm_layer(
+            self.norm_cfg, width, postfix=2)
+        self.norm3_name, norm3 = build_norm_layer(
+            self.norm_cfg, self.planes * self.expansion, postfix=3)
+
+        self.conv1 = build_conv_layer(
+            self.conv_cfg,
+            self.inplanes,
+            width,
+            kernel_size=1,
+            stride=self.conv1_stride,
+            bias=False)
+        self.add_module(self.norm1_name, norm1)
+        fallback_on_stride = False
+        self.with_modulated_dcn = False
+        if self.with_dcn:
+            fallback_on_stride = self.dcn.pop('fallback_on_stride', False)
+        if not self.with_dcn or fallback_on_stride:
+            self.conv2 = build_conv_layer(
+                self.conv_cfg,
+                width,
+                width,
+                kernel_size=3,
+                stride=self.conv2_stride,
+                padding=self.dilation,
+                dilation=self.dilation,
+                groups=groups,
+                bias=False)
+        else:
+            assert self.conv_cfg is None, 'conv_cfg must be None for DCN'
+            self.conv2 = build_conv_layer(
+                self.dcn,
+                width,
+                width,
+                kernel_size=3,
+                stride=self.conv2_stride,
+                padding=self.dilation,
+                dilation=self.dilation,
+                groups=groups,
+                bias=False)
+
+        self.add_module(self.norm2_name, norm2)
+        self.conv3 = build_conv_layer(
+            self.conv_cfg,
+            width,
+            self.planes * self.expansion,
+            kernel_size=1,
+            bias=False)
+        self.add_module(self.norm3_name, norm3)
+
+        if self.with_plugins:
+            self._del_block_plugins(self.after_conv1_plugin_names +
+                                    self.after_conv2_plugin_names +
+                                    self.after_conv3_plugin_names)
+            self.after_conv1_plugin_names = self.make_block_plugins(
+                width, self.after_conv1_plugins)
+            self.after_conv2_plugin_names = self.make_block_plugins(
+                width, self.after_conv2_plugins)
+            self.after_conv3_plugin_names = self.make_block_plugins(
+                self.planes * self.expansion, self.after_conv3_plugins)
+
+    def _del_block_plugins(self, plugin_names):
+        """delete plugins for block if exist.
+
+        Args:
+            plugin_names (list[str]): List of plugins name to delete.
+        """
+        assert isinstance(plugin_names, list)
+        for plugin_name in plugin_names:
+            del self._modules[plugin_name]
+
+
+@MODELS.register_module()
+class ResNeXt(ResNet):
+    """ResNeXt backbone.
+
+    Args:
+        depth (int): Depth of resnet, from {18, 34, 50, 101, 152}.
+        in_channels (int): Number of input image channels. Default: 3.
+        num_stages (int): Resnet stages. Default: 4.
+        groups (int): Group of resnext.
+        base_width (int): Base width of resnext.
+        strides (Sequence[int]): Strides of the first block of each stage.
+        dilations (Sequence[int]): Dilation of each stage.
+        out_indices (Sequence[int]): Output from which stages.
+        style (str): `pytorch` or `caffe`. If set to "pytorch", the stride-two
+            layer is the 3x3 conv layer, otherwise the stride-two layer is
+            the first 1x1 conv layer.
+        frozen_stages (int): Stages to be frozen (all param fixed). -1 means
+            not freezing any parameters.
+        norm_cfg (dict): dictionary to construct and config norm layer.
+        norm_eval (bool): Whether to set norm layers to eval mode, namely,
+            freeze running stats (mean and var). Note: Effect on Batch Norm
+            and its variants only.
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save some
+            memory while slowing down the training speed.
+        zero_init_residual (bool): whether to use zero init for last norm layer
+            in resblocks to let them behave as identity.
+    """
+
+    arch_settings = {
+        50: (Bottleneck, (3, 4, 6, 3)),
+        101: (Bottleneck, (3, 4, 23, 3)),
+        152: (Bottleneck, (3, 8, 36, 3))
+    }
+
+    def __init__(self, groups=1, base_width=4, **kwargs):
+        self.groups = groups
+        self.base_width = base_width
+        super(ResNeXt, self).__init__(**kwargs)
+
+    def make_res_layer(self, **kwargs):
+        """Pack all blocks in a stage into a ``ResLayer``"""
+        return ResLayer(
+            groups=self.groups,
+            base_width=self.base_width,
+            base_channels=self.base_channels,
+            **kwargs)
diff --git a/mmdetection/mmdet/models/backbones/ssd_vgg.py b/mmdetection/mmdet/models/backbones/ssd_vgg.py
new file mode 100644
index 00000000..843e82e2
--- /dev/null
+++ b/mmdetection/mmdet/models/backbones/ssd_vgg.py
@@ -0,0 +1,128 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+
+import torch.nn as nn
+from mmcv.cnn import VGG
+from mmengine.model import BaseModule
+
+from mmdet.registry import MODELS
+from ..necks import ssd_neck
+
+
+@MODELS.register_module()
+class SSDVGG(VGG, BaseModule):
+    """VGG Backbone network for single-shot-detection.
+
+    Args:
+        depth (int): Depth of vgg, from {11, 13, 16, 19}.
+        with_last_pool (bool): Whether to add a pooling layer at the last
+            of the model
+        ceil_mode (bool): When True, will use `ceil` instead of `floor`
+            to compute the output shape.
+        out_indices (Sequence[int]): Output from which stages.
+        out_feature_indices (Sequence[int]): Output from which feature map.
+        pretrained (str, optional): model pretrained path. Default: None
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None
+        input_size (int, optional): Deprecated argumment.
+            Width and height of input, from {300, 512}.
+        l2_norm_scale (float, optional) : Deprecated argumment.
+            L2 normalization layer init scale.
+
+    Example:
+        >>> self = SSDVGG(input_size=300, depth=11)
+        >>> self.eval()
+        >>> inputs = torch.rand(1, 3, 300, 300)
+        >>> level_outputs = self.forward(inputs)
+        >>> for level_out in level_outputs:
+        ...     print(tuple(level_out.shape))
+        (1, 1024, 19, 19)
+        (1, 512, 10, 10)
+        (1, 256, 5, 5)
+        (1, 256, 3, 3)
+        (1, 256, 1, 1)
+    """
+    extra_setting = {
+        300: (256, 'S', 512, 128, 'S', 256, 128, 256, 128, 256),
+        512: (256, 'S', 512, 128, 'S', 256, 128, 'S', 256, 128, 'S', 256, 128),
+    }
+
+    def __init__(self,
+                 depth,
+                 with_last_pool=False,
+                 ceil_mode=True,
+                 out_indices=(3, 4),
+                 out_feature_indices=(22, 34),
+                 pretrained=None,
+                 init_cfg=None,
+                 input_size=None,
+                 l2_norm_scale=None):
+        # TODO: in_channels for mmcv.VGG
+        super(SSDVGG, self).__init__(
+            depth,
+            with_last_pool=with_last_pool,
+            ceil_mode=ceil_mode,
+            out_indices=out_indices)
+
+        self.features.add_module(
+            str(len(self.features)),
+            nn.MaxPool2d(kernel_size=3, stride=1, padding=1))
+        self.features.add_module(
+            str(len(self.features)),
+            nn.Conv2d(512, 1024, kernel_size=3, padding=6, dilation=6))
+        self.features.add_module(
+            str(len(self.features)), nn.ReLU(inplace=True))
+        self.features.add_module(
+            str(len(self.features)), nn.Conv2d(1024, 1024, kernel_size=1))
+        self.features.add_module(
+            str(len(self.features)), nn.ReLU(inplace=True))
+        self.out_feature_indices = out_feature_indices
+
+        assert not (init_cfg and pretrained), \
+            'init_cfg and pretrained cannot be specified at the same time'
+
+        if init_cfg is not None:
+            self.init_cfg = init_cfg
+        elif isinstance(pretrained, str):
+            warnings.warn('DeprecationWarning: pretrained is deprecated, '
+                          'please use "init_cfg" instead')
+            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
+        elif pretrained is None:
+            self.init_cfg = [
+                dict(type='Kaiming', layer='Conv2d'),
+                dict(type='Constant', val=1, layer='BatchNorm2d'),
+                dict(type='Normal', std=0.01, layer='Linear'),
+            ]
+        else:
+            raise TypeError('pretrained must be a str or None')
+
+        if input_size is not None:
+            warnings.warn('DeprecationWarning: input_size is deprecated')
+        if l2_norm_scale is not None:
+            warnings.warn('DeprecationWarning: l2_norm_scale in VGG is '
+                          'deprecated, it has been moved to SSDNeck.')
+
+    def init_weights(self, pretrained=None):
+        super(VGG, self).init_weights()
+
+    def forward(self, x):
+        """Forward function."""
+        outs = []
+        for i, layer in enumerate(self.features):
+            x = layer(x)
+            if i in self.out_feature_indices:
+                outs.append(x)
+
+        if len(outs) == 1:
+            return outs[0]
+        else:
+            return tuple(outs)
+
+
+class L2Norm(ssd_neck.L2Norm):
+
+    def __init__(self, **kwargs):
+        super(L2Norm, self).__init__(**kwargs)
+        warnings.warn('DeprecationWarning: L2Norm in ssd_vgg.py '
+                      'is deprecated, please use L2Norm in '
+                      'mmdet/models/necks/ssd_neck.py instead')
diff --git a/mmdetection/mmdet/models/backbones/swin.py b/mmdetection/mmdet/models/backbones/swin.py
new file mode 100644
index 00000000..062190fa
--- /dev/null
+++ b/mmdetection/mmdet/models/backbones/swin.py
@@ -0,0 +1,819 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+from collections import OrderedDict
+from copy import deepcopy
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.checkpoint as cp
+from mmcv.cnn import build_norm_layer
+from mmcv.cnn.bricks.transformer import FFN, build_dropout
+from mmengine.logging import MMLogger
+from mmengine.model import BaseModule, ModuleList
+from mmengine.model.weight_init import (constant_init, trunc_normal_,
+                                        trunc_normal_init)
+from mmengine.runner.checkpoint import CheckpointLoader
+from mmengine.utils import to_2tuple
+
+from mmdet.registry import MODELS
+from ..layers import PatchEmbed, PatchMerging
+
+
+class WindowMSA(BaseModule):
+    """Window based multi-head self-attention (W-MSA) module with relative
+    position bias.
+
+    Args:
+        embed_dims (int): Number of input channels.
+        num_heads (int): Number of attention heads.
+        window_size (tuple[int]): The height and width of the window.
+        qkv_bias (bool, optional):  If True, add a learnable bias to q, k, v.
+            Default: True.
+        qk_scale (float | None, optional): Override default qk scale of
+            head_dim ** -0.5 if set. Default: None.
+        attn_drop_rate (float, optional): Dropout ratio of attention weight.
+            Default: 0.0
+        proj_drop_rate (float, optional): Dropout ratio of output. Default: 0.
+        init_cfg (dict | None, optional): The Config for initialization.
+            Default: None.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 num_heads,
+                 window_size,
+                 qkv_bias=True,
+                 qk_scale=None,
+                 attn_drop_rate=0.,
+                 proj_drop_rate=0.,
+                 init_cfg=None):
+
+        super().__init__()
+        self.embed_dims = embed_dims
+        self.window_size = window_size  # Wh, Ww
+        self.num_heads = num_heads
+        head_embed_dims = embed_dims // num_heads
+        self.scale = qk_scale or head_embed_dims**-0.5
+        self.init_cfg = init_cfg
+
+        # define a parameter table of relative position bias
+        self.relative_position_bias_table = nn.Parameter(
+            torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1),
+                        num_heads))  # 2*Wh-1 * 2*Ww-1, nH
+
+        # About 2x faster than original impl
+        Wh, Ww = self.window_size
+        rel_index_coords = self.double_step_seq(2 * Ww - 1, Wh, 1, Ww)
+        rel_position_index = rel_index_coords + rel_index_coords.T
+        rel_position_index = rel_position_index.flip(1).contiguous()
+        self.register_buffer('relative_position_index', rel_position_index)
+
+        self.qkv = nn.Linear(embed_dims, embed_dims * 3, bias=qkv_bias)
+        self.attn_drop = nn.Dropout(attn_drop_rate)
+        self.proj = nn.Linear(embed_dims, embed_dims)
+        self.proj_drop = nn.Dropout(proj_drop_rate)
+
+        self.softmax = nn.Softmax(dim=-1)
+
+    def init_weights(self):
+        trunc_normal_(self.relative_position_bias_table, std=0.02)
+
+    def forward(self, x, mask=None):
+        """
+        Args:
+
+            x (tensor): input features with shape of (num_windows*B, N, C)
+            mask (tensor | None, Optional): mask with shape of (num_windows,
+                Wh*Ww, Wh*Ww), value should be between (-inf, 0].
+        """
+        B, N, C = x.shape
+        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads,
+                                  C // self.num_heads).permute(2, 0, 3, 1, 4)
+        # make torchscript happy (cannot use tensor as tuple)
+        q, k, v = qkv[0], qkv[1], qkv[2]
+
+        q = q * self.scale
+        attn = (q @ k.transpose(-2, -1))
+
+        relative_position_bias = self.relative_position_bias_table[
+            self.relative_position_index.view(-1)].view(
+                self.window_size[0] * self.window_size[1],
+                self.window_size[0] * self.window_size[1],
+                -1)  # Wh*Ww,Wh*Ww,nH
+        relative_position_bias = relative_position_bias.permute(
+            2, 0, 1).contiguous()  # nH, Wh*Ww, Wh*Ww
+        attn = attn + relative_position_bias.unsqueeze(0)
+
+        if mask is not None:
+            nW = mask.shape[0]
+            attn = attn.view(B // nW, nW, self.num_heads, N,
+                             N) + mask.unsqueeze(1).unsqueeze(0)
+            attn = attn.view(-1, self.num_heads, N, N)
+        attn = self.softmax(attn)
+
+        attn = self.attn_drop(attn)
+
+        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+    @staticmethod
+    def double_step_seq(step1, len1, step2, len2):
+        seq1 = torch.arange(0, step1 * len1, step1)
+        seq2 = torch.arange(0, step2 * len2, step2)
+        return (seq1[:, None] + seq2[None, :]).reshape(1, -1)
+
+
+class ShiftWindowMSA(BaseModule):
+    """Shifted Window Multihead Self-Attention Module.
+
+    Args:
+        embed_dims (int): Number of input channels.
+        num_heads (int): Number of attention heads.
+        window_size (int): The height and width of the window.
+        shift_size (int, optional): The shift step of each window towards
+            right-bottom. If zero, act as regular window-msa. Defaults to 0.
+        qkv_bias (bool, optional): If True, add a learnable bias to q, k, v.
+            Default: True
+        qk_scale (float | None, optional): Override default qk scale of
+            head_dim ** -0.5 if set. Defaults: None.
+        attn_drop_rate (float, optional): Dropout ratio of attention weight.
+            Defaults: 0.
+        proj_drop_rate (float, optional): Dropout ratio of output.
+            Defaults: 0.
+        dropout_layer (dict, optional): The dropout_layer used before output.
+            Defaults: dict(type='DropPath', drop_prob=0.).
+        init_cfg (dict, optional): The extra config for initialization.
+            Default: None.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 num_heads,
+                 window_size,
+                 shift_size=0,
+                 qkv_bias=True,
+                 qk_scale=None,
+                 attn_drop_rate=0,
+                 proj_drop_rate=0,
+                 dropout_layer=dict(type='DropPath', drop_prob=0.),
+                 init_cfg=None):
+        super().__init__(init_cfg)
+
+        self.window_size = window_size
+        self.shift_size = shift_size
+        assert 0 <= self.shift_size < self.window_size
+
+        self.w_msa = WindowMSA(
+            embed_dims=embed_dims,
+            num_heads=num_heads,
+            window_size=to_2tuple(window_size),
+            qkv_bias=qkv_bias,
+            qk_scale=qk_scale,
+            attn_drop_rate=attn_drop_rate,
+            proj_drop_rate=proj_drop_rate,
+            init_cfg=None)
+
+        self.drop = build_dropout(dropout_layer)
+
+    def forward(self, query, hw_shape):
+        B, L, C = query.shape
+        H, W = hw_shape
+        assert L == H * W, 'input feature has wrong size'
+        query = query.view(B, H, W, C)
+
+        # pad feature maps to multiples of window size
+        pad_r = (self.window_size - W % self.window_size) % self.window_size
+        pad_b = (self.window_size - H % self.window_size) % self.window_size
+        query = F.pad(query, (0, 0, 0, pad_r, 0, pad_b))
+        H_pad, W_pad = query.shape[1], query.shape[2]
+
+        # cyclic shift
+        if self.shift_size > 0:
+            shifted_query = torch.roll(
+                query,
+                shifts=(-self.shift_size, -self.shift_size),
+                dims=(1, 2))
+
+            # calculate attention mask for SW-MSA
+            img_mask = torch.zeros((1, H_pad, W_pad, 1), device=query.device)
+            h_slices = (slice(0, -self.window_size),
+                        slice(-self.window_size,
+                              -self.shift_size), slice(-self.shift_size, None))
+            w_slices = (slice(0, -self.window_size),
+                        slice(-self.window_size,
+                              -self.shift_size), slice(-self.shift_size, None))
+            cnt = 0
+            for h in h_slices:
+                for w in w_slices:
+                    img_mask[:, h, w, :] = cnt
+                    cnt += 1
+
+            # nW, window_size, window_size, 1
+            mask_windows = self.window_partition(img_mask)
+            mask_windows = mask_windows.view(
+                -1, self.window_size * self.window_size)
+            attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
+            attn_mask = attn_mask.masked_fill(attn_mask != 0,
+                                              float(-100.0)).masked_fill(
+                                                  attn_mask == 0, float(0.0))
+        else:
+            shifted_query = query
+            attn_mask = None
+
+        # nW*B, window_size, window_size, C
+        query_windows = self.window_partition(shifted_query)
+        # nW*B, window_size*window_size, C
+        query_windows = query_windows.view(-1, self.window_size**2, C)
+
+        # W-MSA/SW-MSA (nW*B, window_size*window_size, C)
+        attn_windows = self.w_msa(query_windows, mask=attn_mask)
+
+        # merge windows
+        attn_windows = attn_windows.view(-1, self.window_size,
+                                         self.window_size, C)
+
+        # B H' W' C
+        shifted_x = self.window_reverse(attn_windows, H_pad, W_pad)
+        # reverse cyclic shift
+        if self.shift_size > 0:
+            x = torch.roll(
+                shifted_x,
+                shifts=(self.shift_size, self.shift_size),
+                dims=(1, 2))
+        else:
+            x = shifted_x
+
+        if pad_r > 0 or pad_b:
+            x = x[:, :H, :W, :].contiguous()
+
+        x = x.view(B, H * W, C)
+
+        x = self.drop(x)
+        return x
+
+    def window_reverse(self, windows, H, W):
+        """
+        Args:
+            windows: (num_windows*B, window_size, window_size, C)
+            H (int): Height of image
+            W (int): Width of image
+        Returns:
+            x: (B, H, W, C)
+        """
+        window_size = self.window_size
+        B = int(windows.shape[0] / (H * W / window_size / window_size))
+        x = windows.view(B, H // window_size, W // window_size, window_size,
+                         window_size, -1)
+        x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)
+        return x
+
+    def window_partition(self, x):
+        """
+        Args:
+            x: (B, H, W, C)
+        Returns:
+            windows: (num_windows*B, window_size, window_size, C)
+        """
+        B, H, W, C = x.shape
+        window_size = self.window_size
+        x = x.view(B, H // window_size, window_size, W // window_size,
+                   window_size, C)
+        windows = x.permute(0, 1, 3, 2, 4, 5).contiguous()
+        windows = windows.view(-1, window_size, window_size, C)
+        return windows
+
+
+class SwinBlock(BaseModule):
+    """"
+    Args:
+        embed_dims (int): The feature dimension.
+        num_heads (int): Parallel attention heads.
+        feedforward_channels (int): The hidden dimension for FFNs.
+        window_size (int, optional): The local window scale. Default: 7.
+        shift (bool, optional): whether to shift window or not. Default False.
+        qkv_bias (bool, optional): enable bias for qkv if True. Default: True.
+        qk_scale (float | None, optional): Override default qk scale of
+            head_dim ** -0.5 if set. Default: None.
+        drop_rate (float, optional): Dropout rate. Default: 0.
+        attn_drop_rate (float, optional): Attention dropout rate. Default: 0.
+        drop_path_rate (float, optional): Stochastic depth rate. Default: 0.
+        act_cfg (dict, optional): The config dict of activation function.
+            Default: dict(type='GELU').
+        norm_cfg (dict, optional): The config dict of normalization.
+            Default: dict(type='LN').
+        with_cp (bool, optional): Use checkpoint or not. Using checkpoint
+            will save some memory while slowing down the training speed.
+            Default: False.
+        init_cfg (dict | list | None, optional): The init config.
+            Default: None.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 num_heads,
+                 feedforward_channels,
+                 window_size=7,
+                 shift=False,
+                 qkv_bias=True,
+                 qk_scale=None,
+                 drop_rate=0.,
+                 attn_drop_rate=0.,
+                 drop_path_rate=0.,
+                 act_cfg=dict(type='GELU'),
+                 norm_cfg=dict(type='LN'),
+                 with_cp=False,
+                 init_cfg=None):
+
+        super(SwinBlock, self).__init__()
+
+        self.init_cfg = init_cfg
+        self.with_cp = with_cp
+
+        self.norm1 = build_norm_layer(norm_cfg, embed_dims)[1]
+        self.attn = ShiftWindowMSA(
+            embed_dims=embed_dims,
+            num_heads=num_heads,
+            window_size=window_size,
+            shift_size=window_size // 2 if shift else 0,
+            qkv_bias=qkv_bias,
+            qk_scale=qk_scale,
+            attn_drop_rate=attn_drop_rate,
+            proj_drop_rate=drop_rate,
+            dropout_layer=dict(type='DropPath', drop_prob=drop_path_rate),
+            init_cfg=None)
+
+        self.norm2 = build_norm_layer(norm_cfg, embed_dims)[1]
+        self.ffn = FFN(
+            embed_dims=embed_dims,
+            feedforward_channels=feedforward_channels,
+            num_fcs=2,
+            ffn_drop=drop_rate,
+            dropout_layer=dict(type='DropPath', drop_prob=drop_path_rate),
+            act_cfg=act_cfg,
+            add_identity=True,
+            init_cfg=None)
+
+    def forward(self, x, hw_shape):
+
+        def _inner_forward(x):
+            identity = x
+            x = self.norm1(x)
+            x = self.attn(x, hw_shape)
+
+            x = x + identity
+
+            identity = x
+            x = self.norm2(x)
+            x = self.ffn(x, identity=identity)
+
+            return x
+
+        if self.with_cp and x.requires_grad:
+            x = cp.checkpoint(_inner_forward, x)
+        else:
+            x = _inner_forward(x)
+
+        return x
+
+
+class SwinBlockSequence(BaseModule):
+    """Implements one stage in Swin Transformer.
+
+    Args:
+        embed_dims (int): The feature dimension.
+        num_heads (int): Parallel attention heads.
+        feedforward_channels (int): The hidden dimension for FFNs.
+        depth (int): The number of blocks in this stage.
+        window_size (int, optional): The local window scale. Default: 7.
+        qkv_bias (bool, optional): enable bias for qkv if True. Default: True.
+        qk_scale (float | None, optional): Override default qk scale of
+            head_dim ** -0.5 if set. Default: None.
+        drop_rate (float, optional): Dropout rate. Default: 0.
+        attn_drop_rate (float, optional): Attention dropout rate. Default: 0.
+        drop_path_rate (float | list[float], optional): Stochastic depth
+            rate. Default: 0.
+        downsample (BaseModule | None, optional): The downsample operation
+            module. Default: None.
+        act_cfg (dict, optional): The config dict of activation function.
+            Default: dict(type='GELU').
+        norm_cfg (dict, optional): The config dict of normalization.
+            Default: dict(type='LN').
+        with_cp (bool, optional): Use checkpoint or not. Using checkpoint
+            will save some memory while slowing down the training speed.
+            Default: False.
+        init_cfg (dict | list | None, optional): The init config.
+            Default: None.
+    """
+
+    def __init__(self,
+                 embed_dims,
+                 num_heads,
+                 feedforward_channels,
+                 depth,
+                 window_size=7,
+                 qkv_bias=True,
+                 qk_scale=None,
+                 drop_rate=0.,
+                 attn_drop_rate=0.,
+                 drop_path_rate=0.,
+                 downsample=None,
+                 act_cfg=dict(type='GELU'),
+                 norm_cfg=dict(type='LN'),
+                 with_cp=False,
+                 init_cfg=None):
+        super().__init__(init_cfg=init_cfg)
+
+        if isinstance(drop_path_rate, list):
+            drop_path_rates = drop_path_rate
+            assert len(drop_path_rates) == depth
+        else:
+            drop_path_rates = [deepcopy(drop_path_rate) for _ in range(depth)]
+
+        self.blocks = ModuleList()
+        for i in range(depth):
+            block = SwinBlock(
+                embed_dims=embed_dims,
+                num_heads=num_heads,
+                feedforward_channels=feedforward_channels,
+                window_size=window_size,
+                shift=False if i % 2 == 0 else True,
+                qkv_bias=qkv_bias,
+                qk_scale=qk_scale,
+                drop_rate=drop_rate,
+                attn_drop_rate=attn_drop_rate,
+                drop_path_rate=drop_path_rates[i],
+                act_cfg=act_cfg,
+                norm_cfg=norm_cfg,
+                with_cp=with_cp,
+                init_cfg=None)
+            self.blocks.append(block)
+
+        self.downsample = downsample
+
+    def forward(self, x, hw_shape):
+        for block in self.blocks:
+            x = block(x, hw_shape)
+
+        if self.downsample:
+            x_down, down_hw_shape = self.downsample(x, hw_shape)
+            return x_down, down_hw_shape, x, hw_shape
+        else:
+            return x, hw_shape, x, hw_shape
+
+
+@MODELS.register_module()
+class SwinTransformer(BaseModule):
+    """ Swin Transformer
+    A PyTorch implement of : `Swin Transformer:
+    Hierarchical Vision Transformer using Shifted Windows`  -
+        https://arxiv.org/abs/2103.14030
+
+    Inspiration from
+    https://github.com/microsoft/Swin-Transformer
+
+    Args:
+        pretrain_img_size (int | tuple[int]): The size of input image when
+            pretrain. Defaults: 224.
+        in_channels (int): The num of input channels.
+            Defaults: 3.
+        embed_dims (int): The feature dimension. Default: 96.
+        patch_size (int | tuple[int]): Patch size. Default: 4.
+        window_size (int): Window size. Default: 7.
+        mlp_ratio (int): Ratio of mlp hidden dim to embedding dim.
+            Default: 4.
+        depths (tuple[int]): Depths of each Swin Transformer stage.
+            Default: (2, 2, 6, 2).
+        num_heads (tuple[int]): Parallel attention heads of each Swin
+            Transformer stage. Default: (3, 6, 12, 24).
+        strides (tuple[int]): The patch merging or patch embedding stride of
+            each Swin Transformer stage. (In swin, we set kernel size equal to
+            stride.) Default: (4, 2, 2, 2).
+        out_indices (tuple[int]): Output from which stages.
+            Default: (0, 1, 2, 3).
+        qkv_bias (bool, optional): If True, add a learnable bias to query, key,
+            value. Default: True
+        qk_scale (float | None, optional): Override default qk scale of
+            head_dim ** -0.5 if set. Default: None.
+        patch_norm (bool): If add a norm layer for patch embed and patch
+            merging. Default: True.
+        drop_rate (float): Dropout rate. Defaults: 0.
+        attn_drop_rate (float): Attention dropout rate. Default: 0.
+        drop_path_rate (float): Stochastic depth rate. Defaults: 0.1.
+        use_abs_pos_embed (bool): If True, add absolute position embedding to
+            the patch embedding. Defaults: False.
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='GELU').
+        norm_cfg (dict): Config dict for normalization layer at
+            output of backone. Defaults: dict(type='LN').
+        with_cp (bool, optional): Use checkpoint or not. Using checkpoint
+            will save some memory while slowing down the training speed.
+            Default: False.
+        pretrained (str, optional): model pretrained path. Default: None.
+        convert_weights (bool): The flag indicates whether the
+            pre-trained model is from the original repo. We may need
+            to convert some keys to make it compatible.
+            Default: False.
+        frozen_stages (int): Stages to be frozen (stop grad and set eval mode).
+            Default: -1 (-1 means not freezing any parameters).
+        init_cfg (dict, optional): The Config for initialization.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 pretrain_img_size=224,
+                 in_channels=3,
+                 embed_dims=96,
+                 patch_size=4,
+                 window_size=7,
+                 mlp_ratio=4,
+                 depths=(2, 2, 6, 2),
+                 num_heads=(3, 6, 12, 24),
+                 strides=(4, 2, 2, 2),
+                 out_indices=(0, 1, 2, 3),
+                 qkv_bias=True,
+                 qk_scale=None,
+                 patch_norm=True,
+                 drop_rate=0.,
+                 attn_drop_rate=0.,
+                 drop_path_rate=0.1,
+                 use_abs_pos_embed=False,
+                 act_cfg=dict(type='GELU'),
+                 norm_cfg=dict(type='LN'),
+                 with_cp=False,
+                 pretrained=None,
+                 convert_weights=False,
+                 frozen_stages=-1,
+                 init_cfg=None):
+        self.convert_weights = convert_weights
+        self.frozen_stages = frozen_stages
+        if isinstance(pretrain_img_size, int):
+            pretrain_img_size = to_2tuple(pretrain_img_size)
+        elif isinstance(pretrain_img_size, tuple):
+            if len(pretrain_img_size) == 1:
+                pretrain_img_size = to_2tuple(pretrain_img_size[0])
+            assert len(pretrain_img_size) == 2, \
+                f'The size of image should have length 1 or 2, ' \
+                f'but got {len(pretrain_img_size)}'
+
+        assert not (init_cfg and pretrained), \
+            'init_cfg and pretrained cannot be specified at the same time'
+        if isinstance(pretrained, str):
+            warnings.warn('DeprecationWarning: pretrained is deprecated, '
+                          'please use "init_cfg" instead')
+            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
+        elif pretrained is None:
+            self.init_cfg = init_cfg
+        else:
+            raise TypeError('pretrained must be a str or None')
+
+        super(SwinTransformer, self).__init__(init_cfg=init_cfg)
+
+        num_layers = len(depths)
+        self.out_indices = out_indices
+        self.use_abs_pos_embed = use_abs_pos_embed
+
+        assert strides[0] == patch_size, 'Use non-overlapping patch embed.'
+
+        self.patch_embed = PatchEmbed(
+            in_channels=in_channels,
+            embed_dims=embed_dims,
+            conv_type='Conv2d',
+            kernel_size=patch_size,
+            stride=strides[0],
+            norm_cfg=norm_cfg if patch_norm else None,
+            init_cfg=None)
+
+        if self.use_abs_pos_embed:
+            patch_row = pretrain_img_size[0] // patch_size
+            patch_col = pretrain_img_size[1] // patch_size
+            num_patches = patch_row * patch_col
+            self.absolute_pos_embed = nn.Parameter(
+                torch.zeros((1, num_patches, embed_dims)))
+
+        self.drop_after_pos = nn.Dropout(p=drop_rate)
+
+        # set stochastic depth decay rule
+        total_depth = sum(depths)
+        dpr = [
+            x.item() for x in torch.linspace(0, drop_path_rate, total_depth)
+        ]
+
+        self.stages = ModuleList()
+        in_channels = embed_dims
+        for i in range(num_layers):
+            if i < num_layers - 1:
+                downsample = PatchMerging(
+                    in_channels=in_channels,
+                    out_channels=2 * in_channels,
+                    stride=strides[i + 1],
+                    norm_cfg=norm_cfg if patch_norm else None,
+                    init_cfg=None)
+            else:
+                downsample = None
+
+            stage = SwinBlockSequence(
+                embed_dims=in_channels,
+                num_heads=num_heads[i],
+                feedforward_channels=mlp_ratio * in_channels,
+                depth=depths[i],
+                window_size=window_size,
+                qkv_bias=qkv_bias,
+                qk_scale=qk_scale,
+                drop_rate=drop_rate,
+                attn_drop_rate=attn_drop_rate,
+                drop_path_rate=dpr[sum(depths[:i]):sum(depths[:i + 1])],
+                downsample=downsample,
+                act_cfg=act_cfg,
+                norm_cfg=norm_cfg,
+                with_cp=with_cp,
+                init_cfg=None)
+            self.stages.append(stage)
+            if downsample:
+                in_channels = downsample.out_channels
+
+        self.num_features = [int(embed_dims * 2**i) for i in range(num_layers)]
+        # Add a norm layer for each output
+        for i in out_indices:
+            layer = build_norm_layer(norm_cfg, self.num_features[i])[1]
+            layer_name = f'norm{i}'
+            self.add_module(layer_name, layer)
+
+    def train(self, mode=True):
+        """Convert the model into training mode while keep layers freezed."""
+        super(SwinTransformer, self).train(mode)
+        self._freeze_stages()
+
+    def _freeze_stages(self):
+        if self.frozen_stages >= 0:
+            self.patch_embed.eval()
+            for param in self.patch_embed.parameters():
+                param.requires_grad = False
+            if self.use_abs_pos_embed:
+                self.absolute_pos_embed.requires_grad = False
+            self.drop_after_pos.eval()
+
+        for i in range(1, self.frozen_stages + 1):
+
+            if (i - 1) in self.out_indices:
+                norm_layer = getattr(self, f'norm{i-1}')
+                norm_layer.eval()
+                for param in norm_layer.parameters():
+                    param.requires_grad = False
+
+            m = self.stages[i - 1]
+            m.eval()
+            for param in m.parameters():
+                param.requires_grad = False
+
+    def init_weights(self):
+        logger = MMLogger.get_current_instance()
+        if self.init_cfg is None:
+            logger.warn(f'No pre-trained weights for '
+                        f'{self.__class__.__name__}, '
+                        f'training start from scratch')
+            if self.use_abs_pos_embed:
+                trunc_normal_(self.absolute_pos_embed, std=0.02)
+            for m in self.modules():
+                if isinstance(m, nn.Linear):
+                    trunc_normal_init(m, std=.02, bias=0.)
+                elif isinstance(m, nn.LayerNorm):
+                    constant_init(m, 1.0)
+        else:
+            assert 'checkpoint' in self.init_cfg, f'Only support ' \
+                                                  f'specify `Pretrained` in ' \
+                                                  f'`init_cfg` in ' \
+                                                  f'{self.__class__.__name__} '
+            ckpt = CheckpointLoader.load_checkpoint(
+                self.init_cfg.checkpoint, logger=logger, map_location='cpu')
+            if 'state_dict' in ckpt:
+                _state_dict = ckpt['state_dict']
+            elif 'model' in ckpt:
+                _state_dict = ckpt['model']
+            else:
+                _state_dict = ckpt
+            if self.convert_weights:
+                # supported loading weight from original repo,
+                _state_dict = swin_converter(_state_dict)
+
+            state_dict = OrderedDict()
+            for k, v in _state_dict.items():
+                if k.startswith('backbone.'):
+                    state_dict[k[9:]] = v
+
+            # strip prefix of state_dict
+            if list(state_dict.keys())[0].startswith('module.'):
+                state_dict = {k[7:]: v for k, v in state_dict.items()}
+
+            # reshape absolute position embedding
+            if state_dict.get('absolute_pos_embed') is not None:
+                absolute_pos_embed = state_dict['absolute_pos_embed']
+                N1, L, C1 = absolute_pos_embed.size()
+                N2, C2, H, W = self.absolute_pos_embed.size()
+                if N1 != N2 or C1 != C2 or L != H * W:
+                    logger.warning('Error in loading absolute_pos_embed, pass')
+                else:
+                    state_dict['absolute_pos_embed'] = absolute_pos_embed.view(
+                        N2, H, W, C2).permute(0, 3, 1, 2).contiguous()
+
+            # interpolate position bias table if needed
+            relative_position_bias_table_keys = [
+                k for k in state_dict.keys()
+                if 'relative_position_bias_table' in k
+            ]
+            for table_key in relative_position_bias_table_keys:
+                table_pretrained = state_dict[table_key]
+                table_current = self.state_dict()[table_key]
+                L1, nH1 = table_pretrained.size()
+                L2, nH2 = table_current.size()
+                if nH1 != nH2:
+                    logger.warning(f'Error in loading {table_key}, pass')
+                elif L1 != L2:
+                    S1 = int(L1**0.5)
+                    S2 = int(L2**0.5)
+                    table_pretrained_resized = F.interpolate(
+                        table_pretrained.permute(1, 0).reshape(1, nH1, S1, S1),
+                        size=(S2, S2),
+                        mode='bicubic')
+                    state_dict[table_key] = table_pretrained_resized.view(
+                        nH2, L2).permute(1, 0).contiguous()
+
+            # load state_dict
+            self.load_state_dict(state_dict, False)
+
+    def forward(self, x):
+        x, hw_shape = self.patch_embed(x)
+
+        if self.use_abs_pos_embed:
+            x = x + self.absolute_pos_embed
+        x = self.drop_after_pos(x)
+
+        outs = []
+        for i, stage in enumerate(self.stages):
+            x, hw_shape, out, out_hw_shape = stage(x, hw_shape)
+            if i in self.out_indices:
+                norm_layer = getattr(self, f'norm{i}')
+                out = norm_layer(out)
+                out = out.view(-1, *out_hw_shape,
+                               self.num_features[i]).permute(0, 3, 1,
+                                                             2).contiguous()
+                outs.append(out)
+
+        return outs
+
+
+def swin_converter(ckpt):
+
+    new_ckpt = OrderedDict()
+
+    def correct_unfold_reduction_order(x):
+        out_channel, in_channel = x.shape
+        x = x.reshape(out_channel, 4, in_channel // 4)
+        x = x[:, [0, 2, 1, 3], :].transpose(1,
+                                            2).reshape(out_channel, in_channel)
+        return x
+
+    def correct_unfold_norm_order(x):
+        in_channel = x.shape[0]
+        x = x.reshape(4, in_channel // 4)
+        x = x[[0, 2, 1, 3], :].transpose(0, 1).reshape(in_channel)
+        return x
+
+    for k, v in ckpt.items():
+        if k.startswith('head'):
+            continue
+        elif k.startswith('layers'):
+            new_v = v
+            if 'attn.' in k:
+                new_k = k.replace('attn.', 'attn.w_msa.')
+            elif 'mlp.' in k:
+                if 'mlp.fc1.' in k:
+                    new_k = k.replace('mlp.fc1.', 'ffn.layers.0.0.')
+                elif 'mlp.fc2.' in k:
+                    new_k = k.replace('mlp.fc2.', 'ffn.layers.1.')
+                else:
+                    new_k = k.replace('mlp.', 'ffn.')
+            elif 'downsample' in k:
+                new_k = k
+                if 'reduction.' in k:
+                    new_v = correct_unfold_reduction_order(v)
+                elif 'norm.' in k:
+                    new_v = correct_unfold_norm_order(v)
+            else:
+                new_k = k
+            new_k = new_k.replace('layers', 'stages', 1)
+        elif k.startswith('patch_embed'):
+            new_v = v
+            if 'proj' in k:
+                new_k = k.replace('proj', 'projection')
+            else:
+                new_k = k
+        else:
+            new_v = v
+            new_k = k
+
+        new_ckpt['backbone.' + new_k] = new_v
+
+    return new_ckpt
diff --git a/mmdetection/mmdet/models/backbones/trident_resnet.py b/mmdetection/mmdet/models/backbones/trident_resnet.py
new file mode 100644
index 00000000..22c76354
--- /dev/null
+++ b/mmdetection/mmdet/models/backbones/trident_resnet.py
@@ -0,0 +1,298 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.checkpoint as cp
+from mmcv.cnn import build_conv_layer, build_norm_layer
+from mmengine.model import BaseModule
+from torch.nn.modules.utils import _pair
+
+from mmdet.models.backbones.resnet import Bottleneck, ResNet
+from mmdet.registry import MODELS
+
+
+class TridentConv(BaseModule):
+    """Trident Convolution Module.
+
+    Args:
+        in_channels (int): Number of channels in input.
+        out_channels (int): Number of channels in output.
+        kernel_size (int): Size of convolution kernel.
+        stride (int, optional): Convolution stride. Default: 1.
+        trident_dilations (tuple[int, int, int], optional): Dilations of
+            different trident branch. Default: (1, 2, 3).
+        test_branch_idx (int, optional): In inference, all 3 branches will
+            be used if `test_branch_idx==-1`, otherwise only branch with
+            index `test_branch_idx` will be used. Default: 1.
+        bias (bool, optional): Whether to use bias in convolution or not.
+            Default: False.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 kernel_size,
+                 stride=1,
+                 trident_dilations=(1, 2, 3),
+                 test_branch_idx=1,
+                 bias=False,
+                 init_cfg=None):
+        super(TridentConv, self).__init__(init_cfg)
+        self.num_branch = len(trident_dilations)
+        self.with_bias = bias
+        self.test_branch_idx = test_branch_idx
+        self.stride = _pair(stride)
+        self.kernel_size = _pair(kernel_size)
+        self.paddings = _pair(trident_dilations)
+        self.dilations = trident_dilations
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.bias = bias
+
+        self.weight = nn.Parameter(
+            torch.Tensor(out_channels, in_channels, *self.kernel_size))
+        if bias:
+            self.bias = nn.Parameter(torch.Tensor(out_channels))
+        else:
+            self.bias = None
+
+    def extra_repr(self):
+        tmpstr = f'in_channels={self.in_channels}'
+        tmpstr += f', out_channels={self.out_channels}'
+        tmpstr += f', kernel_size={self.kernel_size}'
+        tmpstr += f', num_branch={self.num_branch}'
+        tmpstr += f', test_branch_idx={self.test_branch_idx}'
+        tmpstr += f', stride={self.stride}'
+        tmpstr += f', paddings={self.paddings}'
+        tmpstr += f', dilations={self.dilations}'
+        tmpstr += f', bias={self.bias}'
+        return tmpstr
+
+    def forward(self, inputs):
+        if self.training or self.test_branch_idx == -1:
+            outputs = [
+                F.conv2d(input, self.weight, self.bias, self.stride, padding,
+                         dilation) for input, dilation, padding in zip(
+                             inputs, self.dilations, self.paddings)
+            ]
+        else:
+            assert len(inputs) == 1
+            outputs = [
+                F.conv2d(inputs[0], self.weight, self.bias, self.stride,
+                         self.paddings[self.test_branch_idx],
+                         self.dilations[self.test_branch_idx])
+            ]
+
+        return outputs
+
+
+# Since TridentNet is defined over ResNet50 and ResNet101, here we
+# only support TridentBottleneckBlock.
+class TridentBottleneck(Bottleneck):
+    """BottleBlock for TridentResNet.
+
+    Args:
+        trident_dilations (tuple[int, int, int]): Dilations of different
+            trident branch.
+        test_branch_idx (int): In inference, all 3 branches will be used
+            if `test_branch_idx==-1`, otherwise only branch with index
+            `test_branch_idx` will be used.
+        concat_output (bool): Whether to concat the output list to a Tensor.
+            `True` only in the last Block.
+    """
+
+    def __init__(self, trident_dilations, test_branch_idx, concat_output,
+                 **kwargs):
+
+        super(TridentBottleneck, self).__init__(**kwargs)
+        self.trident_dilations = trident_dilations
+        self.num_branch = len(trident_dilations)
+        self.concat_output = concat_output
+        self.test_branch_idx = test_branch_idx
+        self.conv2 = TridentConv(
+            self.planes,
+            self.planes,
+            kernel_size=3,
+            stride=self.conv2_stride,
+            bias=False,
+            trident_dilations=self.trident_dilations,
+            test_branch_idx=test_branch_idx,
+            init_cfg=dict(
+                type='Kaiming',
+                distribution='uniform',
+                mode='fan_in',
+                override=dict(name='conv2')))
+
+    def forward(self, x):
+
+        def _inner_forward(x):
+            num_branch = (
+                self.num_branch
+                if self.training or self.test_branch_idx == -1 else 1)
+            identity = x
+            if not isinstance(x, list):
+                x = (x, ) * num_branch
+                identity = x
+                if self.downsample is not None:
+                    identity = [self.downsample(b) for b in x]
+
+            out = [self.conv1(b) for b in x]
+            out = [self.norm1(b) for b in out]
+            out = [self.relu(b) for b in out]
+
+            if self.with_plugins:
+                for k in range(len(out)):
+                    out[k] = self.forward_plugin(out[k],
+                                                 self.after_conv1_plugin_names)
+
+            out = self.conv2(out)
+            out = [self.norm2(b) for b in out]
+            out = [self.relu(b) for b in out]
+            if self.with_plugins:
+                for k in range(len(out)):
+                    out[k] = self.forward_plugin(out[k],
+                                                 self.after_conv2_plugin_names)
+
+            out = [self.conv3(b) for b in out]
+            out = [self.norm3(b) for b in out]
+
+            if self.with_plugins:
+                for k in range(len(out)):
+                    out[k] = self.forward_plugin(out[k],
+                                                 self.after_conv3_plugin_names)
+
+            out = [
+                out_b + identity_b for out_b, identity_b in zip(out, identity)
+            ]
+            return out
+
+        if self.with_cp and x.requires_grad:
+            out = cp.checkpoint(_inner_forward, x)
+        else:
+            out = _inner_forward(x)
+
+        out = [self.relu(b) for b in out]
+        if self.concat_output:
+            out = torch.cat(out, dim=0)
+        return out
+
+
+def make_trident_res_layer(block,
+                           inplanes,
+                           planes,
+                           num_blocks,
+                           stride=1,
+                           trident_dilations=(1, 2, 3),
+                           style='pytorch',
+                           with_cp=False,
+                           conv_cfg=None,
+                           norm_cfg=dict(type='BN'),
+                           dcn=None,
+                           plugins=None,
+                           test_branch_idx=-1):
+    """Build Trident Res Layers."""
+
+    downsample = None
+    if stride != 1 or inplanes != planes * block.expansion:
+        downsample = []
+        conv_stride = stride
+        downsample.extend([
+            build_conv_layer(
+                conv_cfg,
+                inplanes,
+                planes * block.expansion,
+                kernel_size=1,
+                stride=conv_stride,
+                bias=False),
+            build_norm_layer(norm_cfg, planes * block.expansion)[1]
+        ])
+        downsample = nn.Sequential(*downsample)
+
+    layers = []
+    for i in range(num_blocks):
+        layers.append(
+            block(
+                inplanes=inplanes,
+                planes=planes,
+                stride=stride if i == 0 else 1,
+                trident_dilations=trident_dilations,
+                downsample=downsample if i == 0 else None,
+                style=style,
+                with_cp=with_cp,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                dcn=dcn,
+                plugins=plugins,
+                test_branch_idx=test_branch_idx,
+                concat_output=True if i == num_blocks - 1 else False))
+        inplanes = planes * block.expansion
+    return nn.Sequential(*layers)
+
+
+@MODELS.register_module()
+class TridentResNet(ResNet):
+    """The stem layer, stage 1 and stage 2 in Trident ResNet are identical to
+    ResNet, while in stage 3, Trident BottleBlock is utilized to replace the
+    normal BottleBlock to yield trident output. Different branch shares the
+    convolution weight but uses different dilations to achieve multi-scale
+    output.
+
+                               / stage3(b0) \
+    x - stem - stage1 - stage2 - stage3(b1) - output
+                               \ stage3(b2) /
+
+    Args:
+        depth (int): Depth of resnet, from {50, 101, 152}.
+        num_branch (int): Number of branches in TridentNet.
+        test_branch_idx (int): In inference, all 3 branches will be used
+            if `test_branch_idx==-1`, otherwise only branch with index
+            `test_branch_idx` will be used.
+        trident_dilations (tuple[int]): Dilations of different trident branch.
+            len(trident_dilations) should be equal to num_branch.
+    """  # noqa
+
+    def __init__(self, depth, num_branch, test_branch_idx, trident_dilations,
+                 **kwargs):
+
+        assert num_branch == len(trident_dilations)
+        assert depth in (50, 101, 152)
+        super(TridentResNet, self).__init__(depth, **kwargs)
+        assert self.num_stages == 3
+        self.test_branch_idx = test_branch_idx
+        self.num_branch = num_branch
+
+        last_stage_idx = self.num_stages - 1
+        stride = self.strides[last_stage_idx]
+        dilation = trident_dilations
+        dcn = self.dcn if self.stage_with_dcn[last_stage_idx] else None
+        if self.plugins is not None:
+            stage_plugins = self.make_stage_plugins(self.plugins,
+                                                    last_stage_idx)
+        else:
+            stage_plugins = None
+        planes = self.base_channels * 2**last_stage_idx
+        res_layer = make_trident_res_layer(
+            TridentBottleneck,
+            inplanes=(self.block.expansion * self.base_channels *
+                      2**(last_stage_idx - 1)),
+            planes=planes,
+            num_blocks=self.stage_blocks[last_stage_idx],
+            stride=stride,
+            trident_dilations=dilation,
+            style=self.style,
+            with_cp=self.with_cp,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            dcn=dcn,
+            plugins=stage_plugins,
+            test_branch_idx=self.test_branch_idx)
+
+        layer_name = f'layer{last_stage_idx + 1}'
+
+        self.__setattr__(layer_name, res_layer)
+        self.res_layers.pop(last_stage_idx)
+        self.res_layers.insert(last_stage_idx, layer_name)
+
+        self._freeze_stages()
diff --git a/mmdetection/mmdet/models/data_preprocessors/__init__.py b/mmdetection/mmdet/models/data_preprocessors/__init__.py
new file mode 100644
index 00000000..201a1da6
--- /dev/null
+++ b/mmdetection/mmdet/models/data_preprocessors/__init__.py
@@ -0,0 +1,13 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .data_preprocessor import (BatchFixedSizePad, BatchResize,
+                                BatchSyncRandomResize, BoxInstDataPreprocessor,
+                                DetDataPreprocessor,
+                                MultiBranchDataPreprocessor)
+from .reid_data_preprocessor import ReIDDataPreprocessor
+from .track_data_preprocessor import TrackDataPreprocessor
+
+__all__ = [
+    'DetDataPreprocessor', 'BatchSyncRandomResize', 'BatchFixedSizePad',
+    'MultiBranchDataPreprocessor', 'BatchResize', 'BoxInstDataPreprocessor',
+    'TrackDataPreprocessor', 'ReIDDataPreprocessor'
+]
diff --git a/mmdetection/mmdet/models/data_preprocessors/data_preprocessor.py b/mmdetection/mmdet/models/data_preprocessors/data_preprocessor.py
new file mode 100644
index 00000000..55b5c35b
--- /dev/null
+++ b/mmdetection/mmdet/models/data_preprocessors/data_preprocessor.py
@@ -0,0 +1,793 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import random
+from numbers import Number
+from typing import List, Optional, Sequence, Tuple, Union
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmengine.dist import barrier, broadcast, get_dist_info
+from mmengine.logging import MessageHub
+from mmengine.model import BaseDataPreprocessor, ImgDataPreprocessor
+from mmengine.structures import PixelData
+from mmengine.utils import is_seq_of
+from torch import Tensor
+
+from mmdet.models.utils import unfold_wo_center
+from mmdet.models.utils.misc import samplelist_boxtype2tensor
+from mmdet.registry import MODELS
+from mmdet.structures import DetDataSample
+from mmdet.structures.mask import BitmapMasks
+from mmdet.utils import ConfigType
+
+try:
+    import skimage
+except ImportError:
+    skimage = None
+
+
+@MODELS.register_module()
+class DetDataPreprocessor(ImgDataPreprocessor):
+    """Image pre-processor for detection tasks.
+
+    Comparing with the :class:`mmengine.ImgDataPreprocessor`,
+
+    1. It supports batch augmentations.
+    2. It will additionally append batch_input_shape and pad_shape
+    to data_samples considering the object detection task.
+
+    It provides the data pre-processing as follows
+
+    - Collate and move data to the target device.
+    - Pad inputs to the maximum size of current batch with defined
+      ``pad_value``. The padding size can be divisible by a defined
+      ``pad_size_divisor``
+    - Stack inputs to batch_inputs.
+    - Convert inputs from bgr to rgb if the shape of input is (3, H, W).
+    - Normalize image with defined std and mean.
+    - Do batch augmentations during training.
+
+    Args:
+        mean (Sequence[Number], optional): The pixel mean of R, G, B channels.
+            Defaults to None.
+        std (Sequence[Number], optional): The pixel standard deviation of
+            R, G, B channels. Defaults to None.
+        pad_size_divisor (int): The size of padded image should be
+            divisible by ``pad_size_divisor``. Defaults to 1.
+        pad_value (Number): The padded pixel value. Defaults to 0.
+        pad_mask (bool): Whether to pad instance masks. Defaults to False.
+        mask_pad_value (int): The padded pixel value for instance masks.
+            Defaults to 0.
+        pad_seg (bool): Whether to pad semantic segmentation maps.
+            Defaults to False.
+        seg_pad_value (int): The padded pixel value for semantic
+            segmentation maps. Defaults to 255.
+        bgr_to_rgb (bool): whether to convert image from BGR to RGB.
+            Defaults to False.
+        rgb_to_bgr (bool): whether to convert image from RGB to RGB.
+            Defaults to False.
+        boxtype2tensor (bool): Whether to convert the ``BaseBoxes`` type of
+            bboxes data to ``Tensor`` type. Defaults to True.
+        non_blocking (bool): Whether block current process
+            when transferring data to device. Defaults to False.
+        batch_augments (list[dict], optional): Batch-level augmentations
+    """
+
+    def __init__(self,
+                 mean: Sequence[Number] = None,
+                 std: Sequence[Number] = None,
+                 pad_size_divisor: int = 1,
+                 pad_value: Union[float, int] = 0,
+                 pad_mask: bool = False,
+                 mask_pad_value: int = 0,
+                 pad_seg: bool = False,
+                 seg_pad_value: int = 255,
+                 bgr_to_rgb: bool = False,
+                 rgb_to_bgr: bool = False,
+                 boxtype2tensor: bool = True,
+                 non_blocking: Optional[bool] = False,
+                 batch_augments: Optional[List[dict]] = None):
+        super().__init__(
+            mean=mean,
+            std=std,
+            pad_size_divisor=pad_size_divisor,
+            pad_value=pad_value,
+            bgr_to_rgb=bgr_to_rgb,
+            rgb_to_bgr=rgb_to_bgr,
+            non_blocking=non_blocking)
+        if batch_augments is not None:
+            self.batch_augments = nn.ModuleList(
+                [MODELS.build(aug) for aug in batch_augments])
+        else:
+            self.batch_augments = None
+        self.pad_mask = pad_mask
+        self.mask_pad_value = mask_pad_value
+        self.pad_seg = pad_seg
+        self.seg_pad_value = seg_pad_value
+        self.boxtype2tensor = boxtype2tensor
+
+    def forward(self, data: dict, training: bool = False) -> dict:
+        """Perform normalization,padding and bgr2rgb conversion based on
+        ``BaseDataPreprocessor``.
+
+        Args:
+            data (dict): Data sampled from dataloader.
+            training (bool): Whether to enable training time augmentation.
+
+        Returns:
+            dict: Data in the same format as the model input.
+        """
+        batch_pad_shape = self._get_pad_shape(data)
+        data = super().forward(data=data, training=training)
+        inputs, data_samples = data['inputs'], data['data_samples']
+
+        if data_samples is not None:
+            # NOTE the batched image size information may be useful, e.g.
+            # in DETR, this is needed for the construction of masks, which is
+            # then used for the transformer_head.
+            batch_input_shape = tuple(inputs[0].size()[-2:])
+            for data_sample, pad_shape in zip(data_samples, batch_pad_shape):
+                data_sample.set_metainfo({
+                    'batch_input_shape': batch_input_shape,
+                    'pad_shape': pad_shape
+                })
+
+            if self.boxtype2tensor:
+                samplelist_boxtype2tensor(data_samples)
+
+            if self.pad_mask and training:
+                self.pad_gt_masks(data_samples)
+
+            if self.pad_seg and training:
+                self.pad_gt_sem_seg(data_samples)
+
+        if training and self.batch_augments is not None:
+            for batch_aug in self.batch_augments:
+                inputs, data_samples = batch_aug(inputs, data_samples)
+
+        return {'inputs': inputs, 'data_samples': data_samples}
+
+    def _get_pad_shape(self, data: dict) -> List[tuple]:
+        """Get the pad_shape of each image based on data and
+        pad_size_divisor."""
+        _batch_inputs = data['inputs']
+        # Process data with `pseudo_collate`.
+        if is_seq_of(_batch_inputs, torch.Tensor):
+            batch_pad_shape = []
+            for ori_input in _batch_inputs:
+                pad_h = int(
+                    np.ceil(ori_input.shape[1] /
+                            self.pad_size_divisor)) * self.pad_size_divisor
+                pad_w = int(
+                    np.ceil(ori_input.shape[2] /
+                            self.pad_size_divisor)) * self.pad_size_divisor
+                batch_pad_shape.append((pad_h, pad_w))
+        # Process data with `default_collate`.
+        elif isinstance(_batch_inputs, torch.Tensor):
+            assert _batch_inputs.dim() == 4, (
+                'The input of `ImgDataPreprocessor` should be a NCHW tensor '
+                'or a list of tensor, but got a tensor with shape: '
+                f'{_batch_inputs.shape}')
+            pad_h = int(
+                np.ceil(_batch_inputs.shape[2] /
+                        self.pad_size_divisor)) * self.pad_size_divisor
+            pad_w = int(
+                np.ceil(_batch_inputs.shape[3] /
+                        self.pad_size_divisor)) * self.pad_size_divisor
+            batch_pad_shape = [(pad_h, pad_w)] * _batch_inputs.shape[0]
+        else:
+            raise TypeError('Output of `cast_data` should be a dict '
+                            'or a tuple with inputs and data_samples, but got'
+                            f'{type(data)}: {data}')
+        return batch_pad_shape
+
+    def pad_gt_masks(self,
+                     batch_data_samples: Sequence[DetDataSample]) -> None:
+        """Pad gt_masks to shape of batch_input_shape."""
+        if 'masks' in batch_data_samples[0].gt_instances:
+            for data_samples in batch_data_samples:
+                masks = data_samples.gt_instances.masks
+                data_samples.gt_instances.masks = masks.pad(
+                    data_samples.batch_input_shape,
+                    pad_val=self.mask_pad_value)
+
+    def pad_gt_sem_seg(self,
+                       batch_data_samples: Sequence[DetDataSample]) -> None:
+        """Pad gt_sem_seg to shape of batch_input_shape."""
+        if 'gt_sem_seg' in batch_data_samples[0]:
+            for data_samples in batch_data_samples:
+                gt_sem_seg = data_samples.gt_sem_seg.sem_seg
+                h, w = gt_sem_seg.shape[-2:]
+                pad_h, pad_w = data_samples.batch_input_shape
+                gt_sem_seg = F.pad(
+                    gt_sem_seg,
+                    pad=(0, max(pad_w - w, 0), 0, max(pad_h - h, 0)),
+                    mode='constant',
+                    value=self.seg_pad_value)
+                data_samples.gt_sem_seg = PixelData(sem_seg=gt_sem_seg)
+
+
+@MODELS.register_module()
+class BatchSyncRandomResize(nn.Module):
+    """Batch random resize which synchronizes the random size across ranks.
+
+    Args:
+        random_size_range (tuple): The multi-scale random range during
+            multi-scale training.
+        interval (int): The iter interval of change
+            image size. Defaults to 10.
+        size_divisor (int): Image size divisible factor.
+            Defaults to 32.
+    """
+
+    def __init__(self,
+                 random_size_range: Tuple[int, int],
+                 interval: int = 10,
+                 size_divisor: int = 32) -> None:
+        super().__init__()
+        self.rank, self.world_size = get_dist_info()
+        self._input_size = None
+        self._random_size_range = (round(random_size_range[0] / size_divisor),
+                                   round(random_size_range[1] / size_divisor))
+        self._interval = interval
+        self._size_divisor = size_divisor
+
+    def forward(
+        self, inputs: Tensor, data_samples: List[DetDataSample]
+    ) -> Tuple[Tensor, List[DetDataSample]]:
+        """resize a batch of images and bboxes to shape ``self._input_size``"""
+        h, w = inputs.shape[-2:]
+        if self._input_size is None:
+            self._input_size = (h, w)
+        scale_y = self._input_size[0] / h
+        scale_x = self._input_size[1] / w
+        if scale_x != 1 or scale_y != 1:
+            inputs = F.interpolate(
+                inputs,
+                size=self._input_size,
+                mode='bilinear',
+                align_corners=False)
+            for data_sample in data_samples:
+                img_shape = (int(data_sample.img_shape[0] * scale_y),
+                             int(data_sample.img_shape[1] * scale_x))
+                pad_shape = (int(data_sample.pad_shape[0] * scale_y),
+                             int(data_sample.pad_shape[1] * scale_x))
+                data_sample.set_metainfo({
+                    'img_shape': img_shape,
+                    'pad_shape': pad_shape,
+                    'batch_input_shape': self._input_size
+                })
+                data_sample.gt_instances.bboxes[
+                    ...,
+                    0::2] = data_sample.gt_instances.bboxes[...,
+                                                            0::2] * scale_x
+                data_sample.gt_instances.bboxes[
+                    ...,
+                    1::2] = data_sample.gt_instances.bboxes[...,
+                                                            1::2] * scale_y
+                if 'ignored_instances' in data_sample:
+                    data_sample.ignored_instances.bboxes[
+                        ..., 0::2] = data_sample.ignored_instances.bboxes[
+                            ..., 0::2] * scale_x
+                    data_sample.ignored_instances.bboxes[
+                        ..., 1::2] = data_sample.ignored_instances.bboxes[
+                            ..., 1::2] * scale_y
+        message_hub = MessageHub.get_current_instance()
+        if (message_hub.get_info('iter') + 1) % self._interval == 0:
+            self._input_size = self._get_random_size(
+                aspect_ratio=float(w / h), device=inputs.device)
+        return inputs, data_samples
+
+    def _get_random_size(self, aspect_ratio: float,
+                         device: torch.device) -> Tuple[int, int]:
+        """Randomly generate a shape in ``_random_size_range`` and broadcast to
+        all ranks."""
+        tensor = torch.LongTensor(2).to(device)
+        if self.rank == 0:
+            size = random.randint(*self._random_size_range)
+            size = (self._size_divisor * size,
+                    self._size_divisor * int(aspect_ratio * size))
+            tensor[0] = size[0]
+            tensor[1] = size[1]
+        barrier()
+        broadcast(tensor, 0)
+        input_size = (tensor[0].item(), tensor[1].item())
+        return input_size
+
+
+@MODELS.register_module()
+class BatchFixedSizePad(nn.Module):
+    """Fixed size padding for batch images.
+
+    Args:
+        size (Tuple[int, int]): Fixed padding size. Expected padding
+            shape (h, w). Defaults to None.
+        img_pad_value (int): The padded pixel value for images.
+            Defaults to 0.
+        pad_mask (bool): Whether to pad instance masks. Defaults to False.
+        mask_pad_value (int): The padded pixel value for instance masks.
+            Defaults to 0.
+        pad_seg (bool): Whether to pad semantic segmentation maps.
+            Defaults to False.
+        seg_pad_value (int): The padded pixel value for semantic
+            segmentation maps. Defaults to 255.
+    """
+
+    def __init__(self,
+                 size: Tuple[int, int],
+                 img_pad_value: int = 0,
+                 pad_mask: bool = False,
+                 mask_pad_value: int = 0,
+                 pad_seg: bool = False,
+                 seg_pad_value: int = 255) -> None:
+        super().__init__()
+        self.size = size
+        self.pad_mask = pad_mask
+        self.pad_seg = pad_seg
+        self.img_pad_value = img_pad_value
+        self.mask_pad_value = mask_pad_value
+        self.seg_pad_value = seg_pad_value
+
+    def forward(
+        self,
+        inputs: Tensor,
+        data_samples: Optional[List[dict]] = None
+    ) -> Tuple[Tensor, Optional[List[dict]]]:
+        """Pad image, instance masks, segmantic segmentation maps."""
+        src_h, src_w = inputs.shape[-2:]
+        dst_h, dst_w = self.size
+
+        if src_h >= dst_h and src_w >= dst_w:
+            return inputs, data_samples
+
+        inputs = F.pad(
+            inputs,
+            pad=(0, max(0, dst_w - src_w), 0, max(0, dst_h - src_h)),
+            mode='constant',
+            value=self.img_pad_value)
+
+        if data_samples is not None:
+            # update batch_input_shape
+            for data_sample in data_samples:
+                data_sample.set_metainfo({
+                    'batch_input_shape': (dst_h, dst_w),
+                    'pad_shape': (dst_h, dst_w)
+                })
+
+            if self.pad_mask:
+                for data_sample in data_samples:
+                    masks = data_sample.gt_instances.masks
+                    data_sample.gt_instances.masks = masks.pad(
+                        (dst_h, dst_w), pad_val=self.mask_pad_value)
+
+            if self.pad_seg:
+                for data_sample in data_samples:
+                    gt_sem_seg = data_sample.gt_sem_seg.sem_seg
+                    h, w = gt_sem_seg.shape[-2:]
+                    gt_sem_seg = F.pad(
+                        gt_sem_seg,
+                        pad=(0, max(0, dst_w - w), 0, max(0, dst_h - h)),
+                        mode='constant',
+                        value=self.seg_pad_value)
+                    data_sample.gt_sem_seg = PixelData(sem_seg=gt_sem_seg)
+
+        return inputs, data_samples
+
+
+@MODELS.register_module()
+class MultiBranchDataPreprocessor(BaseDataPreprocessor):
+    """DataPreprocessor wrapper for multi-branch data.
+
+    Take semi-supervised object detection as an example, assume that
+    the ratio of labeled data and unlabeled data in a batch is 1:2,
+    `sup` indicates the branch where the labeled data is augmented,
+    `unsup_teacher` and `unsup_student` indicate the branches where
+    the unlabeled data is augmented by different pipeline.
+
+    The input format of multi-branch data is shown as below :
+
+    .. code-block:: none
+        {
+            'inputs':
+                {
+                    'sup': [Tensor, None, None],
+                    'unsup_teacher': [None, Tensor, Tensor],
+                    'unsup_student': [None, Tensor, Tensor],
+                },
+            'data_sample':
+                {
+                    'sup': [DetDataSample, None, None],
+                    'unsup_teacher': [None, DetDataSample, DetDataSample],
+                    'unsup_student': [NOne, DetDataSample, DetDataSample],
+                }
+        }
+
+    The format of multi-branch data
+    after filtering None is shown as below :
+
+    .. code-block:: none
+        {
+            'inputs':
+                {
+                    'sup': [Tensor],
+                    'unsup_teacher': [Tensor, Tensor],
+                    'unsup_student': [Tensor, Tensor],
+                },
+            'data_sample':
+                {
+                    'sup': [DetDataSample],
+                    'unsup_teacher': [DetDataSample, DetDataSample],
+                    'unsup_student': [DetDataSample, DetDataSample],
+                }
+        }
+
+    In order to reuse `DetDataPreprocessor` for the data
+    from different branches, the format of multi-branch data
+    grouped by branch is as below :
+
+    .. code-block:: none
+        {
+            'sup':
+                {
+                    'inputs': [Tensor]
+                    'data_sample': [DetDataSample, DetDataSample]
+                },
+            'unsup_teacher':
+                {
+                    'inputs': [Tensor, Tensor]
+                    'data_sample': [DetDataSample, DetDataSample]
+                },
+            'unsup_student':
+                {
+                    'inputs': [Tensor, Tensor]
+                    'data_sample': [DetDataSample, DetDataSample]
+                },
+        }
+
+    After preprocessing data from different branches,
+    the multi-branch data needs to be reformatted as:
+
+    .. code-block:: none
+        {
+            'inputs':
+                {
+                    'sup': [Tensor],
+                    'unsup_teacher': [Tensor, Tensor],
+                    'unsup_student': [Tensor, Tensor],
+                },
+            'data_sample':
+                {
+                    'sup': [DetDataSample],
+                    'unsup_teacher': [DetDataSample, DetDataSample],
+                    'unsup_student': [DetDataSample, DetDataSample],
+                }
+        }
+
+    Args:
+        data_preprocessor (:obj:`ConfigDict` or dict): Config of
+            :class:`DetDataPreprocessor` to process the input data.
+    """
+
+    def __init__(self, data_preprocessor: ConfigType) -> None:
+        super().__init__()
+        self.data_preprocessor = MODELS.build(data_preprocessor)
+
+    def forward(self, data: dict, training: bool = False) -> dict:
+        """Perform normalization,padding and bgr2rgb conversion based on
+        ``BaseDataPreprocessor`` for multi-branch data.
+
+        Args:
+            data (dict): Data sampled from dataloader.
+            training (bool): Whether to enable training time augmentation.
+
+        Returns:
+            dict:
+
+            - 'inputs' (Dict[str, obj:`torch.Tensor`]): The forward data of
+                models from different branches.
+            - 'data_sample' (Dict[str, obj:`DetDataSample`]): The annotation
+                info of the sample from different branches.
+        """
+
+        if training is False:
+            return self.data_preprocessor(data, training)
+
+        # Filter out branches with a value of None
+        for key in data.keys():
+            for branch in data[key].keys():
+                data[key][branch] = list(
+                    filter(lambda x: x is not None, data[key][branch]))
+
+        # Group data by branch
+        multi_branch_data = {}
+        for key in data.keys():
+            for branch in data[key].keys():
+                if multi_branch_data.get(branch, None) is None:
+                    multi_branch_data[branch] = {key: data[key][branch]}
+                elif multi_branch_data[branch].get(key, None) is None:
+                    multi_branch_data[branch][key] = data[key][branch]
+                else:
+                    multi_branch_data[branch][key].append(data[key][branch])
+
+        # Preprocess data from different branches
+        for branch, _data in multi_branch_data.items():
+            multi_branch_data[branch] = self.data_preprocessor(_data, training)
+
+        # Format data by inputs and data_samples
+        format_data = {}
+        for branch in multi_branch_data.keys():
+            for key in multi_branch_data[branch].keys():
+                if format_data.get(key, None) is None:
+                    format_data[key] = {branch: multi_branch_data[branch][key]}
+                elif format_data[key].get(branch, None) is None:
+                    format_data[key][branch] = multi_branch_data[branch][key]
+                else:
+                    format_data[key][branch].append(
+                        multi_branch_data[branch][key])
+
+        return format_data
+
+    @property
+    def device(self):
+        return self.data_preprocessor.device
+
+    def to(self, device: Optional[Union[int, torch.device]], *args,
+           **kwargs) -> nn.Module:
+        """Overrides this method to set the :attr:`device`
+
+        Args:
+            device (int or torch.device, optional): The desired device of the
+                parameters and buffers in this module.
+
+        Returns:
+            nn.Module: The model itself.
+        """
+
+        return self.data_preprocessor.to(device, *args, **kwargs)
+
+    def cuda(self, *args, **kwargs) -> nn.Module:
+        """Overrides this method to set the :attr:`device`
+
+        Returns:
+            nn.Module: The model itself.
+        """
+
+        return self.data_preprocessor.cuda(*args, **kwargs)
+
+    def cpu(self, *args, **kwargs) -> nn.Module:
+        """Overrides this method to set the :attr:`device`
+
+        Returns:
+            nn.Module: The model itself.
+        """
+
+        return self.data_preprocessor.cpu(*args, **kwargs)
+
+
+@MODELS.register_module()
+class BatchResize(nn.Module):
+    """Batch resize during training. This implementation is modified from
+    https://github.com/Purkialo/CrowdDet/blob/master/lib/data/CrowdHuman.py.
+
+    It provides the data pre-processing as follows:
+    - A batch of all images will pad to a uniform size and stack them into
+      a torch.Tensor by `DetDataPreprocessor`.
+    - `BatchFixShapeResize` resize all images to the target size.
+    - Padding images to make sure the size of image can be divisible by
+      ``pad_size_divisor``.
+
+    Args:
+        scale (tuple): Images scales for resizing.
+        pad_size_divisor (int): Image size divisible factor.
+            Defaults to 1.
+        pad_value (Number): The padded pixel value. Defaults to 0.
+    """
+
+    def __init__(
+        self,
+        scale: tuple,
+        pad_size_divisor: int = 1,
+        pad_value: Union[float, int] = 0,
+    ) -> None:
+        super().__init__()
+        self.min_size = min(scale)
+        self.max_size = max(scale)
+        self.pad_size_divisor = pad_size_divisor
+        self.pad_value = pad_value
+
+    def forward(
+        self, inputs: Tensor, data_samples: List[DetDataSample]
+    ) -> Tuple[Tensor, List[DetDataSample]]:
+        """resize a batch of images and bboxes."""
+
+        batch_height, batch_width = inputs.shape[-2:]
+        target_height, target_width, scale = self.get_target_size(
+            batch_height, batch_width)
+
+        inputs = F.interpolate(
+            inputs,
+            size=(target_height, target_width),
+            mode='bilinear',
+            align_corners=False)
+
+        inputs = self.get_padded_tensor(inputs, self.pad_value)
+
+        if data_samples is not None:
+            batch_input_shape = tuple(inputs.size()[-2:])
+            for data_sample in data_samples:
+                img_shape = [
+                    int(scale * _) for _ in list(data_sample.img_shape)
+                ]
+                data_sample.set_metainfo({
+                    'img_shape': tuple(img_shape),
+                    'batch_input_shape': batch_input_shape,
+                    'pad_shape': batch_input_shape,
+                    'scale_factor': (scale, scale)
+                })
+
+                data_sample.gt_instances.bboxes *= scale
+                data_sample.ignored_instances.bboxes *= scale
+
+        return inputs, data_samples
+
+    def get_target_size(self, height: int,
+                        width: int) -> Tuple[int, int, float]:
+        """Get the target size of a batch of images based on data and scale."""
+        im_size_min = np.min([height, width])
+        im_size_max = np.max([height, width])
+        scale = self.min_size / im_size_min
+        if scale * im_size_max > self.max_size:
+            scale = self.max_size / im_size_max
+        target_height, target_width = int(round(height * scale)), int(
+            round(width * scale))
+        return target_height, target_width, scale
+
+    def get_padded_tensor(self, tensor: Tensor, pad_value: int) -> Tensor:
+        """Pad images according to pad_size_divisor."""
+        assert tensor.ndim == 4
+        target_height, target_width = tensor.shape[-2], tensor.shape[-1]
+        divisor = self.pad_size_divisor
+        padded_height = (target_height + divisor - 1) // divisor * divisor
+        padded_width = (target_width + divisor - 1) // divisor * divisor
+        padded_tensor = torch.ones([
+            tensor.shape[0], tensor.shape[1], padded_height, padded_width
+        ]) * pad_value
+        padded_tensor = padded_tensor.type_as(tensor)
+        padded_tensor[:, :, :target_height, :target_width] = tensor
+        return padded_tensor
+
+
+@MODELS.register_module()
+class BoxInstDataPreprocessor(DetDataPreprocessor):
+    """Pseudo mask pre-processor for BoxInst.
+
+    Comparing with the :class:`mmdet.DetDataPreprocessor`,
+
+    1. It generates masks using box annotations.
+    2. It computes the images color similarity in LAB color space.
+
+    Args:
+        mask_stride (int): The mask output stride in boxinst. Defaults to 4.
+        pairwise_size (int): The size of neighborhood for each pixel.
+            Defaults to 3.
+        pairwise_dilation (int): The dilation of neighborhood for each pixel.
+            Defaults to 2.
+        pairwise_color_thresh (float): The thresh of image color similarity.
+            Defaults to 0.3.
+        bottom_pixels_removed (int): The length of removed pixels in bottom.
+            It is caused by the annotation error in coco dataset.
+            Defaults to 10.
+    """
+
+    def __init__(self,
+                 *arg,
+                 mask_stride: int = 4,
+                 pairwise_size: int = 3,
+                 pairwise_dilation: int = 2,
+                 pairwise_color_thresh: float = 0.3,
+                 bottom_pixels_removed: int = 10,
+                 **kwargs) -> None:
+        super().__init__(*arg, **kwargs)
+        self.mask_stride = mask_stride
+        self.pairwise_size = pairwise_size
+        self.pairwise_dilation = pairwise_dilation
+        self.pairwise_color_thresh = pairwise_color_thresh
+        self.bottom_pixels_removed = bottom_pixels_removed
+
+        if skimage is None:
+            raise RuntimeError('skimage is not installed,\
+                 please install it by: pip install scikit-image')
+
+    def get_images_color_similarity(self, inputs: Tensor,
+                                    image_masks: Tensor) -> Tensor:
+        """Compute the image color similarity in LAB color space."""
+        assert inputs.dim() == 4
+        assert inputs.size(0) == 1
+
+        unfolded_images = unfold_wo_center(
+            inputs,
+            kernel_size=self.pairwise_size,
+            dilation=self.pairwise_dilation)
+        diff = inputs[:, :, None] - unfolded_images
+        similarity = torch.exp(-torch.norm(diff, dim=1) * 0.5)
+
+        unfolded_weights = unfold_wo_center(
+            image_masks[None, None],
+            kernel_size=self.pairwise_size,
+            dilation=self.pairwise_dilation)
+        unfolded_weights = torch.max(unfolded_weights, dim=1)[0]
+
+        return similarity * unfolded_weights
+
+    def forward(self, data: dict, training: bool = False) -> dict:
+        """Get pseudo mask labels using color similarity."""
+        det_data = super().forward(data, training)
+        inputs, data_samples = det_data['inputs'], det_data['data_samples']
+
+        if training:
+            # get image masks and remove bottom pixels
+            b_img_h, b_img_w = data_samples[0].batch_input_shape
+            img_masks = []
+            for i in range(inputs.shape[0]):
+                img_h, img_w = data_samples[i].img_shape
+                img_mask = inputs.new_ones((img_h, img_w))
+                pixels_removed = int(self.bottom_pixels_removed *
+                                     float(img_h) / float(b_img_h))
+                if pixels_removed > 0:
+                    img_mask[-pixels_removed:, :] = 0
+                pad_w = b_img_w - img_w
+                pad_h = b_img_h - img_h
+                img_mask = F.pad(img_mask, (0, pad_w, 0, pad_h), 'constant',
+                                 0.)
+                img_masks.append(img_mask)
+            img_masks = torch.stack(img_masks, dim=0)
+            start = int(self.mask_stride // 2)
+            img_masks = img_masks[:, start::self.mask_stride,
+                                  start::self.mask_stride]
+
+            # Get origin rgb image for color similarity
+            ori_imgs = inputs * self.std + self.mean
+            downsampled_imgs = F.avg_pool2d(
+                ori_imgs.float(),
+                kernel_size=self.mask_stride,
+                stride=self.mask_stride,
+                padding=0)
+
+            # Compute color similarity for pseudo mask generation
+            for im_i, data_sample in enumerate(data_samples):
+                # TODO: Support rgb2lab in mmengine?
+                images_lab = skimage.color.rgb2lab(
+                    downsampled_imgs[im_i].byte().permute(1, 2,
+                                                          0).cpu().numpy())
+                images_lab = torch.as_tensor(
+                    images_lab, device=ori_imgs.device, dtype=torch.float32)
+                images_lab = images_lab.permute(2, 0, 1)[None]
+                images_color_similarity = self.get_images_color_similarity(
+                    images_lab, img_masks[im_i])
+                pairwise_mask = (images_color_similarity >=
+                                 self.pairwise_color_thresh).float()
+
+                per_im_bboxes = data_sample.gt_instances.bboxes
+                if per_im_bboxes.shape[0] > 0:
+                    per_im_masks = []
+                    for per_box in per_im_bboxes:
+                        mask_full = torch.zeros((b_img_h, b_img_w),
+                                                device=self.device).float()
+                        mask_full[int(per_box[1]):int(per_box[3] + 1),
+                                  int(per_box[0]):int(per_box[2] + 1)] = 1.0
+                        per_im_masks.append(mask_full)
+                    per_im_masks = torch.stack(per_im_masks, dim=0)
+                    pairwise_masks = torch.cat(
+                        [pairwise_mask for _ in range(per_im_bboxes.shape[0])],
+                        dim=0)
+                else:
+                    per_im_masks = torch.zeros((0, b_img_h, b_img_w))
+                    pairwise_masks = torch.zeros(
+                        (0, self.pairwise_size**2 - 1, b_img_h, b_img_w))
+
+                # TODO: Support BitmapMasks with tensor?
+                data_sample.gt_instances.masks = BitmapMasks(
+                    per_im_masks.cpu().numpy(), b_img_h, b_img_w)
+                data_sample.gt_instances.pairwise_masks = pairwise_masks
+        return {'inputs': inputs, 'data_samples': data_samples}
diff --git a/mmdetection/mmdet/models/data_preprocessors/reid_data_preprocessor.py b/mmdetection/mmdet/models/data_preprocessors/reid_data_preprocessor.py
new file mode 100644
index 00000000..3d0a1d45
--- /dev/null
+++ b/mmdetection/mmdet/models/data_preprocessors/reid_data_preprocessor.py
@@ -0,0 +1,216 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+from numbers import Number
+from typing import Optional, Sequence
+
+import torch
+import torch.nn.functional as F
+from mmengine.model import BaseDataPreprocessor, stack_batch
+
+from mmdet.registry import MODELS
+
+try:
+    import mmpretrain
+    from mmpretrain.models.utils.batch_augments import RandomBatchAugment
+    from mmpretrain.structures import (batch_label_to_onehot, cat_batch_labels,
+                                       tensor_split)
+except ImportError:
+    mmpretrain = None
+
+
+def stack_batch_scores(elements, device=None):
+    """Stack the ``score`` of a batch of :obj:`LabelData` to a tensor.
+
+    Args:
+        elements (List[LabelData]): A batch of :obj`LabelData`.
+        device (torch.device, optional): The output device of the batch label.
+            Defaults to None.
+    Returns:
+        torch.Tensor: The stacked score tensor.
+    """
+    item = elements[0]
+    if 'score' not in item._data_fields:
+        return None
+
+    batch_score = torch.stack([element.score for element in elements])
+    if device is not None:
+        batch_score = batch_score.to(device)
+    return batch_score
+
+
+@MODELS.register_module()
+class ReIDDataPreprocessor(BaseDataPreprocessor):
+    """Image pre-processor for classification tasks.
+
+    Comparing with the :class:`mmengine.model.ImgDataPreprocessor`,
+
+    1. It won't do normalization if ``mean`` is not specified.
+    2. It does normalization and color space conversion after stacking batch.
+    3. It supports batch augmentations like mixup and cutmix.
+
+    It provides the data pre-processing as follows
+
+    - Collate and move data to the target device.
+    - Pad inputs to the maximum size of current batch with defined
+      ``pad_value``. The padding size can be divisible by a defined
+      ``pad_size_divisor``
+    - Stack inputs to batch_inputs.
+    - Convert inputs from bgr to rgb if the shape of input is (3, H, W).
+    - Normalize image with defined std and mean.
+    - Do batch augmentations like Mixup and Cutmix during training.
+
+    Args:
+        mean (Sequence[Number], optional): The pixel mean of R, G, B channels.
+            Defaults to None.
+        std (Sequence[Number], optional): The pixel standard deviation of
+            R, G, B channels. Defaults to None.
+        pad_size_divisor (int): The size of padded image should be
+            divisible by ``pad_size_divisor``. Defaults to 1.
+        pad_value (Number): The padded pixel value. Defaults to 0.
+        to_rgb (bool): whether to convert image from BGR to RGB.
+            Defaults to False.
+        to_onehot (bool): Whether to generate one-hot format gt-labels and set
+            to data samples. Defaults to False.
+        num_classes (int, optional): The number of classes. Defaults to None.
+        batch_augments (dict, optional): The batch augmentations settings,
+            including "augments" and "probs". For more details, see
+            :class:`mmpretrain.models.RandomBatchAugment`.
+    """
+
+    def __init__(self,
+                 mean: Sequence[Number] = None,
+                 std: Sequence[Number] = None,
+                 pad_size_divisor: int = 1,
+                 pad_value: Number = 0,
+                 to_rgb: bool = False,
+                 to_onehot: bool = False,
+                 num_classes: Optional[int] = None,
+                 batch_augments: Optional[dict] = None):
+        if mmpretrain is None:
+            raise RuntimeError('Please run "pip install openmim" and '
+                               'run "mim install mmpretrain" to '
+                               'install mmpretrain first.')
+        super().__init__()
+        self.pad_size_divisor = pad_size_divisor
+        self.pad_value = pad_value
+        self.to_rgb = to_rgb
+        self.to_onehot = to_onehot
+        self.num_classes = num_classes
+
+        if mean is not None:
+            assert std is not None, 'To enable the normalization in ' \
+                'preprocessing, please specify both `mean` and `std`.'
+            # Enable the normalization in preprocessing.
+            self._enable_normalize = True
+            self.register_buffer('mean',
+                                 torch.tensor(mean).view(-1, 1, 1), False)
+            self.register_buffer('std',
+                                 torch.tensor(std).view(-1, 1, 1), False)
+        else:
+            self._enable_normalize = False
+
+        if batch_augments is not None:
+            self.batch_augments = RandomBatchAugment(**batch_augments)
+            if not self.to_onehot:
+                from mmengine.logging import MMLogger
+                MMLogger.get_current_instance().info(
+                    'Because batch augmentations are enabled, the data '
+                    'preprocessor automatically enables the `to_onehot` '
+                    'option to generate one-hot format labels.')
+                self.to_onehot = True
+        else:
+            self.batch_augments = None
+
+    def forward(self, data: dict, training: bool = False) -> dict:
+        """Perform normalization, padding, bgr2rgb conversion and batch
+        augmentation based on ``BaseDataPreprocessor``.
+
+        Args:
+            data (dict): data sampled from dataloader.
+            training (bool): Whether to enable training time augmentation.
+
+        Returns:
+            dict: Data in the same format as the model input.
+        """
+        inputs = self.cast_data(data['inputs'])
+
+        if isinstance(inputs, torch.Tensor):
+            # The branch if use `default_collate` as the collate_fn in the
+            # dataloader.
+
+            # ------ To RGB ------
+            if self.to_rgb and inputs.size(1) == 3:
+                inputs = inputs.flip(1)
+
+            # -- Normalization ---
+            inputs = inputs.float()
+            if self._enable_normalize:
+                inputs = (inputs - self.mean) / self.std
+
+            # ------ Padding -----
+            if self.pad_size_divisor > 1:
+                h, w = inputs.shape[-2:]
+
+                target_h = math.ceil(
+                    h / self.pad_size_divisor) * self.pad_size_divisor
+                target_w = math.ceil(
+                    w / self.pad_size_divisor) * self.pad_size_divisor
+                pad_h = target_h - h
+                pad_w = target_w - w
+                inputs = F.pad(inputs, (0, pad_w, 0, pad_h), 'constant',
+                               self.pad_value)
+        else:
+            # The branch if use `pseudo_collate` as the collate_fn in the
+            # dataloader.
+
+            processed_inputs = []
+            for input_ in inputs:
+                # ------ To RGB ------
+                if self.to_rgb and input_.size(0) == 3:
+                    input_ = input_.flip(0)
+
+                # -- Normalization ---
+                input_ = input_.float()
+                if self._enable_normalize:
+                    input_ = (input_ - self.mean) / self.std
+
+                processed_inputs.append(input_)
+            # Combine padding and stack
+            inputs = stack_batch(processed_inputs, self.pad_size_divisor,
+                                 self.pad_value)
+
+        data_samples = data.get('data_samples', None)
+        sample_item = data_samples[0] if data_samples is not None else None
+        if 'gt_label' in sample_item:
+            gt_labels = [sample.gt_label for sample in data_samples]
+            gt_labels_tensor = [gt_label.label for gt_label in gt_labels]
+            batch_label, label_indices = cat_batch_labels(gt_labels_tensor)
+            batch_label = batch_label.to(self.device)
+
+            batch_score = stack_batch_scores(gt_labels, device=self.device)
+            if batch_score is None and self.to_onehot:
+                assert batch_label is not None, \
+                    'Cannot generate onehot format labels because no labels.'
+                num_classes = self.num_classes or data_samples[0].get(
+                    'num_classes')
+                assert num_classes is not None, \
+                    'Cannot generate one-hot format labels because not set ' \
+                    '`num_classes` in `data_preprocessor`.'
+                batch_score = batch_label_to_onehot(batch_label, label_indices,
+                                                    num_classes)
+
+            # ----- Batch Augmentations ----
+            if training and self.batch_augments is not None:
+                inputs, batch_score = self.batch_augments(inputs, batch_score)
+
+            # ----- scatter labels and scores to data samples ---
+            if batch_label is not None:
+                for sample, label in zip(
+                        data_samples, tensor_split(batch_label,
+                                                   label_indices)):
+                    sample.set_gt_label(label)
+            if batch_score is not None:
+                for sample, score in zip(data_samples, batch_score):
+                    sample.set_gt_score(score)
+
+        return {'inputs': inputs, 'data_samples': data_samples}
diff --git a/mmdetection/mmdet/models/data_preprocessors/track_data_preprocessor.py b/mmdetection/mmdet/models/data_preprocessors/track_data_preprocessor.py
new file mode 100644
index 00000000..40a65b8e
--- /dev/null
+++ b/mmdetection/mmdet/models/data_preprocessors/track_data_preprocessor.py
@@ -0,0 +1,266 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, List, Optional, Sequence, Union
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from mmengine.model.utils import stack_batch
+
+from mmdet.models.utils.misc import samplelist_boxtype2tensor
+from mmdet.registry import MODELS
+from mmdet.structures import TrackDataSample
+from mmdet.structures.mask import BitmapMasks
+from .data_preprocessor import DetDataPreprocessor
+
+
+@MODELS.register_module()
+class TrackDataPreprocessor(DetDataPreprocessor):
+    """Image pre-processor for tracking tasks.
+
+        Accepts the data sampled by the dataloader, and preprocesses
+        it into the format of the model input. ``TrackDataPreprocessor``
+        provides the tracking data pre-processing as follows:
+
+        - Collate and move data to the target device.
+        - Pad inputs to the maximum size of current batch with defined
+          ``pad_value``. The padding size can be divisible by a defined
+          ``pad_size_divisor``
+        - Stack inputs to inputs.
+        - Convert inputs from bgr to rgb if the shape of input is (1, 3, H, W).
+        - Normalize image with defined std and mean.
+        - Do batch augmentations during training.
+        - Record the information of ``batch_input_shape`` and ``pad_shape``.
+
+        Args:
+            mean (Sequence[Number], optional): The pixel mean of R, G, B
+                channels. Defaults to None.
+            std (Sequence[Number], optional): The pixel standard deviation of
+                R, G, B channels. Defaults to None.
+            pad_size_divisor (int): The size of padded image should be
+                divisible by ``pad_size_divisor``. Defaults to 1.
+            pad_value (Number): The padded pixel value. Defaults to 0.
+            pad_mask (bool): Whether to pad instance masks. Defaults to False.
+            mask_pad_value (int): The padded pixel value for instance masks.
+                Defaults to 0.
+            bgr_to_rgb (bool): whether to convert image from BGR to RGB.
+                Defaults to False.
+            rgb_to_bgr (bool): whether to convert image from RGB to RGB.
+                Defaults to False.
+            use_det_processor: (bool): whether to use DetDataPreprocessor
+                in training phrase. This is mainly for some tracking models
+                fed into one image rather than a group of image in training.
+                Defaults to False.
+    .       boxtype2tensor (bool): Whether to convert the ``BaseBoxes`` type of
+                bboxes data to ``Tensor`` type. Defaults to True.
+            batch_augments (list[dict], optional): Batch-level augmentations
+    """
+
+    def __init__(self,
+                 mean: Optional[Sequence[Union[float, int]]] = None,
+                 std: Optional[Sequence[Union[float, int]]] = None,
+                 use_det_processor: bool = False,
+                 **kwargs):
+        super().__init__(mean=mean, std=std, **kwargs)
+        self.use_det_processor = use_det_processor
+        if mean is not None and not self.use_det_processor:
+            # overwrite the ``register_bufffer`` in ``ImgDataPreprocessor``
+            # since the shape of ``mean`` and ``std`` in tracking tasks must be
+            # (T, C, H, W), which T is the temporal length of the video.
+            self.register_buffer('mean',
+                                 torch.tensor(mean).view(1, -1, 1, 1), False)
+            self.register_buffer('std',
+                                 torch.tensor(std).view(1, -1, 1, 1), False)
+
+    def forward(self, data: dict, training: bool = False) -> Dict:
+        """Perform normalization,padding and bgr2rgb conversion based on
+        ``TrackDataPreprocessor``.
+
+        Args:
+            data (dict): data sampled from dataloader.
+            training (bool): Whether to enable training time augmentation.
+
+        Returns:
+            Tuple[Dict[str, List[torch.Tensor]], OptSampleList]: Data in the
+            same format as the model input.
+        """
+        if self.use_det_processor and training:
+            batch_pad_shape = self._get_pad_shape(data)
+        else:
+            batch_pad_shape = self._get_track_pad_shape(data)
+
+        data = self.cast_data(data)
+        imgs, data_samples = data['inputs'], data['data_samples']
+
+        if self.use_det_processor and training:
+            assert imgs[0].dim() == 3, \
+                'Only support the 3 dims when use detpreprocessor in training'
+            if self._channel_conversion:
+                imgs = [_img[[2, 1, 0], ...] for _img in imgs]
+            # Convert to `float`
+            imgs = [_img.float() for _img in imgs]
+            if self._enable_normalize:
+                imgs = [(_img - self.mean) / self.std for _img in imgs]
+            inputs = stack_batch(imgs, self.pad_size_divisor, self.pad_value)
+        else:
+            assert imgs[0].dim() == 4, \
+                'Only support the 4 dims when use trackprocessor in training'
+            # The shape of imgs[0] is (T, C, H, W).
+            channel = imgs[0].size(1)
+            if self._channel_conversion and channel == 3:
+                imgs = [_img[:, [2, 1, 0], ...] for _img in imgs]
+            # change to `float`
+            imgs = [_img.float() for _img in imgs]
+            if self._enable_normalize:
+                imgs = [(_img - self.mean) / self.std for _img in imgs]
+            inputs = stack_track_batch(imgs, self.pad_size_divisor,
+                                       self.pad_value)
+
+        if data_samples is not None:
+            # NOTE the batched image size information may be useful, e.g.
+            # in DETR, this is needed for the construction of masks, which is
+            # then used for the transformer_head.
+            batch_input_shape = tuple(inputs.size()[-2:])
+            if self.use_det_processor and training:
+                for data_sample, pad_shape in zip(data_samples,
+                                                  batch_pad_shape):
+                    data_sample.set_metainfo({
+                        'batch_input_shape': batch_input_shape,
+                        'pad_shape': pad_shape
+                    })
+                if self.boxtype2tensor:
+                    samplelist_boxtype2tensor(data_samples)
+                if self.pad_mask:
+                    self.pad_gt_masks(data_samples)
+            else:
+                for track_data_sample, pad_shapes in zip(
+                        data_samples, batch_pad_shape):
+                    for i in range(len(track_data_sample)):
+                        det_data_sample = track_data_sample[i]
+                        det_data_sample.set_metainfo({
+                            'batch_input_shape': batch_input_shape,
+                            'pad_shape': pad_shapes[i]
+                        })
+                if self.pad_mask and training:
+                    self.pad_track_gt_masks(data_samples)
+
+        if training and self.batch_augments is not None:
+            for batch_aug in self.batch_augments:
+                if self.use_det_processor and training:
+                    inputs, data_samples = batch_aug(inputs, data_samples)
+                else:
+                    # we only support T==1 when using batch augments.
+                    # Only yolox need batch_aug, and yolox can only process
+                    # (N, C, H, W) shape.
+                    # The shape of `inputs` is (N, T, C, H, W), hence, we use
+                    # inputs[:, 0] to change the shape to (N, C, H, W).
+                    assert inputs.size(1) == 1 and len(
+                        data_samples[0]
+                    ) == 1, 'Only support the number of sequence images equals to 1 when using batch augment.'  # noqa: E501
+                    det_data_samples = [
+                        track_data_sample[0]
+                        for track_data_sample in data_samples
+                    ]
+                    aug_inputs, aug_det_samples = batch_aug(
+                        inputs[:, 0], det_data_samples)
+                    inputs = aug_inputs.unsqueeze(1)
+                    for track_data_sample, det_sample in zip(
+                            data_samples, aug_det_samples):
+                        track_data_sample.video_data_samples = [det_sample]
+
+        # Note: inputs may contain large number of frames, so we must make
+        # sure that the mmeory is contiguous for stable forward
+        inputs = inputs.contiguous()
+
+        return dict(inputs=inputs, data_samples=data_samples)
+
+    def _get_track_pad_shape(self, data: dict) -> Dict[str, List]:
+        """Get the pad_shape of each image based on data and pad_size_divisor.
+
+        Args:
+            data (dict): Data sampled from dataloader.
+
+        Returns:
+            Dict[str, List]: The shape of padding.
+        """
+        batch_pad_shape = dict()
+        batch_pad_shape = []
+        for imgs in data['inputs']:
+            # The sequence images in one sample among a batch have the same
+            # original shape
+            pad_h = int(np.ceil(imgs.shape[-2] /
+                                self.pad_size_divisor)) * self.pad_size_divisor
+            pad_w = int(np.ceil(imgs.shape[-1] /
+                                self.pad_size_divisor)) * self.pad_size_divisor
+            pad_shapes = [(pad_h, pad_w)] * imgs.size(0)
+            batch_pad_shape.append(pad_shapes)
+        return batch_pad_shape
+
+    def pad_track_gt_masks(self,
+                           data_samples: Sequence[TrackDataSample]) -> None:
+        """Pad gt_masks to shape of batch_input_shape."""
+        if 'masks' in data_samples[0][0].get('gt_instances', None):
+            for track_data_sample in data_samples:
+                for i in range(len(track_data_sample)):
+                    det_data_sample = track_data_sample[i]
+                    masks = det_data_sample.gt_instances.masks
+                    # TODO: whether to use BitmapMasks
+                    assert isinstance(masks, BitmapMasks)
+                    batch_input_shape = det_data_sample.batch_input_shape
+                    det_data_sample.gt_instances.masks = masks.pad(
+                        batch_input_shape, pad_val=self.mask_pad_value)
+
+
+def stack_track_batch(tensors: List[torch.Tensor],
+                      pad_size_divisor: int = 0,
+                      pad_value: Union[int, float] = 0) -> torch.Tensor:
+    """Stack multiple tensors to form a batch and pad the images to the max
+    shape use the right bottom padding mode in these images. If
+    ``pad_size_divisor > 0``, add padding to ensure the common height and width
+    is divisible by ``pad_size_divisor``. The difference between this function
+    and ``stack_batch`` in MMEngine is that this function can process batch
+    sequence images with shape (N, T, C, H, W).
+
+    Args:
+        tensors (List[Tensor]): The input multiple tensors. each is a
+            TCHW 4D-tensor. T denotes the number of key/reference frames.
+        pad_size_divisor (int): If ``pad_size_divisor > 0``, add padding
+            to ensure the common height and width is divisible by
+            ``pad_size_divisor``. This depends on the model, and many
+            models need a divisibility of 32. Defaults to 0
+        pad_value (int, float): The padding value. Defaults to 0
+
+    Returns:
+       Tensor: The NTCHW 5D-tensor. N denotes the batch size.
+    """
+    assert isinstance(tensors, list), \
+        f'Expected input type to be list, but got {type(tensors)}'
+    assert len(set([tensor.ndim for tensor in tensors])) == 1, \
+        f'Expected the dimensions of all tensors must be the same, ' \
+        f'but got {[tensor.ndim for tensor in tensors]}'
+    assert tensors[0].ndim == 4, f'Expected tensor dimension to be 4, ' \
+                                 f'but got {tensors[0].ndim}'
+    assert len(set([tensor.shape[0] for tensor in tensors])) == 1, \
+        f'Expected the channels of all tensors must be the same, ' \
+        f'but got {[tensor.shape[0] for tensor in tensors]}'
+
+    tensor_sizes = [(tensor.shape[-2], tensor.shape[-1]) for tensor in tensors]
+    max_size = np.stack(tensor_sizes).max(0)
+
+    if pad_size_divisor > 1:
+        # the last two dims are H,W, both subject to divisibility requirement
+        max_size = (
+            max_size +
+            (pad_size_divisor - 1)) // pad_size_divisor * pad_size_divisor
+
+    padded_samples = []
+    for tensor in tensors:
+        padding_size = [
+            0, max_size[-1] - tensor.shape[-1], 0,
+            max_size[-2] - tensor.shape[-2]
+        ]
+        if sum(padding_size) == 0:
+            padded_samples.append(tensor)
+        else:
+            padded_samples.append(F.pad(tensor, padding_size, value=pad_value))
+
+    return torch.stack(padded_samples, dim=0)
diff --git a/mmdetection/mmdet/models/dense_heads/__init__.py b/mmdetection/mmdet/models/dense_heads/__init__.py
new file mode 100644
index 00000000..c9b55ec2
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/__init__.py
@@ -0,0 +1,72 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .anchor_free_head import AnchorFreeHead
+from .anchor_head import AnchorHead
+from .atss_head import ATSSHead
+from .atss_vlfusion_head import ATSSVLFusionHead
+from .autoassign_head import AutoAssignHead
+from .boxinst_head import BoxInstBboxHead, BoxInstMaskHead
+from .cascade_rpn_head import CascadeRPNHead, StageCascadeRPNHead
+from .centernet_head import CenterNetHead
+from .centernet_update_head import CenterNetUpdateHead
+from .centripetal_head import CentripetalHead
+from .condinst_head import CondInstBboxHead, CondInstMaskHead
+from .conditional_detr_head import ConditionalDETRHead
+from .corner_head import CornerHead
+from .dab_detr_head import DABDETRHead
+from .ddod_head import DDODHead
+from .ddq_detr_head import DDQDETRHead
+from .deformable_detr_head import DeformableDETRHead
+from .detr_head import DETRHead
+from .dino_head import DINOHead
+from .embedding_rpn_head import EmbeddingRPNHead
+from .fcos_head import FCOSHead
+from .fovea_head import FoveaHead
+from .free_anchor_retina_head import FreeAnchorRetinaHead
+from .fsaf_head import FSAFHead
+from .ga_retina_head import GARetinaHead
+from .ga_rpn_head import GARPNHead
+from .gfl_head import GFLHead
+from .grounding_dino_head import GroundingDINOHead
+from .guided_anchor_head import FeatureAdaption, GuidedAnchorHead
+from .lad_head import LADHead
+from .ld_head import LDHead
+from .mask2former_head import Mask2FormerHead
+from .maskformer_head import MaskFormerHead
+from .nasfcos_head import NASFCOSHead
+from .paa_head import PAAHead
+from .pisa_retinanet_head import PISARetinaHead
+from .pisa_ssd_head import PISASSDHead
+from .reppoints_head import RepPointsHead
+from .retina_head import RetinaHead
+from .retina_sepbn_head import RetinaSepBNHead
+from .rpn_head import RPNHead
+from .rtmdet_head import RTMDetHead, RTMDetSepBNHead
+from .rtmdet_ins_head import RTMDetInsHead, RTMDetInsSepBNHead
+from .sabl_retina_head import SABLRetinaHead
+from .solo_head import DecoupledSOLOHead, DecoupledSOLOLightHead, SOLOHead
+from .solov2_head import SOLOV2Head
+from .ssd_head import SSDHead
+from .tood_head import TOODHead
+from .vfnet_head import VFNetHead
+from .yolact_head import YOLACTHead, YOLACTProtonet
+from .yolo_head import YOLOV3Head
+from .yolof_head import YOLOFHead
+from .yolox_head import YOLOXHead
+
+__all__ = [
+    'AnchorFreeHead', 'AnchorHead', 'GuidedAnchorHead', 'FeatureAdaption',
+    'RPNHead', 'GARPNHead', 'RetinaHead', 'RetinaSepBNHead', 'GARetinaHead',
+    'SSDHead', 'FCOSHead', 'RepPointsHead', 'FoveaHead',
+    'FreeAnchorRetinaHead', 'ATSSHead', 'FSAFHead', 'NASFCOSHead',
+    'PISARetinaHead', 'PISASSDHead', 'GFLHead', 'CornerHead', 'YOLACTHead',
+    'YOLACTProtonet', 'YOLOV3Head', 'PAAHead', 'SABLRetinaHead',
+    'CentripetalHead', 'VFNetHead', 'StageCascadeRPNHead', 'CascadeRPNHead',
+    'EmbeddingRPNHead', 'LDHead', 'AutoAssignHead', 'DETRHead', 'YOLOFHead',
+    'DeformableDETRHead', 'CenterNetHead', 'YOLOXHead', 'SOLOHead',
+    'DecoupledSOLOHead', 'DecoupledSOLOLightHead', 'SOLOV2Head', 'LADHead',
+    'TOODHead', 'MaskFormerHead', 'Mask2FormerHead', 'DDODHead',
+    'CenterNetUpdateHead', 'RTMDetHead', 'RTMDetSepBNHead', 'CondInstBboxHead',
+    'CondInstMaskHead', 'RTMDetInsHead', 'RTMDetInsSepBNHead',
+    'BoxInstBboxHead', 'BoxInstMaskHead', 'ConditionalDETRHead', 'DINOHead',
+    'ATSSVLFusionHead', 'DABDETRHead', 'DDQDETRHead', 'GroundingDINOHead'
+]
diff --git a/mmdetection/mmdet/models/dense_heads/anchor_free_head.py b/mmdetection/mmdet/models/dense_heads/anchor_free_head.py
new file mode 100644
index 00000000..90a9b362
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/anchor_free_head.py
@@ -0,0 +1,317 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from abc import abstractmethod
+from typing import Any, List, Sequence, Tuple, Union
+
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from numpy import ndarray
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.utils import (ConfigType, InstanceList, MultiConfig, OptConfigType,
+                         OptInstanceList)
+from ..task_modules.prior_generators import MlvlPointGenerator
+from ..utils import multi_apply
+from .base_dense_head import BaseDenseHead
+
+StrideType = Union[Sequence[int], Sequence[Tuple[int, int]]]
+
+
+@MODELS.register_module()
+class AnchorFreeHead(BaseDenseHead):
+    """Anchor-free head (FCOS, Fovea, RepPoints, etc.).
+
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (int): Number of channels in the input feature map.
+        feat_channels (int): Number of hidden channels. Used in child classes.
+        stacked_convs (int): Number of stacking convs of the head.
+        strides (Sequence[int] or Sequence[Tuple[int, int]]): Downsample
+            factor of each feature map.
+        dcn_on_last_conv (bool): If true, use dcn in the last layer of
+            towers. Defaults to False.
+        conv_bias (bool or str): If specified as `auto`, it will be decided by
+            the norm_cfg. Bias of conv will be set as True if `norm_cfg` is
+            None, otherwise False. Default: "auto".
+        loss_cls (:obj:`ConfigDict` or dict): Config of classification loss.
+        loss_bbox (:obj:`ConfigDict` or dict): Config of localization loss.
+        bbox_coder (:obj:`ConfigDict` or dict): Config of bbox coder. Defaults
+            'DistancePointBBoxCoder'.
+        conv_cfg (:obj:`ConfigDict` or dict, Optional): Config dict for
+            convolution layer. Defaults to None.
+        norm_cfg (:obj:`ConfigDict` or dict, Optional): Config dict for
+            normalization layer. Defaults to None.
+        train_cfg (:obj:`ConfigDict` or dict, Optional): Training config of
+            anchor-free head.
+        test_cfg (:obj:`ConfigDict` or dict, Optional): Testing config of
+            anchor-free head.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict]): Initialization config dict.
+    """  # noqa: W605
+
+    _version = 1
+
+    def __init__(
+        self,
+        num_classes: int,
+        in_channels: int,
+        feat_channels: int = 256,
+        stacked_convs: int = 4,
+        strides: StrideType = (4, 8, 16, 32, 64),
+        dcn_on_last_conv: bool = False,
+        conv_bias: Union[bool, str] = 'auto',
+        loss_cls: ConfigType = dict(
+            type='FocalLoss',
+            use_sigmoid=True,
+            gamma=2.0,
+            alpha=0.25,
+            loss_weight=1.0),
+        loss_bbox: ConfigType = dict(type='IoULoss', loss_weight=1.0),
+        bbox_coder: ConfigType = dict(type='DistancePointBBoxCoder'),
+        conv_cfg: OptConfigType = None,
+        norm_cfg: OptConfigType = None,
+        train_cfg: OptConfigType = None,
+        test_cfg: OptConfigType = None,
+        init_cfg: MultiConfig = dict(
+            type='Normal',
+            layer='Conv2d',
+            std=0.01,
+            override=dict(
+                type='Normal', name='conv_cls', std=0.01, bias_prob=0.01))
+    ) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.num_classes = num_classes
+        self.use_sigmoid_cls = loss_cls.get('use_sigmoid', False)
+        if self.use_sigmoid_cls:
+            self.cls_out_channels = num_classes
+        else:
+            self.cls_out_channels = num_classes + 1
+        self.in_channels = in_channels
+        self.feat_channels = feat_channels
+        self.stacked_convs = stacked_convs
+        self.strides = strides
+        self.dcn_on_last_conv = dcn_on_last_conv
+        assert conv_bias == 'auto' or isinstance(conv_bias, bool)
+        self.conv_bias = conv_bias
+        self.loss_cls = MODELS.build(loss_cls)
+        self.loss_bbox = MODELS.build(loss_bbox)
+        self.bbox_coder = TASK_UTILS.build(bbox_coder)
+
+        self.prior_generator = MlvlPointGenerator(strides)
+
+        # In order to keep a more general interface and be consistent with
+        # anchor_head. We can think of point like one anchor
+        self.num_base_priors = self.prior_generator.num_base_priors[0]
+
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.fp16_enabled = False
+
+        self._init_layers()
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        self._init_cls_convs()
+        self._init_reg_convs()
+        self._init_predictor()
+
+    def _init_cls_convs(self) -> None:
+        """Initialize classification conv layers of the head."""
+        self.cls_convs = nn.ModuleList()
+        for i in range(self.stacked_convs):
+            chn = self.in_channels if i == 0 else self.feat_channels
+            if self.dcn_on_last_conv and i == self.stacked_convs - 1:
+                conv_cfg = dict(type='DCNv2')
+            else:
+                conv_cfg = self.conv_cfg
+            self.cls_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=self.norm_cfg,
+                    bias=self.conv_bias))
+
+    def _init_reg_convs(self) -> None:
+        """Initialize bbox regression conv layers of the head."""
+        self.reg_convs = nn.ModuleList()
+        for i in range(self.stacked_convs):
+            chn = self.in_channels if i == 0 else self.feat_channels
+            if self.dcn_on_last_conv and i == self.stacked_convs - 1:
+                conv_cfg = dict(type='DCNv2')
+            else:
+                conv_cfg = self.conv_cfg
+            self.reg_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=self.norm_cfg,
+                    bias=self.conv_bias))
+
+    def _init_predictor(self) -> None:
+        """Initialize predictor layers of the head."""
+        self.conv_cls = nn.Conv2d(
+            self.feat_channels, self.cls_out_channels, 3, padding=1)
+        self.conv_reg = nn.Conv2d(self.feat_channels, 4, 3, padding=1)
+
+    def _load_from_state_dict(self, state_dict: dict, prefix: str,
+                              local_metadata: dict, strict: bool,
+                              missing_keys: Union[List[str], str],
+                              unexpected_keys: Union[List[str], str],
+                              error_msgs: Union[List[str], str]) -> None:
+        """Hack some keys of the model state dict so that can load checkpoints
+        of previous version."""
+        version = local_metadata.get('version', None)
+        if version is None:
+            # the key is different in early versions
+            # for example, 'fcos_cls' become 'conv_cls' now
+            bbox_head_keys = [
+                k for k in state_dict.keys() if k.startswith(prefix)
+            ]
+            ori_predictor_keys = []
+            new_predictor_keys = []
+            # e.g. 'fcos_cls' or 'fcos_reg'
+            for key in bbox_head_keys:
+                ori_predictor_keys.append(key)
+                key = key.split('.')
+                if len(key) < 2:
+                    conv_name = None
+                elif key[1].endswith('cls'):
+                    conv_name = 'conv_cls'
+                elif key[1].endswith('reg'):
+                    conv_name = 'conv_reg'
+                elif key[1].endswith('centerness'):
+                    conv_name = 'conv_centerness'
+                else:
+                    conv_name = None
+                if conv_name is not None:
+                    key[1] = conv_name
+                    new_predictor_keys.append('.'.join(key))
+                else:
+                    ori_predictor_keys.pop(-1)
+            for i in range(len(new_predictor_keys)):
+                state_dict[new_predictor_keys[i]] = state_dict.pop(
+                    ori_predictor_keys[i])
+        super()._load_from_state_dict(state_dict, prefix, local_metadata,
+                                      strict, missing_keys, unexpected_keys,
+                                      error_msgs)
+
+    def forward(self, x: Tuple[Tensor]) -> Tuple[List[Tensor], List[Tensor]]:
+        """Forward features from the upstream network.
+
+        Args:
+            feats (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple: Usually contain classification scores and bbox predictions.
+
+            - cls_scores (list[Tensor]): Box scores for each scale level, \
+            each is a 4D-tensor, the channel number is \
+            num_points * num_classes.
+            - bbox_preds (list[Tensor]): Box energies / deltas for each scale \
+            level, each is a 4D-tensor, the channel number is num_points * 4.
+        """
+        return multi_apply(self.forward_single, x)[:2]
+
+    def forward_single(self, x: Tensor) -> Tuple[Tensor, ...]:
+        """Forward features of a single scale level.
+
+        Args:
+            x (Tensor): FPN feature maps of the specified stride.
+
+        Returns:
+            tuple: Scores for each class, bbox predictions, features
+            after classification and regression conv layers, some
+            models needs these features like FCOS.
+        """
+        cls_feat = x
+        reg_feat = x
+
+        for cls_layer in self.cls_convs:
+            cls_feat = cls_layer(cls_feat)
+        cls_score = self.conv_cls(cls_feat)
+
+        for reg_layer in self.reg_convs:
+            reg_feat = reg_layer(reg_feat)
+        bbox_pred = self.conv_reg(reg_feat)
+        return cls_score, bbox_pred, cls_feat, reg_feat
+
+    @abstractmethod
+    def loss_by_feat(
+            self,
+            cls_scores: List[Tensor],
+            bbox_preds: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> dict:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level,
+                each is a 4D-tensor, the channel number is
+                num_points * num_classes.
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level, each is a 4D-tensor, the channel number is
+                num_points * 4.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], Optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+        """
+
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_targets(self, points: List[Tensor],
+                    batch_gt_instances: InstanceList) -> Any:
+        """Compute regression, classification and centerness targets for points
+        in multiple images.
+
+        Args:
+            points (list[Tensor]): Points of each fpn level, each has shape
+                (num_points, 2).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+        """
+        raise NotImplementedError
+
+    # TODO refactor aug_test
+    def aug_test(self,
+                 aug_batch_feats: List[Tensor],
+                 aug_batch_img_metas: List[List[Tensor]],
+                 rescale: bool = False) -> List[ndarray]:
+        """Test function with test time augmentation.
+
+        Args:
+            aug_batch_feats (list[Tensor]): the outer list indicates test-time
+                augmentations and inner Tensor should have a shape NxCxHxW,
+                which contains features for all images in the batch.
+            aug_batch_img_metas (list[list[dict]]): the outer list indicates
+                test-time augs (multiscale, flip, etc.) and the inner list
+                indicates images in a batch. each dict has image information.
+            rescale (bool, optional): Whether to rescale the results.
+                Defaults to False.
+
+        Returns:
+            list[ndarray]: bbox results of each class
+        """
+        return self.aug_test_bboxes(
+            aug_batch_feats, aug_batch_img_metas, rescale=rescale)
diff --git a/mmdetection/mmdet/models/dense_heads/anchor_head.py b/mmdetection/mmdet/models/dense_heads/anchor_head.py
new file mode 100644
index 00000000..4578caca
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/anchor_head.py
@@ -0,0 +1,530 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+from typing import List, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.structures.bbox import BaseBoxes, cat_boxes, get_box_tensor
+from mmdet.utils import (ConfigType, InstanceList, OptConfigType,
+                         OptInstanceList, OptMultiConfig)
+from ..task_modules.prior_generators import (AnchorGenerator,
+                                             anchor_inside_flags)
+from ..task_modules.samplers import PseudoSampler
+from ..utils import images_to_levels, multi_apply, unmap
+from .base_dense_head import BaseDenseHead
+
+
+@MODELS.register_module()
+class AnchorHead(BaseDenseHead):
+    """Anchor-based head (RPN, RetinaNet, SSD, etc.).
+
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (int): Number of channels in the input feature map.
+        feat_channels (int): Number of hidden channels. Used in child classes.
+        anchor_generator (dict): Config dict for anchor generator
+        bbox_coder (dict): Config of bounding box coder.
+        reg_decoded_bbox (bool): If true, the regression loss would be
+            applied directly on decoded bounding boxes, converting both
+            the predicted boxes and regression targets to absolute
+            coordinates format. Default False. It should be `True` when
+            using `IoULoss`, `GIoULoss`, or `DIoULoss` in the bbox head.
+        loss_cls (dict): Config of classification loss.
+        loss_bbox (dict): Config of localization loss.
+        train_cfg (dict): Training config of anchor head.
+        test_cfg (dict): Testing config of anchor head.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+    """  # noqa: W605
+
+    def __init__(
+        self,
+        num_classes: int,
+        in_channels: int,
+        feat_channels: int = 256,
+        anchor_generator: ConfigType = dict(
+            type='AnchorGenerator',
+            scales=[8, 16, 32],
+            ratios=[0.5, 1.0, 2.0],
+            strides=[4, 8, 16, 32, 64]),
+        bbox_coder: ConfigType = dict(
+            type='DeltaXYWHBBoxCoder',
+            clip_border=True,
+            target_means=(.0, .0, .0, .0),
+            target_stds=(1.0, 1.0, 1.0, 1.0)),
+        reg_decoded_bbox: bool = False,
+        loss_cls: ConfigType = dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
+        loss_bbox: ConfigType = dict(
+            type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=1.0),
+        train_cfg: OptConfigType = None,
+        test_cfg: OptConfigType = None,
+        init_cfg: OptMultiConfig = dict(
+            type='Normal', layer='Conv2d', std=0.01)
+    ) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.in_channels = in_channels
+        self.num_classes = num_classes
+        self.feat_channels = feat_channels
+        self.use_sigmoid_cls = loss_cls.get('use_sigmoid', False)
+        if self.use_sigmoid_cls:
+            self.cls_out_channels = num_classes
+        else:
+            self.cls_out_channels = num_classes + 1
+
+        if self.cls_out_channels <= 0:
+            raise ValueError(f'num_classes={num_classes} is too small')
+        self.reg_decoded_bbox = reg_decoded_bbox
+
+        self.bbox_coder = TASK_UTILS.build(bbox_coder)
+        self.loss_cls = MODELS.build(loss_cls)
+        self.loss_bbox = MODELS.build(loss_bbox)
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+        if self.train_cfg:
+            self.assigner = TASK_UTILS.build(self.train_cfg['assigner'])
+            if train_cfg.get('sampler', None) is not None:
+                self.sampler = TASK_UTILS.build(
+                    self.train_cfg['sampler'], default_args=dict(context=self))
+            else:
+                self.sampler = PseudoSampler(context=self)
+
+        self.fp16_enabled = False
+
+        self.prior_generator = TASK_UTILS.build(anchor_generator)
+
+        # Usually the numbers of anchors for each level are the same
+        # except SSD detectors. So it is an int in the most dense
+        # heads but a list of int in SSDHead
+        self.num_base_priors = self.prior_generator.num_base_priors[0]
+        self._init_layers()
+
+    @property
+    def num_anchors(self) -> int:
+        warnings.warn('DeprecationWarning: `num_anchors` is deprecated, '
+                      'for consistency or also use '
+                      '`num_base_priors` instead')
+        return self.prior_generator.num_base_priors[0]
+
+    @property
+    def anchor_generator(self) -> AnchorGenerator:
+        warnings.warn('DeprecationWarning: anchor_generator is deprecated, '
+                      'please use "prior_generator" instead')
+        return self.prior_generator
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        self.conv_cls = nn.Conv2d(self.in_channels,
+                                  self.num_base_priors * self.cls_out_channels,
+                                  1)
+        reg_dim = self.bbox_coder.encode_size
+        self.conv_reg = nn.Conv2d(self.in_channels,
+                                  self.num_base_priors * reg_dim, 1)
+
+    def forward_single(self, x: Tensor) -> Tuple[Tensor, Tensor]:
+        """Forward feature of a single scale level.
+
+        Args:
+            x (Tensor): Features of a single scale level.
+
+        Returns:
+            tuple:
+                cls_score (Tensor): Cls scores for a single scale level \
+                    the channels number is num_base_priors * num_classes.
+                bbox_pred (Tensor): Box energies / deltas for a single scale \
+                    level, the channels number is num_base_priors * 4.
+        """
+        cls_score = self.conv_cls(x)
+        bbox_pred = self.conv_reg(x)
+        return cls_score, bbox_pred
+
+    def forward(self, x: Tuple[Tensor]) -> Tuple[List[Tensor]]:
+        """Forward features from the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple: A tuple of classification scores and bbox prediction.
+
+                - cls_scores (list[Tensor]): Classification scores for all \
+                    scale levels, each is a 4D-tensor, the channels number \
+                    is num_base_priors * num_classes.
+                - bbox_preds (list[Tensor]): Box energies / deltas for all \
+                    scale levels, each is a 4D-tensor, the channels number \
+                    is num_base_priors * 4.
+        """
+        return multi_apply(self.forward_single, x)
+
+    def get_anchors(self,
+                    featmap_sizes: List[tuple],
+                    batch_img_metas: List[dict],
+                    device: Union[torch.device, str] = 'cuda') \
+            -> Tuple[List[List[Tensor]], List[List[Tensor]]]:
+        """Get anchors according to feature map sizes.
+
+        Args:
+            featmap_sizes (list[tuple]): Multi-level feature map sizes.
+            batch_img_metas (list[dict]): Image meta info.
+            device (torch.device | str): Device for returned tensors.
+                Defaults to cuda.
+
+        Returns:
+            tuple:
+
+                - anchor_list (list[list[Tensor]]): Anchors of each image.
+                - valid_flag_list (list[list[Tensor]]): Valid flags of each
+                  image.
+        """
+        num_imgs = len(batch_img_metas)
+
+        # since feature map sizes of all images are the same, we only compute
+        # anchors for one time
+        multi_level_anchors = self.prior_generator.grid_priors(
+            featmap_sizes, device=device)
+        anchor_list = [multi_level_anchors for _ in range(num_imgs)]
+
+        # for each image, we compute valid flags of multi level anchors
+        valid_flag_list = []
+        for img_id, img_meta in enumerate(batch_img_metas):
+            multi_level_flags = self.prior_generator.valid_flags(
+                featmap_sizes, img_meta['pad_shape'], device)
+            valid_flag_list.append(multi_level_flags)
+
+        return anchor_list, valid_flag_list
+
+    def _get_targets_single(self,
+                            flat_anchors: Union[Tensor, BaseBoxes],
+                            valid_flags: Tensor,
+                            gt_instances: InstanceData,
+                            img_meta: dict,
+                            gt_instances_ignore: Optional[InstanceData] = None,
+                            unmap_outputs: bool = True) -> tuple:
+        """Compute regression and classification targets for anchors in a
+        single image.
+
+        Args:
+            flat_anchors (Tensor or :obj:`BaseBoxes`): Multi-level anchors
+                of the image, which are concatenated into a single tensor
+                or box type of shape (num_anchors, 4)
+            valid_flags (Tensor): Multi level valid flags of the image,
+                which are concatenated into a single tensor of
+                    shape (num_anchors, ).
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It should includes ``bboxes`` and ``labels``
+                attributes.
+            img_meta (dict): Meta information for current image.
+            gt_instances_ignore (:obj:`InstanceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+            unmap_outputs (bool): Whether to map outputs back to the original
+                set of anchors.  Defaults to True.
+
+        Returns:
+            tuple:
+
+                - labels (Tensor): Labels of each level.
+                - label_weights (Tensor): Label weights of each level.
+                - bbox_targets (Tensor): BBox targets of each level.
+                - bbox_weights (Tensor): BBox weights of each level.
+                - pos_inds (Tensor): positive samples indexes.
+                - neg_inds (Tensor): negative samples indexes.
+                - sampling_result (:obj:`SamplingResult`): Sampling results.
+        """
+        inside_flags = anchor_inside_flags(flat_anchors, valid_flags,
+                                           img_meta['img_shape'][:2],
+                                           self.train_cfg['allowed_border'])
+        if not inside_flags.any():
+            raise ValueError(
+                'There is no valid anchor inside the image boundary. Please '
+                'check the image size and anchor sizes, or set '
+                '``allowed_border`` to -1 to skip the condition.')
+        # assign gt and sample anchors
+        anchors = flat_anchors[inside_flags]
+
+        pred_instances = InstanceData(priors=anchors)
+        assign_result = self.assigner.assign(pred_instances, gt_instances,
+                                             gt_instances_ignore)
+        # No sampling is required except for RPN and
+        # Guided Anchoring algorithms
+        sampling_result = self.sampler.sample(assign_result, pred_instances,
+                                              gt_instances)
+
+        num_valid_anchors = anchors.shape[0]
+        target_dim = gt_instances.bboxes.size(-1) if self.reg_decoded_bbox \
+            else self.bbox_coder.encode_size
+        bbox_targets = anchors.new_zeros(num_valid_anchors, target_dim)
+        bbox_weights = anchors.new_zeros(num_valid_anchors, target_dim)
+
+        # TODO: Considering saving memory, is it necessary to be long?
+        labels = anchors.new_full((num_valid_anchors, ),
+                                  self.num_classes,
+                                  dtype=torch.long)
+        label_weights = anchors.new_zeros(num_valid_anchors, dtype=torch.float)
+
+        pos_inds = sampling_result.pos_inds
+        neg_inds = sampling_result.neg_inds
+        # `bbox_coder.encode` accepts tensor or box type inputs and generates
+        # tensor targets. If regressing decoded boxes, the code will convert
+        # box type `pos_bbox_targets` to tensor.
+        if len(pos_inds) > 0:
+            if not self.reg_decoded_bbox:
+                pos_bbox_targets = self.bbox_coder.encode(
+                    sampling_result.pos_priors, sampling_result.pos_gt_bboxes)
+            else:
+                pos_bbox_targets = sampling_result.pos_gt_bboxes
+                pos_bbox_targets = get_box_tensor(pos_bbox_targets)
+            bbox_targets[pos_inds, :] = pos_bbox_targets
+            bbox_weights[pos_inds, :] = 1.0
+
+            labels[pos_inds] = sampling_result.pos_gt_labels
+            if self.train_cfg['pos_weight'] <= 0:
+                label_weights[pos_inds] = 1.0
+            else:
+                label_weights[pos_inds] = self.train_cfg['pos_weight']
+        if len(neg_inds) > 0:
+            label_weights[neg_inds] = 1.0
+
+        # map up to original set of anchors
+        if unmap_outputs:
+            num_total_anchors = flat_anchors.size(0)
+            labels = unmap(
+                labels, num_total_anchors, inside_flags,
+                fill=self.num_classes)  # fill bg label
+            label_weights = unmap(label_weights, num_total_anchors,
+                                  inside_flags)
+            bbox_targets = unmap(bbox_targets, num_total_anchors, inside_flags)
+            bbox_weights = unmap(bbox_weights, num_total_anchors, inside_flags)
+
+        return (labels, label_weights, bbox_targets, bbox_weights, pos_inds,
+                neg_inds, sampling_result)
+
+    def get_targets(self,
+                    anchor_list: List[List[Tensor]],
+                    valid_flag_list: List[List[Tensor]],
+                    batch_gt_instances: InstanceList,
+                    batch_img_metas: List[dict],
+                    batch_gt_instances_ignore: OptInstanceList = None,
+                    unmap_outputs: bool = True,
+                    return_sampling_results: bool = False) -> tuple:
+        """Compute regression and classification targets for anchors in
+        multiple images.
+
+        Args:
+            anchor_list (list[list[Tensor]]): Multi level anchors of each
+                image. The outer list indicates images, and the inner list
+                corresponds to feature levels of the image. Each element of
+                the inner list is a tensor of shape (num_anchors, 4).
+            valid_flag_list (list[list[Tensor]]): Multi level valid flags of
+                each image. The outer list indicates images, and the inner list
+                corresponds to feature levels of the image. Each element of
+                the inner list is a tensor of shape (num_anchors, )
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+            unmap_outputs (bool): Whether to map outputs back to the original
+                set of anchors. Defaults to True.
+            return_sampling_results (bool): Whether to return the sampling
+                results. Defaults to False.
+
+        Returns:
+            tuple: Usually returns a tuple containing learning targets.
+
+                - labels_list (list[Tensor]): Labels of each level.
+                - label_weights_list (list[Tensor]): Label weights of each
+                  level.
+                - bbox_targets_list (list[Tensor]): BBox targets of each level.
+                - bbox_weights_list (list[Tensor]): BBox weights of each level.
+                - avg_factor (int): Average factor that is used to average
+                  the loss. When using sampling method, avg_factor is usually
+                  the sum of positive and negative priors. When using
+                  `PseudoSampler`, `avg_factor` is usually equal to the number
+                  of positive priors.
+
+            additional_returns: This function enables user-defined returns from
+                `self._get_targets_single`. These returns are currently refined
+                to properties at each feature map (i.e. having HxW dimension).
+                The results will be concatenated after the end
+        """
+        num_imgs = len(batch_img_metas)
+        assert len(anchor_list) == len(valid_flag_list) == num_imgs
+
+        if batch_gt_instances_ignore is None:
+            batch_gt_instances_ignore = [None] * num_imgs
+
+        # anchor number of multi levels
+        num_level_anchors = [anchors.size(0) for anchors in anchor_list[0]]
+        # concat all level anchors to a single tensor
+        concat_anchor_list = []
+        concat_valid_flag_list = []
+        for i in range(num_imgs):
+            assert len(anchor_list[i]) == len(valid_flag_list[i])
+            concat_anchor_list.append(cat_boxes(anchor_list[i]))
+            concat_valid_flag_list.append(torch.cat(valid_flag_list[i]))
+
+        # compute targets for each image
+        results = multi_apply(
+            self._get_targets_single,
+            concat_anchor_list,
+            concat_valid_flag_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore,
+            unmap_outputs=unmap_outputs)
+        (all_labels, all_label_weights, all_bbox_targets, all_bbox_weights,
+         pos_inds_list, neg_inds_list, sampling_results_list) = results[:7]
+        rest_results = list(results[7:])  # user-added return values
+        # Get `avg_factor` of all images, which calculate in `SamplingResult`.
+        # When using sampling method, avg_factor is usually the sum of
+        # positive and negative priors. When using `PseudoSampler`,
+        # `avg_factor` is usually equal to the number of positive priors.
+        avg_factor = sum(
+            [results.avg_factor for results in sampling_results_list])
+        # update `_raw_positive_infos`, which will be used when calling
+        # `get_positive_infos`.
+        self._raw_positive_infos.update(sampling_results=sampling_results_list)
+        # split targets to a list w.r.t. multiple levels
+        labels_list = images_to_levels(all_labels, num_level_anchors)
+        label_weights_list = images_to_levels(all_label_weights,
+                                              num_level_anchors)
+        bbox_targets_list = images_to_levels(all_bbox_targets,
+                                             num_level_anchors)
+        bbox_weights_list = images_to_levels(all_bbox_weights,
+                                             num_level_anchors)
+        res = (labels_list, label_weights_list, bbox_targets_list,
+               bbox_weights_list, avg_factor)
+        if return_sampling_results:
+            res = res + (sampling_results_list, )
+        for i, r in enumerate(rest_results):  # user-added return values
+            rest_results[i] = images_to_levels(r, num_level_anchors)
+
+        return res + tuple(rest_results)
+
+    def loss_by_feat_single(self, cls_score: Tensor, bbox_pred: Tensor,
+                            anchors: Tensor, labels: Tensor,
+                            label_weights: Tensor, bbox_targets: Tensor,
+                            bbox_weights: Tensor, avg_factor: int) -> tuple:
+        """Calculate the loss of a single scale level based on the features
+        extracted by the detection head.
+
+        Args:
+            cls_score (Tensor): Box scores for each scale level
+                Has shape (N, num_anchors * num_classes, H, W).
+            bbox_pred (Tensor): Box energies / deltas for each scale
+                level with shape (N, num_anchors * 4, H, W).
+            anchors (Tensor): Box reference for each scale level with shape
+                (N, num_total_anchors, 4).
+            labels (Tensor): Labels of each anchors with shape
+                (N, num_total_anchors).
+            label_weights (Tensor): Label weights of each anchor with shape
+                (N, num_total_anchors)
+            bbox_targets (Tensor): BBox regression targets of each anchor
+                weight shape (N, num_total_anchors, 4).
+            bbox_weights (Tensor): BBox regression loss weights of each anchor
+                with shape (N, num_total_anchors, 4).
+            avg_factor (int): Average factor that is used to average the loss.
+
+        Returns:
+            tuple: loss components.
+        """
+        # classification loss
+        labels = labels.reshape(-1)
+        label_weights = label_weights.reshape(-1)
+        cls_score = cls_score.permute(0, 2, 3,
+                                      1).reshape(-1, self.cls_out_channels)
+        loss_cls = self.loss_cls(
+            cls_score, labels, label_weights, avg_factor=avg_factor)
+        # regression loss
+        target_dim = bbox_targets.size(-1)
+        bbox_targets = bbox_targets.reshape(-1, target_dim)
+        bbox_weights = bbox_weights.reshape(-1, target_dim)
+        bbox_pred = bbox_pred.permute(0, 2, 3,
+                                      1).reshape(-1,
+                                                 self.bbox_coder.encode_size)
+        if self.reg_decoded_bbox:
+            # When the regression loss (e.g. `IouLoss`, `GIouLoss`)
+            # is applied directly on the decoded bounding boxes, it
+            # decodes the already encoded coordinates to absolute format.
+            anchors = anchors.reshape(-1, anchors.size(-1))
+            bbox_pred = self.bbox_coder.decode(anchors, bbox_pred)
+            bbox_pred = get_box_tensor(bbox_pred)
+        loss_bbox = self.loss_bbox(
+            bbox_pred, bbox_targets, bbox_weights, avg_factor=avg_factor)
+        return loss_cls, loss_bbox
+
+    def loss_by_feat(
+            self,
+            cls_scores: List[Tensor],
+            bbox_preds: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> dict:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level
+                has shape (N, num_anchors * num_classes, H, W).
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level with shape (N, num_anchors * 4, H, W).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        assert len(featmap_sizes) == self.prior_generator.num_levels
+
+        device = cls_scores[0].device
+
+        anchor_list, valid_flag_list = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+        cls_reg_targets = self.get_targets(
+            anchor_list,
+            valid_flag_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore)
+        (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,
+         avg_factor) = cls_reg_targets
+
+        # anchor number of multi levels
+        num_level_anchors = [anchors.size(0) for anchors in anchor_list[0]]
+        # concat all level anchors and flags to a single tensor
+        concat_anchor_list = []
+        for i in range(len(anchor_list)):
+            concat_anchor_list.append(cat_boxes(anchor_list[i]))
+        all_anchor_list = images_to_levels(concat_anchor_list,
+                                           num_level_anchors)
+
+        losses_cls, losses_bbox = multi_apply(
+            self.loss_by_feat_single,
+            cls_scores,
+            bbox_preds,
+            all_anchor_list,
+            labels_list,
+            label_weights_list,
+            bbox_targets_list,
+            bbox_weights_list,
+            avg_factor=avg_factor)
+        return dict(loss_cls=losses_cls, loss_bbox=losses_bbox)
diff --git a/mmdetection/mmdet/models/dense_heads/atss_head.py b/mmdetection/mmdet/models/dense_heads/atss_head.py
new file mode 100644
index 00000000..2ce71b3e
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/atss_head.py
@@ -0,0 +1,524 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Sequence, Tuple
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule, Scale
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import (ConfigType, InstanceList, MultiConfig, OptConfigType,
+                         OptInstanceList, reduce_mean)
+from ..task_modules.prior_generators import anchor_inside_flags
+from ..utils import images_to_levels, multi_apply, unmap
+from .anchor_head import AnchorHead
+
+
+@MODELS.register_module()
+class ATSSHead(AnchorHead):
+    """Detection Head of `ATSS `_.
+
+    ATSS head structure is similar with FCOS, however ATSS use anchor boxes
+    and assign label by Adaptive Training Sample Selection instead max-iou.
+
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (int): Number of channels in the input feature map.
+        pred_kernel_size (int): Kernel size of ``nn.Conv2d``
+        stacked_convs (int): Number of stacking convs of the head.
+        conv_cfg (:obj:`ConfigDict` or dict, optional): Config dict for
+            convolution layer. Defaults to None.
+        norm_cfg (:obj:`ConfigDict` or dict): Config dict for normalization
+            layer. Defaults to ``dict(type='GN', num_groups=32,
+            requires_grad=True)``.
+        reg_decoded_bbox (bool): If true, the regression loss would be
+            applied directly on decoded bounding boxes, converting both
+            the predicted boxes and regression targets to absolute
+            coordinates format. Defaults to False. It should be `True` when
+            using `IoULoss`, `GIoULoss`, or `DIoULoss` in the bbox head.
+        loss_centerness (:obj:`ConfigDict` or dict): Config of centerness loss.
+            Defaults to ``dict(type='CrossEntropyLoss', use_sigmoid=True,
+            loss_weight=1.0)``.
+        init_cfg (:obj:`ConfigDict` or dict or list[dict] or
+            list[:obj:`ConfigDict`]): Initialization config dict.
+    """
+
+    def __init__(self,
+                 num_classes: int,
+                 in_channels: int,
+                 pred_kernel_size: int = 3,
+                 stacked_convs: int = 4,
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: ConfigType = dict(
+                     type='GN', num_groups=32, requires_grad=True),
+                 reg_decoded_bbox: bool = True,
+                 loss_centerness: ConfigType = dict(
+                     type='CrossEntropyLoss',
+                     use_sigmoid=True,
+                     loss_weight=1.0),
+                 init_cfg: MultiConfig = dict(
+                     type='Normal',
+                     layer='Conv2d',
+                     std=0.01,
+                     override=dict(
+                         type='Normal',
+                         name='atss_cls',
+                         std=0.01,
+                         bias_prob=0.01)),
+                 **kwargs) -> None:
+        self.pred_kernel_size = pred_kernel_size
+        self.stacked_convs = stacked_convs
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        super().__init__(
+            num_classes=num_classes,
+            in_channels=in_channels,
+            reg_decoded_bbox=reg_decoded_bbox,
+            init_cfg=init_cfg,
+            **kwargs)
+
+        self.sampling = False
+        self.loss_centerness = MODELS.build(loss_centerness)
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        self.relu = nn.ReLU(inplace=True)
+        self.cls_convs = nn.ModuleList()
+        self.reg_convs = nn.ModuleList()
+        for i in range(self.stacked_convs):
+            chn = self.in_channels if i == 0 else self.feat_channels
+            self.cls_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg))
+            self.reg_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg))
+        pred_pad_size = self.pred_kernel_size // 2
+        self.atss_cls = nn.Conv2d(
+            self.feat_channels,
+            self.num_anchors * self.cls_out_channels,
+            self.pred_kernel_size,
+            padding=pred_pad_size)
+        self.atss_reg = nn.Conv2d(
+            self.feat_channels,
+            self.num_base_priors * 4,
+            self.pred_kernel_size,
+            padding=pred_pad_size)
+        self.atss_centerness = nn.Conv2d(
+            self.feat_channels,
+            self.num_base_priors * 1,
+            self.pred_kernel_size,
+            padding=pred_pad_size)
+        self.scales = nn.ModuleList(
+            [Scale(1.0) for _ in self.prior_generator.strides])
+
+    def forward(self, x: Tuple[Tensor]) -> Tuple[List[Tensor]]:
+        """Forward features from the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple: Usually a tuple of classification scores and bbox prediction
+                cls_scores (list[Tensor]): Classification scores for all scale
+                    levels, each is a 4D-tensor, the channels number is
+                    num_anchors * num_classes.
+                bbox_preds (list[Tensor]): Box energies / deltas for all scale
+                    levels, each is a 4D-tensor, the channels number is
+                    num_anchors * 4.
+        """
+        return multi_apply(self.forward_single, x, self.scales)
+
+    def forward_single(self, x: Tensor, scale: Scale) -> Sequence[Tensor]:
+        """Forward feature of a single scale level.
+
+        Args:
+            x (Tensor): Features of a single scale level.
+            scale (:obj: `mmcv.cnn.Scale`): Learnable scale module to resize
+                the bbox prediction.
+
+        Returns:
+            tuple:
+                cls_score (Tensor): Cls scores for a single scale level
+                    the channels number is num_anchors * num_classes.
+                bbox_pred (Tensor): Box energies / deltas for a single scale
+                    level, the channels number is num_anchors * 4.
+                centerness (Tensor): Centerness for a single scale level, the
+                    channel number is (N, num_anchors * 1, H, W).
+        """
+        cls_feat = x
+        reg_feat = x
+        for cls_conv in self.cls_convs:
+            cls_feat = cls_conv(cls_feat)
+        for reg_conv in self.reg_convs:
+            reg_feat = reg_conv(reg_feat)
+        cls_score = self.atss_cls(cls_feat)
+        # we just follow atss, not apply exp in bbox_pred
+        bbox_pred = scale(self.atss_reg(reg_feat)).float()
+        centerness = self.atss_centerness(reg_feat)
+        return cls_score, bbox_pred, centerness
+
+    def loss_by_feat_single(self, anchors: Tensor, cls_score: Tensor,
+                            bbox_pred: Tensor, centerness: Tensor,
+                            labels: Tensor, label_weights: Tensor,
+                            bbox_targets: Tensor, avg_factor: float) -> dict:
+        """Calculate the loss of a single scale level based on the features
+        extracted by the detection head.
+
+        Args:
+            cls_score (Tensor): Box scores for each scale level
+                Has shape (N, num_anchors * num_classes, H, W).
+            bbox_pred (Tensor): Box energies / deltas for each scale
+                level with shape (N, num_anchors * 4, H, W).
+            anchors (Tensor): Box reference for each scale level with shape
+                (N, num_total_anchors, 4).
+            labels (Tensor): Labels of each anchors with shape
+                (N, num_total_anchors).
+            label_weights (Tensor): Label weights of each anchor with shape
+                (N, num_total_anchors)
+            bbox_targets (Tensor): BBox regression targets of each anchor with
+                shape (N, num_total_anchors, 4).
+            avg_factor (float): Average factor that is used to average
+                the loss. When using sampling method, avg_factor is usually
+                the sum of positive and negative priors. When using
+                `PseudoSampler`, `avg_factor` is usually equal to the number
+                of positive priors.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+
+        anchors = anchors.reshape(-1, 4)
+        cls_score = cls_score.permute(0, 2, 3, 1).reshape(
+            -1, self.cls_out_channels).contiguous()
+        bbox_pred = bbox_pred.permute(0, 2, 3, 1).reshape(-1, 4)
+        centerness = centerness.permute(0, 2, 3, 1).reshape(-1)
+        bbox_targets = bbox_targets.reshape(-1, 4)
+        labels = labels.reshape(-1)
+        label_weights = label_weights.reshape(-1)
+
+        # classification loss
+        loss_cls = self.loss_cls(
+            cls_score, labels, label_weights, avg_factor=avg_factor)
+
+        # FG cat_id: [0, num_classes -1], BG cat_id: num_classes
+        bg_class_ind = self.num_classes
+        pos_inds = ((labels >= 0)
+                    & (labels < bg_class_ind)).nonzero().squeeze(1)
+
+        if len(pos_inds) > 0:
+            pos_bbox_targets = bbox_targets[pos_inds]
+            pos_bbox_pred = bbox_pred[pos_inds]
+            pos_anchors = anchors[pos_inds]
+            pos_centerness = centerness[pos_inds]
+
+            centerness_targets = self.centerness_target(
+                pos_anchors, pos_bbox_targets)
+            pos_decode_bbox_pred = self.bbox_coder.decode(
+                pos_anchors, pos_bbox_pred)
+
+            # regression loss
+            loss_bbox = self.loss_bbox(
+                pos_decode_bbox_pred,
+                pos_bbox_targets,
+                weight=centerness_targets,
+                avg_factor=1.0)
+
+            # centerness loss
+            loss_centerness = self.loss_centerness(
+                pos_centerness, centerness_targets, avg_factor=avg_factor)
+
+        else:
+            loss_bbox = bbox_pred.sum() * 0
+            loss_centerness = centerness.sum() * 0
+            centerness_targets = bbox_targets.new_tensor(0.)
+
+        return loss_cls, loss_bbox, loss_centerness, centerness_targets.sum()
+
+    def loss_by_feat(
+            self,
+            cls_scores: List[Tensor],
+            bbox_preds: List[Tensor],
+            centernesses: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> dict:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level
+                Has shape (N, num_anchors * num_classes, H, W)
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level with shape (N, num_anchors * 4, H, W)
+            centernesses (list[Tensor]): Centerness for each scale
+                level with shape (N, num_anchors * 1, H, W)
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], Optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        featmap_sizes = [featmap.size()[-2:] for featmap in bbox_preds]
+        assert len(featmap_sizes) == self.prior_generator.num_levels
+
+        device = cls_scores[0].device
+        anchor_list, valid_flag_list = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+
+        cls_reg_targets = self.get_targets(
+            anchor_list,
+            valid_flag_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore)
+
+        (anchor_list, labels_list, label_weights_list, bbox_targets_list,
+         bbox_weights_list, avg_factor) = cls_reg_targets
+        avg_factor = reduce_mean(
+            torch.tensor(avg_factor, dtype=torch.float, device=device)).item()
+
+        losses_cls, losses_bbox, loss_centerness, \
+            bbox_avg_factor = multi_apply(
+                self.loss_by_feat_single,
+                anchor_list,
+                cls_scores,
+                bbox_preds,
+                centernesses,
+                labels_list,
+                label_weights_list,
+                bbox_targets_list,
+                avg_factor=avg_factor)
+
+        bbox_avg_factor = sum(bbox_avg_factor)
+        bbox_avg_factor = reduce_mean(bbox_avg_factor).clamp_(min=1).item()
+        losses_bbox = list(map(lambda x: x / bbox_avg_factor, losses_bbox))
+        return dict(
+            loss_cls=losses_cls,
+            loss_bbox=losses_bbox,
+            loss_centerness=loss_centerness)
+
+    def centerness_target(self, anchors: Tensor, gts: Tensor) -> Tensor:
+        """Calculate the centerness between anchors and gts.
+
+        Only calculate pos centerness targets, otherwise there may be nan.
+
+        Args:
+            anchors (Tensor): Anchors with shape (N, 4), "xyxy" format.
+            gts (Tensor): Ground truth bboxes with shape (N, 4), "xyxy" format.
+
+        Returns:
+            Tensor: Centerness between anchors and gts.
+        """
+        anchors_cx = (anchors[:, 2] + anchors[:, 0]) / 2
+        anchors_cy = (anchors[:, 3] + anchors[:, 1]) / 2
+        l_ = anchors_cx - gts[:, 0]
+        t_ = anchors_cy - gts[:, 1]
+        r_ = gts[:, 2] - anchors_cx
+        b_ = gts[:, 3] - anchors_cy
+
+        left_right = torch.stack([l_, r_], dim=1)
+        top_bottom = torch.stack([t_, b_], dim=1)
+        centerness = torch.sqrt(
+            (left_right.min(dim=-1)[0] / left_right.max(dim=-1)[0]) *
+            (top_bottom.min(dim=-1)[0] / top_bottom.max(dim=-1)[0]))
+        assert not torch.isnan(centerness).any()
+        return centerness
+
+    def get_targets(self,
+                    anchor_list: List[List[Tensor]],
+                    valid_flag_list: List[List[Tensor]],
+                    batch_gt_instances: InstanceList,
+                    batch_img_metas: List[dict],
+                    batch_gt_instances_ignore: OptInstanceList = None,
+                    unmap_outputs: bool = True) -> tuple:
+        """Get targets for ATSS head.
+
+        This method is almost the same as `AnchorHead.get_targets()`. Besides
+        returning the targets as the parent method does, it also returns the
+        anchors as the first element of the returned tuple.
+        """
+        num_imgs = len(batch_img_metas)
+        assert len(anchor_list) == len(valid_flag_list) == num_imgs
+
+        # anchor number of multi levels
+        num_level_anchors = [anchors.size(0) for anchors in anchor_list[0]]
+        num_level_anchors_list = [num_level_anchors] * num_imgs
+
+        # concat all level anchors and flags to a single tensor
+        for i in range(num_imgs):
+            assert len(anchor_list[i]) == len(valid_flag_list[i])
+            anchor_list[i] = torch.cat(anchor_list[i])
+            valid_flag_list[i] = torch.cat(valid_flag_list[i])
+
+        # compute targets for each image
+        if batch_gt_instances_ignore is None:
+            batch_gt_instances_ignore = [None] * num_imgs
+        (all_anchors, all_labels, all_label_weights, all_bbox_targets,
+         all_bbox_weights, pos_inds_list, neg_inds_list,
+         sampling_results_list) = multi_apply(
+             self._get_targets_single,
+             anchor_list,
+             valid_flag_list,
+             num_level_anchors_list,
+             batch_gt_instances,
+             batch_img_metas,
+             batch_gt_instances_ignore,
+             unmap_outputs=unmap_outputs)
+        # Get `avg_factor` of all images, which calculate in `SamplingResult`.
+        # When using sampling method, avg_factor is usually the sum of
+        # positive and negative priors. When using `PseudoSampler`,
+        # `avg_factor` is usually equal to the number of positive priors.
+        avg_factor = sum(
+            [results.avg_factor for results in sampling_results_list])
+        # split targets to a list w.r.t. multiple levels
+        anchors_list = images_to_levels(all_anchors, num_level_anchors)
+        labels_list = images_to_levels(all_labels, num_level_anchors)
+        label_weights_list = images_to_levels(all_label_weights,
+                                              num_level_anchors)
+        bbox_targets_list = images_to_levels(all_bbox_targets,
+                                             num_level_anchors)
+        bbox_weights_list = images_to_levels(all_bbox_weights,
+                                             num_level_anchors)
+        return (anchors_list, labels_list, label_weights_list,
+                bbox_targets_list, bbox_weights_list, avg_factor)
+
+    def _get_targets_single(self,
+                            flat_anchors: Tensor,
+                            valid_flags: Tensor,
+                            num_level_anchors: List[int],
+                            gt_instances: InstanceData,
+                            img_meta: dict,
+                            gt_instances_ignore: Optional[InstanceData] = None,
+                            unmap_outputs: bool = True) -> tuple:
+        """Compute regression, classification targets for anchors in a single
+        image.
+
+        Args:
+            flat_anchors (Tensor): Multi-level anchors of the image, which are
+                concatenated into a single tensor of shape (num_anchors ,4)
+            valid_flags (Tensor): Multi level valid flags of the image,
+                which are concatenated into a single tensor of
+                    shape (num_anchors,).
+            num_level_anchors (List[int]): Number of anchors of each scale
+                level.
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            img_meta (dict): Meta information for current image.
+            gt_instances_ignore (:obj:`InstanceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+            unmap_outputs (bool): Whether to map outputs back to the original
+                set of anchors.
+
+        Returns:
+            tuple: N is the number of total anchors in the image.
+                labels (Tensor): Labels of all anchors in the image with shape
+                    (N,).
+                label_weights (Tensor): Label weights of all anchor in the
+                    image with shape (N,).
+                bbox_targets (Tensor): BBox targets of all anchors in the
+                    image with shape (N, 4).
+                bbox_weights (Tensor): BBox weights of all anchors in the
+                    image with shape (N, 4)
+                pos_inds (Tensor): Indices of positive anchor with shape
+                    (num_pos,).
+                neg_inds (Tensor): Indices of negative anchor with shape
+                    (num_neg,).
+                sampling_result (:obj:`SamplingResult`): Sampling results.
+        """
+        inside_flags = anchor_inside_flags(flat_anchors, valid_flags,
+                                           img_meta['img_shape'][:2],
+                                           self.train_cfg['allowed_border'])
+        if not inside_flags.any():
+            raise ValueError(
+                'There is no valid anchor inside the image boundary. Please '
+                'check the image size and anchor sizes, or set '
+                '``allowed_border`` to -1 to skip the condition.')
+        # assign gt and sample anchors
+        anchors = flat_anchors[inside_flags, :]
+
+        num_level_anchors_inside = self.get_num_level_anchors_inside(
+            num_level_anchors, inside_flags)
+        pred_instances = InstanceData(priors=anchors)
+        assign_result = self.assigner.assign(pred_instances,
+                                             num_level_anchors_inside,
+                                             gt_instances, gt_instances_ignore)
+
+        sampling_result = self.sampler.sample(assign_result, pred_instances,
+                                              gt_instances)
+
+        num_valid_anchors = anchors.shape[0]
+        bbox_targets = torch.zeros_like(anchors)
+        bbox_weights = torch.zeros_like(anchors)
+        labels = anchors.new_full((num_valid_anchors, ),
+                                  self.num_classes,
+                                  dtype=torch.long)
+        label_weights = anchors.new_zeros(num_valid_anchors, dtype=torch.float)
+
+        pos_inds = sampling_result.pos_inds
+        neg_inds = sampling_result.neg_inds
+        if len(pos_inds) > 0:
+            if self.reg_decoded_bbox:
+                pos_bbox_targets = sampling_result.pos_gt_bboxes
+            else:
+                pos_bbox_targets = self.bbox_coder.encode(
+                    sampling_result.pos_priors, sampling_result.pos_gt_bboxes)
+
+            bbox_targets[pos_inds, :] = pos_bbox_targets
+            bbox_weights[pos_inds, :] = 1.0
+
+            labels[pos_inds] = sampling_result.pos_gt_labels
+            if self.train_cfg['pos_weight'] <= 0:
+                label_weights[pos_inds] = 1.0
+            else:
+                label_weights[pos_inds] = self.train_cfg['pos_weight']
+        if len(neg_inds) > 0:
+            label_weights[neg_inds] = 1.0
+
+        # map up to original set of anchors
+        if unmap_outputs:
+            num_total_anchors = flat_anchors.size(0)
+            anchors = unmap(anchors, num_total_anchors, inside_flags)
+            labels = unmap(
+                labels, num_total_anchors, inside_flags, fill=self.num_classes)
+            label_weights = unmap(label_weights, num_total_anchors,
+                                  inside_flags)
+            bbox_targets = unmap(bbox_targets, num_total_anchors, inside_flags)
+            bbox_weights = unmap(bbox_weights, num_total_anchors, inside_flags)
+
+        return (anchors, labels, label_weights, bbox_targets, bbox_weights,
+                pos_inds, neg_inds, sampling_result)
+
+    def get_num_level_anchors_inside(self, num_level_anchors, inside_flags):
+        """Get the number of valid anchors in every level."""
+
+        split_inside_flags = torch.split(inside_flags, num_level_anchors)
+        num_level_anchors_inside = [
+            int(flags.sum()) for flags in split_inside_flags
+        ]
+        return num_level_anchors_inside
diff --git a/mmdetection/mmdet/models/dense_heads/atss_vlfusion_head.py b/mmdetection/mmdet/models/dense_heads/atss_vlfusion_head.py
new file mode 100644
index 00000000..c5cd28b4
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/atss_vlfusion_head.py
@@ -0,0 +1,949 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import math
+from typing import Callable, List, Optional, Sequence, Tuple, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import Scale
+from mmcv.ops.modulated_deform_conv import ModulatedDeformConv2d
+from mmengine.config import ConfigDict
+from mmengine.model import BaseModel
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+try:
+    from transformers import BertConfig
+except ImportError:
+    BertConfig = None
+
+from mmdet.registry import MODELS
+from mmdet.structures.bbox import cat_boxes
+from mmdet.utils import InstanceList, OptInstanceList, reduce_mean
+from ..utils import (BertEncoderLayer, VLFuse, filter_scores_and_topk,
+                     permute_and_flatten, select_single_mlvl,
+                     unpack_gt_instances)
+from ..utils.vlfuse_helper import MAX_CLAMP_VALUE
+from .atss_head import ATSSHead
+
+
+def convert_grounding_to_cls_scores(logits: Tensor,
+                                    positive_maps: List[dict]) -> Tensor:
+    """Convert logits to class scores."""
+    assert len(positive_maps) == logits.shape[0]  # batch size
+
+    scores = torch.zeros(logits.shape[0], logits.shape[1],
+                         len(positive_maps[0])).to(logits.device)
+    if positive_maps is not None:
+        if all(x == positive_maps[0] for x in positive_maps):
+            # only need to compute once
+            positive_map = positive_maps[0]
+            for label_j in positive_map:
+                scores[:, :, label_j -
+                       1] = logits[:, :,
+                                   torch.LongTensor(positive_map[label_j]
+                                                    )].mean(-1)
+        else:
+            for i, positive_map in enumerate(positive_maps):
+                for label_j in positive_map:
+                    scores[i, :, label_j - 1] = logits[
+                        i, :, torch.LongTensor(positive_map[label_j])].mean(-1)
+    return scores
+
+
+class Conv3x3Norm(nn.Module):
+    """Conv3x3 and norm."""
+
+    def __init__(self,
+                 in_channels: int,
+                 out_channels: int,
+                 stride: int,
+                 groups: int = 1,
+                 use_dcn: bool = False,
+                 norm_type: Optional[Union[Sequence, str]] = None):
+        super().__init__()
+
+        if use_dcn:
+            self.conv = ModulatedDeformConv2d(
+                in_channels,
+                out_channels,
+                kernel_size=3,
+                stride=stride,
+                padding=1,
+                groups=groups)
+        else:
+            self.conv = nn.Conv2d(
+                in_channels,
+                out_channels,
+                kernel_size=3,
+                stride=stride,
+                padding=1,
+                groups=groups)
+
+        if isinstance(norm_type, Sequence):
+            assert len(norm_type) == 2
+            assert norm_type[0] == 'gn'
+            gn_group = norm_type[1]
+            norm_type = norm_type[0]
+
+        if norm_type == 'bn':
+            bn_op = nn.BatchNorm2d(out_channels)
+        elif norm_type == 'gn':
+            bn_op = nn.GroupNorm(
+                num_groups=gn_group, num_channels=out_channels)
+        if norm_type is not None:
+            self.bn = bn_op
+        else:
+            self.bn = None
+
+    def forward(self, x, **kwargs):
+        x = self.conv(x, **kwargs)
+        if self.bn:
+            x = self.bn(x)
+        return x
+
+
+class DyReLU(nn.Module):
+    """Dynamic ReLU."""
+
+    def __init__(self,
+                 in_channels: int,
+                 out_channels: int,
+                 expand_ratio: int = 4):
+        super().__init__()
+        self.avg_pool = nn.AdaptiveAvgPool2d(1)
+        self.expand_ratio = expand_ratio
+        self.out_channels = out_channels
+
+        self.fc = nn.Sequential(
+            nn.Linear(in_channels, in_channels // expand_ratio),
+            nn.ReLU(inplace=True),
+            nn.Linear(in_channels // expand_ratio,
+                      out_channels * self.expand_ratio),
+            nn.Hardsigmoid(inplace=True))
+
+    def forward(self, x) -> Tensor:
+        x_out = x
+        b, c, h, w = x.size()
+        x = self.avg_pool(x).view(b, c)
+        x = self.fc(x).view(b, -1, 1, 1)
+
+        a1, b1, a2, b2 = torch.split(x, self.out_channels, dim=1)
+        a1 = (a1 - 0.5) * 2 + 1.0
+        a2 = (a2 - 0.5) * 2
+        b1 = b1 - 0.5
+        b2 = b2 - 0.5
+        out = torch.max(x_out * a1 + b1, x_out * a2 + b2)
+        return out
+
+
+class DyConv(nn.Module):
+    """Dynamic Convolution."""
+
+    def __init__(self,
+                 conv_func: Callable,
+                 in_channels: int,
+                 out_channels: int,
+                 use_dyfuse: bool = True,
+                 use_dyrelu: bool = False,
+                 use_dcn: bool = False):
+        super().__init__()
+
+        self.dyconvs = nn.ModuleList()
+        self.dyconvs.append(conv_func(in_channels, out_channels, 1))
+        self.dyconvs.append(conv_func(in_channels, out_channels, 1))
+        self.dyconvs.append(conv_func(in_channels, out_channels, 2))
+
+        if use_dyfuse:
+            self.attnconv = nn.Sequential(
+                nn.AdaptiveAvgPool2d(1),
+                nn.Conv2d(in_channels, 1, kernel_size=1),
+                nn.ReLU(inplace=True))
+            self.h_sigmoid = nn.Hardsigmoid(inplace=True)
+        else:
+            self.attnconv = None
+
+        if use_dyrelu:
+            self.relu = DyReLU(in_channels, out_channels)
+        else:
+            self.relu = nn.ReLU()
+
+        if use_dcn:
+            self.offset = nn.Conv2d(
+                in_channels, 27, kernel_size=3, stride=1, padding=1)
+        else:
+            self.offset = None
+
+        self.init_weights()
+
+    def init_weights(self):
+        for m in self.dyconvs.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.normal_(m.weight.data, 0, 0.01)
+                if m.bias is not None:
+                    m.bias.data.zero_()
+        if self.attnconv is not None:
+            for m in self.attnconv.modules():
+                if isinstance(m, nn.Conv2d):
+                    nn.init.normal_(m.weight.data, 0, 0.01)
+                    if m.bias is not None:
+                        m.bias.data.zero_()
+
+    def forward(self, inputs: dict) -> dict:
+        visual_feats = inputs['visual']
+
+        out_vis_feats = []
+        for level, feature in enumerate(visual_feats):
+
+            offset_conv_args = {}
+            if self.offset is not None:
+                offset_mask = self.offset(feature)
+                offset = offset_mask[:, :18, :, :]
+                mask = offset_mask[:, 18:, :, :].sigmoid()
+                offset_conv_args = dict(offset=offset, mask=mask)
+
+            temp_feats = [self.dyconvs[1](feature, **offset_conv_args)]
+
+            if level > 0:
+                temp_feats.append(self.dyconvs[2](visual_feats[level - 1],
+                                                  **offset_conv_args))
+            if level < len(visual_feats) - 1:
+                temp_feats.append(
+                    F.upsample_bilinear(
+                        self.dyconvs[0](visual_feats[level + 1],
+                                        **offset_conv_args),
+                        size=[feature.size(2),
+                              feature.size(3)]))
+            mean_feats = torch.mean(
+                torch.stack(temp_feats), dim=0, keepdim=False)
+
+            if self.attnconv is not None:
+                attn_feat = []
+                res_feat = []
+                for feat in temp_feats:
+                    res_feat.append(feat)
+                    attn_feat.append(self.attnconv(feat))
+
+                res_feat = torch.stack(res_feat)
+                spa_pyr_attn = self.h_sigmoid(torch.stack(attn_feat))
+
+                mean_feats = torch.mean(
+                    res_feat * spa_pyr_attn, dim=0, keepdim=False)
+
+            out_vis_feats.append(mean_feats)
+
+        out_vis_feats = [self.relu(item) for item in out_vis_feats]
+
+        features_dict = {'visual': out_vis_feats, 'lang': inputs['lang']}
+
+        return features_dict
+
+
+class VLFusionModule(BaseModel):
+    """Visual-lang Fusion Module."""
+
+    def __init__(self,
+                 in_channels: int,
+                 feat_channels: int,
+                 num_base_priors: int,
+                 early_fuse: bool = False,
+                 num_dyhead_blocks: int = 6,
+                 lang_model_name: str = 'bert-base-uncased',
+                 use_dyrelu: bool = True,
+                 use_dyfuse: bool = True,
+                 use_dcn: bool = True,
+                 use_checkpoint: bool = False,
+                 **kwargs) -> None:
+        super().__init__(**kwargs)
+        if BertConfig is None:
+            raise RuntimeError(
+                'transformers is not installed, please install it by: '
+                'pip install transformers.')
+        self.in_channels = in_channels
+        self.feat_channels = feat_channels
+        self.num_base_priors = num_base_priors
+        self.early_fuse = early_fuse
+        self.num_dyhead_blocks = num_dyhead_blocks
+        self.use_dyrelu = use_dyrelu
+        self.use_dyfuse = use_dyfuse
+        self.use_dcn = use_dcn
+        self.use_checkpoint = use_checkpoint
+
+        self.lang_cfg = BertConfig.from_pretrained(lang_model_name)
+        self.lang_dim = self.lang_cfg.hidden_size
+        self._init_layers()
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the model."""
+        bias_value = -math.log((1 - 0.01) / 0.01)
+
+        dyhead_tower = []
+        for i in range(self.num_dyhead_blocks):
+            if self.early_fuse:
+                # cross-modality fusion
+                dyhead_tower.append(VLFuse(use_checkpoint=self.use_checkpoint))
+                # lang branch
+                dyhead_tower.append(
+                    BertEncoderLayer(
+                        self.lang_cfg,
+                        clamp_min_for_underflow=True,
+                        clamp_max_for_overflow=True))
+
+            # vision branch
+            dyhead_tower.append(
+                DyConv(
+                    lambda i, o, s: Conv3x3Norm(
+                        i, o, s, use_dcn=self.use_dcn, norm_type=['gn', 16]),
+                    self.in_channels if i == 0 else self.feat_channels,
+                    self.feat_channels,
+                    use_dyrelu=(self.use_dyrelu
+                                and self.in_channels == self.feat_channels)
+                    if i == 0 else self.use_dyrelu,
+                    use_dyfuse=(self.use_dyfuse
+                                and self.in_channels == self.feat_channels)
+                    if i == 0 else self.use_dyfuse,
+                    use_dcn=(self.use_dcn
+                             and self.in_channels == self.feat_channels)
+                    if i == 0 else self.use_dcn,
+                ))
+
+        self.add_module('dyhead_tower', nn.Sequential(*dyhead_tower))
+
+        self.bbox_pred = nn.Conv2d(
+            self.feat_channels, self.num_base_priors * 4, kernel_size=1)
+        self.centerness = nn.Conv2d(
+            self.feat_channels, self.num_base_priors * 1, kernel_size=1)
+        self.dot_product_projection_text = nn.Linear(
+            self.lang_dim,
+            self.num_base_priors * self.feat_channels,
+            bias=True)
+        self.log_scale = nn.Parameter(torch.Tensor([0.0]), requires_grad=True)
+        self.bias_lang = nn.Parameter(
+            torch.zeros(self.lang_dim), requires_grad=True)
+        self.bias0 = nn.Parameter(
+            torch.Tensor([bias_value]), requires_grad=True)
+        self.scales = nn.ModuleList([Scale(1.0) for _ in range(5)])
+
+    def forward(self, visual_feats: Tuple[Tensor],
+                language_feats: dict) -> Tuple:
+        feat_inputs = {'visual': visual_feats, 'lang': language_feats}
+        dyhead_tower = self.dyhead_tower(feat_inputs)
+
+        if self.early_fuse:
+            embedding = dyhead_tower['lang']['hidden']
+        else:
+            embedding = language_feats['embedded']
+
+        embedding = F.normalize(embedding, p=2, dim=-1)
+        dot_product_proj_tokens = self.dot_product_projection_text(embedding /
+                                                                   2.0)
+        dot_product_proj_tokens_bias = torch.matmul(
+            embedding, self.bias_lang) + self.bias0
+
+        bbox_preds = []
+        centerness = []
+        cls_logits = []
+
+        for i, feature in enumerate(visual_feats):
+            visual = dyhead_tower['visual'][i]
+            B, C, H, W = visual.shape
+
+            bbox_pred = self.scales[i](self.bbox_pred(visual))
+            bbox_preds.append(bbox_pred)
+            centerness.append(self.centerness(visual))
+
+            dot_product_proj_queries = permute_and_flatten(
+                visual, B, self.num_base_priors, C, H, W)
+
+            bias = dot_product_proj_tokens_bias.unsqueeze(1).repeat(
+                1, self.num_base_priors, 1)
+            dot_product_logit = (
+                torch.matmul(dot_product_proj_queries,
+                             dot_product_proj_tokens.transpose(-1, -2)) /
+                self.log_scale.exp()) + bias
+            dot_product_logit = torch.clamp(
+                dot_product_logit, max=MAX_CLAMP_VALUE)
+            dot_product_logit = torch.clamp(
+                dot_product_logit, min=-MAX_CLAMP_VALUE)
+            cls_logits.append(dot_product_logit)
+
+        return bbox_preds, centerness, cls_logits
+
+
+@MODELS.register_module()
+class ATSSVLFusionHead(ATSSHead):
+    """ATSS head with visual-language fusion module.
+
+    Args:
+        early_fuse (bool): Whether to fuse visual and language features
+            Defaults to False.
+        use_checkpoint (bool): Whether to use checkpoint. Defaults to False.
+        num_dyhead_blocks (int): Number of dynamic head blocks. Defaults to 6.
+        lang_model_name (str): Name of the language model.
+            Defaults to 'bert-base-uncased'.
+    """
+
+    def __init__(self,
+                 *args,
+                 early_fuse: bool = False,
+                 use_checkpoint: bool = False,
+                 num_dyhead_blocks: int = 6,
+                 lang_model_name: str = 'bert-base-uncased',
+                 init_cfg=None,
+                 **kwargs):
+        super().__init__(*args, **kwargs, init_cfg=init_cfg)
+        self.head = VLFusionModule(
+            in_channels=self.in_channels,
+            feat_channels=self.feat_channels,
+            num_base_priors=self.num_base_priors,
+            early_fuse=early_fuse,
+            use_checkpoint=use_checkpoint,
+            num_dyhead_blocks=num_dyhead_blocks,
+            lang_model_name=lang_model_name)
+        self.text_masks = None
+
+    def _init_layers(self) -> None:
+        """No need to initialize the ATSS head layer."""
+        pass
+
+    def forward(self, visual_feats: Tuple[Tensor],
+                language_feats: dict) -> Tuple[Tensor]:
+        """Forward function."""
+        bbox_preds, centerness, cls_logits = self.head(visual_feats,
+                                                       language_feats)
+        return cls_logits, bbox_preds, centerness
+
+    def loss(self, visual_feats: Tuple[Tensor], language_feats: dict,
+             batch_data_samples):
+        outputs = unpack_gt_instances(batch_data_samples)
+        (batch_gt_instances, batch_gt_instances_ignore,
+         batch_img_metas) = outputs
+
+        outs = self(visual_feats, language_feats)
+        self.text_masks = language_feats['masks']
+        loss_inputs = outs + (batch_gt_instances, batch_img_metas,
+                              batch_gt_instances_ignore)
+        losses = self.loss_by_feat(*loss_inputs)
+        return losses
+
+    def loss_by_feat(
+            self,
+            cls_scores: List[Tensor],
+            bbox_preds: List[Tensor],
+            centernesses: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> dict:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level
+                Has shape (N, num_anchors * num_classes, H, W)
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level with shape (N, num_anchors * 4, H, W)
+            centernesses (list[Tensor]): Centerness for each scale
+                level with shape (N, num_anchors * 1, H, W)
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], Optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        featmap_sizes = [featmap.size()[-2:] for featmap in bbox_preds]
+        assert len(featmap_sizes) == self.prior_generator.num_levels
+
+        device = cls_scores[0].device
+        anchor_list, valid_flag_list = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+
+        cls_reg_targets = self.get_targets(
+            anchor_list,
+            valid_flag_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore)
+
+        (anchor_list, labels_list, label_weights_list, bbox_targets_list,
+         bbox_weights_list, avg_factor) = cls_reg_targets
+        avg_factor = reduce_mean(
+            torch.tensor(avg_factor, dtype=torch.float, device=device)).item()
+
+        anchors = torch.cat(anchor_list, dim=1)
+        labels = torch.cat(labels_list, dim=1)
+        label_weights = torch.cat(label_weights_list, dim=1)
+        bbox_targets = torch.cat(bbox_targets_list, dim=1)
+        cls_scores = torch.cat(cls_scores, dim=1)
+
+        centernesses_ = []
+        bbox_preds_ = []
+        for bbox_pred, centerness in zip(bbox_preds, centernesses):
+            centernesses_.append(
+                centerness.permute(0, 2, 3,
+                                   1).reshape(cls_scores.size(0), -1, 1))
+            bbox_preds_.append(
+                bbox_pred.permute(0, 2, 3,
+                                  1).reshape(cls_scores.size(0), -1, 4))
+        bbox_preds = torch.cat(bbox_preds_, dim=1)
+        centernesses = torch.cat(centernesses_, dim=1)
+
+        losses_cls, losses_bbox, loss_centerness, bbox_avg_factor = \
+            self._loss_by_feat(
+                anchors,
+                cls_scores,
+                bbox_preds,
+                centernesses,
+                labels,
+                label_weights,
+                bbox_targets,
+                avg_factor=avg_factor)
+
+        bbox_avg_factor = reduce_mean(bbox_avg_factor).clamp_(min=1).item()
+        losses_bbox = losses_bbox / bbox_avg_factor
+        return dict(
+            loss_cls=losses_cls,
+            loss_bbox=losses_bbox,
+            loss_centerness=loss_centerness)
+
+    def _loss_by_feat(self, anchors: Tensor, cls_score: Tensor,
+                      bbox_pred: Tensor, centerness: Tensor, labels: Tensor,
+                      label_weights: Tensor, bbox_targets: Tensor,
+                      avg_factor: float) -> dict:
+        """Calculate the loss of all scale level based on the features
+        extracted by the detection head.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+
+        anchors = anchors.reshape(-1, 4)
+
+        # ===== this change =====
+        pos_inds = (labels.sum(-1) > 0).reshape(-1)
+
+        # Loss is not computed for the padded regions of the text.
+        assert (self.text_masks.dim() == 2)
+        text_mask = (self.text_masks > 0).unsqueeze(1)
+        text_mask = text_mask.repeat(1, cls_score.size(1), 1)
+        cls_score = torch.masked_select(cls_score, text_mask).contiguous()
+        labels = torch.masked_select(labels, text_mask)
+        label_weights = label_weights[...,
+                                      None].repeat(1, 1, text_mask.size(-1))
+        label_weights = torch.masked_select(label_weights, text_mask)
+
+        bbox_pred = bbox_pred.reshape(-1, 4)
+        centerness = centerness.reshape(-1)
+        bbox_targets = bbox_targets.reshape(-1, 4)
+        labels = labels.reshape(-1)
+        label_weights = label_weights.reshape(-1)
+
+        # classification loss
+        loss_cls = self.loss_cls(
+            cls_score, labels, label_weights, avg_factor=avg_factor)
+
+        if pos_inds.sum() > 0:
+            pos_bbox_targets = bbox_targets[pos_inds]
+            pos_bbox_pred = bbox_pred[pos_inds]
+            pos_anchors = anchors[pos_inds]
+            pos_centerness = centerness[pos_inds]
+
+            centerness_targets = self.centerness_target(
+                pos_anchors, pos_bbox_targets)
+
+            if torch.isnan(centerness_targets).any():
+                print('=====Centerness includes NaN=====')
+                mask = ~torch.isnan(centerness_targets)
+                centerness_targets = centerness_targets[mask]
+                pos_centerness = pos_centerness[mask]
+                pos_anchors = pos_anchors[mask]
+                pos_bbox_targets = pos_bbox_targets[mask]
+                pos_bbox_pred = pos_bbox_pred[mask]
+
+                if pos_bbox_targets.shape[0] == 0:
+                    loss_bbox = bbox_pred.sum() * 0
+                    loss_centerness = centerness.sum() * 0
+                    centerness_targets = bbox_targets.new_tensor(0.)
+                    return loss_cls, loss_bbox, loss_centerness, \
+                        centerness_targets.sum()
+
+            # The decoding process takes the offset into consideration.
+            pos_anchors[:, 2:] += 1
+            pos_decode_bbox_pred = self.bbox_coder.decode(
+                pos_anchors, pos_bbox_pred)
+
+            # regression loss
+            loss_bbox = self.loss_bbox(
+                pos_decode_bbox_pred,
+                pos_bbox_targets,
+                weight=centerness_targets,
+                avg_factor=1.0)
+
+            # centerness loss
+            loss_centerness = self.loss_centerness(
+                pos_centerness, centerness_targets, avg_factor=avg_factor)
+        else:
+            loss_bbox = bbox_pred.sum() * 0
+            loss_centerness = centerness.sum() * 0
+            centerness_targets = bbox_targets.new_tensor(0.)
+
+        return loss_cls, loss_bbox, loss_centerness, centerness_targets.sum()
+
+    def _get_targets_single(self,
+                            flat_anchors: Tensor,
+                            valid_flags: Tensor,
+                            num_level_anchors: List[int],
+                            gt_instances: InstanceData,
+                            img_meta: dict,
+                            gt_instances_ignore: Optional[InstanceData] = None,
+                            unmap_outputs: bool = True) -> tuple:
+        """Compute regression, classification targets for anchors in a single
+        image.
+
+        Args:
+            flat_anchors (Tensor): Multi-level anchors of the image, which are
+                concatenated into a single tensor of shape (num_anchors ,4)
+            valid_flags (Tensor): Multi level valid flags of the image,
+                which are concatenated into a single tensor of
+                    shape (num_anchors,).
+            num_level_anchors (List[int]): Number of anchors of each scale
+                level.
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            img_meta (dict): Meta information for current image.
+            gt_instances_ignore (:obj:`InstanceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+            unmap_outputs (bool): Whether to map outputs back to the original
+                set of anchors.
+
+        Returns:
+            tuple: N is the number of total anchors in the image.
+                labels (Tensor): Labels of all anchors in the image with shape
+                    (N,).
+                label_weights (Tensor): Label weights of all anchor in the
+                    image with shape (N,).
+                bbox_targets (Tensor): BBox targets of all anchors in the
+                    image with shape (N, 4).
+                bbox_weights (Tensor): BBox weights of all anchors in the
+                    image with shape (N, 4)
+                pos_inds (Tensor): Indices of positive anchor with shape
+                    (num_pos,).
+                neg_inds (Tensor): Indices of negative anchor with shape
+                    (num_neg,).
+                sampling_result (:obj:`SamplingResult`): Sampling results.
+        """
+        anchors = flat_anchors
+        # Align the official implementation
+        anchors[:, 2:] -= 1
+
+        num_level_anchors_inside = num_level_anchors
+        pred_instances = InstanceData(priors=anchors)
+        assign_result = self.assigner.assign(pred_instances,
+                                             num_level_anchors_inside,
+                                             gt_instances, gt_instances_ignore)
+
+        sampling_result = self.sampler.sample(assign_result, pred_instances,
+                                              gt_instances)
+
+        num_valid_anchors = anchors.shape[0]
+        bbox_targets = torch.zeros_like(anchors)
+        bbox_weights = torch.zeros_like(anchors)
+
+        # ===== this change =====
+        labels = anchors.new_full((num_valid_anchors, self.feat_channels),
+                                  0,
+                                  dtype=torch.float32)
+        label_weights = anchors.new_zeros(num_valid_anchors, dtype=torch.float)
+        pos_inds = sampling_result.pos_inds
+        neg_inds = sampling_result.neg_inds
+        if len(pos_inds) > 0:
+            if self.reg_decoded_bbox:
+                pos_bbox_targets = sampling_result.pos_gt_bboxes
+            else:
+                pos_bbox_targets = self.bbox_coder.encode(
+                    sampling_result.pos_priors, sampling_result.pos_gt_bboxes)
+
+            bbox_targets[pos_inds, :] = pos_bbox_targets
+            bbox_weights[pos_inds, :] = 1.0
+
+            # ===== this change =====
+            labels[pos_inds] = gt_instances.positive_maps[
+                sampling_result.pos_assigned_gt_inds]
+            if self.train_cfg['pos_weight'] <= 0:
+                label_weights[pos_inds] = 1.0
+            else:
+                label_weights[pos_inds] = self.train_cfg['pos_weight']
+        if len(neg_inds) > 0:
+            label_weights[neg_inds] = 1.0
+
+        return (anchors, labels, label_weights, bbox_targets, bbox_weights,
+                pos_inds, neg_inds, sampling_result)
+
+    def centerness_target(self, anchors: Tensor, gts: Tensor) -> Tensor:
+        """Calculate the centerness between anchors and gts.
+
+        Only calculate pos centerness targets, otherwise there may be nan.
+
+        Args:
+            anchors (Tensor): Anchors with shape (N, 4), "xyxy" format.
+            gts (Tensor): Ground truth bboxes with shape (N, 4), "xyxy" format.
+
+        Returns:
+            Tensor: Centerness between anchors and gts.
+        """
+        anchors_cx = (anchors[:, 2] + anchors[:, 0]) / 2
+        anchors_cy = (anchors[:, 3] + anchors[:, 1]) / 2
+        l_ = anchors_cx - gts[:, 0]
+        t_ = anchors_cy - gts[:, 1]
+        r_ = gts[:, 2] - anchors_cx
+        b_ = gts[:, 3] - anchors_cy
+
+        left_right = torch.stack([l_, r_], dim=1)
+        top_bottom = torch.stack([t_, b_], dim=1)
+        centerness = torch.sqrt(
+            (left_right.min(dim=-1)[0] / left_right.max(dim=-1)[0]) *
+            (top_bottom.min(dim=-1)[0] / top_bottom.max(dim=-1)[0]))
+        # assert not torch.isnan(centerness).any()
+        return centerness
+
+    def predict(self,
+                visual_feats: Tuple[Tensor],
+                language_feats: dict,
+                batch_data_samples,
+                rescale: bool = True):
+        """Perform forward propagation of the detection head and predict
+        detection results on the features of the upstream network.
+
+        Args:
+            visual_feats (tuple[Tensor]): Multi-level visual features from the
+                upstream network, each is a 4D-tensor.
+            language_feats (dict): Language features from the upstream network.
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            rescale (bool, optional): Whether to rescale the results.
+                Defaults to False.
+
+        Returns:
+            list[obj:`InstanceData`]: Detection results of each image
+            after the post process.
+        """
+        batch_img_metas = [
+            data_samples.metainfo for data_samples in batch_data_samples
+        ]
+        batch_token_positive_maps = [
+            data_samples.token_positive_map
+            for data_samples in batch_data_samples
+        ]
+        outs = self(visual_feats, language_feats)
+
+        predictions = self.predict_by_feat(
+            *outs,
+            batch_img_metas=batch_img_metas,
+            batch_token_positive_maps=batch_token_positive_maps,
+            rescale=rescale)
+        return predictions
+
+    def predict_by_feat(self,
+                        cls_logits: List[Tensor],
+                        bbox_preds: List[Tensor],
+                        score_factors: List[Tensor],
+                        batch_img_metas: Optional[List[dict]] = None,
+                        batch_token_positive_maps: Optional[List[dict]] = None,
+                        cfg: Optional[ConfigDict] = None,
+                        rescale: bool = False,
+                        with_nms: bool = True) -> InstanceList:
+        """Transform a batch of output features extracted from the head into
+        bbox results.
+
+        Note: When score_factors is not None, the cls_scores are
+        usually multiplied by it then obtain the real score used in NMS,
+        such as CenterNess in FCOS, IoU branch in ATSS.
+
+        Args:
+            cls_logits (list[Tensor]): Classification scores for all
+                scale levels, each is a 4D-tensor, has shape
+                (batch_size, num_priors * num_classes, H, W).
+            bbox_preds (list[Tensor]): Box energies / deltas for all
+                scale levels, each is a 4D-tensor, has shape
+                (batch_size, num_priors * 4, H, W).
+            score_factors (list[Tensor], optional): Score factor for
+                all scale level, each is a 4D-tensor, has shape
+                (batch_size, num_priors * 1, H, W). Defaults to None.
+            batch_img_metas (list[dict], Optional): Batch image meta info.
+                Defaults to None.
+            batch_token_positive_maps (list[dict], Optional): Batch token
+                positive map. Defaults to None.
+            cfg (ConfigDict, optional): Test / postprocessing
+                configuration, if None, test_cfg would be used.
+                Defaults to None.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            with_nms (bool): If True, do nms before return boxes.
+                Defaults to True.
+
+        Returns:
+            list[:obj:`InstanceData`]: Object detection results of each image
+            after the post process. Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        assert len(bbox_preds) == len(score_factors)
+        num_levels = len(bbox_preds)
+
+        featmap_sizes = [bbox_preds[i].shape[-2:] for i in range(num_levels)]
+        mlvl_priors = self.prior_generator.grid_priors(
+            featmap_sizes,
+            dtype=bbox_preds[0].dtype,
+            device=bbox_preds[0].device)
+
+        result_list = []
+
+        for img_id in range(len(batch_img_metas)):
+            img_meta = batch_img_metas[img_id]
+            token_positive_maps = batch_token_positive_maps[img_id]
+            bbox_pred_list = select_single_mlvl(
+                bbox_preds, img_id, detach=True)
+            score_factor_list = select_single_mlvl(
+                score_factors, img_id, detach=True)
+            cls_logit_list = select_single_mlvl(
+                cls_logits, img_id, detach=True)
+
+            results = self._predict_by_feat_single(
+                bbox_pred_list=bbox_pred_list,
+                score_factor_list=score_factor_list,
+                cls_logit_list=cls_logit_list,
+                mlvl_priors=mlvl_priors,
+                token_positive_maps=token_positive_maps,
+                img_meta=img_meta,
+                cfg=cfg,
+                rescale=rescale,
+                with_nms=with_nms)
+            result_list.append(results)
+        return result_list
+
+    def _predict_by_feat_single(self,
+                                bbox_pred_list: List[Tensor],
+                                score_factor_list: List[Tensor],
+                                cls_logit_list: List[Tensor],
+                                mlvl_priors: List[Tensor],
+                                token_positive_maps: dict,
+                                img_meta: dict,
+                                cfg: ConfigDict,
+                                rescale: bool = True,
+                                with_nms: bool = True) -> InstanceData:
+        """Transform a single image's features extracted from the head into
+        bbox results.
+
+        Args:
+            bbox_pred_list (list[Tensor]): Box energies / deltas from
+                all scale levels of a single image, each item has shape
+                (num_priors * 4, H, W).
+            score_factor_list (list[Tensor]): Score factor from all scale
+                levels of a single image, each item has shape
+                (num_priors * 1, H, W).
+            cls_logit_list (list[Tensor]): Box scores from all scale
+                levels of a single image, each item has shape
+                (num_priors * num_classes, H, W).
+            mlvl_priors (list[Tensor]): Each element in the list is
+                the priors of a single level in feature pyramid. In all
+                anchor-based methods, it has shape (num_priors, 4). In
+                all anchor-free methods, it has shape (num_priors, 2)
+                when `with_stride=True`, otherwise it still has shape
+                (num_priors, 4).
+            token_positive_maps (dict): Token positive map.
+            img_meta (dict): Image meta info.
+            cfg (mmengine.Config): Test / postprocessing configuration,
+                if None, test_cfg would be used.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            with_nms (bool): If True, do nms before return boxes.
+                Defaults to True.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        cfg = self.test_cfg if cfg is None else cfg
+        cfg = copy.deepcopy(cfg)
+        img_shape = img_meta['img_shape']
+        nms_pre = cfg.get('nms_pre', -1)
+        score_thr = cfg.get('score_thr', 0)
+
+        mlvl_bbox_preds = []
+        mlvl_valid_priors = []
+        mlvl_scores = []
+        mlvl_labels = []
+
+        for level_idx, (bbox_pred, score_factor, cls_logit, priors) in \
+                enumerate(zip(bbox_pred_list,
+                              score_factor_list, cls_logit_list, mlvl_priors)):
+            bbox_pred = bbox_pred.permute(1, 2, 0).reshape(
+                -1, self.bbox_coder.encode_size)
+            score_factor = score_factor.permute(1, 2, 0).reshape(-1).sigmoid()
+
+            scores = convert_grounding_to_cls_scores(
+                logits=cls_logit.sigmoid()[None],
+                positive_maps=[token_positive_maps])[0]
+
+            results = filter_scores_and_topk(
+                scores, score_thr, nms_pre,
+                dict(bbox_pred=bbox_pred, priors=priors))
+
+            scores, labels, keep_idxs, filtered_results = results
+
+            bbox_pred = filtered_results['bbox_pred']
+            priors = filtered_results['priors']
+            score_factor = score_factor[keep_idxs]
+            scores = torch.sqrt(scores * score_factor)
+
+            mlvl_bbox_preds.append(bbox_pred)
+            mlvl_valid_priors.append(priors)
+            mlvl_scores.append(scores)
+            mlvl_labels.append(labels)
+
+        bbox_pred = torch.cat(mlvl_bbox_preds)
+        priors = cat_boxes(mlvl_valid_priors)
+        bboxes = self.bbox_coder.decode(priors, bbox_pred, max_shape=img_shape)
+
+        results = InstanceData()
+        results.bboxes = bboxes
+        results.scores = torch.cat(mlvl_scores)
+        results.labels = torch.cat(mlvl_labels)
+
+        predictions = self._bbox_post_process(
+            results=results,
+            cfg=cfg,
+            rescale=rescale,
+            with_nms=with_nms,
+            img_meta=img_meta)
+
+        if len(predictions) > 0:
+            # Note: GLIP adopts a very strange bbox decoder logic,
+            # and if 1 is not added here, it will not align with
+            # the official mAP.
+            predictions.bboxes[:, 2:] = predictions.bboxes[:, 2:] + 1
+        return predictions
diff --git a/mmdetection/mmdet/models/dense_heads/autoassign_head.py b/mmdetection/mmdet/models/dense_heads/autoassign_head.py
new file mode 100644
index 00000000..a2b30ff0
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/autoassign_head.py
@@ -0,0 +1,524 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, List, Sequence, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import Scale
+from mmengine.model import bias_init_with_prob, normal_init
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures.bbox import bbox_overlaps
+from mmdet.utils import InstanceList, OptInstanceList, reduce_mean
+from ..task_modules.prior_generators import MlvlPointGenerator
+from ..utils import levels_to_images, multi_apply
+from .fcos_head import FCOSHead
+
+EPS = 1e-12
+
+
+class CenterPrior(nn.Module):
+    """Center Weighting module to adjust the category-specific prior
+    distributions.
+
+    Args:
+        force_topk (bool): When no point falls into gt_bbox, forcibly
+            select the k points closest to the center to calculate
+            the center prior. Defaults to False.
+        topk (int): The number of points used to calculate the
+            center prior when no point falls in gt_bbox. Only work when
+            force_topk if True. Defaults to 9.
+        num_classes (int): The class number of dataset. Defaults to 80.
+        strides (Sequence[int]): The stride of each input feature map.
+            Defaults to (8, 16, 32, 64, 128).
+    """
+
+    def __init__(
+        self,
+        force_topk: bool = False,
+        topk: int = 9,
+        num_classes: int = 80,
+        strides: Sequence[int] = (8, 16, 32, 64, 128)
+    ) -> None:
+        super().__init__()
+        self.mean = nn.Parameter(torch.zeros(num_classes, 2))
+        self.sigma = nn.Parameter(torch.ones(num_classes, 2))
+        self.strides = strides
+        self.force_topk = force_topk
+        self.topk = topk
+
+    def forward(self, anchor_points_list: List[Tensor],
+                gt_instances: InstanceData,
+                inside_gt_bbox_mask: Tensor) -> Tuple[Tensor, Tensor]:
+        """Get the center prior of each point on the feature map for each
+        instance.
+
+        Args:
+            anchor_points_list (list[Tensor]): list of coordinate
+                of points on feature map. Each with shape
+                (num_points, 2).
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It should includes ``bboxes`` and ``labels``
+                attributes.
+            inside_gt_bbox_mask (Tensor): Tensor of bool type,
+                with shape of (num_points, num_gt), each
+                value is used to mark whether this point falls
+                within a certain gt.
+
+        Returns:
+            tuple[Tensor, Tensor]:
+
+            - center_prior_weights(Tensor): Float tensor with shape  of \
+            (num_points, num_gt). Each value represents the center \
+            weighting coefficient.
+            - inside_gt_bbox_mask (Tensor): Tensor of bool type, with shape \
+            of (num_points, num_gt), each value is used to mark whether this \
+            point falls within a certain gt or is the topk nearest points for \
+            a specific gt_bbox.
+        """
+        gt_bboxes = gt_instances.bboxes
+        labels = gt_instances.labels
+
+        inside_gt_bbox_mask = inside_gt_bbox_mask.clone()
+        num_gts = len(labels)
+        num_points = sum([len(item) for item in anchor_points_list])
+        if num_gts == 0:
+            return gt_bboxes.new_zeros(num_points,
+                                       num_gts), inside_gt_bbox_mask
+        center_prior_list = []
+        for slvl_points, stride in zip(anchor_points_list, self.strides):
+            # slvl_points: points from single level in FPN, has shape (h*w, 2)
+            # single_level_points has shape (h*w, num_gt, 2)
+            single_level_points = slvl_points[:, None, :].expand(
+                (slvl_points.size(0), len(gt_bboxes), 2))
+            gt_center_x = ((gt_bboxes[:, 0] + gt_bboxes[:, 2]) / 2)
+            gt_center_y = ((gt_bboxes[:, 1] + gt_bboxes[:, 3]) / 2)
+            gt_center = torch.stack((gt_center_x, gt_center_y), dim=1)
+            gt_center = gt_center[None]
+            # instance_center has shape (1, num_gt, 2)
+            instance_center = self.mean[labels][None]
+            # instance_sigma has shape (1, num_gt, 2)
+            instance_sigma = self.sigma[labels][None]
+            # distance has shape (num_points, num_gt, 2)
+            distance = (((single_level_points - gt_center) / float(stride) -
+                         instance_center)**2)
+            center_prior = torch.exp(-distance /
+                                     (2 * instance_sigma**2)).prod(dim=-1)
+            center_prior_list.append(center_prior)
+        center_prior_weights = torch.cat(center_prior_list, dim=0)
+
+        if self.force_topk:
+            gt_inds_no_points_inside = torch.nonzero(
+                inside_gt_bbox_mask.sum(0) == 0).reshape(-1)
+            if gt_inds_no_points_inside.numel():
+                topk_center_index = \
+                    center_prior_weights[:, gt_inds_no_points_inside].topk(
+                                                             self.topk,
+                                                             dim=0)[1]
+                temp_mask = inside_gt_bbox_mask[:, gt_inds_no_points_inside]
+                inside_gt_bbox_mask[:, gt_inds_no_points_inside] = \
+                    torch.scatter(temp_mask,
+                                  dim=0,
+                                  index=topk_center_index,
+                                  src=torch.ones_like(
+                                    topk_center_index,
+                                    dtype=torch.bool))
+
+        center_prior_weights[~inside_gt_bbox_mask] = 0
+        return center_prior_weights, inside_gt_bbox_mask
+
+
+@MODELS.register_module()
+class AutoAssignHead(FCOSHead):
+    """AutoAssignHead head used in AutoAssign.
+
+    More details can be found in the `paper
+    `_ .
+
+    Args:
+        force_topk (bool): Used in center prior initialization to
+            handle extremely small gt. Default is False.
+        topk (int): The number of points used to calculate the
+            center prior when no point falls in gt_bbox. Only work when
+            force_topk if True. Defaults to 9.
+        pos_loss_weight (float): The loss weight of positive loss
+            and with default value 0.25.
+        neg_loss_weight (float): The loss weight of negative loss
+            and with default value 0.75.
+        center_loss_weight (float): The loss weight of center prior
+            loss and with default value 0.75.
+    """
+
+    def __init__(self,
+                 *args,
+                 force_topk: bool = False,
+                 topk: int = 9,
+                 pos_loss_weight: float = 0.25,
+                 neg_loss_weight: float = 0.75,
+                 center_loss_weight: float = 0.75,
+                 **kwargs) -> None:
+        super().__init__(*args, conv_bias=True, **kwargs)
+        self.center_prior = CenterPrior(
+            force_topk=force_topk,
+            topk=topk,
+            num_classes=self.num_classes,
+            strides=self.strides)
+        self.pos_loss_weight = pos_loss_weight
+        self.neg_loss_weight = neg_loss_weight
+        self.center_loss_weight = center_loss_weight
+        self.prior_generator = MlvlPointGenerator(self.strides, offset=0)
+
+    def init_weights(self) -> None:
+        """Initialize weights of the head.
+
+        In particular, we have special initialization for classified conv's and
+        regression conv's bias
+        """
+
+        super(AutoAssignHead, self).init_weights()
+        bias_cls = bias_init_with_prob(0.02)
+        normal_init(self.conv_cls, std=0.01, bias=bias_cls)
+        normal_init(self.conv_reg, std=0.01, bias=4.0)
+
+    def forward_single(self, x: Tensor, scale: Scale,
+                       stride: int) -> Tuple[Tensor, Tensor, Tensor]:
+        """Forward features of a single scale level.
+
+        Args:
+            x (Tensor): FPN feature maps of the specified stride.
+            scale (:obj:`mmcv.cnn.Scale`): Learnable scale module to resize
+                the bbox prediction.
+            stride (int): The corresponding stride for feature maps, only
+                used to normalize the bbox prediction when self.norm_on_bbox
+                is True.
+
+        Returns:
+            tuple[Tensor, Tensor, Tensor]: scores for each class, bbox
+            predictions and centerness predictions of input feature maps.
+        """
+        cls_score, bbox_pred, cls_feat, reg_feat = super(
+            FCOSHead, self).forward_single(x)
+        centerness = self.conv_centerness(reg_feat)
+        # scale the bbox_pred of different level
+        # float to avoid overflow when enabling FP16
+        bbox_pred = scale(bbox_pred).float()
+        # bbox_pred needed for gradient computation has been modified
+        # by F.relu(bbox_pred) when run with PyTorch 1.10. So replace
+        # F.relu(bbox_pred) with bbox_pred.clamp(min=0)
+        bbox_pred = bbox_pred.clamp(min=0)
+        bbox_pred *= stride
+        return cls_score, bbox_pred, centerness
+
+    def get_pos_loss_single(self, cls_score: Tensor, objectness: Tensor,
+                            reg_loss: Tensor, gt_instances: InstanceData,
+                            center_prior_weights: Tensor) -> Tuple[Tensor]:
+        """Calculate the positive loss of all points in gt_bboxes.
+
+        Args:
+            cls_score (Tensor): All category scores for each point on
+                the feature map. The shape is (num_points, num_class).
+            objectness (Tensor): Foreground probability of all points,
+                has shape (num_points, 1).
+            reg_loss (Tensor): The regression loss of each gt_bbox and each
+                prediction box, has shape of (num_points, num_gt).
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It should includes ``bboxes`` and ``labels``
+                attributes.
+            center_prior_weights (Tensor): Float tensor with shape
+                of (num_points, num_gt). Each value represents
+                the center weighting coefficient.
+
+        Returns:
+            tuple[Tensor]:
+
+            - pos_loss (Tensor): The positive loss of all points in the \
+            gt_bboxes.
+        """
+        gt_labels = gt_instances.labels
+        # p_loc: localization confidence
+        p_loc = torch.exp(-reg_loss)
+        # p_cls: classification confidence
+        p_cls = (cls_score * objectness)[:, gt_labels]
+        # p_pos: joint confidence indicator
+        p_pos = p_cls * p_loc
+
+        # 3 is a hyper-parameter to control the contributions of high and
+        # low confidence locations towards positive losses.
+        confidence_weight = torch.exp(p_pos * 3)
+        p_pos_weight = (confidence_weight * center_prior_weights) / (
+            (confidence_weight * center_prior_weights).sum(
+                0, keepdim=True)).clamp(min=EPS)
+        reweighted_p_pos = (p_pos * p_pos_weight).sum(0)
+        pos_loss = F.binary_cross_entropy(
+            reweighted_p_pos,
+            torch.ones_like(reweighted_p_pos),
+            reduction='none')
+        pos_loss = pos_loss.sum() * self.pos_loss_weight
+        return pos_loss,
+
+    def get_neg_loss_single(self, cls_score: Tensor, objectness: Tensor,
+                            gt_instances: InstanceData, ious: Tensor,
+                            inside_gt_bbox_mask: Tensor) -> Tuple[Tensor]:
+        """Calculate the negative loss of all points in feature map.
+
+        Args:
+            cls_score (Tensor): All category scores for each point on
+                the feature map. The shape is (num_points, num_class).
+            objectness (Tensor): Foreground probability of all points
+                and is shape of (num_points, 1).
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It should includes ``bboxes`` and ``labels``
+                attributes.
+            ious (Tensor): Float tensor with shape of (num_points, num_gt).
+                Each value represent the iou of pred_bbox and gt_bboxes.
+            inside_gt_bbox_mask (Tensor): Tensor of bool type,
+                with shape of (num_points, num_gt), each
+                value is used to mark whether this point falls
+                within a certain gt.
+
+        Returns:
+            tuple[Tensor]:
+
+            - neg_loss (Tensor): The negative loss of all points in the \
+            feature map.
+        """
+        gt_labels = gt_instances.labels
+        num_gts = len(gt_labels)
+        joint_conf = (cls_score * objectness)
+        p_neg_weight = torch.ones_like(joint_conf)
+        if num_gts > 0:
+            # the order of dinmension would affect the value of
+            # p_neg_weight, we strictly follow the original
+            # implementation.
+            inside_gt_bbox_mask = inside_gt_bbox_mask.permute(1, 0)
+            ious = ious.permute(1, 0)
+
+            foreground_idxs = torch.nonzero(inside_gt_bbox_mask, as_tuple=True)
+            temp_weight = (1 / (1 - ious[foreground_idxs]).clamp_(EPS))
+
+            def normalize(x):
+                return (x - x.min() + EPS) / (x.max() - x.min() + EPS)
+
+            for instance_idx in range(num_gts):
+                idxs = foreground_idxs[0] == instance_idx
+                if idxs.any():
+                    temp_weight[idxs] = normalize(temp_weight[idxs])
+
+            p_neg_weight[foreground_idxs[1],
+                         gt_labels[foreground_idxs[0]]] = 1 - temp_weight
+
+        logits = (joint_conf * p_neg_weight)
+        neg_loss = (
+            logits**2 * F.binary_cross_entropy(
+                logits, torch.zeros_like(logits), reduction='none'))
+        neg_loss = neg_loss.sum() * self.neg_loss_weight
+        return neg_loss,
+
+    def loss_by_feat(
+        self,
+        cls_scores: List[Tensor],
+        bbox_preds: List[Tensor],
+        objectnesses: List[Tensor],
+        batch_gt_instances: InstanceList,
+        batch_img_metas: List[dict],
+        batch_gt_instances_ignore: OptInstanceList = None
+    ) -> Dict[str, Tensor]:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level,
+                each is a 4D-tensor, the channel number is
+                num_points * num_classes.
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level, each is a 4D-tensor, the channel number is
+                num_points * 4.
+            objectnesses (list[Tensor]): objectness for each scale level, each
+                is a 4D-tensor, the channel number is num_points * 1.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+
+        assert len(cls_scores) == len(bbox_preds) == len(objectnesses)
+        all_num_gt = sum([len(item) for item in batch_gt_instances])
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        all_level_points = self.prior_generator.grid_priors(
+            featmap_sizes,
+            dtype=bbox_preds[0].dtype,
+            device=bbox_preds[0].device)
+        inside_gt_bbox_mask_list, bbox_targets_list = self.get_targets(
+            all_level_points, batch_gt_instances)
+
+        center_prior_weight_list = []
+        temp_inside_gt_bbox_mask_list = []
+        for gt_instances, inside_gt_bbox_mask in zip(batch_gt_instances,
+                                                     inside_gt_bbox_mask_list):
+            center_prior_weight, inside_gt_bbox_mask = \
+                self.center_prior(all_level_points, gt_instances,
+                                  inside_gt_bbox_mask)
+            center_prior_weight_list.append(center_prior_weight)
+            temp_inside_gt_bbox_mask_list.append(inside_gt_bbox_mask)
+        inside_gt_bbox_mask_list = temp_inside_gt_bbox_mask_list
+        mlvl_points = torch.cat(all_level_points, dim=0)
+        bbox_preds = levels_to_images(bbox_preds)
+        cls_scores = levels_to_images(cls_scores)
+        objectnesses = levels_to_images(objectnesses)
+
+        reg_loss_list = []
+        ious_list = []
+        num_points = len(mlvl_points)
+
+        for bbox_pred, encoded_targets, inside_gt_bbox_mask in zip(
+                bbox_preds, bbox_targets_list, inside_gt_bbox_mask_list):
+            temp_num_gt = encoded_targets.size(1)
+            expand_mlvl_points = mlvl_points[:, None, :].expand(
+                num_points, temp_num_gt, 2).reshape(-1, 2)
+            encoded_targets = encoded_targets.reshape(-1, 4)
+            expand_bbox_pred = bbox_pred[:, None, :].expand(
+                num_points, temp_num_gt, 4).reshape(-1, 4)
+            decoded_bbox_preds = self.bbox_coder.decode(
+                expand_mlvl_points, expand_bbox_pred)
+            decoded_target_preds = self.bbox_coder.decode(
+                expand_mlvl_points, encoded_targets)
+            with torch.no_grad():
+                ious = bbox_overlaps(
+                    decoded_bbox_preds, decoded_target_preds, is_aligned=True)
+                ious = ious.reshape(num_points, temp_num_gt)
+                if temp_num_gt:
+                    ious = ious.max(
+                        dim=-1, keepdim=True).values.repeat(1, temp_num_gt)
+                else:
+                    ious = ious.new_zeros(num_points, temp_num_gt)
+                ious[~inside_gt_bbox_mask] = 0
+                ious_list.append(ious)
+            loss_bbox = self.loss_bbox(
+                decoded_bbox_preds,
+                decoded_target_preds,
+                weight=None,
+                reduction_override='none')
+            reg_loss_list.append(loss_bbox.reshape(num_points, temp_num_gt))
+
+        cls_scores = [item.sigmoid() for item in cls_scores]
+        objectnesses = [item.sigmoid() for item in objectnesses]
+        pos_loss_list, = multi_apply(self.get_pos_loss_single, cls_scores,
+                                     objectnesses, reg_loss_list,
+                                     batch_gt_instances,
+                                     center_prior_weight_list)
+        pos_avg_factor = reduce_mean(
+            bbox_pred.new_tensor(all_num_gt)).clamp_(min=1)
+        pos_loss = sum(pos_loss_list) / pos_avg_factor
+
+        neg_loss_list, = multi_apply(self.get_neg_loss_single, cls_scores,
+                                     objectnesses, batch_gt_instances,
+                                     ious_list, inside_gt_bbox_mask_list)
+        neg_avg_factor = sum(item.data.sum()
+                             for item in center_prior_weight_list)
+        neg_avg_factor = reduce_mean(neg_avg_factor).clamp_(min=1)
+        neg_loss = sum(neg_loss_list) / neg_avg_factor
+
+        center_loss = []
+        for i in range(len(batch_img_metas)):
+
+            if inside_gt_bbox_mask_list[i].any():
+                center_loss.append(
+                    len(batch_gt_instances[i]) /
+                    center_prior_weight_list[i].sum().clamp_(min=EPS))
+            # when width or height of gt_bbox is smaller than stride of p3
+            else:
+                center_loss.append(center_prior_weight_list[i].sum() * 0)
+
+        center_loss = torch.stack(center_loss).mean() * self.center_loss_weight
+
+        # avoid dead lock in DDP
+        if all_num_gt == 0:
+            pos_loss = bbox_preds[0].sum() * 0
+            dummy_center_prior_loss = self.center_prior.mean.sum(
+            ) * 0 + self.center_prior.sigma.sum() * 0
+            center_loss = objectnesses[0].sum() * 0 + dummy_center_prior_loss
+
+        loss = dict(
+            loss_pos=pos_loss, loss_neg=neg_loss, loss_center=center_loss)
+
+        return loss
+
+    def get_targets(
+            self, points: List[Tensor], batch_gt_instances: InstanceList
+    ) -> Tuple[List[Tensor], List[Tensor]]:
+        """Compute regression targets and each point inside or outside gt_bbox
+        in multiple images.
+
+        Args:
+            points (list[Tensor]): Points of all fpn level, each has shape
+                (num_points, 2).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+
+        Returns:
+            tuple(list[Tensor], list[Tensor]):
+
+            - inside_gt_bbox_mask_list (list[Tensor]): Each Tensor is with \
+            bool type and shape of (num_points, num_gt), each value is used \
+            to mark whether this point falls within a certain gt.
+            - concat_lvl_bbox_targets (list[Tensor]): BBox targets of each \
+            level. Each tensor has shape (num_points, num_gt, 4).
+        """
+
+        concat_points = torch.cat(points, dim=0)
+        # the number of points per img, per lvl
+        inside_gt_bbox_mask_list, bbox_targets_list = multi_apply(
+            self._get_targets_single, batch_gt_instances, points=concat_points)
+        return inside_gt_bbox_mask_list, bbox_targets_list
+
+    def _get_targets_single(self, gt_instances: InstanceData,
+                            points: Tensor) -> Tuple[Tensor, Tensor]:
+        """Compute regression targets and each point inside or outside gt_bbox
+        for a single image.
+
+        Args:
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It should includes ``bboxes`` and ``labels``
+                attributes.
+            points (Tensor): Points of all fpn level, has shape
+                (num_points, 2).
+
+        Returns:
+            tuple[Tensor, Tensor]: Containing the following Tensors:
+
+            - inside_gt_bbox_mask (Tensor): Bool tensor with shape \
+            (num_points, num_gt), each value is used to mark whether this \
+            point falls within a certain gt.
+            - bbox_targets (Tensor): BBox targets of each points with each \
+            gt_bboxes, has shape (num_points, num_gt, 4).
+        """
+        gt_bboxes = gt_instances.bboxes
+        num_points = points.size(0)
+        num_gts = gt_bboxes.size(0)
+        gt_bboxes = gt_bboxes[None].expand(num_points, num_gts, 4)
+        xs, ys = points[:, 0], points[:, 1]
+        xs = xs[:, None]
+        ys = ys[:, None]
+        left = xs - gt_bboxes[..., 0]
+        right = gt_bboxes[..., 2] - xs
+        top = ys - gt_bboxes[..., 1]
+        bottom = gt_bboxes[..., 3] - ys
+        bbox_targets = torch.stack((left, top, right, bottom), -1)
+        if num_gts:
+            inside_gt_bbox_mask = bbox_targets.min(-1)[0] > 0
+        else:
+            inside_gt_bbox_mask = bbox_targets.new_zeros((num_points, num_gts),
+                                                         dtype=torch.bool)
+
+        return inside_gt_bbox_mask, bbox_targets
diff --git a/mmdetection/mmdet/models/dense_heads/base_dense_head.py b/mmdetection/mmdet/models/dense_heads/base_dense_head.py
new file mode 100644
index 00000000..d0a4469e
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/base_dense_head.py
@@ -0,0 +1,583 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+from abc import ABCMeta, abstractmethod
+from inspect import signature
+from typing import List, Optional, Tuple
+
+import torch
+from mmcv.ops import batched_nms
+from mmengine.config import ConfigDict
+from mmengine.model import BaseModule, constant_init
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.structures import SampleList
+from mmdet.structures.bbox import (cat_boxes, get_box_tensor, get_box_wh,
+                                   scale_boxes)
+from mmdet.utils import InstanceList, OptMultiConfig
+from ..test_time_augs import merge_aug_results
+from ..utils import (filter_scores_and_topk, select_single_mlvl,
+                     unpack_gt_instances)
+
+
+class BaseDenseHead(BaseModule, metaclass=ABCMeta):
+    """Base class for DenseHeads.
+
+    1. The ``init_weights`` method is used to initialize densehead's
+    model parameters. After detector initialization, ``init_weights``
+    is triggered when ``detector.init_weights()`` is called externally.
+
+    2. The ``loss`` method is used to calculate the loss of densehead,
+    which includes two steps: (1) the densehead model performs forward
+    propagation to obtain the feature maps (2) The ``loss_by_feat`` method
+    is called based on the feature maps to calculate the loss.
+
+    .. code:: text
+
+    loss(): forward() -> loss_by_feat()
+
+    3. The ``predict`` method is used to predict detection results,
+    which includes two steps: (1) the densehead model performs forward
+    propagation to obtain the feature maps (2) The ``predict_by_feat`` method
+    is called based on the feature maps to predict detection results including
+    post-processing.
+
+    .. code:: text
+
+    predict(): forward() -> predict_by_feat()
+
+    4. The ``loss_and_predict`` method is used to return loss and detection
+    results at the same time. It will call densehead's ``forward``,
+    ``loss_by_feat`` and ``predict_by_feat`` methods in order.  If one-stage is
+    used as RPN, the densehead needs to return both losses and predictions.
+    This predictions is used as the proposal of roihead.
+
+    .. code:: text
+
+    loss_and_predict(): forward() -> loss_by_feat() -> predict_by_feat()
+    """
+
+    def __init__(self, init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(init_cfg=init_cfg)
+        # `_raw_positive_infos` will be used in `get_positive_infos`, which
+        # can get positive information.
+        self._raw_positive_infos = dict()
+
+    def init_weights(self) -> None:
+        """Initialize the weights."""
+        super().init_weights()
+        # avoid init_cfg overwrite the initialization of `conv_offset`
+        for m in self.modules():
+            # DeformConv2dPack, ModulatedDeformConv2dPack
+            if hasattr(m, 'conv_offset'):
+                constant_init(m.conv_offset, 0)
+
+    def get_positive_infos(self) -> InstanceList:
+        """Get positive information from sampling results.
+
+        Returns:
+            list[:obj:`InstanceData`]: Positive information of each image,
+            usually including positive bboxes, positive labels, positive
+            priors, etc.
+        """
+        if len(self._raw_positive_infos) == 0:
+            return None
+
+        sampling_results = self._raw_positive_infos.get(
+            'sampling_results', None)
+        assert sampling_results is not None
+        positive_infos = []
+        for sampling_result in enumerate(sampling_results):
+            pos_info = InstanceData()
+            pos_info.bboxes = sampling_result.pos_gt_bboxes
+            pos_info.labels = sampling_result.pos_gt_labels
+            pos_info.priors = sampling_result.pos_priors
+            pos_info.pos_assigned_gt_inds = \
+                sampling_result.pos_assigned_gt_inds
+            pos_info.pos_inds = sampling_result.pos_inds
+            positive_infos.append(pos_info)
+        return positive_infos
+
+    def loss(self, x: Tuple[Tensor], batch_data_samples: SampleList) -> dict:
+        """Perform forward propagation and loss calculation of the detection
+        head on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        outs = self(x)
+
+        outputs = unpack_gt_instances(batch_data_samples)
+        (batch_gt_instances, batch_gt_instances_ignore,
+         batch_img_metas) = outputs
+
+        loss_inputs = outs + (batch_gt_instances, batch_img_metas,
+                              batch_gt_instances_ignore)
+        losses = self.loss_by_feat(*loss_inputs)
+        return losses
+
+    @abstractmethod
+    def loss_by_feat(self, **kwargs) -> dict:
+        """Calculate the loss based on the features extracted by the detection
+        head."""
+        pass
+
+    def loss_and_predict(
+        self,
+        x: Tuple[Tensor],
+        batch_data_samples: SampleList,
+        proposal_cfg: Optional[ConfigDict] = None
+    ) -> Tuple[dict, InstanceList]:
+        """Perform forward propagation of the head, then calculate loss and
+        predictions from the features and data samples.
+
+        Args:
+            x (tuple[Tensor]): Features from FPN.
+            batch_data_samples (list[:obj:`DetDataSample`]): Each item contains
+                the meta information of each image and corresponding
+                annotations.
+            proposal_cfg (ConfigDict, optional): Test / postprocessing
+                configuration, if None, test_cfg would be used.
+                Defaults to None.
+
+        Returns:
+            tuple: the return value is a tuple contains:
+
+                - losses: (dict[str, Tensor]): A dictionary of loss components.
+                - predictions (list[:obj:`InstanceData`]): Detection
+                  results of each image after the post process.
+        """
+        outputs = unpack_gt_instances(batch_data_samples)
+        (batch_gt_instances, batch_gt_instances_ignore,
+         batch_img_metas) = outputs
+
+        outs = self(x)
+
+        loss_inputs = outs + (batch_gt_instances, batch_img_metas,
+                              batch_gt_instances_ignore)
+        losses = self.loss_by_feat(*loss_inputs)
+
+        predictions = self.predict_by_feat(
+            *outs, batch_img_metas=batch_img_metas, cfg=proposal_cfg)
+        return losses, predictions
+
+    def predict(self,
+                x: Tuple[Tensor],
+                batch_data_samples: SampleList,
+                rescale: bool = False) -> InstanceList:
+        """Perform forward propagation of the detection head and predict
+        detection results on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Multi-level features from the
+                upstream network, each is a 4D-tensor.
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            rescale (bool, optional): Whether to rescale the results.
+                Defaults to False.
+
+        Returns:
+            list[obj:`InstanceData`]: Detection results of each image
+            after the post process.
+        """
+        batch_img_metas = [
+            data_samples.metainfo for data_samples in batch_data_samples
+        ]
+
+        outs = self(x)
+
+        predictions = self.predict_by_feat(
+            *outs, batch_img_metas=batch_img_metas, rescale=rescale)
+        return predictions
+
+    def predict_by_feat(self,
+                        cls_scores: List[Tensor],
+                        bbox_preds: List[Tensor],
+                        score_factors: Optional[List[Tensor]] = None,
+                        batch_img_metas: Optional[List[dict]] = None,
+                        cfg: Optional[ConfigDict] = None,
+                        rescale: bool = False,
+                        with_nms: bool = True) -> InstanceList:
+        """Transform a batch of output features extracted from the head into
+        bbox results.
+
+        Note: When score_factors is not None, the cls_scores are
+        usually multiplied by it then obtain the real score used in NMS,
+        such as CenterNess in FCOS, IoU branch in ATSS.
+
+        Args:
+            cls_scores (list[Tensor]): Classification scores for all
+                scale levels, each is a 4D-tensor, has shape
+                (batch_size, num_priors * num_classes, H, W).
+            bbox_preds (list[Tensor]): Box energies / deltas for all
+                scale levels, each is a 4D-tensor, has shape
+                (batch_size, num_priors * 4, H, W).
+            score_factors (list[Tensor], optional): Score factor for
+                all scale level, each is a 4D-tensor, has shape
+                (batch_size, num_priors * 1, H, W). Defaults to None.
+            batch_img_metas (list[dict], Optional): Batch image meta info.
+                Defaults to None.
+            cfg (ConfigDict, optional): Test / postprocessing
+                configuration, if None, test_cfg would be used.
+                Defaults to None.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            with_nms (bool): If True, do nms before return boxes.
+                Defaults to True.
+
+        Returns:
+            list[:obj:`InstanceData`]: Object detection results of each image
+            after the post process. Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        assert len(cls_scores) == len(bbox_preds)
+
+        if score_factors is None:
+            # e.g. Retina, FreeAnchor, Foveabox, etc.
+            with_score_factors = False
+        else:
+            # e.g. FCOS, PAA, ATSS, AutoAssign, etc.
+            with_score_factors = True
+            assert len(cls_scores) == len(score_factors)
+
+        num_levels = len(cls_scores)
+
+        featmap_sizes = [cls_scores[i].shape[-2:] for i in range(num_levels)]
+        mlvl_priors = self.prior_generator.grid_priors(
+            featmap_sizes,
+            dtype=cls_scores[0].dtype,
+            device=cls_scores[0].device)
+
+        result_list = []
+
+        for img_id in range(len(batch_img_metas)):
+            img_meta = batch_img_metas[img_id]
+            cls_score_list = select_single_mlvl(
+                cls_scores, img_id, detach=True)
+            bbox_pred_list = select_single_mlvl(
+                bbox_preds, img_id, detach=True)
+            if with_score_factors:
+                score_factor_list = select_single_mlvl(
+                    score_factors, img_id, detach=True)
+            else:
+                score_factor_list = [None for _ in range(num_levels)]
+
+            results = self._predict_by_feat_single(
+                cls_score_list=cls_score_list,
+                bbox_pred_list=bbox_pred_list,
+                score_factor_list=score_factor_list,
+                mlvl_priors=mlvl_priors,
+                img_meta=img_meta,
+                cfg=cfg,
+                rescale=rescale,
+                with_nms=with_nms)
+            result_list.append(results)
+        return result_list
+
+    def _predict_by_feat_single(self,
+                                cls_score_list: List[Tensor],
+                                bbox_pred_list: List[Tensor],
+                                score_factor_list: List[Tensor],
+                                mlvl_priors: List[Tensor],
+                                img_meta: dict,
+                                cfg: ConfigDict,
+                                rescale: bool = False,
+                                with_nms: bool = True) -> InstanceData:
+        """Transform a single image's features extracted from the head into
+        bbox results.
+
+        Args:
+            cls_score_list (list[Tensor]): Box scores from all scale
+                levels of a single image, each item has shape
+                (num_priors * num_classes, H, W).
+            bbox_pred_list (list[Tensor]): Box energies / deltas from
+                all scale levels of a single image, each item has shape
+                (num_priors * 4, H, W).
+            score_factor_list (list[Tensor]): Score factor from all scale
+                levels of a single image, each item has shape
+                (num_priors * 1, H, W).
+            mlvl_priors (list[Tensor]): Each element in the list is
+                the priors of a single level in feature pyramid. In all
+                anchor-based methods, it has shape (num_priors, 4). In
+                all anchor-free methods, it has shape (num_priors, 2)
+                when `with_stride=True`, otherwise it still has shape
+                (num_priors, 4).
+            img_meta (dict): Image meta info.
+            cfg (mmengine.Config): Test / postprocessing configuration,
+                if None, test_cfg would be used.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            with_nms (bool): If True, do nms before return boxes.
+                Defaults to True.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        if score_factor_list[0] is None:
+            # e.g. Retina, FreeAnchor, etc.
+            with_score_factors = False
+        else:
+            # e.g. FCOS, PAA, ATSS, etc.
+            with_score_factors = True
+
+        cfg = self.test_cfg if cfg is None else cfg
+        cfg = copy.deepcopy(cfg)
+        img_shape = img_meta['img_shape']
+        nms_pre = cfg.get('nms_pre', -1)
+
+        mlvl_bbox_preds = []
+        mlvl_valid_priors = []
+        mlvl_scores = []
+        mlvl_labels = []
+        if with_score_factors:
+            mlvl_score_factors = []
+        else:
+            mlvl_score_factors = None
+        for level_idx, (cls_score, bbox_pred, score_factor, priors) in \
+                enumerate(zip(cls_score_list, bbox_pred_list,
+                              score_factor_list, mlvl_priors)):
+
+            assert cls_score.size()[-2:] == bbox_pred.size()[-2:]
+
+            dim = self.bbox_coder.encode_size
+            bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, dim)
+            if with_score_factors:
+                score_factor = score_factor.permute(1, 2,
+                                                    0).reshape(-1).sigmoid()
+            cls_score = cls_score.permute(1, 2,
+                                          0).reshape(-1, self.cls_out_channels)
+
+            # the `custom_cls_channels` parameter is derived from
+            # CrossEntropyCustomLoss and FocalCustomLoss, and is currently used
+            # in v3det.
+            if getattr(self.loss_cls, 'custom_cls_channels', False):
+                scores = self.loss_cls.get_activation(cls_score)
+            elif self.use_sigmoid_cls:
+                scores = cls_score.sigmoid()
+            else:
+                # remind that we set FG labels to [0, num_class-1]
+                # since mmdet v2.0
+                # BG cat_id: num_class
+                scores = cls_score.softmax(-1)[:, :-1]
+
+            # After https://github.com/open-mmlab/mmdetection/pull/6268/,
+            # this operation keeps fewer bboxes under the same `nms_pre`.
+            # There is no difference in performance for most models. If you
+            # find a slight drop in performance, you can set a larger
+            # `nms_pre` than before.
+            score_thr = cfg.get('score_thr', 0)
+
+            results = filter_scores_and_topk(
+                scores, score_thr, nms_pre,
+                dict(bbox_pred=bbox_pred, priors=priors))
+            scores, labels, keep_idxs, filtered_results = results
+
+            bbox_pred = filtered_results['bbox_pred']
+            priors = filtered_results['priors']
+
+            if with_score_factors:
+                score_factor = score_factor[keep_idxs]
+
+            mlvl_bbox_preds.append(bbox_pred)
+            mlvl_valid_priors.append(priors)
+            mlvl_scores.append(scores)
+            mlvl_labels.append(labels)
+
+            if with_score_factors:
+                mlvl_score_factors.append(score_factor)
+
+        bbox_pred = torch.cat(mlvl_bbox_preds)
+        priors = cat_boxes(mlvl_valid_priors)
+        bboxes = self.bbox_coder.decode(priors, bbox_pred, max_shape=img_shape)
+
+        results = InstanceData()
+        results.bboxes = bboxes
+        results.scores = torch.cat(mlvl_scores)
+        results.labels = torch.cat(mlvl_labels)
+        if with_score_factors:
+            results.score_factors = torch.cat(mlvl_score_factors)
+
+        return self._bbox_post_process(
+            results=results,
+            cfg=cfg,
+            rescale=rescale,
+            with_nms=with_nms,
+            img_meta=img_meta)
+
+    def _bbox_post_process(self,
+                           results: InstanceData,
+                           cfg: ConfigDict,
+                           rescale: bool = False,
+                           with_nms: bool = True,
+                           img_meta: Optional[dict] = None) -> InstanceData:
+        """bbox post-processing method.
+
+        The boxes would be rescaled to the original image scale and do
+        the nms operation. Usually `with_nms` is False is used for aug test.
+
+        Args:
+            results (:obj:`InstaceData`): Detection instance results,
+                each item has shape (num_bboxes, ).
+            cfg (ConfigDict): Test / postprocessing configuration,
+                if None, test_cfg would be used.
+            rescale (bool): If True, return boxes in original image space.
+                Default to False.
+            with_nms (bool): If True, do nms before return boxes.
+                Default to True.
+            img_meta (dict, optional): Image meta info. Defaults to None.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        if rescale:
+            assert img_meta.get('scale_factor') is not None
+            scale_factor = [1 / s for s in img_meta['scale_factor']]
+            results.bboxes = scale_boxes(results.bboxes, scale_factor)
+
+        if hasattr(results, 'score_factors'):
+            # TODO: Add sqrt operation in order to be consistent with
+            #  the paper.
+            score_factors = results.pop('score_factors')
+            results.scores = results.scores * score_factors
+
+        # filter small size bboxes
+        if cfg.get('min_bbox_size', -1) >= 0:
+            w, h = get_box_wh(results.bboxes)
+            valid_mask = (w > cfg.min_bbox_size) & (h > cfg.min_bbox_size)
+            if not valid_mask.all():
+                results = results[valid_mask]
+
+        # TODO: deal with `with_nms` and `nms_cfg=None` in test_cfg
+        if with_nms and results.bboxes.numel() > 0:
+            bboxes = get_box_tensor(results.bboxes)
+            det_bboxes, keep_idxs = batched_nms(bboxes, results.scores,
+                                                results.labels, cfg.nms)
+            results = results[keep_idxs]
+            # some nms would reweight the score, such as softnms
+            results.scores = det_bboxes[:, -1]
+            results = results[:cfg.max_per_img]
+
+        return results
+
+    def aug_test(self,
+                 aug_batch_feats,
+                 aug_batch_img_metas,
+                 rescale=False,
+                 with_ori_nms=False,
+                 **kwargs):
+        """Test function with test time augmentation.
+
+        Args:
+            aug_batch_feats (list[tuple[Tensor]]): The outer list
+                indicates test-time augmentations and inner tuple
+                indicate the multi-level feats from
+                FPN, each Tensor should have a shape (B, C, H, W),
+            aug_batch_img_metas (list[list[dict]]): Meta information
+                of images under the different test-time augs
+                (multiscale, flip, etc.). The outer list indicate
+                the
+            rescale (bool, optional): Whether to rescale the results.
+                Defaults to False.
+            with_ori_nms (bool): Whether execute the nms in original head.
+                Defaults to False. It will be `True` when the head is
+                adopted as `rpn_head`.
+
+        Returns:
+            list(obj:`InstanceData`): Detection results of the
+            input images. Each item usually contains\
+            following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance,)
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances,).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        # TODO: remove this for detr and deformdetr
+        sig_of_get_results = signature(self.get_results)
+        get_results_args = [
+            p.name for p in sig_of_get_results.parameters.values()
+        ]
+        get_results_single_sig = signature(self._get_results_single)
+        get_results_single_sig_args = [
+            p.name for p in get_results_single_sig.parameters.values()
+        ]
+        assert ('with_nms' in get_results_args) and \
+               ('with_nms' in get_results_single_sig_args), \
+               f'{self.__class__.__name__}' \
+               'does not support test-time augmentation '
+
+        num_imgs = len(aug_batch_img_metas[0])
+        aug_batch_results = []
+        for x, img_metas in zip(aug_batch_feats, aug_batch_img_metas):
+            outs = self.forward(x)
+            batch_instance_results = self.get_results(
+                *outs,
+                img_metas=img_metas,
+                cfg=self.test_cfg,
+                rescale=False,
+                with_nms=with_ori_nms,
+                **kwargs)
+            aug_batch_results.append(batch_instance_results)
+
+        # after merging, bboxes will be rescaled to the original image
+        batch_results = merge_aug_results(aug_batch_results,
+                                          aug_batch_img_metas)
+
+        final_results = []
+        for img_id in range(num_imgs):
+            results = batch_results[img_id]
+            det_bboxes, keep_idxs = batched_nms(results.bboxes, results.scores,
+                                                results.labels,
+                                                self.test_cfg.nms)
+            results = results[keep_idxs]
+            # some nms operation may reweight the score such as softnms
+            results.scores = det_bboxes[:, -1]
+            results = results[:self.test_cfg.max_per_img]
+            if rescale:
+                # all results have been mapped to the original scale
+                # in `merge_aug_results`, so just pass
+                pass
+            else:
+                # map to the first aug image scale
+                scale_factor = results.bboxes.new_tensor(
+                    aug_batch_img_metas[0][img_id]['scale_factor'])
+                results.bboxes = \
+                    results.bboxes * scale_factor
+
+            final_results.append(results)
+
+        return final_results
diff --git a/mmdetection/mmdet/models/dense_heads/base_mask_head.py b/mmdetection/mmdet/models/dense_heads/base_mask_head.py
new file mode 100644
index 00000000..7183d782
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/base_mask_head.py
@@ -0,0 +1,128 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from abc import ABCMeta, abstractmethod
+from typing import List, Tuple, Union
+
+from mmengine.model import BaseModule
+from torch import Tensor
+
+from mmdet.structures import SampleList
+from mmdet.utils import InstanceList, OptInstanceList, OptMultiConfig
+from ..utils import unpack_gt_instances
+
+
+class BaseMaskHead(BaseModule, metaclass=ABCMeta):
+    """Base class for mask heads used in One-Stage Instance Segmentation."""
+
+    def __init__(self, init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(init_cfg=init_cfg)
+
+    @abstractmethod
+    def loss_by_feat(self, *args, **kwargs):
+        """Calculate the loss based on the features extracted by the mask
+        head."""
+        pass
+
+    @abstractmethod
+    def predict_by_feat(self, *args, **kwargs):
+        """Transform a batch of output features extracted from the head into
+        mask results."""
+        pass
+
+    def loss(self,
+             x: Union[List[Tensor], Tuple[Tensor]],
+             batch_data_samples: SampleList,
+             positive_infos: OptInstanceList = None,
+             **kwargs) -> dict:
+        """Perform forward propagation and loss calculation of the mask head on
+        the features of the upstream network.
+
+        Args:
+            x (list[Tensor] | tuple[Tensor]): Features from FPN.
+                Each has a shape (B, C, H, W).
+            batch_data_samples (list[:obj:`DetDataSample`]): Each item contains
+                the meta information of each image and corresponding
+                annotations.
+            positive_infos (list[:obj:`InstanceData`], optional): Information
+                of positive samples. Used when the label assignment is
+                done outside the MaskHead, e.g., BboxHead in
+                YOLACT or CondInst, etc. When the label assignment is done in
+                MaskHead, it would be None, like SOLO or SOLOv2. All values
+                in it should have shape (num_positive_samples, *).
+
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        if positive_infos is None:
+            outs = self(x)
+        else:
+            outs = self(x, positive_infos)
+
+        assert isinstance(outs, tuple), 'Forward results should be a tuple, ' \
+                                        'even if only one item is returned'
+
+        outputs = unpack_gt_instances(batch_data_samples)
+        batch_gt_instances, batch_gt_instances_ignore, batch_img_metas \
+            = outputs
+        for gt_instances, img_metas in zip(batch_gt_instances,
+                                           batch_img_metas):
+            img_shape = img_metas['batch_input_shape']
+            gt_masks = gt_instances.masks.pad(img_shape)
+            gt_instances.masks = gt_masks
+
+        losses = self.loss_by_feat(
+            *outs,
+            batch_gt_instances=batch_gt_instances,
+            batch_img_metas=batch_img_metas,
+            positive_infos=positive_infos,
+            batch_gt_instances_ignore=batch_gt_instances_ignore,
+            **kwargs)
+        return losses
+
+    def predict(self,
+                x: Tuple[Tensor],
+                batch_data_samples: SampleList,
+                rescale: bool = False,
+                results_list: OptInstanceList = None,
+                **kwargs) -> InstanceList:
+        """Test function without test-time augmentation.
+
+        Args:
+            x (tuple[Tensor]): Multi-level features from the
+                upstream network, each is a 4D-tensor.
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            rescale (bool, optional): Whether to rescale the results.
+                Defaults to False.
+            results_list (list[obj:`InstanceData`], optional): Detection
+                results of each image after the post process. Only exist
+                if there is a `bbox_head`, like `YOLACT`, `CondInst`, etc.
+
+        Returns:
+            list[obj:`InstanceData`]: Instance segmentation
+            results of each image after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance,)
+                - labels (Tensor): Has a shape (num_instances,).
+                - masks (Tensor): Processed mask results, has a
+                  shape (num_instances, h, w).
+        """
+        batch_img_metas = [
+            data_samples.metainfo for data_samples in batch_data_samples
+        ]
+        if results_list is None:
+            outs = self(x)
+        else:
+            outs = self(x, results_list)
+
+        results_list = self.predict_by_feat(
+            *outs,
+            batch_img_metas=batch_img_metas,
+            rescale=rescale,
+            results_list=results_list,
+            **kwargs)
+
+        return results_list
diff --git a/mmdetection/mmdet/models/dense_heads/boxinst_head.py b/mmdetection/mmdet/models/dense_heads/boxinst_head.py
new file mode 100644
index 00000000..7d6e8f77
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/boxinst_head.py
@@ -0,0 +1,252 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List
+
+import torch
+import torch.nn.functional as F
+from mmengine import MessageHub
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import InstanceList
+from ..utils.misc import unfold_wo_center
+from .condinst_head import CondInstBboxHead, CondInstMaskHead
+
+
+@MODELS.register_module()
+class BoxInstBboxHead(CondInstBboxHead):
+    """BoxInst box head used in https://arxiv.org/abs/2012.02310."""
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+
+@MODELS.register_module()
+class BoxInstMaskHead(CondInstMaskHead):
+    """BoxInst mask head used in https://arxiv.org/abs/2012.02310.
+
+    This head outputs the mask for BoxInst.
+
+    Args:
+        pairwise_size (dict): The size of neighborhood for each pixel.
+            Defaults to 3.
+        pairwise_dilation (int): The dilation of neighborhood for each pixel.
+            Defaults to 2.
+        warmup_iters (int): Warmup iterations for pair-wise loss.
+            Defaults to 10000.
+    """
+
+    def __init__(self,
+                 *arg,
+                 pairwise_size: int = 3,
+                 pairwise_dilation: int = 2,
+                 warmup_iters: int = 10000,
+                 **kwargs) -> None:
+        self.pairwise_size = pairwise_size
+        self.pairwise_dilation = pairwise_dilation
+        self.warmup_iters = warmup_iters
+        super().__init__(*arg, **kwargs)
+
+    def get_pairwise_affinity(self, mask_logits: Tensor) -> Tensor:
+        """Compute the pairwise affinity for each pixel."""
+        log_fg_prob = F.logsigmoid(mask_logits).unsqueeze(1)
+        log_bg_prob = F.logsigmoid(-mask_logits).unsqueeze(1)
+
+        log_fg_prob_unfold = unfold_wo_center(
+            log_fg_prob,
+            kernel_size=self.pairwise_size,
+            dilation=self.pairwise_dilation)
+        log_bg_prob_unfold = unfold_wo_center(
+            log_bg_prob,
+            kernel_size=self.pairwise_size,
+            dilation=self.pairwise_dilation)
+
+        # the probability of making the same prediction:
+        # p_i * p_j + (1 - p_i) * (1 - p_j)
+        # we compute the the probability in log space
+        # to avoid numerical instability
+        log_same_fg_prob = log_fg_prob[:, :, None] + log_fg_prob_unfold
+        log_same_bg_prob = log_bg_prob[:, :, None] + log_bg_prob_unfold
+
+        # TODO: Figure out the difference between it and directly sum
+        max_ = torch.max(log_same_fg_prob, log_same_bg_prob)
+        log_same_prob = torch.log(
+            torch.exp(log_same_fg_prob - max_) +
+            torch.exp(log_same_bg_prob - max_)) + max_
+
+        return -log_same_prob[:, 0]
+
+    def loss_by_feat(self, mask_preds: List[Tensor],
+                     batch_gt_instances: InstanceList,
+                     batch_img_metas: List[dict], positive_infos: InstanceList,
+                     **kwargs) -> dict:
+        """Calculate the loss based on the features extracted by the mask head.
+
+        Args:
+            mask_preds (list[Tensor]): List of predicted masks, each has
+                shape (num_classes, H, W).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes``, ``masks``,
+                and ``labels`` attributes.
+            batch_img_metas (list[dict]): Meta information of multiple images.
+            positive_infos (List[:obj:``InstanceData``]): Information of
+                positive samples of each image that are assigned in detection
+                head.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        assert positive_infos is not None, \
+            'positive_infos should not be None in `BoxInstMaskHead`'
+        losses = dict()
+
+        loss_mask_project = 0.
+        loss_mask_pairwise = 0.
+        num_imgs = len(mask_preds)
+        total_pos = 0.
+        avg_fatcor = 0.
+
+        for idx in range(num_imgs):
+            (mask_pred, pos_mask_targets, pos_pairwise_masks, num_pos) = \
+                self._get_targets_single(
+                mask_preds[idx], batch_gt_instances[idx],
+                positive_infos[idx])
+            # mask loss
+            total_pos += num_pos
+            if num_pos == 0 or pos_mask_targets is None:
+                loss_project = mask_pred.new_zeros(1).mean()
+                loss_pairwise = mask_pred.new_zeros(1).mean()
+                avg_fatcor += 0.
+            else:
+                # compute the project term
+                loss_project_x = self.loss_mask(
+                    mask_pred.max(dim=1, keepdim=True)[0],
+                    pos_mask_targets.max(dim=1, keepdim=True)[0],
+                    reduction_override='none').sum()
+                loss_project_y = self.loss_mask(
+                    mask_pred.max(dim=2, keepdim=True)[0],
+                    pos_mask_targets.max(dim=2, keepdim=True)[0],
+                    reduction_override='none').sum()
+                loss_project = loss_project_x + loss_project_y
+                # compute the pairwise term
+                pairwise_affinity = self.get_pairwise_affinity(mask_pred)
+                avg_fatcor += pos_pairwise_masks.sum().clamp(min=1.0)
+                loss_pairwise = (pairwise_affinity * pos_pairwise_masks).sum()
+
+            loss_mask_project += loss_project
+            loss_mask_pairwise += loss_pairwise
+
+        if total_pos == 0:
+            total_pos += 1  # avoid nan
+        if avg_fatcor == 0:
+            avg_fatcor += 1  # avoid nan
+        loss_mask_project = loss_mask_project / total_pos
+        loss_mask_pairwise = loss_mask_pairwise / avg_fatcor
+        message_hub = MessageHub.get_current_instance()
+        iter = message_hub.get_info('iter')
+        warmup_factor = min(iter / float(self.warmup_iters), 1.0)
+        loss_mask_pairwise *= warmup_factor
+
+        losses.update(
+            loss_mask_project=loss_mask_project,
+            loss_mask_pairwise=loss_mask_pairwise)
+        return losses
+
+    def _get_targets_single(self, mask_preds: Tensor,
+                            gt_instances: InstanceData,
+                            positive_info: InstanceData):
+        """Compute targets for predictions of single image.
+
+        Args:
+            mask_preds (Tensor): Predicted prototypes with shape
+                (num_classes, H, W).
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It should includes ``bboxes``, ``labels``,
+                and ``masks`` attributes.
+            positive_info (:obj:`InstanceData`): Information of positive
+                samples that are assigned in detection head. It usually
+                contains following keys.
+
+                    - pos_assigned_gt_inds (Tensor): Assigner GT indexes of
+                      positive proposals, has shape (num_pos, )
+                    - pos_inds (Tensor): Positive index of image, has
+                      shape (num_pos, ).
+                    - param_pred (Tensor): Positive param preditions
+                      with shape (num_pos, num_params).
+
+        Returns:
+            tuple: Usually returns a tuple containing learning targets.
+
+            - mask_preds (Tensor): Positive predicted mask with shape
+              (num_pos, mask_h, mask_w).
+            - pos_mask_targets (Tensor): Positive mask targets with shape
+              (num_pos, mask_h, mask_w).
+            - pos_pairwise_masks (Tensor): Positive pairwise masks with
+              shape: (num_pos, num_neighborhood, mask_h, mask_w).
+            - num_pos (int): Positive numbers.
+        """
+        gt_bboxes = gt_instances.bboxes
+        device = gt_bboxes.device
+        # Note that gt_masks are generated by full box
+        # from BoxInstDataPreprocessor
+        gt_masks = gt_instances.masks.to_tensor(
+            dtype=torch.bool, device=device).float()
+        # Note that pairwise_masks are generated by image color similarity
+        # from BoxInstDataPreprocessor
+        pairwise_masks = gt_instances.pairwise_masks
+        pairwise_masks = pairwise_masks.to(device=device)
+
+        # process with mask targets
+        pos_assigned_gt_inds = positive_info.get('pos_assigned_gt_inds')
+        scores = positive_info.get('scores')
+        centernesses = positive_info.get('centernesses')
+        num_pos = pos_assigned_gt_inds.size(0)
+
+        if gt_masks.size(0) == 0 or num_pos == 0:
+            return mask_preds, None, None, 0
+        # Since we're producing (near) full image masks,
+        # it'd take too much vram to backprop on every single mask.
+        # Thus we select only a subset.
+        if (self.max_masks_to_train != -1) and \
+           (num_pos > self.max_masks_to_train):
+            perm = torch.randperm(num_pos)
+            select = perm[:self.max_masks_to_train]
+            mask_preds = mask_preds[select]
+            pos_assigned_gt_inds = pos_assigned_gt_inds[select]
+            num_pos = self.max_masks_to_train
+        elif self.topk_masks_per_img != -1:
+            unique_gt_inds = pos_assigned_gt_inds.unique()
+            num_inst_per_gt = max(
+                int(self.topk_masks_per_img / len(unique_gt_inds)), 1)
+
+            keep_mask_preds = []
+            keep_pos_assigned_gt_inds = []
+            for gt_ind in unique_gt_inds:
+                per_inst_pos_inds = (pos_assigned_gt_inds == gt_ind)
+                mask_preds_per_inst = mask_preds[per_inst_pos_inds]
+                gt_inds_per_inst = pos_assigned_gt_inds[per_inst_pos_inds]
+                if sum(per_inst_pos_inds) > num_inst_per_gt:
+                    per_inst_scores = scores[per_inst_pos_inds].sigmoid().max(
+                        dim=1)[0]
+                    per_inst_centerness = centernesses[
+                        per_inst_pos_inds].sigmoid().reshape(-1, )
+                    select = (per_inst_scores * per_inst_centerness).topk(
+                        k=num_inst_per_gt, dim=0)[1]
+                    mask_preds_per_inst = mask_preds_per_inst[select]
+                    gt_inds_per_inst = gt_inds_per_inst[select]
+                keep_mask_preds.append(mask_preds_per_inst)
+                keep_pos_assigned_gt_inds.append(gt_inds_per_inst)
+            mask_preds = torch.cat(keep_mask_preds)
+            pos_assigned_gt_inds = torch.cat(keep_pos_assigned_gt_inds)
+            num_pos = pos_assigned_gt_inds.size(0)
+
+        # Follow the origin implement
+        start = int(self.mask_out_stride // 2)
+        gt_masks = gt_masks[:, start::self.mask_out_stride,
+                            start::self.mask_out_stride]
+        gt_masks = gt_masks.gt(0.5).float()
+        pos_mask_targets = gt_masks[pos_assigned_gt_inds]
+        pos_pairwise_masks = pairwise_masks[pos_assigned_gt_inds]
+        pos_pairwise_masks = pos_pairwise_masks * pos_mask_targets.unsqueeze(1)
+
+        return (mask_preds, pos_mask_targets, pos_pairwise_masks, num_pos)
diff --git a/mmdetection/mmdet/models/dense_heads/cascade_rpn_head.py b/mmdetection/mmdet/models/dense_heads/cascade_rpn_head.py
new file mode 100644
index 00000000..a8686cc2
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/cascade_rpn_head.py
@@ -0,0 +1,1110 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from __future__ import division
+import copy
+from typing import Dict, List, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+from mmcv.ops import DeformConv2d
+from mmengine.config import ConfigDict
+from mmengine.model import BaseModule, ModuleList
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.structures import SampleList
+from mmdet.utils import (ConfigType, InstanceList, MultiConfig,
+                         OptInstanceList, OptMultiConfig)
+from ..task_modules.assigners import RegionAssigner
+from ..task_modules.samplers import PseudoSampler
+from ..utils import (images_to_levels, multi_apply, select_single_mlvl,
+                     unpack_gt_instances)
+from .base_dense_head import BaseDenseHead
+from .rpn_head import RPNHead
+
+
+class AdaptiveConv(BaseModule):
+    """AdaptiveConv used to adapt the sampling location with the anchors.
+
+    Args:
+        in_channels (int): Number of channels in the input image.
+        out_channels (int): Number of channels produced by the convolution.
+        kernel_size (int or tuple[int]): Size of the conv kernel.
+            Defaults to 3.
+        stride (int or tuple[int]): Stride of the convolution. Defaults to 1.
+        padding (int or tuple[int]): Zero-padding added to both sides of
+            the input. Defaults to 1.
+        dilation (int or tuple[int]): Spacing between kernel elements.
+            Defaults to 3.
+        groups (int): Number of blocked connections from input channels to
+            output channels. Defaults to 1.
+        bias (bool): If set True, adds a learnable bias to the output.
+            Defaults to False.
+        adapt_type (str): Type of adaptive conv, can be either ``offset``
+            (arbitrary anchors) or 'dilation' (uniform anchor).
+            Defaults to 'dilation'.
+        init_cfg (:obj:`ConfigDict` or list[:obj:`ConfigDict`] or dict or \
+            list[dict]): Initialization config dict.
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel_size: Union[int, Tuple[int]] = 3,
+        stride: Union[int, Tuple[int]] = 1,
+        padding: Union[int, Tuple[int]] = 1,
+        dilation: Union[int, Tuple[int]] = 3,
+        groups: int = 1,
+        bias: bool = False,
+        adapt_type: str = 'dilation',
+        init_cfg: MultiConfig = dict(
+            type='Normal', std=0.01, override=dict(name='conv'))
+    ) -> None:
+        super().__init__(init_cfg=init_cfg)
+        assert adapt_type in ['offset', 'dilation']
+        self.adapt_type = adapt_type
+
+        assert kernel_size == 3, 'Adaptive conv only supports kernels 3'
+        if self.adapt_type == 'offset':
+            assert stride == 1 and padding == 1 and groups == 1, \
+                'Adaptive conv offset mode only supports padding: {1}, ' \
+                f'stride: {1}, groups: {1}'
+            self.conv = DeformConv2d(
+                in_channels,
+                out_channels,
+                kernel_size,
+                padding=padding,
+                stride=stride,
+                groups=groups,
+                bias=bias)
+        else:
+            self.conv = nn.Conv2d(
+                in_channels,
+                out_channels,
+                kernel_size,
+                padding=dilation,
+                dilation=dilation)
+
+    def forward(self, x: Tensor, offset: Tensor) -> Tensor:
+        """Forward function."""
+        if self.adapt_type == 'offset':
+            N, _, H, W = x.shape
+            assert offset is not None
+            assert H * W == offset.shape[1]
+            # reshape [N, NA, 18] to (N, 18, H, W)
+            offset = offset.permute(0, 2, 1).reshape(N, -1, H, W)
+            offset = offset.contiguous()
+            x = self.conv(x, offset)
+        else:
+            assert offset is None
+            x = self.conv(x)
+        return x
+
+
+@MODELS.register_module()
+class StageCascadeRPNHead(RPNHead):
+    """Stage of CascadeRPNHead.
+
+    Args:
+        in_channels (int): Number of channels in the input feature map.
+        anchor_generator (:obj:`ConfigDict` or dict): anchor generator config.
+        adapt_cfg (:obj:`ConfigDict` or dict): adaptation config.
+        bridged_feature (bool): whether update rpn feature. Defaults to False.
+        with_cls (bool): whether use classification branch. Defaults to True.
+        init_cfg :obj:`ConfigDict` or list[:obj:`ConfigDict`] or dict or
+            list[dict], optional): Initialization config dict.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 in_channels: int,
+                 anchor_generator: ConfigType = dict(
+                     type='AnchorGenerator',
+                     scales=[8],
+                     ratios=[1.0],
+                     strides=[4, 8, 16, 32, 64]),
+                 adapt_cfg: ConfigType = dict(type='dilation', dilation=3),
+                 bridged_feature: bool = False,
+                 with_cls: bool = True,
+                 init_cfg: OptMultiConfig = None,
+                 **kwargs) -> None:
+        self.with_cls = with_cls
+        self.anchor_strides = anchor_generator['strides']
+        self.anchor_scales = anchor_generator['scales']
+        self.bridged_feature = bridged_feature
+        self.adapt_cfg = adapt_cfg
+        super().__init__(
+            in_channels=in_channels,
+            anchor_generator=anchor_generator,
+            init_cfg=init_cfg,
+            **kwargs)
+
+        # override sampling and sampler
+        if self.train_cfg:
+            self.assigner = TASK_UTILS.build(self.train_cfg['assigner'])
+            # use PseudoSampler when sampling is False
+            if self.train_cfg.get('sampler', None) is not None:
+                self.sampler = TASK_UTILS.build(
+                    self.train_cfg['sampler'], default_args=dict(context=self))
+            else:
+                self.sampler = PseudoSampler(context=self)
+
+        if init_cfg is None:
+            self.init_cfg = dict(
+                type='Normal', std=0.01, override=[dict(name='rpn_reg')])
+            if self.with_cls:
+                self.init_cfg['override'].append(dict(name='rpn_cls'))
+
+    def _init_layers(self) -> None:
+        """Init layers of a CascadeRPN stage."""
+        adapt_cfg = copy.deepcopy(self.adapt_cfg)
+        adapt_cfg['adapt_type'] = adapt_cfg.pop('type')
+        self.rpn_conv = AdaptiveConv(self.in_channels, self.feat_channels,
+                                     **adapt_cfg)
+        if self.with_cls:
+            self.rpn_cls = nn.Conv2d(self.feat_channels,
+                                     self.num_anchors * self.cls_out_channels,
+                                     1)
+        self.rpn_reg = nn.Conv2d(self.feat_channels, self.num_anchors * 4, 1)
+        self.relu = nn.ReLU(inplace=True)
+
+    def forward_single(self, x: Tensor, offset: Tensor) -> Tuple[Tensor]:
+        """Forward function of single scale."""
+        bridged_x = x
+        x = self.relu(self.rpn_conv(x, offset))
+        if self.bridged_feature:
+            bridged_x = x  # update feature
+        cls_score = self.rpn_cls(x) if self.with_cls else None
+        bbox_pred = self.rpn_reg(x)
+        return bridged_x, cls_score, bbox_pred
+
+    def forward(
+            self,
+            feats: List[Tensor],
+            offset_list: Optional[List[Tensor]] = None) -> Tuple[List[Tensor]]:
+        """Forward function."""
+        if offset_list is None:
+            offset_list = [None for _ in range(len(feats))]
+        return multi_apply(self.forward_single, feats, offset_list)
+
+    def _region_targets_single(self, flat_anchors: Tensor, valid_flags: Tensor,
+                               gt_instances: InstanceData, img_meta: dict,
+                               gt_instances_ignore: InstanceData,
+                               featmap_sizes: List[Tuple[int, int]],
+                               num_level_anchors: List[int]) -> tuple:
+        """Get anchor targets based on region for single level.
+
+        Args:
+            flat_anchors (Tensor): Multi-level anchors of the image, which are
+                concatenated into a single tensor of shape (num_anchors, 4)
+            valid_flags (Tensor): Multi level valid flags of the image,
+                which are concatenated into a single tensor of
+                    shape (num_anchors, ).
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It should includes ``bboxes`` and ``labels``
+                attributes.
+            img_meta (dict): Meta information for current image.
+            gt_instances_ignore (:obj:`InstanceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+            featmap_sizes (list[Tuple[int, int]]): Feature map size each level.
+            num_level_anchors (list[int]): The number of anchors in each level.
+
+        Returns:
+            tuple:
+
+                - labels (Tensor): Labels of each level.
+                - label_weights (Tensor): Label weights of each level.
+                - bbox_targets (Tensor): BBox targets of each level.
+                - bbox_weights (Tensor): BBox weights of each level.
+                - pos_inds (Tensor): positive samples indexes.
+                - neg_inds (Tensor): negative samples indexes.
+                - sampling_result (:obj:`SamplingResult`): Sampling results.
+        """
+        pred_instances = InstanceData()
+        pred_instances.priors = flat_anchors
+        pred_instances.valid_flags = valid_flags
+
+        assign_result = self.assigner.assign(
+            pred_instances,
+            gt_instances,
+            img_meta,
+            featmap_sizes,
+            num_level_anchors,
+            self.anchor_scales[0],
+            self.anchor_strides,
+            gt_instances_ignore=gt_instances_ignore,
+            allowed_border=self.train_cfg['allowed_border'])
+        sampling_result = self.sampler.sample(assign_result, pred_instances,
+                                              gt_instances)
+
+        num_anchors = flat_anchors.shape[0]
+        bbox_targets = torch.zeros_like(flat_anchors)
+        bbox_weights = torch.zeros_like(flat_anchors)
+        labels = flat_anchors.new_zeros(num_anchors, dtype=torch.long)
+        label_weights = flat_anchors.new_zeros(num_anchors, dtype=torch.float)
+
+        pos_inds = sampling_result.pos_inds
+        neg_inds = sampling_result.neg_inds
+        if len(pos_inds) > 0:
+            if not self.reg_decoded_bbox:
+                pos_bbox_targets = self.bbox_coder.encode(
+                    sampling_result.pos_bboxes, sampling_result.pos_gt_bboxes)
+            else:
+                pos_bbox_targets = sampling_result.pos_gt_bboxes
+            bbox_targets[pos_inds, :] = pos_bbox_targets
+            bbox_weights[pos_inds, :] = 1.0
+            labels[pos_inds] = sampling_result.pos_gt_labels
+            if self.train_cfg['pos_weight'] <= 0:
+                label_weights[pos_inds] = 1.0
+            else:
+                label_weights[pos_inds] = self.train_cfg['pos_weight']
+        if len(neg_inds) > 0:
+            label_weights[neg_inds] = 1.0
+
+        return (labels, label_weights, bbox_targets, bbox_weights, pos_inds,
+                neg_inds, sampling_result)
+
+    def region_targets(
+        self,
+        anchor_list: List[List[Tensor]],
+        valid_flag_list: List[List[Tensor]],
+        featmap_sizes: List[Tuple[int, int]],
+        batch_gt_instances: InstanceList,
+        batch_img_metas: List[dict],
+        batch_gt_instances_ignore: OptInstanceList = None,
+        return_sampling_results: bool = False,
+    ) -> tuple:
+        """Compute regression and classification targets for anchors when using
+        RegionAssigner.
+
+        Args:
+            anchor_list (list[list[Tensor]]): Multi level anchors of each
+                image.
+            valid_flag_list (list[list[Tensor]]): Multi level valid flags of
+                each image.
+            featmap_sizes (list[Tuple[int, int]]): Feature map size each level.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            tuple:
+
+                - labels_list (list[Tensor]): Labels of each level.
+                - label_weights_list (list[Tensor]): Label weights of each
+                  level.
+                - bbox_targets_list (list[Tensor]): BBox targets of each level.
+                - bbox_weights_list (list[Tensor]): BBox weights of each level.
+                - avg_factor (int): Average factor that is used to average
+                  the loss. When using sampling method, avg_factor is usually
+                  the sum of positive and negative priors. When using
+                  ``PseudoSampler``, ``avg_factor`` is usually equal to the
+                  number of positive priors.
+        """
+        num_imgs = len(batch_img_metas)
+        assert len(anchor_list) == len(valid_flag_list) == num_imgs
+
+        if batch_gt_instances_ignore is None:
+            batch_gt_instances_ignore = [None] * num_imgs
+
+        # anchor number of multi levels
+        num_level_anchors = [anchors.size(0) for anchors in anchor_list[0]]
+        # concat all level anchors to a single tensor
+        concat_anchor_list = []
+        concat_valid_flag_list = []
+        for i in range(num_imgs):
+            assert len(anchor_list[i]) == len(valid_flag_list[i])
+            concat_anchor_list.append(torch.cat(anchor_list[i]))
+            concat_valid_flag_list.append(torch.cat(valid_flag_list[i]))
+
+        # compute targets for each image
+        (all_labels, all_label_weights, all_bbox_targets, all_bbox_weights,
+         pos_inds_list, neg_inds_list, sampling_results_list) = multi_apply(
+             self._region_targets_single,
+             concat_anchor_list,
+             concat_valid_flag_list,
+             batch_gt_instances,
+             batch_img_metas,
+             batch_gt_instances_ignore,
+             featmap_sizes=featmap_sizes,
+             num_level_anchors=num_level_anchors)
+        # no valid anchors
+        if any([labels is None for labels in all_labels]):
+            return None
+        # sampled anchors of all images
+        avg_factor = sum(
+            [results.avg_factor for results in sampling_results_list])
+        # split targets to a list w.r.t. multiple levels
+        labels_list = images_to_levels(all_labels, num_level_anchors)
+        label_weights_list = images_to_levels(all_label_weights,
+                                              num_level_anchors)
+        bbox_targets_list = images_to_levels(all_bbox_targets,
+                                             num_level_anchors)
+        bbox_weights_list = images_to_levels(all_bbox_weights,
+                                             num_level_anchors)
+        res = (labels_list, label_weights_list, bbox_targets_list,
+               bbox_weights_list, avg_factor)
+        if return_sampling_results:
+            res = res + (sampling_results_list, )
+        return res
+
+    def get_targets(
+        self,
+        anchor_list: List[List[Tensor]],
+        valid_flag_list: List[List[Tensor]],
+        featmap_sizes: List[Tuple[int, int]],
+        batch_gt_instances: InstanceList,
+        batch_img_metas: List[dict],
+        batch_gt_instances_ignore: OptInstanceList = None,
+        return_sampling_results: bool = False,
+    ) -> tuple:
+        """Compute regression and classification targets for anchors.
+
+        Args:
+            anchor_list (list[list[Tensor]]): Multi level anchors of each
+                image.
+            valid_flag_list (list[list[Tensor]]): Multi level valid flags of
+                each image.
+            featmap_sizes (list[Tuple[int, int]]): Feature map size each level.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+            return_sampling_results (bool): Whether to return the sampling
+                results. Defaults to False.
+
+        Returns:
+            tuple:
+
+                - labels_list (list[Tensor]): Labels of each level.
+                - label_weights_list (list[Tensor]): Label weights of each
+                  level.
+                - bbox_targets_list (list[Tensor]): BBox targets of each level.
+                - bbox_weights_list (list[Tensor]): BBox weights of each level.
+                - avg_factor (int): Average factor that is used to average
+                  the loss. When using sampling method, avg_factor is usually
+                  the sum of positive and negative priors. When using
+                  ``PseudoSampler``, ``avg_factor`` is usually equal to the
+                  number of positive priors.
+        """
+        if isinstance(self.assigner, RegionAssigner):
+            cls_reg_targets = self.region_targets(
+                anchor_list,
+                valid_flag_list,
+                featmap_sizes,
+                batch_gt_instances,
+                batch_img_metas,
+                batch_gt_instances_ignore=batch_gt_instances_ignore,
+                return_sampling_results=return_sampling_results)
+        else:
+            cls_reg_targets = super().get_targets(
+                anchor_list,
+                valid_flag_list,
+                batch_gt_instances,
+                batch_img_metas,
+                batch_gt_instances_ignore=batch_gt_instances_ignore,
+                return_sampling_results=return_sampling_results)
+        return cls_reg_targets
+
+    def anchor_offset(self, anchor_list: List[List[Tensor]],
+                      anchor_strides: List[int],
+                      featmap_sizes: List[Tuple[int, int]]) -> List[Tensor]:
+        """ Get offset for deformable conv based on anchor shape
+        NOTE: currently support deformable kernel_size=3 and dilation=1
+
+        Args:
+            anchor_list (list[list[tensor])): [NI, NLVL, NA, 4] list of
+                multi-level anchors
+            anchor_strides (list[int]): anchor stride of each level
+
+        Returns:
+            list[tensor]: offset of DeformConv kernel with shapes of
+            [NLVL, NA, 2, 18].
+        """
+
+        def _shape_offset(anchors, stride, ks=3, dilation=1):
+            # currently support kernel_size=3 and dilation=1
+            assert ks == 3 and dilation == 1
+            pad = (ks - 1) // 2
+            idx = torch.arange(-pad, pad + 1, dtype=dtype, device=device)
+            yy, xx = torch.meshgrid(idx, idx)  # return order matters
+            xx = xx.reshape(-1)
+            yy = yy.reshape(-1)
+            w = (anchors[:, 2] - anchors[:, 0]) / stride
+            h = (anchors[:, 3] - anchors[:, 1]) / stride
+            w = w / (ks - 1) - dilation
+            h = h / (ks - 1) - dilation
+            offset_x = w[:, None] * xx  # (NA, ks**2)
+            offset_y = h[:, None] * yy  # (NA, ks**2)
+            return offset_x, offset_y
+
+        def _ctr_offset(anchors, stride, featmap_size):
+            feat_h, feat_w = featmap_size
+            assert len(anchors) == feat_h * feat_w
+
+            x = (anchors[:, 0] + anchors[:, 2]) * 0.5
+            y = (anchors[:, 1] + anchors[:, 3]) * 0.5
+            # compute centers on feature map
+            x = x / stride
+            y = y / stride
+            # compute predefine centers
+            xx = torch.arange(0, feat_w, device=anchors.device)
+            yy = torch.arange(0, feat_h, device=anchors.device)
+            yy, xx = torch.meshgrid(yy, xx)
+            xx = xx.reshape(-1).type_as(x)
+            yy = yy.reshape(-1).type_as(y)
+
+            offset_x = x - xx  # (NA, )
+            offset_y = y - yy  # (NA, )
+            return offset_x, offset_y
+
+        num_imgs = len(anchor_list)
+        num_lvls = len(anchor_list[0])
+        dtype = anchor_list[0][0].dtype
+        device = anchor_list[0][0].device
+        num_level_anchors = [anchors.size(0) for anchors in anchor_list[0]]
+
+        offset_list = []
+        for i in range(num_imgs):
+            mlvl_offset = []
+            for lvl in range(num_lvls):
+                c_offset_x, c_offset_y = _ctr_offset(anchor_list[i][lvl],
+                                                     anchor_strides[lvl],
+                                                     featmap_sizes[lvl])
+                s_offset_x, s_offset_y = _shape_offset(anchor_list[i][lvl],
+                                                       anchor_strides[lvl])
+
+                # offset = ctr_offset + shape_offset
+                offset_x = s_offset_x + c_offset_x[:, None]
+                offset_y = s_offset_y + c_offset_y[:, None]
+
+                # offset order (y0, x0, y1, x2, .., y8, x8, y9, x9)
+                offset = torch.stack([offset_y, offset_x], dim=-1)
+                offset = offset.reshape(offset.size(0), -1)  # [NA, 2*ks**2]
+                mlvl_offset.append(offset)
+            offset_list.append(torch.cat(mlvl_offset))  # [totalNA, 2*ks**2]
+        offset_list = images_to_levels(offset_list, num_level_anchors)
+        return offset_list
+
+    def loss_by_feat_single(self, cls_score: Tensor, bbox_pred: Tensor,
+                            anchors: Tensor, labels: Tensor,
+                            label_weights: Tensor, bbox_targets: Tensor,
+                            bbox_weights: Tensor, avg_factor: int) -> tuple:
+        """Loss function on single scale."""
+        # classification loss
+        if self.with_cls:
+            labels = labels.reshape(-1)
+            label_weights = label_weights.reshape(-1)
+            cls_score = cls_score.permute(0, 2, 3,
+                                          1).reshape(-1, self.cls_out_channels)
+            loss_cls = self.loss_cls(
+                cls_score, labels, label_weights, avg_factor=avg_factor)
+        # regression loss
+        bbox_targets = bbox_targets.reshape(-1, 4)
+        bbox_weights = bbox_weights.reshape(-1, 4)
+        bbox_pred = bbox_pred.permute(0, 2, 3, 1).reshape(-1, 4)
+        if self.reg_decoded_bbox:
+            # When the regression loss (e.g. `IouLoss`, `GIouLoss`)
+            # is applied directly on the decoded bounding boxes, it
+            # decodes the already encoded coordinates to absolute format.
+            anchors = anchors.reshape(-1, 4)
+            bbox_pred = self.bbox_coder.decode(anchors, bbox_pred)
+        loss_reg = self.loss_bbox(
+            bbox_pred, bbox_targets, bbox_weights, avg_factor=avg_factor)
+        if self.with_cls:
+            return loss_cls, loss_reg
+        return None, loss_reg
+
+    def loss_by_feat(
+        self,
+        anchor_list: List[List[Tensor]],
+        valid_flag_list: List[List[Tensor]],
+        cls_scores: List[Tensor],
+        bbox_preds: List[Tensor],
+        batch_gt_instances: InstanceList,
+        batch_img_metas: List[dict],
+        batch_gt_instances_ignore: OptInstanceList = None
+    ) -> Dict[str, Tensor]:
+        """Compute losses of the head.
+
+        Args:
+            anchor_list (list[list[Tensor]]): Multi level anchors of each
+                image.
+            valid_flag_list (list[list[Tensor]]): Multi level valid flags of
+                each image. The outer list indicates images, and the inner list
+                corresponds to feature levels of the image. Each element of
+                the inner list is a tensor of shape (num_anchors, )
+            cls_scores (list[Tensor]): Box scores for each scale level
+                Has shape (N, num_anchors * num_classes, H, W)
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level with shape (N, num_anchors * 4, H, W)
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        featmap_sizes = [featmap.size()[-2:] for featmap in bbox_preds]
+        cls_reg_targets = self.get_targets(
+            anchor_list,
+            valid_flag_list,
+            featmap_sizes,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore,
+            return_sampling_results=True)
+        (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,
+         avg_factor, sampling_results_list) = cls_reg_targets
+        if not sampling_results_list[0].avg_factor_with_neg:
+            # 200 is hard-coded average factor,
+            # which follows guided anchoring.
+            avg_factor = sum([label.numel() for label in labels_list]) / 200.0
+
+        # change per image, per level anchor_list to per_level, per_image
+        mlvl_anchor_list = list(zip(*anchor_list))
+        # concat mlvl_anchor_list
+        mlvl_anchor_list = [
+            torch.cat(anchors, dim=0) for anchors in mlvl_anchor_list
+        ]
+
+        losses = multi_apply(
+            self.loss_by_feat_single,
+            cls_scores,
+            bbox_preds,
+            mlvl_anchor_list,
+            labels_list,
+            label_weights_list,
+            bbox_targets_list,
+            bbox_weights_list,
+            avg_factor=avg_factor)
+        if self.with_cls:
+            return dict(loss_rpn_cls=losses[0], loss_rpn_reg=losses[1])
+        return dict(loss_rpn_reg=losses[1])
+
+    def predict_by_feat(self,
+                        anchor_list: List[List[Tensor]],
+                        cls_scores: List[Tensor],
+                        bbox_preds: List[Tensor],
+                        batch_img_metas: List[dict],
+                        cfg: Optional[ConfigDict] = None,
+                        rescale: bool = False) -> InstanceList:
+        """Get proposal predict. Overriding to enable input ``anchor_list``
+        from outside.
+
+        Args:
+            anchor_list (list[list[Tensor]]): Multi level anchors of each
+                image.
+            cls_scores (list[Tensor]): Classification scores for all
+                scale levels, each is a 4D-tensor, has shape
+                (batch_size, num_priors * num_classes, H, W).
+            bbox_preds (list[Tensor]): Box energies / deltas for all
+                scale levels, each is a 4D-tensor, has shape
+                (batch_size, num_priors * 4, H, W).
+            batch_img_metas (list[dict], Optional): Image meta info.
+            cfg (:obj:`ConfigDict`, optional): Test / postprocessing
+                configuration, if None, test_cfg would be used.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Object detection results of each image
+            after the post process. Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        assert len(cls_scores) == len(bbox_preds)
+
+        result_list = []
+        for img_id in range(len(batch_img_metas)):
+            cls_score_list = select_single_mlvl(cls_scores, img_id)
+            bbox_pred_list = select_single_mlvl(bbox_preds, img_id)
+            proposals = self._predict_by_feat_single(
+                cls_scores=cls_score_list,
+                bbox_preds=bbox_pred_list,
+                mlvl_anchors=anchor_list[img_id],
+                img_meta=batch_img_metas[img_id],
+                cfg=cfg,
+                rescale=rescale)
+            result_list.append(proposals)
+        return result_list
+
+    def _predict_by_feat_single(self,
+                                cls_scores: List[Tensor],
+                                bbox_preds: List[Tensor],
+                                mlvl_anchors: List[Tensor],
+                                img_meta: dict,
+                                cfg: ConfigDict,
+                                rescale: bool = False) -> InstanceData:
+        """Transform outputs of a single image into bbox predictions.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores from all scale
+                levels of a single image, each item has shape
+                (num_anchors * num_classes, H, W).
+            bbox_preds (list[Tensor]): Box energies / deltas from
+                all scale levels of a single image, each item has
+                shape (num_anchors * 4, H, W).
+            mlvl_anchors (list[Tensor]): Box reference from all scale
+                levels of a single image, each item has shape
+                (num_total_anchors, 4).
+            img_shape (tuple[int]): Shape of the input image,
+                (height, width, 3).
+            scale_factor (ndarray): Scale factor of the image arange as
+                (w_scale, h_scale, w_scale, h_scale).
+            cfg (:obj:`ConfigDict`): Test / postprocessing configuration,
+                if None, test_cfg would be used.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        cfg = self.test_cfg if cfg is None else cfg
+        cfg = copy.deepcopy(cfg)
+        # bboxes from different level should be independent during NMS,
+        # level_ids are used as labels for batched NMS to separate them
+        level_ids = []
+        mlvl_scores = []
+        mlvl_bbox_preds = []
+        mlvl_valid_anchors = []
+        nms_pre = cfg.get('nms_pre', -1)
+        for idx in range(len(cls_scores)):
+            rpn_cls_score = cls_scores[idx]
+            rpn_bbox_pred = bbox_preds[idx]
+            assert rpn_cls_score.size()[-2:] == rpn_bbox_pred.size()[-2:]
+            rpn_cls_score = rpn_cls_score.permute(1, 2, 0)
+            if self.use_sigmoid_cls:
+                rpn_cls_score = rpn_cls_score.reshape(-1)
+                scores = rpn_cls_score.sigmoid()
+            else:
+                rpn_cls_score = rpn_cls_score.reshape(-1, 2)
+                # We set FG labels to [0, num_class-1] and BG label to
+                # num_class in RPN head since mmdet v2.5, which is unified to
+                # be consistent with other head since mmdet v2.0. In mmdet v2.0
+                # to v2.4 we keep BG label as 0 and FG label as 1 in rpn head.
+                scores = rpn_cls_score.softmax(dim=1)[:, 0]
+            rpn_bbox_pred = rpn_bbox_pred.permute(1, 2, 0).reshape(-1, 4)
+            anchors = mlvl_anchors[idx]
+
+            if 0 < nms_pre < scores.shape[0]:
+                # sort is faster than topk
+                # _, topk_inds = scores.topk(cfg.nms_pre)
+                ranked_scores, rank_inds = scores.sort(descending=True)
+                topk_inds = rank_inds[:nms_pre]
+                scores = ranked_scores[:nms_pre]
+                rpn_bbox_pred = rpn_bbox_pred[topk_inds, :]
+                anchors = anchors[topk_inds, :]
+            mlvl_scores.append(scores)
+            mlvl_bbox_preds.append(rpn_bbox_pred)
+            mlvl_valid_anchors.append(anchors)
+            level_ids.append(
+                scores.new_full((scores.size(0), ), idx, dtype=torch.long))
+
+        anchors = torch.cat(mlvl_valid_anchors)
+        rpn_bbox_pred = torch.cat(mlvl_bbox_preds)
+        bboxes = self.bbox_coder.decode(
+            anchors, rpn_bbox_pred, max_shape=img_meta['img_shape'])
+
+        proposals = InstanceData()
+        proposals.bboxes = bboxes
+        proposals.scores = torch.cat(mlvl_scores)
+        proposals.level_ids = torch.cat(level_ids)
+
+        return self._bbox_post_process(
+            results=proposals, cfg=cfg, rescale=rescale, img_meta=img_meta)
+
+    def refine_bboxes(self, anchor_list: List[List[Tensor]],
+                      bbox_preds: List[Tensor],
+                      img_metas: List[dict]) -> List[List[Tensor]]:
+        """Refine bboxes through stages."""
+        num_levels = len(bbox_preds)
+        new_anchor_list = []
+        for img_id in range(len(img_metas)):
+            mlvl_anchors = []
+            for i in range(num_levels):
+                bbox_pred = bbox_preds[i][img_id].detach()
+                bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, 4)
+                img_shape = img_metas[img_id]['img_shape']
+                bboxes = self.bbox_coder.decode(anchor_list[img_id][i],
+                                                bbox_pred, img_shape)
+                mlvl_anchors.append(bboxes)
+            new_anchor_list.append(mlvl_anchors)
+        return new_anchor_list
+
+    def loss(self, x: Tuple[Tensor], batch_data_samples: SampleList) -> dict:
+        """Perform forward propagation and loss calculation of the detection
+        head on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        outputs = unpack_gt_instances(batch_data_samples)
+        batch_gt_instances, _, batch_img_metas = outputs
+
+        featmap_sizes = [featmap.size()[-2:] for featmap in x]
+        device = x[0].device
+        anchor_list, valid_flag_list = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+
+        if self.adapt_cfg['type'] == 'offset':
+            offset_list = self.anchor_offset(anchor_list, self.anchor_strides,
+                                             featmap_sizes)
+        else:
+            offset_list = None
+
+        x, cls_score, bbox_pred = self(x, offset_list)
+        rpn_loss_inputs = (anchor_list, valid_flag_list, cls_score, bbox_pred,
+                           batch_gt_instances, batch_img_metas)
+        losses = self.loss_by_feat(*rpn_loss_inputs)
+
+        return losses
+
+    def loss_and_predict(
+        self,
+        x: Tuple[Tensor],
+        batch_data_samples: SampleList,
+        proposal_cfg: Optional[ConfigDict] = None,
+    ) -> Tuple[dict, InstanceList]:
+        """Perform forward propagation of the head, then calculate loss and
+        predictions from the features and data samples.
+
+        Args:
+            x (tuple[Tensor]): Features from FPN.
+            batch_data_samples (list[:obj:`DetDataSample`]): Each item contains
+                the meta information of each image and corresponding
+                annotations.
+            proposal_cfg (:obj`ConfigDict`, optional): Test / postprocessing
+                configuration, if None, test_cfg would be used.
+                Defaults to None.
+
+        Returns:
+            tuple: the return value is a tuple contains:
+
+                - losses: (dict[str, Tensor]): A dictionary of loss components.
+                - predictions (list[:obj:`InstanceData`]): Detection
+                  results of each image after the post process.
+        """
+        outputs = unpack_gt_instances(batch_data_samples)
+        batch_gt_instances, _, batch_img_metas = outputs
+
+        featmap_sizes = [featmap.size()[-2:] for featmap in x]
+        device = x[0].device
+        anchor_list, valid_flag_list = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+
+        if self.adapt_cfg['type'] == 'offset':
+            offset_list = self.anchor_offset(anchor_list, self.anchor_strides,
+                                             featmap_sizes)
+        else:
+            offset_list = None
+
+        x, cls_score, bbox_pred = self(x, offset_list)
+        rpn_loss_inputs = (anchor_list, valid_flag_list, cls_score, bbox_pred,
+                           batch_gt_instances, batch_img_metas)
+        losses = self.loss_by_feat(*rpn_loss_inputs)
+
+        predictions = self.predict_by_feat(
+            anchor_list,
+            cls_score,
+            bbox_pred,
+            batch_img_metas=batch_img_metas,
+            cfg=proposal_cfg)
+        return losses, predictions
+
+    def predict(self,
+                x: Tuple[Tensor],
+                batch_data_samples: SampleList,
+                rescale: bool = False) -> InstanceList:
+        """Perform forward propagation of the detection head and predict
+        detection results on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Multi-level features from the
+                upstream network, each is a 4D-tensor.
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            rescale (bool, optional): Whether to rescale the results.
+                Defaults to False.
+
+        Returns:
+            list[obj:`InstanceData`]: Detection results of each image
+            after the post process.
+        """
+        batch_img_metas = [
+            data_samples.metainfo for data_samples in batch_data_samples
+        ]
+
+        featmap_sizes = [featmap.size()[-2:] for featmap in x]
+        device = x[0].device
+        anchor_list, _ = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+
+        if self.adapt_cfg['type'] == 'offset':
+            offset_list = self.anchor_offset(anchor_list, self.anchor_strides,
+                                             featmap_sizes)
+        else:
+            offset_list = None
+
+        x, cls_score, bbox_pred = self(x, offset_list)
+        predictions = self.stages[-1].predict_by_feat(
+            anchor_list,
+            cls_score,
+            bbox_pred,
+            batch_img_metas=batch_img_metas,
+            rescale=rescale)
+        return predictions
+
+
+@MODELS.register_module()
+class CascadeRPNHead(BaseDenseHead):
+    """The CascadeRPNHead will predict more accurate region proposals, which is
+    required for two-stage detectors (such as Fast/Faster R-CNN). CascadeRPN
+    consists of a sequence of RPNStage to progressively improve the accuracy of
+    the detected proposals.
+
+    More details can be found in ``https://arxiv.org/abs/1909.06720``.
+
+    Args:
+        num_stages (int): number of CascadeRPN stages.
+        stages (list[:obj:`ConfigDict` or dict]): list of configs to build
+            the stages.
+        train_cfg (list[:obj:`ConfigDict` or dict]): list of configs at
+            training time each stage.
+        test_cfg (:obj:`ConfigDict` or dict): config at testing time.
+        init_cfg (:obj:`ConfigDict` or list[:obj:`ConfigDict`] or dict or \
+            list[dict]): Initialization config dict.
+    """
+
+    def __init__(self,
+                 num_classes: int,
+                 num_stages: int,
+                 stages: List[ConfigType],
+                 train_cfg: List[ConfigType],
+                 test_cfg: ConfigType,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(init_cfg=init_cfg)
+        assert num_classes == 1, 'Only support num_classes == 1'
+        assert num_stages == len(stages)
+        self.num_stages = num_stages
+        # Be careful! Pretrained weights cannot be loaded when use
+        # nn.ModuleList
+        self.stages = ModuleList()
+        for i in range(len(stages)):
+            train_cfg_i = train_cfg[i] if train_cfg is not None else None
+            stages[i].update(train_cfg=train_cfg_i)
+            stages[i].update(test_cfg=test_cfg)
+            self.stages.append(MODELS.build(stages[i]))
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+
+    def loss_by_feat(self):
+        """loss_by_feat() is implemented in StageCascadeRPNHead."""
+        pass
+
+    def predict_by_feat(self):
+        """predict_by_feat() is implemented in StageCascadeRPNHead."""
+        pass
+
+    def loss(self, x: Tuple[Tensor], batch_data_samples: SampleList) -> dict:
+        """Perform forward propagation and loss calculation of the detection
+        head on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        outputs = unpack_gt_instances(batch_data_samples)
+        batch_gt_instances, _, batch_img_metas = outputs
+
+        featmap_sizes = [featmap.size()[-2:] for featmap in x]
+        device = x[0].device
+        anchor_list, valid_flag_list = self.stages[0].get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+
+        losses = dict()
+
+        for i in range(self.num_stages):
+            stage = self.stages[i]
+
+            if stage.adapt_cfg['type'] == 'offset':
+                offset_list = stage.anchor_offset(anchor_list,
+                                                  stage.anchor_strides,
+                                                  featmap_sizes)
+            else:
+                offset_list = None
+            x, cls_score, bbox_pred = stage(x, offset_list)
+            rpn_loss_inputs = (anchor_list, valid_flag_list, cls_score,
+                               bbox_pred, batch_gt_instances, batch_img_metas)
+            stage_loss = stage.loss_by_feat(*rpn_loss_inputs)
+            for name, value in stage_loss.items():
+                losses['s{}.{}'.format(i, name)] = value
+
+            # refine boxes
+            if i < self.num_stages - 1:
+                anchor_list = stage.refine_bboxes(anchor_list, bbox_pred,
+                                                  batch_img_metas)
+
+        return losses
+
+    def loss_and_predict(
+        self,
+        x: Tuple[Tensor],
+        batch_data_samples: SampleList,
+        proposal_cfg: Optional[ConfigDict] = None,
+    ) -> Tuple[dict, InstanceList]:
+        """Perform forward propagation of the head, then calculate loss and
+        predictions from the features and data samples.
+
+        Args:
+            x (tuple[Tensor]): Features from FPN.
+            batch_data_samples (list[:obj:`DetDataSample`]): Each item contains
+                the meta information of each image and corresponding
+                annotations.
+            proposal_cfg (ConfigDict, optional): Test / postprocessing
+                configuration, if None, test_cfg would be used.
+                Defaults to None.
+
+        Returns:
+            tuple: the return value is a tuple contains:
+
+                - losses: (dict[str, Tensor]): A dictionary of loss components.
+                - predictions (list[:obj:`InstanceData`]): Detection
+                  results of each image after the post process.
+        """
+        outputs = unpack_gt_instances(batch_data_samples)
+        batch_gt_instances, _, batch_img_metas = outputs
+
+        featmap_sizes = [featmap.size()[-2:] for featmap in x]
+        device = x[0].device
+        anchor_list, valid_flag_list = self.stages[0].get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+
+        losses = dict()
+
+        for i in range(self.num_stages):
+            stage = self.stages[i]
+
+            if stage.adapt_cfg['type'] == 'offset':
+                offset_list = stage.anchor_offset(anchor_list,
+                                                  stage.anchor_strides,
+                                                  featmap_sizes)
+            else:
+                offset_list = None
+            x, cls_score, bbox_pred = stage(x, offset_list)
+            rpn_loss_inputs = (anchor_list, valid_flag_list, cls_score,
+                               bbox_pred, batch_gt_instances, batch_img_metas)
+            stage_loss = stage.loss_by_feat(*rpn_loss_inputs)
+            for name, value in stage_loss.items():
+                losses['s{}.{}'.format(i, name)] = value
+
+            # refine boxes
+            if i < self.num_stages - 1:
+                anchor_list = stage.refine_bboxes(anchor_list, bbox_pred,
+                                                  batch_img_metas)
+
+        predictions = self.stages[-1].predict_by_feat(
+            anchor_list,
+            cls_score,
+            bbox_pred,
+            batch_img_metas=batch_img_metas,
+            cfg=proposal_cfg)
+        return losses, predictions
+
+    def predict(self,
+                x: Tuple[Tensor],
+                batch_data_samples: SampleList,
+                rescale: bool = False) -> InstanceList:
+        """Perform forward propagation of the detection head and predict
+        detection results on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Multi-level features from the
+                upstream network, each is a 4D-tensor.
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            rescale (bool, optional): Whether to rescale the results.
+                Defaults to False.
+
+        Returns:
+            list[obj:`InstanceData`]: Detection results of each image
+            after the post process.
+        """
+        batch_img_metas = [
+            data_samples.metainfo for data_samples in batch_data_samples
+        ]
+
+        featmap_sizes = [featmap.size()[-2:] for featmap in x]
+        device = x[0].device
+        anchor_list, _ = self.stages[0].get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+
+        for i in range(self.num_stages):
+            stage = self.stages[i]
+            if stage.adapt_cfg['type'] == 'offset':
+                offset_list = stage.anchor_offset(anchor_list,
+                                                  stage.anchor_strides,
+                                                  featmap_sizes)
+            else:
+                offset_list = None
+            x, cls_score, bbox_pred = stage(x, offset_list)
+            if i < self.num_stages - 1:
+                anchor_list = stage.refine_bboxes(anchor_list, bbox_pred,
+                                                  batch_img_metas)
+
+        predictions = self.stages[-1].predict_by_feat(
+            anchor_list,
+            cls_score,
+            bbox_pred,
+            batch_img_metas=batch_img_metas,
+            rescale=rescale)
+        return predictions
diff --git a/mmdetection/mmdet/models/dense_heads/centernet_head.py b/mmdetection/mmdet/models/dense_heads/centernet_head.py
new file mode 100644
index 00000000..09f3e599
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/centernet_head.py
@@ -0,0 +1,447 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Tuple
+
+import torch
+import torch.nn as nn
+from mmcv.ops import batched_nms
+from mmengine.config import ConfigDict
+from mmengine.model import bias_init_with_prob, normal_init
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import (ConfigType, InstanceList, OptConfigType,
+                         OptInstanceList, OptMultiConfig)
+from ..utils import (gaussian_radius, gen_gaussian_target, get_local_maximum,
+                     get_topk_from_heatmap, multi_apply,
+                     transpose_and_gather_feat)
+from .base_dense_head import BaseDenseHead
+
+
+@MODELS.register_module()
+class CenterNetHead(BaseDenseHead):
+    """Objects as Points Head. CenterHead use center_point to indicate object's
+    position. Paper link 
+
+    Args:
+        in_channels (int): Number of channel in the input feature map.
+        feat_channels (int): Number of channel in the intermediate feature map.
+        num_classes (int): Number of categories excluding the background
+            category.
+        loss_center_heatmap (:obj:`ConfigDict` or dict): Config of center
+            heatmap loss. Defaults to
+            dict(type='GaussianFocalLoss', loss_weight=1.0)
+        loss_wh (:obj:`ConfigDict` or dict): Config of wh loss. Defaults to
+             dict(type='L1Loss', loss_weight=0.1).
+        loss_offset (:obj:`ConfigDict` or dict): Config of offset loss.
+            Defaults to dict(type='L1Loss', loss_weight=1.0).
+        train_cfg (:obj:`ConfigDict` or dict, optional): Training config.
+            Useless in CenterNet, but we keep this variable for
+            SingleStageDetector.
+        test_cfg (:obj:`ConfigDict` or dict, optional): Testing config
+            of CenterNet.
+        init_cfg (:obj:`ConfigDict` or dict or list[dict] or
+            list[:obj:`ConfigDict`], optional): Initialization
+            config dict.
+    """
+
+    def __init__(self,
+                 in_channels: int,
+                 feat_channels: int,
+                 num_classes: int,
+                 loss_center_heatmap: ConfigType = dict(
+                     type='GaussianFocalLoss', loss_weight=1.0),
+                 loss_wh: ConfigType = dict(type='L1Loss', loss_weight=0.1),
+                 loss_offset: ConfigType = dict(
+                     type='L1Loss', loss_weight=1.0),
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.num_classes = num_classes
+        self.heatmap_head = self._build_head(in_channels, feat_channels,
+                                             num_classes)
+        self.wh_head = self._build_head(in_channels, feat_channels, 2)
+        self.offset_head = self._build_head(in_channels, feat_channels, 2)
+
+        self.loss_center_heatmap = MODELS.build(loss_center_heatmap)
+        self.loss_wh = MODELS.build(loss_wh)
+        self.loss_offset = MODELS.build(loss_offset)
+
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+        self.fp16_enabled = False
+
+    def _build_head(self, in_channels: int, feat_channels: int,
+                    out_channels: int) -> nn.Sequential:
+        """Build head for each branch."""
+        layer = nn.Sequential(
+            nn.Conv2d(in_channels, feat_channels, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(feat_channels, out_channels, kernel_size=1))
+        return layer
+
+    def init_weights(self) -> None:
+        """Initialize weights of the head."""
+        bias_init = bias_init_with_prob(0.1)
+        self.heatmap_head[-1].bias.data.fill_(bias_init)
+        for head in [self.wh_head, self.offset_head]:
+            for m in head.modules():
+                if isinstance(m, nn.Conv2d):
+                    normal_init(m, std=0.001)
+
+    def forward(self, x: Tuple[Tensor, ...]) -> Tuple[List[Tensor]]:
+        """Forward features. Notice CenterNet head does not use FPN.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            center_heatmap_preds (list[Tensor]): center predict heatmaps for
+                all levels, the channels number is num_classes.
+            wh_preds (list[Tensor]): wh predicts for all levels, the channels
+                number is 2.
+            offset_preds (list[Tensor]): offset predicts for all levels, the
+               channels number is 2.
+        """
+        return multi_apply(self.forward_single, x)
+
+    def forward_single(self, x: Tensor) -> Tuple[Tensor, ...]:
+        """Forward feature of a single level.
+
+        Args:
+            x (Tensor): Feature of a single level.
+
+        Returns:
+            center_heatmap_pred (Tensor): center predict heatmaps, the
+               channels number is num_classes.
+            wh_pred (Tensor): wh predicts, the channels number is 2.
+            offset_pred (Tensor): offset predicts, the channels number is 2.
+        """
+        center_heatmap_pred = self.heatmap_head(x).sigmoid()
+        wh_pred = self.wh_head(x)
+        offset_pred = self.offset_head(x)
+        return center_heatmap_pred, wh_pred, offset_pred
+
+    def loss_by_feat(
+            self,
+            center_heatmap_preds: List[Tensor],
+            wh_preds: List[Tensor],
+            offset_preds: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> dict:
+        """Compute losses of the head.
+
+        Args:
+            center_heatmap_preds (list[Tensor]): center predict heatmaps for
+               all levels with shape (B, num_classes, H, W).
+            wh_preds (list[Tensor]): wh predicts for all levels with
+               shape (B, 2, H, W).
+            offset_preds (list[Tensor]): offset predicts for all levels
+               with shape (B, 2, H, W).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: which has components below:
+                - loss_center_heatmap (Tensor): loss of center heatmap.
+                - loss_wh (Tensor): loss of hw heatmap
+                - loss_offset (Tensor): loss of offset heatmap.
+        """
+        assert len(center_heatmap_preds) == len(wh_preds) == len(
+            offset_preds) == 1
+        center_heatmap_pred = center_heatmap_preds[0]
+        wh_pred = wh_preds[0]
+        offset_pred = offset_preds[0]
+
+        gt_bboxes = [
+            gt_instances.bboxes for gt_instances in batch_gt_instances
+        ]
+        gt_labels = [
+            gt_instances.labels for gt_instances in batch_gt_instances
+        ]
+        img_shape = batch_img_metas[0]['batch_input_shape']
+        target_result, avg_factor = self.get_targets(gt_bboxes, gt_labels,
+                                                     center_heatmap_pred.shape,
+                                                     img_shape)
+
+        center_heatmap_target = target_result['center_heatmap_target']
+        wh_target = target_result['wh_target']
+        offset_target = target_result['offset_target']
+        wh_offset_target_weight = target_result['wh_offset_target_weight']
+
+        # Since the channel of wh_target and offset_target is 2, the avg_factor
+        # of loss_center_heatmap is always 1/2 of loss_wh and loss_offset.
+        loss_center_heatmap = self.loss_center_heatmap(
+            center_heatmap_pred, center_heatmap_target, avg_factor=avg_factor)
+        loss_wh = self.loss_wh(
+            wh_pred,
+            wh_target,
+            wh_offset_target_weight,
+            avg_factor=avg_factor * 2)
+        loss_offset = self.loss_offset(
+            offset_pred,
+            offset_target,
+            wh_offset_target_weight,
+            avg_factor=avg_factor * 2)
+        return dict(
+            loss_center_heatmap=loss_center_heatmap,
+            loss_wh=loss_wh,
+            loss_offset=loss_offset)
+
+    def get_targets(self, gt_bboxes: List[Tensor], gt_labels: List[Tensor],
+                    feat_shape: tuple, img_shape: tuple) -> Tuple[dict, int]:
+        """Compute regression and classification targets in multiple images.
+
+        Args:
+            gt_bboxes (list[Tensor]): Ground truth bboxes for each image with
+                shape (num_gts, 4) in [tl_x, tl_y, br_x, br_y] format.
+            gt_labels (list[Tensor]): class indices corresponding to each box.
+            feat_shape (tuple): feature map shape with value [B, _, H, W]
+            img_shape (tuple): image shape.
+
+        Returns:
+            tuple[dict, float]: The float value is mean avg_factor, the dict
+            has components below:
+               - center_heatmap_target (Tensor): targets of center heatmap, \
+                   shape (B, num_classes, H, W).
+               - wh_target (Tensor): targets of wh predict, shape \
+                   (B, 2, H, W).
+               - offset_target (Tensor): targets of offset predict, shape \
+                   (B, 2, H, W).
+               - wh_offset_target_weight (Tensor): weights of wh and offset \
+                   predict, shape (B, 2, H, W).
+        """
+        img_h, img_w = img_shape[:2]
+        bs, _, feat_h, feat_w = feat_shape
+
+        width_ratio = float(feat_w / img_w)
+        height_ratio = float(feat_h / img_h)
+
+        center_heatmap_target = gt_bboxes[-1].new_zeros(
+            [bs, self.num_classes, feat_h, feat_w])
+        wh_target = gt_bboxes[-1].new_zeros([bs, 2, feat_h, feat_w])
+        offset_target = gt_bboxes[-1].new_zeros([bs, 2, feat_h, feat_w])
+        wh_offset_target_weight = gt_bboxes[-1].new_zeros(
+            [bs, 2, feat_h, feat_w])
+
+        for batch_id in range(bs):
+            gt_bbox = gt_bboxes[batch_id]
+            gt_label = gt_labels[batch_id]
+            center_x = (gt_bbox[:, [0]] + gt_bbox[:, [2]]) * width_ratio / 2
+            center_y = (gt_bbox[:, [1]] + gt_bbox[:, [3]]) * height_ratio / 2
+            gt_centers = torch.cat((center_x, center_y), dim=1)
+
+            for j, ct in enumerate(gt_centers):
+                ctx_int, cty_int = ct.int()
+                ctx, cty = ct
+                scale_box_h = (gt_bbox[j][3] - gt_bbox[j][1]) * height_ratio
+                scale_box_w = (gt_bbox[j][2] - gt_bbox[j][0]) * width_ratio
+                radius = gaussian_radius([scale_box_h, scale_box_w],
+                                         min_overlap=0.3)
+                radius = max(0, int(radius))
+                ind = gt_label[j]
+                gen_gaussian_target(center_heatmap_target[batch_id, ind],
+                                    [ctx_int, cty_int], radius)
+
+                wh_target[batch_id, 0, cty_int, ctx_int] = scale_box_w
+                wh_target[batch_id, 1, cty_int, ctx_int] = scale_box_h
+
+                offset_target[batch_id, 0, cty_int, ctx_int] = ctx - ctx_int
+                offset_target[batch_id, 1, cty_int, ctx_int] = cty - cty_int
+
+                wh_offset_target_weight[batch_id, :, cty_int, ctx_int] = 1
+
+        avg_factor = max(1, center_heatmap_target.eq(1).sum())
+        target_result = dict(
+            center_heatmap_target=center_heatmap_target,
+            wh_target=wh_target,
+            offset_target=offset_target,
+            wh_offset_target_weight=wh_offset_target_weight)
+        return target_result, avg_factor
+
+    def predict_by_feat(self,
+                        center_heatmap_preds: List[Tensor],
+                        wh_preds: List[Tensor],
+                        offset_preds: List[Tensor],
+                        batch_img_metas: Optional[List[dict]] = None,
+                        rescale: bool = True,
+                        with_nms: bool = False) -> InstanceList:
+        """Transform network output for a batch into bbox predictions.
+
+        Args:
+            center_heatmap_preds (list[Tensor]): Center predict heatmaps for
+                all levels with shape (B, num_classes, H, W).
+            wh_preds (list[Tensor]): WH predicts for all levels with
+                shape (B, 2, H, W).
+            offset_preds (list[Tensor]): Offset predicts for all levels
+                with shape (B, 2, H, W).
+            batch_img_metas (list[dict], optional): Batch image meta info.
+                Defaults to None.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to True.
+            with_nms (bool): If True, do nms before return boxes.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Instance segmentation
+            results of each image after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        assert len(center_heatmap_preds) == len(wh_preds) == len(
+            offset_preds) == 1
+        result_list = []
+        for img_id in range(len(batch_img_metas)):
+            result_list.append(
+                self._predict_by_feat_single(
+                    center_heatmap_preds[0][img_id:img_id + 1, ...],
+                    wh_preds[0][img_id:img_id + 1, ...],
+                    offset_preds[0][img_id:img_id + 1, ...],
+                    batch_img_metas[img_id],
+                    rescale=rescale,
+                    with_nms=with_nms))
+        return result_list
+
+    def _predict_by_feat_single(self,
+                                center_heatmap_pred: Tensor,
+                                wh_pred: Tensor,
+                                offset_pred: Tensor,
+                                img_meta: dict,
+                                rescale: bool = True,
+                                with_nms: bool = False) -> InstanceData:
+        """Transform outputs of a single image into bbox results.
+
+        Args:
+            center_heatmap_pred (Tensor): Center heatmap for current level with
+                shape (1, num_classes, H, W).
+            wh_pred (Tensor): WH heatmap for current level with shape
+                (1, num_classes, H, W).
+            offset_pred (Tensor): Offset for current level with shape
+                (1, corner_offset_channels, H, W).
+            img_meta (dict): Meta information of current image, e.g.,
+                image size, scaling factor, etc.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to True.
+            with_nms (bool): If True, do nms before return boxes.
+                Defaults to False.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        batch_det_bboxes, batch_labels = self._decode_heatmap(
+            center_heatmap_pred,
+            wh_pred,
+            offset_pred,
+            img_meta['batch_input_shape'],
+            k=self.test_cfg.topk,
+            kernel=self.test_cfg.local_maximum_kernel)
+
+        det_bboxes = batch_det_bboxes.view([-1, 5])
+        det_labels = batch_labels.view(-1)
+
+        batch_border = det_bboxes.new_tensor(img_meta['border'])[...,
+                                                                 [2, 0, 2, 0]]
+        det_bboxes[..., :4] -= batch_border
+
+        if rescale and 'scale_factor' in img_meta:
+            det_bboxes[..., :4] /= det_bboxes.new_tensor(
+                img_meta['scale_factor']).repeat((1, 2))
+
+        if with_nms:
+            det_bboxes, det_labels = self._bboxes_nms(det_bboxes, det_labels,
+                                                      self.test_cfg)
+        results = InstanceData()
+        results.bboxes = det_bboxes[..., :4]
+        results.scores = det_bboxes[..., 4]
+        results.labels = det_labels
+        return results
+
+    def _decode_heatmap(self,
+                        center_heatmap_pred: Tensor,
+                        wh_pred: Tensor,
+                        offset_pred: Tensor,
+                        img_shape: tuple,
+                        k: int = 100,
+                        kernel: int = 3) -> Tuple[Tensor, Tensor]:
+        """Transform outputs into detections raw bbox prediction.
+
+        Args:
+            center_heatmap_pred (Tensor): center predict heatmap,
+               shape (B, num_classes, H, W).
+            wh_pred (Tensor): wh predict, shape (B, 2, H, W).
+            offset_pred (Tensor): offset predict, shape (B, 2, H, W).
+            img_shape (tuple): image shape in hw format.
+            k (int): Get top k center keypoints from heatmap. Defaults to 100.
+            kernel (int): Max pooling kernel for extract local maximum pixels.
+               Defaults to 3.
+
+        Returns:
+            tuple[Tensor]: Decoded output of CenterNetHead, containing
+               the following Tensors:
+
+              - batch_bboxes (Tensor): Coords of each box with shape (B, k, 5)
+              - batch_topk_labels (Tensor): Categories of each box with \
+                  shape (B, k)
+        """
+        height, width = center_heatmap_pred.shape[2:]
+        inp_h, inp_w = img_shape
+
+        center_heatmap_pred = get_local_maximum(
+            center_heatmap_pred, kernel=kernel)
+
+        *batch_dets, topk_ys, topk_xs = get_topk_from_heatmap(
+            center_heatmap_pred, k=k)
+        batch_scores, batch_index, batch_topk_labels = batch_dets
+
+        wh = transpose_and_gather_feat(wh_pred, batch_index)
+        offset = transpose_and_gather_feat(offset_pred, batch_index)
+        topk_xs = topk_xs + offset[..., 0]
+        topk_ys = topk_ys + offset[..., 1]
+        tl_x = (topk_xs - wh[..., 0] / 2) * (inp_w / width)
+        tl_y = (topk_ys - wh[..., 1] / 2) * (inp_h / height)
+        br_x = (topk_xs + wh[..., 0] / 2) * (inp_w / width)
+        br_y = (topk_ys + wh[..., 1] / 2) * (inp_h / height)
+
+        batch_bboxes = torch.stack([tl_x, tl_y, br_x, br_y], dim=2)
+        batch_bboxes = torch.cat((batch_bboxes, batch_scores[..., None]),
+                                 dim=-1)
+        return batch_bboxes, batch_topk_labels
+
+    def _bboxes_nms(self, bboxes: Tensor, labels: Tensor,
+                    cfg: ConfigDict) -> Tuple[Tensor, Tensor]:
+        """bboxes nms."""
+        if labels.numel() > 0:
+            max_num = cfg.max_per_img
+            bboxes, keep = batched_nms(bboxes[:, :4], bboxes[:,
+                                                             -1].contiguous(),
+                                       labels, cfg.nms)
+            if max_num > 0:
+                bboxes = bboxes[:max_num]
+                labels = labels[keep][:max_num]
+
+        return bboxes, labels
diff --git a/mmdetection/mmdet/models/dense_heads/centernet_update_head.py b/mmdetection/mmdet/models/dense_heads/centernet_update_head.py
new file mode 100644
index 00000000..00cfcb89
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/centernet_update_head.py
@@ -0,0 +1,624 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, List, Optional, Sequence, Tuple
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import Scale
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures.bbox import bbox2distance
+from mmdet.utils import (ConfigType, InstanceList, OptConfigType,
+                         OptInstanceList, reduce_mean)
+from ..utils import multi_apply
+from .anchor_free_head import AnchorFreeHead
+
+INF = 1000000000
+RangeType = Sequence[Tuple[int, int]]
+
+
+def _transpose(tensor_list: List[Tensor],
+               num_point_list: list) -> List[Tensor]:
+    """This function is used to transpose image first tensors to level first
+    ones."""
+    for img_idx in range(len(tensor_list)):
+        tensor_list[img_idx] = torch.split(
+            tensor_list[img_idx], num_point_list, dim=0)
+
+    tensors_level_first = []
+    for targets_per_level in zip(*tensor_list):
+        tensors_level_first.append(torch.cat(targets_per_level, dim=0))
+    return tensors_level_first
+
+
+@MODELS.register_module()
+class CenterNetUpdateHead(AnchorFreeHead):
+    """CenterNetUpdateHead is an improved version of CenterNet in CenterNet2.
+    Paper link ``_.
+
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (int): Number of channel in the input feature map.
+        regress_ranges (Sequence[Tuple[int, int]]): Regress range of multiple
+            level points.
+        hm_min_radius (int): Heatmap target minimum radius of cls branch.
+            Defaults to 4.
+        hm_min_overlap (float): Heatmap target minimum overlap of cls branch.
+            Defaults to 0.8.
+        more_pos_thresh (float): The filtering threshold when the cls branch
+            adds more positive samples. Defaults to 0.2.
+        more_pos_topk (int): The maximum number of additional positive samples
+            added to each gt. Defaults to 9.
+        soft_weight_on_reg (bool): Whether to use the soft target of the
+            cls branch as the soft weight of the bbox branch.
+            Defaults to False.
+        loss_cls (:obj:`ConfigDict` or dict): Config of cls loss. Defaults to
+            dict(type='GaussianFocalLoss', loss_weight=1.0)
+        loss_bbox (:obj:`ConfigDict` or dict): Config of bbox loss. Defaults to
+             dict(type='GIoULoss', loss_weight=2.0).
+        norm_cfg (:obj:`ConfigDict` or dict, optional): dictionary to construct
+            and config norm layer.  Defaults to
+            ``norm_cfg=dict(type='GN', num_groups=32, requires_grad=True)``.
+        train_cfg (:obj:`ConfigDict` or dict, optional): Training config.
+            Unused in CenterNet. Reserved for compatibility with
+            SingleStageDetector.
+        test_cfg (:obj:`ConfigDict` or dict, optional): Testing config
+            of CenterNet.
+    """
+
+    def __init__(self,
+                 num_classes: int,
+                 in_channels: int,
+                 regress_ranges: RangeType = ((0, 80), (64, 160), (128, 320),
+                                              (256, 640), (512, INF)),
+                 hm_min_radius: int = 4,
+                 hm_min_overlap: float = 0.8,
+                 more_pos_thresh: float = 0.2,
+                 more_pos_topk: int = 9,
+                 soft_weight_on_reg: bool = False,
+                 loss_cls: ConfigType = dict(
+                     type='GaussianFocalLoss',
+                     pos_weight=0.25,
+                     neg_weight=0.75,
+                     loss_weight=1.0),
+                 loss_bbox: ConfigType = dict(
+                     type='GIoULoss', loss_weight=2.0),
+                 norm_cfg: OptConfigType = dict(
+                     type='GN', num_groups=32, requires_grad=True),
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 **kwargs) -> None:
+        super().__init__(
+            num_classes=num_classes,
+            in_channels=in_channels,
+            loss_cls=loss_cls,
+            loss_bbox=loss_bbox,
+            norm_cfg=norm_cfg,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            **kwargs)
+        self.soft_weight_on_reg = soft_weight_on_reg
+        self.hm_min_radius = hm_min_radius
+        self.more_pos_thresh = more_pos_thresh
+        self.more_pos_topk = more_pos_topk
+        self.delta = (1 - hm_min_overlap) / (1 + hm_min_overlap)
+        self.sigmoid_clamp = 0.0001
+
+        # GaussianFocalLoss must be sigmoid mode
+        self.use_sigmoid_cls = True
+        self.cls_out_channels = num_classes
+
+        self.regress_ranges = regress_ranges
+        self.scales = nn.ModuleList([Scale(1.0) for _ in self.strides])
+
+    def _init_predictor(self) -> None:
+        """Initialize predictor layers of the head."""
+        self.conv_cls = nn.Conv2d(
+            self.feat_channels, self.num_classes, 3, padding=1)
+        self.conv_reg = nn.Conv2d(self.feat_channels, 4, 3, padding=1)
+
+    def forward(self, x: Tuple[Tensor]) -> Tuple[List[Tensor], List[Tensor]]:
+        """Forward features from the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple: A tuple of each level outputs.
+
+            - cls_scores (list[Tensor]): Box scores for each scale level, \
+            each is a 4D-tensor, the channel number is num_classes.
+            - bbox_preds (list[Tensor]): Box energies / deltas for each \
+            scale level, each is a 4D-tensor, the channel number is 4.
+        """
+        return multi_apply(self.forward_single, x, self.scales, self.strides)
+
+    def forward_single(self, x: Tensor, scale: Scale,
+                       stride: int) -> Tuple[Tensor, Tensor]:
+        """Forward features of a single scale level.
+
+        Args:
+            x (Tensor): FPN feature maps of the specified stride.
+            scale (:obj:`mmcv.cnn.Scale`): Learnable scale module to resize
+                the bbox prediction.
+            stride (int): The corresponding stride for feature maps.
+
+        Returns:
+            tuple: scores for each class, bbox predictions of
+            input feature maps.
+        """
+        cls_score, bbox_pred, _, _ = super().forward_single(x)
+        # scale the bbox_pred of different level
+        # float to avoid overflow when enabling FP16
+        bbox_pred = scale(bbox_pred).float()
+        # bbox_pred needed for gradient computation has been modified
+        # by F.relu(bbox_pred) when run with PyTorch 1.10. So replace
+        # F.relu(bbox_pred) with bbox_pred.clamp(min=0)
+        bbox_pred = bbox_pred.clamp(min=0)
+        if not self.training:
+            bbox_pred *= stride
+        return cls_score, bbox_pred
+
+    def loss_by_feat(
+        self,
+        cls_scores: List[Tensor],
+        bbox_preds: List[Tensor],
+        batch_gt_instances: InstanceList,
+        batch_img_metas: List[dict],
+        batch_gt_instances_ignore: OptInstanceList = None
+    ) -> Dict[str, Tensor]:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level,
+                each is a 4D-tensor, the channel number is num_classes.
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level, each is a 4D-tensor, the channel number is 4.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        num_imgs = cls_scores[0].size(0)
+        assert len(cls_scores) == len(bbox_preds)
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        all_level_points = self.prior_generator.grid_priors(
+            featmap_sizes,
+            dtype=bbox_preds[0].dtype,
+            device=bbox_preds[0].device)
+
+        # 1 flatten outputs
+        flatten_cls_scores = [
+            cls_score.permute(0, 2, 3, 1).reshape(-1, self.cls_out_channels)
+            for cls_score in cls_scores
+        ]
+        flatten_bbox_preds = [
+            bbox_pred.permute(0, 2, 3, 1).reshape(-1, 4)
+            for bbox_pred in bbox_preds
+        ]
+        flatten_cls_scores = torch.cat(flatten_cls_scores)
+        flatten_bbox_preds = torch.cat(flatten_bbox_preds)
+
+        # repeat points to align with bbox_preds
+        flatten_points = torch.cat(
+            [points.repeat(num_imgs, 1) for points in all_level_points])
+
+        assert (torch.isfinite(flatten_bbox_preds).all().item())
+
+        # 2 calc reg and cls branch targets
+        cls_targets, bbox_targets = self.get_targets(all_level_points,
+                                                     batch_gt_instances)
+
+        # 3 add more pos index for cls branch
+        featmap_sizes = flatten_points.new_tensor(featmap_sizes)
+        pos_inds, cls_labels = self.add_cls_pos_inds(flatten_points,
+                                                     flatten_bbox_preds,
+                                                     featmap_sizes,
+                                                     batch_gt_instances)
+
+        # 4 calc cls loss
+        if pos_inds is None:
+            # num_gts=0
+            num_pos_cls = bbox_preds[0].new_tensor(0, dtype=torch.float)
+        else:
+            num_pos_cls = bbox_preds[0].new_tensor(
+                len(pos_inds), dtype=torch.float)
+        num_pos_cls = max(reduce_mean(num_pos_cls), 1.0)
+        flatten_cls_scores = flatten_cls_scores.sigmoid().clamp(
+            min=self.sigmoid_clamp, max=1 - self.sigmoid_clamp)
+        cls_loss = self.loss_cls(
+            flatten_cls_scores,
+            cls_targets,
+            pos_inds=pos_inds,
+            pos_labels=cls_labels,
+            avg_factor=num_pos_cls)
+
+        # 5 calc reg loss
+        pos_bbox_inds = torch.nonzero(
+            bbox_targets.max(dim=1)[0] >= 0).squeeze(1)
+        pos_bbox_preds = flatten_bbox_preds[pos_bbox_inds]
+        pos_bbox_targets = bbox_targets[pos_bbox_inds]
+
+        bbox_weight_map = cls_targets.max(dim=1)[0]
+        bbox_weight_map = bbox_weight_map[pos_bbox_inds]
+        bbox_weight_map = bbox_weight_map if self.soft_weight_on_reg \
+            else torch.ones_like(bbox_weight_map)
+        num_pos_bbox = max(reduce_mean(bbox_weight_map.sum()), 1.0)
+
+        if len(pos_bbox_inds) > 0:
+            pos_points = flatten_points[pos_bbox_inds]
+            pos_decoded_bbox_preds = self.bbox_coder.decode(
+                pos_points, pos_bbox_preds)
+            pos_decoded_target_preds = self.bbox_coder.decode(
+                pos_points, pos_bbox_targets)
+            bbox_loss = self.loss_bbox(
+                pos_decoded_bbox_preds,
+                pos_decoded_target_preds,
+                weight=bbox_weight_map,
+                avg_factor=num_pos_bbox)
+        else:
+            bbox_loss = flatten_bbox_preds.sum() * 0
+
+        return dict(loss_cls=cls_loss, loss_bbox=bbox_loss)
+
+    def get_targets(
+        self,
+        points: List[Tensor],
+        batch_gt_instances: InstanceList,
+    ) -> Tuple[Tensor, Tensor]:
+        """Compute classification and bbox targets for points in multiple
+        images.
+
+        Args:
+            points (list[Tensor]): Points of each fpn level, each has shape
+                (num_points, 2).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+
+        Returns:
+            tuple: Targets of each level.
+
+            - concat_lvl_labels (Tensor): Labels of all level and batch.
+            - concat_lvl_bbox_targets (Tensor): BBox targets of all \
+            level and batch.
+        """
+        assert len(points) == len(self.regress_ranges)
+
+        num_levels = len(points)
+        # the number of points per img, per lvl
+        num_points = [center.size(0) for center in points]
+
+        # expand regress ranges to align with points
+        expanded_regress_ranges = [
+            points[i].new_tensor(self.regress_ranges[i])[None].expand_as(
+                points[i]) for i in range(num_levels)
+        ]
+        # concat all levels points and regress ranges
+        concat_regress_ranges = torch.cat(expanded_regress_ranges, dim=0)
+        concat_points = torch.cat(points, dim=0)
+        concat_strides = torch.cat([
+            concat_points.new_ones(num_points[i]) * self.strides[i]
+            for i in range(num_levels)
+        ])
+
+        # get labels and bbox_targets of each image
+        cls_targets_list, bbox_targets_list = multi_apply(
+            self._get_targets_single,
+            batch_gt_instances,
+            points=concat_points,
+            regress_ranges=concat_regress_ranges,
+            strides=concat_strides)
+
+        bbox_targets_list = _transpose(bbox_targets_list, num_points)
+        cls_targets_list = _transpose(cls_targets_list, num_points)
+        concat_lvl_bbox_targets = torch.cat(bbox_targets_list, 0)
+        concat_lvl_cls_targets = torch.cat(cls_targets_list, dim=0)
+        return concat_lvl_cls_targets, concat_lvl_bbox_targets
+
+    def _get_targets_single(self, gt_instances: InstanceData, points: Tensor,
+                            regress_ranges: Tensor,
+                            strides: Tensor) -> Tuple[Tensor, Tensor]:
+        """Compute classification and bbox targets for a single image."""
+        num_points = points.size(0)
+        num_gts = len(gt_instances)
+        gt_bboxes = gt_instances.bboxes
+        gt_labels = gt_instances.labels
+
+        if num_gts == 0:
+            return gt_labels.new_full((num_points,
+                                       self.num_classes),
+                                      self.num_classes), \
+                   gt_bboxes.new_full((num_points, 4), -1)
+
+        # Calculate the regression tblr target corresponding to all points
+        points = points[:, None].expand(num_points, num_gts, 2)
+        gt_bboxes = gt_bboxes[None].expand(num_points, num_gts, 4)
+        strides = strides[:, None, None].expand(num_points, num_gts, 2)
+
+        bbox_target = bbox2distance(points, gt_bboxes)  # M x N x 4
+
+        # condition1: inside a gt bbox
+        inside_gt_bbox_mask = bbox_target.min(dim=2)[0] > 0  # M x N
+
+        # condition2: Calculate the nearest points from
+        # the upper, lower, left and right ranges from
+        # the center of the gt bbox
+        centers = ((gt_bboxes[..., [0, 1]] + gt_bboxes[..., [2, 3]]) / 2)
+        centers_discret = ((centers / strides).int() * strides).float() + \
+            strides / 2
+
+        centers_discret_dist = points - centers_discret
+        dist_x = centers_discret_dist[..., 0].abs()
+        dist_y = centers_discret_dist[..., 1].abs()
+        inside_gt_center3x3_mask = (dist_x <= strides[..., 0]) & \
+                                   (dist_y <= strides[..., 0])
+
+        # condition3: limit the regression range for each location
+        bbox_target_wh = bbox_target[..., :2] + bbox_target[..., 2:]
+        crit = (bbox_target_wh**2).sum(dim=2)**0.5 / 2
+        inside_fpn_level_mask = (crit >= regress_ranges[:, [0]]) & \
+                                (crit <= regress_ranges[:, [1]])
+        bbox_target_mask = inside_gt_bbox_mask & \
+            inside_gt_center3x3_mask & \
+            inside_fpn_level_mask
+
+        # Calculate the distance weight map
+        gt_center_peak_mask = ((centers_discret_dist**2).sum(dim=2) == 0)
+        weighted_dist = ((points - centers)**2).sum(dim=2)  # M x N
+        weighted_dist[gt_center_peak_mask] = 0
+
+        areas = (gt_bboxes[..., 2] - gt_bboxes[..., 0]) * (
+            gt_bboxes[..., 3] - gt_bboxes[..., 1])
+        radius = self.delta**2 * 2 * areas
+        radius = torch.clamp(radius, min=self.hm_min_radius**2)
+        weighted_dist = weighted_dist / radius
+
+        # Calculate bbox_target
+        bbox_weighted_dist = weighted_dist.clone()
+        bbox_weighted_dist[bbox_target_mask == 0] = INF * 1.0
+        min_dist, min_inds = bbox_weighted_dist.min(dim=1)
+        bbox_target = bbox_target[range(len(bbox_target)),
+                                  min_inds]  # M x N x 4 --> M x 4
+        bbox_target[min_dist == INF] = -INF
+
+        # Convert to feature map scale
+        bbox_target /= strides[:, 0, :].repeat(1, 2)
+
+        # Calculate cls_target
+        cls_target = self._create_heatmaps_from_dist(weighted_dist, gt_labels)
+
+        return cls_target, bbox_target
+
+    @torch.no_grad()
+    def add_cls_pos_inds(
+        self, flatten_points: Tensor, flatten_bbox_preds: Tensor,
+        featmap_sizes: Tensor, batch_gt_instances: InstanceList
+    ) -> Tuple[Optional[Tensor], Optional[Tensor]]:
+        """Provide additional adaptive positive samples to the classification
+        branch.
+
+        Args:
+            flatten_points (Tensor): The point after flatten, including
+                batch image and all levels. The shape is (N, 2).
+            flatten_bbox_preds (Tensor): The bbox predicts after flatten,
+                including batch image and all levels. The shape is (N, 4).
+            featmap_sizes (Tensor): Feature map size of all layers.
+                The shape is (5, 2).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+
+        Returns:
+           tuple:
+
+           - pos_inds (Tensor): Adaptively selected positive sample index.
+           - cls_labels (Tensor): Corresponding positive class label.
+        """
+        outputs = self._get_center3x3_region_index_targets(
+            batch_gt_instances, featmap_sizes)
+        cls_labels, fpn_level_masks, center3x3_inds, \
+            center3x3_bbox_targets, center3x3_masks = outputs
+
+        num_gts, total_level, K = cls_labels.shape[0], len(
+            self.strides), center3x3_masks.shape[-1]
+
+        if num_gts == 0:
+            return None, None
+
+        # The out-of-bounds index is forcibly set to 0
+        # to prevent loss calculation errors
+        center3x3_inds[center3x3_masks == 0] = 0
+        reg_pred_center3x3 = flatten_bbox_preds[center3x3_inds]
+        center3x3_points = flatten_points[center3x3_inds].view(-1, 2)
+
+        center3x3_bbox_targets_expand = center3x3_bbox_targets.view(
+            -1, 4).clamp(min=0)
+
+        pos_decoded_bbox_preds = self.bbox_coder.decode(
+            center3x3_points, reg_pred_center3x3.view(-1, 4))
+        pos_decoded_target_preds = self.bbox_coder.decode(
+            center3x3_points, center3x3_bbox_targets_expand)
+        center3x3_bbox_loss = self.loss_bbox(
+            pos_decoded_bbox_preds,
+            pos_decoded_target_preds,
+            None,
+            reduction_override='none').view(num_gts, total_level,
+                                            K) / self.loss_bbox.loss_weight
+
+        # Invalid index Loss set to infinity
+        center3x3_bbox_loss[center3x3_masks == 0] = INF
+
+        # 4 is the center point of the sampled 9 points, the center point
+        # of gt bbox after discretization.
+        # The center point of gt bbox after discretization
+        # must be a positive sample, so we force its loss to be set to 0.
+        center3x3_bbox_loss.view(-1, K)[fpn_level_masks.view(-1), 4] = 0
+        center3x3_bbox_loss = center3x3_bbox_loss.view(num_gts, -1)
+
+        loss_thr = torch.kthvalue(
+            center3x3_bbox_loss, self.more_pos_topk, dim=1)[0]
+
+        loss_thr[loss_thr > self.more_pos_thresh] = self.more_pos_thresh
+        new_pos = center3x3_bbox_loss < loss_thr.view(num_gts, 1)
+        pos_inds = center3x3_inds.view(num_gts, -1)[new_pos]
+        cls_labels = cls_labels.view(num_gts,
+                                     1).expand(num_gts,
+                                               total_level * K)[new_pos]
+        return pos_inds, cls_labels
+
+    def _create_heatmaps_from_dist(self, weighted_dist: Tensor,
+                                   cls_labels: Tensor) -> Tensor:
+        """Generate heatmaps of classification branch based on weighted
+        distance map."""
+        heatmaps = weighted_dist.new_zeros(
+            (weighted_dist.shape[0], self.num_classes))
+        for c in range(self.num_classes):
+            inds = (cls_labels == c)  # N
+            if inds.int().sum() == 0:
+                continue
+            heatmaps[:, c] = torch.exp(-weighted_dist[:, inds].min(dim=1)[0])
+            zeros = heatmaps[:, c] < 1e-4
+            heatmaps[zeros, c] = 0
+        return heatmaps
+
+    def _get_center3x3_region_index_targets(self,
+                                            bacth_gt_instances: InstanceList,
+                                            shapes_per_level: Tensor) -> tuple:
+        """Get the center (and the 3x3 region near center) locations and target
+        of each objects."""
+        cls_labels = []
+        inside_fpn_level_masks = []
+        center3x3_inds = []
+        center3x3_masks = []
+        center3x3_bbox_targets = []
+
+        total_levels = len(self.strides)
+        batch = len(bacth_gt_instances)
+
+        shapes_per_level = shapes_per_level.long()
+        area_per_level = (shapes_per_level[:, 0] * shapes_per_level[:, 1])
+
+        # Select a total of 9 positions of 3x3 in the center of the gt bbox
+        # as candidate positive samples
+        K = 9
+        dx = shapes_per_level.new_tensor([-1, 0, 1, -1, 0, 1, -1, 0,
+                                          1]).view(1, 1, K)
+        dy = shapes_per_level.new_tensor([-1, -1, -1, 0, 0, 0, 1, 1,
+                                          1]).view(1, 1, K)
+
+        regress_ranges = shapes_per_level.new_tensor(self.regress_ranges).view(
+            len(self.regress_ranges), 2)  # L x 2
+        strides = shapes_per_level.new_tensor(self.strides)
+
+        start_coord_pre_level = []
+        _start = 0
+        for level in range(total_levels):
+            start_coord_pre_level.append(_start)
+            _start = _start + batch * area_per_level[level]
+        start_coord_pre_level = shapes_per_level.new_tensor(
+            start_coord_pre_level).view(1, total_levels, 1)
+        area_per_level = area_per_level.view(1, total_levels, 1)
+
+        for im_i in range(batch):
+            gt_instance = bacth_gt_instances[im_i]
+            gt_bboxes = gt_instance.bboxes
+            gt_labels = gt_instance.labels
+            num_gts = gt_bboxes.shape[0]
+            if num_gts == 0:
+                continue
+
+            cls_labels.append(gt_labels)
+
+            gt_bboxes = gt_bboxes[:, None].expand(num_gts, total_levels, 4)
+            expanded_strides = strides[None, :,
+                                       None].expand(num_gts, total_levels, 2)
+            expanded_regress_ranges = regress_ranges[None].expand(
+                num_gts, total_levels, 2)
+            expanded_shapes_per_level = shapes_per_level[None].expand(
+                num_gts, total_levels, 2)
+
+            # calc reg_target
+            centers = ((gt_bboxes[..., [0, 1]] + gt_bboxes[..., [2, 3]]) / 2)
+            centers_inds = (centers / expanded_strides).long()
+            centers_discret = centers_inds * expanded_strides \
+                + expanded_strides // 2
+
+            bbox_target = bbox2distance(centers_discret,
+                                        gt_bboxes)  # M x N x 4
+
+            # calc inside_fpn_level_mask
+            bbox_target_wh = bbox_target[..., :2] + bbox_target[..., 2:]
+            crit = (bbox_target_wh**2).sum(dim=2)**0.5 / 2
+            inside_fpn_level_mask = \
+                (crit >= expanded_regress_ranges[..., 0]) & \
+                (crit <= expanded_regress_ranges[..., 1])
+
+            inside_gt_bbox_mask = bbox_target.min(dim=2)[0] >= 0
+            inside_fpn_level_mask = inside_gt_bbox_mask & inside_fpn_level_mask
+            inside_fpn_level_masks.append(inside_fpn_level_mask)
+
+            # calc center3x3_ind and mask
+            expand_ws = expanded_shapes_per_level[..., 1:2].expand(
+                num_gts, total_levels, K)
+            expand_hs = expanded_shapes_per_level[..., 0:1].expand(
+                num_gts, total_levels, K)
+            centers_inds_x = centers_inds[..., 0:1]
+            centers_inds_y = centers_inds[..., 1:2]
+
+            center3x3_idx = start_coord_pre_level + \
+                im_i * area_per_level + \
+                (centers_inds_y + dy) * expand_ws + \
+                (centers_inds_x + dx)
+            center3x3_mask = \
+                ((centers_inds_y + dy) < expand_hs) & \
+                ((centers_inds_y + dy) >= 0) & \
+                ((centers_inds_x + dx) < expand_ws) & \
+                ((centers_inds_x + dx) >= 0)
+
+            # recalc center3x3 region reg target
+            bbox_target = bbox_target / expanded_strides.repeat(1, 1, 2)
+            center3x3_bbox_target = bbox_target[..., None, :].expand(
+                num_gts, total_levels, K, 4).clone()
+            center3x3_bbox_target[..., 0] += dx
+            center3x3_bbox_target[..., 1] += dy
+            center3x3_bbox_target[..., 2] -= dx
+            center3x3_bbox_target[..., 3] -= dy
+            # update center3x3_mask
+            center3x3_mask = center3x3_mask & (
+                center3x3_bbox_target.min(dim=3)[0] >= 0)  # n x L x K
+
+            center3x3_inds.append(center3x3_idx)
+            center3x3_masks.append(center3x3_mask)
+            center3x3_bbox_targets.append(center3x3_bbox_target)
+
+        if len(inside_fpn_level_masks) > 0:
+            cls_labels = torch.cat(cls_labels, dim=0)
+            inside_fpn_level_masks = torch.cat(inside_fpn_level_masks, dim=0)
+            center3x3_inds = torch.cat(center3x3_inds, dim=0).long()
+            center3x3_bbox_targets = torch.cat(center3x3_bbox_targets, dim=0)
+            center3x3_masks = torch.cat(center3x3_masks, dim=0)
+        else:
+            cls_labels = shapes_per_level.new_zeros(0).long()
+            inside_fpn_level_masks = shapes_per_level.new_zeros(
+                (0, total_levels)).bool()
+            center3x3_inds = shapes_per_level.new_zeros(
+                (0, total_levels, K)).long()
+            center3x3_bbox_targets = shapes_per_level.new_zeros(
+                (0, total_levels, K, 4)).float()
+            center3x3_masks = shapes_per_level.new_zeros(
+                (0, total_levels, K)).bool()
+        return cls_labels, inside_fpn_level_masks, center3x3_inds, \
+            center3x3_bbox_targets, center3x3_masks
diff --git a/mmdetection/mmdet/models/dense_heads/centripetal_head.py b/mmdetection/mmdet/models/dense_heads/centripetal_head.py
new file mode 100644
index 00000000..18f6601f
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/centripetal_head.py
@@ -0,0 +1,459 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Tuple
+
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmcv.ops import DeformConv2d
+from mmengine.model import normal_init
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import (ConfigType, InstanceList, OptInstanceList,
+                         OptMultiConfig)
+from ..utils import multi_apply
+from .corner_head import CornerHead
+
+
+@MODELS.register_module()
+class CentripetalHead(CornerHead):
+    """Head of CentripetalNet: Pursuing High-quality Keypoint Pairs for Object
+    Detection.
+
+    CentripetalHead inherits from :class:`CornerHead`. It removes the
+    embedding branch and adds guiding shift and centripetal shift branches.
+    More details can be found in the `paper
+    `_ .
+
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (int): Number of channels in the input feature map.
+        num_feat_levels (int): Levels of feature from the previous module.
+            2 for HourglassNet-104 and 1 for HourglassNet-52. HourglassNet-104
+            outputs the final feature and intermediate supervision feature and
+            HourglassNet-52 only outputs the final feature. Defaults to 2.
+        corner_emb_channels (int): Channel of embedding vector. Defaults to 1.
+        train_cfg (:obj:`ConfigDict` or dict, optional): Training config.
+            Useless in CornerHead, but we keep this variable for
+            SingleStageDetector.
+        test_cfg (:obj:`ConfigDict` or dict, optional): Testing config of
+            CornerHead.
+        loss_heatmap (:obj:`ConfigDict` or dict): Config of corner heatmap
+            loss. Defaults to GaussianFocalLoss.
+        loss_embedding (:obj:`ConfigDict` or dict): Config of corner embedding
+            loss. Defaults to AssociativeEmbeddingLoss.
+        loss_offset (:obj:`ConfigDict` or dict): Config of corner offset loss.
+            Defaults to SmoothL1Loss.
+        loss_guiding_shift (:obj:`ConfigDict` or dict): Config of
+            guiding shift loss. Defaults to SmoothL1Loss.
+        loss_centripetal_shift (:obj:`ConfigDict` or dict): Config of
+            centripetal shift loss. Defaults to SmoothL1Loss.
+       init_cfg (:obj:`ConfigDict` or dict, optional): the config to control
+           the initialization.
+    """
+
+    def __init__(self,
+                 *args,
+                 centripetal_shift_channels: int = 2,
+                 guiding_shift_channels: int = 2,
+                 feat_adaption_conv_kernel: int = 3,
+                 loss_guiding_shift: ConfigType = dict(
+                     type='SmoothL1Loss', beta=1.0, loss_weight=0.05),
+                 loss_centripetal_shift: ConfigType = dict(
+                     type='SmoothL1Loss', beta=1.0, loss_weight=1),
+                 init_cfg: OptMultiConfig = None,
+                 **kwargs) -> None:
+        assert init_cfg is None, 'To prevent abnormal initialization ' \
+                                 'behavior, init_cfg is not allowed to be set'
+        assert centripetal_shift_channels == 2, (
+            'CentripetalHead only support centripetal_shift_channels == 2')
+        self.centripetal_shift_channels = centripetal_shift_channels
+        assert guiding_shift_channels == 2, (
+            'CentripetalHead only support guiding_shift_channels == 2')
+        self.guiding_shift_channels = guiding_shift_channels
+        self.feat_adaption_conv_kernel = feat_adaption_conv_kernel
+        super().__init__(*args, init_cfg=init_cfg, **kwargs)
+        self.loss_guiding_shift = MODELS.build(loss_guiding_shift)
+        self.loss_centripetal_shift = MODELS.build(loss_centripetal_shift)
+
+    def _init_centripetal_layers(self) -> None:
+        """Initialize centripetal layers.
+
+        Including feature adaption deform convs (feat_adaption), deform offset
+        prediction convs (dcn_off), guiding shift (guiding_shift) and
+        centripetal shift ( centripetal_shift). Each branch has two parts:
+        prefix `tl_` for top-left and `br_` for bottom-right.
+        """
+        self.tl_feat_adaption = nn.ModuleList()
+        self.br_feat_adaption = nn.ModuleList()
+        self.tl_dcn_offset = nn.ModuleList()
+        self.br_dcn_offset = nn.ModuleList()
+        self.tl_guiding_shift = nn.ModuleList()
+        self.br_guiding_shift = nn.ModuleList()
+        self.tl_centripetal_shift = nn.ModuleList()
+        self.br_centripetal_shift = nn.ModuleList()
+
+        for _ in range(self.num_feat_levels):
+            self.tl_feat_adaption.append(
+                DeformConv2d(self.in_channels, self.in_channels,
+                             self.feat_adaption_conv_kernel, 1, 1))
+            self.br_feat_adaption.append(
+                DeformConv2d(self.in_channels, self.in_channels,
+                             self.feat_adaption_conv_kernel, 1, 1))
+
+            self.tl_guiding_shift.append(
+                self._make_layers(
+                    out_channels=self.guiding_shift_channels,
+                    in_channels=self.in_channels))
+            self.br_guiding_shift.append(
+                self._make_layers(
+                    out_channels=self.guiding_shift_channels,
+                    in_channels=self.in_channels))
+
+            self.tl_dcn_offset.append(
+                ConvModule(
+                    self.guiding_shift_channels,
+                    self.feat_adaption_conv_kernel**2 *
+                    self.guiding_shift_channels,
+                    1,
+                    bias=False,
+                    act_cfg=None))
+            self.br_dcn_offset.append(
+                ConvModule(
+                    self.guiding_shift_channels,
+                    self.feat_adaption_conv_kernel**2 *
+                    self.guiding_shift_channels,
+                    1,
+                    bias=False,
+                    act_cfg=None))
+
+            self.tl_centripetal_shift.append(
+                self._make_layers(
+                    out_channels=self.centripetal_shift_channels,
+                    in_channels=self.in_channels))
+            self.br_centripetal_shift.append(
+                self._make_layers(
+                    out_channels=self.centripetal_shift_channels,
+                    in_channels=self.in_channels))
+
+    def _init_layers(self) -> None:
+        """Initialize layers for CentripetalHead.
+
+        Including two parts: CornerHead layers and CentripetalHead layers
+        """
+        super()._init_layers()  # using _init_layers in CornerHead
+        self._init_centripetal_layers()
+
+    def init_weights(self) -> None:
+        super().init_weights()
+        for i in range(self.num_feat_levels):
+            normal_init(self.tl_feat_adaption[i], std=0.01)
+            normal_init(self.br_feat_adaption[i], std=0.01)
+            normal_init(self.tl_dcn_offset[i].conv, std=0.1)
+            normal_init(self.br_dcn_offset[i].conv, std=0.1)
+            _ = [x.conv.reset_parameters() for x in self.tl_guiding_shift[i]]
+            _ = [x.conv.reset_parameters() for x in self.br_guiding_shift[i]]
+            _ = [
+                x.conv.reset_parameters() for x in self.tl_centripetal_shift[i]
+            ]
+            _ = [
+                x.conv.reset_parameters() for x in self.br_centripetal_shift[i]
+            ]
+
+    def forward_single(self, x: Tensor, lvl_ind: int) -> List[Tensor]:
+        """Forward feature of a single level.
+
+        Args:
+            x (Tensor): Feature of a single level.
+            lvl_ind (int): Level index of current feature.
+
+        Returns:
+            tuple[Tensor]: A tuple of CentripetalHead's output for current
+            feature level. Containing the following Tensors:
+
+                - tl_heat (Tensor): Predicted top-left corner heatmap.
+                - br_heat (Tensor): Predicted bottom-right corner heatmap.
+                - tl_off (Tensor): Predicted top-left offset heatmap.
+                - br_off (Tensor): Predicted bottom-right offset heatmap.
+                - tl_guiding_shift (Tensor): Predicted top-left guiding shift
+                  heatmap.
+                - br_guiding_shift (Tensor): Predicted bottom-right guiding
+                  shift heatmap.
+                - tl_centripetal_shift (Tensor): Predicted top-left centripetal
+                  shift heatmap.
+                - br_centripetal_shift (Tensor): Predicted bottom-right
+                  centripetal shift heatmap.
+        """
+        tl_heat, br_heat, _, _, tl_off, br_off, tl_pool, br_pool = super(
+        ).forward_single(
+            x, lvl_ind, return_pool=True)
+
+        tl_guiding_shift = self.tl_guiding_shift[lvl_ind](tl_pool)
+        br_guiding_shift = self.br_guiding_shift[lvl_ind](br_pool)
+
+        tl_dcn_offset = self.tl_dcn_offset[lvl_ind](tl_guiding_shift.detach())
+        br_dcn_offset = self.br_dcn_offset[lvl_ind](br_guiding_shift.detach())
+
+        tl_feat_adaption = self.tl_feat_adaption[lvl_ind](tl_pool,
+                                                          tl_dcn_offset)
+        br_feat_adaption = self.br_feat_adaption[lvl_ind](br_pool,
+                                                          br_dcn_offset)
+
+        tl_centripetal_shift = self.tl_centripetal_shift[lvl_ind](
+            tl_feat_adaption)
+        br_centripetal_shift = self.br_centripetal_shift[lvl_ind](
+            br_feat_adaption)
+
+        result_list = [
+            tl_heat, br_heat, tl_off, br_off, tl_guiding_shift,
+            br_guiding_shift, tl_centripetal_shift, br_centripetal_shift
+        ]
+        return result_list
+
+    def loss_by_feat(
+            self,
+            tl_heats: List[Tensor],
+            br_heats: List[Tensor],
+            tl_offs: List[Tensor],
+            br_offs: List[Tensor],
+            tl_guiding_shifts: List[Tensor],
+            br_guiding_shifts: List[Tensor],
+            tl_centripetal_shifts: List[Tensor],
+            br_centripetal_shifts: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> dict:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            tl_heats (list[Tensor]): Top-left corner heatmaps for each level
+                with shape (N, num_classes, H, W).
+            br_heats (list[Tensor]): Bottom-right corner heatmaps for each
+                level with shape (N, num_classes, H, W).
+            tl_offs (list[Tensor]): Top-left corner offsets for each level
+                with shape (N, corner_offset_channels, H, W).
+            br_offs (list[Tensor]): Bottom-right corner offsets for each level
+                with shape (N, corner_offset_channels, H, W).
+            tl_guiding_shifts (list[Tensor]): Top-left guiding shifts for each
+                level with shape (N, guiding_shift_channels, H, W).
+            br_guiding_shifts (list[Tensor]): Bottom-right guiding shifts for
+                each level with shape (N, guiding_shift_channels, H, W).
+            tl_centripetal_shifts (list[Tensor]): Top-left centripetal shifts
+                for each level with shape (N, centripetal_shift_channels, H,
+                W).
+            br_centripetal_shifts (list[Tensor]): Bottom-right centripetal
+                shifts for each level with shape (N,
+                centripetal_shift_channels, H, W).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Specify which bounding boxes can be ignored when computing
+                the loss.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components. Containing the
+            following losses:
+
+                - det_loss (list[Tensor]): Corner keypoint losses of all
+                  feature levels.
+                - off_loss (list[Tensor]): Corner offset losses of all feature
+                  levels.
+                - guiding_loss (list[Tensor]): Guiding shift losses of all
+                  feature levels.
+                - centripetal_loss (list[Tensor]): Centripetal shift losses of
+                  all feature levels.
+        """
+        gt_bboxes = [
+            gt_instances.bboxes for gt_instances in batch_gt_instances
+        ]
+        gt_labels = [
+            gt_instances.labels for gt_instances in batch_gt_instances
+        ]
+
+        targets = self.get_targets(
+            gt_bboxes,
+            gt_labels,
+            tl_heats[-1].shape,
+            batch_img_metas[0]['batch_input_shape'],
+            with_corner_emb=self.with_corner_emb,
+            with_guiding_shift=True,
+            with_centripetal_shift=True)
+        mlvl_targets = [targets for _ in range(self.num_feat_levels)]
+        [det_losses, off_losses, guiding_losses, centripetal_losses
+         ] = multi_apply(self.loss_by_feat_single, tl_heats, br_heats, tl_offs,
+                         br_offs, tl_guiding_shifts, br_guiding_shifts,
+                         tl_centripetal_shifts, br_centripetal_shifts,
+                         mlvl_targets)
+        loss_dict = dict(
+            det_loss=det_losses,
+            off_loss=off_losses,
+            guiding_loss=guiding_losses,
+            centripetal_loss=centripetal_losses)
+        return loss_dict
+
+    def loss_by_feat_single(self, tl_hmp: Tensor, br_hmp: Tensor,
+                            tl_off: Tensor, br_off: Tensor,
+                            tl_guiding_shift: Tensor, br_guiding_shift: Tensor,
+                            tl_centripetal_shift: Tensor,
+                            br_centripetal_shift: Tensor,
+                            targets: dict) -> Tuple[Tensor, ...]:
+        """Calculate the loss of a single scale level based on the features
+        extracted by the detection head.
+
+        Args:
+            tl_hmp (Tensor): Top-left corner heatmap for current level with
+                shape (N, num_classes, H, W).
+            br_hmp (Tensor): Bottom-right corner heatmap for current level with
+                shape (N, num_classes, H, W).
+            tl_off (Tensor): Top-left corner offset for current level with
+                shape (N, corner_offset_channels, H, W).
+            br_off (Tensor): Bottom-right corner offset for current level with
+                shape (N, corner_offset_channels, H, W).
+            tl_guiding_shift (Tensor): Top-left guiding shift for current level
+                with shape (N, guiding_shift_channels, H, W).
+            br_guiding_shift (Tensor): Bottom-right guiding shift for current
+                level with shape (N, guiding_shift_channels, H, W).
+            tl_centripetal_shift (Tensor): Top-left centripetal shift for
+                current level with shape (N, centripetal_shift_channels, H, W).
+            br_centripetal_shift (Tensor): Bottom-right centripetal shift for
+                current level with shape (N, centripetal_shift_channels, H, W).
+            targets (dict): Corner target generated by `get_targets`.
+
+        Returns:
+            tuple[torch.Tensor]: Losses of the head's different branches
+            containing the following losses:
+
+                - det_loss (Tensor): Corner keypoint loss.
+                - off_loss (Tensor): Corner offset loss.
+                - guiding_loss (Tensor): Guiding shift loss.
+                - centripetal_loss (Tensor): Centripetal shift loss.
+        """
+        targets['corner_embedding'] = None
+
+        det_loss, _, _, off_loss = super().loss_by_feat_single(
+            tl_hmp, br_hmp, None, None, tl_off, br_off, targets)
+
+        gt_tl_guiding_shift = targets['topleft_guiding_shift']
+        gt_br_guiding_shift = targets['bottomright_guiding_shift']
+        gt_tl_centripetal_shift = targets['topleft_centripetal_shift']
+        gt_br_centripetal_shift = targets['bottomright_centripetal_shift']
+
+        gt_tl_heatmap = targets['topleft_heatmap']
+        gt_br_heatmap = targets['bottomright_heatmap']
+        # We only compute the offset loss at the real corner position.
+        # The value of real corner would be 1 in heatmap ground truth.
+        # The mask is computed in class agnostic mode and its shape is
+        # batch * 1 * width * height.
+        tl_mask = gt_tl_heatmap.eq(1).sum(1).gt(0).unsqueeze(1).type_as(
+            gt_tl_heatmap)
+        br_mask = gt_br_heatmap.eq(1).sum(1).gt(0).unsqueeze(1).type_as(
+            gt_br_heatmap)
+
+        # Guiding shift loss
+        tl_guiding_loss = self.loss_guiding_shift(
+            tl_guiding_shift,
+            gt_tl_guiding_shift,
+            tl_mask,
+            avg_factor=tl_mask.sum())
+        br_guiding_loss = self.loss_guiding_shift(
+            br_guiding_shift,
+            gt_br_guiding_shift,
+            br_mask,
+            avg_factor=br_mask.sum())
+        guiding_loss = (tl_guiding_loss + br_guiding_loss) / 2.0
+        # Centripetal shift loss
+        tl_centripetal_loss = self.loss_centripetal_shift(
+            tl_centripetal_shift,
+            gt_tl_centripetal_shift,
+            tl_mask,
+            avg_factor=tl_mask.sum())
+        br_centripetal_loss = self.loss_centripetal_shift(
+            br_centripetal_shift,
+            gt_br_centripetal_shift,
+            br_mask,
+            avg_factor=br_mask.sum())
+        centripetal_loss = (tl_centripetal_loss + br_centripetal_loss) / 2.0
+
+        return det_loss, off_loss, guiding_loss, centripetal_loss
+
+    def predict_by_feat(self,
+                        tl_heats: List[Tensor],
+                        br_heats: List[Tensor],
+                        tl_offs: List[Tensor],
+                        br_offs: List[Tensor],
+                        tl_guiding_shifts: List[Tensor],
+                        br_guiding_shifts: List[Tensor],
+                        tl_centripetal_shifts: List[Tensor],
+                        br_centripetal_shifts: List[Tensor],
+                        batch_img_metas: Optional[List[dict]] = None,
+                        rescale: bool = False,
+                        with_nms: bool = True) -> InstanceList:
+        """Transform a batch of output features extracted from the head into
+        bbox results.
+
+        Args:
+            tl_heats (list[Tensor]): Top-left corner heatmaps for each level
+                with shape (N, num_classes, H, W).
+            br_heats (list[Tensor]): Bottom-right corner heatmaps for each
+                level with shape (N, num_classes, H, W).
+            tl_offs (list[Tensor]): Top-left corner offsets for each level
+                with shape (N, corner_offset_channels, H, W).
+            br_offs (list[Tensor]): Bottom-right corner offsets for each level
+                with shape (N, corner_offset_channels, H, W).
+            tl_guiding_shifts (list[Tensor]): Top-left guiding shifts for each
+                level with shape (N, guiding_shift_channels, H, W). Useless in
+                this function, we keep this arg because it's the raw output
+                from CentripetalHead.
+            br_guiding_shifts (list[Tensor]): Bottom-right guiding shifts for
+                each level with shape (N, guiding_shift_channels, H, W).
+                Useless in this function, we keep this arg because it's the
+                raw output from CentripetalHead.
+            tl_centripetal_shifts (list[Tensor]): Top-left centripetal shifts
+                for each level with shape (N, centripetal_shift_channels, H,
+                W).
+            br_centripetal_shifts (list[Tensor]): Bottom-right centripetal
+                shifts for each level with shape (N,
+                centripetal_shift_channels, H, W).
+            batch_img_metas (list[dict], optional): Batch image meta info.
+                Defaults to None.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            with_nms (bool): If True, do nms before return boxes.
+                Defaults to True.
+
+        Returns:
+            list[:obj:`InstanceData`]: Object detection results of each image
+            after the post process. Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        assert tl_heats[-1].shape[0] == br_heats[-1].shape[0] == len(
+            batch_img_metas)
+        result_list = []
+        for img_id in range(len(batch_img_metas)):
+            result_list.append(
+                self._predict_by_feat_single(
+                    tl_heats[-1][img_id:img_id + 1, :],
+                    br_heats[-1][img_id:img_id + 1, :],
+                    tl_offs[-1][img_id:img_id + 1, :],
+                    br_offs[-1][img_id:img_id + 1, :],
+                    batch_img_metas[img_id],
+                    tl_emb=None,
+                    br_emb=None,
+                    tl_centripetal_shift=tl_centripetal_shifts[-1][
+                        img_id:img_id + 1, :],
+                    br_centripetal_shift=br_centripetal_shifts[-1][
+                        img_id:img_id + 1, :],
+                    rescale=rescale,
+                    with_nms=with_nms))
+
+        return result_list
diff --git a/mmdetection/mmdet/models/dense_heads/condinst_head.py b/mmdetection/mmdet/models/dense_heads/condinst_head.py
new file mode 100644
index 00000000..35a25e63
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/condinst_head.py
@@ -0,0 +1,1226 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+from typing import Dict, List, Optional, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule, Scale
+from mmengine.config import ConfigDict
+from mmengine.model import BaseModule, kaiming_init
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures.bbox import cat_boxes
+from mmdet.utils import (ConfigType, InstanceList, MultiConfig, OptConfigType,
+                         OptInstanceList, reduce_mean)
+from ..task_modules.prior_generators import MlvlPointGenerator
+from ..utils import (aligned_bilinear, filter_scores_and_topk, multi_apply,
+                     relative_coordinate_maps, select_single_mlvl)
+from ..utils.misc import empty_instances
+from .base_mask_head import BaseMaskHead
+from .fcos_head import FCOSHead
+
+INF = 1e8
+
+
+@MODELS.register_module()
+class CondInstBboxHead(FCOSHead):
+    """CondInst box head used in https://arxiv.org/abs/1904.02689.
+
+    Note that CondInst Bbox Head is a extension of FCOS head.
+    Two differences are described as follows:
+
+    1. CondInst box head predicts a set of params for each instance.
+    2. CondInst box head return the pos_gt_inds and pos_inds.
+
+    Args:
+        num_params (int): Number of params for instance segmentation.
+    """
+
+    def __init__(self, *args, num_params: int = 169, **kwargs) -> None:
+        self.num_params = num_params
+        super().__init__(*args, **kwargs)
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        super()._init_layers()
+        self.controller = nn.Conv2d(
+            self.feat_channels, self.num_params, 3, padding=1)
+
+    def forward_single(self, x: Tensor, scale: Scale,
+                       stride: int) -> Tuple[Tensor, Tensor, Tensor, Tensor]:
+        """Forward features of a single scale level.
+
+        Args:
+            x (Tensor): FPN feature maps of the specified stride.
+            scale (:obj:`mmcv.cnn.Scale`): Learnable scale module to resize
+                the bbox prediction.
+            stride (int): The corresponding stride for feature maps, only
+                used to normalize the bbox prediction when self.norm_on_bbox
+                is True.
+
+        Returns:
+            tuple: scores for each class, bbox predictions, centerness
+            predictions and param predictions of input feature maps.
+        """
+        cls_score, bbox_pred, cls_feat, reg_feat = \
+            super(FCOSHead, self).forward_single(x)
+        if self.centerness_on_reg:
+            centerness = self.conv_centerness(reg_feat)
+        else:
+            centerness = self.conv_centerness(cls_feat)
+        # scale the bbox_pred of different level
+        # float to avoid overflow when enabling FP16
+        bbox_pred = scale(bbox_pred).float()
+        if self.norm_on_bbox:
+            # bbox_pred needed for gradient computation has been modified
+            # by F.relu(bbox_pred) when run with PyTorch 1.10. So replace
+            # F.relu(bbox_pred) with bbox_pred.clamp(min=0)
+            bbox_pred = bbox_pred.clamp(min=0)
+            if not self.training:
+                bbox_pred *= stride
+        else:
+            bbox_pred = bbox_pred.exp()
+        param_pred = self.controller(reg_feat)
+        return cls_score, bbox_pred, centerness, param_pred
+
+    def loss_by_feat(
+        self,
+        cls_scores: List[Tensor],
+        bbox_preds: List[Tensor],
+        centernesses: List[Tensor],
+        param_preds: List[Tensor],
+        batch_gt_instances: InstanceList,
+        batch_img_metas: List[dict],
+        batch_gt_instances_ignore: OptInstanceList = None
+    ) -> Dict[str, Tensor]:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level,
+                each is a 4D-tensor, the channel number is
+                num_points * num_classes.
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level, each is a 4D-tensor, the channel number is
+                num_points * 4.
+            centernesses (list[Tensor]): centerness for each scale level, each
+                is a 4D-tensor, the channel number is num_points * 1.
+            param_preds (List[Tensor]): param_pred for each scale level, each
+                is a 4D-tensor, the channel number is num_params.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], Optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        assert len(cls_scores) == len(bbox_preds) == len(centernesses)
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        # Need stride for rel coord compute
+        all_level_points_strides = self.prior_generator.grid_priors(
+            featmap_sizes,
+            dtype=bbox_preds[0].dtype,
+            device=bbox_preds[0].device,
+            with_stride=True)
+        all_level_points = [i[:, :2] for i in all_level_points_strides]
+        all_level_strides = [i[:, 2] for i in all_level_points_strides]
+        labels, bbox_targets, pos_inds_list, pos_gt_inds_list = \
+            self.get_targets(all_level_points, batch_gt_instances)
+
+        num_imgs = cls_scores[0].size(0)
+        # flatten cls_scores, bbox_preds and centerness
+        flatten_cls_scores = [
+            cls_score.permute(0, 2, 3, 1).reshape(-1, self.cls_out_channels)
+            for cls_score in cls_scores
+        ]
+        flatten_bbox_preds = [
+            bbox_pred.permute(0, 2, 3, 1).reshape(-1, 4)
+            for bbox_pred in bbox_preds
+        ]
+        flatten_centerness = [
+            centerness.permute(0, 2, 3, 1).reshape(-1)
+            for centerness in centernesses
+        ]
+        flatten_cls_scores = torch.cat(flatten_cls_scores)
+        flatten_bbox_preds = torch.cat(flatten_bbox_preds)
+        flatten_centerness = torch.cat(flatten_centerness)
+        flatten_labels = torch.cat(labels)
+        flatten_bbox_targets = torch.cat(bbox_targets)
+        # repeat points to align with bbox_preds
+        flatten_points = torch.cat(
+            [points.repeat(num_imgs, 1) for points in all_level_points])
+
+        # FG cat_id: [0, num_classes -1], BG cat_id: num_classes
+        bg_class_ind = self.num_classes
+        pos_inds = ((flatten_labels >= 0)
+                    & (flatten_labels < bg_class_ind)).nonzero().reshape(-1)
+        num_pos = torch.tensor(
+            len(pos_inds), dtype=torch.float, device=bbox_preds[0].device)
+        num_pos = max(reduce_mean(num_pos), 1.0)
+        loss_cls = self.loss_cls(
+            flatten_cls_scores, flatten_labels, avg_factor=num_pos)
+
+        pos_bbox_preds = flatten_bbox_preds[pos_inds]
+        pos_centerness = flatten_centerness[pos_inds]
+        pos_bbox_targets = flatten_bbox_targets[pos_inds]
+        pos_centerness_targets = self.centerness_target(pos_bbox_targets)
+        # centerness weighted iou loss
+        centerness_denorm = max(
+            reduce_mean(pos_centerness_targets.sum().detach()), 1e-6)
+
+        if len(pos_inds) > 0:
+            pos_points = flatten_points[pos_inds]
+            pos_decoded_bbox_preds = self.bbox_coder.decode(
+                pos_points, pos_bbox_preds)
+            pos_decoded_target_preds = self.bbox_coder.decode(
+                pos_points, pos_bbox_targets)
+            loss_bbox = self.loss_bbox(
+                pos_decoded_bbox_preds,
+                pos_decoded_target_preds,
+                weight=pos_centerness_targets,
+                avg_factor=centerness_denorm)
+            loss_centerness = self.loss_centerness(
+                pos_centerness, pos_centerness_targets, avg_factor=num_pos)
+        else:
+            loss_bbox = pos_bbox_preds.sum()
+            loss_centerness = pos_centerness.sum()
+
+        self._raw_positive_infos.update(cls_scores=cls_scores)
+        self._raw_positive_infos.update(centernesses=centernesses)
+        self._raw_positive_infos.update(param_preds=param_preds)
+        self._raw_positive_infos.update(all_level_points=all_level_points)
+        self._raw_positive_infos.update(all_level_strides=all_level_strides)
+        self._raw_positive_infos.update(pos_gt_inds_list=pos_gt_inds_list)
+        self._raw_positive_infos.update(pos_inds_list=pos_inds_list)
+
+        return dict(
+            loss_cls=loss_cls,
+            loss_bbox=loss_bbox,
+            loss_centerness=loss_centerness)
+
+    def get_targets(
+        self, points: List[Tensor], batch_gt_instances: InstanceList
+    ) -> Tuple[List[Tensor], List[Tensor], List[Tensor], List[Tensor]]:
+        """Compute regression, classification and centerness targets for points
+        in multiple images.
+
+        Args:
+            points (list[Tensor]): Points of each fpn level, each has shape
+                (num_points, 2).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+
+        Returns:
+            tuple: Targets of each level.
+
+            - concat_lvl_labels (list[Tensor]): Labels of each level.
+            - concat_lvl_bbox_targets (list[Tensor]): BBox targets of each \
+            level.
+            - pos_inds_list (list[Tensor]): pos_inds of each image.
+            - pos_gt_inds_list (List[Tensor]): pos_gt_inds of each image.
+        """
+        assert len(points) == len(self.regress_ranges)
+        num_levels = len(points)
+        # expand regress ranges to align with points
+        expanded_regress_ranges = [
+            points[i].new_tensor(self.regress_ranges[i])[None].expand_as(
+                points[i]) for i in range(num_levels)
+        ]
+        # concat all levels points and regress ranges
+        concat_regress_ranges = torch.cat(expanded_regress_ranges, dim=0)
+        concat_points = torch.cat(points, dim=0)
+
+        # the number of points per img, per lvl
+        num_points = [center.size(0) for center in points]
+
+        # get labels and bbox_targets of each image
+        labels_list, bbox_targets_list, pos_inds_list, pos_gt_inds_list = \
+            multi_apply(
+                self._get_targets_single,
+                batch_gt_instances,
+                points=concat_points,
+                regress_ranges=concat_regress_ranges,
+                num_points_per_lvl=num_points)
+
+        # split to per img, per level
+        labels_list = [labels.split(num_points, 0) for labels in labels_list]
+        bbox_targets_list = [
+            bbox_targets.split(num_points, 0)
+            for bbox_targets in bbox_targets_list
+        ]
+
+        # concat per level image
+        concat_lvl_labels = []
+        concat_lvl_bbox_targets = []
+        for i in range(num_levels):
+            concat_lvl_labels.append(
+                torch.cat([labels[i] for labels in labels_list]))
+            bbox_targets = torch.cat(
+                [bbox_targets[i] for bbox_targets in bbox_targets_list])
+            if self.norm_on_bbox:
+                bbox_targets = bbox_targets / self.strides[i]
+            concat_lvl_bbox_targets.append(bbox_targets)
+        return (concat_lvl_labels, concat_lvl_bbox_targets, pos_inds_list,
+                pos_gt_inds_list)
+
+    def _get_targets_single(
+        self, gt_instances: InstanceData, points: Tensor,
+        regress_ranges: Tensor, num_points_per_lvl: List[int]
+    ) -> Tuple[Tensor, Tensor, Tensor, Tensor]:
+        """Compute regression and classification targets for a single image."""
+        num_points = points.size(0)
+        num_gts = len(gt_instances)
+        gt_bboxes = gt_instances.bboxes
+        gt_labels = gt_instances.labels
+        gt_masks = gt_instances.get('masks', None)
+
+        if num_gts == 0:
+            return gt_labels.new_full((num_points,), self.num_classes), \
+                   gt_bboxes.new_zeros((num_points, 4)), \
+                   gt_bboxes.new_zeros((0,), dtype=torch.int64), \
+                   gt_bboxes.new_zeros((0,), dtype=torch.int64)
+
+        areas = (gt_bboxes[:, 2] - gt_bboxes[:, 0]) * (
+            gt_bboxes[:, 3] - gt_bboxes[:, 1])
+        # TODO: figure out why these two are different
+        # areas = areas[None].expand(num_points, num_gts)
+        areas = areas[None].repeat(num_points, 1)
+        regress_ranges = regress_ranges[:, None, :].expand(
+            num_points, num_gts, 2)
+        gt_bboxes = gt_bboxes[None].expand(num_points, num_gts, 4)
+        xs, ys = points[:, 0], points[:, 1]
+        xs = xs[:, None].expand(num_points, num_gts)
+        ys = ys[:, None].expand(num_points, num_gts)
+
+        left = xs - gt_bboxes[..., 0]
+        right = gt_bboxes[..., 2] - xs
+        top = ys - gt_bboxes[..., 1]
+        bottom = gt_bboxes[..., 3] - ys
+        bbox_targets = torch.stack((left, top, right, bottom), -1)
+
+        if self.center_sampling:
+            # condition1: inside a `center bbox`
+            radius = self.center_sample_radius
+            # if gt_mask not None, use gt mask's centroid to determine
+            # the center region rather than gt_bbox center
+            if gt_masks is None:
+                center_xs = (gt_bboxes[..., 0] + gt_bboxes[..., 2]) / 2
+                center_ys = (gt_bboxes[..., 1] + gt_bboxes[..., 3]) / 2
+            else:
+                h, w = gt_masks.height, gt_masks.width
+                masks = gt_masks.to_tensor(
+                    dtype=torch.bool, device=gt_bboxes.device)
+                yys = torch.arange(
+                    0, h, dtype=torch.float32, device=masks.device)
+                xxs = torch.arange(
+                    0, w, dtype=torch.float32, device=masks.device)
+                # m00/m10/m01 represent the moments of a contour
+                # centroid is computed by m00/m10 and m00/m01
+                m00 = masks.sum(dim=-1).sum(dim=-1).clamp(min=1e-6)
+                m10 = (masks * xxs).sum(dim=-1).sum(dim=-1)
+                m01 = (masks * yys[:, None]).sum(dim=-1).sum(dim=-1)
+                center_xs = m10 / m00
+                center_ys = m01 / m00
+
+                center_xs = center_xs[None].expand(num_points, num_gts)
+                center_ys = center_ys[None].expand(num_points, num_gts)
+            center_gts = torch.zeros_like(gt_bboxes)
+            stride = center_xs.new_zeros(center_xs.shape)
+
+            # project the points on current lvl back to the `original` sizes
+            lvl_begin = 0
+            for lvl_idx, num_points_lvl in enumerate(num_points_per_lvl):
+                lvl_end = lvl_begin + num_points_lvl
+                stride[lvl_begin:lvl_end] = self.strides[lvl_idx] * radius
+                lvl_begin = lvl_end
+
+            x_mins = center_xs - stride
+            y_mins = center_ys - stride
+            x_maxs = center_xs + stride
+            y_maxs = center_ys + stride
+            center_gts[..., 0] = torch.where(x_mins > gt_bboxes[..., 0],
+                                             x_mins, gt_bboxes[..., 0])
+            center_gts[..., 1] = torch.where(y_mins > gt_bboxes[..., 1],
+                                             y_mins, gt_bboxes[..., 1])
+            center_gts[..., 2] = torch.where(x_maxs > gt_bboxes[..., 2],
+                                             gt_bboxes[..., 2], x_maxs)
+            center_gts[..., 3] = torch.where(y_maxs > gt_bboxes[..., 3],
+                                             gt_bboxes[..., 3], y_maxs)
+
+            cb_dist_left = xs - center_gts[..., 0]
+            cb_dist_right = center_gts[..., 2] - xs
+            cb_dist_top = ys - center_gts[..., 1]
+            cb_dist_bottom = center_gts[..., 3] - ys
+            center_bbox = torch.stack(
+                (cb_dist_left, cb_dist_top, cb_dist_right, cb_dist_bottom), -1)
+            inside_gt_bbox_mask = center_bbox.min(-1)[0] > 0
+        else:
+            # condition1: inside a gt bbox
+            inside_gt_bbox_mask = bbox_targets.min(-1)[0] > 0
+
+        # condition2: limit the regression range for each location
+        max_regress_distance = bbox_targets.max(-1)[0]
+        inside_regress_range = (
+            (max_regress_distance >= regress_ranges[..., 0])
+            & (max_regress_distance <= regress_ranges[..., 1]))
+
+        # if there are still more than one objects for a location,
+        # we choose the one with minimal area
+        areas[inside_gt_bbox_mask == 0] = INF
+        areas[inside_regress_range == 0] = INF
+        min_area, min_area_inds = areas.min(dim=1)
+
+        labels = gt_labels[min_area_inds]
+        labels[min_area == INF] = self.num_classes  # set as BG
+        bbox_targets = bbox_targets[range(num_points), min_area_inds]
+
+        # return pos_inds & pos_gt_inds
+        bg_class_ind = self.num_classes
+        pos_inds = ((labels >= 0)
+                    & (labels < bg_class_ind)).nonzero().reshape(-1)
+        pos_gt_inds = min_area_inds[labels < self.num_classes]
+        return labels, bbox_targets, pos_inds, pos_gt_inds
+
+    def get_positive_infos(self) -> InstanceList:
+        """Get positive information from sampling results.
+
+        Returns:
+            list[:obj:`InstanceData`]: Positive information of each image,
+            usually including positive bboxes, positive labels, positive
+            priors, etc.
+        """
+        assert len(self._raw_positive_infos) > 0
+
+        pos_gt_inds_list = self._raw_positive_infos['pos_gt_inds_list']
+        pos_inds_list = self._raw_positive_infos['pos_inds_list']
+        num_imgs = len(pos_gt_inds_list)
+
+        cls_score_list = []
+        centerness_list = []
+        param_pred_list = []
+        point_list = []
+        stride_list = []
+        for cls_score_per_lvl, centerness_per_lvl, param_pred_per_lvl,\
+            point_per_lvl, stride_per_lvl in \
+            zip(self._raw_positive_infos['cls_scores'],
+                self._raw_positive_infos['centernesses'],
+                self._raw_positive_infos['param_preds'],
+                self._raw_positive_infos['all_level_points'],
+                self._raw_positive_infos['all_level_strides']):
+            cls_score_per_lvl = \
+                cls_score_per_lvl.permute(
+                    0, 2, 3, 1).reshape(num_imgs, -1, self.num_classes)
+            centerness_per_lvl = \
+                centerness_per_lvl.permute(
+                    0, 2, 3, 1).reshape(num_imgs, -1, 1)
+            param_pred_per_lvl = \
+                param_pred_per_lvl.permute(
+                    0, 2, 3, 1).reshape(num_imgs, -1, self.num_params)
+            point_per_lvl = point_per_lvl.unsqueeze(0).repeat(num_imgs, 1, 1)
+            stride_per_lvl = stride_per_lvl.unsqueeze(0).repeat(num_imgs, 1)
+
+            cls_score_list.append(cls_score_per_lvl)
+            centerness_list.append(centerness_per_lvl)
+            param_pred_list.append(param_pred_per_lvl)
+            point_list.append(point_per_lvl)
+            stride_list.append(stride_per_lvl)
+        cls_scores = torch.cat(cls_score_list, dim=1)
+        centernesses = torch.cat(centerness_list, dim=1)
+        param_preds = torch.cat(param_pred_list, dim=1)
+        all_points = torch.cat(point_list, dim=1)
+        all_strides = torch.cat(stride_list, dim=1)
+
+        positive_infos = []
+        for i, (pos_gt_inds,
+                pos_inds) in enumerate(zip(pos_gt_inds_list, pos_inds_list)):
+            pos_info = InstanceData()
+            pos_info.points = all_points[i][pos_inds]
+            pos_info.strides = all_strides[i][pos_inds]
+            pos_info.scores = cls_scores[i][pos_inds]
+            pos_info.centernesses = centernesses[i][pos_inds]
+            pos_info.param_preds = param_preds[i][pos_inds]
+            pos_info.pos_assigned_gt_inds = pos_gt_inds
+            pos_info.pos_inds = pos_inds
+            positive_infos.append(pos_info)
+        return positive_infos
+
+    def predict_by_feat(self,
+                        cls_scores: List[Tensor],
+                        bbox_preds: List[Tensor],
+                        score_factors: Optional[List[Tensor]] = None,
+                        param_preds: Optional[List[Tensor]] = None,
+                        batch_img_metas: Optional[List[dict]] = None,
+                        cfg: Optional[ConfigDict] = None,
+                        rescale: bool = False,
+                        with_nms: bool = True) -> InstanceList:
+        """Transform a batch of output features extracted from the head into
+        bbox results.
+
+        Note: When score_factors is not None, the cls_scores are
+        usually multiplied by it then obtain the real score used in NMS,
+        such as CenterNess in FCOS, IoU branch in ATSS.
+
+        Args:
+            cls_scores (list[Tensor]): Classification scores for all
+                scale levels, each is a 4D-tensor, has shape
+                (batch_size, num_priors * num_classes, H, W).
+            bbox_preds (list[Tensor]): Box energies / deltas for all
+                scale levels, each is a 4D-tensor, has shape
+                (batch_size, num_priors * 4, H, W).
+            score_factors (list[Tensor], optional): Score factor for
+                all scale level, each is a 4D-tensor, has shape
+                (batch_size, num_priors * 1, H, W). Defaults to None.
+            param_preds (list[Tensor], optional): Params for all scale
+                level, each is a 4D-tensor, has shape
+                (batch_size, num_priors * num_params, H, W)
+            batch_img_metas (list[dict], Optional): Batch image meta info.
+                Defaults to None.
+            cfg (ConfigDict, optional): Test / postprocessing
+                configuration, if None, test_cfg would be used.
+                Defaults to None.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            with_nms (bool): If True, do nms before return boxes.
+                Defaults to True.
+
+        Returns:
+            list[:obj:`InstanceData`]: Object detection results of each image
+            after the post process. Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        assert len(cls_scores) == len(bbox_preds)
+
+        if score_factors is None:
+            # e.g. Retina, FreeAnchor, Foveabox, etc.
+            with_score_factors = False
+        else:
+            # e.g. FCOS, PAA, ATSS, AutoAssign, etc.
+            with_score_factors = True
+            assert len(cls_scores) == len(score_factors)
+
+        num_levels = len(cls_scores)
+
+        featmap_sizes = [cls_scores[i].shape[-2:] for i in range(num_levels)]
+        all_level_points_strides = self.prior_generator.grid_priors(
+            featmap_sizes,
+            dtype=bbox_preds[0].dtype,
+            device=bbox_preds[0].device,
+            with_stride=True)
+        all_level_points = [i[:, :2] for i in all_level_points_strides]
+        all_level_strides = [i[:, 2] for i in all_level_points_strides]
+
+        result_list = []
+
+        for img_id in range(len(batch_img_metas)):
+            img_meta = batch_img_metas[img_id]
+            cls_score_list = select_single_mlvl(
+                cls_scores, img_id, detach=True)
+            bbox_pred_list = select_single_mlvl(
+                bbox_preds, img_id, detach=True)
+            if with_score_factors:
+                score_factor_list = select_single_mlvl(
+                    score_factors, img_id, detach=True)
+            else:
+                score_factor_list = [None for _ in range(num_levels)]
+            param_pred_list = select_single_mlvl(
+                param_preds, img_id, detach=True)
+
+            results = self._predict_by_feat_single(
+                cls_score_list=cls_score_list,
+                bbox_pred_list=bbox_pred_list,
+                score_factor_list=score_factor_list,
+                param_pred_list=param_pred_list,
+                mlvl_points=all_level_points,
+                mlvl_strides=all_level_strides,
+                img_meta=img_meta,
+                cfg=cfg,
+                rescale=rescale,
+                with_nms=with_nms)
+            result_list.append(results)
+        return result_list
+
+    def _predict_by_feat_single(self,
+                                cls_score_list: List[Tensor],
+                                bbox_pred_list: List[Tensor],
+                                score_factor_list: List[Tensor],
+                                param_pred_list: List[Tensor],
+                                mlvl_points: List[Tensor],
+                                mlvl_strides: List[Tensor],
+                                img_meta: dict,
+                                cfg: ConfigDict,
+                                rescale: bool = False,
+                                with_nms: bool = True) -> InstanceData:
+        """Transform a single image's features extracted from the head into
+        bbox results.
+
+        Args:
+            cls_score_list (list[Tensor]): Box scores from all scale
+                levels of a single image, each item has shape
+                (num_priors * num_classes, H, W).
+            bbox_pred_list (list[Tensor]): Box energies / deltas from
+                all scale levels of a single image, each item has shape
+                (num_priors * 4, H, W).
+            score_factor_list (list[Tensor]): Score factor from all scale
+                levels of a single image, each item has shape
+                (num_priors * 1, H, W).
+            param_pred_list (List[Tensor]): Param predition from all scale
+                levels of a single image, each item has shape
+                (num_priors * num_params, H, W).
+            mlvl_points (list[Tensor]): Each element in the list is
+                the priors of a single level in feature pyramid.
+                It has shape (num_priors, 2)
+            mlvl_strides (List[Tensor]):  Each element in the list is
+                the stride of a single level in feature pyramid.
+                It has shape (num_priors, 1)
+            img_meta (dict): Image meta info.
+            cfg (mmengine.Config): Test / postprocessing configuration,
+                if None, test_cfg would be used.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            with_nms (bool): If True, do nms before return boxes.
+                Defaults to True.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        if score_factor_list[0] is None:
+            # e.g. Retina, FreeAnchor, etc.
+            with_score_factors = False
+        else:
+            # e.g. FCOS, PAA, ATSS, etc.
+            with_score_factors = True
+
+        cfg = self.test_cfg if cfg is None else cfg
+        cfg = copy.deepcopy(cfg)
+        img_shape = img_meta['img_shape']
+        nms_pre = cfg.get('nms_pre', -1)
+
+        mlvl_bbox_preds = []
+        mlvl_param_preds = []
+        mlvl_valid_points = []
+        mlvl_valid_strides = []
+        mlvl_scores = []
+        mlvl_labels = []
+        if with_score_factors:
+            mlvl_score_factors = []
+        else:
+            mlvl_score_factors = None
+        for level_idx, (cls_score, bbox_pred, score_factor,
+                        param_pred, points, strides) in \
+                enumerate(zip(cls_score_list, bbox_pred_list,
+                              score_factor_list, param_pred_list,
+                              mlvl_points, mlvl_strides)):
+
+            assert cls_score.size()[-2:] == bbox_pred.size()[-2:]
+
+            dim = self.bbox_coder.encode_size
+            bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, dim)
+            if with_score_factors:
+                score_factor = score_factor.permute(1, 2,
+                                                    0).reshape(-1).sigmoid()
+            cls_score = cls_score.permute(1, 2,
+                                          0).reshape(-1, self.cls_out_channels)
+            if self.use_sigmoid_cls:
+                scores = cls_score.sigmoid()
+            else:
+                # remind that we set FG labels to [0, num_class-1]
+                # since mmdet v2.0
+                # BG cat_id: num_class
+                scores = cls_score.softmax(-1)[:, :-1]
+
+            param_pred = param_pred.permute(1, 2,
+                                            0).reshape(-1, self.num_params)
+
+            # After https://github.com/open-mmlab/mmdetection/pull/6268/,
+            # this operation keeps fewer bboxes under the same `nms_pre`.
+            # There is no difference in performance for most models. If you
+            # find a slight drop in performance, you can set a larger
+            # `nms_pre` than before.
+            score_thr = cfg.get('score_thr', 0)
+
+            results = filter_scores_and_topk(
+                scores, score_thr, nms_pre,
+                dict(
+                    bbox_pred=bbox_pred,
+                    param_pred=param_pred,
+                    points=points,
+                    strides=strides))
+            scores, labels, keep_idxs, filtered_results = results
+
+            bbox_pred = filtered_results['bbox_pred']
+            param_pred = filtered_results['param_pred']
+            points = filtered_results['points']
+            strides = filtered_results['strides']
+
+            if with_score_factors:
+                score_factor = score_factor[keep_idxs]
+
+            mlvl_bbox_preds.append(bbox_pred)
+            mlvl_param_preds.append(param_pred)
+            mlvl_valid_points.append(points)
+            mlvl_valid_strides.append(strides)
+            mlvl_scores.append(scores)
+            mlvl_labels.append(labels)
+
+            if with_score_factors:
+                mlvl_score_factors.append(score_factor)
+
+        bbox_pred = torch.cat(mlvl_bbox_preds)
+        priors = cat_boxes(mlvl_valid_points)
+        bboxes = self.bbox_coder.decode(priors, bbox_pred, max_shape=img_shape)
+
+        results = InstanceData()
+        results.bboxes = bboxes
+        results.scores = torch.cat(mlvl_scores)
+        results.labels = torch.cat(mlvl_labels)
+        results.param_preds = torch.cat(mlvl_param_preds)
+        results.points = torch.cat(mlvl_valid_points)
+        results.strides = torch.cat(mlvl_valid_strides)
+        if with_score_factors:
+            results.score_factors = torch.cat(mlvl_score_factors)
+
+        return self._bbox_post_process(
+            results=results,
+            cfg=cfg,
+            rescale=rescale,
+            with_nms=with_nms,
+            img_meta=img_meta)
+
+
+class MaskFeatModule(BaseModule):
+    """CondInst mask feature map branch used in \
+    https://arxiv.org/abs/1904.02689.
+
+    Args:
+        in_channels (int): Number of channels in the input feature map.
+        feat_channels (int): Number of hidden channels of the mask feature
+             map branch.
+        start_level (int): The starting feature map level from RPN that
+             will be used to predict the mask feature map.
+        end_level (int): The ending feature map level from rpn that
+             will be used to predict the mask feature map.
+        out_channels (int): Number of output channels of the mask feature
+             map branch. This is the channel count of the mask
+             feature map that to be dynamically convolved with the predicted
+             kernel.
+        mask_stride (int): Downsample factor of the mask feature map output.
+            Defaults to 4.
+        num_stacked_convs (int): Number of convs in mask feature branch.
+        conv_cfg (dict): Config dict for convolution layer. Default: None.
+        norm_cfg (dict): Config dict for normalization layer. Default: None.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+    """
+
+    def __init__(self,
+                 in_channels: int,
+                 feat_channels: int,
+                 start_level: int,
+                 end_level: int,
+                 out_channels: int,
+                 mask_stride: int = 4,
+                 num_stacked_convs: int = 4,
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: OptConfigType = None,
+                 init_cfg: MultiConfig = [
+                     dict(type='Normal', layer='Conv2d', std=0.01)
+                 ],
+                 **kwargs) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.in_channels = in_channels
+        self.feat_channels = feat_channels
+        self.start_level = start_level
+        self.end_level = end_level
+        self.mask_stride = mask_stride
+        self.num_stacked_convs = num_stacked_convs
+        assert start_level >= 0 and end_level >= start_level
+        self.out_channels = out_channels
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self._init_layers()
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        self.convs_all_levels = nn.ModuleList()
+        for i in range(self.start_level, self.end_level + 1):
+            convs_per_level = nn.Sequential()
+            convs_per_level.add_module(
+                f'conv{i}',
+                ConvModule(
+                    self.in_channels,
+                    self.feat_channels,
+                    3,
+                    padding=1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg,
+                    inplace=False,
+                    bias=False))
+            self.convs_all_levels.append(convs_per_level)
+
+        conv_branch = []
+        for _ in range(self.num_stacked_convs):
+            conv_branch.append(
+                ConvModule(
+                    self.feat_channels,
+                    self.feat_channels,
+                    3,
+                    padding=1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg,
+                    bias=False))
+        self.conv_branch = nn.Sequential(*conv_branch)
+
+        self.conv_pred = nn.Conv2d(
+            self.feat_channels, self.out_channels, 1, stride=1)
+
+    def init_weights(self) -> None:
+        """Initialize weights of the head."""
+        super().init_weights()
+        kaiming_init(self.convs_all_levels, a=1, distribution='uniform')
+        kaiming_init(self.conv_branch, a=1, distribution='uniform')
+        kaiming_init(self.conv_pred, a=1, distribution='uniform')
+
+    def forward(self, x: Tuple[Tensor]) -> Tensor:
+        """Forward features from the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            Tensor: The predicted mask feature map.
+        """
+        inputs = x[self.start_level:self.end_level + 1]
+        assert len(inputs) == (self.end_level - self.start_level + 1)
+        feature_add_all_level = self.convs_all_levels[0](inputs[0])
+        target_h, target_w = feature_add_all_level.size()[2:]
+        for i in range(1, len(inputs)):
+            input_p = inputs[i]
+            x_p = self.convs_all_levels[i](input_p)
+            h, w = x_p.size()[2:]
+            factor_h = target_h // h
+            factor_w = target_w // w
+            assert factor_h == factor_w
+            feature_per_level = aligned_bilinear(x_p, factor_h)
+            feature_add_all_level = feature_add_all_level + \
+                feature_per_level
+
+        feature_add_all_level = self.conv_branch(feature_add_all_level)
+        feature_pred = self.conv_pred(feature_add_all_level)
+        return feature_pred
+
+
+@MODELS.register_module()
+class CondInstMaskHead(BaseMaskHead):
+    """CondInst mask head used in https://arxiv.org/abs/1904.02689.
+
+    This head outputs the mask for CondInst.
+
+    Args:
+        mask_feature_head (dict): Config of CondInstMaskFeatHead.
+        num_layers (int): Number of dynamic conv layers.
+        feat_channels (int): Number of channels in the dynamic conv.
+        mask_out_stride (int): The stride of the mask feat.
+        size_of_interest (int): The size of the region used in rel coord.
+        max_masks_to_train (int): Maximum number of masks to train for
+            each image.
+        loss_segm (:obj:`ConfigDict` or dict, optional): Config of
+            segmentation loss.
+        train_cfg (:obj:`ConfigDict` or dict, optional): Training config
+            of head.
+        test_cfg (:obj:`ConfigDict` or dict, optional): Testing config of
+            head.
+    """
+
+    def __init__(self,
+                 mask_feature_head: ConfigType,
+                 num_layers: int = 3,
+                 feat_channels: int = 8,
+                 mask_out_stride: int = 4,
+                 size_of_interest: int = 8,
+                 max_masks_to_train: int = -1,
+                 topk_masks_per_img: int = -1,
+                 loss_mask: ConfigType = None,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None) -> None:
+        super().__init__()
+        self.mask_feature_head = MaskFeatModule(**mask_feature_head)
+        self.mask_feat_stride = self.mask_feature_head.mask_stride
+        self.in_channels = self.mask_feature_head.out_channels
+        self.num_layers = num_layers
+        self.feat_channels = feat_channels
+        self.size_of_interest = size_of_interest
+        self.mask_out_stride = mask_out_stride
+        self.max_masks_to_train = max_masks_to_train
+        self.topk_masks_per_img = topk_masks_per_img
+        self.prior_generator = MlvlPointGenerator([self.mask_feat_stride])
+
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+        self.loss_mask = MODELS.build(loss_mask)
+        self._init_layers()
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        weight_nums, bias_nums = [], []
+        for i in range(self.num_layers):
+            if i == 0:
+                weight_nums.append((self.in_channels + 2) * self.feat_channels)
+                bias_nums.append(self.feat_channels)
+            elif i == self.num_layers - 1:
+                weight_nums.append(self.feat_channels * 1)
+                bias_nums.append(1)
+            else:
+                weight_nums.append(self.feat_channels * self.feat_channels)
+                bias_nums.append(self.feat_channels)
+
+        self.weight_nums = weight_nums
+        self.bias_nums = bias_nums
+        self.num_params = sum(weight_nums) + sum(bias_nums)
+
+    def parse_dynamic_params(
+            self, params: Tensor) -> Tuple[List[Tensor], List[Tensor]]:
+        """parse the dynamic params for dynamic conv."""
+        num_insts = params.size(0)
+        params_splits = list(
+            torch.split_with_sizes(
+                params, self.weight_nums + self.bias_nums, dim=1))
+        weight_splits = params_splits[:self.num_layers]
+        bias_splits = params_splits[self.num_layers:]
+        for i in range(self.num_layers):
+            if i < self.num_layers - 1:
+                weight_splits[i] = weight_splits[i].reshape(
+                    num_insts * self.in_channels, -1, 1, 1)
+                bias_splits[i] = bias_splits[i].reshape(num_insts *
+                                                        self.in_channels)
+            else:
+                # out_channels x in_channels x 1 x 1
+                weight_splits[i] = weight_splits[i].reshape(
+                    num_insts * 1, -1, 1, 1)
+                bias_splits[i] = bias_splits[i].reshape(num_insts)
+
+        return weight_splits, bias_splits
+
+    def dynamic_conv_forward(self, features: Tensor, weights: List[Tensor],
+                             biases: List[Tensor], num_insts: int) -> Tensor:
+        """dynamic forward, each layer follow a relu."""
+        n_layers = len(weights)
+        x = features
+        for i, (w, b) in enumerate(zip(weights, biases)):
+            x = F.conv2d(x, w, bias=b, stride=1, padding=0, groups=num_insts)
+            if i < n_layers - 1:
+                x = F.relu(x)
+        return x
+
+    def forward(self, x: tuple, positive_infos: InstanceList) -> tuple:
+        """Forward feature from the upstream network to get prototypes and
+        linearly combine the prototypes, using masks coefficients, into
+        instance masks. Finally, crop the instance masks with given bboxes.
+
+        Args:
+            x (Tuple[Tensor]): Feature from the upstream network, which is
+                a 4D-tensor.
+            positive_infos (List[:obj:``InstanceData``]): Positive information
+                that calculate from detect head.
+
+        Returns:
+            tuple: Predicted instance segmentation masks
+        """
+        mask_feats = self.mask_feature_head(x)
+        return multi_apply(self.forward_single, mask_feats, positive_infos)
+
+    def forward_single(self, mask_feat: Tensor,
+                       positive_info: InstanceData) -> Tensor:
+        """Forward features of a each image."""
+        pos_param_preds = positive_info.get('param_preds')
+        pos_points = positive_info.get('points')
+        pos_strides = positive_info.get('strides')
+
+        num_inst = pos_param_preds.shape[0]
+        mask_feat = mask_feat[None].repeat(num_inst, 1, 1, 1)
+        _, _, H, W = mask_feat.size()
+        if num_inst == 0:
+            return (pos_param_preds.new_zeros((0, 1, H, W)), )
+
+        locations = self.prior_generator.single_level_grid_priors(
+            mask_feat.size()[2:], 0, device=mask_feat.device)
+
+        rel_coords = relative_coordinate_maps(locations, pos_points,
+                                              pos_strides,
+                                              self.size_of_interest,
+                                              mask_feat.size()[2:])
+        mask_head_inputs = torch.cat([rel_coords, mask_feat], dim=1)
+        mask_head_inputs = mask_head_inputs.reshape(1, -1, H, W)
+
+        weights, biases = self.parse_dynamic_params(pos_param_preds)
+        mask_preds = self.dynamic_conv_forward(mask_head_inputs, weights,
+                                               biases, num_inst)
+        mask_preds = mask_preds.reshape(-1, H, W)
+        mask_preds = aligned_bilinear(
+            mask_preds.unsqueeze(0),
+            int(self.mask_feat_stride / self.mask_out_stride)).squeeze(0)
+
+        return (mask_preds, )
+
+    def loss_by_feat(self, mask_preds: List[Tensor],
+                     batch_gt_instances: InstanceList,
+                     batch_img_metas: List[dict], positive_infos: InstanceList,
+                     **kwargs) -> dict:
+        """Calculate the loss based on the features extracted by the mask head.
+
+        Args:
+            mask_preds (list[Tensor]): List of predicted masks, each has
+                shape (num_classes, H, W).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes``, ``masks``,
+                and ``labels`` attributes.
+            batch_img_metas (list[dict]): Meta information of multiple images.
+            positive_infos (List[:obj:``InstanceData``]): Information of
+                positive samples of each image that are assigned in detection
+                head.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        assert positive_infos is not None, \
+            'positive_infos should not be None in `CondInstMaskHead`'
+        losses = dict()
+
+        loss_mask = 0.
+        num_imgs = len(mask_preds)
+        total_pos = 0
+
+        for idx in range(num_imgs):
+            (mask_pred, pos_mask_targets, num_pos) = \
+                self._get_targets_single(
+                mask_preds[idx], batch_gt_instances[idx],
+                positive_infos[idx])
+            # mask loss
+            total_pos += num_pos
+            if num_pos == 0 or pos_mask_targets is None:
+                loss = mask_pred.new_zeros(1).mean()
+            else:
+                loss = self.loss_mask(
+                    mask_pred, pos_mask_targets,
+                    reduction_override='none').sum()
+            loss_mask += loss
+
+        if total_pos == 0:
+            total_pos += 1  # avoid nan
+        loss_mask = loss_mask / total_pos
+        losses.update(loss_mask=loss_mask)
+        return losses
+
+    def _get_targets_single(self, mask_preds: Tensor,
+                            gt_instances: InstanceData,
+                            positive_info: InstanceData):
+        """Compute targets for predictions of single image.
+
+        Args:
+            mask_preds (Tensor): Predicted prototypes with shape
+                (num_classes, H, W).
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It should includes ``bboxes``, ``labels``,
+                and ``masks`` attributes.
+            positive_info (:obj:`InstanceData`): Information of positive
+                samples that are assigned in detection head. It usually
+                contains following keys.
+
+                    - pos_assigned_gt_inds (Tensor): Assigner GT indexes of
+                      positive proposals, has shape (num_pos, )
+                    - pos_inds (Tensor): Positive index of image, has
+                      shape (num_pos, ).
+                    - param_pred (Tensor): Positive param preditions
+                      with shape (num_pos, num_params).
+
+        Returns:
+            tuple: Usually returns a tuple containing learning targets.
+
+            - mask_preds (Tensor): Positive predicted mask with shape
+              (num_pos, mask_h, mask_w).
+            - pos_mask_targets (Tensor): Positive mask targets with shape
+              (num_pos, mask_h, mask_w).
+            - num_pos (int): Positive numbers.
+        """
+        gt_bboxes = gt_instances.bboxes
+        device = gt_bboxes.device
+        gt_masks = gt_instances.masks.to_tensor(
+            dtype=torch.bool, device=device).float()
+
+        # process with mask targets
+        pos_assigned_gt_inds = positive_info.get('pos_assigned_gt_inds')
+        scores = positive_info.get('scores')
+        centernesses = positive_info.get('centernesses')
+        num_pos = pos_assigned_gt_inds.size(0)
+
+        if gt_masks.size(0) == 0 or num_pos == 0:
+            return mask_preds, None, 0
+        # Since we're producing (near) full image masks,
+        # it'd take too much vram to backprop on every single mask.
+        # Thus we select only a subset.
+        if (self.max_masks_to_train != -1) and \
+           (num_pos > self.max_masks_to_train):
+            perm = torch.randperm(num_pos)
+            select = perm[:self.max_masks_to_train]
+            mask_preds = mask_preds[select]
+            pos_assigned_gt_inds = pos_assigned_gt_inds[select]
+            num_pos = self.max_masks_to_train
+        elif self.topk_masks_per_img != -1:
+            unique_gt_inds = pos_assigned_gt_inds.unique()
+            num_inst_per_gt = max(
+                int(self.topk_masks_per_img / len(unique_gt_inds)), 1)
+
+            keep_mask_preds = []
+            keep_pos_assigned_gt_inds = []
+            for gt_ind in unique_gt_inds:
+                per_inst_pos_inds = (pos_assigned_gt_inds == gt_ind)
+                mask_preds_per_inst = mask_preds[per_inst_pos_inds]
+                gt_inds_per_inst = pos_assigned_gt_inds[per_inst_pos_inds]
+                if sum(per_inst_pos_inds) > num_inst_per_gt:
+                    per_inst_scores = scores[per_inst_pos_inds].sigmoid().max(
+                        dim=1)[0]
+                    per_inst_centerness = centernesses[
+                        per_inst_pos_inds].sigmoid().reshape(-1, )
+                    select = (per_inst_scores * per_inst_centerness).topk(
+                        k=num_inst_per_gt, dim=0)[1]
+                    mask_preds_per_inst = mask_preds_per_inst[select]
+                    gt_inds_per_inst = gt_inds_per_inst[select]
+                keep_mask_preds.append(mask_preds_per_inst)
+                keep_pos_assigned_gt_inds.append(gt_inds_per_inst)
+            mask_preds = torch.cat(keep_mask_preds)
+            pos_assigned_gt_inds = torch.cat(keep_pos_assigned_gt_inds)
+            num_pos = pos_assigned_gt_inds.size(0)
+
+        # Follow the origin implement
+        start = int(self.mask_out_stride // 2)
+        gt_masks = gt_masks[:, start::self.mask_out_stride,
+                            start::self.mask_out_stride]
+        gt_masks = gt_masks.gt(0.5).float()
+        pos_mask_targets = gt_masks[pos_assigned_gt_inds]
+
+        return (mask_preds, pos_mask_targets, num_pos)
+
+    def predict_by_feat(self,
+                        mask_preds: List[Tensor],
+                        results_list: InstanceList,
+                        batch_img_metas: List[dict],
+                        rescale: bool = True,
+                        **kwargs) -> InstanceList:
+        """Transform a batch of output features extracted from the head into
+        mask results.
+
+        Args:
+            mask_preds (list[Tensor]): Predicted prototypes with shape
+                (num_classes, H, W).
+            results_list (List[:obj:``InstanceData``]): BBoxHead results.
+            batch_img_metas (list[dict]): Meta information of all images.
+            rescale (bool, optional): Whether to rescale the results.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Processed results of multiple
+            images.Each :obj:`InstanceData` usually contains
+            following keys.
+
+                - scores (Tensor): Classification scores, has shape
+                  (num_instance,).
+                - labels (Tensor): Has shape (num_instances,).
+                - masks (Tensor): Processed mask results, has
+                  shape (num_instances, h, w).
+        """
+        assert len(mask_preds) == len(results_list) == len(batch_img_metas)
+
+        for img_id in range(len(batch_img_metas)):
+            img_meta = batch_img_metas[img_id]
+            results = results_list[img_id]
+            bboxes = results.bboxes
+            mask_pred = mask_preds[img_id]
+            if bboxes.shape[0] == 0 or mask_pred.shape[0] == 0:
+                results_list[img_id] = empty_instances(
+                    [img_meta],
+                    bboxes.device,
+                    task_type='mask',
+                    instance_results=[results])[0]
+            else:
+                im_mask = self._predict_by_feat_single(
+                    mask_preds=mask_pred,
+                    bboxes=bboxes,
+                    img_meta=img_meta,
+                    rescale=rescale)
+                results.masks = im_mask
+        return results_list
+
+    def _predict_by_feat_single(self,
+                                mask_preds: Tensor,
+                                bboxes: Tensor,
+                                img_meta: dict,
+                                rescale: bool,
+                                cfg: OptConfigType = None):
+        """Transform a single image's features extracted from the head into
+        mask results.
+
+        Args:
+            mask_preds (Tensor): Predicted prototypes, has shape [H, W, N].
+            img_meta (dict): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            rescale (bool): If rescale is False, then returned masks will
+                fit the scale of imgs[0].
+            cfg (dict, optional): Config used in test phase.
+                Defaults to None.
+
+        Returns:
+            :obj:`InstanceData`: Processed results of single image.
+             it usually contains following keys.
+
+                - scores (Tensor): Classification scores, has shape
+                  (num_instance,).
+                - labels (Tensor): Has shape (num_instances,).
+                - masks (Tensor): Processed mask results, has
+                  shape (num_instances, h, w).
+        """
+        cfg = self.test_cfg if cfg is None else cfg
+        scale_factor = bboxes.new_tensor(img_meta['scale_factor']).repeat(
+            (1, 2))
+        img_h, img_w = img_meta['img_shape'][:2]
+        ori_h, ori_w = img_meta['ori_shape'][:2]
+
+        mask_preds = mask_preds.sigmoid().unsqueeze(0)
+        mask_preds = aligned_bilinear(mask_preds, self.mask_out_stride)
+        mask_preds = mask_preds[:, :, :img_h, :img_w]
+        if rescale:  # in-placed rescale the bboxes
+            scale_factor = bboxes.new_tensor(img_meta['scale_factor']).repeat(
+                (1, 2))
+            bboxes /= scale_factor
+
+            masks = F.interpolate(
+                mask_preds, (ori_h, ori_w),
+                mode='bilinear',
+                align_corners=False).squeeze(0) > cfg.mask_thr
+        else:
+            masks = mask_preds.squeeze(0) > cfg.mask_thr
+
+        return masks
diff --git a/mmdetection/mmdet/models/dense_heads/conditional_detr_head.py b/mmdetection/mmdet/models/dense_heads/conditional_detr_head.py
new file mode 100644
index 00000000..cc2df2c2
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/conditional_detr_head.py
@@ -0,0 +1,168 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Tuple
+
+import torch
+import torch.nn as nn
+from mmengine.model import bias_init_with_prob
+from torch import Tensor
+
+from mmdet.models.layers.transformer import inverse_sigmoid
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.utils import InstanceList
+from .detr_head import DETRHead
+
+
+@MODELS.register_module()
+class ConditionalDETRHead(DETRHead):
+    """Head of Conditional DETR. Conditional DETR: Conditional DETR for Fast
+    Training Convergence. More details can be found in the `paper.
+
+    `_ .
+    """
+
+    def init_weights(self):
+        """Initialize weights of the transformer head."""
+        super().init_weights()
+        # The initialization below for transformer head is very
+        # important as we use Focal_loss for loss_cls
+        if self.loss_cls.use_sigmoid:
+            bias_init = bias_init_with_prob(0.01)
+            nn.init.constant_(self.fc_cls.bias, bias_init)
+
+    def forward(self, hidden_states: Tensor,
+                references: Tensor) -> Tuple[Tensor, Tensor]:
+        """"Forward function.
+
+        Args:
+            hidden_states (Tensor): Features from transformer decoder. If
+                `return_intermediate_dec` is True output has shape
+                (num_decoder_layers, bs, num_queries, dim), else has shape (1,
+                bs, num_queries, dim) which only contains the last layer
+                outputs.
+            references (Tensor): References from transformer decoder, has
+                shape (bs, num_queries, 2).
+        Returns:
+            tuple[Tensor]: results of head containing the following tensor.
+
+            - layers_cls_scores (Tensor): Outputs from the classification head,
+              shape (num_decoder_layers, bs, num_queries, cls_out_channels).
+              Note cls_out_channels should include background.
+            - layers_bbox_preds (Tensor): Sigmoid outputs from the regression
+              head with normalized coordinate format (cx, cy, w, h), has shape
+              (num_decoder_layers, bs, num_queries, 4).
+        """
+
+        references_unsigmoid = inverse_sigmoid(references)
+        layers_bbox_preds = []
+        for layer_id in range(hidden_states.shape[0]):
+            tmp_reg_preds = self.fc_reg(
+                self.activate(self.reg_ffn(hidden_states[layer_id])))
+            tmp_reg_preds[..., :2] += references_unsigmoid
+            outputs_coord = tmp_reg_preds.sigmoid()
+            layers_bbox_preds.append(outputs_coord)
+        layers_bbox_preds = torch.stack(layers_bbox_preds)
+
+        layers_cls_scores = self.fc_cls(hidden_states)
+        return layers_cls_scores, layers_bbox_preds
+
+    def loss(self, hidden_states: Tensor, references: Tensor,
+             batch_data_samples: SampleList) -> dict:
+        """Perform forward propagation and loss calculation of the detection
+        head on the features of the upstream network.
+
+        Args:
+            hidden_states (Tensor): Features from the transformer decoder, has
+                shape (num_decoder_layers, bs, num_queries, dim).
+            references (Tensor): References from the transformer decoder, has
+               shape (num_decoder_layers, bs, num_queries, 2).
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        batch_gt_instances = []
+        batch_img_metas = []
+        for data_sample in batch_data_samples:
+            batch_img_metas.append(data_sample.metainfo)
+            batch_gt_instances.append(data_sample.gt_instances)
+
+        outs = self(hidden_states, references)
+        loss_inputs = outs + (batch_gt_instances, batch_img_metas)
+        losses = self.loss_by_feat(*loss_inputs)
+        return losses
+
+    def loss_and_predict(
+            self, hidden_states: Tensor, references: Tensor,
+            batch_data_samples: SampleList) -> Tuple[dict, InstanceList]:
+        """Perform forward propagation of the head, then calculate loss and
+        predictions from the features and data samples. Over-write because
+        img_metas are needed as inputs for bbox_head.
+
+        Args:
+            hidden_states (Tensor): Features from the transformer decoder, has
+                shape (num_decoder_layers, bs, num_queries, dim).
+            references (Tensor): References from the transformer decoder, has
+                shape (num_decoder_layers, bs, num_queries, 2).
+            batch_data_samples (list[:obj:`DetDataSample`]): Each item contains
+                the meta information of each image and corresponding
+                annotations.
+
+        Returns:
+            tuple: The return value is a tuple contains:
+
+            - losses: (dict[str, Tensor]): A dictionary of loss components.
+            - predictions (list[:obj:`InstanceData`]): Detection
+              results of each image after the post process.
+        """
+        batch_gt_instances = []
+        batch_img_metas = []
+        for data_sample in batch_data_samples:
+            batch_img_metas.append(data_sample.metainfo)
+            batch_gt_instances.append(data_sample.gt_instances)
+
+        outs = self(hidden_states, references)
+        loss_inputs = outs + (batch_gt_instances, batch_img_metas)
+        losses = self.loss_by_feat(*loss_inputs)
+
+        predictions = self.predict_by_feat(
+            *outs, batch_img_metas=batch_img_metas)
+        return losses, predictions
+
+    def predict(self,
+                hidden_states: Tensor,
+                references: Tensor,
+                batch_data_samples: SampleList,
+                rescale: bool = True) -> InstanceList:
+        """Perform forward propagation of the detection head and predict
+        detection results on the features of the upstream network. Over-write
+        because img_metas are needed as inputs for bbox_head.
+
+        Args:
+            hidden_states (Tensor): Features from the transformer decoder, has
+                shape (num_decoder_layers, bs, num_queries, dim).
+            references (Tensor): References from the transformer decoder, has
+                shape (num_decoder_layers, bs, num_queries, 2).
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            rescale (bool, optional): Whether to rescale the results.
+                Defaults to True.
+
+        Returns:
+            list[obj:`InstanceData`]: Detection results of each image
+            after the post process.
+        """
+        batch_img_metas = [
+            data_samples.metainfo for data_samples in batch_data_samples
+        ]
+
+        last_layer_hidden_state = hidden_states[-1].unsqueeze(0)
+        outs = self(last_layer_hidden_state, references)
+
+        predictions = self.predict_by_feat(
+            *outs, batch_img_metas=batch_img_metas, rescale=rescale)
+
+        return predictions
diff --git a/mmdetection/mmdet/models/dense_heads/corner_head.py b/mmdetection/mmdet/models/dense_heads/corner_head.py
new file mode 100644
index 00000000..0cec71d5
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/corner_head.py
@@ -0,0 +1,1084 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from logging import warning
+from math import ceil, log
+from typing import List, Optional, Sequence, Tuple
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmcv.ops import CornerPool, batched_nms
+from mmengine.config import ConfigDict
+from mmengine.model import BaseModule, bias_init_with_prob
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import (ConfigType, InstanceList, OptConfigType,
+                         OptInstanceList, OptMultiConfig)
+from ..utils import (gather_feat, gaussian_radius, gen_gaussian_target,
+                     get_local_maximum, get_topk_from_heatmap, multi_apply,
+                     transpose_and_gather_feat)
+from .base_dense_head import BaseDenseHead
+
+
+class BiCornerPool(BaseModule):
+    """Bidirectional Corner Pooling Module (TopLeft, BottomRight, etc.)
+
+    Args:
+        in_channels (int): Input channels of module.
+        directions (list[str]): Directions of two CornerPools.
+        out_channels (int): Output channels of module.
+        feat_channels (int): Feature channels of module.
+        norm_cfg (:obj:`ConfigDict` or dict): Dictionary to construct
+            and config norm layer.
+        init_cfg (:obj:`ConfigDict` or dict, optional): the config to
+            control the initialization.
+    """
+
+    def __init__(self,
+                 in_channels: int,
+                 directions: List[int],
+                 feat_channels: int = 128,
+                 out_channels: int = 128,
+                 norm_cfg: ConfigType = dict(type='BN', requires_grad=True),
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(init_cfg)
+        self.direction1_conv = ConvModule(
+            in_channels, feat_channels, 3, padding=1, norm_cfg=norm_cfg)
+        self.direction2_conv = ConvModule(
+            in_channels, feat_channels, 3, padding=1, norm_cfg=norm_cfg)
+
+        self.aftpool_conv = ConvModule(
+            feat_channels,
+            out_channels,
+            3,
+            padding=1,
+            norm_cfg=norm_cfg,
+            act_cfg=None)
+
+        self.conv1 = ConvModule(
+            in_channels, out_channels, 1, norm_cfg=norm_cfg, act_cfg=None)
+        self.conv2 = ConvModule(
+            in_channels, out_channels, 3, padding=1, norm_cfg=norm_cfg)
+
+        self.direction1_pool = CornerPool(directions[0])
+        self.direction2_pool = CornerPool(directions[1])
+        self.relu = nn.ReLU(inplace=True)
+
+    def forward(self, x: Tensor) -> Tensor:
+        """Forward features from the upstream network.
+
+        Args:
+            x (tensor): Input feature of BiCornerPool.
+
+        Returns:
+            conv2 (tensor): Output feature of BiCornerPool.
+        """
+        direction1_conv = self.direction1_conv(x)
+        direction2_conv = self.direction2_conv(x)
+        direction1_feat = self.direction1_pool(direction1_conv)
+        direction2_feat = self.direction2_pool(direction2_conv)
+        aftpool_conv = self.aftpool_conv(direction1_feat + direction2_feat)
+        conv1 = self.conv1(x)
+        relu = self.relu(aftpool_conv + conv1)
+        conv2 = self.conv2(relu)
+        return conv2
+
+
+@MODELS.register_module()
+class CornerHead(BaseDenseHead):
+    """Head of CornerNet: Detecting Objects as Paired Keypoints.
+
+    Code is modified from the `official github repo
+    `_ .
+
+    More details can be found in the `paper
+    `_ .
+
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (int): Number of channels in the input feature map.
+        num_feat_levels (int): Levels of feature from the previous module.
+            2 for HourglassNet-104 and 1 for HourglassNet-52. Because
+            HourglassNet-104 outputs the final feature and intermediate
+            supervision feature and HourglassNet-52 only outputs the final
+            feature. Defaults to 2.
+        corner_emb_channels (int): Channel of embedding vector. Defaults to 1.
+        train_cfg (:obj:`ConfigDict` or dict, optional): Training config.
+            Useless in CornerHead, but we keep this variable for
+            SingleStageDetector.
+        test_cfg (:obj:`ConfigDict` or dict, optional): Testing config of
+            CornerHead.
+        loss_heatmap (:obj:`ConfigDict` or dict): Config of corner heatmap
+            loss. Defaults to GaussianFocalLoss.
+        loss_embedding (:obj:`ConfigDict` or dict): Config of corner embedding
+            loss. Defaults to AssociativeEmbeddingLoss.
+        loss_offset (:obj:`ConfigDict` or dict): Config of corner offset loss.
+            Defaults to SmoothL1Loss.
+        init_cfg (:obj:`ConfigDict` or dict, optional): the config to control
+            the initialization.
+    """
+
+    def __init__(self,
+                 num_classes: int,
+                 in_channels: int,
+                 num_feat_levels: int = 2,
+                 corner_emb_channels: int = 1,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 loss_heatmap: ConfigType = dict(
+                     type='GaussianFocalLoss',
+                     alpha=2.0,
+                     gamma=4.0,
+                     loss_weight=1),
+                 loss_embedding: ConfigType = dict(
+                     type='AssociativeEmbeddingLoss',
+                     pull_weight=0.25,
+                     push_weight=0.25),
+                 loss_offset: ConfigType = dict(
+                     type='SmoothL1Loss', beta=1.0, loss_weight=1),
+                 init_cfg: OptMultiConfig = None) -> None:
+        assert init_cfg is None, 'To prevent abnormal initialization ' \
+                                 'behavior, init_cfg is not allowed to be set'
+        super().__init__(init_cfg=init_cfg)
+        self.num_classes = num_classes
+        self.in_channels = in_channels
+        self.corner_emb_channels = corner_emb_channels
+        self.with_corner_emb = self.corner_emb_channels > 0
+        self.corner_offset_channels = 2
+        self.num_feat_levels = num_feat_levels
+        self.loss_heatmap = MODELS.build(
+            loss_heatmap) if loss_heatmap is not None else None
+        self.loss_embedding = MODELS.build(
+            loss_embedding) if loss_embedding is not None else None
+        self.loss_offset = MODELS.build(
+            loss_offset) if loss_offset is not None else None
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+
+        self._init_layers()
+
+    def _make_layers(self,
+                     out_channels: int,
+                     in_channels: int = 256,
+                     feat_channels: int = 256) -> nn.Sequential:
+        """Initialize conv sequential for CornerHead."""
+        return nn.Sequential(
+            ConvModule(in_channels, feat_channels, 3, padding=1),
+            ConvModule(
+                feat_channels, out_channels, 1, norm_cfg=None, act_cfg=None))
+
+    def _init_corner_kpt_layers(self) -> None:
+        """Initialize corner keypoint layers.
+
+        Including corner heatmap branch and corner offset branch. Each branch
+        has two parts: prefix `tl_` for top-left and `br_` for bottom-right.
+        """
+        self.tl_pool, self.br_pool = nn.ModuleList(), nn.ModuleList()
+        self.tl_heat, self.br_heat = nn.ModuleList(), nn.ModuleList()
+        self.tl_off, self.br_off = nn.ModuleList(), nn.ModuleList()
+
+        for _ in range(self.num_feat_levels):
+            self.tl_pool.append(
+                BiCornerPool(
+                    self.in_channels, ['top', 'left'],
+                    out_channels=self.in_channels))
+            self.br_pool.append(
+                BiCornerPool(
+                    self.in_channels, ['bottom', 'right'],
+                    out_channels=self.in_channels))
+
+            self.tl_heat.append(
+                self._make_layers(
+                    out_channels=self.num_classes,
+                    in_channels=self.in_channels))
+            self.br_heat.append(
+                self._make_layers(
+                    out_channels=self.num_classes,
+                    in_channels=self.in_channels))
+
+            self.tl_off.append(
+                self._make_layers(
+                    out_channels=self.corner_offset_channels,
+                    in_channels=self.in_channels))
+            self.br_off.append(
+                self._make_layers(
+                    out_channels=self.corner_offset_channels,
+                    in_channels=self.in_channels))
+
+    def _init_corner_emb_layers(self) -> None:
+        """Initialize corner embedding layers.
+
+        Only include corner embedding branch with two parts: prefix `tl_` for
+        top-left and `br_` for bottom-right.
+        """
+        self.tl_emb, self.br_emb = nn.ModuleList(), nn.ModuleList()
+
+        for _ in range(self.num_feat_levels):
+            self.tl_emb.append(
+                self._make_layers(
+                    out_channels=self.corner_emb_channels,
+                    in_channels=self.in_channels))
+            self.br_emb.append(
+                self._make_layers(
+                    out_channels=self.corner_emb_channels,
+                    in_channels=self.in_channels))
+
+    def _init_layers(self) -> None:
+        """Initialize layers for CornerHead.
+
+        Including two parts: corner keypoint layers and corner embedding layers
+        """
+        self._init_corner_kpt_layers()
+        if self.with_corner_emb:
+            self._init_corner_emb_layers()
+
+    def init_weights(self) -> None:
+        super().init_weights()
+        bias_init = bias_init_with_prob(0.1)
+        for i in range(self.num_feat_levels):
+            # The initialization of parameters are different between
+            # nn.Conv2d and ConvModule. Our experiments show that
+            # using the original initialization of nn.Conv2d increases
+            # the final mAP by about 0.2%
+            self.tl_heat[i][-1].conv.reset_parameters()
+            self.tl_heat[i][-1].conv.bias.data.fill_(bias_init)
+            self.br_heat[i][-1].conv.reset_parameters()
+            self.br_heat[i][-1].conv.bias.data.fill_(bias_init)
+            self.tl_off[i][-1].conv.reset_parameters()
+            self.br_off[i][-1].conv.reset_parameters()
+            if self.with_corner_emb:
+                self.tl_emb[i][-1].conv.reset_parameters()
+                self.br_emb[i][-1].conv.reset_parameters()
+
+    def forward(self, feats: Tuple[Tensor]) -> tuple:
+        """Forward features from the upstream network.
+
+        Args:
+            feats (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple: Usually a tuple of corner heatmaps, offset heatmaps and
+            embedding heatmaps.
+                - tl_heats (list[Tensor]): Top-left corner heatmaps for all
+                  levels, each is a 4D-tensor, the channels number is
+                  num_classes.
+                - br_heats (list[Tensor]): Bottom-right corner heatmaps for all
+                  levels, each is a 4D-tensor, the channels number is
+                  num_classes.
+                - tl_embs (list[Tensor] | list[None]): Top-left embedding
+                  heatmaps for all levels, each is a 4D-tensor or None.
+                  If not None, the channels number is corner_emb_channels.
+                - br_embs (list[Tensor] | list[None]): Bottom-right embedding
+                  heatmaps for all levels, each is a 4D-tensor or None.
+                  If not None, the channels number is corner_emb_channels.
+                - tl_offs (list[Tensor]): Top-left offset heatmaps for all
+                  levels, each is a 4D-tensor. The channels number is
+                  corner_offset_channels.
+                - br_offs (list[Tensor]): Bottom-right offset heatmaps for all
+                  levels, each is a 4D-tensor. The channels number is
+                  corner_offset_channels.
+        """
+        lvl_ind = list(range(self.num_feat_levels))
+        return multi_apply(self.forward_single, feats, lvl_ind)
+
+    def forward_single(self,
+                       x: Tensor,
+                       lvl_ind: int,
+                       return_pool: bool = False) -> List[Tensor]:
+        """Forward feature of a single level.
+
+        Args:
+            x (Tensor): Feature of a single level.
+            lvl_ind (int): Level index of current feature.
+            return_pool (bool): Return corner pool feature or not.
+                Defaults to False.
+
+        Returns:
+            tuple[Tensor]: A tuple of CornerHead's output for current feature
+            level. Containing the following Tensors:
+
+                - tl_heat (Tensor): Predicted top-left corner heatmap.
+                - br_heat (Tensor): Predicted bottom-right corner heatmap.
+                - tl_emb (Tensor | None): Predicted top-left embedding heatmap.
+                  None for `self.with_corner_emb == False`.
+                - br_emb (Tensor | None): Predicted bottom-right embedding
+                  heatmap. None for `self.with_corner_emb == False`.
+                - tl_off (Tensor): Predicted top-left offset heatmap.
+                - br_off (Tensor): Predicted bottom-right offset heatmap.
+                - tl_pool (Tensor): Top-left corner pool feature. Not must
+                  have.
+                - br_pool (Tensor): Bottom-right corner pool feature. Not must
+                  have.
+        """
+        tl_pool = self.tl_pool[lvl_ind](x)
+        tl_heat = self.tl_heat[lvl_ind](tl_pool)
+        br_pool = self.br_pool[lvl_ind](x)
+        br_heat = self.br_heat[lvl_ind](br_pool)
+
+        tl_emb, br_emb = None, None
+        if self.with_corner_emb:
+            tl_emb = self.tl_emb[lvl_ind](tl_pool)
+            br_emb = self.br_emb[lvl_ind](br_pool)
+
+        tl_off = self.tl_off[lvl_ind](tl_pool)
+        br_off = self.br_off[lvl_ind](br_pool)
+
+        result_list = [tl_heat, br_heat, tl_emb, br_emb, tl_off, br_off]
+        if return_pool:
+            result_list.append(tl_pool)
+            result_list.append(br_pool)
+
+        return result_list
+
+    def get_targets(self,
+                    gt_bboxes: List[Tensor],
+                    gt_labels: List[Tensor],
+                    feat_shape: Sequence[int],
+                    img_shape: Sequence[int],
+                    with_corner_emb: bool = False,
+                    with_guiding_shift: bool = False,
+                    with_centripetal_shift: bool = False) -> dict:
+        """Generate corner targets.
+
+        Including corner heatmap, corner offset.
+
+        Optional: corner embedding, corner guiding shift, centripetal shift.
+
+        For CornerNet, we generate corner heatmap, corner offset and corner
+        embedding from this function.
+
+        For CentripetalNet, we generate corner heatmap, corner offset, guiding
+        shift and centripetal shift from this function.
+
+        Args:
+            gt_bboxes (list[Tensor]): Ground truth bboxes of each image, each
+                has shape (num_gt, 4).
+            gt_labels (list[Tensor]): Ground truth labels of each box, each has
+                shape (num_gt, ).
+            feat_shape (Sequence[int]): Shape of output feature,
+                [batch, channel, height, width].
+            img_shape (Sequence[int]): Shape of input image,
+                [height, width, channel].
+            with_corner_emb (bool): Generate corner embedding target or not.
+                Defaults to False.
+            with_guiding_shift (bool): Generate guiding shift target or not.
+                Defaults to False.
+            with_centripetal_shift (bool): Generate centripetal shift target or
+                not. Defaults to False.
+
+        Returns:
+            dict: Ground truth of corner heatmap, corner offset, corner
+            embedding, guiding shift and centripetal shift. Containing the
+            following keys:
+
+                - topleft_heatmap (Tensor): Ground truth top-left corner
+                  heatmap.
+                - bottomright_heatmap (Tensor): Ground truth bottom-right
+                  corner heatmap.
+                - topleft_offset (Tensor): Ground truth top-left corner offset.
+                - bottomright_offset (Tensor): Ground truth bottom-right corner
+                  offset.
+                - corner_embedding (list[list[list[int]]]): Ground truth corner
+                  embedding. Not must have.
+                - topleft_guiding_shift (Tensor): Ground truth top-left corner
+                  guiding shift. Not must have.
+                - bottomright_guiding_shift (Tensor): Ground truth bottom-right
+                  corner guiding shift. Not must have.
+                - topleft_centripetal_shift (Tensor): Ground truth top-left
+                  corner centripetal shift. Not must have.
+                - bottomright_centripetal_shift (Tensor): Ground truth
+                  bottom-right corner centripetal shift. Not must have.
+        """
+        batch_size, _, height, width = feat_shape
+        img_h, img_w = img_shape[:2]
+
+        width_ratio = float(width / img_w)
+        height_ratio = float(height / img_h)
+
+        gt_tl_heatmap = gt_bboxes[-1].new_zeros(
+            [batch_size, self.num_classes, height, width])
+        gt_br_heatmap = gt_bboxes[-1].new_zeros(
+            [batch_size, self.num_classes, height, width])
+        gt_tl_offset = gt_bboxes[-1].new_zeros([batch_size, 2, height, width])
+        gt_br_offset = gt_bboxes[-1].new_zeros([batch_size, 2, height, width])
+
+        if with_corner_emb:
+            match = []
+
+        # Guiding shift is a kind of offset, from center to corner
+        if with_guiding_shift:
+            gt_tl_guiding_shift = gt_bboxes[-1].new_zeros(
+                [batch_size, 2, height, width])
+            gt_br_guiding_shift = gt_bboxes[-1].new_zeros(
+                [batch_size, 2, height, width])
+        # Centripetal shift is also a kind of offset, from center to corner
+        # and normalized by log.
+        if with_centripetal_shift:
+            gt_tl_centripetal_shift = gt_bboxes[-1].new_zeros(
+                [batch_size, 2, height, width])
+            gt_br_centripetal_shift = gt_bboxes[-1].new_zeros(
+                [batch_size, 2, height, width])
+
+        for batch_id in range(batch_size):
+            # Ground truth of corner embedding per image is a list of coord set
+            corner_match = []
+            for box_id in range(len(gt_labels[batch_id])):
+                left, top, right, bottom = gt_bboxes[batch_id][box_id]
+                center_x = (left + right) / 2.0
+                center_y = (top + bottom) / 2.0
+                label = gt_labels[batch_id][box_id]
+
+                # Use coords in the feature level to generate ground truth
+                scale_left = left * width_ratio
+                scale_right = right * width_ratio
+                scale_top = top * height_ratio
+                scale_bottom = bottom * height_ratio
+                scale_center_x = center_x * width_ratio
+                scale_center_y = center_y * height_ratio
+
+                # Int coords on feature map/ground truth tensor
+                left_idx = int(min(scale_left, width - 1))
+                right_idx = int(min(scale_right, width - 1))
+                top_idx = int(min(scale_top, height - 1))
+                bottom_idx = int(min(scale_bottom, height - 1))
+
+                # Generate gaussian heatmap
+                scale_box_width = ceil(scale_right - scale_left)
+                scale_box_height = ceil(scale_bottom - scale_top)
+                radius = gaussian_radius((scale_box_height, scale_box_width),
+                                         min_overlap=0.3)
+                radius = max(0, int(radius))
+                gt_tl_heatmap[batch_id, label] = gen_gaussian_target(
+                    gt_tl_heatmap[batch_id, label], [left_idx, top_idx],
+                    radius)
+                gt_br_heatmap[batch_id, label] = gen_gaussian_target(
+                    gt_br_heatmap[batch_id, label], [right_idx, bottom_idx],
+                    radius)
+
+                # Generate corner offset
+                left_offset = scale_left - left_idx
+                top_offset = scale_top - top_idx
+                right_offset = scale_right - right_idx
+                bottom_offset = scale_bottom - bottom_idx
+                gt_tl_offset[batch_id, 0, top_idx, left_idx] = left_offset
+                gt_tl_offset[batch_id, 1, top_idx, left_idx] = top_offset
+                gt_br_offset[batch_id, 0, bottom_idx, right_idx] = right_offset
+                gt_br_offset[batch_id, 1, bottom_idx,
+                             right_idx] = bottom_offset
+
+                # Generate corner embedding
+                if with_corner_emb:
+                    corner_match.append([[top_idx, left_idx],
+                                         [bottom_idx, right_idx]])
+                # Generate guiding shift
+                if with_guiding_shift:
+                    gt_tl_guiding_shift[batch_id, 0, top_idx,
+                                        left_idx] = scale_center_x - left_idx
+                    gt_tl_guiding_shift[batch_id, 1, top_idx,
+                                        left_idx] = scale_center_y - top_idx
+                    gt_br_guiding_shift[batch_id, 0, bottom_idx,
+                                        right_idx] = right_idx - scale_center_x
+                    gt_br_guiding_shift[
+                        batch_id, 1, bottom_idx,
+                        right_idx] = bottom_idx - scale_center_y
+                # Generate centripetal shift
+                if with_centripetal_shift:
+                    gt_tl_centripetal_shift[batch_id, 0, top_idx,
+                                            left_idx] = log(scale_center_x -
+                                                            scale_left)
+                    gt_tl_centripetal_shift[batch_id, 1, top_idx,
+                                            left_idx] = log(scale_center_y -
+                                                            scale_top)
+                    gt_br_centripetal_shift[batch_id, 0, bottom_idx,
+                                            right_idx] = log(scale_right -
+                                                             scale_center_x)
+                    gt_br_centripetal_shift[batch_id, 1, bottom_idx,
+                                            right_idx] = log(scale_bottom -
+                                                             scale_center_y)
+
+            if with_corner_emb:
+                match.append(corner_match)
+
+        target_result = dict(
+            topleft_heatmap=gt_tl_heatmap,
+            topleft_offset=gt_tl_offset,
+            bottomright_heatmap=gt_br_heatmap,
+            bottomright_offset=gt_br_offset)
+
+        if with_corner_emb:
+            target_result.update(corner_embedding=match)
+        if with_guiding_shift:
+            target_result.update(
+                topleft_guiding_shift=gt_tl_guiding_shift,
+                bottomright_guiding_shift=gt_br_guiding_shift)
+        if with_centripetal_shift:
+            target_result.update(
+                topleft_centripetal_shift=gt_tl_centripetal_shift,
+                bottomright_centripetal_shift=gt_br_centripetal_shift)
+
+        return target_result
+
+    def loss_by_feat(
+            self,
+            tl_heats: List[Tensor],
+            br_heats: List[Tensor],
+            tl_embs: List[Tensor],
+            br_embs: List[Tensor],
+            tl_offs: List[Tensor],
+            br_offs: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> dict:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            tl_heats (list[Tensor]): Top-left corner heatmaps for each level
+                with shape (N, num_classes, H, W).
+            br_heats (list[Tensor]): Bottom-right corner heatmaps for each
+                level with shape (N, num_classes, H, W).
+            tl_embs (list[Tensor]): Top-left corner embeddings for each level
+                with shape (N, corner_emb_channels, H, W).
+            br_embs (list[Tensor]): Bottom-right corner embeddings for each
+                level with shape (N, corner_emb_channels, H, W).
+            tl_offs (list[Tensor]): Top-left corner offsets for each level
+                with shape (N, corner_offset_channels, H, W).
+            br_offs (list[Tensor]): Bottom-right corner offsets for each level
+                with shape (N, corner_offset_channels, H, W).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Specify which bounding boxes can be ignored when computing
+                the loss.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components. Containing the
+            following losses:
+
+                - det_loss (list[Tensor]): Corner keypoint losses of all
+                  feature levels.
+                - pull_loss (list[Tensor]): Part one of AssociativeEmbedding
+                  losses of all feature levels.
+                - push_loss (list[Tensor]): Part two of AssociativeEmbedding
+                  losses of all feature levels.
+                - off_loss (list[Tensor]): Corner offset losses of all feature
+                  levels.
+        """
+        gt_bboxes = [
+            gt_instances.bboxes for gt_instances in batch_gt_instances
+        ]
+        gt_labels = [
+            gt_instances.labels for gt_instances in batch_gt_instances
+        ]
+
+        targets = self.get_targets(
+            gt_bboxes,
+            gt_labels,
+            tl_heats[-1].shape,
+            batch_img_metas[0]['batch_input_shape'],
+            with_corner_emb=self.with_corner_emb)
+        mlvl_targets = [targets for _ in range(self.num_feat_levels)]
+        det_losses, pull_losses, push_losses, off_losses = multi_apply(
+            self.loss_by_feat_single, tl_heats, br_heats, tl_embs, br_embs,
+            tl_offs, br_offs, mlvl_targets)
+        loss_dict = dict(det_loss=det_losses, off_loss=off_losses)
+        if self.with_corner_emb:
+            loss_dict.update(pull_loss=pull_losses, push_loss=push_losses)
+        return loss_dict
+
+    def loss_by_feat_single(self, tl_hmp: Tensor, br_hmp: Tensor,
+                            tl_emb: Optional[Tensor], br_emb: Optional[Tensor],
+                            tl_off: Tensor, br_off: Tensor,
+                            targets: dict) -> Tuple[Tensor, ...]:
+        """Calculate the loss of a single scale level based on the features
+        extracted by the detection head.
+
+        Args:
+            tl_hmp (Tensor): Top-left corner heatmap for current level with
+                shape (N, num_classes, H, W).
+            br_hmp (Tensor): Bottom-right corner heatmap for current level with
+                shape (N, num_classes, H, W).
+            tl_emb (Tensor, optional): Top-left corner embedding for current
+                level with shape (N, corner_emb_channels, H, W).
+            br_emb (Tensor, optional): Bottom-right corner embedding for
+                current level with shape (N, corner_emb_channels, H, W).
+            tl_off (Tensor): Top-left corner offset for current level with
+                shape (N, corner_offset_channels, H, W).
+            br_off (Tensor): Bottom-right corner offset for current level with
+                shape (N, corner_offset_channels, H, W).
+            targets (dict): Corner target generated by `get_targets`.
+
+        Returns:
+            tuple[torch.Tensor]: Losses of the head's different branches
+            containing the following losses:
+
+                - det_loss (Tensor): Corner keypoint loss.
+                - pull_loss (Tensor): Part one of AssociativeEmbedding loss.
+                - push_loss (Tensor): Part two of AssociativeEmbedding loss.
+                - off_loss (Tensor): Corner offset loss.
+        """
+        gt_tl_hmp = targets['topleft_heatmap']
+        gt_br_hmp = targets['bottomright_heatmap']
+        gt_tl_off = targets['topleft_offset']
+        gt_br_off = targets['bottomright_offset']
+        gt_embedding = targets['corner_embedding']
+
+        # Detection loss
+        tl_det_loss = self.loss_heatmap(
+            tl_hmp.sigmoid(),
+            gt_tl_hmp,
+            avg_factor=max(1,
+                           gt_tl_hmp.eq(1).sum()))
+        br_det_loss = self.loss_heatmap(
+            br_hmp.sigmoid(),
+            gt_br_hmp,
+            avg_factor=max(1,
+                           gt_br_hmp.eq(1).sum()))
+        det_loss = (tl_det_loss + br_det_loss) / 2.0
+
+        # AssociativeEmbedding loss
+        if self.with_corner_emb and self.loss_embedding is not None:
+            pull_loss, push_loss = self.loss_embedding(tl_emb, br_emb,
+                                                       gt_embedding)
+        else:
+            pull_loss, push_loss = None, None
+
+        # Offset loss
+        # We only compute the offset loss at the real corner position.
+        # The value of real corner would be 1 in heatmap ground truth.
+        # The mask is computed in class agnostic mode and its shape is
+        # batch * 1 * width * height.
+        tl_off_mask = gt_tl_hmp.eq(1).sum(1).gt(0).unsqueeze(1).type_as(
+            gt_tl_hmp)
+        br_off_mask = gt_br_hmp.eq(1).sum(1).gt(0).unsqueeze(1).type_as(
+            gt_br_hmp)
+        tl_off_loss = self.loss_offset(
+            tl_off,
+            gt_tl_off,
+            tl_off_mask,
+            avg_factor=max(1, tl_off_mask.sum()))
+        br_off_loss = self.loss_offset(
+            br_off,
+            gt_br_off,
+            br_off_mask,
+            avg_factor=max(1, br_off_mask.sum()))
+
+        off_loss = (tl_off_loss + br_off_loss) / 2.0
+
+        return det_loss, pull_loss, push_loss, off_loss
+
+    def predict_by_feat(self,
+                        tl_heats: List[Tensor],
+                        br_heats: List[Tensor],
+                        tl_embs: List[Tensor],
+                        br_embs: List[Tensor],
+                        tl_offs: List[Tensor],
+                        br_offs: List[Tensor],
+                        batch_img_metas: Optional[List[dict]] = None,
+                        rescale: bool = False,
+                        with_nms: bool = True) -> InstanceList:
+        """Transform a batch of output features extracted from the head into
+        bbox results.
+
+        Args:
+            tl_heats (list[Tensor]): Top-left corner heatmaps for each level
+                with shape (N, num_classes, H, W).
+            br_heats (list[Tensor]): Bottom-right corner heatmaps for each
+                level with shape (N, num_classes, H, W).
+            tl_embs (list[Tensor]): Top-left corner embeddings for each level
+                with shape (N, corner_emb_channels, H, W).
+            br_embs (list[Tensor]): Bottom-right corner embeddings for each
+                level with shape (N, corner_emb_channels, H, W).
+            tl_offs (list[Tensor]): Top-left corner offsets for each level
+                with shape (N, corner_offset_channels, H, W).
+            br_offs (list[Tensor]): Bottom-right corner offsets for each level
+                with shape (N, corner_offset_channels, H, W).
+            batch_img_metas (list[dict], optional): Batch image meta info.
+                Defaults to None.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            with_nms (bool): If True, do nms before return boxes.
+                Defaults to True.
+
+        Returns:
+            list[:obj:`InstanceData`]: Object detection results of each image
+            after the post process. Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        assert tl_heats[-1].shape[0] == br_heats[-1].shape[0] == len(
+            batch_img_metas)
+        result_list = []
+        for img_id in range(len(batch_img_metas)):
+            result_list.append(
+                self._predict_by_feat_single(
+                    tl_heats[-1][img_id:img_id + 1, :],
+                    br_heats[-1][img_id:img_id + 1, :],
+                    tl_offs[-1][img_id:img_id + 1, :],
+                    br_offs[-1][img_id:img_id + 1, :],
+                    batch_img_metas[img_id],
+                    tl_emb=tl_embs[-1][img_id:img_id + 1, :],
+                    br_emb=br_embs[-1][img_id:img_id + 1, :],
+                    rescale=rescale,
+                    with_nms=with_nms))
+
+        return result_list
+
+    def _predict_by_feat_single(self,
+                                tl_heat: Tensor,
+                                br_heat: Tensor,
+                                tl_off: Tensor,
+                                br_off: Tensor,
+                                img_meta: dict,
+                                tl_emb: Optional[Tensor] = None,
+                                br_emb: Optional[Tensor] = None,
+                                tl_centripetal_shift: Optional[Tensor] = None,
+                                br_centripetal_shift: Optional[Tensor] = None,
+                                rescale: bool = False,
+                                with_nms: bool = True) -> InstanceData:
+        """Transform a single image's features extracted from the head into
+        bbox results.
+
+        Args:
+            tl_heat (Tensor): Top-left corner heatmap for current level with
+                shape (N, num_classes, H, W).
+            br_heat (Tensor): Bottom-right corner heatmap for current level
+                with shape (N, num_classes, H, W).
+            tl_off (Tensor): Top-left corner offset for current level with
+                shape (N, corner_offset_channels, H, W).
+            br_off (Tensor): Bottom-right corner offset for current level with
+                shape (N, corner_offset_channels, H, W).
+            img_meta (dict): Meta information of current image, e.g.,
+                image size, scaling factor, etc.
+            tl_emb (Tensor): Top-left corner embedding for current level with
+                shape (N, corner_emb_channels, H, W).
+            br_emb (Tensor): Bottom-right corner embedding for current level
+                with shape (N, corner_emb_channels, H, W).
+            tl_centripetal_shift: Top-left corner's centripetal shift for
+                current level with shape (N, 2, H, W).
+            br_centripetal_shift: Bottom-right corner's centripetal shift for
+                current level with shape (N, 2, H, W).
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            with_nms (bool): If True, do nms before return boxes.
+                Defaults to True.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        if isinstance(img_meta, (list, tuple)):
+            img_meta = img_meta[0]
+
+        batch_bboxes, batch_scores, batch_clses = self._decode_heatmap(
+            tl_heat=tl_heat.sigmoid(),
+            br_heat=br_heat.sigmoid(),
+            tl_off=tl_off,
+            br_off=br_off,
+            tl_emb=tl_emb,
+            br_emb=br_emb,
+            tl_centripetal_shift=tl_centripetal_shift,
+            br_centripetal_shift=br_centripetal_shift,
+            img_meta=img_meta,
+            k=self.test_cfg.corner_topk,
+            kernel=self.test_cfg.local_maximum_kernel,
+            distance_threshold=self.test_cfg.distance_threshold)
+
+        if rescale and 'scale_factor' in img_meta:
+            batch_bboxes /= batch_bboxes.new_tensor(
+                img_meta['scale_factor']).repeat((1, 2))
+
+        bboxes = batch_bboxes.view([-1, 4])
+        scores = batch_scores.view(-1)
+        clses = batch_clses.view(-1)
+
+        det_bboxes = torch.cat([bboxes, scores.unsqueeze(-1)], -1)
+        keepinds = (det_bboxes[:, -1] > -0.1)
+        det_bboxes = det_bboxes[keepinds]
+        det_labels = clses[keepinds]
+
+        if with_nms:
+            det_bboxes, det_labels = self._bboxes_nms(det_bboxes, det_labels,
+                                                      self.test_cfg)
+
+        results = InstanceData()
+        results.bboxes = det_bboxes[..., :4]
+        results.scores = det_bboxes[..., 4]
+        results.labels = det_labels
+        return results
+
+    def _bboxes_nms(self, bboxes: Tensor, labels: Tensor,
+                    cfg: ConfigDict) -> Tuple[Tensor, Tensor]:
+        """bboxes nms."""
+        if 'nms_cfg' in cfg:
+            warning.warn('nms_cfg in test_cfg will be deprecated. '
+                         'Please rename it as nms')
+        if 'nms' not in cfg:
+            cfg.nms = cfg.nms_cfg
+
+        if labels.numel() > 0:
+            max_num = cfg.max_per_img
+            bboxes, keep = batched_nms(bboxes[:, :4], bboxes[:,
+                                                             -1].contiguous(),
+                                       labels, cfg.nms)
+            if max_num > 0:
+                bboxes = bboxes[:max_num]
+                labels = labels[keep][:max_num]
+
+        return bboxes, labels
+
+    def _decode_heatmap(self,
+                        tl_heat: Tensor,
+                        br_heat: Tensor,
+                        tl_off: Tensor,
+                        br_off: Tensor,
+                        tl_emb: Optional[Tensor] = None,
+                        br_emb: Optional[Tensor] = None,
+                        tl_centripetal_shift: Optional[Tensor] = None,
+                        br_centripetal_shift: Optional[Tensor] = None,
+                        img_meta: Optional[dict] = None,
+                        k: int = 100,
+                        kernel: int = 3,
+                        distance_threshold: float = 0.5,
+                        num_dets: int = 1000) -> Tuple[Tensor, Tensor, Tensor]:
+        """Transform outputs into detections raw bbox prediction.
+
+        Args:
+            tl_heat (Tensor): Top-left corner heatmap for current level with
+                shape (N, num_classes, H, W).
+            br_heat (Tensor): Bottom-right corner heatmap for current level
+                with shape (N, num_classes, H, W).
+            tl_off (Tensor): Top-left corner offset for current level with
+                shape (N, corner_offset_channels, H, W).
+            br_off (Tensor): Bottom-right corner offset for current level with
+                shape (N, corner_offset_channels, H, W).
+            tl_emb (Tensor, Optional): Top-left corner embedding for current
+                level with shape (N, corner_emb_channels, H, W).
+            br_emb (Tensor, Optional): Bottom-right corner embedding for
+                current level with shape (N, corner_emb_channels, H, W).
+            tl_centripetal_shift (Tensor, Optional): Top-left centripetal shift
+                for current level with shape (N, 2, H, W).
+            br_centripetal_shift (Tensor, Optional): Bottom-right centripetal
+                shift for current level with shape (N, 2, H, W).
+            img_meta (dict): Meta information of current image, e.g.,
+                image size, scaling factor, etc.
+            k (int): Get top k corner keypoints from heatmap.
+            kernel (int): Max pooling kernel for extract local maximum pixels.
+            distance_threshold (float): Distance threshold. Top-left and
+                bottom-right corner keypoints with feature distance less than
+                the threshold will be regarded as keypoints from same object.
+            num_dets (int): Num of raw boxes before doing nms.
+
+        Returns:
+            tuple[torch.Tensor]: Decoded output of CornerHead, containing the
+            following Tensors:
+
+            - bboxes (Tensor): Coords of each box.
+            - scores (Tensor): Scores of each box.
+            - clses (Tensor): Categories of each box.
+        """
+        with_embedding = tl_emb is not None and br_emb is not None
+        with_centripetal_shift = (
+            tl_centripetal_shift is not None
+            and br_centripetal_shift is not None)
+        assert with_embedding + with_centripetal_shift == 1
+        batch, _, height, width = tl_heat.size()
+        if torch.onnx.is_in_onnx_export():
+            inp_h, inp_w = img_meta['pad_shape_for_onnx'][:2]
+        else:
+            inp_h, inp_w = img_meta['batch_input_shape'][:2]
+
+        # perform nms on heatmaps
+        tl_heat = get_local_maximum(tl_heat, kernel=kernel)
+        br_heat = get_local_maximum(br_heat, kernel=kernel)
+
+        tl_scores, tl_inds, tl_clses, tl_ys, tl_xs = get_topk_from_heatmap(
+            tl_heat, k=k)
+        br_scores, br_inds, br_clses, br_ys, br_xs = get_topk_from_heatmap(
+            br_heat, k=k)
+
+        # We use repeat instead of expand here because expand is a
+        # shallow-copy function. Thus it could cause unexpected testing result
+        # sometimes. Using expand will decrease about 10% mAP during testing
+        # compared to repeat.
+        tl_ys = tl_ys.view(batch, k, 1).repeat(1, 1, k)
+        tl_xs = tl_xs.view(batch, k, 1).repeat(1, 1, k)
+        br_ys = br_ys.view(batch, 1, k).repeat(1, k, 1)
+        br_xs = br_xs.view(batch, 1, k).repeat(1, k, 1)
+
+        tl_off = transpose_and_gather_feat(tl_off, tl_inds)
+        tl_off = tl_off.view(batch, k, 1, 2)
+        br_off = transpose_and_gather_feat(br_off, br_inds)
+        br_off = br_off.view(batch, 1, k, 2)
+
+        tl_xs = tl_xs + tl_off[..., 0]
+        tl_ys = tl_ys + tl_off[..., 1]
+        br_xs = br_xs + br_off[..., 0]
+        br_ys = br_ys + br_off[..., 1]
+
+        if with_centripetal_shift:
+            tl_centripetal_shift = transpose_and_gather_feat(
+                tl_centripetal_shift, tl_inds).view(batch, k, 1, 2).exp()
+            br_centripetal_shift = transpose_and_gather_feat(
+                br_centripetal_shift, br_inds).view(batch, 1, k, 2).exp()
+
+            tl_ctxs = tl_xs + tl_centripetal_shift[..., 0]
+            tl_ctys = tl_ys + tl_centripetal_shift[..., 1]
+            br_ctxs = br_xs - br_centripetal_shift[..., 0]
+            br_ctys = br_ys - br_centripetal_shift[..., 1]
+
+        # all possible boxes based on top k corners (ignoring class)
+        tl_xs *= (inp_w / width)
+        tl_ys *= (inp_h / height)
+        br_xs *= (inp_w / width)
+        br_ys *= (inp_h / height)
+
+        if with_centripetal_shift:
+            tl_ctxs *= (inp_w / width)
+            tl_ctys *= (inp_h / height)
+            br_ctxs *= (inp_w / width)
+            br_ctys *= (inp_h / height)
+
+        x_off, y_off = 0, 0  # no crop
+        if not torch.onnx.is_in_onnx_export():
+            # since `RandomCenterCropPad` is done on CPU with numpy and it's
+            # not dynamic traceable when exporting to ONNX, thus 'border'
+            # does not appears as key in 'img_meta'. As a tmp solution,
+            # we move this 'border' handle part to the postprocess after
+            # finished exporting to ONNX, which is handle in
+            # `mmdet/core/export/model_wrappers.py`. Though difference between
+            # pytorch and exported onnx model, it might be ignored since
+            # comparable performance is achieved between them (e.g. 40.4 vs
+            # 40.6 on COCO val2017, for CornerNet without test-time flip)
+            if 'border' in img_meta:
+                x_off = img_meta['border'][2]
+                y_off = img_meta['border'][0]
+
+        tl_xs -= x_off
+        tl_ys -= y_off
+        br_xs -= x_off
+        br_ys -= y_off
+
+        zeros = tl_xs.new_zeros(*tl_xs.size())
+        tl_xs = torch.where(tl_xs > 0.0, tl_xs, zeros)
+        tl_ys = torch.where(tl_ys > 0.0, tl_ys, zeros)
+        br_xs = torch.where(br_xs > 0.0, br_xs, zeros)
+        br_ys = torch.where(br_ys > 0.0, br_ys, zeros)
+
+        bboxes = torch.stack((tl_xs, tl_ys, br_xs, br_ys), dim=3)
+        area_bboxes = ((br_xs - tl_xs) * (br_ys - tl_ys)).abs()
+
+        if with_centripetal_shift:
+            tl_ctxs -= x_off
+            tl_ctys -= y_off
+            br_ctxs -= x_off
+            br_ctys -= y_off
+
+            tl_ctxs *= tl_ctxs.gt(0.0).type_as(tl_ctxs)
+            tl_ctys *= tl_ctys.gt(0.0).type_as(tl_ctys)
+            br_ctxs *= br_ctxs.gt(0.0).type_as(br_ctxs)
+            br_ctys *= br_ctys.gt(0.0).type_as(br_ctys)
+
+            ct_bboxes = torch.stack((tl_ctxs, tl_ctys, br_ctxs, br_ctys),
+                                    dim=3)
+            area_ct_bboxes = ((br_ctxs - tl_ctxs) * (br_ctys - tl_ctys)).abs()
+
+            rcentral = torch.zeros_like(ct_bboxes)
+            # magic nums from paper section 4.1
+            mu = torch.ones_like(area_bboxes) / 2.4
+            mu[area_bboxes > 3500] = 1 / 2.1  # large bbox have smaller mu
+
+            bboxes_center_x = (bboxes[..., 0] + bboxes[..., 2]) / 2
+            bboxes_center_y = (bboxes[..., 1] + bboxes[..., 3]) / 2
+            rcentral[..., 0] = bboxes_center_x - mu * (bboxes[..., 2] -
+                                                       bboxes[..., 0]) / 2
+            rcentral[..., 1] = bboxes_center_y - mu * (bboxes[..., 3] -
+                                                       bboxes[..., 1]) / 2
+            rcentral[..., 2] = bboxes_center_x + mu * (bboxes[..., 2] -
+                                                       bboxes[..., 0]) / 2
+            rcentral[..., 3] = bboxes_center_y + mu * (bboxes[..., 3] -
+                                                       bboxes[..., 1]) / 2
+            area_rcentral = ((rcentral[..., 2] - rcentral[..., 0]) *
+                             (rcentral[..., 3] - rcentral[..., 1])).abs()
+            dists = area_ct_bboxes / area_rcentral
+
+            tl_ctx_inds = (ct_bboxes[..., 0] <= rcentral[..., 0]) | (
+                ct_bboxes[..., 0] >= rcentral[..., 2])
+            tl_cty_inds = (ct_bboxes[..., 1] <= rcentral[..., 1]) | (
+                ct_bboxes[..., 1] >= rcentral[..., 3])
+            br_ctx_inds = (ct_bboxes[..., 2] <= rcentral[..., 0]) | (
+                ct_bboxes[..., 2] >= rcentral[..., 2])
+            br_cty_inds = (ct_bboxes[..., 3] <= rcentral[..., 1]) | (
+                ct_bboxes[..., 3] >= rcentral[..., 3])
+
+        if with_embedding:
+            tl_emb = transpose_and_gather_feat(tl_emb, tl_inds)
+            tl_emb = tl_emb.view(batch, k, 1)
+            br_emb = transpose_and_gather_feat(br_emb, br_inds)
+            br_emb = br_emb.view(batch, 1, k)
+            dists = torch.abs(tl_emb - br_emb)
+
+        tl_scores = tl_scores.view(batch, k, 1).repeat(1, 1, k)
+        br_scores = br_scores.view(batch, 1, k).repeat(1, k, 1)
+
+        scores = (tl_scores + br_scores) / 2  # scores for all possible boxes
+
+        # tl and br should have same class
+        tl_clses = tl_clses.view(batch, k, 1).repeat(1, 1, k)
+        br_clses = br_clses.view(batch, 1, k).repeat(1, k, 1)
+        cls_inds = (tl_clses != br_clses)
+
+        # reject boxes based on distances
+        dist_inds = dists > distance_threshold
+
+        # reject boxes based on widths and heights
+        width_inds = (br_xs <= tl_xs)
+        height_inds = (br_ys <= tl_ys)
+
+        # No use `scores[cls_inds]`, instead we use `torch.where` here.
+        # Since only 1-D indices with type 'tensor(bool)' are supported
+        # when exporting to ONNX, any other bool indices with more dimensions
+        # (e.g. 2-D bool tensor) as input parameter in node is invalid
+        negative_scores = -1 * torch.ones_like(scores)
+        scores = torch.where(cls_inds, negative_scores, scores)
+        scores = torch.where(width_inds, negative_scores, scores)
+        scores = torch.where(height_inds, negative_scores, scores)
+        scores = torch.where(dist_inds, negative_scores, scores)
+
+        if with_centripetal_shift:
+            scores[tl_ctx_inds] = -1
+            scores[tl_cty_inds] = -1
+            scores[br_ctx_inds] = -1
+            scores[br_cty_inds] = -1
+
+        scores = scores.view(batch, -1)
+        scores, inds = torch.topk(scores, num_dets)
+        scores = scores.unsqueeze(2)
+
+        bboxes = bboxes.view(batch, -1, 4)
+        bboxes = gather_feat(bboxes, inds)
+
+        clses = tl_clses.contiguous().view(batch, -1, 1)
+        clses = gather_feat(clses, inds)
+
+        return bboxes, scores, clses
diff --git a/mmdetection/mmdet/models/dense_heads/dab_detr_head.py b/mmdetection/mmdet/models/dense_heads/dab_detr_head.py
new file mode 100644
index 00000000..892833ff
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/dab_detr_head.py
@@ -0,0 +1,106 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Tuple
+
+import torch.nn as nn
+from mmcv.cnn import Linear
+from mmengine.model import bias_init_with_prob, constant_init
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.utils import InstanceList
+from ..layers import MLP, inverse_sigmoid
+from .conditional_detr_head import ConditionalDETRHead
+
+
+@MODELS.register_module()
+class DABDETRHead(ConditionalDETRHead):
+    """Head of DAB-DETR. DAB-DETR: Dynamic Anchor Boxes are Better Queries for
+    DETR.
+
+    More details can be found in the `paper
+    `_ .
+    """
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the transformer head."""
+        # cls branch
+        self.fc_cls = Linear(self.embed_dims, self.cls_out_channels)
+        # reg branch
+        self.fc_reg = MLP(self.embed_dims, self.embed_dims, 4, 3)
+
+    def init_weights(self) -> None:
+        """initialize weights."""
+        if self.loss_cls.use_sigmoid:
+            bias_init = bias_init_with_prob(0.01)
+            nn.init.constant_(self.fc_cls.bias, bias_init)
+        constant_init(self.fc_reg.layers[-1], 0., bias=0.)
+
+    def forward(self, hidden_states: Tensor,
+                references: Tensor) -> Tuple[Tensor, Tensor]:
+        """"Forward function.
+
+        Args:
+            hidden_states (Tensor): Features from transformer decoder. If
+                `return_intermediate_dec` is True output has shape
+                (num_decoder_layers, bs, num_queries, dim), else has shape (1,
+                bs, num_queries, dim) which only contains the last layer
+                outputs.
+            references (Tensor): References from transformer decoder. If
+                `return_intermediate_dec` is True output has shape
+                (num_decoder_layers, bs, num_queries, 2/4), else has shape (1,
+                bs, num_queries, 2/4)
+                which only contains the last layer reference.
+        Returns:
+            tuple[Tensor]: results of head containing the following tensor.
+
+            - layers_cls_scores (Tensor): Outputs from the classification head,
+              shape (num_decoder_layers, bs, num_queries, cls_out_channels).
+              Note cls_out_channels should include background.
+            - layers_bbox_preds (Tensor): Sigmoid outputs from the regression
+              head with normalized coordinate format (cx, cy, w, h), has shape
+              (num_decoder_layers, bs, num_queries, 4).
+        """
+        layers_cls_scores = self.fc_cls(hidden_states)
+        references_before_sigmoid = inverse_sigmoid(references, eps=1e-3)
+        tmp_reg_preds = self.fc_reg(hidden_states)
+        tmp_reg_preds[..., :references_before_sigmoid.
+                      size(-1)] += references_before_sigmoid
+        layers_bbox_preds = tmp_reg_preds.sigmoid()
+        return layers_cls_scores, layers_bbox_preds
+
+    def predict(self,
+                hidden_states: Tensor,
+                references: Tensor,
+                batch_data_samples: SampleList,
+                rescale: bool = True) -> InstanceList:
+        """Perform forward propagation of the detection head and predict
+        detection results on the features of the upstream network. Over-write
+        because img_metas are needed as inputs for bbox_head.
+
+        Args:
+            hidden_states (Tensor): Feature from the transformer decoder, has
+                shape (num_decoder_layers, bs, num_queries, dim).
+            references (Tensor): references from the transformer decoder, has
+                shape (num_decoder_layers, bs, num_queries, 2/4).
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            rescale (bool, optional): Whether to rescale the results.
+                Defaults to True.
+
+        Returns:
+            list[obj:`InstanceData`]: Detection results of each image
+            after the post process.
+        """
+        batch_img_metas = [
+            data_samples.metainfo for data_samples in batch_data_samples
+        ]
+
+        last_layer_hidden_state = hidden_states[-1].unsqueeze(0)
+        last_layer_reference = references[-1].unsqueeze(0)
+        outs = self(last_layer_hidden_state, last_layer_reference)
+
+        predictions = self.predict_by_feat(
+            *outs, batch_img_metas=batch_img_metas, rescale=rescale)
+        return predictions
diff --git a/mmdetection/mmdet/models/dense_heads/ddod_head.py b/mmdetection/mmdet/models/dense_heads/ddod_head.py
new file mode 100644
index 00000000..64e91ff0
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/ddod_head.py
@@ -0,0 +1,794 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Sequence, Tuple
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule, Scale
+from mmengine.model import bias_init_with_prob, normal_init
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.structures.bbox import bbox_overlaps
+from mmdet.utils import (ConfigType, InstanceList, OptConfigType,
+                         OptInstanceList, reduce_mean)
+from ..task_modules.prior_generators import anchor_inside_flags
+from ..utils import images_to_levels, multi_apply, unmap
+from .anchor_head import AnchorHead
+
+EPS = 1e-12
+
+
+@MODELS.register_module()
+class DDODHead(AnchorHead):
+    """Detection Head of `DDOD `_.
+
+    DDOD head decomposes conjunctions lying in most current one-stage
+    detectors via label assignment disentanglement, spatial feature
+    disentanglement, and pyramid supervision disentanglement.
+
+    Args:
+        num_classes (int): Number of categories excluding the
+            background category.
+        in_channels (int): Number of channels in the input feature map.
+        stacked_convs (int): The number of stacked Conv. Defaults to 4.
+        conv_cfg (:obj:`ConfigDict` or dict, optional): Config dict for
+            convolution layer. Defaults to None.
+        use_dcn (bool): Use dcn, Same as ATSS when False. Defaults to True.
+        norm_cfg (:obj:`ConfigDict` or dict): Normal config of ddod head.
+            Defaults to dict(type='GN', num_groups=32, requires_grad=True).
+        loss_iou (:obj:`ConfigDict` or dict): Config of IoU loss. Defaults to
+            dict(type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0).
+    """
+
+    def __init__(self,
+                 num_classes: int,
+                 in_channels: int,
+                 stacked_convs: int = 4,
+                 conv_cfg: OptConfigType = None,
+                 use_dcn: bool = True,
+                 norm_cfg: ConfigType = dict(
+                     type='GN', num_groups=32, requires_grad=True),
+                 loss_iou: ConfigType = dict(
+                     type='CrossEntropyLoss',
+                     use_sigmoid=True,
+                     loss_weight=1.0),
+                 **kwargs) -> None:
+        self.stacked_convs = stacked_convs
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.use_dcn = use_dcn
+        super().__init__(num_classes, in_channels, **kwargs)
+
+        if self.train_cfg:
+            self.cls_assigner = TASK_UTILS.build(self.train_cfg['assigner'])
+            self.reg_assigner = TASK_UTILS.build(
+                self.train_cfg['reg_assigner'])
+        self.loss_iou = MODELS.build(loss_iou)
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        self.relu = nn.ReLU(inplace=True)
+        self.cls_convs = nn.ModuleList()
+        self.reg_convs = nn.ModuleList()
+        for i in range(self.stacked_convs):
+            chn = self.in_channels if i == 0 else self.feat_channels
+            self.cls_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=dict(type='DCN', deform_groups=1)
+                    if i == 0 and self.use_dcn else self.conv_cfg,
+                    norm_cfg=self.norm_cfg))
+            self.reg_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=dict(type='DCN', deform_groups=1)
+                    if i == 0 and self.use_dcn else self.conv_cfg,
+                    norm_cfg=self.norm_cfg))
+        self.atss_cls = nn.Conv2d(
+            self.feat_channels,
+            self.num_base_priors * self.cls_out_channels,
+            3,
+            padding=1)
+        self.atss_reg = nn.Conv2d(
+            self.feat_channels, self.num_base_priors * 4, 3, padding=1)
+        self.atss_iou = nn.Conv2d(
+            self.feat_channels, self.num_base_priors * 1, 3, padding=1)
+        self.scales = nn.ModuleList(
+            [Scale(1.0) for _ in self.prior_generator.strides])
+
+        # we use the global list in loss
+        self.cls_num_pos_samples_per_level = [
+            0. for _ in range(len(self.prior_generator.strides))
+        ]
+        self.reg_num_pos_samples_per_level = [
+            0. for _ in range(len(self.prior_generator.strides))
+        ]
+
+    def init_weights(self) -> None:
+        """Initialize weights of the head."""
+        for m in self.cls_convs:
+            normal_init(m.conv, std=0.01)
+        for m in self.reg_convs:
+            normal_init(m.conv, std=0.01)
+        normal_init(self.atss_reg, std=0.01)
+        normal_init(self.atss_iou, std=0.01)
+        bias_cls = bias_init_with_prob(0.01)
+        normal_init(self.atss_cls, std=0.01, bias=bias_cls)
+
+    def forward(self, x: Tuple[Tensor]) -> Tuple[List[Tensor]]:
+        """Forward features from the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple: A tuple of classification scores, bbox predictions,
+            and iou predictions.
+
+            - cls_scores (list[Tensor]): Classification scores for all \
+            scale levels, each is a 4D-tensor, the channels number is \
+            num_base_priors * num_classes.
+            - bbox_preds (list[Tensor]): Box energies / deltas for all \
+            scale levels, each is a 4D-tensor, the channels number is \
+            num_base_priors * 4.
+            - iou_preds (list[Tensor]): IoU scores for all scale levels, \
+            each is a 4D-tensor, the channels number is num_base_priors * 1.
+        """
+        return multi_apply(self.forward_single, x, self.scales)
+
+    def forward_single(self, x: Tensor, scale: Scale) -> Sequence[Tensor]:
+        """Forward feature of a single scale level.
+
+        Args:
+            x (Tensor): Features of a single scale level.
+            scale (:obj: `mmcv.cnn.Scale`): Learnable scale module to resize
+                the bbox prediction.
+
+        Returns:
+            tuple:
+
+            - cls_score (Tensor): Cls scores for a single scale level \
+            the channels number is num_base_priors * num_classes.
+            - bbox_pred (Tensor): Box energies / deltas for a single \
+            scale level, the channels number is num_base_priors * 4.
+            - iou_pred (Tensor): Iou for a single scale level, the \
+            channel number is (N, num_base_priors * 1, H, W).
+        """
+        cls_feat = x
+        reg_feat = x
+        for cls_conv in self.cls_convs:
+            cls_feat = cls_conv(cls_feat)
+        for reg_conv in self.reg_convs:
+            reg_feat = reg_conv(reg_feat)
+        cls_score = self.atss_cls(cls_feat)
+        # we just follow atss, not apply exp in bbox_pred
+        bbox_pred = scale(self.atss_reg(reg_feat)).float()
+        iou_pred = self.atss_iou(reg_feat)
+        return cls_score, bbox_pred, iou_pred
+
+    def loss_cls_by_feat_single(self, cls_score: Tensor, labels: Tensor,
+                                label_weights: Tensor,
+                                reweight_factor: List[float],
+                                avg_factor: float) -> Tuple[Tensor]:
+        """Compute cls loss of a single scale level.
+
+        Args:
+            cls_score (Tensor): Box scores for each scale level
+                Has shape (N, num_base_priors * num_classes, H, W).
+            labels (Tensor): Labels of each anchors with shape
+                (N, num_total_anchors).
+            label_weights (Tensor): Label weights of each anchor with shape
+                (N, num_total_anchors)
+            reweight_factor (List[float]): Reweight factor for cls and reg
+                loss.
+            avg_factor (float): Average factor that is used to average
+                the loss. When using sampling method, avg_factor is usually
+                the sum of positive and negative priors. When using
+                `PseudoSampler`, `avg_factor` is usually equal to the number
+                of positive priors.
+
+        Returns:
+            Tuple[Tensor]: A tuple of loss components.
+        """
+        cls_score = cls_score.permute(0, 2, 3, 1).reshape(
+            -1, self.cls_out_channels).contiguous()
+        labels = labels.reshape(-1)
+        label_weights = label_weights.reshape(-1)
+        loss_cls = self.loss_cls(
+            cls_score, labels, label_weights, avg_factor=avg_factor)
+        return reweight_factor * loss_cls,
+
+    def loss_reg_by_feat_single(self, anchors: Tensor, bbox_pred: Tensor,
+                                iou_pred: Tensor, labels,
+                                label_weights: Tensor, bbox_targets: Tensor,
+                                bbox_weights: Tensor,
+                                reweight_factor: List[float],
+                                avg_factor: float) -> Tuple[Tensor, Tensor]:
+        """Compute reg loss of a single scale level based on the features
+        extracted by the detection head.
+
+        Args:
+            anchors (Tensor): Box reference for each scale level with shape
+                (N, num_total_anchors, 4).
+            bbox_pred (Tensor): Box energies / deltas for each scale
+                level with shape (N, num_base_priors * 4, H, W).
+            iou_pred (Tensor): Iou for a single scale level, the
+                channel number is (N, num_base_priors * 1, H, W).
+            labels (Tensor): Labels of each anchors with shape
+                (N, num_total_anchors).
+            label_weights (Tensor): Label weights of each anchor with shape
+                (N, num_total_anchors)
+            bbox_targets (Tensor): BBox regression targets of each anchor with
+                shape (N, num_total_anchors, 4).
+            bbox_weights (Tensor): BBox weights of all anchors in the
+                image with shape (N, 4)
+            reweight_factor (List[float]): Reweight factor for cls and reg
+                loss.
+            avg_factor (float): Average factor that is used to average
+                the loss. When using sampling method, avg_factor is usually
+                the sum of positive and negative priors. When using
+                `PseudoSampler`, `avg_factor` is usually equal to the number
+                of positive priors.
+        Returns:
+            Tuple[Tensor, Tensor]: A tuple of loss components.
+        """
+        anchors = anchors.reshape(-1, 4)
+        bbox_pred = bbox_pred.permute(0, 2, 3, 1).reshape(-1, 4)
+        iou_pred = iou_pred.permute(0, 2, 3, 1).reshape(-1, )
+        bbox_targets = bbox_targets.reshape(-1, 4)
+        bbox_weights = bbox_weights.reshape(-1, 4)
+        labels = labels.reshape(-1)
+        label_weights = label_weights.reshape(-1)
+
+        iou_targets = label_weights.new_zeros(labels.shape)
+        iou_weights = label_weights.new_zeros(labels.shape)
+        iou_weights[(bbox_weights.sum(axis=1) > 0).nonzero(
+            as_tuple=False)] = 1.
+
+        # FG cat_id: [0, num_classes -1], BG cat_id: num_classes
+        bg_class_ind = self.num_classes
+        pos_inds = ((labels >= 0)
+                    &
+                    (labels < bg_class_ind)).nonzero(as_tuple=False).squeeze(1)
+
+        if len(pos_inds) > 0:
+            pos_bbox_targets = bbox_targets[pos_inds]
+            pos_bbox_pred = bbox_pred[pos_inds]
+            pos_anchors = anchors[pos_inds]
+
+            pos_decode_bbox_pred = self.bbox_coder.decode(
+                pos_anchors, pos_bbox_pred)
+            pos_decode_bbox_targets = self.bbox_coder.decode(
+                pos_anchors, pos_bbox_targets)
+
+            # regression loss
+            loss_bbox = self.loss_bbox(
+                pos_decode_bbox_pred,
+                pos_decode_bbox_targets,
+                avg_factor=avg_factor)
+
+            iou_targets[pos_inds] = bbox_overlaps(
+                pos_decode_bbox_pred.detach(),
+                pos_decode_bbox_targets,
+                is_aligned=True)
+            loss_iou = self.loss_iou(
+                iou_pred, iou_targets, iou_weights, avg_factor=avg_factor)
+        else:
+            loss_bbox = bbox_pred.sum() * 0
+            loss_iou = iou_pred.sum() * 0
+
+        return reweight_factor * loss_bbox, reweight_factor * loss_iou
+
+    def calc_reweight_factor(self, labels_list: List[Tensor]) -> List[float]:
+        """Compute reweight_factor for regression and classification loss."""
+        # get pos samples for each level
+        bg_class_ind = self.num_classes
+        for ii, each_level_label in enumerate(labels_list):
+            pos_inds = ((each_level_label >= 0) &
+                        (each_level_label < bg_class_ind)).nonzero(
+                            as_tuple=False).squeeze(1)
+            self.cls_num_pos_samples_per_level[ii] += len(pos_inds)
+        # get reweight factor from 1 ~ 2 with bilinear interpolation
+        min_pos_samples = min(self.cls_num_pos_samples_per_level)
+        max_pos_samples = max(self.cls_num_pos_samples_per_level)
+        interval = 1. / (max_pos_samples - min_pos_samples + 1e-10)
+        reweight_factor_per_level = []
+        for pos_samples in self.cls_num_pos_samples_per_level:
+            factor = 2. - (pos_samples - min_pos_samples) * interval
+            reweight_factor_per_level.append(factor)
+        return reweight_factor_per_level
+
+    def loss_by_feat(
+            self,
+            cls_scores: List[Tensor],
+            bbox_preds: List[Tensor],
+            iou_preds: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> dict:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level
+                Has shape (N, num_base_priors * num_classes, H, W)
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level with shape (N, num_base_priors * 4, H, W)
+            iou_preds (list[Tensor]): Score factor for all scale level,
+                each is a 4D-tensor, has shape (batch_size, 1, H, W).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], Optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        assert len(featmap_sizes) == self.prior_generator.num_levels
+
+        device = cls_scores[0].device
+        anchor_list, valid_flag_list = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+
+        # calculate common vars for cls and reg assigners at once
+        targets_com = self.process_predictions_and_anchors(
+            anchor_list, valid_flag_list, cls_scores, bbox_preds,
+            batch_img_metas, batch_gt_instances_ignore)
+        (anchor_list, valid_flag_list, num_level_anchors_list, cls_score_list,
+         bbox_pred_list, batch_gt_instances_ignore) = targets_com
+
+        # classification branch assigner
+        cls_targets = self.get_cls_targets(
+            anchor_list,
+            valid_flag_list,
+            num_level_anchors_list,
+            cls_score_list,
+            bbox_pred_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore)
+
+        (cls_anchor_list, labels_list, label_weights_list, bbox_targets_list,
+         bbox_weights_list, avg_factor) = cls_targets
+
+        avg_factor = reduce_mean(
+            torch.tensor(avg_factor, dtype=torch.float, device=device)).item()
+        avg_factor = max(avg_factor, 1.0)
+
+        reweight_factor_per_level = self.calc_reweight_factor(labels_list)
+
+        cls_losses_cls, = multi_apply(
+            self.loss_cls_by_feat_single,
+            cls_scores,
+            labels_list,
+            label_weights_list,
+            reweight_factor_per_level,
+            avg_factor=avg_factor)
+
+        # regression branch assigner
+        reg_targets = self.get_reg_targets(
+            anchor_list,
+            valid_flag_list,
+            num_level_anchors_list,
+            cls_score_list,
+            bbox_pred_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore)
+
+        (reg_anchor_list, labels_list, label_weights_list, bbox_targets_list,
+         bbox_weights_list, avg_factor) = reg_targets
+
+        avg_factor = reduce_mean(
+            torch.tensor(avg_factor, dtype=torch.float, device=device)).item()
+        avg_factor = max(avg_factor, 1.0)
+
+        reweight_factor_per_level = self.calc_reweight_factor(labels_list)
+
+        reg_losses_bbox, reg_losses_iou = multi_apply(
+            self.loss_reg_by_feat_single,
+            reg_anchor_list,
+            bbox_preds,
+            iou_preds,
+            labels_list,
+            label_weights_list,
+            bbox_targets_list,
+            bbox_weights_list,
+            reweight_factor_per_level,
+            avg_factor=avg_factor)
+
+        return dict(
+            loss_cls=cls_losses_cls,
+            loss_bbox=reg_losses_bbox,
+            loss_iou=reg_losses_iou)
+
+    def process_predictions_and_anchors(
+            self,
+            anchor_list: List[List[Tensor]],
+            valid_flag_list: List[List[Tensor]],
+            cls_scores: List[Tensor],
+            bbox_preds: List[Tensor],
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> tuple:
+        """Compute common vars for regression and classification targets.
+
+        Args:
+            anchor_list (List[List[Tensor]]): anchors of each image.
+            valid_flag_list (List[List[Tensor]]): Valid flags of each image.
+            cls_scores (List[Tensor]): Classification scores for all scale
+                levels, each is a 4D-tensor, the channels number is
+                num_base_priors * num_classes.
+            bbox_preds (list[Tensor]): Box energies / deltas for all scale
+                levels, each is a 4D-tensor, the channels number is
+                num_base_priors * 4.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], Optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Return:
+            tuple[Tensor]: A tuple of common loss vars.
+        """
+        num_imgs = len(batch_img_metas)
+        assert len(anchor_list) == len(valid_flag_list) == num_imgs
+
+        # anchor number of multi levels
+        num_level_anchors = [anchors.size(0) for anchors in anchor_list[0]]
+        num_level_anchors_list = [num_level_anchors] * num_imgs
+
+        anchor_list_ = []
+        valid_flag_list_ = []
+        # concat all level anchors and flags to a single tensor
+        for i in range(num_imgs):
+            assert len(anchor_list[i]) == len(valid_flag_list[i])
+            anchor_list_.append(torch.cat(anchor_list[i]))
+            valid_flag_list_.append(torch.cat(valid_flag_list[i]))
+
+        # compute targets for each image
+        if batch_gt_instances_ignore is None:
+            batch_gt_instances_ignore = [None for _ in range(num_imgs)]
+
+        num_levels = len(cls_scores)
+        cls_score_list = []
+        bbox_pred_list = []
+
+        mlvl_cls_score_list = [
+            cls_score.permute(0, 2, 3, 1).reshape(
+                num_imgs, -1, self.num_base_priors * self.cls_out_channels)
+            for cls_score in cls_scores
+        ]
+        mlvl_bbox_pred_list = [
+            bbox_pred.permute(0, 2, 3, 1).reshape(num_imgs, -1,
+                                                  self.num_base_priors * 4)
+            for bbox_pred in bbox_preds
+        ]
+
+        for i in range(num_imgs):
+            mlvl_cls_tensor_list = [
+                mlvl_cls_score_list[j][i] for j in range(num_levels)
+            ]
+            mlvl_bbox_tensor_list = [
+                mlvl_bbox_pred_list[j][i] for j in range(num_levels)
+            ]
+            cat_mlvl_cls_score = torch.cat(mlvl_cls_tensor_list, dim=0)
+            cat_mlvl_bbox_pred = torch.cat(mlvl_bbox_tensor_list, dim=0)
+            cls_score_list.append(cat_mlvl_cls_score)
+            bbox_pred_list.append(cat_mlvl_bbox_pred)
+        return (anchor_list_, valid_flag_list_, num_level_anchors_list,
+                cls_score_list, bbox_pred_list, batch_gt_instances_ignore)
+
+    def get_cls_targets(self,
+                        anchor_list: List[Tensor],
+                        valid_flag_list: List[Tensor],
+                        num_level_anchors_list: List[int],
+                        cls_score_list: List[Tensor],
+                        bbox_pred_list: List[Tensor],
+                        batch_gt_instances: InstanceList,
+                        batch_img_metas: List[dict],
+                        batch_gt_instances_ignore: OptInstanceList = None,
+                        unmap_outputs: bool = True) -> tuple:
+        """Get cls targets for DDOD head.
+
+        This method is almost the same as `AnchorHead.get_targets()`.
+        Besides returning the targets as the parent  method does,
+        it also returns the anchors as the first element of the
+        returned tuple.
+
+        Args:
+            anchor_list (list[Tensor]): anchors of each image.
+            valid_flag_list (list[Tensor]): Valid flags of each image.
+            num_level_anchors_list (list[Tensor]): Number of anchors of each
+                scale level of all image.
+            cls_score_list (list[Tensor]): Classification scores for all scale
+                levels, each is a 4D-tensor, the channels number is
+                num_base_priors * num_classes.
+            bbox_pred_list (list[Tensor]): Box energies / deltas for all scale
+                levels, each is a 4D-tensor, the channels number is
+                num_base_priors * 4.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+            unmap_outputs (bool): Whether to map outputs back to the original
+                set of anchors.
+
+        Return:
+            tuple[Tensor]: A tuple of cls targets components.
+        """
+        (all_anchors, all_labels, all_label_weights, all_bbox_targets,
+         all_bbox_weights, pos_inds_list, neg_inds_list,
+         sampling_results_list) = multi_apply(
+             self._get_targets_single,
+             anchor_list,
+             valid_flag_list,
+             cls_score_list,
+             bbox_pred_list,
+             num_level_anchors_list,
+             batch_gt_instances,
+             batch_img_metas,
+             batch_gt_instances_ignore,
+             unmap_outputs=unmap_outputs,
+             is_cls_assigner=True)
+        # Get `avg_factor` of all images, which calculate in `SamplingResult`.
+        # When using sampling method, avg_factor is usually the sum of
+        # positive and negative priors. When using `PseudoSampler`,
+        # `avg_factor` is usually equal to the number of positive priors.
+        avg_factor = sum(
+            [results.avg_factor for results in sampling_results_list])
+        # split targets to a list w.r.t. multiple levels
+        anchors_list = images_to_levels(all_anchors, num_level_anchors_list[0])
+        labels_list = images_to_levels(all_labels, num_level_anchors_list[0])
+        label_weights_list = images_to_levels(all_label_weights,
+                                              num_level_anchors_list[0])
+        bbox_targets_list = images_to_levels(all_bbox_targets,
+                                             num_level_anchors_list[0])
+        bbox_weights_list = images_to_levels(all_bbox_weights,
+                                             num_level_anchors_list[0])
+        return (anchors_list, labels_list, label_weights_list,
+                bbox_targets_list, bbox_weights_list, avg_factor)
+
+    def get_reg_targets(self,
+                        anchor_list: List[Tensor],
+                        valid_flag_list: List[Tensor],
+                        num_level_anchors_list: List[int],
+                        cls_score_list: List[Tensor],
+                        bbox_pred_list: List[Tensor],
+                        batch_gt_instances: InstanceList,
+                        batch_img_metas: List[dict],
+                        batch_gt_instances_ignore: OptInstanceList = None,
+                        unmap_outputs: bool = True) -> tuple:
+        """Get reg targets for DDOD head.
+
+        This method is almost the same as `AnchorHead.get_targets()` when
+        is_cls_assigner is False. Besides returning the targets as the parent
+        method does, it also returns the anchors as the first element of the
+        returned tuple.
+
+        Args:
+            anchor_list (list[Tensor]): anchors of each image.
+            valid_flag_list (list[Tensor]): Valid flags of each image.
+            num_level_anchors_list (list[Tensor]): Number of anchors of each
+                scale level of all image.
+            cls_score_list (list[Tensor]): Classification scores for all scale
+                levels, each is a 4D-tensor, the channels number is
+                num_base_priors * num_classes.
+            bbox_pred_list (list[Tensor]): Box energies / deltas for all scale
+                levels, each is a 4D-tensor, the channels number is
+                num_base_priors * 4.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+            unmap_outputs (bool): Whether to map outputs back to the original
+                set of anchors.
+
+        Return:
+            tuple[Tensor]: A tuple of reg targets components.
+        """
+        (all_anchors, all_labels, all_label_weights, all_bbox_targets,
+         all_bbox_weights, pos_inds_list, neg_inds_list,
+         sampling_results_list) = multi_apply(
+             self._get_targets_single,
+             anchor_list,
+             valid_flag_list,
+             cls_score_list,
+             bbox_pred_list,
+             num_level_anchors_list,
+             batch_gt_instances,
+             batch_img_metas,
+             batch_gt_instances_ignore,
+             unmap_outputs=unmap_outputs,
+             is_cls_assigner=False)
+        # Get `avg_factor` of all images, which calculate in `SamplingResult`.
+        # When using sampling method, avg_factor is usually the sum of
+        # positive and negative priors. When using `PseudoSampler`,
+        # `avg_factor` is usually equal to the number of positive priors.
+        avg_factor = sum(
+            [results.avg_factor for results in sampling_results_list])
+        # split targets to a list w.r.t. multiple levels
+        anchors_list = images_to_levels(all_anchors, num_level_anchors_list[0])
+        labels_list = images_to_levels(all_labels, num_level_anchors_list[0])
+        label_weights_list = images_to_levels(all_label_weights,
+                                              num_level_anchors_list[0])
+        bbox_targets_list = images_to_levels(all_bbox_targets,
+                                             num_level_anchors_list[0])
+        bbox_weights_list = images_to_levels(all_bbox_weights,
+                                             num_level_anchors_list[0])
+        return (anchors_list, labels_list, label_weights_list,
+                bbox_targets_list, bbox_weights_list, avg_factor)
+
+    def _get_targets_single(self,
+                            flat_anchors: Tensor,
+                            valid_flags: Tensor,
+                            cls_scores: Tensor,
+                            bbox_preds: Tensor,
+                            num_level_anchors: List[int],
+                            gt_instances: InstanceData,
+                            img_meta: dict,
+                            gt_instances_ignore: Optional[InstanceData] = None,
+                            unmap_outputs: bool = True,
+                            is_cls_assigner: bool = True) -> tuple:
+        """Compute regression, classification targets for anchors in a single
+        image.
+
+        Args:
+            flat_anchors (Tensor): Multi-level anchors of the image,
+                which are concatenated into a single tensor of shape
+                (num_base_priors, 4).
+            valid_flags (Tensor): Multi level valid flags of the image,
+                which are concatenated into a single tensor of
+                shape (num_base_priors,).
+            cls_scores (Tensor): Classification scores for all scale
+                levels of the image.
+            bbox_preds (Tensor): Box energies / deltas for all scale
+                levels of the image.
+            num_level_anchors (List[int]): Number of anchors of each
+                scale level.
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            img_meta (dict): Meta information for current image.
+            gt_instances_ignore (:obj:`InstanceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+            unmap_outputs (bool): Whether to map outputs back to the original
+                set of anchors. Defaults to True.
+            is_cls_assigner (bool): Classification or regression.
+                Defaults to True.
+
+        Returns:
+            tuple: N is the number of total anchors in the image.
+            - anchors (Tensor): all anchors in the image with shape (N, 4).
+            - labels (Tensor): Labels of all anchors in the image with \
+            shape (N, ).
+            - label_weights (Tensor): Label weights of all anchor in the \
+            image with shape (N, ).
+            - bbox_targets (Tensor): BBox targets of all anchors in the \
+            image with shape (N, 4).
+            - bbox_weights (Tensor): BBox weights of all anchors in the \
+            image with shape (N, 4)
+            - pos_inds (Tensor): Indices of positive anchor with shape \
+            (num_pos, ).
+            - neg_inds (Tensor): Indices of negative anchor with shape \
+            (num_neg, ).
+            - sampling_result (:obj:`SamplingResult`): Sampling results.
+        """
+        inside_flags = anchor_inside_flags(flat_anchors, valid_flags,
+                                           img_meta['img_shape'][:2],
+                                           self.train_cfg['allowed_border'])
+        if not inside_flags.any():
+            raise ValueError(
+                'There is no valid anchor inside the image boundary. Please '
+                'check the image size and anchor sizes, or set '
+                '``allowed_border`` to -1 to skip the condition.')
+        # assign gt and sample anchors
+        anchors = flat_anchors[inside_flags, :]
+
+        num_level_anchors_inside = self.get_num_level_anchors_inside(
+            num_level_anchors, inside_flags)
+        bbox_preds_valid = bbox_preds[inside_flags, :]
+        cls_scores_valid = cls_scores[inside_flags, :]
+
+        assigner = self.cls_assigner if is_cls_assigner else self.reg_assigner
+
+        # decode prediction out of assigner
+        bbox_preds_valid = self.bbox_coder.decode(anchors, bbox_preds_valid)
+        pred_instances = InstanceData(
+            priors=anchors, bboxes=bbox_preds_valid, scores=cls_scores_valid)
+
+        assign_result = assigner.assign(
+            pred_instances=pred_instances,
+            num_level_priors=num_level_anchors_inside,
+            gt_instances=gt_instances,
+            gt_instances_ignore=gt_instances_ignore)
+        sampling_result = self.sampler.sample(
+            assign_result=assign_result,
+            pred_instances=pred_instances,
+            gt_instances=gt_instances)
+
+        num_valid_anchors = anchors.shape[0]
+        bbox_targets = torch.zeros_like(anchors)
+        bbox_weights = torch.zeros_like(anchors)
+        labels = anchors.new_full((num_valid_anchors, ),
+                                  self.num_classes,
+                                  dtype=torch.long)
+        label_weights = anchors.new_zeros(num_valid_anchors, dtype=torch.float)
+
+        pos_inds = sampling_result.pos_inds
+        neg_inds = sampling_result.neg_inds
+        if len(pos_inds) > 0:
+            pos_bbox_targets = self.bbox_coder.encode(
+                sampling_result.pos_bboxes, sampling_result.pos_gt_bboxes)
+            bbox_targets[pos_inds, :] = pos_bbox_targets
+            bbox_weights[pos_inds, :] = 1.0
+
+            labels[pos_inds] = sampling_result.pos_gt_labels
+            if self.train_cfg['pos_weight'] <= 0:
+                label_weights[pos_inds] = 1.0
+            else:
+                label_weights[pos_inds] = self.train_cfg['pos_weight']
+        if len(neg_inds) > 0:
+            label_weights[neg_inds] = 1.0
+
+        # map up to original set of anchors
+        if unmap_outputs:
+            num_total_anchors = flat_anchors.size(0)
+            anchors = unmap(anchors, num_total_anchors, inside_flags)
+            labels = unmap(
+                labels, num_total_anchors, inside_flags, fill=self.num_classes)
+            label_weights = unmap(label_weights, num_total_anchors,
+                                  inside_flags)
+            bbox_targets = unmap(bbox_targets, num_total_anchors, inside_flags)
+            bbox_weights = unmap(bbox_weights, num_total_anchors, inside_flags)
+
+        return (anchors, labels, label_weights, bbox_targets, bbox_weights,
+                pos_inds, neg_inds, sampling_result)
+
+    def get_num_level_anchors_inside(self, num_level_anchors: List[int],
+                                     inside_flags: Tensor) -> List[int]:
+        """Get the anchors of each scale level inside.
+
+        Args:
+            num_level_anchors (list[int]): Number of anchors of each
+                scale level.
+            inside_flags (Tensor): Multi level inside flags of the image,
+                which are concatenated into a single tensor of
+                shape (num_base_priors,).
+
+        Returns:
+            list[int]: Number of anchors of each scale level inside.
+        """
+        split_inside_flags = torch.split(inside_flags, num_level_anchors)
+        num_level_anchors_inside = [
+            int(flags.sum()) for flags in split_inside_flags
+        ]
+        return num_level_anchors_inside
diff --git a/mmdetection/mmdet/models/dense_heads/ddq_detr_head.py b/mmdetection/mmdet/models/dense_heads/ddq_detr_head.py
new file mode 100644
index 00000000..0580653a
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/ddq_detr_head.py
@@ -0,0 +1,550 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+from typing import Dict, List, Tuple
+
+import torch
+from mmengine.model import bias_init_with_prob, constant_init
+from torch import Tensor, nn
+
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.structures.bbox import bbox_cxcywh_to_xyxy
+from mmdet.utils import InstanceList, OptInstanceList, reduce_mean
+from ..layers import inverse_sigmoid
+from ..losses import DDQAuxLoss
+from ..utils import multi_apply
+from .dino_head import DINOHead
+
+
+@MODELS.register_module()
+class DDQDETRHead(DINOHead):
+    r"""Head of DDQDETR: Dense Distinct Query for
+        End-to-End Object Detection.
+
+    Code is modified from the `official github repo
+        `_.
+
+    More details can be found in the `paper
+        `_ .
+
+    Args:
+        aux_num_pos (int): Number of positive targets assigned to a
+            perdicted object. Defaults to 4.
+    """
+
+    def __init__(self, *args, aux_num_pos=4, **kwargs):
+        super(DDQDETRHead, self).__init__(*args, **kwargs)
+        self.aux_loss_for_dense = DDQAuxLoss(
+            train_cfg=dict(
+                assigner=dict(type='TopkHungarianAssigner', topk=aux_num_pos),
+                alpha=1,
+                beta=6))
+
+    def _init_layers(self) -> None:
+        """Initialize classification branch and regression branch of aux head
+        for dense queries."""
+        super(DDQDETRHead, self)._init_layers()
+        # If decoder `num_layers` = 6 and `as_two_stage` = True, then:
+        #   1) 6 main heads are required for
+        #       each decoder output of distinct queries.
+        #   2) 1 main head is required for `output_memory` of distinct queries.
+        #   3) 1 aux head is required for `output_memory` of dense queries,
+        #       which is done by code below this comment.
+        # So 8 heads are required in sum.
+        # aux head for dense queries on encoder feature map
+        self.cls_branches.append(copy.deepcopy(self.cls_branches[-1]))
+        self.reg_branches.append(copy.deepcopy(self.reg_branches[-1]))
+
+        # If decoder `num_layers` = 6 and `as_two_stage` = True, then:
+        #   6 aux heads are required for each decoder output of dense queries.
+        # So 8 + 6 = 14 heads and heads are requires in sum.
+        # self.num_pred_layer is 7
+        # aux head for dense queries in decoder
+        self.aux_cls_branches = nn.ModuleList([
+            copy.deepcopy(self.cls_branches[-1])
+            for _ in range(self.num_pred_layer - 1)
+        ])
+        self.aux_reg_branches = nn.ModuleList([
+            copy.deepcopy(self.reg_branches[-1])
+            for _ in range(self.num_pred_layer - 1)
+        ])
+
+    def init_weights(self) -> None:
+        """Initialize weights of the Deformable DETR head."""
+        bias_init = bias_init_with_prob(0.01)
+        for m in self.cls_branches:
+            nn.init.constant_(m.bias, bias_init)
+        for m in self.aux_cls_branches:
+            nn.init.constant_(m.bias, bias_init)
+        for m in self.reg_branches:
+            constant_init(m[-1], 0, bias=0)
+        for m in self.reg_branches:
+            nn.init.constant_(m[-1].bias.data[2:], 0.0)
+
+        for m in self.aux_reg_branches:
+            constant_init(m[-1], 0, bias=0)
+
+        for m in self.aux_reg_branches:
+            nn.init.constant_(m[-1].bias.data[2:], 0.0)
+
+    def forward(self, hidden_states: Tensor,
+                references: List[Tensor]) -> Tuple[Tensor]:
+        """Forward function.
+
+        Args:
+            hidden_states (Tensor): Hidden states output from each decoder
+                layer, has shape (num_decoder_layers, bs, num_queries_total,
+                dim), where `num_queries_total` is the sum of
+                `num_denoising_queries`, `num_queries` and `num_dense_queries`
+                when `self.training` is `True`, else `num_queries`.
+            references (list[Tensor]): List of the reference from the decoder.
+                The first reference is the `init_reference` (initial) and the
+                other num_decoder_layers(6) references are `inter_references`
+                (intermediate). Each reference has shape (bs,
+                num_queries_total, 4) with the last dimension arranged as
+                (cx, cy, w, h).
+
+        Returns:
+            tuple[Tensor]: results of head containing the following tensors.
+
+            - all_layers_outputs_classes (Tensor): Outputs from the
+              classification head, has shape (num_decoder_layers, bs,
+              num_queries_total, cls_out_channels).
+            - all_layers_outputs_coords (Tensor): Sigmoid outputs from the
+              regression head with normalized coordinate format (cx, cy, w,
+              h), has shape (num_decoder_layers, bs, num_queries_total, 4)
+              with the last dimension arranged as (cx, cy, w, h).
+        """
+        all_layers_outputs_classes = []
+        all_layers_outputs_coords = []
+        if self.training:
+            num_dense = self.cache_dict['num_dense_queries']
+        for layer_id in range(hidden_states.shape[0]):
+            reference = inverse_sigmoid(references[layer_id])
+            hidden_state = hidden_states[layer_id]
+            if self.training:
+                dense_hidden_state = hidden_state[:, -num_dense:]
+                hidden_state = hidden_state[:, :-num_dense]
+
+            outputs_class = self.cls_branches[layer_id](hidden_state)
+            tmp_reg_preds = self.reg_branches[layer_id](hidden_state)
+            if self.training:
+                dense_outputs_class = self.aux_cls_branches[layer_id](
+                    dense_hidden_state)
+                dense_tmp_reg_preds = self.aux_reg_branches[layer_id](
+                    dense_hidden_state)
+                outputs_class = torch.cat([outputs_class, dense_outputs_class],
+                                          dim=1)
+                tmp_reg_preds = torch.cat([tmp_reg_preds, dense_tmp_reg_preds],
+                                          dim=1)
+
+            if reference.shape[-1] == 4:
+                tmp_reg_preds += reference
+            else:
+                assert reference.shape[-1] == 2
+                tmp_reg_preds[..., :2] += reference
+            outputs_coord = tmp_reg_preds.sigmoid()
+            all_layers_outputs_classes.append(outputs_class)
+            all_layers_outputs_coords.append(outputs_coord)
+
+        all_layers_outputs_classes = torch.stack(all_layers_outputs_classes)
+        all_layers_outputs_coords = torch.stack(all_layers_outputs_coords)
+
+        return all_layers_outputs_classes, all_layers_outputs_coords
+
+    def loss(self,
+             hidden_states: Tensor,
+             references: List[Tensor],
+             enc_outputs_class: Tensor,
+             enc_outputs_coord: Tensor,
+             batch_data_samples: SampleList,
+             dn_meta: Dict[str, int],
+             aux_enc_outputs_class=None,
+             aux_enc_outputs_coord=None) -> dict:
+        """Perform forward propagation and loss calculation of the detection
+        head on the queries of the upstream network.
+
+        Args:
+            hidden_states (Tensor): Hidden states output from each decoder
+                layer, has shape (num_decoder_layers, bs, num_queries_total,
+                dim), where `num_queries_total` is the sum of
+                `num_denoising_queries`, `num_queries` and `num_dense_queries`
+                when `self.training` is `True`, else `num_queries`.
+            references (list[Tensor]): List of the reference from the decoder.
+                The first reference is the `init_reference` (initial) and the
+                other num_decoder_layers(6) references are `inter_references`
+                (intermediate). Each reference has shape (bs,
+                num_queries_total, 4) with the last dimension arranged as
+                (cx, cy, w, h).
+            enc_outputs_class (Tensor): The top k classification score of
+                each point on encoder feature map, has shape (bs, num_queries,
+                cls_out_channels).
+            enc_outputs_coord (Tensor): The proposal generated from points
+                with top k score, has shape (bs, num_queries, 4) with the
+                last dimension arranged as (cx, cy, w, h).
+            batch_data_samples (list[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            dn_meta (Dict[str, int]): The dictionary saves information about
+              group collation, including 'num_denoising_queries' and
+              'num_denoising_groups'. It will be used for split outputs of
+              denoising and matching parts and loss calculation.
+            aux_enc_outputs_class (Tensor): The `dense_topk` classification
+                score of each point on encoder feature map, has shape (bs,
+                num_dense_queries, cls_out_channels).
+                It is `None` when `self.training` is `False`.
+            aux_enc_outputs_coord (Tensor): The proposal generated from points
+                with `dense_topk` score, has shape (bs, num_dense_queries, 4)
+                with the last dimension arranged as (cx, cy, w, h).
+                It is `None` when `self.training` is `False`.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        batch_gt_instances = []
+        batch_img_metas = []
+        for data_sample in batch_data_samples:
+            batch_img_metas.append(data_sample.metainfo)
+            batch_gt_instances.append(data_sample.gt_instances)
+
+        outs = self(hidden_states, references)
+        loss_inputs = outs + (enc_outputs_class, enc_outputs_coord,
+                              batch_gt_instances, batch_img_metas, dn_meta)
+        losses = self.loss_by_feat(*loss_inputs)
+
+        aux_enc_outputs_coord = bbox_cxcywh_to_xyxy(aux_enc_outputs_coord)
+        aux_enc_outputs_coord_list = []
+        for img_id in range(len(aux_enc_outputs_coord)):
+            det_bboxes = aux_enc_outputs_coord[img_id]
+            img_shape = batch_img_metas[img_id]['img_shape']
+            det_bboxes[:, 0::2] = det_bboxes[:, 0::2] * img_shape[1]
+            det_bboxes[:, 1::2] = det_bboxes[:, 1::2] * img_shape[0]
+            aux_enc_outputs_coord_list.append(det_bboxes)
+        aux_enc_outputs_coord = torch.stack(aux_enc_outputs_coord_list)
+        aux_loss = self.aux_loss_for_dense.loss(
+            aux_enc_outputs_class.sigmoid(), aux_enc_outputs_coord,
+            [item.bboxes for item in batch_gt_instances],
+            [item.labels for item in batch_gt_instances], batch_img_metas)
+        for k, v in aux_loss.items():
+            losses[f'aux_enc_{k}'] = v
+
+        return losses
+
+    def loss_by_feat(
+        self,
+        all_layers_cls_scores: Tensor,
+        all_layers_bbox_preds: Tensor,
+        enc_cls_scores: Tensor,
+        enc_bbox_preds: Tensor,
+        batch_gt_instances: InstanceList,
+        batch_img_metas: List[dict],
+        dn_meta: Dict[str, int],
+        batch_gt_instances_ignore: OptInstanceList = None
+    ) -> Dict[str, Tensor]:
+        """Loss function.
+
+        Args:
+            all_layers_cls_scores (Tensor): Classification scores of all
+                decoder layers, has shape (num_decoder_layers, bs,
+                num_queries_total, cls_out_channels).
+            all_layers_bbox_preds (Tensor): Bbox coordinates of all decoder
+                layers. Each has shape (num_decoder_layers, bs,
+                num_queries_total, 4) with normalized coordinate format
+                (cx, cy, w, h).
+            enc_cls_scores (Tensor): The top k score of each point on
+                encoder feature map, has shape (bs, num_queries,
+                cls_out_channels).
+            enc_bbox_preds (Tensor): The proposal generated from points
+                with top k score, has shape (bs, num_queries, 4) with the
+                last dimension arranged as (cx, cy, w, h).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image,
+                e.g., image size, scaling factor, etc.
+            dn_meta (Dict[str, int]): The dictionary saves information about
+                group collation, including 'num_denoising_queries' and
+                'num_denoising_groups'. It will be used for split outputs of
+                denoising and matching parts and loss calculation.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        (all_layers_matching_cls_scores, all_layers_matching_bbox_preds,
+         all_layers_denoising_cls_scores, all_layers_denoising_bbox_preds) = \
+            self.split_outputs(
+                all_layers_cls_scores, all_layers_bbox_preds, dn_meta)
+
+        num_dense_queries = dn_meta['num_dense_queries']
+        num_layer = all_layers_matching_bbox_preds.size(0)
+        dense_all_layers_matching_cls_scores = all_layers_matching_cls_scores[:, :,  # noqa: E501
+                                                                              -num_dense_queries:]  # noqa: E501
+        dense_all_layers_matching_bbox_preds = all_layers_matching_bbox_preds[:, :,  # noqa: E501
+                                                                              -num_dense_queries:]  # noqa: E501
+
+        all_layers_matching_cls_scores = all_layers_matching_cls_scores[:, :, :  # noqa: E501
+                                                                        -num_dense_queries]  # noqa: E501
+        all_layers_matching_bbox_preds = all_layers_matching_bbox_preds[:, :, :  # noqa: E501
+                                                                        -num_dense_queries]  # noqa: E501
+
+        loss_dict = self.loss_for_distinct_queries(
+            all_layers_matching_cls_scores, all_layers_matching_bbox_preds,
+            batch_gt_instances, batch_img_metas, batch_gt_instances_ignore)
+
+        if enc_cls_scores is not None:
+
+            enc_loss_cls, enc_losses_bbox, enc_losses_iou = \
+                self.loss_by_feat_single(
+                    enc_cls_scores, enc_bbox_preds,
+                    batch_gt_instances=batch_gt_instances,
+                    batch_img_metas=batch_img_metas)
+            loss_dict['enc_loss_cls'] = enc_loss_cls
+            loss_dict['enc_loss_bbox'] = enc_losses_bbox
+            loss_dict['enc_loss_iou'] = enc_losses_iou
+
+        if all_layers_denoising_cls_scores is not None:
+            dn_losses_cls, dn_losses_bbox, dn_losses_iou = self.loss_dn(
+                all_layers_denoising_cls_scores,
+                all_layers_denoising_bbox_preds,
+                batch_gt_instances=batch_gt_instances,
+                batch_img_metas=batch_img_metas,
+                dn_meta=dn_meta)
+            loss_dict['dn_loss_cls'] = dn_losses_cls[-1]
+            loss_dict['dn_loss_bbox'] = dn_losses_bbox[-1]
+            loss_dict['dn_loss_iou'] = dn_losses_iou[-1]
+            for num_dec_layer, (loss_cls_i, loss_bbox_i, loss_iou_i) in \
+                    enumerate(zip(dn_losses_cls[:-1], dn_losses_bbox[:-1],
+                                  dn_losses_iou[:-1])):
+                loss_dict[f'd{num_dec_layer}.dn_loss_cls'] = loss_cls_i
+                loss_dict[f'd{num_dec_layer}.dn_loss_bbox'] = loss_bbox_i
+                loss_dict[f'd{num_dec_layer}.dn_loss_iou'] = loss_iou_i
+
+        for l_id in range(num_layer):
+            cls_scores = dense_all_layers_matching_cls_scores[l_id].sigmoid()
+            bbox_preds = dense_all_layers_matching_bbox_preds[l_id]
+
+            bbox_preds = bbox_cxcywh_to_xyxy(bbox_preds)
+            bbox_preds_list = []
+            for img_id in range(len(bbox_preds)):
+                det_bboxes = bbox_preds[img_id]
+                img_shape = batch_img_metas[img_id]['img_shape']
+                det_bboxes[:, 0::2] = det_bboxes[:, 0::2] * img_shape[1]
+                det_bboxes[:, 1::2] = det_bboxes[:, 1::2] * img_shape[0]
+                bbox_preds_list.append(det_bboxes)
+            bbox_preds = torch.stack(bbox_preds_list)
+            aux_loss = self.aux_loss_for_dense.loss(
+                cls_scores, bbox_preds,
+                [item.bboxes for item in batch_gt_instances],
+                [item.labels for item in batch_gt_instances], batch_img_metas)
+            for k, v in aux_loss.items():
+                loss_dict[f'{l_id}_aux_{k}'] = v
+
+        return loss_dict
+
+    def loss_for_distinct_queries(
+        self,
+        all_layers_cls_scores: Tensor,
+        all_layers_bbox_preds: Tensor,
+        batch_gt_instances: InstanceList,
+        batch_img_metas: List[dict],
+        batch_gt_instances_ignore: OptInstanceList = None
+    ) -> Dict[str, Tensor]:
+        """Calculate the loss of distinct queries, that is, excluding denoising
+        and dense queries. Only select the distinct queries in decoder for
+        loss.
+
+        Args:
+            all_layers_cls_scores (Tensor): Classification scores of all
+                decoder layers, has shape (num_decoder_layers, bs,
+                num_queries, cls_out_channels).
+            all_layers_bbox_preds (Tensor): Bbox coordinates of all decoder
+                layers. It has shape (num_decoder_layers, bs,
+                num_queries, 4) with the last dimension arranged as
+                (cx, cy, w, h).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image,
+            e.g., image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        assert batch_gt_instances_ignore is None, \
+            f'{self.__class__.__name__} only supports ' \
+            'for batch_gt_instances_ignore setting to None.'
+
+        losses_cls, losses_bbox, losses_iou = multi_apply(
+            self._loss_for_distinct_queries_single,
+            all_layers_cls_scores,
+            all_layers_bbox_preds,
+            [i for i in range(len(all_layers_bbox_preds))],
+            batch_gt_instances=batch_gt_instances,
+            batch_img_metas=batch_img_metas)
+
+        loss_dict = dict()
+        # loss from the last decoder layer
+        loss_dict['loss_cls'] = losses_cls[-1]
+        loss_dict['loss_bbox'] = losses_bbox[-1]
+        loss_dict['loss_iou'] = losses_iou[-1]
+        # loss from other decoder layers
+        num_dec_layer = 0
+        for loss_cls_i, loss_bbox_i, loss_iou_i in \
+                zip(losses_cls[:-1], losses_bbox[:-1], losses_iou[:-1]):
+            loss_dict[f'd{num_dec_layer}.loss_cls'] = loss_cls_i
+            loss_dict[f'd{num_dec_layer}.loss_bbox'] = loss_bbox_i
+            loss_dict[f'd{num_dec_layer}.loss_iou'] = loss_iou_i
+            num_dec_layer += 1
+        return loss_dict
+
+    def _loss_for_distinct_queries_single(self, cls_scores, bbox_preds, l_id,
+                                          batch_gt_instances, batch_img_metas):
+        """Calculate the loss for outputs from a single decoder layer of
+        distinct queries, that is, excluding denoising and dense queries. Only
+        select the distinct queries in decoder for loss.
+
+        Args:
+            cls_scores (Tensor): Classification scores of a single
+                decoder layer, has shape (bs, num_queries, cls_out_channels).
+            bbox_preds (Tensor): Bbox coordinates of a single decoder
+                layer. It has shape (bs, num_queries, 4) with the last
+                dimension arranged as (cx, cy, w, h).
+            l_id (int): Decoder layer index for these outputs.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image,
+            e.g., image size, scaling factor, etc.
+
+        Returns:
+            Tuple[Tensor]: A tuple including `loss_cls`, `loss_box` and
+            `loss_iou`.
+        """
+        num_imgs = cls_scores.size(0)
+        if 0 < l_id:
+            batch_mask = [
+                self.cache_dict['distinct_query_mask'][l_id - 1][
+                    img_id * self.cache_dict['num_heads']][0]
+                for img_id in range(num_imgs)
+            ]
+        else:
+            batch_mask = [
+                torch.ones(len(cls_scores[i]),
+                           device=cls_scores.device).bool()
+                for i in range(num_imgs)
+            ]
+        # only select the distinct queries in decoder for loss
+        cls_scores_list = [
+            cls_scores[i][batch_mask[i]] for i in range(num_imgs)
+        ]
+        bbox_preds_list = [
+            bbox_preds[i][batch_mask[i]] for i in range(num_imgs)
+        ]
+        cls_scores = torch.cat(cls_scores_list)
+
+        cls_reg_targets = self.get_targets(cls_scores_list, bbox_preds_list,
+                                           batch_gt_instances, batch_img_metas)
+        (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,
+         num_total_pos, num_total_neg) = cls_reg_targets
+        labels = torch.cat(labels_list, 0)
+        label_weights = torch.cat(label_weights_list, 0)
+        bbox_targets = torch.cat(bbox_targets_list, 0)
+        bbox_weights = torch.cat(bbox_weights_list, 0)
+
+        # classification loss
+        cls_scores = cls_scores.reshape(-1, self.cls_out_channels)
+        # construct weighted avg_factor to match with the official DETR repo
+        cls_avg_factor = num_total_pos * 1.0 + \
+            num_total_neg * self.bg_cls_weight
+        if self.sync_cls_avg_factor:
+            cls_avg_factor = reduce_mean(
+                cls_scores.new_tensor([cls_avg_factor]))
+        cls_avg_factor = max(cls_avg_factor, 1)
+
+        loss_cls = self.loss_cls(
+            cls_scores, labels, label_weights, avg_factor=cls_avg_factor)
+
+        # Compute the average number of gt boxes across all gpus, for
+        # normalization purposes
+        num_total_pos = loss_cls.new_tensor([num_total_pos])
+        num_total_pos = torch.clamp(reduce_mean(num_total_pos), min=1).item()
+
+        # construct factors used for rescale bboxes
+        factors = []
+        for img_meta, bbox_pred in zip(batch_img_metas, bbox_preds_list):
+            img_h, img_w, = img_meta['img_shape']
+            factor = bbox_pred.new_tensor([img_w, img_h, img_w,
+                                           img_h]).unsqueeze(0).repeat(
+                                               bbox_pred.size(0), 1)
+            factors.append(factor)
+        factors = torch.cat(factors, 0)
+
+        # DETR regress the relative position of boxes (cxcywh) in the image,
+        # thus the learning target is normalized by the image size. So here
+        # we need to re-scale them for calculating IoU loss
+        bbox_preds = torch.cat(bbox_preds_list)
+        bbox_preds = bbox_preds.reshape(-1, 4)
+        bboxes = bbox_cxcywh_to_xyxy(bbox_preds) * factors
+        bboxes_gt = bbox_cxcywh_to_xyxy(bbox_targets) * factors
+
+        # regression IoU loss, defaultly GIoU loss
+        loss_iou = self.loss_iou(
+            bboxes, bboxes_gt, bbox_weights, avg_factor=num_total_pos)
+
+        # regression L1 loss
+        loss_bbox = self.loss_bbox(
+            bbox_preds, bbox_targets, bbox_weights, avg_factor=num_total_pos)
+        return loss_cls, loss_bbox, loss_iou
+
+    def predict_by_feat(self,
+                        layer_cls_scores: Tensor,
+                        layer_bbox_preds: Tensor,
+                        batch_img_metas: List[dict],
+                        rescale: bool = True) -> InstanceList:
+        """Transform a batch of output features extracted from the head into
+        bbox results.
+
+        Args:
+            layer_cls_scores (Tensor): Classification scores of all
+                decoder layers, has shape (num_decoder_layers, bs,
+                num_queries, cls_out_channels).
+            layer_bbox_preds (Tensor): Bbox coordinates of all decoder layers.
+                Each has shape (num_decoder_layers, bs, num_queries, 4)
+                with normalized coordinate format (cx, cy, w, h).
+            batch_img_metas (list[dict]): Meta information of each image.
+            rescale (bool, optional): If `True`, return boxes in original
+                image space. Default `False`.
+
+        Returns:
+            list[obj:`InstanceData`]: Detection results of each image
+            after the post process.
+        """
+        cls_scores = layer_cls_scores[-1]
+        bbox_preds = layer_bbox_preds[-1]
+
+        num_imgs = cls_scores.size(0)
+        # -1 is last layer input query mask
+
+        batch_mask = [
+            self.cache_dict['distinct_query_mask'][-1][
+                img_id * self.cache_dict['num_heads']][0]
+            for img_id in range(num_imgs)
+        ]
+
+        result_list = []
+        for img_id in range(len(batch_img_metas)):
+            cls_score = cls_scores[img_id][batch_mask[img_id]]
+            bbox_pred = bbox_preds[img_id][batch_mask[img_id]]
+            img_meta = batch_img_metas[img_id]
+            results = self._predict_by_feat_single(cls_score, bbox_pred,
+                                                   img_meta, rescale)
+            result_list.append(results)
+        return result_list
diff --git a/mmdetection/mmdet/models/dense_heads/deformable_detr_head.py b/mmdetection/mmdet/models/dense_heads/deformable_detr_head.py
new file mode 100644
index 00000000..adedd4aa
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/deformable_detr_head.py
@@ -0,0 +1,329 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+from typing import Dict, List, Tuple
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import Linear
+from mmengine.model import bias_init_with_prob, constant_init
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.utils import InstanceList, OptInstanceList
+from ..layers import inverse_sigmoid
+from .detr_head import DETRHead
+
+
+@MODELS.register_module()
+class DeformableDETRHead(DETRHead):
+    r"""Head of DeformDETR: Deformable DETR: Deformable Transformers for
+    End-to-End Object Detection.
+
+    Code is modified from the `official github repo
+    `_.
+
+    More details can be found in the `paper
+    `_ .
+
+    Args:
+        share_pred_layer (bool): Whether to share parameters for all the
+            prediction layers. Defaults to `False`.
+        num_pred_layer (int): The number of the prediction layers.
+            Defaults to 6.
+        as_two_stage (bool, optional): Whether to generate the proposal
+            from the outputs of encoder. Defaults to `False`.
+    """
+
+    def __init__(self,
+                 *args,
+                 share_pred_layer: bool = False,
+                 num_pred_layer: int = 6,
+                 as_two_stage: bool = False,
+                 **kwargs) -> None:
+        self.share_pred_layer = share_pred_layer
+        self.num_pred_layer = num_pred_layer
+        self.as_two_stage = as_two_stage
+
+        super().__init__(*args, **kwargs)
+
+    def _init_layers(self) -> None:
+        """Initialize classification branch and regression branch of head."""
+        fc_cls = Linear(self.embed_dims, self.cls_out_channels)
+        reg_branch = []
+        for _ in range(self.num_reg_fcs):
+            reg_branch.append(Linear(self.embed_dims, self.embed_dims))
+            reg_branch.append(nn.ReLU())
+        reg_branch.append(Linear(self.embed_dims, 4))
+        reg_branch = nn.Sequential(*reg_branch)
+
+        if self.share_pred_layer:
+            self.cls_branches = nn.ModuleList(
+                [fc_cls for _ in range(self.num_pred_layer)])
+            self.reg_branches = nn.ModuleList(
+                [reg_branch for _ in range(self.num_pred_layer)])
+        else:
+            self.cls_branches = nn.ModuleList(
+                [copy.deepcopy(fc_cls) for _ in range(self.num_pred_layer)])
+            self.reg_branches = nn.ModuleList([
+                copy.deepcopy(reg_branch) for _ in range(self.num_pred_layer)
+            ])
+
+    def init_weights(self) -> None:
+        """Initialize weights of the Deformable DETR head."""
+        if self.loss_cls.use_sigmoid:
+            bias_init = bias_init_with_prob(0.01)
+            for m in self.cls_branches:
+                if hasattr(m, 'bias') and m.bias is not None:
+                    nn.init.constant_(m.bias, bias_init)
+        for m in self.reg_branches:
+            constant_init(m[-1], 0, bias=0)
+        nn.init.constant_(self.reg_branches[0][-1].bias.data[2:], -2.0)
+        if self.as_two_stage:
+            for m in self.reg_branches:
+                nn.init.constant_(m[-1].bias.data[2:], 0.0)
+
+    def forward(self, hidden_states: Tensor,
+                references: List[Tensor]) -> Tuple[Tensor, Tensor]:
+        """Forward function.
+
+        Args:
+            hidden_states (Tensor): Hidden states output from each decoder
+                layer, has shape (num_decoder_layers, bs, num_queries, dim).
+            references (list[Tensor]): List of the reference from the decoder.
+                The first reference is the `init_reference` (initial) and the
+                other num_decoder_layers(6) references are `inter_references`
+                (intermediate). The `init_reference` has shape (bs,
+                num_queries, 4) when `as_two_stage` of the detector is `True`,
+                otherwise (bs, num_queries, 2). Each `inter_reference` has
+                shape (bs, num_queries, 4) when `with_box_refine` of the
+                detector is `True`, otherwise (bs, num_queries, 2). The
+                coordinates are arranged as (cx, cy) when the last dimension is
+                2, and (cx, cy, w, h) when it is 4.
+
+        Returns:
+            tuple[Tensor]: results of head containing the following tensor.
+
+            - all_layers_outputs_classes (Tensor): Outputs from the
+              classification head, has shape (num_decoder_layers, bs,
+              num_queries, cls_out_channels).
+            - all_layers_outputs_coords (Tensor): Sigmoid outputs from the
+              regression head with normalized coordinate format (cx, cy, w,
+              h), has shape (num_decoder_layers, bs, num_queries, 4) with the
+              last dimension arranged as (cx, cy, w, h).
+        """
+        all_layers_outputs_classes = []
+        all_layers_outputs_coords = []
+
+        for layer_id in range(hidden_states.shape[0]):
+            reference = inverse_sigmoid(references[layer_id])
+            # NOTE The last reference will not be used.
+            hidden_state = hidden_states[layer_id]
+            outputs_class = self.cls_branches[layer_id](hidden_state)
+            tmp_reg_preds = self.reg_branches[layer_id](hidden_state)
+            if reference.shape[-1] == 4:
+                # When `layer` is 0 and `as_two_stage` of the detector
+                # is `True`, or when `layer` is greater than 0 and
+                # `with_box_refine` of the detector is `True`.
+                tmp_reg_preds += reference
+            else:
+                # When `layer` is 0 and `as_two_stage` of the detector
+                # is `False`, or when `layer` is greater than 0 and
+                # `with_box_refine` of the detector is `False`.
+                assert reference.shape[-1] == 2
+                tmp_reg_preds[..., :2] += reference
+            outputs_coord = tmp_reg_preds.sigmoid()
+            all_layers_outputs_classes.append(outputs_class)
+            all_layers_outputs_coords.append(outputs_coord)
+
+        all_layers_outputs_classes = torch.stack(all_layers_outputs_classes)
+        all_layers_outputs_coords = torch.stack(all_layers_outputs_coords)
+
+        return all_layers_outputs_classes, all_layers_outputs_coords
+
+    def loss(self, hidden_states: Tensor, references: List[Tensor],
+             enc_outputs_class: Tensor, enc_outputs_coord: Tensor,
+             batch_data_samples: SampleList) -> dict:
+        """Perform forward propagation and loss calculation of the detection
+        head on the queries of the upstream network.
+
+        Args:
+            hidden_states (Tensor): Hidden states output from each decoder
+                layer, has shape (num_decoder_layers, num_queries, bs, dim).
+            references (list[Tensor]): List of the reference from the decoder.
+                The first reference is the `init_reference` (initial) and the
+                other num_decoder_layers(6) references are `inter_references`
+                (intermediate). The `init_reference` has shape (bs,
+                num_queries, 4) when `as_two_stage` of the detector is `True`,
+                otherwise (bs, num_queries, 2). Each `inter_reference` has
+                shape (bs, num_queries, 4) when `with_box_refine` of the
+                detector is `True`, otherwise (bs, num_queries, 2). The
+                coordinates are arranged as (cx, cy) when the last dimension is
+                2, and (cx, cy, w, h) when it is 4.
+            enc_outputs_class (Tensor): The score of each point on encode
+                feature map, has shape (bs, num_feat_points, cls_out_channels).
+                Only when `as_two_stage` is `True` it would be passed in,
+                otherwise it would be `None`.
+            enc_outputs_coord (Tensor): The proposal generate from the encode
+                feature map, has shape (bs, num_feat_points, 4) with the last
+                dimension arranged as (cx, cy, w, h). Only when `as_two_stage`
+                is `True` it would be passed in, otherwise it would be `None`.
+            batch_data_samples (list[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        batch_gt_instances = []
+        batch_img_metas = []
+        for data_sample in batch_data_samples:
+            batch_img_metas.append(data_sample.metainfo)
+            batch_gt_instances.append(data_sample.gt_instances)
+
+        outs = self(hidden_states, references)
+        loss_inputs = outs + (enc_outputs_class, enc_outputs_coord,
+                              batch_gt_instances, batch_img_metas)
+        losses = self.loss_by_feat(*loss_inputs)
+        return losses
+
+    def loss_by_feat(
+        self,
+        all_layers_cls_scores: Tensor,
+        all_layers_bbox_preds: Tensor,
+        enc_cls_scores: Tensor,
+        enc_bbox_preds: Tensor,
+        batch_gt_instances: InstanceList,
+        batch_img_metas: List[dict],
+        batch_gt_instances_ignore: OptInstanceList = None
+    ) -> Dict[str, Tensor]:
+        """Loss function.
+
+        Args:
+            all_layers_cls_scores (Tensor): Classification scores of all
+                decoder layers, has shape (num_decoder_layers, bs, num_queries,
+                cls_out_channels).
+            all_layers_bbox_preds (Tensor): Regression outputs of all decoder
+                layers. Each is a 4D-tensor with normalized coordinate format
+                (cx, cy, w, h) and has shape (num_decoder_layers, bs,
+                num_queries, 4) with the last dimension arranged as
+                (cx, cy, w, h).
+            enc_cls_scores (Tensor): The score of each point on encode
+                feature map, has shape (bs, num_feat_points, cls_out_channels).
+                Only when `as_two_stage` is `True` it would be passes in,
+                otherwise, it would be `None`.
+            enc_bbox_preds (Tensor): The proposal generate from the encode
+                feature map, has shape (bs, num_feat_points, 4) with the last
+                dimension arranged as (cx, cy, w, h). Only when `as_two_stage`
+                is `True` it would be passed in, otherwise it would be `None`.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        loss_dict = super().loss_by_feat(all_layers_cls_scores,
+                                         all_layers_bbox_preds,
+                                         batch_gt_instances, batch_img_metas,
+                                         batch_gt_instances_ignore)
+
+        # loss of proposal generated from encode feature map.
+        if enc_cls_scores is not None:
+            proposal_gt_instances = copy.deepcopy(batch_gt_instances)
+            for i in range(len(proposal_gt_instances)):
+                proposal_gt_instances[i].labels = torch.zeros_like(
+                    proposal_gt_instances[i].labels)
+            enc_loss_cls, enc_losses_bbox, enc_losses_iou = \
+                self.loss_by_feat_single(
+                    enc_cls_scores, enc_bbox_preds,
+                    batch_gt_instances=proposal_gt_instances,
+                    batch_img_metas=batch_img_metas)
+            loss_dict['enc_loss_cls'] = enc_loss_cls
+            loss_dict['enc_loss_bbox'] = enc_losses_bbox
+            loss_dict['enc_loss_iou'] = enc_losses_iou
+        return loss_dict
+
+    def predict(self,
+                hidden_states: Tensor,
+                references: List[Tensor],
+                batch_data_samples: SampleList,
+                rescale: bool = True) -> InstanceList:
+        """Perform forward propagation and loss calculation of the detection
+        head on the queries of the upstream network.
+
+        Args:
+            hidden_states (Tensor): Hidden states output from each decoder
+                layer, has shape (num_decoder_layers, num_queries, bs, dim).
+            references (list[Tensor]): List of the reference from the decoder.
+                The first reference is the `init_reference` (initial) and the
+                other num_decoder_layers(6) references are `inter_references`
+                (intermediate). The `init_reference` has shape (bs,
+                num_queries, 4) when `as_two_stage` of the detector is `True`,
+                otherwise (bs, num_queries, 2). Each `inter_reference` has
+                shape (bs, num_queries, 4) when `with_box_refine` of the
+                detector is `True`, otherwise (bs, num_queries, 2). The
+                coordinates are arranged as (cx, cy) when the last dimension is
+                2, and (cx, cy, w, h) when it is 4.
+            batch_data_samples (list[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            rescale (bool, optional): If `True`, return boxes in original
+                image space. Defaults to `True`.
+
+        Returns:
+            list[obj:`InstanceData`]: Detection results of each image
+            after the post process.
+        """
+        batch_img_metas = [
+            data_samples.metainfo for data_samples in batch_data_samples
+        ]
+
+        outs = self(hidden_states, references)
+
+        predictions = self.predict_by_feat(
+            *outs, batch_img_metas=batch_img_metas, rescale=rescale)
+        return predictions
+
+    def predict_by_feat(self,
+                        all_layers_cls_scores: Tensor,
+                        all_layers_bbox_preds: Tensor,
+                        batch_img_metas: List[Dict],
+                        rescale: bool = False) -> InstanceList:
+        """Transform a batch of output features extracted from the head into
+        bbox results.
+
+        Args:
+            all_layers_cls_scores (Tensor): Classification scores of all
+                decoder layers, has shape (num_decoder_layers, bs, num_queries,
+                cls_out_channels).
+            all_layers_bbox_preds (Tensor): Regression outputs of all decoder
+                layers. Each is a 4D-tensor with normalized coordinate format
+                (cx, cy, w, h) and shape (num_decoder_layers, bs, num_queries,
+                4) with the last dimension arranged as (cx, cy, w, h).
+            batch_img_metas (list[dict]): Meta information of each image.
+            rescale (bool, optional): If `True`, return boxes in original
+                image space. Default `False`.
+
+        Returns:
+            list[obj:`InstanceData`]: Detection results of each image
+            after the post process.
+        """
+        cls_scores = all_layers_cls_scores[-1]
+        bbox_preds = all_layers_bbox_preds[-1]
+
+        result_list = []
+        for img_id in range(len(batch_img_metas)):
+            cls_score = cls_scores[img_id]
+            bbox_pred = bbox_preds[img_id]
+            img_meta = batch_img_metas[img_id]
+            results = self._predict_by_feat_single(cls_score, bbox_pred,
+                                                   img_meta, rescale)
+            result_list.append(results)
+        return result_list
diff --git a/mmdetection/mmdet/models/dense_heads/dense_test_mixins.py b/mmdetection/mmdet/models/dense_heads/dense_test_mixins.py
new file mode 100644
index 00000000..a7526d48
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/dense_test_mixins.py
@@ -0,0 +1,215 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import sys
+import warnings
+from inspect import signature
+
+import torch
+from mmcv.ops import batched_nms
+from mmengine.structures import InstanceData
+
+from mmdet.structures.bbox import bbox_mapping_back
+from ..test_time_augs import merge_aug_proposals
+
+if sys.version_info >= (3, 7):
+    from mmdet.utils.contextmanagers import completed
+
+
+class BBoxTestMixin(object):
+    """Mixin class for testing det bboxes via DenseHead."""
+
+    def simple_test_bboxes(self, feats, img_metas, rescale=False):
+        """Test det bboxes without test-time augmentation, can be applied in
+        DenseHead except for ``RPNHead`` and its variants, e.g., ``GARPNHead``,
+        etc.
+
+        Args:
+            feats (tuple[torch.Tensor]): Multi-level features from the
+                upstream network, each is a 4D-tensor.
+            img_metas (list[dict]): List of image information.
+            rescale (bool, optional): Whether to rescale the results.
+                Defaults to False.
+
+        Returns:
+            list[obj:`InstanceData`]: Detection results of each
+                image after the post process. \
+                Each item usually contains following keys. \
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance,)
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances,).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        warnings.warn('You are calling `simple_test_bboxes` in '
+                      '`dense_test_mixins`, but the `dense_test_mixins`'
+                      'will be deprecated soon. Please use '
+                      '`simple_test` instead.')
+        outs = self.forward(feats)
+        results_list = self.get_results(
+            *outs, img_metas=img_metas, rescale=rescale)
+        return results_list
+
+    def aug_test_bboxes(self, feats, img_metas, rescale=False):
+        """Test det bboxes with test time augmentation, can be applied in
+        DenseHead except for ``RPNHead`` and its variants, e.g., ``GARPNHead``,
+        etc.
+
+        Args:
+            feats (list[Tensor]): the outer list indicates test-time
+                augmentations and inner Tensor should have a shape NxCxHxW,
+                which contains features for all images in the batch.
+            img_metas (list[list[dict]]): the outer list indicates test-time
+                augs (multiscale, flip, etc.) and the inner list indicates
+                images in a batch. each dict has image information.
+            rescale (bool, optional): Whether to rescale the results.
+                Defaults to False.
+
+        Returns:
+            list[tuple[Tensor, Tensor]]: Each item in result_list is 2-tuple.
+                The first item is ``bboxes`` with shape (n, 5),
+                where 5 represent (tl_x, tl_y, br_x, br_y, score).
+                The shape of the second tensor in the tuple is ``labels``
+                with shape (n,). The length of list should always be 1.
+        """
+
+        warnings.warn('You are calling `aug_test_bboxes` in '
+                      '`dense_test_mixins`, but the `dense_test_mixins`'
+                      'will be deprecated soon. Please use '
+                      '`aug_test` instead.')
+        # check with_nms argument
+        gb_sig = signature(self.get_results)
+        gb_args = [p.name for p in gb_sig.parameters.values()]
+        gbs_sig = signature(self._get_results_single)
+        gbs_args = [p.name for p in gbs_sig.parameters.values()]
+        assert ('with_nms' in gb_args) and ('with_nms' in gbs_args), \
+            f'{self.__class__.__name__}' \
+            ' does not support test-time augmentation'
+
+        aug_bboxes = []
+        aug_scores = []
+        aug_labels = []
+        for x, img_meta in zip(feats, img_metas):
+            # only one image in the batch
+            outs = self.forward(x)
+            bbox_outputs = self.get_results(
+                *outs,
+                img_metas=img_meta,
+                cfg=self.test_cfg,
+                rescale=False,
+                with_nms=False)[0]
+            aug_bboxes.append(bbox_outputs.bboxes)
+            aug_scores.append(bbox_outputs.scores)
+            if len(bbox_outputs) >= 3:
+                aug_labels.append(bbox_outputs.labels)
+
+        # after merging, bboxes will be rescaled to the original image size
+        merged_bboxes, merged_scores = self.merge_aug_bboxes(
+            aug_bboxes, aug_scores, img_metas)
+        merged_labels = torch.cat(aug_labels, dim=0) if aug_labels else None
+
+        if merged_bboxes.numel() == 0:
+            det_bboxes = torch.cat([merged_bboxes, merged_scores[:, None]], -1)
+            return [
+                (det_bboxes, merged_labels),
+            ]
+
+        det_bboxes, keep_idxs = batched_nms(merged_bboxes, merged_scores,
+                                            merged_labels, self.test_cfg.nms)
+        det_bboxes = det_bboxes[:self.test_cfg.max_per_img]
+        det_labels = merged_labels[keep_idxs][:self.test_cfg.max_per_img]
+
+        if rescale:
+            _det_bboxes = det_bboxes
+        else:
+            _det_bboxes = det_bboxes.clone()
+            _det_bboxes[:, :4] *= det_bboxes.new_tensor(
+                img_metas[0][0]['scale_factor'])
+
+        results = InstanceData()
+        results.bboxes = _det_bboxes[:, :4]
+        results.scores = _det_bboxes[:, 4]
+        results.labels = det_labels
+        return [results]
+
+    def aug_test_rpn(self, feats, img_metas):
+        """Test with augmentation for only for ``RPNHead`` and its variants,
+        e.g., ``GARPNHead``, etc.
+
+        Args:
+            feats (tuple[Tensor]): Features from the upstream network, each is
+                        a 4D-tensor.
+            img_metas (list[dict]): Meta info of each image.
+
+        Returns:
+            list[Tensor]: Proposals of each image, each item has shape (n, 5),
+                where 5 represent (tl_x, tl_y, br_x, br_y, score).
+        """
+        samples_per_gpu = len(img_metas[0])
+        aug_proposals = [[] for _ in range(samples_per_gpu)]
+        for x, img_meta in zip(feats, img_metas):
+            results_list = self.simple_test_rpn(x, img_meta)
+            for i, results in enumerate(results_list):
+                proposals = torch.cat(
+                    [results.bboxes, results.scores[:, None]], dim=-1)
+                aug_proposals[i].append(proposals)
+        # reorganize the order of 'img_metas' to match the dimensions
+        # of 'aug_proposals'
+        aug_img_metas = []
+        for i in range(samples_per_gpu):
+            aug_img_meta = []
+            for j in range(len(img_metas)):
+                aug_img_meta.append(img_metas[j][i])
+            aug_img_metas.append(aug_img_meta)
+        # after merging, proposals will be rescaled to the original image size
+
+        merged_proposals = []
+        for proposals, aug_img_meta in zip(aug_proposals, aug_img_metas):
+            merged_proposal = merge_aug_proposals(proposals, aug_img_meta,
+                                                  self.test_cfg)
+            results = InstanceData()
+            results.bboxes = merged_proposal[:, :4]
+            results.scores = merged_proposal[:, 4]
+            merged_proposals.append(results)
+        return merged_proposals
+
+    if sys.version_info >= (3, 7):
+
+        async def async_simple_test_rpn(self, x, img_metas):
+            sleep_interval = self.test_cfg.pop('async_sleep_interval', 0.025)
+            async with completed(
+                    __name__, 'rpn_head_forward',
+                    sleep_interval=sleep_interval):
+                rpn_outs = self(x)
+
+            proposal_list = self.get_results(*rpn_outs, img_metas=img_metas)
+            return proposal_list
+
+    def merge_aug_bboxes(self, aug_bboxes, aug_scores, img_metas):
+        """Merge augmented detection bboxes and scores.
+
+        Args:
+            aug_bboxes (list[Tensor]): shape (n, 4*#class)
+            aug_scores (list[Tensor] or None): shape (n, #class)
+            img_shapes (list[Tensor]): shape (3, ).
+
+        Returns:
+            tuple[Tensor]: ``bboxes`` with shape (n,4), where
+            4 represent (tl_x, tl_y, br_x, br_y)
+            and ``scores`` with shape (n,).
+        """
+        recovered_bboxes = []
+        for bboxes, img_info in zip(aug_bboxes, img_metas):
+            img_shape = img_info[0]['img_shape']
+            scale_factor = img_info[0]['scale_factor']
+            flip = img_info[0]['flip']
+            flip_direction = img_info[0]['flip_direction']
+            bboxes = bbox_mapping_back(bboxes, img_shape, scale_factor, flip,
+                                       flip_direction)
+            recovered_bboxes.append(bboxes)
+        bboxes = torch.cat(recovered_bboxes, dim=0)
+        if aug_scores is None:
+            return bboxes
+        else:
+            scores = torch.cat(aug_scores, dim=0)
+            return bboxes, scores
diff --git a/mmdetection/mmdet/models/dense_heads/detr_head.py b/mmdetection/mmdet/models/dense_heads/detr_head.py
new file mode 100644
index 00000000..9daeb474
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/detr_head.py
@@ -0,0 +1,634 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, List, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import Linear
+from mmcv.cnn.bricks.transformer import FFN
+from mmengine.model import BaseModule
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.structures import SampleList
+from mmdet.structures.bbox import (bbox_cxcywh_to_xyxy, bbox_overlaps,
+                                   bbox_xyxy_to_cxcywh)
+from mmdet.utils import (ConfigType, InstanceList, OptInstanceList,
+                         OptMultiConfig, reduce_mean)
+from ..losses import QualityFocalLoss
+from ..utils import multi_apply
+
+
+@MODELS.register_module()
+class DETRHead(BaseModule):
+    r"""Head of DETR. DETR:End-to-End Object Detection with Transformers.
+
+    More details can be found in the `paper
+    `_ .
+
+    Args:
+        num_classes (int): Number of categories excluding the background.
+        embed_dims (int): The dims of Transformer embedding.
+        num_reg_fcs (int): Number of fully-connected layers used in `FFN`,
+            which is then used for the regression head. Defaults to 2.
+        sync_cls_avg_factor (bool): Whether to sync the `avg_factor` of
+            all ranks. Default to `False`.
+        loss_cls (:obj:`ConfigDict` or dict): Config of the classification
+            loss. Defaults to `CrossEntropyLoss`.
+        loss_bbox (:obj:`ConfigDict` or dict): Config of the regression bbox
+            loss. Defaults to `L1Loss`.
+        loss_iou (:obj:`ConfigDict` or dict): Config of the regression iou
+            loss. Defaults to `GIoULoss`.
+        train_cfg (:obj:`ConfigDict` or dict): Training config of transformer
+            head.
+        test_cfg (:obj:`ConfigDict` or dict): Testing config of transformer
+            head.
+        init_cfg (:obj:`ConfigDict` or dict, optional): the config to control
+            the initialization. Defaults to None.
+    """
+
+    _version = 2
+
+    def __init__(
+            self,
+            num_classes: int,
+            embed_dims: int = 256,
+            num_reg_fcs: int = 2,
+            sync_cls_avg_factor: bool = False,
+            loss_cls: ConfigType = dict(
+                type='CrossEntropyLoss',
+                bg_cls_weight=0.1,
+                use_sigmoid=False,
+                loss_weight=1.0,
+                class_weight=1.0),
+            loss_bbox: ConfigType = dict(type='L1Loss', loss_weight=5.0),
+            loss_iou: ConfigType = dict(type='GIoULoss', loss_weight=2.0),
+            train_cfg: ConfigType = dict(
+                assigner=dict(
+                    type='HungarianAssigner',
+                    match_costs=[
+                        dict(type='ClassificationCost', weight=1.),
+                        dict(type='BBoxL1Cost', weight=5.0, box_format='xywh'),
+                        dict(type='IoUCost', iou_mode='giou', weight=2.0)
+                    ])),
+            test_cfg: ConfigType = dict(max_per_img=100),
+            init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.bg_cls_weight = 0
+        self.sync_cls_avg_factor = sync_cls_avg_factor
+        class_weight = loss_cls.get('class_weight', None)
+        if class_weight is not None and (self.__class__ is DETRHead):
+            assert isinstance(class_weight, float), 'Expected ' \
+                'class_weight to have type float. Found ' \
+                f'{type(class_weight)}.'
+            # NOTE following the official DETR repo, bg_cls_weight means
+            # relative classification weight of the no-object class.
+            bg_cls_weight = loss_cls.get('bg_cls_weight', class_weight)
+            assert isinstance(bg_cls_weight, float), 'Expected ' \
+                'bg_cls_weight to have type float. Found ' \
+                f'{type(bg_cls_weight)}.'
+            class_weight = torch.ones(num_classes + 1) * class_weight
+            # set background class as the last indice
+            class_weight[num_classes] = bg_cls_weight
+            loss_cls.update({'class_weight': class_weight})
+            if 'bg_cls_weight' in loss_cls:
+                loss_cls.pop('bg_cls_weight')
+            self.bg_cls_weight = bg_cls_weight
+
+        if train_cfg:
+            assert 'assigner' in train_cfg, 'assigner should be provided ' \
+                                            'when train_cfg is set.'
+            assigner = train_cfg['assigner']
+            self.assigner = TASK_UTILS.build(assigner)
+            if train_cfg.get('sampler', None) is not None:
+                raise RuntimeError('DETR do not build sampler.')
+        self.num_classes = num_classes
+        self.embed_dims = embed_dims
+        self.num_reg_fcs = num_reg_fcs
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+        self.loss_cls = MODELS.build(loss_cls)
+        self.loss_bbox = MODELS.build(loss_bbox)
+        self.loss_iou = MODELS.build(loss_iou)
+
+        if self.loss_cls.use_sigmoid:
+            self.cls_out_channels = num_classes
+        else:
+            self.cls_out_channels = num_classes + 1
+
+        self._init_layers()
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the transformer head."""
+        # cls branch
+        self.fc_cls = Linear(self.embed_dims, self.cls_out_channels)
+        # reg branch
+        self.activate = nn.ReLU()
+        self.reg_ffn = FFN(
+            self.embed_dims,
+            self.embed_dims,
+            self.num_reg_fcs,
+            dict(type='ReLU', inplace=True),
+            dropout=0.0,
+            add_residual=False)
+        # NOTE the activations of reg_branch here is the same as
+        # those in transformer, but they are actually different
+        # in DAB-DETR (prelu in transformer and relu in reg_branch)
+        self.fc_reg = Linear(self.embed_dims, 4)
+
+    def forward(self, hidden_states: Tensor) -> Tuple[Tensor]:
+        """"Forward function.
+
+        Args:
+            hidden_states (Tensor): Features from transformer decoder. If
+                `return_intermediate_dec` in detr.py is True output has shape
+                (num_decoder_layers, bs, num_queries, dim), else has shape
+                (1, bs, num_queries, dim) which only contains the last layer
+                outputs.
+        Returns:
+            tuple[Tensor]: results of head containing the following tensor.
+
+            - layers_cls_scores (Tensor): Outputs from the classification head,
+              shape (num_decoder_layers, bs, num_queries, cls_out_channels).
+              Note cls_out_channels should include background.
+            - layers_bbox_preds (Tensor): Sigmoid outputs from the regression
+              head with normalized coordinate format (cx, cy, w, h), has shape
+              (num_decoder_layers, bs, num_queries, 4).
+        """
+        layers_cls_scores = self.fc_cls(hidden_states)
+        layers_bbox_preds = self.fc_reg(
+            self.activate(self.reg_ffn(hidden_states))).sigmoid()
+        return layers_cls_scores, layers_bbox_preds
+
+    def loss(self, hidden_states: Tensor,
+             batch_data_samples: SampleList) -> dict:
+        """Perform forward propagation and loss calculation of the detection
+        head on the features of the upstream network.
+
+        Args:
+            hidden_states (Tensor): Feature from the transformer decoder, has
+                shape (num_decoder_layers, bs, num_queries, cls_out_channels)
+                or (num_decoder_layers, num_queries, bs, cls_out_channels).
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        batch_gt_instances = []
+        batch_img_metas = []
+        for data_sample in batch_data_samples:
+            batch_img_metas.append(data_sample.metainfo)
+            batch_gt_instances.append(data_sample.gt_instances)
+
+        outs = self(hidden_states)
+        loss_inputs = outs + (batch_gt_instances, batch_img_metas)
+        losses = self.loss_by_feat(*loss_inputs)
+        return losses
+
+    def loss_by_feat(
+        self,
+        all_layers_cls_scores: Tensor,
+        all_layers_bbox_preds: Tensor,
+        batch_gt_instances: InstanceList,
+        batch_img_metas: List[dict],
+        batch_gt_instances_ignore: OptInstanceList = None
+    ) -> Dict[str, Tensor]:
+        """"Loss function.
+
+        Only outputs from the last feature level are used for computing
+        losses by default.
+
+        Args:
+            all_layers_cls_scores (Tensor): Classification outputs
+                of each decoder layers. Each is a 4D-tensor, has shape
+                (num_decoder_layers, bs, num_queries, cls_out_channels).
+            all_layers_bbox_preds (Tensor): Sigmoid regression
+                outputs of each decoder layers. Each is a 4D-tensor with
+                normalized coordinate format (cx, cy, w, h) and shape
+                (num_decoder_layers, bs, num_queries, 4).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        assert batch_gt_instances_ignore is None, \
+            f'{self.__class__.__name__} only supports ' \
+            'for batch_gt_instances_ignore setting to None.'
+
+        losses_cls, losses_bbox, losses_iou = multi_apply(
+            self.loss_by_feat_single,
+            all_layers_cls_scores,
+            all_layers_bbox_preds,
+            batch_gt_instances=batch_gt_instances,
+            batch_img_metas=batch_img_metas)
+
+        loss_dict = dict()
+        # loss from the last decoder layer
+        loss_dict['loss_cls'] = losses_cls[-1]
+        loss_dict['loss_bbox'] = losses_bbox[-1]
+        loss_dict['loss_iou'] = losses_iou[-1]
+        # loss from other decoder layers
+        num_dec_layer = 0
+        for loss_cls_i, loss_bbox_i, loss_iou_i in \
+                zip(losses_cls[:-1], losses_bbox[:-1], losses_iou[:-1]):
+            loss_dict[f'd{num_dec_layer}.loss_cls'] = loss_cls_i
+            loss_dict[f'd{num_dec_layer}.loss_bbox'] = loss_bbox_i
+            loss_dict[f'd{num_dec_layer}.loss_iou'] = loss_iou_i
+            num_dec_layer += 1
+        return loss_dict
+
+    def loss_by_feat_single(self, cls_scores: Tensor, bbox_preds: Tensor,
+                            batch_gt_instances: InstanceList,
+                            batch_img_metas: List[dict]) -> Tuple[Tensor]:
+        """Loss function for outputs from a single decoder layer of a single
+        feature level.
+
+        Args:
+            cls_scores (Tensor): Box score logits from a single decoder layer
+                for all images, has shape (bs, num_queries, cls_out_channels).
+            bbox_preds (Tensor): Sigmoid outputs from a single decoder layer
+                for all images, with normalized coordinate (cx, cy, w, h) and
+                shape (bs, num_queries, 4).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+
+        Returns:
+            Tuple[Tensor]: A tuple including `loss_cls`, `loss_box` and
+            `loss_iou`.
+        """
+        num_imgs = cls_scores.size(0)
+        cls_scores_list = [cls_scores[i] for i in range(num_imgs)]
+        bbox_preds_list = [bbox_preds[i] for i in range(num_imgs)]
+        cls_reg_targets = self.get_targets(cls_scores_list, bbox_preds_list,
+                                           batch_gt_instances, batch_img_metas)
+        (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,
+         num_total_pos, num_total_neg) = cls_reg_targets
+        labels = torch.cat(labels_list, 0)
+        label_weights = torch.cat(label_weights_list, 0)
+        bbox_targets = torch.cat(bbox_targets_list, 0)
+        bbox_weights = torch.cat(bbox_weights_list, 0)
+
+        # classification loss
+        cls_scores = cls_scores.reshape(-1, self.cls_out_channels)
+        # construct weighted avg_factor to match with the official DETR repo
+        cls_avg_factor = num_total_pos * 1.0 + \
+            num_total_neg * self.bg_cls_weight
+        if self.sync_cls_avg_factor:
+            cls_avg_factor = reduce_mean(
+                cls_scores.new_tensor([cls_avg_factor]))
+        cls_avg_factor = max(cls_avg_factor, 1)
+
+        if isinstance(self.loss_cls, QualityFocalLoss):
+            bg_class_ind = self.num_classes
+            pos_inds = ((labels >= 0)
+                        & (labels < bg_class_ind)).nonzero().squeeze(1)
+            scores = label_weights.new_zeros(labels.shape)
+            pos_bbox_targets = bbox_targets[pos_inds]
+            pos_decode_bbox_targets = bbox_cxcywh_to_xyxy(pos_bbox_targets)
+            pos_bbox_pred = bbox_preds.reshape(-1, 4)[pos_inds]
+            pos_decode_bbox_pred = bbox_cxcywh_to_xyxy(pos_bbox_pred)
+            scores[pos_inds] = bbox_overlaps(
+                pos_decode_bbox_pred.detach(),
+                pos_decode_bbox_targets,
+                is_aligned=True)
+            loss_cls = self.loss_cls(
+                cls_scores, (labels, scores),
+                label_weights,
+                avg_factor=cls_avg_factor)
+        else:
+            loss_cls = self.loss_cls(
+                cls_scores, labels, label_weights, avg_factor=cls_avg_factor)
+
+        # Compute the average number of gt boxes across all gpus, for
+        # normalization purposes
+        num_total_pos = loss_cls.new_tensor([num_total_pos])
+        num_total_pos = torch.clamp(reduce_mean(num_total_pos), min=1).item()
+
+        # construct factors used for rescale bboxes
+        factors = []
+        for img_meta, bbox_pred in zip(batch_img_metas, bbox_preds):
+            img_h, img_w, = img_meta['img_shape']
+            factor = bbox_pred.new_tensor([img_w, img_h, img_w,
+                                           img_h]).unsqueeze(0).repeat(
+                                               bbox_pred.size(0), 1)
+            factors.append(factor)
+        factors = torch.cat(factors, 0)
+
+        # DETR regress the relative position of boxes (cxcywh) in the image,
+        # thus the learning target is normalized by the image size. So here
+        # we need to re-scale them for calculating IoU loss
+        bbox_preds = bbox_preds.reshape(-1, 4)
+        bboxes = bbox_cxcywh_to_xyxy(bbox_preds) * factors
+        bboxes_gt = bbox_cxcywh_to_xyxy(bbox_targets) * factors
+
+        # regression IoU loss, defaultly GIoU loss
+        loss_iou = self.loss_iou(
+            bboxes, bboxes_gt, bbox_weights, avg_factor=num_total_pos)
+
+        # regression L1 loss
+        loss_bbox = self.loss_bbox(
+            bbox_preds, bbox_targets, bbox_weights, avg_factor=num_total_pos)
+        return loss_cls, loss_bbox, loss_iou
+
+    def get_targets(self, cls_scores_list: List[Tensor],
+                    bbox_preds_list: List[Tensor],
+                    batch_gt_instances: InstanceList,
+                    batch_img_metas: List[dict]) -> tuple:
+        """Compute regression and classification targets for a batch image.
+
+        Outputs from a single decoder layer of a single feature level are used.
+
+        Args:
+            cls_scores_list (list[Tensor]): Box score logits from a single
+                decoder layer for each image, has shape [num_queries,
+                cls_out_channels].
+            bbox_preds_list (list[Tensor]): Sigmoid outputs from a single
+                decoder layer for each image, with normalized coordinate
+                (cx, cy, w, h) and shape [num_queries, 4].
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+
+        Returns:
+            tuple: a tuple containing the following targets.
+
+            - labels_list (list[Tensor]): Labels for all images.
+            - label_weights_list (list[Tensor]): Label weights for all images.
+            - bbox_targets_list (list[Tensor]): BBox targets for all images.
+            - bbox_weights_list (list[Tensor]): BBox weights for all images.
+            - num_total_pos (int): Number of positive samples in all images.
+            - num_total_neg (int): Number of negative samples in all images.
+        """
+        (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,
+         pos_inds_list,
+         neg_inds_list) = multi_apply(self._get_targets_single,
+                                      cls_scores_list, bbox_preds_list,
+                                      batch_gt_instances, batch_img_metas)
+        num_total_pos = sum((inds.numel() for inds in pos_inds_list))
+        num_total_neg = sum((inds.numel() for inds in neg_inds_list))
+        return (labels_list, label_weights_list, bbox_targets_list,
+                bbox_weights_list, num_total_pos, num_total_neg)
+
+    def _get_targets_single(self, cls_score: Tensor, bbox_pred: Tensor,
+                            gt_instances: InstanceData,
+                            img_meta: dict) -> tuple:
+        """Compute regression and classification targets for one image.
+
+        Outputs from a single decoder layer of a single feature level are used.
+
+        Args:
+            cls_score (Tensor): Box score logits from a single decoder layer
+                for one image. Shape [num_queries, cls_out_channels].
+            bbox_pred (Tensor): Sigmoid outputs from a single decoder layer
+                for one image, with normalized coordinate (cx, cy, w, h) and
+                shape [num_queries, 4].
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It should includes ``bboxes`` and ``labels``
+                attributes.
+            img_meta (dict): Meta information for one image.
+
+        Returns:
+            tuple[Tensor]: a tuple containing the following for one image.
+
+            - labels (Tensor): Labels of each image.
+            - label_weights (Tensor]): Label weights of each image.
+            - bbox_targets (Tensor): BBox targets of each image.
+            - bbox_weights (Tensor): BBox weights of each image.
+            - pos_inds (Tensor): Sampled positive indices for each image.
+            - neg_inds (Tensor): Sampled negative indices for each image.
+        """
+        img_h, img_w = img_meta['img_shape']
+        factor = bbox_pred.new_tensor([img_w, img_h, img_w,
+                                       img_h]).unsqueeze(0)
+        num_bboxes = bbox_pred.size(0)
+        # convert bbox_pred from xywh, normalized to xyxy, unnormalized
+        bbox_pred = bbox_cxcywh_to_xyxy(bbox_pred)
+        bbox_pred = bbox_pred * factor
+
+        pred_instances = InstanceData(scores=cls_score, bboxes=bbox_pred)
+        # assigner and sampler
+        assign_result = self.assigner.assign(
+            pred_instances=pred_instances,
+            gt_instances=gt_instances,
+            img_meta=img_meta)
+
+        gt_bboxes = gt_instances.bboxes
+        gt_labels = gt_instances.labels
+        pos_inds = torch.nonzero(
+            assign_result.gt_inds > 0, as_tuple=False).squeeze(-1).unique()
+        neg_inds = torch.nonzero(
+            assign_result.gt_inds == 0, as_tuple=False).squeeze(-1).unique()
+        pos_assigned_gt_inds = assign_result.gt_inds[pos_inds] - 1
+        pos_gt_bboxes = gt_bboxes[pos_assigned_gt_inds.long(), :]
+
+        # label targets
+        labels = gt_bboxes.new_full((num_bboxes, ),
+                                    self.num_classes,
+                                    dtype=torch.long)
+        labels[pos_inds] = gt_labels[pos_assigned_gt_inds]
+        label_weights = gt_bboxes.new_ones(num_bboxes)
+
+        # bbox targets
+        bbox_targets = torch.zeros_like(bbox_pred, dtype=gt_bboxes.dtype)
+        bbox_weights = torch.zeros_like(bbox_pred, dtype=gt_bboxes.dtype)
+        bbox_weights[pos_inds] = 1.0
+
+        # DETR regress the relative position of boxes (cxcywh) in the image.
+        # Thus the learning target should be normalized by the image size, also
+        # the box format should be converted from defaultly x1y1x2y2 to cxcywh.
+        pos_gt_bboxes_normalized = pos_gt_bboxes / factor
+        pos_gt_bboxes_targets = bbox_xyxy_to_cxcywh(pos_gt_bboxes_normalized)
+        bbox_targets[pos_inds] = pos_gt_bboxes_targets
+        return (labels, label_weights, bbox_targets, bbox_weights, pos_inds,
+                neg_inds)
+
+    def loss_and_predict(
+            self, hidden_states: Tuple[Tensor],
+            batch_data_samples: SampleList) -> Tuple[dict, InstanceList]:
+        """Perform forward propagation of the head, then calculate loss and
+        predictions from the features and data samples. Over-write because
+        img_metas are needed as inputs for bbox_head.
+
+        Args:
+            hidden_states (tuple[Tensor]): Feature from the transformer
+                decoder, has shape (num_decoder_layers, bs, num_queries, dim).
+            batch_data_samples (list[:obj:`DetDataSample`]): Each item contains
+                the meta information of each image and corresponding
+                annotations.
+
+        Returns:
+            tuple: the return value is a tuple contains:
+
+            - losses: (dict[str, Tensor]): A dictionary of loss components.
+            - predictions (list[:obj:`InstanceData`]): Detection
+              results of each image after the post process.
+        """
+        batch_gt_instances = []
+        batch_img_metas = []
+        for data_sample in batch_data_samples:
+            batch_img_metas.append(data_sample.metainfo)
+            batch_gt_instances.append(data_sample.gt_instances)
+
+        outs = self(hidden_states)
+        loss_inputs = outs + (batch_gt_instances, batch_img_metas)
+        losses = self.loss_by_feat(*loss_inputs)
+
+        predictions = self.predict_by_feat(
+            *outs, batch_img_metas=batch_img_metas)
+        return losses, predictions
+
+    def predict(self,
+                hidden_states: Tuple[Tensor],
+                batch_data_samples: SampleList,
+                rescale: bool = True) -> InstanceList:
+        """Perform forward propagation of the detection head and predict
+        detection results on the features of the upstream network. Over-write
+        because img_metas are needed as inputs for bbox_head.
+
+        Args:
+            hidden_states (tuple[Tensor]): Multi-level features from the
+                upstream network, each is a 4D-tensor.
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            rescale (bool, optional): Whether to rescale the results.
+                Defaults to True.
+
+        Returns:
+            list[obj:`InstanceData`]: Detection results of each image
+            after the post process.
+        """
+        batch_img_metas = [
+            data_samples.metainfo for data_samples in batch_data_samples
+        ]
+
+        last_layer_hidden_state = hidden_states[-1].unsqueeze(0)
+        outs = self(last_layer_hidden_state)
+
+        predictions = self.predict_by_feat(
+            *outs, batch_img_metas=batch_img_metas, rescale=rescale)
+
+        return predictions
+
+    def predict_by_feat(self,
+                        layer_cls_scores: Tensor,
+                        layer_bbox_preds: Tensor,
+                        batch_img_metas: List[dict],
+                        rescale: bool = True) -> InstanceList:
+        """Transform network outputs for a batch into bbox predictions.
+
+        Args:
+            layer_cls_scores (Tensor): Classification outputs of the last or
+                all decoder layer. Each is a 4D-tensor, has shape
+                (num_decoder_layers, bs, num_queries, cls_out_channels).
+            layer_bbox_preds (Tensor): Sigmoid regression outputs of the last
+                or all decoder layer. Each is a 4D-tensor with normalized
+                coordinate format (cx, cy, w, h) and shape
+                (num_decoder_layers, bs, num_queries, 4).
+            batch_img_metas (list[dict]): Meta information of each image.
+            rescale (bool, optional): If `True`, return boxes in original
+                image space. Defaults to `True`.
+
+        Returns:
+            list[:obj:`InstanceData`]: Object detection results of each image
+            after the post process. Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        # NOTE only using outputs from the last feature level,
+        # and only the outputs from the last decoder layer is used.
+        cls_scores = layer_cls_scores[-1]
+        bbox_preds = layer_bbox_preds[-1]
+
+        result_list = []
+        for img_id in range(len(batch_img_metas)):
+            cls_score = cls_scores[img_id]
+            bbox_pred = bbox_preds[img_id]
+            img_meta = batch_img_metas[img_id]
+            results = self._predict_by_feat_single(cls_score, bbox_pred,
+                                                   img_meta, rescale)
+            result_list.append(results)
+        return result_list
+
+    def _predict_by_feat_single(self,
+                                cls_score: Tensor,
+                                bbox_pred: Tensor,
+                                img_meta: dict,
+                                rescale: bool = True) -> InstanceData:
+        """Transform outputs from the last decoder layer into bbox predictions
+        for each image.
+
+        Args:
+            cls_score (Tensor): Box score logits from the last decoder layer
+                for each image. Shape [num_queries, cls_out_channels].
+            bbox_pred (Tensor): Sigmoid outputs from the last decoder layer
+                for each image, with coordinate format (cx, cy, w, h) and
+                shape [num_queries, 4].
+            img_meta (dict): Image meta info.
+            rescale (bool): If True, return boxes in original image
+                space. Default True.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        assert len(cls_score) == len(bbox_pred)  # num_queries
+        max_per_img = self.test_cfg.get('max_per_img', len(cls_score))
+        img_shape = img_meta['img_shape']
+        # exclude background
+        if self.loss_cls.use_sigmoid:
+            cls_score = cls_score.sigmoid()
+            scores, indexes = cls_score.view(-1).topk(max_per_img)
+            det_labels = indexes % self.num_classes
+            bbox_index = indexes // self.num_classes
+            bbox_pred = bbox_pred[bbox_index]
+        else:
+            scores, det_labels = F.softmax(cls_score, dim=-1)[..., :-1].max(-1)
+            scores, bbox_index = scores.topk(max_per_img)
+            bbox_pred = bbox_pred[bbox_index]
+            det_labels = det_labels[bbox_index]
+
+        det_bboxes = bbox_cxcywh_to_xyxy(bbox_pred)
+        det_bboxes[:, 0::2] = det_bboxes[:, 0::2] * img_shape[1]
+        det_bboxes[:, 1::2] = det_bboxes[:, 1::2] * img_shape[0]
+        det_bboxes[:, 0::2].clamp_(min=0, max=img_shape[1])
+        det_bboxes[:, 1::2].clamp_(min=0, max=img_shape[0])
+        if rescale:
+            assert img_meta.get('scale_factor') is not None
+            det_bboxes /= det_bboxes.new_tensor(
+                img_meta['scale_factor']).repeat((1, 2))
+
+        results = InstanceData()
+        results.bboxes = det_bboxes
+        results.scores = scores
+        results.labels = det_labels
+        return results
diff --git a/mmdetection/mmdet/models/dense_heads/dino_head.py b/mmdetection/mmdet/models/dense_heads/dino_head.py
new file mode 100644
index 00000000..54f46d14
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/dino_head.py
@@ -0,0 +1,479 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, List, Tuple
+
+import torch
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.structures.bbox import (bbox_cxcywh_to_xyxy, bbox_overlaps,
+                                   bbox_xyxy_to_cxcywh)
+from mmdet.utils import InstanceList, OptInstanceList, reduce_mean
+from ..losses import QualityFocalLoss
+from ..utils import multi_apply
+from .deformable_detr_head import DeformableDETRHead
+
+
+@MODELS.register_module()
+class DINOHead(DeformableDETRHead):
+    r"""Head of the DINO: DETR with Improved DeNoising Anchor Boxes
+    for End-to-End Object Detection
+
+    Code is modified from the `official github repo
+    `_.
+
+    More details can be found in the `paper
+    `_ .
+    """
+
+    def loss(self, hidden_states: Tensor, references: List[Tensor],
+             enc_outputs_class: Tensor, enc_outputs_coord: Tensor,
+             batch_data_samples: SampleList, dn_meta: Dict[str, int]) -> dict:
+        """Perform forward propagation and loss calculation of the detection
+        head on the queries of the upstream network.
+
+        Args:
+            hidden_states (Tensor): Hidden states output from each decoder
+                layer, has shape (num_decoder_layers, bs, num_queries_total,
+                dim), where `num_queries_total` is the sum of
+                `num_denoising_queries` and `num_matching_queries` when
+                `self.training` is `True`, else `num_matching_queries`.
+            references (list[Tensor]): List of the reference from the decoder.
+                The first reference is the `init_reference` (initial) and the
+                other num_decoder_layers(6) references are `inter_references`
+                (intermediate). The `init_reference` has shape (bs,
+                num_queries_total, 4) and each `inter_reference` has shape
+                (bs, num_queries, 4) with the last dimension arranged as
+                (cx, cy, w, h).
+            enc_outputs_class (Tensor): The score of each point on encode
+                feature map, has shape (bs, num_feat_points, cls_out_channels).
+            enc_outputs_coord (Tensor): The proposal generate from the
+                encode feature map, has shape (bs, num_feat_points, 4) with the
+                last dimension arranged as (cx, cy, w, h).
+            batch_data_samples (list[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            dn_meta (Dict[str, int]): The dictionary saves information about
+              group collation, including 'num_denoising_queries' and
+              'num_denoising_groups'. It will be used for split outputs of
+              denoising and matching parts and loss calculation.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        batch_gt_instances = []
+        batch_img_metas = []
+        for data_sample in batch_data_samples:
+            batch_img_metas.append(data_sample.metainfo)
+            batch_gt_instances.append(data_sample.gt_instances)
+
+        outs = self(hidden_states, references)
+        loss_inputs = outs + (enc_outputs_class, enc_outputs_coord,
+                              batch_gt_instances, batch_img_metas, dn_meta)
+        losses = self.loss_by_feat(*loss_inputs)
+        return losses
+
+    def loss_by_feat(
+        self,
+        all_layers_cls_scores: Tensor,
+        all_layers_bbox_preds: Tensor,
+        enc_cls_scores: Tensor,
+        enc_bbox_preds: Tensor,
+        batch_gt_instances: InstanceList,
+        batch_img_metas: List[dict],
+        dn_meta: Dict[str, int],
+        batch_gt_instances_ignore: OptInstanceList = None
+    ) -> Dict[str, Tensor]:
+        """Loss function.
+
+        Args:
+            all_layers_cls_scores (Tensor): Classification scores of all
+                decoder layers, has shape (num_decoder_layers, bs,
+                num_queries_total, cls_out_channels), where
+                `num_queries_total` is the sum of `num_denoising_queries`
+                and `num_matching_queries`.
+            all_layers_bbox_preds (Tensor): Regression outputs of all decoder
+                layers. Each is a 4D-tensor with normalized coordinate format
+                (cx, cy, w, h) and has shape (num_decoder_layers, bs,
+                num_queries_total, 4).
+            enc_cls_scores (Tensor): The score of each point on encode
+                feature map, has shape (bs, num_feat_points, cls_out_channels).
+            enc_bbox_preds (Tensor): The proposal generate from the encode
+                feature map, has shape (bs, num_feat_points, 4) with the last
+                dimension arranged as (cx, cy, w, h).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            dn_meta (Dict[str, int]): The dictionary saves information about
+                group collation, including 'num_denoising_queries' and
+                'num_denoising_groups'. It will be used for split outputs of
+                denoising and matching parts and loss calculation.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        # extract denoising and matching part of outputs
+        (all_layers_matching_cls_scores, all_layers_matching_bbox_preds,
+         all_layers_denoising_cls_scores, all_layers_denoising_bbox_preds) = \
+            self.split_outputs(
+                all_layers_cls_scores, all_layers_bbox_preds, dn_meta)
+
+        loss_dict = super(DeformableDETRHead, self).loss_by_feat(
+            all_layers_matching_cls_scores, all_layers_matching_bbox_preds,
+            batch_gt_instances, batch_img_metas, batch_gt_instances_ignore)
+        # NOTE DETRHead.loss_by_feat but not DeformableDETRHead.loss_by_feat
+        # is called, because the encoder loss calculations are different
+        # between DINO and DeformableDETR.
+
+        # loss of proposal generated from encode feature map.
+        if enc_cls_scores is not None:
+            # NOTE The enc_loss calculation of the DINO is
+            # different from that of Deformable DETR.
+            enc_loss_cls, enc_losses_bbox, enc_losses_iou = \
+                self.loss_by_feat_single(
+                    enc_cls_scores, enc_bbox_preds,
+                    batch_gt_instances=batch_gt_instances,
+                    batch_img_metas=batch_img_metas)
+            loss_dict['enc_loss_cls'] = enc_loss_cls
+            loss_dict['enc_loss_bbox'] = enc_losses_bbox
+            loss_dict['enc_loss_iou'] = enc_losses_iou
+
+        if all_layers_denoising_cls_scores is not None:
+            # calculate denoising loss from all decoder layers
+            dn_losses_cls, dn_losses_bbox, dn_losses_iou = self.loss_dn(
+                all_layers_denoising_cls_scores,
+                all_layers_denoising_bbox_preds,
+                batch_gt_instances=batch_gt_instances,
+                batch_img_metas=batch_img_metas,
+                dn_meta=dn_meta)
+            # collate denoising loss
+            loss_dict['dn_loss_cls'] = dn_losses_cls[-1]
+            loss_dict['dn_loss_bbox'] = dn_losses_bbox[-1]
+            loss_dict['dn_loss_iou'] = dn_losses_iou[-1]
+            for num_dec_layer, (loss_cls_i, loss_bbox_i, loss_iou_i) in \
+                    enumerate(zip(dn_losses_cls[:-1], dn_losses_bbox[:-1],
+                                  dn_losses_iou[:-1])):
+                loss_dict[f'd{num_dec_layer}.dn_loss_cls'] = loss_cls_i
+                loss_dict[f'd{num_dec_layer}.dn_loss_bbox'] = loss_bbox_i
+                loss_dict[f'd{num_dec_layer}.dn_loss_iou'] = loss_iou_i
+        return loss_dict
+
+    def loss_dn(self, all_layers_denoising_cls_scores: Tensor,
+                all_layers_denoising_bbox_preds: Tensor,
+                batch_gt_instances: InstanceList, batch_img_metas: List[dict],
+                dn_meta: Dict[str, int]) -> Tuple[List[Tensor]]:
+        """Calculate denoising loss.
+
+        Args:
+            all_layers_denoising_cls_scores (Tensor): Classification scores of
+                all decoder layers in denoising part, has shape (
+                num_decoder_layers, bs, num_denoising_queries,
+                cls_out_channels).
+            all_layers_denoising_bbox_preds (Tensor): Regression outputs of all
+                decoder layers in denoising part. Each is a 4D-tensor with
+                normalized coordinate format (cx, cy, w, h) and has shape
+                (num_decoder_layers, bs, num_denoising_queries, 4).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            dn_meta (Dict[str, int]): The dictionary saves information about
+              group collation, including 'num_denoising_queries' and
+              'num_denoising_groups'. It will be used for split outputs of
+              denoising and matching parts and loss calculation.
+
+        Returns:
+            Tuple[List[Tensor]]: The loss_dn_cls, loss_dn_bbox, and loss_dn_iou
+            of each decoder layers.
+        """
+        return multi_apply(
+            self._loss_dn_single,
+            all_layers_denoising_cls_scores,
+            all_layers_denoising_bbox_preds,
+            batch_gt_instances=batch_gt_instances,
+            batch_img_metas=batch_img_metas,
+            dn_meta=dn_meta)
+
+    def _loss_dn_single(self, dn_cls_scores: Tensor, dn_bbox_preds: Tensor,
+                        batch_gt_instances: InstanceList,
+                        batch_img_metas: List[dict],
+                        dn_meta: Dict[str, int]) -> Tuple[Tensor]:
+        """Denoising loss for outputs from a single decoder layer.
+
+        Args:
+            dn_cls_scores (Tensor): Classification scores of a single decoder
+                layer in denoising part, has shape (bs, num_denoising_queries,
+                cls_out_channels).
+            dn_bbox_preds (Tensor): Regression outputs of a single decoder
+                layer in denoising part. Each is a 4D-tensor with normalized
+                coordinate format (cx, cy, w, h) and has shape
+                (bs, num_denoising_queries, 4).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            dn_meta (Dict[str, int]): The dictionary saves information about
+              group collation, including 'num_denoising_queries' and
+              'num_denoising_groups'. It will be used for split outputs of
+              denoising and matching parts and loss calculation.
+
+        Returns:
+            Tuple[Tensor]: A tuple including `loss_cls`, `loss_box` and
+            `loss_iou`.
+        """
+        cls_reg_targets = self.get_dn_targets(batch_gt_instances,
+                                              batch_img_metas, dn_meta)
+        (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,
+         num_total_pos, num_total_neg) = cls_reg_targets
+        labels = torch.cat(labels_list, 0)
+        label_weights = torch.cat(label_weights_list, 0)
+        bbox_targets = torch.cat(bbox_targets_list, 0)
+        bbox_weights = torch.cat(bbox_weights_list, 0)
+
+        # classification loss
+        cls_scores = dn_cls_scores.reshape(-1, self.cls_out_channels)
+        # construct weighted avg_factor to match with the official DETR repo
+        cls_avg_factor = \
+            num_total_pos * 1.0 + num_total_neg * self.bg_cls_weight
+        if self.sync_cls_avg_factor:
+            cls_avg_factor = reduce_mean(
+                cls_scores.new_tensor([cls_avg_factor]))
+        cls_avg_factor = max(cls_avg_factor, 1)
+
+        if len(cls_scores) > 0:
+            if isinstance(self.loss_cls, QualityFocalLoss):
+                bg_class_ind = self.num_classes
+                pos_inds = ((labels >= 0)
+                            & (labels < bg_class_ind)).nonzero().squeeze(1)
+                scores = label_weights.new_zeros(labels.shape)
+                pos_bbox_targets = bbox_targets[pos_inds]
+                pos_decode_bbox_targets = bbox_cxcywh_to_xyxy(pos_bbox_targets)
+                pos_bbox_pred = dn_bbox_preds.reshape(-1, 4)[pos_inds]
+                pos_decode_bbox_pred = bbox_cxcywh_to_xyxy(pos_bbox_pred)
+                scores[pos_inds] = bbox_overlaps(
+                    pos_decode_bbox_pred.detach(),
+                    pos_decode_bbox_targets,
+                    is_aligned=True)
+                loss_cls = self.loss_cls(
+                    cls_scores, (labels, scores),
+                    weight=label_weights,
+                    avg_factor=cls_avg_factor)
+            else:
+                loss_cls = self.loss_cls(
+                    cls_scores,
+                    labels,
+                    label_weights,
+                    avg_factor=cls_avg_factor)
+        else:
+            loss_cls = torch.zeros(
+                1, dtype=cls_scores.dtype, device=cls_scores.device)
+
+        # Compute the average number of gt boxes across all gpus, for
+        # normalization purposes
+        num_total_pos = loss_cls.new_tensor([num_total_pos])
+        num_total_pos = torch.clamp(reduce_mean(num_total_pos), min=1).item()
+
+        # construct factors used for rescale bboxes
+        factors = []
+        for img_meta, bbox_pred in zip(batch_img_metas, dn_bbox_preds):
+            img_h, img_w = img_meta['img_shape']
+            factor = bbox_pred.new_tensor([img_w, img_h, img_w,
+                                           img_h]).unsqueeze(0).repeat(
+                                               bbox_pred.size(0), 1)
+            factors.append(factor)
+        factors = torch.cat(factors)
+
+        # DETR regress the relative position of boxes (cxcywh) in the image,
+        # thus the learning target is normalized by the image size. So here
+        # we need to re-scale them for calculating IoU loss
+        bbox_preds = dn_bbox_preds.reshape(-1, 4)
+        bboxes = bbox_cxcywh_to_xyxy(bbox_preds) * factors
+        bboxes_gt = bbox_cxcywh_to_xyxy(bbox_targets) * factors
+
+        # regression IoU loss, defaultly GIoU loss
+        loss_iou = self.loss_iou(
+            bboxes, bboxes_gt, bbox_weights, avg_factor=num_total_pos)
+
+        # regression L1 loss
+        loss_bbox = self.loss_bbox(
+            bbox_preds, bbox_targets, bbox_weights, avg_factor=num_total_pos)
+        return loss_cls, loss_bbox, loss_iou
+
+    def get_dn_targets(self, batch_gt_instances: InstanceList,
+                       batch_img_metas: dict, dn_meta: Dict[str,
+                                                            int]) -> tuple:
+        """Get targets in denoising part for a batch of images.
+
+        Args:
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            dn_meta (Dict[str, int]): The dictionary saves information about
+              group collation, including 'num_denoising_queries' and
+              'num_denoising_groups'. It will be used for split outputs of
+              denoising and matching parts and loss calculation.
+
+        Returns:
+            tuple: a tuple containing the following targets.
+
+            - labels_list (list[Tensor]): Labels for all images.
+            - label_weights_list (list[Tensor]): Label weights for all images.
+            - bbox_targets_list (list[Tensor]): BBox targets for all images.
+            - bbox_weights_list (list[Tensor]): BBox weights for all images.
+            - num_total_pos (int): Number of positive samples in all images.
+            - num_total_neg (int): Number of negative samples in all images.
+        """
+        (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,
+         pos_inds_list, neg_inds_list) = multi_apply(
+             self._get_dn_targets_single,
+             batch_gt_instances,
+             batch_img_metas,
+             dn_meta=dn_meta)
+        num_total_pos = sum((inds.numel() for inds in pos_inds_list))
+        num_total_neg = sum((inds.numel() for inds in neg_inds_list))
+        return (labels_list, label_weights_list, bbox_targets_list,
+                bbox_weights_list, num_total_pos, num_total_neg)
+
+    def _get_dn_targets_single(self, gt_instances: InstanceData,
+                               img_meta: dict, dn_meta: Dict[str,
+                                                             int]) -> tuple:
+        """Get targets in denoising part for one image.
+
+        Args:
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It should includes ``bboxes`` and ``labels``
+                attributes.
+            img_meta (dict): Meta information for one image.
+            dn_meta (Dict[str, int]): The dictionary saves information about
+              group collation, including 'num_denoising_queries' and
+              'num_denoising_groups'. It will be used for split outputs of
+              denoising and matching parts and loss calculation.
+
+        Returns:
+            tuple[Tensor]: a tuple containing the following for one image.
+
+            - labels (Tensor): Labels of each image.
+            - label_weights (Tensor]): Label weights of each image.
+            - bbox_targets (Tensor): BBox targets of each image.
+            - bbox_weights (Tensor): BBox weights of each image.
+            - pos_inds (Tensor): Sampled positive indices for each image.
+            - neg_inds (Tensor): Sampled negative indices for each image.
+        """
+        gt_bboxes = gt_instances.bboxes
+        gt_labels = gt_instances.labels
+        num_groups = dn_meta['num_denoising_groups']
+        num_denoising_queries = dn_meta['num_denoising_queries']
+        num_queries_each_group = int(num_denoising_queries / num_groups)
+        device = gt_bboxes.device
+
+        if len(gt_labels) > 0:
+            t = torch.arange(len(gt_labels), dtype=torch.long, device=device)
+            t = t.unsqueeze(0).repeat(num_groups, 1)
+            pos_assigned_gt_inds = t.flatten()
+            pos_inds = torch.arange(
+                num_groups, dtype=torch.long, device=device)
+            pos_inds = pos_inds.unsqueeze(1) * num_queries_each_group + t
+            pos_inds = pos_inds.flatten()
+        else:
+            pos_inds = pos_assigned_gt_inds = \
+                gt_bboxes.new_tensor([], dtype=torch.long)
+
+        neg_inds = pos_inds + num_queries_each_group // 2
+
+        # label targets
+        labels = gt_bboxes.new_full((num_denoising_queries, ),
+                                    self.num_classes,
+                                    dtype=torch.long)
+        labels[pos_inds] = gt_labels[pos_assigned_gt_inds]
+        label_weights = gt_bboxes.new_ones(num_denoising_queries)
+
+        # bbox targets
+        bbox_targets = torch.zeros(num_denoising_queries, 4, device=device)
+        bbox_weights = torch.zeros(num_denoising_queries, 4, device=device)
+        bbox_weights[pos_inds] = 1.0
+        img_h, img_w = img_meta['img_shape']
+
+        # DETR regress the relative position of boxes (cxcywh) in the image.
+        # Thus the learning target should be normalized by the image size, also
+        # the box format should be converted from defaultly x1y1x2y2 to cxcywh.
+        factor = gt_bboxes.new_tensor([img_w, img_h, img_w,
+                                       img_h]).unsqueeze(0)
+        gt_bboxes_normalized = gt_bboxes / factor
+        gt_bboxes_targets = bbox_xyxy_to_cxcywh(gt_bboxes_normalized)
+        bbox_targets[pos_inds] = gt_bboxes_targets.repeat([num_groups, 1])
+
+        return (labels, label_weights, bbox_targets, bbox_weights, pos_inds,
+                neg_inds)
+
+    @staticmethod
+    def split_outputs(all_layers_cls_scores: Tensor,
+                      all_layers_bbox_preds: Tensor,
+                      dn_meta: Dict[str, int]) -> Tuple[Tensor]:
+        """Split outputs of the denoising part and the matching part.
+
+        For the total outputs of `num_queries_total` length, the former
+        `num_denoising_queries` outputs are from denoising queries, and
+        the rest `num_matching_queries` ones are from matching queries,
+        where `num_queries_total` is the sum of `num_denoising_queries` and
+        `num_matching_queries`.
+
+        Args:
+            all_layers_cls_scores (Tensor): Classification scores of all
+                decoder layers, has shape (num_decoder_layers, bs,
+                num_queries_total, cls_out_channels).
+            all_layers_bbox_preds (Tensor): Regression outputs of all decoder
+                layers. Each is a 4D-tensor with normalized coordinate format
+                (cx, cy, w, h) and has shape (num_decoder_layers, bs,
+                num_queries_total, 4).
+            dn_meta (Dict[str, int]): The dictionary saves information about
+              group collation, including 'num_denoising_queries' and
+              'num_denoising_groups'.
+
+        Returns:
+            Tuple[Tensor]: a tuple containing the following outputs.
+
+            - all_layers_matching_cls_scores (Tensor): Classification scores
+              of all decoder layers in matching part, has shape
+              (num_decoder_layers, bs, num_matching_queries, cls_out_channels).
+            - all_layers_matching_bbox_preds (Tensor): Regression outputs of
+              all decoder layers in matching part. Each is a 4D-tensor with
+              normalized coordinate format (cx, cy, w, h) and has shape
+              (num_decoder_layers, bs, num_matching_queries, 4).
+            - all_layers_denoising_cls_scores (Tensor): Classification scores
+              of all decoder layers in denoising part, has shape
+              (num_decoder_layers, bs, num_denoising_queries,
+              cls_out_channels).
+            - all_layers_denoising_bbox_preds (Tensor): Regression outputs of
+              all decoder layers in denoising part. Each is a 4D-tensor with
+              normalized coordinate format (cx, cy, w, h) and has shape
+              (num_decoder_layers, bs, num_denoising_queries, 4).
+        """
+        num_denoising_queries = dn_meta['num_denoising_queries']
+        if dn_meta is not None:
+            all_layers_denoising_cls_scores = \
+                all_layers_cls_scores[:, :, : num_denoising_queries, :]
+            all_layers_denoising_bbox_preds = \
+                all_layers_bbox_preds[:, :, : num_denoising_queries, :]
+            all_layers_matching_cls_scores = \
+                all_layers_cls_scores[:, :, num_denoising_queries:, :]
+            all_layers_matching_bbox_preds = \
+                all_layers_bbox_preds[:, :, num_denoising_queries:, :]
+        else:
+            all_layers_denoising_cls_scores = None
+            all_layers_denoising_bbox_preds = None
+            all_layers_matching_cls_scores = all_layers_cls_scores
+            all_layers_matching_bbox_preds = all_layers_bbox_preds
+        return (all_layers_matching_cls_scores, all_layers_matching_bbox_preds,
+                all_layers_denoising_cls_scores,
+                all_layers_denoising_bbox_preds)
diff --git a/mmdetection/mmdet/models/dense_heads/embedding_rpn_head.py b/mmdetection/mmdet/models/dense_heads/embedding_rpn_head.py
new file mode 100644
index 00000000..97e84fa8
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/embedding_rpn_head.py
@@ -0,0 +1,132 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List
+
+import torch
+import torch.nn as nn
+from mmengine.model import BaseModule
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures.bbox import bbox_cxcywh_to_xyxy
+from mmdet.structures.det_data_sample import SampleList
+from mmdet.utils import InstanceList, OptConfigType
+
+
+@MODELS.register_module()
+class EmbeddingRPNHead(BaseModule):
+    """RPNHead in the `Sparse R-CNN `_ .
+
+    Unlike traditional RPNHead, this module does not need FPN input, but just
+    decode `init_proposal_bboxes` and expand the first dimension of
+    `init_proposal_bboxes` and `init_proposal_features` to the batch_size.
+
+    Args:
+        num_proposals (int): Number of init_proposals. Defaults to 100.
+        proposal_feature_channel (int): Channel number of
+            init_proposal_feature. Defaults to 256.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict]): Initialization config dict. Defaults to None.
+    """
+
+    def __init__(self,
+                 num_proposals: int = 100,
+                 proposal_feature_channel: int = 256,
+                 init_cfg: OptConfigType = None,
+                 **kwargs) -> None:
+        # `**kwargs` is necessary to avoid some potential error.
+        assert init_cfg is None, 'To prevent abnormal initialization ' \
+                                 'behavior, init_cfg is not allowed to be set'
+        super().__init__(init_cfg=init_cfg)
+        self.num_proposals = num_proposals
+        self.proposal_feature_channel = proposal_feature_channel
+        self._init_layers()
+
+    def _init_layers(self) -> None:
+        """Initialize a sparse set of proposal boxes and proposal features."""
+        self.init_proposal_bboxes = nn.Embedding(self.num_proposals, 4)
+        self.init_proposal_features = nn.Embedding(
+            self.num_proposals, self.proposal_feature_channel)
+
+    def init_weights(self) -> None:
+        """Initialize the init_proposal_bboxes as normalized.
+
+        [c_x, c_y, w, h], and we initialize it to the size of  the entire
+        image.
+        """
+        super().init_weights()
+        nn.init.constant_(self.init_proposal_bboxes.weight[:, :2], 0.5)
+        nn.init.constant_(self.init_proposal_bboxes.weight[:, 2:], 1)
+
+    def _decode_init_proposals(self, x: List[Tensor],
+                               batch_data_samples: SampleList) -> InstanceList:
+        """Decode init_proposal_bboxes according to the size of images and
+        expand dimension of init_proposal_features to batch_size.
+
+        Args:
+            x (list[Tensor]): List of FPN features.
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+
+        Returns:
+            List[:obj:`InstanceData`:] Detection results of each image.
+            Each item usually contains following keys.
+
+            - proposals: Decoded proposal bboxes,
+              has shape (num_proposals, 4).
+            - features: init_proposal_features, expanded proposal
+              features, has shape
+              (num_proposals, proposal_feature_channel).
+            - imgs_whwh: Tensor with shape
+              (num_proposals, 4), the dimension means
+              [img_width, img_height, img_width, img_height].
+        """
+        batch_img_metas = []
+        for data_sample in batch_data_samples:
+            batch_img_metas.append(data_sample.metainfo)
+
+        proposals = self.init_proposal_bboxes.weight.clone()
+        proposals = bbox_cxcywh_to_xyxy(proposals)
+        imgs_whwh = []
+        for meta in batch_img_metas:
+            h, w = meta['img_shape'][:2]
+            imgs_whwh.append(x[0].new_tensor([[w, h, w, h]]))
+        imgs_whwh = torch.cat(imgs_whwh, dim=0)
+        imgs_whwh = imgs_whwh[:, None, :]
+        proposals = proposals * imgs_whwh
+
+        rpn_results_list = []
+        for idx in range(len(batch_img_metas)):
+            rpn_results = InstanceData()
+            rpn_results.bboxes = proposals[idx]
+            rpn_results.imgs_whwh = imgs_whwh[idx].repeat(
+                self.num_proposals, 1)
+            rpn_results.features = self.init_proposal_features.weight.clone()
+            rpn_results_list.append(rpn_results)
+        return rpn_results_list
+
+    def loss(self, *args, **kwargs):
+        """Perform forward propagation and loss calculation of the detection
+        head on the features of the upstream network."""
+        raise NotImplementedError(
+            'EmbeddingRPNHead does not have `loss`, please use '
+            '`predict` or `loss_and_predict` instead.')
+
+    def predict(self, x: List[Tensor], batch_data_samples: SampleList,
+                **kwargs) -> InstanceList:
+        """Perform forward propagation of the detection head and predict
+        detection results on the features of the upstream network."""
+        # `**kwargs` is necessary to avoid some potential error.
+        return self._decode_init_proposals(
+            x=x, batch_data_samples=batch_data_samples)
+
+    def loss_and_predict(self, x: List[Tensor], batch_data_samples: SampleList,
+                         **kwargs) -> tuple:
+        """Perform forward propagation of the head, then calculate loss and
+        predictions from the features and data samples."""
+        # `**kwargs` is necessary to avoid some potential error.
+        predictions = self._decode_init_proposals(
+            x=x, batch_data_samples=batch_data_samples)
+
+        return dict(), predictions
diff --git a/mmdetection/mmdet/models/dense_heads/fcos_head.py b/mmdetection/mmdet/models/dense_heads/fcos_head.py
new file mode 100644
index 00000000..ba4d4640
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/fcos_head.py
@@ -0,0 +1,476 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, List, Tuple
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import Scale
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.models.layers import NormedConv2d
+from mmdet.registry import MODELS
+from mmdet.utils import (ConfigType, InstanceList, MultiConfig,
+                         OptInstanceList, RangeType, reduce_mean)
+from ..utils import multi_apply
+from .anchor_free_head import AnchorFreeHead
+
+INF = 1e8
+
+
+@MODELS.register_module()
+class FCOSHead(AnchorFreeHead):
+    """Anchor-free head used in `FCOS `_.
+
+    The FCOS head does not use anchor boxes. Instead bounding boxes are
+    predicted at each pixel and a centerness measure is used to suppress
+    low-quality predictions.
+    Here norm_on_bbox, centerness_on_reg, dcn_on_last_conv are training
+    tricks used in official repo, which will bring remarkable mAP gains
+    of up to 4.9. Please see https://github.com/tianzhi0549/FCOS for
+    more detail.
+
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (int): Number of channels in the input feature map.
+        strides (Sequence[int] or Sequence[Tuple[int, int]]): Strides of points
+            in multiple feature levels. Defaults to (4, 8, 16, 32, 64).
+        regress_ranges (Sequence[Tuple[int, int]]): Regress range of multiple
+            level points.
+        center_sampling (bool): If true, use center sampling.
+            Defaults to False.
+        center_sample_radius (float): Radius of center sampling.
+            Defaults to 1.5.
+        norm_on_bbox (bool): If true, normalize the regression targets with
+            FPN strides. Defaults to False.
+        centerness_on_reg (bool): If true, position centerness on the
+            regress branch. Please refer to https://github.com/tianzhi0549/FCOS/issues/89#issuecomment-516877042.
+            Defaults to False.
+        conv_bias (bool or str): If specified as `auto`, it will be decided by
+            the norm_cfg. Bias of conv will be set as True if `norm_cfg` is
+            None, otherwise False. Defaults to "auto".
+        loss_cls (:obj:`ConfigDict` or dict): Config of classification loss.
+        loss_bbox (:obj:`ConfigDict` or dict): Config of localization loss.
+        loss_centerness (:obj:`ConfigDict`, or dict): Config of centerness
+            loss.
+        norm_cfg (:obj:`ConfigDict` or dict): dictionary to construct and
+            config norm layer.  Defaults to
+            ``norm_cfg=dict(type='GN', num_groups=32, requires_grad=True)``.
+        cls_predictor_cfg (:obj:`ConfigDict` or dict): dictionary to construct and
+            config conv_cls. Defaults to None.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict]): Initialization config dict.
+
+    Example:
+        >>> self = FCOSHead(11, 7)
+        >>> feats = [torch.rand(1, 7, s, s) for s in [4, 8, 16, 32, 64]]
+        >>> cls_score, bbox_pred, centerness = self.forward(feats)
+        >>> assert len(cls_score) == len(self.scales)
+    """  # noqa: E501
+
+    def __init__(self,
+                 num_classes: int,
+                 in_channels: int,
+                 regress_ranges: RangeType = ((-1, 64), (64, 128), (128, 256),
+                                              (256, 512), (512, INF)),
+                 center_sampling: bool = False,
+                 center_sample_radius: float = 1.5,
+                 norm_on_bbox: bool = False,
+                 centerness_on_reg: bool = False,
+                 loss_cls: ConfigType = dict(
+                     type='FocalLoss',
+                     use_sigmoid=True,
+                     gamma=2.0,
+                     alpha=0.25,
+                     loss_weight=1.0),
+                 loss_bbox: ConfigType = dict(type='IoULoss', loss_weight=1.0),
+                 loss_centerness: ConfigType = dict(
+                     type='CrossEntropyLoss',
+                     use_sigmoid=True,
+                     loss_weight=1.0),
+                 norm_cfg: ConfigType = dict(
+                     type='GN', num_groups=32, requires_grad=True),
+                 cls_predictor_cfg=None,
+                 init_cfg: MultiConfig = dict(
+                     type='Normal',
+                     layer='Conv2d',
+                     std=0.01,
+                     override=dict(
+                         type='Normal',
+                         name='conv_cls',
+                         std=0.01,
+                         bias_prob=0.01)),
+                 **kwargs) -> None:
+        self.regress_ranges = regress_ranges
+        self.center_sampling = center_sampling
+        self.center_sample_radius = center_sample_radius
+        self.norm_on_bbox = norm_on_bbox
+        self.centerness_on_reg = centerness_on_reg
+        self.cls_predictor_cfg = cls_predictor_cfg
+        super().__init__(
+            num_classes=num_classes,
+            in_channels=in_channels,
+            loss_cls=loss_cls,
+            loss_bbox=loss_bbox,
+            norm_cfg=norm_cfg,
+            init_cfg=init_cfg,
+            **kwargs)
+        self.loss_centerness = MODELS.build(loss_centerness)
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        super()._init_layers()
+        self.conv_centerness = nn.Conv2d(self.feat_channels, 1, 3, padding=1)
+        self.scales = nn.ModuleList([Scale(1.0) for _ in self.strides])
+        if self.cls_predictor_cfg is not None:
+            self.cls_predictor_cfg.pop('type')
+            self.conv_cls = NormedConv2d(
+                self.feat_channels,
+                self.cls_out_channels,
+                1,
+                padding=0,
+                **self.cls_predictor_cfg)
+
+    def forward(
+            self, x: Tuple[Tensor]
+    ) -> Tuple[List[Tensor], List[Tensor], List[Tensor]]:
+        """Forward features from the upstream network.
+
+        Args:
+            feats (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple: A tuple of each level outputs.
+
+            - cls_scores (list[Tensor]): Box scores for each scale level, \
+            each is a 4D-tensor, the channel number is \
+            num_points * num_classes.
+            - bbox_preds (list[Tensor]): Box energies / deltas for each \
+            scale level, each is a 4D-tensor, the channel number is \
+            num_points * 4.
+            - centernesses (list[Tensor]): centerness for each scale level, \
+            each is a 4D-tensor, the channel number is num_points * 1.
+        """
+        return multi_apply(self.forward_single, x, self.scales, self.strides)
+
+    def forward_single(self, x: Tensor, scale: Scale,
+                       stride: int) -> Tuple[Tensor, Tensor, Tensor]:
+        """Forward features of a single scale level.
+
+        Args:
+            x (Tensor): FPN feature maps of the specified stride.
+            scale (:obj:`mmcv.cnn.Scale`): Learnable scale module to resize
+                the bbox prediction.
+            stride (int): The corresponding stride for feature maps, only
+                used to normalize the bbox prediction when self.norm_on_bbox
+                is True.
+
+        Returns:
+            tuple: scores for each class, bbox predictions and centerness
+            predictions of input feature maps.
+        """
+        cls_score, bbox_pred, cls_feat, reg_feat = super().forward_single(x)
+        if self.centerness_on_reg:
+            centerness = self.conv_centerness(reg_feat)
+        else:
+            centerness = self.conv_centerness(cls_feat)
+        # scale the bbox_pred of different level
+        # float to avoid overflow when enabling FP16
+        bbox_pred = scale(bbox_pred).float()
+        if self.norm_on_bbox:
+            # bbox_pred needed for gradient computation has been modified
+            # by F.relu(bbox_pred) when run with PyTorch 1.10. So replace
+            # F.relu(bbox_pred) with bbox_pred.clamp(min=0)
+            bbox_pred = bbox_pred.clamp(min=0)
+            if not self.training:
+                bbox_pred *= stride
+        else:
+            bbox_pred = bbox_pred.exp()
+        return cls_score, bbox_pred, centerness
+
+    def loss_by_feat(
+        self,
+        cls_scores: List[Tensor],
+        bbox_preds: List[Tensor],
+        centernesses: List[Tensor],
+        batch_gt_instances: InstanceList,
+        batch_img_metas: List[dict],
+        batch_gt_instances_ignore: OptInstanceList = None
+    ) -> Dict[str, Tensor]:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level,
+                each is a 4D-tensor, the channel number is
+                num_points * num_classes.
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level, each is a 4D-tensor, the channel number is
+                num_points * 4.
+            centernesses (list[Tensor]): centerness for each scale level, each
+                is a 4D-tensor, the channel number is num_points * 1.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], Optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        assert len(cls_scores) == len(bbox_preds) == len(centernesses)
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        all_level_points = self.prior_generator.grid_priors(
+            featmap_sizes,
+            dtype=bbox_preds[0].dtype,
+            device=bbox_preds[0].device)
+        labels, bbox_targets = self.get_targets(all_level_points,
+                                                batch_gt_instances)
+
+        num_imgs = cls_scores[0].size(0)
+        # flatten cls_scores, bbox_preds and centerness
+        flatten_cls_scores = [
+            cls_score.permute(0, 2, 3, 1).reshape(-1, self.cls_out_channels)
+            for cls_score in cls_scores
+        ]
+        flatten_bbox_preds = [
+            bbox_pred.permute(0, 2, 3, 1).reshape(-1, 4)
+            for bbox_pred in bbox_preds
+        ]
+        flatten_centerness = [
+            centerness.permute(0, 2, 3, 1).reshape(-1)
+            for centerness in centernesses
+        ]
+        flatten_cls_scores = torch.cat(flatten_cls_scores)
+        flatten_bbox_preds = torch.cat(flatten_bbox_preds)
+        flatten_centerness = torch.cat(flatten_centerness)
+        flatten_labels = torch.cat(labels)
+        flatten_bbox_targets = torch.cat(bbox_targets)
+        # repeat points to align with bbox_preds
+        flatten_points = torch.cat(
+            [points.repeat(num_imgs, 1) for points in all_level_points])
+
+        losses = dict()
+
+        # FG cat_id: [0, num_classes -1], BG cat_id: num_classes
+        bg_class_ind = self.num_classes
+        pos_inds = ((flatten_labels >= 0)
+                    & (flatten_labels < bg_class_ind)).nonzero().reshape(-1)
+        num_pos = torch.tensor(
+            len(pos_inds), dtype=torch.float, device=bbox_preds[0].device)
+        num_pos = max(reduce_mean(num_pos), 1.0)
+        loss_cls = self.loss_cls(
+            flatten_cls_scores, flatten_labels, avg_factor=num_pos)
+
+        if getattr(self.loss_cls, 'custom_accuracy', False):
+            acc = self.loss_cls.get_accuracy(flatten_cls_scores,
+                                             flatten_labels)
+            losses.update(acc)
+
+        pos_bbox_preds = flatten_bbox_preds[pos_inds]
+        pos_centerness = flatten_centerness[pos_inds]
+        pos_bbox_targets = flatten_bbox_targets[pos_inds]
+        pos_centerness_targets = self.centerness_target(pos_bbox_targets)
+        # centerness weighted iou loss
+        centerness_denorm = max(
+            reduce_mean(pos_centerness_targets.sum().detach()), 1e-6)
+
+        if len(pos_inds) > 0:
+            pos_points = flatten_points[pos_inds]
+            pos_decoded_bbox_preds = self.bbox_coder.decode(
+                pos_points, pos_bbox_preds)
+            pos_decoded_target_preds = self.bbox_coder.decode(
+                pos_points, pos_bbox_targets)
+            loss_bbox = self.loss_bbox(
+                pos_decoded_bbox_preds,
+                pos_decoded_target_preds,
+                weight=pos_centerness_targets,
+                avg_factor=centerness_denorm)
+            loss_centerness = self.loss_centerness(
+                pos_centerness, pos_centerness_targets, avg_factor=num_pos)
+        else:
+            loss_bbox = pos_bbox_preds.sum()
+            loss_centerness = pos_centerness.sum()
+
+        losses['loss_cls'] = loss_cls
+        losses['loss_bbox'] = loss_bbox
+        losses['loss_centerness'] = loss_centerness
+
+        return losses
+
+    def get_targets(
+            self, points: List[Tensor], batch_gt_instances: InstanceList
+    ) -> Tuple[List[Tensor], List[Tensor]]:
+        """Compute regression, classification and centerness targets for points
+        in multiple images.
+
+        Args:
+            points (list[Tensor]): Points of each fpn level, each has shape
+                (num_points, 2).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+
+        Returns:
+            tuple: Targets of each level.
+
+            - concat_lvl_labels (list[Tensor]): Labels of each level.
+            - concat_lvl_bbox_targets (list[Tensor]): BBox targets of each \
+            level.
+        """
+        assert len(points) == len(self.regress_ranges)
+        num_levels = len(points)
+        # expand regress ranges to align with points
+        expanded_regress_ranges = [
+            points[i].new_tensor(self.regress_ranges[i])[None].expand_as(
+                points[i]) for i in range(num_levels)
+        ]
+        # concat all levels points and regress ranges
+        concat_regress_ranges = torch.cat(expanded_regress_ranges, dim=0)
+        concat_points = torch.cat(points, dim=0)
+
+        # the number of points per img, per lvl
+        num_points = [center.size(0) for center in points]
+
+        # get labels and bbox_targets of each image
+        labels_list, bbox_targets_list = multi_apply(
+            self._get_targets_single,
+            batch_gt_instances,
+            points=concat_points,
+            regress_ranges=concat_regress_ranges,
+            num_points_per_lvl=num_points)
+
+        # split to per img, per level
+        labels_list = [labels.split(num_points, 0) for labels in labels_list]
+        bbox_targets_list = [
+            bbox_targets.split(num_points, 0)
+            for bbox_targets in bbox_targets_list
+        ]
+
+        # concat per level image
+        concat_lvl_labels = []
+        concat_lvl_bbox_targets = []
+        for i in range(num_levels):
+            concat_lvl_labels.append(
+                torch.cat([labels[i] for labels in labels_list]))
+            bbox_targets = torch.cat(
+                [bbox_targets[i] for bbox_targets in bbox_targets_list])
+            if self.norm_on_bbox:
+                bbox_targets = bbox_targets / self.strides[i]
+            concat_lvl_bbox_targets.append(bbox_targets)
+        return concat_lvl_labels, concat_lvl_bbox_targets
+
+    def _get_targets_single(
+            self, gt_instances: InstanceData, points: Tensor,
+            regress_ranges: Tensor,
+            num_points_per_lvl: List[int]) -> Tuple[Tensor, Tensor]:
+        """Compute regression and classification targets for a single image."""
+        num_points = points.size(0)
+        num_gts = len(gt_instances)
+        gt_bboxes = gt_instances.bboxes
+        gt_labels = gt_instances.labels
+
+        if num_gts == 0:
+            return gt_labels.new_full((num_points,), self.num_classes), \
+                   gt_bboxes.new_zeros((num_points, 4))
+
+        areas = (gt_bboxes[:, 2] - gt_bboxes[:, 0]) * (
+            gt_bboxes[:, 3] - gt_bboxes[:, 1])
+        # TODO: figure out why these two are different
+        # areas = areas[None].expand(num_points, num_gts)
+        areas = areas[None].repeat(num_points, 1)
+        regress_ranges = regress_ranges[:, None, :].expand(
+            num_points, num_gts, 2)
+        gt_bboxes = gt_bboxes[None].expand(num_points, num_gts, 4)
+        xs, ys = points[:, 0], points[:, 1]
+        xs = xs[:, None].expand(num_points, num_gts)
+        ys = ys[:, None].expand(num_points, num_gts)
+
+        left = xs - gt_bboxes[..., 0]
+        right = gt_bboxes[..., 2] - xs
+        top = ys - gt_bboxes[..., 1]
+        bottom = gt_bboxes[..., 3] - ys
+        bbox_targets = torch.stack((left, top, right, bottom), -1)
+
+        if self.center_sampling:
+            # condition1: inside a `center bbox`
+            radius = self.center_sample_radius
+            center_xs = (gt_bboxes[..., 0] + gt_bboxes[..., 2]) / 2
+            center_ys = (gt_bboxes[..., 1] + gt_bboxes[..., 3]) / 2
+            center_gts = torch.zeros_like(gt_bboxes)
+            stride = center_xs.new_zeros(center_xs.shape)
+
+            # project the points on current lvl back to the `original` sizes
+            lvl_begin = 0
+            for lvl_idx, num_points_lvl in enumerate(num_points_per_lvl):
+                lvl_end = lvl_begin + num_points_lvl
+                stride[lvl_begin:lvl_end] = self.strides[lvl_idx] * radius
+                lvl_begin = lvl_end
+
+            x_mins = center_xs - stride
+            y_mins = center_ys - stride
+            x_maxs = center_xs + stride
+            y_maxs = center_ys + stride
+            center_gts[..., 0] = torch.where(x_mins > gt_bboxes[..., 0],
+                                             x_mins, gt_bboxes[..., 0])
+            center_gts[..., 1] = torch.where(y_mins > gt_bboxes[..., 1],
+                                             y_mins, gt_bboxes[..., 1])
+            center_gts[..., 2] = torch.where(x_maxs > gt_bboxes[..., 2],
+                                             gt_bboxes[..., 2], x_maxs)
+            center_gts[..., 3] = torch.where(y_maxs > gt_bboxes[..., 3],
+                                             gt_bboxes[..., 3], y_maxs)
+
+            cb_dist_left = xs - center_gts[..., 0]
+            cb_dist_right = center_gts[..., 2] - xs
+            cb_dist_top = ys - center_gts[..., 1]
+            cb_dist_bottom = center_gts[..., 3] - ys
+            center_bbox = torch.stack(
+                (cb_dist_left, cb_dist_top, cb_dist_right, cb_dist_bottom), -1)
+            inside_gt_bbox_mask = center_bbox.min(-1)[0] > 0
+        else:
+            # condition1: inside a gt bbox
+            inside_gt_bbox_mask = bbox_targets.min(-1)[0] > 0
+
+        # condition2: limit the regression range for each location
+        max_regress_distance = bbox_targets.max(-1)[0]
+        inside_regress_range = (
+            (max_regress_distance >= regress_ranges[..., 0])
+            & (max_regress_distance <= regress_ranges[..., 1]))
+
+        # if there are still more than one objects for a location,
+        # we choose the one with minimal area
+        areas[inside_gt_bbox_mask == 0] = INF
+        areas[inside_regress_range == 0] = INF
+        min_area, min_area_inds = areas.min(dim=1)
+
+        labels = gt_labels[min_area_inds]
+        labels[min_area == INF] = self.num_classes  # set as BG
+        bbox_targets = bbox_targets[range(num_points), min_area_inds]
+
+        return labels, bbox_targets
+
+    def centerness_target(self, pos_bbox_targets: Tensor) -> Tensor:
+        """Compute centerness targets.
+
+        Args:
+            pos_bbox_targets (Tensor): BBox targets of positive bboxes in shape
+                (num_pos, 4)
+
+        Returns:
+            Tensor: Centerness target.
+        """
+        # only calculate pos centerness targets, otherwise there may be nan
+        left_right = pos_bbox_targets[:, [0, 2]]
+        top_bottom = pos_bbox_targets[:, [1, 3]]
+        if len(left_right) == 0:
+            centerness_targets = left_right[..., 0]
+        else:
+            centerness_targets = (
+                left_right.min(dim=-1)[0] / left_right.max(dim=-1)[0]) * (
+                    top_bottom.min(dim=-1)[0] / top_bottom.max(dim=-1)[0])
+        return torch.sqrt(centerness_targets)
diff --git a/mmdetection/mmdet/models/dense_heads/fovea_head.py b/mmdetection/mmdet/models/dense_heads/fovea_head.py
new file mode 100644
index 00000000..89353dea
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/fovea_head.py
@@ -0,0 +1,509 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, List, Optional, Tuple
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmcv.ops import DeformConv2d
+from mmengine.config import ConfigDict
+from mmengine.model import BaseModule
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import InstanceList, OptInstanceList, OptMultiConfig
+from ..utils import filter_scores_and_topk, multi_apply
+from .anchor_free_head import AnchorFreeHead
+
+INF = 1e8
+
+
+class FeatureAlign(BaseModule):
+    """Feature Align Module.
+
+    Feature Align Module is implemented based on DCN v1.
+    It uses anchor shape prediction rather than feature map to
+    predict offsets of deform conv layer.
+
+    Args:
+        in_channels (int): Number of channels in the input feature map.
+        out_channels (int): Number of channels in the output feature map.
+        kernel_size (int): Size of the convolution kernel.
+            ``norm_cfg=dict(type='GN', num_groups=32, requires_grad=True)``.
+        deform_groups: (int): Group number of DCN in
+            FeatureAdaption module.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict], optional): Initialization config dict.
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel_size: int = 3,
+        deform_groups: int = 4,
+        init_cfg: OptMultiConfig = dict(
+            type='Normal',
+            layer='Conv2d',
+            std=0.1,
+            override=dict(type='Normal', name='conv_adaption', std=0.01))
+    ) -> None:
+        super().__init__(init_cfg=init_cfg)
+        offset_channels = kernel_size * kernel_size * 2
+        self.conv_offset = nn.Conv2d(
+            4, deform_groups * offset_channels, 1, bias=False)
+        self.conv_adaption = DeformConv2d(
+            in_channels,
+            out_channels,
+            kernel_size=kernel_size,
+            padding=(kernel_size - 1) // 2,
+            deform_groups=deform_groups)
+        self.relu = nn.ReLU(inplace=True)
+
+    def forward(self, x: Tensor, shape: Tensor) -> Tensor:
+        """Forward function of feature align module.
+
+        Args:
+            x (Tensor): Features from the upstream network.
+            shape (Tensor): Exponential of bbox predictions.
+
+        Returns:
+            x (Tensor): The aligned features.
+        """
+        offset = self.conv_offset(shape)
+        x = self.relu(self.conv_adaption(x, offset))
+        return x
+
+
+@MODELS.register_module()
+class FoveaHead(AnchorFreeHead):
+    """Detection Head of `FoveaBox: Beyond Anchor-based Object Detector.
+
+    `_.
+
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (int): Number of channels in the input feature map.
+        base_edge_list (list[int]): List of edges.
+        scale_ranges (list[tuple]): Range of scales.
+        sigma (float): Super parameter of ``FoveaHead``.
+        with_deform (bool):  Whether use deform conv.
+        deform_groups (int): Deformable conv group size.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict], optional): Initialization config dict.
+    """
+
+    def __init__(self,
+                 num_classes: int,
+                 in_channels: int,
+                 base_edge_list: List[int] = (16, 32, 64, 128, 256),
+                 scale_ranges: List[tuple] = ((8, 32), (16, 64), (32, 128),
+                                              (64, 256), (128, 512)),
+                 sigma: float = 0.4,
+                 with_deform: bool = False,
+                 deform_groups: int = 4,
+                 init_cfg: OptMultiConfig = dict(
+                     type='Normal',
+                     layer='Conv2d',
+                     std=0.01,
+                     override=dict(
+                         type='Normal',
+                         name='conv_cls',
+                         std=0.01,
+                         bias_prob=0.01)),
+                 **kwargs) -> None:
+        self.base_edge_list = base_edge_list
+        self.scale_ranges = scale_ranges
+        self.sigma = sigma
+        self.with_deform = with_deform
+        self.deform_groups = deform_groups
+        super().__init__(
+            num_classes=num_classes,
+            in_channels=in_channels,
+            init_cfg=init_cfg,
+            **kwargs)
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        # box branch
+        super()._init_reg_convs()
+        self.conv_reg = nn.Conv2d(self.feat_channels, 4, 3, padding=1)
+
+        # cls branch
+        if not self.with_deform:
+            super()._init_cls_convs()
+            self.conv_cls = nn.Conv2d(
+                self.feat_channels, self.cls_out_channels, 3, padding=1)
+        else:
+            self.cls_convs = nn.ModuleList()
+            self.cls_convs.append(
+                ConvModule(
+                    self.feat_channels, (self.feat_channels * 4),
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg,
+                    bias=self.norm_cfg is None))
+            self.cls_convs.append(
+                ConvModule((self.feat_channels * 4), (self.feat_channels * 4),
+                           1,
+                           stride=1,
+                           padding=0,
+                           conv_cfg=self.conv_cfg,
+                           norm_cfg=self.norm_cfg,
+                           bias=self.norm_cfg is None))
+            self.feature_adaption = FeatureAlign(
+                self.feat_channels,
+                self.feat_channels,
+                kernel_size=3,
+                deform_groups=self.deform_groups)
+            self.conv_cls = nn.Conv2d(
+                int(self.feat_channels * 4),
+                self.cls_out_channels,
+                3,
+                padding=1)
+
+    def forward_single(self, x: Tensor) -> Tuple[Tensor, Tensor]:
+        """Forward features of a single scale level.
+
+        Args:
+            x (Tensor): FPN feature maps of the specified stride.
+
+        Returns:
+            tuple: scores for each class and bbox predictions of input
+            feature maps.
+        """
+        cls_feat = x
+        reg_feat = x
+        for reg_layer in self.reg_convs:
+            reg_feat = reg_layer(reg_feat)
+        bbox_pred = self.conv_reg(reg_feat)
+        if self.with_deform:
+            cls_feat = self.feature_adaption(cls_feat, bbox_pred.exp())
+        for cls_layer in self.cls_convs:
+            cls_feat = cls_layer(cls_feat)
+        cls_score = self.conv_cls(cls_feat)
+        return cls_score, bbox_pred
+
+    def loss_by_feat(
+        self,
+        cls_scores: List[Tensor],
+        bbox_preds: List[Tensor],
+        batch_gt_instances: InstanceList,
+        batch_img_metas: List[dict],
+        batch_gt_instances_ignore: OptInstanceList = None
+    ) -> Dict[str, Tensor]:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level,
+                each is a 4D-tensor, the channel number is
+                num_priors * num_classes.
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level, each is a 4D-tensor, the channel number is
+                num_priors * 4.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], Optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        assert len(cls_scores) == len(bbox_preds)
+
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        priors = self.prior_generator.grid_priors(
+            featmap_sizes,
+            dtype=bbox_preds[0].dtype,
+            device=bbox_preds[0].device)
+        num_imgs = cls_scores[0].size(0)
+        flatten_cls_scores = [
+            cls_score.permute(0, 2, 3, 1).reshape(-1, self.cls_out_channels)
+            for cls_score in cls_scores
+        ]
+        flatten_bbox_preds = [
+            bbox_pred.permute(0, 2, 3, 1).reshape(-1, 4)
+            for bbox_pred in bbox_preds
+        ]
+        flatten_cls_scores = torch.cat(flatten_cls_scores)
+        flatten_bbox_preds = torch.cat(flatten_bbox_preds)
+        flatten_labels, flatten_bbox_targets = self.get_targets(
+            batch_gt_instances, featmap_sizes, priors)
+
+        # FG cat_id: [0, num_classes -1], BG cat_id: num_classes
+        pos_inds = ((flatten_labels >= 0)
+                    & (flatten_labels < self.num_classes)).nonzero().view(-1)
+        num_pos = len(pos_inds)
+
+        loss_cls = self.loss_cls(
+            flatten_cls_scores, flatten_labels, avg_factor=num_pos + num_imgs)
+        if num_pos > 0:
+            pos_bbox_preds = flatten_bbox_preds[pos_inds]
+            pos_bbox_targets = flatten_bbox_targets[pos_inds]
+            pos_weights = pos_bbox_targets.new_ones(pos_bbox_targets.size())
+            loss_bbox = self.loss_bbox(
+                pos_bbox_preds,
+                pos_bbox_targets,
+                pos_weights,
+                avg_factor=num_pos)
+        else:
+            loss_bbox = torch.tensor(
+                0,
+                dtype=flatten_bbox_preds.dtype,
+                device=flatten_bbox_preds.device)
+        return dict(loss_cls=loss_cls, loss_bbox=loss_bbox)
+
+    def get_targets(
+            self, batch_gt_instances: InstanceList, featmap_sizes: List[tuple],
+            priors_list: List[Tensor]) -> Tuple[List[Tensor], List[Tensor]]:
+        """Compute regression and classification for priors in multiple images.
+
+        Args:
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            featmap_sizes (list[tuple]): Size tuple of feature maps.
+            priors_list (list[Tensor]): Priors list of each fpn level, each has
+                shape (num_priors, 2).
+
+        Returns:
+            tuple: Targets of each level.
+
+            - flatten_labels (list[Tensor]): Labels of each level.
+            - flatten_bbox_targets (list[Tensor]): BBox targets of each
+              level.
+        """
+        label_list, bbox_target_list = multi_apply(
+            self._get_targets_single,
+            batch_gt_instances,
+            featmap_size_list=featmap_sizes,
+            priors_list=priors_list)
+        flatten_labels = [
+            torch.cat([
+                labels_level_img.flatten() for labels_level_img in labels_level
+            ]) for labels_level in zip(*label_list)
+        ]
+        flatten_bbox_targets = [
+            torch.cat([
+                bbox_targets_level_img.reshape(-1, 4)
+                for bbox_targets_level_img in bbox_targets_level
+            ]) for bbox_targets_level in zip(*bbox_target_list)
+        ]
+        flatten_labels = torch.cat(flatten_labels)
+        flatten_bbox_targets = torch.cat(flatten_bbox_targets)
+        return flatten_labels, flatten_bbox_targets
+
+    def _get_targets_single(self,
+                            gt_instances: InstanceData,
+                            featmap_size_list: List[tuple] = None,
+                            priors_list: List[Tensor] = None) -> tuple:
+        """Compute regression and classification targets for a single image.
+
+        Args:
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            featmap_size_list (list[tuple]): Size tuple of feature maps.
+            priors_list (list[Tensor]): Priors of each fpn level, each has
+                shape (num_priors, 2).
+
+        Returns:
+            tuple:
+
+            - label_list (list[Tensor]): Labels of all anchors in the image.
+            - box_target_list (list[Tensor]): BBox targets of all anchors in
+              the image.
+        """
+        gt_bboxes_raw = gt_instances.bboxes
+        gt_labels_raw = gt_instances.labels
+        gt_areas = torch.sqrt((gt_bboxes_raw[:, 2] - gt_bboxes_raw[:, 0]) *
+                              (gt_bboxes_raw[:, 3] - gt_bboxes_raw[:, 1]))
+        label_list = []
+        bbox_target_list = []
+        # for each pyramid, find the cls and box target
+        for base_len, (lower_bound, upper_bound), stride, featmap_size, \
+            priors in zip(self.base_edge_list, self.scale_ranges,
+                          self.strides, featmap_size_list, priors_list):
+            # FG cat_id: [0, num_classes -1], BG cat_id: num_classes
+            priors = priors.view(*featmap_size, 2)
+            x, y = priors[..., 0], priors[..., 1]
+            labels = gt_labels_raw.new_full(featmap_size, self.num_classes)
+            bbox_targets = gt_bboxes_raw.new_ones(featmap_size[0],
+                                                  featmap_size[1], 4)
+            # scale assignment
+            hit_indices = ((gt_areas >= lower_bound) &
+                           (gt_areas <= upper_bound)).nonzero().flatten()
+            if len(hit_indices) == 0:
+                label_list.append(labels)
+                bbox_target_list.append(torch.log(bbox_targets))
+                continue
+            _, hit_index_order = torch.sort(-gt_areas[hit_indices])
+            hit_indices = hit_indices[hit_index_order]
+            gt_bboxes = gt_bboxes_raw[hit_indices, :] / stride
+            gt_labels = gt_labels_raw[hit_indices]
+            half_w = 0.5 * (gt_bboxes[:, 2] - gt_bboxes[:, 0])
+            half_h = 0.5 * (gt_bboxes[:, 3] - gt_bboxes[:, 1])
+            # valid fovea area: left, right, top, down
+            pos_left = torch.ceil(
+                gt_bboxes[:, 0] + (1 - self.sigma) * half_w - 0.5).long(). \
+                clamp(0, featmap_size[1] - 1)
+            pos_right = torch.floor(
+                gt_bboxes[:, 0] + (1 + self.sigma) * half_w - 0.5).long(). \
+                clamp(0, featmap_size[1] - 1)
+            pos_top = torch.ceil(
+                gt_bboxes[:, 1] + (1 - self.sigma) * half_h - 0.5).long(). \
+                clamp(0, featmap_size[0] - 1)
+            pos_down = torch.floor(
+                gt_bboxes[:, 1] + (1 + self.sigma) * half_h - 0.5).long(). \
+                clamp(0, featmap_size[0] - 1)
+            for px1, py1, px2, py2, label, (gt_x1, gt_y1, gt_x2, gt_y2) in \
+                    zip(pos_left, pos_top, pos_right, pos_down, gt_labels,
+                        gt_bboxes_raw[hit_indices, :]):
+                labels[py1:py2 + 1, px1:px2 + 1] = label
+                bbox_targets[py1:py2 + 1, px1:px2 + 1, 0] = \
+                    (x[py1:py2 + 1, px1:px2 + 1] - gt_x1) / base_len
+                bbox_targets[py1:py2 + 1, px1:px2 + 1, 1] = \
+                    (y[py1:py2 + 1, px1:px2 + 1] - gt_y1) / base_len
+                bbox_targets[py1:py2 + 1, px1:px2 + 1, 2] = \
+                    (gt_x2 - x[py1:py2 + 1, px1:px2 + 1]) / base_len
+                bbox_targets[py1:py2 + 1, px1:px2 + 1, 3] = \
+                    (gt_y2 - y[py1:py2 + 1, px1:px2 + 1]) / base_len
+            bbox_targets = bbox_targets.clamp(min=1. / 16, max=16.)
+            label_list.append(labels)
+            bbox_target_list.append(torch.log(bbox_targets))
+        return label_list, bbox_target_list
+
+    # Same as base_dense_head/_predict_by_feat_single except self._bbox_decode
+    def _predict_by_feat_single(self,
+                                cls_score_list: List[Tensor],
+                                bbox_pred_list: List[Tensor],
+                                score_factor_list: List[Tensor],
+                                mlvl_priors: List[Tensor],
+                                img_meta: dict,
+                                cfg: Optional[ConfigDict] = None,
+                                rescale: bool = False,
+                                with_nms: bool = True) -> InstanceData:
+        """Transform a single image's features extracted from the head into
+        bbox results.
+
+        Args:
+            cls_score_list (list[Tensor]): Box scores from all scale
+                levels of a single image, each item has shape
+                (num_priors * num_classes, H, W).
+            bbox_pred_list (list[Tensor]): Box energies / deltas from
+                all scale levels of a single image, each item has shape
+                (num_priors * 4, H, W).
+            score_factor_list (list[Tensor]): Score factor from all scale
+                levels of a single image, each item has shape
+                (num_priors * 1, H, W).
+            mlvl_priors (list[Tensor]): Each element in the list is
+                the priors of a single level in feature pyramid, has shape
+                (num_priors, 2).
+            img_meta (dict): Image meta info.
+            cfg (ConfigDict, optional): Test / postprocessing
+                configuration, if None, test_cfg would be used.
+                Defaults to None.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            with_nms (bool): If True, do nms before return boxes.
+                Defaults to True.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+            - scores (Tensor): Classification scores, has a shape
+              (num_instance, )
+            - labels (Tensor): Labels of bboxes, has a shape
+              (num_instances, ).
+            - bboxes (Tensor): Has a shape (num_instances, 4),
+              the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        cfg = self.test_cfg if cfg is None else cfg
+        assert len(cls_score_list) == len(bbox_pred_list)
+        img_shape = img_meta['img_shape']
+        nms_pre = cfg.get('nms_pre', -1)
+
+        mlvl_bboxes = []
+        mlvl_scores = []
+        mlvl_labels = []
+        for level_idx, (cls_score, bbox_pred, stride, base_len, priors) in \
+                enumerate(zip(cls_score_list, bbox_pred_list, self.strides,
+                              self.base_edge_list, mlvl_priors)):
+            assert cls_score.size()[-2:] == bbox_pred.size()[-2:]
+            bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, 4)
+
+            scores = cls_score.permute(1, 2, 0).reshape(
+                -1, self.cls_out_channels).sigmoid()
+
+            # After https://github.com/open-mmlab/mmdetection/pull/6268/,
+            # this operation keeps fewer bboxes under the same `nms_pre`.
+            # There is no difference in performance for most models. If you
+            # find a slight drop in performance, you can set a larger
+            # `nms_pre` than before.
+            results = filter_scores_and_topk(
+                scores, cfg.score_thr, nms_pre,
+                dict(bbox_pred=bbox_pred, priors=priors))
+            scores, labels, _, filtered_results = results
+
+            bbox_pred = filtered_results['bbox_pred']
+            priors = filtered_results['priors']
+
+            bboxes = self._bbox_decode(priors, bbox_pred, base_len, img_shape)
+
+            mlvl_bboxes.append(bboxes)
+            mlvl_scores.append(scores)
+            mlvl_labels.append(labels)
+
+        results = InstanceData()
+        results.bboxes = torch.cat(mlvl_bboxes)
+        results.scores = torch.cat(mlvl_scores)
+        results.labels = torch.cat(mlvl_labels)
+
+        return self._bbox_post_process(
+            results=results,
+            cfg=cfg,
+            rescale=rescale,
+            with_nms=with_nms,
+            img_meta=img_meta)
+
+    def _bbox_decode(self, priors: Tensor, bbox_pred: Tensor, base_len: int,
+                     max_shape: int) -> Tensor:
+        """Function to decode bbox.
+
+        Args:
+            priors (Tensor): Center proiors of an image, has shape
+                (num_instances, 2).
+            bbox_preds (Tensor): Box energies / deltas for all instances,
+                has shape (batch_size, num_instances, 4).
+            base_len (int): The base length.
+            max_shape (int): The max shape of bbox.
+
+        Returns:
+            Tensor: Decoded bboxes in (tl_x, tl_y, br_x, br_y) format. Has
+            shape (batch_size, num_instances, 4).
+        """
+        bbox_pred = bbox_pred.exp()
+
+        y = priors[:, 1]
+        x = priors[:, 0]
+        x1 = (x - base_len * bbox_pred[:, 0]). \
+            clamp(min=0, max=max_shape[1] - 1)
+        y1 = (y - base_len * bbox_pred[:, 1]). \
+            clamp(min=0, max=max_shape[0] - 1)
+        x2 = (x + base_len * bbox_pred[:, 2]). \
+            clamp(min=0, max=max_shape[1] - 1)
+        y2 = (y + base_len * bbox_pred[:, 3]). \
+            clamp(min=0, max=max_shape[0] - 1)
+        decoded_bboxes = torch.stack([x1, y1, x2, y2], -1)
+        return decoded_bboxes
diff --git a/mmdetection/mmdet/models/dense_heads/free_anchor_retina_head.py b/mmdetection/mmdet/models/dense_heads/free_anchor_retina_head.py
new file mode 100644
index 00000000..df6fb920
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/free_anchor_retina_head.py
@@ -0,0 +1,312 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List
+
+import torch
+import torch.nn.functional as F
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures.bbox import bbox_overlaps
+from mmdet.utils import InstanceList, OptConfigType, OptInstanceList
+from ..utils import multi_apply
+from .retina_head import RetinaHead
+
+EPS = 1e-12
+
+
+@MODELS.register_module()
+class FreeAnchorRetinaHead(RetinaHead):
+    """FreeAnchor RetinaHead used in https://arxiv.org/abs/1909.02466.
+
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (int): Number of channels in the input feature map.
+        stacked_convs (int): Number of conv layers in cls and reg tower.
+            Defaults to 4.
+        conv_cfg (:obj:`ConfigDict` or dict, optional): dictionary to
+            construct and config conv layer. Defaults to None.
+        norm_cfg (:obj:`ConfigDict` or dict, optional): dictionary to
+            construct and config norm layer. Defaults to
+            norm_cfg=dict(type='GN', num_groups=32, requires_grad=True).
+        pre_anchor_topk (int): Number of boxes that be token in each bag.
+            Defaults to 50
+        bbox_thr (float): The threshold of the saturated linear function.
+            It is usually the same with the IoU threshold used in NMS.
+            Defaults to 0.6.
+        gamma (float): Gamma parameter in focal loss. Defaults to 2.0.
+        alpha (float): Alpha parameter in focal loss. Defaults to 0.5.
+    """
+
+    def __init__(self,
+                 num_classes: int,
+                 in_channels: int,
+                 stacked_convs: int = 4,
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: OptConfigType = None,
+                 pre_anchor_topk: int = 50,
+                 bbox_thr: float = 0.6,
+                 gamma: float = 2.0,
+                 alpha: float = 0.5,
+                 **kwargs) -> None:
+        super().__init__(
+            num_classes=num_classes,
+            in_channels=in_channels,
+            stacked_convs=stacked_convs,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            **kwargs)
+
+        self.pre_anchor_topk = pre_anchor_topk
+        self.bbox_thr = bbox_thr
+        self.gamma = gamma
+        self.alpha = alpha
+
+    def loss_by_feat(
+            self,
+            cls_scores: List[Tensor],
+            bbox_preds: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> dict:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level
+                has shape (N, num_anchors * num_classes, H, W).
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level with shape (N, num_anchors * 4, H, W).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        assert len(featmap_sizes) == self.prior_generator.num_levels
+
+        device = cls_scores[0].device
+
+        anchor_list, _ = self.get_anchors(
+            featmap_sizes=featmap_sizes,
+            batch_img_metas=batch_img_metas,
+            device=device)
+        concat_anchor_list = [torch.cat(anchor) for anchor in anchor_list]
+
+        # concatenate each level
+        cls_scores = [
+            cls.permute(0, 2, 3,
+                        1).reshape(cls.size(0), -1, self.cls_out_channels)
+            for cls in cls_scores
+        ]
+        bbox_preds = [
+            bbox_pred.permute(0, 2, 3, 1).reshape(bbox_pred.size(0), -1, 4)
+            for bbox_pred in bbox_preds
+        ]
+        cls_scores = torch.cat(cls_scores, dim=1)
+        cls_probs = torch.sigmoid(cls_scores)
+        bbox_preds = torch.cat(bbox_preds, dim=1)
+
+        box_probs, positive_losses, num_pos_list = multi_apply(
+            self.positive_loss_single, cls_probs, bbox_preds,
+            concat_anchor_list, batch_gt_instances)
+
+        num_pos = sum(num_pos_list)
+        positive_loss = torch.cat(positive_losses).sum() / max(1, num_pos)
+
+        # box_prob: P{a_{j} \in A_{+}}
+        box_probs = torch.stack(box_probs, dim=0)
+
+        # negative_loss:
+        # \sum_{j}{ FL((1 - P{a_{j} \in A_{+}}) * (1 - P_{j}^{bg})) } / n||B||
+        negative_loss = self.negative_bag_loss(cls_probs, box_probs).sum() / \
+            max(1, num_pos * self.pre_anchor_topk)
+
+        # avoid the absence of gradients in regression subnet
+        # when no ground-truth in a batch
+        if num_pos == 0:
+            positive_loss = bbox_preds.sum() * 0
+
+        losses = {
+            'positive_bag_loss': positive_loss,
+            'negative_bag_loss': negative_loss
+        }
+        return losses
+
+    def positive_loss_single(self, cls_prob: Tensor, bbox_pred: Tensor,
+                             flat_anchors: Tensor,
+                             gt_instances: InstanceData) -> tuple:
+        """Compute positive loss.
+
+        Args:
+            cls_prob (Tensor): Classification probability of shape
+                (num_anchors, num_classes).
+            bbox_pred (Tensor): Box probability of shape (num_anchors, 4).
+            flat_anchors (Tensor): Multi-level anchors of the image, which are
+                concatenated into a single tensor of shape (num_anchors, 4)
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It should includes ``bboxes`` and ``labels``
+                attributes.
+
+        Returns:
+            tuple:
+
+                - box_prob (Tensor): Box probability of shape (num_anchors, 4).
+                - positive_loss (Tensor): Positive loss of shape (num_pos, ).
+                - num_pos (int): positive samples indexes.
+        """
+
+        gt_bboxes = gt_instances.bboxes
+        gt_labels = gt_instances.labels
+        with torch.no_grad():
+            if len(gt_bboxes) == 0:
+                image_box_prob = torch.zeros(
+                    flat_anchors.size(0),
+                    self.cls_out_channels).type_as(bbox_pred)
+            else:
+                # box_localization: a_{j}^{loc}, shape: [j, 4]
+                pred_boxes = self.bbox_coder.decode(flat_anchors, bbox_pred)
+
+                # object_box_iou: IoU_{ij}^{loc}, shape: [i, j]
+                object_box_iou = bbox_overlaps(gt_bboxes, pred_boxes)
+
+                # object_box_prob: P{a_{j} -> b_{i}}, shape: [i, j]
+                t1 = self.bbox_thr
+                t2 = object_box_iou.max(
+                    dim=1, keepdim=True).values.clamp(min=t1 + 1e-12)
+                object_box_prob = ((object_box_iou - t1) / (t2 - t1)).clamp(
+                    min=0, max=1)
+
+                # object_cls_box_prob: P{a_{j} -> b_{i}}, shape: [i, c, j]
+                num_obj = gt_labels.size(0)
+                indices = torch.stack(
+                    [torch.arange(num_obj).type_as(gt_labels), gt_labels],
+                    dim=0)
+                object_cls_box_prob = torch.sparse_coo_tensor(
+                    indices, object_box_prob)
+
+                # image_box_iou: P{a_{j} \in A_{+}}, shape: [c, j]
+                """
+                from "start" to "end" implement:
+                image_box_iou = torch.sparse.max(object_cls_box_prob,
+                                                 dim=0).t()
+
+                """
+                # start
+                box_cls_prob = torch.sparse.sum(
+                    object_cls_box_prob, dim=0).to_dense()
+
+                indices = torch.nonzero(box_cls_prob, as_tuple=False).t_()
+                if indices.numel() == 0:
+                    image_box_prob = torch.zeros(
+                        flat_anchors.size(0),
+                        self.cls_out_channels).type_as(object_box_prob)
+                else:
+                    nonzero_box_prob = torch.where(
+                        (gt_labels.unsqueeze(dim=-1) == indices[0]),
+                        object_box_prob[:, indices[1]],
+                        torch.tensor(
+                            [0]).type_as(object_box_prob)).max(dim=0).values
+
+                    # upmap to shape [j, c]
+                    image_box_prob = torch.sparse_coo_tensor(
+                        indices.flip([0]),
+                        nonzero_box_prob,
+                        size=(flat_anchors.size(0),
+                              self.cls_out_channels)).to_dense()
+                # end
+            box_prob = image_box_prob
+
+        # construct bags for objects
+        match_quality_matrix = bbox_overlaps(gt_bboxes, flat_anchors)
+        _, matched = torch.topk(
+            match_quality_matrix, self.pre_anchor_topk, dim=1, sorted=False)
+        del match_quality_matrix
+
+        # matched_cls_prob: P_{ij}^{cls}
+        matched_cls_prob = torch.gather(
+            cls_prob[matched], 2,
+            gt_labels.view(-1, 1, 1).repeat(1, self.pre_anchor_topk,
+                                            1)).squeeze(2)
+
+        # matched_box_prob: P_{ij}^{loc}
+        matched_anchors = flat_anchors[matched]
+        matched_object_targets = self.bbox_coder.encode(
+            matched_anchors,
+            gt_bboxes.unsqueeze(dim=1).expand_as(matched_anchors))
+        loss_bbox = self.loss_bbox(
+            bbox_pred[matched],
+            matched_object_targets,
+            reduction_override='none').sum(-1)
+        matched_box_prob = torch.exp(-loss_bbox)
+
+        # positive_losses: {-log( Mean-max(P_{ij}^{cls} * P_{ij}^{loc}) )}
+        num_pos = len(gt_bboxes)
+        positive_loss = self.positive_bag_loss(matched_cls_prob,
+                                               matched_box_prob)
+
+        return box_prob, positive_loss, num_pos
+
+    def positive_bag_loss(self, matched_cls_prob: Tensor,
+                          matched_box_prob: Tensor) -> Tensor:
+        """Compute positive bag loss.
+
+        :math:`-log( Mean-max(P_{ij}^{cls} * P_{ij}^{loc}) )`.
+
+        :math:`P_{ij}^{cls}`: matched_cls_prob, classification probability of matched samples.
+
+        :math:`P_{ij}^{loc}`: matched_box_prob, box probability of matched samples.
+
+        Args:
+            matched_cls_prob (Tensor): Classification probability of matched
+                samples in shape (num_gt, pre_anchor_topk).
+            matched_box_prob (Tensor): BBox probability of matched samples,
+                in shape (num_gt, pre_anchor_topk).
+
+        Returns:
+            Tensor: Positive bag loss in shape (num_gt,).
+        """  # noqa: E501, W605
+        # bag_prob = Mean-max(matched_prob)
+        matched_prob = matched_cls_prob * matched_box_prob
+        weight = 1 / torch.clamp(1 - matched_prob, 1e-12, None)
+        weight /= weight.sum(dim=1).unsqueeze(dim=-1)
+        bag_prob = (weight * matched_prob).sum(dim=1)
+        # positive_bag_loss = -self.alpha * log(bag_prob)
+        return self.alpha * F.binary_cross_entropy(
+            bag_prob, torch.ones_like(bag_prob), reduction='none')
+
+    def negative_bag_loss(self, cls_prob: Tensor, box_prob: Tensor) -> Tensor:
+        """Compute negative bag loss.
+
+        :math:`FL((1 - P_{a_{j} \in A_{+}}) * (1 - P_{j}^{bg}))`.
+
+        :math:`P_{a_{j} \in A_{+}}`: Box_probability of matched samples.
+
+        :math:`P_{j}^{bg}`: Classification probability of negative samples.
+
+        Args:
+            cls_prob (Tensor): Classification probability, in shape
+                (num_img, num_anchors, num_classes).
+            box_prob (Tensor): Box probability, in shape
+                (num_img, num_anchors, num_classes).
+
+        Returns:
+            Tensor: Negative bag loss in shape (num_img, num_anchors,
+            num_classes).
+        """  # noqa: E501, W605
+        prob = cls_prob * (1 - box_prob)
+        # There are some cases when neg_prob = 0.
+        # This will cause the neg_prob.log() to be inf without clamp.
+        prob = prob.clamp(min=EPS, max=1 - EPS)
+        negative_bag_loss = prob**self.gamma * F.binary_cross_entropy(
+            prob, torch.zeros_like(prob), reduction='none')
+        return (1 - self.alpha) * negative_bag_loss
diff --git a/mmdetection/mmdet/models/dense_heads/fsaf_head.py b/mmdetection/mmdet/models/dense_heads/fsaf_head.py
new file mode 100644
index 00000000..0a01c487
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/fsaf_head.py
@@ -0,0 +1,458 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+import torch
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import InstanceList, OptInstanceList, OptMultiConfig
+from ..losses.accuracy import accuracy
+from ..losses.utils import weight_reduce_loss
+from ..task_modules.prior_generators import anchor_inside_flags
+from ..utils import images_to_levels, multi_apply, unmap
+from .retina_head import RetinaHead
+
+
+@MODELS.register_module()
+class FSAFHead(RetinaHead):
+    """Anchor-free head used in `FSAF `_.
+
+    The head contains two subnetworks. The first classifies anchor boxes and
+    the second regresses deltas for the anchors (num_anchors is 1 for anchor-
+    free methods)
+
+    Args:
+        *args: Same as its base class in :class:`RetinaHead`
+        score_threshold (float, optional): The score_threshold to calculate
+            positive recall. If given, prediction scores lower than this value
+            is counted as incorrect prediction. Defaults to None.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict]): Initialization config dict.
+        **kwargs: Same as its base class in :class:`RetinaHead`
+
+    Example:
+        >>> import torch
+        >>> self = FSAFHead(11, 7)
+        >>> x = torch.rand(1, 7, 32, 32)
+        >>> cls_score, bbox_pred = self.forward_single(x)
+        >>> # Each anchor predicts a score for each class except background
+        >>> cls_per_anchor = cls_score.shape[1] / self.num_anchors
+        >>> box_per_anchor = bbox_pred.shape[1] / self.num_anchors
+        >>> assert cls_per_anchor == self.num_classes
+        >>> assert box_per_anchor == 4
+    """
+
+    def __init__(self,
+                 *args,
+                 score_threshold: Optional[float] = None,
+                 init_cfg: OptMultiConfig = None,
+                 **kwargs) -> None:
+        # The positive bias in self.retina_reg conv is to prevent predicted \
+        #  bbox with 0 area
+        if init_cfg is None:
+            init_cfg = dict(
+                type='Normal',
+                layer='Conv2d',
+                std=0.01,
+                override=[
+                    dict(
+                        type='Normal',
+                        name='retina_cls',
+                        std=0.01,
+                        bias_prob=0.01),
+                    dict(
+                        type='Normal', name='retina_reg', std=0.01, bias=0.25)
+                ])
+        super().__init__(*args, init_cfg=init_cfg, **kwargs)
+        self.score_threshold = score_threshold
+
+    def forward_single(self, x: Tensor) -> Tuple[Tensor, Tensor]:
+        """Forward feature map of a single scale level.
+
+        Args:
+            x (Tensor): Feature map of a single scale level.
+
+        Returns:
+            tuple[Tensor, Tensor]:
+
+            - cls_score (Tensor): Box scores for each scale level Has \
+            shape (N, num_points * num_classes, H, W).
+            - bbox_pred (Tensor): Box energies / deltas for each scale \
+            level with shape (N, num_points * 4, H, W).
+        """
+        cls_score, bbox_pred = super().forward_single(x)
+        # relu: TBLR encoder only accepts positive bbox_pred
+        return cls_score, self.relu(bbox_pred)
+
+    def _get_targets_single(self,
+                            flat_anchors: Tensor,
+                            valid_flags: Tensor,
+                            gt_instances: InstanceData,
+                            img_meta: dict,
+                            gt_instances_ignore: Optional[InstanceData] = None,
+                            unmap_outputs: bool = True) -> tuple:
+        """Compute regression and classification targets for anchors in a
+        single image.
+
+        Most of the codes are the same with the base class :obj: `AnchorHead`,
+        except that it also collects and returns the matched gt index in the
+        image (from 0 to num_gt-1). If the anchor bbox is not matched to any
+        gt, the corresponding value in pos_gt_inds is -1.
+
+        Args:
+            flat_anchors (Tensor): Multi-level anchors of the image, which are
+                concatenated into a single tensor of shape (num_anchors, 4)
+            valid_flags (Tensor): Multi level valid flags of the image,
+                which are concatenated into a single tensor of
+                    shape (num_anchors, ).
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It should includes ``bboxes`` and ``labels``
+                attributes.
+            img_meta (dict): Meta information for current image.
+            gt_instances_ignore (:obj:`InstanceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+            unmap_outputs (bool): Whether to map outputs back to the original
+                set of anchors.  Defaults to True.
+        """
+        inside_flags = anchor_inside_flags(flat_anchors, valid_flags,
+                                           img_meta['img_shape'][:2],
+                                           self.train_cfg['allowed_border'])
+        if not inside_flags.any():
+            raise ValueError(
+                'There is no valid anchor inside the image boundary. Please '
+                'check the image size and anchor sizes, or set '
+                '``allowed_border`` to -1 to skip the condition.')
+        # Assign gt and sample anchors
+        anchors = flat_anchors[inside_flags.type(torch.bool), :]
+
+        pred_instances = InstanceData(priors=anchors)
+        assign_result = self.assigner.assign(pred_instances, gt_instances,
+                                             gt_instances_ignore)
+        sampling_result = self.sampler.sample(assign_result, pred_instances,
+                                              gt_instances)
+
+        num_valid_anchors = anchors.shape[0]
+        bbox_targets = torch.zeros_like(anchors)
+        bbox_weights = torch.zeros_like(anchors)
+        labels = anchors.new_full((num_valid_anchors, ),
+                                  self.num_classes,
+                                  dtype=torch.long)
+        label_weights = anchors.new_zeros(
+            (num_valid_anchors, self.cls_out_channels), dtype=torch.float)
+        pos_gt_inds = anchors.new_full((num_valid_anchors, ),
+                                       -1,
+                                       dtype=torch.long)
+
+        pos_inds = sampling_result.pos_inds
+        neg_inds = sampling_result.neg_inds
+
+        if len(pos_inds) > 0:
+            if not self.reg_decoded_bbox:
+                pos_bbox_targets = self.bbox_coder.encode(
+                    sampling_result.pos_bboxes, sampling_result.pos_gt_bboxes)
+            else:
+                # When the regression loss (e.g. `IouLoss`, `GIouLoss`)
+                # is applied directly on the decoded bounding boxes, both
+                # the predicted boxes and regression targets should be with
+                # absolute coordinate format.
+                pos_bbox_targets = sampling_result.pos_gt_bboxes
+            bbox_targets[pos_inds, :] = pos_bbox_targets
+            bbox_weights[pos_inds, :] = 1.0
+            # The assigned gt_index for each anchor. (0-based)
+            pos_gt_inds[pos_inds] = sampling_result.pos_assigned_gt_inds
+            labels[pos_inds] = sampling_result.pos_gt_labels
+            if self.train_cfg['pos_weight'] <= 0:
+                label_weights[pos_inds] = 1.0
+            else:
+                label_weights[pos_inds] = self.train_cfg['pos_weight']
+
+        if len(neg_inds) > 0:
+            label_weights[neg_inds] = 1.0
+
+        # shadowed_labels is a tensor composed of tuples
+        #  (anchor_inds, class_label) that indicate those anchors lying in the
+        #  outer region of a gt or overlapped by another gt with a smaller
+        #  area.
+        #
+        # Therefore, only the shadowed labels are ignored for loss calculation.
+        # the key `shadowed_labels` is defined in :obj:`CenterRegionAssigner`
+        shadowed_labels = assign_result.get_extra_property('shadowed_labels')
+        if shadowed_labels is not None and shadowed_labels.numel():
+            if len(shadowed_labels.shape) == 2:
+                idx_, label_ = shadowed_labels[:, 0], shadowed_labels[:, 1]
+                assert (labels[idx_] != label_).all(), \
+                    'One label cannot be both positive and ignored'
+                label_weights[idx_, label_] = 0
+            else:
+                label_weights[shadowed_labels] = 0
+
+        # map up to original set of anchors
+        if unmap_outputs:
+            num_total_anchors = flat_anchors.size(0)
+            labels = unmap(
+                labels, num_total_anchors, inside_flags,
+                fill=self.num_classes)  # fill bg label
+            label_weights = unmap(label_weights, num_total_anchors,
+                                  inside_flags)
+            bbox_targets = unmap(bbox_targets, num_total_anchors, inside_flags)
+            bbox_weights = unmap(bbox_weights, num_total_anchors, inside_flags)
+            pos_gt_inds = unmap(
+                pos_gt_inds, num_total_anchors, inside_flags, fill=-1)
+
+        return (labels, label_weights, bbox_targets, bbox_weights, pos_inds,
+                neg_inds, sampling_result, pos_gt_inds)
+
+    def loss_by_feat(
+        self,
+        cls_scores: List[Tensor],
+        bbox_preds: List[Tensor],
+        batch_gt_instances: InstanceList,
+        batch_img_metas: List[dict],
+        batch_gt_instances_ignore: OptInstanceList = None
+    ) -> Dict[str, Tensor]:
+        """Compute loss of the head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level
+                Has shape (N, num_points * num_classes, H, W).
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level with shape (N, num_points * 4, H, W).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        for i in range(len(bbox_preds)):  # loop over fpn level
+            # avoid 0 area of the predicted bbox
+            bbox_preds[i] = bbox_preds[i].clamp(min=1e-4)
+        # TODO: It may directly use the base-class loss function.
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        assert len(featmap_sizes) == self.prior_generator.num_levels
+        batch_size = len(batch_img_metas)
+        device = cls_scores[0].device
+        anchor_list, valid_flag_list = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+        cls_reg_targets = self.get_targets(
+            anchor_list,
+            valid_flag_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore,
+            return_sampling_results=True)
+        (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,
+         avg_factor, sampling_results_list,
+         pos_assigned_gt_inds_list) = cls_reg_targets
+
+        num_gts = np.array(list(map(len, batch_gt_instances)))
+        # anchor number of multi levels
+        num_level_anchors = [anchors.size(0) for anchors in anchor_list[0]]
+        # concat all level anchors and flags to a single tensor
+        concat_anchor_list = []
+        for i in range(len(anchor_list)):
+            concat_anchor_list.append(torch.cat(anchor_list[i]))
+        all_anchor_list = images_to_levels(concat_anchor_list,
+                                           num_level_anchors)
+        losses_cls, losses_bbox = multi_apply(
+            self.loss_by_feat_single,
+            cls_scores,
+            bbox_preds,
+            all_anchor_list,
+            labels_list,
+            label_weights_list,
+            bbox_targets_list,
+            bbox_weights_list,
+            avg_factor=avg_factor)
+
+        # `pos_assigned_gt_inds_list` (length: fpn_levels) stores the assigned
+        # gt index of each anchor bbox in each fpn level.
+        cum_num_gts = list(np.cumsum(num_gts))  # length of batch_size
+        for i, assign in enumerate(pos_assigned_gt_inds_list):
+            # loop over fpn levels
+            for j in range(1, batch_size):
+                # loop over batch size
+                # Convert gt indices in each img to those in the batch
+                assign[j][assign[j] >= 0] += int(cum_num_gts[j - 1])
+            pos_assigned_gt_inds_list[i] = assign.flatten()
+            labels_list[i] = labels_list[i].flatten()
+        num_gts = num_gts.sum()  # total number of gt in the batch
+        # The unique label index of each gt in the batch
+        label_sequence = torch.arange(num_gts, device=device)
+        # Collect the average loss of each gt in each level
+        with torch.no_grad():
+            loss_levels, = multi_apply(
+                self.collect_loss_level_single,
+                losses_cls,
+                losses_bbox,
+                pos_assigned_gt_inds_list,
+                labels_seq=label_sequence)
+            # Shape: (fpn_levels, num_gts). Loss of each gt at each fpn level
+            loss_levels = torch.stack(loss_levels, dim=0)
+            # Locate the best fpn level for loss back-propagation
+            if loss_levels.numel() == 0:  # zero gt
+                argmin = loss_levels.new_empty((num_gts, ), dtype=torch.long)
+            else:
+                _, argmin = loss_levels.min(dim=0)
+
+        # Reweight the loss of each (anchor, label) pair, so that only those
+        #  at the best gt level are back-propagated.
+        losses_cls, losses_bbox, pos_inds = multi_apply(
+            self.reweight_loss_single,
+            losses_cls,
+            losses_bbox,
+            pos_assigned_gt_inds_list,
+            labels_list,
+            list(range(len(losses_cls))),
+            min_levels=argmin)
+        num_pos = torch.cat(pos_inds, 0).sum().float()
+        pos_recall = self.calculate_pos_recall(cls_scores, labels_list,
+                                               pos_inds)
+
+        if num_pos == 0:  # No gt
+            num_total_neg = sum(
+                [results.num_neg for results in sampling_results_list])
+            avg_factor = num_pos + num_total_neg
+        else:
+            avg_factor = num_pos
+        for i in range(len(losses_cls)):
+            losses_cls[i] /= avg_factor
+            losses_bbox[i] /= avg_factor
+        return dict(
+            loss_cls=losses_cls,
+            loss_bbox=losses_bbox,
+            num_pos=num_pos / batch_size,
+            pos_recall=pos_recall)
+
+    def calculate_pos_recall(self, cls_scores: List[Tensor],
+                             labels_list: List[Tensor],
+                             pos_inds: List[Tensor]) -> Tensor:
+        """Calculate positive recall with score threshold.
+
+        Args:
+            cls_scores (list[Tensor]): Classification scores at all fpn levels.
+                Each tensor is in shape (N, num_classes * num_anchors, H, W)
+            labels_list (list[Tensor]): The label that each anchor is assigned
+                to. Shape (N * H * W * num_anchors, )
+            pos_inds (list[Tensor]): List of bool tensors indicating whether
+                the anchor is assigned to a positive label.
+                Shape (N * H * W * num_anchors, )
+
+        Returns:
+            Tensor: A single float number indicating the positive recall.
+        """
+        with torch.no_grad():
+            num_class = self.num_classes
+            scores = [
+                cls.permute(0, 2, 3, 1).reshape(-1, num_class)[pos]
+                for cls, pos in zip(cls_scores, pos_inds)
+            ]
+            labels = [
+                label.reshape(-1)[pos]
+                for label, pos in zip(labels_list, pos_inds)
+            ]
+            scores = torch.cat(scores, dim=0)
+            labels = torch.cat(labels, dim=0)
+            if self.use_sigmoid_cls:
+                scores = scores.sigmoid()
+            else:
+                scores = scores.softmax(dim=1)
+
+            return accuracy(scores, labels, thresh=self.score_threshold)
+
+    def collect_loss_level_single(self, cls_loss: Tensor, reg_loss: Tensor,
+                                  assigned_gt_inds: Tensor,
+                                  labels_seq: Tensor) -> Tensor:
+        """Get the average loss in each FPN level w.r.t. each gt label.
+
+        Args:
+            cls_loss (Tensor): Classification loss of each feature map pixel,
+              shape (num_anchor, num_class)
+            reg_loss (Tensor): Regression loss of each feature map pixel,
+              shape (num_anchor, 4)
+            assigned_gt_inds (Tensor): It indicates which gt the prior is
+              assigned to (0-based, -1: no assignment). shape (num_anchor),
+            labels_seq: The rank of labels. shape (num_gt)
+
+        Returns:
+            Tensor: shape (num_gt), average loss of each gt in this level
+        """
+        if len(reg_loss.shape) == 2:  # iou loss has shape (num_prior, 4)
+            reg_loss = reg_loss.sum(dim=-1)  # sum loss in tblr dims
+        if len(cls_loss.shape) == 2:
+            cls_loss = cls_loss.sum(dim=-1)  # sum loss in class dims
+        loss = cls_loss + reg_loss
+        assert loss.size(0) == assigned_gt_inds.size(0)
+        # Default loss value is 1e6 for a layer where no anchor is positive
+        #  to ensure it will not be chosen to back-propagate gradient
+        losses_ = loss.new_full(labels_seq.shape, 1e6)
+        for i, l in enumerate(labels_seq):
+            match = assigned_gt_inds == l
+            if match.any():
+                losses_[i] = loss[match].mean()
+        return losses_,
+
+    def reweight_loss_single(self, cls_loss: Tensor, reg_loss: Tensor,
+                             assigned_gt_inds: Tensor, labels: Tensor,
+                             level: int, min_levels: Tensor) -> tuple:
+        """Reweight loss values at each level.
+
+        Reassign loss values at each level by masking those where the
+        pre-calculated loss is too large. Then return the reduced losses.
+
+        Args:
+            cls_loss (Tensor): Element-wise classification loss.
+              Shape: (num_anchors, num_classes)
+            reg_loss (Tensor): Element-wise regression loss.
+              Shape: (num_anchors, 4)
+            assigned_gt_inds (Tensor): The gt indices that each anchor bbox
+              is assigned to. -1 denotes a negative anchor, otherwise it is the
+              gt index (0-based). Shape: (num_anchors, ),
+            labels (Tensor): Label assigned to anchors. Shape: (num_anchors, ).
+            level (int): The current level index in the pyramid
+              (0-4 for RetinaNet)
+            min_levels (Tensor): The best-matching level for each gt.
+              Shape: (num_gts, ),
+
+        Returns:
+            tuple:
+
+            - cls_loss: Reduced corrected classification loss. Scalar.
+            - reg_loss: Reduced corrected regression loss. Scalar.
+            - pos_flags (Tensor): Corrected bool tensor indicating the \
+            final positive anchors. Shape: (num_anchors, ).
+        """
+        loc_weight = torch.ones_like(reg_loss)
+        cls_weight = torch.ones_like(cls_loss)
+        pos_flags = assigned_gt_inds >= 0  # positive pixel flag
+        pos_indices = torch.nonzero(pos_flags, as_tuple=False).flatten()
+
+        if pos_flags.any():  # pos pixels exist
+            pos_assigned_gt_inds = assigned_gt_inds[pos_flags]
+            zeroing_indices = (min_levels[pos_assigned_gt_inds] != level)
+            neg_indices = pos_indices[zeroing_indices]
+
+            if neg_indices.numel():
+                pos_flags[neg_indices] = 0
+                loc_weight[neg_indices] = 0
+                # Only the weight corresponding to the label is
+                #  zeroed out if not selected
+                zeroing_labels = labels[neg_indices]
+                assert (zeroing_labels >= 0).all()
+                cls_weight[neg_indices, zeroing_labels] = 0
+
+        # Weighted loss for both cls and reg loss
+        cls_loss = weight_reduce_loss(cls_loss, cls_weight, reduction='sum')
+        reg_loss = weight_reduce_loss(reg_loss, loc_weight, reduction='sum')
+
+        return cls_loss, reg_loss, pos_flags
diff --git a/mmdetection/mmdet/models/dense_heads/ga_retina_head.py b/mmdetection/mmdet/models/dense_heads/ga_retina_head.py
new file mode 100644
index 00000000..569910b3
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/ga_retina_head.py
@@ -0,0 +1,120 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Tuple
+
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmcv.ops import MaskedConv2d
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import OptConfigType, OptMultiConfig
+from .guided_anchor_head import FeatureAdaption, GuidedAnchorHead
+
+
+@MODELS.register_module()
+class GARetinaHead(GuidedAnchorHead):
+    """Guided-Anchor-based RetinaNet head."""
+
+    def __init__(self,
+                 num_classes: int,
+                 in_channels: int,
+                 stacked_convs: int = 4,
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None,
+                 **kwargs) -> None:
+        if init_cfg is None:
+            init_cfg = dict(
+                type='Normal',
+                layer='Conv2d',
+                std=0.01,
+                override=[
+                    dict(
+                        type='Normal',
+                        name='conv_loc',
+                        std=0.01,
+                        bias_prob=0.01),
+                    dict(
+                        type='Normal',
+                        name='retina_cls',
+                        std=0.01,
+                        bias_prob=0.01)
+                ])
+        self.stacked_convs = stacked_convs
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        super().__init__(
+            num_classes=num_classes,
+            in_channels=in_channels,
+            init_cfg=init_cfg,
+            **kwargs)
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        self.relu = nn.ReLU(inplace=True)
+        self.cls_convs = nn.ModuleList()
+        self.reg_convs = nn.ModuleList()
+        for i in range(self.stacked_convs):
+            chn = self.in_channels if i == 0 else self.feat_channels
+            self.cls_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg))
+            self.reg_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg))
+
+        self.conv_loc = nn.Conv2d(self.feat_channels, 1, 1)
+        num_anchors = self.square_anchor_generator.num_base_priors[0]
+        self.conv_shape = nn.Conv2d(self.feat_channels, num_anchors * 2, 1)
+        self.feature_adaption_cls = FeatureAdaption(
+            self.feat_channels,
+            self.feat_channels,
+            kernel_size=3,
+            deform_groups=self.deform_groups)
+        self.feature_adaption_reg = FeatureAdaption(
+            self.feat_channels,
+            self.feat_channels,
+            kernel_size=3,
+            deform_groups=self.deform_groups)
+        self.retina_cls = MaskedConv2d(
+            self.feat_channels,
+            self.num_base_priors * self.cls_out_channels,
+            3,
+            padding=1)
+        self.retina_reg = MaskedConv2d(
+            self.feat_channels, self.num_base_priors * 4, 3, padding=1)
+
+    def forward_single(self, x: Tensor) -> Tuple[Tensor]:
+        """Forward feature map of a single scale level."""
+        cls_feat = x
+        reg_feat = x
+        for cls_conv in self.cls_convs:
+            cls_feat = cls_conv(cls_feat)
+        for reg_conv in self.reg_convs:
+            reg_feat = reg_conv(reg_feat)
+
+        loc_pred = self.conv_loc(cls_feat)
+        shape_pred = self.conv_shape(reg_feat)
+
+        cls_feat = self.feature_adaption_cls(cls_feat, shape_pred)
+        reg_feat = self.feature_adaption_reg(reg_feat, shape_pred)
+
+        if not self.training:
+            mask = loc_pred.sigmoid()[0] >= self.loc_filter_thr
+        else:
+            mask = None
+        cls_score = self.retina_cls(cls_feat, mask)
+        bbox_pred = self.retina_reg(reg_feat, mask)
+        return cls_score, bbox_pred, shape_pred, loc_pred
diff --git a/mmdetection/mmdet/models/dense_heads/ga_rpn_head.py b/mmdetection/mmdet/models/dense_heads/ga_rpn_head.py
new file mode 100644
index 00000000..96144631
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/ga_rpn_head.py
@@ -0,0 +1,222 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+from typing import List, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.ops import nms
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, InstanceList, MultiConfig, OptInstanceList
+from .guided_anchor_head import GuidedAnchorHead
+
+
+@MODELS.register_module()
+class GARPNHead(GuidedAnchorHead):
+    """Guided-Anchor-based RPN head."""
+
+    def __init__(self,
+                 in_channels: int,
+                 num_classes: int = 1,
+                 init_cfg: MultiConfig = dict(
+                     type='Normal',
+                     layer='Conv2d',
+                     std=0.01,
+                     override=dict(
+                         type='Normal',
+                         name='conv_loc',
+                         std=0.01,
+                         bias_prob=0.01)),
+                 **kwargs) -> None:
+        super().__init__(
+            num_classes=num_classes,
+            in_channels=in_channels,
+            init_cfg=init_cfg,
+            **kwargs)
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        self.rpn_conv = nn.Conv2d(
+            self.in_channels, self.feat_channels, 3, padding=1)
+        super(GARPNHead, self)._init_layers()
+
+    def forward_single(self, x: Tensor) -> Tuple[Tensor]:
+        """Forward feature of a single scale level."""
+
+        x = self.rpn_conv(x)
+        x = F.relu(x, inplace=True)
+        (cls_score, bbox_pred, shape_pred,
+         loc_pred) = super().forward_single(x)
+        return cls_score, bbox_pred, shape_pred, loc_pred
+
+    def loss_by_feat(
+            self,
+            cls_scores: List[Tensor],
+            bbox_preds: List[Tensor],
+            shape_preds: List[Tensor],
+            loc_preds: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> dict:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level
+                has shape (N, num_anchors * num_classes, H, W).
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level with shape (N, num_anchors * 4, H, W).
+            shape_preds (list[Tensor]): shape predictions for each scale
+                level with shape (N, 1, H, W).
+            loc_preds (list[Tensor]): location predictions for each scale
+                level with shape (N, num_anchors * 2, H, W).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        losses = super().loss_by_feat(
+            cls_scores,
+            bbox_preds,
+            shape_preds,
+            loc_preds,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore)
+        return dict(
+            loss_rpn_cls=losses['loss_cls'],
+            loss_rpn_bbox=losses['loss_bbox'],
+            loss_anchor_shape=losses['loss_shape'],
+            loss_anchor_loc=losses['loss_loc'])
+
+    def _predict_by_feat_single(self,
+                                cls_scores: List[Tensor],
+                                bbox_preds: List[Tensor],
+                                mlvl_anchors: List[Tensor],
+                                mlvl_masks: List[Tensor],
+                                img_meta: dict,
+                                cfg: ConfigType,
+                                rescale: bool = False) -> InstanceData:
+        """Transform a single image's features extracted from the head into
+        bbox results.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores from all scale
+                levels of a single image, each item has shape
+                (num_priors * num_classes, H, W).
+            bbox_preds (list[Tensor]): Box energies / deltas from
+                all scale levels of a single image, each item has shape
+                (num_priors * 4, H, W).
+            mlvl_anchors (list[Tensor]): Each element in the list is
+                the anchors of a single level in feature pyramid. it has
+                shape (num_priors, 4).
+            mlvl_masks (list[Tensor]): Each element in the list is location
+                masks of a single level.
+            img_meta (dict): Image meta info.
+            cfg (:obj:`ConfigDict` or dict): Test / postprocessing
+                configuration, if None, test_cfg would be used.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+            - scores (Tensor): Classification scores, has a shape
+              (num_instance, )
+            - labels (Tensor): Labels of bboxes, has a shape (num_instances, ).
+            - bboxes (Tensor): Has a shape (num_instances, 4), the last
+              dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        cfg = self.test_cfg if cfg is None else cfg
+        cfg = copy.deepcopy(cfg)
+        assert cfg.nms.get('type', 'nms') == 'nms', 'GARPNHead only support ' \
+            'naive nms.'
+
+        mlvl_proposals = []
+        for idx in range(len(cls_scores)):
+            rpn_cls_score = cls_scores[idx]
+            rpn_bbox_pred = bbox_preds[idx]
+            anchors = mlvl_anchors[idx]
+            mask = mlvl_masks[idx]
+            assert rpn_cls_score.size()[-2:] == rpn_bbox_pred.size()[-2:]
+            # if no location is kept, end.
+            if mask.sum() == 0:
+                continue
+            rpn_cls_score = rpn_cls_score.permute(1, 2, 0)
+            if self.use_sigmoid_cls:
+                rpn_cls_score = rpn_cls_score.reshape(-1)
+                scores = rpn_cls_score.sigmoid()
+            else:
+                rpn_cls_score = rpn_cls_score.reshape(-1, 2)
+                # remind that we set FG labels to [0, num_class-1]
+                # since mmdet v2.0
+                # BG cat_id: num_class
+                scores = rpn_cls_score.softmax(dim=1)[:, :-1]
+            # filter scores, bbox_pred w.r.t. mask.
+            # anchors are filtered in get_anchors() beforehand.
+            scores = scores[mask]
+            rpn_bbox_pred = rpn_bbox_pred.permute(1, 2, 0).reshape(-1,
+                                                                   4)[mask, :]
+            if scores.dim() == 0:
+                rpn_bbox_pred = rpn_bbox_pred.unsqueeze(0)
+                anchors = anchors.unsqueeze(0)
+                scores = scores.unsqueeze(0)
+            # filter anchors, bbox_pred, scores w.r.t. scores
+            if cfg.nms_pre > 0 and scores.shape[0] > cfg.nms_pre:
+                _, topk_inds = scores.topk(cfg.nms_pre)
+                rpn_bbox_pred = rpn_bbox_pred[topk_inds, :]
+                anchors = anchors[topk_inds, :]
+                scores = scores[topk_inds]
+            # get proposals w.r.t. anchors and rpn_bbox_pred
+            proposals = self.bbox_coder.decode(
+                anchors, rpn_bbox_pred, max_shape=img_meta['img_shape'])
+            # filter out too small bboxes
+            if cfg.min_bbox_size >= 0:
+                w = proposals[:, 2] - proposals[:, 0]
+                h = proposals[:, 3] - proposals[:, 1]
+                valid_mask = (w > cfg.min_bbox_size) & (h > cfg.min_bbox_size)
+                if not valid_mask.all():
+                    proposals = proposals[valid_mask]
+                    scores = scores[valid_mask]
+
+            # NMS in current level
+            proposals, _ = nms(proposals, scores, cfg.nms.iou_threshold)
+            proposals = proposals[:cfg.nms_post, :]
+            mlvl_proposals.append(proposals)
+        proposals = torch.cat(mlvl_proposals, 0)
+        if cfg.get('nms_across_levels', False):
+            # NMS across multi levels
+            proposals, _ = nms(proposals[:, :4], proposals[:, -1],
+                               cfg.nms.iou_threshold)
+            proposals = proposals[:cfg.max_per_img, :]
+        else:
+            scores = proposals[:, 4]
+            num = min(cfg.max_per_img, proposals.shape[0])
+            _, topk_inds = scores.topk(num)
+            proposals = proposals[topk_inds, :]
+
+        bboxes = proposals[:, :-1]
+        scores = proposals[:, -1]
+        if rescale:
+            assert img_meta.get('scale_factor') is not None
+            bboxes /= bboxes.new_tensor(img_meta['scale_factor']).repeat(
+                (1, 2))
+
+        results = InstanceData()
+        results.bboxes = bboxes
+        results.scores = scores
+        results.labels = scores.new_zeros(scores.size(0), dtype=torch.long)
+        return results
diff --git a/mmdetection/mmdet/models/dense_heads/gfl_head.py b/mmdetection/mmdet/models/dense_heads/gfl_head.py
new file mode 100644
index 00000000..be43d9b4
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/gfl_head.py
@@ -0,0 +1,667 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Sequence, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule, Scale
+from mmengine.config import ConfigDict
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.structures.bbox import bbox_overlaps
+from mmdet.utils import (ConfigType, InstanceList, MultiConfig, OptConfigType,
+                         OptInstanceList, reduce_mean)
+from ..task_modules.prior_generators import anchor_inside_flags
+from ..task_modules.samplers import PseudoSampler
+from ..utils import (filter_scores_and_topk, images_to_levels, multi_apply,
+                     unmap)
+from .anchor_head import AnchorHead
+
+
+class Integral(nn.Module):
+    """A fixed layer for calculating integral result from distribution.
+
+    This layer calculates the target location by :math: ``sum{P(y_i) * y_i}``,
+    P(y_i) denotes the softmax vector that represents the discrete distribution
+    y_i denotes the discrete set, usually {0, 1, 2, ..., reg_max}
+
+    Args:
+        reg_max (int): The maximal value of the discrete set. Defaults to 16.
+            You may want to reset it according to your new dataset or related
+            settings.
+    """
+
+    def __init__(self, reg_max: int = 16) -> None:
+        super().__init__()
+        self.reg_max = reg_max
+        self.register_buffer('project',
+                             torch.linspace(0, self.reg_max, self.reg_max + 1))
+
+    def forward(self, x: Tensor) -> Tensor:
+        """Forward feature from the regression head to get integral result of
+        bounding box location.
+
+        Args:
+            x (Tensor): Features of the regression head, shape (N, 4*(n+1)),
+                n is self.reg_max.
+
+        Returns:
+            x (Tensor): Integral result of box locations, i.e., distance
+                offsets from the box center in four directions, shape (N, 4).
+        """
+        x = F.softmax(x.reshape(-1, self.reg_max + 1), dim=1)
+        x = F.linear(x, self.project.type_as(x)).reshape(-1, 4)
+        return x
+
+
+@MODELS.register_module()
+class GFLHead(AnchorHead):
+    """Generalized Focal Loss: Learning Qualified and Distributed Bounding
+    Boxes for Dense Object Detection.
+
+    GFL head structure is similar with ATSS, however GFL uses
+    1) joint representation for classification and localization quality, and
+    2) flexible General distribution for bounding box locations,
+    which are supervised by
+    Quality Focal Loss (QFL) and Distribution Focal Loss (DFL), respectively
+
+    https://arxiv.org/abs/2006.04388
+
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (int): Number of channels in the input feature map.
+        stacked_convs (int): Number of conv layers in cls and reg tower.
+            Defaults to 4.
+        conv_cfg (:obj:`ConfigDict` or dict, optional): dictionary to construct
+            and config conv layer. Defaults to None.
+        norm_cfg (:obj:`ConfigDict` or dict): dictionary to construct and
+            config norm layer. Default: dict(type='GN', num_groups=32,
+            requires_grad=True).
+        loss_qfl (:obj:`ConfigDict` or dict): Config of Quality Focal Loss
+            (QFL).
+        bbox_coder (:obj:`ConfigDict` or dict): Config of bbox coder. Defaults
+             to 'DistancePointBBoxCoder'.
+        reg_max (int): Max value of integral set :math: ``{0, ..., reg_max}``
+            in QFL setting. Defaults to 16.
+        init_cfg (:obj:`ConfigDict` or dict or list[dict] or
+            list[:obj:`ConfigDict`]): Initialization config dict.
+    Example:
+        >>> self = GFLHead(11, 7)
+        >>> feats = [torch.rand(1, 7, s, s) for s in [4, 8, 16, 32, 64]]
+        >>> cls_quality_score, bbox_pred = self.forward(feats)
+        >>> assert len(cls_quality_score) == len(self.scales)
+    """
+
+    def __init__(self,
+                 num_classes: int,
+                 in_channels: int,
+                 stacked_convs: int = 4,
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: ConfigType = dict(
+                     type='GN', num_groups=32, requires_grad=True),
+                 loss_dfl: ConfigType = dict(
+                     type='DistributionFocalLoss', loss_weight=0.25),
+                 bbox_coder: ConfigType = dict(type='DistancePointBBoxCoder'),
+                 reg_max: int = 16,
+                 init_cfg: MultiConfig = dict(
+                     type='Normal',
+                     layer='Conv2d',
+                     std=0.01,
+                     override=dict(
+                         type='Normal',
+                         name='gfl_cls',
+                         std=0.01,
+                         bias_prob=0.01)),
+                 **kwargs) -> None:
+        self.stacked_convs = stacked_convs
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.reg_max = reg_max
+        super().__init__(
+            num_classes=num_classes,
+            in_channels=in_channels,
+            bbox_coder=bbox_coder,
+            init_cfg=init_cfg,
+            **kwargs)
+
+        if self.train_cfg:
+            self.assigner = TASK_UTILS.build(self.train_cfg['assigner'])
+            if self.train_cfg.get('sampler', None) is not None:
+                self.sampler = TASK_UTILS.build(
+                    self.train_cfg['sampler'], default_args=dict(context=self))
+            else:
+                self.sampler = PseudoSampler(context=self)
+
+        self.integral = Integral(self.reg_max)
+        self.loss_dfl = MODELS.build(loss_dfl)
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        self.relu = nn.ReLU()
+        self.cls_convs = nn.ModuleList()
+        self.reg_convs = nn.ModuleList()
+        for i in range(self.stacked_convs):
+            chn = self.in_channels if i == 0 else self.feat_channels
+            self.cls_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg))
+            self.reg_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg))
+        assert self.num_anchors == 1, 'anchor free version'
+        self.gfl_cls = nn.Conv2d(
+            self.feat_channels, self.cls_out_channels, 3, padding=1)
+        self.gfl_reg = nn.Conv2d(
+            self.feat_channels, 4 * (self.reg_max + 1), 3, padding=1)
+        self.scales = nn.ModuleList(
+            [Scale(1.0) for _ in self.prior_generator.strides])
+
+    def forward(self, x: Tuple[Tensor]) -> Tuple[List[Tensor]]:
+        """Forward features from the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple: Usually a tuple of classification scores and bbox prediction
+
+            - cls_scores (list[Tensor]): Classification and quality (IoU)
+              joint scores for all scale levels, each is a 4D-tensor,
+              the channel number is num_classes.
+            - bbox_preds (list[Tensor]): Box distribution logits for all
+              scale levels, each is a 4D-tensor, the channel number is
+              4*(n+1), n is max value of integral set.
+        """
+        return multi_apply(self.forward_single, x, self.scales)
+
+    def forward_single(self, x: Tensor, scale: Scale) -> Sequence[Tensor]:
+        """Forward feature of a single scale level.
+
+        Args:
+            x (Tensor): Features of a single scale level.
+            scale (:obj: `mmcv.cnn.Scale`): Learnable scale module to resize
+                the bbox prediction.
+
+        Returns:
+            tuple:
+
+            - cls_score (Tensor): Cls and quality joint scores for a single
+              scale level the channel number is num_classes.
+            - bbox_pred (Tensor): Box distribution logits for a single scale
+              level, the channel number is 4*(n+1), n is max value of
+              integral set.
+        """
+        cls_feat = x
+        reg_feat = x
+        for cls_conv in self.cls_convs:
+            cls_feat = cls_conv(cls_feat)
+        for reg_conv in self.reg_convs:
+            reg_feat = reg_conv(reg_feat)
+        cls_score = self.gfl_cls(cls_feat)
+        bbox_pred = scale(self.gfl_reg(reg_feat)).float()
+        return cls_score, bbox_pred
+
+    def anchor_center(self, anchors: Tensor) -> Tensor:
+        """Get anchor centers from anchors.
+
+        Args:
+            anchors (Tensor): Anchor list with shape (N, 4), ``xyxy`` format.
+
+        Returns:
+            Tensor: Anchor centers with shape (N, 2), ``xy`` format.
+        """
+        anchors_cx = (anchors[..., 2] + anchors[..., 0]) / 2
+        anchors_cy = (anchors[..., 3] + anchors[..., 1]) / 2
+        return torch.stack([anchors_cx, anchors_cy], dim=-1)
+
+    def loss_by_feat_single(self, anchors: Tensor, cls_score: Tensor,
+                            bbox_pred: Tensor, labels: Tensor,
+                            label_weights: Tensor, bbox_targets: Tensor,
+                            stride: Tuple[int], avg_factor: int) -> dict:
+        """Calculate the loss of a single scale level based on the features
+        extracted by the detection head.
+
+        Args:
+            anchors (Tensor): Box reference for each scale level with shape
+                (N, num_total_anchors, 4).
+            cls_score (Tensor): Cls and quality joint scores for each scale
+                level has shape (N, num_classes, H, W).
+            bbox_pred (Tensor): Box distribution logits for each scale
+                level with shape (N, 4*(n+1), H, W), n is max value of integral
+                set.
+            labels (Tensor): Labels of each anchors with shape
+                (N, num_total_anchors).
+            label_weights (Tensor): Label weights of each anchor with shape
+                (N, num_total_anchors)
+            bbox_targets (Tensor): BBox regression targets of each anchor with
+                shape (N, num_total_anchors, 4).
+            stride (Tuple[int]): Stride in this scale level.
+            avg_factor (int): Average factor that is used to average
+                the loss. When using sampling method, avg_factor is usually
+                the sum of positive and negative priors. When using
+                `PseudoSampler`, `avg_factor` is usually equal to the number
+                of positive priors.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        assert stride[0] == stride[1], 'h stride is not equal to w stride!'
+        anchors = anchors.reshape(-1, 4)
+        cls_score = cls_score.permute(0, 2, 3,
+                                      1).reshape(-1, self.cls_out_channels)
+        bbox_pred = bbox_pred.permute(0, 2, 3,
+                                      1).reshape(-1, 4 * (self.reg_max + 1))
+        bbox_targets = bbox_targets.reshape(-1, 4)
+        labels = labels.reshape(-1)
+        label_weights = label_weights.reshape(-1)
+
+        # FG cat_id: [0, num_classes -1], BG cat_id: num_classes
+        bg_class_ind = self.num_classes
+        pos_inds = ((labels >= 0)
+                    & (labels < bg_class_ind)).nonzero().squeeze(1)
+        score = label_weights.new_zeros(labels.shape)
+
+        if len(pos_inds) > 0:
+            pos_bbox_targets = bbox_targets[pos_inds]
+            pos_bbox_pred = bbox_pred[pos_inds]
+            pos_anchors = anchors[pos_inds]
+            pos_anchor_centers = self.anchor_center(pos_anchors) / stride[0]
+
+            weight_targets = cls_score.detach().sigmoid()
+            weight_targets = weight_targets.max(dim=1)[0][pos_inds]
+            pos_bbox_pred_corners = self.integral(pos_bbox_pred)
+            pos_decode_bbox_pred = self.bbox_coder.decode(
+                pos_anchor_centers, pos_bbox_pred_corners)
+            pos_decode_bbox_targets = pos_bbox_targets / stride[0]
+            score[pos_inds] = bbox_overlaps(
+                pos_decode_bbox_pred.detach(),
+                pos_decode_bbox_targets,
+                is_aligned=True)
+            pred_corners = pos_bbox_pred.reshape(-1, self.reg_max + 1)
+            target_corners = self.bbox_coder.encode(pos_anchor_centers,
+                                                    pos_decode_bbox_targets,
+                                                    self.reg_max).reshape(-1)
+
+            # regression loss
+            loss_bbox = self.loss_bbox(
+                pos_decode_bbox_pred,
+                pos_decode_bbox_targets,
+                weight=weight_targets,
+                avg_factor=1.0)
+
+            # dfl loss
+            loss_dfl = self.loss_dfl(
+                pred_corners,
+                target_corners,
+                weight=weight_targets[:, None].expand(-1, 4).reshape(-1),
+                avg_factor=4.0)
+        else:
+            loss_bbox = bbox_pred.sum() * 0
+            loss_dfl = bbox_pred.sum() * 0
+            weight_targets = bbox_pred.new_tensor(0)
+
+        # cls (qfl) loss
+        loss_cls = self.loss_cls(
+            cls_score, (labels, score),
+            weight=label_weights,
+            avg_factor=avg_factor)
+
+        return loss_cls, loss_bbox, loss_dfl, weight_targets.sum()
+
+    def loss_by_feat(
+            self,
+            cls_scores: List[Tensor],
+            bbox_preds: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> dict:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            cls_scores (list[Tensor]): Cls and quality scores for each scale
+                level has shape (N, num_classes, H, W).
+            bbox_preds (list[Tensor]): Box distribution logits for each scale
+                level with shape (N, 4*(n+1), H, W), n is max value of integral
+                set.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], Optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        assert len(featmap_sizes) == self.prior_generator.num_levels
+
+        device = cls_scores[0].device
+        anchor_list, valid_flag_list = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+
+        cls_reg_targets = self.get_targets(
+            anchor_list,
+            valid_flag_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore)
+
+        (anchor_list, labels_list, label_weights_list, bbox_targets_list,
+         bbox_weights_list, avg_factor) = cls_reg_targets
+
+        avg_factor = reduce_mean(
+            torch.tensor(avg_factor, dtype=torch.float, device=device)).item()
+
+        losses_cls, losses_bbox, losses_dfl,\
+            avg_factor = multi_apply(
+                self.loss_by_feat_single,
+                anchor_list,
+                cls_scores,
+                bbox_preds,
+                labels_list,
+                label_weights_list,
+                bbox_targets_list,
+                self.prior_generator.strides,
+                avg_factor=avg_factor)
+
+        avg_factor = sum(avg_factor)
+        avg_factor = reduce_mean(avg_factor).clamp_(min=1).item()
+        losses_bbox = list(map(lambda x: x / avg_factor, losses_bbox))
+        losses_dfl = list(map(lambda x: x / avg_factor, losses_dfl))
+        return dict(
+            loss_cls=losses_cls, loss_bbox=losses_bbox, loss_dfl=losses_dfl)
+
+    def _predict_by_feat_single(self,
+                                cls_score_list: List[Tensor],
+                                bbox_pred_list: List[Tensor],
+                                score_factor_list: List[Tensor],
+                                mlvl_priors: List[Tensor],
+                                img_meta: dict,
+                                cfg: ConfigDict,
+                                rescale: bool = False,
+                                with_nms: bool = True) -> InstanceData:
+        """Transform a single image's features extracted from the head into
+        bbox results.
+
+        Args:
+            cls_score_list (list[Tensor]): Box scores from all scale
+                levels of a single image, each item has shape
+                (num_priors * num_classes, H, W).
+            bbox_pred_list (list[Tensor]): Box energies / deltas from
+                all scale levels of a single image, each item has shape
+                (num_priors * 4, H, W).
+            score_factor_list (list[Tensor]): Score factor from all scale
+                levels of a single image. GFL head does not need this value.
+            mlvl_priors (list[Tensor]): Each element in the list is
+                the priors of a single level in feature pyramid, has shape
+                (num_priors, 4).
+            img_meta (dict): Image meta info.
+            cfg (:obj: `ConfigDict`): Test / postprocessing configuration,
+                if None, test_cfg would be used.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            with_nms (bool): If True, do nms before return boxes.
+                Defaults to True.
+
+        Returns:
+            tuple[Tensor]: Results of detected bboxes and labels. If with_nms
+            is False and mlvl_score_factor is None, return mlvl_bboxes and
+            mlvl_scores, else return mlvl_bboxes, mlvl_scores and
+            mlvl_score_factor. Usually with_nms is False is used for aug
+            test. If with_nms is True, then return the following format
+
+            - det_bboxes (Tensor): Predicted bboxes with shape
+              [num_bboxes, 5], where the first 4 columns are bounding
+              box positions (tl_x, tl_y, br_x, br_y) and the 5-th
+              column are scores between 0 and 1.
+            - det_labels (Tensor): Predicted labels of the corresponding
+              box with shape [num_bboxes].
+        """
+        cfg = self.test_cfg if cfg is None else cfg
+        img_shape = img_meta['img_shape']
+        nms_pre = cfg.get('nms_pre', -1)
+
+        mlvl_bboxes = []
+        mlvl_scores = []
+        mlvl_labels = []
+        for level_idx, (cls_score, bbox_pred, stride, priors) in enumerate(
+                zip(cls_score_list, bbox_pred_list,
+                    self.prior_generator.strides, mlvl_priors)):
+            assert cls_score.size()[-2:] == bbox_pred.size()[-2:]
+            assert stride[0] == stride[1]
+
+            bbox_pred = bbox_pred.permute(1, 2, 0)
+            bbox_pred = self.integral(bbox_pred) * stride[0]
+
+            scores = cls_score.permute(1, 2, 0).reshape(
+                -1, self.cls_out_channels).sigmoid()
+
+            # After https://github.com/open-mmlab/mmdetection/pull/6268/,
+            # this operation keeps fewer bboxes under the same `nms_pre`.
+            # There is no difference in performance for most models. If you
+            # find a slight drop in performance, you can set a larger
+            # `nms_pre` than before.
+            results = filter_scores_and_topk(
+                scores, cfg.score_thr, nms_pre,
+                dict(bbox_pred=bbox_pred, priors=priors))
+            scores, labels, _, filtered_results = results
+
+            bbox_pred = filtered_results['bbox_pred']
+            priors = filtered_results['priors']
+
+            bboxes = self.bbox_coder.decode(
+                self.anchor_center(priors), bbox_pred, max_shape=img_shape)
+            mlvl_bboxes.append(bboxes)
+            mlvl_scores.append(scores)
+            mlvl_labels.append(labels)
+
+        results = InstanceData()
+        results.bboxes = torch.cat(mlvl_bboxes)
+        results.scores = torch.cat(mlvl_scores)
+        results.labels = torch.cat(mlvl_labels)
+
+        return self._bbox_post_process(
+            results=results,
+            cfg=cfg,
+            rescale=rescale,
+            with_nms=with_nms,
+            img_meta=img_meta)
+
+    def get_targets(self,
+                    anchor_list: List[Tensor],
+                    valid_flag_list: List[Tensor],
+                    batch_gt_instances: InstanceList,
+                    batch_img_metas: List[dict],
+                    batch_gt_instances_ignore: OptInstanceList = None,
+                    unmap_outputs=True) -> tuple:
+        """Get targets for GFL head.
+
+        This method is almost the same as `AnchorHead.get_targets()`. Besides
+        returning the targets as the parent method does, it also returns the
+        anchors as the first element of the returned tuple.
+        """
+        num_imgs = len(batch_img_metas)
+        assert len(anchor_list) == len(valid_flag_list) == num_imgs
+
+        # anchor number of multi levels
+        num_level_anchors = [anchors.size(0) for anchors in anchor_list[0]]
+        num_level_anchors_list = [num_level_anchors] * num_imgs
+
+        # concat all level anchors and flags to a single tensor
+        for i in range(num_imgs):
+            assert len(anchor_list[i]) == len(valid_flag_list[i])
+            anchor_list[i] = torch.cat(anchor_list[i])
+            valid_flag_list[i] = torch.cat(valid_flag_list[i])
+
+        # compute targets for each image
+        if batch_gt_instances_ignore is None:
+            batch_gt_instances_ignore = [None] * num_imgs
+        (all_anchors, all_labels, all_label_weights, all_bbox_targets,
+         all_bbox_weights, pos_inds_list, neg_inds_list,
+         sampling_results_list) = multi_apply(
+             self._get_targets_single,
+             anchor_list,
+             valid_flag_list,
+             num_level_anchors_list,
+             batch_gt_instances,
+             batch_img_metas,
+             batch_gt_instances_ignore,
+             unmap_outputs=unmap_outputs)
+        # Get `avg_factor` of all images, which calculate in `SamplingResult`.
+        # When using sampling method, avg_factor is usually the sum of
+        # positive and negative priors. When using `PseudoSampler`,
+        # `avg_factor` is usually equal to the number of positive priors.
+        avg_factor = sum(
+            [results.avg_factor for results in sampling_results_list])
+        # split targets to a list w.r.t. multiple levels
+        anchors_list = images_to_levels(all_anchors, num_level_anchors)
+        labels_list = images_to_levels(all_labels, num_level_anchors)
+        label_weights_list = images_to_levels(all_label_weights,
+                                              num_level_anchors)
+        bbox_targets_list = images_to_levels(all_bbox_targets,
+                                             num_level_anchors)
+        bbox_weights_list = images_to_levels(all_bbox_weights,
+                                             num_level_anchors)
+        return (anchors_list, labels_list, label_weights_list,
+                bbox_targets_list, bbox_weights_list, avg_factor)
+
+    def _get_targets_single(self,
+                            flat_anchors: Tensor,
+                            valid_flags: Tensor,
+                            num_level_anchors: List[int],
+                            gt_instances: InstanceData,
+                            img_meta: dict,
+                            gt_instances_ignore: Optional[InstanceData] = None,
+                            unmap_outputs: bool = True) -> tuple:
+        """Compute regression, classification targets for anchors in a single
+        image.
+
+        Args:
+            flat_anchors (Tensor): Multi-level anchors of the image, which are
+                concatenated into a single tensor of shape (num_anchors, 4)
+            valid_flags (Tensor): Multi level valid flags of the image,
+                which are concatenated into a single tensor of
+                    shape (num_anchors,).
+            num_level_anchors (list[int]): Number of anchors of each scale
+                level.
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            img_meta (dict): Meta information for current image.
+            gt_instances_ignore (:obj:`InstanceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+            unmap_outputs (bool): Whether to map outputs back to the original
+                set of anchors. Defaults to True.
+
+        Returns:
+            tuple: N is the number of total anchors in the image.
+
+            - anchors (Tensor): All anchors in the image with shape (N, 4).
+            - labels (Tensor): Labels of all anchors in the image with
+              shape (N,).
+            - label_weights (Tensor): Label weights of all anchor in the
+              image with shape (N,).
+            - bbox_targets (Tensor): BBox targets of all anchors in the
+              image with shape (N, 4).
+            - bbox_weights (Tensor): BBox weights of all anchors in the
+              image with shape (N, 4).
+            - pos_inds (Tensor): Indices of positive anchor with shape
+              (num_pos,).
+            - neg_inds (Tensor): Indices of negative anchor with shape
+              (num_neg,).
+            - sampling_result (:obj:`SamplingResult`): Sampling results.
+        """
+        inside_flags = anchor_inside_flags(flat_anchors, valid_flags,
+                                           img_meta['img_shape'][:2],
+                                           self.train_cfg['allowed_border'])
+        if not inside_flags.any():
+            raise ValueError(
+                'There is no valid anchor inside the image boundary. Please '
+                'check the image size and anchor sizes, or set '
+                '``allowed_border`` to -1 to skip the condition.')
+        # assign gt and sample anchors
+        anchors = flat_anchors[inside_flags, :]
+        num_level_anchors_inside = self.get_num_level_anchors_inside(
+            num_level_anchors, inside_flags)
+        pred_instances = InstanceData(priors=anchors)
+        assign_result = self.assigner.assign(
+            pred_instances=pred_instances,
+            num_level_priors=num_level_anchors_inside,
+            gt_instances=gt_instances,
+            gt_instances_ignore=gt_instances_ignore)
+
+        sampling_result = self.sampler.sample(
+            assign_result=assign_result,
+            pred_instances=pred_instances,
+            gt_instances=gt_instances)
+
+        num_valid_anchors = anchors.shape[0]
+        bbox_targets = torch.zeros_like(anchors)
+        bbox_weights = torch.zeros_like(anchors)
+        labels = anchors.new_full((num_valid_anchors, ),
+                                  self.num_classes,
+                                  dtype=torch.long)
+        label_weights = anchors.new_zeros(num_valid_anchors, dtype=torch.float)
+
+        pos_inds = sampling_result.pos_inds
+        neg_inds = sampling_result.neg_inds
+        if len(pos_inds) > 0:
+            pos_bbox_targets = sampling_result.pos_gt_bboxes
+            bbox_targets[pos_inds, :] = pos_bbox_targets
+            bbox_weights[pos_inds, :] = 1.0
+
+            labels[pos_inds] = sampling_result.pos_gt_labels
+            if self.train_cfg['pos_weight'] <= 0:
+                label_weights[pos_inds] = 1.0
+            else:
+                label_weights[pos_inds] = self.train_cfg['pos_weight']
+        if len(neg_inds) > 0:
+            label_weights[neg_inds] = 1.0
+
+        # map up to original set of anchors
+        if unmap_outputs:
+            num_total_anchors = flat_anchors.size(0)
+            anchors = unmap(anchors, num_total_anchors, inside_flags)
+            labels = unmap(
+                labels, num_total_anchors, inside_flags, fill=self.num_classes)
+            label_weights = unmap(label_weights, num_total_anchors,
+                                  inside_flags)
+            bbox_targets = unmap(bbox_targets, num_total_anchors, inside_flags)
+            bbox_weights = unmap(bbox_weights, num_total_anchors, inside_flags)
+
+        return (anchors, labels, label_weights, bbox_targets, bbox_weights,
+                pos_inds, neg_inds, sampling_result)
+
+    def get_num_level_anchors_inside(self, num_level_anchors: List[int],
+                                     inside_flags: Tensor) -> List[int]:
+        """Get the number of valid anchors in every level."""
+
+        split_inside_flags = torch.split(inside_flags, num_level_anchors)
+        num_level_anchors_inside = [
+            int(flags.sum()) for flags in split_inside_flags
+        ]
+        return num_level_anchors_inside
diff --git a/mmdetection/mmdet/models/dense_heads/grounding_dino_head.py b/mmdetection/mmdet/models/dense_heads/grounding_dino_head.py
new file mode 100644
index 00000000..80883225
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/grounding_dino_head.py
@@ -0,0 +1,774 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import math
+from typing import Dict, List, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import Linear
+from mmengine.model import constant_init
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.models.losses import QualityFocalLoss
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.structures.bbox import bbox_cxcywh_to_xyxy, bbox_xyxy_to_cxcywh
+from mmdet.utils import InstanceList, reduce_mean
+from ..layers import inverse_sigmoid
+from .atss_vlfusion_head import convert_grounding_to_cls_scores
+from .dino_head import DINOHead
+
+
+class ContrastiveEmbed(nn.Module):
+    """text visual ContrastiveEmbed layer.
+
+    Args:
+        max_text_len (int, optional): Maximum length of text.
+        log_scale (Optional[Union[str, float]]):  The initial value of a
+          learnable parameter to multiply with the similarity
+          matrix to normalize the output.  Defaults to 0.0.
+          - If set to 'auto', the similarity matrix will be normalized by
+            a fixed value ``sqrt(d_c)`` where ``d_c`` is the channel number.
+          - If set to 'none' or ``None``, there is no normalization applied.
+          - If set to a float number, the similarity matrix will be multiplied
+            by ``exp(log_scale)``, where ``log_scale`` is learnable.
+        bias (bool, optional): Whether to add bias to the output.
+          If set to ``True``, a learnable bias that is initialized as -4.6
+          will be added to the output. Useful when training from scratch.
+          Defaults to False.
+    """
+
+    def __init__(self,
+                 max_text_len: int = 256,
+                 log_scale: Optional[Union[str, float]] = None,
+                 bias: bool = False):
+        super().__init__()
+        self.max_text_len = max_text_len
+        self.log_scale = log_scale
+        if isinstance(log_scale, float):
+            self.log_scale = nn.Parameter(
+                torch.Tensor([float(log_scale)]), requires_grad=True)
+        elif log_scale not in ['auto', 'none', None]:
+            raise ValueError(f'log_scale should be one of '
+                             f'"auto", "none", None, but got {log_scale}')
+
+        self.bias = None
+        if bias:
+            bias_value = -math.log((1 - 0.01) / 0.01)
+            self.bias = nn.Parameter(
+                torch.Tensor([bias_value]), requires_grad=True)
+
+    def forward(self, visual_feat: Tensor, text_feat: Tensor,
+                text_token_mask: Tensor) -> Tensor:
+        """Forward function.
+
+        Args:
+            visual_feat (Tensor): Visual features.
+            text_feat (Tensor): Text features.
+            text_token_mask (Tensor): A mask used for text feats.
+
+        Returns:
+            Tensor: Classification score.
+        """
+        res = visual_feat @ text_feat.transpose(-1, -2)
+        if isinstance(self.log_scale, nn.Parameter):
+            res = res * self.log_scale.exp()
+        elif self.log_scale == 'auto':
+            # NOTE: similar to the normalizer in self-attention
+            res = res / math.sqrt(visual_feat.shape[-1])
+        if self.bias is not None:
+            res = res + self.bias
+        res.masked_fill_(~text_token_mask[:, None, :], float('-inf'))
+
+        new_res = torch.full((*res.shape[:-1], self.max_text_len),
+                             float('-inf'),
+                             device=res.device)
+        new_res[..., :res.shape[-1]] = res
+
+        return new_res
+
+
+@MODELS.register_module()
+class GroundingDINOHead(DINOHead):
+    """Head of the Grounding DINO: Marrying DINO with Grounded Pre-Training for
+    Open-Set Object Detection.
+
+    Args:
+        contrastive_cfg (dict, optional): Contrastive config that contains
+          keys like ``max_text_len``. Defaults to dict(max_text_len=256).
+    """
+
+    def __init__(self, contrastive_cfg=dict(max_text_len=256), **kwargs):
+        self.contrastive_cfg = contrastive_cfg
+        self.max_text_len = contrastive_cfg.get('max_text_len', 256)
+        super().__init__(**kwargs)
+
+    def _init_layers(self) -> None:
+        """Initialize classification branch and regression branch of head."""
+        fc_cls = ContrastiveEmbed(**self.contrastive_cfg)
+        reg_branch = []
+        for _ in range(self.num_reg_fcs):
+            reg_branch.append(Linear(self.embed_dims, self.embed_dims))
+            reg_branch.append(nn.ReLU())
+        reg_branch.append(Linear(self.embed_dims, 4))
+        reg_branch = nn.Sequential(*reg_branch)
+
+        # NOTE: due to the fc_cls is a contrastive embedding and don't
+        # have any trainable parameters,we do not need to copy it.
+        if self.share_pred_layer:
+            self.cls_branches = nn.ModuleList(
+                [fc_cls for _ in range(self.num_pred_layer)])
+            self.reg_branches = nn.ModuleList(
+                [reg_branch for _ in range(self.num_pred_layer)])
+        else:
+            self.cls_branches = nn.ModuleList(
+                [copy.deepcopy(fc_cls) for _ in range(self.num_pred_layer)])
+            self.reg_branches = nn.ModuleList([
+                copy.deepcopy(reg_branch) for _ in range(self.num_pred_layer)
+            ])
+
+    def init_weights(self) -> None:
+        """Initialize weights of the Deformable DETR head."""
+        for m in self.reg_branches:
+            constant_init(m[-1], 0, bias=0)
+        nn.init.constant_(self.reg_branches[0][-1].bias.data[2:], -2.0)
+        if self.as_two_stage:
+            for m in self.reg_branches:
+                nn.init.constant_(m[-1].bias.data[2:], 0.0)
+
+    def _get_targets_single(self, cls_score: Tensor, bbox_pred: Tensor,
+                            gt_instances: InstanceData,
+                            img_meta: dict) -> tuple:
+        """Compute regression and classification targets for one image.
+
+        Outputs from a single decoder layer of a single feature level are used.
+
+        Args:
+            cls_score (Tensor): Box score logits from a single decoder layer
+                for one image. Shape [num_queries, cls_out_channels].
+            bbox_pred (Tensor): Sigmoid outputs from a single decoder layer
+                for one image, with normalized coordinate (cx, cy, w, h) and
+                shape [num_queries, 4].
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It should includes ``bboxes`` and ``labels``
+                attributes.
+            img_meta (dict): Meta information for one image.
+
+        Returns:
+            tuple[Tensor]: a tuple containing the following for one image.
+
+            - labels (Tensor): Labels of each image.
+            - label_weights (Tensor]): Label weights of each image.
+            - bbox_targets (Tensor): BBox targets of each image.
+            - bbox_weights (Tensor): BBox weights of each image.
+            - pos_inds (Tensor): Sampled positive indices for each image.
+            - neg_inds (Tensor): Sampled negative indices for each image.
+        """
+        img_h, img_w = img_meta['img_shape']
+        factor = bbox_pred.new_tensor([img_w, img_h, img_w,
+                                       img_h]).unsqueeze(0)
+        num_bboxes = bbox_pred.size(0)
+        # convert bbox_pred from xywh, normalized to xyxy, unnormalized
+        bbox_pred = bbox_cxcywh_to_xyxy(bbox_pred)
+        bbox_pred = bbox_pred * factor
+
+        pred_instances = InstanceData(scores=cls_score, bboxes=bbox_pred)
+        # assigner and sampler
+        assign_result = self.assigner.assign(
+            pred_instances=pred_instances,
+            gt_instances=gt_instances,
+            img_meta=img_meta)
+        gt_bboxes = gt_instances.bboxes
+
+        pos_inds = torch.nonzero(
+            assign_result.gt_inds > 0, as_tuple=False).squeeze(-1).unique()
+        neg_inds = torch.nonzero(
+            assign_result.gt_inds == 0, as_tuple=False).squeeze(-1).unique()
+        pos_assigned_gt_inds = assign_result.gt_inds[pos_inds] - 1
+        pos_gt_bboxes = gt_bboxes[pos_assigned_gt_inds.long(), :]
+
+        # Major changes. The labels are 0-1 binary labels for each bbox
+        # and text tokens.
+        labels = gt_bboxes.new_full((num_bboxes, self.max_text_len),
+                                    0,
+                                    dtype=torch.float32)
+        labels[pos_inds] = gt_instances.positive_maps[pos_assigned_gt_inds]
+        label_weights = gt_bboxes.new_ones(num_bboxes)
+
+        # bbox targets
+        bbox_targets = torch.zeros_like(bbox_pred, dtype=gt_bboxes.dtype)
+        bbox_weights = torch.zeros_like(bbox_pred, dtype=gt_bboxes.dtype)
+        bbox_weights[pos_inds] = 1.0
+
+        # DETR regress the relative position of boxes (cxcywh) in the image.
+        # Thus the learning target should be normalized by the image size, also
+        # the box format should be converted from defaultly x1y1x2y2 to cxcywh.
+        pos_gt_bboxes_normalized = pos_gt_bboxes / factor
+        pos_gt_bboxes_targets = bbox_xyxy_to_cxcywh(pos_gt_bboxes_normalized)
+        bbox_targets[pos_inds] = pos_gt_bboxes_targets
+        return (labels, label_weights, bbox_targets, bbox_weights, pos_inds,
+                neg_inds)
+
+    def forward(
+        self,
+        hidden_states: Tensor,
+        references: List[Tensor],
+        memory_text: Tensor,
+        text_token_mask: Tensor,
+    ) -> Tuple[Tensor]:
+        """Forward function.
+
+        Args:
+            hidden_states (Tensor): Hidden states output from each decoder
+                layer, has shape (num_decoder_layers, bs, num_queries, dim).
+            references (List[Tensor]): List of the reference from the decoder.
+                The first reference is the `init_reference` (initial) and the
+                other num_decoder_layers(6) references are `inter_references`
+                (intermediate). The `init_reference` has shape (bs,
+                num_queries, 4) when `as_two_stage` of the detector is `True`,
+                otherwise (bs, num_queries, 2). Each `inter_reference` has
+                shape (bs, num_queries, 4) when `with_box_refine` of the
+                detector is `True`, otherwise (bs, num_queries, 2). The
+                coordinates are arranged as (cx, cy) when the last dimension is
+                2, and (cx, cy, w, h) when it is 4.
+            memory_text (Tensor): Memory text. It has shape (bs, len_text,
+                text_embed_dims).
+            text_token_mask (Tensor): Text token mask. It has shape (bs,
+                len_text).
+
+        Returns:
+            tuple[Tensor]: results of head containing the following tensor.
+
+            - all_layers_outputs_classes (Tensor): Outputs from the
+              classification head, has shape (num_decoder_layers, bs,
+              num_queries, cls_out_channels).
+            - all_layers_outputs_coords (Tensor): Sigmoid outputs from the
+              regression head with normalized coordinate format (cx, cy, w,
+              h), has shape (num_decoder_layers, bs, num_queries, 4) with the
+              last dimension arranged as (cx, cy, w, h).
+        """
+        all_layers_outputs_classes = []
+        all_layers_outputs_coords = []
+
+        for layer_id in range(hidden_states.shape[0]):
+            reference = inverse_sigmoid(references[layer_id])
+            # NOTE The last reference will not be used.
+            hidden_state = hidden_states[layer_id]
+            outputs_class = self.cls_branches[layer_id](hidden_state,
+                                                        memory_text,
+                                                        text_token_mask)
+            tmp_reg_preds = self.reg_branches[layer_id](hidden_state)
+            if reference.shape[-1] == 4:
+                # When `layer` is 0 and `as_two_stage` of the detector
+                # is `True`, or when `layer` is greater than 0 and
+                # `with_box_refine` of the detector is `True`.
+                tmp_reg_preds += reference
+            else:
+                # When `layer` is 0 and `as_two_stage` of the detector
+                # is `False`, or when `layer` is greater than 0 and
+                # `with_box_refine` of the detector is `False`.
+                assert reference.shape[-1] == 2
+                tmp_reg_preds[..., :2] += reference
+            outputs_coord = tmp_reg_preds.sigmoid()
+            all_layers_outputs_classes.append(outputs_class)
+            all_layers_outputs_coords.append(outputs_coord)
+
+        all_layers_outputs_classes = torch.stack(all_layers_outputs_classes)
+        all_layers_outputs_coords = torch.stack(all_layers_outputs_coords)
+
+        return all_layers_outputs_classes, all_layers_outputs_coords
+
+    def predict(self,
+                hidden_states: Tensor,
+                references: List[Tensor],
+                memory_text: Tensor,
+                text_token_mask: Tensor,
+                batch_data_samples: SampleList,
+                rescale: bool = True) -> InstanceList:
+        """Perform forward propagation and loss calculation of the detection
+        head on the queries of the upstream network.
+
+        Args:
+            hidden_states (Tensor): Hidden states output from each decoder
+                layer, has shape (num_decoder_layers, num_queries, bs, dim).
+            references (List[Tensor]): List of the reference from the decoder.
+                The first reference is the `init_reference` (initial) and the
+                other num_decoder_layers(6) references are `inter_references`
+                (intermediate). The `init_reference` has shape (bs,
+                num_queries, 4) when `as_two_stage` of the detector is `True`,
+                otherwise (bs, num_queries, 2). Each `inter_reference` has
+                shape (bs, num_queries, 4) when `with_box_refine` of the
+                detector is `True`, otherwise (bs, num_queries, 2). The
+                coordinates are arranged as (cx, cy) when the last dimension is
+                2, and (cx, cy, w, h) when it is 4.
+            memory_text (Tensor): Memory text. It has shape (bs, len_text,
+                text_embed_dims).
+            text_token_mask (Tensor): Text token mask. It has shape (bs,
+                len_text).
+            batch_data_samples (SampleList): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            rescale (bool, optional): If `True`, return boxes in original
+                image space. Defaults to `True`.
+
+        Returns:
+            InstanceList: Detection results of each image
+                after the post process.
+        """
+        batch_img_metas = [
+            data_samples.metainfo for data_samples in batch_data_samples
+        ]
+        batch_token_positive_maps = [
+            data_samples.token_positive_map
+            for data_samples in batch_data_samples
+        ]
+
+        outs = self(hidden_states, references, memory_text, text_token_mask)
+
+        predictions = self.predict_by_feat(
+            *outs,
+            batch_img_metas=batch_img_metas,
+            batch_token_positive_maps=batch_token_positive_maps,
+            rescale=rescale)
+        return predictions
+
+    def predict_by_feat(self,
+                        all_layers_cls_scores: Tensor,
+                        all_layers_bbox_preds: Tensor,
+                        batch_img_metas: List[Dict],
+                        batch_token_positive_maps: Optional[List[dict]] = None,
+                        rescale: bool = False) -> InstanceList:
+        """Transform a batch of output features extracted from the head into
+        bbox results.
+
+        Args:
+            all_layers_cls_scores (Tensor):  Classification scores of all
+                decoder layers, has shape (num_decoder_layers, bs, num_queries,
+                cls_out_channels).
+            all_layers_bbox_preds (Tensor): Regression outputs of all decoder
+                layers. Each is a 4D-tensor with normalized coordinate format
+                (cx, cy, w, h) and shape (num_decoder_layers, bs, num_queries,
+                4) with the last dimension arranged as (cx, cy, w, h).
+            batch_img_metas (List[Dict]): _description_
+            batch_token_positive_maps (list[dict], Optional): Batch token
+                positive map. Defaults to None.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Object detection results of each image
+            after the post process. Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        cls_scores = all_layers_cls_scores[-1]
+        bbox_preds = all_layers_bbox_preds[-1]
+        result_list = []
+        for img_id in range(len(batch_img_metas)):
+            cls_score = cls_scores[img_id]
+            bbox_pred = bbox_preds[img_id]
+            img_meta = batch_img_metas[img_id]
+            token_positive_maps = batch_token_positive_maps[img_id]
+            results = self._predict_by_feat_single(cls_score, bbox_pred,
+                                                   token_positive_maps,
+                                                   img_meta, rescale)
+            result_list.append(results)
+        return result_list
+
+    def _predict_by_feat_single(self,
+                                cls_score: Tensor,
+                                bbox_pred: Tensor,
+                                token_positive_maps: dict,
+                                img_meta: dict,
+                                rescale: bool = True) -> InstanceData:
+        """Transform a single image's features extracted from the head into
+        bbox results.
+
+        Args:
+            cls_score (Tensor): Box score logits from the last decoder layer
+                for each image. Shape [num_queries, cls_out_channels].
+            bbox_pred (Tensor): Sigmoid outputs from the last decoder layer
+                for each image, with coordinate format (cx, cy, w, h) and
+                shape [num_queries, 4].
+            token_positive_maps (dict): Token positive map.
+            img_meta (dict): Image meta info.
+            rescale (bool, optional): If True, return boxes in original image
+                space. Default True.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        assert len(cls_score) == len(bbox_pred)  # num_queries
+        max_per_img = self.test_cfg.get('max_per_img', len(cls_score))
+        img_shape = img_meta['img_shape']
+
+        if token_positive_maps is not None:
+            cls_score = convert_grounding_to_cls_scores(
+                logits=cls_score.sigmoid()[None],
+                positive_maps=[token_positive_maps])[0]
+            scores, indexes = cls_score.view(-1).topk(max_per_img)
+            num_classes = cls_score.shape[-1]
+            det_labels = indexes % num_classes
+            bbox_index = indexes // num_classes
+            bbox_pred = bbox_pred[bbox_index]
+        else:
+            cls_score = cls_score.sigmoid()
+            scores, _ = cls_score.max(-1)
+            scores, indexes = scores.topk(max_per_img)
+            bbox_pred = bbox_pred[indexes]
+            det_labels = scores.new_zeros(scores.shape, dtype=torch.long)
+
+        det_bboxes = bbox_cxcywh_to_xyxy(bbox_pred)
+        det_bboxes[:, 0::2] = det_bboxes[:, 0::2] * img_shape[1]
+        det_bboxes[:, 1::2] = det_bboxes[:, 1::2] * img_shape[0]
+        det_bboxes[:, 0::2].clamp_(min=0, max=img_shape[1])
+        det_bboxes[:, 1::2].clamp_(min=0, max=img_shape[0])
+        if rescale:
+            assert img_meta.get('scale_factor') is not None
+            det_bboxes /= det_bboxes.new_tensor(
+                img_meta['scale_factor']).repeat((1, 2))
+        results = InstanceData()
+        results.bboxes = det_bboxes
+        results.scores = scores
+        results.labels = det_labels
+        return results
+
+    def loss(self, hidden_states: Tensor, references: List[Tensor],
+             memory_text: Tensor, text_token_mask: Tensor,
+             enc_outputs_class: Tensor, enc_outputs_coord: Tensor,
+             batch_data_samples: SampleList, dn_meta: Dict[str, int]) -> dict:
+        """Perform forward propagation and loss calculation of the detection
+        head on the queries of the upstream network.
+
+        Args:
+            hidden_states (Tensor): Hidden states output from each decoder
+                layer, has shape (num_decoder_layers, bs, num_queries_total,
+                dim), where `num_queries_total` is the sum of
+                `num_denoising_queries` and `num_matching_queries` when
+                `self.training` is `True`, else `num_matching_queries`.
+            references (list[Tensor]): List of the reference from the decoder.
+                The first reference is the `init_reference` (initial) and the
+                other num_decoder_layers(6) references are `inter_references`
+                (intermediate). The `init_reference` has shape (bs,
+                num_queries_total, 4) and each `inter_reference` has shape
+                (bs, num_queries, 4) with the last dimension arranged as
+                (cx, cy, w, h).
+            memory_text (Tensor): Memory text. It has shape (bs, len_text,
+                text_embed_dims).
+            enc_outputs_class (Tensor): The score of each point on encode
+                feature map, has shape (bs, num_feat_points, cls_out_channels).
+            enc_outputs_coord (Tensor): The proposal generate from the
+                encode feature map, has shape (bs, num_feat_points, 4) with the
+                last dimension arranged as (cx, cy, w, h).
+            batch_data_samples (list[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            dn_meta (Dict[str, int]): The dictionary saves information about
+              group collation, including 'num_denoising_queries' and
+              'num_denoising_groups'. It will be used for split outputs of
+              denoising and matching parts and loss calculation.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        batch_gt_instances = []
+        batch_img_metas = []
+        for data_sample in batch_data_samples:
+            batch_img_metas.append(data_sample.metainfo)
+            batch_gt_instances.append(data_sample.gt_instances)
+
+        outs = self(hidden_states, references, memory_text, text_token_mask)
+        self.text_masks = text_token_mask
+        loss_inputs = outs + (enc_outputs_class, enc_outputs_coord,
+                              batch_gt_instances, batch_img_metas, dn_meta)
+        losses = self.loss_by_feat(*loss_inputs)
+        return losses
+
+    def loss_by_feat_single(self, cls_scores: Tensor, bbox_preds: Tensor,
+                            batch_gt_instances: InstanceList,
+                            batch_img_metas: List[dict]) -> Tuple[Tensor]:
+        """Loss function for outputs from a single decoder layer of a single
+        feature level.
+
+        Args:
+            cls_scores (Tensor): Box score logits from a single decoder layer
+                for all images, has shape (bs, num_queries, cls_out_channels).
+            bbox_preds (Tensor): Sigmoid outputs from a single decoder layer
+                for all images, with normalized coordinate (cx, cy, w, h) and
+                shape (bs, num_queries, 4).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+
+        Returns:
+            Tuple[Tensor]: A tuple including `loss_cls`, `loss_box` and
+            `loss_iou`.
+        """
+        num_imgs = cls_scores.size(0)
+        cls_scores_list = [cls_scores[i] for i in range(num_imgs)]
+        bbox_preds_list = [bbox_preds[i] for i in range(num_imgs)]
+        with torch.no_grad():
+            cls_reg_targets = self.get_targets(cls_scores_list,
+                                               bbox_preds_list,
+                                               batch_gt_instances,
+                                               batch_img_metas)
+        (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,
+         num_total_pos, num_total_neg) = cls_reg_targets
+        labels = torch.stack(labels_list, 0)
+        label_weights = torch.stack(label_weights_list, 0)
+        bbox_targets = torch.cat(bbox_targets_list, 0)
+        bbox_weights = torch.cat(bbox_weights_list, 0)
+
+        # ===== this change =====
+        # Loss is not computed for the padded regions of the text.
+        assert (self.text_masks.dim() == 2)
+        text_masks = self.text_masks.new_zeros(
+            (self.text_masks.size(0), self.max_text_len))
+        text_masks[:, :self.text_masks.size(1)] = self.text_masks
+        text_mask = (text_masks > 0).unsqueeze(1)
+        text_mask = text_mask.repeat(1, cls_scores.size(1), 1)
+        cls_scores = torch.masked_select(cls_scores, text_mask).contiguous()
+
+        labels = torch.masked_select(labels, text_mask)
+        label_weights = label_weights[...,
+                                      None].repeat(1, 1, text_mask.size(-1))
+        label_weights = torch.masked_select(label_weights, text_mask)
+
+        # classification loss
+        # construct weighted avg_factor to match with the official DETR repo
+        cls_avg_factor = num_total_pos * 1.0 + \
+            num_total_neg * self.bg_cls_weight
+        if self.sync_cls_avg_factor:
+            cls_avg_factor = reduce_mean(
+                cls_scores.new_tensor([cls_avg_factor]))
+        cls_avg_factor = max(cls_avg_factor, 1)
+
+        if isinstance(self.loss_cls, QualityFocalLoss):
+            raise NotImplementedError(
+                'QualityFocalLoss for GroundingDINOHead is not supported yet.')
+        else:
+            loss_cls = self.loss_cls(
+                cls_scores, labels, label_weights, avg_factor=cls_avg_factor)
+
+        # Compute the average number of gt boxes across all gpus, for
+        # normalization purposes
+        num_total_pos = loss_cls.new_tensor([num_total_pos])
+        num_total_pos = torch.clamp(reduce_mean(num_total_pos), min=1).item()
+
+        # construct factors used for rescale bboxes
+        factors = []
+        for img_meta, bbox_pred in zip(batch_img_metas, bbox_preds):
+            img_h, img_w, = img_meta['img_shape']
+            factor = bbox_pred.new_tensor([img_w, img_h, img_w,
+                                           img_h]).unsqueeze(0).repeat(
+                                               bbox_pred.size(0), 1)
+            factors.append(factor)
+        factors = torch.cat(factors, 0)
+
+        # DETR regress the relative position of boxes (cxcywh) in the image,
+        # thus the learning target is normalized by the image size. So here
+        # we need to re-scale them for calculating IoU loss
+        bbox_preds = bbox_preds.reshape(-1, 4)
+        bboxes = bbox_cxcywh_to_xyxy(bbox_preds) * factors
+        bboxes_gt = bbox_cxcywh_to_xyxy(bbox_targets) * factors
+
+        # regression IoU loss, defaultly GIoU loss
+        loss_iou = self.loss_iou(
+            bboxes, bboxes_gt, bbox_weights, avg_factor=num_total_pos)
+
+        # regression L1 loss
+        loss_bbox = self.loss_bbox(
+            bbox_preds, bbox_targets, bbox_weights, avg_factor=num_total_pos)
+        return loss_cls, loss_bbox, loss_iou
+
+    def _loss_dn_single(self, dn_cls_scores: Tensor, dn_bbox_preds: Tensor,
+                        batch_gt_instances: InstanceList,
+                        batch_img_metas: List[dict],
+                        dn_meta: Dict[str, int]) -> Tuple[Tensor]:
+        """Denoising loss for outputs from a single decoder layer.
+
+        Args:
+            dn_cls_scores (Tensor): Classification scores of a single decoder
+                layer in denoising part, has shape (bs, num_denoising_queries,
+                cls_out_channels).
+            dn_bbox_preds (Tensor): Regression outputs of a single decoder
+                layer in denoising part. Each is a 4D-tensor with normalized
+                coordinate format (cx, cy, w, h) and has shape
+                (bs, num_denoising_queries, 4).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            dn_meta (Dict[str, int]): The dictionary saves information about
+              group collation, including 'num_denoising_queries' and
+              'num_denoising_groups'. It will be used for split outputs of
+              denoising and matching parts and loss calculation.
+
+        Returns:
+            Tuple[Tensor]: A tuple including `loss_cls`, `loss_box` and
+            `loss_iou`.
+        """
+        cls_reg_targets = self.get_dn_targets(batch_gt_instances,
+                                              batch_img_metas, dn_meta)
+        (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,
+         num_total_pos, num_total_neg) = cls_reg_targets
+        labels = torch.stack(labels_list, 0)
+        label_weights = torch.stack(label_weights_list, 0)
+        bbox_targets = torch.cat(bbox_targets_list, 0)
+        bbox_weights = torch.cat(bbox_weights_list, 0)
+        # ===== this change =====
+        # Loss is not computed for the padded regions of the text.
+        assert (self.text_masks.dim() == 2)
+        text_masks = self.text_masks.new_zeros(
+            (self.text_masks.size(0), self.max_text_len))
+        text_masks[:, :self.text_masks.size(1)] = self.text_masks
+        text_mask = (text_masks > 0).unsqueeze(1)
+        text_mask = text_mask.repeat(1, dn_cls_scores.size(1), 1)
+        cls_scores = torch.masked_select(dn_cls_scores, text_mask).contiguous()
+        labels = torch.masked_select(labels, text_mask)
+        label_weights = label_weights[...,
+                                      None].repeat(1, 1, text_mask.size(-1))
+        label_weights = torch.masked_select(label_weights, text_mask)
+        # =======================
+
+        # classification loss
+        # construct weighted avg_factor to match with the official DETR repo
+        cls_avg_factor = \
+            num_total_pos * 1.0 + num_total_neg * self.bg_cls_weight
+        if self.sync_cls_avg_factor:
+            cls_avg_factor = reduce_mean(
+                cls_scores.new_tensor([cls_avg_factor]))
+        cls_avg_factor = max(cls_avg_factor, 1)
+
+        if len(cls_scores) > 0:
+            if isinstance(self.loss_cls, QualityFocalLoss):
+                raise NotImplementedError('QualityFocalLoss is not supported')
+            else:
+                loss_cls = self.loss_cls(
+                    cls_scores,
+                    labels,
+                    label_weights,
+                    avg_factor=cls_avg_factor)
+        else:
+            loss_cls = torch.zeros(
+                1, dtype=cls_scores.dtype, device=cls_scores.device)
+
+        # Compute the average number of gt boxes across all gpus, for
+        # normalization purposes
+        num_total_pos = loss_cls.new_tensor([num_total_pos])
+        num_total_pos = torch.clamp(reduce_mean(num_total_pos), min=1).item()
+
+        # construct factors used for rescale bboxes
+        factors = []
+        for img_meta, bbox_pred in zip(batch_img_metas, dn_bbox_preds):
+            img_h, img_w = img_meta['img_shape']
+            factor = bbox_pred.new_tensor([img_w, img_h, img_w,
+                                           img_h]).unsqueeze(0).repeat(
+                                               bbox_pred.size(0), 1)
+            factors.append(factor)
+        factors = torch.cat(factors)
+
+        # DETR regress the relative position of boxes (cxcywh) in the image,
+        # thus the learning target is normalized by the image size. So here
+        # we need to re-scale them for calculating IoU loss
+        bbox_preds = dn_bbox_preds.reshape(-1, 4)
+        bboxes = bbox_cxcywh_to_xyxy(bbox_preds) * factors
+        bboxes_gt = bbox_cxcywh_to_xyxy(bbox_targets) * factors
+
+        # regression IoU loss, defaultly GIoU loss
+        loss_iou = self.loss_iou(
+            bboxes, bboxes_gt, bbox_weights, avg_factor=num_total_pos)
+
+        # regression L1 loss
+        loss_bbox = self.loss_bbox(
+            bbox_preds, bbox_targets, bbox_weights, avg_factor=num_total_pos)
+        return loss_cls, loss_bbox, loss_iou
+
+    def _get_dn_targets_single(self, gt_instances: InstanceData,
+                               img_meta: dict, dn_meta: Dict[str,
+                                                             int]) -> tuple:
+        """Get targets in denoising part for one image.
+
+        Args:
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It should includes ``bboxes`` and ``labels``
+                attributes.
+            img_meta (dict): Meta information for one image.
+            dn_meta (Dict[str, int]): The dictionary saves information about
+              group collation, including 'num_denoising_queries' and
+              'num_denoising_groups'. It will be used for split outputs of
+              denoising and matching parts and loss calculation.
+
+        Returns:
+            tuple[Tensor]: a tuple containing the following for one image.
+
+            - labels (Tensor): Labels of each image.
+            - label_weights (Tensor]): Label weights of each image.
+            - bbox_targets (Tensor): BBox targets of each image.
+            - bbox_weights (Tensor): BBox weights of each image.
+            - pos_inds (Tensor): Sampled positive indices for each image.
+            - neg_inds (Tensor): Sampled negative indices for each image.
+        """
+        gt_bboxes = gt_instances.bboxes
+        gt_labels = gt_instances.labels
+        num_groups = dn_meta['num_denoising_groups']
+        num_denoising_queries = dn_meta['num_denoising_queries']
+        num_queries_each_group = int(num_denoising_queries / num_groups)
+        device = gt_bboxes.device
+
+        if len(gt_labels) > 0:
+            t = torch.arange(len(gt_labels), dtype=torch.long, device=device)
+            t = t.unsqueeze(0).repeat(num_groups, 1)
+            pos_assigned_gt_inds = t.flatten()
+            pos_inds = torch.arange(
+                num_groups, dtype=torch.long, device=device)
+            pos_inds = pos_inds.unsqueeze(1) * num_queries_each_group + t
+            pos_inds = pos_inds.flatten()
+        else:
+            pos_inds = pos_assigned_gt_inds = \
+                gt_bboxes.new_tensor([], dtype=torch.long)
+
+        neg_inds = pos_inds + num_queries_each_group // 2
+        # label targets
+        # this change
+        labels = gt_bboxes.new_full((num_denoising_queries, self.max_text_len),
+                                    0,
+                                    dtype=torch.float32)
+        labels[pos_inds] = gt_instances.positive_maps[pos_assigned_gt_inds]
+        label_weights = gt_bboxes.new_ones(num_denoising_queries)
+
+        # bbox targets
+        bbox_targets = torch.zeros(num_denoising_queries, 4, device=device)
+        bbox_weights = torch.zeros(num_denoising_queries, 4, device=device)
+        bbox_weights[pos_inds] = 1.0
+        img_h, img_w = img_meta['img_shape']
+
+        # DETR regress the relative position of boxes (cxcywh) in the image.
+        # Thus the learning target should be normalized by the image size, also
+        # the box format should be converted from defaultly x1y1x2y2 to cxcywh.
+        factor = gt_bboxes.new_tensor([img_w, img_h, img_w,
+                                       img_h]).unsqueeze(0)
+        gt_bboxes_normalized = gt_bboxes / factor
+        gt_bboxes_targets = bbox_xyxy_to_cxcywh(gt_bboxes_normalized)
+        bbox_targets[pos_inds] = gt_bboxes_targets.repeat([num_groups, 1])
+
+        return (labels, label_weights, bbox_targets, bbox_weights, pos_inds,
+                neg_inds)
diff --git a/mmdetection/mmdet/models/dense_heads/guided_anchor_head.py b/mmdetection/mmdet/models/dense_heads/guided_anchor_head.py
new file mode 100644
index 00000000..59f6dd33
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/guided_anchor_head.py
@@ -0,0 +1,994 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Tuple
+
+import torch
+import torch.nn as nn
+from mmcv.ops import DeformConv2d, MaskedConv2d
+from mmengine.model import BaseModule
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.utils import (ConfigType, InstanceList, MultiConfig, OptConfigType,
+                         OptInstanceList)
+from ..layers import multiclass_nms
+from ..task_modules.prior_generators import anchor_inside_flags, calc_region
+from ..task_modules.samplers import PseudoSampler
+from ..utils import images_to_levels, multi_apply, unmap
+from .anchor_head import AnchorHead
+
+
+class FeatureAdaption(BaseModule):
+    """Feature Adaption Module.
+
+    Feature Adaption Module is implemented based on DCN v1.
+    It uses anchor shape prediction rather than feature map to
+    predict offsets of deform conv layer.
+
+    Args:
+        in_channels (int): Number of channels in the input feature map.
+        out_channels (int): Number of channels in the output feature map.
+        kernel_size (int): Deformable conv kernel size. Defaults to 3.
+        deform_groups (int): Deformable conv group size. Defaults to 4.
+        init_cfg (:obj:`ConfigDict` or list[:obj:`ConfigDict`] or dict or \
+            list[dict], optional): Initialization config dict.
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel_size: int = 3,
+        deform_groups: int = 4,
+        init_cfg: MultiConfig = dict(
+            type='Normal',
+            layer='Conv2d',
+            std=0.1,
+            override=dict(type='Normal', name='conv_adaption', std=0.01))
+    ) -> None:
+        super().__init__(init_cfg=init_cfg)
+        offset_channels = kernel_size * kernel_size * 2
+        self.conv_offset = nn.Conv2d(
+            2, deform_groups * offset_channels, 1, bias=False)
+        self.conv_adaption = DeformConv2d(
+            in_channels,
+            out_channels,
+            kernel_size=kernel_size,
+            padding=(kernel_size - 1) // 2,
+            deform_groups=deform_groups)
+        self.relu = nn.ReLU(inplace=True)
+
+    def forward(self, x: Tensor, shape: Tensor) -> Tensor:
+        offset = self.conv_offset(shape.detach())
+        x = self.relu(self.conv_adaption(x, offset))
+        return x
+
+
+@MODELS.register_module()
+class GuidedAnchorHead(AnchorHead):
+    """Guided-Anchor-based head (GA-RPN, GA-RetinaNet, etc.).
+
+    This GuidedAnchorHead will predict high-quality feature guided
+    anchors and locations where anchors will be kept in inference.
+    There are mainly 3 categories of bounding-boxes.
+
+    - Sampled 9 pairs for target assignment. (approxes)
+    - The square boxes where the predicted anchors are based on. (squares)
+    - Guided anchors.
+
+    Please refer to https://arxiv.org/abs/1901.03278 for more details.
+
+    Args:
+        num_classes (int): Number of classes.
+        in_channels (int): Number of channels in the input feature map.
+        feat_channels (int): Number of hidden channels. Defaults to 256.
+        approx_anchor_generator (:obj:`ConfigDict` or dict): Config dict
+            for approx generator
+        square_anchor_generator (:obj:`ConfigDict` or dict): Config dict
+            for square generator
+        anchor_coder (:obj:`ConfigDict` or dict): Config dict for anchor coder
+        bbox_coder (:obj:`ConfigDict` or dict): Config dict for bbox coder
+        reg_decoded_bbox (bool): If true, the regression loss would be
+            applied directly on decoded bounding boxes, converting both
+            the predicted boxes and regression targets to absolute
+            coordinates format. Defaults to False. It should be `True` when
+            using `IoULoss`, `GIoULoss`, or `DIoULoss` in the bbox head.
+        deform_groups: (int): Group number of DCN in FeatureAdaption module.
+            Defaults to 4.
+        loc_filter_thr (float): Threshold to filter out unconcerned regions.
+            Defaults to 0.01.
+        loss_loc (:obj:`ConfigDict` or dict): Config of location loss.
+        loss_shape (:obj:`ConfigDict` or dict): Config of anchor shape loss.
+        loss_cls (:obj:`ConfigDict` or dict): Config of classification loss.
+        loss_bbox (:obj:`ConfigDict` or dict): Config of bbox regression loss.
+        init_cfg (:obj:`ConfigDict` or list[:obj:`ConfigDict`] or dict or \
+            list[dict], optional): Initialization config dict.
+    """
+
+    def __init__(
+        self,
+        num_classes: int,
+        in_channels: int,
+        feat_channels: int = 256,
+        approx_anchor_generator: ConfigType = dict(
+            type='AnchorGenerator',
+            octave_base_scale=8,
+            scales_per_octave=3,
+            ratios=[0.5, 1.0, 2.0],
+            strides=[4, 8, 16, 32, 64]),
+        square_anchor_generator: ConfigType = dict(
+            type='AnchorGenerator',
+            ratios=[1.0],
+            scales=[8],
+            strides=[4, 8, 16, 32, 64]),
+        anchor_coder: ConfigType = dict(
+            type='DeltaXYWHBBoxCoder',
+            target_means=[.0, .0, .0, .0],
+            target_stds=[1.0, 1.0, 1.0, 1.0]),
+        bbox_coder: ConfigType = dict(
+            type='DeltaXYWHBBoxCoder',
+            target_means=[.0, .0, .0, .0],
+            target_stds=[1.0, 1.0, 1.0, 1.0]),
+        reg_decoded_bbox: bool = False,
+        deform_groups: int = 4,
+        loc_filter_thr: float = 0.01,
+        train_cfg: OptConfigType = None,
+        test_cfg: OptConfigType = None,
+        loss_loc: ConfigType = dict(
+            type='FocalLoss',
+            use_sigmoid=True,
+            gamma=2.0,
+            alpha=0.25,
+            loss_weight=1.0),
+        loss_shape: ConfigType = dict(
+            type='BoundedIoULoss', beta=0.2, loss_weight=1.0),
+        loss_cls: ConfigType = dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
+        loss_bbox: ConfigType = dict(
+            type='SmoothL1Loss', beta=1.0, loss_weight=1.0),
+        init_cfg: MultiConfig = dict(
+            type='Normal',
+            layer='Conv2d',
+            std=0.01,
+            override=dict(
+                type='Normal', name='conv_loc', std=0.01, lbias_prob=0.01))
+    ) -> None:
+        super(AnchorHead, self).__init__(init_cfg=init_cfg)
+        self.in_channels = in_channels
+        self.num_classes = num_classes
+        self.feat_channels = feat_channels
+        self.deform_groups = deform_groups
+        self.loc_filter_thr = loc_filter_thr
+
+        # build approx_anchor_generator and square_anchor_generator
+        assert (approx_anchor_generator['octave_base_scale'] ==
+                square_anchor_generator['scales'][0])
+        assert (approx_anchor_generator['strides'] ==
+                square_anchor_generator['strides'])
+        self.approx_anchor_generator = TASK_UTILS.build(
+            approx_anchor_generator)
+        self.square_anchor_generator = TASK_UTILS.build(
+            square_anchor_generator)
+        self.approxs_per_octave = self.approx_anchor_generator \
+            .num_base_priors[0]
+
+        self.reg_decoded_bbox = reg_decoded_bbox
+
+        # one anchor per location
+        self.num_base_priors = self.square_anchor_generator.num_base_priors[0]
+
+        self.use_sigmoid_cls = loss_cls.get('use_sigmoid', False)
+        self.loc_focal_loss = loss_loc['type'] in ['FocalLoss']
+        if self.use_sigmoid_cls:
+            self.cls_out_channels = self.num_classes
+        else:
+            self.cls_out_channels = self.num_classes + 1
+
+        # build bbox_coder
+        self.anchor_coder = TASK_UTILS.build(anchor_coder)
+        self.bbox_coder = TASK_UTILS.build(bbox_coder)
+
+        # build losses
+        self.loss_loc = MODELS.build(loss_loc)
+        self.loss_shape = MODELS.build(loss_shape)
+        self.loss_cls = MODELS.build(loss_cls)
+        self.loss_bbox = MODELS.build(loss_bbox)
+
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+
+        if self.train_cfg:
+            self.assigner = TASK_UTILS.build(self.train_cfg['assigner'])
+            # use PseudoSampler when no sampler in train_cfg
+            if train_cfg.get('sampler', None) is not None:
+                self.sampler = TASK_UTILS.build(
+                    self.train_cfg['sampler'], default_args=dict(context=self))
+            else:
+                self.sampler = PseudoSampler()
+
+            self.ga_assigner = TASK_UTILS.build(self.train_cfg['ga_assigner'])
+            if train_cfg.get('ga_sampler', None) is not None:
+                self.ga_sampler = TASK_UTILS.build(
+                    self.train_cfg['ga_sampler'],
+                    default_args=dict(context=self))
+            else:
+                self.ga_sampler = PseudoSampler()
+
+        self._init_layers()
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        self.relu = nn.ReLU(inplace=True)
+        self.conv_loc = nn.Conv2d(self.in_channels, 1, 1)
+        self.conv_shape = nn.Conv2d(self.in_channels, self.num_base_priors * 2,
+                                    1)
+        self.feature_adaption = FeatureAdaption(
+            self.in_channels,
+            self.feat_channels,
+            kernel_size=3,
+            deform_groups=self.deform_groups)
+        self.conv_cls = MaskedConv2d(
+            self.feat_channels, self.num_base_priors * self.cls_out_channels,
+            1)
+        self.conv_reg = MaskedConv2d(self.feat_channels,
+                                     self.num_base_priors * 4, 1)
+
+    def forward_single(self, x: Tensor) -> Tuple[Tensor]:
+        """Forward feature of a single scale level."""
+        loc_pred = self.conv_loc(x)
+        shape_pred = self.conv_shape(x)
+        x = self.feature_adaption(x, shape_pred)
+        # masked conv is only used during inference for speed-up
+        if not self.training:
+            mask = loc_pred.sigmoid()[0] >= self.loc_filter_thr
+        else:
+            mask = None
+        cls_score = self.conv_cls(x, mask)
+        bbox_pred = self.conv_reg(x, mask)
+        return cls_score, bbox_pred, shape_pred, loc_pred
+
+    def forward(self, x: List[Tensor]) -> Tuple[List[Tensor]]:
+        """Forward features from the upstream network."""
+        return multi_apply(self.forward_single, x)
+
+    def get_sampled_approxs(self,
+                            featmap_sizes: List[Tuple[int, int]],
+                            batch_img_metas: List[dict],
+                            device: str = 'cuda') -> tuple:
+        """Get sampled approxs and inside flags according to feature map sizes.
+
+        Args:
+            featmap_sizes (list[tuple]): Multi-level feature map sizes.
+            batch_img_metas (list[dict]): Image meta info.
+            device (str): device for returned tensors
+
+        Returns:
+            tuple: approxes of each image, inside flags of each image
+        """
+        num_imgs = len(batch_img_metas)
+
+        # since feature map sizes of all images are the same, we only compute
+        # approxes for one time
+        multi_level_approxs = self.approx_anchor_generator.grid_priors(
+            featmap_sizes, device=device)
+        approxs_list = [multi_level_approxs for _ in range(num_imgs)]
+
+        # for each image, we compute inside flags of multi level approxes
+        inside_flag_list = []
+        for img_id, img_meta in enumerate(batch_img_metas):
+            multi_level_flags = []
+            multi_level_approxs = approxs_list[img_id]
+
+            # obtain valid flags for each approx first
+            multi_level_approx_flags = self.approx_anchor_generator \
+                .valid_flags(featmap_sizes,
+                             img_meta['pad_shape'],
+                             device=device)
+
+            for i, flags in enumerate(multi_level_approx_flags):
+                approxs = multi_level_approxs[i]
+                inside_flags_list = []
+                for j in range(self.approxs_per_octave):
+                    split_valid_flags = flags[j::self.approxs_per_octave]
+                    split_approxs = approxs[j::self.approxs_per_octave, :]
+                    inside_flags = anchor_inside_flags(
+                        split_approxs, split_valid_flags,
+                        img_meta['img_shape'][:2],
+                        self.train_cfg['allowed_border'])
+                    inside_flags_list.append(inside_flags)
+                # inside_flag for a position is true if any anchor in this
+                # position is true
+                inside_flags = (
+                    torch.stack(inside_flags_list, 0).sum(dim=0) > 0)
+                multi_level_flags.append(inside_flags)
+            inside_flag_list.append(multi_level_flags)
+        return approxs_list, inside_flag_list
+
+    def get_anchors(self,
+                    featmap_sizes: List[Tuple[int, int]],
+                    shape_preds: List[Tensor],
+                    loc_preds: List[Tensor],
+                    batch_img_metas: List[dict],
+                    use_loc_filter: bool = False,
+                    device: str = 'cuda') -> tuple:
+        """Get squares according to feature map sizes and guided anchors.
+
+        Args:
+            featmap_sizes (list[tuple]): Multi-level feature map sizes.
+            shape_preds (list[tensor]): Multi-level shape predictions.
+            loc_preds (list[tensor]): Multi-level location predictions.
+            batch_img_metas (list[dict]): Image meta info.
+            use_loc_filter (bool): Use loc filter or not. Defaults to False
+            device (str): device for returned tensors.
+                Defaults to `cuda`.
+
+        Returns:
+            tuple: square approxs of each image, guided anchors of each image,
+            loc masks of each image.
+        """
+        num_imgs = len(batch_img_metas)
+        num_levels = len(featmap_sizes)
+
+        # since feature map sizes of all images are the same, we only compute
+        # squares for one time
+        multi_level_squares = self.square_anchor_generator.grid_priors(
+            featmap_sizes, device=device)
+        squares_list = [multi_level_squares for _ in range(num_imgs)]
+
+        # for each image, we compute multi level guided anchors
+        guided_anchors_list = []
+        loc_mask_list = []
+        for img_id, img_meta in enumerate(batch_img_metas):
+            multi_level_guided_anchors = []
+            multi_level_loc_mask = []
+            for i in range(num_levels):
+                squares = squares_list[img_id][i]
+                shape_pred = shape_preds[i][img_id]
+                loc_pred = loc_preds[i][img_id]
+                guided_anchors, loc_mask = self._get_guided_anchors_single(
+                    squares,
+                    shape_pred,
+                    loc_pred,
+                    use_loc_filter=use_loc_filter)
+                multi_level_guided_anchors.append(guided_anchors)
+                multi_level_loc_mask.append(loc_mask)
+            guided_anchors_list.append(multi_level_guided_anchors)
+            loc_mask_list.append(multi_level_loc_mask)
+        return squares_list, guided_anchors_list, loc_mask_list
+
+    def _get_guided_anchors_single(
+            self,
+            squares: Tensor,
+            shape_pred: Tensor,
+            loc_pred: Tensor,
+            use_loc_filter: bool = False) -> Tuple[Tensor]:
+        """Get guided anchors and loc masks for a single level.
+
+        Args:
+            squares (tensor): Squares of a single level.
+            shape_pred (tensor): Shape predictions of a single level.
+            loc_pred (tensor): Loc predictions of a single level.
+            use_loc_filter (list[tensor]): Use loc filter or not.
+                Defaults to False.
+
+        Returns:
+            tuple: guided anchors, location masks
+        """
+        # calculate location filtering mask
+        loc_pred = loc_pred.sigmoid().detach()
+        if use_loc_filter:
+            loc_mask = loc_pred >= self.loc_filter_thr
+        else:
+            loc_mask = loc_pred >= 0.0
+        mask = loc_mask.permute(1, 2, 0).expand(-1, -1, self.num_base_priors)
+        mask = mask.contiguous().view(-1)
+        # calculate guided anchors
+        squares = squares[mask]
+        anchor_deltas = shape_pred.permute(1, 2, 0).contiguous().view(
+            -1, 2).detach()[mask]
+        bbox_deltas = anchor_deltas.new_full(squares.size(), 0)
+        bbox_deltas[:, 2:] = anchor_deltas
+        guided_anchors = self.anchor_coder.decode(
+            squares, bbox_deltas, wh_ratio_clip=1e-6)
+        return guided_anchors, mask
+
+    def ga_loc_targets(self, batch_gt_instances: InstanceList,
+                       featmap_sizes: List[Tuple[int, int]]) -> tuple:
+        """Compute location targets for guided anchoring.
+
+        Each feature map is divided into positive, negative and ignore regions.
+        - positive regions: target 1, weight 1
+        - ignore regions: target 0, weight 0
+        - negative regions: target 0, weight 0.1
+
+        Args:
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            featmap_sizes (list[tuple]): Multi level sizes of each feature
+                maps.
+
+        Returns:
+            tuple: Returns a tuple containing location targets.
+        """
+        anchor_scale = self.approx_anchor_generator.octave_base_scale
+        anchor_strides = self.approx_anchor_generator.strides
+        # Currently only supports same stride in x and y direction.
+        for stride in anchor_strides:
+            assert (stride[0] == stride[1])
+        anchor_strides = [stride[0] for stride in anchor_strides]
+
+        center_ratio = self.train_cfg['center_ratio']
+        ignore_ratio = self.train_cfg['ignore_ratio']
+        img_per_gpu = len(batch_gt_instances)
+        num_lvls = len(featmap_sizes)
+        r1 = (1 - center_ratio) / 2
+        r2 = (1 - ignore_ratio) / 2
+        all_loc_targets = []
+        all_loc_weights = []
+        all_ignore_map = []
+        for lvl_id in range(num_lvls):
+            h, w = featmap_sizes[lvl_id]
+            loc_targets = torch.zeros(
+                img_per_gpu,
+                1,
+                h,
+                w,
+                device=batch_gt_instances[0].bboxes.device,
+                dtype=torch.float32)
+            loc_weights = torch.full_like(loc_targets, -1)
+            ignore_map = torch.zeros_like(loc_targets)
+            all_loc_targets.append(loc_targets)
+            all_loc_weights.append(loc_weights)
+            all_ignore_map.append(ignore_map)
+        for img_id in range(img_per_gpu):
+            gt_bboxes = batch_gt_instances[img_id].bboxes
+            scale = torch.sqrt((gt_bboxes[:, 2] - gt_bboxes[:, 0]) *
+                               (gt_bboxes[:, 3] - gt_bboxes[:, 1]))
+            min_anchor_size = scale.new_full(
+                (1, ), float(anchor_scale * anchor_strides[0]))
+            # assign gt bboxes to different feature levels w.r.t. their scales
+            target_lvls = torch.floor(
+                torch.log2(scale) - torch.log2(min_anchor_size) + 0.5)
+            target_lvls = target_lvls.clamp(min=0, max=num_lvls - 1).long()
+            for gt_id in range(gt_bboxes.size(0)):
+                lvl = target_lvls[gt_id].item()
+                # rescaled to corresponding feature map
+                gt_ = gt_bboxes[gt_id, :4] / anchor_strides[lvl]
+                # calculate ignore regions
+                ignore_x1, ignore_y1, ignore_x2, ignore_y2 = calc_region(
+                    gt_, r2, featmap_sizes[lvl])
+                # calculate positive (center) regions
+                ctr_x1, ctr_y1, ctr_x2, ctr_y2 = calc_region(
+                    gt_, r1, featmap_sizes[lvl])
+                all_loc_targets[lvl][img_id, 0, ctr_y1:ctr_y2 + 1,
+                                     ctr_x1:ctr_x2 + 1] = 1
+                all_loc_weights[lvl][img_id, 0, ignore_y1:ignore_y2 + 1,
+                                     ignore_x1:ignore_x2 + 1] = 0
+                all_loc_weights[lvl][img_id, 0, ctr_y1:ctr_y2 + 1,
+                                     ctr_x1:ctr_x2 + 1] = 1
+                # calculate ignore map on nearby low level feature
+                if lvl > 0:
+                    d_lvl = lvl - 1
+                    # rescaled to corresponding feature map
+                    gt_ = gt_bboxes[gt_id, :4] / anchor_strides[d_lvl]
+                    ignore_x1, ignore_y1, ignore_x2, ignore_y2 = calc_region(
+                        gt_, r2, featmap_sizes[d_lvl])
+                    all_ignore_map[d_lvl][img_id, 0, ignore_y1:ignore_y2 + 1,
+                                          ignore_x1:ignore_x2 + 1] = 1
+                # calculate ignore map on nearby high level feature
+                if lvl < num_lvls - 1:
+                    u_lvl = lvl + 1
+                    # rescaled to corresponding feature map
+                    gt_ = gt_bboxes[gt_id, :4] / anchor_strides[u_lvl]
+                    ignore_x1, ignore_y1, ignore_x2, ignore_y2 = calc_region(
+                        gt_, r2, featmap_sizes[u_lvl])
+                    all_ignore_map[u_lvl][img_id, 0, ignore_y1:ignore_y2 + 1,
+                                          ignore_x1:ignore_x2 + 1] = 1
+        for lvl_id in range(num_lvls):
+            # ignore negative regions w.r.t. ignore map
+            all_loc_weights[lvl_id][(all_loc_weights[lvl_id] < 0)
+                                    & (all_ignore_map[lvl_id] > 0)] = 0
+            # set negative regions with weight 0.1
+            all_loc_weights[lvl_id][all_loc_weights[lvl_id] < 0] = 0.1
+        # loc average factor to balance loss
+        loc_avg_factor = sum(
+            [t.size(0) * t.size(-1) * t.size(-2)
+             for t in all_loc_targets]) / 200
+        return all_loc_targets, all_loc_weights, loc_avg_factor
+
+    def _ga_shape_target_single(self,
+                                flat_approxs: Tensor,
+                                inside_flags: Tensor,
+                                flat_squares: Tensor,
+                                gt_instances: InstanceData,
+                                gt_instances_ignore: Optional[InstanceData],
+                                img_meta: dict,
+                                unmap_outputs: bool = True) -> tuple:
+        """Compute guided anchoring targets.
+
+        This function returns sampled anchors and gt bboxes directly
+        rather than calculates regression targets.
+
+        Args:
+            flat_approxs (Tensor): flat approxs of a single image,
+                shape (n, 4)
+            inside_flags (Tensor): inside flags of a single image,
+                shape (n, ).
+            flat_squares (Tensor): flat squares of a single image,
+                shape (approxs_per_octave * n, 4)
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            gt_instances_ignore (:obj:`InstanceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+            img_meta (dict): Meta info of a single image.
+            unmap_outputs (bool): unmap outputs or not.
+
+        Returns:
+            tuple: Returns a tuple containing shape targets of each image.
+        """
+        if not inside_flags.any():
+            raise ValueError(
+                'There is no valid anchor inside the image boundary. Please '
+                'check the image size and anchor sizes, or set '
+                '``allowed_border`` to -1 to skip the condition.')
+        # assign gt and sample anchors
+        num_square = flat_squares.size(0)
+        approxs = flat_approxs.view(num_square, self.approxs_per_octave, 4)
+        approxs = approxs[inside_flags, ...]
+        squares = flat_squares[inside_flags, :]
+
+        pred_instances = InstanceData()
+        pred_instances.priors = squares
+        pred_instances.approxs = approxs
+
+        assign_result = self.ga_assigner.assign(
+            pred_instances=pred_instances,
+            gt_instances=gt_instances,
+            gt_instances_ignore=gt_instances_ignore)
+        sampling_result = self.ga_sampler.sample(
+            assign_result=assign_result,
+            pred_instances=pred_instances,
+            gt_instances=gt_instances)
+
+        bbox_anchors = torch.zeros_like(squares)
+        bbox_gts = torch.zeros_like(squares)
+        bbox_weights = torch.zeros_like(squares)
+
+        pos_inds = sampling_result.pos_inds
+        neg_inds = sampling_result.neg_inds
+        if len(pos_inds) > 0:
+            bbox_anchors[pos_inds, :] = sampling_result.pos_bboxes
+            bbox_gts[pos_inds, :] = sampling_result.pos_gt_bboxes
+            bbox_weights[pos_inds, :] = 1.0
+
+        # map up to original set of anchors
+        if unmap_outputs:
+            num_total_anchors = flat_squares.size(0)
+            bbox_anchors = unmap(bbox_anchors, num_total_anchors, inside_flags)
+            bbox_gts = unmap(bbox_gts, num_total_anchors, inside_flags)
+            bbox_weights = unmap(bbox_weights, num_total_anchors, inside_flags)
+
+        return (bbox_anchors, bbox_gts, bbox_weights, pos_inds, neg_inds,
+                sampling_result)
+
+    def ga_shape_targets(self,
+                         approx_list: List[List[Tensor]],
+                         inside_flag_list: List[List[Tensor]],
+                         square_list: List[List[Tensor]],
+                         batch_gt_instances: InstanceList,
+                         batch_img_metas: List[dict],
+                         batch_gt_instances_ignore: OptInstanceList = None,
+                         unmap_outputs: bool = True) -> tuple:
+        """Compute guided anchoring targets.
+
+        Args:
+            approx_list (list[list[Tensor]]): Multi level approxs of each
+                image.
+            inside_flag_list (list[list[Tensor]]): Multi level inside flags
+                of each image.
+            square_list (list[list[Tensor]]): Multi level squares of each
+                image.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+            unmap_outputs (bool): unmap outputs or not. Defaults to None.
+
+        Returns:
+            tuple:  Returns a tuple containing shape targets.
+        """
+        num_imgs = len(batch_img_metas)
+        assert len(approx_list) == len(inside_flag_list) == len(
+            square_list) == num_imgs
+        # anchor number of multi levels
+        num_level_squares = [squares.size(0) for squares in square_list[0]]
+        # concat all level anchors and flags to a single tensor
+        inside_flag_flat_list = []
+        approx_flat_list = []
+        square_flat_list = []
+        for i in range(num_imgs):
+            assert len(square_list[i]) == len(inside_flag_list[i])
+            inside_flag_flat_list.append(torch.cat(inside_flag_list[i]))
+            approx_flat_list.append(torch.cat(approx_list[i]))
+            square_flat_list.append(torch.cat(square_list[i]))
+
+        # compute targets for each image
+        if batch_gt_instances_ignore is None:
+            batch_gt_instances_ignore = [None for _ in range(num_imgs)]
+        (all_bbox_anchors, all_bbox_gts, all_bbox_weights, pos_inds_list,
+         neg_inds_list, sampling_results_list) = multi_apply(
+             self._ga_shape_target_single,
+             approx_flat_list,
+             inside_flag_flat_list,
+             square_flat_list,
+             batch_gt_instances,
+             batch_gt_instances_ignore,
+             batch_img_metas,
+             unmap_outputs=unmap_outputs)
+        # sampled anchors of all images
+        avg_factor = sum(
+            [results.avg_factor for results in sampling_results_list])
+        # split targets to a list w.r.t. multiple levels
+        bbox_anchors_list = images_to_levels(all_bbox_anchors,
+                                             num_level_squares)
+        bbox_gts_list = images_to_levels(all_bbox_gts, num_level_squares)
+        bbox_weights_list = images_to_levels(all_bbox_weights,
+                                             num_level_squares)
+        return (bbox_anchors_list, bbox_gts_list, bbox_weights_list,
+                avg_factor)
+
+    def loss_shape_single(self, shape_pred: Tensor, bbox_anchors: Tensor,
+                          bbox_gts: Tensor, anchor_weights: Tensor,
+                          avg_factor: int) -> Tensor:
+        """Compute shape loss in single level."""
+        shape_pred = shape_pred.permute(0, 2, 3, 1).contiguous().view(-1, 2)
+        bbox_anchors = bbox_anchors.contiguous().view(-1, 4)
+        bbox_gts = bbox_gts.contiguous().view(-1, 4)
+        anchor_weights = anchor_weights.contiguous().view(-1, 4)
+        bbox_deltas = bbox_anchors.new_full(bbox_anchors.size(), 0)
+        bbox_deltas[:, 2:] += shape_pred
+        # filter out negative samples to speed-up weighted_bounded_iou_loss
+        inds = torch.nonzero(
+            anchor_weights[:, 0] > 0, as_tuple=False).squeeze(1)
+        bbox_deltas_ = bbox_deltas[inds]
+        bbox_anchors_ = bbox_anchors[inds]
+        bbox_gts_ = bbox_gts[inds]
+        anchor_weights_ = anchor_weights[inds]
+        pred_anchors_ = self.anchor_coder.decode(
+            bbox_anchors_, bbox_deltas_, wh_ratio_clip=1e-6)
+        loss_shape = self.loss_shape(
+            pred_anchors_, bbox_gts_, anchor_weights_, avg_factor=avg_factor)
+        return loss_shape
+
+    def loss_loc_single(self, loc_pred: Tensor, loc_target: Tensor,
+                        loc_weight: Tensor, avg_factor: float) -> Tensor:
+        """Compute location loss in single level."""
+        loss_loc = self.loss_loc(
+            loc_pred.reshape(-1, 1),
+            loc_target.reshape(-1).long(),
+            loc_weight.reshape(-1),
+            avg_factor=avg_factor)
+        return loss_loc
+
+    def loss_by_feat(
+            self,
+            cls_scores: List[Tensor],
+            bbox_preds: List[Tensor],
+            shape_preds: List[Tensor],
+            loc_preds: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> dict:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level
+                has shape (N, num_anchors * num_classes, H, W).
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level with shape (N, num_anchors * 4, H, W).
+            shape_preds (list[Tensor]): shape predictions for each scale
+                level with shape (N, 1, H, W).
+            loc_preds (list[Tensor]): location predictions for each scale
+                level with shape (N, num_anchors * 2, H, W).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        assert len(featmap_sizes) == self.approx_anchor_generator.num_levels
+
+        device = cls_scores[0].device
+
+        # get loc targets
+        loc_targets, loc_weights, loc_avg_factor = self.ga_loc_targets(
+            batch_gt_instances, featmap_sizes)
+
+        # get sampled approxes
+        approxs_list, inside_flag_list = self.get_sampled_approxs(
+            featmap_sizes, batch_img_metas, device=device)
+        # get squares and guided anchors
+        squares_list, guided_anchors_list, _ = self.get_anchors(
+            featmap_sizes,
+            shape_preds,
+            loc_preds,
+            batch_img_metas,
+            device=device)
+
+        # get shape targets
+        shape_targets = self.ga_shape_targets(approxs_list, inside_flag_list,
+                                              squares_list, batch_gt_instances,
+                                              batch_img_metas)
+        (bbox_anchors_list, bbox_gts_list, anchor_weights_list,
+         ga_avg_factor) = shape_targets
+
+        # get anchor targets
+        cls_reg_targets = self.get_targets(
+            guided_anchors_list,
+            inside_flag_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore)
+        (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,
+         avg_factor) = cls_reg_targets
+
+        # anchor number of multi levels
+        num_level_anchors = [
+            anchors.size(0) for anchors in guided_anchors_list[0]
+        ]
+        # concat all level anchors to a single tensor
+        concat_anchor_list = []
+        for i in range(len(guided_anchors_list)):
+            concat_anchor_list.append(torch.cat(guided_anchors_list[i]))
+        all_anchor_list = images_to_levels(concat_anchor_list,
+                                           num_level_anchors)
+
+        # get classification and bbox regression losses
+        losses_cls, losses_bbox = multi_apply(
+            self.loss_by_feat_single,
+            cls_scores,
+            bbox_preds,
+            all_anchor_list,
+            labels_list,
+            label_weights_list,
+            bbox_targets_list,
+            bbox_weights_list,
+            avg_factor=avg_factor)
+
+        # get anchor location loss
+        losses_loc = []
+        for i in range(len(loc_preds)):
+            loss_loc = self.loss_loc_single(
+                loc_preds[i],
+                loc_targets[i],
+                loc_weights[i],
+                avg_factor=loc_avg_factor)
+            losses_loc.append(loss_loc)
+
+        # get anchor shape loss
+        losses_shape = []
+        for i in range(len(shape_preds)):
+            loss_shape = self.loss_shape_single(
+                shape_preds[i],
+                bbox_anchors_list[i],
+                bbox_gts_list[i],
+                anchor_weights_list[i],
+                avg_factor=ga_avg_factor)
+            losses_shape.append(loss_shape)
+
+        return dict(
+            loss_cls=losses_cls,
+            loss_bbox=losses_bbox,
+            loss_shape=losses_shape,
+            loss_loc=losses_loc)
+
+    def predict_by_feat(self,
+                        cls_scores: List[Tensor],
+                        bbox_preds: List[Tensor],
+                        shape_preds: List[Tensor],
+                        loc_preds: List[Tensor],
+                        batch_img_metas: List[dict],
+                        cfg: OptConfigType = None,
+                        rescale: bool = False) -> InstanceList:
+        """Transform a batch of output features extracted from the head into
+        bbox results.
+
+        Args:
+            cls_scores (list[Tensor]): Classification scores for all
+                scale levels, each is a 4D-tensor, has shape
+                (batch_size, num_priors * num_classes, H, W).
+            bbox_preds (list[Tensor]): Box energies / deltas for all
+                scale levels, each is a 4D-tensor, has shape
+                (batch_size, num_priors * 4, H, W).
+            shape_preds (list[Tensor]): shape predictions for each scale
+                level with shape (N, 1, H, W).
+            loc_preds (list[Tensor]): location predictions for each scale
+                level with shape (N, num_anchors * 2, H, W).
+            batch_img_metas (list[dict], Optional): Batch image meta info.
+                Defaults to None.
+            cfg (ConfigDict, optional): Test / postprocessing
+                configuration, if None, test_cfg would be used.
+                Defaults to None.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Object detection results of each image
+            after the post process. Each item usually contains following keys.
+
+            - scores (Tensor): Classification scores, has a shape
+              (num_instance, )
+            - labels (Tensor): Labels of bboxes, has a shape (num_instances, ).
+            - bboxes (Tensor): Has a shape (num_instances, 4), the last
+              dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        assert len(cls_scores) == len(bbox_preds) == len(shape_preds) == len(
+            loc_preds)
+        num_levels = len(cls_scores)
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        device = cls_scores[0].device
+        # get guided anchors
+        _, guided_anchors, loc_masks = self.get_anchors(
+            featmap_sizes,
+            shape_preds,
+            loc_preds,
+            batch_img_metas,
+            use_loc_filter=not self.training,
+            device=device)
+        result_list = []
+        for img_id in range(len(batch_img_metas)):
+            cls_score_list = [
+                cls_scores[i][img_id].detach() for i in range(num_levels)
+            ]
+            bbox_pred_list = [
+                bbox_preds[i][img_id].detach() for i in range(num_levels)
+            ]
+            guided_anchor_list = [
+                guided_anchors[img_id][i].detach() for i in range(num_levels)
+            ]
+            loc_mask_list = [
+                loc_masks[img_id][i].detach() for i in range(num_levels)
+            ]
+            proposals = self._predict_by_feat_single(
+                cls_scores=cls_score_list,
+                bbox_preds=bbox_pred_list,
+                mlvl_anchors=guided_anchor_list,
+                mlvl_masks=loc_mask_list,
+                img_meta=batch_img_metas[img_id],
+                cfg=cfg,
+                rescale=rescale)
+            result_list.append(proposals)
+        return result_list
+
+    def _predict_by_feat_single(self,
+                                cls_scores: List[Tensor],
+                                bbox_preds: List[Tensor],
+                                mlvl_anchors: List[Tensor],
+                                mlvl_masks: List[Tensor],
+                                img_meta: dict,
+                                cfg: ConfigType,
+                                rescale: bool = False) -> InstanceData:
+        """Transform a single image's features extracted from the head into
+        bbox results.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores from all scale
+                levels of a single image, each item has shape
+                (num_priors * num_classes, H, W).
+            bbox_preds (list[Tensor]): Box energies / deltas from
+                all scale levels of a single image, each item has shape
+                (num_priors * 4, H, W).
+            mlvl_anchors (list[Tensor]): Each element in the list is
+                the anchors of a single level in feature pyramid. it has
+                shape (num_priors, 4).
+            mlvl_masks (list[Tensor]): Each element in the list is location
+                masks of a single level.
+            img_meta (dict): Image meta info.
+            cfg (:obj:`ConfigDict` or dict): Test / postprocessing
+                configuration, if None, test_cfg would be used.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+            - scores (Tensor): Classification scores, has a shape
+              (num_instance, )
+            - labels (Tensor): Labels of bboxes, has a shape (num_instances, ).
+            - bboxes (Tensor): Has a shape (num_instances, 4), the last
+              dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        cfg = self.test_cfg if cfg is None else cfg
+        assert len(cls_scores) == len(bbox_preds) == len(mlvl_anchors)
+        mlvl_bbox_preds = []
+        mlvl_valid_anchors = []
+        mlvl_scores = []
+        for cls_score, bbox_pred, anchors, mask in zip(cls_scores, bbox_preds,
+                                                       mlvl_anchors,
+                                                       mlvl_masks):
+            assert cls_score.size()[-2:] == bbox_pred.size()[-2:]
+            # if no location is kept, end.
+            if mask.sum() == 0:
+                continue
+            # reshape scores and bbox_pred
+            cls_score = cls_score.permute(1, 2,
+                                          0).reshape(-1, self.cls_out_channels)
+            if self.use_sigmoid_cls:
+                scores = cls_score.sigmoid()
+            else:
+                scores = cls_score.softmax(-1)
+            bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, 4)
+            # filter scores, bbox_pred w.r.t. mask.
+            # anchors are filtered in get_anchors() beforehand.
+            scores = scores[mask, :]
+            bbox_pred = bbox_pred[mask, :]
+            if scores.dim() == 0:
+                anchors = anchors.unsqueeze(0)
+                scores = scores.unsqueeze(0)
+                bbox_pred = bbox_pred.unsqueeze(0)
+            # filter anchors, bbox_pred, scores w.r.t. scores
+            nms_pre = cfg.get('nms_pre', -1)
+            if nms_pre > 0 and scores.shape[0] > nms_pre:
+                if self.use_sigmoid_cls:
+                    max_scores, _ = scores.max(dim=1)
+                else:
+                    # remind that we set FG labels to [0, num_class-1]
+                    # since mmdet v2.0
+                    # BG cat_id: num_class
+                    max_scores, _ = scores[:, :-1].max(dim=1)
+                _, topk_inds = max_scores.topk(nms_pre)
+                anchors = anchors[topk_inds, :]
+                bbox_pred = bbox_pred[topk_inds, :]
+                scores = scores[topk_inds, :]
+
+            mlvl_bbox_preds.append(bbox_pred)
+            mlvl_valid_anchors.append(anchors)
+            mlvl_scores.append(scores)
+
+        mlvl_bbox_preds = torch.cat(mlvl_bbox_preds)
+        mlvl_anchors = torch.cat(mlvl_valid_anchors)
+        mlvl_scores = torch.cat(mlvl_scores)
+        mlvl_bboxes = self.bbox_coder.decode(
+            mlvl_anchors, mlvl_bbox_preds, max_shape=img_meta['img_shape'])
+
+        if rescale:
+            assert img_meta.get('scale_factor') is not None
+            mlvl_bboxes /= mlvl_bboxes.new_tensor(
+                img_meta['scale_factor']).repeat((1, 2))
+
+        if self.use_sigmoid_cls:
+            # Add a dummy background class to the backend when using sigmoid
+            # remind that we set FG labels to [0, num_class-1] since mmdet v2.0
+            # BG cat_id: num_class
+            padding = mlvl_scores.new_zeros(mlvl_scores.shape[0], 1)
+            mlvl_scores = torch.cat([mlvl_scores, padding], dim=1)
+        # multi class NMS
+        det_bboxes, det_labels = multiclass_nms(mlvl_bboxes, mlvl_scores,
+                                                cfg.score_thr, cfg.nms,
+                                                cfg.max_per_img)
+
+        results = InstanceData()
+        results.bboxes = det_bboxes[:, :-1]
+        results.scores = det_bboxes[:, -1]
+        results.labels = det_labels
+        return results
diff --git a/mmdetection/mmdet/models/dense_heads/lad_head.py b/mmdetection/mmdet/models/dense_heads/lad_head.py
new file mode 100644
index 00000000..d1218e1f
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/lad_head.py
@@ -0,0 +1,226 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional
+
+import torch
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.structures.bbox import bbox_overlaps
+from mmdet.utils import InstanceList, OptInstanceList
+from ..utils import levels_to_images, multi_apply, unpack_gt_instances
+from .paa_head import PAAHead
+
+
+@MODELS.register_module()
+class LADHead(PAAHead):
+    """Label Assignment Head from the paper: `Improving Object Detection by
+    Label Assignment Distillation `_"""
+
+    def get_label_assignment(
+            self,
+            cls_scores: List[Tensor],
+            bbox_preds: List[Tensor],
+            iou_preds: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> tuple:
+        """Get label assignment (from teacher).
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level
+                Has shape (N, num_anchors * num_classes, H, W)
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level with shape (N, num_anchors * 4, H, W)
+            iou_preds (list[Tensor]): iou_preds for each scale
+                level with shape (N, num_anchors * 1, H, W)
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            tuple: Returns a tuple containing label assignment variables.
+
+            - labels (Tensor): Labels of all anchors, each with
+              shape (num_anchors,).
+            - labels_weight (Tensor): Label weights of all anchor.
+              each with shape (num_anchors,).
+            - bboxes_target (Tensor): BBox targets of all anchors.
+              each with shape (num_anchors, 4).
+            - bboxes_weight (Tensor): BBox weights of all anchors.
+              each with shape (num_anchors, 4).
+            - pos_inds_flatten (Tensor): Contains all index of positive
+              sample in all anchor.
+            - pos_anchors (Tensor): Positive anchors.
+            - num_pos (int): Number of positive anchors.
+        """
+
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        assert len(featmap_sizes) == self.prior_generator.num_levels
+
+        device = cls_scores[0].device
+        anchor_list, valid_flag_list = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+        cls_reg_targets = self.get_targets(
+            anchor_list,
+            valid_flag_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore,
+        )
+        (labels, labels_weight, bboxes_target, bboxes_weight, pos_inds,
+         pos_gt_index) = cls_reg_targets
+        cls_scores = levels_to_images(cls_scores)
+        cls_scores = [
+            item.reshape(-1, self.cls_out_channels) for item in cls_scores
+        ]
+        bbox_preds = levels_to_images(bbox_preds)
+        bbox_preds = [item.reshape(-1, 4) for item in bbox_preds]
+        pos_losses_list, = multi_apply(self.get_pos_loss, anchor_list,
+                                       cls_scores, bbox_preds, labels,
+                                       labels_weight, bboxes_target,
+                                       bboxes_weight, pos_inds)
+
+        with torch.no_grad():
+            reassign_labels, reassign_label_weight, \
+                reassign_bbox_weights, num_pos = multi_apply(
+                    self.paa_reassign,
+                    pos_losses_list,
+                    labels,
+                    labels_weight,
+                    bboxes_weight,
+                    pos_inds,
+                    pos_gt_index,
+                    anchor_list)
+            num_pos = sum(num_pos)
+        # convert all tensor list to a flatten tensor
+        labels = torch.cat(reassign_labels, 0).view(-1)
+        flatten_anchors = torch.cat(
+            [torch.cat(item, 0) for item in anchor_list])
+        labels_weight = torch.cat(reassign_label_weight, 0).view(-1)
+        bboxes_target = torch.cat(bboxes_target,
+                                  0).view(-1, bboxes_target[0].size(-1))
+
+        pos_inds_flatten = ((labels >= 0)
+                            &
+                            (labels < self.num_classes)).nonzero().reshape(-1)
+
+        if num_pos:
+            pos_anchors = flatten_anchors[pos_inds_flatten]
+        else:
+            pos_anchors = None
+
+        label_assignment_results = (labels, labels_weight, bboxes_target,
+                                    bboxes_weight, pos_inds_flatten,
+                                    pos_anchors, num_pos)
+        return label_assignment_results
+
+    def loss(self, x: List[Tensor], label_assignment_results: tuple,
+             batch_data_samples: SampleList) -> dict:
+        """Forward train with the available label assignment (student receives
+        from teacher).
+
+        Args:
+            x (list[Tensor]): Features from FPN.
+            label_assignment_results (tuple): As the outputs defined in the
+                function `self.get_label_assignment`.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            losses: (dict[str, Tensor]): A dictionary of loss components.
+        """
+        outputs = unpack_gt_instances(batch_data_samples)
+        batch_gt_instances, batch_gt_instances_ignore, batch_img_metas \
+            = outputs
+
+        outs = self(x)
+        loss_inputs = outs + (batch_gt_instances, batch_img_metas)
+        losses = self.loss_by_feat(
+            *loss_inputs,
+            batch_gt_instances_ignore=batch_gt_instances_ignore,
+            label_assignment_results=label_assignment_results)
+        return losses
+
+    def loss_by_feat(self,
+                     cls_scores: List[Tensor],
+                     bbox_preds: List[Tensor],
+                     iou_preds: List[Tensor],
+                     batch_gt_instances: InstanceList,
+                     batch_img_metas: List[dict],
+                     batch_gt_instances_ignore: OptInstanceList = None,
+                     label_assignment_results: Optional[tuple] = None) -> dict:
+        """Compute losses of the head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level
+                Has shape (N, num_anchors * num_classes, H, W)
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level with shape (N, num_anchors * 4, H, W)
+            iou_preds (list[Tensor]): iou_preds for each scale
+                level with shape (N, num_anchors * 1, H, W)
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+            label_assignment_results (tuple, optional): As the outputs defined
+                in the function `self.get_
+                label_assignment`.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss gmm_assignment.
+        """
+
+        (labels, labels_weight, bboxes_target, bboxes_weight, pos_inds_flatten,
+         pos_anchors, num_pos) = label_assignment_results
+
+        cls_scores = levels_to_images(cls_scores)
+        cls_scores = [
+            item.reshape(-1, self.cls_out_channels) for item in cls_scores
+        ]
+        bbox_preds = levels_to_images(bbox_preds)
+        bbox_preds = [item.reshape(-1, 4) for item in bbox_preds]
+        iou_preds = levels_to_images(iou_preds)
+        iou_preds = [item.reshape(-1, 1) for item in iou_preds]
+
+        # convert all tensor list to a flatten tensor
+        cls_scores = torch.cat(cls_scores, 0).view(-1, cls_scores[0].size(-1))
+        bbox_preds = torch.cat(bbox_preds, 0).view(-1, bbox_preds[0].size(-1))
+        iou_preds = torch.cat(iou_preds, 0).view(-1, iou_preds[0].size(-1))
+
+        losses_cls = self.loss_cls(
+            cls_scores,
+            labels,
+            labels_weight,
+            avg_factor=max(num_pos, len(batch_img_metas)))  # avoid num_pos=0
+        if num_pos:
+            pos_bbox_pred = self.bbox_coder.decode(
+                pos_anchors, bbox_preds[pos_inds_flatten])
+            pos_bbox_target = bboxes_target[pos_inds_flatten]
+            iou_target = bbox_overlaps(
+                pos_bbox_pred.detach(), pos_bbox_target, is_aligned=True)
+            losses_iou = self.loss_centerness(
+                iou_preds[pos_inds_flatten],
+                iou_target.unsqueeze(-1),
+                avg_factor=num_pos)
+            losses_bbox = self.loss_bbox(
+                pos_bbox_pred, pos_bbox_target, avg_factor=num_pos)
+
+        else:
+            losses_iou = iou_preds.sum() * 0
+            losses_bbox = bbox_preds.sum() * 0
+
+        return dict(
+            loss_cls=losses_cls, loss_bbox=losses_bbox, loss_iou=losses_iou)
diff --git a/mmdetection/mmdet/models/dense_heads/ld_head.py b/mmdetection/mmdet/models/dense_heads/ld_head.py
new file mode 100644
index 00000000..2558fac9
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/ld_head.py
@@ -0,0 +1,257 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple
+
+import torch
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.structures.bbox import bbox_overlaps
+from mmdet.utils import ConfigType, InstanceList, OptInstanceList, reduce_mean
+from ..utils import multi_apply, unpack_gt_instances
+from .gfl_head import GFLHead
+
+
+@MODELS.register_module()
+class LDHead(GFLHead):
+    """Localization distillation Head. (Short description)
+
+    It utilizes the learned bbox distributions to transfer the localization
+    dark knowledge from teacher to student. Original paper: `Localization
+    Distillation for Object Detection. `_
+
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (int): Number of channels in the input feature map.
+        loss_ld (:obj:`ConfigDict` or dict): Config of Localization
+            Distillation Loss (LD), T is the temperature for distillation.
+    """
+
+    def __init__(self,
+                 num_classes: int,
+                 in_channels: int,
+                 loss_ld: ConfigType = dict(
+                     type='LocalizationDistillationLoss',
+                     loss_weight=0.25,
+                     T=10),
+                 **kwargs) -> dict:
+
+        super().__init__(
+            num_classes=num_classes, in_channels=in_channels, **kwargs)
+        self.loss_ld = MODELS.build(loss_ld)
+
+    def loss_by_feat_single(self, anchors: Tensor, cls_score: Tensor,
+                            bbox_pred: Tensor, labels: Tensor,
+                            label_weights: Tensor, bbox_targets: Tensor,
+                            stride: Tuple[int], soft_targets: Tensor,
+                            avg_factor: int):
+        """Calculate the loss of a single scale level based on the features
+        extracted by the detection head.
+
+        Args:
+            anchors (Tensor): Box reference for each scale level with shape
+                (N, num_total_anchors, 4).
+            cls_score (Tensor): Cls and quality joint scores for each scale
+                level has shape (N, num_classes, H, W).
+            bbox_pred (Tensor): Box distribution logits for each scale
+                level with shape (N, 4*(n+1), H, W), n is max value of integral
+                set.
+            labels (Tensor): Labels of each anchors with shape
+                (N, num_total_anchors).
+            label_weights (Tensor): Label weights of each anchor with shape
+                (N, num_total_anchors)
+            bbox_targets (Tensor): BBox regression targets of each anchor with
+                shape (N, num_total_anchors, 4).
+            stride (tuple): Stride in this scale level.
+            soft_targets (Tensor): Soft BBox regression targets.
+            avg_factor (int): Average factor that is used to average
+                the loss. When using sampling method, avg_factor is usually
+                the sum of positive and negative priors. When using
+                `PseudoSampler`, `avg_factor` is usually equal to the number
+                of positive priors.
+
+        Returns:
+            dict[tuple, Tensor]: Loss components and weight targets.
+        """
+        assert stride[0] == stride[1], 'h stride is not equal to w stride!'
+        anchors = anchors.reshape(-1, 4)
+        cls_score = cls_score.permute(0, 2, 3,
+                                      1).reshape(-1, self.cls_out_channels)
+        bbox_pred = bbox_pred.permute(0, 2, 3,
+                                      1).reshape(-1, 4 * (self.reg_max + 1))
+        soft_targets = soft_targets.permute(0, 2, 3,
+                                            1).reshape(-1,
+                                                       4 * (self.reg_max + 1))
+
+        bbox_targets = bbox_targets.reshape(-1, 4)
+        labels = labels.reshape(-1)
+        label_weights = label_weights.reshape(-1)
+
+        # FG cat_id: [0, num_classes -1], BG cat_id: num_classes
+        bg_class_ind = self.num_classes
+        pos_inds = ((labels >= 0)
+                    & (labels < bg_class_ind)).nonzero().squeeze(1)
+        score = label_weights.new_zeros(labels.shape)
+
+        if len(pos_inds) > 0:
+            pos_bbox_targets = bbox_targets[pos_inds]
+            pos_bbox_pred = bbox_pred[pos_inds]
+            pos_anchors = anchors[pos_inds]
+            pos_anchor_centers = self.anchor_center(pos_anchors) / stride[0]
+
+            weight_targets = cls_score.detach().sigmoid()
+            weight_targets = weight_targets.max(dim=1)[0][pos_inds]
+            pos_bbox_pred_corners = self.integral(pos_bbox_pred)
+            pos_decode_bbox_pred = self.bbox_coder.decode(
+                pos_anchor_centers, pos_bbox_pred_corners)
+            pos_decode_bbox_targets = pos_bbox_targets / stride[0]
+            score[pos_inds] = bbox_overlaps(
+                pos_decode_bbox_pred.detach(),
+                pos_decode_bbox_targets,
+                is_aligned=True)
+            pred_corners = pos_bbox_pred.reshape(-1, self.reg_max + 1)
+            pos_soft_targets = soft_targets[pos_inds]
+            soft_corners = pos_soft_targets.reshape(-1, self.reg_max + 1)
+
+            target_corners = self.bbox_coder.encode(pos_anchor_centers,
+                                                    pos_decode_bbox_targets,
+                                                    self.reg_max).reshape(-1)
+
+            # regression loss
+            loss_bbox = self.loss_bbox(
+                pos_decode_bbox_pred,
+                pos_decode_bbox_targets,
+                weight=weight_targets,
+                avg_factor=1.0)
+
+            # dfl loss
+            loss_dfl = self.loss_dfl(
+                pred_corners,
+                target_corners,
+                weight=weight_targets[:, None].expand(-1, 4).reshape(-1),
+                avg_factor=4.0)
+
+            # ld loss
+            loss_ld = self.loss_ld(
+                pred_corners,
+                soft_corners,
+                weight=weight_targets[:, None].expand(-1, 4).reshape(-1),
+                avg_factor=4.0)
+
+        else:
+            loss_ld = bbox_pred.sum() * 0
+            loss_bbox = bbox_pred.sum() * 0
+            loss_dfl = bbox_pred.sum() * 0
+            weight_targets = bbox_pred.new_tensor(0)
+
+        # cls (qfl) loss
+        loss_cls = self.loss_cls(
+            cls_score, (labels, score),
+            weight=label_weights,
+            avg_factor=avg_factor)
+
+        return loss_cls, loss_bbox, loss_dfl, loss_ld, weight_targets.sum()
+
+    def loss(self, x: List[Tensor], out_teacher: Tuple[Tensor],
+             batch_data_samples: SampleList) -> dict:
+        """
+        Args:
+            x (list[Tensor]): Features from FPN.
+            out_teacher (tuple[Tensor]): The output of teacher.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            tuple[dict, list]: The loss components and proposals of each image.
+
+            - losses (dict[str, Tensor]): A dictionary of loss components.
+            - proposal_list (list[Tensor]): Proposals of each image.
+        """
+        outputs = unpack_gt_instances(batch_data_samples)
+        batch_gt_instances, batch_gt_instances_ignore, batch_img_metas \
+            = outputs
+
+        outs = self(x)
+        soft_targets = out_teacher[1]
+        loss_inputs = outs + (batch_gt_instances, batch_img_metas,
+                              soft_targets)
+        losses = self.loss_by_feat(
+            *loss_inputs, batch_gt_instances_ignore=batch_gt_instances_ignore)
+
+        return losses
+
+    def loss_by_feat(
+            self,
+            cls_scores: List[Tensor],
+            bbox_preds: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            soft_targets: List[Tensor],
+            batch_gt_instances_ignore: OptInstanceList = None) -> dict:
+        """Compute losses of the head.
+
+        Args:
+            cls_scores (list[Tensor]): Cls and quality scores for each scale
+                level has shape (N, num_classes, H, W).
+            bbox_preds (list[Tensor]): Box distribution logits for each scale
+                level with shape (N, 4*(n+1), H, W), n is max value of integral
+                set.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            soft_targets (list[Tensor]): Soft BBox regression targets.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], Optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        assert len(featmap_sizes) == self.prior_generator.num_levels
+
+        device = cls_scores[0].device
+        anchor_list, valid_flag_list = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+
+        cls_reg_targets = self.get_targets(
+            anchor_list,
+            valid_flag_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore)
+
+        (anchor_list, labels_list, label_weights_list, bbox_targets_list,
+         bbox_weights_list, avg_factor) = cls_reg_targets
+
+        avg_factor = reduce_mean(
+            torch.tensor(avg_factor, dtype=torch.float, device=device)).item()
+
+        losses_cls, losses_bbox, losses_dfl, losses_ld, \
+            avg_factor = multi_apply(
+                self.loss_by_feat_single,
+                anchor_list,
+                cls_scores,
+                bbox_preds,
+                labels_list,
+                label_weights_list,
+                bbox_targets_list,
+                self.prior_generator.strides,
+                soft_targets,
+                avg_factor=avg_factor)
+
+        avg_factor = sum(avg_factor) + 1e-6
+        avg_factor = reduce_mean(avg_factor).item()
+        losses_bbox = [x / avg_factor for x in losses_bbox]
+        losses_dfl = [x / avg_factor for x in losses_dfl]
+        return dict(
+            loss_cls=losses_cls,
+            loss_bbox=losses_bbox,
+            loss_dfl=losses_dfl,
+            loss_ld=losses_ld)
diff --git a/mmdetection/mmdet/models/dense_heads/mask2former_head.py b/mmdetection/mmdet/models/dense_heads/mask2former_head.py
new file mode 100644
index 00000000..12d47c65
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/mask2former_head.py
@@ -0,0 +1,459 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+from typing import List, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import Conv2d
+from mmcv.ops import point_sample
+from mmengine.model import ModuleList, caffe2_xavier_init
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.structures import SampleList
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig, reduce_mean
+from ..layers import Mask2FormerTransformerDecoder, SinePositionalEncoding
+from ..utils import get_uncertain_point_coords_with_randomness
+from .anchor_free_head import AnchorFreeHead
+from .maskformer_head import MaskFormerHead
+
+
+@MODELS.register_module()
+class Mask2FormerHead(MaskFormerHead):
+    """Implements the Mask2Former head.
+
+    See `Masked-attention Mask Transformer for Universal Image
+    Segmentation `_ for details.
+
+    Args:
+        in_channels (list[int]): Number of channels in the input feature map.
+        feat_channels (int): Number of channels for features.
+        out_channels (int): Number of channels for output.
+        num_things_classes (int): Number of things.
+        num_stuff_classes (int): Number of stuff.
+        num_queries (int): Number of query in Transformer decoder.
+        pixel_decoder (:obj:`ConfigDict` or dict): Config for pixel
+            decoder. Defaults to None.
+        enforce_decoder_input_project (bool, optional): Whether to add
+            a layer to change the embed_dim of tranformer encoder in
+            pixel decoder to the embed_dim of transformer decoder.
+            Defaults to False.
+        transformer_decoder (:obj:`ConfigDict` or dict): Config for
+            transformer decoder. Defaults to None.
+        positional_encoding (:obj:`ConfigDict` or dict): Config for
+            transformer decoder position encoding. Defaults to
+            dict(num_feats=128, normalize=True).
+        loss_cls (:obj:`ConfigDict` or dict): Config of the classification
+            loss. Defaults to None.
+        loss_mask (:obj:`ConfigDict` or dict): Config of the mask loss.
+            Defaults to None.
+        loss_dice (:obj:`ConfigDict` or dict): Config of the dice loss.
+            Defaults to None.
+        train_cfg (:obj:`ConfigDict` or dict, optional): Training config of
+            Mask2Former head.
+        test_cfg (:obj:`ConfigDict` or dict, optional): Testing config of
+            Mask2Former head.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict], optional): Initialization config dict. Defaults to None.
+    """
+
+    def __init__(self,
+                 in_channels: List[int],
+                 feat_channels: int,
+                 out_channels: int,
+                 num_things_classes: int = 80,
+                 num_stuff_classes: int = 53,
+                 num_queries: int = 100,
+                 num_transformer_feat_level: int = 3,
+                 pixel_decoder: ConfigType = ...,
+                 enforce_decoder_input_project: bool = False,
+                 transformer_decoder: ConfigType = ...,
+                 positional_encoding: ConfigType = dict(
+                     num_feats=128, normalize=True),
+                 loss_cls: ConfigType = dict(
+                     type='CrossEntropyLoss',
+                     use_sigmoid=False,
+                     loss_weight=2.0,
+                     reduction='mean',
+                     class_weight=[1.0] * 133 + [0.1]),
+                 loss_mask: ConfigType = dict(
+                     type='CrossEntropyLoss',
+                     use_sigmoid=True,
+                     reduction='mean',
+                     loss_weight=5.0),
+                 loss_dice: ConfigType = dict(
+                     type='DiceLoss',
+                     use_sigmoid=True,
+                     activate=True,
+                     reduction='mean',
+                     naive_dice=True,
+                     eps=1.0,
+                     loss_weight=5.0),
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None,
+                 **kwargs) -> None:
+        super(AnchorFreeHead, self).__init__(init_cfg=init_cfg)
+        self.num_things_classes = num_things_classes
+        self.num_stuff_classes = num_stuff_classes
+        self.num_classes = self.num_things_classes + self.num_stuff_classes
+        self.num_queries = num_queries
+        self.num_transformer_feat_level = num_transformer_feat_level
+        self.num_heads = transformer_decoder.layer_cfg.cross_attn_cfg.num_heads
+        self.num_transformer_decoder_layers = transformer_decoder.num_layers
+        assert pixel_decoder.encoder.layer_cfg. \
+            self_attn_cfg.num_levels == num_transformer_feat_level
+        pixel_decoder_ = copy.deepcopy(pixel_decoder)
+        pixel_decoder_.update(
+            in_channels=in_channels,
+            feat_channels=feat_channels,
+            out_channels=out_channels)
+        self.pixel_decoder = MODELS.build(pixel_decoder_)
+        self.transformer_decoder = Mask2FormerTransformerDecoder(
+            **transformer_decoder)
+        self.decoder_embed_dims = self.transformer_decoder.embed_dims
+
+        self.decoder_input_projs = ModuleList()
+        # from low resolution to high resolution
+        for _ in range(num_transformer_feat_level):
+            if (self.decoder_embed_dims != feat_channels
+                    or enforce_decoder_input_project):
+                self.decoder_input_projs.append(
+                    Conv2d(
+                        feat_channels, self.decoder_embed_dims, kernel_size=1))
+            else:
+                self.decoder_input_projs.append(nn.Identity())
+        self.decoder_positional_encoding = SinePositionalEncoding(
+            **positional_encoding)
+        self.query_embed = nn.Embedding(self.num_queries, feat_channels)
+        self.query_feat = nn.Embedding(self.num_queries, feat_channels)
+        # from low resolution to high resolution
+        self.level_embed = nn.Embedding(self.num_transformer_feat_level,
+                                        feat_channels)
+
+        self.cls_embed = nn.Linear(feat_channels, self.num_classes + 1)
+        self.mask_embed = nn.Sequential(
+            nn.Linear(feat_channels, feat_channels), nn.ReLU(inplace=True),
+            nn.Linear(feat_channels, feat_channels), nn.ReLU(inplace=True),
+            nn.Linear(feat_channels, out_channels))
+
+        self.test_cfg = test_cfg
+        self.train_cfg = train_cfg
+        if train_cfg:
+            self.assigner = TASK_UTILS.build(self.train_cfg['assigner'])
+            self.sampler = TASK_UTILS.build(
+                self.train_cfg['sampler'], default_args=dict(context=self))
+            self.num_points = self.train_cfg.get('num_points', 12544)
+            self.oversample_ratio = self.train_cfg.get('oversample_ratio', 3.0)
+            self.importance_sample_ratio = self.train_cfg.get(
+                'importance_sample_ratio', 0.75)
+
+        self.class_weight = loss_cls.class_weight
+        self.loss_cls = MODELS.build(loss_cls)
+        self.loss_mask = MODELS.build(loss_mask)
+        self.loss_dice = MODELS.build(loss_dice)
+
+    def init_weights(self) -> None:
+        for m in self.decoder_input_projs:
+            if isinstance(m, Conv2d):
+                caffe2_xavier_init(m, bias=0)
+
+        self.pixel_decoder.init_weights()
+
+        for p in self.transformer_decoder.parameters():
+            if p.dim() > 1:
+                nn.init.xavier_normal_(p)
+
+    def _get_targets_single(self, cls_score: Tensor, mask_pred: Tensor,
+                            gt_instances: InstanceData,
+                            img_meta: dict) -> Tuple[Tensor]:
+        """Compute classification and mask targets for one image.
+
+        Args:
+            cls_score (Tensor): Mask score logits from a single decoder layer
+                for one image. Shape (num_queries, cls_out_channels).
+            mask_pred (Tensor): Mask logits for a single decoder layer for one
+                image. Shape (num_queries, h, w).
+            gt_instances (:obj:`InstanceData`): It contains ``labels`` and
+                ``masks``.
+            img_meta (dict): Image informtation.
+
+        Returns:
+            tuple[Tensor]: A tuple containing the following for one image.
+
+                - labels (Tensor): Labels of each image. \
+                    shape (num_queries, ).
+                - label_weights (Tensor): Label weights of each image. \
+                    shape (num_queries, ).
+                - mask_targets (Tensor): Mask targets of each image. \
+                    shape (num_queries, h, w).
+                - mask_weights (Tensor): Mask weights of each image. \
+                    shape (num_queries, ).
+                - pos_inds (Tensor): Sampled positive indices for each \
+                    image.
+                - neg_inds (Tensor): Sampled negative indices for each \
+                    image.
+                - sampling_result (:obj:`SamplingResult`): Sampling results.
+        """
+        gt_labels = gt_instances.labels
+        gt_masks = gt_instances.masks
+        # sample points
+        num_queries = cls_score.shape[0]
+        num_gts = gt_labels.shape[0]
+
+        point_coords = torch.rand((1, self.num_points, 2),
+                                  device=cls_score.device)
+        # shape (num_queries, num_points)
+        mask_points_pred = point_sample(
+            mask_pred.unsqueeze(1), point_coords.repeat(num_queries, 1,
+                                                        1)).squeeze(1)
+        # shape (num_gts, num_points)
+        gt_points_masks = point_sample(
+            gt_masks.unsqueeze(1).float(), point_coords.repeat(num_gts, 1,
+                                                               1)).squeeze(1)
+
+        sampled_gt_instances = InstanceData(
+            labels=gt_labels, masks=gt_points_masks)
+        sampled_pred_instances = InstanceData(
+            scores=cls_score, masks=mask_points_pred)
+        # assign and sample
+        assign_result = self.assigner.assign(
+            pred_instances=sampled_pred_instances,
+            gt_instances=sampled_gt_instances,
+            img_meta=img_meta)
+        pred_instances = InstanceData(scores=cls_score, masks=mask_pred)
+        sampling_result = self.sampler.sample(
+            assign_result=assign_result,
+            pred_instances=pred_instances,
+            gt_instances=gt_instances)
+        pos_inds = sampling_result.pos_inds
+        neg_inds = sampling_result.neg_inds
+
+        # label target
+        labels = gt_labels.new_full((self.num_queries, ),
+                                    self.num_classes,
+                                    dtype=torch.long)
+        labels[pos_inds] = gt_labels[sampling_result.pos_assigned_gt_inds]
+        label_weights = gt_labels.new_ones((self.num_queries, ))
+
+        # mask target
+        mask_targets = gt_masks[sampling_result.pos_assigned_gt_inds]
+        mask_weights = mask_pred.new_zeros((self.num_queries, ))
+        mask_weights[pos_inds] = 1.0
+
+        return (labels, label_weights, mask_targets, mask_weights, pos_inds,
+                neg_inds, sampling_result)
+
+    def _loss_by_feat_single(self, cls_scores: Tensor, mask_preds: Tensor,
+                             batch_gt_instances: List[InstanceData],
+                             batch_img_metas: List[dict]) -> Tuple[Tensor]:
+        """Loss function for outputs from a single decoder layer.
+
+        Args:
+            cls_scores (Tensor): Mask score logits from a single decoder layer
+                for all images. Shape (batch_size, num_queries,
+                cls_out_channels). Note `cls_out_channels` should includes
+                background.
+            mask_preds (Tensor): Mask logits for a pixel decoder for all
+                images. Shape (batch_size, num_queries, h, w).
+            batch_gt_instances (list[obj:`InstanceData`]): each contains
+                ``labels`` and ``masks``.
+            batch_img_metas (list[dict]): List of image meta information.
+
+        Returns:
+            tuple[Tensor]: Loss components for outputs from a single \
+                decoder layer.
+        """
+        num_imgs = cls_scores.size(0)
+        cls_scores_list = [cls_scores[i] for i in range(num_imgs)]
+        mask_preds_list = [mask_preds[i] for i in range(num_imgs)]
+        (labels_list, label_weights_list, mask_targets_list, mask_weights_list,
+         avg_factor) = self.get_targets(cls_scores_list, mask_preds_list,
+                                        batch_gt_instances, batch_img_metas)
+        # shape (batch_size, num_queries)
+        labels = torch.stack(labels_list, dim=0)
+        # shape (batch_size, num_queries)
+        label_weights = torch.stack(label_weights_list, dim=0)
+        # shape (num_total_gts, h, w)
+        mask_targets = torch.cat(mask_targets_list, dim=0)
+        # shape (batch_size, num_queries)
+        mask_weights = torch.stack(mask_weights_list, dim=0)
+
+        # classfication loss
+        # shape (batch_size * num_queries, )
+        cls_scores = cls_scores.flatten(0, 1)
+        labels = labels.flatten(0, 1)
+        label_weights = label_weights.flatten(0, 1)
+
+        class_weight = cls_scores.new_tensor(self.class_weight)
+        loss_cls = self.loss_cls(
+            cls_scores,
+            labels,
+            label_weights,
+            avg_factor=class_weight[labels].sum())
+
+        num_total_masks = reduce_mean(cls_scores.new_tensor([avg_factor]))
+        num_total_masks = max(num_total_masks, 1)
+
+        # extract positive ones
+        # shape (batch_size, num_queries, h, w) -> (num_total_gts, h, w)
+        mask_preds = mask_preds[mask_weights > 0]
+
+        if mask_targets.shape[0] == 0:
+            # zero match
+            loss_dice = mask_preds.sum()
+            loss_mask = mask_preds.sum()
+            return loss_cls, loss_mask, loss_dice
+
+        with torch.no_grad():
+            points_coords = get_uncertain_point_coords_with_randomness(
+                mask_preds.unsqueeze(1), None, self.num_points,
+                self.oversample_ratio, self.importance_sample_ratio)
+            # shape (num_total_gts, h, w) -> (num_total_gts, num_points)
+            mask_point_targets = point_sample(
+                mask_targets.unsqueeze(1).float(), points_coords).squeeze(1)
+        # shape (num_queries, h, w) -> (num_queries, num_points)
+        mask_point_preds = point_sample(
+            mask_preds.unsqueeze(1), points_coords).squeeze(1)
+
+        # dice loss
+        loss_dice = self.loss_dice(
+            mask_point_preds, mask_point_targets, avg_factor=num_total_masks)
+
+        # mask loss
+        # shape (num_queries, num_points) -> (num_queries * num_points, )
+        mask_point_preds = mask_point_preds.reshape(-1)
+        # shape (num_total_gts, num_points) -> (num_total_gts * num_points, )
+        mask_point_targets = mask_point_targets.reshape(-1)
+        loss_mask = self.loss_mask(
+            mask_point_preds,
+            mask_point_targets,
+            avg_factor=num_total_masks * self.num_points)
+
+        return loss_cls, loss_mask, loss_dice
+
+    def _forward_head(self, decoder_out: Tensor, mask_feature: Tensor,
+                      attn_mask_target_size: Tuple[int, int]) -> Tuple[Tensor]:
+        """Forward for head part which is called after every decoder layer.
+
+        Args:
+            decoder_out (Tensor): in shape (batch_size, num_queries, c).
+            mask_feature (Tensor): in shape (batch_size, c, h, w).
+            attn_mask_target_size (tuple[int, int]): target attention
+                mask size.
+
+        Returns:
+            tuple: A tuple contain three elements.
+
+                - cls_pred (Tensor): Classification scores in shape \
+                    (batch_size, num_queries, cls_out_channels). \
+                    Note `cls_out_channels` should includes background.
+                - mask_pred (Tensor): Mask scores in shape \
+                    (batch_size, num_queries,h, w).
+                - attn_mask (Tensor): Attention mask in shape \
+                    (batch_size * num_heads, num_queries, h, w).
+        """
+        decoder_out = self.transformer_decoder.post_norm(decoder_out)
+        # shape (num_queries, batch_size, c)
+        cls_pred = self.cls_embed(decoder_out)
+        # shape (num_queries, batch_size, c)
+        mask_embed = self.mask_embed(decoder_out)
+        # shape (num_queries, batch_size, h, w)
+        mask_pred = torch.einsum('bqc,bchw->bqhw', mask_embed, mask_feature)
+        attn_mask = F.interpolate(
+            mask_pred,
+            attn_mask_target_size,
+            mode='bilinear',
+            align_corners=False)
+        # shape (num_queries, batch_size, h, w) ->
+        #   (batch_size * num_head, num_queries, h, w)
+        attn_mask = attn_mask.flatten(2).unsqueeze(1).repeat(
+            (1, self.num_heads, 1, 1)).flatten(0, 1)
+        attn_mask = attn_mask.sigmoid() < 0.5
+        attn_mask = attn_mask.detach()
+
+        return cls_pred, mask_pred, attn_mask
+
+    def forward(self, x: List[Tensor],
+                batch_data_samples: SampleList) -> Tuple[List[Tensor]]:
+        """Forward function.
+
+        Args:
+            x (list[Tensor]): Multi scale Features from the
+                upstream network, each is a 4D-tensor.
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+
+        Returns:
+            tuple[list[Tensor]]: A tuple contains two elements.
+
+                - cls_pred_list (list[Tensor)]: Classification logits \
+                    for each decoder layer. Each is a 3D-tensor with shape \
+                    (batch_size, num_queries, cls_out_channels). \
+                    Note `cls_out_channels` should includes background.
+                - mask_pred_list (list[Tensor]): Mask logits for each \
+                    decoder layer. Each with shape (batch_size, num_queries, \
+                    h, w).
+        """
+        batch_size = x[0].shape[0]
+        mask_features, multi_scale_memorys = self.pixel_decoder(x)
+        # multi_scale_memorys (from low resolution to high resolution)
+        decoder_inputs = []
+        decoder_positional_encodings = []
+        for i in range(self.num_transformer_feat_level):
+            decoder_input = self.decoder_input_projs[i](multi_scale_memorys[i])
+            # shape (batch_size, c, h, w) -> (batch_size, h*w, c)
+            decoder_input = decoder_input.flatten(2).permute(0, 2, 1)
+            level_embed = self.level_embed.weight[i].view(1, 1, -1)
+            decoder_input = decoder_input + level_embed
+            # shape (batch_size, c, h, w) -> (batch_size, h*w, c)
+            mask = decoder_input.new_zeros(
+                (batch_size, ) + multi_scale_memorys[i].shape[-2:],
+                dtype=torch.bool)
+            decoder_positional_encoding = self.decoder_positional_encoding(
+                mask)
+            decoder_positional_encoding = decoder_positional_encoding.flatten(
+                2).permute(0, 2, 1)
+            decoder_inputs.append(decoder_input)
+            decoder_positional_encodings.append(decoder_positional_encoding)
+        # shape (num_queries, c) -> (batch_size, num_queries, c)
+        query_feat = self.query_feat.weight.unsqueeze(0).repeat(
+            (batch_size, 1, 1))
+        query_embed = self.query_embed.weight.unsqueeze(0).repeat(
+            (batch_size, 1, 1))
+
+        cls_pred_list = []
+        mask_pred_list = []
+        cls_pred, mask_pred, attn_mask = self._forward_head(
+            query_feat, mask_features, multi_scale_memorys[0].shape[-2:])
+        cls_pred_list.append(cls_pred)
+        mask_pred_list.append(mask_pred)
+
+        for i in range(self.num_transformer_decoder_layers):
+            level_idx = i % self.num_transformer_feat_level
+            # if a mask is all True(all background), then set it all False.
+            mask_sum = (attn_mask.sum(-1) != attn_mask.shape[-1]).unsqueeze(-1)
+            attn_mask = attn_mask & mask_sum
+            # cross_attn + self_attn
+            layer = self.transformer_decoder.layers[i]
+            query_feat = layer(
+                query=query_feat,
+                key=decoder_inputs[level_idx],
+                value=decoder_inputs[level_idx],
+                query_pos=query_embed,
+                key_pos=decoder_positional_encodings[level_idx],
+                cross_attn_mask=attn_mask,
+                query_key_padding_mask=None,
+                # here we do not apply masking on padded region
+                key_padding_mask=None)
+            cls_pred, mask_pred, attn_mask = self._forward_head(
+                query_feat, mask_features, multi_scale_memorys[
+                    (i + 1) % self.num_transformer_feat_level].shape[-2:])
+
+            cls_pred_list.append(cls_pred)
+            mask_pred_list.append(mask_pred)
+
+        return cls_pred_list, mask_pred_list
diff --git a/mmdetection/mmdet/models/dense_heads/maskformer_head.py b/mmdetection/mmdet/models/dense_heads/maskformer_head.py
new file mode 100644
index 00000000..24c0655e
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/maskformer_head.py
@@ -0,0 +1,601 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, List, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import Conv2d
+from mmengine.model import caffe2_xavier_init
+from mmengine.structures import InstanceData, PixelData
+from torch import Tensor
+
+from mmdet.models.layers.pixel_decoder import PixelDecoder
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.structures import SampleList
+from mmdet.utils import (ConfigType, InstanceList, OptConfigType,
+                         OptMultiConfig, reduce_mean)
+from ..layers import DetrTransformerDecoder, SinePositionalEncoding
+from ..utils import multi_apply, preprocess_panoptic_gt
+from .anchor_free_head import AnchorFreeHead
+
+
+@MODELS.register_module()
+class MaskFormerHead(AnchorFreeHead):
+    """Implements the MaskFormer head.
+
+    See `Per-Pixel Classification is Not All You Need for Semantic
+    Segmentation `_ for details.
+
+    Args:
+        in_channels (list[int]): Number of channels in the input feature map.
+        feat_channels (int): Number of channels for feature.
+        out_channels (int): Number of channels for output.
+        num_things_classes (int): Number of things.
+        num_stuff_classes (int): Number of stuff.
+        num_queries (int): Number of query in Transformer.
+        pixel_decoder (:obj:`ConfigDict` or dict): Config for pixel
+            decoder.
+        enforce_decoder_input_project (bool): Whether to add a layer
+            to change the embed_dim of transformer encoder in pixel decoder to
+            the embed_dim of transformer decoder. Defaults to False.
+        transformer_decoder (:obj:`ConfigDict` or dict): Config for
+            transformer decoder.
+        positional_encoding (:obj:`ConfigDict` or dict): Config for
+            transformer decoder position encoding.
+        loss_cls (:obj:`ConfigDict` or dict): Config of the classification
+            loss. Defaults to `CrossEntropyLoss`.
+        loss_mask (:obj:`ConfigDict` or dict): Config of the mask loss.
+            Defaults to `FocalLoss`.
+        loss_dice (:obj:`ConfigDict` or dict): Config of the dice loss.
+            Defaults to `DiceLoss`.
+        train_cfg (:obj:`ConfigDict` or dict, optional): Training config of
+            MaskFormer head.
+        test_cfg (:obj:`ConfigDict` or dict, optional): Testing config of
+            MaskFormer head.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict], optional): Initialization config dict. Defaults to None.
+    """
+
+    def __init__(self,
+                 in_channels: List[int],
+                 feat_channels: int,
+                 out_channels: int,
+                 num_things_classes: int = 80,
+                 num_stuff_classes: int = 53,
+                 num_queries: int = 100,
+                 pixel_decoder: ConfigType = ...,
+                 enforce_decoder_input_project: bool = False,
+                 transformer_decoder: ConfigType = ...,
+                 positional_encoding: ConfigType = dict(
+                     num_feats=128, normalize=True),
+                 loss_cls: ConfigType = dict(
+                     type='CrossEntropyLoss',
+                     use_sigmoid=False,
+                     loss_weight=1.0,
+                     class_weight=[1.0] * 133 + [0.1]),
+                 loss_mask: ConfigType = dict(
+                     type='FocalLoss',
+                     use_sigmoid=True,
+                     gamma=2.0,
+                     alpha=0.25,
+                     loss_weight=20.0),
+                 loss_dice: ConfigType = dict(
+                     type='DiceLoss',
+                     use_sigmoid=True,
+                     activate=True,
+                     naive_dice=True,
+                     loss_weight=1.0),
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None,
+                 **kwargs) -> None:
+        super(AnchorFreeHead, self).__init__(init_cfg=init_cfg)
+        self.num_things_classes = num_things_classes
+        self.num_stuff_classes = num_stuff_classes
+        self.num_classes = self.num_things_classes + self.num_stuff_classes
+        self.num_queries = num_queries
+
+        pixel_decoder.update(
+            in_channels=in_channels,
+            feat_channels=feat_channels,
+            out_channels=out_channels)
+        self.pixel_decoder = MODELS.build(pixel_decoder)
+        self.transformer_decoder = DetrTransformerDecoder(
+            **transformer_decoder)
+        self.decoder_embed_dims = self.transformer_decoder.embed_dims
+        if type(self.pixel_decoder) == PixelDecoder and (
+                self.decoder_embed_dims != in_channels[-1]
+                or enforce_decoder_input_project):
+            self.decoder_input_proj = Conv2d(
+                in_channels[-1], self.decoder_embed_dims, kernel_size=1)
+        else:
+            self.decoder_input_proj = nn.Identity()
+        self.decoder_pe = SinePositionalEncoding(**positional_encoding)
+        self.query_embed = nn.Embedding(self.num_queries, out_channels)
+
+        self.cls_embed = nn.Linear(feat_channels, self.num_classes + 1)
+        self.mask_embed = nn.Sequential(
+            nn.Linear(feat_channels, feat_channels), nn.ReLU(inplace=True),
+            nn.Linear(feat_channels, feat_channels), nn.ReLU(inplace=True),
+            nn.Linear(feat_channels, out_channels))
+
+        self.test_cfg = test_cfg
+        self.train_cfg = train_cfg
+        if train_cfg:
+            self.assigner = TASK_UTILS.build(train_cfg['assigner'])
+            self.sampler = TASK_UTILS.build(
+                train_cfg['sampler'], default_args=dict(context=self))
+
+        self.class_weight = loss_cls.class_weight
+        self.loss_cls = MODELS.build(loss_cls)
+        self.loss_mask = MODELS.build(loss_mask)
+        self.loss_dice = MODELS.build(loss_dice)
+
+    def init_weights(self) -> None:
+        if isinstance(self.decoder_input_proj, Conv2d):
+            caffe2_xavier_init(self.decoder_input_proj, bias=0)
+
+        self.pixel_decoder.init_weights()
+
+        for p in self.transformer_decoder.parameters():
+            if p.dim() > 1:
+                nn.init.xavier_uniform_(p)
+
+    def preprocess_gt(
+            self, batch_gt_instances: InstanceList,
+            batch_gt_semantic_segs: List[Optional[PixelData]]) -> InstanceList:
+        """Preprocess the ground truth for all images.
+
+        Args:
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``labels``, each is
+                ground truth labels of each bbox, with shape (num_gts, )
+                and ``masks``, each is ground truth masks of each instances
+                of a image, shape (num_gts, h, w).
+            gt_semantic_seg (list[Optional[PixelData]]): Ground truth of
+                semantic segmentation, each with the shape (1, h, w).
+                [0, num_thing_class - 1] means things,
+                [num_thing_class, num_class-1] means stuff,
+                255 means VOID. It's None when training instance segmentation.
+
+        Returns:
+            list[obj:`InstanceData`]: each contains the following keys
+
+                - labels (Tensor): Ground truth class indices\
+                    for a image, with shape (n, ), n is the sum of\
+                    number of stuff type and number of instance in a image.
+                - masks (Tensor): Ground truth mask for a\
+                    image, with shape (n, h, w).
+        """
+        num_things_list = [self.num_things_classes] * len(batch_gt_instances)
+        num_stuff_list = [self.num_stuff_classes] * len(batch_gt_instances)
+        gt_labels_list = [
+            gt_instances['labels'] for gt_instances in batch_gt_instances
+        ]
+        gt_masks_list = [
+            gt_instances['masks'] for gt_instances in batch_gt_instances
+        ]
+        gt_semantic_segs = [
+            None if gt_semantic_seg is None else gt_semantic_seg.sem_seg
+            for gt_semantic_seg in batch_gt_semantic_segs
+        ]
+        targets = multi_apply(preprocess_panoptic_gt, gt_labels_list,
+                              gt_masks_list, gt_semantic_segs, num_things_list,
+                              num_stuff_list)
+        labels, masks = targets
+        batch_gt_instances = [
+            InstanceData(labels=label, masks=mask)
+            for label, mask in zip(labels, masks)
+        ]
+        return batch_gt_instances
+
+    def get_targets(
+        self,
+        cls_scores_list: List[Tensor],
+        mask_preds_list: List[Tensor],
+        batch_gt_instances: InstanceList,
+        batch_img_metas: List[dict],
+        return_sampling_results: bool = False
+    ) -> Tuple[List[Union[Tensor, int]]]:
+        """Compute classification and mask targets for all images for a decoder
+        layer.
+
+        Args:
+            cls_scores_list (list[Tensor]): Mask score logits from a single
+                decoder layer for all images. Each with shape (num_queries,
+                cls_out_channels).
+            mask_preds_list (list[Tensor]): Mask logits from a single decoder
+                layer for all images. Each with shape (num_queries, h, w).
+            batch_gt_instances (list[obj:`InstanceData`]): each contains
+                ``labels`` and ``masks``.
+            batch_img_metas (list[dict]): List of image meta information.
+            return_sampling_results (bool): Whether to return the sampling
+                results. Defaults to False.
+
+        Returns:
+            tuple: a tuple containing the following targets.
+
+                - labels_list (list[Tensor]): Labels of all images.\
+                    Each with shape (num_queries, ).
+                - label_weights_list (list[Tensor]): Label weights\
+                    of all images. Each with shape (num_queries, ).
+                - mask_targets_list (list[Tensor]): Mask targets of\
+                    all images. Each with shape (num_queries, h, w).
+                - mask_weights_list (list[Tensor]): Mask weights of\
+                    all images. Each with shape (num_queries, ).
+                - avg_factor (int): Average factor that is used to average\
+                    the loss. When using sampling method, avg_factor is
+                    usually the sum of positive and negative priors. When
+                    using `MaskPseudoSampler`, `avg_factor` is usually equal
+                    to the number of positive priors.
+
+            additional_returns: This function enables user-defined returns from
+                `self._get_targets_single`. These returns are currently refined
+                to properties at each feature map (i.e. having HxW dimension).
+                The results will be concatenated after the end.
+        """
+        results = multi_apply(self._get_targets_single, cls_scores_list,
+                              mask_preds_list, batch_gt_instances,
+                              batch_img_metas)
+        (labels_list, label_weights_list, mask_targets_list, mask_weights_list,
+         pos_inds_list, neg_inds_list, sampling_results_list) = results[:7]
+        rest_results = list(results[7:])
+
+        avg_factor = sum(
+            [results.avg_factor for results in sampling_results_list])
+
+        res = (labels_list, label_weights_list, mask_targets_list,
+               mask_weights_list, avg_factor)
+        if return_sampling_results:
+            res = res + (sampling_results_list)
+
+        return res + tuple(rest_results)
+
+    def _get_targets_single(self, cls_score: Tensor, mask_pred: Tensor,
+                            gt_instances: InstanceData,
+                            img_meta: dict) -> Tuple[Tensor]:
+        """Compute classification and mask targets for one image.
+
+        Args:
+            cls_score (Tensor): Mask score logits from a single decoder layer
+                for one image. Shape (num_queries, cls_out_channels).
+            mask_pred (Tensor): Mask logits for a single decoder layer for one
+                image. Shape (num_queries, h, w).
+            gt_instances (:obj:`InstanceData`): It contains ``labels`` and
+                ``masks``.
+            img_meta (dict): Image informtation.
+
+        Returns:
+            tuple: a tuple containing the following for one image.
+
+                - labels (Tensor): Labels of each image.
+                    shape (num_queries, ).
+                - label_weights (Tensor): Label weights of each image.
+                    shape (num_queries, ).
+                - mask_targets (Tensor): Mask targets of each image.
+                    shape (num_queries, h, w).
+                - mask_weights (Tensor): Mask weights of each image.
+                    shape (num_queries, ).
+                - pos_inds (Tensor): Sampled positive indices for each image.
+                - neg_inds (Tensor): Sampled negative indices for each image.
+                - sampling_result (:obj:`SamplingResult`): Sampling results.
+        """
+        gt_masks = gt_instances.masks
+        gt_labels = gt_instances.labels
+
+        target_shape = mask_pred.shape[-2:]
+        if gt_masks.shape[0] > 0:
+            gt_masks_downsampled = F.interpolate(
+                gt_masks.unsqueeze(1).float(), target_shape,
+                mode='nearest').squeeze(1).long()
+        else:
+            gt_masks_downsampled = gt_masks
+
+        pred_instances = InstanceData(scores=cls_score, masks=mask_pred)
+        downsampled_gt_instances = InstanceData(
+            labels=gt_labels, masks=gt_masks_downsampled)
+        # assign and sample
+        assign_result = self.assigner.assign(
+            pred_instances=pred_instances,
+            gt_instances=downsampled_gt_instances,
+            img_meta=img_meta)
+        sampling_result = self.sampler.sample(
+            assign_result=assign_result,
+            pred_instances=pred_instances,
+            gt_instances=gt_instances)
+        pos_inds = sampling_result.pos_inds
+        neg_inds = sampling_result.neg_inds
+
+        # label target
+        labels = gt_labels.new_full((self.num_queries, ),
+                                    self.num_classes,
+                                    dtype=torch.long)
+        labels[pos_inds] = gt_labels[sampling_result.pos_assigned_gt_inds]
+        label_weights = gt_labels.new_ones(self.num_queries)
+
+        # mask target
+        mask_targets = gt_masks[sampling_result.pos_assigned_gt_inds]
+        mask_weights = mask_pred.new_zeros((self.num_queries, ))
+        mask_weights[pos_inds] = 1.0
+
+        return (labels, label_weights, mask_targets, mask_weights, pos_inds,
+                neg_inds, sampling_result)
+
+    def loss_by_feat(self, all_cls_scores: Tensor, all_mask_preds: Tensor,
+                     batch_gt_instances: List[InstanceData],
+                     batch_img_metas: List[dict]) -> Dict[str, Tensor]:
+        """Loss function.
+
+        Args:
+            all_cls_scores (Tensor): Classification scores for all decoder
+                layers with shape (num_decoder, batch_size, num_queries,
+                cls_out_channels). Note `cls_out_channels` should includes
+                background.
+            all_mask_preds (Tensor): Mask scores for all decoder layers with
+                shape (num_decoder, batch_size, num_queries, h, w).
+            batch_gt_instances (list[obj:`InstanceData`]): each contains
+                ``labels`` and ``masks``.
+            batch_img_metas (list[dict]): List of image meta information.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        num_dec_layers = len(all_cls_scores)
+        batch_gt_instances_list = [
+            batch_gt_instances for _ in range(num_dec_layers)
+        ]
+        img_metas_list = [batch_img_metas for _ in range(num_dec_layers)]
+        losses_cls, losses_mask, losses_dice = multi_apply(
+            self._loss_by_feat_single, all_cls_scores, all_mask_preds,
+            batch_gt_instances_list, img_metas_list)
+
+        loss_dict = dict()
+        # loss from the last decoder layer
+        loss_dict['loss_cls'] = losses_cls[-1]
+        loss_dict['loss_mask'] = losses_mask[-1]
+        loss_dict['loss_dice'] = losses_dice[-1]
+        # loss from other decoder layers
+        num_dec_layer = 0
+        for loss_cls_i, loss_mask_i, loss_dice_i in zip(
+                losses_cls[:-1], losses_mask[:-1], losses_dice[:-1]):
+            loss_dict[f'd{num_dec_layer}.loss_cls'] = loss_cls_i
+            loss_dict[f'd{num_dec_layer}.loss_mask'] = loss_mask_i
+            loss_dict[f'd{num_dec_layer}.loss_dice'] = loss_dice_i
+            num_dec_layer += 1
+        return loss_dict
+
+    def _loss_by_feat_single(self, cls_scores: Tensor, mask_preds: Tensor,
+                             batch_gt_instances: List[InstanceData],
+                             batch_img_metas: List[dict]) -> Tuple[Tensor]:
+        """Loss function for outputs from a single decoder layer.
+
+        Args:
+            cls_scores (Tensor): Mask score logits from a single decoder layer
+                for all images. Shape (batch_size, num_queries,
+                cls_out_channels). Note `cls_out_channels` should includes
+                background.
+            mask_preds (Tensor): Mask logits for a pixel decoder for all
+                images. Shape (batch_size, num_queries, h, w).
+            batch_gt_instances (list[obj:`InstanceData`]): each contains
+                ``labels`` and ``masks``.
+            batch_img_metas (list[dict]): List of image meta information.
+
+        Returns:
+            tuple[Tensor]: Loss components for outputs from a single decoder\
+                layer.
+        """
+        num_imgs = cls_scores.size(0)
+        cls_scores_list = [cls_scores[i] for i in range(num_imgs)]
+        mask_preds_list = [mask_preds[i] for i in range(num_imgs)]
+
+        (labels_list, label_weights_list, mask_targets_list, mask_weights_list,
+         avg_factor) = self.get_targets(cls_scores_list, mask_preds_list,
+                                        batch_gt_instances, batch_img_metas)
+        # shape (batch_size, num_queries)
+        labels = torch.stack(labels_list, dim=0)
+        # shape (batch_size, num_queries)
+        label_weights = torch.stack(label_weights_list, dim=0)
+        # shape (num_total_gts, h, w)
+        mask_targets = torch.cat(mask_targets_list, dim=0)
+        # shape (batch_size, num_queries)
+        mask_weights = torch.stack(mask_weights_list, dim=0)
+
+        # classfication loss
+        # shape (batch_size * num_queries, )
+        cls_scores = cls_scores.flatten(0, 1)
+        labels = labels.flatten(0, 1)
+        label_weights = label_weights.flatten(0, 1)
+
+        class_weight = cls_scores.new_tensor(self.class_weight)
+        loss_cls = self.loss_cls(
+            cls_scores,
+            labels,
+            label_weights,
+            avg_factor=class_weight[labels].sum())
+
+        num_total_masks = reduce_mean(cls_scores.new_tensor([avg_factor]))
+        num_total_masks = max(num_total_masks, 1)
+
+        # extract positive ones
+        # shape (batch_size, num_queries, h, w) -> (num_total_gts, h, w)
+        mask_preds = mask_preds[mask_weights > 0]
+        target_shape = mask_targets.shape[-2:]
+
+        if mask_targets.shape[0] == 0:
+            # zero match
+            loss_dice = mask_preds.sum()
+            loss_mask = mask_preds.sum()
+            return loss_cls, loss_mask, loss_dice
+
+        # upsample to shape of target
+        # shape (num_total_gts, h, w)
+        mask_preds = F.interpolate(
+            mask_preds.unsqueeze(1),
+            target_shape,
+            mode='bilinear',
+            align_corners=False).squeeze(1)
+
+        # dice loss
+        loss_dice = self.loss_dice(
+            mask_preds, mask_targets, avg_factor=num_total_masks)
+
+        # mask loss
+        # FocalLoss support input of shape (n, num_class)
+        h, w = mask_preds.shape[-2:]
+        # shape (num_total_gts, h, w) -> (num_total_gts * h * w, 1)
+        mask_preds = mask_preds.reshape(-1, 1)
+        # shape (num_total_gts, h, w) -> (num_total_gts * h * w)
+        mask_targets = mask_targets.reshape(-1)
+        # target is (1 - mask_targets) !!!
+        loss_mask = self.loss_mask(
+            mask_preds, 1 - mask_targets, avg_factor=num_total_masks * h * w)
+
+        return loss_cls, loss_mask, loss_dice
+
+    def forward(self, x: Tuple[Tensor],
+                batch_data_samples: SampleList) -> Tuple[Tensor]:
+        """Forward function.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each
+                is a 4D-tensor.
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+
+        Returns:
+            tuple[Tensor]: a tuple contains two elements.
+
+                - all_cls_scores (Tensor): Classification scores for each\
+                    scale level. Each is a 4D-tensor with shape\
+                    (num_decoder, batch_size, num_queries, cls_out_channels).\
+                    Note `cls_out_channels` should includes background.
+                - all_mask_preds (Tensor): Mask scores for each decoder\
+                    layer. Each with shape (num_decoder, batch_size,\
+                    num_queries, h, w).
+        """
+        batch_img_metas = [
+            data_sample.metainfo for data_sample in batch_data_samples
+        ]
+        batch_size = x[0].shape[0]
+        input_img_h, input_img_w = batch_img_metas[0]['batch_input_shape']
+        padding_mask = x[-1].new_ones((batch_size, input_img_h, input_img_w),
+                                      dtype=torch.float32)
+        for i in range(batch_size):
+            img_h, img_w = batch_img_metas[i]['img_shape']
+            padding_mask[i, :img_h, :img_w] = 0
+        padding_mask = F.interpolate(
+            padding_mask.unsqueeze(1), size=x[-1].shape[-2:],
+            mode='nearest').to(torch.bool).squeeze(1)
+        # when backbone is swin, memory is output of last stage of swin.
+        # when backbone is r50, memory is output of tranformer encoder.
+        mask_features, memory = self.pixel_decoder(x, batch_img_metas)
+        pos_embed = self.decoder_pe(padding_mask)
+        memory = self.decoder_input_proj(memory)
+        # shape (batch_size, c, h, w) -> (batch_size, h*w, c)
+        memory = memory.flatten(2).permute(0, 2, 1)
+        pos_embed = pos_embed.flatten(2).permute(0, 2, 1)
+        # shape (batch_size, h * w)
+        padding_mask = padding_mask.flatten(1)
+        # shape = (num_queries, embed_dims)
+        query_embed = self.query_embed.weight
+        # shape = (batch_size, num_queries, embed_dims)
+        query_embed = query_embed.unsqueeze(0).repeat(batch_size, 1, 1)
+        target = torch.zeros_like(query_embed)
+        # shape (num_decoder, num_queries, batch_size, embed_dims)
+        out_dec = self.transformer_decoder(
+            query=target,
+            key=memory,
+            value=memory,
+            query_pos=query_embed,
+            key_pos=pos_embed,
+            key_padding_mask=padding_mask)
+
+        # cls_scores
+        all_cls_scores = self.cls_embed(out_dec)
+
+        # mask_preds
+        mask_embed = self.mask_embed(out_dec)
+        all_mask_preds = torch.einsum('lbqc,bchw->lbqhw', mask_embed,
+                                      mask_features)
+
+        return all_cls_scores, all_mask_preds
+
+    def loss(
+        self,
+        x: Tuple[Tensor],
+        batch_data_samples: SampleList,
+    ) -> Dict[str, Tensor]:
+        """Perform forward propagation and loss calculation of the panoptic
+        head on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Multi-level features from the upstream
+                network, each is a 4D-tensor.
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+
+        Returns:
+            dict[str, Tensor]: a dictionary of loss components
+        """
+        batch_img_metas = []
+        batch_gt_instances = []
+        batch_gt_semantic_segs = []
+        for data_sample in batch_data_samples:
+            batch_img_metas.append(data_sample.metainfo)
+            batch_gt_instances.append(data_sample.gt_instances)
+            if 'gt_sem_seg' in data_sample:
+                batch_gt_semantic_segs.append(data_sample.gt_sem_seg)
+            else:
+                batch_gt_semantic_segs.append(None)
+
+        # forward
+        all_cls_scores, all_mask_preds = self(x, batch_data_samples)
+
+        # preprocess ground truth
+        batch_gt_instances = self.preprocess_gt(batch_gt_instances,
+                                                batch_gt_semantic_segs)
+
+        # loss
+        losses = self.loss_by_feat(all_cls_scores, all_mask_preds,
+                                   batch_gt_instances, batch_img_metas)
+
+        return losses
+
+    def predict(self, x: Tuple[Tensor],
+                batch_data_samples: SampleList) -> Tuple[Tensor]:
+        """Test without augmentaton.
+
+        Args:
+            x (tuple[Tensor]): Multi-level features from the
+                upstream network, each is a 4D-tensor.
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+
+        Returns:
+            tuple[Tensor]: A tuple contains two tensors.
+
+                - mask_cls_results (Tensor): Mask classification logits,\
+                    shape (batch_size, num_queries, cls_out_channels).
+                    Note `cls_out_channels` should includes background.
+                - mask_pred_results (Tensor): Mask logits, shape \
+                    (batch_size, num_queries, h, w).
+        """
+        batch_img_metas = [
+            data_sample.metainfo for data_sample in batch_data_samples
+        ]
+        all_cls_scores, all_mask_preds = self(x, batch_data_samples)
+        mask_cls_results = all_cls_scores[-1]
+        mask_pred_results = all_mask_preds[-1]
+
+        # upsample masks
+        img_shape = batch_img_metas[0]['batch_input_shape']
+        mask_pred_results = F.interpolate(
+            mask_pred_results,
+            size=(img_shape[0], img_shape[1]),
+            mode='bilinear',
+            align_corners=False)
+
+        return mask_cls_results, mask_pred_results
diff --git a/mmdetection/mmdet/models/dense_heads/nasfcos_head.py b/mmdetection/mmdet/models/dense_heads/nasfcos_head.py
new file mode 100644
index 00000000..14ee62a7
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/nasfcos_head.py
@@ -0,0 +1,114 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+
+import torch.nn as nn
+from mmcv.cnn import ConvModule, Scale
+
+from mmdet.models.dense_heads.fcos_head import FCOSHead
+from mmdet.registry import MODELS
+from mmdet.utils import OptMultiConfig
+
+
+@MODELS.register_module()
+class NASFCOSHead(FCOSHead):
+    """Anchor-free head used in `NASFCOS `_.
+
+    It is quite similar with FCOS head, except for the searched structure of
+    classification branch and bbox regression branch, where a structure of
+    "dconv3x3, conv3x3, dconv3x3, conv1x1" is utilized instead.
+
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (int): Number of channels in the input feature map.
+        strides (Sequence[int] or Sequence[Tuple[int, int]]): Strides of points
+            in multiple feature levels. Defaults to (4, 8, 16, 32, 64).
+        regress_ranges (Sequence[Tuple[int, int]]): Regress range of multiple
+            level points.
+        center_sampling (bool): If true, use center sampling.
+            Defaults to False.
+        center_sample_radius (float): Radius of center sampling.
+            Defaults to 1.5.
+        norm_on_bbox (bool): If true, normalize the regression targets with
+            FPN strides. Defaults to False.
+        centerness_on_reg (bool): If true, position centerness on the
+            regress branch. Please refer to https://github.com/tianzhi0549/FCOS/issues/89#issuecomment-516877042.
+            Defaults to False.
+        conv_bias (bool or str): If specified as `auto`, it will be decided by
+            the norm_cfg. Bias of conv will be set as True if `norm_cfg` is
+            None, otherwise False. Defaults to "auto".
+        loss_cls (:obj:`ConfigDict` or dict): Config of classification loss.
+        loss_bbox (:obj:`ConfigDict` or dict): Config of localization loss.
+        loss_centerness (:obj:`ConfigDict`, or dict): Config of centerness
+            loss.
+        norm_cfg (:obj:`ConfigDict` or dict): dictionary to construct and
+            config norm layer.  Defaults to
+            ``norm_cfg=dict(type='GN', num_groups=32, requires_grad=True)``.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict], opitonal): Initialization config dict.
+    """  # noqa: E501
+
+    def __init__(self,
+                 *args,
+                 init_cfg: OptMultiConfig = None,
+                 **kwargs) -> None:
+        if init_cfg is None:
+            init_cfg = [
+                dict(type='Caffe2Xavier', layer=['ConvModule', 'Conv2d']),
+                dict(
+                    type='Normal',
+                    std=0.01,
+                    override=[
+                        dict(name='conv_reg'),
+                        dict(name='conv_centerness'),
+                        dict(
+                            name='conv_cls',
+                            type='Normal',
+                            std=0.01,
+                            bias_prob=0.01)
+                    ]),
+            ]
+        super().__init__(*args, init_cfg=init_cfg, **kwargs)
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        dconv3x3_config = dict(
+            type='DCNv2',
+            kernel_size=3,
+            use_bias=True,
+            deform_groups=2,
+            padding=1)
+        conv3x3_config = dict(type='Conv', kernel_size=3, padding=1)
+        conv1x1_config = dict(type='Conv', kernel_size=1)
+
+        self.arch_config = [
+            dconv3x3_config, conv3x3_config, dconv3x3_config, conv1x1_config
+        ]
+        self.cls_convs = nn.ModuleList()
+        self.reg_convs = nn.ModuleList()
+        for i, op_ in enumerate(self.arch_config):
+            op = copy.deepcopy(op_)
+            chn = self.in_channels if i == 0 else self.feat_channels
+            assert isinstance(op, dict)
+            use_bias = op.pop('use_bias', False)
+            padding = op.pop('padding', 0)
+            kernel_size = op.pop('kernel_size')
+            module = ConvModule(
+                chn,
+                self.feat_channels,
+                kernel_size,
+                stride=1,
+                padding=padding,
+                norm_cfg=self.norm_cfg,
+                bias=use_bias,
+                conv_cfg=op)
+
+            self.cls_convs.append(copy.deepcopy(module))
+            self.reg_convs.append(copy.deepcopy(module))
+
+        self.conv_cls = nn.Conv2d(
+            self.feat_channels, self.cls_out_channels, 3, padding=1)
+        self.conv_reg = nn.Conv2d(self.feat_channels, 4, 3, padding=1)
+        self.conv_centerness = nn.Conv2d(self.feat_channels, 1, 3, padding=1)
+
+        self.scales = nn.ModuleList([Scale(1.0) for _ in self.strides])
diff --git a/mmdetection/mmdet/models/dense_heads/paa_head.py b/mmdetection/mmdet/models/dense_heads/paa_head.py
new file mode 100644
index 00000000..3c1f453d
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/paa_head.py
@@ -0,0 +1,730 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Tuple
+
+import numpy as np
+import torch
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures.bbox import bbox_overlaps
+from mmdet.utils import (ConfigType, InstanceList, OptConfigType,
+                         OptInstanceList)
+from ..layers import multiclass_nms
+from ..utils import levels_to_images, multi_apply
+from . import ATSSHead
+
+EPS = 1e-12
+try:
+    import sklearn.mixture as skm
+except ImportError:
+    skm = None
+
+
+@MODELS.register_module()
+class PAAHead(ATSSHead):
+    """Head of PAAAssignment: Probabilistic Anchor Assignment with IoU
+    Prediction for Object Detection.
+
+    Code is modified from the `official github repo
+    `_.
+
+    More details can be found in the `paper
+    `_ .
+
+    Args:
+        topk (int): Select topk samples with smallest loss in
+            each level.
+        score_voting (bool): Whether to use score voting in post-process.
+        covariance_type : String describing the type of covariance parameters
+            to be used in :class:`sklearn.mixture.GaussianMixture`.
+            It must be one of:
+
+            - 'full': each component has its own general covariance matrix
+            - 'tied': all components share the same general covariance matrix
+            - 'diag': each component has its own diagonal covariance matrix
+            - 'spherical': each component has its own single variance
+            Default: 'diag'. From 'full' to 'spherical', the gmm fitting
+            process is faster yet the performance could be influenced. For most
+            cases, 'diag' should be a good choice.
+    """
+
+    def __init__(self,
+                 *args,
+                 topk: int = 9,
+                 score_voting: bool = True,
+                 covariance_type: str = 'diag',
+                 **kwargs):
+        # topk used in paa reassign process
+        self.topk = topk
+        self.with_score_voting = score_voting
+        self.covariance_type = covariance_type
+        super().__init__(*args, **kwargs)
+
+    def loss_by_feat(
+            self,
+            cls_scores: List[Tensor],
+            bbox_preds: List[Tensor],
+            iou_preds: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> dict:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level
+                Has shape (N, num_anchors * num_classes, H, W)
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level with shape (N, num_anchors * 4, H, W)
+            iou_preds (list[Tensor]): iou_preds for each scale
+                level with shape (N, num_anchors * 1, H, W)
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss gmm_assignment.
+        """
+
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        assert len(featmap_sizes) == self.prior_generator.num_levels
+
+        device = cls_scores[0].device
+        anchor_list, valid_flag_list = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+        cls_reg_targets = self.get_targets(
+            anchor_list,
+            valid_flag_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore,
+        )
+        (labels, labels_weight, bboxes_target, bboxes_weight, pos_inds,
+         pos_gt_index) = cls_reg_targets
+        cls_scores = levels_to_images(cls_scores)
+        cls_scores = [
+            item.reshape(-1, self.cls_out_channels) for item in cls_scores
+        ]
+        bbox_preds = levels_to_images(bbox_preds)
+        bbox_preds = [item.reshape(-1, 4) for item in bbox_preds]
+        iou_preds = levels_to_images(iou_preds)
+        iou_preds = [item.reshape(-1, 1) for item in iou_preds]
+        pos_losses_list, = multi_apply(self.get_pos_loss, anchor_list,
+                                       cls_scores, bbox_preds, labels,
+                                       labels_weight, bboxes_target,
+                                       bboxes_weight, pos_inds)
+
+        with torch.no_grad():
+            reassign_labels, reassign_label_weight, \
+                reassign_bbox_weights, num_pos = multi_apply(
+                    self.paa_reassign,
+                    pos_losses_list,
+                    labels,
+                    labels_weight,
+                    bboxes_weight,
+                    pos_inds,
+                    pos_gt_index,
+                    anchor_list)
+            num_pos = sum(num_pos)
+        # convert all tensor list to a flatten tensor
+        cls_scores = torch.cat(cls_scores, 0).view(-1, cls_scores[0].size(-1))
+        bbox_preds = torch.cat(bbox_preds, 0).view(-1, bbox_preds[0].size(-1))
+        iou_preds = torch.cat(iou_preds, 0).view(-1, iou_preds[0].size(-1))
+        labels = torch.cat(reassign_labels, 0).view(-1)
+        flatten_anchors = torch.cat(
+            [torch.cat(item, 0) for item in anchor_list])
+        labels_weight = torch.cat(reassign_label_weight, 0).view(-1)
+        bboxes_target = torch.cat(bboxes_target,
+                                  0).view(-1, bboxes_target[0].size(-1))
+
+        pos_inds_flatten = ((labels >= 0)
+                            &
+                            (labels < self.num_classes)).nonzero().reshape(-1)
+
+        losses_cls = self.loss_cls(
+            cls_scores,
+            labels,
+            labels_weight,
+            avg_factor=max(num_pos, len(batch_img_metas)))  # avoid num_pos=0
+        if num_pos:
+            pos_bbox_pred = self.bbox_coder.decode(
+                flatten_anchors[pos_inds_flatten],
+                bbox_preds[pos_inds_flatten])
+            pos_bbox_target = bboxes_target[pos_inds_flatten]
+            iou_target = bbox_overlaps(
+                pos_bbox_pred.detach(), pos_bbox_target, is_aligned=True)
+            losses_iou = self.loss_centerness(
+                iou_preds[pos_inds_flatten],
+                iou_target.unsqueeze(-1),
+                avg_factor=num_pos)
+            losses_bbox = self.loss_bbox(
+                pos_bbox_pred,
+                pos_bbox_target,
+                iou_target.clamp(min=EPS),
+                avg_factor=iou_target.sum())
+        else:
+            losses_iou = iou_preds.sum() * 0
+            losses_bbox = bbox_preds.sum() * 0
+
+        return dict(
+            loss_cls=losses_cls, loss_bbox=losses_bbox, loss_iou=losses_iou)
+
+    def get_pos_loss(self, anchors: List[Tensor], cls_score: Tensor,
+                     bbox_pred: Tensor, label: Tensor, label_weight: Tensor,
+                     bbox_target: dict, bbox_weight: Tensor,
+                     pos_inds: Tensor) -> Tensor:
+        """Calculate loss of all potential positive samples obtained from first
+        match process.
+
+        Args:
+            anchors (list[Tensor]): Anchors of each scale.
+            cls_score (Tensor): Box scores of single image with shape
+                (num_anchors, num_classes)
+            bbox_pred (Tensor): Box energies / deltas of single image
+                with shape (num_anchors, 4)
+            label (Tensor): classification target of each anchor with
+                shape (num_anchors,)
+            label_weight (Tensor): Classification loss weight of each
+                anchor with shape (num_anchors).
+            bbox_target (dict): Regression target of each anchor with
+                shape (num_anchors, 4).
+            bbox_weight (Tensor): Bbox weight of each anchor with shape
+                (num_anchors, 4).
+            pos_inds (Tensor): Index of all positive samples got from
+                first assign process.
+
+        Returns:
+            Tensor: Losses of all positive samples in single image.
+        """
+        if not len(pos_inds):
+            return cls_score.new([]),
+        anchors_all_level = torch.cat(anchors, 0)
+        pos_scores = cls_score[pos_inds]
+        pos_bbox_pred = bbox_pred[pos_inds]
+        pos_label = label[pos_inds]
+        pos_label_weight = label_weight[pos_inds]
+        pos_bbox_target = bbox_target[pos_inds]
+        pos_bbox_weight = bbox_weight[pos_inds]
+        pos_anchors = anchors_all_level[pos_inds]
+        pos_bbox_pred = self.bbox_coder.decode(pos_anchors, pos_bbox_pred)
+
+        # to keep loss dimension
+        loss_cls = self.loss_cls(
+            pos_scores,
+            pos_label,
+            pos_label_weight,
+            avg_factor=1.0,
+            reduction_override='none')
+
+        loss_bbox = self.loss_bbox(
+            pos_bbox_pred,
+            pos_bbox_target,
+            pos_bbox_weight,
+            avg_factor=1.0,  # keep same loss weight before reassign
+            reduction_override='none')
+
+        loss_cls = loss_cls.sum(-1)
+        pos_loss = loss_bbox + loss_cls
+        return pos_loss,
+
+    def paa_reassign(self, pos_losses: Tensor, label: Tensor,
+                     label_weight: Tensor, bbox_weight: Tensor,
+                     pos_inds: Tensor, pos_gt_inds: Tensor,
+                     anchors: List[Tensor]) -> tuple:
+        """Fit loss to GMM distribution and separate positive, ignore, negative
+        samples again with GMM model.
+
+        Args:
+            pos_losses (Tensor): Losses of all positive samples in
+                single image.
+            label (Tensor): classification target of each anchor with
+                shape (num_anchors,)
+            label_weight (Tensor): Classification loss weight of each
+                anchor with shape (num_anchors).
+            bbox_weight (Tensor): Bbox weight of each anchor with shape
+                (num_anchors, 4).
+            pos_inds (Tensor): Index of all positive samples got from
+                first assign process.
+            pos_gt_inds (Tensor): Gt_index of all positive samples got
+                from first assign process.
+            anchors (list[Tensor]): Anchors of each scale.
+
+        Returns:
+            tuple: Usually returns a tuple containing learning targets.
+
+                - label (Tensor): classification target of each anchor after
+                  paa assign, with shape (num_anchors,)
+                - label_weight (Tensor): Classification loss weight of each
+                  anchor after paa assign, with shape (num_anchors).
+                - bbox_weight (Tensor): Bbox weight of each anchor with shape
+                  (num_anchors, 4).
+                - num_pos (int): The number of positive samples after paa
+                  assign.
+        """
+        if not len(pos_inds):
+            return label, label_weight, bbox_weight, 0
+        label = label.clone()
+        label_weight = label_weight.clone()
+        bbox_weight = bbox_weight.clone()
+        num_gt = pos_gt_inds.max() + 1
+        num_level = len(anchors)
+        num_anchors_each_level = [item.size(0) for item in anchors]
+        num_anchors_each_level.insert(0, 0)
+        inds_level_interval = np.cumsum(num_anchors_each_level)
+        pos_level_mask = []
+        for i in range(num_level):
+            mask = (pos_inds >= inds_level_interval[i]) & (
+                pos_inds < inds_level_interval[i + 1])
+            pos_level_mask.append(mask)
+        pos_inds_after_paa = [label.new_tensor([])]
+        ignore_inds_after_paa = [label.new_tensor([])]
+        for gt_ind in range(num_gt):
+            pos_inds_gmm = []
+            pos_loss_gmm = []
+            gt_mask = pos_gt_inds == gt_ind
+            for level in range(num_level):
+                level_mask = pos_level_mask[level]
+                level_gt_mask = level_mask & gt_mask
+                value, topk_inds = pos_losses[level_gt_mask].topk(
+                    min(level_gt_mask.sum(), self.topk), largest=False)
+                pos_inds_gmm.append(pos_inds[level_gt_mask][topk_inds])
+                pos_loss_gmm.append(value)
+            pos_inds_gmm = torch.cat(pos_inds_gmm)
+            pos_loss_gmm = torch.cat(pos_loss_gmm)
+            # fix gmm need at least two sample
+            if len(pos_inds_gmm) < 2:
+                continue
+            device = pos_inds_gmm.device
+            pos_loss_gmm, sort_inds = pos_loss_gmm.sort()
+            pos_inds_gmm = pos_inds_gmm[sort_inds]
+            pos_loss_gmm = pos_loss_gmm.view(-1, 1).cpu().numpy()
+            min_loss, max_loss = pos_loss_gmm.min(), pos_loss_gmm.max()
+            means_init = np.array([min_loss, max_loss]).reshape(2, 1)
+            weights_init = np.array([0.5, 0.5])
+            precisions_init = np.array([1.0, 1.0]).reshape(2, 1, 1)  # full
+            if self.covariance_type == 'spherical':
+                precisions_init = precisions_init.reshape(2)
+            elif self.covariance_type == 'diag':
+                precisions_init = precisions_init.reshape(2, 1)
+            elif self.covariance_type == 'tied':
+                precisions_init = np.array([[1.0]])
+            if skm is None:
+                raise ImportError('Please run "pip install sklearn" '
+                                  'to install sklearn first.')
+            gmm = skm.GaussianMixture(
+                2,
+                weights_init=weights_init,
+                means_init=means_init,
+                precisions_init=precisions_init,
+                covariance_type=self.covariance_type)
+            gmm.fit(pos_loss_gmm)
+            gmm_assignment = gmm.predict(pos_loss_gmm)
+            scores = gmm.score_samples(pos_loss_gmm)
+            gmm_assignment = torch.from_numpy(gmm_assignment).to(device)
+            scores = torch.from_numpy(scores).to(device)
+
+            pos_inds_temp, ignore_inds_temp = self.gmm_separation_scheme(
+                gmm_assignment, scores, pos_inds_gmm)
+            pos_inds_after_paa.append(pos_inds_temp)
+            ignore_inds_after_paa.append(ignore_inds_temp)
+
+        pos_inds_after_paa = torch.cat(pos_inds_after_paa)
+        ignore_inds_after_paa = torch.cat(ignore_inds_after_paa)
+        reassign_mask = (pos_inds.unsqueeze(1) != pos_inds_after_paa).all(1)
+        reassign_ids = pos_inds[reassign_mask]
+        label[reassign_ids] = self.num_classes
+        label_weight[ignore_inds_after_paa] = 0
+        bbox_weight[reassign_ids] = 0
+        num_pos = len(pos_inds_after_paa)
+        return label, label_weight, bbox_weight, num_pos
+
+    def gmm_separation_scheme(self, gmm_assignment: Tensor, scores: Tensor,
+                              pos_inds_gmm: Tensor) -> Tuple[Tensor, Tensor]:
+        """A general separation scheme for gmm model.
+
+        It separates a GMM distribution of candidate samples into three
+        parts, 0 1 and uncertain areas, and you can implement other
+        separation schemes by rewriting this function.
+
+        Args:
+            gmm_assignment (Tensor): The prediction of GMM which is of shape
+                (num_samples,). The 0/1 value indicates the distribution
+                that each sample comes from.
+            scores (Tensor): The probability of sample coming from the
+                fit GMM distribution. The tensor is of shape (num_samples,).
+            pos_inds_gmm (Tensor): All the indexes of samples which are used
+                to fit GMM model. The tensor is of shape (num_samples,)
+
+        Returns:
+            tuple[Tensor, Tensor]: The indices of positive and ignored samples.
+
+                - pos_inds_temp (Tensor): Indices of positive samples.
+                - ignore_inds_temp (Tensor): Indices of ignore samples.
+        """
+        # The implementation is (c) in Fig.3 in origin paper instead of (b).
+        # You can refer to issues such as
+        # https://github.com/kkhoot/PAA/issues/8 and
+        # https://github.com/kkhoot/PAA/issues/9.
+        fgs = gmm_assignment == 0
+        pos_inds_temp = fgs.new_tensor([], dtype=torch.long)
+        ignore_inds_temp = fgs.new_tensor([], dtype=torch.long)
+        if fgs.nonzero().numel():
+            _, pos_thr_ind = scores[fgs].topk(1)
+            pos_inds_temp = pos_inds_gmm[fgs][:pos_thr_ind + 1]
+            ignore_inds_temp = pos_inds_gmm.new_tensor([])
+        return pos_inds_temp, ignore_inds_temp
+
+    def get_targets(self,
+                    anchor_list: List[List[Tensor]],
+                    valid_flag_list: List[List[Tensor]],
+                    batch_gt_instances: InstanceList,
+                    batch_img_metas: List[dict],
+                    batch_gt_instances_ignore: OptInstanceList = None,
+                    unmap_outputs: bool = True) -> tuple:
+        """Get targets for PAA head.
+
+        This method is almost the same as `AnchorHead.get_targets()`. We direct
+        return the results from _get_targets_single instead map it to levels
+        by images_to_levels function.
+
+        Args:
+            anchor_list (list[list[Tensor]]): Multi level anchors of each
+                image. The outer list indicates images, and the inner list
+                corresponds to feature levels of the image. Each element of
+                the inner list is a tensor of shape (num_anchors, 4).
+            valid_flag_list (list[list[Tensor]]): Multi level valid flags of
+                each image. The outer list indicates images, and the inner list
+                corresponds to feature levels of the image. Each element of
+                the inner list is a tensor of shape (num_anchors, )
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+            unmap_outputs (bool): Whether to map outputs back to the original
+                set of anchors. Defaults to True.
+
+        Returns:
+            tuple: Usually returns a tuple containing learning targets.
+
+                - labels (list[Tensor]): Labels of all anchors, each with
+                    shape (num_anchors,).
+                - label_weights (list[Tensor]): Label weights of all anchor.
+                    each with shape (num_anchors,).
+                - bbox_targets (list[Tensor]): BBox targets of all anchors.
+                    each with shape (num_anchors, 4).
+                - bbox_weights (list[Tensor]): BBox weights of all anchors.
+                    each with shape (num_anchors, 4).
+                - pos_inds (list[Tensor]): Contains all index of positive
+                    sample in all anchor.
+                - gt_inds (list[Tensor]): Contains all gt_index of positive
+                    sample in all anchor.
+        """
+
+        num_imgs = len(batch_img_metas)
+        assert len(anchor_list) == len(valid_flag_list) == num_imgs
+        concat_anchor_list = []
+        concat_valid_flag_list = []
+        for i in range(num_imgs):
+            assert len(anchor_list[i]) == len(valid_flag_list[i])
+            concat_anchor_list.append(torch.cat(anchor_list[i]))
+            concat_valid_flag_list.append(torch.cat(valid_flag_list[i]))
+
+        # compute targets for each image
+        if batch_gt_instances_ignore is None:
+            batch_gt_instances_ignore = [None] * num_imgs
+        results = multi_apply(
+            self._get_targets_single,
+            concat_anchor_list,
+            concat_valid_flag_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore,
+            unmap_outputs=unmap_outputs)
+
+        (labels, label_weights, bbox_targets, bbox_weights, valid_pos_inds,
+         valid_neg_inds, sampling_result) = results
+
+        # Due to valid flag of anchors, we have to calculate the real pos_inds
+        # in origin anchor set.
+        pos_inds = []
+        for i, single_labels in enumerate(labels):
+            pos_mask = (0 <= single_labels) & (
+                single_labels < self.num_classes)
+            pos_inds.append(pos_mask.nonzero().view(-1))
+
+        gt_inds = [item.pos_assigned_gt_inds for item in sampling_result]
+        return (labels, label_weights, bbox_targets, bbox_weights, pos_inds,
+                gt_inds)
+
+    def _get_targets_single(self,
+                            flat_anchors: Tensor,
+                            valid_flags: Tensor,
+                            gt_instances: InstanceData,
+                            img_meta: dict,
+                            gt_instances_ignore: Optional[InstanceData] = None,
+                            unmap_outputs: bool = True) -> tuple:
+        """Compute regression and classification targets for anchors in a
+        single image.
+
+        This method is same as `AnchorHead._get_targets_single()`.
+        """
+        assert unmap_outputs, 'We must map outputs back to the original' \
+                              'set of anchors in PAAhead'
+        return super(ATSSHead, self)._get_targets_single(
+            flat_anchors,
+            valid_flags,
+            gt_instances,
+            img_meta,
+            gt_instances_ignore,
+            unmap_outputs=True)
+
+    def predict_by_feat(self,
+                        cls_scores: List[Tensor],
+                        bbox_preds: List[Tensor],
+                        score_factors: Optional[List[Tensor]] = None,
+                        batch_img_metas: Optional[List[dict]] = None,
+                        cfg: OptConfigType = None,
+                        rescale: bool = False,
+                        with_nms: bool = True) -> InstanceList:
+        """Transform a batch of output features extracted from the head into
+        bbox results.
+
+        This method is same as `BaseDenseHead.get_results()`.
+        """
+        assert with_nms, 'PAA only supports "with_nms=True" now and it ' \
+                         'means PAAHead does not support ' \
+                         'test-time augmentation'
+        return super().predict_by_feat(
+            cls_scores=cls_scores,
+            bbox_preds=bbox_preds,
+            score_factors=score_factors,
+            batch_img_metas=batch_img_metas,
+            cfg=cfg,
+            rescale=rescale,
+            with_nms=with_nms)
+
+    def _predict_by_feat_single(self,
+                                cls_score_list: List[Tensor],
+                                bbox_pred_list: List[Tensor],
+                                score_factor_list: List[Tensor],
+                                mlvl_priors: List[Tensor],
+                                img_meta: dict,
+                                cfg: OptConfigType = None,
+                                rescale: bool = False,
+                                with_nms: bool = True) -> InstanceData:
+        """Transform a single image's features extracted from the head into
+        bbox results.
+
+        Args:
+            cls_score_list (list[Tensor]): Box scores from all scale
+                levels of a single image, each item has shape
+                (num_priors * num_classes, H, W).
+            bbox_pred_list (list[Tensor]): Box energies / deltas from
+                all scale levels of a single image, each item has shape
+                (num_priors * 4, H, W).
+            score_factor_list (list[Tensor]): Score factors from all scale
+                levels of a single image, each item has shape
+                (num_priors * 1, H, W).
+            mlvl_priors (list[Tensor]): Each element in the list is
+                the priors of a single level in feature pyramid, has shape
+                (num_priors, 4).
+            img_meta (dict): Image meta info.
+            cfg (:obj:`ConfigDict` or dict, optional): Test / postprocessing
+                configuration, if None, test_cfg would be used.
+            rescale (bool): If True, return boxes in original image space.
+                Default: False.
+            with_nms (bool): If True, do nms before return boxes.
+                Default: True.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        cfg = self.test_cfg if cfg is None else cfg
+        img_shape = img_meta['img_shape']
+        nms_pre = cfg.get('nms_pre', -1)
+
+        mlvl_bboxes = []
+        mlvl_scores = []
+        mlvl_score_factors = []
+        for level_idx, (cls_score, bbox_pred, score_factor, priors) in \
+                enumerate(zip(cls_score_list, bbox_pred_list,
+                              score_factor_list, mlvl_priors)):
+            assert cls_score.size()[-2:] == bbox_pred.size()[-2:]
+
+            scores = cls_score.permute(1, 2, 0).reshape(
+                -1, self.cls_out_channels).sigmoid()
+            bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, 4)
+            score_factor = score_factor.permute(1, 2, 0).reshape(-1).sigmoid()
+
+            if 0 < nms_pre < scores.shape[0]:
+                max_scores, _ = (scores *
+                                 score_factor[:, None]).sqrt().max(dim=1)
+                _, topk_inds = max_scores.topk(nms_pre)
+                priors = priors[topk_inds, :]
+                bbox_pred = bbox_pred[topk_inds, :]
+                scores = scores[topk_inds, :]
+                score_factor = score_factor[topk_inds]
+
+            bboxes = self.bbox_coder.decode(
+                priors, bbox_pred, max_shape=img_shape)
+            mlvl_bboxes.append(bboxes)
+            mlvl_scores.append(scores)
+            mlvl_score_factors.append(score_factor)
+
+        results = InstanceData()
+        results.bboxes = torch.cat(mlvl_bboxes)
+        results.scores = torch.cat(mlvl_scores)
+        results.score_factors = torch.cat(mlvl_score_factors)
+
+        return self._bbox_post_process(results, cfg, rescale, with_nms,
+                                       img_meta)
+
+    def _bbox_post_process(self,
+                           results: InstanceData,
+                           cfg: ConfigType,
+                           rescale: bool = False,
+                           with_nms: bool = True,
+                           img_meta: Optional[dict] = None):
+        """bbox post-processing method.
+
+        The boxes would be rescaled to the original image scale and do
+        the nms operation. Usually with_nms is False is used for aug test.
+
+        Args:
+            results (:obj:`InstaceData`): Detection instance results,
+                each item has shape (num_bboxes, ).
+            cfg (:obj:`ConfigDict` or dict): Test / postprocessing
+                configuration, if None, test_cfg would be used.
+            rescale (bool): If True, return boxes in original image space.
+                Default: False.
+            with_nms (bool): If True, do nms before return boxes.
+                Default: True.
+            img_meta (dict, optional): Image meta info. Defaults to None.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        if rescale:
+            results.bboxes /= results.bboxes.new_tensor(
+                img_meta['scale_factor']).repeat((1, 2))
+        # Add a dummy background class to the backend when using sigmoid
+        # remind that we set FG labels to [0, num_class-1] since mmdet v2.0
+        # BG cat_id: num_class
+        padding = results.scores.new_zeros(results.scores.shape[0], 1)
+        mlvl_scores = torch.cat([results.scores, padding], dim=1)
+
+        mlvl_nms_scores = (mlvl_scores * results.score_factors[:, None]).sqrt()
+        det_bboxes, det_labels = multiclass_nms(
+            results.bboxes,
+            mlvl_nms_scores,
+            cfg.score_thr,
+            cfg.nms,
+            cfg.max_per_img,
+            score_factors=None)
+        if self.with_score_voting and len(det_bboxes) > 0:
+            det_bboxes, det_labels = self.score_voting(det_bboxes, det_labels,
+                                                       results.bboxes,
+                                                       mlvl_nms_scores,
+                                                       cfg.score_thr)
+        nms_results = InstanceData()
+        nms_results.bboxes = det_bboxes[:, :-1]
+        nms_results.scores = det_bboxes[:, -1]
+        nms_results.labels = det_labels
+        return nms_results
+
+    def score_voting(self, det_bboxes: Tensor, det_labels: Tensor,
+                     mlvl_bboxes: Tensor, mlvl_nms_scores: Tensor,
+                     score_thr: float) -> Tuple[Tensor, Tensor]:
+        """Implementation of score voting method works on each remaining boxes
+        after NMS procedure.
+
+        Args:
+            det_bboxes (Tensor): Remaining boxes after NMS procedure,
+                with shape (k, 5), each dimension means
+                (x1, y1, x2, y2, score).
+            det_labels (Tensor): The label of remaining boxes, with shape
+                (k, 1),Labels are 0-based.
+            mlvl_bboxes (Tensor): All boxes before the NMS procedure,
+                with shape (num_anchors,4).
+            mlvl_nms_scores (Tensor): The scores of all boxes which is used
+                in the NMS procedure, with shape (num_anchors, num_class)
+            score_thr (float): The score threshold of bboxes.
+
+        Returns:
+            tuple: Usually returns a tuple containing voting results.
+
+                - det_bboxes_voted (Tensor): Remaining boxes after
+                    score voting procedure, with shape (k, 5), each
+                    dimension means (x1, y1, x2, y2, score).
+                - det_labels_voted (Tensor): Label of remaining bboxes
+                    after voting, with shape (num_anchors,).
+        """
+        candidate_mask = mlvl_nms_scores > score_thr
+        candidate_mask_nonzeros = candidate_mask.nonzero(as_tuple=False)
+        candidate_inds = candidate_mask_nonzeros[:, 0]
+        candidate_labels = candidate_mask_nonzeros[:, 1]
+        candidate_bboxes = mlvl_bboxes[candidate_inds]
+        candidate_scores = mlvl_nms_scores[candidate_mask]
+        det_bboxes_voted = []
+        det_labels_voted = []
+        for cls in range(self.cls_out_channels):
+            candidate_cls_mask = candidate_labels == cls
+            if not candidate_cls_mask.any():
+                continue
+            candidate_cls_scores = candidate_scores[candidate_cls_mask]
+            candidate_cls_bboxes = candidate_bboxes[candidate_cls_mask]
+            det_cls_mask = det_labels == cls
+            det_cls_bboxes = det_bboxes[det_cls_mask].view(
+                -1, det_bboxes.size(-1))
+            det_candidate_ious = bbox_overlaps(det_cls_bboxes[:, :4],
+                                               candidate_cls_bboxes)
+            for det_ind in range(len(det_cls_bboxes)):
+                single_det_ious = det_candidate_ious[det_ind]
+                pos_ious_mask = single_det_ious > 0.01
+                pos_ious = single_det_ious[pos_ious_mask]
+                pos_bboxes = candidate_cls_bboxes[pos_ious_mask]
+                pos_scores = candidate_cls_scores[pos_ious_mask]
+                pis = (torch.exp(-(1 - pos_ious)**2 / 0.025) *
+                       pos_scores)[:, None]
+                voted_box = torch.sum(
+                    pis * pos_bboxes, dim=0) / torch.sum(
+                        pis, dim=0)
+                voted_score = det_cls_bboxes[det_ind][-1:][None, :]
+                det_bboxes_voted.append(
+                    torch.cat((voted_box[None, :], voted_score), dim=1))
+                det_labels_voted.append(cls)
+
+        det_bboxes_voted = torch.cat(det_bboxes_voted, dim=0)
+        det_labels_voted = det_labels.new_tensor(det_labels_voted)
+        return det_bboxes_voted, det_labels_voted
diff --git a/mmdetection/mmdet/models/dense_heads/pisa_retinanet_head.py b/mmdetection/mmdet/models/dense_heads/pisa_retinanet_head.py
new file mode 100644
index 00000000..85fd54f5
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/pisa_retinanet_head.py
@@ -0,0 +1,154 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List
+
+import torch
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import InstanceList, OptInstanceList
+from ..losses import carl_loss, isr_p
+from ..utils import images_to_levels
+from .retina_head import RetinaHead
+
+
+@MODELS.register_module()
+class PISARetinaHead(RetinaHead):
+    """PISA Retinanet Head.
+
+    The head owns the same structure with Retinanet Head, but differs in two
+        aspects:
+        1. Importance-based Sample Reweighting Positive (ISR-P) is applied to
+            change the positive loss weights.
+        2. Classification-aware regression loss is adopted as a third loss.
+    """
+
+    def loss_by_feat(
+            self,
+            cls_scores: List[Tensor],
+            bbox_preds: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> dict:
+        """Compute losses of the head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level
+                Has shape (N, num_anchors * num_classes, H, W)
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level with shape (N, num_anchors * 4, H, W)
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict: Loss dict, comprise classification loss, regression loss and
+            carl loss.
+        """
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        assert len(featmap_sizes) == self.prior_generator.num_levels
+
+        device = cls_scores[0].device
+
+        anchor_list, valid_flag_list = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+        label_channels = self.cls_out_channels if self.use_sigmoid_cls else 1
+        cls_reg_targets = self.get_targets(
+            anchor_list,
+            valid_flag_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore,
+            return_sampling_results=True)
+        if cls_reg_targets is None:
+            return None
+        (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,
+         avg_factor, sampling_results_list) = cls_reg_targets
+
+        # anchor number of multi levels
+        num_level_anchors = [anchors.size(0) for anchors in anchor_list[0]]
+        # concat all level anchors and flags to a single tensor
+        concat_anchor_list = []
+        for i in range(len(anchor_list)):
+            concat_anchor_list.append(torch.cat(anchor_list[i]))
+        all_anchor_list = images_to_levels(concat_anchor_list,
+                                           num_level_anchors)
+
+        num_imgs = len(batch_img_metas)
+        flatten_cls_scores = [
+            cls_score.permute(0, 2, 3, 1).reshape(num_imgs, -1, label_channels)
+            for cls_score in cls_scores
+        ]
+        flatten_cls_scores = torch.cat(
+            flatten_cls_scores, dim=1).reshape(-1,
+                                               flatten_cls_scores[0].size(-1))
+        flatten_bbox_preds = [
+            bbox_pred.permute(0, 2, 3, 1).reshape(num_imgs, -1, 4)
+            for bbox_pred in bbox_preds
+        ]
+        flatten_bbox_preds = torch.cat(
+            flatten_bbox_preds, dim=1).view(-1, flatten_bbox_preds[0].size(-1))
+        flatten_labels = torch.cat(labels_list, dim=1).reshape(-1)
+        flatten_label_weights = torch.cat(
+            label_weights_list, dim=1).reshape(-1)
+        flatten_anchors = torch.cat(all_anchor_list, dim=1).reshape(-1, 4)
+        flatten_bbox_targets = torch.cat(
+            bbox_targets_list, dim=1).reshape(-1, 4)
+        flatten_bbox_weights = torch.cat(
+            bbox_weights_list, dim=1).reshape(-1, 4)
+
+        # Apply ISR-P
+        isr_cfg = self.train_cfg.get('isr', None)
+        if isr_cfg is not None:
+            all_targets = (flatten_labels, flatten_label_weights,
+                           flatten_bbox_targets, flatten_bbox_weights)
+            with torch.no_grad():
+                all_targets = isr_p(
+                    flatten_cls_scores,
+                    flatten_bbox_preds,
+                    all_targets,
+                    flatten_anchors,
+                    sampling_results_list,
+                    bbox_coder=self.bbox_coder,
+                    loss_cls=self.loss_cls,
+                    num_class=self.num_classes,
+                    **self.train_cfg['isr'])
+            (flatten_labels, flatten_label_weights, flatten_bbox_targets,
+             flatten_bbox_weights) = all_targets
+
+        # For convenience we compute loss once instead separating by fpn level,
+        # so that we don't need to separate the weights by level again.
+        # The result should be the same
+        losses_cls = self.loss_cls(
+            flatten_cls_scores,
+            flatten_labels,
+            flatten_label_weights,
+            avg_factor=avg_factor)
+        losses_bbox = self.loss_bbox(
+            flatten_bbox_preds,
+            flatten_bbox_targets,
+            flatten_bbox_weights,
+            avg_factor=avg_factor)
+        loss_dict = dict(loss_cls=losses_cls, loss_bbox=losses_bbox)
+
+        # CARL Loss
+        carl_cfg = self.train_cfg.get('carl', None)
+        if carl_cfg is not None:
+            loss_carl = carl_loss(
+                flatten_cls_scores,
+                flatten_labels,
+                flatten_bbox_preds,
+                flatten_bbox_targets,
+                self.loss_bbox,
+                **self.train_cfg['carl'],
+                avg_factor=avg_factor,
+                sigmoid=True,
+                num_class=self.num_classes)
+            loss_dict.update(loss_carl)
+
+        return loss_dict
diff --git a/mmdetection/mmdet/models/dense_heads/pisa_ssd_head.py b/mmdetection/mmdet/models/dense_heads/pisa_ssd_head.py
new file mode 100644
index 00000000..ec09cb40
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/pisa_ssd_head.py
@@ -0,0 +1,182 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, List, Union
+
+import torch
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import InstanceList, OptInstanceList
+from ..losses import CrossEntropyLoss, SmoothL1Loss, carl_loss, isr_p
+from ..utils import multi_apply
+from .ssd_head import SSDHead
+
+
+# TODO: add loss evaluator for SSD
+@MODELS.register_module()
+class PISASSDHead(SSDHead):
+    """Implementation of `PISA SSD head `_
+
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (Sequence[int]): Number of channels in the input feature
+            map.
+        stacked_convs (int): Number of conv layers in cls and reg tower.
+            Defaults to 0.
+        feat_channels (int): Number of hidden channels when stacked_convs
+            > 0. Defaults to 256.
+        use_depthwise (bool): Whether to use DepthwiseSeparableConv.
+            Defaults to False.
+        conv_cfg (:obj:`ConfigDict` or dict, Optional): Dictionary to construct
+            and config conv layer. Defaults to None.
+        norm_cfg (:obj:`ConfigDict` or dict, Optional): Dictionary to construct
+            and config norm layer. Defaults to None.
+        act_cfg (:obj:`ConfigDict` or dict, Optional): Dictionary to construct
+            and config activation layer. Defaults to None.
+        anchor_generator (:obj:`ConfigDict` or dict): Config dict for anchor
+            generator.
+        bbox_coder (:obj:`ConfigDict` or dict): Config of bounding box coder.
+        reg_decoded_bbox (bool): If true, the regression loss would be
+            applied directly on decoded bounding boxes, converting both
+            the predicted boxes and regression targets to absolute
+            coordinates format. Defaults to False. It should be `True` when
+            using `IoULoss`, `GIoULoss`, or `DIoULoss` in the bbox head.
+        train_cfg (:obj:`ConfigDict` or dict, Optional): Training config of
+            anchor head.
+        test_cfg (:obj:`ConfigDict` or dict, Optional): Testing config of
+            anchor head.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict], Optional): Initialization config dict.
+    """  # noqa: W605
+
+    def loss_by_feat(
+        self,
+        cls_scores: List[Tensor],
+        bbox_preds: List[Tensor],
+        batch_gt_instances: InstanceList,
+        batch_img_metas: List[dict],
+        batch_gt_instances_ignore: OptInstanceList = None
+    ) -> Dict[str, Union[List[Tensor], Tensor]]:
+        """Compute losses of the head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level
+                Has shape (N, num_anchors * num_classes, H, W)
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level with shape (N, num_anchors * 4, H, W)
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], Optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Union[List[Tensor], Tensor]]: A dictionary of loss
+            components. the dict has components below:
+
+            - loss_cls (list[Tensor]): A list containing each feature map \
+            classification loss.
+            - loss_bbox (list[Tensor]): A list containing each feature map \
+            regression loss.
+            - loss_carl (Tensor): The loss of CARL.
+        """
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        assert len(featmap_sizes) == self.prior_generator.num_levels
+
+        device = cls_scores[0].device
+
+        anchor_list, valid_flag_list = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+        cls_reg_targets = self.get_targets(
+            anchor_list,
+            valid_flag_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore,
+            unmap_outputs=False,
+            return_sampling_results=True)
+        (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,
+         avg_factor, sampling_results_list) = cls_reg_targets
+
+        num_images = len(batch_img_metas)
+        all_cls_scores = torch.cat([
+            s.permute(0, 2, 3, 1).reshape(
+                num_images, -1, self.cls_out_channels) for s in cls_scores
+        ], 1)
+        all_labels = torch.cat(labels_list, -1).view(num_images, -1)
+        all_label_weights = torch.cat(label_weights_list,
+                                      -1).view(num_images, -1)
+        all_bbox_preds = torch.cat([
+            b.permute(0, 2, 3, 1).reshape(num_images, -1, 4)
+            for b in bbox_preds
+        ], -2)
+        all_bbox_targets = torch.cat(bbox_targets_list,
+                                     -2).view(num_images, -1, 4)
+        all_bbox_weights = torch.cat(bbox_weights_list,
+                                     -2).view(num_images, -1, 4)
+
+        # concat all level anchors to a single tensor
+        all_anchors = []
+        for i in range(num_images):
+            all_anchors.append(torch.cat(anchor_list[i]))
+
+        isr_cfg = self.train_cfg.get('isr', None)
+        all_targets = (all_labels.view(-1), all_label_weights.view(-1),
+                       all_bbox_targets.view(-1,
+                                             4), all_bbox_weights.view(-1, 4))
+        # apply ISR-P
+        if isr_cfg is not None:
+            all_targets = isr_p(
+                all_cls_scores.view(-1, all_cls_scores.size(-1)),
+                all_bbox_preds.view(-1, 4),
+                all_targets,
+                torch.cat(all_anchors),
+                sampling_results_list,
+                loss_cls=CrossEntropyLoss(),
+                bbox_coder=self.bbox_coder,
+                **self.train_cfg['isr'],
+                num_class=self.num_classes)
+            (new_labels, new_label_weights, new_bbox_targets,
+             new_bbox_weights) = all_targets
+            all_labels = new_labels.view(all_labels.shape)
+            all_label_weights = new_label_weights.view(all_label_weights.shape)
+            all_bbox_targets = new_bbox_targets.view(all_bbox_targets.shape)
+            all_bbox_weights = new_bbox_weights.view(all_bbox_weights.shape)
+
+        # add CARL loss
+        carl_loss_cfg = self.train_cfg.get('carl', None)
+        if carl_loss_cfg is not None:
+            loss_carl = carl_loss(
+                all_cls_scores.view(-1, all_cls_scores.size(-1)),
+                all_targets[0],
+                all_bbox_preds.view(-1, 4),
+                all_targets[2],
+                SmoothL1Loss(beta=1.),
+                **self.train_cfg['carl'],
+                avg_factor=avg_factor,
+                num_class=self.num_classes)
+
+        # check NaN and Inf
+        assert torch.isfinite(all_cls_scores).all().item(), \
+            'classification scores become infinite or NaN!'
+        assert torch.isfinite(all_bbox_preds).all().item(), \
+            'bbox predications become infinite or NaN!'
+
+        losses_cls, losses_bbox = multi_apply(
+            self.loss_by_feat_single,
+            all_cls_scores,
+            all_bbox_preds,
+            all_anchors,
+            all_labels,
+            all_label_weights,
+            all_bbox_targets,
+            all_bbox_weights,
+            avg_factor=avg_factor)
+        loss_dict = dict(loss_cls=losses_cls, loss_bbox=losses_bbox)
+        if carl_loss_cfg is not None:
+            loss_dict.update(loss_carl)
+        return loss_dict
diff --git a/mmdetection/mmdet/models/dense_heads/reppoints_head.py b/mmdetection/mmdet/models/dense_heads/reppoints_head.py
new file mode 100644
index 00000000..22f3e340
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/reppoints_head.py
@@ -0,0 +1,885 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, List, Sequence, Tuple
+
+import numpy as np
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmcv.ops import DeformConv2d
+from mmengine.config import ConfigDict
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.utils import ConfigType, InstanceList, MultiConfig, OptInstanceList
+from ..task_modules.prior_generators import MlvlPointGenerator
+from ..task_modules.samplers import PseudoSampler
+from ..utils import (filter_scores_and_topk, images_to_levels, multi_apply,
+                     unmap)
+from .anchor_free_head import AnchorFreeHead
+
+
+@MODELS.register_module()
+class RepPointsHead(AnchorFreeHead):
+    """RepPoint head.
+
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (int): Number of channels in the input feature map.
+        point_feat_channels (int): Number of channels of points features.
+        num_points (int): Number of points.
+        gradient_mul (float): The multiplier to gradients from
+            points refinement and recognition.
+        point_strides (Sequence[int]): points strides.
+        point_base_scale (int): bbox scale for assigning labels.
+        loss_cls (:obj:`ConfigDict` or dict): Config of classification loss.
+        loss_bbox_init (:obj:`ConfigDict` or dict): Config of initial points
+            loss.
+        loss_bbox_refine (:obj:`ConfigDict` or dict): Config of points loss in
+            refinement.
+        use_grid_points (bool): If we use bounding box representation, the
+        reppoints is represented as grid points on the bounding box.
+        center_init (bool): Whether to use center point assignment.
+        transform_method (str): The methods to transform RepPoints to bbox.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict]): Initialization config dict.
+    """  # noqa: W605
+
+    def __init__(self,
+                 num_classes: int,
+                 in_channels: int,
+                 point_feat_channels: int = 256,
+                 num_points: int = 9,
+                 gradient_mul: float = 0.1,
+                 point_strides: Sequence[int] = [8, 16, 32, 64, 128],
+                 point_base_scale: int = 4,
+                 loss_cls: ConfigType = dict(
+                     type='FocalLoss',
+                     use_sigmoid=True,
+                     gamma=2.0,
+                     alpha=0.25,
+                     loss_weight=1.0),
+                 loss_bbox_init: ConfigType = dict(
+                     type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=0.5),
+                 loss_bbox_refine: ConfigType = dict(
+                     type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=1.0),
+                 use_grid_points: bool = False,
+                 center_init: bool = True,
+                 transform_method: str = 'moment',
+                 moment_mul: float = 0.01,
+                 init_cfg: MultiConfig = dict(
+                     type='Normal',
+                     layer='Conv2d',
+                     std=0.01,
+                     override=dict(
+                         type='Normal',
+                         name='reppoints_cls_out',
+                         std=0.01,
+                         bias_prob=0.01)),
+                 **kwargs) -> None:
+        self.num_points = num_points
+        self.point_feat_channels = point_feat_channels
+        self.use_grid_points = use_grid_points
+        self.center_init = center_init
+
+        # we use deform conv to extract points features
+        self.dcn_kernel = int(np.sqrt(num_points))
+        self.dcn_pad = int((self.dcn_kernel - 1) / 2)
+        assert self.dcn_kernel * self.dcn_kernel == num_points, \
+            'The points number should be a square number.'
+        assert self.dcn_kernel % 2 == 1, \
+            'The points number should be an odd square number.'
+        dcn_base = np.arange(-self.dcn_pad,
+                             self.dcn_pad + 1).astype(np.float64)
+        dcn_base_y = np.repeat(dcn_base, self.dcn_kernel)
+        dcn_base_x = np.tile(dcn_base, self.dcn_kernel)
+        dcn_base_offset = np.stack([dcn_base_y, dcn_base_x], axis=1).reshape(
+            (-1))
+        self.dcn_base_offset = torch.tensor(dcn_base_offset).view(1, -1, 1, 1)
+
+        super().__init__(
+            num_classes=num_classes,
+            in_channels=in_channels,
+            loss_cls=loss_cls,
+            init_cfg=init_cfg,
+            **kwargs)
+
+        self.gradient_mul = gradient_mul
+        self.point_base_scale = point_base_scale
+        self.point_strides = point_strides
+        self.prior_generator = MlvlPointGenerator(
+            self.point_strides, offset=0.)
+
+        if self.train_cfg:
+            self.init_assigner = TASK_UTILS.build(
+                self.train_cfg['init']['assigner'])
+            self.refine_assigner = TASK_UTILS.build(
+                self.train_cfg['refine']['assigner'])
+
+            if self.train_cfg.get('sampler', None) is not None:
+                self.sampler = TASK_UTILS.build(
+                    self.train_cfg['sampler'], default_args=dict(context=self))
+            else:
+                self.sampler = PseudoSampler(context=self)
+
+        self.transform_method = transform_method
+        if self.transform_method == 'moment':
+            self.moment_transfer = nn.Parameter(
+                data=torch.zeros(2), requires_grad=True)
+            self.moment_mul = moment_mul
+
+        self.use_sigmoid_cls = loss_cls.get('use_sigmoid', False)
+        if self.use_sigmoid_cls:
+            self.cls_out_channels = self.num_classes
+        else:
+            self.cls_out_channels = self.num_classes + 1
+        self.loss_bbox_init = MODELS.build(loss_bbox_init)
+        self.loss_bbox_refine = MODELS.build(loss_bbox_refine)
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        self.relu = nn.ReLU(inplace=True)
+        self.cls_convs = nn.ModuleList()
+        self.reg_convs = nn.ModuleList()
+        for i in range(self.stacked_convs):
+            chn = self.in_channels if i == 0 else self.feat_channels
+            self.cls_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg))
+            self.reg_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg))
+        pts_out_dim = 4 if self.use_grid_points else 2 * self.num_points
+        self.reppoints_cls_conv = DeformConv2d(self.feat_channels,
+                                               self.point_feat_channels,
+                                               self.dcn_kernel, 1,
+                                               self.dcn_pad)
+        self.reppoints_cls_out = nn.Conv2d(self.point_feat_channels,
+                                           self.cls_out_channels, 1, 1, 0)
+        self.reppoints_pts_init_conv = nn.Conv2d(self.feat_channels,
+                                                 self.point_feat_channels, 3,
+                                                 1, 1)
+        self.reppoints_pts_init_out = nn.Conv2d(self.point_feat_channels,
+                                                pts_out_dim, 1, 1, 0)
+        self.reppoints_pts_refine_conv = DeformConv2d(self.feat_channels,
+                                                      self.point_feat_channels,
+                                                      self.dcn_kernel, 1,
+                                                      self.dcn_pad)
+        self.reppoints_pts_refine_out = nn.Conv2d(self.point_feat_channels,
+                                                  pts_out_dim, 1, 1, 0)
+
+    def points2bbox(self, pts: Tensor, y_first: bool = True) -> Tensor:
+        """Converting the points set into bounding box.
+
+        Args:
+            pts (Tensor): the input points sets (fields), each points
+                set (fields) is represented as 2n scalar.
+            y_first (bool): if y_first=True, the point set is
+                represented as [y1, x1, y2, x2 ... yn, xn], otherwise
+                the point set is represented as
+                [x1, y1, x2, y2 ... xn, yn]. Defaults to True.
+
+        Returns:
+            Tensor: each points set is converting to a bbox [x1, y1, x2, y2].
+        """
+        pts_reshape = pts.view(pts.shape[0], -1, 2, *pts.shape[2:])
+        pts_y = pts_reshape[:, :, 0, ...] if y_first else pts_reshape[:, :, 1,
+                                                                      ...]
+        pts_x = pts_reshape[:, :, 1, ...] if y_first else pts_reshape[:, :, 0,
+                                                                      ...]
+        if self.transform_method == 'minmax':
+            bbox_left = pts_x.min(dim=1, keepdim=True)[0]
+            bbox_right = pts_x.max(dim=1, keepdim=True)[0]
+            bbox_up = pts_y.min(dim=1, keepdim=True)[0]
+            bbox_bottom = pts_y.max(dim=1, keepdim=True)[0]
+            bbox = torch.cat([bbox_left, bbox_up, bbox_right, bbox_bottom],
+                             dim=1)
+        elif self.transform_method == 'partial_minmax':
+            pts_y = pts_y[:, :4, ...]
+            pts_x = pts_x[:, :4, ...]
+            bbox_left = pts_x.min(dim=1, keepdim=True)[0]
+            bbox_right = pts_x.max(dim=1, keepdim=True)[0]
+            bbox_up = pts_y.min(dim=1, keepdim=True)[0]
+            bbox_bottom = pts_y.max(dim=1, keepdim=True)[0]
+            bbox = torch.cat([bbox_left, bbox_up, bbox_right, bbox_bottom],
+                             dim=1)
+        elif self.transform_method == 'moment':
+            pts_y_mean = pts_y.mean(dim=1, keepdim=True)
+            pts_x_mean = pts_x.mean(dim=1, keepdim=True)
+            pts_y_std = torch.std(pts_y - pts_y_mean, dim=1, keepdim=True)
+            pts_x_std = torch.std(pts_x - pts_x_mean, dim=1, keepdim=True)
+            moment_transfer = (self.moment_transfer * self.moment_mul) + (
+                self.moment_transfer.detach() * (1 - self.moment_mul))
+            moment_width_transfer = moment_transfer[0]
+            moment_height_transfer = moment_transfer[1]
+            half_width = pts_x_std * torch.exp(moment_width_transfer)
+            half_height = pts_y_std * torch.exp(moment_height_transfer)
+            bbox = torch.cat([
+                pts_x_mean - half_width, pts_y_mean - half_height,
+                pts_x_mean + half_width, pts_y_mean + half_height
+            ],
+                             dim=1)
+        else:
+            raise NotImplementedError
+        return bbox
+
+    def gen_grid_from_reg(self, reg: Tensor,
+                          previous_boxes: Tensor) -> Tuple[Tensor]:
+        """Base on the previous bboxes and regression values, we compute the
+        regressed bboxes and generate the grids on the bboxes.
+
+        Args:
+            reg (Tensor): the regression value to previous bboxes.
+            previous_boxes (Tensor): previous bboxes.
+
+        Returns:
+            Tuple[Tensor]: generate grids on the regressed bboxes.
+        """
+        b, _, h, w = reg.shape
+        bxy = (previous_boxes[:, :2, ...] + previous_boxes[:, 2:, ...]) / 2.
+        bwh = (previous_boxes[:, 2:, ...] -
+               previous_boxes[:, :2, ...]).clamp(min=1e-6)
+        grid_topleft = bxy + bwh * reg[:, :2, ...] - 0.5 * bwh * torch.exp(
+            reg[:, 2:, ...])
+        grid_wh = bwh * torch.exp(reg[:, 2:, ...])
+        grid_left = grid_topleft[:, [0], ...]
+        grid_top = grid_topleft[:, [1], ...]
+        grid_width = grid_wh[:, [0], ...]
+        grid_height = grid_wh[:, [1], ...]
+        intervel = torch.linspace(0., 1., self.dcn_kernel).view(
+            1, self.dcn_kernel, 1, 1).type_as(reg)
+        grid_x = grid_left + grid_width * intervel
+        grid_x = grid_x.unsqueeze(1).repeat(1, self.dcn_kernel, 1, 1, 1)
+        grid_x = grid_x.view(b, -1, h, w)
+        grid_y = grid_top + grid_height * intervel
+        grid_y = grid_y.unsqueeze(2).repeat(1, 1, self.dcn_kernel, 1, 1)
+        grid_y = grid_y.view(b, -1, h, w)
+        grid_yx = torch.stack([grid_y, grid_x], dim=2)
+        grid_yx = grid_yx.view(b, -1, h, w)
+        regressed_bbox = torch.cat([
+            grid_left, grid_top, grid_left + grid_width, grid_top + grid_height
+        ], 1)
+        return grid_yx, regressed_bbox
+
+    def forward(self, feats: Tuple[Tensor]) -> Tuple[Tensor]:
+        return multi_apply(self.forward_single, feats)
+
+    def forward_single(self, x: Tensor) -> Tuple[Tensor]:
+        """Forward feature map of a single FPN level."""
+        dcn_base_offset = self.dcn_base_offset.type_as(x)
+        # If we use center_init, the initial reppoints is from center points.
+        # If we use bounding bbox representation, the initial reppoints is
+        #   from regular grid placed on a pre-defined bbox.
+        if self.use_grid_points or not self.center_init:
+            scale = self.point_base_scale / 2
+            points_init = dcn_base_offset / dcn_base_offset.max() * scale
+            bbox_init = x.new_tensor([-scale, -scale, scale,
+                                      scale]).view(1, 4, 1, 1)
+        else:
+            points_init = 0
+        cls_feat = x
+        pts_feat = x
+        for cls_conv in self.cls_convs:
+            cls_feat = cls_conv(cls_feat)
+        for reg_conv in self.reg_convs:
+            pts_feat = reg_conv(pts_feat)
+        # initialize reppoints
+        pts_out_init = self.reppoints_pts_init_out(
+            self.relu(self.reppoints_pts_init_conv(pts_feat)))
+        if self.use_grid_points:
+            pts_out_init, bbox_out_init = self.gen_grid_from_reg(
+                pts_out_init, bbox_init.detach())
+        else:
+            pts_out_init = pts_out_init + points_init
+        # refine and classify reppoints
+        pts_out_init_grad_mul = (1 - self.gradient_mul) * pts_out_init.detach(
+        ) + self.gradient_mul * pts_out_init
+        dcn_offset = pts_out_init_grad_mul - dcn_base_offset
+        cls_out = self.reppoints_cls_out(
+            self.relu(self.reppoints_cls_conv(cls_feat, dcn_offset)))
+        pts_out_refine = self.reppoints_pts_refine_out(
+            self.relu(self.reppoints_pts_refine_conv(pts_feat, dcn_offset)))
+        if self.use_grid_points:
+            pts_out_refine, bbox_out_refine = self.gen_grid_from_reg(
+                pts_out_refine, bbox_out_init.detach())
+        else:
+            pts_out_refine = pts_out_refine + pts_out_init.detach()
+
+        if self.training:
+            return cls_out, pts_out_init, pts_out_refine
+        else:
+            return cls_out, self.points2bbox(pts_out_refine)
+
+    def get_points(self, featmap_sizes: List[Tuple[int]],
+                   batch_img_metas: List[dict], device: str) -> tuple:
+        """Get points according to feature map sizes.
+
+        Args:
+            featmap_sizes (list[tuple]): Multi-level feature map sizes.
+            batch_img_metas (list[dict]): Image meta info.
+
+        Returns:
+            tuple: points of each image, valid flags of each image
+        """
+        num_imgs = len(batch_img_metas)
+
+        # since feature map sizes of all images are the same, we only compute
+        # points center for one time
+        multi_level_points = self.prior_generator.grid_priors(
+            featmap_sizes, device=device, with_stride=True)
+        points_list = [[point.clone() for point in multi_level_points]
+                       for _ in range(num_imgs)]
+
+        # for each image, we compute valid flags of multi level grids
+        valid_flag_list = []
+        for img_id, img_meta in enumerate(batch_img_metas):
+            multi_level_flags = self.prior_generator.valid_flags(
+                featmap_sizes, img_meta['pad_shape'], device=device)
+            valid_flag_list.append(multi_level_flags)
+
+        return points_list, valid_flag_list
+
+    def centers_to_bboxes(self, point_list: List[Tensor]) -> List[Tensor]:
+        """Get bboxes according to center points.
+
+        Only used in :class:`MaxIoUAssigner`.
+        """
+        bbox_list = []
+        for i_img, point in enumerate(point_list):
+            bbox = []
+            for i_lvl in range(len(self.point_strides)):
+                scale = self.point_base_scale * self.point_strides[i_lvl] * 0.5
+                bbox_shift = torch.Tensor([-scale, -scale, scale,
+                                           scale]).view(1, 4).type_as(point[0])
+                bbox_center = torch.cat(
+                    [point[i_lvl][:, :2], point[i_lvl][:, :2]], dim=1)
+                bbox.append(bbox_center + bbox_shift)
+            bbox_list.append(bbox)
+        return bbox_list
+
+    def offset_to_pts(self, center_list: List[Tensor],
+                      pred_list: List[Tensor]) -> List[Tensor]:
+        """Change from point offset to point coordinate."""
+        pts_list = []
+        for i_lvl in range(len(self.point_strides)):
+            pts_lvl = []
+            for i_img in range(len(center_list)):
+                pts_center = center_list[i_img][i_lvl][:, :2].repeat(
+                    1, self.num_points)
+                pts_shift = pred_list[i_lvl][i_img]
+                yx_pts_shift = pts_shift.permute(1, 2, 0).view(
+                    -1, 2 * self.num_points)
+                y_pts_shift = yx_pts_shift[..., 0::2]
+                x_pts_shift = yx_pts_shift[..., 1::2]
+                xy_pts_shift = torch.stack([x_pts_shift, y_pts_shift], -1)
+                xy_pts_shift = xy_pts_shift.view(*yx_pts_shift.shape[:-1], -1)
+                pts = xy_pts_shift * self.point_strides[i_lvl] + pts_center
+                pts_lvl.append(pts)
+            pts_lvl = torch.stack(pts_lvl, 0)
+            pts_list.append(pts_lvl)
+        return pts_list
+
+    def _get_targets_single(self,
+                            flat_proposals: Tensor,
+                            valid_flags: Tensor,
+                            gt_instances: InstanceData,
+                            gt_instances_ignore: InstanceData,
+                            stage: str = 'init',
+                            unmap_outputs: bool = True) -> tuple:
+        """Compute corresponding GT box and classification targets for
+        proposals.
+
+        Args:
+            flat_proposals (Tensor): Multi level points of a image.
+            valid_flags (Tensor): Multi level valid flags of a image.
+            gt_instances (InstanceData): It usually includes ``bboxes`` and
+                ``labels`` attributes.
+            gt_instances_ignore (InstanceData): It includes ``bboxes``
+                attribute data that is ignored during training and testing.
+            stage (str): 'init' or 'refine'. Generate target for
+                init stage or refine stage. Defaults to 'init'.
+            unmap_outputs (bool): Whether to map outputs back to
+                the original set of anchors. Defaults to True.
+
+        Returns:
+            tuple:
+
+                - labels (Tensor): Labels of each level.
+                - label_weights (Tensor): Label weights of each level.
+                - bbox_targets (Tensor): BBox targets of each level.
+                - bbox_weights (Tensor): BBox weights of each level.
+                - pos_inds (Tensor): positive samples indexes.
+                - neg_inds (Tensor): negative samples indexes.
+                - sampling_result (:obj:`SamplingResult`): Sampling results.
+        """
+        inside_flags = valid_flags
+        if not inside_flags.any():
+            raise ValueError(
+                'There is no valid proposal inside the image boundary. Please '
+                'check the image size.')
+        # assign gt and sample proposals
+        proposals = flat_proposals[inside_flags, :]
+        pred_instances = InstanceData(priors=proposals)
+
+        if stage == 'init':
+            assigner = self.init_assigner
+            pos_weight = self.train_cfg['init']['pos_weight']
+        else:
+            assigner = self.refine_assigner
+            pos_weight = self.train_cfg['refine']['pos_weight']
+
+        assign_result = assigner.assign(pred_instances, gt_instances,
+                                        gt_instances_ignore)
+        sampling_result = self.sampler.sample(assign_result, pred_instances,
+                                              gt_instances)
+
+        num_valid_proposals = proposals.shape[0]
+        bbox_gt = proposals.new_zeros([num_valid_proposals, 4])
+        pos_proposals = torch.zeros_like(proposals)
+        proposals_weights = proposals.new_zeros([num_valid_proposals, 4])
+        labels = proposals.new_full((num_valid_proposals, ),
+                                    self.num_classes,
+                                    dtype=torch.long)
+        label_weights = proposals.new_zeros(
+            num_valid_proposals, dtype=torch.float)
+
+        pos_inds = sampling_result.pos_inds
+        neg_inds = sampling_result.neg_inds
+        if len(pos_inds) > 0:
+            bbox_gt[pos_inds, :] = sampling_result.pos_gt_bboxes
+            pos_proposals[pos_inds, :] = proposals[pos_inds, :]
+            proposals_weights[pos_inds, :] = 1.0
+
+            labels[pos_inds] = sampling_result.pos_gt_labels
+            if pos_weight <= 0:
+                label_weights[pos_inds] = 1.0
+            else:
+                label_weights[pos_inds] = pos_weight
+        if len(neg_inds) > 0:
+            label_weights[neg_inds] = 1.0
+
+        # map up to original set of proposals
+        if unmap_outputs:
+            num_total_proposals = flat_proposals.size(0)
+            labels = unmap(
+                labels,
+                num_total_proposals,
+                inside_flags,
+                fill=self.num_classes)  # fill bg label
+            label_weights = unmap(label_weights, num_total_proposals,
+                                  inside_flags)
+            bbox_gt = unmap(bbox_gt, num_total_proposals, inside_flags)
+            pos_proposals = unmap(pos_proposals, num_total_proposals,
+                                  inside_flags)
+            proposals_weights = unmap(proposals_weights, num_total_proposals,
+                                      inside_flags)
+
+        return (labels, label_weights, bbox_gt, pos_proposals,
+                proposals_weights, pos_inds, neg_inds, sampling_result)
+
+    def get_targets(self,
+                    proposals_list: List[Tensor],
+                    valid_flag_list: List[Tensor],
+                    batch_gt_instances: InstanceList,
+                    batch_img_metas: List[dict],
+                    batch_gt_instances_ignore: OptInstanceList = None,
+                    stage: str = 'init',
+                    unmap_outputs: bool = True,
+                    return_sampling_results: bool = False) -> tuple:
+        """Compute corresponding GT box and classification targets for
+        proposals.
+
+        Args:
+            proposals_list (list[Tensor]): Multi level points/bboxes of each
+                image.
+            valid_flag_list (list[Tensor]): Multi level valid flags of each
+                image.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+            stage (str): 'init' or 'refine'. Generate target for init stage or
+                refine stage.
+            unmap_outputs (bool): Whether to map outputs back to the original
+                set of anchors.
+            return_sampling_results (bool): Whether to return the sampling
+                results. Defaults to False.
+
+        Returns:
+            tuple:
+
+                - labels_list (list[Tensor]): Labels of each level.
+                - label_weights_list (list[Tensor]): Label weights of each
+                  level.
+                - bbox_gt_list (list[Tensor]): Ground truth bbox of each level.
+                - proposals_list (list[Tensor]): Proposals(points/bboxes) of
+                  each level.
+                - proposal_weights_list (list[Tensor]): Proposal weights of
+                  each level.
+                - avg_factor (int): Average factor that is used to average
+                  the loss. When using sampling method, avg_factor is usually
+                  the sum of positive and negative priors. When using
+                  `PseudoSampler`, `avg_factor` is usually equal to the number
+                  of positive priors.
+        """
+        assert stage in ['init', 'refine']
+        num_imgs = len(batch_img_metas)
+        assert len(proposals_list) == len(valid_flag_list) == num_imgs
+
+        # points number of multi levels
+        num_level_proposals = [points.size(0) for points in proposals_list[0]]
+
+        # concat all level points and flags to a single tensor
+        for i in range(num_imgs):
+            assert len(proposals_list[i]) == len(valid_flag_list[i])
+            proposals_list[i] = torch.cat(proposals_list[i])
+            valid_flag_list[i] = torch.cat(valid_flag_list[i])
+
+        if batch_gt_instances_ignore is None:
+            batch_gt_instances_ignore = [None] * num_imgs
+
+        (all_labels, all_label_weights, all_bbox_gt, all_proposals,
+         all_proposal_weights, pos_inds_list, neg_inds_list,
+         sampling_results_list) = multi_apply(
+             self._get_targets_single,
+             proposals_list,
+             valid_flag_list,
+             batch_gt_instances,
+             batch_gt_instances_ignore,
+             stage=stage,
+             unmap_outputs=unmap_outputs)
+
+        # sampled points of all images
+        avg_refactor = sum(
+            [results.avg_factor for results in sampling_results_list])
+        labels_list = images_to_levels(all_labels, num_level_proposals)
+        label_weights_list = images_to_levels(all_label_weights,
+                                              num_level_proposals)
+        bbox_gt_list = images_to_levels(all_bbox_gt, num_level_proposals)
+        proposals_list = images_to_levels(all_proposals, num_level_proposals)
+        proposal_weights_list = images_to_levels(all_proposal_weights,
+                                                 num_level_proposals)
+        res = (labels_list, label_weights_list, bbox_gt_list, proposals_list,
+               proposal_weights_list, avg_refactor)
+        if return_sampling_results:
+            res = res + (sampling_results_list, )
+
+        return res
+
+    def loss_by_feat_single(self, cls_score: Tensor, pts_pred_init: Tensor,
+                            pts_pred_refine: Tensor, labels: Tensor,
+                            label_weights, bbox_gt_init: Tensor,
+                            bbox_weights_init: Tensor, bbox_gt_refine: Tensor,
+                            bbox_weights_refine: Tensor, stride: int,
+                            avg_factor_init: int,
+                            avg_factor_refine: int) -> Tuple[Tensor]:
+        """Calculate the loss of a single scale level based on the features
+        extracted by the detection head.
+
+        Args:
+            cls_score (Tensor): Box scores for each scale level
+                Has shape (N, num_classes, h_i, w_i).
+            pts_pred_init (Tensor): Points of shape
+                (batch_size, h_i * w_i, num_points * 2).
+            pts_pred_refine (Tensor): Points refined of shape
+                (batch_size, h_i * w_i, num_points * 2).
+            labels (Tensor): Ground truth class indices with shape
+                (batch_size, h_i * w_i).
+            label_weights (Tensor): Label weights of shape
+                (batch_size, h_i * w_i).
+            bbox_gt_init (Tensor): BBox regression targets in the init stage
+                of shape (batch_size, h_i * w_i, 4).
+            bbox_weights_init (Tensor): BBox regression loss weights in the
+                init stage of shape (batch_size, h_i * w_i, 4).
+            bbox_gt_refine (Tensor): BBox regression targets in the refine
+                stage of shape (batch_size, h_i * w_i, 4).
+            bbox_weights_refine (Tensor): BBox regression loss weights in the
+                refine stage of shape (batch_size, h_i * w_i, 4).
+            stride (int): Point stride.
+            avg_factor_init (int): Average factor that is used to average
+                the loss in the init stage.
+            avg_factor_refine (int): Average factor that is used to average
+                the loss in the refine stage.
+
+        Returns:
+            Tuple[Tensor]: loss components.
+        """
+        # classification loss
+        labels = labels.reshape(-1)
+        label_weights = label_weights.reshape(-1)
+        cls_score = cls_score.permute(0, 2, 3,
+                                      1).reshape(-1, self.cls_out_channels)
+        cls_score = cls_score.contiguous()
+        loss_cls = self.loss_cls(
+            cls_score, labels, label_weights, avg_factor=avg_factor_refine)
+
+        # points loss
+        bbox_gt_init = bbox_gt_init.reshape(-1, 4)
+        bbox_weights_init = bbox_weights_init.reshape(-1, 4)
+        bbox_pred_init = self.points2bbox(
+            pts_pred_init.reshape(-1, 2 * self.num_points), y_first=False)
+        bbox_gt_refine = bbox_gt_refine.reshape(-1, 4)
+        bbox_weights_refine = bbox_weights_refine.reshape(-1, 4)
+        bbox_pred_refine = self.points2bbox(
+            pts_pred_refine.reshape(-1, 2 * self.num_points), y_first=False)
+        normalize_term = self.point_base_scale * stride
+        loss_pts_init = self.loss_bbox_init(
+            bbox_pred_init / normalize_term,
+            bbox_gt_init / normalize_term,
+            bbox_weights_init,
+            avg_factor=avg_factor_init)
+        loss_pts_refine = self.loss_bbox_refine(
+            bbox_pred_refine / normalize_term,
+            bbox_gt_refine / normalize_term,
+            bbox_weights_refine,
+            avg_factor=avg_factor_refine)
+        return loss_cls, loss_pts_init, loss_pts_refine
+
+    def loss_by_feat(
+        self,
+        cls_scores: List[Tensor],
+        pts_preds_init: List[Tensor],
+        pts_preds_refine: List[Tensor],
+        batch_gt_instances: InstanceList,
+        batch_img_metas: List[dict],
+        batch_gt_instances_ignore: OptInstanceList = None
+    ) -> Dict[str, Tensor]:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level,
+                each is a 4D-tensor, of shape (batch_size, num_classes, h, w).
+            pts_preds_init (list[Tensor]): Points for each scale level, each is
+                a 3D-tensor, of shape (batch_size, h_i * w_i, num_points * 2).
+            pts_preds_refine (list[Tensor]): Points refined for each scale
+                level, each is a 3D-tensor, of shape
+                (batch_size, h_i * w_i, num_points * 2).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], Optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        device = cls_scores[0].device
+
+        # target for initial stage
+        center_list, valid_flag_list = self.get_points(featmap_sizes,
+                                                       batch_img_metas, device)
+        pts_coordinate_preds_init = self.offset_to_pts(center_list,
+                                                       pts_preds_init)
+        if self.train_cfg['init']['assigner']['type'] == 'PointAssigner':
+            # Assign target for center list
+            candidate_list = center_list
+        else:
+            # transform center list to bbox list and
+            #   assign target for bbox list
+            bbox_list = self.centers_to_bboxes(center_list)
+            candidate_list = bbox_list
+        cls_reg_targets_init = self.get_targets(
+            proposals_list=candidate_list,
+            valid_flag_list=valid_flag_list,
+            batch_gt_instances=batch_gt_instances,
+            batch_img_metas=batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore,
+            stage='init',
+            return_sampling_results=False)
+        (*_, bbox_gt_list_init, candidate_list_init, bbox_weights_list_init,
+         avg_factor_init) = cls_reg_targets_init
+
+        # target for refinement stage
+        center_list, valid_flag_list = self.get_points(featmap_sizes,
+                                                       batch_img_metas, device)
+        pts_coordinate_preds_refine = self.offset_to_pts(
+            center_list, pts_preds_refine)
+        bbox_list = []
+        for i_img, center in enumerate(center_list):
+            bbox = []
+            for i_lvl in range(len(pts_preds_refine)):
+                bbox_preds_init = self.points2bbox(
+                    pts_preds_init[i_lvl].detach())
+                bbox_shift = bbox_preds_init * self.point_strides[i_lvl]
+                bbox_center = torch.cat(
+                    [center[i_lvl][:, :2], center[i_lvl][:, :2]], dim=1)
+                bbox.append(bbox_center +
+                            bbox_shift[i_img].permute(1, 2, 0).reshape(-1, 4))
+            bbox_list.append(bbox)
+        cls_reg_targets_refine = self.get_targets(
+            proposals_list=bbox_list,
+            valid_flag_list=valid_flag_list,
+            batch_gt_instances=batch_gt_instances,
+            batch_img_metas=batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore,
+            stage='refine',
+            return_sampling_results=False)
+        (labels_list, label_weights_list, bbox_gt_list_refine,
+         candidate_list_refine, bbox_weights_list_refine,
+         avg_factor_refine) = cls_reg_targets_refine
+
+        # compute loss
+        losses_cls, losses_pts_init, losses_pts_refine = multi_apply(
+            self.loss_by_feat_single,
+            cls_scores,
+            pts_coordinate_preds_init,
+            pts_coordinate_preds_refine,
+            labels_list,
+            label_weights_list,
+            bbox_gt_list_init,
+            bbox_weights_list_init,
+            bbox_gt_list_refine,
+            bbox_weights_list_refine,
+            self.point_strides,
+            avg_factor_init=avg_factor_init,
+            avg_factor_refine=avg_factor_refine)
+        loss_dict_all = {
+            'loss_cls': losses_cls,
+            'loss_pts_init': losses_pts_init,
+            'loss_pts_refine': losses_pts_refine
+        }
+        return loss_dict_all
+
+    # Same as base_dense_head/_get_bboxes_single except self._bbox_decode
+    def _predict_by_feat_single(self,
+                                cls_score_list: List[Tensor],
+                                bbox_pred_list: List[Tensor],
+                                score_factor_list: List[Tensor],
+                                mlvl_priors: List[Tensor],
+                                img_meta: dict,
+                                cfg: ConfigDict,
+                                rescale: bool = False,
+                                with_nms: bool = True) -> InstanceData:
+        """Transform outputs of a single image into bbox predictions.
+
+        Args:
+            cls_score_list (list[Tensor]): Box scores from all scale
+                levels of a single image, each item has shape
+                (num_priors * num_classes, H, W).
+            bbox_pred_list (list[Tensor]): Box energies / deltas from
+                all scale levels of a single image, each item has shape
+                (num_priors * 4, H, W).
+            score_factor_list (list[Tensor]): Score factor from all scale
+                levels of a single image. RepPoints head does not need
+                this value.
+            mlvl_priors (list[Tensor]): Each element in the list is
+                the priors of a single level in feature pyramid, has shape
+                (num_priors, 2).
+            img_meta (dict): Image meta info.
+            cfg (:obj:`ConfigDict`): Test / postprocessing configuration,
+                if None, test_cfg would be used.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            with_nms (bool): If True, do nms before return boxes.
+                Defaults to True.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        cfg = self.test_cfg if cfg is None else cfg
+        assert len(cls_score_list) == len(bbox_pred_list)
+        img_shape = img_meta['img_shape']
+        nms_pre = cfg.get('nms_pre', -1)
+
+        mlvl_bboxes = []
+        mlvl_scores = []
+        mlvl_labels = []
+        for level_idx, (cls_score, bbox_pred, priors) in enumerate(
+                zip(cls_score_list, bbox_pred_list, mlvl_priors)):
+            assert cls_score.size()[-2:] == bbox_pred.size()[-2:]
+            bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, 4)
+
+            cls_score = cls_score.permute(1, 2,
+                                          0).reshape(-1, self.cls_out_channels)
+            if self.use_sigmoid_cls:
+                scores = cls_score.sigmoid()
+            else:
+                scores = cls_score.softmax(-1)[:, :-1]
+
+            # After https://github.com/open-mmlab/mmdetection/pull/6268/,
+            # this operation keeps fewer bboxes under the same `nms_pre`.
+            # There is no difference in performance for most models. If you
+            # find a slight drop in performance, you can set a larger
+            # `nms_pre` than before.
+            results = filter_scores_and_topk(
+                scores, cfg.score_thr, nms_pre,
+                dict(bbox_pred=bbox_pred, priors=priors))
+            scores, labels, _, filtered_results = results
+
+            bbox_pred = filtered_results['bbox_pred']
+            priors = filtered_results['priors']
+
+            bboxes = self._bbox_decode(priors, bbox_pred,
+                                       self.point_strides[level_idx],
+                                       img_shape)
+
+            mlvl_bboxes.append(bboxes)
+            mlvl_scores.append(scores)
+            mlvl_labels.append(labels)
+
+        results = InstanceData()
+        results.bboxes = torch.cat(mlvl_bboxes)
+        results.scores = torch.cat(mlvl_scores)
+        results.labels = torch.cat(mlvl_labels)
+
+        return self._bbox_post_process(
+            results=results,
+            cfg=cfg,
+            rescale=rescale,
+            with_nms=with_nms,
+            img_meta=img_meta)
+
+    def _bbox_decode(self, points: Tensor, bbox_pred: Tensor, stride: int,
+                     max_shape: Tuple[int, int]) -> Tensor:
+        """Decode the prediction to bounding box.
+
+        Args:
+            points (Tensor): shape (h_i * w_i, 2).
+            bbox_pred (Tensor): shape (h_i * w_i, 4).
+            stride (int): Stride for bbox_pred in different level.
+            max_shape (Tuple[int, int]): image shape.
+
+        Returns:
+            Tensor: Bounding boxes decoded.
+        """
+        bbox_pos_center = torch.cat([points[:, :2], points[:, :2]], dim=1)
+        bboxes = bbox_pred * stride + bbox_pos_center
+        x1 = bboxes[:, 0].clamp(min=0, max=max_shape[1])
+        y1 = bboxes[:, 1].clamp(min=0, max=max_shape[0])
+        x2 = bboxes[:, 2].clamp(min=0, max=max_shape[1])
+        y2 = bboxes[:, 3].clamp(min=0, max=max_shape[0])
+        decoded_bboxes = torch.stack([x1, y1, x2, y2], dim=-1)
+        return decoded_bboxes
diff --git a/mmdetection/mmdet/models/dense_heads/retina_head.py b/mmdetection/mmdet/models/dense_heads/retina_head.py
new file mode 100644
index 00000000..be3ae74d
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/retina_head.py
@@ -0,0 +1,120 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+
+from mmdet.registry import MODELS
+from .anchor_head import AnchorHead
+
+
+@MODELS.register_module()
+class RetinaHead(AnchorHead):
+    r"""An anchor-based head used in `RetinaNet
+    `_.
+
+    The head contains two subnetworks. The first classifies anchor boxes and
+    the second regresses deltas for the anchors.
+
+    Example:
+        >>> import torch
+        >>> self = RetinaHead(11, 7)
+        >>> x = torch.rand(1, 7, 32, 32)
+        >>> cls_score, bbox_pred = self.forward_single(x)
+        >>> # Each anchor predicts a score for each class except background
+        >>> cls_per_anchor = cls_score.shape[1] / self.num_anchors
+        >>> box_per_anchor = bbox_pred.shape[1] / self.num_anchors
+        >>> assert cls_per_anchor == (self.num_classes)
+        >>> assert box_per_anchor == 4
+    """
+
+    def __init__(self,
+                 num_classes,
+                 in_channels,
+                 stacked_convs=4,
+                 conv_cfg=None,
+                 norm_cfg=None,
+                 anchor_generator=dict(
+                     type='AnchorGenerator',
+                     octave_base_scale=4,
+                     scales_per_octave=3,
+                     ratios=[0.5, 1.0, 2.0],
+                     strides=[8, 16, 32, 64, 128]),
+                 init_cfg=dict(
+                     type='Normal',
+                     layer='Conv2d',
+                     std=0.01,
+                     override=dict(
+                         type='Normal',
+                         name='retina_cls',
+                         std=0.01,
+                         bias_prob=0.01)),
+                 **kwargs):
+        assert stacked_convs >= 0, \
+            '`stacked_convs` must be non-negative integers, ' \
+            f'but got {stacked_convs} instead.'
+        self.stacked_convs = stacked_convs
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        super(RetinaHead, self).__init__(
+            num_classes,
+            in_channels,
+            anchor_generator=anchor_generator,
+            init_cfg=init_cfg,
+            **kwargs)
+
+    def _init_layers(self):
+        """Initialize layers of the head."""
+        self.relu = nn.ReLU(inplace=True)
+        self.cls_convs = nn.ModuleList()
+        self.reg_convs = nn.ModuleList()
+        in_channels = self.in_channels
+        for i in range(self.stacked_convs):
+            self.cls_convs.append(
+                ConvModule(
+                    in_channels,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg))
+            self.reg_convs.append(
+                ConvModule(
+                    in_channels,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg))
+            in_channels = self.feat_channels
+        self.retina_cls = nn.Conv2d(
+            in_channels,
+            self.num_base_priors * self.cls_out_channels,
+            3,
+            padding=1)
+        reg_dim = self.bbox_coder.encode_size
+        self.retina_reg = nn.Conv2d(
+            in_channels, self.num_base_priors * reg_dim, 3, padding=1)
+
+    def forward_single(self, x):
+        """Forward feature of a single scale level.
+
+        Args:
+            x (Tensor): Features of a single scale level.
+
+        Returns:
+            tuple:
+                cls_score (Tensor): Cls scores for a single scale level
+                    the channels number is num_anchors * num_classes.
+                bbox_pred (Tensor): Box energies / deltas for a single scale
+                    level, the channels number is num_anchors * 4.
+        """
+        cls_feat = x
+        reg_feat = x
+        for cls_conv in self.cls_convs:
+            cls_feat = cls_conv(cls_feat)
+        for reg_conv in self.reg_convs:
+            reg_feat = reg_conv(reg_feat)
+        cls_score = self.retina_cls(cls_feat)
+        bbox_pred = self.retina_reg(reg_feat)
+        return cls_score, bbox_pred
diff --git a/mmdetection/mmdet/models/dense_heads/retina_sepbn_head.py b/mmdetection/mmdet/models/dense_heads/retina_sepbn_head.py
new file mode 100644
index 00000000..681a3998
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/retina_sepbn_head.py
@@ -0,0 +1,127 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Tuple
+
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmengine.model import bias_init_with_prob, normal_init
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import OptConfigType, OptMultiConfig
+from .anchor_head import AnchorHead
+
+
+@MODELS.register_module()
+class RetinaSepBNHead(AnchorHead):
+    """"RetinaHead with separate BN.
+
+    In RetinaHead, conv/norm layers are shared across different FPN levels,
+    while in RetinaSepBNHead, conv layers are shared across different FPN
+    levels, but BN layers are separated.
+    """
+
+    def __init__(self,
+                 num_classes: int,
+                 num_ins: int,
+                 in_channels: int,
+                 stacked_convs: int = 4,
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None,
+                 **kwargs) -> None:
+        assert init_cfg is None, 'To prevent abnormal initialization ' \
+                                 'behavior, init_cfg is not allowed to be set'
+        self.stacked_convs = stacked_convs
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.num_ins = num_ins
+        super().__init__(
+            num_classes=num_classes,
+            in_channels=in_channels,
+            init_cfg=init_cfg,
+            **kwargs)
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        self.relu = nn.ReLU(inplace=True)
+        self.cls_convs = nn.ModuleList()
+        self.reg_convs = nn.ModuleList()
+        for i in range(self.num_ins):
+            cls_convs = nn.ModuleList()
+            reg_convs = nn.ModuleList()
+            for j in range(self.stacked_convs):
+                chn = self.in_channels if j == 0 else self.feat_channels
+                cls_convs.append(
+                    ConvModule(
+                        chn,
+                        self.feat_channels,
+                        3,
+                        stride=1,
+                        padding=1,
+                        conv_cfg=self.conv_cfg,
+                        norm_cfg=self.norm_cfg))
+                reg_convs.append(
+                    ConvModule(
+                        chn,
+                        self.feat_channels,
+                        3,
+                        stride=1,
+                        padding=1,
+                        conv_cfg=self.conv_cfg,
+                        norm_cfg=self.norm_cfg))
+            self.cls_convs.append(cls_convs)
+            self.reg_convs.append(reg_convs)
+        for i in range(self.stacked_convs):
+            for j in range(1, self.num_ins):
+                self.cls_convs[j][i].conv = self.cls_convs[0][i].conv
+                self.reg_convs[j][i].conv = self.reg_convs[0][i].conv
+        self.retina_cls = nn.Conv2d(
+            self.feat_channels,
+            self.num_base_priors * self.cls_out_channels,
+            3,
+            padding=1)
+        self.retina_reg = nn.Conv2d(
+            self.feat_channels, self.num_base_priors * 4, 3, padding=1)
+
+    def init_weights(self) -> None:
+        """Initialize weights of the head."""
+        super().init_weights()
+        for m in self.cls_convs[0]:
+            normal_init(m.conv, std=0.01)
+        for m in self.reg_convs[0]:
+            normal_init(m.conv, std=0.01)
+        bias_cls = bias_init_with_prob(0.01)
+        normal_init(self.retina_cls, std=0.01, bias=bias_cls)
+        normal_init(self.retina_reg, std=0.01)
+
+    def forward(self, feats: Tuple[Tensor]) -> tuple:
+        """Forward features from the upstream network.
+
+        Args:
+            feats (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple: Usually a tuple of classification scores and bbox prediction
+
+                - cls_scores (list[Tensor]): Classification scores for all
+                  scale levels, each is a 4D-tensor, the channels number is
+                  num_anchors * num_classes.
+                - bbox_preds (list[Tensor]): Box energies / deltas for all
+                  scale levels, each is a 4D-tensor, the channels number is
+                  num_anchors * 4.
+        """
+        cls_scores = []
+        bbox_preds = []
+        for i, x in enumerate(feats):
+            cls_feat = feats[i]
+            reg_feat = feats[i]
+            for cls_conv in self.cls_convs[i]:
+                cls_feat = cls_conv(cls_feat)
+            for reg_conv in self.reg_convs[i]:
+                reg_feat = reg_conv(reg_feat)
+            cls_score = self.retina_cls(cls_feat)
+            bbox_pred = self.retina_reg(reg_feat)
+            cls_scores.append(cls_score)
+            bbox_preds.append(bbox_pred)
+        return cls_scores, bbox_preds
diff --git a/mmdetection/mmdet/models/dense_heads/rpn_head.py b/mmdetection/mmdet/models/dense_heads/rpn_head.py
new file mode 100644
index 00000000..6b544009
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/rpn_head.py
@@ -0,0 +1,302 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+from typing import List, Optional, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+from mmcv.ops import batched_nms
+from mmengine.config import ConfigDict
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures.bbox import (cat_boxes, empty_box_as, get_box_tensor,
+                                   get_box_wh, scale_boxes)
+from mmdet.utils import InstanceList, MultiConfig, OptInstanceList
+from .anchor_head import AnchorHead
+
+
+@MODELS.register_module()
+class RPNHead(AnchorHead):
+    """Implementation of RPN head.
+
+    Args:
+        in_channels (int): Number of channels in the input feature map.
+        num_classes (int): Number of categories excluding the background
+            category. Defaults to 1.
+        init_cfg (:obj:`ConfigDict` or list[:obj:`ConfigDict`] or dict or \
+            list[dict]): Initialization config dict.
+        num_convs (int): Number of convolution layers in the head.
+            Defaults to 1.
+    """  # noqa: W605
+
+    def __init__(self,
+                 in_channels: int,
+                 num_classes: int = 1,
+                 init_cfg: MultiConfig = dict(
+                     type='Normal', layer='Conv2d', std=0.01),
+                 num_convs: int = 1,
+                 **kwargs) -> None:
+        self.num_convs = num_convs
+        assert num_classes == 1
+        super().__init__(
+            num_classes=num_classes,
+            in_channels=in_channels,
+            init_cfg=init_cfg,
+            **kwargs)
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        if self.num_convs > 1:
+            rpn_convs = []
+            for i in range(self.num_convs):
+                if i == 0:
+                    in_channels = self.in_channels
+                else:
+                    in_channels = self.feat_channels
+                # use ``inplace=False`` to avoid error: one of the variables
+                # needed for gradient computation has been modified by an
+                # inplace operation.
+                rpn_convs.append(
+                    ConvModule(
+                        in_channels,
+                        self.feat_channels,
+                        3,
+                        padding=1,
+                        inplace=False))
+            self.rpn_conv = nn.Sequential(*rpn_convs)
+        else:
+            self.rpn_conv = nn.Conv2d(
+                self.in_channels, self.feat_channels, 3, padding=1)
+        self.rpn_cls = nn.Conv2d(self.feat_channels,
+                                 self.num_base_priors * self.cls_out_channels,
+                                 1)
+        reg_dim = self.bbox_coder.encode_size
+        self.rpn_reg = nn.Conv2d(self.feat_channels,
+                                 self.num_base_priors * reg_dim, 1)
+
+    def forward_single(self, x: Tensor) -> Tuple[Tensor, Tensor]:
+        """Forward feature of a single scale level.
+
+        Args:
+            x (Tensor): Features of a single scale level.
+
+        Returns:
+            tuple:
+                cls_score (Tensor): Cls scores for a single scale level \
+                    the channels number is num_base_priors * num_classes.
+                bbox_pred (Tensor): Box energies / deltas for a single scale \
+                    level, the channels number is num_base_priors * 4.
+        """
+        x = self.rpn_conv(x)
+        x = F.relu(x)
+        rpn_cls_score = self.rpn_cls(x)
+        rpn_bbox_pred = self.rpn_reg(x)
+        return rpn_cls_score, rpn_bbox_pred
+
+    def loss_by_feat(self,
+                     cls_scores: List[Tensor],
+                     bbox_preds: List[Tensor],
+                     batch_gt_instances: InstanceList,
+                     batch_img_metas: List[dict],
+                     batch_gt_instances_ignore: OptInstanceList = None) \
+            -> dict:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level,
+                has shape (N, num_anchors * num_classes, H, W).
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level with shape (N, num_anchors * 4, H, W).
+            batch_gt_instances (list[obj:InstanceData]): Batch of gt_instance.
+                It usually includes ``bboxes`` and ``labels`` attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[obj:InstanceData], Optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        losses = super().loss_by_feat(
+            cls_scores,
+            bbox_preds,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore)
+        return dict(
+            loss_rpn_cls=losses['loss_cls'], loss_rpn_bbox=losses['loss_bbox'])
+
+    def _predict_by_feat_single(self,
+                                cls_score_list: List[Tensor],
+                                bbox_pred_list: List[Tensor],
+                                score_factor_list: List[Tensor],
+                                mlvl_priors: List[Tensor],
+                                img_meta: dict,
+                                cfg: ConfigDict,
+                                rescale: bool = False,
+                                with_nms: bool = True) -> InstanceData:
+        """Transform a single image's features extracted from the head into
+        bbox results.
+
+        Args:
+            cls_score_list (list[Tensor]): Box scores from all scale
+                levels of a single image, each item has shape
+                (num_priors * num_classes, H, W).
+            bbox_pred_list (list[Tensor]): Box energies / deltas from
+                all scale levels of a single image, each item has shape
+                (num_priors * 4, H, W).
+            score_factor_list (list[Tensor]): Be compatible with
+                BaseDenseHead. Not used in RPNHead.
+            mlvl_priors (list[Tensor]): Each element in the list is
+                the priors of a single level in feature pyramid. In all
+                anchor-based methods, it has shape (num_priors, 4). In
+                all anchor-free methods, it has shape (num_priors, 2)
+                when `with_stride=True`, otherwise it still has shape
+                (num_priors, 4).
+            img_meta (dict): Image meta info.
+            cfg (ConfigDict, optional): Test / postprocessing configuration,
+                if None, test_cfg would be used.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        cfg = self.test_cfg if cfg is None else cfg
+        cfg = copy.deepcopy(cfg)
+        img_shape = img_meta['img_shape']
+        nms_pre = cfg.get('nms_pre', -1)
+
+        mlvl_bbox_preds = []
+        mlvl_valid_priors = []
+        mlvl_scores = []
+        level_ids = []
+        for level_idx, (cls_score, bbox_pred, priors) in \
+                enumerate(zip(cls_score_list, bbox_pred_list,
+                              mlvl_priors)):
+            assert cls_score.size()[-2:] == bbox_pred.size()[-2:]
+
+            reg_dim = self.bbox_coder.encode_size
+            bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, reg_dim)
+            cls_score = cls_score.permute(1, 2,
+                                          0).reshape(-1, self.cls_out_channels)
+            if self.use_sigmoid_cls:
+                scores = cls_score.sigmoid()
+            else:
+                # remind that we set FG labels to [0] since mmdet v2.0
+                # BG cat_id: 1
+                scores = cls_score.softmax(-1)[:, :-1]
+
+            scores = torch.squeeze(scores)
+            if 0 < nms_pre < scores.shape[0]:
+                # sort is faster than topk
+                # _, topk_inds = scores.topk(cfg.nms_pre)
+                ranked_scores, rank_inds = scores.sort(descending=True)
+                topk_inds = rank_inds[:nms_pre]
+                scores = ranked_scores[:nms_pre]
+                bbox_pred = bbox_pred[topk_inds, :]
+                priors = priors[topk_inds]
+
+            mlvl_bbox_preds.append(bbox_pred)
+            mlvl_valid_priors.append(priors)
+            mlvl_scores.append(scores)
+
+            # use level id to implement the separate level nms
+            level_ids.append(
+                scores.new_full((scores.size(0), ),
+                                level_idx,
+                                dtype=torch.long))
+
+        bbox_pred = torch.cat(mlvl_bbox_preds)
+        priors = cat_boxes(mlvl_valid_priors)
+        bboxes = self.bbox_coder.decode(priors, bbox_pred, max_shape=img_shape)
+
+        results = InstanceData()
+        results.bboxes = bboxes
+        results.scores = torch.cat(mlvl_scores)
+        results.level_ids = torch.cat(level_ids)
+
+        return self._bbox_post_process(
+            results=results, cfg=cfg, rescale=rescale, img_meta=img_meta)
+
+    def _bbox_post_process(self,
+                           results: InstanceData,
+                           cfg: ConfigDict,
+                           rescale: bool = False,
+                           with_nms: bool = True,
+                           img_meta: Optional[dict] = None) -> InstanceData:
+        """bbox post-processing method.
+
+        The boxes would be rescaled to the original image scale and do
+        the nms operation.
+
+        Args:
+            results (:obj:`InstaceData`): Detection instance results,
+                each item has shape (num_bboxes, ).
+            cfg (ConfigDict): Test / postprocessing configuration.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            with_nms (bool): If True, do nms before return boxes.
+                Default to True.
+            img_meta (dict, optional): Image meta info. Defaults to None.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        assert with_nms, '`with_nms` must be True in RPNHead'
+        if rescale:
+            assert img_meta.get('scale_factor') is not None
+            scale_factor = [1 / s for s in img_meta['scale_factor']]
+            results.bboxes = scale_boxes(results.bboxes, scale_factor)
+
+        # filter small size bboxes
+        if cfg.get('min_bbox_size', -1) >= 0:
+            w, h = get_box_wh(results.bboxes)
+            valid_mask = (w > cfg.min_bbox_size) & (h > cfg.min_bbox_size)
+            if not valid_mask.all():
+                results = results[valid_mask]
+
+        if results.bboxes.numel() > 0:
+            bboxes = get_box_tensor(results.bboxes)
+            det_bboxes, keep_idxs = batched_nms(bboxes, results.scores,
+                                                results.level_ids, cfg.nms)
+            results = results[keep_idxs]
+            # some nms would reweight the score, such as softnms
+            results.scores = det_bboxes[:, -1]
+            results = results[:cfg.max_per_img]
+            # TODO: This would unreasonably show the 0th class label
+            #  in visualization
+            results.labels = results.scores.new_zeros(
+                len(results), dtype=torch.long)
+            del results.level_ids
+        else:
+            # To avoid some potential error
+            results_ = InstanceData()
+            results_.bboxes = empty_box_as(results.bboxes)
+            results_.scores = results.scores.new_zeros(0)
+            results_.labels = results.scores.new_zeros(0)
+            results = results_
+        return results
diff --git a/mmdetection/mmdet/models/dense_heads/rtmdet_head.py b/mmdetection/mmdet/models/dense_heads/rtmdet_head.py
new file mode 100644
index 00000000..ae0ee6d2
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/rtmdet_head.py
@@ -0,0 +1,692 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule, DepthwiseSeparableConvModule, Scale, is_norm
+from mmengine.model import bias_init_with_prob, constant_init, normal_init
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.structures.bbox import distance2bbox
+from mmdet.utils import ConfigType, InstanceList, OptInstanceList, reduce_mean
+from ..layers.transformer import inverse_sigmoid
+from ..task_modules import anchor_inside_flags
+from ..utils import (images_to_levels, multi_apply, sigmoid_geometric_mean,
+                     unmap)
+from .atss_head import ATSSHead
+
+
+@MODELS.register_module()
+class RTMDetHead(ATSSHead):
+    """Detection Head of RTMDet.
+
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (int): Number of channels in the input feature map.
+        with_objectness (bool): Whether to add an objectness branch.
+            Defaults to True.
+        act_cfg (:obj:`ConfigDict` or dict): Config dict for activation layer.
+            Default: dict(type='ReLU')
+    """
+
+    def __init__(self,
+                 num_classes: int,
+                 in_channels: int,
+                 with_objectness: bool = True,
+                 act_cfg: ConfigType = dict(type='ReLU'),
+                 **kwargs) -> None:
+        self.act_cfg = act_cfg
+        self.with_objectness = with_objectness
+        super().__init__(num_classes, in_channels, **kwargs)
+        if self.train_cfg:
+            self.assigner = TASK_UTILS.build(self.train_cfg['assigner'])
+
+    def _init_layers(self):
+        """Initialize layers of the head."""
+        self.cls_convs = nn.ModuleList()
+        self.reg_convs = nn.ModuleList()
+        for i in range(self.stacked_convs):
+            chn = self.in_channels if i == 0 else self.feat_channels
+            self.cls_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg,
+                    act_cfg=self.act_cfg))
+            self.reg_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg,
+                    act_cfg=self.act_cfg))
+        pred_pad_size = self.pred_kernel_size // 2
+        self.rtm_cls = nn.Conv2d(
+            self.feat_channels,
+            self.num_base_priors * self.cls_out_channels,
+            self.pred_kernel_size,
+            padding=pred_pad_size)
+        self.rtm_reg = nn.Conv2d(
+            self.feat_channels,
+            self.num_base_priors * 4,
+            self.pred_kernel_size,
+            padding=pred_pad_size)
+        if self.with_objectness:
+            self.rtm_obj = nn.Conv2d(
+                self.feat_channels,
+                1,
+                self.pred_kernel_size,
+                padding=pred_pad_size)
+
+        self.scales = nn.ModuleList(
+            [Scale(1.0) for _ in self.prior_generator.strides])
+
+    def init_weights(self) -> None:
+        """Initialize weights of the head."""
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                normal_init(m, mean=0, std=0.01)
+            if is_norm(m):
+                constant_init(m, 1)
+        bias_cls = bias_init_with_prob(0.01)
+        normal_init(self.rtm_cls, std=0.01, bias=bias_cls)
+        normal_init(self.rtm_reg, std=0.01)
+        if self.with_objectness:
+            normal_init(self.rtm_obj, std=0.01, bias=bias_cls)
+
+    def forward(self, feats: Tuple[Tensor, ...]) -> tuple:
+        """Forward features from the upstream network.
+
+        Args:
+            feats (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple: Usually a tuple of classification scores and bbox prediction
+            - cls_scores (list[Tensor]): Classification scores for all scale
+              levels, each is a 4D-tensor, the channels number is
+              num_base_priors * num_classes.
+            - bbox_preds (list[Tensor]): Box energies / deltas for all scale
+              levels, each is a 4D-tensor, the channels number is
+              num_base_priors * 4.
+        """
+
+        cls_scores = []
+        bbox_preds = []
+        for idx, (x, scale, stride) in enumerate(
+                zip(feats, self.scales, self.prior_generator.strides)):
+            cls_feat = x
+            reg_feat = x
+
+            for cls_layer in self.cls_convs:
+                cls_feat = cls_layer(cls_feat)
+            cls_score = self.rtm_cls(cls_feat)
+
+            for reg_layer in self.reg_convs:
+                reg_feat = reg_layer(reg_feat)
+
+            if self.with_objectness:
+                objectness = self.rtm_obj(reg_feat)
+                cls_score = inverse_sigmoid(
+                    sigmoid_geometric_mean(cls_score, objectness))
+
+            reg_dist = scale(self.rtm_reg(reg_feat).exp()).float() * stride[0]
+
+            cls_scores.append(cls_score)
+            bbox_preds.append(reg_dist)
+        return tuple(cls_scores), tuple(bbox_preds)
+
+    def loss_by_feat_single(self, cls_score: Tensor, bbox_pred: Tensor,
+                            labels: Tensor, label_weights: Tensor,
+                            bbox_targets: Tensor, assign_metrics: Tensor,
+                            stride: List[int]):
+        """Compute loss of a single scale level.
+
+        Args:
+            cls_score (Tensor): Box scores for each scale level
+                Has shape (N, num_anchors * num_classes, H, W).
+            bbox_pred (Tensor): Decoded bboxes for each scale
+                level with shape (N, num_anchors * 4, H, W).
+            labels (Tensor): Labels of each anchors with shape
+                (N, num_total_anchors).
+            label_weights (Tensor): Label weights of each anchor with shape
+                (N, num_total_anchors).
+            bbox_targets (Tensor): BBox regression targets of each anchor with
+                shape (N, num_total_anchors, 4).
+            assign_metrics (Tensor): Assign metrics with shape
+                (N, num_total_anchors).
+            stride (List[int]): Downsample stride of the feature map.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        assert stride[0] == stride[1], 'h stride is not equal to w stride!'
+        cls_score = cls_score.permute(0, 2, 3, 1).reshape(
+            -1, self.cls_out_channels).contiguous()
+        bbox_pred = bbox_pred.reshape(-1, 4)
+        bbox_targets = bbox_targets.reshape(-1, 4)
+        labels = labels.reshape(-1)
+        assign_metrics = assign_metrics.reshape(-1)
+        label_weights = label_weights.reshape(-1)
+        targets = (labels, assign_metrics)
+
+        loss_cls = self.loss_cls(
+            cls_score, targets, label_weights, avg_factor=1.0)
+
+        # FG cat_id: [0, num_classes -1], BG cat_id: num_classes
+        bg_class_ind = self.num_classes
+        pos_inds = ((labels >= 0)
+                    & (labels < bg_class_ind)).nonzero().squeeze(1)
+
+        if len(pos_inds) > 0:
+            pos_bbox_targets = bbox_targets[pos_inds]
+            pos_bbox_pred = bbox_pred[pos_inds]
+
+            pos_decode_bbox_pred = pos_bbox_pred
+            pos_decode_bbox_targets = pos_bbox_targets
+
+            # regression loss
+            pos_bbox_weight = assign_metrics[pos_inds]
+
+            loss_bbox = self.loss_bbox(
+                pos_decode_bbox_pred,
+                pos_decode_bbox_targets,
+                weight=pos_bbox_weight,
+                avg_factor=1.0)
+        else:
+            loss_bbox = bbox_pred.sum() * 0
+            pos_bbox_weight = bbox_targets.new_tensor(0.)
+
+        return loss_cls, loss_bbox, assign_metrics.sum(), pos_bbox_weight.sum()
+
+    def loss_by_feat(self,
+                     cls_scores: List[Tensor],
+                     bbox_preds: List[Tensor],
+                     batch_gt_instances: InstanceList,
+                     batch_img_metas: List[dict],
+                     batch_gt_instances_ignore: OptInstanceList = None):
+        """Compute losses of the head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level
+                Has shape (N, num_anchors * num_classes, H, W)
+            bbox_preds (list[Tensor]): Decoded box for each scale
+                level with shape (N, num_anchors * 4, H, W) in
+                [tl_x, tl_y, br_x, br_y] format.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], Optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        num_imgs = len(batch_img_metas)
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        assert len(featmap_sizes) == self.prior_generator.num_levels
+
+        device = cls_scores[0].device
+        anchor_list, valid_flag_list = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+        flatten_cls_scores = torch.cat([
+            cls_score.permute(0, 2, 3, 1).reshape(num_imgs, -1,
+                                                  self.cls_out_channels)
+            for cls_score in cls_scores
+        ], 1)
+        decoded_bboxes = []
+        for anchor, bbox_pred in zip(anchor_list[0], bbox_preds):
+            anchor = anchor.reshape(-1, 4)
+            bbox_pred = bbox_pred.permute(0, 2, 3, 1).reshape(num_imgs, -1, 4)
+            bbox_pred = distance2bbox(anchor, bbox_pred)
+            decoded_bboxes.append(bbox_pred)
+
+        flatten_bboxes = torch.cat(decoded_bboxes, 1)
+
+        cls_reg_targets = self.get_targets(
+            flatten_cls_scores,
+            flatten_bboxes,
+            anchor_list,
+            valid_flag_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore)
+        (anchor_list, labels_list, label_weights_list, bbox_targets_list,
+         assign_metrics_list, sampling_results_list) = cls_reg_targets
+
+        losses_cls, losses_bbox,\
+            cls_avg_factors, bbox_avg_factors = multi_apply(
+                self.loss_by_feat_single,
+                cls_scores,
+                decoded_bboxes,
+                labels_list,
+                label_weights_list,
+                bbox_targets_list,
+                assign_metrics_list,
+                self.prior_generator.strides)
+
+        cls_avg_factor = reduce_mean(sum(cls_avg_factors)).clamp_(min=1).item()
+        losses_cls = list(map(lambda x: x / cls_avg_factor, losses_cls))
+
+        bbox_avg_factor = reduce_mean(
+            sum(bbox_avg_factors)).clamp_(min=1).item()
+        losses_bbox = list(map(lambda x: x / bbox_avg_factor, losses_bbox))
+        return dict(loss_cls=losses_cls, loss_bbox=losses_bbox)
+
+    def get_targets(self,
+                    cls_scores: Tensor,
+                    bbox_preds: Tensor,
+                    anchor_list: List[List[Tensor]],
+                    valid_flag_list: List[List[Tensor]],
+                    batch_gt_instances: InstanceList,
+                    batch_img_metas: List[dict],
+                    batch_gt_instances_ignore: OptInstanceList = None,
+                    unmap_outputs=True):
+        """Compute regression and classification targets for anchors in
+        multiple images.
+
+        Args:
+            cls_scores (Tensor): Classification predictions of images,
+                a 3D-Tensor with shape [num_imgs, num_priors, num_classes].
+            bbox_preds (Tensor): Decoded bboxes predictions of one image,
+                a 3D-Tensor with shape [num_imgs, num_priors, 4] in [tl_x,
+                tl_y, br_x, br_y] format.
+            anchor_list (list[list[Tensor]]): Multi level anchors of each
+                image. The outer list indicates images, and the inner list
+                corresponds to feature levels of the image. Each element of
+                the inner list is a tensor of shape (num_anchors, 4).
+            valid_flag_list (list[list[Tensor]]): Multi level valid flags of
+                each image. The outer list indicates images, and the inner list
+                corresponds to feature levels of the image. Each element of
+                the inner list is a tensor of shape (num_anchors, )
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], Optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+            unmap_outputs (bool): Whether to map outputs back to the original
+                set of anchors. Defaults to True.
+
+        Returns:
+            tuple: a tuple containing learning targets.
+
+            - anchors_list (list[list[Tensor]]): Anchors of each level.
+            - labels_list (list[Tensor]): Labels of each level.
+            - label_weights_list (list[Tensor]): Label weights of each
+              level.
+            - bbox_targets_list (list[Tensor]): BBox targets of each level.
+            - assign_metrics_list (list[Tensor]): alignment metrics of each
+              level.
+        """
+        num_imgs = len(batch_img_metas)
+        assert len(anchor_list) == len(valid_flag_list) == num_imgs
+
+        # anchor number of multi levels
+        num_level_anchors = [anchors.size(0) for anchors in anchor_list[0]]
+
+        # concat all level anchors and flags to a single tensor
+        for i in range(num_imgs):
+            assert len(anchor_list[i]) == len(valid_flag_list[i])
+            anchor_list[i] = torch.cat(anchor_list[i])
+            valid_flag_list[i] = torch.cat(valid_flag_list[i])
+
+        # compute targets for each image
+        if batch_gt_instances_ignore is None:
+            batch_gt_instances_ignore = [None] * num_imgs
+        # anchor_list: list(b * [-1, 4])
+        (all_anchors, all_labels, all_label_weights, all_bbox_targets,
+         all_assign_metrics, sampling_results_list) = multi_apply(
+             self._get_targets_single,
+             cls_scores.detach(),
+             bbox_preds.detach(),
+             anchor_list,
+             valid_flag_list,
+             batch_gt_instances,
+             batch_img_metas,
+             batch_gt_instances_ignore,
+             unmap_outputs=unmap_outputs)
+        # no valid anchors
+        if any([labels is None for labels in all_labels]):
+            return None
+
+        # split targets to a list w.r.t. multiple levels
+        anchors_list = images_to_levels(all_anchors, num_level_anchors)
+        labels_list = images_to_levels(all_labels, num_level_anchors)
+        label_weights_list = images_to_levels(all_label_weights,
+                                              num_level_anchors)
+        bbox_targets_list = images_to_levels(all_bbox_targets,
+                                             num_level_anchors)
+        assign_metrics_list = images_to_levels(all_assign_metrics,
+                                               num_level_anchors)
+
+        return (anchors_list, labels_list, label_weights_list,
+                bbox_targets_list, assign_metrics_list, sampling_results_list)
+
+    def _get_targets_single(self,
+                            cls_scores: Tensor,
+                            bbox_preds: Tensor,
+                            flat_anchors: Tensor,
+                            valid_flags: Tensor,
+                            gt_instances: InstanceData,
+                            img_meta: dict,
+                            gt_instances_ignore: Optional[InstanceData] = None,
+                            unmap_outputs=True):
+        """Compute regression, classification targets for anchors in a single
+        image.
+
+        Args:
+            cls_scores (list(Tensor)): Box scores for each image.
+            bbox_preds (list(Tensor)): Box energies / deltas for each image.
+            flat_anchors (Tensor): Multi-level anchors of the image, which are
+                concatenated into a single tensor of shape (num_anchors ,4)
+            valid_flags (Tensor): Multi level valid flags of the image,
+                which are concatenated into a single tensor of
+                    shape (num_anchors,).
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            img_meta (dict): Meta information for current image.
+            gt_instances_ignore (:obj:`InstanceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+            unmap_outputs (bool): Whether to map outputs back to the original
+                set of anchors. Defaults to True.
+
+        Returns:
+            tuple: N is the number of total anchors in the image.
+
+            - anchors (Tensor): All anchors in the image with shape (N, 4).
+            - labels (Tensor): Labels of all anchors in the image with shape
+              (N,).
+            - label_weights (Tensor): Label weights of all anchor in the
+              image with shape (N,).
+            - bbox_targets (Tensor): BBox targets of all anchors in the
+              image with shape (N, 4).
+            - norm_alignment_metrics (Tensor): Normalized alignment metrics
+              of all priors in the image with shape (N,).
+        """
+        inside_flags = anchor_inside_flags(flat_anchors, valid_flags,
+                                           img_meta['img_shape'][:2],
+                                           self.train_cfg['allowed_border'])
+        if not inside_flags.any():
+            return (None, ) * 7
+        # assign gt and sample anchors
+        anchors = flat_anchors[inside_flags, :]
+
+        pred_instances = InstanceData(
+            scores=cls_scores[inside_flags, :],
+            bboxes=bbox_preds[inside_flags, :],
+            priors=anchors)
+
+        assign_result = self.assigner.assign(pred_instances, gt_instances,
+                                             gt_instances_ignore)
+
+        sampling_result = self.sampler.sample(assign_result, pred_instances,
+                                              gt_instances)
+
+        num_valid_anchors = anchors.shape[0]
+        bbox_targets = torch.zeros_like(anchors)
+        labels = anchors.new_full((num_valid_anchors, ),
+                                  self.num_classes,
+                                  dtype=torch.long)
+        label_weights = anchors.new_zeros(num_valid_anchors, dtype=torch.float)
+        assign_metrics = anchors.new_zeros(
+            num_valid_anchors, dtype=torch.float)
+
+        pos_inds = sampling_result.pos_inds
+        neg_inds = sampling_result.neg_inds
+        if len(pos_inds) > 0:
+            # point-based
+            pos_bbox_targets = sampling_result.pos_gt_bboxes
+            bbox_targets[pos_inds, :] = pos_bbox_targets
+
+            labels[pos_inds] = sampling_result.pos_gt_labels
+            if self.train_cfg['pos_weight'] <= 0:
+                label_weights[pos_inds] = 1.0
+            else:
+                label_weights[pos_inds] = self.train_cfg['pos_weight']
+        if len(neg_inds) > 0:
+            label_weights[neg_inds] = 1.0
+
+        class_assigned_gt_inds = torch.unique(
+            sampling_result.pos_assigned_gt_inds)
+        for gt_inds in class_assigned_gt_inds:
+            gt_class_inds = pos_inds[sampling_result.pos_assigned_gt_inds ==
+                                     gt_inds]
+            assign_metrics[gt_class_inds] = assign_result.max_overlaps[
+                gt_class_inds]
+
+        # map up to original set of anchors
+        if unmap_outputs:
+            num_total_anchors = flat_anchors.size(0)
+            anchors = unmap(anchors, num_total_anchors, inside_flags)
+            labels = unmap(
+                labels, num_total_anchors, inside_flags, fill=self.num_classes)
+            label_weights = unmap(label_weights, num_total_anchors,
+                                  inside_flags)
+            bbox_targets = unmap(bbox_targets, num_total_anchors, inside_flags)
+            assign_metrics = unmap(assign_metrics, num_total_anchors,
+                                   inside_flags)
+        return (anchors, labels, label_weights, bbox_targets, assign_metrics,
+                sampling_result)
+
+    def get_anchors(self,
+                    featmap_sizes: List[tuple],
+                    batch_img_metas: List[dict],
+                    device: Union[torch.device, str] = 'cuda') \
+            -> Tuple[List[List[Tensor]], List[List[Tensor]]]:
+        """Get anchors according to feature map sizes.
+
+        Args:
+            featmap_sizes (list[tuple]): Multi-level feature map sizes.
+            batch_img_metas (list[dict]): Image meta info.
+            device (torch.device or str): Device for returned tensors.
+                Defaults to cuda.
+
+        Returns:
+            tuple:
+
+            - anchor_list (list[list[Tensor]]): Anchors of each image.
+            - valid_flag_list (list[list[Tensor]]): Valid flags of each
+              image.
+        """
+        num_imgs = len(batch_img_metas)
+
+        # since feature map sizes of all images are the same, we only compute
+        # anchors for one time
+        multi_level_anchors = self.prior_generator.grid_priors(
+            featmap_sizes, device=device, with_stride=True)
+        anchor_list = [multi_level_anchors for _ in range(num_imgs)]
+
+        # for each image, we compute valid flags of multi level anchors
+        valid_flag_list = []
+        for img_id, img_meta in enumerate(batch_img_metas):
+            multi_level_flags = self.prior_generator.valid_flags(
+                featmap_sizes, img_meta['pad_shape'], device)
+            valid_flag_list.append(multi_level_flags)
+        return anchor_list, valid_flag_list
+
+
+@MODELS.register_module()
+class RTMDetSepBNHead(RTMDetHead):
+    """RTMDetHead with separated BN layers and shared conv layers.
+
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (int): Number of channels in the input feature map.
+        share_conv (bool): Whether to share conv layers between stages.
+            Defaults to True.
+        use_depthwise (bool): Whether to use depthwise separable convolution in
+            head. Defaults to False.
+        norm_cfg (:obj:`ConfigDict` or dict)): Config dict for normalization
+            layer. Defaults to dict(type='BN', momentum=0.03, eps=0.001).
+        act_cfg (:obj:`ConfigDict` or dict)): Config dict for activation layer.
+            Defaults to dict(type='SiLU').
+        pred_kernel_size (int): Kernel size of prediction layer. Defaults to 1.
+    """
+
+    def __init__(self,
+                 num_classes: int,
+                 in_channels: int,
+                 share_conv: bool = True,
+                 use_depthwise: bool = False,
+                 norm_cfg: ConfigType = dict(
+                     type='BN', momentum=0.03, eps=0.001),
+                 act_cfg: ConfigType = dict(type='SiLU'),
+                 pred_kernel_size: int = 1,
+                 exp_on_reg=False,
+                 **kwargs) -> None:
+        self.share_conv = share_conv
+        self.exp_on_reg = exp_on_reg
+        self.use_depthwise = use_depthwise
+        super().__init__(
+            num_classes,
+            in_channels,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg,
+            pred_kernel_size=pred_kernel_size,
+            **kwargs)
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        conv = DepthwiseSeparableConvModule \
+            if self.use_depthwise else ConvModule
+        self.cls_convs = nn.ModuleList()
+        self.reg_convs = nn.ModuleList()
+
+        self.rtm_cls = nn.ModuleList()
+        self.rtm_reg = nn.ModuleList()
+        if self.with_objectness:
+            self.rtm_obj = nn.ModuleList()
+        for n in range(len(self.prior_generator.strides)):
+            cls_convs = nn.ModuleList()
+            reg_convs = nn.ModuleList()
+            for i in range(self.stacked_convs):
+                chn = self.in_channels if i == 0 else self.feat_channels
+                cls_convs.append(
+                    conv(
+                        chn,
+                        self.feat_channels,
+                        3,
+                        stride=1,
+                        padding=1,
+                        conv_cfg=self.conv_cfg,
+                        norm_cfg=self.norm_cfg,
+                        act_cfg=self.act_cfg))
+                reg_convs.append(
+                    conv(
+                        chn,
+                        self.feat_channels,
+                        3,
+                        stride=1,
+                        padding=1,
+                        conv_cfg=self.conv_cfg,
+                        norm_cfg=self.norm_cfg,
+                        act_cfg=self.act_cfg))
+            self.cls_convs.append(cls_convs)
+            self.reg_convs.append(reg_convs)
+
+            self.rtm_cls.append(
+                nn.Conv2d(
+                    self.feat_channels,
+                    self.num_base_priors * self.cls_out_channels,
+                    self.pred_kernel_size,
+                    padding=self.pred_kernel_size // 2))
+            self.rtm_reg.append(
+                nn.Conv2d(
+                    self.feat_channels,
+                    self.num_base_priors * 4,
+                    self.pred_kernel_size,
+                    padding=self.pred_kernel_size // 2))
+            if self.with_objectness:
+                self.rtm_obj.append(
+                    nn.Conv2d(
+                        self.feat_channels,
+                        1,
+                        self.pred_kernel_size,
+                        padding=self.pred_kernel_size // 2))
+
+        if self.share_conv:
+            for n in range(len(self.prior_generator.strides)):
+                for i in range(self.stacked_convs):
+                    self.cls_convs[n][i].conv = self.cls_convs[0][i].conv
+                    self.reg_convs[n][i].conv = self.reg_convs[0][i].conv
+
+    def init_weights(self) -> None:
+        """Initialize weights of the head."""
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                normal_init(m, mean=0, std=0.01)
+            if is_norm(m):
+                constant_init(m, 1)
+        bias_cls = bias_init_with_prob(0.01)
+        for rtm_cls, rtm_reg in zip(self.rtm_cls, self.rtm_reg):
+            normal_init(rtm_cls, std=0.01, bias=bias_cls)
+            normal_init(rtm_reg, std=0.01)
+        if self.with_objectness:
+            for rtm_obj in self.rtm_obj:
+                normal_init(rtm_obj, std=0.01, bias=bias_cls)
+
+    def forward(self, feats: Tuple[Tensor, ...]) -> tuple:
+        """Forward features from the upstream network.
+
+        Args:
+            feats (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple: Usually a tuple of classification scores and bbox prediction
+
+            - cls_scores (tuple[Tensor]): Classification scores for all scale
+              levels, each is a 4D-tensor, the channels number is
+              num_anchors * num_classes.
+            - bbox_preds (tuple[Tensor]): Box energies / deltas for all scale
+              levels, each is a 4D-tensor, the channels number is
+              num_anchors * 4.
+        """
+
+        cls_scores = []
+        bbox_preds = []
+        for idx, (x, stride) in enumerate(
+                zip(feats, self.prior_generator.strides)):
+            cls_feat = x
+            reg_feat = x
+
+            for cls_layer in self.cls_convs[idx]:
+                cls_feat = cls_layer(cls_feat)
+            cls_score = self.rtm_cls[idx](cls_feat)
+
+            for reg_layer in self.reg_convs[idx]:
+                reg_feat = reg_layer(reg_feat)
+
+            if self.with_objectness:
+                objectness = self.rtm_obj[idx](reg_feat)
+                cls_score = inverse_sigmoid(
+                    sigmoid_geometric_mean(cls_score, objectness))
+            if self.exp_on_reg:
+                reg_dist = self.rtm_reg[idx](reg_feat).exp() * stride[0]
+            else:
+                reg_dist = self.rtm_reg[idx](reg_feat) * stride[0]
+            cls_scores.append(cls_score)
+            bbox_preds.append(reg_dist)
+        return tuple(cls_scores), tuple(bbox_preds)
diff --git a/mmdetection/mmdet/models/dense_heads/rtmdet_ins_head.py b/mmdetection/mmdet/models/dense_heads/rtmdet_ins_head.py
new file mode 100644
index 00000000..261a57fe
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/rtmdet_ins_head.py
@@ -0,0 +1,1034 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import math
+from typing import List, Optional, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule, is_norm
+from mmcv.ops import batched_nms
+from mmengine.model import (BaseModule, bias_init_with_prob, constant_init,
+                            normal_init)
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.models.layers.transformer import inverse_sigmoid
+from mmdet.models.utils import (filter_scores_and_topk, multi_apply,
+                                select_single_mlvl, sigmoid_geometric_mean)
+from mmdet.registry import MODELS
+from mmdet.structures.bbox import (cat_boxes, distance2bbox, get_box_tensor,
+                                   get_box_wh, scale_boxes)
+from mmdet.utils import ConfigType, InstanceList, OptInstanceList, reduce_mean
+from .rtmdet_head import RTMDetHead
+
+
+@MODELS.register_module()
+class RTMDetInsHead(RTMDetHead):
+    """Detection Head of RTMDet-Ins.
+
+    Args:
+        num_prototypes (int): Number of mask prototype features extracted
+            from the mask head. Defaults to 8.
+        dyconv_channels (int): Channel of the dynamic conv layers.
+            Defaults to 8.
+        num_dyconvs (int): Number of the dynamic convolution layers.
+            Defaults to 3.
+        mask_loss_stride (int): Down sample stride of the masks for loss
+            computation. Defaults to 4.
+        loss_mask (:obj:`ConfigDict` or dict): Config dict for mask loss.
+    """
+
+    def __init__(self,
+                 *args,
+                 num_prototypes: int = 8,
+                 dyconv_channels: int = 8,
+                 num_dyconvs: int = 3,
+                 mask_loss_stride: int = 4,
+                 loss_mask=dict(
+                     type='DiceLoss',
+                     loss_weight=2.0,
+                     eps=5e-6,
+                     reduction='mean'),
+                 **kwargs) -> None:
+        self.num_prototypes = num_prototypes
+        self.num_dyconvs = num_dyconvs
+        self.dyconv_channels = dyconv_channels
+        self.mask_loss_stride = mask_loss_stride
+        super().__init__(*args, **kwargs)
+        self.loss_mask = MODELS.build(loss_mask)
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        super()._init_layers()
+        # a branch to predict kernels of dynamic convs
+        self.kernel_convs = nn.ModuleList()
+        # calculate num dynamic parameters
+        weight_nums, bias_nums = [], []
+        for i in range(self.num_dyconvs):
+            if i == 0:
+                weight_nums.append(
+                    # mask prototype and coordinate features
+                    (self.num_prototypes + 2) * self.dyconv_channels)
+                bias_nums.append(self.dyconv_channels * 1)
+            elif i == self.num_dyconvs - 1:
+                weight_nums.append(self.dyconv_channels * 1)
+                bias_nums.append(1)
+            else:
+                weight_nums.append(self.dyconv_channels * self.dyconv_channels)
+                bias_nums.append(self.dyconv_channels * 1)
+        self.weight_nums = weight_nums
+        self.bias_nums = bias_nums
+        self.num_gen_params = sum(weight_nums) + sum(bias_nums)
+
+        for i in range(self.stacked_convs):
+            chn = self.in_channels if i == 0 else self.feat_channels
+            self.kernel_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg,
+                    act_cfg=self.act_cfg))
+        pred_pad_size = self.pred_kernel_size // 2
+        self.rtm_kernel = nn.Conv2d(
+            self.feat_channels,
+            self.num_gen_params,
+            self.pred_kernel_size,
+            padding=pred_pad_size)
+        self.mask_head = MaskFeatModule(
+            in_channels=self.in_channels,
+            feat_channels=self.feat_channels,
+            stacked_convs=4,
+            num_levels=len(self.prior_generator.strides),
+            num_prototypes=self.num_prototypes,
+            act_cfg=self.act_cfg,
+            norm_cfg=self.norm_cfg)
+
+    def forward(self, feats: Tuple[Tensor, ...]) -> tuple:
+        """Forward features from the upstream network.
+
+        Args:
+            feats (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple: Usually a tuple of classification scores and bbox prediction
+            - cls_scores (list[Tensor]): Classification scores for all scale
+              levels, each is a 4D-tensor, the channels number is
+              num_base_priors * num_classes.
+            - bbox_preds (list[Tensor]): Box energies / deltas for all scale
+              levels, each is a 4D-tensor, the channels number is
+              num_base_priors * 4.
+            - kernel_preds (list[Tensor]): Dynamic conv kernels for all scale
+              levels, each is a 4D-tensor, the channels number is
+              num_gen_params.
+            - mask_feat (Tensor): Output feature of the mask head. Each is a
+              4D-tensor, the channels number is num_prototypes.
+        """
+        mask_feat = self.mask_head(feats)
+
+        cls_scores = []
+        bbox_preds = []
+        kernel_preds = []
+        for idx, (x, scale, stride) in enumerate(
+                zip(feats, self.scales, self.prior_generator.strides)):
+            cls_feat = x
+            reg_feat = x
+            kernel_feat = x
+
+            for cls_layer in self.cls_convs:
+                cls_feat = cls_layer(cls_feat)
+            cls_score = self.rtm_cls(cls_feat)
+
+            for kernel_layer in self.kernel_convs:
+                kernel_feat = kernel_layer(kernel_feat)
+            kernel_pred = self.rtm_kernel(kernel_feat)
+
+            for reg_layer in self.reg_convs:
+                reg_feat = reg_layer(reg_feat)
+
+            if self.with_objectness:
+                objectness = self.rtm_obj(reg_feat)
+                cls_score = inverse_sigmoid(
+                    sigmoid_geometric_mean(cls_score, objectness))
+
+            reg_dist = scale(self.rtm_reg(reg_feat)) * stride[0]
+
+            cls_scores.append(cls_score)
+            bbox_preds.append(reg_dist)
+            kernel_preds.append(kernel_pred)
+        return tuple(cls_scores), tuple(bbox_preds), tuple(
+            kernel_preds), mask_feat
+
+    def predict_by_feat(self,
+                        cls_scores: List[Tensor],
+                        bbox_preds: List[Tensor],
+                        kernel_preds: List[Tensor],
+                        mask_feat: Tensor,
+                        score_factors: Optional[List[Tensor]] = None,
+                        batch_img_metas: Optional[List[dict]] = None,
+                        cfg: Optional[ConfigType] = None,
+                        rescale: bool = False,
+                        with_nms: bool = True) -> InstanceList:
+        """Transform a batch of output features extracted from the head into
+        bbox results.
+
+        Note: When score_factors is not None, the cls_scores are
+        usually multiplied by it then obtain the real score used in NMS,
+        such as CenterNess in FCOS, IoU branch in ATSS.
+
+        Args:
+            cls_scores (list[Tensor]): Classification scores for all
+                scale levels, each is a 4D-tensor, has shape
+                (batch_size, num_priors * num_classes, H, W).
+            bbox_preds (list[Tensor]): Box energies / deltas for all
+                scale levels, each is a 4D-tensor, has shape
+                (batch_size, num_priors * 4, H, W).
+            kernel_preds (list[Tensor]): Kernel predictions of dynamic
+                convs for all scale levels, each is a 4D-tensor, has shape
+                (batch_size, num_params, H, W).
+            mask_feat (Tensor): Mask prototype features extracted from the
+                mask head, has shape (batch_size, num_prototypes, H, W).
+            score_factors (list[Tensor], optional): Score factor for
+                all scale level, each is a 4D-tensor, has shape
+                (batch_size, num_priors * 1, H, W). Defaults to None.
+            batch_img_metas (list[dict], Optional): Batch image meta info.
+                Defaults to None.
+            cfg (ConfigDict, optional): Test / postprocessing
+                configuration, if None, test_cfg would be used.
+                Defaults to None.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            with_nms (bool): If True, do nms before return boxes.
+                Defaults to True.
+
+        Returns:
+            list[:obj:`InstanceData`]: Object detection results of each image
+            after the post process. Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+                - masks (Tensor): Has a shape (num_instances, h, w).
+        """
+        assert len(cls_scores) == len(bbox_preds)
+
+        if score_factors is None:
+            # e.g. Retina, FreeAnchor, Foveabox, etc.
+            with_score_factors = False
+        else:
+            # e.g. FCOS, PAA, ATSS, AutoAssign, etc.
+            with_score_factors = True
+            assert len(cls_scores) == len(score_factors)
+
+        num_levels = len(cls_scores)
+
+        featmap_sizes = [cls_scores[i].shape[-2:] for i in range(num_levels)]
+        mlvl_priors = self.prior_generator.grid_priors(
+            featmap_sizes,
+            dtype=cls_scores[0].dtype,
+            device=cls_scores[0].device,
+            with_stride=True)
+
+        result_list = []
+
+        for img_id in range(len(batch_img_metas)):
+            img_meta = batch_img_metas[img_id]
+            cls_score_list = select_single_mlvl(
+                cls_scores, img_id, detach=True)
+            bbox_pred_list = select_single_mlvl(
+                bbox_preds, img_id, detach=True)
+            kernel_pred_list = select_single_mlvl(
+                kernel_preds, img_id, detach=True)
+            if with_score_factors:
+                score_factor_list = select_single_mlvl(
+                    score_factors, img_id, detach=True)
+            else:
+                score_factor_list = [None for _ in range(num_levels)]
+
+            results = self._predict_by_feat_single(
+                cls_score_list=cls_score_list,
+                bbox_pred_list=bbox_pred_list,
+                kernel_pred_list=kernel_pred_list,
+                mask_feat=mask_feat[img_id],
+                score_factor_list=score_factor_list,
+                mlvl_priors=mlvl_priors,
+                img_meta=img_meta,
+                cfg=cfg,
+                rescale=rescale,
+                with_nms=with_nms)
+            result_list.append(results)
+        return result_list
+
+    def _predict_by_feat_single(self,
+                                cls_score_list: List[Tensor],
+                                bbox_pred_list: List[Tensor],
+                                kernel_pred_list: List[Tensor],
+                                mask_feat: Tensor,
+                                score_factor_list: List[Tensor],
+                                mlvl_priors: List[Tensor],
+                                img_meta: dict,
+                                cfg: ConfigType,
+                                rescale: bool = False,
+                                with_nms: bool = True) -> InstanceData:
+        """Transform a single image's features extracted from the head into
+        bbox and mask results.
+
+        Args:
+            cls_score_list (list[Tensor]): Box scores from all scale
+                levels of a single image, each item has shape
+                (num_priors * num_classes, H, W).
+            bbox_pred_list (list[Tensor]): Box energies / deltas from
+                all scale levels of a single image, each item has shape
+                (num_priors * 4, H, W).
+            kernel_preds (list[Tensor]): Kernel predictions of dynamic
+                convs for all scale levels of a single image, each is a
+                4D-tensor, has shape (num_params, H, W).
+            mask_feat (Tensor): Mask prototype features of a single image
+                extracted from the mask head, has shape (num_prototypes, H, W).
+            score_factor_list (list[Tensor]): Score factor from all scale
+                levels of a single image, each item has shape
+                (num_priors * 1, H, W).
+            mlvl_priors (list[Tensor]): Each element in the list is
+                the priors of a single level in feature pyramid. In all
+                anchor-based methods, it has shape (num_priors, 4). In
+                all anchor-free methods, it has shape (num_priors, 2)
+                when `with_stride=True`, otherwise it still has shape
+                (num_priors, 4).
+            img_meta (dict): Image meta info.
+            cfg (mmengine.Config): Test / postprocessing configuration,
+                if None, test_cfg would be used.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            with_nms (bool): If True, do nms before return boxes.
+                Defaults to True.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+                - masks (Tensor): Has a shape (num_instances, h, w).
+        """
+        if score_factor_list[0] is None:
+            # e.g. Retina, FreeAnchor, etc.
+            with_score_factors = False
+        else:
+            # e.g. FCOS, PAA, ATSS, etc.
+            with_score_factors = True
+
+        cfg = self.test_cfg if cfg is None else cfg
+        cfg = copy.deepcopy(cfg)
+        img_shape = img_meta['img_shape']
+        nms_pre = cfg.get('nms_pre', -1)
+
+        mlvl_bbox_preds = []
+        mlvl_kernels = []
+        mlvl_valid_priors = []
+        mlvl_scores = []
+        mlvl_labels = []
+        if with_score_factors:
+            mlvl_score_factors = []
+        else:
+            mlvl_score_factors = None
+
+        for level_idx, (cls_score, bbox_pred, kernel_pred,
+                        score_factor, priors) in \
+                enumerate(zip(cls_score_list, bbox_pred_list, kernel_pred_list,
+                              score_factor_list, mlvl_priors)):
+
+            assert cls_score.size()[-2:] == bbox_pred.size()[-2:]
+
+            dim = self.bbox_coder.encode_size
+            bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, dim)
+            if with_score_factors:
+                score_factor = score_factor.permute(1, 2,
+                                                    0).reshape(-1).sigmoid()
+            cls_score = cls_score.permute(1, 2,
+                                          0).reshape(-1, self.cls_out_channels)
+            kernel_pred = kernel_pred.permute(1, 2, 0).reshape(
+                -1, self.num_gen_params)
+            if self.use_sigmoid_cls:
+                scores = cls_score.sigmoid()
+            else:
+                # remind that we set FG labels to [0, num_class-1]
+                # since mmdet v2.0
+                # BG cat_id: num_class
+                scores = cls_score.softmax(-1)[:, :-1]
+
+            # After https://github.com/open-mmlab/mmdetection/pull/6268/,
+            # this operation keeps fewer bboxes under the same `nms_pre`.
+            # There is no difference in performance for most models. If you
+            # find a slight drop in performance, you can set a larger
+            # `nms_pre` than before.
+            score_thr = cfg.get('score_thr', 0)
+
+            results = filter_scores_and_topk(
+                scores, score_thr, nms_pre,
+                dict(
+                    bbox_pred=bbox_pred,
+                    priors=priors,
+                    kernel_pred=kernel_pred))
+            scores, labels, keep_idxs, filtered_results = results
+
+            bbox_pred = filtered_results['bbox_pred']
+            priors = filtered_results['priors']
+            kernel_pred = filtered_results['kernel_pred']
+
+            if with_score_factors:
+                score_factor = score_factor[keep_idxs]
+
+            mlvl_bbox_preds.append(bbox_pred)
+            mlvl_valid_priors.append(priors)
+            mlvl_scores.append(scores)
+            mlvl_labels.append(labels)
+            mlvl_kernels.append(kernel_pred)
+
+            if with_score_factors:
+                mlvl_score_factors.append(score_factor)
+
+        bbox_pred = torch.cat(mlvl_bbox_preds)
+        priors = cat_boxes(mlvl_valid_priors)
+        bboxes = self.bbox_coder.decode(
+            priors[..., :2], bbox_pred, max_shape=img_shape)
+
+        results = InstanceData()
+        results.bboxes = bboxes
+        results.priors = priors
+        results.scores = torch.cat(mlvl_scores)
+        results.labels = torch.cat(mlvl_labels)
+        results.kernels = torch.cat(mlvl_kernels)
+        if with_score_factors:
+            results.score_factors = torch.cat(mlvl_score_factors)
+
+        return self._bbox_mask_post_process(
+            results=results,
+            mask_feat=mask_feat,
+            cfg=cfg,
+            rescale=rescale,
+            with_nms=with_nms,
+            img_meta=img_meta)
+
+    def _bbox_mask_post_process(
+            self,
+            results: InstanceData,
+            mask_feat,
+            cfg: ConfigType,
+            rescale: bool = False,
+            with_nms: bool = True,
+            img_meta: Optional[dict] = None) -> InstanceData:
+        """bbox and mask post-processing method.
+
+        The boxes would be rescaled to the original image scale and do
+        the nms operation. Usually `with_nms` is False is used for aug test.
+
+        Args:
+            results (:obj:`InstaceData`): Detection instance results,
+                each item has shape (num_bboxes, ).
+            cfg (ConfigDict): Test / postprocessing configuration,
+                if None, test_cfg would be used.
+            rescale (bool): If True, return boxes in original image space.
+                Default to False.
+            with_nms (bool): If True, do nms before return boxes.
+                Default to True.
+            img_meta (dict, optional): Image meta info. Defaults to None.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+                - masks (Tensor): Has a shape (num_instances, h, w).
+        """
+        stride = self.prior_generator.strides[0][0]
+        if rescale:
+            assert img_meta.get('scale_factor') is not None
+            scale_factor = [1 / s for s in img_meta['scale_factor']]
+            results.bboxes = scale_boxes(results.bboxes, scale_factor)
+
+        if hasattr(results, 'score_factors'):
+            # TODO: Add sqrt operation in order to be consistent with
+            #  the paper.
+            score_factors = results.pop('score_factors')
+            results.scores = results.scores * score_factors
+
+        # filter small size bboxes
+        if cfg.get('min_bbox_size', -1) >= 0:
+            w, h = get_box_wh(results.bboxes)
+            valid_mask = (w > cfg.min_bbox_size) & (h > cfg.min_bbox_size)
+            if not valid_mask.all():
+                results = results[valid_mask]
+
+        # TODO: deal with `with_nms` and `nms_cfg=None` in test_cfg
+        assert with_nms, 'with_nms must be True for RTMDet-Ins'
+        if results.bboxes.numel() > 0:
+            bboxes = get_box_tensor(results.bboxes)
+            det_bboxes, keep_idxs = batched_nms(bboxes, results.scores,
+                                                results.labels, cfg.nms)
+            results = results[keep_idxs]
+            # some nms would reweight the score, such as softnms
+            results.scores = det_bboxes[:, -1]
+            results = results[:cfg.max_per_img]
+
+            # process masks
+            mask_logits = self._mask_predict_by_feat_single(
+                mask_feat, results.kernels, results.priors)
+
+            mask_logits = F.interpolate(
+                mask_logits.unsqueeze(0), scale_factor=stride, mode='bilinear')
+            if rescale:
+                ori_h, ori_w = img_meta['ori_shape'][:2]
+                mask_logits = F.interpolate(
+                    mask_logits,
+                    size=[
+                        math.ceil(mask_logits.shape[-2] * scale_factor[0]),
+                        math.ceil(mask_logits.shape[-1] * scale_factor[1])
+                    ],
+                    mode='bilinear',
+                    align_corners=False)[..., :ori_h, :ori_w]
+            masks = mask_logits.sigmoid().squeeze(0)
+            masks = masks > cfg.mask_thr_binary
+            results.masks = masks
+        else:
+            h, w = img_meta['ori_shape'][:2] if rescale else img_meta[
+                'img_shape'][:2]
+            results.masks = torch.zeros(
+                size=(results.bboxes.shape[0], h, w),
+                dtype=torch.bool,
+                device=results.bboxes.device)
+
+        return results
+
+    def parse_dynamic_params(self, flatten_kernels: Tensor) -> tuple:
+        """split kernel head prediction to conv weight and bias."""
+        n_inst = flatten_kernels.size(0)
+        n_layers = len(self.weight_nums)
+        params_splits = list(
+            torch.split_with_sizes(
+                flatten_kernels, self.weight_nums + self.bias_nums, dim=1))
+        weight_splits = params_splits[:n_layers]
+        bias_splits = params_splits[n_layers:]
+        for i in range(n_layers):
+            if i < n_layers - 1:
+                weight_splits[i] = weight_splits[i].reshape(
+                    n_inst * self.dyconv_channels, -1, 1, 1)
+                bias_splits[i] = bias_splits[i].reshape(n_inst *
+                                                        self.dyconv_channels)
+            else:
+                weight_splits[i] = weight_splits[i].reshape(n_inst, -1, 1, 1)
+                bias_splits[i] = bias_splits[i].reshape(n_inst)
+
+        return weight_splits, bias_splits
+
+    def _mask_predict_by_feat_single(self, mask_feat: Tensor, kernels: Tensor,
+                                     priors: Tensor) -> Tensor:
+        """Generate mask logits from mask features with dynamic convs.
+
+        Args:
+            mask_feat (Tensor): Mask prototype features.
+                Has shape (num_prototypes, H, W).
+            kernels (Tensor): Kernel parameters for each instance.
+                Has shape (num_instance, num_params)
+            priors (Tensor): Center priors for each instance.
+                Has shape (num_instance, 4).
+        Returns:
+            Tensor: Instance segmentation masks for each instance.
+                Has shape (num_instance, H, W).
+        """
+        num_inst = priors.shape[0]
+        h, w = mask_feat.size()[-2:]
+        if num_inst < 1:
+            return torch.empty(
+                size=(num_inst, h, w),
+                dtype=mask_feat.dtype,
+                device=mask_feat.device)
+        if len(mask_feat.shape) < 4:
+            mask_feat.unsqueeze(0)
+
+        coord = self.prior_generator.single_level_grid_priors(
+            (h, w), level_idx=0, device=mask_feat.device).reshape(1, -1, 2)
+        num_inst = priors.shape[0]
+        points = priors[:, :2].reshape(-1, 1, 2)
+        strides = priors[:, 2:].reshape(-1, 1, 2)
+        relative_coord = (points - coord).permute(0, 2, 1) / (
+            strides[..., 0].reshape(-1, 1, 1) * 8)
+        relative_coord = relative_coord.reshape(num_inst, 2, h, w)
+
+        mask_feat = torch.cat(
+            [relative_coord,
+             mask_feat.repeat(num_inst, 1, 1, 1)], dim=1)
+        weights, biases = self.parse_dynamic_params(kernels)
+
+        n_layers = len(weights)
+        x = mask_feat.reshape(1, -1, h, w)
+        for i, (weight, bias) in enumerate(zip(weights, biases)):
+            x = F.conv2d(
+                x, weight, bias=bias, stride=1, padding=0, groups=num_inst)
+            if i < n_layers - 1:
+                x = F.relu(x)
+        x = x.reshape(num_inst, h, w)
+        return x
+
+    def loss_mask_by_feat(self, mask_feats: Tensor, flatten_kernels: Tensor,
+                          sampling_results_list: list,
+                          batch_gt_instances: InstanceList) -> Tensor:
+        """Compute instance segmentation loss.
+
+        Args:
+            mask_feats (list[Tensor]): Mask prototype features extracted from
+                the mask head. Has shape (N, num_prototypes, H, W)
+            flatten_kernels (list[Tensor]): Kernels of the dynamic conv layers.
+                Has shape (N, num_instances, num_params)
+            sampling_results_list (list[:obj:`SamplingResults`]) Batch of
+                assignment results.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+
+        Returns:
+            Tensor: The mask loss tensor.
+        """
+        batch_pos_mask_logits = []
+        pos_gt_masks = []
+        for idx, (mask_feat, kernels, sampling_results,
+                  gt_instances) in enumerate(
+                      zip(mask_feats, flatten_kernels, sampling_results_list,
+                          batch_gt_instances)):
+            pos_priors = sampling_results.pos_priors
+            pos_inds = sampling_results.pos_inds
+            pos_kernels = kernels[pos_inds]  # n_pos, num_gen_params
+            pos_mask_logits = self._mask_predict_by_feat_single(
+                mask_feat, pos_kernels, pos_priors)
+            if gt_instances.masks.numel() == 0:
+                gt_masks = torch.empty_like(gt_instances.masks)
+            else:
+                gt_masks = gt_instances.masks[
+                    sampling_results.pos_assigned_gt_inds, :]
+            batch_pos_mask_logits.append(pos_mask_logits)
+            pos_gt_masks.append(gt_masks)
+
+        pos_gt_masks = torch.cat(pos_gt_masks, 0)
+        batch_pos_mask_logits = torch.cat(batch_pos_mask_logits, 0)
+
+        # avg_factor
+        num_pos = batch_pos_mask_logits.shape[0]
+        num_pos = reduce_mean(mask_feats.new_tensor([num_pos
+                                                     ])).clamp_(min=1).item()
+
+        if batch_pos_mask_logits.shape[0] == 0:
+            return mask_feats.sum() * 0
+
+        scale = self.prior_generator.strides[0][0] // self.mask_loss_stride
+        # upsample pred masks
+        batch_pos_mask_logits = F.interpolate(
+            batch_pos_mask_logits.unsqueeze(0),
+            scale_factor=scale,
+            mode='bilinear',
+            align_corners=False).squeeze(0)
+        # downsample gt masks
+        pos_gt_masks = pos_gt_masks[:, self.mask_loss_stride //
+                                    2::self.mask_loss_stride,
+                                    self.mask_loss_stride //
+                                    2::self.mask_loss_stride]
+
+        loss_mask = self.loss_mask(
+            batch_pos_mask_logits,
+            pos_gt_masks,
+            weight=None,
+            avg_factor=num_pos)
+
+        return loss_mask
+
+    def loss_by_feat(self,
+                     cls_scores: List[Tensor],
+                     bbox_preds: List[Tensor],
+                     kernel_preds: List[Tensor],
+                     mask_feat: Tensor,
+                     batch_gt_instances: InstanceList,
+                     batch_img_metas: List[dict],
+                     batch_gt_instances_ignore: OptInstanceList = None):
+        """Compute losses of the head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level
+                Has shape (N, num_anchors * num_classes, H, W)
+            bbox_preds (list[Tensor]): Decoded box for each scale
+                level with shape (N, num_anchors * 4, H, W) in
+                [tl_x, tl_y, br_x, br_y] format.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], Optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        num_imgs = len(batch_img_metas)
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        assert len(featmap_sizes) == self.prior_generator.num_levels
+
+        device = cls_scores[0].device
+        anchor_list, valid_flag_list = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+        flatten_cls_scores = torch.cat([
+            cls_score.permute(0, 2, 3, 1).reshape(num_imgs, -1,
+                                                  self.cls_out_channels)
+            for cls_score in cls_scores
+        ], 1)
+        flatten_kernels = torch.cat([
+            kernel_pred.permute(0, 2, 3, 1).reshape(num_imgs, -1,
+                                                    self.num_gen_params)
+            for kernel_pred in kernel_preds
+        ], 1)
+        decoded_bboxes = []
+        for anchor, bbox_pred in zip(anchor_list[0], bbox_preds):
+            anchor = anchor.reshape(-1, 4)
+            bbox_pred = bbox_pred.permute(0, 2, 3, 1).reshape(num_imgs, -1, 4)
+            bbox_pred = distance2bbox(anchor, bbox_pred)
+            decoded_bboxes.append(bbox_pred)
+
+        flatten_bboxes = torch.cat(decoded_bboxes, 1)
+        for gt_instances in batch_gt_instances:
+            gt_instances.masks = gt_instances.masks.to_tensor(
+                dtype=torch.bool, device=device)
+
+        cls_reg_targets = self.get_targets(
+            flatten_cls_scores,
+            flatten_bboxes,
+            anchor_list,
+            valid_flag_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore)
+        (anchor_list, labels_list, label_weights_list, bbox_targets_list,
+         assign_metrics_list, sampling_results_list) = cls_reg_targets
+
+        losses_cls, losses_bbox,\
+            cls_avg_factors, bbox_avg_factors = multi_apply(
+                self.loss_by_feat_single,
+                cls_scores,
+                decoded_bboxes,
+                labels_list,
+                label_weights_list,
+                bbox_targets_list,
+                assign_metrics_list,
+                self.prior_generator.strides)
+
+        cls_avg_factor = reduce_mean(sum(cls_avg_factors)).clamp_(min=1).item()
+        losses_cls = list(map(lambda x: x / cls_avg_factor, losses_cls))
+
+        bbox_avg_factor = reduce_mean(
+            sum(bbox_avg_factors)).clamp_(min=1).item()
+        losses_bbox = list(map(lambda x: x / bbox_avg_factor, losses_bbox))
+
+        loss_mask = self.loss_mask_by_feat(mask_feat, flatten_kernels,
+                                           sampling_results_list,
+                                           batch_gt_instances)
+        loss = dict(
+            loss_cls=losses_cls, loss_bbox=losses_bbox, loss_mask=loss_mask)
+        return loss
+
+
+class MaskFeatModule(BaseModule):
+    """Mask feature head used in RTMDet-Ins.
+
+    Args:
+        in_channels (int): Number of channels in the input feature map.
+        feat_channels (int): Number of hidden channels of the mask feature
+             map branch.
+        num_levels (int): The starting feature map level from RPN that
+             will be used to predict the mask feature map.
+        num_prototypes (int): Number of output channel of the mask feature
+             map branch. This is the channel count of the mask
+             feature map that to be dynamically convolved with the predicted
+             kernel.
+        stacked_convs (int): Number of convs in mask feature branch.
+        act_cfg (:obj:`ConfigDict` or dict): Config dict for activation layer.
+            Default: dict(type='ReLU', inplace=True)
+        norm_cfg (dict): Config dict for normalization layer. Default: None.
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        feat_channels: int = 256,
+        stacked_convs: int = 4,
+        num_levels: int = 3,
+        num_prototypes: int = 8,
+        act_cfg: ConfigType = dict(type='ReLU', inplace=True),
+        norm_cfg: ConfigType = dict(type='BN')
+    ) -> None:
+        super().__init__(init_cfg=None)
+        self.num_levels = num_levels
+        self.fusion_conv = nn.Conv2d(num_levels * in_channels, in_channels, 1)
+        convs = []
+        for i in range(stacked_convs):
+            in_c = in_channels if i == 0 else feat_channels
+            convs.append(
+                ConvModule(
+                    in_c,
+                    feat_channels,
+                    3,
+                    padding=1,
+                    act_cfg=act_cfg,
+                    norm_cfg=norm_cfg))
+        self.stacked_convs = nn.Sequential(*convs)
+        self.projection = nn.Conv2d(
+            feat_channels, num_prototypes, kernel_size=1)
+
+    def forward(self, features: Tuple[Tensor, ...]) -> Tensor:
+        # multi-level feature fusion
+        fusion_feats = [features[0]]
+        size = features[0].shape[-2:]
+        for i in range(1, self.num_levels):
+            f = F.interpolate(features[i], size=size, mode='bilinear')
+            fusion_feats.append(f)
+        fusion_feats = torch.cat(fusion_feats, dim=1)
+        fusion_feats = self.fusion_conv(fusion_feats)
+        # pred mask feats
+        mask_features = self.stacked_convs(fusion_feats)
+        mask_features = self.projection(mask_features)
+        return mask_features
+
+
+@MODELS.register_module()
+class RTMDetInsSepBNHead(RTMDetInsHead):
+    """Detection Head of RTMDet-Ins with sep-bn layers.
+
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (int): Number of channels in the input feature map.
+        share_conv (bool): Whether to share conv layers between stages.
+            Defaults to True.
+        norm_cfg (:obj:`ConfigDict` or dict)): Config dict for normalization
+            layer. Defaults to dict(type='BN').
+        act_cfg (:obj:`ConfigDict` or dict)): Config dict for activation layer.
+            Defaults to dict(type='SiLU', inplace=True).
+        pred_kernel_size (int): Kernel size of prediction layer. Defaults to 1.
+    """
+
+    def __init__(self,
+                 num_classes: int,
+                 in_channels: int,
+                 share_conv: bool = True,
+                 with_objectness: bool = False,
+                 norm_cfg: ConfigType = dict(type='BN', requires_grad=True),
+                 act_cfg: ConfigType = dict(type='SiLU', inplace=True),
+                 pred_kernel_size: int = 1,
+                 **kwargs) -> None:
+        self.share_conv = share_conv
+        super().__init__(
+            num_classes,
+            in_channels,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg,
+            pred_kernel_size=pred_kernel_size,
+            with_objectness=with_objectness,
+            **kwargs)
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        self.cls_convs = nn.ModuleList()
+        self.reg_convs = nn.ModuleList()
+        self.kernel_convs = nn.ModuleList()
+
+        self.rtm_cls = nn.ModuleList()
+        self.rtm_reg = nn.ModuleList()
+        self.rtm_kernel = nn.ModuleList()
+        self.rtm_obj = nn.ModuleList()
+
+        # calculate num dynamic parameters
+        weight_nums, bias_nums = [], []
+        for i in range(self.num_dyconvs):
+            if i == 0:
+                weight_nums.append(
+                    (self.num_prototypes + 2) * self.dyconv_channels)
+                bias_nums.append(self.dyconv_channels)
+            elif i == self.num_dyconvs - 1:
+                weight_nums.append(self.dyconv_channels)
+                bias_nums.append(1)
+            else:
+                weight_nums.append(self.dyconv_channels * self.dyconv_channels)
+                bias_nums.append(self.dyconv_channels)
+        self.weight_nums = weight_nums
+        self.bias_nums = bias_nums
+        self.num_gen_params = sum(weight_nums) + sum(bias_nums)
+        pred_pad_size = self.pred_kernel_size // 2
+
+        for n in range(len(self.prior_generator.strides)):
+            cls_convs = nn.ModuleList()
+            reg_convs = nn.ModuleList()
+            kernel_convs = nn.ModuleList()
+            for i in range(self.stacked_convs):
+                chn = self.in_channels if i == 0 else self.feat_channels
+                cls_convs.append(
+                    ConvModule(
+                        chn,
+                        self.feat_channels,
+                        3,
+                        stride=1,
+                        padding=1,
+                        conv_cfg=self.conv_cfg,
+                        norm_cfg=self.norm_cfg,
+                        act_cfg=self.act_cfg))
+                reg_convs.append(
+                    ConvModule(
+                        chn,
+                        self.feat_channels,
+                        3,
+                        stride=1,
+                        padding=1,
+                        conv_cfg=self.conv_cfg,
+                        norm_cfg=self.norm_cfg,
+                        act_cfg=self.act_cfg))
+                kernel_convs.append(
+                    ConvModule(
+                        chn,
+                        self.feat_channels,
+                        3,
+                        stride=1,
+                        padding=1,
+                        conv_cfg=self.conv_cfg,
+                        norm_cfg=self.norm_cfg,
+                        act_cfg=self.act_cfg))
+            self.cls_convs.append(cls_convs)
+            self.reg_convs.append(cls_convs)
+            self.kernel_convs.append(kernel_convs)
+
+            self.rtm_cls.append(
+                nn.Conv2d(
+                    self.feat_channels,
+                    self.num_base_priors * self.cls_out_channels,
+                    self.pred_kernel_size,
+                    padding=pred_pad_size))
+            self.rtm_reg.append(
+                nn.Conv2d(
+                    self.feat_channels,
+                    self.num_base_priors * 4,
+                    self.pred_kernel_size,
+                    padding=pred_pad_size))
+            self.rtm_kernel.append(
+                nn.Conv2d(
+                    self.feat_channels,
+                    self.num_gen_params,
+                    self.pred_kernel_size,
+                    padding=pred_pad_size))
+            if self.with_objectness:
+                self.rtm_obj.append(
+                    nn.Conv2d(
+                        self.feat_channels,
+                        1,
+                        self.pred_kernel_size,
+                        padding=pred_pad_size))
+
+        if self.share_conv:
+            for n in range(len(self.prior_generator.strides)):
+                for i in range(self.stacked_convs):
+                    self.cls_convs[n][i].conv = self.cls_convs[0][i].conv
+                    self.reg_convs[n][i].conv = self.reg_convs[0][i].conv
+
+        self.mask_head = MaskFeatModule(
+            in_channels=self.in_channels,
+            feat_channels=self.feat_channels,
+            stacked_convs=4,
+            num_levels=len(self.prior_generator.strides),
+            num_prototypes=self.num_prototypes,
+            act_cfg=self.act_cfg,
+            norm_cfg=self.norm_cfg)
+
+    def init_weights(self) -> None:
+        """Initialize weights of the head."""
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                normal_init(m, mean=0, std=0.01)
+            if is_norm(m):
+                constant_init(m, 1)
+        bias_cls = bias_init_with_prob(0.01)
+        for rtm_cls, rtm_reg, rtm_kernel in zip(self.rtm_cls, self.rtm_reg,
+                                                self.rtm_kernel):
+            normal_init(rtm_cls, std=0.01, bias=bias_cls)
+            normal_init(rtm_reg, std=0.01, bias=1)
+        if self.with_objectness:
+            for rtm_obj in self.rtm_obj:
+                normal_init(rtm_obj, std=0.01, bias=bias_cls)
+
+    def forward(self, feats: Tuple[Tensor, ...]) -> tuple:
+        """Forward features from the upstream network.
+
+        Args:
+            feats (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple: Usually a tuple of classification scores and bbox prediction
+            - cls_scores (list[Tensor]): Classification scores for all scale
+              levels, each is a 4D-tensor, the channels number is
+              num_base_priors * num_classes.
+            - bbox_preds (list[Tensor]): Box energies / deltas for all scale
+              levels, each is a 4D-tensor, the channels number is
+              num_base_priors * 4.
+            - kernel_preds (list[Tensor]): Dynamic conv kernels for all scale
+              levels, each is a 4D-tensor, the channels number is
+              num_gen_params.
+            - mask_feat (Tensor): Output feature of the mask head. Each is a
+              4D-tensor, the channels number is num_prototypes.
+        """
+        mask_feat = self.mask_head(feats)
+
+        cls_scores = []
+        bbox_preds = []
+        kernel_preds = []
+        for idx, (x, stride) in enumerate(
+                zip(feats, self.prior_generator.strides)):
+            cls_feat = x
+            reg_feat = x
+            kernel_feat = x
+
+            for cls_layer in self.cls_convs[idx]:
+                cls_feat = cls_layer(cls_feat)
+            cls_score = self.rtm_cls[idx](cls_feat)
+
+            for kernel_layer in self.kernel_convs[idx]:
+                kernel_feat = kernel_layer(kernel_feat)
+            kernel_pred = self.rtm_kernel[idx](kernel_feat)
+
+            for reg_layer in self.reg_convs[idx]:
+                reg_feat = reg_layer(reg_feat)
+
+            if self.with_objectness:
+                objectness = self.rtm_obj[idx](reg_feat)
+                cls_score = inverse_sigmoid(
+                    sigmoid_geometric_mean(cls_score, objectness))
+
+            reg_dist = F.relu(self.rtm_reg[idx](reg_feat)) * stride[0]
+
+            cls_scores.append(cls_score)
+            bbox_preds.append(reg_dist)
+            kernel_preds.append(kernel_pred)
+        return tuple(cls_scores), tuple(bbox_preds), tuple(
+            kernel_preds), mask_feat
diff --git a/mmdetection/mmdet/models/dense_heads/sabl_retina_head.py b/mmdetection/mmdet/models/dense_heads/sabl_retina_head.py
new file mode 100644
index 00000000..8cd1b71c
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/sabl_retina_head.py
@@ -0,0 +1,706 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Tuple, Union
+
+import numpy as np
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmengine.config import ConfigDict
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.utils import (ConfigType, InstanceList, MultiConfig, OptConfigType,
+                         OptInstanceList)
+from ..task_modules.samplers import PseudoSampler
+from ..utils import (filter_scores_and_topk, images_to_levels, multi_apply,
+                     unmap)
+from .base_dense_head import BaseDenseHead
+from .guided_anchor_head import GuidedAnchorHead
+
+
+@MODELS.register_module()
+class SABLRetinaHead(BaseDenseHead):
+    """Side-Aware Boundary Localization (SABL) for RetinaNet.
+
+    The anchor generation, assigning and sampling in SABLRetinaHead
+    are the same as GuidedAnchorHead for guided anchoring.
+
+    Please refer to https://arxiv.org/abs/1912.04260 for more details.
+
+    Args:
+        num_classes (int): Number of classes.
+        in_channels (int): Number of channels in the input feature map.
+        stacked_convs (int): Number of Convs for classification and
+            regression branches. Defaults to 4.
+        feat_channels (int): Number of hidden channels. Defaults to 256.
+        approx_anchor_generator (:obj:`ConfigType` or dict): Config dict for
+            approx generator.
+        square_anchor_generator (:obj:`ConfigDict` or dict): Config dict for
+            square generator.
+        conv_cfg (:obj:`ConfigDict` or dict, optional): Config dict for
+            ConvModule. Defaults to None.
+        norm_cfg (:obj:`ConfigDict` or dict, optional): Config dict for
+            Norm Layer. Defaults to None.
+        bbox_coder (:obj:`ConfigDict` or dict): Config dict for bbox coder.
+        reg_decoded_bbox (bool): If true, the regression loss would be
+            applied directly on decoded bounding boxes, converting both
+            the predicted boxes and regression targets to absolute
+            coordinates format. Default False. It should be ``True`` when
+            using ``IoULoss``, ``GIoULoss``, or ``DIoULoss`` in the bbox head.
+        train_cfg (:obj:`ConfigDict` or dict, optional): Training config of
+            SABLRetinaHead.
+        test_cfg (:obj:`ConfigDict` or dict, optional): Testing config of
+            SABLRetinaHead.
+        loss_cls (:obj:`ConfigDict` or dict): Config of classification loss.
+        loss_bbox_cls (:obj:`ConfigDict` or dict): Config of classification
+            loss for bbox branch.
+        loss_bbox_reg (:obj:`ConfigDict` or dict): Config of regression loss
+            for bbox branch.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict], optional): Initialization config dict.
+    """
+
+    def __init__(
+        self,
+        num_classes: int,
+        in_channels: int,
+        stacked_convs: int = 4,
+        feat_channels: int = 256,
+        approx_anchor_generator: ConfigType = dict(
+            type='AnchorGenerator',
+            octave_base_scale=4,
+            scales_per_octave=3,
+            ratios=[0.5, 1.0, 2.0],
+            strides=[8, 16, 32, 64, 128]),
+        square_anchor_generator: ConfigType = dict(
+            type='AnchorGenerator',
+            ratios=[1.0],
+            scales=[4],
+            strides=[8, 16, 32, 64, 128]),
+        conv_cfg: OptConfigType = None,
+        norm_cfg: OptConfigType = None,
+        bbox_coder: ConfigType = dict(
+            type='BucketingBBoxCoder', num_buckets=14, scale_factor=3.0),
+        reg_decoded_bbox: bool = False,
+        train_cfg: OptConfigType = None,
+        test_cfg: OptConfigType = None,
+        loss_cls: ConfigType = dict(
+            type='FocalLoss',
+            use_sigmoid=True,
+            gamma=2.0,
+            alpha=0.25,
+            loss_weight=1.0),
+        loss_bbox_cls: ConfigType = dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.5),
+        loss_bbox_reg: ConfigType = dict(
+            type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=1.5),
+        init_cfg: MultiConfig = dict(
+            type='Normal',
+            layer='Conv2d',
+            std=0.01,
+            override=dict(
+                type='Normal', name='retina_cls', std=0.01, bias_prob=0.01))
+    ) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.in_channels = in_channels
+        self.num_classes = num_classes
+        self.feat_channels = feat_channels
+        self.num_buckets = bbox_coder['num_buckets']
+        self.side_num = int(np.ceil(self.num_buckets / 2))
+
+        assert (approx_anchor_generator['octave_base_scale'] ==
+                square_anchor_generator['scales'][0])
+        assert (approx_anchor_generator['strides'] ==
+                square_anchor_generator['strides'])
+
+        self.approx_anchor_generator = TASK_UTILS.build(
+            approx_anchor_generator)
+        self.square_anchor_generator = TASK_UTILS.build(
+            square_anchor_generator)
+        self.approxs_per_octave = (
+            self.approx_anchor_generator.num_base_priors[0])
+
+        # one anchor per location
+        self.num_base_priors = self.square_anchor_generator.num_base_priors[0]
+
+        self.stacked_convs = stacked_convs
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+
+        self.reg_decoded_bbox = reg_decoded_bbox
+
+        self.use_sigmoid_cls = loss_cls.get('use_sigmoid', False)
+        if self.use_sigmoid_cls:
+            self.cls_out_channels = num_classes
+        else:
+            self.cls_out_channels = num_classes + 1
+
+        self.bbox_coder = TASK_UTILS.build(bbox_coder)
+        self.loss_cls = MODELS.build(loss_cls)
+        self.loss_bbox_cls = MODELS.build(loss_bbox_cls)
+        self.loss_bbox_reg = MODELS.build(loss_bbox_reg)
+
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+
+        if self.train_cfg:
+            self.assigner = TASK_UTILS.build(self.train_cfg['assigner'])
+            # use PseudoSampler when sampling is False
+            if 'sampler' in self.train_cfg:
+                self.sampler = TASK_UTILS.build(
+                    self.train_cfg['sampler'], default_args=dict(context=self))
+            else:
+                self.sampler = PseudoSampler(context=self)
+
+        self._init_layers()
+
+    def _init_layers(self) -> None:
+        self.relu = nn.ReLU(inplace=True)
+        self.cls_convs = nn.ModuleList()
+        self.reg_convs = nn.ModuleList()
+        for i in range(self.stacked_convs):
+            chn = self.in_channels if i == 0 else self.feat_channels
+            self.cls_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg))
+            self.reg_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg))
+        self.retina_cls = nn.Conv2d(
+            self.feat_channels, self.cls_out_channels, 3, padding=1)
+        self.retina_bbox_reg = nn.Conv2d(
+            self.feat_channels, self.side_num * 4, 3, padding=1)
+        self.retina_bbox_cls = nn.Conv2d(
+            self.feat_channels, self.side_num * 4, 3, padding=1)
+
+    def forward_single(self, x: Tensor) -> Tuple[Tensor, Tensor]:
+        cls_feat = x
+        reg_feat = x
+        for cls_conv in self.cls_convs:
+            cls_feat = cls_conv(cls_feat)
+        for reg_conv in self.reg_convs:
+            reg_feat = reg_conv(reg_feat)
+        cls_score = self.retina_cls(cls_feat)
+        bbox_cls_pred = self.retina_bbox_cls(reg_feat)
+        bbox_reg_pred = self.retina_bbox_reg(reg_feat)
+        bbox_pred = (bbox_cls_pred, bbox_reg_pred)
+        return cls_score, bbox_pred
+
+    def forward(self, feats: List[Tensor]) -> Tuple[List[Tensor]]:
+        return multi_apply(self.forward_single, feats)
+
+    def get_anchors(
+        self,
+        featmap_sizes: List[tuple],
+        img_metas: List[dict],
+        device: Union[torch.device, str] = 'cuda'
+    ) -> Tuple[List[List[Tensor]], List[List[Tensor]]]:
+        """Get squares according to feature map sizes and guided anchors.
+
+        Args:
+            featmap_sizes (list[tuple]): Multi-level feature map sizes.
+            img_metas (list[dict]): Image meta info.
+            device (torch.device | str): device for returned tensors
+
+        Returns:
+            tuple: square approxs of each image
+        """
+        num_imgs = len(img_metas)
+
+        # since feature map sizes of all images are the same, we only compute
+        # squares for one time
+        multi_level_squares = self.square_anchor_generator.grid_priors(
+            featmap_sizes, device=device)
+        squares_list = [multi_level_squares for _ in range(num_imgs)]
+
+        return squares_list
+
+    def get_targets(self,
+                    approx_list: List[List[Tensor]],
+                    inside_flag_list: List[List[Tensor]],
+                    square_list: List[List[Tensor]],
+                    batch_gt_instances: InstanceList,
+                    batch_img_metas,
+                    batch_gt_instances_ignore: OptInstanceList = None,
+                    unmap_outputs=True) -> tuple:
+        """Compute bucketing targets.
+
+        Args:
+            approx_list (list[list[Tensor]]): Multi level approxs of each
+                image.
+            inside_flag_list (list[list[Tensor]]): Multi level inside flags of
+                each image.
+            square_list (list[list[Tensor]]): Multi level squares of each
+                image.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+            unmap_outputs (bool): Whether to map outputs back to the original
+                set of anchors. Defaults to True.
+
+        Returns:
+            tuple: Returns a tuple containing learning targets.
+
+            - labels_list (list[Tensor]): Labels of each level.
+            - label_weights_list (list[Tensor]): Label weights of each level.
+            - bbox_cls_targets_list (list[Tensor]): BBox cls targets of \
+            each level.
+            - bbox_cls_weights_list (list[Tensor]): BBox cls weights of \
+            each level.
+            - bbox_reg_targets_list (list[Tensor]): BBox reg targets of \
+            each level.
+            - bbox_reg_weights_list (list[Tensor]): BBox reg weights of \
+            each level.
+            - num_total_pos (int): Number of positive samples in all images.
+            - num_total_neg (int): Number of negative samples in all images.
+        """
+        num_imgs = len(batch_img_metas)
+        assert len(approx_list) == len(inside_flag_list) == len(
+            square_list) == num_imgs
+        # anchor number of multi levels
+        num_level_squares = [squares.size(0) for squares in square_list[0]]
+        # concat all level anchors and flags to a single tensor
+        inside_flag_flat_list = []
+        approx_flat_list = []
+        square_flat_list = []
+        for i in range(num_imgs):
+            assert len(square_list[i]) == len(inside_flag_list[i])
+            inside_flag_flat_list.append(torch.cat(inside_flag_list[i]))
+            approx_flat_list.append(torch.cat(approx_list[i]))
+            square_flat_list.append(torch.cat(square_list[i]))
+
+        # compute targets for each image
+        if batch_gt_instances_ignore is None:
+            batch_gt_instances_ignore = [None for _ in range(num_imgs)]
+        (all_labels, all_label_weights, all_bbox_cls_targets,
+         all_bbox_cls_weights, all_bbox_reg_targets, all_bbox_reg_weights,
+         pos_inds_list, neg_inds_list, sampling_results_list) = multi_apply(
+             self._get_targets_single,
+             approx_flat_list,
+             inside_flag_flat_list,
+             square_flat_list,
+             batch_gt_instances,
+             batch_img_metas,
+             batch_gt_instances_ignore,
+             unmap_outputs=unmap_outputs)
+
+        # sampled anchors of all images
+        avg_factor = sum(
+            [results.avg_factor for results in sampling_results_list])
+        # split targets to a list w.r.t. multiple levels
+        labels_list = images_to_levels(all_labels, num_level_squares)
+        label_weights_list = images_to_levels(all_label_weights,
+                                              num_level_squares)
+        bbox_cls_targets_list = images_to_levels(all_bbox_cls_targets,
+                                                 num_level_squares)
+        bbox_cls_weights_list = images_to_levels(all_bbox_cls_weights,
+                                                 num_level_squares)
+        bbox_reg_targets_list = images_to_levels(all_bbox_reg_targets,
+                                                 num_level_squares)
+        bbox_reg_weights_list = images_to_levels(all_bbox_reg_weights,
+                                                 num_level_squares)
+        return (labels_list, label_weights_list, bbox_cls_targets_list,
+                bbox_cls_weights_list, bbox_reg_targets_list,
+                bbox_reg_weights_list, avg_factor)
+
+    def _get_targets_single(self,
+                            flat_approxs: Tensor,
+                            inside_flags: Tensor,
+                            flat_squares: Tensor,
+                            gt_instances: InstanceData,
+                            img_meta: dict,
+                            gt_instances_ignore: Optional[InstanceData] = None,
+                            unmap_outputs: bool = True) -> tuple:
+        """Compute regression and classification targets for anchors in a
+        single image.
+
+        Args:
+            flat_approxs (Tensor): flat approxs of a single image,
+                shape (n, 4)
+            inside_flags (Tensor): inside flags of a single image,
+                shape (n, ).
+            flat_squares (Tensor): flat squares of a single image,
+                shape (approxs_per_octave * n, 4)
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It should includes ``bboxes`` and ``labels``
+                attributes.
+            img_meta (dict): Meta information for current image.
+            gt_instances_ignore (:obj:`InstanceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+            unmap_outputs (bool): Whether to map outputs back to the original
+                set of anchors.  Defaults to True.
+
+        Returns:
+            tuple:
+
+            - labels_list (Tensor): Labels in a single image.
+            - label_weights (Tensor): Label weights in a single image.
+            - bbox_cls_targets (Tensor): BBox cls targets in a single image.
+            - bbox_cls_weights (Tensor): BBox cls weights in a single image.
+            - bbox_reg_targets (Tensor): BBox reg targets in a single image.
+            - bbox_reg_weights (Tensor): BBox reg weights in a single image.
+            - num_total_pos (int): Number of positive samples in a single \
+            image.
+            - num_total_neg (int): Number of negative samples in a single \
+            image.
+            - sampling_result (:obj:`SamplingResult`): Sampling result object.
+        """
+        if not inside_flags.any():
+            raise ValueError(
+                'There is no valid anchor inside the image boundary. Please '
+                'check the image size and anchor sizes, or set '
+                '``allowed_border`` to -1 to skip the condition.')
+        # assign gt and sample anchors
+        num_square = flat_squares.size(0)
+        approxs = flat_approxs.view(num_square, self.approxs_per_octave, 4)
+        approxs = approxs[inside_flags, ...]
+        squares = flat_squares[inside_flags, :]
+
+        pred_instances = InstanceData()
+        pred_instances.priors = squares
+        pred_instances.approxs = approxs
+        assign_result = self.assigner.assign(pred_instances, gt_instances,
+                                             gt_instances_ignore)
+        sampling_result = self.sampler.sample(assign_result, pred_instances,
+                                              gt_instances)
+
+        num_valid_squares = squares.shape[0]
+        bbox_cls_targets = squares.new_zeros(
+            (num_valid_squares, self.side_num * 4))
+        bbox_cls_weights = squares.new_zeros(
+            (num_valid_squares, self.side_num * 4))
+        bbox_reg_targets = squares.new_zeros(
+            (num_valid_squares, self.side_num * 4))
+        bbox_reg_weights = squares.new_zeros(
+            (num_valid_squares, self.side_num * 4))
+        labels = squares.new_full((num_valid_squares, ),
+                                  self.num_classes,
+                                  dtype=torch.long)
+        label_weights = squares.new_zeros(num_valid_squares, dtype=torch.float)
+
+        pos_inds = sampling_result.pos_inds
+        neg_inds = sampling_result.neg_inds
+        if len(pos_inds) > 0:
+            (pos_bbox_reg_targets, pos_bbox_reg_weights, pos_bbox_cls_targets,
+             pos_bbox_cls_weights) = self.bbox_coder.encode(
+                 sampling_result.pos_bboxes, sampling_result.pos_gt_bboxes)
+
+            bbox_cls_targets[pos_inds, :] = pos_bbox_cls_targets
+            bbox_reg_targets[pos_inds, :] = pos_bbox_reg_targets
+            bbox_cls_weights[pos_inds, :] = pos_bbox_cls_weights
+            bbox_reg_weights[pos_inds, :] = pos_bbox_reg_weights
+            labels[pos_inds] = sampling_result.pos_gt_labels
+            if self.train_cfg['pos_weight'] <= 0:
+                label_weights[pos_inds] = 1.0
+            else:
+                label_weights[pos_inds] = self.train_cfg['pos_weight']
+        if len(neg_inds) > 0:
+            label_weights[neg_inds] = 1.0
+
+        # map up to original set of anchors
+        if unmap_outputs:
+            num_total_anchors = flat_squares.size(0)
+            labels = unmap(
+                labels, num_total_anchors, inside_flags, fill=self.num_classes)
+            label_weights = unmap(label_weights, num_total_anchors,
+                                  inside_flags)
+            bbox_cls_targets = unmap(bbox_cls_targets, num_total_anchors,
+                                     inside_flags)
+            bbox_cls_weights = unmap(bbox_cls_weights, num_total_anchors,
+                                     inside_flags)
+            bbox_reg_targets = unmap(bbox_reg_targets, num_total_anchors,
+                                     inside_flags)
+            bbox_reg_weights = unmap(bbox_reg_weights, num_total_anchors,
+                                     inside_flags)
+        return (labels, label_weights, bbox_cls_targets, bbox_cls_weights,
+                bbox_reg_targets, bbox_reg_weights, pos_inds, neg_inds,
+                sampling_result)
+
+    def loss_by_feat_single(self, cls_score: Tensor, bbox_pred: Tensor,
+                            labels: Tensor, label_weights: Tensor,
+                            bbox_cls_targets: Tensor, bbox_cls_weights: Tensor,
+                            bbox_reg_targets: Tensor, bbox_reg_weights: Tensor,
+                            avg_factor: float) -> Tuple[Tensor]:
+        """Calculate the loss of a single scale level based on the features
+        extracted by the detection head.
+
+        Args:
+            cls_score (Tensor): Box scores for each scale level
+                Has shape (N, num_anchors * num_classes, H, W).
+            bbox_pred (Tensor): Box energies / deltas for each scale
+                level with shape (N, num_anchors * 4, H, W).
+            labels (Tensor): Labels in a single image.
+            label_weights (Tensor): Label weights in a single level.
+            bbox_cls_targets (Tensor): BBox cls targets in a single level.
+            bbox_cls_weights (Tensor): BBox cls weights in a single level.
+            bbox_reg_targets (Tensor): BBox reg targets in a single level.
+            bbox_reg_weights (Tensor): BBox reg weights in a single level.
+            avg_factor (int): Average factor that is used to average the loss.
+
+        Returns:
+            tuple: loss components.
+        """
+        # classification loss
+        labels = labels.reshape(-1)
+        label_weights = label_weights.reshape(-1)
+        cls_score = cls_score.permute(0, 2, 3,
+                                      1).reshape(-1, self.cls_out_channels)
+        loss_cls = self.loss_cls(
+            cls_score, labels, label_weights, avg_factor=avg_factor)
+        # regression loss
+        bbox_cls_targets = bbox_cls_targets.reshape(-1, self.side_num * 4)
+        bbox_cls_weights = bbox_cls_weights.reshape(-1, self.side_num * 4)
+        bbox_reg_targets = bbox_reg_targets.reshape(-1, self.side_num * 4)
+        bbox_reg_weights = bbox_reg_weights.reshape(-1, self.side_num * 4)
+        (bbox_cls_pred, bbox_reg_pred) = bbox_pred
+        bbox_cls_pred = bbox_cls_pred.permute(0, 2, 3, 1).reshape(
+            -1, self.side_num * 4)
+        bbox_reg_pred = bbox_reg_pred.permute(0, 2, 3, 1).reshape(
+            -1, self.side_num * 4)
+        loss_bbox_cls = self.loss_bbox_cls(
+            bbox_cls_pred,
+            bbox_cls_targets.long(),
+            bbox_cls_weights,
+            avg_factor=avg_factor * 4 * self.side_num)
+        loss_bbox_reg = self.loss_bbox_reg(
+            bbox_reg_pred,
+            bbox_reg_targets,
+            bbox_reg_weights,
+            avg_factor=avg_factor * 4 * self.bbox_coder.offset_topk)
+        return loss_cls, loss_bbox_cls, loss_bbox_reg
+
+    def loss_by_feat(
+            self,
+            cls_scores: List[Tensor],
+            bbox_preds: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> dict:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level
+                has shape (N, num_anchors * num_classes, H, W).
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level with shape (N, num_anchors * 4, H, W).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        assert len(featmap_sizes) == self.approx_anchor_generator.num_levels
+
+        device = cls_scores[0].device
+
+        # get sampled approxes
+        approxs_list, inside_flag_list = GuidedAnchorHead.get_sampled_approxs(
+            self, featmap_sizes, batch_img_metas, device=device)
+
+        square_list = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+
+        cls_reg_targets = self.get_targets(
+            approxs_list,
+            inside_flag_list,
+            square_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore)
+        (labels_list, label_weights_list, bbox_cls_targets_list,
+         bbox_cls_weights_list, bbox_reg_targets_list, bbox_reg_weights_list,
+         avg_factor) = cls_reg_targets
+
+        losses_cls, losses_bbox_cls, losses_bbox_reg = multi_apply(
+            self.loss_by_feat_single,
+            cls_scores,
+            bbox_preds,
+            labels_list,
+            label_weights_list,
+            bbox_cls_targets_list,
+            bbox_cls_weights_list,
+            bbox_reg_targets_list,
+            bbox_reg_weights_list,
+            avg_factor=avg_factor)
+        return dict(
+            loss_cls=losses_cls,
+            loss_bbox_cls=losses_bbox_cls,
+            loss_bbox_reg=losses_bbox_reg)
+
+    def predict_by_feat(self,
+                        cls_scores: List[Tensor],
+                        bbox_preds: List[Tensor],
+                        batch_img_metas: List[dict],
+                        cfg: Optional[ConfigDict] = None,
+                        rescale: bool = False,
+                        with_nms: bool = True) -> InstanceList:
+        """Transform a batch of output features extracted from the head into
+        bbox results.
+
+        Note: When score_factors is not None, the cls_scores are
+        usually multiplied by it then obtain the real score used in NMS,
+        such as CenterNess in FCOS, IoU branch in ATSS.
+
+        Args:
+            cls_scores (list[Tensor]): Classification scores for all
+                scale levels, each is a 4D-tensor, has shape
+                (batch_size, num_priors * num_classes, H, W).
+            bbox_preds (list[Tensor]): Box energies / deltas for all
+                scale levels, each is a 4D-tensor, has shape
+                (batch_size, num_priors * 4, H, W).
+            batch_img_metas (list[dict], Optional): Batch image meta info.
+            cfg (:obj:`ConfigDict`, optional): Test / postprocessing
+                configuration, if None, test_cfg would be used.
+                Defaults to None.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            with_nms (bool): If True, do nms before return boxes.
+                Defaults to True.
+
+        Returns:
+            list[:obj:`InstanceData`]: Object detection results of each image
+            after the post process. Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        assert len(cls_scores) == len(bbox_preds)
+        num_levels = len(cls_scores)
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+
+        device = cls_scores[0].device
+        mlvl_anchors = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+        result_list = []
+        for img_id in range(len(batch_img_metas)):
+            cls_score_list = [
+                cls_scores[i][img_id].detach() for i in range(num_levels)
+            ]
+            bbox_cls_pred_list = [
+                bbox_preds[i][0][img_id].detach() for i in range(num_levels)
+            ]
+            bbox_reg_pred_list = [
+                bbox_preds[i][1][img_id].detach() for i in range(num_levels)
+            ]
+            proposals = self._predict_by_feat_single(
+                cls_scores=cls_score_list,
+                bbox_cls_preds=bbox_cls_pred_list,
+                bbox_reg_preds=bbox_reg_pred_list,
+                mlvl_anchors=mlvl_anchors[img_id],
+                img_meta=batch_img_metas[img_id],
+                cfg=cfg,
+                rescale=rescale,
+                with_nms=with_nms)
+            result_list.append(proposals)
+        return result_list
+
+    def _predict_by_feat_single(self,
+                                cls_scores: List[Tensor],
+                                bbox_cls_preds: List[Tensor],
+                                bbox_reg_preds: List[Tensor],
+                                mlvl_anchors: List[Tensor],
+                                img_meta: dict,
+                                cfg: ConfigDict,
+                                rescale: bool = False,
+                                with_nms: bool = True) -> InstanceData:
+        cfg = self.test_cfg if cfg is None else cfg
+        nms_pre = cfg.get('nms_pre', -1)
+
+        mlvl_bboxes = []
+        mlvl_scores = []
+        mlvl_confids = []
+        mlvl_labels = []
+        assert len(cls_scores) == len(bbox_cls_preds) == len(
+            bbox_reg_preds) == len(mlvl_anchors)
+        for cls_score, bbox_cls_pred, bbox_reg_pred, anchors in zip(
+                cls_scores, bbox_cls_preds, bbox_reg_preds, mlvl_anchors):
+            assert cls_score.size()[-2:] == bbox_cls_pred.size(
+            )[-2:] == bbox_reg_pred.size()[-2::]
+            cls_score = cls_score.permute(1, 2,
+                                          0).reshape(-1, self.cls_out_channels)
+            if self.use_sigmoid_cls:
+                scores = cls_score.sigmoid()
+            else:
+                scores = cls_score.softmax(-1)[:, :-1]
+            bbox_cls_pred = bbox_cls_pred.permute(1, 2, 0).reshape(
+                -1, self.side_num * 4)
+            bbox_reg_pred = bbox_reg_pred.permute(1, 2, 0).reshape(
+                -1, self.side_num * 4)
+
+            # After https://github.com/open-mmlab/mmdetection/pull/6268/,
+            # this operation keeps fewer bboxes under the same `nms_pre`.
+            # There is no difference in performance for most models. If you
+            # find a slight drop in performance, you can set a larger
+            # `nms_pre` than before.
+            results = filter_scores_and_topk(
+                scores, cfg.score_thr, nms_pre,
+                dict(
+                    anchors=anchors,
+                    bbox_cls_pred=bbox_cls_pred,
+                    bbox_reg_pred=bbox_reg_pred))
+            scores, labels, _, filtered_results = results
+
+            anchors = filtered_results['anchors']
+            bbox_cls_pred = filtered_results['bbox_cls_pred']
+            bbox_reg_pred = filtered_results['bbox_reg_pred']
+
+            bbox_preds = [
+                bbox_cls_pred.contiguous(),
+                bbox_reg_pred.contiguous()
+            ]
+            bboxes, confids = self.bbox_coder.decode(
+                anchors.contiguous(),
+                bbox_preds,
+                max_shape=img_meta['img_shape'])
+
+            mlvl_bboxes.append(bboxes)
+            mlvl_scores.append(scores)
+            mlvl_confids.append(confids)
+            mlvl_labels.append(labels)
+
+        results = InstanceData()
+        results.bboxes = torch.cat(mlvl_bboxes)
+        results.scores = torch.cat(mlvl_scores)
+        results.score_factors = torch.cat(mlvl_confids)
+        results.labels = torch.cat(mlvl_labels)
+
+        return self._bbox_post_process(
+            results=results,
+            cfg=cfg,
+            rescale=rescale,
+            with_nms=with_nms,
+            img_meta=img_meta)
diff --git a/mmdetection/mmdet/models/dense_heads/solo_head.py b/mmdetection/mmdet/models/dense_heads/solo_head.py
new file mode 100644
index 00000000..8cf33845
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/solo_head.py
@@ -0,0 +1,1263 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Tuple
+
+import mmcv
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.models.utils.misc import floordiv
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, InstanceList, MultiConfig, OptConfigType
+from ..layers import mask_matrix_nms
+from ..utils import center_of_mass, generate_coordinate, multi_apply
+from .base_mask_head import BaseMaskHead
+
+
+@MODELS.register_module()
+class SOLOHead(BaseMaskHead):
+    """SOLO mask head used in `SOLO: Segmenting Objects by Locations.
+
+    `_
+
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (int): Number of channels in the input feature map.
+        feat_channels (int): Number of hidden channels. Used in child classes.
+            Defaults to 256.
+        stacked_convs (int): Number of stacking convs of the head.
+            Defaults to 4.
+        strides (tuple): Downsample factor of each feature map.
+        scale_ranges (tuple[tuple[int, int]]): Area range of multiple
+            level masks, in the format [(min1, max1), (min2, max2), ...].
+            A range of (16, 64) means the area range between (16, 64).
+        pos_scale (float): Constant scale factor to control the center region.
+        num_grids (list[int]): Divided image into a uniform grids, each
+            feature map has a different grid value. The number of output
+            channels is grid ** 2. Defaults to [40, 36, 24, 16, 12].
+        cls_down_index (int): The index of downsample operation in
+            classification branch. Defaults to 0.
+        loss_mask (dict): Config of mask loss.
+        loss_cls (dict): Config of classification loss.
+        norm_cfg (dict): Dictionary to construct and config norm layer.
+            Defaults to norm_cfg=dict(type='GN', num_groups=32,
+            requires_grad=True).
+        train_cfg (dict): Training config of head.
+        test_cfg (dict): Testing config of head.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+    """
+
+    def __init__(
+        self,
+        num_classes: int,
+        in_channels: int,
+        feat_channels: int = 256,
+        stacked_convs: int = 4,
+        strides: tuple = (4, 8, 16, 32, 64),
+        scale_ranges: tuple = ((8, 32), (16, 64), (32, 128), (64, 256), (128,
+                                                                         512)),
+        pos_scale: float = 0.2,
+        num_grids: list = [40, 36, 24, 16, 12],
+        cls_down_index: int = 0,
+        loss_mask: ConfigType = dict(
+            type='DiceLoss', use_sigmoid=True, loss_weight=3.0),
+        loss_cls: ConfigType = dict(
+            type='FocalLoss',
+            use_sigmoid=True,
+            gamma=2.0,
+            alpha=0.25,
+            loss_weight=1.0),
+        norm_cfg: ConfigType = dict(
+            type='GN', num_groups=32, requires_grad=True),
+        train_cfg: OptConfigType = None,
+        test_cfg: OptConfigType = None,
+        init_cfg: MultiConfig = [
+            dict(type='Normal', layer='Conv2d', std=0.01),
+            dict(
+                type='Normal',
+                std=0.01,
+                bias_prob=0.01,
+                override=dict(name='conv_mask_list')),
+            dict(
+                type='Normal',
+                std=0.01,
+                bias_prob=0.01,
+                override=dict(name='conv_cls'))
+        ]
+    ) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.num_classes = num_classes
+        self.cls_out_channels = self.num_classes
+        self.in_channels = in_channels
+        self.feat_channels = feat_channels
+        self.stacked_convs = stacked_convs
+        self.strides = strides
+        self.num_grids = num_grids
+        # number of FPN feats
+        self.num_levels = len(strides)
+        assert self.num_levels == len(scale_ranges) == len(num_grids)
+        self.scale_ranges = scale_ranges
+        self.pos_scale = pos_scale
+
+        self.cls_down_index = cls_down_index
+        self.loss_cls = MODELS.build(loss_cls)
+        self.loss_mask = MODELS.build(loss_mask)
+        self.norm_cfg = norm_cfg
+        self.init_cfg = init_cfg
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+        self._init_layers()
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        self.mask_convs = nn.ModuleList()
+        self.cls_convs = nn.ModuleList()
+        for i in range(self.stacked_convs):
+            chn = self.in_channels + 2 if i == 0 else self.feat_channels
+            self.mask_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    norm_cfg=self.norm_cfg))
+            chn = self.in_channels if i == 0 else self.feat_channels
+            self.cls_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    norm_cfg=self.norm_cfg))
+        self.conv_mask_list = nn.ModuleList()
+        for num_grid in self.num_grids:
+            self.conv_mask_list.append(
+                nn.Conv2d(self.feat_channels, num_grid**2, 1))
+
+        self.conv_cls = nn.Conv2d(
+            self.feat_channels, self.cls_out_channels, 3, padding=1)
+
+    def resize_feats(self, x: Tuple[Tensor]) -> List[Tensor]:
+        """Downsample the first feat and upsample last feat in feats.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            list[Tensor]: Features after resizing, each is a 4D-tensor.
+        """
+        out = []
+        for i in range(len(x)):
+            if i == 0:
+                out.append(
+                    F.interpolate(x[0], scale_factor=0.5, mode='bilinear'))
+            elif i == len(x) - 1:
+                out.append(
+                    F.interpolate(
+                        x[i], size=x[i - 1].shape[-2:], mode='bilinear'))
+            else:
+                out.append(x[i])
+        return out
+
+    def forward(self, x: Tuple[Tensor]) -> tuple:
+        """Forward features from the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple: A tuple of classification scores and mask prediction.
+
+                - mlvl_mask_preds (list[Tensor]): Multi-level mask prediction.
+                  Each element in the list has shape
+                  (batch_size, num_grids**2 ,h ,w).
+                - mlvl_cls_preds (list[Tensor]): Multi-level scores.
+                  Each element in the list has shape
+                  (batch_size, num_classes, num_grids ,num_grids).
+        """
+        assert len(x) == self.num_levels
+        feats = self.resize_feats(x)
+        mlvl_mask_preds = []
+        mlvl_cls_preds = []
+        for i in range(self.num_levels):
+            x = feats[i]
+            mask_feat = x
+            cls_feat = x
+            # generate and concat the coordinate
+            coord_feat = generate_coordinate(mask_feat.size(),
+                                             mask_feat.device)
+            mask_feat = torch.cat([mask_feat, coord_feat], 1)
+
+            for mask_layer in (self.mask_convs):
+                mask_feat = mask_layer(mask_feat)
+
+            mask_feat = F.interpolate(
+                mask_feat, scale_factor=2, mode='bilinear')
+            mask_preds = self.conv_mask_list[i](mask_feat)
+
+            # cls branch
+            for j, cls_layer in enumerate(self.cls_convs):
+                if j == self.cls_down_index:
+                    num_grid = self.num_grids[i]
+                    cls_feat = F.interpolate(
+                        cls_feat, size=num_grid, mode='bilinear')
+                cls_feat = cls_layer(cls_feat)
+
+            cls_pred = self.conv_cls(cls_feat)
+
+            if not self.training:
+                feat_wh = feats[0].size()[-2:]
+                upsampled_size = (feat_wh[0] * 2, feat_wh[1] * 2)
+                mask_preds = F.interpolate(
+                    mask_preds.sigmoid(), size=upsampled_size, mode='bilinear')
+                cls_pred = cls_pred.sigmoid()
+                # get local maximum
+                local_max = F.max_pool2d(cls_pred, 2, stride=1, padding=1)
+                keep_mask = local_max[:, :, :-1, :-1] == cls_pred
+                cls_pred = cls_pred * keep_mask
+
+            mlvl_mask_preds.append(mask_preds)
+            mlvl_cls_preds.append(cls_pred)
+        return mlvl_mask_preds, mlvl_cls_preds
+
+    def loss_by_feat(self, mlvl_mask_preds: List[Tensor],
+                     mlvl_cls_preds: List[Tensor],
+                     batch_gt_instances: InstanceList,
+                     batch_img_metas: List[dict], **kwargs) -> dict:
+        """Calculate the loss based on the features extracted by the mask head.
+
+        Args:
+            mlvl_mask_preds (list[Tensor]): Multi-level mask prediction.
+                Each element in the list has shape
+                (batch_size, num_grids**2 ,h ,w).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes``, ``masks``,
+                and ``labels`` attributes.
+            batch_img_metas (list[dict]): Meta information of multiple images.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        num_levels = self.num_levels
+        num_imgs = len(batch_img_metas)
+
+        featmap_sizes = [featmap.size()[-2:] for featmap in mlvl_mask_preds]
+
+        # `BoolTensor` in `pos_masks` represent
+        # whether the corresponding point is
+        # positive
+        pos_mask_targets, labels, pos_masks = multi_apply(
+            self._get_targets_single,
+            batch_gt_instances,
+            featmap_sizes=featmap_sizes)
+
+        # change from the outside list meaning multi images
+        # to the outside list meaning multi levels
+        mlvl_pos_mask_targets = [[] for _ in range(num_levels)]
+        mlvl_pos_mask_preds = [[] for _ in range(num_levels)]
+        mlvl_pos_masks = [[] for _ in range(num_levels)]
+        mlvl_labels = [[] for _ in range(num_levels)]
+        for img_id in range(num_imgs):
+            assert num_levels == len(pos_mask_targets[img_id])
+            for lvl in range(num_levels):
+                mlvl_pos_mask_targets[lvl].append(
+                    pos_mask_targets[img_id][lvl])
+                mlvl_pos_mask_preds[lvl].append(
+                    mlvl_mask_preds[lvl][img_id, pos_masks[img_id][lvl], ...])
+                mlvl_pos_masks[lvl].append(pos_masks[img_id][lvl].flatten())
+                mlvl_labels[lvl].append(labels[img_id][lvl].flatten())
+
+        # cat multiple image
+        temp_mlvl_cls_preds = []
+        for lvl in range(num_levels):
+            mlvl_pos_mask_targets[lvl] = torch.cat(
+                mlvl_pos_mask_targets[lvl], dim=0)
+            mlvl_pos_mask_preds[lvl] = torch.cat(
+                mlvl_pos_mask_preds[lvl], dim=0)
+            mlvl_pos_masks[lvl] = torch.cat(mlvl_pos_masks[lvl], dim=0)
+            mlvl_labels[lvl] = torch.cat(mlvl_labels[lvl], dim=0)
+            temp_mlvl_cls_preds.append(mlvl_cls_preds[lvl].permute(
+                0, 2, 3, 1).reshape(-1, self.cls_out_channels))
+
+        num_pos = sum(item.sum() for item in mlvl_pos_masks)
+        # dice loss
+        loss_mask = []
+        for pred, target in zip(mlvl_pos_mask_preds, mlvl_pos_mask_targets):
+            if pred.size()[0] == 0:
+                loss_mask.append(pred.sum().unsqueeze(0))
+                continue
+            loss_mask.append(
+                self.loss_mask(pred, target, reduction_override='none'))
+        if num_pos > 0:
+            loss_mask = torch.cat(loss_mask).sum() / num_pos
+        else:
+            loss_mask = torch.cat(loss_mask).mean()
+
+        flatten_labels = torch.cat(mlvl_labels)
+        flatten_cls_preds = torch.cat(temp_mlvl_cls_preds)
+        loss_cls = self.loss_cls(
+            flatten_cls_preds, flatten_labels, avg_factor=num_pos + 1)
+        return dict(loss_mask=loss_mask, loss_cls=loss_cls)
+
+    def _get_targets_single(self,
+                            gt_instances: InstanceData,
+                            featmap_sizes: Optional[list] = None) -> tuple:
+        """Compute targets for predictions of single image.
+
+        Args:
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It should includes ``bboxes``, ``labels``,
+                and ``masks`` attributes.
+            featmap_sizes (list[:obj:`torch.size`]): Size of each
+                feature map from feature pyramid, each element
+                means (feat_h, feat_w). Defaults to None.
+
+        Returns:
+            Tuple: Usually returns a tuple containing targets for predictions.
+
+                - mlvl_pos_mask_targets (list[Tensor]): Each element represent
+                  the binary mask targets for positive points in this
+                  level, has shape (num_pos, out_h, out_w).
+                - mlvl_labels (list[Tensor]): Each element is
+                  classification labels for all
+                  points in this level, has shape
+                  (num_grid, num_grid).
+                - mlvl_pos_masks (list[Tensor]): Each element is
+                  a `BoolTensor` to represent whether the
+                  corresponding point in single level
+                  is positive, has shape (num_grid **2).
+        """
+        gt_labels = gt_instances.labels
+        device = gt_labels.device
+
+        gt_bboxes = gt_instances.bboxes
+        gt_areas = torch.sqrt((gt_bboxes[:, 2] - gt_bboxes[:, 0]) *
+                              (gt_bboxes[:, 3] - gt_bboxes[:, 1]))
+
+        gt_masks = gt_instances.masks.to_tensor(
+            dtype=torch.bool, device=device)
+
+        mlvl_pos_mask_targets = []
+        mlvl_labels = []
+        mlvl_pos_masks = []
+        for (lower_bound, upper_bound), stride, featmap_size, num_grid \
+                in zip(self.scale_ranges, self.strides,
+                       featmap_sizes, self.num_grids):
+
+            mask_target = torch.zeros(
+                [num_grid**2, featmap_size[0], featmap_size[1]],
+                dtype=torch.uint8,
+                device=device)
+            # FG cat_id: [0, num_classes -1], BG cat_id: num_classes
+            labels = torch.zeros([num_grid, num_grid],
+                                 dtype=torch.int64,
+                                 device=device) + self.num_classes
+            pos_mask = torch.zeros([num_grid**2],
+                                   dtype=torch.bool,
+                                   device=device)
+
+            gt_inds = ((gt_areas >= lower_bound) &
+                       (gt_areas <= upper_bound)).nonzero().flatten()
+            if len(gt_inds) == 0:
+                mlvl_pos_mask_targets.append(
+                    mask_target.new_zeros(0, featmap_size[0], featmap_size[1]))
+                mlvl_labels.append(labels)
+                mlvl_pos_masks.append(pos_mask)
+                continue
+            hit_gt_bboxes = gt_bboxes[gt_inds]
+            hit_gt_labels = gt_labels[gt_inds]
+            hit_gt_masks = gt_masks[gt_inds, ...]
+
+            pos_w_ranges = 0.5 * (hit_gt_bboxes[:, 2] -
+                                  hit_gt_bboxes[:, 0]) * self.pos_scale
+            pos_h_ranges = 0.5 * (hit_gt_bboxes[:, 3] -
+                                  hit_gt_bboxes[:, 1]) * self.pos_scale
+
+            # Make sure hit_gt_masks has a value
+            valid_mask_flags = hit_gt_masks.sum(dim=-1).sum(dim=-1) > 0
+            output_stride = stride / 2
+
+            for gt_mask, gt_label, pos_h_range, pos_w_range, \
+                valid_mask_flag in \
+                    zip(hit_gt_masks, hit_gt_labels, pos_h_ranges,
+                        pos_w_ranges, valid_mask_flags):
+                if not valid_mask_flag:
+                    continue
+                upsampled_size = (featmap_sizes[0][0] * 4,
+                                  featmap_sizes[0][1] * 4)
+                center_h, center_w = center_of_mass(gt_mask)
+
+                coord_w = int(
+                    floordiv((center_w / upsampled_size[1]), (1. / num_grid),
+                             rounding_mode='trunc'))
+                coord_h = int(
+                    floordiv((center_h / upsampled_size[0]), (1. / num_grid),
+                             rounding_mode='trunc'))
+
+                # left, top, right, down
+                top_box = max(
+                    0,
+                    int(
+                        floordiv(
+                            (center_h - pos_h_range) / upsampled_size[0],
+                            (1. / num_grid),
+                            rounding_mode='trunc')))
+                down_box = min(
+                    num_grid - 1,
+                    int(
+                        floordiv(
+                            (center_h + pos_h_range) / upsampled_size[0],
+                            (1. / num_grid),
+                            rounding_mode='trunc')))
+                left_box = max(
+                    0,
+                    int(
+                        floordiv(
+                            (center_w - pos_w_range) / upsampled_size[1],
+                            (1. / num_grid),
+                            rounding_mode='trunc')))
+                right_box = min(
+                    num_grid - 1,
+                    int(
+                        floordiv(
+                            (center_w + pos_w_range) / upsampled_size[1],
+                            (1. / num_grid),
+                            rounding_mode='trunc')))
+
+                top = max(top_box, coord_h - 1)
+                down = min(down_box, coord_h + 1)
+                left = max(coord_w - 1, left_box)
+                right = min(right_box, coord_w + 1)
+
+                labels[top:(down + 1), left:(right + 1)] = gt_label
+                # ins
+                gt_mask = np.uint8(gt_mask.cpu().numpy())
+                # Follow the original implementation, F.interpolate is
+                # different from cv2 and opencv
+                gt_mask = mmcv.imrescale(gt_mask, scale=1. / output_stride)
+                gt_mask = torch.from_numpy(gt_mask).to(device=device)
+
+                for i in range(top, down + 1):
+                    for j in range(left, right + 1):
+                        index = int(i * num_grid + j)
+                        mask_target[index, :gt_mask.shape[0], :gt_mask.
+                                    shape[1]] = gt_mask
+                        pos_mask[index] = True
+            mlvl_pos_mask_targets.append(mask_target[pos_mask])
+            mlvl_labels.append(labels)
+            mlvl_pos_masks.append(pos_mask)
+        return mlvl_pos_mask_targets, mlvl_labels, mlvl_pos_masks
+
+    def predict_by_feat(self, mlvl_mask_preds: List[Tensor],
+                        mlvl_cls_scores: List[Tensor],
+                        batch_img_metas: List[dict], **kwargs) -> InstanceList:
+        """Transform a batch of output features extracted from the head into
+        mask results.
+
+        Args:
+            mlvl_mask_preds (list[Tensor]): Multi-level mask prediction.
+                Each element in the list has shape
+                (batch_size, num_grids**2 ,h ,w).
+            mlvl_cls_scores (list[Tensor]): Multi-level scores. Each element
+                in the list has shape
+                (batch_size, num_classes, num_grids ,num_grids).
+            batch_img_metas (list[dict]): Meta information of all images.
+
+        Returns:
+            list[:obj:`InstanceData`]: Processed results of multiple
+            images.Each :obj:`InstanceData` usually contains
+            following keys.
+
+                - scores (Tensor): Classification scores, has shape
+                  (num_instance,).
+                - labels (Tensor): Has shape (num_instances,).
+                - masks (Tensor): Processed mask results, has
+                  shape (num_instances, h, w).
+        """
+        mlvl_cls_scores = [
+            item.permute(0, 2, 3, 1) for item in mlvl_cls_scores
+        ]
+        assert len(mlvl_mask_preds) == len(mlvl_cls_scores)
+        num_levels = len(mlvl_cls_scores)
+
+        results_list = []
+        for img_id in range(len(batch_img_metas)):
+            cls_pred_list = [
+                mlvl_cls_scores[lvl][img_id].view(-1, self.cls_out_channels)
+                for lvl in range(num_levels)
+            ]
+            mask_pred_list = [
+                mlvl_mask_preds[lvl][img_id] for lvl in range(num_levels)
+            ]
+
+            cls_pred_list = torch.cat(cls_pred_list, dim=0)
+            mask_pred_list = torch.cat(mask_pred_list, dim=0)
+            img_meta = batch_img_metas[img_id]
+
+            results = self._predict_by_feat_single(
+                cls_pred_list, mask_pred_list, img_meta=img_meta)
+            results_list.append(results)
+
+        return results_list
+
+    def _predict_by_feat_single(self,
+                                cls_scores: Tensor,
+                                mask_preds: Tensor,
+                                img_meta: dict,
+                                cfg: OptConfigType = None) -> InstanceData:
+        """Transform a single image's features extracted from the head into
+        mask results.
+
+        Args:
+            cls_scores (Tensor): Classification score of all points
+                in single image, has shape (num_points, num_classes).
+            mask_preds (Tensor): Mask prediction of all points in
+                single image, has shape (num_points, feat_h, feat_w).
+            img_meta (dict): Meta information of corresponding image.
+            cfg (dict, optional): Config used in test phase.
+                Defaults to None.
+
+        Returns:
+            :obj:`InstanceData`: Processed results of single image.
+             it usually contains following keys.
+
+                - scores (Tensor): Classification scores, has shape
+                  (num_instance,).
+                - labels (Tensor): Has shape (num_instances,).
+                - masks (Tensor): Processed mask results, has
+                  shape (num_instances, h, w).
+        """
+
+        def empty_results(cls_scores, ori_shape):
+            """Generate a empty results."""
+            results = InstanceData()
+            results.scores = cls_scores.new_ones(0)
+            results.masks = cls_scores.new_zeros(0, *ori_shape)
+            results.labels = cls_scores.new_ones(0)
+            results.bboxes = cls_scores.new_zeros(0, 4)
+            return results
+
+        cfg = self.test_cfg if cfg is None else cfg
+        assert len(cls_scores) == len(mask_preds)
+
+        featmap_size = mask_preds.size()[-2:]
+
+        h, w = img_meta['img_shape'][:2]
+        upsampled_size = (featmap_size[0] * 4, featmap_size[1] * 4)
+
+        score_mask = (cls_scores > cfg.score_thr)
+        cls_scores = cls_scores[score_mask]
+        if len(cls_scores) == 0:
+            return empty_results(cls_scores, img_meta['ori_shape'][:2])
+
+        inds = score_mask.nonzero()
+        cls_labels = inds[:, 1]
+
+        # Filter the mask mask with an area is smaller than
+        # stride of corresponding feature level
+        lvl_interval = cls_labels.new_tensor(self.num_grids).pow(2).cumsum(0)
+        strides = cls_scores.new_ones(lvl_interval[-1])
+        strides[:lvl_interval[0]] *= self.strides[0]
+        for lvl in range(1, self.num_levels):
+            strides[lvl_interval[lvl -
+                                 1]:lvl_interval[lvl]] *= self.strides[lvl]
+        strides = strides[inds[:, 0]]
+        mask_preds = mask_preds[inds[:, 0]]
+
+        masks = mask_preds > cfg.mask_thr
+        sum_masks = masks.sum((1, 2)).float()
+        keep = sum_masks > strides
+        if keep.sum() == 0:
+            return empty_results(cls_scores, img_meta['ori_shape'][:2])
+        masks = masks[keep]
+        mask_preds = mask_preds[keep]
+        sum_masks = sum_masks[keep]
+        cls_scores = cls_scores[keep]
+        cls_labels = cls_labels[keep]
+
+        # maskness.
+        mask_scores = (mask_preds * masks).sum((1, 2)) / sum_masks
+        cls_scores *= mask_scores
+
+        scores, labels, _, keep_inds = mask_matrix_nms(
+            masks,
+            cls_labels,
+            cls_scores,
+            mask_area=sum_masks,
+            nms_pre=cfg.nms_pre,
+            max_num=cfg.max_per_img,
+            kernel=cfg.kernel,
+            sigma=cfg.sigma,
+            filter_thr=cfg.filter_thr)
+        # mask_matrix_nms may return an empty Tensor
+        if len(keep_inds) == 0:
+            return empty_results(cls_scores, img_meta['ori_shape'][:2])
+        mask_preds = mask_preds[keep_inds]
+        mask_preds = F.interpolate(
+            mask_preds.unsqueeze(0), size=upsampled_size,
+            mode='bilinear')[:, :, :h, :w]
+        mask_preds = F.interpolate(
+            mask_preds, size=img_meta['ori_shape'][:2],
+            mode='bilinear').squeeze(0)
+        masks = mask_preds > cfg.mask_thr
+
+        results = InstanceData()
+        results.masks = masks
+        results.labels = labels
+        results.scores = scores
+        # create an empty bbox in InstanceData to avoid bugs when
+        # calculating metrics.
+        results.bboxes = results.scores.new_zeros(len(scores), 4)
+        return results
+
+
+@MODELS.register_module()
+class DecoupledSOLOHead(SOLOHead):
+    """Decoupled SOLO mask head used in `SOLO: Segmenting Objects by Locations.
+
+    `_
+
+    Args:
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+    """
+
+    def __init__(self,
+                 *args,
+                 init_cfg: MultiConfig = [
+                     dict(type='Normal', layer='Conv2d', std=0.01),
+                     dict(
+                         type='Normal',
+                         std=0.01,
+                         bias_prob=0.01,
+                         override=dict(name='conv_mask_list_x')),
+                     dict(
+                         type='Normal',
+                         std=0.01,
+                         bias_prob=0.01,
+                         override=dict(name='conv_mask_list_y')),
+                     dict(
+                         type='Normal',
+                         std=0.01,
+                         bias_prob=0.01,
+                         override=dict(name='conv_cls'))
+                 ],
+                 **kwargs) -> None:
+        super().__init__(*args, init_cfg=init_cfg, **kwargs)
+
+    def _init_layers(self) -> None:
+        self.mask_convs_x = nn.ModuleList()
+        self.mask_convs_y = nn.ModuleList()
+        self.cls_convs = nn.ModuleList()
+
+        for i in range(self.stacked_convs):
+            chn = self.in_channels + 1 if i == 0 else self.feat_channels
+            self.mask_convs_x.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    norm_cfg=self.norm_cfg))
+            self.mask_convs_y.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    norm_cfg=self.norm_cfg))
+
+            chn = self.in_channels if i == 0 else self.feat_channels
+            self.cls_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    norm_cfg=self.norm_cfg))
+
+        self.conv_mask_list_x = nn.ModuleList()
+        self.conv_mask_list_y = nn.ModuleList()
+        for num_grid in self.num_grids:
+            self.conv_mask_list_x.append(
+                nn.Conv2d(self.feat_channels, num_grid, 3, padding=1))
+            self.conv_mask_list_y.append(
+                nn.Conv2d(self.feat_channels, num_grid, 3, padding=1))
+        self.conv_cls = nn.Conv2d(
+            self.feat_channels, self.cls_out_channels, 3, padding=1)
+
+    def forward(self, x: Tuple[Tensor]) -> Tuple:
+        """Forward features from the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple: A tuple of classification scores and mask prediction.
+
+                - mlvl_mask_preds_x (list[Tensor]): Multi-level mask prediction
+                  from x branch. Each element in the list has shape
+                  (batch_size, num_grids ,h ,w).
+                - mlvl_mask_preds_y (list[Tensor]): Multi-level mask prediction
+                  from y branch. Each element in the list has shape
+                  (batch_size, num_grids ,h ,w).
+                - mlvl_cls_preds (list[Tensor]): Multi-level scores.
+                  Each element in the list has shape
+                  (batch_size, num_classes, num_grids ,num_grids).
+        """
+        assert len(x) == self.num_levels
+        feats = self.resize_feats(x)
+        mask_preds_x = []
+        mask_preds_y = []
+        cls_preds = []
+        for i in range(self.num_levels):
+            x = feats[i]
+            mask_feat = x
+            cls_feat = x
+            # generate and concat the coordinate
+            coord_feat = generate_coordinate(mask_feat.size(),
+                                             mask_feat.device)
+            mask_feat_x = torch.cat([mask_feat, coord_feat[:, 0:1, ...]], 1)
+            mask_feat_y = torch.cat([mask_feat, coord_feat[:, 1:2, ...]], 1)
+
+            for mask_layer_x, mask_layer_y in \
+                    zip(self.mask_convs_x, self.mask_convs_y):
+                mask_feat_x = mask_layer_x(mask_feat_x)
+                mask_feat_y = mask_layer_y(mask_feat_y)
+
+            mask_feat_x = F.interpolate(
+                mask_feat_x, scale_factor=2, mode='bilinear')
+            mask_feat_y = F.interpolate(
+                mask_feat_y, scale_factor=2, mode='bilinear')
+
+            mask_pred_x = self.conv_mask_list_x[i](mask_feat_x)
+            mask_pred_y = self.conv_mask_list_y[i](mask_feat_y)
+
+            # cls branch
+            for j, cls_layer in enumerate(self.cls_convs):
+                if j == self.cls_down_index:
+                    num_grid = self.num_grids[i]
+                    cls_feat = F.interpolate(
+                        cls_feat, size=num_grid, mode='bilinear')
+                cls_feat = cls_layer(cls_feat)
+
+            cls_pred = self.conv_cls(cls_feat)
+
+            if not self.training:
+                feat_wh = feats[0].size()[-2:]
+                upsampled_size = (feat_wh[0] * 2, feat_wh[1] * 2)
+                mask_pred_x = F.interpolate(
+                    mask_pred_x.sigmoid(),
+                    size=upsampled_size,
+                    mode='bilinear')
+                mask_pred_y = F.interpolate(
+                    mask_pred_y.sigmoid(),
+                    size=upsampled_size,
+                    mode='bilinear')
+                cls_pred = cls_pred.sigmoid()
+                # get local maximum
+                local_max = F.max_pool2d(cls_pred, 2, stride=1, padding=1)
+                keep_mask = local_max[:, :, :-1, :-1] == cls_pred
+                cls_pred = cls_pred * keep_mask
+
+            mask_preds_x.append(mask_pred_x)
+            mask_preds_y.append(mask_pred_y)
+            cls_preds.append(cls_pred)
+        return mask_preds_x, mask_preds_y, cls_preds
+
+    def loss_by_feat(self, mlvl_mask_preds_x: List[Tensor],
+                     mlvl_mask_preds_y: List[Tensor],
+                     mlvl_cls_preds: List[Tensor],
+                     batch_gt_instances: InstanceList,
+                     batch_img_metas: List[dict], **kwargs) -> dict:
+        """Calculate the loss based on the features extracted by the mask head.
+
+        Args:
+            mlvl_mask_preds_x (list[Tensor]): Multi-level mask prediction
+                from x branch. Each element in the list has shape
+                (batch_size, num_grids ,h ,w).
+            mlvl_mask_preds_y (list[Tensor]): Multi-level mask prediction
+                from y branch. Each element in the list has shape
+                (batch_size, num_grids ,h ,w).
+            mlvl_cls_preds (list[Tensor]): Multi-level scores. Each element
+                in the list has shape
+                (batch_size, num_classes, num_grids ,num_grids).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes``, ``masks``,
+                and ``labels`` attributes.
+            batch_img_metas (list[dict]): Meta information of multiple images.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        num_levels = self.num_levels
+        num_imgs = len(batch_img_metas)
+        featmap_sizes = [featmap.size()[-2:] for featmap in mlvl_mask_preds_x]
+
+        pos_mask_targets, labels, xy_pos_indexes = multi_apply(
+            self._get_targets_single,
+            batch_gt_instances,
+            featmap_sizes=featmap_sizes)
+
+        # change from the outside list meaning multi images
+        # to the outside list meaning multi levels
+        mlvl_pos_mask_targets = [[] for _ in range(num_levels)]
+        mlvl_pos_mask_preds_x = [[] for _ in range(num_levels)]
+        mlvl_pos_mask_preds_y = [[] for _ in range(num_levels)]
+        mlvl_labels = [[] for _ in range(num_levels)]
+        for img_id in range(num_imgs):
+
+            for lvl in range(num_levels):
+                mlvl_pos_mask_targets[lvl].append(
+                    pos_mask_targets[img_id][lvl])
+                mlvl_pos_mask_preds_x[lvl].append(
+                    mlvl_mask_preds_x[lvl][img_id,
+                                           xy_pos_indexes[img_id][lvl][:, 1]])
+                mlvl_pos_mask_preds_y[lvl].append(
+                    mlvl_mask_preds_y[lvl][img_id,
+                                           xy_pos_indexes[img_id][lvl][:, 0]])
+                mlvl_labels[lvl].append(labels[img_id][lvl].flatten())
+
+        # cat multiple image
+        temp_mlvl_cls_preds = []
+        for lvl in range(num_levels):
+            mlvl_pos_mask_targets[lvl] = torch.cat(
+                mlvl_pos_mask_targets[lvl], dim=0)
+            mlvl_pos_mask_preds_x[lvl] = torch.cat(
+                mlvl_pos_mask_preds_x[lvl], dim=0)
+            mlvl_pos_mask_preds_y[lvl] = torch.cat(
+                mlvl_pos_mask_preds_y[lvl], dim=0)
+            mlvl_labels[lvl] = torch.cat(mlvl_labels[lvl], dim=0)
+            temp_mlvl_cls_preds.append(mlvl_cls_preds[lvl].permute(
+                0, 2, 3, 1).reshape(-1, self.cls_out_channels))
+
+        num_pos = 0.
+        # dice loss
+        loss_mask = []
+        for pred_x, pred_y, target in \
+                zip(mlvl_pos_mask_preds_x,
+                    mlvl_pos_mask_preds_y, mlvl_pos_mask_targets):
+            num_masks = pred_x.size(0)
+            if num_masks == 0:
+                # make sure can get grad
+                loss_mask.append((pred_x.sum() + pred_y.sum()).unsqueeze(0))
+                continue
+            num_pos += num_masks
+            pred_mask = pred_y.sigmoid() * pred_x.sigmoid()
+            loss_mask.append(
+                self.loss_mask(pred_mask, target, reduction_override='none'))
+        if num_pos > 0:
+            loss_mask = torch.cat(loss_mask).sum() / num_pos
+        else:
+            loss_mask = torch.cat(loss_mask).mean()
+
+        # cate
+        flatten_labels = torch.cat(mlvl_labels)
+        flatten_cls_preds = torch.cat(temp_mlvl_cls_preds)
+
+        loss_cls = self.loss_cls(
+            flatten_cls_preds, flatten_labels, avg_factor=num_pos + 1)
+        return dict(loss_mask=loss_mask, loss_cls=loss_cls)
+
+    def _get_targets_single(self,
+                            gt_instances: InstanceData,
+                            featmap_sizes: Optional[list] = None) -> tuple:
+        """Compute targets for predictions of single image.
+
+        Args:
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It should includes ``bboxes``, ``labels``,
+                and ``masks`` attributes.
+            featmap_sizes (list[:obj:`torch.size`]): Size of each
+                feature map from feature pyramid, each element
+                means (feat_h, feat_w). Defaults to None.
+
+        Returns:
+            Tuple: Usually returns a tuple containing targets for predictions.
+
+                - mlvl_pos_mask_targets (list[Tensor]): Each element represent
+                  the binary mask targets for positive points in this
+                  level, has shape (num_pos, out_h, out_w).
+                - mlvl_labels (list[Tensor]): Each element is
+                  classification labels for all
+                  points in this level, has shape
+                  (num_grid, num_grid).
+                - mlvl_xy_pos_indexes (list[Tensor]): Each element
+                  in the list contains the index of positive samples in
+                  corresponding level, has shape (num_pos, 2), last
+                  dimension 2 present (index_x, index_y).
+        """
+        mlvl_pos_mask_targets, mlvl_labels, mlvl_pos_masks = \
+            super()._get_targets_single(gt_instances,
+                                        featmap_sizes=featmap_sizes)
+
+        mlvl_xy_pos_indexes = [(item - self.num_classes).nonzero()
+                               for item in mlvl_labels]
+
+        return mlvl_pos_mask_targets, mlvl_labels, mlvl_xy_pos_indexes
+
+    def predict_by_feat(self, mlvl_mask_preds_x: List[Tensor],
+                        mlvl_mask_preds_y: List[Tensor],
+                        mlvl_cls_scores: List[Tensor],
+                        batch_img_metas: List[dict], **kwargs) -> InstanceList:
+        """Transform a batch of output features extracted from the head into
+        mask results.
+
+        Args:
+            mlvl_mask_preds_x (list[Tensor]): Multi-level mask prediction
+                from x branch. Each element in the list has shape
+                (batch_size, num_grids ,h ,w).
+            mlvl_mask_preds_y (list[Tensor]): Multi-level mask prediction
+                from y branch. Each element in the list has shape
+                (batch_size, num_grids ,h ,w).
+            mlvl_cls_scores (list[Tensor]): Multi-level scores. Each element
+                in the list has shape
+                (batch_size, num_classes ,num_grids ,num_grids).
+            batch_img_metas (list[dict]): Meta information of all images.
+
+        Returns:
+            list[:obj:`InstanceData`]: Processed results of multiple
+            images.Each :obj:`InstanceData` usually contains
+            following keys.
+
+                - scores (Tensor): Classification scores, has shape
+                  (num_instance,).
+                - labels (Tensor): Has shape (num_instances,).
+                - masks (Tensor): Processed mask results, has
+                  shape (num_instances, h, w).
+        """
+        mlvl_cls_scores = [
+            item.permute(0, 2, 3, 1) for item in mlvl_cls_scores
+        ]
+        assert len(mlvl_mask_preds_x) == len(mlvl_cls_scores)
+        num_levels = len(mlvl_cls_scores)
+
+        results_list = []
+        for img_id in range(len(batch_img_metas)):
+            cls_pred_list = [
+                mlvl_cls_scores[i][img_id].view(
+                    -1, self.cls_out_channels).detach()
+                for i in range(num_levels)
+            ]
+            mask_pred_list_x = [
+                mlvl_mask_preds_x[i][img_id] for i in range(num_levels)
+            ]
+            mask_pred_list_y = [
+                mlvl_mask_preds_y[i][img_id] for i in range(num_levels)
+            ]
+
+            cls_pred_list = torch.cat(cls_pred_list, dim=0)
+            mask_pred_list_x = torch.cat(mask_pred_list_x, dim=0)
+            mask_pred_list_y = torch.cat(mask_pred_list_y, dim=0)
+            img_meta = batch_img_metas[img_id]
+
+            results = self._predict_by_feat_single(
+                cls_pred_list,
+                mask_pred_list_x,
+                mask_pred_list_y,
+                img_meta=img_meta)
+            results_list.append(results)
+        return results_list
+
+    def _predict_by_feat_single(self,
+                                cls_scores: Tensor,
+                                mask_preds_x: Tensor,
+                                mask_preds_y: Tensor,
+                                img_meta: dict,
+                                cfg: OptConfigType = None) -> InstanceData:
+        """Transform a single image's features extracted from the head into
+        mask results.
+
+        Args:
+            cls_scores (Tensor): Classification score of all points
+                in single image, has shape (num_points, num_classes).
+            mask_preds_x (Tensor): Mask prediction of x branch of
+                all points in single image, has shape
+                (sum_num_grids, feat_h, feat_w).
+            mask_preds_y (Tensor): Mask prediction of y branch of
+                all points in single image, has shape
+                (sum_num_grids, feat_h, feat_w).
+            img_meta (dict): Meta information of corresponding image.
+            cfg (dict): Config used in test phase.
+
+        Returns:
+            :obj:`InstanceData`: Processed results of single image.
+             it usually contains following keys.
+
+                - scores (Tensor): Classification scores, has shape
+                  (num_instance,).
+                - labels (Tensor): Has shape (num_instances,).
+                - masks (Tensor): Processed mask results, has
+                  shape (num_instances, h, w).
+        """
+
+        def empty_results(cls_scores, ori_shape):
+            """Generate a empty results."""
+            results = InstanceData()
+            results.scores = cls_scores.new_ones(0)
+            results.masks = cls_scores.new_zeros(0, *ori_shape)
+            results.labels = cls_scores.new_ones(0)
+            results.bboxes = cls_scores.new_zeros(0, 4)
+            return results
+
+        cfg = self.test_cfg if cfg is None else cfg
+
+        featmap_size = mask_preds_x.size()[-2:]
+
+        h, w = img_meta['img_shape'][:2]
+        upsampled_size = (featmap_size[0] * 4, featmap_size[1] * 4)
+
+        score_mask = (cls_scores > cfg.score_thr)
+        cls_scores = cls_scores[score_mask]
+        inds = score_mask.nonzero()
+        lvl_interval = inds.new_tensor(self.num_grids).pow(2).cumsum(0)
+        num_all_points = lvl_interval[-1]
+        lvl_start_index = inds.new_ones(num_all_points)
+        num_grids = inds.new_ones(num_all_points)
+        seg_size = inds.new_tensor(self.num_grids).cumsum(0)
+        mask_lvl_start_index = inds.new_ones(num_all_points)
+        strides = inds.new_ones(num_all_points)
+
+        lvl_start_index[:lvl_interval[0]] *= 0
+        mask_lvl_start_index[:lvl_interval[0]] *= 0
+        num_grids[:lvl_interval[0]] *= self.num_grids[0]
+        strides[:lvl_interval[0]] *= self.strides[0]
+
+        for lvl in range(1, self.num_levels):
+            lvl_start_index[lvl_interval[lvl - 1]:lvl_interval[lvl]] *= \
+                lvl_interval[lvl - 1]
+            mask_lvl_start_index[lvl_interval[lvl - 1]:lvl_interval[lvl]] *= \
+                seg_size[lvl - 1]
+            num_grids[lvl_interval[lvl - 1]:lvl_interval[lvl]] *= \
+                self.num_grids[lvl]
+            strides[lvl_interval[lvl - 1]:lvl_interval[lvl]] *= \
+                self.strides[lvl]
+
+        lvl_start_index = lvl_start_index[inds[:, 0]]
+        mask_lvl_start_index = mask_lvl_start_index[inds[:, 0]]
+        num_grids = num_grids[inds[:, 0]]
+        strides = strides[inds[:, 0]]
+
+        y_lvl_offset = (inds[:, 0] - lvl_start_index) // num_grids
+        x_lvl_offset = (inds[:, 0] - lvl_start_index) % num_grids
+        y_inds = mask_lvl_start_index + y_lvl_offset
+        x_inds = mask_lvl_start_index + x_lvl_offset
+
+        cls_labels = inds[:, 1]
+        mask_preds = mask_preds_x[x_inds, ...] * mask_preds_y[y_inds, ...]
+
+        masks = mask_preds > cfg.mask_thr
+        sum_masks = masks.sum((1, 2)).float()
+        keep = sum_masks > strides
+        if keep.sum() == 0:
+            return empty_results(cls_scores, img_meta['ori_shape'][:2])
+
+        masks = masks[keep]
+        mask_preds = mask_preds[keep]
+        sum_masks = sum_masks[keep]
+        cls_scores = cls_scores[keep]
+        cls_labels = cls_labels[keep]
+
+        # maskness.
+        mask_scores = (mask_preds * masks).sum((1, 2)) / sum_masks
+        cls_scores *= mask_scores
+
+        scores, labels, _, keep_inds = mask_matrix_nms(
+            masks,
+            cls_labels,
+            cls_scores,
+            mask_area=sum_masks,
+            nms_pre=cfg.nms_pre,
+            max_num=cfg.max_per_img,
+            kernel=cfg.kernel,
+            sigma=cfg.sigma,
+            filter_thr=cfg.filter_thr)
+        # mask_matrix_nms may return an empty Tensor
+        if len(keep_inds) == 0:
+            return empty_results(cls_scores, img_meta['ori_shape'][:2])
+        mask_preds = mask_preds[keep_inds]
+        mask_preds = F.interpolate(
+            mask_preds.unsqueeze(0), size=upsampled_size,
+            mode='bilinear')[:, :, :h, :w]
+        mask_preds = F.interpolate(
+            mask_preds, size=img_meta['ori_shape'][:2],
+            mode='bilinear').squeeze(0)
+        masks = mask_preds > cfg.mask_thr
+
+        results = InstanceData()
+        results.masks = masks
+        results.labels = labels
+        results.scores = scores
+        # create an empty bbox in InstanceData to avoid bugs when
+        # calculating metrics.
+        results.bboxes = results.scores.new_zeros(len(scores), 4)
+
+        return results
+
+
+@MODELS.register_module()
+class DecoupledSOLOLightHead(DecoupledSOLOHead):
+    """Decoupled Light SOLO mask head used in `SOLO: Segmenting Objects by
+    Locations `_
+
+    Args:
+        with_dcn (bool): Whether use dcn in mask_convs and cls_convs,
+            Defaults to False.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+    """
+
+    def __init__(self,
+                 *args,
+                 dcn_cfg: OptConfigType = None,
+                 init_cfg: MultiConfig = [
+                     dict(type='Normal', layer='Conv2d', std=0.01),
+                     dict(
+                         type='Normal',
+                         std=0.01,
+                         bias_prob=0.01,
+                         override=dict(name='conv_mask_list_x')),
+                     dict(
+                         type='Normal',
+                         std=0.01,
+                         bias_prob=0.01,
+                         override=dict(name='conv_mask_list_y')),
+                     dict(
+                         type='Normal',
+                         std=0.01,
+                         bias_prob=0.01,
+                         override=dict(name='conv_cls'))
+                 ],
+                 **kwargs) -> None:
+        assert dcn_cfg is None or isinstance(dcn_cfg, dict)
+        self.dcn_cfg = dcn_cfg
+        super().__init__(*args, init_cfg=init_cfg, **kwargs)
+
+    def _init_layers(self) -> None:
+        self.mask_convs = nn.ModuleList()
+        self.cls_convs = nn.ModuleList()
+
+        for i in range(self.stacked_convs):
+            if self.dcn_cfg is not None \
+                    and i == self.stacked_convs - 1:
+                conv_cfg = self.dcn_cfg
+            else:
+                conv_cfg = None
+
+            chn = self.in_channels + 2 if i == 0 else self.feat_channels
+            self.mask_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=self.norm_cfg))
+
+            chn = self.in_channels if i == 0 else self.feat_channels
+            self.cls_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=self.norm_cfg))
+
+        self.conv_mask_list_x = nn.ModuleList()
+        self.conv_mask_list_y = nn.ModuleList()
+        for num_grid in self.num_grids:
+            self.conv_mask_list_x.append(
+                nn.Conv2d(self.feat_channels, num_grid, 3, padding=1))
+            self.conv_mask_list_y.append(
+                nn.Conv2d(self.feat_channels, num_grid, 3, padding=1))
+        self.conv_cls = nn.Conv2d(
+            self.feat_channels, self.cls_out_channels, 3, padding=1)
+
+    def forward(self, x: Tuple[Tensor]) -> Tuple:
+        """Forward features from the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple: A tuple of classification scores and mask prediction.
+
+                - mlvl_mask_preds_x (list[Tensor]): Multi-level mask prediction
+                  from x branch. Each element in the list has shape
+                  (batch_size, num_grids ,h ,w).
+                - mlvl_mask_preds_y (list[Tensor]): Multi-level mask prediction
+                  from y branch. Each element in the list has shape
+                  (batch_size, num_grids ,h ,w).
+                - mlvl_cls_preds (list[Tensor]): Multi-level scores.
+                  Each element in the list has shape
+                  (batch_size, num_classes, num_grids ,num_grids).
+        """
+        assert len(x) == self.num_levels
+        feats = self.resize_feats(x)
+        mask_preds_x = []
+        mask_preds_y = []
+        cls_preds = []
+        for i in range(self.num_levels):
+            x = feats[i]
+            mask_feat = x
+            cls_feat = x
+            # generate and concat the coordinate
+            coord_feat = generate_coordinate(mask_feat.size(),
+                                             mask_feat.device)
+            mask_feat = torch.cat([mask_feat, coord_feat], 1)
+
+            for mask_layer in self.mask_convs:
+                mask_feat = mask_layer(mask_feat)
+
+            mask_feat = F.interpolate(
+                mask_feat, scale_factor=2, mode='bilinear')
+
+            mask_pred_x = self.conv_mask_list_x[i](mask_feat)
+            mask_pred_y = self.conv_mask_list_y[i](mask_feat)
+
+            # cls branch
+            for j, cls_layer in enumerate(self.cls_convs):
+                if j == self.cls_down_index:
+                    num_grid = self.num_grids[i]
+                    cls_feat = F.interpolate(
+                        cls_feat, size=num_grid, mode='bilinear')
+                cls_feat = cls_layer(cls_feat)
+
+            cls_pred = self.conv_cls(cls_feat)
+
+            if not self.training:
+                feat_wh = feats[0].size()[-2:]
+                upsampled_size = (feat_wh[0] * 2, feat_wh[1] * 2)
+                mask_pred_x = F.interpolate(
+                    mask_pred_x.sigmoid(),
+                    size=upsampled_size,
+                    mode='bilinear')
+                mask_pred_y = F.interpolate(
+                    mask_pred_y.sigmoid(),
+                    size=upsampled_size,
+                    mode='bilinear')
+                cls_pred = cls_pred.sigmoid()
+                # get local maximum
+                local_max = F.max_pool2d(cls_pred, 2, stride=1, padding=1)
+                keep_mask = local_max[:, :, :-1, :-1] == cls_pred
+                cls_pred = cls_pred * keep_mask
+
+            mask_preds_x.append(mask_pred_x)
+            mask_preds_y.append(mask_pred_y)
+            cls_preds.append(cls_pred)
+        return mask_preds_x, mask_preds_y, cls_preds
diff --git a/mmdetection/mmdet/models/dense_heads/solov2_head.py b/mmdetection/mmdet/models/dense_heads/solov2_head.py
new file mode 100644
index 00000000..35b9df0c
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/solov2_head.py
@@ -0,0 +1,799 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+from typing import List, Optional, Tuple
+
+import mmcv
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.models.utils.misc import floordiv
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, InstanceList, MultiConfig, OptConfigType
+from ..layers import mask_matrix_nms
+from ..utils import center_of_mass, generate_coordinate, multi_apply
+from .solo_head import SOLOHead
+
+
+class MaskFeatModule(BaseModule):
+    """SOLOv2 mask feature map branch used in `SOLOv2: Dynamic and Fast
+    Instance Segmentation. `_
+
+    Args:
+        in_channels (int): Number of channels in the input feature map.
+        feat_channels (int): Number of hidden channels of the mask feature
+             map branch.
+        start_level (int): The starting feature map level from RPN that
+             will be used to predict the mask feature map.
+        end_level (int): The ending feature map level from rpn that
+             will be used to predict the mask feature map.
+        out_channels (int): Number of output channels of the mask feature
+             map branch. This is the channel count of the mask
+             feature map that to be dynamically convolved with the predicted
+             kernel.
+        mask_stride (int): Downsample factor of the mask feature map output.
+            Defaults to 4.
+        conv_cfg (dict): Config dict for convolution layer. Default: None.
+        norm_cfg (dict): Config dict for normalization layer. Default: None.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        feat_channels: int,
+        start_level: int,
+        end_level: int,
+        out_channels: int,
+        mask_stride: int = 4,
+        conv_cfg: OptConfigType = None,
+        norm_cfg: OptConfigType = None,
+        init_cfg: MultiConfig = [
+            dict(type='Normal', layer='Conv2d', std=0.01)
+        ]
+    ) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.in_channels = in_channels
+        self.feat_channels = feat_channels
+        self.start_level = start_level
+        self.end_level = end_level
+        self.mask_stride = mask_stride
+        assert start_level >= 0 and end_level >= start_level
+        self.out_channels = out_channels
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self._init_layers()
+        self.fp16_enabled = False
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        self.convs_all_levels = nn.ModuleList()
+        for i in range(self.start_level, self.end_level + 1):
+            convs_per_level = nn.Sequential()
+            if i == 0:
+                convs_per_level.add_module(
+                    f'conv{i}',
+                    ConvModule(
+                        self.in_channels,
+                        self.feat_channels,
+                        3,
+                        padding=1,
+                        conv_cfg=self.conv_cfg,
+                        norm_cfg=self.norm_cfg,
+                        inplace=False))
+                self.convs_all_levels.append(convs_per_level)
+                continue
+
+            for j in range(i):
+                if j == 0:
+                    if i == self.end_level:
+                        chn = self.in_channels + 2
+                    else:
+                        chn = self.in_channels
+                    convs_per_level.add_module(
+                        f'conv{j}',
+                        ConvModule(
+                            chn,
+                            self.feat_channels,
+                            3,
+                            padding=1,
+                            conv_cfg=self.conv_cfg,
+                            norm_cfg=self.norm_cfg,
+                            inplace=False))
+                    convs_per_level.add_module(
+                        f'upsample{j}',
+                        nn.Upsample(
+                            scale_factor=2,
+                            mode='bilinear',
+                            align_corners=False))
+                    continue
+
+                convs_per_level.add_module(
+                    f'conv{j}',
+                    ConvModule(
+                        self.feat_channels,
+                        self.feat_channels,
+                        3,
+                        padding=1,
+                        conv_cfg=self.conv_cfg,
+                        norm_cfg=self.norm_cfg,
+                        inplace=False))
+                convs_per_level.add_module(
+                    f'upsample{j}',
+                    nn.Upsample(
+                        scale_factor=2, mode='bilinear', align_corners=False))
+
+            self.convs_all_levels.append(convs_per_level)
+
+        self.conv_pred = ConvModule(
+            self.feat_channels,
+            self.out_channels,
+            1,
+            padding=0,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg)
+
+    def forward(self, x: Tuple[Tensor]) -> Tensor:
+        """Forward features from the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            Tensor: The predicted mask feature map.
+        """
+        inputs = x[self.start_level:self.end_level + 1]
+        assert len(inputs) == (self.end_level - self.start_level + 1)
+        feature_add_all_level = self.convs_all_levels[0](inputs[0])
+        for i in range(1, len(inputs)):
+            input_p = inputs[i]
+            if i == len(inputs) - 1:
+                coord_feat = generate_coordinate(input_p.size(),
+                                                 input_p.device)
+                input_p = torch.cat([input_p, coord_feat], 1)
+
+            feature_add_all_level = feature_add_all_level + \
+                self.convs_all_levels[i](input_p)
+
+        feature_pred = self.conv_pred(feature_add_all_level)
+        return feature_pred
+
+
+@MODELS.register_module()
+class SOLOV2Head(SOLOHead):
+    """SOLOv2 mask head used in `SOLOv2: Dynamic and Fast Instance
+    Segmentation. `_
+
+    Args:
+        mask_feature_head (dict): Config of SOLOv2MaskFeatHead.
+        dynamic_conv_size (int): Dynamic Conv kernel size. Defaults to 1.
+        dcn_cfg (dict): Dcn conv configurations in kernel_convs and cls_conv.
+            Defaults to None.
+        dcn_apply_to_all_conv (bool): Whether to use dcn in every layer of
+            kernel_convs and cls_convs, or only the last layer. It shall be set
+            `True` for the normal version of SOLOv2 and `False` for the
+            light-weight version. Defaults to True.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+    """
+
+    def __init__(self,
+                 *args,
+                 mask_feature_head: ConfigType,
+                 dynamic_conv_size: int = 1,
+                 dcn_cfg: OptConfigType = None,
+                 dcn_apply_to_all_conv: bool = True,
+                 init_cfg: MultiConfig = [
+                     dict(type='Normal', layer='Conv2d', std=0.01),
+                     dict(
+                         type='Normal',
+                         std=0.01,
+                         bias_prob=0.01,
+                         override=dict(name='conv_cls'))
+                 ],
+                 **kwargs) -> None:
+        assert dcn_cfg is None or isinstance(dcn_cfg, dict)
+        self.dcn_cfg = dcn_cfg
+        self.with_dcn = dcn_cfg is not None
+        self.dcn_apply_to_all_conv = dcn_apply_to_all_conv
+        self.dynamic_conv_size = dynamic_conv_size
+        mask_out_channels = mask_feature_head.get('out_channels')
+        self.kernel_out_channels = \
+            mask_out_channels * self.dynamic_conv_size * self.dynamic_conv_size
+
+        super().__init__(*args, init_cfg=init_cfg, **kwargs)
+
+        # update the in_channels of mask_feature_head
+        if mask_feature_head.get('in_channels', None) is not None:
+            if mask_feature_head.in_channels != self.in_channels:
+                warnings.warn('The `in_channels` of SOLOv2MaskFeatHead and '
+                              'SOLOv2Head should be same, changing '
+                              'mask_feature_head.in_channels to '
+                              f'{self.in_channels}')
+                mask_feature_head.update(in_channels=self.in_channels)
+        else:
+            mask_feature_head.update(in_channels=self.in_channels)
+
+        self.mask_feature_head = MaskFeatModule(**mask_feature_head)
+        self.mask_stride = self.mask_feature_head.mask_stride
+        self.fp16_enabled = False
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        self.cls_convs = nn.ModuleList()
+        self.kernel_convs = nn.ModuleList()
+        conv_cfg = None
+        for i in range(self.stacked_convs):
+            if self.with_dcn:
+                if self.dcn_apply_to_all_conv:
+                    conv_cfg = self.dcn_cfg
+                elif i == self.stacked_convs - 1:
+                    # light head
+                    conv_cfg = self.dcn_cfg
+
+            chn = self.in_channels + 2 if i == 0 else self.feat_channels
+            self.kernel_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=self.norm_cfg,
+                    bias=self.norm_cfg is None))
+
+            chn = self.in_channels if i == 0 else self.feat_channels
+            self.cls_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=self.norm_cfg,
+                    bias=self.norm_cfg is None))
+
+        self.conv_cls = nn.Conv2d(
+            self.feat_channels, self.cls_out_channels, 3, padding=1)
+
+        self.conv_kernel = nn.Conv2d(
+            self.feat_channels, self.kernel_out_channels, 3, padding=1)
+
+    def forward(self, x):
+        """Forward features from the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple: A tuple of classification scores, mask prediction,
+            and mask features.
+
+                - mlvl_kernel_preds (list[Tensor]): Multi-level dynamic kernel
+                  prediction. The kernel is used to generate instance
+                  segmentation masks by dynamic convolution. Each element in
+                  the list has shape
+                  (batch_size, kernel_out_channels, num_grids, num_grids).
+                - mlvl_cls_preds (list[Tensor]): Multi-level scores. Each
+                  element in the list has shape
+                  (batch_size, num_classes, num_grids, num_grids).
+                - mask_feats (Tensor): Unified mask feature map used to
+                  generate instance segmentation masks by dynamic convolution.
+                  Has shape (batch_size, mask_out_channels, h, w).
+        """
+        assert len(x) == self.num_levels
+        mask_feats = self.mask_feature_head(x)
+        ins_kernel_feats = self.resize_feats(x)
+        mlvl_kernel_preds = []
+        mlvl_cls_preds = []
+        for i in range(self.num_levels):
+            ins_kernel_feat = ins_kernel_feats[i]
+            # ins branch
+            # concat coord
+            coord_feat = generate_coordinate(ins_kernel_feat.size(),
+                                             ins_kernel_feat.device)
+            ins_kernel_feat = torch.cat([ins_kernel_feat, coord_feat], 1)
+
+            # kernel branch
+            kernel_feat = ins_kernel_feat
+            kernel_feat = F.interpolate(
+                kernel_feat,
+                size=self.num_grids[i],
+                mode='bilinear',
+                align_corners=False)
+
+            cate_feat = kernel_feat[:, :-2, :, :]
+
+            kernel_feat = kernel_feat.contiguous()
+            for i, kernel_conv in enumerate(self.kernel_convs):
+                kernel_feat = kernel_conv(kernel_feat)
+            kernel_pred = self.conv_kernel(kernel_feat)
+
+            # cate branch
+            cate_feat = cate_feat.contiguous()
+            for i, cls_conv in enumerate(self.cls_convs):
+                cate_feat = cls_conv(cate_feat)
+            cate_pred = self.conv_cls(cate_feat)
+
+            mlvl_kernel_preds.append(kernel_pred)
+            mlvl_cls_preds.append(cate_pred)
+
+        return mlvl_kernel_preds, mlvl_cls_preds, mask_feats
+
+    def _get_targets_single(self,
+                            gt_instances: InstanceData,
+                            featmap_sizes: Optional[list] = None) -> tuple:
+        """Compute targets for predictions of single image.
+
+        Args:
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It should includes ``bboxes``, ``labels``,
+                and ``masks`` attributes.
+            featmap_sizes (list[:obj:`torch.size`]): Size of each
+                feature map from feature pyramid, each element
+                means (feat_h, feat_w). Defaults to None.
+
+        Returns:
+            Tuple: Usually returns a tuple containing targets for predictions.
+
+                - mlvl_pos_mask_targets (list[Tensor]): Each element represent
+                  the binary mask targets for positive points in this
+                  level, has shape (num_pos, out_h, out_w).
+                - mlvl_labels (list[Tensor]): Each element is
+                  classification labels for all
+                  points in this level, has shape
+                  (num_grid, num_grid).
+                - mlvl_pos_masks  (list[Tensor]): Each element is
+                  a `BoolTensor` to represent whether the
+                  corresponding point in single level
+                  is positive, has shape (num_grid **2).
+                - mlvl_pos_indexes  (list[list]): Each element
+                  in the list contains the positive index in
+                  corresponding level, has shape (num_pos).
+        """
+        gt_labels = gt_instances.labels
+        device = gt_labels.device
+
+        gt_bboxes = gt_instances.bboxes
+        gt_areas = torch.sqrt((gt_bboxes[:, 2] - gt_bboxes[:, 0]) *
+                              (gt_bboxes[:, 3] - gt_bboxes[:, 1]))
+        gt_masks = gt_instances.masks.to_tensor(
+            dtype=torch.bool, device=device)
+
+        mlvl_pos_mask_targets = []
+        mlvl_pos_indexes = []
+        mlvl_labels = []
+        mlvl_pos_masks = []
+        for (lower_bound, upper_bound), num_grid \
+                in zip(self.scale_ranges, self.num_grids):
+            mask_target = []
+            # FG cat_id: [0, num_classes -1], BG cat_id: num_classes
+            pos_index = []
+            labels = torch.zeros([num_grid, num_grid],
+                                 dtype=torch.int64,
+                                 device=device) + self.num_classes
+            pos_mask = torch.zeros([num_grid**2],
+                                   dtype=torch.bool,
+                                   device=device)
+
+            gt_inds = ((gt_areas >= lower_bound) &
+                       (gt_areas <= upper_bound)).nonzero().flatten()
+            if len(gt_inds) == 0:
+                mlvl_pos_mask_targets.append(
+                    torch.zeros([0, featmap_sizes[0], featmap_sizes[1]],
+                                dtype=torch.uint8,
+                                device=device))
+                mlvl_labels.append(labels)
+                mlvl_pos_masks.append(pos_mask)
+                mlvl_pos_indexes.append([])
+                continue
+            hit_gt_bboxes = gt_bboxes[gt_inds]
+            hit_gt_labels = gt_labels[gt_inds]
+            hit_gt_masks = gt_masks[gt_inds, ...]
+
+            pos_w_ranges = 0.5 * (hit_gt_bboxes[:, 2] -
+                                  hit_gt_bboxes[:, 0]) * self.pos_scale
+            pos_h_ranges = 0.5 * (hit_gt_bboxes[:, 3] -
+                                  hit_gt_bboxes[:, 1]) * self.pos_scale
+
+            # Make sure hit_gt_masks has a value
+            valid_mask_flags = hit_gt_masks.sum(dim=-1).sum(dim=-1) > 0
+
+            for gt_mask, gt_label, pos_h_range, pos_w_range, \
+                valid_mask_flag in \
+                    zip(hit_gt_masks, hit_gt_labels, pos_h_ranges,
+                        pos_w_ranges, valid_mask_flags):
+                if not valid_mask_flag:
+                    continue
+                upsampled_size = (featmap_sizes[0] * self.mask_stride,
+                                  featmap_sizes[1] * self.mask_stride)
+                center_h, center_w = center_of_mass(gt_mask)
+
+                coord_w = int(
+                    floordiv((center_w / upsampled_size[1]), (1. / num_grid),
+                             rounding_mode='trunc'))
+                coord_h = int(
+                    floordiv((center_h / upsampled_size[0]), (1. / num_grid),
+                             rounding_mode='trunc'))
+
+                # left, top, right, down
+                top_box = max(
+                    0,
+                    int(
+                        floordiv(
+                            (center_h - pos_h_range) / upsampled_size[0],
+                            (1. / num_grid),
+                            rounding_mode='trunc')))
+                down_box = min(
+                    num_grid - 1,
+                    int(
+                        floordiv(
+                            (center_h + pos_h_range) / upsampled_size[0],
+                            (1. / num_grid),
+                            rounding_mode='trunc')))
+                left_box = max(
+                    0,
+                    int(
+                        floordiv(
+                            (center_w - pos_w_range) / upsampled_size[1],
+                            (1. / num_grid),
+                            rounding_mode='trunc')))
+                right_box = min(
+                    num_grid - 1,
+                    int(
+                        floordiv(
+                            (center_w + pos_w_range) / upsampled_size[1],
+                            (1. / num_grid),
+                            rounding_mode='trunc')))
+
+                top = max(top_box, coord_h - 1)
+                down = min(down_box, coord_h + 1)
+                left = max(coord_w - 1, left_box)
+                right = min(right_box, coord_w + 1)
+
+                labels[top:(down + 1), left:(right + 1)] = gt_label
+                # ins
+                gt_mask = np.uint8(gt_mask.cpu().numpy())
+                # Follow the original implementation, F.interpolate is
+                # different from cv2 and opencv
+                gt_mask = mmcv.imrescale(gt_mask, scale=1. / self.mask_stride)
+                gt_mask = torch.from_numpy(gt_mask).to(device=device)
+
+                for i in range(top, down + 1):
+                    for j in range(left, right + 1):
+                        index = int(i * num_grid + j)
+                        this_mask_target = torch.zeros(
+                            [featmap_sizes[0], featmap_sizes[1]],
+                            dtype=torch.uint8,
+                            device=device)
+                        this_mask_target[:gt_mask.shape[0], :gt_mask.
+                                         shape[1]] = gt_mask
+                        mask_target.append(this_mask_target)
+                        pos_mask[index] = True
+                        pos_index.append(index)
+            if len(mask_target) == 0:
+                mask_target = torch.zeros(
+                    [0, featmap_sizes[0], featmap_sizes[1]],
+                    dtype=torch.uint8,
+                    device=device)
+            else:
+                mask_target = torch.stack(mask_target, 0)
+            mlvl_pos_mask_targets.append(mask_target)
+            mlvl_labels.append(labels)
+            mlvl_pos_masks.append(pos_mask)
+            mlvl_pos_indexes.append(pos_index)
+        return (mlvl_pos_mask_targets, mlvl_labels, mlvl_pos_masks,
+                mlvl_pos_indexes)
+
+    def loss_by_feat(self, mlvl_kernel_preds: List[Tensor],
+                     mlvl_cls_preds: List[Tensor], mask_feats: Tensor,
+                     batch_gt_instances: InstanceList,
+                     batch_img_metas: List[dict], **kwargs) -> dict:
+        """Calculate the loss based on the features extracted by the mask head.
+
+        Args:
+            mlvl_kernel_preds (list[Tensor]): Multi-level dynamic kernel
+                prediction. The kernel is used to generate instance
+                segmentation masks by dynamic convolution. Each element in the
+                list has shape
+                (batch_size, kernel_out_channels, num_grids, num_grids).
+            mlvl_cls_preds (list[Tensor]): Multi-level scores. Each element
+                in the list has shape
+                (batch_size, num_classes, num_grids, num_grids).
+            mask_feats (Tensor): Unified mask feature map used to generate
+                instance segmentation masks by dynamic convolution. Has shape
+                (batch_size, mask_out_channels, h, w).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes``, ``masks``,
+                and ``labels`` attributes.
+            batch_img_metas (list[dict]): Meta information of multiple images.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        featmap_sizes = mask_feats.size()[-2:]
+
+        pos_mask_targets, labels, pos_masks, pos_indexes = multi_apply(
+            self._get_targets_single,
+            batch_gt_instances,
+            featmap_sizes=featmap_sizes)
+
+        mlvl_mask_targets = [
+            torch.cat(lvl_mask_targets, 0)
+            for lvl_mask_targets in zip(*pos_mask_targets)
+        ]
+
+        mlvl_pos_kernel_preds = []
+        for lvl_kernel_preds, lvl_pos_indexes in zip(mlvl_kernel_preds,
+                                                     zip(*pos_indexes)):
+            lvl_pos_kernel_preds = []
+            for img_lvl_kernel_preds, img_lvl_pos_indexes in zip(
+                    lvl_kernel_preds, lvl_pos_indexes):
+                img_lvl_pos_kernel_preds = img_lvl_kernel_preds.view(
+                    img_lvl_kernel_preds.shape[0], -1)[:, img_lvl_pos_indexes]
+                lvl_pos_kernel_preds.append(img_lvl_pos_kernel_preds)
+            mlvl_pos_kernel_preds.append(lvl_pos_kernel_preds)
+
+        # make multilevel mlvl_mask_pred
+        mlvl_mask_preds = []
+        for lvl_pos_kernel_preds in mlvl_pos_kernel_preds:
+            lvl_mask_preds = []
+            for img_id, img_lvl_pos_kernel_pred in enumerate(
+                    lvl_pos_kernel_preds):
+                if img_lvl_pos_kernel_pred.size()[-1] == 0:
+                    continue
+                img_mask_feats = mask_feats[[img_id]]
+                h, w = img_mask_feats.shape[-2:]
+                num_kernel = img_lvl_pos_kernel_pred.shape[1]
+                img_lvl_mask_pred = F.conv2d(
+                    img_mask_feats,
+                    img_lvl_pos_kernel_pred.permute(1, 0).view(
+                        num_kernel, -1, self.dynamic_conv_size,
+                        self.dynamic_conv_size),
+                    stride=1).view(-1, h, w)
+                lvl_mask_preds.append(img_lvl_mask_pred)
+            if len(lvl_mask_preds) == 0:
+                lvl_mask_preds = None
+            else:
+                lvl_mask_preds = torch.cat(lvl_mask_preds, 0)
+            mlvl_mask_preds.append(lvl_mask_preds)
+        # dice loss
+        num_pos = 0
+        for img_pos_masks in pos_masks:
+            for lvl_img_pos_masks in img_pos_masks:
+                # Fix `Tensor` object has no attribute `count_nonzero()`
+                # in PyTorch 1.6, the type of `lvl_img_pos_masks`
+                # should be `torch.bool`.
+                num_pos += lvl_img_pos_masks.nonzero().numel()
+        loss_mask = []
+        for lvl_mask_preds, lvl_mask_targets in zip(mlvl_mask_preds,
+                                                    mlvl_mask_targets):
+            if lvl_mask_preds is None:
+                continue
+            loss_mask.append(
+                self.loss_mask(
+                    lvl_mask_preds,
+                    lvl_mask_targets,
+                    reduction_override='none'))
+        if num_pos > 0:
+            loss_mask = torch.cat(loss_mask).sum() / num_pos
+        else:
+            loss_mask = mask_feats.sum() * 0
+
+        # cate
+        flatten_labels = [
+            torch.cat(
+                [img_lvl_labels.flatten() for img_lvl_labels in lvl_labels])
+            for lvl_labels in zip(*labels)
+        ]
+        flatten_labels = torch.cat(flatten_labels)
+
+        flatten_cls_preds = [
+            lvl_cls_preds.permute(0, 2, 3, 1).reshape(-1, self.num_classes)
+            for lvl_cls_preds in mlvl_cls_preds
+        ]
+        flatten_cls_preds = torch.cat(flatten_cls_preds)
+
+        loss_cls = self.loss_cls(
+            flatten_cls_preds, flatten_labels, avg_factor=num_pos + 1)
+        return dict(loss_mask=loss_mask, loss_cls=loss_cls)
+
+    def predict_by_feat(self, mlvl_kernel_preds: List[Tensor],
+                        mlvl_cls_scores: List[Tensor], mask_feats: Tensor,
+                        batch_img_metas: List[dict], **kwargs) -> InstanceList:
+        """Transform a batch of output features extracted from the head into
+        mask results.
+
+        Args:
+            mlvl_kernel_preds (list[Tensor]): Multi-level dynamic kernel
+                prediction. The kernel is used to generate instance
+                segmentation masks by dynamic convolution. Each element in the
+                list has shape
+                (batch_size, kernel_out_channels, num_grids, num_grids).
+            mlvl_cls_scores (list[Tensor]): Multi-level scores. Each element
+                in the list has shape
+                (batch_size, num_classes, num_grids, num_grids).
+            mask_feats (Tensor): Unified mask feature map used to generate
+                instance segmentation masks by dynamic convolution. Has shape
+                (batch_size, mask_out_channels, h, w).
+            batch_img_metas (list[dict]): Meta information of all images.
+
+        Returns:
+            list[:obj:`InstanceData`]: Processed results of multiple
+            images.Each :obj:`InstanceData` usually contains
+            following keys.
+
+                - scores (Tensor): Classification scores, has shape
+                  (num_instance,).
+                - labels (Tensor): Has shape (num_instances,).
+                - masks (Tensor): Processed mask results, has
+                  shape (num_instances, h, w).
+        """
+        num_levels = len(mlvl_cls_scores)
+        assert len(mlvl_kernel_preds) == len(mlvl_cls_scores)
+
+        for lvl in range(num_levels):
+            cls_scores = mlvl_cls_scores[lvl]
+            cls_scores = cls_scores.sigmoid()
+            local_max = F.max_pool2d(cls_scores, 2, stride=1, padding=1)
+            keep_mask = local_max[:, :, :-1, :-1] == cls_scores
+            cls_scores = cls_scores * keep_mask
+            mlvl_cls_scores[lvl] = cls_scores.permute(0, 2, 3, 1)
+
+        result_list = []
+        for img_id in range(len(batch_img_metas)):
+            img_cls_pred = [
+                mlvl_cls_scores[lvl][img_id].view(-1, self.cls_out_channels)
+                for lvl in range(num_levels)
+            ]
+            img_mask_feats = mask_feats[[img_id]]
+            img_kernel_pred = [
+                mlvl_kernel_preds[lvl][img_id].permute(1, 2, 0).view(
+                    -1, self.kernel_out_channels) for lvl in range(num_levels)
+            ]
+            img_cls_pred = torch.cat(img_cls_pred, dim=0)
+            img_kernel_pred = torch.cat(img_kernel_pred, dim=0)
+            result = self._predict_by_feat_single(
+                img_kernel_pred,
+                img_cls_pred,
+                img_mask_feats,
+                img_meta=batch_img_metas[img_id])
+            result_list.append(result)
+        return result_list
+
+    def _predict_by_feat_single(self,
+                                kernel_preds: Tensor,
+                                cls_scores: Tensor,
+                                mask_feats: Tensor,
+                                img_meta: dict,
+                                cfg: OptConfigType = None) -> InstanceData:
+        """Transform a single image's features extracted from the head into
+        mask results.
+
+        Args:
+            kernel_preds (Tensor): Dynamic kernel prediction of all points
+                in single image, has shape
+                (num_points, kernel_out_channels).
+            cls_scores (Tensor): Classification score of all points
+                in single image, has shape (num_points, num_classes).
+            mask_feats (Tensor): Mask prediction of all points in
+                single image, has shape (num_points, feat_h, feat_w).
+            img_meta (dict): Meta information of corresponding image.
+            cfg (dict, optional): Config used in test phase.
+                Defaults to None.
+
+        Returns:
+            :obj:`InstanceData`: Processed results of single image.
+             it usually contains following keys.
+
+                - scores (Tensor): Classification scores, has shape
+                  (num_instance,).
+                - labels (Tensor): Has shape (num_instances,).
+                - masks (Tensor): Processed mask results, has
+                  shape (num_instances, h, w).
+        """
+
+        def empty_results(cls_scores, ori_shape):
+            """Generate a empty results."""
+            results = InstanceData()
+            results.scores = cls_scores.new_ones(0)
+            results.masks = cls_scores.new_zeros(0, *ori_shape)
+            results.labels = cls_scores.new_ones(0)
+            results.bboxes = cls_scores.new_zeros(0, 4)
+            return results
+
+        cfg = self.test_cfg if cfg is None else cfg
+        assert len(kernel_preds) == len(cls_scores)
+
+        featmap_size = mask_feats.size()[-2:]
+
+        # overall info
+        h, w = img_meta['img_shape'][:2]
+        upsampled_size = (featmap_size[0] * self.mask_stride,
+                          featmap_size[1] * self.mask_stride)
+
+        # process.
+        score_mask = (cls_scores > cfg.score_thr)
+        cls_scores = cls_scores[score_mask]
+        if len(cls_scores) == 0:
+            return empty_results(cls_scores, img_meta['ori_shape'][:2])
+
+        # cate_labels & kernel_preds
+        inds = score_mask.nonzero()
+        cls_labels = inds[:, 1]
+        kernel_preds = kernel_preds[inds[:, 0]]
+
+        # trans vector.
+        lvl_interval = cls_labels.new_tensor(self.num_grids).pow(2).cumsum(0)
+        strides = kernel_preds.new_ones(lvl_interval[-1])
+
+        strides[:lvl_interval[0]] *= self.strides[0]
+        for lvl in range(1, self.num_levels):
+            strides[lvl_interval[lvl -
+                                 1]:lvl_interval[lvl]] *= self.strides[lvl]
+        strides = strides[inds[:, 0]]
+
+        # mask encoding.
+        kernel_preds = kernel_preds.view(
+            kernel_preds.size(0), -1, self.dynamic_conv_size,
+            self.dynamic_conv_size)
+        mask_preds = F.conv2d(
+            mask_feats, kernel_preds, stride=1).squeeze(0).sigmoid()
+        # mask.
+        masks = mask_preds > cfg.mask_thr
+        sum_masks = masks.sum((1, 2)).float()
+        keep = sum_masks > strides
+        if keep.sum() == 0:
+            return empty_results(cls_scores, img_meta['ori_shape'][:2])
+        masks = masks[keep]
+        mask_preds = mask_preds[keep]
+        sum_masks = sum_masks[keep]
+        cls_scores = cls_scores[keep]
+        cls_labels = cls_labels[keep]
+
+        # maskness.
+        mask_scores = (mask_preds * masks).sum((1, 2)) / sum_masks
+        cls_scores *= mask_scores
+
+        scores, labels, _, keep_inds = mask_matrix_nms(
+            masks,
+            cls_labels,
+            cls_scores,
+            mask_area=sum_masks,
+            nms_pre=cfg.nms_pre,
+            max_num=cfg.max_per_img,
+            kernel=cfg.kernel,
+            sigma=cfg.sigma,
+            filter_thr=cfg.filter_thr)
+        if len(keep_inds) == 0:
+            return empty_results(cls_scores, img_meta['ori_shape'][:2])
+        mask_preds = mask_preds[keep_inds]
+        mask_preds = F.interpolate(
+            mask_preds.unsqueeze(0),
+            size=upsampled_size,
+            mode='bilinear',
+            align_corners=False)[:, :, :h, :w]
+        mask_preds = F.interpolate(
+            mask_preds,
+            size=img_meta['ori_shape'][:2],
+            mode='bilinear',
+            align_corners=False).squeeze(0)
+        masks = mask_preds > cfg.mask_thr
+
+        results = InstanceData()
+        results.masks = masks
+        results.labels = labels
+        results.scores = scores
+        # create an empty bbox in InstanceData to avoid bugs when
+        # calculating metrics.
+        results.bboxes = results.scores.new_zeros(len(scores), 4)
+
+        return results
diff --git a/mmdetection/mmdet/models/dense_heads/ssd_head.py b/mmdetection/mmdet/models/dense_heads/ssd_head.py
new file mode 100644
index 00000000..950df291
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/ssd_head.py
@@ -0,0 +1,362 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, List, Optional, Sequence, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule, DepthwiseSeparableConvModule
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.utils import ConfigType, InstanceList, MultiConfig, OptInstanceList
+from ..losses import smooth_l1_loss
+from ..task_modules.samplers import PseudoSampler
+from ..utils import multi_apply
+from .anchor_head import AnchorHead
+
+
+# TODO: add loss evaluator for SSD
+@MODELS.register_module()
+class SSDHead(AnchorHead):
+    """Implementation of `SSD head `_
+
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (Sequence[int]): Number of channels in the input feature
+            map.
+        stacked_convs (int): Number of conv layers in cls and reg tower.
+            Defaults to 0.
+        feat_channels (int): Number of hidden channels when stacked_convs
+            > 0. Defaults to 256.
+        use_depthwise (bool): Whether to use DepthwiseSeparableConv.
+            Defaults to False.
+        conv_cfg (:obj:`ConfigDict` or dict, Optional): Dictionary to construct
+            and config conv layer. Defaults to None.
+        norm_cfg (:obj:`ConfigDict` or dict, Optional): Dictionary to construct
+            and config norm layer. Defaults to None.
+        act_cfg (:obj:`ConfigDict` or dict, Optional): Dictionary to construct
+            and config activation layer. Defaults to None.
+        anchor_generator (:obj:`ConfigDict` or dict): Config dict for anchor
+            generator.
+        bbox_coder (:obj:`ConfigDict` or dict): Config of bounding box coder.
+        reg_decoded_bbox (bool): If true, the regression loss would be
+            applied directly on decoded bounding boxes, converting both
+            the predicted boxes and regression targets to absolute
+            coordinates format. Defaults to False. It should be `True` when
+            using `IoULoss`, `GIoULoss`, or `DIoULoss` in the bbox head.
+        train_cfg (:obj:`ConfigDict` or dict, Optional): Training config of
+            anchor head.
+        test_cfg (:obj:`ConfigDict` or dict, Optional): Testing config of
+            anchor head.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict], Optional): Initialization config dict.
+    """  # noqa: W605
+
+    def __init__(
+        self,
+        num_classes: int = 80,
+        in_channels: Sequence[int] = (512, 1024, 512, 256, 256, 256),
+        stacked_convs: int = 0,
+        feat_channels: int = 256,
+        use_depthwise: bool = False,
+        conv_cfg: Optional[ConfigType] = None,
+        norm_cfg: Optional[ConfigType] = None,
+        act_cfg: Optional[ConfigType] = None,
+        anchor_generator: ConfigType = dict(
+            type='SSDAnchorGenerator',
+            scale_major=False,
+            input_size=300,
+            strides=[8, 16, 32, 64, 100, 300],
+            ratios=([2], [2, 3], [2, 3], [2, 3], [2], [2]),
+            basesize_ratio_range=(0.1, 0.9)),
+        bbox_coder: ConfigType = dict(
+            type='DeltaXYWHBBoxCoder',
+            clip_border=True,
+            target_means=[.0, .0, .0, .0],
+            target_stds=[1.0, 1.0, 1.0, 1.0],
+        ),
+        reg_decoded_bbox: bool = False,
+        train_cfg: Optional[ConfigType] = None,
+        test_cfg: Optional[ConfigType] = None,
+        init_cfg: MultiConfig = dict(
+            type='Xavier', layer='Conv2d', distribution='uniform', bias=0)
+    ) -> None:
+        super(AnchorHead, self).__init__(init_cfg=init_cfg)
+        self.num_classes = num_classes
+        self.in_channels = in_channels
+        self.stacked_convs = stacked_convs
+        self.feat_channels = feat_channels
+        self.use_depthwise = use_depthwise
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+
+        self.cls_out_channels = num_classes + 1  # add background class
+        self.prior_generator = TASK_UTILS.build(anchor_generator)
+
+        # Usually the numbers of anchors for each level are the same
+        # except SSD detectors. So it is an int in the most dense
+        # heads but a list of int in SSDHead
+        self.num_base_priors = self.prior_generator.num_base_priors
+
+        self._init_layers()
+
+        self.bbox_coder = TASK_UTILS.build(bbox_coder)
+        self.reg_decoded_bbox = reg_decoded_bbox
+        self.use_sigmoid_cls = False
+        self.cls_focal_loss = False
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+        if self.train_cfg:
+            self.assigner = TASK_UTILS.build(self.train_cfg['assigner'])
+            if self.train_cfg.get('sampler', None) is not None:
+                self.sampler = TASK_UTILS.build(
+                    self.train_cfg['sampler'], default_args=dict(context=self))
+            else:
+                self.sampler = PseudoSampler(context=self)
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        self.cls_convs = nn.ModuleList()
+        self.reg_convs = nn.ModuleList()
+        # TODO: Use registry to choose ConvModule type
+        conv = DepthwiseSeparableConvModule \
+            if self.use_depthwise else ConvModule
+
+        for channel, num_base_priors in zip(self.in_channels,
+                                            self.num_base_priors):
+            cls_layers = []
+            reg_layers = []
+            in_channel = channel
+            # build stacked conv tower, not used in default ssd
+            for i in range(self.stacked_convs):
+                cls_layers.append(
+                    conv(
+                        in_channel,
+                        self.feat_channels,
+                        3,
+                        padding=1,
+                        conv_cfg=self.conv_cfg,
+                        norm_cfg=self.norm_cfg,
+                        act_cfg=self.act_cfg))
+                reg_layers.append(
+                    conv(
+                        in_channel,
+                        self.feat_channels,
+                        3,
+                        padding=1,
+                        conv_cfg=self.conv_cfg,
+                        norm_cfg=self.norm_cfg,
+                        act_cfg=self.act_cfg))
+                in_channel = self.feat_channels
+            # SSD-Lite head
+            if self.use_depthwise:
+                cls_layers.append(
+                    ConvModule(
+                        in_channel,
+                        in_channel,
+                        3,
+                        padding=1,
+                        groups=in_channel,
+                        conv_cfg=self.conv_cfg,
+                        norm_cfg=self.norm_cfg,
+                        act_cfg=self.act_cfg))
+                reg_layers.append(
+                    ConvModule(
+                        in_channel,
+                        in_channel,
+                        3,
+                        padding=1,
+                        groups=in_channel,
+                        conv_cfg=self.conv_cfg,
+                        norm_cfg=self.norm_cfg,
+                        act_cfg=self.act_cfg))
+            cls_layers.append(
+                nn.Conv2d(
+                    in_channel,
+                    num_base_priors * self.cls_out_channels,
+                    kernel_size=1 if self.use_depthwise else 3,
+                    padding=0 if self.use_depthwise else 1))
+            reg_layers.append(
+                nn.Conv2d(
+                    in_channel,
+                    num_base_priors * 4,
+                    kernel_size=1 if self.use_depthwise else 3,
+                    padding=0 if self.use_depthwise else 1))
+            self.cls_convs.append(nn.Sequential(*cls_layers))
+            self.reg_convs.append(nn.Sequential(*reg_layers))
+
+    def forward(self, x: Tuple[Tensor]) -> Tuple[List[Tensor], List[Tensor]]:
+        """Forward features from the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple[list[Tensor], list[Tensor]]: A tuple of cls_scores list and
+            bbox_preds list.
+
+            - cls_scores (list[Tensor]): Classification scores for all scale \
+            levels, each is a 4D-tensor, the channels number is \
+            num_anchors * num_classes.
+            - bbox_preds (list[Tensor]): Box energies / deltas for all scale \
+            levels, each is a 4D-tensor, the channels number is \
+            num_anchors * 4.
+        """
+        cls_scores = []
+        bbox_preds = []
+        for feat, reg_conv, cls_conv in zip(x, self.reg_convs, self.cls_convs):
+            cls_scores.append(cls_conv(feat))
+            bbox_preds.append(reg_conv(feat))
+        return cls_scores, bbox_preds
+
+    def loss_by_feat_single(self, cls_score: Tensor, bbox_pred: Tensor,
+                            anchor: Tensor, labels: Tensor,
+                            label_weights: Tensor, bbox_targets: Tensor,
+                            bbox_weights: Tensor,
+                            avg_factor: int) -> Tuple[Tensor, Tensor]:
+        """Compute loss of a single image.
+
+        Args:
+            cls_score (Tensor): Box scores for eachimage
+                Has shape (num_total_anchors, num_classes).
+            bbox_pred (Tensor): Box energies / deltas for each image
+                level with shape (num_total_anchors, 4).
+            anchors (Tensor): Box reference for each scale level with shape
+                (num_total_anchors, 4).
+            labels (Tensor): Labels of each anchors with shape
+                (num_total_anchors,).
+            label_weights (Tensor): Label weights of each anchor with shape
+                (num_total_anchors,)
+            bbox_targets (Tensor): BBox regression targets of each anchor with
+                shape (num_total_anchors, 4).
+            bbox_weights (Tensor): BBox regression loss weights of each anchor
+                with shape (num_total_anchors, 4).
+            avg_factor (int): Average factor that is used to average
+                the loss. When using sampling method, avg_factor is usually
+                the sum of positive and negative priors. When using
+                `PseudoSampler`, `avg_factor` is usually equal to the number
+                of positive priors.
+
+        Returns:
+            Tuple[Tensor, Tensor]: A tuple of cls loss and bbox loss of one
+            feature map.
+        """
+
+        loss_cls_all = F.cross_entropy(
+            cls_score, labels, reduction='none') * label_weights
+        # FG cat_id: [0, num_classes -1], BG cat_id: num_classes
+        pos_inds = ((labels >= 0) & (labels < self.num_classes)).nonzero(
+            as_tuple=False).reshape(-1)
+        neg_inds = (labels == self.num_classes).nonzero(
+            as_tuple=False).view(-1)
+
+        num_pos_samples = pos_inds.size(0)
+        num_neg_samples = self.train_cfg['neg_pos_ratio'] * num_pos_samples
+        if num_neg_samples > neg_inds.size(0):
+            num_neg_samples = neg_inds.size(0)
+        topk_loss_cls_neg, _ = loss_cls_all[neg_inds].topk(num_neg_samples)
+        loss_cls_pos = loss_cls_all[pos_inds].sum()
+        loss_cls_neg = topk_loss_cls_neg.sum()
+        loss_cls = (loss_cls_pos + loss_cls_neg) / avg_factor
+
+        if self.reg_decoded_bbox:
+            # When the regression loss (e.g. `IouLoss`, `GIouLoss`)
+            # is applied directly on the decoded bounding boxes, it
+            # decodes the already encoded coordinates to absolute format.
+            bbox_pred = self.bbox_coder.decode(anchor, bbox_pred)
+
+        loss_bbox = smooth_l1_loss(
+            bbox_pred,
+            bbox_targets,
+            bbox_weights,
+            beta=self.train_cfg['smoothl1_beta'],
+            avg_factor=avg_factor)
+        return loss_cls[None], loss_bbox
+
+    def loss_by_feat(
+        self,
+        cls_scores: List[Tensor],
+        bbox_preds: List[Tensor],
+        batch_gt_instances: InstanceList,
+        batch_img_metas: List[dict],
+        batch_gt_instances_ignore: OptInstanceList = None
+    ) -> Dict[str, List[Tensor]]:
+        """Compute losses of the head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level
+                Has shape (N, num_anchors * num_classes, H, W)
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level with shape (N, num_anchors * 4, H, W)
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], Optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, list[Tensor]]: A dictionary of loss components. the dict
+            has components below:
+
+            - loss_cls (list[Tensor]): A list containing each feature map \
+            classification loss.
+            - loss_bbox (list[Tensor]): A list containing each feature map \
+            regression loss.
+        """
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        assert len(featmap_sizes) == self.prior_generator.num_levels
+
+        device = cls_scores[0].device
+
+        anchor_list, valid_flag_list = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+        cls_reg_targets = self.get_targets(
+            anchor_list,
+            valid_flag_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore,
+            unmap_outputs=True)
+        (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,
+         avg_factor) = cls_reg_targets
+
+        num_images = len(batch_img_metas)
+        all_cls_scores = torch.cat([
+            s.permute(0, 2, 3, 1).reshape(
+                num_images, -1, self.cls_out_channels) for s in cls_scores
+        ], 1)
+        all_labels = torch.cat(labels_list, -1).view(num_images, -1)
+        all_label_weights = torch.cat(label_weights_list,
+                                      -1).view(num_images, -1)
+        all_bbox_preds = torch.cat([
+            b.permute(0, 2, 3, 1).reshape(num_images, -1, 4)
+            for b in bbox_preds
+        ], -2)
+        all_bbox_targets = torch.cat(bbox_targets_list,
+                                     -2).view(num_images, -1, 4)
+        all_bbox_weights = torch.cat(bbox_weights_list,
+                                     -2).view(num_images, -1, 4)
+
+        # concat all level anchors to a single tensor
+        all_anchors = []
+        for i in range(num_images):
+            all_anchors.append(torch.cat(anchor_list[i]))
+
+        losses_cls, losses_bbox = multi_apply(
+            self.loss_by_feat_single,
+            all_cls_scores,
+            all_bbox_preds,
+            all_anchors,
+            all_labels,
+            all_label_weights,
+            all_bbox_targets,
+            all_bbox_weights,
+            avg_factor=avg_factor)
+        return dict(loss_cls=losses_cls, loss_bbox=losses_bbox)
diff --git a/mmdetection/mmdet/models/dense_heads/tood_head.py b/mmdetection/mmdet/models/dense_heads/tood_head.py
new file mode 100644
index 00000000..8c59598d
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/tood_head.py
@@ -0,0 +1,805 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule, Scale
+from mmcv.ops import deform_conv2d
+from mmengine import MessageHub
+from mmengine.config import ConfigDict
+from mmengine.model import bias_init_with_prob, normal_init
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.structures.bbox import distance2bbox
+from mmdet.utils import (ConfigType, InstanceList, OptConfigType,
+                         OptInstanceList, reduce_mean)
+from ..task_modules.prior_generators import anchor_inside_flags
+from ..utils import (filter_scores_and_topk, images_to_levels, multi_apply,
+                     sigmoid_geometric_mean, unmap)
+from .atss_head import ATSSHead
+
+
+class TaskDecomposition(nn.Module):
+    """Task decomposition module in task-aligned predictor of TOOD.
+
+    Args:
+        feat_channels (int): Number of feature channels in TOOD head.
+        stacked_convs (int): Number of conv layers in TOOD head.
+        la_down_rate (int): Downsample rate of layer attention.
+            Defaults to 8.
+        conv_cfg (:obj:`ConfigDict` or dict, optional): Config dict for
+            convolution layer. Defaults to None.
+        norm_cfg (:obj:`ConfigDict` or dict, optional):  Config dict for
+        normalization layer. Defaults to None.
+    """
+
+    def __init__(self,
+                 feat_channels: int,
+                 stacked_convs: int,
+                 la_down_rate: int = 8,
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: OptConfigType = None) -> None:
+        super().__init__()
+        self.feat_channels = feat_channels
+        self.stacked_convs = stacked_convs
+        self.in_channels = self.feat_channels * self.stacked_convs
+        self.norm_cfg = norm_cfg
+        self.layer_attention = nn.Sequential(
+            nn.Conv2d(self.in_channels, self.in_channels // la_down_rate, 1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(
+                self.in_channels // la_down_rate,
+                self.stacked_convs,
+                1,
+                padding=0), nn.Sigmoid())
+
+        self.reduction_conv = ConvModule(
+            self.in_channels,
+            self.feat_channels,
+            1,
+            stride=1,
+            padding=0,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            bias=norm_cfg is None)
+
+    def init_weights(self) -> None:
+        """Initialize the parameters."""
+        for m in self.layer_attention.modules():
+            if isinstance(m, nn.Conv2d):
+                normal_init(m, std=0.001)
+        normal_init(self.reduction_conv.conv, std=0.01)
+
+    def forward(self,
+                feat: Tensor,
+                avg_feat: Optional[Tensor] = None) -> Tensor:
+        """Forward function of task decomposition module."""
+        b, c, h, w = feat.shape
+        if avg_feat is None:
+            avg_feat = F.adaptive_avg_pool2d(feat, (1, 1))
+        weight = self.layer_attention(avg_feat)
+
+        # here we first compute the product between layer attention weight and
+        # conv weight, and then compute the convolution between new conv weight
+        # and feature map, in order to save memory and FLOPs.
+        conv_weight = weight.reshape(
+            b, 1, self.stacked_convs,
+            1) * self.reduction_conv.conv.weight.reshape(
+                1, self.feat_channels, self.stacked_convs, self.feat_channels)
+        conv_weight = conv_weight.reshape(b, self.feat_channels,
+                                          self.in_channels)
+        feat = feat.reshape(b, self.in_channels, h * w)
+        feat = torch.bmm(conv_weight, feat).reshape(b, self.feat_channels, h,
+                                                    w)
+        if self.norm_cfg is not None:
+            feat = self.reduction_conv.norm(feat)
+        feat = self.reduction_conv.activate(feat)
+
+        return feat
+
+
+@MODELS.register_module()
+class TOODHead(ATSSHead):
+    """TOODHead used in `TOOD: Task-aligned One-stage Object Detection.
+
+    `_.
+
+    TOOD uses Task-aligned head (T-head) and is optimized by Task Alignment
+    Learning (TAL).
+
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (int): Number of channels in the input feature map.
+        num_dcn (int): Number of deformable convolution in the head.
+            Defaults to 0.
+        anchor_type (str): If set to ``anchor_free``, the head will use centers
+            to regress bboxes. If set to ``anchor_based``, the head will
+            regress bboxes based on anchors. Defaults to ``anchor_free``.
+        initial_loss_cls (:obj:`ConfigDict` or dict): Config of initial loss.
+
+    Example:
+        >>> self = TOODHead(11, 7)
+        >>> feats = [torch.rand(1, 7, s, s) for s in [4, 8, 16, 32, 64]]
+        >>> cls_score, bbox_pred = self.forward(feats)
+        >>> assert len(cls_score) == len(self.scales)
+    """
+
+    def __init__(self,
+                 num_classes: int,
+                 in_channels: int,
+                 num_dcn: int = 0,
+                 anchor_type: str = 'anchor_free',
+                 initial_loss_cls: ConfigType = dict(
+                     type='FocalLoss',
+                     use_sigmoid=True,
+                     activated=True,
+                     gamma=2.0,
+                     alpha=0.25,
+                     loss_weight=1.0),
+                 **kwargs) -> None:
+        assert anchor_type in ['anchor_free', 'anchor_based']
+        self.num_dcn = num_dcn
+        self.anchor_type = anchor_type
+        super().__init__(
+            num_classes=num_classes, in_channels=in_channels, **kwargs)
+
+        if self.train_cfg:
+            self.initial_epoch = self.train_cfg['initial_epoch']
+            self.initial_assigner = TASK_UTILS.build(
+                self.train_cfg['initial_assigner'])
+            self.initial_loss_cls = MODELS.build(initial_loss_cls)
+            self.assigner = self.initial_assigner
+            self.alignment_assigner = TASK_UTILS.build(
+                self.train_cfg['assigner'])
+            self.alpha = self.train_cfg['alpha']
+            self.beta = self.train_cfg['beta']
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        self.relu = nn.ReLU(inplace=True)
+        self.inter_convs = nn.ModuleList()
+        for i in range(self.stacked_convs):
+            if i < self.num_dcn:
+                conv_cfg = dict(type='DCNv2', deform_groups=4)
+            else:
+                conv_cfg = self.conv_cfg
+            chn = self.in_channels if i == 0 else self.feat_channels
+            self.inter_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=self.norm_cfg))
+
+        self.cls_decomp = TaskDecomposition(self.feat_channels,
+                                            self.stacked_convs,
+                                            self.stacked_convs * 8,
+                                            self.conv_cfg, self.norm_cfg)
+        self.reg_decomp = TaskDecomposition(self.feat_channels,
+                                            self.stacked_convs,
+                                            self.stacked_convs * 8,
+                                            self.conv_cfg, self.norm_cfg)
+
+        self.tood_cls = nn.Conv2d(
+            self.feat_channels,
+            self.num_base_priors * self.cls_out_channels,
+            3,
+            padding=1)
+        self.tood_reg = nn.Conv2d(
+            self.feat_channels, self.num_base_priors * 4, 3, padding=1)
+
+        self.cls_prob_module = nn.Sequential(
+            nn.Conv2d(self.feat_channels * self.stacked_convs,
+                      self.feat_channels // 4, 1), nn.ReLU(inplace=True),
+            nn.Conv2d(self.feat_channels // 4, 1, 3, padding=1))
+        self.reg_offset_module = nn.Sequential(
+            nn.Conv2d(self.feat_channels * self.stacked_convs,
+                      self.feat_channels // 4, 1), nn.ReLU(inplace=True),
+            nn.Conv2d(self.feat_channels // 4, 4 * 2, 3, padding=1))
+
+        self.scales = nn.ModuleList(
+            [Scale(1.0) for _ in self.prior_generator.strides])
+
+    def init_weights(self) -> None:
+        """Initialize weights of the head."""
+        bias_cls = bias_init_with_prob(0.01)
+        for m in self.inter_convs:
+            normal_init(m.conv, std=0.01)
+        for m in self.cls_prob_module:
+            if isinstance(m, nn.Conv2d):
+                normal_init(m, std=0.01)
+        for m in self.reg_offset_module:
+            if isinstance(m, nn.Conv2d):
+                normal_init(m, std=0.001)
+        normal_init(self.cls_prob_module[-1], std=0.01, bias=bias_cls)
+
+        self.cls_decomp.init_weights()
+        self.reg_decomp.init_weights()
+
+        normal_init(self.tood_cls, std=0.01, bias=bias_cls)
+        normal_init(self.tood_reg, std=0.01)
+
+    def forward(self, feats: Tuple[Tensor]) -> Tuple[List[Tensor]]:
+        """Forward features from the upstream network.
+
+        Args:
+            feats (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple: Usually a tuple of classification scores and bbox prediction
+                cls_scores (list[Tensor]): Classification scores for all scale
+                    levels, each is a 4D-tensor, the channels number is
+                    num_anchors * num_classes.
+                bbox_preds (list[Tensor]): Decoded box for all scale levels,
+                    each is a 4D-tensor, the channels number is
+                    num_anchors * 4. In [tl_x, tl_y, br_x, br_y] format.
+        """
+        cls_scores = []
+        bbox_preds = []
+        for idx, (x, scale, stride) in enumerate(
+                zip(feats, self.scales, self.prior_generator.strides)):
+            b, c, h, w = x.shape
+            anchor = self.prior_generator.single_level_grid_priors(
+                (h, w), idx, device=x.device)
+            anchor = torch.cat([anchor for _ in range(b)])
+            # extract task interactive features
+            inter_feats = []
+            for inter_conv in self.inter_convs:
+                x = inter_conv(x)
+                inter_feats.append(x)
+            feat = torch.cat(inter_feats, 1)
+
+            # task decomposition
+            avg_feat = F.adaptive_avg_pool2d(feat, (1, 1))
+            cls_feat = self.cls_decomp(feat, avg_feat)
+            reg_feat = self.reg_decomp(feat, avg_feat)
+
+            # cls prediction and alignment
+            cls_logits = self.tood_cls(cls_feat)
+            cls_prob = self.cls_prob_module(feat)
+            cls_score = sigmoid_geometric_mean(cls_logits, cls_prob)
+
+            # reg prediction and alignment
+            if self.anchor_type == 'anchor_free':
+                reg_dist = scale(self.tood_reg(reg_feat).exp()).float()
+                reg_dist = reg_dist.permute(0, 2, 3, 1).reshape(-1, 4)
+                reg_bbox = distance2bbox(
+                    self.anchor_center(anchor) / stride[0],
+                    reg_dist).reshape(b, h, w, 4).permute(0, 3, 1,
+                                                          2)  # (b, c, h, w)
+            elif self.anchor_type == 'anchor_based':
+                reg_dist = scale(self.tood_reg(reg_feat)).float()
+                reg_dist = reg_dist.permute(0, 2, 3, 1).reshape(-1, 4)
+                reg_bbox = self.bbox_coder.decode(anchor, reg_dist).reshape(
+                    b, h, w, 4).permute(0, 3, 1, 2) / stride[0]
+            else:
+                raise NotImplementedError(
+                    f'Unknown anchor type: {self.anchor_type}.'
+                    f'Please use `anchor_free` or `anchor_based`.')
+            reg_offset = self.reg_offset_module(feat)
+            bbox_pred = self.deform_sampling(reg_bbox.contiguous(),
+                                             reg_offset.contiguous())
+
+            # After deform_sampling, some boxes will become invalid (The
+            # left-top point is at the right or bottom of the right-bottom
+            # point), which will make the GIoULoss negative.
+            invalid_bbox_idx = (bbox_pred[:, [0]] > bbox_pred[:, [2]]) | \
+                               (bbox_pred[:, [1]] > bbox_pred[:, [3]])
+            invalid_bbox_idx = invalid_bbox_idx.expand_as(bbox_pred)
+            bbox_pred = torch.where(invalid_bbox_idx, reg_bbox, bbox_pred)
+
+            cls_scores.append(cls_score)
+            bbox_preds.append(bbox_pred)
+        return tuple(cls_scores), tuple(bbox_preds)
+
+    def deform_sampling(self, feat: Tensor, offset: Tensor) -> Tensor:
+        """Sampling the feature x according to offset.
+
+        Args:
+            feat (Tensor): Feature
+            offset (Tensor): Spatial offset for feature sampling
+        """
+        # it is an equivalent implementation of bilinear interpolation
+        b, c, h, w = feat.shape
+        weight = feat.new_ones(c, 1, 1, 1)
+        y = deform_conv2d(feat, offset, weight, 1, 0, 1, c, c)
+        return y
+
+    def anchor_center(self, anchors: Tensor) -> Tensor:
+        """Get anchor centers from anchors.
+
+        Args:
+            anchors (Tensor): Anchor list with shape (N, 4), "xyxy" format.
+
+        Returns:
+            Tensor: Anchor centers with shape (N, 2), "xy" format.
+        """
+        anchors_cx = (anchors[:, 2] + anchors[:, 0]) / 2
+        anchors_cy = (anchors[:, 3] + anchors[:, 1]) / 2
+        return torch.stack([anchors_cx, anchors_cy], dim=-1)
+
+    def loss_by_feat_single(self, anchors: Tensor, cls_score: Tensor,
+                            bbox_pred: Tensor, labels: Tensor,
+                            label_weights: Tensor, bbox_targets: Tensor,
+                            alignment_metrics: Tensor,
+                            stride: Tuple[int, int]) -> dict:
+        """Calculate the loss of a single scale level based on the features
+        extracted by the detection head.
+
+        Args:
+            anchors (Tensor): Box reference for each scale level with shape
+                (N, num_total_anchors, 4).
+            cls_score (Tensor): Box scores for each scale level
+                Has shape (N, num_anchors * num_classes, H, W).
+            bbox_pred (Tensor): Decoded bboxes for each scale
+                level with shape (N, num_anchors * 4, H, W).
+            labels (Tensor): Labels of each anchors with shape
+                (N, num_total_anchors).
+            label_weights (Tensor): Label weights of each anchor with shape
+                (N, num_total_anchors).
+            bbox_targets (Tensor): BBox regression targets of each anchor with
+                shape (N, num_total_anchors, 4).
+            alignment_metrics (Tensor): Alignment metrics with shape
+                (N, num_total_anchors).
+            stride (Tuple[int, int]): Downsample stride of the feature map.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        assert stride[0] == stride[1], 'h stride is not equal to w stride!'
+        anchors = anchors.reshape(-1, 4)
+        cls_score = cls_score.permute(0, 2, 3, 1).reshape(
+            -1, self.cls_out_channels).contiguous()
+        bbox_pred = bbox_pred.permute(0, 2, 3, 1).reshape(-1, 4)
+        bbox_targets = bbox_targets.reshape(-1, 4)
+        labels = labels.reshape(-1)
+        alignment_metrics = alignment_metrics.reshape(-1)
+        label_weights = label_weights.reshape(-1)
+        targets = labels if self.epoch < self.initial_epoch else (
+            labels, alignment_metrics)
+        cls_loss_func = self.initial_loss_cls \
+            if self.epoch < self.initial_epoch else self.loss_cls
+
+        loss_cls = cls_loss_func(
+            cls_score, targets, label_weights, avg_factor=1.0)
+
+        # FG cat_id: [0, num_classes -1], BG cat_id: num_classes
+        bg_class_ind = self.num_classes
+        pos_inds = ((labels >= 0)
+                    & (labels < bg_class_ind)).nonzero().squeeze(1)
+
+        if len(pos_inds) > 0:
+            pos_bbox_targets = bbox_targets[pos_inds]
+            pos_bbox_pred = bbox_pred[pos_inds]
+            pos_anchors = anchors[pos_inds]
+
+            pos_decode_bbox_pred = pos_bbox_pred
+            pos_decode_bbox_targets = pos_bbox_targets / stride[0]
+
+            # regression loss
+            pos_bbox_weight = self.centerness_target(
+                pos_anchors, pos_bbox_targets
+            ) if self.epoch < self.initial_epoch else alignment_metrics[
+                pos_inds]
+
+            loss_bbox = self.loss_bbox(
+                pos_decode_bbox_pred,
+                pos_decode_bbox_targets,
+                weight=pos_bbox_weight,
+                avg_factor=1.0)
+        else:
+            loss_bbox = bbox_pred.sum() * 0
+            pos_bbox_weight = bbox_targets.new_tensor(0.)
+
+        return loss_cls, loss_bbox, alignment_metrics.sum(
+        ), pos_bbox_weight.sum()
+
+    def loss_by_feat(
+            self,
+            cls_scores: List[Tensor],
+            bbox_preds: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> dict:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level
+                Has shape (N, num_anchors * num_classes, H, W)
+            bbox_preds (list[Tensor]): Decoded box for each scale
+                level with shape (N, num_anchors * 4, H, W) in
+                [tl_x, tl_y, br_x, br_y] format.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], Optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        num_imgs = len(batch_img_metas)
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        assert len(featmap_sizes) == self.prior_generator.num_levels
+
+        device = cls_scores[0].device
+        anchor_list, valid_flag_list = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+
+        flatten_cls_scores = torch.cat([
+            cls_score.permute(0, 2, 3, 1).reshape(num_imgs, -1,
+                                                  self.cls_out_channels)
+            for cls_score in cls_scores
+        ], 1)
+        flatten_bbox_preds = torch.cat([
+            bbox_pred.permute(0, 2, 3, 1).reshape(num_imgs, -1, 4) * stride[0]
+            for bbox_pred, stride in zip(bbox_preds,
+                                         self.prior_generator.strides)
+        ], 1)
+
+        cls_reg_targets = self.get_targets(
+            flatten_cls_scores,
+            flatten_bbox_preds,
+            anchor_list,
+            valid_flag_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore)
+        (anchor_list, labels_list, label_weights_list, bbox_targets_list,
+         alignment_metrics_list) = cls_reg_targets
+
+        losses_cls, losses_bbox, \
+            cls_avg_factors, bbox_avg_factors = multi_apply(
+                self.loss_by_feat_single,
+                anchor_list,
+                cls_scores,
+                bbox_preds,
+                labels_list,
+                label_weights_list,
+                bbox_targets_list,
+                alignment_metrics_list,
+                self.prior_generator.strides)
+
+        cls_avg_factor = reduce_mean(sum(cls_avg_factors)).clamp_(min=1).item()
+        losses_cls = list(map(lambda x: x / cls_avg_factor, losses_cls))
+
+        bbox_avg_factor = reduce_mean(
+            sum(bbox_avg_factors)).clamp_(min=1).item()
+        losses_bbox = list(map(lambda x: x / bbox_avg_factor, losses_bbox))
+        return dict(loss_cls=losses_cls, loss_bbox=losses_bbox)
+
+    def _predict_by_feat_single(self,
+                                cls_score_list: List[Tensor],
+                                bbox_pred_list: List[Tensor],
+                                score_factor_list: List[Tensor],
+                                mlvl_priors: List[Tensor],
+                                img_meta: dict,
+                                cfg: Optional[ConfigDict] = None,
+                                rescale: bool = False,
+                                with_nms: bool = True) -> InstanceData:
+        """Transform a single image's features extracted from the head into
+        bbox results.
+
+        Args:
+            cls_score_list (list[Tensor]): Box scores from all scale
+                levels of a single image, each item has shape
+                (num_priors * num_classes, H, W).
+            bbox_pred_list (list[Tensor]): Box energies / deltas from
+                all scale levels of a single image, each item has shape
+                (num_priors * 4, H, W).
+            score_factor_list (list[Tensor]): Score factor from all scale
+                levels of a single image, each item has shape
+                (num_priors * 1, H, W).
+            mlvl_priors (list[Tensor]): Each element in the list is
+                the priors of a single level in feature pyramid. In all
+                anchor-based methods, it has shape (num_priors, 4). In
+                all anchor-free methods, it has shape (num_priors, 2)
+                when `with_stride=True`, otherwise it still has shape
+                (num_priors, 4).
+            img_meta (dict): Image meta info.
+            cfg (:obj:`ConfigDict`, optional): Test / postprocessing
+                configuration, if None, test_cfg would be used.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            with_nms (bool): If True, do nms before return boxes.
+                Defaults to True.
+
+        Returns:
+            tuple[Tensor]: Results of detected bboxes and labels. If with_nms
+                is False and mlvl_score_factor is None, return mlvl_bboxes and
+                mlvl_scores, else return mlvl_bboxes, mlvl_scores and
+                mlvl_score_factor. Usually with_nms is False is used for aug
+                test. If with_nms is True, then return the following format
+
+                - det_bboxes (Tensor): Predicted bboxes with shape \
+                    [num_bboxes, 5], where the first 4 columns are bounding \
+                    box positions (tl_x, tl_y, br_x, br_y) and the 5-th \
+                    column are scores between 0 and 1.
+                - det_labels (Tensor): Predicted labels of the corresponding \
+                    box with shape [num_bboxes].
+        """
+
+        cfg = self.test_cfg if cfg is None else cfg
+        nms_pre = cfg.get('nms_pre', -1)
+
+        mlvl_bboxes = []
+        mlvl_scores = []
+        mlvl_labels = []
+        for cls_score, bbox_pred, priors, stride in zip(
+                cls_score_list, bbox_pred_list, mlvl_priors,
+                self.prior_generator.strides):
+            assert cls_score.size()[-2:] == bbox_pred.size()[-2:]
+
+            bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, 4) * stride[0]
+            scores = cls_score.permute(1, 2,
+                                       0).reshape(-1, self.cls_out_channels)
+
+            # After https://github.com/open-mmlab/mmdetection/pull/6268/,
+            # this operation keeps fewer bboxes under the same `nms_pre`.
+            # There is no difference in performance for most models. If you
+            # find a slight drop in performance, you can set a larger
+            # `nms_pre` than before.
+            results = filter_scores_and_topk(
+                scores, cfg.score_thr, nms_pre,
+                dict(bbox_pred=bbox_pred, priors=priors))
+            scores, labels, keep_idxs, filtered_results = results
+
+            bboxes = filtered_results['bbox_pred']
+
+            mlvl_bboxes.append(bboxes)
+            mlvl_scores.append(scores)
+            mlvl_labels.append(labels)
+
+        results = InstanceData()
+        results.bboxes = torch.cat(mlvl_bboxes)
+        results.scores = torch.cat(mlvl_scores)
+        results.labels = torch.cat(mlvl_labels)
+
+        return self._bbox_post_process(
+            results=results,
+            cfg=cfg,
+            rescale=rescale,
+            with_nms=with_nms,
+            img_meta=img_meta)
+
+    def get_targets(self,
+                    cls_scores: List[List[Tensor]],
+                    bbox_preds: List[List[Tensor]],
+                    anchor_list: List[List[Tensor]],
+                    valid_flag_list: List[List[Tensor]],
+                    batch_gt_instances: InstanceList,
+                    batch_img_metas: List[dict],
+                    batch_gt_instances_ignore: OptInstanceList = None,
+                    unmap_outputs: bool = True) -> tuple:
+        """Compute regression and classification targets for anchors in
+        multiple images.
+
+        Args:
+            cls_scores (list[list[Tensor]]): Classification predictions of
+                images, a 3D-Tensor with shape [num_imgs, num_priors,
+                num_classes].
+            bbox_preds (list[list[Tensor]]): Decoded bboxes predictions of one
+                image, a 3D-Tensor with shape [num_imgs, num_priors, 4] in
+                [tl_x, tl_y, br_x, br_y] format.
+            anchor_list (list[list[Tensor]]): Multi level anchors of each
+                image. The outer list indicates images, and the inner list
+                corresponds to feature levels of the image. Each element of
+                the inner list is a tensor of shape (num_anchors, 4).
+            valid_flag_list (list[list[Tensor]]): Multi level valid flags of
+                each image. The outer list indicates images, and the inner list
+                corresponds to feature levels of the image. Each element of
+                the inner list is a tensor of shape (num_anchors, )
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], Optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+            unmap_outputs (bool): Whether to map outputs back to the original
+                set of anchors.
+
+        Returns:
+            tuple: a tuple containing learning targets.
+
+                - anchors_list (list[list[Tensor]]): Anchors of each level.
+                - labels_list (list[Tensor]): Labels of each level.
+                - label_weights_list (list[Tensor]): Label weights of each
+                  level.
+                - bbox_targets_list (list[Tensor]): BBox targets of each level.
+                - norm_alignment_metrics_list (list[Tensor]): Normalized
+                  alignment metrics of each level.
+        """
+        num_imgs = len(batch_img_metas)
+        assert len(anchor_list) == len(valid_flag_list) == num_imgs
+
+        # anchor number of multi levels
+        num_level_anchors = [anchors.size(0) for anchors in anchor_list[0]]
+        num_level_anchors_list = [num_level_anchors] * num_imgs
+
+        # concat all level anchors and flags to a single tensor
+        for i in range(num_imgs):
+            assert len(anchor_list[i]) == len(valid_flag_list[i])
+            anchor_list[i] = torch.cat(anchor_list[i])
+            valid_flag_list[i] = torch.cat(valid_flag_list[i])
+
+        # compute targets for each image
+        if batch_gt_instances_ignore is None:
+            batch_gt_instances_ignore = [None] * num_imgs
+        # anchor_list: list(b * [-1, 4])
+
+        # get epoch information from message hub
+        message_hub = MessageHub.get_current_instance()
+        self.epoch = message_hub.get_info('epoch')
+
+        if self.epoch < self.initial_epoch:
+            (all_anchors, all_labels, all_label_weights, all_bbox_targets,
+             all_bbox_weights, pos_inds_list, neg_inds_list,
+             sampling_result) = multi_apply(
+                 super()._get_targets_single,
+                 anchor_list,
+                 valid_flag_list,
+                 num_level_anchors_list,
+                 batch_gt_instances,
+                 batch_img_metas,
+                 batch_gt_instances_ignore,
+                 unmap_outputs=unmap_outputs)
+            all_assign_metrics = [
+                weight[..., 0] for weight in all_bbox_weights
+            ]
+        else:
+            (all_anchors, all_labels, all_label_weights, all_bbox_targets,
+             all_assign_metrics) = multi_apply(
+                 self._get_targets_single,
+                 cls_scores,
+                 bbox_preds,
+                 anchor_list,
+                 valid_flag_list,
+                 batch_gt_instances,
+                 batch_img_metas,
+                 batch_gt_instances_ignore,
+                 unmap_outputs=unmap_outputs)
+
+        # split targets to a list w.r.t. multiple levels
+        anchors_list = images_to_levels(all_anchors, num_level_anchors)
+        labels_list = images_to_levels(all_labels, num_level_anchors)
+        label_weights_list = images_to_levels(all_label_weights,
+                                              num_level_anchors)
+        bbox_targets_list = images_to_levels(all_bbox_targets,
+                                             num_level_anchors)
+        norm_alignment_metrics_list = images_to_levels(all_assign_metrics,
+                                                       num_level_anchors)
+
+        return (anchors_list, labels_list, label_weights_list,
+                bbox_targets_list, norm_alignment_metrics_list)
+
+    def _get_targets_single(self,
+                            cls_scores: Tensor,
+                            bbox_preds: Tensor,
+                            flat_anchors: Tensor,
+                            valid_flags: Tensor,
+                            gt_instances: InstanceData,
+                            img_meta: dict,
+                            gt_instances_ignore: Optional[InstanceData] = None,
+                            unmap_outputs: bool = True) -> tuple:
+        """Compute regression, classification targets for anchors in a single
+        image.
+
+        Args:
+            cls_scores (Tensor): Box scores for each image.
+            bbox_preds (Tensor): Box energies / deltas for each image.
+            flat_anchors (Tensor): Multi-level anchors of the image, which are
+                concatenated into a single tensor of shape (num_anchors ,4)
+            valid_flags (Tensor): Multi level valid flags of the image,
+                which are concatenated into a single tensor of
+                    shape (num_anchors,).
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            img_meta (dict): Meta information for current image.
+            gt_instances_ignore (:obj:`InstanceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+            unmap_outputs (bool): Whether to map outputs back to the original
+                set of anchors.
+
+        Returns:
+            tuple: N is the number of total anchors in the image.
+                anchors (Tensor): All anchors in the image with shape (N, 4).
+                labels (Tensor): Labels of all anchors in the image with shape
+                    (N,).
+                label_weights (Tensor): Label weights of all anchor in the
+                    image with shape (N,).
+                bbox_targets (Tensor): BBox targets of all anchors in the
+                    image with shape (N, 4).
+                norm_alignment_metrics (Tensor): Normalized alignment metrics
+                    of all priors in the image with shape (N,).
+        """
+        inside_flags = anchor_inside_flags(flat_anchors, valid_flags,
+                                           img_meta['img_shape'][:2],
+                                           self.train_cfg['allowed_border'])
+        if not inside_flags.any():
+            raise ValueError(
+                'There is no valid anchor inside the image boundary. Please '
+                'check the image size and anchor sizes, or set '
+                '``allowed_border`` to -1 to skip the condition.')
+        # assign gt and sample anchors
+        anchors = flat_anchors[inside_flags, :]
+        pred_instances = InstanceData(
+            priors=anchors,
+            scores=cls_scores[inside_flags, :],
+            bboxes=bbox_preds[inside_flags, :])
+        assign_result = self.alignment_assigner.assign(pred_instances,
+                                                       gt_instances,
+                                                       gt_instances_ignore,
+                                                       self.alpha, self.beta)
+        assign_ious = assign_result.max_overlaps
+        assign_metrics = assign_result.assign_metrics
+
+        sampling_result = self.sampler.sample(assign_result, pred_instances,
+                                              gt_instances)
+
+        num_valid_anchors = anchors.shape[0]
+        bbox_targets = torch.zeros_like(anchors)
+        labels = anchors.new_full((num_valid_anchors, ),
+                                  self.num_classes,
+                                  dtype=torch.long)
+        label_weights = anchors.new_zeros(num_valid_anchors, dtype=torch.float)
+        norm_alignment_metrics = anchors.new_zeros(
+            num_valid_anchors, dtype=torch.float)
+
+        pos_inds = sampling_result.pos_inds
+        neg_inds = sampling_result.neg_inds
+        if len(pos_inds) > 0:
+            # point-based
+            pos_bbox_targets = sampling_result.pos_gt_bboxes
+            bbox_targets[pos_inds, :] = pos_bbox_targets
+
+            labels[pos_inds] = sampling_result.pos_gt_labels
+            if self.train_cfg['pos_weight'] <= 0:
+                label_weights[pos_inds] = 1.0
+            else:
+                label_weights[pos_inds] = self.train_cfg['pos_weight']
+        if len(neg_inds) > 0:
+            label_weights[neg_inds] = 1.0
+
+        class_assigned_gt_inds = torch.unique(
+            sampling_result.pos_assigned_gt_inds)
+        for gt_inds in class_assigned_gt_inds:
+            gt_class_inds = pos_inds[sampling_result.pos_assigned_gt_inds ==
+                                     gt_inds]
+            pos_alignment_metrics = assign_metrics[gt_class_inds]
+            pos_ious = assign_ious[gt_class_inds]
+            pos_norm_alignment_metrics = pos_alignment_metrics / (
+                pos_alignment_metrics.max() + 10e-8) * pos_ious.max()
+            norm_alignment_metrics[gt_class_inds] = pos_norm_alignment_metrics
+
+        # map up to original set of anchors
+        if unmap_outputs:
+            num_total_anchors = flat_anchors.size(0)
+            anchors = unmap(anchors, num_total_anchors, inside_flags)
+            labels = unmap(
+                labels, num_total_anchors, inside_flags, fill=self.num_classes)
+            label_weights = unmap(label_weights, num_total_anchors,
+                                  inside_flags)
+            bbox_targets = unmap(bbox_targets, num_total_anchors, inside_flags)
+            norm_alignment_metrics = unmap(norm_alignment_metrics,
+                                           num_total_anchors, inside_flags)
+        return (anchors, labels, label_weights, bbox_targets,
+                norm_alignment_metrics)
diff --git a/mmdetection/mmdet/models/dense_heads/vfnet_head.py b/mmdetection/mmdet/models/dense_heads/vfnet_head.py
new file mode 100644
index 00000000..430b06d0
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/vfnet_head.py
@@ -0,0 +1,722 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple, Union
+
+import numpy as np
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule, Scale
+from mmcv.ops import DeformConv2d
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.structures.bbox import bbox_overlaps
+from mmdet.utils import (ConfigType, InstanceList, MultiConfig,
+                         OptInstanceList, RangeType, reduce_mean)
+from ..task_modules.prior_generators import MlvlPointGenerator
+from ..task_modules.samplers import PseudoSampler
+from ..utils import multi_apply
+from .atss_head import ATSSHead
+from .fcos_head import FCOSHead
+
+INF = 1e8
+
+
+@MODELS.register_module()
+class VFNetHead(ATSSHead, FCOSHead):
+    """Head of `VarifocalNet (VFNet): An IoU-aware Dense Object
+    Detector.`_.
+
+    The VFNet predicts IoU-aware classification scores which mix the
+    object presence confidence and object localization accuracy as the
+    detection score. It is built on the FCOS architecture and uses ATSS
+    for defining positive/negative training examples. The VFNet is trained
+    with Varifocal Loss and empolys star-shaped deformable convolution to
+    extract features for a bbox.
+
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (int): Number of channels in the input feature map.
+        regress_ranges (Sequence[Tuple[int, int]]): Regress range of multiple
+            level points.
+        center_sampling (bool): If true, use center sampling. Defaults to False.
+        center_sample_radius (float): Radius of center sampling. Defaults to 1.5.
+        sync_num_pos (bool): If true, synchronize the number of positive
+            examples across GPUs. Defaults to True
+        gradient_mul (float): The multiplier to gradients from bbox refinement
+            and recognition. Defaults to 0.1.
+        bbox_norm_type (str): The bbox normalization type, 'reg_denom' or
+            'stride'. Defaults to reg_denom
+        loss_cls_fl (:obj:`ConfigDict` or dict): Config of focal loss.
+        use_vfl (bool): If true, use varifocal loss for training.
+            Defaults to True.
+        loss_cls (:obj:`ConfigDict` or dict): Config of varifocal loss.
+        loss_bbox (:obj:`ConfigDict` or dict): Config of localization loss,
+            GIoU Loss.
+        loss_bbox (:obj:`ConfigDict` or dict): Config of localization
+            refinement loss, GIoU Loss.
+        norm_cfg (:obj:`ConfigDict` or dict): dictionary to construct and
+            config norm layer. Defaults to norm_cfg=dict(type='GN',
+            num_groups=32, requires_grad=True).
+        use_atss (bool): If true, use ATSS to define positive/negative
+            examples. Defaults to True.
+        anchor_generator (:obj:`ConfigDict` or dict): Config of anchor
+            generator for ATSS.
+        init_cfg (:obj:`ConfigDict` or dict or list[dict] or
+            list[:obj:`ConfigDict`]): Initialization config dict.
+
+    Example:
+        >>> self = VFNetHead(11, 7)
+        >>> feats = [torch.rand(1, 7, s, s) for s in [4, 8, 16, 32, 64]]
+        >>> cls_score, bbox_pred, bbox_pred_refine= self.forward(feats)
+        >>> assert len(cls_score) == len(self.scales)
+    """  # noqa: E501
+
+    def __init__(self,
+                 num_classes: int,
+                 in_channels: int,
+                 regress_ranges: RangeType = ((-1, 64), (64, 128), (128, 256),
+                                              (256, 512), (512, INF)),
+                 center_sampling: bool = False,
+                 center_sample_radius: float = 1.5,
+                 sync_num_pos: bool = True,
+                 gradient_mul: float = 0.1,
+                 bbox_norm_type: str = 'reg_denom',
+                 loss_cls_fl: ConfigType = dict(
+                     type='FocalLoss',
+                     use_sigmoid=True,
+                     gamma=2.0,
+                     alpha=0.25,
+                     loss_weight=1.0),
+                 use_vfl: bool = True,
+                 loss_cls: ConfigType = dict(
+                     type='VarifocalLoss',
+                     use_sigmoid=True,
+                     alpha=0.75,
+                     gamma=2.0,
+                     iou_weighted=True,
+                     loss_weight=1.0),
+                 loss_bbox: ConfigType = dict(
+                     type='GIoULoss', loss_weight=1.5),
+                 loss_bbox_refine: ConfigType = dict(
+                     type='GIoULoss', loss_weight=2.0),
+                 norm_cfg: ConfigType = dict(
+                     type='GN', num_groups=32, requires_grad=True),
+                 use_atss: bool = True,
+                 reg_decoded_bbox: bool = True,
+                 anchor_generator: ConfigType = dict(
+                     type='AnchorGenerator',
+                     ratios=[1.0],
+                     octave_base_scale=8,
+                     scales_per_octave=1,
+                     center_offset=0.0,
+                     strides=[8, 16, 32, 64, 128]),
+                 init_cfg: MultiConfig = dict(
+                     type='Normal',
+                     layer='Conv2d',
+                     std=0.01,
+                     override=dict(
+                         type='Normal',
+                         name='vfnet_cls',
+                         std=0.01,
+                         bias_prob=0.01)),
+                 **kwargs) -> None:
+        # dcn base offsets, adapted from reppoints_head.py
+        self.num_dconv_points = 9
+        self.dcn_kernel = int(np.sqrt(self.num_dconv_points))
+        self.dcn_pad = int((self.dcn_kernel - 1) / 2)
+        dcn_base = np.arange(-self.dcn_pad,
+                             self.dcn_pad + 1).astype(np.float64)
+        dcn_base_y = np.repeat(dcn_base, self.dcn_kernel)
+        dcn_base_x = np.tile(dcn_base, self.dcn_kernel)
+        dcn_base_offset = np.stack([dcn_base_y, dcn_base_x], axis=1).reshape(
+            (-1))
+        self.dcn_base_offset = torch.tensor(dcn_base_offset).view(1, -1, 1, 1)
+
+        super(FCOSHead, self).__init__(
+            num_classes=num_classes,
+            in_channels=in_channels,
+            norm_cfg=norm_cfg,
+            init_cfg=init_cfg,
+            **kwargs)
+        self.regress_ranges = regress_ranges
+        self.reg_denoms = [
+            regress_range[-1] for regress_range in regress_ranges
+        ]
+        self.reg_denoms[-1] = self.reg_denoms[-2] * 2
+        self.center_sampling = center_sampling
+        self.center_sample_radius = center_sample_radius
+        self.sync_num_pos = sync_num_pos
+        self.bbox_norm_type = bbox_norm_type
+        self.gradient_mul = gradient_mul
+        self.use_vfl = use_vfl
+        if self.use_vfl:
+            self.loss_cls = MODELS.build(loss_cls)
+        else:
+            self.loss_cls = MODELS.build(loss_cls_fl)
+        self.loss_bbox = MODELS.build(loss_bbox)
+        self.loss_bbox_refine = MODELS.build(loss_bbox_refine)
+
+        # for getting ATSS targets
+        self.use_atss = use_atss
+        self.reg_decoded_bbox = reg_decoded_bbox
+        self.use_sigmoid_cls = loss_cls.get('use_sigmoid', False)
+
+        self.anchor_center_offset = anchor_generator['center_offset']
+
+        self.num_base_priors = self.prior_generator.num_base_priors[0]
+
+        if self.train_cfg:
+            self.assigner = TASK_UTILS.build(self.train_cfg['assigner'])
+            if self.train_cfg.get('sampler', None) is not None:
+                self.sampler = TASK_UTILS.build(
+                    self.train_cfg['sampler'], default_args=dict(context=self))
+            else:
+                self.sampler = PseudoSampler()
+        # only be used in `get_atss_targets` when `use_atss` is True
+        self.atss_prior_generator = TASK_UTILS.build(anchor_generator)
+
+        self.fcos_prior_generator = MlvlPointGenerator(
+            anchor_generator['strides'],
+            self.anchor_center_offset if self.use_atss else 0.5)
+
+        # In order to reuse the `get_bboxes` in `BaseDenseHead.
+        # Only be used in testing phase.
+        self.prior_generator = self.fcos_prior_generator
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        super(FCOSHead, self)._init_cls_convs()
+        super(FCOSHead, self)._init_reg_convs()
+        self.relu = nn.ReLU()
+        self.vfnet_reg_conv = ConvModule(
+            self.feat_channels,
+            self.feat_channels,
+            3,
+            stride=1,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            bias=self.conv_bias)
+        self.vfnet_reg = nn.Conv2d(self.feat_channels, 4, 3, padding=1)
+        self.scales = nn.ModuleList([Scale(1.0) for _ in self.strides])
+
+        self.vfnet_reg_refine_dconv = DeformConv2d(
+            self.feat_channels,
+            self.feat_channels,
+            self.dcn_kernel,
+            1,
+            padding=self.dcn_pad)
+        self.vfnet_reg_refine = nn.Conv2d(self.feat_channels, 4, 3, padding=1)
+        self.scales_refine = nn.ModuleList([Scale(1.0) for _ in self.strides])
+
+        self.vfnet_cls_dconv = DeformConv2d(
+            self.feat_channels,
+            self.feat_channels,
+            self.dcn_kernel,
+            1,
+            padding=self.dcn_pad)
+        self.vfnet_cls = nn.Conv2d(
+            self.feat_channels, self.cls_out_channels, 3, padding=1)
+
+    def forward(self, x: Tuple[Tensor]) -> Tuple[List[Tensor]]:
+        """Forward features from the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple:
+
+            - cls_scores (list[Tensor]): Box iou-aware scores for each scale
+              level, each is a 4D-tensor, the channel number is
+              num_points * num_classes.
+            - bbox_preds (list[Tensor]): Box offsets for each
+              scale level, each is a 4D-tensor, the channel number is
+              num_points * 4.
+            - bbox_preds_refine (list[Tensor]): Refined Box offsets for
+              each scale level, each is a 4D-tensor, the channel
+              number is num_points * 4.
+        """
+        return multi_apply(self.forward_single, x, self.scales,
+                           self.scales_refine, self.strides, self.reg_denoms)
+
+    def forward_single(self, x: Tensor, scale: Scale, scale_refine: Scale,
+                       stride: int, reg_denom: int) -> tuple:
+        """Forward features of a single scale level.
+
+        Args:
+            x (Tensor): FPN feature maps of the specified stride.
+            scale (:obj: `mmcv.cnn.Scale`): Learnable scale module to resize
+                the bbox prediction.
+            scale_refine (:obj: `mmcv.cnn.Scale`): Learnable scale module to
+                resize the refined bbox prediction.
+            stride (int): The corresponding stride for feature maps,
+                used to normalize the bbox prediction when
+                bbox_norm_type = 'stride'.
+            reg_denom (int): The corresponding regression range for feature
+                maps, only used to normalize the bbox prediction when
+                bbox_norm_type = 'reg_denom'.
+
+        Returns:
+            tuple: iou-aware cls scores for each box, bbox predictions and
+            refined bbox predictions of input feature maps.
+        """
+        cls_feat = x
+        reg_feat = x
+
+        for cls_layer in self.cls_convs:
+            cls_feat = cls_layer(cls_feat)
+
+        for reg_layer in self.reg_convs:
+            reg_feat = reg_layer(reg_feat)
+
+        # predict the bbox_pred of different level
+        reg_feat_init = self.vfnet_reg_conv(reg_feat)
+        if self.bbox_norm_type == 'reg_denom':
+            bbox_pred = scale(
+                self.vfnet_reg(reg_feat_init)).float().exp() * reg_denom
+        elif self.bbox_norm_type == 'stride':
+            bbox_pred = scale(
+                self.vfnet_reg(reg_feat_init)).float().exp() * stride
+        else:
+            raise NotImplementedError
+
+        # compute star deformable convolution offsets
+        # converting dcn_offset to reg_feat.dtype thus VFNet can be
+        # trained with FP16
+        dcn_offset = self.star_dcn_offset(bbox_pred, self.gradient_mul,
+                                          stride).to(reg_feat.dtype)
+
+        # refine the bbox_pred
+        reg_feat = self.relu(self.vfnet_reg_refine_dconv(reg_feat, dcn_offset))
+        bbox_pred_refine = scale_refine(
+            self.vfnet_reg_refine(reg_feat)).float().exp()
+        bbox_pred_refine = bbox_pred_refine * bbox_pred.detach()
+
+        # predict the iou-aware cls score
+        cls_feat = self.relu(self.vfnet_cls_dconv(cls_feat, dcn_offset))
+        cls_score = self.vfnet_cls(cls_feat)
+
+        if self.training:
+            return cls_score, bbox_pred, bbox_pred_refine
+        else:
+            return cls_score, bbox_pred_refine
+
+    def star_dcn_offset(self, bbox_pred: Tensor, gradient_mul: float,
+                        stride: int) -> Tensor:
+        """Compute the star deformable conv offsets.
+
+        Args:
+            bbox_pred (Tensor): Predicted bbox distance offsets (l, r, t, b).
+            gradient_mul (float): Gradient multiplier.
+            stride (int): The corresponding stride for feature maps,
+                used to project the bbox onto the feature map.
+
+        Returns:
+            Tensor: The offsets for deformable convolution.
+        """
+        dcn_base_offset = self.dcn_base_offset.type_as(bbox_pred)
+        bbox_pred_grad_mul = (1 - gradient_mul) * bbox_pred.detach() + \
+            gradient_mul * bbox_pred
+        # map to the feature map scale
+        bbox_pred_grad_mul = bbox_pred_grad_mul / stride
+        N, C, H, W = bbox_pred.size()
+
+        x1 = bbox_pred_grad_mul[:, 0, :, :]
+        y1 = bbox_pred_grad_mul[:, 1, :, :]
+        x2 = bbox_pred_grad_mul[:, 2, :, :]
+        y2 = bbox_pred_grad_mul[:, 3, :, :]
+        bbox_pred_grad_mul_offset = bbox_pred.new_zeros(
+            N, 2 * self.num_dconv_points, H, W)
+        bbox_pred_grad_mul_offset[:, 0, :, :] = -1.0 * y1  # -y1
+        bbox_pred_grad_mul_offset[:, 1, :, :] = -1.0 * x1  # -x1
+        bbox_pred_grad_mul_offset[:, 2, :, :] = -1.0 * y1  # -y1
+        bbox_pred_grad_mul_offset[:, 4, :, :] = -1.0 * y1  # -y1
+        bbox_pred_grad_mul_offset[:, 5, :, :] = x2  # x2
+        bbox_pred_grad_mul_offset[:, 7, :, :] = -1.0 * x1  # -x1
+        bbox_pred_grad_mul_offset[:, 11, :, :] = x2  # x2
+        bbox_pred_grad_mul_offset[:, 12, :, :] = y2  # y2
+        bbox_pred_grad_mul_offset[:, 13, :, :] = -1.0 * x1  # -x1
+        bbox_pred_grad_mul_offset[:, 14, :, :] = y2  # y2
+        bbox_pred_grad_mul_offset[:, 16, :, :] = y2  # y2
+        bbox_pred_grad_mul_offset[:, 17, :, :] = x2  # x2
+        dcn_offset = bbox_pred_grad_mul_offset - dcn_base_offset
+
+        return dcn_offset
+
+    def loss_by_feat(
+            self,
+            cls_scores: List[Tensor],
+            bbox_preds: List[Tensor],
+            bbox_preds_refine: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> dict:
+        """Compute loss of the head.
+
+        Args:
+            cls_scores (list[Tensor]): Box iou-aware scores for each scale
+                level, each is a 4D-tensor, the channel number is
+                num_points * num_classes.
+            bbox_preds (list[Tensor]): Box offsets for each
+                scale level, each is a 4D-tensor, the channel number is
+                num_points * 4.
+            bbox_preds_refine (list[Tensor]): Refined Box offsets for
+                each scale level, each is a 4D-tensor, the channel
+                number is num_points * 4.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], Optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        assert len(cls_scores) == len(bbox_preds) == len(bbox_preds_refine)
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        all_level_points = self.fcos_prior_generator.grid_priors(
+            featmap_sizes, bbox_preds[0].dtype, bbox_preds[0].device)
+        labels, label_weights, bbox_targets, bbox_weights = self.get_targets(
+            cls_scores,
+            all_level_points,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore)
+
+        num_imgs = cls_scores[0].size(0)
+        # flatten cls_scores, bbox_preds and bbox_preds_refine
+        flatten_cls_scores = [
+            cls_score.permute(0, 2, 3,
+                              1).reshape(-1,
+                                         self.cls_out_channels).contiguous()
+            for cls_score in cls_scores
+        ]
+        flatten_bbox_preds = [
+            bbox_pred.permute(0, 2, 3, 1).reshape(-1, 4).contiguous()
+            for bbox_pred in bbox_preds
+        ]
+        flatten_bbox_preds_refine = [
+            bbox_pred_refine.permute(0, 2, 3, 1).reshape(-1, 4).contiguous()
+            for bbox_pred_refine in bbox_preds_refine
+        ]
+        flatten_cls_scores = torch.cat(flatten_cls_scores)
+        flatten_bbox_preds = torch.cat(flatten_bbox_preds)
+        flatten_bbox_preds_refine = torch.cat(flatten_bbox_preds_refine)
+        flatten_labels = torch.cat(labels)
+        flatten_bbox_targets = torch.cat(bbox_targets)
+        # repeat points to align with bbox_preds
+        flatten_points = torch.cat(
+            [points.repeat(num_imgs, 1) for points in all_level_points])
+
+        # FG cat_id: [0, num_classes - 1], BG cat_id: num_classes
+        bg_class_ind = self.num_classes
+        pos_inds = torch.where(
+            ((flatten_labels >= 0) & (flatten_labels < bg_class_ind)) > 0)[0]
+        num_pos = len(pos_inds)
+
+        pos_bbox_preds = flatten_bbox_preds[pos_inds]
+        pos_bbox_preds_refine = flatten_bbox_preds_refine[pos_inds]
+        pos_labels = flatten_labels[pos_inds]
+
+        # sync num_pos across all gpus
+        if self.sync_num_pos:
+            num_pos_avg_per_gpu = reduce_mean(
+                pos_inds.new_tensor(num_pos).float()).item()
+            num_pos_avg_per_gpu = max(num_pos_avg_per_gpu, 1.0)
+        else:
+            num_pos_avg_per_gpu = num_pos
+
+        pos_bbox_targets = flatten_bbox_targets[pos_inds]
+        pos_points = flatten_points[pos_inds]
+
+        pos_decoded_bbox_preds = self.bbox_coder.decode(
+            pos_points, pos_bbox_preds)
+        pos_decoded_target_preds = self.bbox_coder.decode(
+            pos_points, pos_bbox_targets)
+        iou_targets_ini = bbox_overlaps(
+            pos_decoded_bbox_preds,
+            pos_decoded_target_preds.detach(),
+            is_aligned=True).clamp(min=1e-6)
+        bbox_weights_ini = iou_targets_ini.clone().detach()
+        bbox_avg_factor_ini = reduce_mean(
+            bbox_weights_ini.sum()).clamp_(min=1).item()
+
+        pos_decoded_bbox_preds_refine = \
+            self.bbox_coder.decode(pos_points, pos_bbox_preds_refine)
+        iou_targets_rf = bbox_overlaps(
+            pos_decoded_bbox_preds_refine,
+            pos_decoded_target_preds.detach(),
+            is_aligned=True).clamp(min=1e-6)
+        bbox_weights_rf = iou_targets_rf.clone().detach()
+        bbox_avg_factor_rf = reduce_mean(
+            bbox_weights_rf.sum()).clamp_(min=1).item()
+
+        if num_pos > 0:
+            loss_bbox = self.loss_bbox(
+                pos_decoded_bbox_preds,
+                pos_decoded_target_preds.detach(),
+                weight=bbox_weights_ini,
+                avg_factor=bbox_avg_factor_ini)
+
+            loss_bbox_refine = self.loss_bbox_refine(
+                pos_decoded_bbox_preds_refine,
+                pos_decoded_target_preds.detach(),
+                weight=bbox_weights_rf,
+                avg_factor=bbox_avg_factor_rf)
+
+            # build IoU-aware cls_score targets
+            if self.use_vfl:
+                pos_ious = iou_targets_rf.clone().detach()
+                cls_iou_targets = torch.zeros_like(flatten_cls_scores)
+                cls_iou_targets[pos_inds, pos_labels] = pos_ious
+        else:
+            loss_bbox = pos_bbox_preds.sum() * 0
+            loss_bbox_refine = pos_bbox_preds_refine.sum() * 0
+            if self.use_vfl:
+                cls_iou_targets = torch.zeros_like(flatten_cls_scores)
+
+        if self.use_vfl:
+            loss_cls = self.loss_cls(
+                flatten_cls_scores,
+                cls_iou_targets,
+                avg_factor=num_pos_avg_per_gpu)
+        else:
+            loss_cls = self.loss_cls(
+                flatten_cls_scores,
+                flatten_labels,
+                weight=label_weights,
+                avg_factor=num_pos_avg_per_gpu)
+
+        return dict(
+            loss_cls=loss_cls,
+            loss_bbox=loss_bbox,
+            loss_bbox_rf=loss_bbox_refine)
+
+    def get_targets(
+            self,
+            cls_scores: List[Tensor],
+            mlvl_points: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> tuple:
+        """A wrapper for computing ATSS and FCOS targets for points in multiple
+        images.
+
+        Args:
+            cls_scores (list[Tensor]): Box iou-aware scores for each scale
+                level with shape (N, num_points * num_classes, H, W).
+            mlvl_points (list[Tensor]): Points of each fpn level, each has
+                shape (num_points, 2).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], Optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            tuple:
+
+            - labels_list (list[Tensor]): Labels of each level.
+            - label_weights (Tensor/None): Label weights of all levels.
+            - bbox_targets_list (list[Tensor]): Regression targets of each
+              level, (l, t, r, b).
+            - bbox_weights (Tensor/None): Bbox weights of all levels.
+        """
+        if self.use_atss:
+            return self.get_atss_targets(cls_scores, mlvl_points,
+                                         batch_gt_instances, batch_img_metas,
+                                         batch_gt_instances_ignore)
+        else:
+            self.norm_on_bbox = False
+            return self.get_fcos_targets(mlvl_points, batch_gt_instances)
+
+    def _get_targets_single(self, *args, **kwargs):
+        """Avoid ambiguity in multiple inheritance."""
+        if self.use_atss:
+            return ATSSHead._get_targets_single(self, *args, **kwargs)
+        else:
+            return FCOSHead._get_targets_single(self, *args, **kwargs)
+
+    def get_fcos_targets(self, points: List[Tensor],
+                         batch_gt_instances: InstanceList) -> tuple:
+        """Compute FCOS regression and classification targets for points in
+        multiple images.
+
+        Args:
+            points (list[Tensor]): Points of each fpn level, each has shape
+                (num_points, 2).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+
+        Returns:
+            tuple:
+
+            - labels (list[Tensor]): Labels of each level.
+            - label_weights: None, to be compatible with ATSS targets.
+            - bbox_targets (list[Tensor]): BBox targets of each level.
+            - bbox_weights: None, to be compatible with ATSS targets.
+        """
+        labels, bbox_targets = FCOSHead.get_targets(self, points,
+                                                    batch_gt_instances)
+        label_weights = None
+        bbox_weights = None
+        return labels, label_weights, bbox_targets, bbox_weights
+
+    def get_anchors(self,
+                    featmap_sizes: List[Tuple],
+                    batch_img_metas: List[dict],
+                    device: str = 'cuda') -> tuple:
+        """Get anchors according to feature map sizes.
+
+        Args:
+            featmap_sizes (list[tuple]): Multi-level feature map sizes.
+            batch_img_metas (list[dict]): Image meta info.
+            device (str): Device for returned tensors
+
+        Returns:
+            tuple:
+
+            - anchor_list (list[Tensor]): Anchors of each image.
+            - valid_flag_list (list[Tensor]): Valid flags of each image.
+        """
+        num_imgs = len(batch_img_metas)
+
+        # since feature map sizes of all images are the same, we only compute
+        # anchors for one time
+        multi_level_anchors = self.atss_prior_generator.grid_priors(
+            featmap_sizes, device=device)
+        anchor_list = [multi_level_anchors for _ in range(num_imgs)]
+
+        # for each image, we compute valid flags of multi level anchors
+        valid_flag_list = []
+        for img_id, img_meta in enumerate(batch_img_metas):
+            multi_level_flags = self.atss_prior_generator.valid_flags(
+                featmap_sizes, img_meta['pad_shape'], device=device)
+            valid_flag_list.append(multi_level_flags)
+
+        return anchor_list, valid_flag_list
+
+    def get_atss_targets(
+            self,
+            cls_scores: List[Tensor],
+            mlvl_points: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> tuple:
+        """A wrapper for computing ATSS targets for points in multiple images.
+
+        Args:
+            cls_scores (list[Tensor]): Box iou-aware scores for each scale
+                level with shape (N, num_points * num_classes, H, W).
+            mlvl_points (list[Tensor]): Points of each fpn level, each has
+                shape (num_points, 2).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], Optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            tuple:
+
+            - labels_list (list[Tensor]): Labels of each level.
+            - label_weights (Tensor): Label weights of all levels.
+            - bbox_targets_list (list[Tensor]): Regression targets of each
+              level, (l, t, r, b).
+            - bbox_weights (Tensor): Bbox weights of all levels.
+        """
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        assert len(
+            featmap_sizes
+        ) == self.atss_prior_generator.num_levels == \
+            self.fcos_prior_generator.num_levels
+
+        device = cls_scores[0].device
+
+        anchor_list, valid_flag_list = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+
+        cls_reg_targets = ATSSHead.get_targets(
+            self,
+            anchor_list,
+            valid_flag_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore,
+            unmap_outputs=True)
+
+        (anchor_list, labels_list, label_weights_list, bbox_targets_list,
+         bbox_weights_list, avg_factor) = cls_reg_targets
+
+        bbox_targets_list = [
+            bbox_targets.reshape(-1, 4) for bbox_targets in bbox_targets_list
+        ]
+
+        num_imgs = len(batch_img_metas)
+        # transform bbox_targets (x1, y1, x2, y2) into (l, t, r, b) format
+        bbox_targets_list = self.transform_bbox_targets(
+            bbox_targets_list, mlvl_points, num_imgs)
+
+        labels_list = [labels.reshape(-1) for labels in labels_list]
+        label_weights_list = [
+            label_weights.reshape(-1) for label_weights in label_weights_list
+        ]
+        bbox_weights_list = [
+            bbox_weights.reshape(-1) for bbox_weights in bbox_weights_list
+        ]
+        label_weights = torch.cat(label_weights_list)
+        bbox_weights = torch.cat(bbox_weights_list)
+        return labels_list, label_weights, bbox_targets_list, bbox_weights
+
+    def transform_bbox_targets(self, decoded_bboxes: List[Tensor],
+                               mlvl_points: List[Tensor],
+                               num_imgs: int) -> List[Tensor]:
+        """Transform bbox_targets (x1, y1, x2, y2) into (l, t, r, b) format.
+
+        Args:
+            decoded_bboxes (list[Tensor]): Regression targets of each level,
+                in the form of (x1, y1, x2, y2).
+            mlvl_points (list[Tensor]): Points of each fpn level, each has
+                shape (num_points, 2).
+            num_imgs (int): the number of images in a batch.
+
+        Returns:
+            bbox_targets (list[Tensor]): Regression targets of each level in
+                the form of (l, t, r, b).
+        """
+        # TODO: Re-implemented in Class PointCoder
+        assert len(decoded_bboxes) == len(mlvl_points)
+        num_levels = len(decoded_bboxes)
+        mlvl_points = [points.repeat(num_imgs, 1) for points in mlvl_points]
+        bbox_targets = []
+        for i in range(num_levels):
+            bbox_target = self.bbox_coder.encode(mlvl_points[i],
+                                                 decoded_bboxes[i])
+            bbox_targets.append(bbox_target)
+
+        return bbox_targets
+
+    def _load_from_state_dict(self, state_dict: dict, prefix: str,
+                              local_metadata: dict, strict: bool,
+                              missing_keys: Union[List[str], str],
+                              unexpected_keys: Union[List[str], str],
+                              error_msgs: Union[List[str], str]) -> None:
+        """Override the method in the parent class to avoid changing para's
+        name."""
+        pass
diff --git a/mmdetection/mmdet/models/dense_heads/yolact_head.py b/mmdetection/mmdet/models/dense_heads/yolact_head.py
new file mode 100644
index 00000000..3390c136
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/yolact_head.py
@@ -0,0 +1,1193 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+from typing import List, Optional
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule, ModuleList
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import (ConfigType, InstanceList, OptConfigType,
+                         OptInstanceList, OptMultiConfig)
+from ..layers import fast_nms
+from ..utils import images_to_levels, multi_apply, select_single_mlvl
+from ..utils.misc import empty_instances
+from .anchor_head import AnchorHead
+from .base_mask_head import BaseMaskHead
+
+
+@MODELS.register_module()
+class YOLACTHead(AnchorHead):
+    """YOLACT box head used in https://arxiv.org/abs/1904.02689.
+
+    Note that YOLACT head is a light version of RetinaNet head.
+    Four differences are described as follows:
+
+    1. YOLACT box head has three-times fewer anchors.
+    2. YOLACT box head shares the convs for box and cls branches.
+    3. YOLACT box head uses OHEM instead of Focal loss.
+    4. YOLACT box head predicts a set of mask coefficients for each box.
+
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (int): Number of channels in the input feature map.
+        anchor_generator (:obj:`ConfigDict` or dict): Config dict for
+            anchor generator
+        loss_cls (:obj:`ConfigDict` or dict): Config of classification loss.
+        loss_bbox (:obj:`ConfigDict` or dict): Config of localization loss.
+        num_head_convs (int): Number of the conv layers shared by
+            box and cls branches.
+        num_protos (int): Number of the mask coefficients.
+        use_ohem (bool): If true, ``loss_single_OHEM`` will be used for
+            cls loss calculation. If false, ``loss_single`` will be used.
+        conv_cfg (:obj:`ConfigDict` or dict, optional): Dictionary to
+            construct and config conv layer.
+        norm_cfg (:obj:`ConfigDict` or dict, optional): Dictionary to
+            construct and config norm layer.
+        init_cfg (:obj:`ConfigDict` or list[:obj:`ConfigDict`] or dict or
+            list[dict], optional): Initialization config dict.
+    """
+
+    def __init__(self,
+                 num_classes: int,
+                 in_channels: int,
+                 anchor_generator: ConfigType = dict(
+                     type='AnchorGenerator',
+                     octave_base_scale=3,
+                     scales_per_octave=1,
+                     ratios=[0.5, 1.0, 2.0],
+                     strides=[8, 16, 32, 64, 128]),
+                 loss_cls: ConfigType = dict(
+                     type='CrossEntropyLoss',
+                     use_sigmoid=False,
+                     reduction='none',
+                     loss_weight=1.0),
+                 loss_bbox: ConfigType = dict(
+                     type='SmoothL1Loss', beta=1.0, loss_weight=1.5),
+                 num_head_convs: int = 1,
+                 num_protos: int = 32,
+                 use_ohem: bool = True,
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: OptConfigType = None,
+                 init_cfg: OptMultiConfig = dict(
+                     type='Xavier',
+                     distribution='uniform',
+                     bias=0,
+                     layer='Conv2d'),
+                 **kwargs) -> None:
+        self.num_head_convs = num_head_convs
+        self.num_protos = num_protos
+        self.use_ohem = use_ohem
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        super().__init__(
+            num_classes=num_classes,
+            in_channels=in_channels,
+            loss_cls=loss_cls,
+            loss_bbox=loss_bbox,
+            anchor_generator=anchor_generator,
+            init_cfg=init_cfg,
+            **kwargs)
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        self.relu = nn.ReLU(inplace=True)
+        self.head_convs = ModuleList()
+        for i in range(self.num_head_convs):
+            chn = self.in_channels if i == 0 else self.feat_channels
+            self.head_convs.append(
+                ConvModule(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg))
+        self.conv_cls = nn.Conv2d(
+            self.feat_channels,
+            self.num_base_priors * self.cls_out_channels,
+            3,
+            padding=1)
+        self.conv_reg = nn.Conv2d(
+            self.feat_channels, self.num_base_priors * 4, 3, padding=1)
+        self.conv_coeff = nn.Conv2d(
+            self.feat_channels,
+            self.num_base_priors * self.num_protos,
+            3,
+            padding=1)
+
+    def forward_single(self, x: Tensor) -> tuple:
+        """Forward feature of a single scale level.
+
+        Args:
+            x (Tensor): Features of a single scale level.
+
+        Returns:
+            tuple:
+
+            - cls_score (Tensor): Cls scores for a single scale level
+              the channels number is num_anchors * num_classes.
+            - bbox_pred (Tensor): Box energies / deltas for a single scale
+              level, the channels number is num_anchors * 4.
+            - coeff_pred (Tensor): Mask coefficients for a single scale
+              level, the channels number is num_anchors * num_protos.
+        """
+        for head_conv in self.head_convs:
+            x = head_conv(x)
+        cls_score = self.conv_cls(x)
+        bbox_pred = self.conv_reg(x)
+        coeff_pred = self.conv_coeff(x).tanh()
+        return cls_score, bbox_pred, coeff_pred
+
+    def loss_by_feat(
+            self,
+            cls_scores: List[Tensor],
+            bbox_preds: List[Tensor],
+            coeff_preds: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> dict:
+        """Calculate the loss based on the features extracted by the bbox head.
+
+        When ``self.use_ohem == True``, it functions like ``SSDHead.loss``,
+        otherwise, it follows ``AnchorHead.loss``.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level
+                has shape (N, num_anchors * num_classes, H, W).
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level with shape (N, num_anchors * 4, H, W).
+            coeff_preds (list[Tensor]): Mask coefficients for each scale
+                level with shape (N, num_anchors * num_protos, H, W)
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        assert len(featmap_sizes) == self.prior_generator.num_levels
+
+        device = cls_scores[0].device
+
+        anchor_list, valid_flag_list = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+        cls_reg_targets = self.get_targets(
+            anchor_list,
+            valid_flag_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore,
+            unmap_outputs=not self.use_ohem,
+            return_sampling_results=True)
+        (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,
+         avg_factor, sampling_results) = cls_reg_targets
+
+        if self.use_ohem:
+            num_images = len(batch_img_metas)
+            all_cls_scores = torch.cat([
+                s.permute(0, 2, 3, 1).reshape(
+                    num_images, -1, self.cls_out_channels) for s in cls_scores
+            ], 1)
+            all_labels = torch.cat(labels_list, -1).view(num_images, -1)
+            all_label_weights = torch.cat(label_weights_list,
+                                          -1).view(num_images, -1)
+            all_bbox_preds = torch.cat([
+                b.permute(0, 2, 3, 1).reshape(num_images, -1, 4)
+                for b in bbox_preds
+            ], -2)
+            all_bbox_targets = torch.cat(bbox_targets_list,
+                                         -2).view(num_images, -1, 4)
+            all_bbox_weights = torch.cat(bbox_weights_list,
+                                         -2).view(num_images, -1, 4)
+
+            # concat all level anchors to a single tensor
+            all_anchors = []
+            for i in range(num_images):
+                all_anchors.append(torch.cat(anchor_list[i]))
+
+            # check NaN and Inf
+            assert torch.isfinite(all_cls_scores).all().item(), \
+                'classification scores become infinite or NaN!'
+            assert torch.isfinite(all_bbox_preds).all().item(), \
+                'bbox predications become infinite or NaN!'
+
+            losses_cls, losses_bbox = multi_apply(
+                self.OHEMloss_by_feat_single,
+                all_cls_scores,
+                all_bbox_preds,
+                all_anchors,
+                all_labels,
+                all_label_weights,
+                all_bbox_targets,
+                all_bbox_weights,
+                avg_factor=avg_factor)
+        else:
+            # anchor number of multi levels
+            num_level_anchors = [anchors.size(0) for anchors in anchor_list[0]]
+            # concat all level anchors and flags to a single tensor
+            concat_anchor_list = []
+            for i in range(len(anchor_list)):
+                concat_anchor_list.append(torch.cat(anchor_list[i]))
+            all_anchor_list = images_to_levels(concat_anchor_list,
+                                               num_level_anchors)
+            losses_cls, losses_bbox = multi_apply(
+                self.loss_by_feat_single,
+                cls_scores,
+                bbox_preds,
+                all_anchor_list,
+                labels_list,
+                label_weights_list,
+                bbox_targets_list,
+                bbox_weights_list,
+                avg_factor=avg_factor)
+        losses = dict(loss_cls=losses_cls, loss_bbox=losses_bbox)
+        # update `_raw_positive_infos`, which will be used when calling
+        # `get_positive_infos`.
+        self._raw_positive_infos.update(coeff_preds=coeff_preds)
+        return losses
+
+    def OHEMloss_by_feat_single(self, cls_score: Tensor, bbox_pred: Tensor,
+                                anchors: Tensor, labels: Tensor,
+                                label_weights: Tensor, bbox_targets: Tensor,
+                                bbox_weights: Tensor,
+                                avg_factor: int) -> tuple:
+        """Compute loss of a single image. Similar to
+        func:``SSDHead.loss_by_feat_single``
+
+        Args:
+            cls_score (Tensor): Box scores for eachimage
+                Has shape (num_total_anchors, num_classes).
+            bbox_pred (Tensor): Box energies / deltas for each image
+                level with shape (num_total_anchors, 4).
+            anchors (Tensor): Box reference for each scale level with shape
+                (num_total_anchors, 4).
+            labels (Tensor): Labels of each anchors with shape
+                (num_total_anchors,).
+            label_weights (Tensor): Label weights of each anchor with shape
+                (num_total_anchors,)
+            bbox_targets (Tensor): BBox regression targets of each anchor with
+                shape (num_total_anchors, 4).
+            bbox_weights (Tensor): BBox regression loss weights of each anchor
+                with shape (num_total_anchors, 4).
+            avg_factor (int): Average factor that is used to average
+                the loss. When using sampling method, avg_factor is usually
+                the sum of positive and negative priors. When using
+                `PseudoSampler`, `avg_factor` is usually equal to the number
+                of positive priors.
+
+        Returns:
+            Tuple[Tensor, Tensor]: A tuple of cls loss and bbox loss of one
+            feature map.
+        """
+
+        loss_cls_all = self.loss_cls(cls_score, labels, label_weights)
+
+        # FG cat_id: [0, num_classes -1], BG cat_id: num_classes
+        pos_inds = ((labels >= 0) & (labels < self.num_classes)).nonzero(
+            as_tuple=False).reshape(-1)
+        neg_inds = (labels == self.num_classes).nonzero(
+            as_tuple=False).view(-1)
+
+        num_pos_samples = pos_inds.size(0)
+        if num_pos_samples == 0:
+            num_neg_samples = neg_inds.size(0)
+        else:
+            num_neg_samples = self.train_cfg['neg_pos_ratio'] * \
+                              num_pos_samples
+            if num_neg_samples > neg_inds.size(0):
+                num_neg_samples = neg_inds.size(0)
+        topk_loss_cls_neg, _ = loss_cls_all[neg_inds].topk(num_neg_samples)
+        loss_cls_pos = loss_cls_all[pos_inds].sum()
+        loss_cls_neg = topk_loss_cls_neg.sum()
+        loss_cls = (loss_cls_pos + loss_cls_neg) / avg_factor
+        if self.reg_decoded_bbox:
+            # When the regression loss (e.g. `IouLoss`, `GIouLoss`)
+            # is applied directly on the decoded bounding boxes, it
+            # decodes the already encoded coordinates to absolute format.
+            bbox_pred = self.bbox_coder.decode(anchors, bbox_pred)
+        loss_bbox = self.loss_bbox(
+            bbox_pred, bbox_targets, bbox_weights, avg_factor=avg_factor)
+        return loss_cls[None], loss_bbox
+
+    def get_positive_infos(self) -> InstanceList:
+        """Get positive information from sampling results.
+
+        Returns:
+            list[:obj:`InstanceData`]: Positive Information of each image,
+            usually including positive bboxes, positive labels, positive
+            priors, positive coeffs, etc.
+        """
+        assert len(self._raw_positive_infos) > 0
+        sampling_results = self._raw_positive_infos['sampling_results']
+        num_imgs = len(sampling_results)
+
+        coeff_pred_list = []
+        for coeff_pred_per_level in self._raw_positive_infos['coeff_preds']:
+            coeff_pred_per_level = \
+                coeff_pred_per_level.permute(
+                    0, 2, 3, 1).reshape(num_imgs, -1, self.num_protos)
+            coeff_pred_list.append(coeff_pred_per_level)
+        coeff_preds = torch.cat(coeff_pred_list, dim=1)
+
+        pos_info_list = []
+        for idx, sampling_result in enumerate(sampling_results):
+            pos_info = InstanceData()
+            coeff_preds_single = coeff_preds[idx]
+            pos_info.pos_assigned_gt_inds = \
+                sampling_result.pos_assigned_gt_inds
+            pos_info.pos_inds = sampling_result.pos_inds
+            pos_info.coeffs = coeff_preds_single[sampling_result.pos_inds]
+            pos_info.bboxes = sampling_result.pos_gt_bboxes
+            pos_info_list.append(pos_info)
+        return pos_info_list
+
+    def predict_by_feat(self,
+                        cls_scores,
+                        bbox_preds,
+                        coeff_preds,
+                        batch_img_metas,
+                        cfg=None,
+                        rescale=True,
+                        **kwargs):
+        """Similar to func:``AnchorHead.get_bboxes``, but additionally
+        processes coeff_preds.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level
+                with shape (N, num_anchors * num_classes, H, W)
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level with shape (N, num_anchors * 4, H, W)
+            coeff_preds (list[Tensor]): Mask coefficients for each scale
+                level with shape (N, num_anchors * num_protos, H, W)
+            batch_img_metas (list[dict]): Batch image meta info.
+            cfg (:obj:`Config` | None): Test / postprocessing configuration,
+                if None, test_cfg would be used
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to True.
+
+        Returns:
+            list[:obj:`InstanceData`]: Object detection results of each image
+            after the post process. Each item usually contains following keys.
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+                - coeffs (Tensor): the predicted mask coefficients of
+                  instance inside the corresponding box has a shape
+                  (n, num_protos).
+        """
+        assert len(cls_scores) == len(bbox_preds)
+        num_levels = len(cls_scores)
+
+        device = cls_scores[0].device
+        featmap_sizes = [cls_scores[i].shape[-2:] for i in range(num_levels)]
+        mlvl_priors = self.prior_generator.grid_priors(
+            featmap_sizes, device=device)
+
+        result_list = []
+        for img_id in range(len(batch_img_metas)):
+            img_meta = batch_img_metas[img_id]
+            cls_score_list = select_single_mlvl(cls_scores, img_id)
+            bbox_pred_list = select_single_mlvl(bbox_preds, img_id)
+            coeff_pred_list = select_single_mlvl(coeff_preds, img_id)
+            results = self._predict_by_feat_single(
+                cls_score_list=cls_score_list,
+                bbox_pred_list=bbox_pred_list,
+                coeff_preds_list=coeff_pred_list,
+                mlvl_priors=mlvl_priors,
+                img_meta=img_meta,
+                cfg=cfg,
+                rescale=rescale)
+            result_list.append(results)
+        return result_list
+
+    def _predict_by_feat_single(self,
+                                cls_score_list: List[Tensor],
+                                bbox_pred_list: List[Tensor],
+                                coeff_preds_list: List[Tensor],
+                                mlvl_priors: List[Tensor],
+                                img_meta: dict,
+                                cfg: ConfigType,
+                                rescale: bool = True) -> InstanceData:
+        """Transform a single image's features extracted from the head into
+        bbox results. Similar to func:``AnchorHead._predict_by_feat_single``,
+        but additionally processes coeff_preds_list and uses fast NMS instead
+        of traditional NMS.
+
+        Args:
+            cls_score_list (list[Tensor]): Box scores for a single scale level
+                Has shape (num_priors * num_classes, H, W).
+            bbox_pred_list (list[Tensor]): Box energies / deltas for a single
+                scale level with shape (num_priors * 4, H, W).
+            coeff_preds_list (list[Tensor]): Mask coefficients for a single
+                scale level with shape (num_priors * num_protos, H, W).
+            mlvl_priors (list[Tensor]): Each element in the list is
+                the priors of a single level in feature pyramid,
+                has shape (num_priors, 4).
+            img_meta (dict): Image meta info.
+            cfg (mmengine.Config): Test / postprocessing configuration,
+                if None, test_cfg would be used.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+                - coeffs (Tensor): the predicted mask coefficients of
+                  instance inside the corresponding box has a shape
+                  (n, num_protos).
+        """
+        assert len(cls_score_list) == len(bbox_pred_list) == len(mlvl_priors)
+
+        cfg = self.test_cfg if cfg is None else cfg
+        cfg = copy.deepcopy(cfg)
+        img_shape = img_meta['img_shape']
+        nms_pre = cfg.get('nms_pre', -1)
+
+        mlvl_bbox_preds = []
+        mlvl_valid_priors = []
+        mlvl_scores = []
+        mlvl_coeffs = []
+        for cls_score, bbox_pred, coeff_pred, priors in \
+                zip(cls_score_list, bbox_pred_list,
+                    coeff_preds_list, mlvl_priors):
+            assert cls_score.size()[-2:] == bbox_pred.size()[-2:]
+            cls_score = cls_score.permute(1, 2,
+                                          0).reshape(-1, self.cls_out_channels)
+            if self.use_sigmoid_cls:
+                scores = cls_score.sigmoid()
+            else:
+                scores = cls_score.softmax(-1)
+            bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, 4)
+            coeff_pred = coeff_pred.permute(1, 2,
+                                            0).reshape(-1, self.num_protos)
+
+            if 0 < nms_pre < scores.shape[0]:
+                # Get maximum scores for foreground classes.
+                if self.use_sigmoid_cls:
+                    max_scores, _ = scores.max(dim=1)
+                else:
+                    # remind that we set FG labels to [0, num_class-1]
+                    # since mmdet v2.0
+                    # BG cat_id: num_class
+                    max_scores, _ = scores[:, :-1].max(dim=1)
+                _, topk_inds = max_scores.topk(nms_pre)
+                priors = priors[topk_inds, :]
+                bbox_pred = bbox_pred[topk_inds, :]
+                scores = scores[topk_inds, :]
+                coeff_pred = coeff_pred[topk_inds, :]
+
+            mlvl_bbox_preds.append(bbox_pred)
+            mlvl_valid_priors.append(priors)
+            mlvl_scores.append(scores)
+            mlvl_coeffs.append(coeff_pred)
+
+        bbox_pred = torch.cat(mlvl_bbox_preds)
+        priors = torch.cat(mlvl_valid_priors)
+        multi_bboxes = self.bbox_coder.decode(
+            priors, bbox_pred, max_shape=img_shape)
+
+        multi_scores = torch.cat(mlvl_scores)
+        multi_coeffs = torch.cat(mlvl_coeffs)
+
+        return self._bbox_post_process(
+            multi_bboxes=multi_bboxes,
+            multi_scores=multi_scores,
+            multi_coeffs=multi_coeffs,
+            cfg=cfg,
+            rescale=rescale,
+            img_meta=img_meta)
+
+    def _bbox_post_process(self,
+                           multi_bboxes: Tensor,
+                           multi_scores: Tensor,
+                           multi_coeffs: Tensor,
+                           cfg: ConfigType,
+                           rescale: bool = False,
+                           img_meta: Optional[dict] = None,
+                           **kwargs) -> InstanceData:
+        """bbox post-processing method.
+
+        The boxes would be rescaled to the original image scale and do
+        the nms operation. Usually `with_nms` is False is used for aug test.
+
+        Args:
+            multi_bboxes (Tensor): Predicted bbox that concat all levels.
+            multi_scores (Tensor): Bbox scores that concat all levels.
+            multi_coeffs (Tensor): Mask coefficients  that concat all levels.
+            cfg (ConfigDict): Test / postprocessing configuration,
+                if None, test_cfg would be used.
+            rescale (bool): If True, return boxes in original image space.
+                Default to False.
+            img_meta (dict, optional): Image meta info. Defaults to None.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+                - coeffs (Tensor): the predicted mask coefficients of
+                  instance inside the corresponding box has a shape
+                  (n, num_protos).
+        """
+        if rescale:
+            assert img_meta.get('scale_factor') is not None
+            multi_bboxes /= multi_bboxes.new_tensor(
+                img_meta['scale_factor']).repeat((1, 2))
+            # mlvl_bboxes /= mlvl_bboxes.new_tensor(scale_factor)
+
+        if self.use_sigmoid_cls:
+            # Add a dummy background class to the backend when using sigmoid
+            # remind that we set FG labels to [0, num_class-1] since mmdet v2.0
+            # BG cat_id: num_class
+
+            padding = multi_scores.new_zeros(multi_scores.shape[0], 1)
+            multi_scores = torch.cat([multi_scores, padding], dim=1)
+        det_bboxes, det_labels, det_coeffs = fast_nms(
+            multi_bboxes, multi_scores, multi_coeffs, cfg.score_thr,
+            cfg.iou_thr, cfg.top_k, cfg.max_per_img)
+        results = InstanceData()
+        results.bboxes = det_bboxes[:, :4]
+        results.scores = det_bboxes[:, -1]
+        results.labels = det_labels
+        results.coeffs = det_coeffs
+        return results
+
+
+@MODELS.register_module()
+class YOLACTProtonet(BaseMaskHead):
+    """YOLACT mask head used in https://arxiv.org/abs/1904.02689.
+
+    This head outputs the mask prototypes for YOLACT.
+
+    Args:
+        in_channels (int): Number of channels in the input feature map.
+        proto_channels (tuple[int]): Output channels of protonet convs.
+        proto_kernel_sizes (tuple[int]): Kernel sizes of protonet convs.
+        include_last_relu (bool): If keep the last relu of protonet.
+        num_protos (int): Number of prototypes.
+        num_classes (int): Number of categories excluding the background
+            category.
+        loss_mask_weight (float): Reweight the mask loss by this factor.
+        max_masks_to_train (int): Maximum number of masks to train for
+            each image.
+        with_seg_branch (bool): Whether to apply a semantic segmentation
+            branch and calculate loss during training to increase
+            performance with no speed penalty. Defaults to True.
+        loss_segm (:obj:`ConfigDict` or dict, optional): Config of
+            semantic segmentation loss.
+        train_cfg (:obj:`ConfigDict` or dict, optional): Training config
+            of head.
+        test_cfg (:obj:`ConfigDict` or dict, optional): Testing config of
+            head.
+        init_cfg (:obj:`ConfigDict` or list[:obj:`ConfigDict`] or dict or
+            list[dict], optional): Initialization config dict.
+    """
+
+    def __init__(
+        self,
+        num_classes: int,
+        in_channels: int = 256,
+        proto_channels: tuple = (256, 256, 256, None, 256, 32),
+        proto_kernel_sizes: tuple = (3, 3, 3, -2, 3, 1),
+        include_last_relu: bool = True,
+        num_protos: int = 32,
+        loss_mask_weight: float = 1.0,
+        max_masks_to_train: int = 100,
+        train_cfg: OptConfigType = None,
+        test_cfg: OptConfigType = None,
+        with_seg_branch: bool = True,
+        loss_segm: ConfigType = dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
+        init_cfg=dict(
+            type='Xavier',
+            distribution='uniform',
+            override=dict(name='protonet'))
+    ) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.in_channels = in_channels
+        self.proto_channels = proto_channels
+        self.proto_kernel_sizes = proto_kernel_sizes
+        self.include_last_relu = include_last_relu
+
+        # Segmentation branch
+        self.with_seg_branch = with_seg_branch
+        self.segm_branch = SegmentationModule(
+            num_classes=num_classes, in_channels=in_channels) \
+            if with_seg_branch else None
+        self.loss_segm = MODELS.build(loss_segm) if with_seg_branch else None
+
+        self.loss_mask_weight = loss_mask_weight
+        self.num_protos = num_protos
+        self.num_classes = num_classes
+        self.max_masks_to_train = max_masks_to_train
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+        self._init_layers()
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        # Possible patterns:
+        # ( 256, 3) -> conv
+        # ( 256,-2) -> deconv
+        # (None,-2) -> bilinear interpolate
+        in_channels = self.in_channels
+        protonets = ModuleList()
+        for num_channels, kernel_size in zip(self.proto_channels,
+                                             self.proto_kernel_sizes):
+            if kernel_size > 0:
+                layer = nn.Conv2d(
+                    in_channels,
+                    num_channels,
+                    kernel_size,
+                    padding=kernel_size // 2)
+            else:
+                if num_channels is None:
+                    layer = InterpolateModule(
+                        scale_factor=-kernel_size,
+                        mode='bilinear',
+                        align_corners=False)
+                else:
+                    layer = nn.ConvTranspose2d(
+                        in_channels,
+                        num_channels,
+                        -kernel_size,
+                        padding=kernel_size // 2)
+            protonets.append(layer)
+            protonets.append(nn.ReLU(inplace=True))
+            in_channels = num_channels if num_channels is not None \
+                else in_channels
+        if not self.include_last_relu:
+            protonets = protonets[:-1]
+        self.protonet = nn.Sequential(*protonets)
+
+    def forward(self, x: tuple, positive_infos: InstanceList) -> tuple:
+        """Forward feature from the upstream network to get prototypes and
+        linearly combine the prototypes, using masks coefficients, into
+        instance masks. Finally, crop the instance masks with given bboxes.
+
+        Args:
+            x (Tuple[Tensor]): Feature from the upstream network, which is
+                a 4D-tensor.
+            positive_infos (List[:obj:``InstanceData``]): Positive information
+                that calculate from detect head.
+
+        Returns:
+            tuple: Predicted instance segmentation masks and
+            semantic segmentation map.
+        """
+        # YOLACT used single feature map to get segmentation masks
+        single_x = x[0]
+
+        # YOLACT segmentation branch, if not training or segmentation branch
+        # is None, will not process the forward function.
+        if self.segm_branch is not None and self.training:
+            segm_preds = self.segm_branch(single_x)
+        else:
+            segm_preds = None
+        # YOLACT mask head
+        prototypes = self.protonet(single_x)
+        prototypes = prototypes.permute(0, 2, 3, 1).contiguous()
+
+        num_imgs = single_x.size(0)
+
+        mask_pred_list = []
+        for idx in range(num_imgs):
+            cur_prototypes = prototypes[idx]
+            pos_coeffs = positive_infos[idx].coeffs
+
+            # Linearly combine the prototypes with the mask coefficients
+            mask_preds = cur_prototypes @ pos_coeffs.t()
+            mask_preds = torch.sigmoid(mask_preds)
+            mask_pred_list.append(mask_preds)
+        return mask_pred_list, segm_preds
+
+    def loss_by_feat(self, mask_preds: List[Tensor], segm_preds: List[Tensor],
+                     batch_gt_instances: InstanceList,
+                     batch_img_metas: List[dict], positive_infos: InstanceList,
+                     **kwargs) -> dict:
+        """Calculate the loss based on the features extracted by the mask head.
+
+        Args:
+            mask_preds (list[Tensor]): List of predicted prototypes, each has
+                shape (num_classes, H, W).
+            segm_preds (Tensor):  Predicted semantic segmentation map with
+                shape (N, num_classes, H, W)
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes``, ``masks``,
+                and ``labels`` attributes.
+            batch_img_metas (list[dict]): Meta information of multiple images.
+            positive_infos (List[:obj:``InstanceData``]): Information of
+                positive samples of each image that are assigned in detection
+                head.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        assert positive_infos is not None, \
+            'positive_infos should not be None in `YOLACTProtonet`'
+        losses = dict()
+
+        # crop
+        croped_mask_pred = self.crop_mask_preds(mask_preds, batch_img_metas,
+                                                positive_infos)
+
+        loss_mask = []
+        loss_segm = []
+        num_imgs, _, mask_h, mask_w = segm_preds.size()
+        assert num_imgs == len(croped_mask_pred)
+        segm_avg_factor = num_imgs * mask_h * mask_w
+        total_pos = 0
+
+        if self.segm_branch is not None:
+            assert segm_preds is not None
+
+        for idx in range(num_imgs):
+            img_meta = batch_img_metas[idx]
+
+            (mask_preds, pos_mask_targets, segm_targets, num_pos,
+             gt_bboxes_for_reweight) = self._get_targets_single(
+                 croped_mask_pred[idx], segm_preds[idx],
+                 batch_gt_instances[idx], positive_infos[idx])
+
+            # segmentation loss
+            if self.with_seg_branch:
+                if segm_targets is None:
+                    loss = segm_preds[idx].sum() * 0.
+                else:
+                    loss = self.loss_segm(
+                        segm_preds[idx],
+                        segm_targets,
+                        avg_factor=segm_avg_factor)
+                loss_segm.append(loss)
+            # mask loss
+            total_pos += num_pos
+            if num_pos == 0 or pos_mask_targets is None:
+                loss = mask_preds.sum() * 0.
+            else:
+                mask_preds = torch.clamp(mask_preds, 0, 1)
+                loss = F.binary_cross_entropy(
+                    mask_preds, pos_mask_targets,
+                    reduction='none') * self.loss_mask_weight
+
+                h, w = img_meta['img_shape'][:2]
+                gt_bboxes_width = (gt_bboxes_for_reweight[:, 2] -
+                                   gt_bboxes_for_reweight[:, 0]) / w
+                gt_bboxes_height = (gt_bboxes_for_reweight[:, 3] -
+                                    gt_bboxes_for_reweight[:, 1]) / h
+                loss = loss.mean(dim=(1,
+                                      2)) / gt_bboxes_width / gt_bboxes_height
+                loss = torch.sum(loss)
+            loss_mask.append(loss)
+
+        if total_pos == 0:
+            total_pos += 1  # avoid nan
+        loss_mask = [x / total_pos for x in loss_mask]
+
+        losses.update(loss_mask=loss_mask)
+        if self.with_seg_branch:
+            losses.update(loss_segm=loss_segm)
+
+        return losses
+
+    def _get_targets_single(self, mask_preds: Tensor, segm_pred: Tensor,
+                            gt_instances: InstanceData,
+                            positive_info: InstanceData):
+        """Compute targets for predictions of single image.
+
+        Args:
+            mask_preds (Tensor): Predicted prototypes with shape
+                (num_classes, H, W).
+            segm_pred (Tensor): Predicted semantic segmentation map
+                with shape (num_classes, H, W).
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It should includes ``bboxes``, ``labels``,
+                and ``masks`` attributes.
+            positive_info (:obj:`InstanceData`): Information of positive
+                samples that are assigned in detection head. It usually
+                contains following keys.
+
+                    - pos_assigned_gt_inds (Tensor): Assigner GT indexes of
+                      positive proposals, has shape (num_pos, )
+                    - pos_inds (Tensor): Positive index of image, has
+                      shape (num_pos, ).
+                    - coeffs (Tensor): Positive mask coefficients
+                      with shape (num_pos, num_protos).
+                    - bboxes (Tensor): Positive bboxes with shape
+                      (num_pos, 4)
+
+        Returns:
+            tuple: Usually returns a tuple containing learning targets.
+
+            - mask_preds (Tensor): Positive predicted mask with shape
+              (num_pos, mask_h, mask_w).
+            - pos_mask_targets (Tensor): Positive mask targets with shape
+              (num_pos, mask_h, mask_w).
+            - segm_targets (Tensor): Semantic segmentation targets with shape
+              (num_classes, segm_h, segm_w).
+            - num_pos (int): Positive numbers.
+            - gt_bboxes_for_reweight (Tensor): GT bboxes that match to the
+              positive priors has shape (num_pos, 4).
+        """
+        gt_bboxes = gt_instances.bboxes
+        gt_labels = gt_instances.labels
+        device = gt_bboxes.device
+        gt_masks = gt_instances.masks.to_tensor(
+            dtype=torch.bool, device=device).float()
+        if gt_masks.size(0) == 0:
+            return mask_preds, None, None, 0, None
+
+        # process with semantic segmentation targets
+        if segm_pred is not None:
+            num_classes, segm_h, segm_w = segm_pred.size()
+            with torch.no_grad():
+                downsampled_masks = F.interpolate(
+                    gt_masks.unsqueeze(0), (segm_h, segm_w),
+                    mode='bilinear',
+                    align_corners=False).squeeze(0)
+                downsampled_masks = downsampled_masks.gt(0.5).float()
+                segm_targets = torch.zeros_like(segm_pred, requires_grad=False)
+                for obj_idx in range(downsampled_masks.size(0)):
+                    segm_targets[gt_labels[obj_idx] - 1] = torch.max(
+                        segm_targets[gt_labels[obj_idx] - 1],
+                        downsampled_masks[obj_idx])
+        else:
+            segm_targets = None
+        # process with mask targets
+        pos_assigned_gt_inds = positive_info.pos_assigned_gt_inds
+        num_pos = pos_assigned_gt_inds.size(0)
+        # Since we're producing (near) full image masks,
+        # it'd take too much vram to backprop on every single mask.
+        # Thus we select only a subset.
+        if num_pos > self.max_masks_to_train:
+            perm = torch.randperm(num_pos)
+            select = perm[:self.max_masks_to_train]
+            mask_preds = mask_preds[select]
+            pos_assigned_gt_inds = pos_assigned_gt_inds[select]
+            num_pos = self.max_masks_to_train
+
+        gt_bboxes_for_reweight = gt_bboxes[pos_assigned_gt_inds]
+
+        mask_h, mask_w = mask_preds.shape[-2:]
+        gt_masks = F.interpolate(
+            gt_masks.unsqueeze(0), (mask_h, mask_w),
+            mode='bilinear',
+            align_corners=False).squeeze(0)
+        gt_masks = gt_masks.gt(0.5).float()
+        pos_mask_targets = gt_masks[pos_assigned_gt_inds]
+
+        return (mask_preds, pos_mask_targets, segm_targets, num_pos,
+                gt_bboxes_for_reweight)
+
+    def crop_mask_preds(self, mask_preds: List[Tensor],
+                        batch_img_metas: List[dict],
+                        positive_infos: InstanceList) -> list:
+        """Crop predicted masks by zeroing out everything not in the predicted
+        bbox.
+
+        Args:
+            mask_preds (list[Tensor]): Predicted prototypes with shape
+                (num_classes, H, W).
+            batch_img_metas (list[dict]): Meta information of multiple images.
+            positive_infos (List[:obj:``InstanceData``]): Positive
+                information that calculate from detect head.
+
+        Returns:
+            list: The cropped masks.
+        """
+        croped_mask_preds = []
+        for img_meta, mask_preds, cur_info in zip(batch_img_metas, mask_preds,
+                                                  positive_infos):
+            bboxes_for_cropping = copy.deepcopy(cur_info.bboxes)
+            h, w = img_meta['img_shape'][:2]
+            bboxes_for_cropping[:, 0::2] /= w
+            bboxes_for_cropping[:, 1::2] /= h
+            mask_preds = self.crop_single(mask_preds, bboxes_for_cropping)
+            mask_preds = mask_preds.permute(2, 0, 1).contiguous()
+            croped_mask_preds.append(mask_preds)
+        return croped_mask_preds
+
+    def crop_single(self,
+                    masks: Tensor,
+                    boxes: Tensor,
+                    padding: int = 1) -> Tensor:
+        """Crop single predicted masks by zeroing out everything not in the
+        predicted bbox.
+
+        Args:
+            masks (Tensor): Predicted prototypes, has shape [H, W, N].
+            boxes (Tensor): Bbox coords in relative point form with
+                shape [N, 4].
+            padding (int): Image padding size.
+
+        Return:
+            Tensor: The cropped masks.
+        """
+        h, w, n = masks.size()
+        x1, x2 = self.sanitize_coordinates(
+            boxes[:, 0], boxes[:, 2], w, padding, cast=False)
+        y1, y2 = self.sanitize_coordinates(
+            boxes[:, 1], boxes[:, 3], h, padding, cast=False)
+
+        rows = torch.arange(
+            w, device=masks.device, dtype=x1.dtype).view(1, -1,
+                                                         1).expand(h, w, n)
+        cols = torch.arange(
+            h, device=masks.device, dtype=x1.dtype).view(-1, 1,
+                                                         1).expand(h, w, n)
+
+        masks_left = rows >= x1.view(1, 1, -1)
+        masks_right = rows < x2.view(1, 1, -1)
+        masks_up = cols >= y1.view(1, 1, -1)
+        masks_down = cols < y2.view(1, 1, -1)
+
+        crop_mask = masks_left * masks_right * masks_up * masks_down
+
+        return masks * crop_mask.float()
+
+    def sanitize_coordinates(self,
+                             x1: Tensor,
+                             x2: Tensor,
+                             img_size: int,
+                             padding: int = 0,
+                             cast: bool = True) -> tuple:
+        """Sanitizes the input coordinates so that x1 < x2, x1 != x2, x1 >= 0,
+        and x2 <= image_size. Also converts from relative to absolute
+        coordinates and casts the results to long tensors.
+
+        Warning: this does things in-place behind the scenes so
+        copy if necessary.
+
+        Args:
+            x1 (Tensor): shape (N, ).
+            x2 (Tensor): shape (N, ).
+            img_size (int): Size of the input image.
+            padding (int): x1 >= padding, x2 <= image_size-padding.
+            cast (bool): If cast is false, the result won't be cast to longs.
+
+        Returns:
+            tuple:
+
+            - x1 (Tensor): Sanitized _x1.
+            - x2 (Tensor): Sanitized _x2.
+        """
+        x1 = x1 * img_size
+        x2 = x2 * img_size
+        if cast:
+            x1 = x1.long()
+            x2 = x2.long()
+        x1 = torch.min(x1, x2)
+        x2 = torch.max(x1, x2)
+        x1 = torch.clamp(x1 - padding, min=0)
+        x2 = torch.clamp(x2 + padding, max=img_size)
+        return x1, x2
+
+    def predict_by_feat(self,
+                        mask_preds: List[Tensor],
+                        segm_preds: Tensor,
+                        results_list: InstanceList,
+                        batch_img_metas: List[dict],
+                        rescale: bool = True,
+                        **kwargs) -> InstanceList:
+        """Transform a batch of output features extracted from the head into
+        mask results.
+
+        Args:
+            mask_preds (list[Tensor]): Predicted prototypes with shape
+                (num_classes, H, W).
+            results_list (List[:obj:``InstanceData``]): BBoxHead results.
+            batch_img_metas (list[dict]): Meta information of all images.
+            rescale (bool, optional): Whether to rescale the results.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Processed results of multiple
+            images.Each :obj:`InstanceData` usually contains
+            following keys.
+
+                - scores (Tensor): Classification scores, has shape
+                  (num_instance,).
+                - labels (Tensor): Has shape (num_instances,).
+                - masks (Tensor): Processed mask results, has
+                  shape (num_instances, h, w).
+        """
+        assert len(mask_preds) == len(results_list) == len(batch_img_metas)
+
+        croped_mask_pred = self.crop_mask_preds(mask_preds, batch_img_metas,
+                                                results_list)
+
+        for img_id in range(len(batch_img_metas)):
+            img_meta = batch_img_metas[img_id]
+            results = results_list[img_id]
+            bboxes = results.bboxes
+            mask_preds = croped_mask_pred[img_id]
+            if bboxes.shape[0] == 0 or mask_preds.shape[0] == 0:
+                results_list[img_id] = empty_instances(
+                    [img_meta],
+                    bboxes.device,
+                    task_type='mask',
+                    instance_results=[results])[0]
+            else:
+                im_mask = self._predict_by_feat_single(
+                    mask_preds=croped_mask_pred[img_id],
+                    bboxes=bboxes,
+                    img_meta=img_meta,
+                    rescale=rescale)
+                results.masks = im_mask
+        return results_list
+
+    def _predict_by_feat_single(self,
+                                mask_preds: Tensor,
+                                bboxes: Tensor,
+                                img_meta: dict,
+                                rescale: bool,
+                                cfg: OptConfigType = None):
+        """Transform a single image's features extracted from the head into
+        mask results.
+
+        Args:
+            mask_preds (Tensor): Predicted prototypes, has shape [H, W, N].
+            bboxes (Tensor): Bbox coords in relative point form with
+                shape [N, 4].
+            img_meta (dict): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            rescale (bool): If rescale is False, then returned masks will
+                fit the scale of imgs[0].
+            cfg (dict, optional): Config used in test phase.
+                Defaults to None.
+
+        Returns:
+            :obj:`InstanceData`: Processed results of single image.
+             it usually contains following keys.
+
+                - scores (Tensor): Classification scores, has shape
+                  (num_instance,).
+                - labels (Tensor): Has shape (num_instances,).
+                - masks (Tensor): Processed mask results, has
+                  shape (num_instances, h, w).
+        """
+        cfg = self.test_cfg if cfg is None else cfg
+        scale_factor = bboxes.new_tensor(img_meta['scale_factor']).repeat(
+            (1, 2))
+        img_h, img_w = img_meta['ori_shape'][:2]
+        if rescale:  # in-placed rescale the bboxes
+            scale_factor = bboxes.new_tensor(img_meta['scale_factor']).repeat(
+                (1, 2))
+            bboxes /= scale_factor
+        else:
+            w_scale, h_scale = scale_factor[0, 0], scale_factor[0, 1]
+            img_h = np.round(img_h * h_scale.item()).astype(np.int32)
+            img_w = np.round(img_w * w_scale.item()).astype(np.int32)
+
+        masks = F.interpolate(
+            mask_preds.unsqueeze(0), (img_h, img_w),
+            mode='bilinear',
+            align_corners=False).squeeze(0) > cfg.mask_thr
+
+        if cfg.mask_thr_binary < 0:
+            # for visualization and debugging
+            masks = (masks * 255).to(dtype=torch.uint8)
+
+        return masks
+
+
+class SegmentationModule(BaseModule):
+    """YOLACT segmentation branch used in `_
+
+    In mmdet v2.x `segm_loss` is calculated in YOLACTSegmHead, while in
+    mmdet v3.x `SegmentationModule` is used to obtain the predicted semantic
+    segmentation map and `segm_loss` is calculated in YOLACTProtonet.
+
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (int): Number of channels in the input feature map.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+    """
+
+    def __init__(
+        self,
+        num_classes: int,
+        in_channels: int = 256,
+        init_cfg: ConfigType = dict(
+            type='Xavier',
+            distribution='uniform',
+            override=dict(name='segm_conv'))
+    ) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.in_channels = in_channels
+        self.num_classes = num_classes
+        self._init_layers()
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        self.segm_conv = nn.Conv2d(
+            self.in_channels, self.num_classes, kernel_size=1)
+
+    def forward(self, x: Tensor) -> Tensor:
+        """Forward feature from the upstream network.
+
+        Args:
+            x (Tensor): Feature from the upstream network, which is
+                a 4D-tensor.
+
+        Returns:
+            Tensor: Predicted semantic segmentation map with shape
+                (N, num_classes, H, W).
+        """
+        return self.segm_conv(x)
+
+
+class InterpolateModule(BaseModule):
+    """This is a module version of F.interpolate.
+
+    Any arguments you give it just get passed along for the ride.
+    """
+
+    def __init__(self, *args, init_cfg=None, **kwargs) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.args = args
+        self.kwargs = kwargs
+
+    def forward(self, x: Tensor) -> Tensor:
+        """Forward features from the upstream network.
+
+        Args:
+            x (Tensor): Feature from the upstream network, which is
+                a 4D-tensor.
+
+        Returns:
+            Tensor: A 4D-tensor feature map.
+        """
+        return F.interpolate(x, *self.args, **self.kwargs)
diff --git a/mmdetection/mmdet/models/dense_heads/yolo_head.py b/mmdetection/mmdet/models/dense_heads/yolo_head.py
new file mode 100644
index 00000000..0f63afbb
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/yolo_head.py
@@ -0,0 +1,527 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# Copyright (c) 2019 Western Digital Corporation or its affiliates.
+
+import copy
+import warnings
+from typing import List, Optional, Sequence, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule, is_norm
+from mmengine.model import bias_init_with_prob, constant_init, normal_init
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.utils import (ConfigType, InstanceList, OptConfigType,
+                         OptInstanceList)
+from ..task_modules.samplers import PseudoSampler
+from ..utils import filter_scores_and_topk, images_to_levels, multi_apply
+from .base_dense_head import BaseDenseHead
+
+
+@MODELS.register_module()
+class YOLOV3Head(BaseDenseHead):
+    """YOLOV3Head Paper link: https://arxiv.org/abs/1804.02767.
+
+    Args:
+        num_classes (int): The number of object classes (w/o background)
+        in_channels (Sequence[int]): Number of input channels per scale.
+        out_channels (Sequence[int]): The number of output channels per scale
+            before the final 1x1 layer. Default: (1024, 512, 256).
+        anchor_generator (:obj:`ConfigDict` or dict): Config dict for anchor
+            generator.
+        bbox_coder (:obj:`ConfigDict` or dict): Config of bounding box coder.
+        featmap_strides (Sequence[int]): The stride of each scale.
+            Should be in descending order. Defaults to (32, 16, 8).
+        one_hot_smoother (float): Set a non-zero value to enable label-smooth
+            Defaults to 0.
+        conv_cfg (:obj:`ConfigDict` or dict, optional): Config dict for
+            convolution layer. Defaults to None.
+        norm_cfg (:obj:`ConfigDict` or dict): Dictionary to construct and
+            config norm layer. Defaults to dict(type='BN', requires_grad=True).
+        act_cfg (:obj:`ConfigDict` or dict): Config dict for activation layer.
+            Defaults to dict(type='LeakyReLU', negative_slope=0.1).
+        loss_cls (:obj:`ConfigDict` or dict): Config of classification loss.
+        loss_conf (:obj:`ConfigDict` or dict): Config of confidence loss.
+        loss_xy (:obj:`ConfigDict` or dict): Config of xy coordinate loss.
+        loss_wh (:obj:`ConfigDict` or dict): Config of wh coordinate loss.
+        train_cfg (:obj:`ConfigDict` or dict, optional): Training config of
+            YOLOV3 head. Defaults to None.
+        test_cfg (:obj:`ConfigDict` or dict, optional): Testing config of
+            YOLOV3 head. Defaults to None.
+    """
+
+    def __init__(self,
+                 num_classes: int,
+                 in_channels: Sequence[int],
+                 out_channels: Sequence[int] = (1024, 512, 256),
+                 anchor_generator: ConfigType = dict(
+                     type='YOLOAnchorGenerator',
+                     base_sizes=[[(116, 90), (156, 198), (373, 326)],
+                                 [(30, 61), (62, 45), (59, 119)],
+                                 [(10, 13), (16, 30), (33, 23)]],
+                     strides=[32, 16, 8]),
+                 bbox_coder: ConfigType = dict(type='YOLOBBoxCoder'),
+                 featmap_strides: Sequence[int] = (32, 16, 8),
+                 one_hot_smoother: float = 0.,
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: ConfigType = dict(type='BN', requires_grad=True),
+                 act_cfg: ConfigType = dict(
+                     type='LeakyReLU', negative_slope=0.1),
+                 loss_cls: ConfigType = dict(
+                     type='CrossEntropyLoss',
+                     use_sigmoid=True,
+                     loss_weight=1.0),
+                 loss_conf: ConfigType = dict(
+                     type='CrossEntropyLoss',
+                     use_sigmoid=True,
+                     loss_weight=1.0),
+                 loss_xy: ConfigType = dict(
+                     type='CrossEntropyLoss',
+                     use_sigmoid=True,
+                     loss_weight=1.0),
+                 loss_wh: ConfigType = dict(type='MSELoss', loss_weight=1.0),
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None) -> None:
+        super().__init__(init_cfg=None)
+        # Check params
+        assert (len(in_channels) == len(out_channels) == len(featmap_strides))
+
+        self.num_classes = num_classes
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.featmap_strides = featmap_strides
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+        if self.train_cfg:
+            self.assigner = TASK_UTILS.build(self.train_cfg['assigner'])
+            if train_cfg.get('sampler', None) is not None:
+                self.sampler = TASK_UTILS.build(
+                    self.train_cfg['sampler'], context=self)
+            else:
+                self.sampler = PseudoSampler()
+
+        self.one_hot_smoother = one_hot_smoother
+
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+
+        self.bbox_coder = TASK_UTILS.build(bbox_coder)
+
+        self.prior_generator = TASK_UTILS.build(anchor_generator)
+
+        self.loss_cls = MODELS.build(loss_cls)
+        self.loss_conf = MODELS.build(loss_conf)
+        self.loss_xy = MODELS.build(loss_xy)
+        self.loss_wh = MODELS.build(loss_wh)
+
+        self.num_base_priors = self.prior_generator.num_base_priors[0]
+        assert len(
+            self.prior_generator.num_base_priors) == len(featmap_strides)
+        self._init_layers()
+
+    @property
+    def num_levels(self) -> int:
+        """int: number of feature map levels"""
+        return len(self.featmap_strides)
+
+    @property
+    def num_attrib(self) -> int:
+        """int: number of attributes in pred_map, bboxes (4) +
+        objectness (1) + num_classes"""
+
+        return 5 + self.num_classes
+
+    def _init_layers(self) -> None:
+        """initialize conv layers in YOLOv3 head."""
+        self.convs_bridge = nn.ModuleList()
+        self.convs_pred = nn.ModuleList()
+        for i in range(self.num_levels):
+            conv_bridge = ConvModule(
+                self.in_channels[i],
+                self.out_channels[i],
+                3,
+                padding=1,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg)
+            conv_pred = nn.Conv2d(self.out_channels[i],
+                                  self.num_base_priors * self.num_attrib, 1)
+
+            self.convs_bridge.append(conv_bridge)
+            self.convs_pred.append(conv_pred)
+
+    def init_weights(self) -> None:
+        """initialize weights."""
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                normal_init(m, mean=0, std=0.01)
+            if is_norm(m):
+                constant_init(m, 1)
+
+        # Use prior in model initialization to improve stability
+        for conv_pred, stride in zip(self.convs_pred, self.featmap_strides):
+            bias = conv_pred.bias.reshape(self.num_base_priors, -1)
+            # init objectness with prior of 8 objects per feature map
+            # refer to https://github.com/ultralytics/yolov3
+            nn.init.constant_(bias.data[:, 4],
+                              bias_init_with_prob(8 / (608 / stride)**2))
+            nn.init.constant_(bias.data[:, 5:], bias_init_with_prob(0.01))
+
+    def forward(self, x: Tuple[Tensor, ...]) -> tuple:
+        """Forward features from the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple[Tensor]: A tuple of multi-level predication map, each is a
+                4D-tensor of shape (batch_size, 5+num_classes, height, width).
+        """
+
+        assert len(x) == self.num_levels
+        pred_maps = []
+        for i in range(self.num_levels):
+            feat = x[i]
+            feat = self.convs_bridge[i](feat)
+            pred_map = self.convs_pred[i](feat)
+            pred_maps.append(pred_map)
+
+        return tuple(pred_maps),
+
+    def predict_by_feat(self,
+                        pred_maps: Sequence[Tensor],
+                        batch_img_metas: Optional[List[dict]],
+                        cfg: OptConfigType = None,
+                        rescale: bool = False,
+                        with_nms: bool = True) -> InstanceList:
+        """Transform a batch of output features extracted from the head into
+        bbox results. It has been accelerated since PR #5991.
+
+        Args:
+            pred_maps (Sequence[Tensor]): Raw predictions for a batch of
+                images.
+            batch_img_metas (list[dict], Optional): Batch image meta info.
+                Defaults to None.
+            cfg (:obj:`ConfigDict` or dict, optional): Test / postprocessing
+                configuration, if None, test_cfg would be used.
+                Defaults to None.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            with_nms (bool): If True, do nms before return boxes.
+                Defaults to True.
+
+        Returns:
+            list[:obj:`InstanceData`]: Object detection results of each image
+            after the post process. Each item usually contains following keys.
+
+            - scores (Tensor): Classification scores, has a shape
+              (num_instance, )
+            - labels (Tensor): Labels of bboxes, has a shape
+              (num_instances, ).
+            - bboxes (Tensor): Has a shape (num_instances, 4),
+              the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        assert len(pred_maps) == self.num_levels
+        cfg = self.test_cfg if cfg is None else cfg
+        cfg = copy.deepcopy(cfg)
+
+        num_imgs = len(batch_img_metas)
+        featmap_sizes = [pred_map.shape[-2:] for pred_map in pred_maps]
+
+        mlvl_anchors = self.prior_generator.grid_priors(
+            featmap_sizes, device=pred_maps[0].device)
+        flatten_preds = []
+        flatten_strides = []
+        for pred, stride in zip(pred_maps, self.featmap_strides):
+            pred = pred.permute(0, 2, 3, 1).reshape(num_imgs, -1,
+                                                    self.num_attrib)
+            pred[..., :2].sigmoid_()
+            flatten_preds.append(pred)
+            flatten_strides.append(
+                pred.new_tensor(stride).expand(pred.size(1)))
+
+        flatten_preds = torch.cat(flatten_preds, dim=1)
+        flatten_bbox_preds = flatten_preds[..., :4]
+        flatten_objectness = flatten_preds[..., 4].sigmoid()
+        flatten_cls_scores = flatten_preds[..., 5:].sigmoid()
+        flatten_anchors = torch.cat(mlvl_anchors)
+        flatten_strides = torch.cat(flatten_strides)
+        flatten_bboxes = self.bbox_coder.decode(flatten_anchors,
+                                                flatten_bbox_preds,
+                                                flatten_strides.unsqueeze(-1))
+        results_list = []
+        for (bboxes, scores, objectness,
+             img_meta) in zip(flatten_bboxes, flatten_cls_scores,
+                              flatten_objectness, batch_img_metas):
+            # Filtering out all predictions with conf < conf_thr
+            conf_thr = cfg.get('conf_thr', -1)
+            if conf_thr > 0:
+                conf_inds = objectness >= conf_thr
+                bboxes = bboxes[conf_inds, :]
+                scores = scores[conf_inds, :]
+                objectness = objectness[conf_inds]
+
+            score_thr = cfg.get('score_thr', 0)
+            nms_pre = cfg.get('nms_pre', -1)
+            scores, labels, keep_idxs, _ = filter_scores_and_topk(
+                scores, score_thr, nms_pre)
+
+            results = InstanceData(
+                scores=scores,
+                labels=labels,
+                bboxes=bboxes[keep_idxs],
+                score_factors=objectness[keep_idxs],
+            )
+            results = self._bbox_post_process(
+                results=results,
+                cfg=cfg,
+                rescale=rescale,
+                with_nms=with_nms,
+                img_meta=img_meta)
+            results_list.append(results)
+        return results_list
+
+    def loss_by_feat(
+            self,
+            pred_maps: Sequence[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> dict:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            pred_maps (list[Tensor]): Prediction map for each scale level,
+                shape (N, num_anchors * num_attrib, H, W)
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        num_imgs = len(batch_img_metas)
+        device = pred_maps[0][0].device
+
+        featmap_sizes = [
+            pred_maps[i].shape[-2:] for i in range(self.num_levels)
+        ]
+        mlvl_anchors = self.prior_generator.grid_priors(
+            featmap_sizes, device=device)
+        anchor_list = [mlvl_anchors for _ in range(num_imgs)]
+
+        responsible_flag_list = []
+        for img_id in range(num_imgs):
+            responsible_flag_list.append(
+                self.responsible_flags(featmap_sizes,
+                                       batch_gt_instances[img_id].bboxes,
+                                       device))
+
+        target_maps_list, neg_maps_list = self.get_targets(
+            anchor_list, responsible_flag_list, batch_gt_instances)
+
+        losses_cls, losses_conf, losses_xy, losses_wh = multi_apply(
+            self.loss_by_feat_single, pred_maps, target_maps_list,
+            neg_maps_list)
+
+        return dict(
+            loss_cls=losses_cls,
+            loss_conf=losses_conf,
+            loss_xy=losses_xy,
+            loss_wh=losses_wh)
+
+    def loss_by_feat_single(self, pred_map: Tensor, target_map: Tensor,
+                            neg_map: Tensor) -> tuple:
+        """Calculate the loss of a single scale level based on the features
+        extracted by the detection head.
+
+        Args:
+            pred_map (Tensor): Raw predictions for a single level.
+            target_map (Tensor): The Ground-Truth target for a single level.
+            neg_map (Tensor): The negative masks for a single level.
+
+        Returns:
+            tuple:
+                loss_cls (Tensor): Classification loss.
+                loss_conf (Tensor): Confidence loss.
+                loss_xy (Tensor): Regression loss of x, y coordinate.
+                loss_wh (Tensor): Regression loss of w, h coordinate.
+        """
+
+        num_imgs = len(pred_map)
+        pred_map = pred_map.permute(0, 2, 3,
+                                    1).reshape(num_imgs, -1, self.num_attrib)
+        neg_mask = neg_map.float()
+        pos_mask = target_map[..., 4]
+        pos_and_neg_mask = neg_mask + pos_mask
+        pos_mask = pos_mask.unsqueeze(dim=-1)
+        if torch.max(pos_and_neg_mask) > 1.:
+            warnings.warn('There is overlap between pos and neg sample.')
+            pos_and_neg_mask = pos_and_neg_mask.clamp(min=0., max=1.)
+
+        pred_xy = pred_map[..., :2]
+        pred_wh = pred_map[..., 2:4]
+        pred_conf = pred_map[..., 4]
+        pred_label = pred_map[..., 5:]
+
+        target_xy = target_map[..., :2]
+        target_wh = target_map[..., 2:4]
+        target_conf = target_map[..., 4]
+        target_label = target_map[..., 5:]
+
+        loss_cls = self.loss_cls(pred_label, target_label, weight=pos_mask)
+        loss_conf = self.loss_conf(
+            pred_conf, target_conf, weight=pos_and_neg_mask)
+        loss_xy = self.loss_xy(pred_xy, target_xy, weight=pos_mask)
+        loss_wh = self.loss_wh(pred_wh, target_wh, weight=pos_mask)
+
+        return loss_cls, loss_conf, loss_xy, loss_wh
+
+    def get_targets(self, anchor_list: List[List[Tensor]],
+                    responsible_flag_list: List[List[Tensor]],
+                    batch_gt_instances: List[InstanceData]) -> tuple:
+        """Compute target maps for anchors in multiple images.
+
+        Args:
+            anchor_list (list[list[Tensor]]): Multi level anchors of each
+                image. The outer list indicates images, and the inner list
+                corresponds to feature levels of the image. Each element of
+                the inner list is a tensor of shape (num_total_anchors, 4).
+            responsible_flag_list (list[list[Tensor]]): Multi level responsible
+                flags of each image. Each element is a tensor of shape
+                (num_total_anchors, )
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+
+        Returns:
+            tuple: Usually returns a tuple containing learning targets.
+                - target_map_list (list[Tensor]): Target map of each level.
+                - neg_map_list (list[Tensor]): Negative map of each level.
+        """
+        num_imgs = len(anchor_list)
+
+        # anchor number of multi levels
+        num_level_anchors = [anchors.size(0) for anchors in anchor_list[0]]
+
+        results = multi_apply(self._get_targets_single, anchor_list,
+                              responsible_flag_list, batch_gt_instances)
+
+        all_target_maps, all_neg_maps = results
+        assert num_imgs == len(all_target_maps) == len(all_neg_maps)
+        target_maps_list = images_to_levels(all_target_maps, num_level_anchors)
+        neg_maps_list = images_to_levels(all_neg_maps, num_level_anchors)
+
+        return target_maps_list, neg_maps_list
+
+    def _get_targets_single(self, anchors: List[Tensor],
+                            responsible_flags: List[Tensor],
+                            gt_instances: InstanceData) -> tuple:
+        """Generate matching bounding box prior and converted GT.
+
+        Args:
+            anchors (List[Tensor]): Multi-level anchors of the image.
+            responsible_flags (List[Tensor]): Multi-level responsible flags of
+                anchors
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It should includes ``bboxes`` and ``labels``
+                attributes.
+
+        Returns:
+            tuple:
+                target_map (Tensor): Predication target map of each
+                    scale level, shape (num_total_anchors,
+                    5+num_classes)
+                neg_map (Tensor): Negative map of each scale level,
+                    shape (num_total_anchors,)
+        """
+        gt_bboxes = gt_instances.bboxes
+        gt_labels = gt_instances.labels
+        anchor_strides = []
+        for i in range(len(anchors)):
+            anchor_strides.append(
+                torch.tensor(self.featmap_strides[i],
+                             device=gt_bboxes.device).repeat(len(anchors[i])))
+        concat_anchors = torch.cat(anchors)
+        concat_responsible_flags = torch.cat(responsible_flags)
+
+        anchor_strides = torch.cat(anchor_strides)
+        assert len(anchor_strides) == len(concat_anchors) == \
+               len(concat_responsible_flags)
+        pred_instances = InstanceData(
+            priors=concat_anchors, responsible_flags=concat_responsible_flags)
+
+        assign_result = self.assigner.assign(pred_instances, gt_instances)
+        sampling_result = self.sampler.sample(assign_result, pred_instances,
+                                              gt_instances)
+
+        target_map = concat_anchors.new_zeros(
+            concat_anchors.size(0), self.num_attrib)
+
+        target_map[sampling_result.pos_inds, :4] = self.bbox_coder.encode(
+            sampling_result.pos_priors, sampling_result.pos_gt_bboxes,
+            anchor_strides[sampling_result.pos_inds])
+
+        target_map[sampling_result.pos_inds, 4] = 1
+
+        gt_labels_one_hot = F.one_hot(
+            gt_labels, num_classes=self.num_classes).float()
+        if self.one_hot_smoother != 0:  # label smooth
+            gt_labels_one_hot = gt_labels_one_hot * (
+                1 - self.one_hot_smoother
+            ) + self.one_hot_smoother / self.num_classes
+        target_map[sampling_result.pos_inds, 5:] = gt_labels_one_hot[
+            sampling_result.pos_assigned_gt_inds]
+
+        neg_map = concat_anchors.new_zeros(
+            concat_anchors.size(0), dtype=torch.uint8)
+        neg_map[sampling_result.neg_inds] = 1
+
+        return target_map, neg_map
+
+    def responsible_flags(self, featmap_sizes: List[tuple], gt_bboxes: Tensor,
+                          device: str) -> List[Tensor]:
+        """Generate responsible anchor flags of grid cells in multiple scales.
+
+        Args:
+            featmap_sizes (List[tuple]): List of feature map sizes in multiple
+                feature levels.
+            gt_bboxes (Tensor): Ground truth boxes, shape (n, 4).
+            device (str): Device where the anchors will be put on.
+
+        Return:
+            List[Tensor]: responsible flags of anchors in multiple level
+        """
+        assert self.num_levels == len(featmap_sizes)
+        multi_level_responsible_flags = []
+        for i in range(self.num_levels):
+            anchor_stride = self.prior_generator.strides[i]
+            feat_h, feat_w = featmap_sizes[i]
+            gt_cx = ((gt_bboxes[:, 0] + gt_bboxes[:, 2]) * 0.5).to(device)
+            gt_cy = ((gt_bboxes[:, 1] + gt_bboxes[:, 3]) * 0.5).to(device)
+            gt_grid_x = torch.floor(gt_cx / anchor_stride[0]).long()
+            gt_grid_y = torch.floor(gt_cy / anchor_stride[1]).long()
+            # row major indexing
+            gt_bboxes_grid_idx = gt_grid_y * feat_w + gt_grid_x
+
+            responsible_grid = torch.zeros(
+                feat_h * feat_w, dtype=torch.uint8, device=device)
+            responsible_grid[gt_bboxes_grid_idx] = 1
+
+            responsible_grid = responsible_grid[:, None].expand(
+                responsible_grid.size(0),
+                self.prior_generator.num_base_priors[i]).contiguous().view(-1)
+
+            multi_level_responsible_flags.append(responsible_grid)
+        return multi_level_responsible_flags
diff --git a/mmdetection/mmdet/models/dense_heads/yolof_head.py b/mmdetection/mmdet/models/dense_heads/yolof_head.py
new file mode 100644
index 00000000..b5e5e6b7
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/yolof_head.py
@@ -0,0 +1,399 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Tuple
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule, is_norm
+from mmengine.model import bias_init_with_prob, constant_init, normal_init
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, InstanceList, OptInstanceList, reduce_mean
+from ..task_modules.prior_generators import anchor_inside_flags
+from ..utils import levels_to_images, multi_apply, unmap
+from .anchor_head import AnchorHead
+
+INF = 1e8
+
+
+@MODELS.register_module()
+class YOLOFHead(AnchorHead):
+    """Detection Head of `YOLOF `_
+
+    Args:
+        num_classes (int): The number of object classes (w/o background)
+        in_channels (list[int]): The number of input channels per scale.
+        cls_num_convs (int): The number of convolutions of cls branch.
+           Defaults to 2.
+        reg_num_convs (int): The number of convolutions of reg branch.
+           Defaults to 4.
+        norm_cfg (:obj:`ConfigDict` or dict): Config dict for normalization
+            layer. Defaults to ``dict(type='BN', requires_grad=True)``.
+    """
+
+    def __init__(self,
+                 num_classes: int,
+                 in_channels: List[int],
+                 num_cls_convs: int = 2,
+                 num_reg_convs: int = 4,
+                 norm_cfg: ConfigType = dict(type='BN', requires_grad=True),
+                 **kwargs) -> None:
+        self.num_cls_convs = num_cls_convs
+        self.num_reg_convs = num_reg_convs
+        self.norm_cfg = norm_cfg
+        super().__init__(
+            num_classes=num_classes, in_channels=in_channels, **kwargs)
+
+    def _init_layers(self) -> None:
+        cls_subnet = []
+        bbox_subnet = []
+        for i in range(self.num_cls_convs):
+            cls_subnet.append(
+                ConvModule(
+                    self.in_channels,
+                    self.in_channels,
+                    kernel_size=3,
+                    padding=1,
+                    norm_cfg=self.norm_cfg))
+        for i in range(self.num_reg_convs):
+            bbox_subnet.append(
+                ConvModule(
+                    self.in_channels,
+                    self.in_channels,
+                    kernel_size=3,
+                    padding=1,
+                    norm_cfg=self.norm_cfg))
+        self.cls_subnet = nn.Sequential(*cls_subnet)
+        self.bbox_subnet = nn.Sequential(*bbox_subnet)
+        self.cls_score = nn.Conv2d(
+            self.in_channels,
+            self.num_base_priors * self.num_classes,
+            kernel_size=3,
+            stride=1,
+            padding=1)
+        self.bbox_pred = nn.Conv2d(
+            self.in_channels,
+            self.num_base_priors * 4,
+            kernel_size=3,
+            stride=1,
+            padding=1)
+        self.object_pred = nn.Conv2d(
+            self.in_channels,
+            self.num_base_priors,
+            kernel_size=3,
+            stride=1,
+            padding=1)
+
+    def init_weights(self) -> None:
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                normal_init(m, mean=0, std=0.01)
+            if is_norm(m):
+                constant_init(m, 1)
+
+        # Use prior in model initialization to improve stability
+        bias_cls = bias_init_with_prob(0.01)
+        torch.nn.init.constant_(self.cls_score.bias, bias_cls)
+
+    def forward_single(self, x: Tensor) -> Tuple[Tensor, Tensor]:
+        """Forward feature of a single scale level.
+
+        Args:
+            x (Tensor): Features of a single scale level.
+
+        Returns:
+            tuple:
+                normalized_cls_score (Tensor): Normalized Cls scores for a \
+                    single scale level, the channels number is \
+                    num_base_priors * num_classes.
+                bbox_reg (Tensor): Box energies / deltas for a single scale \
+                    level, the channels number is num_base_priors * 4.
+        """
+        cls_score = self.cls_score(self.cls_subnet(x))
+        N, _, H, W = cls_score.shape
+        cls_score = cls_score.view(N, -1, self.num_classes, H, W)
+
+        reg_feat = self.bbox_subnet(x)
+        bbox_reg = self.bbox_pred(reg_feat)
+        objectness = self.object_pred(reg_feat)
+
+        # implicit objectness
+        objectness = objectness.view(N, -1, 1, H, W)
+        normalized_cls_score = cls_score + objectness - torch.log(
+            1. + torch.clamp(cls_score.exp(), max=INF) +
+            torch.clamp(objectness.exp(), max=INF))
+        normalized_cls_score = normalized_cls_score.view(N, -1, H, W)
+        return normalized_cls_score, bbox_reg
+
+    def loss_by_feat(
+            self,
+            cls_scores: List[Tensor],
+            bbox_preds: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> dict:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level
+                has shape (N, num_anchors * num_classes, H, W).
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level with shape (N, num_anchors * 4, H, W).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        assert len(cls_scores) == 1
+        assert self.prior_generator.num_levels == 1
+
+        device = cls_scores[0].device
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        anchor_list, valid_flag_list = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+
+        # The output level is always 1
+        anchor_list = [anchors[0] for anchors in anchor_list]
+        valid_flag_list = [valid_flags[0] for valid_flags in valid_flag_list]
+
+        cls_scores_list = levels_to_images(cls_scores)
+        bbox_preds_list = levels_to_images(bbox_preds)
+
+        cls_reg_targets = self.get_targets(
+            cls_scores_list,
+            bbox_preds_list,
+            anchor_list,
+            valid_flag_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore)
+        if cls_reg_targets is None:
+            return None
+        (batch_labels, batch_label_weights, avg_factor, batch_bbox_weights,
+         batch_pos_predicted_boxes, batch_target_boxes) = cls_reg_targets
+
+        flatten_labels = batch_labels.reshape(-1)
+        batch_label_weights = batch_label_weights.reshape(-1)
+        cls_score = cls_scores[0].permute(0, 2, 3,
+                                          1).reshape(-1, self.cls_out_channels)
+
+        avg_factor = reduce_mean(
+            torch.tensor(avg_factor, dtype=torch.float, device=device)).item()
+
+        # classification loss
+        loss_cls = self.loss_cls(
+            cls_score,
+            flatten_labels,
+            batch_label_weights,
+            avg_factor=avg_factor)
+
+        # regression loss
+        if batch_pos_predicted_boxes.shape[0] == 0:
+            # no pos sample
+            loss_bbox = batch_pos_predicted_boxes.sum() * 0
+        else:
+            loss_bbox = self.loss_bbox(
+                batch_pos_predicted_boxes,
+                batch_target_boxes,
+                batch_bbox_weights.float(),
+                avg_factor=avg_factor)
+
+        return dict(loss_cls=loss_cls, loss_bbox=loss_bbox)
+
+    def get_targets(self,
+                    cls_scores_list: List[Tensor],
+                    bbox_preds_list: List[Tensor],
+                    anchor_list: List[Tensor],
+                    valid_flag_list: List[Tensor],
+                    batch_gt_instances: InstanceList,
+                    batch_img_metas: List[dict],
+                    batch_gt_instances_ignore: OptInstanceList = None,
+                    unmap_outputs: bool = True):
+        """Compute regression and classification targets for anchors in
+        multiple images.
+
+        Args:
+            cls_scores_list (list[Tensor]): Classification scores of
+                each image. each is a 4D-tensor, the shape is
+                (h * w, num_anchors * num_classes).
+            bbox_preds_list (list[Tensor]): Bbox preds of each image.
+                each is a 4D-tensor, the shape is (h * w, num_anchors * 4).
+            anchor_list (list[Tensor]): Anchors of each image. Each element of
+                is a tensor of shape (h * w * num_anchors, 4).
+            valid_flag_list (list[Tensor]): Valid flags of each image. Each
+               element of is a tensor of shape (h * w * num_anchors, )
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+            unmap_outputs (bool): Whether to map outputs back to the original
+                set of anchors.
+
+        Returns:
+            tuple: Usually returns a tuple containing learning targets.
+
+                - batch_labels (Tensor): Label of all images. Each element \
+                    of is a tensor of shape (batch, h * w * num_anchors)
+                - batch_label_weights (Tensor): Label weights of all images \
+                    of is a tensor of shape (batch, h * w * num_anchors)
+                - num_total_pos (int): Number of positive samples in all \
+                    images.
+                - num_total_neg (int): Number of negative samples in all \
+                    images.
+            additional_returns: This function enables user-defined returns from
+                `self._get_targets_single`. These returns are currently refined
+                to properties at each feature map (i.e. having HxW dimension).
+                The results will be concatenated after the end
+        """
+        num_imgs = len(batch_img_metas)
+        assert len(anchor_list) == len(valid_flag_list) == num_imgs
+
+        # compute targets for each image
+        if batch_gt_instances_ignore is None:
+            batch_gt_instances_ignore = [None] * num_imgs
+        results = multi_apply(
+            self._get_targets_single,
+            bbox_preds_list,
+            anchor_list,
+            valid_flag_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore,
+            unmap_outputs=unmap_outputs)
+        (all_labels, all_label_weights, pos_inds, neg_inds,
+         sampling_results_list) = results[:5]
+        # Get `avg_factor` of all images, which calculate in `SamplingResult`.
+        # When using sampling method, avg_factor is usually the sum of
+        # positive and negative priors. When using `PseudoSampler`,
+        # `avg_factor` is usually equal to the number of positive priors.
+        avg_factor = sum(
+            [results.avg_factor for results in sampling_results_list])
+        rest_results = list(results[5:])  # user-added return values
+
+        batch_labels = torch.stack(all_labels, 0)
+        batch_label_weights = torch.stack(all_label_weights, 0)
+
+        res = (batch_labels, batch_label_weights, avg_factor)
+        for i, rests in enumerate(rest_results):  # user-added return values
+            rest_results[i] = torch.cat(rests, 0)
+
+        return res + tuple(rest_results)
+
+    def _get_targets_single(self,
+                            bbox_preds: Tensor,
+                            flat_anchors: Tensor,
+                            valid_flags: Tensor,
+                            gt_instances: InstanceData,
+                            img_meta: dict,
+                            gt_instances_ignore: Optional[InstanceData] = None,
+                            unmap_outputs: bool = True) -> tuple:
+        """Compute regression and classification targets for anchors in a
+        single image.
+
+        Args:
+            bbox_preds (Tensor): Bbox prediction of the image, which
+                shape is (h * w ,4)
+            flat_anchors (Tensor): Anchors of the image, which shape is
+                (h * w * num_anchors ,4)
+            valid_flags (Tensor): Valid flags of the image, which shape is
+                (h * w * num_anchors,).
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It should includes ``bboxes`` and ``labels``
+                attributes.
+            img_meta (dict): Meta information for current image.
+            gt_instances_ignore (:obj:`InstanceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+            unmap_outputs (bool): Whether to map outputs back to the original
+                set of anchors.
+
+        Returns:
+            tuple:
+                labels (Tensor): Labels of image, which shape is
+                    (h * w * num_anchors, ).
+                label_weights (Tensor): Label weights of image, which shape is
+                    (h * w * num_anchors, ).
+                pos_inds (Tensor): Pos index of image.
+                neg_inds (Tensor): Neg index of image.
+                sampling_result (obj:`SamplingResult`): Sampling result.
+                pos_bbox_weights (Tensor): The Weight of using to calculate
+                    the bbox branch loss, which shape is (num, ).
+                pos_predicted_boxes (Tensor): boxes predicted value of
+                    using to calculate the bbox branch loss, which shape is
+                    (num, 4).
+                pos_target_boxes (Tensor): boxes target value of
+                    using to calculate the bbox branch loss, which shape is
+                    (num, 4).
+        """
+        inside_flags = anchor_inside_flags(flat_anchors, valid_flags,
+                                           img_meta['img_shape'][:2],
+                                           self.train_cfg['allowed_border'])
+        if not inside_flags.any():
+            raise ValueError(
+                'There is no valid anchor inside the image boundary. Please '
+                'check the image size and anchor sizes, or set '
+                '``allowed_border`` to -1 to skip the condition.')
+
+        # assign gt and sample anchors
+        anchors = flat_anchors[inside_flags, :]
+        bbox_preds = bbox_preds.reshape(-1, 4)
+        bbox_preds = bbox_preds[inside_flags, :]
+
+        # decoded bbox
+        decoder_bbox_preds = self.bbox_coder.decode(anchors, bbox_preds)
+        pred_instances = InstanceData(
+            priors=anchors, decoder_priors=decoder_bbox_preds)
+        assign_result = self.assigner.assign(pred_instances, gt_instances,
+                                             gt_instances_ignore)
+
+        pos_bbox_weights = assign_result.get_extra_property('pos_idx')
+        pos_predicted_boxes = assign_result.get_extra_property(
+            'pos_predicted_boxes')
+        pos_target_boxes = assign_result.get_extra_property('target_boxes')
+
+        sampling_result = self.sampler.sample(assign_result, pred_instances,
+                                              gt_instances)
+        num_valid_anchors = anchors.shape[0]
+        labels = anchors.new_full((num_valid_anchors, ),
+                                  self.num_classes,
+                                  dtype=torch.long)
+        label_weights = anchors.new_zeros(num_valid_anchors, dtype=torch.float)
+
+        pos_inds = sampling_result.pos_inds
+        neg_inds = sampling_result.neg_inds
+        if len(pos_inds) > 0:
+            labels[pos_inds] = sampling_result.pos_gt_labels
+            if self.train_cfg['pos_weight'] <= 0:
+                label_weights[pos_inds] = 1.0
+            else:
+                label_weights[pos_inds] = self.train_cfg['pos_weight']
+        if len(neg_inds) > 0:
+            label_weights[neg_inds] = 1.0
+
+        # map up to original set of anchors
+        if unmap_outputs:
+            num_total_anchors = flat_anchors.size(0)
+            labels = unmap(
+                labels, num_total_anchors, inside_flags,
+                fill=self.num_classes)  # fill bg label
+            label_weights = unmap(label_weights, num_total_anchors,
+                                  inside_flags)
+
+        return (labels, label_weights, pos_inds, neg_inds, sampling_result,
+                pos_bbox_weights, pos_predicted_boxes, pos_target_boxes)
diff --git a/mmdetection/mmdet/models/dense_heads/yolox_head.py b/mmdetection/mmdet/models/dense_heads/yolox_head.py
new file mode 100644
index 00000000..00fe1e42
--- /dev/null
+++ b/mmdetection/mmdet/models/dense_heads/yolox_head.py
@@ -0,0 +1,618 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+from typing import List, Optional, Sequence, Tuple, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule, DepthwiseSeparableConvModule
+from mmcv.ops.nms import batched_nms
+from mmengine.config import ConfigDict
+from mmengine.model import bias_init_with_prob
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.structures.bbox import bbox_xyxy_to_cxcywh
+from mmdet.utils import (ConfigType, OptConfigType, OptInstanceList,
+                         OptMultiConfig, reduce_mean)
+from ..task_modules.prior_generators import MlvlPointGenerator
+from ..task_modules.samplers import PseudoSampler
+from ..utils import multi_apply
+from .base_dense_head import BaseDenseHead
+
+
+@MODELS.register_module()
+class YOLOXHead(BaseDenseHead):
+    """YOLOXHead head used in `YOLOX `_.
+
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (int): Number of channels in the input feature map.
+        feat_channels (int): Number of hidden channels in stacking convs.
+            Defaults to 256
+        stacked_convs (int): Number of stacking convs of the head.
+            Defaults to (8, 16, 32).
+        strides (Sequence[int]): Downsample factor of each feature map.
+             Defaults to None.
+        use_depthwise (bool): Whether to depthwise separable convolution in
+            blocks. Defaults to False.
+        dcn_on_last_conv (bool): If true, use dcn in the last layer of
+            towers. Defaults to False.
+        conv_bias (bool or str): If specified as `auto`, it will be decided by
+            the norm_cfg. Bias of conv will be set as True if `norm_cfg` is
+            None, otherwise False. Defaults to "auto".
+        conv_cfg (:obj:`ConfigDict` or dict, optional): Config dict for
+            convolution layer. Defaults to None.
+        norm_cfg (:obj:`ConfigDict` or dict): Config dict for normalization
+            layer. Defaults to dict(type='BN', momentum=0.03, eps=0.001).
+        act_cfg (:obj:`ConfigDict` or dict): Config dict for activation layer.
+            Defaults to None.
+        loss_cls (:obj:`ConfigDict` or dict): Config of classification loss.
+        loss_bbox (:obj:`ConfigDict` or dict): Config of localization loss.
+        loss_obj (:obj:`ConfigDict` or dict): Config of objectness loss.
+        loss_l1 (:obj:`ConfigDict` or dict): Config of L1 loss.
+        train_cfg (:obj:`ConfigDict` or dict, optional): Training config of
+            anchor head. Defaults to None.
+        test_cfg (:obj:`ConfigDict` or dict, optional): Testing config of
+            anchor head. Defaults to None.
+        init_cfg (:obj:`ConfigDict` or list[:obj:`ConfigDict`] or dict or
+            list[dict], optional): Initialization config dict.
+            Defaults to None.
+    """
+
+    def __init__(
+        self,
+        num_classes: int,
+        in_channels: int,
+        feat_channels: int = 256,
+        stacked_convs: int = 2,
+        strides: Sequence[int] = (8, 16, 32),
+        use_depthwise: bool = False,
+        dcn_on_last_conv: bool = False,
+        conv_bias: Union[bool, str] = 'auto',
+        conv_cfg: OptConfigType = None,
+        norm_cfg: ConfigType = dict(type='BN', momentum=0.03, eps=0.001),
+        act_cfg: ConfigType = dict(type='Swish'),
+        loss_cls: ConfigType = dict(
+            type='CrossEntropyLoss',
+            use_sigmoid=True,
+            reduction='sum',
+            loss_weight=1.0),
+        loss_bbox: ConfigType = dict(
+            type='IoULoss',
+            mode='square',
+            eps=1e-16,
+            reduction='sum',
+            loss_weight=5.0),
+        loss_obj: ConfigType = dict(
+            type='CrossEntropyLoss',
+            use_sigmoid=True,
+            reduction='sum',
+            loss_weight=1.0),
+        loss_l1: ConfigType = dict(
+            type='L1Loss', reduction='sum', loss_weight=1.0),
+        train_cfg: OptConfigType = None,
+        test_cfg: OptConfigType = None,
+        init_cfg: OptMultiConfig = dict(
+            type='Kaiming',
+            layer='Conv2d',
+            a=math.sqrt(5),
+            distribution='uniform',
+            mode='fan_in',
+            nonlinearity='leaky_relu')
+    ) -> None:
+
+        super().__init__(init_cfg=init_cfg)
+        self.num_classes = num_classes
+        self.cls_out_channels = num_classes
+        self.in_channels = in_channels
+        self.feat_channels = feat_channels
+        self.stacked_convs = stacked_convs
+        self.strides = strides
+        self.use_depthwise = use_depthwise
+        self.dcn_on_last_conv = dcn_on_last_conv
+        assert conv_bias == 'auto' or isinstance(conv_bias, bool)
+        self.conv_bias = conv_bias
+        self.use_sigmoid_cls = True
+
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+
+        self.loss_cls: nn.Module = MODELS.build(loss_cls)
+        self.loss_bbox: nn.Module = MODELS.build(loss_bbox)
+        self.loss_obj: nn.Module = MODELS.build(loss_obj)
+
+        self.use_l1 = False  # This flag will be modified by hooks.
+        self.loss_l1: nn.Module = MODELS.build(loss_l1)
+
+        self.prior_generator = MlvlPointGenerator(strides, offset=0)
+
+        self.test_cfg = test_cfg
+        self.train_cfg = train_cfg
+
+        if self.train_cfg:
+            self.assigner = TASK_UTILS.build(self.train_cfg['assigner'])
+            # YOLOX does not support sampling
+            self.sampler = PseudoSampler()
+
+        self._init_layers()
+
+    def _init_layers(self) -> None:
+        """Initialize heads for all level feature maps."""
+        self.multi_level_cls_convs = nn.ModuleList()
+        self.multi_level_reg_convs = nn.ModuleList()
+        self.multi_level_conv_cls = nn.ModuleList()
+        self.multi_level_conv_reg = nn.ModuleList()
+        self.multi_level_conv_obj = nn.ModuleList()
+        for _ in self.strides:
+            self.multi_level_cls_convs.append(self._build_stacked_convs())
+            self.multi_level_reg_convs.append(self._build_stacked_convs())
+            conv_cls, conv_reg, conv_obj = self._build_predictor()
+            self.multi_level_conv_cls.append(conv_cls)
+            self.multi_level_conv_reg.append(conv_reg)
+            self.multi_level_conv_obj.append(conv_obj)
+
+    def _build_stacked_convs(self) -> nn.Sequential:
+        """Initialize conv layers of a single level head."""
+        conv = DepthwiseSeparableConvModule \
+            if self.use_depthwise else ConvModule
+        stacked_convs = []
+        for i in range(self.stacked_convs):
+            chn = self.in_channels if i == 0 else self.feat_channels
+            if self.dcn_on_last_conv and i == self.stacked_convs - 1:
+                conv_cfg = dict(type='DCNv2')
+            else:
+                conv_cfg = self.conv_cfg
+            stacked_convs.append(
+                conv(
+                    chn,
+                    self.feat_channels,
+                    3,
+                    stride=1,
+                    padding=1,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=self.norm_cfg,
+                    act_cfg=self.act_cfg,
+                    bias=self.conv_bias))
+        return nn.Sequential(*stacked_convs)
+
+    def _build_predictor(self) -> Tuple[nn.Module, nn.Module, nn.Module]:
+        """Initialize predictor layers of a single level head."""
+        conv_cls = nn.Conv2d(self.feat_channels, self.cls_out_channels, 1)
+        conv_reg = nn.Conv2d(self.feat_channels, 4, 1)
+        conv_obj = nn.Conv2d(self.feat_channels, 1, 1)
+        return conv_cls, conv_reg, conv_obj
+
+    def init_weights(self) -> None:
+        """Initialize weights of the head."""
+        super(YOLOXHead, self).init_weights()
+        # Use prior in model initialization to improve stability
+        bias_init = bias_init_with_prob(0.01)
+        for conv_cls, conv_obj in zip(self.multi_level_conv_cls,
+                                      self.multi_level_conv_obj):
+            conv_cls.bias.data.fill_(bias_init)
+            conv_obj.bias.data.fill_(bias_init)
+
+    def forward_single(self, x: Tensor, cls_convs: nn.Module,
+                       reg_convs: nn.Module, conv_cls: nn.Module,
+                       conv_reg: nn.Module,
+                       conv_obj: nn.Module) -> Tuple[Tensor, Tensor, Tensor]:
+        """Forward feature of a single scale level."""
+
+        cls_feat = cls_convs(x)
+        reg_feat = reg_convs(x)
+
+        cls_score = conv_cls(cls_feat)
+        bbox_pred = conv_reg(reg_feat)
+        objectness = conv_obj(reg_feat)
+
+        return cls_score, bbox_pred, objectness
+
+    def forward(self, x: Tuple[Tensor]) -> Tuple[List]:
+        """Forward features from the upstream network.
+
+        Args:
+            x (Tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+        Returns:
+            Tuple[List]: A tuple of multi-level classification scores, bbox
+            predictions, and objectnesses.
+        """
+
+        return multi_apply(self.forward_single, x, self.multi_level_cls_convs,
+                           self.multi_level_reg_convs,
+                           self.multi_level_conv_cls,
+                           self.multi_level_conv_reg,
+                           self.multi_level_conv_obj)
+
+    def predict_by_feat(self,
+                        cls_scores: List[Tensor],
+                        bbox_preds: List[Tensor],
+                        objectnesses: Optional[List[Tensor]],
+                        batch_img_metas: Optional[List[dict]] = None,
+                        cfg: Optional[ConfigDict] = None,
+                        rescale: bool = False,
+                        with_nms: bool = True) -> List[InstanceData]:
+        """Transform a batch of output features extracted by the head into
+        bbox results.
+        Args:
+            cls_scores (list[Tensor]): Classification scores for all
+                scale levels, each is a 4D-tensor, has shape
+                (batch_size, num_priors * num_classes, H, W).
+            bbox_preds (list[Tensor]): Box energies / deltas for all
+                scale levels, each is a 4D-tensor, has shape
+                (batch_size, num_priors * 4, H, W).
+            objectnesses (list[Tensor], Optional): Score factor for
+                all scale level, each is a 4D-tensor, has shape
+                (batch_size, 1, H, W).
+            batch_img_metas (list[dict], Optional): Batch image meta info.
+                Defaults to None.
+            cfg (ConfigDict, optional): Test / postprocessing
+                configuration, if None, test_cfg would be used.
+                Defaults to None.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            with_nms (bool): If True, do nms before return boxes.
+                Defaults to True.
+
+        Returns:
+            list[:obj:`InstanceData`]: Object detection results of each image
+            after the post process. Each item usually contains following keys.
+
+            - scores (Tensor): Classification scores, has a shape
+              (num_instance, )
+            - labels (Tensor): Labels of bboxes, has a shape
+              (num_instances, ).
+            - bboxes (Tensor): Has a shape (num_instances, 4),
+              the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        assert len(cls_scores) == len(bbox_preds) == len(objectnesses)
+        cfg = self.test_cfg if cfg is None else cfg
+
+        num_imgs = len(batch_img_metas)
+        featmap_sizes = [cls_score.shape[2:] for cls_score in cls_scores]
+        mlvl_priors = self.prior_generator.grid_priors(
+            featmap_sizes,
+            dtype=cls_scores[0].dtype,
+            device=cls_scores[0].device,
+            with_stride=True)
+
+        # flatten cls_scores, bbox_preds and objectness
+        flatten_cls_scores = [
+            cls_score.permute(0, 2, 3, 1).reshape(num_imgs, -1,
+                                                  self.cls_out_channels)
+            for cls_score in cls_scores
+        ]
+        flatten_bbox_preds = [
+            bbox_pred.permute(0, 2, 3, 1).reshape(num_imgs, -1, 4)
+            for bbox_pred in bbox_preds
+        ]
+        flatten_objectness = [
+            objectness.permute(0, 2, 3, 1).reshape(num_imgs, -1)
+            for objectness in objectnesses
+        ]
+
+        flatten_cls_scores = torch.cat(flatten_cls_scores, dim=1).sigmoid()
+        flatten_bbox_preds = torch.cat(flatten_bbox_preds, dim=1)
+        flatten_objectness = torch.cat(flatten_objectness, dim=1).sigmoid()
+        flatten_priors = torch.cat(mlvl_priors)
+
+        flatten_bboxes = self._bbox_decode(flatten_priors, flatten_bbox_preds)
+
+        result_list = []
+        for img_id, img_meta in enumerate(batch_img_metas):
+            max_scores, labels = torch.max(flatten_cls_scores[img_id], 1)
+            valid_mask = flatten_objectness[
+                img_id] * max_scores >= cfg.score_thr
+            results = InstanceData(
+                bboxes=flatten_bboxes[img_id][valid_mask],
+                scores=max_scores[valid_mask] *
+                flatten_objectness[img_id][valid_mask],
+                labels=labels[valid_mask])
+
+            result_list.append(
+                self._bbox_post_process(
+                    results=results,
+                    cfg=cfg,
+                    rescale=rescale,
+                    with_nms=with_nms,
+                    img_meta=img_meta))
+
+        return result_list
+
+    def _bbox_decode(self, priors: Tensor, bbox_preds: Tensor) -> Tensor:
+        """Decode regression results (delta_x, delta_x, w, h) to bboxes (tl_x,
+        tl_y, br_x, br_y).
+
+        Args:
+            priors (Tensor): Center proiors of an image, has shape
+                (num_instances, 2).
+            bbox_preds (Tensor): Box energies / deltas for all instances,
+                has shape (batch_size, num_instances, 4).
+
+        Returns:
+            Tensor: Decoded bboxes in (tl_x, tl_y, br_x, br_y) format. Has
+            shape (batch_size, num_instances, 4).
+        """
+        xys = (bbox_preds[..., :2] * priors[:, 2:]) + priors[:, :2]
+        whs = bbox_preds[..., 2:].exp() * priors[:, 2:]
+
+        tl_x = (xys[..., 0] - whs[..., 0] / 2)
+        tl_y = (xys[..., 1] - whs[..., 1] / 2)
+        br_x = (xys[..., 0] + whs[..., 0] / 2)
+        br_y = (xys[..., 1] + whs[..., 1] / 2)
+
+        decoded_bboxes = torch.stack([tl_x, tl_y, br_x, br_y], -1)
+        return decoded_bboxes
+
+    def _bbox_post_process(self,
+                           results: InstanceData,
+                           cfg: ConfigDict,
+                           rescale: bool = False,
+                           with_nms: bool = True,
+                           img_meta: Optional[dict] = None) -> InstanceData:
+        """bbox post-processing method.
+
+        The boxes would be rescaled to the original image scale and do
+        the nms operation. Usually `with_nms` is False is used for aug test.
+
+        Args:
+            results (:obj:`InstaceData`): Detection instance results,
+                each item has shape (num_bboxes, ).
+            cfg (mmengine.Config): Test / postprocessing configuration,
+                if None, test_cfg would be used.
+            rescale (bool): If True, return boxes in original image space.
+                Default to False.
+            with_nms (bool): If True, do nms before return boxes.
+                Default to True.
+            img_meta (dict, optional): Image meta info. Defaults to None.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+            - scores (Tensor): Classification scores, has a shape
+              (num_instance, )
+            - labels (Tensor): Labels of bboxes, has a shape
+              (num_instances, ).
+            - bboxes (Tensor): Has a shape (num_instances, 4),
+              the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+
+        if rescale:
+            assert img_meta.get('scale_factor') is not None
+            results.bboxes /= results.bboxes.new_tensor(
+                img_meta['scale_factor']).repeat((1, 2))
+
+        if with_nms and results.bboxes.numel() > 0:
+            det_bboxes, keep_idxs = batched_nms(results.bboxes, results.scores,
+                                                results.labels, cfg.nms)
+            results = results[keep_idxs]
+            # some nms would reweight the score, such as softnms
+            results.scores = det_bboxes[:, -1]
+        return results
+
+    def loss_by_feat(
+            self,
+            cls_scores: Sequence[Tensor],
+            bbox_preds: Sequence[Tensor],
+            objectnesses: Sequence[Tensor],
+            batch_gt_instances: Sequence[InstanceData],
+            batch_img_metas: Sequence[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> dict:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            cls_scores (Sequence[Tensor]): Box scores for each scale level,
+                each is a 4D-tensor, the channel number is
+                num_priors * num_classes.
+            bbox_preds (Sequence[Tensor]): Box energies / deltas for each scale
+                level, each is a 4D-tensor, the channel number is
+                num_priors * 4.
+            objectnesses (Sequence[Tensor]): Score factor for
+                all scale level, each is a 4D-tensor, has shape
+                (batch_size, 1, H, W).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+        Returns:
+            dict[str, Tensor]: A dictionary of losses.
+        """
+        num_imgs = len(batch_img_metas)
+        if batch_gt_instances_ignore is None:
+            batch_gt_instances_ignore = [None] * num_imgs
+
+        featmap_sizes = [cls_score.shape[2:] for cls_score in cls_scores]
+        mlvl_priors = self.prior_generator.grid_priors(
+            featmap_sizes,
+            dtype=cls_scores[0].dtype,
+            device=cls_scores[0].device,
+            with_stride=True)
+
+        flatten_cls_preds = [
+            cls_pred.permute(0, 2, 3, 1).reshape(num_imgs, -1,
+                                                 self.cls_out_channels)
+            for cls_pred in cls_scores
+        ]
+        flatten_bbox_preds = [
+            bbox_pred.permute(0, 2, 3, 1).reshape(num_imgs, -1, 4)
+            for bbox_pred in bbox_preds
+        ]
+        flatten_objectness = [
+            objectness.permute(0, 2, 3, 1).reshape(num_imgs, -1)
+            for objectness in objectnesses
+        ]
+
+        flatten_cls_preds = torch.cat(flatten_cls_preds, dim=1)
+        flatten_bbox_preds = torch.cat(flatten_bbox_preds, dim=1)
+        flatten_objectness = torch.cat(flatten_objectness, dim=1)
+        flatten_priors = torch.cat(mlvl_priors)
+        flatten_bboxes = self._bbox_decode(flatten_priors, flatten_bbox_preds)
+
+        (pos_masks, cls_targets, obj_targets, bbox_targets, l1_targets,
+         num_fg_imgs) = multi_apply(
+             self._get_targets_single,
+             flatten_priors.unsqueeze(0).repeat(num_imgs, 1, 1),
+             flatten_cls_preds.detach(), flatten_bboxes.detach(),
+             flatten_objectness.detach(), batch_gt_instances, batch_img_metas,
+             batch_gt_instances_ignore)
+
+        # The experimental results show that 'reduce_mean' can improve
+        # performance on the COCO dataset.
+        num_pos = torch.tensor(
+            sum(num_fg_imgs),
+            dtype=torch.float,
+            device=flatten_cls_preds.device)
+        num_total_samples = max(reduce_mean(num_pos), 1.0)
+
+        pos_masks = torch.cat(pos_masks, 0)
+        cls_targets = torch.cat(cls_targets, 0)
+        obj_targets = torch.cat(obj_targets, 0)
+        bbox_targets = torch.cat(bbox_targets, 0)
+        if self.use_l1:
+            l1_targets = torch.cat(l1_targets, 0)
+
+        loss_obj = self.loss_obj(flatten_objectness.view(-1, 1),
+                                 obj_targets) / num_total_samples
+        if num_pos > 0:
+            loss_cls = self.loss_cls(
+                flatten_cls_preds.view(-1, self.num_classes)[pos_masks],
+                cls_targets) / num_total_samples
+            loss_bbox = self.loss_bbox(
+                flatten_bboxes.view(-1, 4)[pos_masks],
+                bbox_targets) / num_total_samples
+        else:
+            # Avoid cls and reg branch not participating in the gradient
+            # propagation when there is no ground-truth in the images.
+            # For more details, please refer to
+            # https://github.com/open-mmlab/mmdetection/issues/7298
+            loss_cls = flatten_cls_preds.sum() * 0
+            loss_bbox = flatten_bboxes.sum() * 0
+
+        loss_dict = dict(
+            loss_cls=loss_cls, loss_bbox=loss_bbox, loss_obj=loss_obj)
+
+        if self.use_l1:
+            if num_pos > 0:
+                loss_l1 = self.loss_l1(
+                    flatten_bbox_preds.view(-1, 4)[pos_masks],
+                    l1_targets) / num_total_samples
+            else:
+                # Avoid cls and reg branch not participating in the gradient
+                # propagation when there is no ground-truth in the images.
+                # For more details, please refer to
+                # https://github.com/open-mmlab/mmdetection/issues/7298
+                loss_l1 = flatten_bbox_preds.sum() * 0
+            loss_dict.update(loss_l1=loss_l1)
+
+        return loss_dict
+
+    @torch.no_grad()
+    def _get_targets_single(
+            self,
+            priors: Tensor,
+            cls_preds: Tensor,
+            decoded_bboxes: Tensor,
+            objectness: Tensor,
+            gt_instances: InstanceData,
+            img_meta: dict,
+            gt_instances_ignore: Optional[InstanceData] = None) -> tuple:
+        """Compute classification, regression, and objectness targets for
+        priors in a single image.
+
+        Args:
+            priors (Tensor): All priors of one image, a 2D-Tensor with shape
+                [num_priors, 4] in [cx, xy, stride_w, stride_y] format.
+            cls_preds (Tensor): Classification predictions of one image,
+                a 2D-Tensor with shape [num_priors, num_classes]
+            decoded_bboxes (Tensor): Decoded bboxes predictions of one image,
+                a 2D-Tensor with shape [num_priors, 4] in [tl_x, tl_y,
+                br_x, br_y] format.
+            objectness (Tensor): Objectness predictions of one image,
+                a 1D-Tensor with shape [num_priors]
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It should includes ``bboxes`` and ``labels``
+                attributes.
+            img_meta (dict): Meta information for current image.
+            gt_instances_ignore (:obj:`InstanceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+        Returns:
+            tuple:
+                foreground_mask (list[Tensor]): Binary mask of foreground
+                targets.
+                cls_target (list[Tensor]): Classification targets of an image.
+                obj_target (list[Tensor]): Objectness targets of an image.
+                bbox_target (list[Tensor]): BBox targets of an image.
+                l1_target (int): BBox L1 targets of an image.
+                num_pos_per_img (int): Number of positive samples in an image.
+        """
+
+        num_priors = priors.size(0)
+        num_gts = len(gt_instances)
+        # No target
+        if num_gts == 0:
+            cls_target = cls_preds.new_zeros((0, self.num_classes))
+            bbox_target = cls_preds.new_zeros((0, 4))
+            l1_target = cls_preds.new_zeros((0, 4))
+            obj_target = cls_preds.new_zeros((num_priors, 1))
+            foreground_mask = cls_preds.new_zeros(num_priors).bool()
+            return (foreground_mask, cls_target, obj_target, bbox_target,
+                    l1_target, 0)
+
+        # YOLOX uses center priors with 0.5 offset to assign targets,
+        # but use center priors without offset to regress bboxes.
+        offset_priors = torch.cat(
+            [priors[:, :2] + priors[:, 2:] * 0.5, priors[:, 2:]], dim=-1)
+
+        scores = cls_preds.sigmoid() * objectness.unsqueeze(1).sigmoid()
+        pred_instances = InstanceData(
+            bboxes=decoded_bboxes, scores=scores.sqrt_(), priors=offset_priors)
+        assign_result = self.assigner.assign(
+            pred_instances=pred_instances,
+            gt_instances=gt_instances,
+            gt_instances_ignore=gt_instances_ignore)
+
+        sampling_result = self.sampler.sample(assign_result, pred_instances,
+                                              gt_instances)
+        pos_inds = sampling_result.pos_inds
+        num_pos_per_img = pos_inds.size(0)
+
+        pos_ious = assign_result.max_overlaps[pos_inds]
+        # IOU aware classification score
+        cls_target = F.one_hot(sampling_result.pos_gt_labels,
+                               self.num_classes) * pos_ious.unsqueeze(-1)
+        obj_target = torch.zeros_like(objectness).unsqueeze(-1)
+        obj_target[pos_inds] = 1
+        bbox_target = sampling_result.pos_gt_bboxes
+        l1_target = cls_preds.new_zeros((num_pos_per_img, 4))
+        if self.use_l1:
+            l1_target = self._get_l1_target(l1_target, bbox_target,
+                                            priors[pos_inds])
+        foreground_mask = torch.zeros_like(objectness).to(torch.bool)
+        foreground_mask[pos_inds] = 1
+        return (foreground_mask, cls_target, obj_target, bbox_target,
+                l1_target, num_pos_per_img)
+
+    def _get_l1_target(self,
+                       l1_target: Tensor,
+                       gt_bboxes: Tensor,
+                       priors: Tensor,
+                       eps: float = 1e-8) -> Tensor:
+        """Convert gt bboxes to center offset and log width height."""
+        gt_cxcywh = bbox_xyxy_to_cxcywh(gt_bboxes)
+        l1_target[:, :2] = (gt_cxcywh[:, :2] - priors[:, :2]) / priors[:, 2:]
+        l1_target[:, 2:] = torch.log(gt_cxcywh[:, 2:] / priors[:, 2:] + eps)
+        return l1_target
diff --git a/mmdetection/mmdet/models/detectors/__init__.py b/mmdetection/mmdet/models/detectors/__init__.py
new file mode 100644
index 00000000..e5a06d28
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/__init__.py
@@ -0,0 +1,75 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .atss import ATSS
+from .autoassign import AutoAssign
+from .base import BaseDetector
+from .base_detr import DetectionTransformer
+from .boxinst import BoxInst
+from .cascade_rcnn import CascadeRCNN
+from .centernet import CenterNet
+from .condinst import CondInst
+from .conditional_detr import ConditionalDETR
+from .cornernet import CornerNet
+from .crowddet import CrowdDet
+from .d2_wrapper import Detectron2Wrapper
+from .dab_detr import DABDETR
+from .ddod import DDOD
+from .ddq_detr import DDQDETR
+from .deformable_detr import DeformableDETR
+from .detr import DETR
+from .dino import DINO
+from .fast_rcnn import FastRCNN
+from .faster_rcnn import FasterRCNN
+from .fcos import FCOS
+from .fovea import FOVEA
+from .fsaf import FSAF
+from .gfl import GFL
+from .glip import GLIP
+from .grid_rcnn import GridRCNN
+from .grounding_dino import GroundingDINO
+from .htc import HybridTaskCascade
+from .kd_one_stage import KnowledgeDistillationSingleStageDetector
+from .lad import LAD
+from .mask2former import Mask2Former
+from .mask_rcnn import MaskRCNN
+from .mask_scoring_rcnn import MaskScoringRCNN
+from .maskformer import MaskFormer
+from .nasfcos import NASFCOS
+from .paa import PAA
+from .panoptic_fpn import PanopticFPN
+from .panoptic_two_stage_segmentor import TwoStagePanopticSegmentor
+from .point_rend import PointRend
+from .queryinst import QueryInst
+from .reppoints_detector import RepPointsDetector
+from .retinanet import RetinaNet
+from .rpn import RPN
+from .rtmdet import RTMDet
+from .scnet import SCNet
+from .semi_base import SemiBaseDetector
+from .single_stage import SingleStageDetector
+from .soft_teacher import SoftTeacher
+from .solo import SOLO
+from .solov2 import SOLOv2
+from .sparse_rcnn import SparseRCNN
+from .tood import TOOD
+from .trident_faster_rcnn import TridentFasterRCNN
+from .two_stage import TwoStageDetector
+from .vfnet import VFNet
+from .yolact import YOLACT
+from .yolo import YOLOV3
+from .yolof import YOLOF
+from .yolox import YOLOX
+
+__all__ = [
+    'ATSS', 'BaseDetector', 'SingleStageDetector', 'TwoStageDetector', 'RPN',
+    'KnowledgeDistillationSingleStageDetector', 'FastRCNN', 'FasterRCNN',
+    'MaskRCNN', 'CascadeRCNN', 'HybridTaskCascade', 'RetinaNet', 'FCOS',
+    'GridRCNN', 'MaskScoringRCNN', 'RepPointsDetector', 'FOVEA', 'FSAF',
+    'NASFCOS', 'PointRend', 'GFL', 'CornerNet', 'PAA', 'YOLOV3', 'YOLACT',
+    'VFNet', 'DETR', 'TridentFasterRCNN', 'SparseRCNN', 'SCNet', 'SOLO',
+    'SOLOv2', 'DeformableDETR', 'AutoAssign', 'YOLOF', 'CenterNet', 'YOLOX',
+    'TwoStagePanopticSegmentor', 'PanopticFPN', 'QueryInst', 'LAD', 'TOOD',
+    'MaskFormer', 'DDOD', 'Mask2Former', 'SemiBaseDetector', 'SoftTeacher',
+    'RTMDet', 'Detectron2Wrapper', 'CrowdDet', 'CondInst', 'BoxInst',
+    'DetectionTransformer', 'ConditionalDETR', 'DINO', 'DABDETR', 'GLIP',
+    'DDQDETR', 'GroundingDINO'
+]
diff --git a/mmdetection/mmdet/models/detectors/atss.py b/mmdetection/mmdet/models/detectors/atss.py
new file mode 100644
index 00000000..0bfcc728
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/atss.py
@@ -0,0 +1,41 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage import SingleStageDetector
+
+
+@MODELS.register_module()
+class ATSS(SingleStageDetector):
+    """Implementation of `ATSS `_
+
+    Args:
+        backbone (:obj:`ConfigDict` or dict): The backbone module.
+        neck (:obj:`ConfigDict` or dict): The neck module.
+        bbox_head (:obj:`ConfigDict` or dict): The bbox head module.
+        train_cfg (:obj:`ConfigDict` or dict, optional): The training config
+            of ATSS. Defaults to None.
+        test_cfg (:obj:`ConfigDict` or dict, optional): The testing config
+            of ATSS. Defaults to None.
+        data_preprocessor (:obj:`ConfigDict` or dict, optional): Config of
+            :class:`DetDataPreprocessor` to process the input data.
+            Defaults to None.
+        init_cfg (:obj:`ConfigDict` or dict, optional): the config to control
+            the initialization. Defaults to None.
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/autoassign.py b/mmdetection/mmdet/models/detectors/autoassign.py
new file mode 100644
index 00000000..a0b3570f
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/autoassign.py
@@ -0,0 +1,43 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage import SingleStageDetector
+
+
+@MODELS.register_module()
+class AutoAssign(SingleStageDetector):
+    """Implementation of `AutoAssign: Differentiable Label Assignment for Dense
+    Object Detection `_
+
+    Args:
+        backbone (:obj:`ConfigDict` or dict): The backbone config.
+        neck (:obj:`ConfigDict` or dict): The neck config.
+        bbox_head (:obj:`ConfigDict` or dict): The bbox head config.
+        train_cfg (:obj:`ConfigDict` or dict, optional): The training config
+            of AutoAssign. Defaults to None.
+        test_cfg (:obj:`ConfigDict` or dict, optional): The testing config
+            of AutoAssign. Defaults to None.
+        data_preprocessor (:obj:`ConfigDict` or dict, optional): Config of
+            :class:`DetDataPreprocessor` to process the input data.
+            Defaults to None.
+        init_cfg (:obj:`ConfigDict` or list[:obj:`ConfigDict`] or dict or
+            list[dict], optional): Initialization config dict.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None):
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/base.py b/mmdetection/mmdet/models/detectors/base.py
new file mode 100644
index 00000000..1a193b0c
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/base.py
@@ -0,0 +1,156 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from abc import ABCMeta, abstractmethod
+from typing import Dict, List, Tuple, Union
+
+import torch
+from mmengine.model import BaseModel
+from torch import Tensor
+
+from mmdet.structures import DetDataSample, OptSampleList, SampleList
+from mmdet.utils import InstanceList, OptConfigType, OptMultiConfig
+from ..utils import samplelist_boxtype2tensor
+
+ForwardResults = Union[Dict[str, torch.Tensor], List[DetDataSample],
+                       Tuple[torch.Tensor], torch.Tensor]
+
+
+class BaseDetector(BaseModel, metaclass=ABCMeta):
+    """Base class for detectors.
+
+    Args:
+       data_preprocessor (dict or ConfigDict, optional): The pre-process
+           config of :class:`BaseDataPreprocessor`.  it usually includes,
+            ``pad_size_divisor``, ``pad_value``, ``mean`` and ``std``.
+       init_cfg (dict or ConfigDict, optional): the config to control the
+           initialization. Defaults to None.
+    """
+
+    def __init__(self,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None):
+        super().__init__(
+            data_preprocessor=data_preprocessor, init_cfg=init_cfg)
+
+    @property
+    def with_neck(self) -> bool:
+        """bool: whether the detector has a neck"""
+        return hasattr(self, 'neck') and self.neck is not None
+
+    # TODO: these properties need to be carefully handled
+    # for both single stage & two stage detectors
+    @property
+    def with_shared_head(self) -> bool:
+        """bool: whether the detector has a shared head in the RoI Head"""
+        return hasattr(self, 'roi_head') and self.roi_head.with_shared_head
+
+    @property
+    def with_bbox(self) -> bool:
+        """bool: whether the detector has a bbox head"""
+        return ((hasattr(self, 'roi_head') and self.roi_head.with_bbox)
+                or (hasattr(self, 'bbox_head') and self.bbox_head is not None))
+
+    @property
+    def with_mask(self) -> bool:
+        """bool: whether the detector has a mask head"""
+        return ((hasattr(self, 'roi_head') and self.roi_head.with_mask)
+                or (hasattr(self, 'mask_head') and self.mask_head is not None))
+
+    def forward(self,
+                inputs: torch.Tensor,
+                data_samples: OptSampleList = None,
+                mode: str = 'tensor') -> ForwardResults:
+        """The unified entry for a forward process in both training and test.
+
+        The method should accept three modes: "tensor", "predict" and "loss":
+
+        - "tensor": Forward the whole network and return tensor or tuple of
+        tensor without any post-processing, same as a common nn.Module.
+        - "predict": Forward and return the predictions, which are fully
+        processed to a list of :obj:`DetDataSample`.
+        - "loss": Forward and return a dict of losses according to the given
+        inputs and data samples.
+
+        Note that this method doesn't handle either back propagation or
+        parameter update, which are supposed to be done in :meth:`train_step`.
+
+        Args:
+            inputs (torch.Tensor): The input tensor with shape
+                (N, C, ...) in general.
+            data_samples (list[:obj:`DetDataSample`], optional): A batch of
+                data samples that contain annotations and predictions.
+                Defaults to None.
+            mode (str): Return what kind of value. Defaults to 'tensor'.
+
+        Returns:
+            The return type depends on ``mode``.
+
+            - If ``mode="tensor"``, return a tensor or a tuple of tensor.
+            - If ``mode="predict"``, return a list of :obj:`DetDataSample`.
+            - If ``mode="loss"``, return a dict of tensor.
+        """
+        if mode == 'loss':
+            return self.loss(inputs, data_samples)
+        elif mode == 'predict':
+            return self.predict(inputs, data_samples)
+        elif mode == 'tensor':
+            return self._forward(inputs, data_samples)
+        else:
+            raise RuntimeError(f'Invalid mode "{mode}". '
+                               'Only supports loss, predict and tensor mode')
+
+    @abstractmethod
+    def loss(self, batch_inputs: Tensor,
+             batch_data_samples: SampleList) -> Union[dict, tuple]:
+        """Calculate losses from a batch of inputs and data samples."""
+        pass
+
+    @abstractmethod
+    def predict(self, batch_inputs: Tensor,
+                batch_data_samples: SampleList) -> SampleList:
+        """Predict results from a batch of inputs and data samples with post-
+        processing."""
+        pass
+
+    @abstractmethod
+    def _forward(self,
+                 batch_inputs: Tensor,
+                 batch_data_samples: OptSampleList = None):
+        """Network forward process.
+
+        Usually includes backbone, neck and head forward without any post-
+        processing.
+        """
+        pass
+
+    @abstractmethod
+    def extract_feat(self, batch_inputs: Tensor):
+        """Extract features from images."""
+        pass
+
+    def add_pred_to_datasample(self, data_samples: SampleList,
+                               results_list: InstanceList) -> SampleList:
+        """Add predictions to `DetDataSample`.
+
+        Args:
+            data_samples (list[:obj:`DetDataSample`], optional): A batch of
+                data samples that contain annotations and predictions.
+            results_list (list[:obj:`InstanceData`]): Detection results of
+                each image.
+
+        Returns:
+            list[:obj:`DetDataSample`]: Detection results of the
+            input images. Each DetDataSample usually contain
+            'pred_instances'. And the ``pred_instances`` usually
+            contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                    (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                    (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                    the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        for data_sample, pred_instances in zip(data_samples, results_list):
+            data_sample.pred_instances = pred_instances
+        samplelist_boxtype2tensor(data_samples)
+        return data_samples
diff --git a/mmdetection/mmdet/models/detectors/base_detr.py b/mmdetection/mmdet/models/detectors/base_detr.py
new file mode 100644
index 00000000..88f00ec7
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/base_detr.py
@@ -0,0 +1,332 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from abc import ABCMeta, abstractmethod
+from typing import Dict, List, Tuple, Union
+
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import OptSampleList, SampleList
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .base import BaseDetector
+
+
+@MODELS.register_module()
+class DetectionTransformer(BaseDetector, metaclass=ABCMeta):
+    r"""Base class for Detection Transformer.
+
+    In Detection Transformer, an encoder is used to process output features of
+    neck, then several queries interact with the encoder features using a
+    decoder and do the regression and classification with the bounding box
+    head.
+
+    Args:
+        backbone (:obj:`ConfigDict` or dict): Config of the backbone.
+        neck (:obj:`ConfigDict` or dict, optional): Config of the neck.
+            Defaults to None.
+        encoder (:obj:`ConfigDict` or dict, optional): Config of the
+            Transformer encoder. Defaults to None.
+        decoder (:obj:`ConfigDict` or dict, optional): Config of the
+            Transformer decoder. Defaults to None.
+        bbox_head (:obj:`ConfigDict` or dict, optional): Config for the
+            bounding box head module. Defaults to None.
+        positional_encoding (:obj:`ConfigDict` or dict, optional): Config
+            of the positional encoding module. Defaults to None.
+        num_queries (int, optional): Number of decoder query in Transformer.
+            Defaults to 100.
+        train_cfg (:obj:`ConfigDict` or dict, optional): Training config of
+            the bounding box head module. Defaults to None.
+        test_cfg (:obj:`ConfigDict` or dict, optional): Testing config of
+            the bounding box head module. Defaults to None.
+        data_preprocessor (dict or ConfigDict, optional): The pre-process
+            config of :class:`BaseDataPreprocessor`.  it usually includes,
+            ``pad_size_divisor``, ``pad_value``, ``mean`` and ``std``.
+            Defaults to None.
+        init_cfg (:obj:`ConfigDict` or dict, optional): the config to control
+            the initialization. Defaults to None.
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: OptConfigType = None,
+                 encoder: OptConfigType = None,
+                 decoder: OptConfigType = None,
+                 bbox_head: OptConfigType = None,
+                 positional_encoding: OptConfigType = None,
+                 num_queries: int = 100,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            data_preprocessor=data_preprocessor, init_cfg=init_cfg)
+        # process args
+        bbox_head.update(train_cfg=train_cfg)
+        bbox_head.update(test_cfg=test_cfg)
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+        self.encoder = encoder
+        self.decoder = decoder
+        self.positional_encoding = positional_encoding
+        self.num_queries = num_queries
+
+        # init model layers
+        self.backbone = MODELS.build(backbone)
+        if neck is not None:
+            self.neck = MODELS.build(neck)
+        self.bbox_head = MODELS.build(bbox_head)
+        self._init_layers()
+
+    @abstractmethod
+    def _init_layers(self) -> None:
+        """Initialize layers except for backbone, neck and bbox_head."""
+        pass
+
+    def loss(self, batch_inputs: Tensor,
+             batch_data_samples: SampleList) -> Union[dict, list]:
+        """Calculate losses from a batch of inputs and data samples.
+
+        Args:
+            batch_inputs (Tensor): Input images of shape (bs, dim, H, W).
+                These should usually be mean centered and std scaled.
+            batch_data_samples (List[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            dict: A dictionary of loss components
+        """
+        img_feats = self.extract_feat(batch_inputs)
+        head_inputs_dict = self.forward_transformer(img_feats,
+                                                    batch_data_samples)
+        losses = self.bbox_head.loss(
+            **head_inputs_dict, batch_data_samples=batch_data_samples)
+
+        return losses
+
+    def predict(self,
+                batch_inputs: Tensor,
+                batch_data_samples: SampleList,
+                rescale: bool = True) -> SampleList:
+        """Predict results from a batch of inputs and data samples with post-
+        processing.
+
+        Args:
+            batch_inputs (Tensor): Inputs, has shape (bs, dim, H, W).
+            batch_data_samples (List[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+            rescale (bool): Whether to rescale the results.
+                Defaults to True.
+
+        Returns:
+            list[:obj:`DetDataSample`]: Detection results of the input images.
+            Each DetDataSample usually contain 'pred_instances'. And the
+            `pred_instances` usually contains following keys.
+
+            - scores (Tensor): Classification scores, has a shape
+              (num_instance, )
+            - labels (Tensor): Labels of bboxes, has a shape
+              (num_instances, ).
+            - bboxes (Tensor): Has a shape (num_instances, 4),
+              the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        img_feats = self.extract_feat(batch_inputs)
+        head_inputs_dict = self.forward_transformer(img_feats,
+                                                    batch_data_samples)
+        results_list = self.bbox_head.predict(
+            **head_inputs_dict,
+            rescale=rescale,
+            batch_data_samples=batch_data_samples)
+        batch_data_samples = self.add_pred_to_datasample(
+            batch_data_samples, results_list)
+        return batch_data_samples
+
+    def _forward(
+            self,
+            batch_inputs: Tensor,
+            batch_data_samples: OptSampleList = None) -> Tuple[List[Tensor]]:
+        """Network forward process. Usually includes backbone, neck and head
+        forward without any post-processing.
+
+         Args:
+            batch_inputs (Tensor): Inputs, has shape (bs, dim, H, W).
+            batch_data_samples (List[:obj:`DetDataSample`], optional): The
+                batch data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+                Defaults to None.
+
+        Returns:
+            tuple[Tensor]: A tuple of features from ``bbox_head`` forward.
+        """
+        img_feats = self.extract_feat(batch_inputs)
+        head_inputs_dict = self.forward_transformer(img_feats,
+                                                    batch_data_samples)
+        results = self.bbox_head.forward(**head_inputs_dict)
+        return results
+
+    def forward_transformer(self,
+                            img_feats: Tuple[Tensor],
+                            batch_data_samples: OptSampleList = None) -> Dict:
+        """Forward process of Transformer, which includes four steps:
+        'pre_transformer' -> 'encoder' -> 'pre_decoder' -> 'decoder'. We
+        summarized the parameters flow of the existing DETR-like detector,
+        which can be illustrated as follow:
+
+        .. code:: text
+
+                 img_feats & batch_data_samples
+                               |
+                               V
+                      +-----------------+
+                      | pre_transformer |
+                      +-----------------+
+                          |          |
+                          |          V
+                          |    +-----------------+
+                          |    | forward_encoder |
+                          |    +-----------------+
+                          |             |
+                          |             V
+                          |     +---------------+
+                          |     |  pre_decoder  |
+                          |     +---------------+
+                          |         |       |
+                          V         V       |
+                      +-----------------+   |
+                      | forward_decoder |   |
+                      +-----------------+   |
+                                |           |
+                                V           V
+                               head_inputs_dict
+
+        Args:
+            img_feats (tuple[Tensor]): Tuple of feature maps from neck. Each
+                    feature map has shape (bs, dim, H, W).
+            batch_data_samples (list[:obj:`DetDataSample`], optional): The
+                batch data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+                Defaults to None.
+
+        Returns:
+            dict: The dictionary of bbox_head function inputs, which always
+            includes the `hidden_states` of the decoder output and may contain
+            `references` including the initial and intermediate references.
+        """
+        encoder_inputs_dict, decoder_inputs_dict = self.pre_transformer(
+            img_feats, batch_data_samples)
+
+        encoder_outputs_dict = self.forward_encoder(**encoder_inputs_dict)
+
+        tmp_dec_in, head_inputs_dict = self.pre_decoder(**encoder_outputs_dict)
+        decoder_inputs_dict.update(tmp_dec_in)
+
+        decoder_outputs_dict = self.forward_decoder(**decoder_inputs_dict)
+        head_inputs_dict.update(decoder_outputs_dict)
+        return head_inputs_dict
+
+    def extract_feat(self, batch_inputs: Tensor) -> Tuple[Tensor]:
+        """Extract features.
+
+        Args:
+            batch_inputs (Tensor): Image tensor, has shape (bs, dim, H, W).
+
+        Returns:
+            tuple[Tensor]: Tuple of feature maps from neck. Each feature map
+            has shape (bs, dim, H, W).
+        """
+        x = self.backbone(batch_inputs)
+        if self.with_neck:
+            x = self.neck(x)
+        return x
+
+    @abstractmethod
+    def pre_transformer(
+            self,
+            img_feats: Tuple[Tensor],
+            batch_data_samples: OptSampleList = None) -> Tuple[Dict, Dict]:
+        """Process image features before feeding them to the transformer.
+
+        Args:
+            img_feats (tuple[Tensor]): Tuple of feature maps from neck. Each
+                feature map has shape (bs, dim, H, W).
+            batch_data_samples (list[:obj:`DetDataSample`], optional): The
+                batch data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+                Defaults to None.
+
+        Returns:
+            tuple[dict, dict]: The first dict contains the inputs of encoder
+            and the second dict contains the inputs of decoder.
+
+            - encoder_inputs_dict (dict): The keyword args dictionary of
+              `self.forward_encoder()`, which includes 'feat', 'feat_mask',
+              'feat_pos', and other algorithm-specific arguments.
+            - decoder_inputs_dict (dict): The keyword args dictionary of
+              `self.forward_decoder()`, which includes 'memory_mask', and
+              other algorithm-specific arguments.
+        """
+        pass
+
+    @abstractmethod
+    def forward_encoder(self, feat: Tensor, feat_mask: Tensor,
+                        feat_pos: Tensor, **kwargs) -> Dict:
+        """Forward with Transformer encoder.
+
+        Args:
+            feat (Tensor): Sequential features, has shape (bs, num_feat_points,
+                dim).
+            feat_mask (Tensor): ByteTensor, the padding mask of the features,
+                has shape (bs, num_feat_points).
+            feat_pos (Tensor): The positional embeddings of the features, has
+                shape (bs, num_feat_points, dim).
+
+        Returns:
+            dict: The dictionary of encoder outputs, which includes the
+            `memory` of the encoder output and other algorithm-specific
+            arguments.
+        """
+        pass
+
+    @abstractmethod
+    def pre_decoder(self, memory: Tensor, **kwargs) -> Tuple[Dict, Dict]:
+        """Prepare intermediate variables before entering Transformer decoder,
+        such as `query`, `query_pos`, and `reference_points`.
+
+        Args:
+            memory (Tensor): The output embeddings of the Transformer encoder,
+                has shape (bs, num_feat_points, dim).
+
+        Returns:
+            tuple[dict, dict]: The first dict contains the inputs of decoder
+            and the second dict contains the inputs of the bbox_head function.
+
+            - decoder_inputs_dict (dict): The keyword dictionary args of
+              `self.forward_decoder()`, which includes 'query', 'query_pos',
+              'memory', and other algorithm-specific arguments.
+            - head_inputs_dict (dict): The keyword dictionary args of the
+              bbox_head functions, which is usually empty, or includes
+              `enc_outputs_class` and `enc_outputs_class` when the detector
+              support 'two stage' or 'query selection' strategies.
+        """
+        pass
+
+    @abstractmethod
+    def forward_decoder(self, query: Tensor, query_pos: Tensor, memory: Tensor,
+                        **kwargs) -> Dict:
+        """Forward with Transformer decoder.
+
+        Args:
+            query (Tensor): The queries of decoder inputs, has shape
+                (bs, num_queries, dim).
+            query_pos (Tensor): The positional queries of decoder inputs,
+                has shape (bs, num_queries, dim).
+            memory (Tensor): The output embeddings of the Transformer encoder,
+                has shape (bs, num_feat_points, dim).
+
+        Returns:
+            dict: The dictionary of decoder outputs, which includes the
+            `hidden_states` of the decoder output, `references` including
+            the initial and intermediate reference_points, and other
+            algorithm-specific arguments.
+        """
+        pass
diff --git a/mmdetection/mmdet/models/detectors/boxinst.py b/mmdetection/mmdet/models/detectors/boxinst.py
new file mode 100644
index 00000000..ca6b0bdd
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/boxinst.py
@@ -0,0 +1,28 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage_instance_seg import SingleStageInstanceSegmentor
+
+
+@MODELS.register_module()
+class BoxInst(SingleStageInstanceSegmentor):
+    """Implementation of `BoxInst `_"""
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 mask_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            mask_head=mask_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/cascade_rcnn.py b/mmdetection/mmdet/models/detectors/cascade_rcnn.py
new file mode 100644
index 00000000..ecf733ff
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/cascade_rcnn.py
@@ -0,0 +1,29 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .two_stage import TwoStageDetector
+
+
+@MODELS.register_module()
+class CascadeRCNN(TwoStageDetector):
+    r"""Implementation of `Cascade R-CNN: Delving into High Quality Object
+    Detection `_"""
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: OptConfigType = None,
+                 rpn_head: OptConfigType = None,
+                 roi_head: OptConfigType = None,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            rpn_head=rpn_head,
+            roi_head=roi_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/centernet.py b/mmdetection/mmdet/models/detectors/centernet.py
new file mode 100644
index 00000000..9c6622d6
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/centernet.py
@@ -0,0 +1,29 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage import SingleStageDetector
+
+
+@MODELS.register_module()
+class CenterNet(SingleStageDetector):
+    """Implementation of CenterNet(Objects as Points)
+
+    .
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/condinst.py b/mmdetection/mmdet/models/detectors/condinst.py
new file mode 100644
index 00000000..ed2dc99e
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/condinst.py
@@ -0,0 +1,28 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage_instance_seg import SingleStageInstanceSegmentor
+
+
+@MODELS.register_module()
+class CondInst(SingleStageInstanceSegmentor):
+    """Implementation of `CondInst `_"""
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 mask_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            mask_head=mask_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/conditional_detr.py b/mmdetection/mmdet/models/detectors/conditional_detr.py
new file mode 100644
index 00000000..d57868e6
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/conditional_detr.py
@@ -0,0 +1,74 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict
+
+import torch.nn as nn
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from ..layers import (ConditionalDetrTransformerDecoder,
+                      DetrTransformerEncoder, SinePositionalEncoding)
+from .detr import DETR
+
+
+@MODELS.register_module()
+class ConditionalDETR(DETR):
+    r"""Implementation of `Conditional DETR for Fast Training Convergence.
+
+    `_.
+
+    Code is modified from the `official github repo
+    `_.
+    """
+
+    def _init_layers(self) -> None:
+        """Initialize layers except for backbone, neck and bbox_head."""
+        self.positional_encoding = SinePositionalEncoding(
+            **self.positional_encoding)
+        self.encoder = DetrTransformerEncoder(**self.encoder)
+        self.decoder = ConditionalDetrTransformerDecoder(**self.decoder)
+        self.embed_dims = self.encoder.embed_dims
+        # NOTE The embed_dims is typically passed from the inside out.
+        # For example in DETR, The embed_dims is passed as
+        # self_attn -> the first encoder layer -> encoder -> detector.
+        self.query_embedding = nn.Embedding(self.num_queries, self.embed_dims)
+
+        num_feats = self.positional_encoding.num_feats
+        assert num_feats * 2 == self.embed_dims, \
+            f'embed_dims should be exactly 2 times of num_feats. ' \
+            f'Found {self.embed_dims} and {num_feats}.'
+
+    def forward_decoder(self, query: Tensor, query_pos: Tensor, memory: Tensor,
+                        memory_mask: Tensor, memory_pos: Tensor) -> Dict:
+        """Forward with Transformer decoder.
+
+        Args:
+            query (Tensor): The queries of decoder inputs, has shape
+                (bs, num_queries, dim).
+            query_pos (Tensor): The positional queries of decoder inputs,
+                has shape (bs, num_queries, dim).
+            memory (Tensor): The output embeddings of the Transformer encoder,
+                has shape (bs, num_feat_points, dim).
+            memory_mask (Tensor): ByteTensor, the padding mask of the memory,
+                has shape (bs, num_feat_points).
+            memory_pos (Tensor): The positional embeddings of memory, has
+                shape (bs, num_feat_points, dim).
+
+        Returns:
+            dict: The dictionary of decoder outputs, which includes the
+            `hidden_states` and `references` of the decoder output.
+
+            - hidden_states (Tensor): Has shape
+                (num_decoder_layers, bs, num_queries, dim)
+            - references (Tensor): Has shape
+                (bs, num_queries, 2)
+        """
+
+        hidden_states, references = self.decoder(
+            query=query,
+            key=memory,
+            query_pos=query_pos,
+            key_pos=memory_pos,
+            key_padding_mask=memory_mask)
+        head_inputs_dict = dict(
+            hidden_states=hidden_states, references=references)
+        return head_inputs_dict
diff --git a/mmdetection/mmdet/models/detectors/cornernet.py b/mmdetection/mmdet/models/detectors/cornernet.py
new file mode 100644
index 00000000..946af4db
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/cornernet.py
@@ -0,0 +1,30 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage import SingleStageDetector
+
+
+@MODELS.register_module()
+class CornerNet(SingleStageDetector):
+    """CornerNet.
+
+    This detector is the implementation of the paper `CornerNet: Detecting
+    Objects as Paired Keypoints `_ .
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/crowddet.py b/mmdetection/mmdet/models/detectors/crowddet.py
new file mode 100644
index 00000000..4f43bc08
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/crowddet.py
@@ -0,0 +1,45 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .two_stage import TwoStageDetector
+
+
+@MODELS.register_module()
+class CrowdDet(TwoStageDetector):
+    """Implementation of `CrowdDet `_
+
+    Args:
+        backbone (:obj:`ConfigDict` or dict): The backbone config.
+        rpn_head (:obj:`ConfigDict` or dict): The rpn config.
+        roi_head (:obj:`ConfigDict` or dict): The roi config.
+        train_cfg (:obj:`ConfigDict` or dict, optional): The training config
+            of FCOS. Defaults to None.
+        test_cfg (:obj:`ConfigDict` or dict, optional): The testing config
+            of FCOS. Defaults to None.
+        neck (:obj:`ConfigDict` or dict): The neck config.
+        data_preprocessor (:obj:`ConfigDict` or dict, optional): Config of
+            :class:`DetDataPreprocessor` to process the input data.
+            Defaults to None.
+        init_cfg (:obj:`ConfigDict` or list[:obj:`ConfigDict`] or dict or
+            list[dict], optional): Initialization config dict.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 rpn_head: ConfigType,
+                 roi_head: ConfigType,
+                 train_cfg: ConfigType,
+                 test_cfg: ConfigType,
+                 neck: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            rpn_head=rpn_head,
+            roi_head=roi_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            init_cfg=init_cfg,
+            data_preprocessor=data_preprocessor)
diff --git a/mmdetection/mmdet/models/detectors/d2_wrapper.py b/mmdetection/mmdet/models/detectors/d2_wrapper.py
new file mode 100644
index 00000000..3a2daa41
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/d2_wrapper.py
@@ -0,0 +1,291 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Union
+
+from mmengine.config import ConfigDict
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.structures.bbox import BaseBoxes
+from mmdet.structures.mask import BitmapMasks, PolygonMasks
+from mmdet.utils import ConfigType
+from .base import BaseDetector
+
+try:
+    import detectron2
+    from detectron2.config import get_cfg
+    from detectron2.modeling import build_model
+    from detectron2.structures.masks import BitMasks as D2_BitMasks
+    from detectron2.structures.masks import PolygonMasks as D2_PolygonMasks
+    from detectron2.utils.events import EventStorage
+except ImportError:
+    detectron2 = None
+
+
+def _to_cfgnode_list(cfg: ConfigType,
+                     config_list: list = [],
+                     father_name: str = 'MODEL') -> tuple:
+    """Convert the key and value of mmengine.ConfigDict into a list.
+
+    Args:
+        cfg (ConfigDict): The detectron2 model config.
+        config_list (list): A list contains the key and value of ConfigDict.
+            Defaults to [].
+        father_name (str): The father name add before the key.
+            Defaults to "MODEL".
+
+    Returns:
+        tuple:
+
+        - config_list: A list contains the key and value of ConfigDict.
+        - father_name (str): The father name add before the key.
+          Defaults to "MODEL".
+    """
+    for key, value in cfg.items():
+        name = f'{father_name}.{key.upper()}'
+        if isinstance(value, ConfigDict) or isinstance(value, dict):
+            config_list, fater_name = \
+                _to_cfgnode_list(value, config_list, name)
+        else:
+            config_list.append(name)
+            config_list.append(value)
+
+    return config_list, father_name
+
+
+def convert_d2_pred_to_datasample(data_samples: SampleList,
+                                  d2_results_list: list) -> SampleList:
+    """Convert the Detectron2's result to DetDataSample.
+
+    Args:
+        data_samples (list[:obj:`DetDataSample`]): The batch
+            data samples. It usually includes information such
+            as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+        d2_results_list (list): The list of the results of Detectron2's model.
+
+    Returns:
+        list[:obj:`DetDataSample`]: Detection results of the
+        input images. Each DetDataSample usually contain
+        'pred_instances'. And the ``pred_instances`` usually
+        contains following keys.
+
+        - scores (Tensor): Classification scores, has a shape
+          (num_instance, )
+        - labels (Tensor): Labels of bboxes, has a shape
+          (num_instances, ).
+        - bboxes (Tensor): Has a shape (num_instances, 4),
+          the last dimension 4 arrange as (x1, y1, x2, y2).
+    """
+    assert len(data_samples) == len(d2_results_list)
+    for data_sample, d2_results in zip(data_samples, d2_results_list):
+        d2_instance = d2_results['instances']
+
+        results = InstanceData()
+        results.bboxes = d2_instance.pred_boxes.tensor
+        results.scores = d2_instance.scores
+        results.labels = d2_instance.pred_classes
+
+        if d2_instance.has('pred_masks'):
+            results.masks = d2_instance.pred_masks
+        data_sample.pred_instances = results
+
+    return data_samples
+
+
+@MODELS.register_module()
+class Detectron2Wrapper(BaseDetector):
+    """Wrapper of a Detectron2 model. Input/output formats of this class follow
+    MMDetection's convention, so a Detectron2 model can be trained and
+    evaluated in MMDetection.
+
+    Args:
+        detector (:obj:`ConfigDict` or dict): The module config of
+            Detectron2.
+        bgr_to_rgb (bool): whether to convert image from BGR to RGB.
+            Defaults to False.
+        rgb_to_bgr (bool): whether to convert image from RGB to BGR.
+            Defaults to False.
+    """
+
+    def __init__(self,
+                 detector: ConfigType,
+                 bgr_to_rgb: bool = False,
+                 rgb_to_bgr: bool = False) -> None:
+        if detectron2 is None:
+            raise ImportError('Please install Detectron2 first')
+        assert not (bgr_to_rgb and rgb_to_bgr), (
+            '`bgr2rgb` and `rgb2bgr` cannot be set to True at the same time')
+        super().__init__()
+        self._channel_conversion = rgb_to_bgr or bgr_to_rgb
+        cfgnode_list, _ = _to_cfgnode_list(detector)
+        self.cfg = get_cfg()
+        self.cfg.merge_from_list(cfgnode_list)
+        self.d2_model = build_model(self.cfg)
+        self.storage = EventStorage()
+
+    def init_weights(self) -> None:
+        """Initialization Backbone.
+
+        NOTE: The initialization of other layers are in Detectron2,
+        if users want to change the initialization way, please
+        change the code in Detectron2.
+        """
+        from detectron2.checkpoint import DetectionCheckpointer
+        checkpointer = DetectionCheckpointer(model=self.d2_model)
+        checkpointer.load(self.cfg.MODEL.WEIGHTS, checkpointables=[])
+
+    def loss(self, batch_inputs: Tensor,
+             batch_data_samples: SampleList) -> Union[dict, tuple]:
+        """Calculate losses from a batch of inputs and data samples.
+
+        The inputs will first convert to the Detectron2 type and feed into
+        D2 models.
+
+        Args:
+            batch_inputs (Tensor): Input images of shape (N, C, H, W).
+                These should usually be mean centered and std scaled.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        d2_batched_inputs = self._convert_to_d2_inputs(
+            batch_inputs=batch_inputs,
+            batch_data_samples=batch_data_samples,
+            training=True)
+
+        with self.storage as storage:  # noqa
+            losses = self.d2_model(d2_batched_inputs)
+        # storage contains some training information, such as cls_accuracy.
+        # you can use storage.latest() to get the detail information
+        return losses
+
+    def predict(self, batch_inputs: Tensor,
+                batch_data_samples: SampleList) -> SampleList:
+        """Predict results from a batch of inputs and data samples with post-
+        processing.
+
+        The inputs will first convert to the Detectron2 type and feed into
+        D2 models. And the results will convert back to the MMDet type.
+
+        Args:
+            batch_inputs (Tensor): Input images of shape (N, C, H, W).
+                These should usually be mean centered and std scaled.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+
+        Returns:
+            list[:obj:`DetDataSample`]: Detection results of the
+            input images. Each DetDataSample usually contain
+            'pred_instances'. And the ``pred_instances`` usually
+            contains following keys.
+
+            - scores (Tensor): Classification scores, has a shape
+              (num_instance, )
+            - labels (Tensor): Labels of bboxes, has a shape
+              (num_instances, ).
+            - bboxes (Tensor): Has a shape (num_instances, 4),
+              the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        d2_batched_inputs = self._convert_to_d2_inputs(
+            batch_inputs=batch_inputs,
+            batch_data_samples=batch_data_samples,
+            training=False)
+        # results in detectron2 has already rescale
+        d2_results_list = self.d2_model(d2_batched_inputs)
+        batch_data_samples = convert_d2_pred_to_datasample(
+            data_samples=batch_data_samples, d2_results_list=d2_results_list)
+
+        return batch_data_samples
+
+    def _forward(self, *args, **kwargs):
+        """Network forward process.
+
+        Usually includes backbone, neck and head forward without any post-
+        processing.
+        """
+        raise NotImplementedError(
+            f'`_forward` is not implemented in {self.__class__.__name__}')
+
+    def extract_feat(self, *args, **kwargs):
+        """Extract features from images.
+
+        `extract_feat` will not be used in obj:``Detectron2Wrapper``.
+        """
+        pass
+
+    def _convert_to_d2_inputs(self,
+                              batch_inputs: Tensor,
+                              batch_data_samples: SampleList,
+                              training=True) -> list:
+        """Convert inputs type to support Detectron2's model.
+
+        Args:
+            batch_inputs (Tensor): Input images of shape (N, C, H, W).
+                These should usually be mean centered and std scaled.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+            training (bool): Whether to enable training time processing.
+
+        Returns:
+            list[dict]: A list of dict, which will be fed into Detectron2's
+            model. And the dict usually contains following keys.
+
+            - image (Tensor): Image in (C, H, W) format.
+            - instances (Instances): GT Instance.
+            - height (int): the output height resolution of the model
+            - width (int): the output width resolution of the model
+        """
+        from detectron2.data.detection_utils import filter_empty_instances
+        from detectron2.structures import Boxes, Instances
+
+        batched_d2_inputs = []
+        for image, data_samples in zip(batch_inputs, batch_data_samples):
+            d2_inputs = dict()
+            # deal with metainfo
+            meta_info = data_samples.metainfo
+            d2_inputs['file_name'] = meta_info['img_path']
+            d2_inputs['height'], d2_inputs['width'] = meta_info['ori_shape']
+            d2_inputs['image_id'] = meta_info['img_id']
+            # deal with image
+            if self._channel_conversion:
+                image = image[[2, 1, 0], ...]
+            d2_inputs['image'] = image
+            # deal with gt_instances
+            gt_instances = data_samples.gt_instances
+            d2_instances = Instances(meta_info['img_shape'])
+
+            gt_boxes = gt_instances.bboxes
+            # TODO: use mmdet.structures.box.get_box_tensor after PR 8658
+            #  has merged
+            if isinstance(gt_boxes, BaseBoxes):
+                gt_boxes = gt_boxes.tensor
+            d2_instances.gt_boxes = Boxes(gt_boxes)
+
+            d2_instances.gt_classes = gt_instances.labels
+            if gt_instances.get('masks', None) is not None:
+                gt_masks = gt_instances.masks
+                if isinstance(gt_masks, PolygonMasks):
+                    d2_instances.gt_masks = D2_PolygonMasks(gt_masks.masks)
+                elif isinstance(gt_masks, BitmapMasks):
+                    d2_instances.gt_masks = D2_BitMasks(gt_masks.masks)
+                else:
+                    raise TypeError('The type of `gt_mask` can be '
+                                    '`PolygonMasks` or `BitMasks`, but get '
+                                    f'{type(gt_masks)}.')
+            # convert to cpu and convert back to cuda to avoid
+            # some potential error
+            if training:
+                device = gt_boxes.device
+                d2_instances = filter_empty_instances(
+                    d2_instances.to('cpu')).to(device)
+                d2_inputs['instances'] = d2_instances
+            batched_d2_inputs.append(d2_inputs)
+
+        return batched_d2_inputs
diff --git a/mmdetection/mmdet/models/detectors/dab_detr.py b/mmdetection/mmdet/models/detectors/dab_detr.py
new file mode 100644
index 00000000..b61301cf
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/dab_detr.py
@@ -0,0 +1,139 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, Tuple
+
+from mmengine.model import uniform_init
+from torch import Tensor, nn
+
+from mmdet.registry import MODELS
+from ..layers import SinePositionalEncoding
+from ..layers.transformer import (DABDetrTransformerDecoder,
+                                  DABDetrTransformerEncoder, inverse_sigmoid)
+from .detr import DETR
+
+
+@MODELS.register_module()
+class DABDETR(DETR):
+    r"""Implementation of `DAB-DETR:
+    Dynamic Anchor Boxes are Better Queries for DETR.
+
+    `_.
+
+    Code is modified from the `official github repo
+    `_.
+
+    Args:
+        with_random_refpoints (bool): Whether to randomly initialize query
+            embeddings and not update them during training.
+            Defaults to False.
+        num_patterns (int): Inspired by Anchor-DETR. Defaults to 0.
+    """
+
+    def __init__(self,
+                 *args,
+                 with_random_refpoints: bool = False,
+                 num_patterns: int = 0,
+                 **kwargs) -> None:
+        self.with_random_refpoints = with_random_refpoints
+        assert isinstance(num_patterns, int), \
+            f'num_patterns should be int but {num_patterns}.'
+        self.num_patterns = num_patterns
+
+        super().__init__(*args, **kwargs)
+
+    def _init_layers(self) -> None:
+        """Initialize layers except for backbone, neck and bbox_head."""
+        self.positional_encoding = SinePositionalEncoding(
+            **self.positional_encoding)
+        self.encoder = DABDetrTransformerEncoder(**self.encoder)
+        self.decoder = DABDetrTransformerDecoder(**self.decoder)
+        self.embed_dims = self.encoder.embed_dims
+        self.query_dim = self.decoder.query_dim
+        self.query_embedding = nn.Embedding(self.num_queries, self.query_dim)
+        if self.num_patterns > 0:
+            self.patterns = nn.Embedding(self.num_patterns, self.embed_dims)
+
+        num_feats = self.positional_encoding.num_feats
+        assert num_feats * 2 == self.embed_dims, \
+            f'embed_dims should be exactly 2 times of num_feats. ' \
+            f'Found {self.embed_dims} and {num_feats}.'
+
+    def init_weights(self) -> None:
+        """Initialize weights for Transformer and other components."""
+        super(DABDETR, self).init_weights()
+        if self.with_random_refpoints:
+            uniform_init(self.query_embedding)
+            self.query_embedding.weight.data[:, :2] = \
+                inverse_sigmoid(self.query_embedding.weight.data[:, :2])
+            self.query_embedding.weight.data[:, :2].requires_grad = False
+
+    def pre_decoder(self, memory: Tensor) -> Tuple[Dict, Dict]:
+        """Prepare intermediate variables before entering Transformer decoder,
+        such as `query`, `query_pos`.
+
+        Args:
+            memory (Tensor): The output embeddings of the Transformer encoder,
+                has shape (bs, num_feat_points, dim).
+
+        Returns:
+            tuple[dict, dict]: The first dict contains the inputs of decoder
+            and the second dict contains the inputs of the bbox_head function.
+
+            - decoder_inputs_dict (dict): The keyword args dictionary of
+                `self.forward_decoder()`, which includes 'query', 'query_pos',
+                'memory' and 'reg_branches'.
+            - head_inputs_dict (dict): The keyword args dictionary of the
+                bbox_head functions, which is usually empty, or includes
+                `enc_outputs_class` and `enc_outputs_class` when the detector
+                support 'two stage' or 'query selection' strategies.
+        """
+        batch_size = memory.size(0)
+        query_pos = self.query_embedding.weight
+        query_pos = query_pos.unsqueeze(0).repeat(batch_size, 1, 1)
+        if self.num_patterns == 0:
+            query = query_pos.new_zeros(batch_size, self.num_queries,
+                                        self.embed_dims)
+        else:
+            query = self.patterns.weight[:, None, None, :]\
+                .repeat(1, self.num_queries, batch_size, 1)\
+                .view(-1, batch_size, self.embed_dims)\
+                .permute(1, 0, 2)
+            query_pos = query_pos.repeat(1, self.num_patterns, 1)
+
+        decoder_inputs_dict = dict(
+            query_pos=query_pos, query=query, memory=memory)
+        head_inputs_dict = dict()
+        return decoder_inputs_dict, head_inputs_dict
+
+    def forward_decoder(self, query: Tensor, query_pos: Tensor, memory: Tensor,
+                        memory_mask: Tensor, memory_pos: Tensor) -> Dict:
+        """Forward with Transformer decoder.
+
+        Args:
+            query (Tensor): The queries of decoder inputs, has shape
+                (bs, num_queries, dim).
+            query_pos (Tensor): The positional queries of decoder inputs,
+                has shape (bs, num_queries, dim).
+            memory (Tensor): The output embeddings of the Transformer encoder,
+                has shape (bs, num_feat_points, dim).
+            memory_mask (Tensor): ByteTensor, the padding mask of the memory,
+                has shape (bs, num_feat_points).
+            memory_pos (Tensor): The positional embeddings of memory, has
+                shape (bs, num_feat_points, dim).
+
+        Returns:
+            dict: The dictionary of decoder outputs, which includes the
+            `hidden_states` and `references` of the decoder output.
+        """
+
+        hidden_states, references = self.decoder(
+            query=query,
+            key=memory,
+            query_pos=query_pos,
+            key_pos=memory_pos,
+            key_padding_mask=memory_mask,
+            reg_branches=self.bbox_head.
+            fc_reg  # iterative refinement for anchor boxes
+        )
+        head_inputs_dict = dict(
+            hidden_states=hidden_states, references=references)
+        return head_inputs_dict
diff --git a/mmdetection/mmdet/models/detectors/ddod.py b/mmdetection/mmdet/models/detectors/ddod.py
new file mode 100644
index 00000000..3503a40c
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/ddod.py
@@ -0,0 +1,41 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage import SingleStageDetector
+
+
+@MODELS.register_module()
+class DDOD(SingleStageDetector):
+    """Implementation of `DDOD `_.
+
+    Args:
+        backbone (:obj:`ConfigDict` or dict): The backbone module.
+        neck (:obj:`ConfigDict` or dict): The neck module.
+        bbox_head (:obj:`ConfigDict` or dict): The bbox head module.
+        train_cfg (:obj:`ConfigDict` or dict, optional): The training config
+            of ATSS. Defaults to None.
+        test_cfg (:obj:`ConfigDict` or dict, optional): The testing config
+            of ATSS. Defaults to None.
+        data_preprocessor (:obj:`ConfigDict` or dict, optional): Config of
+            :class:`DetDataPreprocessor` to process the input data.
+            Defaults to None.
+        init_cfg (:obj:`ConfigDict` or dict, optional): the config to control
+            the initialization. Defaults to None.
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/ddq_detr.py b/mmdetection/mmdet/models/detectors/ddq_detr.py
new file mode 100644
index 00000000..57d4959d
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/ddq_detr.py
@@ -0,0 +1,274 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, Tuple
+
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from mmcv.ops import MultiScaleDeformableAttention, batched_nms
+from torch import Tensor, nn
+from torch.nn.init import normal_
+
+from mmdet.registry import MODELS
+from mmdet.structures import OptSampleList
+from mmdet.structures.bbox import bbox_cxcywh_to_xyxy
+from mmdet.utils import OptConfigType
+from ..layers import DDQTransformerDecoder
+from ..utils import align_tensor
+from .deformable_detr import DeformableDETR
+from .dino import DINO
+
+
+@MODELS.register_module()
+class DDQDETR(DINO):
+    r"""Implementation of `Dense Distinct Query for
+    End-to-End Object Detection `_
+
+    Code is modified from the `official github repo
+    `_.
+
+    Args:
+        dense_topk_ratio (float): Ratio of num_dense queries to num_queries.
+            Defaults to 1.5.
+        dqs_cfg (:obj:`ConfigDict` or dict, optional): Config of
+            Distinct Queries Selection. Defaults to nms with
+            `iou_threshold` = 0.8.
+    """
+
+    def __init__(self,
+                 *args,
+                 dense_topk_ratio: float = 1.5,
+                 dqs_cfg: OptConfigType = dict(type='nms', iou_threshold=0.8),
+                 **kwargs):
+        self.dense_topk_ratio = dense_topk_ratio
+        self.decoder_cfg = kwargs['decoder']
+        self.dqs_cfg = dqs_cfg
+        super().__init__(*args, **kwargs)
+
+        # a share dict in all moduls
+        # pass some intermediate results and config parameters
+        cache_dict = dict()
+        for m in self.modules():
+            m.cache_dict = cache_dict
+        # first element is the start index of matching queries
+        # second element is the number of matching queries
+        self.cache_dict['dis_query_info'] = [0, 0]
+
+        # mask for distinct queries in each decoder layer
+        self.cache_dict['distinct_query_mask'] = []
+        # pass to decoder do the dqs
+        self.cache_dict['cls_branches'] = self.bbox_head.cls_branches
+        # Used to construct the attention mask after dqs
+        self.cache_dict['num_heads'] = self.encoder.layers[
+            0].self_attn.num_heads
+        # pass to decoder to do the dqs
+        self.cache_dict['dqs_cfg'] = self.dqs_cfg
+
+    def _init_layers(self) -> None:
+        """Initialize layers except for backbone, neck and bbox_head."""
+        super(DDQDETR, self)._init_layers()
+        self.decoder = DDQTransformerDecoder(**self.decoder_cfg)
+        self.query_embedding = None
+        self.query_map = nn.Linear(self.embed_dims, self.embed_dims)
+
+    def init_weights(self) -> None:
+        """Initialize weights for Transformer and other components."""
+        super(DeformableDETR, self).init_weights()
+        for coder in self.encoder, self.decoder:
+            for p in coder.parameters():
+                if p.dim() > 1:
+                    nn.init.xavier_uniform_(p)
+        for m in self.modules():
+            if isinstance(m, MultiScaleDeformableAttention):
+                m.init_weights()
+        nn.init.xavier_uniform_(self.memory_trans_fc.weight)
+        normal_(self.level_embed)
+
+    def pre_decoder(
+        self,
+        memory: Tensor,
+        memory_mask: Tensor,
+        spatial_shapes: Tensor,
+        batch_data_samples: OptSampleList = None,
+    ) -> Tuple[Dict]:
+        """Prepare intermediate variables before entering Transformer decoder,
+        such as `query`, `memory`, and `reference_points`.
+
+        Args:
+            memory (Tensor): The output embeddings of the Transformer encoder,
+                has shape (bs, num_feat_points, dim).
+            memory_mask (Tensor): ByteTensor, the padding mask of the memory,
+                has shape (bs, num_feat_points). Will only be used when
+                `as_two_stage` is `True`.
+            spatial_shapes (Tensor): Spatial shapes of features in all levels.
+                With shape (num_levels, 2), last dimension represents (h, w).
+                Will only be used when `as_two_stage` is `True`.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+                Defaults to None.
+
+        Returns:
+            tuple[dict]: The decoder_inputs_dict and head_inputs_dict.
+
+            - decoder_inputs_dict (dict): The keyword dictionary args of
+              `self.forward_decoder()`, which includes 'query', 'memory',
+              `reference_points`, and `dn_mask`. The reference points of
+              decoder input here are 4D boxes, although it has `points`
+              in its name.
+            - head_inputs_dict (dict): The keyword dictionary args of the
+              bbox_head functions, which includes `topk_score`, `topk_coords`,
+              `dense_topk_score`, `dense_topk_coords`,
+              and `dn_meta`, when `self.training` is `True`, else is empty.
+        """
+        bs, _, c = memory.shape
+        output_memory, output_proposals = self.gen_encoder_output_proposals(
+            memory, memory_mask, spatial_shapes)
+        enc_outputs_class = self.bbox_head.cls_branches[
+            self.decoder.num_layers](
+                output_memory)
+        enc_outputs_coord_unact = self.bbox_head.reg_branches[
+            self.decoder.num_layers](output_memory) + output_proposals
+
+        if self.training:
+            # aux dense branch particularly in DDQ DETR, which doesn't exist
+            #   in DINO.
+            # -1 is the aux head for the encoder
+            dense_enc_outputs_class = self.bbox_head.cls_branches[-1](
+                output_memory)
+            dense_enc_outputs_coord_unact = self.bbox_head.reg_branches[-1](
+                output_memory) + output_proposals
+
+        topk = self.num_queries
+        dense_topk = int(topk * self.dense_topk_ratio)
+
+        proposals = enc_outputs_coord_unact.sigmoid()
+        proposals = bbox_cxcywh_to_xyxy(proposals)
+        scores = enc_outputs_class.max(-1)[0].sigmoid()
+
+        if self.training:
+            # aux dense branch particularly in DDQ DETR, which doesn't exist
+            #   in DINO.
+            dense_proposals = dense_enc_outputs_coord_unact.sigmoid()
+            dense_proposals = bbox_cxcywh_to_xyxy(dense_proposals)
+            dense_scores = dense_enc_outputs_class.max(-1)[0].sigmoid()
+
+        num_imgs = len(scores)
+        topk_score = []
+        topk_coords_unact = []
+        # Distinct query.
+        query = []
+
+        dense_topk_score = []
+        dense_topk_coords_unact = []
+        dense_query = []
+
+        for img_id in range(num_imgs):
+            single_proposals = proposals[img_id]
+            single_scores = scores[img_id]
+
+            # `batched_nms` of class scores and bbox coordinations is used
+            #   particularly by DDQ DETR for region proposal generation,
+            #   instead of `topk` of class scores by DINO.
+            _, keep_idxs = batched_nms(
+                single_proposals, single_scores,
+                torch.ones(len(single_scores), device=single_scores.device),
+                self.cache_dict['dqs_cfg'])
+
+            if self.training:
+                # aux dense branch particularly in DDQ DETR, which doesn't
+                #   exist in DINO.
+                dense_single_proposals = dense_proposals[img_id]
+                dense_single_scores = dense_scores[img_id]
+                # sort according the score
+                # Only sort by classification score, neither nms nor topk is
+                #   required. So input parameter `nms_cfg` = None.
+                _, dense_keep_idxs = batched_nms(
+                    dense_single_proposals, dense_single_scores,
+                    torch.ones(
+                        len(dense_single_scores),
+                        device=dense_single_scores.device), None)
+
+                dense_topk_score.append(dense_enc_outputs_class[img_id]
+                                        [dense_keep_idxs][:dense_topk])
+                dense_topk_coords_unact.append(
+                    dense_enc_outputs_coord_unact[img_id][dense_keep_idxs]
+                    [:dense_topk])
+
+            topk_score.append(enc_outputs_class[img_id][keep_idxs][:topk])
+
+            # Instead of initializing the content part with transformed
+            #   coordinates in Deformable DETR, we fuse the feature map
+            #   embedding of distinct positions as the content part, which
+            #   makes the initial queries more distinct.
+            topk_coords_unact.append(
+                enc_outputs_coord_unact[img_id][keep_idxs][:topk])
+
+            map_memory = self.query_map(memory[img_id].detach())
+            query.append(map_memory[keep_idxs][:topk])
+            if self.training:
+                # aux dense branch particularly in DDQ DETR, which doesn't
+                # exist in DINO.
+                dense_query.append(map_memory[dense_keep_idxs][:dense_topk])
+
+        topk_score = align_tensor(topk_score, topk)
+        topk_coords_unact = align_tensor(topk_coords_unact, topk)
+        query = align_tensor(query, topk)
+        if self.training:
+            dense_topk_score = align_tensor(dense_topk_score)
+            dense_topk_coords_unact = align_tensor(dense_topk_coords_unact)
+
+            dense_query = align_tensor(dense_query)
+            num_dense_queries = dense_query.size(1)
+        if self.training:
+            query = torch.cat([query, dense_query], dim=1)
+            topk_coords_unact = torch.cat(
+                [topk_coords_unact, dense_topk_coords_unact], dim=1)
+
+        topk_coords = topk_coords_unact.sigmoid()
+        if self.training:
+            dense_topk_coords = topk_coords[:, -num_dense_queries:]
+            topk_coords = topk_coords[:, :-num_dense_queries]
+
+        topk_coords_unact = topk_coords_unact.detach()
+
+        if self.training:
+            dn_label_query, dn_bbox_query, dn_mask, dn_meta = \
+                self.dn_query_generator(batch_data_samples)
+            query = torch.cat([dn_label_query, query], dim=1)
+            reference_points = torch.cat([dn_bbox_query, topk_coords_unact],
+                                         dim=1)
+
+            # Update `dn_mask` to add mask for dense queries.
+            ori_size = dn_mask.size(-1)
+            new_size = dn_mask.size(-1) + num_dense_queries
+            new_dn_mask = dn_mask.new_ones((new_size, new_size)).bool()
+            dense_mask = torch.zeros(num_dense_queries,
+                                     num_dense_queries).bool()
+            self.cache_dict['dis_query_info'] = [dn_label_query.size(1), topk]
+
+            new_dn_mask[ori_size:, ori_size:] = dense_mask
+            new_dn_mask[:ori_size, :ori_size] = dn_mask
+            dn_meta['num_dense_queries'] = num_dense_queries
+            dn_mask = new_dn_mask
+            self.cache_dict['num_dense_queries'] = num_dense_queries
+            self.decoder.aux_reg_branches = self.bbox_head.aux_reg_branches
+
+        else:
+            self.cache_dict['dis_query_info'] = [0, topk]
+            reference_points = topk_coords_unact
+            dn_mask, dn_meta = None, None
+
+        reference_points = reference_points.sigmoid()
+
+        decoder_inputs_dict = dict(
+            query=query,
+            memory=memory,
+            reference_points=reference_points,
+            dn_mask=dn_mask)
+        head_inputs_dict = dict(
+            enc_outputs_class=topk_score,
+            enc_outputs_coord=topk_coords,
+            aux_enc_outputs_class=dense_topk_score,
+            aux_enc_outputs_coord=dense_topk_coords,
+            dn_meta=dn_meta) if self.training else dict()
+
+        return decoder_inputs_dict, head_inputs_dict
diff --git a/mmdetection/mmdet/models/detectors/deformable_detr.py b/mmdetection/mmdet/models/detectors/deformable_detr.py
new file mode 100644
index 00000000..0eb5cd2f
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/deformable_detr.py
@@ -0,0 +1,572 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+from typing import Dict, Tuple
+
+import torch
+import torch.nn.functional as F
+from mmcv.cnn.bricks.transformer import MultiScaleDeformableAttention
+from mmengine.model import xavier_init
+from torch import Tensor, nn
+from torch.nn.init import normal_
+
+from mmdet.registry import MODELS
+from mmdet.structures import OptSampleList
+from mmdet.utils import OptConfigType
+from ..layers import (DeformableDetrTransformerDecoder,
+                      DeformableDetrTransformerEncoder, SinePositionalEncoding)
+from .base_detr import DetectionTransformer
+
+
+@MODELS.register_module()
+class DeformableDETR(DetectionTransformer):
+    r"""Implementation of `Deformable DETR: Deformable Transformers for
+    End-to-End Object Detection `_
+
+    Code is modified from the `official github repo
+    `_.
+
+    Args:
+        decoder (:obj:`ConfigDict` or dict, optional): Config of the
+            Transformer decoder. Defaults to None.
+        bbox_head (:obj:`ConfigDict` or dict, optional): Config for the
+            bounding box head module. Defaults to None.
+        with_box_refine (bool, optional): Whether to refine the references
+            in the decoder. Defaults to `False`.
+        as_two_stage (bool, optional): Whether to generate the proposal
+            from the outputs of encoder. Defaults to `False`.
+        num_feature_levels (int, optional): Number of feature levels.
+            Defaults to 4.
+    """
+
+    def __init__(self,
+                 *args,
+                 decoder: OptConfigType = None,
+                 bbox_head: OptConfigType = None,
+                 with_box_refine: bool = False,
+                 as_two_stage: bool = False,
+                 num_feature_levels: int = 4,
+                 **kwargs) -> None:
+        self.with_box_refine = with_box_refine
+        self.as_two_stage = as_two_stage
+        self.num_feature_levels = num_feature_levels
+
+        if bbox_head is not None:
+            assert 'share_pred_layer' not in bbox_head and \
+                   'num_pred_layer' not in bbox_head and \
+                   'as_two_stage' not in bbox_head, \
+                'The two keyword args `share_pred_layer`, `num_pred_layer`, ' \
+                'and `as_two_stage are set in `detector.__init__()`, users ' \
+                'should not set them in `bbox_head` config.'
+            # The last prediction layer is used to generate proposal
+            # from encode feature map when `as_two_stage` is `True`.
+            # And all the prediction layers should share parameters
+            # when `with_box_refine` is `True`.
+            bbox_head['share_pred_layer'] = not with_box_refine
+            bbox_head['num_pred_layer'] = (decoder['num_layers'] + 1) \
+                if self.as_two_stage else decoder['num_layers']
+            bbox_head['as_two_stage'] = as_two_stage
+
+        super().__init__(*args, decoder=decoder, bbox_head=bbox_head, **kwargs)
+
+    def _init_layers(self) -> None:
+        """Initialize layers except for backbone, neck and bbox_head."""
+        self.positional_encoding = SinePositionalEncoding(
+            **self.positional_encoding)
+        self.encoder = DeformableDetrTransformerEncoder(**self.encoder)
+        self.decoder = DeformableDetrTransformerDecoder(**self.decoder)
+        self.embed_dims = self.encoder.embed_dims
+        if not self.as_two_stage:
+            self.query_embedding = nn.Embedding(self.num_queries,
+                                                self.embed_dims * 2)
+            # NOTE The query_embedding will be split into query and query_pos
+            # in self.pre_decoder, hence, the embed_dims are doubled.
+
+        num_feats = self.positional_encoding.num_feats
+        assert num_feats * 2 == self.embed_dims, \
+            'embed_dims should be exactly 2 times of num_feats. ' \
+            f'Found {self.embed_dims} and {num_feats}.'
+
+        self.level_embed = nn.Parameter(
+            torch.Tensor(self.num_feature_levels, self.embed_dims))
+
+        if self.as_two_stage:
+            self.memory_trans_fc = nn.Linear(self.embed_dims, self.embed_dims)
+            self.memory_trans_norm = nn.LayerNorm(self.embed_dims)
+            self.pos_trans_fc = nn.Linear(self.embed_dims * 2,
+                                          self.embed_dims * 2)
+            self.pos_trans_norm = nn.LayerNorm(self.embed_dims * 2)
+        else:
+            self.reference_points_fc = nn.Linear(self.embed_dims, 2)
+
+    def init_weights(self) -> None:
+        """Initialize weights for Transformer and other components."""
+        super().init_weights()
+        for coder in self.encoder, self.decoder:
+            for p in coder.parameters():
+                if p.dim() > 1:
+                    nn.init.xavier_uniform_(p)
+        for m in self.modules():
+            if isinstance(m, MultiScaleDeformableAttention):
+                m.init_weights()
+        if self.as_two_stage:
+            nn.init.xavier_uniform_(self.memory_trans_fc.weight)
+            nn.init.xavier_uniform_(self.pos_trans_fc.weight)
+        else:
+            xavier_init(
+                self.reference_points_fc, distribution='uniform', bias=0.)
+        normal_(self.level_embed)
+
+    def pre_transformer(
+            self,
+            mlvl_feats: Tuple[Tensor],
+            batch_data_samples: OptSampleList = None) -> Tuple[Dict]:
+        """Process image features before feeding them to the transformer.
+
+        The forward procedure of the transformer is defined as:
+        'pre_transformer' -> 'encoder' -> 'pre_decoder' -> 'decoder'
+        More details can be found at `TransformerDetector.forward_transformer`
+        in `mmdet/detector/base_detr.py`.
+
+        Args:
+            mlvl_feats (tuple[Tensor]): Multi-level features that may have
+                different resolutions, output from neck. Each feature has
+                shape (bs, dim, h_lvl, w_lvl), where 'lvl' means 'layer'.
+            batch_data_samples (list[:obj:`DetDataSample`], optional): The
+                batch data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+                Defaults to None.
+
+        Returns:
+            tuple[dict]: The first dict contains the inputs of encoder and the
+            second dict contains the inputs of decoder.
+
+            - encoder_inputs_dict (dict): The keyword args dictionary of
+              `self.forward_encoder()`, which includes 'feat', 'feat_mask',
+              and 'feat_pos'.
+            - decoder_inputs_dict (dict): The keyword args dictionary of
+              `self.forward_decoder()`, which includes 'memory_mask'.
+        """
+        batch_size = mlvl_feats[0].size(0)
+
+        # construct binary masks for the transformer.
+        assert batch_data_samples is not None
+        batch_input_shape = batch_data_samples[0].batch_input_shape
+        input_img_h, input_img_w = batch_input_shape
+        img_shape_list = [sample.img_shape for sample in batch_data_samples]
+        same_shape_flag = all([
+            s[0] == input_img_h and s[1] == input_img_w for s in img_shape_list
+        ])
+        # support torch2onnx without feeding masks
+        if torch.onnx.is_in_onnx_export() or same_shape_flag:
+            mlvl_masks = []
+            mlvl_pos_embeds = []
+            for feat in mlvl_feats:
+                mlvl_masks.append(None)
+                mlvl_pos_embeds.append(
+                    self.positional_encoding(None, input=feat))
+        else:
+            masks = mlvl_feats[0].new_ones(
+                (batch_size, input_img_h, input_img_w))
+            for img_id in range(batch_size):
+                img_h, img_w = img_shape_list[img_id]
+                masks[img_id, :img_h, :img_w] = 0
+            # NOTE following the official DETR repo, non-zero
+            # values representing ignored positions, while
+            # zero values means valid positions.
+
+            mlvl_masks = []
+            mlvl_pos_embeds = []
+            for feat in mlvl_feats:
+                mlvl_masks.append(
+                    F.interpolate(masks[None], size=feat.shape[-2:]).to(
+                        torch.bool).squeeze(0))
+                mlvl_pos_embeds.append(
+                    self.positional_encoding(mlvl_masks[-1]))
+
+        feat_flatten = []
+        lvl_pos_embed_flatten = []
+        mask_flatten = []
+        spatial_shapes = []
+        for lvl, (feat, mask, pos_embed) in enumerate(
+                zip(mlvl_feats, mlvl_masks, mlvl_pos_embeds)):
+            batch_size, c, h, w = feat.shape
+            spatial_shape = torch._shape_as_tensor(feat)[2:].to(feat.device)
+            # [bs, c, h_lvl, w_lvl] -> [bs, h_lvl*w_lvl, c]
+            feat = feat.view(batch_size, c, -1).permute(0, 2, 1)
+            pos_embed = pos_embed.view(batch_size, c, -1).permute(0, 2, 1)
+            lvl_pos_embed = pos_embed + self.level_embed[lvl].view(1, 1, -1)
+            # [bs, h_lvl, w_lvl] -> [bs, h_lvl*w_lvl]
+            if mask is not None:
+                mask = mask.flatten(1)
+
+            feat_flatten.append(feat)
+            lvl_pos_embed_flatten.append(lvl_pos_embed)
+            mask_flatten.append(mask)
+            spatial_shapes.append(spatial_shape)
+
+        # (bs, num_feat_points, dim)
+        feat_flatten = torch.cat(feat_flatten, 1)
+        lvl_pos_embed_flatten = torch.cat(lvl_pos_embed_flatten, 1)
+        # (bs, num_feat_points), where num_feat_points = sum_lvl(h_lvl*w_lvl)
+        if mask_flatten[0] is not None:
+            mask_flatten = torch.cat(mask_flatten, 1)
+        else:
+            mask_flatten = None
+
+        # (num_level, 2)
+        spatial_shapes = torch.cat(spatial_shapes).view(-1, 2)
+        level_start_index = torch.cat((
+            spatial_shapes.new_zeros((1, )),  # (num_level)
+            spatial_shapes.prod(1).cumsum(0)[:-1]))
+        if mlvl_masks[0] is not None:
+            valid_ratios = torch.stack(  # (bs, num_level, 2)
+                [self.get_valid_ratio(m) for m in mlvl_masks], 1)
+        else:
+            valid_ratios = mlvl_feats[0].new_ones(batch_size, len(mlvl_feats),
+                                                  2)
+
+        encoder_inputs_dict = dict(
+            feat=feat_flatten,
+            feat_mask=mask_flatten,
+            feat_pos=lvl_pos_embed_flatten,
+            spatial_shapes=spatial_shapes,
+            level_start_index=level_start_index,
+            valid_ratios=valid_ratios)
+        decoder_inputs_dict = dict(
+            memory_mask=mask_flatten,
+            spatial_shapes=spatial_shapes,
+            level_start_index=level_start_index,
+            valid_ratios=valid_ratios)
+        return encoder_inputs_dict, decoder_inputs_dict
+
+    def forward_encoder(self, feat: Tensor, feat_mask: Tensor,
+                        feat_pos: Tensor, spatial_shapes: Tensor,
+                        level_start_index: Tensor,
+                        valid_ratios: Tensor) -> Dict:
+        """Forward with Transformer encoder.
+
+        The forward procedure of the transformer is defined as:
+        'pre_transformer' -> 'encoder' -> 'pre_decoder' -> 'decoder'
+        More details can be found at `TransformerDetector.forward_transformer`
+        in `mmdet/detector/base_detr.py`.
+
+        Args:
+            feat (Tensor): Sequential features, has shape (bs, num_feat_points,
+                dim).
+            feat_mask (Tensor): ByteTensor, the padding mask of the features,
+                has shape (bs, num_feat_points).
+            feat_pos (Tensor): The positional embeddings of the features, has
+                shape (bs, num_feat_points, dim).
+            spatial_shapes (Tensor): Spatial shapes of features in all levels,
+                has shape (num_levels, 2), last dimension represents (h, w).
+            level_start_index (Tensor): The start index of each level.
+                A tensor has shape (num_levels, ) and can be represented
+                as [0, h_0*w_0, h_0*w_0+h_1*w_1, ...].
+            valid_ratios (Tensor): The ratios of the valid width and the valid
+                height relative to the width and the height of features in all
+                levels, has shape (bs, num_levels, 2).
+
+        Returns:
+            dict: The dictionary of encoder outputs, which includes the
+            `memory` of the encoder output.
+        """
+        memory = self.encoder(
+            query=feat,
+            query_pos=feat_pos,
+            key_padding_mask=feat_mask,  # for self_attn
+            spatial_shapes=spatial_shapes,
+            level_start_index=level_start_index,
+            valid_ratios=valid_ratios)
+        encoder_outputs_dict = dict(
+            memory=memory,
+            memory_mask=feat_mask,
+            spatial_shapes=spatial_shapes)
+        return encoder_outputs_dict
+
+    def pre_decoder(self, memory: Tensor, memory_mask: Tensor,
+                    spatial_shapes: Tensor) -> Tuple[Dict, Dict]:
+        """Prepare intermediate variables before entering Transformer decoder,
+        such as `query`, `query_pos`, and `reference_points`.
+
+        The forward procedure of the transformer is defined as:
+        'pre_transformer' -> 'encoder' -> 'pre_decoder' -> 'decoder'
+        More details can be found at `TransformerDetector.forward_transformer`
+        in `mmdet/detector/base_detr.py`.
+
+        Args:
+            memory (Tensor): The output embeddings of the Transformer encoder,
+                has shape (bs, num_feat_points, dim).
+            memory_mask (Tensor): ByteTensor, the padding mask of the memory,
+                has shape (bs, num_feat_points). It will only be used when
+                `as_two_stage` is `True`.
+            spatial_shapes (Tensor): Spatial shapes of features in all levels,
+                has shape (num_levels, 2), last dimension represents (h, w).
+                It will only be used when `as_two_stage` is `True`.
+
+        Returns:
+            tuple[dict, dict]: The decoder_inputs_dict and head_inputs_dict.
+
+            - decoder_inputs_dict (dict): The keyword dictionary args of
+              `self.forward_decoder()`, which includes 'query', 'query_pos',
+              'memory', and `reference_points`. The reference_points of
+              decoder input here are 4D boxes when `as_two_stage` is `True`,
+              otherwise 2D points, although it has `points` in its name.
+              The reference_points in encoder is always 2D points.
+            - head_inputs_dict (dict): The keyword dictionary args of the
+              bbox_head functions, which includes `enc_outputs_class` and
+              `enc_outputs_coord`. They are both `None` when 'as_two_stage'
+              is `False`. The dict is empty when `self.training` is `False`.
+        """
+        batch_size, _, c = memory.shape
+        if self.as_two_stage:
+            output_memory, output_proposals = \
+                self.gen_encoder_output_proposals(
+                    memory, memory_mask, spatial_shapes)
+            enc_outputs_class = self.bbox_head.cls_branches[
+                self.decoder.num_layers](
+                    output_memory)
+            enc_outputs_coord_unact = self.bbox_head.reg_branches[
+                self.decoder.num_layers](output_memory) + output_proposals
+            enc_outputs_coord = enc_outputs_coord_unact.sigmoid()
+            # We only use the first channel in enc_outputs_class as foreground,
+            # the other (num_classes - 1) channels are actually not used.
+            # Its targets are set to be 0s, which indicates the first
+            # class (foreground) because we use [0, num_classes - 1] to
+            # indicate class labels, background class is indicated by
+            # num_classes (similar convention in RPN).
+            # See https://github.com/open-mmlab/mmdetection/blob/master/mmdet/models/dense_heads/deformable_detr_head.py#L241 # noqa
+            # This follows the official implementation of Deformable DETR.
+            topk_proposals = torch.topk(
+                enc_outputs_class[..., 0], self.num_queries, dim=1)[1]
+            topk_coords_unact = torch.gather(
+                enc_outputs_coord_unact, 1,
+                topk_proposals.unsqueeze(-1).repeat(1, 1, 4))
+            topk_coords_unact = topk_coords_unact.detach()
+            reference_points = topk_coords_unact.sigmoid()
+            pos_trans_out = self.pos_trans_fc(
+                self.get_proposal_pos_embed(topk_coords_unact))
+            pos_trans_out = self.pos_trans_norm(pos_trans_out)
+            query_pos, query = torch.split(pos_trans_out, c, dim=2)
+        else:
+            enc_outputs_class, enc_outputs_coord = None, None
+            query_embed = self.query_embedding.weight
+            query_pos, query = torch.split(query_embed, c, dim=1)
+            query_pos = query_pos.unsqueeze(0).expand(batch_size, -1, -1)
+            query = query.unsqueeze(0).expand(batch_size, -1, -1)
+            reference_points = self.reference_points_fc(query_pos).sigmoid()
+
+        decoder_inputs_dict = dict(
+            query=query,
+            query_pos=query_pos,
+            memory=memory,
+            reference_points=reference_points)
+        head_inputs_dict = dict(
+            enc_outputs_class=enc_outputs_class,
+            enc_outputs_coord=enc_outputs_coord) if self.training else dict()
+        return decoder_inputs_dict, head_inputs_dict
+
+    def forward_decoder(self, query: Tensor, query_pos: Tensor, memory: Tensor,
+                        memory_mask: Tensor, reference_points: Tensor,
+                        spatial_shapes: Tensor, level_start_index: Tensor,
+                        valid_ratios: Tensor) -> Dict:
+        """Forward with Transformer decoder.
+
+        The forward procedure of the transformer is defined as:
+        'pre_transformer' -> 'encoder' -> 'pre_decoder' -> 'decoder'
+        More details can be found at `TransformerDetector.forward_transformer`
+        in `mmdet/detector/base_detr.py`.
+
+        Args:
+            query (Tensor): The queries of decoder inputs, has shape
+                (bs, num_queries, dim).
+            query_pos (Tensor): The positional queries of decoder inputs,
+                has shape (bs, num_queries, dim).
+            memory (Tensor): The output embeddings of the Transformer encoder,
+                has shape (bs, num_feat_points, dim).
+            memory_mask (Tensor): ByteTensor, the padding mask of the memory,
+                has shape (bs, num_feat_points).
+            reference_points (Tensor): The initial reference, has shape
+                (bs, num_queries, 4) with the last dimension arranged as
+                (cx, cy, w, h) when `as_two_stage` is `True`, otherwise has
+                shape (bs, num_queries, 2) with the last dimension arranged as
+                (cx, cy).
+            spatial_shapes (Tensor): Spatial shapes of features in all levels,
+                has shape (num_levels, 2), last dimension represents (h, w).
+            level_start_index (Tensor): The start index of each level.
+                A tensor has shape (num_levels, ) and can be represented
+                as [0, h_0*w_0, h_0*w_0+h_1*w_1, ...].
+            valid_ratios (Tensor): The ratios of the valid width and the valid
+                height relative to the width and the height of features in all
+                levels, has shape (bs, num_levels, 2).
+
+        Returns:
+            dict: The dictionary of decoder outputs, which includes the
+            `hidden_states` of the decoder output and `references` including
+            the initial and intermediate reference_points.
+        """
+        inter_states, inter_references = self.decoder(
+            query=query,
+            value=memory,
+            query_pos=query_pos,
+            key_padding_mask=memory_mask,  # for cross_attn
+            reference_points=reference_points,
+            spatial_shapes=spatial_shapes,
+            level_start_index=level_start_index,
+            valid_ratios=valid_ratios,
+            reg_branches=self.bbox_head.reg_branches
+            if self.with_box_refine else None)
+        references = [reference_points, *inter_references]
+        decoder_outputs_dict = dict(
+            hidden_states=inter_states, references=references)
+        return decoder_outputs_dict
+
+    @staticmethod
+    def get_valid_ratio(mask: Tensor) -> Tensor:
+        """Get the valid radios of feature map in a level.
+
+        .. code:: text
+
+                    |---> valid_W <---|
+                 ---+-----------------+-----+---
+                  A |                 |     | A
+                  | |                 |     | |
+                  | |                 |     | |
+            valid_H |                 |     | |
+                  | |                 |     | H
+                  | |                 |     | |
+                  V |                 |     | |
+                 ---+-----------------+     | |
+                    |                       | V
+                    +-----------------------+---
+                    |---------> W <---------|
+
+          The valid_ratios are defined as:
+                r_h = valid_H / H,  r_w = valid_W / W
+          They are the factors to re-normalize the relative coordinates of the
+          image to the relative coordinates of the current level feature map.
+
+        Args:
+            mask (Tensor): Binary mask of a feature map, has shape (bs, H, W).
+
+        Returns:
+            Tensor: valid ratios [r_w, r_h] of a feature map, has shape (1, 2).
+        """
+        _, H, W = mask.shape
+        valid_H = torch.sum(~mask[:, :, 0], 1)
+        valid_W = torch.sum(~mask[:, 0, :], 1)
+        valid_ratio_h = valid_H.float() / H
+        valid_ratio_w = valid_W.float() / W
+        valid_ratio = torch.stack([valid_ratio_w, valid_ratio_h], -1)
+        return valid_ratio
+
+    def gen_encoder_output_proposals(
+            self, memory: Tensor, memory_mask: Tensor,
+            spatial_shapes: Tensor) -> Tuple[Tensor, Tensor]:
+        """Generate proposals from encoded memory. The function will only be
+        used when `as_two_stage` is `True`.
+
+        Args:
+            memory (Tensor): The output embeddings of the Transformer encoder,
+                has shape (bs, num_feat_points, dim).
+            memory_mask (Tensor): ByteTensor, the padding mask of the memory,
+                has shape (bs, num_feat_points).
+            spatial_shapes (Tensor): Spatial shapes of features in all levels,
+                has shape (num_levels, 2), last dimension represents (h, w).
+
+        Returns:
+            tuple: A tuple of transformed memory and proposals.
+
+            - output_memory (Tensor): The transformed memory for obtaining
+              top-k proposals, has shape (bs, num_feat_points, dim).
+            - output_proposals (Tensor): The inverse-normalized proposal, has
+              shape (batch_size, num_keys, 4) with the last dimension arranged
+              as (cx, cy, w, h).
+        """
+
+        bs = memory.size(0)
+        proposals = []
+        _cur = 0  # start index in the sequence of the current level
+        for lvl, HW in enumerate(spatial_shapes):
+            H, W = HW
+
+            if memory_mask is not None:
+                mask_flatten_ = memory_mask[:, _cur:(_cur + H * W)].view(
+                    bs, H, W, 1)
+                valid_H = torch.sum(~mask_flatten_[:, :, 0, 0],
+                                    1).unsqueeze(-1)
+                valid_W = torch.sum(~mask_flatten_[:, 0, :, 0],
+                                    1).unsqueeze(-1)
+                scale = torch.cat([valid_W, valid_H], 1).view(bs, 1, 1, 2)
+            else:
+                if not isinstance(HW, torch.Tensor):
+                    HW = memory.new_tensor(HW)
+                scale = HW.unsqueeze(0).flip(dims=[0, 1]).view(1, 1, 1, 2)
+            grid_y, grid_x = torch.meshgrid(
+                torch.linspace(
+                    0, H - 1, H, dtype=torch.float32, device=memory.device),
+                torch.linspace(
+                    0, W - 1, W, dtype=torch.float32, device=memory.device))
+            grid = torch.cat([grid_x.unsqueeze(-1), grid_y.unsqueeze(-1)], -1)
+            grid = (grid.unsqueeze(0).expand(bs, -1, -1, -1) + 0.5) / scale
+            wh = torch.ones_like(grid) * 0.05 * (2.0**lvl)
+            proposal = torch.cat((grid, wh), -1).view(bs, -1, 4)
+            proposals.append(proposal)
+            _cur += (H * W)
+        output_proposals = torch.cat(proposals, 1)
+        # do not use `all` to make it exportable to onnx
+        output_proposals_valid = (
+            (output_proposals > 0.01) & (output_proposals < 0.99)).sum(
+                -1, keepdim=True) == output_proposals.shape[-1]
+        # inverse_sigmoid
+        output_proposals = torch.log(output_proposals / (1 - output_proposals))
+        if memory_mask is not None:
+            output_proposals = output_proposals.masked_fill(
+                memory_mask.unsqueeze(-1), float('inf'))
+        output_proposals = output_proposals.masked_fill(
+            ~output_proposals_valid, float('inf'))
+
+        output_memory = memory
+        if memory_mask is not None:
+            output_memory = output_memory.masked_fill(
+                memory_mask.unsqueeze(-1), float(0))
+        output_memory = output_memory.masked_fill(~output_proposals_valid,
+                                                  float(0))
+        output_memory = self.memory_trans_fc(output_memory)
+        output_memory = self.memory_trans_norm(output_memory)
+        # [bs, sum(hw), 2]
+        return output_memory, output_proposals
+
+    @staticmethod
+    def get_proposal_pos_embed(proposals: Tensor,
+                               num_pos_feats: int = 128,
+                               temperature: int = 10000) -> Tensor:
+        """Get the position embedding of the proposal.
+
+        Args:
+            proposals (Tensor): Not normalized proposals, has shape
+                (bs, num_queries, 4) with the last dimension arranged as
+                (cx, cy, w, h).
+            num_pos_feats (int, optional): The feature dimension for each
+                position along x, y, w, and h-axis. Note the final returned
+                dimension for each position is 4 times of num_pos_feats.
+                Default to 128.
+            temperature (int, optional): The temperature used for scaling the
+                position embedding. Defaults to 10000.
+
+        Returns:
+            Tensor: The position embedding of proposal, has shape
+            (bs, num_queries, num_pos_feats * 4), with the last dimension
+            arranged as (cx, cy, w, h)
+        """
+        scale = 2 * math.pi
+        dim_t = torch.arange(
+            num_pos_feats, dtype=torch.float32, device=proposals.device)
+        dim_t = temperature**(2 * (dim_t // 2) / num_pos_feats)
+        # N, L, 4
+        proposals = proposals.sigmoid() * scale
+        # N, L, 4, 128
+        pos = proposals[:, :, :, None] / dim_t
+        # N, L, 4, 64, 2
+        pos = torch.stack((pos[:, :, :, 0::2].sin(), pos[:, :, :, 1::2].cos()),
+                          dim=4).flatten(2)
+        return pos
diff --git a/mmdetection/mmdet/models/detectors/detr.py b/mmdetection/mmdet/models/detectors/detr.py
new file mode 100644
index 00000000..7895e9ec
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/detr.py
@@ -0,0 +1,225 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, Tuple
+
+import torch
+import torch.nn.functional as F
+from torch import Tensor, nn
+
+from mmdet.registry import MODELS
+from mmdet.structures import OptSampleList
+from ..layers import (DetrTransformerDecoder, DetrTransformerEncoder,
+                      SinePositionalEncoding)
+from .base_detr import DetectionTransformer
+
+
+@MODELS.register_module()
+class DETR(DetectionTransformer):
+    r"""Implementation of `DETR: End-to-End Object Detection with Transformers.
+
+    `_.
+
+    Code is modified from the `official github repo
+    `_.
+    """
+
+    def _init_layers(self) -> None:
+        """Initialize layers except for backbone, neck and bbox_head."""
+        self.positional_encoding = SinePositionalEncoding(
+            **self.positional_encoding)
+        self.encoder = DetrTransformerEncoder(**self.encoder)
+        self.decoder = DetrTransformerDecoder(**self.decoder)
+        self.embed_dims = self.encoder.embed_dims
+        # NOTE The embed_dims is typically passed from the inside out.
+        # For example in DETR, The embed_dims is passed as
+        # self_attn -> the first encoder layer -> encoder -> detector.
+        self.query_embedding = nn.Embedding(self.num_queries, self.embed_dims)
+
+        num_feats = self.positional_encoding.num_feats
+        assert num_feats * 2 == self.embed_dims, \
+            'embed_dims should be exactly 2 times of num_feats. ' \
+            f'Found {self.embed_dims} and {num_feats}.'
+
+    def init_weights(self) -> None:
+        """Initialize weights for Transformer and other components."""
+        super().init_weights()
+        for coder in self.encoder, self.decoder:
+            for p in coder.parameters():
+                if p.dim() > 1:
+                    nn.init.xavier_uniform_(p)
+
+    def pre_transformer(
+            self,
+            img_feats: Tuple[Tensor],
+            batch_data_samples: OptSampleList = None) -> Tuple[Dict, Dict]:
+        """Prepare the inputs of the Transformer.
+
+        The forward procedure of the transformer is defined as:
+        'pre_transformer' -> 'encoder' -> 'pre_decoder' -> 'decoder'
+        More details can be found at `TransformerDetector.forward_transformer`
+        in `mmdet/detector/base_detr.py`.
+
+        Args:
+            img_feats (Tuple[Tensor]): Tuple of features output from the neck,
+                has shape (bs, c, h, w).
+            batch_data_samples (List[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such as
+                `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+                Defaults to None.
+
+        Returns:
+            tuple[dict, dict]: The first dict contains the inputs of encoder
+            and the second dict contains the inputs of decoder.
+
+            - encoder_inputs_dict (dict): The keyword args dictionary of
+              `self.forward_encoder()`, which includes 'feat', 'feat_mask',
+              and 'feat_pos'.
+            - decoder_inputs_dict (dict): The keyword args dictionary of
+              `self.forward_decoder()`, which includes 'memory_mask',
+              and 'memory_pos'.
+        """
+
+        feat = img_feats[-1]  # NOTE img_feats contains only one feature.
+        batch_size, feat_dim, _, _ = feat.shape
+        # construct binary masks which for the transformer.
+        assert batch_data_samples is not None
+        batch_input_shape = batch_data_samples[0].batch_input_shape
+        input_img_h, input_img_w = batch_input_shape
+        img_shape_list = [sample.img_shape for sample in batch_data_samples]
+        same_shape_flag = all([
+            s[0] == input_img_h and s[1] == input_img_w for s in img_shape_list
+        ])
+        if torch.onnx.is_in_onnx_export() or same_shape_flag:
+            masks = None
+            # [batch_size, embed_dim, h, w]
+            pos_embed = self.positional_encoding(masks, input=feat)
+        else:
+            masks = feat.new_ones((batch_size, input_img_h, input_img_w))
+            for img_id in range(batch_size):
+                img_h, img_w = img_shape_list[img_id]
+                masks[img_id, :img_h, :img_w] = 0
+            # NOTE following the official DETR repo, non-zero values represent
+            # ignored positions, while zero values mean valid positions.
+
+            masks = F.interpolate(
+                masks.unsqueeze(1),
+                size=feat.shape[-2:]).to(torch.bool).squeeze(1)
+            # [batch_size, embed_dim, h, w]
+            pos_embed = self.positional_encoding(masks)
+
+        # use `view` instead of `flatten` for dynamically exporting to ONNX
+        # [bs, c, h, w] -> [bs, h*w, c]
+        feat = feat.view(batch_size, feat_dim, -1).permute(0, 2, 1)
+        pos_embed = pos_embed.view(batch_size, feat_dim, -1).permute(0, 2, 1)
+        # [bs, h, w] -> [bs, h*w]
+        if masks is not None:
+            masks = masks.view(batch_size, -1)
+
+        # prepare transformer_inputs_dict
+        encoder_inputs_dict = dict(
+            feat=feat, feat_mask=masks, feat_pos=pos_embed)
+        decoder_inputs_dict = dict(memory_mask=masks, memory_pos=pos_embed)
+        return encoder_inputs_dict, decoder_inputs_dict
+
+    def forward_encoder(self, feat: Tensor, feat_mask: Tensor,
+                        feat_pos: Tensor) -> Dict:
+        """Forward with Transformer encoder.
+
+        The forward procedure of the transformer is defined as:
+        'pre_transformer' -> 'encoder' -> 'pre_decoder' -> 'decoder'
+        More details can be found at `TransformerDetector.forward_transformer`
+        in `mmdet/detector/base_detr.py`.
+
+        Args:
+            feat (Tensor): Sequential features, has shape (bs, num_feat_points,
+                dim).
+            feat_mask (Tensor): ByteTensor, the padding mask of the features,
+                has shape (bs, num_feat_points).
+            feat_pos (Tensor): The positional embeddings of the features, has
+                shape (bs, num_feat_points, dim).
+
+        Returns:
+            dict: The dictionary of encoder outputs, which includes the
+            `memory` of the encoder output.
+        """
+        memory = self.encoder(
+            query=feat, query_pos=feat_pos,
+            key_padding_mask=feat_mask)  # for self_attn
+        encoder_outputs_dict = dict(memory=memory)
+        return encoder_outputs_dict
+
+    def pre_decoder(self, memory: Tensor) -> Tuple[Dict, Dict]:
+        """Prepare intermediate variables before entering Transformer decoder,
+        such as `query`, `query_pos`.
+
+        The forward procedure of the transformer is defined as:
+        'pre_transformer' -> 'encoder' -> 'pre_decoder' -> 'decoder'
+        More details can be found at `TransformerDetector.forward_transformer`
+        in `mmdet/detector/base_detr.py`.
+
+        Args:
+            memory (Tensor): The output embeddings of the Transformer encoder,
+                has shape (bs, num_feat_points, dim).
+
+        Returns:
+            tuple[dict, dict]: The first dict contains the inputs of decoder
+            and the second dict contains the inputs of the bbox_head function.
+
+            - decoder_inputs_dict (dict): The keyword args dictionary of
+              `self.forward_decoder()`, which includes 'query', 'query_pos',
+              'memory'.
+            - head_inputs_dict (dict): The keyword args dictionary of the
+              bbox_head functions, which is usually empty, or includes
+              `enc_outputs_class` and `enc_outputs_class` when the detector
+              support 'two stage' or 'query selection' strategies.
+        """
+
+        batch_size = memory.size(0)  # (bs, num_feat_points, dim)
+        query_pos = self.query_embedding.weight
+        # (num_queries, dim) -> (bs, num_queries, dim)
+        query_pos = query_pos.unsqueeze(0).repeat(batch_size, 1, 1)
+        query = torch.zeros_like(query_pos)
+
+        decoder_inputs_dict = dict(
+            query_pos=query_pos, query=query, memory=memory)
+        head_inputs_dict = dict()
+        return decoder_inputs_dict, head_inputs_dict
+
+    def forward_decoder(self, query: Tensor, query_pos: Tensor, memory: Tensor,
+                        memory_mask: Tensor, memory_pos: Tensor) -> Dict:
+        """Forward with Transformer decoder.
+
+        The forward procedure of the transformer is defined as:
+        'pre_transformer' -> 'encoder' -> 'pre_decoder' -> 'decoder'
+        More details can be found at `TransformerDetector.forward_transformer`
+        in `mmdet/detector/base_detr.py`.
+
+        Args:
+            query (Tensor): The queries of decoder inputs, has shape
+                (bs, num_queries, dim).
+            query_pos (Tensor): The positional queries of decoder inputs,
+                has shape (bs, num_queries, dim).
+            memory (Tensor): The output embeddings of the Transformer encoder,
+                has shape (bs, num_feat_points, dim).
+            memory_mask (Tensor): ByteTensor, the padding mask of the memory,
+                has shape (bs, num_feat_points).
+            memory_pos (Tensor): The positional embeddings of memory, has
+                shape (bs, num_feat_points, dim).
+
+        Returns:
+            dict: The dictionary of decoder outputs, which includes the
+            `hidden_states` of the decoder output.
+
+            - hidden_states (Tensor): Has shape
+              (num_decoder_layers, bs, num_queries, dim)
+        """
+
+        hidden_states = self.decoder(
+            query=query,
+            key=memory,
+            value=memory,
+            query_pos=query_pos,
+            key_pos=memory_pos,
+            key_padding_mask=memory_mask)  # for cross_attn
+
+        head_inputs_dict = dict(hidden_states=hidden_states)
+        return head_inputs_dict
diff --git a/mmdetection/mmdet/models/detectors/dino.py b/mmdetection/mmdet/models/detectors/dino.py
new file mode 100644
index 00000000..ade47f53
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/dino.py
@@ -0,0 +1,287 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, Optional, Tuple
+
+import torch
+from torch import Tensor, nn
+from torch.nn.init import normal_
+
+from mmdet.registry import MODELS
+from mmdet.structures import OptSampleList
+from mmdet.utils import OptConfigType
+from ..layers import (CdnQueryGenerator, DeformableDetrTransformerEncoder,
+                      DinoTransformerDecoder, SinePositionalEncoding)
+from .deformable_detr import DeformableDETR, MultiScaleDeformableAttention
+
+
+@MODELS.register_module()
+class DINO(DeformableDETR):
+    r"""Implementation of `DINO: DETR with Improved DeNoising Anchor Boxes
+    for End-to-End Object Detection `_
+
+    Code is modified from the `official github repo
+    `_.
+
+    Args:
+        dn_cfg (:obj:`ConfigDict` or dict, optional): Config of denoising
+            query generator. Defaults to `None`.
+    """
+
+    def __init__(self, *args, dn_cfg: OptConfigType = None, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        assert self.as_two_stage, 'as_two_stage must be True for DINO'
+        assert self.with_box_refine, 'with_box_refine must be True for DINO'
+
+        if dn_cfg is not None:
+            assert 'num_classes' not in dn_cfg and \
+                   'num_queries' not in dn_cfg and \
+                   'hidden_dim' not in dn_cfg, \
+                'The three keyword args `num_classes`, `embed_dims`, and ' \
+                '`num_matching_queries` are set in `detector.__init__()`, ' \
+                'users should not set them in `dn_cfg` config.'
+            dn_cfg['num_classes'] = self.bbox_head.num_classes
+            dn_cfg['embed_dims'] = self.embed_dims
+            dn_cfg['num_matching_queries'] = self.num_queries
+        self.dn_query_generator = CdnQueryGenerator(**dn_cfg)
+
+    def _init_layers(self) -> None:
+        """Initialize layers except for backbone, neck and bbox_head."""
+        self.positional_encoding = SinePositionalEncoding(
+            **self.positional_encoding)
+        self.encoder = DeformableDetrTransformerEncoder(**self.encoder)
+        self.decoder = DinoTransformerDecoder(**self.decoder)
+        self.embed_dims = self.encoder.embed_dims
+        self.query_embedding = nn.Embedding(self.num_queries, self.embed_dims)
+        # NOTE In DINO, the query_embedding only contains content
+        # queries, while in Deformable DETR, the query_embedding
+        # contains both content and spatial queries, and in DETR,
+        # it only contains spatial queries.
+
+        num_feats = self.positional_encoding.num_feats
+        assert num_feats * 2 == self.embed_dims, \
+            f'embed_dims should be exactly 2 times of num_feats. ' \
+            f'Found {self.embed_dims} and {num_feats}.'
+
+        self.level_embed = nn.Parameter(
+            torch.Tensor(self.num_feature_levels, self.embed_dims))
+        self.memory_trans_fc = nn.Linear(self.embed_dims, self.embed_dims)
+        self.memory_trans_norm = nn.LayerNorm(self.embed_dims)
+
+    def init_weights(self) -> None:
+        """Initialize weights for Transformer and other components."""
+        super(DeformableDETR, self).init_weights()
+        for coder in self.encoder, self.decoder:
+            for p in coder.parameters():
+                if p.dim() > 1:
+                    nn.init.xavier_uniform_(p)
+        for m in self.modules():
+            if isinstance(m, MultiScaleDeformableAttention):
+                m.init_weights()
+        nn.init.xavier_uniform_(self.memory_trans_fc.weight)
+        nn.init.xavier_uniform_(self.query_embedding.weight)
+        normal_(self.level_embed)
+
+    def forward_transformer(
+        self,
+        img_feats: Tuple[Tensor],
+        batch_data_samples: OptSampleList = None,
+    ) -> Dict:
+        """Forward process of Transformer.
+
+        The forward procedure of the transformer is defined as:
+        'pre_transformer' -> 'encoder' -> 'pre_decoder' -> 'decoder'
+        More details can be found at `TransformerDetector.forward_transformer`
+        in `mmdet/detector/base_detr.py`.
+        The difference is that the ground truth in `batch_data_samples` is
+        required for the `pre_decoder` to prepare the query of DINO.
+        Additionally, DINO inherits the `pre_transformer` method and the
+        `forward_encoder` method of DeformableDETR. More details about the
+        two methods can be found in `mmdet/detector/deformable_detr.py`.
+
+        Args:
+            img_feats (tuple[Tensor]): Tuple of feature maps from neck. Each
+                feature map has shape (bs, dim, H, W).
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+                Defaults to None.
+
+        Returns:
+            dict: The dictionary of bbox_head function inputs, which always
+            includes the `hidden_states` of the decoder output and may contain
+            `references` including the initial and intermediate references.
+        """
+        encoder_inputs_dict, decoder_inputs_dict = self.pre_transformer(
+            img_feats, batch_data_samples)
+
+        encoder_outputs_dict = self.forward_encoder(**encoder_inputs_dict)
+
+        tmp_dec_in, head_inputs_dict = self.pre_decoder(
+            **encoder_outputs_dict, batch_data_samples=batch_data_samples)
+        decoder_inputs_dict.update(tmp_dec_in)
+
+        decoder_outputs_dict = self.forward_decoder(**decoder_inputs_dict)
+        head_inputs_dict.update(decoder_outputs_dict)
+        return head_inputs_dict
+
+    def pre_decoder(
+        self,
+        memory: Tensor,
+        memory_mask: Tensor,
+        spatial_shapes: Tensor,
+        batch_data_samples: OptSampleList = None,
+    ) -> Tuple[Dict]:
+        """Prepare intermediate variables before entering Transformer decoder,
+        such as `query`, `query_pos`, and `reference_points`.
+
+        Args:
+            memory (Tensor): The output embeddings of the Transformer encoder,
+                has shape (bs, num_feat_points, dim).
+            memory_mask (Tensor): ByteTensor, the padding mask of the memory,
+                has shape (bs, num_feat_points). Will only be used when
+                `as_two_stage` is `True`.
+            spatial_shapes (Tensor): Spatial shapes of features in all levels.
+                With shape (num_levels, 2), last dimension represents (h, w).
+                Will only be used when `as_two_stage` is `True`.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+                Defaults to None.
+
+        Returns:
+            tuple[dict]: The decoder_inputs_dict and head_inputs_dict.
+
+            - decoder_inputs_dict (dict): The keyword dictionary args of
+              `self.forward_decoder()`, which includes 'query', 'memory',
+              `reference_points`, and `dn_mask`. The reference points of
+              decoder input here are 4D boxes, although it has `points`
+              in its name.
+            - head_inputs_dict (dict): The keyword dictionary args of the
+              bbox_head functions, which includes `topk_score`, `topk_coords`,
+              and `dn_meta` when `self.training` is `True`, else is empty.
+        """
+        bs, _, c = memory.shape
+        cls_out_features = self.bbox_head.cls_branches[
+            self.decoder.num_layers].out_features
+
+        output_memory, output_proposals = self.gen_encoder_output_proposals(
+            memory, memory_mask, spatial_shapes)
+        enc_outputs_class = self.bbox_head.cls_branches[
+            self.decoder.num_layers](
+                output_memory)
+        enc_outputs_coord_unact = self.bbox_head.reg_branches[
+            self.decoder.num_layers](output_memory) + output_proposals
+
+        # NOTE The DINO selects top-k proposals according to scores of
+        # multi-class classification, while DeformDETR, where the input
+        # is `enc_outputs_class[..., 0]` selects according to scores of
+        # binary classification.
+        topk_indices = torch.topk(
+            enc_outputs_class.max(-1)[0], k=self.num_queries, dim=1)[1]
+        topk_score = torch.gather(
+            enc_outputs_class, 1,
+            topk_indices.unsqueeze(-1).repeat(1, 1, cls_out_features))
+        topk_coords_unact = torch.gather(
+            enc_outputs_coord_unact, 1,
+            topk_indices.unsqueeze(-1).repeat(1, 1, 4))
+        topk_coords = topk_coords_unact.sigmoid()
+        topk_coords_unact = topk_coords_unact.detach()
+
+        query = self.query_embedding.weight[:, None, :]
+        query = query.repeat(1, bs, 1).transpose(0, 1)
+        if self.training:
+            dn_label_query, dn_bbox_query, dn_mask, dn_meta = \
+                self.dn_query_generator(batch_data_samples)
+            query = torch.cat([dn_label_query, query], dim=1)
+            reference_points = torch.cat([dn_bbox_query, topk_coords_unact],
+                                         dim=1)
+        else:
+            reference_points = topk_coords_unact
+            dn_mask, dn_meta = None, None
+        reference_points = reference_points.sigmoid()
+
+        decoder_inputs_dict = dict(
+            query=query,
+            memory=memory,
+            reference_points=reference_points,
+            dn_mask=dn_mask)
+        # NOTE DINO calculates encoder losses on scores and coordinates
+        # of selected top-k encoder queries, while DeformDETR is of all
+        # encoder queries.
+        head_inputs_dict = dict(
+            enc_outputs_class=topk_score,
+            enc_outputs_coord=topk_coords,
+            dn_meta=dn_meta) if self.training else dict()
+        return decoder_inputs_dict, head_inputs_dict
+
+    def forward_decoder(self,
+                        query: Tensor,
+                        memory: Tensor,
+                        memory_mask: Tensor,
+                        reference_points: Tensor,
+                        spatial_shapes: Tensor,
+                        level_start_index: Tensor,
+                        valid_ratios: Tensor,
+                        dn_mask: Optional[Tensor] = None,
+                        **kwargs) -> Dict:
+        """Forward with Transformer decoder.
+
+        The forward procedure of the transformer is defined as:
+        'pre_transformer' -> 'encoder' -> 'pre_decoder' -> 'decoder'
+        More details can be found at `TransformerDetector.forward_transformer`
+        in `mmdet/detector/base_detr.py`.
+
+        Args:
+            query (Tensor): The queries of decoder inputs, has shape
+                (bs, num_queries_total, dim), where `num_queries_total` is the
+                sum of `num_denoising_queries` and `num_matching_queries` when
+                `self.training` is `True`, else `num_matching_queries`.
+            memory (Tensor): The output embeddings of the Transformer encoder,
+                has shape (bs, num_feat_points, dim).
+            memory_mask (Tensor): ByteTensor, the padding mask of the memory,
+                has shape (bs, num_feat_points).
+            reference_points (Tensor): The initial reference, has shape
+                (bs, num_queries_total, 4) with the last dimension arranged as
+                (cx, cy, w, h).
+            spatial_shapes (Tensor): Spatial shapes of features in all levels,
+                has shape (num_levels, 2), last dimension represents (h, w).
+            level_start_index (Tensor): The start index of each level.
+                A tensor has shape (num_levels, ) and can be represented
+                as [0, h_0*w_0, h_0*w_0+h_1*w_1, ...].
+            valid_ratios (Tensor): The ratios of the valid width and the valid
+                height relative to the width and the height of features in all
+                levels, has shape (bs, num_levels, 2).
+            dn_mask (Tensor, optional): The attention mask to prevent
+                information leakage from different denoising groups and
+                matching parts, will be used as `self_attn_mask` of the
+                `self.decoder`, has shape (num_queries_total,
+                num_queries_total).
+                It is `None` when `self.training` is `False`.
+
+        Returns:
+            dict: The dictionary of decoder outputs, which includes the
+            `hidden_states` of the decoder output and `references` including
+            the initial and intermediate reference_points.
+        """
+        inter_states, references = self.decoder(
+            query=query,
+            value=memory,
+            key_padding_mask=memory_mask,
+            self_attn_mask=dn_mask,
+            reference_points=reference_points,
+            spatial_shapes=spatial_shapes,
+            level_start_index=level_start_index,
+            valid_ratios=valid_ratios,
+            reg_branches=self.bbox_head.reg_branches,
+            **kwargs)
+
+        if len(query) == self.num_queries:
+            # NOTE: This is to make sure label_embeding can be involved to
+            # produce loss even if there is no denoising query (no ground truth
+            # target in this GPU), otherwise, this will raise runtime error in
+            # distributed training.
+            inter_states[0] += \
+                self.dn_query_generator.label_embedding.weight[0, 0] * 0.0
+
+        decoder_outputs_dict = dict(
+            hidden_states=inter_states, references=list(references))
+        return decoder_outputs_dict
diff --git a/mmdetection/mmdet/models/detectors/fast_rcnn.py b/mmdetection/mmdet/models/detectors/fast_rcnn.py
new file mode 100644
index 00000000..5b39050f
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/fast_rcnn.py
@@ -0,0 +1,26 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .two_stage import TwoStageDetector
+
+
+@MODELS.register_module()
+class FastRCNN(TwoStageDetector):
+    """Implementation of `Fast R-CNN `_"""
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 roi_head: ConfigType,
+                 train_cfg: ConfigType,
+                 test_cfg: ConfigType,
+                 neck: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            roi_head=roi_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            init_cfg=init_cfg,
+            data_preprocessor=data_preprocessor)
diff --git a/mmdetection/mmdet/models/detectors/faster_rcnn.py b/mmdetection/mmdet/models/detectors/faster_rcnn.py
new file mode 100644
index 00000000..36109e32
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/faster_rcnn.py
@@ -0,0 +1,28 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .two_stage import TwoStageDetector
+
+
+@MODELS.register_module()
+class FasterRCNN(TwoStageDetector):
+    """Implementation of `Faster R-CNN `_"""
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 rpn_head: ConfigType,
+                 roi_head: ConfigType,
+                 train_cfg: ConfigType,
+                 test_cfg: ConfigType,
+                 neck: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            rpn_head=rpn_head,
+            roi_head=roi_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            init_cfg=init_cfg,
+            data_preprocessor=data_preprocessor)
diff --git a/mmdetection/mmdet/models/detectors/fcos.py b/mmdetection/mmdet/models/detectors/fcos.py
new file mode 100644
index 00000000..c6280593
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/fcos.py
@@ -0,0 +1,42 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage import SingleStageDetector
+
+
+@MODELS.register_module()
+class FCOS(SingleStageDetector):
+    """Implementation of `FCOS `_
+
+    Args:
+        backbone (:obj:`ConfigDict` or dict): The backbone config.
+        neck (:obj:`ConfigDict` or dict): The neck config.
+        bbox_head (:obj:`ConfigDict` or dict): The bbox head config.
+        train_cfg (:obj:`ConfigDict` or dict, optional): The training config
+            of FCOS. Defaults to None.
+        test_cfg (:obj:`ConfigDict` or dict, optional): The testing config
+            of FCOS. Defaults to None.
+        data_preprocessor (:obj:`ConfigDict` or dict, optional): Config of
+            :class:`DetDataPreprocessor` to process the input data.
+            Defaults to None.
+        init_cfg (:obj:`ConfigDict` or list[:obj:`ConfigDict`] or dict or
+            list[dict], optional): Initialization config dict.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/fovea.py b/mmdetection/mmdet/models/detectors/fovea.py
new file mode 100644
index 00000000..5e4f21ca
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/fovea.py
@@ -0,0 +1,41 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage import SingleStageDetector
+
+
+@MODELS.register_module()
+class FOVEA(SingleStageDetector):
+    """Implementation of `FoveaBox `_
+    Args:
+        backbone (:obj:`ConfigDict` or dict): The backbone config.
+        neck (:obj:`ConfigDict` or dict): The neck config.
+        bbox_head (:obj:`ConfigDict` or dict): The bbox head config.
+        train_cfg (:obj:`ConfigDict` or dict, optional): The training config
+            of FOVEA. Defaults to None.
+        test_cfg (:obj:`ConfigDict` or dict, optional): The testing config
+            of FOVEA. Defaults to None.
+        data_preprocessor (:obj:`ConfigDict` or dict, optional): Config of
+            :class:`DetDataPreprocessor` to process the input data.
+            Defaults to None.
+        init_cfg (:obj:`ConfigDict` or list[:obj:`ConfigDict`] or dict or
+            list[dict], optional): Initialization config dict.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/fsaf.py b/mmdetection/mmdet/models/detectors/fsaf.py
new file mode 100644
index 00000000..01b40273
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/fsaf.py
@@ -0,0 +1,26 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage import SingleStageDetector
+
+
+@MODELS.register_module()
+class FSAF(SingleStageDetector):
+    """Implementation of `FSAF `_"""
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None):
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/gfl.py b/mmdetection/mmdet/models/detectors/gfl.py
new file mode 100644
index 00000000..c26821af
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/gfl.py
@@ -0,0 +1,41 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage import SingleStageDetector
+
+
+@MODELS.register_module()
+class GFL(SingleStageDetector):
+    """Implementation of `GFL `_
+
+    Args:
+        backbone (:obj:`ConfigDict` or dict): The backbone module.
+        neck (:obj:`ConfigDict` or dict): The neck module.
+        bbox_head (:obj:`ConfigDict` or dict): The bbox head module.
+        train_cfg (:obj:`ConfigDict` or dict, optional): The training config
+            of GFL. Defaults to None.
+        test_cfg (:obj:`ConfigDict` or dict, optional): The testing config
+            of GFL. Defaults to None.
+        data_preprocessor (:obj:`ConfigDict` or dict, optional): Config of
+            :class:`DetDataPreprocessor` to process the input data.
+            Defaults to None.
+        init_cfg (:obj:`ConfigDict` or dict, optional): the config to control
+            the initialization. Defaults to None.
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/glip.py b/mmdetection/mmdet/models/detectors/glip.py
new file mode 100644
index 00000000..45cfe7d3
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/glip.py
@@ -0,0 +1,590 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import re
+import warnings
+from typing import Optional, Tuple, Union
+
+import torch
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage import SingleStageDetector
+
+
+def find_noun_phrases(caption: str) -> list:
+    """Find noun phrases in a caption using nltk.
+    Args:
+        caption (str): The caption to analyze.
+
+    Returns:
+        list: List of noun phrases found in the caption.
+
+    Examples:
+        >>> caption = 'There is two cat and a remote in the picture'
+        >>> find_noun_phrases(caption) # ['cat', 'a remote', 'the picture']
+    """
+    try:
+        import nltk
+        nltk.download('punkt', download_dir='~/nltk_data')
+        nltk.download('averaged_perceptron_tagger', download_dir='~/nltk_data')
+    except ImportError:
+        raise RuntimeError('nltk is not installed, please install it by: '
+                           'pip install nltk.')
+
+    caption = caption.lower()
+    tokens = nltk.word_tokenize(caption)
+    pos_tags = nltk.pos_tag(tokens)
+
+    grammar = 'NP: {
    ?*+}'
+    cp = nltk.RegexpParser(grammar)
+    result = cp.parse(pos_tags)
+
+    noun_phrases = []
+    for subtree in result.subtrees():
+        if subtree.label() == 'NP':
+            noun_phrases.append(' '.join(t[0] for t in subtree.leaves()))
+
+    return noun_phrases
+
+
+def remove_punctuation(text: str) -> str:
+    """Remove punctuation from a text.
+    Args:
+        text (str): The input text.
+
+    Returns:
+        str: The text with punctuation removed.
+    """
+    punctuation = [
+        '|', ':', ';', '@', '(', ')', '[', ']', '{', '}', '^', '\'', '\"', '’',
+        '`', '?', '$', '%', '#', '!', '&', '*', '+', ',', '.'
+    ]
+    for p in punctuation:
+        text = text.replace(p, '')
+    return text.strip()
+
+
+def run_ner(caption: str) -> Tuple[list, list]:
+    """Run NER on a caption and return the tokens and noun phrases.
+    Args:
+        caption (str): The input caption.
+
+    Returns:
+        Tuple[List, List]: A tuple containing the tokens and noun phrases.
+            - tokens_positive (List): A list of token positions.
+            - noun_phrases (List): A list of noun phrases.
+    """
+    noun_phrases = find_noun_phrases(caption)
+    noun_phrases = [remove_punctuation(phrase) for phrase in noun_phrases]
+    noun_phrases = [phrase for phrase in noun_phrases if phrase != '']
+    print('noun_phrases:', noun_phrases)
+    relevant_phrases = noun_phrases
+    labels = noun_phrases
+
+    tokens_positive = []
+    for entity, label in zip(relevant_phrases, labels):
+        try:
+            # search all occurrences and mark them as different entities
+            # TODO: Not Robust
+            for m in re.finditer(entity, caption.lower()):
+                tokens_positive.append([[m.start(), m.end()]])
+        except Exception:
+            print('noun entities:', noun_phrases)
+            print('entity:', entity)
+            print('caption:', caption.lower())
+    return tokens_positive, noun_phrases
+
+
+def create_positive_map(tokenized,
+                        tokens_positive: list,
+                        max_num_entities: int = 256) -> Tensor:
+    """construct a map such that positive_map[i,j] = True
+    if box i is associated to token j
+
+    Args:
+        tokenized: The tokenized input.
+        tokens_positive (list): A list of token ranges
+            associated with positive boxes.
+        max_num_entities (int, optional): The maximum number of entities.
+            Defaults to 256.
+
+    Returns:
+        torch.Tensor: The positive map.
+
+    Raises:
+        Exception: If an error occurs during token-to-char mapping.
+    """
+    positive_map = torch.zeros((len(tokens_positive), max_num_entities),
+                               dtype=torch.float)
+
+    for j, tok_list in enumerate(tokens_positive):
+        for (beg, end) in tok_list:
+            try:
+                beg_pos = tokenized.char_to_token(beg)
+                end_pos = tokenized.char_to_token(end - 1)
+            except Exception as e:
+                print('beg:', beg, 'end:', end)
+                print('token_positive:', tokens_positive)
+                raise e
+            if beg_pos is None:
+                try:
+                    beg_pos = tokenized.char_to_token(beg + 1)
+                    if beg_pos is None:
+                        beg_pos = tokenized.char_to_token(beg + 2)
+                except Exception:
+                    beg_pos = None
+            if end_pos is None:
+                try:
+                    end_pos = tokenized.char_to_token(end - 2)
+                    if end_pos is None:
+                        end_pos = tokenized.char_to_token(end - 3)
+                except Exception:
+                    end_pos = None
+            if beg_pos is None or end_pos is None:
+                continue
+
+            assert beg_pos is not None and end_pos is not None
+            positive_map[j, beg_pos:end_pos + 1].fill_(1)
+    return positive_map / (positive_map.sum(-1)[:, None] + 1e-6)
+
+
+def create_positive_map_label_to_token(positive_map: Tensor,
+                                       plus: int = 0) -> dict:
+    """Create a dictionary mapping the label to the token.
+    Args:
+        positive_map (Tensor): The positive map tensor.
+        plus (int, optional): Value added to the label for indexing.
+            Defaults to 0.
+
+    Returns:
+        dict: The dictionary mapping the label to the token.
+    """
+    positive_map_label_to_token = {}
+    for i in range(len(positive_map)):
+        positive_map_label_to_token[i + plus] = torch.nonzero(
+            positive_map[i], as_tuple=True)[0].tolist()
+    return positive_map_label_to_token
+
+
+def clean_label_name(name: str) -> str:
+    name = re.sub(r'\(.*\)', '', name)
+    name = re.sub(r'_', ' ', name)
+    name = re.sub(r'  ', ' ', name)
+    return name
+
+
+def chunks(lst: list, n: int) -> list:
+    """Yield successive n-sized chunks from lst."""
+    all_ = []
+    for i in range(0, len(lst), n):
+        data_index = lst[i:i + n]
+        all_.append(data_index)
+    counter = 0
+    for i in all_:
+        counter += len(i)
+    assert (counter == len(lst))
+
+    return all_
+
+
+@MODELS.register_module()
+class GLIP(SingleStageDetector):
+    """Implementation of `GLIP `_
+    Args:
+        backbone (:obj:`ConfigDict` or dict): The backbone config.
+        neck (:obj:`ConfigDict` or dict): The neck config.
+        bbox_head (:obj:`ConfigDict` or dict): The bbox head config.
+        language_model (:obj:`ConfigDict` or dict): The language model config.
+        train_cfg (:obj:`ConfigDict` or dict, optional): The training config
+            of GLIP. Defaults to None.
+        test_cfg (:obj:`ConfigDict` or dict, optional): The testing config
+            of GLIP. Defaults to None.
+        data_preprocessor (:obj:`ConfigDict` or dict, optional): Config of
+            :class:`DetDataPreprocessor` to process the input data.
+            Defaults to None.
+        init_cfg (:obj:`ConfigDict` or list[:obj:`ConfigDict`] or dict or
+            list[dict], optional): Initialization config dict.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 language_model: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
+        self.language_model = MODELS.build(language_model)
+
+        self._special_tokens = '. '
+
+    def to_enhance_text_prompts(self, original_caption, enhanced_text_prompts):
+        caption_string = ''
+        tokens_positive = []
+        for idx, word in enumerate(original_caption):
+            if word in enhanced_text_prompts:
+                enhanced_text_dict = enhanced_text_prompts[word]
+                if 'prefix' in enhanced_text_dict:
+                    caption_string += enhanced_text_dict['prefix']
+                start_i = len(caption_string)
+                if 'name' in enhanced_text_dict:
+                    caption_string += enhanced_text_dict['name']
+                else:
+                    caption_string += word
+                end_i = len(caption_string)
+                tokens_positive.append([[start_i, end_i]])
+
+                if 'suffix' in enhanced_text_dict:
+                    caption_string += enhanced_text_dict['suffix']
+            else:
+                tokens_positive.append(
+                    [[len(caption_string),
+                      len(caption_string) + len(word)]])
+                caption_string += word
+
+            if idx != len(original_caption) - 1:
+                caption_string += self._special_tokens
+        return caption_string, tokens_positive
+
+    def to_plain_text_prompts(self, original_caption):
+        caption_string = ''
+        tokens_positive = []
+        for idx, word in enumerate(original_caption):
+            tokens_positive.append(
+                [[len(caption_string),
+                  len(caption_string) + len(word)]])
+            caption_string += word
+            if idx != len(original_caption) - 1:
+                caption_string += self._special_tokens
+        return caption_string, tokens_positive
+
+    def get_tokens_and_prompts(
+        self,
+        original_caption: Union[str, list, tuple],
+        custom_entities: bool = False,
+        enhanced_text_prompts: Optional[ConfigType] = None
+    ) -> Tuple[dict, str, list, list]:
+        """Get the tokens positive and prompts for the caption."""
+        if isinstance(original_caption, (list, tuple)) or custom_entities:
+            if custom_entities and isinstance(original_caption, str):
+                original_caption = original_caption.strip(self._special_tokens)
+                original_caption = original_caption.split(self._special_tokens)
+                original_caption = list(
+                    filter(lambda x: len(x) > 0, original_caption))
+
+            original_caption = [clean_label_name(i) for i in original_caption]
+
+            if custom_entities and enhanced_text_prompts is not None:
+                caption_string, tokens_positive = self.to_enhance_text_prompts(
+                    original_caption, enhanced_text_prompts)
+            else:
+                caption_string, tokens_positive = self.to_plain_text_prompts(
+                    original_caption)
+
+            tokenized = self.language_model.tokenizer([caption_string],
+                                                      return_tensors='pt')
+            entities = original_caption
+        else:
+            original_caption = original_caption.strip(self._special_tokens)
+            tokenized = self.language_model.tokenizer([original_caption],
+                                                      return_tensors='pt')
+            tokens_positive, noun_phrases = run_ner(original_caption)
+            entities = noun_phrases
+            caption_string = original_caption
+
+        return tokenized, caption_string, tokens_positive, entities
+
+    def get_positive_map(self, tokenized, tokens_positive):
+        positive_map = create_positive_map(tokenized, tokens_positive)
+        positive_map_label_to_token = create_positive_map_label_to_token(
+            positive_map, plus=1)
+        return positive_map_label_to_token, positive_map
+
+    def get_tokens_positive_and_prompts(
+        self,
+        original_caption: Union[str, list, tuple],
+        custom_entities: bool = False,
+        enhanced_text_prompt: Optional[ConfigType] = None,
+        tokens_positive: Optional[list] = None,
+    ) -> Tuple[dict, str, Tensor, list]:
+        if tokens_positive is not None:
+            if tokens_positive == -1:
+                if not original_caption.endswith('.'):
+                    original_caption = original_caption + self._special_tokens
+                return None, original_caption, None, original_caption
+            else:
+                if not original_caption.endswith('.'):
+                    original_caption = original_caption + self._special_tokens
+                tokenized = self.language_model.tokenizer([original_caption],
+                                                          return_tensors='pt')
+                positive_map_label_to_token, positive_map = \
+                    self.get_positive_map(tokenized, tokens_positive)
+
+                entities = []
+                for token_positive in tokens_positive:
+                    instance_entities = []
+                    for t in token_positive:
+                        instance_entities.append(original_caption[t[0]:t[1]])
+                    entities.append(' / '.join(instance_entities))
+                return positive_map_label_to_token, original_caption, \
+                    positive_map, entities
+
+        chunked_size = self.test_cfg.get('chunked_size', -1)
+        if not self.training and chunked_size > 0:
+            assert isinstance(original_caption,
+                              (list, tuple)) or custom_entities is True
+            all_output = self.get_tokens_positive_and_prompts_chunked(
+                original_caption, enhanced_text_prompt)
+            positive_map_label_to_token, \
+                caption_string, \
+                positive_map, \
+                entities = all_output
+        else:
+            tokenized, caption_string, tokens_positive, entities = \
+                self.get_tokens_and_prompts(
+                    original_caption, custom_entities, enhanced_text_prompt)
+            positive_map_label_to_token, positive_map = self.get_positive_map(
+                tokenized, tokens_positive)
+            if tokenized.input_ids.shape[1] > self.language_model.max_tokens:
+                warnings.warn('Inputting a text that is too long will result '
+                              'in poor prediction performance. '
+                              'Please reduce the text length.')
+        return positive_map_label_to_token, caption_string, \
+            positive_map, entities
+
+    def get_tokens_positive_and_prompts_chunked(
+            self,
+            original_caption: Union[list, tuple],
+            enhanced_text_prompts: Optional[ConfigType] = None):
+        chunked_size = self.test_cfg.get('chunked_size', -1)
+        original_caption = [clean_label_name(i) for i in original_caption]
+
+        original_caption_chunked = chunks(original_caption, chunked_size)
+        ids_chunked = chunks(
+            list(range(1,
+                       len(original_caption) + 1)), chunked_size)
+
+        positive_map_label_to_token_chunked = []
+        caption_string_chunked = []
+        positive_map_chunked = []
+        entities_chunked = []
+
+        for i in range(len(ids_chunked)):
+            if enhanced_text_prompts is not None:
+                caption_string, tokens_positive = self.to_enhance_text_prompts(
+                    original_caption_chunked[i], enhanced_text_prompts)
+            else:
+                caption_string, tokens_positive = self.to_plain_text_prompts(
+                    original_caption_chunked[i])
+            tokenized = self.language_model.tokenizer([caption_string],
+                                                      return_tensors='pt')
+            if tokenized.input_ids.shape[1] > self.language_model.max_tokens:
+                warnings.warn('Inputting a text that is too long will result '
+                              'in poor prediction performance. '
+                              'Please reduce the --chunked-size.')
+            positive_map_label_to_token, positive_map = self.get_positive_map(
+                tokenized, tokens_positive)
+
+            caption_string_chunked.append(caption_string)
+            positive_map_label_to_token_chunked.append(
+                positive_map_label_to_token)
+            positive_map_chunked.append(positive_map)
+            entities_chunked.append(original_caption_chunked[i])
+
+        return positive_map_label_to_token_chunked, \
+            caption_string_chunked, \
+            positive_map_chunked, \
+            entities_chunked
+
+    def loss(self, batch_inputs: Tensor,
+             batch_data_samples: SampleList) -> Union[dict, list]:
+        # TODO: Only open vocabulary tasks are supported for training now.
+        text_prompts = [
+            data_samples.text for data_samples in batch_data_samples
+        ]
+
+        gt_labels = [
+            data_samples.gt_instances.labels
+            for data_samples in batch_data_samples
+        ]
+
+        new_text_prompts = []
+        positive_maps = []
+        if len(set(text_prompts)) == 1:
+            # All the text prompts are the same,
+            # so there is no need to calculate them multiple times.
+            tokenized, caption_string, tokens_positive, _ = \
+                self.get_tokens_and_prompts(
+                    text_prompts[0], True)
+            new_text_prompts = [caption_string] * len(batch_inputs)
+            for gt_label in gt_labels:
+                new_tokens_positive = [
+                    tokens_positive[label] for label in gt_label
+                ]
+                _, positive_map = self.get_positive_map(
+                    tokenized, new_tokens_positive)
+                positive_maps.append(positive_map)
+        else:
+            for text_prompt, gt_label in zip(text_prompts, gt_labels):
+                tokenized, caption_string, tokens_positive, _ = \
+                    self.get_tokens_and_prompts(
+                        text_prompt, True)
+                new_tokens_positive = [
+                    tokens_positive[label] for label in gt_label
+                ]
+                _, positive_map = self.get_positive_map(
+                    tokenized, new_tokens_positive)
+                positive_maps.append(positive_map)
+                new_text_prompts.append(caption_string)
+
+        language_dict_features = self.language_model(new_text_prompts)
+        for i, data_samples in enumerate(batch_data_samples):
+            # .bool().float() is very important
+            positive_map = positive_maps[i].to(
+                batch_inputs.device).bool().float()
+            data_samples.gt_instances.positive_maps = positive_map
+
+        visual_features = self.extract_feat(batch_inputs)
+
+        losses = self.bbox_head.loss(visual_features, language_dict_features,
+                                     batch_data_samples)
+        return losses
+
+    def predict(self,
+                batch_inputs: Tensor,
+                batch_data_samples: SampleList,
+                rescale: bool = True) -> SampleList:
+        """Predict results from a batch of inputs and data samples with post-
+        processing.
+
+        Args:
+            batch_inputs (Tensor): Inputs with shape (N, C, H, W).
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            rescale (bool): Whether to rescale the results.
+                Defaults to True.
+
+        Returns:
+            list[:obj:`DetDataSample`]: Detection results of the
+            input images. Each DetDataSample usually contain
+            'pred_instances'. And the ``pred_instances`` usually
+            contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                    (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                    (num_instances, ).
+                - label_names (List[str]): Label names of bboxes.
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                    the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        text_prompts = []
+        enhanced_text_prompts = []
+        tokens_positives = []
+        for data_samples in batch_data_samples:
+            text_prompts.append(data_samples.text)
+            if 'caption_prompt' in data_samples:
+                enhanced_text_prompts.append(data_samples.caption_prompt)
+            else:
+                enhanced_text_prompts.append(None)
+            tokens_positives.append(data_samples.get('tokens_positive', None))
+
+        if 'custom_entities' in batch_data_samples[0]:
+            # Assuming that the `custom_entities` flag
+            # inside a batch is always the same. For single image inference
+            custom_entities = batch_data_samples[0].custom_entities
+        else:
+            custom_entities = False
+
+        if len(set(text_prompts)) == 1:
+            # All the text prompts are the same,
+            # so there is no need to calculate them multiple times.
+            _positive_maps_and_prompts = [
+                self.get_tokens_positive_and_prompts(
+                    text_prompts[0], custom_entities, enhanced_text_prompts[0],
+                    tokens_positives[0])
+            ] * len(batch_inputs)
+        else:
+            _positive_maps_and_prompts = [
+                self.get_tokens_positive_and_prompts(text_prompt,
+                                                     custom_entities,
+                                                     enhanced_text_prompt,
+                                                     tokens_positive)
+                for text_prompt, enhanced_text_prompt, tokens_positive in zip(
+                    text_prompts, enhanced_text_prompts, tokens_positives)
+            ]
+
+        token_positive_maps, text_prompts, _, entities = zip(
+            *_positive_maps_and_prompts)
+
+        visual_features = self.extract_feat(batch_inputs)
+
+        if isinstance(text_prompts[0], list):
+            # chunked text prompts, only bs=1 is supported
+            assert len(batch_inputs) == 1
+            count = 0
+            results_list = []
+
+            entities = [[item for lst in entities[0] for item in lst]]
+
+            for b in range(len(text_prompts[0])):
+                text_prompts_once = [text_prompts[0][b]]
+                token_positive_maps_once = token_positive_maps[0][b]
+                language_dict_features = self.language_model(text_prompts_once)
+                batch_data_samples[
+                    0].token_positive_map = token_positive_maps_once
+
+                pred_instances = self.bbox_head.predict(
+                    copy.deepcopy(visual_features),
+                    language_dict_features,
+                    batch_data_samples,
+                    rescale=rescale)[0]
+
+                if len(pred_instances) > 0:
+                    pred_instances.labels += count
+                count += len(token_positive_maps_once)
+                results_list.append(pred_instances)
+            results_list = [results_list[0].cat(results_list)]
+        else:
+            language_dict_features = self.language_model(list(text_prompts))
+
+            for i, data_samples in enumerate(batch_data_samples):
+                data_samples.token_positive_map = token_positive_maps[i]
+
+            results_list = self.bbox_head.predict(
+                visual_features,
+                language_dict_features,
+                batch_data_samples,
+                rescale=rescale)
+
+        for data_sample, pred_instances, entity in zip(batch_data_samples,
+                                                       results_list, entities):
+            if len(pred_instances) > 0:
+                label_names = []
+                for labels in pred_instances.labels:
+                    if labels >= len(entity):
+                        warnings.warn(
+                            'The unexpected output indicates an issue with '
+                            'named entity recognition. You can try '
+                            'setting custom_entities=True and running '
+                            'again to see if it helps.')
+                        label_names.append('unobject')
+                    else:
+                        label_names.append(entity[labels])
+                # for visualization
+                pred_instances.label_names = label_names
+            data_sample.pred_instances = pred_instances
+        return batch_data_samples
diff --git a/mmdetection/mmdet/models/detectors/grid_rcnn.py b/mmdetection/mmdet/models/detectors/grid_rcnn.py
new file mode 100644
index 00000000..7bcb5b03
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/grid_rcnn.py
@@ -0,0 +1,33 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .two_stage import TwoStageDetector
+
+
+@MODELS.register_module()
+class GridRCNN(TwoStageDetector):
+    """Grid R-CNN.
+
+    This detector is the implementation of:
+    - Grid R-CNN (https://arxiv.org/abs/1811.12030)
+    - Grid R-CNN Plus: Faster and Better (https://arxiv.org/abs/1906.05688)
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 rpn_head: ConfigType,
+                 roi_head: ConfigType,
+                 train_cfg: ConfigType,
+                 test_cfg: ConfigType,
+                 neck: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            rpn_head=rpn_head,
+            roi_head=roi_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/grounding_dino.py b/mmdetection/mmdet/models/detectors/grounding_dino.py
new file mode 100644
index 00000000..b1ab7c2d
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/grounding_dino.py
@@ -0,0 +1,621 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import re
+import warnings
+from typing import Dict, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+from mmengine.runner.amp import autocast
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import OptSampleList, SampleList
+from mmdet.utils import ConfigType
+from ..layers import SinePositionalEncoding
+from ..layers.transformer.grounding_dino_layers import (
+    GroundingDinoTransformerDecoder, GroundingDinoTransformerEncoder)
+from .dino import DINO
+from .glip import (create_positive_map, create_positive_map_label_to_token,
+                   run_ner)
+
+
+def clean_label_name(name: str) -> str:
+    name = re.sub(r'\(.*\)', '', name)
+    name = re.sub(r'_', ' ', name)
+    name = re.sub(r'  ', ' ', name)
+    return name
+
+
+def chunks(lst: list, n: int) -> list:
+    """Yield successive n-sized chunks from lst."""
+    all_ = []
+    for i in range(0, len(lst), n):
+        data_index = lst[i:i + n]
+        all_.append(data_index)
+    counter = 0
+    for i in all_:
+        counter += len(i)
+    assert (counter == len(lst))
+
+    return all_
+
+
+@MODELS.register_module()
+class GroundingDINO(DINO):
+    """Implementation of `Grounding DINO: Marrying DINO with Grounded Pre-
+    Training for Open-Set Object Detection.
+
+    `_
+
+    Code is modified from the `official github repo
+    `_.
+    """
+
+    def __init__(self,
+                 language_model,
+                 *args,
+                 use_autocast=False,
+                 **kwargs) -> None:
+
+        self.language_model_cfg = language_model
+        self._special_tokens = '. '
+        self.use_autocast = use_autocast
+        super().__init__(*args, **kwargs)
+
+    def _init_layers(self) -> None:
+        """Initialize layers except for backbone, neck and bbox_head."""
+        self.positional_encoding = SinePositionalEncoding(
+            **self.positional_encoding)
+        self.encoder = GroundingDinoTransformerEncoder(**self.encoder)
+        self.decoder = GroundingDinoTransformerDecoder(**self.decoder)
+        self.embed_dims = self.encoder.embed_dims
+        self.query_embedding = nn.Embedding(self.num_queries, self.embed_dims)
+        num_feats = self.positional_encoding.num_feats
+        assert num_feats * 2 == self.embed_dims, \
+            f'embed_dims should be exactly 2 times of num_feats. ' \
+            f'Found {self.embed_dims} and {num_feats}.'
+
+        self.level_embed = nn.Parameter(
+            torch.Tensor(self.num_feature_levels, self.embed_dims))
+        self.memory_trans_fc = nn.Linear(self.embed_dims, self.embed_dims)
+        self.memory_trans_norm = nn.LayerNorm(self.embed_dims)
+
+        # text modules
+        self.language_model = MODELS.build(self.language_model_cfg)
+        self.text_feat_map = nn.Linear(
+            self.language_model.language_backbone.body.language_dim,
+            self.embed_dims,
+            bias=True)
+
+    def init_weights(self) -> None:
+        """Initialize weights for Transformer and other components."""
+        super().init_weights()
+        nn.init.constant_(self.text_feat_map.bias.data, 0)
+        nn.init.xavier_uniform_(self.text_feat_map.weight.data)
+
+    def to_enhance_text_prompts(self, original_caption, enhanced_text_prompts):
+        caption_string = ''
+        tokens_positive = []
+        for idx, word in enumerate(original_caption):
+            if word in enhanced_text_prompts:
+                enhanced_text_dict = enhanced_text_prompts[word]
+                if 'prefix' in enhanced_text_dict:
+                    caption_string += enhanced_text_dict['prefix']
+                start_i = len(caption_string)
+                if 'name' in enhanced_text_dict:
+                    caption_string += enhanced_text_dict['name']
+                else:
+                    caption_string += word
+                end_i = len(caption_string)
+                tokens_positive.append([[start_i, end_i]])
+
+                if 'suffix' in enhanced_text_dict:
+                    caption_string += enhanced_text_dict['suffix']
+            else:
+                tokens_positive.append(
+                    [[len(caption_string),
+                      len(caption_string) + len(word)]])
+                caption_string += word
+            caption_string += self._special_tokens
+        return caption_string, tokens_positive
+
+    def to_plain_text_prompts(self, original_caption):
+        caption_string = ''
+        tokens_positive = []
+        for idx, word in enumerate(original_caption):
+            tokens_positive.append(
+                [[len(caption_string),
+                  len(caption_string) + len(word)]])
+            caption_string += word
+            caption_string += self._special_tokens
+        return caption_string, tokens_positive
+
+    def get_tokens_and_prompts(
+        self,
+        original_caption: Union[str, list, tuple],
+        custom_entities: bool = False,
+        enhanced_text_prompts: Optional[ConfigType] = None
+    ) -> Tuple[dict, str, list]:
+        """Get the tokens positive and prompts for the caption."""
+        if isinstance(original_caption, (list, tuple)) or custom_entities:
+            if custom_entities and isinstance(original_caption, str):
+                original_caption = original_caption.strip(self._special_tokens)
+                original_caption = original_caption.split(self._special_tokens)
+                original_caption = list(
+                    filter(lambda x: len(x) > 0, original_caption))
+
+            original_caption = [clean_label_name(i) for i in original_caption]
+
+            if custom_entities and enhanced_text_prompts is not None:
+                caption_string, tokens_positive = self.to_enhance_text_prompts(
+                    original_caption, enhanced_text_prompts)
+            else:
+                caption_string, tokens_positive = self.to_plain_text_prompts(
+                    original_caption)
+
+            # NOTE: Tokenizer in Grounding DINO is different from
+            # that in GLIP. The tokenizer in GLIP will pad the
+            # caption_string to max_length, while the tokenizer
+            # in Grounding DINO will not.
+            tokenized = self.language_model.tokenizer(
+                [caption_string],
+                padding='max_length'
+                if self.language_model.pad_to_max else 'longest',
+                return_tensors='pt')
+            entities = original_caption
+        else:
+            if not original_caption.endswith('.'):
+                original_caption = original_caption + self._special_tokens
+            # NOTE: Tokenizer in Grounding DINO is different from
+            # that in GLIP. The tokenizer in GLIP will pad the
+            # caption_string to max_length, while the tokenizer
+            # in Grounding DINO will not.
+            tokenized = self.language_model.tokenizer(
+                [original_caption],
+                padding='max_length'
+                if self.language_model.pad_to_max else 'longest',
+                return_tensors='pt')
+            tokens_positive, noun_phrases = run_ner(original_caption)
+            entities = noun_phrases
+            caption_string = original_caption
+
+        return tokenized, caption_string, tokens_positive, entities
+
+    def get_positive_map(self, tokenized, tokens_positive):
+        positive_map = create_positive_map(
+            tokenized,
+            tokens_positive,
+            max_num_entities=self.bbox_head.cls_branches[
+                self.decoder.num_layers].max_text_len)
+        positive_map_label_to_token = create_positive_map_label_to_token(
+            positive_map, plus=1)
+        return positive_map_label_to_token, positive_map
+
+    def get_tokens_positive_and_prompts(
+        self,
+        original_caption: Union[str, list, tuple],
+        custom_entities: bool = False,
+        enhanced_text_prompt: Optional[ConfigType] = None,
+        tokens_positive: Optional[list] = None,
+    ) -> Tuple[dict, str, Tensor, list]:
+        """Get the tokens positive and prompts for the caption.
+
+        Args:
+            original_caption (str): The original caption, e.g. 'bench . car .'
+            custom_entities (bool, optional): Whether to use custom entities.
+                If ``True``, the ``original_caption`` should be a list of
+                strings, each of which is a word. Defaults to False.
+
+        Returns:
+            Tuple[dict, str, dict, str]: The dict is a mapping from each entity
+            id, which is numbered from 1, to its positive token id.
+            The str represents the prompts.
+        """
+        if tokens_positive is not None:
+            if tokens_positive == -1:
+                if not original_caption.endswith('.'):
+                    original_caption = original_caption + self._special_tokens
+                return None, original_caption, None, original_caption
+            else:
+                if not original_caption.endswith('.'):
+                    original_caption = original_caption + self._special_tokens
+                tokenized = self.language_model.tokenizer(
+                    [original_caption],
+                    padding='max_length'
+                    if self.language_model.pad_to_max else 'longest',
+                    return_tensors='pt')
+                positive_map_label_to_token, positive_map = \
+                    self.get_positive_map(tokenized, tokens_positive)
+
+                entities = []
+                for token_positive in tokens_positive:
+                    instance_entities = []
+                    for t in token_positive:
+                        instance_entities.append(original_caption[t[0]:t[1]])
+                    entities.append(' / '.join(instance_entities))
+                return positive_map_label_to_token, original_caption, \
+                    positive_map, entities
+
+        chunked_size = self.test_cfg.get('chunked_size', -1)
+        if not self.training and chunked_size > 0:
+            assert isinstance(original_caption,
+                              (list, tuple)) or custom_entities is True
+            all_output = self.get_tokens_positive_and_prompts_chunked(
+                original_caption, enhanced_text_prompt)
+            positive_map_label_to_token, \
+                caption_string, \
+                positive_map, \
+                entities = all_output
+        else:
+            tokenized, caption_string, tokens_positive, entities = \
+                self.get_tokens_and_prompts(
+                    original_caption, custom_entities, enhanced_text_prompt)
+            positive_map_label_to_token, positive_map = self.get_positive_map(
+                tokenized, tokens_positive)
+        return positive_map_label_to_token, caption_string, \
+            positive_map, entities
+
+    def get_tokens_positive_and_prompts_chunked(
+            self,
+            original_caption: Union[list, tuple],
+            enhanced_text_prompts: Optional[ConfigType] = None):
+        chunked_size = self.test_cfg.get('chunked_size', -1)
+        original_caption = [clean_label_name(i) for i in original_caption]
+
+        original_caption_chunked = chunks(original_caption, chunked_size)
+        ids_chunked = chunks(
+            list(range(1,
+                       len(original_caption) + 1)), chunked_size)
+
+        positive_map_label_to_token_chunked = []
+        caption_string_chunked = []
+        positive_map_chunked = []
+        entities_chunked = []
+
+        for i in range(len(ids_chunked)):
+            if enhanced_text_prompts is not None:
+                caption_string, tokens_positive = self.to_enhance_text_prompts(
+                    original_caption_chunked[i], enhanced_text_prompts)
+            else:
+                caption_string, tokens_positive = self.to_plain_text_prompts(
+                    original_caption_chunked[i])
+            tokenized = self.language_model.tokenizer([caption_string],
+                                                      return_tensors='pt')
+            if tokenized.input_ids.shape[1] > self.language_model.max_tokens:
+                warnings.warn('Inputting a text that is too long will result '
+                              'in poor prediction performance. '
+                              'Please reduce the --chunked-size.')
+            positive_map_label_to_token, positive_map = self.get_positive_map(
+                tokenized, tokens_positive)
+
+            caption_string_chunked.append(caption_string)
+            positive_map_label_to_token_chunked.append(
+                positive_map_label_to_token)
+            positive_map_chunked.append(positive_map)
+            entities_chunked.append(original_caption_chunked[i])
+
+        return positive_map_label_to_token_chunked, \
+            caption_string_chunked, \
+            positive_map_chunked, \
+            entities_chunked
+
+    def forward_transformer(
+        self,
+        img_feats: Tuple[Tensor],
+        text_dict: Dict,
+        batch_data_samples: OptSampleList = None,
+    ) -> Dict:
+        encoder_inputs_dict, decoder_inputs_dict = self.pre_transformer(
+            img_feats, batch_data_samples)
+
+        encoder_outputs_dict = self.forward_encoder(
+            **encoder_inputs_dict, text_dict=text_dict)
+
+        tmp_dec_in, head_inputs_dict = self.pre_decoder(
+            **encoder_outputs_dict, batch_data_samples=batch_data_samples)
+        decoder_inputs_dict.update(tmp_dec_in)
+
+        decoder_outputs_dict = self.forward_decoder(**decoder_inputs_dict)
+        head_inputs_dict.update(decoder_outputs_dict)
+        return head_inputs_dict
+
+    def forward_encoder(self, feat: Tensor, feat_mask: Tensor,
+                        feat_pos: Tensor, spatial_shapes: Tensor,
+                        level_start_index: Tensor, valid_ratios: Tensor,
+                        text_dict: Dict) -> Dict:
+        text_token_mask = text_dict['text_token_mask']
+        memory, memory_text = self.encoder(
+            query=feat,
+            query_pos=feat_pos,
+            key_padding_mask=feat_mask,  # for self_attn
+            spatial_shapes=spatial_shapes,
+            level_start_index=level_start_index,
+            valid_ratios=valid_ratios,
+            # for text encoder
+            memory_text=text_dict['embedded'],
+            text_attention_mask=~text_token_mask,
+            position_ids=text_dict['position_ids'],
+            text_self_attention_masks=text_dict['masks'])
+        encoder_outputs_dict = dict(
+            memory=memory,
+            memory_mask=feat_mask,
+            spatial_shapes=spatial_shapes,
+            memory_text=memory_text,
+            text_token_mask=text_token_mask)
+        return encoder_outputs_dict
+
+    def pre_decoder(
+        self,
+        memory: Tensor,
+        memory_mask: Tensor,
+        spatial_shapes: Tensor,
+        memory_text: Tensor,
+        text_token_mask: Tensor,
+        batch_data_samples: OptSampleList = None,
+    ) -> Tuple[Dict]:
+        bs, _, c = memory.shape
+
+        output_memory, output_proposals = self.gen_encoder_output_proposals(
+            memory, memory_mask, spatial_shapes)
+
+        enc_outputs_class = self.bbox_head.cls_branches[
+            self.decoder.num_layers](output_memory, memory_text,
+                                     text_token_mask)
+        cls_out_features = self.bbox_head.cls_branches[
+            self.decoder.num_layers].max_text_len
+        enc_outputs_coord_unact = self.bbox_head.reg_branches[
+            self.decoder.num_layers](output_memory) + output_proposals
+
+        # NOTE The DINO selects top-k proposals according to scores of
+        # multi-class classification, while DeformDETR, where the input
+        # is `enc_outputs_class[..., 0]` selects according to scores of
+        # binary classification.
+        topk_indices = torch.topk(
+            enc_outputs_class.max(-1)[0], k=self.num_queries, dim=1)[1]
+
+        topk_score = torch.gather(
+            enc_outputs_class, 1,
+            topk_indices.unsqueeze(-1).repeat(1, 1, cls_out_features))
+        topk_coords_unact = torch.gather(
+            enc_outputs_coord_unact, 1,
+            topk_indices.unsqueeze(-1).repeat(1, 1, 4))
+        topk_coords = topk_coords_unact.sigmoid()
+        topk_coords_unact = topk_coords_unact.detach()
+
+        query = self.query_embedding.weight[:, None, :]
+        query = query.repeat(1, bs, 1).transpose(0, 1)
+        if self.training:
+            dn_label_query, dn_bbox_query, dn_mask, dn_meta = \
+                self.dn_query_generator(batch_data_samples)
+            query = torch.cat([dn_label_query, query], dim=1)
+            reference_points = torch.cat([dn_bbox_query, topk_coords_unact],
+                                         dim=1)
+        else:
+            reference_points = topk_coords_unact
+            dn_mask, dn_meta = None, None
+        reference_points = reference_points.sigmoid()
+
+        decoder_inputs_dict = dict(
+            query=query,
+            memory=memory,
+            reference_points=reference_points,
+            dn_mask=dn_mask,
+            memory_text=memory_text,
+            text_attention_mask=~text_token_mask,
+        )
+        # NOTE DINO calculates encoder losses on scores and coordinates
+        # of selected top-k encoder queries, while DeformDETR is of all
+        # encoder queries.
+        head_inputs_dict = dict(
+            enc_outputs_class=topk_score,
+            enc_outputs_coord=topk_coords,
+            dn_meta=dn_meta) if self.training else dict()
+        # append text_feats to head_inputs_dict
+        head_inputs_dict['memory_text'] = memory_text
+        head_inputs_dict['text_token_mask'] = text_token_mask
+        return decoder_inputs_dict, head_inputs_dict
+
+    def loss(self, batch_inputs: Tensor,
+             batch_data_samples: SampleList) -> Union[dict, list]:
+        text_prompts = [
+            data_samples.text for data_samples in batch_data_samples
+        ]
+
+        gt_labels = [
+            data_samples.gt_instances.labels
+            for data_samples in batch_data_samples
+        ]
+
+        if 'tokens_positive' in batch_data_samples[0]:
+            tokens_positive = [
+                data_samples.tokens_positive
+                for data_samples in batch_data_samples
+            ]
+            positive_maps = []
+            for token_positive, text_prompt, gt_label in zip(
+                    tokens_positive, text_prompts, gt_labels):
+                tokenized = self.language_model.tokenizer(
+                    [text_prompt],
+                    padding='max_length'
+                    if self.language_model.pad_to_max else 'longest',
+                    return_tensors='pt')
+                new_tokens_positive = [
+                    token_positive[label.item()] for label in gt_label
+                ]
+                _, positive_map = self.get_positive_map(
+                    tokenized, new_tokens_positive)
+                positive_maps.append(positive_map)
+            new_text_prompts = text_prompts
+        else:
+            new_text_prompts = []
+            positive_maps = []
+            if len(set(text_prompts)) == 1:
+                # All the text prompts are the same,
+                # so there is no need to calculate them multiple times.
+                tokenized, caption_string, tokens_positive, _ = \
+                    self.get_tokens_and_prompts(
+                        text_prompts[0], True)
+                new_text_prompts = [caption_string] * len(batch_inputs)
+                for gt_label in gt_labels:
+                    new_tokens_positive = [
+                        tokens_positive[label] for label in gt_label
+                    ]
+                    _, positive_map = self.get_positive_map(
+                        tokenized, new_tokens_positive)
+                    positive_maps.append(positive_map)
+            else:
+                for text_prompt, gt_label in zip(text_prompts, gt_labels):
+                    tokenized, caption_string, tokens_positive, _ = \
+                        self.get_tokens_and_prompts(
+                            text_prompt, True)
+                    new_tokens_positive = [
+                        tokens_positive[label] for label in gt_label
+                    ]
+                    _, positive_map = self.get_positive_map(
+                        tokenized, new_tokens_positive)
+                    positive_maps.append(positive_map)
+                    new_text_prompts.append(caption_string)
+
+        text_dict = self.language_model(new_text_prompts)
+        if self.text_feat_map is not None:
+            text_dict['embedded'] = self.text_feat_map(text_dict['embedded'])
+
+        for i, data_samples in enumerate(batch_data_samples):
+            positive_map = positive_maps[i].to(
+                batch_inputs.device).bool().float()
+            text_token_mask = text_dict['text_token_mask'][i]
+            data_samples.gt_instances.positive_maps = positive_map
+            data_samples.gt_instances.text_token_mask = \
+                text_token_mask.unsqueeze(0).repeat(
+                    len(positive_map), 1)
+        if self.use_autocast:
+            with autocast(enabled=True):
+                visual_features = self.extract_feat(batch_inputs)
+        else:
+            visual_features = self.extract_feat(batch_inputs)
+        head_inputs_dict = self.forward_transformer(visual_features, text_dict,
+                                                    batch_data_samples)
+
+        losses = self.bbox_head.loss(
+            **head_inputs_dict, batch_data_samples=batch_data_samples)
+        return losses
+
+    def predict(self, batch_inputs, batch_data_samples, rescale: bool = True):
+        text_prompts = []
+        enhanced_text_prompts = []
+        tokens_positives = []
+        for data_samples in batch_data_samples:
+            text_prompts.append(data_samples.text)
+            if 'caption_prompt' in data_samples:
+                enhanced_text_prompts.append(data_samples.caption_prompt)
+            else:
+                enhanced_text_prompts.append(None)
+            tokens_positives.append(data_samples.get('tokens_positive', None))
+
+        if 'custom_entities' in batch_data_samples[0]:
+            # Assuming that the `custom_entities` flag
+            # inside a batch is always the same. For single image inference
+            custom_entities = batch_data_samples[0].custom_entities
+        else:
+            custom_entities = False
+        if len(text_prompts) == 1:
+            # All the text prompts are the same,
+            # so there is no need to calculate them multiple times.
+            _positive_maps_and_prompts = [
+                self.get_tokens_positive_and_prompts(
+                    text_prompts[0], custom_entities, enhanced_text_prompts[0],
+                    tokens_positives[0])
+            ] * len(batch_inputs)
+        else:
+            _positive_maps_and_prompts = [
+                self.get_tokens_positive_and_prompts(text_prompt,
+                                                     custom_entities,
+                                                     enhanced_text_prompt,
+                                                     tokens_positive)
+                for text_prompt, enhanced_text_prompt, tokens_positive in zip(
+                    text_prompts, enhanced_text_prompts, tokens_positives)
+            ]
+        token_positive_maps, text_prompts, _, entities = zip(
+            *_positive_maps_and_prompts)
+
+        # image feature extraction
+        visual_feats = self.extract_feat(batch_inputs)
+
+        if isinstance(text_prompts[0], list):
+            # chunked text prompts, only bs=1 is supported
+            assert len(batch_inputs) == 1
+            count = 0
+            results_list = []
+
+            entities = [[item for lst in entities[0] for item in lst]]
+
+            for b in range(len(text_prompts[0])):
+                text_prompts_once = [text_prompts[0][b]]
+                token_positive_maps_once = token_positive_maps[0][b]
+                text_dict = self.language_model(text_prompts_once)
+                # text feature map layer
+                if self.text_feat_map is not None:
+                    text_dict['embedded'] = self.text_feat_map(
+                        text_dict['embedded'])
+
+                batch_data_samples[
+                    0].token_positive_map = token_positive_maps_once
+
+                head_inputs_dict = self.forward_transformer(
+                    copy.deepcopy(visual_feats), text_dict, batch_data_samples)
+                pred_instances = self.bbox_head.predict(
+                    **head_inputs_dict,
+                    rescale=rescale,
+                    batch_data_samples=batch_data_samples)[0]
+
+                if len(pred_instances) > 0:
+                    pred_instances.labels += count
+                count += len(token_positive_maps_once)
+                results_list.append(pred_instances)
+            results_list = [results_list[0].cat(results_list)]
+            is_rec_tasks = [False] * len(results_list)
+        else:
+            # extract text feats
+            text_dict = self.language_model(list(text_prompts))
+            # text feature map layer
+            if self.text_feat_map is not None:
+                text_dict['embedded'] = self.text_feat_map(
+                    text_dict['embedded'])
+
+            is_rec_tasks = []
+            for i, data_samples in enumerate(batch_data_samples):
+                if token_positive_maps[i] is not None:
+                    is_rec_tasks.append(False)
+                else:
+                    is_rec_tasks.append(True)
+                data_samples.token_positive_map = token_positive_maps[i]
+
+            head_inputs_dict = self.forward_transformer(
+                visual_feats, text_dict, batch_data_samples)
+            results_list = self.bbox_head.predict(
+                **head_inputs_dict,
+                rescale=rescale,
+                batch_data_samples=batch_data_samples)
+
+        for data_sample, pred_instances, entity, is_rec_task in zip(
+                batch_data_samples, results_list, entities, is_rec_tasks):
+            if len(pred_instances) > 0:
+                label_names = []
+                for labels in pred_instances.labels:
+                    if is_rec_task:
+                        label_names.append(entity)
+                        continue
+                    if labels >= len(entity):
+                        warnings.warn(
+                            'The unexpected output indicates an issue with '
+                            'named entity recognition. You can try '
+                            'setting custom_entities=True and running '
+                            'again to see if it helps.')
+                        label_names.append('unobject')
+                    else:
+                        label_names.append(entity[labels])
+                # for visualization
+                pred_instances.label_names = label_names
+            data_sample.pred_instances = pred_instances
+        return batch_data_samples
diff --git a/mmdetection/mmdet/models/detectors/htc.py b/mmdetection/mmdet/models/detectors/htc.py
new file mode 100644
index 00000000..22a2aa88
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/htc.py
@@ -0,0 +1,16 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from .cascade_rcnn import CascadeRCNN
+
+
+@MODELS.register_module()
+class HybridTaskCascade(CascadeRCNN):
+    """Implementation of `HTC `_"""
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+
+    @property
+    def with_semantic(self) -> bool:
+        """bool: whether the detector has a semantic head"""
+        return self.roi_head.with_semantic
diff --git a/mmdetection/mmdet/models/detectors/kd_one_stage.py b/mmdetection/mmdet/models/detectors/kd_one_stage.py
new file mode 100644
index 00000000..8a4a1bb5
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/kd_one_stage.py
@@ -0,0 +1,122 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from pathlib import Path
+from typing import Any, Optional, Union
+
+import torch
+import torch.nn as nn
+from mmengine.config import Config
+from mmengine.runner import load_checkpoint
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.utils import ConfigType, OptConfigType
+from .single_stage import SingleStageDetector
+
+
+@MODELS.register_module()
+class KnowledgeDistillationSingleStageDetector(SingleStageDetector):
+    r"""Implementation of `Distilling the Knowledge in a Neural Network.
+    `_.
+
+    Args:
+        backbone (:obj:`ConfigDict` or dict): The backbone module.
+        neck (:obj:`ConfigDict` or dict): The neck module.
+        bbox_head (:obj:`ConfigDict` or dict): The bbox head module.
+        teacher_config (:obj:`ConfigDict` | dict | str | Path): Config file
+            path or the config object of teacher model.
+        teacher_ckpt (str, optional): Checkpoint path of teacher model.
+            If left as None, the model will not load any weights.
+            Defaults to True.
+        eval_teacher (bool): Set the train mode for teacher.
+            Defaults to True.
+        train_cfg (:obj:`ConfigDict` or dict, optional): The training config
+            of ATSS. Defaults to None.
+        test_cfg (:obj:`ConfigDict` or dict, optional): The testing config
+            of ATSS. Defaults to None.
+        data_preprocessor (:obj:`ConfigDict` or dict, optional): Config of
+            :class:`DetDataPreprocessor` to process the input data.
+            Defaults to None.
+    """
+
+    def __init__(
+        self,
+        backbone: ConfigType,
+        neck: ConfigType,
+        bbox_head: ConfigType,
+        teacher_config: Union[ConfigType, str, Path],
+        teacher_ckpt: Optional[str] = None,
+        eval_teacher: bool = True,
+        train_cfg: OptConfigType = None,
+        test_cfg: OptConfigType = None,
+        data_preprocessor: OptConfigType = None,
+    ) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor)
+        self.eval_teacher = eval_teacher
+        # Build teacher model
+        if isinstance(teacher_config, (str, Path)):
+            teacher_config = Config.fromfile(teacher_config)
+        self.teacher_model = MODELS.build(teacher_config['model'])
+        if teacher_ckpt is not None:
+            load_checkpoint(
+                self.teacher_model, teacher_ckpt, map_location='cpu')
+
+    def loss(self, batch_inputs: Tensor,
+             batch_data_samples: SampleList) -> dict:
+        """
+        Args:
+            batch_inputs (Tensor): Input images of shape (N, C, H, W).
+                These should usually be mean centered and std scaled.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        x = self.extract_feat(batch_inputs)
+        with torch.no_grad():
+            teacher_x = self.teacher_model.extract_feat(batch_inputs)
+            out_teacher = self.teacher_model.bbox_head(teacher_x)
+        losses = self.bbox_head.loss(x, out_teacher, batch_data_samples)
+        return losses
+
+    def cuda(self, device: Optional[str] = None) -> nn.Module:
+        """Since teacher_model is registered as a plain object, it is necessary
+        to put the teacher model to cuda when calling ``cuda`` function."""
+        self.teacher_model.cuda(device=device)
+        return super().cuda(device=device)
+
+    def to(self, device: Optional[str] = None) -> nn.Module:
+        """Since teacher_model is registered as a plain object, it is necessary
+        to put the teacher model to other device when calling ``to``
+        function."""
+        self.teacher_model.to(device=device)
+        return super().to(device=device)
+
+    def train(self, mode: bool = True) -> None:
+        """Set the same train mode for teacher and student model."""
+        if self.eval_teacher:
+            self.teacher_model.train(False)
+        else:
+            self.teacher_model.train(mode)
+        super().train(mode)
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        """Set attribute, i.e. self.name = value
+
+        This reloading prevent the teacher model from being registered as a
+        nn.Module. The teacher module is registered as a plain object, so that
+        the teacher parameters will not show up when calling
+        ``self.parameters``, ``self.modules``, ``self.children`` methods.
+        """
+        if name == 'teacher_model':
+            object.__setattr__(self, name, value)
+        else:
+            super().__setattr__(name, value)
diff --git a/mmdetection/mmdet/models/detectors/lad.py b/mmdetection/mmdet/models/detectors/lad.py
new file mode 100644
index 00000000..008f8987
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/lad.py
@@ -0,0 +1,93 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional
+
+import torch
+import torch.nn as nn
+from mmengine.runner import load_checkpoint
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.utils import ConfigType, OptConfigType
+from ..utils.misc import unpack_gt_instances
+from .kd_one_stage import KnowledgeDistillationSingleStageDetector
+
+
+@MODELS.register_module()
+class LAD(KnowledgeDistillationSingleStageDetector):
+    """Implementation of `LAD `_."""
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 teacher_backbone: ConfigType,
+                 teacher_neck: ConfigType,
+                 teacher_bbox_head: ConfigType,
+                 teacher_ckpt: Optional[str] = None,
+                 eval_teacher: bool = True,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None) -> None:
+        super(KnowledgeDistillationSingleStageDetector, self).__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor)
+        self.eval_teacher = eval_teacher
+        self.teacher_model = nn.Module()
+        self.teacher_model.backbone = MODELS.build(teacher_backbone)
+        if teacher_neck is not None:
+            self.teacher_model.neck = MODELS.build(teacher_neck)
+        teacher_bbox_head.update(train_cfg=train_cfg)
+        teacher_bbox_head.update(test_cfg=test_cfg)
+        self.teacher_model.bbox_head = MODELS.build(teacher_bbox_head)
+        if teacher_ckpt is not None:
+            load_checkpoint(
+                self.teacher_model, teacher_ckpt, map_location='cpu')
+
+    @property
+    def with_teacher_neck(self) -> bool:
+        """bool: whether the detector has a teacher_neck"""
+        return hasattr(self.teacher_model, 'neck') and \
+            self.teacher_model.neck is not None
+
+    def extract_teacher_feat(self, batch_inputs: Tensor) -> Tensor:
+        """Directly extract teacher features from the backbone+neck."""
+        x = self.teacher_model.backbone(batch_inputs)
+        if self.with_teacher_neck:
+            x = self.teacher_model.neck(x)
+        return x
+
+    def loss(self, batch_inputs: Tensor,
+             batch_data_samples: SampleList) -> dict:
+        """
+        Args:
+            batch_inputs (Tensor): Input images of shape (N, C, H, W).
+                These should usually be mean centered and std scaled.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        outputs = unpack_gt_instances(batch_data_samples)
+        batch_gt_instances, batch_gt_instances_ignore, batch_img_metas \
+            = outputs
+        # get label assignment from the teacher
+        with torch.no_grad():
+            x_teacher = self.extract_teacher_feat(batch_inputs)
+            outs_teacher = self.teacher_model.bbox_head(x_teacher)
+            label_assignment_results = \
+                self.teacher_model.bbox_head.get_label_assignment(
+                    *outs_teacher, batch_gt_instances, batch_img_metas,
+                    batch_gt_instances_ignore)
+
+        # the student use the label assignment from the teacher to learn
+        x = self.extract_feat(batch_inputs)
+        losses = self.bbox_head.loss(x, label_assignment_results,
+                                     batch_data_samples)
+        return losses
diff --git a/mmdetection/mmdet/models/detectors/mask2former.py b/mmdetection/mmdet/models/detectors/mask2former.py
new file mode 100644
index 00000000..4f38ef44
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/mask2former.py
@@ -0,0 +1,30 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .maskformer import MaskFormer
+
+
+@MODELS.register_module()
+class Mask2Former(MaskFormer):
+    r"""Implementation of `Masked-attention Mask
+    Transformer for Universal Image Segmentation
+    `_."""
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: OptConfigType = None,
+                 panoptic_head: OptConfigType = None,
+                 panoptic_fusion_head: OptConfigType = None,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None):
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            panoptic_head=panoptic_head,
+            panoptic_fusion_head=panoptic_fusion_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/mask_rcnn.py b/mmdetection/mmdet/models/detectors/mask_rcnn.py
new file mode 100644
index 00000000..880ee1e8
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/mask_rcnn.py
@@ -0,0 +1,30 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.config import ConfigDict
+
+from mmdet.registry import MODELS
+from mmdet.utils import OptConfigType, OptMultiConfig
+from .two_stage import TwoStageDetector
+
+
+@MODELS.register_module()
+class MaskRCNN(TwoStageDetector):
+    """Implementation of `Mask R-CNN `_"""
+
+    def __init__(self,
+                 backbone: ConfigDict,
+                 rpn_head: ConfigDict,
+                 roi_head: ConfigDict,
+                 train_cfg: ConfigDict,
+                 test_cfg: ConfigDict,
+                 neck: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            rpn_head=rpn_head,
+            roi_head=roi_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            init_cfg=init_cfg,
+            data_preprocessor=data_preprocessor)
diff --git a/mmdetection/mmdet/models/detectors/mask_scoring_rcnn.py b/mmdetection/mmdet/models/detectors/mask_scoring_rcnn.py
new file mode 100644
index 00000000..e09d3a10
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/mask_scoring_rcnn.py
@@ -0,0 +1,31 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .two_stage import TwoStageDetector
+
+
+@MODELS.register_module()
+class MaskScoringRCNN(TwoStageDetector):
+    """Mask Scoring RCNN.
+
+    https://arxiv.org/abs/1903.00241
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 rpn_head: ConfigType,
+                 roi_head: ConfigType,
+                 train_cfg: ConfigType,
+                 test_cfg: ConfigType,
+                 neck: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            rpn_head=rpn_head,
+            roi_head=roi_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/maskformer.py b/mmdetection/mmdet/models/detectors/maskformer.py
new file mode 100644
index 00000000..7493c00e
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/maskformer.py
@@ -0,0 +1,170 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, List, Tuple
+
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage import SingleStageDetector
+
+
+@MODELS.register_module()
+class MaskFormer(SingleStageDetector):
+    r"""Implementation of `Per-Pixel Classification is
+    NOT All You Need for Semantic Segmentation
+    `_."""
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: OptConfigType = None,
+                 panoptic_head: OptConfigType = None,
+                 panoptic_fusion_head: OptConfigType = None,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None):
+        super(SingleStageDetector, self).__init__(
+            data_preprocessor=data_preprocessor, init_cfg=init_cfg)
+        self.backbone = MODELS.build(backbone)
+        if neck is not None:
+            self.neck = MODELS.build(neck)
+
+        panoptic_head_ = panoptic_head.deepcopy()
+        panoptic_head_.update(train_cfg=train_cfg)
+        panoptic_head_.update(test_cfg=test_cfg)
+        self.panoptic_head = MODELS.build(panoptic_head_)
+
+        panoptic_fusion_head_ = panoptic_fusion_head.deepcopy()
+        panoptic_fusion_head_.update(test_cfg=test_cfg)
+        self.panoptic_fusion_head = MODELS.build(panoptic_fusion_head_)
+
+        self.num_things_classes = self.panoptic_head.num_things_classes
+        self.num_stuff_classes = self.panoptic_head.num_stuff_classes
+        self.num_classes = self.panoptic_head.num_classes
+
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+
+    def loss(self, batch_inputs: Tensor,
+             batch_data_samples: SampleList) -> Dict[str, Tensor]:
+        """
+        Args:
+            batch_inputs (Tensor): Input images of shape (N, C, H, W).
+                These should usually be mean centered and std scaled.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            dict[str, Tensor]: a dictionary of loss components
+        """
+        x = self.extract_feat(batch_inputs)
+        losses = self.panoptic_head.loss(x, batch_data_samples)
+        return losses
+
+    def predict(self,
+                batch_inputs: Tensor,
+                batch_data_samples: SampleList,
+                rescale: bool = True) -> SampleList:
+        """Predict results from a batch of inputs and data samples with post-
+        processing.
+
+        Args:
+            batch_inputs (Tensor): Inputs with shape (N, C, H, W).
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            rescale (bool): Whether to rescale the results.
+                Defaults to True.
+
+        Returns:
+            list[:obj:`DetDataSample`]: Detection results of the
+            input images. Each DetDataSample usually contain
+            'pred_instances' and `pred_panoptic_seg`. And the
+            ``pred_instances`` usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                    (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                    (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                    the last dimension 4 arrange as (x1, y1, x2, y2).
+                - masks (Tensor): Has a shape (num_instances, H, W).
+
+            And the ``pred_panoptic_seg`` contains the following key
+
+                - sem_seg (Tensor): panoptic segmentation mask, has a
+                    shape (1, h, w).
+        """
+        feats = self.extract_feat(batch_inputs)
+        mask_cls_results, mask_pred_results = self.panoptic_head.predict(
+            feats, batch_data_samples)
+        results_list = self.panoptic_fusion_head.predict(
+            mask_cls_results,
+            mask_pred_results,
+            batch_data_samples,
+            rescale=rescale)
+        results = self.add_pred_to_datasample(batch_data_samples, results_list)
+
+        return results
+
+    def add_pred_to_datasample(self, data_samples: SampleList,
+                               results_list: List[dict]) -> SampleList:
+        """Add predictions to `DetDataSample`.
+
+        Args:
+            data_samples (list[:obj:`DetDataSample`], optional): A batch of
+                data samples that contain annotations and predictions.
+            results_list (List[dict]): Instance segmentation, segmantic
+                segmentation and panoptic segmentation results.
+
+        Returns:
+            list[:obj:`DetDataSample`]: Detection results of the
+            input images. Each DetDataSample usually contain
+            'pred_instances' and `pred_panoptic_seg`. And the
+            ``pred_instances`` usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                    (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                    (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                    the last dimension 4 arrange as (x1, y1, x2, y2).
+                - masks (Tensor): Has a shape (num_instances, H, W).
+
+            And the ``pred_panoptic_seg`` contains the following key
+
+                - sem_seg (Tensor): panoptic segmentation mask, has a
+                    shape (1, h, w).
+        """
+        for data_sample, pred_results in zip(data_samples, results_list):
+            if 'pan_results' in pred_results:
+                data_sample.pred_panoptic_seg = pred_results['pan_results']
+
+            if 'ins_results' in pred_results:
+                data_sample.pred_instances = pred_results['ins_results']
+
+            assert 'sem_results' not in pred_results, 'segmantic ' \
+                'segmentation results are not supported yet.'
+
+        return data_samples
+
+    def _forward(self, batch_inputs: Tensor,
+                 batch_data_samples: SampleList) -> Tuple[List[Tensor]]:
+        """Network forward process. Usually includes backbone, neck and head
+        forward without any post-processing.
+
+         Args:
+            batch_inputs (Tensor): Inputs with shape (N, C, H, W).
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            tuple[List[Tensor]]: A tuple of features from ``panoptic_head``
+            forward.
+        """
+        feats = self.extract_feat(batch_inputs)
+        results = self.panoptic_head.forward(feats, batch_data_samples)
+        return results
diff --git a/mmdetection/mmdet/models/detectors/nasfcos.py b/mmdetection/mmdet/models/detectors/nasfcos.py
new file mode 100644
index 00000000..da2b911b
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/nasfcos.py
@@ -0,0 +1,43 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage import SingleStageDetector
+
+
+@MODELS.register_module()
+class NASFCOS(SingleStageDetector):
+    """Implementation of `NAS-FCOS: Fast Neural Architecture Search for Object
+    Detection. `_
+
+    Args:
+        backbone (:obj:`ConfigDict` or dict): The backbone config.
+        neck (:obj:`ConfigDict` or dict): The neck config.
+        bbox_head (:obj:`ConfigDict` or dict): The bbox head config.
+        train_cfg (:obj:`ConfigDict` or dict, optional): The training config
+            of NASFCOS. Defaults to None.
+        test_cfg (:obj:`ConfigDict` or dict, optional): The testing config
+            of NASFCOS. Defaults to None.
+        data_preprocessor (:obj:`ConfigDict` or dict, optional): Config of
+            :class:`DetDataPreprocessor` to process the input data.
+            Defaults to None.
+        init_cfg (:obj:`ConfigDict` or list[:obj:`ConfigDict`] or dict or
+            list[dict], optional): Initialization config dict.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/paa.py b/mmdetection/mmdet/models/detectors/paa.py
new file mode 100644
index 00000000..094306b2
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/paa.py
@@ -0,0 +1,41 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage import SingleStageDetector
+
+
+@MODELS.register_module()
+class PAA(SingleStageDetector):
+    """Implementation of `PAA `_
+
+    Args:
+        backbone (:obj:`ConfigDict` or dict): The backbone module.
+        neck (:obj:`ConfigDict` or dict): The neck module.
+        bbox_head (:obj:`ConfigDict` or dict): The bbox head module.
+        train_cfg (:obj:`ConfigDict` or dict, optional): The training config
+            of PAA. Defaults to None.
+        test_cfg (:obj:`ConfigDict` or dict, optional): The testing config
+            of PAA. Defaults to None.
+        data_preprocessor (:obj:`ConfigDict` or dict, optional): Config of
+            :class:`DetDataPreprocessor` to process the input data.
+            Defaults to None.
+        init_cfg (:obj:`ConfigDict` or dict, optional): the config to control
+            the initialization. Defaults to None.
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/panoptic_fpn.py b/mmdetection/mmdet/models/detectors/panoptic_fpn.py
new file mode 100644
index 00000000..ae63ccc3
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/panoptic_fpn.py
@@ -0,0 +1,35 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .panoptic_two_stage_segmentor import TwoStagePanopticSegmentor
+
+
+@MODELS.register_module()
+class PanopticFPN(TwoStagePanopticSegmentor):
+    r"""Implementation of `Panoptic feature pyramid
+    networks `_"""
+
+    def __init__(
+            self,
+            backbone: ConfigType,
+            neck: OptConfigType = None,
+            rpn_head: OptConfigType = None,
+            roi_head: OptConfigType = None,
+            train_cfg: OptConfigType = None,
+            test_cfg: OptConfigType = None,
+            data_preprocessor: OptConfigType = None,
+            init_cfg: OptMultiConfig = None,
+            # for panoptic segmentation
+            semantic_head: OptConfigType = None,
+            panoptic_fusion_head: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            rpn_head=rpn_head,
+            roi_head=roi_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg,
+            semantic_head=semantic_head,
+            panoptic_fusion_head=panoptic_fusion_head)
diff --git a/mmdetection/mmdet/models/detectors/panoptic_two_stage_segmentor.py b/mmdetection/mmdet/models/detectors/panoptic_two_stage_segmentor.py
new file mode 100644
index 00000000..879edbe1
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/panoptic_two_stage_segmentor.py
@@ -0,0 +1,234 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+from typing import List
+
+import torch
+from mmengine.structures import PixelData
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .two_stage import TwoStageDetector
+
+
+@MODELS.register_module()
+class TwoStagePanopticSegmentor(TwoStageDetector):
+    """Base class of Two-stage Panoptic Segmentor.
+
+    As well as the components in TwoStageDetector, Panoptic Segmentor has extra
+    semantic_head and panoptic_fusion_head.
+    """
+
+    def __init__(
+            self,
+            backbone: ConfigType,
+            neck: OptConfigType = None,
+            rpn_head: OptConfigType = None,
+            roi_head: OptConfigType = None,
+            train_cfg: OptConfigType = None,
+            test_cfg: OptConfigType = None,
+            data_preprocessor: OptConfigType = None,
+            init_cfg: OptMultiConfig = None,
+            # for panoptic segmentation
+            semantic_head: OptConfigType = None,
+            panoptic_fusion_head: OptConfigType = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            rpn_head=rpn_head,
+            roi_head=roi_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
+
+        if semantic_head is not None:
+            self.semantic_head = MODELS.build(semantic_head)
+
+        if panoptic_fusion_head is not None:
+            panoptic_cfg = test_cfg.panoptic if test_cfg is not None else None
+            panoptic_fusion_head_ = panoptic_fusion_head.deepcopy()
+            panoptic_fusion_head_.update(test_cfg=panoptic_cfg)
+            self.panoptic_fusion_head = MODELS.build(panoptic_fusion_head_)
+
+            self.num_things_classes = self.panoptic_fusion_head.\
+                num_things_classes
+            self.num_stuff_classes = self.panoptic_fusion_head.\
+                num_stuff_classes
+            self.num_classes = self.panoptic_fusion_head.num_classes
+
+    @property
+    def with_semantic_head(self) -> bool:
+        """bool: whether the detector has semantic head"""
+        return hasattr(self,
+                       'semantic_head') and self.semantic_head is not None
+
+    @property
+    def with_panoptic_fusion_head(self) -> bool:
+        """bool: whether the detector has panoptic fusion head"""
+        return hasattr(self, 'panoptic_fusion_head') and \
+            self.panoptic_fusion_head is not None
+
+    def loss(self, batch_inputs: Tensor,
+             batch_data_samples: SampleList) -> dict:
+        """
+        Args:
+            batch_inputs (Tensor): Input images of shape (N, C, H, W).
+                These should usually be mean centered and std scaled.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        x = self.extract_feat(batch_inputs)
+
+        losses = dict()
+
+        # RPN forward and loss
+        if self.with_rpn:
+            proposal_cfg = self.train_cfg.get('rpn_proposal',
+                                              self.test_cfg.rpn)
+            rpn_data_samples = copy.deepcopy(batch_data_samples)
+            # set cat_id of gt_labels to 0 in RPN
+            for data_sample in rpn_data_samples:
+                data_sample.gt_instances.labels = \
+                    torch.zeros_like(data_sample.gt_instances.labels)
+
+            rpn_losses, rpn_results_list = self.rpn_head.loss_and_predict(
+                x, rpn_data_samples, proposal_cfg=proposal_cfg)
+            # avoid get same name with roi_head loss
+            keys = rpn_losses.keys()
+            for key in list(keys):
+                if 'loss' in key and 'rpn' not in key:
+                    rpn_losses[f'rpn_{key}'] = rpn_losses.pop(key)
+            losses.update(rpn_losses)
+        else:
+            # TODO: Not support currently, should have a check at Fast R-CNN
+            assert batch_data_samples[0].get('proposals', None) is not None
+            # use pre-defined proposals in InstanceData for the second stage
+            # to extract ROI features.
+            rpn_results_list = [
+                data_sample.proposals for data_sample in batch_data_samples
+            ]
+
+        roi_losses = self.roi_head.loss(x, rpn_results_list,
+                                        batch_data_samples)
+        losses.update(roi_losses)
+
+        semantic_loss = self.semantic_head.loss(x, batch_data_samples)
+        losses.update(semantic_loss)
+
+        return losses
+
+    def predict(self,
+                batch_inputs: Tensor,
+                batch_data_samples: SampleList,
+                rescale: bool = True) -> SampleList:
+        """Predict results from a batch of inputs and data samples with post-
+        processing.
+
+        Args:
+            batch_inputs (Tensor): Inputs with shape (N, C, H, W).
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            rescale (bool): Whether to rescale the results.
+                Defaults to True.
+
+        Returns:
+            List[:obj:`DetDataSample`]: Return the packed panoptic segmentation
+                results of input images. Each DetDataSample usually contains
+                'pred_panoptic_seg'. And the 'pred_panoptic_seg' has a key
+                ``sem_seg``, which is a tensor of shape (1, h, w).
+        """
+        batch_img_metas = [
+            data_samples.metainfo for data_samples in batch_data_samples
+        ]
+
+        x = self.extract_feat(batch_inputs)
+
+        # If there are no pre-defined proposals, use RPN to get proposals
+        if batch_data_samples[0].get('proposals', None) is None:
+            rpn_results_list = self.rpn_head.predict(
+                x, batch_data_samples, rescale=False)
+        else:
+            rpn_results_list = [
+                data_sample.proposals for data_sample in batch_data_samples
+            ]
+
+        results_list = self.roi_head.predict(
+            x, rpn_results_list, batch_data_samples, rescale=rescale)
+
+        seg_preds = self.semantic_head.predict(x, batch_img_metas, rescale)
+
+        results_list = self.panoptic_fusion_head.predict(
+            results_list, seg_preds)
+
+        batch_data_samples = self.add_pred_to_datasample(
+            batch_data_samples, results_list)
+        return batch_data_samples
+
+    # TODO the code has not been verified and needs to be refactored later.
+    def _forward(self, batch_inputs: Tensor,
+                 batch_data_samples: SampleList) -> tuple:
+        """Network forward process. Usually includes backbone, neck and head
+        forward without any post-processing.
+
+        Args:
+            batch_inputs (Tensor): Inputs with shape (N, C, H, W).
+
+        Returns:
+            tuple: A tuple of features from ``rpn_head``, ``roi_head`` and
+                ``semantic_head`` forward.
+        """
+        results = ()
+        x = self.extract_feat(batch_inputs)
+        rpn_outs = self.rpn_head.forward(x)
+        results = results + (rpn_outs)
+
+        # If there are no pre-defined proposals, use RPN to get proposals
+        if batch_data_samples[0].get('proposals', None) is None:
+            batch_img_metas = [
+                data_samples.metainfo for data_samples in batch_data_samples
+            ]
+            rpn_results_list = self.rpn_head.predict_by_feat(
+                *rpn_outs, batch_img_metas=batch_img_metas, rescale=False)
+        else:
+            # TODO: Not checked currently.
+            rpn_results_list = [
+                data_sample.proposals for data_sample in batch_data_samples
+            ]
+
+        # roi_head
+        roi_outs = self.roi_head(x, rpn_results_list)
+        results = results + (roi_outs)
+
+        # semantic_head
+        sem_outs = self.semantic_head.forward(x)
+        results = results + (sem_outs['seg_preds'], )
+
+        return results
+
+    def add_pred_to_datasample(self, data_samples: SampleList,
+                               results_list: List[PixelData]) -> SampleList:
+        """Add predictions to `DetDataSample`.
+
+        Args:
+            data_samples (list[:obj:`DetDataSample`]): The
+                annotation data of every samples.
+            results_list (List[PixelData]): Panoptic segmentation results of
+                each image.
+
+        Returns:
+            List[:obj:`DetDataSample`]: Return the packed panoptic segmentation
+                results of input images. Each DetDataSample usually contains
+                'pred_panoptic_seg'. And the 'pred_panoptic_seg' has a key
+                ``sem_seg``, which is a tensor of shape (1, h, w).
+        """
+
+        for data_sample, pred_panoptic_seg in zip(data_samples, results_list):
+            data_sample.pred_panoptic_seg = pred_panoptic_seg
+        return data_samples
diff --git a/mmdetection/mmdet/models/detectors/point_rend.py b/mmdetection/mmdet/models/detectors/point_rend.py
new file mode 100644
index 00000000..5062ac0c
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/point_rend.py
@@ -0,0 +1,35 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.config import ConfigDict
+
+from mmdet.registry import MODELS
+from mmdet.utils import OptConfigType, OptMultiConfig
+from .two_stage import TwoStageDetector
+
+
+@MODELS.register_module()
+class PointRend(TwoStageDetector):
+    """PointRend: Image Segmentation as Rendering
+
+    This detector is the implementation of
+    `PointRend `_.
+
+    """
+
+    def __init__(self,
+                 backbone: ConfigDict,
+                 rpn_head: ConfigDict,
+                 roi_head: ConfigDict,
+                 train_cfg: ConfigDict,
+                 test_cfg: ConfigDict,
+                 neck: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            rpn_head=rpn_head,
+            roi_head=roi_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            init_cfg=init_cfg,
+            data_preprocessor=data_preprocessor)
diff --git a/mmdetection/mmdet/models/detectors/queryinst.py b/mmdetection/mmdet/models/detectors/queryinst.py
new file mode 100644
index 00000000..400ce20c
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/queryinst.py
@@ -0,0 +1,29 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .sparse_rcnn import SparseRCNN
+
+
+@MODELS.register_module()
+class QueryInst(SparseRCNN):
+    r"""Implementation of
+    `Instances as Queries `_"""
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 rpn_head: ConfigType,
+                 roi_head: ConfigType,
+                 train_cfg: ConfigType,
+                 test_cfg: ConfigType,
+                 neck: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            rpn_head=rpn_head,
+            roi_head=roi_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/reppoints_detector.py b/mmdetection/mmdet/models/detectors/reppoints_detector.py
new file mode 100644
index 00000000..d86cec2e
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/reppoints_detector.py
@@ -0,0 +1,30 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage import SingleStageDetector
+
+
+@MODELS.register_module()
+class RepPointsDetector(SingleStageDetector):
+    """RepPoints: Point Set Representation for Object Detection.
+
+        This detector is the implementation of:
+        - RepPoints detector (https://arxiv.org/pdf/1904.11490)
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None):
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/retinanet.py b/mmdetection/mmdet/models/detectors/retinanet.py
new file mode 100644
index 00000000..03e3cb20
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/retinanet.py
@@ -0,0 +1,26 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage import SingleStageDetector
+
+
+@MODELS.register_module()
+class RetinaNet(SingleStageDetector):
+    """Implementation of `RetinaNet `_"""
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/rpn.py b/mmdetection/mmdet/models/detectors/rpn.py
new file mode 100644
index 00000000..72fe8521
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/rpn.py
@@ -0,0 +1,81 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import warnings
+
+import torch
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage import SingleStageDetector
+
+
+@MODELS.register_module()
+class RPN(SingleStageDetector):
+    """Implementation of Region Proposal Network.
+
+    Args:
+        backbone (:obj:`ConfigDict` or dict): The backbone config.
+        neck (:obj:`ConfigDict` or dict): The neck config.
+        bbox_head (:obj:`ConfigDict` or dict): The bbox head config.
+        train_cfg (:obj:`ConfigDict` or dict, optional): The training config.
+        test_cfg (:obj:`ConfigDict` or dict, optional): The testing config.
+        data_preprocessor (:obj:`ConfigDict` or dict, optional): Config of
+            :class:`DetDataPreprocessor` to process the input data.
+            Defaults to None.
+        init_cfg (:obj:`ConfigDict` or list[:obj:`ConfigDict`] or dict or
+            list[dict], optional): Initialization config dict.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 rpn_head: ConfigType,
+                 train_cfg: ConfigType,
+                 test_cfg: ConfigType,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None,
+                 **kwargs) -> None:
+        super(SingleStageDetector, self).__init__(
+            data_preprocessor=data_preprocessor, init_cfg=init_cfg)
+        self.backbone = MODELS.build(backbone)
+        self.neck = MODELS.build(neck) if neck is not None else None
+        rpn_train_cfg = train_cfg['rpn'] if train_cfg is not None else None
+        rpn_head_num_classes = rpn_head.get('num_classes', 1)
+        if rpn_head_num_classes != 1:
+            warnings.warn('The `num_classes` should be 1 in RPN, but get '
+                          f'{rpn_head_num_classes}, please set '
+                          'rpn_head.num_classes = 1 in your config file.')
+            rpn_head.update(num_classes=1)
+        rpn_head.update(train_cfg=rpn_train_cfg)
+        rpn_head.update(test_cfg=test_cfg['rpn'])
+        self.bbox_head = MODELS.build(rpn_head)
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+
+    def loss(self, batch_inputs: Tensor,
+             batch_data_samples: SampleList) -> dict:
+        """Calculate losses from a batch of inputs and data samples.
+
+        Args:
+            batch_inputs (Tensor): Input images of shape (N, C, H, W).
+                These should usually be mean centered and std scaled.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        x = self.extract_feat(batch_inputs)
+
+        # set cat_id of gt_labels to 0 in RPN
+        rpn_data_samples = copy.deepcopy(batch_data_samples)
+        for data_sample in rpn_data_samples:
+            data_sample.gt_instances.labels = \
+                torch.zeros_like(data_sample.gt_instances.labels)
+
+        losses = self.bbox_head.loss(x, rpn_data_samples)
+        return losses
diff --git a/mmdetection/mmdet/models/detectors/rtmdet.py b/mmdetection/mmdet/models/detectors/rtmdet.py
new file mode 100644
index 00000000..b43e053f
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/rtmdet.py
@@ -0,0 +1,52 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from mmengine.dist import get_world_size
+from mmengine.logging import print_log
+
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage import SingleStageDetector
+
+
+@MODELS.register_module()
+class RTMDet(SingleStageDetector):
+    """Implementation of RTMDet.
+
+    Args:
+        backbone (:obj:`ConfigDict` or dict): The backbone module.
+        neck (:obj:`ConfigDict` or dict): The neck module.
+        bbox_head (:obj:`ConfigDict` or dict): The bbox head module.
+        train_cfg (:obj:`ConfigDict` or dict, optional): The training config
+            of ATSS. Defaults to None.
+        test_cfg (:obj:`ConfigDict` or dict, optional): The testing config
+            of ATSS. Defaults to None.
+        data_preprocessor (:obj:`ConfigDict` or dict, optional): Config of
+            :class:`DetDataPreprocessor` to process the input data.
+            Defaults to None.
+        init_cfg (:obj:`ConfigDict` or dict, optional): the config to control
+            the initialization. Defaults to None.
+        use_syncbn (bool): Whether to use SyncBatchNorm. Defaults to True.
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None,
+                 use_syncbn: bool = True) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
+
+        # TODO: Waiting for mmengine support
+        if use_syncbn and get_world_size() > 1:
+            torch.nn.SyncBatchNorm.convert_sync_batchnorm(self)
+            print_log('Using SyncBatchNorm()', 'current')
diff --git a/mmdetection/mmdet/models/detectors/scnet.py b/mmdetection/mmdet/models/detectors/scnet.py
new file mode 100644
index 00000000..606a0203
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/scnet.py
@@ -0,0 +1,11 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from .cascade_rcnn import CascadeRCNN
+
+
+@MODELS.register_module()
+class SCNet(CascadeRCNN):
+    """Implementation of `SCNet `_"""
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
diff --git a/mmdetection/mmdet/models/detectors/semi_base.py b/mmdetection/mmdet/models/detectors/semi_base.py
new file mode 100644
index 00000000..f3f0c8c0
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/semi_base.py
@@ -0,0 +1,266 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+from typing import Dict, List, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+from torch import Tensor
+
+from mmdet.models.utils import (filter_gt_instances, rename_loss_dict,
+                                reweight_loss_dict)
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.structures.bbox import bbox_project
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .base import BaseDetector
+
+
+@MODELS.register_module()
+class SemiBaseDetector(BaseDetector):
+    """Base class for semi-supervised detectors.
+
+    Semi-supervised detectors typically consisting of a teacher model
+    updated by exponential moving average and a student model updated
+    by gradient descent.
+
+    Args:
+        detector (:obj:`ConfigDict` or dict): The detector config.
+        semi_train_cfg (:obj:`ConfigDict` or dict, optional):
+            The semi-supervised training config.
+        semi_test_cfg (:obj:`ConfigDict` or dict, optional):
+            The semi-supervised testing config.
+        data_preprocessor (:obj:`ConfigDict` or dict, optional): Config of
+            :class:`DetDataPreprocessor` to process the input data.
+            Defaults to None.
+        init_cfg (:obj:`ConfigDict` or list[:obj:`ConfigDict`] or dict or
+            list[dict], optional): Initialization config dict.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 detector: ConfigType,
+                 semi_train_cfg: OptConfigType = None,
+                 semi_test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            data_preprocessor=data_preprocessor, init_cfg=init_cfg)
+        self.student = MODELS.build(detector)
+        self.teacher = MODELS.build(detector)
+        self.semi_train_cfg = semi_train_cfg
+        self.semi_test_cfg = semi_test_cfg
+        if self.semi_train_cfg.get('freeze_teacher', True) is True:
+            self.freeze(self.teacher)
+
+    @staticmethod
+    def freeze(model: nn.Module):
+        """Freeze the model."""
+        model.eval()
+        for param in model.parameters():
+            param.requires_grad = False
+
+    def loss(self, multi_batch_inputs: Dict[str, Tensor],
+             multi_batch_data_samples: Dict[str, SampleList]) -> dict:
+        """Calculate losses from multi-branch inputs and data samples.
+
+        Args:
+            multi_batch_inputs (Dict[str, Tensor]): The dict of multi-branch
+                input images, each value with shape (N, C, H, W).
+                Each value should usually be mean centered and std scaled.
+            multi_batch_data_samples (Dict[str, List[:obj:`DetDataSample`]]):
+                The dict of multi-branch data samples.
+
+        Returns:
+            dict: A dictionary of loss components
+        """
+        losses = dict()
+        losses.update(**self.loss_by_gt_instances(
+            multi_batch_inputs['sup'], multi_batch_data_samples['sup']))
+
+        origin_pseudo_data_samples, batch_info = self.get_pseudo_instances(
+            multi_batch_inputs['unsup_teacher'],
+            multi_batch_data_samples['unsup_teacher'])
+        multi_batch_data_samples[
+            'unsup_student'] = self.project_pseudo_instances(
+                origin_pseudo_data_samples,
+                multi_batch_data_samples['unsup_student'])
+        losses.update(**self.loss_by_pseudo_instances(
+            multi_batch_inputs['unsup_student'],
+            multi_batch_data_samples['unsup_student'], batch_info))
+        return losses
+
+    def loss_by_gt_instances(self, batch_inputs: Tensor,
+                             batch_data_samples: SampleList) -> dict:
+        """Calculate losses from a batch of inputs and ground-truth data
+        samples.
+
+        Args:
+            batch_inputs (Tensor): Input images of shape (N, C, H, W).
+                These should usually be mean centered and std scaled.
+            batch_data_samples (List[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            dict: A dictionary of loss components
+        """
+
+        losses = self.student.loss(batch_inputs, batch_data_samples)
+        sup_weight = self.semi_train_cfg.get('sup_weight', 1.)
+        return rename_loss_dict('sup_', reweight_loss_dict(losses, sup_weight))
+
+    def loss_by_pseudo_instances(self,
+                                 batch_inputs: Tensor,
+                                 batch_data_samples: SampleList,
+                                 batch_info: Optional[dict] = None) -> dict:
+        """Calculate losses from a batch of inputs and pseudo data samples.
+
+        Args:
+            batch_inputs (Tensor): Input images of shape (N, C, H, W).
+                These should usually be mean centered and std scaled.
+            batch_data_samples (List[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`,
+                which are `pseudo_instance` or `pseudo_panoptic_seg`
+                or `pseudo_sem_seg` in fact.
+            batch_info (dict): Batch information of teacher model
+                forward propagation process. Defaults to None.
+
+        Returns:
+            dict: A dictionary of loss components
+        """
+        batch_data_samples = filter_gt_instances(
+            batch_data_samples, score_thr=self.semi_train_cfg.cls_pseudo_thr)
+        losses = self.student.loss(batch_inputs, batch_data_samples)
+        pseudo_instances_num = sum([
+            len(data_samples.gt_instances)
+            for data_samples in batch_data_samples
+        ])
+        unsup_weight = self.semi_train_cfg.get(
+            'unsup_weight', 1.) if pseudo_instances_num > 0 else 0.
+        return rename_loss_dict('unsup_',
+                                reweight_loss_dict(losses, unsup_weight))
+
+    @torch.no_grad()
+    def get_pseudo_instances(
+            self, batch_inputs: Tensor, batch_data_samples: SampleList
+    ) -> Tuple[SampleList, Optional[dict]]:
+        """Get pseudo instances from teacher model."""
+        self.teacher.eval()
+        results_list = self.teacher.predict(
+            batch_inputs, batch_data_samples, rescale=False)
+        batch_info = {}
+        for data_samples, results in zip(batch_data_samples, results_list):
+            data_samples.gt_instances = results.pred_instances
+            data_samples.gt_instances.bboxes = bbox_project(
+                data_samples.gt_instances.bboxes,
+                torch.from_numpy(data_samples.homography_matrix).inverse().to(
+                    self.data_preprocessor.device), data_samples.ori_shape)
+        return batch_data_samples, batch_info
+
+    def project_pseudo_instances(self, batch_pseudo_instances: SampleList,
+                                 batch_data_samples: SampleList) -> SampleList:
+        """Project pseudo instances."""
+        for pseudo_instances, data_samples in zip(batch_pseudo_instances,
+                                                  batch_data_samples):
+            data_samples.gt_instances = copy.deepcopy(
+                pseudo_instances.gt_instances)
+            data_samples.gt_instances.bboxes = bbox_project(
+                data_samples.gt_instances.bboxes,
+                torch.tensor(data_samples.homography_matrix).to(
+                    self.data_preprocessor.device), data_samples.img_shape)
+        wh_thr = self.semi_train_cfg.get('min_pseudo_bbox_wh', (1e-2, 1e-2))
+        return filter_gt_instances(batch_data_samples, wh_thr=wh_thr)
+
+    def predict(self, batch_inputs: Tensor,
+                batch_data_samples: SampleList) -> SampleList:
+        """Predict results from a batch of inputs and data samples with post-
+        processing.
+
+        Args:
+            batch_inputs (Tensor): Inputs with shape (N, C, H, W).
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            rescale (bool): Whether to rescale the results.
+                Defaults to True.
+
+        Returns:
+            list[:obj:`DetDataSample`]: Return the detection results of the
+            input images. The returns value is DetDataSample,
+            which usually contain 'pred_instances'. And the
+            ``pred_instances`` usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                    (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                    (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                    the last dimension 4 arrange as (x1, y1, x2, y2).
+                - masks (Tensor): Has a shape (num_instances, H, W).
+        """
+        if self.semi_test_cfg.get('predict_on', 'teacher') == 'teacher':
+            return self.teacher(
+                batch_inputs, batch_data_samples, mode='predict')
+        else:
+            return self.student(
+                batch_inputs, batch_data_samples, mode='predict')
+
+    def _forward(self, batch_inputs: Tensor,
+                 batch_data_samples: SampleList) -> SampleList:
+        """Network forward process. Usually includes backbone, neck and head
+        forward without any post-processing.
+
+        Args:
+            batch_inputs (Tensor): Inputs with shape (N, C, H, W).
+
+        Returns:
+            tuple: A tuple of features from ``rpn_head`` and ``roi_head``
+            forward.
+        """
+        if self.semi_test_cfg.get('forward_on', 'teacher') == 'teacher':
+            return self.teacher(
+                batch_inputs, batch_data_samples, mode='tensor')
+        else:
+            return self.student(
+                batch_inputs, batch_data_samples, mode='tensor')
+
+    def extract_feat(self, batch_inputs: Tensor) -> Tuple[Tensor]:
+        """Extract features.
+
+        Args:
+            batch_inputs (Tensor): Image tensor with shape (N, C, H ,W).
+
+        Returns:
+            tuple[Tensor]: Multi-level features that may have
+            different resolutions.
+        """
+        if self.semi_test_cfg.get('extract_feat_on', 'teacher') == 'teacher':
+            return self.teacher.extract_feat(batch_inputs)
+        else:
+            return self.student.extract_feat(batch_inputs)
+
+    def _load_from_state_dict(self, state_dict: dict, prefix: str,
+                              local_metadata: dict, strict: bool,
+                              missing_keys: Union[List[str], str],
+                              unexpected_keys: Union[List[str], str],
+                              error_msgs: Union[List[str], str]) -> None:
+        """Add teacher and student prefixes to model parameter names."""
+        if not any([
+                'student' in key or 'teacher' in key
+                for key in state_dict.keys()
+        ]):
+            keys = list(state_dict.keys())
+            state_dict.update({'teacher.' + k: state_dict[k] for k in keys})
+            state_dict.update({'student.' + k: state_dict[k] for k in keys})
+            for k in keys:
+                state_dict.pop(k)
+        return super()._load_from_state_dict(
+            state_dict,
+            prefix,
+            local_metadata,
+            strict,
+            missing_keys,
+            unexpected_keys,
+            error_msgs,
+        )
diff --git a/mmdetection/mmdet/models/detectors/single_stage.py b/mmdetection/mmdet/models/detectors/single_stage.py
new file mode 100644
index 00000000..06c07408
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/single_stage.py
@@ -0,0 +1,149 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple, Union
+
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import OptSampleList, SampleList
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .base import BaseDetector
+
+
+@MODELS.register_module()
+class SingleStageDetector(BaseDetector):
+    """Base class for single-stage detectors.
+
+    Single-stage detectors directly and densely predict bounding boxes on the
+    output features of the backbone+neck.
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: OptConfigType = None,
+                 bbox_head: OptConfigType = None,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            data_preprocessor=data_preprocessor, init_cfg=init_cfg)
+        self.backbone = MODELS.build(backbone)
+        if neck is not None:
+            self.neck = MODELS.build(neck)
+        bbox_head.update(train_cfg=train_cfg)
+        bbox_head.update(test_cfg=test_cfg)
+        self.bbox_head = MODELS.build(bbox_head)
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+
+    def _load_from_state_dict(self, state_dict: dict, prefix: str,
+                              local_metadata: dict, strict: bool,
+                              missing_keys: Union[List[str], str],
+                              unexpected_keys: Union[List[str], str],
+                              error_msgs: Union[List[str], str]) -> None:
+        """Exchange bbox_head key to rpn_head key when loading two-stage
+        weights into single-stage model."""
+        bbox_head_prefix = prefix + '.bbox_head' if prefix else 'bbox_head'
+        bbox_head_keys = [
+            k for k in state_dict.keys() if k.startswith(bbox_head_prefix)
+        ]
+        rpn_head_prefix = prefix + '.rpn_head' if prefix else 'rpn_head'
+        rpn_head_keys = [
+            k for k in state_dict.keys() if k.startswith(rpn_head_prefix)
+        ]
+        if len(bbox_head_keys) == 0 and len(rpn_head_keys) != 0:
+            for rpn_head_key in rpn_head_keys:
+                bbox_head_key = bbox_head_prefix + \
+                                rpn_head_key[len(rpn_head_prefix):]
+                state_dict[bbox_head_key] = state_dict.pop(rpn_head_key)
+        super()._load_from_state_dict(state_dict, prefix, local_metadata,
+                                      strict, missing_keys, unexpected_keys,
+                                      error_msgs)
+
+    def loss(self, batch_inputs: Tensor,
+             batch_data_samples: SampleList) -> Union[dict, list]:
+        """Calculate losses from a batch of inputs and data samples.
+
+        Args:
+            batch_inputs (Tensor): Input images of shape (N, C, H, W).
+                These should usually be mean centered and std scaled.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        x = self.extract_feat(batch_inputs)
+        losses = self.bbox_head.loss(x, batch_data_samples)
+        return losses
+
+    def predict(self,
+                batch_inputs: Tensor,
+                batch_data_samples: SampleList,
+                rescale: bool = True) -> SampleList:
+        """Predict results from a batch of inputs and data samples with post-
+        processing.
+
+        Args:
+            batch_inputs (Tensor): Inputs with shape (N, C, H, W).
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            rescale (bool): Whether to rescale the results.
+                Defaults to True.
+
+        Returns:
+            list[:obj:`DetDataSample`]: Detection results of the
+            input images. Each DetDataSample usually contain
+            'pred_instances'. And the ``pred_instances`` usually
+            contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                    (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                    (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                    the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        x = self.extract_feat(batch_inputs)
+        results_list = self.bbox_head.predict(
+            x, batch_data_samples, rescale=rescale)
+        batch_data_samples = self.add_pred_to_datasample(
+            batch_data_samples, results_list)
+        return batch_data_samples
+
+    def _forward(
+            self,
+            batch_inputs: Tensor,
+            batch_data_samples: OptSampleList = None) -> Tuple[List[Tensor]]:
+        """Network forward process. Usually includes backbone, neck and head
+        forward without any post-processing.
+
+         Args:
+            batch_inputs (Tensor): Inputs with shape (N, C, H, W).
+            batch_data_samples (list[:obj:`DetDataSample`]): Each item contains
+                the meta information of each image and corresponding
+                annotations.
+
+        Returns:
+            tuple[list]: A tuple of features from ``bbox_head`` forward.
+        """
+        x = self.extract_feat(batch_inputs)
+        results = self.bbox_head.forward(x)
+        return results
+
+    def extract_feat(self, batch_inputs: Tensor) -> Tuple[Tensor]:
+        """Extract features.
+
+        Args:
+            batch_inputs (Tensor): Image tensor with shape (N, C, H ,W).
+
+        Returns:
+            tuple[Tensor]: Multi-level features that may have
+            different resolutions.
+        """
+        x = self.backbone(batch_inputs)
+        if self.with_neck:
+            x = self.neck(x)
+        return x
diff --git a/mmdetection/mmdet/models/detectors/single_stage_instance_seg.py b/mmdetection/mmdet/models/detectors/single_stage_instance_seg.py
new file mode 100644
index 00000000..acb5f0d2
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/single_stage_instance_seg.py
@@ -0,0 +1,180 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+from typing import Tuple
+
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import OptSampleList, SampleList
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .base import BaseDetector
+
+INF = 1e8
+
+
+@MODELS.register_module()
+class SingleStageInstanceSegmentor(BaseDetector):
+    """Base class for single-stage instance segmentors."""
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: OptConfigType = None,
+                 bbox_head: OptConfigType = None,
+                 mask_head: OptConfigType = None,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            data_preprocessor=data_preprocessor, init_cfg=init_cfg)
+        self.backbone = MODELS.build(backbone)
+        if neck is not None:
+            self.neck = MODELS.build(neck)
+        else:
+            self.neck = None
+        if bbox_head is not None:
+            bbox_head.update(train_cfg=copy.deepcopy(train_cfg))
+            bbox_head.update(test_cfg=copy.deepcopy(test_cfg))
+            self.bbox_head = MODELS.build(bbox_head)
+        else:
+            self.bbox_head = None
+
+        assert mask_head, f'`mask_head` must ' \
+                          f'be implemented in {self.__class__.__name__}'
+        mask_head.update(train_cfg=copy.deepcopy(train_cfg))
+        mask_head.update(test_cfg=copy.deepcopy(test_cfg))
+        self.mask_head = MODELS.build(mask_head)
+
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+
+    def extract_feat(self, batch_inputs: Tensor) -> Tuple[Tensor]:
+        """Extract features.
+
+        Args:
+            batch_inputs (Tensor): Image tensor with shape (N, C, H ,W).
+
+        Returns:
+            tuple[Tensor]: Multi-level features that may have different
+            resolutions.
+        """
+        x = self.backbone(batch_inputs)
+        if self.with_neck:
+            x = self.neck(x)
+        return x
+
+    def _forward(self,
+                 batch_inputs: Tensor,
+                 batch_data_samples: OptSampleList = None,
+                 **kwargs) -> tuple:
+        """Network forward process. Usually includes backbone, neck and head
+        forward without any post-processing.
+
+         Args:
+            batch_inputs (Tensor): Inputs with shape (N, C, H, W).
+
+        Returns:
+            tuple: A tuple of features from ``bbox_head`` forward.
+        """
+        outs = ()
+        # backbone
+        x = self.extract_feat(batch_inputs)
+        # bbox_head
+        positive_infos = None
+        if self.with_bbox:
+            assert batch_data_samples is not None
+            bbox_outs = self.bbox_head.forward(x)
+            outs = outs + (bbox_outs, )
+            # It is necessary to use `bbox_head.loss` to update
+            # `_raw_positive_infos` which will be used in `get_positive_infos`
+            # positive_infos will be used in the following mask head.
+            _ = self.bbox_head.loss(x, batch_data_samples, **kwargs)
+            positive_infos = self.bbox_head.get_positive_infos()
+        # mask_head
+        if positive_infos is None:
+            mask_outs = self.mask_head.forward(x)
+        else:
+            mask_outs = self.mask_head.forward(x, positive_infos)
+        outs = outs + (mask_outs, )
+        return outs
+
+    def loss(self, batch_inputs: Tensor, batch_data_samples: SampleList,
+             **kwargs) -> dict:
+        """
+        Args:
+            batch_inputs (Tensor): Input images of shape (N, C, H, W).
+                These should usually be mean centered and std scaled.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        x = self.extract_feat(batch_inputs)
+        losses = dict()
+
+        positive_infos = None
+        # CondInst and YOLACT have bbox_head
+        if self.with_bbox:
+            bbox_losses = self.bbox_head.loss(x, batch_data_samples, **kwargs)
+            losses.update(bbox_losses)
+            # get positive information from bbox head, which will be used
+            # in the following mask head.
+            positive_infos = self.bbox_head.get_positive_infos()
+
+        mask_loss = self.mask_head.loss(
+            x, batch_data_samples, positive_infos=positive_infos, **kwargs)
+        # avoid loss override
+        assert not set(mask_loss.keys()) & set(losses.keys())
+
+        losses.update(mask_loss)
+        return losses
+
+    def predict(self,
+                batch_inputs: Tensor,
+                batch_data_samples: SampleList,
+                rescale: bool = True,
+                **kwargs) -> SampleList:
+        """Perform forward propagation of the mask head and predict mask
+        results on the features of the upstream network.
+
+        Args:
+            batch_inputs (Tensor): Inputs with shape (N, C, H, W).
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            rescale (bool): Whether to rescale the results.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`DetDataSample`]: Detection results of the
+            input images. Each DetDataSample usually contain
+            'pred_instances'. And the ``pred_instances`` usually
+            contains following keys.
+
+            - scores (Tensor): Classification scores, has a shape
+                (num_instance, )
+            - labels (Tensor): Labels of bboxes, has a shape
+                (num_instances, ).
+            - bboxes (Tensor): Has a shape (num_instances, 4),
+                the last dimension 4 arrange as (x1, y1, x2, y2).
+            - masks (Tensor): Has a shape (num_instances, H, W).
+        """
+        x = self.extract_feat(batch_inputs)
+        if self.with_bbox:
+            # the bbox branch does not need to be scaled to the original
+            # image scale, because the mask branch will scale both bbox
+            # and mask at the same time.
+            bbox_rescale = rescale if not self.with_mask else False
+            results_list = self.bbox_head.predict(
+                x, batch_data_samples, rescale=bbox_rescale)
+        else:
+            results_list = None
+
+        results_list = self.mask_head.predict(
+            x, batch_data_samples, rescale=rescale, results_list=results_list)
+
+        batch_data_samples = self.add_pred_to_datasample(
+            batch_data_samples, results_list)
+        return batch_data_samples
diff --git a/mmdetection/mmdet/models/detectors/soft_teacher.py b/mmdetection/mmdet/models/detectors/soft_teacher.py
new file mode 100644
index 00000000..80853f1d
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/soft_teacher.py
@@ -0,0 +1,378 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+from typing import List, Optional, Tuple
+
+import torch
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.models.utils import (filter_gt_instances, rename_loss_dict,
+                                reweight_loss_dict)
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.structures.bbox import bbox2roi, bbox_project
+from mmdet.utils import ConfigType, InstanceList, OptConfigType, OptMultiConfig
+from ..utils.misc import unpack_gt_instances
+from .semi_base import SemiBaseDetector
+
+
+@MODELS.register_module()
+class SoftTeacher(SemiBaseDetector):
+    r"""Implementation of `End-to-End Semi-Supervised Object Detection
+    with Soft Teacher `_
+
+    Args:
+        detector (:obj:`ConfigDict` or dict): The detector config.
+        semi_train_cfg (:obj:`ConfigDict` or dict, optional):
+            The semi-supervised training config.
+        semi_test_cfg (:obj:`ConfigDict` or dict, optional):
+            The semi-supervised testing config.
+        data_preprocessor (:obj:`ConfigDict` or dict, optional): Config of
+            :class:`DetDataPreprocessor` to process the input data.
+            Defaults to None.
+        init_cfg (:obj:`ConfigDict` or list[:obj:`ConfigDict`] or dict or
+            list[dict], optional): Initialization config dict.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 detector: ConfigType,
+                 semi_train_cfg: OptConfigType = None,
+                 semi_test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            detector=detector,
+            semi_train_cfg=semi_train_cfg,
+            semi_test_cfg=semi_test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
+
+    def loss_by_pseudo_instances(self,
+                                 batch_inputs: Tensor,
+                                 batch_data_samples: SampleList,
+                                 batch_info: Optional[dict] = None) -> dict:
+        """Calculate losses from a batch of inputs and pseudo data samples.
+
+        Args:
+            batch_inputs (Tensor): Input images of shape (N, C, H, W).
+                These should usually be mean centered and std scaled.
+            batch_data_samples (List[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`,
+                which are `pseudo_instance` or `pseudo_panoptic_seg`
+                or `pseudo_sem_seg` in fact.
+            batch_info (dict): Batch information of teacher model
+                forward propagation process. Defaults to None.
+
+        Returns:
+            dict: A dictionary of loss components
+        """
+
+        x = self.student.extract_feat(batch_inputs)
+
+        losses = {}
+        rpn_losses, rpn_results_list = self.rpn_loss_by_pseudo_instances(
+            x, batch_data_samples)
+        losses.update(**rpn_losses)
+        losses.update(**self.rcnn_cls_loss_by_pseudo_instances(
+            x, rpn_results_list, batch_data_samples, batch_info))
+        losses.update(**self.rcnn_reg_loss_by_pseudo_instances(
+            x, rpn_results_list, batch_data_samples))
+        unsup_weight = self.semi_train_cfg.get('unsup_weight', 1.)
+        return rename_loss_dict('unsup_',
+                                reweight_loss_dict(losses, unsup_weight))
+
+    @torch.no_grad()
+    def get_pseudo_instances(
+            self, batch_inputs: Tensor, batch_data_samples: SampleList
+    ) -> Tuple[SampleList, Optional[dict]]:
+        """Get pseudo instances from teacher model."""
+        assert self.teacher.with_bbox, 'Bbox head must be implemented.'
+        x = self.teacher.extract_feat(batch_inputs)
+
+        # If there are no pre-defined proposals, use RPN to get proposals
+        if batch_data_samples[0].get('proposals', None) is None:
+            rpn_results_list = self.teacher.rpn_head.predict(
+                x, batch_data_samples, rescale=False)
+        else:
+            rpn_results_list = [
+                data_sample.proposals for data_sample in batch_data_samples
+            ]
+
+        results_list = self.teacher.roi_head.predict(
+            x, rpn_results_list, batch_data_samples, rescale=False)
+
+        for data_samples, results in zip(batch_data_samples, results_list):
+            data_samples.gt_instances = results
+
+        batch_data_samples = filter_gt_instances(
+            batch_data_samples,
+            score_thr=self.semi_train_cfg.pseudo_label_initial_score_thr)
+
+        reg_uncs_list = self.compute_uncertainty_with_aug(
+            x, batch_data_samples)
+
+        for data_samples, reg_uncs in zip(batch_data_samples, reg_uncs_list):
+            data_samples.gt_instances['reg_uncs'] = reg_uncs
+            data_samples.gt_instances.bboxes = bbox_project(
+                data_samples.gt_instances.bboxes,
+                torch.from_numpy(data_samples.homography_matrix).inverse().to(
+                    self.data_preprocessor.device), data_samples.ori_shape)
+
+        batch_info = {
+            'feat': x,
+            'img_shape': [],
+            'homography_matrix': [],
+            'metainfo': []
+        }
+        for data_samples in batch_data_samples:
+            batch_info['img_shape'].append(data_samples.img_shape)
+            batch_info['homography_matrix'].append(
+                torch.from_numpy(data_samples.homography_matrix).to(
+                    self.data_preprocessor.device))
+            batch_info['metainfo'].append(data_samples.metainfo)
+        return batch_data_samples, batch_info
+
+    def rpn_loss_by_pseudo_instances(self, x: Tuple[Tensor],
+                                     batch_data_samples: SampleList) -> dict:
+        """Calculate rpn loss from a batch of inputs and pseudo data samples.
+
+        Args:
+            x (tuple[Tensor]): Features from FPN.
+            batch_data_samples (List[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`,
+                which are `pseudo_instance` or `pseudo_panoptic_seg`
+                or `pseudo_sem_seg` in fact.
+        Returns:
+            dict: A dictionary of rpn loss components
+        """
+
+        rpn_data_samples = copy.deepcopy(batch_data_samples)
+        rpn_data_samples = filter_gt_instances(
+            rpn_data_samples, score_thr=self.semi_train_cfg.rpn_pseudo_thr)
+        proposal_cfg = self.student.train_cfg.get('rpn_proposal',
+                                                  self.student.test_cfg.rpn)
+        # set cat_id of gt_labels to 0 in RPN
+        for data_sample in rpn_data_samples:
+            data_sample.gt_instances.labels = \
+                torch.zeros_like(data_sample.gt_instances.labels)
+
+        rpn_losses, rpn_results_list = self.student.rpn_head.loss_and_predict(
+            x, rpn_data_samples, proposal_cfg=proposal_cfg)
+        for key in rpn_losses.keys():
+            if 'loss' in key and 'rpn' not in key:
+                rpn_losses[f'rpn_{key}'] = rpn_losses.pop(key)
+        return rpn_losses, rpn_results_list
+
+    def rcnn_cls_loss_by_pseudo_instances(self, x: Tuple[Tensor],
+                                          unsup_rpn_results_list: InstanceList,
+                                          batch_data_samples: SampleList,
+                                          batch_info: dict) -> dict:
+        """Calculate classification loss from a batch of inputs and pseudo data
+        samples.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            unsup_rpn_results_list (list[:obj:`InstanceData`]):
+                List of region proposals.
+            batch_data_samples (List[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`,
+                which are `pseudo_instance` or `pseudo_panoptic_seg`
+                or `pseudo_sem_seg` in fact.
+            batch_info (dict): Batch information of teacher model
+                forward propagation process.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of rcnn
+                classification loss components
+        """
+        rpn_results_list = copy.deepcopy(unsup_rpn_results_list)
+        cls_data_samples = copy.deepcopy(batch_data_samples)
+        cls_data_samples = filter_gt_instances(
+            cls_data_samples, score_thr=self.semi_train_cfg.cls_pseudo_thr)
+
+        outputs = unpack_gt_instances(cls_data_samples)
+        batch_gt_instances, batch_gt_instances_ignore, _ = outputs
+
+        # assign gts and sample proposals
+        num_imgs = len(cls_data_samples)
+        sampling_results = []
+        for i in range(num_imgs):
+            # rename rpn_results.bboxes to rpn_results.priors
+            rpn_results = rpn_results_list[i]
+            rpn_results.priors = rpn_results.pop('bboxes')
+            assign_result = self.student.roi_head.bbox_assigner.assign(
+                rpn_results, batch_gt_instances[i],
+                batch_gt_instances_ignore[i])
+            sampling_result = self.student.roi_head.bbox_sampler.sample(
+                assign_result,
+                rpn_results,
+                batch_gt_instances[i],
+                feats=[lvl_feat[i][None] for lvl_feat in x])
+            sampling_results.append(sampling_result)
+
+        selected_bboxes = [res.priors for res in sampling_results]
+        rois = bbox2roi(selected_bboxes)
+        bbox_results = self.student.roi_head._bbox_forward(x, rois)
+        # cls_reg_targets is a tuple of labels, label_weights,
+        # and bbox_targets, bbox_weights
+        cls_reg_targets = self.student.roi_head.bbox_head.get_targets(
+            sampling_results, self.student.train_cfg.rcnn)
+
+        selected_results_list = []
+        for bboxes, data_samples, teacher_matrix, teacher_img_shape in zip(
+                selected_bboxes, batch_data_samples,
+                batch_info['homography_matrix'], batch_info['img_shape']):
+            student_matrix = torch.tensor(
+                data_samples.homography_matrix, device=teacher_matrix.device)
+            homography_matrix = teacher_matrix @ student_matrix.inverse()
+            projected_bboxes = bbox_project(bboxes, homography_matrix,
+                                            teacher_img_shape)
+            selected_results_list.append(InstanceData(bboxes=projected_bboxes))
+
+        with torch.no_grad():
+            results_list = self.teacher.roi_head.predict_bbox(
+                batch_info['feat'],
+                batch_info['metainfo'],
+                selected_results_list,
+                rcnn_test_cfg=None,
+                rescale=False)
+            bg_score = torch.cat(
+                [results.scores[:, -1] for results in results_list])
+            # cls_reg_targets[0] is labels
+            neg_inds = cls_reg_targets[
+                0] == self.student.roi_head.bbox_head.num_classes
+            # cls_reg_targets[1] is label_weights
+            cls_reg_targets[1][neg_inds] = bg_score[neg_inds].detach()
+
+        losses = self.student.roi_head.bbox_head.loss(
+            bbox_results['cls_score'], bbox_results['bbox_pred'], rois,
+            *cls_reg_targets)
+        # cls_reg_targets[1] is label_weights
+        losses['loss_cls'] = losses['loss_cls'] * len(
+            cls_reg_targets[1]) / max(sum(cls_reg_targets[1]), 1.0)
+        return losses
+
+    def rcnn_reg_loss_by_pseudo_instances(
+            self, x: Tuple[Tensor], unsup_rpn_results_list: InstanceList,
+            batch_data_samples: SampleList) -> dict:
+        """Calculate rcnn regression loss from a batch of inputs and pseudo
+        data samples.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            unsup_rpn_results_list (list[:obj:`InstanceData`]):
+                List of region proposals.
+            batch_data_samples (List[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`,
+                which are `pseudo_instance` or `pseudo_panoptic_seg`
+                or `pseudo_sem_seg` in fact.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of rcnn
+                regression loss components
+        """
+        rpn_results_list = copy.deepcopy(unsup_rpn_results_list)
+        reg_data_samples = copy.deepcopy(batch_data_samples)
+        for data_samples in reg_data_samples:
+            if data_samples.gt_instances.bboxes.shape[0] > 0:
+                data_samples.gt_instances = data_samples.gt_instances[
+                    data_samples.gt_instances.reg_uncs <
+                    self.semi_train_cfg.reg_pseudo_thr]
+        roi_losses = self.student.roi_head.loss(x, rpn_results_list,
+                                                reg_data_samples)
+        return {'loss_bbox': roi_losses['loss_bbox']}
+
+    def compute_uncertainty_with_aug(
+            self, x: Tuple[Tensor],
+            batch_data_samples: SampleList) -> List[Tensor]:
+        """Compute uncertainty with augmented bboxes.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            batch_data_samples (List[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`,
+                which are `pseudo_instance` or `pseudo_panoptic_seg`
+                or `pseudo_sem_seg` in fact.
+
+        Returns:
+            list[Tensor]: A list of uncertainty for pseudo bboxes.
+        """
+        auged_results_list = self.aug_box(batch_data_samples,
+                                          self.semi_train_cfg.jitter_times,
+                                          self.semi_train_cfg.jitter_scale)
+        # flatten
+        auged_results_list = [
+            InstanceData(bboxes=auged.reshape(-1, auged.shape[-1]))
+            for auged in auged_results_list
+        ]
+
+        self.teacher.roi_head.test_cfg = None
+        results_list = self.teacher.roi_head.predict(
+            x, auged_results_list, batch_data_samples, rescale=False)
+        self.teacher.roi_head.test_cfg = self.teacher.test_cfg.rcnn
+
+        reg_channel = max(
+            [results.bboxes.shape[-1] for results in results_list]) // 4
+        bboxes = [
+            results.bboxes.reshape(self.semi_train_cfg.jitter_times, -1,
+                                   results.bboxes.shape[-1])
+            if results.bboxes.numel() > 0 else results.bboxes.new_zeros(
+                self.semi_train_cfg.jitter_times, 0, 4 * reg_channel).float()
+            for results in results_list
+        ]
+
+        box_unc = [bbox.std(dim=0) for bbox in bboxes]
+        bboxes = [bbox.mean(dim=0) for bbox in bboxes]
+        labels = [
+            data_samples.gt_instances.labels
+            for data_samples in batch_data_samples
+        ]
+        if reg_channel != 1:
+            bboxes = [
+                bbox.reshape(bbox.shape[0], reg_channel,
+                             4)[torch.arange(bbox.shape[0]), label]
+                for bbox, label in zip(bboxes, labels)
+            ]
+            box_unc = [
+                unc.reshape(unc.shape[0], reg_channel,
+                            4)[torch.arange(unc.shape[0]), label]
+                for unc, label in zip(box_unc, labels)
+            ]
+
+        box_shape = [(bbox[:, 2:4] - bbox[:, :2]).clamp(min=1.0)
+                     for bbox in bboxes]
+        box_unc = [
+            torch.mean(
+                unc / wh[:, None, :].expand(-1, 2, 2).reshape(-1, 4), dim=-1)
+            if wh.numel() > 0 else unc for unc, wh in zip(box_unc, box_shape)
+        ]
+        return box_unc
+
+    @staticmethod
+    def aug_box(batch_data_samples, times, frac):
+        """Augment bboxes with jitter."""
+
+        def _aug_single(box):
+            box_scale = box[:, 2:4] - box[:, :2]
+            box_scale = (
+                box_scale.clamp(min=1)[:, None, :].expand(-1, 2,
+                                                          2).reshape(-1, 4))
+            aug_scale = box_scale * frac  # [n,4]
+
+            offset = (
+                torch.randn(times, box.shape[0], 4, device=box.device) *
+                aug_scale[None, ...])
+            new_box = box.clone()[None, ...].expand(times, box.shape[0],
+                                                    -1) + offset
+            return new_box
+
+        return [
+            _aug_single(data_samples.gt_instances.bboxes)
+            for data_samples in batch_data_samples
+        ]
diff --git a/mmdetection/mmdet/models/detectors/solo.py b/mmdetection/mmdet/models/detectors/solo.py
new file mode 100644
index 00000000..6bf47ba2
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/solo.py
@@ -0,0 +1,31 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage_instance_seg import SingleStageInstanceSegmentor
+
+
+@MODELS.register_module()
+class SOLO(SingleStageInstanceSegmentor):
+    """`SOLO: Segmenting Objects by Locations
+    `_
+
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: OptConfigType = None,
+                 bbox_head: OptConfigType = None,
+                 mask_head: OptConfigType = None,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None):
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            mask_head=mask_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/solov2.py b/mmdetection/mmdet/models/detectors/solov2.py
new file mode 100644
index 00000000..1eefe4c5
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/solov2.py
@@ -0,0 +1,31 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage_instance_seg import SingleStageInstanceSegmentor
+
+
+@MODELS.register_module()
+class SOLOv2(SingleStageInstanceSegmentor):
+    """`SOLOv2: Dynamic and Fast Instance Segmentation
+    `_
+
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: OptConfigType = None,
+                 bbox_head: OptConfigType = None,
+                 mask_head: OptConfigType = None,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None):
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            mask_head=mask_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/sparse_rcnn.py b/mmdetection/mmdet/models/detectors/sparse_rcnn.py
new file mode 100644
index 00000000..75442a69
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/sparse_rcnn.py
@@ -0,0 +1,31 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .two_stage import TwoStageDetector
+
+
+@MODELS.register_module()
+class SparseRCNN(TwoStageDetector):
+    r"""Implementation of `Sparse R-CNN: End-to-End Object Detection with
+    Learnable Proposals `_"""
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: OptConfigType = None,
+                 rpn_head: OptConfigType = None,
+                 roi_head: OptConfigType = None,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            rpn_head=rpn_head,
+            roi_head=roi_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
+        assert self.with_rpn, 'Sparse R-CNN and QueryInst ' \
+            'do not support external proposals'
diff --git a/mmdetection/mmdet/models/detectors/tood.py b/mmdetection/mmdet/models/detectors/tood.py
new file mode 100644
index 00000000..38720482
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/tood.py
@@ -0,0 +1,42 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage import SingleStageDetector
+
+
+@MODELS.register_module()
+class TOOD(SingleStageDetector):
+    r"""Implementation of `TOOD: Task-aligned One-stage Object Detection.
+    `_
+
+    Args:
+        backbone (:obj:`ConfigDict` or dict): The backbone module.
+        neck (:obj:`ConfigDict` or dict): The neck module.
+        bbox_head (:obj:`ConfigDict` or dict): The bbox head module.
+        train_cfg (:obj:`ConfigDict` or dict, optional): The training config
+            of TOOD. Defaults to None.
+        test_cfg (:obj:`ConfigDict` or dict, optional): The testing config
+            of TOOD. Defaults to None.
+        data_preprocessor (:obj:`ConfigDict` or dict, optional): Config of
+            :class:`DetDataPreprocessor` to process the input data.
+            Defaults to None.
+        init_cfg (:obj:`ConfigDict` or dict, optional): the config to control
+            the initialization. Defaults to None.
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/trident_faster_rcnn.py b/mmdetection/mmdet/models/detectors/trident_faster_rcnn.py
new file mode 100644
index 00000000..4244925b
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/trident_faster_rcnn.py
@@ -0,0 +1,81 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .faster_rcnn import FasterRCNN
+
+
+@MODELS.register_module()
+class TridentFasterRCNN(FasterRCNN):
+    """Implementation of `TridentNet `_"""
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 rpn_head: ConfigType,
+                 roi_head: ConfigType,
+                 train_cfg: ConfigType,
+                 test_cfg: ConfigType,
+                 neck: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            rpn_head=rpn_head,
+            roi_head=roi_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
+        assert self.backbone.num_branch == self.roi_head.num_branch
+        assert self.backbone.test_branch_idx == self.roi_head.test_branch_idx
+        self.num_branch = self.backbone.num_branch
+        self.test_branch_idx = self.backbone.test_branch_idx
+
+    def _forward(self, batch_inputs: Tensor,
+                 batch_data_samples: SampleList) -> tuple:
+        """copy the ``batch_data_samples`` to fit multi-branch."""
+        num_branch = self.num_branch \
+            if self.training or self.test_branch_idx == -1 else 1
+        trident_data_samples = batch_data_samples * num_branch
+        return super()._forward(
+            batch_inputs=batch_inputs, batch_data_samples=trident_data_samples)
+
+    def loss(self, batch_inputs: Tensor,
+             batch_data_samples: SampleList) -> dict:
+        """copy the ``batch_data_samples`` to fit multi-branch."""
+        num_branch = self.num_branch \
+            if self.training or self.test_branch_idx == -1 else 1
+        trident_data_samples = batch_data_samples * num_branch
+        return super().loss(
+            batch_inputs=batch_inputs, batch_data_samples=trident_data_samples)
+
+    def predict(self,
+                batch_inputs: Tensor,
+                batch_data_samples: SampleList,
+                rescale: bool = True) -> SampleList:
+        """copy the ``batch_data_samples`` to fit multi-branch."""
+        num_branch = self.num_branch \
+            if self.training or self.test_branch_idx == -1 else 1
+        trident_data_samples = batch_data_samples * num_branch
+        return super().predict(
+            batch_inputs=batch_inputs,
+            batch_data_samples=trident_data_samples,
+            rescale=rescale)
+
+    # TODO need to refactor
+    def aug_test(self, imgs, img_metas, rescale=False):
+        """Test with augmentations.
+
+        If rescale is False, then returned bboxes and masks will fit the scale
+        of imgs[0].
+        """
+        x = self.extract_feats(imgs)
+        num_branch = (self.num_branch if self.test_branch_idx == -1 else 1)
+        trident_img_metas = [img_metas * num_branch for img_metas in img_metas]
+        proposal_list = self.rpn_head.aug_test_rpn(x, trident_img_metas)
+        return self.roi_head.aug_test(
+            x, proposal_list, img_metas, rescale=rescale)
diff --git a/mmdetection/mmdet/models/detectors/two_stage.py b/mmdetection/mmdet/models/detectors/two_stage.py
new file mode 100644
index 00000000..4e83df9e
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/two_stage.py
@@ -0,0 +1,243 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import warnings
+from typing import List, Tuple, Union
+
+import torch
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .base import BaseDetector
+
+
+@MODELS.register_module()
+class TwoStageDetector(BaseDetector):
+    """Base class for two-stage detectors.
+
+    Two-stage detectors typically consisting of a region proposal network and a
+    task-specific regression head.
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: OptConfigType = None,
+                 rpn_head: OptConfigType = None,
+                 roi_head: OptConfigType = None,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            data_preprocessor=data_preprocessor, init_cfg=init_cfg)
+        self.backbone = MODELS.build(backbone)
+
+        if neck is not None:
+            self.neck = MODELS.build(neck)
+
+        if rpn_head is not None:
+            rpn_train_cfg = train_cfg.rpn if train_cfg is not None else None
+            rpn_head_ = rpn_head.copy()
+            rpn_head_.update(train_cfg=rpn_train_cfg, test_cfg=test_cfg.rpn)
+            rpn_head_num_classes = rpn_head_.get('num_classes', None)
+            if rpn_head_num_classes is None:
+                rpn_head_.update(num_classes=1)
+            else:
+                if rpn_head_num_classes != 1:
+                    warnings.warn(
+                        'The `num_classes` should be 1 in RPN, but get '
+                        f'{rpn_head_num_classes}, please set '
+                        'rpn_head.num_classes = 1 in your config file.')
+                    rpn_head_.update(num_classes=1)
+            self.rpn_head = MODELS.build(rpn_head_)
+
+        if roi_head is not None:
+            # update train and test cfg here for now
+            # TODO: refactor assigner & sampler
+            rcnn_train_cfg = train_cfg.rcnn if train_cfg is not None else None
+            roi_head.update(train_cfg=rcnn_train_cfg)
+            roi_head.update(test_cfg=test_cfg.rcnn)
+            self.roi_head = MODELS.build(roi_head)
+
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+
+    def _load_from_state_dict(self, state_dict: dict, prefix: str,
+                              local_metadata: dict, strict: bool,
+                              missing_keys: Union[List[str], str],
+                              unexpected_keys: Union[List[str], str],
+                              error_msgs: Union[List[str], str]) -> None:
+        """Exchange bbox_head key to rpn_head key when loading single-stage
+        weights into two-stage model."""
+        bbox_head_prefix = prefix + '.bbox_head' if prefix else 'bbox_head'
+        bbox_head_keys = [
+            k for k in state_dict.keys() if k.startswith(bbox_head_prefix)
+        ]
+        rpn_head_prefix = prefix + '.rpn_head' if prefix else 'rpn_head'
+        rpn_head_keys = [
+            k for k in state_dict.keys() if k.startswith(rpn_head_prefix)
+        ]
+        if len(bbox_head_keys) != 0 and len(rpn_head_keys) == 0:
+            for bbox_head_key in bbox_head_keys:
+                rpn_head_key = rpn_head_prefix + \
+                               bbox_head_key[len(bbox_head_prefix):]
+                state_dict[rpn_head_key] = state_dict.pop(bbox_head_key)
+        super()._load_from_state_dict(state_dict, prefix, local_metadata,
+                                      strict, missing_keys, unexpected_keys,
+                                      error_msgs)
+
+    @property
+    def with_rpn(self) -> bool:
+        """bool: whether the detector has RPN"""
+        return hasattr(self, 'rpn_head') and self.rpn_head is not None
+
+    @property
+    def with_roi_head(self) -> bool:
+        """bool: whether the detector has a RoI head"""
+        return hasattr(self, 'roi_head') and self.roi_head is not None
+
+    def extract_feat(self, batch_inputs: Tensor) -> Tuple[Tensor]:
+        """Extract features.
+
+        Args:
+            batch_inputs (Tensor): Image tensor with shape (N, C, H ,W).
+
+        Returns:
+            tuple[Tensor]: Multi-level features that may have
+            different resolutions.
+        """
+        x = self.backbone(batch_inputs)
+        if self.with_neck:
+            x = self.neck(x)
+        return x
+
+    def _forward(self, batch_inputs: Tensor,
+                 batch_data_samples: SampleList) -> tuple:
+        """Network forward process. Usually includes backbone, neck and head
+        forward without any post-processing.
+
+        Args:
+            batch_inputs (Tensor): Inputs with shape (N, C, H, W).
+            batch_data_samples (list[:obj:`DetDataSample`]): Each item contains
+                the meta information of each image and corresponding
+                annotations.
+
+        Returns:
+            tuple: A tuple of features from ``rpn_head`` and ``roi_head``
+            forward.
+        """
+        results = ()
+        x = self.extract_feat(batch_inputs)
+
+        if self.with_rpn:
+            rpn_results_list = self.rpn_head.predict(
+                x, batch_data_samples, rescale=False)
+        else:
+            assert batch_data_samples[0].get('proposals', None) is not None
+            rpn_results_list = [
+                data_sample.proposals for data_sample in batch_data_samples
+            ]
+        roi_outs = self.roi_head.forward(x, rpn_results_list,
+                                         batch_data_samples)
+        results = results + (roi_outs, )
+        return results
+
+    def loss(self, batch_inputs: Tensor,
+             batch_data_samples: SampleList) -> dict:
+        """Calculate losses from a batch of inputs and data samples.
+
+        Args:
+            batch_inputs (Tensor): Input images of shape (N, C, H, W).
+                These should usually be mean centered and std scaled.
+            batch_data_samples (List[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            dict: A dictionary of loss components
+        """
+        x = self.extract_feat(batch_inputs)
+
+        losses = dict()
+
+        # RPN forward and loss
+        if self.with_rpn:
+            proposal_cfg = self.train_cfg.get('rpn_proposal',
+                                              self.test_cfg.rpn)
+            rpn_data_samples = copy.deepcopy(batch_data_samples)
+            # set cat_id of gt_labels to 0 in RPN
+            for data_sample in rpn_data_samples:
+                data_sample.gt_instances.labels = \
+                    torch.zeros_like(data_sample.gt_instances.labels)
+
+            rpn_losses, rpn_results_list = self.rpn_head.loss_and_predict(
+                x, rpn_data_samples, proposal_cfg=proposal_cfg)
+            # avoid get same name with roi_head loss
+            keys = rpn_losses.keys()
+            for key in list(keys):
+                if 'loss' in key and 'rpn' not in key:
+                    rpn_losses[f'rpn_{key}'] = rpn_losses.pop(key)
+            losses.update(rpn_losses)
+        else:
+            assert batch_data_samples[0].get('proposals', None) is not None
+            # use pre-defined proposals in InstanceData for the second stage
+            # to extract ROI features.
+            rpn_results_list = [
+                data_sample.proposals for data_sample in batch_data_samples
+            ]
+
+        roi_losses = self.roi_head.loss(x, rpn_results_list,
+                                        batch_data_samples)
+        losses.update(roi_losses)
+
+        return losses
+
+    def predict(self,
+                batch_inputs: Tensor,
+                batch_data_samples: SampleList,
+                rescale: bool = True) -> SampleList:
+        """Predict results from a batch of inputs and data samples with post-
+        processing.
+
+        Args:
+            batch_inputs (Tensor): Inputs with shape (N, C, H, W).
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            rescale (bool): Whether to rescale the results.
+                Defaults to True.
+
+        Returns:
+            list[:obj:`DetDataSample`]: Return the detection results of the
+            input images. The returns value is DetDataSample,
+            which usually contain 'pred_instances'. And the
+            ``pred_instances`` usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                    (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                    (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                    the last dimension 4 arrange as (x1, y1, x2, y2).
+                - masks (Tensor): Has a shape (num_instances, H, W).
+        """
+
+        assert self.with_bbox, 'Bbox head must be implemented.'
+        x = self.extract_feat(batch_inputs)
+
+        # If there are no pre-defined proposals, use RPN to get proposals
+        if batch_data_samples[0].get('proposals', None) is None:
+            rpn_results_list = self.rpn_head.predict(
+                x, batch_data_samples, rescale=False)
+        else:
+            rpn_results_list = [
+                data_sample.proposals for data_sample in batch_data_samples
+            ]
+
+        results_list = self.roi_head.predict(
+            x, rpn_results_list, batch_data_samples, rescale=rescale)
+
+        batch_data_samples = self.add_pred_to_datasample(
+            batch_data_samples, results_list)
+        return batch_data_samples
diff --git a/mmdetection/mmdet/models/detectors/vfnet.py b/mmdetection/mmdet/models/detectors/vfnet.py
new file mode 100644
index 00000000..a695513f
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/vfnet.py
@@ -0,0 +1,42 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage import SingleStageDetector
+
+
+@MODELS.register_module()
+class VFNet(SingleStageDetector):
+    """Implementation of `VarifocalNet
+    (VFNet).`_
+
+    Args:
+        backbone (:obj:`ConfigDict` or dict): The backbone module.
+        neck (:obj:`ConfigDict` or dict): The neck module.
+        bbox_head (:obj:`ConfigDict` or dict): The bbox head module.
+        train_cfg (:obj:`ConfigDict` or dict, optional): The training config
+            of VFNet. Defaults to None.
+        test_cfg (:obj:`ConfigDict` or dict, optional): The testing config
+            of VFNet. Defaults to None.
+        data_preprocessor (:obj:`ConfigDict` or dict, optional): Config of
+            :class:`DetDataPreprocessor` to process the input data.
+            Defaults to None.
+        init_cfg (:obj:`ConfigDict` or dict, optional): the config to control
+            the initialization. Defaults to None.
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/yolact.py b/mmdetection/mmdet/models/detectors/yolact.py
new file mode 100644
index 00000000..f15fb7b7
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/yolact.py
@@ -0,0 +1,28 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage_instance_seg import SingleStageInstanceSegmentor
+
+
+@MODELS.register_module()
+class YOLACT(SingleStageInstanceSegmentor):
+    """Implementation of `YOLACT `_"""
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 mask_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            mask_head=mask_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/yolo.py b/mmdetection/mmdet/models/detectors/yolo.py
new file mode 100644
index 00000000..5cb9a9cd
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/yolo.py
@@ -0,0 +1,45 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# Copyright (c) 2019 Western Digital Corporation or its affiliates.
+
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage import SingleStageDetector
+
+
+@MODELS.register_module()
+class YOLOV3(SingleStageDetector):
+    r"""Implementation of `Yolov3: An incremental improvement
+    `_
+
+    Args:
+        backbone (:obj:`ConfigDict` or dict): The backbone module.
+        neck (:obj:`ConfigDict` or dict): The neck module.
+        bbox_head (:obj:`ConfigDict` or dict): The bbox head module.
+        train_cfg (:obj:`ConfigDict` or dict, optional): The training config
+            of YOLOX. Default: None.
+        test_cfg (:obj:`ConfigDict` or dict, optional): The testing config
+            of YOLOX. Default: None.
+        data_preprocessor (:obj:`ConfigDict` or dict, optional):
+            Model preprocessing config for processing the input data.
+            it usually includes ``to_rgb``, ``pad_size_divisor``,
+            ``pad_value``, ``mean`` and ``std``. Defaults to None.
+        init_cfg (:obj:`ConfigDict` or dict, optional): the config to control
+            the initialization. Defaults to None.
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/yolof.py b/mmdetection/mmdet/models/detectors/yolof.py
new file mode 100644
index 00000000..c6d98b91
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/yolof.py
@@ -0,0 +1,43 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage import SingleStageDetector
+
+
+@MODELS.register_module()
+class YOLOF(SingleStageDetector):
+    r"""Implementation of `You Only Look One-level Feature
+    `_
+
+    Args:
+        backbone (:obj:`ConfigDict` or dict): The backbone module.
+        neck (:obj:`ConfigDict` or dict): The neck module.
+        bbox_head (:obj:`ConfigDict` or dict): The bbox head module.
+        train_cfg (:obj:`ConfigDict` or dict, optional): The training config
+            of YOLOF. Defaults to None.
+        test_cfg (:obj:`ConfigDict` or dict, optional): The testing config
+            of YOLOF. Defaults to None.
+        data_preprocessor (:obj:`ConfigDict` or dict, optional):
+            Model preprocessing config for processing the input data.
+            it usually includes ``to_rgb``, ``pad_size_divisor``,
+            ``pad_value``, ``mean`` and ``std``. Defaults to None.
+        init_cfg (:obj:`ConfigDict` or dict, optional): the config to control
+            the initialization. Defaults to None.
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/detectors/yolox.py b/mmdetection/mmdet/models/detectors/yolox.py
new file mode 100644
index 00000000..df9190c9
--- /dev/null
+++ b/mmdetection/mmdet/models/detectors/yolox.py
@@ -0,0 +1,43 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .single_stage import SingleStageDetector
+
+
+@MODELS.register_module()
+class YOLOX(SingleStageDetector):
+    r"""Implementation of `YOLOX: Exceeding YOLO Series in 2021
+    `_
+
+    Args:
+        backbone (:obj:`ConfigDict` or dict): The backbone config.
+        neck (:obj:`ConfigDict` or dict): The neck config.
+        bbox_head (:obj:`ConfigDict` or dict): The bbox head config.
+        train_cfg (:obj:`ConfigDict` or dict, optional): The training config
+            of YOLOX. Defaults to None.
+        test_cfg (:obj:`ConfigDict` or dict, optional): The testing config
+            of YOLOX. Defaults to None.
+        data_preprocessor (:obj:`ConfigDict` or dict, optional): Config of
+            :class:`DetDataPreprocessor` to process the input data.
+            Defaults to None.
+        init_cfg (:obj:`ConfigDict` or list[:obj:`ConfigDict`] or dict or
+            list[dict], optional): Initialization config dict.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/mmdet/models/language_models/__init__.py b/mmdetection/mmdet/models/language_models/__init__.py
new file mode 100644
index 00000000..70f1a22c
--- /dev/null
+++ b/mmdetection/mmdet/models/language_models/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .bert import BertModel
+
+__all__ = ['BertModel']
diff --git a/mmdetection/mmdet/models/language_models/bert.py b/mmdetection/mmdet/models/language_models/bert.py
new file mode 100644
index 00000000..efb0f46b
--- /dev/null
+++ b/mmdetection/mmdet/models/language_models/bert.py
@@ -0,0 +1,231 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from collections import OrderedDict
+from typing import Sequence
+
+import torch
+from mmengine.model import BaseModel
+from torch import nn
+
+try:
+    from transformers import AutoTokenizer, BertConfig
+    from transformers import BertModel as HFBertModel
+except ImportError:
+    AutoTokenizer = None
+    HFBertModel = None
+
+from mmdet.registry import MODELS
+
+
+def generate_masks_with_special_tokens_and_transfer_map(
+        tokenized, special_tokens_list):
+    """Generate attention mask between each pair of special tokens.
+
+    Only token pairs in between two special tokens are attended to
+    and thus the attention mask for these pairs is positive.
+
+    Args:
+        input_ids (torch.Tensor): input ids. Shape: [bs, num_token]
+        special_tokens_mask (list): special tokens mask.
+
+    Returns:
+        Tuple(Tensor, Tensor):
+        - attention_mask is the attention mask between each tokens.
+          Only token pairs in between two special tokens are positive.
+          Shape: [bs, num_token, num_token].
+        - position_ids is the position id of tokens within each valid sentence.
+          The id starts from 0 whenenver a special token is encountered.
+          Shape: [bs, num_token]
+    """
+    input_ids = tokenized['input_ids']
+    bs, num_token = input_ids.shape
+    # special_tokens_mask:
+    # bs, num_token. 1 for special tokens. 0 for normal tokens
+    special_tokens_mask = torch.zeros((bs, num_token),
+                                      device=input_ids.device).bool()
+
+    for special_token in special_tokens_list:
+        special_tokens_mask |= input_ids == special_token
+
+    # idxs: each row is a list of indices of special tokens
+    idxs = torch.nonzero(special_tokens_mask)
+
+    # generate attention mask and positional ids
+    attention_mask = (
+        torch.eye(num_token,
+                  device=input_ids.device).bool().unsqueeze(0).repeat(
+                      bs, 1, 1))
+    position_ids = torch.zeros((bs, num_token), device=input_ids.device)
+    previous_col = 0
+    for i in range(idxs.shape[0]):
+        row, col = idxs[i]
+        if (col == 0) or (col == num_token - 1):
+            attention_mask[row, col, col] = True
+            position_ids[row, col] = 0
+        else:
+            attention_mask[row, previous_col + 1:col + 1,
+                           previous_col + 1:col + 1] = True
+            position_ids[row, previous_col + 1:col + 1] = torch.arange(
+                0, col - previous_col, device=input_ids.device)
+        previous_col = col
+
+    return attention_mask, position_ids.to(torch.long)
+
+
+@MODELS.register_module()
+class BertModel(BaseModel):
+    """BERT model for language embedding only encoder.
+
+    Args:
+        name (str, optional): name of the pretrained BERT model from
+            HuggingFace. Defaults to bert-base-uncased.
+        max_tokens (int, optional): maximum number of tokens to be
+            used for BERT. Defaults to 256.
+        pad_to_max (bool, optional): whether to pad the tokens to max_tokens.
+             Defaults to True.
+        use_sub_sentence_represent (bool, optional): whether to use sub
+            sentence represent introduced in `Grounding DINO
+            `. Defaults to False.
+        special_tokens_list (list, optional): special tokens used to split
+            subsentence. It cannot be None when `use_sub_sentence_represent`
+            is True. Defaults to None.
+        add_pooling_layer (bool, optional): whether to adding pooling
+            layer in bert encoder. Defaults to False.
+        num_layers_of_embedded (int, optional): number of layers of
+            the embedded model. Defaults to 1.
+        use_checkpoint (bool, optional): whether to use gradient checkpointing.
+             Defaults to False.
+    """
+
+    def __init__(self,
+                 name: str = 'bert-base-uncased',
+                 max_tokens: int = 256,
+                 pad_to_max: bool = True,
+                 use_sub_sentence_represent: bool = False,
+                 special_tokens_list: list = None,
+                 add_pooling_layer: bool = False,
+                 num_layers_of_embedded: int = 1,
+                 use_checkpoint: bool = False,
+                 **kwargs) -> None:
+
+        super().__init__(**kwargs)
+        self.max_tokens = max_tokens
+        self.pad_to_max = pad_to_max
+
+        if AutoTokenizer is None:
+            raise RuntimeError(
+                'transformers is not installed, please install it by: '
+                'pip install transformers.')
+
+        self.tokenizer = AutoTokenizer.from_pretrained(name)
+        self.language_backbone = nn.Sequential(
+            OrderedDict([('body',
+                          BertEncoder(
+                              name,
+                              add_pooling_layer=add_pooling_layer,
+                              num_layers_of_embedded=num_layers_of_embedded,
+                              use_checkpoint=use_checkpoint))]))
+
+        self.use_sub_sentence_represent = use_sub_sentence_represent
+        if self.use_sub_sentence_represent:
+            assert special_tokens_list is not None, \
+                'special_tokens should not be None \
+                    if use_sub_sentence_represent is True'
+
+            self.special_tokens = self.tokenizer.convert_tokens_to_ids(
+                special_tokens_list)
+
+    def forward(self, captions: Sequence[str], **kwargs) -> dict:
+        """Forward function."""
+        device = next(self.language_backbone.parameters()).device
+        tokenized = self.tokenizer.batch_encode_plus(
+            captions,
+            max_length=self.max_tokens,
+            padding='max_length' if self.pad_to_max else 'longest',
+            return_special_tokens_mask=True,
+            return_tensors='pt',
+            truncation=True).to(device)
+        input_ids = tokenized.input_ids
+        if self.use_sub_sentence_represent:
+            attention_mask, position_ids = \
+                generate_masks_with_special_tokens_and_transfer_map(
+                    tokenized, self.special_tokens)
+            token_type_ids = tokenized['token_type_ids']
+
+        else:
+            attention_mask = tokenized.attention_mask
+            position_ids = None
+            token_type_ids = None
+
+        tokenizer_input = {
+            'input_ids': input_ids,
+            'attention_mask': attention_mask,
+            'position_ids': position_ids,
+            'token_type_ids': token_type_ids
+        }
+        language_dict_features = self.language_backbone(tokenizer_input)
+        if self.use_sub_sentence_represent:
+            language_dict_features['position_ids'] = position_ids
+            language_dict_features[
+                'text_token_mask'] = tokenized.attention_mask.bool()
+        return language_dict_features
+
+
+class BertEncoder(nn.Module):
+    """BERT encoder for language embedding.
+
+    Args:
+        name (str): name of the pretrained BERT model from HuggingFace.
+                Defaults to bert-base-uncased.
+        add_pooling_layer (bool): whether to add a pooling layer.
+        num_layers_of_embedded (int): number of layers of the embedded model.
+                Defaults to 1.
+        use_checkpoint (bool): whether to use gradient checkpointing.
+                Defaults to False.
+    """
+
+    def __init__(self,
+                 name: str,
+                 add_pooling_layer: bool = False,
+                 num_layers_of_embedded: int = 1,
+                 use_checkpoint: bool = False):
+        super().__init__()
+        if BertConfig is None:
+            raise RuntimeError(
+                'transformers is not installed, please install it by: '
+                'pip install transformers.')
+        config = BertConfig.from_pretrained(name)
+        config.gradient_checkpointing = use_checkpoint
+        # only encoder
+        self.model = HFBertModel.from_pretrained(
+            name, add_pooling_layer=add_pooling_layer, config=config)
+        self.language_dim = config.hidden_size
+        self.num_layers_of_embedded = num_layers_of_embedded
+
+    def forward(self, x) -> dict:
+        mask = x['attention_mask']
+
+        outputs = self.model(
+            input_ids=x['input_ids'],
+            attention_mask=mask,
+            position_ids=x['position_ids'],
+            token_type_ids=x['token_type_ids'],
+            output_hidden_states=True,
+        )
+
+        # outputs has 13 layers, 1 input layer and 12 hidden layers
+        encoded_layers = outputs.hidden_states[1:]
+        features = torch.stack(encoded_layers[-self.num_layers_of_embedded:],
+                               1).mean(1)
+        # language embedding has shape [len(phrase), seq_len, language_dim]
+        features = features / self.num_layers_of_embedded
+        if mask.dim() == 2:
+            embedded = features * mask.unsqueeze(-1).float()
+        else:
+            embedded = features
+
+        results = {
+            'embedded': embedded,
+            'masks': mask,
+            'hidden': encoded_layers[-1]
+        }
+        return results
diff --git a/mmdetection/mmdet/models/layers/__init__.py b/mmdetection/mmdet/models/layers/__init__.py
new file mode 100644
index 00000000..e3c41f64
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/__init__.py
@@ -0,0 +1,65 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .activations import SiLU
+from .bbox_nms import fast_nms, multiclass_nms
+from .brick_wrappers import (AdaptiveAvgPool2d, FrozenBatchNorm2d,
+                             adaptive_avg_pool2d)
+from .conv_upsample import ConvUpsample
+from .csp_layer import CSPLayer
+from .dropblock import DropBlock
+from .ema import ExpMomentumEMA
+from .inverted_residual import InvertedResidual
+from .matrix_nms import mask_matrix_nms
+from .msdeformattn_pixel_decoder import MSDeformAttnPixelDecoder
+from .normed_predictor import NormedConv2d, NormedLinear
+from .pixel_decoder import PixelDecoder, TransformerEncoderPixelDecoder
+from .positional_encoding import (LearnedPositionalEncoding,
+                                  SinePositionalEncoding,
+                                  SinePositionalEncoding3D)
+from .res_layer import ResLayer, SimplifiedBasicBlock
+from .se_layer import ChannelAttention, DyReLU, SELayer
+# yapf: disable
+from .transformer import (MLP, AdaptivePadding, CdnQueryGenerator,
+                          ConditionalAttention,
+                          ConditionalDetrTransformerDecoder,
+                          ConditionalDetrTransformerDecoderLayer,
+                          DABDetrTransformerDecoder,
+                          DABDetrTransformerDecoderLayer,
+                          DABDetrTransformerEncoder, DDQTransformerDecoder,
+                          DeformableDetrTransformerDecoder,
+                          DeformableDetrTransformerDecoderLayer,
+                          DeformableDetrTransformerEncoder,
+                          DeformableDetrTransformerEncoderLayer,
+                          DetrTransformerDecoder, DetrTransformerDecoderLayer,
+                          DetrTransformerEncoder, DetrTransformerEncoderLayer,
+                          DinoTransformerDecoder, DynamicConv,
+                          Mask2FormerTransformerDecoder,
+                          Mask2FormerTransformerDecoderLayer,
+                          Mask2FormerTransformerEncoder, PatchEmbed,
+                          PatchMerging, coordinate_to_encoding,
+                          inverse_sigmoid, nchw_to_nlc, nlc_to_nchw)
+
+# yapf: enable
+
+__all__ = [
+    'fast_nms', 'multiclass_nms', 'mask_matrix_nms', 'DropBlock',
+    'PixelDecoder', 'TransformerEncoderPixelDecoder',
+    'MSDeformAttnPixelDecoder', 'ResLayer', 'PatchMerging',
+    'SinePositionalEncoding', 'LearnedPositionalEncoding', 'DynamicConv',
+    'SimplifiedBasicBlock', 'NormedLinear', 'NormedConv2d', 'InvertedResidual',
+    'SELayer', 'ConvUpsample', 'CSPLayer', 'adaptive_avg_pool2d',
+    'AdaptiveAvgPool2d', 'PatchEmbed', 'nchw_to_nlc', 'nlc_to_nchw', 'DyReLU',
+    'ExpMomentumEMA', 'inverse_sigmoid', 'ChannelAttention', 'SiLU', 'MLP',
+    'DetrTransformerEncoderLayer', 'DetrTransformerDecoderLayer',
+    'DetrTransformerEncoder', 'DetrTransformerDecoder',
+    'DeformableDetrTransformerEncoder', 'DeformableDetrTransformerDecoder',
+    'DeformableDetrTransformerEncoderLayer',
+    'DeformableDetrTransformerDecoderLayer', 'AdaptivePadding',
+    'coordinate_to_encoding', 'ConditionalAttention',
+    'DABDetrTransformerDecoderLayer', 'DABDetrTransformerDecoder',
+    'DABDetrTransformerEncoder', 'DDQTransformerDecoder',
+    'ConditionalDetrTransformerDecoder',
+    'ConditionalDetrTransformerDecoderLayer', 'DinoTransformerDecoder',
+    'CdnQueryGenerator', 'Mask2FormerTransformerEncoder',
+    'Mask2FormerTransformerDecoderLayer', 'Mask2FormerTransformerDecoder',
+    'SinePositionalEncoding3D', 'FrozenBatchNorm2d'
+]
diff --git a/mmdetection/mmdet/models/layers/activations.py b/mmdetection/mmdet/models/layers/activations.py
new file mode 100644
index 00000000..9e73ef42
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/activations.py
@@ -0,0 +1,22 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmengine.utils import digit_version
+
+from mmdet.registry import MODELS
+
+if digit_version(torch.__version__) >= digit_version('1.7.0'):
+    from torch.nn import SiLU
+else:
+
+    class SiLU(nn.Module):
+        """Sigmoid Weighted Liner Unit."""
+
+        def __init__(self, inplace=True):
+            super().__init__()
+
+        def forward(self, inputs) -> torch.Tensor:
+            return inputs * torch.sigmoid(inputs)
+
+
+MODELS.register_module(module=SiLU, name='SiLU')
diff --git a/mmdetection/mmdet/models/layers/bbox_nms.py b/mmdetection/mmdet/models/layers/bbox_nms.py
new file mode 100644
index 00000000..fd67a45f
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/bbox_nms.py
@@ -0,0 +1,184 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Tuple, Union
+
+import torch
+from mmcv.ops.nms import batched_nms
+from torch import Tensor
+
+from mmdet.structures.bbox import bbox_overlaps
+from mmdet.utils import ConfigType
+
+
+def multiclass_nms(
+    multi_bboxes: Tensor,
+    multi_scores: Tensor,
+    score_thr: float,
+    nms_cfg: ConfigType,
+    max_num: int = -1,
+    score_factors: Optional[Tensor] = None,
+    return_inds: bool = False,
+    box_dim: int = 4
+) -> Union[Tuple[Tensor, Tensor, Tensor], Tuple[Tensor, Tensor]]:
+    """NMS for multi-class bboxes.
+
+    Args:
+        multi_bboxes (Tensor): shape (n, #class*4) or (n, 4)
+        multi_scores (Tensor): shape (n, #class), where the last column
+            contains scores of the background class, but this will be ignored.
+        score_thr (float): bbox threshold, bboxes with scores lower than it
+            will not be considered.
+        nms_cfg (Union[:obj:`ConfigDict`, dict]): a dict that contains
+            the arguments of nms operations.
+        max_num (int, optional): if there are more than max_num bboxes after
+            NMS, only top max_num will be kept. Default to -1.
+        score_factors (Tensor, optional): The factors multiplied to scores
+            before applying NMS. Default to None.
+        return_inds (bool, optional): Whether return the indices of kept
+            bboxes. Default to False.
+        box_dim (int): The dimension of boxes. Defaults to 4.
+
+    Returns:
+        Union[Tuple[Tensor, Tensor, Tensor], Tuple[Tensor, Tensor]]:
+            (dets, labels, indices (optional)), tensors of shape (k, 5),
+            (k), and (k). Dets are boxes with scores. Labels are 0-based.
+    """
+    num_classes = multi_scores.size(1) - 1
+    # exclude background category
+    if multi_bboxes.shape[1] > box_dim:
+        bboxes = multi_bboxes.view(multi_scores.size(0), -1, box_dim)
+    else:
+        bboxes = multi_bboxes[:, None].expand(
+            multi_scores.size(0), num_classes, box_dim)
+
+    scores = multi_scores[:, :-1]
+
+    labels = torch.arange(num_classes, dtype=torch.long, device=scores.device)
+    labels = labels.view(1, -1).expand_as(scores)
+
+    bboxes = bboxes.reshape(-1, box_dim)
+    scores = scores.reshape(-1)
+    labels = labels.reshape(-1)
+
+    if not torch.onnx.is_in_onnx_export():
+        # NonZero not supported  in TensorRT
+        # remove low scoring boxes
+        valid_mask = scores > score_thr
+    # multiply score_factor after threshold to preserve more bboxes, improve
+    # mAP by 1% for YOLOv3
+    if score_factors is not None:
+        # expand the shape to match original shape of score
+        score_factors = score_factors.view(-1, 1).expand(
+            multi_scores.size(0), num_classes)
+        score_factors = score_factors.reshape(-1)
+        scores = scores * score_factors
+
+    if not torch.onnx.is_in_onnx_export():
+        # NonZero not supported  in TensorRT
+        inds = valid_mask.nonzero(as_tuple=False).squeeze(1)
+        bboxes, scores, labels = bboxes[inds], scores[inds], labels[inds]
+    else:
+        # TensorRT NMS plugin has invalid output filled with -1
+        # add dummy data to make detection output correct.
+        bboxes = torch.cat([bboxes, bboxes.new_zeros(1, box_dim)], dim=0)
+        scores = torch.cat([scores, scores.new_zeros(1)], dim=0)
+        labels = torch.cat([labels, labels.new_zeros(1)], dim=0)
+
+    if bboxes.numel() == 0:
+        if torch.onnx.is_in_onnx_export():
+            raise RuntimeError('[ONNX Error] Can not record NMS '
+                               'as it has not been executed this time')
+        dets = torch.cat([bboxes, scores[:, None]], -1)
+        if return_inds:
+            return dets, labels, inds
+        else:
+            return dets, labels
+
+    dets, keep = batched_nms(bboxes, scores, labels, nms_cfg)
+
+    if max_num > 0:
+        dets = dets[:max_num]
+        keep = keep[:max_num]
+
+    if return_inds:
+        return dets, labels[keep], inds[keep]
+    else:
+        return dets, labels[keep]
+
+
+def fast_nms(
+    multi_bboxes: Tensor,
+    multi_scores: Tensor,
+    multi_coeffs: Tensor,
+    score_thr: float,
+    iou_thr: float,
+    top_k: int,
+    max_num: int = -1
+) -> Union[Tuple[Tensor, Tensor, Tensor], Tuple[Tensor, Tensor]]:
+    """Fast NMS in `YOLACT `_.
+
+    Fast NMS allows already-removed detections to suppress other detections so
+    that every instance can be decided to be kept or discarded in parallel,
+    which is not possible in traditional NMS. This relaxation allows us to
+    implement Fast NMS entirely in standard GPU-accelerated matrix operations.
+
+    Args:
+        multi_bboxes (Tensor): shape (n, #class*4) or (n, 4)
+        multi_scores (Tensor): shape (n, #class+1), where the last column
+            contains scores of the background class, but this will be ignored.
+        multi_coeffs (Tensor): shape (n, #class*coeffs_dim).
+        score_thr (float): bbox threshold, bboxes with scores lower than it
+            will not be considered.
+        iou_thr (float): IoU threshold to be considered as conflicted.
+        top_k (int): if there are more than top_k bboxes before NMS,
+            only top top_k will be kept.
+        max_num (int): if there are more than max_num bboxes after NMS,
+            only top max_num will be kept. If -1, keep all the bboxes.
+            Default: -1.
+
+    Returns:
+        Union[Tuple[Tensor, Tensor, Tensor], Tuple[Tensor, Tensor]]:
+            (dets, labels, coefficients), tensors of shape (k, 5), (k, 1),
+            and (k, coeffs_dim). Dets are boxes with scores.
+            Labels are 0-based.
+    """
+
+    scores = multi_scores[:, :-1].t()  # [#class, n]
+    scores, idx = scores.sort(1, descending=True)
+
+    idx = idx[:, :top_k].contiguous()
+    scores = scores[:, :top_k]  # [#class, topk]
+    num_classes, num_dets = idx.size()
+    boxes = multi_bboxes[idx.view(-1), :].view(num_classes, num_dets, 4)
+    coeffs = multi_coeffs[idx.view(-1), :].view(num_classes, num_dets, -1)
+
+    iou = bbox_overlaps(boxes, boxes)  # [#class, topk, topk]
+    iou.triu_(diagonal=1)
+    iou_max, _ = iou.max(dim=1)
+
+    # Now just filter out the ones higher than the threshold
+    keep = iou_max <= iou_thr
+
+    # Second thresholding introduces 0.2 mAP gain at negligible time cost
+    keep *= scores > score_thr
+
+    # Assign each kept detection to its corresponding class
+    classes = torch.arange(
+        num_classes, device=boxes.device)[:, None].expand_as(keep)
+    classes = classes[keep]
+
+    boxes = boxes[keep]
+    coeffs = coeffs[keep]
+    scores = scores[keep]
+
+    # Only keep the top max_num highest scores across all classes
+    scores, idx = scores.sort(0, descending=True)
+    if max_num > 0:
+        idx = idx[:max_num]
+        scores = scores[:max_num]
+
+    classes = classes[idx]
+    boxes = boxes[idx]
+    coeffs = coeffs[idx]
+
+    cls_dets = torch.cat([boxes, scores[:, None]], dim=1)
+    return cls_dets, classes, coeffs
diff --git a/mmdetection/mmdet/models/layers/brick_wrappers.py b/mmdetection/mmdet/models/layers/brick_wrappers.py
new file mode 100644
index 00000000..5ecb8499
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/brick_wrappers.py
@@ -0,0 +1,138 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn.bricks.wrappers import NewEmptyTensorOp, obsolete_torch_version
+
+from mmdet.registry import MODELS
+
+if torch.__version__ == 'parrots':
+    TORCH_VERSION = torch.__version__
+else:
+    # torch.__version__ could be 1.3.1+cu92, we only need the first two
+    # for comparison
+    TORCH_VERSION = tuple(int(x) for x in torch.__version__.split('.')[:2])
+
+
+def adaptive_avg_pool2d(input, output_size):
+    """Handle empty batch dimension to adaptive_avg_pool2d.
+
+    Args:
+        input (tensor): 4D tensor.
+        output_size (int, tuple[int,int]): the target output size.
+    """
+    if input.numel() == 0 and obsolete_torch_version(TORCH_VERSION, (1, 9)):
+        if isinstance(output_size, int):
+            output_size = [output_size, output_size]
+        output_size = [*input.shape[:2], *output_size]
+        empty = NewEmptyTensorOp.apply(input, output_size)
+        return empty
+    else:
+        return F.adaptive_avg_pool2d(input, output_size)
+
+
+class AdaptiveAvgPool2d(nn.AdaptiveAvgPool2d):
+    """Handle empty batch dimension to AdaptiveAvgPool2d."""
+
+    def forward(self, x):
+        # PyTorch 1.9 does not support empty tensor inference yet
+        if x.numel() == 0 and obsolete_torch_version(TORCH_VERSION, (1, 9)):
+            output_size = self.output_size
+            if isinstance(output_size, int):
+                output_size = [output_size, output_size]
+            else:
+                output_size = [
+                    v if v is not None else d
+                    for v, d in zip(output_size,
+                                    x.size()[-2:])
+                ]
+            output_size = [*x.shape[:2], *output_size]
+            empty = NewEmptyTensorOp.apply(x, output_size)
+            return empty
+
+        return super().forward(x)
+
+
+# Modified from
+# https://github.com/facebookresearch/detectron2/blob/main/detectron2/layers/batch_norm.py#L13 # noqa
+@MODELS.register_module('FrozenBN')
+class FrozenBatchNorm2d(nn.Module):
+    """BatchNorm2d where the batch statistics and the affine parameters are
+    fixed.
+
+    It contains non-trainable buffers called
+    "weight" and "bias", "running_mean", "running_var",
+    initialized to perform identity transformation.
+    Args:
+       num_features (int):  :math:`C` from an expected input of size
+            :math:`(N, C, H, W)`.
+       eps (float): a value added to the denominator for numerical stability.
+            Default: 1e-5
+    """
+
+    def __init__(self, num_features, eps=1e-5, **kwargs):
+        super().__init__()
+        self.num_features = num_features
+        self.eps = eps
+        self.register_buffer('weight', torch.ones(num_features))
+        self.register_buffer('bias', torch.zeros(num_features))
+        self.register_buffer('running_mean', torch.zeros(num_features))
+        self.register_buffer('running_var', torch.ones(num_features) - eps)
+
+    def forward(self, x):
+        if x.requires_grad:
+            # When gradients are needed, F.batch_norm will use extra memory
+            # because its backward op computes gradients for weight/bias
+            # as well.
+            scale = self.weight * (self.running_var + self.eps).rsqrt()
+            bias = self.bias - self.running_mean * scale
+            scale = scale.reshape(1, -1, 1, 1)
+            bias = bias.reshape(1, -1, 1, 1)
+            out_dtype = x.dtype  # may be half
+            return x * scale.to(out_dtype) + bias.to(out_dtype)
+        else:
+            # When gradients are not needed, F.batch_norm is a single fused op
+            # and provide more optimization opportunities.
+            return F.batch_norm(
+                x,
+                self.running_mean,
+                self.running_var,
+                self.weight,
+                self.bias,
+                training=False,
+                eps=self.eps,
+            )
+
+    def __repr__(self):
+        return 'FrozenBatchNorm2d(num_features={}, eps={})'.format(
+            self.num_features, self.eps)
+
+    @classmethod
+    def convert_frozen_batchnorm(cls, module):
+        """Convert all BatchNorm/SyncBatchNorm in module into FrozenBatchNorm.
+
+        Args:
+            module (torch.nn.Module):
+        Returns:
+            If module is BatchNorm/SyncBatchNorm, returns a new module.
+            Otherwise, in-place convert module and return it.
+        Similar to convert_sync_batchnorm in
+        https://github.com/pytorch/pytorch/blob/master/torch/nn/modules/batchnorm.py
+        """
+        bn_module = nn.modules.batchnorm
+        bn_module = (bn_module.BatchNorm2d, bn_module.SyncBatchNorm)
+        res = module
+        if isinstance(module, bn_module):
+            res = cls(module.num_features)
+            if module.affine:
+                res.weight.data = module.weight.data.clone().detach()
+                res.bias.data = module.bias.data.clone().detach()
+            res.running_mean.data = module.running_mean.data
+            res.running_var.data = module.running_var.data
+            res.eps = module.eps
+        else:
+            for name, child in module.named_children():
+                new_child = cls.convert_frozen_batchnorm(child)
+                if new_child is not child:
+                    res.add_module(name, new_child)
+        return res
diff --git a/mmdetection/mmdet/models/layers/conv_upsample.py b/mmdetection/mmdet/models/layers/conv_upsample.py
new file mode 100644
index 00000000..32505875
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/conv_upsample.py
@@ -0,0 +1,67 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule, ModuleList
+
+
+class ConvUpsample(BaseModule):
+    """ConvUpsample performs 2x upsampling after Conv.
+
+    There are several `ConvModule` layers. In the first few layers, upsampling
+    will be applied after each layer of convolution. The number of upsampling
+    must be no more than the number of ConvModule layers.
+
+    Args:
+        in_channels (int): Number of channels in the input feature map.
+        inner_channels (int): Number of channels produced by the convolution.
+        num_layers (int): Number of convolution layers.
+        num_upsample (int | optional): Number of upsampling layer. Must be no
+            more than num_layers. Upsampling will be applied after the first
+            ``num_upsample`` layers of convolution. Default: ``num_layers``.
+        conv_cfg (dict): Config dict for convolution layer. Default: None,
+            which means using conv2d.
+        norm_cfg (dict): Config dict for normalization layer. Default: None.
+        init_cfg (dict): Config dict for initialization. Default: None.
+        kwargs (key word augments): Other augments used in ConvModule.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 inner_channels,
+                 num_layers=1,
+                 num_upsample=None,
+                 conv_cfg=None,
+                 norm_cfg=None,
+                 init_cfg=None,
+                 **kwargs):
+        super(ConvUpsample, self).__init__(init_cfg)
+        if num_upsample is None:
+            num_upsample = num_layers
+        assert num_upsample <= num_layers, \
+            f'num_upsample({num_upsample})must be no more than ' \
+            f'num_layers({num_layers})'
+        self.num_layers = num_layers
+        self.num_upsample = num_upsample
+        self.conv = ModuleList()
+        for i in range(num_layers):
+            self.conv.append(
+                ConvModule(
+                    in_channels,
+                    inner_channels,
+                    3,
+                    padding=1,
+                    stride=1,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    **kwargs))
+            in_channels = inner_channels
+
+    def forward(self, x):
+        num_upsample = self.num_upsample
+        for i in range(self.num_layers):
+            x = self.conv[i](x)
+            if num_upsample > 0:
+                num_upsample -= 1
+                x = F.interpolate(
+                    x, scale_factor=2, mode='bilinear', align_corners=False)
+        return x
diff --git a/mmdetection/mmdet/models/layers/csp_layer.py b/mmdetection/mmdet/models/layers/csp_layer.py
new file mode 100644
index 00000000..c8b547b8
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/csp_layer.py
@@ -0,0 +1,246 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule, DepthwiseSeparableConvModule
+from mmengine.model import BaseModule
+from torch import Tensor
+
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from .se_layer import ChannelAttention
+
+
+class DarknetBottleneck(BaseModule):
+    """The basic bottleneck block used in Darknet.
+
+    Each ResBlock consists of two ConvModules and the input is added to the
+    final output. Each ConvModule is composed of Conv, BN, and LeakyReLU.
+    The first convLayer has filter size of 1x1 and the second one has the
+    filter size of 3x3.
+
+    Args:
+        in_channels (int): The input channels of this Module.
+        out_channels (int): The output channels of this Module.
+        expansion (float): The kernel size of the convolution.
+            Defaults to 0.5.
+        add_identity (bool): Whether to add identity to the out.
+            Defaults to True.
+        use_depthwise (bool): Whether to use depthwise separable convolution.
+            Defaults to False.
+        conv_cfg (dict): Config dict for convolution layer. Defaults to None,
+            which means using conv2d.
+        norm_cfg (dict): Config dict for normalization layer.
+            Defaults to dict(type='BN').
+        act_cfg (dict): Config dict for activation layer.
+            Defaults to dict(type='Swish').
+    """
+
+    def __init__(self,
+                 in_channels: int,
+                 out_channels: int,
+                 expansion: float = 0.5,
+                 add_identity: bool = True,
+                 use_depthwise: bool = False,
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: ConfigType = dict(
+                     type='BN', momentum=0.03, eps=0.001),
+                 act_cfg: ConfigType = dict(type='Swish'),
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(init_cfg=init_cfg)
+        hidden_channels = int(out_channels * expansion)
+        conv = DepthwiseSeparableConvModule if use_depthwise else ConvModule
+        self.conv1 = ConvModule(
+            in_channels,
+            hidden_channels,
+            1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        self.conv2 = conv(
+            hidden_channels,
+            out_channels,
+            3,
+            stride=1,
+            padding=1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        self.add_identity = \
+            add_identity and in_channels == out_channels
+
+    def forward(self, x: Tensor) -> Tensor:
+        """Forward function."""
+        identity = x
+        out = self.conv1(x)
+        out = self.conv2(out)
+
+        if self.add_identity:
+            return out + identity
+        else:
+            return out
+
+
+class CSPNeXtBlock(BaseModule):
+    """The basic bottleneck block used in CSPNeXt.
+
+    Args:
+        in_channels (int): The input channels of this Module.
+        out_channels (int): The output channels of this Module.
+        expansion (float): Expand ratio of the hidden channel. Defaults to 0.5.
+        add_identity (bool): Whether to add identity to the out. Only works
+            when in_channels == out_channels. Defaults to True.
+        use_depthwise (bool): Whether to use depthwise separable convolution.
+            Defaults to False.
+        kernel_size (int): The kernel size of the second convolution layer.
+            Defaults to 5.
+        conv_cfg (dict): Config dict for convolution layer. Defaults to None,
+            which means using conv2d.
+        norm_cfg (dict): Config dict for normalization layer.
+            Defaults to dict(type='BN', momentum=0.03, eps=0.001).
+        act_cfg (dict): Config dict for activation layer.
+            Defaults to dict(type='SiLU').
+        init_cfg (:obj:`ConfigDict` or dict or list[dict] or
+            list[:obj:`ConfigDict`], optional): Initialization config dict.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 in_channels: int,
+                 out_channels: int,
+                 expansion: float = 0.5,
+                 add_identity: bool = True,
+                 use_depthwise: bool = False,
+                 kernel_size: int = 5,
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: ConfigType = dict(
+                     type='BN', momentum=0.03, eps=0.001),
+                 act_cfg: ConfigType = dict(type='SiLU'),
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(init_cfg=init_cfg)
+        hidden_channels = int(out_channels * expansion)
+        conv = DepthwiseSeparableConvModule if use_depthwise else ConvModule
+        self.conv1 = conv(
+            in_channels,
+            hidden_channels,
+            3,
+            stride=1,
+            padding=1,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        self.conv2 = DepthwiseSeparableConvModule(
+            hidden_channels,
+            out_channels,
+            kernel_size,
+            stride=1,
+            padding=kernel_size // 2,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        self.add_identity = \
+            add_identity and in_channels == out_channels
+
+    def forward(self, x: Tensor) -> Tensor:
+        """Forward function."""
+        identity = x
+        out = self.conv1(x)
+        out = self.conv2(out)
+
+        if self.add_identity:
+            return out + identity
+        else:
+            return out
+
+
+class CSPLayer(BaseModule):
+    """Cross Stage Partial Layer.
+
+    Args:
+        in_channels (int): The input channels of the CSP layer.
+        out_channels (int): The output channels of the CSP layer.
+        expand_ratio (float): Ratio to adjust the number of channels of the
+            hidden layer. Defaults to 0.5.
+        num_blocks (int): Number of blocks. Defaults to 1.
+        add_identity (bool): Whether to add identity in blocks.
+            Defaults to True.
+        use_cspnext_block (bool): Whether to use CSPNeXt block.
+            Defaults to False.
+        use_depthwise (bool): Whether to use depthwise separable convolution in
+            blocks. Defaults to False.
+        channel_attention (bool): Whether to add channel attention in each
+            stage. Defaults to True.
+        conv_cfg (dict, optional): Config dict for convolution layer.
+            Defaults to None, which means using conv2d.
+        norm_cfg (dict): Config dict for normalization layer.
+            Defaults to dict(type='BN')
+        act_cfg (dict): Config dict for activation layer.
+            Defaults to dict(type='Swish')
+        init_cfg (:obj:`ConfigDict` or dict or list[dict] or
+            list[:obj:`ConfigDict`], optional): Initialization config dict.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 in_channels: int,
+                 out_channels: int,
+                 expand_ratio: float = 0.5,
+                 num_blocks: int = 1,
+                 add_identity: bool = True,
+                 use_depthwise: bool = False,
+                 use_cspnext_block: bool = False,
+                 channel_attention: bool = False,
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: ConfigType = dict(
+                     type='BN', momentum=0.03, eps=0.001),
+                 act_cfg: ConfigType = dict(type='Swish'),
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(init_cfg=init_cfg)
+        block = CSPNeXtBlock if use_cspnext_block else DarknetBottleneck
+        mid_channels = int(out_channels * expand_ratio)
+        self.channel_attention = channel_attention
+        self.main_conv = ConvModule(
+            in_channels,
+            mid_channels,
+            1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        self.short_conv = ConvModule(
+            in_channels,
+            mid_channels,
+            1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        self.final_conv = ConvModule(
+            2 * mid_channels,
+            out_channels,
+            1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+
+        self.blocks = nn.Sequential(*[
+            block(
+                mid_channels,
+                mid_channels,
+                1.0,
+                add_identity,
+                use_depthwise,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg) for _ in range(num_blocks)
+        ])
+        if channel_attention:
+            self.attention = ChannelAttention(2 * mid_channels)
+
+    def forward(self, x: Tensor) -> Tensor:
+        """Forward function."""
+        x_short = self.short_conv(x)
+
+        x_main = self.main_conv(x)
+        x_main = self.blocks(x_main)
+
+        x_final = torch.cat((x_main, x_short), dim=1)
+
+        if self.channel_attention:
+            x_final = self.attention(x_final)
+        return self.final_conv(x_final)
diff --git a/mmdetection/mmdet/models/layers/dropblock.py b/mmdetection/mmdet/models/layers/dropblock.py
new file mode 100644
index 00000000..7938199b
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/dropblock.py
@@ -0,0 +1,86 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from mmdet.registry import MODELS
+
+eps = 1e-6
+
+
+@MODELS.register_module()
+class DropBlock(nn.Module):
+    """Randomly drop some regions of feature maps.
+
+     Please refer to the method proposed in `DropBlock
+     `_ for details.
+
+    Args:
+        drop_prob (float): The probability of dropping each block.
+        block_size (int): The size of dropped blocks.
+        warmup_iters (int): The drop probability will linearly increase
+            from `0` to `drop_prob` during the first `warmup_iters` iterations.
+            Default: 2000.
+    """
+
+    def __init__(self, drop_prob, block_size, warmup_iters=2000, **kwargs):
+        super(DropBlock, self).__init__()
+        assert block_size % 2 == 1
+        assert 0 < drop_prob <= 1
+        assert warmup_iters >= 0
+        self.drop_prob = drop_prob
+        self.block_size = block_size
+        self.warmup_iters = warmup_iters
+        self.iter_cnt = 0
+
+    def forward(self, x):
+        """
+        Args:
+            x (Tensor): Input feature map on which some areas will be randomly
+                dropped.
+
+        Returns:
+            Tensor: The tensor after DropBlock layer.
+        """
+        if not self.training:
+            return x
+        self.iter_cnt += 1
+        N, C, H, W = list(x.shape)
+        gamma = self._compute_gamma((H, W))
+        mask_shape = (N, C, H - self.block_size + 1, W - self.block_size + 1)
+        mask = torch.bernoulli(torch.full(mask_shape, gamma, device=x.device))
+
+        mask = F.pad(mask, [self.block_size // 2] * 4, value=0)
+        mask = F.max_pool2d(
+            input=mask,
+            stride=(1, 1),
+            kernel_size=(self.block_size, self.block_size),
+            padding=self.block_size // 2)
+        mask = 1 - mask
+        x = x * mask * mask.numel() / (eps + mask.sum())
+        return x
+
+    def _compute_gamma(self, feat_size):
+        """Compute the value of gamma according to paper. gamma is the
+        parameter of bernoulli distribution, which controls the number of
+        features to drop.
+
+        gamma = (drop_prob * fm_area) / (drop_area * keep_area)
+
+        Args:
+            feat_size (tuple[int, int]): The height and width of feature map.
+
+        Returns:
+            float: The value of gamma.
+        """
+        gamma = (self.drop_prob * feat_size[0] * feat_size[1])
+        gamma /= ((feat_size[0] - self.block_size + 1) *
+                  (feat_size[1] - self.block_size + 1))
+        gamma /= (self.block_size**2)
+        factor = (1.0 if self.iter_cnt > self.warmup_iters else self.iter_cnt /
+                  self.warmup_iters)
+        return gamma * factor
+
+    def extra_repr(self):
+        return (f'drop_prob={self.drop_prob}, block_size={self.block_size}, '
+                f'warmup_iters={self.warmup_iters}')
diff --git a/mmdetection/mmdet/models/layers/ema.py b/mmdetection/mmdet/models/layers/ema.py
new file mode 100644
index 00000000..73a0ca67
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/ema.py
@@ -0,0 +1,66 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+from typing import Optional
+
+import torch
+import torch.nn as nn
+from mmengine.model import ExponentialMovingAverage
+from torch import Tensor
+
+from mmdet.registry import MODELS
+
+
+@MODELS.register_module()
+class ExpMomentumEMA(ExponentialMovingAverage):
+    """Exponential moving average (EMA) with exponential momentum strategy,
+    which is used in YOLOX.
+
+    Args:
+        model (nn.Module): The model to be averaged.
+        momentum (float): The momentum used for updating ema parameter.
+            Ema's parameter are updated with the formula:
+           `averaged_param = (1-momentum) * averaged_param + momentum *
+           source_param`. Defaults to 0.0002.
+        gamma (int): Use a larger momentum early in training and gradually
+            annealing to a smaller value to update the ema model smoothly. The
+            momentum is calculated as
+            `(1 - momentum) * exp(-(1 + steps) / gamma) + momentum`.
+            Defaults to 2000.
+        interval (int): Interval between two updates. Defaults to 1.
+        device (torch.device, optional): If provided, the averaged model will
+            be stored on the :attr:`device`. Defaults to None.
+        update_buffers (bool): if True, it will compute running averages for
+            both the parameters and the buffers of the model. Defaults to
+            False.
+    """
+
+    def __init__(self,
+                 model: nn.Module,
+                 momentum: float = 0.0002,
+                 gamma: int = 2000,
+                 interval=1,
+                 device: Optional[torch.device] = None,
+                 update_buffers: bool = False) -> None:
+        super().__init__(
+            model=model,
+            momentum=momentum,
+            interval=interval,
+            device=device,
+            update_buffers=update_buffers)
+        assert gamma > 0, f'gamma must be greater than 0, but got {gamma}'
+        self.gamma = gamma
+
+    def avg_func(self, averaged_param: Tensor, source_param: Tensor,
+                 steps: int) -> None:
+        """Compute the moving average of the parameters using the exponential
+        momentum strategy.
+
+        Args:
+            averaged_param (Tensor): The averaged parameters.
+            source_param (Tensor): The source parameters.
+            steps (int): The number of times the parameters have been
+                updated.
+        """
+        momentum = (1 - self.momentum) * math.exp(
+            -float(1 + steps) / self.gamma) + self.momentum
+        averaged_param.lerp_(source_param, momentum)
diff --git a/mmdetection/mmdet/models/layers/inverted_residual.py b/mmdetection/mmdet/models/layers/inverted_residual.py
new file mode 100644
index 00000000..a174ccc8
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/inverted_residual.py
@@ -0,0 +1,130 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch.nn as nn
+import torch.utils.checkpoint as cp
+from mmcv.cnn import ConvModule
+from mmcv.cnn.bricks import DropPath
+from mmengine.model import BaseModule
+
+from .se_layer import SELayer
+
+
+class InvertedResidual(BaseModule):
+    """Inverted Residual Block.
+
+    Args:
+        in_channels (int): The input channels of this Module.
+        out_channels (int): The output channels of this Module.
+        mid_channels (int): The input channels of the depthwise convolution.
+        kernel_size (int): The kernel size of the depthwise convolution.
+            Default: 3.
+        stride (int): The stride of the depthwise convolution. Default: 1.
+        se_cfg (dict): Config dict for se layer. Default: None, which means no
+            se layer.
+        with_expand_conv (bool): Use expand conv or not. If set False,
+            mid_channels must be the same with in_channels.
+            Default: True.
+        conv_cfg (dict): Config dict for convolution layer. Default: None,
+            which means using conv2d.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN').
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='ReLU').
+        drop_path_rate (float): stochastic depth rate. Defaults to 0.
+        with_cp (bool): Use checkpoint or not. Using checkpoint will save some
+            memory while slowing down the training speed. Default: False.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None
+
+    Returns:
+        Tensor: The output tensor.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 mid_channels,
+                 kernel_size=3,
+                 stride=1,
+                 se_cfg=None,
+                 with_expand_conv=True,
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN'),
+                 act_cfg=dict(type='ReLU'),
+                 drop_path_rate=0.,
+                 with_cp=False,
+                 init_cfg=None):
+        super(InvertedResidual, self).__init__(init_cfg)
+        self.with_res_shortcut = (stride == 1 and in_channels == out_channels)
+        assert stride in [1, 2], f'stride must in [1, 2]. ' \
+            f'But received {stride}.'
+        self.with_cp = with_cp
+        self.drop_path = DropPath(
+            drop_path_rate) if drop_path_rate > 0 else nn.Identity()
+        self.with_se = se_cfg is not None
+        self.with_expand_conv = with_expand_conv
+
+        if self.with_se:
+            assert isinstance(se_cfg, dict)
+        if not self.with_expand_conv:
+            assert mid_channels == in_channels
+
+        if self.with_expand_conv:
+            self.expand_conv = ConvModule(
+                in_channels=in_channels,
+                out_channels=mid_channels,
+                kernel_size=1,
+                stride=1,
+                padding=0,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg)
+        self.depthwise_conv = ConvModule(
+            in_channels=mid_channels,
+            out_channels=mid_channels,
+            kernel_size=kernel_size,
+            stride=stride,
+            padding=kernel_size // 2,
+            groups=mid_channels,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+
+        if self.with_se:
+            self.se = SELayer(**se_cfg)
+
+        self.linear_conv = ConvModule(
+            in_channels=mid_channels,
+            out_channels=out_channels,
+            kernel_size=1,
+            stride=1,
+            padding=0,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=None)
+
+    def forward(self, x):
+
+        def _inner_forward(x):
+            out = x
+
+            if self.with_expand_conv:
+                out = self.expand_conv(out)
+
+            out = self.depthwise_conv(out)
+
+            if self.with_se:
+                out = self.se(out)
+
+            out = self.linear_conv(out)
+
+            if self.with_res_shortcut:
+                return x + self.drop_path(out)
+            else:
+                return out
+
+        if self.with_cp and x.requires_grad:
+            out = cp.checkpoint(_inner_forward, x)
+        else:
+            out = _inner_forward(x)
+
+        return out
diff --git a/mmdetection/mmdet/models/layers/matrix_nms.py b/mmdetection/mmdet/models/layers/matrix_nms.py
new file mode 100644
index 00000000..9dc8c4f7
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/matrix_nms.py
@@ -0,0 +1,121 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+
+
+def mask_matrix_nms(masks,
+                    labels,
+                    scores,
+                    filter_thr=-1,
+                    nms_pre=-1,
+                    max_num=-1,
+                    kernel='gaussian',
+                    sigma=2.0,
+                    mask_area=None):
+    """Matrix NMS for multi-class masks.
+
+    Args:
+        masks (Tensor): Has shape (num_instances, h, w)
+        labels (Tensor): Labels of corresponding masks,
+            has shape (num_instances,).
+        scores (Tensor): Mask scores of corresponding masks,
+            has shape (num_instances).
+        filter_thr (float): Score threshold to filter the masks
+            after matrix nms. Default: -1, which means do not
+            use filter_thr.
+        nms_pre (int): The max number of instances to do the matrix nms.
+            Default: -1, which means do not use nms_pre.
+        max_num (int, optional): If there are more than max_num masks after
+            matrix, only top max_num will be kept. Default: -1, which means
+            do not use max_num.
+        kernel (str): 'linear' or 'gaussian'.
+        sigma (float): std in gaussian method.
+        mask_area (Tensor): The sum of seg_masks.
+
+    Returns:
+        tuple(Tensor): Processed mask results.
+
+            - scores (Tensor): Updated scores, has shape (n,).
+            - labels (Tensor): Remained labels, has shape (n,).
+            - masks (Tensor): Remained masks, has shape (n, w, h).
+            - keep_inds (Tensor): The indices number of
+                the remaining mask in the input mask, has shape (n,).
+    """
+    assert len(labels) == len(masks) == len(scores)
+    if len(labels) == 0:
+        return scores.new_zeros(0), labels.new_zeros(0), masks.new_zeros(
+            0, *masks.shape[-2:]), labels.new_zeros(0)
+    if mask_area is None:
+        mask_area = masks.sum((1, 2)).float()
+    else:
+        assert len(masks) == len(mask_area)
+
+    # sort and keep top nms_pre
+    scores, sort_inds = torch.sort(scores, descending=True)
+
+    keep_inds = sort_inds
+    if nms_pre > 0 and len(sort_inds) > nms_pre:
+        sort_inds = sort_inds[:nms_pre]
+        keep_inds = keep_inds[:nms_pre]
+        scores = scores[:nms_pre]
+    masks = masks[sort_inds]
+    mask_area = mask_area[sort_inds]
+    labels = labels[sort_inds]
+
+    num_masks = len(labels)
+    flatten_masks = masks.reshape(num_masks, -1).float()
+    # inter.
+    inter_matrix = torch.mm(flatten_masks, flatten_masks.transpose(1, 0))
+    expanded_mask_area = mask_area.expand(num_masks, num_masks)
+    # Upper triangle iou matrix.
+    iou_matrix = (inter_matrix /
+                  (expanded_mask_area + expanded_mask_area.transpose(1, 0) -
+                   inter_matrix)).triu(diagonal=1)
+    # label_specific matrix.
+    expanded_labels = labels.expand(num_masks, num_masks)
+    # Upper triangle label matrix.
+    label_matrix = (expanded_labels == expanded_labels.transpose(
+        1, 0)).triu(diagonal=1)
+
+    # IoU compensation
+    compensate_iou, _ = (iou_matrix * label_matrix).max(0)
+    compensate_iou = compensate_iou.expand(num_masks,
+                                           num_masks).transpose(1, 0)
+
+    # IoU decay
+    decay_iou = iou_matrix * label_matrix
+
+    # Calculate the decay_coefficient
+    if kernel == 'gaussian':
+        decay_matrix = torch.exp(-1 * sigma * (decay_iou**2))
+        compensate_matrix = torch.exp(-1 * sigma * (compensate_iou**2))
+        decay_coefficient, _ = (decay_matrix / compensate_matrix).min(0)
+    elif kernel == 'linear':
+        decay_matrix = (1 - decay_iou) / (1 - compensate_iou)
+        decay_coefficient, _ = decay_matrix.min(0)
+    else:
+        raise NotImplementedError(
+            f'{kernel} kernel is not supported in matrix nms!')
+    # update the score.
+    scores = scores * decay_coefficient
+
+    if filter_thr > 0:
+        keep = scores >= filter_thr
+        keep_inds = keep_inds[keep]
+        if not keep.any():
+            return scores.new_zeros(0), labels.new_zeros(0), masks.new_zeros(
+                0, *masks.shape[-2:]), labels.new_zeros(0)
+        masks = masks[keep]
+        scores = scores[keep]
+        labels = labels[keep]
+
+    # sort and keep top max_num
+    scores, sort_inds = torch.sort(scores, descending=True)
+    keep_inds = keep_inds[sort_inds]
+    if max_num > 0 and len(sort_inds) > max_num:
+        sort_inds = sort_inds[:max_num]
+        keep_inds = keep_inds[:max_num]
+        scores = scores[:max_num]
+    masks = masks[sort_inds]
+    labels = labels[sort_inds]
+
+    return scores, labels, masks, keep_inds
diff --git a/mmdetection/mmdet/models/layers/msdeformattn_pixel_decoder.py b/mmdetection/mmdet/models/layers/msdeformattn_pixel_decoder.py
new file mode 100644
index 00000000..a67dc3c4
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/msdeformattn_pixel_decoder.py
@@ -0,0 +1,246 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import Conv2d, ConvModule
+from mmcv.cnn.bricks.transformer import MultiScaleDeformableAttention
+from mmengine.model import (BaseModule, ModuleList, caffe2_xavier_init,
+                            normal_init, xavier_init)
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptMultiConfig
+from ..task_modules.prior_generators import MlvlPointGenerator
+from .positional_encoding import SinePositionalEncoding
+from .transformer import Mask2FormerTransformerEncoder
+
+
+@MODELS.register_module()
+class MSDeformAttnPixelDecoder(BaseModule):
+    """Pixel decoder with multi-scale deformable attention.
+
+    Args:
+        in_channels (list[int] | tuple[int]): Number of channels in the
+            input feature maps.
+        strides (list[int] | tuple[int]): Output strides of feature from
+            backbone.
+        feat_channels (int): Number of channels for feature.
+        out_channels (int): Number of channels for output.
+        num_outs (int): Number of output scales.
+        norm_cfg (:obj:`ConfigDict` or dict): Config for normalization.
+            Defaults to dict(type='GN', num_groups=32).
+        act_cfg (:obj:`ConfigDict` or dict): Config for activation.
+            Defaults to dict(type='ReLU').
+        encoder (:obj:`ConfigDict` or dict): Config for transformer
+            encoder. Defaults to None.
+        positional_encoding (:obj:`ConfigDict` or dict): Config for
+            transformer encoder position encoding. Defaults to
+            dict(num_feats=128, normalize=True).
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict], optional): Initialization config dict. Defaults to None.
+    """
+
+    def __init__(self,
+                 in_channels: Union[List[int],
+                                    Tuple[int]] = [256, 512, 1024, 2048],
+                 strides: Union[List[int], Tuple[int]] = [4, 8, 16, 32],
+                 feat_channels: int = 256,
+                 out_channels: int = 256,
+                 num_outs: int = 3,
+                 norm_cfg: ConfigType = dict(type='GN', num_groups=32),
+                 act_cfg: ConfigType = dict(type='ReLU'),
+                 encoder: ConfigType = None,
+                 positional_encoding: ConfigType = dict(
+                     num_feats=128, normalize=True),
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.strides = strides
+        self.num_input_levels = len(in_channels)
+        self.num_encoder_levels = \
+            encoder.layer_cfg.self_attn_cfg.num_levels
+        assert self.num_encoder_levels >= 1, \
+            'num_levels in attn_cfgs must be at least one'
+        input_conv_list = []
+        # from top to down (low to high resolution)
+        for i in range(self.num_input_levels - 1,
+                       self.num_input_levels - self.num_encoder_levels - 1,
+                       -1):
+            input_conv = ConvModule(
+                in_channels[i],
+                feat_channels,
+                kernel_size=1,
+                norm_cfg=norm_cfg,
+                act_cfg=None,
+                bias=True)
+            input_conv_list.append(input_conv)
+        self.input_convs = ModuleList(input_conv_list)
+
+        self.encoder = Mask2FormerTransformerEncoder(**encoder)
+        self.postional_encoding = SinePositionalEncoding(**positional_encoding)
+        # high resolution to low resolution
+        self.level_encoding = nn.Embedding(self.num_encoder_levels,
+                                           feat_channels)
+
+        # fpn-like structure
+        self.lateral_convs = ModuleList()
+        self.output_convs = ModuleList()
+        self.use_bias = norm_cfg is None
+        # from top to down (low to high resolution)
+        # fpn for the rest features that didn't pass in encoder
+        for i in range(self.num_input_levels - self.num_encoder_levels - 1, -1,
+                       -1):
+            lateral_conv = ConvModule(
+                in_channels[i],
+                feat_channels,
+                kernel_size=1,
+                bias=self.use_bias,
+                norm_cfg=norm_cfg,
+                act_cfg=None)
+            output_conv = ConvModule(
+                feat_channels,
+                feat_channels,
+                kernel_size=3,
+                stride=1,
+                padding=1,
+                bias=self.use_bias,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg)
+            self.lateral_convs.append(lateral_conv)
+            self.output_convs.append(output_conv)
+
+        self.mask_feature = Conv2d(
+            feat_channels, out_channels, kernel_size=1, stride=1, padding=0)
+
+        self.num_outs = num_outs
+        self.point_generator = MlvlPointGenerator(strides)
+
+    def init_weights(self) -> None:
+        """Initialize weights."""
+        for i in range(0, self.num_encoder_levels):
+            xavier_init(
+                self.input_convs[i].conv,
+                gain=1,
+                bias=0,
+                distribution='uniform')
+
+        for i in range(0, self.num_input_levels - self.num_encoder_levels):
+            caffe2_xavier_init(self.lateral_convs[i].conv, bias=0)
+            caffe2_xavier_init(self.output_convs[i].conv, bias=0)
+
+        caffe2_xavier_init(self.mask_feature, bias=0)
+
+        normal_init(self.level_encoding, mean=0, std=1)
+        for p in self.encoder.parameters():
+            if p.dim() > 1:
+                nn.init.xavier_normal_(p)
+
+        # init_weights defined in MultiScaleDeformableAttention
+        for m in self.encoder.layers.modules():
+            if isinstance(m, MultiScaleDeformableAttention):
+                m.init_weights()
+
+    def forward(self, feats: List[Tensor]) -> Tuple[Tensor, Tensor]:
+        """
+        Args:
+            feats (list[Tensor]): Feature maps of each level. Each has
+                shape of (batch_size, c, h, w).
+
+        Returns:
+            tuple: A tuple containing the following:
+
+                - mask_feature (Tensor): shape (batch_size, c, h, w).
+                - multi_scale_features (list[Tensor]): Multi scale \
+                        features, each in shape (batch_size, c, h, w).
+        """
+        # generate padding mask for each level, for each image
+        batch_size = feats[0].shape[0]
+        encoder_input_list = []
+        padding_mask_list = []
+        level_positional_encoding_list = []
+        spatial_shapes = []
+        reference_points_list = []
+        for i in range(self.num_encoder_levels):
+            level_idx = self.num_input_levels - i - 1
+            feat = feats[level_idx]
+            feat_projected = self.input_convs[i](feat)
+            feat_hw = torch._shape_as_tensor(feat)[2:].to(feat.device)
+
+            # no padding
+            padding_mask_resized = feat.new_zeros(
+                (batch_size, ) + feat.shape[-2:], dtype=torch.bool)
+            pos_embed = self.postional_encoding(padding_mask_resized)
+            level_embed = self.level_encoding.weight[i]
+            level_pos_embed = level_embed.view(1, -1, 1, 1) + pos_embed
+            # (h_i * w_i, 2)
+            reference_points = self.point_generator.single_level_grid_priors(
+                feat.shape[-2:], level_idx, device=feat.device)
+            # normalize
+            feat_wh = feat_hw.unsqueeze(0).flip(dims=[0, 1])
+            factor = feat_wh * self.strides[level_idx]
+            reference_points = reference_points / factor
+
+            # shape (batch_size, c, h_i, w_i) -> (h_i * w_i, batch_size, c)
+            feat_projected = feat_projected.flatten(2).permute(0, 2, 1)
+            level_pos_embed = level_pos_embed.flatten(2).permute(0, 2, 1)
+            padding_mask_resized = padding_mask_resized.flatten(1)
+
+            encoder_input_list.append(feat_projected)
+            padding_mask_list.append(padding_mask_resized)
+            level_positional_encoding_list.append(level_pos_embed)
+            spatial_shapes.append(feat_hw)
+            reference_points_list.append(reference_points)
+        # shape (batch_size, total_num_queries),
+        # total_num_queries=sum([., h_i * w_i,.])
+        padding_masks = torch.cat(padding_mask_list, dim=1)
+        # shape (total_num_queries, batch_size, c)
+        encoder_inputs = torch.cat(encoder_input_list, dim=1)
+        level_positional_encodings = torch.cat(
+            level_positional_encoding_list, dim=1)
+        # shape (num_encoder_levels, 2), from low
+        # resolution to high resolution
+        num_queries_per_level = [e[0] * e[1] for e in spatial_shapes]
+        spatial_shapes = torch.cat(spatial_shapes).view(-1, 2)
+        # shape (0, h_0*w_0, h_0*w_0+h_1*w_1, ...)
+        level_start_index = torch.cat((spatial_shapes.new_zeros(
+            (1, )), spatial_shapes.prod(1).cumsum(0)[:-1]))
+        reference_points = torch.cat(reference_points_list, dim=0)
+        reference_points = reference_points[None, :, None].repeat(
+            batch_size, 1, self.num_encoder_levels, 1)
+        valid_radios = reference_points.new_ones(
+            (batch_size, self.num_encoder_levels, 2))
+        # shape (num_total_queries, batch_size, c)
+        memory = self.encoder(
+            query=encoder_inputs,
+            query_pos=level_positional_encodings,
+            key_padding_mask=padding_masks,
+            spatial_shapes=spatial_shapes,
+            reference_points=reference_points,
+            level_start_index=level_start_index,
+            valid_ratios=valid_radios)
+        # (batch_size, c, num_total_queries)
+        memory = memory.permute(0, 2, 1)
+
+        # from low resolution to high resolution
+        outs = torch.split(memory, num_queries_per_level, dim=-1)
+        outs = [
+            x.reshape(batch_size, -1, spatial_shapes[i][0],
+                      spatial_shapes[i][1]) for i, x in enumerate(outs)
+        ]
+
+        for i in range(self.num_input_levels - self.num_encoder_levels - 1, -1,
+                       -1):
+            x = feats[i]
+            cur_feat = self.lateral_convs[i](x)
+            y = cur_feat + F.interpolate(
+                outs[-1],
+                size=cur_feat.shape[-2:],
+                mode='bilinear',
+                align_corners=False)
+            y = self.output_convs[i](y)
+            outs.append(y)
+        multi_scale_features = outs[:self.num_outs]
+
+        mask_feature = self.mask_feature(outs[-1])
+        return mask_feature, multi_scale_features
diff --git a/mmdetection/mmdet/models/layers/normed_predictor.py b/mmdetection/mmdet/models/layers/normed_predictor.py
new file mode 100644
index 00000000..592194b1
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/normed_predictor.py
@@ -0,0 +1,99 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmengine.utils import digit_version
+from torch import Tensor
+
+from mmdet.registry import MODELS
+
+MODELS.register_module('Linear', module=nn.Linear)
+
+
+@MODELS.register_module(name='NormedLinear')
+class NormedLinear(nn.Linear):
+    """Normalized Linear Layer.
+
+    Args:
+        tempeature (float, optional): Tempeature term. Defaults to 20.
+        power (int, optional): Power term. Defaults to 1.0.
+        eps (float, optional): The minimal value of divisor to
+             keep numerical stability. Defaults to 1e-6.
+    """
+
+    def __init__(self,
+                 *args,
+                 tempearture: float = 20,
+                 power: int = 1.0,
+                 eps: float = 1e-6,
+                 **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.tempearture = tempearture
+        self.power = power
+        self.eps = eps
+        self.init_weights()
+
+    def init_weights(self) -> None:
+        """Initialize the weights."""
+        nn.init.normal_(self.weight, mean=0, std=0.01)
+        if self.bias is not None:
+            nn.init.constant_(self.bias, 0)
+
+    def forward(self, x: Tensor) -> Tensor:
+        """Forward function for `NormedLinear`."""
+        weight_ = self.weight / (
+            self.weight.norm(dim=1, keepdim=True).pow(self.power) + self.eps)
+        x_ = x / (x.norm(dim=1, keepdim=True).pow(self.power) + self.eps)
+        x_ = x_ * self.tempearture
+
+        return F.linear(x_, weight_, self.bias)
+
+
+@MODELS.register_module(name='NormedConv2d')
+class NormedConv2d(nn.Conv2d):
+    """Normalized Conv2d Layer.
+
+    Args:
+        tempeature (float, optional): Tempeature term. Defaults to 20.
+        power (int, optional): Power term. Defaults to 1.0.
+        eps (float, optional): The minimal value of divisor to
+             keep numerical stability. Defaults to 1e-6.
+        norm_over_kernel (bool, optional): Normalize over kernel.
+             Defaults to False.
+    """
+
+    def __init__(self,
+                 *args,
+                 tempearture: float = 20,
+                 power: int = 1.0,
+                 eps: float = 1e-6,
+                 norm_over_kernel: bool = False,
+                 **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.tempearture = tempearture
+        self.power = power
+        self.norm_over_kernel = norm_over_kernel
+        self.eps = eps
+
+    def forward(self, x: Tensor) -> Tensor:
+        """Forward function for `NormedConv2d`."""
+        if not self.norm_over_kernel:
+            weight_ = self.weight / (
+                self.weight.norm(dim=1, keepdim=True).pow(self.power) +
+                self.eps)
+        else:
+            weight_ = self.weight / (
+                self.weight.view(self.weight.size(0), -1).norm(
+                    dim=1, keepdim=True).pow(self.power)[..., None, None] +
+                self.eps)
+        x_ = x / (x.norm(dim=1, keepdim=True).pow(self.power) + self.eps)
+        x_ = x_ * self.tempearture
+
+        if hasattr(self, 'conv2d_forward'):
+            x_ = self.conv2d_forward(x_, weight_)
+        else:
+            if digit_version(torch.__version__) >= digit_version('1.8'):
+                x_ = self._conv_forward(x_, weight_, self.bias)
+            else:
+                x_ = self._conv_forward(x_, weight_)
+        return x_
diff --git a/mmdetection/mmdet/models/layers/pixel_decoder.py b/mmdetection/mmdet/models/layers/pixel_decoder.py
new file mode 100644
index 00000000..fb614340
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/pixel_decoder.py
@@ -0,0 +1,249 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import Conv2d, ConvModule
+from mmengine.model import BaseModule, ModuleList, caffe2_xavier_init
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptMultiConfig
+from .positional_encoding import SinePositionalEncoding
+from .transformer import DetrTransformerEncoder
+
+
+@MODELS.register_module()
+class PixelDecoder(BaseModule):
+    """Pixel decoder with a structure like fpn.
+
+    Args:
+        in_channels (list[int] | tuple[int]): Number of channels in the
+            input feature maps.
+        feat_channels (int): Number channels for feature.
+        out_channels (int): Number channels for output.
+        norm_cfg (:obj:`ConfigDict` or dict): Config for normalization.
+            Defaults to dict(type='GN', num_groups=32).
+        act_cfg (:obj:`ConfigDict` or dict): Config for activation.
+            Defaults to dict(type='ReLU').
+        encoder (:obj:`ConfigDict` or dict): Config for transorformer
+            encoder.Defaults to None.
+        positional_encoding (:obj:`ConfigDict` or dict): Config for
+            transformer encoder position encoding. Defaults to
+            dict(type='SinePositionalEncoding', num_feats=128,
+            normalize=True).
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict], optional): Initialization config dict. Defaults to None.
+    """
+
+    def __init__(self,
+                 in_channels: Union[List[int], Tuple[int]],
+                 feat_channels: int,
+                 out_channels: int,
+                 norm_cfg: ConfigType = dict(type='GN', num_groups=32),
+                 act_cfg: ConfigType = dict(type='ReLU'),
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.in_channels = in_channels
+        self.num_inputs = len(in_channels)
+        self.lateral_convs = ModuleList()
+        self.output_convs = ModuleList()
+        self.use_bias = norm_cfg is None
+        for i in range(0, self.num_inputs - 1):
+            lateral_conv = ConvModule(
+                in_channels[i],
+                feat_channels,
+                kernel_size=1,
+                bias=self.use_bias,
+                norm_cfg=norm_cfg,
+                act_cfg=None)
+            output_conv = ConvModule(
+                feat_channels,
+                feat_channels,
+                kernel_size=3,
+                stride=1,
+                padding=1,
+                bias=self.use_bias,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg)
+            self.lateral_convs.append(lateral_conv)
+            self.output_convs.append(output_conv)
+
+        self.last_feat_conv = ConvModule(
+            in_channels[-1],
+            feat_channels,
+            kernel_size=3,
+            padding=1,
+            stride=1,
+            bias=self.use_bias,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+        self.mask_feature = Conv2d(
+            feat_channels, out_channels, kernel_size=3, stride=1, padding=1)
+
+    def init_weights(self) -> None:
+        """Initialize weights."""
+        for i in range(0, self.num_inputs - 2):
+            caffe2_xavier_init(self.lateral_convs[i].conv, bias=0)
+            caffe2_xavier_init(self.output_convs[i].conv, bias=0)
+
+        caffe2_xavier_init(self.mask_feature, bias=0)
+        caffe2_xavier_init(self.last_feat_conv, bias=0)
+
+    def forward(self, feats: List[Tensor],
+                batch_img_metas: List[dict]) -> Tuple[Tensor, Tensor]:
+        """
+        Args:
+            feats (list[Tensor]): Feature maps of each level. Each has
+                shape of (batch_size, c, h, w).
+            batch_img_metas (list[dict]): List of image information.
+                Pass in for creating more accurate padding mask. Not
+                used here.
+
+        Returns:
+            tuple[Tensor, Tensor]: a tuple containing the following:
+
+                - mask_feature (Tensor): Shape (batch_size, c, h, w).
+                - memory (Tensor): Output of last stage of backbone.\
+                        Shape (batch_size, c, h, w).
+        """
+        y = self.last_feat_conv(feats[-1])
+        for i in range(self.num_inputs - 2, -1, -1):
+            x = feats[i]
+            cur_feat = self.lateral_convs[i](x)
+            y = cur_feat + \
+                F.interpolate(y, size=cur_feat.shape[-2:], mode='nearest')
+            y = self.output_convs[i](y)
+
+        mask_feature = self.mask_feature(y)
+        memory = feats[-1]
+        return mask_feature, memory
+
+
+@MODELS.register_module()
+class TransformerEncoderPixelDecoder(PixelDecoder):
+    """Pixel decoder with transormer encoder inside.
+
+    Args:
+        in_channels (list[int] | tuple[int]): Number of channels in the
+            input feature maps.
+        feat_channels (int): Number channels for feature.
+        out_channels (int): Number channels for output.
+        norm_cfg (:obj:`ConfigDict` or dict): Config for normalization.
+            Defaults to dict(type='GN', num_groups=32).
+        act_cfg (:obj:`ConfigDict` or dict): Config for activation.
+            Defaults to dict(type='ReLU').
+        encoder (:obj:`ConfigDict` or dict): Config for transformer encoder.
+            Defaults to None.
+        positional_encoding (:obj:`ConfigDict` or dict): Config for
+            transformer encoder position encoding. Defaults to
+            dict(num_feats=128, normalize=True).
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict], optional): Initialization config dict. Defaults to None.
+    """
+
+    def __init__(self,
+                 in_channels: Union[List[int], Tuple[int]],
+                 feat_channels: int,
+                 out_channels: int,
+                 norm_cfg: ConfigType = dict(type='GN', num_groups=32),
+                 act_cfg: ConfigType = dict(type='ReLU'),
+                 encoder: ConfigType = None,
+                 positional_encoding: ConfigType = dict(
+                     num_feats=128, normalize=True),
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            in_channels=in_channels,
+            feat_channels=feat_channels,
+            out_channels=out_channels,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg,
+            init_cfg=init_cfg)
+        self.last_feat_conv = None
+
+        self.encoder = DetrTransformerEncoder(**encoder)
+        self.encoder_embed_dims = self.encoder.embed_dims
+        assert self.encoder_embed_dims == feat_channels, 'embed_dims({}) of ' \
+            'tranformer encoder must equal to feat_channels({})'.format(
+                feat_channels, self.encoder_embed_dims)
+        self.positional_encoding = SinePositionalEncoding(
+            **positional_encoding)
+        self.encoder_in_proj = Conv2d(
+            in_channels[-1], feat_channels, kernel_size=1)
+        self.encoder_out_proj = ConvModule(
+            feat_channels,
+            feat_channels,
+            kernel_size=3,
+            stride=1,
+            padding=1,
+            bias=self.use_bias,
+            norm_cfg=norm_cfg,
+            act_cfg=act_cfg)
+
+    def init_weights(self) -> None:
+        """Initialize weights."""
+        for i in range(0, self.num_inputs - 2):
+            caffe2_xavier_init(self.lateral_convs[i].conv, bias=0)
+            caffe2_xavier_init(self.output_convs[i].conv, bias=0)
+
+        caffe2_xavier_init(self.mask_feature, bias=0)
+        caffe2_xavier_init(self.encoder_in_proj, bias=0)
+        caffe2_xavier_init(self.encoder_out_proj.conv, bias=0)
+
+        for p in self.encoder.parameters():
+            if p.dim() > 1:
+                nn.init.xavier_uniform_(p)
+
+    def forward(self, feats: List[Tensor],
+                batch_img_metas: List[dict]) -> Tuple[Tensor, Tensor]:
+        """
+        Args:
+            feats (list[Tensor]): Feature maps of each level. Each has
+                shape of (batch_size, c, h, w).
+            batch_img_metas (list[dict]): List of image information. Pass in
+                for creating more accurate padding mask.
+
+        Returns:
+            tuple: a tuple containing the following:
+
+                - mask_feature (Tensor): shape (batch_size, c, h, w).
+                - memory (Tensor): shape (batch_size, c, h, w).
+        """
+        feat_last = feats[-1]
+        bs, c, h, w = feat_last.shape
+        input_img_h, input_img_w = batch_img_metas[0]['batch_input_shape']
+        padding_mask = feat_last.new_ones((bs, input_img_h, input_img_w),
+                                          dtype=torch.float32)
+        for i in range(bs):
+            img_h, img_w = batch_img_metas[i]['img_shape']
+            padding_mask[i, :img_h, :img_w] = 0
+        padding_mask = F.interpolate(
+            padding_mask.unsqueeze(1),
+            size=feat_last.shape[-2:],
+            mode='nearest').to(torch.bool).squeeze(1)
+
+        pos_embed = self.positional_encoding(padding_mask)
+        feat_last = self.encoder_in_proj(feat_last)
+        # (batch_size, c, h, w) -> (batch_size, num_queries, c)
+        feat_last = feat_last.flatten(2).permute(0, 2, 1)
+        pos_embed = pos_embed.flatten(2).permute(0, 2, 1)
+        # (batch_size, h, w) -> (batch_size, h*w)
+        padding_mask = padding_mask.flatten(1)
+        memory = self.encoder(
+            query=feat_last,
+            query_pos=pos_embed,
+            key_padding_mask=padding_mask)
+        # (batch_size, num_queries, c) -> (batch_size, c, h, w)
+        memory = memory.permute(0, 2, 1).view(bs, self.encoder_embed_dims, h,
+                                              w)
+        y = self.encoder_out_proj(memory)
+        for i in range(self.num_inputs - 2, -1, -1):
+            x = feats[i]
+            cur_feat = self.lateral_convs[i](x)
+            y = cur_feat + \
+                F.interpolate(y, size=cur_feat.shape[-2:], mode='nearest')
+            y = self.output_convs[i](y)
+
+        mask_feature = self.mask_feature(y)
+        return mask_feature, memory
diff --git a/mmdetection/mmdet/models/layers/positional_encoding.py b/mmdetection/mmdet/models/layers/positional_encoding.py
new file mode 100644
index 00000000..87080d81
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/positional_encoding.py
@@ -0,0 +1,269 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+from typing import Optional
+
+import torch
+import torch.nn as nn
+from mmengine.model import BaseModule
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import MultiConfig, OptMultiConfig
+
+
+@MODELS.register_module()
+class SinePositionalEncoding(BaseModule):
+    """Position encoding with sine and cosine functions.
+
+    See `End-to-End Object Detection with Transformers
+    `_ for details.
+
+    Args:
+        num_feats (int): The feature dimension for each position
+            along x-axis or y-axis. Note the final returned dimension
+            for each position is 2 times of this value.
+        temperature (int, optional): The temperature used for scaling
+            the position embedding. Defaults to 10000.
+        normalize (bool, optional): Whether to normalize the position
+            embedding. Defaults to False.
+        scale (float, optional): A scale factor that scales the position
+            embedding. The scale will be used only when `normalize` is True.
+            Defaults to 2*pi.
+        eps (float, optional): A value added to the denominator for
+            numerical stability. Defaults to 1e-6.
+        offset (float): offset add to embed when do the normalization.
+            Defaults to 0.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Defaults to None
+    """
+
+    def __init__(self,
+                 num_feats: int,
+                 temperature: int = 10000,
+                 normalize: bool = False,
+                 scale: float = 2 * math.pi,
+                 eps: float = 1e-6,
+                 offset: float = 0.,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(init_cfg=init_cfg)
+        if normalize:
+            assert isinstance(scale, (float, int)), 'when normalize is set,' \
+                'scale should be provided and in float or int type, ' \
+                f'found {type(scale)}'
+        self.num_feats = num_feats
+        self.temperature = temperature
+        self.normalize = normalize
+        self.scale = scale
+        self.eps = eps
+        self.offset = offset
+
+    def forward(self, mask: Tensor, input: Optional[Tensor] = None) -> Tensor:
+        """Forward function for `SinePositionalEncoding`.
+
+        Args:
+            mask (Tensor): ByteTensor mask. Non-zero values representing
+                ignored positions, while zero values means valid positions
+                for this image. Shape [bs, h, w].
+            input (Tensor, optional): Input image/feature Tensor.
+                Shape [bs, c, h, w]
+
+        Returns:
+            pos (Tensor): Returned position embedding with shape
+                [bs, num_feats*2, h, w].
+        """
+        assert not (mask is None and input is None)
+
+        if mask is not None:
+            B, H, W = mask.size()
+            device = mask.device
+            # For convenience of exporting to ONNX,
+            # it's required to convert
+            # `masks` from bool to int.
+            mask = mask.to(torch.int)
+            not_mask = 1 - mask  # logical_not
+            y_embed = not_mask.cumsum(1, dtype=torch.float32)
+            x_embed = not_mask.cumsum(2, dtype=torch.float32)
+        else:
+            # single image or batch image with no padding
+            B, _, H, W = input.shape
+            device = input.device
+            x_embed = torch.arange(
+                1, W + 1, dtype=torch.float32, device=device)
+            x_embed = x_embed.view(1, 1, -1).repeat(B, H, 1)
+            y_embed = torch.arange(
+                1, H + 1, dtype=torch.float32, device=device)
+            y_embed = y_embed.view(1, -1, 1).repeat(B, 1, W)
+        if self.normalize:
+            y_embed = (y_embed + self.offset) / \
+                      (y_embed[:, -1:, :] + self.eps) * self.scale
+            x_embed = (x_embed + self.offset) / \
+                      (x_embed[:, :, -1:] + self.eps) * self.scale
+        dim_t = torch.arange(
+            self.num_feats, dtype=torch.float32, device=device)
+        dim_t = self.temperature**(2 * (dim_t // 2) / self.num_feats)
+        pos_x = x_embed[:, :, :, None] / dim_t
+        pos_y = y_embed[:, :, :, None] / dim_t
+        # use `view` instead of `flatten` for dynamically exporting to ONNX
+
+        pos_x = torch.stack(
+            (pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()),
+            dim=4).view(B, H, W, -1)
+        pos_y = torch.stack(
+            (pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()),
+            dim=4).view(B, H, W, -1)
+        pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2)
+        return pos
+
+    def __repr__(self) -> str:
+        """str: a string that describes the module"""
+        repr_str = self.__class__.__name__
+        repr_str += f'(num_feats={self.num_feats}, '
+        repr_str += f'temperature={self.temperature}, '
+        repr_str += f'normalize={self.normalize}, '
+        repr_str += f'scale={self.scale}, '
+        repr_str += f'eps={self.eps})'
+        return repr_str
+
+
+@MODELS.register_module()
+class LearnedPositionalEncoding(BaseModule):
+    """Position embedding with learnable embedding weights.
+
+    Args:
+        num_feats (int): The feature dimension for each position
+            along x-axis or y-axis. The final returned dimension for
+            each position is 2 times of this value.
+        row_num_embed (int, optional): The dictionary size of row embeddings.
+            Defaults to 50.
+        col_num_embed (int, optional): The dictionary size of col embeddings.
+            Defaults to 50.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+    """
+
+    def __init__(
+        self,
+        num_feats: int,
+        row_num_embed: int = 50,
+        col_num_embed: int = 50,
+        init_cfg: MultiConfig = dict(type='Uniform', layer='Embedding')
+    ) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.row_embed = nn.Embedding(row_num_embed, num_feats)
+        self.col_embed = nn.Embedding(col_num_embed, num_feats)
+        self.num_feats = num_feats
+        self.row_num_embed = row_num_embed
+        self.col_num_embed = col_num_embed
+
+    def forward(self, mask: Tensor) -> Tensor:
+        """Forward function for `LearnedPositionalEncoding`.
+
+        Args:
+            mask (Tensor): ByteTensor mask. Non-zero values representing
+                ignored positions, while zero values means valid positions
+                for this image. Shape [bs, h, w].
+
+        Returns:
+            pos (Tensor): Returned position embedding with shape
+                [bs, num_feats*2, h, w].
+        """
+        h, w = mask.shape[-2:]
+        x = torch.arange(w, device=mask.device)
+        y = torch.arange(h, device=mask.device)
+        x_embed = self.col_embed(x)
+        y_embed = self.row_embed(y)
+        pos = torch.cat(
+            (x_embed.unsqueeze(0).repeat(h, 1, 1), y_embed.unsqueeze(1).repeat(
+                1, w, 1)),
+            dim=-1).permute(2, 0,
+                            1).unsqueeze(0).repeat(mask.shape[0], 1, 1, 1)
+        return pos
+
+    def __repr__(self) -> str:
+        """str: a string that describes the module"""
+        repr_str = self.__class__.__name__
+        repr_str += f'(num_feats={self.num_feats}, '
+        repr_str += f'row_num_embed={self.row_num_embed}, '
+        repr_str += f'col_num_embed={self.col_num_embed})'
+        return repr_str
+
+
+@MODELS.register_module()
+class SinePositionalEncoding3D(SinePositionalEncoding):
+    """Position encoding with sine and cosine functions.
+
+    See `End-to-End Object Detection with Transformers
+    `_ for details.
+
+    Args:
+        num_feats (int): The feature dimension for each position
+            along x-axis or y-axis. Note the final returned dimension
+            for each position is 2 times of this value.
+        temperature (int, optional): The temperature used for scaling
+            the position embedding. Defaults to 10000.
+        normalize (bool, optional): Whether to normalize the position
+            embedding. Defaults to False.
+        scale (float, optional): A scale factor that scales the position
+            embedding. The scale will be used only when `normalize` is True.
+            Defaults to 2*pi.
+        eps (float, optional): A value added to the denominator for
+            numerical stability. Defaults to 1e-6.
+        offset (float): offset add to embed when do the normalization.
+            Defaults to 0.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Defaults to None.
+    """
+
+    def forward(self, mask: Tensor) -> Tensor:
+        """Forward function for `SinePositionalEncoding3D`.
+
+        Args:
+            mask (Tensor): ByteTensor mask. Non-zero values representing
+                ignored positions, while zero values means valid positions
+                for this image. Shape [bs, t, h, w].
+
+        Returns:
+            pos (Tensor): Returned position embedding with shape
+                [bs, num_feats*2, h, w].
+        """
+        assert mask.dim() == 4,\
+            f'{mask.shape} should be a 4-dimensional Tensor,' \
+            f' got {mask.dim()}-dimensional Tensor instead '
+        # For convenience of exporting to ONNX, it's required to convert
+        # `masks` from bool to int.
+        mask = mask.to(torch.int)
+        not_mask = 1 - mask  # logical_not
+        z_embed = not_mask.cumsum(1, dtype=torch.float32)
+        y_embed = not_mask.cumsum(2, dtype=torch.float32)
+        x_embed = not_mask.cumsum(3, dtype=torch.float32)
+        if self.normalize:
+            z_embed = (z_embed + self.offset) / \
+                      (z_embed[:, -1:, :, :] + self.eps) * self.scale
+            y_embed = (y_embed + self.offset) / \
+                      (y_embed[:, :, -1:, :] + self.eps) * self.scale
+            x_embed = (x_embed + self.offset) / \
+                      (x_embed[:, :, :, -1:] + self.eps) * self.scale
+        dim_t = torch.arange(
+            self.num_feats, dtype=torch.float32, device=mask.device)
+        dim_t = self.temperature**(2 * (dim_t // 2) / self.num_feats)
+
+        dim_t_z = torch.arange((self.num_feats * 2),
+                               dtype=torch.float32,
+                               device=mask.device)
+        dim_t_z = self.temperature**(2 * (dim_t_z // 2) / (self.num_feats * 2))
+
+        pos_x = x_embed[:, :, :, :, None] / dim_t
+        pos_y = y_embed[:, :, :, :, None] / dim_t
+        pos_z = z_embed[:, :, :, :, None] / dim_t_z
+        # use `view` instead of `flatten` for dynamically exporting to ONNX
+        B, T, H, W = mask.size()
+        pos_x = torch.stack(
+            (pos_x[:, :, :, :, 0::2].sin(), pos_x[:, :, :, :, 1::2].cos()),
+            dim=5).view(B, T, H, W, -1)
+        pos_y = torch.stack(
+            (pos_y[:, :, :, :, 0::2].sin(), pos_y[:, :, :, :, 1::2].cos()),
+            dim=5).view(B, T, H, W, -1)
+        pos_z = torch.stack(
+            (pos_z[:, :, :, :, 0::2].sin(), pos_z[:, :, :, :, 1::2].cos()),
+            dim=5).view(B, T, H, W, -1)
+        pos = (torch.cat((pos_y, pos_x), dim=4) + pos_z).permute(0, 1, 4, 2, 3)
+        return pos
diff --git a/mmdetection/mmdet/models/layers/res_layer.py b/mmdetection/mmdet/models/layers/res_layer.py
new file mode 100644
index 00000000..ff24d3e8
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/res_layer.py
@@ -0,0 +1,195 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional
+
+from mmcv.cnn import build_conv_layer, build_norm_layer
+from mmengine.model import BaseModule, Sequential
+from torch import Tensor
+from torch import nn as nn
+
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+
+
+class ResLayer(Sequential):
+    """ResLayer to build ResNet style backbone.
+
+    Args:
+        block (nn.Module): block used to build ResLayer.
+        inplanes (int): inplanes of block.
+        planes (int): planes of block.
+        num_blocks (int): number of blocks.
+        stride (int): stride of the first block. Defaults to 1
+        avg_down (bool): Use AvgPool instead of stride conv when
+            downsampling in the bottleneck. Defaults to False
+        conv_cfg (dict): dictionary to construct and config conv layer.
+            Defaults to None
+        norm_cfg (dict): dictionary to construct and config norm layer.
+            Defaults to dict(type='BN')
+        downsample_first (bool): Downsample at the first block or last block.
+            False for Hourglass, True for ResNet. Defaults to True
+    """
+
+    def __init__(self,
+                 block: BaseModule,
+                 inplanes: int,
+                 planes: int,
+                 num_blocks: int,
+                 stride: int = 1,
+                 avg_down: bool = False,
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: ConfigType = dict(type='BN'),
+                 downsample_first: bool = True,
+                 **kwargs) -> None:
+        self.block = block
+
+        downsample = None
+        if stride != 1 or inplanes != planes * block.expansion:
+            downsample = []
+            conv_stride = stride
+            if avg_down:
+                conv_stride = 1
+                downsample.append(
+                    nn.AvgPool2d(
+                        kernel_size=stride,
+                        stride=stride,
+                        ceil_mode=True,
+                        count_include_pad=False))
+            downsample.extend([
+                build_conv_layer(
+                    conv_cfg,
+                    inplanes,
+                    planes * block.expansion,
+                    kernel_size=1,
+                    stride=conv_stride,
+                    bias=False),
+                build_norm_layer(norm_cfg, planes * block.expansion)[1]
+            ])
+            downsample = nn.Sequential(*downsample)
+
+        layers = []
+        if downsample_first:
+            layers.append(
+                block(
+                    inplanes=inplanes,
+                    planes=planes,
+                    stride=stride,
+                    downsample=downsample,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    **kwargs))
+            inplanes = planes * block.expansion
+            for _ in range(1, num_blocks):
+                layers.append(
+                    block(
+                        inplanes=inplanes,
+                        planes=planes,
+                        stride=1,
+                        conv_cfg=conv_cfg,
+                        norm_cfg=norm_cfg,
+                        **kwargs))
+
+        else:  # downsample_first=False is for HourglassModule
+            for _ in range(num_blocks - 1):
+                layers.append(
+                    block(
+                        inplanes=inplanes,
+                        planes=inplanes,
+                        stride=1,
+                        conv_cfg=conv_cfg,
+                        norm_cfg=norm_cfg,
+                        **kwargs))
+            layers.append(
+                block(
+                    inplanes=inplanes,
+                    planes=planes,
+                    stride=stride,
+                    downsample=downsample,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    **kwargs))
+        super().__init__(*layers)
+
+
+class SimplifiedBasicBlock(BaseModule):
+    """Simplified version of original basic residual block. This is used in
+    `SCNet `_.
+
+    - Norm layer is now optional
+    - Last ReLU in forward function is removed
+    """
+    expansion = 1
+
+    def __init__(self,
+                 inplanes: int,
+                 planes: int,
+                 stride: int = 1,
+                 dilation: int = 1,
+                 downsample: Optional[Sequential] = None,
+                 style: ConfigType = 'pytorch',
+                 with_cp: bool = False,
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: ConfigType = dict(type='BN'),
+                 dcn: OptConfigType = None,
+                 plugins: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(init_cfg=init_cfg)
+        assert dcn is None, 'Not implemented yet.'
+        assert plugins is None, 'Not implemented yet.'
+        assert not with_cp, 'Not implemented yet.'
+        self.with_norm = norm_cfg is not None
+        with_bias = True if norm_cfg is None else False
+        self.conv1 = build_conv_layer(
+            conv_cfg,
+            inplanes,
+            planes,
+            3,
+            stride=stride,
+            padding=dilation,
+            dilation=dilation,
+            bias=with_bias)
+        if self.with_norm:
+            self.norm1_name, norm1 = build_norm_layer(
+                norm_cfg, planes, postfix=1)
+            self.add_module(self.norm1_name, norm1)
+        self.conv2 = build_conv_layer(
+            conv_cfg, planes, planes, 3, padding=1, bias=with_bias)
+        if self.with_norm:
+            self.norm2_name, norm2 = build_norm_layer(
+                norm_cfg, planes, postfix=2)
+            self.add_module(self.norm2_name, norm2)
+
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+        self.dilation = dilation
+        self.with_cp = with_cp
+
+    @property
+    def norm1(self) -> Optional[BaseModule]:
+        """nn.Module: normalization layer after the first convolution layer"""
+        return getattr(self, self.norm1_name) if self.with_norm else None
+
+    @property
+    def norm2(self) -> Optional[BaseModule]:
+        """nn.Module: normalization layer after the second convolution layer"""
+        return getattr(self, self.norm2_name) if self.with_norm else None
+
+    def forward(self, x: Tensor) -> Tensor:
+        """Forward function for SimplifiedBasicBlock."""
+
+        identity = x
+
+        out = self.conv1(x)
+        if self.with_norm:
+            out = self.norm1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        if self.with_norm:
+            out = self.norm2(out)
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out += identity
+
+        return out
diff --git a/mmdetection/mmdet/models/layers/se_layer.py b/mmdetection/mmdet/models/layers/se_layer.py
new file mode 100644
index 00000000..5598daba
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/se_layer.py
@@ -0,0 +1,162 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule
+from mmengine.utils import digit_version, is_tuple_of
+from torch import Tensor
+
+from mmdet.utils import MultiConfig, OptConfigType, OptMultiConfig
+
+
+class SELayer(BaseModule):
+    """Squeeze-and-Excitation Module.
+
+    Args:
+        channels (int): The input (and output) channels of the SE layer.
+        ratio (int): Squeeze ratio in SELayer, the intermediate channel will be
+            ``int(channels/ratio)``. Defaults to 16.
+        conv_cfg (None or dict): Config dict for convolution layer.
+            Defaults to None, which means using conv2d.
+        act_cfg (dict or Sequence[dict]): Config dict for activation layer.
+            If act_cfg is a dict, two activation layers will be configurated
+            by this dict. If act_cfg is a sequence of dicts, the first
+            activation layer will be configurated by the first dict and the
+            second activation layer will be configurated by the second dict.
+            Defaults to (dict(type='ReLU'), dict(type='Sigmoid'))
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Defaults to None
+    """
+
+    def __init__(self,
+                 channels: int,
+                 ratio: int = 16,
+                 conv_cfg: OptConfigType = None,
+                 act_cfg: MultiConfig = (dict(type='ReLU'),
+                                         dict(type='Sigmoid')),
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(init_cfg=init_cfg)
+        if isinstance(act_cfg, dict):
+            act_cfg = (act_cfg, act_cfg)
+        assert len(act_cfg) == 2
+        assert is_tuple_of(act_cfg, dict)
+        self.global_avgpool = nn.AdaptiveAvgPool2d(1)
+        self.conv1 = ConvModule(
+            in_channels=channels,
+            out_channels=int(channels / ratio),
+            kernel_size=1,
+            stride=1,
+            conv_cfg=conv_cfg,
+            act_cfg=act_cfg[0])
+        self.conv2 = ConvModule(
+            in_channels=int(channels / ratio),
+            out_channels=channels,
+            kernel_size=1,
+            stride=1,
+            conv_cfg=conv_cfg,
+            act_cfg=act_cfg[1])
+
+    def forward(self, x: Tensor) -> Tensor:
+        """Forward function for SELayer."""
+        out = self.global_avgpool(x)
+        out = self.conv1(out)
+        out = self.conv2(out)
+        return x * out
+
+
+class DyReLU(BaseModule):
+    """Dynamic ReLU (DyReLU) module.
+
+    See `Dynamic ReLU `_ for details.
+    Current implementation is specialized for task-aware attention in DyHead.
+    HSigmoid arguments in default act_cfg follow DyHead official code.
+    https://github.com/microsoft/DynamicHead/blob/master/dyhead/dyrelu.py
+
+    Args:
+        channels (int): The input (and output) channels of DyReLU module.
+        ratio (int): Squeeze ratio in Squeeze-and-Excitation-like module,
+            the intermediate channel will be ``int(channels/ratio)``.
+            Defaults to 4.
+        conv_cfg (None or dict): Config dict for convolution layer.
+            Defaults to None, which means using conv2d.
+        act_cfg (dict or Sequence[dict]): Config dict for activation layer.
+            If act_cfg is a dict, two activation layers will be configurated
+            by this dict. If act_cfg is a sequence of dicts, the first
+            activation layer will be configurated by the first dict and the
+            second activation layer will be configurated by the second dict.
+            Defaults to (dict(type='ReLU'), dict(type='HSigmoid', bias=3.0,
+            divisor=6.0))
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Defaults to None
+    """
+
+    def __init__(self,
+                 channels: int,
+                 ratio: int = 4,
+                 conv_cfg: OptConfigType = None,
+                 act_cfg: MultiConfig = (dict(type='ReLU'),
+                                         dict(
+                                             type='HSigmoid',
+                                             bias=3.0,
+                                             divisor=6.0)),
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(init_cfg=init_cfg)
+        if isinstance(act_cfg, dict):
+            act_cfg = (act_cfg, act_cfg)
+        assert len(act_cfg) == 2
+        assert is_tuple_of(act_cfg, dict)
+        self.channels = channels
+        self.expansion = 4  # for a1, b1, a2, b2
+        self.global_avgpool = nn.AdaptiveAvgPool2d(1)
+        self.conv1 = ConvModule(
+            in_channels=channels,
+            out_channels=int(channels / ratio),
+            kernel_size=1,
+            stride=1,
+            conv_cfg=conv_cfg,
+            act_cfg=act_cfg[0])
+        self.conv2 = ConvModule(
+            in_channels=int(channels / ratio),
+            out_channels=channels * self.expansion,
+            kernel_size=1,
+            stride=1,
+            conv_cfg=conv_cfg,
+            act_cfg=act_cfg[1])
+
+    def forward(self, x: Tensor) -> Tensor:
+        """Forward function."""
+        coeffs = self.global_avgpool(x)
+        coeffs = self.conv1(coeffs)
+        coeffs = self.conv2(coeffs) - 0.5  # value range: [-0.5, 0.5]
+        a1, b1, a2, b2 = torch.split(coeffs, self.channels, dim=1)
+        a1 = a1 * 2.0 + 1.0  # [-1.0, 1.0] + 1.0
+        a2 = a2 * 2.0  # [-1.0, 1.0]
+        out = torch.max(x * a1 + b1, x * a2 + b2)
+        return out
+
+
+class ChannelAttention(BaseModule):
+    """Channel attention Module.
+
+    Args:
+        channels (int): The input (and output) channels of the attention layer.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Defaults to None
+    """
+
+    def __init__(self, channels: int, init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.global_avgpool = nn.AdaptiveAvgPool2d(1)
+        self.fc = nn.Conv2d(channels, channels, 1, 1, 0, bias=True)
+        if digit_version(torch.__version__) < (1, 7, 0):
+            self.act = nn.Hardsigmoid()
+        else:
+            self.act = nn.Hardsigmoid(inplace=True)
+
+    def forward(self, x: Tensor) -> Tensor:
+        """Forward function for ChannelAttention."""
+        with torch.cuda.amp.autocast(enabled=False):
+            out = self.global_avgpool(x)
+        out = self.fc(out)
+        out = self.act(out)
+        return x * out
diff --git a/mmdetection/mmdet/models/layers/transformer/__init__.py b/mmdetection/mmdet/models/layers/transformer/__init__.py
new file mode 100644
index 00000000..839d9364
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/transformer/__init__.py
@@ -0,0 +1,41 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .conditional_detr_layers import (ConditionalDetrTransformerDecoder,
+                                      ConditionalDetrTransformerDecoderLayer)
+from .dab_detr_layers import (DABDetrTransformerDecoder,
+                              DABDetrTransformerDecoderLayer,
+                              DABDetrTransformerEncoder)
+from .ddq_detr_layers import DDQTransformerDecoder
+from .deformable_detr_layers import (DeformableDetrTransformerDecoder,
+                                     DeformableDetrTransformerDecoderLayer,
+                                     DeformableDetrTransformerEncoder,
+                                     DeformableDetrTransformerEncoderLayer)
+from .detr_layers import (DetrTransformerDecoder, DetrTransformerDecoderLayer,
+                          DetrTransformerEncoder, DetrTransformerEncoderLayer)
+from .dino_layers import CdnQueryGenerator, DinoTransformerDecoder
+from .grounding_dino_layers import (GroundingDinoTransformerDecoder,
+                                    GroundingDinoTransformerDecoderLayer,
+                                    GroundingDinoTransformerEncoder)
+from .mask2former_layers import (Mask2FormerTransformerDecoder,
+                                 Mask2FormerTransformerDecoderLayer,
+                                 Mask2FormerTransformerEncoder)
+from .utils import (MLP, AdaptivePadding, ConditionalAttention, DynamicConv,
+                    PatchEmbed, PatchMerging, coordinate_to_encoding,
+                    inverse_sigmoid, nchw_to_nlc, nlc_to_nchw)
+
+__all__ = [
+    'nlc_to_nchw', 'nchw_to_nlc', 'AdaptivePadding', 'PatchEmbed',
+    'PatchMerging', 'inverse_sigmoid', 'DynamicConv', 'MLP',
+    'DetrTransformerEncoder', 'DetrTransformerDecoder',
+    'DetrTransformerEncoderLayer', 'DetrTransformerDecoderLayer',
+    'DeformableDetrTransformerEncoder', 'DeformableDetrTransformerDecoder',
+    'DeformableDetrTransformerEncoderLayer',
+    'DeformableDetrTransformerDecoderLayer', 'coordinate_to_encoding',
+    'ConditionalAttention', 'DABDetrTransformerDecoderLayer',
+    'DABDetrTransformerDecoder', 'DABDetrTransformerEncoder',
+    'DDQTransformerDecoder', 'ConditionalDetrTransformerDecoder',
+    'ConditionalDetrTransformerDecoderLayer', 'DinoTransformerDecoder',
+    'CdnQueryGenerator', 'Mask2FormerTransformerEncoder',
+    'Mask2FormerTransformerDecoderLayer', 'Mask2FormerTransformerDecoder',
+    'GroundingDinoTransformerDecoderLayer', 'GroundingDinoTransformerEncoder',
+    'GroundingDinoTransformerDecoder'
+]
diff --git a/mmdetection/mmdet/models/layers/transformer/conditional_detr_layers.py b/mmdetection/mmdet/models/layers/transformer/conditional_detr_layers.py
new file mode 100644
index 00000000..6db12a13
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/transformer/conditional_detr_layers.py
@@ -0,0 +1,170 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from mmcv.cnn import build_norm_layer
+from mmcv.cnn.bricks.transformer import FFN
+from torch import Tensor
+from torch.nn import ModuleList
+
+from .detr_layers import DetrTransformerDecoder, DetrTransformerDecoderLayer
+from .utils import MLP, ConditionalAttention, coordinate_to_encoding
+
+
+class ConditionalDetrTransformerDecoder(DetrTransformerDecoder):
+    """Decoder of Conditional DETR."""
+
+    def _init_layers(self) -> None:
+        """Initialize decoder layers and other layers."""
+        self.layers = ModuleList([
+            ConditionalDetrTransformerDecoderLayer(**self.layer_cfg)
+            for _ in range(self.num_layers)
+        ])
+        self.embed_dims = self.layers[0].embed_dims
+        self.post_norm = build_norm_layer(self.post_norm_cfg,
+                                          self.embed_dims)[1]
+        # conditional detr affline
+        self.query_scale = MLP(self.embed_dims, self.embed_dims,
+                               self.embed_dims, 2)
+        self.ref_point_head = MLP(self.embed_dims, self.embed_dims, 2, 2)
+        # we have substitute 'qpos_proj' with 'qpos_sine_proj' except for
+        # the first decoder layer), so 'qpos_proj' should be deleted
+        # in other layers.
+        for layer_id in range(self.num_layers - 1):
+            self.layers[layer_id + 1].cross_attn.qpos_proj = None
+
+    def forward(self,
+                query: Tensor,
+                key: Tensor = None,
+                query_pos: Tensor = None,
+                key_pos: Tensor = None,
+                key_padding_mask: Tensor = None):
+        """Forward function of decoder.
+
+        Args:
+            query (Tensor): The input query with shape
+                (bs, num_queries, dim).
+            key (Tensor): The input key with shape (bs, num_keys, dim) If
+                `None`, the `query` will be used. Defaults to `None`.
+            query_pos (Tensor): The positional encoding for `query`, with the
+                same shape as `query`. If not `None`, it will be added to
+                `query` before forward function. Defaults to `None`.
+            key_pos (Tensor): The positional encoding for `key`, with the
+                same shape as `key`. If not `None`, it will be added to
+                `key` before forward function. If `None`, and `query_pos`
+                has the same shape as `key`, then `query_pos` will be used
+                as `key_pos`. Defaults to `None`.
+            key_padding_mask (Tensor): ByteTensor with shape (bs, num_keys).
+                Defaults to `None`.
+        Returns:
+            List[Tensor]: forwarded results with shape (num_decoder_layers,
+            bs, num_queries, dim) if `return_intermediate` is True, otherwise
+            with shape (1, bs, num_queries, dim). References with shape
+            (bs, num_queries, 2).
+        """
+        reference_unsigmoid = self.ref_point_head(
+            query_pos)  # [bs, num_queries, 2]
+        reference = reference_unsigmoid.sigmoid()
+        reference_xy = reference[..., :2]
+        intermediate = []
+        for layer_id, layer in enumerate(self.layers):
+            if layer_id == 0:
+                pos_transformation = 1
+            else:
+                pos_transformation = self.query_scale(query)
+            # get sine embedding for the query reference
+            ref_sine_embed = coordinate_to_encoding(coord_tensor=reference_xy)
+            # apply transformation
+            ref_sine_embed = ref_sine_embed * pos_transformation
+            query = layer(
+                query,
+                key=key,
+                query_pos=query_pos,
+                key_pos=key_pos,
+                key_padding_mask=key_padding_mask,
+                ref_sine_embed=ref_sine_embed,
+                is_first=(layer_id == 0))
+            if self.return_intermediate:
+                intermediate.append(self.post_norm(query))
+
+        if self.return_intermediate:
+            return torch.stack(intermediate), reference
+
+        query = self.post_norm(query)
+        return query.unsqueeze(0), reference
+
+
+class ConditionalDetrTransformerDecoderLayer(DetrTransformerDecoderLayer):
+    """Implements decoder layer in Conditional DETR transformer."""
+
+    def _init_layers(self):
+        """Initialize self-attention, cross-attention, FFN, and
+        normalization."""
+        self.self_attn = ConditionalAttention(**self.self_attn_cfg)
+        self.cross_attn = ConditionalAttention(**self.cross_attn_cfg)
+        self.embed_dims = self.self_attn.embed_dims
+        self.ffn = FFN(**self.ffn_cfg)
+        norms_list = [
+            build_norm_layer(self.norm_cfg, self.embed_dims)[1]
+            for _ in range(3)
+        ]
+        self.norms = ModuleList(norms_list)
+
+    def forward(self,
+                query: Tensor,
+                key: Tensor = None,
+                query_pos: Tensor = None,
+                key_pos: Tensor = None,
+                self_attn_masks: Tensor = None,
+                cross_attn_masks: Tensor = None,
+                key_padding_mask: Tensor = None,
+                ref_sine_embed: Tensor = None,
+                is_first: bool = False):
+        """
+        Args:
+            query (Tensor): The input query, has shape (bs, num_queries, dim)
+            key (Tensor, optional): The input key, has shape (bs, num_keys,
+                dim). If `None`, the `query` will be used. Defaults to `None`.
+            query_pos (Tensor, optional): The positional encoding for `query`,
+                has the same shape as `query`. If not `None`, it will be
+                added to `query` before forward function. Defaults to `None`.
+            ref_sine_embed (Tensor): The positional encoding for query in
+                cross attention, with the same shape as `x`. Defaults to None.
+            key_pos (Tensor, optional): The positional encoding for `key`, has
+                the same shape as `key`. If not None, it will be added to
+                `key` before forward function. If None, and `query_pos` has
+                the same shape as `key`, then `query_pos` will be used for
+                `key_pos`. Defaults to None.
+            self_attn_masks (Tensor, optional): ByteTensor mask, has shape
+                (num_queries, num_keys), Same in `nn.MultiheadAttention.
+                forward`. Defaults to None.
+            cross_attn_masks (Tensor, optional): ByteTensor mask, has shape
+                (num_queries, num_keys), Same in `nn.MultiheadAttention.
+                forward`. Defaults to None.
+            key_padding_mask (Tensor, optional): ByteTensor, has shape
+                (bs, num_keys). Defaults to None.
+            is_first (bool): A indicator to tell whether the current layer
+                is the first layer of the decoder. Defaults to False.
+
+        Returns:
+            Tensor: Forwarded results, has shape (bs, num_queries, dim).
+        """
+        query = self.self_attn(
+            query=query,
+            key=query,
+            query_pos=query_pos,
+            key_pos=query_pos,
+            attn_mask=self_attn_masks)
+        query = self.norms[0](query)
+        query = self.cross_attn(
+            query=query,
+            key=key,
+            query_pos=query_pos,
+            key_pos=key_pos,
+            attn_mask=cross_attn_masks,
+            key_padding_mask=key_padding_mask,
+            ref_sine_embed=ref_sine_embed,
+            is_first=is_first)
+        query = self.norms[1](query)
+        query = self.ffn(query)
+        query = self.norms[2](query)
+
+        return query
diff --git a/mmdetection/mmdet/models/layers/transformer/dab_detr_layers.py b/mmdetection/mmdet/models/layers/transformer/dab_detr_layers.py
new file mode 100644
index 00000000..b8a6e772
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/transformer/dab_detr_layers.py
@@ -0,0 +1,298 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import build_norm_layer
+from mmcv.cnn.bricks.transformer import FFN
+from mmengine.model import ModuleList
+from torch import Tensor
+
+from .detr_layers import (DetrTransformerDecoder, DetrTransformerDecoderLayer,
+                          DetrTransformerEncoder, DetrTransformerEncoderLayer)
+from .utils import (MLP, ConditionalAttention, coordinate_to_encoding,
+                    inverse_sigmoid)
+
+
+class DABDetrTransformerDecoderLayer(DetrTransformerDecoderLayer):
+    """Implements decoder layer in DAB-DETR transformer."""
+
+    def _init_layers(self):
+        """Initialize self-attention, cross-attention, FFN, normalization and
+        others."""
+        self.self_attn = ConditionalAttention(**self.self_attn_cfg)
+        self.cross_attn = ConditionalAttention(**self.cross_attn_cfg)
+        self.embed_dims = self.self_attn.embed_dims
+        self.ffn = FFN(**self.ffn_cfg)
+        norms_list = [
+            build_norm_layer(self.norm_cfg, self.embed_dims)[1]
+            for _ in range(3)
+        ]
+        self.norms = ModuleList(norms_list)
+        self.keep_query_pos = self.cross_attn.keep_query_pos
+
+    def forward(self,
+                query: Tensor,
+                key: Tensor,
+                query_pos: Tensor,
+                key_pos: Tensor,
+                ref_sine_embed: Tensor = None,
+                self_attn_masks: Tensor = None,
+                cross_attn_masks: Tensor = None,
+                key_padding_mask: Tensor = None,
+                is_first: bool = False,
+                **kwargs) -> Tensor:
+        """
+        Args:
+            query (Tensor): The input query with shape [bs, num_queries,
+                dim].
+            key (Tensor): The key tensor with shape [bs, num_keys,
+                dim].
+            query_pos (Tensor): The positional encoding for query in self
+                attention, with the same shape as `x`.
+            key_pos (Tensor): The positional encoding for `key`, with the
+                same shape as `key`.
+            ref_sine_embed (Tensor): The positional encoding for query in
+                cross attention, with the same shape as `x`.
+                Defaults to None.
+            self_attn_masks (Tensor): ByteTensor mask with shape [num_queries,
+                num_keys]. Same in `nn.MultiheadAttention.forward`.
+                Defaults to None.
+            cross_attn_masks (Tensor): ByteTensor mask with shape [num_queries,
+                num_keys]. Same in `nn.MultiheadAttention.forward`.
+                Defaults to None.
+            key_padding_mask (Tensor): ByteTensor with shape [bs, num_keys].
+                Defaults to None.
+            is_first (bool): A indicator to tell whether the current layer
+                is the first layer of the decoder.
+                Defaults to False.
+
+        Returns:
+            Tensor: forwarded results with shape
+            [bs, num_queries, dim].
+        """
+
+        query = self.self_attn(
+            query=query,
+            key=query,
+            query_pos=query_pos,
+            key_pos=query_pos,
+            attn_mask=self_attn_masks,
+            **kwargs)
+        query = self.norms[0](query)
+        query = self.cross_attn(
+            query=query,
+            key=key,
+            query_pos=query_pos,
+            key_pos=key_pos,
+            ref_sine_embed=ref_sine_embed,
+            attn_mask=cross_attn_masks,
+            key_padding_mask=key_padding_mask,
+            is_first=is_first,
+            **kwargs)
+        query = self.norms[1](query)
+        query = self.ffn(query)
+        query = self.norms[2](query)
+
+        return query
+
+
+class DABDetrTransformerDecoder(DetrTransformerDecoder):
+    """Decoder of DAB-DETR.
+
+    Args:
+        query_dim (int): The last dimension of query pos,
+            4 for anchor format, 2 for point format.
+            Defaults to 4.
+        query_scale_type (str): Type of transformation applied
+            to content query. Defaults to `cond_elewise`.
+        with_modulated_hw_attn (bool): Whether to inject h&w info
+            during cross conditional attention. Defaults to True.
+    """
+
+    def __init__(self,
+                 *args,
+                 query_dim: int = 4,
+                 query_scale_type: str = 'cond_elewise',
+                 with_modulated_hw_attn: bool = True,
+                 **kwargs):
+
+        self.query_dim = query_dim
+        self.query_scale_type = query_scale_type
+        self.with_modulated_hw_attn = with_modulated_hw_attn
+
+        super().__init__(*args, **kwargs)
+
+    def _init_layers(self):
+        """Initialize decoder layers and other layers."""
+        assert self.query_dim in [2, 4], \
+            f'{"dab-detr only supports anchor prior or reference point prior"}'
+        assert self.query_scale_type in [
+            'cond_elewise', 'cond_scalar', 'fix_elewise'
+        ]
+
+        self.layers = ModuleList([
+            DABDetrTransformerDecoderLayer(**self.layer_cfg)
+            for _ in range(self.num_layers)
+        ])
+
+        embed_dims = self.layers[0].embed_dims
+        self.embed_dims = embed_dims
+
+        self.post_norm = build_norm_layer(self.post_norm_cfg, embed_dims)[1]
+        if self.query_scale_type == 'cond_elewise':
+            self.query_scale = MLP(embed_dims, embed_dims, embed_dims, 2)
+        elif self.query_scale_type == 'cond_scalar':
+            self.query_scale = MLP(embed_dims, embed_dims, 1, 2)
+        elif self.query_scale_type == 'fix_elewise':
+            self.query_scale = nn.Embedding(self.num_layers, embed_dims)
+        else:
+            raise NotImplementedError('Unknown query_scale_type: {}'.format(
+                self.query_scale_type))
+
+        self.ref_point_head = MLP(self.query_dim // 2 * embed_dims, embed_dims,
+                                  embed_dims, 2)
+
+        if self.with_modulated_hw_attn and self.query_dim == 4:
+            self.ref_anchor_head = MLP(embed_dims, embed_dims, 2, 2)
+
+        self.keep_query_pos = self.layers[0].keep_query_pos
+        if not self.keep_query_pos:
+            for layer_id in range(self.num_layers - 1):
+                self.layers[layer_id + 1].cross_attn.qpos_proj = None
+
+    def forward(self,
+                query: Tensor,
+                key: Tensor,
+                query_pos: Tensor,
+                key_pos: Tensor,
+                reg_branches: nn.Module,
+                key_padding_mask: Tensor = None,
+                **kwargs) -> List[Tensor]:
+        """Forward function of decoder.
+
+        Args:
+            query (Tensor): The input query with shape (bs, num_queries, dim).
+            key (Tensor): The input key with shape (bs, num_keys, dim).
+            query_pos (Tensor): The positional encoding for `query`, with the
+                same shape as `query`.
+            key_pos (Tensor): The positional encoding for `key`, with the
+                same shape as `key`.
+            reg_branches (nn.Module): The regression branch for dynamically
+                updating references in each layer.
+            key_padding_mask (Tensor): ByteTensor with shape (bs, num_keys).
+                Defaults to `None`.
+
+        Returns:
+            List[Tensor]: forwarded results with shape (num_decoder_layers,
+            bs, num_queries, dim) if `return_intermediate` is True, otherwise
+            with shape (1, bs, num_queries, dim). references with shape
+            (num_decoder_layers, bs, num_queries, 2/4).
+        """
+        output = query
+        unsigmoid_references = query_pos
+
+        reference_points = unsigmoid_references.sigmoid()
+        intermediate_reference_points = [reference_points]
+
+        intermediate = []
+        for layer_id, layer in enumerate(self.layers):
+            obj_center = reference_points[..., :self.query_dim]
+            ref_sine_embed = coordinate_to_encoding(
+                coord_tensor=obj_center, num_feats=self.embed_dims // 2)
+            query_pos = self.ref_point_head(
+                ref_sine_embed)  # [bs, nq, 2c] -> [bs, nq, c]
+            # For the first decoder layer, do not apply transformation
+            if self.query_scale_type != 'fix_elewise':
+                if layer_id == 0:
+                    pos_transformation = 1
+                else:
+                    pos_transformation = self.query_scale(output)
+            else:
+                pos_transformation = self.query_scale.weight[layer_id]
+            # apply transformation
+            ref_sine_embed = ref_sine_embed[
+                ..., :self.embed_dims] * pos_transformation
+            # modulated height and weight attention
+            if self.with_modulated_hw_attn:
+                assert obj_center.size(-1) == 4
+                ref_hw = self.ref_anchor_head(output).sigmoid()
+                ref_sine_embed[..., self.embed_dims // 2:] *= \
+                    (ref_hw[..., 0] / obj_center[..., 2]).unsqueeze(-1)
+                ref_sine_embed[..., : self.embed_dims // 2] *= \
+                    (ref_hw[..., 1] / obj_center[..., 3]).unsqueeze(-1)
+
+            output = layer(
+                output,
+                key,
+                query_pos=query_pos,
+                ref_sine_embed=ref_sine_embed,
+                key_pos=key_pos,
+                key_padding_mask=key_padding_mask,
+                is_first=(layer_id == 0),
+                **kwargs)
+            # iter update
+            tmp_reg_preds = reg_branches(output)
+            tmp_reg_preds[..., :self.query_dim] += inverse_sigmoid(
+                reference_points)
+            new_reference_points = tmp_reg_preds[
+                ..., :self.query_dim].sigmoid()
+            if layer_id != self.num_layers - 1:
+                intermediate_reference_points.append(new_reference_points)
+            reference_points = new_reference_points.detach()
+
+            if self.return_intermediate:
+                intermediate.append(self.post_norm(output))
+
+        output = self.post_norm(output)
+
+        if self.return_intermediate:
+            return [
+                torch.stack(intermediate),
+                torch.stack(intermediate_reference_points),
+            ]
+        else:
+            return [
+                output.unsqueeze(0),
+                torch.stack(intermediate_reference_points)
+            ]
+
+
+class DABDetrTransformerEncoder(DetrTransformerEncoder):
+    """Encoder of DAB-DETR."""
+
+    def _init_layers(self):
+        """Initialize encoder layers."""
+        self.layers = ModuleList([
+            DetrTransformerEncoderLayer(**self.layer_cfg)
+            for _ in range(self.num_layers)
+        ])
+        embed_dims = self.layers[0].embed_dims
+        self.embed_dims = embed_dims
+        self.query_scale = MLP(embed_dims, embed_dims, embed_dims, 2)
+
+    def forward(self, query: Tensor, query_pos: Tensor,
+                key_padding_mask: Tensor, **kwargs):
+        """Forward function of encoder.
+
+        Args:
+            query (Tensor): Input queries of encoder, has shape
+                (bs, num_queries, dim).
+            query_pos (Tensor): The positional embeddings of the queries, has
+                shape (bs, num_feat_points, dim).
+            key_padding_mask (Tensor): ByteTensor, the key padding mask
+                of the queries, has shape (bs, num_feat_points).
+
+        Returns:
+            Tensor: With shape (num_queries, bs, dim).
+        """
+
+        for layer in self.layers:
+            pos_scales = self.query_scale(query)
+            query = layer(
+                query,
+                query_pos=query_pos * pos_scales,
+                key_padding_mask=key_padding_mask,
+                **kwargs)
+
+        return query
diff --git a/mmdetection/mmdet/models/layers/transformer/ddq_detr_layers.py b/mmdetection/mmdet/models/layers/transformer/ddq_detr_layers.py
new file mode 100644
index 00000000..57664c7e
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/transformer/ddq_detr_layers.py
@@ -0,0 +1,223 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+
+import torch
+from mmcv.ops import batched_nms
+from torch import Tensor, nn
+
+from mmdet.structures.bbox import bbox_cxcywh_to_xyxy
+from .deformable_detr_layers import DeformableDetrTransformerDecoder
+from .utils import MLP, coordinate_to_encoding, inverse_sigmoid
+
+
+class DDQTransformerDecoder(DeformableDetrTransformerDecoder):
+    """Transformer decoder of DDQ."""
+
+    def _init_layers(self) -> None:
+        """Initialize encoder layers."""
+        super()._init_layers()
+        self.ref_point_head = MLP(self.embed_dims * 2, self.embed_dims,
+                                  self.embed_dims, 2)
+        self.norm = nn.LayerNorm(self.embed_dims)
+
+    def select_distinct_queries(self, reference_points: Tensor, query: Tensor,
+                                self_attn_mask: Tensor, layer_index):
+        """Get updated `self_attn_mask` for distinct queries selection, it is
+        used in self attention layers of decoder.
+
+        Args:
+            reference_points (Tensor): The input reference of decoder,
+                has shape (bs, num_queries, 4) with the last dimension
+                arranged as (cx, cy, w, h).
+            query (Tensor): The input query of decoder, has shape
+                (bs, num_queries, dims).
+            self_attn_mask (Tensor): The input self attention mask of
+                last decoder layer, has shape (bs, num_queries_total,
+                num_queries_total).
+            layer_index (int): Last decoder layer index, used to get
+                classification score of last layer output, for
+                distinct queries selection.
+
+        Returns:
+            Tensor: `self_attn_mask` used in self attention layers
+                of decoder, has shape (bs, num_queries_total,
+                num_queries_total).
+        """
+        num_imgs = len(reference_points)
+        dis_start, num_dis = self.cache_dict['dis_query_info']
+        # shape of self_attn_mask
+        # (batch⋅num_heads, num_queries, embed_dims)
+        dis_mask = self_attn_mask[:, dis_start:dis_start + num_dis,
+                                  dis_start:dis_start + num_dis]
+        # cls_branches from DDQDETRHead
+        scores = self.cache_dict['cls_branches'][layer_index](
+            query[:, dis_start:dis_start + num_dis]).sigmoid().max(-1).values
+        proposals = reference_points[:, dis_start:dis_start + num_dis]
+        proposals = bbox_cxcywh_to_xyxy(proposals)
+
+        attn_mask_list = []
+        for img_id in range(num_imgs):
+            single_proposals = proposals[img_id]
+            single_scores = scores[img_id]
+            attn_mask = ~dis_mask[img_id * self.cache_dict['num_heads']][0]
+            # distinct query inds in this layer
+            ori_index = attn_mask.nonzero().view(-1)
+            _, keep_idxs = batched_nms(single_proposals[ori_index],
+                                       single_scores[ori_index],
+                                       torch.ones(len(ori_index)),
+                                       self.cache_dict['dqs_cfg'])
+
+            real_keep_index = ori_index[keep_idxs]
+
+            attn_mask = torch.ones_like(dis_mask[0]).bool()
+            # such a attn_mask give best result
+            # If it requires to keep index i, then all cells in row or column
+            #   i should be kept in `attn_mask` . For example, if
+            #   `real_keep_index` = [1, 4], and `attn_mask` size = [8, 8],
+            #   then all cells at rows or columns [1, 4] should be kept, and
+            #   all the other cells should be masked out. So the value of
+            #  `attn_mask` should be:
+            #
+            # target\source   0 1 2 3 4 5 6 7
+            #             0 [ 0 1 0 0 1 0 0 0 ]
+            #             1 [ 1 1 1 1 1 1 1 1 ]
+            #             2 [ 0 1 0 0 1 0 0 0 ]
+            #             3 [ 0 1 0 0 1 0 0 0 ]
+            #             4 [ 1 1 1 1 1 1 1 1 ]
+            #             5 [ 0 1 0 0 1 0 0 0 ]
+            #             6 [ 0 1 0 0 1 0 0 0 ]
+            #             7 [ 0 1 0 0 1 0 0 0 ]
+            attn_mask[real_keep_index] = False
+            attn_mask[:, real_keep_index] = False
+
+            attn_mask = attn_mask[None].repeat(self.cache_dict['num_heads'], 1,
+                                               1)
+            attn_mask_list.append(attn_mask)
+        attn_mask = torch.cat(attn_mask_list)
+        self_attn_mask = copy.deepcopy(self_attn_mask)
+        self_attn_mask[:, dis_start:dis_start + num_dis,
+                       dis_start:dis_start + num_dis] = attn_mask
+        # will be used in loss and inference
+        self.cache_dict['distinct_query_mask'].append(~attn_mask)
+        return self_attn_mask
+
+    def forward(self, query: Tensor, value: Tensor, key_padding_mask: Tensor,
+                self_attn_mask: Tensor, reference_points: Tensor,
+                spatial_shapes: Tensor, level_start_index: Tensor,
+                valid_ratios: Tensor, reg_branches: nn.ModuleList,
+                **kwargs) -> Tensor:
+        """Forward function of Transformer decoder.
+
+        Args:
+            query (Tensor): The input query, has shape (bs, num_queries,
+                dims).
+            value (Tensor): The input values, has shape (bs, num_value, dim).
+            key_padding_mask (Tensor): The `key_padding_mask` of `cross_attn`
+                input. ByteTensor, has shape (bs, num_value).
+            self_attn_mask (Tensor): The attention mask to prevent information
+                leakage from different denoising groups, distinct queries and
+                dense queries, has shape (num_queries_total,
+                num_queries_total). It will be updated for distinct queries
+                selection in this forward function. It is `None` when
+                `self.training` is `False`.
+            reference_points (Tensor): The initial reference, has shape
+                (bs, num_queries, 4) with the last dimension arranged as
+                (cx, cy, w, h).
+            spatial_shapes (Tensor): Spatial shapes of features in all levels,
+                has shape (num_levels, 2), last dimension represents (h, w).
+            level_start_index (Tensor): The start index of each level.
+                A tensor has shape (num_levels, ) and can be represented
+                as [0, h_0*w_0, h_0*w_0+h_1*w_1, ...].
+            valid_ratios (Tensor): The ratios of the valid width and the valid
+                height relative to the width and the height of features in all
+                levels, has shape (bs, num_levels, 2).
+            reg_branches: (obj:`nn.ModuleList`): Used for refining the
+                regression results.
+
+        Returns:
+            tuple[Tensor]: Output queries and references of Transformer
+                decoder
+
+            - query (Tensor): Output embeddings of the last decoder, has
+              shape (bs, num_queries, embed_dims) when `return_intermediate`
+              is `False`. Otherwise, Intermediate output embeddings of all
+              decoder layers, has shape (num_decoder_layers, bs, num_queries,
+              embed_dims).
+            - reference_points (Tensor): The reference of the last decoder
+              layer, has shape (bs, num_queries, 4) when `return_intermediate`
+              is `False`. Otherwise, Intermediate references of all decoder
+              layers, has shape (1 + num_decoder_layers, bs, num_queries, 4).
+              The coordinates are arranged as (cx, cy, w, h).
+        """
+        intermediate = []
+        intermediate_reference_points = [reference_points]
+        self.cache_dict['distinct_query_mask'] = []
+        if self_attn_mask is None:
+            self_attn_mask = torch.zeros((query.size(1), query.size(1)),
+                                         device=query.device).bool()
+        # shape is (batch*number_heads, num_queries, num_queries)
+        self_attn_mask = self_attn_mask[None].repeat(
+            len(query) * self.cache_dict['num_heads'], 1, 1)
+        for layer_index, layer in enumerate(self.layers):
+            if reference_points.shape[-1] == 4:
+                reference_points_input = \
+                    reference_points[:, :, None] * torch.cat(
+                        [valid_ratios, valid_ratios], -1)[:, None]
+            else:
+                assert reference_points.shape[-1] == 2
+                reference_points_input = \
+                    reference_points[:, :, None] * valid_ratios[:, None]
+
+            query_sine_embed = coordinate_to_encoding(
+                reference_points_input[:, :, 0, :],
+                num_feats=self.embed_dims // 2)
+            query_pos = self.ref_point_head(query_sine_embed)
+
+            query = layer(
+                query,
+                query_pos=query_pos,
+                value=value,
+                key_padding_mask=key_padding_mask,
+                self_attn_mask=self_attn_mask,
+                spatial_shapes=spatial_shapes,
+                level_start_index=level_start_index,
+                valid_ratios=valid_ratios,
+                reference_points=reference_points_input,
+                **kwargs)
+
+            if not self.training:
+                tmp = reg_branches[layer_index](query)
+                assert reference_points.shape[-1] == 4
+                new_reference_points = tmp + inverse_sigmoid(
+                    reference_points, eps=1e-3)
+                new_reference_points = new_reference_points.sigmoid()
+                reference_points = new_reference_points.detach()
+                if layer_index < (len(self.layers) - 1):
+                    self_attn_mask = self.select_distinct_queries(
+                        reference_points, query, self_attn_mask, layer_index)
+
+            else:
+                num_dense = self.cache_dict['num_dense_queries']
+                tmp = reg_branches[layer_index](query[:, :-num_dense])
+                tmp_dense = self.aux_reg_branches[layer_index](
+                    query[:, -num_dense:])
+
+                tmp = torch.cat([tmp, tmp_dense], dim=1)
+                assert reference_points.shape[-1] == 4
+                new_reference_points = tmp + inverse_sigmoid(
+                    reference_points, eps=1e-3)
+                new_reference_points = new_reference_points.sigmoid()
+                reference_points = new_reference_points.detach()
+                if layer_index < (len(self.layers) - 1):
+                    self_attn_mask = self.select_distinct_queries(
+                        reference_points, query, self_attn_mask, layer_index)
+
+            if self.return_intermediate:
+                intermediate.append(self.norm(query))
+                intermediate_reference_points.append(new_reference_points)
+
+        if self.return_intermediate:
+            return torch.stack(intermediate), torch.stack(
+                intermediate_reference_points)
+
+        return query, reference_points
diff --git a/mmdetection/mmdet/models/layers/transformer/deformable_detr_layers.py b/mmdetection/mmdet/models/layers/transformer/deformable_detr_layers.py
new file mode 100644
index 00000000..da6325d6
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/transformer/deformable_detr_layers.py
@@ -0,0 +1,265 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Tuple, Union
+
+import torch
+from mmcv.cnn import build_norm_layer
+from mmcv.cnn.bricks.transformer import FFN, MultiheadAttention
+from mmcv.ops import MultiScaleDeformableAttention
+from mmengine.model import ModuleList
+from torch import Tensor, nn
+
+from .detr_layers import (DetrTransformerDecoder, DetrTransformerDecoderLayer,
+                          DetrTransformerEncoder, DetrTransformerEncoderLayer)
+from .utils import inverse_sigmoid
+
+try:
+    from fairscale.nn.checkpoint import checkpoint_wrapper
+except Exception:
+    checkpoint_wrapper = None
+
+
+class DeformableDetrTransformerEncoder(DetrTransformerEncoder):
+    """Transformer encoder of Deformable DETR."""
+
+    def _init_layers(self) -> None:
+        """Initialize encoder layers."""
+        self.layers = ModuleList([
+            DeformableDetrTransformerEncoderLayer(**self.layer_cfg)
+            for _ in range(self.num_layers)
+        ])
+
+        if self.num_cp > 0:
+            if checkpoint_wrapper is None:
+                raise NotImplementedError(
+                    'If you want to reduce GPU memory usage, \
+                    please install fairscale by executing the \
+                    following command: pip install fairscale.')
+            for i in range(self.num_cp):
+                self.layers[i] = checkpoint_wrapper(self.layers[i])
+
+        self.embed_dims = self.layers[0].embed_dims
+
+    def forward(self, query: Tensor, query_pos: Tensor,
+                key_padding_mask: Tensor, spatial_shapes: Tensor,
+                level_start_index: Tensor, valid_ratios: Tensor,
+                **kwargs) -> Tensor:
+        """Forward function of Transformer encoder.
+
+        Args:
+            query (Tensor): The input query, has shape (bs, num_queries, dim).
+            query_pos (Tensor): The positional encoding for query, has shape
+                (bs, num_queries, dim).
+            key_padding_mask (Tensor): The `key_padding_mask` of `self_attn`
+                input. ByteTensor, has shape (bs, num_queries).
+            spatial_shapes (Tensor): Spatial shapes of features in all levels,
+                has shape (num_levels, 2), last dimension represents (h, w).
+            level_start_index (Tensor): The start index of each level.
+                A tensor has shape (num_levels, ) and can be represented
+                as [0, h_0*w_0, h_0*w_0+h_1*w_1, ...].
+            valid_ratios (Tensor): The ratios of the valid width and the valid
+                height relative to the width and the height of features in all
+                levels, has shape (bs, num_levels, 2).
+
+        Returns:
+            Tensor: Output queries of Transformer encoder, which is also
+            called 'encoder output embeddings' or 'memory', has shape
+            (bs, num_queries, dim)
+        """
+        reference_points = self.get_encoder_reference_points(
+            spatial_shapes, valid_ratios, device=query.device)
+        for layer in self.layers:
+            query = layer(
+                query=query,
+                query_pos=query_pos,
+                key_padding_mask=key_padding_mask,
+                spatial_shapes=spatial_shapes,
+                level_start_index=level_start_index,
+                valid_ratios=valid_ratios,
+                reference_points=reference_points,
+                **kwargs)
+        return query
+
+    @staticmethod
+    def get_encoder_reference_points(
+            spatial_shapes: Tensor, valid_ratios: Tensor,
+            device: Union[torch.device, str]) -> Tensor:
+        """Get the reference points used in encoder.
+
+        Args:
+            spatial_shapes (Tensor): Spatial shapes of features in all levels,
+                has shape (num_levels, 2), last dimension represents (h, w).
+            valid_ratios (Tensor): The ratios of the valid width and the valid
+                height relative to the width and the height of features in all
+                levels, has shape (bs, num_levels, 2).
+            device (obj:`device` or str): The device acquired by the
+                `reference_points`.
+
+        Returns:
+            Tensor: Reference points used in decoder, has shape (bs, length,
+            num_levels, 2).
+        """
+
+        reference_points_list = []
+        for lvl, (H, W) in enumerate(spatial_shapes):
+            ref_y, ref_x = torch.meshgrid(
+                torch.linspace(
+                    0.5, H - 0.5, H, dtype=torch.float32, device=device),
+                torch.linspace(
+                    0.5, W - 0.5, W, dtype=torch.float32, device=device))
+            ref_y = ref_y.reshape(-1)[None] / (
+                valid_ratios[:, None, lvl, 1] * H)
+            ref_x = ref_x.reshape(-1)[None] / (
+                valid_ratios[:, None, lvl, 0] * W)
+            ref = torch.stack((ref_x, ref_y), -1)
+            reference_points_list.append(ref)
+        reference_points = torch.cat(reference_points_list, 1)
+        # [bs, sum(hw), num_level, 2]
+        reference_points = reference_points[:, :, None] * valid_ratios[:, None]
+        return reference_points
+
+
+class DeformableDetrTransformerDecoder(DetrTransformerDecoder):
+    """Transformer Decoder of Deformable DETR."""
+
+    def _init_layers(self) -> None:
+        """Initialize decoder layers."""
+        self.layers = ModuleList([
+            DeformableDetrTransformerDecoderLayer(**self.layer_cfg)
+            for _ in range(self.num_layers)
+        ])
+        self.embed_dims = self.layers[0].embed_dims
+        if self.post_norm_cfg is not None:
+            raise ValueError('There is not post_norm in '
+                             f'{self._get_name()}')
+
+    def forward(self,
+                query: Tensor,
+                query_pos: Tensor,
+                value: Tensor,
+                key_padding_mask: Tensor,
+                reference_points: Tensor,
+                spatial_shapes: Tensor,
+                level_start_index: Tensor,
+                valid_ratios: Tensor,
+                reg_branches: Optional[nn.Module] = None,
+                **kwargs) -> Tuple[Tensor]:
+        """Forward function of Transformer decoder.
+
+        Args:
+            query (Tensor): The input queries, has shape (bs, num_queries,
+                dim).
+            query_pos (Tensor): The input positional query, has shape
+                (bs, num_queries, dim). It will be added to `query` before
+                forward function.
+            value (Tensor): The input values, has shape (bs, num_value, dim).
+            key_padding_mask (Tensor): The `key_padding_mask` of `cross_attn`
+                input. ByteTensor, has shape (bs, num_value).
+            reference_points (Tensor): The initial reference, has shape
+                (bs, num_queries, 4) with the last dimension arranged as
+                (cx, cy, w, h) when `as_two_stage` is `True`, otherwise has
+                shape (bs, num_queries, 2) with the last dimension arranged
+                as (cx, cy).
+            spatial_shapes (Tensor): Spatial shapes of features in all levels,
+                has shape (num_levels, 2), last dimension represents (h, w).
+            level_start_index (Tensor): The start index of each level.
+                A tensor has shape (num_levels, ) and can be represented
+                as [0, h_0*w_0, h_0*w_0+h_1*w_1, ...].
+            valid_ratios (Tensor): The ratios of the valid width and the valid
+                height relative to the width and the height of features in all
+                levels, has shape (bs, num_levels, 2).
+            reg_branches: (obj:`nn.ModuleList`, optional): Used for refining
+                the regression results. Only would be passed when
+                `with_box_refine` is `True`, otherwise would be `None`.
+
+        Returns:
+            tuple[Tensor]: Outputs of Deformable Transformer Decoder.
+
+            - output (Tensor): Output embeddings of the last decoder, has
+              shape (num_queries, bs, embed_dims) when `return_intermediate`
+              is `False`. Otherwise, Intermediate output embeddings of all
+              decoder layers, has shape (num_decoder_layers, num_queries, bs,
+              embed_dims).
+            - reference_points (Tensor): The reference of the last decoder
+              layer, has shape (bs, num_queries, 4)  when `return_intermediate`
+              is `False`. Otherwise, Intermediate references of all decoder
+              layers, has shape (num_decoder_layers, bs, num_queries, 4). The
+              coordinates are arranged as (cx, cy, w, h)
+        """
+        output = query
+        intermediate = []
+        intermediate_reference_points = []
+        for layer_id, layer in enumerate(self.layers):
+            if reference_points.shape[-1] == 4:
+                reference_points_input = \
+                    reference_points[:, :, None] * \
+                    torch.cat([valid_ratios, valid_ratios], -1)[:, None]
+            else:
+                assert reference_points.shape[-1] == 2
+                reference_points_input = \
+                    reference_points[:, :, None] * \
+                    valid_ratios[:, None]
+            output = layer(
+                output,
+                query_pos=query_pos,
+                value=value,
+                key_padding_mask=key_padding_mask,
+                spatial_shapes=spatial_shapes,
+                level_start_index=level_start_index,
+                valid_ratios=valid_ratios,
+                reference_points=reference_points_input,
+                **kwargs)
+
+            if reg_branches is not None:
+                tmp_reg_preds = reg_branches[layer_id](output)
+                if reference_points.shape[-1] == 4:
+                    new_reference_points = tmp_reg_preds + inverse_sigmoid(
+                        reference_points)
+                    new_reference_points = new_reference_points.sigmoid()
+                else:
+                    assert reference_points.shape[-1] == 2
+                    new_reference_points = tmp_reg_preds
+                    new_reference_points[..., :2] = tmp_reg_preds[
+                        ..., :2] + inverse_sigmoid(reference_points)
+                    new_reference_points = new_reference_points.sigmoid()
+                reference_points = new_reference_points.detach()
+
+            if self.return_intermediate:
+                intermediate.append(output)
+                intermediate_reference_points.append(reference_points)
+
+        if self.return_intermediate:
+            return torch.stack(intermediate), torch.stack(
+                intermediate_reference_points)
+
+        return output, reference_points
+
+
+class DeformableDetrTransformerEncoderLayer(DetrTransformerEncoderLayer):
+    """Encoder layer of Deformable DETR."""
+
+    def _init_layers(self) -> None:
+        """Initialize self_attn, ffn, and norms."""
+        self.self_attn = MultiScaleDeformableAttention(**self.self_attn_cfg)
+        self.embed_dims = self.self_attn.embed_dims
+        self.ffn = FFN(**self.ffn_cfg)
+        norms_list = [
+            build_norm_layer(self.norm_cfg, self.embed_dims)[1]
+            for _ in range(2)
+        ]
+        self.norms = ModuleList(norms_list)
+
+
+class DeformableDetrTransformerDecoderLayer(DetrTransformerDecoderLayer):
+    """Decoder layer of Deformable DETR."""
+
+    def _init_layers(self) -> None:
+        """Initialize self_attn, cross-attn, ffn, and norms."""
+        self.self_attn = MultiheadAttention(**self.self_attn_cfg)
+        self.cross_attn = MultiScaleDeformableAttention(**self.cross_attn_cfg)
+        self.embed_dims = self.self_attn.embed_dims
+        self.ffn = FFN(**self.ffn_cfg)
+        norms_list = [
+            build_norm_layer(self.norm_cfg, self.embed_dims)[1]
+            for _ in range(3)
+        ]
+        self.norms = ModuleList(norms_list)
diff --git a/mmdetection/mmdet/models/layers/transformer/detr_layers.py b/mmdetection/mmdet/models/layers/transformer/detr_layers.py
new file mode 100644
index 00000000..6a83dd2f
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/transformer/detr_layers.py
@@ -0,0 +1,374 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Union
+
+import torch
+from mmcv.cnn import build_norm_layer
+from mmcv.cnn.bricks.transformer import FFN, MultiheadAttention
+from mmengine import ConfigDict
+from mmengine.model import BaseModule, ModuleList
+from torch import Tensor
+
+from mmdet.utils import ConfigType, OptConfigType
+
+try:
+    from fairscale.nn.checkpoint import checkpoint_wrapper
+except Exception:
+    checkpoint_wrapper = None
+
+
+class DetrTransformerEncoder(BaseModule):
+    """Encoder of DETR.
+
+    Args:
+        num_layers (int): Number of encoder layers.
+        layer_cfg (:obj:`ConfigDict` or dict): the config of each encoder
+            layer. All the layers will share the same config.
+        num_cp (int): Number of checkpointing blocks in encoder layer.
+            Default to -1.
+        init_cfg (:obj:`ConfigDict` or dict, optional): the config to control
+            the initialization. Defaults to None.
+    """
+
+    def __init__(self,
+                 num_layers: int,
+                 layer_cfg: ConfigType,
+                 num_cp: int = -1,
+                 init_cfg: OptConfigType = None) -> None:
+
+        super().__init__(init_cfg=init_cfg)
+        self.num_layers = num_layers
+        self.layer_cfg = layer_cfg
+        self.num_cp = num_cp
+        assert self.num_cp <= self.num_layers
+        self._init_layers()
+
+    def _init_layers(self) -> None:
+        """Initialize encoder layers."""
+        self.layers = ModuleList([
+            DetrTransformerEncoderLayer(**self.layer_cfg)
+            for _ in range(self.num_layers)
+        ])
+
+        if self.num_cp > 0:
+            if checkpoint_wrapper is None:
+                raise NotImplementedError(
+                    'If you want to reduce GPU memory usage, \
+                    please install fairscale by executing the \
+                    following command: pip install fairscale.')
+            for i in range(self.num_cp):
+                self.layers[i] = checkpoint_wrapper(self.layers[i])
+
+        self.embed_dims = self.layers[0].embed_dims
+
+    def forward(self, query: Tensor, query_pos: Tensor,
+                key_padding_mask: Tensor, **kwargs) -> Tensor:
+        """Forward function of encoder.
+
+        Args:
+            query (Tensor): Input queries of encoder, has shape
+                (bs, num_queries, dim).
+            query_pos (Tensor): The positional embeddings of the queries, has
+                shape (bs, num_queries, dim).
+            key_padding_mask (Tensor): The `key_padding_mask` of `self_attn`
+                input. ByteTensor, has shape (bs, num_queries).
+
+        Returns:
+            Tensor: Has shape (bs, num_queries, dim) if `batch_first` is
+            `True`, otherwise (num_queries, bs, dim).
+        """
+        for layer in self.layers:
+            query = layer(query, query_pos, key_padding_mask, **kwargs)
+        return query
+
+
+class DetrTransformerDecoder(BaseModule):
+    """Decoder of DETR.
+
+    Args:
+        num_layers (int): Number of decoder layers.
+        layer_cfg (:obj:`ConfigDict` or dict): the config of each encoder
+            layer. All the layers will share the same config.
+        post_norm_cfg (:obj:`ConfigDict` or dict, optional): Config of the
+            post normalization layer. Defaults to `LN`.
+        return_intermediate (bool, optional): Whether to return outputs of
+            intermediate layers. Defaults to `True`,
+        init_cfg (:obj:`ConfigDict` or dict, optional): the config to control
+            the initialization. Defaults to None.
+    """
+
+    def __init__(self,
+                 num_layers: int,
+                 layer_cfg: ConfigType,
+                 post_norm_cfg: OptConfigType = dict(type='LN'),
+                 return_intermediate: bool = True,
+                 init_cfg: Union[dict, ConfigDict] = None) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.layer_cfg = layer_cfg
+        self.num_layers = num_layers
+        self.post_norm_cfg = post_norm_cfg
+        self.return_intermediate = return_intermediate
+        self._init_layers()
+
+    def _init_layers(self) -> None:
+        """Initialize decoder layers."""
+        self.layers = ModuleList([
+            DetrTransformerDecoderLayer(**self.layer_cfg)
+            for _ in range(self.num_layers)
+        ])
+        self.embed_dims = self.layers[0].embed_dims
+        self.post_norm = build_norm_layer(self.post_norm_cfg,
+                                          self.embed_dims)[1]
+
+    def forward(self, query: Tensor, key: Tensor, value: Tensor,
+                query_pos: Tensor, key_pos: Tensor, key_padding_mask: Tensor,
+                **kwargs) -> Tensor:
+        """Forward function of decoder
+        Args:
+            query (Tensor): The input query, has shape (bs, num_queries, dim).
+            key (Tensor): The input key, has shape (bs, num_keys, dim).
+            value (Tensor): The input value with the same shape as `key`.
+            query_pos (Tensor): The positional encoding for `query`, with the
+                same shape as `query`.
+            key_pos (Tensor): The positional encoding for `key`, with the
+                same shape as `key`.
+            key_padding_mask (Tensor): The `key_padding_mask` of `cross_attn`
+                input. ByteTensor, has shape (bs, num_value).
+
+        Returns:
+            Tensor: The forwarded results will have shape
+            (num_decoder_layers, bs, num_queries, dim) if
+            `return_intermediate` is `True` else (1, bs, num_queries, dim).
+        """
+        intermediate = []
+        for layer in self.layers:
+            query = layer(
+                query,
+                key=key,
+                value=value,
+                query_pos=query_pos,
+                key_pos=key_pos,
+                key_padding_mask=key_padding_mask,
+                **kwargs)
+            if self.return_intermediate:
+                intermediate.append(self.post_norm(query))
+        query = self.post_norm(query)
+
+        if self.return_intermediate:
+            return torch.stack(intermediate)
+
+        return query.unsqueeze(0)
+
+
+class DetrTransformerEncoderLayer(BaseModule):
+    """Implements encoder layer in DETR transformer.
+
+    Args:
+        self_attn_cfg (:obj:`ConfigDict` or dict, optional): Config for self
+            attention.
+        ffn_cfg (:obj:`ConfigDict` or dict, optional): Config for FFN.
+        norm_cfg (:obj:`ConfigDict` or dict, optional): Config for
+            normalization layers. All the layers will share the same
+            config. Defaults to `LN`.
+        init_cfg (:obj:`ConfigDict` or dict, optional): Config to control
+            the initialization. Defaults to None.
+    """
+
+    def __init__(self,
+                 self_attn_cfg: OptConfigType = dict(
+                     embed_dims=256, num_heads=8, dropout=0.0),
+                 ffn_cfg: OptConfigType = dict(
+                     embed_dims=256,
+                     feedforward_channels=1024,
+                     num_fcs=2,
+                     ffn_drop=0.,
+                     act_cfg=dict(type='ReLU', inplace=True)),
+                 norm_cfg: OptConfigType = dict(type='LN'),
+                 init_cfg: OptConfigType = None) -> None:
+
+        super().__init__(init_cfg=init_cfg)
+
+        self.self_attn_cfg = self_attn_cfg
+        if 'batch_first' not in self.self_attn_cfg:
+            self.self_attn_cfg['batch_first'] = True
+        else:
+            assert self.self_attn_cfg['batch_first'] is True, 'First \
+            dimension of all DETRs in mmdet is `batch`, \
+            please set `batch_first` flag.'
+
+        self.ffn_cfg = ffn_cfg
+        self.norm_cfg = norm_cfg
+        self._init_layers()
+
+    def _init_layers(self) -> None:
+        """Initialize self-attention, FFN, and normalization."""
+        self.self_attn = MultiheadAttention(**self.self_attn_cfg)
+        self.embed_dims = self.self_attn.embed_dims
+        self.ffn = FFN(**self.ffn_cfg)
+        norms_list = [
+            build_norm_layer(self.norm_cfg, self.embed_dims)[1]
+            for _ in range(2)
+        ]
+        self.norms = ModuleList(norms_list)
+
+    def forward(self, query: Tensor, query_pos: Tensor,
+                key_padding_mask: Tensor, **kwargs) -> Tensor:
+        """Forward function of an encoder layer.
+
+        Args:
+            query (Tensor): The input query, has shape (bs, num_queries, dim).
+            query_pos (Tensor): The positional encoding for query, with
+                the same shape as `query`.
+            key_padding_mask (Tensor): The `key_padding_mask` of `self_attn`
+                input. ByteTensor. has shape (bs, num_queries).
+        Returns:
+            Tensor: forwarded results, has shape (bs, num_queries, dim).
+        """
+        query = self.self_attn(
+            query=query,
+            key=query,
+            value=query,
+            query_pos=query_pos,
+            key_pos=query_pos,
+            key_padding_mask=key_padding_mask,
+            **kwargs)
+        query = self.norms[0](query)
+        query = self.ffn(query)
+        query = self.norms[1](query)
+
+        return query
+
+
+class DetrTransformerDecoderLayer(BaseModule):
+    """Implements decoder layer in DETR transformer.
+
+    Args:
+        self_attn_cfg (:obj:`ConfigDict` or dict, optional): Config for self
+            attention.
+        cross_attn_cfg (:obj:`ConfigDict` or dict, optional): Config for cross
+            attention.
+        ffn_cfg (:obj:`ConfigDict` or dict, optional): Config for FFN.
+        norm_cfg (:obj:`ConfigDict` or dict, optional): Config for
+            normalization layers. All the layers will share the same
+            config. Defaults to `LN`.
+        init_cfg (:obj:`ConfigDict` or dict, optional): Config to control
+            the initialization. Defaults to None.
+    """
+
+    def __init__(self,
+                 self_attn_cfg: OptConfigType = dict(
+                     embed_dims=256,
+                     num_heads=8,
+                     dropout=0.0,
+                     batch_first=True),
+                 cross_attn_cfg: OptConfigType = dict(
+                     embed_dims=256,
+                     num_heads=8,
+                     dropout=0.0,
+                     batch_first=True),
+                 ffn_cfg: OptConfigType = dict(
+                     embed_dims=256,
+                     feedforward_channels=1024,
+                     num_fcs=2,
+                     ffn_drop=0.,
+                     act_cfg=dict(type='ReLU', inplace=True),
+                 ),
+                 norm_cfg: OptConfigType = dict(type='LN'),
+                 init_cfg: OptConfigType = None) -> None:
+
+        super().__init__(init_cfg=init_cfg)
+
+        self.self_attn_cfg = self_attn_cfg
+        self.cross_attn_cfg = cross_attn_cfg
+        if 'batch_first' not in self.self_attn_cfg:
+            self.self_attn_cfg['batch_first'] = True
+        else:
+            assert self.self_attn_cfg['batch_first'] is True, 'First \
+            dimension of all DETRs in mmdet is `batch`, \
+            please set `batch_first` flag.'
+
+        if 'batch_first' not in self.cross_attn_cfg:
+            self.cross_attn_cfg['batch_first'] = True
+        else:
+            assert self.cross_attn_cfg['batch_first'] is True, 'First \
+            dimension of all DETRs in mmdet is `batch`, \
+            please set `batch_first` flag.'
+
+        self.ffn_cfg = ffn_cfg
+        self.norm_cfg = norm_cfg
+        self._init_layers()
+
+    def _init_layers(self) -> None:
+        """Initialize self-attention, FFN, and normalization."""
+        self.self_attn = MultiheadAttention(**self.self_attn_cfg)
+        self.cross_attn = MultiheadAttention(**self.cross_attn_cfg)
+        self.embed_dims = self.self_attn.embed_dims
+        self.ffn = FFN(**self.ffn_cfg)
+        norms_list = [
+            build_norm_layer(self.norm_cfg, self.embed_dims)[1]
+            for _ in range(3)
+        ]
+        self.norms = ModuleList(norms_list)
+
+    def forward(self,
+                query: Tensor,
+                key: Tensor = None,
+                value: Tensor = None,
+                query_pos: Tensor = None,
+                key_pos: Tensor = None,
+                self_attn_mask: Tensor = None,
+                cross_attn_mask: Tensor = None,
+                key_padding_mask: Tensor = None,
+                **kwargs) -> Tensor:
+        """
+        Args:
+            query (Tensor): The input query, has shape (bs, num_queries, dim).
+            key (Tensor, optional): The input key, has shape (bs, num_keys,
+                dim). If `None`, the `query` will be used. Defaults to `None`.
+            value (Tensor, optional): The input value, has the same shape as
+                `key`, as in `nn.MultiheadAttention.forward`. If `None`, the
+                `key` will be used. Defaults to `None`.
+            query_pos (Tensor, optional): The positional encoding for `query`,
+                has the same shape as `query`. If not `None`, it will be added
+                to `query` before forward function. Defaults to `None`.
+            key_pos (Tensor, optional): The positional encoding for `key`, has
+                the same shape as `key`. If not `None`, it will be added to
+                `key` before forward function. If None, and `query_pos` has the
+                same shape as `key`, then `query_pos` will be used for
+                `key_pos`. Defaults to None.
+            self_attn_mask (Tensor, optional): ByteTensor mask, has shape
+                (num_queries, num_keys), as in `nn.MultiheadAttention.forward`.
+                Defaults to None.
+            cross_attn_mask (Tensor, optional): ByteTensor mask, has shape
+                (num_queries, num_keys), as in `nn.MultiheadAttention.forward`.
+                Defaults to None.
+            key_padding_mask (Tensor, optional): The `key_padding_mask` of
+                `self_attn` input. ByteTensor, has shape (bs, num_value).
+                Defaults to None.
+
+        Returns:
+            Tensor: forwarded results, has shape (bs, num_queries, dim).
+        """
+
+        query = self.self_attn(
+            query=query,
+            key=query,
+            value=query,
+            query_pos=query_pos,
+            key_pos=query_pos,
+            attn_mask=self_attn_mask,
+            **kwargs)
+        query = self.norms[0](query)
+        query = self.cross_attn(
+            query=query,
+            key=key,
+            value=value,
+            query_pos=query_pos,
+            key_pos=key_pos,
+            attn_mask=cross_attn_mask,
+            key_padding_mask=key_padding_mask,
+            **kwargs)
+        query = self.norms[1](query)
+        query = self.ffn(query)
+        query = self.norms[2](query)
+
+        return query
diff --git a/mmdetection/mmdet/models/layers/transformer/dino_layers.py b/mmdetection/mmdet/models/layers/transformer/dino_layers.py
new file mode 100644
index 00000000..64610d0a
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/transformer/dino_layers.py
@@ -0,0 +1,562 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+from typing import Tuple, Union
+
+import torch
+from mmengine.model import BaseModule
+from torch import Tensor, nn
+
+from mmdet.structures import SampleList
+from mmdet.structures.bbox import bbox_xyxy_to_cxcywh
+from mmdet.utils import OptConfigType
+from .deformable_detr_layers import DeformableDetrTransformerDecoder
+from .utils import MLP, coordinate_to_encoding, inverse_sigmoid
+
+
+class DinoTransformerDecoder(DeformableDetrTransformerDecoder):
+    """Transformer decoder of DINO."""
+
+    def _init_layers(self) -> None:
+        """Initialize decoder layers."""
+        super()._init_layers()
+        self.ref_point_head = MLP(self.embed_dims * 2, self.embed_dims,
+                                  self.embed_dims, 2)
+        self.norm = nn.LayerNorm(self.embed_dims)
+
+    def forward(self, query: Tensor, value: Tensor, key_padding_mask: Tensor,
+                self_attn_mask: Tensor, reference_points: Tensor,
+                spatial_shapes: Tensor, level_start_index: Tensor,
+                valid_ratios: Tensor, reg_branches: nn.ModuleList,
+                **kwargs) -> Tuple[Tensor]:
+        """Forward function of Transformer decoder.
+
+        Args:
+            query (Tensor): The input query, has shape (num_queries, bs, dim).
+            value (Tensor): The input values, has shape (num_value, bs, dim).
+            key_padding_mask (Tensor): The `key_padding_mask` of `self_attn`
+                input. ByteTensor, has shape (num_queries, bs).
+            self_attn_mask (Tensor): The attention mask to prevent information
+                leakage from different denoising groups and matching parts, has
+                shape (num_queries_total, num_queries_total). It is `None` when
+                `self.training` is `False`.
+            reference_points (Tensor): The initial reference, has shape
+                (bs, num_queries, 4) with the last dimension arranged as
+                (cx, cy, w, h).
+            spatial_shapes (Tensor): Spatial shapes of features in all levels,
+                has shape (num_levels, 2), last dimension represents (h, w).
+            level_start_index (Tensor): The start index of each level.
+                A tensor has shape (num_levels, ) and can be represented
+                as [0, h_0*w_0, h_0*w_0+h_1*w_1, ...].
+            valid_ratios (Tensor): The ratios of the valid width and the valid
+                height relative to the width and the height of features in all
+                levels, has shape (bs, num_levels, 2).
+            reg_branches: (obj:`nn.ModuleList`): Used for refining the
+                regression results.
+
+        Returns:
+            tuple[Tensor]: Output queries and references of Transformer
+                decoder
+
+            - query (Tensor): Output embeddings of the last decoder, has
+              shape (num_queries, bs, embed_dims) when `return_intermediate`
+              is `False`. Otherwise, Intermediate output embeddings of all
+              decoder layers, has shape (num_decoder_layers, num_queries, bs,
+              embed_dims).
+            - reference_points (Tensor): The reference of the last decoder
+              layer, has shape (bs, num_queries, 4)  when `return_intermediate`
+              is `False`. Otherwise, Intermediate references of all decoder
+              layers, has shape (num_decoder_layers, bs, num_queries, 4). The
+              coordinates are arranged as (cx, cy, w, h)
+        """
+        intermediate = []
+        intermediate_reference_points = [reference_points]
+        for lid, layer in enumerate(self.layers):
+            if reference_points.shape[-1] == 4:
+                reference_points_input = \
+                    reference_points[:, :, None] * torch.cat(
+                        [valid_ratios, valid_ratios], -1)[:, None]
+            else:
+                assert reference_points.shape[-1] == 2
+                reference_points_input = \
+                    reference_points[:, :, None] * valid_ratios[:, None]
+
+            query_sine_embed = coordinate_to_encoding(
+                reference_points_input[:, :, 0, :])
+            query_pos = self.ref_point_head(query_sine_embed)
+
+            query = layer(
+                query,
+                query_pos=query_pos,
+                value=value,
+                key_padding_mask=key_padding_mask,
+                self_attn_mask=self_attn_mask,
+                spatial_shapes=spatial_shapes,
+                level_start_index=level_start_index,
+                valid_ratios=valid_ratios,
+                reference_points=reference_points_input,
+                **kwargs)
+
+            if reg_branches is not None:
+                tmp = reg_branches[lid](query)
+                assert reference_points.shape[-1] == 4
+                new_reference_points = tmp + inverse_sigmoid(
+                    reference_points, eps=1e-3)
+                new_reference_points = new_reference_points.sigmoid()
+                reference_points = new_reference_points.detach()
+
+            if self.return_intermediate:
+                intermediate.append(self.norm(query))
+                intermediate_reference_points.append(new_reference_points)
+                # NOTE this is for the "Look Forward Twice" module,
+                # in the DeformDETR, reference_points was appended.
+
+        if self.return_intermediate:
+            return torch.stack(intermediate), torch.stack(
+                intermediate_reference_points)
+
+        return query, reference_points
+
+
+class CdnQueryGenerator(BaseModule):
+    """Implement query generator of the Contrastive denoising (CDN) proposed in
+    `DINO: DETR with Improved DeNoising Anchor Boxes for End-to-End Object
+    Detection `_
+
+    Code is modified from the `official github repo
+    `_.
+
+    Args:
+        num_classes (int): Number of object classes.
+        embed_dims (int): The embedding dimensions of the generated queries.
+        num_matching_queries (int): The queries number of the matching part.
+            Used for generating dn_mask.
+        label_noise_scale (float): The scale of label noise, defaults to 0.5.
+        box_noise_scale (float): The scale of box noise, defaults to 1.0.
+        group_cfg (:obj:`ConfigDict` or dict, optional): The config of the
+            denoising queries grouping, includes `dynamic`, `num_dn_queries`,
+            and `num_groups`. Two grouping strategies, 'static dn groups' and
+            'dynamic dn groups', are supported. When `dynamic` is `False`,
+            the `num_groups` should be set, and the number of denoising query
+            groups will always be `num_groups`. When `dynamic` is `True`, the
+            `num_dn_queries` should be set, and the group number will be
+            dynamic to ensure that the denoising queries number will not exceed
+            `num_dn_queries` to prevent large fluctuations of memory. Defaults
+            to `None`.
+    """
+
+    def __init__(self,
+                 num_classes: int,
+                 embed_dims: int,
+                 num_matching_queries: int,
+                 label_noise_scale: float = 0.5,
+                 box_noise_scale: float = 1.0,
+                 group_cfg: OptConfigType = None) -> None:
+        super().__init__()
+        self.num_classes = num_classes
+        self.embed_dims = embed_dims
+        self.num_matching_queries = num_matching_queries
+        self.label_noise_scale = label_noise_scale
+        self.box_noise_scale = box_noise_scale
+
+        # prepare grouping strategy
+        group_cfg = {} if group_cfg is None else group_cfg
+        self.dynamic_dn_groups = group_cfg.get('dynamic', True)
+        if self.dynamic_dn_groups:
+            if 'num_dn_queries' not in group_cfg:
+                warnings.warn("'num_dn_queries' should be set when using "
+                              'dynamic dn groups, use 100 as default.')
+            self.num_dn_queries = group_cfg.get('num_dn_queries', 100)
+            assert isinstance(self.num_dn_queries, int), \
+                f'Expected the num_dn_queries to have type int, but got ' \
+                f'{self.num_dn_queries}({type(self.num_dn_queries)}). '
+        else:
+            assert 'num_groups' in group_cfg, \
+                'num_groups should be set when using static dn groups'
+            self.num_groups = group_cfg['num_groups']
+            assert isinstance(self.num_groups, int), \
+                f'Expected the num_groups to have type int, but got ' \
+                f'{self.num_groups}({type(self.num_groups)}). '
+
+        # NOTE The original repo of DINO set the num_embeddings 92 for coco,
+        # 91 (0~90) of which represents target classes and the 92 (91)
+        # indicates `Unknown` class. However, the embedding of `unknown` class
+        # is not used in the original DINO.
+        # TODO: num_classes + 1 or num_classes ?
+        self.label_embedding = nn.Embedding(self.num_classes, self.embed_dims)
+
+    def __call__(self, batch_data_samples: SampleList) -> tuple:
+        """Generate contrastive denoising (cdn) queries with ground truth.
+
+        Descriptions of the Number Values in code and comments:
+            - num_target_total: the total target number of the input batch
+              samples.
+            - max_num_target: the max target number of the input batch samples.
+            - num_noisy_targets: the total targets number after adding noise,
+              i.e., num_target_total * num_groups * 2.
+            - num_denoising_queries: the length of the output batched queries,
+              i.e., max_num_target * num_groups * 2.
+
+        NOTE The format of input bboxes in batch_data_samples is unnormalized
+        (x, y, x, y), and the output bbox queries are embedded by normalized
+        (cx, cy, w, h) format bboxes going through inverse_sigmoid.
+
+        Args:
+            batch_data_samples (list[:obj:`DetDataSample`]): List of the batch
+                data samples, each includes `gt_instance` which has attributes
+                `bboxes` and `labels`. The `bboxes` has unnormalized coordinate
+                format (x, y, x, y).
+
+        Returns:
+            tuple: The outputs of the dn query generator.
+
+            - dn_label_query (Tensor): The output content queries for denoising
+              part, has shape (bs, num_denoising_queries, dim), where
+              `num_denoising_queries = max_num_target * num_groups * 2`.
+            - dn_bbox_query (Tensor): The output reference bboxes as positions
+              of queries for denoising part, which are embedded by normalized
+              (cx, cy, w, h) format bboxes going through inverse_sigmoid, has
+              shape (bs, num_denoising_queries, 4) with the last dimension
+              arranged as (cx, cy, w, h).
+            - attn_mask (Tensor): The attention mask to prevent information
+              leakage from different denoising groups and matching parts,
+              will be used as `self_attn_mask` of the `decoder`, has shape
+              (num_queries_total, num_queries_total), where `num_queries_total`
+              is the sum of `num_denoising_queries` and `num_matching_queries`.
+            - dn_meta (Dict[str, int]): The dictionary saves information about
+              group collation, including 'num_denoising_queries' and
+              'num_denoising_groups'. It will be used for split outputs of
+              denoising and matching parts and loss calculation.
+        """
+        # normalize bbox and collate ground truth (gt)
+        gt_labels_list = []
+        gt_bboxes_list = []
+        for sample in batch_data_samples:
+            img_h, img_w = sample.img_shape
+            bboxes = sample.gt_instances.bboxes
+            factor = bboxes.new_tensor([img_w, img_h, img_w,
+                                        img_h]).unsqueeze(0)
+            bboxes_normalized = bboxes / factor
+            gt_bboxes_list.append(bboxes_normalized)
+            gt_labels_list.append(sample.gt_instances.labels)
+        gt_labels = torch.cat(gt_labels_list)  # (num_target_total, 4)
+        gt_bboxes = torch.cat(gt_bboxes_list)
+
+        num_target_list = [len(bboxes) for bboxes in gt_bboxes_list]
+        max_num_target = max(num_target_list)
+        num_groups = self.get_num_groups(max_num_target)
+
+        dn_label_query = self.generate_dn_label_query(gt_labels, num_groups)
+        dn_bbox_query = self.generate_dn_bbox_query(gt_bboxes, num_groups)
+
+        # The `batch_idx` saves the batch index of the corresponding sample
+        # for each target, has shape (num_target_total).
+        batch_idx = torch.cat([
+            torch.full_like(t.long(), i) for i, t in enumerate(gt_labels_list)
+        ])
+        dn_label_query, dn_bbox_query = self.collate_dn_queries(
+            dn_label_query, dn_bbox_query, batch_idx, len(batch_data_samples),
+            num_groups)
+
+        attn_mask = self.generate_dn_mask(
+            max_num_target, num_groups, device=dn_label_query.device)
+
+        dn_meta = dict(
+            num_denoising_queries=int(max_num_target * 2 * num_groups),
+            num_denoising_groups=num_groups)
+
+        return dn_label_query, dn_bbox_query, attn_mask, dn_meta
+
+    def get_num_groups(self, max_num_target: int = None) -> int:
+        """Calculate denoising query groups number.
+
+        Two grouping strategies, 'static dn groups' and 'dynamic dn groups',
+        are supported. When `self.dynamic_dn_groups` is `False`, the number
+        of denoising query groups will always be `self.num_groups`. When
+        `self.dynamic_dn_groups` is `True`, the group number will be dynamic,
+        ensuring the denoising queries number will not exceed
+        `self.num_dn_queries` to prevent large fluctuations of memory.
+
+        NOTE The `num_group` is shared for different samples in a batch. When
+        the target numbers in the samples varies, the denoising queries of the
+        samples containing fewer targets are padded to the max length.
+
+        Args:
+            max_num_target (int, optional): The max target number of the batch
+                samples. It will only be used when `self.dynamic_dn_groups` is
+                `True`. Defaults to `None`.
+
+        Returns:
+            int: The denoising group number of the current batch.
+        """
+        if self.dynamic_dn_groups:
+            assert max_num_target is not None, \
+                'group_queries should be provided when using ' \
+                'dynamic dn groups'
+            if max_num_target == 0:
+                num_groups = 1
+            else:
+                num_groups = self.num_dn_queries // max_num_target
+        else:
+            num_groups = self.num_groups
+        if num_groups < 1:
+            num_groups = 1
+        return int(num_groups)
+
+    def generate_dn_label_query(self, gt_labels: Tensor,
+                                num_groups: int) -> Tensor:
+        """Generate noisy labels and their query embeddings.
+
+        The strategy for generating noisy labels is: Randomly choose labels of
+        `self.label_noise_scale * 0.5` proportion and override each of them
+        with a random object category label.
+
+        NOTE Not add noise to all labels. Besides, the `self.label_noise_scale
+        * 0.5` arg is the ratio of the chosen positions, which is higher than
+        the actual proportion of noisy labels, because the labels to override
+        may be correct. And the gap becomes larger as the number of target
+        categories decreases. The users should notice this and modify the scale
+        arg or the corresponding logic according to specific dataset.
+
+        Args:
+            gt_labels (Tensor): The concatenated gt labels of all samples
+                in the batch, has shape (num_target_total, ) where
+                `num_target_total = sum(num_target_list)`.
+            num_groups (int): The number of denoising query groups.
+
+        Returns:
+            Tensor: The query embeddings of noisy labels, has shape
+            (num_noisy_targets, embed_dims), where `num_noisy_targets =
+            num_target_total * num_groups * 2`.
+        """
+        assert self.label_noise_scale > 0
+        gt_labels_expand = gt_labels.repeat(2 * num_groups,
+                                            1).view(-1)  # Note `* 2`  # noqa
+        p = torch.rand_like(gt_labels_expand.float())
+        chosen_indice = torch.nonzero(p < (self.label_noise_scale * 0.5)).view(
+            -1)  # Note `* 0.5`
+        new_labels = torch.randint_like(chosen_indice, 0, self.num_classes)
+        noisy_labels_expand = gt_labels_expand.scatter(0, chosen_indice,
+                                                       new_labels)
+        dn_label_query = self.label_embedding(noisy_labels_expand)
+        return dn_label_query
+
+    def generate_dn_bbox_query(self, gt_bboxes: Tensor,
+                               num_groups: int) -> Tensor:
+        """Generate noisy bboxes and their query embeddings.
+
+        The strategy for generating noisy bboxes is as follow:
+
+        .. code:: text
+
+            +--------------------+
+            |      negative      |
+            |    +----------+    |
+            |    | positive |    |
+            |    |    +-----|----+------------+
+            |    |    |     |    |            |
+            |    +----+-----+    |            |
+            |         |          |            |
+            +---------+----------+            |
+                      |                       |
+                      |        gt bbox        |
+                      |                       |
+                      |             +---------+----------+
+                      |             |         |          |
+                      |             |    +----+-----+    |
+                      |             |    |    |     |    |
+                      +-------------|--- +----+     |    |
+                                    |    | positive |    |
+                                    |    +----------+    |
+                                    |      negative      |
+                                    +--------------------+
+
+         The random noise is added to the top-left and down-right point
+         positions, hence, normalized (x, y, x, y) format of bboxes are
+         required. The noisy bboxes of positive queries have the points
+         both within the inner square, while those of negative queries
+         have the points both between the inner and outer squares.
+
+        Besides, the length of outer square is twice as long as that of
+        the inner square, i.e., self.box_noise_scale * w_or_h / 2.
+        NOTE The noise is added to all the bboxes. Moreover, there is still
+        unconsidered case when one point is within the positive square and
+        the others is between the inner and outer squares.
+
+        Args:
+            gt_bboxes (Tensor): The concatenated gt bboxes of all samples
+                in the batch, has shape (num_target_total, 4) with the last
+                dimension arranged as (cx, cy, w, h) where
+                `num_target_total = sum(num_target_list)`.
+            num_groups (int): The number of denoising query groups.
+
+        Returns:
+            Tensor: The output noisy bboxes, which are embedded by normalized
+            (cx, cy, w, h) format bboxes going through inverse_sigmoid, has
+            shape (num_noisy_targets, 4) with the last dimension arranged as
+            (cx, cy, w, h), where
+            `num_noisy_targets = num_target_total * num_groups * 2`.
+        """
+        assert self.box_noise_scale > 0
+        device = gt_bboxes.device
+
+        # expand gt_bboxes as groups
+        gt_bboxes_expand = gt_bboxes.repeat(2 * num_groups, 1)  # xyxy
+
+        # obtain index of negative queries in gt_bboxes_expand
+        positive_idx = torch.arange(
+            len(gt_bboxes), dtype=torch.long, device=device)
+        positive_idx = positive_idx.unsqueeze(0).repeat(num_groups, 1)
+        positive_idx += 2 * len(gt_bboxes) * torch.arange(
+            num_groups, dtype=torch.long, device=device)[:, None]
+        positive_idx = positive_idx.flatten()
+        negative_idx = positive_idx + len(gt_bboxes)
+
+        # determine the sign of each element in the random part of the added
+        # noise to be positive or negative randomly.
+        rand_sign = torch.randint_like(
+            gt_bboxes_expand, low=0, high=2,
+            dtype=torch.float32) * 2.0 - 1.0  # [low, high), 1 or -1, randomly
+
+        # calculate the random part of the added noise
+        rand_part = torch.rand_like(gt_bboxes_expand)  # [0, 1)
+        rand_part[negative_idx] += 1.0  # pos: [0, 1); neg: [1, 2)
+        rand_part *= rand_sign  # pos: (-1, 1); neg: (-2, -1] U [1, 2)
+
+        # add noise to the bboxes
+        bboxes_whwh = bbox_xyxy_to_cxcywh(gt_bboxes_expand)[:, 2:].repeat(1, 2)
+        noisy_bboxes_expand = gt_bboxes_expand + torch.mul(
+            rand_part, bboxes_whwh) * self.box_noise_scale / 2  # xyxy
+        noisy_bboxes_expand = noisy_bboxes_expand.clamp(min=0.0, max=1.0)
+        noisy_bboxes_expand = bbox_xyxy_to_cxcywh(noisy_bboxes_expand)
+
+        dn_bbox_query = inverse_sigmoid(noisy_bboxes_expand, eps=1e-3)
+        return dn_bbox_query
+
+    def collate_dn_queries(self, input_label_query: Tensor,
+                           input_bbox_query: Tensor, batch_idx: Tensor,
+                           batch_size: int, num_groups: int) -> Tuple[Tensor]:
+        """Collate generated queries to obtain batched dn queries.
+
+        The strategy for query collation is as follow:
+
+        .. code:: text
+
+                    input_queries (num_target_total, query_dim)
+            P_A1 P_B1 P_B2 N_A1 N_B1 N_B2 P'A1 P'B1 P'B2 N'A1 N'B1 N'B2
+              |________ group1 ________|    |________ group2 ________|
+                                         |
+                                         V
+                      P_A1 Pad0 N_A1 Pad0 P'A1 Pad0 N'A1 Pad0
+                      P_B1 P_B2 N_B1 N_B2 P'B1 P'B2 N'B1 N'B2
+                       |____ group1 ____| |____ group2 ____|
+             batched_queries (batch_size, max_num_target, query_dim)
+
+            where query_dim is 4 for bbox and self.embed_dims for label.
+            Notation: _-group 1; '-group 2;
+                      A-Sample1(has 1 target); B-sample2(has 2 targets)
+
+        Args:
+            input_label_query (Tensor): The generated label queries of all
+                targets, has shape (num_target_total, embed_dims) where
+                `num_target_total = sum(num_target_list)`.
+            input_bbox_query (Tensor): The generated bbox queries of all
+                targets, has shape (num_target_total, 4) with the last
+                dimension arranged as (cx, cy, w, h).
+            batch_idx (Tensor): The batch index of the corresponding sample
+                for each target, has shape (num_target_total).
+            batch_size (int): The size of the input batch.
+            num_groups (int): The number of denoising query groups.
+
+        Returns:
+            tuple[Tensor]: Output batched label and bbox queries.
+            - batched_label_query (Tensor): The output batched label queries,
+              has shape (batch_size, max_num_target, embed_dims).
+            - batched_bbox_query (Tensor): The output batched bbox queries,
+              has shape (batch_size, max_num_target, 4) with the last dimension
+              arranged as (cx, cy, w, h).
+        """
+        device = input_label_query.device
+        num_target_list = [
+            torch.sum(batch_idx == idx) for idx in range(batch_size)
+        ]
+        max_num_target = max(num_target_list)
+        num_denoising_queries = int(max_num_target * 2 * num_groups)
+
+        map_query_index = torch.cat([
+            torch.arange(num_target, device=device)
+            for num_target in num_target_list
+        ])
+        map_query_index = torch.cat([
+            map_query_index + max_num_target * i for i in range(2 * num_groups)
+        ]).long()
+        batch_idx_expand = batch_idx.repeat(2 * num_groups, 1).view(-1)
+        mapper = (batch_idx_expand, map_query_index)
+
+        batched_label_query = torch.zeros(
+            batch_size, num_denoising_queries, self.embed_dims, device=device)
+        batched_bbox_query = torch.zeros(
+            batch_size, num_denoising_queries, 4, device=device)
+
+        batched_label_query[mapper] = input_label_query
+        batched_bbox_query[mapper] = input_bbox_query
+        return batched_label_query, batched_bbox_query
+
+    def generate_dn_mask(self, max_num_target: int, num_groups: int,
+                         device: Union[torch.device, str]) -> Tensor:
+        """Generate attention mask to prevent information leakage from
+        different denoising groups and matching parts.
+
+        .. code:: text
+
+                        0 0 0 0 1 1 1 1 0 0 0 0 0
+                        0 0 0 0 1 1 1 1 0 0 0 0 0
+                        0 0 0 0 1 1 1 1 0 0 0 0 0
+                        0 0 0 0 1 1 1 1 0 0 0 0 0
+                        1 1 1 1 0 0 0 0 0 0 0 0 0
+                        1 1 1 1 0 0 0 0 0 0 0 0 0
+                        1 1 1 1 0 0 0 0 0 0 0 0 0
+                        1 1 1 1 0 0 0 0 0 0 0 0 0
+                        1 1 1 1 1 1 1 1 0 0 0 0 0
+                        1 1 1 1 1 1 1 1 0 0 0 0 0
+                        1 1 1 1 1 1 1 1 0 0 0 0 0
+                        1 1 1 1 1 1 1 1 0 0 0 0 0
+                        1 1 1 1 1 1 1 1 0 0 0 0 0
+         max_num_target |_|           |_________| num_matching_queries
+                        |_____________| num_denoising_queries
+
+               1 -> True  (Masked), means 'can not see'.
+               0 -> False (UnMasked), means 'can see'.
+
+        Args:
+            max_num_target (int): The max target number of the input batch
+                samples.
+            num_groups (int): The number of denoising query groups.
+            device (obj:`device` or str): The device of generated mask.
+
+        Returns:
+            Tensor: The attention mask to prevent information leakage from
+            different denoising groups and matching parts, will be used as
+            `self_attn_mask` of the `decoder`, has shape (num_queries_total,
+            num_queries_total), where `num_queries_total` is the sum of
+            `num_denoising_queries` and `num_matching_queries`.
+        """
+        num_denoising_queries = int(max_num_target * 2 * num_groups)
+        num_queries_total = num_denoising_queries + self.num_matching_queries
+        attn_mask = torch.zeros(
+            num_queries_total,
+            num_queries_total,
+            device=device,
+            dtype=torch.bool)
+        # Make the matching part cannot see the denoising groups
+        attn_mask[num_denoising_queries:, :num_denoising_queries] = True
+        # Make the denoising groups cannot see each other
+        for i in range(num_groups):
+            # Mask rows of one group per step.
+            row_scope = slice(max_num_target * 2 * i,
+                              max_num_target * 2 * (i + 1))
+            left_scope = slice(max_num_target * 2 * i)
+            right_scope = slice(max_num_target * 2 * (i + 1),
+                                num_denoising_queries)
+            attn_mask[row_scope, right_scope] = True
+            attn_mask[row_scope, left_scope] = True
+        return attn_mask
diff --git a/mmdetection/mmdet/models/layers/transformer/grounding_dino_layers.py b/mmdetection/mmdet/models/layers/transformer/grounding_dino_layers.py
new file mode 100644
index 00000000..3c285768
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/transformer/grounding_dino_layers.py
@@ -0,0 +1,270 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmcv.cnn import build_norm_layer
+from mmcv.cnn.bricks.transformer import FFN, MultiheadAttention
+from mmcv.ops import MultiScaleDeformableAttention
+from mmengine.model import ModuleList
+from torch import Tensor
+
+from mmdet.models.utils.vlfuse_helper import SingleScaleBiAttentionBlock
+from mmdet.utils import ConfigType, OptConfigType
+from .deformable_detr_layers import (DeformableDetrTransformerDecoderLayer,
+                                     DeformableDetrTransformerEncoder,
+                                     DeformableDetrTransformerEncoderLayer)
+from .detr_layers import DetrTransformerEncoderLayer
+from .dino_layers import DinoTransformerDecoder
+from .utils import MLP, get_text_sine_pos_embed
+
+try:
+    from fairscale.nn.checkpoint import checkpoint_wrapper
+except Exception:
+    checkpoint_wrapper = None
+
+
+class GroundingDinoTransformerDecoderLayer(
+        DeformableDetrTransformerDecoderLayer):
+
+    def __init__(self,
+                 cross_attn_text_cfg: OptConfigType = dict(
+                     embed_dims=256,
+                     num_heads=8,
+                     dropout=0.0,
+                     batch_first=True),
+                 **kwargs) -> None:
+        """Decoder layer of Deformable DETR."""
+        self.cross_attn_text_cfg = cross_attn_text_cfg
+        if 'batch_first' not in self.cross_attn_text_cfg:
+            self.cross_attn_text_cfg['batch_first'] = True
+        super().__init__(**kwargs)
+
+    def _init_layers(self) -> None:
+        """Initialize self_attn, cross-attn, ffn, and norms."""
+        self.self_attn = MultiheadAttention(**self.self_attn_cfg)
+        self.cross_attn_text = MultiheadAttention(**self.cross_attn_text_cfg)
+        self.cross_attn = MultiScaleDeformableAttention(**self.cross_attn_cfg)
+        self.embed_dims = self.self_attn.embed_dims
+        self.ffn = FFN(**self.ffn_cfg)
+        norms_list = [
+            build_norm_layer(self.norm_cfg, self.embed_dims)[1]
+            for _ in range(4)
+        ]
+        self.norms = ModuleList(norms_list)
+
+    def forward(self,
+                query: Tensor,
+                key: Tensor = None,
+                value: Tensor = None,
+                query_pos: Tensor = None,
+                key_pos: Tensor = None,
+                self_attn_mask: Tensor = None,
+                cross_attn_mask: Tensor = None,
+                key_padding_mask: Tensor = None,
+                memory_text: Tensor = None,
+                text_attention_mask: Tensor = None,
+                **kwargs) -> Tensor:
+        """Implements decoder layer in Grounding DINO transformer.
+
+        Args:
+            query (Tensor): The input query, has shape (bs, num_queries, dim).
+            key (Tensor, optional): The input key, has shape (bs, num_keys,
+                dim). If `None`, the `query` will be used. Defaults to `None`.
+            value (Tensor, optional): The input value, has the same shape as
+                `key`, as in `nn.MultiheadAttention.forward`. If `None`, the
+                `key` will be used. Defaults to `None`.
+            query_pos (Tensor, optional): The positional encoding for `query`,
+                has the same shape as `query`. If not `None`, it will be added
+                to `query` before forward function. Defaults to `None`.
+            key_pos (Tensor, optional): The positional encoding for `key`, has
+                the same shape as `key`. If not `None`, it will be added to
+                `key` before forward function. If None, and `query_pos` has the
+                same shape as `key`, then `query_pos` will be used for
+                `key_pos`. Defaults to None.
+            self_attn_mask (Tensor, optional): ByteTensor mask, has shape
+                (num_queries, num_keys), as in `nn.MultiheadAttention.forward`.
+                Defaults to None.
+            cross_attn_mask (Tensor, optional): ByteTensor mask, has shape
+                (num_queries, num_keys), as in `nn.MultiheadAttention.forward`.
+                Defaults to None.
+            key_padding_mask (Tensor, optional): The `key_padding_mask` of
+                `self_attn` input. ByteTensor, has shape (bs, num_value).
+                Defaults to None.
+            memory_text (Tensor): Memory text. It has shape (bs, len_text,
+                text_embed_dims).
+            text_attention_mask (Tensor): Text token mask. It has shape (bs,
+                len_text).
+
+        Returns:
+            Tensor: forwarded results, has shape (bs, num_queries, dim).
+        """
+        # self attention
+        query = self.self_attn(
+            query=query,
+            key=query,
+            value=query,
+            query_pos=query_pos,
+            key_pos=query_pos,
+            attn_mask=self_attn_mask,
+            **kwargs)
+        query = self.norms[0](query)
+        # cross attention between query and text
+        query = self.cross_attn_text(
+            query=query,
+            query_pos=query_pos,
+            key=memory_text,
+            value=memory_text,
+            key_padding_mask=text_attention_mask)
+        query = self.norms[1](query)
+        # cross attention between query and image
+        query = self.cross_attn(
+            query=query,
+            key=key,
+            value=value,
+            query_pos=query_pos,
+            key_pos=key_pos,
+            attn_mask=cross_attn_mask,
+            key_padding_mask=key_padding_mask,
+            **kwargs)
+        query = self.norms[2](query)
+        query = self.ffn(query)
+        query = self.norms[3](query)
+
+        return query
+
+
+class GroundingDinoTransformerEncoder(DeformableDetrTransformerEncoder):
+
+    def __init__(self, text_layer_cfg: ConfigType,
+                 fusion_layer_cfg: ConfigType, **kwargs) -> None:
+        self.text_layer_cfg = text_layer_cfg
+        self.fusion_layer_cfg = fusion_layer_cfg
+        super().__init__(**kwargs)
+
+    def _init_layers(self) -> None:
+        """Initialize encoder layers."""
+        self.layers = ModuleList([
+            DeformableDetrTransformerEncoderLayer(**self.layer_cfg)
+            for _ in range(self.num_layers)
+        ])
+        self.text_layers = ModuleList([
+            DetrTransformerEncoderLayer(**self.text_layer_cfg)
+            for _ in range(self.num_layers)
+        ])
+        self.fusion_layers = ModuleList([
+            SingleScaleBiAttentionBlock(**self.fusion_layer_cfg)
+            for _ in range(self.num_layers)
+        ])
+        self.embed_dims = self.layers[0].embed_dims
+        if self.num_cp > 0:
+            if checkpoint_wrapper is None:
+                raise NotImplementedError(
+                    'If you want to reduce GPU memory usage, \
+                    please install fairscale by executing the \
+                    following command: pip install fairscale.')
+            for i in range(self.num_cp):
+                self.layers[i] = checkpoint_wrapper(self.layers[i])
+                self.fusion_layers[i] = checkpoint_wrapper(
+                    self.fusion_layers[i])
+
+    def forward(self,
+                query: Tensor,
+                query_pos: Tensor,
+                key_padding_mask: Tensor,
+                spatial_shapes: Tensor,
+                level_start_index: Tensor,
+                valid_ratios: Tensor,
+                memory_text: Tensor = None,
+                text_attention_mask: Tensor = None,
+                pos_text: Tensor = None,
+                text_self_attention_masks: Tensor = None,
+                position_ids: Tensor = None):
+        """Forward function of Transformer encoder.
+
+        Args:
+            query (Tensor): The input query, has shape (bs, num_queries, dim).
+            query_pos (Tensor): The positional encoding for query, has shape
+                (bs, num_queries, dim).
+            key_padding_mask (Tensor): The `key_padding_mask` of `self_attn`
+                input. ByteTensor, has shape (bs, num_queries).
+            spatial_shapes (Tensor): Spatial shapes of features in all levels,
+                has shape (num_levels, 2), last dimension represents (h, w).
+            level_start_index (Tensor): The start index of each level.
+                A tensor has shape (num_levels, ) and can be represented
+                as [0, h_0*w_0, h_0*w_0+h_1*w_1, ...].
+            valid_ratios (Tensor): The ratios of the valid width and the valid
+                height relative to the width and the height of features in all
+                levels, has shape (bs, num_levels, 2).
+            memory_text (Tensor, optional): Memory text. It has shape (bs,
+                len_text, text_embed_dims).
+            text_attention_mask (Tensor, optional): Text token mask. It has
+                shape (bs,len_text).
+            pos_text (Tensor, optional): The positional encoding for text.
+                Defaults to None.
+            text_self_attention_masks (Tensor, optional): Text self attention
+                mask. Defaults to None.
+            position_ids (Tensor, optional): Text position ids.
+                Defaults to None.
+        """
+        output = query
+        reference_points = self.get_encoder_reference_points(
+            spatial_shapes, valid_ratios, device=query.device)
+        if self.text_layers:
+            # generate pos_text
+            bs, n_text, _ = memory_text.shape
+            if pos_text is None and position_ids is None:
+                pos_text = (
+                    torch.arange(n_text,
+                                 device=memory_text.device).float().unsqueeze(
+                                     0).unsqueeze(-1).repeat(bs, 1, 1))
+                pos_text = get_text_sine_pos_embed(
+                    pos_text, num_pos_feats=256, exchange_xy=False)
+            if position_ids is not None:
+                pos_text = get_text_sine_pos_embed(
+                    position_ids[..., None],
+                    num_pos_feats=256,
+                    exchange_xy=False)
+
+        # main process
+        for layer_id, layer in enumerate(self.layers):
+            if self.fusion_layers:
+                output, memory_text = self.fusion_layers[layer_id](
+                    visual_feature=output,
+                    lang_feature=memory_text,
+                    attention_mask_v=key_padding_mask,
+                    attention_mask_l=text_attention_mask,
+                )
+            if self.text_layers:
+                text_num_heads = self.text_layers[
+                    layer_id].self_attn_cfg.num_heads
+                memory_text = self.text_layers[layer_id](
+                    query=memory_text,
+                    query_pos=(pos_text if pos_text is not None else None),
+                    attn_mask=~text_self_attention_masks.repeat(
+                        text_num_heads, 1, 1),  # note we use ~ for mask here
+                    key_padding_mask=None,
+                )
+            output = layer(
+                query=output,
+                query_pos=query_pos,
+                reference_points=reference_points,
+                spatial_shapes=spatial_shapes,
+                level_start_index=level_start_index,
+                key_padding_mask=key_padding_mask)
+        return output, memory_text
+
+
+class GroundingDinoTransformerDecoder(DinoTransformerDecoder):
+
+    def _init_layers(self) -> None:
+        """Initialize decoder layers."""
+        self.layers = ModuleList([
+            GroundingDinoTransformerDecoderLayer(**self.layer_cfg)
+            for _ in range(self.num_layers)
+        ])
+        self.embed_dims = self.layers[0].embed_dims
+        if self.post_norm_cfg is not None:
+            raise ValueError('There is not post_norm in '
+                             f'{self._get_name()}')
+        self.ref_point_head = MLP(self.embed_dims * 2, self.embed_dims,
+                                  self.embed_dims, 2)
+        self.norm = nn.LayerNorm(self.embed_dims)
diff --git a/mmdetection/mmdet/models/layers/transformer/mask2former_layers.py b/mmdetection/mmdet/models/layers/transformer/mask2former_layers.py
new file mode 100644
index 00000000..dcc604e2
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/transformer/mask2former_layers.py
@@ -0,0 +1,135 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.cnn import build_norm_layer
+from mmengine.model import ModuleList
+from torch import Tensor
+
+from .deformable_detr_layers import DeformableDetrTransformerEncoder
+from .detr_layers import DetrTransformerDecoder, DetrTransformerDecoderLayer
+
+
+class Mask2FormerTransformerEncoder(DeformableDetrTransformerEncoder):
+    """Encoder in PixelDecoder of Mask2Former."""
+
+    def forward(self, query: Tensor, query_pos: Tensor,
+                key_padding_mask: Tensor, spatial_shapes: Tensor,
+                level_start_index: Tensor, valid_ratios: Tensor,
+                reference_points: Tensor, **kwargs) -> Tensor:
+        """Forward function of Transformer encoder.
+
+        Args:
+            query (Tensor): The input query, has shape (bs, num_queries, dim).
+            query_pos (Tensor): The positional encoding for query, has shape
+                (bs, num_queries, dim). If not None, it will be added to the
+                `query` before forward function. Defaults to None.
+            key_padding_mask (Tensor): The `key_padding_mask` of `self_attn`
+                input. ByteTensor, has shape (bs, num_queries).
+            spatial_shapes (Tensor): Spatial shapes of features in all levels,
+                has shape (num_levels, 2), last dimension represents (h, w).
+            level_start_index (Tensor): The start index of each level.
+                A tensor has shape (num_levels, ) and can be represented
+                as [0, h_0*w_0, h_0*w_0+h_1*w_1, ...].
+            valid_ratios (Tensor): The ratios of the valid width and the valid
+                height relative to the width and the height of features in all
+                levels, has shape (bs, num_levels, 2).
+            reference_points (Tensor): The initial reference, has shape
+                (bs, num_queries, 2) with the last dimension arranged
+                as (cx, cy).
+
+        Returns:
+            Tensor: Output queries of Transformer encoder, which is also
+            called 'encoder output embeddings' or 'memory', has shape
+            (bs, num_queries, dim)
+        """
+        for layer in self.layers:
+            query = layer(
+                query=query,
+                query_pos=query_pos,
+                key_padding_mask=key_padding_mask,
+                spatial_shapes=spatial_shapes,
+                level_start_index=level_start_index,
+                valid_ratios=valid_ratios,
+                reference_points=reference_points,
+                **kwargs)
+        return query
+
+
+class Mask2FormerTransformerDecoder(DetrTransformerDecoder):
+    """Decoder of Mask2Former."""
+
+    def _init_layers(self) -> None:
+        """Initialize decoder layers."""
+        self.layers = ModuleList([
+            Mask2FormerTransformerDecoderLayer(**self.layer_cfg)
+            for _ in range(self.num_layers)
+        ])
+        self.embed_dims = self.layers[0].embed_dims
+        self.post_norm = build_norm_layer(self.post_norm_cfg,
+                                          self.embed_dims)[1]
+
+
+class Mask2FormerTransformerDecoderLayer(DetrTransformerDecoderLayer):
+    """Implements decoder layer in Mask2Former transformer."""
+
+    def forward(self,
+                query: Tensor,
+                key: Tensor = None,
+                value: Tensor = None,
+                query_pos: Tensor = None,
+                key_pos: Tensor = None,
+                self_attn_mask: Tensor = None,
+                cross_attn_mask: Tensor = None,
+                key_padding_mask: Tensor = None,
+                **kwargs) -> Tensor:
+        """
+        Args:
+            query (Tensor): The input query, has shape (bs, num_queries, dim).
+            key (Tensor, optional): The input key, has shape (bs, num_keys,
+                dim). If `None`, the `query` will be used. Defaults to `None`.
+            value (Tensor, optional): The input value, has the same shape as
+                `key`, as in `nn.MultiheadAttention.forward`. If `None`, the
+                `key` will be used. Defaults to `None`.
+            query_pos (Tensor, optional): The positional encoding for `query`,
+                has the same shape as `query`. If not `None`, it will be added
+                to `query` before forward function. Defaults to `None`.
+            key_pos (Tensor, optional): The positional encoding for `key`, has
+                the same shape as `key`. If not `None`, it will be added to
+                `key` before forward function. If None, and `query_pos` has the
+                same shape as `key`, then `query_pos` will be used for
+                `key_pos`. Defaults to None.
+            self_attn_mask (Tensor, optional): ByteTensor mask, has shape
+                (num_queries, num_keys), as in `nn.MultiheadAttention.forward`.
+                Defaults to None.
+            cross_attn_mask (Tensor, optional): ByteTensor mask, has shape
+                (num_queries, num_keys), as in `nn.MultiheadAttention.forward`.
+                Defaults to None.
+            key_padding_mask (Tensor, optional): The `key_padding_mask` of
+                `self_attn` input. ByteTensor, has shape (bs, num_value).
+                Defaults to None.
+
+        Returns:
+            Tensor: forwarded results, has shape (bs, num_queries, dim).
+        """
+
+        query = self.cross_attn(
+            query=query,
+            key=key,
+            value=value,
+            query_pos=query_pos,
+            key_pos=key_pos,
+            attn_mask=cross_attn_mask,
+            key_padding_mask=key_padding_mask,
+            **kwargs)
+        query = self.norms[0](query)
+        query = self.self_attn(
+            query=query,
+            key=query,
+            value=query,
+            query_pos=query_pos,
+            key_pos=query_pos,
+            attn_mask=self_attn_mask,
+            **kwargs)
+        query = self.norms[1](query)
+        query = self.ffn(query)
+        query = self.norms[2](query)
+
+        return query
diff --git a/mmdetection/mmdet/models/layers/transformer/utils.py b/mmdetection/mmdet/models/layers/transformer/utils.py
new file mode 100644
index 00000000..6e43a172
--- /dev/null
+++ b/mmdetection/mmdet/models/layers/transformer/utils.py
@@ -0,0 +1,915 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+import warnings
+from typing import Optional, Sequence, Tuple, Union
+
+import torch
+import torch.nn.functional as F
+from mmcv.cnn import (Linear, build_activation_layer, build_conv_layer,
+                      build_norm_layer)
+from mmcv.cnn.bricks.drop import Dropout
+from mmengine.model import BaseModule, ModuleList
+from mmengine.utils import to_2tuple
+from torch import Tensor, nn
+
+from mmdet.registry import MODELS
+from mmdet.utils import OptConfigType, OptMultiConfig
+
+
+def nlc_to_nchw(x: Tensor, hw_shape: Sequence[int]) -> Tensor:
+    """Convert [N, L, C] shape tensor to [N, C, H, W] shape tensor.
+
+    Args:
+        x (Tensor): The input tensor of shape [N, L, C] before conversion.
+        hw_shape (Sequence[int]): The height and width of output feature map.
+
+    Returns:
+        Tensor: The output tensor of shape [N, C, H, W] after conversion.
+    """
+    H, W = hw_shape
+    assert len(x.shape) == 3
+    B, L, C = x.shape
+    assert L == H * W, 'The seq_len does not match H, W'
+    return x.transpose(1, 2).reshape(B, C, H, W).contiguous()
+
+
+def nchw_to_nlc(x):
+    """Flatten [N, C, H, W] shape tensor to [N, L, C] shape tensor.
+
+    Args:
+        x (Tensor): The input tensor of shape [N, C, H, W] before conversion.
+
+    Returns:
+        Tensor: The output tensor of shape [N, L, C] after conversion.
+    """
+    assert len(x.shape) == 4
+    return x.flatten(2).transpose(1, 2).contiguous()
+
+
+def coordinate_to_encoding(coord_tensor: Tensor,
+                           num_feats: int = 128,
+                           temperature: int = 10000,
+                           scale: float = 2 * math.pi):
+    """Convert coordinate tensor to positional encoding.
+
+    Args:
+        coord_tensor (Tensor): Coordinate tensor to be converted to
+            positional encoding. With the last dimension as 2 or 4.
+        num_feats (int, optional): The feature dimension for each position
+            along x-axis or y-axis. Note the final returned dimension
+            for each position is 2 times of this value. Defaults to 128.
+        temperature (int, optional): The temperature used for scaling
+            the position embedding. Defaults to 10000.
+        scale (float, optional): A scale factor that scales the position
+            embedding. The scale will be used only when `normalize` is True.
+            Defaults to 2*pi.
+    Returns:
+        Tensor: Returned encoded positional tensor.
+    """
+    dim_t = torch.arange(
+        num_feats, dtype=torch.float32, device=coord_tensor.device)
+    dim_t = temperature**(2 * (dim_t // 2) / num_feats)
+    x_embed = coord_tensor[..., 0] * scale
+    y_embed = coord_tensor[..., 1] * scale
+    pos_x = x_embed[..., None] / dim_t
+    pos_y = y_embed[..., None] / dim_t
+    pos_x = torch.stack((pos_x[..., 0::2].sin(), pos_x[..., 1::2].cos()),
+                        dim=-1).flatten(2)
+    pos_y = torch.stack((pos_y[..., 0::2].sin(), pos_y[..., 1::2].cos()),
+                        dim=-1).flatten(2)
+    if coord_tensor.size(-1) == 2:
+        pos = torch.cat((pos_y, pos_x), dim=-1)
+    elif coord_tensor.size(-1) == 4:
+        w_embed = coord_tensor[..., 2] * scale
+        pos_w = w_embed[..., None] / dim_t
+        pos_w = torch.stack((pos_w[..., 0::2].sin(), pos_w[..., 1::2].cos()),
+                            dim=-1).flatten(2)
+
+        h_embed = coord_tensor[..., 3] * scale
+        pos_h = h_embed[..., None] / dim_t
+        pos_h = torch.stack((pos_h[..., 0::2].sin(), pos_h[..., 1::2].cos()),
+                            dim=-1).flatten(2)
+
+        pos = torch.cat((pos_y, pos_x, pos_w, pos_h), dim=-1)
+    else:
+        raise ValueError('Unknown pos_tensor shape(-1):{}'.format(
+            coord_tensor.size(-1)))
+    return pos
+
+
+def inverse_sigmoid(x: Tensor, eps: float = 1e-5) -> Tensor:
+    """Inverse function of sigmoid.
+
+    Args:
+        x (Tensor): The tensor to do the inverse.
+        eps (float): EPS avoid numerical overflow. Defaults 1e-5.
+    Returns:
+        Tensor: The x has passed the inverse function of sigmoid, has the same
+        shape with input.
+    """
+    x = x.clamp(min=0, max=1)
+    x1 = x.clamp(min=eps)
+    x2 = (1 - x).clamp(min=eps)
+    return torch.log(x1 / x2)
+
+
+class AdaptivePadding(nn.Module):
+    """Applies padding to input (if needed) so that input can get fully covered
+    by filter you specified. It support two modes "same" and "corner". The
+    "same" mode is same with "SAME" padding mode in TensorFlow, pad zero around
+    input. The "corner"  mode would pad zero to bottom right.
+
+    Args:
+        kernel_size (int | tuple): Size of the kernel:
+        stride (int | tuple): Stride of the filter. Default: 1:
+        dilation (int | tuple): Spacing between kernel elements.
+            Default: 1
+        padding (str): Support "same" and "corner", "corner" mode
+            would pad zero to bottom right, and "same" mode would
+            pad zero around input. Default: "corner".
+    Example:
+        >>> kernel_size = 16
+        >>> stride = 16
+        >>> dilation = 1
+        >>> input = torch.rand(1, 1, 15, 17)
+        >>> adap_pad = AdaptivePadding(
+        >>>     kernel_size=kernel_size,
+        >>>     stride=stride,
+        >>>     dilation=dilation,
+        >>>     padding="corner")
+        >>> out = adap_pad(input)
+        >>> assert (out.shape[2], out.shape[3]) == (16, 32)
+        >>> input = torch.rand(1, 1, 16, 17)
+        >>> out = adap_pad(input)
+        >>> assert (out.shape[2], out.shape[3]) == (16, 32)
+    """
+
+    def __init__(self, kernel_size=1, stride=1, dilation=1, padding='corner'):
+
+        super(AdaptivePadding, self).__init__()
+
+        assert padding in ('same', 'corner')
+
+        kernel_size = to_2tuple(kernel_size)
+        stride = to_2tuple(stride)
+        padding = to_2tuple(padding)
+        dilation = to_2tuple(dilation)
+
+        self.padding = padding
+        self.kernel_size = kernel_size
+        self.stride = stride
+        self.dilation = dilation
+
+    def get_pad_shape(self, input_shape):
+        input_h, input_w = input_shape
+        kernel_h, kernel_w = self.kernel_size
+        stride_h, stride_w = self.stride
+        output_h = math.ceil(input_h / stride_h)
+        output_w = math.ceil(input_w / stride_w)
+        pad_h = max((output_h - 1) * stride_h +
+                    (kernel_h - 1) * self.dilation[0] + 1 - input_h, 0)
+        pad_w = max((output_w - 1) * stride_w +
+                    (kernel_w - 1) * self.dilation[1] + 1 - input_w, 0)
+        return pad_h, pad_w
+
+    def forward(self, x):
+        pad_h, pad_w = self.get_pad_shape(x.size()[-2:])
+        if pad_h > 0 or pad_w > 0:
+            if self.padding == 'corner':
+                x = F.pad(x, [0, pad_w, 0, pad_h])
+            elif self.padding == 'same':
+                x = F.pad(x, [
+                    pad_w // 2, pad_w - pad_w // 2, pad_h // 2,
+                    pad_h - pad_h // 2
+                ])
+        return x
+
+
+class PatchEmbed(BaseModule):
+    """Image to Patch Embedding.
+
+    We use a conv layer to implement PatchEmbed.
+
+    Args:
+        in_channels (int): The num of input channels. Default: 3
+        embed_dims (int): The dimensions of embedding. Default: 768
+        conv_type (str): The config dict for embedding
+            conv layer type selection. Default: "Conv2d.
+        kernel_size (int): The kernel_size of embedding conv. Default: 16.
+        stride (int): The slide stride of embedding conv.
+            Default: None (Would be set as `kernel_size`).
+        padding (int | tuple | string ): The padding length of
+            embedding conv. When it is a string, it means the mode
+            of adaptive padding, support "same" and "corner" now.
+            Default: "corner".
+        dilation (int): The dilation rate of embedding conv. Default: 1.
+        bias (bool): Bias of embed conv. Default: True.
+        norm_cfg (dict, optional): Config dict for normalization layer.
+            Default: None.
+        input_size (int | tuple | None): The size of input, which will be
+            used to calculate the out size. Only work when `dynamic_size`
+            is False. Default: None.
+        init_cfg (`mmengine.ConfigDict`, optional): The Config for
+            initialization. Default: None.
+    """
+
+    def __init__(self,
+                 in_channels: int = 3,
+                 embed_dims: int = 768,
+                 conv_type: str = 'Conv2d',
+                 kernel_size: int = 16,
+                 stride: int = 16,
+                 padding: Union[int, tuple, str] = 'corner',
+                 dilation: int = 1,
+                 bias: bool = True,
+                 norm_cfg: OptConfigType = None,
+                 input_size: Union[int, tuple] = None,
+                 init_cfg: OptConfigType = None) -> None:
+        super(PatchEmbed, self).__init__(init_cfg=init_cfg)
+
+        self.embed_dims = embed_dims
+        if stride is None:
+            stride = kernel_size
+
+        kernel_size = to_2tuple(kernel_size)
+        stride = to_2tuple(stride)
+        dilation = to_2tuple(dilation)
+
+        if isinstance(padding, str):
+            self.adap_padding = AdaptivePadding(
+                kernel_size=kernel_size,
+                stride=stride,
+                dilation=dilation,
+                padding=padding)
+            # disable the padding of conv
+            padding = 0
+        else:
+            self.adap_padding = None
+        padding = to_2tuple(padding)
+
+        self.projection = build_conv_layer(
+            dict(type=conv_type),
+            in_channels=in_channels,
+            out_channels=embed_dims,
+            kernel_size=kernel_size,
+            stride=stride,
+            padding=padding,
+            dilation=dilation,
+            bias=bias)
+
+        if norm_cfg is not None:
+            self.norm = build_norm_layer(norm_cfg, embed_dims)[1]
+        else:
+            self.norm = None
+
+        if input_size:
+            input_size = to_2tuple(input_size)
+            # `init_out_size` would be used outside to
+            # calculate the num_patches
+            # when `use_abs_pos_embed` outside
+            self.init_input_size = input_size
+            if self.adap_padding:
+                pad_h, pad_w = self.adap_padding.get_pad_shape(input_size)
+                input_h, input_w = input_size
+                input_h = input_h + pad_h
+                input_w = input_w + pad_w
+                input_size = (input_h, input_w)
+
+            # https://pytorch.org/docs/stable/generated/torch.nn.Conv2d.html
+            h_out = (input_size[0] + 2 * padding[0] - dilation[0] *
+                     (kernel_size[0] - 1) - 1) // stride[0] + 1
+            w_out = (input_size[1] + 2 * padding[1] - dilation[1] *
+                     (kernel_size[1] - 1) - 1) // stride[1] + 1
+            self.init_out_size = (h_out, w_out)
+        else:
+            self.init_input_size = None
+            self.init_out_size = None
+
+    def forward(self, x: Tensor) -> Tuple[Tensor, Tuple[int]]:
+        """
+        Args:
+            x (Tensor): Has shape (B, C, H, W). In most case, C is 3.
+
+        Returns:
+            tuple: Contains merged results and its spatial shape.
+
+                - x (Tensor): Has shape (B, out_h * out_w, embed_dims)
+                - out_size (tuple[int]): Spatial shape of x, arrange as
+                    (out_h, out_w).
+        """
+
+        if self.adap_padding:
+            x = self.adap_padding(x)
+
+        x = self.projection(x)
+        out_size = (x.shape[2], x.shape[3])
+        x = x.flatten(2).transpose(1, 2)
+        if self.norm is not None:
+            x = self.norm(x)
+        return x, out_size
+
+
+class PatchMerging(BaseModule):
+    """Merge patch feature map.
+
+    This layer groups feature map by kernel_size, and applies norm and linear
+    layers to the grouped feature map. Our implementation uses `nn.Unfold` to
+    merge patch, which is about 25% faster than original implementation.
+    Instead, we need to modify pretrained models for compatibility.
+
+    Args:
+        in_channels (int): The num of input channels.
+            to gets fully covered by filter and stride you specified..
+            Default: True.
+        out_channels (int): The num of output channels.
+        kernel_size (int | tuple, optional): the kernel size in the unfold
+            layer. Defaults to 2.
+        stride (int | tuple, optional): the stride of the sliding blocks in the
+            unfold layer. Default: None. (Would be set as `kernel_size`)
+        padding (int | tuple | string ): The padding length of
+            embedding conv. When it is a string, it means the mode
+            of adaptive padding, support "same" and "corner" now.
+            Default: "corner".
+        dilation (int | tuple, optional): dilation parameter in the unfold
+            layer. Default: 1.
+        bias (bool, optional): Whether to add bias in linear layer or not.
+            Defaults: False.
+        norm_cfg (dict, optional): Config dict for normalization layer.
+            Default: dict(type='LN').
+        init_cfg (dict, optional): The extra config for initialization.
+            Default: None.
+    """
+
+    def __init__(self,
+                 in_channels: int,
+                 out_channels: int,
+                 kernel_size: Optional[Union[int, tuple]] = 2,
+                 stride: Optional[Union[int, tuple]] = None,
+                 padding: Union[int, tuple, str] = 'corner',
+                 dilation: Optional[Union[int, tuple]] = 1,
+                 bias: Optional[bool] = False,
+                 norm_cfg: OptConfigType = dict(type='LN'),
+                 init_cfg: OptConfigType = None) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        if stride:
+            stride = stride
+        else:
+            stride = kernel_size
+
+        kernel_size = to_2tuple(kernel_size)
+        stride = to_2tuple(stride)
+        dilation = to_2tuple(dilation)
+
+        if isinstance(padding, str):
+            self.adap_padding = AdaptivePadding(
+                kernel_size=kernel_size,
+                stride=stride,
+                dilation=dilation,
+                padding=padding)
+            # disable the padding of unfold
+            padding = 0
+        else:
+            self.adap_padding = None
+
+        padding = to_2tuple(padding)
+        self.sampler = nn.Unfold(
+            kernel_size=kernel_size,
+            dilation=dilation,
+            padding=padding,
+            stride=stride)
+
+        sample_dim = kernel_size[0] * kernel_size[1] * in_channels
+
+        if norm_cfg is not None:
+            self.norm = build_norm_layer(norm_cfg, sample_dim)[1]
+        else:
+            self.norm = None
+
+        self.reduction = nn.Linear(sample_dim, out_channels, bias=bias)
+
+    def forward(self, x: Tensor,
+                input_size: Tuple[int]) -> Tuple[Tensor, Tuple[int]]:
+        """
+        Args:
+            x (Tensor): Has shape (B, H*W, C_in).
+            input_size (tuple[int]): The spatial shape of x, arrange as (H, W).
+                Default: None.
+
+        Returns:
+            tuple: Contains merged results and its spatial shape.
+
+                - x (Tensor): Has shape (B, Merged_H * Merged_W, C_out)
+                - out_size (tuple[int]): Spatial shape of x, arrange as
+                    (Merged_H, Merged_W).
+        """
+        B, L, C = x.shape
+        assert isinstance(input_size, Sequence), f'Expect ' \
+                                                 f'input_size is ' \
+                                                 f'`Sequence` ' \
+                                                 f'but get {input_size}'
+
+        H, W = input_size
+        assert L == H * W, 'input feature has wrong size'
+
+        x = x.view(B, H, W, C).permute([0, 3, 1, 2])  # B, C, H, W
+        # Use nn.Unfold to merge patch. About 25% faster than original method,
+        # but need to modify pretrained model for compatibility
+
+        if self.adap_padding:
+            x = self.adap_padding(x)
+            H, W = x.shape[-2:]
+
+        x = self.sampler(x)
+        # if kernel_size=2 and stride=2, x should has shape (B, 4*C, H/2*W/2)
+
+        out_h = (H + 2 * self.sampler.padding[0] - self.sampler.dilation[0] *
+                 (self.sampler.kernel_size[0] - 1) -
+                 1) // self.sampler.stride[0] + 1
+        out_w = (W + 2 * self.sampler.padding[1] - self.sampler.dilation[1] *
+                 (self.sampler.kernel_size[1] - 1) -
+                 1) // self.sampler.stride[1] + 1
+
+        output_size = (out_h, out_w)
+        x = x.transpose(1, 2)  # B, H/2*W/2, 4*C
+        x = self.norm(x) if self.norm else x
+        x = self.reduction(x)
+        return x, output_size
+
+
+class ConditionalAttention(BaseModule):
+    """A wrapper of conditional attention, dropout and residual connection.
+
+    Args:
+        embed_dims (int): The embedding dimension.
+        num_heads (int): Parallel attention heads.
+        attn_drop (float): A Dropout layer on attn_output_weights.
+            Default: 0.0.
+        proj_drop: A Dropout layer after `nn.MultiheadAttention`.
+            Default: 0.0.
+        cross_attn (bool): Whether the attention module is for cross attention.
+            Default: False
+        keep_query_pos (bool): Whether to transform query_pos before cross
+            attention.
+            Default: False.
+        batch_first (bool): When it is True, Key, Query and Value are shape of
+            (batch, n, embed_dim), otherwise (n, batch, embed_dim).
+             Default: True.
+        init_cfg (obj:`mmcv.ConfigDict`): The Config for initialization.
+            Default: None.
+    """
+
+    def __init__(self,
+                 embed_dims: int,
+                 num_heads: int,
+                 attn_drop: float = 0.,
+                 proj_drop: float = 0.,
+                 cross_attn: bool = False,
+                 keep_query_pos: bool = False,
+                 batch_first: bool = True,
+                 init_cfg: OptMultiConfig = None):
+        super().__init__(init_cfg=init_cfg)
+
+        assert batch_first is True, 'Set `batch_first`\
+        to False is NOT supported in ConditionalAttention. \
+        First dimension of all DETRs in mmdet is `batch`, \
+        please set `batch_first` to True.'
+
+        self.cross_attn = cross_attn
+        self.keep_query_pos = keep_query_pos
+        self.embed_dims = embed_dims
+        self.num_heads = num_heads
+        self.attn_drop = Dropout(attn_drop)
+        self.proj_drop = Dropout(proj_drop)
+
+        self._init_layers()
+
+    def _init_layers(self):
+        """Initialize layers for qkv projection."""
+        embed_dims = self.embed_dims
+        self.qcontent_proj = Linear(embed_dims, embed_dims)
+        self.qpos_proj = Linear(embed_dims, embed_dims)
+        self.kcontent_proj = Linear(embed_dims, embed_dims)
+        self.kpos_proj = Linear(embed_dims, embed_dims)
+        self.v_proj = Linear(embed_dims, embed_dims)
+        if self.cross_attn:
+            self.qpos_sine_proj = Linear(embed_dims, embed_dims)
+        self.out_proj = Linear(embed_dims, embed_dims)
+
+        nn.init.constant_(self.out_proj.bias, 0.)
+
+    def forward_attn(self,
+                     query: Tensor,
+                     key: Tensor,
+                     value: Tensor,
+                     attn_mask: Tensor = None,
+                     key_padding_mask: Tensor = None) -> Tuple[Tensor]:
+        """Forward process for `ConditionalAttention`.
+
+        Args:
+            query (Tensor): The input query with shape [bs, num_queries,
+                embed_dims].
+            key (Tensor): The key tensor with shape [bs, num_keys,
+                embed_dims].
+                If None, the `query` will be used. Defaults to None.
+            value (Tensor): The value tensor with same shape as `key`.
+                Same in `nn.MultiheadAttention.forward`. Defaults to None.
+                If None, the `key` will be used.
+            attn_mask (Tensor): ByteTensor mask with shape [num_queries,
+                num_keys]. Same in `nn.MultiheadAttention.forward`.
+                Defaults to None.
+            key_padding_mask (Tensor): ByteTensor with shape [bs, num_keys].
+                Defaults to None.
+        Returns:
+            Tuple[Tensor]: Attention outputs of shape :math:`(N, L, E)`,
+            where :math:`N` is the batch size, :math:`L` is the target
+            sequence length , and :math:`E` is the embedding dimension
+            `embed_dim`. Attention weights per head of shape :math:`
+            (num_heads, L, S)`. where :math:`N` is batch size, :math:`L`
+            is target sequence length, and :math:`S` is the source sequence
+            length.
+        """
+        assert key.size(1) == value.size(1), \
+            f'{"key, value must have the same sequence length"}'
+        assert query.size(0) == key.size(0) == value.size(0), \
+            f'{"batch size must be equal for query, key, value"}'
+        assert query.size(2) == key.size(2), \
+            f'{"q_dims, k_dims must be equal"}'
+        assert value.size(2) == self.embed_dims, \
+            f'{"v_dims must be equal to embed_dims"}'
+
+        bs, tgt_len, hidden_dims = query.size()
+        _, src_len, _ = key.size()
+        head_dims = hidden_dims // self.num_heads
+        v_head_dims = self.embed_dims // self.num_heads
+        assert head_dims * self.num_heads == hidden_dims, \
+            f'{"hidden_dims must be divisible by num_heads"}'
+        scaling = float(head_dims)**-0.5
+
+        q = query * scaling
+        k = key
+        v = value
+
+        if attn_mask is not None:
+            assert attn_mask.dtype == torch.float32 or \
+                   attn_mask.dtype == torch.float64 or \
+                   attn_mask.dtype == torch.float16 or \
+                   attn_mask.dtype == torch.uint8 or \
+                   attn_mask.dtype == torch.bool, \
+                   'Only float, byte, and bool types are supported for \
+                    attn_mask'
+
+            if attn_mask.dtype == torch.uint8:
+                warnings.warn('Byte tensor for attn_mask is deprecated.\
+                     Use bool tensor instead.')
+                attn_mask = attn_mask.to(torch.bool)
+            if attn_mask.dim() == 2:
+                attn_mask = attn_mask.unsqueeze(0)
+                if list(attn_mask.size()) != [1, query.size(1), key.size(1)]:
+                    raise RuntimeError(
+                        'The size of the 2D attn_mask is not correct.')
+            elif attn_mask.dim() == 3:
+                if list(attn_mask.size()) != [
+                        bs * self.num_heads,
+                        query.size(1),
+                        key.size(1)
+                ]:
+                    raise RuntimeError(
+                        'The size of the 3D attn_mask is not correct.')
+            else:
+                raise RuntimeError(
+                    "attn_mask's dimension {} is not supported".format(
+                        attn_mask.dim()))
+        # attn_mask's dim is 3 now.
+
+        if key_padding_mask is not None and key_padding_mask.dtype == int:
+            key_padding_mask = key_padding_mask.to(torch.bool)
+
+        q = q.contiguous().view(bs, tgt_len, self.num_heads,
+                                head_dims).permute(0, 2, 1, 3).flatten(0, 1)
+        if k is not None:
+            k = k.contiguous().view(bs, src_len, self.num_heads,
+                                    head_dims).permute(0, 2, 1,
+                                                       3).flatten(0, 1)
+        if v is not None:
+            v = v.contiguous().view(bs, src_len, self.num_heads,
+                                    v_head_dims).permute(0, 2, 1,
+                                                         3).flatten(0, 1)
+
+        if key_padding_mask is not None:
+            assert key_padding_mask.size(0) == bs
+            assert key_padding_mask.size(1) == src_len
+
+        attn_output_weights = torch.bmm(q, k.transpose(1, 2))
+        assert list(attn_output_weights.size()) == [
+            bs * self.num_heads, tgt_len, src_len
+        ]
+
+        if attn_mask is not None:
+            if attn_mask.dtype == torch.bool:
+                attn_output_weights.masked_fill_(attn_mask, float('-inf'))
+            else:
+                attn_output_weights += attn_mask
+
+        if key_padding_mask is not None:
+            attn_output_weights = attn_output_weights.view(
+                bs, self.num_heads, tgt_len, src_len)
+            attn_output_weights = attn_output_weights.masked_fill(
+                key_padding_mask.unsqueeze(1).unsqueeze(2),
+                float('-inf'),
+            )
+            attn_output_weights = attn_output_weights.view(
+                bs * self.num_heads, tgt_len, src_len)
+
+        attn_output_weights = F.softmax(
+            attn_output_weights -
+            attn_output_weights.max(dim=-1, keepdim=True)[0],
+            dim=-1)
+        attn_output_weights = self.attn_drop(attn_output_weights)
+
+        attn_output = torch.bmm(attn_output_weights, v)
+        assert list(
+            attn_output.size()) == [bs * self.num_heads, tgt_len, v_head_dims]
+        attn_output = attn_output.view(bs, self.num_heads, tgt_len,
+                                       v_head_dims).permute(0, 2, 1,
+                                                            3).flatten(2)
+        attn_output = self.out_proj(attn_output)
+
+        # average attention weights over heads
+        attn_output_weights = attn_output_weights.view(bs, self.num_heads,
+                                                       tgt_len, src_len)
+        return attn_output, attn_output_weights.sum(dim=1) / self.num_heads
+
+    def forward(self,
+                query: Tensor,
+                key: Tensor,
+                query_pos: Tensor = None,
+                ref_sine_embed: Tensor = None,
+                key_pos: Tensor = None,
+                attn_mask: Tensor = None,
+                key_padding_mask: Tensor = None,
+                is_first: bool = False) -> Tensor:
+        """Forward function for `ConditionalAttention`.
+        Args:
+            query (Tensor): The input query with shape [bs, num_queries,
+                embed_dims].
+            key (Tensor): The key tensor with shape [bs, num_keys,
+                embed_dims].
+                If None, the `query` will be used. Defaults to None.
+            query_pos (Tensor): The positional encoding for query in self
+                attention, with the same shape as `x`. If not None, it will
+                be added to `x` before forward function.
+                Defaults to None.
+            query_sine_embed (Tensor): The positional encoding for query in
+                cross attention, with the same shape as `x`. If not None, it
+                will be added to `x` before forward function.
+                Defaults to None.
+            key_pos (Tensor): The positional encoding for `key`, with the
+                same shape as `key`. Defaults to None. If not None, it will
+                be added to `key` before forward function. If None, and
+                `query_pos` has the same shape as `key`, then `query_pos`
+                will be used for `key_pos`. Defaults to None.
+            attn_mask (Tensor): ByteTensor mask with shape [num_queries,
+                num_keys]. Same in `nn.MultiheadAttention.forward`.
+                Defaults to None.
+            key_padding_mask (Tensor): ByteTensor with shape [bs, num_keys].
+                Defaults to None.
+            is_first (bool): A indicator to tell whether the current layer
+                is the first layer of the decoder.
+                Defaults to False.
+        Returns:
+            Tensor: forwarded results with shape
+            [bs, num_queries, embed_dims].
+        """
+
+        if self.cross_attn:
+            q_content = self.qcontent_proj(query)
+            k_content = self.kcontent_proj(key)
+            v = self.v_proj(key)
+
+            bs, nq, c = q_content.size()
+            _, hw, _ = k_content.size()
+
+            k_pos = self.kpos_proj(key_pos)
+            if is_first or self.keep_query_pos:
+                q_pos = self.qpos_proj(query_pos)
+                q = q_content + q_pos
+                k = k_content + k_pos
+            else:
+                q = q_content
+                k = k_content
+            q = q.view(bs, nq, self.num_heads, c // self.num_heads)
+            query_sine_embed = self.qpos_sine_proj(ref_sine_embed)
+            query_sine_embed = query_sine_embed.view(bs, nq, self.num_heads,
+                                                     c // self.num_heads)
+            q = torch.cat([q, query_sine_embed], dim=3).view(bs, nq, 2 * c)
+            k = k.view(bs, hw, self.num_heads, c // self.num_heads)
+            k_pos = k_pos.view(bs, hw, self.num_heads, c // self.num_heads)
+            k = torch.cat([k, k_pos], dim=3).view(bs, hw, 2 * c)
+            ca_output = self.forward_attn(
+                query=q,
+                key=k,
+                value=v,
+                attn_mask=attn_mask,
+                key_padding_mask=key_padding_mask)[0]
+            query = query + self.proj_drop(ca_output)
+        else:
+            q_content = self.qcontent_proj(query)
+            q_pos = self.qpos_proj(query_pos)
+            k_content = self.kcontent_proj(query)
+            k_pos = self.kpos_proj(query_pos)
+            v = self.v_proj(query)
+            q = q_content if q_pos is None else q_content + q_pos
+            k = k_content if k_pos is None else k_content + k_pos
+            sa_output = self.forward_attn(
+                query=q,
+                key=k,
+                value=v,
+                attn_mask=attn_mask,
+                key_padding_mask=key_padding_mask)[0]
+            query = query + self.proj_drop(sa_output)
+
+        return query
+
+
+class MLP(BaseModule):
+    """Very simple multi-layer perceptron (also called FFN) with relu. Mostly
+    used in DETR series detectors.
+
+    Args:
+        input_dim (int): Feature dim of the input tensor.
+        hidden_dim (int): Feature dim of the hidden layer.
+        output_dim (int): Feature dim of the output tensor.
+        num_layers (int): Number of FFN layers. As the last
+            layer of MLP only contains FFN (Linear).
+    """
+
+    def __init__(self, input_dim: int, hidden_dim: int, output_dim: int,
+                 num_layers: int) -> None:
+        super().__init__()
+        self.num_layers = num_layers
+        h = [hidden_dim] * (num_layers - 1)
+        self.layers = ModuleList(
+            Linear(n, k) for n, k in zip([input_dim] + h, h + [output_dim]))
+
+    def forward(self, x: Tensor) -> Tensor:
+        """Forward function of MLP.
+
+        Args:
+            x (Tensor): The input feature, has shape
+                (num_queries, bs, input_dim).
+        Returns:
+            Tensor: The output feature, has shape
+                (num_queries, bs, output_dim).
+        """
+        for i, layer in enumerate(self.layers):
+            x = F.relu(layer(x)) if i < self.num_layers - 1 else layer(x)
+        return x
+
+
+@MODELS.register_module()
+class DynamicConv(BaseModule):
+    """Implements Dynamic Convolution.
+
+    This module generate parameters for each sample and
+    use bmm to implement 1*1 convolution. Code is modified
+    from the `official github repo `_ .
+
+    Args:
+        in_channels (int): The input feature channel.
+            Defaults to 256.
+        feat_channels (int): The inner feature channel.
+            Defaults to 64.
+        out_channels (int, optional): The output feature channel.
+            When not specified, it will be set to `in_channels`
+            by default
+        input_feat_shape (int): The shape of input feature.
+            Defaults to 7.
+        with_proj (bool): Project two-dimentional feature to
+            one-dimentional feature. Default to True.
+        act_cfg (dict): The activation config for DynamicConv.
+        norm_cfg (dict): Config dict for normalization layer. Default
+            layer normalization.
+        init_cfg (obj:`mmengine.ConfigDict`): The Config for initialization.
+            Default: None.
+    """
+
+    def __init__(self,
+                 in_channels: int = 256,
+                 feat_channels: int = 64,
+                 out_channels: Optional[int] = None,
+                 input_feat_shape: int = 7,
+                 with_proj: bool = True,
+                 act_cfg: OptConfigType = dict(type='ReLU', inplace=True),
+                 norm_cfg: OptConfigType = dict(type='LN'),
+                 init_cfg: OptConfigType = None) -> None:
+        super(DynamicConv, self).__init__(init_cfg)
+        self.in_channels = in_channels
+        self.feat_channels = feat_channels
+        self.out_channels_raw = out_channels
+        self.input_feat_shape = input_feat_shape
+        self.with_proj = with_proj
+        self.act_cfg = act_cfg
+        self.norm_cfg = norm_cfg
+        self.out_channels = out_channels if out_channels else in_channels
+
+        self.num_params_in = self.in_channels * self.feat_channels
+        self.num_params_out = self.out_channels * self.feat_channels
+        self.dynamic_layer = nn.Linear(
+            self.in_channels, self.num_params_in + self.num_params_out)
+
+        self.norm_in = build_norm_layer(norm_cfg, self.feat_channels)[1]
+        self.norm_out = build_norm_layer(norm_cfg, self.out_channels)[1]
+
+        self.activation = build_activation_layer(act_cfg)
+
+        num_output = self.out_channels * input_feat_shape**2
+        if self.with_proj:
+            self.fc_layer = nn.Linear(num_output, self.out_channels)
+            self.fc_norm = build_norm_layer(norm_cfg, self.out_channels)[1]
+
+    def forward(self, param_feature: Tensor, input_feature: Tensor) -> Tensor:
+        """Forward function for `DynamicConv`.
+
+        Args:
+            param_feature (Tensor): The feature can be used
+                to generate the parameter, has shape
+                (num_all_proposals, in_channels).
+            input_feature (Tensor): Feature that
+                interact with parameters, has shape
+                (num_all_proposals, in_channels, H, W).
+
+        Returns:
+            Tensor: The output feature has shape
+            (num_all_proposals, out_channels).
+        """
+        input_feature = input_feature.flatten(2).permute(2, 0, 1)
+
+        input_feature = input_feature.permute(1, 0, 2)
+        parameters = self.dynamic_layer(param_feature)
+
+        param_in = parameters[:, :self.num_params_in].view(
+            -1, self.in_channels, self.feat_channels)
+        param_out = parameters[:, -self.num_params_out:].view(
+            -1, self.feat_channels, self.out_channels)
+
+        # input_feature has shape (num_all_proposals, H*W, in_channels)
+        # param_in has shape (num_all_proposals, in_channels, feat_channels)
+        # feature has shape (num_all_proposals, H*W, feat_channels)
+        features = torch.bmm(input_feature, param_in)
+        features = self.norm_in(features)
+        features = self.activation(features)
+
+        # param_out has shape (batch_size, feat_channels, out_channels)
+        features = torch.bmm(features, param_out)
+        features = self.norm_out(features)
+        features = self.activation(features)
+
+        if self.with_proj:
+            features = features.flatten(1)
+            features = self.fc_layer(features)
+            features = self.fc_norm(features)
+            features = self.activation(features)
+
+        return features
+
+
+def get_text_sine_pos_embed(
+    pos_tensor: torch.Tensor,
+    num_pos_feats: int = 128,
+    temperature: int = 10000,
+    exchange_xy: bool = True,
+):
+    """generate sine position embedding from a position tensor
+    Args:
+        pos_tensor (torch.Tensor): shape: [..., n].
+        num_pos_feats (int): projected shape for each float in the tensor.
+        temperature (int): temperature in the sine/cosine function.
+        exchange_xy (bool, optional): exchange pos x and pos y. For example,
+            input tensor is [x,y], the results will be [pos(y), pos(x)].
+            Defaults to True.
+    Returns:
+        pos_embed (torch.Tensor): shape: [..., n*num_pos_feats].
+    """
+    scale = 2 * math.pi
+    dim_t = torch.arange(
+        num_pos_feats, dtype=torch.float32, device=pos_tensor.device)
+    dim_t = temperature**(2 * torch.div(dim_t, 2, rounding_mode='floor') /
+                          num_pos_feats)
+
+    def sine_func(x: torch.Tensor):
+        sin_x = x * scale / dim_t
+        sin_x = torch.stack((sin_x[..., 0::2].sin(), sin_x[..., 1::2].cos()),
+                            dim=3).flatten(2)
+        return sin_x
+
+    pos_res = [
+        sine_func(x)
+        for x in pos_tensor.split([1] * pos_tensor.shape[-1], dim=-1)
+    ]
+    if exchange_xy:
+        pos_res[0], pos_res[1] = pos_res[1], pos_res[0]
+    pos_res = torch.cat(pos_res, dim=-1)
+    return pos_res
diff --git a/mmdetection/mmdet/models/losses/__init__.py b/mmdetection/mmdet/models/losses/__init__.py
new file mode 100644
index 00000000..7c57a3a9
--- /dev/null
+++ b/mmdetection/mmdet/models/losses/__init__.py
@@ -0,0 +1,42 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .accuracy import Accuracy, accuracy
+from .ae_loss import AssociativeEmbeddingLoss
+from .balanced_l1_loss import BalancedL1Loss, balanced_l1_loss
+from .cross_entropy_loss import (CrossEntropyCustomLoss, CrossEntropyLoss,
+                                 binary_cross_entropy, cross_entropy,
+                                 mask_cross_entropy)
+from .ddq_detr_aux_loss import DDQAuxLoss
+from .dice_loss import DiceLoss
+from .eqlv2_loss import EQLV2Loss
+from .focal_loss import FocalCustomLoss, FocalLoss, sigmoid_focal_loss
+from .gaussian_focal_loss import GaussianFocalLoss
+from .gfocal_loss import DistributionFocalLoss, QualityFocalLoss
+from .ghm_loss import GHMC, GHMR
+from .iou_loss import (BoundedIoULoss, CIoULoss, DIoULoss, EIoULoss, GIoULoss,
+                       IoULoss, SIoULoss, bounded_iou_loss, iou_loss)
+from .kd_loss import KnowledgeDistillationKLDivLoss
+from .l2_loss import L2Loss
+from .margin_loss import MarginL2Loss
+from .mse_loss import MSELoss, mse_loss
+from .multipos_cross_entropy_loss import MultiPosCrossEntropyLoss
+from .pisa_loss import carl_loss, isr_p
+from .seesaw_loss import SeesawLoss
+from .smooth_l1_loss import L1Loss, SmoothL1Loss, l1_loss, smooth_l1_loss
+from .triplet_loss import TripletLoss
+from .utils import reduce_loss, weight_reduce_loss, weighted_loss
+from .varifocal_loss import VarifocalLoss
+
+__all__ = [
+    'accuracy', 'Accuracy', 'cross_entropy', 'binary_cross_entropy',
+    'mask_cross_entropy', 'CrossEntropyLoss', 'sigmoid_focal_loss',
+    'FocalLoss', 'smooth_l1_loss', 'SmoothL1Loss', 'balanced_l1_loss',
+    'BalancedL1Loss', 'mse_loss', 'MSELoss', 'iou_loss', 'bounded_iou_loss',
+    'IoULoss', 'BoundedIoULoss', 'GIoULoss', 'DIoULoss', 'CIoULoss',
+    'EIoULoss', 'SIoULoss', 'GHMC', 'GHMR', 'reduce_loss',
+    'weight_reduce_loss', 'weighted_loss', 'L1Loss', 'l1_loss', 'isr_p',
+    'carl_loss', 'AssociativeEmbeddingLoss', 'GaussianFocalLoss',
+    'QualityFocalLoss', 'DistributionFocalLoss', 'VarifocalLoss',
+    'KnowledgeDistillationKLDivLoss', 'SeesawLoss', 'DiceLoss', 'EQLV2Loss',
+    'MarginL2Loss', 'MultiPosCrossEntropyLoss', 'L2Loss', 'TripletLoss',
+    'DDQAuxLoss', 'CrossEntropyCustomLoss', 'FocalCustomLoss'
+]
diff --git a/mmdetection/mmdet/models/losses/accuracy.py b/mmdetection/mmdet/models/losses/accuracy.py
new file mode 100644
index 00000000..d68484e1
--- /dev/null
+++ b/mmdetection/mmdet/models/losses/accuracy.py
@@ -0,0 +1,77 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch.nn as nn
+
+
+def accuracy(pred, target, topk=1, thresh=None):
+    """Calculate accuracy according to the prediction and target.
+
+    Args:
+        pred (torch.Tensor): The model prediction, shape (N, num_class)
+        target (torch.Tensor): The target of each prediction, shape (N, )
+        topk (int | tuple[int], optional): If the predictions in ``topk``
+            matches the target, the predictions will be regarded as
+            correct ones. Defaults to 1.
+        thresh (float, optional): If not None, predictions with scores under
+            this threshold are considered incorrect. Default to None.
+
+    Returns:
+        float | tuple[float]: If the input ``topk`` is a single integer,
+            the function will return a single float as accuracy. If
+            ``topk`` is a tuple containing multiple integers, the
+            function will return a tuple containing accuracies of
+            each ``topk`` number.
+    """
+    assert isinstance(topk, (int, tuple))
+    if isinstance(topk, int):
+        topk = (topk, )
+        return_single = True
+    else:
+        return_single = False
+
+    maxk = max(topk)
+    if pred.size(0) == 0:
+        accu = [pred.new_tensor(0.) for i in range(len(topk))]
+        return accu[0] if return_single else accu
+    assert pred.ndim == 2 and target.ndim == 1
+    assert pred.size(0) == target.size(0)
+    assert maxk <= pred.size(1), \
+        f'maxk {maxk} exceeds pred dimension {pred.size(1)}'
+    pred_value, pred_label = pred.topk(maxk, dim=1)
+    pred_label = pred_label.t()  # transpose to shape (maxk, N)
+    correct = pred_label.eq(target.view(1, -1).expand_as(pred_label))
+    if thresh is not None:
+        # Only prediction values larger than thresh are counted as correct
+        correct = correct & (pred_value > thresh).t()
+    res = []
+    for k in topk:
+        correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)
+        res.append(correct_k.mul_(100.0 / pred.size(0)))
+    return res[0] if return_single else res
+
+
+class Accuracy(nn.Module):
+
+    def __init__(self, topk=(1, ), thresh=None):
+        """Module to calculate the accuracy.
+
+        Args:
+            topk (tuple, optional): The criterion used to calculate the
+                accuracy. Defaults to (1,).
+            thresh (float, optional): If not None, predictions with scores
+                under this threshold are considered incorrect. Default to None.
+        """
+        super().__init__()
+        self.topk = topk
+        self.thresh = thresh
+
+    def forward(self, pred, target):
+        """Forward function to calculate accuracy.
+
+        Args:
+            pred (torch.Tensor): Prediction of models.
+            target (torch.Tensor): Target for each prediction.
+
+        Returns:
+            tuple[float]: The accuracies under different topk criterions.
+        """
+        return accuracy(pred, target, self.topk, self.thresh)
diff --git a/mmdetection/mmdet/models/losses/ae_loss.py b/mmdetection/mmdet/models/losses/ae_loss.py
new file mode 100644
index 00000000..2aa7d696
--- /dev/null
+++ b/mmdetection/mmdet/models/losses/ae_loss.py
@@ -0,0 +1,101 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from mmdet.registry import MODELS
+
+
+def ae_loss_per_image(tl_preds, br_preds, match):
+    """Associative Embedding Loss in one image.
+
+    Associative Embedding Loss including two parts: pull loss and push loss.
+    Pull loss makes embedding vectors from same object closer to each other.
+    Push loss distinguish embedding vector from different objects, and makes
+        the gap between them is large enough.
+
+    During computing, usually there are 3 cases:
+        - no object in image: both pull loss and push loss will be 0.
+        - one object in image: push loss will be 0 and pull loss is computed
+            by the two corner of the only object.
+        - more than one objects in image: pull loss is computed by corner pairs
+            from each object, push loss is computed by each object with all
+            other objects. We use confusion matrix with 0 in diagonal to
+            compute the push loss.
+
+    Args:
+        tl_preds (tensor): Embedding feature map of left-top corner.
+        br_preds (tensor): Embedding feature map of bottim-right corner.
+        match (list): Downsampled coordinates pair of each ground truth box.
+    """
+
+    tl_list, br_list, me_list = [], [], []
+    if len(match) == 0:  # no object in image
+        pull_loss = tl_preds.sum() * 0.
+        push_loss = tl_preds.sum() * 0.
+    else:
+        for m in match:
+            [tl_y, tl_x], [br_y, br_x] = m
+            tl_e = tl_preds[:, tl_y, tl_x].view(-1, 1)
+            br_e = br_preds[:, br_y, br_x].view(-1, 1)
+            tl_list.append(tl_e)
+            br_list.append(br_e)
+            me_list.append((tl_e + br_e) / 2.0)
+
+        tl_list = torch.cat(tl_list)
+        br_list = torch.cat(br_list)
+        me_list = torch.cat(me_list)
+
+        assert tl_list.size() == br_list.size()
+
+        # N is object number in image, M is dimension of embedding vector
+        N, M = tl_list.size()
+
+        pull_loss = (tl_list - me_list).pow(2) + (br_list - me_list).pow(2)
+        pull_loss = pull_loss.sum() / N
+
+        margin = 1  # exp setting of CornerNet, details in section 3.3 of paper
+
+        # confusion matrix of push loss
+        conf_mat = me_list.expand((N, N, M)).permute(1, 0, 2) - me_list
+        conf_weight = 1 - torch.eye(N).type_as(me_list)
+        conf_mat = conf_weight * (margin - conf_mat.sum(-1).abs())
+
+        if N > 1:  # more than one object in current image
+            push_loss = F.relu(conf_mat).sum() / (N * (N - 1))
+        else:
+            push_loss = tl_preds.sum() * 0.
+
+    return pull_loss, push_loss
+
+
+@MODELS.register_module()
+class AssociativeEmbeddingLoss(nn.Module):
+    """Associative Embedding Loss.
+
+    More details can be found in
+    `Associative Embedding `_ and
+    `CornerNet `_ .
+    Code is modified from `kp_utils.py `_  # noqa: E501
+
+    Args:
+        pull_weight (float): Loss weight for corners from same object.
+        push_weight (float): Loss weight for corners from different object.
+    """
+
+    def __init__(self, pull_weight=0.25, push_weight=0.25):
+        super(AssociativeEmbeddingLoss, self).__init__()
+        self.pull_weight = pull_weight
+        self.push_weight = push_weight
+
+    def forward(self, pred, target, match):
+        """Forward function."""
+        batch = pred.size(0)
+        pull_all, push_all = 0.0, 0.0
+        for i in range(batch):
+            pull, push = ae_loss_per_image(pred[i], target[i], match[i])
+
+            pull_all += self.pull_weight * pull
+            push_all += self.push_weight * push
+
+        return pull_all, push_all
diff --git a/mmdetection/mmdet/models/losses/balanced_l1_loss.py b/mmdetection/mmdet/models/losses/balanced_l1_loss.py
new file mode 100644
index 00000000..25adaab2
--- /dev/null
+++ b/mmdetection/mmdet/models/losses/balanced_l1_loss.py
@@ -0,0 +1,122 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import numpy as np
+import torch
+import torch.nn as nn
+
+from mmdet.registry import MODELS
+from .utils import weighted_loss
+
+
+@weighted_loss
+def balanced_l1_loss(pred,
+                     target,
+                     beta=1.0,
+                     alpha=0.5,
+                     gamma=1.5,
+                     reduction='mean'):
+    """Calculate balanced L1 loss.
+
+    Please see the `Libra R-CNN `_
+
+    Args:
+        pred (torch.Tensor): The prediction with shape (N, 4).
+        target (torch.Tensor): The learning target of the prediction with
+            shape (N, 4).
+        beta (float): The loss is a piecewise function of prediction and target
+            and ``beta`` serves as a threshold for the difference between the
+            prediction and target. Defaults to 1.0.
+        alpha (float): The denominator ``alpha`` in the balanced L1 loss.
+            Defaults to 0.5.
+        gamma (float): The ``gamma`` in the balanced L1 loss.
+            Defaults to 1.5.
+        reduction (str, optional): The method that reduces the loss to a
+            scalar. Options are "none", "mean" and "sum".
+
+    Returns:
+        torch.Tensor: The calculated loss
+    """
+    assert beta > 0
+    if target.numel() == 0:
+        return pred.sum() * 0
+
+    assert pred.size() == target.size()
+
+    diff = torch.abs(pred - target)
+    b = np.e**(gamma / alpha) - 1
+    loss = torch.where(
+        diff < beta, alpha / b *
+        (b * diff + 1) * torch.log(b * diff / beta + 1) - alpha * diff,
+        gamma * diff + gamma / b - alpha * beta)
+
+    return loss
+
+
+@MODELS.register_module()
+class BalancedL1Loss(nn.Module):
+    """Balanced L1 Loss.
+
+    arXiv: https://arxiv.org/pdf/1904.02701.pdf (CVPR 2019)
+
+    Args:
+        alpha (float): The denominator ``alpha`` in the balanced L1 loss.
+            Defaults to 0.5.
+        gamma (float): The ``gamma`` in the balanced L1 loss. Defaults to 1.5.
+        beta (float, optional): The loss is a piecewise function of prediction
+            and target. ``beta`` serves as a threshold for the difference
+            between the prediction and target. Defaults to 1.0.
+        reduction (str, optional): The method that reduces the loss to a
+            scalar. Options are "none", "mean" and "sum".
+        loss_weight (float, optional): The weight of the loss. Defaults to 1.0
+    """
+
+    def __init__(self,
+                 alpha=0.5,
+                 gamma=1.5,
+                 beta=1.0,
+                 reduction='mean',
+                 loss_weight=1.0):
+        super(BalancedL1Loss, self).__init__()
+        self.alpha = alpha
+        self.gamma = gamma
+        self.beta = beta
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+
+    def forward(self,
+                pred,
+                target,
+                weight=None,
+                avg_factor=None,
+                reduction_override=None,
+                **kwargs):
+        """Forward function of loss.
+
+        Args:
+            pred (torch.Tensor): The prediction with shape (N, 4).
+            target (torch.Tensor): The learning target of the prediction with
+                shape (N, 4).
+            weight (torch.Tensor, optional): Sample-wise loss weight with
+                shape (N, ).
+            avg_factor (int, optional): Average factor that is used to average
+                the loss. Defaults to None.
+            reduction_override (str, optional): The reduction method used to
+                override the original reduction method of the loss.
+                Options are "none", "mean" and "sum".
+
+        Returns:
+            torch.Tensor: The calculated loss
+        """
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        loss_bbox = self.loss_weight * balanced_l1_loss(
+            pred,
+            target,
+            weight,
+            alpha=self.alpha,
+            gamma=self.gamma,
+            beta=self.beta,
+            reduction=reduction,
+            avg_factor=avg_factor,
+            **kwargs)
+        return loss_bbox
diff --git a/mmdetection/mmdet/models/losses/cross_entropy_loss.py b/mmdetection/mmdet/models/losses/cross_entropy_loss.py
new file mode 100644
index 00000000..49fac774
--- /dev/null
+++ b/mmdetection/mmdet/models/losses/cross_entropy_loss.py
@@ -0,0 +1,401 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from mmdet.registry import MODELS
+from .accuracy import accuracy
+from .utils import weight_reduce_loss
+
+
+def cross_entropy(pred,
+                  label,
+                  weight=None,
+                  reduction='mean',
+                  avg_factor=None,
+                  class_weight=None,
+                  ignore_index=-100,
+                  avg_non_ignore=False):
+    """Calculate the CrossEntropy loss.
+
+    Args:
+        pred (torch.Tensor): The prediction with shape (N, C), C is the number
+            of classes.
+        label (torch.Tensor): The learning label of the prediction.
+        weight (torch.Tensor, optional): Sample-wise loss weight.
+        reduction (str, optional): The method used to reduce the loss.
+        avg_factor (int, optional): Average factor that is used to average
+            the loss. Defaults to None.
+        class_weight (list[float], optional): The weight for each class.
+        ignore_index (int | None): The label index to be ignored.
+            If None, it will be set to default value. Default: -100.
+        avg_non_ignore (bool): The flag decides to whether the loss is
+            only averaged over non-ignored targets. Default: False.
+
+    Returns:
+        torch.Tensor: The calculated loss
+    """
+    # The default value of ignore_index is the same as F.cross_entropy
+    ignore_index = -100 if ignore_index is None else ignore_index
+    # element-wise losses
+    loss = F.cross_entropy(
+        pred,
+        label,
+        weight=class_weight,
+        reduction='none',
+        ignore_index=ignore_index)
+
+    # average loss over non-ignored elements
+    # pytorch's official cross_entropy average loss over non-ignored elements
+    # refer to https://github.com/pytorch/pytorch/blob/56b43f4fec1f76953f15a627694d4bba34588969/torch/nn/functional.py#L2660  # noqa
+    if (avg_factor is None) and avg_non_ignore and reduction == 'mean':
+        avg_factor = label.numel() - (label == ignore_index).sum().item()
+
+    # apply weights and do the reduction
+    if weight is not None:
+        weight = weight.float()
+    loss = weight_reduce_loss(
+        loss, weight=weight, reduction=reduction, avg_factor=avg_factor)
+
+    return loss
+
+
+def _expand_onehot_labels(labels, label_weights, label_channels, ignore_index):
+    """Expand onehot labels to match the size of prediction."""
+    bin_labels = labels.new_full((labels.size(0), label_channels), 0)
+    valid_mask = (labels >= 0) & (labels != ignore_index)
+    inds = torch.nonzero(
+        valid_mask & (labels < label_channels), as_tuple=False)
+
+    if inds.numel() > 0:
+        bin_labels[inds, labels[inds]] = 1
+
+    valid_mask = valid_mask.view(-1, 1).expand(labels.size(0),
+                                               label_channels).float()
+    if label_weights is None:
+        bin_label_weights = valid_mask
+    else:
+        bin_label_weights = label_weights.view(-1, 1).repeat(1, label_channels)
+        bin_label_weights *= valid_mask
+
+    return bin_labels, bin_label_weights, valid_mask
+
+
+def binary_cross_entropy(pred,
+                         label,
+                         weight=None,
+                         reduction='mean',
+                         avg_factor=None,
+                         class_weight=None,
+                         ignore_index=-100,
+                         avg_non_ignore=False):
+    """Calculate the binary CrossEntropy loss.
+
+    Args:
+        pred (torch.Tensor): The prediction with shape (N, 1) or (N, ).
+            When the shape of pred is (N, 1), label will be expanded to
+            one-hot format, and when the shape of pred is (N, ), label
+            will not be expanded to one-hot format.
+        label (torch.Tensor): The learning label of the prediction,
+            with shape (N, ).
+        weight (torch.Tensor, optional): Sample-wise loss weight.
+        reduction (str, optional): The method used to reduce the loss.
+            Options are "none", "mean" and "sum".
+        avg_factor (int, optional): Average factor that is used to average
+            the loss. Defaults to None.
+        class_weight (list[float], optional): The weight for each class.
+        ignore_index (int | None): The label index to be ignored.
+            If None, it will be set to default value. Default: -100.
+        avg_non_ignore (bool): The flag decides to whether the loss is
+            only averaged over non-ignored targets. Default: False.
+
+    Returns:
+        torch.Tensor: The calculated loss.
+    """
+    # The default value of ignore_index is the same as F.cross_entropy
+    ignore_index = -100 if ignore_index is None else ignore_index
+
+    if pred.dim() != label.dim():
+        label, weight, valid_mask = _expand_onehot_labels(
+            label, weight, pred.size(-1), ignore_index)
+    else:
+        # should mask out the ignored elements
+        valid_mask = ((label >= 0) & (label != ignore_index)).float()
+        if weight is not None:
+            # The inplace writing method will have a mismatched broadcast
+            # shape error if the weight and valid_mask dimensions
+            # are inconsistent such as (B,N,1) and (B,N,C).
+            weight = weight * valid_mask
+        else:
+            weight = valid_mask
+
+    # average loss over non-ignored elements
+    if (avg_factor is None) and avg_non_ignore and reduction == 'mean':
+        avg_factor = valid_mask.sum().item()
+
+    # weighted element-wise losses
+    weight = weight.float()
+    loss = F.binary_cross_entropy_with_logits(
+        pred, label.float(), pos_weight=class_weight, reduction='none')
+    # do the reduction for the weighted loss
+    loss = weight_reduce_loss(
+        loss, weight, reduction=reduction, avg_factor=avg_factor)
+
+    return loss
+
+
+def mask_cross_entropy(pred,
+                       target,
+                       label,
+                       reduction='mean',
+                       avg_factor=None,
+                       class_weight=None,
+                       ignore_index=None,
+                       **kwargs):
+    """Calculate the CrossEntropy loss for masks.
+
+    Args:
+        pred (torch.Tensor): The prediction with shape (N, C, *), C is the
+            number of classes. The trailing * indicates arbitrary shape.
+        target (torch.Tensor): The learning label of the prediction.
+        label (torch.Tensor): ``label`` indicates the class label of the mask
+            corresponding object. This will be used to select the mask in the
+            of the class which the object belongs to when the mask prediction
+            if not class-agnostic.
+        reduction (str, optional): The method used to reduce the loss.
+            Options are "none", "mean" and "sum".
+        avg_factor (int, optional): Average factor that is used to average
+            the loss. Defaults to None.
+        class_weight (list[float], optional): The weight for each class.
+        ignore_index (None): Placeholder, to be consistent with other loss.
+            Default: None.
+
+    Returns:
+        torch.Tensor: The calculated loss
+
+    Example:
+        >>> N, C = 3, 11
+        >>> H, W = 2, 2
+        >>> pred = torch.randn(N, C, H, W) * 1000
+        >>> target = torch.rand(N, H, W)
+        >>> label = torch.randint(0, C, size=(N,))
+        >>> reduction = 'mean'
+        >>> avg_factor = None
+        >>> class_weights = None
+        >>> loss = mask_cross_entropy(pred, target, label, reduction,
+        >>>                           avg_factor, class_weights)
+        >>> assert loss.shape == (1,)
+    """
+    assert ignore_index is None, 'BCE loss does not support ignore_index'
+    # TODO: handle these two reserved arguments
+    assert reduction == 'mean' and avg_factor is None
+    num_rois = pred.size()[0]
+    inds = torch.arange(0, num_rois, dtype=torch.long, device=pred.device)
+    pred_slice = pred[inds, label].squeeze(1)
+    return F.binary_cross_entropy_with_logits(
+        pred_slice, target, weight=class_weight, reduction='mean')[None]
+
+
+@MODELS.register_module()
+class CrossEntropyLoss(nn.Module):
+
+    def __init__(self,
+                 use_sigmoid=False,
+                 use_mask=False,
+                 reduction='mean',
+                 class_weight=None,
+                 ignore_index=None,
+                 loss_weight=1.0,
+                 avg_non_ignore=False):
+        """CrossEntropyLoss.
+
+        Args:
+            use_sigmoid (bool, optional): Whether the prediction uses sigmoid
+                of softmax. Defaults to False.
+            use_mask (bool, optional): Whether to use mask cross entropy loss.
+                Defaults to False.
+            reduction (str, optional): . Defaults to 'mean'.
+                Options are "none", "mean" and "sum".
+            class_weight (list[float], optional): Weight of each class.
+                Defaults to None.
+            ignore_index (int | None): The label index to be ignored.
+                Defaults to None.
+            loss_weight (float, optional): Weight of the loss. Defaults to 1.0.
+            avg_non_ignore (bool): The flag decides to whether the loss is
+                only averaged over non-ignored targets. Default: False.
+        """
+        super(CrossEntropyLoss, self).__init__()
+        assert (use_sigmoid is False) or (use_mask is False)
+        self.use_sigmoid = use_sigmoid
+        self.use_mask = use_mask
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+        self.class_weight = class_weight
+        self.ignore_index = ignore_index
+        self.avg_non_ignore = avg_non_ignore
+        if ((ignore_index is not None) and not self.avg_non_ignore
+                and self.reduction == 'mean'):
+            warnings.warn(
+                'Default ``avg_non_ignore`` is False, if you would like to '
+                'ignore the certain label and average loss over non-ignore '
+                'labels, which is the same with PyTorch official '
+                'cross_entropy, set ``avg_non_ignore=True``.')
+
+        if self.use_sigmoid:
+            self.cls_criterion = binary_cross_entropy
+        elif self.use_mask:
+            self.cls_criterion = mask_cross_entropy
+        else:
+            self.cls_criterion = cross_entropy
+
+    def extra_repr(self):
+        """Extra repr."""
+        s = f'avg_non_ignore={self.avg_non_ignore}'
+        return s
+
+    def forward(self,
+                cls_score,
+                label,
+                weight=None,
+                avg_factor=None,
+                reduction_override=None,
+                ignore_index=None,
+                **kwargs):
+        """Forward function.
+
+        Args:
+            cls_score (torch.Tensor): The prediction.
+            label (torch.Tensor): The learning label of the prediction.
+            weight (torch.Tensor, optional): Sample-wise loss weight.
+            avg_factor (int, optional): Average factor that is used to average
+                the loss. Defaults to None.
+            reduction_override (str, optional): The method used to reduce the
+                loss. Options are "none", "mean" and "sum".
+            ignore_index (int | None): The label index to be ignored.
+                If not None, it will override the default value. Default: None.
+        Returns:
+            torch.Tensor: The calculated loss.
+        """
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        if ignore_index is None:
+            ignore_index = self.ignore_index
+
+        if self.class_weight is not None:
+            class_weight = cls_score.new_tensor(
+                self.class_weight, device=cls_score.device)
+        else:
+            class_weight = None
+        loss_cls = self.loss_weight * self.cls_criterion(
+            cls_score,
+            label,
+            weight,
+            class_weight=class_weight,
+            reduction=reduction,
+            avg_factor=avg_factor,
+            ignore_index=ignore_index,
+            avg_non_ignore=self.avg_non_ignore,
+            **kwargs)
+        return loss_cls
+
+
+@MODELS.register_module()
+class CrossEntropyCustomLoss(CrossEntropyLoss):
+
+    def __init__(self,
+                 use_sigmoid=False,
+                 use_mask=False,
+                 reduction='mean',
+                 num_classes=-1,
+                 class_weight=None,
+                 ignore_index=None,
+                 loss_weight=1.0,
+                 avg_non_ignore=False):
+        """CrossEntropyCustomLoss.
+
+        Args:
+            use_sigmoid (bool, optional): Whether the prediction uses sigmoid
+                of softmax. Defaults to False.
+            use_mask (bool, optional): Whether to use mask cross entropy loss.
+                Defaults to False.
+            reduction (str, optional): . Defaults to 'mean'.
+                Options are "none", "mean" and "sum".
+            num_classes (int): Number of classes to classify.
+            class_weight (list[float], optional): Weight of each class.
+                Defaults to None.
+            ignore_index (int | None): The label index to be ignored.
+                Defaults to None.
+            loss_weight (float, optional): Weight of the loss. Defaults to 1.0.
+            avg_non_ignore (bool): The flag decides to whether the loss is
+                only averaged over non-ignored targets. Default: False.
+        """
+        super(CrossEntropyCustomLoss, self).__init__()
+        assert (use_sigmoid is False) or (use_mask is False)
+        self.use_sigmoid = use_sigmoid
+        self.use_mask = use_mask
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+        self.class_weight = class_weight
+        self.ignore_index = ignore_index
+        self.avg_non_ignore = avg_non_ignore
+        if ((ignore_index is not None) and not self.avg_non_ignore
+                and self.reduction == 'mean'):
+            warnings.warn(
+                'Default ``avg_non_ignore`` is False, if you would like to '
+                'ignore the certain label and average loss over non-ignore '
+                'labels, which is the same with PyTorch official '
+                'cross_entropy, set ``avg_non_ignore=True``.')
+
+        if self.use_sigmoid:
+            self.cls_criterion = binary_cross_entropy
+        elif self.use_mask:
+            self.cls_criterion = mask_cross_entropy
+        else:
+            self.cls_criterion = cross_entropy
+
+        self.num_classes = num_classes
+
+        assert self.num_classes != -1
+
+        # custom output channels of the classifier
+        self.custom_cls_channels = True
+        # custom activation of cls_score
+        self.custom_activation = True
+        # custom accuracy of the classsifier
+        self.custom_accuracy = True
+
+    def get_cls_channels(self, num_classes):
+        assert num_classes == self.num_classes
+        if not self.use_sigmoid:
+            return num_classes + 1
+        else:
+            return num_classes
+
+    def get_activation(self, cls_score):
+
+        fine_cls_score = cls_score[:, :self.num_classes]
+
+        if not self.use_sigmoid:
+            bg_score = cls_score[:, [-1]]
+            new_score = torch.cat([fine_cls_score, bg_score], dim=-1)
+            scores = F.softmax(new_score, dim=-1)
+        else:
+            score_classes = fine_cls_score.sigmoid()
+            score_neg = 1 - score_classes.sum(dim=1, keepdim=True)
+            score_neg = score_neg.clamp(min=0, max=1)
+            scores = torch.cat([score_classes, score_neg], dim=1)
+
+        return scores
+
+    def get_accuracy(self, cls_score, labels):
+
+        fine_cls_score = cls_score[:, :self.num_classes]
+
+        pos_inds = labels < self.num_classes
+        acc_classes = accuracy(fine_cls_score[pos_inds], labels[pos_inds])
+        acc = dict()
+        acc['acc_classes'] = acc_classes
+        return acc
diff --git a/mmdetection/mmdet/models/losses/ddq_detr_aux_loss.py b/mmdetection/mmdet/models/losses/ddq_detr_aux_loss.py
new file mode 100644
index 00000000..41f1c716
--- /dev/null
+++ b/mmdetection/mmdet/models/losses/ddq_detr_aux_loss.py
@@ -0,0 +1,303 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmengine.structures import BaseDataElement
+
+from mmdet.models.utils import multi_apply
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.utils import reduce_mean
+
+
+class DDQAuxLoss(nn.Module):
+    """DDQ auxiliary branches loss for dense queries.
+
+    Args:
+        loss_cls (dict):
+            Configuration of classification loss function.
+        loss_bbox (dict):
+            Configuration of bbox regression loss function.
+        train_cfg (dict):
+            Configuration of gt targets assigner for each predicted bbox.
+    """
+
+    def __init__(
+        self,
+        loss_cls=dict(
+            type='QualityFocalLoss',
+            use_sigmoid=True,
+            activated=True,  # use probability instead of logit as input
+            beta=2.0,
+            loss_weight=1.0),
+        loss_bbox=dict(type='GIoULoss', loss_weight=2.0),
+        train_cfg=dict(
+            assigner=dict(type='TopkHungarianAssigner', topk=8),
+            alpha=1,
+            beta=6),
+    ):
+        super(DDQAuxLoss, self).__init__()
+        self.train_cfg = train_cfg
+        self.loss_cls = MODELS.build(loss_cls)
+        self.loss_bbox = MODELS.build(loss_bbox)
+        self.assigner = TASK_UTILS.build(self.train_cfg['assigner'])
+
+        sampler_cfg = dict(type='PseudoSampler')
+        self.sampler = TASK_UTILS.build(sampler_cfg)
+
+    def loss_single(self, cls_score, bbox_pred, labels, label_weights,
+                    bbox_targets, alignment_metrics):
+        """Calculate auxiliary branches loss for dense queries for one image.
+
+        Args:
+            cls_score (Tensor): Predicted normalized classification
+                scores for one image, has shape (num_dense_queries,
+                cls_out_channels).
+            bbox_pred (Tensor): Predicted unnormalized bbox coordinates
+                for one image, has shape (num_dense_queries, 4) with the
+                last dimension arranged as (x1, y1, x2, y2).
+            labels (Tensor): Labels for one image.
+            label_weights (Tensor): Label weights for one image.
+            bbox_targets (Tensor): Bbox targets for one image.
+            alignment_metrics (Tensor): Normalized alignment metrics for one
+                image.
+
+        Returns:
+            tuple: A tuple of loss components and loss weights.
+        """
+        bbox_targets = bbox_targets.reshape(-1, 4)
+        labels = labels.reshape(-1)
+        alignment_metrics = alignment_metrics.reshape(-1)
+        label_weights = label_weights.reshape(-1)
+        targets = (labels, alignment_metrics)
+        cls_loss_func = self.loss_cls
+
+        loss_cls = cls_loss_func(
+            cls_score, targets, label_weights, avg_factor=1.0)
+
+        # FG cat_id: [0, num_classes -1], BG cat_id: num_classes
+        bg_class_ind = cls_score.size(-1)
+        pos_inds = ((labels >= 0)
+                    & (labels < bg_class_ind)).nonzero().squeeze(1)
+
+        if len(pos_inds) > 0:
+            pos_bbox_targets = bbox_targets[pos_inds]
+            pos_bbox_pred = bbox_pred[pos_inds]
+
+            pos_decode_bbox_pred = pos_bbox_pred
+            pos_decode_bbox_targets = pos_bbox_targets
+
+            # regression loss
+            pos_bbox_weight = alignment_metrics[pos_inds]
+
+            loss_bbox = self.loss_bbox(
+                pos_decode_bbox_pred,
+                pos_decode_bbox_targets,
+                weight=pos_bbox_weight,
+                avg_factor=1.0)
+        else:
+            loss_bbox = bbox_pred.sum() * 0
+            pos_bbox_weight = bbox_targets.new_tensor(0.)
+
+        return loss_cls, loss_bbox, alignment_metrics.sum(
+        ), pos_bbox_weight.sum()
+
+    def loss(self, cls_scores, bbox_preds, gt_bboxes, gt_labels, img_metas,
+             **kwargs):
+        """Calculate auxiliary branches loss for dense queries.
+
+        Args:
+            cls_scores (Tensor): Predicted normalized classification
+                scores, has shape (bs, num_dense_queries,
+                cls_out_channels).
+            bbox_preds (Tensor): Predicted unnormalized bbox coordinates,
+                has shape (bs, num_dense_queries, 4) with the last
+                dimension arranged as (x1, y1, x2, y2).
+            gt_bboxes (list[Tensor]): List of unnormalized ground truth
+                bboxes for each image, each has shape (num_gt, 4) with the
+                last dimension arranged as (x1, y1, x2, y2).
+                NOTE: num_gt is dynamic for each image.
+            gt_labels (list[Tensor]): List of ground truth classification
+                index for each image, each has shape (num_gt,).
+                NOTE: num_gt is dynamic for each image.
+            img_metas (list[dict]): Meta information for one image,
+                e.g., image size, scaling factor, etc.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        flatten_cls_scores = cls_scores
+        flatten_bbox_preds = bbox_preds
+
+        cls_reg_targets = self.get_targets(
+            flatten_cls_scores,
+            flatten_bbox_preds,
+            gt_bboxes,
+            img_metas,
+            gt_labels_list=gt_labels,
+        )
+        (labels_list, label_weights_list, bbox_targets_list,
+         alignment_metrics_list) = cls_reg_targets
+
+        losses_cls, losses_bbox, \
+            cls_avg_factors, bbox_avg_factors = multi_apply(
+                self.loss_single,
+                flatten_cls_scores,
+                flatten_bbox_preds,
+                labels_list,
+                label_weights_list,
+                bbox_targets_list,
+                alignment_metrics_list,
+                )
+
+        cls_avg_factor = reduce_mean(sum(cls_avg_factors)).clamp_(min=1).item()
+        losses_cls = list(map(lambda x: x / cls_avg_factor, losses_cls))
+
+        bbox_avg_factor = reduce_mean(
+            sum(bbox_avg_factors)).clamp_(min=1).item()
+        losses_bbox = list(map(lambda x: x / bbox_avg_factor, losses_bbox))
+        return dict(aux_loss_cls=losses_cls, aux_loss_bbox=losses_bbox)
+
+    def get_targets(self,
+                    cls_scores,
+                    bbox_preds,
+                    gt_bboxes_list,
+                    img_metas,
+                    gt_labels_list=None,
+                    **kwargs):
+        """Compute regression and classification targets for a batch images.
+
+        Args:
+            cls_scores (Tensor): Predicted normalized classification
+                scores, has shape (bs, num_dense_queries,
+                cls_out_channels).
+            bbox_preds (Tensor): Predicted unnormalized bbox coordinates,
+                has shape (bs, num_dense_queries, 4) with the last
+                dimension arranged as (x1, y1, x2, y2).
+            gt_bboxes_list (List[Tensor]): List of unnormalized ground truth
+                bboxes for each image, each has shape (num_gt, 4) with the
+                last dimension arranged as (x1, y1, x2, y2).
+                NOTE: num_gt is dynamic for each image.
+            img_metas (list[dict]): Meta information for one image,
+                e.g., image size, scaling factor, etc.
+            gt_labels_list (list[Tensor]): List of ground truth classification
+                    index for each image, each has shape (num_gt,).
+                    NOTE: num_gt is dynamic for each image.
+                    Default: None.
+
+        Returns:
+            tuple: a tuple containing the following targets.
+
+            - all_labels (list[Tensor]): Labels for all images.
+            - all_label_weights (list[Tensor]): Label weights for all images.
+            - all_bbox_targets (list[Tensor]): Bbox targets for all images.
+            - all_assign_metrics (list[Tensor]): Normalized alignment metrics
+                for all images.
+        """
+        (all_labels, all_label_weights, all_bbox_targets,
+         all_assign_metrics) = multi_apply(self._get_target_single, cls_scores,
+                                           bbox_preds, gt_bboxes_list,
+                                           gt_labels_list, img_metas)
+
+        return (all_labels, all_label_weights, all_bbox_targets,
+                all_assign_metrics)
+
+    def _get_target_single(self, cls_scores, bbox_preds, gt_bboxes, gt_labels,
+                           img_meta, **kwargs):
+        """Compute regression and classification targets for one image.
+
+        Args:
+            cls_scores (Tensor): Predicted normalized classification
+                scores for one image, has shape (num_dense_queries,
+                cls_out_channels).
+            bbox_preds (Tensor): Predicted unnormalized bbox coordinates
+                for one image, has shape (num_dense_queries, 4) with the
+                last dimension arranged as (x1, y1, x2, y2).
+            gt_bboxes (Tensor): Unnormalized ground truth
+                bboxes for one image, has shape (num_gt, 4) with the
+                last dimension arranged as (x1, y1, x2, y2).
+                NOTE: num_gt is dynamic for each image.
+            gt_labels (Tensor): Ground truth classification
+                    index for the image, has shape (num_gt,).
+                    NOTE: num_gt is dynamic for each image.
+            img_meta (dict): Meta information for one image.
+
+        Returns:
+            tuple[Tensor]: a tuple containing the following for one image.
+
+            - labels (Tensor): Labels for one image.
+            - label_weights (Tensor): Label weights for one image.
+            - bbox_targets (Tensor): Bbox targets for one image.
+            - norm_alignment_metrics (Tensor): Normalized alignment
+                metrics for one image.
+        """
+        if len(gt_labels) == 0:
+            num_valid_anchors = len(cls_scores)
+            bbox_targets = torch.zeros_like(bbox_preds)
+            labels = bbox_preds.new_full((num_valid_anchors, ),
+                                         cls_scores.size(-1),
+                                         dtype=torch.long)
+            label_weights = bbox_preds.new_zeros(
+                num_valid_anchors, dtype=torch.float)
+            norm_alignment_metrics = bbox_preds.new_zeros(
+                num_valid_anchors, dtype=torch.float)
+            return (labels, label_weights, bbox_targets,
+                    norm_alignment_metrics)
+
+        assign_result = self.assigner.assign(cls_scores, bbox_preds, gt_bboxes,
+                                             gt_labels, img_meta)
+        assign_ious = assign_result.max_overlaps
+        assign_metrics = assign_result.assign_metrics
+
+        pred_instances = BaseDataElement()
+        gt_instances = BaseDataElement()
+
+        pred_instances.bboxes = bbox_preds
+        gt_instances.bboxes = gt_bboxes
+
+        pred_instances.priors = cls_scores
+        gt_instances.labels = gt_labels
+
+        sampling_result = self.sampler.sample(assign_result, pred_instances,
+                                              gt_instances)
+
+        num_valid_anchors = len(cls_scores)
+        bbox_targets = torch.zeros_like(bbox_preds)
+        labels = bbox_preds.new_full((num_valid_anchors, ),
+                                     cls_scores.size(-1),
+                                     dtype=torch.long)
+        label_weights = bbox_preds.new_zeros(
+            num_valid_anchors, dtype=torch.float)
+        norm_alignment_metrics = bbox_preds.new_zeros(
+            num_valid_anchors, dtype=torch.float)
+
+        pos_inds = sampling_result.pos_inds
+        neg_inds = sampling_result.neg_inds
+        if len(pos_inds) > 0:
+            # point-based
+            pos_bbox_targets = sampling_result.pos_gt_bboxes
+            bbox_targets[pos_inds, :] = pos_bbox_targets
+
+            if gt_labels is None:
+                # Only dense_heads gives gt_labels as None
+                # Foreground is the first class since v2.5.0
+                labels[pos_inds] = 0
+            else:
+                labels[pos_inds] = gt_labels[
+                    sampling_result.pos_assigned_gt_inds]
+
+            label_weights[pos_inds] = 1.0
+
+        if len(neg_inds) > 0:
+            label_weights[neg_inds] = 1.0
+
+        class_assigned_gt_inds = torch.unique(
+            sampling_result.pos_assigned_gt_inds)
+        for gt_inds in class_assigned_gt_inds:
+            gt_class_inds = sampling_result.pos_assigned_gt_inds == gt_inds
+            pos_alignment_metrics = assign_metrics[gt_class_inds]
+            pos_ious = assign_ious[gt_class_inds]
+            pos_norm_alignment_metrics = pos_alignment_metrics / (
+                pos_alignment_metrics.max() + 10e-8) * pos_ious.max()
+            norm_alignment_metrics[
+                pos_inds[gt_class_inds]] = pos_norm_alignment_metrics
+
+        return (labels, label_weights, bbox_targets, norm_alignment_metrics)
diff --git a/mmdetection/mmdet/models/losses/dice_loss.py b/mmdetection/mmdet/models/losses/dice_loss.py
new file mode 100644
index 00000000..1d5cac1e
--- /dev/null
+++ b/mmdetection/mmdet/models/losses/dice_loss.py
@@ -0,0 +1,146 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+
+from mmdet.registry import MODELS
+from .utils import weight_reduce_loss
+
+
+def dice_loss(pred,
+              target,
+              weight=None,
+              eps=1e-3,
+              reduction='mean',
+              naive_dice=False,
+              avg_factor=None):
+    """Calculate dice loss, there are two forms of dice loss is supported:
+
+        - the one proposed in `V-Net: Fully Convolutional Neural
+            Networks for Volumetric Medical Image Segmentation
+            `_.
+        - the dice loss in which the power of the number in the
+            denominator is the first power instead of the second
+            power.
+
+    Args:
+        pred (torch.Tensor): The prediction, has a shape (n, *)
+        target (torch.Tensor): The learning label of the prediction,
+            shape (n, *), same shape of pred.
+        weight (torch.Tensor, optional): The weight of loss for each
+            prediction, has a shape (n,). Defaults to None.
+        eps (float): Avoid dividing by zero. Default: 1e-3.
+        reduction (str, optional): The method used to reduce the loss into
+            a scalar. Defaults to 'mean'.
+            Options are "none", "mean" and "sum".
+        naive_dice (bool, optional): If false, use the dice
+                loss defined in the V-Net paper, otherwise, use the
+                naive dice loss in which the power of the number in the
+                denominator is the first power instead of the second
+                power.Defaults to False.
+        avg_factor (int, optional): Average factor that is used to average
+            the loss. Defaults to None.
+    """
+
+    input = pred.flatten(1)
+    target = target.flatten(1).float()
+
+    a = torch.sum(input * target, 1)
+    if naive_dice:
+        b = torch.sum(input, 1)
+        c = torch.sum(target, 1)
+        d = (2 * a + eps) / (b + c + eps)
+    else:
+        b = torch.sum(input * input, 1) + eps
+        c = torch.sum(target * target, 1) + eps
+        d = (2 * a) / (b + c)
+
+    loss = 1 - d
+    if weight is not None:
+        assert weight.ndim == loss.ndim
+        assert len(weight) == len(pred)
+    loss = weight_reduce_loss(loss, weight, reduction, avg_factor)
+    return loss
+
+
+@MODELS.register_module()
+class DiceLoss(nn.Module):
+
+    def __init__(self,
+                 use_sigmoid=True,
+                 activate=True,
+                 reduction='mean',
+                 naive_dice=False,
+                 loss_weight=1.0,
+                 eps=1e-3):
+        """Compute dice loss.
+
+        Args:
+            use_sigmoid (bool, optional): Whether to the prediction is
+                used for sigmoid or softmax. Defaults to True.
+            activate (bool): Whether to activate the predictions inside,
+                this will disable the inside sigmoid operation.
+                Defaults to True.
+            reduction (str, optional): The method used
+                to reduce the loss. Options are "none",
+                "mean" and "sum". Defaults to 'mean'.
+            naive_dice (bool, optional): If false, use the dice
+                loss defined in the V-Net paper, otherwise, use the
+                naive dice loss in which the power of the number in the
+                denominator is the first power instead of the second
+                power. Defaults to False.
+            loss_weight (float, optional): Weight of loss. Defaults to 1.0.
+            eps (float): Avoid dividing by zero. Defaults to 1e-3.
+        """
+
+        super(DiceLoss, self).__init__()
+        self.use_sigmoid = use_sigmoid
+        self.reduction = reduction
+        self.naive_dice = naive_dice
+        self.loss_weight = loss_weight
+        self.eps = eps
+        self.activate = activate
+
+    def forward(self,
+                pred,
+                target,
+                weight=None,
+                reduction_override=None,
+                avg_factor=None):
+        """Forward function.
+
+        Args:
+            pred (torch.Tensor): The prediction, has a shape (n, *).
+            target (torch.Tensor): The label of the prediction,
+                shape (n, *), same shape of pred.
+            weight (torch.Tensor, optional): The weight of loss for each
+                prediction, has a shape (n,). Defaults to None.
+            avg_factor (int, optional): Average factor that is used to average
+                the loss. Defaults to None.
+            reduction_override (str, optional): The reduction method used to
+                override the original reduction method of the loss.
+                Options are "none", "mean" and "sum".
+
+        Returns:
+            torch.Tensor: The calculated loss
+        """
+
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+
+        if self.activate:
+            if self.use_sigmoid:
+                pred = pred.sigmoid()
+            else:
+                raise NotImplementedError
+
+        loss = self.loss_weight * dice_loss(
+            pred,
+            target,
+            weight,
+            eps=self.eps,
+            reduction=reduction,
+            naive_dice=self.naive_dice,
+            avg_factor=avg_factor)
+
+        return loss
diff --git a/mmdetection/mmdet/models/losses/eqlv2_loss.py b/mmdetection/mmdet/models/losses/eqlv2_loss.py
new file mode 100644
index 00000000..ea1f4a9a
--- /dev/null
+++ b/mmdetection/mmdet/models/losses/eqlv2_loss.py
@@ -0,0 +1,173 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import logging
+from functools import partial
+from typing import Optional
+
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+import torch.nn.functional as F
+from mmengine.logging import print_log
+from torch import Tensor
+
+from mmdet.registry import MODELS
+
+
+@MODELS.register_module()
+class EQLV2Loss(nn.Module):
+
+    def __init__(self,
+                 use_sigmoid: bool = True,
+                 reduction: str = 'mean',
+                 class_weight: Optional[Tensor] = None,
+                 loss_weight: float = 1.0,
+                 num_classes: int = 1203,
+                 use_distributed: bool = False,
+                 mu: float = 0.8,
+                 alpha: float = 4.0,
+                 gamma: int = 12,
+                 vis_grad: bool = False,
+                 test_with_obj: bool = True) -> None:
+        """`Equalization Loss v2 `_
+
+        Args:
+            use_sigmoid (bool): EQLv2 uses the sigmoid function to transform
+                the predicted logits to an estimated probability distribution.
+            reduction (str, optional): The method used to reduce the loss into
+                a scalar. Defaults to 'mean'.
+            class_weight (Tensor, optional): The weight of loss for each
+                prediction. Defaults to None.
+            loss_weight (float, optional): The weight of the total EQLv2 loss.
+                Defaults to 1.0.
+            num_classes (int): 1203 for lvis v1.0, 1230 for lvis v0.5.
+            use_distributed (bool, float): EQLv2 will calculate the gradients
+                on all GPUs if there is any. Change to True if you are using
+                distributed training. Default to False.
+            mu (float, optional): Defaults to 0.8
+            alpha (float, optional): A balance factor for the negative part of
+                EQLV2 Loss. Defaults to 4.0.
+            gamma (int, optional): The gamma for calculating the modulating
+                factor. Defaults to 12.
+            vis_grad (bool, optional): Default to False.
+            test_with_obj (bool, optional): Default to True.
+
+        Returns:
+            None.
+        """
+        super().__init__()
+        self.use_sigmoid = True
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+        self.class_weight = class_weight
+        self.num_classes = num_classes
+        self.group = True
+
+        # cfg for eqlv2
+        self.vis_grad = vis_grad
+        self.mu = mu
+        self.alpha = alpha
+        self.gamma = gamma
+        self.use_distributed = use_distributed
+
+        # initial variables
+        self.register_buffer('pos_grad', torch.zeros(self.num_classes))
+        self.register_buffer('neg_grad', torch.zeros(self.num_classes))
+        # At the beginning of training, we set a high value (eg. 100)
+        # for the initial gradient ratio so that the weight for pos
+        # gradients and neg gradients are 1.
+        self.register_buffer('pos_neg', torch.ones(self.num_classes) * 100)
+
+        self.test_with_obj = test_with_obj
+
+        def _func(x, gamma, mu):
+            return 1 / (1 + torch.exp(-gamma * (x - mu)))
+
+        self.map_func = partial(_func, gamma=self.gamma, mu=self.mu)
+
+        print_log(
+            f'build EQL v2, gamma: {gamma}, mu: {mu}, alpha: {alpha}',
+            logger='current',
+            level=logging.DEBUG)
+
+    def forward(self,
+                cls_score: Tensor,
+                label: Tensor,
+                weight: Optional[Tensor] = None,
+                avg_factor: Optional[int] = None,
+                reduction_override: Optional[Tensor] = None) -> Tensor:
+        """`Equalization Loss v2 `_
+
+        Args:
+            cls_score (Tensor): The prediction with shape (N, C), C is the
+                number of classes.
+            label (Tensor): The ground truth label of the predicted target with
+                shape (N, C), C is the number of classes.
+            weight (Tensor, optional): The weight of loss for each prediction.
+                Defaults to None.
+            avg_factor (int, optional): Average factor that is used to average
+                the loss. Defaults to None.
+            reduction_override (str, optional): The reduction method used to
+                override the original reduction method of the loss.
+                Options are "none", "mean" and "sum".
+
+        Returns:
+           Tensor: The calculated loss
+        """
+        self.n_i, self.n_c = cls_score.size()
+        self.gt_classes = label
+        self.pred_class_logits = cls_score
+
+        def expand_label(pred, gt_classes):
+            target = pred.new_zeros(self.n_i, self.n_c)
+            target[torch.arange(self.n_i), gt_classes] = 1
+            return target
+
+        target = expand_label(cls_score, label)
+
+        pos_w, neg_w = self.get_weight(cls_score)
+
+        weight = pos_w * target + neg_w * (1 - target)
+
+        cls_loss = F.binary_cross_entropy_with_logits(
+            cls_score, target, reduction='none')
+        cls_loss = torch.sum(cls_loss * weight) / self.n_i
+
+        self.collect_grad(cls_score.detach(), target.detach(), weight.detach())
+
+        return self.loss_weight * cls_loss
+
+    def get_channel_num(self, num_classes):
+        num_channel = num_classes + 1
+        return num_channel
+
+    def get_activation(self, pred):
+        pred = torch.sigmoid(pred)
+        n_i, n_c = pred.size()
+        bg_score = pred[:, -1].view(n_i, 1)
+        if self.test_with_obj:
+            pred[:, :-1] *= (1 - bg_score)
+        return pred
+
+    def collect_grad(self, pred, target, weight):
+        prob = torch.sigmoid(pred)
+        grad = target * (prob - 1) + (1 - target) * prob
+        grad = torch.abs(grad)
+
+        # do not collect grad for objectiveness branch [:-1]
+        pos_grad = torch.sum(grad * target * weight, dim=0)[:-1]
+        neg_grad = torch.sum(grad * (1 - target) * weight, dim=0)[:-1]
+
+        if self.use_distributed:
+            dist.all_reduce(pos_grad)
+            dist.all_reduce(neg_grad)
+
+        self.pos_grad += pos_grad
+        self.neg_grad += neg_grad
+        self.pos_neg = self.pos_grad / (self.neg_grad + 1e-10)
+
+    def get_weight(self, pred):
+        neg_w = torch.cat([self.map_func(self.pos_neg), pred.new_ones(1)])
+        pos_w = 1 + self.alpha * (1 - neg_w)
+        neg_w = neg_w.view(1, -1).expand(self.n_i, self.n_c)
+        pos_w = pos_w.view(1, -1).expand(self.n_i, self.n_c)
+        return pos_w, neg_w
diff --git a/mmdetection/mmdet/models/losses/focal_loss.py b/mmdetection/mmdet/models/losses/focal_loss.py
new file mode 100644
index 00000000..15bef293
--- /dev/null
+++ b/mmdetection/mmdet/models/losses/focal_loss.py
@@ -0,0 +1,371 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.ops import sigmoid_focal_loss as _sigmoid_focal_loss
+
+from mmdet.registry import MODELS
+from .accuracy import accuracy
+from .utils import weight_reduce_loss
+
+
+# This method is only for debugging
+def py_sigmoid_focal_loss(pred,
+                          target,
+                          weight=None,
+                          gamma=2.0,
+                          alpha=0.25,
+                          reduction='mean',
+                          avg_factor=None):
+    """PyTorch version of `Focal Loss `_.
+
+    Args:
+        pred (torch.Tensor): The prediction with shape (N, C), C is the
+            number of classes
+        target (torch.Tensor): The learning label of the prediction.
+        weight (torch.Tensor, optional): Sample-wise loss weight.
+        gamma (float, optional): The gamma for calculating the modulating
+            factor. Defaults to 2.0.
+        alpha (float, optional): A balanced form for Focal Loss.
+            Defaults to 0.25.
+        reduction (str, optional): The method used to reduce the loss into
+            a scalar. Defaults to 'mean'.
+        avg_factor (int, optional): Average factor that is used to average
+            the loss. Defaults to None.
+    """
+    pred_sigmoid = pred.sigmoid()
+    target = target.type_as(pred)
+    # Actually, pt here denotes (1 - pt) in the Focal Loss paper
+    pt = (1 - pred_sigmoid) * target + pred_sigmoid * (1 - target)
+    # Thus it's pt.pow(gamma) rather than (1 - pt).pow(gamma)
+    focal_weight = (alpha * target + (1 - alpha) *
+                    (1 - target)) * pt.pow(gamma)
+    loss = F.binary_cross_entropy_with_logits(
+        pred, target, reduction='none') * focal_weight
+    if weight is not None:
+        if weight.shape != loss.shape:
+            if weight.size(0) == loss.size(0):
+                # For most cases, weight is of shape (num_priors, ),
+                #  which means it does not have the second axis num_class
+                weight = weight.view(-1, 1)
+            else:
+                # Sometimes, weight per anchor per class is also needed. e.g.
+                #  in FSAF. But it may be flattened of shape
+                #  (num_priors x num_class, ), while loss is still of shape
+                #  (num_priors, num_class).
+                assert weight.numel() == loss.numel()
+                weight = weight.view(loss.size(0), -1)
+        assert weight.ndim == loss.ndim
+    loss = weight_reduce_loss(loss, weight, reduction, avg_factor)
+    return loss
+
+
+def py_focal_loss_with_prob(pred,
+                            target,
+                            weight=None,
+                            gamma=2.0,
+                            alpha=0.25,
+                            reduction='mean',
+                            avg_factor=None):
+    """PyTorch version of `Focal Loss `_.
+    Different from `py_sigmoid_focal_loss`, this function accepts probability
+    as input.
+
+    Args:
+        pred (torch.Tensor): The prediction probability with shape (N, C),
+            C is the number of classes.
+        target (torch.Tensor): The learning label of the prediction.
+            The target shape support (N,C) or (N,), (N,C) means one-hot form.
+        weight (torch.Tensor, optional): Sample-wise loss weight.
+        gamma (float, optional): The gamma for calculating the modulating
+            factor. Defaults to 2.0.
+        alpha (float, optional): A balanced form for Focal Loss.
+            Defaults to 0.25.
+        reduction (str, optional): The method used to reduce the loss into
+            a scalar. Defaults to 'mean'.
+        avg_factor (int, optional): Average factor that is used to average
+            the loss. Defaults to None.
+    """
+    if pred.dim() != target.dim():
+        num_classes = pred.size(1)
+        target = F.one_hot(target, num_classes=num_classes + 1)
+        target = target[:, :num_classes]
+
+    target = target.type_as(pred)
+    pt = (1 - pred) * target + pred * (1 - target)
+    focal_weight = (alpha * target + (1 - alpha) *
+                    (1 - target)) * pt.pow(gamma)
+    loss = F.binary_cross_entropy(
+        pred, target, reduction='none') * focal_weight
+    if weight is not None:
+        if weight.shape != loss.shape:
+            if weight.size(0) == loss.size(0):
+                # For most cases, weight is of shape (num_priors, ),
+                #  which means it does not have the second axis num_class
+                weight = weight.view(-1, 1)
+            else:
+                # Sometimes, weight per anchor per class is also needed. e.g.
+                #  in FSAF. But it may be flattened of shape
+                #  (num_priors x num_class, ), while loss is still of shape
+                #  (num_priors, num_class).
+                assert weight.numel() == loss.numel()
+                weight = weight.view(loss.size(0), -1)
+        assert weight.ndim == loss.ndim
+    loss = weight_reduce_loss(loss, weight, reduction, avg_factor)
+    return loss
+
+
+def sigmoid_focal_loss(pred,
+                       target,
+                       weight=None,
+                       gamma=2.0,
+                       alpha=0.25,
+                       reduction='mean',
+                       avg_factor=None):
+    r"""A wrapper of cuda version `Focal Loss
+    `_.
+
+    Args:
+        pred (torch.Tensor): The prediction with shape (N, C), C is the number
+            of classes.
+        target (torch.Tensor): The learning label of the prediction.
+        weight (torch.Tensor, optional): Sample-wise loss weight.
+        gamma (float, optional): The gamma for calculating the modulating
+            factor. Defaults to 2.0.
+        alpha (float, optional): A balanced form for Focal Loss.
+            Defaults to 0.25.
+        reduction (str, optional): The method used to reduce the loss into
+            a scalar. Defaults to 'mean'. Options are "none", "mean" and "sum".
+        avg_factor (int, optional): Average factor that is used to average
+            the loss. Defaults to None.
+    """
+    # Function.apply does not accept keyword arguments, so the decorator
+    # "weighted_loss" is not applicable
+    loss = _sigmoid_focal_loss(pred.contiguous(), target.contiguous(), gamma,
+                               alpha, None, 'none')
+    if weight is not None:
+        if weight.shape != loss.shape:
+            if weight.size(0) == loss.size(0):
+                # For most cases, weight is of shape (num_priors, ),
+                #  which means it does not have the second axis num_class
+                weight = weight.view(-1, 1)
+            else:
+                # Sometimes, weight per anchor per class is also needed. e.g.
+                #  in FSAF. But it may be flattened of shape
+                #  (num_priors x num_class, ), while loss is still of shape
+                #  (num_priors, num_class).
+                assert weight.numel() == loss.numel()
+                weight = weight.view(loss.size(0), -1)
+        assert weight.ndim == loss.ndim
+    loss = weight_reduce_loss(loss, weight, reduction, avg_factor)
+    return loss
+
+
+@MODELS.register_module()
+class FocalLoss(nn.Module):
+
+    def __init__(self,
+                 use_sigmoid=True,
+                 gamma=2.0,
+                 alpha=0.25,
+                 reduction='mean',
+                 loss_weight=1.0,
+                 activated=False):
+        """`Focal Loss `_
+
+        Args:
+            use_sigmoid (bool, optional): Whether to the prediction is
+                used for sigmoid or softmax. Defaults to True.
+            gamma (float, optional): The gamma for calculating the modulating
+                factor. Defaults to 2.0.
+            alpha (float, optional): A balanced form for Focal Loss.
+                Defaults to 0.25.
+            reduction (str, optional): The method used to reduce the loss into
+                a scalar. Defaults to 'mean'. Options are "none", "mean" and
+                "sum".
+            loss_weight (float, optional): Weight of loss. Defaults to 1.0.
+            activated (bool, optional): Whether the input is activated.
+                If True, it means the input has been activated and can be
+                treated as probabilities. Else, it should be treated as logits.
+                Defaults to False.
+        """
+        super(FocalLoss, self).__init__()
+        assert use_sigmoid is True, 'Only sigmoid focal loss supported now.'
+        self.use_sigmoid = use_sigmoid
+        self.gamma = gamma
+        self.alpha = alpha
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+        self.activated = activated
+
+    def forward(self,
+                pred,
+                target,
+                weight=None,
+                avg_factor=None,
+                reduction_override=None):
+        """Forward function.
+
+        Args:
+            pred (torch.Tensor): The prediction.
+            target (torch.Tensor): The learning label of the prediction.
+                The target shape support (N,C) or (N,), (N,C) means
+                one-hot form.
+            weight (torch.Tensor, optional): The weight of loss for each
+                prediction. Defaults to None.
+            avg_factor (int, optional): Average factor that is used to average
+                the loss. Defaults to None.
+            reduction_override (str, optional): The reduction method used to
+                override the original reduction method of the loss.
+                Options are "none", "mean" and "sum".
+
+        Returns:
+            torch.Tensor: The calculated loss
+        """
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        if self.use_sigmoid:
+            if self.activated:
+                calculate_loss_func = py_focal_loss_with_prob
+            else:
+                if pred.dim() == target.dim():
+                    # this means that target is already in One-Hot form.
+                    calculate_loss_func = py_sigmoid_focal_loss
+                elif torch.cuda.is_available() and pred.is_cuda:
+                    calculate_loss_func = sigmoid_focal_loss
+                else:
+                    num_classes = pred.size(1)
+                    target = F.one_hot(target, num_classes=num_classes + 1)
+                    target = target[:, :num_classes]
+                    calculate_loss_func = py_sigmoid_focal_loss
+
+            loss_cls = self.loss_weight * calculate_loss_func(
+                pred,
+                target,
+                weight,
+                gamma=self.gamma,
+                alpha=self.alpha,
+                reduction=reduction,
+                avg_factor=avg_factor)
+
+        else:
+            raise NotImplementedError
+        return loss_cls
+
+
+@MODELS.register_module()
+class FocalCustomLoss(nn.Module):
+
+    def __init__(self,
+                 use_sigmoid=True,
+                 num_classes=-1,
+                 gamma=2.0,
+                 alpha=0.25,
+                 reduction='mean',
+                 loss_weight=1.0,
+                 activated=False):
+        """`Focal Loss for V3Det `_
+
+        Args:
+            use_sigmoid (bool, optional): Whether to the prediction is
+                used for sigmoid or softmax. Defaults to True.
+            num_classes (int): Number of classes to classify.
+            gamma (float, optional): The gamma for calculating the modulating
+                factor. Defaults to 2.0.
+            alpha (float, optional): A balanced form for Focal Loss.
+                Defaults to 0.25.
+            reduction (str, optional): The method used to reduce the loss into
+                a scalar. Defaults to 'mean'. Options are "none", "mean" and
+                "sum".
+            loss_weight (float, optional): Weight of loss. Defaults to 1.0.
+            activated (bool, optional): Whether the input is activated.
+                If True, it means the input has been activated and can be
+                treated as probabilities. Else, it should be treated as logits.
+                Defaults to False.
+        """
+        super(FocalCustomLoss, self).__init__()
+        assert use_sigmoid is True, 'Only sigmoid focal loss supported now.'
+        self.use_sigmoid = use_sigmoid
+        self.num_classes = num_classes
+        self.gamma = gamma
+        self.alpha = alpha
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+        self.activated = activated
+
+        assert self.num_classes != -1
+
+        # custom output channels of the classifier
+        self.custom_cls_channels = True
+        # custom activation of cls_score
+        self.custom_activation = True
+        # custom accuracy of the classsifier
+        self.custom_accuracy = True
+
+    def get_cls_channels(self, num_classes):
+        assert num_classes == self.num_classes
+        return num_classes
+
+    def get_activation(self, cls_score):
+
+        fine_cls_score = cls_score[:, :self.num_classes]
+
+        score_classes = fine_cls_score.sigmoid()
+
+        return score_classes
+
+    def get_accuracy(self, cls_score, labels):
+
+        fine_cls_score = cls_score[:, :self.num_classes]
+
+        pos_inds = labels < self.num_classes
+        acc_classes = accuracy(fine_cls_score[pos_inds], labels[pos_inds])
+        acc = dict()
+        acc['acc_classes'] = acc_classes
+        return acc
+
+    def forward(self,
+                pred,
+                target,
+                weight=None,
+                avg_factor=None,
+                reduction_override=None):
+        """Forward function.
+
+        Args:
+            pred (torch.Tensor): The prediction.
+            target (torch.Tensor): The learning label of the prediction.
+            weight (torch.Tensor, optional): The weight of loss for each
+                prediction. Defaults to None.
+            avg_factor (int, optional): Average factor that is used to average
+                the loss. Defaults to None.
+            reduction_override (str, optional): The reduction method used to
+                override the original reduction method of the loss.
+                Options are "none", "mean" and "sum".
+
+        Returns:
+            torch.Tensor: The calculated loss
+        """
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        if self.use_sigmoid:
+
+            num_classes = pred.size(1)
+            target = F.one_hot(target, num_classes=num_classes + 1)
+            target = target[:, :num_classes]
+            calculate_loss_func = py_sigmoid_focal_loss
+
+            loss_cls = self.loss_weight * calculate_loss_func(
+                pred,
+                target,
+                weight,
+                gamma=self.gamma,
+                alpha=self.alpha,
+                reduction=reduction,
+                avg_factor=avg_factor)
+
+        else:
+            raise NotImplementedError
+        return loss_cls
diff --git a/mmdetection/mmdet/models/losses/gaussian_focal_loss.py b/mmdetection/mmdet/models/losses/gaussian_focal_loss.py
new file mode 100644
index 00000000..14fa8da4
--- /dev/null
+++ b/mmdetection/mmdet/models/losses/gaussian_focal_loss.py
@@ -0,0 +1,186 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Union
+
+import torch.nn as nn
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from .utils import weight_reduce_loss, weighted_loss
+
+
+@weighted_loss
+def gaussian_focal_loss(pred: Tensor,
+                        gaussian_target: Tensor,
+                        alpha: float = 2.0,
+                        gamma: float = 4.0,
+                        pos_weight: float = 1.0,
+                        neg_weight: float = 1.0) -> Tensor:
+    """`Focal Loss `_ for targets in gaussian
+    distribution.
+
+    Args:
+        pred (torch.Tensor): The prediction.
+        gaussian_target (torch.Tensor): The learning target of the prediction
+            in gaussian distribution.
+        alpha (float, optional): A balanced form for Focal Loss.
+            Defaults to 2.0.
+        gamma (float, optional): The gamma for calculating the modulating
+            factor. Defaults to 4.0.
+        pos_weight(float): Positive sample loss weight. Defaults to 1.0.
+        neg_weight(float): Negative sample loss weight. Defaults to 1.0.
+    """
+    eps = 1e-12
+    pos_weights = gaussian_target.eq(1)
+    neg_weights = (1 - gaussian_target).pow(gamma)
+    pos_loss = -(pred + eps).log() * (1 - pred).pow(alpha) * pos_weights
+    neg_loss = -(1 - pred + eps).log() * pred.pow(alpha) * neg_weights
+    return pos_weight * pos_loss + neg_weight * neg_loss
+
+
+def gaussian_focal_loss_with_pos_inds(
+        pred: Tensor,
+        gaussian_target: Tensor,
+        pos_inds: Tensor,
+        pos_labels: Tensor,
+        alpha: float = 2.0,
+        gamma: float = 4.0,
+        pos_weight: float = 1.0,
+        neg_weight: float = 1.0,
+        reduction: str = 'mean',
+        avg_factor: Optional[Union[int, float]] = None) -> Tensor:
+    """`Focal Loss `_ for targets in gaussian
+    distribution.
+
+    Note: The index with a value of 1 in ``gaussian_target`` in the
+    ``gaussian_focal_loss`` function is a positive sample, but in
+    ``gaussian_focal_loss_with_pos_inds`` the positive sample is passed
+    in through the ``pos_inds`` parameter.
+
+    Args:
+        pred (torch.Tensor): The prediction. The shape is (N, num_classes).
+        gaussian_target (torch.Tensor): The learning target of the prediction
+            in gaussian distribution. The shape is (N, num_classes).
+        pos_inds (torch.Tensor): The positive sample index.
+            The shape is (M, ).
+        pos_labels (torch.Tensor): The label corresponding to the positive
+            sample index. The shape is (M, ).
+        alpha (float, optional): A balanced form for Focal Loss.
+            Defaults to 2.0.
+        gamma (float, optional): The gamma for calculating the modulating
+            factor. Defaults to 4.0.
+        pos_weight(float): Positive sample loss weight. Defaults to 1.0.
+        neg_weight(float): Negative sample loss weight. Defaults to 1.0.
+        reduction (str): Options are "none", "mean" and "sum".
+            Defaults to 'mean`.
+        avg_factor (int, float, optional): Average factor that is used to
+            average the loss. Defaults to None.
+    """
+    eps = 1e-12
+    neg_weights = (1 - gaussian_target).pow(gamma)
+
+    pos_pred_pix = pred[pos_inds]
+    pos_pred = pos_pred_pix.gather(1, pos_labels.unsqueeze(1))
+    pos_loss = -(pos_pred + eps).log() * (1 - pos_pred).pow(alpha)
+    pos_loss = weight_reduce_loss(pos_loss, None, reduction, avg_factor)
+
+    neg_loss = -(1 - pred + eps).log() * pred.pow(alpha) * neg_weights
+    neg_loss = weight_reduce_loss(neg_loss, None, reduction, avg_factor)
+
+    return pos_weight * pos_loss + neg_weight * neg_loss
+
+
+@MODELS.register_module()
+class GaussianFocalLoss(nn.Module):
+    """GaussianFocalLoss is a variant of focal loss.
+
+    More details can be found in the `paper
+    `_
+    Code is modified from `kp_utils.py
+    `_  # noqa: E501
+    Please notice that the target in GaussianFocalLoss is a gaussian heatmap,
+    not 0/1 binary target.
+
+    Args:
+        alpha (float): Power of prediction.
+        gamma (float): Power of target for negative samples.
+        reduction (str): Options are "none", "mean" and "sum".
+        loss_weight (float): Loss weight of current loss.
+        pos_weight(float): Positive sample loss weight. Defaults to 1.0.
+        neg_weight(float): Negative sample loss weight. Defaults to 1.0.
+    """
+
+    def __init__(self,
+                 alpha: float = 2.0,
+                 gamma: float = 4.0,
+                 reduction: str = 'mean',
+                 loss_weight: float = 1.0,
+                 pos_weight: float = 1.0,
+                 neg_weight: float = 1.0) -> None:
+        super().__init__()
+        self.alpha = alpha
+        self.gamma = gamma
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+        self.pos_weight = pos_weight
+        self.neg_weight = neg_weight
+
+    def forward(self,
+                pred: Tensor,
+                target: Tensor,
+                pos_inds: Optional[Tensor] = None,
+                pos_labels: Optional[Tensor] = None,
+                weight: Optional[Tensor] = None,
+                avg_factor: Optional[Union[int, float]] = None,
+                reduction_override: Optional[str] = None) -> Tensor:
+        """Forward function.
+
+        If you want to manually determine which positions are
+        positive samples, you can set the pos_index and pos_label
+        parameter. Currently, only the CenterNet update version uses
+        the parameter.
+
+        Args:
+            pred (torch.Tensor): The prediction. The shape is (N, num_classes).
+            target (torch.Tensor): The learning target of the prediction
+                in gaussian distribution. The shape is (N, num_classes).
+            pos_inds (torch.Tensor): The positive sample index.
+                Defaults to None.
+            pos_labels (torch.Tensor): The label corresponding to the positive
+                sample index. Defaults to None.
+            weight (torch.Tensor, optional): The weight of loss for each
+                prediction. Defaults to None.
+            avg_factor (int, float, optional): Average factor that is used to
+                average the loss. Defaults to None.
+            reduction_override (str, optional): The reduction method used to
+                override the original reduction method of the loss.
+                Defaults to None.
+        """
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        if pos_inds is not None:
+            assert pos_labels is not None
+            # Only used by centernet update version
+            loss_reg = self.loss_weight * gaussian_focal_loss_with_pos_inds(
+                pred,
+                target,
+                pos_inds,
+                pos_labels,
+                alpha=self.alpha,
+                gamma=self.gamma,
+                pos_weight=self.pos_weight,
+                neg_weight=self.neg_weight,
+                reduction=reduction,
+                avg_factor=avg_factor)
+        else:
+            loss_reg = self.loss_weight * gaussian_focal_loss(
+                pred,
+                target,
+                weight,
+                alpha=self.alpha,
+                gamma=self.gamma,
+                pos_weight=self.pos_weight,
+                neg_weight=self.neg_weight,
+                reduction=reduction,
+                avg_factor=avg_factor)
+        return loss_reg
diff --git a/mmdetection/mmdet/models/losses/gfocal_loss.py b/mmdetection/mmdet/models/losses/gfocal_loss.py
new file mode 100644
index 00000000..b3a11722
--- /dev/null
+++ b/mmdetection/mmdet/models/losses/gfocal_loss.py
@@ -0,0 +1,295 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from functools import partial
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from mmdet.models.losses.utils import weighted_loss
+from mmdet.registry import MODELS
+
+
+@weighted_loss
+def quality_focal_loss(pred, target, beta=2.0):
+    r"""Quality Focal Loss (QFL) is from `Generalized Focal Loss: Learning
+    Qualified and Distributed Bounding Boxes for Dense Object Detection
+    `_.
+
+    Args:
+        pred (torch.Tensor): Predicted joint representation of classification
+            and quality (IoU) estimation with shape (N, C), C is the number of
+            classes.
+        target (tuple([torch.Tensor])): Target category label with shape (N,)
+            and target quality label with shape (N,).
+        beta (float): The beta parameter for calculating the modulating factor.
+            Defaults to 2.0.
+
+    Returns:
+        torch.Tensor: Loss tensor with shape (N,).
+    """
+    assert len(target) == 2, """target for QFL must be a tuple of two elements,
+        including category label and quality label, respectively"""
+    # label denotes the category id, score denotes the quality score
+    label, score = target
+
+    # negatives are supervised by 0 quality score
+    pred_sigmoid = pred.sigmoid()
+    scale_factor = pred_sigmoid
+    zerolabel = scale_factor.new_zeros(pred.shape)
+    loss = F.binary_cross_entropy_with_logits(
+        pred, zerolabel, reduction='none') * scale_factor.pow(beta)
+
+    # FG cat_id: [0, num_classes -1], BG cat_id: num_classes
+    bg_class_ind = pred.size(1)
+    pos = ((label >= 0) & (label < bg_class_ind)).nonzero().squeeze(1)
+    pos_label = label[pos].long()
+    # positives are supervised by bbox quality (IoU) score
+    scale_factor = score[pos] - pred_sigmoid[pos, pos_label]
+    loss[pos, pos_label] = F.binary_cross_entropy_with_logits(
+        pred[pos, pos_label], score[pos],
+        reduction='none') * scale_factor.abs().pow(beta)
+
+    loss = loss.sum(dim=1, keepdim=False)
+    return loss
+
+
+@weighted_loss
+def quality_focal_loss_tensor_target(pred, target, beta=2.0, activated=False):
+    """`QualityFocal Loss `_
+    Args:
+        pred (torch.Tensor): The prediction with shape (N, C), C is the
+            number of classes
+        target (torch.Tensor): The learning target of the iou-aware
+            classification score with shape (N, C), C is the number of classes.
+        beta (float): The beta parameter for calculating the modulating factor.
+            Defaults to 2.0.
+        activated (bool): Whether the input is activated.
+            If True, it means the input has been activated and can be
+            treated as probabilities. Else, it should be treated as logits.
+            Defaults to False.
+    """
+    # pred and target should be of the same size
+    assert pred.size() == target.size()
+    if activated:
+        pred_sigmoid = pred
+        loss_function = F.binary_cross_entropy
+    else:
+        pred_sigmoid = pred.sigmoid()
+        loss_function = F.binary_cross_entropy_with_logits
+
+    scale_factor = pred_sigmoid
+    target = target.type_as(pred)
+
+    zerolabel = scale_factor.new_zeros(pred.shape)
+    loss = loss_function(
+        pred, zerolabel, reduction='none') * scale_factor.pow(beta)
+
+    pos = (target != 0)
+    scale_factor = target[pos] - pred_sigmoid[pos]
+    loss[pos] = loss_function(
+        pred[pos], target[pos],
+        reduction='none') * scale_factor.abs().pow(beta)
+
+    loss = loss.sum(dim=1, keepdim=False)
+    return loss
+
+
+@weighted_loss
+def quality_focal_loss_with_prob(pred, target, beta=2.0):
+    r"""Quality Focal Loss (QFL) is from `Generalized Focal Loss: Learning
+    Qualified and Distributed Bounding Boxes for Dense Object Detection
+    `_.
+    Different from `quality_focal_loss`, this function accepts probability
+    as input.
+
+    Args:
+        pred (torch.Tensor): Predicted joint representation of classification
+            and quality (IoU) estimation with shape (N, C), C is the number of
+            classes.
+        target (tuple([torch.Tensor])): Target category label with shape (N,)
+            and target quality label with shape (N,).
+        beta (float): The beta parameter for calculating the modulating factor.
+            Defaults to 2.0.
+
+    Returns:
+        torch.Tensor: Loss tensor with shape (N,).
+    """
+    assert len(target) == 2, """target for QFL must be a tuple of two elements,
+        including category label and quality label, respectively"""
+    # label denotes the category id, score denotes the quality score
+    label, score = target
+
+    # negatives are supervised by 0 quality score
+    pred_sigmoid = pred
+    scale_factor = pred_sigmoid
+    zerolabel = scale_factor.new_zeros(pred.shape)
+    loss = F.binary_cross_entropy(
+        pred, zerolabel, reduction='none') * scale_factor.pow(beta)
+
+    # FG cat_id: [0, num_classes -1], BG cat_id: num_classes
+    bg_class_ind = pred.size(1)
+    pos = ((label >= 0) & (label < bg_class_ind)).nonzero().squeeze(1)
+    pos_label = label[pos].long()
+    # positives are supervised by bbox quality (IoU) score
+    scale_factor = score[pos] - pred_sigmoid[pos, pos_label]
+    loss[pos, pos_label] = F.binary_cross_entropy(
+        pred[pos, pos_label], score[pos],
+        reduction='none') * scale_factor.abs().pow(beta)
+
+    loss = loss.sum(dim=1, keepdim=False)
+    return loss
+
+
+@weighted_loss
+def distribution_focal_loss(pred, label):
+    r"""Distribution Focal Loss (DFL) is from `Generalized Focal Loss: Learning
+    Qualified and Distributed Bounding Boxes for Dense Object Detection
+    `_.
+
+    Args:
+        pred (torch.Tensor): Predicted general distribution of bounding boxes
+            (before softmax) with shape (N, n+1), n is the max value of the
+            integral set `{0, ..., n}` in paper.
+        label (torch.Tensor): Target distance label for bounding boxes with
+            shape (N,).
+
+    Returns:
+        torch.Tensor: Loss tensor with shape (N,).
+    """
+    dis_left = label.long()
+    dis_right = dis_left + 1
+    weight_left = dis_right.float() - label
+    weight_right = label - dis_left.float()
+    loss = F.cross_entropy(pred, dis_left, reduction='none') * weight_left \
+        + F.cross_entropy(pred, dis_right, reduction='none') * weight_right
+    return loss
+
+
+@MODELS.register_module()
+class QualityFocalLoss(nn.Module):
+    r"""Quality Focal Loss (QFL) is a variant of `Generalized Focal Loss:
+    Learning Qualified and Distributed Bounding Boxes for Dense Object
+    Detection `_.
+
+    Args:
+        use_sigmoid (bool): Whether sigmoid operation is conducted in QFL.
+            Defaults to True.
+        beta (float): The beta parameter for calculating the modulating factor.
+            Defaults to 2.0.
+        reduction (str): Options are "none", "mean" and "sum".
+        loss_weight (float): Loss weight of current loss.
+        activated (bool, optional): Whether the input is activated.
+            If True, it means the input has been activated and can be
+            treated as probabilities. Else, it should be treated as logits.
+            Defaults to False.
+    """
+
+    def __init__(self,
+                 use_sigmoid=True,
+                 beta=2.0,
+                 reduction='mean',
+                 loss_weight=1.0,
+                 activated=False):
+        super(QualityFocalLoss, self).__init__()
+        assert use_sigmoid is True, 'Only sigmoid in QFL supported now.'
+        self.use_sigmoid = use_sigmoid
+        self.beta = beta
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+        self.activated = activated
+
+    def forward(self,
+                pred,
+                target,
+                weight=None,
+                avg_factor=None,
+                reduction_override=None):
+        """Forward function.
+
+        Args:
+            pred (torch.Tensor): Predicted joint representation of
+                classification and quality (IoU) estimation with shape (N, C),
+                C is the number of classes.
+            target (Union(tuple([torch.Tensor]),Torch.Tensor)): The type is
+                tuple, it should be included Target category label with
+                shape (N,) and target quality label with shape (N,).The type
+                is torch.Tensor, the target should be one-hot form with
+                soft weights.
+            weight (torch.Tensor, optional): The weight of loss for each
+                prediction. Defaults to None.
+            avg_factor (int, optional): Average factor that is used to average
+                the loss. Defaults to None.
+            reduction_override (str, optional): The reduction method used to
+                override the original reduction method of the loss.
+                Defaults to None.
+        """
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        if self.use_sigmoid:
+            if self.activated:
+                calculate_loss_func = quality_focal_loss_with_prob
+            else:
+                calculate_loss_func = quality_focal_loss
+            if isinstance(target, torch.Tensor):
+                # the target shape with (N,C) or (N,C,...), which means
+                # the target is one-hot form with soft weights.
+                calculate_loss_func = partial(
+                    quality_focal_loss_tensor_target, activated=self.activated)
+
+            loss_cls = self.loss_weight * calculate_loss_func(
+                pred,
+                target,
+                weight,
+                beta=self.beta,
+                reduction=reduction,
+                avg_factor=avg_factor)
+        else:
+            raise NotImplementedError
+        return loss_cls
+
+
+@MODELS.register_module()
+class DistributionFocalLoss(nn.Module):
+    r"""Distribution Focal Loss (DFL) is a variant of `Generalized Focal Loss:
+    Learning Qualified and Distributed Bounding Boxes for Dense Object
+    Detection `_.
+
+    Args:
+        reduction (str): Options are `'none'`, `'mean'` and `'sum'`.
+        loss_weight (float): Loss weight of current loss.
+    """
+
+    def __init__(self, reduction='mean', loss_weight=1.0):
+        super(DistributionFocalLoss, self).__init__()
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+
+    def forward(self,
+                pred,
+                target,
+                weight=None,
+                avg_factor=None,
+                reduction_override=None):
+        """Forward function.
+
+        Args:
+            pred (torch.Tensor): Predicted general distribution of bounding
+                boxes (before softmax) with shape (N, n+1), n is the max value
+                of the integral set `{0, ..., n}` in paper.
+            target (torch.Tensor): Target distance label for bounding boxes
+                with shape (N,).
+            weight (torch.Tensor, optional): The weight of loss for each
+                prediction. Defaults to None.
+            avg_factor (int, optional): Average factor that is used to average
+                the loss. Defaults to None.
+            reduction_override (str, optional): The reduction method used to
+                override the original reduction method of the loss.
+                Defaults to None.
+        """
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        loss_cls = self.loss_weight * distribution_focal_loss(
+            pred, target, weight, reduction=reduction, avg_factor=avg_factor)
+        return loss_cls
diff --git a/mmdetection/mmdet/models/losses/ghm_loss.py b/mmdetection/mmdet/models/losses/ghm_loss.py
new file mode 100644
index 00000000..a874c003
--- /dev/null
+++ b/mmdetection/mmdet/models/losses/ghm_loss.py
@@ -0,0 +1,213 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from mmdet.registry import MODELS
+from .utils import weight_reduce_loss
+
+
+def _expand_onehot_labels(labels, label_weights, label_channels):
+    bin_labels = labels.new_full((labels.size(0), label_channels), 0)
+    inds = torch.nonzero(
+        (labels >= 0) & (labels < label_channels), as_tuple=False).squeeze()
+    if inds.numel() > 0:
+        bin_labels[inds, labels[inds]] = 1
+    bin_label_weights = label_weights.view(-1, 1).expand(
+        label_weights.size(0), label_channels)
+    return bin_labels, bin_label_weights
+
+
+# TODO: code refactoring to make it consistent with other losses
+@MODELS.register_module()
+class GHMC(nn.Module):
+    """GHM Classification Loss.
+
+    Details of the theorem can be viewed in the paper
+    `Gradient Harmonized Single-stage Detector
+    `_.
+
+    Args:
+        bins (int): Number of the unit regions for distribution calculation.
+        momentum (float): The parameter for moving average.
+        use_sigmoid (bool): Can only be true for BCE based loss now.
+        loss_weight (float): The weight of the total GHM-C loss.
+        reduction (str): Options are "none", "mean" and "sum".
+            Defaults to "mean"
+    """
+
+    def __init__(self,
+                 bins=10,
+                 momentum=0,
+                 use_sigmoid=True,
+                 loss_weight=1.0,
+                 reduction='mean'):
+        super(GHMC, self).__init__()
+        self.bins = bins
+        self.momentum = momentum
+        edges = torch.arange(bins + 1).float() / bins
+        self.register_buffer('edges', edges)
+        self.edges[-1] += 1e-6
+        if momentum > 0:
+            acc_sum = torch.zeros(bins)
+            self.register_buffer('acc_sum', acc_sum)
+        self.use_sigmoid = use_sigmoid
+        if not self.use_sigmoid:
+            raise NotImplementedError
+        self.loss_weight = loss_weight
+        self.reduction = reduction
+
+    def forward(self,
+                pred,
+                target,
+                label_weight,
+                reduction_override=None,
+                **kwargs):
+        """Calculate the GHM-C loss.
+
+        Args:
+            pred (float tensor of size [batch_num, class_num]):
+                The direct prediction of classification fc layer.
+            target (float tensor of size [batch_num, class_num]):
+                Binary class target for each sample.
+            label_weight (float tensor of size [batch_num, class_num]):
+                the value is 1 if the sample is valid and 0 if ignored.
+            reduction_override (str, optional): The reduction method used to
+                override the original reduction method of the loss.
+                Defaults to None.
+        Returns:
+            The gradient harmonized loss.
+        """
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        # the target should be binary class label
+        if pred.dim() != target.dim():
+            target, label_weight = _expand_onehot_labels(
+                target, label_weight, pred.size(-1))
+        target, label_weight = target.float(), label_weight.float()
+        edges = self.edges
+        mmt = self.momentum
+        weights = torch.zeros_like(pred)
+
+        # gradient length
+        g = torch.abs(pred.sigmoid().detach() - target)
+
+        valid = label_weight > 0
+        tot = max(valid.float().sum().item(), 1.0)
+        n = 0  # n valid bins
+        for i in range(self.bins):
+            inds = (g >= edges[i]) & (g < edges[i + 1]) & valid
+            num_in_bin = inds.sum().item()
+            if num_in_bin > 0:
+                if mmt > 0:
+                    self.acc_sum[i] = mmt * self.acc_sum[i] \
+                        + (1 - mmt) * num_in_bin
+                    weights[inds] = tot / self.acc_sum[i]
+                else:
+                    weights[inds] = tot / num_in_bin
+                n += 1
+        if n > 0:
+            weights = weights / n
+
+        loss = F.binary_cross_entropy_with_logits(
+            pred, target, reduction='none')
+        loss = weight_reduce_loss(
+            loss, weights, reduction=reduction, avg_factor=tot)
+        return loss * self.loss_weight
+
+
+# TODO: code refactoring to make it consistent with other losses
+@MODELS.register_module()
+class GHMR(nn.Module):
+    """GHM Regression Loss.
+
+    Details of the theorem can be viewed in the paper
+    `Gradient Harmonized Single-stage Detector
+    `_.
+
+    Args:
+        mu (float): The parameter for the Authentic Smooth L1 loss.
+        bins (int): Number of the unit regions for distribution calculation.
+        momentum (float): The parameter for moving average.
+        loss_weight (float): The weight of the total GHM-R loss.
+        reduction (str): Options are "none", "mean" and "sum".
+            Defaults to "mean"
+    """
+
+    def __init__(self,
+                 mu=0.02,
+                 bins=10,
+                 momentum=0,
+                 loss_weight=1.0,
+                 reduction='mean'):
+        super(GHMR, self).__init__()
+        self.mu = mu
+        self.bins = bins
+        edges = torch.arange(bins + 1).float() / bins
+        self.register_buffer('edges', edges)
+        self.edges[-1] = 1e3
+        self.momentum = momentum
+        if momentum > 0:
+            acc_sum = torch.zeros(bins)
+            self.register_buffer('acc_sum', acc_sum)
+        self.loss_weight = loss_weight
+        self.reduction = reduction
+
+    # TODO: support reduction parameter
+    def forward(self,
+                pred,
+                target,
+                label_weight,
+                avg_factor=None,
+                reduction_override=None):
+        """Calculate the GHM-R loss.
+
+        Args:
+            pred (float tensor of size [batch_num, 4 (* class_num)]):
+                The prediction of box regression layer. Channel number can be 4
+                or 4 * class_num depending on whether it is class-agnostic.
+            target (float tensor of size [batch_num, 4 (* class_num)]):
+                The target regression values with the same size of pred.
+            label_weight (float tensor of size [batch_num, 4 (* class_num)]):
+                The weight of each sample, 0 if ignored.
+            reduction_override (str, optional): The reduction method used to
+                override the original reduction method of the loss.
+                Defaults to None.
+        Returns:
+            The gradient harmonized loss.
+        """
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        mu = self.mu
+        edges = self.edges
+        mmt = self.momentum
+
+        # ASL1 loss
+        diff = pred - target
+        loss = torch.sqrt(diff * diff + mu * mu) - mu
+
+        # gradient length
+        g = torch.abs(diff / torch.sqrt(mu * mu + diff * diff)).detach()
+        weights = torch.zeros_like(g)
+
+        valid = label_weight > 0
+        tot = max(label_weight.float().sum().item(), 1.0)
+        n = 0  # n: valid bins
+        for i in range(self.bins):
+            inds = (g >= edges[i]) & (g < edges[i + 1]) & valid
+            num_in_bin = inds.sum().item()
+            if num_in_bin > 0:
+                n += 1
+                if mmt > 0:
+                    self.acc_sum[i] = mmt * self.acc_sum[i] \
+                        + (1 - mmt) * num_in_bin
+                    weights[inds] = tot / self.acc_sum[i]
+                else:
+                    weights[inds] = tot / num_in_bin
+        if n > 0:
+            weights /= n
+        loss = weight_reduce_loss(
+            loss, weights, reduction=reduction, avg_factor=tot)
+        return loss * self.loss_weight
diff --git a/mmdetection/mmdet/models/losses/iou_loss.py b/mmdetection/mmdet/models/losses/iou_loss.py
new file mode 100644
index 00000000..c8a2b977
--- /dev/null
+++ b/mmdetection/mmdet/models/losses/iou_loss.py
@@ -0,0 +1,926 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+import warnings
+from typing import Optional
+
+import torch
+import torch.nn as nn
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures.bbox import bbox_overlaps
+from .utils import weighted_loss
+
+
+@weighted_loss
+def iou_loss(pred: Tensor,
+             target: Tensor,
+             linear: bool = False,
+             mode: str = 'log',
+             eps: float = 1e-6) -> Tensor:
+    """IoU loss.
+
+    Computing the IoU loss between a set of predicted bboxes and target bboxes.
+    The loss is calculated as negative log of IoU.
+
+    Args:
+        pred (Tensor): Predicted bboxes of format (x1, y1, x2, y2),
+            shape (n, 4).
+        target (Tensor): Corresponding gt bboxes, shape (n, 4).
+        linear (bool, optional): If True, use linear scale of loss instead of
+            log scale. Default: False.
+        mode (str): Loss scaling mode, including "linear", "square", and "log".
+            Default: 'log'
+        eps (float): Epsilon to avoid log(0).
+
+    Return:
+        Tensor: Loss tensor.
+    """
+    assert mode in ['linear', 'square', 'log']
+    if linear:
+        mode = 'linear'
+        warnings.warn('DeprecationWarning: Setting "linear=True" in '
+                      'iou_loss is deprecated, please use "mode=`linear`" '
+                      'instead.')
+    # avoid fp16 overflow
+    if pred.dtype == torch.float16:
+        fp16 = True
+        pred = pred.to(torch.float32)
+    else:
+        fp16 = False
+
+    ious = bbox_overlaps(pred, target, is_aligned=True).clamp(min=eps)
+
+    if fp16:
+        ious = ious.to(torch.float16)
+
+    if mode == 'linear':
+        loss = 1 - ious
+    elif mode == 'square':
+        loss = 1 - ious**2
+    elif mode == 'log':
+        loss = -ious.log()
+    else:
+        raise NotImplementedError
+    return loss
+
+
+@weighted_loss
+def bounded_iou_loss(pred: Tensor,
+                     target: Tensor,
+                     beta: float = 0.2,
+                     eps: float = 1e-3) -> Tensor:
+    """BIoULoss.
+
+    This is an implementation of paper
+    `Improving Object Localization with Fitness NMS and Bounded IoU Loss.
+    `_.
+
+    Args:
+        pred (Tensor): Predicted bboxes of format (x1, y1, x2, y2),
+            shape (n, 4).
+        target (Tensor): Corresponding gt bboxes, shape (n, 4).
+        beta (float, optional): Beta parameter in smoothl1.
+        eps (float, optional): Epsilon to avoid NaN values.
+
+    Return:
+        Tensor: Loss tensor.
+    """
+    pred_ctrx = (pred[:, 0] + pred[:, 2]) * 0.5
+    pred_ctry = (pred[:, 1] + pred[:, 3]) * 0.5
+    pred_w = pred[:, 2] - pred[:, 0]
+    pred_h = pred[:, 3] - pred[:, 1]
+    with torch.no_grad():
+        target_ctrx = (target[:, 0] + target[:, 2]) * 0.5
+        target_ctry = (target[:, 1] + target[:, 3]) * 0.5
+        target_w = target[:, 2] - target[:, 0]
+        target_h = target[:, 3] - target[:, 1]
+
+    dx = target_ctrx - pred_ctrx
+    dy = target_ctry - pred_ctry
+
+    loss_dx = 1 - torch.max(
+        (target_w - 2 * dx.abs()) /
+        (target_w + 2 * dx.abs() + eps), torch.zeros_like(dx))
+    loss_dy = 1 - torch.max(
+        (target_h - 2 * dy.abs()) /
+        (target_h + 2 * dy.abs() + eps), torch.zeros_like(dy))
+    loss_dw = 1 - torch.min(target_w / (pred_w + eps), pred_w /
+                            (target_w + eps))
+    loss_dh = 1 - torch.min(target_h / (pred_h + eps), pred_h /
+                            (target_h + eps))
+    # view(..., -1) does not work for empty tensor
+    loss_comb = torch.stack([loss_dx, loss_dy, loss_dw, loss_dh],
+                            dim=-1).flatten(1)
+
+    loss = torch.where(loss_comb < beta, 0.5 * loss_comb * loss_comb / beta,
+                       loss_comb - 0.5 * beta)
+    return loss
+
+
+@weighted_loss
+def giou_loss(pred: Tensor, target: Tensor, eps: float = 1e-7) -> Tensor:
+    r"""`Generalized Intersection over Union: A Metric and A Loss for Bounding
+    Box Regression `_.
+
+    Args:
+        pred (Tensor): Predicted bboxes of format (x1, y1, x2, y2),
+            shape (n, 4).
+        target (Tensor): Corresponding gt bboxes, shape (n, 4).
+        eps (float): Epsilon to avoid log(0).
+
+    Return:
+        Tensor: Loss tensor.
+    """
+    # avoid fp16 overflow
+    if pred.dtype == torch.float16:
+        fp16 = True
+        pred = pred.to(torch.float32)
+    else:
+        fp16 = False
+
+    gious = bbox_overlaps(pred, target, mode='giou', is_aligned=True, eps=eps)
+
+    if fp16:
+        gious = gious.to(torch.float16)
+
+    loss = 1 - gious
+    return loss
+
+
+@weighted_loss
+def diou_loss(pred: Tensor, target: Tensor, eps: float = 1e-7) -> Tensor:
+    r"""Implementation of `Distance-IoU Loss: Faster and Better
+    Learning for Bounding Box Regression https://arxiv.org/abs/1911.08287`_.
+
+    Code is modified from https://github.com/Zzh-tju/DIoU.
+
+    Args:
+        pred (Tensor): Predicted bboxes of format (x1, y1, x2, y2),
+            shape (n, 4).
+        target (Tensor): Corresponding gt bboxes, shape (n, 4).
+        eps (float): Epsilon to avoid log(0).
+
+    Return:
+        Tensor: Loss tensor.
+    """
+    # overlap
+    lt = torch.max(pred[:, :2], target[:, :2])
+    rb = torch.min(pred[:, 2:], target[:, 2:])
+    wh = (rb - lt).clamp(min=0)
+    overlap = wh[:, 0] * wh[:, 1]
+
+    # union
+    ap = (pred[:, 2] - pred[:, 0]) * (pred[:, 3] - pred[:, 1])
+    ag = (target[:, 2] - target[:, 0]) * (target[:, 3] - target[:, 1])
+    union = ap + ag - overlap + eps
+
+    # IoU
+    ious = overlap / union
+
+    # enclose area
+    enclose_x1y1 = torch.min(pred[:, :2], target[:, :2])
+    enclose_x2y2 = torch.max(pred[:, 2:], target[:, 2:])
+    enclose_wh = (enclose_x2y2 - enclose_x1y1).clamp(min=0)
+
+    cw = enclose_wh[:, 0]
+    ch = enclose_wh[:, 1]
+
+    c2 = cw**2 + ch**2 + eps
+
+    b1_x1, b1_y1 = pred[:, 0], pred[:, 1]
+    b1_x2, b1_y2 = pred[:, 2], pred[:, 3]
+    b2_x1, b2_y1 = target[:, 0], target[:, 1]
+    b2_x2, b2_y2 = target[:, 2], target[:, 3]
+
+    left = ((b2_x1 + b2_x2) - (b1_x1 + b1_x2))**2 / 4
+    right = ((b2_y1 + b2_y2) - (b1_y1 + b1_y2))**2 / 4
+    rho2 = left + right
+
+    # DIoU
+    dious = ious - rho2 / c2
+    loss = 1 - dious
+    return loss
+
+
+@weighted_loss
+def ciou_loss(pred: Tensor, target: Tensor, eps: float = 1e-7) -> Tensor:
+    r"""`Implementation of paper `Enhancing Geometric Factors into
+    Model Learning and Inference for Object Detection and Instance
+    Segmentation `_.
+
+    Code is modified from https://github.com/Zzh-tju/CIoU.
+
+    Args:
+        pred (Tensor): Predicted bboxes of format (x1, y1, x2, y2),
+            shape (n, 4).
+        target (Tensor): Corresponding gt bboxes, shape (n, 4).
+        eps (float): Epsilon to avoid log(0).
+
+    Return:
+        Tensor: Loss tensor.
+    """
+    # overlap
+    lt = torch.max(pred[:, :2], target[:, :2])
+    rb = torch.min(pred[:, 2:], target[:, 2:])
+    wh = (rb - lt).clamp(min=0)
+    overlap = wh[:, 0] * wh[:, 1]
+
+    # union
+    ap = (pred[:, 2] - pred[:, 0]) * (pred[:, 3] - pred[:, 1])
+    ag = (target[:, 2] - target[:, 0]) * (target[:, 3] - target[:, 1])
+    union = ap + ag - overlap + eps
+
+    # IoU
+    ious = overlap / union
+
+    # enclose area
+    enclose_x1y1 = torch.min(pred[:, :2], target[:, :2])
+    enclose_x2y2 = torch.max(pred[:, 2:], target[:, 2:])
+    enclose_wh = (enclose_x2y2 - enclose_x1y1).clamp(min=0)
+
+    cw = enclose_wh[:, 0]
+    ch = enclose_wh[:, 1]
+
+    c2 = cw**2 + ch**2 + eps
+
+    b1_x1, b1_y1 = pred[:, 0], pred[:, 1]
+    b1_x2, b1_y2 = pred[:, 2], pred[:, 3]
+    b2_x1, b2_y1 = target[:, 0], target[:, 1]
+    b2_x2, b2_y2 = target[:, 2], target[:, 3]
+
+    w1, h1 = b1_x2 - b1_x1, b1_y2 - b1_y1 + eps
+    w2, h2 = b2_x2 - b2_x1, b2_y2 - b2_y1 + eps
+
+    left = ((b2_x1 + b2_x2) - (b1_x1 + b1_x2))**2 / 4
+    right = ((b2_y1 + b2_y2) - (b1_y1 + b1_y2))**2 / 4
+    rho2 = left + right
+
+    factor = 4 / math.pi**2
+    v = factor * torch.pow(torch.atan(w2 / h2) - torch.atan(w1 / h1), 2)
+
+    with torch.no_grad():
+        alpha = (ious > 0.5).float() * v / (1 - ious + v)
+
+    # CIoU
+    cious = ious - (rho2 / c2 + alpha * v)
+    loss = 1 - cious.clamp(min=-1.0, max=1.0)
+    return loss
+
+
+@weighted_loss
+def eiou_loss(pred: Tensor,
+              target: Tensor,
+              smooth_point: float = 0.1,
+              eps: float = 1e-7) -> Tensor:
+    r"""Implementation of paper `Extended-IoU Loss: A Systematic
+    IoU-Related Method: Beyond Simplified Regression for Better
+    Localization `_
+
+    Code is modified from https://github.com//ShiqiYu/libfacedetection.train.
+
+    Args:
+        pred (Tensor): Predicted bboxes of format (x1, y1, x2, y2),
+            shape (n, 4).
+        target (Tensor): Corresponding gt bboxes, shape (n, 4).
+        smooth_point (float): hyperparameter, default is 0.1.
+        eps (float): Epsilon to avoid log(0).
+
+    Return:
+        Tensor: Loss tensor.
+    """
+    px1, py1, px2, py2 = pred[:, 0], pred[:, 1], pred[:, 2], pred[:, 3]
+    tx1, ty1, tx2, ty2 = target[:, 0], target[:, 1], target[:, 2], target[:, 3]
+
+    # extent top left
+    ex1 = torch.min(px1, tx1)
+    ey1 = torch.min(py1, ty1)
+
+    # intersection coordinates
+    ix1 = torch.max(px1, tx1)
+    iy1 = torch.max(py1, ty1)
+    ix2 = torch.min(px2, tx2)
+    iy2 = torch.min(py2, ty2)
+
+    # extra
+    xmin = torch.min(ix1, ix2)
+    ymin = torch.min(iy1, iy2)
+    xmax = torch.max(ix1, ix2)
+    ymax = torch.max(iy1, iy2)
+
+    # Intersection
+    intersection = (ix2 - ex1) * (iy2 - ey1) + (xmin - ex1) * (ymin - ey1) - (
+        ix1 - ex1) * (ymax - ey1) - (xmax - ex1) * (
+            iy1 - ey1)
+    # Union
+    union = (px2 - px1) * (py2 - py1) + (tx2 - tx1) * (
+        ty2 - ty1) - intersection + eps
+    # IoU
+    ious = 1 - (intersection / union)
+
+    # Smooth-EIoU
+    smooth_sign = (ious < smooth_point).detach().float()
+    loss = 0.5 * smooth_sign * (ious**2) / smooth_point + (1 - smooth_sign) * (
+        ious - 0.5 * smooth_point)
+    return loss
+
+
+@weighted_loss
+def siou_loss(pred, target, eps=1e-7, neg_gamma=False):
+    r"""`Implementation of paper `SIoU Loss: More Powerful Learning
+    for Bounding Box Regression `_.
+
+    Code is modified from https://github.com/meituan/YOLOv6.
+
+    Args:
+        pred (Tensor): Predicted bboxes of format (x1, y1, x2, y2),
+            shape (n, 4).
+        target (Tensor): Corresponding gt bboxes, shape (n, 4).
+        eps (float): Eps to avoid log(0).
+        neg_gamma (bool): `True` follows original implementation in paper.
+
+    Return:
+        Tensor: Loss tensor.
+    """
+    # overlap
+    lt = torch.max(pred[:, :2], target[:, :2])
+    rb = torch.min(pred[:, 2:], target[:, 2:])
+    wh = (rb - lt).clamp(min=0)
+    overlap = wh[:, 0] * wh[:, 1]
+
+    # union
+    ap = (pred[:, 2] - pred[:, 0]) * (pred[:, 3] - pred[:, 1])
+    ag = (target[:, 2] - target[:, 0]) * (target[:, 3] - target[:, 1])
+    union = ap + ag - overlap + eps
+
+    # IoU
+    ious = overlap / union
+
+    # enclose area
+    enclose_x1y1 = torch.min(pred[:, :2], target[:, :2])
+    enclose_x2y2 = torch.max(pred[:, 2:], target[:, 2:])
+    # modified clamp threshold zero to eps to avoid NaN
+    enclose_wh = (enclose_x2y2 - enclose_x1y1).clamp(min=eps)
+
+    cw = enclose_wh[:, 0]
+    ch = enclose_wh[:, 1]
+
+    b1_x1, b1_y1 = pred[:, 0], pred[:, 1]
+    b1_x2, b1_y2 = pred[:, 2], pred[:, 3]
+    b2_x1, b2_y1 = target[:, 0], target[:, 1]
+    b2_x2, b2_y2 = target[:, 2], target[:, 3]
+
+    w1, h1 = b1_x2 - b1_x1, b1_y2 - b1_y1 + eps
+    w2, h2 = b2_x2 - b2_x1, b2_y2 - b2_y1 + eps
+
+    # angle cost
+    s_cw = (b2_x1 + b2_x2 - b1_x1 - b1_x2) * 0.5 + eps
+    s_ch = (b2_y1 + b2_y2 - b1_y1 - b1_y2) * 0.5 + eps
+
+    sigma = torch.pow(s_cw**2 + s_ch**2, 0.5)
+
+    sin_alpha_1 = torch.abs(s_cw) / sigma
+    sin_alpha_2 = torch.abs(s_ch) / sigma
+    threshold = pow(2, 0.5) / 2
+    sin_alpha = torch.where(sin_alpha_1 > threshold, sin_alpha_2, sin_alpha_1)
+    angle_cost = torch.cos(torch.asin(sin_alpha) * 2 - math.pi / 2)
+
+    # distance cost
+    rho_x = (s_cw / cw)**2
+    rho_y = (s_ch / ch)**2
+
+    # `neg_gamma=True` follows original implementation in paper
+    # but setting `neg_gamma=False` makes training more stable.
+    gamma = angle_cost - 2 if neg_gamma else 2 - angle_cost
+    distance_cost = 2 - torch.exp(gamma * rho_x) - torch.exp(gamma * rho_y)
+
+    # shape cost
+    omiga_w = torch.abs(w1 - w2) / torch.max(w1, w2)
+    omiga_h = torch.abs(h1 - h2) / torch.max(h1, h2)
+    shape_cost = torch.pow(1 - torch.exp(-1 * omiga_w), 4) + torch.pow(
+        1 - torch.exp(-1 * omiga_h), 4)
+
+    # SIoU
+    sious = ious - 0.5 * (distance_cost + shape_cost)
+    loss = 1 - sious.clamp(min=-1.0, max=1.0)
+    return loss
+
+
+@MODELS.register_module()
+class IoULoss(nn.Module):
+    """IoULoss.
+
+    Computing the IoU loss between a set of predicted bboxes and target bboxes.
+
+    Args:
+        linear (bool): If True, use linear scale of loss else determined
+            by mode. Default: False.
+        eps (float): Epsilon to avoid log(0).
+        reduction (str): Options are "none", "mean" and "sum".
+        loss_weight (float): Weight of loss.
+        mode (str): Loss scaling mode, including "linear", "square", and "log".
+            Default: 'log'
+    """
+
+    def __init__(self,
+                 linear: bool = False,
+                 eps: float = 1e-6,
+                 reduction: str = 'mean',
+                 loss_weight: float = 1.0,
+                 mode: str = 'log') -> None:
+        super().__init__()
+        assert mode in ['linear', 'square', 'log']
+        if linear:
+            mode = 'linear'
+            warnings.warn('DeprecationWarning: Setting "linear=True" in '
+                          'IOULoss is deprecated, please use "mode=`linear`" '
+                          'instead.')
+        self.mode = mode
+        self.linear = linear
+        self.eps = eps
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+
+    def forward(self,
+                pred: Tensor,
+                target: Tensor,
+                weight: Optional[Tensor] = None,
+                avg_factor: Optional[int] = None,
+                reduction_override: Optional[str] = None,
+                **kwargs) -> Tensor:
+        """Forward function.
+
+        Args:
+            pred (Tensor): Predicted bboxes of format (x1, y1, x2, y2),
+                shape (n, 4).
+            target (Tensor): The learning target of the prediction,
+                shape (n, 4).
+            weight (Tensor, optional): The weight of loss for each
+                prediction. Defaults to None.
+            avg_factor (int, optional): Average factor that is used to average
+                the loss. Defaults to None.
+            reduction_override (str, optional): The reduction method used to
+                override the original reduction method of the loss.
+                Defaults to None. Options are "none", "mean" and "sum".
+
+        Return:
+            Tensor: Loss tensor.
+        """
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        if (weight is not None) and (not torch.any(weight > 0)) and (
+                reduction != 'none'):
+            if pred.dim() == weight.dim() + 1:
+                weight = weight.unsqueeze(1)
+            return (pred * weight).sum()  # 0
+        if weight is not None and weight.dim() > 1:
+            # TODO: remove this in the future
+            # reduce the weight of shape (n, 4) to (n,) to match the
+            # iou_loss of shape (n,)
+            assert weight.shape == pred.shape
+            weight = weight.mean(-1)
+        loss = self.loss_weight * iou_loss(
+            pred,
+            target,
+            weight,
+            mode=self.mode,
+            eps=self.eps,
+            reduction=reduction,
+            avg_factor=avg_factor,
+            **kwargs)
+        return loss
+
+
+@MODELS.register_module()
+class BoundedIoULoss(nn.Module):
+    """BIoULoss.
+
+    This is an implementation of paper
+    `Improving Object Localization with Fitness NMS and Bounded IoU Loss.
+    `_.
+
+    Args:
+        beta (float, optional): Beta parameter in smoothl1.
+        eps (float, optional): Epsilon to avoid NaN values.
+        reduction (str): Options are "none", "mean" and "sum".
+        loss_weight (float): Weight of loss.
+    """
+
+    def __init__(self,
+                 beta: float = 0.2,
+                 eps: float = 1e-3,
+                 reduction: str = 'mean',
+                 loss_weight: float = 1.0) -> None:
+        super().__init__()
+        self.beta = beta
+        self.eps = eps
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+
+    def forward(self,
+                pred: Tensor,
+                target: Tensor,
+                weight: Optional[Tensor] = None,
+                avg_factor: Optional[int] = None,
+                reduction_override: Optional[str] = None,
+                **kwargs) -> Tensor:
+        """Forward function.
+
+        Args:
+            pred (Tensor): Predicted bboxes of format (x1, y1, x2, y2),
+                shape (n, 4).
+            target (Tensor): The learning target of the prediction,
+                shape (n, 4).
+            weight (Optional[Tensor], optional): The weight of loss for each
+                prediction. Defaults to None.
+            avg_factor (Optional[int], optional): Average factor that is used
+                to average the loss. Defaults to None.
+            reduction_override (Optional[str], optional): The reduction method
+                used to override the original reduction method of the loss.
+                Defaults to None. Options are "none", "mean" and "sum".
+
+        Returns:
+            Tensor: Loss tensor.
+        """
+        if weight is not None and not torch.any(weight > 0):
+            if pred.dim() == weight.dim() + 1:
+                weight = weight.unsqueeze(1)
+            return (pred * weight).sum()  # 0
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        loss = self.loss_weight * bounded_iou_loss(
+            pred,
+            target,
+            weight,
+            beta=self.beta,
+            eps=self.eps,
+            reduction=reduction,
+            avg_factor=avg_factor,
+            **kwargs)
+        return loss
+
+
+@MODELS.register_module()
+class GIoULoss(nn.Module):
+    r"""`Generalized Intersection over Union: A Metric and A Loss for Bounding
+    Box Regression `_.
+
+    Args:
+        eps (float): Epsilon to avoid log(0).
+        reduction (str): Options are "none", "mean" and "sum".
+        loss_weight (float): Weight of loss.
+    """
+
+    def __init__(self,
+                 eps: float = 1e-6,
+                 reduction: str = 'mean',
+                 loss_weight: float = 1.0) -> None:
+        super().__init__()
+        self.eps = eps
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+
+    def forward(self,
+                pred: Tensor,
+                target: Tensor,
+                weight: Optional[Tensor] = None,
+                avg_factor: Optional[int] = None,
+                reduction_override: Optional[str] = None,
+                **kwargs) -> Tensor:
+        """Forward function.
+
+        Args:
+            pred (Tensor): Predicted bboxes of format (x1, y1, x2, y2),
+                shape (n, 4).
+            target (Tensor): The learning target of the prediction,
+                shape (n, 4).
+            weight (Optional[Tensor], optional): The weight of loss for each
+                prediction. Defaults to None.
+            avg_factor (Optional[int], optional): Average factor that is used
+                to average the loss. Defaults to None.
+            reduction_override (Optional[str], optional): The reduction method
+                used to override the original reduction method of the loss.
+                Defaults to None. Options are "none", "mean" and "sum".
+
+        Returns:
+            Tensor: Loss tensor.
+        """
+        if weight is not None and not torch.any(weight > 0):
+            if pred.dim() == weight.dim() + 1:
+                weight = weight.unsqueeze(1)
+            return (pred * weight).sum()  # 0
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        if weight is not None and weight.dim() > 1:
+            # TODO: remove this in the future
+            # reduce the weight of shape (n, 4) to (n,) to match the
+            # giou_loss of shape (n,)
+            assert weight.shape == pred.shape
+            weight = weight.mean(-1)
+        loss = self.loss_weight * giou_loss(
+            pred,
+            target,
+            weight,
+            eps=self.eps,
+            reduction=reduction,
+            avg_factor=avg_factor,
+            **kwargs)
+        return loss
+
+
+@MODELS.register_module()
+class DIoULoss(nn.Module):
+    r"""Implementation of `Distance-IoU Loss: Faster and Better
+    Learning for Bounding Box Regression https://arxiv.org/abs/1911.08287`_.
+
+    Code is modified from https://github.com/Zzh-tju/DIoU.
+
+    Args:
+        eps (float): Epsilon to avoid log(0).
+        reduction (str): Options are "none", "mean" and "sum".
+        loss_weight (float): Weight of loss.
+    """
+
+    def __init__(self,
+                 eps: float = 1e-6,
+                 reduction: str = 'mean',
+                 loss_weight: float = 1.0) -> None:
+        super().__init__()
+        self.eps = eps
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+
+    def forward(self,
+                pred: Tensor,
+                target: Tensor,
+                weight: Optional[Tensor] = None,
+                avg_factor: Optional[int] = None,
+                reduction_override: Optional[str] = None,
+                **kwargs) -> Tensor:
+        """Forward function.
+
+        Args:
+            pred (Tensor): Predicted bboxes of format (x1, y1, x2, y2),
+                shape (n, 4).
+            target (Tensor): The learning target of the prediction,
+                shape (n, 4).
+            weight (Optional[Tensor], optional): The weight of loss for each
+                prediction. Defaults to None.
+            avg_factor (Optional[int], optional): Average factor that is used
+                to average the loss. Defaults to None.
+            reduction_override (Optional[str], optional): The reduction method
+                used to override the original reduction method of the loss.
+                Defaults to None. Options are "none", "mean" and "sum".
+
+        Returns:
+            Tensor: Loss tensor.
+        """
+        if weight is not None and not torch.any(weight > 0):
+            if pred.dim() == weight.dim() + 1:
+                weight = weight.unsqueeze(1)
+            return (pred * weight).sum()  # 0
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        if weight is not None and weight.dim() > 1:
+            # TODO: remove this in the future
+            # reduce the weight of shape (n, 4) to (n,) to match the
+            # giou_loss of shape (n,)
+            assert weight.shape == pred.shape
+            weight = weight.mean(-1)
+        loss = self.loss_weight * diou_loss(
+            pred,
+            target,
+            weight,
+            eps=self.eps,
+            reduction=reduction,
+            avg_factor=avg_factor,
+            **kwargs)
+        return loss
+
+
+@MODELS.register_module()
+class CIoULoss(nn.Module):
+    r"""`Implementation of paper `Enhancing Geometric Factors into
+    Model Learning and Inference for Object Detection and Instance
+    Segmentation `_.
+
+    Code is modified from https://github.com/Zzh-tju/CIoU.
+
+    Args:
+        eps (float): Epsilon to avoid log(0).
+        reduction (str): Options are "none", "mean" and "sum".
+        loss_weight (float): Weight of loss.
+    """
+
+    def __init__(self,
+                 eps: float = 1e-6,
+                 reduction: str = 'mean',
+                 loss_weight: float = 1.0) -> None:
+        super().__init__()
+        self.eps = eps
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+
+    def forward(self,
+                pred: Tensor,
+                target: Tensor,
+                weight: Optional[Tensor] = None,
+                avg_factor: Optional[int] = None,
+                reduction_override: Optional[str] = None,
+                **kwargs) -> Tensor:
+        """Forward function.
+
+        Args:
+            pred (Tensor): Predicted bboxes of format (x1, y1, x2, y2),
+                shape (n, 4).
+            target (Tensor): The learning target of the prediction,
+                shape (n, 4).
+            weight (Optional[Tensor], optional): The weight of loss for each
+                prediction. Defaults to None.
+            avg_factor (Optional[int], optional): Average factor that is used
+                to average the loss. Defaults to None.
+            reduction_override (Optional[str], optional): The reduction method
+                used to override the original reduction method of the loss.
+                Defaults to None. Options are "none", "mean" and "sum".
+
+        Returns:
+            Tensor: Loss tensor.
+        """
+        if weight is not None and not torch.any(weight > 0):
+            if pred.dim() == weight.dim() + 1:
+                weight = weight.unsqueeze(1)
+            return (pred * weight).sum()  # 0
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        if weight is not None and weight.dim() > 1:
+            # TODO: remove this in the future
+            # reduce the weight of shape (n, 4) to (n,) to match the
+            # giou_loss of shape (n,)
+            assert weight.shape == pred.shape
+            weight = weight.mean(-1)
+        loss = self.loss_weight * ciou_loss(
+            pred,
+            target,
+            weight,
+            eps=self.eps,
+            reduction=reduction,
+            avg_factor=avg_factor,
+            **kwargs)
+        return loss
+
+
+@MODELS.register_module()
+class EIoULoss(nn.Module):
+    r"""Implementation of paper `Extended-IoU Loss: A Systematic
+    IoU-Related Method: Beyond Simplified Regression for Better
+    Localization `_
+
+    Code is modified from https://github.com//ShiqiYu/libfacedetection.train.
+
+    Args:
+        eps (float): Epsilon to avoid log(0).
+        reduction (str): Options are "none", "mean" and "sum".
+        loss_weight (float): Weight of loss.
+        smooth_point (float): hyperparameter, default is 0.1.
+    """
+
+    def __init__(self,
+                 eps: float = 1e-6,
+                 reduction: str = 'mean',
+                 loss_weight: float = 1.0,
+                 smooth_point: float = 0.1) -> None:
+        super().__init__()
+        self.eps = eps
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+        self.smooth_point = smooth_point
+
+    def forward(self,
+                pred: Tensor,
+                target: Tensor,
+                weight: Optional[Tensor] = None,
+                avg_factor: Optional[int] = None,
+                reduction_override: Optional[str] = None,
+                **kwargs) -> Tensor:
+        """Forward function.
+
+        Args:
+            pred (Tensor): Predicted bboxes of format (x1, y1, x2, y2),
+                shape (n, 4).
+            target (Tensor): The learning target of the prediction,
+                shape (n, 4).
+            weight (Optional[Tensor], optional): The weight of loss for each
+                prediction. Defaults to None.
+            avg_factor (Optional[int], optional): Average factor that is used
+                to average the loss. Defaults to None.
+            reduction_override (Optional[str], optional): The reduction method
+                used to override the original reduction method of the loss.
+                Defaults to None. Options are "none", "mean" and "sum".
+
+        Returns:
+            Tensor: Loss tensor.
+        """
+        if weight is not None and not torch.any(weight > 0):
+            if pred.dim() == weight.dim() + 1:
+                weight = weight.unsqueeze(1)
+            return (pred * weight).sum()  # 0
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        if weight is not None and weight.dim() > 1:
+            assert weight.shape == pred.shape
+            weight = weight.mean(-1)
+        loss = self.loss_weight * eiou_loss(
+            pred,
+            target,
+            weight,
+            smooth_point=self.smooth_point,
+            eps=self.eps,
+            reduction=reduction,
+            avg_factor=avg_factor,
+            **kwargs)
+        return loss
+
+
+@MODELS.register_module()
+class SIoULoss(nn.Module):
+    r"""`Implementation of paper `SIoU Loss: More Powerful Learning
+    for Bounding Box Regression `_.
+
+    Code is modified from https://github.com/meituan/YOLOv6.
+
+    Args:
+        pred (Tensor): Predicted bboxes of format (x1, y1, x2, y2),
+            shape (n, 4).
+        target (Tensor): Corresponding gt bboxes, shape (n, 4).
+        eps (float): Eps to avoid log(0).
+        neg_gamma (bool): `True` follows original implementation in paper.
+
+    Return:
+        Tensor: Loss tensor.
+    """
+
+    def __init__(self,
+                 eps: float = 1e-6,
+                 reduction: str = 'mean',
+                 loss_weight: float = 1.0,
+                 neg_gamma: bool = False) -> None:
+        super().__init__()
+        self.eps = eps
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+        self.neg_gamma = neg_gamma
+
+    def forward(self,
+                pred: Tensor,
+                target: Tensor,
+                weight: Optional[Tensor] = None,
+                avg_factor: Optional[int] = None,
+                reduction_override: Optional[str] = None,
+                **kwargs) -> Tensor:
+        """Forward function.
+
+        Args:
+            pred (Tensor): Predicted bboxes of format (x1, y1, x2, y2),
+                shape (n, 4).
+            target (Tensor): The learning target of the prediction,
+                shape (n, 4).
+            weight (Optional[Tensor], optional): The weight of loss for each
+                prediction. Defaults to None.
+            avg_factor (Optional[int], optional): Average factor that is used
+                to average the loss. Defaults to None.
+            reduction_override (Optional[str], optional): The reduction method
+                used to override the original reduction method of the loss.
+                Defaults to None. Options are "none", "mean" and "sum".
+
+        Returns:
+            Tensor: Loss tensor.
+        """
+        if weight is not None and not torch.any(weight > 0):
+            if pred.dim() == weight.dim() + 1:
+                weight = weight.unsqueeze(1)
+            return (pred * weight).sum()  # 0
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        if weight is not None and weight.dim() > 1:
+            # TODO: remove this in the future
+            # reduce the weight of shape (n, 4) to (n,) to match the
+            # giou_loss of shape (n,)
+            assert weight.shape == pred.shape
+            weight = weight.mean(-1)
+        loss = self.loss_weight * siou_loss(
+            pred,
+            target,
+            weight,
+            eps=self.eps,
+            reduction=reduction,
+            avg_factor=avg_factor,
+            neg_gamma=self.neg_gamma,
+            **kwargs)
+        return loss
diff --git a/mmdetection/mmdet/models/losses/kd_loss.py b/mmdetection/mmdet/models/losses/kd_loss.py
new file mode 100644
index 00000000..0a7d5ef2
--- /dev/null
+++ b/mmdetection/mmdet/models/losses/kd_loss.py
@@ -0,0 +1,95 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional
+
+import torch.nn as nn
+import torch.nn.functional as F
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from .utils import weighted_loss
+
+
+@weighted_loss
+def knowledge_distillation_kl_div_loss(pred: Tensor,
+                                       soft_label: Tensor,
+                                       T: int,
+                                       detach_target: bool = True) -> Tensor:
+    r"""Loss function for knowledge distilling using KL divergence.
+
+    Args:
+        pred (Tensor): Predicted logits with shape (N, n + 1).
+        soft_label (Tensor): Target logits with shape (N, N + 1).
+        T (int): Temperature for distillation.
+        detach_target (bool): Remove soft_label from automatic differentiation
+
+    Returns:
+        Tensor: Loss tensor with shape (N,).
+    """
+    assert pred.size() == soft_label.size()
+    target = F.softmax(soft_label / T, dim=1)
+    if detach_target:
+        target = target.detach()
+
+    kd_loss = F.kl_div(
+        F.log_softmax(pred / T, dim=1), target, reduction='none').mean(1) * (
+            T * T)
+
+    return kd_loss
+
+
+@MODELS.register_module()
+class KnowledgeDistillationKLDivLoss(nn.Module):
+    """Loss function for knowledge distilling using KL divergence.
+
+    Args:
+        reduction (str): Options are `'none'`, `'mean'` and `'sum'`.
+        loss_weight (float): Loss weight of current loss.
+        T (int): Temperature for distillation.
+    """
+
+    def __init__(self,
+                 reduction: str = 'mean',
+                 loss_weight: float = 1.0,
+                 T: int = 10) -> None:
+        super().__init__()
+        assert T >= 1
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+        self.T = T
+
+    def forward(self,
+                pred: Tensor,
+                soft_label: Tensor,
+                weight: Optional[Tensor] = None,
+                avg_factor: Optional[int] = None,
+                reduction_override: Optional[str] = None) -> Tensor:
+        """Forward function.
+
+        Args:
+            pred (Tensor): Predicted logits with shape (N, n + 1).
+            soft_label (Tensor): Target logits with shape (N, N + 1).
+            weight (Tensor, optional): The weight of loss for each
+                prediction. Defaults to None.
+            avg_factor (int, optional): Average factor that is used to average
+                the loss. Defaults to None.
+            reduction_override (str, optional): The reduction method used to
+                override the original reduction method of the loss.
+                Defaults to None.
+
+        Returns:
+            Tensor: Loss tensor.
+        """
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+
+        loss_kd = self.loss_weight * knowledge_distillation_kl_div_loss(
+            pred,
+            soft_label,
+            weight,
+            reduction=reduction,
+            avg_factor=avg_factor,
+            T=self.T)
+
+        return loss_kd
diff --git a/mmdetection/mmdet/models/losses/l2_loss.py b/mmdetection/mmdet/models/losses/l2_loss.py
new file mode 100644
index 00000000..6210a300
--- /dev/null
+++ b/mmdetection/mmdet/models/losses/l2_loss.py
@@ -0,0 +1,139 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Tuple, Union
+
+import numpy as np
+import torch
+from mmengine.model import BaseModule
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from .utils import weighted_loss
+
+
+@weighted_loss
+def l2_loss(pred: Tensor, target: Tensor) -> Tensor:
+    """L2 loss.
+
+    Args:
+        pred (torch.Tensor): The prediction.
+        target (torch.Tensor): The learning target of the prediction.
+
+    Returns:
+        torch.Tensor: Calculated loss
+    """
+    assert pred.size() == target.size()
+    loss = torch.abs(pred - target)**2
+    return loss
+
+
+@MODELS.register_module()
+class L2Loss(BaseModule):
+    """L2 loss.
+
+    Args:
+        reduction (str, optional): The method to reduce the loss.
+            Options are "none", "mean" and "sum".
+        loss_weight (float, optional): The weight of loss.
+    """
+
+    def __init__(self,
+                 neg_pos_ub: int = -1,
+                 pos_margin: float = -1,
+                 neg_margin: float = -1,
+                 hard_mining: bool = False,
+                 reduction: str = 'mean',
+                 loss_weight: float = 1.0):
+        super(L2Loss, self).__init__()
+        self.neg_pos_ub = neg_pos_ub
+        self.pos_margin = pos_margin
+        self.neg_margin = neg_margin
+        self.hard_mining = hard_mining
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+
+    def forward(self,
+                pred: Tensor,
+                target: Tensor,
+                weight: Optional[Tensor] = None,
+                avg_factor: Optional[float] = None,
+                reduction_override: Optional[str] = None) -> Tensor:
+        """Forward function.
+
+        Args:
+            pred (torch.Tensor): The prediction.
+            target (torch.Tensor): The learning target of the prediction.
+            weight (torch.Tensor, optional): The weight of loss for each
+                prediction. Defaults to None.
+            avg_factor (float, optional): Average factor that is used to
+                average the loss. Defaults to None.
+            reduction_override (str, optional): The reduction method used to
+                override the original reduction method of the loss.
+                Defaults to None.
+        """
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        pred, weight, avg_factor = self.update_weight(pred, target, weight,
+                                                      avg_factor)
+        loss_bbox = self.loss_weight * l2_loss(
+            pred, target, weight, reduction=reduction, avg_factor=avg_factor)
+        return loss_bbox
+
+    def update_weight(self, pred: Tensor, target: Tensor, weight: Tensor,
+                      avg_factor: float) -> Tuple[Tensor, Tensor, float]:
+        """Update the weight according to targets."""
+        if weight is None:
+            weight = target.new_ones(target.size())
+
+        invalid_inds = weight <= 0
+        target[invalid_inds] = -1
+        pos_inds = target == 1
+        neg_inds = target == 0
+
+        if self.pos_margin > 0:
+            pred[pos_inds] -= self.pos_margin
+        if self.neg_margin > 0:
+            pred[neg_inds] -= self.neg_margin
+        pred = torch.clamp(pred, min=0, max=1)
+
+        num_pos = int((target == 1).sum())
+        num_neg = int((target == 0).sum())
+        if self.neg_pos_ub > 0 and num_neg / (num_pos +
+                                              1e-6) > self.neg_pos_ub:
+            num_neg = num_pos * self.neg_pos_ub
+            neg_idx = torch.nonzero(target == 0, as_tuple=False)
+
+            if self.hard_mining:
+                costs = l2_loss(
+                    pred, target, reduction='none')[neg_idx[:, 0],
+                                                    neg_idx[:, 1]].detach()
+                neg_idx = neg_idx[costs.topk(num_neg)[1], :]
+            else:
+                neg_idx = self.random_choice(neg_idx, num_neg)
+
+            new_neg_inds = neg_inds.new_zeros(neg_inds.size()).bool()
+            new_neg_inds[neg_idx[:, 0], neg_idx[:, 1]] = True
+
+            invalid_neg_inds = torch.logical_xor(neg_inds, new_neg_inds)
+            weight[invalid_neg_inds] = 0
+
+        avg_factor = (weight > 0).sum()
+        return pred, weight, avg_factor
+
+    @staticmethod
+    def random_choice(gallery: Union[list, np.ndarray, Tensor],
+                      num: int) -> np.ndarray:
+        """Random select some elements from the gallery.
+
+        It seems that Pytorch's implementation is slower than numpy so we use
+        numpy to randperm the indices.
+        """
+        assert len(gallery) >= num
+        if isinstance(gallery, list):
+            gallery = np.array(gallery)
+        cands = np.arange(len(gallery))
+        np.random.shuffle(cands)
+        rand_inds = cands[:num]
+        if not isinstance(gallery, np.ndarray):
+            rand_inds = torch.from_numpy(rand_inds).long().to(gallery.device)
+        return gallery[rand_inds]
diff --git a/mmdetection/mmdet/models/losses/margin_loss.py b/mmdetection/mmdet/models/losses/margin_loss.py
new file mode 100644
index 00000000..0609e1db
--- /dev/null
+++ b/mmdetection/mmdet/models/losses/margin_loss.py
@@ -0,0 +1,152 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Tuple, Union
+
+import numpy as np
+import torch
+from mmengine.model import BaseModule
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from .mse_loss import mse_loss
+
+
+@MODELS.register_module()
+class MarginL2Loss(BaseModule):
+    """L2 loss with margin.
+
+    Args:
+        neg_pos_ub (int, optional): The upper bound of negative to positive
+            samples in hard mining. Defaults to -1.
+        pos_margin (float, optional): The similarity margin for positive
+            samples in hard mining. Defaults to -1.
+        neg_margin (float, optional): The similarity margin for negative
+            samples in hard mining. Defaults to -1.
+        hard_mining (bool, optional): Whether to use hard mining. Defaults to
+            False.
+        reduction (str, optional): The method to reduce the loss.
+            Options are "none", "mean" and "sum". Defaults to "mean".
+        loss_weight (float, optional): The weight of loss. Defaults to 1.0.
+    """
+
+    def __init__(self,
+                 neg_pos_ub: int = -1,
+                 pos_margin: float = -1,
+                 neg_margin: float = -1,
+                 hard_mining: bool = False,
+                 reduction: str = 'mean',
+                 loss_weight: float = 1.0):
+        super(MarginL2Loss, self).__init__()
+        self.neg_pos_ub = neg_pos_ub
+        self.pos_margin = pos_margin
+        self.neg_margin = neg_margin
+        self.hard_mining = hard_mining
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+
+    def forward(self,
+                pred: Tensor,
+                target: Tensor,
+                weight: Optional[Tensor] = None,
+                avg_factor: Optional[float] = None,
+                reduction_override: Optional[str] = None) -> Tensor:
+        """Forward function.
+
+        Args:
+            pred (torch.Tensor): The prediction.
+            target (torch.Tensor): The learning target of the prediction.
+            weight (torch.Tensor, optional): The weight of loss for each
+                prediction. Defaults to None.
+            avg_factor (float, optional): Average factor that is used to
+                average the loss. Defaults to None.
+            reduction_override (str, optional): The reduction method used to
+                override the original reduction method of the loss.
+                Defaults to None.
+        """
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        pred, weight, avg_factor = self.update_weight(pred, target, weight,
+                                                      avg_factor)
+        loss_bbox = self.loss_weight * mse_loss(
+            pred,
+            target.float(),
+            weight.float(),
+            reduction=reduction,
+            avg_factor=avg_factor)
+        return loss_bbox
+
+    def update_weight(self, pred: Tensor, target: Tensor, weight: Tensor,
+                      avg_factor: float) -> Tuple[Tensor, Tensor, float]:
+        """Update the weight according to targets.
+
+        Args:
+            pred (torch.Tensor): The prediction.
+            target (torch.Tensor): The learning target of the prediction.
+            weight (torch.Tensor): The weight of loss for each prediction.
+            avg_factor (float): Average factor that is used to average the
+                loss.
+
+        Returns:
+            tuple[torch.Tensor]: The updated prediction, weight and average
+            factor.
+        """
+        if weight is None:
+            weight = target.new_ones(target.size())
+
+        invalid_inds = weight <= 0
+        target[invalid_inds] = -1
+        pos_inds = target == 1
+        neg_inds = target == 0
+
+        if self.pos_margin > 0:
+            pred[pos_inds] -= self.pos_margin
+        if self.neg_margin > 0:
+            pred[neg_inds] -= self.neg_margin
+        pred = torch.clamp(pred, min=0, max=1)
+
+        num_pos = int((target == 1).sum())
+        num_neg = int((target == 0).sum())
+        if self.neg_pos_ub > 0 and num_neg / (num_pos +
+                                              1e-6) > self.neg_pos_ub:
+            num_neg = num_pos * self.neg_pos_ub
+            neg_idx = torch.nonzero(target == 0, as_tuple=False)
+
+            if self.hard_mining:
+                costs = mse_loss(
+                    pred, target.float(),
+                    reduction='none')[neg_idx[:, 0], neg_idx[:, 1]].detach()
+                neg_idx = neg_idx[costs.topk(num_neg)[1], :]
+            else:
+                neg_idx = self.random_choice(neg_idx, num_neg)
+
+            new_neg_inds = neg_inds.new_zeros(neg_inds.size()).bool()
+            new_neg_inds[neg_idx[:, 0], neg_idx[:, 1]] = True
+
+            invalid_neg_inds = torch.logical_xor(neg_inds, new_neg_inds)
+            weight[invalid_neg_inds] = 0
+
+        avg_factor = (weight > 0).sum()
+        return pred, weight, avg_factor
+
+    @staticmethod
+    def random_choice(gallery: Union[list, np.ndarray, Tensor],
+                      num: int) -> np.ndarray:
+        """Random select some elements from the gallery.
+
+        It seems that Pytorch's implementation is slower than numpy so we use
+        numpy to randperm the indices.
+
+        Args:
+            gallery (list | np.ndarray | torch.Tensor): The gallery from
+                which to sample.
+            num (int): The number of elements to sample.
+        """
+        assert len(gallery) >= num
+        if isinstance(gallery, list):
+            gallery = np.array(gallery)
+        cands = np.arange(len(gallery))
+        np.random.shuffle(cands)
+        rand_inds = cands[:num]
+        if not isinstance(gallery, np.ndarray):
+            rand_inds = torch.from_numpy(rand_inds).long().to(gallery.device)
+        return gallery[rand_inds]
diff --git a/mmdetection/mmdet/models/losses/mse_loss.py b/mmdetection/mmdet/models/losses/mse_loss.py
new file mode 100644
index 00000000..6048218a
--- /dev/null
+++ b/mmdetection/mmdet/models/losses/mse_loss.py
@@ -0,0 +1,69 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional
+
+import torch.nn as nn
+import torch.nn.functional as F
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from .utils import weighted_loss
+
+
+@weighted_loss
+def mse_loss(pred: Tensor, target: Tensor) -> Tensor:
+    """A Wrapper of MSE loss.
+    Args:
+        pred (Tensor): The prediction.
+        target (Tensor): The learning target of the prediction.
+
+    Returns:
+        Tensor: loss Tensor
+    """
+    return F.mse_loss(pred, target, reduction='none')
+
+
+@MODELS.register_module()
+class MSELoss(nn.Module):
+    """MSELoss.
+
+    Args:
+        reduction (str, optional): The method that reduces the loss to a
+            scalar. Options are "none", "mean" and "sum".
+        loss_weight (float, optional): The weight of the loss. Defaults to 1.0
+    """
+
+    def __init__(self,
+                 reduction: str = 'mean',
+                 loss_weight: float = 1.0) -> None:
+        super().__init__()
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+
+    def forward(self,
+                pred: Tensor,
+                target: Tensor,
+                weight: Optional[Tensor] = None,
+                avg_factor: Optional[int] = None,
+                reduction_override: Optional[str] = None) -> Tensor:
+        """Forward function of loss.
+
+        Args:
+            pred (Tensor): The prediction.
+            target (Tensor): The learning target of the prediction.
+            weight (Tensor, optional): Weight of the loss for each
+                prediction. Defaults to None.
+            avg_factor (int, optional): Average factor that is used to average
+                the loss. Defaults to None.
+            reduction_override (str, optional): The reduction method used to
+                override the original reduction method of the loss.
+                Defaults to None.
+
+        Returns:
+            Tensor: The calculated loss.
+        """
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        loss = self.loss_weight * mse_loss(
+            pred, target, weight, reduction=reduction, avg_factor=avg_factor)
+        return loss
diff --git a/mmdetection/mmdet/models/losses/multipos_cross_entropy_loss.py b/mmdetection/mmdet/models/losses/multipos_cross_entropy_loss.py
new file mode 100644
index 00000000..a7d1561e
--- /dev/null
+++ b/mmdetection/mmdet/models/losses/multipos_cross_entropy_loss.py
@@ -0,0 +1,100 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional
+
+import torch
+from mmengine.model import BaseModule
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from .utils import weight_reduce_loss
+
+
+@MODELS.register_module()
+class MultiPosCrossEntropyLoss(BaseModule):
+    """multi-positive targets cross entropy loss.
+
+    Args:
+        reduction (str, optional): The method to reduce the loss.
+            Options are "none", "mean" and "sum". Defaults to "mean".
+        loss_weight (float, optional): The weight of loss. Defaults to 1.0.
+    """
+
+    def __init__(self, reduction: str = 'mean', loss_weight: float = 1.0):
+        super(MultiPosCrossEntropyLoss, self).__init__()
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+
+    def multi_pos_cross_entropy(self,
+                                pred: Tensor,
+                                label: Tensor,
+                                weight: Optional[Tensor] = None,
+                                reduction: str = 'mean',
+                                avg_factor: Optional[float] = None) -> Tensor:
+        """Multi-positive targets cross entropy loss.
+
+        Args:
+            pred (torch.Tensor): The prediction.
+            label (torch.Tensor): The assigned label of the prediction.
+            weight (torch.Tensor): The element-wise weight.
+            reduction (str): Same as built-in losses of PyTorch.
+            avg_factor (float): Average factor when computing
+                the mean of losses.
+
+        Returns:
+            torch.Tensor: Calculated loss
+        """
+
+        pos_inds = (label >= 1)
+        neg_inds = (label == 0)
+        pred_pos = pred * pos_inds.float()
+        pred_neg = pred * neg_inds.float()
+        # use -inf to mask out unwanted elements.
+        pred_pos[neg_inds] = pred_pos[neg_inds] + float('inf')
+        pred_neg[pos_inds] = pred_neg[pos_inds] + float('-inf')
+
+        _pos_expand = torch.repeat_interleave(pred_pos, pred.shape[1], dim=1)
+        _neg_expand = pred_neg.repeat(1, pred.shape[1])
+
+        x = torch.nn.functional.pad((_neg_expand - _pos_expand), (0, 1),
+                                    'constant', 0)
+        loss = torch.logsumexp(x, dim=1)
+
+        # apply weights and do the reduction
+        if weight is not None:
+            weight = weight.float()
+        loss = weight_reduce_loss(
+            loss, weight=weight, reduction=reduction, avg_factor=avg_factor)
+
+        return loss
+
+    def forward(self,
+                cls_score: Tensor,
+                label: Tensor,
+                weight: Optional[Tensor] = None,
+                avg_factor: Optional[float] = None,
+                reduction_override: Optional[str] = None,
+                **kwargs) -> Tensor:
+        """Forward function.
+
+        Args:
+            cls_score (torch.Tensor): The classification score.
+            label (torch.Tensor): The assigned label of the prediction.
+            weight (torch.Tensor): The element-wise weight.
+            avg_factor (float): Average factor when computing
+                the mean of losses.
+            reduction_override (str): Same as built-in losses of PyTorch.
+
+        Returns:
+            torch.Tensor: Calculated loss
+        """
+        assert cls_score.size() == label.size()
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        loss_cls = self.loss_weight * self.multi_pos_cross_entropy(
+            cls_score,
+            label,
+            weight,
+            reduction=reduction,
+            avg_factor=avg_factor)
+        return loss_cls
diff --git a/mmdetection/mmdet/models/losses/pisa_loss.py b/mmdetection/mmdet/models/losses/pisa_loss.py
new file mode 100644
index 00000000..b192aa0d
--- /dev/null
+++ b/mmdetection/mmdet/models/losses/pisa_loss.py
@@ -0,0 +1,187 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Tuple
+
+import torch
+import torch.nn as nn
+from torch import Tensor
+
+from mmdet.structures.bbox import bbox_overlaps
+from ..task_modules.coders import BaseBBoxCoder
+from ..task_modules.samplers import SamplingResult
+
+
+def isr_p(cls_score: Tensor,
+          bbox_pred: Tensor,
+          bbox_targets: Tuple[Tensor],
+          rois: Tensor,
+          sampling_results: List[SamplingResult],
+          loss_cls: nn.Module,
+          bbox_coder: BaseBBoxCoder,
+          k: float = 2,
+          bias: float = 0,
+          num_class: int = 80) -> tuple:
+    """Importance-based Sample Reweighting (ISR_P), positive part.
+
+    Args:
+        cls_score (Tensor): Predicted classification scores.
+        bbox_pred (Tensor): Predicted bbox deltas.
+        bbox_targets (tuple[Tensor]): A tuple of bbox targets, the are
+            labels, label_weights, bbox_targets, bbox_weights, respectively.
+        rois (Tensor): Anchors (single_stage) in shape (n, 4) or RoIs
+            (two_stage) in shape (n, 5).
+        sampling_results (:obj:`SamplingResult`): Sampling results.
+        loss_cls (:obj:`nn.Module`): Classification loss func of the head.
+        bbox_coder (:obj:`BaseBBoxCoder`): BBox coder of the head.
+        k (float): Power of the non-linear mapping. Defaults to 2.
+        bias (float): Shift of the non-linear mapping. Defaults to 0.
+        num_class (int): Number of classes, defaults to 80.
+
+    Return:
+        tuple([Tensor]): labels, imp_based_label_weights, bbox_targets,
+            bbox_target_weights
+    """
+
+    labels, label_weights, bbox_targets, bbox_weights = bbox_targets
+    pos_label_inds = ((labels >= 0) &
+                      (labels < num_class)).nonzero().reshape(-1)
+    pos_labels = labels[pos_label_inds]
+
+    # if no positive samples, return the original targets
+    num_pos = float(pos_label_inds.size(0))
+    if num_pos == 0:
+        return labels, label_weights, bbox_targets, bbox_weights
+
+    # merge pos_assigned_gt_inds of per image to a single tensor
+    gts = list()
+    last_max_gt = 0
+    for i in range(len(sampling_results)):
+        gt_i = sampling_results[i].pos_assigned_gt_inds
+        gts.append(gt_i + last_max_gt)
+        if len(gt_i) != 0:
+            last_max_gt = gt_i.max() + 1
+    gts = torch.cat(gts)
+    assert len(gts) == num_pos
+
+    cls_score = cls_score.detach()
+    bbox_pred = bbox_pred.detach()
+
+    # For single stage detectors, rois here indicate anchors, in shape (N, 4)
+    # For two stage detectors, rois are in shape (N, 5)
+    if rois.size(-1) == 5:
+        pos_rois = rois[pos_label_inds][:, 1:]
+    else:
+        pos_rois = rois[pos_label_inds]
+
+    if bbox_pred.size(-1) > 4:
+        bbox_pred = bbox_pred.view(bbox_pred.size(0), -1, 4)
+        pos_delta_pred = bbox_pred[pos_label_inds, pos_labels].view(-1, 4)
+    else:
+        pos_delta_pred = bbox_pred[pos_label_inds].view(-1, 4)
+
+    # compute iou of the predicted bbox and the corresponding GT
+    pos_delta_target = bbox_targets[pos_label_inds].view(-1, 4)
+    pos_bbox_pred = bbox_coder.decode(pos_rois, pos_delta_pred)
+    target_bbox_pred = bbox_coder.decode(pos_rois, pos_delta_target)
+    ious = bbox_overlaps(pos_bbox_pred, target_bbox_pred, is_aligned=True)
+
+    pos_imp_weights = label_weights[pos_label_inds]
+    # Two steps to compute IoU-HLR. Samples are first sorted by IoU locally,
+    # then sorted again within the same-rank group
+    max_l_num = pos_labels.bincount().max()
+    for label in pos_labels.unique():
+        l_inds = (pos_labels == label).nonzero().view(-1)
+        l_gts = gts[l_inds]
+        for t in l_gts.unique():
+            t_inds = l_inds[l_gts == t]
+            t_ious = ious[t_inds]
+            _, t_iou_rank_idx = t_ious.sort(descending=True)
+            _, t_iou_rank = t_iou_rank_idx.sort()
+            ious[t_inds] += max_l_num - t_iou_rank.float()
+        l_ious = ious[l_inds]
+        _, l_iou_rank_idx = l_ious.sort(descending=True)
+        _, l_iou_rank = l_iou_rank_idx.sort()  # IoU-HLR
+        # linearly map HLR to label weights
+        pos_imp_weights[l_inds] *= (max_l_num - l_iou_rank.float()) / max_l_num
+
+    pos_imp_weights = (bias + pos_imp_weights * (1 - bias)).pow(k)
+
+    # normalize to make the new weighted loss value equal to the original loss
+    pos_loss_cls = loss_cls(
+        cls_score[pos_label_inds], pos_labels, reduction_override='none')
+    if pos_loss_cls.dim() > 1:
+        ori_pos_loss_cls = pos_loss_cls * label_weights[pos_label_inds][:,
+                                                                        None]
+        new_pos_loss_cls = pos_loss_cls * pos_imp_weights[:, None]
+    else:
+        ori_pos_loss_cls = pos_loss_cls * label_weights[pos_label_inds]
+        new_pos_loss_cls = pos_loss_cls * pos_imp_weights
+    pos_loss_cls_ratio = ori_pos_loss_cls.sum() / new_pos_loss_cls.sum()
+    pos_imp_weights = pos_imp_weights * pos_loss_cls_ratio
+    label_weights[pos_label_inds] = pos_imp_weights
+
+    bbox_targets = labels, label_weights, bbox_targets, bbox_weights
+    return bbox_targets
+
+
+def carl_loss(cls_score: Tensor,
+              labels: Tensor,
+              bbox_pred: Tensor,
+              bbox_targets: Tensor,
+              loss_bbox: nn.Module,
+              k: float = 1,
+              bias: float = 0.2,
+              avg_factor: Optional[int] = None,
+              sigmoid: bool = False,
+              num_class: int = 80) -> dict:
+    """Classification-Aware Regression Loss (CARL).
+
+    Args:
+        cls_score (Tensor): Predicted classification scores.
+        labels (Tensor): Targets of classification.
+        bbox_pred (Tensor): Predicted bbox deltas.
+        bbox_targets (Tensor): Target of bbox regression.
+        loss_bbox (func): Regression loss func of the head.
+        bbox_coder (obj): BBox coder of the head.
+        k (float): Power of the non-linear mapping. Defaults to 1.
+        bias (float): Shift of the non-linear mapping. Defaults to 0.2.
+        avg_factor (int, optional): Average factor used in regression loss.
+        sigmoid (bool): Activation of the classification score.
+        num_class (int): Number of classes, defaults to 80.
+
+    Return:
+        dict: CARL loss dict.
+    """
+    pos_label_inds = ((labels >= 0) &
+                      (labels < num_class)).nonzero().reshape(-1)
+    if pos_label_inds.numel() == 0:
+        return dict(loss_carl=cls_score.sum()[None] * 0.)
+    pos_labels = labels[pos_label_inds]
+
+    # multiply pos_cls_score with the corresponding bbox weight
+    # and remain gradient
+    if sigmoid:
+        pos_cls_score = cls_score.sigmoid()[pos_label_inds, pos_labels]
+    else:
+        pos_cls_score = cls_score.softmax(-1)[pos_label_inds, pos_labels]
+    carl_loss_weights = (bias + (1 - bias) * pos_cls_score).pow(k)
+
+    # normalize carl_loss_weight to make its sum equal to num positive
+    num_pos = float(pos_cls_score.size(0))
+    weight_ratio = num_pos / carl_loss_weights.sum()
+    carl_loss_weights *= weight_ratio
+
+    if avg_factor is None:
+        avg_factor = bbox_targets.size(0)
+    # if is class agnostic, bbox pred is in shape (N, 4)
+    # otherwise, bbox pred is in shape (N, #classes, 4)
+    if bbox_pred.size(-1) > 4:
+        bbox_pred = bbox_pred.view(bbox_pred.size(0), -1, 4)
+        pos_bbox_preds = bbox_pred[pos_label_inds, pos_labels]
+    else:
+        pos_bbox_preds = bbox_pred[pos_label_inds]
+    ori_loss_reg = loss_bbox(
+        pos_bbox_preds,
+        bbox_targets[pos_label_inds],
+        reduction_override='none') / avg_factor
+    loss_carl = (ori_loss_reg * carl_loss_weights[:, None]).sum()
+    return dict(loss_carl=loss_carl[None])
diff --git a/mmdetection/mmdet/models/losses/seesaw_loss.py b/mmdetection/mmdet/models/losses/seesaw_loss.py
new file mode 100644
index 00000000..4dec62b0
--- /dev/null
+++ b/mmdetection/mmdet/models/losses/seesaw_loss.py
@@ -0,0 +1,278 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from .accuracy import accuracy
+from .cross_entropy_loss import cross_entropy
+from .utils import weight_reduce_loss
+
+
+def seesaw_ce_loss(cls_score: Tensor,
+                   labels: Tensor,
+                   label_weights: Tensor,
+                   cum_samples: Tensor,
+                   num_classes: int,
+                   p: float,
+                   q: float,
+                   eps: float,
+                   reduction: str = 'mean',
+                   avg_factor: Optional[int] = None) -> Tensor:
+    """Calculate the Seesaw CrossEntropy loss.
+
+    Args:
+        cls_score (Tensor): The prediction with shape (N, C),
+             C is the number of classes.
+        labels (Tensor): The learning label of the prediction.
+        label_weights (Tensor): Sample-wise loss weight.
+        cum_samples (Tensor): Cumulative samples for each category.
+        num_classes (int): The number of classes.
+        p (float): The ``p`` in the mitigation factor.
+        q (float): The ``q`` in the compenstation factor.
+        eps (float): The minimal value of divisor to smooth
+             the computation of compensation factor
+        reduction (str, optional): The method used to reduce the loss.
+        avg_factor (int, optional): Average factor that is used to average
+            the loss. Defaults to None.
+
+    Returns:
+        Tensor: The calculated loss
+    """
+    assert cls_score.size(-1) == num_classes
+    assert len(cum_samples) == num_classes
+
+    onehot_labels = F.one_hot(labels, num_classes)
+    seesaw_weights = cls_score.new_ones(onehot_labels.size())
+
+    # mitigation factor
+    if p > 0:
+        sample_ratio_matrix = cum_samples[None, :].clamp(
+            min=1) / cum_samples[:, None].clamp(min=1)
+        index = (sample_ratio_matrix < 1.0).float()
+        sample_weights = sample_ratio_matrix.pow(p) * index + (1 - index)
+        mitigation_factor = sample_weights[labels.long(), :]
+        seesaw_weights = seesaw_weights * mitigation_factor
+
+    # compensation factor
+    if q > 0:
+        scores = F.softmax(cls_score.detach(), dim=1)
+        self_scores = scores[
+            torch.arange(0, len(scores)).to(scores.device).long(),
+            labels.long()]
+        score_matrix = scores / self_scores[:, None].clamp(min=eps)
+        index = (score_matrix > 1.0).float()
+        compensation_factor = score_matrix.pow(q) * index + (1 - index)
+        seesaw_weights = seesaw_weights * compensation_factor
+
+    cls_score = cls_score + (seesaw_weights.log() * (1 - onehot_labels))
+
+    loss = F.cross_entropy(cls_score, labels, weight=None, reduction='none')
+
+    if label_weights is not None:
+        label_weights = label_weights.float()
+    loss = weight_reduce_loss(
+        loss, weight=label_weights, reduction=reduction, avg_factor=avg_factor)
+    return loss
+
+
+@MODELS.register_module()
+class SeesawLoss(nn.Module):
+    """
+    Seesaw Loss for Long-Tailed Instance Segmentation (CVPR 2021)
+    arXiv: https://arxiv.org/abs/2008.10032
+
+    Args:
+        use_sigmoid (bool, optional): Whether the prediction uses sigmoid
+             of softmax. Only False is supported.
+        p (float, optional): The ``p`` in the mitigation factor.
+             Defaults to 0.8.
+        q (float, optional): The ``q`` in the compenstation factor.
+             Defaults to 2.0.
+        num_classes (int, optional): The number of classes.
+             Default to 1203 for LVIS v1 dataset.
+        eps (float, optional): The minimal value of divisor to smooth
+             the computation of compensation factor
+        reduction (str, optional): The method that reduces the loss to a
+             scalar. Options are "none", "mean" and "sum".
+        loss_weight (float, optional): The weight of the loss. Defaults to 1.0
+        return_dict (bool, optional): Whether return the losses as a dict.
+             Default to True.
+    """
+
+    def __init__(self,
+                 use_sigmoid: bool = False,
+                 p: float = 0.8,
+                 q: float = 2.0,
+                 num_classes: int = 1203,
+                 eps: float = 1e-2,
+                 reduction: str = 'mean',
+                 loss_weight: float = 1.0,
+                 return_dict: bool = True) -> None:
+        super().__init__()
+        assert not use_sigmoid
+        self.use_sigmoid = False
+        self.p = p
+        self.q = q
+        self.num_classes = num_classes
+        self.eps = eps
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+        self.return_dict = return_dict
+
+        # 0 for pos, 1 for neg
+        self.cls_criterion = seesaw_ce_loss
+
+        # cumulative samples for each category
+        self.register_buffer(
+            'cum_samples',
+            torch.zeros(self.num_classes + 1, dtype=torch.float))
+
+        # custom output channels of the classifier
+        self.custom_cls_channels = True
+        # custom activation of cls_score
+        self.custom_activation = True
+        # custom accuracy of the classsifier
+        self.custom_accuracy = True
+
+    def _split_cls_score(self, cls_score: Tensor) -> Tuple[Tensor, Tensor]:
+        """split cls_score.
+
+        Args:
+            cls_score (Tensor): The prediction with shape (N, C + 2).
+
+        Returns:
+            Tuple[Tensor, Tensor]: The score for classes and objectness,
+                 respectively
+        """
+        # split cls_score to cls_score_classes and cls_score_objectness
+        assert cls_score.size(-1) == self.num_classes + 2
+        cls_score_classes = cls_score[..., :-2]
+        cls_score_objectness = cls_score[..., -2:]
+        return cls_score_classes, cls_score_objectness
+
+    def get_cls_channels(self, num_classes: int) -> int:
+        """Get custom classification channels.
+
+        Args:
+            num_classes (int): The number of classes.
+
+        Returns:
+            int: The custom classification channels.
+        """
+        assert num_classes == self.num_classes
+        return num_classes + 2
+
+    def get_activation(self, cls_score: Tensor) -> Tensor:
+        """Get custom activation of cls_score.
+
+        Args:
+            cls_score (Tensor): The prediction with shape (N, C + 2).
+
+        Returns:
+            Tensor: The custom activation of cls_score with shape
+                 (N, C + 1).
+        """
+        cls_score_classes, cls_score_objectness = self._split_cls_score(
+            cls_score)
+        score_classes = F.softmax(cls_score_classes, dim=-1)
+        score_objectness = F.softmax(cls_score_objectness, dim=-1)
+        score_pos = score_objectness[..., [0]]
+        score_neg = score_objectness[..., [1]]
+        score_classes = score_classes * score_pos
+        scores = torch.cat([score_classes, score_neg], dim=-1)
+        return scores
+
+    def get_accuracy(self, cls_score: Tensor,
+                     labels: Tensor) -> Dict[str, Tensor]:
+        """Get custom accuracy w.r.t. cls_score and labels.
+
+        Args:
+            cls_score (Tensor): The prediction with shape (N, C + 2).
+            labels (Tensor): The learning label of the prediction.
+
+        Returns:
+            Dict [str, Tensor]: The accuracy for objectness and classes,
+                 respectively.
+        """
+        pos_inds = labels < self.num_classes
+        obj_labels = (labels == self.num_classes).long()
+        cls_score_classes, cls_score_objectness = self._split_cls_score(
+            cls_score)
+        acc_objectness = accuracy(cls_score_objectness, obj_labels)
+        acc_classes = accuracy(cls_score_classes[pos_inds], labels[pos_inds])
+        acc = dict()
+        acc['acc_objectness'] = acc_objectness
+        acc['acc_classes'] = acc_classes
+        return acc
+
+    def forward(
+        self,
+        cls_score: Tensor,
+        labels: Tensor,
+        label_weights: Optional[Tensor] = None,
+        avg_factor: Optional[int] = None,
+        reduction_override: Optional[str] = None
+    ) -> Union[Tensor, Dict[str, Tensor]]:
+        """Forward function.
+
+        Args:
+            cls_score (Tensor): The prediction with shape (N, C + 2).
+            labels (Tensor): The learning label of the prediction.
+            label_weights (Tensor, optional): Sample-wise loss weight.
+            avg_factor (int, optional): Average factor that is used to average
+                 the loss. Defaults to None.
+            reduction (str, optional): The method used to reduce the loss.
+                 Options are "none", "mean" and "sum".
+
+        Returns:
+            Tensor | Dict [str, Tensor]:
+                 if return_dict == False: The calculated loss |
+                 if return_dict == True: The dict of calculated losses
+                 for objectness and classes, respectively.
+        """
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        assert cls_score.size(-1) == self.num_classes + 2
+        pos_inds = labels < self.num_classes
+        # 0 for pos, 1 for neg
+        obj_labels = (labels == self.num_classes).long()
+
+        # accumulate the samples for each category
+        unique_labels = labels.unique()
+        for u_l in unique_labels:
+            inds_ = labels == u_l.item()
+            self.cum_samples[u_l] += inds_.sum()
+
+        if label_weights is not None:
+            label_weights = label_weights.float()
+        else:
+            label_weights = labels.new_ones(labels.size(), dtype=torch.float)
+
+        cls_score_classes, cls_score_objectness = self._split_cls_score(
+            cls_score)
+        # calculate loss_cls_classes (only need pos samples)
+        if pos_inds.sum() > 0:
+            loss_cls_classes = self.loss_weight * self.cls_criterion(
+                cls_score_classes[pos_inds], labels[pos_inds],
+                label_weights[pos_inds], self.cum_samples[:self.num_classes],
+                self.num_classes, self.p, self.q, self.eps, reduction,
+                avg_factor)
+        else:
+            loss_cls_classes = cls_score_classes[pos_inds].sum()
+        # calculate loss_cls_objectness
+        loss_cls_objectness = self.loss_weight * cross_entropy(
+            cls_score_objectness, obj_labels, label_weights, reduction,
+            avg_factor)
+
+        if self.return_dict:
+            loss_cls = dict()
+            loss_cls['loss_cls_objectness'] = loss_cls_objectness
+            loss_cls['loss_cls_classes'] = loss_cls_classes
+        else:
+            loss_cls = loss_cls_classes + loss_cls_objectness
+        return loss_cls
diff --git a/mmdetection/mmdet/models/losses/smooth_l1_loss.py b/mmdetection/mmdet/models/losses/smooth_l1_loss.py
new file mode 100644
index 00000000..102f9780
--- /dev/null
+++ b/mmdetection/mmdet/models/losses/smooth_l1_loss.py
@@ -0,0 +1,165 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional
+
+import torch
+import torch.nn as nn
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from .utils import weighted_loss
+
+
+@weighted_loss
+def smooth_l1_loss(pred: Tensor, target: Tensor, beta: float = 1.0) -> Tensor:
+    """Smooth L1 loss.
+
+    Args:
+        pred (Tensor): The prediction.
+        target (Tensor): The learning target of the prediction.
+        beta (float, optional): The threshold in the piecewise function.
+            Defaults to 1.0.
+
+    Returns:
+        Tensor: Calculated loss
+    """
+    assert beta > 0
+    if target.numel() == 0:
+        return pred.sum() * 0
+
+    assert pred.size() == target.size()
+    diff = torch.abs(pred - target)
+    loss = torch.where(diff < beta, 0.5 * diff * diff / beta,
+                       diff - 0.5 * beta)
+    return loss
+
+
+@weighted_loss
+def l1_loss(pred: Tensor, target: Tensor) -> Tensor:
+    """L1 loss.
+
+    Args:
+        pred (Tensor): The prediction.
+        target (Tensor): The learning target of the prediction.
+
+    Returns:
+        Tensor: Calculated loss
+    """
+    if target.numel() == 0:
+        return pred.sum() * 0
+
+    assert pred.size() == target.size()
+    loss = torch.abs(pred - target)
+    return loss
+
+
+@MODELS.register_module()
+class SmoothL1Loss(nn.Module):
+    """Smooth L1 loss.
+
+    Args:
+        beta (float, optional): The threshold in the piecewise function.
+            Defaults to 1.0.
+        reduction (str, optional): The method to reduce the loss.
+            Options are "none", "mean" and "sum". Defaults to "mean".
+        loss_weight (float, optional): The weight of loss.
+    """
+
+    def __init__(self,
+                 beta: float = 1.0,
+                 reduction: str = 'mean',
+                 loss_weight: float = 1.0) -> None:
+        super().__init__()
+        self.beta = beta
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+
+    def forward(self,
+                pred: Tensor,
+                target: Tensor,
+                weight: Optional[Tensor] = None,
+                avg_factor: Optional[int] = None,
+                reduction_override: Optional[str] = None,
+                **kwargs) -> Tensor:
+        """Forward function.
+
+        Args:
+            pred (Tensor): The prediction.
+            target (Tensor): The learning target of the prediction.
+            weight (Tensor, optional): The weight of loss for each
+                prediction. Defaults to None.
+            avg_factor (int, optional): Average factor that is used to average
+                the loss. Defaults to None.
+            reduction_override (str, optional): The reduction method used to
+                override the original reduction method of the loss.
+                Defaults to None.
+
+        Returns:
+            Tensor: Calculated loss
+        """
+        if weight is not None and not torch.any(weight > 0):
+            if pred.dim() == weight.dim() + 1:
+                weight = weight.unsqueeze(1)
+            return (pred * weight).sum()
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        loss_bbox = self.loss_weight * smooth_l1_loss(
+            pred,
+            target,
+            weight,
+            beta=self.beta,
+            reduction=reduction,
+            avg_factor=avg_factor,
+            **kwargs)
+        return loss_bbox
+
+
+@MODELS.register_module()
+class L1Loss(nn.Module):
+    """L1 loss.
+
+    Args:
+        reduction (str, optional): The method to reduce the loss.
+            Options are "none", "mean" and "sum".
+        loss_weight (float, optional): The weight of loss.
+    """
+
+    def __init__(self,
+                 reduction: str = 'mean',
+                 loss_weight: float = 1.0) -> None:
+        super().__init__()
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+
+    def forward(self,
+                pred: Tensor,
+                target: Tensor,
+                weight: Optional[Tensor] = None,
+                avg_factor: Optional[int] = None,
+                reduction_override: Optional[str] = None) -> Tensor:
+        """Forward function.
+
+        Args:
+            pred (Tensor): The prediction.
+            target (Tensor): The learning target of the prediction.
+            weight (Tensor, optional): The weight of loss for each
+                prediction. Defaults to None.
+            avg_factor (int, optional): Average factor that is used to average
+                the loss. Defaults to None.
+            reduction_override (str, optional): The reduction method used to
+                override the original reduction method of the loss.
+                Defaults to None.
+
+        Returns:
+            Tensor: Calculated loss
+        """
+        if weight is not None and not torch.any(weight > 0):
+            if pred.dim() == weight.dim() + 1:
+                weight = weight.unsqueeze(1)
+            return (pred * weight).sum()
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        loss_bbox = self.loss_weight * l1_loss(
+            pred, target, weight, reduction=reduction, avg_factor=avg_factor)
+        return loss_bbox
diff --git a/mmdetection/mmdet/models/losses/triplet_loss.py b/mmdetection/mmdet/models/losses/triplet_loss.py
new file mode 100644
index 00000000..4528239b
--- /dev/null
+++ b/mmdetection/mmdet/models/losses/triplet_loss.py
@@ -0,0 +1,88 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmengine.model import BaseModule
+
+from mmdet.registry import MODELS
+
+
+@MODELS.register_module()
+class TripletLoss(BaseModule):
+    """Triplet loss with hard positive/negative mining.
+
+    Reference:
+        Hermans et al. In Defense of the Triplet Loss for
+            Person Re-Identification. arXiv:1703.07737.
+    Imported from ``_.
+    Args:
+        margin (float, optional): Margin for triplet loss. Defaults to 0.3.
+        loss_weight (float, optional): Weight of the loss. Defaults to 1.0.
+        hard_mining (bool, optional): Whether to perform hard mining.
+            Defaults to True.
+    """
+
+    def __init__(self,
+                 margin: float = 0.3,
+                 loss_weight: float = 1.0,
+                 hard_mining=True):
+        super(TripletLoss, self).__init__()
+        self.margin = margin
+        self.ranking_loss = nn.MarginRankingLoss(margin=margin)
+        self.loss_weight = loss_weight
+        self.hard_mining = hard_mining
+
+    def hard_mining_triplet_loss_forward(
+            self, inputs: torch.Tensor,
+            targets: torch.LongTensor) -> torch.Tensor:
+        """
+        Args:
+            inputs (torch.Tensor): feature matrix with shape
+                (batch_size, feat_dim).
+            targets (torch.LongTensor): ground truth labels with shape
+                (batch_size).
+
+        Returns:
+            torch.Tensor: triplet loss with hard mining.
+        """
+
+        batch_size = inputs.size(0)
+
+        # Compute Euclidean distance
+        dist = torch.pow(inputs, 2).sum(
+            dim=1, keepdim=True).expand(batch_size, batch_size)
+        dist = dist + dist.t()
+        dist.addmm_(inputs, inputs.t(), beta=1, alpha=-2)
+        dist = dist.clamp(min=1e-12).sqrt()  # for numerical stability
+
+        # For each anchor, find the furthest positive sample
+        # and nearest negative sample in the embedding space
+        mask = targets.expand(batch_size, batch_size).eq(
+            targets.expand(batch_size, batch_size).t())
+        dist_ap, dist_an = [], []
+        for i in range(batch_size):
+            dist_ap.append(dist[i][mask[i]].max().unsqueeze(0))
+            dist_an.append(dist[i][mask[i] == 0].min().unsqueeze(0))
+        dist_ap = torch.cat(dist_ap)
+        dist_an = torch.cat(dist_an)
+
+        # Compute ranking hinge loss
+        y = torch.ones_like(dist_an)
+        return self.loss_weight * self.ranking_loss(dist_an, dist_ap, y)
+
+    def forward(self, inputs: torch.Tensor,
+                targets: torch.LongTensor) -> torch.Tensor:
+        """
+        Args:
+            inputs (torch.Tensor): feature matrix with shape
+                (batch_size, feat_dim).
+            targets (torch.LongTensor): ground truth labels with shape
+                (num_classes).
+
+        Returns:
+            torch.Tensor: triplet loss.
+        """
+        if self.hard_mining:
+            return self.hard_mining_triplet_loss_forward(inputs, targets)
+        else:
+            raise NotImplementedError()
diff --git a/mmdetection/mmdet/models/losses/utils.py b/mmdetection/mmdet/models/losses/utils.py
new file mode 100644
index 00000000..5e6e7859
--- /dev/null
+++ b/mmdetection/mmdet/models/losses/utils.py
@@ -0,0 +1,125 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import functools
+from typing import Callable, Optional
+
+import torch
+import torch.nn.functional as F
+from torch import Tensor
+
+
+def reduce_loss(loss: Tensor, reduction: str) -> Tensor:
+    """Reduce loss as specified.
+
+    Args:
+        loss (Tensor): Elementwise loss tensor.
+        reduction (str): Options are "none", "mean" and "sum".
+
+    Return:
+        Tensor: Reduced loss tensor.
+    """
+    reduction_enum = F._Reduction.get_enum(reduction)
+    # none: 0, elementwise_mean:1, sum: 2
+    if reduction_enum == 0:
+        return loss
+    elif reduction_enum == 1:
+        return loss.mean()
+    elif reduction_enum == 2:
+        return loss.sum()
+
+
+def weight_reduce_loss(loss: Tensor,
+                       weight: Optional[Tensor] = None,
+                       reduction: str = 'mean',
+                       avg_factor: Optional[float] = None) -> Tensor:
+    """Apply element-wise weight and reduce loss.
+
+    Args:
+        loss (Tensor): Element-wise loss.
+        weight (Optional[Tensor], optional): Element-wise weights.
+            Defaults to None.
+        reduction (str, optional): Same as built-in losses of PyTorch.
+            Defaults to 'mean'.
+        avg_factor (Optional[float], optional): Average factor when
+            computing the mean of losses. Defaults to None.
+
+    Returns:
+        Tensor: Processed loss values.
+    """
+    # if weight is specified, apply element-wise weight
+    if weight is not None:
+        loss = loss * weight
+
+    # if avg_factor is not specified, just reduce the loss
+    if avg_factor is None:
+        loss = reduce_loss(loss, reduction)
+    else:
+        # if reduction is mean, then average the loss by avg_factor
+        if reduction == 'mean':
+            # Avoid causing ZeroDivisionError when avg_factor is 0.0,
+            # i.e., all labels of an image belong to ignore index.
+            eps = torch.finfo(torch.float32).eps
+            loss = loss.sum() / (avg_factor + eps)
+        # if reduction is 'none', then do nothing, otherwise raise an error
+        elif reduction != 'none':
+            raise ValueError('avg_factor can not be used with reduction="sum"')
+    return loss
+
+
+def weighted_loss(loss_func: Callable) -> Callable:
+    """Create a weighted version of a given loss function.
+
+    To use this decorator, the loss function must have the signature like
+    `loss_func(pred, target, **kwargs)`. The function only needs to compute
+    element-wise loss without any reduction. This decorator will add weight
+    and reduction arguments to the function. The decorated function will have
+    the signature like `loss_func(pred, target, weight=None, reduction='mean',
+    avg_factor=None, **kwargs)`.
+
+    :Example:
+
+    >>> import torch
+    >>> @weighted_loss
+    >>> def l1_loss(pred, target):
+    >>>     return (pred - target).abs()
+
+    >>> pred = torch.Tensor([0, 2, 3])
+    >>> target = torch.Tensor([1, 1, 1])
+    >>> weight = torch.Tensor([1, 0, 1])
+
+    >>> l1_loss(pred, target)
+    tensor(1.3333)
+    >>> l1_loss(pred, target, weight)
+    tensor(1.)
+    >>> l1_loss(pred, target, reduction='none')
+    tensor([1., 1., 2.])
+    >>> l1_loss(pred, target, weight, avg_factor=2)
+    tensor(1.5000)
+    """
+
+    @functools.wraps(loss_func)
+    def wrapper(pred: Tensor,
+                target: Tensor,
+                weight: Optional[Tensor] = None,
+                reduction: str = 'mean',
+                avg_factor: Optional[int] = None,
+                **kwargs) -> Tensor:
+        """
+        Args:
+            pred (Tensor): The prediction.
+            target (Tensor): Target bboxes.
+            weight (Optional[Tensor], optional): The weight of loss for each
+                prediction. Defaults to None.
+            reduction (str, optional): Options are "none", "mean" and "sum".
+                Defaults to 'mean'.
+            avg_factor (Optional[int], optional): Average factor that is used
+                to average the loss. Defaults to None.
+
+        Returns:
+            Tensor: Loss tensor.
+        """
+        # get element-wise loss
+        loss = loss_func(pred, target, **kwargs)
+        loss = weight_reduce_loss(loss, weight, reduction, avg_factor)
+        return loss
+
+    return wrapper
diff --git a/mmdetection/mmdet/models/losses/varifocal_loss.py b/mmdetection/mmdet/models/losses/varifocal_loss.py
new file mode 100644
index 00000000..58ab1673
--- /dev/null
+++ b/mmdetection/mmdet/models/losses/varifocal_loss.py
@@ -0,0 +1,141 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional
+
+import torch.nn as nn
+import torch.nn.functional as F
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from .utils import weight_reduce_loss
+
+
+def varifocal_loss(pred: Tensor,
+                   target: Tensor,
+                   weight: Optional[Tensor] = None,
+                   alpha: float = 0.75,
+                   gamma: float = 2.0,
+                   iou_weighted: bool = True,
+                   reduction: str = 'mean',
+                   avg_factor: Optional[int] = None) -> Tensor:
+    """`Varifocal Loss `_
+
+    Args:
+        pred (Tensor): The prediction with shape (N, C), C is the
+            number of classes.
+        target (Tensor): The learning target of the iou-aware
+            classification score with shape (N, C), C is the number of classes.
+        weight (Tensor, optional): The weight of loss for each
+            prediction. Defaults to None.
+        alpha (float, optional): A balance factor for the negative part of
+            Varifocal Loss, which is different from the alpha of Focal Loss.
+            Defaults to 0.75.
+        gamma (float, optional): The gamma for calculating the modulating
+            factor. Defaults to 2.0.
+        iou_weighted (bool, optional): Whether to weight the loss of the
+            positive example with the iou target. Defaults to True.
+        reduction (str, optional): The method used to reduce the loss into
+            a scalar. Defaults to 'mean'. Options are "none", "mean" and
+            "sum".
+        avg_factor (int, optional): Average factor that is used to average
+            the loss. Defaults to None.
+
+    Returns:
+        Tensor: Loss tensor.
+    """
+    # pred and target should be of the same size
+    assert pred.size() == target.size()
+    pred_sigmoid = pred.sigmoid()
+    target = target.type_as(pred)
+    if iou_weighted:
+        focal_weight = target * (target > 0.0).float() + \
+            alpha * (pred_sigmoid - target).abs().pow(gamma) * \
+            (target <= 0.0).float()
+    else:
+        focal_weight = (target > 0.0).float() + \
+            alpha * (pred_sigmoid - target).abs().pow(gamma) * \
+            (target <= 0.0).float()
+    loss = F.binary_cross_entropy_with_logits(
+        pred, target, reduction='none') * focal_weight
+    loss = weight_reduce_loss(loss, weight, reduction, avg_factor)
+    return loss
+
+
+@MODELS.register_module()
+class VarifocalLoss(nn.Module):
+
+    def __init__(self,
+                 use_sigmoid: bool = True,
+                 alpha: float = 0.75,
+                 gamma: float = 2.0,
+                 iou_weighted: bool = True,
+                 reduction: str = 'mean',
+                 loss_weight: float = 1.0) -> None:
+        """`Varifocal Loss `_
+
+        Args:
+            use_sigmoid (bool, optional): Whether the prediction is
+                used for sigmoid or softmax. Defaults to True.
+            alpha (float, optional): A balance factor for the negative part of
+                Varifocal Loss, which is different from the alpha of Focal
+                Loss. Defaults to 0.75.
+            gamma (float, optional): The gamma for calculating the modulating
+                factor. Defaults to 2.0.
+            iou_weighted (bool, optional): Whether to weight the loss of the
+                positive examples with the iou target. Defaults to True.
+            reduction (str, optional): The method used to reduce the loss into
+                a scalar. Defaults to 'mean'. Options are "none", "mean" and
+                "sum".
+            loss_weight (float, optional): Weight of loss. Defaults to 1.0.
+        """
+        super().__init__()
+        assert use_sigmoid is True, \
+            'Only sigmoid varifocal loss supported now.'
+        assert alpha >= 0.0
+        self.use_sigmoid = use_sigmoid
+        self.alpha = alpha
+        self.gamma = gamma
+        self.iou_weighted = iou_weighted
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+
+    def forward(self,
+                pred: Tensor,
+                target: Tensor,
+                weight: Optional[Tensor] = None,
+                avg_factor: Optional[int] = None,
+                reduction_override: Optional[str] = None) -> Tensor:
+        """Forward function.
+
+        Args:
+            pred (Tensor): The prediction with shape (N, C), C is the
+                number of classes.
+            target (Tensor): The learning target of the iou-aware
+                classification score with shape (N, C), C is
+                the number of classes.
+            weight (Tensor, optional): The weight of loss for each
+                prediction. Defaults to None.
+            avg_factor (int, optional): Average factor that is used to average
+                the loss. Defaults to None.
+            reduction_override (str, optional): The reduction method used to
+                override the original reduction method of the loss.
+                Options are "none", "mean" and "sum".
+
+        Returns:
+            Tensor: The calculated loss
+        """
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        if self.use_sigmoid:
+            loss_cls = self.loss_weight * varifocal_loss(
+                pred,
+                target,
+                weight,
+                alpha=self.alpha,
+                gamma=self.gamma,
+                iou_weighted=self.iou_weighted,
+                reduction=reduction,
+                avg_factor=avg_factor)
+        else:
+            raise NotImplementedError
+        return loss_cls
diff --git a/mmdetection/mmdet/models/mot/__init__.py b/mmdetection/mmdet/models/mot/__init__.py
new file mode 100644
index 00000000..1bd3c8d3
--- /dev/null
+++ b/mmdetection/mmdet/models/mot/__init__.py
@@ -0,0 +1,11 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .base import BaseMOTModel
+from .bytetrack import ByteTrack
+from .deep_sort import DeepSORT
+from .ocsort import OCSORT
+from .qdtrack import QDTrack
+from .strongsort import StrongSORT
+
+__all__ = [
+    'BaseMOTModel', 'ByteTrack', 'QDTrack', 'DeepSORT', 'StrongSORT', 'OCSORT'
+]
diff --git a/mmdetection/mmdet/models/mot/base.py b/mmdetection/mmdet/models/mot/base.py
new file mode 100644
index 00000000..99814179
--- /dev/null
+++ b/mmdetection/mmdet/models/mot/base.py
@@ -0,0 +1,147 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from abc import ABCMeta, abstractmethod
+from typing import Dict, List, Tuple, Union
+
+from mmengine.model import BaseModel
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import OptTrackSampleList, TrackSampleList
+from mmdet.utils import OptConfigType, OptMultiConfig
+
+
+@MODELS.register_module()
+class BaseMOTModel(BaseModel, metaclass=ABCMeta):
+    """Base class for multiple object tracking.
+
+    Args:
+        data_preprocessor (dict or ConfigDict, optional): The pre-process
+           config of :class:`TrackDataPreprocessor`.  it usually includes,
+            ``pad_size_divisor``, ``pad_value``, ``mean`` and ``std``.
+        init_cfg (dict or list[dict]): Initialization config dict.
+    """
+
+    def __init__(self,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            data_preprocessor=data_preprocessor, init_cfg=init_cfg)
+
+    def freeze_module(self, module: Union[List[str], Tuple[str], str]) -> None:
+        """Freeze module during training."""
+        if isinstance(module, str):
+            modules = [module]
+        else:
+            if not (isinstance(module, list) or isinstance(module, tuple)):
+                raise TypeError('module must be a str or a list.')
+            else:
+                modules = module
+        for module in modules:
+            m = getattr(self, module)
+            m.eval()
+            for param in m.parameters():
+                param.requires_grad = False
+
+    @property
+    def with_detector(self) -> bool:
+        """bool: whether the framework has a detector."""
+        return hasattr(self, 'detector') and self.detector is not None
+
+    @property
+    def with_reid(self) -> bool:
+        """bool: whether the framework has a reid model."""
+        return hasattr(self, 'reid') and self.reid is not None
+
+    @property
+    def with_motion(self) -> bool:
+        """bool: whether the framework has a motion model."""
+        return hasattr(self, 'motion') and self.motion is not None
+
+    @property
+    def with_track_head(self) -> bool:
+        """bool: whether the framework has a track_head."""
+        return hasattr(self, 'track_head') and self.track_head is not None
+
+    @property
+    def with_tracker(self) -> bool:
+        """bool: whether the framework has a tracker."""
+        return hasattr(self, 'tracker') and self.tracker is not None
+
+    def forward(self,
+                inputs: Dict[str, Tensor],
+                data_samples: OptTrackSampleList = None,
+                mode: str = 'predict',
+                **kwargs):
+        """The unified entry for a forward process in both training and test.
+
+        The method should accept three modes: "tensor", "predict" and "loss":
+
+        - "tensor": Forward the whole network and return tensor or tuple of
+        tensor without any post-processing, same as a common nn.Module.
+        - "predict": Forward and return the predictions, which are fully
+        processed to a list of :obj:`TrackDataSample`.
+        - "loss": Forward and return a dict of losses according to the given
+        inputs and data samples.
+
+        Note that this method doesn't handle neither back propagation nor
+        optimizer updating, which are done in the :meth:`train_step`.
+
+        Args:
+            inputs (Dict[str, Tensor]): of shape (N, T, C, H, W)
+                encoding input images. Typically these should be mean centered
+                and std scaled. The N denotes batch size. The T denotes the
+                number of key/reference frames.
+                - img (Tensor) : The key images.
+                - ref_img (Tensor): The reference images.
+            data_samples (list[:obj:`TrackDataSample`], optional): The
+                annotation data of every samples. Defaults to None.
+            mode (str): Return what kind of value. Defaults to 'predict'.
+
+        Returns:
+            The return type depends on ``mode``.
+
+            - If ``mode="tensor"``, return a tensor or a tuple of tensor.
+            - If ``mode="predict"``, return a list of :obj:`TrackDataSample`.
+            - If ``mode="loss"``, return a dict of tensor.
+        """
+        if mode == 'loss':
+            return self.loss(inputs, data_samples, **kwargs)
+        elif mode == 'predict':
+            return self.predict(inputs, data_samples, **kwargs)
+        elif mode == 'tensor':
+            return self._forward(inputs, data_samples, **kwargs)
+        else:
+            raise RuntimeError(f'Invalid mode "{mode}". '
+                               'Only supports loss, predict and tensor mode')
+
+    @abstractmethod
+    def loss(self, inputs: Dict[str, Tensor], data_samples: TrackSampleList,
+             **kwargs) -> Union[dict, tuple]:
+        """Calculate losses from a batch of inputs and data samples."""
+        pass
+
+    @abstractmethod
+    def predict(self, inputs: Dict[str, Tensor], data_samples: TrackSampleList,
+                **kwargs) -> TrackSampleList:
+        """Predict results from a batch of inputs and data samples with post-
+        processing."""
+        pass
+
+    def _forward(self,
+                 inputs: Dict[str, Tensor],
+                 data_samples: OptTrackSampleList = None,
+                 **kwargs):
+        """Network forward process. Usually includes backbone, neck and head
+        forward without any post-processing.
+
+         Args:
+            inputs (Dict[str, Tensor]): of shape (N, T, C, H, W).
+            data_samples (List[:obj:`TrackDataSample`], optional): The
+                Data Samples. It usually includes information such as
+                `gt_instance`.
+
+        Returns:
+            tuple[list]: A tuple of features from ``head`` forward.
+        """
+        raise NotImplementedError(
+            "_forward function (namely 'tensor' mode) is not supported now")
diff --git a/mmdetection/mmdet/models/mot/bytetrack.py b/mmdetection/mmdet/models/mot/bytetrack.py
new file mode 100644
index 00000000..8a3bb867
--- /dev/null
+++ b/mmdetection/mmdet/models/mot/bytetrack.py
@@ -0,0 +1,94 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, Optional
+
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList, TrackSampleList
+from mmdet.utils import OptConfigType, OptMultiConfig
+from .base import BaseMOTModel
+
+
+@MODELS.register_module()
+class ByteTrack(BaseMOTModel):
+    """ByteTrack: Multi-Object Tracking by Associating Every Detection Box.
+
+    This multi object tracker is the implementation of `ByteTrack
+    `_.
+
+    Args:
+        detector (dict): Configuration of detector. Defaults to None.
+        tracker (dict): Configuration of tracker. Defaults to None.
+        data_preprocessor (dict or ConfigDict, optional): The pre-process
+           config of :class:`TrackDataPreprocessor`.  it usually includes,
+            ``pad_size_divisor``, ``pad_value``, ``mean`` and ``std``.
+        init_cfg (dict or list[dict]): Configuration of initialization.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 detector: Optional[dict] = None,
+                 tracker: Optional[dict] = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None):
+        super().__init__(data_preprocessor, init_cfg)
+
+        if detector is not None:
+            self.detector = MODELS.build(detector)
+
+        if tracker is not None:
+            self.tracker = MODELS.build(tracker)
+
+    def loss(self, inputs: Tensor, data_samples: SampleList, **kwargs) -> dict:
+        """Calculate losses from a batch of inputs and data samples.
+
+        Args:
+            inputs (Tensor): of shape (N, C, H, W) encoding
+                input images. Typically these should be mean centered and std
+                scaled. The N denotes batch size
+            data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance`.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        return self.detector.loss(inputs, data_samples, **kwargs)
+
+    def predict(self, inputs: Dict[str, Tensor], data_samples: TrackSampleList,
+                **kwargs) -> TrackSampleList:
+        """Predict results from a video and data samples with post-processing.
+
+        Args:
+            inputs (Tensor): of shape (N, T, C, H, W) encoding
+                input images. The N denotes batch size.
+                The T denotes the number of frames in a video.
+            data_samples (list[:obj:`TrackDataSample`]): The batch
+                data samples. It usually includes information such
+                as `video_data_samples`.
+        Returns:
+            TrackSampleList: Tracking results of the inputs.
+        """
+        assert inputs.dim() == 5, 'The img must be 5D Tensor (N, T, C, H, W).'
+        assert inputs.size(0) == 1, \
+            'Bytetrack inference only support ' \
+            '1 batch size per gpu for now.'
+
+        assert len(data_samples) == 1, \
+            'Bytetrack inference only support 1 batch size per gpu for now.'
+
+        track_data_sample = data_samples[0]
+        video_len = len(track_data_sample)
+
+        for frame_id in range(video_len):
+            img_data_sample = track_data_sample[frame_id]
+            single_img = inputs[:, frame_id].contiguous()
+            # det_results List[DetDataSample]
+            det_results = self.detector.predict(single_img, [img_data_sample])
+            assert len(det_results) == 1, 'Batch inference is not supported.'
+
+            pred_track_instances = self.tracker.track(
+                data_sample=det_results[0], **kwargs)
+            img_data_sample.pred_track_instances = pred_track_instances
+
+        return [track_data_sample]
diff --git a/mmdetection/mmdet/models/mot/deep_sort.py b/mmdetection/mmdet/models/mot/deep_sort.py
new file mode 100644
index 00000000..70b30c7b
--- /dev/null
+++ b/mmdetection/mmdet/models/mot/deep_sort.py
@@ -0,0 +1,110 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional
+
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import TrackSampleList
+from mmdet.utils import OptConfigType
+from .base import BaseMOTModel
+
+
+@MODELS.register_module()
+class DeepSORT(BaseMOTModel):
+    """Simple online and realtime tracking with a deep association metric.
+
+    Details can be found at `DeepSORT`_.
+
+    Args:
+        detector (dict): Configuration of detector. Defaults to None.
+        reid (dict): Configuration of reid. Defaults to None
+        tracker (dict): Configuration of tracker. Defaults to None.
+        data_preprocessor (dict or ConfigDict, optional): The pre-process
+           config of :class:`TrackDataPreprocessor`.  it usually includes,
+            ``pad_size_divisor``, ``pad_value``, ``mean`` and ``std``.
+        init_cfg (dict or list[dict]): Configuration of initialization.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 detector: Optional[dict] = None,
+                 reid: Optional[dict] = None,
+                 tracker: Optional[dict] = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptConfigType = None):
+        super().__init__(data_preprocessor, init_cfg)
+
+        if detector is not None:
+            self.detector = MODELS.build(detector)
+
+        if reid is not None:
+            self.reid = MODELS.build(reid)
+
+        if tracker is not None:
+            self.tracker = MODELS.build(tracker)
+
+        self.preprocess_cfg = data_preprocessor
+
+    def loss(self, inputs: Tensor, data_samples: TrackSampleList,
+             **kwargs) -> dict:
+        """Calculate losses from a batch of inputs and data samples."""
+        raise NotImplementedError(
+            'Please train `detector` and `reid` models firstly, then \
+                inference with SORT/DeepSORT.')
+
+    def predict(self,
+                inputs: Tensor,
+                data_samples: TrackSampleList,
+                rescale: bool = True,
+                **kwargs) -> TrackSampleList:
+        """Predict results from a video and data samples with post- processing.
+
+        Args:
+            inputs (Tensor): of shape (N, T, C, H, W) encoding
+                input images. The N denotes batch size.
+                The T denotes the number of key frames
+                and reference frames.
+            data_samples (list[:obj:`TrackDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance`.
+            rescale (bool, Optional): If False, then returned bboxes and masks
+                will fit the scale of img, otherwise, returned bboxes and masks
+                will fit the scale of original image shape. Defaults to True.
+
+        Returns:
+            TrackSampleList: List[TrackDataSample]
+            Tracking results of the input videos.
+            Each DetDataSample usually contains ``pred_track_instances``.
+        """
+        assert inputs.dim() == 5, 'The img must be 5D Tensor (N, T, C, H, W).'
+        assert inputs.size(0) == 1, \
+            'SORT/DeepSORT inference only support ' \
+            '1 batch size per gpu for now.'
+
+        assert len(data_samples) == 1, \
+            'SORT/DeepSORT inference only support ' \
+            '1 batch size per gpu for now.'
+
+        track_data_sample = data_samples[0]
+        video_len = len(track_data_sample)
+        if track_data_sample[0].frame_id == 0:
+            self.tracker.reset()
+
+        for frame_id in range(video_len):
+            img_data_sample = track_data_sample[frame_id]
+            single_img = inputs[:, frame_id].contiguous()
+            # det_results List[DetDataSample]
+            det_results = self.detector.predict(single_img, [img_data_sample])
+            assert len(det_results) == 1, 'Batch inference is not supported.'
+
+            pred_track_instances = self.tracker.track(
+                model=self,
+                img=single_img,
+                feats=None,
+                data_sample=det_results[0],
+                data_preprocessor=self.preprocess_cfg,
+                rescale=rescale,
+                **kwargs)
+            img_data_sample.pred_track_instances = pred_track_instances
+
+        return [track_data_sample]
diff --git a/mmdetection/mmdet/models/mot/ocsort.py b/mmdetection/mmdet/models/mot/ocsort.py
new file mode 100644
index 00000000..abf4eb3b
--- /dev/null
+++ b/mmdetection/mmdet/models/mot/ocsort.py
@@ -0,0 +1,82 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+from typing import Dict, Optional
+
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import TrackSampleList
+from mmdet.utils import OptConfigType, OptMultiConfig
+from .base import BaseMOTModel
+
+
+@MODELS.register_module()
+class OCSORT(BaseMOTModel):
+    """OCOSRT: Observation-Centric SORT: Rethinking SORT for Robust
+    Multi-Object Tracking
+
+    This multi object tracker is the implementation of `OC-SORT
+    `_.
+
+    Args:
+        detector (dict): Configuration of detector. Defaults to None.
+        tracker (dict): Configuration of tracker. Defaults to None.
+        motion (dict): Configuration of motion. Defaults to None.
+        init_cfg (dict): Configuration of initialization. Defaults to None.
+    """
+
+    def __init__(self,
+                 detector: Optional[dict] = None,
+                 tracker: Optional[dict] = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None):
+        super().__init__(data_preprocessor, init_cfg)
+
+        if detector is not None:
+            self.detector = MODELS.build(detector)
+
+        if tracker is not None:
+            self.tracker = MODELS.build(tracker)
+
+    def loss(self, inputs: Tensor, data_samples: TrackSampleList,
+             **kwargs) -> dict:
+        """Calculate losses from a batch of inputs and data samples."""
+        return self.detector.loss(inputs, data_samples, **kwargs)
+
+    def predict(self, inputs: Dict[str, Tensor], data_samples: TrackSampleList,
+                **kwargs) -> TrackSampleList:
+        """Predict results from a video and data samples with post-processing.
+
+        Args:
+            inputs (Tensor): of shape (N, T, C, H, W) encoding
+                input images. The N denotes batch size.
+                The T denotes the number of frames in a video.
+            data_samples (list[:obj:`TrackDataSample`]): The batch
+                data samples. It usually includes information such
+                as `video_data_samples`.
+        Returns:
+            TrackSampleList: Tracking results of the inputs.
+        """
+        assert inputs.dim() == 5, 'The img must be 5D Tensor (N, T, C, H, W).'
+        assert inputs.size(0) == 1, \
+            'OCSORT inference only support ' \
+            '1 batch size per gpu for now.'
+
+        assert len(data_samples) == 1, \
+            'OCSORT inference only support 1 batch size per gpu for now.'
+
+        track_data_sample = data_samples[0]
+        video_len = len(track_data_sample)
+
+        for frame_id in range(video_len):
+            img_data_sample = track_data_sample[frame_id]
+            single_img = inputs[:, frame_id].contiguous()
+            # det_results List[DetDataSample]
+            det_results = self.detector.predict(single_img, [img_data_sample])
+            assert len(det_results) == 1, 'Batch inference is not supported.'
+
+            pred_track_instances = self.tracker.track(
+                data_sample=det_results[0], **kwargs)
+            img_data_sample.pred_track_instances = pred_track_instances
+
+        return [track_data_sample]
diff --git a/mmdetection/mmdet/models/mot/qdtrack.py b/mmdetection/mmdet/models/mot/qdtrack.py
new file mode 100644
index 00000000..43d5dd60
--- /dev/null
+++ b/mmdetection/mmdet/models/mot/qdtrack.py
@@ -0,0 +1,186 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Union
+
+import torch
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import TrackSampleList
+from mmdet.utils import OptConfigType, OptMultiConfig
+from .base import BaseMOTModel
+
+
+@MODELS.register_module()
+class QDTrack(BaseMOTModel):
+    """Quasi-Dense Similarity Learning for Multiple Object Tracking.
+
+    This multi object tracker is the implementation of `QDTrack
+    `_.
+
+    Args:
+        detector (dict): Configuration of detector. Defaults to None.
+        track_head (dict): Configuration of track head. Defaults to None.
+        tracker (dict): Configuration of tracker. Defaults to None.
+        freeze_detector (bool): If True, freeze the detector weights.
+            Defaults to False.
+        data_preprocessor (dict or ConfigDict, optional): The pre-process
+           config of :class:`TrackDataPreprocessor`.  it usually includes,
+            ``pad_size_divisor``, ``pad_value``, ``mean`` and ``std``.
+        init_cfg (dict or list[dict]): Configuration of initialization.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 detector: Optional[dict] = None,
+                 track_head: Optional[dict] = None,
+                 tracker: Optional[dict] = None,
+                 freeze_detector: bool = False,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None):
+        super().__init__(data_preprocessor, init_cfg)
+        if detector is not None:
+            self.detector = MODELS.build(detector)
+
+        if track_head is not None:
+            self.track_head = MODELS.build(track_head)
+
+        if tracker is not None:
+            self.tracker = MODELS.build(tracker)
+
+        self.freeze_detector = freeze_detector
+        if self.freeze_detector:
+            self.freeze_module('detector')
+
+    def predict(self,
+                inputs: Tensor,
+                data_samples: TrackSampleList,
+                rescale: bool = True,
+                **kwargs) -> TrackSampleList:
+        """Predict results from a video and data samples with post- processing.
+
+        Args:
+            inputs (Tensor): of shape (N, T, C, H, W) encoding
+                input images. The N denotes batch size.
+                The T denotes the number of frames in a video.
+            data_samples (list[:obj:`TrackDataSample`]): The batch
+                data samples. It usually includes information such
+                as `video_data_samples`.
+            rescale (bool, Optional): If False, then returned bboxes and masks
+                will fit the scale of img, otherwise, returned bboxes and masks
+                will fit the scale of original image shape. Defaults to True.
+
+        Returns:
+            TrackSampleList: Tracking results of the inputs.
+        """
+        assert inputs.dim() == 5, 'The img must be 5D Tensor (N, T, C, H, W).'
+        assert inputs.size(0) == 1, \
+            'QDTrack inference only support 1 batch size per gpu for now.'
+
+        assert len(data_samples) == 1, \
+            'QDTrack only support 1 batch size per gpu for now.'
+
+        track_data_sample = data_samples[0]
+        video_len = len(track_data_sample)
+        if track_data_sample[0].frame_id == 0:
+            self.tracker.reset()
+
+        for frame_id in range(video_len):
+            img_data_sample = track_data_sample[frame_id]
+            single_img = inputs[:, frame_id].contiguous()
+            x = self.detector.extract_feat(single_img)
+            rpn_results_list = self.detector.rpn_head.predict(
+                x, [img_data_sample])
+            # det_results List[InstanceData]
+            det_results = self.detector.roi_head.predict(
+                x, rpn_results_list, [img_data_sample], rescale=rescale)
+            assert len(det_results) == 1, 'Batch inference is not supported.'
+            img_data_sample.pred_instances = det_results[0]
+            frame_pred_track_instances = self.tracker.track(
+                model=self,
+                img=single_img,
+                feats=x,
+                data_sample=img_data_sample,
+                **kwargs)
+            img_data_sample.pred_track_instances = frame_pred_track_instances
+
+        return [track_data_sample]
+
+    def loss(self, inputs: Tensor, data_samples: TrackSampleList,
+             **kwargs) -> Union[dict, tuple]:
+        """Calculate losses from a batch of inputs and data samples.
+
+        Args:
+            inputs (Dict[str, Tensor]): of shape (N, T, C, H, W) encoding
+                input images. Typically these should be mean centered and std
+                scaled. The N denotes batch size. The T denotes the number of
+                frames.
+            data_samples (list[:obj:`TrackDataSample`]): The batch
+                data samples. It usually includes information such
+                as `video_data_samples`.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        # modify the inputs shape to fit mmdet
+        assert inputs.dim() == 5, 'The img must be 5D Tensor (N, T, C, H, W).'
+        assert inputs.size(1) == 2, \
+            'QDTrack can only have 1 key frame and 1 reference frame.'
+
+        # split the data_samples into two aspects: key frames and reference
+        # frames
+        ref_data_samples, key_data_samples = [], []
+        key_frame_inds, ref_frame_inds = [], []
+        # set cat_id of gt_labels to 0 in RPN
+        for track_data_sample in data_samples:
+            key_frame_inds.append(track_data_sample.key_frames_inds[0])
+            ref_frame_inds.append(track_data_sample.ref_frames_inds[0])
+            key_data_sample = track_data_sample.get_key_frames()[0]
+            key_data_sample.gt_instances.labels = \
+                torch.zeros_like(key_data_sample.gt_instances.labels)
+            key_data_samples.append(key_data_sample)
+            ref_data_sample = track_data_sample.get_ref_frames()[0]
+            ref_data_samples.append(ref_data_sample)
+
+        key_frame_inds = torch.tensor(key_frame_inds, dtype=torch.int64)
+        ref_frame_inds = torch.tensor(ref_frame_inds, dtype=torch.int64)
+        batch_inds = torch.arange(len(inputs))
+        key_imgs = inputs[batch_inds, key_frame_inds].contiguous()
+        ref_imgs = inputs[batch_inds, ref_frame_inds].contiguous()
+
+        x = self.detector.extract_feat(key_imgs)
+        ref_x = self.detector.extract_feat(ref_imgs)
+
+        losses = dict()
+        # RPN head forward and loss
+        assert self.detector.with_rpn, \
+            'QDTrack only support detector with RPN.'
+
+        proposal_cfg = self.detector.train_cfg.get('rpn_proposal',
+                                                   self.detector.test_cfg.rpn)
+        rpn_losses, rpn_results_list = self.detector.rpn_head. \
+            loss_and_predict(x,
+                             key_data_samples,
+                             proposal_cfg=proposal_cfg,
+                             **kwargs)
+        ref_rpn_results_list = self.detector.rpn_head.predict(
+            ref_x, ref_data_samples, **kwargs)
+
+        # avoid get same name with roi_head loss
+        keys = rpn_losses.keys()
+        for key in keys:
+            if 'loss' in key and 'rpn' not in key:
+                rpn_losses[f'rpn_{key}'] = rpn_losses.pop(key)
+        losses.update(rpn_losses)
+
+        # roi_head loss
+        losses_detect = self.detector.roi_head.loss(x, rpn_results_list,
+                                                    key_data_samples, **kwargs)
+        losses.update(losses_detect)
+
+        # tracking head loss
+        losses_track = self.track_head.loss(x, ref_x, rpn_results_list,
+                                            ref_rpn_results_list, data_samples,
+                                            **kwargs)
+        losses.update(losses_track)
+
+        return losses
diff --git a/mmdetection/mmdet/models/mot/strongsort.py b/mmdetection/mmdet/models/mot/strongsort.py
new file mode 100644
index 00000000..6129bf49
--- /dev/null
+++ b/mmdetection/mmdet/models/mot/strongsort.py
@@ -0,0 +1,129 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional
+
+import numpy as np
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.structures import TrackSampleList
+from mmdet.utils import OptConfigType
+from .deep_sort import DeepSORT
+
+
+@MODELS.register_module()
+class StrongSORT(DeepSORT):
+    """StrongSORT: Make DeepSORT Great Again.
+
+    Details can be found at `StrongSORT`_.
+
+    Args:
+        detector (dict): Configuration of detector. Defaults to None.
+        reid (dict): Configuration of reid. Defaults to None
+        tracker (dict): Configuration of tracker. Defaults to None.
+        kalman (dict): Configuration of Kalman filter. Defaults to None.
+        cmc (dict): Configuration of camera model compensation.
+            Defaults to None.
+        data_preprocessor (dict or ConfigDict, optional): The pre-process
+           config of :class:`TrackDataPreprocessor`.  it usually includes,
+            ``pad_size_divisor``, ``pad_value``, ``mean`` and ``std``.
+        init_cfg (dict or list[dict]): Configuration of initialization.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 detector: Optional[dict] = None,
+                 reid: Optional[dict] = None,
+                 cmc: Optional[dict] = None,
+                 tracker: Optional[dict] = None,
+                 postprocess_model: Optional[dict] = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptConfigType = None):
+        super().__init__(detector, reid, tracker, data_preprocessor, init_cfg)
+
+        if cmc is not None:
+            self.cmc = TASK_UTILS.build(cmc)
+
+        if postprocess_model is not None:
+            self.postprocess_model = TASK_UTILS.build(postprocess_model)
+
+    @property
+    def with_cmc(self):
+        """bool: whether the framework has a camera model compensation
+                model.
+        """
+        return hasattr(self, 'cmc') and self.cmc is not None
+
+    def predict(self,
+                inputs: Tensor,
+                data_samples: TrackSampleList,
+                rescale: bool = True,
+                **kwargs) -> TrackSampleList:
+        """Predict results from a video and data samples with post- processing.
+
+        Args:
+            inputs (Tensor): of shape (N, T, C, H, W) encoding
+                input images. The N denotes batch size.
+                The T denotes the number of key frames
+                and reference frames.
+            data_samples (list[:obj:`TrackDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance`.
+            rescale (bool, Optional): If False, then returned bboxes and masks
+                will fit the scale of img, otherwise, returned bboxes and masks
+                will fit the scale of original image shape. Defaults to True.
+
+        Returns:
+            TrackSampleList: List[TrackDataSample]
+            Tracking results of the input videos.
+            Each DetDataSample usually contains ``pred_track_instances``.
+        """
+        assert inputs.dim() == 5, 'The img must be 5D Tensor (N, T, C, H, W).'
+        assert inputs.size(0) == 1, \
+            'SORT/DeepSORT inference only support ' \
+            '1 batch size per gpu for now.'
+
+        assert len(data_samples) == 1, \
+            'SORT/DeepSORT inference only support ' \
+            '1 batch size per gpu for now.'
+
+        track_data_sample = data_samples[0]
+        video_len = len(track_data_sample)
+
+        video_track_instances = []
+        for frame_id in range(video_len):
+            img_data_sample = track_data_sample[frame_id]
+            single_img = inputs[:, frame_id].contiguous()
+            # det_results List[DetDataSample]
+            det_results = self.detector.predict(single_img, [img_data_sample])
+            assert len(det_results) == 1, 'Batch inference is not supported.'
+
+            pred_track_instances = self.tracker.track(
+                model=self,
+                img=single_img,
+                data_sample=det_results[0],
+                data_preprocessor=self.preprocess_cfg,
+                rescale=rescale,
+                **kwargs)
+            for i in range(len(pred_track_instances.instances_id)):
+                video_track_instances.append(
+                    np.array([
+                        frame_id + 1,
+                        pred_track_instances.instances_id[i].cpu(),
+                        pred_track_instances.bboxes[i][0].cpu(),
+                        pred_track_instances.bboxes[i][1].cpu(),
+                        (pred_track_instances.bboxes[i][2] -
+                         pred_track_instances.bboxes[i][0]).cpu(),
+                        (pred_track_instances.bboxes[i][3] -
+                         pred_track_instances.bboxes[i][1]).cpu(),
+                        pred_track_instances.scores[i].cpu()
+                    ]))
+        video_track_instances = np.array(video_track_instances).reshape(-1, 7)
+        video_track_instances = self.postprocess_model.forward(
+            video_track_instances)
+        for frame_id in range(video_len):
+            track_data_sample[frame_id].pred_track_instances = \
+                    InstanceData(bboxes=video_track_instances[
+                        video_track_instances[:, 0] == frame_id + 1, :])
+
+        return [track_data_sample]
diff --git a/mmdetection/mmdet/models/necks/__init__.py b/mmdetection/mmdet/models/necks/__init__.py
new file mode 100644
index 00000000..343fbfef
--- /dev/null
+++ b/mmdetection/mmdet/models/necks/__init__.py
@@ -0,0 +1,27 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .bfp import BFP
+from .channel_mapper import ChannelMapper
+from .cspnext_pafpn import CSPNeXtPAFPN
+from .ct_resnet_neck import CTResNetNeck
+from .dilated_encoder import DilatedEncoder
+from .dyhead import DyHead
+from .fpg import FPG
+from .fpn import FPN
+from .fpn_carafe import FPN_CARAFE
+from .fpn_dropblock import FPN_DropBlock
+from .hrfpn import HRFPN
+from .nas_fpn import NASFPN
+from .nasfcos_fpn import NASFCOS_FPN
+from .pafpn import PAFPN
+from .rfp import RFP
+from .ssd_neck import SSDNeck
+from .ssh import SSH
+from .yolo_neck import YOLOV3Neck
+from .yolox_pafpn import YOLOXPAFPN
+
+__all__ = [
+    'FPN', 'BFP', 'ChannelMapper', 'HRFPN', 'NASFPN', 'FPN_CARAFE', 'PAFPN',
+    'NASFCOS_FPN', 'RFP', 'YOLOV3Neck', 'FPG', 'DilatedEncoder',
+    'CTResNetNeck', 'SSDNeck', 'YOLOXPAFPN', 'DyHead', 'CSPNeXtPAFPN', 'SSH',
+    'FPN_DropBlock'
+]
diff --git a/mmdetection/mmdet/models/necks/bfp.py b/mmdetection/mmdet/models/necks/bfp.py
new file mode 100644
index 00000000..401cdb0f
--- /dev/null
+++ b/mmdetection/mmdet/models/necks/bfp.py
@@ -0,0 +1,111 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Tuple
+
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+from mmcv.cnn.bricks import NonLocal2d
+from mmengine.model import BaseModule
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import OptConfigType, OptMultiConfig
+
+
+@MODELS.register_module()
+class BFP(BaseModule):
+    """BFP (Balanced Feature Pyramids)
+
+    BFP takes multi-level features as inputs and gather them into a single one,
+    then refine the gathered feature and scatter the refined results to
+    multi-level features. This module is used in Libra R-CNN (CVPR 2019), see
+    the paper `Libra R-CNN: Towards Balanced Learning for Object Detection
+    `_ for details.
+
+    Args:
+        in_channels (int): Number of input channels (feature maps of all levels
+            should have the same channels).
+        num_levels (int): Number of input feature levels.
+        refine_level (int): Index of integration and refine level of BSF in
+            multi-level features from bottom to top.
+        refine_type (str): Type of the refine op, currently support
+            [None, 'conv', 'non_local'].
+        conv_cfg (:obj:`ConfigDict` or dict, optional): The config dict for
+            convolution layers.
+        norm_cfg (:obj:`ConfigDict` or dict, optional): The config dict for
+            normalization layers.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or
+            dict], optional): Initialization config dict.
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        num_levels: int,
+        refine_level: int = 2,
+        refine_type: str = None,
+        conv_cfg: OptConfigType = None,
+        norm_cfg: OptConfigType = None,
+        init_cfg: OptMultiConfig = dict(
+            type='Xavier', layer='Conv2d', distribution='uniform')
+    ) -> None:
+        super().__init__(init_cfg=init_cfg)
+        assert refine_type in [None, 'conv', 'non_local']
+
+        self.in_channels = in_channels
+        self.num_levels = num_levels
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+
+        self.refine_level = refine_level
+        self.refine_type = refine_type
+        assert 0 <= self.refine_level < self.num_levels
+
+        if self.refine_type == 'conv':
+            self.refine = ConvModule(
+                self.in_channels,
+                self.in_channels,
+                3,
+                padding=1,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg)
+        elif self.refine_type == 'non_local':
+            self.refine = NonLocal2d(
+                self.in_channels,
+                reduction=1,
+                use_scale=False,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg)
+
+    def forward(self, inputs: Tuple[Tensor]) -> Tuple[Tensor]:
+        """Forward function."""
+        assert len(inputs) == self.num_levels
+
+        # step 1: gather multi-level features by resize and average
+        feats = []
+        gather_size = inputs[self.refine_level].size()[2:]
+        for i in range(self.num_levels):
+            if i < self.refine_level:
+                gathered = F.adaptive_max_pool2d(
+                    inputs[i], output_size=gather_size)
+            else:
+                gathered = F.interpolate(
+                    inputs[i], size=gather_size, mode='nearest')
+            feats.append(gathered)
+
+        bsf = sum(feats) / len(feats)
+
+        # step 2: refine gathered features
+        if self.refine_type is not None:
+            bsf = self.refine(bsf)
+
+        # step 3: scatter refined features to multi-levels by a residual path
+        outs = []
+        for i in range(self.num_levels):
+            out_size = inputs[i].size()[2:]
+            if i < self.refine_level:
+                residual = F.interpolate(bsf, size=out_size, mode='nearest')
+            else:
+                residual = F.adaptive_max_pool2d(bsf, output_size=out_size)
+            outs.append(residual + inputs[i])
+
+        return tuple(outs)
diff --git a/mmdetection/mmdet/models/necks/channel_mapper.py b/mmdetection/mmdet/models/necks/channel_mapper.py
new file mode 100644
index 00000000..74293618
--- /dev/null
+++ b/mmdetection/mmdet/models/necks/channel_mapper.py
@@ -0,0 +1,112 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple, Union
+
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import OptConfigType, OptMultiConfig
+
+
+@MODELS.register_module()
+class ChannelMapper(BaseModule):
+    """Channel Mapper to reduce/increase channels of backbone features.
+
+    This is used to reduce/increase channels of backbone features.
+
+    Args:
+        in_channels (List[int]): Number of input channels per scale.
+        out_channels (int): Number of output channels (used at each scale).
+        kernel_size (int, optional): kernel_size for reducing channels (used
+            at each scale). Default: 3.
+        conv_cfg (:obj:`ConfigDict` or dict, optional): Config dict for
+            convolution layer. Default: None.
+        norm_cfg (:obj:`ConfigDict` or dict, optional): Config dict for
+            normalization layer. Default: None.
+        act_cfg (:obj:`ConfigDict` or dict, optional): Config dict for
+            activation layer in ConvModule. Default: dict(type='ReLU').
+        bias (bool | str): If specified as `auto`, it will be decided by the
+            norm_cfg. Bias will be set as True if `norm_cfg` is None, otherwise
+            False. Default: "auto".
+        num_outs (int, optional): Number of output feature maps. There would
+            be extra_convs when num_outs larger than the length of in_channels.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or dict],
+            optional): Initialization config dict.
+    Example:
+        >>> import torch
+        >>> in_channels = [2, 3, 5, 7]
+        >>> scales = [340, 170, 84, 43]
+        >>> inputs = [torch.rand(1, c, s, s)
+        ...           for c, s in zip(in_channels, scales)]
+        >>> self = ChannelMapper(in_channels, 11, 3).eval()
+        >>> outputs = self.forward(inputs)
+        >>> for i in range(len(outputs)):
+        ...     print(f'outputs[{i}].shape = {outputs[i].shape}')
+        outputs[0].shape = torch.Size([1, 11, 340, 340])
+        outputs[1].shape = torch.Size([1, 11, 170, 170])
+        outputs[2].shape = torch.Size([1, 11, 84, 84])
+        outputs[3].shape = torch.Size([1, 11, 43, 43])
+    """
+
+    def __init__(
+        self,
+        in_channels: List[int],
+        out_channels: int,
+        kernel_size: int = 3,
+        conv_cfg: OptConfigType = None,
+        norm_cfg: OptConfigType = None,
+        act_cfg: OptConfigType = dict(type='ReLU'),
+        bias: Union[bool, str] = 'auto',
+        num_outs: int = None,
+        init_cfg: OptMultiConfig = dict(
+            type='Xavier', layer='Conv2d', distribution='uniform')
+    ) -> None:
+        super().__init__(init_cfg=init_cfg)
+        assert isinstance(in_channels, list)
+        self.extra_convs = None
+        if num_outs is None:
+            num_outs = len(in_channels)
+        self.convs = nn.ModuleList()
+        for in_channel in in_channels:
+            self.convs.append(
+                ConvModule(
+                    in_channel,
+                    out_channels,
+                    kernel_size,
+                    padding=(kernel_size - 1) // 2,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg,
+                    bias=bias))
+        if num_outs > len(in_channels):
+            self.extra_convs = nn.ModuleList()
+            for i in range(len(in_channels), num_outs):
+                if i == len(in_channels):
+                    in_channel = in_channels[-1]
+                else:
+                    in_channel = out_channels
+                self.extra_convs.append(
+                    ConvModule(
+                        in_channel,
+                        out_channels,
+                        3,
+                        stride=2,
+                        padding=1,
+                        conv_cfg=conv_cfg,
+                        norm_cfg=norm_cfg,
+                        act_cfg=act_cfg,
+                        bias=bias))
+
+    def forward(self, inputs: Tuple[Tensor]) -> Tuple[Tensor]:
+        """Forward function."""
+        assert len(inputs) == len(self.convs)
+        outs = [self.convs[i](inputs[i]) for i in range(len(inputs))]
+        if self.extra_convs:
+            for i in range(len(self.extra_convs)):
+                if i == 0:
+                    outs.append(self.extra_convs[0](inputs[-1]))
+                else:
+                    outs.append(self.extra_convs[i](outs[-1]))
+        return tuple(outs)
diff --git a/mmdetection/mmdet/models/necks/cspnext_pafpn.py b/mmdetection/mmdet/models/necks/cspnext_pafpn.py
new file mode 100644
index 00000000..a52ba72d
--- /dev/null
+++ b/mmdetection/mmdet/models/necks/cspnext_pafpn.py
@@ -0,0 +1,170 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+from typing import Sequence, Tuple
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule, DepthwiseSeparableConvModule
+from mmengine.model import BaseModule
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptMultiConfig
+from ..layers import CSPLayer
+
+
+@MODELS.register_module()
+class CSPNeXtPAFPN(BaseModule):
+    """Path Aggregation Network with CSPNeXt blocks.
+
+    Args:
+        in_channels (Sequence[int]): Number of input channels per scale.
+        out_channels (int): Number of output channels (used at each scale)
+        num_csp_blocks (int): Number of bottlenecks in CSPLayer.
+            Defaults to 3.
+        use_depthwise (bool): Whether to use depthwise separable convolution in
+            blocks. Defaults to False.
+        expand_ratio (float): Ratio to adjust the number of channels of the
+            hidden layer. Default: 0.5
+        upsample_cfg (dict): Config dict for interpolate layer.
+            Default: `dict(scale_factor=2, mode='nearest')`
+        conv_cfg (dict, optional): Config dict for convolution layer.
+            Default: None, which means using conv2d.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN')
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='Swish')
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    """
+
+    def __init__(
+        self,
+        in_channels: Sequence[int],
+        out_channels: int,
+        num_csp_blocks: int = 3,
+        use_depthwise: bool = False,
+        expand_ratio: float = 0.5,
+        upsample_cfg: ConfigType = dict(scale_factor=2, mode='nearest'),
+        conv_cfg: bool = None,
+        norm_cfg: ConfigType = dict(type='BN', momentum=0.03, eps=0.001),
+        act_cfg: ConfigType = dict(type='Swish'),
+        init_cfg: OptMultiConfig = dict(
+            type='Kaiming',
+            layer='Conv2d',
+            a=math.sqrt(5),
+            distribution='uniform',
+            mode='fan_in',
+            nonlinearity='leaky_relu')
+    ) -> None:
+        super().__init__(init_cfg)
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+
+        conv = DepthwiseSeparableConvModule if use_depthwise else ConvModule
+
+        # build top-down blocks
+        self.upsample = nn.Upsample(**upsample_cfg)
+        self.reduce_layers = nn.ModuleList()
+        self.top_down_blocks = nn.ModuleList()
+        for idx in range(len(in_channels) - 1, 0, -1):
+            self.reduce_layers.append(
+                ConvModule(
+                    in_channels[idx],
+                    in_channels[idx - 1],
+                    1,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg))
+            self.top_down_blocks.append(
+                CSPLayer(
+                    in_channels[idx - 1] * 2,
+                    in_channels[idx - 1],
+                    num_blocks=num_csp_blocks,
+                    add_identity=False,
+                    use_depthwise=use_depthwise,
+                    use_cspnext_block=True,
+                    expand_ratio=expand_ratio,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg))
+
+        # build bottom-up blocks
+        self.downsamples = nn.ModuleList()
+        self.bottom_up_blocks = nn.ModuleList()
+        for idx in range(len(in_channels) - 1):
+            self.downsamples.append(
+                conv(
+                    in_channels[idx],
+                    in_channels[idx],
+                    3,
+                    stride=2,
+                    padding=1,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg))
+            self.bottom_up_blocks.append(
+                CSPLayer(
+                    in_channels[idx] * 2,
+                    in_channels[idx + 1],
+                    num_blocks=num_csp_blocks,
+                    add_identity=False,
+                    use_depthwise=use_depthwise,
+                    use_cspnext_block=True,
+                    expand_ratio=expand_ratio,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg))
+
+        self.out_convs = nn.ModuleList()
+        for i in range(len(in_channels)):
+            self.out_convs.append(
+                conv(
+                    in_channels[i],
+                    out_channels,
+                    3,
+                    padding=1,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg))
+
+    def forward(self, inputs: Tuple[Tensor, ...]) -> Tuple[Tensor, ...]:
+        """
+        Args:
+            inputs (tuple[Tensor]): input features.
+
+        Returns:
+            tuple[Tensor]: YOLOXPAFPN features.
+        """
+        assert len(inputs) == len(self.in_channels)
+
+        # top-down path
+        inner_outs = [inputs[-1]]
+        for idx in range(len(self.in_channels) - 1, 0, -1):
+            feat_heigh = inner_outs[0]
+            feat_low = inputs[idx - 1]
+            feat_heigh = self.reduce_layers[len(self.in_channels) - 1 - idx](
+                feat_heigh)
+            inner_outs[0] = feat_heigh
+
+            upsample_feat = self.upsample(feat_heigh)
+
+            inner_out = self.top_down_blocks[len(self.in_channels) - 1 - idx](
+                torch.cat([upsample_feat, feat_low], 1))
+            inner_outs.insert(0, inner_out)
+
+        # bottom-up path
+        outs = [inner_outs[0]]
+        for idx in range(len(self.in_channels) - 1):
+            feat_low = outs[-1]
+            feat_height = inner_outs[idx + 1]
+            downsample_feat = self.downsamples[idx](feat_low)
+            out = self.bottom_up_blocks[idx](
+                torch.cat([downsample_feat, feat_height], 1))
+            outs.append(out)
+
+        # out convs
+        for idx, conv in enumerate(self.out_convs):
+            outs[idx] = conv(outs[idx])
+
+        return tuple(outs)
diff --git a/mmdetection/mmdet/models/necks/ct_resnet_neck.py b/mmdetection/mmdet/models/necks/ct_resnet_neck.py
new file mode 100644
index 00000000..9109fe79
--- /dev/null
+++ b/mmdetection/mmdet/models/necks/ct_resnet_neck.py
@@ -0,0 +1,102 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+from typing import Sequence, Tuple
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule
+
+from mmdet.registry import MODELS
+from mmdet.utils import OptMultiConfig
+
+
+@MODELS.register_module()
+class CTResNetNeck(BaseModule):
+    """The neck used in `CenterNet `_ for
+    object classification and box regression.
+
+    Args:
+         in_channels (int): Number of input channels.
+         num_deconv_filters (tuple[int]): Number of filters per stage.
+         num_deconv_kernels (tuple[int]): Number of kernels per stage.
+         use_dcn (bool): If True, use DCNv2. Defaults to True.
+         init_cfg (:obj:`ConfigDict` or dict or list[dict] or
+             list[:obj:`ConfigDict`], optional): Initialization
+             config dict.
+    """
+
+    def __init__(self,
+                 in_channels: int,
+                 num_deconv_filters: Tuple[int, ...],
+                 num_deconv_kernels: Tuple[int, ...],
+                 use_dcn: bool = True,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(init_cfg=init_cfg)
+        assert len(num_deconv_filters) == len(num_deconv_kernels)
+        self.fp16_enabled = False
+        self.use_dcn = use_dcn
+        self.in_channels = in_channels
+        self.deconv_layers = self._make_deconv_layer(num_deconv_filters,
+                                                     num_deconv_kernels)
+
+    def _make_deconv_layer(
+            self, num_deconv_filters: Tuple[int, ...],
+            num_deconv_kernels: Tuple[int, ...]) -> nn.Sequential:
+        """use deconv layers to upsample backbone's output."""
+        layers = []
+        for i in range(len(num_deconv_filters)):
+            feat_channels = num_deconv_filters[i]
+            conv_module = ConvModule(
+                self.in_channels,
+                feat_channels,
+                3,
+                padding=1,
+                conv_cfg=dict(type='DCNv2') if self.use_dcn else None,
+                norm_cfg=dict(type='BN'))
+            layers.append(conv_module)
+            upsample_module = ConvModule(
+                feat_channels,
+                feat_channels,
+                num_deconv_kernels[i],
+                stride=2,
+                padding=1,
+                conv_cfg=dict(type='deconv'),
+                norm_cfg=dict(type='BN'))
+            layers.append(upsample_module)
+            self.in_channels = feat_channels
+
+        return nn.Sequential(*layers)
+
+    def init_weights(self) -> None:
+        """Initialize the parameters."""
+        for m in self.modules():
+            if isinstance(m, nn.ConvTranspose2d):
+                # In order to be consistent with the source code,
+                # reset the ConvTranspose2d initialization parameters
+                m.reset_parameters()
+                # Simulated bilinear upsampling kernel
+                w = m.weight.data
+                f = math.ceil(w.size(2) / 2)
+                c = (2 * f - 1 - f % 2) / (2. * f)
+                for i in range(w.size(2)):
+                    for j in range(w.size(3)):
+                        w[0, 0, i, j] = \
+                            (1 - math.fabs(i / f - c)) * (
+                                    1 - math.fabs(j / f - c))
+                for c in range(1, w.size(0)):
+                    w[c, 0, :, :] = w[0, 0, :, :]
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+            # self.use_dcn is False
+            elif not self.use_dcn and isinstance(m, nn.Conv2d):
+                # In order to be consistent with the source code,
+                # reset the Conv2d initialization parameters
+                m.reset_parameters()
+
+    def forward(self, x: Sequence[torch.Tensor]) -> Tuple[torch.Tensor]:
+        """model forward."""
+        assert isinstance(x, (list, tuple))
+        outs = self.deconv_layers(x[-1])
+        return outs,
diff --git a/mmdetection/mmdet/models/necks/dilated_encoder.py b/mmdetection/mmdet/models/necks/dilated_encoder.py
new file mode 100644
index 00000000..e9beb3ea
--- /dev/null
+++ b/mmdetection/mmdet/models/necks/dilated_encoder.py
@@ -0,0 +1,109 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch.nn as nn
+from mmcv.cnn import ConvModule, is_norm
+from mmengine.model import caffe2_xavier_init, constant_init, normal_init
+from torch.nn import BatchNorm2d
+
+from mmdet.registry import MODELS
+
+
+class Bottleneck(nn.Module):
+    """Bottleneck block for DilatedEncoder used in `YOLOF.
+
+    `.
+
+    The Bottleneck contains three ConvLayers and one residual connection.
+
+    Args:
+        in_channels (int): The number of input channels.
+        mid_channels (int): The number of middle output channels.
+        dilation (int): Dilation rate.
+        norm_cfg (dict): Dictionary to construct and config norm layer.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 mid_channels,
+                 dilation,
+                 norm_cfg=dict(type='BN', requires_grad=True)):
+        super(Bottleneck, self).__init__()
+        self.conv1 = ConvModule(
+            in_channels, mid_channels, 1, norm_cfg=norm_cfg)
+        self.conv2 = ConvModule(
+            mid_channels,
+            mid_channels,
+            3,
+            padding=dilation,
+            dilation=dilation,
+            norm_cfg=norm_cfg)
+        self.conv3 = ConvModule(
+            mid_channels, in_channels, 1, norm_cfg=norm_cfg)
+
+    def forward(self, x):
+        identity = x
+        out = self.conv1(x)
+        out = self.conv2(out)
+        out = self.conv3(out)
+        out = out + identity
+        return out
+
+
+@MODELS.register_module()
+class DilatedEncoder(nn.Module):
+    """Dilated Encoder for YOLOF `.
+
+    This module contains two types of components:
+        - the original FPN lateral convolution layer and fpn convolution layer,
+              which are 1x1 conv + 3x3 conv
+        - the dilated residual block
+
+    Args:
+        in_channels (int): The number of input channels.
+        out_channels (int): The number of output channels.
+        block_mid_channels (int): The number of middle block output channels
+        num_residual_blocks (int): The number of residual blocks.
+        block_dilations (list): The list of residual blocks dilation.
+    """
+
+    def __init__(self, in_channels, out_channels, block_mid_channels,
+                 num_residual_blocks, block_dilations):
+        super(DilatedEncoder, self).__init__()
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.block_mid_channels = block_mid_channels
+        self.num_residual_blocks = num_residual_blocks
+        self.block_dilations = block_dilations
+        self._init_layers()
+
+    def _init_layers(self):
+        self.lateral_conv = nn.Conv2d(
+            self.in_channels, self.out_channels, kernel_size=1)
+        self.lateral_norm = BatchNorm2d(self.out_channels)
+        self.fpn_conv = nn.Conv2d(
+            self.out_channels, self.out_channels, kernel_size=3, padding=1)
+        self.fpn_norm = BatchNorm2d(self.out_channels)
+        encoder_blocks = []
+        for i in range(self.num_residual_blocks):
+            dilation = self.block_dilations[i]
+            encoder_blocks.append(
+                Bottleneck(
+                    self.out_channels,
+                    self.block_mid_channels,
+                    dilation=dilation))
+        self.dilated_encoder_blocks = nn.Sequential(*encoder_blocks)
+
+    def init_weights(self):
+        caffe2_xavier_init(self.lateral_conv)
+        caffe2_xavier_init(self.fpn_conv)
+        for m in [self.lateral_norm, self.fpn_norm]:
+            constant_init(m, 1)
+        for m in self.dilated_encoder_blocks.modules():
+            if isinstance(m, nn.Conv2d):
+                normal_init(m, mean=0, std=0.01)
+            if is_norm(m):
+                constant_init(m, 1)
+
+    def forward(self, feature):
+        out = self.lateral_norm(self.lateral_conv(feature[-1]))
+        out = self.fpn_norm(self.fpn_conv(out))
+        return self.dilated_encoder_blocks(out),
diff --git a/mmdetection/mmdet/models/necks/dyhead.py b/mmdetection/mmdet/models/necks/dyhead.py
new file mode 100644
index 00000000..5f5ae0b2
--- /dev/null
+++ b/mmdetection/mmdet/models/necks/dyhead.py
@@ -0,0 +1,173 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import build_activation_layer, build_norm_layer
+from mmcv.ops.modulated_deform_conv import ModulatedDeformConv2d
+from mmengine.model import BaseModule, constant_init, normal_init
+
+from mmdet.registry import MODELS
+from ..layers import DyReLU
+
+# Reference:
+# https://github.com/microsoft/DynamicHead
+# https://github.com/jshilong/SEPC
+
+
+class DyDCNv2(nn.Module):
+    """ModulatedDeformConv2d with normalization layer used in DyHead.
+
+    This module cannot be configured with `conv_cfg=dict(type='DCNv2')`
+    because DyHead calculates offset and mask from middle-level feature.
+
+    Args:
+        in_channels (int): Number of input channels.
+        out_channels (int): Number of output channels.
+        stride (int | tuple[int], optional): Stride of the convolution.
+            Default: 1.
+        norm_cfg (dict, optional): Config dict for normalization layer.
+            Default: dict(type='GN', num_groups=16, requires_grad=True).
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 stride=1,
+                 norm_cfg=dict(type='GN', num_groups=16, requires_grad=True)):
+        super().__init__()
+        self.with_norm = norm_cfg is not None
+        bias = not self.with_norm
+        self.conv = ModulatedDeformConv2d(
+            in_channels, out_channels, 3, stride=stride, padding=1, bias=bias)
+        if self.with_norm:
+            self.norm = build_norm_layer(norm_cfg, out_channels)[1]
+
+    def forward(self, x, offset, mask):
+        """Forward function."""
+        x = self.conv(x.contiguous(), offset, mask)
+        if self.with_norm:
+            x = self.norm(x)
+        return x
+
+
+class DyHeadBlock(nn.Module):
+    """DyHead Block with three types of attention.
+
+    HSigmoid arguments in default act_cfg follow official code, not paper.
+    https://github.com/microsoft/DynamicHead/blob/master/dyhead/dyrelu.py
+
+    Args:
+        in_channels (int): Number of input channels.
+        out_channels (int): Number of output channels.
+        zero_init_offset (bool, optional): Whether to use zero init for
+            `spatial_conv_offset`. Default: True.
+        act_cfg (dict, optional): Config dict for the last activation layer of
+            scale-aware attention. Default: dict(type='HSigmoid', bias=3.0,
+            divisor=6.0).
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 zero_init_offset=True,
+                 act_cfg=dict(type='HSigmoid', bias=3.0, divisor=6.0)):
+        super().__init__()
+        self.zero_init_offset = zero_init_offset
+        # (offset_x, offset_y, mask) * kernel_size_y * kernel_size_x
+        self.offset_and_mask_dim = 3 * 3 * 3
+        self.offset_dim = 2 * 3 * 3
+
+        self.spatial_conv_high = DyDCNv2(in_channels, out_channels)
+        self.spatial_conv_mid = DyDCNv2(in_channels, out_channels)
+        self.spatial_conv_low = DyDCNv2(in_channels, out_channels, stride=2)
+        self.spatial_conv_offset = nn.Conv2d(
+            in_channels, self.offset_and_mask_dim, 3, padding=1)
+        self.scale_attn_module = nn.Sequential(
+            nn.AdaptiveAvgPool2d(1), nn.Conv2d(out_channels, 1, 1),
+            nn.ReLU(inplace=True), build_activation_layer(act_cfg))
+        self.task_attn_module = DyReLU(out_channels)
+        self._init_weights()
+
+    def _init_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                normal_init(m, 0, 0.01)
+        if self.zero_init_offset:
+            constant_init(self.spatial_conv_offset, 0)
+
+    def forward(self, x):
+        """Forward function."""
+        outs = []
+        for level in range(len(x)):
+            # calculate offset and mask of DCNv2 from middle-level feature
+            offset_and_mask = self.spatial_conv_offset(x[level])
+            offset = offset_and_mask[:, :self.offset_dim, :, :]
+            mask = offset_and_mask[:, self.offset_dim:, :, :].sigmoid()
+
+            mid_feat = self.spatial_conv_mid(x[level], offset, mask)
+            sum_feat = mid_feat * self.scale_attn_module(mid_feat)
+            summed_levels = 1
+            if level > 0:
+                low_feat = self.spatial_conv_low(x[level - 1], offset, mask)
+                sum_feat += low_feat * self.scale_attn_module(low_feat)
+                summed_levels += 1
+            if level < len(x) - 1:
+                # this upsample order is weird, but faster than natural order
+                # https://github.com/microsoft/DynamicHead/issues/25
+                high_feat = F.interpolate(
+                    self.spatial_conv_high(x[level + 1], offset, mask),
+                    size=x[level].shape[-2:],
+                    mode='bilinear',
+                    align_corners=True)
+                sum_feat += high_feat * self.scale_attn_module(high_feat)
+                summed_levels += 1
+            outs.append(self.task_attn_module(sum_feat / summed_levels))
+
+        return outs
+
+
+@MODELS.register_module()
+class DyHead(BaseModule):
+    """DyHead neck consisting of multiple DyHead Blocks.
+
+    See `Dynamic Head: Unifying Object Detection Heads with Attentions
+    `_ for details.
+
+    Args:
+        in_channels (int): Number of input channels.
+        out_channels (int): Number of output channels.
+        num_blocks (int, optional): Number of DyHead Blocks. Default: 6.
+        zero_init_offset (bool, optional): Whether to use zero init for
+            `spatial_conv_offset`. Default: True.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 num_blocks=6,
+                 zero_init_offset=True,
+                 init_cfg=None):
+        assert init_cfg is None, 'To prevent abnormal initialization ' \
+                                 'behavior, init_cfg is not allowed to be set'
+        super().__init__(init_cfg=init_cfg)
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.num_blocks = num_blocks
+        self.zero_init_offset = zero_init_offset
+
+        dyhead_blocks = []
+        for i in range(num_blocks):
+            in_channels = self.in_channels if i == 0 else self.out_channels
+            dyhead_blocks.append(
+                DyHeadBlock(
+                    in_channels,
+                    self.out_channels,
+                    zero_init_offset=zero_init_offset))
+        self.dyhead_blocks = nn.Sequential(*dyhead_blocks)
+
+    def forward(self, inputs):
+        """Forward function."""
+        assert isinstance(inputs, (tuple, list))
+        outs = self.dyhead_blocks(inputs)
+        return tuple(outs)
diff --git a/mmdetection/mmdet/models/necks/fpg.py b/mmdetection/mmdet/models/necks/fpg.py
new file mode 100644
index 00000000..73ee799b
--- /dev/null
+++ b/mmdetection/mmdet/models/necks/fpg.py
@@ -0,0 +1,406 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule
+
+from mmdet.registry import MODELS
+
+
+class Transition(BaseModule):
+    """Base class for transition.
+
+    Args:
+        in_channels (int): Number of input channels.
+        out_channels (int): Number of output channels.
+    """
+
+    def __init__(self, in_channels, out_channels, init_cfg=None):
+        super().__init__(init_cfg)
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+
+    def forward(x):
+        pass
+
+
+class UpInterpolationConv(Transition):
+    """A transition used for up-sampling.
+
+    Up-sample the input by interpolation then refines the feature by
+    a convolution layer.
+
+    Args:
+        in_channels (int): Number of input channels.
+        out_channels (int): Number of output channels.
+        scale_factor (int): Up-sampling factor. Default: 2.
+        mode (int): Interpolation mode. Default: nearest.
+        align_corners (bool): Whether align corners when interpolation.
+            Default: None.
+        kernel_size (int): Kernel size for the conv. Default: 3.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 scale_factor=2,
+                 mode='nearest',
+                 align_corners=None,
+                 kernel_size=3,
+                 init_cfg=None,
+                 **kwargs):
+        super().__init__(in_channels, out_channels, init_cfg)
+        self.mode = mode
+        self.scale_factor = scale_factor
+        self.align_corners = align_corners
+        self.conv = ConvModule(
+            in_channels,
+            out_channels,
+            kernel_size,
+            padding=(kernel_size - 1) // 2,
+            **kwargs)
+
+    def forward(self, x):
+        x = F.interpolate(
+            x,
+            scale_factor=self.scale_factor,
+            mode=self.mode,
+            align_corners=self.align_corners)
+        x = self.conv(x)
+        return x
+
+
+class LastConv(Transition):
+    """A transition used for refining the output of the last stage.
+
+    Args:
+        in_channels (int): Number of input channels.
+        out_channels (int): Number of output channels.
+        num_inputs (int): Number of inputs of the FPN features.
+        kernel_size (int): Kernel size for the conv. Default: 3.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 num_inputs,
+                 kernel_size=3,
+                 init_cfg=None,
+                 **kwargs):
+        super().__init__(in_channels, out_channels, init_cfg)
+        self.num_inputs = num_inputs
+        self.conv_out = ConvModule(
+            in_channels,
+            out_channels,
+            kernel_size,
+            padding=(kernel_size - 1) // 2,
+            **kwargs)
+
+    def forward(self, inputs):
+        assert len(inputs) == self.num_inputs
+        return self.conv_out(inputs[-1])
+
+
+@MODELS.register_module()
+class FPG(BaseModule):
+    """FPG.
+
+    Implementation of `Feature Pyramid Grids (FPG)
+    `_.
+    This implementation only gives the basic structure stated in the paper.
+    But users can implement different type of transitions to fully explore the
+    the potential power of the structure of FPG.
+
+    Args:
+        in_channels (int): Number of input channels (feature maps of all levels
+            should have the same channels).
+        out_channels (int): Number of output channels (used at each scale)
+        num_outs (int): Number of output scales.
+        stack_times (int): The number of times the pyramid architecture will
+            be stacked.
+        paths (list[str]): Specify the path order of each stack level.
+            Each element in the list should be either 'bu' (bottom-up) or
+            'td' (top-down).
+        inter_channels (int): Number of inter channels.
+        same_up_trans (dict): Transition that goes down at the same stage.
+        same_down_trans (dict): Transition that goes up at the same stage.
+        across_lateral_trans (dict): Across-pathway same-stage
+        across_down_trans (dict): Across-pathway bottom-up connection.
+        across_up_trans (dict): Across-pathway top-down connection.
+        across_skip_trans (dict): Across-pathway skip connection.
+        output_trans (dict): Transition that trans the output of the
+            last stage.
+        start_level (int): Index of the start input backbone level used to
+            build the feature pyramid. Default: 0.
+        end_level (int): Index of the end input backbone level (exclusive) to
+            build the feature pyramid. Default: -1, which means the last level.
+        add_extra_convs (bool): It decides whether to add conv
+            layers on top of the original feature maps. Default to False.
+            If True, its actual mode is specified by `extra_convs_on_inputs`.
+        norm_cfg (dict): Config dict for normalization layer. Default: None.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+    """
+
+    transition_types = {
+        'conv': ConvModule,
+        'interpolation_conv': UpInterpolationConv,
+        'last_conv': LastConv,
+    }
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 num_outs,
+                 stack_times,
+                 paths,
+                 inter_channels=None,
+                 same_down_trans=None,
+                 same_up_trans=dict(
+                     type='conv', kernel_size=3, stride=2, padding=1),
+                 across_lateral_trans=dict(type='conv', kernel_size=1),
+                 across_down_trans=dict(type='conv', kernel_size=3),
+                 across_up_trans=None,
+                 across_skip_trans=dict(type='identity'),
+                 output_trans=dict(type='last_conv', kernel_size=3),
+                 start_level=0,
+                 end_level=-1,
+                 add_extra_convs=False,
+                 norm_cfg=None,
+                 skip_inds=None,
+                 init_cfg=[
+                     dict(type='Caffe2Xavier', layer='Conv2d'),
+                     dict(
+                         type='Constant',
+                         layer=[
+                             '_BatchNorm', '_InstanceNorm', 'GroupNorm',
+                             'LayerNorm'
+                         ],
+                         val=1.0)
+                 ]):
+        super(FPG, self).__init__(init_cfg)
+        assert isinstance(in_channels, list)
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.num_ins = len(in_channels)
+        self.num_outs = num_outs
+        if inter_channels is None:
+            self.inter_channels = [out_channels for _ in range(num_outs)]
+        elif isinstance(inter_channels, int):
+            self.inter_channels = [inter_channels for _ in range(num_outs)]
+        else:
+            assert isinstance(inter_channels, list)
+            assert len(inter_channels) == num_outs
+            self.inter_channels = inter_channels
+        self.stack_times = stack_times
+        self.paths = paths
+        assert isinstance(paths, list) and len(paths) == stack_times
+        for d in paths:
+            assert d in ('bu', 'td')
+
+        self.same_down_trans = same_down_trans
+        self.same_up_trans = same_up_trans
+        self.across_lateral_trans = across_lateral_trans
+        self.across_down_trans = across_down_trans
+        self.across_up_trans = across_up_trans
+        self.output_trans = output_trans
+        self.across_skip_trans = across_skip_trans
+
+        self.with_bias = norm_cfg is None
+        # skip inds must be specified if across skip trans is not None
+        if self.across_skip_trans is not None:
+            skip_inds is not None
+        self.skip_inds = skip_inds
+        assert len(self.skip_inds[0]) <= self.stack_times
+
+        if end_level == -1 or end_level == self.num_ins - 1:
+            self.backbone_end_level = self.num_ins
+            assert num_outs >= self.num_ins - start_level
+        else:
+            # if end_level is not the last level, no extra level is allowed
+            self.backbone_end_level = end_level + 1
+            assert end_level < self.num_ins
+            assert num_outs == end_level - start_level + 1
+        self.start_level = start_level
+        self.end_level = end_level
+        self.add_extra_convs = add_extra_convs
+
+        # build lateral 1x1 convs to reduce channels
+        self.lateral_convs = nn.ModuleList()
+        for i in range(self.start_level, self.backbone_end_level):
+            l_conv = nn.Conv2d(self.in_channels[i],
+                               self.inter_channels[i - self.start_level], 1)
+            self.lateral_convs.append(l_conv)
+
+        extra_levels = num_outs - self.backbone_end_level + self.start_level
+        self.extra_downsamples = nn.ModuleList()
+        for i in range(extra_levels):
+            if self.add_extra_convs:
+                fpn_idx = self.backbone_end_level - self.start_level + i
+                extra_conv = nn.Conv2d(
+                    self.inter_channels[fpn_idx - 1],
+                    self.inter_channels[fpn_idx],
+                    3,
+                    stride=2,
+                    padding=1)
+                self.extra_downsamples.append(extra_conv)
+            else:
+                self.extra_downsamples.append(nn.MaxPool2d(1, stride=2))
+
+        self.fpn_transitions = nn.ModuleList()  # stack times
+        for s in range(self.stack_times):
+            stage_trans = nn.ModuleList()  # num of feature levels
+            for i in range(self.num_outs):
+                # same, across_lateral, across_down, across_up
+                trans = nn.ModuleDict()
+                if s in self.skip_inds[i]:
+                    stage_trans.append(trans)
+                    continue
+                # build same-stage down trans (used in bottom-up paths)
+                if i == 0 or self.same_up_trans is None:
+                    same_up_trans = None
+                else:
+                    same_up_trans = self.build_trans(
+                        self.same_up_trans, self.inter_channels[i - 1],
+                        self.inter_channels[i])
+                trans['same_up'] = same_up_trans
+                # build same-stage up trans (used in top-down paths)
+                if i == self.num_outs - 1 or self.same_down_trans is None:
+                    same_down_trans = None
+                else:
+                    same_down_trans = self.build_trans(
+                        self.same_down_trans, self.inter_channels[i + 1],
+                        self.inter_channels[i])
+                trans['same_down'] = same_down_trans
+                # build across lateral trans
+                across_lateral_trans = self.build_trans(
+                    self.across_lateral_trans, self.inter_channels[i],
+                    self.inter_channels[i])
+                trans['across_lateral'] = across_lateral_trans
+                # build across down trans
+                if i == self.num_outs - 1 or self.across_down_trans is None:
+                    across_down_trans = None
+                else:
+                    across_down_trans = self.build_trans(
+                        self.across_down_trans, self.inter_channels[i + 1],
+                        self.inter_channels[i])
+                trans['across_down'] = across_down_trans
+                # build across up trans
+                if i == 0 or self.across_up_trans is None:
+                    across_up_trans = None
+                else:
+                    across_up_trans = self.build_trans(
+                        self.across_up_trans, self.inter_channels[i - 1],
+                        self.inter_channels[i])
+                trans['across_up'] = across_up_trans
+                if self.across_skip_trans is None:
+                    across_skip_trans = None
+                else:
+                    across_skip_trans = self.build_trans(
+                        self.across_skip_trans, self.inter_channels[i - 1],
+                        self.inter_channels[i])
+                trans['across_skip'] = across_skip_trans
+                # build across_skip trans
+                stage_trans.append(trans)
+            self.fpn_transitions.append(stage_trans)
+
+        self.output_transition = nn.ModuleList()  # output levels
+        for i in range(self.num_outs):
+            trans = self.build_trans(
+                self.output_trans,
+                self.inter_channels[i],
+                self.out_channels,
+                num_inputs=self.stack_times + 1)
+            self.output_transition.append(trans)
+
+        self.relu = nn.ReLU(inplace=True)
+
+    def build_trans(self, cfg, in_channels, out_channels, **extra_args):
+        cfg_ = cfg.copy()
+        trans_type = cfg_.pop('type')
+        trans_cls = self.transition_types[trans_type]
+        return trans_cls(in_channels, out_channels, **cfg_, **extra_args)
+
+    def fuse(self, fuse_dict):
+        out = None
+        for item in fuse_dict.values():
+            if item is not None:
+                if out is None:
+                    out = item
+                else:
+                    out = out + item
+        return out
+
+    def forward(self, inputs):
+        assert len(inputs) == len(self.in_channels)
+
+        # build all levels from original feature maps
+        feats = [
+            lateral_conv(inputs[i + self.start_level])
+            for i, lateral_conv in enumerate(self.lateral_convs)
+        ]
+        for downsample in self.extra_downsamples:
+            feats.append(downsample(feats[-1]))
+
+        outs = [feats]
+
+        for i in range(self.stack_times):
+            current_outs = outs[-1]
+            next_outs = []
+            direction = self.paths[i]
+            for j in range(self.num_outs):
+                if i in self.skip_inds[j]:
+                    next_outs.append(outs[-1][j])
+                    continue
+                # feature level
+                if direction == 'td':
+                    lvl = self.num_outs - j - 1
+                else:
+                    lvl = j
+                # get transitions
+                if direction == 'td':
+                    same_trans = self.fpn_transitions[i][lvl]['same_down']
+                else:
+                    same_trans = self.fpn_transitions[i][lvl]['same_up']
+                across_lateral_trans = self.fpn_transitions[i][lvl][
+                    'across_lateral']
+                across_down_trans = self.fpn_transitions[i][lvl]['across_down']
+                across_up_trans = self.fpn_transitions[i][lvl]['across_up']
+                across_skip_trans = self.fpn_transitions[i][lvl]['across_skip']
+                # init output
+                to_fuse = dict(
+                    same=None, lateral=None, across_up=None, across_down=None)
+                # same downsample/upsample
+                if same_trans is not None:
+                    to_fuse['same'] = same_trans(next_outs[-1])
+                # across lateral
+                if across_lateral_trans is not None:
+                    to_fuse['lateral'] = across_lateral_trans(
+                        current_outs[lvl])
+                # across downsample
+                if lvl > 0 and across_up_trans is not None:
+                    to_fuse['across_up'] = across_up_trans(current_outs[lvl -
+                                                                        1])
+                # across upsample
+                if (lvl < self.num_outs - 1 and across_down_trans is not None):
+                    to_fuse['across_down'] = across_down_trans(
+                        current_outs[lvl + 1])
+                if across_skip_trans is not None:
+                    to_fuse['across_skip'] = across_skip_trans(outs[0][lvl])
+                x = self.fuse(to_fuse)
+                next_outs.append(x)
+
+            if direction == 'td':
+                outs.append(next_outs[::-1])
+            else:
+                outs.append(next_outs)
+
+        # output trans
+        final_outs = []
+        for i in range(self.num_outs):
+            lvl_out_list = []
+            for s in range(len(outs)):
+                lvl_out_list.append(outs[s][i])
+            lvl_out = self.output_transition[i](lvl_out_list)
+            final_outs.append(lvl_out)
+
+        return final_outs
diff --git a/mmdetection/mmdet/models/necks/fpn.py b/mmdetection/mmdet/models/necks/fpn.py
new file mode 100644
index 00000000..67bd8879
--- /dev/null
+++ b/mmdetection/mmdet/models/necks/fpn.py
@@ -0,0 +1,221 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple, Union
+
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, MultiConfig, OptConfigType
+
+
+@MODELS.register_module()
+class FPN(BaseModule):
+    r"""Feature Pyramid Network.
+
+    This is an implementation of paper `Feature Pyramid Networks for Object
+    Detection `_.
+
+    Args:
+        in_channels (list[int]): Number of input channels per scale.
+        out_channels (int): Number of output channels (used at each scale).
+        num_outs (int): Number of output scales.
+        start_level (int): Index of the start input backbone level used to
+            build the feature pyramid. Defaults to 0.
+        end_level (int): Index of the end input backbone level (exclusive) to
+            build the feature pyramid. Defaults to -1, which means the
+            last level.
+        add_extra_convs (bool | str): If bool, it decides whether to add conv
+            layers on top of the original feature maps. Defaults to False.
+            If True, it is equivalent to `add_extra_convs='on_input'`.
+            If str, it specifies the source feature map of the extra convs.
+            Only the following options are allowed
+
+            - 'on_input': Last feat map of neck inputs (i.e. backbone feature).
+            - 'on_lateral': Last feature map after lateral convs.
+            - 'on_output': The last output feature map after fpn convs.
+        relu_before_extra_convs (bool): Whether to apply relu before the extra
+            conv. Defaults to False.
+        no_norm_on_lateral (bool): Whether to apply norm on lateral.
+            Defaults to False.
+        conv_cfg (:obj:`ConfigDict` or dict, optional): Config dict for
+            convolution layer. Defaults to None.
+        norm_cfg (:obj:`ConfigDict` or dict, optional): Config dict for
+            normalization layer. Defaults to None.
+        act_cfg (:obj:`ConfigDict` or dict, optional): Config dict for
+            activation layer in ConvModule. Defaults to None.
+        upsample_cfg (:obj:`ConfigDict` or dict, optional): Config dict
+            for interpolate layer. Defaults to dict(mode='nearest').
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict]): Initialization config dict.
+
+    Example:
+        >>> import torch
+        >>> in_channels = [2, 3, 5, 7]
+        >>> scales = [340, 170, 84, 43]
+        >>> inputs = [torch.rand(1, c, s, s)
+        ...           for c, s in zip(in_channels, scales)]
+        >>> self = FPN(in_channels, 11, len(in_channels)).eval()
+        >>> outputs = self.forward(inputs)
+        >>> for i in range(len(outputs)):
+        ...     print(f'outputs[{i}].shape = {outputs[i].shape}')
+        outputs[0].shape = torch.Size([1, 11, 340, 340])
+        outputs[1].shape = torch.Size([1, 11, 170, 170])
+        outputs[2].shape = torch.Size([1, 11, 84, 84])
+        outputs[3].shape = torch.Size([1, 11, 43, 43])
+    """
+
+    def __init__(
+        self,
+        in_channels: List[int],
+        out_channels: int,
+        num_outs: int,
+        start_level: int = 0,
+        end_level: int = -1,
+        add_extra_convs: Union[bool, str] = False,
+        relu_before_extra_convs: bool = False,
+        no_norm_on_lateral: bool = False,
+        conv_cfg: OptConfigType = None,
+        norm_cfg: OptConfigType = None,
+        act_cfg: OptConfigType = None,
+        upsample_cfg: ConfigType = dict(mode='nearest'),
+        init_cfg: MultiConfig = dict(
+            type='Xavier', layer='Conv2d', distribution='uniform')
+    ) -> None:
+        super().__init__(init_cfg=init_cfg)
+        assert isinstance(in_channels, list)
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.num_ins = len(in_channels)
+        self.num_outs = num_outs
+        self.relu_before_extra_convs = relu_before_extra_convs
+        self.no_norm_on_lateral = no_norm_on_lateral
+        self.fp16_enabled = False
+        self.upsample_cfg = upsample_cfg.copy()
+
+        if end_level == -1 or end_level == self.num_ins - 1:
+            self.backbone_end_level = self.num_ins
+            assert num_outs >= self.num_ins - start_level
+        else:
+            # if end_level is not the last level, no extra level is allowed
+            self.backbone_end_level = end_level + 1
+            assert end_level < self.num_ins
+            assert num_outs == end_level - start_level + 1
+        self.start_level = start_level
+        self.end_level = end_level
+        self.add_extra_convs = add_extra_convs
+        assert isinstance(add_extra_convs, (str, bool))
+        if isinstance(add_extra_convs, str):
+            # Extra_convs_source choices: 'on_input', 'on_lateral', 'on_output'
+            assert add_extra_convs in ('on_input', 'on_lateral', 'on_output')
+        elif add_extra_convs:  # True
+            self.add_extra_convs = 'on_input'
+
+        self.lateral_convs = nn.ModuleList()
+        self.fpn_convs = nn.ModuleList()
+
+        for i in range(self.start_level, self.backbone_end_level):
+            l_conv = ConvModule(
+                in_channels[i],
+                out_channels,
+                1,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg if not self.no_norm_on_lateral else None,
+                act_cfg=act_cfg,
+                inplace=False)
+            fpn_conv = ConvModule(
+                out_channels,
+                out_channels,
+                3,
+                padding=1,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg,
+                inplace=False)
+
+            self.lateral_convs.append(l_conv)
+            self.fpn_convs.append(fpn_conv)
+
+        # add extra conv layers (e.g., RetinaNet)
+        extra_levels = num_outs - self.backbone_end_level + self.start_level
+        if self.add_extra_convs and extra_levels >= 1:
+            for i in range(extra_levels):
+                if i == 0 and self.add_extra_convs == 'on_input':
+                    in_channels = self.in_channels[self.backbone_end_level - 1]
+                else:
+                    in_channels = out_channels
+                extra_fpn_conv = ConvModule(
+                    in_channels,
+                    out_channels,
+                    3,
+                    stride=2,
+                    padding=1,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg,
+                    inplace=False)
+                self.fpn_convs.append(extra_fpn_conv)
+
+    def forward(self, inputs: Tuple[Tensor]) -> tuple:
+        """Forward function.
+
+        Args:
+            inputs (tuple[Tensor]): Features from the upstream network, each
+                is a 4D-tensor.
+
+        Returns:
+            tuple: Feature maps, each is a 4D-tensor.
+        """
+        assert len(inputs) == len(self.in_channels)
+
+        # build laterals
+        laterals = [
+            lateral_conv(inputs[i + self.start_level])
+            for i, lateral_conv in enumerate(self.lateral_convs)
+        ]
+
+        # build top-down path
+        used_backbone_levels = len(laterals)
+        for i in range(used_backbone_levels - 1, 0, -1):
+            # In some cases, fixing `scale factor` (e.g. 2) is preferred, but
+            #  it cannot co-exist with `size` in `F.interpolate`.
+            if 'scale_factor' in self.upsample_cfg:
+                # fix runtime error of "+=" inplace operation in PyTorch 1.10
+                laterals[i - 1] = laterals[i - 1] + F.interpolate(
+                    laterals[i], **self.upsample_cfg)
+            else:
+                prev_shape = laterals[i - 1].shape[2:]
+                laterals[i - 1] = laterals[i - 1] + F.interpolate(
+                    laterals[i], size=prev_shape, **self.upsample_cfg)
+
+        # build outputs
+        # part 1: from original levels
+        outs = [
+            self.fpn_convs[i](laterals[i]) for i in range(used_backbone_levels)
+        ]
+        # part 2: add extra levels
+        if self.num_outs > len(outs):
+            # use max pool to get more levels on top of outputs
+            # (e.g., Faster R-CNN, Mask R-CNN)
+            if not self.add_extra_convs:
+                for i in range(self.num_outs - used_backbone_levels):
+                    outs.append(F.max_pool2d(outs[-1], 1, stride=2))
+            # add conv layers on top of original feature maps (RetinaNet)
+            else:
+                if self.add_extra_convs == 'on_input':
+                    extra_source = inputs[self.backbone_end_level - 1]
+                elif self.add_extra_convs == 'on_lateral':
+                    extra_source = laterals[-1]
+                elif self.add_extra_convs == 'on_output':
+                    extra_source = outs[-1]
+                else:
+                    raise NotImplementedError
+                outs.append(self.fpn_convs[used_backbone_levels](extra_source))
+                for i in range(used_backbone_levels + 1, self.num_outs):
+                    if self.relu_before_extra_convs:
+                        outs.append(self.fpn_convs[i](F.relu(outs[-1])))
+                    else:
+                        outs.append(self.fpn_convs[i](outs[-1]))
+        return tuple(outs)
diff --git a/mmdetection/mmdet/models/necks/fpn_carafe.py b/mmdetection/mmdet/models/necks/fpn_carafe.py
new file mode 100644
index 00000000..b393ff7c
--- /dev/null
+++ b/mmdetection/mmdet/models/necks/fpn_carafe.py
@@ -0,0 +1,275 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch.nn as nn
+from mmcv.cnn import ConvModule, build_upsample_layer
+from mmcv.ops.carafe import CARAFEPack
+from mmengine.model import BaseModule, ModuleList, xavier_init
+
+from mmdet.registry import MODELS
+
+
+@MODELS.register_module()
+class FPN_CARAFE(BaseModule):
+    """FPN_CARAFE is a more flexible implementation of FPN. It allows more
+    choice for upsample methods during the top-down pathway.
+
+    It can reproduce the performance of ICCV 2019 paper
+    CARAFE: Content-Aware ReAssembly of FEatures
+    Please refer to https://arxiv.org/abs/1905.02188 for more details.
+
+    Args:
+        in_channels (list[int]): Number of channels for each input feature map.
+        out_channels (int): Output channels of feature pyramids.
+        num_outs (int): Number of output stages.
+        start_level (int): Start level of feature pyramids.
+            (Default: 0)
+        end_level (int): End level of feature pyramids.
+            (Default: -1 indicates the last level).
+        norm_cfg (dict): Dictionary to construct and config norm layer.
+        activate (str): Type of activation function in ConvModule
+            (Default: None indicates w/o activation).
+        order (dict): Order of components in ConvModule.
+        upsample (str): Type of upsample layer.
+        upsample_cfg (dict): Dictionary to construct and config upsample layer.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 num_outs,
+                 start_level=0,
+                 end_level=-1,
+                 norm_cfg=None,
+                 act_cfg=None,
+                 order=('conv', 'norm', 'act'),
+                 upsample_cfg=dict(
+                     type='carafe',
+                     up_kernel=5,
+                     up_group=1,
+                     encoder_kernel=3,
+                     encoder_dilation=1),
+                 init_cfg=None):
+        assert init_cfg is None, 'To prevent abnormal initialization ' \
+                                 'behavior, init_cfg is not allowed to be set'
+        super(FPN_CARAFE, self).__init__(init_cfg)
+        assert isinstance(in_channels, list)
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.num_ins = len(in_channels)
+        self.num_outs = num_outs
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+        self.with_bias = norm_cfg is None
+        self.upsample_cfg = upsample_cfg.copy()
+        self.upsample = self.upsample_cfg.get('type')
+        self.relu = nn.ReLU(inplace=False)
+
+        self.order = order
+        assert order in [('conv', 'norm', 'act'), ('act', 'conv', 'norm')]
+
+        assert self.upsample in [
+            'nearest', 'bilinear', 'deconv', 'pixel_shuffle', 'carafe', None
+        ]
+        if self.upsample in ['deconv', 'pixel_shuffle']:
+            assert hasattr(
+                self.upsample_cfg,
+                'upsample_kernel') and self.upsample_cfg.upsample_kernel > 0
+            self.upsample_kernel = self.upsample_cfg.pop('upsample_kernel')
+
+        if end_level == -1 or end_level == self.num_ins - 1:
+            self.backbone_end_level = self.num_ins
+            assert num_outs >= self.num_ins - start_level
+        else:
+            # if end_level is not the last level, no extra level is allowed
+            self.backbone_end_level = end_level + 1
+            assert end_level < self.num_ins
+            assert num_outs == end_level - start_level + 1
+        self.start_level = start_level
+        self.end_level = end_level
+
+        self.lateral_convs = ModuleList()
+        self.fpn_convs = ModuleList()
+        self.upsample_modules = ModuleList()
+
+        for i in range(self.start_level, self.backbone_end_level):
+            l_conv = ConvModule(
+                in_channels[i],
+                out_channels,
+                1,
+                norm_cfg=norm_cfg,
+                bias=self.with_bias,
+                act_cfg=act_cfg,
+                inplace=False,
+                order=self.order)
+            fpn_conv = ConvModule(
+                out_channels,
+                out_channels,
+                3,
+                padding=1,
+                norm_cfg=self.norm_cfg,
+                bias=self.with_bias,
+                act_cfg=act_cfg,
+                inplace=False,
+                order=self.order)
+            if i != self.backbone_end_level - 1:
+                upsample_cfg_ = self.upsample_cfg.copy()
+                if self.upsample == 'deconv':
+                    upsample_cfg_.update(
+                        in_channels=out_channels,
+                        out_channels=out_channels,
+                        kernel_size=self.upsample_kernel,
+                        stride=2,
+                        padding=(self.upsample_kernel - 1) // 2,
+                        output_padding=(self.upsample_kernel - 1) // 2)
+                elif self.upsample == 'pixel_shuffle':
+                    upsample_cfg_.update(
+                        in_channels=out_channels,
+                        out_channels=out_channels,
+                        scale_factor=2,
+                        upsample_kernel=self.upsample_kernel)
+                elif self.upsample == 'carafe':
+                    upsample_cfg_.update(channels=out_channels, scale_factor=2)
+                else:
+                    # suppress warnings
+                    align_corners = (None
+                                     if self.upsample == 'nearest' else False)
+                    upsample_cfg_.update(
+                        scale_factor=2,
+                        mode=self.upsample,
+                        align_corners=align_corners)
+                upsample_module = build_upsample_layer(upsample_cfg_)
+                self.upsample_modules.append(upsample_module)
+            self.lateral_convs.append(l_conv)
+            self.fpn_convs.append(fpn_conv)
+
+        # add extra conv layers (e.g., RetinaNet)
+        extra_out_levels = (
+            num_outs - self.backbone_end_level + self.start_level)
+        if extra_out_levels >= 1:
+            for i in range(extra_out_levels):
+                in_channels = (
+                    self.in_channels[self.backbone_end_level -
+                                     1] if i == 0 else out_channels)
+                extra_l_conv = ConvModule(
+                    in_channels,
+                    out_channels,
+                    3,
+                    stride=2,
+                    padding=1,
+                    norm_cfg=norm_cfg,
+                    bias=self.with_bias,
+                    act_cfg=act_cfg,
+                    inplace=False,
+                    order=self.order)
+                if self.upsample == 'deconv':
+                    upsampler_cfg_ = dict(
+                        in_channels=out_channels,
+                        out_channels=out_channels,
+                        kernel_size=self.upsample_kernel,
+                        stride=2,
+                        padding=(self.upsample_kernel - 1) // 2,
+                        output_padding=(self.upsample_kernel - 1) // 2)
+                elif self.upsample == 'pixel_shuffle':
+                    upsampler_cfg_ = dict(
+                        in_channels=out_channels,
+                        out_channels=out_channels,
+                        scale_factor=2,
+                        upsample_kernel=self.upsample_kernel)
+                elif self.upsample == 'carafe':
+                    upsampler_cfg_ = dict(
+                        channels=out_channels,
+                        scale_factor=2,
+                        **self.upsample_cfg)
+                else:
+                    # suppress warnings
+                    align_corners = (None
+                                     if self.upsample == 'nearest' else False)
+                    upsampler_cfg_ = dict(
+                        scale_factor=2,
+                        mode=self.upsample,
+                        align_corners=align_corners)
+                upsampler_cfg_['type'] = self.upsample
+                upsample_module = build_upsample_layer(upsampler_cfg_)
+                extra_fpn_conv = ConvModule(
+                    out_channels,
+                    out_channels,
+                    3,
+                    padding=1,
+                    norm_cfg=self.norm_cfg,
+                    bias=self.with_bias,
+                    act_cfg=act_cfg,
+                    inplace=False,
+                    order=self.order)
+                self.upsample_modules.append(upsample_module)
+                self.fpn_convs.append(extra_fpn_conv)
+                self.lateral_convs.append(extra_l_conv)
+
+    # default init_weights for conv(msra) and norm in ConvModule
+    def init_weights(self):
+        """Initialize the weights of module."""
+        super(FPN_CARAFE, self).init_weights()
+        for m in self.modules():
+            if isinstance(m, (nn.Conv2d, nn.ConvTranspose2d)):
+                xavier_init(m, distribution='uniform')
+        for m in self.modules():
+            if isinstance(m, CARAFEPack):
+                m.init_weights()
+
+    def slice_as(self, src, dst):
+        """Slice ``src`` as ``dst``
+
+        Note:
+            ``src`` should have the same or larger size than ``dst``.
+
+        Args:
+            src (torch.Tensor): Tensors to be sliced.
+            dst (torch.Tensor): ``src`` will be sliced to have the same
+                size as ``dst``.
+
+        Returns:
+            torch.Tensor: Sliced tensor.
+        """
+        assert (src.size(2) >= dst.size(2)) and (src.size(3) >= dst.size(3))
+        if src.size(2) == dst.size(2) and src.size(3) == dst.size(3):
+            return src
+        else:
+            return src[:, :, :dst.size(2), :dst.size(3)]
+
+    def tensor_add(self, a, b):
+        """Add tensors ``a`` and ``b`` that might have different sizes."""
+        if a.size() == b.size():
+            c = a + b
+        else:
+            c = a + self.slice_as(b, a)
+        return c
+
+    def forward(self, inputs):
+        """Forward function."""
+        assert len(inputs) == len(self.in_channels)
+
+        # build laterals
+        laterals = []
+        for i, lateral_conv in enumerate(self.lateral_convs):
+            if i <= self.backbone_end_level - self.start_level:
+                input = inputs[min(i + self.start_level, len(inputs) - 1)]
+            else:
+                input = laterals[-1]
+            lateral = lateral_conv(input)
+            laterals.append(lateral)
+
+        # build top-down path
+        for i in range(len(laterals) - 1, 0, -1):
+            if self.upsample is not None:
+                upsample_feat = self.upsample_modules[i - 1](laterals[i])
+            else:
+                upsample_feat = laterals[i]
+            laterals[i - 1] = self.tensor_add(laterals[i - 1], upsample_feat)
+
+        # build outputs
+        num_conv_outs = len(self.fpn_convs)
+        outs = []
+        for i in range(num_conv_outs):
+            out = self.fpn_convs[i](laterals[i])
+            outs.append(out)
+        return tuple(outs)
diff --git a/mmdetection/mmdet/models/necks/fpn_dropblock.py b/mmdetection/mmdet/models/necks/fpn_dropblock.py
new file mode 100644
index 00000000..473af924
--- /dev/null
+++ b/mmdetection/mmdet/models/necks/fpn_dropblock.py
@@ -0,0 +1,90 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Tuple
+
+import torch.nn.functional as F
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from .fpn import FPN
+
+
+@MODELS.register_module()
+class FPN_DropBlock(FPN):
+
+    def __init__(self,
+                 *args,
+                 plugin: Optional[dict] = dict(
+                     type='DropBlock',
+                     drop_prob=0.3,
+                     block_size=3,
+                     warmup_iters=0),
+                 **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.plugin = None
+        if plugin is not None:
+            self.plugin = MODELS.build(plugin)
+
+    def forward(self, inputs: Tuple[Tensor]) -> tuple:
+        """Forward function.
+
+        Args:
+            inputs (tuple[Tensor]): Features from the upstream network, each
+                is a 4D-tensor.
+
+        Returns:
+            tuple: Feature maps, each is a 4D-tensor.
+        """
+        assert len(inputs) == len(self.in_channels)
+
+        # build laterals
+        laterals = [
+            lateral_conv(inputs[i + self.start_level])
+            for i, lateral_conv in enumerate(self.lateral_convs)
+        ]
+
+        # build top-down path
+        used_backbone_levels = len(laterals)
+        for i in range(used_backbone_levels - 1, 0, -1):
+            # In some cases, fixing `scale factor` (e.g. 2) is preferred, but
+            #  it cannot co-exist with `size` in `F.interpolate`.
+            if 'scale_factor' in self.upsample_cfg:
+                # fix runtime error of "+=" inplace operation in PyTorch 1.10
+                laterals[i - 1] = laterals[i - 1] + F.interpolate(
+                    laterals[i], **self.upsample_cfg)
+            else:
+                prev_shape = laterals[i - 1].shape[2:]
+                laterals[i - 1] = laterals[i - 1] + F.interpolate(
+                    laterals[i], size=prev_shape, **self.upsample_cfg)
+
+            if self.plugin is not None:
+                laterals[i - 1] = self.plugin(laterals[i - 1])
+
+        # build outputs
+        # part 1: from original levels
+        outs = [
+            self.fpn_convs[i](laterals[i]) for i in range(used_backbone_levels)
+        ]
+        # part 2: add extra levels
+        if self.num_outs > len(outs):
+            # use max pool to get more levels on top of outputs
+            # (e.g., Faster R-CNN, Mask R-CNN)
+            if not self.add_extra_convs:
+                for i in range(self.num_outs - used_backbone_levels):
+                    outs.append(F.max_pool2d(outs[-1], 1, stride=2))
+            # add conv layers on top of original feature maps (RetinaNet)
+            else:
+                if self.add_extra_convs == 'on_input':
+                    extra_source = inputs[self.backbone_end_level - 1]
+                elif self.add_extra_convs == 'on_lateral':
+                    extra_source = laterals[-1]
+                elif self.add_extra_convs == 'on_output':
+                    extra_source = outs[-1]
+                else:
+                    raise NotImplementedError
+                outs.append(self.fpn_convs[used_backbone_levels](extra_source))
+                for i in range(used_backbone_levels + 1, self.num_outs):
+                    if self.relu_before_extra_convs:
+                        outs.append(self.fpn_convs[i](F.relu(outs[-1])))
+                    else:
+                        outs.append(self.fpn_convs[i](outs[-1]))
+        return tuple(outs)
diff --git a/mmdetection/mmdet/models/necks/hrfpn.py b/mmdetection/mmdet/models/necks/hrfpn.py
new file mode 100644
index 00000000..d2627549
--- /dev/null
+++ b/mmdetection/mmdet/models/necks/hrfpn.py
@@ -0,0 +1,100 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule
+from torch.utils.checkpoint import checkpoint
+
+from mmdet.registry import MODELS
+
+
+@MODELS.register_module()
+class HRFPN(BaseModule):
+    """HRFPN (High Resolution Feature Pyramids)
+
+    paper: `High-Resolution Representations for Labeling Pixels and Regions
+    `_.
+
+    Args:
+        in_channels (list): number of channels for each branch.
+        out_channels (int): output channels of feature pyramids.
+        num_outs (int): number of output stages.
+        pooling_type (str): pooling for generating feature pyramids
+            from {MAX, AVG}.
+        conv_cfg (dict): dictionary to construct and config conv layer.
+        norm_cfg (dict): dictionary to construct and config norm layer.
+        with_cp  (bool): Use checkpoint or not. Using checkpoint will save some
+            memory while slowing down the training speed.
+        stride (int): stride of 3x3 convolutional layers
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 num_outs=5,
+                 pooling_type='AVG',
+                 conv_cfg=None,
+                 norm_cfg=None,
+                 with_cp=False,
+                 stride=1,
+                 init_cfg=dict(type='Caffe2Xavier', layer='Conv2d')):
+        super(HRFPN, self).__init__(init_cfg)
+        assert isinstance(in_channels, list)
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.num_ins = len(in_channels)
+        self.num_outs = num_outs
+        self.with_cp = with_cp
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+
+        self.reduction_conv = ConvModule(
+            sum(in_channels),
+            out_channels,
+            kernel_size=1,
+            conv_cfg=self.conv_cfg,
+            act_cfg=None)
+
+        self.fpn_convs = nn.ModuleList()
+        for i in range(self.num_outs):
+            self.fpn_convs.append(
+                ConvModule(
+                    out_channels,
+                    out_channels,
+                    kernel_size=3,
+                    padding=1,
+                    stride=stride,
+                    conv_cfg=self.conv_cfg,
+                    act_cfg=None))
+
+        if pooling_type == 'MAX':
+            self.pooling = F.max_pool2d
+        else:
+            self.pooling = F.avg_pool2d
+
+    def forward(self, inputs):
+        """Forward function."""
+        assert len(inputs) == self.num_ins
+        outs = [inputs[0]]
+        for i in range(1, self.num_ins):
+            outs.append(
+                F.interpolate(inputs[i], scale_factor=2**i, mode='bilinear'))
+        out = torch.cat(outs, dim=1)
+        if out.requires_grad and self.with_cp:
+            out = checkpoint(self.reduction_conv, out)
+        else:
+            out = self.reduction_conv(out)
+        outs = [out]
+        for i in range(1, self.num_outs):
+            outs.append(self.pooling(out, kernel_size=2**i, stride=2**i))
+        outputs = []
+
+        for i in range(self.num_outs):
+            if outs[i].requires_grad and self.with_cp:
+                tmp_out = checkpoint(self.fpn_convs[i], outs[i])
+            else:
+                tmp_out = self.fpn_convs[i](outs[i])
+            outputs.append(tmp_out)
+        return tuple(outputs)
diff --git a/mmdetection/mmdet/models/necks/nas_fpn.py b/mmdetection/mmdet/models/necks/nas_fpn.py
new file mode 100644
index 00000000..8ec90cd6
--- /dev/null
+++ b/mmdetection/mmdet/models/necks/nas_fpn.py
@@ -0,0 +1,171 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple
+
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmcv.ops.merge_cells import GlobalPoolingCell, SumCell
+from mmengine.model import BaseModule, ModuleList
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import MultiConfig, OptConfigType
+
+
+@MODELS.register_module()
+class NASFPN(BaseModule):
+    """NAS-FPN.
+
+    Implementation of `NAS-FPN: Learning Scalable Feature Pyramid Architecture
+    for Object Detection `_
+
+    Args:
+        in_channels (List[int]): Number of input channels per scale.
+        out_channels (int): Number of output channels (used at each scale)
+        num_outs (int): Number of output scales.
+        stack_times (int): The number of times the pyramid architecture will
+            be stacked.
+        start_level (int): Index of the start input backbone level used to
+            build the feature pyramid. Defaults to 0.
+        end_level (int): Index of the end input backbone level (exclusive) to
+            build the feature pyramid. Defaults to -1, which means the
+            last level.
+        norm_cfg (:obj:`ConfigDict` or dict, optional): Config dict for
+            normalization layer. Defaults to None.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict]): Initialization config dict.
+    """
+
+    def __init__(
+        self,
+        in_channels: List[int],
+        out_channels: int,
+        num_outs: int,
+        stack_times: int,
+        start_level: int = 0,
+        end_level: int = -1,
+        norm_cfg: OptConfigType = None,
+        init_cfg: MultiConfig = dict(type='Caffe2Xavier', layer='Conv2d')
+    ) -> None:
+        super().__init__(init_cfg=init_cfg)
+        assert isinstance(in_channels, list)
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.num_ins = len(in_channels)  # num of input feature levels
+        self.num_outs = num_outs  # num of output feature levels
+        self.stack_times = stack_times
+        self.norm_cfg = norm_cfg
+
+        if end_level == -1 or end_level == self.num_ins - 1:
+            self.backbone_end_level = self.num_ins
+            assert num_outs >= self.num_ins - start_level
+        else:
+            # if end_level is not the last level, no extra level is allowed
+            self.backbone_end_level = end_level + 1
+            assert end_level < self.num_ins
+            assert num_outs == end_level - start_level + 1
+        self.start_level = start_level
+        self.end_level = end_level
+
+        # add lateral connections
+        self.lateral_convs = nn.ModuleList()
+        for i in range(self.start_level, self.backbone_end_level):
+            l_conv = ConvModule(
+                in_channels[i],
+                out_channels,
+                1,
+                norm_cfg=norm_cfg,
+                act_cfg=None)
+            self.lateral_convs.append(l_conv)
+
+        # add extra downsample layers (stride-2 pooling or conv)
+        extra_levels = num_outs - self.backbone_end_level + self.start_level
+        self.extra_downsamples = nn.ModuleList()
+        for i in range(extra_levels):
+            extra_conv = ConvModule(
+                out_channels, out_channels, 1, norm_cfg=norm_cfg, act_cfg=None)
+            self.extra_downsamples.append(
+                nn.Sequential(extra_conv, nn.MaxPool2d(2, 2)))
+
+        # add NAS FPN connections
+        self.fpn_stages = ModuleList()
+        for _ in range(self.stack_times):
+            stage = nn.ModuleDict()
+            # gp(p6, p4) -> p4_1
+            stage['gp_64_4'] = GlobalPoolingCell(
+                in_channels=out_channels,
+                out_channels=out_channels,
+                out_norm_cfg=norm_cfg)
+            # sum(p4_1, p4) -> p4_2
+            stage['sum_44_4'] = SumCell(
+                in_channels=out_channels,
+                out_channels=out_channels,
+                out_norm_cfg=norm_cfg)
+            # sum(p4_2, p3) -> p3_out
+            stage['sum_43_3'] = SumCell(
+                in_channels=out_channels,
+                out_channels=out_channels,
+                out_norm_cfg=norm_cfg)
+            # sum(p3_out, p4_2) -> p4_out
+            stage['sum_34_4'] = SumCell(
+                in_channels=out_channels,
+                out_channels=out_channels,
+                out_norm_cfg=norm_cfg)
+            # sum(p5, gp(p4_out, p3_out)) -> p5_out
+            stage['gp_43_5'] = GlobalPoolingCell(with_out_conv=False)
+            stage['sum_55_5'] = SumCell(
+                in_channels=out_channels,
+                out_channels=out_channels,
+                out_norm_cfg=norm_cfg)
+            # sum(p7, gp(p5_out, p4_2)) -> p7_out
+            stage['gp_54_7'] = GlobalPoolingCell(with_out_conv=False)
+            stage['sum_77_7'] = SumCell(
+                in_channels=out_channels,
+                out_channels=out_channels,
+                out_norm_cfg=norm_cfg)
+            # gp(p7_out, p5_out) -> p6_out
+            stage['gp_75_6'] = GlobalPoolingCell(
+                in_channels=out_channels,
+                out_channels=out_channels,
+                out_norm_cfg=norm_cfg)
+            self.fpn_stages.append(stage)
+
+    def forward(self, inputs: Tuple[Tensor]) -> tuple:
+        """Forward function.
+
+         Args:
+            inputs (tuple[Tensor]): Features from the upstream network, each
+                is a 4D-tensor.
+
+        Returns:
+            tuple: Feature maps, each is a 4D-tensor.
+        """
+        # build P3-P5
+        feats = [
+            lateral_conv(inputs[i + self.start_level])
+            for i, lateral_conv in enumerate(self.lateral_convs)
+        ]
+        # build P6-P7 on top of P5
+        for downsample in self.extra_downsamples:
+            feats.append(downsample(feats[-1]))
+
+        p3, p4, p5, p6, p7 = feats
+
+        for stage in self.fpn_stages:
+            # gp(p6, p4) -> p4_1
+            p4_1 = stage['gp_64_4'](p6, p4, out_size=p4.shape[-2:])
+            # sum(p4_1, p4) -> p4_2
+            p4_2 = stage['sum_44_4'](p4_1, p4, out_size=p4.shape[-2:])
+            # sum(p4_2, p3) -> p3_out
+            p3 = stage['sum_43_3'](p4_2, p3, out_size=p3.shape[-2:])
+            # sum(p3_out, p4_2) -> p4_out
+            p4 = stage['sum_34_4'](p3, p4_2, out_size=p4.shape[-2:])
+            # sum(p5, gp(p4_out, p3_out)) -> p5_out
+            p5_tmp = stage['gp_43_5'](p4, p3, out_size=p5.shape[-2:])
+            p5 = stage['sum_55_5'](p5, p5_tmp, out_size=p5.shape[-2:])
+            # sum(p7, gp(p5_out, p4_2)) -> p7_out
+            p7_tmp = stage['gp_54_7'](p5, p4_2, out_size=p7.shape[-2:])
+            p7 = stage['sum_77_7'](p7, p7_tmp, out_size=p7.shape[-2:])
+            # gp(p7_out, p5_out) -> p6_out
+            p6 = stage['gp_75_6'](p7, p5, out_size=p6.shape[-2:])
+
+        return p3, p4, p5, p6, p7
diff --git a/mmdetection/mmdet/models/necks/nasfcos_fpn.py b/mmdetection/mmdet/models/necks/nasfcos_fpn.py
new file mode 100644
index 00000000..12d0848f
--- /dev/null
+++ b/mmdetection/mmdet/models/necks/nasfcos_fpn.py
@@ -0,0 +1,170 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+from mmcv.ops.merge_cells import ConcatCell
+from mmengine.model import BaseModule, caffe2_xavier_init
+
+from mmdet.registry import MODELS
+
+
+@MODELS.register_module()
+class NASFCOS_FPN(BaseModule):
+    """FPN structure in NASFPN.
+
+    Implementation of paper `NAS-FCOS: Fast Neural Architecture Search for
+    Object Detection `_
+
+    Args:
+        in_channels (List[int]): Number of input channels per scale.
+        out_channels (int): Number of output channels (used at each scale)
+        num_outs (int): Number of output scales.
+        start_level (int): Index of the start input backbone level used to
+            build the feature pyramid. Default: 0.
+        end_level (int): Index of the end input backbone level (exclusive) to
+            build the feature pyramid. Default: -1, which means the last level.
+        add_extra_convs (bool): It decides whether to add conv
+            layers on top of the original feature maps. Default to False.
+            If True, its actual mode is specified by `extra_convs_on_inputs`.
+        conv_cfg (dict): dictionary to construct and config conv layer.
+        norm_cfg (dict): dictionary to construct and config norm layer.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 num_outs,
+                 start_level=1,
+                 end_level=-1,
+                 add_extra_convs=False,
+                 conv_cfg=None,
+                 norm_cfg=None,
+                 init_cfg=None):
+        assert init_cfg is None, 'To prevent abnormal initialization ' \
+                                 'behavior, init_cfg is not allowed to be set'
+        super(NASFCOS_FPN, self).__init__(init_cfg)
+        assert isinstance(in_channels, list)
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.num_ins = len(in_channels)
+        self.num_outs = num_outs
+        self.norm_cfg = norm_cfg
+        self.conv_cfg = conv_cfg
+
+        if end_level == -1 or end_level == self.num_ins - 1:
+            self.backbone_end_level = self.num_ins
+            assert num_outs >= self.num_ins - start_level
+        else:
+            # if end_level is not the last level, no extra level is allowed
+            self.backbone_end_level = end_level + 1
+            assert end_level < self.num_ins
+            assert num_outs == end_level - start_level + 1
+        self.start_level = start_level
+        self.end_level = end_level
+        self.add_extra_convs = add_extra_convs
+
+        self.adapt_convs = nn.ModuleList()
+        for i in range(self.start_level, self.backbone_end_level):
+            adapt_conv = ConvModule(
+                in_channels[i],
+                out_channels,
+                1,
+                stride=1,
+                padding=0,
+                bias=False,
+                norm_cfg=dict(type='BN'),
+                act_cfg=dict(type='ReLU', inplace=False))
+            self.adapt_convs.append(adapt_conv)
+
+        # C2 is omitted according to the paper
+        extra_levels = num_outs - self.backbone_end_level + self.start_level
+
+        def build_concat_cell(with_input1_conv, with_input2_conv):
+            cell_conv_cfg = dict(
+                kernel_size=1, padding=0, bias=False, groups=out_channels)
+            return ConcatCell(
+                in_channels=out_channels,
+                out_channels=out_channels,
+                with_out_conv=True,
+                out_conv_cfg=cell_conv_cfg,
+                out_norm_cfg=dict(type='BN'),
+                out_conv_order=('norm', 'act', 'conv'),
+                with_input1_conv=with_input1_conv,
+                with_input2_conv=with_input2_conv,
+                input_conv_cfg=conv_cfg,
+                input_norm_cfg=norm_cfg,
+                upsample_mode='nearest')
+
+        # Denote c3=f0, c4=f1, c5=f2 for convince
+        self.fpn = nn.ModuleDict()
+        self.fpn['c22_1'] = build_concat_cell(True, True)
+        self.fpn['c22_2'] = build_concat_cell(True, True)
+        self.fpn['c32'] = build_concat_cell(True, False)
+        self.fpn['c02'] = build_concat_cell(True, False)
+        self.fpn['c42'] = build_concat_cell(True, True)
+        self.fpn['c36'] = build_concat_cell(True, True)
+        self.fpn['c61'] = build_concat_cell(True, True)  # f9
+        self.extra_downsamples = nn.ModuleList()
+        for i in range(extra_levels):
+            extra_act_cfg = None if i == 0 \
+                else dict(type='ReLU', inplace=False)
+            self.extra_downsamples.append(
+                ConvModule(
+                    out_channels,
+                    out_channels,
+                    3,
+                    stride=2,
+                    padding=1,
+                    act_cfg=extra_act_cfg,
+                    order=('act', 'norm', 'conv')))
+
+    def forward(self, inputs):
+        """Forward function."""
+        feats = [
+            adapt_conv(inputs[i + self.start_level])
+            for i, adapt_conv in enumerate(self.adapt_convs)
+        ]
+
+        for (i, module_name) in enumerate(self.fpn):
+            idx_1, idx_2 = int(module_name[1]), int(module_name[2])
+            res = self.fpn[module_name](feats[idx_1], feats[idx_2])
+            feats.append(res)
+
+        ret = []
+        for (idx, input_idx) in zip([9, 8, 7], [1, 2, 3]):  # add P3, P4, P5
+            feats1, feats2 = feats[idx], feats[5]
+            feats2_resize = F.interpolate(
+                feats2,
+                size=feats1.size()[2:],
+                mode='bilinear',
+                align_corners=False)
+
+            feats_sum = feats1 + feats2_resize
+            ret.append(
+                F.interpolate(
+                    feats_sum,
+                    size=inputs[input_idx].size()[2:],
+                    mode='bilinear',
+                    align_corners=False))
+
+        for submodule in self.extra_downsamples:
+            ret.append(submodule(ret[-1]))
+
+        return tuple(ret)
+
+    def init_weights(self):
+        """Initialize the weights of module."""
+        super(NASFCOS_FPN, self).init_weights()
+        for module in self.fpn.values():
+            if hasattr(module, 'conv_out'):
+                caffe2_xavier_init(module.out_conv.conv)
+
+        for modules in [
+                self.adapt_convs.modules(),
+                self.extra_downsamples.modules()
+        ]:
+            for module in modules:
+                if isinstance(module, nn.Conv2d):
+                    caffe2_xavier_init(module)
diff --git a/mmdetection/mmdet/models/necks/pafpn.py b/mmdetection/mmdet/models/necks/pafpn.py
new file mode 100644
index 00000000..557638f4
--- /dev/null
+++ b/mmdetection/mmdet/models/necks/pafpn.py
@@ -0,0 +1,157 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+
+from mmdet.registry import MODELS
+from .fpn import FPN
+
+
+@MODELS.register_module()
+class PAFPN(FPN):
+    """Path Aggregation Network for Instance Segmentation.
+
+    This is an implementation of the `PAFPN in Path Aggregation Network
+    `_.
+
+    Args:
+        in_channels (List[int]): Number of input channels per scale.
+        out_channels (int): Number of output channels (used at each scale)
+        num_outs (int): Number of output scales.
+        start_level (int): Index of the start input backbone level used to
+            build the feature pyramid. Default: 0.
+        end_level (int): Index of the end input backbone level (exclusive) to
+            build the feature pyramid. Default: -1, which means the last level.
+        add_extra_convs (bool | str): If bool, it decides whether to add conv
+            layers on top of the original feature maps. Default to False.
+            If True, it is equivalent to `add_extra_convs='on_input'`.
+            If str, it specifies the source feature map of the extra convs.
+            Only the following options are allowed
+
+            - 'on_input': Last feat map of neck inputs (i.e. backbone feature).
+            - 'on_lateral':  Last feature map after lateral convs.
+            - 'on_output': The last output feature map after fpn convs.
+        relu_before_extra_convs (bool): Whether to apply relu before the extra
+            conv. Default: False.
+        no_norm_on_lateral (bool): Whether to apply norm on lateral.
+            Default: False.
+        conv_cfg (dict): Config dict for convolution layer. Default: None.
+        norm_cfg (dict): Config dict for normalization layer. Default: None.
+        act_cfg (str): Config dict for activation layer in ConvModule.
+            Default: None.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 num_outs,
+                 start_level=0,
+                 end_level=-1,
+                 add_extra_convs=False,
+                 relu_before_extra_convs=False,
+                 no_norm_on_lateral=False,
+                 conv_cfg=None,
+                 norm_cfg=None,
+                 act_cfg=None,
+                 init_cfg=dict(
+                     type='Xavier', layer='Conv2d', distribution='uniform')):
+        super(PAFPN, self).__init__(
+            in_channels,
+            out_channels,
+            num_outs,
+            start_level,
+            end_level,
+            add_extra_convs,
+            relu_before_extra_convs,
+            no_norm_on_lateral,
+            conv_cfg,
+            norm_cfg,
+            act_cfg,
+            init_cfg=init_cfg)
+        # add extra bottom up pathway
+        self.downsample_convs = nn.ModuleList()
+        self.pafpn_convs = nn.ModuleList()
+        for i in range(self.start_level + 1, self.backbone_end_level):
+            d_conv = ConvModule(
+                out_channels,
+                out_channels,
+                3,
+                stride=2,
+                padding=1,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg,
+                inplace=False)
+            pafpn_conv = ConvModule(
+                out_channels,
+                out_channels,
+                3,
+                padding=1,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg,
+                inplace=False)
+            self.downsample_convs.append(d_conv)
+            self.pafpn_convs.append(pafpn_conv)
+
+    def forward(self, inputs):
+        """Forward function."""
+        assert len(inputs) == len(self.in_channels)
+
+        # build laterals
+        laterals = [
+            lateral_conv(inputs[i + self.start_level])
+            for i, lateral_conv in enumerate(self.lateral_convs)
+        ]
+
+        # build top-down path
+        used_backbone_levels = len(laterals)
+        for i in range(used_backbone_levels - 1, 0, -1):
+            prev_shape = laterals[i - 1].shape[2:]
+            laterals[i - 1] = laterals[i - 1] + F.interpolate(
+                laterals[i], size=prev_shape, mode='nearest')
+
+        # build outputs
+        # part 1: from original levels
+        inter_outs = [
+            self.fpn_convs[i](laterals[i]) for i in range(used_backbone_levels)
+        ]
+
+        # part 2: add bottom-up path
+        for i in range(0, used_backbone_levels - 1):
+            inter_outs[i + 1] = inter_outs[i + 1] + \
+                                self.downsample_convs[i](inter_outs[i])
+
+        outs = []
+        outs.append(inter_outs[0])
+        outs.extend([
+            self.pafpn_convs[i - 1](inter_outs[i])
+            for i in range(1, used_backbone_levels)
+        ])
+
+        # part 3: add extra levels
+        if self.num_outs > len(outs):
+            # use max pool to get more levels on top of outputs
+            # (e.g., Faster R-CNN, Mask R-CNN)
+            if not self.add_extra_convs:
+                for i in range(self.num_outs - used_backbone_levels):
+                    outs.append(F.max_pool2d(outs[-1], 1, stride=2))
+            # add conv layers on top of original feature maps (RetinaNet)
+            else:
+                if self.add_extra_convs == 'on_input':
+                    orig = inputs[self.backbone_end_level - 1]
+                    outs.append(self.fpn_convs[used_backbone_levels](orig))
+                elif self.add_extra_convs == 'on_lateral':
+                    outs.append(self.fpn_convs[used_backbone_levels](
+                        laterals[-1]))
+                elif self.add_extra_convs == 'on_output':
+                    outs.append(self.fpn_convs[used_backbone_levels](outs[-1]))
+                else:
+                    raise NotImplementedError
+                for i in range(used_backbone_levels + 1, self.num_outs):
+                    if self.relu_before_extra_convs:
+                        outs.append(self.fpn_convs[i](F.relu(outs[-1])))
+                    else:
+                        outs.append(self.fpn_convs[i](outs[-1]))
+        return tuple(outs)
diff --git a/mmdetection/mmdet/models/necks/rfp.py b/mmdetection/mmdet/models/necks/rfp.py
new file mode 100644
index 00000000..7ec9b375
--- /dev/null
+++ b/mmdetection/mmdet/models/necks/rfp.py
@@ -0,0 +1,134 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmengine.model import BaseModule, ModuleList, constant_init, xavier_init
+
+from mmdet.registry import MODELS
+from .fpn import FPN
+
+
+class ASPP(BaseModule):
+    """ASPP (Atrous Spatial Pyramid Pooling)
+
+    This is an implementation of the ASPP module used in DetectoRS
+    (https://arxiv.org/pdf/2006.02334.pdf)
+
+    Args:
+        in_channels (int): Number of input channels.
+        out_channels (int): Number of channels produced by this module
+        dilations (tuple[int]): Dilations of the four branches.
+            Default: (1, 3, 6, 1)
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 dilations=(1, 3, 6, 1),
+                 init_cfg=dict(type='Kaiming', layer='Conv2d')):
+        super().__init__(init_cfg)
+        assert dilations[-1] == 1
+        self.aspp = nn.ModuleList()
+        for dilation in dilations:
+            kernel_size = 3 if dilation > 1 else 1
+            padding = dilation if dilation > 1 else 0
+            conv = nn.Conv2d(
+                in_channels,
+                out_channels,
+                kernel_size=kernel_size,
+                stride=1,
+                dilation=dilation,
+                padding=padding,
+                bias=True)
+            self.aspp.append(conv)
+        self.gap = nn.AdaptiveAvgPool2d(1)
+
+    def forward(self, x):
+        avg_x = self.gap(x)
+        out = []
+        for aspp_idx in range(len(self.aspp)):
+            inp = avg_x if (aspp_idx == len(self.aspp) - 1) else x
+            out.append(F.relu_(self.aspp[aspp_idx](inp)))
+        out[-1] = out[-1].expand_as(out[-2])
+        out = torch.cat(out, dim=1)
+        return out
+
+
+@MODELS.register_module()
+class RFP(FPN):
+    """RFP (Recursive Feature Pyramid)
+
+    This is an implementation of RFP in `DetectoRS
+    `_. Different from standard FPN, the
+    input of RFP should be multi level features along with origin input image
+    of backbone.
+
+    Args:
+        rfp_steps (int): Number of unrolled steps of RFP.
+        rfp_backbone (dict): Configuration of the backbone for RFP.
+        aspp_out_channels (int): Number of output channels of ASPP module.
+        aspp_dilations (tuple[int]): Dilation rates of four branches.
+            Default: (1, 3, 6, 1)
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None
+    """
+
+    def __init__(self,
+                 rfp_steps,
+                 rfp_backbone,
+                 aspp_out_channels,
+                 aspp_dilations=(1, 3, 6, 1),
+                 init_cfg=None,
+                 **kwargs):
+        assert init_cfg is None, 'To prevent abnormal initialization ' \
+                                 'behavior, init_cfg is not allowed to be set'
+        super().__init__(init_cfg=init_cfg, **kwargs)
+        self.rfp_steps = rfp_steps
+        # Be careful! Pretrained weights cannot be loaded when use
+        # nn.ModuleList
+        self.rfp_modules = ModuleList()
+        for rfp_idx in range(1, rfp_steps):
+            rfp_module = MODELS.build(rfp_backbone)
+            self.rfp_modules.append(rfp_module)
+        self.rfp_aspp = ASPP(self.out_channels, aspp_out_channels,
+                             aspp_dilations)
+        self.rfp_weight = nn.Conv2d(
+            self.out_channels,
+            1,
+            kernel_size=1,
+            stride=1,
+            padding=0,
+            bias=True)
+
+    def init_weights(self):
+        # Avoid using super().init_weights(), which may alter the default
+        # initialization of the modules in self.rfp_modules that have missing
+        # keys in the pretrained checkpoint.
+        for convs in [self.lateral_convs, self.fpn_convs]:
+            for m in convs.modules():
+                if isinstance(m, nn.Conv2d):
+                    xavier_init(m, distribution='uniform')
+        for rfp_idx in range(self.rfp_steps - 1):
+            self.rfp_modules[rfp_idx].init_weights()
+        constant_init(self.rfp_weight, 0)
+
+    def forward(self, inputs):
+        inputs = list(inputs)
+        assert len(inputs) == len(self.in_channels) + 1  # +1 for input image
+        img = inputs.pop(0)
+        # FPN forward
+        x = super().forward(tuple(inputs))
+        for rfp_idx in range(self.rfp_steps - 1):
+            rfp_feats = [x[0]] + list(
+                self.rfp_aspp(x[i]) for i in range(1, len(x)))
+            x_idx = self.rfp_modules[rfp_idx].rfp_forward(img, rfp_feats)
+            # FPN forward
+            x_idx = super().forward(x_idx)
+            x_new = []
+            for ft_idx in range(len(x_idx)):
+                add_weight = torch.sigmoid(self.rfp_weight(x_idx[ft_idx]))
+                x_new.append(add_weight * x_idx[ft_idx] +
+                             (1 - add_weight) * x[ft_idx])
+            x = x_new
+        return x
diff --git a/mmdetection/mmdet/models/necks/ssd_neck.py b/mmdetection/mmdet/models/necks/ssd_neck.py
new file mode 100644
index 00000000..17ba3193
--- /dev/null
+++ b/mmdetection/mmdet/models/necks/ssd_neck.py
@@ -0,0 +1,129 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule, DepthwiseSeparableConvModule
+from mmengine.model import BaseModule
+
+from mmdet.registry import MODELS
+
+
+@MODELS.register_module()
+class SSDNeck(BaseModule):
+    """Extra layers of SSD backbone to generate multi-scale feature maps.
+
+    Args:
+        in_channels (Sequence[int]): Number of input channels per scale.
+        out_channels (Sequence[int]): Number of output channels per scale.
+        level_strides (Sequence[int]): Stride of 3x3 conv per level.
+        level_paddings (Sequence[int]): Padding size of 3x3 conv per level.
+        l2_norm_scale (float|None): L2 normalization layer init scale.
+            If None, not use L2 normalization on the first input feature.
+        last_kernel_size (int): Kernel size of the last conv layer.
+            Default: 3.
+        use_depthwise (bool): Whether to use DepthwiseSeparableConv.
+            Default: False.
+        conv_cfg (dict): Config dict for convolution layer. Default: None.
+        norm_cfg (dict): Dictionary to construct and config norm layer.
+            Default: None.
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='ReLU').
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 level_strides,
+                 level_paddings,
+                 l2_norm_scale=20.,
+                 last_kernel_size=3,
+                 use_depthwise=False,
+                 conv_cfg=None,
+                 norm_cfg=None,
+                 act_cfg=dict(type='ReLU'),
+                 init_cfg=[
+                     dict(
+                         type='Xavier', distribution='uniform',
+                         layer='Conv2d'),
+                     dict(type='Constant', val=1, layer='BatchNorm2d'),
+                 ]):
+        super(SSDNeck, self).__init__(init_cfg)
+        assert len(out_channels) > len(in_channels)
+        assert len(out_channels) - len(in_channels) == len(level_strides)
+        assert len(level_strides) == len(level_paddings)
+        assert in_channels == out_channels[:len(in_channels)]
+
+        if l2_norm_scale:
+            self.l2_norm = L2Norm(in_channels[0], l2_norm_scale)
+            self.init_cfg += [
+                dict(
+                    type='Constant',
+                    val=self.l2_norm.scale,
+                    override=dict(name='l2_norm'))
+            ]
+
+        self.extra_layers = nn.ModuleList()
+        extra_layer_channels = out_channels[len(in_channels):]
+        second_conv = DepthwiseSeparableConvModule if \
+            use_depthwise else ConvModule
+
+        for i, (out_channel, stride, padding) in enumerate(
+                zip(extra_layer_channels, level_strides, level_paddings)):
+            kernel_size = last_kernel_size \
+                if i == len(extra_layer_channels) - 1 else 3
+            per_lvl_convs = nn.Sequential(
+                ConvModule(
+                    out_channels[len(in_channels) - 1 + i],
+                    out_channel // 2,
+                    1,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg),
+                second_conv(
+                    out_channel // 2,
+                    out_channel,
+                    kernel_size,
+                    stride=stride,
+                    padding=padding,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg))
+            self.extra_layers.append(per_lvl_convs)
+
+    def forward(self, inputs):
+        """Forward function."""
+        outs = [feat for feat in inputs]
+        if hasattr(self, 'l2_norm'):
+            outs[0] = self.l2_norm(outs[0])
+
+        feat = outs[-1]
+        for layer in self.extra_layers:
+            feat = layer(feat)
+            outs.append(feat)
+        return tuple(outs)
+
+
+class L2Norm(nn.Module):
+
+    def __init__(self, n_dims, scale=20., eps=1e-10):
+        """L2 normalization layer.
+
+        Args:
+            n_dims (int): Number of dimensions to be normalized
+            scale (float, optional): Defaults to 20..
+            eps (float, optional): Used to avoid division by zero.
+                Defaults to 1e-10.
+        """
+        super(L2Norm, self).__init__()
+        self.n_dims = n_dims
+        self.weight = nn.Parameter(torch.Tensor(self.n_dims))
+        self.eps = eps
+        self.scale = scale
+
+    def forward(self, x):
+        """Forward function."""
+        # normalization layer convert to FP32 in FP16 training
+        x_float = x.float()
+        norm = x_float.pow(2).sum(1, keepdim=True).sqrt() + self.eps
+        return (self.weight[None, :, None, None].float().expand_as(x_float) *
+                x_float / norm).type_as(x)
diff --git a/mmdetection/mmdet/models/necks/ssh.py b/mmdetection/mmdet/models/necks/ssh.py
new file mode 100644
index 00000000..75a65614
--- /dev/null
+++ b/mmdetection/mmdet/models/necks/ssh.py
@@ -0,0 +1,216 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple
+
+import torch
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule
+
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+
+
+class SSHContextModule(BaseModule):
+    """This is an implementation of `SSH context module` described in `SSH:
+    Single Stage Headless Face Detector.
+
+    `_.
+
+    Args:
+        in_channels (int): Number of input channels used at each scale.
+        out_channels (int): Number of output channels used at each scale.
+        conv_cfg (:obj:`ConfigDict` or dict, optional): Config dict for
+            convolution layer. Defaults to None.
+        norm_cfg (:obj:`ConfigDict` or dict): Config dict for normalization
+            layer. Defaults to dict(type='BN').
+        init_cfg (:obj:`ConfigDict` or list[:obj:`ConfigDict`] or dict or
+            list[dict], optional): Initialization config dict.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 in_channels: int,
+                 out_channels: int,
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: ConfigType = dict(type='BN'),
+                 init_cfg: OptMultiConfig = None):
+        super().__init__(init_cfg=init_cfg)
+        assert out_channels % 4 == 0
+
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+
+        self.conv5x5_1 = ConvModule(
+            self.in_channels,
+            self.out_channels // 4,
+            3,
+            stride=1,
+            padding=1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+        )
+
+        self.conv5x5_2 = ConvModule(
+            self.out_channels // 4,
+            self.out_channels // 4,
+            3,
+            stride=1,
+            padding=1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=None)
+
+        self.conv7x7_2 = ConvModule(
+            self.out_channels // 4,
+            self.out_channels // 4,
+            3,
+            stride=1,
+            padding=1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+        )
+
+        self.conv7x7_3 = ConvModule(
+            self.out_channels // 4,
+            self.out_channels // 4,
+            3,
+            stride=1,
+            padding=1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=None,
+        )
+
+    def forward(self, x: torch.Tensor) -> tuple:
+        conv5x5_1 = self.conv5x5_1(x)
+        conv5x5 = self.conv5x5_2(conv5x5_1)
+        conv7x7_2 = self.conv7x7_2(conv5x5_1)
+        conv7x7 = self.conv7x7_3(conv7x7_2)
+
+        return (conv5x5, conv7x7)
+
+
+class SSHDetModule(BaseModule):
+    """This is an implementation of `SSH detection module` described in `SSH:
+    Single Stage Headless Face Detector.
+
+    `_.
+
+    Args:
+        in_channels (int): Number of input channels used at each scale.
+        out_channels (int): Number of output channels used at each scale.
+        conv_cfg (:obj:`ConfigDict` or dict, optional): Config dict for
+            convolution layer. Defaults to None.
+        norm_cfg (:obj:`ConfigDict` or dict): Config dict for normalization
+            layer. Defaults to dict(type='BN').
+        init_cfg (:obj:`ConfigDict` or list[:obj:`ConfigDict`] or dict or
+            list[dict], optional): Initialization config dict.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 in_channels: int,
+                 out_channels: int,
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: ConfigType = dict(type='BN'),
+                 init_cfg: OptMultiConfig = None):
+        super().__init__(init_cfg=init_cfg)
+        assert out_channels % 4 == 0
+
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+
+        self.conv3x3 = ConvModule(
+            self.in_channels,
+            self.out_channels // 2,
+            3,
+            stride=1,
+            padding=1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=None)
+
+        self.context_module = SSHContextModule(
+            in_channels=self.in_channels,
+            out_channels=self.out_channels,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        conv3x3 = self.conv3x3(x)
+        conv5x5, conv7x7 = self.context_module(x)
+        out = torch.cat([conv3x3, conv5x5, conv7x7], dim=1)
+        out = F.relu(out)
+
+        return out
+
+
+@MODELS.register_module()
+class SSH(BaseModule):
+    """`SSH Neck` used in `SSH: Single Stage Headless Face Detector.
+
+    `_.
+
+    Args:
+        num_scales (int): The number of scales / stages.
+        in_channels (list[int]): The number of input channels per scale.
+        out_channels (list[int]): The number of output channels  per scale.
+        conv_cfg (:obj:`ConfigDict` or dict, optional): Config dict for
+            convolution layer. Defaults to None.
+        norm_cfg (:obj:`ConfigDict` or dict): Config dict for normalization
+            layer. Defaults to dict(type='BN').
+        init_cfg (:obj:`ConfigDict` or list[:obj:`ConfigDict`] or dict or
+            list[dict], optional): Initialization config dict.
+
+    Example:
+        >>> import torch
+        >>> in_channels = [8, 16, 32, 64]
+        >>> out_channels = [16, 32, 64, 128]
+        >>> scales = [340, 170, 84, 43]
+        >>> inputs = [torch.rand(1, c, s, s)
+        ...           for c, s in zip(in_channels, scales)]
+        >>> self = SSH(num_scales=4, in_channels=in_channels,
+        ...           out_channels=out_channels)
+        >>> outputs = self.forward(inputs)
+        >>> for i in range(len(outputs)):
+        ...     print(f'outputs[{i}].shape = {outputs[i].shape}')
+        outputs[0].shape = torch.Size([1, 16, 340, 340])
+        outputs[1].shape = torch.Size([1, 32, 170, 170])
+        outputs[2].shape = torch.Size([1, 64, 84, 84])
+        outputs[3].shape = torch.Size([1, 128, 43, 43])
+    """
+
+    def __init__(self,
+                 num_scales: int,
+                 in_channels: List[int],
+                 out_channels: List[int],
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: ConfigType = dict(type='BN'),
+                 init_cfg: OptMultiConfig = dict(
+                     type='Xavier', layer='Conv2d', distribution='uniform')):
+        super().__init__(init_cfg=init_cfg)
+        assert (num_scales == len(in_channels) == len(out_channels))
+        self.num_scales = num_scales
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+
+        for idx in range(self.num_scales):
+            in_c, out_c = self.in_channels[idx], self.out_channels[idx]
+            self.add_module(
+                f'ssh_module{idx}',
+                SSHDetModule(
+                    in_channels=in_c,
+                    out_channels=out_c,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg))
+
+    def forward(self, inputs: Tuple[torch.Tensor]) -> tuple:
+        assert len(inputs) == self.num_scales
+
+        outs = []
+        for idx, x in enumerate(inputs):
+            ssh_module = getattr(self, f'ssh_module{idx}')
+            out = ssh_module(x)
+            outs.append(out)
+
+        return tuple(outs)
diff --git a/mmdetection/mmdet/models/necks/yolo_neck.py b/mmdetection/mmdet/models/necks/yolo_neck.py
new file mode 100644
index 00000000..48a6b1a4
--- /dev/null
+++ b/mmdetection/mmdet/models/necks/yolo_neck.py
@@ -0,0 +1,145 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# Copyright (c) 2019 Western Digital Corporation or its affiliates.
+from typing import List, Tuple
+
+import torch
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+
+
+class DetectionBlock(BaseModule):
+    """Detection block in YOLO neck.
+
+    Let out_channels = n, the DetectionBlock contains:
+    Six ConvLayers, 1 Conv2D Layer and 1 YoloLayer.
+    The first 6 ConvLayers are formed the following way:
+        1x1xn, 3x3x2n, 1x1xn, 3x3x2n, 1x1xn, 3x3x2n.
+    The Conv2D layer is 1x1x255.
+    Some block will have branch after the fifth ConvLayer.
+    The input channel is arbitrary (in_channels)
+
+    Args:
+        in_channels (int): The number of input channels.
+        out_channels (int): The number of output channels.
+        conv_cfg (dict): Config dict for convolution layer. Default: None.
+        norm_cfg (dict): Dictionary to construct and config norm layer.
+            Default: dict(type='BN', requires_grad=True)
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='LeakyReLU', negative_slope=0.1).
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None
+    """
+
+    def __init__(self,
+                 in_channels: int,
+                 out_channels: int,
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: ConfigType = dict(type='BN', requires_grad=True),
+                 act_cfg: ConfigType = dict(
+                     type='LeakyReLU', negative_slope=0.1),
+                 init_cfg: OptMultiConfig = None) -> None:
+        super(DetectionBlock, self).__init__(init_cfg)
+        double_out_channels = out_channels * 2
+
+        # shortcut
+        cfg = dict(conv_cfg=conv_cfg, norm_cfg=norm_cfg, act_cfg=act_cfg)
+        self.conv1 = ConvModule(in_channels, out_channels, 1, **cfg)
+        self.conv2 = ConvModule(
+            out_channels, double_out_channels, 3, padding=1, **cfg)
+        self.conv3 = ConvModule(double_out_channels, out_channels, 1, **cfg)
+        self.conv4 = ConvModule(
+            out_channels, double_out_channels, 3, padding=1, **cfg)
+        self.conv5 = ConvModule(double_out_channels, out_channels, 1, **cfg)
+
+    def forward(self, x: Tensor) -> Tensor:
+        tmp = self.conv1(x)
+        tmp = self.conv2(tmp)
+        tmp = self.conv3(tmp)
+        tmp = self.conv4(tmp)
+        out = self.conv5(tmp)
+        return out
+
+
+@MODELS.register_module()
+class YOLOV3Neck(BaseModule):
+    """The neck of YOLOV3.
+
+    It can be treated as a simplified version of FPN. It
+    will take the result from Darknet backbone and do some upsampling and
+    concatenation. It will finally output the detection result.
+
+    Note:
+        The input feats should be from top to bottom.
+            i.e., from high-lvl to low-lvl
+        But YOLOV3Neck will process them in reversed order.
+            i.e., from bottom (high-lvl) to top (low-lvl)
+
+    Args:
+        num_scales (int): The number of scales / stages.
+        in_channels (List[int]): The number of input channels per scale.
+        out_channels (List[int]): The number of output channels  per scale.
+        conv_cfg (dict, optional): Config dict for convolution layer.
+            Default: None.
+        norm_cfg (dict, optional): Dictionary to construct and config norm
+            layer. Default: dict(type='BN', requires_grad=True)
+        act_cfg (dict, optional): Config dict for activation layer.
+            Default: dict(type='LeakyReLU', negative_slope=0.1).
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None
+    """
+
+    def __init__(self,
+                 num_scales: int,
+                 in_channels: List[int],
+                 out_channels: List[int],
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: ConfigType = dict(type='BN', requires_grad=True),
+                 act_cfg: ConfigType = dict(
+                     type='LeakyReLU', negative_slope=0.1),
+                 init_cfg: OptMultiConfig = None) -> None:
+        super(YOLOV3Neck, self).__init__(init_cfg)
+        assert (num_scales == len(in_channels) == len(out_channels))
+        self.num_scales = num_scales
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+
+        # shortcut
+        cfg = dict(conv_cfg=conv_cfg, norm_cfg=norm_cfg, act_cfg=act_cfg)
+
+        # To support arbitrary scales, the code looks awful, but it works.
+        # Better solution is welcomed.
+        self.detect1 = DetectionBlock(in_channels[0], out_channels[0], **cfg)
+        for i in range(1, self.num_scales):
+            in_c, out_c = self.in_channels[i], self.out_channels[i]
+            inter_c = out_channels[i - 1]
+            self.add_module(f'conv{i}', ConvModule(inter_c, out_c, 1, **cfg))
+            # in_c + out_c : High-lvl feats will be cat with low-lvl feats
+            self.add_module(f'detect{i+1}',
+                            DetectionBlock(in_c + out_c, out_c, **cfg))
+
+    def forward(self, feats=Tuple[Tensor]) -> Tuple[Tensor]:
+        assert len(feats) == self.num_scales
+
+        # processed from bottom (high-lvl) to top (low-lvl)
+        outs = []
+        out = self.detect1(feats[-1])
+        outs.append(out)
+
+        for i, x in enumerate(reversed(feats[:-1])):
+            conv = getattr(self, f'conv{i+1}')
+            tmp = conv(out)
+
+            # Cat with low-lvl feats
+            tmp = F.interpolate(tmp, scale_factor=2)
+            tmp = torch.cat((tmp, x), 1)
+
+            detect = getattr(self, f'detect{i+2}')
+            out = detect(tmp)
+            outs.append(out)
+
+        return tuple(outs)
diff --git a/mmdetection/mmdet/models/necks/yolox_pafpn.py b/mmdetection/mmdet/models/necks/yolox_pafpn.py
new file mode 100644
index 00000000..8ec3d12b
--- /dev/null
+++ b/mmdetection/mmdet/models/necks/yolox_pafpn.py
@@ -0,0 +1,156 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import math
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule, DepthwiseSeparableConvModule
+from mmengine.model import BaseModule
+
+from mmdet.registry import MODELS
+from ..layers import CSPLayer
+
+
+@MODELS.register_module()
+class YOLOXPAFPN(BaseModule):
+    """Path Aggregation Network used in YOLOX.
+
+    Args:
+        in_channels (List[int]): Number of input channels per scale.
+        out_channels (int): Number of output channels (used at each scale)
+        num_csp_blocks (int): Number of bottlenecks in CSPLayer. Default: 3
+        use_depthwise (bool): Whether to depthwise separable convolution in
+            blocks. Default: False
+        upsample_cfg (dict): Config dict for interpolate layer.
+            Default: `dict(scale_factor=2, mode='nearest')`
+        conv_cfg (dict, optional): Config dict for convolution layer.
+            Default: None, which means using conv2d.
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: dict(type='BN')
+        act_cfg (dict): Config dict for activation layer.
+            Default: dict(type='Swish')
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Default: None.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 num_csp_blocks=3,
+                 use_depthwise=False,
+                 upsample_cfg=dict(scale_factor=2, mode='nearest'),
+                 conv_cfg=None,
+                 norm_cfg=dict(type='BN', momentum=0.03, eps=0.001),
+                 act_cfg=dict(type='Swish'),
+                 init_cfg=dict(
+                     type='Kaiming',
+                     layer='Conv2d',
+                     a=math.sqrt(5),
+                     distribution='uniform',
+                     mode='fan_in',
+                     nonlinearity='leaky_relu')):
+        super(YOLOXPAFPN, self).__init__(init_cfg)
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+
+        conv = DepthwiseSeparableConvModule if use_depthwise else ConvModule
+
+        # build top-down blocks
+        self.upsample = nn.Upsample(**upsample_cfg)
+        self.reduce_layers = nn.ModuleList()
+        self.top_down_blocks = nn.ModuleList()
+        for idx in range(len(in_channels) - 1, 0, -1):
+            self.reduce_layers.append(
+                ConvModule(
+                    in_channels[idx],
+                    in_channels[idx - 1],
+                    1,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg))
+            self.top_down_blocks.append(
+                CSPLayer(
+                    in_channels[idx - 1] * 2,
+                    in_channels[idx - 1],
+                    num_blocks=num_csp_blocks,
+                    add_identity=False,
+                    use_depthwise=use_depthwise,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg))
+
+        # build bottom-up blocks
+        self.downsamples = nn.ModuleList()
+        self.bottom_up_blocks = nn.ModuleList()
+        for idx in range(len(in_channels) - 1):
+            self.downsamples.append(
+                conv(
+                    in_channels[idx],
+                    in_channels[idx],
+                    3,
+                    stride=2,
+                    padding=1,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg))
+            self.bottom_up_blocks.append(
+                CSPLayer(
+                    in_channels[idx] * 2,
+                    in_channels[idx + 1],
+                    num_blocks=num_csp_blocks,
+                    add_identity=False,
+                    use_depthwise=use_depthwise,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg))
+
+        self.out_convs = nn.ModuleList()
+        for i in range(len(in_channels)):
+            self.out_convs.append(
+                ConvModule(
+                    in_channels[i],
+                    out_channels,
+                    1,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                    act_cfg=act_cfg))
+
+    def forward(self, inputs):
+        """
+        Args:
+            inputs (tuple[Tensor]): input features.
+
+        Returns:
+            tuple[Tensor]: YOLOXPAFPN features.
+        """
+        assert len(inputs) == len(self.in_channels)
+
+        # top-down path
+        inner_outs = [inputs[-1]]
+        for idx in range(len(self.in_channels) - 1, 0, -1):
+            feat_heigh = inner_outs[0]
+            feat_low = inputs[idx - 1]
+            feat_heigh = self.reduce_layers[len(self.in_channels) - 1 - idx](
+                feat_heigh)
+            inner_outs[0] = feat_heigh
+
+            upsample_feat = self.upsample(feat_heigh)
+
+            inner_out = self.top_down_blocks[len(self.in_channels) - 1 - idx](
+                torch.cat([upsample_feat, feat_low], 1))
+            inner_outs.insert(0, inner_out)
+
+        # bottom-up path
+        outs = [inner_outs[0]]
+        for idx in range(len(self.in_channels) - 1):
+            feat_low = outs[-1]
+            feat_height = inner_outs[idx + 1]
+            downsample_feat = self.downsamples[idx](feat_low)
+            out = self.bottom_up_blocks[idx](
+                torch.cat([downsample_feat, feat_height], 1))
+            outs.append(out)
+
+        # out convs
+        for idx, conv in enumerate(self.out_convs):
+            outs[idx] = conv(outs[idx])
+
+        return tuple(outs)
diff --git a/mmdetection/mmdet/models/reid/__init__.py b/mmdetection/mmdet/models/reid/__init__.py
new file mode 100644
index 00000000..aca617f7
--- /dev/null
+++ b/mmdetection/mmdet/models/reid/__init__.py
@@ -0,0 +1,7 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .base_reid import BaseReID
+from .fc_module import FcModule
+from .gap import GlobalAveragePooling
+from .linear_reid_head import LinearReIDHead
+
+__all__ = ['BaseReID', 'GlobalAveragePooling', 'LinearReIDHead', 'FcModule']
diff --git a/mmdetection/mmdet/models/reid/base_reid.py b/mmdetection/mmdet/models/reid/base_reid.py
new file mode 100644
index 00000000..4c459643
--- /dev/null
+++ b/mmdetection/mmdet/models/reid/base_reid.py
@@ -0,0 +1,65 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional
+
+import torch
+
+try:
+    import mmpretrain
+    from mmpretrain.models.classifiers import ImageClassifier
+except ImportError:
+    mmpretrain = None
+    ImageClassifier = object
+
+from mmdet.registry import MODELS
+from mmdet.structures import ReIDDataSample
+
+
+@MODELS.register_module()
+class BaseReID(ImageClassifier):
+    """Base model for re-identification."""
+
+    def __init__(self, *args, **kwargs):
+        if mmpretrain is None:
+            raise RuntimeError('Please run "pip install openmim" and '
+                               'run "mim install mmpretrain" to '
+                               'install mmpretrain first.')
+        super().__init__(*args, **kwargs)
+
+    def forward(self,
+                inputs: torch.Tensor,
+                data_samples: Optional[List[ReIDDataSample]] = None,
+                mode: str = 'tensor'):
+        """The unified entry for a forward process in both training and test.
+
+        The method should accept three modes: "tensor", "predict" and "loss":
+
+        - "tensor": Forward the whole network and return tensor or tuple of
+          tensor without any post-processing, same as a common nn.Module.
+        - "predict": Forward and return the predictions, which are fully
+          processed to a list of :obj:`ReIDDataSample`.
+        - "loss": Forward and return a dict of losses according to the given
+          inputs and data samples.
+
+        Note that this method doesn't handle neither back propagation nor
+        optimizer updating, which are done in the :meth:`train_step`.
+
+        Args:
+            inputs (torch.Tensor): The input tensor with shape
+                (N, C, H, W) or (N, T, C, H, W).
+            data_samples (List[ReIDDataSample], optional): The annotation
+                data of every sample. It's required if ``mode="loss"``.
+                Defaults to None.
+            mode (str): Return what kind of value. Defaults to 'tensor'.
+
+        Returns:
+            The return type depends on ``mode``.
+
+            - If ``mode="tensor"``, return a tensor or a tuple of tensor.
+            - If ``mode="predict"``, return a list of
+              :obj:`ReIDDataSample`.
+            - If ``mode="loss"``, return a dict of tensor.
+        """
+        if len(inputs.size()) == 5:
+            assert inputs.size(0) == 1
+            inputs = inputs[0]
+        return super().forward(inputs, data_samples, mode)
diff --git a/mmdetection/mmdet/models/reid/fc_module.py b/mmdetection/mmdet/models/reid/fc_module.py
new file mode 100644
index 00000000..76e7efd6
--- /dev/null
+++ b/mmdetection/mmdet/models/reid/fc_module.py
@@ -0,0 +1,71 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch.nn as nn
+from mmcv.cnn import build_activation_layer, build_norm_layer
+from mmengine.model import BaseModule
+
+from mmdet.registry import MODELS
+
+
+@MODELS.register_module()
+class FcModule(BaseModule):
+    """Fully-connected layer module.
+
+    Args:
+        in_channels (int): Input channels.
+        out_channels (int): Ourput channels.
+        norm_cfg (dict, optional): Configuration of normlization method
+            after fc. Defaults to None.
+        act_cfg (dict, optional): Configuration of activation method after fc.
+            Defaults to dict(type='ReLU').
+        inplace (bool, optional): Whether inplace the activatation module.
+            Defaults to True.
+        init_cfg (dict, optional): Initialization config dict.
+            Defaults to dict(type='Kaiming', layer='Linear').
+    """
+
+    def __init__(self,
+                 in_channels: int,
+                 out_channels: int,
+                 norm_cfg: dict = None,
+                 act_cfg: dict = dict(type='ReLU'),
+                 inplace: bool = True,
+                 init_cfg=dict(type='Kaiming', layer='Linear')):
+        super(FcModule, self).__init__(init_cfg)
+        assert norm_cfg is None or isinstance(norm_cfg, dict)
+        assert act_cfg is None or isinstance(act_cfg, dict)
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+        self.inplace = inplace
+
+        self.with_norm = norm_cfg is not None
+        self.with_activation = act_cfg is not None
+
+        self.fc = nn.Linear(in_channels, out_channels)
+        # build normalization layers
+        if self.with_norm:
+            self.norm_name, norm = build_norm_layer(norm_cfg, out_channels)
+            self.add_module(self.norm_name, norm)
+
+        # build activation layer
+        if self.with_activation:
+            act_cfg_ = act_cfg.copy()
+            # nn.Tanh has no 'inplace' argument
+            if act_cfg_['type'] not in [
+                    'Tanh', 'PReLU', 'Sigmoid', 'HSigmoid', 'Swish'
+            ]:
+                act_cfg_.setdefault('inplace', inplace)
+            self.activate = build_activation_layer(act_cfg_)
+
+    @property
+    def norm(self):
+        """Normalization."""
+        return getattr(self, self.norm_name)
+
+    def forward(self, x, activate=True, norm=True):
+        """Model forward."""
+        x = self.fc(x)
+        if norm and self.with_norm:
+            x = self.norm(x)
+        if activate and self.with_activation:
+            x = self.activate(x)
+        return x
diff --git a/mmdetection/mmdet/models/reid/gap.py b/mmdetection/mmdet/models/reid/gap.py
new file mode 100644
index 00000000..aadc25e7
--- /dev/null
+++ b/mmdetection/mmdet/models/reid/gap.py
@@ -0,0 +1,40 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn as nn
+from mmengine.model import BaseModule
+
+from mmdet.registry import MODELS
+
+
+@MODELS.register_module()
+class GlobalAveragePooling(BaseModule):
+    """Global Average Pooling neck.
+
+    Note that we use `view` to remove extra channel after pooling. We do not
+    use `squeeze` as it will also remove the batch dimension when the tensor
+    has a batch dimension of size 1, which can lead to unexpected errors.
+    """
+
+    def __init__(self, kernel_size=None, stride=None):
+        super(GlobalAveragePooling, self).__init__()
+        if kernel_size is None and stride is None:
+            self.gap = nn.AdaptiveAvgPool2d((1, 1))
+        else:
+            self.gap = nn.AvgPool2d(kernel_size, stride)
+
+    def forward(self, inputs):
+        if isinstance(inputs, tuple):
+            outs = tuple([self.gap(x) for x in inputs])
+            outs = tuple([
+                out.view(x.size(0),
+                         torch.tensor(out.size()[1:]).prod())
+                for out, x in zip(outs, inputs)
+            ])
+        elif isinstance(inputs, torch.Tensor):
+            outs = self.gap(inputs)
+            outs = outs.view(
+                inputs.size(0),
+                torch.tensor(outs.size()[1:]).prod())
+        else:
+            raise TypeError('neck inputs should be tuple or torch.tensor')
+        return outs
diff --git a/mmdetection/mmdet/models/reid/linear_reid_head.py b/mmdetection/mmdet/models/reid/linear_reid_head.py
new file mode 100644
index 00000000..f35aaf6c
--- /dev/null
+++ b/mmdetection/mmdet/models/reid/linear_reid_head.py
@@ -0,0 +1,202 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+from typing import List, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+
+try:
+    import mmpretrain
+    from mmpretrain.evaluation.metrics import Accuracy
+except ImportError:
+    mmpretrain = None
+
+from mmengine.model import BaseModule
+
+from mmdet.registry import MODELS
+from mmdet.structures import ReIDDataSample
+from .fc_module import FcModule
+
+
+@MODELS.register_module()
+class LinearReIDHead(BaseModule):
+    """Linear head for re-identification.
+
+    Args:
+        num_fcs (int): Number of fcs.
+        in_channels (int): Number of channels in the input.
+        fc_channels (int): Number of channels in the fcs.
+        out_channels (int): Number of channels in the output.
+        norm_cfg (dict, optional): Configuration of normlization method
+            after fc. Defaults to None.
+        act_cfg (dict, optional): Configuration of activation method after fc.
+            Defaults to None.
+        num_classes (int, optional): Number of the identities. Default to None.
+        loss_cls (dict, optional): Cross entropy loss to train the ReID module.
+            Defaults to None.
+        loss_triplet (dict, optional): Triplet loss to train the ReID module.
+            Defaults to None.
+        topk (int | Tuple[int]): Top-k accuracy. Defaults to ``(1, )``.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Defaults to dict(type='Normal',layer='Linear', mean=0, std=0.01,
+            bias=0).
+    """
+
+    def __init__(self,
+                 num_fcs: int,
+                 in_channels: int,
+                 fc_channels: int,
+                 out_channels: int,
+                 norm_cfg: Optional[dict] = None,
+                 act_cfg: Optional[dict] = None,
+                 num_classes: Optional[int] = None,
+                 loss_cls: Optional[dict] = None,
+                 loss_triplet: Optional[dict] = None,
+                 topk: Union[int, Tuple[int]] = (1, ),
+                 init_cfg: Union[dict, List[dict]] = dict(
+                     type='Normal', layer='Linear', mean=0, std=0.01, bias=0)):
+        if mmpretrain is None:
+            raise RuntimeError('Please run "pip install openmim" and '
+                               'run "mim install mmpretrain" to '
+                               'install mmpretrain first.')
+        super(LinearReIDHead, self).__init__(init_cfg=init_cfg)
+
+        assert isinstance(topk, (int, tuple))
+        if isinstance(topk, int):
+            topk = (topk, )
+        for _topk in topk:
+            assert _topk > 0, 'Top-k should be larger than 0'
+        self.topk = topk
+
+        if loss_cls is None:
+            if isinstance(num_classes, int):
+                warnings.warn('Since cross entropy is not set, '
+                              'the num_classes will be ignored.')
+            if loss_triplet is None:
+                raise ValueError('Please choose at least one loss in '
+                                 'triplet loss and cross entropy loss.')
+        elif not isinstance(num_classes, int):
+            raise TypeError('The num_classes must be a current number, '
+                            'if there is cross entropy loss.')
+        self.loss_cls = MODELS.build(loss_cls) if loss_cls else None
+        self.loss_triplet = MODELS.build(loss_triplet) \
+            if loss_triplet else None
+
+        self.num_fcs = num_fcs
+        self.in_channels = in_channels
+        self.fc_channels = fc_channels
+        self.out_channels = out_channels
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+        self.num_classes = num_classes
+
+        self._init_layers()
+
+    def _init_layers(self):
+        """Initialize fc layers."""
+        self.fcs = nn.ModuleList()
+        for i in range(self.num_fcs):
+            in_channels = self.in_channels if i == 0 else self.fc_channels
+            self.fcs.append(
+                FcModule(in_channels, self.fc_channels, self.norm_cfg,
+                         self.act_cfg))
+        in_channels = self.in_channels if self.num_fcs == 0 else \
+            self.fc_channels
+        self.fc_out = nn.Linear(in_channels, self.out_channels)
+        if self.loss_cls:
+            self.bn = nn.BatchNorm1d(self.out_channels)
+            self.classifier = nn.Linear(self.out_channels, self.num_classes)
+
+    def forward(self, feats: Tuple[torch.Tensor]) -> torch.Tensor:
+        """The forward process."""
+        # Multiple stage inputs are acceptable
+        # but only the last stage will be used.
+        feats = feats[-1]
+
+        for m in self.fcs:
+            feats = m(feats)
+        feats = self.fc_out(feats)
+        return feats
+
+    def loss(self, feats: Tuple[torch.Tensor],
+             data_samples: List[ReIDDataSample]) -> dict:
+        """Calculate losses.
+
+        Args:
+            feats (tuple[Tensor]): The features extracted from the backbone.
+            data_samples (List[ReIDDataSample]): The annotation data of
+                every samples.
+
+        Returns:
+            dict: a dictionary of loss components
+        """
+        # The part can be traced by torch.fx
+        feats = self(feats)
+
+        # The part can not be traced by torch.fx
+        losses = self.loss_by_feat(feats, data_samples)
+        return losses
+
+    def loss_by_feat(self, feats: torch.Tensor,
+                     data_samples: List[ReIDDataSample]) -> dict:
+        """Unpack data samples and compute loss."""
+        losses = dict()
+        gt_label = torch.cat([i.gt_label.label for i in data_samples])
+        gt_label = gt_label.to(feats.device)
+
+        if self.loss_triplet:
+            losses['triplet_loss'] = self.loss_triplet(feats, gt_label)
+
+        if self.loss_cls:
+            feats_bn = self.bn(feats)
+            cls_score = self.classifier(feats_bn)
+            losses['ce_loss'] = self.loss_cls(cls_score, gt_label)
+            acc = Accuracy.calculate(cls_score, gt_label, topk=self.topk)
+            losses.update(
+                {f'accuracy_top-{k}': a
+                 for k, a in zip(self.topk, acc)})
+
+        return losses
+
+    def predict(
+            self,
+            feats: Tuple[torch.Tensor],
+            data_samples: List[ReIDDataSample] = None) -> List[ReIDDataSample]:
+        """Inference without augmentation.
+
+        Args:
+            feats (Tuple[Tensor]): The features extracted from the backbone.
+                Multiple stage inputs are acceptable but only the last stage
+                will be used.
+            data_samples (List[ReIDDataSample], optional): The annotation
+                data of every samples. If not None, set ``pred_label`` of
+                the input data samples. Defaults to None.
+
+        Returns:
+            List[ReIDDataSample]: A list of data samples which contains the
+            predicted results.
+        """
+        # The part can be traced by torch.fx
+        feats = self(feats)
+
+        # The part can not be traced by torch.fx
+        data_samples = self.predict_by_feat(feats, data_samples)
+
+        return data_samples
+
+    def predict_by_feat(
+            self,
+            feats: torch.Tensor,
+            data_samples: List[ReIDDataSample] = None) -> List[ReIDDataSample]:
+        """Add prediction features to data samples."""
+        if data_samples is not None:
+            for data_sample, feat in zip(data_samples, feats):
+                data_sample.pred_feature = feat
+        else:
+            data_samples = []
+            for feat in feats:
+                data_sample = ReIDDataSample()
+                data_sample.pred_feature = feat
+                data_samples.append(data_sample)
+
+        return data_samples
diff --git a/mmdetection/mmdet/models/roi_heads/__init__.py b/mmdetection/mmdet/models/roi_heads/__init__.py
new file mode 100644
index 00000000..bba5664c
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/__init__.py
@@ -0,0 +1,38 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .base_roi_head import BaseRoIHead
+from .bbox_heads import (BBoxHead, ConvFCBBoxHead, DIIHead,
+                         DoubleConvFCBBoxHead, SABLHead, SCNetBBoxHead,
+                         Shared2FCBBoxHead, Shared4Conv1FCBBoxHead)
+from .cascade_roi_head import CascadeRoIHead
+from .double_roi_head import DoubleHeadRoIHead
+from .dynamic_roi_head import DynamicRoIHead
+from .grid_roi_head import GridRoIHead
+from .htc_roi_head import HybridTaskCascadeRoIHead
+from .mask_heads import (CoarseMaskHead, FCNMaskHead, FeatureRelayHead,
+                         FusedSemanticHead, GlobalContextHead, GridHead,
+                         HTCMaskHead, MaskIoUHead, MaskPointHead,
+                         SCNetMaskHead, SCNetSemanticHead)
+from .mask_scoring_roi_head import MaskScoringRoIHead
+from .multi_instance_roi_head import MultiInstanceRoIHead
+from .pisa_roi_head import PISARoIHead
+from .point_rend_roi_head import PointRendRoIHead
+from .roi_extractors import (BaseRoIExtractor, GenericRoIExtractor,
+                             SingleRoIExtractor)
+from .scnet_roi_head import SCNetRoIHead
+from .shared_heads import ResLayer
+from .sparse_roi_head import SparseRoIHead
+from .standard_roi_head import StandardRoIHead
+from .trident_roi_head import TridentRoIHead
+
+__all__ = [
+    'BaseRoIHead', 'CascadeRoIHead', 'DoubleHeadRoIHead', 'MaskScoringRoIHead',
+    'HybridTaskCascadeRoIHead', 'GridRoIHead', 'ResLayer', 'BBoxHead',
+    'ConvFCBBoxHead', 'DIIHead', 'SABLHead', 'Shared2FCBBoxHead',
+    'StandardRoIHead', 'Shared4Conv1FCBBoxHead', 'DoubleConvFCBBoxHead',
+    'FCNMaskHead', 'HTCMaskHead', 'FusedSemanticHead', 'GridHead',
+    'MaskIoUHead', 'BaseRoIExtractor', 'GenericRoIExtractor',
+    'SingleRoIExtractor', 'PISARoIHead', 'PointRendRoIHead', 'MaskPointHead',
+    'CoarseMaskHead', 'DynamicRoIHead', 'SparseRoIHead', 'TridentRoIHead',
+    'SCNetRoIHead', 'SCNetMaskHead', 'SCNetSemanticHead', 'SCNetBBoxHead',
+    'FeatureRelayHead', 'GlobalContextHead', 'MultiInstanceRoIHead'
+]
diff --git a/mmdetection/mmdet/models/roi_heads/base_roi_head.py b/mmdetection/mmdet/models/roi_heads/base_roi_head.py
new file mode 100644
index 00000000..405f80a7
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/base_roi_head.py
@@ -0,0 +1,129 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from abc import ABCMeta, abstractmethod
+from typing import Tuple
+
+from mmengine.model import BaseModule
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.utils import InstanceList, OptConfigType, OptMultiConfig
+
+
+class BaseRoIHead(BaseModule, metaclass=ABCMeta):
+    """Base class for RoIHeads."""
+
+    def __init__(self,
+                 bbox_roi_extractor: OptMultiConfig = None,
+                 bbox_head: OptMultiConfig = None,
+                 mask_roi_extractor: OptMultiConfig = None,
+                 mask_head: OptMultiConfig = None,
+                 shared_head: OptConfigType = None,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+        if shared_head is not None:
+            self.shared_head = MODELS.build(shared_head)
+
+        if bbox_head is not None:
+            self.init_bbox_head(bbox_roi_extractor, bbox_head)
+
+        if mask_head is not None:
+            self.init_mask_head(mask_roi_extractor, mask_head)
+
+        self.init_assigner_sampler()
+
+    @property
+    def with_bbox(self) -> bool:
+        """bool: whether the RoI head contains a `bbox_head`"""
+        return hasattr(self, 'bbox_head') and self.bbox_head is not None
+
+    @property
+    def with_mask(self) -> bool:
+        """bool: whether the RoI head contains a `mask_head`"""
+        return hasattr(self, 'mask_head') and self.mask_head is not None
+
+    @property
+    def with_shared_head(self) -> bool:
+        """bool: whether the RoI head contains a `shared_head`"""
+        return hasattr(self, 'shared_head') and self.shared_head is not None
+
+    @abstractmethod
+    def init_bbox_head(self, *args, **kwargs):
+        """Initialize ``bbox_head``"""
+        pass
+
+    @abstractmethod
+    def init_mask_head(self, *args, **kwargs):
+        """Initialize ``mask_head``"""
+        pass
+
+    @abstractmethod
+    def init_assigner_sampler(self, *args, **kwargs):
+        """Initialize assigner and sampler."""
+        pass
+
+    @abstractmethod
+    def loss(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
+             batch_data_samples: SampleList):
+        """Perform forward propagation and loss calculation of the roi head on
+        the features of the upstream network."""
+
+    def predict(self,
+                x: Tuple[Tensor],
+                rpn_results_list: InstanceList,
+                batch_data_samples: SampleList,
+                rescale: bool = False) -> InstanceList:
+        """Perform forward propagation of the roi head and predict detection
+        results on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from upstream network. Each
+                has shape (N, C, H, W).
+            rpn_results_list (list[:obj:`InstanceData`]): list of region
+                proposals.
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            rescale (bool): Whether to rescale the results to
+                the original image. Defaults to True.
+
+        Returns:
+            list[obj:`InstanceData`]: Detection results of each image.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+                - masks (Tensor): Has a shape (num_instances, H, W).
+        """
+        assert self.with_bbox, 'Bbox head must be implemented.'
+        batch_img_metas = [
+            data_samples.metainfo for data_samples in batch_data_samples
+        ]
+
+        # TODO: nms_op in mmcv need be enhanced, the bbox result may get
+        #  difference when not rescale in bbox_head
+
+        # If it has the mask branch, the bbox branch does not need
+        # to be scaled to the original image scale, because the mask
+        # branch will scale both bbox and mask at the same time.
+        bbox_rescale = rescale if not self.with_mask else False
+        results_list = self.predict_bbox(
+            x,
+            batch_img_metas,
+            rpn_results_list,
+            rcnn_test_cfg=self.test_cfg,
+            rescale=bbox_rescale)
+
+        if self.with_mask:
+            results_list = self.predict_mask(
+                x, batch_img_metas, results_list, rescale=rescale)
+
+        return results_list
diff --git a/mmdetection/mmdet/models/roi_heads/bbox_heads/__init__.py b/mmdetection/mmdet/models/roi_heads/bbox_heads/__init__.py
new file mode 100644
index 00000000..d9e742ab
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/bbox_heads/__init__.py
@@ -0,0 +1,15 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .bbox_head import BBoxHead
+from .convfc_bbox_head import (ConvFCBBoxHead, Shared2FCBBoxHead,
+                               Shared4Conv1FCBBoxHead)
+from .dii_head import DIIHead
+from .double_bbox_head import DoubleConvFCBBoxHead
+from .multi_instance_bbox_head import MultiInstanceBBoxHead
+from .sabl_head import SABLHead
+from .scnet_bbox_head import SCNetBBoxHead
+
+__all__ = [
+    'BBoxHead', 'ConvFCBBoxHead', 'Shared2FCBBoxHead',
+    'Shared4Conv1FCBBoxHead', 'DoubleConvFCBBoxHead', 'SABLHead', 'DIIHead',
+    'SCNetBBoxHead', 'MultiInstanceBBoxHead'
+]
diff --git a/mmdetection/mmdet/models/roi_heads/bbox_heads/bbox_head.py b/mmdetection/mmdet/models/roi_heads/bbox_heads/bbox_head.py
new file mode 100644
index 00000000..3b2e8aae
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/bbox_heads/bbox_head.py
@@ -0,0 +1,708 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmengine.config import ConfigDict
+from mmengine.model import BaseModule
+from mmengine.structures import InstanceData
+from torch import Tensor
+from torch.nn.modules.utils import _pair
+
+from mmdet.models.layers import multiclass_nms
+from mmdet.models.losses import accuracy
+from mmdet.models.task_modules.samplers import SamplingResult
+from mmdet.models.utils import empty_instances, multi_apply
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.structures.bbox import get_box_tensor, scale_boxes
+from mmdet.utils import ConfigType, InstanceList, OptMultiConfig
+
+
+@MODELS.register_module()
+class BBoxHead(BaseModule):
+    """Simplest RoI head, with only two fc layers for classification and
+    regression respectively."""
+
+    def __init__(self,
+                 with_avg_pool: bool = False,
+                 with_cls: bool = True,
+                 with_reg: bool = True,
+                 roi_feat_size: int = 7,
+                 in_channels: int = 256,
+                 num_classes: int = 80,
+                 bbox_coder: ConfigType = dict(
+                     type='DeltaXYWHBBoxCoder',
+                     clip_border=True,
+                     target_means=[0., 0., 0., 0.],
+                     target_stds=[0.1, 0.1, 0.2, 0.2]),
+                 predict_box_type: str = 'hbox',
+                 reg_class_agnostic: bool = False,
+                 reg_decoded_bbox: bool = False,
+                 reg_predictor_cfg: ConfigType = dict(type='Linear'),
+                 cls_predictor_cfg: ConfigType = dict(type='Linear'),
+                 loss_cls: ConfigType = dict(
+                     type='CrossEntropyLoss',
+                     use_sigmoid=False,
+                     loss_weight=1.0),
+                 loss_bbox: ConfigType = dict(
+                     type='SmoothL1Loss', beta=1.0, loss_weight=1.0),
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(init_cfg=init_cfg)
+        assert with_cls or with_reg
+        self.with_avg_pool = with_avg_pool
+        self.with_cls = with_cls
+        self.with_reg = with_reg
+        self.roi_feat_size = _pair(roi_feat_size)
+        self.roi_feat_area = self.roi_feat_size[0] * self.roi_feat_size[1]
+        self.in_channels = in_channels
+        self.num_classes = num_classes
+        self.predict_box_type = predict_box_type
+        self.reg_class_agnostic = reg_class_agnostic
+        self.reg_decoded_bbox = reg_decoded_bbox
+        self.reg_predictor_cfg = reg_predictor_cfg
+        self.cls_predictor_cfg = cls_predictor_cfg
+
+        self.bbox_coder = TASK_UTILS.build(bbox_coder)
+        self.loss_cls = MODELS.build(loss_cls)
+        self.loss_bbox = MODELS.build(loss_bbox)
+
+        in_channels = self.in_channels
+        if self.with_avg_pool:
+            self.avg_pool = nn.AvgPool2d(self.roi_feat_size)
+        else:
+            in_channels *= self.roi_feat_area
+        if self.with_cls:
+            # need to add background class
+            if self.custom_cls_channels:
+                cls_channels = self.loss_cls.get_cls_channels(self.num_classes)
+            else:
+                cls_channels = num_classes + 1
+            cls_predictor_cfg_ = self.cls_predictor_cfg.copy()
+            cls_predictor_cfg_.update(
+                in_features=in_channels, out_features=cls_channels)
+            self.fc_cls = MODELS.build(cls_predictor_cfg_)
+        if self.with_reg:
+            box_dim = self.bbox_coder.encode_size
+            out_dim_reg = box_dim if reg_class_agnostic else \
+                box_dim * num_classes
+            reg_predictor_cfg_ = self.reg_predictor_cfg.copy()
+            if isinstance(reg_predictor_cfg_, (dict, ConfigDict)):
+                reg_predictor_cfg_.update(
+                    in_features=in_channels, out_features=out_dim_reg)
+            self.fc_reg = MODELS.build(reg_predictor_cfg_)
+        self.debug_imgs = None
+        if init_cfg is None:
+            self.init_cfg = []
+            if self.with_cls:
+                self.init_cfg += [
+                    dict(
+                        type='Normal', std=0.01, override=dict(name='fc_cls'))
+                ]
+            if self.with_reg:
+                self.init_cfg += [
+                    dict(
+                        type='Normal', std=0.001, override=dict(name='fc_reg'))
+                ]
+
+    # TODO: Create a SeasawBBoxHead to simplified logic in BBoxHead
+    @property
+    def custom_cls_channels(self) -> bool:
+        """get custom_cls_channels from loss_cls."""
+        return getattr(self.loss_cls, 'custom_cls_channels', False)
+
+    # TODO: Create a SeasawBBoxHead to simplified logic in BBoxHead
+    @property
+    def custom_activation(self) -> bool:
+        """get custom_activation from loss_cls."""
+        return getattr(self.loss_cls, 'custom_activation', False)
+
+    # TODO: Create a SeasawBBoxHead to simplified logic in BBoxHead
+    @property
+    def custom_accuracy(self) -> bool:
+        """get custom_accuracy from loss_cls."""
+        return getattr(self.loss_cls, 'custom_accuracy', False)
+
+    def forward(self, x: Tuple[Tensor]) -> tuple:
+        """Forward features from the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple: A tuple of classification scores and bbox prediction.
+
+                - cls_score (Tensor): Classification scores for all
+                  scale levels, each is a 4D-tensor, the channels number
+                  is num_base_priors * num_classes.
+                - bbox_pred (Tensor): Box energies / deltas for all
+                  scale levels, each is a 4D-tensor, the channels number
+                  is num_base_priors * 4.
+        """
+        if self.with_avg_pool:
+            if x.numel() > 0:
+                x = self.avg_pool(x)
+                x = x.view(x.size(0), -1)
+            else:
+                # avg_pool does not support empty tensor,
+                # so use torch.mean instead it
+                x = torch.mean(x, dim=(-1, -2))
+        cls_score = self.fc_cls(x) if self.with_cls else None
+        bbox_pred = self.fc_reg(x) if self.with_reg else None
+        return cls_score, bbox_pred
+
+    def _get_targets_single(self, pos_priors: Tensor, neg_priors: Tensor,
+                            pos_gt_bboxes: Tensor, pos_gt_labels: Tensor,
+                            cfg: ConfigDict) -> tuple:
+        """Calculate the ground truth for proposals in the single image
+        according to the sampling results.
+
+        Args:
+            pos_priors (Tensor): Contains all the positive boxes,
+                has shape (num_pos, 4), the last dimension 4
+                represents [tl_x, tl_y, br_x, br_y].
+            neg_priors (Tensor): Contains all the negative boxes,
+                has shape (num_neg, 4), the last dimension 4
+                represents [tl_x, tl_y, br_x, br_y].
+            pos_gt_bboxes (Tensor): Contains gt_boxes for
+                all positive samples, has shape (num_pos, 4),
+                the last dimension 4
+                represents [tl_x, tl_y, br_x, br_y].
+            pos_gt_labels (Tensor): Contains gt_labels for
+                all positive samples, has shape (num_pos, ).
+            cfg (obj:`ConfigDict`): `train_cfg` of R-CNN.
+
+        Returns:
+            Tuple[Tensor]: Ground truth for proposals
+            in a single image. Containing the following Tensors:
+
+                - labels(Tensor): Gt_labels for all proposals, has
+                  shape (num_proposals,).
+                - label_weights(Tensor): Labels_weights for all
+                  proposals, has shape (num_proposals,).
+                - bbox_targets(Tensor):Regression target for all
+                  proposals, has shape (num_proposals, 4), the
+                  last dimension 4 represents [tl_x, tl_y, br_x, br_y].
+                - bbox_weights(Tensor):Regression weights for all
+                  proposals, has shape (num_proposals, 4).
+        """
+        num_pos = pos_priors.size(0)
+        num_neg = neg_priors.size(0)
+        num_samples = num_pos + num_neg
+
+        # original implementation uses new_zeros since BG are set to be 0
+        # now use empty & fill because BG cat_id = num_classes,
+        # FG cat_id = [0, num_classes-1]
+        labels = pos_priors.new_full((num_samples, ),
+                                     self.num_classes,
+                                     dtype=torch.long)
+        reg_dim = pos_gt_bboxes.size(-1) if self.reg_decoded_bbox \
+            else self.bbox_coder.encode_size
+        label_weights = pos_priors.new_zeros(num_samples)
+        bbox_targets = pos_priors.new_zeros(num_samples, reg_dim)
+        bbox_weights = pos_priors.new_zeros(num_samples, reg_dim)
+        if num_pos > 0:
+            labels[:num_pos] = pos_gt_labels
+            pos_weight = 1.0 if cfg.pos_weight <= 0 else cfg.pos_weight
+            label_weights[:num_pos] = pos_weight
+            if not self.reg_decoded_bbox:
+                pos_bbox_targets = self.bbox_coder.encode(
+                    pos_priors, pos_gt_bboxes)
+            else:
+                # When the regression loss (e.g. `IouLoss`, `GIouLoss`)
+                # is applied directly on the decoded bounding boxes, both
+                # the predicted boxes and regression targets should be with
+                # absolute coordinate format.
+                pos_bbox_targets = get_box_tensor(pos_gt_bboxes)
+            bbox_targets[:num_pos, :] = pos_bbox_targets
+            bbox_weights[:num_pos, :] = 1
+        if num_neg > 0:
+            label_weights[-num_neg:] = 1.0
+
+        return labels, label_weights, bbox_targets, bbox_weights
+
+    def get_targets(self,
+                    sampling_results: List[SamplingResult],
+                    rcnn_train_cfg: ConfigDict,
+                    concat: bool = True) -> tuple:
+        """Calculate the ground truth for all samples in a batch according to
+        the sampling_results.
+
+        Almost the same as the implementation in bbox_head, we passed
+        additional parameters pos_inds_list and neg_inds_list to
+        `_get_targets_single` function.
+
+        Args:
+            sampling_results (List[obj:SamplingResult]): Assign results of
+                all images in a batch after sampling.
+            rcnn_train_cfg (obj:ConfigDict): `train_cfg` of RCNN.
+            concat (bool): Whether to concatenate the results of all
+                the images in a single batch.
+
+        Returns:
+            Tuple[Tensor]: Ground truth for proposals in a single image.
+            Containing the following list of Tensors:
+
+            - labels (list[Tensor],Tensor): Gt_labels for all
+                proposals in a batch, each tensor in list has
+                shape (num_proposals,) when `concat=False`, otherwise
+                just a single tensor has shape (num_all_proposals,).
+            - label_weights (list[Tensor]): Labels_weights for
+                all proposals in a batch, each tensor in list has
+                shape (num_proposals,) when `concat=False`, otherwise
+                just a single tensor has shape (num_all_proposals,).
+            - bbox_targets (list[Tensor],Tensor): Regression target
+                for all proposals in a batch, each tensor in list
+                has shape (num_proposals, 4) when `concat=False`,
+                otherwise just a single tensor has shape
+                (num_all_proposals, 4), the last dimension 4 represents
+                [tl_x, tl_y, br_x, br_y].
+            - bbox_weights (list[tensor],Tensor): Regression weights for
+                all proposals in a batch, each tensor in list has shape
+                (num_proposals, 4) when `concat=False`, otherwise just a
+                single tensor has shape (num_all_proposals, 4).
+        """
+        pos_priors_list = [res.pos_priors for res in sampling_results]
+        neg_priors_list = [res.neg_priors for res in sampling_results]
+        pos_gt_bboxes_list = [res.pos_gt_bboxes for res in sampling_results]
+        pos_gt_labels_list = [res.pos_gt_labels for res in sampling_results]
+        labels, label_weights, bbox_targets, bbox_weights = multi_apply(
+            self._get_targets_single,
+            pos_priors_list,
+            neg_priors_list,
+            pos_gt_bboxes_list,
+            pos_gt_labels_list,
+            cfg=rcnn_train_cfg)
+
+        if concat:
+            labels = torch.cat(labels, 0)
+            label_weights = torch.cat(label_weights, 0)
+            bbox_targets = torch.cat(bbox_targets, 0)
+            bbox_weights = torch.cat(bbox_weights, 0)
+        return labels, label_weights, bbox_targets, bbox_weights
+
+    def loss_and_target(self,
+                        cls_score: Tensor,
+                        bbox_pred: Tensor,
+                        rois: Tensor,
+                        sampling_results: List[SamplingResult],
+                        rcnn_train_cfg: ConfigDict,
+                        concat: bool = True,
+                        reduction_override: Optional[str] = None) -> dict:
+        """Calculate the loss based on the features extracted by the bbox head.
+
+        Args:
+            cls_score (Tensor): Classification prediction
+                results of all class, has shape
+                (batch_size * num_proposals_single_image, num_classes)
+            bbox_pred (Tensor): Regression prediction results,
+                has shape
+                (batch_size * num_proposals_single_image, 4), the last
+                dimension 4 represents [tl_x, tl_y, br_x, br_y].
+            rois (Tensor): RoIs with the shape
+                (batch_size * num_proposals_single_image, 5) where the first
+                column indicates batch id of each RoI.
+            sampling_results (List[obj:SamplingResult]): Assign results of
+                all images in a batch after sampling.
+            rcnn_train_cfg (obj:ConfigDict): `train_cfg` of RCNN.
+            concat (bool): Whether to concatenate the results of all
+                the images in a single batch. Defaults to True.
+            reduction_override (str, optional): The reduction
+                method used to override the original reduction
+                method of the loss. Options are "none",
+                "mean" and "sum". Defaults to None,
+
+        Returns:
+            dict: A dictionary of loss and targets components.
+                The targets are only used for cascade rcnn.
+        """
+
+        cls_reg_targets = self.get_targets(
+            sampling_results, rcnn_train_cfg, concat=concat)
+        losses = self.loss(
+            cls_score,
+            bbox_pred,
+            rois,
+            *cls_reg_targets,
+            reduction_override=reduction_override)
+
+        # cls_reg_targets is only for cascade rcnn
+        return dict(loss_bbox=losses, bbox_targets=cls_reg_targets)
+
+    def loss(self,
+             cls_score: Tensor,
+             bbox_pred: Tensor,
+             rois: Tensor,
+             labels: Tensor,
+             label_weights: Tensor,
+             bbox_targets: Tensor,
+             bbox_weights: Tensor,
+             reduction_override: Optional[str] = None) -> dict:
+        """Calculate the loss based on the network predictions and targets.
+
+        Args:
+            cls_score (Tensor): Classification prediction
+                results of all class, has shape
+                (batch_size * num_proposals_single_image, num_classes)
+            bbox_pred (Tensor): Regression prediction results,
+                has shape
+                (batch_size * num_proposals_single_image, 4), the last
+                dimension 4 represents [tl_x, tl_y, br_x, br_y].
+            rois (Tensor): RoIs with the shape
+                (batch_size * num_proposals_single_image, 5) where the first
+                column indicates batch id of each RoI.
+            labels (Tensor): Gt_labels for all proposals in a batch, has
+                shape (batch_size * num_proposals_single_image, ).
+            label_weights (Tensor): Labels_weights for all proposals in a
+                batch, has shape (batch_size * num_proposals_single_image, ).
+            bbox_targets (Tensor): Regression target for all proposals in a
+                batch, has shape (batch_size * num_proposals_single_image, 4),
+                the last dimension 4 represents [tl_x, tl_y, br_x, br_y].
+            bbox_weights (Tensor): Regression weights for all proposals in a
+                batch, has shape (batch_size * num_proposals_single_image, 4).
+            reduction_override (str, optional): The reduction
+                method used to override the original reduction
+                method of the loss. Options are "none",
+                "mean" and "sum". Defaults to None,
+
+        Returns:
+            dict: A dictionary of loss.
+        """
+
+        losses = dict()
+
+        if cls_score is not None:
+            avg_factor = max(torch.sum(label_weights > 0).float().item(), 1.)
+            if cls_score.numel() > 0:
+                loss_cls_ = self.loss_cls(
+                    cls_score,
+                    labels,
+                    label_weights,
+                    avg_factor=avg_factor,
+                    reduction_override=reduction_override)
+                if isinstance(loss_cls_, dict):
+                    losses.update(loss_cls_)
+                else:
+                    losses['loss_cls'] = loss_cls_
+                if self.custom_activation:
+                    acc_ = self.loss_cls.get_accuracy(cls_score, labels)
+                    losses.update(acc_)
+                else:
+                    losses['acc'] = accuracy(cls_score, labels)
+        if bbox_pred is not None:
+            bg_class_ind = self.num_classes
+            # 0~self.num_classes-1 are FG, self.num_classes is BG
+            pos_inds = (labels >= 0) & (labels < bg_class_ind)
+            # do not perform bounding box regression for BG anymore.
+            if pos_inds.any():
+                if self.reg_decoded_bbox:
+                    # When the regression loss (e.g. `IouLoss`,
+                    # `GIouLoss`, `DIouLoss`) is applied directly on
+                    # the decoded bounding boxes, it decodes the
+                    # already encoded coordinates to absolute format.
+                    bbox_pred = self.bbox_coder.decode(rois[:, 1:], bbox_pred)
+                    bbox_pred = get_box_tensor(bbox_pred)
+                if self.reg_class_agnostic:
+                    pos_bbox_pred = bbox_pred.view(
+                        bbox_pred.size(0), -1)[pos_inds.type(torch.bool)]
+                else:
+                    pos_bbox_pred = bbox_pred.view(
+                        bbox_pred.size(0), self.num_classes,
+                        -1)[pos_inds.type(torch.bool),
+                            labels[pos_inds.type(torch.bool)]]
+                losses['loss_bbox'] = self.loss_bbox(
+                    pos_bbox_pred,
+                    bbox_targets[pos_inds.type(torch.bool)],
+                    bbox_weights[pos_inds.type(torch.bool)],
+                    avg_factor=bbox_targets.size(0),
+                    reduction_override=reduction_override)
+            else:
+                losses['loss_bbox'] = bbox_pred[pos_inds].sum()
+
+        return losses
+
+    def predict_by_feat(self,
+                        rois: Tuple[Tensor],
+                        cls_scores: Tuple[Tensor],
+                        bbox_preds: Tuple[Tensor],
+                        batch_img_metas: List[dict],
+                        rcnn_test_cfg: Optional[ConfigDict] = None,
+                        rescale: bool = False) -> InstanceList:
+        """Transform a batch of output features extracted from the head into
+        bbox results.
+
+        Args:
+            rois (tuple[Tensor]): Tuple of boxes to be transformed.
+                Each has shape  (num_boxes, 5). last dimension 5 arrange as
+                (batch_index, x1, y1, x2, y2).
+            cls_scores (tuple[Tensor]): Tuple of box scores, each has shape
+                (num_boxes, num_classes + 1).
+            bbox_preds (tuple[Tensor]): Tuple of box energies / deltas, each
+                has shape (num_boxes, num_classes * 4).
+            batch_img_metas (list[dict]): List of image information.
+            rcnn_test_cfg (obj:`ConfigDict`, optional): `test_cfg` of R-CNN.
+                Defaults to None.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Instance segmentation
+            results of each image after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        assert len(cls_scores) == len(bbox_preds)
+        result_list = []
+        for img_id in range(len(batch_img_metas)):
+            img_meta = batch_img_metas[img_id]
+            results = self._predict_by_feat_single(
+                roi=rois[img_id],
+                cls_score=cls_scores[img_id],
+                bbox_pred=bbox_preds[img_id],
+                img_meta=img_meta,
+                rescale=rescale,
+                rcnn_test_cfg=rcnn_test_cfg)
+            result_list.append(results)
+
+        return result_list
+
+    def _predict_by_feat_single(
+            self,
+            roi: Tensor,
+            cls_score: Tensor,
+            bbox_pred: Tensor,
+            img_meta: dict,
+            rescale: bool = False,
+            rcnn_test_cfg: Optional[ConfigDict] = None) -> InstanceData:
+        """Transform a single image's features extracted from the head into
+        bbox results.
+
+        Args:
+            roi (Tensor): Boxes to be transformed. Has shape (num_boxes, 5).
+                last dimension 5 arrange as (batch_index, x1, y1, x2, y2).
+            cls_score (Tensor): Box scores, has shape
+                (num_boxes, num_classes + 1).
+            bbox_pred (Tensor): Box energies / deltas.
+                has shape (num_boxes, num_classes * 4).
+            img_meta (dict): image information.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            rcnn_test_cfg (obj:`ConfigDict`): `test_cfg` of Bbox Head.
+                Defaults to None
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image\
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        results = InstanceData()
+        if roi.shape[0] == 0:
+            return empty_instances([img_meta],
+                                   roi.device,
+                                   task_type='bbox',
+                                   instance_results=[results],
+                                   box_type=self.predict_box_type,
+                                   use_box_type=False,
+                                   num_classes=self.num_classes,
+                                   score_per_cls=rcnn_test_cfg is None)[0]
+
+        # some loss (Seesaw loss..) may have custom activation
+        if self.custom_cls_channels:
+            scores = self.loss_cls.get_activation(cls_score)
+        else:
+            scores = F.softmax(
+                cls_score, dim=-1) if cls_score is not None else None
+
+        img_shape = img_meta['img_shape']
+        num_rois = roi.size(0)
+        # bbox_pred would be None in some detector when with_reg is False,
+        # e.g. Grid R-CNN.
+        if bbox_pred is not None:
+            num_classes = 1 if self.reg_class_agnostic else self.num_classes
+            roi = roi.repeat_interleave(num_classes, dim=0)
+            bbox_pred = bbox_pred.view(-1, self.bbox_coder.encode_size)
+            bboxes = self.bbox_coder.decode(
+                roi[..., 1:], bbox_pred, max_shape=img_shape)
+        else:
+            bboxes = roi[:, 1:].clone()
+            if img_shape is not None and bboxes.size(-1) == 4:
+                bboxes[:, [0, 2]].clamp_(min=0, max=img_shape[1])
+                bboxes[:, [1, 3]].clamp_(min=0, max=img_shape[0])
+
+        if rescale and bboxes.size(0) > 0:
+            assert img_meta.get('scale_factor') is not None
+            scale_factor = [1 / s for s in img_meta['scale_factor']]
+            bboxes = scale_boxes(bboxes, scale_factor)
+
+        # Get the inside tensor when `bboxes` is a box type
+        bboxes = get_box_tensor(bboxes)
+        box_dim = bboxes.size(-1)
+        bboxes = bboxes.view(num_rois, -1)
+
+        if rcnn_test_cfg is None:
+            # This means that it is aug test.
+            # It needs to return the raw results without nms.
+            results.bboxes = bboxes
+            results.scores = scores
+        else:
+            det_bboxes, det_labels = multiclass_nms(
+                bboxes,
+                scores,
+                rcnn_test_cfg.score_thr,
+                rcnn_test_cfg.nms,
+                rcnn_test_cfg.max_per_img,
+                box_dim=box_dim)
+            results.bboxes = det_bboxes[:, :-1]
+            results.scores = det_bboxes[:, -1]
+            results.labels = det_labels
+        return results
+
+    def refine_bboxes(self, sampling_results: Union[List[SamplingResult],
+                                                    InstanceList],
+                      bbox_results: dict,
+                      batch_img_metas: List[dict]) -> InstanceList:
+        """Refine bboxes during training.
+
+        Args:
+            sampling_results (List[:obj:`SamplingResult`] or
+                List[:obj:`InstanceData`]): Sampling results.
+                :obj:`SamplingResult` is the real sampling results
+                calculate from bbox_head, while :obj:`InstanceData` is
+                fake sampling results, e.g., in Sparse R-CNN or QueryInst, etc.
+            bbox_results (dict): Usually is a dictionary with keys:
+
+                - `cls_score` (Tensor): Classification scores.
+                - `bbox_pred` (Tensor): Box energies / deltas.
+                - `rois` (Tensor): RoIs with the shape (n, 5) where the first
+                  column indicates batch id of each RoI.
+                - `bbox_targets` (tuple):  Ground truth for proposals in a
+                  single image. Containing the following list of Tensors:
+                  (labels, label_weights, bbox_targets, bbox_weights)
+            batch_img_metas (List[dict]): List of image information.
+
+        Returns:
+            list[:obj:`InstanceData`]: Refined bboxes of each image.
+
+        Example:
+            >>> # xdoctest: +REQUIRES(module:kwarray)
+            >>> import numpy as np
+            >>> from mmdet.models.task_modules.samplers.
+            ... sampling_result import random_boxes
+            >>> from mmdet.models.task_modules.samplers import SamplingResult
+            >>> self = BBoxHead(reg_class_agnostic=True)
+            >>> n_roi = 2
+            >>> n_img = 4
+            >>> scale = 512
+            >>> rng = np.random.RandomState(0)
+            ... batch_img_metas = [{'img_shape': (scale, scale)}
+            >>>                     for _ in range(n_img)]
+            >>> sampling_results = [SamplingResult.random(rng=10)
+            ...                     for _ in range(n_img)]
+            >>> # Create rois in the expected format
+            >>> roi_boxes = random_boxes(n_roi, scale=scale, rng=rng)
+            >>> img_ids = torch.randint(0, n_img, (n_roi,))
+            >>> img_ids = img_ids.float()
+            >>> rois = torch.cat([img_ids[:, None], roi_boxes], dim=1)
+            >>> # Create other args
+            >>> labels = torch.randint(0, 81, (scale,)).long()
+            >>> bbox_preds = random_boxes(n_roi, scale=scale, rng=rng)
+            >>> cls_score = torch.randn((scale, 81))
+            ... # For each image, pretend random positive boxes are gts
+            >>> bbox_targets = (labels, None, None, None)
+            ... bbox_results = dict(rois=rois, bbox_pred=bbox_preds,
+            ...                     cls_score=cls_score,
+            ...                     bbox_targets=bbox_targets)
+            >>> bboxes_list = self.refine_bboxes(sampling_results,
+            ...                                  bbox_results,
+            ...                                  batch_img_metas)
+            >>> print(bboxes_list)
+        """
+        pos_is_gts = [res.pos_is_gt for res in sampling_results]
+        # bbox_targets is a tuple
+        labels = bbox_results['bbox_targets'][0]
+        cls_scores = bbox_results['cls_score']
+        rois = bbox_results['rois']
+        bbox_preds = bbox_results['bbox_pred']
+        if self.custom_activation:
+            # TODO: Create a SeasawBBoxHead to simplified logic in BBoxHead
+            cls_scores = self.loss_cls.get_activation(cls_scores)
+        if cls_scores.numel() == 0:
+            return None
+        if cls_scores.shape[-1] == self.num_classes + 1:
+            # remove background class
+            cls_scores = cls_scores[:, :-1]
+        elif cls_scores.shape[-1] != self.num_classes:
+            raise ValueError('The last dim of `cls_scores` should equal to '
+                             '`num_classes` or `num_classes + 1`,'
+                             f'but got {cls_scores.shape[-1]}.')
+        labels = torch.where(labels == self.num_classes, cls_scores.argmax(1),
+                             labels)
+
+        img_ids = rois[:, 0].long().unique(sorted=True)
+        assert img_ids.numel() <= len(batch_img_metas)
+
+        results_list = []
+        for i in range(len(batch_img_metas)):
+            inds = torch.nonzero(
+                rois[:, 0] == i, as_tuple=False).squeeze(dim=1)
+            num_rois = inds.numel()
+
+            bboxes_ = rois[inds, 1:]
+            label_ = labels[inds]
+            bbox_pred_ = bbox_preds[inds]
+            img_meta_ = batch_img_metas[i]
+            pos_is_gts_ = pos_is_gts[i]
+
+            bboxes = self.regress_by_class(bboxes_, label_, bbox_pred_,
+                                           img_meta_)
+            # filter gt bboxes
+            pos_keep = 1 - pos_is_gts_
+            keep_inds = pos_is_gts_.new_ones(num_rois)
+            keep_inds[:len(pos_is_gts_)] = pos_keep
+            results = InstanceData(bboxes=bboxes[keep_inds.type(torch.bool)])
+            results_list.append(results)
+
+        return results_list
+
+    def regress_by_class(self, priors: Tensor, label: Tensor,
+                         bbox_pred: Tensor, img_meta: dict) -> Tensor:
+        """Regress the bbox for the predicted class. Used in Cascade R-CNN.
+
+        Args:
+            priors (Tensor): Priors from `rpn_head` or last stage
+                `bbox_head`, has shape (num_proposals, 4).
+            label (Tensor): Only used when `self.reg_class_agnostic`
+                is False, has shape (num_proposals, ).
+            bbox_pred (Tensor): Regression prediction of
+                current stage `bbox_head`. When `self.reg_class_agnostic`
+                is False, it has shape (n, num_classes * 4), otherwise
+                it has shape (n, 4).
+            img_meta (dict): Image meta info.
+
+        Returns:
+            Tensor: Regressed bboxes, the same shape as input rois.
+        """
+        reg_dim = self.bbox_coder.encode_size
+        if not self.reg_class_agnostic:
+            label = label * reg_dim
+            inds = torch.stack([label + i for i in range(reg_dim)], 1)
+            bbox_pred = torch.gather(bbox_pred, 1, inds)
+        assert bbox_pred.size()[1] == reg_dim
+
+        max_shape = img_meta['img_shape']
+        regressed_bboxes = self.bbox_coder.decode(
+            priors, bbox_pred, max_shape=max_shape)
+        return regressed_bboxes
diff --git a/mmdetection/mmdet/models/roi_heads/bbox_heads/convfc_bbox_head.py b/mmdetection/mmdet/models/roi_heads/bbox_heads/convfc_bbox_head.py
new file mode 100644
index 00000000..cb6aadd8
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/bbox_heads/convfc_bbox_head.py
@@ -0,0 +1,249 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Tuple, Union
+
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmengine.config import ConfigDict
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from .bbox_head import BBoxHead
+
+
+@MODELS.register_module()
+class ConvFCBBoxHead(BBoxHead):
+    r"""More general bbox head, with shared conv and fc layers and two optional
+    separated branches.
+
+    .. code-block:: none
+
+                                    /-> cls convs -> cls fcs -> cls
+        shared convs -> shared fcs
+                                    \-> reg convs -> reg fcs -> reg
+    """  # noqa: W605
+
+    def __init__(self,
+                 num_shared_convs: int = 0,
+                 num_shared_fcs: int = 0,
+                 num_cls_convs: int = 0,
+                 num_cls_fcs: int = 0,
+                 num_reg_convs: int = 0,
+                 num_reg_fcs: int = 0,
+                 conv_out_channels: int = 256,
+                 fc_out_channels: int = 1024,
+                 conv_cfg: Optional[Union[dict, ConfigDict]] = None,
+                 norm_cfg: Optional[Union[dict, ConfigDict]] = None,
+                 init_cfg: Optional[Union[dict, ConfigDict]] = None,
+                 *args,
+                 **kwargs) -> None:
+        super().__init__(*args, init_cfg=init_cfg, **kwargs)
+        assert (num_shared_convs + num_shared_fcs + num_cls_convs +
+                num_cls_fcs + num_reg_convs + num_reg_fcs > 0)
+        if num_cls_convs > 0 or num_reg_convs > 0:
+            assert num_shared_fcs == 0
+        if not self.with_cls:
+            assert num_cls_convs == 0 and num_cls_fcs == 0
+        if not self.with_reg:
+            assert num_reg_convs == 0 and num_reg_fcs == 0
+        self.num_shared_convs = num_shared_convs
+        self.num_shared_fcs = num_shared_fcs
+        self.num_cls_convs = num_cls_convs
+        self.num_cls_fcs = num_cls_fcs
+        self.num_reg_convs = num_reg_convs
+        self.num_reg_fcs = num_reg_fcs
+        self.conv_out_channels = conv_out_channels
+        self.fc_out_channels = fc_out_channels
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+
+        # add shared convs and fcs
+        self.shared_convs, self.shared_fcs, last_layer_dim = \
+            self._add_conv_fc_branch(
+                self.num_shared_convs, self.num_shared_fcs, self.in_channels,
+                True)
+        self.shared_out_channels = last_layer_dim
+
+        # add cls specific branch
+        self.cls_convs, self.cls_fcs, self.cls_last_dim = \
+            self._add_conv_fc_branch(
+                self.num_cls_convs, self.num_cls_fcs, self.shared_out_channels)
+
+        # add reg specific branch
+        self.reg_convs, self.reg_fcs, self.reg_last_dim = \
+            self._add_conv_fc_branch(
+                self.num_reg_convs, self.num_reg_fcs, self.shared_out_channels)
+
+        if self.num_shared_fcs == 0 and not self.with_avg_pool:
+            if self.num_cls_fcs == 0:
+                self.cls_last_dim *= self.roi_feat_area
+            if self.num_reg_fcs == 0:
+                self.reg_last_dim *= self.roi_feat_area
+
+        self.relu = nn.ReLU(inplace=True)
+        # reconstruct fc_cls and fc_reg since input channels are changed
+        if self.with_cls:
+            if self.custom_cls_channels:
+                cls_channels = self.loss_cls.get_cls_channels(self.num_classes)
+            else:
+                cls_channels = self.num_classes + 1
+            cls_predictor_cfg_ = self.cls_predictor_cfg.copy()
+            cls_predictor_cfg_.update(
+                in_features=self.cls_last_dim, out_features=cls_channels)
+            self.fc_cls = MODELS.build(cls_predictor_cfg_)
+        if self.with_reg:
+            box_dim = self.bbox_coder.encode_size
+            out_dim_reg = box_dim if self.reg_class_agnostic else \
+                box_dim * self.num_classes
+            reg_predictor_cfg_ = self.reg_predictor_cfg.copy()
+            if isinstance(reg_predictor_cfg_, (dict, ConfigDict)):
+                reg_predictor_cfg_.update(
+                    in_features=self.reg_last_dim, out_features=out_dim_reg)
+            self.fc_reg = MODELS.build(reg_predictor_cfg_)
+
+        if init_cfg is None:
+            # when init_cfg is None,
+            # It has been set to
+            # [[dict(type='Normal', std=0.01, override=dict(name='fc_cls'))],
+            #  [dict(type='Normal', std=0.001, override=dict(name='fc_reg'))]
+            # after `super(ConvFCBBoxHead, self).__init__()`
+            # we only need to append additional configuration
+            # for `shared_fcs`, `cls_fcs` and `reg_fcs`
+            self.init_cfg += [
+                dict(
+                    type='Xavier',
+                    distribution='uniform',
+                    override=[
+                        dict(name='shared_fcs'),
+                        dict(name='cls_fcs'),
+                        dict(name='reg_fcs')
+                    ])
+            ]
+
+    def _add_conv_fc_branch(self,
+                            num_branch_convs: int,
+                            num_branch_fcs: int,
+                            in_channels: int,
+                            is_shared: bool = False) -> tuple:
+        """Add shared or separable branch.
+
+        convs -> avg pool (optional) -> fcs
+        """
+        last_layer_dim = in_channels
+        # add branch specific conv layers
+        branch_convs = nn.ModuleList()
+        if num_branch_convs > 0:
+            for i in range(num_branch_convs):
+                conv_in_channels = (
+                    last_layer_dim if i == 0 else self.conv_out_channels)
+                branch_convs.append(
+                    ConvModule(
+                        conv_in_channels,
+                        self.conv_out_channels,
+                        3,
+                        padding=1,
+                        conv_cfg=self.conv_cfg,
+                        norm_cfg=self.norm_cfg))
+            last_layer_dim = self.conv_out_channels
+        # add branch specific fc layers
+        branch_fcs = nn.ModuleList()
+        if num_branch_fcs > 0:
+            # for shared branch, only consider self.with_avg_pool
+            # for separated branches, also consider self.num_shared_fcs
+            if (is_shared
+                    or self.num_shared_fcs == 0) and not self.with_avg_pool:
+                last_layer_dim *= self.roi_feat_area
+            for i in range(num_branch_fcs):
+                fc_in_channels = (
+                    last_layer_dim if i == 0 else self.fc_out_channels)
+                branch_fcs.append(
+                    nn.Linear(fc_in_channels, self.fc_out_channels))
+            last_layer_dim = self.fc_out_channels
+        return branch_convs, branch_fcs, last_layer_dim
+
+    def forward(self, x: Tuple[Tensor]) -> tuple:
+        """Forward features from the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple: A tuple of classification scores and bbox prediction.
+
+                - cls_score (Tensor): Classification scores for all \
+                    scale levels, each is a 4D-tensor, the channels number \
+                    is num_base_priors * num_classes.
+                - bbox_pred (Tensor): Box energies / deltas for all \
+                    scale levels, each is a 4D-tensor, the channels number \
+                    is num_base_priors * 4.
+        """
+        # shared part
+        if self.num_shared_convs > 0:
+            for conv in self.shared_convs:
+                x = conv(x)
+
+        if self.num_shared_fcs > 0:
+            if self.with_avg_pool:
+                x = self.avg_pool(x)
+
+            x = x.flatten(1)
+
+            for fc in self.shared_fcs:
+                x = self.relu(fc(x))
+        # separate branches
+        x_cls = x
+        x_reg = x
+
+        for conv in self.cls_convs:
+            x_cls = conv(x_cls)
+        if x_cls.dim() > 2:
+            if self.with_avg_pool:
+                x_cls = self.avg_pool(x_cls)
+            x_cls = x_cls.flatten(1)
+        for fc in self.cls_fcs:
+            x_cls = self.relu(fc(x_cls))
+
+        for conv in self.reg_convs:
+            x_reg = conv(x_reg)
+        if x_reg.dim() > 2:
+            if self.with_avg_pool:
+                x_reg = self.avg_pool(x_reg)
+            x_reg = x_reg.flatten(1)
+        for fc in self.reg_fcs:
+            x_reg = self.relu(fc(x_reg))
+
+        cls_score = self.fc_cls(x_cls) if self.with_cls else None
+        bbox_pred = self.fc_reg(x_reg) if self.with_reg else None
+        return cls_score, bbox_pred
+
+
+@MODELS.register_module()
+class Shared2FCBBoxHead(ConvFCBBoxHead):
+
+    def __init__(self, fc_out_channels: int = 1024, *args, **kwargs) -> None:
+        super().__init__(
+            num_shared_convs=0,
+            num_shared_fcs=2,
+            num_cls_convs=0,
+            num_cls_fcs=0,
+            num_reg_convs=0,
+            num_reg_fcs=0,
+            fc_out_channels=fc_out_channels,
+            *args,
+            **kwargs)
+
+
+@MODELS.register_module()
+class Shared4Conv1FCBBoxHead(ConvFCBBoxHead):
+
+    def __init__(self, fc_out_channels: int = 1024, *args, **kwargs) -> None:
+        super().__init__(
+            num_shared_convs=4,
+            num_shared_fcs=1,
+            num_cls_convs=0,
+            num_cls_fcs=0,
+            num_reg_convs=0,
+            num_reg_fcs=0,
+            fc_out_channels=fc_out_channels,
+            *args,
+            **kwargs)
diff --git a/mmdetection/mmdet/models/roi_heads/bbox_heads/dii_head.py b/mmdetection/mmdet/models/roi_heads/bbox_heads/dii_head.py
new file mode 100644
index 00000000..ae9a31bb
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/bbox_heads/dii_head.py
@@ -0,0 +1,422 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import build_activation_layer, build_norm_layer
+from mmcv.cnn.bricks.transformer import FFN, MultiheadAttention
+from mmengine.config import ConfigDict
+from mmengine.model import bias_init_with_prob
+from torch import Tensor
+
+from mmdet.models.losses import accuracy
+from mmdet.models.task_modules import SamplingResult
+from mmdet.models.utils import multi_apply
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, reduce_mean
+from .bbox_head import BBoxHead
+
+
+@MODELS.register_module()
+class DIIHead(BBoxHead):
+    r"""Dynamic Instance Interactive Head for `Sparse R-CNN: End-to-End Object
+    Detection with Learnable Proposals `_
+
+    Args:
+        num_classes (int): Number of class in dataset.
+            Defaults to 80.
+        num_ffn_fcs (int): The number of fully-connected
+            layers in FFNs. Defaults to 2.
+        num_heads (int): The hidden dimension of FFNs.
+            Defaults to 8.
+        num_cls_fcs (int): The number of fully-connected
+            layers in classification subnet. Defaults to 1.
+        num_reg_fcs (int): The number of fully-connected
+            layers in regression subnet. Defaults to 3.
+        feedforward_channels (int): The hidden dimension
+            of FFNs. Defaults to 2048
+        in_channels (int): Hidden_channels of MultiheadAttention.
+            Defaults to 256.
+        dropout (float): Probability of drop the channel.
+            Defaults to 0.0
+        ffn_act_cfg (:obj:`ConfigDict` or dict): The activation config
+            for FFNs.
+        dynamic_conv_cfg (:obj:`ConfigDict` or dict): The convolution
+            config for DynamicConv.
+        loss_iou (:obj:`ConfigDict` or dict): The config for iou or
+            giou loss.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict]): Initialization config dict. Defaults to None.
+    """
+
+    def __init__(self,
+                 num_classes: int = 80,
+                 num_ffn_fcs: int = 2,
+                 num_heads: int = 8,
+                 num_cls_fcs: int = 1,
+                 num_reg_fcs: int = 3,
+                 feedforward_channels: int = 2048,
+                 in_channels: int = 256,
+                 dropout: float = 0.0,
+                 ffn_act_cfg: ConfigType = dict(type='ReLU', inplace=True),
+                 dynamic_conv_cfg: ConfigType = dict(
+                     type='DynamicConv',
+                     in_channels=256,
+                     feat_channels=64,
+                     out_channels=256,
+                     input_feat_shape=7,
+                     act_cfg=dict(type='ReLU', inplace=True),
+                     norm_cfg=dict(type='LN')),
+                 loss_iou: ConfigType = dict(type='GIoULoss', loss_weight=2.0),
+                 init_cfg: OptConfigType = None,
+                 **kwargs) -> None:
+        assert init_cfg is None, 'To prevent abnormal initialization ' \
+                                 'behavior, init_cfg is not allowed to be set'
+        super().__init__(
+            num_classes=num_classes,
+            reg_decoded_bbox=True,
+            reg_class_agnostic=True,
+            init_cfg=init_cfg,
+            **kwargs)
+        self.loss_iou = MODELS.build(loss_iou)
+        self.in_channels = in_channels
+        self.fp16_enabled = False
+        self.attention = MultiheadAttention(in_channels, num_heads, dropout)
+        self.attention_norm = build_norm_layer(dict(type='LN'), in_channels)[1]
+
+        self.instance_interactive_conv = MODELS.build(dynamic_conv_cfg)
+        self.instance_interactive_conv_dropout = nn.Dropout(dropout)
+        self.instance_interactive_conv_norm = build_norm_layer(
+            dict(type='LN'), in_channels)[1]
+
+        self.ffn = FFN(
+            in_channels,
+            feedforward_channels,
+            num_ffn_fcs,
+            act_cfg=ffn_act_cfg,
+            dropout=dropout)
+        self.ffn_norm = build_norm_layer(dict(type='LN'), in_channels)[1]
+
+        self.cls_fcs = nn.ModuleList()
+        for _ in range(num_cls_fcs):
+            self.cls_fcs.append(
+                nn.Linear(in_channels, in_channels, bias=False))
+            self.cls_fcs.append(
+                build_norm_layer(dict(type='LN'), in_channels)[1])
+            self.cls_fcs.append(
+                build_activation_layer(dict(type='ReLU', inplace=True)))
+
+        # over load the self.fc_cls in BBoxHead
+        if self.loss_cls.use_sigmoid:
+            self.fc_cls = nn.Linear(in_channels, self.num_classes)
+        else:
+            self.fc_cls = nn.Linear(in_channels, self.num_classes + 1)
+
+        self.reg_fcs = nn.ModuleList()
+        for _ in range(num_reg_fcs):
+            self.reg_fcs.append(
+                nn.Linear(in_channels, in_channels, bias=False))
+            self.reg_fcs.append(
+                build_norm_layer(dict(type='LN'), in_channels)[1])
+            self.reg_fcs.append(
+                build_activation_layer(dict(type='ReLU', inplace=True)))
+        # over load the self.fc_cls in BBoxHead
+        self.fc_reg = nn.Linear(in_channels, 4)
+
+        assert self.reg_class_agnostic, 'DIIHead only ' \
+            'suppport `reg_class_agnostic=True` '
+        assert self.reg_decoded_bbox, 'DIIHead only ' \
+            'suppport `reg_decoded_bbox=True`'
+
+    def init_weights(self) -> None:
+        """Use xavier initialization for all weight parameter and set
+        classification head bias as a specific value when use focal loss."""
+        super().init_weights()
+        for p in self.parameters():
+            if p.dim() > 1:
+                nn.init.xavier_uniform_(p)
+            else:
+                # adopt the default initialization for
+                # the weight and bias of the layer norm
+                pass
+        if self.loss_cls.use_sigmoid:
+            bias_init = bias_init_with_prob(0.01)
+            nn.init.constant_(self.fc_cls.bias, bias_init)
+
+    def forward(self, roi_feat: Tensor, proposal_feat: Tensor) -> tuple:
+        """Forward function of Dynamic Instance Interactive Head.
+
+        Args:
+            roi_feat (Tensor): Roi-pooling features with shape
+                (batch_size*num_proposals, feature_dimensions,
+                pooling_h , pooling_w).
+            proposal_feat (Tensor): Intermediate feature get from
+                diihead in last stage, has shape
+                (batch_size, num_proposals, feature_dimensions)
+
+        Returns:
+            tuple[Tensor]: Usually a tuple of classification scores
+            and bbox prediction and a intermediate feature.
+
+            - cls_scores (Tensor): Classification scores for
+              all proposals, has shape
+              (batch_size, num_proposals, num_classes).
+            - bbox_preds (Tensor): Box energies / deltas for
+              all proposals, has shape
+              (batch_size, num_proposals, 4).
+            - obj_feat (Tensor): Object feature before classification
+              and regression subnet, has shape
+              (batch_size, num_proposal, feature_dimensions).
+            - attn_feats (Tensor): Intermediate feature.
+        """
+        N, num_proposals = proposal_feat.shape[:2]
+
+        # Self attention
+        proposal_feat = proposal_feat.permute(1, 0, 2)
+        proposal_feat = self.attention_norm(self.attention(proposal_feat))
+        attn_feats = proposal_feat.permute(1, 0, 2)
+
+        # instance interactive
+        proposal_feat = attn_feats.reshape(-1, self.in_channels)
+        proposal_feat_iic = self.instance_interactive_conv(
+            proposal_feat, roi_feat)
+        proposal_feat = proposal_feat + self.instance_interactive_conv_dropout(
+            proposal_feat_iic)
+        obj_feat = self.instance_interactive_conv_norm(proposal_feat)
+
+        # FFN
+        obj_feat = self.ffn_norm(self.ffn(obj_feat))
+
+        cls_feat = obj_feat
+        reg_feat = obj_feat
+
+        for cls_layer in self.cls_fcs:
+            cls_feat = cls_layer(cls_feat)
+        for reg_layer in self.reg_fcs:
+            reg_feat = reg_layer(reg_feat)
+
+        cls_score = self.fc_cls(cls_feat).view(
+            N, num_proposals, self.num_classes
+            if self.loss_cls.use_sigmoid else self.num_classes + 1)
+        bbox_delta = self.fc_reg(reg_feat).view(N, num_proposals, 4)
+
+        return cls_score, bbox_delta, obj_feat.view(
+            N, num_proposals, self.in_channels), attn_feats
+
+    def loss_and_target(self,
+                        cls_score: Tensor,
+                        bbox_pred: Tensor,
+                        sampling_results: List[SamplingResult],
+                        rcnn_train_cfg: ConfigType,
+                        imgs_whwh: Tensor,
+                        concat: bool = True,
+                        reduction_override: str = None) -> dict:
+        """Calculate the loss based on the features extracted by the DIIHead.
+
+        Args:
+            cls_score (Tensor): Classification prediction
+                results of all class, has shape
+                (batch_size * num_proposals_single_image, num_classes)
+            bbox_pred (Tensor): Regression prediction results, has shape
+                (batch_size * num_proposals_single_image, 4), the last
+                dimension 4 represents [tl_x, tl_y, br_x, br_y].
+            sampling_results (List[obj:SamplingResult]): Assign results of
+                all images in a batch after sampling.
+            rcnn_train_cfg (obj:ConfigDict): `train_cfg` of RCNN.
+            imgs_whwh (Tensor): imgs_whwh (Tensor): Tensor with\
+                shape (batch_size, num_proposals, 4), the last
+                dimension means
+                [img_width,img_height, img_width, img_height].
+            concat (bool): Whether to concatenate the results of all
+                the images in a single batch. Defaults to True.
+            reduction_override (str, optional): The reduction
+                method used to override the original reduction
+                method of the loss. Options are "none",
+                "mean" and "sum". Defaults to None.
+
+        Returns:
+            dict: A dictionary of loss and targets components.
+            The targets are only used for cascade rcnn.
+        """
+        cls_reg_targets = self.get_targets(
+            sampling_results=sampling_results,
+            rcnn_train_cfg=rcnn_train_cfg,
+            concat=concat)
+        (labels, label_weights, bbox_targets, bbox_weights) = cls_reg_targets
+
+        losses = dict()
+        bg_class_ind = self.num_classes
+        # note in spare rcnn num_gt == num_pos
+        pos_inds = (labels >= 0) & (labels < bg_class_ind)
+        num_pos = pos_inds.sum().float()
+        avg_factor = reduce_mean(num_pos)
+        if cls_score is not None:
+            if cls_score.numel() > 0:
+                losses['loss_cls'] = self.loss_cls(
+                    cls_score,
+                    labels,
+                    label_weights,
+                    avg_factor=avg_factor,
+                    reduction_override=reduction_override)
+                losses['pos_acc'] = accuracy(cls_score[pos_inds],
+                                             labels[pos_inds])
+        if bbox_pred is not None:
+            # 0~self.num_classes-1 are FG, self.num_classes is BG
+            # do not perform bounding box regression for BG anymore.
+            if pos_inds.any():
+                pos_bbox_pred = bbox_pred.reshape(bbox_pred.size(0),
+                                                  4)[pos_inds.type(torch.bool)]
+                imgs_whwh = imgs_whwh.reshape(bbox_pred.size(0),
+                                              4)[pos_inds.type(torch.bool)]
+                losses['loss_bbox'] = self.loss_bbox(
+                    pos_bbox_pred / imgs_whwh,
+                    bbox_targets[pos_inds.type(torch.bool)] / imgs_whwh,
+                    bbox_weights[pos_inds.type(torch.bool)],
+                    avg_factor=avg_factor)
+                losses['loss_iou'] = self.loss_iou(
+                    pos_bbox_pred,
+                    bbox_targets[pos_inds.type(torch.bool)],
+                    bbox_weights[pos_inds.type(torch.bool)],
+                    avg_factor=avg_factor)
+            else:
+                losses['loss_bbox'] = bbox_pred.sum() * 0
+                losses['loss_iou'] = bbox_pred.sum() * 0
+        return dict(loss_bbox=losses, bbox_targets=cls_reg_targets)
+
+    def _get_targets_single(self, pos_inds: Tensor, neg_inds: Tensor,
+                            pos_priors: Tensor, neg_priors: Tensor,
+                            pos_gt_bboxes: Tensor, pos_gt_labels: Tensor,
+                            cfg: ConfigDict) -> tuple:
+        """Calculate the ground truth for proposals in the single image
+        according to the sampling results.
+
+        Almost the same as the implementation in `bbox_head`,
+        we add pos_inds and neg_inds to select positive and
+        negative samples instead of selecting the first num_pos
+        as positive samples.
+
+        Args:
+            pos_inds (Tensor): The length is equal to the
+                positive sample numbers contain all index
+                of the positive sample in the origin proposal set.
+            neg_inds (Tensor): The length is equal to the
+                negative sample numbers contain all index
+                of the negative sample in the origin proposal set.
+            pos_priors (Tensor): Contains all the positive boxes,
+                has shape (num_pos, 4), the last dimension 4
+                represents [tl_x, tl_y, br_x, br_y].
+            neg_priors (Tensor): Contains all the negative boxes,
+                has shape (num_neg, 4), the last dimension 4
+                represents [tl_x, tl_y, br_x, br_y].
+            pos_gt_bboxes (Tensor): Contains gt_boxes for
+                all positive samples, has shape (num_pos, 4),
+                the last dimension 4
+                represents [tl_x, tl_y, br_x, br_y].
+            pos_gt_labels (Tensor): Contains gt_labels for
+                all positive samples, has shape (num_pos, ).
+            cfg (obj:`ConfigDict`): `train_cfg` of R-CNN.
+
+        Returns:
+            Tuple[Tensor]: Ground truth for proposals in a single image.
+            Containing the following Tensors:
+
+            - labels(Tensor): Gt_labels for all proposals, has
+              shape (num_proposals,).
+            - label_weights(Tensor): Labels_weights for all proposals, has
+              shape (num_proposals,).
+            - bbox_targets(Tensor):Regression target for all proposals, has
+              shape (num_proposals, 4), the last dimension 4
+              represents [tl_x, tl_y, br_x, br_y].
+            - bbox_weights(Tensor):Regression weights for all proposals,
+              has shape (num_proposals, 4).
+        """
+        num_pos = pos_priors.size(0)
+        num_neg = neg_priors.size(0)
+        num_samples = num_pos + num_neg
+
+        # original implementation uses new_zeros since BG are set to be 0
+        # now use empty & fill because BG cat_id = num_classes,
+        # FG cat_id = [0, num_classes-1]
+        labels = pos_priors.new_full((num_samples, ),
+                                     self.num_classes,
+                                     dtype=torch.long)
+        label_weights = pos_priors.new_zeros(num_samples)
+        bbox_targets = pos_priors.new_zeros(num_samples, 4)
+        bbox_weights = pos_priors.new_zeros(num_samples, 4)
+        if num_pos > 0:
+            labels[pos_inds] = pos_gt_labels
+            pos_weight = 1.0 if cfg.pos_weight <= 0 else cfg.pos_weight
+            label_weights[pos_inds] = pos_weight
+            if not self.reg_decoded_bbox:
+                pos_bbox_targets = self.bbox_coder.encode(
+                    pos_priors, pos_gt_bboxes)
+            else:
+                pos_bbox_targets = pos_gt_bboxes
+            bbox_targets[pos_inds, :] = pos_bbox_targets
+            bbox_weights[pos_inds, :] = 1
+        if num_neg > 0:
+            label_weights[neg_inds] = 1.0
+
+        return labels, label_weights, bbox_targets, bbox_weights
+
+    def get_targets(self,
+                    sampling_results: List[SamplingResult],
+                    rcnn_train_cfg: ConfigDict,
+                    concat: bool = True) -> tuple:
+        """Calculate the ground truth for all samples in a batch according to
+        the sampling_results.
+
+        Almost the same as the implementation in bbox_head, we passed
+        additional parameters pos_inds_list and neg_inds_list to
+        `_get_targets_single` function.
+
+        Args:
+            sampling_results (List[obj:SamplingResult]): Assign results of
+                all images in a batch after sampling.
+            rcnn_train_cfg (obj:ConfigDict): `train_cfg` of RCNN.
+            concat (bool): Whether to concatenate the results of all
+                the images in a single batch.
+
+        Returns:
+            Tuple[Tensor]: Ground truth for proposals in a single image.
+            Containing the following list of Tensors:
+
+            - labels (list[Tensor],Tensor): Gt_labels for all
+              proposals in a batch, each tensor in list has
+              shape (num_proposals,) when `concat=False`, otherwise just
+              a single tensor has shape (num_all_proposals,).
+            - label_weights (list[Tensor]): Labels_weights for
+              all proposals in a batch, each tensor in list has shape
+              (num_proposals,) when `concat=False`, otherwise just a
+              single tensor has shape (num_all_proposals,).
+            - bbox_targets (list[Tensor],Tensor): Regression target
+              for all proposals in a batch, each tensor in list has
+              shape (num_proposals, 4) when `concat=False`, otherwise
+              just a single tensor has shape (num_all_proposals, 4),
+              the last dimension 4 represents [tl_x, tl_y, br_x, br_y].
+            - bbox_weights (list[tensor],Tensor): Regression weights for
+              all proposals in a batch, each tensor in list has shape
+              (num_proposals, 4) when `concat=False`, otherwise just a
+              single tensor has shape (num_all_proposals, 4).
+        """
+        pos_inds_list = [res.pos_inds for res in sampling_results]
+        neg_inds_list = [res.neg_inds for res in sampling_results]
+        pos_priors_list = [res.pos_priors for res in sampling_results]
+        neg_priors_list = [res.neg_priors for res in sampling_results]
+        pos_gt_bboxes_list = [res.pos_gt_bboxes for res in sampling_results]
+        pos_gt_labels_list = [res.pos_gt_labels for res in sampling_results]
+        labels, label_weights, bbox_targets, bbox_weights = multi_apply(
+            self._get_targets_single,
+            pos_inds_list,
+            neg_inds_list,
+            pos_priors_list,
+            neg_priors_list,
+            pos_gt_bboxes_list,
+            pos_gt_labels_list,
+            cfg=rcnn_train_cfg)
+        if concat:
+            labels = torch.cat(labels, 0)
+            label_weights = torch.cat(label_weights, 0)
+            bbox_targets = torch.cat(bbox_targets, 0)
+            bbox_weights = torch.cat(bbox_weights, 0)
+        return labels, label_weights, bbox_targets, bbox_weights
diff --git a/mmdetection/mmdet/models/roi_heads/bbox_heads/double_bbox_head.py b/mmdetection/mmdet/models/roi_heads/bbox_heads/double_bbox_head.py
new file mode 100644
index 00000000..076c3584
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/bbox_heads/double_bbox_head.py
@@ -0,0 +1,199 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Tuple
+
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule, ModuleList
+from torch import Tensor
+
+from mmdet.models.backbones.resnet import Bottleneck
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, MultiConfig, OptConfigType, OptMultiConfig
+from .bbox_head import BBoxHead
+
+
+class BasicResBlock(BaseModule):
+    """Basic residual block.
+
+    This block is a little different from the block in the ResNet backbone.
+    The kernel size of conv1 is 1 in this block while 3 in ResNet BasicBlock.
+
+    Args:
+        in_channels (int): Channels of the input feature map.
+        out_channels (int): Channels of the output feature map.
+        conv_cfg (:obj:`ConfigDict` or dict, optional): The config dict
+            for convolution layers.
+        norm_cfg (:obj:`ConfigDict` or dict): The config dict for
+            normalization layers.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict], optional): Initialization config dict. Defaults to None
+    """
+
+    def __init__(self,
+                 in_channels: int,
+                 out_channels: int,
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: ConfigType = dict(type='BN'),
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(init_cfg=init_cfg)
+
+        # main path
+        self.conv1 = ConvModule(
+            in_channels,
+            in_channels,
+            kernel_size=3,
+            padding=1,
+            bias=False,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg)
+        self.conv2 = ConvModule(
+            in_channels,
+            out_channels,
+            kernel_size=1,
+            bias=False,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=None)
+
+        # identity path
+        self.conv_identity = ConvModule(
+            in_channels,
+            out_channels,
+            kernel_size=1,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            act_cfg=None)
+
+        self.relu = nn.ReLU(inplace=True)
+
+    def forward(self, x: Tensor) -> Tensor:
+        """Forward function."""
+        identity = x
+
+        x = self.conv1(x)
+        x = self.conv2(x)
+
+        identity = self.conv_identity(identity)
+        out = x + identity
+
+        out = self.relu(out)
+        return out
+
+
+@MODELS.register_module()
+class DoubleConvFCBBoxHead(BBoxHead):
+    r"""Bbox head used in Double-Head R-CNN
+
+    .. code-block:: none
+
+                                          /-> cls
+                      /-> shared convs ->
+                                          \-> reg
+        roi features
+                                          /-> cls
+                      \-> shared fc    ->
+                                          \-> reg
+    """  # noqa: W605
+
+    def __init__(self,
+                 num_convs: int = 0,
+                 num_fcs: int = 0,
+                 conv_out_channels: int = 1024,
+                 fc_out_channels: int = 1024,
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: ConfigType = dict(type='BN'),
+                 init_cfg: MultiConfig = dict(
+                     type='Normal',
+                     override=[
+                         dict(type='Normal', name='fc_cls', std=0.01),
+                         dict(type='Normal', name='fc_reg', std=0.001),
+                         dict(
+                             type='Xavier',
+                             name='fc_branch',
+                             distribution='uniform')
+                     ]),
+                 **kwargs) -> None:
+        kwargs.setdefault('with_avg_pool', True)
+        super().__init__(init_cfg=init_cfg, **kwargs)
+        assert self.with_avg_pool
+        assert num_convs > 0
+        assert num_fcs > 0
+        self.num_convs = num_convs
+        self.num_fcs = num_fcs
+        self.conv_out_channels = conv_out_channels
+        self.fc_out_channels = fc_out_channels
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+
+        # increase the channel of input features
+        self.res_block = BasicResBlock(self.in_channels,
+                                       self.conv_out_channels)
+
+        # add conv heads
+        self.conv_branch = self._add_conv_branch()
+        # add fc heads
+        self.fc_branch = self._add_fc_branch()
+
+        out_dim_reg = 4 if self.reg_class_agnostic else 4 * self.num_classes
+        self.fc_reg = nn.Linear(self.conv_out_channels, out_dim_reg)
+
+        self.fc_cls = nn.Linear(self.fc_out_channels, self.num_classes + 1)
+        self.relu = nn.ReLU()
+
+    def _add_conv_branch(self) -> None:
+        """Add the fc branch which consists of a sequential of conv layers."""
+        branch_convs = ModuleList()
+        for i in range(self.num_convs):
+            branch_convs.append(
+                Bottleneck(
+                    inplanes=self.conv_out_channels,
+                    planes=self.conv_out_channels // 4,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg))
+        return branch_convs
+
+    def _add_fc_branch(self) -> None:
+        """Add the fc branch which consists of a sequential of fc layers."""
+        branch_fcs = ModuleList()
+        for i in range(self.num_fcs):
+            fc_in_channels = (
+                self.in_channels *
+                self.roi_feat_area if i == 0 else self.fc_out_channels)
+            branch_fcs.append(nn.Linear(fc_in_channels, self.fc_out_channels))
+        return branch_fcs
+
+    def forward(self, x_cls: Tensor, x_reg: Tensor) -> Tuple[Tensor]:
+        """Forward features from the upstream network.
+
+        Args:
+            x_cls (Tensor): Classification features of rois
+            x_reg (Tensor): Regression features from the upstream network.
+
+        Returns:
+            tuple: A tuple of classification scores and bbox prediction.
+
+                - cls_score (Tensor): Classification score predictions of rois.
+                  each roi predicts num_classes + 1 channels.
+                - bbox_pred (Tensor): BBox deltas predictions of rois. each roi
+                  predicts 4 * num_classes channels.
+        """
+        # conv head
+        x_conv = self.res_block(x_reg)
+
+        for conv in self.conv_branch:
+            x_conv = conv(x_conv)
+
+        if self.with_avg_pool:
+            x_conv = self.avg_pool(x_conv)
+
+        x_conv = x_conv.view(x_conv.size(0), -1)
+        bbox_pred = self.fc_reg(x_conv)
+
+        # fc head
+        x_fc = x_cls.view(x_cls.size(0), -1)
+        for fc in self.fc_branch:
+            x_fc = self.relu(fc(x_fc))
+
+        cls_score = self.fc_cls(x_fc)
+
+        return cls_score, bbox_pred
diff --git a/mmdetection/mmdet/models/roi_heads/bbox_heads/multi_instance_bbox_head.py b/mmdetection/mmdet/models/roi_heads/bbox_heads/multi_instance_bbox_head.py
new file mode 100644
index 00000000..38e57d2e
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/bbox_heads/multi_instance_bbox_head.py
@@ -0,0 +1,626 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Tuple, Union
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+from mmengine.config import ConfigDict
+from mmengine.structures import InstanceData
+from torch import Tensor, nn
+
+from mmdet.models.roi_heads.bbox_heads.bbox_head import BBoxHead
+from mmdet.models.task_modules.samplers import SamplingResult
+from mmdet.models.utils import empty_instances
+from mmdet.registry import MODELS
+from mmdet.structures.bbox import bbox_overlaps
+
+
+@MODELS.register_module()
+class MultiInstanceBBoxHead(BBoxHead):
+    r"""Bbox head used in CrowdDet.
+
+    .. code-block:: none
+
+                                      /-> cls convs_1 -> cls fcs_1 -> cls_1
+                                   |--
+                                   |  \-> reg convs_1 -> reg fcs_1 -> reg_1
+                                   |
+                                   |  /-> cls convs_2 -> cls fcs_2 -> cls_2
+        shared convs -> shared fcs |--
+                                   |  \-> reg convs_2 -> reg fcs_2 -> reg_2
+                                   |
+                                   |                     ...
+                                   |
+                                   |  /-> cls convs_k -> cls fcs_k -> cls_k
+                                   |--
+                                      \-> reg convs_k -> reg fcs_k -> reg_k
+
+
+    Args:
+        num_instance (int): The number of branches after shared fcs.
+            Defaults to 2.
+        with_refine (bool): Whether to use refine module. Defaults to False.
+        num_shared_convs (int): The number of shared convs. Defaults to 0.
+        num_shared_fcs (int): The number of shared fcs. Defaults to 2.
+        num_cls_convs (int): The number of cls convs. Defaults to 0.
+        num_cls_fcs (int): The number of cls fcs. Defaults to 0.
+        num_reg_convs (int): The number of reg convs. Defaults to 0.
+        num_reg_fcs (int): The number of reg fcs. Defaults to 0.
+        conv_out_channels (int): The number of conv out channels.
+            Defaults to 256.
+        fc_out_channels (int): The number of fc out channels. Defaults to 1024.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Defaults to None.
+    """  # noqa: W605
+
+    def __init__(self,
+                 num_instance: int = 2,
+                 with_refine: bool = False,
+                 num_shared_convs: int = 0,
+                 num_shared_fcs: int = 2,
+                 num_cls_convs: int = 0,
+                 num_cls_fcs: int = 0,
+                 num_reg_convs: int = 0,
+                 num_reg_fcs: int = 0,
+                 conv_out_channels: int = 256,
+                 fc_out_channels: int = 1024,
+                 init_cfg: Optional[Union[dict, ConfigDict]] = None,
+                 *args,
+                 **kwargs) -> None:
+        super().__init__(*args, init_cfg=init_cfg, **kwargs)
+        assert (num_shared_convs + num_shared_fcs + num_cls_convs +
+                num_cls_fcs + num_reg_convs + num_reg_fcs > 0)
+        assert num_instance == 2, 'Currently only 2 instances are supported'
+        if num_cls_convs > 0 or num_reg_convs > 0:
+            assert num_shared_fcs == 0
+        if not self.with_cls:
+            assert num_cls_convs == 0 and num_cls_fcs == 0
+        if not self.with_reg:
+            assert num_reg_convs == 0 and num_reg_fcs == 0
+        self.num_instance = num_instance
+        self.num_shared_convs = num_shared_convs
+        self.num_shared_fcs = num_shared_fcs
+        self.num_cls_convs = num_cls_convs
+        self.num_cls_fcs = num_cls_fcs
+        self.num_reg_convs = num_reg_convs
+        self.num_reg_fcs = num_reg_fcs
+        self.conv_out_channels = conv_out_channels
+        self.fc_out_channels = fc_out_channels
+        self.with_refine = with_refine
+
+        # add shared convs and fcs
+        self.shared_convs, self.shared_fcs, last_layer_dim = \
+            self._add_conv_fc_branch(
+                self.num_shared_convs, self.num_shared_fcs, self.in_channels,
+                True)
+        self.shared_out_channels = last_layer_dim
+        self.relu = nn.ReLU(inplace=True)
+
+        if self.with_refine:
+            refine_model_cfg = {
+                'type': 'Linear',
+                'in_features': self.shared_out_channels + 20,
+                'out_features': self.shared_out_channels
+            }
+            self.shared_fcs_ref = MODELS.build(refine_model_cfg)
+            self.fc_cls_ref = nn.ModuleList()
+            self.fc_reg_ref = nn.ModuleList()
+
+        self.cls_convs = nn.ModuleList()
+        self.cls_fcs = nn.ModuleList()
+        self.reg_convs = nn.ModuleList()
+        self.reg_fcs = nn.ModuleList()
+        self.cls_last_dim = list()
+        self.reg_last_dim = list()
+        self.fc_cls = nn.ModuleList()
+        self.fc_reg = nn.ModuleList()
+        for k in range(self.num_instance):
+            # add cls specific branch
+            cls_convs, cls_fcs, cls_last_dim = self._add_conv_fc_branch(
+                self.num_cls_convs, self.num_cls_fcs, self.shared_out_channels)
+            self.cls_convs.append(cls_convs)
+            self.cls_fcs.append(cls_fcs)
+            self.cls_last_dim.append(cls_last_dim)
+
+            # add reg specific branch
+            reg_convs, reg_fcs, reg_last_dim = self._add_conv_fc_branch(
+                self.num_reg_convs, self.num_reg_fcs, self.shared_out_channels)
+            self.reg_convs.append(reg_convs)
+            self.reg_fcs.append(reg_fcs)
+            self.reg_last_dim.append(reg_last_dim)
+
+            if self.num_shared_fcs == 0 and not self.with_avg_pool:
+                if self.num_cls_fcs == 0:
+                    self.cls_last_dim *= self.roi_feat_area
+                if self.num_reg_fcs == 0:
+                    self.reg_last_dim *= self.roi_feat_area
+
+            if self.with_cls:
+                if self.custom_cls_channels:
+                    cls_channels = self.loss_cls.get_cls_channels(
+                        self.num_classes)
+                else:
+                    cls_channels = self.num_classes + 1
+                cls_predictor_cfg_ = self.cls_predictor_cfg.copy()  # deepcopy
+                cls_predictor_cfg_.update(
+                    in_features=self.cls_last_dim[k],
+                    out_features=cls_channels)
+                self.fc_cls.append(MODELS.build(cls_predictor_cfg_))
+                if self.with_refine:
+                    self.fc_cls_ref.append(MODELS.build(cls_predictor_cfg_))
+
+            if self.with_reg:
+                out_dim_reg = (4 if self.reg_class_agnostic else 4 *
+                               self.num_classes)
+                reg_predictor_cfg_ = self.reg_predictor_cfg.copy()
+                reg_predictor_cfg_.update(
+                    in_features=self.reg_last_dim[k], out_features=out_dim_reg)
+                self.fc_reg.append(MODELS.build(reg_predictor_cfg_))
+                if self.with_refine:
+                    self.fc_reg_ref.append(MODELS.build(reg_predictor_cfg_))
+
+        if init_cfg is None:
+            # when init_cfg is None,
+            # It has been set to
+            # [[dict(type='Normal', std=0.01, override=dict(name='fc_cls'))],
+            #  [dict(type='Normal', std=0.001, override=dict(name='fc_reg'))]
+            # after `super(ConvFCBBoxHead, self).__init__()`
+            # we only need to append additional configuration
+            # for `shared_fcs`, `cls_fcs` and `reg_fcs`
+            self.init_cfg += [
+                dict(
+                    type='Xavier',
+                    distribution='uniform',
+                    override=[
+                        dict(name='shared_fcs'),
+                        dict(name='cls_fcs'),
+                        dict(name='reg_fcs')
+                    ])
+            ]
+
+    def _add_conv_fc_branch(self,
+                            num_branch_convs: int,
+                            num_branch_fcs: int,
+                            in_channels: int,
+                            is_shared: bool = False) -> tuple:
+        """Add shared or separable branch.
+
+        convs -> avg pool (optional) -> fcs
+        """
+        last_layer_dim = in_channels
+        # add branch specific conv layers
+        branch_convs = nn.ModuleList()
+        if num_branch_convs > 0:
+            for i in range(num_branch_convs):
+                conv_in_channels = (
+                    last_layer_dim if i == 0 else self.conv_out_channels)
+                branch_convs.append(
+                    ConvModule(
+                        conv_in_channels, self.conv_out_channels, 3,
+                        padding=1))
+            last_layer_dim = self.conv_out_channels
+        # add branch specific fc layers
+        branch_fcs = nn.ModuleList()
+        if num_branch_fcs > 0:
+            # for shared branch, only consider self.with_avg_pool
+            # for separated branches, also consider self.num_shared_fcs
+            if (is_shared
+                    or self.num_shared_fcs == 0) and not self.with_avg_pool:
+                last_layer_dim *= self.roi_feat_area
+            for i in range(num_branch_fcs):
+                fc_in_channels = (
+                    last_layer_dim if i == 0 else self.fc_out_channels)
+                branch_fcs.append(
+                    nn.Linear(fc_in_channels, self.fc_out_channels))
+            last_layer_dim = self.fc_out_channels
+        return branch_convs, branch_fcs, last_layer_dim
+
+    def forward(self, x: Tuple[Tensor]) -> tuple:
+        """Forward features from the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple: A tuple of classification scores and bbox prediction.
+
+                - cls_score (Tensor): Classification scores for all scale
+                  levels, each is a 4D-tensor, the channels number is
+                  num_base_priors * num_classes.
+                - bbox_pred (Tensor): Box energies / deltas for all scale
+                  levels, each is a 4D-tensor, the channels number is
+                  num_base_priors * 4.
+                - cls_score_ref (Tensor): The cls_score after refine model.
+                - bbox_pred_ref (Tensor): The bbox_pred after refine model.
+        """
+        # shared part
+        if self.num_shared_convs > 0:
+            for conv in self.shared_convs:
+                x = conv(x)
+
+        if self.num_shared_fcs > 0:
+            if self.with_avg_pool:
+                x = self.avg_pool(x)
+
+            x = x.flatten(1)
+            for fc in self.shared_fcs:
+                x = self.relu(fc(x))
+
+        x_cls = x
+        x_reg = x
+        # separate branches
+        cls_score = list()
+        bbox_pred = list()
+        for k in range(self.num_instance):
+            for conv in self.cls_convs[k]:
+                x_cls = conv(x_cls)
+            if x_cls.dim() > 2:
+                if self.with_avg_pool:
+                    x_cls = self.avg_pool(x_cls)
+                x_cls = x_cls.flatten(1)
+            for fc in self.cls_fcs[k]:
+                x_cls = self.relu(fc(x_cls))
+
+            for conv in self.reg_convs[k]:
+                x_reg = conv(x_reg)
+            if x_reg.dim() > 2:
+                if self.with_avg_pool:
+                    x_reg = self.avg_pool(x_reg)
+                x_reg = x_reg.flatten(1)
+            for fc in self.reg_fcs[k]:
+                x_reg = self.relu(fc(x_reg))
+
+            cls_score.append(self.fc_cls[k](x_cls) if self.with_cls else None)
+            bbox_pred.append(self.fc_reg[k](x_reg) if self.with_reg else None)
+
+        if self.with_refine:
+            x_ref = x
+            cls_score_ref = list()
+            bbox_pred_ref = list()
+            for k in range(self.num_instance):
+                feat_ref = cls_score[k].softmax(dim=-1)
+                feat_ref = torch.cat((bbox_pred[k], feat_ref[:, 1][:, None]),
+                                     dim=1).repeat(1, 4)
+                feat_ref = torch.cat((x_ref, feat_ref), dim=1)
+                feat_ref = F.relu_(self.shared_fcs_ref(feat_ref))
+
+                cls_score_ref.append(self.fc_cls_ref[k](feat_ref))
+                bbox_pred_ref.append(self.fc_reg_ref[k](feat_ref))
+
+            cls_score = torch.cat(cls_score, dim=1)
+            bbox_pred = torch.cat(bbox_pred, dim=1)
+            cls_score_ref = torch.cat(cls_score_ref, dim=1)
+            bbox_pred_ref = torch.cat(bbox_pred_ref, dim=1)
+            return cls_score, bbox_pred, cls_score_ref, bbox_pred_ref
+
+        cls_score = torch.cat(cls_score, dim=1)
+        bbox_pred = torch.cat(bbox_pred, dim=1)
+
+        return cls_score, bbox_pred
+
+    def get_targets(self,
+                    sampling_results: List[SamplingResult],
+                    rcnn_train_cfg: ConfigDict,
+                    concat: bool = True) -> tuple:
+        """Calculate the ground truth for all samples in a batch according to
+        the sampling_results.
+
+        Almost the same as the implementation in bbox_head, we passed
+        additional parameters pos_inds_list and neg_inds_list to
+        `_get_targets_single` function.
+
+        Args:
+            sampling_results (List[obj:SamplingResult]): Assign results of
+                all images in a batch after sampling.
+            rcnn_train_cfg (obj:ConfigDict): `train_cfg` of RCNN.
+            concat (bool): Whether to concatenate the results of all
+                the images in a single batch.
+
+        Returns:
+            Tuple[Tensor]: Ground truth for proposals in a single image.
+            Containing the following list of Tensors:
+
+            - labels (list[Tensor],Tensor): Gt_labels for all proposals in a
+              batch, each tensor in list has shape (num_proposals,) when
+              `concat=False`, otherwise just a single tensor has shape
+              (num_all_proposals,).
+            - label_weights (list[Tensor]): Labels_weights for
+              all proposals in a batch, each tensor in list has shape
+              (num_proposals,) when `concat=False`, otherwise just a single
+              tensor has shape (num_all_proposals,).
+            - bbox_targets (list[Tensor],Tensor): Regression target for all
+              proposals in a batch, each tensor in list has shape
+              (num_proposals, 4) when `concat=False`, otherwise just a single
+              tensor has shape (num_all_proposals, 4), the last dimension 4
+              represents [tl_x, tl_y, br_x, br_y].
+            - bbox_weights (list[tensor],Tensor): Regression weights for
+              all proposals in a batch, each tensor in list has shape
+              (num_proposals, 4) when `concat=False`, otherwise just a
+              single tensor has shape (num_all_proposals, 4).
+        """
+        labels = []
+        bbox_targets = []
+        bbox_weights = []
+        label_weights = []
+        for i in range(len(sampling_results)):
+            sample_bboxes = torch.cat([
+                sampling_results[i].pos_gt_bboxes,
+                sampling_results[i].neg_gt_bboxes
+            ])
+            sample_priors = sampling_results[i].priors
+            sample_priors = sample_priors.repeat(1, self.num_instance).reshape(
+                -1, 4)
+            sample_bboxes = sample_bboxes.reshape(-1, 4)
+
+            if not self.reg_decoded_bbox:
+                _bbox_targets = self.bbox_coder.encode(sample_priors,
+                                                       sample_bboxes)
+            else:
+                _bbox_targets = sample_priors
+            _bbox_targets = _bbox_targets.reshape(-1, self.num_instance * 4)
+            _bbox_weights = torch.ones(_bbox_targets.shape)
+            _labels = torch.cat([
+                sampling_results[i].pos_gt_labels,
+                sampling_results[i].neg_gt_labels
+            ])
+            _labels_weights = torch.ones(_labels.shape)
+
+            bbox_targets.append(_bbox_targets)
+            bbox_weights.append(_bbox_weights)
+            labels.append(_labels)
+            label_weights.append(_labels_weights)
+
+        if concat:
+            labels = torch.cat(labels, 0)
+            label_weights = torch.cat(label_weights, 0)
+            bbox_targets = torch.cat(bbox_targets, 0)
+            bbox_weights = torch.cat(bbox_weights, 0)
+        return labels, label_weights, bbox_targets, bbox_weights
+
+    def loss(self, cls_score: Tensor, bbox_pred: Tensor, rois: Tensor,
+             labels: Tensor, label_weights: Tensor, bbox_targets: Tensor,
+             bbox_weights: Tensor, **kwargs) -> dict:
+        """Calculate the loss based on the network predictions and targets.
+
+        Args:
+            cls_score (Tensor): Classification prediction results of all class,
+                has shape (batch_size * num_proposals_single_image,
+                (num_classes + 1) * k), k represents the number of prediction
+                boxes generated by each proposal box.
+            bbox_pred (Tensor): Regression prediction results, has shape
+                (batch_size * num_proposals_single_image, 4 * k), the last
+                dimension 4 represents [tl_x, tl_y, br_x, br_y].
+            rois (Tensor): RoIs with the shape
+                (batch_size * num_proposals_single_image, 5) where the first
+                column indicates batch id of each RoI.
+            labels (Tensor): Gt_labels for all proposals in a batch, has
+                shape (batch_size * num_proposals_single_image, k).
+            label_weights (Tensor): Labels_weights for all proposals in a
+                batch, has shape (batch_size * num_proposals_single_image, k).
+            bbox_targets (Tensor): Regression target for all proposals in a
+                batch, has shape (batch_size * num_proposals_single_image,
+                4 * k), the last dimension 4 represents [tl_x, tl_y, br_x,
+                br_y].
+            bbox_weights (Tensor): Regression weights for all proposals in a
+                batch, has shape (batch_size * num_proposals_single_image,
+                4 * k).
+
+        Returns:
+            dict: A dictionary of loss.
+        """
+        losses = dict()
+        if bbox_pred.numel():
+            loss_0 = self.emd_loss(bbox_pred[:, 0:4], cls_score[:, 0:2],
+                                   bbox_pred[:, 4:8], cls_score[:, 2:4],
+                                   bbox_targets, labels)
+            loss_1 = self.emd_loss(bbox_pred[:, 4:8], cls_score[:, 2:4],
+                                   bbox_pred[:, 0:4], cls_score[:, 0:2],
+                                   bbox_targets, labels)
+            loss = torch.cat([loss_0, loss_1], dim=1)
+            _, min_indices = loss.min(dim=1)
+            loss_emd = loss[torch.arange(loss.shape[0]), min_indices]
+            loss_emd = loss_emd.mean()
+        else:
+            loss_emd = bbox_pred.sum()
+        losses['loss_rcnn_emd'] = loss_emd
+        return losses
+
+    def emd_loss(self, bbox_pred_0: Tensor, cls_score_0: Tensor,
+                 bbox_pred_1: Tensor, cls_score_1: Tensor, targets: Tensor,
+                 labels: Tensor) -> Tensor:
+        """Calculate the emd loss.
+
+        Note:
+            This implementation is modified from https://github.com/Purkialo/
+            CrowdDet/blob/master/lib/det_oprs/loss_opr.py
+
+        Args:
+            bbox_pred_0 (Tensor): Part of regression prediction results, has
+                shape (batch_size * num_proposals_single_image, 4), the last
+                dimension 4 represents [tl_x, tl_y, br_x, br_y].
+            cls_score_0 (Tensor): Part of classification prediction results,
+                has shape (batch_size * num_proposals_single_image,
+                (num_classes + 1)), where 1 represents the background.
+            bbox_pred_1 (Tensor): The other part of regression prediction
+                results, has shape (batch_size*num_proposals_single_image, 4).
+            cls_score_1 (Tensor):The other part of classification prediction
+                results, has shape (batch_size * num_proposals_single_image,
+                (num_classes + 1)).
+            targets (Tensor):Regression target for all proposals in a
+                batch, has shape (batch_size * num_proposals_single_image,
+                4 * k), the last dimension 4 represents [tl_x, tl_y, br_x,
+                br_y], k represents the number of prediction boxes generated
+                by each proposal box.
+            labels (Tensor): Gt_labels for all proposals in a batch, has
+                shape (batch_size * num_proposals_single_image, k).
+
+        Returns:
+            torch.Tensor: The calculated loss.
+        """
+
+        bbox_pred = torch.cat([bbox_pred_0, bbox_pred_1],
+                              dim=1).reshape(-1, bbox_pred_0.shape[-1])
+        cls_score = torch.cat([cls_score_0, cls_score_1],
+                              dim=1).reshape(-1, cls_score_0.shape[-1])
+        targets = targets.reshape(-1, 4)
+        labels = labels.long().flatten()
+
+        # masks
+        valid_masks = labels >= 0
+        fg_masks = labels > 0
+
+        # multiple class
+        bbox_pred = bbox_pred.reshape(-1, self.num_classes, 4)
+        fg_gt_classes = labels[fg_masks]
+        bbox_pred = bbox_pred[fg_masks, fg_gt_classes - 1, :]
+
+        # loss for regression
+        loss_bbox = self.loss_bbox(bbox_pred, targets[fg_masks])
+        loss_bbox = loss_bbox.sum(dim=1)
+
+        # loss for classification
+        labels = labels * valid_masks
+        loss_cls = self.loss_cls(cls_score, labels)
+
+        loss_cls[fg_masks] = loss_cls[fg_masks] + loss_bbox
+        loss = loss_cls.reshape(-1, 2).sum(dim=1)
+        return loss.reshape(-1, 1)
+
+    def _predict_by_feat_single(
+            self,
+            roi: Tensor,
+            cls_score: Tensor,
+            bbox_pred: Tensor,
+            img_meta: dict,
+            rescale: bool = False,
+            rcnn_test_cfg: Optional[ConfigDict] = None) -> InstanceData:
+        """Transform a single image's features extracted from the head into
+        bbox results.
+
+        Args:
+            roi (Tensor): Boxes to be transformed. Has shape (num_boxes, 5).
+                last dimension 5 arrange as (batch_index, x1, y1, x2, y2).
+            cls_score (Tensor): Box scores, has shape
+                (num_boxes, num_classes + 1).
+            bbox_pred (Tensor): Box energies / deltas. has shape
+                (num_boxes, num_classes * 4).
+            img_meta (dict): image information.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            rcnn_test_cfg (obj:`ConfigDict`): `test_cfg` of Bbox Head.
+                Defaults to None
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+
+        cls_score = cls_score.reshape(-1, self.num_classes + 1)
+        bbox_pred = bbox_pred.reshape(-1, 4)
+        roi = roi.repeat_interleave(self.num_instance, dim=0)
+
+        results = InstanceData()
+        if roi.shape[0] == 0:
+            return empty_instances([img_meta],
+                                   roi.device,
+                                   task_type='bbox',
+                                   instance_results=[results])[0]
+
+        scores = cls_score.softmax(dim=-1) if cls_score is not None else None
+        img_shape = img_meta['img_shape']
+        bboxes = self.bbox_coder.decode(
+            roi[..., 1:], bbox_pred, max_shape=img_shape)
+
+        if rescale and bboxes.size(0) > 0:
+            assert img_meta.get('scale_factor') is not None
+            scale_factor = bboxes.new_tensor(img_meta['scale_factor']).repeat(
+                (1, 2))
+            bboxes = (bboxes.view(bboxes.size(0), -1, 4) / scale_factor).view(
+                bboxes.size()[0], -1)
+
+        if rcnn_test_cfg is None:
+            # This means that it is aug test.
+            # It needs to return the raw results without nms.
+            results.bboxes = bboxes
+            results.scores = scores
+        else:
+            roi_idx = np.tile(
+                np.arange(bboxes.shape[0] / self.num_instance)[:, None],
+                (1, self.num_instance)).reshape(-1, 1)[:, 0]
+            roi_idx = torch.from_numpy(roi_idx).to(bboxes.device).reshape(
+                -1, 1)
+            bboxes = torch.cat([bboxes, roi_idx], dim=1)
+            det_bboxes, det_scores = self.set_nms(
+                bboxes, scores[:, 1], rcnn_test_cfg.score_thr,
+                rcnn_test_cfg.nms['iou_threshold'], rcnn_test_cfg.max_per_img)
+
+            results.bboxes = det_bboxes[:, :-1]
+            results.scores = det_scores
+            results.labels = torch.zeros_like(det_scores)
+
+        return results
+
+    @staticmethod
+    def set_nms(bboxes: Tensor,
+                scores: Tensor,
+                score_thr: float,
+                iou_threshold: float,
+                max_num: int = -1) -> Tuple[Tensor, Tensor]:
+        """NMS for multi-instance prediction. Please refer to
+        https://github.com/Purkialo/CrowdDet for more details.
+
+        Args:
+            bboxes (Tensor): predict bboxes.
+            scores (Tensor): The score of each predict bbox.
+            score_thr (float): bbox threshold, bboxes with scores lower than it
+                will not be considered.
+            iou_threshold (float): IoU threshold to be considered as
+                conflicted.
+            max_num (int, optional): if there are more than max_num bboxes
+                after NMS, only top max_num will be kept. Default to -1.
+
+        Returns:
+            Tuple[Tensor, Tensor]: (bboxes, scores).
+        """
+
+        bboxes = bboxes[scores > score_thr]
+        scores = scores[scores > score_thr]
+
+        ordered_scores, order = scores.sort(descending=True)
+        ordered_bboxes = bboxes[order]
+        roi_idx = ordered_bboxes[:, -1]
+
+        keep = torch.ones(len(ordered_bboxes)) == 1
+        ruler = torch.arange(len(ordered_bboxes))
+
+        keep = keep.to(bboxes.device)
+        ruler = ruler.to(bboxes.device)
+
+        while ruler.shape[0] > 0:
+            basement = ruler[0]
+            ruler = ruler[1:]
+            idx = roi_idx[basement]
+            # calculate the body overlap
+            basement_bbox = ordered_bboxes[:, :4][basement].reshape(-1, 4)
+            ruler_bbox = ordered_bboxes[:, :4][ruler].reshape(-1, 4)
+            overlap = bbox_overlaps(basement_bbox, ruler_bbox)
+            indices = torch.where(overlap > iou_threshold)[1]
+            loc = torch.where(roi_idx[ruler][indices] == idx)
+            # the mask won't change in the step
+            mask = keep[ruler[indices][loc]]
+            keep[ruler[indices]] = False
+            keep[ruler[indices][loc][mask]] = True
+            ruler[~keep[ruler]] = -1
+            ruler = ruler[ruler > 0]
+
+        keep = keep[order.sort()[1]]
+        return bboxes[keep][:max_num, :], scores[keep][:max_num]
diff --git a/mmdetection/mmdet/models/roi_heads/bbox_heads/sabl_head.py b/mmdetection/mmdet/models/roi_heads/bbox_heads/sabl_head.py
new file mode 100644
index 00000000..9a9ee6ab
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/bbox_heads/sabl_head.py
@@ -0,0 +1,684 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Sequence, Tuple
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+from mmengine.config import ConfigDict
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.models.layers import multiclass_nms
+from mmdet.models.losses import accuracy
+from mmdet.models.task_modules import SamplingResult
+from mmdet.models.utils import multi_apply
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.utils import ConfigType, InstanceList, OptConfigType, OptMultiConfig
+from .bbox_head import BBoxHead
+
+
+@MODELS.register_module()
+class SABLHead(BBoxHead):
+    """Side-Aware Boundary Localization (SABL) for RoI-Head.
+
+    Side-Aware features are extracted by conv layers
+    with an attention mechanism.
+    Boundary Localization with Bucketing and Bucketing Guided Rescoring
+    are implemented in BucketingBBoxCoder.
+
+    Please refer to https://arxiv.org/abs/1912.04260 for more details.
+
+    Args:
+        cls_in_channels (int): Input channels of cls RoI feature. \
+            Defaults to 256.
+        reg_in_channels (int): Input channels of reg RoI feature. \
+            Defaults to 256.
+        roi_feat_size (int): Size of RoI features. Defaults to 7.
+        reg_feat_up_ratio (int): Upsample ratio of reg features. \
+            Defaults to 2.
+        reg_pre_kernel (int): Kernel of 2D conv layers before \
+            attention pooling. Defaults to 3.
+        reg_post_kernel (int): Kernel of 1D conv layers after \
+            attention pooling. Defaults to 3.
+        reg_pre_num (int): Number of pre convs. Defaults to 2.
+        reg_post_num (int): Number of post convs. Defaults to 1.
+        num_classes (int): Number of classes in dataset. Defaults to 80.
+        cls_out_channels (int): Hidden channels in cls fcs. Defaults to 1024.
+        reg_offset_out_channels (int): Hidden and output channel \
+            of reg offset branch. Defaults to 256.
+        reg_cls_out_channels (int): Hidden and output channel \
+            of reg cls branch. Defaults to 256.
+        num_cls_fcs (int): Number of fcs for cls branch. Defaults to 1.
+        num_reg_fcs (int): Number of fcs for reg branch.. Defaults to 0.
+        reg_class_agnostic (bool): Class agnostic regression or not. \
+            Defaults to True.
+        norm_cfg (dict): Config of norm layers. Defaults to None.
+        bbox_coder (dict): Config of bbox coder. Defaults 'BucketingBBoxCoder'.
+        loss_cls (dict): Config of classification loss.
+        loss_bbox_cls (dict): Config of classification loss for bbox branch.
+        loss_bbox_reg (dict): Config of regression loss for bbox branch.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 num_classes: int,
+                 cls_in_channels: int = 256,
+                 reg_in_channels: int = 256,
+                 roi_feat_size: int = 7,
+                 reg_feat_up_ratio: int = 2,
+                 reg_pre_kernel: int = 3,
+                 reg_post_kernel: int = 3,
+                 reg_pre_num: int = 2,
+                 reg_post_num: int = 1,
+                 cls_out_channels: int = 1024,
+                 reg_offset_out_channels: int = 256,
+                 reg_cls_out_channels: int = 256,
+                 num_cls_fcs: int = 1,
+                 num_reg_fcs: int = 0,
+                 reg_class_agnostic: bool = True,
+                 norm_cfg: OptConfigType = None,
+                 bbox_coder: ConfigType = dict(
+                     type='BucketingBBoxCoder',
+                     num_buckets=14,
+                     scale_factor=1.7),
+                 loss_cls: ConfigType = dict(
+                     type='CrossEntropyLoss',
+                     use_sigmoid=False,
+                     loss_weight=1.0),
+                 loss_bbox_cls: ConfigType = dict(
+                     type='CrossEntropyLoss',
+                     use_sigmoid=True,
+                     loss_weight=1.0),
+                 loss_bbox_reg: ConfigType = dict(
+                     type='SmoothL1Loss', beta=0.1, loss_weight=1.0),
+                 init_cfg: OptMultiConfig = None) -> None:
+        super(BBoxHead, self).__init__(init_cfg=init_cfg)
+        self.cls_in_channels = cls_in_channels
+        self.reg_in_channels = reg_in_channels
+        self.roi_feat_size = roi_feat_size
+        self.reg_feat_up_ratio = int(reg_feat_up_ratio)
+        self.num_buckets = bbox_coder['num_buckets']
+        assert self.reg_feat_up_ratio // 2 >= 1
+        self.up_reg_feat_size = roi_feat_size * self.reg_feat_up_ratio
+        assert self.up_reg_feat_size == bbox_coder['num_buckets']
+        self.reg_pre_kernel = reg_pre_kernel
+        self.reg_post_kernel = reg_post_kernel
+        self.reg_pre_num = reg_pre_num
+        self.reg_post_num = reg_post_num
+        self.num_classes = num_classes
+        self.cls_out_channels = cls_out_channels
+        self.reg_offset_out_channels = reg_offset_out_channels
+        self.reg_cls_out_channels = reg_cls_out_channels
+        self.num_cls_fcs = num_cls_fcs
+        self.num_reg_fcs = num_reg_fcs
+        self.reg_class_agnostic = reg_class_agnostic
+        assert self.reg_class_agnostic
+        self.norm_cfg = norm_cfg
+
+        self.bbox_coder = TASK_UTILS.build(bbox_coder)
+        self.loss_cls = MODELS.build(loss_cls)
+        self.loss_bbox_cls = MODELS.build(loss_bbox_cls)
+        self.loss_bbox_reg = MODELS.build(loss_bbox_reg)
+
+        self.cls_fcs = self._add_fc_branch(self.num_cls_fcs,
+                                           self.cls_in_channels,
+                                           self.roi_feat_size,
+                                           self.cls_out_channels)
+
+        self.side_num = int(np.ceil(self.num_buckets / 2))
+
+        if self.reg_feat_up_ratio > 1:
+            self.upsample_x = nn.ConvTranspose1d(
+                reg_in_channels,
+                reg_in_channels,
+                self.reg_feat_up_ratio,
+                stride=self.reg_feat_up_ratio)
+            self.upsample_y = nn.ConvTranspose1d(
+                reg_in_channels,
+                reg_in_channels,
+                self.reg_feat_up_ratio,
+                stride=self.reg_feat_up_ratio)
+
+        self.reg_pre_convs = nn.ModuleList()
+        for i in range(self.reg_pre_num):
+            reg_pre_conv = ConvModule(
+                reg_in_channels,
+                reg_in_channels,
+                kernel_size=reg_pre_kernel,
+                padding=reg_pre_kernel // 2,
+                norm_cfg=norm_cfg,
+                act_cfg=dict(type='ReLU'))
+            self.reg_pre_convs.append(reg_pre_conv)
+
+        self.reg_post_conv_xs = nn.ModuleList()
+        for i in range(self.reg_post_num):
+            reg_post_conv_x = ConvModule(
+                reg_in_channels,
+                reg_in_channels,
+                kernel_size=(1, reg_post_kernel),
+                padding=(0, reg_post_kernel // 2),
+                norm_cfg=norm_cfg,
+                act_cfg=dict(type='ReLU'))
+            self.reg_post_conv_xs.append(reg_post_conv_x)
+        self.reg_post_conv_ys = nn.ModuleList()
+        for i in range(self.reg_post_num):
+            reg_post_conv_y = ConvModule(
+                reg_in_channels,
+                reg_in_channels,
+                kernel_size=(reg_post_kernel, 1),
+                padding=(reg_post_kernel // 2, 0),
+                norm_cfg=norm_cfg,
+                act_cfg=dict(type='ReLU'))
+            self.reg_post_conv_ys.append(reg_post_conv_y)
+
+        self.reg_conv_att_x = nn.Conv2d(reg_in_channels, 1, 1)
+        self.reg_conv_att_y = nn.Conv2d(reg_in_channels, 1, 1)
+
+        self.fc_cls = nn.Linear(self.cls_out_channels, self.num_classes + 1)
+        self.relu = nn.ReLU(inplace=True)
+
+        self.reg_cls_fcs = self._add_fc_branch(self.num_reg_fcs,
+                                               self.reg_in_channels, 1,
+                                               self.reg_cls_out_channels)
+        self.reg_offset_fcs = self._add_fc_branch(self.num_reg_fcs,
+                                                  self.reg_in_channels, 1,
+                                                  self.reg_offset_out_channels)
+        self.fc_reg_cls = nn.Linear(self.reg_cls_out_channels, 1)
+        self.fc_reg_offset = nn.Linear(self.reg_offset_out_channels, 1)
+
+        if init_cfg is None:
+            self.init_cfg = [
+                dict(
+                    type='Xavier',
+                    layer='Linear',
+                    distribution='uniform',
+                    override=[
+                        dict(type='Normal', name='reg_conv_att_x', std=0.01),
+                        dict(type='Normal', name='reg_conv_att_y', std=0.01),
+                        dict(type='Normal', name='fc_reg_cls', std=0.01),
+                        dict(type='Normal', name='fc_cls', std=0.01),
+                        dict(type='Normal', name='fc_reg_offset', std=0.001)
+                    ])
+            ]
+            if self.reg_feat_up_ratio > 1:
+                self.init_cfg += [
+                    dict(
+                        type='Kaiming',
+                        distribution='normal',
+                        override=[
+                            dict(name='upsample_x'),
+                            dict(name='upsample_y')
+                        ])
+                ]
+
+    def _add_fc_branch(self, num_branch_fcs: int, in_channels: int,
+                       roi_feat_size: int,
+                       fc_out_channels: int) -> nn.ModuleList:
+        """build fc layers."""
+        in_channels = in_channels * roi_feat_size * roi_feat_size
+        branch_fcs = nn.ModuleList()
+        for i in range(num_branch_fcs):
+            fc_in_channels = (in_channels if i == 0 else fc_out_channels)
+            branch_fcs.append(nn.Linear(fc_in_channels, fc_out_channels))
+        return branch_fcs
+
+    def cls_forward(self, cls_x: Tensor) -> Tensor:
+        """forward of classification fc layers."""
+        cls_x = cls_x.view(cls_x.size(0), -1)
+        for fc in self.cls_fcs:
+            cls_x = self.relu(fc(cls_x))
+        cls_score = self.fc_cls(cls_x)
+        return cls_score
+
+    def attention_pool(self, reg_x: Tensor) -> tuple:
+        """Extract direction-specific features fx and fy with attention
+        methanism."""
+        reg_fx = reg_x
+        reg_fy = reg_x
+        reg_fx_att = self.reg_conv_att_x(reg_fx).sigmoid()
+        reg_fy_att = self.reg_conv_att_y(reg_fy).sigmoid()
+        reg_fx_att = reg_fx_att / reg_fx_att.sum(dim=2).unsqueeze(2)
+        reg_fy_att = reg_fy_att / reg_fy_att.sum(dim=3).unsqueeze(3)
+        reg_fx = (reg_fx * reg_fx_att).sum(dim=2)
+        reg_fy = (reg_fy * reg_fy_att).sum(dim=3)
+        return reg_fx, reg_fy
+
+    def side_aware_feature_extractor(self, reg_x: Tensor) -> tuple:
+        """Refine and extract side-aware features without split them."""
+        for reg_pre_conv in self.reg_pre_convs:
+            reg_x = reg_pre_conv(reg_x)
+        reg_fx, reg_fy = self.attention_pool(reg_x)
+
+        if self.reg_post_num > 0:
+            reg_fx = reg_fx.unsqueeze(2)
+            reg_fy = reg_fy.unsqueeze(3)
+            for i in range(self.reg_post_num):
+                reg_fx = self.reg_post_conv_xs[i](reg_fx)
+                reg_fy = self.reg_post_conv_ys[i](reg_fy)
+            reg_fx = reg_fx.squeeze(2)
+            reg_fy = reg_fy.squeeze(3)
+        if self.reg_feat_up_ratio > 1:
+            reg_fx = self.relu(self.upsample_x(reg_fx))
+            reg_fy = self.relu(self.upsample_y(reg_fy))
+        reg_fx = torch.transpose(reg_fx, 1, 2)
+        reg_fy = torch.transpose(reg_fy, 1, 2)
+        return reg_fx.contiguous(), reg_fy.contiguous()
+
+    def reg_pred(self, x: Tensor, offset_fcs: nn.ModuleList,
+                 cls_fcs: nn.ModuleList) -> tuple:
+        """Predict bucketing estimation (cls_pred) and fine regression (offset
+        pred) with side-aware features."""
+        x_offset = x.view(-1, self.reg_in_channels)
+        x_cls = x.view(-1, self.reg_in_channels)
+
+        for fc in offset_fcs:
+            x_offset = self.relu(fc(x_offset))
+        for fc in cls_fcs:
+            x_cls = self.relu(fc(x_cls))
+        offset_pred = self.fc_reg_offset(x_offset)
+        cls_pred = self.fc_reg_cls(x_cls)
+
+        offset_pred = offset_pred.view(x.size(0), -1)
+        cls_pred = cls_pred.view(x.size(0), -1)
+
+        return offset_pred, cls_pred
+
+    def side_aware_split(self, feat: Tensor) -> Tensor:
+        """Split side-aware features aligned with orders of bucketing
+        targets."""
+        l_end = int(np.ceil(self.up_reg_feat_size / 2))
+        r_start = int(np.floor(self.up_reg_feat_size / 2))
+        feat_fl = feat[:, :l_end]
+        feat_fr = feat[:, r_start:].flip(dims=(1, ))
+        feat_fl = feat_fl.contiguous()
+        feat_fr = feat_fr.contiguous()
+        feat = torch.cat([feat_fl, feat_fr], dim=-1)
+        return feat
+
+    def bbox_pred_split(self, bbox_pred: tuple,
+                        num_proposals_per_img: Sequence[int]) -> tuple:
+        """Split batch bbox prediction back to each image."""
+        bucket_cls_preds, bucket_offset_preds = bbox_pred
+        bucket_cls_preds = bucket_cls_preds.split(num_proposals_per_img, 0)
+        bucket_offset_preds = bucket_offset_preds.split(
+            num_proposals_per_img, 0)
+        bbox_pred = tuple(zip(bucket_cls_preds, bucket_offset_preds))
+        return bbox_pred
+
+    def reg_forward(self, reg_x: Tensor) -> tuple:
+        """forward of regression branch."""
+        outs = self.side_aware_feature_extractor(reg_x)
+        edge_offset_preds = []
+        edge_cls_preds = []
+        reg_fx = outs[0]
+        reg_fy = outs[1]
+        offset_pred_x, cls_pred_x = self.reg_pred(reg_fx, self.reg_offset_fcs,
+                                                  self.reg_cls_fcs)
+        offset_pred_y, cls_pred_y = self.reg_pred(reg_fy, self.reg_offset_fcs,
+                                                  self.reg_cls_fcs)
+        offset_pred_x = self.side_aware_split(offset_pred_x)
+        offset_pred_y = self.side_aware_split(offset_pred_y)
+        cls_pred_x = self.side_aware_split(cls_pred_x)
+        cls_pred_y = self.side_aware_split(cls_pred_y)
+        edge_offset_preds = torch.cat([offset_pred_x, offset_pred_y], dim=-1)
+        edge_cls_preds = torch.cat([cls_pred_x, cls_pred_y], dim=-1)
+
+        return edge_cls_preds, edge_offset_preds
+
+    def forward(self, x: Tensor) -> tuple:
+        """Forward features from the upstream network."""
+        bbox_pred = self.reg_forward(x)
+        cls_score = self.cls_forward(x)
+
+        return cls_score, bbox_pred
+
+    def get_targets(self,
+                    sampling_results: List[SamplingResult],
+                    rcnn_train_cfg: ConfigDict,
+                    concat: bool = True) -> tuple:
+        """Calculate the ground truth for all samples in a batch according to
+        the sampling_results."""
+        pos_proposals = [res.pos_bboxes for res in sampling_results]
+        neg_proposals = [res.neg_bboxes for res in sampling_results]
+        pos_gt_bboxes = [res.pos_gt_bboxes for res in sampling_results]
+        pos_gt_labels = [res.pos_gt_labels for res in sampling_results]
+        cls_reg_targets = self.bucket_target(
+            pos_proposals,
+            neg_proposals,
+            pos_gt_bboxes,
+            pos_gt_labels,
+            rcnn_train_cfg,
+            concat=concat)
+        (labels, label_weights, bucket_cls_targets, bucket_cls_weights,
+         bucket_offset_targets, bucket_offset_weights) = cls_reg_targets
+        return (labels, label_weights, (bucket_cls_targets,
+                                        bucket_offset_targets),
+                (bucket_cls_weights, bucket_offset_weights))
+
+    def bucket_target(self,
+                      pos_proposals_list: list,
+                      neg_proposals_list: list,
+                      pos_gt_bboxes_list: list,
+                      pos_gt_labels_list: list,
+                      rcnn_train_cfg: ConfigDict,
+                      concat: bool = True) -> tuple:
+        """Compute bucketing estimation targets and fine regression targets for
+        a batch of images."""
+        (labels, label_weights, bucket_cls_targets, bucket_cls_weights,
+         bucket_offset_targets, bucket_offset_weights) = multi_apply(
+             self._bucket_target_single,
+             pos_proposals_list,
+             neg_proposals_list,
+             pos_gt_bboxes_list,
+             pos_gt_labels_list,
+             cfg=rcnn_train_cfg)
+
+        if concat:
+            labels = torch.cat(labels, 0)
+            label_weights = torch.cat(label_weights, 0)
+            bucket_cls_targets = torch.cat(bucket_cls_targets, 0)
+            bucket_cls_weights = torch.cat(bucket_cls_weights, 0)
+            bucket_offset_targets = torch.cat(bucket_offset_targets, 0)
+            bucket_offset_weights = torch.cat(bucket_offset_weights, 0)
+        return (labels, label_weights, bucket_cls_targets, bucket_cls_weights,
+                bucket_offset_targets, bucket_offset_weights)
+
+    def _bucket_target_single(self, pos_proposals: Tensor,
+                              neg_proposals: Tensor, pos_gt_bboxes: Tensor,
+                              pos_gt_labels: Tensor, cfg: ConfigDict) -> tuple:
+        """Compute bucketing estimation targets and fine regression targets for
+        a single image.
+
+        Args:
+            pos_proposals (Tensor): positive proposals of a single image,
+                 Shape (n_pos, 4)
+            neg_proposals (Tensor): negative proposals of a single image,
+                 Shape (n_neg, 4).
+            pos_gt_bboxes (Tensor): gt bboxes assigned to positive proposals
+                 of a single image, Shape (n_pos, 4).
+            pos_gt_labels (Tensor): gt labels assigned to positive proposals
+                 of a single image, Shape (n_pos, ).
+            cfg (dict): Config of calculating targets
+
+        Returns:
+            tuple:
+
+            - labels (Tensor): Labels in a single image. Shape (n,).
+            - label_weights (Tensor): Label weights in a single image.
+                Shape (n,)
+            - bucket_cls_targets (Tensor): Bucket cls targets in
+                a single image. Shape (n, num_buckets*2).
+            - bucket_cls_weights (Tensor): Bucket cls weights in
+                a single image. Shape (n, num_buckets*2).
+            - bucket_offset_targets (Tensor): Bucket offset targets
+                in a single image. Shape (n, num_buckets*2).
+            - bucket_offset_targets (Tensor): Bucket offset weights
+                in a single image. Shape (n, num_buckets*2).
+        """
+        num_pos = pos_proposals.size(0)
+        num_neg = neg_proposals.size(0)
+        num_samples = num_pos + num_neg
+        labels = pos_gt_bboxes.new_full((num_samples, ),
+                                        self.num_classes,
+                                        dtype=torch.long)
+        label_weights = pos_proposals.new_zeros(num_samples)
+        bucket_cls_targets = pos_proposals.new_zeros(num_samples,
+                                                     4 * self.side_num)
+        bucket_cls_weights = pos_proposals.new_zeros(num_samples,
+                                                     4 * self.side_num)
+        bucket_offset_targets = pos_proposals.new_zeros(
+            num_samples, 4 * self.side_num)
+        bucket_offset_weights = pos_proposals.new_zeros(
+            num_samples, 4 * self.side_num)
+        if num_pos > 0:
+            labels[:num_pos] = pos_gt_labels
+            label_weights[:num_pos] = 1.0
+            (pos_bucket_offset_targets, pos_bucket_offset_weights,
+             pos_bucket_cls_targets,
+             pos_bucket_cls_weights) = self.bbox_coder.encode(
+                 pos_proposals, pos_gt_bboxes)
+            bucket_cls_targets[:num_pos, :] = pos_bucket_cls_targets
+            bucket_cls_weights[:num_pos, :] = pos_bucket_cls_weights
+            bucket_offset_targets[:num_pos, :] = pos_bucket_offset_targets
+            bucket_offset_weights[:num_pos, :] = pos_bucket_offset_weights
+        if num_neg > 0:
+            label_weights[-num_neg:] = 1.0
+        return (labels, label_weights, bucket_cls_targets, bucket_cls_weights,
+                bucket_offset_targets, bucket_offset_weights)
+
+    def loss(self,
+             cls_score: Tensor,
+             bbox_pred: Tuple[Tensor, Tensor],
+             rois: Tensor,
+             labels: Tensor,
+             label_weights: Tensor,
+             bbox_targets: Tuple[Tensor, Tensor],
+             bbox_weights: Tuple[Tensor, Tensor],
+             reduction_override: Optional[str] = None) -> dict:
+        """Calculate the loss based on the network predictions and targets.
+
+        Args:
+            cls_score (Tensor): Classification prediction
+                results of all class, has shape
+                (batch_size * num_proposals_single_image, num_classes)
+            bbox_pred (Tensor): A tuple of regression prediction results
+                containing `bucket_cls_preds and` `bucket_offset_preds`.
+            rois (Tensor): RoIs with the shape
+                (batch_size * num_proposals_single_image, 5) where the first
+                column indicates batch id of each RoI.
+            labels (Tensor): Gt_labels for all proposals in a batch, has
+                shape (batch_size * num_proposals_single_image, ).
+            label_weights (Tensor): Labels_weights for all proposals in a
+                batch, has shape (batch_size * num_proposals_single_image, ).
+            bbox_targets (Tuple[Tensor, Tensor]): A tuple of regression target
+                containing `bucket_cls_targets` and `bucket_offset_targets`.
+                the last dimension 4 represents [tl_x, tl_y, br_x, br_y].
+            bbox_weights (Tuple[Tensor, Tensor]): A tuple of regression
+                weights containing `bucket_cls_weights` and
+                `bucket_offset_weights`.
+            reduction_override (str, optional): The reduction
+                method used to override the original reduction
+                method of the loss. Options are "none",
+                "mean" and "sum". Defaults to None,
+
+        Returns:
+            dict: A dictionary of loss.
+        """
+        losses = dict()
+        if cls_score is not None:
+            avg_factor = max(torch.sum(label_weights > 0).float().item(), 1.)
+            losses['loss_cls'] = self.loss_cls(
+                cls_score,
+                labels,
+                label_weights,
+                avg_factor=avg_factor,
+                reduction_override=reduction_override)
+            losses['acc'] = accuracy(cls_score, labels)
+
+        if bbox_pred is not None:
+            bucket_cls_preds, bucket_offset_preds = bbox_pred
+            bucket_cls_targets, bucket_offset_targets = bbox_targets
+            bucket_cls_weights, bucket_offset_weights = bbox_weights
+            # edge cls
+            bucket_cls_preds = bucket_cls_preds.view(-1, self.side_num)
+            bucket_cls_targets = bucket_cls_targets.view(-1, self.side_num)
+            bucket_cls_weights = bucket_cls_weights.view(-1, self.side_num)
+            losses['loss_bbox_cls'] = self.loss_bbox_cls(
+                bucket_cls_preds,
+                bucket_cls_targets,
+                bucket_cls_weights,
+                avg_factor=bucket_cls_targets.size(0),
+                reduction_override=reduction_override)
+
+            losses['loss_bbox_reg'] = self.loss_bbox_reg(
+                bucket_offset_preds,
+                bucket_offset_targets,
+                bucket_offset_weights,
+                avg_factor=bucket_offset_targets.size(0),
+                reduction_override=reduction_override)
+
+        return losses
+
+    def _predict_by_feat_single(
+            self,
+            roi: Tensor,
+            cls_score: Tensor,
+            bbox_pred: Tuple[Tensor, Tensor],
+            img_meta: dict,
+            rescale: bool = False,
+            rcnn_test_cfg: Optional[ConfigDict] = None) -> InstanceData:
+        """Transform a single image's features extracted from the head into
+        bbox results.
+
+        Args:
+            roi (Tensor): Boxes to be transformed. Has shape (num_boxes, 5).
+                last dimension 5 arrange as (batch_index, x1, y1, x2, y2).
+            cls_score (Tensor): Box scores, has shape
+                (num_boxes, num_classes + 1).
+            bbox_pred (Tuple[Tensor, Tensor]): Box cls preds and offset preds.
+            img_meta (dict): image information.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            rcnn_test_cfg (obj:`ConfigDict`): `test_cfg` of Bbox Head.
+                Defaults to None
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            Each item usually contains following keys.
+
+            - scores (Tensor): Classification scores, has a shape
+              (num_instance, )
+            - labels (Tensor): Labels of bboxes, has a shape
+              (num_instances, ).
+            - bboxes (Tensor): Has a shape (num_instances, 4),
+              the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        results = InstanceData()
+        if isinstance(cls_score, list):
+            cls_score = sum(cls_score) / float(len(cls_score))
+        scores = F.softmax(cls_score, dim=1) if cls_score is not None else None
+        img_shape = img_meta['img_shape']
+        if bbox_pred is not None:
+            bboxes, confidences = self.bbox_coder.decode(
+                roi[:, 1:], bbox_pred, img_shape)
+        else:
+            bboxes = roi[:, 1:].clone()
+            confidences = None
+            if img_shape is not None:
+                bboxes[:, [0, 2]].clamp_(min=0, max=img_shape[1] - 1)
+                bboxes[:, [1, 3]].clamp_(min=0, max=img_shape[0] - 1)
+
+        if rescale and bboxes.size(0) > 0:
+            assert img_meta.get('scale_factor') is not None
+            scale_factor = bboxes.new_tensor(img_meta['scale_factor']).repeat(
+                (1, 2))
+            bboxes = (bboxes.view(bboxes.size(0), -1, 4) / scale_factor).view(
+                bboxes.size()[0], -1)
+
+        if rcnn_test_cfg is None:
+            results.bboxes = bboxes
+            results.scores = scores
+        else:
+            det_bboxes, det_labels = multiclass_nms(
+                bboxes,
+                scores,
+                rcnn_test_cfg.score_thr,
+                rcnn_test_cfg.nms,
+                rcnn_test_cfg.max_per_img,
+                score_factors=confidences)
+            results.bboxes = det_bboxes[:, :4]
+            results.scores = det_bboxes[:, -1]
+            results.labels = det_labels
+        return results
+
+    def refine_bboxes(self, sampling_results: List[SamplingResult],
+                      bbox_results: dict,
+                      batch_img_metas: List[dict]) -> InstanceList:
+        """Refine bboxes during training.
+
+        Args:
+            sampling_results (List[:obj:`SamplingResult`]): Sampling results.
+            bbox_results (dict): Usually is a dictionary with keys:
+
+                - `cls_score` (Tensor): Classification scores.
+                - `bbox_pred` (Tensor): Box energies / deltas.
+                - `rois` (Tensor): RoIs with the shape (n, 5) where the first
+                  column indicates batch id of each RoI.
+                - `bbox_targets` (tuple):  Ground truth for proposals in a
+                  single image. Containing the following list of Tensors:
+                  (labels, label_weights, bbox_targets, bbox_weights)
+            batch_img_metas (List[dict]): List of image information.
+
+        Returns:
+            list[:obj:`InstanceData`]: Refined bboxes of each image.
+        """
+        pos_is_gts = [res.pos_is_gt for res in sampling_results]
+        # bbox_targets is a tuple
+        labels = bbox_results['bbox_targets'][0]
+        cls_scores = bbox_results['cls_score']
+        rois = bbox_results['rois']
+        bbox_preds = bbox_results['bbox_pred']
+
+        if cls_scores.numel() == 0:
+            return None
+
+        labels = torch.where(labels == self.num_classes,
+                             cls_scores[:, :-1].argmax(1), labels)
+
+        img_ids = rois[:, 0].long().unique(sorted=True)
+        assert img_ids.numel() <= len(batch_img_metas)
+
+        results_list = []
+        for i in range(len(batch_img_metas)):
+            inds = torch.nonzero(
+                rois[:, 0] == i, as_tuple=False).squeeze(dim=1)
+            num_rois = inds.numel()
+
+            bboxes_ = rois[inds, 1:]
+            label_ = labels[inds]
+            edge_cls_preds, edge_offset_preds = bbox_preds
+            edge_cls_preds_ = edge_cls_preds[inds]
+            edge_offset_preds_ = edge_offset_preds[inds]
+            bbox_pred_ = (edge_cls_preds_, edge_offset_preds_)
+            img_meta_ = batch_img_metas[i]
+            pos_is_gts_ = pos_is_gts[i]
+
+            bboxes = self.regress_by_class(bboxes_, label_, bbox_pred_,
+                                           img_meta_)
+            # filter gt bboxes
+            pos_keep = 1 - pos_is_gts_
+            keep_inds = pos_is_gts_.new_ones(num_rois)
+            keep_inds[:len(pos_is_gts_)] = pos_keep
+            results = InstanceData(bboxes=bboxes[keep_inds.type(torch.bool)])
+            results_list.append(results)
+
+        return results_list
+
+    def regress_by_class(self, rois: Tensor, label: Tensor, bbox_pred: tuple,
+                         img_meta: dict) -> Tensor:
+        """Regress the bbox for the predicted class. Used in Cascade R-CNN.
+
+        Args:
+            rois (Tensor): shape (n, 4) or (n, 5)
+            label (Tensor): shape (n, )
+            bbox_pred (Tuple[Tensor]): shape [(n, num_buckets *2), \
+                (n, num_buckets *2)]
+            img_meta (dict): Image meta info.
+
+        Returns:
+            Tensor: Regressed bboxes, the same shape as input rois.
+        """
+        assert rois.size(1) == 4 or rois.size(1) == 5
+
+        if rois.size(1) == 4:
+            new_rois, _ = self.bbox_coder.decode(rois, bbox_pred,
+                                                 img_meta['img_shape'])
+        else:
+            bboxes, _ = self.bbox_coder.decode(rois[:, 1:], bbox_pred,
+                                               img_meta['img_shape'])
+            new_rois = torch.cat((rois[:, [0]], bboxes), dim=1)
+
+        return new_rois
diff --git a/mmdetection/mmdet/models/roi_heads/bbox_heads/scnet_bbox_head.py b/mmdetection/mmdet/models/roi_heads/bbox_heads/scnet_bbox_head.py
new file mode 100644
index 00000000..790b08fb
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/bbox_heads/scnet_bbox_head.py
@@ -0,0 +1,101 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Tuple, Union
+
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from .convfc_bbox_head import ConvFCBBoxHead
+
+
+@MODELS.register_module()
+class SCNetBBoxHead(ConvFCBBoxHead):
+    """BBox head for `SCNet `_.
+
+    This inherits ``ConvFCBBoxHead`` with modified forward() function, allow us
+    to get intermediate shared feature.
+    """
+
+    def _forward_shared(self, x: Tensor) -> Tensor:
+        """Forward function for shared part.
+
+        Args:
+            x (Tensor): Input feature.
+
+        Returns:
+            Tensor: Shared feature.
+        """
+        if self.num_shared_convs > 0:
+            for conv in self.shared_convs:
+                x = conv(x)
+
+        if self.num_shared_fcs > 0:
+            if self.with_avg_pool:
+                x = self.avg_pool(x)
+
+            x = x.flatten(1)
+
+            for fc in self.shared_fcs:
+                x = self.relu(fc(x))
+
+        return x
+
+    def _forward_cls_reg(self, x: Tensor) -> Tuple[Tensor]:
+        """Forward function for classification and regression parts.
+
+        Args:
+            x (Tensor): Input feature.
+
+        Returns:
+            tuple[Tensor]:
+
+                - cls_score (Tensor): classification prediction.
+                - bbox_pred (Tensor): bbox prediction.
+        """
+        x_cls = x
+        x_reg = x
+
+        for conv in self.cls_convs:
+            x_cls = conv(x_cls)
+        if x_cls.dim() > 2:
+            if self.with_avg_pool:
+                x_cls = self.avg_pool(x_cls)
+            x_cls = x_cls.flatten(1)
+        for fc in self.cls_fcs:
+            x_cls = self.relu(fc(x_cls))
+
+        for conv in self.reg_convs:
+            x_reg = conv(x_reg)
+        if x_reg.dim() > 2:
+            if self.with_avg_pool:
+                x_reg = self.avg_pool(x_reg)
+            x_reg = x_reg.flatten(1)
+        for fc in self.reg_fcs:
+            x_reg = self.relu(fc(x_reg))
+
+        cls_score = self.fc_cls(x_cls) if self.with_cls else None
+        bbox_pred = self.fc_reg(x_reg) if self.with_reg else None
+
+        return cls_score, bbox_pred
+
+    def forward(
+            self,
+            x: Tensor,
+            return_shared_feat: bool = False) -> Union[Tensor, Tuple[Tensor]]:
+        """Forward function.
+
+        Args:
+            x (Tensor): input features
+            return_shared_feat (bool): If True, return cls-reg-shared feature.
+
+        Return:
+            out (tuple[Tensor]): contain ``cls_score`` and ``bbox_pred``,
+                if  ``return_shared_feat`` is True, append ``x_shared`` to the
+                returned tuple.
+        """
+        x_shared = self._forward_shared(x)
+        out = self._forward_cls_reg(x_shared)
+
+        if return_shared_feat:
+            out += (x_shared, )
+
+        return out
diff --git a/mmdetection/mmdet/models/roi_heads/cascade_roi_head.py b/mmdetection/mmdet/models/roi_heads/cascade_roi_head.py
new file mode 100644
index 00000000..81db6711
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/cascade_roi_head.py
@@ -0,0 +1,568 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Sequence, Tuple, Union
+
+import torch
+import torch.nn as nn
+from mmengine.model import ModuleList
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.models.task_modules.samplers import SamplingResult
+from mmdet.models.test_time_augs import merge_aug_masks
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.structures import SampleList
+from mmdet.structures.bbox import bbox2roi, get_box_tensor
+from mmdet.utils import (ConfigType, InstanceList, MultiConfig, OptConfigType,
+                         OptMultiConfig)
+from ..utils.misc import empty_instances, unpack_gt_instances
+from .base_roi_head import BaseRoIHead
+
+
+@MODELS.register_module()
+class CascadeRoIHead(BaseRoIHead):
+    """Cascade roi head including one bbox head and one mask head.
+
+    https://arxiv.org/abs/1712.00726
+    """
+
+    def __init__(self,
+                 num_stages: int,
+                 stage_loss_weights: Union[List[float], Tuple[float]],
+                 bbox_roi_extractor: OptMultiConfig = None,
+                 bbox_head: OptMultiConfig = None,
+                 mask_roi_extractor: OptMultiConfig = None,
+                 mask_head: OptMultiConfig = None,
+                 shared_head: OptConfigType = None,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        assert bbox_roi_extractor is not None
+        assert bbox_head is not None
+        assert shared_head is None, \
+            'Shared head is not supported in Cascade RCNN anymore'
+
+        self.num_stages = num_stages
+        self.stage_loss_weights = stage_loss_weights
+        super().__init__(
+            bbox_roi_extractor=bbox_roi_extractor,
+            bbox_head=bbox_head,
+            mask_roi_extractor=mask_roi_extractor,
+            mask_head=mask_head,
+            shared_head=shared_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            init_cfg=init_cfg)
+
+    def init_bbox_head(self, bbox_roi_extractor: MultiConfig,
+                       bbox_head: MultiConfig) -> None:
+        """Initialize box head and box roi extractor.
+
+        Args:
+            bbox_roi_extractor (:obj:`ConfigDict`, dict or list):
+                Config of box roi extractor.
+            bbox_head (:obj:`ConfigDict`, dict or list): Config
+                of box in box head.
+        """
+        self.bbox_roi_extractor = ModuleList()
+        self.bbox_head = ModuleList()
+        if not isinstance(bbox_roi_extractor, list):
+            bbox_roi_extractor = [
+                bbox_roi_extractor for _ in range(self.num_stages)
+            ]
+        if not isinstance(bbox_head, list):
+            bbox_head = [bbox_head for _ in range(self.num_stages)]
+        assert len(bbox_roi_extractor) == len(bbox_head) == self.num_stages
+        for roi_extractor, head in zip(bbox_roi_extractor, bbox_head):
+            self.bbox_roi_extractor.append(MODELS.build(roi_extractor))
+            self.bbox_head.append(MODELS.build(head))
+
+    def init_mask_head(self, mask_roi_extractor: MultiConfig,
+                       mask_head: MultiConfig) -> None:
+        """Initialize mask head and mask roi extractor.
+
+        Args:
+            mask_head (dict): Config of mask in mask head.
+            mask_roi_extractor (:obj:`ConfigDict`, dict or list):
+                Config of mask roi extractor.
+        """
+        self.mask_head = nn.ModuleList()
+        if not isinstance(mask_head, list):
+            mask_head = [mask_head for _ in range(self.num_stages)]
+        assert len(mask_head) == self.num_stages
+        for head in mask_head:
+            self.mask_head.append(MODELS.build(head))
+        if mask_roi_extractor is not None:
+            self.share_roi_extractor = False
+            self.mask_roi_extractor = ModuleList()
+            if not isinstance(mask_roi_extractor, list):
+                mask_roi_extractor = [
+                    mask_roi_extractor for _ in range(self.num_stages)
+                ]
+            assert len(mask_roi_extractor) == self.num_stages
+            for roi_extractor in mask_roi_extractor:
+                self.mask_roi_extractor.append(MODELS.build(roi_extractor))
+        else:
+            self.share_roi_extractor = True
+            self.mask_roi_extractor = self.bbox_roi_extractor
+
+    def init_assigner_sampler(self) -> None:
+        """Initialize assigner and sampler for each stage."""
+        self.bbox_assigner = []
+        self.bbox_sampler = []
+        if self.train_cfg is not None:
+            for idx, rcnn_train_cfg in enumerate(self.train_cfg):
+                self.bbox_assigner.append(
+                    TASK_UTILS.build(rcnn_train_cfg.assigner))
+                self.current_stage = idx
+                self.bbox_sampler.append(
+                    TASK_UTILS.build(
+                        rcnn_train_cfg.sampler,
+                        default_args=dict(context=self)))
+
+    def _bbox_forward(self, stage: int, x: Tuple[Tensor],
+                      rois: Tensor) -> dict:
+        """Box head forward function used in both training and testing.
+
+        Args:
+            stage (int): The current stage in Cascade RoI Head.
+            x (tuple[Tensor]): List of multi-level img features.
+            rois (Tensor): RoIs with the shape (n, 5) where the first
+                column indicates batch id of each RoI.
+
+        Returns:
+             dict[str, Tensor]: Usually returns a dictionary with keys:
+
+                - `cls_score` (Tensor): Classification scores.
+                - `bbox_pred` (Tensor): Box energies / deltas.
+                - `bbox_feats` (Tensor): Extract bbox RoI features.
+        """
+        bbox_roi_extractor = self.bbox_roi_extractor[stage]
+        bbox_head = self.bbox_head[stage]
+        bbox_feats = bbox_roi_extractor(x[:bbox_roi_extractor.num_inputs],
+                                        rois)
+        # do not support caffe_c4 model anymore
+        cls_score, bbox_pred = bbox_head(bbox_feats)
+
+        bbox_results = dict(
+            cls_score=cls_score, bbox_pred=bbox_pred, bbox_feats=bbox_feats)
+        return bbox_results
+
+    def bbox_loss(self, stage: int, x: Tuple[Tensor],
+                  sampling_results: List[SamplingResult]) -> dict:
+        """Run forward function and calculate loss for box head in training.
+
+        Args:
+            stage (int): The current stage in Cascade RoI Head.
+            x (tuple[Tensor]): List of multi-level img features.
+            sampling_results (list["obj:`SamplingResult`]): Sampling results.
+
+        Returns:
+            dict: Usually returns a dictionary with keys:
+
+                - `cls_score` (Tensor): Classification scores.
+                - `bbox_pred` (Tensor): Box energies / deltas.
+                - `bbox_feats` (Tensor): Extract bbox RoI features.
+                - `loss_bbox` (dict): A dictionary of bbox loss components.
+                - `rois` (Tensor): RoIs with the shape (n, 5) where the first
+                  column indicates batch id of each RoI.
+                - `bbox_targets` (tuple):  Ground truth for proposals in a
+                  single image. Containing the following list of Tensors:
+                  (labels, label_weights, bbox_targets, bbox_weights)
+        """
+        bbox_head = self.bbox_head[stage]
+        rois = bbox2roi([res.priors for res in sampling_results])
+        bbox_results = self._bbox_forward(stage, x, rois)
+        bbox_results.update(rois=rois)
+
+        bbox_loss_and_target = bbox_head.loss_and_target(
+            cls_score=bbox_results['cls_score'],
+            bbox_pred=bbox_results['bbox_pred'],
+            rois=rois,
+            sampling_results=sampling_results,
+            rcnn_train_cfg=self.train_cfg[stage])
+        bbox_results.update(bbox_loss_and_target)
+
+        return bbox_results
+
+    def _mask_forward(self, stage: int, x: Tuple[Tensor],
+                      rois: Tensor) -> dict:
+        """Mask head forward function used in both training and testing.
+
+        Args:
+            stage (int): The current stage in Cascade RoI Head.
+            x (tuple[Tensor]): Tuple of multi-level img features.
+            rois (Tensor): RoIs with the shape (n, 5) where the first
+                column indicates batch id of each RoI.
+
+        Returns:
+            dict: Usually returns a dictionary with keys:
+
+                - `mask_preds` (Tensor): Mask prediction.
+        """
+        mask_roi_extractor = self.mask_roi_extractor[stage]
+        mask_head = self.mask_head[stage]
+        mask_feats = mask_roi_extractor(x[:mask_roi_extractor.num_inputs],
+                                        rois)
+        # do not support caffe_c4 model anymore
+        mask_preds = mask_head(mask_feats)
+
+        mask_results = dict(mask_preds=mask_preds)
+        return mask_results
+
+    def mask_loss(self, stage: int, x: Tuple[Tensor],
+                  sampling_results: List[SamplingResult],
+                  batch_gt_instances: InstanceList) -> dict:
+        """Run forward function and calculate loss for mask head in training.
+
+        Args:
+            stage (int): The current stage in Cascade RoI Head.
+            x (tuple[Tensor]): Tuple of multi-level img features.
+            sampling_results (list["obj:`SamplingResult`]): Sampling results.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes``, ``labels``, and
+                ``masks`` attributes.
+
+        Returns:
+            dict: Usually returns a dictionary with keys:
+
+                - `mask_preds` (Tensor): Mask prediction.
+                - `loss_mask` (dict): A dictionary of mask loss components.
+        """
+        pos_rois = bbox2roi([res.pos_priors for res in sampling_results])
+        mask_results = self._mask_forward(stage, x, pos_rois)
+
+        mask_head = self.mask_head[stage]
+
+        mask_loss_and_target = mask_head.loss_and_target(
+            mask_preds=mask_results['mask_preds'],
+            sampling_results=sampling_results,
+            batch_gt_instances=batch_gt_instances,
+            rcnn_train_cfg=self.train_cfg[stage])
+        mask_results.update(mask_loss_and_target)
+
+        return mask_results
+
+    def loss(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
+             batch_data_samples: SampleList) -> dict:
+        """Perform forward propagation and loss calculation of the detection
+        roi on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components
+        """
+        # TODO: May add a new function in baseroihead
+        assert len(rpn_results_list) == len(batch_data_samples)
+        outputs = unpack_gt_instances(batch_data_samples)
+        batch_gt_instances, batch_gt_instances_ignore, batch_img_metas \
+            = outputs
+
+        num_imgs = len(batch_data_samples)
+        losses = dict()
+        results_list = rpn_results_list
+        for stage in range(self.num_stages):
+            self.current_stage = stage
+
+            stage_loss_weight = self.stage_loss_weights[stage]
+
+            # assign gts and sample proposals
+            sampling_results = []
+            if self.with_bbox or self.with_mask:
+                bbox_assigner = self.bbox_assigner[stage]
+                bbox_sampler = self.bbox_sampler[stage]
+
+                for i in range(num_imgs):
+                    results = results_list[i]
+                    # rename rpn_results.bboxes to rpn_results.priors
+                    results.priors = results.pop('bboxes')
+
+                    assign_result = bbox_assigner.assign(
+                        results, batch_gt_instances[i],
+                        batch_gt_instances_ignore[i])
+
+                    sampling_result = bbox_sampler.sample(
+                        assign_result,
+                        results,
+                        batch_gt_instances[i],
+                        feats=[lvl_feat[i][None] for lvl_feat in x])
+                    sampling_results.append(sampling_result)
+
+            # bbox head forward and loss
+            bbox_results = self.bbox_loss(stage, x, sampling_results)
+
+            for name, value in bbox_results['loss_bbox'].items():
+                losses[f's{stage}.{name}'] = (
+                    value * stage_loss_weight if 'loss' in name else value)
+
+            # mask head forward and loss
+            if self.with_mask:
+                mask_results = self.mask_loss(stage, x, sampling_results,
+                                              batch_gt_instances)
+                for name, value in mask_results['loss_mask'].items():
+                    losses[f's{stage}.{name}'] = (
+                        value * stage_loss_weight if 'loss' in name else value)
+
+            # refine bboxes
+            if stage < self.num_stages - 1:
+                bbox_head = self.bbox_head[stage]
+                with torch.no_grad():
+                    results_list = bbox_head.refine_bboxes(
+                        sampling_results, bbox_results, batch_img_metas)
+                    # Empty proposal
+                    if results_list is None:
+                        break
+        return losses
+
+    def predict_bbox(self,
+                     x: Tuple[Tensor],
+                     batch_img_metas: List[dict],
+                     rpn_results_list: InstanceList,
+                     rcnn_test_cfg: ConfigType,
+                     rescale: bool = False,
+                     **kwargs) -> InstanceList:
+        """Perform forward propagation of the bbox head and predict detection
+        results on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Feature maps of all scale level.
+            batch_img_metas (list[dict]): List of image information.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals.
+            rcnn_test_cfg (obj:`ConfigDict`): `test_cfg` of R-CNN.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        proposals = [res.bboxes for res in rpn_results_list]
+        num_proposals_per_img = tuple(len(p) for p in proposals)
+        rois = bbox2roi(proposals)
+
+        if rois.shape[0] == 0:
+            return empty_instances(
+                batch_img_metas,
+                rois.device,
+                task_type='bbox',
+                box_type=self.bbox_head[-1].predict_box_type,
+                num_classes=self.bbox_head[-1].num_classes,
+                score_per_cls=rcnn_test_cfg is None)
+
+        rois, cls_scores, bbox_preds = self._refine_roi(
+            x=x,
+            rois=rois,
+            batch_img_metas=batch_img_metas,
+            num_proposals_per_img=num_proposals_per_img,
+            **kwargs)
+
+        results_list = self.bbox_head[-1].predict_by_feat(
+            rois=rois,
+            cls_scores=cls_scores,
+            bbox_preds=bbox_preds,
+            batch_img_metas=batch_img_metas,
+            rescale=rescale,
+            rcnn_test_cfg=rcnn_test_cfg)
+        return results_list
+
+    def predict_mask(self,
+                     x: Tuple[Tensor],
+                     batch_img_metas: List[dict],
+                     results_list: List[InstanceData],
+                     rescale: bool = False) -> List[InstanceData]:
+        """Perform forward propagation of the mask head and predict detection
+        results on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Feature maps of all scale level.
+            batch_img_metas (list[dict]): List of image information.
+            results_list (list[:obj:`InstanceData`]): Detection results of
+                each image.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+                - masks (Tensor): Has a shape (num_instances, H, W).
+        """
+        bboxes = [res.bboxes for res in results_list]
+        mask_rois = bbox2roi(bboxes)
+        if mask_rois.shape[0] == 0:
+            results_list = empty_instances(
+                batch_img_metas,
+                mask_rois.device,
+                task_type='mask',
+                instance_results=results_list,
+                mask_thr_binary=self.test_cfg.mask_thr_binary)
+            return results_list
+
+        num_mask_rois_per_img = [len(res) for res in results_list]
+        aug_masks = []
+        for stage in range(self.num_stages):
+            mask_results = self._mask_forward(stage, x, mask_rois)
+            mask_preds = mask_results['mask_preds']
+            # split batch mask prediction back to each image
+            mask_preds = mask_preds.split(num_mask_rois_per_img, 0)
+            aug_masks.append([m.sigmoid().detach() for m in mask_preds])
+
+        merged_masks = []
+        for i in range(len(batch_img_metas)):
+            aug_mask = [mask[i] for mask in aug_masks]
+            merged_mask = merge_aug_masks(aug_mask, batch_img_metas[i])
+            merged_masks.append(merged_mask)
+        results_list = self.mask_head[-1].predict_by_feat(
+            mask_preds=merged_masks,
+            results_list=results_list,
+            batch_img_metas=batch_img_metas,
+            rcnn_test_cfg=self.test_cfg,
+            rescale=rescale,
+            activate_map=True)
+        return results_list
+
+    def _refine_roi(self, x: Tuple[Tensor], rois: Tensor,
+                    batch_img_metas: List[dict],
+                    num_proposals_per_img: Sequence[int], **kwargs) -> tuple:
+        """Multi-stage refinement of RoI.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            rois (Tensor): shape (n, 5), [batch_ind, x1, y1, x2, y2]
+            batch_img_metas (list[dict]): List of image information.
+            num_proposals_per_img (sequence[int]): number of proposals
+                in each image.
+
+        Returns:
+            tuple:
+
+               - rois (Tensor): Refined RoI.
+               - cls_scores (list[Tensor]): Average predicted
+                   cls score per image.
+               - bbox_preds (list[Tensor]): Bbox branch predictions
+                   for the last stage of per image.
+        """
+        # "ms" in variable names means multi-stage
+        ms_scores = []
+        for stage in range(self.num_stages):
+            bbox_results = self._bbox_forward(
+                stage=stage, x=x, rois=rois, **kwargs)
+
+            # split batch bbox prediction back to each image
+            cls_scores = bbox_results['cls_score']
+            bbox_preds = bbox_results['bbox_pred']
+
+            rois = rois.split(num_proposals_per_img, 0)
+            cls_scores = cls_scores.split(num_proposals_per_img, 0)
+            ms_scores.append(cls_scores)
+
+            # some detector with_reg is False, bbox_preds will be None
+            if bbox_preds is not None:
+                # TODO move this to a sabl_roi_head
+                # the bbox prediction of some detectors like SABL is not Tensor
+                if isinstance(bbox_preds, torch.Tensor):
+                    bbox_preds = bbox_preds.split(num_proposals_per_img, 0)
+                else:
+                    bbox_preds = self.bbox_head[stage].bbox_pred_split(
+                        bbox_preds, num_proposals_per_img)
+            else:
+                bbox_preds = (None, ) * len(batch_img_metas)
+
+            if stage < self.num_stages - 1:
+                bbox_head = self.bbox_head[stage]
+                if bbox_head.custom_activation:
+                    cls_scores = [
+                        bbox_head.loss_cls.get_activation(s)
+                        for s in cls_scores
+                    ]
+                refine_rois_list = []
+                for i in range(len(batch_img_metas)):
+                    if rois[i].shape[0] > 0:
+                        bbox_label = cls_scores[i][:, :-1].argmax(dim=1)
+                        # Refactor `bbox_head.regress_by_class` to only accept
+                        # box tensor without img_idx concatenated.
+                        refined_bboxes = bbox_head.regress_by_class(
+                            rois[i][:, 1:], bbox_label, bbox_preds[i],
+                            batch_img_metas[i])
+                        refined_bboxes = get_box_tensor(refined_bboxes)
+                        refined_rois = torch.cat(
+                            [rois[i][:, [0]], refined_bboxes], dim=1)
+                        refine_rois_list.append(refined_rois)
+                rois = torch.cat(refine_rois_list)
+
+        # average scores of each image by stages
+        cls_scores = [
+            sum([score[i] for score in ms_scores]) / float(len(ms_scores))
+            for i in range(len(batch_img_metas))
+        ]
+        return rois, cls_scores, bbox_preds
+
+    def forward(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
+                batch_data_samples: SampleList) -> tuple:
+        """Network forward process. Usually includes backbone, neck and head
+        forward without any post-processing.
+
+        Args:
+            x (List[Tensor]): Multi-level features that may have different
+                resolutions.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals.
+            batch_data_samples (list[:obj:`DetDataSample`]): Each item contains
+                the meta information of each image and corresponding
+                annotations.
+
+        Returns
+            tuple: A tuple of features from ``bbox_head`` and ``mask_head``
+            forward.
+        """
+        results = ()
+        batch_img_metas = [
+            data_samples.metainfo for data_samples in batch_data_samples
+        ]
+        proposals = [rpn_results.bboxes for rpn_results in rpn_results_list]
+        num_proposals_per_img = tuple(len(p) for p in proposals)
+        rois = bbox2roi(proposals)
+        # bbox head
+        if self.with_bbox:
+            rois, cls_scores, bbox_preds = self._refine_roi(
+                x, rois, batch_img_metas, num_proposals_per_img)
+            results = results + (cls_scores, bbox_preds)
+        # mask head
+        if self.with_mask:
+            aug_masks = []
+            rois = torch.cat(rois)
+            for stage in range(self.num_stages):
+                mask_results = self._mask_forward(stage, x, rois)
+                mask_preds = mask_results['mask_preds']
+                mask_preds = mask_preds.split(num_proposals_per_img, 0)
+                aug_masks.append([m.sigmoid().detach() for m in mask_preds])
+
+            merged_masks = []
+            for i in range(len(batch_img_metas)):
+                aug_mask = [mask[i] for mask in aug_masks]
+                merged_mask = merge_aug_masks(aug_mask, batch_img_metas[i])
+                merged_masks.append(merged_mask)
+            results = results + (merged_masks, )
+        return results
diff --git a/mmdetection/mmdet/models/roi_heads/double_roi_head.py b/mmdetection/mmdet/models/roi_heads/double_roi_head.py
new file mode 100644
index 00000000..f9464ff5
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/double_roi_head.py
@@ -0,0 +1,53 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Tuple
+
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from .standard_roi_head import StandardRoIHead
+
+
+@MODELS.register_module()
+class DoubleHeadRoIHead(StandardRoIHead):
+    """RoI head for `Double Head RCNN `_.
+
+    Args:
+        reg_roi_scale_factor (float): The scale factor to extend the rois
+            used to extract the regression features.
+    """
+
+    def __init__(self, reg_roi_scale_factor: float, **kwargs):
+        super().__init__(**kwargs)
+        self.reg_roi_scale_factor = reg_roi_scale_factor
+
+    def _bbox_forward(self, x: Tuple[Tensor], rois: Tensor) -> dict:
+        """Box head forward function used in both training and testing.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            rois (Tensor): RoIs with the shape (n, 5) where the first
+                column indicates batch id of each RoI.
+
+        Returns:
+             dict[str, Tensor]: Usually returns a dictionary with keys:
+
+                - `cls_score` (Tensor): Classification scores.
+                - `bbox_pred` (Tensor): Box energies / deltas.
+                - `bbox_feats` (Tensor): Extract bbox RoI features.
+        """
+        bbox_cls_feats = self.bbox_roi_extractor(
+            x[:self.bbox_roi_extractor.num_inputs], rois)
+        bbox_reg_feats = self.bbox_roi_extractor(
+            x[:self.bbox_roi_extractor.num_inputs],
+            rois,
+            roi_scale_factor=self.reg_roi_scale_factor)
+        if self.with_shared_head:
+            bbox_cls_feats = self.shared_head(bbox_cls_feats)
+            bbox_reg_feats = self.shared_head(bbox_reg_feats)
+        cls_score, bbox_pred = self.bbox_head(bbox_cls_feats, bbox_reg_feats)
+
+        bbox_results = dict(
+            cls_score=cls_score,
+            bbox_pred=bbox_pred,
+            bbox_feats=bbox_cls_feats)
+        return bbox_results
diff --git a/mmdetection/mmdet/models/roi_heads/dynamic_roi_head.py b/mmdetection/mmdet/models/roi_heads/dynamic_roi_head.py
new file mode 100644
index 00000000..3c7f7bd2
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/dynamic_roi_head.py
@@ -0,0 +1,163 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple
+
+import numpy as np
+import torch
+from torch import Tensor
+
+from mmdet.models.losses import SmoothL1Loss
+from mmdet.models.task_modules.samplers import SamplingResult
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.structures.bbox import bbox2roi
+from mmdet.utils import InstanceList
+from ..utils.misc import unpack_gt_instances
+from .standard_roi_head import StandardRoIHead
+
+EPS = 1e-15
+
+
+@MODELS.register_module()
+class DynamicRoIHead(StandardRoIHead):
+    """RoI head for `Dynamic R-CNN `_."""
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        assert isinstance(self.bbox_head.loss_bbox, SmoothL1Loss)
+        # the IoU history of the past `update_iter_interval` iterations
+        self.iou_history = []
+        # the beta history of the past `update_iter_interval` iterations
+        self.beta_history = []
+
+    def loss(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
+             batch_data_samples: SampleList) -> dict:
+        """Forward function for training.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            dict[str, Tensor]: a dictionary of loss components
+        """
+        assert len(rpn_results_list) == len(batch_data_samples)
+        outputs = unpack_gt_instances(batch_data_samples)
+        batch_gt_instances, batch_gt_instances_ignore, _ = outputs
+
+        # assign gts and sample proposals
+        num_imgs = len(batch_data_samples)
+        sampling_results = []
+        cur_iou = []
+        for i in range(num_imgs):
+            # rename rpn_results.bboxes to rpn_results.priors
+            rpn_results = rpn_results_list[i]
+            rpn_results.priors = rpn_results.pop('bboxes')
+
+            assign_result = self.bbox_assigner.assign(
+                rpn_results, batch_gt_instances[i],
+                batch_gt_instances_ignore[i])
+            sampling_result = self.bbox_sampler.sample(
+                assign_result,
+                rpn_results,
+                batch_gt_instances[i],
+                feats=[lvl_feat[i][None] for lvl_feat in x])
+            # record the `iou_topk`-th largest IoU in an image
+            iou_topk = min(self.train_cfg.dynamic_rcnn.iou_topk,
+                           len(assign_result.max_overlaps))
+            ious, _ = torch.topk(assign_result.max_overlaps, iou_topk)
+            cur_iou.append(ious[-1].item())
+            sampling_results.append(sampling_result)
+        # average the current IoUs over images
+        cur_iou = np.mean(cur_iou)
+        self.iou_history.append(cur_iou)
+
+        losses = dict()
+        # bbox head forward and loss
+        if self.with_bbox:
+            bbox_results = self.bbox_loss(x, sampling_results)
+            losses.update(bbox_results['loss_bbox'])
+
+        # mask head forward and loss
+        if self.with_mask:
+            mask_results = self.mask_loss(x, sampling_results,
+                                          bbox_results['bbox_feats'],
+                                          batch_gt_instances)
+            losses.update(mask_results['loss_mask'])
+
+        # update IoU threshold and SmoothL1 beta
+        update_iter_interval = self.train_cfg.dynamic_rcnn.update_iter_interval
+        if len(self.iou_history) % update_iter_interval == 0:
+            new_iou_thr, new_beta = self.update_hyperparameters()
+
+        return losses
+
+    def bbox_loss(self, x: Tuple[Tensor],
+                  sampling_results: List[SamplingResult]) -> dict:
+        """Perform forward propagation and loss calculation of the bbox head on
+        the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            sampling_results (list["obj:`SamplingResult`]): Sampling results.
+
+        Returns:
+            dict[str, Tensor]: Usually returns a dictionary with keys:
+
+                - `cls_score` (Tensor): Classification scores.
+                - `bbox_pred` (Tensor): Box energies / deltas.
+                - `bbox_feats` (Tensor): Extract bbox RoI features.
+                - `loss_bbox` (dict): A dictionary of bbox loss components.
+        """
+        rois = bbox2roi([res.priors for res in sampling_results])
+        bbox_results = self._bbox_forward(x, rois)
+
+        bbox_loss_and_target = self.bbox_head.loss_and_target(
+            cls_score=bbox_results['cls_score'],
+            bbox_pred=bbox_results['bbox_pred'],
+            rois=rois,
+            sampling_results=sampling_results,
+            rcnn_train_cfg=self.train_cfg)
+        bbox_results.update(loss_bbox=bbox_loss_and_target['loss_bbox'])
+
+        # record the `beta_topk`-th smallest target
+        # `bbox_targets[2]` and `bbox_targets[3]` stand for bbox_targets
+        # and bbox_weights, respectively
+        bbox_targets = bbox_loss_and_target['bbox_targets']
+        pos_inds = bbox_targets[3][:, 0].nonzero().squeeze(1)
+        num_pos = len(pos_inds)
+        num_imgs = len(sampling_results)
+        if num_pos > 0:
+            cur_target = bbox_targets[2][pos_inds, :2].abs().mean(dim=1)
+            beta_topk = min(self.train_cfg.dynamic_rcnn.beta_topk * num_imgs,
+                            num_pos)
+            cur_target = torch.kthvalue(cur_target, beta_topk)[0].item()
+            self.beta_history.append(cur_target)
+
+        return bbox_results
+
+    def update_hyperparameters(self):
+        """Update hyperparameters like IoU thresholds for assigner and beta for
+        SmoothL1 loss based on the training statistics.
+
+        Returns:
+            tuple[float]: the updated ``iou_thr`` and ``beta``.
+        """
+        new_iou_thr = max(self.train_cfg.dynamic_rcnn.initial_iou,
+                          np.mean(self.iou_history))
+        self.iou_history = []
+        self.bbox_assigner.pos_iou_thr = new_iou_thr
+        self.bbox_assigner.neg_iou_thr = new_iou_thr
+        self.bbox_assigner.min_pos_iou = new_iou_thr
+        if (not self.beta_history) or (np.median(self.beta_history) < EPS):
+            # avoid 0 or too small value for new_beta
+            new_beta = self.bbox_head.loss_bbox.beta
+        else:
+            new_beta = min(self.train_cfg.dynamic_rcnn.initial_beta,
+                           np.median(self.beta_history))
+        self.beta_history = []
+        self.bbox_head.loss_bbox.beta = new_beta
+        return new_iou_thr, new_beta
diff --git a/mmdetection/mmdet/models/roi_heads/grid_roi_head.py b/mmdetection/mmdet/models/roi_heads/grid_roi_head.py
new file mode 100644
index 00000000..9eda7f01
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/grid_roi_head.py
@@ -0,0 +1,280 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Tuple
+
+import torch
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.structures.bbox import bbox2roi
+from mmdet.utils import ConfigType, InstanceList
+from ..task_modules.samplers import SamplingResult
+from ..utils.misc import unpack_gt_instances
+from .standard_roi_head import StandardRoIHead
+
+
+@MODELS.register_module()
+class GridRoIHead(StandardRoIHead):
+    """Implementation of `Grid RoI Head `_
+
+    Args:
+        grid_roi_extractor (:obj:`ConfigDict` or dict): Config of
+            roi extractor.
+        grid_head (:obj:`ConfigDict` or dict): Config of grid head
+    """
+
+    def __init__(self, grid_roi_extractor: ConfigType, grid_head: ConfigType,
+                 **kwargs) -> None:
+        assert grid_head is not None
+        super().__init__(**kwargs)
+        if grid_roi_extractor is not None:
+            self.grid_roi_extractor = MODELS.build(grid_roi_extractor)
+            self.share_roi_extractor = False
+        else:
+            self.share_roi_extractor = True
+            self.grid_roi_extractor = self.bbox_roi_extractor
+        self.grid_head = MODELS.build(grid_head)
+
+    def _random_jitter(self,
+                       sampling_results: List[SamplingResult],
+                       batch_img_metas: List[dict],
+                       amplitude: float = 0.15) -> List[SamplingResult]:
+        """Ramdom jitter positive proposals for training.
+
+        Args:
+            sampling_results (List[obj:SamplingResult]): Assign results of
+                all images in a batch after sampling.
+            batch_img_metas (list[dict]): List of image information.
+            amplitude (float): Amplitude of random offset. Defaults to 0.15.
+
+        Returns:
+            list[obj:SamplingResult]: SamplingResults after random jittering.
+        """
+        for sampling_result, img_meta in zip(sampling_results,
+                                             batch_img_metas):
+            bboxes = sampling_result.pos_priors
+            random_offsets = bboxes.new_empty(bboxes.shape[0], 4).uniform_(
+                -amplitude, amplitude)
+            # before jittering
+            cxcy = (bboxes[:, 2:4] + bboxes[:, :2]) / 2
+            wh = (bboxes[:, 2:4] - bboxes[:, :2]).abs()
+            # after jittering
+            new_cxcy = cxcy + wh * random_offsets[:, :2]
+            new_wh = wh * (1 + random_offsets[:, 2:])
+            # xywh to xyxy
+            new_x1y1 = (new_cxcy - new_wh / 2)
+            new_x2y2 = (new_cxcy + new_wh / 2)
+            new_bboxes = torch.cat([new_x1y1, new_x2y2], dim=1)
+            # clip bboxes
+            max_shape = img_meta['img_shape']
+            if max_shape is not None:
+                new_bboxes[:, 0::2].clamp_(min=0, max=max_shape[1] - 1)
+                new_bboxes[:, 1::2].clamp_(min=0, max=max_shape[0] - 1)
+
+            sampling_result.pos_priors = new_bboxes
+        return sampling_results
+
+    # TODO: Forward is incorrect and need to refactor.
+    def forward(self,
+                x: Tuple[Tensor],
+                rpn_results_list: InstanceList,
+                batch_data_samples: SampleList = None) -> tuple:
+        """Network forward process. Usually includes backbone, neck and head
+        forward without any post-processing.
+
+        Args:
+            x (Tuple[Tensor]): Multi-level features that may have different
+                resolutions.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals.
+            batch_data_samples (list[:obj:`DetDataSample`]): Each item contains
+            the meta information of each image and corresponding
+            annotations.
+
+        Returns
+            tuple: A tuple of features from ``bbox_head`` and ``mask_head``
+            forward.
+        """
+        results = ()
+        proposals = [rpn_results.bboxes for rpn_results in rpn_results_list]
+        rois = bbox2roi(proposals)
+        # bbox head
+        if self.with_bbox:
+            bbox_results = self._bbox_forward(x, rois)
+            results = results + (bbox_results['cls_score'], )
+            if self.bbox_head.with_reg:
+                results = results + (bbox_results['bbox_pred'], )
+
+            # grid head
+            grid_rois = rois[:100]
+            grid_feats = self.grid_roi_extractor(
+                x[:len(self.grid_roi_extractor.featmap_strides)], grid_rois)
+            if self.with_shared_head:
+                grid_feats = self.shared_head(grid_feats)
+            self.grid_head.test_mode = True
+            grid_preds = self.grid_head(grid_feats)
+            results = results + (grid_preds, )
+
+        # mask head
+        if self.with_mask:
+            mask_rois = rois[:100]
+            mask_results = self._mask_forward(x, mask_rois)
+            results = results + (mask_results['mask_preds'], )
+        return results
+
+    def loss(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
+             batch_data_samples: SampleList, **kwargs) -> dict:
+        """Perform forward propagation and loss calculation of the detection
+        roi on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components
+        """
+        assert len(rpn_results_list) == len(batch_data_samples)
+        outputs = unpack_gt_instances(batch_data_samples)
+        (batch_gt_instances, batch_gt_instances_ignore,
+         batch_img_metas) = outputs
+
+        # assign gts and sample proposals
+        num_imgs = len(batch_data_samples)
+        sampling_results = []
+        for i in range(num_imgs):
+            # rename rpn_results.bboxes to rpn_results.priors
+            rpn_results = rpn_results_list[i]
+            rpn_results.priors = rpn_results.pop('bboxes')
+
+            assign_result = self.bbox_assigner.assign(
+                rpn_results, batch_gt_instances[i],
+                batch_gt_instances_ignore[i])
+            sampling_result = self.bbox_sampler.sample(
+                assign_result,
+                rpn_results,
+                batch_gt_instances[i],
+                feats=[lvl_feat[i][None] for lvl_feat in x])
+            sampling_results.append(sampling_result)
+
+        losses = dict()
+        # bbox head loss
+        if self.with_bbox:
+            bbox_results = self.bbox_loss(x, sampling_results, batch_img_metas)
+            losses.update(bbox_results['loss_bbox'])
+
+        # mask head forward and loss
+        if self.with_mask:
+            mask_results = self.mask_loss(x, sampling_results,
+                                          bbox_results['bbox_feats'],
+                                          batch_gt_instances)
+            losses.update(mask_results['loss_mask'])
+
+        return losses
+
+    def bbox_loss(self,
+                  x: Tuple[Tensor],
+                  sampling_results: List[SamplingResult],
+                  batch_img_metas: Optional[List[dict]] = None) -> dict:
+        """Perform forward propagation and loss calculation of the bbox head on
+        the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            sampling_results (list[:obj:`SamplingResult`]): Sampling results.
+            batch_img_metas (list[dict], optional): Meta information of each
+                image, e.g., image size, scaling factor, etc.
+
+        Returns:
+            dict[str, Tensor]: Usually returns a dictionary with keys:
+
+            - `cls_score` (Tensor): Classification scores.
+            - `bbox_pred` (Tensor): Box energies / deltas.
+            - `bbox_feats` (Tensor): Extract bbox RoI features.
+            - `loss_bbox` (dict): A dictionary of bbox loss components.
+        """
+        assert batch_img_metas is not None
+        bbox_results = super().bbox_loss(x, sampling_results)
+
+        # Grid head forward and loss
+        sampling_results = self._random_jitter(sampling_results,
+                                               batch_img_metas)
+        pos_rois = bbox2roi([res.pos_bboxes for res in sampling_results])
+
+        # GN in head does not support zero shape input
+        if pos_rois.shape[0] == 0:
+            return bbox_results
+
+        grid_feats = self.grid_roi_extractor(
+            x[:self.grid_roi_extractor.num_inputs], pos_rois)
+        if self.with_shared_head:
+            grid_feats = self.shared_head(grid_feats)
+        # Accelerate training
+        max_sample_num_grid = self.train_cfg.get('max_num_grid', 192)
+        sample_idx = torch.randperm(
+            grid_feats.shape[0])[:min(grid_feats.shape[0], max_sample_num_grid
+                                      )]
+        grid_feats = grid_feats[sample_idx]
+        grid_pred = self.grid_head(grid_feats)
+
+        loss_grid = self.grid_head.loss(grid_pred, sample_idx,
+                                        sampling_results, self.train_cfg)
+
+        bbox_results['loss_bbox'].update(loss_grid)
+        return bbox_results
+
+    def predict_bbox(self,
+                     x: Tuple[Tensor],
+                     batch_img_metas: List[dict],
+                     rpn_results_list: InstanceList,
+                     rcnn_test_cfg: ConfigType,
+                     rescale: bool = False) -> InstanceList:
+        """Perform forward propagation of the bbox head and predict detection
+        results on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Feature maps of all scale level.
+            batch_img_metas (list[dict]): List of image information.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals.
+            rcnn_test_cfg (:obj:`ConfigDict`): `test_cfg` of R-CNN.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+            - scores (Tensor): Classification scores, has a shape \
+            (num_instance, )
+            - labels (Tensor): Labels of bboxes, has a shape (num_instances, ).
+            - bboxes (Tensor): Has a shape (num_instances, 4), the last \
+            dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        results_list = super().predict_bbox(
+            x,
+            batch_img_metas=batch_img_metas,
+            rpn_results_list=rpn_results_list,
+            rcnn_test_cfg=rcnn_test_cfg,
+            rescale=False)
+
+        grid_rois = bbox2roi([res.bboxes for res in results_list])
+        if grid_rois.shape[0] != 0:
+            grid_feats = self.grid_roi_extractor(
+                x[:len(self.grid_roi_extractor.featmap_strides)], grid_rois)
+            if self.with_shared_head:
+                grid_feats = self.shared_head(grid_feats)
+            self.grid_head.test_mode = True
+            grid_preds = self.grid_head(grid_feats)
+            results_list = self.grid_head.predict_by_feat(
+                grid_preds=grid_preds,
+                results_list=results_list,
+                batch_img_metas=batch_img_metas,
+                rescale=rescale)
+
+        return results_list
diff --git a/mmdetection/mmdet/models/roi_heads/htc_roi_head.py b/mmdetection/mmdet/models/roi_heads/htc_roi_head.py
new file mode 100644
index 00000000..0fdd99dd
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/htc_roi_head.py
@@ -0,0 +1,581 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, List, Optional, Tuple
+
+import torch
+import torch.nn.functional as F
+from torch import Tensor
+
+from mmdet.models.test_time_augs import merge_aug_masks
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.structures.bbox import bbox2roi
+from mmdet.utils import InstanceList, OptConfigType
+from ..layers import adaptive_avg_pool2d
+from ..task_modules.samplers import SamplingResult
+from ..utils import empty_instances, unpack_gt_instances
+from .cascade_roi_head import CascadeRoIHead
+
+
+@MODELS.register_module()
+class HybridTaskCascadeRoIHead(CascadeRoIHead):
+    """Hybrid task cascade roi head including one bbox head and one mask head.
+
+    https://arxiv.org/abs/1901.07518
+
+    Args:
+        num_stages (int): Number of cascade stages.
+        stage_loss_weights (list[float]): Loss weight for every stage.
+        semantic_roi_extractor (:obj:`ConfigDict` or dict, optional):
+            Config of semantic roi extractor. Defaults to None.
+        Semantic_head (:obj:`ConfigDict` or dict, optional):
+            Config of semantic head. Defaults to None.
+        interleaved (bool): Whether to interleaves the box branch and mask
+            branch. If True, the mask branch can take the refined bounding
+            box predictions. Defaults to True.
+        mask_info_flow (bool): Whether to turn on the mask information flow,
+            which means that feeding the mask features of the preceding stage
+            to the current stage. Defaults to True.
+    """
+
+    def __init__(self,
+                 num_stages: int,
+                 stage_loss_weights: List[float],
+                 semantic_roi_extractor: OptConfigType = None,
+                 semantic_head: OptConfigType = None,
+                 semantic_fusion: Tuple[str] = ('bbox', 'mask'),
+                 interleaved: bool = True,
+                 mask_info_flow: bool = True,
+                 **kwargs) -> None:
+        super().__init__(
+            num_stages=num_stages,
+            stage_loss_weights=stage_loss_weights,
+            **kwargs)
+        assert self.with_bbox
+        assert not self.with_shared_head  # shared head is not supported
+
+        if semantic_head is not None:
+            self.semantic_roi_extractor = MODELS.build(semantic_roi_extractor)
+            self.semantic_head = MODELS.build(semantic_head)
+
+        self.semantic_fusion = semantic_fusion
+        self.interleaved = interleaved
+        self.mask_info_flow = mask_info_flow
+
+    # TODO move to base_roi_head later
+    @property
+    def with_semantic(self) -> bool:
+        """bool: whether the head has semantic head"""
+        return hasattr(self,
+                       'semantic_head') and self.semantic_head is not None
+
+    def _bbox_forward(
+            self,
+            stage: int,
+            x: Tuple[Tensor],
+            rois: Tensor,
+            semantic_feat: Optional[Tensor] = None) -> Dict[str, Tensor]:
+        """Box head forward function used in both training and testing.
+
+        Args:
+            stage (int): The current stage in Cascade RoI Head.
+            x (tuple[Tensor]): List of multi-level img features.
+            rois (Tensor): RoIs with the shape (n, 5) where the first
+                column indicates batch id of each RoI.
+            semantic_feat (Tensor, optional): Semantic feature. Defaults to
+                None.
+
+        Returns:
+             dict[str, Tensor]: Usually returns a dictionary with keys:
+
+                - `cls_score` (Tensor): Classification scores.
+                - `bbox_pred` (Tensor): Box energies / deltas.
+                - `bbox_feats` (Tensor): Extract bbox RoI features.
+        """
+        bbox_roi_extractor = self.bbox_roi_extractor[stage]
+        bbox_head = self.bbox_head[stage]
+        bbox_feats = bbox_roi_extractor(x[:bbox_roi_extractor.num_inputs],
+                                        rois)
+        if self.with_semantic and 'bbox' in self.semantic_fusion:
+            bbox_semantic_feat = self.semantic_roi_extractor([semantic_feat],
+                                                             rois)
+            if bbox_semantic_feat.shape[-2:] != bbox_feats.shape[-2:]:
+                bbox_semantic_feat = adaptive_avg_pool2d(
+                    bbox_semantic_feat, bbox_feats.shape[-2:])
+            bbox_feats += bbox_semantic_feat
+        cls_score, bbox_pred = bbox_head(bbox_feats)
+
+        bbox_results = dict(cls_score=cls_score, bbox_pred=bbox_pred)
+        return bbox_results
+
+    def bbox_loss(self,
+                  stage: int,
+                  x: Tuple[Tensor],
+                  sampling_results: List[SamplingResult],
+                  semantic_feat: Optional[Tensor] = None) -> dict:
+        """Run forward function and calculate loss for box head in training.
+
+        Args:
+            stage (int): The current stage in Cascade RoI Head.
+            x (tuple[Tensor]): List of multi-level img features.
+            sampling_results (list["obj:`SamplingResult`]): Sampling results.
+            semantic_feat (Tensor, optional): Semantic feature. Defaults to
+                None.
+
+        Returns:
+            dict: Usually returns a dictionary with keys:
+
+                - `cls_score` (Tensor): Classification scores.
+                - `bbox_pred` (Tensor): Box energies / deltas.
+                - `bbox_feats` (Tensor): Extract bbox RoI features.
+                - `loss_bbox` (dict): A dictionary of bbox loss components.
+                - `rois` (Tensor): RoIs with the shape (n, 5) where the first
+                  column indicates batch id of each RoI.
+                - `bbox_targets` (tuple):  Ground truth for proposals in a
+                  single image. Containing the following list of Tensors:
+                  (labels, label_weights, bbox_targets, bbox_weights)
+        """
+        bbox_head = self.bbox_head[stage]
+        rois = bbox2roi([res.priors for res in sampling_results])
+        bbox_results = self._bbox_forward(
+            stage, x, rois, semantic_feat=semantic_feat)
+        bbox_results.update(rois=rois)
+
+        bbox_loss_and_target = bbox_head.loss_and_target(
+            cls_score=bbox_results['cls_score'],
+            bbox_pred=bbox_results['bbox_pred'],
+            rois=rois,
+            sampling_results=sampling_results,
+            rcnn_train_cfg=self.train_cfg[stage])
+        bbox_results.update(bbox_loss_and_target)
+        return bbox_results
+
+    def _mask_forward(self,
+                      stage: int,
+                      x: Tuple[Tensor],
+                      rois: Tensor,
+                      semantic_feat: Optional[Tensor] = None,
+                      training: bool = True) -> Dict[str, Tensor]:
+        """Mask head forward function used only in training.
+
+        Args:
+            stage (int): The current stage in Cascade RoI Head.
+            x (tuple[Tensor]): Tuple of multi-level img features.
+            rois (Tensor): RoIs with the shape (n, 5) where the first
+                column indicates batch id of each RoI.
+            semantic_feat (Tensor, optional): Semantic feature. Defaults to
+                None.
+            training (bool): Mask Forward is different between training and
+                testing. If True, use the mask forward in training.
+                Defaults to True.
+
+        Returns:
+            dict: Usually returns a dictionary with keys:
+
+                - `mask_preds` (Tensor): Mask prediction.
+        """
+        mask_roi_extractor = self.mask_roi_extractor[stage]
+        mask_head = self.mask_head[stage]
+        mask_feats = mask_roi_extractor(x[:mask_roi_extractor.num_inputs],
+                                        rois)
+
+        # semantic feature fusion
+        # element-wise sum for original features and pooled semantic features
+        if self.with_semantic and 'mask' in self.semantic_fusion:
+            mask_semantic_feat = self.semantic_roi_extractor([semantic_feat],
+                                                             rois)
+            if mask_semantic_feat.shape[-2:] != mask_feats.shape[-2:]:
+                mask_semantic_feat = F.adaptive_avg_pool2d(
+                    mask_semantic_feat, mask_feats.shape[-2:])
+            mask_feats = mask_feats + mask_semantic_feat
+
+        # mask information flow
+        # forward all previous mask heads to obtain last_feat, and fuse it
+        # with the normal mask feature
+        if training:
+            if self.mask_info_flow:
+                last_feat = None
+                for i in range(stage):
+                    last_feat = self.mask_head[i](
+                        mask_feats, last_feat, return_logits=False)
+                mask_preds = mask_head(
+                    mask_feats, last_feat, return_feat=False)
+            else:
+                mask_preds = mask_head(mask_feats, return_feat=False)
+
+            mask_results = dict(mask_preds=mask_preds)
+        else:
+            aug_masks = []
+            last_feat = None
+            for i in range(self.num_stages):
+                mask_head = self.mask_head[i]
+                if self.mask_info_flow:
+                    mask_preds, last_feat = mask_head(mask_feats, last_feat)
+                else:
+                    mask_preds = mask_head(mask_feats)
+            aug_masks.append(mask_preds)
+
+            mask_results = dict(mask_preds=aug_masks)
+
+        return mask_results
+
+    def mask_loss(self,
+                  stage: int,
+                  x: Tuple[Tensor],
+                  sampling_results: List[SamplingResult],
+                  batch_gt_instances: InstanceList,
+                  semantic_feat: Optional[Tensor] = None) -> dict:
+        """Run forward function and calculate loss for mask head in training.
+
+        Args:
+            stage (int): The current stage in Cascade RoI Head.
+            x (tuple[Tensor]): Tuple of multi-level img features.
+            sampling_results (list["obj:`SamplingResult`]): Sampling results.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes``, ``labels``, and
+                ``masks`` attributes.
+            semantic_feat (Tensor, optional): Semantic feature. Defaults to
+                None.
+
+        Returns:
+            dict: Usually returns a dictionary with keys:
+
+                - `mask_preds` (Tensor): Mask prediction.
+                - `loss_mask` (dict): A dictionary of mask loss components.
+        """
+        pos_rois = bbox2roi([res.pos_priors for res in sampling_results])
+        mask_results = self._mask_forward(
+            stage=stage,
+            x=x,
+            rois=pos_rois,
+            semantic_feat=semantic_feat,
+            training=True)
+
+        mask_head = self.mask_head[stage]
+        mask_loss_and_target = mask_head.loss_and_target(
+            mask_preds=mask_results['mask_preds'],
+            sampling_results=sampling_results,
+            batch_gt_instances=batch_gt_instances,
+            rcnn_train_cfg=self.train_cfg[stage])
+        mask_results.update(mask_loss_and_target)
+
+        return mask_results
+
+    def loss(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
+             batch_data_samples: SampleList) -> dict:
+        """Perform forward propagation and loss calculation of the detection
+        roi on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components
+        """
+        assert len(rpn_results_list) == len(batch_data_samples)
+        outputs = unpack_gt_instances(batch_data_samples)
+        batch_gt_instances, batch_gt_instances_ignore, batch_img_metas \
+            = outputs
+
+        # semantic segmentation part
+        # 2 outputs: segmentation prediction and embedded features
+        losses = dict()
+        if self.with_semantic:
+            gt_semantic_segs = [
+                data_sample.gt_sem_seg.sem_seg
+                for data_sample in batch_data_samples
+            ]
+            gt_semantic_segs = torch.stack(gt_semantic_segs)
+            semantic_pred, semantic_feat = self.semantic_head(x)
+            loss_seg = self.semantic_head.loss(semantic_pred, gt_semantic_segs)
+            losses['loss_semantic_seg'] = loss_seg
+        else:
+            semantic_feat = None
+
+        results_list = rpn_results_list
+        num_imgs = len(batch_img_metas)
+        for stage in range(self.num_stages):
+            self.current_stage = stage
+
+            stage_loss_weight = self.stage_loss_weights[stage]
+
+            # assign gts and sample proposals
+            sampling_results = []
+            bbox_assigner = self.bbox_assigner[stage]
+            bbox_sampler = self.bbox_sampler[stage]
+            for i in range(num_imgs):
+                results = results_list[i]
+                # rename rpn_results.bboxes to rpn_results.priors
+                if 'bboxes' in results:
+                    results.priors = results.pop('bboxes')
+
+                assign_result = bbox_assigner.assign(
+                    results, batch_gt_instances[i],
+                    batch_gt_instances_ignore[i])
+                sampling_result = bbox_sampler.sample(
+                    assign_result,
+                    results,
+                    batch_gt_instances[i],
+                    feats=[lvl_feat[i][None] for lvl_feat in x])
+                sampling_results.append(sampling_result)
+
+            # bbox head forward and loss
+            bbox_results = self.bbox_loss(
+                stage=stage,
+                x=x,
+                sampling_results=sampling_results,
+                semantic_feat=semantic_feat)
+
+            for name, value in bbox_results['loss_bbox'].items():
+                losses[f's{stage}.{name}'] = (
+                    value * stage_loss_weight if 'loss' in name else value)
+
+            # mask head forward and loss
+            if self.with_mask:
+                # interleaved execution: use regressed bboxes by the box branch
+                # to train the mask branch
+                if self.interleaved:
+                    bbox_head = self.bbox_head[stage]
+                    with torch.no_grad():
+                        results_list = bbox_head.refine_bboxes(
+                            sampling_results, bbox_results, batch_img_metas)
+                        # re-assign and sample 512 RoIs from 512 RoIs
+                        sampling_results = []
+                        for i in range(num_imgs):
+                            results = results_list[i]
+                            # rename rpn_results.bboxes to rpn_results.priors
+                            results.priors = results.pop('bboxes')
+                            assign_result = bbox_assigner.assign(
+                                results, batch_gt_instances[i],
+                                batch_gt_instances_ignore[i])
+                            sampling_result = bbox_sampler.sample(
+                                assign_result,
+                                results,
+                                batch_gt_instances[i],
+                                feats=[lvl_feat[i][None] for lvl_feat in x])
+                            sampling_results.append(sampling_result)
+                mask_results = self.mask_loss(
+                    stage=stage,
+                    x=x,
+                    sampling_results=sampling_results,
+                    batch_gt_instances=batch_gt_instances,
+                    semantic_feat=semantic_feat)
+                for name, value in mask_results['loss_mask'].items():
+                    losses[f's{stage}.{name}'] = (
+                        value * stage_loss_weight if 'loss' in name else value)
+
+            # refine bboxes (same as Cascade R-CNN)
+            if stage < self.num_stages - 1 and not self.interleaved:
+                bbox_head = self.bbox_head[stage]
+                with torch.no_grad():
+                    results_list = bbox_head.refine_bboxes(
+                        sampling_results=sampling_results,
+                        bbox_results=bbox_results,
+                        batch_img_metas=batch_img_metas)
+
+        return losses
+
+    def predict(self,
+                x: Tuple[Tensor],
+                rpn_results_list: InstanceList,
+                batch_data_samples: SampleList,
+                rescale: bool = False) -> InstanceList:
+        """Perform forward propagation of the roi head and predict detection
+        results on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from upstream network. Each
+                has shape (N, C, H, W).
+            rpn_results_list (list[:obj:`InstanceData`]): list of region
+                proposals.
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            rescale (bool): Whether to rescale the results to
+                the original image. Defaults to False.
+
+        Returns:
+            list[obj:`InstanceData`]: Detection results of each image.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                    (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                    (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                    the last dimension 4 arrange as (x1, y1, x2, y2).
+                - masks (Tensor): Has a shape (num_instances, H, W).
+        """
+        assert self.with_bbox, 'Bbox head must be implemented.'
+        batch_img_metas = [
+            data_samples.metainfo for data_samples in batch_data_samples
+        ]
+
+        if self.with_semantic:
+            _, semantic_feat = self.semantic_head(x)
+        else:
+            semantic_feat = None
+
+        # TODO: nms_op in mmcv need be enhanced, the bbox result may get
+        #  difference when not rescale in bbox_head
+
+        # If it has the mask branch, the bbox branch does not need
+        # to be scaled to the original image scale, because the mask
+        # branch will scale both bbox and mask at the same time.
+        bbox_rescale = rescale if not self.with_mask else False
+        results_list = self.predict_bbox(
+            x=x,
+            semantic_feat=semantic_feat,
+            batch_img_metas=batch_img_metas,
+            rpn_results_list=rpn_results_list,
+            rcnn_test_cfg=self.test_cfg,
+            rescale=bbox_rescale)
+
+        if self.with_mask:
+            results_list = self.predict_mask(
+                x=x,
+                semantic_heat=semantic_feat,
+                batch_img_metas=batch_img_metas,
+                results_list=results_list,
+                rescale=rescale)
+
+        return results_list
+
+    def predict_mask(self,
+                     x: Tuple[Tensor],
+                     semantic_heat: Tensor,
+                     batch_img_metas: List[dict],
+                     results_list: InstanceList,
+                     rescale: bool = False) -> InstanceList:
+        """Perform forward propagation of the mask head and predict detection
+        results on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Feature maps of all scale level.
+            semantic_feat (Tensor): Semantic feature.
+            batch_img_metas (list[dict]): List of image information.
+            results_list (list[:obj:`InstanceData`]): Detection results of
+                each image.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+                - masks (Tensor): Has a shape (num_instances, H, W).
+        """
+        num_imgs = len(batch_img_metas)
+        bboxes = [res.bboxes for res in results_list]
+        mask_rois = bbox2roi(bboxes)
+        if mask_rois.shape[0] == 0:
+            results_list = empty_instances(
+                batch_img_metas=batch_img_metas,
+                device=mask_rois.device,
+                task_type='mask',
+                instance_results=results_list,
+                mask_thr_binary=self.test_cfg.mask_thr_binary)
+            return results_list
+
+        num_mask_rois_per_img = [len(res) for res in results_list]
+        mask_results = self._mask_forward(
+            stage=-1,
+            x=x,
+            rois=mask_rois,
+            semantic_feat=semantic_heat,
+            training=False)
+        # split batch mask prediction back to each image
+        aug_masks = [[
+            mask.sigmoid().detach()
+            for mask in mask_preds.split(num_mask_rois_per_img, 0)
+        ] for mask_preds in mask_results['mask_preds']]
+
+        merged_masks = []
+        for i in range(num_imgs):
+            aug_mask = [mask[i] for mask in aug_masks]
+            merged_mask = merge_aug_masks(aug_mask, batch_img_metas[i])
+            merged_masks.append(merged_mask)
+
+        results_list = self.mask_head[-1].predict_by_feat(
+            mask_preds=merged_masks,
+            results_list=results_list,
+            batch_img_metas=batch_img_metas,
+            rcnn_test_cfg=self.test_cfg,
+            rescale=rescale,
+            activate_map=True)
+
+        return results_list
+
+    def forward(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
+                batch_data_samples: SampleList) -> tuple:
+        """Network forward process. Usually includes backbone, neck and head
+        forward without any post-processing.
+
+        Args:
+            x (List[Tensor]): Multi-level features that may have different
+                resolutions.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals.
+            batch_data_samples (list[:obj:`DetDataSample`]): Each item contains
+                the meta information of each image and corresponding
+                annotations.
+
+        Returns
+            tuple: A tuple of features from ``bbox_head`` and ``mask_head``
+            forward.
+        """
+        results = ()
+        batch_img_metas = [
+            data_samples.metainfo for data_samples in batch_data_samples
+        ]
+        num_imgs = len(batch_img_metas)
+
+        if self.with_semantic:
+            _, semantic_feat = self.semantic_head(x)
+        else:
+            semantic_feat = None
+
+        proposals = [rpn_results.bboxes for rpn_results in rpn_results_list]
+        num_proposals_per_img = tuple(len(p) for p in proposals)
+        rois = bbox2roi(proposals)
+        # bbox head
+        if self.with_bbox:
+            rois, cls_scores, bbox_preds = self._refine_roi(
+                x=x,
+                rois=rois,
+                semantic_feat=semantic_feat,
+                batch_img_metas=batch_img_metas,
+                num_proposals_per_img=num_proposals_per_img)
+            results = results + (cls_scores, bbox_preds)
+        # mask head
+        if self.with_mask:
+            rois = torch.cat(rois)
+            mask_results = self._mask_forward(
+                stage=-1,
+                x=x,
+                rois=rois,
+                semantic_feat=semantic_feat,
+                training=False)
+            aug_masks = [[
+                mask.sigmoid().detach()
+                for mask in mask_preds.split(num_proposals_per_img, 0)
+            ] for mask_preds in mask_results['mask_preds']]
+
+            merged_masks = []
+            for i in range(num_imgs):
+                aug_mask = [mask[i] for mask in aug_masks]
+                merged_mask = merge_aug_masks(aug_mask, batch_img_metas[i])
+                merged_masks.append(merged_mask)
+            results = results + (merged_masks, )
+        return results
diff --git a/mmdetection/mmdet/models/roi_heads/mask_heads/__init__.py b/mmdetection/mmdet/models/roi_heads/mask_heads/__init__.py
new file mode 100644
index 00000000..48a5d422
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/mask_heads/__init__.py
@@ -0,0 +1,20 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .coarse_mask_head import CoarseMaskHead
+from .dynamic_mask_head import DynamicMaskHead
+from .fcn_mask_head import FCNMaskHead
+from .feature_relay_head import FeatureRelayHead
+from .fused_semantic_head import FusedSemanticHead
+from .global_context_head import GlobalContextHead
+from .grid_head import GridHead
+from .htc_mask_head import HTCMaskHead
+from .mask_point_head import MaskPointHead
+from .maskiou_head import MaskIoUHead
+from .scnet_mask_head import SCNetMaskHead
+from .scnet_semantic_head import SCNetSemanticHead
+
+__all__ = [
+    'FCNMaskHead', 'HTCMaskHead', 'FusedSemanticHead', 'GridHead',
+    'MaskIoUHead', 'CoarseMaskHead', 'MaskPointHead', 'SCNetMaskHead',
+    'SCNetSemanticHead', 'GlobalContextHead', 'FeatureRelayHead',
+    'DynamicMaskHead'
+]
diff --git a/mmdetection/mmdet/models/roi_heads/mask_heads/coarse_mask_head.py b/mmdetection/mmdet/models/roi_heads/mask_heads/coarse_mask_head.py
new file mode 100644
index 00000000..1caa9012
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/mask_heads/coarse_mask_head.py
@@ -0,0 +1,110 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmcv.cnn import ConvModule, Linear
+from mmengine.model import ModuleList
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import MultiConfig
+from .fcn_mask_head import FCNMaskHead
+
+
+@MODELS.register_module()
+class CoarseMaskHead(FCNMaskHead):
+    """Coarse mask head used in PointRend.
+
+    Compared with standard ``FCNMaskHead``, ``CoarseMaskHead`` will downsample
+    the input feature map instead of upsample it.
+
+    Args:
+        num_convs (int): Number of conv layers in the head. Defaults to 0.
+        num_fcs (int): Number of fc layers in the head. Defaults to 2.
+        fc_out_channels (int): Number of output channels of fc layer.
+            Defaults to 1024.
+        downsample_factor (int): The factor that feature map is downsampled by.
+            Defaults to 2.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+    """
+
+    def __init__(self,
+                 num_convs: int = 0,
+                 num_fcs: int = 2,
+                 fc_out_channels: int = 1024,
+                 downsample_factor: int = 2,
+                 init_cfg: MultiConfig = dict(
+                     type='Xavier',
+                     override=[
+                         dict(name='fcs'),
+                         dict(type='Constant', val=0.001, name='fc_logits')
+                     ]),
+                 *arg,
+                 **kwarg) -> None:
+        super().__init__(
+            *arg,
+            num_convs=num_convs,
+            upsample_cfg=dict(type=None),
+            init_cfg=None,
+            **kwarg)
+        self.init_cfg = init_cfg
+        self.num_fcs = num_fcs
+        assert self.num_fcs > 0
+        self.fc_out_channels = fc_out_channels
+        self.downsample_factor = downsample_factor
+        assert self.downsample_factor >= 1
+        # remove conv_logit
+        delattr(self, 'conv_logits')
+
+        if downsample_factor > 1:
+            downsample_in_channels = (
+                self.conv_out_channels
+                if self.num_convs > 0 else self.in_channels)
+            self.downsample_conv = ConvModule(
+                downsample_in_channels,
+                self.conv_out_channels,
+                kernel_size=downsample_factor,
+                stride=downsample_factor,
+                padding=0,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg)
+        else:
+            self.downsample_conv = None
+
+        self.output_size = (self.roi_feat_size[0] // downsample_factor,
+                            self.roi_feat_size[1] // downsample_factor)
+        self.output_area = self.output_size[0] * self.output_size[1]
+
+        last_layer_dim = self.conv_out_channels * self.output_area
+
+        self.fcs = ModuleList()
+        for i in range(num_fcs):
+            fc_in_channels = (
+                last_layer_dim if i == 0 else self.fc_out_channels)
+            self.fcs.append(Linear(fc_in_channels, self.fc_out_channels))
+        last_layer_dim = self.fc_out_channels
+        output_channels = self.num_classes * self.output_area
+        self.fc_logits = Linear(last_layer_dim, output_channels)
+
+    def init_weights(self) -> None:
+        """Initialize weights."""
+        super(FCNMaskHead, self).init_weights()
+
+    def forward(self, x: Tensor) -> Tensor:
+        """Forward features from the upstream network.
+
+        Args:
+            x (Tensor): Extract mask RoI features.
+
+        Returns:
+            Tensor: Predicted foreground masks.
+        """
+        for conv in self.convs:
+            x = conv(x)
+
+        if self.downsample_conv is not None:
+            x = self.downsample_conv(x)
+
+        x = x.flatten(1)
+        for fc in self.fcs:
+            x = self.relu(fc(x))
+        mask_preds = self.fc_logits(x).view(
+            x.size(0), self.num_classes, *self.output_size)
+        return mask_preds
diff --git a/mmdetection/mmdet/models/roi_heads/mask_heads/dynamic_mask_head.py b/mmdetection/mmdet/models/roi_heads/mask_heads/dynamic_mask_head.py
new file mode 100644
index 00000000..f33612b1
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/mask_heads/dynamic_mask_head.py
@@ -0,0 +1,166 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List
+
+import torch
+import torch.nn as nn
+from mmengine.config import ConfigDict
+from torch import Tensor
+
+from mmdet.models.task_modules import SamplingResult
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, InstanceList, OptConfigType, reduce_mean
+from .fcn_mask_head import FCNMaskHead
+
+
+@MODELS.register_module()
+class DynamicMaskHead(FCNMaskHead):
+    r"""Dynamic Mask Head for
+    `Instances as Queries `_
+
+    Args:
+        num_convs (int): Number of convolution layer.
+            Defaults to 4.
+        roi_feat_size (int): The output size of RoI extractor,
+            Defaults to 14.
+        in_channels (int): Input feature channels.
+            Defaults to 256.
+        conv_kernel_size (int): Kernel size of convolution layers.
+            Defaults to 3.
+        conv_out_channels (int): Output channels of convolution layers.
+            Defaults to 256.
+        num_classes (int): Number of classes.
+            Defaults to 80
+        class_agnostic (int): Whether generate class agnostic prediction.
+            Defaults to False.
+        dropout (float): Probability of drop the channel.
+            Defaults to 0.0
+        upsample_cfg (:obj:`ConfigDict` or dict): The config for
+            upsample layer.
+        conv_cfg (:obj:`ConfigDict` or dict, optional): The convolution
+            layer config.
+        norm_cfg (:obj:`ConfigDict` or dict, optional): The norm layer config.
+        dynamic_conv_cfg (:obj:`ConfigDict` or dict): The dynamic convolution
+            layer config.
+        loss_mask (:obj:`ConfigDict` or dict): The config for mask loss.
+    """
+
+    def __init__(self,
+                 num_convs: int = 4,
+                 roi_feat_size: int = 14,
+                 in_channels: int = 256,
+                 conv_kernel_size: int = 3,
+                 conv_out_channels: int = 256,
+                 num_classes: int = 80,
+                 class_agnostic: bool = False,
+                 upsample_cfg: ConfigType = dict(
+                     type='deconv', scale_factor=2),
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: OptConfigType = None,
+                 dynamic_conv_cfg: ConfigType = dict(
+                     type='DynamicConv',
+                     in_channels=256,
+                     feat_channels=64,
+                     out_channels=256,
+                     input_feat_shape=14,
+                     with_proj=False,
+                     act_cfg=dict(type='ReLU', inplace=True),
+                     norm_cfg=dict(type='LN')),
+                 loss_mask: ConfigType = dict(
+                     type='DiceLoss', loss_weight=8.0),
+                 **kwargs) -> None:
+        super().__init__(
+            num_convs=num_convs,
+            roi_feat_size=roi_feat_size,
+            in_channels=in_channels,
+            conv_kernel_size=conv_kernel_size,
+            conv_out_channels=conv_out_channels,
+            num_classes=num_classes,
+            class_agnostic=class_agnostic,
+            upsample_cfg=upsample_cfg,
+            conv_cfg=conv_cfg,
+            norm_cfg=norm_cfg,
+            loss_mask=loss_mask,
+            **kwargs)
+        assert class_agnostic is False, \
+            'DynamicMaskHead only support class_agnostic=False'
+        self.fp16_enabled = False
+
+        self.instance_interactive_conv = MODELS.build(dynamic_conv_cfg)
+
+    def init_weights(self) -> None:
+        """Use xavier initialization for all weight parameter and set
+        classification head bias as a specific value when use focal loss."""
+        for p in self.parameters():
+            if p.dim() > 1:
+                nn.init.xavier_uniform_(p)
+            nn.init.constant_(self.conv_logits.bias, 0.)
+
+    def forward(self, roi_feat: Tensor, proposal_feat: Tensor) -> Tensor:
+        """Forward function of DynamicMaskHead.
+
+        Args:
+            roi_feat (Tensor): Roi-pooling features with shape
+                (batch_size*num_proposals, feature_dimensions,
+                pooling_h , pooling_w).
+            proposal_feat (Tensor): Intermediate feature get from
+                diihead in last stage, has shape
+                (batch_size*num_proposals, feature_dimensions)
+
+          Returns:
+            mask_preds (Tensor): Predicted foreground masks with shape
+            (batch_size*num_proposals, num_classes, pooling_h*2, pooling_w*2).
+        """
+
+        proposal_feat = proposal_feat.reshape(-1, self.in_channels)
+        proposal_feat_iic = self.instance_interactive_conv(
+            proposal_feat, roi_feat)
+
+        x = proposal_feat_iic.permute(0, 2, 1).reshape(roi_feat.size())
+
+        for conv in self.convs:
+            x = conv(x)
+        if self.upsample is not None:
+            x = self.upsample(x)
+            if self.upsample_method == 'deconv':
+                x = self.relu(x)
+        mask_preds = self.conv_logits(x)
+        return mask_preds
+
+    def loss_and_target(self, mask_preds: Tensor,
+                        sampling_results: List[SamplingResult],
+                        batch_gt_instances: InstanceList,
+                        rcnn_train_cfg: ConfigDict) -> dict:
+        """Calculate the loss based on the features extracted by the mask head.
+
+        Args:
+            mask_preds (Tensor): Predicted foreground masks, has shape
+                (num_pos, num_classes, h, w).
+            sampling_results (List[obj:SamplingResult]): Assign results of
+                all images in a batch after sampling.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes``, ``labels``, and
+                ``masks`` attributes.
+            rcnn_train_cfg (obj:ConfigDict): `train_cfg` of RCNN.
+
+        Returns:
+            dict: A dictionary of loss and targets components.
+        """
+        mask_targets = self.get_targets(
+            sampling_results=sampling_results,
+            batch_gt_instances=batch_gt_instances,
+            rcnn_train_cfg=rcnn_train_cfg)
+        pos_labels = torch.cat([res.pos_gt_labels for res in sampling_results])
+
+        num_pos = pos_labels.new_ones(pos_labels.size()).float().sum()
+        avg_factor = torch.clamp(reduce_mean(num_pos), min=1.).item()
+        loss = dict()
+        if mask_preds.size(0) == 0:
+            loss_mask = mask_preds.sum()
+        else:
+            loss_mask = self.loss_mask(
+                mask_preds[torch.arange(num_pos).long(), pos_labels,
+                           ...].sigmoid(),
+                mask_targets,
+                avg_factor=avg_factor)
+        loss['loss_mask'] = loss_mask
+        return dict(loss_mask=loss, mask_targets=mask_targets)
diff --git a/mmdetection/mmdet/models/roi_heads/mask_heads/fcn_mask_head.py b/mmdetection/mmdet/models/roi_heads/mask_heads/fcn_mask_head.py
new file mode 100644
index 00000000..3a089dfa
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/mask_heads/fcn_mask_head.py
@@ -0,0 +1,474 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule, build_conv_layer, build_upsample_layer
+from mmcv.ops.carafe import CARAFEPack
+from mmengine.config import ConfigDict
+from mmengine.model import BaseModule, ModuleList
+from mmengine.structures import InstanceData
+from torch import Tensor
+from torch.nn.modules.utils import _pair
+
+from mmdet.models.task_modules.samplers import SamplingResult
+from mmdet.models.utils import empty_instances
+from mmdet.registry import MODELS
+from mmdet.structures.mask import mask_target
+from mmdet.utils import ConfigType, InstanceList, OptConfigType, OptMultiConfig
+
+BYTES_PER_FLOAT = 4
+# TODO: This memory limit may be too much or too little. It would be better to
+#  determine it based on available resources.
+GPU_MEM_LIMIT = 1024**3  # 1 GB memory limit
+
+
+@MODELS.register_module()
+class FCNMaskHead(BaseModule):
+
+    def __init__(self,
+                 num_convs: int = 4,
+                 roi_feat_size: int = 14,
+                 in_channels: int = 256,
+                 conv_kernel_size: int = 3,
+                 conv_out_channels: int = 256,
+                 num_classes: int = 80,
+                 class_agnostic: int = False,
+                 upsample_cfg: ConfigType = dict(
+                     type='deconv', scale_factor=2),
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: OptConfigType = None,
+                 predictor_cfg: ConfigType = dict(type='Conv'),
+                 loss_mask: ConfigType = dict(
+                     type='CrossEntropyLoss', use_mask=True, loss_weight=1.0),
+                 init_cfg: OptMultiConfig = None) -> None:
+        assert init_cfg is None, 'To prevent abnormal initialization ' \
+                                 'behavior, init_cfg is not allowed to be set'
+        super().__init__(init_cfg=init_cfg)
+        self.upsample_cfg = upsample_cfg.copy()
+        if self.upsample_cfg['type'] not in [
+                None, 'deconv', 'nearest', 'bilinear', 'carafe'
+        ]:
+            raise ValueError(
+                f'Invalid upsample method {self.upsample_cfg["type"]}, '
+                'accepted methods are "deconv", "nearest", "bilinear", '
+                '"carafe"')
+        self.num_convs = num_convs
+        # WARN: roi_feat_size is reserved and not used
+        self.roi_feat_size = _pair(roi_feat_size)
+        self.in_channels = in_channels
+        self.conv_kernel_size = conv_kernel_size
+        self.conv_out_channels = conv_out_channels
+        self.upsample_method = self.upsample_cfg.get('type')
+        self.scale_factor = self.upsample_cfg.pop('scale_factor', None)
+        self.num_classes = num_classes
+        self.class_agnostic = class_agnostic
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.predictor_cfg = predictor_cfg
+        self.loss_mask = MODELS.build(loss_mask)
+
+        self.convs = ModuleList()
+        for i in range(self.num_convs):
+            in_channels = (
+                self.in_channels if i == 0 else self.conv_out_channels)
+            padding = (self.conv_kernel_size - 1) // 2
+            self.convs.append(
+                ConvModule(
+                    in_channels,
+                    self.conv_out_channels,
+                    self.conv_kernel_size,
+                    padding=padding,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg))
+        upsample_in_channels = (
+            self.conv_out_channels if self.num_convs > 0 else in_channels)
+        upsample_cfg_ = self.upsample_cfg.copy()
+        if self.upsample_method is None:
+            self.upsample = None
+        elif self.upsample_method == 'deconv':
+            upsample_cfg_.update(
+                in_channels=upsample_in_channels,
+                out_channels=self.conv_out_channels,
+                kernel_size=self.scale_factor,
+                stride=self.scale_factor)
+            self.upsample = build_upsample_layer(upsample_cfg_)
+        elif self.upsample_method == 'carafe':
+            upsample_cfg_.update(
+                channels=upsample_in_channels, scale_factor=self.scale_factor)
+            self.upsample = build_upsample_layer(upsample_cfg_)
+        else:
+            # suppress warnings
+            align_corners = (None
+                             if self.upsample_method == 'nearest' else False)
+            upsample_cfg_.update(
+                scale_factor=self.scale_factor,
+                mode=self.upsample_method,
+                align_corners=align_corners)
+            self.upsample = build_upsample_layer(upsample_cfg_)
+
+        out_channels = 1 if self.class_agnostic else self.num_classes
+        logits_in_channel = (
+            self.conv_out_channels
+            if self.upsample_method == 'deconv' else upsample_in_channels)
+        self.conv_logits = build_conv_layer(self.predictor_cfg,
+                                            logits_in_channel, out_channels, 1)
+        self.relu = nn.ReLU(inplace=True)
+        self.debug_imgs = None
+
+    def init_weights(self) -> None:
+        """Initialize the weights."""
+        super().init_weights()
+        for m in [self.upsample, self.conv_logits]:
+            if m is None:
+                continue
+            elif isinstance(m, CARAFEPack):
+                m.init_weights()
+            elif hasattr(m, 'weight') and hasattr(m, 'bias'):
+                nn.init.kaiming_normal_(
+                    m.weight, mode='fan_out', nonlinearity='relu')
+                nn.init.constant_(m.bias, 0)
+
+    def forward(self, x: Tensor) -> Tensor:
+        """Forward features from the upstream network.
+
+        Args:
+            x (Tensor): Extract mask RoI features.
+
+        Returns:
+            Tensor: Predicted foreground masks.
+        """
+        for conv in self.convs:
+            x = conv(x)
+        if self.upsample is not None:
+            x = self.upsample(x)
+            if self.upsample_method == 'deconv':
+                x = self.relu(x)
+        mask_preds = self.conv_logits(x)
+        return mask_preds
+
+    def get_targets(self, sampling_results: List[SamplingResult],
+                    batch_gt_instances: InstanceList,
+                    rcnn_train_cfg: ConfigDict) -> Tensor:
+        """Calculate the ground truth for all samples in a batch according to
+        the sampling_results.
+
+        Args:
+            sampling_results (List[obj:SamplingResult]): Assign results of
+                all images in a batch after sampling.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes``, ``labels``, and
+                ``masks`` attributes.
+            rcnn_train_cfg (obj:ConfigDict): `train_cfg` of RCNN.
+
+        Returns:
+            Tensor: Mask target of each positive proposals in the image.
+        """
+        pos_proposals = [res.pos_priors for res in sampling_results]
+        pos_assigned_gt_inds = [
+            res.pos_assigned_gt_inds for res in sampling_results
+        ]
+        gt_masks = [res.masks for res in batch_gt_instances]
+        mask_targets = mask_target(pos_proposals, pos_assigned_gt_inds,
+                                   gt_masks, rcnn_train_cfg)
+        return mask_targets
+
+    def loss_and_target(self, mask_preds: Tensor,
+                        sampling_results: List[SamplingResult],
+                        batch_gt_instances: InstanceList,
+                        rcnn_train_cfg: ConfigDict) -> dict:
+        """Calculate the loss based on the features extracted by the mask head.
+
+        Args:
+            mask_preds (Tensor): Predicted foreground masks, has shape
+                (num_pos, num_classes, h, w).
+            sampling_results (List[obj:SamplingResult]): Assign results of
+                all images in a batch after sampling.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes``, ``labels``, and
+                ``masks`` attributes.
+            rcnn_train_cfg (obj:ConfigDict): `train_cfg` of RCNN.
+
+        Returns:
+            dict: A dictionary of loss and targets components.
+        """
+        mask_targets = self.get_targets(
+            sampling_results=sampling_results,
+            batch_gt_instances=batch_gt_instances,
+            rcnn_train_cfg=rcnn_train_cfg)
+
+        pos_labels = torch.cat([res.pos_gt_labels for res in sampling_results])
+
+        loss = dict()
+        if mask_preds.size(0) == 0:
+            loss_mask = mask_preds.sum()
+        else:
+            if self.class_agnostic:
+                loss_mask = self.loss_mask(mask_preds, mask_targets,
+                                           torch.zeros_like(pos_labels))
+            else:
+                loss_mask = self.loss_mask(mask_preds, mask_targets,
+                                           pos_labels)
+        loss['loss_mask'] = loss_mask
+        # TODO: which algorithm requires mask_targets?
+        return dict(loss_mask=loss, mask_targets=mask_targets)
+
+    def predict_by_feat(self,
+                        mask_preds: Tuple[Tensor],
+                        results_list: List[InstanceData],
+                        batch_img_metas: List[dict],
+                        rcnn_test_cfg: ConfigDict,
+                        rescale: bool = False,
+                        activate_map: bool = False) -> InstanceList:
+        """Transform a batch of output features extracted from the head into
+        mask results.
+
+        Args:
+            mask_preds (tuple[Tensor]): Tuple of predicted foreground masks,
+                each has shape (n, num_classes, h, w).
+            results_list (list[:obj:`InstanceData`]): Detection results of
+                each image.
+            batch_img_metas (list[dict]): List of image information.
+            rcnn_test_cfg (obj:`ConfigDict`): `test_cfg` of Bbox Head.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            activate_map (book): Whether get results with augmentations test.
+                If True, the `mask_preds` will not process with sigmoid.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Detection results of each image
+            after the post process. Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+                - masks (Tensor): Has a shape (num_instances, H, W).
+        """
+        assert len(mask_preds) == len(results_list) == len(batch_img_metas)
+
+        for img_id in range(len(batch_img_metas)):
+            img_meta = batch_img_metas[img_id]
+            results = results_list[img_id]
+            bboxes = results.bboxes
+            if bboxes.shape[0] == 0:
+                results_list[img_id] = empty_instances(
+                    [img_meta],
+                    bboxes.device,
+                    task_type='mask',
+                    instance_results=[results],
+                    mask_thr_binary=rcnn_test_cfg.mask_thr_binary)[0]
+            else:
+                im_mask = self._predict_by_feat_single(
+                    mask_preds=mask_preds[img_id],
+                    bboxes=bboxes,
+                    labels=results.labels,
+                    img_meta=img_meta,
+                    rcnn_test_cfg=rcnn_test_cfg,
+                    rescale=rescale,
+                    activate_map=activate_map)
+                results.masks = im_mask
+        return results_list
+
+    def _predict_by_feat_single(self,
+                                mask_preds: Tensor,
+                                bboxes: Tensor,
+                                labels: Tensor,
+                                img_meta: dict,
+                                rcnn_test_cfg: ConfigDict,
+                                rescale: bool = False,
+                                activate_map: bool = False) -> Tensor:
+        """Get segmentation masks from mask_preds and bboxes.
+
+        Args:
+            mask_preds (Tensor): Predicted foreground masks, has shape
+                (n, num_classes, h, w).
+            bboxes (Tensor): Predicted bboxes, has shape (n, 4)
+            labels (Tensor): Labels of bboxes, has shape (n, )
+            img_meta (dict): image information.
+            rcnn_test_cfg (obj:`ConfigDict`): `test_cfg` of Bbox Head.
+                Defaults to None.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            activate_map (book): Whether get results with augmentations test.
+                If True, the `mask_preds` will not process with sigmoid.
+                Defaults to False.
+
+        Returns:
+            Tensor: Encoded masks, has shape (n, img_w, img_h)
+
+        Example:
+            >>> from mmengine.config import Config
+            >>> from mmdet.models.roi_heads.mask_heads.fcn_mask_head import *  # NOQA
+            >>> N = 7  # N = number of extracted ROIs
+            >>> C, H, W = 11, 32, 32
+            >>> # Create example instance of FCN Mask Head.
+            >>> self = FCNMaskHead(num_classes=C, num_convs=0)
+            >>> inputs = torch.rand(N, self.in_channels, H, W)
+            >>> mask_preds = self.forward(inputs)
+            >>> # Each input is associated with some bounding box
+            >>> bboxes = torch.Tensor([[1, 1, 42, 42 ]] * N)
+            >>> labels = torch.randint(0, C, size=(N,))
+            >>> rcnn_test_cfg = Config({'mask_thr_binary': 0, })
+            >>> ori_shape = (H * 4, W * 4)
+            >>> scale_factor = (1, 1)
+            >>> rescale = False
+            >>> img_meta = {'scale_factor': scale_factor,
+            ...             'ori_shape': ori_shape}
+            >>> # Encoded masks are a list for each category.
+            >>> encoded_masks = self._get_seg_masks_single(
+            ...     mask_preds, bboxes, labels,
+            ...     img_meta, rcnn_test_cfg, rescale)
+            >>> assert encoded_masks.size()[0] == N
+            >>> assert encoded_masks.size()[1:] == ori_shape
+        """
+        scale_factor = bboxes.new_tensor(img_meta['scale_factor']).repeat(
+            (1, 2))
+        img_h, img_w = img_meta['ori_shape'][:2]
+        device = bboxes.device
+
+        if not activate_map:
+            mask_preds = mask_preds.sigmoid()
+        else:
+            # In AugTest, has been activated before
+            mask_preds = bboxes.new_tensor(mask_preds)
+
+        if rescale:  # in-placed rescale the bboxes
+            bboxes /= scale_factor
+        else:
+            w_scale, h_scale = scale_factor[0, 0], scale_factor[0, 1]
+            img_h = np.round(img_h * h_scale.item()).astype(np.int32)
+            img_w = np.round(img_w * w_scale.item()).astype(np.int32)
+
+        N = len(mask_preds)
+        # The actual implementation split the input into chunks,
+        # and paste them chunk by chunk.
+        if device.type == 'cpu':
+            # CPU is most efficient when they are pasted one by one with
+            # skip_empty=True, so that it performs minimal number of
+            # operations.
+            num_chunks = N
+        else:
+            # GPU benefits from parallelism for larger chunks,
+            # but may have memory issue
+            # the types of img_w and img_h are np.int32,
+            # when the image resolution is large,
+            # the calculation of num_chunks will overflow.
+            # so we need to change the types of img_w and img_h to int.
+            # See https://github.com/open-mmlab/mmdetection/pull/5191
+            num_chunks = int(
+                np.ceil(N * int(img_h) * int(img_w) * BYTES_PER_FLOAT /
+                        GPU_MEM_LIMIT))
+            assert (num_chunks <=
+                    N), 'Default GPU_MEM_LIMIT is too small; try increasing it'
+        chunks = torch.chunk(torch.arange(N, device=device), num_chunks)
+
+        threshold = rcnn_test_cfg.mask_thr_binary
+        im_mask = torch.zeros(
+            N,
+            img_h,
+            img_w,
+            device=device,
+            dtype=torch.bool if threshold >= 0 else torch.uint8)
+
+        if not self.class_agnostic:
+            mask_preds = mask_preds[range(N), labels][:, None]
+
+        for inds in chunks:
+            masks_chunk, spatial_inds = _do_paste_mask(
+                mask_preds[inds],
+                bboxes[inds],
+                img_h,
+                img_w,
+                skip_empty=device.type == 'cpu')
+
+            if threshold >= 0:
+                masks_chunk = (masks_chunk >= threshold).to(dtype=torch.bool)
+            else:
+                # for visualization and debugging
+                masks_chunk = (masks_chunk * 255).to(dtype=torch.uint8)
+
+            im_mask[(inds, ) + spatial_inds] = masks_chunk
+        return im_mask
+
+
+def _do_paste_mask(masks: Tensor,
+                   boxes: Tensor,
+                   img_h: int,
+                   img_w: int,
+                   skip_empty: bool = True) -> tuple:
+    """Paste instance masks according to boxes.
+
+    This implementation is modified from
+    https://github.com/facebookresearch/detectron2/
+
+    Args:
+        masks (Tensor): N, 1, H, W
+        boxes (Tensor): N, 4
+        img_h (int): Height of the image to be pasted.
+        img_w (int): Width of the image to be pasted.
+        skip_empty (bool): Only paste masks within the region that
+            tightly bound all boxes, and returns the results this region only.
+            An important optimization for CPU.
+
+    Returns:
+        tuple: (Tensor, tuple). The first item is mask tensor, the second one
+        is the slice object.
+
+            If skip_empty == False, the whole image will be pasted. It will
+            return a mask of shape (N, img_h, img_w) and an empty tuple.
+
+            If skip_empty == True, only area around the mask will be pasted.
+            A mask of shape (N, h', w') and its start and end coordinates
+            in the original image will be returned.
+    """
+    # On GPU, paste all masks together (up to chunk size)
+    # by using the entire image to sample the masks
+    # Compared to pasting them one by one,
+    # this has more operations but is faster on COCO-scale dataset.
+    device = masks.device
+    if skip_empty:
+        x0_int, y0_int = torch.clamp(
+            boxes.min(dim=0).values.floor()[:2] - 1,
+            min=0).to(dtype=torch.int32)
+        x1_int = torch.clamp(
+            boxes[:, 2].max().ceil() + 1, max=img_w).to(dtype=torch.int32)
+        y1_int = torch.clamp(
+            boxes[:, 3].max().ceil() + 1, max=img_h).to(dtype=torch.int32)
+    else:
+        x0_int, y0_int = 0, 0
+        x1_int, y1_int = img_w, img_h
+    x0, y0, x1, y1 = torch.split(boxes, 1, dim=1)  # each is Nx1
+
+    N = masks.shape[0]
+
+    img_y = torch.arange(y0_int, y1_int, device=device).to(torch.float32) + 0.5
+    img_x = torch.arange(x0_int, x1_int, device=device).to(torch.float32) + 0.5
+    img_y = (img_y - y0) / (y1 - y0) * 2 - 1
+    img_x = (img_x - x0) / (x1 - x0) * 2 - 1
+    # img_x, img_y have shapes (N, w), (N, h)
+    # IsInf op is not supported with ONNX<=1.7.0
+    if not torch.onnx.is_in_onnx_export():
+        if torch.isinf(img_x).any():
+            inds = torch.where(torch.isinf(img_x))
+            img_x[inds] = 0
+        if torch.isinf(img_y).any():
+            inds = torch.where(torch.isinf(img_y))
+            img_y[inds] = 0
+
+    gx = img_x[:, None, :].expand(N, img_y.size(1), img_x.size(1))
+    gy = img_y[:, :, None].expand(N, img_y.size(1), img_x.size(1))
+    grid = torch.stack([gx, gy], dim=3)
+
+    img_masks = F.grid_sample(
+        masks.to(dtype=torch.float32), grid, align_corners=False)
+
+    if skip_empty:
+        return img_masks[:, 0], (slice(y0_int, y1_int), slice(x0_int, x1_int))
+    else:
+        return img_masks[:, 0], ()
diff --git a/mmdetection/mmdet/models/roi_heads/mask_heads/feature_relay_head.py b/mmdetection/mmdet/models/roi_heads/mask_heads/feature_relay_head.py
new file mode 100644
index 00000000..0c34561f
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/mask_heads/feature_relay_head.py
@@ -0,0 +1,68 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional
+
+import torch.nn as nn
+from mmengine.model import BaseModule
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import MultiConfig
+
+
+@MODELS.register_module()
+class FeatureRelayHead(BaseModule):
+    """Feature Relay Head used in `SCNet `_.
+
+    Args:
+        in_channels (int): number of input channels. Defaults to 256.
+        conv_out_channels (int): number of output channels before
+            classification layer. Defaults to 256.
+        roi_feat_size (int): roi feat size at box head. Default: 7.
+        scale_factor (int): scale factor to match roi feat size
+            at mask head. Defaults to 2.
+        init_cfg (:obj:`ConfigDict` or dict or list[dict] or
+            list[:obj:`ConfigDict`]): Initialization config dict. Defaults to
+            dict(type='Kaiming', layer='Linear').
+    """
+
+    def __init__(
+        self,
+        in_channels: int = 1024,
+        out_conv_channels: int = 256,
+        roi_feat_size: int = 7,
+        scale_factor: int = 2,
+        init_cfg: MultiConfig = dict(type='Kaiming', layer='Linear')
+    ) -> None:
+        super().__init__(init_cfg=init_cfg)
+        assert isinstance(roi_feat_size, int)
+
+        self.in_channels = in_channels
+        self.out_conv_channels = out_conv_channels
+        self.roi_feat_size = roi_feat_size
+        self.out_channels = (roi_feat_size**2) * out_conv_channels
+        self.scale_factor = scale_factor
+        self.fp16_enabled = False
+
+        self.fc = nn.Linear(self.in_channels, self.out_channels)
+        self.upsample = nn.Upsample(
+            scale_factor=scale_factor, mode='bilinear', align_corners=True)
+
+    def forward(self, x: Tensor) -> Optional[Tensor]:
+        """Forward function.
+
+        Args:
+            x (Tensor): Input feature.
+
+        Returns:
+            Optional[Tensor]: Output feature. When the first dim of input is
+            0, None is returned.
+        """
+        N, _ = x.shape
+        if N > 0:
+            out_C = self.out_conv_channels
+            out_HW = self.roi_feat_size
+            x = self.fc(x)
+            x = x.reshape(N, out_C, out_HW, out_HW)
+            x = self.upsample(x)
+            return x
+        return None
diff --git a/mmdetection/mmdet/models/roi_heads/mask_heads/fused_semantic_head.py b/mmdetection/mmdet/models/roi_heads/mask_heads/fused_semantic_head.py
new file mode 100644
index 00000000..d20beb29
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/mask_heads/fused_semantic_head.py
@@ -0,0 +1,144 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+from typing import Tuple
+
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+from mmengine.config import ConfigDict
+from mmengine.model import BaseModule
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import MultiConfig, OptConfigType
+
+
+@MODELS.register_module()
+class FusedSemanticHead(BaseModule):
+    r"""Multi-level fused semantic segmentation head.
+
+    .. code-block:: none
+
+        in_1 -> 1x1 conv ---
+                            |
+        in_2 -> 1x1 conv -- |
+                           ||
+        in_3 -> 1x1 conv - ||
+                          |||                  /-> 1x1 conv (mask prediction)
+        in_4 -> 1x1 conv -----> 3x3 convs (*4)
+                            |                  \-> 1x1 conv (feature)
+        in_5 -> 1x1 conv ---
+    """  # noqa: W605
+
+    def __init__(
+        self,
+        num_ins: int,
+        fusion_level: int,
+        seg_scale_factor=1 / 8,
+        num_convs: int = 4,
+        in_channels: int = 256,
+        conv_out_channels: int = 256,
+        num_classes: int = 183,
+        conv_cfg: OptConfigType = None,
+        norm_cfg: OptConfigType = None,
+        ignore_label: int = None,
+        loss_weight: float = None,
+        loss_seg: ConfigDict = dict(
+            type='CrossEntropyLoss', ignore_index=255, loss_weight=0.2),
+        init_cfg: MultiConfig = dict(
+            type='Kaiming', override=dict(name='conv_logits'))
+    ) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.num_ins = num_ins
+        self.fusion_level = fusion_level
+        self.seg_scale_factor = seg_scale_factor
+        self.num_convs = num_convs
+        self.in_channels = in_channels
+        self.conv_out_channels = conv_out_channels
+        self.num_classes = num_classes
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.fp16_enabled = False
+
+        self.lateral_convs = nn.ModuleList()
+        for i in range(self.num_ins):
+            self.lateral_convs.append(
+                ConvModule(
+                    self.in_channels,
+                    self.in_channels,
+                    1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg,
+                    inplace=False))
+
+        self.convs = nn.ModuleList()
+        for i in range(self.num_convs):
+            in_channels = self.in_channels if i == 0 else conv_out_channels
+            self.convs.append(
+                ConvModule(
+                    in_channels,
+                    conv_out_channels,
+                    3,
+                    padding=1,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg))
+        self.conv_embedding = ConvModule(
+            conv_out_channels,
+            conv_out_channels,
+            1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg)
+        self.conv_logits = nn.Conv2d(conv_out_channels, self.num_classes, 1)
+        if ignore_label:
+            loss_seg['ignore_index'] = ignore_label
+        if loss_weight:
+            loss_seg['loss_weight'] = loss_weight
+        if ignore_label or loss_weight:
+            warnings.warn('``ignore_label`` and ``loss_weight`` would be '
+                          'deprecated soon. Please set ``ingore_index`` and '
+                          '``loss_weight`` in ``loss_seg`` instead.')
+        self.criterion = MODELS.build(loss_seg)
+
+    def forward(self, feats: Tuple[Tensor]) -> Tuple[Tensor]:
+        """Forward function.
+
+        Args:
+            feats (tuple[Tensor]): Multi scale feature maps.
+
+        Returns:
+            tuple[Tensor]:
+
+                - mask_preds (Tensor): Predicted mask logits.
+                - x (Tensor): Fused feature.
+        """
+        x = self.lateral_convs[self.fusion_level](feats[self.fusion_level])
+        fused_size = tuple(x.shape[-2:])
+        for i, feat in enumerate(feats):
+            if i != self.fusion_level:
+                feat = F.interpolate(
+                    feat, size=fused_size, mode='bilinear', align_corners=True)
+                # fix runtime error of "+=" inplace operation in PyTorch 1.10
+                x = x + self.lateral_convs[i](feat)
+
+        for i in range(self.num_convs):
+            x = self.convs[i](x)
+
+        mask_preds = self.conv_logits(x)
+        x = self.conv_embedding(x)
+        return mask_preds, x
+
+    def loss(self, mask_preds: Tensor, labels: Tensor) -> Tensor:
+        """Loss function.
+
+        Args:
+            mask_preds (Tensor): Predicted mask logits.
+            labels (Tensor): Ground truth.
+
+        Returns:
+            Tensor: Semantic segmentation loss.
+        """
+        labels = F.interpolate(
+            labels.float(), scale_factor=self.seg_scale_factor, mode='nearest')
+        labels = labels.squeeze(1).long()
+        loss_semantic_seg = self.criterion(mask_preds, labels)
+        return loss_semantic_seg
diff --git a/mmdetection/mmdet/models/roi_heads/mask_heads/global_context_head.py b/mmdetection/mmdet/models/roi_heads/mask_heads/global_context_head.py
new file mode 100644
index 00000000..cb947ea5
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/mask_heads/global_context_head.py
@@ -0,0 +1,127 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple
+
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule
+from torch import Tensor
+
+from mmdet.models.layers import ResLayer, SimplifiedBasicBlock
+from mmdet.registry import MODELS
+from mmdet.utils import MultiConfig, OptConfigType
+
+
+@MODELS.register_module()
+class GlobalContextHead(BaseModule):
+    """Global context head used in `SCNet `_.
+
+    Args:
+        num_convs (int, optional): number of convolutional layer in GlbCtxHead.
+            Defaults to 4.
+        in_channels (int, optional): number of input channels. Defaults to 256.
+        conv_out_channels (int, optional): number of output channels before
+            classification layer. Defaults to 256.
+        num_classes (int, optional): number of classes. Defaults to 80.
+        loss_weight (float, optional): global context loss weight.
+            Defaults to 1.
+        conv_cfg (dict, optional): config to init conv layer. Defaults to None.
+        norm_cfg (dict, optional): config to init norm layer. Defaults to None.
+        conv_to_res (bool, optional): if True, 2 convs will be grouped into
+            1 `SimplifiedBasicBlock` using a skip connection.
+            Defaults to False.
+        init_cfg (:obj:`ConfigDict` or dict or list[dict] or
+            list[:obj:`ConfigDict`]): Initialization config dict. Defaults to
+            dict(type='Normal', std=0.01, override=dict(name='fc')).
+    """
+
+    def __init__(
+        self,
+        num_convs: int = 4,
+        in_channels: int = 256,
+        conv_out_channels: int = 256,
+        num_classes: int = 80,
+        loss_weight: float = 1.0,
+        conv_cfg: OptConfigType = None,
+        norm_cfg: OptConfigType = None,
+        conv_to_res: bool = False,
+        init_cfg: MultiConfig = dict(
+            type='Normal', std=0.01, override=dict(name='fc'))
+    ) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.num_convs = num_convs
+        self.in_channels = in_channels
+        self.conv_out_channels = conv_out_channels
+        self.num_classes = num_classes
+        self.loss_weight = loss_weight
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.conv_to_res = conv_to_res
+        self.fp16_enabled = False
+
+        if self.conv_to_res:
+            num_res_blocks = num_convs // 2
+            self.convs = ResLayer(
+                SimplifiedBasicBlock,
+                in_channels,
+                self.conv_out_channels,
+                num_res_blocks,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg)
+            self.num_convs = num_res_blocks
+        else:
+            self.convs = nn.ModuleList()
+            for i in range(self.num_convs):
+                in_channels = self.in_channels if i == 0 else conv_out_channels
+                self.convs.append(
+                    ConvModule(
+                        in_channels,
+                        conv_out_channels,
+                        3,
+                        padding=1,
+                        conv_cfg=self.conv_cfg,
+                        norm_cfg=self.norm_cfg))
+
+        self.pool = nn.AdaptiveAvgPool2d(1)
+        self.fc = nn.Linear(conv_out_channels, num_classes)
+
+        self.criterion = nn.BCEWithLogitsLoss()
+
+    def forward(self, feats: Tuple[Tensor]) -> Tuple[Tensor]:
+        """Forward function.
+
+        Args:
+            feats (Tuple[Tensor]): Multi-scale feature maps.
+
+        Returns:
+            Tuple[Tensor]:
+
+                - mc_pred (Tensor): Multi-class prediction.
+                - x (Tensor): Global context feature.
+        """
+        x = feats[-1]
+        for i in range(self.num_convs):
+            x = self.convs[i](x)
+        x = self.pool(x)
+
+        # multi-class prediction
+        mc_pred = x.reshape(x.size(0), -1)
+        mc_pred = self.fc(mc_pred)
+
+        return mc_pred, x
+
+    def loss(self, pred: Tensor, labels: List[Tensor]) -> Tensor:
+        """Loss function.
+
+        Args:
+            pred (Tensor): Logits.
+            labels (list[Tensor]): Grouth truths.
+
+        Returns:
+            Tensor: Loss.
+        """
+        labels = [lbl.unique() for lbl in labels]
+        targets = pred.new_zeros(pred.size())
+        for i, label in enumerate(labels):
+            targets[i, label] = 1.0
+        loss = self.loss_weight * self.criterion(pred, targets)
+        return loss
diff --git a/mmdetection/mmdet/models/roi_heads/mask_heads/grid_head.py b/mmdetection/mmdet/models/roi_heads/mask_heads/grid_head.py
new file mode 100644
index 00000000..d9514ae7
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/mask_heads/grid_head.py
@@ -0,0 +1,490 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, List, Tuple
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import ConvModule
+from mmengine.config import ConfigDict
+from mmengine.model import BaseModule
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.models.task_modules.samplers import SamplingResult
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, InstanceList, MultiConfig, OptConfigType
+
+
+@MODELS.register_module()
+class GridHead(BaseModule):
+    """Implementation of `Grid Head `_
+
+    Args:
+        grid_points (int): The number of grid points. Defaults to 9.
+        num_convs (int): The number of convolution layers. Defaults to 8.
+        roi_feat_size (int): RoI feature size. Default to 14.
+        in_channels (int): The channel number of inputs features.
+            Defaults to 256.
+        conv_kernel_size (int): The kernel size of convolution layers.
+            Defaults to 3.
+        point_feat_channels (int): The number of channels of each point
+            features. Defaults to 64.
+        class_agnostic (bool): Whether use class agnostic classification.
+            If so, the output channels of logits will be 1. Defaults to False.
+        loss_grid (:obj:`ConfigDict` or dict): Config of grid loss.
+        conv_cfg (:obj:`ConfigDict` or dict, optional) dictionary to
+            construct and config conv layer.
+        norm_cfg (:obj:`ConfigDict` or dict): dictionary to construct and
+            config norm layer.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict]): Initialization config dict.
+    """
+
+    def __init__(
+        self,
+        grid_points: int = 9,
+        num_convs: int = 8,
+        roi_feat_size: int = 14,
+        in_channels: int = 256,
+        conv_kernel_size: int = 3,
+        point_feat_channels: int = 64,
+        deconv_kernel_size: int = 4,
+        class_agnostic: bool = False,
+        loss_grid: ConfigType = dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=15),
+        conv_cfg: OptConfigType = None,
+        norm_cfg: ConfigType = dict(type='GN', num_groups=36),
+        init_cfg: MultiConfig = [
+            dict(type='Kaiming', layer=['Conv2d', 'Linear']),
+            dict(
+                type='Normal',
+                layer='ConvTranspose2d',
+                std=0.001,
+                override=dict(
+                    type='Normal',
+                    name='deconv2',
+                    std=0.001,
+                    bias=-np.log(0.99 / 0.01)))
+        ]
+    ) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.grid_points = grid_points
+        self.num_convs = num_convs
+        self.roi_feat_size = roi_feat_size
+        self.in_channels = in_channels
+        self.conv_kernel_size = conv_kernel_size
+        self.point_feat_channels = point_feat_channels
+        self.conv_out_channels = self.point_feat_channels * self.grid_points
+        self.class_agnostic = class_agnostic
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        if isinstance(norm_cfg, dict) and norm_cfg['type'] == 'GN':
+            assert self.conv_out_channels % norm_cfg['num_groups'] == 0
+
+        assert self.grid_points >= 4
+        self.grid_size = int(np.sqrt(self.grid_points))
+        if self.grid_size * self.grid_size != self.grid_points:
+            raise ValueError('grid_points must be a square number')
+
+        # the predicted heatmap is half of whole_map_size
+        if not isinstance(self.roi_feat_size, int):
+            raise ValueError('Only square RoIs are supporeted in Grid R-CNN')
+        self.whole_map_size = self.roi_feat_size * 4
+
+        # compute point-wise sub-regions
+        self.sub_regions = self.calc_sub_regions()
+
+        self.convs = []
+        for i in range(self.num_convs):
+            in_channels = (
+                self.in_channels if i == 0 else self.conv_out_channels)
+            stride = 2 if i == 0 else 1
+            padding = (self.conv_kernel_size - 1) // 2
+            self.convs.append(
+                ConvModule(
+                    in_channels,
+                    self.conv_out_channels,
+                    self.conv_kernel_size,
+                    stride=stride,
+                    padding=padding,
+                    conv_cfg=self.conv_cfg,
+                    norm_cfg=self.norm_cfg,
+                    bias=True))
+        self.convs = nn.Sequential(*self.convs)
+
+        self.deconv1 = nn.ConvTranspose2d(
+            self.conv_out_channels,
+            self.conv_out_channels,
+            kernel_size=deconv_kernel_size,
+            stride=2,
+            padding=(deconv_kernel_size - 2) // 2,
+            groups=grid_points)
+        self.norm1 = nn.GroupNorm(grid_points, self.conv_out_channels)
+        self.deconv2 = nn.ConvTranspose2d(
+            self.conv_out_channels,
+            grid_points,
+            kernel_size=deconv_kernel_size,
+            stride=2,
+            padding=(deconv_kernel_size - 2) // 2,
+            groups=grid_points)
+
+        # find the 4-neighbor of each grid point
+        self.neighbor_points = []
+        grid_size = self.grid_size
+        for i in range(grid_size):  # i-th column
+            for j in range(grid_size):  # j-th row
+                neighbors = []
+                if i > 0:  # left: (i - 1, j)
+                    neighbors.append((i - 1) * grid_size + j)
+                if j > 0:  # up: (i, j - 1)
+                    neighbors.append(i * grid_size + j - 1)
+                if j < grid_size - 1:  # down: (i, j + 1)
+                    neighbors.append(i * grid_size + j + 1)
+                if i < grid_size - 1:  # right: (i + 1, j)
+                    neighbors.append((i + 1) * grid_size + j)
+                self.neighbor_points.append(tuple(neighbors))
+        # total edges in the grid
+        self.num_edges = sum([len(p) for p in self.neighbor_points])
+
+        self.forder_trans = nn.ModuleList()  # first-order feature transition
+        self.sorder_trans = nn.ModuleList()  # second-order feature transition
+        for neighbors in self.neighbor_points:
+            fo_trans = nn.ModuleList()
+            so_trans = nn.ModuleList()
+            for _ in range(len(neighbors)):
+                # each transition module consists of a 5x5 depth-wise conv and
+                # 1x1 conv.
+                fo_trans.append(
+                    nn.Sequential(
+                        nn.Conv2d(
+                            self.point_feat_channels,
+                            self.point_feat_channels,
+                            5,
+                            stride=1,
+                            padding=2,
+                            groups=self.point_feat_channels),
+                        nn.Conv2d(self.point_feat_channels,
+                                  self.point_feat_channels, 1)))
+                so_trans.append(
+                    nn.Sequential(
+                        nn.Conv2d(
+                            self.point_feat_channels,
+                            self.point_feat_channels,
+                            5,
+                            1,
+                            2,
+                            groups=self.point_feat_channels),
+                        nn.Conv2d(self.point_feat_channels,
+                                  self.point_feat_channels, 1)))
+            self.forder_trans.append(fo_trans)
+            self.sorder_trans.append(so_trans)
+
+        self.loss_grid = MODELS.build(loss_grid)
+
+    def forward(self, x: Tensor) -> Dict[str, Tensor]:
+        """forward function of ``GridHead``.
+
+        Args:
+            x (Tensor): RoI features, has shape
+                (num_rois, num_channels, roi_feat_size, roi_feat_size).
+
+        Returns:
+            Dict[str, Tensor]: Return a dict including fused and unfused
+            heatmap.
+        """
+        assert x.shape[-1] == x.shape[-2] == self.roi_feat_size
+        # RoI feature transformation, downsample 2x
+        x = self.convs(x)
+
+        c = self.point_feat_channels
+        # first-order fusion
+        x_fo = [None for _ in range(self.grid_points)]
+        for i, points in enumerate(self.neighbor_points):
+            x_fo[i] = x[:, i * c:(i + 1) * c]
+            for j, point_idx in enumerate(points):
+                x_fo[i] = x_fo[i] + self.forder_trans[i][j](
+                    x[:, point_idx * c:(point_idx + 1) * c])
+
+        # second-order fusion
+        x_so = [None for _ in range(self.grid_points)]
+        for i, points in enumerate(self.neighbor_points):
+            x_so[i] = x[:, i * c:(i + 1) * c]
+            for j, point_idx in enumerate(points):
+                x_so[i] = x_so[i] + self.sorder_trans[i][j](x_fo[point_idx])
+
+        # predicted heatmap with fused features
+        x2 = torch.cat(x_so, dim=1)
+        x2 = self.deconv1(x2)
+        x2 = F.relu(self.norm1(x2), inplace=True)
+        heatmap = self.deconv2(x2)
+
+        # predicted heatmap with original features (applicable during training)
+        if self.training:
+            x1 = x
+            x1 = self.deconv1(x1)
+            x1 = F.relu(self.norm1(x1), inplace=True)
+            heatmap_unfused = self.deconv2(x1)
+        else:
+            heatmap_unfused = heatmap
+
+        return dict(fused=heatmap, unfused=heatmap_unfused)
+
+    def calc_sub_regions(self) -> List[Tuple[float]]:
+        """Compute point specific representation regions.
+
+        See `Grid R-CNN Plus `_ for details.
+        """
+        # to make it consistent with the original implementation, half_size
+        # is computed as 2 * quarter_size, which is smaller
+        half_size = self.whole_map_size // 4 * 2
+        sub_regions = []
+        for i in range(self.grid_points):
+            x_idx = i // self.grid_size
+            y_idx = i % self.grid_size
+            if x_idx == 0:
+                sub_x1 = 0
+            elif x_idx == self.grid_size - 1:
+                sub_x1 = half_size
+            else:
+                ratio = x_idx / (self.grid_size - 1) - 0.25
+                sub_x1 = max(int(ratio * self.whole_map_size), 0)
+
+            if y_idx == 0:
+                sub_y1 = 0
+            elif y_idx == self.grid_size - 1:
+                sub_y1 = half_size
+            else:
+                ratio = y_idx / (self.grid_size - 1) - 0.25
+                sub_y1 = max(int(ratio * self.whole_map_size), 0)
+            sub_regions.append(
+                (sub_x1, sub_y1, sub_x1 + half_size, sub_y1 + half_size))
+        return sub_regions
+
+    def get_targets(self, sampling_results: List[SamplingResult],
+                    rcnn_train_cfg: ConfigDict) -> Tensor:
+        """Calculate the ground truth for all samples in a batch according to
+        the sampling_results.".
+
+        Args:
+            sampling_results (List[:obj:`SamplingResult`]): Assign results of
+                all images in a batch after sampling.
+            rcnn_train_cfg (:obj:`ConfigDict`): `train_cfg` of RCNN.
+
+        Returns:
+            Tensor: Grid heatmap targets.
+        """
+        # mix all samples (across images) together.
+        pos_bboxes = torch.cat([res.pos_bboxes for res in sampling_results],
+                               dim=0).cpu()
+        pos_gt_bboxes = torch.cat(
+            [res.pos_gt_bboxes for res in sampling_results], dim=0).cpu()
+        assert pos_bboxes.shape == pos_gt_bboxes.shape
+
+        # expand pos_bboxes to 2x of original size
+        x1 = pos_bboxes[:, 0] - (pos_bboxes[:, 2] - pos_bboxes[:, 0]) / 2
+        y1 = pos_bboxes[:, 1] - (pos_bboxes[:, 3] - pos_bboxes[:, 1]) / 2
+        x2 = pos_bboxes[:, 2] + (pos_bboxes[:, 2] - pos_bboxes[:, 0]) / 2
+        y2 = pos_bboxes[:, 3] + (pos_bboxes[:, 3] - pos_bboxes[:, 1]) / 2
+        pos_bboxes = torch.stack([x1, y1, x2, y2], dim=-1)
+        pos_bbox_ws = (pos_bboxes[:, 2] - pos_bboxes[:, 0]).unsqueeze(-1)
+        pos_bbox_hs = (pos_bboxes[:, 3] - pos_bboxes[:, 1]).unsqueeze(-1)
+
+        num_rois = pos_bboxes.shape[0]
+        map_size = self.whole_map_size
+        # this is not the final target shape
+        targets = torch.zeros((num_rois, self.grid_points, map_size, map_size),
+                              dtype=torch.float)
+
+        # pre-compute interpolation factors for all grid points.
+        # the first item is the factor of x-dim, and the second is y-dim.
+        # for a 9-point grid, factors are like (1, 0), (0.5, 0.5), (0, 1)
+        factors = []
+        for j in range(self.grid_points):
+            x_idx = j // self.grid_size
+            y_idx = j % self.grid_size
+            factors.append((1 - x_idx / (self.grid_size - 1),
+                            1 - y_idx / (self.grid_size - 1)))
+
+        radius = rcnn_train_cfg.pos_radius
+        radius2 = radius**2
+        for i in range(num_rois):
+            # ignore small bboxes
+            if (pos_bbox_ws[i] <= self.grid_size
+                    or pos_bbox_hs[i] <= self.grid_size):
+                continue
+            # for each grid point, mark a small circle as positive
+            for j in range(self.grid_points):
+                factor_x, factor_y = factors[j]
+                gridpoint_x = factor_x * pos_gt_bboxes[i, 0] + (
+                    1 - factor_x) * pos_gt_bboxes[i, 2]
+                gridpoint_y = factor_y * pos_gt_bboxes[i, 1] + (
+                    1 - factor_y) * pos_gt_bboxes[i, 3]
+
+                cx = int((gridpoint_x - pos_bboxes[i, 0]) / pos_bbox_ws[i] *
+                         map_size)
+                cy = int((gridpoint_y - pos_bboxes[i, 1]) / pos_bbox_hs[i] *
+                         map_size)
+
+                for x in range(cx - radius, cx + radius + 1):
+                    for y in range(cy - radius, cy + radius + 1):
+                        if x >= 0 and x < map_size and y >= 0 and y < map_size:
+                            if (x - cx)**2 + (y - cy)**2 <= radius2:
+                                targets[i, j, y, x] = 1
+        # reduce the target heatmap size by a half
+        # proposed in Grid R-CNN Plus (https://arxiv.org/abs/1906.05688).
+        sub_targets = []
+        for i in range(self.grid_points):
+            sub_x1, sub_y1, sub_x2, sub_y2 = self.sub_regions[i]
+            sub_targets.append(targets[:, [i], sub_y1:sub_y2, sub_x1:sub_x2])
+        sub_targets = torch.cat(sub_targets, dim=1)
+        sub_targets = sub_targets.to(sampling_results[0].pos_bboxes.device)
+        return sub_targets
+
+    def loss(self, grid_pred: Tensor, sample_idx: Tensor,
+             sampling_results: List[SamplingResult],
+             rcnn_train_cfg: ConfigDict) -> dict:
+        """Calculate the loss based on the features extracted by the grid head.
+
+        Args:
+            grid_pred (dict[str, Tensor]): Outputs of grid_head forward.
+            sample_idx (Tensor): The sampling index of ``grid_pred``.
+            sampling_results (List[obj:SamplingResult]): Assign results of
+                all images in a batch after sampling.
+            rcnn_train_cfg (obj:`ConfigDict`): `train_cfg` of RCNN.
+
+        Returns:
+            dict: A dictionary of loss and targets components.
+        """
+        grid_targets = self.get_targets(sampling_results, rcnn_train_cfg)
+        grid_targets = grid_targets[sample_idx]
+
+        loss_fused = self.loss_grid(grid_pred['fused'], grid_targets)
+        loss_unfused = self.loss_grid(grid_pred['unfused'], grid_targets)
+        loss_grid = loss_fused + loss_unfused
+        return dict(loss_grid=loss_grid)
+
+    def predict_by_feat(self,
+                        grid_preds: Dict[str, Tensor],
+                        results_list: List[InstanceData],
+                        batch_img_metas: List[dict],
+                        rescale: bool = False) -> InstanceList:
+        """Adjust the predicted bboxes from bbox head.
+
+        Args:
+            grid_preds (dict[str, Tensor]): dictionary outputted by forward
+                function.
+            results_list (list[:obj:`InstanceData`]): Detection results of
+                each image.
+            batch_img_metas (list[dict]): List of image information.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Detection results of each image
+            after the post process. Each item usually contains following keys.
+
+            - scores (Tensor): Classification scores, has a shape \
+            (num_instance, )
+            - labels (Tensor): Labels of bboxes, has a shape (num_instances, ).
+            - bboxes (Tensor): Has a shape (num_instances, 4), the last \
+            dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        num_roi_per_img = tuple(res.bboxes.size(0) for res in results_list)
+        grid_preds = {
+            k: v.split(num_roi_per_img, 0)
+            for k, v in grid_preds.items()
+        }
+
+        for i, results in enumerate(results_list):
+            if len(results) != 0:
+                bboxes = self._predict_by_feat_single(
+                    grid_pred=grid_preds['fused'][i],
+                    bboxes=results.bboxes,
+                    img_meta=batch_img_metas[i],
+                    rescale=rescale)
+                results.bboxes = bboxes
+        return results_list
+
+    def _predict_by_feat_single(self,
+                                grid_pred: Tensor,
+                                bboxes: Tensor,
+                                img_meta: dict,
+                                rescale: bool = False) -> Tensor:
+        """Adjust ``bboxes`` according to ``grid_pred``.
+
+        Args:
+            grid_pred (Tensor): Grid fused heatmap.
+            bboxes (Tensor): Predicted bboxes, has shape (n, 4)
+            img_meta (dict): image information.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            Tensor: adjusted bboxes.
+        """
+        assert bboxes.size(0) == grid_pred.size(0)
+        grid_pred = grid_pred.sigmoid()
+
+        R, c, h, w = grid_pred.shape
+        half_size = self.whole_map_size // 4 * 2
+        assert h == w == half_size
+        assert c == self.grid_points
+
+        # find the point with max scores in the half-sized heatmap
+        grid_pred = grid_pred.view(R * c, h * w)
+        pred_scores, pred_position = grid_pred.max(dim=1)
+        xs = pred_position % w
+        ys = pred_position // w
+
+        # get the position in the whole heatmap instead of half-sized heatmap
+        for i in range(self.grid_points):
+            xs[i::self.grid_points] += self.sub_regions[i][0]
+            ys[i::self.grid_points] += self.sub_regions[i][1]
+
+        # reshape to (num_rois, grid_points)
+        pred_scores, xs, ys = tuple(
+            map(lambda x: x.view(R, c), [pred_scores, xs, ys]))
+
+        # get expanded pos_bboxes
+        widths = (bboxes[:, 2] - bboxes[:, 0]).unsqueeze(-1)
+        heights = (bboxes[:, 3] - bboxes[:, 1]).unsqueeze(-1)
+        x1 = (bboxes[:, 0, None] - widths / 2)
+        y1 = (bboxes[:, 1, None] - heights / 2)
+        # map the grid point to the absolute coordinates
+        abs_xs = (xs.float() + 0.5) / w * widths + x1
+        abs_ys = (ys.float() + 0.5) / h * heights + y1
+
+        # get the grid points indices that fall on the bbox boundaries
+        x1_inds = [i for i in range(self.grid_size)]
+        y1_inds = [i * self.grid_size for i in range(self.grid_size)]
+        x2_inds = [
+            self.grid_points - self.grid_size + i
+            for i in range(self.grid_size)
+        ]
+        y2_inds = [(i + 1) * self.grid_size - 1 for i in range(self.grid_size)]
+
+        # voting of all grid points on some boundary
+        bboxes_x1 = (abs_xs[:, x1_inds] * pred_scores[:, x1_inds]).sum(
+            dim=1, keepdim=True) / (
+                pred_scores[:, x1_inds].sum(dim=1, keepdim=True))
+        bboxes_y1 = (abs_ys[:, y1_inds] * pred_scores[:, y1_inds]).sum(
+            dim=1, keepdim=True) / (
+                pred_scores[:, y1_inds].sum(dim=1, keepdim=True))
+        bboxes_x2 = (abs_xs[:, x2_inds] * pred_scores[:, x2_inds]).sum(
+            dim=1, keepdim=True) / (
+                pred_scores[:, x2_inds].sum(dim=1, keepdim=True))
+        bboxes_y2 = (abs_ys[:, y2_inds] * pred_scores[:, y2_inds]).sum(
+            dim=1, keepdim=True) / (
+                pred_scores[:, y2_inds].sum(dim=1, keepdim=True))
+
+        bboxes = torch.cat([bboxes_x1, bboxes_y1, bboxes_x2, bboxes_y2], dim=1)
+        bboxes[:, [0, 2]].clamp_(min=0, max=img_meta['img_shape'][1])
+        bboxes[:, [1, 3]].clamp_(min=0, max=img_meta['img_shape'][0])
+
+        if rescale:
+            assert img_meta.get('scale_factor') is not None
+            bboxes /= bboxes.new_tensor(img_meta['scale_factor']).repeat(
+                (1, 2))
+
+        return bboxes
diff --git a/mmdetection/mmdet/models/roi_heads/mask_heads/htc_mask_head.py b/mmdetection/mmdet/models/roi_heads/mask_heads/htc_mask_head.py
new file mode 100644
index 00000000..73ac1e6e
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/mask_heads/htc_mask_head.py
@@ -0,0 +1,65 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Union
+
+from mmcv.cnn import ConvModule
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from .fcn_mask_head import FCNMaskHead
+
+
+@MODELS.register_module()
+class HTCMaskHead(FCNMaskHead):
+    """Mask head for HTC.
+
+    Args:
+        with_conv_res (bool): Whether add conv layer for ``res_feat``.
+            Defaults to True.
+    """
+
+    def __init__(self, with_conv_res: bool = True, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.with_conv_res = with_conv_res
+        if self.with_conv_res:
+            self.conv_res = ConvModule(
+                self.conv_out_channels,
+                self.conv_out_channels,
+                1,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg)
+
+    def forward(self,
+                x: Tensor,
+                res_feat: Optional[Tensor] = None,
+                return_logits: bool = True,
+                return_feat: bool = True) -> Union[Tensor, List[Tensor]]:
+        """
+        Args:
+            x (Tensor): Feature map.
+            res_feat (Tensor, optional): Feature for residual connection.
+                Defaults to None.
+            return_logits (bool): Whether return mask logits. Defaults to True.
+            return_feat (bool): Whether return feature map. Defaults to True.
+
+        Returns:
+            Union[Tensor, List[Tensor]]: The return result is one of three
+                results: res_feat, logits, or [logits, res_feat].
+        """
+        assert not (not return_logits and not return_feat)
+        if res_feat is not None:
+            assert self.with_conv_res
+            res_feat = self.conv_res(res_feat)
+            x = x + res_feat
+        for conv in self.convs:
+            x = conv(x)
+        res_feat = x
+        outs = []
+        if return_logits:
+            x = self.upsample(x)
+            if self.upsample_method == 'deconv':
+                x = self.relu(x)
+            mask_preds = self.conv_logits(x)
+            outs.append(mask_preds)
+        if return_feat:
+            outs.append(res_feat)
+        return outs if len(outs) > 1 else outs[0]
diff --git a/mmdetection/mmdet/models/roi_heads/mask_heads/mask_point_head.py b/mmdetection/mmdet/models/roi_heads/mask_heads/mask_point_head.py
new file mode 100644
index 00000000..2084f59f
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/mask_heads/mask_point_head.py
@@ -0,0 +1,284 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# Modified from https://github.com/facebookresearch/detectron2/tree/master/projects/PointRend/point_head/point_head.py  # noqa
+
+from typing import List, Tuple
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmcv.ops import point_sample, rel_roi_point_to_rel_img_point
+from mmengine.model import BaseModule
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.models.task_modules.samplers import SamplingResult
+from mmdet.models.utils import (get_uncertain_point_coords_with_randomness,
+                                get_uncertainty)
+from mmdet.registry import MODELS
+from mmdet.structures.bbox import bbox2roi
+from mmdet.utils import ConfigType, InstanceList, MultiConfig, OptConfigType
+
+
+@MODELS.register_module()
+class MaskPointHead(BaseModule):
+    """A mask point head use in PointRend.
+
+    ``MaskPointHead`` use shared multi-layer perceptron (equivalent to
+    nn.Conv1d) to predict the logit of input points. The fine-grained feature
+    and coarse feature will be concatenate together for predication.
+
+    Args:
+        num_fcs (int): Number of fc layers in the head. Defaults to 3.
+        in_channels (int): Number of input channels. Defaults to 256.
+        fc_channels (int): Number of fc channels. Defaults to 256.
+        num_classes (int): Number of classes for logits. Defaults to 80.
+        class_agnostic (bool): Whether use class agnostic classification.
+            If so, the output channels of logits will be 1. Defaults to False.
+        coarse_pred_each_layer (bool): Whether concatenate coarse feature with
+            the output of each fc layer. Defaults to True.
+        conv_cfg (:obj:`ConfigDict` or dict): Dictionary to construct
+            and config conv layer. Defaults to dict(type='Conv1d')).
+        norm_cfg (:obj:`ConfigDict` or dict, optional): Dictionary to construct
+            and config norm layer. Defaults to None.
+        loss_point (:obj:`ConfigDict` or dict): Dictionary to construct and
+            config loss layer of point head. Defaults to
+            dict(type='CrossEntropyLoss', use_mask=True, loss_weight=1.0).
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict], optional): Initialization config dict.
+    """
+
+    def __init__(
+        self,
+        num_classes: int,
+        num_fcs: int = 3,
+        in_channels: int = 256,
+        fc_channels: int = 256,
+        class_agnostic: bool = False,
+        coarse_pred_each_layer: bool = True,
+        conv_cfg: ConfigType = dict(type='Conv1d'),
+        norm_cfg: OptConfigType = None,
+        act_cfg: ConfigType = dict(type='ReLU'),
+        loss_point: ConfigType = dict(
+            type='CrossEntropyLoss', use_mask=True, loss_weight=1.0),
+        init_cfg: MultiConfig = dict(
+            type='Normal', std=0.001, override=dict(name='fc_logits'))
+    ) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.num_fcs = num_fcs
+        self.in_channels = in_channels
+        self.fc_channels = fc_channels
+        self.num_classes = num_classes
+        self.class_agnostic = class_agnostic
+        self.coarse_pred_each_layer = coarse_pred_each_layer
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.loss_point = MODELS.build(loss_point)
+
+        fc_in_channels = in_channels + num_classes
+        self.fcs = nn.ModuleList()
+        for _ in range(num_fcs):
+            fc = ConvModule(
+                fc_in_channels,
+                fc_channels,
+                kernel_size=1,
+                stride=1,
+                padding=0,
+                conv_cfg=conv_cfg,
+                norm_cfg=norm_cfg,
+                act_cfg=act_cfg)
+            self.fcs.append(fc)
+            fc_in_channels = fc_channels
+            fc_in_channels += num_classes if self.coarse_pred_each_layer else 0
+
+        out_channels = 1 if self.class_agnostic else self.num_classes
+        self.fc_logits = nn.Conv1d(
+            fc_in_channels, out_channels, kernel_size=1, stride=1, padding=0)
+
+    def forward(self, fine_grained_feats: Tensor,
+                coarse_feats: Tensor) -> Tensor:
+        """Classify each point base on fine grained and coarse feats.
+
+        Args:
+            fine_grained_feats (Tensor): Fine grained feature sampled from FPN,
+                shape (num_rois, in_channels, num_points).
+            coarse_feats (Tensor): Coarse feature sampled from CoarseMaskHead,
+                shape (num_rois, num_classes, num_points).
+
+        Returns:
+            Tensor: Point classification results,
+            shape (num_rois, num_class, num_points).
+        """
+
+        x = torch.cat([fine_grained_feats, coarse_feats], dim=1)
+        for fc in self.fcs:
+            x = fc(x)
+            if self.coarse_pred_each_layer:
+                x = torch.cat((x, coarse_feats), dim=1)
+        return self.fc_logits(x)
+
+    def get_targets(self, rois: Tensor, rel_roi_points: Tensor,
+                    sampling_results: List[SamplingResult],
+                    batch_gt_instances: InstanceList,
+                    cfg: ConfigType) -> Tensor:
+        """Get training targets of MaskPointHead for all images.
+
+        Args:
+            rois (Tensor): Region of Interest, shape (num_rois, 5).
+            rel_roi_points (Tensor): Points coordinates relative to RoI, shape
+                (num_rois, num_points, 2).
+            sampling_results (:obj:`SamplingResult`): Sampling result after
+                sampling and assignment.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes``, ``labels``, and
+                ``masks`` attributes.
+            cfg (obj:`ConfigDict` or dict): Training cfg.
+
+        Returns:
+            Tensor: Point target, shape (num_rois, num_points).
+        """
+
+        num_imgs = len(sampling_results)
+        rois_list = []
+        rel_roi_points_list = []
+        for batch_ind in range(num_imgs):
+            inds = (rois[:, 0] == batch_ind)
+            rois_list.append(rois[inds])
+            rel_roi_points_list.append(rel_roi_points[inds])
+        pos_assigned_gt_inds_list = [
+            res.pos_assigned_gt_inds for res in sampling_results
+        ]
+        cfg_list = [cfg for _ in range(num_imgs)]
+
+        point_targets = map(self._get_targets_single, rois_list,
+                            rel_roi_points_list, pos_assigned_gt_inds_list,
+                            batch_gt_instances, cfg_list)
+        point_targets = list(point_targets)
+
+        if len(point_targets) > 0:
+            point_targets = torch.cat(point_targets)
+
+        return point_targets
+
+    def _get_targets_single(self, rois: Tensor, rel_roi_points: Tensor,
+                            pos_assigned_gt_inds: Tensor,
+                            gt_instances: InstanceData,
+                            cfg: ConfigType) -> Tensor:
+        """Get training target of MaskPointHead for each image."""
+        num_pos = rois.size(0)
+        num_points = cfg.num_points
+        if num_pos > 0:
+            gt_masks_th = (
+                gt_instances.masks.to_tensor(rois.dtype,
+                                             rois.device).index_select(
+                                                 0, pos_assigned_gt_inds))
+            gt_masks_th = gt_masks_th.unsqueeze(1)
+            rel_img_points = rel_roi_point_to_rel_img_point(
+                rois, rel_roi_points, gt_masks_th)
+            point_targets = point_sample(gt_masks_th,
+                                         rel_img_points).squeeze(1)
+        else:
+            point_targets = rois.new_zeros((0, num_points))
+        return point_targets
+
+    def loss_and_target(self, point_pred: Tensor, rel_roi_points: Tensor,
+                        sampling_results: List[SamplingResult],
+                        batch_gt_instances: InstanceList,
+                        cfg: ConfigType) -> dict:
+        """Calculate loss for MaskPointHead.
+
+        Args:
+            point_pred (Tensor): Point predication result, shape
+                (num_rois, num_classes, num_points).
+            rel_roi_points (Tensor): Points coordinates relative to RoI, shape
+                (num_rois, num_points, 2).
+             sampling_results (:obj:`SamplingResult`): Sampling result after
+                sampling and assignment.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes``, ``labels``, and
+                ``masks`` attributes.
+            cfg (obj:`ConfigDict` or dict): Training cfg.
+
+        Returns:
+            dict: a dictionary of point loss and point target.
+        """
+        rois = bbox2roi([res.pos_bboxes for res in sampling_results])
+        pos_labels = torch.cat([res.pos_gt_labels for res in sampling_results])
+
+        point_target = self.get_targets(rois, rel_roi_points, sampling_results,
+                                        batch_gt_instances, cfg)
+        if self.class_agnostic:
+            loss_point = self.loss_point(point_pred, point_target,
+                                         torch.zeros_like(pos_labels))
+        else:
+            loss_point = self.loss_point(point_pred, point_target, pos_labels)
+
+        return dict(loss_point=loss_point, point_target=point_target)
+
+    def get_roi_rel_points_train(self, mask_preds: Tensor, labels: Tensor,
+                                 cfg: ConfigType) -> Tensor:
+        """Get ``num_points`` most uncertain points with random points during
+        train.
+
+        Sample points in [0, 1] x [0, 1] coordinate space based on their
+        uncertainty. The uncertainties are calculated for each point using
+        '_get_uncertainty()' function that takes point's logit prediction as
+        input.
+
+        Args:
+            mask_preds (Tensor): A tensor of shape (num_rois, num_classes,
+                mask_height, mask_width) for class-specific or class-agnostic
+                prediction.
+            labels (Tensor): The ground truth class for each instance.
+            cfg (:obj:`ConfigDict` or dict): Training config of point head.
+
+        Returns:
+            point_coords (Tensor): A tensor of shape (num_rois, num_points, 2)
+            that contains the coordinates sampled points.
+        """
+        point_coords = get_uncertain_point_coords_with_randomness(
+            mask_preds, labels, cfg.num_points, cfg.oversample_ratio,
+            cfg.importance_sample_ratio)
+        return point_coords
+
+    def get_roi_rel_points_test(self, mask_preds: Tensor, label_preds: Tensor,
+                                cfg: ConfigType) -> Tuple[Tensor, Tensor]:
+        """Get ``num_points`` most uncertain points during test.
+
+        Args:
+            mask_preds (Tensor): A tensor of shape (num_rois, num_classes,
+                mask_height, mask_width) for class-specific or class-agnostic
+                prediction.
+            label_preds (Tensor): The predication class for each instance.
+            cfg (:obj:`ConfigDict` or dict): Testing config of point head.
+
+        Returns:
+            tuple:
+
+            - point_indices (Tensor): A tensor of shape (num_rois, num_points)
+              that contains indices from [0, mask_height x mask_width) of the
+              most uncertain points.
+            - point_coords (Tensor): A tensor of shape (num_rois, num_points,
+              2) that contains [0, 1] x [0, 1] normalized coordinates of the
+              most uncertain points from the [mask_height, mask_width] grid.
+        """
+        num_points = cfg.subdivision_num_points
+        uncertainty_map = get_uncertainty(mask_preds, label_preds)
+        num_rois, _, mask_height, mask_width = uncertainty_map.shape
+
+        # During ONNX exporting, the type of each elements of 'shape' is
+        # `Tensor(float)`, while it is `float` during PyTorch inference.
+        if isinstance(mask_height, torch.Tensor):
+            h_step = 1.0 / mask_height.float()
+            w_step = 1.0 / mask_width.float()
+        else:
+            h_step = 1.0 / mask_height
+            w_step = 1.0 / mask_width
+        # cast to int to avoid dynamic K for TopK op in ONNX
+        mask_size = int(mask_height * mask_width)
+        uncertainty_map = uncertainty_map.view(num_rois, mask_size)
+        num_points = min(mask_size, num_points)
+        point_indices = uncertainty_map.topk(num_points, dim=1)[1]
+        xs = w_step / 2.0 + (point_indices % mask_width).float() * w_step
+        ys = h_step / 2.0 + (point_indices // mask_width).float() * h_step
+        point_coords = torch.stack([xs, ys], dim=2)
+        return point_indices, point_coords
diff --git a/mmdetection/mmdet/models/roi_heads/mask_heads/maskiou_head.py b/mmdetection/mmdet/models/roi_heads/mask_heads/maskiou_head.py
new file mode 100644
index 00000000..8901871e
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/mask_heads/maskiou_head.py
@@ -0,0 +1,277 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple
+
+import numpy as np
+import torch
+import torch.nn as nn
+from mmcv.cnn import Conv2d, Linear, MaxPool2d
+from mmengine.config import ConfigDict
+from mmengine.model import BaseModule
+from mmengine.structures import InstanceData
+from torch import Tensor
+from torch.nn.modules.utils import _pair
+
+from mmdet.models.task_modules.samplers import SamplingResult
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, InstanceList, OptMultiConfig
+
+
+@MODELS.register_module()
+class MaskIoUHead(BaseModule):
+    """Mask IoU Head.
+
+    This head predicts the IoU of predicted masks and corresponding gt masks.
+
+    Args:
+        num_convs (int): The number of convolution layers. Defaults to 4.
+        num_fcs (int): The number of fully connected layers. Defaults to 2.
+        roi_feat_size (int): RoI feature size. Default to 14.
+        in_channels (int): The channel number of inputs features.
+            Defaults to 256.
+        conv_out_channels (int): The feature channels of convolution layers.
+            Defaults to 256.
+        fc_out_channels (int): The feature channels of fully connected layers.
+            Defaults to 1024.
+        num_classes (int): Number of categories excluding the background
+            category. Defaults to 80.
+        loss_iou (:obj:`ConfigDict` or dict): IoU loss.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict], optional): Initialization config dict.
+    """
+
+    def __init__(
+        self,
+        num_convs: int = 4,
+        num_fcs: int = 2,
+        roi_feat_size: int = 14,
+        in_channels: int = 256,
+        conv_out_channels: int = 256,
+        fc_out_channels: int = 1024,
+        num_classes: int = 80,
+        loss_iou: ConfigType = dict(type='MSELoss', loss_weight=0.5),
+        init_cfg: OptMultiConfig = [
+            dict(type='Kaiming', override=dict(name='convs')),
+            dict(type='Caffe2Xavier', override=dict(name='fcs')),
+            dict(type='Normal', std=0.01, override=dict(name='fc_mask_iou'))
+        ]
+    ) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.in_channels = in_channels
+        self.conv_out_channels = conv_out_channels
+        self.fc_out_channels = fc_out_channels
+        self.num_classes = num_classes
+
+        self.convs = nn.ModuleList()
+        for i in range(num_convs):
+            if i == 0:
+                # concatenation of mask feature and mask prediction
+                in_channels = self.in_channels + 1
+            else:
+                in_channels = self.conv_out_channels
+            stride = 2 if i == num_convs - 1 else 1
+            self.convs.append(
+                Conv2d(
+                    in_channels,
+                    self.conv_out_channels,
+                    3,
+                    stride=stride,
+                    padding=1))
+
+        roi_feat_size = _pair(roi_feat_size)
+        pooled_area = (roi_feat_size[0] // 2) * (roi_feat_size[1] // 2)
+        self.fcs = nn.ModuleList()
+        for i in range(num_fcs):
+            in_channels = (
+                self.conv_out_channels *
+                pooled_area if i == 0 else self.fc_out_channels)
+            self.fcs.append(Linear(in_channels, self.fc_out_channels))
+
+        self.fc_mask_iou = Linear(self.fc_out_channels, self.num_classes)
+        self.relu = nn.ReLU()
+        self.max_pool = MaxPool2d(2, 2)
+        self.loss_iou = MODELS.build(loss_iou)
+
+    def forward(self, mask_feat: Tensor, mask_preds: Tensor) -> Tensor:
+        """Forward function.
+
+        Args:
+            mask_feat (Tensor): Mask features from upstream models.
+            mask_preds (Tensor): Mask predictions from mask head.
+
+        Returns:
+            Tensor: Mask IoU predictions.
+        """
+        mask_preds = mask_preds.sigmoid()
+        mask_pred_pooled = self.max_pool(mask_preds.unsqueeze(1))
+
+        x = torch.cat((mask_feat, mask_pred_pooled), 1)
+
+        for conv in self.convs:
+            x = self.relu(conv(x))
+        x = x.flatten(1)
+        for fc in self.fcs:
+            x = self.relu(fc(x))
+        mask_iou = self.fc_mask_iou(x)
+        return mask_iou
+
+    def loss_and_target(self, mask_iou_pred: Tensor, mask_preds: Tensor,
+                        mask_targets: Tensor,
+                        sampling_results: List[SamplingResult],
+                        batch_gt_instances: InstanceList,
+                        rcnn_train_cfg: ConfigDict) -> dict:
+        """Calculate the loss and targets of MaskIoUHead.
+
+        Args:
+            mask_iou_pred (Tensor): Mask IoU predictions results, has shape
+                (num_pos, num_classes)
+            mask_preds (Tensor): Mask predictions from mask head, has shape
+                (num_pos, mask_size, mask_size).
+            mask_targets (Tensor): The ground truth masks assigned with
+                predictions, has shape
+                (num_pos, mask_size, mask_size).
+            sampling_results (List[obj:SamplingResult]): Assign results of
+                all images in a batch after sampling.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It includes ``masks`` inside.
+            rcnn_train_cfg (obj:`ConfigDict`): `train_cfg` of RCNN.
+
+        Returns:
+            dict: A dictionary of loss and targets components.
+                The targets are only used for cascade rcnn.
+        """
+        mask_iou_targets = self.get_targets(
+            sampling_results=sampling_results,
+            batch_gt_instances=batch_gt_instances,
+            mask_preds=mask_preds,
+            mask_targets=mask_targets,
+            rcnn_train_cfg=rcnn_train_cfg)
+
+        pos_inds = mask_iou_targets > 0
+        if pos_inds.sum() > 0:
+            loss_mask_iou = self.loss_iou(mask_iou_pred[pos_inds],
+                                          mask_iou_targets[pos_inds])
+        else:
+            loss_mask_iou = mask_iou_pred.sum() * 0
+        return dict(loss_mask_iou=loss_mask_iou)
+
+    def get_targets(self, sampling_results: List[SamplingResult],
+                    batch_gt_instances: InstanceList, mask_preds: Tensor,
+                    mask_targets: Tensor,
+                    rcnn_train_cfg: ConfigDict) -> Tensor:
+        """Compute target of mask IoU.
+
+        Mask IoU target is the IoU of the predicted mask (inside a bbox) and
+        the gt mask of corresponding gt mask (the whole instance).
+        The intersection area is computed inside the bbox, and the gt mask area
+        is computed with two steps, firstly we compute the gt area inside the
+        bbox, then divide it by the area ratio of gt area inside the bbox and
+        the gt area of the whole instance.
+
+        Args:
+            sampling_results (list[:obj:`SamplingResult`]): sampling results.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It includes ``masks`` inside.
+            mask_preds (Tensor): Predicted masks of each positive proposal,
+                shape (num_pos, h, w).
+            mask_targets (Tensor): Gt mask of each positive proposal,
+                binary map of the shape (num_pos, h, w).
+            rcnn_train_cfg (obj:`ConfigDict`): Training config for R-CNN part.
+
+        Returns:
+            Tensor: mask iou target (length == num positive).
+        """
+        pos_proposals = [res.pos_priors for res in sampling_results]
+        pos_assigned_gt_inds = [
+            res.pos_assigned_gt_inds for res in sampling_results
+        ]
+        gt_masks = [res.masks for res in batch_gt_instances]
+
+        # compute the area ratio of gt areas inside the proposals and
+        # the whole instance
+        area_ratios = map(self._get_area_ratio, pos_proposals,
+                          pos_assigned_gt_inds, gt_masks)
+        area_ratios = torch.cat(list(area_ratios))
+        assert mask_targets.size(0) == area_ratios.size(0)
+
+        mask_preds = (mask_preds > rcnn_train_cfg.mask_thr_binary).float()
+        mask_pred_areas = mask_preds.sum((-1, -2))
+
+        # mask_preds and mask_targets are binary maps
+        overlap_areas = (mask_preds * mask_targets).sum((-1, -2))
+
+        # compute the mask area of the whole instance
+        gt_full_areas = mask_targets.sum((-1, -2)) / (area_ratios + 1e-7)
+
+        mask_iou_targets = overlap_areas / (
+            mask_pred_areas + gt_full_areas - overlap_areas)
+        return mask_iou_targets
+
+    def _get_area_ratio(self, pos_proposals: Tensor,
+                        pos_assigned_gt_inds: Tensor,
+                        gt_masks: InstanceData) -> Tensor:
+        """Compute area ratio of the gt mask inside the proposal and the gt
+        mask of the corresponding instance.
+
+        Args:
+            pos_proposals (Tensor): Positive proposals, has shape (num_pos, 4).
+            pos_assigned_gt_inds (Tensor): positive proposals assigned ground
+                truth index.
+            gt_masks (BitmapMask or PolygonMask): Gt masks (the whole instance)
+                of each image, with the same shape of the input image.
+
+        Returns:
+            Tensor: The area ratio of the gt mask inside the proposal and the
+            gt mask of the corresponding instance.
+        """
+        num_pos = pos_proposals.size(0)
+        if num_pos > 0:
+            area_ratios = []
+            proposals_np = pos_proposals.cpu().numpy()
+            pos_assigned_gt_inds = pos_assigned_gt_inds.cpu().numpy()
+            # compute mask areas of gt instances (batch processing for speedup)
+            gt_instance_mask_area = gt_masks.areas
+            for i in range(num_pos):
+                gt_mask = gt_masks[pos_assigned_gt_inds[i]]
+
+                # crop the gt mask inside the proposal
+                bbox = proposals_np[i, :].astype(np.int32)
+                gt_mask_in_proposal = gt_mask.crop(bbox)
+
+                ratio = gt_mask_in_proposal.areas[0] / (
+                    gt_instance_mask_area[pos_assigned_gt_inds[i]] + 1e-7)
+                area_ratios.append(ratio)
+            area_ratios = torch.from_numpy(np.stack(area_ratios)).float().to(
+                pos_proposals.device)
+        else:
+            area_ratios = pos_proposals.new_zeros((0, ))
+        return area_ratios
+
+    def predict_by_feat(self, mask_iou_preds: Tuple[Tensor],
+                        results_list: InstanceList) -> InstanceList:
+        """Predict the mask iou and calculate it into ``results.scores``.
+
+        Args:
+            mask_iou_preds (Tensor): Mask IoU predictions results, has shape
+                (num_proposals, num_classes)
+            results_list (list[:obj:`InstanceData`]): Detection results of
+                each image.
+
+        Returns:
+            list[:obj:`InstanceData`]: Detection results of each image
+            after the post process. Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+                - masks (Tensor): Has a shape (num_instances, H, W).
+        """
+        assert len(mask_iou_preds) == len(results_list)
+        for results, mask_iou_pred in zip(results_list, mask_iou_preds):
+            labels = results.labels
+            scores = results.scores
+            results.scores = scores * mask_iou_pred[range(labels.size(0)),
+                                                    labels]
+        return results_list
diff --git a/mmdetection/mmdet/models/roi_heads/mask_heads/scnet_mask_head.py b/mmdetection/mmdet/models/roi_heads/mask_heads/scnet_mask_head.py
new file mode 100644
index 00000000..ffd30c33
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/mask_heads/scnet_mask_head.py
@@ -0,0 +1,28 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.models.layers import ResLayer, SimplifiedBasicBlock
+from mmdet.registry import MODELS
+from .fcn_mask_head import FCNMaskHead
+
+
+@MODELS.register_module()
+class SCNetMaskHead(FCNMaskHead):
+    """Mask head for `SCNet `_.
+
+    Args:
+        conv_to_res (bool, optional): if True, change the conv layers to
+            ``SimplifiedBasicBlock``.
+    """
+
+    def __init__(self, conv_to_res: bool = True, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.conv_to_res = conv_to_res
+        if conv_to_res:
+            assert self.conv_kernel_size == 3
+            self.num_res_blocks = self.num_convs // 2
+            self.convs = ResLayer(
+                SimplifiedBasicBlock,
+                self.in_channels,
+                self.conv_out_channels,
+                self.num_res_blocks,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg)
diff --git a/mmdetection/mmdet/models/roi_heads/mask_heads/scnet_semantic_head.py b/mmdetection/mmdet/models/roi_heads/mask_heads/scnet_semantic_head.py
new file mode 100644
index 00000000..55c5c8e4
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/mask_heads/scnet_semantic_head.py
@@ -0,0 +1,28 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.models.layers import ResLayer, SimplifiedBasicBlock
+from mmdet.registry import MODELS
+from .fused_semantic_head import FusedSemanticHead
+
+
+@MODELS.register_module()
+class SCNetSemanticHead(FusedSemanticHead):
+    """Mask head for `SCNet `_.
+
+    Args:
+        conv_to_res (bool, optional): if True, change the conv layers to
+            ``SimplifiedBasicBlock``.
+    """
+
+    def __init__(self, conv_to_res: bool = True, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.conv_to_res = conv_to_res
+        if self.conv_to_res:
+            num_res_blocks = self.num_convs // 2
+            self.convs = ResLayer(
+                SimplifiedBasicBlock,
+                self.in_channels,
+                self.conv_out_channels,
+                num_res_blocks,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg)
+            self.num_convs = num_res_blocks
diff --git a/mmdetection/mmdet/models/roi_heads/mask_scoring_roi_head.py b/mmdetection/mmdet/models/roi_heads/mask_scoring_roi_head.py
new file mode 100644
index 00000000..6545c0ed
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/mask_scoring_roi_head.py
@@ -0,0 +1,208 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple
+
+import torch
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.structures.bbox import bbox2roi
+from mmdet.utils import ConfigType, InstanceList
+from ..task_modules.samplers import SamplingResult
+from ..utils.misc import empty_instances
+from .standard_roi_head import StandardRoIHead
+
+
+@MODELS.register_module()
+class MaskScoringRoIHead(StandardRoIHead):
+    """Mask Scoring RoIHead for `Mask Scoring RCNN.
+
+    `_.
+
+    Args:
+        mask_iou_head (:obj`ConfigDict`, dict): The config of mask_iou_head.
+    """
+
+    def __init__(self, mask_iou_head: ConfigType, **kwargs):
+        assert mask_iou_head is not None
+        super().__init__(**kwargs)
+        self.mask_iou_head = MODELS.build(mask_iou_head)
+
+    def forward(self,
+                x: Tuple[Tensor],
+                rpn_results_list: InstanceList,
+                batch_data_samples: SampleList = None) -> tuple:
+        """Network forward process. Usually includes backbone, neck and head
+        forward without any post-processing.
+
+        Args:
+            x (List[Tensor]): Multi-level features that may have different
+                resolutions.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals.
+            batch_data_samples (list[:obj:`DetDataSample`]): Each item contains
+            the meta information of each image and corresponding
+            annotations.
+
+        Returns
+            tuple: A tuple of features from ``bbox_head`` and ``mask_head``
+            forward.
+        """
+        results = ()
+        proposals = [rpn_results.bboxes for rpn_results in rpn_results_list]
+        rois = bbox2roi(proposals)
+        # bbox head
+        if self.with_bbox:
+            bbox_results = self._bbox_forward(x, rois)
+            results = results + (bbox_results['cls_score'],
+                                 bbox_results['bbox_pred'])
+        # mask head
+        if self.with_mask:
+            mask_rois = rois[:100]
+            mask_results = self._mask_forward(x, mask_rois)
+            results = results + (mask_results['mask_preds'], )
+
+            # mask iou head
+            cls_score = bbox_results['cls_score'][:100]
+            mask_preds = mask_results['mask_preds']
+            mask_feats = mask_results['mask_feats']
+            _, labels = cls_score[:, :self.bbox_head.num_classes].max(dim=1)
+            mask_iou_preds = self.mask_iou_head(
+                mask_feats, mask_preds[range(labels.size(0)), labels])
+            results = results + (mask_iou_preds, )
+
+        return results
+
+    def mask_loss(self, x: Tuple[Tensor],
+                  sampling_results: List[SamplingResult], bbox_feats,
+                  batch_gt_instances: InstanceList) -> dict:
+        """Perform forward propagation and loss calculation of the mask head on
+        the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Tuple of multi-level img features.
+            sampling_results (list["obj:`SamplingResult`]): Sampling results.
+            bbox_feats (Tensor): Extract bbox RoI features.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes``, ``labels``, and
+                ``masks`` attributes.
+
+        Returns:
+            dict: Usually returns a dictionary with keys:
+
+                - `mask_preds` (Tensor): Mask prediction.
+                - `mask_feats` (Tensor): Extract mask RoI features.
+                - `mask_targets` (Tensor): Mask target of each positive\
+                    proposals in the image.
+                - `loss_mask` (dict): A dictionary of mask loss components.
+                - `loss_mask_iou` (Tensor): mask iou loss.
+        """
+        if not self.share_roi_extractor:
+            pos_rois = bbox2roi([res.pos_priors for res in sampling_results])
+            mask_results = self._mask_forward(x, pos_rois)
+        else:
+            pos_inds = []
+            device = bbox_feats.device
+            for res in sampling_results:
+                pos_inds.append(
+                    torch.ones(
+                        res.pos_priors.shape[0],
+                        device=device,
+                        dtype=torch.uint8))
+                pos_inds.append(
+                    torch.zeros(
+                        res.neg_priors.shape[0],
+                        device=device,
+                        dtype=torch.uint8))
+            pos_inds = torch.cat(pos_inds)
+
+            mask_results = self._mask_forward(
+                x, pos_inds=pos_inds, bbox_feats=bbox_feats)
+
+        mask_loss_and_target = self.mask_head.loss_and_target(
+            mask_preds=mask_results['mask_preds'],
+            sampling_results=sampling_results,
+            batch_gt_instances=batch_gt_instances,
+            rcnn_train_cfg=self.train_cfg)
+        mask_targets = mask_loss_and_target['mask_targets']
+        mask_results.update(loss_mask=mask_loss_and_target['loss_mask'])
+        if mask_results['loss_mask'] is None:
+            return mask_results
+
+        # mask iou head forward and loss
+        pos_labels = torch.cat([res.pos_gt_labels for res in sampling_results])
+        pos_mask_pred = mask_results['mask_preds'][
+            range(mask_results['mask_preds'].size(0)), pos_labels]
+        mask_iou_pred = self.mask_iou_head(mask_results['mask_feats'],
+                                           pos_mask_pred)
+        pos_mask_iou_pred = mask_iou_pred[range(mask_iou_pred.size(0)),
+                                          pos_labels]
+
+        loss_mask_iou = self.mask_iou_head.loss_and_target(
+            pos_mask_iou_pred, pos_mask_pred, mask_targets, sampling_results,
+            batch_gt_instances, self.train_cfg)
+        mask_results['loss_mask'].update(loss_mask_iou)
+        return mask_results
+
+    def predict_mask(self,
+                     x: Tensor,
+                     batch_img_metas: List[dict],
+                     results_list: InstanceList,
+                     rescale: bool = False) -> InstanceList:
+        """Perform forward propagation of the mask head and predict detection
+        results on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Feature maps of all scale level.
+            batch_img_metas (list[dict]): List of image information.
+            results_list (list[:obj:`InstanceData`]): Detection results of
+                each image.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+                - masks (Tensor): Has a shape (num_instances, H, W).
+        """
+        bboxes = [res.bboxes for res in results_list]
+        mask_rois = bbox2roi(bboxes)
+        if mask_rois.shape[0] == 0:
+            results_list = empty_instances(
+                batch_img_metas,
+                mask_rois.device,
+                task_type='mask',
+                instance_results=results_list,
+                mask_thr_binary=self.test_cfg.mask_thr_binary)
+            return results_list
+
+        mask_results = self._mask_forward(x, mask_rois)
+        mask_preds = mask_results['mask_preds']
+        mask_feats = mask_results['mask_feats']
+        # get mask scores with mask iou head
+        labels = torch.cat([res.labels for res in results_list])
+        mask_iou_preds = self.mask_iou_head(
+            mask_feats, mask_preds[range(labels.size(0)), labels])
+        # split batch mask prediction back to each image
+        num_mask_rois_per_img = [len(res) for res in results_list]
+        mask_preds = mask_preds.split(num_mask_rois_per_img, 0)
+        mask_iou_preds = mask_iou_preds.split(num_mask_rois_per_img, 0)
+
+        # TODO: Handle the case where rescale is false
+        results_list = self.mask_head.predict_by_feat(
+            mask_preds=mask_preds,
+            results_list=results_list,
+            batch_img_metas=batch_img_metas,
+            rcnn_test_cfg=self.test_cfg,
+            rescale=rescale)
+        results_list = self.mask_iou_head.predict_by_feat(
+            mask_iou_preds=mask_iou_preds, results_list=results_list)
+        return results_list
diff --git a/mmdetection/mmdet/models/roi_heads/multi_instance_roi_head.py b/mmdetection/mmdet/models/roi_heads/multi_instance_roi_head.py
new file mode 100644
index 00000000..fee55b0a
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/multi_instance_roi_head.py
@@ -0,0 +1,226 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple
+
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import DetDataSample
+from mmdet.structures.bbox import bbox2roi
+from mmdet.utils import ConfigType, InstanceList
+from ..task_modules.samplers import SamplingResult
+from ..utils import empty_instances, unpack_gt_instances
+from .standard_roi_head import StandardRoIHead
+
+
+@MODELS.register_module()
+class MultiInstanceRoIHead(StandardRoIHead):
+    """The roi head for Multi-instance prediction."""
+
+    def __init__(self, num_instance: int = 2, *args, **kwargs) -> None:
+        self.num_instance = num_instance
+        super().__init__(*args, **kwargs)
+
+    def init_bbox_head(self, bbox_roi_extractor: ConfigType,
+                       bbox_head: ConfigType) -> None:
+        """Initialize box head and box roi extractor.
+
+        Args:
+            bbox_roi_extractor (dict or ConfigDict): Config of box
+                roi extractor.
+            bbox_head (dict or ConfigDict): Config of box in box head.
+        """
+        self.bbox_roi_extractor = MODELS.build(bbox_roi_extractor)
+        self.bbox_head = MODELS.build(bbox_head)
+
+    def _bbox_forward(self, x: Tuple[Tensor], rois: Tensor) -> dict:
+        """Box head forward function used in both training and testing.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            rois (Tensor): RoIs with the shape (n, 5) where the first
+                column indicates batch id of each RoI.
+
+        Returns:
+             dict[str, Tensor]: Usually returns a dictionary with keys:
+
+                - `cls_score` (Tensor): Classification scores.
+                - `bbox_pred` (Tensor): Box energies / deltas.
+                - `cls_score_ref` (Tensor): The cls_score after refine model.
+                - `bbox_pred_ref` (Tensor): The bbox_pred after refine model.
+                - `bbox_feats` (Tensor): Extract bbox RoI features.
+        """
+        # TODO: a more flexible way to decide which feature maps to use
+        bbox_feats = self.bbox_roi_extractor(
+            x[:self.bbox_roi_extractor.num_inputs], rois)
+        bbox_results = self.bbox_head(bbox_feats)
+
+        if self.bbox_head.with_refine:
+            bbox_results = dict(
+                cls_score=bbox_results[0],
+                bbox_pred=bbox_results[1],
+                cls_score_ref=bbox_results[2],
+                bbox_pred_ref=bbox_results[3],
+                bbox_feats=bbox_feats)
+        else:
+            bbox_results = dict(
+                cls_score=bbox_results[0],
+                bbox_pred=bbox_results[1],
+                bbox_feats=bbox_feats)
+
+        return bbox_results
+
+    def bbox_loss(self, x: Tuple[Tensor],
+                  sampling_results: List[SamplingResult]) -> dict:
+        """Perform forward propagation and loss calculation of the bbox head on
+        the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            sampling_results (list["obj:`SamplingResult`]): Sampling results.
+
+        Returns:
+            dict[str, Tensor]: Usually returns a dictionary with keys:
+
+                - `cls_score` (Tensor): Classification scores.
+                - `bbox_pred` (Tensor): Box energies / deltas.
+                - `bbox_feats` (Tensor): Extract bbox RoI features.
+                - `loss_bbox` (dict): A dictionary of bbox loss components.
+        """
+        rois = bbox2roi([res.priors for res in sampling_results])
+        bbox_results = self._bbox_forward(x, rois)
+
+        # If there is a refining process, add refine loss.
+        if 'cls_score_ref' in bbox_results:
+            bbox_loss_and_target = self.bbox_head.loss_and_target(
+                cls_score=bbox_results['cls_score'],
+                bbox_pred=bbox_results['bbox_pred'],
+                rois=rois,
+                sampling_results=sampling_results,
+                rcnn_train_cfg=self.train_cfg)
+            bbox_results.update(loss_bbox=bbox_loss_and_target['loss_bbox'])
+            bbox_loss_and_target_ref = self.bbox_head.loss_and_target(
+                cls_score=bbox_results['cls_score_ref'],
+                bbox_pred=bbox_results['bbox_pred_ref'],
+                rois=rois,
+                sampling_results=sampling_results,
+                rcnn_train_cfg=self.train_cfg)
+            bbox_results['loss_bbox']['loss_rcnn_emd_ref'] = \
+                bbox_loss_and_target_ref['loss_bbox']['loss_rcnn_emd']
+        else:
+            bbox_loss_and_target = self.bbox_head.loss_and_target(
+                cls_score=bbox_results['cls_score'],
+                bbox_pred=bbox_results['bbox_pred'],
+                rois=rois,
+                sampling_results=sampling_results,
+                rcnn_train_cfg=self.train_cfg)
+            bbox_results.update(loss_bbox=bbox_loss_and_target['loss_bbox'])
+
+        return bbox_results
+
+    def loss(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
+             batch_data_samples: List[DetDataSample]) -> dict:
+        """Perform forward propagation and loss calculation of the detection
+        roi on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components
+        """
+        assert len(rpn_results_list) == len(batch_data_samples)
+        outputs = unpack_gt_instances(batch_data_samples)
+        batch_gt_instances, batch_gt_instances_ignore, _ = outputs
+
+        sampling_results = []
+        for i in range(len(batch_data_samples)):
+            # rename rpn_results.bboxes to rpn_results.priors
+            rpn_results = rpn_results_list[i]
+            rpn_results.priors = rpn_results.pop('bboxes')
+
+            assign_result = self.bbox_assigner.assign(
+                rpn_results, batch_gt_instances[i],
+                batch_gt_instances_ignore[i])
+            sampling_result = self.bbox_sampler.sample(
+                assign_result,
+                rpn_results,
+                batch_gt_instances[i],
+                batch_gt_instances_ignore=batch_gt_instances_ignore[i])
+            sampling_results.append(sampling_result)
+
+        losses = dict()
+        # bbox head loss
+        if self.with_bbox:
+            bbox_results = self.bbox_loss(x, sampling_results)
+            losses.update(bbox_results['loss_bbox'])
+
+        return losses
+
+    def predict_bbox(self,
+                     x: Tuple[Tensor],
+                     batch_img_metas: List[dict],
+                     rpn_results_list: InstanceList,
+                     rcnn_test_cfg: ConfigType,
+                     rescale: bool = False) -> InstanceList:
+        """Perform forward propagation of the bbox head and predict detection
+        results on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Feature maps of all scale level.
+            batch_img_metas (list[dict]): List of image information.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals.
+            rcnn_test_cfg (obj:`ConfigDict`): `test_cfg` of R-CNN.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        proposals = [res.bboxes for res in rpn_results_list]
+        rois = bbox2roi(proposals)
+
+        if rois.shape[0] == 0:
+            return empty_instances(
+                batch_img_metas, rois.device, task_type='bbox')
+
+        bbox_results = self._bbox_forward(x, rois)
+
+        # split batch bbox prediction back to each image
+        if 'cls_score_ref' in bbox_results:
+            cls_scores = bbox_results['cls_score_ref']
+            bbox_preds = bbox_results['bbox_pred_ref']
+        else:
+            cls_scores = bbox_results['cls_score']
+            bbox_preds = bbox_results['bbox_pred']
+        num_proposals_per_img = tuple(len(p) for p in proposals)
+        rois = rois.split(num_proposals_per_img, 0)
+        cls_scores = cls_scores.split(num_proposals_per_img, 0)
+
+        if bbox_preds is not None:
+            bbox_preds = bbox_preds.split(num_proposals_per_img, 0)
+        else:
+            bbox_preds = (None, ) * len(proposals)
+
+        result_list = self.bbox_head.predict_by_feat(
+            rois=rois,
+            cls_scores=cls_scores,
+            bbox_preds=bbox_preds,
+            batch_img_metas=batch_img_metas,
+            rcnn_test_cfg=rcnn_test_cfg,
+            rescale=rescale)
+        return result_list
diff --git a/mmdetection/mmdet/models/roi_heads/pisa_roi_head.py b/mmdetection/mmdet/models/roi_heads/pisa_roi_head.py
new file mode 100644
index 00000000..45d59879
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/pisa_roi_head.py
@@ -0,0 +1,148 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple
+
+from torch import Tensor
+
+from mmdet.models.task_modules import SamplingResult
+from mmdet.registry import MODELS
+from mmdet.structures import DetDataSample
+from mmdet.structures.bbox import bbox2roi
+from mmdet.utils import InstanceList
+from ..losses.pisa_loss import carl_loss, isr_p
+from ..utils import unpack_gt_instances
+from .standard_roi_head import StandardRoIHead
+
+
+@MODELS.register_module()
+class PISARoIHead(StandardRoIHead):
+    r"""The RoI head for `Prime Sample Attention in Object Detection
+    `_."""
+
+    def loss(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
+             batch_data_samples: List[DetDataSample]) -> dict:
+        """Perform forward propagation and loss calculation of the detection
+        roi on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components
+        """
+        assert len(rpn_results_list) == len(batch_data_samples)
+        outputs = unpack_gt_instances(batch_data_samples)
+        batch_gt_instances, batch_gt_instances_ignore, _ = outputs
+
+        # assign gts and sample proposals
+        num_imgs = len(batch_data_samples)
+        sampling_results = []
+        neg_label_weights = []
+        for i in range(num_imgs):
+            # rename rpn_results.bboxes to rpn_results.priors
+            rpn_results = rpn_results_list[i]
+            rpn_results.priors = rpn_results.pop('bboxes')
+
+            assign_result = self.bbox_assigner.assign(
+                rpn_results, batch_gt_instances[i],
+                batch_gt_instances_ignore[i])
+            sampling_result = self.bbox_sampler.sample(
+                assign_result,
+                rpn_results,
+                batch_gt_instances[i],
+                feats=[lvl_feat[i][None] for lvl_feat in x])
+            if isinstance(sampling_result, tuple):
+                sampling_result, neg_label_weight = sampling_result
+            sampling_results.append(sampling_result)
+            neg_label_weights.append(neg_label_weight)
+
+        losses = dict()
+        # bbox head forward and loss
+        if self.with_bbox:
+            bbox_results = self.bbox_loss(
+                x, sampling_results, neg_label_weights=neg_label_weights)
+            losses.update(bbox_results['loss_bbox'])
+
+        # mask head forward and loss
+        if self.with_mask:
+            mask_results = self.mask_loss(x, sampling_results,
+                                          bbox_results['bbox_feats'],
+                                          batch_gt_instances)
+            losses.update(mask_results['loss_mask'])
+
+        return losses
+
+    def bbox_loss(self,
+                  x: Tuple[Tensor],
+                  sampling_results: List[SamplingResult],
+                  neg_label_weights: List[Tensor] = None) -> dict:
+        """Perform forward propagation and loss calculation of the bbox head on
+        the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            sampling_results (list["obj:`SamplingResult`]): Sampling results.
+
+        Returns:
+            dict[str, Tensor]: Usually returns a dictionary with keys:
+
+            - `cls_score` (Tensor): Classification scores.
+            - `bbox_pred` (Tensor): Box energies / deltas.
+            - `bbox_feats` (Tensor): Extract bbox RoI features.
+            - `loss_bbox` (dict): A dictionary of bbox loss components.
+        """
+        rois = bbox2roi([res.priors for res in sampling_results])
+        bbox_results = self._bbox_forward(x, rois)
+        bbox_targets = self.bbox_head.get_targets(sampling_results,
+                                                  self.train_cfg)
+
+        # neg_label_weights obtained by sampler is image-wise, mapping back to
+        # the corresponding location in label weights
+        if neg_label_weights[0] is not None:
+            label_weights = bbox_targets[1]
+            cur_num_rois = 0
+            for i in range(len(sampling_results)):
+                num_pos = sampling_results[i].pos_inds.size(0)
+                num_neg = sampling_results[i].neg_inds.size(0)
+                label_weights[cur_num_rois + num_pos:cur_num_rois + num_pos +
+                              num_neg] = neg_label_weights[i]
+                cur_num_rois += num_pos + num_neg
+
+        cls_score = bbox_results['cls_score']
+        bbox_pred = bbox_results['bbox_pred']
+
+        # Apply ISR-P
+        isr_cfg = self.train_cfg.get('isr', None)
+        if isr_cfg is not None:
+            bbox_targets = isr_p(
+                cls_score,
+                bbox_pred,
+                bbox_targets,
+                rois,
+                sampling_results,
+                self.bbox_head.loss_cls,
+                self.bbox_head.bbox_coder,
+                **isr_cfg,
+                num_class=self.bbox_head.num_classes)
+        loss_bbox = self.bbox_head.loss(cls_score, bbox_pred, rois,
+                                        *bbox_targets)
+
+        # Add CARL Loss
+        carl_cfg = self.train_cfg.get('carl', None)
+        if carl_cfg is not None:
+            loss_carl = carl_loss(
+                cls_score,
+                bbox_targets[0],
+                bbox_pred,
+                bbox_targets[2],
+                self.bbox_head.loss_bbox,
+                **carl_cfg,
+                num_class=self.bbox_head.num_classes)
+            loss_bbox.update(loss_carl)
+
+        bbox_results.update(loss_bbox=loss_bbox)
+        return bbox_results
diff --git a/mmdetection/mmdet/models/roi_heads/point_rend_roi_head.py b/mmdetection/mmdet/models/roi_heads/point_rend_roi_head.py
new file mode 100644
index 00000000..6a064154
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/point_rend_roi_head.py
@@ -0,0 +1,236 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# Modified from https://github.com/facebookresearch/detectron2/tree/master/projects/PointRend  # noqa
+from typing import List, Tuple
+
+import torch
+import torch.nn.functional as F
+from mmcv.ops import point_sample, rel_roi_point_to_rel_img_point
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures.bbox import bbox2roi
+from mmdet.utils import ConfigType, InstanceList
+from ..task_modules.samplers import SamplingResult
+from ..utils import empty_instances
+from .standard_roi_head import StandardRoIHead
+
+
+@MODELS.register_module()
+class PointRendRoIHead(StandardRoIHead):
+    """`PointRend `_."""
+
+    def __init__(self, point_head: ConfigType, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        assert self.with_bbox and self.with_mask
+        self.init_point_head(point_head)
+
+    def init_point_head(self, point_head: ConfigType) -> None:
+        """Initialize ``point_head``"""
+        self.point_head = MODELS.build(point_head)
+
+    def mask_loss(self, x: Tuple[Tensor],
+                  sampling_results: List[SamplingResult], bbox_feats: Tensor,
+                  batch_gt_instances: InstanceList) -> dict:
+        """Run forward function and calculate loss for mask head and point head
+        in training."""
+        mask_results = super().mask_loss(
+            x=x,
+            sampling_results=sampling_results,
+            bbox_feats=bbox_feats,
+            batch_gt_instances=batch_gt_instances)
+
+        mask_point_results = self._mask_point_loss(
+            x=x,
+            sampling_results=sampling_results,
+            mask_preds=mask_results['mask_preds'],
+            batch_gt_instances=batch_gt_instances)
+        mask_results['loss_mask'].update(
+            loss_point=mask_point_results['loss_point'])
+
+        return mask_results
+
+    def _mask_point_loss(self, x: Tuple[Tensor],
+                         sampling_results: List[SamplingResult],
+                         mask_preds: Tensor,
+                         batch_gt_instances: InstanceList) -> dict:
+        """Run forward function and calculate loss for point head in
+        training."""
+        pos_labels = torch.cat([res.pos_gt_labels for res in sampling_results])
+        rel_roi_points = self.point_head.get_roi_rel_points_train(
+            mask_preds, pos_labels, cfg=self.train_cfg)
+        rois = bbox2roi([res.pos_bboxes for res in sampling_results])
+
+        fine_grained_point_feats = self._get_fine_grained_point_feats(
+            x, rois, rel_roi_points)
+        coarse_point_feats = point_sample(mask_preds, rel_roi_points)
+        mask_point_pred = self.point_head(fine_grained_point_feats,
+                                          coarse_point_feats)
+
+        loss_and_target = self.point_head.loss_and_target(
+            point_pred=mask_point_pred,
+            rel_roi_points=rel_roi_points,
+            sampling_results=sampling_results,
+            batch_gt_instances=batch_gt_instances,
+            cfg=self.train_cfg)
+
+        return loss_and_target
+
+    def _mask_point_forward_test(self, x: Tuple[Tensor], rois: Tensor,
+                                 label_preds: Tensor,
+                                 mask_preds: Tensor) -> Tensor:
+        """Mask refining process with point head in testing.
+
+        Args:
+            x (tuple[Tensor]): Feature maps of all scale level.
+            rois (Tensor): shape (num_rois, 5).
+            label_preds (Tensor): The predication class for each rois.
+            mask_preds (Tensor): The predication coarse masks of
+                shape (num_rois, num_classes, small_size, small_size).
+
+        Returns:
+            Tensor: The refined masks of shape (num_rois, num_classes,
+            large_size, large_size).
+        """
+        refined_mask_pred = mask_preds.clone()
+        for subdivision_step in range(self.test_cfg.subdivision_steps):
+            refined_mask_pred = F.interpolate(
+                refined_mask_pred,
+                scale_factor=self.test_cfg.scale_factor,
+                mode='bilinear',
+                align_corners=False)
+            # If `subdivision_num_points` is larger or equal to the
+            # resolution of the next step, then we can skip this step
+            num_rois, channels, mask_height, mask_width = \
+                refined_mask_pred.shape
+            if (self.test_cfg.subdivision_num_points >=
+                    self.test_cfg.scale_factor**2 * mask_height * mask_width
+                    and
+                    subdivision_step < self.test_cfg.subdivision_steps - 1):
+                continue
+            point_indices, rel_roi_points = \
+                self.point_head.get_roi_rel_points_test(
+                    refined_mask_pred, label_preds, cfg=self.test_cfg)
+
+            fine_grained_point_feats = self._get_fine_grained_point_feats(
+                x=x, rois=rois, rel_roi_points=rel_roi_points)
+            coarse_point_feats = point_sample(mask_preds, rel_roi_points)
+            mask_point_pred = self.point_head(fine_grained_point_feats,
+                                              coarse_point_feats)
+
+            point_indices = point_indices.unsqueeze(1).expand(-1, channels, -1)
+            refined_mask_pred = refined_mask_pred.reshape(
+                num_rois, channels, mask_height * mask_width)
+            refined_mask_pred = refined_mask_pred.scatter_(
+                2, point_indices, mask_point_pred)
+            refined_mask_pred = refined_mask_pred.view(num_rois, channels,
+                                                       mask_height, mask_width)
+
+        return refined_mask_pred
+
+    def _get_fine_grained_point_feats(self, x: Tuple[Tensor], rois: Tensor,
+                                      rel_roi_points: Tensor) -> Tensor:
+        """Sample fine grained feats from each level feature map and
+        concatenate them together.
+
+        Args:
+            x (tuple[Tensor]): Feature maps of all scale level.
+            rois (Tensor): shape (num_rois, 5).
+            rel_roi_points (Tensor): A tensor of shape (num_rois, num_points,
+                2) that contains [0, 1] x [0, 1] normalized coordinates of the
+                most uncertain points from the [mask_height, mask_width] grid.
+
+        Returns:
+            Tensor: The fine grained features for each points,
+            has shape (num_rois, feats_channels, num_points).
+        """
+        assert rois.shape[0] > 0, 'RoI is a empty tensor.'
+        num_imgs = x[0].shape[0]
+        fine_grained_feats = []
+        for idx in range(self.mask_roi_extractor.num_inputs):
+            feats = x[idx]
+            spatial_scale = 1. / float(
+                self.mask_roi_extractor.featmap_strides[idx])
+            point_feats = []
+            for batch_ind in range(num_imgs):
+                # unravel batch dim
+                feat = feats[batch_ind].unsqueeze(0)
+                inds = (rois[:, 0].long() == batch_ind)
+                if inds.any():
+                    rel_img_points = rel_roi_point_to_rel_img_point(
+                        rois=rois[inds],
+                        rel_roi_points=rel_roi_points[inds],
+                        img=feat.shape[2:],
+                        spatial_scale=spatial_scale).unsqueeze(0)
+                    point_feat = point_sample(feat, rel_img_points)
+                    point_feat = point_feat.squeeze(0).transpose(0, 1)
+                    point_feats.append(point_feat)
+            fine_grained_feats.append(torch.cat(point_feats, dim=0))
+        return torch.cat(fine_grained_feats, dim=1)
+
+    def predict_mask(self,
+                     x: Tuple[Tensor],
+                     batch_img_metas: List[dict],
+                     results_list: InstanceList,
+                     rescale: bool = False) -> InstanceList:
+        """Perform forward propagation of the mask head and predict detection
+        results on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Feature maps of all scale level.
+            batch_img_metas (list[dict]): List of image information.
+            results_list (list[:obj:`InstanceData`]): Detection results of
+                each image.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+            - scores (Tensor): Classification scores, has a shape
+              (num_instance, )
+            - labels (Tensor): Labels of bboxes, has a shape
+              (num_instances, ).
+            - bboxes (Tensor): Has a shape (num_instances, 4),
+              the last dimension 4 arrange as (x1, y1, x2, y2).
+            - masks (Tensor): Has a shape (num_instances, H, W).
+        """
+        # don't need to consider aug_test.
+        bboxes = [res.bboxes for res in results_list]
+        mask_rois = bbox2roi(bboxes)
+        if mask_rois.shape[0] == 0:
+            results_list = empty_instances(
+                batch_img_metas,
+                mask_rois.device,
+                task_type='mask',
+                instance_results=results_list,
+                mask_thr_binary=self.test_cfg.mask_thr_binary)
+            return results_list
+
+        mask_results = self._mask_forward(x, mask_rois)
+        mask_preds = mask_results['mask_preds']
+        # split batch mask prediction back to each image
+        num_mask_rois_per_img = [len(res) for res in results_list]
+        mask_preds = mask_preds.split(num_mask_rois_per_img, 0)
+
+        # refine mask_preds
+        mask_rois = mask_rois.split(num_mask_rois_per_img, 0)
+        mask_preds_refined = []
+        for i in range(len(batch_img_metas)):
+            labels = results_list[i].labels
+            x_i = [xx[[i]] for xx in x]
+            mask_rois_i = mask_rois[i]
+            mask_rois_i[:, 0] = 0
+            mask_pred_i = self._mask_point_forward_test(
+                x_i, mask_rois_i, labels, mask_preds[i])
+            mask_preds_refined.append(mask_pred_i)
+
+        # TODO: Handle the case where rescale is false
+        results_list = self.mask_head.predict_by_feat(
+            mask_preds=mask_preds_refined,
+            results_list=results_list,
+            batch_img_metas=batch_img_metas,
+            rcnn_test_cfg=self.test_cfg,
+            rescale=rescale)
+        return results_list
diff --git a/mmdetection/mmdet/models/roi_heads/roi_extractors/__init__.py b/mmdetection/mmdet/models/roi_heads/roi_extractors/__init__.py
new file mode 100644
index 00000000..0f602149
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/roi_extractors/__init__.py
@@ -0,0 +1,6 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .base_roi_extractor import BaseRoIExtractor
+from .generic_roi_extractor import GenericRoIExtractor
+from .single_level_roi_extractor import SingleRoIExtractor
+
+__all__ = ['BaseRoIExtractor', 'SingleRoIExtractor', 'GenericRoIExtractor']
diff --git a/mmdetection/mmdet/models/roi_heads/roi_extractors/base_roi_extractor.py b/mmdetection/mmdet/models/roi_heads/roi_extractors/base_roi_extractor.py
new file mode 100644
index 00000000..a8de0518
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/roi_extractors/base_roi_extractor.py
@@ -0,0 +1,111 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from abc import ABCMeta, abstractmethod
+from typing import List, Optional, Tuple
+
+import torch
+import torch.nn as nn
+from mmcv import ops
+from mmengine.model import BaseModule
+from torch import Tensor
+
+from mmdet.utils import ConfigType, OptMultiConfig
+
+
+class BaseRoIExtractor(BaseModule, metaclass=ABCMeta):
+    """Base class for RoI extractor.
+
+    Args:
+        roi_layer (:obj:`ConfigDict` or dict): Specify RoI layer type and
+            arguments.
+        out_channels (int): Output channels of RoI layers.
+        featmap_strides (list[int]): Strides of input feature maps.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict], optional): Initialization config dict. Defaults to None.
+    """
+
+    def __init__(self,
+                 roi_layer: ConfigType,
+                 out_channels: int,
+                 featmap_strides: List[int],
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.roi_layers = self.build_roi_layers(roi_layer, featmap_strides)
+        self.out_channels = out_channels
+        self.featmap_strides = featmap_strides
+
+    @property
+    def num_inputs(self) -> int:
+        """int: Number of input feature maps."""
+        return len(self.featmap_strides)
+
+    def build_roi_layers(self, layer_cfg: ConfigType,
+                         featmap_strides: List[int]) -> nn.ModuleList:
+        """Build RoI operator to extract feature from each level feature map.
+
+        Args:
+            layer_cfg (:obj:`ConfigDict` or dict): Dictionary to construct and
+                config RoI layer operation. Options are modules under
+                ``mmcv/ops`` such as ``RoIAlign``.
+            featmap_strides (list[int]): The stride of input feature map w.r.t
+                to the original image size, which would be used to scale RoI
+                coordinate (original image coordinate system) to feature
+                coordinate system.
+
+        Returns:
+            :obj:`nn.ModuleList`: The RoI extractor modules for each level
+                feature map.
+        """
+
+        cfg = layer_cfg.copy()
+        layer_type = cfg.pop('type')
+        if isinstance(layer_type, str):
+            assert hasattr(ops, layer_type)
+            layer_cls = getattr(ops, layer_type)
+        else:
+            layer_cls = layer_type
+        roi_layers = nn.ModuleList(
+            [layer_cls(spatial_scale=1 / s, **cfg) for s in featmap_strides])
+        return roi_layers
+
+    def roi_rescale(self, rois: Tensor, scale_factor: float) -> Tensor:
+        """Scale RoI coordinates by scale factor.
+
+        Args:
+            rois (Tensor): RoI (Region of Interest), shape (n, 5)
+            scale_factor (float): Scale factor that RoI will be multiplied by.
+
+        Returns:
+            Tensor: Scaled RoI.
+        """
+
+        cx = (rois[:, 1] + rois[:, 3]) * 0.5
+        cy = (rois[:, 2] + rois[:, 4]) * 0.5
+        w = rois[:, 3] - rois[:, 1]
+        h = rois[:, 4] - rois[:, 2]
+        new_w = w * scale_factor
+        new_h = h * scale_factor
+        x1 = cx - new_w * 0.5
+        x2 = cx + new_w * 0.5
+        y1 = cy - new_h * 0.5
+        y2 = cy + new_h * 0.5
+        new_rois = torch.stack((rois[:, 0], x1, y1, x2, y2), dim=-1)
+        return new_rois
+
+    @abstractmethod
+    def forward(self,
+                feats: Tuple[Tensor],
+                rois: Tensor,
+                roi_scale_factor: Optional[float] = None) -> Tensor:
+        """Extractor ROI feats.
+
+        Args:
+            feats (Tuple[Tensor]): Multi-scale features.
+            rois (Tensor): RoIs with the shape (n, 5) where the first
+                column indicates batch id of each RoI.
+            roi_scale_factor (Optional[float]): RoI scale factor.
+                Defaults to None.
+
+        Returns:
+            Tensor: RoI feature.
+        """
+        pass
diff --git a/mmdetection/mmdet/models/roi_heads/roi_extractors/generic_roi_extractor.py b/mmdetection/mmdet/models/roi_heads/roi_extractors/generic_roi_extractor.py
new file mode 100644
index 00000000..39d4c901
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/roi_extractors/generic_roi_extractor.py
@@ -0,0 +1,102 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Tuple
+
+from mmcv.cnn.bricks import build_plugin_layer
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import OptConfigType
+from .base_roi_extractor import BaseRoIExtractor
+
+
+@MODELS.register_module()
+class GenericRoIExtractor(BaseRoIExtractor):
+    """Extract RoI features from all level feature maps levels.
+
+    This is the implementation of `A novel Region of Interest Extraction Layer
+    for Instance Segmentation `_.
+
+    Args:
+        aggregation (str): The method to aggregate multiple feature maps.
+            Options are 'sum', 'concat'. Defaults to 'sum'.
+        pre_cfg (:obj:`ConfigDict` or dict): Specify pre-processing modules.
+            Defaults to None.
+        post_cfg (:obj:`ConfigDict` or dict): Specify post-processing modules.
+            Defaults to None.
+        kwargs (keyword arguments): Arguments that are the same
+            as :class:`BaseRoIExtractor`.
+    """
+
+    def __init__(self,
+                 aggregation: str = 'sum',
+                 pre_cfg: OptConfigType = None,
+                 post_cfg: OptConfigType = None,
+                 **kwargs) -> None:
+        super().__init__(**kwargs)
+
+        assert aggregation in ['sum', 'concat']
+
+        self.aggregation = aggregation
+        self.with_post = post_cfg is not None
+        self.with_pre = pre_cfg is not None
+        # build pre/post processing modules
+        if self.with_post:
+            self.post_module = build_plugin_layer(post_cfg, '_post_module')[1]
+        if self.with_pre:
+            self.pre_module = build_plugin_layer(pre_cfg, '_pre_module')[1]
+
+    def forward(self,
+                feats: Tuple[Tensor],
+                rois: Tensor,
+                roi_scale_factor: Optional[float] = None) -> Tensor:
+        """Extractor ROI feats.
+
+        Args:
+            feats (Tuple[Tensor]): Multi-scale features.
+            rois (Tensor): RoIs with the shape (n, 5) where the first
+                column indicates batch id of each RoI.
+            roi_scale_factor (Optional[float]): RoI scale factor.
+                Defaults to None.
+
+        Returns:
+            Tensor: RoI feature.
+        """
+        out_size = self.roi_layers[0].output_size
+        num_levels = len(feats)
+        roi_feats = feats[0].new_zeros(
+            rois.size(0), self.out_channels, *out_size)
+
+        # some times rois is an empty tensor
+        if roi_feats.shape[0] == 0:
+            return roi_feats
+
+        if num_levels == 1:
+            return self.roi_layers[0](feats[0], rois)
+
+        if roi_scale_factor is not None:
+            rois = self.roi_rescale(rois, roi_scale_factor)
+
+        # mark the starting channels for concat mode
+        start_channels = 0
+        for i in range(num_levels):
+            roi_feats_t = self.roi_layers[i](feats[i], rois)
+            end_channels = start_channels + roi_feats_t.size(1)
+            if self.with_pre:
+                # apply pre-processing to a RoI extracted from each layer
+                roi_feats_t = self.pre_module(roi_feats_t)
+            if self.aggregation == 'sum':
+                # and sum them all
+                roi_feats += roi_feats_t
+            else:
+                # and concat them along channel dimension
+                roi_feats[:, start_channels:end_channels] = roi_feats_t
+            # update channels starting position
+            start_channels = end_channels
+        # check if concat channels match at the end
+        if self.aggregation == 'concat':
+            assert start_channels == self.out_channels
+
+        if self.with_post:
+            # apply post-processing before return the result
+            roi_feats = self.post_module(roi_feats)
+        return roi_feats
diff --git a/mmdetection/mmdet/models/roi_heads/roi_extractors/single_level_roi_extractor.py b/mmdetection/mmdet/models/roi_heads/roi_extractors/single_level_roi_extractor.py
new file mode 100644
index 00000000..59229e0b
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/roi_extractors/single_level_roi_extractor.py
@@ -0,0 +1,119 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Tuple
+
+import torch
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptMultiConfig
+from .base_roi_extractor import BaseRoIExtractor
+
+
+@MODELS.register_module()
+class SingleRoIExtractor(BaseRoIExtractor):
+    """Extract RoI features from a single level feature map.
+
+    If there are multiple input feature levels, each RoI is mapped to a level
+    according to its scale. The mapping rule is proposed in
+    `FPN `_.
+
+    Args:
+        roi_layer (:obj:`ConfigDict` or dict): Specify RoI layer type and
+            arguments.
+        out_channels (int): Output channels of RoI layers.
+        featmap_strides (List[int]): Strides of input feature maps.
+        finest_scale (int): Scale threshold of mapping to level 0.
+            Defaults to 56.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict], optional): Initialization config dict. Defaults to None.
+    """
+
+    def __init__(self,
+                 roi_layer: ConfigType,
+                 out_channels: int,
+                 featmap_strides: List[int],
+                 finest_scale: int = 56,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            roi_layer=roi_layer,
+            out_channels=out_channels,
+            featmap_strides=featmap_strides,
+            init_cfg=init_cfg)
+        self.finest_scale = finest_scale
+
+    def map_roi_levels(self, rois: Tensor, num_levels: int) -> Tensor:
+        """Map rois to corresponding feature levels by scales.
+
+        - scale < finest_scale * 2: level 0
+        - finest_scale * 2 <= scale < finest_scale * 4: level 1
+        - finest_scale * 4 <= scale < finest_scale * 8: level 2
+        - scale >= finest_scale * 8: level 3
+
+        Args:
+            rois (Tensor): Input RoIs, shape (k, 5).
+            num_levels (int): Total level number.
+
+        Returns:
+            Tensor: Level index (0-based) of each RoI, shape (k, )
+        """
+        scale = torch.sqrt(
+            (rois[:, 3] - rois[:, 1]) * (rois[:, 4] - rois[:, 2]))
+        target_lvls = torch.floor(torch.log2(scale / self.finest_scale + 1e-6))
+        target_lvls = target_lvls.clamp(min=0, max=num_levels - 1).long()
+        return target_lvls
+
+    def forward(self,
+                feats: Tuple[Tensor],
+                rois: Tensor,
+                roi_scale_factor: Optional[float] = None):
+        """Extractor ROI feats.
+
+        Args:
+            feats (Tuple[Tensor]): Multi-scale features.
+            rois (Tensor): RoIs with the shape (n, 5) where the first
+                column indicates batch id of each RoI.
+            roi_scale_factor (Optional[float]): RoI scale factor.
+                Defaults to None.
+
+        Returns:
+            Tensor: RoI feature.
+        """
+        # convert fp32 to fp16 when amp is on
+        rois = rois.type_as(feats[0])
+        out_size = self.roi_layers[0].output_size
+        num_levels = len(feats)
+        roi_feats = feats[0].new_zeros(
+            rois.size(0), self.out_channels, *out_size)
+
+        # TODO: remove this when parrots supports
+        if torch.__version__ == 'parrots':
+            roi_feats.requires_grad = True
+
+        if num_levels == 1:
+            if len(rois) == 0:
+                return roi_feats
+            return self.roi_layers[0](feats[0], rois)
+
+        target_lvls = self.map_roi_levels(rois, num_levels)
+
+        if roi_scale_factor is not None:
+            rois = self.roi_rescale(rois, roi_scale_factor)
+
+        for i in range(num_levels):
+            mask = target_lvls == i
+            inds = mask.nonzero(as_tuple=False).squeeze(1)
+            if inds.numel() > 0:
+                rois_ = rois[inds]
+                roi_feats_t = self.roi_layers[i](feats[i], rois_)
+                roi_feats[inds] = roi_feats_t
+            else:
+                # Sometimes some pyramid levels will not be used for RoI
+                # feature extraction and this will cause an incomplete
+                # computation graph in one GPU, which is different from those
+                # in other GPUs and will cause a hanging error.
+                # Therefore, we add it to ensure each feature pyramid is
+                # included in the computation graph to avoid runtime bugs.
+                roi_feats += sum(
+                    x.view(-1)[0]
+                    for x in self.parameters()) * 0. + feats[i].sum() * 0.
+        return roi_feats
diff --git a/mmdetection/mmdet/models/roi_heads/scnet_roi_head.py b/mmdetection/mmdet/models/roi_heads/scnet_roi_head.py
new file mode 100644
index 00000000..e6d2bc19
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/scnet_roi_head.py
@@ -0,0 +1,677 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Tuple
+
+import torch
+import torch.nn.functional as F
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.structures.bbox import bbox2roi
+from mmdet.utils import ConfigType, InstanceList, OptConfigType
+from ..layers import adaptive_avg_pool2d
+from ..task_modules.samplers import SamplingResult
+from ..utils import empty_instances, unpack_gt_instances
+from .cascade_roi_head import CascadeRoIHead
+
+
+@MODELS.register_module()
+class SCNetRoIHead(CascadeRoIHead):
+    """RoIHead for `SCNet `_.
+
+    Args:
+        num_stages (int): number of cascade stages.
+        stage_loss_weights (list): loss weight of cascade stages.
+        semantic_roi_extractor (dict): config to init semantic roi extractor.
+        semantic_head (dict): config to init semantic head.
+        feat_relay_head (dict): config to init feature_relay_head.
+        glbctx_head (dict): config to init global context head.
+    """
+
+    def __init__(self,
+                 num_stages: int,
+                 stage_loss_weights: List[float],
+                 semantic_roi_extractor: OptConfigType = None,
+                 semantic_head: OptConfigType = None,
+                 feat_relay_head: OptConfigType = None,
+                 glbctx_head: OptConfigType = None,
+                 **kwargs) -> None:
+        super().__init__(
+            num_stages=num_stages,
+            stage_loss_weights=stage_loss_weights,
+            **kwargs)
+        assert self.with_bbox and self.with_mask
+        assert not self.with_shared_head  # shared head is not supported
+
+        if semantic_head is not None:
+            self.semantic_roi_extractor = MODELS.build(semantic_roi_extractor)
+            self.semantic_head = MODELS.build(semantic_head)
+
+        if feat_relay_head is not None:
+            self.feat_relay_head = MODELS.build(feat_relay_head)
+
+        if glbctx_head is not None:
+            self.glbctx_head = MODELS.build(glbctx_head)
+
+    def init_mask_head(self, mask_roi_extractor: ConfigType,
+                       mask_head: ConfigType) -> None:
+        """Initialize ``mask_head``"""
+        if mask_roi_extractor is not None:
+            self.mask_roi_extractor = MODELS.build(mask_roi_extractor)
+            self.mask_head = MODELS.build(mask_head)
+
+    # TODO move to base_roi_head later
+    @property
+    def with_semantic(self) -> bool:
+        """bool: whether the head has semantic head"""
+        return hasattr(self,
+                       'semantic_head') and self.semantic_head is not None
+
+    @property
+    def with_feat_relay(self) -> bool:
+        """bool: whether the head has feature relay head"""
+        return (hasattr(self, 'feat_relay_head')
+                and self.feat_relay_head is not None)
+
+    @property
+    def with_glbctx(self) -> bool:
+        """bool: whether the head has global context head"""
+        return hasattr(self, 'glbctx_head') and self.glbctx_head is not None
+
+    def _fuse_glbctx(self, roi_feats: Tensor, glbctx_feat: Tensor,
+                     rois: Tensor) -> Tensor:
+        """Fuse global context feats with roi feats.
+
+        Args:
+            roi_feats (Tensor): RoI features.
+            glbctx_feat (Tensor): Global context feature..
+            rois (Tensor): RoIs with the shape (n, 5) where the first
+                column indicates batch id of each RoI.
+
+        Returns:
+            Tensor: Fused feature.
+        """
+        assert roi_feats.size(0) == rois.size(0)
+        # RuntimeError: isDifferentiableType(variable.scalar_type())
+        # INTERNAL ASSERT FAILED if detach() is not used when calling
+        # roi_head.predict().
+        img_inds = torch.unique(rois[:, 0].detach().cpu(), sorted=True).long()
+        fused_feats = torch.zeros_like(roi_feats)
+        for img_id in img_inds:
+            inds = (rois[:, 0] == img_id.item())
+            fused_feats[inds] = roi_feats[inds] + glbctx_feat[img_id]
+        return fused_feats
+
+    def _slice_pos_feats(self, feats: Tensor,
+                         sampling_results: List[SamplingResult]) -> Tensor:
+        """Get features from pos rois.
+
+        Args:
+            feats (Tensor): Input features.
+            sampling_results (list["obj:`SamplingResult`]): Sampling results.
+
+        Returns:
+            Tensor: Sliced features.
+        """
+        num_rois = [res.priors.size(0) for res in sampling_results]
+        num_pos_rois = [res.pos_priors.size(0) for res in sampling_results]
+        inds = torch.zeros(sum(num_rois), dtype=torch.bool)
+        start = 0
+        for i in range(len(num_rois)):
+            start = 0 if i == 0 else start + num_rois[i - 1]
+            stop = start + num_pos_rois[i]
+            inds[start:stop] = 1
+        sliced_feats = feats[inds]
+        return sliced_feats
+
+    def _bbox_forward(self,
+                      stage: int,
+                      x: Tuple[Tensor],
+                      rois: Tensor,
+                      semantic_feat: Optional[Tensor] = None,
+                      glbctx_feat: Optional[Tensor] = None) -> dict:
+        """Box head forward function used in both training and testing.
+
+        Args:
+            stage (int): The current stage in Cascade RoI Head.
+            x (tuple[Tensor]): List of multi-level img features.
+            rois (Tensor): RoIs with the shape (n, 5) where the first
+                column indicates batch id of each RoI.
+            semantic_feat (Tensor): Semantic feature. Defaults to None.
+            glbctx_feat (Tensor): Global context feature. Defaults to None.
+
+        Returns:
+             dict[str, Tensor]: Usually returns a dictionary with keys:
+
+                - `cls_score` (Tensor): Classification scores.
+                - `bbox_pred` (Tensor): Box energies / deltas.
+                - `bbox_feats` (Tensor): Extract bbox RoI features.
+        """
+        bbox_roi_extractor = self.bbox_roi_extractor[stage]
+        bbox_head = self.bbox_head[stage]
+        bbox_feats = bbox_roi_extractor(x[:bbox_roi_extractor.num_inputs],
+                                        rois)
+        if self.with_semantic and semantic_feat is not None:
+            bbox_semantic_feat = self.semantic_roi_extractor([semantic_feat],
+                                                             rois)
+            if bbox_semantic_feat.shape[-2:] != bbox_feats.shape[-2:]:
+                bbox_semantic_feat = adaptive_avg_pool2d(
+                    bbox_semantic_feat, bbox_feats.shape[-2:])
+            bbox_feats += bbox_semantic_feat
+        if self.with_glbctx and glbctx_feat is not None:
+            bbox_feats = self._fuse_glbctx(bbox_feats, glbctx_feat, rois)
+        cls_score, bbox_pred, relayed_feat = bbox_head(
+            bbox_feats, return_shared_feat=True)
+
+        bbox_results = dict(
+            cls_score=cls_score,
+            bbox_pred=bbox_pred,
+            relayed_feat=relayed_feat)
+        return bbox_results
+
+    def _mask_forward(self,
+                      x: Tuple[Tensor],
+                      rois: Tensor,
+                      semantic_feat: Optional[Tensor] = None,
+                      glbctx_feat: Optional[Tensor] = None,
+                      relayed_feat: Optional[Tensor] = None) -> dict:
+        """Mask head forward function used in both training and testing.
+
+        Args:
+            stage (int): The current stage in Cascade RoI Head.
+            x (tuple[Tensor]): Tuple of multi-level img features.
+            rois (Tensor): RoIs with the shape (n, 5) where the first
+                column indicates batch id of each RoI.
+            semantic_feat (Tensor): Semantic feature. Defaults to None.
+            glbctx_feat (Tensor): Global context feature. Defaults to None.
+            relayed_feat (Tensor): Relayed feature. Defaults to None.
+
+        Returns:
+            dict: Usually returns a dictionary with keys:
+
+                - `mask_preds` (Tensor): Mask prediction.
+        """
+        mask_feats = self.mask_roi_extractor(
+            x[:self.mask_roi_extractor.num_inputs], rois)
+        if self.with_semantic and semantic_feat is not None:
+            mask_semantic_feat = self.semantic_roi_extractor([semantic_feat],
+                                                             rois)
+            if mask_semantic_feat.shape[-2:] != mask_feats.shape[-2:]:
+                mask_semantic_feat = F.adaptive_avg_pool2d(
+                    mask_semantic_feat, mask_feats.shape[-2:])
+            mask_feats += mask_semantic_feat
+        if self.with_glbctx and glbctx_feat is not None:
+            mask_feats = self._fuse_glbctx(mask_feats, glbctx_feat, rois)
+        if self.with_feat_relay and relayed_feat is not None:
+            mask_feats = mask_feats + relayed_feat
+        mask_preds = self.mask_head(mask_feats)
+        mask_results = dict(mask_preds=mask_preds)
+
+        return mask_results
+
+    def bbox_loss(self,
+                  stage: int,
+                  x: Tuple[Tensor],
+                  sampling_results: List[SamplingResult],
+                  semantic_feat: Optional[Tensor] = None,
+                  glbctx_feat: Optional[Tensor] = None) -> dict:
+        """Run forward function and calculate loss for box head in training.
+
+        Args:
+            stage (int): The current stage in Cascade RoI Head.
+            x (tuple[Tensor]): List of multi-level img features.
+            sampling_results (list["obj:`SamplingResult`]): Sampling results.
+            semantic_feat (Tensor): Semantic feature. Defaults to None.
+            glbctx_feat (Tensor): Global context feature. Defaults to None.
+
+        Returns:
+            dict: Usually returns a dictionary with keys:
+
+                - `cls_score` (Tensor): Classification scores.
+                - `bbox_pred` (Tensor): Box energies / deltas.
+                - `bbox_feats` (Tensor): Extract bbox RoI features.
+                - `loss_bbox` (dict): A dictionary of bbox loss components.
+                - `rois` (Tensor): RoIs with the shape (n, 5) where the first
+                  column indicates batch id of each RoI.
+                - `bbox_targets` (tuple):  Ground truth for proposals in a
+                  single image. Containing the following list of Tensors:
+                  (labels, label_weights, bbox_targets, bbox_weights)
+        """
+        bbox_head = self.bbox_head[stage]
+        rois = bbox2roi([res.priors for res in sampling_results])
+        bbox_results = self._bbox_forward(
+            stage,
+            x,
+            rois,
+            semantic_feat=semantic_feat,
+            glbctx_feat=glbctx_feat)
+        bbox_results.update(rois=rois)
+
+        bbox_loss_and_target = bbox_head.loss_and_target(
+            cls_score=bbox_results['cls_score'],
+            bbox_pred=bbox_results['bbox_pred'],
+            rois=rois,
+            sampling_results=sampling_results,
+            rcnn_train_cfg=self.train_cfg[stage])
+
+        bbox_results.update(bbox_loss_and_target)
+        return bbox_results
+
+    def mask_loss(self,
+                  x: Tuple[Tensor],
+                  sampling_results: List[SamplingResult],
+                  batch_gt_instances: InstanceList,
+                  semantic_feat: Optional[Tensor] = None,
+                  glbctx_feat: Optional[Tensor] = None,
+                  relayed_feat: Optional[Tensor] = None) -> dict:
+        """Run forward function and calculate loss for mask head in training.
+
+        Args:
+            x (tuple[Tensor]): Tuple of multi-level img features.
+            sampling_results (list["obj:`SamplingResult`]): Sampling results.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes``, ``labels``, and
+                ``masks`` attributes.
+            semantic_feat (Tensor): Semantic feature. Defaults to None.
+            glbctx_feat (Tensor): Global context feature. Defaults to None.
+            relayed_feat (Tensor): Relayed feature. Defaults to None.
+
+        Returns:
+            dict: Usually returns a dictionary with keys:
+
+                - `mask_preds` (Tensor): Mask prediction.
+                - `loss_mask` (dict): A dictionary of mask loss components.
+        """
+        pos_rois = bbox2roi([res.pos_priors for res in sampling_results])
+        mask_results = self._mask_forward(
+            x,
+            pos_rois,
+            semantic_feat=semantic_feat,
+            glbctx_feat=glbctx_feat,
+            relayed_feat=relayed_feat)
+
+        mask_loss_and_target = self.mask_head.loss_and_target(
+            mask_preds=mask_results['mask_preds'],
+            sampling_results=sampling_results,
+            batch_gt_instances=batch_gt_instances,
+            rcnn_train_cfg=self.train_cfg[-1])
+        mask_results.update(mask_loss_and_target)
+
+        return mask_results
+
+    def semantic_loss(self, x: Tuple[Tensor],
+                      batch_data_samples: SampleList) -> dict:
+        """Semantic segmentation loss.
+
+        Args:
+            x (Tuple[Tensor]): Tuple of multi-level img features.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            dict: Usually returns a dictionary with keys:
+
+                - `semantic_feat` (Tensor): Semantic feature.
+                - `loss_seg` (dict): Semantic segmentation loss.
+        """
+        gt_semantic_segs = [
+            data_sample.gt_sem_seg.sem_seg
+            for data_sample in batch_data_samples
+        ]
+        gt_semantic_segs = torch.stack(gt_semantic_segs)
+        semantic_pred, semantic_feat = self.semantic_head(x)
+        loss_seg = self.semantic_head.loss(semantic_pred, gt_semantic_segs)
+
+        semantic_results = dict(loss_seg=loss_seg, semantic_feat=semantic_feat)
+
+        return semantic_results
+
+    def global_context_loss(self, x: Tuple[Tensor],
+                            batch_gt_instances: InstanceList) -> dict:
+        """Global context loss.
+
+        Args:
+            x (Tuple[Tensor]): Tuple of multi-level img features.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes``, ``labels``, and
+                ``masks`` attributes.
+
+        Returns:
+            dict: Usually returns a dictionary with keys:
+
+                - `glbctx_feat` (Tensor): Global context feature.
+                - `loss_glbctx` (dict): Global context loss.
+        """
+        gt_labels = [
+            gt_instances.labels for gt_instances in batch_gt_instances
+        ]
+        mc_pred, glbctx_feat = self.glbctx_head(x)
+        loss_glbctx = self.glbctx_head.loss(mc_pred, gt_labels)
+        global_context_results = dict(
+            loss_glbctx=loss_glbctx, glbctx_feat=glbctx_feat)
+
+        return global_context_results
+
+    def loss(self, x: Tensor, rpn_results_list: InstanceList,
+             batch_data_samples: SampleList) -> dict:
+        """Perform forward propagation and loss calculation of the detection
+        roi on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components
+        """
+        assert len(rpn_results_list) == len(batch_data_samples)
+        outputs = unpack_gt_instances(batch_data_samples)
+        batch_gt_instances, batch_gt_instances_ignore, batch_img_metas \
+            = outputs
+
+        losses = dict()
+
+        # semantic segmentation branch
+        if self.with_semantic:
+            semantic_results = self.semantic_loss(
+                x=x, batch_data_samples=batch_data_samples)
+            losses['loss_semantic_seg'] = semantic_results['loss_seg']
+            semantic_feat = semantic_results['semantic_feat']
+        else:
+            semantic_feat = None
+
+        # global context branch
+        if self.with_glbctx:
+            global_context_results = self.global_context_loss(
+                x=x, batch_gt_instances=batch_gt_instances)
+            losses['loss_glbctx'] = global_context_results['loss_glbctx']
+            glbctx_feat = global_context_results['glbctx_feat']
+        else:
+            glbctx_feat = None
+
+        results_list = rpn_results_list
+        num_imgs = len(batch_img_metas)
+        for stage in range(self.num_stages):
+            stage_loss_weight = self.stage_loss_weights[stage]
+
+            # assign gts and sample proposals
+            sampling_results = []
+            bbox_assigner = self.bbox_assigner[stage]
+            bbox_sampler = self.bbox_sampler[stage]
+            for i in range(num_imgs):
+                results = results_list[i]
+                # rename rpn_results.bboxes to rpn_results.priors
+                results.priors = results.pop('bboxes')
+
+                assign_result = bbox_assigner.assign(
+                    results, batch_gt_instances[i],
+                    batch_gt_instances_ignore[i])
+                sampling_result = bbox_sampler.sample(
+                    assign_result,
+                    results,
+                    batch_gt_instances[i],
+                    feats=[lvl_feat[i][None] for lvl_feat in x])
+                sampling_results.append(sampling_result)
+
+            # bbox head forward and loss
+            bbox_results = self.bbox_loss(
+                stage=stage,
+                x=x,
+                sampling_results=sampling_results,
+                semantic_feat=semantic_feat,
+                glbctx_feat=glbctx_feat)
+
+            for name, value in bbox_results['loss_bbox'].items():
+                losses[f's{stage}.{name}'] = (
+                    value * stage_loss_weight if 'loss' in name else value)
+
+            # refine bboxes
+            if stage < self.num_stages - 1:
+                bbox_head = self.bbox_head[stage]
+                with torch.no_grad():
+                    results_list = bbox_head.refine_bboxes(
+                        sampling_results=sampling_results,
+                        bbox_results=bbox_results,
+                        batch_img_metas=batch_img_metas)
+
+        if self.with_feat_relay:
+            relayed_feat = self._slice_pos_feats(bbox_results['relayed_feat'],
+                                                 sampling_results)
+            relayed_feat = self.feat_relay_head(relayed_feat)
+        else:
+            relayed_feat = None
+
+        # mask head forward and loss
+        mask_results = self.mask_loss(
+            x=x,
+            sampling_results=sampling_results,
+            batch_gt_instances=batch_gt_instances,
+            semantic_feat=semantic_feat,
+            glbctx_feat=glbctx_feat,
+            relayed_feat=relayed_feat)
+        mask_stage_loss_weight = sum(self.stage_loss_weights)
+        losses['loss_mask'] = mask_stage_loss_weight * mask_results[
+            'loss_mask']['loss_mask']
+
+        return losses
+
+    def predict(self,
+                x: Tuple[Tensor],
+                rpn_results_list: InstanceList,
+                batch_data_samples: SampleList,
+                rescale: bool = False) -> InstanceList:
+        """Perform forward propagation of the roi head and predict detection
+        results on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from upstream network. Each
+                has shape (N, C, H, W).
+            rpn_results_list (list[:obj:`InstanceData`]): list of region
+                proposals.
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            rescale (bool): Whether to rescale the results to
+                the original image. Defaults to False.
+
+        Returns:
+            list[obj:`InstanceData`]: Detection results of each image.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                    (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                    (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                    the last dimension 4 arrange as (x1, y1, x2, y2).
+                - masks (Tensor): Has a shape (num_instances, H, W).
+        """
+        assert self.with_bbox, 'Bbox head must be implemented.'
+        batch_img_metas = [
+            data_samples.metainfo for data_samples in batch_data_samples
+        ]
+
+        if self.with_semantic:
+            _, semantic_feat = self.semantic_head(x)
+        else:
+            semantic_feat = None
+
+        if self.with_glbctx:
+            _, glbctx_feat = self.glbctx_head(x)
+        else:
+            glbctx_feat = None
+
+        # TODO: nms_op in mmcv need be enhanced, the bbox result may get
+        #  difference when not rescale in bbox_head
+
+        # If it has the mask branch, the bbox branch does not need
+        # to be scaled to the original image scale, because the mask
+        # branch will scale both bbox and mask at the same time.
+        bbox_rescale = rescale if not self.with_mask else False
+        results_list = self.predict_bbox(
+            x=x,
+            semantic_feat=semantic_feat,
+            glbctx_feat=glbctx_feat,
+            batch_img_metas=batch_img_metas,
+            rpn_results_list=rpn_results_list,
+            rcnn_test_cfg=self.test_cfg,
+            rescale=bbox_rescale)
+
+        if self.with_mask:
+            results_list = self.predict_mask(
+                x=x,
+                semantic_heat=semantic_feat,
+                glbctx_feat=glbctx_feat,
+                batch_img_metas=batch_img_metas,
+                results_list=results_list,
+                rescale=rescale)
+
+        return results_list
+
+    def predict_mask(self,
+                     x: Tuple[Tensor],
+                     semantic_heat: Tensor,
+                     glbctx_feat: Tensor,
+                     batch_img_metas: List[dict],
+                     results_list: List[InstanceData],
+                     rescale: bool = False) -> List[InstanceData]:
+        """Perform forward propagation of the mask head and predict detection
+        results on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Feature maps of all scale level.
+            semantic_feat (Tensor): Semantic feature.
+            glbctx_feat (Tensor): Global context feature.
+            batch_img_metas (list[dict]): List of image information.
+            results_list (list[:obj:`InstanceData`]): Detection results of
+                each image.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+                - masks (Tensor): Has a shape (num_instances, H, W).
+        """
+        bboxes = [res.bboxes for res in results_list]
+        mask_rois = bbox2roi(bboxes)
+        if mask_rois.shape[0] == 0:
+            results_list = empty_instances(
+                batch_img_metas=batch_img_metas,
+                device=mask_rois.device,
+                task_type='mask',
+                instance_results=results_list,
+                mask_thr_binary=self.test_cfg.mask_thr_binary)
+            return results_list
+
+        bboxes_results = self._bbox_forward(
+            stage=-1,
+            x=x,
+            rois=mask_rois,
+            semantic_feat=semantic_heat,
+            glbctx_feat=glbctx_feat)
+        relayed_feat = bboxes_results['relayed_feat']
+        relayed_feat = self.feat_relay_head(relayed_feat)
+
+        mask_results = self._mask_forward(
+            x=x,
+            rois=mask_rois,
+            semantic_feat=semantic_heat,
+            glbctx_feat=glbctx_feat,
+            relayed_feat=relayed_feat)
+        mask_preds = mask_results['mask_preds']
+
+        # split batch mask prediction back to each image
+        num_bbox_per_img = tuple(len(_bbox) for _bbox in bboxes)
+        mask_preds = mask_preds.split(num_bbox_per_img, 0)
+
+        results_list = self.mask_head.predict_by_feat(
+            mask_preds=mask_preds,
+            results_list=results_list,
+            batch_img_metas=batch_img_metas,
+            rcnn_test_cfg=self.test_cfg,
+            rescale=rescale)
+
+        return results_list
+
+    def forward(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
+                batch_data_samples: SampleList) -> tuple:
+        """Network forward process. Usually includes backbone, neck and head
+        forward without any post-processing.
+
+        Args:
+            x (List[Tensor]): Multi-level features that may have different
+                resolutions.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals.
+            batch_data_samples (list[:obj:`DetDataSample`]): Each item contains
+                the meta information of each image and corresponding
+                annotations.
+
+        Returns
+            tuple: A tuple of features from ``bbox_head`` and ``mask_head``
+            forward.
+        """
+        results = ()
+        batch_img_metas = [
+            data_samples.metainfo for data_samples in batch_data_samples
+        ]
+
+        if self.with_semantic:
+            _, semantic_feat = self.semantic_head(x)
+        else:
+            semantic_feat = None
+
+        if self.with_glbctx:
+            _, glbctx_feat = self.glbctx_head(x)
+        else:
+            glbctx_feat = None
+
+        proposals = [rpn_results.bboxes for rpn_results in rpn_results_list]
+        num_proposals_per_img = tuple(len(p) for p in proposals)
+        rois = bbox2roi(proposals)
+        # bbox head
+        if self.with_bbox:
+            rois, cls_scores, bbox_preds = self._refine_roi(
+                x=x,
+                rois=rois,
+                semantic_feat=semantic_feat,
+                glbctx_feat=glbctx_feat,
+                batch_img_metas=batch_img_metas,
+                num_proposals_per_img=num_proposals_per_img)
+            results = results + (cls_scores, bbox_preds)
+        # mask head
+        if self.with_mask:
+            rois = torch.cat(rois)
+            bboxes_results = self._bbox_forward(
+                stage=-1,
+                x=x,
+                rois=rois,
+                semantic_feat=semantic_feat,
+                glbctx_feat=glbctx_feat)
+            relayed_feat = bboxes_results['relayed_feat']
+            relayed_feat = self.feat_relay_head(relayed_feat)
+            mask_results = self._mask_forward(
+                x=x,
+                rois=rois,
+                semantic_feat=semantic_feat,
+                glbctx_feat=glbctx_feat,
+                relayed_feat=relayed_feat)
+            mask_preds = mask_results['mask_preds']
+            mask_preds = mask_preds.split(num_proposals_per_img, 0)
+            results = results + (mask_preds, )
+        return results
diff --git a/mmdetection/mmdet/models/roi_heads/shared_heads/__init__.py b/mmdetection/mmdet/models/roi_heads/shared_heads/__init__.py
new file mode 100644
index 00000000..d56636ab
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/shared_heads/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .res_layer import ResLayer
+
+__all__ = ['ResLayer']
diff --git a/mmdetection/mmdet/models/roi_heads/shared_heads/res_layer.py b/mmdetection/mmdet/models/roi_heads/shared_heads/res_layer.py
new file mode 100644
index 00000000..d9210cb9
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/shared_heads/res_layer.py
@@ -0,0 +1,79 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+
+import torch.nn as nn
+from mmengine.model import BaseModule
+
+from mmdet.models.backbones import ResNet
+from mmdet.models.layers import ResLayer as _ResLayer
+from mmdet.registry import MODELS
+
+
+@MODELS.register_module()
+class ResLayer(BaseModule):
+
+    def __init__(self,
+                 depth,
+                 stage=3,
+                 stride=2,
+                 dilation=1,
+                 style='pytorch',
+                 norm_cfg=dict(type='BN', requires_grad=True),
+                 norm_eval=True,
+                 with_cp=False,
+                 dcn=None,
+                 pretrained=None,
+                 init_cfg=None):
+        super(ResLayer, self).__init__(init_cfg)
+
+        self.norm_eval = norm_eval
+        self.norm_cfg = norm_cfg
+        self.stage = stage
+        self.fp16_enabled = False
+        block, stage_blocks = ResNet.arch_settings[depth]
+        stage_block = stage_blocks[stage]
+        planes = 64 * 2**stage
+        inplanes = 64 * 2**(stage - 1) * block.expansion
+
+        res_layer = _ResLayer(
+            block,
+            inplanes,
+            planes,
+            stage_block,
+            stride=stride,
+            dilation=dilation,
+            style=style,
+            with_cp=with_cp,
+            norm_cfg=self.norm_cfg,
+            dcn=dcn)
+        self.add_module(f'layer{stage + 1}', res_layer)
+
+        assert not (init_cfg and pretrained), \
+            'init_cfg and pretrained cannot be specified at the same time'
+        if isinstance(pretrained, str):
+            warnings.warn('DeprecationWarning: pretrained is a deprecated, '
+                          'please use "init_cfg" instead')
+            self.init_cfg = dict(type='Pretrained', checkpoint=pretrained)
+        elif pretrained is None:
+            if init_cfg is None:
+                self.init_cfg = [
+                    dict(type='Kaiming', layer='Conv2d'),
+                    dict(
+                        type='Constant',
+                        val=1,
+                        layer=['_BatchNorm', 'GroupNorm'])
+                ]
+        else:
+            raise TypeError('pretrained must be a str or None')
+
+    def forward(self, x):
+        res_layer = getattr(self, f'layer{self.stage + 1}')
+        out = res_layer(x)
+        return out
+
+    def train(self, mode=True):
+        super(ResLayer, self).train(mode)
+        if self.norm_eval:
+            for m in self.modules():
+                if isinstance(m, nn.BatchNorm2d):
+                    m.eval()
diff --git a/mmdetection/mmdet/models/roi_heads/sparse_roi_head.py b/mmdetection/mmdet/models/roi_heads/sparse_roi_head.py
new file mode 100644
index 00000000..19c3e1e3
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/sparse_roi_head.py
@@ -0,0 +1,601 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple
+
+import torch
+from mmengine.config import ConfigDict
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.models.task_modules.samplers import PseudoSampler
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.structures.bbox import bbox2roi
+from mmdet.utils import ConfigType, InstanceList, OptConfigType
+from ..utils.misc import empty_instances, unpack_gt_instances
+from .cascade_roi_head import CascadeRoIHead
+
+
+@MODELS.register_module()
+class SparseRoIHead(CascadeRoIHead):
+    r"""The RoIHead for `Sparse R-CNN: End-to-End Object Detection with
+    Learnable Proposals `_
+    and `Instances as Queries `_
+
+    Args:
+        num_stages (int): Number of stage whole iterative process.
+            Defaults to 6.
+        stage_loss_weights (Tuple[float]): The loss
+            weight of each stage. By default all stages have
+            the same weight 1.
+        bbox_roi_extractor (:obj:`ConfigDict` or dict): Config of box
+            roi extractor.
+        mask_roi_extractor (:obj:`ConfigDict` or dict): Config of mask
+            roi extractor.
+        bbox_head (:obj:`ConfigDict` or dict): Config of box head.
+        mask_head (:obj:`ConfigDict` or dict): Config of mask head.
+        train_cfg (:obj:`ConfigDict` or dict, Optional): Configuration
+            information in train stage. Defaults to None.
+        test_cfg (:obj:`ConfigDict` or dict, Optional): Configuration
+            information in test stage. Defaults to None.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict]): Initialization config dict. Defaults to None.
+    """
+
+    def __init__(self,
+                 num_stages: int = 6,
+                 stage_loss_weights: Tuple[float] = (1, 1, 1, 1, 1, 1),
+                 proposal_feature_channel: int = 256,
+                 bbox_roi_extractor: ConfigType = dict(
+                     type='SingleRoIExtractor',
+                     roi_layer=dict(
+                         type='RoIAlign', output_size=7, sampling_ratio=2),
+                     out_channels=256,
+                     featmap_strides=[4, 8, 16, 32]),
+                 mask_roi_extractor: OptConfigType = None,
+                 bbox_head: ConfigType = dict(
+                     type='DIIHead',
+                     num_classes=80,
+                     num_fcs=2,
+                     num_heads=8,
+                     num_cls_fcs=1,
+                     num_reg_fcs=3,
+                     feedforward_channels=2048,
+                     hidden_channels=256,
+                     dropout=0.0,
+                     roi_feat_size=7,
+                     ffn_act_cfg=dict(type='ReLU', inplace=True)),
+                 mask_head: OptConfigType = None,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 init_cfg: OptConfigType = None) -> None:
+        assert bbox_roi_extractor is not None
+        assert bbox_head is not None
+        assert len(stage_loss_weights) == num_stages
+        self.num_stages = num_stages
+        self.stage_loss_weights = stage_loss_weights
+        self.proposal_feature_channel = proposal_feature_channel
+        super().__init__(
+            num_stages=num_stages,
+            stage_loss_weights=stage_loss_weights,
+            bbox_roi_extractor=bbox_roi_extractor,
+            mask_roi_extractor=mask_roi_extractor,
+            bbox_head=bbox_head,
+            mask_head=mask_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            init_cfg=init_cfg)
+        # train_cfg would be None when run the test.py
+        if train_cfg is not None:
+            for stage in range(num_stages):
+                assert isinstance(self.bbox_sampler[stage], PseudoSampler), \
+                    'Sparse R-CNN and QueryInst only support `PseudoSampler`'
+
+    def bbox_loss(self, stage: int, x: Tuple[Tensor],
+                  results_list: InstanceList, object_feats: Tensor,
+                  batch_img_metas: List[dict],
+                  batch_gt_instances: InstanceList) -> dict:
+        """Perform forward propagation and loss calculation of the bbox head on
+        the features of the upstream network.
+
+        Args:
+            stage (int): The current stage in iterative process.
+            x (tuple[Tensor]): List of multi-level img features.
+            results_list (List[:obj:`InstanceData`]) : List of region
+                proposals.
+            object_feats (Tensor): The object feature extracted from
+                the previous stage.
+            batch_img_metas (list[dict]): Meta information of each image.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes``, ``labels``, and
+                ``masks`` attributes.
+
+        Returns:
+            dict[str, Tensor]: Usually returns a dictionary with keys:
+
+            - `cls_score` (Tensor): Classification scores.
+            - `bbox_pred` (Tensor): Box energies / deltas.
+            - `bbox_feats` (Tensor): Extract bbox RoI features.
+            - `loss_bbox` (dict): A dictionary of bbox loss components.
+        """
+        proposal_list = [res.bboxes for res in results_list]
+        rois = bbox2roi(proposal_list)
+        bbox_results = self._bbox_forward(stage, x, rois, object_feats,
+                                          batch_img_metas)
+        imgs_whwh = torch.cat(
+            [res.imgs_whwh[None, ...] for res in results_list])
+        cls_pred_list = bbox_results['detached_cls_scores']
+        proposal_list = bbox_results['detached_proposals']
+
+        sampling_results = []
+        bbox_head = self.bbox_head[stage]
+        for i in range(len(batch_img_metas)):
+            pred_instances = InstanceData()
+            # TODO: Enhance the logic
+            pred_instances.bboxes = proposal_list[i]  # for assinger
+            pred_instances.scores = cls_pred_list[i]
+            pred_instances.priors = proposal_list[i]  # for sampler
+
+            assign_result = self.bbox_assigner[stage].assign(
+                pred_instances=pred_instances,
+                gt_instances=batch_gt_instances[i],
+                gt_instances_ignore=None,
+                img_meta=batch_img_metas[i])
+
+            sampling_result = self.bbox_sampler[stage].sample(
+                assign_result, pred_instances, batch_gt_instances[i])
+            sampling_results.append(sampling_result)
+
+        bbox_results.update(sampling_results=sampling_results)
+
+        cls_score = bbox_results['cls_score']
+        decoded_bboxes = bbox_results['decoded_bboxes']
+        cls_score = cls_score.view(-1, cls_score.size(-1))
+        decoded_bboxes = decoded_bboxes.view(-1, 4)
+        bbox_loss_and_target = bbox_head.loss_and_target(
+            cls_score,
+            decoded_bboxes,
+            sampling_results,
+            self.train_cfg[stage],
+            imgs_whwh=imgs_whwh,
+            concat=True)
+        bbox_results.update(bbox_loss_and_target)
+
+        # propose for the new proposal_list
+        proposal_list = []
+        for idx in range(len(batch_img_metas)):
+            results = InstanceData()
+            results.imgs_whwh = results_list[idx].imgs_whwh
+            results.bboxes = bbox_results['detached_proposals'][idx]
+            proposal_list.append(results)
+        bbox_results.update(results_list=proposal_list)
+        return bbox_results
+
+    def _bbox_forward(self, stage: int, x: Tuple[Tensor], rois: Tensor,
+                      object_feats: Tensor,
+                      batch_img_metas: List[dict]) -> dict:
+        """Box head forward function used in both training and testing. Returns
+        all regression, classification results and a intermediate feature.
+
+        Args:
+            stage (int): The current stage in iterative process.
+            x (tuple[Tensor]): List of multi-level img features.
+            rois (Tensor): RoIs with the shape (n, 5) where the first
+                column indicates batch id of each RoI.
+                Each dimension means (img_index, x1, y1, x2, y2).
+            object_feats (Tensor): The object feature extracted from
+                the previous stage.
+            batch_img_metas (list[dict]): Meta information of each image.
+
+        Returns:
+            dict[str, Tensor]: a dictionary of bbox head outputs,
+            Containing the following results:
+
+            - cls_score (Tensor): The score of each class, has
+              shape (batch_size, num_proposals, num_classes)
+              when use focal loss or
+              (batch_size, num_proposals, num_classes+1)
+              otherwise.
+            - decoded_bboxes (Tensor): The regression results
+              with shape (batch_size, num_proposal, 4).
+              The last dimension 4 represents
+              [tl_x, tl_y, br_x, br_y].
+            - object_feats (Tensor): The object feature extracted
+              from current stage
+            - detached_cls_scores (list[Tensor]): The detached
+              classification results, length is batch_size, and
+              each tensor has shape (num_proposal, num_classes).
+            - detached_proposals (list[tensor]): The detached
+              regression results, length is batch_size, and each
+              tensor has shape (num_proposal, 4). The last
+              dimension 4 represents [tl_x, tl_y, br_x, br_y].
+        """
+        num_imgs = len(batch_img_metas)
+        bbox_roi_extractor = self.bbox_roi_extractor[stage]
+        bbox_head = self.bbox_head[stage]
+        bbox_feats = bbox_roi_extractor(x[:bbox_roi_extractor.num_inputs],
+                                        rois)
+        cls_score, bbox_pred, object_feats, attn_feats = bbox_head(
+            bbox_feats, object_feats)
+
+        fake_bbox_results = dict(
+            rois=rois,
+            bbox_targets=(rois.new_zeros(len(rois), dtype=torch.long), None),
+            bbox_pred=bbox_pred.view(-1, bbox_pred.size(-1)),
+            cls_score=cls_score.view(-1, cls_score.size(-1)))
+        fake_sampling_results = [
+            InstanceData(pos_is_gt=rois.new_zeros(object_feats.size(1)))
+            for _ in range(len(batch_img_metas))
+        ]
+
+        results_list = bbox_head.refine_bboxes(
+            sampling_results=fake_sampling_results,
+            bbox_results=fake_bbox_results,
+            batch_img_metas=batch_img_metas)
+        proposal_list = [res.bboxes for res in results_list]
+        bbox_results = dict(
+            cls_score=cls_score,
+            decoded_bboxes=torch.cat(proposal_list),
+            object_feats=object_feats,
+            attn_feats=attn_feats,
+            # detach then use it in label assign
+            detached_cls_scores=[
+                cls_score[i].detach() for i in range(num_imgs)
+            ],
+            detached_proposals=[item.detach() for item in proposal_list])
+
+        return bbox_results
+
+    def _mask_forward(self, stage: int, x: Tuple[Tensor], rois: Tensor,
+                      attn_feats) -> dict:
+        """Mask head forward function used in both training and testing.
+
+        Args:
+            stage (int): The current stage in Cascade RoI Head.
+            x (tuple[Tensor]): Tuple of multi-level img features.
+            rois (Tensor): RoIs with the shape (n, 5) where the first
+                column indicates batch id of each RoI.
+            attn_feats (Tensot): Intermediate feature get from the last
+                diihead, has shape
+                (batch_size*num_proposals, feature_dimensions)
+
+        Returns:
+            dict: Usually returns a dictionary with keys:
+
+            - `mask_preds` (Tensor): Mask prediction.
+        """
+        mask_roi_extractor = self.mask_roi_extractor[stage]
+        mask_head = self.mask_head[stage]
+        mask_feats = mask_roi_extractor(x[:mask_roi_extractor.num_inputs],
+                                        rois)
+        # do not support caffe_c4 model anymore
+        mask_preds = mask_head(mask_feats, attn_feats)
+
+        mask_results = dict(mask_preds=mask_preds)
+        return mask_results
+
+    def mask_loss(self, stage: int, x: Tuple[Tensor], bbox_results: dict,
+                  batch_gt_instances: InstanceList,
+                  rcnn_train_cfg: ConfigDict) -> dict:
+        """Run forward function and calculate loss for mask head in training.
+
+        Args:
+            stage (int): The current stage in Cascade RoI Head.
+            x (tuple[Tensor]): Tuple of multi-level img features.
+            bbox_results (dict): Results obtained from `bbox_loss`.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes``, ``labels``, and
+                ``masks`` attributes.
+            rcnn_train_cfg (obj:ConfigDict): `train_cfg` of RCNN.
+
+        Returns:
+            dict: Usually returns a dictionary with keys:
+
+            - `mask_preds` (Tensor): Mask prediction.
+            - `loss_mask` (dict): A dictionary of mask loss components.
+        """
+        attn_feats = bbox_results['attn_feats']
+        sampling_results = bbox_results['sampling_results']
+
+        pos_rois = bbox2roi([res.pos_priors for res in sampling_results])
+
+        attn_feats = torch.cat([
+            feats[res.pos_inds]
+            for (feats, res) in zip(attn_feats, sampling_results)
+        ])
+        mask_results = self._mask_forward(stage, x, pos_rois, attn_feats)
+
+        mask_loss_and_target = self.mask_head[stage].loss_and_target(
+            mask_preds=mask_results['mask_preds'],
+            sampling_results=sampling_results,
+            batch_gt_instances=batch_gt_instances,
+            rcnn_train_cfg=rcnn_train_cfg)
+        mask_results.update(mask_loss_and_target)
+
+        return mask_results
+
+    def loss(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
+             batch_data_samples: SampleList) -> dict:
+        """Perform forward propagation and loss calculation of the detection
+        roi on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            rpn_results_list (List[:obj:`InstanceData`]): List of region
+                proposals.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            dict: a dictionary of loss components of all stage.
+        """
+        outputs = unpack_gt_instances(batch_data_samples)
+        batch_gt_instances, batch_gt_instances_ignore, batch_img_metas \
+            = outputs
+
+        object_feats = torch.cat(
+            [res.pop('features')[None, ...] for res in rpn_results_list])
+        results_list = rpn_results_list
+        losses = {}
+        for stage in range(self.num_stages):
+            stage_loss_weight = self.stage_loss_weights[stage]
+
+            # bbox head forward and loss
+            bbox_results = self.bbox_loss(
+                stage=stage,
+                x=x,
+                object_feats=object_feats,
+                results_list=results_list,
+                batch_img_metas=batch_img_metas,
+                batch_gt_instances=batch_gt_instances)
+
+            for name, value in bbox_results['loss_bbox'].items():
+                losses[f's{stage}.{name}'] = (
+                    value * stage_loss_weight if 'loss' in name else value)
+
+            if self.with_mask:
+                mask_results = self.mask_loss(
+                    stage=stage,
+                    x=x,
+                    bbox_results=bbox_results,
+                    batch_gt_instances=batch_gt_instances,
+                    rcnn_train_cfg=self.train_cfg[stage])
+
+                for name, value in mask_results['loss_mask'].items():
+                    losses[f's{stage}.{name}'] = (
+                        value * stage_loss_weight if 'loss' in name else value)
+
+            object_feats = bbox_results['object_feats']
+            results_list = bbox_results['results_list']
+        return losses
+
+    def predict_bbox(self,
+                     x: Tuple[Tensor],
+                     batch_img_metas: List[dict],
+                     rpn_results_list: InstanceList,
+                     rcnn_test_cfg: ConfigType,
+                     rescale: bool = False) -> InstanceList:
+        """Perform forward propagation of the bbox head and predict detection
+        results on the features of the upstream network.
+
+        Args:
+            x(tuple[Tensor]): Feature maps of all scale level.
+            batch_img_metas (list[dict]): List of image information.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals.
+            rcnn_test_cfg (obj:`ConfigDict`): `test_cfg` of R-CNN.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+            - scores (Tensor): Classification scores, has a shape
+              (num_instance, )
+            - labels (Tensor): Labels of bboxes, has a shape
+              (num_instances, ).
+            - bboxes (Tensor): Has a shape (num_instances, 4),
+              the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        proposal_list = [res.bboxes for res in rpn_results_list]
+        object_feats = torch.cat(
+            [res.pop('features')[None, ...] for res in rpn_results_list])
+        if all([proposal.shape[0] == 0 for proposal in proposal_list]):
+            # There is no proposal in the whole batch
+            return empty_instances(
+                batch_img_metas, x[0].device, task_type='bbox')
+
+        for stage in range(self.num_stages):
+            rois = bbox2roi(proposal_list)
+            bbox_results = self._bbox_forward(stage, x, rois, object_feats,
+                                              batch_img_metas)
+            object_feats = bbox_results['object_feats']
+            cls_score = bbox_results['cls_score']
+            proposal_list = bbox_results['detached_proposals']
+
+        num_classes = self.bbox_head[-1].num_classes
+
+        if self.bbox_head[-1].loss_cls.use_sigmoid:
+            cls_score = cls_score.sigmoid()
+        else:
+            cls_score = cls_score.softmax(-1)[..., :-1]
+
+        topk_inds_list = []
+        results_list = []
+        for img_id in range(len(batch_img_metas)):
+            cls_score_per_img = cls_score[img_id]
+            scores_per_img, topk_inds = cls_score_per_img.flatten(0, 1).topk(
+                self.test_cfg.max_per_img, sorted=False)
+            labels_per_img = topk_inds % num_classes
+            bboxes_per_img = proposal_list[img_id][topk_inds // num_classes]
+            topk_inds_list.append(topk_inds)
+            if rescale and bboxes_per_img.size(0) > 0:
+                assert batch_img_metas[img_id].get('scale_factor') is not None
+                scale_factor = bboxes_per_img.new_tensor(
+                    batch_img_metas[img_id]['scale_factor']).repeat((1, 2))
+                bboxes_per_img = (
+                    bboxes_per_img.view(bboxes_per_img.size(0), -1, 4) /
+                    scale_factor).view(bboxes_per_img.size()[0], -1)
+
+            results = InstanceData()
+            results.bboxes = bboxes_per_img
+            results.scores = scores_per_img
+            results.labels = labels_per_img
+            results_list.append(results)
+        if self.with_mask:
+            for img_id in range(len(batch_img_metas)):
+                # add positive information in InstanceData to predict
+                # mask results in `mask_head`.
+                proposals = bbox_results['detached_proposals'][img_id]
+                topk_inds = topk_inds_list[img_id]
+                attn_feats = bbox_results['attn_feats'][img_id]
+
+                results_list[img_id].proposals = proposals
+                results_list[img_id].topk_inds = topk_inds
+                results_list[img_id].attn_feats = attn_feats
+        return results_list
+
+    def predict_mask(self,
+                     x: Tuple[Tensor],
+                     batch_img_metas: List[dict],
+                     results_list: InstanceList,
+                     rescale: bool = False) -> InstanceList:
+        """Perform forward propagation of the mask head and predict detection
+        results on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Feature maps of all scale level.
+            batch_img_metas (list[dict]): List of image information.
+            results_list (list[:obj:`InstanceData`]): Detection results of
+                each image. Each item usually contains following keys:
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+                - proposal (Tensor): Bboxes predicted from bbox_head,
+                  has a shape (num_instances, 4).
+                - topk_inds (Tensor): Topk indices of each image, has
+                  shape (num_instances, )
+                - attn_feats (Tensor): Intermediate feature get from the last
+                  diihead, has shape (num_instances, feature_dimensions)
+
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+            - scores (Tensor): Classification scores, has a shape
+              (num_instance, )
+            - labels (Tensor): Labels of bboxes, has a shape
+              (num_instances, ).
+            - bboxes (Tensor): Has a shape (num_instances, 4),
+              the last dimension 4 arrange as (x1, y1, x2, y2).
+            - masks (Tensor): Has a shape (num_instances, H, W).
+        """
+        proposal_list = [res.pop('proposals') for res in results_list]
+        topk_inds_list = [res.pop('topk_inds') for res in results_list]
+        attn_feats = torch.cat(
+            [res.pop('attn_feats')[None, ...] for res in results_list])
+
+        rois = bbox2roi(proposal_list)
+
+        if rois.shape[0] == 0:
+            results_list = empty_instances(
+                batch_img_metas,
+                rois.device,
+                task_type='mask',
+                instance_results=results_list,
+                mask_thr_binary=self.test_cfg.mask_thr_binary)
+            return results_list
+
+        last_stage = self.num_stages - 1
+        mask_results = self._mask_forward(last_stage, x, rois, attn_feats)
+
+        num_imgs = len(batch_img_metas)
+        mask_results['mask_preds'] = mask_results['mask_preds'].reshape(
+            num_imgs, -1, *mask_results['mask_preds'].size()[1:])
+        num_classes = self.bbox_head[-1].num_classes
+
+        mask_preds = []
+        for img_id in range(num_imgs):
+            topk_inds = topk_inds_list[img_id]
+            masks_per_img = mask_results['mask_preds'][img_id].flatten(
+                0, 1)[topk_inds]
+            masks_per_img = masks_per_img[:, None,
+                                          ...].repeat(1, num_classes, 1, 1)
+            mask_preds.append(masks_per_img)
+        results_list = self.mask_head[-1].predict_by_feat(
+            mask_preds,
+            results_list,
+            batch_img_metas,
+            rcnn_test_cfg=self.test_cfg,
+            rescale=rescale)
+
+        return results_list
+
+    # TODO: Need to refactor later
+    def forward(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
+                batch_data_samples: SampleList) -> tuple:
+        """Network forward process. Usually includes backbone, neck and head
+        forward without any post-processing.
+
+        Args:
+            x (List[Tensor]): Multi-level features that may have different
+                resolutions.
+            rpn_results_list (List[:obj:`InstanceData`]): List of region
+                proposals.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns
+            tuple: A tuple of features from ``bbox_head`` and ``mask_head``
+            forward.
+        """
+        outputs = unpack_gt_instances(batch_data_samples)
+        (batch_gt_instances, batch_gt_instances_ignore,
+         batch_img_metas) = outputs
+
+        all_stage_bbox_results = []
+        object_feats = torch.cat(
+            [res.pop('features')[None, ...] for res in rpn_results_list])
+        results_list = rpn_results_list
+        if self.with_bbox:
+            for stage in range(self.num_stages):
+                bbox_results = self.bbox_loss(
+                    stage=stage,
+                    x=x,
+                    results_list=results_list,
+                    object_feats=object_feats,
+                    batch_img_metas=batch_img_metas,
+                    batch_gt_instances=batch_gt_instances)
+                bbox_results.pop('loss_bbox')
+                # torch.jit does not support obj:SamplingResult
+                bbox_results.pop('results_list')
+                bbox_res = bbox_results.copy()
+                bbox_res.pop('sampling_results')
+                all_stage_bbox_results.append((bbox_res, ))
+
+                if self.with_mask:
+                    attn_feats = bbox_results['attn_feats']
+                    sampling_results = bbox_results['sampling_results']
+
+                    pos_rois = bbox2roi(
+                        [res.pos_priors for res in sampling_results])
+
+                    attn_feats = torch.cat([
+                        feats[res.pos_inds]
+                        for (feats, res) in zip(attn_feats, sampling_results)
+                    ])
+                    mask_results = self._mask_forward(stage, x, pos_rois,
+                                                      attn_feats)
+                    all_stage_bbox_results[-1] += (mask_results, )
+        return tuple(all_stage_bbox_results)
diff --git a/mmdetection/mmdet/models/roi_heads/standard_roi_head.py b/mmdetection/mmdet/models/roi_heads/standard_roi_head.py
new file mode 100644
index 00000000..8d168eba
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/standard_roi_head.py
@@ -0,0 +1,419 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Tuple
+
+import torch
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.structures import DetDataSample, SampleList
+from mmdet.structures.bbox import bbox2roi
+from mmdet.utils import ConfigType, InstanceList
+from ..task_modules.samplers import SamplingResult
+from ..utils import empty_instances, unpack_gt_instances
+from .base_roi_head import BaseRoIHead
+
+
+@MODELS.register_module()
+class StandardRoIHead(BaseRoIHead):
+    """Simplest base roi head including one bbox head and one mask head."""
+
+    def init_assigner_sampler(self) -> None:
+        """Initialize assigner and sampler."""
+        self.bbox_assigner = None
+        self.bbox_sampler = None
+        if self.train_cfg:
+            self.bbox_assigner = TASK_UTILS.build(self.train_cfg.assigner)
+            self.bbox_sampler = TASK_UTILS.build(
+                self.train_cfg.sampler, default_args=dict(context=self))
+
+    def init_bbox_head(self, bbox_roi_extractor: ConfigType,
+                       bbox_head: ConfigType) -> None:
+        """Initialize box head and box roi extractor.
+
+        Args:
+            bbox_roi_extractor (dict or ConfigDict): Config of box
+                roi extractor.
+            bbox_head (dict or ConfigDict): Config of box in box head.
+        """
+        self.bbox_roi_extractor = MODELS.build(bbox_roi_extractor)
+        self.bbox_head = MODELS.build(bbox_head)
+
+    def init_mask_head(self, mask_roi_extractor: ConfigType,
+                       mask_head: ConfigType) -> None:
+        """Initialize mask head and mask roi extractor.
+
+        Args:
+            mask_roi_extractor (dict or ConfigDict): Config of mask roi
+                extractor.
+            mask_head (dict or ConfigDict): Config of mask in mask head.
+        """
+        if mask_roi_extractor is not None:
+            self.mask_roi_extractor = MODELS.build(mask_roi_extractor)
+            self.share_roi_extractor = False
+        else:
+            self.share_roi_extractor = True
+            self.mask_roi_extractor = self.bbox_roi_extractor
+        self.mask_head = MODELS.build(mask_head)
+
+    # TODO: Need to refactor later
+    def forward(self,
+                x: Tuple[Tensor],
+                rpn_results_list: InstanceList,
+                batch_data_samples: SampleList = None) -> tuple:
+        """Network forward process. Usually includes backbone, neck and head
+        forward without any post-processing.
+
+        Args:
+            x (List[Tensor]): Multi-level features that may have different
+                resolutions.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals.
+            batch_data_samples (list[:obj:`DetDataSample`]): Each item contains
+            the meta information of each image and corresponding
+            annotations.
+
+        Returns
+            tuple: A tuple of features from ``bbox_head`` and ``mask_head``
+            forward.
+        """
+        results = ()
+        proposals = [rpn_results.bboxes for rpn_results in rpn_results_list]
+        rois = bbox2roi(proposals)
+        # bbox head
+        if self.with_bbox:
+            bbox_results = self._bbox_forward(x, rois)
+            results = results + (bbox_results['cls_score'],
+                                 bbox_results['bbox_pred'])
+        # mask head
+        if self.with_mask:
+            mask_rois = rois[:100]
+            mask_results = self._mask_forward(x, mask_rois)
+            results = results + (mask_results['mask_preds'], )
+        return results
+
+    def loss(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
+             batch_data_samples: List[DetDataSample]) -> dict:
+        """Perform forward propagation and loss calculation of the detection
+        roi on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components
+        """
+        assert len(rpn_results_list) == len(batch_data_samples)
+        outputs = unpack_gt_instances(batch_data_samples)
+        batch_gt_instances, batch_gt_instances_ignore, _ = outputs
+
+        # assign gts and sample proposals
+        num_imgs = len(batch_data_samples)
+        sampling_results = []
+        for i in range(num_imgs):
+            # rename rpn_results.bboxes to rpn_results.priors
+            rpn_results = rpn_results_list[i]
+            rpn_results.priors = rpn_results.pop('bboxes')
+
+            assign_result = self.bbox_assigner.assign(
+                rpn_results, batch_gt_instances[i],
+                batch_gt_instances_ignore[i])
+            sampling_result = self.bbox_sampler.sample(
+                assign_result,
+                rpn_results,
+                batch_gt_instances[i],
+                feats=[lvl_feat[i][None] for lvl_feat in x])
+            sampling_results.append(sampling_result)
+
+        losses = dict()
+        # bbox head loss
+        if self.with_bbox:
+            bbox_results = self.bbox_loss(x, sampling_results)
+            losses.update(bbox_results['loss_bbox'])
+
+        # mask head forward and loss
+        if self.with_mask:
+            mask_results = self.mask_loss(x, sampling_results,
+                                          bbox_results['bbox_feats'],
+                                          batch_gt_instances)
+            losses.update(mask_results['loss_mask'])
+
+        return losses
+
+    def _bbox_forward(self, x: Tuple[Tensor], rois: Tensor) -> dict:
+        """Box head forward function used in both training and testing.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            rois (Tensor): RoIs with the shape (n, 5) where the first
+                column indicates batch id of each RoI.
+
+        Returns:
+             dict[str, Tensor]: Usually returns a dictionary with keys:
+
+                - `cls_score` (Tensor): Classification scores.
+                - `bbox_pred` (Tensor): Box energies / deltas.
+                - `bbox_feats` (Tensor): Extract bbox RoI features.
+        """
+        # TODO: a more flexible way to decide which feature maps to use
+        bbox_feats = self.bbox_roi_extractor(
+            x[:self.bbox_roi_extractor.num_inputs], rois)
+        if self.with_shared_head:
+            bbox_feats = self.shared_head(bbox_feats)
+        cls_score, bbox_pred = self.bbox_head(bbox_feats)
+
+        bbox_results = dict(
+            cls_score=cls_score, bbox_pred=bbox_pred, bbox_feats=bbox_feats)
+        return bbox_results
+
+    def bbox_loss(self, x: Tuple[Tensor],
+                  sampling_results: List[SamplingResult]) -> dict:
+        """Perform forward propagation and loss calculation of the bbox head on
+        the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            sampling_results (list["obj:`SamplingResult`]): Sampling results.
+
+        Returns:
+            dict[str, Tensor]: Usually returns a dictionary with keys:
+
+                - `cls_score` (Tensor): Classification scores.
+                - `bbox_pred` (Tensor): Box energies / deltas.
+                - `bbox_feats` (Tensor): Extract bbox RoI features.
+                - `loss_bbox` (dict): A dictionary of bbox loss components.
+        """
+        rois = bbox2roi([res.priors for res in sampling_results])
+        bbox_results = self._bbox_forward(x, rois)
+
+        bbox_loss_and_target = self.bbox_head.loss_and_target(
+            cls_score=bbox_results['cls_score'],
+            bbox_pred=bbox_results['bbox_pred'],
+            rois=rois,
+            sampling_results=sampling_results,
+            rcnn_train_cfg=self.train_cfg)
+
+        bbox_results.update(loss_bbox=bbox_loss_and_target['loss_bbox'])
+        return bbox_results
+
+    def mask_loss(self, x: Tuple[Tensor],
+                  sampling_results: List[SamplingResult], bbox_feats: Tensor,
+                  batch_gt_instances: InstanceList) -> dict:
+        """Perform forward propagation and loss calculation of the mask head on
+        the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Tuple of multi-level img features.
+            sampling_results (list["obj:`SamplingResult`]): Sampling results.
+            bbox_feats (Tensor): Extract bbox RoI features.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes``, ``labels``, and
+                ``masks`` attributes.
+
+        Returns:
+            dict: Usually returns a dictionary with keys:
+
+                - `mask_preds` (Tensor): Mask prediction.
+                - `mask_feats` (Tensor): Extract mask RoI features.
+                - `mask_targets` (Tensor): Mask target of each positive\
+                    proposals in the image.
+                - `loss_mask` (dict): A dictionary of mask loss components.
+        """
+        if not self.share_roi_extractor:
+            pos_rois = bbox2roi([res.pos_priors for res in sampling_results])
+            mask_results = self._mask_forward(x, pos_rois)
+        else:
+            pos_inds = []
+            device = bbox_feats.device
+            for res in sampling_results:
+                pos_inds.append(
+                    torch.ones(
+                        res.pos_priors.shape[0],
+                        device=device,
+                        dtype=torch.uint8))
+                pos_inds.append(
+                    torch.zeros(
+                        res.neg_priors.shape[0],
+                        device=device,
+                        dtype=torch.uint8))
+            pos_inds = torch.cat(pos_inds)
+
+            mask_results = self._mask_forward(
+                x, pos_inds=pos_inds, bbox_feats=bbox_feats)
+
+        mask_loss_and_target = self.mask_head.loss_and_target(
+            mask_preds=mask_results['mask_preds'],
+            sampling_results=sampling_results,
+            batch_gt_instances=batch_gt_instances,
+            rcnn_train_cfg=self.train_cfg)
+
+        mask_results.update(loss_mask=mask_loss_and_target['loss_mask'])
+        return mask_results
+
+    def _mask_forward(self,
+                      x: Tuple[Tensor],
+                      rois: Tensor = None,
+                      pos_inds: Optional[Tensor] = None,
+                      bbox_feats: Optional[Tensor] = None) -> dict:
+        """Mask head forward function used in both training and testing.
+
+        Args:
+            x (tuple[Tensor]): Tuple of multi-level img features.
+            rois (Tensor): RoIs with the shape (n, 5) where the first
+                column indicates batch id of each RoI.
+            pos_inds (Tensor, optional): Indices of positive samples.
+                Defaults to None.
+            bbox_feats (Tensor): Extract bbox RoI features. Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: Usually returns a dictionary with keys:
+
+                - `mask_preds` (Tensor): Mask prediction.
+                - `mask_feats` (Tensor): Extract mask RoI features.
+        """
+        assert ((rois is not None) ^
+                (pos_inds is not None and bbox_feats is not None))
+        if rois is not None:
+            mask_feats = self.mask_roi_extractor(
+                x[:self.mask_roi_extractor.num_inputs], rois)
+            if self.with_shared_head:
+                mask_feats = self.shared_head(mask_feats)
+        else:
+            assert bbox_feats is not None
+            mask_feats = bbox_feats[pos_inds]
+
+        mask_preds = self.mask_head(mask_feats)
+        mask_results = dict(mask_preds=mask_preds, mask_feats=mask_feats)
+        return mask_results
+
+    def predict_bbox(self,
+                     x: Tuple[Tensor],
+                     batch_img_metas: List[dict],
+                     rpn_results_list: InstanceList,
+                     rcnn_test_cfg: ConfigType,
+                     rescale: bool = False) -> InstanceList:
+        """Perform forward propagation of the bbox head and predict detection
+        results on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Feature maps of all scale level.
+            batch_img_metas (list[dict]): List of image information.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals.
+            rcnn_test_cfg (obj:`ConfigDict`): `test_cfg` of R-CNN.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        proposals = [res.bboxes for res in rpn_results_list]
+        rois = bbox2roi(proposals)
+
+        if rois.shape[0] == 0:
+            return empty_instances(
+                batch_img_metas,
+                rois.device,
+                task_type='bbox',
+                box_type=self.bbox_head.predict_box_type,
+                num_classes=self.bbox_head.num_classes,
+                score_per_cls=rcnn_test_cfg is None)
+
+        bbox_results = self._bbox_forward(x, rois)
+
+        # split batch bbox prediction back to each image
+        cls_scores = bbox_results['cls_score']
+        bbox_preds = bbox_results['bbox_pred']
+        num_proposals_per_img = tuple(len(p) for p in proposals)
+        rois = rois.split(num_proposals_per_img, 0)
+        cls_scores = cls_scores.split(num_proposals_per_img, 0)
+
+        # some detector with_reg is False, bbox_preds will be None
+        if bbox_preds is not None:
+            # TODO move this to a sabl_roi_head
+            # the bbox prediction of some detectors like SABL is not Tensor
+            if isinstance(bbox_preds, torch.Tensor):
+                bbox_preds = bbox_preds.split(num_proposals_per_img, 0)
+            else:
+                bbox_preds = self.bbox_head.bbox_pred_split(
+                    bbox_preds, num_proposals_per_img)
+        else:
+            bbox_preds = (None, ) * len(proposals)
+
+        result_list = self.bbox_head.predict_by_feat(
+            rois=rois,
+            cls_scores=cls_scores,
+            bbox_preds=bbox_preds,
+            batch_img_metas=batch_img_metas,
+            rcnn_test_cfg=rcnn_test_cfg,
+            rescale=rescale)
+        return result_list
+
+    def predict_mask(self,
+                     x: Tuple[Tensor],
+                     batch_img_metas: List[dict],
+                     results_list: InstanceList,
+                     rescale: bool = False) -> InstanceList:
+        """Perform forward propagation of the mask head and predict detection
+        results on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Feature maps of all scale level.
+            batch_img_metas (list[dict]): List of image information.
+            results_list (list[:obj:`InstanceData`]): Detection results of
+                each image.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+                - masks (Tensor): Has a shape (num_instances, H, W).
+        """
+        # don't need to consider aug_test.
+        bboxes = [res.bboxes for res in results_list]
+        mask_rois = bbox2roi(bboxes)
+        if mask_rois.shape[0] == 0:
+            results_list = empty_instances(
+                batch_img_metas,
+                mask_rois.device,
+                task_type='mask',
+                instance_results=results_list,
+                mask_thr_binary=self.test_cfg.mask_thr_binary)
+            return results_list
+
+        mask_results = self._mask_forward(x, mask_rois)
+        mask_preds = mask_results['mask_preds']
+        # split batch mask prediction back to each image
+        num_mask_rois_per_img = [len(res) for res in results_list]
+        mask_preds = mask_preds.split(num_mask_rois_per_img, 0)
+
+        # TODO: Handle the case where rescale is false
+        results_list = self.mask_head.predict_by_feat(
+            mask_preds=mask_preds,
+            results_list=results_list,
+            batch_img_metas=batch_img_metas,
+            rcnn_test_cfg=self.test_cfg,
+            rescale=rescale)
+        return results_list
diff --git a/mmdetection/mmdet/models/roi_heads/test_mixins.py b/mmdetection/mmdet/models/roi_heads/test_mixins.py
new file mode 100644
index 00000000..94049045
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/test_mixins.py
@@ -0,0 +1,171 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# TODO: delete this file after refactor
+import sys
+
+import torch
+
+from mmdet.models.layers import multiclass_nms
+from mmdet.models.test_time_augs import merge_aug_bboxes, merge_aug_masks
+from mmdet.structures.bbox import bbox2roi, bbox_mapping
+
+if sys.version_info >= (3, 7):
+    from mmdet.utils.contextmanagers import completed
+
+
+class BBoxTestMixin:
+
+    if sys.version_info >= (3, 7):
+        # TODO: Currently not supported
+        async def async_test_bboxes(self,
+                                    x,
+                                    img_metas,
+                                    proposals,
+                                    rcnn_test_cfg,
+                                    rescale=False,
+                                    **kwargs):
+            """Asynchronized test for box head without augmentation."""
+            rois = bbox2roi(proposals)
+            roi_feats = self.bbox_roi_extractor(
+                x[:len(self.bbox_roi_extractor.featmap_strides)], rois)
+            if self.with_shared_head:
+                roi_feats = self.shared_head(roi_feats)
+            sleep_interval = rcnn_test_cfg.get('async_sleep_interval', 0.017)
+
+            async with completed(
+                    __name__, 'bbox_head_forward',
+                    sleep_interval=sleep_interval):
+                cls_score, bbox_pred = self.bbox_head(roi_feats)
+
+            img_shape = img_metas[0]['img_shape']
+            scale_factor = img_metas[0]['scale_factor']
+            det_bboxes, det_labels = self.bbox_head.get_bboxes(
+                rois,
+                cls_score,
+                bbox_pred,
+                img_shape,
+                scale_factor,
+                rescale=rescale,
+                cfg=rcnn_test_cfg)
+            return det_bboxes, det_labels
+
+    # TODO: Currently not supported
+    def aug_test_bboxes(self, feats, img_metas, rpn_results_list,
+                        rcnn_test_cfg):
+        """Test det bboxes with test time augmentation."""
+        aug_bboxes = []
+        aug_scores = []
+        for x, img_meta in zip(feats, img_metas):
+            # only one image in the batch
+            img_shape = img_meta[0]['img_shape']
+            scale_factor = img_meta[0]['scale_factor']
+            flip = img_meta[0]['flip']
+            flip_direction = img_meta[0]['flip_direction']
+            # TODO more flexible
+            proposals = bbox_mapping(rpn_results_list[0][:, :4], img_shape,
+                                     scale_factor, flip, flip_direction)
+            rois = bbox2roi([proposals])
+            bbox_results = self.bbox_forward(x, rois)
+            bboxes, scores = self.bbox_head.get_bboxes(
+                rois,
+                bbox_results['cls_score'],
+                bbox_results['bbox_pred'],
+                img_shape,
+                scale_factor,
+                rescale=False,
+                cfg=None)
+            aug_bboxes.append(bboxes)
+            aug_scores.append(scores)
+        # after merging, bboxes will be rescaled to the original image size
+        merged_bboxes, merged_scores = merge_aug_bboxes(
+            aug_bboxes, aug_scores, img_metas, rcnn_test_cfg)
+        if merged_bboxes.shape[0] == 0:
+            # There is no proposal in the single image
+            det_bboxes = merged_bboxes.new_zeros(0, 5)
+            det_labels = merged_bboxes.new_zeros((0, ), dtype=torch.long)
+        else:
+            det_bboxes, det_labels = multiclass_nms(merged_bboxes,
+                                                    merged_scores,
+                                                    rcnn_test_cfg.score_thr,
+                                                    rcnn_test_cfg.nms,
+                                                    rcnn_test_cfg.max_per_img)
+        return det_bboxes, det_labels
+
+
+class MaskTestMixin:
+
+    if sys.version_info >= (3, 7):
+        # TODO: Currently not supported
+        async def async_test_mask(self,
+                                  x,
+                                  img_metas,
+                                  det_bboxes,
+                                  det_labels,
+                                  rescale=False,
+                                  mask_test_cfg=None):
+            """Asynchronized test for mask head without augmentation."""
+            # image shape of the first image in the batch (only one)
+            ori_shape = img_metas[0]['ori_shape']
+            scale_factor = img_metas[0]['scale_factor']
+            if det_bboxes.shape[0] == 0:
+                segm_result = [[] for _ in range(self.mask_head.num_classes)]
+            else:
+                if rescale and not isinstance(scale_factor,
+                                              (float, torch.Tensor)):
+                    scale_factor = det_bboxes.new_tensor(scale_factor)
+                _bboxes = (
+                    det_bboxes[:, :4] *
+                    scale_factor if rescale else det_bboxes)
+                mask_rois = bbox2roi([_bboxes])
+                mask_feats = self.mask_roi_extractor(
+                    x[:len(self.mask_roi_extractor.featmap_strides)],
+                    mask_rois)
+
+                if self.with_shared_head:
+                    mask_feats = self.shared_head(mask_feats)
+                if mask_test_cfg and \
+                        mask_test_cfg.get('async_sleep_interval'):
+                    sleep_interval = mask_test_cfg['async_sleep_interval']
+                else:
+                    sleep_interval = 0.035
+                async with completed(
+                        __name__,
+                        'mask_head_forward',
+                        sleep_interval=sleep_interval):
+                    mask_pred = self.mask_head(mask_feats)
+                segm_result = self.mask_head.get_results(
+                    mask_pred, _bboxes, det_labels, self.test_cfg, ori_shape,
+                    scale_factor, rescale)
+            return segm_result
+
+    # TODO: Currently not supported
+    def aug_test_mask(self, feats, img_metas, det_bboxes, det_labels):
+        """Test for mask head with test time augmentation."""
+        if det_bboxes.shape[0] == 0:
+            segm_result = [[] for _ in range(self.mask_head.num_classes)]
+        else:
+            aug_masks = []
+            for x, img_meta in zip(feats, img_metas):
+                img_shape = img_meta[0]['img_shape']
+                scale_factor = img_meta[0]['scale_factor']
+                flip = img_meta[0]['flip']
+                flip_direction = img_meta[0]['flip_direction']
+                _bboxes = bbox_mapping(det_bboxes[:, :4], img_shape,
+                                       scale_factor, flip, flip_direction)
+                mask_rois = bbox2roi([_bboxes])
+                mask_results = self._mask_forward(x, mask_rois)
+                # convert to numpy array to save memory
+                aug_masks.append(
+                    mask_results['mask_pred'].sigmoid().cpu().numpy())
+            merged_masks = merge_aug_masks(aug_masks, img_metas, self.test_cfg)
+
+            ori_shape = img_metas[0][0]['ori_shape']
+            scale_factor = det_bboxes.new_ones(4)
+            segm_result = self.mask_head.get_results(
+                merged_masks,
+                det_bboxes,
+                det_labels,
+                self.test_cfg,
+                ori_shape,
+                scale_factor=scale_factor,
+                rescale=False)
+        return segm_result
diff --git a/mmdetection/mmdet/models/roi_heads/trident_roi_head.py b/mmdetection/mmdet/models/roi_heads/trident_roi_head.py
new file mode 100644
index 00000000..52153272
--- /dev/null
+++ b/mmdetection/mmdet/models/roi_heads/trident_roi_head.py
@@ -0,0 +1,112 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Tuple
+
+import torch
+from mmcv.ops import batched_nms
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.utils import InstanceList
+from .standard_roi_head import StandardRoIHead
+
+
+@MODELS.register_module()
+class TridentRoIHead(StandardRoIHead):
+    """Trident roi head.
+
+    Args:
+        num_branch (int): Number of branches in TridentNet.
+        test_branch_idx (int): In inference, all 3 branches will be used
+            if `test_branch_idx==-1`, otherwise only branch with index
+            `test_branch_idx` will be used.
+    """
+
+    def __init__(self, num_branch: int, test_branch_idx: int,
+                 **kwargs) -> None:
+        self.num_branch = num_branch
+        self.test_branch_idx = test_branch_idx
+        super().__init__(**kwargs)
+
+    def merge_trident_bboxes(self,
+                             trident_results: InstanceList) -> InstanceData:
+        """Merge bbox predictions of each branch.
+
+        Args:
+            trident_results (List[:obj:`InstanceData`]): A list of InstanceData
+                predicted from every branch.
+
+        Returns:
+            :obj:`InstanceData`: merged InstanceData.
+        """
+        bboxes = torch.cat([res.bboxes for res in trident_results])
+        scores = torch.cat([res.scores for res in trident_results])
+        labels = torch.cat([res.labels for res in trident_results])
+
+        nms_cfg = self.test_cfg['nms']
+        results = InstanceData()
+        if bboxes.numel() == 0:
+            results.bboxes = bboxes
+            results.scores = scores
+            results.labels = labels
+        else:
+            det_bboxes, keep = batched_nms(bboxes, scores, labels, nms_cfg)
+            results.bboxes = det_bboxes[:, :-1]
+            results.scores = det_bboxes[:, -1]
+            results.labels = labels[keep]
+
+        if self.test_cfg['max_per_img'] > 0:
+            results = results[:self.test_cfg['max_per_img']]
+        return results
+
+    def predict(self,
+                x: Tuple[Tensor],
+                rpn_results_list: InstanceList,
+                batch_data_samples: SampleList,
+                rescale: bool = False) -> InstanceList:
+        """Perform forward propagation of the roi head and predict detection
+        results on the features of the upstream network.
+
+        - Compute prediction bbox and label per branch.
+        - Merge predictions of each branch according to scores of
+          bboxes, i.e., bboxes with higher score are kept to give
+          top-k prediction.
+
+        Args:
+            x (tuple[Tensor]): Features from upstream network. Each
+                has shape (N, C, H, W).
+            rpn_results_list (list[:obj:`InstanceData`]): list of region
+                proposals.
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            rescale (bool): Whether to rescale the results to
+                the original image. Defaults to True.
+
+        Returns:
+            list[obj:`InstanceData`]: Detection results of each image.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        results_list = super().predict(
+            x=x,
+            rpn_results_list=rpn_results_list,
+            batch_data_samples=batch_data_samples,
+            rescale=rescale)
+
+        num_branch = self.num_branch \
+            if self.training or self.test_branch_idx == -1 else 1
+
+        merged_results_list = []
+        for i in range(len(batch_data_samples) // num_branch):
+            merged_results_list.append(
+                self.merge_trident_bboxes(results_list[i * num_branch:(i + 1) *
+                                                       num_branch]))
+        return merged_results_list
diff --git a/mmdetection/mmdet/models/seg_heads/__init__.py b/mmdetection/mmdet/models/seg_heads/__init__.py
new file mode 100644
index 00000000..b489a905
--- /dev/null
+++ b/mmdetection/mmdet/models/seg_heads/__init__.py
@@ -0,0 +1,3 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .panoptic_fpn_head import PanopticFPNHead  # noqa: F401,F403
+from .panoptic_fusion_heads import *  # noqa: F401,F403
diff --git a/mmdetection/mmdet/models/seg_heads/base_semantic_head.py b/mmdetection/mmdet/models/seg_heads/base_semantic_head.py
new file mode 100644
index 00000000..1db71549
--- /dev/null
+++ b/mmdetection/mmdet/models/seg_heads/base_semantic_head.py
@@ -0,0 +1,113 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from abc import ABCMeta, abstractmethod
+from typing import Dict, List, Tuple, Union
+
+import torch.nn.functional as F
+from mmengine.model import BaseModule
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.utils import ConfigType, OptMultiConfig
+
+
+@MODELS.register_module()
+class BaseSemanticHead(BaseModule, metaclass=ABCMeta):
+    """Base module of Semantic Head.
+
+    Args:
+        num_classes (int): the number of classes.
+        seg_rescale_factor (float): the rescale factor for ``gt_sem_seg``,
+            which equals to ``1 / output_strides``. The output_strides is
+            for ``seg_preds``. Defaults to  1 / 4.
+        init_cfg (Optional[Union[:obj:`ConfigDict`, dict]]): the initialization
+            config.
+        loss_seg (Union[:obj:`ConfigDict`, dict]): the loss of the semantic
+            head.
+    """
+
+    def __init__(self,
+                 num_classes: int,
+                 seg_rescale_factor: float = 1 / 4.,
+                 loss_seg: ConfigType = dict(
+                     type='CrossEntropyLoss',
+                     ignore_index=255,
+                     loss_weight=1.0),
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.loss_seg = MODELS.build(loss_seg)
+        self.num_classes = num_classes
+        self.seg_rescale_factor = seg_rescale_factor
+
+    @abstractmethod
+    def forward(self, x: Union[Tensor, Tuple[Tensor]]) -> Dict[str, Tensor]:
+        """Placeholder of forward function.
+
+        Args:
+            x (Tensor): Feature maps.
+
+        Returns:
+            Dict[str, Tensor]: A dictionary, including features
+                and predicted scores. Required keys: 'seg_preds'
+                and 'feats'.
+        """
+        pass
+
+    @abstractmethod
+    def loss(self, x: Union[Tensor, Tuple[Tensor]],
+             batch_data_samples: SampleList) -> Dict[str, Tensor]:
+        """
+        Args:
+            x (Union[Tensor, Tuple[Tensor]]): Feature maps.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Args:
+            x (Tensor): Feature maps.
+
+        Returns:
+            Dict[str, Tensor]: The loss of semantic head.
+        """
+        pass
+
+    def predict(self,
+                x: Union[Tensor, Tuple[Tensor]],
+                batch_img_metas: List[dict],
+                rescale: bool = False) -> List[Tensor]:
+        """Test without Augmentation.
+
+        Args:
+            x (Union[Tensor, Tuple[Tensor]]): Feature maps.
+            batch_img_metas (List[dict]): List of image information.
+            rescale (bool): Whether to rescale the results.
+                Defaults to False.
+
+        Returns:
+            list[Tensor]: semantic segmentation logits.
+        """
+        seg_preds = self.forward(x)['seg_preds']
+        seg_preds = F.interpolate(
+            seg_preds,
+            size=batch_img_metas[0]['batch_input_shape'],
+            mode='bilinear',
+            align_corners=False)
+        seg_preds = [seg_preds[i] for i in range(len(batch_img_metas))]
+
+        if rescale:
+            seg_pred_list = []
+            for i in range(len(batch_img_metas)):
+                h, w = batch_img_metas[i]['img_shape']
+                seg_pred = seg_preds[i][:, :h, :w]
+
+                h, w = batch_img_metas[i]['ori_shape']
+                seg_pred = F.interpolate(
+                    seg_pred[None],
+                    size=(h, w),
+                    mode='bilinear',
+                    align_corners=False)[0]
+                seg_pred_list.append(seg_pred)
+        else:
+            seg_pred_list = seg_preds
+
+        return seg_pred_list
diff --git a/mmdetection/mmdet/models/seg_heads/panoptic_fpn_head.py b/mmdetection/mmdet/models/seg_heads/panoptic_fpn_head.py
new file mode 100644
index 00000000..8d8b9013
--- /dev/null
+++ b/mmdetection/mmdet/models/seg_heads/panoptic_fpn_head.py
@@ -0,0 +1,174 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, Tuple, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmengine.model import ModuleList
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+from ..layers import ConvUpsample
+from ..utils import interpolate_as
+from .base_semantic_head import BaseSemanticHead
+
+
+@MODELS.register_module()
+class PanopticFPNHead(BaseSemanticHead):
+    """PanopticFPNHead used in Panoptic FPN.
+
+    In this head, the number of output channels is ``num_stuff_classes
+    + 1``, including all stuff classes and one thing class. The stuff
+    classes will be reset from ``0`` to ``num_stuff_classes - 1``, the
+    thing classes will be merged to ``num_stuff_classes``-th channel.
+
+    Arg:
+        num_things_classes (int): Number of thing classes. Default: 80.
+        num_stuff_classes (int): Number of stuff classes. Default: 53.
+        in_channels (int): Number of channels in the input feature
+            map.
+        inner_channels (int): Number of channels in inner features.
+        start_level (int): The start level of the input features
+            used in PanopticFPN.
+        end_level (int): The end level of the used features, the
+            ``end_level``-th layer will not be used.
+        conv_cfg (Optional[Union[ConfigDict, dict]]): Dictionary to construct
+            and config conv layer.
+        norm_cfg (Union[ConfigDict, dict]): Dictionary to construct and config
+            norm layer. Use ``GN`` by default.
+        init_cfg (Optional[Union[ConfigDict, dict]]): Initialization config
+            dict.
+        loss_seg (Union[ConfigDict, dict]): the loss of the semantic head.
+    """
+
+    def __init__(self,
+                 num_things_classes: int = 80,
+                 num_stuff_classes: int = 53,
+                 in_channels: int = 256,
+                 inner_channels: int = 128,
+                 start_level: int = 0,
+                 end_level: int = 4,
+                 conv_cfg: OptConfigType = None,
+                 norm_cfg: ConfigType = dict(
+                     type='GN', num_groups=32, requires_grad=True),
+                 loss_seg: ConfigType = dict(
+                     type='CrossEntropyLoss', ignore_index=-1,
+                     loss_weight=1.0),
+                 init_cfg: OptMultiConfig = None) -> None:
+        seg_rescale_factor = 1 / 2**(start_level + 2)
+        super().__init__(
+            num_classes=num_stuff_classes + 1,
+            seg_rescale_factor=seg_rescale_factor,
+            loss_seg=loss_seg,
+            init_cfg=init_cfg)
+        self.num_things_classes = num_things_classes
+        self.num_stuff_classes = num_stuff_classes
+        # Used feature layers are [start_level, end_level)
+        self.start_level = start_level
+        self.end_level = end_level
+        self.num_stages = end_level - start_level
+        self.inner_channels = inner_channels
+
+        self.conv_upsample_layers = ModuleList()
+        for i in range(start_level, end_level):
+            self.conv_upsample_layers.append(
+                ConvUpsample(
+                    in_channels,
+                    inner_channels,
+                    num_layers=i if i > 0 else 1,
+                    num_upsample=i if i > 0 else 0,
+                    conv_cfg=conv_cfg,
+                    norm_cfg=norm_cfg,
+                ))
+        self.conv_logits = nn.Conv2d(inner_channels, self.num_classes, 1)
+
+    def _set_things_to_void(self, gt_semantic_seg: Tensor) -> Tensor:
+        """Merge thing classes to one class.
+
+        In PanopticFPN, the background labels will be reset from `0` to
+        `self.num_stuff_classes-1`, the foreground labels will be merged to
+        `self.num_stuff_classes`-th channel.
+        """
+        gt_semantic_seg = gt_semantic_seg.int()
+        fg_mask = gt_semantic_seg < self.num_things_classes
+        bg_mask = (gt_semantic_seg >= self.num_things_classes) * (
+            gt_semantic_seg < self.num_things_classes + self.num_stuff_classes)
+
+        new_gt_seg = torch.clone(gt_semantic_seg)
+        new_gt_seg = torch.where(bg_mask,
+                                 gt_semantic_seg - self.num_things_classes,
+                                 new_gt_seg)
+        new_gt_seg = torch.where(fg_mask,
+                                 fg_mask.int() * self.num_stuff_classes,
+                                 new_gt_seg)
+        return new_gt_seg
+
+    def loss(self, x: Union[Tensor, Tuple[Tensor]],
+             batch_data_samples: SampleList) -> Dict[str, Tensor]:
+        """
+        Args:
+            x (Union[Tensor, Tuple[Tensor]]): Feature maps.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            Dict[str, Tensor]: The loss of semantic head.
+        """
+        seg_preds = self(x)['seg_preds']
+        gt_semantic_segs = [
+            data_sample.gt_sem_seg.sem_seg
+            for data_sample in batch_data_samples
+        ]
+
+        gt_semantic_segs = torch.stack(gt_semantic_segs)
+        if self.seg_rescale_factor != 1.0:
+            gt_semantic_segs = F.interpolate(
+                gt_semantic_segs.float(),
+                scale_factor=self.seg_rescale_factor,
+                mode='nearest').squeeze(1)
+
+        # Things classes will be merged to one class in PanopticFPN.
+        gt_semantic_segs = self._set_things_to_void(gt_semantic_segs)
+
+        if seg_preds.shape[-2:] != gt_semantic_segs.shape[-2:]:
+            seg_preds = interpolate_as(seg_preds, gt_semantic_segs)
+        seg_preds = seg_preds.permute((0, 2, 3, 1))
+
+        loss_seg = self.loss_seg(
+            seg_preds.reshape(-1, self.num_classes),  # => [NxHxW, C]
+            gt_semantic_segs.reshape(-1).long())
+
+        return dict(loss_seg=loss_seg)
+
+    def init_weights(self) -> None:
+        """Initialize weights."""
+        super().init_weights()
+        nn.init.normal_(self.conv_logits.weight.data, 0, 0.01)
+        self.conv_logits.bias.data.zero_()
+
+    def forward(self, x: Tuple[Tensor]) -> Dict[str, Tensor]:
+        """Forward.
+
+        Args:
+            x (Tuple[Tensor]): Multi scale Feature maps.
+
+        Returns:
+            dict[str, Tensor]: semantic segmentation predictions and
+                feature maps.
+        """
+        # the number of subnets must be not more than
+        # the length of features.
+        assert self.num_stages <= len(x)
+
+        feats = []
+        for i, layer in enumerate(self.conv_upsample_layers):
+            f = layer(x[self.start_level + i])
+            feats.append(f)
+
+        seg_feats = torch.sum(torch.stack(feats, dim=0), dim=0)
+        seg_preds = self.conv_logits(seg_feats)
+        out = dict(seg_preds=seg_preds, seg_feats=seg_feats)
+        return out
diff --git a/mmdetection/mmdet/models/seg_heads/panoptic_fusion_heads/__init__.py b/mmdetection/mmdet/models/seg_heads/panoptic_fusion_heads/__init__.py
new file mode 100644
index 00000000..41625a61
--- /dev/null
+++ b/mmdetection/mmdet/models/seg_heads/panoptic_fusion_heads/__init__.py
@@ -0,0 +1,5 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .base_panoptic_fusion_head import \
+    BasePanopticFusionHead  # noqa: F401,F403
+from .heuristic_fusion_head import HeuristicFusionHead  # noqa: F401,F403
+from .maskformer_fusion_head import MaskFormerFusionHead  # noqa: F401,F403
diff --git a/mmdetection/mmdet/models/seg_heads/panoptic_fusion_heads/base_panoptic_fusion_head.py b/mmdetection/mmdet/models/seg_heads/panoptic_fusion_heads/base_panoptic_fusion_head.py
new file mode 100644
index 00000000..f6b20e1c
--- /dev/null
+++ b/mmdetection/mmdet/models/seg_heads/panoptic_fusion_heads/base_panoptic_fusion_head.py
@@ -0,0 +1,43 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from abc import ABCMeta, abstractmethod
+
+from mmengine.model import BaseModule
+
+from mmdet.registry import MODELS
+from mmdet.utils import OptConfigType, OptMultiConfig
+
+
+@MODELS.register_module()
+class BasePanopticFusionHead(BaseModule, metaclass=ABCMeta):
+    """Base class for panoptic heads."""
+
+    def __init__(self,
+                 num_things_classes: int = 80,
+                 num_stuff_classes: int = 53,
+                 test_cfg: OptConfigType = None,
+                 loss_panoptic: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None,
+                 **kwargs) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.num_things_classes = num_things_classes
+        self.num_stuff_classes = num_stuff_classes
+        self.num_classes = num_things_classes + num_stuff_classes
+        self.test_cfg = test_cfg
+
+        if loss_panoptic:
+            self.loss_panoptic = MODELS.build(loss_panoptic)
+        else:
+            self.loss_panoptic = None
+
+    @property
+    def with_loss(self) -> bool:
+        """bool: whether the panoptic head contains loss function."""
+        return self.loss_panoptic is not None
+
+    @abstractmethod
+    def loss(self, **kwargs):
+        """Loss function."""
+
+    @abstractmethod
+    def predict(self, **kwargs):
+        """Predict function."""
diff --git a/mmdetection/mmdet/models/seg_heads/panoptic_fusion_heads/heuristic_fusion_head.py b/mmdetection/mmdet/models/seg_heads/panoptic_fusion_heads/heuristic_fusion_head.py
new file mode 100644
index 00000000..7a4a4200
--- /dev/null
+++ b/mmdetection/mmdet/models/seg_heads/panoptic_fusion_heads/heuristic_fusion_head.py
@@ -0,0 +1,159 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List
+
+import torch
+from mmengine.structures import InstanceData, PixelData
+from torch import Tensor
+
+from mmdet.evaluation.functional import INSTANCE_OFFSET
+from mmdet.registry import MODELS
+from mmdet.utils import InstanceList, OptConfigType, OptMultiConfig, PixelList
+from .base_panoptic_fusion_head import BasePanopticFusionHead
+
+
+@MODELS.register_module()
+class HeuristicFusionHead(BasePanopticFusionHead):
+    """Fusion Head with Heuristic method."""
+
+    def __init__(self,
+                 num_things_classes: int = 80,
+                 num_stuff_classes: int = 53,
+                 test_cfg: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None,
+                 **kwargs) -> None:
+        super().__init__(
+            num_things_classes=num_things_classes,
+            num_stuff_classes=num_stuff_classes,
+            test_cfg=test_cfg,
+            loss_panoptic=None,
+            init_cfg=init_cfg,
+            **kwargs)
+
+    def loss(self, **kwargs) -> dict:
+        """HeuristicFusionHead has no training loss."""
+        return dict()
+
+    def _lay_masks(self,
+                   mask_results: InstanceData,
+                   overlap_thr: float = 0.5) -> Tensor:
+        """Lay instance masks to a result map.
+
+        Args:
+            mask_results (:obj:`InstanceData`): Instance segmentation results,
+                each contains ``bboxes``, ``labels``, ``scores`` and ``masks``.
+            overlap_thr (float): Threshold to determine whether two masks
+                overlap. default: 0.5.
+
+        Returns:
+            Tensor: The result map, (H, W).
+        """
+        bboxes = mask_results.bboxes
+        scores = mask_results.scores
+        labels = mask_results.labels
+        masks = mask_results.masks
+
+        num_insts = bboxes.shape[0]
+        id_map = torch.zeros(
+            masks.shape[-2:], device=bboxes.device, dtype=torch.long)
+        if num_insts == 0:
+            return id_map, labels
+
+        # Sort by score to use heuristic fusion
+        order = torch.argsort(-scores)
+        bboxes = bboxes[order]
+        labels = labels[order]
+        segm_masks = masks[order]
+
+        instance_id = 1
+        left_labels = []
+        for idx in range(bboxes.shape[0]):
+            _cls = labels[idx]
+            _mask = segm_masks[idx]
+            instance_id_map = torch.ones_like(
+                _mask, dtype=torch.long) * instance_id
+            area = _mask.sum()
+            if area == 0:
+                continue
+
+            pasted = id_map > 0
+            intersect = (_mask * pasted).sum()
+            if (intersect / (area + 1e-5)) > overlap_thr:
+                continue
+
+            _part = _mask * (~pasted)
+            id_map = torch.where(_part, instance_id_map, id_map)
+            left_labels.append(_cls)
+            instance_id += 1
+
+        if len(left_labels) > 0:
+            instance_labels = torch.stack(left_labels)
+        else:
+            instance_labels = bboxes.new_zeros((0, ), dtype=torch.long)
+        assert instance_id == (len(instance_labels) + 1)
+        return id_map, instance_labels
+
+    def _predict_single(self, mask_results: InstanceData, seg_preds: Tensor,
+                        **kwargs) -> PixelData:
+        """Fuse the results of instance and semantic segmentations.
+
+        Args:
+            mask_results (:obj:`InstanceData`): Instance segmentation results,
+                each contains ``bboxes``, ``labels``, ``scores`` and ``masks``.
+            seg_preds (Tensor): The semantic segmentation results,
+                (num_stuff + 1, H, W).
+
+        Returns:
+            Tensor: The panoptic segmentation result, (H, W).
+        """
+        id_map, labels = self._lay_masks(mask_results,
+                                         self.test_cfg.mask_overlap)
+
+        seg_results = seg_preds.argmax(dim=0)
+        seg_results = seg_results + self.num_things_classes
+
+        pan_results = seg_results
+        instance_id = 1
+        for idx in range(len(mask_results)):
+            _mask = id_map == (idx + 1)
+            if _mask.sum() == 0:
+                continue
+            _cls = labels[idx]
+            # simply trust detection
+            segment_id = _cls + instance_id * INSTANCE_OFFSET
+            pan_results[_mask] = segment_id
+            instance_id += 1
+
+        ids, counts = torch.unique(
+            pan_results % INSTANCE_OFFSET, return_counts=True)
+        stuff_ids = ids[ids >= self.num_things_classes]
+        stuff_counts = counts[ids >= self.num_things_classes]
+        ignore_stuff_ids = stuff_ids[
+            stuff_counts < self.test_cfg.stuff_area_limit]
+
+        assert pan_results.ndim == 2
+        pan_results[(pan_results.unsqueeze(2) == ignore_stuff_ids.reshape(
+            1, 1, -1)).any(dim=2)] = self.num_classes
+
+        pan_results = PixelData(sem_seg=pan_results[None].int())
+        return pan_results
+
+    def predict(self, mask_results_list: InstanceList,
+                seg_preds_list: List[Tensor], **kwargs) -> PixelList:
+        """Predict results by fusing the results of instance and semantic
+        segmentations.
+
+        Args:
+            mask_results_list (list[:obj:`InstanceData`]): Instance
+                segmentation results, each contains ``bboxes``, ``labels``,
+                ``scores`` and ``masks``.
+            seg_preds_list (Tensor): List of semantic segmentation results.
+
+        Returns:
+            List[PixelData]: Panoptic segmentation result.
+        """
+        results_list = [
+            self._predict_single(mask_results_list[i], seg_preds_list[i])
+            for i in range(len(mask_results_list))
+        ]
+
+        return results_list
diff --git a/mmdetection/mmdet/models/seg_heads/panoptic_fusion_heads/maskformer_fusion_head.py b/mmdetection/mmdet/models/seg_heads/panoptic_fusion_heads/maskformer_fusion_head.py
new file mode 100644
index 00000000..1b76e6b4
--- /dev/null
+++ b/mmdetection/mmdet/models/seg_heads/panoptic_fusion_heads/maskformer_fusion_head.py
@@ -0,0 +1,266 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List
+
+import torch
+import torch.nn.functional as F
+from mmengine.structures import InstanceData, PixelData
+from torch import Tensor
+
+from mmdet.evaluation.functional import INSTANCE_OFFSET
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.structures.mask import mask2bbox
+from mmdet.utils import OptConfigType, OptMultiConfig
+from .base_panoptic_fusion_head import BasePanopticFusionHead
+
+
+@MODELS.register_module()
+class MaskFormerFusionHead(BasePanopticFusionHead):
+    """MaskFormer fusion head which postprocesses results for panoptic
+    segmentation, instance segmentation and semantic segmentation."""
+
+    def __init__(self,
+                 num_things_classes: int = 80,
+                 num_stuff_classes: int = 53,
+                 test_cfg: OptConfigType = None,
+                 loss_panoptic: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None,
+                 **kwargs):
+        super().__init__(
+            num_things_classes=num_things_classes,
+            num_stuff_classes=num_stuff_classes,
+            test_cfg=test_cfg,
+            loss_panoptic=loss_panoptic,
+            init_cfg=init_cfg,
+            **kwargs)
+
+    def loss(self, **kwargs):
+        """MaskFormerFusionHead has no training loss."""
+        return dict()
+
+    def panoptic_postprocess(self, mask_cls: Tensor,
+                             mask_pred: Tensor) -> PixelData:
+        """Panoptic segmengation inference.
+
+        Args:
+            mask_cls (Tensor): Classfication outputs of shape
+                (num_queries, cls_out_channels) for a image.
+                Note `cls_out_channels` should includes
+                background.
+            mask_pred (Tensor): Mask outputs of shape
+                (num_queries, h, w) for a image.
+
+        Returns:
+            :obj:`PixelData`: Panoptic segment result of shape \
+                (h, w), each element in Tensor means: \
+                ``segment_id = _cls + instance_id * INSTANCE_OFFSET``.
+        """
+        object_mask_thr = self.test_cfg.get('object_mask_thr', 0.8)
+        iou_thr = self.test_cfg.get('iou_thr', 0.8)
+        filter_low_score = self.test_cfg.get('filter_low_score', False)
+
+        scores, labels = F.softmax(mask_cls, dim=-1).max(-1)
+        mask_pred = mask_pred.sigmoid()
+
+        keep = labels.ne(self.num_classes) & (scores > object_mask_thr)
+        cur_scores = scores[keep]
+        cur_classes = labels[keep]
+        cur_masks = mask_pred[keep]
+
+        cur_prob_masks = cur_scores.view(-1, 1, 1) * cur_masks
+
+        h, w = cur_masks.shape[-2:]
+        panoptic_seg = torch.full((h, w),
+                                  self.num_classes,
+                                  dtype=torch.int32,
+                                  device=cur_masks.device)
+        if cur_masks.shape[0] == 0:
+            # We didn't detect any mask :(
+            pass
+        else:
+            cur_mask_ids = cur_prob_masks.argmax(0)
+            instance_id = 1
+            for k in range(cur_classes.shape[0]):
+                pred_class = int(cur_classes[k].item())
+                isthing = pred_class < self.num_things_classes
+                mask = cur_mask_ids == k
+                mask_area = mask.sum().item()
+                original_area = (cur_masks[k] >= 0.5).sum().item()
+
+                if filter_low_score:
+                    mask = mask & (cur_masks[k] >= 0.5)
+
+                if mask_area > 0 and original_area > 0:
+                    if mask_area / original_area < iou_thr:
+                        continue
+
+                    if not isthing:
+                        # different stuff regions of same class will be
+                        # merged here, and stuff share the instance_id 0.
+                        panoptic_seg[mask] = pred_class
+                    else:
+                        panoptic_seg[mask] = (
+                            pred_class + instance_id * INSTANCE_OFFSET)
+                        instance_id += 1
+
+        return PixelData(sem_seg=panoptic_seg[None])
+
+    def semantic_postprocess(self, mask_cls: Tensor,
+                             mask_pred: Tensor) -> PixelData:
+        """Semantic segmengation postprocess.
+
+        Args:
+            mask_cls (Tensor): Classfication outputs of shape
+                (num_queries, cls_out_channels) for a image.
+                Note `cls_out_channels` should includes
+                background.
+            mask_pred (Tensor): Mask outputs of shape
+                (num_queries, h, w) for a image.
+
+        Returns:
+            :obj:`PixelData`: Semantic segment result.
+        """
+        # TODO add semantic segmentation result
+        raise NotImplementedError
+
+    def instance_postprocess(self, mask_cls: Tensor,
+                             mask_pred: Tensor) -> InstanceData:
+        """Instance segmengation postprocess.
+
+        Args:
+            mask_cls (Tensor): Classfication outputs of shape
+                (num_queries, cls_out_channels) for a image.
+                Note `cls_out_channels` should includes
+                background.
+            mask_pred (Tensor): Mask outputs of shape
+                (num_queries, h, w) for a image.
+
+        Returns:
+            :obj:`InstanceData`: Instance segmentation results.
+
+                - scores (Tensor): Classification scores, has a shape
+                    (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                    (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                    the last dimension 4 arrange as (x1, y1, x2, y2).
+                - masks (Tensor): Has a shape (num_instances, H, W).
+        """
+        max_per_image = self.test_cfg.get('max_per_image', 100)
+        num_queries = mask_cls.shape[0]
+        # shape (num_queries, num_class)
+        scores = F.softmax(mask_cls, dim=-1)[:, :-1]
+        # shape (num_queries * num_class, )
+        labels = torch.arange(self.num_classes, device=mask_cls.device).\
+            unsqueeze(0).repeat(num_queries, 1).flatten(0, 1)
+        scores_per_image, top_indices = scores.flatten(0, 1).topk(
+            max_per_image, sorted=False)
+        labels_per_image = labels[top_indices]
+
+        query_indices = top_indices // self.num_classes
+        mask_pred = mask_pred[query_indices]
+
+        # extract things
+        is_thing = labels_per_image < self.num_things_classes
+        scores_per_image = scores_per_image[is_thing]
+        labels_per_image = labels_per_image[is_thing]
+        mask_pred = mask_pred[is_thing]
+
+        mask_pred_binary = (mask_pred > 0).float()
+        mask_scores_per_image = (mask_pred.sigmoid() *
+                                 mask_pred_binary).flatten(1).sum(1) / (
+                                     mask_pred_binary.flatten(1).sum(1) + 1e-6)
+        det_scores = scores_per_image * mask_scores_per_image
+        mask_pred_binary = mask_pred_binary.bool()
+        bboxes = mask2bbox(mask_pred_binary)
+
+        results = InstanceData()
+        results.bboxes = bboxes
+        results.labels = labels_per_image
+        results.scores = det_scores
+        results.masks = mask_pred_binary
+        return results
+
+    def predict(self,
+                mask_cls_results: Tensor,
+                mask_pred_results: Tensor,
+                batch_data_samples: SampleList,
+                rescale: bool = False,
+                **kwargs) -> List[dict]:
+        """Test segment without test-time aumengtation.
+
+        Only the output of last decoder layers was used.
+
+        Args:
+            mask_cls_results (Tensor): Mask classification logits,
+                shape (batch_size, num_queries, cls_out_channels).
+                Note `cls_out_channels` should includes background.
+            mask_pred_results (Tensor): Mask logits, shape
+                (batch_size, num_queries, h, w).
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            rescale (bool): If True, return boxes in
+                original image space. Default False.
+
+        Returns:
+            list[dict]: Instance segmentation \
+                results and panoptic segmentation results for each \
+                image.
+
+            .. code-block:: none
+
+                [
+                    {
+                        'pan_results': PixelData,
+                        'ins_results': InstanceData,
+                        # semantic segmentation results are not supported yet
+                        'sem_results': PixelData
+                    },
+                    ...
+                ]
+        """
+        batch_img_metas = [
+            data_sample.metainfo for data_sample in batch_data_samples
+        ]
+        panoptic_on = self.test_cfg.get('panoptic_on', True)
+        semantic_on = self.test_cfg.get('semantic_on', False)
+        instance_on = self.test_cfg.get('instance_on', False)
+        assert not semantic_on, 'segmantic segmentation '\
+            'results are not supported yet.'
+
+        results = []
+        for mask_cls_result, mask_pred_result, meta in zip(
+                mask_cls_results, mask_pred_results, batch_img_metas):
+            # remove padding
+            img_height, img_width = meta['img_shape'][:2]
+            mask_pred_result = mask_pred_result[:, :img_height, :img_width]
+
+            if rescale:
+                # return result in original resolution
+                ori_height, ori_width = meta['ori_shape'][:2]
+                mask_pred_result = F.interpolate(
+                    mask_pred_result[:, None],
+                    size=(ori_height, ori_width),
+                    mode='bilinear',
+                    align_corners=False)[:, 0]
+
+            result = dict()
+            if panoptic_on:
+                pan_results = self.panoptic_postprocess(
+                    mask_cls_result, mask_pred_result)
+                result['pan_results'] = pan_results
+
+            if instance_on:
+                ins_results = self.instance_postprocess(
+                    mask_cls_result, mask_pred_result)
+                result['ins_results'] = ins_results
+
+            if semantic_on:
+                sem_results = self.semantic_postprocess(
+                    mask_cls_result, mask_pred_result)
+                result['sem_results'] = sem_results
+
+            results.append(result)
+
+        return results
diff --git a/mmdetection/mmdet/models/task_modules/__init__.py b/mmdetection/mmdet/models/task_modules/__init__.py
new file mode 100644
index 00000000..7bfd8f05
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/__init__.py
@@ -0,0 +1,18 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .assigners import *  # noqa: F401,F403
+from .builder import (ANCHOR_GENERATORS, BBOX_ASSIGNERS, BBOX_CODERS,
+                      BBOX_SAMPLERS, IOU_CALCULATORS, MATCH_COSTS,
+                      PRIOR_GENERATORS, build_anchor_generator, build_assigner,
+                      build_bbox_coder, build_iou_calculator, build_match_cost,
+                      build_prior_generator, build_sampler)
+from .coders import *  # noqa: F401,F403
+from .prior_generators import *  # noqa: F401,F403
+from .samplers import *  # noqa: F401,F403
+from .tracking import *  # noqa: F401,F403
+
+__all__ = [
+    'ANCHOR_GENERATORS', 'PRIOR_GENERATORS', 'BBOX_ASSIGNERS', 'BBOX_SAMPLERS',
+    'MATCH_COSTS', 'BBOX_CODERS', 'IOU_CALCULATORS', 'build_anchor_generator',
+    'build_prior_generator', 'build_assigner', 'build_sampler',
+    'build_iou_calculator', 'build_match_cost', 'build_bbox_coder'
+]
diff --git a/mmdetection/mmdet/models/task_modules/assigners/__init__.py b/mmdetection/mmdet/models/task_modules/assigners/__init__.py
new file mode 100644
index 00000000..4e564f24
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/assigners/__init__.py
@@ -0,0 +1,32 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .approx_max_iou_assigner import ApproxMaxIoUAssigner
+from .assign_result import AssignResult
+from .atss_assigner import ATSSAssigner
+from .base_assigner import BaseAssigner
+from .center_region_assigner import CenterRegionAssigner
+from .dynamic_soft_label_assigner import DynamicSoftLabelAssigner
+from .grid_assigner import GridAssigner
+from .hungarian_assigner import HungarianAssigner
+from .iou2d_calculator import BboxOverlaps2D, BboxOverlaps2D_GLIP
+from .match_cost import (BBoxL1Cost, BinaryFocalLossCost, ClassificationCost,
+                         CrossEntropyLossCost, DiceCost, FocalLossCost,
+                         IoUCost)
+from .max_iou_assigner import MaxIoUAssigner
+from .multi_instance_assigner import MultiInstanceAssigner
+from .point_assigner import PointAssigner
+from .region_assigner import RegionAssigner
+from .sim_ota_assigner import SimOTAAssigner
+from .task_aligned_assigner import TaskAlignedAssigner
+from .topk_hungarian_assigner import TopkHungarianAssigner
+from .uniform_assigner import UniformAssigner
+
+__all__ = [
+    'BaseAssigner', 'BinaryFocalLossCost', 'MaxIoUAssigner',
+    'ApproxMaxIoUAssigner', 'AssignResult', 'PointAssigner', 'ATSSAssigner',
+    'CenterRegionAssigner', 'GridAssigner', 'HungarianAssigner',
+    'RegionAssigner', 'UniformAssigner', 'SimOTAAssigner',
+    'TaskAlignedAssigner', 'TopkHungarianAssigner', 'BBoxL1Cost',
+    'ClassificationCost', 'CrossEntropyLossCost', 'DiceCost', 'FocalLossCost',
+    'IoUCost', 'BboxOverlaps2D', 'DynamicSoftLabelAssigner',
+    'MultiInstanceAssigner', 'BboxOverlaps2D_GLIP'
+]
diff --git a/mmdetection/mmdet/models/task_modules/assigners/approx_max_iou_assigner.py b/mmdetection/mmdet/models/task_modules/assigners/approx_max_iou_assigner.py
new file mode 100644
index 00000000..471d54e5
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/assigners/approx_max_iou_assigner.py
@@ -0,0 +1,162 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Union
+
+import torch
+from mmengine.config import ConfigDict
+from mmengine.structures import InstanceData
+
+from mmdet.registry import TASK_UTILS
+from .assign_result import AssignResult
+from .max_iou_assigner import MaxIoUAssigner
+
+
+@TASK_UTILS.register_module()
+class ApproxMaxIoUAssigner(MaxIoUAssigner):
+    """Assign a corresponding gt bbox or background to each bbox.
+
+    Each proposals will be assigned with an integer indicating the ground truth
+     index. (semi-positive index: gt label (0-based), -1: background)
+
+    - -1: negative sample, no assigned gt
+    - semi-positive integer: positive sample, index (0-based) of assigned gt
+
+    Args:
+        pos_iou_thr (float): IoU threshold for positive bboxes.
+        neg_iou_thr (float or tuple): IoU threshold for negative bboxes.
+        min_pos_iou (float): Minimum iou for a bbox to be considered as a
+            positive bbox. Positive samples can have smaller IoU than
+            pos_iou_thr due to the 4th step (assign max IoU sample to each gt).
+        gt_max_assign_all (bool): Whether to assign all bboxes with the same
+            highest overlap with some gt to that gt.
+        ignore_iof_thr (float): IoF threshold for ignoring bboxes (if
+            `gt_bboxes_ignore` is specified). Negative values mean not
+            ignoring any bboxes.
+        ignore_wrt_candidates (bool): Whether to compute the iof between
+            `bboxes` and `gt_bboxes_ignore`, or the contrary.
+        match_low_quality (bool): Whether to allow quality matches. This is
+            usually allowed for RPN and single stage detectors, but not allowed
+            in the second stage.
+        gpu_assign_thr (int): The upper bound of the number of GT for GPU
+            assign. When the number of gt is above this threshold, will assign
+            on CPU device. Negative values mean not assign on CPU.
+        iou_calculator (:obj:`ConfigDict` or dict): Config of overlaps
+            Calculator.
+    """
+
+    def __init__(
+        self,
+        pos_iou_thr: float,
+        neg_iou_thr: Union[float, tuple],
+        min_pos_iou: float = .0,
+        gt_max_assign_all: bool = True,
+        ignore_iof_thr: float = -1,
+        ignore_wrt_candidates: bool = True,
+        match_low_quality: bool = True,
+        gpu_assign_thr: int = -1,
+        iou_calculator: Union[ConfigDict, dict] = dict(type='BboxOverlaps2D')
+    ) -> None:
+        self.pos_iou_thr = pos_iou_thr
+        self.neg_iou_thr = neg_iou_thr
+        self.min_pos_iou = min_pos_iou
+        self.gt_max_assign_all = gt_max_assign_all
+        self.ignore_iof_thr = ignore_iof_thr
+        self.ignore_wrt_candidates = ignore_wrt_candidates
+        self.gpu_assign_thr = gpu_assign_thr
+        self.match_low_quality = match_low_quality
+        self.iou_calculator = TASK_UTILS.build(iou_calculator)
+
+    def assign(self,
+               pred_instances: InstanceData,
+               gt_instances: InstanceData,
+               gt_instances_ignore: Optional[InstanceData] = None,
+               **kwargs) -> AssignResult:
+        """Assign gt to approxs.
+
+        This method assign a gt bbox to each group of approxs (bboxes),
+        each group of approxs is represent by a base approx (bbox) and
+        will be assigned with -1, or a semi-positive number.
+        background_label (-1) means negative sample,
+        semi-positive number is the index (0-based) of assigned gt.
+        The assignment is done in following steps, the order matters.
+
+        1. assign every bbox to background_label (-1)
+        2. use the max IoU of each group of approxs to assign
+        2. assign proposals whose iou with all gts < neg_iou_thr to background
+        3. for each bbox, if the iou with its nearest gt >= pos_iou_thr,
+           assign it to that bbox
+        4. for each gt bbox, assign its nearest proposals (may be more than
+           one) to itself
+
+        Args:
+            pred_instances (:obj:`InstanceData`): Instances of model
+                predictions. It includes ``priors``, and the priors can
+                be anchors or points, or the bboxes predicted by the
+                previous stage, has shape (n, 4). ``approxs`` means the
+                group of approxs aligned with ``priors``, has shape
+                (n, num_approxs, 4).
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes``, with shape (k, 4),
+                and ``labels``, with shape (k, ).
+            gt_instances_ignore (:obj:`InstanceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes``
+                attribute data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            :obj:`AssignResult`: The assign result.
+        """
+        squares = pred_instances.priors
+        approxs = pred_instances.approxs
+        gt_bboxes = gt_instances.bboxes
+        gt_labels = gt_instances.labels
+        gt_bboxes_ignore = None if gt_instances_ignore is None else \
+            gt_instances_ignore.get('bboxes', None)
+        approxs_per_octave = approxs.size(1)
+
+        num_squares = squares.size(0)
+        num_gts = gt_bboxes.size(0)
+
+        if num_squares == 0 or num_gts == 0:
+            # No predictions and/or truth, return empty assignment
+            overlaps = approxs.new(num_gts, num_squares)
+            assign_result = self.assign_wrt_overlaps(overlaps, gt_labels)
+            return assign_result
+
+        # re-organize anchors by approxs_per_octave x num_squares
+        approxs = torch.transpose(approxs, 0, 1).contiguous().view(-1, 4)
+        assign_on_cpu = True if (self.gpu_assign_thr > 0) and (
+            num_gts > self.gpu_assign_thr) else False
+        # compute overlap and assign gt on CPU when number of GT is large
+        if assign_on_cpu:
+            device = approxs.device
+            approxs = approxs.cpu()
+            gt_bboxes = gt_bboxes.cpu()
+            if gt_bboxes_ignore is not None:
+                gt_bboxes_ignore = gt_bboxes_ignore.cpu()
+            if gt_labels is not None:
+                gt_labels = gt_labels.cpu()
+        all_overlaps = self.iou_calculator(approxs, gt_bboxes)
+
+        overlaps, _ = all_overlaps.view(approxs_per_octave, num_squares,
+                                        num_gts).max(dim=0)
+        overlaps = torch.transpose(overlaps, 0, 1)
+
+        if (self.ignore_iof_thr > 0 and gt_bboxes_ignore is not None
+                and gt_bboxes_ignore.numel() > 0 and squares.numel() > 0):
+            if self.ignore_wrt_candidates:
+                ignore_overlaps = self.iou_calculator(
+                    squares, gt_bboxes_ignore, mode='iof')
+                ignore_max_overlaps, _ = ignore_overlaps.max(dim=1)
+            else:
+                ignore_overlaps = self.iou_calculator(
+                    gt_bboxes_ignore, squares, mode='iof')
+                ignore_max_overlaps, _ = ignore_overlaps.max(dim=0)
+            overlaps[:, ignore_max_overlaps > self.ignore_iof_thr] = -1
+
+        assign_result = self.assign_wrt_overlaps(overlaps, gt_labels)
+        if assign_on_cpu:
+            assign_result.gt_inds = assign_result.gt_inds.to(device)
+            assign_result.max_overlaps = assign_result.max_overlaps.to(device)
+            if assign_result.labels is not None:
+                assign_result.labels = assign_result.labels.to(device)
+        return assign_result
diff --git a/mmdetection/mmdet/models/task_modules/assigners/assign_result.py b/mmdetection/mmdet/models/task_modules/assigners/assign_result.py
new file mode 100644
index 00000000..56ca2c3c
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/assigners/assign_result.py
@@ -0,0 +1,198 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from torch import Tensor
+
+from mmdet.utils import util_mixins
+
+
+class AssignResult(util_mixins.NiceRepr):
+    """Stores assignments between predicted and truth boxes.
+
+    Attributes:
+        num_gts (int): the number of truth boxes considered when computing this
+            assignment
+        gt_inds (Tensor): for each predicted box indicates the 1-based
+            index of the assigned truth box. 0 means unassigned and -1 means
+            ignore.
+        max_overlaps (Tensor): the iou between the predicted box and its
+            assigned truth box.
+        labels (Tensor): If specified, for each predicted box
+            indicates the category label of the assigned truth box.
+
+    Example:
+        >>> # An assign result between 4 predicted boxes and 9 true boxes
+        >>> # where only two boxes were assigned.
+        >>> num_gts = 9
+        >>> max_overlaps = torch.LongTensor([0, .5, .9, 0])
+        >>> gt_inds = torch.LongTensor([-1, 1, 2, 0])
+        >>> labels = torch.LongTensor([0, 3, 4, 0])
+        >>> self = AssignResult(num_gts, gt_inds, max_overlaps, labels)
+        >>> print(str(self))  # xdoctest: +IGNORE_WANT
+        
+        >>> # Force addition of gt labels (when adding gt as proposals)
+        >>> new_labels = torch.LongTensor([3, 4, 5])
+        >>> self.add_gt_(new_labels)
+        >>> print(str(self))  # xdoctest: +IGNORE_WANT
+        
+    """
+
+    def __init__(self, num_gts: int, gt_inds: Tensor, max_overlaps: Tensor,
+                 labels: Tensor) -> None:
+        self.num_gts = num_gts
+        self.gt_inds = gt_inds
+        self.max_overlaps = max_overlaps
+        self.labels = labels
+        # Interface for possible user-defined properties
+        self._extra_properties = {}
+
+    @property
+    def num_preds(self):
+        """int: the number of predictions in this assignment"""
+        return len(self.gt_inds)
+
+    def set_extra_property(self, key, value):
+        """Set user-defined new property."""
+        assert key not in self.info
+        self._extra_properties[key] = value
+
+    def get_extra_property(self, key):
+        """Get user-defined property."""
+        return self._extra_properties.get(key, None)
+
+    @property
+    def info(self):
+        """dict: a dictionary of info about the object"""
+        basic_info = {
+            'num_gts': self.num_gts,
+            'num_preds': self.num_preds,
+            'gt_inds': self.gt_inds,
+            'max_overlaps': self.max_overlaps,
+            'labels': self.labels,
+        }
+        basic_info.update(self._extra_properties)
+        return basic_info
+
+    def __nice__(self):
+        """str: a "nice" summary string describing this assign result"""
+        parts = []
+        parts.append(f'num_gts={self.num_gts!r}')
+        if self.gt_inds is None:
+            parts.append(f'gt_inds={self.gt_inds!r}')
+        else:
+            parts.append(f'gt_inds.shape={tuple(self.gt_inds.shape)!r}')
+        if self.max_overlaps is None:
+            parts.append(f'max_overlaps={self.max_overlaps!r}')
+        else:
+            parts.append('max_overlaps.shape='
+                         f'{tuple(self.max_overlaps.shape)!r}')
+        if self.labels is None:
+            parts.append(f'labels={self.labels!r}')
+        else:
+            parts.append(f'labels.shape={tuple(self.labels.shape)!r}')
+        return ', '.join(parts)
+
+    @classmethod
+    def random(cls, **kwargs):
+        """Create random AssignResult for tests or debugging.
+
+        Args:
+            num_preds: number of predicted boxes
+            num_gts: number of true boxes
+            p_ignore (float): probability of a predicted box assigned to an
+                ignored truth
+            p_assigned (float): probability of a predicted box not being
+                assigned
+            p_use_label (float | bool): with labels or not
+            rng (None | int | numpy.random.RandomState): seed or state
+
+        Returns:
+            :obj:`AssignResult`: Randomly generated assign results.
+
+        Example:
+            >>> from mmdet.models.task_modules.assigners.assign_result import *  # NOQA
+            >>> self = AssignResult.random()
+            >>> print(self.info)
+        """
+        from ..samplers.sampling_result import ensure_rng
+        rng = ensure_rng(kwargs.get('rng', None))
+
+        num_gts = kwargs.get('num_gts', None)
+        num_preds = kwargs.get('num_preds', None)
+        p_ignore = kwargs.get('p_ignore', 0.3)
+        p_assigned = kwargs.get('p_assigned', 0.7)
+        num_classes = kwargs.get('num_classes', 3)
+
+        if num_gts is None:
+            num_gts = rng.randint(0, 8)
+        if num_preds is None:
+            num_preds = rng.randint(0, 16)
+
+        if num_gts == 0:
+            max_overlaps = torch.zeros(num_preds, dtype=torch.float32)
+            gt_inds = torch.zeros(num_preds, dtype=torch.int64)
+            labels = torch.zeros(num_preds, dtype=torch.int64)
+
+        else:
+            import numpy as np
+
+            # Create an overlap for each predicted box
+            max_overlaps = torch.from_numpy(rng.rand(num_preds))
+
+            # Construct gt_inds for each predicted box
+            is_assigned = torch.from_numpy(rng.rand(num_preds) < p_assigned)
+            # maximum number of assignments constraints
+            n_assigned = min(num_preds, min(num_gts, is_assigned.sum()))
+
+            assigned_idxs = np.where(is_assigned)[0]
+            rng.shuffle(assigned_idxs)
+            assigned_idxs = assigned_idxs[0:n_assigned]
+            assigned_idxs.sort()
+
+            is_assigned[:] = 0
+            is_assigned[assigned_idxs] = True
+
+            is_ignore = torch.from_numpy(
+                rng.rand(num_preds) < p_ignore) & is_assigned
+
+            gt_inds = torch.zeros(num_preds, dtype=torch.int64)
+
+            true_idxs = np.arange(num_gts)
+            rng.shuffle(true_idxs)
+            true_idxs = torch.from_numpy(true_idxs)
+            gt_inds[is_assigned] = true_idxs[:n_assigned].long()
+
+            gt_inds = torch.from_numpy(
+                rng.randint(1, num_gts + 1, size=num_preds))
+            gt_inds[is_ignore] = -1
+            gt_inds[~is_assigned] = 0
+            max_overlaps[~is_assigned] = 0
+
+            if num_classes == 0:
+                labels = torch.zeros(num_preds, dtype=torch.int64)
+            else:
+                labels = torch.from_numpy(
+                    # remind that we set FG labels to [0, num_class-1]
+                    # since mmdet v2.0
+                    # BG cat_id: num_class
+                    rng.randint(0, num_classes, size=num_preds))
+                labels[~is_assigned] = 0
+
+        self = cls(num_gts, gt_inds, max_overlaps, labels)
+        return self
+
+    def add_gt_(self, gt_labels):
+        """Add ground truth as assigned results.
+
+        Args:
+            gt_labels (torch.Tensor): Labels of gt boxes
+        """
+        self_inds = torch.arange(
+            1, len(gt_labels) + 1, dtype=torch.long, device=gt_labels.device)
+        self.gt_inds = torch.cat([self_inds, self.gt_inds])
+
+        self.max_overlaps = torch.cat(
+            [self.max_overlaps.new_ones(len(gt_labels)), self.max_overlaps])
+
+        self.labels = torch.cat([gt_labels, self.labels])
diff --git a/mmdetection/mmdet/models/task_modules/assigners/atss_assigner.py b/mmdetection/mmdet/models/task_modules/assigners/atss_assigner.py
new file mode 100644
index 00000000..2796b990
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/assigners/atss_assigner.py
@@ -0,0 +1,254 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+from typing import List, Optional
+
+import torch
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import TASK_UTILS
+from mmdet.utils import ConfigType
+from .assign_result import AssignResult
+from .base_assigner import BaseAssigner
+
+
+def bbox_center_distance(bboxes: Tensor, priors: Tensor) -> Tensor:
+    """Compute the center distance between bboxes and priors.
+
+    Args:
+        bboxes (Tensor): Shape (n, 4) for , "xyxy" format.
+        priors (Tensor): Shape (n, 4) for priors, "xyxy" format.
+
+    Returns:
+        Tensor: Center distances between bboxes and priors.
+    """
+    bbox_cx = (bboxes[:, 0] + bboxes[:, 2]) / 2.0
+    bbox_cy = (bboxes[:, 1] + bboxes[:, 3]) / 2.0
+    bbox_points = torch.stack((bbox_cx, bbox_cy), dim=1)
+
+    priors_cx = (priors[:, 0] + priors[:, 2]) / 2.0
+    priors_cy = (priors[:, 1] + priors[:, 3]) / 2.0
+    priors_points = torch.stack((priors_cx, priors_cy), dim=1)
+
+    distances = (priors_points[:, None, :] -
+                 bbox_points[None, :, :]).pow(2).sum(-1).sqrt()
+
+    return distances
+
+
+@TASK_UTILS.register_module()
+class ATSSAssigner(BaseAssigner):
+    """Assign a corresponding gt bbox or background to each prior.
+
+    Each proposals will be assigned with `0` or a positive integer
+    indicating the ground truth index.
+
+    - 0: negative sample, no assigned gt
+    - positive integer: positive sample, index (1-based) of assigned gt
+
+    If ``alpha`` is not None, it means that the dynamic cost
+    ATSSAssigner is adopted, which is currently only used in the DDOD.
+
+    Args:
+        topk (int): number of priors selected in each level
+        alpha (float, optional): param of cost rate for each proposal only
+            in DDOD. Defaults to None.
+        iou_calculator (:obj:`ConfigDict` or dict): Config dict for iou
+            calculator. Defaults to ``dict(type='BboxOverlaps2D')``
+        ignore_iof_thr (float): IoF threshold for ignoring bboxes (if
+            `gt_bboxes_ignore` is specified). Negative values mean not
+            ignoring any bboxes. Defaults to -1.
+    """
+
+    def __init__(self,
+                 topk: int,
+                 alpha: Optional[float] = None,
+                 iou_calculator: ConfigType = dict(type='BboxOverlaps2D'),
+                 ignore_iof_thr: float = -1) -> None:
+        self.topk = topk
+        self.alpha = alpha
+        self.iou_calculator = TASK_UTILS.build(iou_calculator)
+        self.ignore_iof_thr = ignore_iof_thr
+
+    # https://github.com/sfzhang15/ATSS/blob/master/atss_core/modeling/rpn/atss/loss.py
+    def assign(
+            self,
+            pred_instances: InstanceData,
+            num_level_priors: List[int],
+            gt_instances: InstanceData,
+            gt_instances_ignore: Optional[InstanceData] = None
+    ) -> AssignResult:
+        """Assign gt to priors.
+
+        The assignment is done in following steps
+
+        1. compute iou between all prior (prior of all pyramid levels) and gt
+        2. compute center distance between all prior and gt
+        3. on each pyramid level, for each gt, select k prior whose center
+           are closest to the gt center, so we total select k*l prior as
+           candidates for each gt
+        4. get corresponding iou for the these candidates, and compute the
+           mean and std, set mean + std as the iou threshold
+        5. select these candidates whose iou are greater than or equal to
+           the threshold as positive
+        6. limit the positive sample's center in gt
+
+        If ``alpha`` is not None, and ``cls_scores`` and `bbox_preds`
+        are not None, the overlaps calculation in the first step
+        will also include dynamic cost, which is currently only used in
+        the DDOD.
+
+        Args:
+            pred_instances (:obj:`InstaceData`): Instances of model
+                predictions. It includes ``priors``, and the priors can
+                be anchors, points, or bboxes predicted by the model,
+                shape(n, 4).
+            num_level_priors (List): Number of bboxes in each level
+            gt_instances (:obj:`InstaceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            gt_instances_ignore (:obj:`InstaceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes``
+                attribute data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            :obj:`AssignResult`: The assign result.
+        """
+        gt_bboxes = gt_instances.bboxes
+        priors = pred_instances.priors
+        gt_labels = gt_instances.labels
+        if gt_instances_ignore is not None:
+            gt_bboxes_ignore = gt_instances_ignore.bboxes
+        else:
+            gt_bboxes_ignore = None
+
+        INF = 100000000
+        priors = priors[:, :4]
+        num_gt, num_priors = gt_bboxes.size(0), priors.size(0)
+
+        message = 'Invalid alpha parameter because cls_scores or ' \
+                  'bbox_preds are None. If you want to use the ' \
+                  'cost-based ATSSAssigner,  please set cls_scores, ' \
+                  'bbox_preds and self.alpha at the same time. '
+
+        # compute iou between all bbox and gt
+        if self.alpha is None:
+            # ATSSAssigner
+            overlaps = self.iou_calculator(priors, gt_bboxes)
+            if ('scores' in pred_instances or 'bboxes' in pred_instances):
+                warnings.warn(message)
+
+        else:
+            # Dynamic cost ATSSAssigner in DDOD
+            assert ('scores' in pred_instances
+                    and 'bboxes' in pred_instances), message
+            cls_scores = pred_instances.scores
+            bbox_preds = pred_instances.bboxes
+
+            # compute cls cost for bbox and GT
+            cls_cost = torch.sigmoid(cls_scores[:, gt_labels])
+
+            # compute iou between all bbox and gt
+            overlaps = self.iou_calculator(bbox_preds, gt_bboxes)
+
+            # make sure that we are in element-wise multiplication
+            assert cls_cost.shape == overlaps.shape
+
+            # overlaps is actually a cost matrix
+            overlaps = cls_cost**(1 - self.alpha) * overlaps**self.alpha
+
+        # assign 0 by default
+        assigned_gt_inds = overlaps.new_full((num_priors, ),
+                                             0,
+                                             dtype=torch.long)
+
+        if num_gt == 0 or num_priors == 0:
+            # No ground truth or boxes, return empty assignment
+            max_overlaps = overlaps.new_zeros((num_priors, ))
+            if num_gt == 0:
+                # No truth, assign everything to background
+                assigned_gt_inds[:] = 0
+            assigned_labels = overlaps.new_full((num_priors, ),
+                                                -1,
+                                                dtype=torch.long)
+            return AssignResult(
+                num_gt, assigned_gt_inds, max_overlaps, labels=assigned_labels)
+
+        # compute center distance between all bbox and gt
+        distances = bbox_center_distance(gt_bboxes, priors)
+
+        if (self.ignore_iof_thr > 0 and gt_bboxes_ignore is not None
+                and gt_bboxes_ignore.numel() > 0 and priors.numel() > 0):
+            ignore_overlaps = self.iou_calculator(
+                priors, gt_bboxes_ignore, mode='iof')
+            ignore_max_overlaps, _ = ignore_overlaps.max(dim=1)
+            ignore_idxs = ignore_max_overlaps > self.ignore_iof_thr
+            distances[ignore_idxs, :] = INF
+            assigned_gt_inds[ignore_idxs] = -1
+
+        # Selecting candidates based on the center distance
+        candidate_idxs = []
+        start_idx = 0
+        for level, priors_per_level in enumerate(num_level_priors):
+            # on each pyramid level, for each gt,
+            # select k bbox whose center are closest to the gt center
+            end_idx = start_idx + priors_per_level
+            distances_per_level = distances[start_idx:end_idx, :]
+            selectable_k = min(self.topk, priors_per_level)
+            _, topk_idxs_per_level = distances_per_level.topk(
+                selectable_k, dim=0, largest=False)
+            candidate_idxs.append(topk_idxs_per_level + start_idx)
+            start_idx = end_idx
+        candidate_idxs = torch.cat(candidate_idxs, dim=0)
+
+        # get corresponding iou for the these candidates, and compute the
+        # mean and std, set mean + std as the iou threshold
+        candidate_overlaps = overlaps[candidate_idxs, torch.arange(num_gt)]
+        overlaps_mean_per_gt = candidate_overlaps.mean(0)
+        overlaps_std_per_gt = candidate_overlaps.std(0)
+        overlaps_thr_per_gt = overlaps_mean_per_gt + overlaps_std_per_gt
+
+        is_pos = candidate_overlaps >= overlaps_thr_per_gt[None, :]
+
+        # limit the positive sample's center in gt
+        for gt_idx in range(num_gt):
+            candidate_idxs[:, gt_idx] += gt_idx * num_priors
+        priors_cx = (priors[:, 0] + priors[:, 2]) / 2.0
+        priors_cy = (priors[:, 1] + priors[:, 3]) / 2.0
+        ep_priors_cx = priors_cx.view(1, -1).expand(
+            num_gt, num_priors).contiguous().view(-1)
+        ep_priors_cy = priors_cy.view(1, -1).expand(
+            num_gt, num_priors).contiguous().view(-1)
+        candidate_idxs = candidate_idxs.view(-1)
+
+        # calculate the left, top, right, bottom distance between positive
+        # prior center and gt side
+        l_ = ep_priors_cx[candidate_idxs].view(-1, num_gt) - gt_bboxes[:, 0]
+        t_ = ep_priors_cy[candidate_idxs].view(-1, num_gt) - gt_bboxes[:, 1]
+        r_ = gt_bboxes[:, 2] - ep_priors_cx[candidate_idxs].view(-1, num_gt)
+        b_ = gt_bboxes[:, 3] - ep_priors_cy[candidate_idxs].view(-1, num_gt)
+        is_in_gts = torch.stack([l_, t_, r_, b_], dim=1).min(dim=1)[0] > 0.01
+
+        is_pos = is_pos & is_in_gts
+
+        # if an anchor box is assigned to multiple gts,
+        # the one with the highest IoU will be selected.
+        overlaps_inf = torch.full_like(overlaps,
+                                       -INF).t().contiguous().view(-1)
+        index = candidate_idxs.view(-1)[is_pos.view(-1)]
+        overlaps_inf[index] = overlaps.t().contiguous().view(-1)[index]
+        overlaps_inf = overlaps_inf.view(num_gt, -1).t()
+
+        max_overlaps, argmax_overlaps = overlaps_inf.max(dim=1)
+        assigned_gt_inds[
+            max_overlaps != -INF] = argmax_overlaps[max_overlaps != -INF] + 1
+
+        assigned_labels = assigned_gt_inds.new_full((num_priors, ), -1)
+        pos_inds = torch.nonzero(
+            assigned_gt_inds > 0, as_tuple=False).squeeze()
+        if pos_inds.numel() > 0:
+            assigned_labels[pos_inds] = gt_labels[assigned_gt_inds[pos_inds] -
+                                                  1]
+        return AssignResult(
+            num_gt, assigned_gt_inds, max_overlaps, labels=assigned_labels)
diff --git a/mmdetection/mmdet/models/task_modules/assigners/base_assigner.py b/mmdetection/mmdet/models/task_modules/assigners/base_assigner.py
new file mode 100644
index 00000000..b12280ad
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/assigners/base_assigner.py
@@ -0,0 +1,17 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from abc import ABCMeta, abstractmethod
+from typing import Optional
+
+from mmengine.structures import InstanceData
+
+
+class BaseAssigner(metaclass=ABCMeta):
+    """Base assigner that assigns boxes to ground truth boxes."""
+
+    @abstractmethod
+    def assign(self,
+               pred_instances: InstanceData,
+               gt_instances: InstanceData,
+               gt_instances_ignore: Optional[InstanceData] = None,
+               **kwargs):
+        """Assign boxes to either a ground truth boxes or a negative boxes."""
diff --git a/mmdetection/mmdet/models/task_modules/assigners/center_region_assigner.py b/mmdetection/mmdet/models/task_modules/assigners/center_region_assigner.py
new file mode 100644
index 00000000..11c8055c
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/assigners/center_region_assigner.py
@@ -0,0 +1,366 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Tuple
+
+import torch
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import TASK_UTILS
+from mmdet.utils import ConfigType
+from .assign_result import AssignResult
+from .base_assigner import BaseAssigner
+
+
+def scale_boxes(bboxes: Tensor, scale: float) -> Tensor:
+    """Expand an array of boxes by a given scale.
+
+    Args:
+        bboxes (Tensor): Shape (m, 4)
+        scale (float): The scale factor of bboxes
+
+    Returns:
+        Tensor: Shape (m, 4). Scaled bboxes
+    """
+    assert bboxes.size(1) == 4
+    w_half = (bboxes[:, 2] - bboxes[:, 0]) * .5
+    h_half = (bboxes[:, 3] - bboxes[:, 1]) * .5
+    x_c = (bboxes[:, 2] + bboxes[:, 0]) * .5
+    y_c = (bboxes[:, 3] + bboxes[:, 1]) * .5
+
+    w_half *= scale
+    h_half *= scale
+
+    boxes_scaled = torch.zeros_like(bboxes)
+    boxes_scaled[:, 0] = x_c - w_half
+    boxes_scaled[:, 2] = x_c + w_half
+    boxes_scaled[:, 1] = y_c - h_half
+    boxes_scaled[:, 3] = y_c + h_half
+    return boxes_scaled
+
+
+def is_located_in(points: Tensor, bboxes: Tensor) -> Tensor:
+    """Are points located in bboxes.
+
+    Args:
+        points (Tensor): Points, shape: (m, 2).
+        bboxes (Tensor): Bounding boxes, shape: (n, 4).
+
+    Return:
+        Tensor: Flags indicating if points are located in bboxes,
+        shape: (m, n).
+    """
+    assert points.size(1) == 2
+    assert bboxes.size(1) == 4
+    return (points[:, 0].unsqueeze(1) > bboxes[:, 0].unsqueeze(0)) & \
+           (points[:, 0].unsqueeze(1) < bboxes[:, 2].unsqueeze(0)) & \
+           (points[:, 1].unsqueeze(1) > bboxes[:, 1].unsqueeze(0)) & \
+           (points[:, 1].unsqueeze(1) < bboxes[:, 3].unsqueeze(0))
+
+
+def bboxes_area(bboxes: Tensor) -> Tensor:
+    """Compute the area of an array of bboxes.
+
+    Args:
+        bboxes (Tensor): The coordinates ox bboxes. Shape: (m, 4)
+
+    Returns:
+        Tensor: Area of the bboxes. Shape: (m, )
+    """
+    assert bboxes.size(1) == 4
+    w = (bboxes[:, 2] - bboxes[:, 0])
+    h = (bboxes[:, 3] - bboxes[:, 1])
+    areas = w * h
+    return areas
+
+
+@TASK_UTILS.register_module()
+class CenterRegionAssigner(BaseAssigner):
+    """Assign pixels at the center region of a bbox as positive.
+
+    Each proposals will be assigned with `-1`, `0`, or a positive integer
+    indicating the ground truth index.
+    - -1: negative samples
+    - semi-positive numbers: positive sample, index (0-based) of assigned gt
+
+    Args:
+        pos_scale (float): Threshold within which pixels are
+            labelled as positive.
+        neg_scale (float): Threshold above which pixels are
+            labelled as positive.
+        min_pos_iof (float): Minimum iof of a pixel with a gt to be
+            labelled as positive. Default: 1e-2
+        ignore_gt_scale (float): Threshold within which the pixels
+            are ignored when the gt is labelled as shadowed. Default: 0.5
+        foreground_dominate (bool): If True, the bbox will be assigned as
+            positive when a gt's kernel region overlaps with another's shadowed
+            (ignored) region, otherwise it is set as ignored. Default to False.
+        iou_calculator (:obj:`ConfigDict` or dict): Config of overlaps
+            Calculator.
+    """
+
+    def __init__(
+        self,
+        pos_scale: float,
+        neg_scale: float,
+        min_pos_iof: float = 1e-2,
+        ignore_gt_scale: float = 0.5,
+        foreground_dominate: bool = False,
+        iou_calculator: ConfigType = dict(type='BboxOverlaps2D')
+    ) -> None:
+        self.pos_scale = pos_scale
+        self.neg_scale = neg_scale
+        self.min_pos_iof = min_pos_iof
+        self.ignore_gt_scale = ignore_gt_scale
+        self.foreground_dominate = foreground_dominate
+        self.iou_calculator = TASK_UTILS.build(iou_calculator)
+
+    def get_gt_priorities(self, gt_bboxes: Tensor) -> Tensor:
+        """Get gt priorities according to their areas.
+
+        Smaller gt has higher priority.
+
+        Args:
+            gt_bboxes (Tensor): Ground truth boxes, shape (k, 4).
+
+        Returns:
+            Tensor: The priority of gts so that gts with larger priority is
+            more likely to be assigned. Shape (k, )
+        """
+        gt_areas = bboxes_area(gt_bboxes)
+        # Rank all gt bbox areas. Smaller objects has larger priority
+        _, sort_idx = gt_areas.sort(descending=True)
+        sort_idx = sort_idx.argsort()
+        return sort_idx
+
+    def assign(self,
+               pred_instances: InstanceData,
+               gt_instances: InstanceData,
+               gt_instances_ignore: Optional[InstanceData] = None,
+               **kwargs) -> AssignResult:
+        """Assign gt to bboxes.
+
+        This method assigns gts to every prior (proposal/anchor), each prior
+        will be assigned with -1, or a semi-positive number. -1 means
+        negative sample, semi-positive number is the index (0-based) of
+        assigned gt.
+
+        Args:
+            pred_instances (:obj:`InstanceData`): Instances of model
+                predictions. It includes ``priors``, and the priors can
+                be anchors or points, or the bboxes predicted by the
+                previous stage, has shape (n, 4). The bboxes predicted by
+                the current model or stage will be named ``bboxes``,
+                ``labels``, and ``scores``, the same as the ``InstanceData``
+                in other places.
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes``, with shape (k, 4),
+                and ``labels``, with shape (k, ).
+            gt_instances_ignore (:obj:`InstanceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes``
+                attribute data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            :obj:`AssignResult`: The assigned result. Note that shadowed_labels
+            of shape (N, 2) is also added as an `assign_result` attribute.
+            `shadowed_labels` is a tensor composed of N pairs of anchor_ind,
+            class_label], where N is the number of anchors that lie in the
+            outer region of a gt, anchor_ind is the shadowed anchor index
+            and class_label is the shadowed class label.
+
+        Example:
+            >>> from mmengine.structures import InstanceData
+            >>> self = CenterRegionAssigner(0.2, 0.2)
+            >>> pred_instances.priors = torch.Tensor([[0, 0, 10, 10],
+            ...                                      [10, 10, 20, 20]])
+            >>> gt_instances = InstanceData()
+            >>> gt_instances.bboxes = torch.Tensor([[0, 0, 10, 10]])
+            >>> gt_instances.labels = torch.Tensor([0])
+            >>> assign_result = self.assign(pred_instances, gt_instances)
+            >>> expected_gt_inds = torch.LongTensor([1, 0])
+            >>> assert torch.all(assign_result.gt_inds == expected_gt_inds)
+        """
+        # There are in total 5 steps in the pixel assignment
+        # 1. Find core (the center region, say inner 0.2)
+        #     and shadow (the relatively ourter part, say inner 0.2-0.5)
+        #     regions of every gt.
+        # 2. Find all prior bboxes that lie in gt_core and gt_shadow regions
+        # 3. Assign prior bboxes in gt_core with a one-hot id of the gt in
+        #      the image.
+        #    3.1. For overlapping objects, the prior bboxes in gt_core is
+        #           assigned with the object with smallest area
+        # 4. Assign prior bboxes with class label according to its gt id.
+        #    4.1. Assign -1 to prior bboxes lying in shadowed gts
+        #    4.2. Assign positive prior boxes with the corresponding label
+        # 5. Find pixels lying in the shadow of an object and assign them with
+        #      background label, but set the loss weight of its corresponding
+        #      gt to zero.
+
+        # TODO not extract bboxes in assign.
+        gt_bboxes = gt_instances.bboxes
+        priors = pred_instances.priors
+        gt_labels = gt_instances.labels
+
+        assert priors.size(1) == 4, 'priors must have size of 4'
+        # 1. Find core positive and shadow region of every gt
+        gt_core = scale_boxes(gt_bboxes, self.pos_scale)
+        gt_shadow = scale_boxes(gt_bboxes, self.neg_scale)
+
+        # 2. Find prior bboxes that lie in gt_core and gt_shadow regions
+        prior_centers = (priors[:, 2:4] + priors[:, 0:2]) / 2
+        # The center points lie within the gt boxes
+        is_prior_in_gt = is_located_in(prior_centers, gt_bboxes)
+        # Only calculate prior and gt_core IoF. This enables small prior bboxes
+        #   to match large gts
+        prior_and_gt_core_overlaps = self.iou_calculator(
+            priors, gt_core, mode='iof')
+        # The center point of effective priors should be within the gt box
+        is_prior_in_gt_core = is_prior_in_gt & (
+            prior_and_gt_core_overlaps > self.min_pos_iof)  # shape (n, k)
+
+        is_prior_in_gt_shadow = (
+            self.iou_calculator(priors, gt_shadow, mode='iof') >
+            self.min_pos_iof)
+        # Rule out center effective positive pixels
+        is_prior_in_gt_shadow &= (~is_prior_in_gt_core)
+
+        num_gts, num_priors = gt_bboxes.size(0), priors.size(0)
+        if num_gts == 0 or num_priors == 0:
+            # If no gts exist, assign all pixels to negative
+            assigned_gt_ids = \
+                is_prior_in_gt_core.new_zeros((num_priors,),
+                                              dtype=torch.long)
+            pixels_in_gt_shadow = assigned_gt_ids.new_empty((0, 2))
+        else:
+            # Step 3: assign a one-hot gt id to each pixel, and smaller objects
+            #    have high priority to assign the pixel.
+            sort_idx = self.get_gt_priorities(gt_bboxes)
+            assigned_gt_ids, pixels_in_gt_shadow = \
+                self.assign_one_hot_gt_indices(is_prior_in_gt_core,
+                                               is_prior_in_gt_shadow,
+                                               gt_priority=sort_idx)
+
+        if (gt_instances_ignore is not None
+                and gt_instances_ignore.bboxes.numel() > 0):
+            # No ground truth or boxes, return empty assignment
+            gt_bboxes_ignore = gt_instances_ignore.bboxes
+            gt_bboxes_ignore = scale_boxes(
+                gt_bboxes_ignore, scale=self.ignore_gt_scale)
+            is_prior_in_ignored_gts = is_located_in(prior_centers,
+                                                    gt_bboxes_ignore)
+            is_prior_in_ignored_gts = is_prior_in_ignored_gts.any(dim=1)
+            assigned_gt_ids[is_prior_in_ignored_gts] = -1
+
+        # 4. Assign prior bboxes with class label according to its gt id.
+        # Default assigned label is the background (-1)
+        assigned_labels = assigned_gt_ids.new_full((num_priors, ), -1)
+        pos_inds = torch.nonzero(assigned_gt_ids > 0, as_tuple=False).squeeze()
+        if pos_inds.numel() > 0:
+            assigned_labels[pos_inds] = gt_labels[assigned_gt_ids[pos_inds] -
+                                                  1]
+        # 5. Find pixels lying in the shadow of an object
+        shadowed_pixel_labels = pixels_in_gt_shadow.clone()
+        if pixels_in_gt_shadow.numel() > 0:
+            pixel_idx, gt_idx =\
+                pixels_in_gt_shadow[:, 0], pixels_in_gt_shadow[:, 1]
+            assert (assigned_gt_ids[pixel_idx] != gt_idx).all(), \
+                'Some pixels are dually assigned to ignore and gt!'
+            shadowed_pixel_labels[:, 1] = gt_labels[gt_idx - 1]
+            override = (
+                assigned_labels[pixel_idx] == shadowed_pixel_labels[:, 1])
+            if self.foreground_dominate:
+                # When a pixel is both positive and shadowed, set it as pos
+                shadowed_pixel_labels = shadowed_pixel_labels[~override]
+            else:
+                # When a pixel is both pos and shadowed, set it as shadowed
+                assigned_labels[pixel_idx[override]] = -1
+                assigned_gt_ids[pixel_idx[override]] = 0
+
+        assign_result = AssignResult(
+            num_gts, assigned_gt_ids, None, labels=assigned_labels)
+        # Add shadowed_labels as assign_result property. Shape: (num_shadow, 2)
+        assign_result.set_extra_property('shadowed_labels',
+                                         shadowed_pixel_labels)
+        return assign_result
+
+    def assign_one_hot_gt_indices(
+            self,
+            is_prior_in_gt_core: Tensor,
+            is_prior_in_gt_shadow: Tensor,
+            gt_priority: Optional[Tensor] = None) -> Tuple[Tensor, Tensor]:
+        """Assign only one gt index to each prior box.
+
+        Gts with large gt_priority are more likely to be assigned.
+
+        Args:
+            is_prior_in_gt_core (Tensor): Bool tensor indicating the prior
+                center is in the core area of a gt (e.g. 0-0.2).
+                Shape: (num_prior, num_gt).
+            is_prior_in_gt_shadow (Tensor): Bool tensor indicating the prior
+                center is in the shadowed area of a gt (e.g. 0.2-0.5).
+                Shape: (num_prior, num_gt).
+            gt_priority (Tensor): Priorities of gts. The gt with a higher
+                priority is more likely to be assigned to the bbox when the
+                bbox match with multiple gts. Shape: (num_gt, ).
+
+        Returns:
+            tuple: Returns (assigned_gt_inds, shadowed_gt_inds).
+
+            - assigned_gt_inds: The assigned gt index of each prior bbox \
+            (i.e. index from 1 to num_gts). Shape: (num_prior, ).
+            - shadowed_gt_inds: shadowed gt indices. It is a tensor of \
+            shape (num_ignore, 2) with first column being the shadowed prior \
+            bbox indices and the second column the shadowed gt \
+            indices (1-based).
+        """
+        num_bboxes, num_gts = is_prior_in_gt_core.shape
+
+        if gt_priority is None:
+            gt_priority = torch.arange(
+                num_gts, device=is_prior_in_gt_core.device)
+        assert gt_priority.size(0) == num_gts
+        # The bigger gt_priority, the more preferable to be assigned
+        # The assigned inds are by default 0 (background)
+        assigned_gt_inds = is_prior_in_gt_core.new_zeros((num_bboxes, ),
+                                                         dtype=torch.long)
+        # Shadowed bboxes are assigned to be background. But the corresponding
+        #   label is ignored during loss calculation, which is done through
+        #   shadowed_gt_inds
+        shadowed_gt_inds = torch.nonzero(is_prior_in_gt_shadow, as_tuple=False)
+        if is_prior_in_gt_core.sum() == 0:  # No gt match
+            shadowed_gt_inds[:, 1] += 1  # 1-based. For consistency issue
+            return assigned_gt_inds, shadowed_gt_inds
+
+        # The priority of each prior box and gt pair. If one prior box is
+        #  matched bo multiple gts. Only the pair with the highest priority
+        #  is saved
+        pair_priority = is_prior_in_gt_core.new_full((num_bboxes, num_gts),
+                                                     -1,
+                                                     dtype=torch.long)
+
+        # Each bbox could match with multiple gts.
+        # The following codes deal with this situation
+        # Matched  bboxes (to any gt). Shape: (num_pos_anchor, )
+        inds_of_match = torch.any(is_prior_in_gt_core, dim=1)
+        # The matched gt index of each positive bbox. Length >= num_pos_anchor
+        #   , since one bbox could match multiple gts
+        matched_bbox_gt_inds = torch.nonzero(
+            is_prior_in_gt_core, as_tuple=False)[:, 1]
+        # Assign priority to each bbox-gt pair.
+        pair_priority[is_prior_in_gt_core] = gt_priority[matched_bbox_gt_inds]
+        _, argmax_priority = pair_priority[inds_of_match].max(dim=1)
+        assigned_gt_inds[inds_of_match] = argmax_priority + 1  # 1-based
+        # Zero-out the assigned anchor box to filter the shadowed gt indices
+        is_prior_in_gt_core[inds_of_match, argmax_priority] = 0
+        # Concat the shadowed indices due to overlapping with that out side of
+        #   effective scale. shape: (total_num_ignore, 2)
+        shadowed_gt_inds = torch.cat(
+            (shadowed_gt_inds,
+             torch.nonzero(is_prior_in_gt_core, as_tuple=False)),
+            dim=0)
+        # Change `is_prior_in_gt_core` back to keep arguments intact.
+        is_prior_in_gt_core[inds_of_match, argmax_priority] = 1
+        # 1-based shadowed gt indices, to be consistent with `assigned_gt_inds`
+        if shadowed_gt_inds.numel() > 0:
+            shadowed_gt_inds[:, 1] += 1
+        return assigned_gt_inds, shadowed_gt_inds
diff --git a/mmdetection/mmdet/models/task_modules/assigners/dynamic_soft_label_assigner.py b/mmdetection/mmdet/models/task_modules/assigners/dynamic_soft_label_assigner.py
new file mode 100644
index 00000000..3fc7af39
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/assigners/dynamic_soft_label_assigner.py
@@ -0,0 +1,227 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Tuple
+
+import torch
+import torch.nn.functional as F
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import TASK_UTILS
+from mmdet.structures.bbox import BaseBoxes
+from mmdet.utils import ConfigType
+from .assign_result import AssignResult
+from .base_assigner import BaseAssigner
+
+INF = 100000000
+EPS = 1.0e-7
+
+
+def center_of_mass(masks: Tensor, eps: float = 1e-7) -> Tensor:
+    """Compute the masks center of mass.
+
+    Args:
+        masks: Mask tensor, has shape (num_masks, H, W).
+        eps: a small number to avoid normalizer to be zero.
+            Defaults to 1e-7.
+    Returns:
+        Tensor: The masks center of mass. Has shape (num_masks, 2).
+    """
+    n, h, w = masks.shape
+    grid_h = torch.arange(h, device=masks.device)[:, None]
+    grid_w = torch.arange(w, device=masks.device)
+    normalizer = masks.sum(dim=(1, 2)).float().clamp(min=eps)
+    center_y = (masks * grid_h).sum(dim=(1, 2)) / normalizer
+    center_x = (masks * grid_w).sum(dim=(1, 2)) / normalizer
+    center = torch.cat([center_x[:, None], center_y[:, None]], dim=1)
+    return center
+
+
+@TASK_UTILS.register_module()
+class DynamicSoftLabelAssigner(BaseAssigner):
+    """Computes matching between predictions and ground truth with dynamic soft
+    label assignment.
+
+    Args:
+        soft_center_radius (float): Radius of the soft center prior.
+            Defaults to 3.0.
+        topk (int): Select top-k predictions to calculate dynamic k
+            best matches for each gt. Defaults to 13.
+        iou_weight (float): The scale factor of iou cost. Defaults to 3.0.
+        iou_calculator (ConfigType): Config of overlaps Calculator.
+            Defaults to dict(type='BboxOverlaps2D').
+    """
+
+    def __init__(
+        self,
+        soft_center_radius: float = 3.0,
+        topk: int = 13,
+        iou_weight: float = 3.0,
+        iou_calculator: ConfigType = dict(type='BboxOverlaps2D')
+    ) -> None:
+        self.soft_center_radius = soft_center_radius
+        self.topk = topk
+        self.iou_weight = iou_weight
+        self.iou_calculator = TASK_UTILS.build(iou_calculator)
+
+    def assign(self,
+               pred_instances: InstanceData,
+               gt_instances: InstanceData,
+               gt_instances_ignore: Optional[InstanceData] = None,
+               **kwargs) -> AssignResult:
+        """Assign gt to priors.
+
+        Args:
+            pred_instances (:obj:`InstanceData`): Instances of model
+                predictions. It includes ``priors``, and the priors can
+                be anchors or points, or the bboxes predicted by the
+                previous stage, has shape (n, 4). The bboxes predicted by
+                the current model or stage will be named ``bboxes``,
+                ``labels``, and ``scores``, the same as the ``InstanceData``
+                in other places.
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes``, with shape (k, 4),
+                and ``labels``, with shape (k, ).
+            gt_instances_ignore (:obj:`InstanceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes``
+                attribute data that is ignored during training and testing.
+                Defaults to None.
+        Returns:
+            obj:`AssignResult`: The assigned result.
+        """
+        gt_bboxes = gt_instances.bboxes
+        gt_labels = gt_instances.labels
+        num_gt = gt_bboxes.size(0)
+
+        decoded_bboxes = pred_instances.bboxes
+        pred_scores = pred_instances.scores
+        priors = pred_instances.priors
+        num_bboxes = decoded_bboxes.size(0)
+
+        # assign 0 by default
+        assigned_gt_inds = decoded_bboxes.new_full((num_bboxes, ),
+                                                   0,
+                                                   dtype=torch.long)
+        if num_gt == 0 or num_bboxes == 0:
+            # No ground truth or boxes, return empty assignment
+            max_overlaps = decoded_bboxes.new_zeros((num_bboxes, ))
+            if num_gt == 0:
+                # No truth, assign everything to background
+                assigned_gt_inds[:] = 0
+            assigned_labels = decoded_bboxes.new_full((num_bboxes, ),
+                                                      -1,
+                                                      dtype=torch.long)
+            return AssignResult(
+                num_gt, assigned_gt_inds, max_overlaps, labels=assigned_labels)
+
+        prior_center = priors[:, :2]
+        if isinstance(gt_bboxes, BaseBoxes):
+            is_in_gts = gt_bboxes.find_inside_points(prior_center)
+        else:
+            # Tensor boxes will be treated as horizontal boxes by defaults
+            lt_ = prior_center[:, None] - gt_bboxes[:, :2]
+            rb_ = gt_bboxes[:, 2:] - prior_center[:, None]
+
+            deltas = torch.cat([lt_, rb_], dim=-1)
+            is_in_gts = deltas.min(dim=-1).values > 0
+
+        valid_mask = is_in_gts.sum(dim=1) > 0
+
+        valid_decoded_bbox = decoded_bboxes[valid_mask]
+        valid_pred_scores = pred_scores[valid_mask]
+        num_valid = valid_decoded_bbox.size(0)
+
+        if num_valid == 0:
+            # No ground truth or boxes, return empty assignment
+            max_overlaps = decoded_bboxes.new_zeros((num_bboxes, ))
+            assigned_labels = decoded_bboxes.new_full((num_bboxes, ),
+                                                      -1,
+                                                      dtype=torch.long)
+            return AssignResult(
+                num_gt, assigned_gt_inds, max_overlaps, labels=assigned_labels)
+        if hasattr(gt_instances, 'masks'):
+            gt_center = center_of_mass(gt_instances.masks, eps=EPS)
+        elif isinstance(gt_bboxes, BaseBoxes):
+            gt_center = gt_bboxes.centers
+        else:
+            # Tensor boxes will be treated as horizontal boxes by defaults
+            gt_center = (gt_bboxes[:, :2] + gt_bboxes[:, 2:]) / 2.0
+        valid_prior = priors[valid_mask]
+        strides = valid_prior[:, 2]
+        distance = (valid_prior[:, None, :2] - gt_center[None, :, :]
+                    ).pow(2).sum(-1).sqrt() / strides[:, None]
+        soft_center_prior = torch.pow(10, distance - self.soft_center_radius)
+
+        pairwise_ious = self.iou_calculator(valid_decoded_bbox, gt_bboxes)
+        iou_cost = -torch.log(pairwise_ious + EPS) * self.iou_weight
+
+        gt_onehot_label = (
+            F.one_hot(gt_labels.to(torch.int64),
+                      pred_scores.shape[-1]).float().unsqueeze(0).repeat(
+                          num_valid, 1, 1))
+        valid_pred_scores = valid_pred_scores.unsqueeze(1).repeat(1, num_gt, 1)
+
+        soft_label = gt_onehot_label * pairwise_ious[..., None]
+        scale_factor = soft_label - valid_pred_scores.sigmoid()
+        soft_cls_cost = F.binary_cross_entropy_with_logits(
+            valid_pred_scores, soft_label,
+            reduction='none') * scale_factor.abs().pow(2.0)
+        soft_cls_cost = soft_cls_cost.sum(dim=-1)
+
+        cost_matrix = soft_cls_cost + iou_cost + soft_center_prior
+
+        matched_pred_ious, matched_gt_inds = self.dynamic_k_matching(
+            cost_matrix, pairwise_ious, num_gt, valid_mask)
+
+        # convert to AssignResult format
+        assigned_gt_inds[valid_mask] = matched_gt_inds + 1
+        assigned_labels = assigned_gt_inds.new_full((num_bboxes, ), -1)
+        assigned_labels[valid_mask] = gt_labels[matched_gt_inds].long()
+        max_overlaps = assigned_gt_inds.new_full((num_bboxes, ),
+                                                 -INF,
+                                                 dtype=torch.float32)
+        max_overlaps[valid_mask] = matched_pred_ious
+        return AssignResult(
+            num_gt, assigned_gt_inds, max_overlaps, labels=assigned_labels)
+
+    def dynamic_k_matching(self, cost: Tensor, pairwise_ious: Tensor,
+                           num_gt: int,
+                           valid_mask: Tensor) -> Tuple[Tensor, Tensor]:
+        """Use IoU and matching cost to calculate the dynamic top-k positive
+        targets. Same as SimOTA.
+
+        Args:
+            cost (Tensor): Cost matrix.
+            pairwise_ious (Tensor): Pairwise iou matrix.
+            num_gt (int): Number of gt.
+            valid_mask (Tensor): Mask for valid bboxes.
+
+        Returns:
+            tuple: matched ious and gt indexes.
+        """
+        matching_matrix = torch.zeros_like(cost, dtype=torch.uint8)
+        # select candidate topk ious for dynamic-k calculation
+        candidate_topk = min(self.topk, pairwise_ious.size(0))
+        topk_ious, _ = torch.topk(pairwise_ious, candidate_topk, dim=0)
+        # calculate dynamic k for each gt
+        dynamic_ks = torch.clamp(topk_ious.sum(0).int(), min=1)
+        for gt_idx in range(num_gt):
+            _, pos_idx = torch.topk(
+                cost[:, gt_idx], k=dynamic_ks[gt_idx], largest=False)
+            matching_matrix[:, gt_idx][pos_idx] = 1
+
+        del topk_ious, dynamic_ks, pos_idx
+
+        prior_match_gt_mask = matching_matrix.sum(1) > 1
+        if prior_match_gt_mask.sum() > 0:
+            cost_min, cost_argmin = torch.min(
+                cost[prior_match_gt_mask, :], dim=1)
+            matching_matrix[prior_match_gt_mask, :] *= 0
+            matching_matrix[prior_match_gt_mask, cost_argmin] = 1
+        # get foreground mask inside box and center prior
+        fg_mask_inboxes = matching_matrix.sum(1) > 0
+        valid_mask[valid_mask.clone()] = fg_mask_inboxes
+
+        matched_gt_inds = matching_matrix[fg_mask_inboxes, :].argmax(1)
+        matched_pred_ious = (matching_matrix *
+                             pairwise_ious).sum(1)[fg_mask_inboxes]
+        return matched_pred_ious, matched_gt_inds
diff --git a/mmdetection/mmdet/models/task_modules/assigners/grid_assigner.py b/mmdetection/mmdet/models/task_modules/assigners/grid_assigner.py
new file mode 100644
index 00000000..d8935d2d
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/assigners/grid_assigner.py
@@ -0,0 +1,177 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Tuple, Union
+
+import torch
+from mmengine.structures import InstanceData
+
+from mmdet.registry import TASK_UTILS
+from mmdet.utils import ConfigType
+from .assign_result import AssignResult
+from .base_assigner import BaseAssigner
+
+
+@TASK_UTILS.register_module()
+class GridAssigner(BaseAssigner):
+    """Assign a corresponding gt bbox or background to each bbox.
+
+    Each proposals will be assigned with `-1`, `0`, or a positive integer
+    indicating the ground truth index.
+
+    - -1: don't care
+    - 0: negative sample, no assigned gt
+    - positive integer: positive sample, index (1-based) of assigned gt
+
+    Args:
+        pos_iou_thr (float): IoU threshold for positive bboxes.
+        neg_iou_thr (float or tuple[float, float]): IoU threshold for negative
+        bboxes.
+        min_pos_iou (float): Minimum iou for a bbox to be considered as a
+            positive bbox. Positive samples can have smaller IoU than
+            pos_iou_thr due to the 4th step (assign max IoU sample to each gt).
+            Defaults to 0.
+        gt_max_assign_all (bool): Whether to assign all bboxes with the same
+            highest overlap with some gt to that gt.
+        iou_calculator (:obj:`ConfigDict` or dict): Config of overlaps
+            Calculator.
+    """
+
+    def __init__(
+        self,
+        pos_iou_thr: float,
+        neg_iou_thr: Union[float, Tuple[float, float]],
+        min_pos_iou: float = .0,
+        gt_max_assign_all: bool = True,
+        iou_calculator: ConfigType = dict(type='BboxOverlaps2D')
+    ) -> None:
+        self.pos_iou_thr = pos_iou_thr
+        self.neg_iou_thr = neg_iou_thr
+        self.min_pos_iou = min_pos_iou
+        self.gt_max_assign_all = gt_max_assign_all
+        self.iou_calculator = TASK_UTILS.build(iou_calculator)
+
+    def assign(self,
+               pred_instances: InstanceData,
+               gt_instances: InstanceData,
+               gt_instances_ignore: Optional[InstanceData] = None,
+               **kwargs) -> AssignResult:
+        """Assign gt to bboxes. The process is very much like the max iou
+        assigner, except that positive samples are constrained within the cell
+        that the gt boxes fell in.
+
+        This method assign a gt bbox to every bbox (proposal/anchor), each bbox
+        will be assigned with -1, 0, or a positive number. -1 means don't care,
+        0 means negative sample, positive number is the index (1-based) of
+        assigned gt.
+        The assignment is done in following steps, the order matters.
+
+        1. assign every bbox to -1
+        2. assign proposals whose iou with all gts <= neg_iou_thr to 0
+        3. for each bbox within a cell, if the iou with its nearest gt >
+            pos_iou_thr and the center of that gt falls inside the cell,
+            assign it to that bbox
+        4. for each gt bbox, assign its nearest proposals within the cell the
+            gt bbox falls in to itself.
+
+        Args:
+            pred_instances (:obj:`InstanceData`): Instances of model
+                predictions. It includes ``priors``, and the priors can
+                be anchors or points, or the bboxes predicted by the
+                previous stage, has shape (n, 4). The bboxes predicted by
+                the current model or stage will be named ``bboxes``,
+                ``labels``, and ``scores``, the same as the ``InstanceData``
+                in other places.
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes``, with shape (k, 4),
+                and ``labels``, with shape (k, ).
+            gt_instances_ignore (:obj:`InstanceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes``
+                attribute data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            :obj:`AssignResult`: The assign result.
+        """
+        gt_bboxes = gt_instances.bboxes
+        gt_labels = gt_instances.labels
+
+        priors = pred_instances.priors
+        responsible_flags = pred_instances.responsible_flags
+
+        num_gts, num_priors = gt_bboxes.size(0), priors.size(0)
+
+        # compute iou between all gt and priors
+        overlaps = self.iou_calculator(gt_bboxes, priors)
+
+        # 1. assign -1 by default
+        assigned_gt_inds = overlaps.new_full((num_priors, ),
+                                             -1,
+                                             dtype=torch.long)
+
+        if num_gts == 0 or num_priors == 0:
+            # No ground truth or priors, return empty assignment
+            max_overlaps = overlaps.new_zeros((num_priors, ))
+            if num_gts == 0:
+                # No truth, assign everything to background
+                assigned_gt_inds[:] = 0
+            assigned_labels = overlaps.new_full((num_priors, ),
+                                                -1,
+                                                dtype=torch.long)
+            return AssignResult(
+                num_gts,
+                assigned_gt_inds,
+                max_overlaps,
+                labels=assigned_labels)
+
+        # 2. assign negative: below
+        # for each anchor, which gt best overlaps with it
+        # for each anchor, the max iou of all gts
+        # shape of max_overlaps == argmax_overlaps == num_priors
+        max_overlaps, argmax_overlaps = overlaps.max(dim=0)
+
+        if isinstance(self.neg_iou_thr, float):
+            assigned_gt_inds[(max_overlaps >= 0)
+                             & (max_overlaps <= self.neg_iou_thr)] = 0
+        elif isinstance(self.neg_iou_thr, (tuple, list)):
+            assert len(self.neg_iou_thr) == 2
+            assigned_gt_inds[(max_overlaps > self.neg_iou_thr[0])
+                             & (max_overlaps <= self.neg_iou_thr[1])] = 0
+
+        # 3. assign positive: falls into responsible cell and above
+        # positive IOU threshold, the order matters.
+        # the prior condition of comparison is to filter out all
+        # unrelated anchors, i.e. not responsible_flags
+        overlaps[:, ~responsible_flags.type(torch.bool)] = -1.
+
+        # calculate max_overlaps again, but this time we only consider IOUs
+        # for anchors responsible for prediction
+        max_overlaps, argmax_overlaps = overlaps.max(dim=0)
+
+        # for each gt, which anchor best overlaps with it
+        # for each gt, the max iou of all proposals
+        # shape of gt_max_overlaps == gt_argmax_overlaps == num_gts
+        gt_max_overlaps, gt_argmax_overlaps = overlaps.max(dim=1)
+
+        pos_inds = (max_overlaps > self.pos_iou_thr) & responsible_flags.type(
+            torch.bool)
+        assigned_gt_inds[pos_inds] = argmax_overlaps[pos_inds] + 1
+
+        # 4. assign positive to max overlapped anchors within responsible cell
+        for i in range(num_gts):
+            if gt_max_overlaps[i] > self.min_pos_iou:
+                if self.gt_max_assign_all:
+                    max_iou_inds = (overlaps[i, :] == gt_max_overlaps[i]) & \
+                         responsible_flags.type(torch.bool)
+                    assigned_gt_inds[max_iou_inds] = i + 1
+                elif responsible_flags[gt_argmax_overlaps[i]]:
+                    assigned_gt_inds[gt_argmax_overlaps[i]] = i + 1
+
+        # assign labels of positive anchors
+        assigned_labels = assigned_gt_inds.new_full((num_priors, ), -1)
+        pos_inds = torch.nonzero(
+            assigned_gt_inds > 0, as_tuple=False).squeeze()
+        if pos_inds.numel() > 0:
+            assigned_labels[pos_inds] = gt_labels[assigned_gt_inds[pos_inds] -
+                                                  1]
+
+        return AssignResult(
+            num_gts, assigned_gt_inds, max_overlaps, labels=assigned_labels)
diff --git a/mmdetection/mmdet/models/task_modules/assigners/hungarian_assigner.py b/mmdetection/mmdet/models/task_modules/assigners/hungarian_assigner.py
new file mode 100644
index 00000000..a6745a36
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/assigners/hungarian_assigner.py
@@ -0,0 +1,145 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Union
+
+import torch
+from mmengine import ConfigDict
+from mmengine.structures import InstanceData
+from scipy.optimize import linear_sum_assignment
+from torch import Tensor
+
+from mmdet.registry import TASK_UTILS
+from .assign_result import AssignResult
+from .base_assigner import BaseAssigner
+
+
+@TASK_UTILS.register_module()
+class HungarianAssigner(BaseAssigner):
+    """Computes one-to-one matching between predictions and ground truth.
+
+    This class computes an assignment between the targets and the predictions
+    based on the costs. The costs are weighted sum of some components.
+    For DETR the costs are weighted sum of classification cost, regression L1
+    cost and regression iou cost. The targets don't include the no_object, so
+    generally there are more predictions than targets. After the one-to-one
+    matching, the un-matched are treated as backgrounds. Thus each query
+    prediction will be assigned with `0` or a positive integer indicating the
+    ground truth index:
+
+    - 0: negative sample, no assigned gt
+    - positive integer: positive sample, index (1-based) of assigned gt
+
+    Args:
+        match_costs (:obj:`ConfigDict` or dict or \
+            List[Union[:obj:`ConfigDict`, dict]]): Match cost configs.
+    """
+
+    def __init__(
+        self, match_costs: Union[List[Union[dict, ConfigDict]], dict,
+                                 ConfigDict]
+    ) -> None:
+
+        if isinstance(match_costs, dict):
+            match_costs = [match_costs]
+        elif isinstance(match_costs, list):
+            assert len(match_costs) > 0, \
+                'match_costs must not be a empty list.'
+
+        self.match_costs = [
+            TASK_UTILS.build(match_cost) for match_cost in match_costs
+        ]
+
+    def assign(self,
+               pred_instances: InstanceData,
+               gt_instances: InstanceData,
+               img_meta: Optional[dict] = None,
+               **kwargs) -> AssignResult:
+        """Computes one-to-one matching based on the weighted costs.
+
+        This method assign each query prediction to a ground truth or
+        background. The `assigned_gt_inds` with -1 means don't care,
+        0 means negative sample, and positive number is the index (1-based)
+        of assigned gt.
+        The assignment is done in the following steps, the order matters.
+
+        1. assign every prediction to -1
+        2. compute the weighted costs
+        3. do Hungarian matching on CPU based on the costs
+        4. assign all to 0 (background) first, then for each matched pair
+           between predictions and gts, treat this prediction as foreground
+           and assign the corresponding gt index (plus 1) to it.
+
+        Args:
+            pred_instances (:obj:`InstanceData`): Instances of model
+                predictions. It includes ``priors``, and the priors can
+                be anchors or points, or the bboxes predicted by the
+                previous stage, has shape (n, 4). The bboxes predicted by
+                the current model or stage will be named ``bboxes``,
+                ``labels``, and ``scores``, the same as the ``InstanceData``
+                in other places. It may includes ``masks``, with shape
+                (n, h, w) or (n, l).
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes``, with shape (k, 4),
+                ``labels``, with shape (k, ) and ``masks``, with shape
+                (k, h, w) or (k, l).
+            img_meta (dict): Image information.
+
+        Returns:
+            :obj:`AssignResult`: The assigned result.
+        """
+        assert isinstance(gt_instances.labels, Tensor)
+        num_gts, num_preds = len(gt_instances), len(pred_instances)
+        gt_labels = gt_instances.labels
+        device = gt_labels.device
+
+        # 1. assign -1 by default
+        assigned_gt_inds = torch.full((num_preds, ),
+                                      -1,
+                                      dtype=torch.long,
+                                      device=device)
+        assigned_labels = torch.full((num_preds, ),
+                                     -1,
+                                     dtype=torch.long,
+                                     device=device)
+
+        if num_gts == 0 or num_preds == 0:
+            # No ground truth or boxes, return empty assignment
+            if num_gts == 0:
+                # No ground truth, assign all to background
+                assigned_gt_inds[:] = 0
+            return AssignResult(
+                num_gts=num_gts,
+                gt_inds=assigned_gt_inds,
+                max_overlaps=None,
+                labels=assigned_labels)
+
+        # 2. compute weighted cost
+        cost_list = []
+        for match_cost in self.match_costs:
+            cost = match_cost(
+                pred_instances=pred_instances,
+                gt_instances=gt_instances,
+                img_meta=img_meta)
+            cost_list.append(cost)
+        cost = torch.stack(cost_list).sum(dim=0)
+
+        # 3. do Hungarian matching on CPU using linear_sum_assignment
+        cost = cost.detach().cpu()
+        if linear_sum_assignment is None:
+            raise ImportError('Please run "pip install scipy" '
+                              'to install scipy first.')
+
+        matched_row_inds, matched_col_inds = linear_sum_assignment(cost)
+        matched_row_inds = torch.from_numpy(matched_row_inds).to(device)
+        matched_col_inds = torch.from_numpy(matched_col_inds).to(device)
+
+        # 4. assign backgrounds and foregrounds
+        # assign all indices to backgrounds first
+        assigned_gt_inds[:] = 0
+        # assign foregrounds based on matching results
+        assigned_gt_inds[matched_row_inds] = matched_col_inds + 1
+        assigned_labels[matched_row_inds] = gt_labels[matched_col_inds]
+        return AssignResult(
+            num_gts=num_gts,
+            gt_inds=assigned_gt_inds,
+            max_overlaps=None,
+            labels=assigned_labels)
diff --git a/mmdetection/mmdet/models/task_modules/assigners/iou2d_calculator.py b/mmdetection/mmdet/models/task_modules/assigners/iou2d_calculator.py
new file mode 100644
index 00000000..b6daa94f
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/assigners/iou2d_calculator.py
@@ -0,0 +1,88 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+
+from mmdet.registry import TASK_UTILS
+from mmdet.structures.bbox import bbox_overlaps, get_box_tensor
+
+
+def cast_tensor_type(x, scale=1., dtype=None):
+    if dtype == 'fp16':
+        # scale is for preventing overflows
+        x = (x / scale).half()
+    return x
+
+
+@TASK_UTILS.register_module()
+class BboxOverlaps2D:
+    """2D Overlaps (e.g. IoUs, GIoUs) Calculator."""
+
+    def __init__(self, scale=1., dtype=None):
+        self.scale = scale
+        self.dtype = dtype
+
+    def __call__(self, bboxes1, bboxes2, mode='iou', is_aligned=False):
+        """Calculate IoU between 2D bboxes.
+
+        Args:
+            bboxes1 (Tensor or :obj:`BaseBoxes`): bboxes have shape (m, 4)
+                in  format, or shape (m, 5) in  format.
+            bboxes2 (Tensor or :obj:`BaseBoxes`): bboxes have shape (m, 4)
+                in  format, shape (m, 5) in  format, or be empty. If ``is_aligned `` is ``True``,
+                then m and n must be equal.
+            mode (str): "iou" (intersection over union), "iof" (intersection
+                over foreground), or "giou" (generalized intersection over
+                union).
+            is_aligned (bool, optional): If True, then m and n must be equal.
+                Default False.
+
+        Returns:
+            Tensor: shape (m, n) if ``is_aligned `` is False else shape (m,)
+        """
+        bboxes1 = get_box_tensor(bboxes1)
+        bboxes2 = get_box_tensor(bboxes2)
+        assert bboxes1.size(-1) in [0, 4, 5]
+        assert bboxes2.size(-1) in [0, 4, 5]
+        if bboxes2.size(-1) == 5:
+            bboxes2 = bboxes2[..., :4]
+        if bboxes1.size(-1) == 5:
+            bboxes1 = bboxes1[..., :4]
+
+        if self.dtype == 'fp16':
+            # change tensor type to save cpu and cuda memory and keep speed
+            bboxes1 = cast_tensor_type(bboxes1, self.scale, self.dtype)
+            bboxes2 = cast_tensor_type(bboxes2, self.scale, self.dtype)
+            overlaps = bbox_overlaps(bboxes1, bboxes2, mode, is_aligned)
+            if not overlaps.is_cuda and overlaps.dtype == torch.float16:
+                # resume cpu float32
+                overlaps = overlaps.float()
+            return overlaps
+
+        return bbox_overlaps(bboxes1, bboxes2, mode, is_aligned)
+
+    def __repr__(self):
+        """str: a string describing the module"""
+        repr_str = self.__class__.__name__ + f'(' \
+            f'scale={self.scale}, dtype={self.dtype})'
+        return repr_str
+
+
+@TASK_UTILS.register_module()
+class BboxOverlaps2D_GLIP(BboxOverlaps2D):
+
+    def __call__(self, bboxes1, bboxes2, mode='iou', is_aligned=False):
+        TO_REMOVE = 1
+        area1 = (bboxes1[:, 2] - bboxes1[:, 0] + TO_REMOVE) * (
+            bboxes1[:, 3] - bboxes1[:, 1] + TO_REMOVE)
+        area2 = (bboxes2[:, 2] - bboxes2[:, 0] + TO_REMOVE) * (
+            bboxes2[:, 3] - bboxes2[:, 1] + TO_REMOVE)
+
+        lt = torch.max(bboxes1[:, None, :2], bboxes2[:, :2])  # [N,M,2]
+        rb = torch.min(bboxes1[:, None, 2:], bboxes2[:, 2:])  # [N,M,2]
+
+        wh = (rb - lt + TO_REMOVE).clamp(min=0)  # [N,M,2]
+        inter = wh[:, :, 0] * wh[:, :, 1]  # [N,M]
+
+        iou = inter / (area1[:, None] + area2 - inter)
+        return iou
diff --git a/mmdetection/mmdet/models/task_modules/assigners/match_cost.py b/mmdetection/mmdet/models/task_modules/assigners/match_cost.py
new file mode 100644
index 00000000..5fc62f01
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/assigners/match_cost.py
@@ -0,0 +1,525 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from abc import abstractmethod
+from typing import Optional, Union
+
+import torch
+import torch.nn.functional as F
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import TASK_UTILS
+from mmdet.structures.bbox import bbox_overlaps, bbox_xyxy_to_cxcywh
+
+
+class BaseMatchCost:
+    """Base match cost class.
+
+    Args:
+        weight (Union[float, int]): Cost weight. Defaults to 1.
+    """
+
+    def __init__(self, weight: Union[float, int] = 1.) -> None:
+        self.weight = weight
+
+    @abstractmethod
+    def __call__(self,
+                 pred_instances: InstanceData,
+                 gt_instances: InstanceData,
+                 img_meta: Optional[dict] = None,
+                 **kwargs) -> Tensor:
+        """Compute match cost.
+
+        Args:
+            pred_instances (:obj:`InstanceData`): Instances of model
+                predictions. It includes ``priors``, and the priors can
+                be anchors or points, or the bboxes predicted by the
+                previous stage, has shape (n, 4). The bboxes predicted by
+                the current model or stage will be named ``bboxes``,
+                ``labels``, and ``scores``, the same as the ``InstanceData``
+                in other places.
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes``, with shape (k, 4),
+                and ``labels``, with shape (k, ).
+            img_meta (dict, optional): Image information.
+
+        Returns:
+            Tensor: Match Cost matrix of shape (num_preds, num_gts).
+        """
+        pass
+
+
+@TASK_UTILS.register_module()
+class BBoxL1Cost(BaseMatchCost):
+    """BBoxL1Cost.
+
+    Note: ``bboxes`` in ``InstanceData`` passed in is of format 'xyxy'
+    and its coordinates are unnormalized.
+
+    Args:
+        box_format (str, optional): 'xyxy' for DETR, 'xywh' for Sparse_RCNN.
+            Defaults to 'xyxy'.
+        weight (Union[float, int]): Cost weight. Defaults to 1.
+
+    Examples:
+        >>> from mmdet.models.task_modules.assigners.
+        ... match_costs.match_cost import BBoxL1Cost
+        >>> import torch
+        >>> self = BBoxL1Cost()
+        >>> bbox_pred = torch.rand(1, 4)
+        >>> gt_bboxes= torch.FloatTensor([[0, 0, 2, 4], [1, 2, 3, 4]])
+        >>> factor = torch.tensor([10, 8, 10, 8])
+        >>> self(bbox_pred, gt_bboxes, factor)
+        tensor([[1.6172, 1.6422]])
+    """
+
+    def __init__(self,
+                 box_format: str = 'xyxy',
+                 weight: Union[float, int] = 1.) -> None:
+        super().__init__(weight=weight)
+        assert box_format in ['xyxy', 'xywh']
+        self.box_format = box_format
+
+    def __call__(self,
+                 pred_instances: InstanceData,
+                 gt_instances: InstanceData,
+                 img_meta: Optional[dict] = None,
+                 **kwargs) -> Tensor:
+        """Compute match cost.
+
+        Args:
+            pred_instances (:obj:`InstanceData`): ``bboxes`` inside is
+                predicted boxes with unnormalized coordinate
+                (x, y, x, y).
+            gt_instances (:obj:`InstanceData`): ``bboxes`` inside is gt
+                bboxes with unnormalized coordinate (x, y, x, y).
+            img_meta (Optional[dict]): Image information. Defaults to None.
+
+        Returns:
+            Tensor: Match Cost matrix of shape (num_preds, num_gts).
+        """
+        pred_bboxes = pred_instances.bboxes
+        gt_bboxes = gt_instances.bboxes
+
+        # convert box format
+        if self.box_format == 'xywh':
+            gt_bboxes = bbox_xyxy_to_cxcywh(gt_bboxes)
+            pred_bboxes = bbox_xyxy_to_cxcywh(pred_bboxes)
+
+        # normalized
+        img_h, img_w = img_meta['img_shape']
+        factor = gt_bboxes.new_tensor([img_w, img_h, img_w,
+                                       img_h]).unsqueeze(0)
+        gt_bboxes = gt_bboxes / factor
+        pred_bboxes = pred_bboxes / factor
+
+        bbox_cost = torch.cdist(pred_bboxes, gt_bboxes, p=1)
+        return bbox_cost * self.weight
+
+
+@TASK_UTILS.register_module()
+class IoUCost(BaseMatchCost):
+    """IoUCost.
+
+    Note: ``bboxes`` in ``InstanceData`` passed in is of format 'xyxy'
+    and its coordinates are unnormalized.
+
+    Args:
+        iou_mode (str): iou mode such as 'iou', 'giou'. Defaults to 'giou'.
+        weight (Union[float, int]): Cost weight. Defaults to 1.
+
+    Examples:
+        >>> from mmdet.models.task_modules.assigners.
+        ... match_costs.match_cost import IoUCost
+        >>> import torch
+        >>> self = IoUCost()
+        >>> bboxes = torch.FloatTensor([[1,1, 2, 2], [2, 2, 3, 4]])
+        >>> gt_bboxes = torch.FloatTensor([[0, 0, 2, 4], [1, 2, 3, 4]])
+        >>> self(bboxes, gt_bboxes)
+        tensor([[-0.1250,  0.1667],
+            [ 0.1667, -0.5000]])
+    """
+
+    def __init__(self, iou_mode: str = 'giou', weight: Union[float, int] = 1.):
+        super().__init__(weight=weight)
+        self.iou_mode = iou_mode
+
+    def __call__(self,
+                 pred_instances: InstanceData,
+                 gt_instances: InstanceData,
+                 img_meta: Optional[dict] = None,
+                 **kwargs):
+        """Compute match cost.
+
+        Args:
+            pred_instances (:obj:`InstanceData`): ``bboxes`` inside is
+                predicted boxes with unnormalized coordinate
+                (x, y, x, y).
+            gt_instances (:obj:`InstanceData`): ``bboxes`` inside is gt
+                bboxes with unnormalized coordinate (x, y, x, y).
+            img_meta (Optional[dict]): Image information. Defaults to None.
+
+        Returns:
+            Tensor: Match Cost matrix of shape (num_preds, num_gts).
+        """
+        pred_bboxes = pred_instances.bboxes
+        gt_bboxes = gt_instances.bboxes
+
+        # avoid fp16 overflow
+        if pred_bboxes.dtype == torch.float16:
+            fp16 = True
+            pred_bboxes = pred_bboxes.to(torch.float32)
+        else:
+            fp16 = False
+
+        overlaps = bbox_overlaps(
+            pred_bboxes, gt_bboxes, mode=self.iou_mode, is_aligned=False)
+
+        if fp16:
+            overlaps = overlaps.to(torch.float16)
+
+        # The 1 is a constant that doesn't change the matching, so omitted.
+        iou_cost = -overlaps
+        return iou_cost * self.weight
+
+
+@TASK_UTILS.register_module()
+class ClassificationCost(BaseMatchCost):
+    """ClsSoftmaxCost.
+
+    Args:
+        weight (Union[float, int]): Cost weight. Defaults to 1.
+
+    Examples:
+        >>> from mmdet.models.task_modules.assigners.
+        ...  match_costs.match_cost import ClassificationCost
+        >>> import torch
+        >>> self = ClassificationCost()
+        >>> cls_pred = torch.rand(4, 3)
+        >>> gt_labels = torch.tensor([0, 1, 2])
+        >>> factor = torch.tensor([10, 8, 10, 8])
+        >>> self(cls_pred, gt_labels)
+        tensor([[-0.3430, -0.3525, -0.3045],
+            [-0.3077, -0.2931, -0.3992],
+            [-0.3664, -0.3455, -0.2881],
+            [-0.3343, -0.2701, -0.3956]])
+    """
+
+    def __init__(self, weight: Union[float, int] = 1) -> None:
+        super().__init__(weight=weight)
+
+    def __call__(self,
+                 pred_instances: InstanceData,
+                 gt_instances: InstanceData,
+                 img_meta: Optional[dict] = None,
+                 **kwargs) -> Tensor:
+        """Compute match cost.
+
+        Args:
+            pred_instances (:obj:`InstanceData`): ``scores`` inside is
+                predicted classification logits, of shape
+                (num_queries, num_class).
+            gt_instances (:obj:`InstanceData`): ``labels`` inside should have
+                shape (num_gt, ).
+            img_meta (Optional[dict]): _description_. Defaults to None.
+
+        Returns:
+            Tensor: Match Cost matrix of shape (num_preds, num_gts).
+        """
+        pred_scores = pred_instances.scores
+        gt_labels = gt_instances.labels
+
+        pred_scores = pred_scores.softmax(-1)
+        cls_cost = -pred_scores[:, gt_labels]
+
+        return cls_cost * self.weight
+
+
+@TASK_UTILS.register_module()
+class FocalLossCost(BaseMatchCost):
+    """FocalLossCost.
+
+    Args:
+        alpha (Union[float, int]): focal_loss alpha. Defaults to 0.25.
+        gamma (Union[float, int]): focal_loss gamma. Defaults to 2.
+        eps (float): Defaults to 1e-12.
+        binary_input (bool): Whether the input is binary. Currently,
+            binary_input = True is for masks input, binary_input = False
+            is for label input. Defaults to False.
+        weight (Union[float, int]): Cost weight. Defaults to 1.
+    """
+
+    def __init__(self,
+                 alpha: Union[float, int] = 0.25,
+                 gamma: Union[float, int] = 2,
+                 eps: float = 1e-12,
+                 binary_input: bool = False,
+                 weight: Union[float, int] = 1.) -> None:
+        super().__init__(weight=weight)
+        self.alpha = alpha
+        self.gamma = gamma
+        self.eps = eps
+        self.binary_input = binary_input
+
+    def _focal_loss_cost(self, cls_pred: Tensor, gt_labels: Tensor) -> Tensor:
+        """
+        Args:
+            cls_pred (Tensor): Predicted classification logits, shape
+                (num_queries, num_class).
+            gt_labels (Tensor): Label of `gt_bboxes`, shape (num_gt,).
+
+        Returns:
+            torch.Tensor: cls_cost value with weight
+        """
+        cls_pred = cls_pred.sigmoid()
+        neg_cost = -(1 - cls_pred + self.eps).log() * (
+            1 - self.alpha) * cls_pred.pow(self.gamma)
+        pos_cost = -(cls_pred + self.eps).log() * self.alpha * (
+            1 - cls_pred).pow(self.gamma)
+
+        cls_cost = pos_cost[:, gt_labels] - neg_cost[:, gt_labels]
+        return cls_cost * self.weight
+
+    def _mask_focal_loss_cost(self, cls_pred, gt_labels) -> Tensor:
+        """
+        Args:
+            cls_pred (Tensor): Predicted classification logits.
+                in shape (num_queries, d1, ..., dn), dtype=torch.float32.
+            gt_labels (Tensor): Ground truth in shape (num_gt, d1, ..., dn),
+                dtype=torch.long. Labels should be binary.
+
+        Returns:
+            Tensor: Focal cost matrix with weight in shape\
+                (num_queries, num_gt).
+        """
+        cls_pred = cls_pred.flatten(1)
+        gt_labels = gt_labels.flatten(1).float()
+        n = cls_pred.shape[1]
+        cls_pred = cls_pred.sigmoid()
+        neg_cost = -(1 - cls_pred + self.eps).log() * (
+            1 - self.alpha) * cls_pred.pow(self.gamma)
+        pos_cost = -(cls_pred + self.eps).log() * self.alpha * (
+            1 - cls_pred).pow(self.gamma)
+
+        cls_cost = torch.einsum('nc,mc->nm', pos_cost, gt_labels) + \
+            torch.einsum('nc,mc->nm', neg_cost, (1 - gt_labels))
+        return cls_cost / n * self.weight
+
+    def __call__(self,
+                 pred_instances: InstanceData,
+                 gt_instances: InstanceData,
+                 img_meta: Optional[dict] = None,
+                 **kwargs) -> Tensor:
+        """Compute match cost.
+
+        Args:
+            pred_instances (:obj:`InstanceData`): Predicted instances which
+                must contain ``scores`` or ``masks``.
+            gt_instances (:obj:`InstanceData`): Ground truth which must contain
+                ``labels`` or ``mask``.
+            img_meta (Optional[dict]): Image information. Defaults to None.
+
+        Returns:
+            Tensor: Match Cost matrix of shape (num_preds, num_gts).
+        """
+        if self.binary_input:
+            pred_masks = pred_instances.masks
+            gt_masks = gt_instances.masks
+            return self._mask_focal_loss_cost(pred_masks, gt_masks)
+        else:
+            pred_scores = pred_instances.scores
+            gt_labels = gt_instances.labels
+            return self._focal_loss_cost(pred_scores, gt_labels)
+
+
+@TASK_UTILS.register_module()
+class BinaryFocalLossCost(FocalLossCost):
+
+    def _focal_loss_cost(self, cls_pred: Tensor, gt_labels: Tensor) -> Tensor:
+        """
+        Args:
+            cls_pred (Tensor): Predicted classification logits, shape
+                (num_queries, num_class).
+            gt_labels (Tensor): Label of `gt_bboxes`, shape (num_gt,).
+
+        Returns:
+            torch.Tensor: cls_cost value with weight
+        """
+        cls_pred = cls_pred.flatten(1)
+        gt_labels = gt_labels.flatten(1).float()
+        cls_pred = cls_pred.sigmoid()
+        neg_cost = -(1 - cls_pred + self.eps).log() * (
+            1 - self.alpha) * cls_pred.pow(self.gamma)
+        pos_cost = -(cls_pred + self.eps).log() * self.alpha * (
+            1 - cls_pred).pow(self.gamma)
+
+        cls_cost = torch.einsum('nc,mc->nm', pos_cost, gt_labels) + \
+            torch.einsum('nc,mc->nm', neg_cost, (1 - gt_labels))
+        return cls_cost * self.weight
+
+    def __call__(self,
+                 pred_instances: InstanceData,
+                 gt_instances: InstanceData,
+                 img_meta: Optional[dict] = None,
+                 **kwargs) -> Tensor:
+        """Compute match cost.
+
+        Args:
+            pred_instances (:obj:`InstanceData`): Predicted instances which
+                must contain ``scores`` or ``masks``.
+            gt_instances (:obj:`InstanceData`): Ground truth which must contain
+                ``labels`` or ``mask``.
+            img_meta (Optional[dict]): Image information. Defaults to None.
+
+        Returns:
+            Tensor: Match Cost matrix of shape (num_preds, num_gts).
+        """
+        # gt_instances.text_token_mask is a repeated tensor of the same length
+        # of instances. Only gt_instances.text_token_mask[0] is useful
+        text_token_mask = torch.nonzero(
+            gt_instances.text_token_mask[0]).squeeze(-1)
+        pred_scores = pred_instances.scores[:, text_token_mask]
+        gt_labels = gt_instances.positive_maps[:, text_token_mask]
+        return self._focal_loss_cost(pred_scores, gt_labels)
+
+
+@TASK_UTILS.register_module()
+class DiceCost(BaseMatchCost):
+    """Cost of mask assignments based on dice losses.
+
+    Args:
+        pred_act (bool): Whether to apply sigmoid to mask_pred.
+            Defaults to False.
+        eps (float): Defaults to 1e-3.
+        naive_dice (bool): If True, use the naive dice loss
+            in which the power of the number in the denominator is
+            the first power. If False, use the second power that
+            is adopted by K-Net and SOLO. Defaults to True.
+        weight (Union[float, int]): Cost weight. Defaults to 1.
+    """
+
+    def __init__(self,
+                 pred_act: bool = False,
+                 eps: float = 1e-3,
+                 naive_dice: bool = True,
+                 weight: Union[float, int] = 1.) -> None:
+        super().__init__(weight=weight)
+        self.pred_act = pred_act
+        self.eps = eps
+        self.naive_dice = naive_dice
+
+    def _binary_mask_dice_loss(self, mask_preds: Tensor,
+                               gt_masks: Tensor) -> Tensor:
+        """
+        Args:
+            mask_preds (Tensor): Mask prediction in shape (num_queries, *).
+            gt_masks (Tensor): Ground truth in shape (num_gt, *)
+                store 0 or 1, 0 for negative class and 1 for
+                positive class.
+
+        Returns:
+            Tensor: Dice cost matrix in shape (num_queries, num_gt).
+        """
+        mask_preds = mask_preds.flatten(1)
+        gt_masks = gt_masks.flatten(1).float()
+        numerator = 2 * torch.einsum('nc,mc->nm', mask_preds, gt_masks)
+        if self.naive_dice:
+            denominator = mask_preds.sum(-1)[:, None] + \
+                          gt_masks.sum(-1)[None, :]
+        else:
+            denominator = mask_preds.pow(2).sum(1)[:, None] + \
+                          gt_masks.pow(2).sum(1)[None, :]
+        loss = 1 - (numerator + self.eps) / (denominator + self.eps)
+        return loss
+
+    def __call__(self,
+                 pred_instances: InstanceData,
+                 gt_instances: InstanceData,
+                 img_meta: Optional[dict] = None,
+                 **kwargs) -> Tensor:
+        """Compute match cost.
+
+        Args:
+            pred_instances (:obj:`InstanceData`): Predicted instances which
+                must contain ``masks``.
+            gt_instances (:obj:`InstanceData`): Ground truth which must contain
+                ``mask``.
+            img_meta (Optional[dict]): Image information. Defaults to None.
+
+        Returns:
+            Tensor: Match Cost matrix of shape (num_preds, num_gts).
+        """
+        pred_masks = pred_instances.masks
+        gt_masks = gt_instances.masks
+
+        if self.pred_act:
+            pred_masks = pred_masks.sigmoid()
+        dice_cost = self._binary_mask_dice_loss(pred_masks, gt_masks)
+        return dice_cost * self.weight
+
+
+@TASK_UTILS.register_module()
+class CrossEntropyLossCost(BaseMatchCost):
+    """CrossEntropyLossCost.
+
+    Args:
+        use_sigmoid (bool): Whether the prediction uses sigmoid
+                of softmax. Defaults to True.
+        weight (Union[float, int]): Cost weight. Defaults to 1.
+    """
+
+    def __init__(self,
+                 use_sigmoid: bool = True,
+                 weight: Union[float, int] = 1.) -> None:
+        super().__init__(weight=weight)
+        self.use_sigmoid = use_sigmoid
+
+    def _binary_cross_entropy(self, cls_pred: Tensor,
+                              gt_labels: Tensor) -> Tensor:
+        """
+        Args:
+            cls_pred (Tensor): The prediction with shape (num_queries, 1, *) or
+                (num_queries, *).
+            gt_labels (Tensor): The learning label of prediction with
+                shape (num_gt, *).
+
+        Returns:
+            Tensor: Cross entropy cost matrix in shape (num_queries, num_gt).
+        """
+        cls_pred = cls_pred.flatten(1).float()
+        gt_labels = gt_labels.flatten(1).float()
+        n = cls_pred.shape[1]
+        pos = F.binary_cross_entropy_with_logits(
+            cls_pred, torch.ones_like(cls_pred), reduction='none')
+        neg = F.binary_cross_entropy_with_logits(
+            cls_pred, torch.zeros_like(cls_pred), reduction='none')
+        cls_cost = torch.einsum('nc,mc->nm', pos, gt_labels) + \
+            torch.einsum('nc,mc->nm', neg, 1 - gt_labels)
+        cls_cost = cls_cost / n
+
+        return cls_cost
+
+    def __call__(self,
+                 pred_instances: InstanceData,
+                 gt_instances: InstanceData,
+                 img_meta: Optional[dict] = None,
+                 **kwargs) -> Tensor:
+        """Compute match cost.
+
+        Args:
+            pred_instances (:obj:`InstanceData`): Predicted instances which
+                must contain ``scores`` or ``masks``.
+            gt_instances (:obj:`InstanceData`): Ground truth which must contain
+                ``labels`` or ``masks``.
+            img_meta (Optional[dict]): Image information. Defaults to None.
+
+        Returns:
+            Tensor: Match Cost matrix of shape (num_preds, num_gts).
+        """
+        pred_masks = pred_instances.masks
+        gt_masks = gt_instances.masks
+        if self.use_sigmoid:
+            cls_cost = self._binary_cross_entropy(pred_masks, gt_masks)
+        else:
+            raise NotImplementedError
+
+        return cls_cost * self.weight
diff --git a/mmdetection/mmdet/models/task_modules/assigners/max_iou_assigner.py b/mmdetection/mmdet/models/task_modules/assigners/max_iou_assigner.py
new file mode 100644
index 00000000..71da5442
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/assigners/max_iou_assigner.py
@@ -0,0 +1,325 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+from typing import Optional, Union
+
+import torch
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import TASK_UTILS
+from .assign_result import AssignResult
+from .base_assigner import BaseAssigner
+
+
+def _perm_box(bboxes,
+              iou_calculator,
+              iou_thr=0.97,
+              perm_range=0.01,
+              counter=0,
+              max_iter=5):
+    """Compute the permuted bboxes.
+
+    Args:
+        bboxes (Tensor): Shape (n, 4) for , "xyxy" format.
+        iou_calculator (obj): Overlaps Calculator.
+        iou_thr (float): The permuted bboxes should have IoU > iou_thr.
+        perm_range (float): The scale of permutation.
+        counter (int): Counter of permutation iteration.
+        max_iter (int): The max iterations of permutation.
+    Returns:
+        Tensor: The permuted bboxes.
+    """
+    ori_bboxes = copy.deepcopy(bboxes)
+    is_valid = True
+    N = bboxes.size(0)
+    perm_factor = bboxes.new_empty(N, 4).uniform_(1 - perm_range,
+                                                  1 + perm_range)
+    bboxes *= perm_factor
+    new_wh = bboxes[:, 2:] - bboxes[:, :2]
+    if (new_wh <= 0).any():
+        is_valid = False
+    iou = iou_calculator(ori_bboxes.unique(dim=0), bboxes)
+    if (iou < iou_thr).any():
+        is_valid = False
+    if not is_valid and counter < max_iter:
+        return _perm_box(
+            ori_bboxes,
+            iou_calculator,
+            perm_range=max(perm_range - counter * 0.001, 1e-3),
+            counter=counter + 1)
+    return bboxes
+
+
+def perm_repeat_bboxes(bboxes, iou_calculator=None, perm_repeat_cfg=None):
+    """Permute the repeated bboxes.
+
+    Args:
+        bboxes (Tensor): Shape (n, 4) for , "xyxy" format.
+        iou_calculator (obj): Overlaps Calculator.
+        perm_repeat_cfg (Dict): Config of permutation.
+    Returns:
+        Tensor: Bboxes after permuted repeated bboxes.
+    """
+    assert isinstance(bboxes, torch.Tensor)
+    if iou_calculator is None:
+        import torchvision
+        iou_calculator = torchvision.ops.box_iou
+    bboxes = copy.deepcopy(bboxes)
+    unique_bboxes = bboxes.unique(dim=0)
+    iou_thr = perm_repeat_cfg.get('iou_thr', 0.97)
+    perm_range = perm_repeat_cfg.get('perm_range', 0.01)
+    for box in unique_bboxes:
+        inds = (bboxes == box).sum(-1).float() == 4
+        if inds.float().sum().item() == 1:
+            continue
+        bboxes[inds] = _perm_box(
+            bboxes[inds],
+            iou_calculator,
+            iou_thr=iou_thr,
+            perm_range=perm_range,
+            counter=0)
+    return bboxes
+
+
+@TASK_UTILS.register_module()
+class MaxIoUAssigner(BaseAssigner):
+    """Assign a corresponding gt bbox or background to each bbox.
+
+    Each proposals will be assigned with `-1`, or a semi-positive integer
+    indicating the ground truth index.
+
+    - -1: negative sample, no assigned gt
+    - semi-positive integer: positive sample, index (0-based) of assigned gt
+
+    Args:
+        pos_iou_thr (float): IoU threshold for positive bboxes.
+        neg_iou_thr (float or tuple): IoU threshold for negative bboxes.
+        min_pos_iou (float): Minimum iou for a bbox to be considered as a
+            positive bbox. Positive samples can have smaller IoU than
+            pos_iou_thr due to the 4th step (assign max IoU sample to each gt).
+            `min_pos_iou` is set to avoid assigning bboxes that have extremely
+            small iou with GT as positive samples. It brings about 0.3 mAP
+            improvements in 1x schedule but does not affect the performance of
+            3x schedule. More comparisons can be found in
+            `PR #7464 `_.
+        gt_max_assign_all (bool): Whether to assign all bboxes with the same
+            highest overlap with some gt to that gt.
+        ignore_iof_thr (float): IoF threshold for ignoring bboxes (if
+            `gt_bboxes_ignore` is specified). Negative values mean not
+            ignoring any bboxes.
+        ignore_wrt_candidates (bool): Whether to compute the iof between
+            `bboxes` and `gt_bboxes_ignore`, or the contrary.
+        match_low_quality (bool): Whether to allow low quality matches. This is
+            usually allowed for RPN and single stage detectors, but not allowed
+            in the second stage. Details are demonstrated in Step 4.
+        gpu_assign_thr (int): The upper bound of the number of GT for GPU
+            assign. When the number of gt is above this threshold, will assign
+            on CPU device. Negative values mean not assign on CPU.
+        iou_calculator (dict): Config of overlaps Calculator.
+        perm_repeat_gt_cfg (dict): Config of permute repeated gt bboxes.
+    """
+
+    def __init__(self,
+                 pos_iou_thr: float,
+                 neg_iou_thr: Union[float, tuple],
+                 min_pos_iou: float = .0,
+                 gt_max_assign_all: bool = True,
+                 ignore_iof_thr: float = -1,
+                 ignore_wrt_candidates: bool = True,
+                 match_low_quality: bool = True,
+                 gpu_assign_thr: float = -1,
+                 iou_calculator: dict = dict(type='BboxOverlaps2D'),
+                 perm_repeat_gt_cfg=None):
+        self.pos_iou_thr = pos_iou_thr
+        self.neg_iou_thr = neg_iou_thr
+        self.min_pos_iou = min_pos_iou
+        self.gt_max_assign_all = gt_max_assign_all
+        self.ignore_iof_thr = ignore_iof_thr
+        self.ignore_wrt_candidates = ignore_wrt_candidates
+        self.gpu_assign_thr = gpu_assign_thr
+        self.match_low_quality = match_low_quality
+        self.iou_calculator = TASK_UTILS.build(iou_calculator)
+        self.perm_repeat_gt_cfg = perm_repeat_gt_cfg
+
+    def assign(self,
+               pred_instances: InstanceData,
+               gt_instances: InstanceData,
+               gt_instances_ignore: Optional[InstanceData] = None,
+               **kwargs) -> AssignResult:
+        """Assign gt to bboxes.
+
+        This method assign a gt bbox to every bbox (proposal/anchor), each bbox
+        will be assigned with -1, or a semi-positive number. -1 means negative
+        sample, semi-positive number is the index (0-based) of assigned gt.
+        The assignment is done in following steps, the order matters.
+
+        1. assign every bbox to the background
+        2. assign proposals whose iou with all gts < neg_iou_thr to 0
+        3. for each bbox, if the iou with its nearest gt >= pos_iou_thr,
+           assign it to that bbox
+        4. for each gt bbox, assign its nearest proposals (may be more than
+           one) to itself
+
+        Args:
+            pred_instances (:obj:`InstanceData`): Instances of model
+                predictions. It includes ``priors``, and the priors can
+                be anchors or points, or the bboxes predicted by the
+                previous stage, has shape (n, 4). The bboxes predicted by
+                the current model or stage will be named ``bboxes``,
+                ``labels``, and ``scores``, the same as the ``InstanceData``
+                in other places.
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes``, with shape (k, 4),
+                and ``labels``, with shape (k, ).
+            gt_instances_ignore (:obj:`InstanceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes``
+                attribute data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            :obj:`AssignResult`: The assign result.
+
+        Example:
+            >>> from mmengine.structures import InstanceData
+            >>> self = MaxIoUAssigner(0.5, 0.5)
+            >>> pred_instances = InstanceData()
+            >>> pred_instances.priors = torch.Tensor([[0, 0, 10, 10],
+            ...                                      [10, 10, 20, 20]])
+            >>> gt_instances = InstanceData()
+            >>> gt_instances.bboxes = torch.Tensor([[0, 0, 10, 9]])
+            >>> gt_instances.labels = torch.Tensor([0])
+            >>> assign_result = self.assign(pred_instances, gt_instances)
+            >>> expected_gt_inds = torch.LongTensor([1, 0])
+            >>> assert torch.all(assign_result.gt_inds == expected_gt_inds)
+        """
+        gt_bboxes = gt_instances.bboxes
+        priors = pred_instances.priors
+        gt_labels = gt_instances.labels
+        if gt_instances_ignore is not None:
+            gt_bboxes_ignore = gt_instances_ignore.bboxes
+        else:
+            gt_bboxes_ignore = None
+
+        assign_on_cpu = True if (self.gpu_assign_thr > 0) and (
+            gt_bboxes.shape[0] > self.gpu_assign_thr) else False
+        # compute overlap and assign gt on CPU when number of GT is large
+        if assign_on_cpu:
+            device = priors.device
+            priors = priors.cpu()
+            gt_bboxes = gt_bboxes.cpu()
+            gt_labels = gt_labels.cpu()
+            if gt_bboxes_ignore is not None:
+                gt_bboxes_ignore = gt_bboxes_ignore.cpu()
+
+        if self.perm_repeat_gt_cfg is not None and priors.numel() > 0:
+            gt_bboxes_unique = perm_repeat_bboxes(gt_bboxes,
+                                                  self.iou_calculator,
+                                                  self.perm_repeat_gt_cfg)
+        else:
+            gt_bboxes_unique = gt_bboxes
+        overlaps = self.iou_calculator(gt_bboxes_unique, priors)
+
+        if (self.ignore_iof_thr > 0 and gt_bboxes_ignore is not None
+                and gt_bboxes_ignore.numel() > 0 and priors.numel() > 0):
+            if self.ignore_wrt_candidates:
+                ignore_overlaps = self.iou_calculator(
+                    priors, gt_bboxes_ignore, mode='iof')
+                ignore_max_overlaps, _ = ignore_overlaps.max(dim=1)
+            else:
+                ignore_overlaps = self.iou_calculator(
+                    gt_bboxes_ignore, priors, mode='iof')
+                ignore_max_overlaps, _ = ignore_overlaps.max(dim=0)
+            overlaps[:, ignore_max_overlaps > self.ignore_iof_thr] = -1
+
+        assign_result = self.assign_wrt_overlaps(overlaps, gt_labels)
+        if assign_on_cpu:
+            assign_result.gt_inds = assign_result.gt_inds.to(device)
+            assign_result.max_overlaps = assign_result.max_overlaps.to(device)
+            if assign_result.labels is not None:
+                assign_result.labels = assign_result.labels.to(device)
+        return assign_result
+
+    def assign_wrt_overlaps(self, overlaps: Tensor,
+                            gt_labels: Tensor) -> AssignResult:
+        """Assign w.r.t. the overlaps of priors with gts.
+
+        Args:
+            overlaps (Tensor): Overlaps between k gt_bboxes and n bboxes,
+                shape(k, n).
+            gt_labels (Tensor): Labels of k gt_bboxes, shape (k, ).
+
+        Returns:
+            :obj:`AssignResult`: The assign result.
+        """
+        num_gts, num_bboxes = overlaps.size(0), overlaps.size(1)
+
+        # 1. assign -1 by default
+        assigned_gt_inds = overlaps.new_full((num_bboxes, ),
+                                             -1,
+                                             dtype=torch.long)
+
+        if num_gts == 0 or num_bboxes == 0:
+            # No ground truth or boxes, return empty assignment
+            max_overlaps = overlaps.new_zeros((num_bboxes, ))
+            assigned_labels = overlaps.new_full((num_bboxes, ),
+                                                -1,
+                                                dtype=torch.long)
+            if num_gts == 0:
+                # No truth, assign everything to background
+                assigned_gt_inds[:] = 0
+            return AssignResult(
+                num_gts=num_gts,
+                gt_inds=assigned_gt_inds,
+                max_overlaps=max_overlaps,
+                labels=assigned_labels)
+
+        # for each anchor, which gt best overlaps with it
+        # for each anchor, the max iou of all gts
+        max_overlaps, argmax_overlaps = overlaps.max(dim=0)
+        # for each gt, which anchor best overlaps with it
+        # for each gt, the max iou of all proposals
+        gt_max_overlaps, gt_argmax_overlaps = overlaps.max(dim=1)
+
+        # 2. assign negative: below
+        # the negative inds are set to be 0
+        if isinstance(self.neg_iou_thr, float):
+            assigned_gt_inds[(max_overlaps >= 0)
+                             & (max_overlaps < self.neg_iou_thr)] = 0
+        elif isinstance(self.neg_iou_thr, tuple):
+            assert len(self.neg_iou_thr) == 2
+            assigned_gt_inds[(max_overlaps >= self.neg_iou_thr[0])
+                             & (max_overlaps < self.neg_iou_thr[1])] = 0
+
+        # 3. assign positive: above positive IoU threshold
+        pos_inds = max_overlaps >= self.pos_iou_thr
+        assigned_gt_inds[pos_inds] = argmax_overlaps[pos_inds] + 1
+
+        if self.match_low_quality:
+            # Low-quality matching will overwrite the assigned_gt_inds assigned
+            # in Step 3. Thus, the assigned gt might not be the best one for
+            # prediction.
+            # For example, if bbox A has 0.9 and 0.8 iou with GT bbox 1 & 2,
+            # bbox 1 will be assigned as the best target for bbox A in step 3.
+            # However, if GT bbox 2's gt_argmax_overlaps = A, bbox A's
+            # assigned_gt_inds will be overwritten to be bbox 2.
+            # This might be the reason that it is not used in ROI Heads.
+            for i in range(num_gts):
+                if gt_max_overlaps[i] >= self.min_pos_iou:
+                    if self.gt_max_assign_all:
+                        max_iou_inds = overlaps[i, :] == gt_max_overlaps[i]
+                        assigned_gt_inds[max_iou_inds] = i + 1
+                    else:
+                        assigned_gt_inds[gt_argmax_overlaps[i]] = i + 1
+
+        assigned_labels = assigned_gt_inds.new_full((num_bboxes, ), -1)
+        pos_inds = torch.nonzero(
+            assigned_gt_inds > 0, as_tuple=False).squeeze()
+        if pos_inds.numel() > 0:
+            assigned_labels[pos_inds] = gt_labels[assigned_gt_inds[pos_inds] -
+                                                  1]
+
+        return AssignResult(
+            num_gts=num_gts,
+            gt_inds=assigned_gt_inds,
+            max_overlaps=max_overlaps,
+            labels=assigned_labels)
diff --git a/mmdetection/mmdet/models/task_modules/assigners/multi_instance_assigner.py b/mmdetection/mmdet/models/task_modules/assigners/multi_instance_assigner.py
new file mode 100644
index 00000000..1ba32afe
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/assigners/multi_instance_assigner.py
@@ -0,0 +1,140 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional
+
+import torch
+from mmengine.structures import InstanceData
+
+from mmdet.registry import TASK_UTILS
+from .assign_result import AssignResult
+from .max_iou_assigner import MaxIoUAssigner
+
+
+@TASK_UTILS.register_module()
+class MultiInstanceAssigner(MaxIoUAssigner):
+    """Assign a corresponding gt bbox or background to each proposal bbox. If
+    we need to use a proposal box to generate multiple predict boxes,
+    `MultiInstanceAssigner` can assign multiple gt to each proposal box.
+
+    Args:
+        num_instance (int): How many bboxes are predicted by each proposal box.
+    """
+
+    def __init__(self, num_instance: int = 2, **kwargs):
+        super().__init__(**kwargs)
+        self.num_instance = num_instance
+
+    def assign(self,
+               pred_instances: InstanceData,
+               gt_instances: InstanceData,
+               gt_instances_ignore: Optional[InstanceData] = None,
+               **kwargs) -> AssignResult:
+        """Assign gt to bboxes.
+
+        This method assign gt bboxes to every bbox (proposal/anchor), each bbox
+        is assigned a set of gts, and the number of gts in this set is defined
+        by `self.num_instance`.
+
+        Args:
+            pred_instances (:obj:`InstanceData`): Instances of model
+                predictions. It includes ``priors``, and the priors can
+                be anchors or points, or the bboxes predicted by the
+                previous stage, has shape (n, 4). The bboxes predicted by
+                the current model or stage will be named ``bboxes``,
+                ``labels``, and ``scores``, the same as the ``InstanceData``
+                in other places.
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes``, with shape (k, 4),
+                and ``labels``, with shape (k, ).
+            gt_instances_ignore (:obj:`InstanceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes``
+                attribute data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            :obj:`AssignResult`: The assign result.
+        """
+        gt_bboxes = gt_instances.bboxes
+        priors = pred_instances.priors
+        # Set the FG label to 1 and add ignored annotations
+        gt_labels = gt_instances.labels + 1
+        if gt_instances_ignore is not None:
+            gt_bboxes_ignore = gt_instances_ignore.bboxes
+            if hasattr(gt_instances_ignore, 'labels'):
+                gt_labels_ignore = gt_instances_ignore.labels
+            else:
+                gt_labels_ignore = torch.ones_like(gt_bboxes_ignore)[:, 0] * -1
+        else:
+            gt_bboxes_ignore = None
+            gt_labels_ignore = None
+
+        assign_on_cpu = True if (self.gpu_assign_thr > 0) and (
+            gt_bboxes.shape[0] > self.gpu_assign_thr) else False
+        # compute overlap and assign gt on CPU when number of GT is large
+        if assign_on_cpu:
+            device = priors.device
+            priors = priors.cpu()
+            gt_bboxes = gt_bboxes.cpu()
+            gt_labels = gt_labels.cpu()
+            if gt_bboxes_ignore is not None:
+                gt_bboxes_ignore = gt_bboxes_ignore.cpu()
+                gt_labels_ignore = gt_labels_ignore.cpu()
+
+        if gt_bboxes_ignore is not None:
+            all_bboxes = torch.cat([gt_bboxes, gt_bboxes_ignore], dim=0)
+            all_labels = torch.cat([gt_labels, gt_labels_ignore], dim=0)
+        else:
+            all_bboxes = gt_bboxes
+            all_labels = gt_labels
+        all_priors = torch.cat([priors, all_bboxes], dim=0)
+
+        overlaps_normal = self.iou_calculator(
+            all_priors, all_bboxes, mode='iou')
+        overlaps_ignore = self.iou_calculator(
+            all_priors, all_bboxes, mode='iof')
+        gt_ignore_mask = all_labels.eq(-1).repeat(all_priors.shape[0], 1)
+        overlaps_normal = overlaps_normal * ~gt_ignore_mask
+        overlaps_ignore = overlaps_ignore * gt_ignore_mask
+
+        overlaps_normal, overlaps_normal_indices = overlaps_normal.sort(
+            descending=True, dim=1)
+        overlaps_ignore, overlaps_ignore_indices = overlaps_ignore.sort(
+            descending=True, dim=1)
+
+        # select the roi with the higher score
+        max_overlaps_normal = overlaps_normal[:, :self.num_instance].flatten()
+        gt_assignment_normal = overlaps_normal_indices[:, :self.
+                                                       num_instance].flatten()
+        max_overlaps_ignore = overlaps_ignore[:, :self.num_instance].flatten()
+        gt_assignment_ignore = overlaps_ignore_indices[:, :self.
+                                                       num_instance].flatten()
+
+        # ignore or not
+        ignore_assign_mask = (max_overlaps_normal < self.pos_iou_thr) * (
+            max_overlaps_ignore > max_overlaps_normal)
+        overlaps = (max_overlaps_normal * ~ignore_assign_mask) + (
+            max_overlaps_ignore * ignore_assign_mask)
+        gt_assignment = (gt_assignment_normal * ~ignore_assign_mask) + (
+            gt_assignment_ignore * ignore_assign_mask)
+
+        assigned_labels = all_labels[gt_assignment]
+        fg_mask = (overlaps >= self.pos_iou_thr) * (assigned_labels != -1)
+        bg_mask = (overlaps < self.neg_iou_thr) * (overlaps >= 0)
+        assigned_labels[fg_mask] = 1
+        assigned_labels[bg_mask] = 0
+
+        overlaps = overlaps.reshape(-1, self.num_instance)
+        gt_assignment = gt_assignment.reshape(-1, self.num_instance)
+        assigned_labels = assigned_labels.reshape(-1, self.num_instance)
+
+        assign_result = AssignResult(
+            num_gts=all_bboxes.size(0),
+            gt_inds=gt_assignment,
+            max_overlaps=overlaps,
+            labels=assigned_labels)
+
+        if assign_on_cpu:
+            assign_result.gt_inds = assign_result.gt_inds.to(device)
+            assign_result.max_overlaps = assign_result.max_overlaps.to(device)
+            if assign_result.labels is not None:
+                assign_result.labels = assign_result.labels.to(device)
+        return assign_result
diff --git a/mmdetection/mmdet/models/task_modules/assigners/point_assigner.py b/mmdetection/mmdet/models/task_modules/assigners/point_assigner.py
new file mode 100644
index 00000000..4da60a49
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/assigners/point_assigner.py
@@ -0,0 +1,155 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional
+
+import torch
+from mmengine.structures import InstanceData
+
+from mmdet.registry import TASK_UTILS
+from .assign_result import AssignResult
+from .base_assigner import BaseAssigner
+
+
+@TASK_UTILS.register_module()
+class PointAssigner(BaseAssigner):
+    """Assign a corresponding gt bbox or background to each point.
+
+    Each proposals will be assigned with `0`, or a positive integer
+    indicating the ground truth index.
+
+    - 0: negative sample, no assigned gt
+    - positive integer: positive sample, index (1-based) of assigned gt
+    """
+
+    def __init__(self, scale: int = 4, pos_num: int = 3) -> None:
+        self.scale = scale
+        self.pos_num = pos_num
+
+    def assign(self,
+               pred_instances: InstanceData,
+               gt_instances: InstanceData,
+               gt_instances_ignore: Optional[InstanceData] = None,
+               **kwargs) -> AssignResult:
+        """Assign gt to points.
+
+        This method assign a gt bbox to every points set, each points set
+        will be assigned with  the background_label (-1), or a label number.
+        -1 is background, and semi-positive number is the index (0-based) of
+        assigned gt.
+        The assignment is done in following steps, the order matters.
+
+        1. assign every points to the background_label (-1)
+        2. A point is assigned to some gt bbox if
+            (i) the point is within the k closest points to the gt bbox
+            (ii) the distance between this point and the gt is smaller than
+                other gt bboxes
+
+        Args:
+            pred_instances (:obj:`InstanceData`): Instances of model
+                predictions. It includes ``priors``, and the priors can
+                be anchors or points, or the bboxes predicted by the
+                previous stage, has shape (n, 4). The bboxes predicted by
+                the current model or stage will be named ``bboxes``,
+                ``labels``, and ``scores``, the same as the ``InstanceData``
+                in other places.
+
+
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes``, with shape (k, 4),
+                and ``labels``, with shape (k, ).
+            gt_instances_ignore (:obj:`InstanceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes``
+                attribute data that is ignored during training and testing.
+                Defaults to None.
+        Returns:
+            :obj:`AssignResult`: The assign result.
+        """
+        gt_bboxes = gt_instances.bboxes
+        gt_labels = gt_instances.labels
+        # points to be assigned, shape(n, 3) while last
+        # dimension stands for (x, y, stride).
+        points = pred_instances.priors
+
+        num_points = points.shape[0]
+        num_gts = gt_bboxes.shape[0]
+
+        if num_gts == 0 or num_points == 0:
+            # If no truth assign everything to the background
+            assigned_gt_inds = points.new_full((num_points, ),
+                                               0,
+                                               dtype=torch.long)
+            assigned_labels = points.new_full((num_points, ),
+                                              -1,
+                                              dtype=torch.long)
+            return AssignResult(
+                num_gts=num_gts,
+                gt_inds=assigned_gt_inds,
+                max_overlaps=None,
+                labels=assigned_labels)
+
+        points_xy = points[:, :2]
+        points_stride = points[:, 2]
+        points_lvl = torch.log2(
+            points_stride).int()  # [3...,4...,5...,6...,7...]
+        lvl_min, lvl_max = points_lvl.min(), points_lvl.max()
+
+        # assign gt box
+        gt_bboxes_xy = (gt_bboxes[:, :2] + gt_bboxes[:, 2:]) / 2
+        gt_bboxes_wh = (gt_bboxes[:, 2:] - gt_bboxes[:, :2]).clamp(min=1e-6)
+        scale = self.scale
+        gt_bboxes_lvl = ((torch.log2(gt_bboxes_wh[:, 0] / scale) +
+                          torch.log2(gt_bboxes_wh[:, 1] / scale)) / 2).int()
+        gt_bboxes_lvl = torch.clamp(gt_bboxes_lvl, min=lvl_min, max=lvl_max)
+
+        # stores the assigned gt index of each point
+        assigned_gt_inds = points.new_zeros((num_points, ), dtype=torch.long)
+        # stores the assigned gt dist (to this point) of each point
+        assigned_gt_dist = points.new_full((num_points, ), float('inf'))
+        points_range = torch.arange(points.shape[0])
+
+        for idx in range(num_gts):
+            gt_lvl = gt_bboxes_lvl[idx]
+            # get the index of points in this level
+            lvl_idx = gt_lvl == points_lvl
+            points_index = points_range[lvl_idx]
+            # get the points in this level
+            lvl_points = points_xy[lvl_idx, :]
+            # get the center point of gt
+            gt_point = gt_bboxes_xy[[idx], :]
+            # get width and height of gt
+            gt_wh = gt_bboxes_wh[[idx], :]
+            # compute the distance between gt center and
+            #   all points in this level
+            points_gt_dist = ((lvl_points - gt_point) / gt_wh).norm(dim=1)
+            # find the nearest k points to gt center in this level
+            min_dist, min_dist_index = torch.topk(
+                points_gt_dist, self.pos_num, largest=False)
+            # the index of nearest k points to gt center in this level
+            min_dist_points_index = points_index[min_dist_index]
+            # The less_than_recorded_index stores the index
+            #   of min_dist that is less then the assigned_gt_dist. Where
+            #   assigned_gt_dist stores the dist from previous assigned gt
+            #   (if exist) to each point.
+            less_than_recorded_index = min_dist < assigned_gt_dist[
+                min_dist_points_index]
+            # The min_dist_points_index stores the index of points satisfy:
+            #   (1) it is k nearest to current gt center in this level.
+            #   (2) it is closer to current gt center than other gt center.
+            min_dist_points_index = min_dist_points_index[
+                less_than_recorded_index]
+            # assign the result
+            assigned_gt_inds[min_dist_points_index] = idx + 1
+            assigned_gt_dist[min_dist_points_index] = min_dist[
+                less_than_recorded_index]
+
+        assigned_labels = assigned_gt_inds.new_full((num_points, ), -1)
+        pos_inds = torch.nonzero(
+            assigned_gt_inds > 0, as_tuple=False).squeeze()
+        if pos_inds.numel() > 0:
+            assigned_labels[pos_inds] = gt_labels[assigned_gt_inds[pos_inds] -
+                                                  1]
+
+        return AssignResult(
+            num_gts=num_gts,
+            gt_inds=assigned_gt_inds,
+            max_overlaps=None,
+            labels=assigned_labels)
diff --git a/mmdetection/mmdet/models/task_modules/assigners/region_assigner.py b/mmdetection/mmdet/models/task_modules/assigners/region_assigner.py
new file mode 100644
index 00000000..df549143
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/assigners/region_assigner.py
@@ -0,0 +1,239 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Tuple
+
+import torch
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import TASK_UTILS
+from ..prior_generators import anchor_inside_flags
+from .assign_result import AssignResult
+from .base_assigner import BaseAssigner
+
+
+def calc_region(
+        bbox: Tensor,
+        ratio: float,
+        stride: int,
+        featmap_size: Optional[Tuple[int, int]] = None) -> Tuple[Tensor]:
+    """Calculate region of the box defined by the ratio, the ratio is from the
+    center of the box to every edge."""
+    # project bbox on the feature
+    f_bbox = bbox / stride
+    x1 = torch.round((1 - ratio) * f_bbox[0] + ratio * f_bbox[2])
+    y1 = torch.round((1 - ratio) * f_bbox[1] + ratio * f_bbox[3])
+    x2 = torch.round(ratio * f_bbox[0] + (1 - ratio) * f_bbox[2])
+    y2 = torch.round(ratio * f_bbox[1] + (1 - ratio) * f_bbox[3])
+    if featmap_size is not None:
+        x1 = x1.clamp(min=0, max=featmap_size[1])
+        y1 = y1.clamp(min=0, max=featmap_size[0])
+        x2 = x2.clamp(min=0, max=featmap_size[1])
+        y2 = y2.clamp(min=0, max=featmap_size[0])
+    return (x1, y1, x2, y2)
+
+
+def anchor_ctr_inside_region_flags(anchors: Tensor, stride: int,
+                                   region: Tuple[Tensor]) -> Tensor:
+    """Get the flag indicate whether anchor centers are inside regions."""
+    x1, y1, x2, y2 = region
+    f_anchors = anchors / stride
+    x = (f_anchors[:, 0] + f_anchors[:, 2]) * 0.5
+    y = (f_anchors[:, 1] + f_anchors[:, 3]) * 0.5
+    flags = (x >= x1) & (x <= x2) & (y >= y1) & (y <= y2)
+    return flags
+
+
+@TASK_UTILS.register_module()
+class RegionAssigner(BaseAssigner):
+    """Assign a corresponding gt bbox or background to each bbox.
+
+    Each proposals will be assigned with `-1`, `0`, or a positive integer
+    indicating the ground truth index.
+
+    - -1: don't care
+    - 0: negative sample, no assigned gt
+    - positive integer: positive sample, index (1-based) of assigned gt
+
+    Args:
+        center_ratio (float): ratio of the region in the center of the bbox to
+            define positive sample.
+        ignore_ratio (float): ratio of the region to define ignore samples.
+    """
+
+    def __init__(self,
+                 center_ratio: float = 0.2,
+                 ignore_ratio: float = 0.5) -> None:
+        self.center_ratio = center_ratio
+        self.ignore_ratio = ignore_ratio
+
+    def assign(self,
+               pred_instances: InstanceData,
+               gt_instances: InstanceData,
+               img_meta: dict,
+               featmap_sizes: List[Tuple[int, int]],
+               num_level_anchors: List[int],
+               anchor_scale: int,
+               anchor_strides: List[int],
+               gt_instances_ignore: Optional[InstanceData] = None,
+               allowed_border: int = 0) -> AssignResult:
+        """Assign gt to anchors.
+
+        This method assign a gt bbox to every bbox (proposal/anchor), each bbox
+        will be assigned with -1, 0, or a positive number. -1 means don't care,
+        0 means negative sample, positive number is the index (1-based) of
+        assigned gt.
+
+        The assignment is done in following steps, and the order matters.
+
+        1. Assign every anchor to 0 (negative)
+        2. (For each gt_bboxes) Compute ignore flags based on ignore_region
+           then assign -1 to anchors w.r.t. ignore flags
+        3. (For each gt_bboxes) Compute pos flags based on center_region then
+           assign gt_bboxes to anchors w.r.t. pos flags
+        4. (For each gt_bboxes) Compute ignore flags based on adjacent anchor
+           level then assign -1 to anchors w.r.t. ignore flags
+        5. Assign anchor outside of image to -1
+
+        Args:
+            pred_instances (:obj:`InstanceData`): Instances of model
+                predictions. It includes ``priors``, and the priors can
+                be anchors or points, or the bboxes predicted by the
+                previous stage, has shape (n, 4). The bboxes predicted by
+                the current model or stage will be named ``bboxes``,
+                ``labels``, and ``scores``, the same as the ``InstanceData``
+                in other places.
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes``, with shape (k, 4),
+                and ``labels``, with shape (k, ).
+            img_meta (dict): Meta info of image.
+            featmap_sizes (list[tuple[int, int]]): Feature map size each level.
+            num_level_anchors (list[int]): The number of anchors in each level.
+            anchor_scale (int): Scale of the anchor.
+            anchor_strides (list[int]): Stride of the anchor.
+            gt_instances_ignore (:obj:`InstanceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes``
+                attribute data that is ignored during training and testing.
+                Defaults to None.
+            allowed_border (int, optional): The border to allow the valid
+                anchor. Defaults to 0.
+
+        Returns:
+            :obj:`AssignResult`: The assign result.
+        """
+        if gt_instances_ignore is not None:
+            raise NotImplementedError
+
+        num_gts = len(gt_instances)
+        num_bboxes = len(pred_instances)
+
+        gt_bboxes = gt_instances.bboxes
+        gt_labels = gt_instances.labels
+        flat_anchors = pred_instances.priors
+        flat_valid_flags = pred_instances.valid_flags
+        mlvl_anchors = torch.split(flat_anchors, num_level_anchors)
+
+        if num_gts == 0 or num_bboxes == 0:
+            # No ground truth or boxes, return empty assignment
+            max_overlaps = gt_bboxes.new_zeros((num_bboxes, ))
+            assigned_gt_inds = gt_bboxes.new_zeros((num_bboxes, ),
+                                                   dtype=torch.long)
+            assigned_labels = gt_bboxes.new_full((num_bboxes, ),
+                                                 -1,
+                                                 dtype=torch.long)
+            return AssignResult(
+                num_gts=num_gts,
+                gt_inds=assigned_gt_inds,
+                max_overlaps=max_overlaps,
+                labels=assigned_labels)
+
+        num_lvls = len(mlvl_anchors)
+        r1 = (1 - self.center_ratio) / 2
+        r2 = (1 - self.ignore_ratio) / 2
+
+        scale = torch.sqrt((gt_bboxes[:, 2] - gt_bboxes[:, 0]) *
+                           (gt_bboxes[:, 3] - gt_bboxes[:, 1]))
+        min_anchor_size = scale.new_full(
+            (1, ), float(anchor_scale * anchor_strides[0]))
+        target_lvls = torch.floor(
+            torch.log2(scale) - torch.log2(min_anchor_size) + 0.5)
+        target_lvls = target_lvls.clamp(min=0, max=num_lvls - 1).long()
+
+        # 1. assign 0 (negative) by default
+        mlvl_assigned_gt_inds = []
+        mlvl_ignore_flags = []
+        for lvl in range(num_lvls):
+            assigned_gt_inds = gt_bboxes.new_full((num_level_anchors[lvl], ),
+                                                  0,
+                                                  dtype=torch.long)
+            ignore_flags = torch.zeros_like(assigned_gt_inds)
+            mlvl_assigned_gt_inds.append(assigned_gt_inds)
+            mlvl_ignore_flags.append(ignore_flags)
+
+        for gt_id in range(num_gts):
+            lvl = target_lvls[gt_id].item()
+            featmap_size = featmap_sizes[lvl]
+            stride = anchor_strides[lvl]
+            anchors = mlvl_anchors[lvl]
+            gt_bbox = gt_bboxes[gt_id, :4]
+
+            # Compute regions
+            ignore_region = calc_region(gt_bbox, r2, stride, featmap_size)
+            ctr_region = calc_region(gt_bbox, r1, stride, featmap_size)
+
+            # 2. Assign -1 to ignore flags
+            ignore_flags = anchor_ctr_inside_region_flags(
+                anchors, stride, ignore_region)
+            mlvl_assigned_gt_inds[lvl][ignore_flags] = -1
+
+            # 3. Assign gt_bboxes to pos flags
+            pos_flags = anchor_ctr_inside_region_flags(anchors, stride,
+                                                       ctr_region)
+            mlvl_assigned_gt_inds[lvl][pos_flags] = gt_id + 1
+
+            # 4. Assign -1 to ignore adjacent lvl
+            if lvl > 0:
+                d_lvl = lvl - 1
+                d_anchors = mlvl_anchors[d_lvl]
+                d_featmap_size = featmap_sizes[d_lvl]
+                d_stride = anchor_strides[d_lvl]
+                d_ignore_region = calc_region(gt_bbox, r2, d_stride,
+                                              d_featmap_size)
+                ignore_flags = anchor_ctr_inside_region_flags(
+                    d_anchors, d_stride, d_ignore_region)
+                mlvl_ignore_flags[d_lvl][ignore_flags] = 1
+            if lvl < num_lvls - 1:
+                u_lvl = lvl + 1
+                u_anchors = mlvl_anchors[u_lvl]
+                u_featmap_size = featmap_sizes[u_lvl]
+                u_stride = anchor_strides[u_lvl]
+                u_ignore_region = calc_region(gt_bbox, r2, u_stride,
+                                              u_featmap_size)
+                ignore_flags = anchor_ctr_inside_region_flags(
+                    u_anchors, u_stride, u_ignore_region)
+                mlvl_ignore_flags[u_lvl][ignore_flags] = 1
+
+        # 4. (cont.) Assign -1 to ignore adjacent lvl
+        for lvl in range(num_lvls):
+            ignore_flags = mlvl_ignore_flags[lvl]
+            mlvl_assigned_gt_inds[lvl][ignore_flags == 1] = -1
+
+        # 5. Assign -1 to anchor outside of image
+        flat_assigned_gt_inds = torch.cat(mlvl_assigned_gt_inds)
+        assert (flat_assigned_gt_inds.shape[0] == flat_anchors.shape[0] ==
+                flat_valid_flags.shape[0])
+        inside_flags = anchor_inside_flags(flat_anchors, flat_valid_flags,
+                                           img_meta['img_shape'],
+                                           allowed_border)
+        outside_flags = ~inside_flags
+        flat_assigned_gt_inds[outside_flags] = -1
+
+        assigned_labels = torch.zeros_like(flat_assigned_gt_inds)
+        pos_flags = flat_assigned_gt_inds > 0
+        assigned_labels[pos_flags] = gt_labels[flat_assigned_gt_inds[pos_flags]
+                                               - 1]
+
+        return AssignResult(
+            num_gts=num_gts,
+            gt_inds=flat_assigned_gt_inds,
+            max_overlaps=None,
+            labels=assigned_labels)
diff --git a/mmdetection/mmdet/models/task_modules/assigners/sim_ota_assigner.py b/mmdetection/mmdet/models/task_modules/assigners/sim_ota_assigner.py
new file mode 100644
index 00000000..d54a8b91
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/assigners/sim_ota_assigner.py
@@ -0,0 +1,223 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Tuple
+
+import torch
+import torch.nn.functional as F
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import TASK_UTILS
+from mmdet.utils import ConfigType
+from .assign_result import AssignResult
+from .base_assigner import BaseAssigner
+
+INF = 100000.0
+EPS = 1.0e-7
+
+
+@TASK_UTILS.register_module()
+class SimOTAAssigner(BaseAssigner):
+    """Computes matching between predictions and ground truth.
+
+    Args:
+        center_radius (float): Ground truth center size
+            to judge whether a prior is in center. Defaults to 2.5.
+        candidate_topk (int): The candidate top-k which used to
+            get top-k ious to calculate dynamic-k. Defaults to 10.
+        iou_weight (float): The scale factor for regression
+            iou cost. Defaults to 3.0.
+        cls_weight (float): The scale factor for classification
+            cost. Defaults to 1.0.
+        iou_calculator (ConfigType): Config of overlaps Calculator.
+            Defaults to dict(type='BboxOverlaps2D').
+    """
+
+    def __init__(self,
+                 center_radius: float = 2.5,
+                 candidate_topk: int = 10,
+                 iou_weight: float = 3.0,
+                 cls_weight: float = 1.0,
+                 iou_calculator: ConfigType = dict(type='BboxOverlaps2D')):
+        self.center_radius = center_radius
+        self.candidate_topk = candidate_topk
+        self.iou_weight = iou_weight
+        self.cls_weight = cls_weight
+        self.iou_calculator = TASK_UTILS.build(iou_calculator)
+
+    def assign(self,
+               pred_instances: InstanceData,
+               gt_instances: InstanceData,
+               gt_instances_ignore: Optional[InstanceData] = None,
+               **kwargs) -> AssignResult:
+        """Assign gt to priors using SimOTA.
+
+        Args:
+            pred_instances (:obj:`InstanceData`): Instances of model
+                predictions. It includes ``priors``, and the priors can
+                be anchors or points, or the bboxes predicted by the
+                previous stage, has shape (n, 4). The bboxes predicted by
+                the current model or stage will be named ``bboxes``,
+                ``labels``, and ``scores``, the same as the ``InstanceData``
+                in other places.
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes``, with shape (k, 4),
+                and ``labels``, with shape (k, ).
+            gt_instances_ignore (:obj:`InstanceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes``
+                attribute data that is ignored during training and testing.
+                Defaults to None.
+        Returns:
+            obj:`AssignResult`: The assigned result.
+        """
+        gt_bboxes = gt_instances.bboxes
+        gt_labels = gt_instances.labels
+        num_gt = gt_bboxes.size(0)
+
+        decoded_bboxes = pred_instances.bboxes
+        pred_scores = pred_instances.scores
+        priors = pred_instances.priors
+        num_bboxes = decoded_bboxes.size(0)
+
+        # assign 0 by default
+        assigned_gt_inds = decoded_bboxes.new_full((num_bboxes, ),
+                                                   0,
+                                                   dtype=torch.long)
+        if num_gt == 0 or num_bboxes == 0:
+            # No ground truth or boxes, return empty assignment
+            max_overlaps = decoded_bboxes.new_zeros((num_bboxes, ))
+            assigned_labels = decoded_bboxes.new_full((num_bboxes, ),
+                                                      -1,
+                                                      dtype=torch.long)
+            return AssignResult(
+                num_gt, assigned_gt_inds, max_overlaps, labels=assigned_labels)
+
+        valid_mask, is_in_boxes_and_center = self.get_in_gt_and_in_center_info(
+            priors, gt_bboxes)
+        valid_decoded_bbox = decoded_bboxes[valid_mask]
+        valid_pred_scores = pred_scores[valid_mask]
+        num_valid = valid_decoded_bbox.size(0)
+        if num_valid == 0:
+            # No valid bboxes, return empty assignment
+            max_overlaps = decoded_bboxes.new_zeros((num_bboxes, ))
+            assigned_labels = decoded_bboxes.new_full((num_bboxes, ),
+                                                      -1,
+                                                      dtype=torch.long)
+            return AssignResult(
+                num_gt, assigned_gt_inds, max_overlaps, labels=assigned_labels)
+
+        pairwise_ious = self.iou_calculator(valid_decoded_bbox, gt_bboxes)
+        iou_cost = -torch.log(pairwise_ious + EPS)
+
+        gt_onehot_label = (
+            F.one_hot(gt_labels.to(torch.int64),
+                      pred_scores.shape[-1]).float().unsqueeze(0).repeat(
+                          num_valid, 1, 1))
+
+        valid_pred_scores = valid_pred_scores.unsqueeze(1).repeat(1, num_gt, 1)
+        # disable AMP autocast and calculate BCE with FP32 to avoid overflow
+        with torch.cuda.amp.autocast(enabled=False):
+            cls_cost = (
+                F.binary_cross_entropy(
+                    valid_pred_scores.to(dtype=torch.float32),
+                    gt_onehot_label,
+                    reduction='none',
+                ).sum(-1).to(dtype=valid_pred_scores.dtype))
+
+        cost_matrix = (
+            cls_cost * self.cls_weight + iou_cost * self.iou_weight +
+            (~is_in_boxes_and_center) * INF)
+
+        matched_pred_ious, matched_gt_inds = \
+            self.dynamic_k_matching(
+                cost_matrix, pairwise_ious, num_gt, valid_mask)
+
+        # convert to AssignResult format
+        assigned_gt_inds[valid_mask] = matched_gt_inds + 1
+        assigned_labels = assigned_gt_inds.new_full((num_bboxes, ), -1)
+        assigned_labels[valid_mask] = gt_labels[matched_gt_inds].long()
+        max_overlaps = assigned_gt_inds.new_full((num_bboxes, ),
+                                                 -INF,
+                                                 dtype=torch.float32)
+        max_overlaps[valid_mask] = matched_pred_ious
+        return AssignResult(
+            num_gt, assigned_gt_inds, max_overlaps, labels=assigned_labels)
+
+    def get_in_gt_and_in_center_info(
+            self, priors: Tensor, gt_bboxes: Tensor) -> Tuple[Tensor, Tensor]:
+        """Get the information of which prior is in gt bboxes and gt center
+        priors."""
+        num_gt = gt_bboxes.size(0)
+
+        repeated_x = priors[:, 0].unsqueeze(1).repeat(1, num_gt)
+        repeated_y = priors[:, 1].unsqueeze(1).repeat(1, num_gt)
+        repeated_stride_x = priors[:, 2].unsqueeze(1).repeat(1, num_gt)
+        repeated_stride_y = priors[:, 3].unsqueeze(1).repeat(1, num_gt)
+
+        # is prior centers in gt bboxes, shape: [n_prior, n_gt]
+        l_ = repeated_x - gt_bboxes[:, 0]
+        t_ = repeated_y - gt_bboxes[:, 1]
+        r_ = gt_bboxes[:, 2] - repeated_x
+        b_ = gt_bboxes[:, 3] - repeated_y
+
+        deltas = torch.stack([l_, t_, r_, b_], dim=1)
+        is_in_gts = deltas.min(dim=1).values > 0
+        is_in_gts_all = is_in_gts.sum(dim=1) > 0
+
+        # is prior centers in gt centers
+        gt_cxs = (gt_bboxes[:, 0] + gt_bboxes[:, 2]) / 2.0
+        gt_cys = (gt_bboxes[:, 1] + gt_bboxes[:, 3]) / 2.0
+        ct_box_l = gt_cxs - self.center_radius * repeated_stride_x
+        ct_box_t = gt_cys - self.center_radius * repeated_stride_y
+        ct_box_r = gt_cxs + self.center_radius * repeated_stride_x
+        ct_box_b = gt_cys + self.center_radius * repeated_stride_y
+
+        cl_ = repeated_x - ct_box_l
+        ct_ = repeated_y - ct_box_t
+        cr_ = ct_box_r - repeated_x
+        cb_ = ct_box_b - repeated_y
+
+        ct_deltas = torch.stack([cl_, ct_, cr_, cb_], dim=1)
+        is_in_cts = ct_deltas.min(dim=1).values > 0
+        is_in_cts_all = is_in_cts.sum(dim=1) > 0
+
+        # in boxes or in centers, shape: [num_priors]
+        is_in_gts_or_centers = is_in_gts_all | is_in_cts_all
+
+        # both in boxes and centers, shape: [num_fg, num_gt]
+        is_in_boxes_and_centers = (
+            is_in_gts[is_in_gts_or_centers, :]
+            & is_in_cts[is_in_gts_or_centers, :])
+        return is_in_gts_or_centers, is_in_boxes_and_centers
+
+    def dynamic_k_matching(self, cost: Tensor, pairwise_ious: Tensor,
+                           num_gt: int,
+                           valid_mask: Tensor) -> Tuple[Tensor, Tensor]:
+        """Use IoU and matching cost to calculate the dynamic top-k positive
+        targets."""
+        matching_matrix = torch.zeros_like(cost, dtype=torch.uint8)
+        # select candidate topk ious for dynamic-k calculation
+        candidate_topk = min(self.candidate_topk, pairwise_ious.size(0))
+        topk_ious, _ = torch.topk(pairwise_ious, candidate_topk, dim=0)
+        # calculate dynamic k for each gt
+        dynamic_ks = torch.clamp(topk_ious.sum(0).int(), min=1)
+        for gt_idx in range(num_gt):
+            _, pos_idx = torch.topk(
+                cost[:, gt_idx], k=dynamic_ks[gt_idx], largest=False)
+            matching_matrix[:, gt_idx][pos_idx] = 1
+
+        del topk_ious, dynamic_ks, pos_idx
+
+        prior_match_gt_mask = matching_matrix.sum(1) > 1
+        if prior_match_gt_mask.sum() > 0:
+            cost_min, cost_argmin = torch.min(
+                cost[prior_match_gt_mask, :], dim=1)
+            matching_matrix[prior_match_gt_mask, :] *= 0
+            matching_matrix[prior_match_gt_mask, cost_argmin] = 1
+        # get foreground mask inside box and center prior
+        fg_mask_inboxes = matching_matrix.sum(1) > 0
+        valid_mask[valid_mask.clone()] = fg_mask_inboxes
+
+        matched_gt_inds = matching_matrix[fg_mask_inboxes, :].argmax(1)
+        matched_pred_ious = (matching_matrix *
+                             pairwise_ious).sum(1)[fg_mask_inboxes]
+        return matched_pred_ious, matched_gt_inds
diff --git a/mmdetection/mmdet/models/task_modules/assigners/task_aligned_assigner.py b/mmdetection/mmdet/models/task_modules/assigners/task_aligned_assigner.py
new file mode 100644
index 00000000..220ea848
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/assigners/task_aligned_assigner.py
@@ -0,0 +1,158 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional
+
+import torch
+from mmengine.structures import InstanceData
+
+from mmdet.registry import TASK_UTILS
+from mmdet.utils import ConfigType
+from .assign_result import AssignResult
+from .base_assigner import BaseAssigner
+
+INF = 100000000
+
+
+@TASK_UTILS.register_module()
+class TaskAlignedAssigner(BaseAssigner):
+    """Task aligned assigner used in the paper:
+    `TOOD: Task-aligned One-stage Object Detection.
+    `_.
+
+    Assign a corresponding gt bbox or background to each predicted bbox.
+    Each bbox will be assigned with `0` or a positive integer
+    indicating the ground truth index.
+
+    - 0: negative sample, no assigned gt
+    - positive integer: positive sample, index (1-based) of assigned gt
+
+    Args:
+        topk (int): number of bbox selected in each level
+        iou_calculator (:obj:`ConfigDict` or dict): Config dict for iou
+            calculator. Defaults to ``dict(type='BboxOverlaps2D')``
+    """
+
+    def __init__(self,
+                 topk: int,
+                 iou_calculator: ConfigType = dict(type='BboxOverlaps2D')):
+        assert topk >= 1
+        self.topk = topk
+        self.iou_calculator = TASK_UTILS.build(iou_calculator)
+
+    def assign(self,
+               pred_instances: InstanceData,
+               gt_instances: InstanceData,
+               gt_instances_ignore: Optional[InstanceData] = None,
+               alpha: int = 1,
+               beta: int = 6) -> AssignResult:
+        """Assign gt to bboxes.
+
+        The assignment is done in following steps
+
+        1. compute alignment metric between all bbox (bbox of all pyramid
+           levels) and gt
+        2. select top-k bbox as candidates for each gt
+        3. limit the positive sample's center in gt (because the anchor-free
+           detector only can predict positive distance)
+
+
+        Args:
+            pred_instances (:obj:`InstaceData`): Instances of model
+                predictions. It includes ``priors``, and the priors can
+                be anchors, points, or bboxes predicted by the model,
+                shape(n, 4).
+            gt_instances (:obj:`InstaceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            gt_instances_ignore (:obj:`InstaceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes``
+                attribute data that is ignored during training and testing.
+                Defaults to None.
+            alpha (int): Hyper-parameters related to alignment_metrics.
+                Defaults to 1.
+            beta (int): Hyper-parameters related to alignment_metrics.
+                Defaults to 6.
+
+        Returns:
+            :obj:`TaskAlignedAssignResult`: The assign result.
+        """
+        priors = pred_instances.priors
+        decode_bboxes = pred_instances.bboxes
+        pred_scores = pred_instances.scores
+        gt_bboxes = gt_instances.bboxes
+        gt_labels = gt_instances.labels
+
+        priors = priors[:, :4]
+        num_gt, num_bboxes = gt_bboxes.size(0), priors.size(0)
+        # compute alignment metric between all bbox and gt
+        overlaps = self.iou_calculator(decode_bboxes, gt_bboxes).detach()
+        bbox_scores = pred_scores[:, gt_labels].detach()
+        # assign 0 by default
+        assigned_gt_inds = priors.new_full((num_bboxes, ), 0, dtype=torch.long)
+        assign_metrics = priors.new_zeros((num_bboxes, ))
+
+        if num_gt == 0 or num_bboxes == 0:
+            # No ground truth or boxes, return empty assignment
+            max_overlaps = priors.new_zeros((num_bboxes, ))
+            if num_gt == 0:
+                # No gt boxes, assign everything to background
+                assigned_gt_inds[:] = 0
+            assigned_labels = priors.new_full((num_bboxes, ),
+                                              -1,
+                                              dtype=torch.long)
+            assign_result = AssignResult(
+                num_gt, assigned_gt_inds, max_overlaps, labels=assigned_labels)
+            assign_result.assign_metrics = assign_metrics
+            return assign_result
+
+        # select top-k bboxes as candidates for each gt
+        alignment_metrics = bbox_scores**alpha * overlaps**beta
+        topk = min(self.topk, alignment_metrics.size(0))
+        _, candidate_idxs = alignment_metrics.topk(topk, dim=0, largest=True)
+        candidate_metrics = alignment_metrics[candidate_idxs,
+                                              torch.arange(num_gt)]
+        is_pos = candidate_metrics > 0
+
+        # limit the positive sample's center in gt
+        priors_cx = (priors[:, 0] + priors[:, 2]) / 2.0
+        priors_cy = (priors[:, 1] + priors[:, 3]) / 2.0
+        for gt_idx in range(num_gt):
+            candidate_idxs[:, gt_idx] += gt_idx * num_bboxes
+        ep_priors_cx = priors_cx.view(1, -1).expand(
+            num_gt, num_bboxes).contiguous().view(-1)
+        ep_priors_cy = priors_cy.view(1, -1).expand(
+            num_gt, num_bboxes).contiguous().view(-1)
+        candidate_idxs = candidate_idxs.view(-1)
+
+        # calculate the left, top, right, bottom distance between positive
+        # bbox center and gt side
+        l_ = ep_priors_cx[candidate_idxs].view(-1, num_gt) - gt_bboxes[:, 0]
+        t_ = ep_priors_cy[candidate_idxs].view(-1, num_gt) - gt_bboxes[:, 1]
+        r_ = gt_bboxes[:, 2] - ep_priors_cx[candidate_idxs].view(-1, num_gt)
+        b_ = gt_bboxes[:, 3] - ep_priors_cy[candidate_idxs].view(-1, num_gt)
+        is_in_gts = torch.stack([l_, t_, r_, b_], dim=1).min(dim=1)[0] > 0.01
+        is_pos = is_pos & is_in_gts
+
+        # if an anchor box is assigned to multiple gts,
+        # the one with the highest iou will be selected.
+        overlaps_inf = torch.full_like(overlaps,
+                                       -INF).t().contiguous().view(-1)
+        index = candidate_idxs.view(-1)[is_pos.view(-1)]
+        overlaps_inf[index] = overlaps.t().contiguous().view(-1)[index]
+        overlaps_inf = overlaps_inf.view(num_gt, -1).t()
+
+        max_overlaps, argmax_overlaps = overlaps_inf.max(dim=1)
+        assigned_gt_inds[
+            max_overlaps != -INF] = argmax_overlaps[max_overlaps != -INF] + 1
+        assign_metrics[max_overlaps != -INF] = alignment_metrics[
+            max_overlaps != -INF, argmax_overlaps[max_overlaps != -INF]]
+
+        assigned_labels = assigned_gt_inds.new_full((num_bboxes, ), -1)
+        pos_inds = torch.nonzero(
+            assigned_gt_inds > 0, as_tuple=False).squeeze()
+        if pos_inds.numel() > 0:
+            assigned_labels[pos_inds] = gt_labels[assigned_gt_inds[pos_inds] -
+                                                  1]
+        assign_result = AssignResult(
+            num_gt, assigned_gt_inds, max_overlaps, labels=assigned_labels)
+        assign_result.assign_metrics = assign_metrics
+        return assign_result
diff --git a/mmdetection/mmdet/models/task_modules/assigners/topk_hungarian_assigner.py b/mmdetection/mmdet/models/task_modules/assigners/topk_hungarian_assigner.py
new file mode 100644
index 00000000..e48f092a
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/assigners/topk_hungarian_assigner.py
@@ -0,0 +1,182 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from mmengine.structures import BaseDataElement
+from scipy.optimize import linear_sum_assignment
+
+from mmdet.registry import TASK_UTILS
+from .assign_result import AssignResult
+from .task_aligned_assigner import TaskAlignedAssigner
+
+
+@TASK_UTILS.register_module()
+class TopkHungarianAssigner(TaskAlignedAssigner):
+    """Computes 1-to-k matching between ground truth and predictions.
+
+    This class computes an assignment between the targets and the predictions
+    based on the costs. The costs are weighted sum of some components.
+    For DETR the costs are weighted sum of classification cost, regression L1
+    cost and regression iou cost. The targets don't include the no_object, so
+    generally there are more predictions than targets. After the 1-to-k
+    gt-pred matching, the un-matched are treated as backgrounds. Thus each
+    query prediction will be assigned with `0` or a positive integer
+    indicating the ground truth index:
+
+    - 0: negative sample, no assigned gt
+    - positive integer: positive sample, index (1-based) of assigned gt
+
+    Args:
+        cls_cost (dict): Classification cost configuration.
+        reg_cost (dict): Regression L1  cost configuration.
+        iou_cost (dict): Regression iou cost configuration.
+    """
+
+    def __init__(self,
+                 *args,
+                 cls_cost=dict(type='FocalLossCost', weight=2.0),
+                 reg_cost=dict(type='BBoxL1Cost', weight=5.0),
+                 iou_cost=dict(type='IoUCost', iou_mode='giou', weight=2.0),
+                 **kwargs):
+        super(TopkHungarianAssigner, self).__init__(*args, **kwargs)
+
+        self.cls_cost = TASK_UTILS.build(cls_cost)
+        self.reg_cost = TASK_UTILS.build(reg_cost)
+        self.iou_cost = TASK_UTILS.build(iou_cost)
+
+    def assign(self,
+               pred_scores,
+               decode_bboxes,
+               gt_bboxes,
+               gt_labels,
+               img_meta,
+               alpha=1,
+               beta=6,
+               **kwargs):
+        """Computes 1-to-k gt-pred matching based on the weighted costs.
+
+        This method assign each query prediction to a ground truth or
+        background. The `assigned_gt_inds` with -1 means don't care,
+        0 means negative sample, and positive number is the index (1-based)
+        of assigned gt.
+        The assignment is done in the following steps, the order matters.
+
+        1. Assign every prediction to -1.
+        2. Compute the weighted costs, each cost has shape (num_pred, num_gt).
+        3. Update topk to be min(topk, int(num_pred / num_gt)), then repeat
+            costs topk times to shape: (num_pred, num_gt * topk), so that each
+            gt will match topk predictions.
+        3. Do Hungarian matching on CPU based on the costs.
+        4. Assign all to 0 (background) first, then for each matched pair
+           between predictions and gts, treat this prediction as foreground
+           and assign the corresponding gt index (plus 1) to it.
+        5. Calculate alignment metrics and overlaps of each matched pred-gt
+            pair.
+
+        Args:
+            pred_scores (Tensor): Predicted normalized classification
+                scores for one image, has shape (num_dense_queries,
+                cls_out_channels).
+            decode_bboxes (Tensor): Predicted unnormalized bbox coordinates
+                for one image, has shape (num_dense_queries, 4) with the
+                last dimension arranged as (x1, y1, x2, y2).
+            gt_bboxes (Tensor): Unnormalized ground truth
+                bboxes for one image, has shape (num_gt, 4) with the
+                last dimension arranged as (x1, y1, x2, y2).
+                NOTE: num_gt is dynamic for each image.
+            gt_labels (Tensor): Ground truth classification
+                    index for the image, has shape (num_gt,).
+                    NOTE: num_gt is dynamic for each image.
+            img_meta (dict): Meta information for one image.
+            alpha (int): Hyper-parameters related to alignment_metrics.
+                Defaults to 1.
+            beta (int): Hyper-parameters related to alignment_metrics.
+                Defaults to 6.
+
+        Returns:
+            :obj:`AssignResult`: The assigned result.
+        """
+        pred_scores = pred_scores.detach()
+        decode_bboxes = decode_bboxes.detach()
+        temp_overlaps = self.iou_calculator(decode_bboxes, gt_bboxes).detach()
+        bbox_scores = pred_scores[:, gt_labels].detach()
+        alignment_metrics = bbox_scores**alpha * temp_overlaps**beta
+
+        pred_instances = BaseDataElement()
+        gt_instances = BaseDataElement()
+
+        pred_instances.bboxes = decode_bboxes
+        gt_instances.bboxes = gt_bboxes
+
+        pred_instances.scores = pred_scores
+        gt_instances.labels = gt_labels
+
+        reg_cost = self.reg_cost(pred_instances, gt_instances, img_meta)
+        iou_cost = self.iou_cost(pred_instances, gt_instances, img_meta)
+        cls_cost = self.cls_cost(pred_instances, gt_instances, img_meta)
+        all_cost = cls_cost + reg_cost + iou_cost
+
+        num_gt, num_bboxes = gt_bboxes.size(0), pred_scores.size(0)
+        if num_gt > 0:
+            # assign 0 by default
+            assigned_gt_inds = pred_scores.new_full((num_bboxes, ),
+                                                    0,
+                                                    dtype=torch.long)
+            select_cost = all_cost
+
+            topk = min(self.topk, int(len(select_cost) / num_gt))
+
+            # Repeat the ground truth `topk` times to perform 1-to-k gt-pred
+            #   matching. For example, if `num_pred` = 900, `num_gt` = 3, then
+            #   there are only 3 gt-pred pairs in sum for 1-1 matching.
+            #   However, for 1-k gt-pred matching, if `topk` = 4, then each
+            #   gt is assigned 4 unique predictions, so there would be 12
+            #   gt-pred pairs in sum.
+            repeat_select_cost = select_cost[...,
+                                             None].repeat(1, 1, topk).view(
+                                                 select_cost.size(0), -1)
+            # anchor index and gt index
+            matched_row_inds, matched_col_inds = linear_sum_assignment(
+                repeat_select_cost.detach().cpu().numpy())
+            matched_row_inds = torch.from_numpy(matched_row_inds).to(
+                pred_scores.device)
+            matched_col_inds = torch.from_numpy(matched_col_inds).to(
+                pred_scores.device)
+
+            match_gt_ids = matched_col_inds // topk
+            candidate_idxs = matched_row_inds
+
+            assigned_labels = assigned_gt_inds.new_full((num_bboxes, ), -1)
+
+            if candidate_idxs.numel() > 0:
+                assigned_labels[candidate_idxs] = gt_labels[match_gt_ids]
+            else:
+                assigned_labels = None
+
+            assigned_gt_inds[candidate_idxs] = match_gt_ids + 1
+
+            overlaps = self.iou_calculator(
+                decode_bboxes[candidate_idxs],
+                gt_bboxes[match_gt_ids],
+                is_aligned=True).detach()
+
+            temp_pos_alignment_metrics = alignment_metrics[candidate_idxs]
+            pos_alignment_metrics = torch.gather(temp_pos_alignment_metrics, 1,
+                                                 match_gt_ids[:,
+                                                              None]).view(-1)
+            assign_result = AssignResult(
+                num_gt, assigned_gt_inds, overlaps, labels=assigned_labels)
+
+            assign_result.assign_metrics = pos_alignment_metrics
+            return assign_result
+        else:
+
+            assigned_gt_inds = pred_scores.new_full((num_bboxes, ),
+                                                    -1,
+                                                    dtype=torch.long)
+
+            assigned_labels = pred_scores.new_full((num_bboxes, ),
+                                                   -1,
+                                                   dtype=torch.long)
+
+            assigned_gt_inds[:] = 0
+            return AssignResult(
+                0, assigned_gt_inds, None, labels=assigned_labels)
diff --git a/mmdetection/mmdet/models/task_modules/assigners/uniform_assigner.py b/mmdetection/mmdet/models/task_modules/assigners/uniform_assigner.py
new file mode 100644
index 00000000..9a83bfd0
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/assigners/uniform_assigner.py
@@ -0,0 +1,173 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional
+
+import torch
+from mmengine.structures import InstanceData
+
+from mmdet.registry import TASK_UTILS
+from mmdet.structures.bbox import bbox_xyxy_to_cxcywh
+from mmdet.utils import ConfigType
+from .assign_result import AssignResult
+from .base_assigner import BaseAssigner
+
+
+@TASK_UTILS.register_module()
+class UniformAssigner(BaseAssigner):
+    """Uniform Matching between the priors and gt boxes, which can achieve
+    balance in positive priors, and gt_bboxes_ignore was not considered for
+    now.
+
+    Args:
+        pos_ignore_thr (float): the threshold to ignore positive priors
+        neg_ignore_thr (float): the threshold to ignore negative priors
+        match_times(int): Number of positive priors for each gt box.
+           Defaults to 4.
+        iou_calculator (:obj:`ConfigDict` or dict): Config dict for iou
+            calculator. Defaults to ``dict(type='BboxOverlaps2D')``
+    """
+
+    def __init__(self,
+                 pos_ignore_thr: float,
+                 neg_ignore_thr: float,
+                 match_times: int = 4,
+                 iou_calculator: ConfigType = dict(type='BboxOverlaps2D')):
+        self.match_times = match_times
+        self.pos_ignore_thr = pos_ignore_thr
+        self.neg_ignore_thr = neg_ignore_thr
+        self.iou_calculator = TASK_UTILS.build(iou_calculator)
+
+    def assign(
+            self,
+            pred_instances: InstanceData,
+            gt_instances: InstanceData,
+            gt_instances_ignore: Optional[InstanceData] = None
+    ) -> AssignResult:
+        """Assign gt to priors.
+
+        The assignment is done in following steps
+
+        1. assign -1 by default
+        2. compute the L1 cost between boxes. Note that we use priors and
+           predict boxes both
+        3. compute the ignore indexes use gt_bboxes and predict boxes
+        4. compute the ignore indexes of positive sample use priors and
+           predict boxes
+
+
+        Args:
+            pred_instances (:obj:`InstaceData`): Instances of model
+                predictions. It includes ``priors``, and the priors can
+                be priors, points, or bboxes predicted by the model,
+                shape(n, 4).
+            gt_instances (:obj:`InstaceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            gt_instances_ignore (:obj:`InstaceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes``
+                attribute data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            :obj:`AssignResult`: The assign result.
+        """
+
+        gt_bboxes = gt_instances.bboxes
+        gt_labels = gt_instances.labels
+        priors = pred_instances.priors
+        bbox_pred = pred_instances.decoder_priors
+
+        num_gts, num_bboxes = gt_bboxes.size(0), bbox_pred.size(0)
+
+        # 1. assign -1 by default
+        assigned_gt_inds = bbox_pred.new_full((num_bboxes, ),
+                                              0,
+                                              dtype=torch.long)
+        assigned_labels = bbox_pred.new_full((num_bboxes, ),
+                                             -1,
+                                             dtype=torch.long)
+        if num_gts == 0 or num_bboxes == 0:
+            # No ground truth or boxes, return empty assignment
+            if num_gts == 0:
+                # No ground truth, assign all to background
+                assigned_gt_inds[:] = 0
+            assign_result = AssignResult(
+                num_gts, assigned_gt_inds, None, labels=assigned_labels)
+            assign_result.set_extra_property(
+                'pos_idx', bbox_pred.new_empty(0, dtype=torch.bool))
+            assign_result.set_extra_property('pos_predicted_boxes',
+                                             bbox_pred.new_empty((0, 4)))
+            assign_result.set_extra_property('target_boxes',
+                                             bbox_pred.new_empty((0, 4)))
+            return assign_result
+
+        # 2. Compute the L1 cost between boxes
+        # Note that we use priors and predict boxes both
+        cost_bbox = torch.cdist(
+            bbox_xyxy_to_cxcywh(bbox_pred),
+            bbox_xyxy_to_cxcywh(gt_bboxes),
+            p=1)
+        cost_bbox_priors = torch.cdist(
+            bbox_xyxy_to_cxcywh(priors), bbox_xyxy_to_cxcywh(gt_bboxes), p=1)
+
+        # We found that topk function has different results in cpu and
+        # cuda mode. In order to ensure consistency with the source code,
+        # we also use cpu mode.
+        # TODO: Check whether the performance of cpu and cuda are the same.
+        C = cost_bbox.cpu()
+        C1 = cost_bbox_priors.cpu()
+
+        # self.match_times x n
+        index = torch.topk(
+            C,  # c=b,n,x c[i]=n,x
+            k=self.match_times,
+            dim=0,
+            largest=False)[1]
+
+        # self.match_times x n
+        index1 = torch.topk(C1, k=self.match_times, dim=0, largest=False)[1]
+        # (self.match_times*2) x n
+        indexes = torch.cat((index, index1),
+                            dim=1).reshape(-1).to(bbox_pred.device)
+
+        pred_overlaps = self.iou_calculator(bbox_pred, gt_bboxes)
+        anchor_overlaps = self.iou_calculator(priors, gt_bboxes)
+        pred_max_overlaps, _ = pred_overlaps.max(dim=1)
+        anchor_max_overlaps, _ = anchor_overlaps.max(dim=0)
+
+        # 3. Compute the ignore indexes use gt_bboxes and predict boxes
+        ignore_idx = pred_max_overlaps > self.neg_ignore_thr
+        assigned_gt_inds[ignore_idx] = -1
+
+        # 4. Compute the ignore indexes of positive sample use priors
+        # and predict boxes
+        pos_gt_index = torch.arange(
+            0, C1.size(1),
+            device=bbox_pred.device).repeat(self.match_times * 2)
+        pos_ious = anchor_overlaps[indexes, pos_gt_index]
+        pos_ignore_idx = pos_ious < self.pos_ignore_thr
+
+        pos_gt_index_with_ignore = pos_gt_index + 1
+        pos_gt_index_with_ignore[pos_ignore_idx] = -1
+        assigned_gt_inds[indexes] = pos_gt_index_with_ignore
+
+        if gt_labels is not None:
+            assigned_labels = assigned_gt_inds.new_full((num_bboxes, ), -1)
+            pos_inds = torch.nonzero(
+                assigned_gt_inds > 0, as_tuple=False).squeeze()
+            if pos_inds.numel() > 0:
+                assigned_labels[pos_inds] = gt_labels[
+                    assigned_gt_inds[pos_inds] - 1]
+        else:
+            assigned_labels = None
+
+        assign_result = AssignResult(
+            num_gts,
+            assigned_gt_inds,
+            anchor_max_overlaps,
+            labels=assigned_labels)
+        assign_result.set_extra_property('pos_idx', ~pos_ignore_idx)
+        assign_result.set_extra_property('pos_predicted_boxes',
+                                         bbox_pred[indexes])
+        assign_result.set_extra_property('target_boxes',
+                                         gt_bboxes[pos_gt_index])
+        return assign_result
diff --git a/mmdetection/mmdet/models/task_modules/builder.py b/mmdetection/mmdet/models/task_modules/builder.py
new file mode 100644
index 00000000..6736049f
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/builder.py
@@ -0,0 +1,62 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+
+from mmdet.registry import TASK_UTILS
+
+PRIOR_GENERATORS = TASK_UTILS
+ANCHOR_GENERATORS = TASK_UTILS
+BBOX_ASSIGNERS = TASK_UTILS
+BBOX_SAMPLERS = TASK_UTILS
+BBOX_CODERS = TASK_UTILS
+MATCH_COSTS = TASK_UTILS
+IOU_CALCULATORS = TASK_UTILS
+
+
+def build_bbox_coder(cfg, **default_args):
+    """Builder of box coder."""
+    warnings.warn('``build_sampler`` would be deprecated soon, please use '
+                  '``mmdet.registry.TASK_UTILS.build()`` ')
+    return TASK_UTILS.build(cfg, default_args=default_args)
+
+
+def build_iou_calculator(cfg, default_args=None):
+    """Builder of IoU calculator."""
+    warnings.warn(
+        '``build_iou_calculator`` would be deprecated soon, please use '
+        '``mmdet.registry.TASK_UTILS.build()`` ')
+    return TASK_UTILS.build(cfg, default_args=default_args)
+
+
+def build_match_cost(cfg, default_args=None):
+    """Builder of IoU calculator."""
+    warnings.warn('``build_match_cost`` would be deprecated soon, please use '
+                  '``mmdet.registry.TASK_UTILS.build()`` ')
+    return TASK_UTILS.build(cfg, default_args=default_args)
+
+
+def build_assigner(cfg, **default_args):
+    """Builder of box assigner."""
+    warnings.warn('``build_assigner`` would be deprecated soon, please use '
+                  '``mmdet.registry.TASK_UTILS.build()`` ')
+    return TASK_UTILS.build(cfg, default_args=default_args)
+
+
+def build_sampler(cfg, **default_args):
+    """Builder of box sampler."""
+    warnings.warn('``build_sampler`` would be deprecated soon, please use '
+                  '``mmdet.registry.TASK_UTILS.build()`` ')
+    return TASK_UTILS.build(cfg, default_args=default_args)
+
+
+def build_prior_generator(cfg, default_args=None):
+    warnings.warn(
+        '``build_prior_generator`` would be deprecated soon, please use '
+        '``mmdet.registry.TASK_UTILS.build()`` ')
+    return TASK_UTILS.build(cfg, default_args=default_args)
+
+
+def build_anchor_generator(cfg, default_args=None):
+    warnings.warn(
+        '``build_anchor_generator`` would be deprecated soon, please use '
+        '``mmdet.registry.TASK_UTILS.build()`` ')
+    return TASK_UTILS.build(cfg, default_args=default_args)
diff --git a/mmdetection/mmdet/models/task_modules/coders/__init__.py b/mmdetection/mmdet/models/task_modules/coders/__init__.py
new file mode 100644
index 00000000..97c39821
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/coders/__init__.py
@@ -0,0 +1,16 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .base_bbox_coder import BaseBBoxCoder
+from .bucketing_bbox_coder import BucketingBBoxCoder
+from .delta_xywh_bbox_coder import (DeltaXYWHBBoxCoder,
+                                    DeltaXYWHBBoxCoderForGLIP)
+from .distance_point_bbox_coder import DistancePointBBoxCoder
+from .legacy_delta_xywh_bbox_coder import LegacyDeltaXYWHBBoxCoder
+from .pseudo_bbox_coder import PseudoBBoxCoder
+from .tblr_bbox_coder import TBLRBBoxCoder
+from .yolo_bbox_coder import YOLOBBoxCoder
+
+__all__ = [
+    'BaseBBoxCoder', 'PseudoBBoxCoder', 'DeltaXYWHBBoxCoder',
+    'LegacyDeltaXYWHBBoxCoder', 'TBLRBBoxCoder', 'YOLOBBoxCoder',
+    'BucketingBBoxCoder', 'DistancePointBBoxCoder', 'DeltaXYWHBBoxCoderForGLIP'
+]
diff --git a/mmdetection/mmdet/models/task_modules/coders/base_bbox_coder.py b/mmdetection/mmdet/models/task_modules/coders/base_bbox_coder.py
new file mode 100644
index 00000000..806d2651
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/coders/base_bbox_coder.py
@@ -0,0 +1,26 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from abc import ABCMeta, abstractmethod
+
+
+class BaseBBoxCoder(metaclass=ABCMeta):
+    """Base bounding box coder.
+
+    Args:
+        use_box_type (bool): Whether to warp decoded boxes with the
+            box type data structure. Defaults to False.
+    """
+
+    # The size of the last of dimension of the encoded tensor.
+    encode_size = 4
+
+    def __init__(self, use_box_type: bool = False, **kwargs):
+        self.use_box_type = use_box_type
+
+    @abstractmethod
+    def encode(self, bboxes, gt_bboxes):
+        """Encode deltas between bboxes and ground truth boxes."""
+
+    @abstractmethod
+    def decode(self, bboxes, bboxes_pred):
+        """Decode the predicted bboxes according to prediction and base
+        boxes."""
diff --git a/mmdetection/mmdet/models/task_modules/coders/bucketing_bbox_coder.py b/mmdetection/mmdet/models/task_modules/coders/bucketing_bbox_coder.py
new file mode 100644
index 00000000..4044e1cd
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/coders/bucketing_bbox_coder.py
@@ -0,0 +1,366 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Sequence, Tuple, Union
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch import Tensor
+
+from mmdet.registry import TASK_UTILS
+from mmdet.structures.bbox import (BaseBoxes, HorizontalBoxes, bbox_rescale,
+                                   get_box_tensor)
+from .base_bbox_coder import BaseBBoxCoder
+
+
+@TASK_UTILS.register_module()
+class BucketingBBoxCoder(BaseBBoxCoder):
+    """Bucketing BBox Coder for Side-Aware Boundary Localization (SABL).
+
+    Boundary Localization with Bucketing and Bucketing Guided Rescoring
+    are implemented here.
+
+    Please refer to https://arxiv.org/abs/1912.04260 for more details.
+
+    Args:
+        num_buckets (int): Number of buckets.
+        scale_factor (int): Scale factor of proposals to generate buckets.
+        offset_topk (int): Topk buckets are used to generate
+             bucket fine regression targets. Defaults to 2.
+        offset_upperbound (float): Offset upperbound to generate
+             bucket fine regression targets.
+             To avoid too large offset displacements. Defaults to 1.0.
+        cls_ignore_neighbor (bool): Ignore second nearest bucket or Not.
+             Defaults to True.
+        clip_border (bool, optional): Whether clip the objects outside the
+            border of the image. Defaults to True.
+    """
+
+    def __init__(self,
+                 num_buckets: int,
+                 scale_factor: int,
+                 offset_topk: int = 2,
+                 offset_upperbound: float = 1.0,
+                 cls_ignore_neighbor: bool = True,
+                 clip_border: bool = True,
+                 **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.num_buckets = num_buckets
+        self.scale_factor = scale_factor
+        self.offset_topk = offset_topk
+        self.offset_upperbound = offset_upperbound
+        self.cls_ignore_neighbor = cls_ignore_neighbor
+        self.clip_border = clip_border
+
+    def encode(self, bboxes: Union[Tensor, BaseBoxes],
+               gt_bboxes: Union[Tensor, BaseBoxes]) -> Tuple[Tensor]:
+        """Get bucketing estimation and fine regression targets during
+        training.
+
+        Args:
+            bboxes (torch.Tensor or :obj:`BaseBoxes`): source boxes,
+                e.g., object proposals.
+            gt_bboxes (torch.Tensor or :obj:`BaseBoxes`): target of the
+                transformation, e.g., ground truth boxes.
+
+        Returns:
+           encoded_bboxes(tuple[Tensor]): bucketing estimation
+            and fine regression targets and weights
+        """
+        bboxes = get_box_tensor(bboxes)
+        gt_bboxes = get_box_tensor(gt_bboxes)
+        assert bboxes.size(0) == gt_bboxes.size(0)
+        assert bboxes.size(-1) == gt_bboxes.size(-1) == 4
+        encoded_bboxes = bbox2bucket(bboxes, gt_bboxes, self.num_buckets,
+                                     self.scale_factor, self.offset_topk,
+                                     self.offset_upperbound,
+                                     self.cls_ignore_neighbor)
+        return encoded_bboxes
+
+    def decode(
+        self,
+        bboxes: Union[Tensor, BaseBoxes],
+        pred_bboxes: Tensor,
+        max_shape: Optional[Tuple[int]] = None
+    ) -> Tuple[Union[Tensor, BaseBoxes], Tensor]:
+        """Apply transformation `pred_bboxes` to `boxes`.
+        Args:
+            boxes (torch.Tensor or :obj:`BaseBoxes`): Basic boxes.
+            pred_bboxes (torch.Tensor): Predictions for bucketing estimation
+                and fine regression
+            max_shape (tuple[int], optional): Maximum shape of boxes.
+                Defaults to None.
+
+        Returns:
+            Union[torch.Tensor, :obj:`BaseBoxes`]: Decoded boxes.
+        """
+        bboxes = get_box_tensor(bboxes)
+        assert len(pred_bboxes) == 2
+        cls_preds, offset_preds = pred_bboxes
+        assert cls_preds.size(0) == bboxes.size(0) and offset_preds.size(
+            0) == bboxes.size(0)
+        bboxes, loc_confidence = bucket2bbox(bboxes, cls_preds, offset_preds,
+                                             self.num_buckets,
+                                             self.scale_factor, max_shape,
+                                             self.clip_border)
+        if self.use_box_type:
+            bboxes = HorizontalBoxes(bboxes, clone=False)
+        return bboxes, loc_confidence
+
+
+def generat_buckets(proposals: Tensor,
+                    num_buckets: int,
+                    scale_factor: float = 1.0) -> Tuple[Tensor]:
+    """Generate buckets w.r.t bucket number and scale factor of proposals.
+
+    Args:
+        proposals (Tensor): Shape (n, 4)
+        num_buckets (int): Number of buckets.
+        scale_factor (float): Scale factor to rescale proposals.
+
+    Returns:
+        tuple[Tensor]: (bucket_w, bucket_h, l_buckets, r_buckets,
+         t_buckets, d_buckets)
+
+            - bucket_w: Width of buckets on x-axis. Shape (n, ).
+            - bucket_h: Height of buckets on y-axis. Shape (n, ).
+            - l_buckets: Left buckets. Shape (n, ceil(side_num/2)).
+            - r_buckets: Right buckets. Shape (n, ceil(side_num/2)).
+            - t_buckets: Top buckets. Shape (n, ceil(side_num/2)).
+            - d_buckets: Down buckets. Shape (n, ceil(side_num/2)).
+    """
+    proposals = bbox_rescale(proposals, scale_factor)
+
+    # number of buckets in each side
+    side_num = int(np.ceil(num_buckets / 2.0))
+    pw = proposals[..., 2] - proposals[..., 0]
+    ph = proposals[..., 3] - proposals[..., 1]
+    px1 = proposals[..., 0]
+    py1 = proposals[..., 1]
+    px2 = proposals[..., 2]
+    py2 = proposals[..., 3]
+
+    bucket_w = pw / num_buckets
+    bucket_h = ph / num_buckets
+
+    # left buckets
+    l_buckets = px1[:, None] + (0.5 + torch.arange(
+        0, side_num).to(proposals).float())[None, :] * bucket_w[:, None]
+    # right buckets
+    r_buckets = px2[:, None] - (0.5 + torch.arange(
+        0, side_num).to(proposals).float())[None, :] * bucket_w[:, None]
+    # top buckets
+    t_buckets = py1[:, None] + (0.5 + torch.arange(
+        0, side_num).to(proposals).float())[None, :] * bucket_h[:, None]
+    # down buckets
+    d_buckets = py2[:, None] - (0.5 + torch.arange(
+        0, side_num).to(proposals).float())[None, :] * bucket_h[:, None]
+    return bucket_w, bucket_h, l_buckets, r_buckets, t_buckets, d_buckets
+
+
+def bbox2bucket(proposals: Tensor,
+                gt: Tensor,
+                num_buckets: int,
+                scale_factor: float,
+                offset_topk: int = 2,
+                offset_upperbound: float = 1.0,
+                cls_ignore_neighbor: bool = True) -> Tuple[Tensor]:
+    """Generate buckets estimation and fine regression targets.
+
+    Args:
+        proposals (Tensor): Shape (n, 4)
+        gt (Tensor): Shape (n, 4)
+        num_buckets (int): Number of buckets.
+        scale_factor (float): Scale factor to rescale proposals.
+        offset_topk (int): Topk buckets are used to generate
+             bucket fine regression targets. Defaults to 2.
+        offset_upperbound (float): Offset allowance to generate
+             bucket fine regression targets.
+             To avoid too large offset displacements. Defaults to 1.0.
+        cls_ignore_neighbor (bool): Ignore second nearest bucket or Not.
+             Defaults to True.
+
+    Returns:
+        tuple[Tensor]: (offsets, offsets_weights, bucket_labels, cls_weights).
+
+            - offsets: Fine regression targets. \
+                Shape (n, num_buckets*2).
+            - offsets_weights: Fine regression weights. \
+                Shape (n, num_buckets*2).
+            - bucket_labels: Bucketing estimation labels. \
+                Shape (n, num_buckets*2).
+            - cls_weights: Bucketing estimation weights. \
+                Shape (n, num_buckets*2).
+    """
+    assert proposals.size() == gt.size()
+
+    # generate buckets
+    proposals = proposals.float()
+    gt = gt.float()
+    (bucket_w, bucket_h, l_buckets, r_buckets, t_buckets,
+     d_buckets) = generat_buckets(proposals, num_buckets, scale_factor)
+
+    gx1 = gt[..., 0]
+    gy1 = gt[..., 1]
+    gx2 = gt[..., 2]
+    gy2 = gt[..., 3]
+
+    # generate offset targets and weights
+    # offsets from buckets to gts
+    l_offsets = (l_buckets - gx1[:, None]) / bucket_w[:, None]
+    r_offsets = (r_buckets - gx2[:, None]) / bucket_w[:, None]
+    t_offsets = (t_buckets - gy1[:, None]) / bucket_h[:, None]
+    d_offsets = (d_buckets - gy2[:, None]) / bucket_h[:, None]
+
+    # select top-k nearest buckets
+    l_topk, l_label = l_offsets.abs().topk(
+        offset_topk, dim=1, largest=False, sorted=True)
+    r_topk, r_label = r_offsets.abs().topk(
+        offset_topk, dim=1, largest=False, sorted=True)
+    t_topk, t_label = t_offsets.abs().topk(
+        offset_topk, dim=1, largest=False, sorted=True)
+    d_topk, d_label = d_offsets.abs().topk(
+        offset_topk, dim=1, largest=False, sorted=True)
+
+    offset_l_weights = l_offsets.new_zeros(l_offsets.size())
+    offset_r_weights = r_offsets.new_zeros(r_offsets.size())
+    offset_t_weights = t_offsets.new_zeros(t_offsets.size())
+    offset_d_weights = d_offsets.new_zeros(d_offsets.size())
+    inds = torch.arange(0, proposals.size(0)).to(proposals).long()
+
+    # generate offset weights of top-k nearest buckets
+    for k in range(offset_topk):
+        if k >= 1:
+            offset_l_weights[inds, l_label[:,
+                                           k]] = (l_topk[:, k] <
+                                                  offset_upperbound).float()
+            offset_r_weights[inds, r_label[:,
+                                           k]] = (r_topk[:, k] <
+                                                  offset_upperbound).float()
+            offset_t_weights[inds, t_label[:,
+                                           k]] = (t_topk[:, k] <
+                                                  offset_upperbound).float()
+            offset_d_weights[inds, d_label[:,
+                                           k]] = (d_topk[:, k] <
+                                                  offset_upperbound).float()
+        else:
+            offset_l_weights[inds, l_label[:, k]] = 1.0
+            offset_r_weights[inds, r_label[:, k]] = 1.0
+            offset_t_weights[inds, t_label[:, k]] = 1.0
+            offset_d_weights[inds, d_label[:, k]] = 1.0
+
+    offsets = torch.cat([l_offsets, r_offsets, t_offsets, d_offsets], dim=-1)
+    offsets_weights = torch.cat([
+        offset_l_weights, offset_r_weights, offset_t_weights, offset_d_weights
+    ],
+                                dim=-1)
+
+    # generate bucket labels and weight
+    side_num = int(np.ceil(num_buckets / 2.0))
+    labels = torch.stack(
+        [l_label[:, 0], r_label[:, 0], t_label[:, 0], d_label[:, 0]], dim=-1)
+
+    batch_size = labels.size(0)
+    bucket_labels = F.one_hot(labels.view(-1), side_num).view(batch_size,
+                                                              -1).float()
+    bucket_cls_l_weights = (l_offsets.abs() < 1).float()
+    bucket_cls_r_weights = (r_offsets.abs() < 1).float()
+    bucket_cls_t_weights = (t_offsets.abs() < 1).float()
+    bucket_cls_d_weights = (d_offsets.abs() < 1).float()
+    bucket_cls_weights = torch.cat([
+        bucket_cls_l_weights, bucket_cls_r_weights, bucket_cls_t_weights,
+        bucket_cls_d_weights
+    ],
+                                   dim=-1)
+    # ignore second nearest buckets for cls if necessary
+    if cls_ignore_neighbor:
+        bucket_cls_weights = (~((bucket_cls_weights == 1) &
+                                (bucket_labels == 0))).float()
+    else:
+        bucket_cls_weights[:] = 1.0
+    return offsets, offsets_weights, bucket_labels, bucket_cls_weights
+
+
+def bucket2bbox(proposals: Tensor,
+                cls_preds: Tensor,
+                offset_preds: Tensor,
+                num_buckets: int,
+                scale_factor: float = 1.0,
+                max_shape: Optional[Union[Sequence[int], Tensor,
+                                          Sequence[Sequence[int]]]] = None,
+                clip_border: bool = True) -> Tuple[Tensor]:
+    """Apply bucketing estimation (cls preds) and fine regression (offset
+    preds) to generate det bboxes.
+
+    Args:
+        proposals (Tensor): Boxes to be transformed. Shape (n, 4)
+        cls_preds (Tensor): bucketing estimation. Shape (n, num_buckets*2).
+        offset_preds (Tensor): fine regression. Shape (n, num_buckets*2).
+        num_buckets (int): Number of buckets.
+        scale_factor (float): Scale factor to rescale proposals.
+        max_shape (tuple[int, int]): Maximum bounds for boxes. specifies (H, W)
+        clip_border (bool, optional): Whether clip the objects outside the
+            border of the image. Defaults to True.
+
+    Returns:
+        tuple[Tensor]: (bboxes, loc_confidence).
+
+            - bboxes: predicted bboxes. Shape (n, 4)
+            - loc_confidence: localization confidence of predicted bboxes.
+                Shape (n,).
+    """
+
+    side_num = int(np.ceil(num_buckets / 2.0))
+    cls_preds = cls_preds.view(-1, side_num)
+    offset_preds = offset_preds.view(-1, side_num)
+
+    scores = F.softmax(cls_preds, dim=1)
+    score_topk, score_label = scores.topk(2, dim=1, largest=True, sorted=True)
+
+    rescaled_proposals = bbox_rescale(proposals, scale_factor)
+
+    pw = rescaled_proposals[..., 2] - rescaled_proposals[..., 0]
+    ph = rescaled_proposals[..., 3] - rescaled_proposals[..., 1]
+    px1 = rescaled_proposals[..., 0]
+    py1 = rescaled_proposals[..., 1]
+    px2 = rescaled_proposals[..., 2]
+    py2 = rescaled_proposals[..., 3]
+
+    bucket_w = pw / num_buckets
+    bucket_h = ph / num_buckets
+
+    score_inds_l = score_label[0::4, 0]
+    score_inds_r = score_label[1::4, 0]
+    score_inds_t = score_label[2::4, 0]
+    score_inds_d = score_label[3::4, 0]
+    l_buckets = px1 + (0.5 + score_inds_l.float()) * bucket_w
+    r_buckets = px2 - (0.5 + score_inds_r.float()) * bucket_w
+    t_buckets = py1 + (0.5 + score_inds_t.float()) * bucket_h
+    d_buckets = py2 - (0.5 + score_inds_d.float()) * bucket_h
+
+    offsets = offset_preds.view(-1, 4, side_num)
+    inds = torch.arange(proposals.size(0)).to(proposals).long()
+    l_offsets = offsets[:, 0, :][inds, score_inds_l]
+    r_offsets = offsets[:, 1, :][inds, score_inds_r]
+    t_offsets = offsets[:, 2, :][inds, score_inds_t]
+    d_offsets = offsets[:, 3, :][inds, score_inds_d]
+
+    x1 = l_buckets - l_offsets * bucket_w
+    x2 = r_buckets - r_offsets * bucket_w
+    y1 = t_buckets - t_offsets * bucket_h
+    y2 = d_buckets - d_offsets * bucket_h
+
+    if clip_border and max_shape is not None:
+        x1 = x1.clamp(min=0, max=max_shape[1] - 1)
+        y1 = y1.clamp(min=0, max=max_shape[0] - 1)
+        x2 = x2.clamp(min=0, max=max_shape[1] - 1)
+        y2 = y2.clamp(min=0, max=max_shape[0] - 1)
+    bboxes = torch.cat([x1[:, None], y1[:, None], x2[:, None], y2[:, None]],
+                       dim=-1)
+
+    # bucketing guided rescoring
+    loc_confidence = score_topk[:, 0]
+    top2_neighbor_inds = (score_label[:, 0] - score_label[:, 1]).abs() == 1
+    loc_confidence += score_topk[:, 1] * top2_neighbor_inds.float()
+    loc_confidence = loc_confidence.view(-1, 4).mean(dim=1)
+
+    return bboxes, loc_confidence
diff --git a/mmdetection/mmdet/models/task_modules/coders/delta_xywh_bbox_coder.py b/mmdetection/mmdet/models/task_modules/coders/delta_xywh_bbox_coder.py
new file mode 100644
index 00000000..c2b60b5e
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/coders/delta_xywh_bbox_coder.py
@@ -0,0 +1,579 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+from typing import Optional, Sequence, Union
+
+import numpy as np
+import torch
+from torch import Tensor
+
+from mmdet.registry import TASK_UTILS
+from mmdet.structures.bbox import BaseBoxes, HorizontalBoxes, get_box_tensor
+from .base_bbox_coder import BaseBBoxCoder
+
+
+@TASK_UTILS.register_module()
+class DeltaXYWHBBoxCoder(BaseBBoxCoder):
+    """Delta XYWH BBox coder.
+
+    Following the practice in `R-CNN `_,
+    this coder encodes bbox (x1, y1, x2, y2) into delta (dx, dy, dw, dh) and
+    decodes delta (dx, dy, dw, dh) back to original bbox (x1, y1, x2, y2).
+
+    Args:
+        target_means (Sequence[float]): Denormalizing means of target for
+            delta coordinates
+        target_stds (Sequence[float]): Denormalizing standard deviation of
+            target for delta coordinates
+        clip_border (bool, optional): Whether clip the objects outside the
+            border of the image. Defaults to True.
+        add_ctr_clamp (bool): Whether to add center clamp, when added, the
+            predicted box is clamped is its center is too far away from
+            the original anchor's center. Only used by YOLOF. Default False.
+        ctr_clamp (int): the maximum pixel shift to clamp. Only used by YOLOF.
+            Default 32.
+    """
+
+    def __init__(self,
+                 target_means: Sequence[float] = (0., 0., 0., 0.),
+                 target_stds: Sequence[float] = (1., 1., 1., 1.),
+                 clip_border: bool = True,
+                 add_ctr_clamp: bool = False,
+                 ctr_clamp: int = 32,
+                 **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.means = target_means
+        self.stds = target_stds
+        self.clip_border = clip_border
+        self.add_ctr_clamp = add_ctr_clamp
+        self.ctr_clamp = ctr_clamp
+
+    def encode(self, bboxes: Union[Tensor, BaseBoxes],
+               gt_bboxes: Union[Tensor, BaseBoxes]) -> Tensor:
+        """Get box regression transformation deltas that can be used to
+        transform the ``bboxes`` into the ``gt_bboxes``.
+
+        Args:
+            bboxes (torch.Tensor or :obj:`BaseBoxes`): Source boxes,
+                e.g., object proposals.
+            gt_bboxes (torch.Tensor or :obj:`BaseBoxes`): Target of the
+                transformation, e.g., ground-truth boxes.
+
+        Returns:
+            torch.Tensor: Box transformation deltas
+        """
+        bboxes = get_box_tensor(bboxes)
+        gt_bboxes = get_box_tensor(gt_bboxes)
+        assert bboxes.size(0) == gt_bboxes.size(0)
+        assert bboxes.size(-1) == gt_bboxes.size(-1) == 4
+        encoded_bboxes = bbox2delta(bboxes, gt_bboxes, self.means, self.stds)
+        return encoded_bboxes
+
+    def decode(
+        self,
+        bboxes: Union[Tensor, BaseBoxes],
+        pred_bboxes: Tensor,
+        max_shape: Optional[Union[Sequence[int], Tensor,
+                                  Sequence[Sequence[int]]]] = None,
+        wh_ratio_clip: Optional[float] = 16 / 1000
+    ) -> Union[Tensor, BaseBoxes]:
+        """Apply transformation `pred_bboxes` to `boxes`.
+
+        Args:
+            bboxes (torch.Tensor or :obj:`BaseBoxes`): Basic boxes. Shape
+                (B, N, 4) or (N, 4)
+            pred_bboxes (Tensor): Encoded offsets with respect to each roi.
+               Has shape (B, N, num_classes * 4) or (B, N, 4) or
+               (N, num_classes * 4) or (N, 4). Note N = num_anchors * W * H
+               when rois is a grid of anchors.Offset encoding follows [1]_.
+            max_shape (Sequence[int] or torch.Tensor or Sequence[
+               Sequence[int]],optional): Maximum bounds for boxes, specifies
+               (H, W, C) or (H, W). If bboxes shape is (B, N, 4), then
+               the max_shape should be a Sequence[Sequence[int]]
+               and the length of max_shape should also be B.
+            wh_ratio_clip (float, optional): The allowed ratio between
+                width and height.
+
+        Returns:
+            Union[torch.Tensor, :obj:`BaseBoxes`]: Decoded boxes.
+        """
+        bboxes = get_box_tensor(bboxes)
+        assert pred_bboxes.size(0) == bboxes.size(0)
+        if pred_bboxes.ndim == 3:
+            assert pred_bboxes.size(1) == bboxes.size(1)
+
+        if pred_bboxes.ndim == 2 and not torch.onnx.is_in_onnx_export():
+            # single image decode
+            decoded_bboxes = delta2bbox(bboxes, pred_bboxes, self.means,
+                                        self.stds, max_shape, wh_ratio_clip,
+                                        self.clip_border, self.add_ctr_clamp,
+                                        self.ctr_clamp)
+        else:
+            if pred_bboxes.ndim == 3 and not torch.onnx.is_in_onnx_export():
+                warnings.warn(
+                    'DeprecationWarning: onnx_delta2bbox is deprecated '
+                    'in the case of batch decoding and non-ONNX, '
+                    'please use “delta2bbox” instead. In order to improve '
+                    'the decoding speed, the batch function will no '
+                    'longer be supported. ')
+            decoded_bboxes = onnx_delta2bbox(bboxes, pred_bboxes, self.means,
+                                             self.stds, max_shape,
+                                             wh_ratio_clip, self.clip_border,
+                                             self.add_ctr_clamp,
+                                             self.ctr_clamp)
+
+        if self.use_box_type:
+            assert decoded_bboxes.size(-1) == 4, \
+                ('Cannot warp decoded boxes with box type when decoded boxes'
+                 'have shape of (N, num_classes * 4)')
+            decoded_bboxes = HorizontalBoxes(decoded_bboxes)
+        return decoded_bboxes
+
+
+@TASK_UTILS.register_module()
+class DeltaXYWHBBoxCoderForGLIP(DeltaXYWHBBoxCoder):
+    """This is designed specifically for the GLIP algorithm.
+
+    In order to completely match the official performance, we need to perform
+    special calculations in the encoding and decoding processes, such as
+    additional +1 and -1 calculations. However, this is not a user-friendly
+    design.
+    """
+
+    def encode(self, bboxes: Union[Tensor, BaseBoxes],
+               gt_bboxes: Union[Tensor, BaseBoxes]) -> Tensor:
+        """Get box regression transformation deltas that can be used to
+        transform the ``bboxes`` into the ``gt_bboxes``.
+
+        Args:
+            bboxes (torch.Tensor or :obj:`BaseBoxes`): Source boxes,
+                e.g., object proposals.
+            gt_bboxes (torch.Tensor or :obj:`BaseBoxes`): Target of the
+                transformation, e.g., ground-truth boxes.
+
+        Returns:
+            torch.Tensor: Box transformation deltas
+        """
+        bboxes = get_box_tensor(bboxes)
+        gt_bboxes = get_box_tensor(gt_bboxes)
+        assert bboxes.size(0) == gt_bboxes.size(0)
+        assert bboxes.size(-1) == gt_bboxes.size(-1) == 4
+        encoded_bboxes = bbox2delta(bboxes, gt_bboxes, self.means, self.stds)
+        return encoded_bboxes
+
+    def decode(
+        self,
+        bboxes: Union[Tensor, BaseBoxes],
+        pred_bboxes: Tensor,
+        max_shape: Optional[Union[Sequence[int], Tensor,
+                                  Sequence[Sequence[int]]]] = None,
+        wh_ratio_clip: Optional[float] = 16 / 1000
+    ) -> Union[Tensor, BaseBoxes]:
+        """Apply transformation `pred_bboxes` to `boxes`.
+
+        Args:
+            bboxes (torch.Tensor or :obj:`BaseBoxes`): Basic boxes. Shape
+                (B, N, 4) or (N, 4)
+            pred_bboxes (Tensor): Encoded offsets with respect to each roi.
+               Has shape (B, N, num_classes * 4) or (B, N, 4) or
+               (N, num_classes * 4) or (N, 4). Note N = num_anchors * W * H
+               when rois is a grid of anchors.Offset encoding follows [1]_.
+            max_shape (Sequence[int] or torch.Tensor or Sequence[
+               Sequence[int]],optional): Maximum bounds for boxes, specifies
+               (H, W, C) or (H, W). If bboxes shape is (B, N, 4), then
+               the max_shape should be a Sequence[Sequence[int]]
+               and the length of max_shape should also be B.
+            wh_ratio_clip (float, optional): The allowed ratio between
+                width and height.
+
+        Returns:
+            Union[torch.Tensor, :obj:`BaseBoxes`]: Decoded boxes.
+        """
+        bboxes = get_box_tensor(bboxes)
+        assert pred_bboxes.size(0) == bboxes.size(0)
+        if pred_bboxes.ndim == 3:
+            assert pred_bboxes.size(1) == bboxes.size(1)
+
+        if pred_bboxes.ndim == 2 and not torch.onnx.is_in_onnx_export():
+            # single image decode
+            decoded_bboxes = delta2bbox_glip(bboxes, pred_bboxes, self.means,
+                                             self.stds, max_shape,
+                                             wh_ratio_clip, self.clip_border,
+                                             self.add_ctr_clamp,
+                                             self.ctr_clamp)
+        else:
+            raise NotImplementedError()
+
+        if self.use_box_type:
+            assert decoded_bboxes.size(-1) == 4, \
+                ('Cannot warp decoded boxes with box type when decoded boxes'
+                 'have shape of (N, num_classes * 4)')
+            decoded_bboxes = HorizontalBoxes(decoded_bboxes)
+        return decoded_bboxes
+
+
+def bbox2delta(
+    proposals: Tensor,
+    gt: Tensor,
+    means: Sequence[float] = (0., 0., 0., 0.),
+    stds: Sequence[float] = (1., 1., 1., 1.)
+) -> Tensor:
+    """Compute deltas of proposals w.r.t. gt.
+
+    We usually compute the deltas of x, y, w, h of proposals w.r.t ground
+    truth bboxes to get regression target.
+    This is the inverse function of :func:`delta2bbox`.
+
+    Args:
+        proposals (Tensor): Boxes to be transformed, shape (N, ..., 4)
+        gt (Tensor): Gt bboxes to be used as base, shape (N, ..., 4)
+        means (Sequence[float]): Denormalizing means for delta coordinates
+        stds (Sequence[float]): Denormalizing standard deviation for delta
+            coordinates
+
+    Returns:
+        Tensor: deltas with shape (N, 4), where columns represent dx, dy,
+            dw, dh.
+    """
+    assert proposals.size() == gt.size()
+
+    proposals = proposals.float()
+    gt = gt.float()
+    px = (proposals[..., 0] + proposals[..., 2]) * 0.5
+    py = (proposals[..., 1] + proposals[..., 3]) * 0.5
+    pw = proposals[..., 2] - proposals[..., 0]
+    ph = proposals[..., 3] - proposals[..., 1]
+
+    gx = (gt[..., 0] + gt[..., 2]) * 0.5
+    gy = (gt[..., 1] + gt[..., 3]) * 0.5
+    gw = gt[..., 2] - gt[..., 0]
+    gh = gt[..., 3] - gt[..., 1]
+
+    dx = (gx - px) / pw
+    dy = (gy - py) / ph
+    dw = torch.log(gw / pw)
+    dh = torch.log(gh / ph)
+    deltas = torch.stack([dx, dy, dw, dh], dim=-1)
+
+    means = deltas.new_tensor(means).unsqueeze(0)
+    stds = deltas.new_tensor(stds).unsqueeze(0)
+    deltas = deltas.sub_(means).div_(stds)
+
+    return deltas
+
+
+def delta2bbox(rois: Tensor,
+               deltas: Tensor,
+               means: Sequence[float] = (0., 0., 0., 0.),
+               stds: Sequence[float] = (1., 1., 1., 1.),
+               max_shape: Optional[Union[Sequence[int], Tensor,
+                                         Sequence[Sequence[int]]]] = None,
+               wh_ratio_clip: float = 16 / 1000,
+               clip_border: bool = True,
+               add_ctr_clamp: bool = False,
+               ctr_clamp: int = 32) -> Tensor:
+    """Apply deltas to shift/scale base boxes.
+
+    Typically the rois are anchor or proposed bounding boxes and the deltas are
+    network outputs used to shift/scale those boxes.
+    This is the inverse function of :func:`bbox2delta`.
+
+    Args:
+        rois (Tensor): Boxes to be transformed. Has shape (N, 4).
+        deltas (Tensor): Encoded offsets relative to each roi.
+            Has shape (N, num_classes * 4) or (N, 4). Note
+            N = num_base_anchors * W * H, when rois is a grid of
+            anchors. Offset encoding follows [1]_.
+        means (Sequence[float]): Denormalizing means for delta coordinates.
+            Default (0., 0., 0., 0.).
+        stds (Sequence[float]): Denormalizing standard deviation for delta
+            coordinates. Default (1., 1., 1., 1.).
+        max_shape (tuple[int, int]): Maximum bounds for boxes, specifies
+           (H, W). Default None.
+        wh_ratio_clip (float): Maximum aspect ratio for boxes. Default
+            16 / 1000.
+        clip_border (bool, optional): Whether clip the objects outside the
+            border of the image. Default True.
+        add_ctr_clamp (bool): Whether to add center clamp. When set to True,
+            the center of the prediction bounding box will be clamped to
+            avoid being too far away from the center of the anchor.
+            Only used by YOLOF. Default False.
+        ctr_clamp (int): the maximum pixel shift to clamp. Only used by YOLOF.
+            Default 32.
+
+    Returns:
+        Tensor: Boxes with shape (N, num_classes * 4) or (N, 4), where 4
+           represent tl_x, tl_y, br_x, br_y.
+
+    References:
+        .. [1] https://arxiv.org/abs/1311.2524
+
+    Example:
+        >>> rois = torch.Tensor([[ 0.,  0.,  1.,  1.],
+        >>>                      [ 0.,  0.,  1.,  1.],
+        >>>                      [ 0.,  0.,  1.,  1.],
+        >>>                      [ 5.,  5.,  5.,  5.]])
+        >>> deltas = torch.Tensor([[  0.,   0.,   0.,   0.],
+        >>>                        [  1.,   1.,   1.,   1.],
+        >>>                        [  0.,   0.,   2.,  -1.],
+        >>>                        [ 0.7, -1.9, -0.5,  0.3]])
+        >>> delta2bbox(rois, deltas, max_shape=(32, 32, 3))
+        tensor([[0.0000, 0.0000, 1.0000, 1.0000],
+                [0.1409, 0.1409, 2.8591, 2.8591],
+                [0.0000, 0.3161, 4.1945, 0.6839],
+                [5.0000, 5.0000, 5.0000, 5.0000]])
+    """
+    num_bboxes, num_classes = deltas.size(0), deltas.size(1) // 4
+    if num_bboxes == 0:
+        return deltas
+
+    deltas = deltas.reshape(-1, 4)
+
+    means = deltas.new_tensor(means).view(1, -1)
+    stds = deltas.new_tensor(stds).view(1, -1)
+    denorm_deltas = deltas * stds + means
+
+    dxy = denorm_deltas[:, :2]
+    dwh = denorm_deltas[:, 2:]
+
+    # Compute width/height of each roi
+    rois_ = rois.repeat(1, num_classes).reshape(-1, 4)
+    pxy = ((rois_[:, :2] + rois_[:, 2:]) * 0.5)
+    pwh = (rois_[:, 2:] - rois_[:, :2])
+
+    dxy_wh = pwh * dxy
+
+    max_ratio = np.abs(np.log(wh_ratio_clip))
+    if add_ctr_clamp:
+        dxy_wh = torch.clamp(dxy_wh, max=ctr_clamp, min=-ctr_clamp)
+        dwh = torch.clamp(dwh, max=max_ratio)
+    else:
+        dwh = dwh.clamp(min=-max_ratio, max=max_ratio)
+
+    gxy = pxy + dxy_wh
+    gwh = pwh * dwh.exp()
+    x1y1 = gxy - (gwh * 0.5)
+    x2y2 = gxy + (gwh * 0.5)
+    bboxes = torch.cat([x1y1, x2y2], dim=-1)
+    if clip_border and max_shape is not None:
+        bboxes[..., 0::2].clamp_(min=0, max=max_shape[1])
+        bboxes[..., 1::2].clamp_(min=0, max=max_shape[0])
+    bboxes = bboxes.reshape(num_bboxes, -1)
+    return bboxes
+
+
+def onnx_delta2bbox(rois: Tensor,
+                    deltas: Tensor,
+                    means: Sequence[float] = (0., 0., 0., 0.),
+                    stds: Sequence[float] = (1., 1., 1., 1.),
+                    max_shape: Optional[Union[Sequence[int], Tensor,
+                                              Sequence[Sequence[int]]]] = None,
+                    wh_ratio_clip: float = 16 / 1000,
+                    clip_border: Optional[bool] = True,
+                    add_ctr_clamp: bool = False,
+                    ctr_clamp: int = 32) -> Tensor:
+    """Apply deltas to shift/scale base boxes.
+
+    Typically the rois are anchor or proposed bounding boxes and the deltas are
+    network outputs used to shift/scale those boxes.
+    This is the inverse function of :func:`bbox2delta`.
+
+    Args:
+        rois (Tensor): Boxes to be transformed. Has shape (N, 4) or (B, N, 4)
+        deltas (Tensor): Encoded offsets with respect to each roi.
+            Has shape (B, N, num_classes * 4) or (B, N, 4) or
+            (N, num_classes * 4) or (N, 4). Note N = num_anchors * W * H
+            when rois is a grid of anchors.Offset encoding follows [1]_.
+        means (Sequence[float]): Denormalizing means for delta coordinates.
+            Default (0., 0., 0., 0.).
+        stds (Sequence[float]): Denormalizing standard deviation for delta
+            coordinates. Default (1., 1., 1., 1.).
+        max_shape (Sequence[int] or torch.Tensor or Sequence[
+            Sequence[int]],optional): Maximum bounds for boxes, specifies
+            (H, W, C) or (H, W). If rois shape is (B, N, 4), then
+            the max_shape should be a Sequence[Sequence[int]]
+            and the length of max_shape should also be B. Default None.
+        wh_ratio_clip (float): Maximum aspect ratio for boxes.
+            Default 16 / 1000.
+        clip_border (bool, optional): Whether clip the objects outside the
+            border of the image. Default True.
+        add_ctr_clamp (bool): Whether to add center clamp, when added, the
+            predicted box is clamped is its center is too far away from
+            the original anchor's center. Only used by YOLOF. Default False.
+        ctr_clamp (int): the maximum pixel shift to clamp. Only used by YOLOF.
+            Default 32.
+
+    Returns:
+        Tensor: Boxes with shape (B, N, num_classes * 4) or (B, N, 4) or
+           (N, num_classes * 4) or (N, 4), where 4 represent
+           tl_x, tl_y, br_x, br_y.
+
+    References:
+        .. [1] https://arxiv.org/abs/1311.2524
+
+    Example:
+        >>> rois = torch.Tensor([[ 0.,  0.,  1.,  1.],
+        >>>                      [ 0.,  0.,  1.,  1.],
+        >>>                      [ 0.,  0.,  1.,  1.],
+        >>>                      [ 5.,  5.,  5.,  5.]])
+        >>> deltas = torch.Tensor([[  0.,   0.,   0.,   0.],
+        >>>                        [  1.,   1.,   1.,   1.],
+        >>>                        [  0.,   0.,   2.,  -1.],
+        >>>                        [ 0.7, -1.9, -0.5,  0.3]])
+        >>> delta2bbox(rois, deltas, max_shape=(32, 32, 3))
+        tensor([[0.0000, 0.0000, 1.0000, 1.0000],
+                [0.1409, 0.1409, 2.8591, 2.8591],
+                [0.0000, 0.3161, 4.1945, 0.6839],
+                [5.0000, 5.0000, 5.0000, 5.0000]])
+    """
+    means = deltas.new_tensor(means).view(1,
+                                          -1).repeat(1,
+                                                     deltas.size(-1) // 4)
+    stds = deltas.new_tensor(stds).view(1, -1).repeat(1, deltas.size(-1) // 4)
+    denorm_deltas = deltas * stds + means
+    dx = denorm_deltas[..., 0::4]
+    dy = denorm_deltas[..., 1::4]
+    dw = denorm_deltas[..., 2::4]
+    dh = denorm_deltas[..., 3::4]
+
+    x1, y1 = rois[..., 0], rois[..., 1]
+    x2, y2 = rois[..., 2], rois[..., 3]
+    # Compute center of each roi
+    px = ((x1 + x2) * 0.5).unsqueeze(-1).expand_as(dx)
+    py = ((y1 + y2) * 0.5).unsqueeze(-1).expand_as(dy)
+    # Compute width/height of each roi
+    pw = (x2 - x1).unsqueeze(-1).expand_as(dw)
+    ph = (y2 - y1).unsqueeze(-1).expand_as(dh)
+
+    dx_width = pw * dx
+    dy_height = ph * dy
+
+    max_ratio = np.abs(np.log(wh_ratio_clip))
+    if add_ctr_clamp:
+        dx_width = torch.clamp(dx_width, max=ctr_clamp, min=-ctr_clamp)
+        dy_height = torch.clamp(dy_height, max=ctr_clamp, min=-ctr_clamp)
+        dw = torch.clamp(dw, max=max_ratio)
+        dh = torch.clamp(dh, max=max_ratio)
+    else:
+        dw = dw.clamp(min=-max_ratio, max=max_ratio)
+        dh = dh.clamp(min=-max_ratio, max=max_ratio)
+    # Use exp(network energy) to enlarge/shrink each roi
+    gw = pw * dw.exp()
+    gh = ph * dh.exp()
+    # Use network energy to shift the center of each roi
+    gx = px + dx_width
+    gy = py + dy_height
+    # Convert center-xy/width/height to top-left, bottom-right
+    x1 = gx - gw * 0.5
+    y1 = gy - gh * 0.5
+    x2 = gx + gw * 0.5
+    y2 = gy + gh * 0.5
+
+    bboxes = torch.stack([x1, y1, x2, y2], dim=-1).view(deltas.size())
+
+    if clip_border and max_shape is not None:
+        # clip bboxes with dynamic `min` and `max` for onnx
+        if torch.onnx.is_in_onnx_export():
+            from mmdet.core.export import dynamic_clip_for_onnx
+            x1, y1, x2, y2 = dynamic_clip_for_onnx(x1, y1, x2, y2, max_shape)
+            bboxes = torch.stack([x1, y1, x2, y2], dim=-1).view(deltas.size())
+            return bboxes
+        if not isinstance(max_shape, torch.Tensor):
+            max_shape = x1.new_tensor(max_shape)
+        max_shape = max_shape[..., :2].type_as(x1)
+        if max_shape.ndim == 2:
+            assert bboxes.ndim == 3
+            assert max_shape.size(0) == bboxes.size(0)
+
+        min_xy = x1.new_tensor(0)
+        max_xy = torch.cat(
+            [max_shape] * (deltas.size(-1) // 2),
+            dim=-1).flip(-1).unsqueeze(-2)
+        bboxes = torch.where(bboxes < min_xy, min_xy, bboxes)
+        bboxes = torch.where(bboxes > max_xy, max_xy, bboxes)
+
+    return bboxes
+
+
+def delta2bbox_glip(rois: Tensor,
+                    deltas: Tensor,
+                    means: Sequence[float] = (0., 0., 0., 0.),
+                    stds: Sequence[float] = (1., 1., 1., 1.),
+                    max_shape: Optional[Union[Sequence[int], Tensor,
+                                              Sequence[Sequence[int]]]] = None,
+                    wh_ratio_clip: float = 16 / 1000,
+                    clip_border: bool = True,
+                    add_ctr_clamp: bool = False,
+                    ctr_clamp: int = 32) -> Tensor:
+    """Apply deltas to shift/scale base boxes.
+
+    Typically the rois are anchor or proposed bounding boxes and the deltas are
+    network outputs used to shift/scale those boxes.
+    This is the inverse function of :func:`bbox2delta`.
+
+    Args:
+        rois (Tensor): Boxes to be transformed. Has shape (N, 4).
+        deltas (Tensor): Encoded offsets relative to each roi.
+            Has shape (N, num_classes * 4) or (N, 4). Note
+            N = num_base_anchors * W * H, when rois is a grid of
+            anchors. Offset encoding follows [1]_.
+        means (Sequence[float]): Denormalizing means for delta coordinates.
+            Default (0., 0., 0., 0.).
+        stds (Sequence[float]): Denormalizing standard deviation for delta
+            coordinates. Default (1., 1., 1., 1.).
+        max_shape (tuple[int, int]): Maximum bounds for boxes, specifies
+           (H, W). Default None.
+        wh_ratio_clip (float): Maximum aspect ratio for boxes. Default
+            16 / 1000.
+        clip_border (bool, optional): Whether clip the objects outside the
+            border of the image. Default True.
+        add_ctr_clamp (bool): Whether to add center clamp. When set to True,
+            the center of the prediction bounding box will be clamped to
+            avoid being too far away from the center of the anchor.
+            Only used by YOLOF. Default False.
+        ctr_clamp (int): the maximum pixel shift to clamp. Only used by YOLOF.
+            Default 32.
+
+    Returns:
+        Tensor: Boxes with shape (N, num_classes * 4) or (N, 4), where 4
+           represent tl_x, tl_y, br_x, br_y.
+    """
+    num_bboxes, num_classes = deltas.size(0), deltas.size(1) // 4
+    if num_bboxes == 0:
+        return deltas
+
+    deltas = deltas.reshape(-1, 4)
+
+    means = deltas.new_tensor(means).view(1, -1)
+    stds = deltas.new_tensor(stds).view(1, -1)
+    denorm_deltas = deltas * stds + means
+
+    dxy = denorm_deltas[:, :2]
+    dwh = denorm_deltas[:, 2:]
+
+    # Compute width/height of each roi
+    rois_ = rois.repeat(1, num_classes).reshape(-1, 4)
+    pxy = ((rois_[:, :2] + rois_[:, 2:] - 1) * 0.5)  # note
+    pwh = (rois_[:, 2:] - rois_[:, :2])
+
+    dxy_wh = pwh * dxy
+
+    max_ratio = np.abs(np.log(wh_ratio_clip))
+    if add_ctr_clamp:
+        dxy_wh = torch.clamp(dxy_wh, max=ctr_clamp, min=-ctr_clamp)
+        dwh = torch.clamp(dwh, max=max_ratio)
+    else:
+        dwh = dwh.clamp(min=-max_ratio, max=max_ratio)
+
+    gxy = pxy + dxy_wh
+    gwh = pwh * dwh.exp()
+
+    x1y1 = gxy - (gwh - 1) * 0.5  # Note
+    x2y2 = gxy + (gwh - 1) * 0.5  # Note
+
+    bboxes = torch.cat([x1y1, x2y2], dim=-1)
+
+    if clip_border and max_shape is not None:
+        bboxes[..., 0::2].clamp_(min=0, max=max_shape[1] - 1)  # Note
+        bboxes[..., 1::2].clamp_(min=0, max=max_shape[0] - 1)  # Note
+    bboxes = bboxes.reshape(num_bboxes, -1)
+    return bboxes
diff --git a/mmdetection/mmdet/models/task_modules/coders/distance_point_bbox_coder.py b/mmdetection/mmdet/models/task_modules/coders/distance_point_bbox_coder.py
new file mode 100644
index 00000000..ab26bf4b
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/coders/distance_point_bbox_coder.py
@@ -0,0 +1,85 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Sequence, Union
+
+from torch import Tensor
+
+from mmdet.registry import TASK_UTILS
+from mmdet.structures.bbox import (BaseBoxes, HorizontalBoxes, bbox2distance,
+                                   distance2bbox, get_box_tensor)
+from .base_bbox_coder import BaseBBoxCoder
+
+
+@TASK_UTILS.register_module()
+class DistancePointBBoxCoder(BaseBBoxCoder):
+    """Distance Point BBox coder.
+
+    This coder encodes gt bboxes (x1, y1, x2, y2) into (top, bottom, left,
+    right) and decode it back to the original.
+
+    Args:
+        clip_border (bool, optional): Whether clip the objects outside the
+            border of the image. Defaults to True.
+    """
+
+    def __init__(self, clip_border: Optional[bool] = True, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.clip_border = clip_border
+
+    def encode(self,
+               points: Tensor,
+               gt_bboxes: Union[Tensor, BaseBoxes],
+               max_dis: Optional[float] = None,
+               eps: float = 0.1) -> Tensor:
+        """Encode bounding box to distances.
+
+        Args:
+            points (Tensor): Shape (N, 2), The format is [x, y].
+            gt_bboxes (Tensor or :obj:`BaseBoxes`): Shape (N, 4), The format
+                is "xyxy"
+            max_dis (float): Upper bound of the distance. Default None.
+            eps (float): a small value to ensure target < max_dis, instead <=.
+                Default 0.1.
+
+        Returns:
+            Tensor: Box transformation deltas. The shape is (N, 4).
+        """
+        gt_bboxes = get_box_tensor(gt_bboxes)
+        assert points.size(0) == gt_bboxes.size(0)
+        assert points.size(-1) == 2
+        assert gt_bboxes.size(-1) == 4
+        return bbox2distance(points, gt_bboxes, max_dis, eps)
+
+    def decode(
+        self,
+        points: Tensor,
+        pred_bboxes: Tensor,
+        max_shape: Optional[Union[Sequence[int], Tensor,
+                                  Sequence[Sequence[int]]]] = None
+    ) -> Union[Tensor, BaseBoxes]:
+        """Decode distance prediction to bounding box.
+
+        Args:
+            points (Tensor): Shape (B, N, 2) or (N, 2).
+            pred_bboxes (Tensor): Distance from the given point to 4
+                boundaries (left, top, right, bottom). Shape (B, N, 4)
+                or (N, 4)
+            max_shape (Sequence[int] or torch.Tensor or Sequence[
+                Sequence[int]],optional): Maximum bounds for boxes, specifies
+                (H, W, C) or (H, W). If priors shape is (B, N, 4), then
+                the max_shape should be a Sequence[Sequence[int]],
+                and the length of max_shape should also be B.
+                Default None.
+        Returns:
+            Union[Tensor, :obj:`BaseBoxes`]: Boxes with shape (N, 4) or
+            (B, N, 4)
+        """
+        assert points.size(0) == pred_bboxes.size(0)
+        assert points.size(-1) == 2
+        assert pred_bboxes.size(-1) == 4
+        if self.clip_border is False:
+            max_shape = None
+        bboxes = distance2bbox(points, pred_bboxes, max_shape)
+
+        if self.use_box_type:
+            bboxes = HorizontalBoxes(bboxes)
+        return bboxes
diff --git a/mmdetection/mmdet/models/task_modules/coders/legacy_delta_xywh_bbox_coder.py b/mmdetection/mmdet/models/task_modules/coders/legacy_delta_xywh_bbox_coder.py
new file mode 100644
index 00000000..9eb1bedb
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/coders/legacy_delta_xywh_bbox_coder.py
@@ -0,0 +1,235 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Sequence, Union
+
+import numpy as np
+import torch
+from torch import Tensor
+
+from mmdet.registry import TASK_UTILS
+from mmdet.structures.bbox import BaseBoxes, HorizontalBoxes, get_box_tensor
+from .base_bbox_coder import BaseBBoxCoder
+
+
+@TASK_UTILS.register_module()
+class LegacyDeltaXYWHBBoxCoder(BaseBBoxCoder):
+    """Legacy Delta XYWH BBox coder used in MMDet V1.x.
+
+    Following the practice in R-CNN [1]_, this coder encodes bbox (x1, y1, x2,
+    y2) into delta (dx, dy, dw, dh) and decodes delta (dx, dy, dw, dh)
+    back to original bbox (x1, y1, x2, y2).
+
+    Note:
+        The main difference between :class`LegacyDeltaXYWHBBoxCoder` and
+        :class:`DeltaXYWHBBoxCoder` is whether ``+ 1`` is used during width and
+        height calculation. We suggest to only use this coder when testing with
+        MMDet V1.x models.
+
+    References:
+        .. [1] https://arxiv.org/abs/1311.2524
+
+    Args:
+        target_means (Sequence[float]): denormalizing means of target for
+            delta coordinates
+        target_stds (Sequence[float]): denormalizing standard deviation of
+            target for delta coordinates
+    """
+
+    def __init__(self,
+                 target_means: Sequence[float] = (0., 0., 0., 0.),
+                 target_stds: Sequence[float] = (1., 1., 1., 1.),
+                 **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.means = target_means
+        self.stds = target_stds
+
+    def encode(self, bboxes: Union[Tensor, BaseBoxes],
+               gt_bboxes: Union[Tensor, BaseBoxes]) -> Tensor:
+        """Get box regression transformation deltas that can be used to
+        transform the ``bboxes`` into the ``gt_bboxes``.
+
+        Args:
+            bboxes (torch.Tensor or :obj:`BaseBoxes`): source boxes,
+                e.g., object proposals.
+            gt_bboxes (torch.Tensor or :obj:`BaseBoxes`): target of the
+                transformation, e.g., ground-truth boxes.
+
+        Returns:
+            torch.Tensor: Box transformation deltas
+        """
+        bboxes = get_box_tensor(bboxes)
+        gt_bboxes = get_box_tensor(gt_bboxes)
+        assert bboxes.size(0) == gt_bboxes.size(0)
+        assert bboxes.size(-1) == gt_bboxes.size(-1) == 4
+        encoded_bboxes = legacy_bbox2delta(bboxes, gt_bboxes, self.means,
+                                           self.stds)
+        return encoded_bboxes
+
+    def decode(
+        self,
+        bboxes: Union[Tensor, BaseBoxes],
+        pred_bboxes: Tensor,
+        max_shape: Optional[Union[Sequence[int], Tensor,
+                                  Sequence[Sequence[int]]]] = None,
+        wh_ratio_clip: Optional[float] = 16 / 1000
+    ) -> Union[Tensor, BaseBoxes]:
+        """Apply transformation `pred_bboxes` to `boxes`.
+
+        Args:
+            boxes (torch.Tensor or :obj:`BaseBoxes`): Basic boxes.
+            pred_bboxes (torch.Tensor): Encoded boxes with shape
+            max_shape (tuple[int], optional): Maximum shape of boxes.
+                Defaults to None.
+            wh_ratio_clip (float, optional): The allowed ratio between
+                width and height.
+
+        Returns:
+            Union[torch.Tensor, :obj:`BaseBoxes`]: Decoded boxes.
+        """
+        bboxes = get_box_tensor(bboxes)
+        assert pred_bboxes.size(0) == bboxes.size(0)
+        decoded_bboxes = legacy_delta2bbox(bboxes, pred_bboxes, self.means,
+                                           self.stds, max_shape, wh_ratio_clip)
+
+        if self.use_box_type:
+            assert decoded_bboxes.size(-1) == 4, \
+                ('Cannot warp decoded boxes with box type when decoded boxes'
+                 'have shape of (N, num_classes * 4)')
+            decoded_bboxes = HorizontalBoxes(decoded_bboxes)
+        return decoded_bboxes
+
+
+def legacy_bbox2delta(
+    proposals: Tensor,
+    gt: Tensor,
+    means: Sequence[float] = (0., 0., 0., 0.),
+    stds: Sequence[float] = (1., 1., 1., 1.)
+) -> Tensor:
+    """Compute deltas of proposals w.r.t. gt in the MMDet V1.x manner.
+
+    We usually compute the deltas of x, y, w, h of proposals w.r.t ground
+    truth bboxes to get regression target.
+    This is the inverse function of `delta2bbox()`
+
+    Args:
+        proposals (Tensor): Boxes to be transformed, shape (N, ..., 4)
+        gt (Tensor): Gt bboxes to be used as base, shape (N, ..., 4)
+        means (Sequence[float]): Denormalizing means for delta coordinates
+        stds (Sequence[float]): Denormalizing standard deviation for delta
+            coordinates
+
+    Returns:
+        Tensor: deltas with shape (N, 4), where columns represent dx, dy,
+            dw, dh.
+    """
+    assert proposals.size() == gt.size()
+
+    proposals = proposals.float()
+    gt = gt.float()
+    px = (proposals[..., 0] + proposals[..., 2]) * 0.5
+    py = (proposals[..., 1] + proposals[..., 3]) * 0.5
+    pw = proposals[..., 2] - proposals[..., 0] + 1.0
+    ph = proposals[..., 3] - proposals[..., 1] + 1.0
+
+    gx = (gt[..., 0] + gt[..., 2]) * 0.5
+    gy = (gt[..., 1] + gt[..., 3]) * 0.5
+    gw = gt[..., 2] - gt[..., 0] + 1.0
+    gh = gt[..., 3] - gt[..., 1] + 1.0
+
+    dx = (gx - px) / pw
+    dy = (gy - py) / ph
+    dw = torch.log(gw / pw)
+    dh = torch.log(gh / ph)
+    deltas = torch.stack([dx, dy, dw, dh], dim=-1)
+
+    means = deltas.new_tensor(means).unsqueeze(0)
+    stds = deltas.new_tensor(stds).unsqueeze(0)
+    deltas = deltas.sub_(means).div_(stds)
+
+    return deltas
+
+
+def legacy_delta2bbox(rois: Tensor,
+                      deltas: Tensor,
+                      means: Sequence[float] = (0., 0., 0., 0.),
+                      stds: Sequence[float] = (1., 1., 1., 1.),
+                      max_shape: Optional[
+                          Union[Sequence[int], Tensor,
+                                Sequence[Sequence[int]]]] = None,
+                      wh_ratio_clip: float = 16 / 1000) -> Tensor:
+    """Apply deltas to shift/scale base boxes in the MMDet V1.x manner.
+
+    Typically the rois are anchor or proposed bounding boxes and the deltas are
+    network outputs used to shift/scale those boxes.
+    This is the inverse function of `bbox2delta()`
+
+    Args:
+        rois (Tensor): Boxes to be transformed. Has shape (N, 4)
+        deltas (Tensor): Encoded offsets with respect to each roi.
+            Has shape (N, 4 * num_classes). Note N = num_anchors * W * H when
+            rois is a grid of anchors. Offset encoding follows [1]_.
+        means (Sequence[float]): Denormalizing means for delta coordinates
+        stds (Sequence[float]): Denormalizing standard deviation for delta
+            coordinates
+        max_shape (tuple[int, int]): Maximum bounds for boxes. specifies (H, W)
+        wh_ratio_clip (float): Maximum aspect ratio for boxes.
+
+    Returns:
+        Tensor: Boxes with shape (N, 4), where columns represent
+            tl_x, tl_y, br_x, br_y.
+
+    References:
+        .. [1] https://arxiv.org/abs/1311.2524
+
+    Example:
+        >>> rois = torch.Tensor([[ 0.,  0.,  1.,  1.],
+        >>>                      [ 0.,  0.,  1.,  1.],
+        >>>                      [ 0.,  0.,  1.,  1.],
+        >>>                      [ 5.,  5.,  5.,  5.]])
+        >>> deltas = torch.Tensor([[  0.,   0.,   0.,   0.],
+        >>>                        [  1.,   1.,   1.,   1.],
+        >>>                        [  0.,   0.,   2.,  -1.],
+        >>>                        [ 0.7, -1.9, -0.5,  0.3]])
+        >>> legacy_delta2bbox(rois, deltas, max_shape=(32, 32))
+        tensor([[0.0000, 0.0000, 1.5000, 1.5000],
+                [0.0000, 0.0000, 5.2183, 5.2183],
+                [0.0000, 0.1321, 7.8891, 0.8679],
+                [5.3967, 2.4251, 6.0033, 3.7749]])
+    """
+    means = deltas.new_tensor(means).repeat(1, deltas.size(1) // 4)
+    stds = deltas.new_tensor(stds).repeat(1, deltas.size(1) // 4)
+    denorm_deltas = deltas * stds + means
+    dx = denorm_deltas[:, 0::4]
+    dy = denorm_deltas[:, 1::4]
+    dw = denorm_deltas[:, 2::4]
+    dh = denorm_deltas[:, 3::4]
+    max_ratio = np.abs(np.log(wh_ratio_clip))
+    dw = dw.clamp(min=-max_ratio, max=max_ratio)
+    dh = dh.clamp(min=-max_ratio, max=max_ratio)
+    # Compute center of each roi
+    px = ((rois[:, 0] + rois[:, 2]) * 0.5).unsqueeze(1).expand_as(dx)
+    py = ((rois[:, 1] + rois[:, 3]) * 0.5).unsqueeze(1).expand_as(dy)
+    # Compute width/height of each roi
+    pw = (rois[:, 2] - rois[:, 0] + 1.0).unsqueeze(1).expand_as(dw)
+    ph = (rois[:, 3] - rois[:, 1] + 1.0).unsqueeze(1).expand_as(dh)
+    # Use exp(network energy) to enlarge/shrink each roi
+    gw = pw * dw.exp()
+    gh = ph * dh.exp()
+    # Use network energy to shift the center of each roi
+    gx = px + pw * dx
+    gy = py + ph * dy
+    # Convert center-xy/width/height to top-left, bottom-right
+
+    # The true legacy box coder should +- 0.5 here.
+    # However, current implementation improves the performance when testing
+    # the models trained in MMDetection 1.X (~0.5 bbox AP, 0.2 mask AP)
+    x1 = gx - gw * 0.5
+    y1 = gy - gh * 0.5
+    x2 = gx + gw * 0.5
+    y2 = gy + gh * 0.5
+    if max_shape is not None:
+        x1 = x1.clamp(min=0, max=max_shape[1] - 1)
+        y1 = y1.clamp(min=0, max=max_shape[0] - 1)
+        x2 = x2.clamp(min=0, max=max_shape[1] - 1)
+        y2 = y2.clamp(min=0, max=max_shape[0] - 1)
+    bboxes = torch.stack([x1, y1, x2, y2], dim=-1).view_as(deltas)
+    return bboxes
diff --git a/mmdetection/mmdet/models/task_modules/coders/pseudo_bbox_coder.py b/mmdetection/mmdet/models/task_modules/coders/pseudo_bbox_coder.py
new file mode 100644
index 00000000..9ee74311
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/coders/pseudo_bbox_coder.py
@@ -0,0 +1,29 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Union
+
+from torch import Tensor
+
+from mmdet.registry import TASK_UTILS
+from mmdet.structures.bbox import BaseBoxes, HorizontalBoxes, get_box_tensor
+from .base_bbox_coder import BaseBBoxCoder
+
+
+@TASK_UTILS.register_module()
+class PseudoBBoxCoder(BaseBBoxCoder):
+    """Pseudo bounding box coder."""
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def encode(self, bboxes: Tensor, gt_bboxes: Union[Tensor,
+                                                      BaseBoxes]) -> Tensor:
+        """torch.Tensor: return the given ``bboxes``"""
+        gt_bboxes = get_box_tensor(gt_bboxes)
+        return gt_bboxes
+
+    def decode(self, bboxes: Tensor, pred_bboxes: Union[Tensor,
+                                                        BaseBoxes]) -> Tensor:
+        """torch.Tensor: return the given ``pred_bboxes``"""
+        if self.use_box_type:
+            pred_bboxes = HorizontalBoxes(pred_bboxes)
+        return pred_bboxes
diff --git a/mmdetection/mmdet/models/task_modules/coders/tblr_bbox_coder.py b/mmdetection/mmdet/models/task_modules/coders/tblr_bbox_coder.py
new file mode 100644
index 00000000..74b388f7
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/coders/tblr_bbox_coder.py
@@ -0,0 +1,228 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Sequence, Union
+
+import torch
+from torch import Tensor
+
+from mmdet.registry import TASK_UTILS
+from mmdet.structures.bbox import BaseBoxes, HorizontalBoxes, get_box_tensor
+from .base_bbox_coder import BaseBBoxCoder
+
+
+@TASK_UTILS.register_module()
+class TBLRBBoxCoder(BaseBBoxCoder):
+    """TBLR BBox coder.
+
+    Following the practice in `FSAF `_,
+    this coder encodes gt bboxes (x1, y1, x2, y2) into (top, bottom, left,
+    right) and decode it back to the original.
+
+    Args:
+        normalizer (list | float): Normalization factor to be
+          divided with when coding the coordinates. If it is a list, it should
+          have length of 4 indicating normalization factor in tblr dims.
+          Otherwise it is a unified float factor for all dims. Default: 4.0
+        clip_border (bool, optional): Whether clip the objects outside the
+            border of the image. Defaults to True.
+    """
+
+    def __init__(self,
+                 normalizer: Union[Sequence[float], float] = 4.0,
+                 clip_border: bool = True,
+                 **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.normalizer = normalizer
+        self.clip_border = clip_border
+
+    def encode(self, bboxes: Union[Tensor, BaseBoxes],
+               gt_bboxes: Union[Tensor, BaseBoxes]) -> Tensor:
+        """Get box regression transformation deltas that can be used to
+        transform the ``bboxes`` into the ``gt_bboxes`` in the (top, left,
+        bottom, right) order.
+
+        Args:
+            bboxes (torch.Tensor or :obj:`BaseBoxes`): source boxes,
+                e.g., object proposals.
+            gt_bboxes (torch.Tensor or :obj:`BaseBoxes`): target of the
+                transformation, e.g., ground truth boxes.
+
+        Returns:
+            torch.Tensor: Box transformation deltas
+        """
+        bboxes = get_box_tensor(bboxes)
+        gt_bboxes = get_box_tensor(gt_bboxes)
+        assert bboxes.size(0) == gt_bboxes.size(0)
+        assert bboxes.size(-1) == gt_bboxes.size(-1) == 4
+        encoded_bboxes = bboxes2tblr(
+            bboxes, gt_bboxes, normalizer=self.normalizer)
+        return encoded_bboxes
+
+    def decode(
+        self,
+        bboxes: Union[Tensor, BaseBoxes],
+        pred_bboxes: Tensor,
+        max_shape: Optional[Union[Sequence[int], Tensor,
+                                  Sequence[Sequence[int]]]] = None
+    ) -> Union[Tensor, BaseBoxes]:
+        """Apply transformation `pred_bboxes` to `boxes`.
+
+        Args:
+            bboxes (torch.Tensor or :obj:`BaseBoxes`): Basic boxes.Shape
+                (B, N, 4) or (N, 4)
+            pred_bboxes (torch.Tensor): Encoded boxes with shape
+               (B, N, 4) or (N, 4)
+            max_shape (Sequence[int] or torch.Tensor or Sequence[
+               Sequence[int]],optional): Maximum bounds for boxes, specifies
+               (H, W, C) or (H, W). If bboxes shape is (B, N, 4), then
+               the max_shape should be a Sequence[Sequence[int]]
+               and the length of max_shape should also be B.
+
+        Returns:
+            Union[torch.Tensor, :obj:`BaseBoxes`]: Decoded boxes.
+        """
+        bboxes = get_box_tensor(bboxes)
+        decoded_bboxes = tblr2bboxes(
+            bboxes,
+            pred_bboxes,
+            normalizer=self.normalizer,
+            max_shape=max_shape,
+            clip_border=self.clip_border)
+
+        if self.use_box_type:
+            decoded_bboxes = HorizontalBoxes(decoded_bboxes)
+        return decoded_bboxes
+
+
+def bboxes2tblr(priors: Tensor,
+                gts: Tensor,
+                normalizer: Union[Sequence[float], float] = 4.0,
+                normalize_by_wh: bool = True) -> Tensor:
+    """Encode ground truth boxes to tblr coordinate.
+
+    It first convert the gt coordinate to tblr format,
+     (top, bottom, left, right), relative to prior box centers.
+     The tblr coordinate may be normalized by the side length of prior bboxes
+     if `normalize_by_wh` is specified as True, and it is then normalized by
+     the `normalizer` factor.
+
+    Args:
+        priors (Tensor): Prior boxes in point form
+            Shape: (num_proposals,4).
+        gts (Tensor): Coords of ground truth for each prior in point-form
+            Shape: (num_proposals, 4).
+        normalizer (Sequence[float] | float): normalization parameter of
+            encoded boxes. If it is a list, it has to have length = 4.
+            Default: 4.0
+        normalize_by_wh (bool): Whether to normalize tblr coordinate by the
+            side length (wh) of prior bboxes.
+
+    Return:
+        encoded boxes (Tensor), Shape: (num_proposals, 4)
+    """
+
+    # dist b/t match center and prior's center
+    if not isinstance(normalizer, float):
+        normalizer = torch.tensor(normalizer, device=priors.device)
+        assert len(normalizer) == 4, 'Normalizer must have length = 4'
+    assert priors.size(0) == gts.size(0)
+    prior_centers = (priors[:, 0:2] + priors[:, 2:4]) / 2
+    xmin, ymin, xmax, ymax = gts.split(1, dim=1)
+    top = prior_centers[:, 1].unsqueeze(1) - ymin
+    bottom = ymax - prior_centers[:, 1].unsqueeze(1)
+    left = prior_centers[:, 0].unsqueeze(1) - xmin
+    right = xmax - prior_centers[:, 0].unsqueeze(1)
+    loc = torch.cat((top, bottom, left, right), dim=1)
+    if normalize_by_wh:
+        # Normalize tblr by anchor width and height
+        wh = priors[:, 2:4] - priors[:, 0:2]
+        w, h = torch.split(wh, 1, dim=1)
+        loc[:, :2] /= h  # tb is normalized by h
+        loc[:, 2:] /= w  # lr is normalized by w
+    # Normalize tblr by the given normalization factor
+    return loc / normalizer
+
+
+def tblr2bboxes(priors: Tensor,
+                tblr: Tensor,
+                normalizer: Union[Sequence[float], float] = 4.0,
+                normalize_by_wh: bool = True,
+                max_shape: Optional[Union[Sequence[int], Tensor,
+                                          Sequence[Sequence[int]]]] = None,
+                clip_border: bool = True) -> Tensor:
+    """Decode tblr outputs to prediction boxes.
+
+    The process includes 3 steps: 1) De-normalize tblr coordinates by
+    multiplying it with `normalizer`; 2) De-normalize tblr coordinates by the
+    prior bbox width and height if `normalize_by_wh` is `True`; 3) Convert
+    tblr (top, bottom, left, right) pair relative to the center of priors back
+    to (xmin, ymin, xmax, ymax) coordinate.
+
+    Args:
+        priors (Tensor): Prior boxes in point form (x0, y0, x1, y1)
+          Shape: (N,4) or (B, N, 4).
+        tblr (Tensor): Coords of network output in tblr form
+          Shape: (N, 4) or (B, N, 4).
+        normalizer (Sequence[float] | float): Normalization parameter of
+          encoded boxes. By list, it represents the normalization factors at
+          tblr dims. By float, it is the unified normalization factor at all
+          dims. Default: 4.0
+        normalize_by_wh (bool): Whether the tblr coordinates have been
+          normalized by the side length (wh) of prior bboxes.
+        max_shape (Sequence[int] or torch.Tensor or Sequence[
+            Sequence[int]],optional): Maximum bounds for boxes, specifies
+            (H, W, C) or (H, W). If priors shape is (B, N, 4), then
+            the max_shape should be a Sequence[Sequence[int]]
+            and the length of max_shape should also be B.
+        clip_border (bool, optional): Whether clip the objects outside the
+            border of the image. Defaults to True.
+
+    Return:
+        encoded boxes (Tensor): Boxes with shape (N, 4) or (B, N, 4)
+    """
+    if not isinstance(normalizer, float):
+        normalizer = torch.tensor(normalizer, device=priors.device)
+        assert len(normalizer) == 4, 'Normalizer must have length = 4'
+    assert priors.size(0) == tblr.size(0)
+    if priors.ndim == 3:
+        assert priors.size(1) == tblr.size(1)
+
+    loc_decode = tblr * normalizer
+    prior_centers = (priors[..., 0:2] + priors[..., 2:4]) / 2
+    if normalize_by_wh:
+        wh = priors[..., 2:4] - priors[..., 0:2]
+        w, h = torch.split(wh, 1, dim=-1)
+        # Inplace operation with slice would failed for exporting to ONNX
+        th = h * loc_decode[..., :2]  # tb
+        tw = w * loc_decode[..., 2:]  # lr
+        loc_decode = torch.cat([th, tw], dim=-1)
+    # Cannot be exported using onnx when loc_decode.split(1, dim=-1)
+    top, bottom, left, right = loc_decode.split((1, 1, 1, 1), dim=-1)
+    xmin = prior_centers[..., 0].unsqueeze(-1) - left
+    xmax = prior_centers[..., 0].unsqueeze(-1) + right
+    ymin = prior_centers[..., 1].unsqueeze(-1) - top
+    ymax = prior_centers[..., 1].unsqueeze(-1) + bottom
+
+    bboxes = torch.cat((xmin, ymin, xmax, ymax), dim=-1)
+
+    if clip_border and max_shape is not None:
+        # clip bboxes with dynamic `min` and `max` for onnx
+        if torch.onnx.is_in_onnx_export():
+            from mmdet.core.export import dynamic_clip_for_onnx
+            xmin, ymin, xmax, ymax = dynamic_clip_for_onnx(
+                xmin, ymin, xmax, ymax, max_shape)
+            bboxes = torch.cat([xmin, ymin, xmax, ymax], dim=-1)
+            return bboxes
+        if not isinstance(max_shape, torch.Tensor):
+            max_shape = priors.new_tensor(max_shape)
+        max_shape = max_shape[..., :2].type_as(priors)
+        if max_shape.ndim == 2:
+            assert bboxes.ndim == 3
+            assert max_shape.size(0) == bboxes.size(0)
+
+        min_xy = priors.new_tensor(0)
+        max_xy = torch.cat([max_shape, max_shape],
+                           dim=-1).flip(-1).unsqueeze(-2)
+        bboxes = torch.where(bboxes < min_xy, min_xy, bboxes)
+        bboxes = torch.where(bboxes > max_xy, max_xy, bboxes)
+
+    return bboxes
diff --git a/mmdetection/mmdet/models/task_modules/coders/yolo_bbox_coder.py b/mmdetection/mmdet/models/task_modules/coders/yolo_bbox_coder.py
new file mode 100644
index 00000000..2e1c7667
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/coders/yolo_bbox_coder.py
@@ -0,0 +1,94 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Union
+
+import torch
+from torch import Tensor
+
+from mmdet.registry import TASK_UTILS
+from mmdet.structures.bbox import BaseBoxes, HorizontalBoxes, get_box_tensor
+from .base_bbox_coder import BaseBBoxCoder
+
+
+@TASK_UTILS.register_module()
+class YOLOBBoxCoder(BaseBBoxCoder):
+    """YOLO BBox coder.
+
+    Following `YOLO `_, this coder divide
+    image into grids, and encode bbox (x1, y1, x2, y2) into (cx, cy, dw, dh).
+    cx, cy in [0., 1.], denotes relative center position w.r.t the center of
+    bboxes. dw, dh are the same as :obj:`DeltaXYWHBBoxCoder`.
+
+    Args:
+        eps (float): Min value of cx, cy when encoding.
+    """
+
+    def __init__(self, eps: float = 1e-6, **kwargs):
+        super().__init__(**kwargs)
+        self.eps = eps
+
+    def encode(self, bboxes: Union[Tensor, BaseBoxes],
+               gt_bboxes: Union[Tensor, BaseBoxes],
+               stride: Union[Tensor, int]) -> Tensor:
+        """Get box regression transformation deltas that can be used to
+        transform the ``bboxes`` into the ``gt_bboxes``.
+
+        Args:
+            bboxes (torch.Tensor or :obj:`BaseBoxes`): Source boxes,
+                e.g., anchors.
+            gt_bboxes (torch.Tensor or :obj:`BaseBoxes`): Target of the
+                transformation, e.g., ground-truth boxes.
+            stride (torch.Tensor | int): Stride of bboxes.
+
+        Returns:
+            torch.Tensor: Box transformation deltas
+        """
+        bboxes = get_box_tensor(bboxes)
+        gt_bboxes = get_box_tensor(gt_bboxes)
+        assert bboxes.size(0) == gt_bboxes.size(0)
+        assert bboxes.size(-1) == gt_bboxes.size(-1) == 4
+        x_center_gt = (gt_bboxes[..., 0] + gt_bboxes[..., 2]) * 0.5
+        y_center_gt = (gt_bboxes[..., 1] + gt_bboxes[..., 3]) * 0.5
+        w_gt = gt_bboxes[..., 2] - gt_bboxes[..., 0]
+        h_gt = gt_bboxes[..., 3] - gt_bboxes[..., 1]
+        x_center = (bboxes[..., 0] + bboxes[..., 2]) * 0.5
+        y_center = (bboxes[..., 1] + bboxes[..., 3]) * 0.5
+        w = bboxes[..., 2] - bboxes[..., 0]
+        h = bboxes[..., 3] - bboxes[..., 1]
+        w_target = torch.log((w_gt / w).clamp(min=self.eps))
+        h_target = torch.log((h_gt / h).clamp(min=self.eps))
+        x_center_target = ((x_center_gt - x_center) / stride + 0.5).clamp(
+            self.eps, 1 - self.eps)
+        y_center_target = ((y_center_gt - y_center) / stride + 0.5).clamp(
+            self.eps, 1 - self.eps)
+        encoded_bboxes = torch.stack(
+            [x_center_target, y_center_target, w_target, h_target], dim=-1)
+        return encoded_bboxes
+
+    def decode(self, bboxes: Union[Tensor, BaseBoxes], pred_bboxes: Tensor,
+               stride: Union[Tensor, int]) -> Union[Tensor, BaseBoxes]:
+        """Apply transformation `pred_bboxes` to `boxes`.
+
+        Args:
+            boxes (torch.Tensor or :obj:`BaseBoxes`): Basic boxes,
+                e.g. anchors.
+            pred_bboxes (torch.Tensor): Encoded boxes with shape
+            stride (torch.Tensor | int): Strides of bboxes.
+
+        Returns:
+            Union[torch.Tensor, :obj:`BaseBoxes`]: Decoded boxes.
+        """
+        bboxes = get_box_tensor(bboxes)
+        assert pred_bboxes.size(-1) == bboxes.size(-1) == 4
+        xy_centers = (bboxes[..., :2] + bboxes[..., 2:]) * 0.5 + (
+            pred_bboxes[..., :2] - 0.5) * stride
+        whs = (bboxes[..., 2:] -
+               bboxes[..., :2]) * 0.5 * pred_bboxes[..., 2:].exp()
+        decoded_bboxes = torch.stack(
+            (xy_centers[..., 0] - whs[..., 0], xy_centers[..., 1] -
+             whs[..., 1], xy_centers[..., 0] + whs[..., 0],
+             xy_centers[..., 1] + whs[..., 1]),
+            dim=-1)
+
+        if self.use_box_type:
+            decoded_bboxes = HorizontalBoxes(decoded_bboxes)
+        return decoded_bboxes
diff --git a/mmdetection/mmdet/models/task_modules/prior_generators/__init__.py b/mmdetection/mmdet/models/task_modules/prior_generators/__init__.py
new file mode 100644
index 00000000..7795e98c
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/prior_generators/__init__.py
@@ -0,0 +1,11 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .anchor_generator import (AnchorGenerator, LegacyAnchorGenerator,
+                               SSDAnchorGenerator, YOLOAnchorGenerator)
+from .point_generator import MlvlPointGenerator, PointGenerator
+from .utils import anchor_inside_flags, calc_region
+
+__all__ = [
+    'AnchorGenerator', 'LegacyAnchorGenerator', 'anchor_inside_flags',
+    'PointGenerator', 'calc_region', 'YOLOAnchorGenerator',
+    'MlvlPointGenerator', 'SSDAnchorGenerator'
+]
diff --git a/mmdetection/mmdet/models/task_modules/prior_generators/anchor_generator.py b/mmdetection/mmdet/models/task_modules/prior_generators/anchor_generator.py
new file mode 100644
index 00000000..2757697c
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/prior_generators/anchor_generator.py
@@ -0,0 +1,848 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+from typing import List, Optional, Tuple, Union
+
+import numpy as np
+import torch
+from mmengine.utils import is_tuple_of
+from torch import Tensor
+from torch.nn.modules.utils import _pair
+
+from mmdet.registry import TASK_UTILS
+from mmdet.structures.bbox import HorizontalBoxes
+
+DeviceType = Union[str, torch.device]
+
+
+@TASK_UTILS.register_module()
+class AnchorGenerator:
+    """Standard anchor generator for 2D anchor-based detectors.
+
+    Args:
+        strides (list[int] | list[tuple[int, int]]): Strides of anchors
+            in multiple feature levels in order (w, h).
+        ratios (list[float]): The list of ratios between the height and width
+            of anchors in a single level.
+        scales (list[int], Optional): Anchor scales for anchors
+            in a single level. It cannot be set at the same time
+            if `octave_base_scale` and `scales_per_octave` are set.
+        base_sizes (list[int], Optional): The basic sizes
+            of anchors in multiple levels.
+            If None is given, strides will be used as base_sizes.
+            (If strides are non square, the shortest stride is taken.)
+        scale_major (bool): Whether to multiply scales first when generating
+            base anchors. If true, the anchors in the same row will have the
+            same scales. By default it is True in V2.0
+        octave_base_scale (int, Optional): The base scale of octave.
+        scales_per_octave (int, Optional): Number of scales for each octave.
+            `octave_base_scale` and `scales_per_octave` are usually used in
+            retinanet and the `scales` should be None when they are set.
+        centers (list[tuple[float]], Optional): The centers of the anchor
+            relative to the feature grid center in multiple feature levels.
+            By default it is set to be None and not used. If a list of tuple of
+            float is given, they will be used to shift the centers of anchors.
+        center_offset (float): The offset of center in proportion to anchors'
+            width and height. By default it is 0 in V2.0.
+        use_box_type (bool): Whether to warp anchors with the box type data
+            structure. Defaults to False.
+
+    Examples:
+        >>> from mmdet.models.task_modules.
+        ... prior_generators import AnchorGenerator
+        >>> self = AnchorGenerator([16], [1.], [1.], [9])
+        >>> all_anchors = self.grid_priors([(2, 2)], device='cpu')
+        >>> print(all_anchors)
+        [tensor([[-4.5000, -4.5000,  4.5000,  4.5000],
+                [11.5000, -4.5000, 20.5000,  4.5000],
+                [-4.5000, 11.5000,  4.5000, 20.5000],
+                [11.5000, 11.5000, 20.5000, 20.5000]])]
+        >>> self = AnchorGenerator([16, 32], [1.], [1.], [9, 18])
+        >>> all_anchors = self.grid_priors([(2, 2), (1, 1)], device='cpu')
+        >>> print(all_anchors)
+        [tensor([[-4.5000, -4.5000,  4.5000,  4.5000],
+                [11.5000, -4.5000, 20.5000,  4.5000],
+                [-4.5000, 11.5000,  4.5000, 20.5000],
+                [11.5000, 11.5000, 20.5000, 20.5000]]), \
+        tensor([[-9., -9., 9., 9.]])]
+    """
+
+    def __init__(self,
+                 strides: Union[List[int], List[Tuple[int, int]]],
+                 ratios: List[float],
+                 scales: Optional[List[int]] = None,
+                 base_sizes: Optional[List[int]] = None,
+                 scale_major: bool = True,
+                 octave_base_scale: Optional[int] = None,
+                 scales_per_octave: Optional[int] = None,
+                 centers: Optional[List[Tuple[float, float]]] = None,
+                 center_offset: float = 0.,
+                 use_box_type: bool = False) -> None:
+        # check center and center_offset
+        if center_offset != 0:
+            assert centers is None, 'center cannot be set when center_offset' \
+                                    f'!=0, {centers} is given.'
+        if not (0 <= center_offset <= 1):
+            raise ValueError('center_offset should be in range [0, 1], '
+                             f'{center_offset} is given.')
+        if centers is not None:
+            assert len(centers) == len(strides), \
+                'The number of strides should be the same as centers, got ' \
+                f'{strides} and {centers}'
+
+        # calculate base sizes of anchors
+        self.strides = [_pair(stride) for stride in strides]
+        self.base_sizes = [min(stride) for stride in self.strides
+                           ] if base_sizes is None else base_sizes
+        assert len(self.base_sizes) == len(self.strides), \
+            'The number of strides should be the same as base sizes, got ' \
+            f'{self.strides} and {self.base_sizes}'
+
+        # calculate scales of anchors
+        assert ((octave_base_scale is not None
+                 and scales_per_octave is not None) ^ (scales is not None)), \
+            'scales and octave_base_scale with scales_per_octave cannot' \
+            ' be set at the same time'
+        if scales is not None:
+            self.scales = torch.Tensor(scales)
+        elif octave_base_scale is not None and scales_per_octave is not None:
+            octave_scales = np.array(
+                [2**(i / scales_per_octave) for i in range(scales_per_octave)])
+            scales = octave_scales * octave_base_scale
+            self.scales = torch.Tensor(scales)
+        else:
+            raise ValueError('Either scales or octave_base_scale with '
+                             'scales_per_octave should be set')
+
+        self.octave_base_scale = octave_base_scale
+        self.scales_per_octave = scales_per_octave
+        self.ratios = torch.Tensor(ratios)
+        self.scale_major = scale_major
+        self.centers = centers
+        self.center_offset = center_offset
+        self.base_anchors = self.gen_base_anchors()
+        self.use_box_type = use_box_type
+
+    @property
+    def num_base_anchors(self) -> List[int]:
+        """list[int]: total number of base anchors in a feature grid"""
+        return self.num_base_priors
+
+    @property
+    def num_base_priors(self) -> List[int]:
+        """list[int]: The number of priors (anchors) at a point
+        on the feature grid"""
+        return [base_anchors.size(0) for base_anchors in self.base_anchors]
+
+    @property
+    def num_levels(self) -> int:
+        """int: number of feature levels that the generator will be applied"""
+        return len(self.strides)
+
+    def gen_base_anchors(self) -> List[Tensor]:
+        """Generate base anchors.
+
+        Returns:
+            list(torch.Tensor): Base anchors of a feature grid in multiple \
+                feature levels.
+        """
+        multi_level_base_anchors = []
+        for i, base_size in enumerate(self.base_sizes):
+            center = None
+            if self.centers is not None:
+                center = self.centers[i]
+            multi_level_base_anchors.append(
+                self.gen_single_level_base_anchors(
+                    base_size,
+                    scales=self.scales,
+                    ratios=self.ratios,
+                    center=center))
+        return multi_level_base_anchors
+
+    def gen_single_level_base_anchors(self,
+                                      base_size: Union[int, float],
+                                      scales: Tensor,
+                                      ratios: Tensor,
+                                      center: Optional[Tuple[float]] = None) \
+            -> Tensor:
+        """Generate base anchors of a single level.
+
+        Args:
+            base_size (int | float): Basic size of an anchor.
+            scales (torch.Tensor): Scales of the anchor.
+            ratios (torch.Tensor): The ratio between the height
+                and width of anchors in a single level.
+            center (tuple[float], optional): The center of the base anchor
+                related to a single feature grid. Defaults to None.
+
+        Returns:
+            torch.Tensor: Anchors in a single-level feature maps.
+        """
+        w = base_size
+        h = base_size
+        if center is None:
+            x_center = self.center_offset * w
+            y_center = self.center_offset * h
+        else:
+            x_center, y_center = center
+
+        h_ratios = torch.sqrt(ratios)
+        w_ratios = 1 / h_ratios
+        if self.scale_major:
+            ws = (w * w_ratios[:, None] * scales[None, :]).view(-1)
+            hs = (h * h_ratios[:, None] * scales[None, :]).view(-1)
+        else:
+            ws = (w * scales[:, None] * w_ratios[None, :]).view(-1)
+            hs = (h * scales[:, None] * h_ratios[None, :]).view(-1)
+
+        # use float anchor and the anchor's center is aligned with the
+        # pixel center
+        base_anchors = [
+            x_center - 0.5 * ws, y_center - 0.5 * hs, x_center + 0.5 * ws,
+            y_center + 0.5 * hs
+        ]
+        base_anchors = torch.stack(base_anchors, dim=-1)
+
+        return base_anchors
+
+    def _meshgrid(self,
+                  x: Tensor,
+                  y: Tensor,
+                  row_major: bool = True) -> Tuple[Tensor]:
+        """Generate mesh grid of x and y.
+
+        Args:
+            x (torch.Tensor): Grids of x dimension.
+            y (torch.Tensor): Grids of y dimension.
+            row_major (bool): Whether to return y grids first.
+                Defaults to True.
+
+        Returns:
+            tuple[torch.Tensor]: The mesh grids of x and y.
+        """
+        # use shape instead of len to keep tracing while exporting to onnx
+        xx = x.repeat(y.shape[0])
+        yy = y.view(-1, 1).repeat(1, x.shape[0]).view(-1)
+        if row_major:
+            return xx, yy
+        else:
+            return yy, xx
+
+    def grid_priors(self,
+                    featmap_sizes: List[Tuple],
+                    dtype: torch.dtype = torch.float32,
+                    device: DeviceType = 'cuda') -> List[Tensor]:
+        """Generate grid anchors in multiple feature levels.
+
+        Args:
+            featmap_sizes (list[tuple]): List of feature map sizes in
+                multiple feature levels.
+            dtype (:obj:`torch.dtype`): Dtype of priors.
+                Defaults to torch.float32.
+            device (str | torch.device): The device where the anchors
+                will be put on.
+
+        Return:
+            list[torch.Tensor]: Anchors in multiple feature levels. \
+                The sizes of each tensor should be [N, 4], where \
+                N = width * height * num_base_anchors, width and height \
+                are the sizes of the corresponding feature level, \
+                num_base_anchors is the number of anchors for that level.
+        """
+        assert self.num_levels == len(featmap_sizes)
+        multi_level_anchors = []
+        for i in range(self.num_levels):
+            anchors = self.single_level_grid_priors(
+                featmap_sizes[i], level_idx=i, dtype=dtype, device=device)
+            multi_level_anchors.append(anchors)
+        return multi_level_anchors
+
+    def single_level_grid_priors(self,
+                                 featmap_size: Tuple[int, int],
+                                 level_idx: int,
+                                 dtype: torch.dtype = torch.float32,
+                                 device: DeviceType = 'cuda') -> Tensor:
+        """Generate grid anchors of a single level.
+
+        Note:
+            This function is usually called by method ``self.grid_priors``.
+
+        Args:
+            featmap_size (tuple[int, int]): Size of the feature maps.
+            level_idx (int): The index of corresponding feature map level.
+            dtype (obj:`torch.dtype`): Date type of points.Defaults to
+                ``torch.float32``.
+            device (str | torch.device): The device the tensor will be put on.
+                Defaults to 'cuda'.
+
+        Returns:
+            torch.Tensor: Anchors in the overall feature maps.
+        """
+
+        base_anchors = self.base_anchors[level_idx].to(device).to(dtype)
+        feat_h, feat_w = featmap_size
+        stride_w, stride_h = self.strides[level_idx]
+        # First create Range with the default dtype, than convert to
+        # target `dtype` for onnx exporting.
+        shift_x = torch.arange(0, feat_w, device=device).to(dtype) * stride_w
+        shift_y = torch.arange(0, feat_h, device=device).to(dtype) * stride_h
+
+        shift_xx, shift_yy = self._meshgrid(shift_x, shift_y)
+        shifts = torch.stack([shift_xx, shift_yy, shift_xx, shift_yy], dim=-1)
+        # first feat_w elements correspond to the first row of shifts
+        # add A anchors (1, A, 4) to K shifts (K, 1, 4) to get
+        # shifted anchors (K, A, 4), reshape to (K*A, 4)
+
+        all_anchors = base_anchors[None, :, :] + shifts[:, None, :]
+        all_anchors = all_anchors.view(-1, 4)
+        # first A rows correspond to A anchors of (0, 0) in feature map,
+        # then (0, 1), (0, 2), ...
+        if self.use_box_type:
+            all_anchors = HorizontalBoxes(all_anchors)
+        return all_anchors
+
+    def sparse_priors(self,
+                      prior_idxs: Tensor,
+                      featmap_size: Tuple[int, int],
+                      level_idx: int,
+                      dtype: torch.dtype = torch.float32,
+                      device: DeviceType = 'cuda') -> Tensor:
+        """Generate sparse anchors according to the ``prior_idxs``.
+
+        Args:
+            prior_idxs (Tensor): The index of corresponding anchors
+                in the feature map.
+            featmap_size (tuple[int, int]): feature map size arrange as (h, w).
+            level_idx (int): The level index of corresponding feature
+                map.
+            dtype (obj:`torch.dtype`): Date type of points.Defaults to
+                ``torch.float32``.
+            device (str | torch.device): The device where the points is
+                located.
+        Returns:
+            Tensor: Anchor with shape (N, 4), N should be equal to
+                the length of ``prior_idxs``.
+        """
+
+        height, width = featmap_size
+        num_base_anchors = self.num_base_anchors[level_idx]
+        base_anchor_id = prior_idxs % num_base_anchors
+        x = (prior_idxs //
+             num_base_anchors) % width * self.strides[level_idx][0]
+        y = (prior_idxs // width //
+             num_base_anchors) % height * self.strides[level_idx][1]
+        priors = torch.stack([x, y, x, y], 1).to(dtype).to(device) + \
+            self.base_anchors[level_idx][base_anchor_id, :].to(device)
+
+        return priors
+
+    def grid_anchors(self,
+                     featmap_sizes: List[Tuple],
+                     device: DeviceType = 'cuda') -> List[Tensor]:
+        """Generate grid anchors in multiple feature levels.
+
+        Args:
+            featmap_sizes (list[tuple]): List of feature map sizes in
+                multiple feature levels.
+            device (str | torch.device): Device where the anchors will be
+                put on.
+
+        Return:
+            list[torch.Tensor]: Anchors in multiple feature levels. \
+                The sizes of each tensor should be [N, 4], where \
+                N = width * height * num_base_anchors, width and height \
+                are the sizes of the corresponding feature level, \
+                num_base_anchors is the number of anchors for that level.
+        """
+        warnings.warn('``grid_anchors`` would be deprecated soon. '
+                      'Please use ``grid_priors`` ')
+
+        assert self.num_levels == len(featmap_sizes)
+        multi_level_anchors = []
+        for i in range(self.num_levels):
+            anchors = self.single_level_grid_anchors(
+                self.base_anchors[i].to(device),
+                featmap_sizes[i],
+                self.strides[i],
+                device=device)
+            multi_level_anchors.append(anchors)
+        return multi_level_anchors
+
+    def single_level_grid_anchors(self,
+                                  base_anchors: Tensor,
+                                  featmap_size: Tuple[int, int],
+                                  stride: Tuple[int, int] = (16, 16),
+                                  device: DeviceType = 'cuda') -> Tensor:
+        """Generate grid anchors of a single level.
+
+        Note:
+            This function is usually called by method ``self.grid_anchors``.
+
+        Args:
+            base_anchors (torch.Tensor): The base anchors of a feature grid.
+            featmap_size (tuple[int]): Size of the feature maps.
+            stride (tuple[int, int]): Stride of the feature map in order
+                (w, h). Defaults to (16, 16).
+            device (str | torch.device): Device the tensor will be put on.
+                Defaults to 'cuda'.
+
+        Returns:
+            torch.Tensor: Anchors in the overall feature maps.
+        """
+
+        warnings.warn(
+            '``single_level_grid_anchors`` would be deprecated soon. '
+            'Please use ``single_level_grid_priors`` ')
+
+        # keep featmap_size as Tensor instead of int, so that we
+        # can convert to ONNX correctly
+        feat_h, feat_w = featmap_size
+        shift_x = torch.arange(0, feat_w, device=device) * stride[0]
+        shift_y = torch.arange(0, feat_h, device=device) * stride[1]
+
+        shift_xx, shift_yy = self._meshgrid(shift_x, shift_y)
+        shifts = torch.stack([shift_xx, shift_yy, shift_xx, shift_yy], dim=-1)
+        shifts = shifts.type_as(base_anchors)
+        # first feat_w elements correspond to the first row of shifts
+        # add A anchors (1, A, 4) to K shifts (K, 1, 4) to get
+        # shifted anchors (K, A, 4), reshape to (K*A, 4)
+
+        all_anchors = base_anchors[None, :, :] + shifts[:, None, :]
+        all_anchors = all_anchors.view(-1, 4)
+        # first A rows correspond to A anchors of (0, 0) in feature map,
+        # then (0, 1), (0, 2), ...
+        return all_anchors
+
+    def valid_flags(self,
+                    featmap_sizes: List[Tuple[int, int]],
+                    pad_shape: Tuple,
+                    device: DeviceType = 'cuda') -> List[Tensor]:
+        """Generate valid flags of anchors in multiple feature levels.
+
+        Args:
+            featmap_sizes (list(tuple[int, int])): List of feature map sizes in
+                multiple feature levels.
+            pad_shape (tuple): The padded shape of the image.
+            device (str | torch.device): Device where the anchors will be
+                put on.
+
+        Return:
+            list(torch.Tensor): Valid flags of anchors in multiple levels.
+        """
+        assert self.num_levels == len(featmap_sizes)
+        multi_level_flags = []
+        for i in range(self.num_levels):
+            anchor_stride = self.strides[i]
+            feat_h, feat_w = featmap_sizes[i]
+            h, w = pad_shape[:2]
+            valid_feat_h = min(int(np.ceil(h / anchor_stride[1])), feat_h)
+            valid_feat_w = min(int(np.ceil(w / anchor_stride[0])), feat_w)
+            flags = self.single_level_valid_flags((feat_h, feat_w),
+                                                  (valid_feat_h, valid_feat_w),
+                                                  self.num_base_anchors[i],
+                                                  device=device)
+            multi_level_flags.append(flags)
+        return multi_level_flags
+
+    def single_level_valid_flags(self,
+                                 featmap_size: Tuple[int, int],
+                                 valid_size: Tuple[int, int],
+                                 num_base_anchors: int,
+                                 device: DeviceType = 'cuda') -> Tensor:
+        """Generate the valid flags of anchor in a single feature map.
+
+        Args:
+            featmap_size (tuple[int]): The size of feature maps, arrange
+                as (h, w).
+            valid_size (tuple[int]): The valid size of the feature maps.
+            num_base_anchors (int): The number of base anchors.
+            device (str | torch.device): Device where the flags will be put on.
+                Defaults to 'cuda'.
+
+        Returns:
+            torch.Tensor: The valid flags of each anchor in a single level \
+                feature map.
+        """
+        feat_h, feat_w = featmap_size
+        valid_h, valid_w = valid_size
+        assert valid_h <= feat_h and valid_w <= feat_w
+        valid_x = torch.zeros(feat_w, dtype=torch.bool, device=device)
+        valid_y = torch.zeros(feat_h, dtype=torch.bool, device=device)
+        valid_x[:valid_w] = 1
+        valid_y[:valid_h] = 1
+        valid_xx, valid_yy = self._meshgrid(valid_x, valid_y)
+        valid = valid_xx & valid_yy
+        valid = valid[:, None].expand(valid.size(0),
+                                      num_base_anchors).contiguous().view(-1)
+        return valid
+
+    def __repr__(self) -> str:
+        """str: a string that describes the module"""
+        indent_str = '    '
+        repr_str = self.__class__.__name__ + '(\n'
+        repr_str += f'{indent_str}strides={self.strides},\n'
+        repr_str += f'{indent_str}ratios={self.ratios},\n'
+        repr_str += f'{indent_str}scales={self.scales},\n'
+        repr_str += f'{indent_str}base_sizes={self.base_sizes},\n'
+        repr_str += f'{indent_str}scale_major={self.scale_major},\n'
+        repr_str += f'{indent_str}octave_base_scale='
+        repr_str += f'{self.octave_base_scale},\n'
+        repr_str += f'{indent_str}scales_per_octave='
+        repr_str += f'{self.scales_per_octave},\n'
+        repr_str += f'{indent_str}num_levels={self.num_levels}\n'
+        repr_str += f'{indent_str}centers={self.centers},\n'
+        repr_str += f'{indent_str}center_offset={self.center_offset})'
+        return repr_str
+
+
+@TASK_UTILS.register_module()
+class SSDAnchorGenerator(AnchorGenerator):
+    """Anchor generator for SSD.
+
+    Args:
+        strides (list[int]  | list[tuple[int, int]]): Strides of anchors
+            in multiple feature levels.
+        ratios (list[float]): The list of ratios between the height and width
+            of anchors in a single level.
+        min_sizes (list[float]): The list of minimum anchor sizes on each
+            level.
+        max_sizes (list[float]): The list of maximum anchor sizes on each
+            level.
+        basesize_ratio_range (tuple(float)): Ratio range of anchors. Being
+            used when not setting min_sizes and max_sizes.
+        input_size (int): Size of feature map, 300 for SSD300, 512 for
+            SSD512. Being used when not setting min_sizes and max_sizes.
+        scale_major (bool): Whether to multiply scales first when generating
+            base anchors. If true, the anchors in the same row will have the
+            same scales. It is always set to be False in SSD.
+        use_box_type (bool): Whether to warp anchors with the box type data
+            structure. Defaults to False.
+    """
+
+    def __init__(self,
+                 strides: Union[List[int], List[Tuple[int, int]]],
+                 ratios: List[float],
+                 min_sizes: Optional[List[float]] = None,
+                 max_sizes: Optional[List[float]] = None,
+                 basesize_ratio_range: Tuple[float] = (0.15, 0.9),
+                 input_size: int = 300,
+                 scale_major: bool = True,
+                 use_box_type: bool = False) -> None:
+        assert len(strides) == len(ratios)
+        assert not (min_sizes is None) ^ (max_sizes is None)
+        self.strides = [_pair(stride) for stride in strides]
+        self.centers = [(stride[0] / 2., stride[1] / 2.)
+                        for stride in self.strides]
+
+        if min_sizes is None and max_sizes is None:
+            # use hard code to generate SSD anchors
+            self.input_size = input_size
+            assert is_tuple_of(basesize_ratio_range, float)
+            self.basesize_ratio_range = basesize_ratio_range
+            # calculate anchor ratios and sizes
+            min_ratio, max_ratio = basesize_ratio_range
+            min_ratio = int(min_ratio * 100)
+            max_ratio = int(max_ratio * 100)
+            step = int(np.floor(max_ratio - min_ratio) / (self.num_levels - 2))
+            min_sizes = []
+            max_sizes = []
+            for ratio in range(int(min_ratio), int(max_ratio) + 1, step):
+                min_sizes.append(int(self.input_size * ratio / 100))
+                max_sizes.append(int(self.input_size * (ratio + step) / 100))
+            if self.input_size == 300:
+                if basesize_ratio_range[0] == 0.15:  # SSD300 COCO
+                    min_sizes.insert(0, int(self.input_size * 7 / 100))
+                    max_sizes.insert(0, int(self.input_size * 15 / 100))
+                elif basesize_ratio_range[0] == 0.2:  # SSD300 VOC
+                    min_sizes.insert(0, int(self.input_size * 10 / 100))
+                    max_sizes.insert(0, int(self.input_size * 20 / 100))
+                else:
+                    raise ValueError(
+                        'basesize_ratio_range[0] should be either 0.15'
+                        'or 0.2 when input_size is 300, got '
+                        f'{basesize_ratio_range[0]}.')
+            elif self.input_size == 512:
+                if basesize_ratio_range[0] == 0.1:  # SSD512 COCO
+                    min_sizes.insert(0, int(self.input_size * 4 / 100))
+                    max_sizes.insert(0, int(self.input_size * 10 / 100))
+                elif basesize_ratio_range[0] == 0.15:  # SSD512 VOC
+                    min_sizes.insert(0, int(self.input_size * 7 / 100))
+                    max_sizes.insert(0, int(self.input_size * 15 / 100))
+                else:
+                    raise ValueError(
+                        'When not setting min_sizes and max_sizes,'
+                        'basesize_ratio_range[0] should be either 0.1'
+                        'or 0.15 when input_size is 512, got'
+                        f' {basesize_ratio_range[0]}.')
+            else:
+                raise ValueError(
+                    'Only support 300 or 512 in SSDAnchorGenerator when '
+                    'not setting min_sizes and max_sizes, '
+                    f'got {self.input_size}.')
+
+        assert len(min_sizes) == len(max_sizes) == len(strides)
+
+        anchor_ratios = []
+        anchor_scales = []
+        for k in range(len(self.strides)):
+            scales = [1., np.sqrt(max_sizes[k] / min_sizes[k])]
+            anchor_ratio = [1.]
+            for r in ratios[k]:
+                anchor_ratio += [1 / r, r]  # 4 or 6 ratio
+            anchor_ratios.append(torch.Tensor(anchor_ratio))
+            anchor_scales.append(torch.Tensor(scales))
+
+        self.base_sizes = min_sizes
+        self.scales = anchor_scales
+        self.ratios = anchor_ratios
+        self.scale_major = scale_major
+        self.center_offset = 0
+        self.base_anchors = self.gen_base_anchors()
+        self.use_box_type = use_box_type
+
+    def gen_base_anchors(self) -> List[Tensor]:
+        """Generate base anchors.
+
+        Returns:
+            list(torch.Tensor): Base anchors of a feature grid in multiple \
+                feature levels.
+        """
+        multi_level_base_anchors = []
+        for i, base_size in enumerate(self.base_sizes):
+            base_anchors = self.gen_single_level_base_anchors(
+                base_size,
+                scales=self.scales[i],
+                ratios=self.ratios[i],
+                center=self.centers[i])
+            indices = list(range(len(self.ratios[i])))
+            indices.insert(1, len(indices))
+            base_anchors = torch.index_select(base_anchors, 0,
+                                              torch.LongTensor(indices))
+            multi_level_base_anchors.append(base_anchors)
+        return multi_level_base_anchors
+
+    def __repr__(self) -> str:
+        """str: a string that describes the module"""
+        indent_str = '    '
+        repr_str = self.__class__.__name__ + '(\n'
+        repr_str += f'{indent_str}strides={self.strides},\n'
+        repr_str += f'{indent_str}scales={self.scales},\n'
+        repr_str += f'{indent_str}scale_major={self.scale_major},\n'
+        repr_str += f'{indent_str}input_size={self.input_size},\n'
+        repr_str += f'{indent_str}scales={self.scales},\n'
+        repr_str += f'{indent_str}ratios={self.ratios},\n'
+        repr_str += f'{indent_str}num_levels={self.num_levels},\n'
+        repr_str += f'{indent_str}base_sizes={self.base_sizes},\n'
+        repr_str += f'{indent_str}basesize_ratio_range='
+        repr_str += f'{self.basesize_ratio_range})'
+        return repr_str
+
+
+@TASK_UTILS.register_module()
+class LegacyAnchorGenerator(AnchorGenerator):
+    """Legacy anchor generator used in MMDetection V1.x.
+
+    Note:
+        Difference to the V2.0 anchor generator:
+
+        1. The center offset of V1.x anchors are set to be 0.5 rather than 0.
+        2. The width/height are minused by 1 when calculating the anchors' \
+            centers and corners to meet the V1.x coordinate system.
+        3. The anchors' corners are quantized.
+
+    Args:
+        strides (list[int] | list[tuple[int]]): Strides of anchors
+            in multiple feature levels.
+        ratios (list[float]): The list of ratios between the height and width
+            of anchors in a single level.
+        scales (list[int] | None): Anchor scales for anchors in a single level.
+            It cannot be set at the same time if `octave_base_scale` and
+            `scales_per_octave` are set.
+        base_sizes (list[int]): The basic sizes of anchors in multiple levels.
+            If None is given, strides will be used to generate base_sizes.
+        scale_major (bool): Whether to multiply scales first when generating
+            base anchors. If true, the anchors in the same row will have the
+            same scales. By default it is True in V2.0
+        octave_base_scale (int): The base scale of octave.
+        scales_per_octave (int): Number of scales for each octave.
+            `octave_base_scale` and `scales_per_octave` are usually used in
+            retinanet and the `scales` should be None when they are set.
+        centers (list[tuple[float, float]] | None): The centers of the anchor
+            relative to the feature grid center in multiple feature levels.
+            By default it is set to be None and not used. It a list of float
+            is given, this list will be used to shift the centers of anchors.
+        center_offset (float): The offset of center in proportion to anchors'
+            width and height. By default it is 0.5 in V2.0 but it should be 0.5
+            in v1.x models.
+        use_box_type (bool): Whether to warp anchors with the box type data
+            structure. Defaults to False.
+
+    Examples:
+        >>> from mmdet.models.task_modules.
+        ... prior_generators import LegacyAnchorGenerator
+        >>> self = LegacyAnchorGenerator(
+        >>>     [16], [1.], [1.], [9], center_offset=0.5)
+        >>> all_anchors = self.grid_anchors(((2, 2),), device='cpu')
+        >>> print(all_anchors)
+        [tensor([[ 0.,  0.,  8.,  8.],
+                [16.,  0., 24.,  8.],
+                [ 0., 16.,  8., 24.],
+                [16., 16., 24., 24.]])]
+    """
+
+    def gen_single_level_base_anchors(self,
+                                      base_size: Union[int, float],
+                                      scales: Tensor,
+                                      ratios: Tensor,
+                                      center: Optional[Tuple[float]] = None) \
+            -> Tensor:
+        """Generate base anchors of a single level.
+
+        Note:
+            The width/height of anchors are minused by 1 when calculating \
+                the centers and corners to meet the V1.x coordinate system.
+
+        Args:
+            base_size (int | float): Basic size of an anchor.
+            scales (torch.Tensor): Scales of the anchor.
+            ratios (torch.Tensor): The ratio between the height.
+                and width of anchors in a single level.
+            center (tuple[float], optional): The center of the base anchor
+                related to a single feature grid. Defaults to None.
+
+        Returns:
+            torch.Tensor: Anchors in a single-level feature map.
+        """
+        w = base_size
+        h = base_size
+        if center is None:
+            x_center = self.center_offset * (w - 1)
+            y_center = self.center_offset * (h - 1)
+        else:
+            x_center, y_center = center
+
+        h_ratios = torch.sqrt(ratios)
+        w_ratios = 1 / h_ratios
+        if self.scale_major:
+            ws = (w * w_ratios[:, None] * scales[None, :]).view(-1)
+            hs = (h * h_ratios[:, None] * scales[None, :]).view(-1)
+        else:
+            ws = (w * scales[:, None] * w_ratios[None, :]).view(-1)
+            hs = (h * scales[:, None] * h_ratios[None, :]).view(-1)
+
+        # use float anchor and the anchor's center is aligned with the
+        # pixel center
+        base_anchors = [
+            x_center - 0.5 * (ws - 1), y_center - 0.5 * (hs - 1),
+            x_center + 0.5 * (ws - 1), y_center + 0.5 * (hs - 1)
+        ]
+        base_anchors = torch.stack(base_anchors, dim=-1).round()
+
+        return base_anchors
+
+
+@TASK_UTILS.register_module()
+class LegacySSDAnchorGenerator(SSDAnchorGenerator, LegacyAnchorGenerator):
+    """Legacy anchor generator used in MMDetection V1.x.
+
+    The difference between `LegacySSDAnchorGenerator` and `SSDAnchorGenerator`
+    can be found in `LegacyAnchorGenerator`.
+    """
+
+    def __init__(self,
+                 strides: Union[List[int], List[Tuple[int, int]]],
+                 ratios: List[float],
+                 basesize_ratio_range: Tuple[float],
+                 input_size: int = 300,
+                 scale_major: bool = True,
+                 use_box_type: bool = False) -> None:
+        super(LegacySSDAnchorGenerator, self).__init__(
+            strides=strides,
+            ratios=ratios,
+            basesize_ratio_range=basesize_ratio_range,
+            input_size=input_size,
+            scale_major=scale_major,
+            use_box_type=use_box_type)
+        self.centers = [((stride - 1) / 2., (stride - 1) / 2.)
+                        for stride in strides]
+        self.base_anchors = self.gen_base_anchors()
+
+
+@TASK_UTILS.register_module()
+class YOLOAnchorGenerator(AnchorGenerator):
+    """Anchor generator for YOLO.
+
+    Args:
+        strides (list[int] | list[tuple[int, int]]): Strides of anchors
+            in multiple feature levels.
+        base_sizes (list[list[tuple[int, int]]]): The basic sizes
+            of anchors in multiple levels.
+    """
+
+    def __init__(self,
+                 strides: Union[List[int], List[Tuple[int, int]]],
+                 base_sizes: List[List[Tuple[int, int]]],
+                 use_box_type: bool = False) -> None:
+        self.strides = [_pair(stride) for stride in strides]
+        self.centers = [(stride[0] / 2., stride[1] / 2.)
+                        for stride in self.strides]
+        self.base_sizes = []
+        num_anchor_per_level = len(base_sizes[0])
+        for base_sizes_per_level in base_sizes:
+            assert num_anchor_per_level == len(base_sizes_per_level)
+            self.base_sizes.append(
+                [_pair(base_size) for base_size in base_sizes_per_level])
+        self.base_anchors = self.gen_base_anchors()
+        self.use_box_type = use_box_type
+
+    @property
+    def num_levels(self) -> int:
+        """int: number of feature levels that the generator will be applied"""
+        return len(self.base_sizes)
+
+    def gen_base_anchors(self) -> List[Tensor]:
+        """Generate base anchors.
+
+        Returns:
+            list(torch.Tensor): Base anchors of a feature grid in multiple \
+                feature levels.
+        """
+        multi_level_base_anchors = []
+        for i, base_sizes_per_level in enumerate(self.base_sizes):
+            center = None
+            if self.centers is not None:
+                center = self.centers[i]
+            multi_level_base_anchors.append(
+                self.gen_single_level_base_anchors(base_sizes_per_level,
+                                                   center))
+        return multi_level_base_anchors
+
+    def gen_single_level_base_anchors(self,
+                                      base_sizes_per_level: List[Tuple[int]],
+                                      center: Optional[Tuple[float]] = None) \
+            -> Tensor:
+        """Generate base anchors of a single level.
+
+        Args:
+            base_sizes_per_level (list[tuple[int]]): Basic sizes of
+                anchors.
+            center (tuple[float], optional): The center of the base anchor
+                related to a single feature grid. Defaults to None.
+
+        Returns:
+            torch.Tensor: Anchors in a single-level feature maps.
+        """
+        x_center, y_center = center
+        base_anchors = []
+        for base_size in base_sizes_per_level:
+            w, h = base_size
+
+            # use float anchor and the anchor's center is aligned with the
+            # pixel center
+            base_anchor = torch.Tensor([
+                x_center - 0.5 * w, y_center - 0.5 * h, x_center + 0.5 * w,
+                y_center + 0.5 * h
+            ])
+            base_anchors.append(base_anchor)
+        base_anchors = torch.stack(base_anchors, dim=0)
+
+        return base_anchors
diff --git a/mmdetection/mmdet/models/task_modules/prior_generators/point_generator.py b/mmdetection/mmdet/models/task_modules/prior_generators/point_generator.py
new file mode 100644
index 00000000..c87ad656
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/prior_generators/point_generator.py
@@ -0,0 +1,321 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple, Union
+
+import numpy as np
+import torch
+from torch import Tensor
+from torch.nn.modules.utils import _pair
+
+from mmdet.registry import TASK_UTILS
+
+DeviceType = Union[str, torch.device]
+
+
+@TASK_UTILS.register_module()
+class PointGenerator:
+
+    def _meshgrid(self,
+                  x: Tensor,
+                  y: Tensor,
+                  row_major: bool = True) -> Tuple[Tensor, Tensor]:
+        """Generate mesh grid of x and y.
+
+        Args:
+            x (torch.Tensor): Grids of x dimension.
+            y (torch.Tensor): Grids of y dimension.
+            row_major (bool): Whether to return y grids first.
+                Defaults to True.
+
+        Returns:
+            tuple[torch.Tensor]: The mesh grids of x and y.
+        """
+        xx = x.repeat(len(y))
+        yy = y.view(-1, 1).repeat(1, len(x)).view(-1)
+        if row_major:
+            return xx, yy
+        else:
+            return yy, xx
+
+    def grid_points(self,
+                    featmap_size: Tuple[int, int],
+                    stride=16,
+                    device: DeviceType = 'cuda') -> Tensor:
+        """Generate grid points of a single level.
+
+        Args:
+            featmap_size (tuple[int, int]): Size of the feature maps.
+            stride (int): The stride of corresponding feature map.
+            device (str | torch.device): The device the tensor will be put on.
+                Defaults to 'cuda'.
+
+        Returns:
+            torch.Tensor: grid point in a feature map.
+        """
+        feat_h, feat_w = featmap_size
+        shift_x = torch.arange(0., feat_w, device=device) * stride
+        shift_y = torch.arange(0., feat_h, device=device) * stride
+        shift_xx, shift_yy = self._meshgrid(shift_x, shift_y)
+        stride = shift_x.new_full((shift_xx.shape[0], ), stride)
+        shifts = torch.stack([shift_xx, shift_yy, stride], dim=-1)
+        all_points = shifts.to(device)
+        return all_points
+
+    def valid_flags(self,
+                    featmap_size: Tuple[int, int],
+                    valid_size: Tuple[int, int],
+                    device: DeviceType = 'cuda') -> Tensor:
+        """Generate valid flags of anchors in a feature map.
+
+        Args:
+            featmap_sizes (list(tuple[int, int])): List of feature map sizes in
+                multiple feature levels.
+            valid_shape (tuple[int, int]): The valid shape of the image.
+            device (str | torch.device): Device where the anchors will be
+                put on.
+
+        Return:
+            torch.Tensor: Valid flags of anchors in a level.
+        """
+        feat_h, feat_w = featmap_size
+        valid_h, valid_w = valid_size
+        assert valid_h <= feat_h and valid_w <= feat_w
+        valid_x = torch.zeros(feat_w, dtype=torch.bool, device=device)
+        valid_y = torch.zeros(feat_h, dtype=torch.bool, device=device)
+        valid_x[:valid_w] = 1
+        valid_y[:valid_h] = 1
+        valid_xx, valid_yy = self._meshgrid(valid_x, valid_y)
+        valid = valid_xx & valid_yy
+        return valid
+
+
+@TASK_UTILS.register_module()
+class MlvlPointGenerator:
+    """Standard points generator for multi-level (Mlvl) feature maps in 2D
+    points-based detectors.
+
+    Args:
+        strides (list[int] | list[tuple[int, int]]): Strides of anchors
+            in multiple feature levels in order (w, h).
+        offset (float): The offset of points, the value is normalized with
+            corresponding stride. Defaults to 0.5.
+    """
+
+    def __init__(self,
+                 strides: Union[List[int], List[Tuple[int, int]]],
+                 offset: float = 0.5) -> None:
+        self.strides = [_pair(stride) for stride in strides]
+        self.offset = offset
+
+    @property
+    def num_levels(self) -> int:
+        """int: number of feature levels that the generator will be applied"""
+        return len(self.strides)
+
+    @property
+    def num_base_priors(self) -> List[int]:
+        """list[int]: The number of priors (points) at a point
+        on the feature grid"""
+        return [1 for _ in range(len(self.strides))]
+
+    def _meshgrid(self,
+                  x: Tensor,
+                  y: Tensor,
+                  row_major: bool = True) -> Tuple[Tensor, Tensor]:
+        yy, xx = torch.meshgrid(y, x)
+        if row_major:
+            # warning .flatten() would cause error in ONNX exporting
+            # have to use reshape here
+            return xx.reshape(-1), yy.reshape(-1)
+
+        else:
+            return yy.reshape(-1), xx.reshape(-1)
+
+    def grid_priors(self,
+                    featmap_sizes: List[Tuple],
+                    dtype: torch.dtype = torch.float32,
+                    device: DeviceType = 'cuda',
+                    with_stride: bool = False) -> List[Tensor]:
+        """Generate grid points of multiple feature levels.
+
+        Args:
+            featmap_sizes (list[tuple]): List of feature map sizes in
+                multiple feature levels, each size arrange as
+                as (h, w).
+            dtype (:obj:`dtype`): Dtype of priors. Defaults to torch.float32.
+            device (str | torch.device): The device where the anchors will be
+                put on.
+            with_stride (bool): Whether to concatenate the stride to
+                the last dimension of points.
+
+        Return:
+            list[torch.Tensor]: Points of  multiple feature levels.
+            The sizes of each tensor should be (N, 2) when with stride is
+            ``False``, where N = width * height, width and height
+            are the sizes of the corresponding feature level,
+            and the last dimension 2 represent (coord_x, coord_y),
+            otherwise the shape should be (N, 4),
+            and the last dimension 4 represent
+            (coord_x, coord_y, stride_w, stride_h).
+        """
+
+        assert self.num_levels == len(featmap_sizes)
+        multi_level_priors = []
+        for i in range(self.num_levels):
+            priors = self.single_level_grid_priors(
+                featmap_sizes[i],
+                level_idx=i,
+                dtype=dtype,
+                device=device,
+                with_stride=with_stride)
+            multi_level_priors.append(priors)
+        return multi_level_priors
+
+    def single_level_grid_priors(self,
+                                 featmap_size: Tuple[int],
+                                 level_idx: int,
+                                 dtype: torch.dtype = torch.float32,
+                                 device: DeviceType = 'cuda',
+                                 with_stride: bool = False) -> Tensor:
+        """Generate grid Points of a single level.
+
+        Note:
+            This function is usually called by method ``self.grid_priors``.
+
+        Args:
+            featmap_size (tuple[int]): Size of the feature maps, arrange as
+                (h, w).
+            level_idx (int): The index of corresponding feature map level.
+            dtype (:obj:`dtype`): Dtype of priors. Defaults to torch.float32.
+            device (str | torch.device): The device the tensor will be put on.
+                Defaults to 'cuda'.
+            with_stride (bool): Concatenate the stride to the last dimension
+                of points.
+
+        Return:
+            Tensor: Points of single feature levels.
+            The shape of tensor should be (N, 2) when with stride is
+            ``False``, where N = width * height, width and height
+            are the sizes of the corresponding feature level,
+            and the last dimension 2 represent (coord_x, coord_y),
+            otherwise the shape should be (N, 4),
+            and the last dimension 4 represent
+            (coord_x, coord_y, stride_w, stride_h).
+        """
+        feat_h, feat_w = featmap_size
+        stride_w, stride_h = self.strides[level_idx]
+        shift_x = (torch.arange(0, feat_w, device=device) +
+                   self.offset) * stride_w
+        # keep featmap_size as Tensor instead of int, so that we
+        # can convert to ONNX correctly
+        shift_x = shift_x.to(dtype)
+
+        shift_y = (torch.arange(0, feat_h, device=device) +
+                   self.offset) * stride_h
+        # keep featmap_size as Tensor instead of int, so that we
+        # can convert to ONNX correctly
+        shift_y = shift_y.to(dtype)
+        shift_xx, shift_yy = self._meshgrid(shift_x, shift_y)
+        if not with_stride:
+            shifts = torch.stack([shift_xx, shift_yy], dim=-1)
+        else:
+            # use `shape[0]` instead of `len(shift_xx)` for ONNX export
+            stride_w = shift_xx.new_full((shift_xx.shape[0], ),
+                                         stride_w).to(dtype)
+            stride_h = shift_xx.new_full((shift_yy.shape[0], ),
+                                         stride_h).to(dtype)
+            shifts = torch.stack([shift_xx, shift_yy, stride_w, stride_h],
+                                 dim=-1)
+        all_points = shifts.to(device)
+        return all_points
+
+    def valid_flags(self,
+                    featmap_sizes: List[Tuple[int, int]],
+                    pad_shape: Tuple[int],
+                    device: DeviceType = 'cuda') -> List[Tensor]:
+        """Generate valid flags of points of multiple feature levels.
+
+        Args:
+            featmap_sizes (list(tuple)): List of feature map sizes in
+                multiple feature levels, each size arrange as
+                as (h, w).
+            pad_shape (tuple(int)): The padded shape of the image,
+                arrange as (h, w).
+            device (str | torch.device): The device where the anchors will be
+                put on.
+
+        Return:
+            list(torch.Tensor): Valid flags of points of multiple levels.
+        """
+        assert self.num_levels == len(featmap_sizes)
+        multi_level_flags = []
+        for i in range(self.num_levels):
+            point_stride = self.strides[i]
+            feat_h, feat_w = featmap_sizes[i]
+            h, w = pad_shape[:2]
+            valid_feat_h = min(int(np.ceil(h / point_stride[1])), feat_h)
+            valid_feat_w = min(int(np.ceil(w / point_stride[0])), feat_w)
+            flags = self.single_level_valid_flags((feat_h, feat_w),
+                                                  (valid_feat_h, valid_feat_w),
+                                                  device=device)
+            multi_level_flags.append(flags)
+        return multi_level_flags
+
+    def single_level_valid_flags(self,
+                                 featmap_size: Tuple[int, int],
+                                 valid_size: Tuple[int, int],
+                                 device: DeviceType = 'cuda') -> Tensor:
+        """Generate the valid flags of points of a single feature map.
+
+        Args:
+            featmap_size (tuple[int]): The size of feature maps, arrange as
+                as (h, w).
+            valid_size (tuple[int]): The valid size of the feature maps.
+                The size arrange as as (h, w).
+            device (str | torch.device): The device where the flags will be
+            put on. Defaults to 'cuda'.
+
+        Returns:
+            torch.Tensor: The valid flags of each points in a single level \
+                feature map.
+        """
+        feat_h, feat_w = featmap_size
+        valid_h, valid_w = valid_size
+        assert valid_h <= feat_h and valid_w <= feat_w
+        valid_x = torch.zeros(feat_w, dtype=torch.bool, device=device)
+        valid_y = torch.zeros(feat_h, dtype=torch.bool, device=device)
+        valid_x[:valid_w] = 1
+        valid_y[:valid_h] = 1
+        valid_xx, valid_yy = self._meshgrid(valid_x, valid_y)
+        valid = valid_xx & valid_yy
+        return valid
+
+    def sparse_priors(self,
+                      prior_idxs: Tensor,
+                      featmap_size: Tuple[int],
+                      level_idx: int,
+                      dtype: torch.dtype = torch.float32,
+                      device: DeviceType = 'cuda') -> Tensor:
+        """Generate sparse points according to the ``prior_idxs``.
+
+        Args:
+            prior_idxs (Tensor): The index of corresponding anchors
+                in the feature map.
+            featmap_size (tuple[int]): feature map size arrange as (w, h).
+            level_idx (int): The level index of corresponding feature
+                map.
+            dtype (obj:`torch.dtype`): Date type of points. Defaults to
+                ``torch.float32``.
+            device (str | torch.device): The device where the points is
+                located.
+        Returns:
+            Tensor: Anchor with shape (N, 2), N should be equal to
+            the length of ``prior_idxs``. And last dimension
+            2 represent (coord_x, coord_y).
+        """
+        height, width = featmap_size
+        x = (prior_idxs % width + self.offset) * self.strides[level_idx][0]
+        y = ((prior_idxs // width) % height +
+             self.offset) * self.strides[level_idx][1]
+        prioris = torch.stack([x, y], 1).to(dtype)
+        prioris = prioris.to(device)
+        return prioris
diff --git a/mmdetection/mmdet/models/task_modules/prior_generators/utils.py b/mmdetection/mmdet/models/task_modules/prior_generators/utils.py
new file mode 100644
index 00000000..3aa2dfd4
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/prior_generators/utils.py
@@ -0,0 +1,70 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Tuple
+
+import torch
+from torch import Tensor
+
+from mmdet.structures.bbox import BaseBoxes
+
+
+def anchor_inside_flags(flat_anchors: Tensor,
+                        valid_flags: Tensor,
+                        img_shape: Tuple[int],
+                        allowed_border: int = 0) -> Tensor:
+    """Check whether the anchors are inside the border.
+
+    Args:
+        flat_anchors (torch.Tensor): Flatten anchors, shape (n, 4).
+        valid_flags (torch.Tensor): An existing valid flags of anchors.
+        img_shape (tuple(int)): Shape of current image.
+        allowed_border (int): The border to allow the valid anchor.
+            Defaults to 0.
+
+    Returns:
+        torch.Tensor: Flags indicating whether the anchors are inside a \
+            valid range.
+    """
+    img_h, img_w = img_shape[:2]
+    if allowed_border >= 0:
+        if isinstance(flat_anchors, BaseBoxes):
+            inside_flags = valid_flags & \
+                flat_anchors.is_inside([img_h, img_w],
+                                       all_inside=True,
+                                       allowed_border=allowed_border)
+        else:
+            inside_flags = valid_flags & \
+                (flat_anchors[:, 0] >= -allowed_border) & \
+                (flat_anchors[:, 1] >= -allowed_border) & \
+                (flat_anchors[:, 2] < img_w + allowed_border) & \
+                (flat_anchors[:, 3] < img_h + allowed_border)
+    else:
+        inside_flags = valid_flags
+    return inside_flags
+
+
+def calc_region(bbox: Tensor,
+                ratio: float,
+                featmap_size: Optional[Tuple] = None) -> Tuple[int]:
+    """Calculate a proportional bbox region.
+
+    The bbox center are fixed and the new h' and w' is h * ratio and w * ratio.
+
+    Args:
+        bbox (Tensor): Bboxes to calculate regions, shape (n, 4).
+        ratio (float): Ratio of the output region.
+        featmap_size (tuple, Optional): Feature map size in (height, width)
+            order used for clipping the boundary. Defaults to None.
+
+    Returns:
+        tuple: x1, y1, x2, y2
+    """
+    x1 = torch.round((1 - ratio) * bbox[0] + ratio * bbox[2]).long()
+    y1 = torch.round((1 - ratio) * bbox[1] + ratio * bbox[3]).long()
+    x2 = torch.round(ratio * bbox[0] + (1 - ratio) * bbox[2]).long()
+    y2 = torch.round(ratio * bbox[1] + (1 - ratio) * bbox[3]).long()
+    if featmap_size is not None:
+        x1 = x1.clamp(min=0, max=featmap_size[1])
+        y1 = y1.clamp(min=0, max=featmap_size[0])
+        x2 = x2.clamp(min=0, max=featmap_size[1])
+        y2 = y2.clamp(min=0, max=featmap_size[0])
+    return (x1, y1, x2, y2)
diff --git a/mmdetection/mmdet/models/task_modules/samplers/__init__.py b/mmdetection/mmdet/models/task_modules/samplers/__init__.py
new file mode 100644
index 00000000..3782eb89
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/samplers/__init__.py
@@ -0,0 +1,22 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .base_sampler import BaseSampler
+from .combined_sampler import CombinedSampler
+from .instance_balanced_pos_sampler import InstanceBalancedPosSampler
+from .iou_balanced_neg_sampler import IoUBalancedNegSampler
+from .mask_pseudo_sampler import MaskPseudoSampler
+from .mask_sampling_result import MaskSamplingResult
+from .multi_instance_random_sampler import MultiInsRandomSampler
+from .multi_instance_sampling_result import MultiInstanceSamplingResult
+from .ohem_sampler import OHEMSampler
+from .pseudo_sampler import PseudoSampler
+from .random_sampler import RandomSampler
+from .sampling_result import SamplingResult
+from .score_hlr_sampler import ScoreHLRSampler
+
+__all__ = [
+    'BaseSampler', 'PseudoSampler', 'RandomSampler',
+    'InstanceBalancedPosSampler', 'IoUBalancedNegSampler', 'CombinedSampler',
+    'OHEMSampler', 'SamplingResult', 'ScoreHLRSampler', 'MaskPseudoSampler',
+    'MaskSamplingResult', 'MultiInstanceSamplingResult',
+    'MultiInsRandomSampler'
+]
diff --git a/mmdetection/mmdet/models/task_modules/samplers/base_sampler.py b/mmdetection/mmdet/models/task_modules/samplers/base_sampler.py
new file mode 100644
index 00000000..be8a9a5e
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/samplers/base_sampler.py
@@ -0,0 +1,136 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from abc import ABCMeta, abstractmethod
+
+import torch
+from mmengine.structures import InstanceData
+
+from mmdet.structures.bbox import BaseBoxes, cat_boxes
+from ..assigners import AssignResult
+from .sampling_result import SamplingResult
+
+
+class BaseSampler(metaclass=ABCMeta):
+    """Base class of samplers.
+
+    Args:
+        num (int): Number of samples
+        pos_fraction (float): Fraction of positive samples
+        neg_pos_up (int): Upper bound number of negative and
+            positive samples. Defaults to -1.
+        add_gt_as_proposals (bool): Whether to add ground truth
+            boxes as proposals. Defaults to True.
+    """
+
+    def __init__(self,
+                 num: int,
+                 pos_fraction: float,
+                 neg_pos_ub: int = -1,
+                 add_gt_as_proposals: bool = True,
+                 **kwargs) -> None:
+        self.num = num
+        self.pos_fraction = pos_fraction
+        self.neg_pos_ub = neg_pos_ub
+        self.add_gt_as_proposals = add_gt_as_proposals
+        self.pos_sampler = self
+        self.neg_sampler = self
+
+    @abstractmethod
+    def _sample_pos(self, assign_result: AssignResult, num_expected: int,
+                    **kwargs):
+        """Sample positive samples."""
+        pass
+
+    @abstractmethod
+    def _sample_neg(self, assign_result: AssignResult, num_expected: int,
+                    **kwargs):
+        """Sample negative samples."""
+        pass
+
+    def sample(self, assign_result: AssignResult, pred_instances: InstanceData,
+               gt_instances: InstanceData, **kwargs) -> SamplingResult:
+        """Sample positive and negative bboxes.
+
+        This is a simple implementation of bbox sampling given candidates,
+        assigning results and ground truth bboxes.
+
+        Args:
+            assign_result (:obj:`AssignResult`): Assigning results.
+            pred_instances (:obj:`InstanceData`): Instances of model
+                predictions. It includes ``priors``, and the priors can
+                be anchors or points, or the bboxes predicted by the
+                previous stage, has shape (n, 4). The bboxes predicted by
+                the current model or stage will be named ``bboxes``,
+                ``labels``, and ``scores``, the same as the ``InstanceData``
+                in other places.
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes``, with shape (k, 4),
+                and ``labels``, with shape (k, ).
+
+        Returns:
+            :obj:`SamplingResult`: Sampling result.
+
+        Example:
+            >>> from mmengine.structures import InstanceData
+            >>> from mmdet.models.task_modules.samplers import RandomSampler,
+            >>> from mmdet.models.task_modules.assigners import AssignResult
+            >>> from mmdet.models.task_modules.samplers.
+            ... sampling_result import ensure_rng, random_boxes
+            >>> rng = ensure_rng(None)
+            >>> assign_result = AssignResult.random(rng=rng)
+            >>> pred_instances = InstanceData()
+            >>> pred_instances.priors = random_boxes(assign_result.num_preds,
+            ...                                      rng=rng)
+            >>> gt_instances = InstanceData()
+            >>> gt_instances.bboxes = random_boxes(assign_result.num_gts,
+            ...                                    rng=rng)
+            >>> gt_instances.labels = torch.randint(
+            ...     0, 5, (assign_result.num_gts,), dtype=torch.long)
+            >>> self = RandomSampler(num=32, pos_fraction=0.5, neg_pos_ub=-1,
+            >>>                      add_gt_as_proposals=False)
+            >>> self = self.sample(assign_result, pred_instances, gt_instances)
+        """
+        gt_bboxes = gt_instances.bboxes
+        priors = pred_instances.priors
+        gt_labels = gt_instances.labels
+        if len(priors.shape) < 2:
+            priors = priors[None, :]
+
+        gt_flags = priors.new_zeros((priors.shape[0], ), dtype=torch.uint8)
+        if self.add_gt_as_proposals and len(gt_bboxes) > 0:
+            # When `gt_bboxes` and `priors` are all box type, convert
+            # `gt_bboxes` type to `priors` type.
+            if (isinstance(gt_bboxes, BaseBoxes)
+                    and isinstance(priors, BaseBoxes)):
+                gt_bboxes_ = gt_bboxes.convert_to(type(priors))
+            else:
+                gt_bboxes_ = gt_bboxes
+            priors = cat_boxes([gt_bboxes_, priors], dim=0)
+            assign_result.add_gt_(gt_labels)
+            gt_ones = priors.new_ones(gt_bboxes_.shape[0], dtype=torch.uint8)
+            gt_flags = torch.cat([gt_ones, gt_flags])
+
+        num_expected_pos = int(self.num * self.pos_fraction)
+        pos_inds = self.pos_sampler._sample_pos(
+            assign_result, num_expected_pos, bboxes=priors, **kwargs)
+        # We found that sampled indices have duplicated items occasionally.
+        # (may be a bug of PyTorch)
+        pos_inds = pos_inds.unique()
+        num_sampled_pos = pos_inds.numel()
+        num_expected_neg = self.num - num_sampled_pos
+        if self.neg_pos_ub >= 0:
+            _pos = max(1, num_sampled_pos)
+            neg_upper_bound = int(self.neg_pos_ub * _pos)
+            if num_expected_neg > neg_upper_bound:
+                num_expected_neg = neg_upper_bound
+        neg_inds = self.neg_sampler._sample_neg(
+            assign_result, num_expected_neg, bboxes=priors, **kwargs)
+        neg_inds = neg_inds.unique()
+
+        sampling_result = SamplingResult(
+            pos_inds=pos_inds,
+            neg_inds=neg_inds,
+            priors=priors,
+            gt_bboxes=gt_bboxes,
+            assign_result=assign_result,
+            gt_flags=gt_flags)
+        return sampling_result
diff --git a/mmdetection/mmdet/models/task_modules/samplers/combined_sampler.py b/mmdetection/mmdet/models/task_modules/samplers/combined_sampler.py
new file mode 100644
index 00000000..8e0560e3
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/samplers/combined_sampler.py
@@ -0,0 +1,21 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.registry import TASK_UTILS
+from .base_sampler import BaseSampler
+
+
+@TASK_UTILS.register_module()
+class CombinedSampler(BaseSampler):
+    """A sampler that combines positive sampler and negative sampler."""
+
+    def __init__(self, pos_sampler, neg_sampler, **kwargs):
+        super(CombinedSampler, self).__init__(**kwargs)
+        self.pos_sampler = TASK_UTILS.build(pos_sampler, default_args=kwargs)
+        self.neg_sampler = TASK_UTILS.build(neg_sampler, default_args=kwargs)
+
+    def _sample_pos(self, **kwargs):
+        """Sample positive samples."""
+        raise NotImplementedError
+
+    def _sample_neg(self, **kwargs):
+        """Sample negative samples."""
+        raise NotImplementedError
diff --git a/mmdetection/mmdet/models/task_modules/samplers/instance_balanced_pos_sampler.py b/mmdetection/mmdet/models/task_modules/samplers/instance_balanced_pos_sampler.py
new file mode 100644
index 00000000..e48d8e91
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/samplers/instance_balanced_pos_sampler.py
@@ -0,0 +1,56 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import numpy as np
+import torch
+
+from mmdet.registry import TASK_UTILS
+from .random_sampler import RandomSampler
+
+
+@TASK_UTILS.register_module()
+class InstanceBalancedPosSampler(RandomSampler):
+    """Instance balanced sampler that samples equal number of positive samples
+    for each instance."""
+
+    def _sample_pos(self, assign_result, num_expected, **kwargs):
+        """Sample positive boxes.
+
+        Args:
+            assign_result (:obj:`AssignResult`): The assigned results of boxes.
+            num_expected (int): The number of expected positive samples
+
+        Returns:
+            Tensor or ndarray: sampled indices.
+        """
+        pos_inds = torch.nonzero(assign_result.gt_inds > 0, as_tuple=False)
+        if pos_inds.numel() != 0:
+            pos_inds = pos_inds.squeeze(1)
+        if pos_inds.numel() <= num_expected:
+            return pos_inds
+        else:
+            unique_gt_inds = assign_result.gt_inds[pos_inds].unique()
+            num_gts = len(unique_gt_inds)
+            num_per_gt = int(round(num_expected / float(num_gts)) + 1)
+            sampled_inds = []
+            for i in unique_gt_inds:
+                inds = torch.nonzero(
+                    assign_result.gt_inds == i.item(), as_tuple=False)
+                if inds.numel() != 0:
+                    inds = inds.squeeze(1)
+                else:
+                    continue
+                if len(inds) > num_per_gt:
+                    inds = self.random_choice(inds, num_per_gt)
+                sampled_inds.append(inds)
+            sampled_inds = torch.cat(sampled_inds)
+            if len(sampled_inds) < num_expected:
+                num_extra = num_expected - len(sampled_inds)
+                extra_inds = np.array(
+                    list(set(pos_inds.cpu()) - set(sampled_inds.cpu())))
+                if len(extra_inds) > num_extra:
+                    extra_inds = self.random_choice(extra_inds, num_extra)
+                extra_inds = torch.from_numpy(extra_inds).to(
+                    assign_result.gt_inds.device).long()
+                sampled_inds = torch.cat([sampled_inds, extra_inds])
+            elif len(sampled_inds) > num_expected:
+                sampled_inds = self.random_choice(sampled_inds, num_expected)
+            return sampled_inds
diff --git a/mmdetection/mmdet/models/task_modules/samplers/iou_balanced_neg_sampler.py b/mmdetection/mmdet/models/task_modules/samplers/iou_balanced_neg_sampler.py
new file mode 100644
index 00000000..dc1f4641
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/samplers/iou_balanced_neg_sampler.py
@@ -0,0 +1,158 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import numpy as np
+import torch
+
+from mmdet.registry import TASK_UTILS
+from .random_sampler import RandomSampler
+
+
+@TASK_UTILS.register_module()
+class IoUBalancedNegSampler(RandomSampler):
+    """IoU Balanced Sampling.
+
+    arXiv: https://arxiv.org/pdf/1904.02701.pdf (CVPR 2019)
+
+    Sampling proposals according to their IoU. `floor_fraction` of needed RoIs
+    are sampled from proposals whose IoU are lower than `floor_thr` randomly.
+    The others are sampled from proposals whose IoU are higher than
+    `floor_thr`. These proposals are sampled from some bins evenly, which are
+    split by `num_bins` via IoU evenly.
+
+    Args:
+        num (int): number of proposals.
+        pos_fraction (float): fraction of positive proposals.
+        floor_thr (float): threshold (minimum) IoU for IoU balanced sampling,
+            set to -1 if all using IoU balanced sampling.
+        floor_fraction (float): sampling fraction of proposals under floor_thr.
+        num_bins (int): number of bins in IoU balanced sampling.
+    """
+
+    def __init__(self,
+                 num,
+                 pos_fraction,
+                 floor_thr=-1,
+                 floor_fraction=0,
+                 num_bins=3,
+                 **kwargs):
+        super(IoUBalancedNegSampler, self).__init__(num, pos_fraction,
+                                                    **kwargs)
+        assert floor_thr >= 0 or floor_thr == -1
+        assert 0 <= floor_fraction <= 1
+        assert num_bins >= 1
+
+        self.floor_thr = floor_thr
+        self.floor_fraction = floor_fraction
+        self.num_bins = num_bins
+
+    def sample_via_interval(self, max_overlaps, full_set, num_expected):
+        """Sample according to the iou interval.
+
+        Args:
+            max_overlaps (torch.Tensor): IoU between bounding boxes and ground
+                truth boxes.
+            full_set (set(int)): A full set of indices of boxes。
+            num_expected (int): Number of expected samples。
+
+        Returns:
+            np.ndarray: Indices  of samples
+        """
+        max_iou = max_overlaps.max()
+        iou_interval = (max_iou - self.floor_thr) / self.num_bins
+        per_num_expected = int(num_expected / self.num_bins)
+
+        sampled_inds = []
+        for i in range(self.num_bins):
+            start_iou = self.floor_thr + i * iou_interval
+            end_iou = self.floor_thr + (i + 1) * iou_interval
+            tmp_set = set(
+                np.where(
+                    np.logical_and(max_overlaps >= start_iou,
+                                   max_overlaps < end_iou))[0])
+            tmp_inds = list(tmp_set & full_set)
+            if len(tmp_inds) > per_num_expected:
+                tmp_sampled_set = self.random_choice(tmp_inds,
+                                                     per_num_expected)
+            else:
+                tmp_sampled_set = np.array(tmp_inds, dtype=np.int64)
+            sampled_inds.append(tmp_sampled_set)
+
+        sampled_inds = np.concatenate(sampled_inds)
+        if len(sampled_inds) < num_expected:
+            num_extra = num_expected - len(sampled_inds)
+            extra_inds = np.array(list(full_set - set(sampled_inds)))
+            if len(extra_inds) > num_extra:
+                extra_inds = self.random_choice(extra_inds, num_extra)
+            sampled_inds = np.concatenate([sampled_inds, extra_inds])
+
+        return sampled_inds
+
+    def _sample_neg(self, assign_result, num_expected, **kwargs):
+        """Sample negative boxes.
+
+        Args:
+            assign_result (:obj:`AssignResult`): The assigned results of boxes.
+            num_expected (int): The number of expected negative samples
+
+        Returns:
+            Tensor or ndarray: sampled indices.
+        """
+        neg_inds = torch.nonzero(assign_result.gt_inds == 0, as_tuple=False)
+        if neg_inds.numel() != 0:
+            neg_inds = neg_inds.squeeze(1)
+        if len(neg_inds) <= num_expected:
+            return neg_inds
+        else:
+            max_overlaps = assign_result.max_overlaps.cpu().numpy()
+            # balance sampling for negative samples
+            neg_set = set(neg_inds.cpu().numpy())
+
+            if self.floor_thr > 0:
+                floor_set = set(
+                    np.where(
+                        np.logical_and(max_overlaps >= 0,
+                                       max_overlaps < self.floor_thr))[0])
+                iou_sampling_set = set(
+                    np.where(max_overlaps >= self.floor_thr)[0])
+            elif self.floor_thr == 0:
+                floor_set = set(np.where(max_overlaps == 0)[0])
+                iou_sampling_set = set(
+                    np.where(max_overlaps > self.floor_thr)[0])
+            else:
+                floor_set = set()
+                iou_sampling_set = set(
+                    np.where(max_overlaps > self.floor_thr)[0])
+                # for sampling interval calculation
+                self.floor_thr = 0
+
+            floor_neg_inds = list(floor_set & neg_set)
+            iou_sampling_neg_inds = list(iou_sampling_set & neg_set)
+            num_expected_iou_sampling = int(num_expected *
+                                            (1 - self.floor_fraction))
+            if len(iou_sampling_neg_inds) > num_expected_iou_sampling:
+                if self.num_bins >= 2:
+                    iou_sampled_inds = self.sample_via_interval(
+                        max_overlaps, set(iou_sampling_neg_inds),
+                        num_expected_iou_sampling)
+                else:
+                    iou_sampled_inds = self.random_choice(
+                        iou_sampling_neg_inds, num_expected_iou_sampling)
+            else:
+                iou_sampled_inds = np.array(
+                    iou_sampling_neg_inds, dtype=np.int64)
+            num_expected_floor = num_expected - len(iou_sampled_inds)
+            if len(floor_neg_inds) > num_expected_floor:
+                sampled_floor_inds = self.random_choice(
+                    floor_neg_inds, num_expected_floor)
+            else:
+                sampled_floor_inds = np.array(floor_neg_inds, dtype=np.int64)
+            sampled_inds = np.concatenate(
+                (sampled_floor_inds, iou_sampled_inds))
+            if len(sampled_inds) < num_expected:
+                num_extra = num_expected - len(sampled_inds)
+                extra_inds = np.array(list(neg_set - set(sampled_inds)))
+                if len(extra_inds) > num_extra:
+                    extra_inds = self.random_choice(extra_inds, num_extra)
+                sampled_inds = np.concatenate((sampled_inds, extra_inds))
+            sampled_inds = torch.from_numpy(sampled_inds).long().to(
+                assign_result.gt_inds.device)
+            return sampled_inds
diff --git a/mmdetection/mmdet/models/task_modules/samplers/mask_pseudo_sampler.py b/mmdetection/mmdet/models/task_modules/samplers/mask_pseudo_sampler.py
new file mode 100644
index 00000000..307dd5d1
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/samplers/mask_pseudo_sampler.py
@@ -0,0 +1,60 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+"""copy from
+https://github.com/ZwwWayne/K-Net/blob/main/knet/det/mask_pseudo_sampler.py."""
+
+import torch
+from mmengine.structures import InstanceData
+
+from mmdet.registry import TASK_UTILS
+from ..assigners import AssignResult
+from .base_sampler import BaseSampler
+from .mask_sampling_result import MaskSamplingResult
+
+
+@TASK_UTILS.register_module()
+class MaskPseudoSampler(BaseSampler):
+    """A pseudo sampler that does not do sampling actually."""
+
+    def __init__(self, **kwargs):
+        pass
+
+    def _sample_pos(self, **kwargs):
+        """Sample positive samples."""
+        raise NotImplementedError
+
+    def _sample_neg(self, **kwargs):
+        """Sample negative samples."""
+        raise NotImplementedError
+
+    def sample(self, assign_result: AssignResult, pred_instances: InstanceData,
+               gt_instances: InstanceData, *args, **kwargs):
+        """Directly returns the positive and negative indices  of samples.
+
+        Args:
+            assign_result (:obj:`AssignResult`): Mask assigning results.
+            pred_instances (:obj:`InstanceData`): Instances of model
+                predictions. It includes ``scores`` and ``masks`` predicted
+                by the model.
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``labels`` and ``masks``
+                attributes.
+
+        Returns:
+            :obj:`SamplingResult`: sampler results
+        """
+        pred_masks = pred_instances.masks
+        gt_masks = gt_instances.masks
+        pos_inds = torch.nonzero(
+            assign_result.gt_inds > 0, as_tuple=False).squeeze(-1).unique()
+        neg_inds = torch.nonzero(
+            assign_result.gt_inds == 0, as_tuple=False).squeeze(-1).unique()
+        gt_flags = pred_masks.new_zeros(pred_masks.shape[0], dtype=torch.uint8)
+        sampling_result = MaskSamplingResult(
+            pos_inds=pos_inds,
+            neg_inds=neg_inds,
+            masks=pred_masks,
+            gt_masks=gt_masks,
+            assign_result=assign_result,
+            gt_flags=gt_flags,
+            avg_factor_with_neg=False)
+        return sampling_result
diff --git a/mmdetection/mmdet/models/task_modules/samplers/mask_sampling_result.py b/mmdetection/mmdet/models/task_modules/samplers/mask_sampling_result.py
new file mode 100644
index 00000000..adaa62e8
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/samplers/mask_sampling_result.py
@@ -0,0 +1,68 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+"""copy from
+https://github.com/ZwwWayne/K-Net/blob/main/knet/det/mask_pseudo_sampler.py."""
+
+import torch
+from torch import Tensor
+
+from ..assigners import AssignResult
+from .sampling_result import SamplingResult
+
+
+class MaskSamplingResult(SamplingResult):
+    """Mask sampling result."""
+
+    def __init__(self,
+                 pos_inds: Tensor,
+                 neg_inds: Tensor,
+                 masks: Tensor,
+                 gt_masks: Tensor,
+                 assign_result: AssignResult,
+                 gt_flags: Tensor,
+                 avg_factor_with_neg: bool = True) -> None:
+        self.pos_inds = pos_inds
+        self.neg_inds = neg_inds
+        self.num_pos = max(pos_inds.numel(), 1)
+        self.num_neg = max(neg_inds.numel(), 1)
+        self.avg_factor = self.num_pos + self.num_neg \
+            if avg_factor_with_neg else self.num_pos
+
+        self.pos_masks = masks[pos_inds]
+        self.neg_masks = masks[neg_inds]
+        self.pos_is_gt = gt_flags[pos_inds]
+
+        self.num_gts = gt_masks.shape[0]
+        self.pos_assigned_gt_inds = assign_result.gt_inds[pos_inds] - 1
+
+        if gt_masks.numel() == 0:
+            # hack for index error case
+            assert self.pos_assigned_gt_inds.numel() == 0
+            self.pos_gt_masks = torch.empty_like(gt_masks)
+        else:
+            self.pos_gt_masks = gt_masks[self.pos_assigned_gt_inds, :]
+
+    @property
+    def masks(self) -> Tensor:
+        """torch.Tensor: concatenated positive and negative masks."""
+        return torch.cat([self.pos_masks, self.neg_masks])
+
+    def __nice__(self) -> str:
+        data = self.info.copy()
+        data['pos_masks'] = data.pop('pos_masks').shape
+        data['neg_masks'] = data.pop('neg_masks').shape
+        parts = [f"'{k}': {v!r}" for k, v in sorted(data.items())]
+        body = '    ' + ',\n    '.join(parts)
+        return '{\n' + body + '\n}'
+
+    @property
+    def info(self) -> dict:
+        """Returns a dictionary of info about the object."""
+        return {
+            'pos_inds': self.pos_inds,
+            'neg_inds': self.neg_inds,
+            'pos_masks': self.pos_masks,
+            'neg_masks': self.neg_masks,
+            'pos_is_gt': self.pos_is_gt,
+            'num_gts': self.num_gts,
+            'pos_assigned_gt_inds': self.pos_assigned_gt_inds,
+        }
diff --git a/mmdetection/mmdet/models/task_modules/samplers/multi_instance_random_sampler.py b/mmdetection/mmdet/models/task_modules/samplers/multi_instance_random_sampler.py
new file mode 100644
index 00000000..8b74054e
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/samplers/multi_instance_random_sampler.py
@@ -0,0 +1,130 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Union
+
+import torch
+from mmengine.structures import InstanceData
+from numpy import ndarray
+from torch import Tensor
+
+from mmdet.registry import TASK_UTILS
+from ..assigners import AssignResult
+from .multi_instance_sampling_result import MultiInstanceSamplingResult
+from .random_sampler import RandomSampler
+
+
+@TASK_UTILS.register_module()
+class MultiInsRandomSampler(RandomSampler):
+    """Random sampler for multi instance.
+
+    Note:
+        Multi-instance means to predict multiple detection boxes with
+        one proposal box. `AssignResult` may assign multiple gt boxes
+        to each proposal box, in this case `RandomSampler` should be
+        replaced by `MultiInsRandomSampler`
+    """
+
+    def _sample_pos(self, assign_result: AssignResult, num_expected: int,
+                    **kwargs) -> Union[Tensor, ndarray]:
+        """Randomly sample some positive samples.
+
+        Args:
+            assign_result (:obj:`AssignResult`): Bbox assigning results.
+            num_expected (int): The number of expected positive samples
+
+        Returns:
+            Tensor or ndarray: sampled indices.
+        """
+        pos_inds = torch.nonzero(
+            assign_result.labels[:, 0] > 0, as_tuple=False)
+        if pos_inds.numel() != 0:
+            pos_inds = pos_inds.squeeze(1)
+        if pos_inds.numel() <= num_expected:
+            return pos_inds
+        else:
+            return self.random_choice(pos_inds, num_expected)
+
+    def _sample_neg(self, assign_result: AssignResult, num_expected: int,
+                    **kwargs) -> Union[Tensor, ndarray]:
+        """Randomly sample some negative samples.
+
+        Args:
+            assign_result (:obj:`AssignResult`): Bbox assigning results.
+            num_expected (int): The number of expected positive samples
+
+        Returns:
+            Tensor or ndarray: sampled indices.
+        """
+        neg_inds = torch.nonzero(
+            assign_result.labels[:, 0] == 0, as_tuple=False)
+        if neg_inds.numel() != 0:
+            neg_inds = neg_inds.squeeze(1)
+        if len(neg_inds) <= num_expected:
+            return neg_inds
+        else:
+            return self.random_choice(neg_inds, num_expected)
+
+    def sample(self, assign_result: AssignResult, pred_instances: InstanceData,
+               gt_instances: InstanceData,
+               **kwargs) -> MultiInstanceSamplingResult:
+        """Sample positive and negative bboxes.
+
+        Args:
+            assign_result (:obj:`AssignResult`): Assigning results from
+                MultiInstanceAssigner.
+            pred_instances (:obj:`InstanceData`): Instances of model
+                predictions. It includes ``priors``, and the priors can
+                be anchors or points, or the bboxes predicted by the
+                previous stage, has shape (n, 4). The bboxes predicted by
+                the current model or stage will be named ``bboxes``,
+                ``labels``, and ``scores``, the same as the ``InstanceData``
+                in other places.
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes``, with shape (k, 4),
+                and ``labels``, with shape (k, ).
+
+        Returns:
+            :obj:`MultiInstanceSamplingResult`: Sampling result.
+        """
+
+        assert 'batch_gt_instances_ignore' in kwargs, \
+            'batch_gt_instances_ignore is necessary for MultiInsRandomSampler'
+
+        gt_bboxes = gt_instances.bboxes
+        ignore_bboxes = kwargs['batch_gt_instances_ignore'].bboxes
+        gt_and_ignore_bboxes = torch.cat([gt_bboxes, ignore_bboxes], dim=0)
+        priors = pred_instances.priors
+        if len(priors.shape) < 2:
+            priors = priors[None, :]
+        priors = priors[:, :4]
+
+        gt_flags = priors.new_zeros((priors.shape[0], ), dtype=torch.uint8)
+        priors = torch.cat([priors, gt_and_ignore_bboxes], dim=0)
+        gt_ones = priors.new_ones(
+            gt_and_ignore_bboxes.shape[0], dtype=torch.uint8)
+        gt_flags = torch.cat([gt_flags, gt_ones])
+
+        num_expected_pos = int(self.num * self.pos_fraction)
+        pos_inds = self.pos_sampler._sample_pos(assign_result,
+                                                num_expected_pos)
+        # We found that sampled indices have duplicated items occasionally.
+        # (may be a bug of PyTorch)
+        pos_inds = pos_inds.unique()
+        num_sampled_pos = pos_inds.numel()
+        num_expected_neg = self.num - num_sampled_pos
+        if self.neg_pos_ub >= 0:
+            _pos = max(1, num_sampled_pos)
+            neg_upper_bound = int(self.neg_pos_ub * _pos)
+            if num_expected_neg > neg_upper_bound:
+                num_expected_neg = neg_upper_bound
+        neg_inds = self.neg_sampler._sample_neg(assign_result,
+                                                num_expected_neg)
+        neg_inds = neg_inds.unique()
+
+        sampling_result = MultiInstanceSamplingResult(
+            pos_inds=pos_inds,
+            neg_inds=neg_inds,
+            priors=priors,
+            gt_and_ignore_bboxes=gt_and_ignore_bboxes,
+            assign_result=assign_result,
+            gt_flags=gt_flags)
+        return sampling_result
diff --git a/mmdetection/mmdet/models/task_modules/samplers/multi_instance_sampling_result.py b/mmdetection/mmdet/models/task_modules/samplers/multi_instance_sampling_result.py
new file mode 100644
index 00000000..438a0aa9
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/samplers/multi_instance_sampling_result.py
@@ -0,0 +1,56 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from torch import Tensor
+
+from ..assigners import AssignResult
+from .sampling_result import SamplingResult
+
+
+class MultiInstanceSamplingResult(SamplingResult):
+    """Bbox sampling result. Further encapsulation of SamplingResult. Three
+    attributes neg_assigned_gt_inds, neg_gt_labels, and neg_gt_bboxes have been
+    added for SamplingResult.
+
+    Args:
+        pos_inds (Tensor): Indices of positive samples.
+        neg_inds (Tensor): Indices of negative samples.
+        priors (Tensor): The priors can be anchors or points,
+            or the bboxes predicted by the previous stage.
+        gt_and_ignore_bboxes (Tensor): Ground truth and ignore bboxes.
+        assign_result (:obj:`AssignResult`): Assigning results.
+        gt_flags (Tensor): The Ground truth flags.
+        avg_factor_with_neg (bool):  If True, ``avg_factor`` equal to
+            the number of total priors; Otherwise, it is the number of
+            positive priors. Defaults to True.
+    """
+
+    def __init__(self,
+                 pos_inds: Tensor,
+                 neg_inds: Tensor,
+                 priors: Tensor,
+                 gt_and_ignore_bboxes: Tensor,
+                 assign_result: AssignResult,
+                 gt_flags: Tensor,
+                 avg_factor_with_neg: bool = True) -> None:
+        self.neg_assigned_gt_inds = assign_result.gt_inds[neg_inds]
+        self.neg_gt_labels = assign_result.labels[neg_inds]
+
+        if gt_and_ignore_bboxes.numel() == 0:
+            self.neg_gt_bboxes = torch.empty_like(gt_and_ignore_bboxes).view(
+                -1, 4)
+        else:
+            if len(gt_and_ignore_bboxes.shape) < 2:
+                gt_and_ignore_bboxes = gt_and_ignore_bboxes.view(-1, 4)
+            self.neg_gt_bboxes = gt_and_ignore_bboxes[
+                self.neg_assigned_gt_inds.long(), :]
+
+        # To resist the minus 1 operation in `SamplingResult.init()`.
+        assign_result.gt_inds += 1
+        super().__init__(
+            pos_inds=pos_inds,
+            neg_inds=neg_inds,
+            priors=priors,
+            gt_bboxes=gt_and_ignore_bboxes,
+            assign_result=assign_result,
+            gt_flags=gt_flags,
+            avg_factor_with_neg=avg_factor_with_neg)
diff --git a/mmdetection/mmdet/models/task_modules/samplers/ohem_sampler.py b/mmdetection/mmdet/models/task_modules/samplers/ohem_sampler.py
new file mode 100644
index 00000000..f478a448
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/samplers/ohem_sampler.py
@@ -0,0 +1,111 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+
+from mmdet.registry import TASK_UTILS
+from mmdet.structures.bbox import bbox2roi
+from .base_sampler import BaseSampler
+
+
+@TASK_UTILS.register_module()
+class OHEMSampler(BaseSampler):
+    r"""Online Hard Example Mining Sampler described in `Training Region-based
+    Object Detectors with Online Hard Example Mining
+    `_.
+    """
+
+    def __init__(self,
+                 num,
+                 pos_fraction,
+                 context,
+                 neg_pos_ub=-1,
+                 add_gt_as_proposals=True,
+                 loss_key='loss_cls',
+                 **kwargs):
+        super(OHEMSampler, self).__init__(num, pos_fraction, neg_pos_ub,
+                                          add_gt_as_proposals)
+        self.context = context
+        if not hasattr(self.context, 'num_stages'):
+            self.bbox_head = self.context.bbox_head
+        else:
+            self.bbox_head = self.context.bbox_head[self.context.current_stage]
+
+        self.loss_key = loss_key
+
+    def hard_mining(self, inds, num_expected, bboxes, labels, feats):
+        with torch.no_grad():
+            rois = bbox2roi([bboxes])
+            if not hasattr(self.context, 'num_stages'):
+                bbox_results = self.context._bbox_forward(feats, rois)
+            else:
+                bbox_results = self.context._bbox_forward(
+                    self.context.current_stage, feats, rois)
+            cls_score = bbox_results['cls_score']
+            loss = self.bbox_head.loss(
+                cls_score=cls_score,
+                bbox_pred=None,
+                rois=rois,
+                labels=labels,
+                label_weights=cls_score.new_ones(cls_score.size(0)),
+                bbox_targets=None,
+                bbox_weights=None,
+                reduction_override='none')[self.loss_key]
+            _, topk_loss_inds = loss.topk(num_expected)
+        return inds[topk_loss_inds]
+
+    def _sample_pos(self,
+                    assign_result,
+                    num_expected,
+                    bboxes=None,
+                    feats=None,
+                    **kwargs):
+        """Sample positive boxes.
+
+        Args:
+            assign_result (:obj:`AssignResult`): Assigned results
+            num_expected (int): Number of expected positive samples
+            bboxes (torch.Tensor, optional): Boxes. Defaults to None.
+            feats (list[torch.Tensor], optional): Multi-level features.
+                Defaults to None.
+
+        Returns:
+            torch.Tensor: Indices  of positive samples
+        """
+        # Sample some hard positive samples
+        pos_inds = torch.nonzero(assign_result.gt_inds > 0, as_tuple=False)
+        if pos_inds.numel() != 0:
+            pos_inds = pos_inds.squeeze(1)
+        if pos_inds.numel() <= num_expected:
+            return pos_inds
+        else:
+            return self.hard_mining(pos_inds, num_expected, bboxes[pos_inds],
+                                    assign_result.labels[pos_inds], feats)
+
+    def _sample_neg(self,
+                    assign_result,
+                    num_expected,
+                    bboxes=None,
+                    feats=None,
+                    **kwargs):
+        """Sample negative boxes.
+
+        Args:
+            assign_result (:obj:`AssignResult`): Assigned results
+            num_expected (int): Number of expected negative samples
+            bboxes (torch.Tensor, optional): Boxes. Defaults to None.
+            feats (list[torch.Tensor], optional): Multi-level features.
+                Defaults to None.
+
+        Returns:
+            torch.Tensor: Indices  of negative samples
+        """
+        # Sample some hard negative samples
+        neg_inds = torch.nonzero(assign_result.gt_inds == 0, as_tuple=False)
+        if neg_inds.numel() != 0:
+            neg_inds = neg_inds.squeeze(1)
+        if len(neg_inds) <= num_expected:
+            return neg_inds
+        else:
+            neg_labels = assign_result.labels.new_empty(
+                neg_inds.size(0)).fill_(self.bbox_head.num_classes)
+            return self.hard_mining(neg_inds, num_expected, bboxes[neg_inds],
+                                    neg_labels, feats)
diff --git a/mmdetection/mmdet/models/task_modules/samplers/pseudo_sampler.py b/mmdetection/mmdet/models/task_modules/samplers/pseudo_sampler.py
new file mode 100644
index 00000000..a8186cc3
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/samplers/pseudo_sampler.py
@@ -0,0 +1,60 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from mmengine.structures import InstanceData
+
+from mmdet.registry import TASK_UTILS
+from ..assigners import AssignResult
+from .base_sampler import BaseSampler
+from .sampling_result import SamplingResult
+
+
+@TASK_UTILS.register_module()
+class PseudoSampler(BaseSampler):
+    """A pseudo sampler that does not do sampling actually."""
+
+    def __init__(self, **kwargs):
+        pass
+
+    def _sample_pos(self, **kwargs):
+        """Sample positive samples."""
+        raise NotImplementedError
+
+    def _sample_neg(self, **kwargs):
+        """Sample negative samples."""
+        raise NotImplementedError
+
+    def sample(self, assign_result: AssignResult, pred_instances: InstanceData,
+               gt_instances: InstanceData, *args, **kwargs):
+        """Directly returns the positive and negative indices  of samples.
+
+        Args:
+            assign_result (:obj:`AssignResult`): Bbox assigning results.
+            pred_instances (:obj:`InstanceData`): Instances of model
+                predictions. It includes ``priors``, and the priors can
+                be anchors, points, or bboxes predicted by the model,
+                shape(n, 4).
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes`` and ``labels``
+                attributes.
+
+        Returns:
+            :obj:`SamplingResult`: sampler results
+        """
+        gt_bboxes = gt_instances.bboxes
+        priors = pred_instances.priors
+
+        pos_inds = torch.nonzero(
+            assign_result.gt_inds > 0, as_tuple=False).squeeze(-1).unique()
+        neg_inds = torch.nonzero(
+            assign_result.gt_inds == 0, as_tuple=False).squeeze(-1).unique()
+
+        gt_flags = priors.new_zeros(priors.shape[0], dtype=torch.uint8)
+        sampling_result = SamplingResult(
+            pos_inds=pos_inds,
+            neg_inds=neg_inds,
+            priors=priors,
+            gt_bboxes=gt_bboxes,
+            assign_result=assign_result,
+            gt_flags=gt_flags,
+            avg_factor_with_neg=False)
+        return sampling_result
diff --git a/mmdetection/mmdet/models/task_modules/samplers/random_sampler.py b/mmdetection/mmdet/models/task_modules/samplers/random_sampler.py
new file mode 100644
index 00000000..fa03665f
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/samplers/random_sampler.py
@@ -0,0 +1,109 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Union
+
+import torch
+from numpy import ndarray
+from torch import Tensor
+
+from mmdet.registry import TASK_UTILS
+from ..assigners import AssignResult
+from .base_sampler import BaseSampler
+
+
+@TASK_UTILS.register_module()
+class RandomSampler(BaseSampler):
+    """Random sampler.
+
+    Args:
+        num (int): Number of samples
+        pos_fraction (float): Fraction of positive samples
+        neg_pos_up (int): Upper bound number of negative and
+            positive samples. Defaults to -1.
+        add_gt_as_proposals (bool): Whether to add ground truth
+            boxes as proposals. Defaults to True.
+    """
+
+    def __init__(self,
+                 num: int,
+                 pos_fraction: float,
+                 neg_pos_ub: int = -1,
+                 add_gt_as_proposals: bool = True,
+                 **kwargs):
+        from .sampling_result import ensure_rng
+        super().__init__(
+            num=num,
+            pos_fraction=pos_fraction,
+            neg_pos_ub=neg_pos_ub,
+            add_gt_as_proposals=add_gt_as_proposals)
+        self.rng = ensure_rng(kwargs.get('rng', None))
+
+    def random_choice(self, gallery: Union[Tensor, ndarray, list],
+                      num: int) -> Union[Tensor, ndarray]:
+        """Random select some elements from the gallery.
+
+        If `gallery` is a Tensor, the returned indices will be a Tensor;
+        If `gallery` is a ndarray or list, the returned indices will be a
+        ndarray.
+
+        Args:
+            gallery (Tensor | ndarray | list): indices pool.
+            num (int): expected sample num.
+
+        Returns:
+            Tensor or ndarray: sampled indices.
+        """
+        assert len(gallery) >= num
+
+        is_tensor = isinstance(gallery, torch.Tensor)
+        if not is_tensor:
+            if torch.cuda.is_available():
+                device = torch.cuda.current_device()
+            else:
+                device = 'cpu'
+            gallery = torch.tensor(gallery, dtype=torch.long, device=device)
+        # This is a temporary fix. We can revert the following code
+        # when PyTorch fixes the abnormal return of torch.randperm.
+        # See: https://github.com/open-mmlab/mmdetection/pull/5014
+        perm = torch.randperm(gallery.numel())[:num].to(device=gallery.device)
+        rand_inds = gallery[perm]
+        if not is_tensor:
+            rand_inds = rand_inds.cpu().numpy()
+        return rand_inds
+
+    def _sample_pos(self, assign_result: AssignResult, num_expected: int,
+                    **kwargs) -> Union[Tensor, ndarray]:
+        """Randomly sample some positive samples.
+
+        Args:
+            assign_result (:obj:`AssignResult`): Bbox assigning results.
+            num_expected (int): The number of expected positive samples
+
+        Returns:
+            Tensor or ndarray: sampled indices.
+        """
+        pos_inds = torch.nonzero(assign_result.gt_inds > 0, as_tuple=False)
+        if pos_inds.numel() != 0:
+            pos_inds = pos_inds.squeeze(1)
+        if pos_inds.numel() <= num_expected:
+            return pos_inds
+        else:
+            return self.random_choice(pos_inds, num_expected)
+
+    def _sample_neg(self, assign_result: AssignResult, num_expected: int,
+                    **kwargs) -> Union[Tensor, ndarray]:
+        """Randomly sample some negative samples.
+
+        Args:
+            assign_result (:obj:`AssignResult`): Bbox assigning results.
+            num_expected (int): The number of expected positive samples
+
+        Returns:
+            Tensor or ndarray: sampled indices.
+        """
+        neg_inds = torch.nonzero(assign_result.gt_inds == 0, as_tuple=False)
+        if neg_inds.numel() != 0:
+            neg_inds = neg_inds.squeeze(1)
+        if len(neg_inds) <= num_expected:
+            return neg_inds
+        else:
+            return self.random_choice(neg_inds, num_expected)
diff --git a/mmdetection/mmdet/models/task_modules/samplers/sampling_result.py b/mmdetection/mmdet/models/task_modules/samplers/sampling_result.py
new file mode 100644
index 00000000..cb510ee6
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/samplers/sampling_result.py
@@ -0,0 +1,240 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+
+import numpy as np
+import torch
+from torch import Tensor
+
+from mmdet.structures.bbox import BaseBoxes, cat_boxes
+from mmdet.utils import util_mixins
+from mmdet.utils.util_random import ensure_rng
+from ..assigners import AssignResult
+
+
+def random_boxes(num=1, scale=1, rng=None):
+    """Simple version of ``kwimage.Boxes.random``
+
+    Returns:
+        Tensor: shape (n, 4) in x1, y1, x2, y2 format.
+
+    References:
+        https://gitlab.kitware.com/computer-vision/kwimage/blob/master/kwimage/structs/boxes.py#L1390
+
+    Example:
+        >>> num = 3
+        >>> scale = 512
+        >>> rng = 0
+        >>> boxes = random_boxes(num, scale, rng)
+        >>> print(boxes)
+        tensor([[280.9925, 278.9802, 308.6148, 366.1769],
+                [216.9113, 330.6978, 224.0446, 456.5878],
+                [405.3632, 196.3221, 493.3953, 270.7942]])
+    """
+    rng = ensure_rng(rng)
+
+    tlbr = rng.rand(num, 4).astype(np.float32)
+
+    tl_x = np.minimum(tlbr[:, 0], tlbr[:, 2])
+    tl_y = np.minimum(tlbr[:, 1], tlbr[:, 3])
+    br_x = np.maximum(tlbr[:, 0], tlbr[:, 2])
+    br_y = np.maximum(tlbr[:, 1], tlbr[:, 3])
+
+    tlbr[:, 0] = tl_x * scale
+    tlbr[:, 1] = tl_y * scale
+    tlbr[:, 2] = br_x * scale
+    tlbr[:, 3] = br_y * scale
+
+    boxes = torch.from_numpy(tlbr)
+    return boxes
+
+
+class SamplingResult(util_mixins.NiceRepr):
+    """Bbox sampling result.
+
+    Args:
+        pos_inds (Tensor): Indices of positive samples.
+        neg_inds (Tensor): Indices of negative samples.
+        priors (Tensor): The priors can be anchors or points,
+            or the bboxes predicted by the previous stage.
+        gt_bboxes (Tensor): Ground truth of bboxes.
+        assign_result (:obj:`AssignResult`): Assigning results.
+        gt_flags (Tensor): The Ground truth flags.
+        avg_factor_with_neg (bool):  If True, ``avg_factor`` equal to
+            the number of total priors; Otherwise, it is the number of
+            positive priors. Defaults to True.
+
+    Example:
+        >>> # xdoctest: +IGNORE_WANT
+        >>> from mmdet.models.task_modules.samplers.sampling_result import *  # NOQA
+        >>> self = SamplingResult.random(rng=10)
+        >>> print(f'self = {self}')
+        self = 
+    """
+
+    def __init__(self,
+                 pos_inds: Tensor,
+                 neg_inds: Tensor,
+                 priors: Tensor,
+                 gt_bboxes: Tensor,
+                 assign_result: AssignResult,
+                 gt_flags: Tensor,
+                 avg_factor_with_neg: bool = True) -> None:
+        self.pos_inds = pos_inds
+        self.neg_inds = neg_inds
+        self.num_pos = max(pos_inds.numel(), 1)
+        self.num_neg = max(neg_inds.numel(), 1)
+        self.avg_factor_with_neg = avg_factor_with_neg
+        self.avg_factor = self.num_pos + self.num_neg \
+            if avg_factor_with_neg else self.num_pos
+        self.pos_priors = priors[pos_inds]
+        self.neg_priors = priors[neg_inds]
+        self.pos_is_gt = gt_flags[pos_inds]
+
+        self.num_gts = gt_bboxes.shape[0]
+        self.pos_assigned_gt_inds = assign_result.gt_inds[pos_inds] - 1
+        self.pos_gt_labels = assign_result.labels[pos_inds]
+        box_dim = gt_bboxes.box_dim if isinstance(gt_bboxes, BaseBoxes) else 4
+        if gt_bboxes.numel() == 0:
+            # hack for index error case
+            assert self.pos_assigned_gt_inds.numel() == 0
+            self.pos_gt_bboxes = gt_bboxes.view(-1, box_dim)
+        else:
+            if len(gt_bboxes.shape) < 2:
+                gt_bboxes = gt_bboxes.view(-1, box_dim)
+            self.pos_gt_bboxes = gt_bboxes[self.pos_assigned_gt_inds.long()]
+
+    @property
+    def priors(self):
+        """torch.Tensor: concatenated positive and negative priors"""
+        return cat_boxes([self.pos_priors, self.neg_priors])
+
+    @property
+    def bboxes(self):
+        """torch.Tensor: concatenated positive and negative boxes"""
+        warnings.warn('DeprecationWarning: bboxes is deprecated, '
+                      'please use "priors" instead')
+        return self.priors
+
+    @property
+    def pos_bboxes(self):
+        warnings.warn('DeprecationWarning: pos_bboxes is deprecated, '
+                      'please use "pos_priors" instead')
+        return self.pos_priors
+
+    @property
+    def neg_bboxes(self):
+        warnings.warn('DeprecationWarning: neg_bboxes is deprecated, '
+                      'please use "neg_priors" instead')
+        return self.neg_priors
+
+    def to(self, device):
+        """Change the device of the data inplace.
+
+        Example:
+            >>> self = SamplingResult.random()
+            >>> print(f'self = {self.to(None)}')
+            >>> # xdoctest: +REQUIRES(--gpu)
+            >>> print(f'self = {self.to(0)}')
+        """
+        _dict = self.__dict__
+        for key, value in _dict.items():
+            if isinstance(value, (torch.Tensor, BaseBoxes)):
+                _dict[key] = value.to(device)
+        return self
+
+    def __nice__(self):
+        data = self.info.copy()
+        data['pos_priors'] = data.pop('pos_priors').shape
+        data['neg_priors'] = data.pop('neg_priors').shape
+        parts = [f"'{k}': {v!r}" for k, v in sorted(data.items())]
+        body = '    ' + ',\n    '.join(parts)
+        return '{\n' + body + '\n}'
+
+    @property
+    def info(self):
+        """Returns a dictionary of info about the object."""
+        return {
+            'pos_inds': self.pos_inds,
+            'neg_inds': self.neg_inds,
+            'pos_priors': self.pos_priors,
+            'neg_priors': self.neg_priors,
+            'pos_is_gt': self.pos_is_gt,
+            'num_gts': self.num_gts,
+            'pos_assigned_gt_inds': self.pos_assigned_gt_inds,
+            'num_pos': self.num_pos,
+            'num_neg': self.num_neg,
+            'avg_factor': self.avg_factor
+        }
+
+    @classmethod
+    def random(cls, rng=None, **kwargs):
+        """
+        Args:
+            rng (None | int | numpy.random.RandomState): seed or state.
+            kwargs (keyword arguments):
+                - num_preds: Number of predicted boxes.
+                - num_gts: Number of true boxes.
+                - p_ignore (float): Probability of a predicted box assigned to
+                    an ignored truth.
+                - p_assigned (float): probability of a predicted box not being
+                    assigned.
+
+        Returns:
+            :obj:`SamplingResult`: Randomly generated sampling result.
+
+        Example:
+            >>> from mmdet.models.task_modules.samplers.sampling_result import *  # NOQA
+            >>> self = SamplingResult.random()
+            >>> print(self.__dict__)
+        """
+        from mmengine.structures import InstanceData
+
+        from mmdet.models.task_modules.assigners import AssignResult
+        from mmdet.models.task_modules.samplers import RandomSampler
+        rng = ensure_rng(rng)
+
+        # make probabilistic?
+        num = 32
+        pos_fraction = 0.5
+        neg_pos_ub = -1
+
+        assign_result = AssignResult.random(rng=rng, **kwargs)
+
+        # Note we could just compute an assignment
+        priors = random_boxes(assign_result.num_preds, rng=rng)
+        gt_bboxes = random_boxes(assign_result.num_gts, rng=rng)
+        gt_labels = torch.randint(
+            0, 5, (assign_result.num_gts, ), dtype=torch.long)
+
+        pred_instances = InstanceData()
+        pred_instances.priors = priors
+
+        gt_instances = InstanceData()
+        gt_instances.bboxes = gt_bboxes
+        gt_instances.labels = gt_labels
+
+        add_gt_as_proposals = True
+
+        sampler = RandomSampler(
+            num,
+            pos_fraction,
+            neg_pos_ub=neg_pos_ub,
+            add_gt_as_proposals=add_gt_as_proposals,
+            rng=rng)
+        self = sampler.sample(
+            assign_result=assign_result,
+            pred_instances=pred_instances,
+            gt_instances=gt_instances)
+        return self
diff --git a/mmdetection/mmdet/models/task_modules/samplers/score_hlr_sampler.py b/mmdetection/mmdet/models/task_modules/samplers/score_hlr_sampler.py
new file mode 100644
index 00000000..0227585b
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/samplers/score_hlr_sampler.py
@@ -0,0 +1,290 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Union
+
+import torch
+from mmcv.ops import nms_match
+from mmengine.structures import InstanceData
+from numpy import ndarray
+from torch import Tensor
+
+from mmdet.registry import TASK_UTILS
+from mmdet.structures.bbox import bbox2roi
+from ..assigners import AssignResult
+from .base_sampler import BaseSampler
+from .sampling_result import SamplingResult
+
+
+@TASK_UTILS.register_module()
+class ScoreHLRSampler(BaseSampler):
+    r"""Importance-based Sample Reweighting (ISR_N), described in `Prime Sample
+    Attention in Object Detection `_.
+
+    Score hierarchical local rank (HLR) differentiates with RandomSampler in
+    negative part. It firstly computes Score-HLR in a two-step way,
+    then linearly maps score hlr to the loss weights.
+
+    Args:
+        num (int): Total number of sampled RoIs.
+        pos_fraction (float): Fraction of positive samples.
+        context (:obj:`BaseRoIHead`): RoI head that the sampler belongs to.
+        neg_pos_ub (int): Upper bound of the ratio of num negative to num
+            positive, -1 means no upper bound. Defaults to -1.
+        add_gt_as_proposals (bool): Whether to add ground truth as proposals.
+            Defaults to True.
+        k (float): Power of the non-linear mapping. Defaults to 0.5
+        bias (float): Shift of the non-linear mapping. Defaults to 0.
+        score_thr (float): Minimum score that a negative sample is to be
+            considered as valid bbox. Defaults to 0.05.
+        iou_thr (float): IoU threshold for NMS match. Defaults to 0.5.
+    """
+
+    def __init__(self,
+                 num: int,
+                 pos_fraction: float,
+                 context,
+                 neg_pos_ub: int = -1,
+                 add_gt_as_proposals: bool = True,
+                 k: float = 0.5,
+                 bias: float = 0,
+                 score_thr: float = 0.05,
+                 iou_thr: float = 0.5,
+                 **kwargs) -> None:
+        super().__init__(
+            num=num,
+            pos_fraction=pos_fraction,
+            neg_pos_ub=neg_pos_ub,
+            add_gt_as_proposals=add_gt_as_proposals)
+        self.k = k
+        self.bias = bias
+        self.score_thr = score_thr
+        self.iou_thr = iou_thr
+        self.context = context
+        # context of cascade detectors is a list, so distinguish them here.
+        if not hasattr(context, 'num_stages'):
+            self.bbox_roi_extractor = context.bbox_roi_extractor
+            self.bbox_head = context.bbox_head
+            self.with_shared_head = context.with_shared_head
+            if self.with_shared_head:
+                self.shared_head = context.shared_head
+        else:
+            self.bbox_roi_extractor = context.bbox_roi_extractor[
+                context.current_stage]
+            self.bbox_head = context.bbox_head[context.current_stage]
+
+    @staticmethod
+    def random_choice(gallery: Union[Tensor, ndarray, list],
+                      num: int) -> Union[Tensor, ndarray]:
+        """Randomly select some elements from the gallery.
+
+        If `gallery` is a Tensor, the returned indices will be a Tensor;
+        If `gallery` is a ndarray or list, the returned indices will be a
+        ndarray.
+
+        Args:
+            gallery (Tensor or ndarray or list): indices pool.
+            num (int): expected sample num.
+
+        Returns:
+            Tensor or ndarray: sampled indices.
+        """
+        assert len(gallery) >= num
+
+        is_tensor = isinstance(gallery, torch.Tensor)
+        if not is_tensor:
+            if torch.cuda.is_available():
+                device = torch.cuda.current_device()
+            else:
+                device = 'cpu'
+            gallery = torch.tensor(gallery, dtype=torch.long, device=device)
+        perm = torch.randperm(gallery.numel(), device=gallery.device)[:num]
+        rand_inds = gallery[perm]
+        if not is_tensor:
+            rand_inds = rand_inds.cpu().numpy()
+        return rand_inds
+
+    def _sample_pos(self, assign_result: AssignResult, num_expected: int,
+                    **kwargs) -> Union[Tensor, ndarray]:
+        """Randomly sample some positive samples.
+
+        Args:
+            assign_result (:obj:`AssignResult`): Bbox assigning results.
+            num_expected (int): The number of expected positive samples
+
+        Returns:
+            Tensor or ndarray: sampled indices.
+        """
+        pos_inds = torch.nonzero(assign_result.gt_inds > 0).flatten()
+        if pos_inds.numel() <= num_expected:
+            return pos_inds
+        else:
+            return self.random_choice(pos_inds, num_expected)
+
+    def _sample_neg(self, assign_result: AssignResult, num_expected: int,
+                    bboxes: Tensor, feats: Tensor,
+                    **kwargs) -> Union[Tensor, ndarray]:
+        """Sample negative samples.
+
+        Score-HLR sampler is done in the following steps:
+        1. Take the maximum positive score prediction of each negative samples
+            as s_i.
+        2. Filter out negative samples whose s_i <= score_thr, the left samples
+            are called valid samples.
+        3. Use NMS-Match to divide valid samples into different groups,
+            samples in the same group will greatly overlap with each other
+        4. Rank the matched samples in two-steps to get Score-HLR.
+            (1) In the same group, rank samples with their scores.
+            (2) In the same score rank across different groups,
+                rank samples with their scores again.
+        5. Linearly map Score-HLR to the final label weights.
+
+        Args:
+            assign_result (:obj:`AssignResult`): result of assigner.
+            num_expected (int): Expected number of samples.
+            bboxes (Tensor): bbox to be sampled.
+            feats (Tensor): Features come from FPN.
+
+        Returns:
+            Tensor or ndarray: sampled indices.
+        """
+        neg_inds = torch.nonzero(assign_result.gt_inds == 0).flatten()
+        num_neg = neg_inds.size(0)
+        if num_neg == 0:
+            return neg_inds, None
+        with torch.no_grad():
+            neg_bboxes = bboxes[neg_inds]
+            neg_rois = bbox2roi([neg_bboxes])
+            bbox_result = self.context._bbox_forward(feats, neg_rois)
+            cls_score, bbox_pred = bbox_result['cls_score'], bbox_result[
+                'bbox_pred']
+
+            ori_loss = self.bbox_head.loss(
+                cls_score=cls_score,
+                bbox_pred=None,
+                rois=None,
+                labels=neg_inds.new_full((num_neg, ),
+                                         self.bbox_head.num_classes),
+                label_weights=cls_score.new_ones(num_neg),
+                bbox_targets=None,
+                bbox_weights=None,
+                reduction_override='none')['loss_cls']
+
+            # filter out samples with the max score lower than score_thr
+            max_score, argmax_score = cls_score.softmax(-1)[:, :-1].max(-1)
+            valid_inds = (max_score > self.score_thr).nonzero().view(-1)
+            invalid_inds = (max_score <= self.score_thr).nonzero().view(-1)
+            num_valid = valid_inds.size(0)
+            num_invalid = invalid_inds.size(0)
+
+            num_expected = min(num_neg, num_expected)
+            num_hlr = min(num_valid, num_expected)
+            num_rand = num_expected - num_hlr
+            if num_valid > 0:
+                valid_rois = neg_rois[valid_inds]
+                valid_max_score = max_score[valid_inds]
+                valid_argmax_score = argmax_score[valid_inds]
+                valid_bbox_pred = bbox_pred[valid_inds]
+
+                # valid_bbox_pred shape: [num_valid, #num_classes, 4]
+                valid_bbox_pred = valid_bbox_pred.view(
+                    valid_bbox_pred.size(0), -1, 4)
+                selected_bbox_pred = valid_bbox_pred[range(num_valid),
+                                                     valid_argmax_score]
+                pred_bboxes = self.bbox_head.bbox_coder.decode(
+                    valid_rois[:, 1:], selected_bbox_pred)
+                pred_bboxes_with_score = torch.cat(
+                    [pred_bboxes, valid_max_score[:, None]], -1)
+                group = nms_match(pred_bboxes_with_score, self.iou_thr)
+
+                # imp: importance
+                imp = cls_score.new_zeros(num_valid)
+                for g in group:
+                    g_score = valid_max_score[g]
+                    # g_score has already sorted
+                    rank = g_score.new_tensor(range(g_score.size(0)))
+                    imp[g] = num_valid - rank + g_score
+                _, imp_rank_inds = imp.sort(descending=True)
+                _, imp_rank = imp_rank_inds.sort()
+                hlr_inds = imp_rank_inds[:num_expected]
+
+                if num_rand > 0:
+                    rand_inds = torch.randperm(num_invalid)[:num_rand]
+                    select_inds = torch.cat(
+                        [valid_inds[hlr_inds], invalid_inds[rand_inds]])
+                else:
+                    select_inds = valid_inds[hlr_inds]
+
+                neg_label_weights = cls_score.new_ones(num_expected)
+
+                up_bound = max(num_expected, num_valid)
+                imp_weights = (up_bound -
+                               imp_rank[hlr_inds].float()) / up_bound
+                neg_label_weights[:num_hlr] = imp_weights
+                neg_label_weights[num_hlr:] = imp_weights.min()
+                neg_label_weights = (self.bias +
+                                     (1 - self.bias) * neg_label_weights).pow(
+                                         self.k)
+                ori_selected_loss = ori_loss[select_inds]
+                new_loss = ori_selected_loss * neg_label_weights
+                norm_ratio = ori_selected_loss.sum() / new_loss.sum()
+                neg_label_weights *= norm_ratio
+            else:
+                neg_label_weights = cls_score.new_ones(num_expected)
+                select_inds = torch.randperm(num_neg)[:num_expected]
+
+            return neg_inds[select_inds], neg_label_weights
+
+    def sample(self, assign_result: AssignResult, pred_instances: InstanceData,
+               gt_instances: InstanceData, **kwargs) -> SamplingResult:
+        """Sample positive and negative bboxes.
+
+        This is a simple implementation of bbox sampling given candidates,
+        assigning results and ground truth bboxes.
+
+        Args:
+            assign_result (:obj:`AssignResult`): Assigning results.
+            pred_instances (:obj:`InstanceData`): Instances of model
+                predictions. It includes ``priors``, and the priors can
+                be anchors or points, or the bboxes predicted by the
+                previous stage, has shape (n, 4). The bboxes predicted by
+                the current model or stage will be named ``bboxes``,
+                ``labels``, and ``scores``, the same as the ``InstanceData``
+                in other places.
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes``, with shape (k, 4),
+                and ``labels``, with shape (k, ).
+
+        Returns:
+            :obj:`SamplingResult`: Sampling result.
+        """
+        gt_bboxes = gt_instances.bboxes
+        priors = pred_instances.priors
+        gt_labels = gt_instances.labels
+
+        gt_flags = priors.new_zeros((priors.shape[0], ), dtype=torch.uint8)
+        if self.add_gt_as_proposals and len(gt_bboxes) > 0:
+            priors = torch.cat([gt_bboxes, priors], dim=0)
+            assign_result.add_gt_(gt_labels)
+            gt_ones = priors.new_ones(gt_bboxes.shape[0], dtype=torch.uint8)
+            gt_flags = torch.cat([gt_ones, gt_flags])
+
+        num_expected_pos = int(self.num * self.pos_fraction)
+        pos_inds = self.pos_sampler._sample_pos(
+            assign_result, num_expected_pos, bboxes=priors, **kwargs)
+        num_sampled_pos = pos_inds.numel()
+        num_expected_neg = self.num - num_sampled_pos
+        if self.neg_pos_ub >= 0:
+            _pos = max(1, num_sampled_pos)
+            neg_upper_bound = int(self.neg_pos_ub * _pos)
+            if num_expected_neg > neg_upper_bound:
+                num_expected_neg = neg_upper_bound
+        neg_inds, neg_label_weights = self.neg_sampler._sample_neg(
+            assign_result, num_expected_neg, bboxes=priors, **kwargs)
+
+        sampling_result = SamplingResult(
+            pos_inds=pos_inds,
+            neg_inds=neg_inds,
+            priors=priors,
+            gt_bboxes=gt_bboxes,
+            assign_result=assign_result,
+            gt_flags=gt_flags)
+        return sampling_result, neg_label_weights
diff --git a/mmdetection/mmdet/models/task_modules/tracking/__init__.py b/mmdetection/mmdet/models/task_modules/tracking/__init__.py
new file mode 100644
index 00000000..57a86d73
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/tracking/__init__.py
@@ -0,0 +1,11 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .aflink import AppearanceFreeLink
+from .camera_motion_compensation import CameraMotionCompensation
+from .interpolation import InterpolateTracklets
+from .kalman_filter import KalmanFilter
+from .similarity import embed_similarity
+
+__all__ = [
+    'KalmanFilter', 'InterpolateTracklets', 'embed_similarity',
+    'AppearanceFreeLink', 'CameraMotionCompensation'
+]
diff --git a/mmdetection/mmdet/models/task_modules/tracking/aflink.py b/mmdetection/mmdet/models/task_modules/tracking/aflink.py
new file mode 100644
index 00000000..52461067
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/tracking/aflink.py
@@ -0,0 +1,281 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from collections import defaultdict
+from typing import Tuple
+
+import numpy as np
+import torch
+from mmengine.model import BaseModule
+from mmengine.runner.checkpoint import load_checkpoint
+from scipy.optimize import linear_sum_assignment
+from torch import Tensor, nn
+
+from mmdet.registry import TASK_UTILS
+
+INFINITY = 1e5
+
+
+class TemporalBlock(BaseModule):
+    """The temporal block of AFLink model.
+
+    Args:
+        in_channel (int): the dimension of the input channels.
+        out_channel (int): the dimension of the output channels.
+    """
+
+    def __init__(self,
+                 in_channel: int,
+                 out_channel: int,
+                 kernel_size: tuple = (7, 1)):
+        super(TemporalBlock, self).__init__()
+        self.conv = nn.Conv2d(in_channel, out_channel, kernel_size, bias=False)
+        self.relu = nn.ReLU(inplace=True)
+        self.bnf = nn.BatchNorm1d(out_channel)
+        self.bnx = nn.BatchNorm1d(out_channel)
+        self.bny = nn.BatchNorm1d(out_channel)
+
+    def bn(self, x: Tensor) -> Tensor:
+        x[:, :, :, 0] = self.bnf(x[:, :, :, 0])
+        x[:, :, :, 1] = self.bnx(x[:, :, :, 1])
+        x[:, :, :, 2] = self.bny(x[:, :, :, 2])
+        return x
+
+    def forward(self, x: Tensor) -> Tensor:
+        x = self.conv(x)
+        x = self.bn(x)
+        x = self.relu(x)
+        return x
+
+
+class FusionBlock(BaseModule):
+    """The fusion block of AFLink model.
+
+    Args:
+        in_channel (int): the dimension of the input channels.
+        out_channel (int): the dimension of the output channels.
+    """
+
+    def __init__(self, in_channel: int, out_channel: int):
+        super(FusionBlock, self).__init__()
+        self.conv = nn.Conv2d(in_channel, out_channel, (1, 3), bias=False)
+        self.bn = nn.BatchNorm2d(out_channel)
+        self.relu = nn.ReLU(inplace=True)
+
+    def forward(self, x: Tensor) -> Tensor:
+        x = self.conv(x)
+        x = self.bn(x)
+        x = self.relu(x)
+        return x
+
+
+class Classifier(BaseModule):
+    """The classifier of AFLink model.
+
+    Args:
+        in_channel (int): the dimension of the input channels.
+    """
+
+    def __init__(self, in_channel: int, out_channel: int):
+        super(Classifier, self).__init__()
+        self.fc1 = nn.Linear(in_channel * 2, in_channel // 2)
+        self.relu = nn.ReLU(inplace=True)
+        self.fc2 = nn.Linear(in_channel // 2, out_channel)
+
+    def forward(self, x1: Tensor, x2: Tensor) -> Tensor:
+        x = torch.cat((x1, x2), dim=1)
+        x = self.fc1(x)
+        x = self.relu(x)
+        x = self.fc2(x)
+        return x
+
+
+class AFLinkModel(BaseModule):
+    """Appearance-Free Link Model."""
+
+    def __init__(self,
+                 temporal_module_channels: list = [1, 32, 64, 128, 256],
+                 fusion_module_channels: list = [256, 256],
+                 classifier_channels: list = [256, 2]):
+        super(AFLinkModel, self).__init__()
+        self.TemporalModule_1 = nn.Sequential(*[
+            TemporalBlock(temporal_module_channels[i],
+                          temporal_module_channels[i + 1])
+            for i in range(len(temporal_module_channels) - 1)
+        ])
+
+        self.TemporalModule_2 = nn.Sequential(*[
+            TemporalBlock(temporal_module_channels[i],
+                          temporal_module_channels[i + 1])
+            for i in range(len(temporal_module_channels) - 1)
+        ])
+
+        self.FusionBlock_1 = FusionBlock(*fusion_module_channels)
+        self.FusionBlock_2 = FusionBlock(*fusion_module_channels)
+
+        self.pooling = nn.AdaptiveAvgPool2d((1, 1))
+        self.classifier = Classifier(*classifier_channels)
+
+    def forward(self, x1: Tensor, x2: Tensor) -> Tensor:
+        assert not self.training, 'Only testing is supported for AFLink.'
+        x1 = x1[:, :, :, :3]
+        x2 = x2[:, :, :, :3]
+        x1 = self.TemporalModule_1(x1)  # [B,1,30,3] -> [B,256,6,3]
+        x2 = self.TemporalModule_2(x2)
+        x1 = self.FusionBlock_1(x1)
+        x2 = self.FusionBlock_2(x2)
+        x1 = self.pooling(x1).squeeze(-1).squeeze(-1)
+        x2 = self.pooling(x2).squeeze(-1).squeeze(-1)
+        y = self.classifier(x1, x2)
+        y = torch.softmax(y, dim=1)[0, 1]
+        return y
+
+
+@TASK_UTILS.register_module()
+class AppearanceFreeLink(BaseModule):
+    """Appearance-Free Link method.
+
+    This method is proposed in
+    "StrongSORT: Make DeepSORT Great Again"
+    `StrongSORT`_.
+
+    Args:
+        checkpoint (str): Checkpoint path.
+        temporal_threshold (tuple, optional): The temporal constraint
+            for tracklets association. Defaults to (0, 30).
+        spatial_threshold (int, optional): The spatial constraint for
+            tracklets association. Defaults to 75.
+        confidence_threshold (float, optional): The minimum confidence
+            threshold for tracklets association. Defaults to 0.95.
+    """
+
+    def __init__(self,
+                 checkpoint: str,
+                 temporal_threshold: tuple = (0, 30),
+                 spatial_threshold: int = 75,
+                 confidence_threshold: float = 0.95):
+        super(AppearanceFreeLink, self).__init__()
+        self.temporal_threshold = temporal_threshold
+        self.spatial_threshold = spatial_threshold
+        self.confidence_threshold = confidence_threshold
+
+        self.model = AFLinkModel()
+        if checkpoint:
+            load_checkpoint(self.model, checkpoint)
+        if torch.cuda.is_available():
+            self.model.cuda()
+        self.model.eval()
+
+        self.device = next(self.model.parameters()).device
+        self.fn_l2 = lambda x, y: np.sqrt(x**2 + y**2)
+
+    def data_transform(self,
+                       track1: np.ndarray,
+                       track2: np.ndarray,
+                       length: int = 30) -> Tuple[np.ndarray]:
+        """Data Transformation. This is used to standardize the length of
+        tracks to a unified length. Then perform min-max normalization to the
+        motion embeddings.
+
+        Args:
+            track1 (ndarray): the first track with shape (N,C).
+            track2 (ndarray): the second track with shape (M,C).
+            length (int): the unified length of tracks. Defaults to 30.
+
+        Returns:
+            Tuple[ndarray]: the transformed track1 and track2.
+        """
+        # fill or cut track1
+        length_1 = track1.shape[0]
+        track1 = track1[-length:] if length_1 >= length else \
+            np.pad(track1, ((length - length_1, 0), (0, 0)))
+
+        # fill or cut track1
+        length_2 = track2.shape[0]
+        track2 = track2[:length] if length_2 >= length else \
+            np.pad(track2, ((0, length - length_2), (0, 0)))
+
+        # min-max normalization
+        min_ = np.concatenate((track1, track2), axis=0).min(axis=0)
+        max_ = np.concatenate((track1, track2), axis=0).max(axis=0)
+        subtractor = (max_ + min_) / 2
+        divisor = (max_ - min_) / 2 + 1e-5
+        track1 = (track1 - subtractor) / divisor
+        track2 = (track2 - subtractor) / divisor
+
+        return track1, track2
+
+    def forward(self, pred_tracks: np.ndarray) -> np.ndarray:
+        """Forward function.
+
+        pred_tracks (ndarray): With shape (N, 7). Each row denotes
+            (frame_id, track_id, x1, y1, x2, y2, score).
+
+        Returns:
+            ndarray: The linked tracks with shape (N, 7). Each row denotes
+                (frame_id, track_id, x1, y1, x2, y2, score)
+        """
+        # sort tracks by the frame id
+        pred_tracks = pred_tracks[np.argsort(pred_tracks[:, 0])]
+
+        # gather tracks information
+        id2info = defaultdict(list)
+        for row in pred_tracks:
+            frame_id, track_id, x1, y1, x2, y2 = row[:6]
+            id2info[track_id].append([frame_id, x1, y1, x2 - x1, y2 - y1])
+        id2info = {k: np.array(v) for k, v in id2info.items()}
+        num_track = len(id2info)
+        track_ids = np.array(list(id2info))
+        cost_matrix = np.full((num_track, num_track), INFINITY)
+
+        # compute the cost matrix
+        for i, id_i in enumerate(track_ids):
+            for j, id_j in enumerate(track_ids):
+                if id_i == id_j:
+                    continue
+                info_i, info_j = id2info[id_i], id2info[id_j]
+                frame_i, box_i = info_i[-1][0], info_i[-1][1:3]
+                frame_j, box_j = info_j[0][0], info_j[0][1:3]
+                # temporal constraint
+                if not self.temporal_threshold[0] <= \
+                        frame_j - frame_i <= self.temporal_threshold[1]:
+                    continue
+                # spatial constraint
+                if self.fn_l2(box_i[0] - box_j[0], box_i[1] - box_j[1]) \
+                        > self.spatial_threshold:
+                    continue
+                # confidence constraint
+                track_i, track_j = self.data_transform(info_i, info_j)
+
+                # numpy to torch
+                track_i = torch.tensor(
+                    track_i, dtype=torch.float).to(self.device)
+                track_j = torch.tensor(
+                    track_j, dtype=torch.float).to(self.device)
+                track_i = track_i.unsqueeze(0).unsqueeze(0)
+                track_j = track_j.unsqueeze(0).unsqueeze(0)
+
+                confidence = self.model(track_i,
+                                        track_j).detach().cpu().numpy()
+                if confidence >= self.confidence_threshold:
+                    cost_matrix[i, j] = 1 - confidence
+
+        # linear assignment
+        indices = linear_sum_assignment(cost_matrix)
+        _id2id = dict()  # the temporary assignment results
+        id2id = dict()  # the final assignment results
+        for i, j in zip(indices[0], indices[1]):
+            if cost_matrix[i, j] < INFINITY:
+                _id2id[i] = j
+        for k, v in _id2id.items():
+            if k in id2id:
+                id2id[v] = id2id[k]
+            else:
+                id2id[v] = k
+
+        # link
+        for k, v in id2id.items():
+            pred_tracks[pred_tracks[:, 1] == k, 1] = v
+
+        # deduplicate
+        _, index = np.unique(pred_tracks[:, :2], return_index=True, axis=0)
+
+        return pred_tracks[index]
diff --git a/mmdetection/mmdet/models/task_modules/tracking/camera_motion_compensation.py b/mmdetection/mmdet/models/task_modules/tracking/camera_motion_compensation.py
new file mode 100644
index 00000000..1a629849
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/tracking/camera_motion_compensation.py
@@ -0,0 +1,104 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import cv2
+import numpy as np
+import torch
+from torch import Tensor
+
+from mmdet.registry import TASK_UTILS
+from mmdet.structures.bbox import bbox_cxcyah_to_xyxy, bbox_xyxy_to_cxcyah
+
+
+@TASK_UTILS.register_module()
+class CameraMotionCompensation:
+    """Camera motion compensation.
+
+    Args:
+        warp_mode (str): Warp mode in opencv.
+            Defaults to 'cv2.MOTION_EUCLIDEAN'.
+        num_iters (int): Number of the iterations. Defaults to 50.
+        stop_eps (float): Terminate threshold. Defaults to 0.001.
+    """
+
+    def __init__(self,
+                 warp_mode: str = 'cv2.MOTION_EUCLIDEAN',
+                 num_iters: int = 50,
+                 stop_eps: float = 0.001):
+        self.warp_mode = eval(warp_mode)
+        self.num_iters = num_iters
+        self.stop_eps = stop_eps
+
+    def get_warp_matrix(self, img: np.ndarray, ref_img: np.ndarray) -> Tensor:
+        """Calculate warping matrix between two images."""
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        ref_img = cv2.cvtColor(ref_img, cv2.COLOR_BGR2GRAY)
+
+        warp_matrix = np.eye(2, 3, dtype=np.float32)
+        criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT,
+                    self.num_iters, self.stop_eps)
+        cc, warp_matrix = cv2.findTransformECC(img, ref_img, warp_matrix,
+                                               self.warp_mode, criteria, None,
+                                               1)
+        warp_matrix = torch.from_numpy(warp_matrix)
+        return warp_matrix
+
+    def warp_bboxes(self, bboxes: Tensor, warp_matrix: Tensor) -> Tensor:
+        """Warp bounding boxes according to the warping matrix."""
+        tl, br = bboxes[:, :2], bboxes[:, 2:]
+        tl = torch.cat((tl, torch.ones(tl.shape[0], 1).to(bboxes.device)),
+                       dim=1)
+        br = torch.cat((br, torch.ones(tl.shape[0], 1).to(bboxes.device)),
+                       dim=1)
+        trans_tl = torch.mm(warp_matrix, tl.t()).t()
+        trans_br = torch.mm(warp_matrix, br.t()).t()
+        trans_bboxes = torch.cat((trans_tl, trans_br), dim=1)
+        return trans_bboxes.to(bboxes.device)
+
+    def warp_means(self, means: np.ndarray, warp_matrix: Tensor) -> np.ndarray:
+        """Warp track.mean according to the warping matrix."""
+        cxcyah = torch.from_numpy(means[:, :4]).float()
+        xyxy = bbox_cxcyah_to_xyxy(cxcyah)
+        warped_xyxy = self.warp_bboxes(xyxy, warp_matrix)
+        warped_cxcyah = bbox_xyxy_to_cxcyah(warped_xyxy).numpy()
+        means[:, :4] = warped_cxcyah
+        return means
+
+    def track(self, img: Tensor, ref_img: Tensor, tracks: dict,
+              num_samples: int, frame_id: int, metainfo: dict) -> dict:
+        """Tracking forward."""
+        img = img.squeeze(0).cpu().numpy().transpose((1, 2, 0))
+        ref_img = ref_img.squeeze(0).cpu().numpy().transpose((1, 2, 0))
+        warp_matrix = self.get_warp_matrix(img, ref_img)
+
+        # rescale the warp_matrix due to the `resize` in pipeline
+        scale_factor_h, scale_factor_w = metainfo['scale_factor']
+        warp_matrix[0, 2] = warp_matrix[0, 2] / scale_factor_w
+        warp_matrix[1, 2] = warp_matrix[1, 2] / scale_factor_h
+
+        bboxes = []
+        num_bboxes = []
+        means = []
+        for k, v in tracks.items():
+            if int(v['frame_ids'][-1]) < frame_id - 1:
+                _num = 1
+            else:
+                _num = min(num_samples, len(v.bboxes))
+            num_bboxes.append(_num)
+            bboxes.extend(v.bboxes[-_num:])
+            if len(v.mean) > 0:
+                means.append(v.mean)
+        bboxes = torch.cat(bboxes, dim=0)
+        warped_bboxes = self.warp_bboxes(bboxes, warp_matrix.to(bboxes.device))
+
+        warped_bboxes = torch.split(warped_bboxes, num_bboxes)
+        for b, (k, v) in zip(warped_bboxes, tracks.items()):
+            _num = b.shape[0]
+            b = torch.split(b, [1] * _num)
+            tracks[k].bboxes[-_num:] = b
+
+        if means:
+            means = np.asarray(means)
+            warped_means = self.warp_means(means, warp_matrix)
+            for m, (k, v) in zip(warped_means, tracks.items()):
+                tracks[k].mean = m
+
+        return tracks
diff --git a/mmdetection/mmdet/models/task_modules/tracking/interpolation.py b/mmdetection/mmdet/models/task_modules/tracking/interpolation.py
new file mode 100644
index 00000000..fb6a25af
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/tracking/interpolation.py
@@ -0,0 +1,168 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import numpy as np
+
+try:
+    from sklearn.gaussian_process import GaussianProcessRegressor as GPR
+    from sklearn.gaussian_process.kernels import RBF
+    HAS_SKIKIT_LEARN = True
+except ImportError:
+    HAS_SKIKIT_LEARN = False
+
+from mmdet.registry import TASK_UTILS
+
+
+@TASK_UTILS.register_module()
+class InterpolateTracklets:
+    """Interpolate tracks to make tracks more complete.
+
+    Args:
+        min_num_frames (int, optional): The minimum length of a track that will
+            be interpolated. Defaults to 5.
+        max_num_frames (int, optional): The maximum disconnected length in
+            a track. Defaults to 20.
+        use_gsi (bool, optional): Whether to use the GSI (Gaussian-smoothed
+            interpolation) method. Defaults to False.
+        smooth_tau (int, optional): smoothing parameter in GSI. Defaults to 10.
+    """
+
+    def __init__(self,
+                 min_num_frames: int = 5,
+                 max_num_frames: int = 20,
+                 use_gsi: bool = False,
+                 smooth_tau: int = 10):
+        if not HAS_SKIKIT_LEARN:
+            raise RuntimeError('sscikit-learn is not installed,\
+                 please install it by: pip install scikit-learn')
+        self.min_num_frames = min_num_frames
+        self.max_num_frames = max_num_frames
+        self.use_gsi = use_gsi
+        self.smooth_tau = smooth_tau
+
+    def _interpolate_track(self,
+                           track: np.ndarray,
+                           track_id: int,
+                           max_num_frames: int = 20) -> np.ndarray:
+        """Interpolate a track linearly to make the track more complete.
+
+        This function is proposed in
+        "ByteTrack: Multi-Object Tracking by Associating Every Detection Box."
+        `ByteTrack`_.
+
+        Args:
+            track (ndarray): With shape (N, 7). Each row denotes
+                (frame_id, track_id, x1, y1, x2, y2, score).
+            max_num_frames (int, optional): The maximum disconnected length in
+                the track. Defaults to 20.
+
+        Returns:
+            ndarray: The interpolated track with shape (N, 7). Each row denotes
+                (frame_id, track_id, x1, y1, x2, y2, score)
+        """
+        assert (track[:, 1] == track_id).all(), \
+            'The track id should not changed when interpolate a track.'
+
+        frame_ids = track[:, 0]
+        interpolated_track = np.zeros((0, 7))
+        # perform interpolation for the disconnected frames in the track.
+        for i in np.where(np.diff(frame_ids) > 1)[0]:
+            left_frame_id = frame_ids[i]
+            right_frame_id = frame_ids[i + 1]
+            num_disconnected_frames = int(right_frame_id - left_frame_id)
+
+            if 1 < num_disconnected_frames < max_num_frames:
+                left_bbox = track[i, 2:6]
+                right_bbox = track[i + 1, 2:6]
+
+                # perform interpolation for two adjacent tracklets.
+                for j in range(1, num_disconnected_frames):
+                    cur_bbox = j / (num_disconnected_frames) * (
+                        right_bbox - left_bbox) + left_bbox
+                    cur_result = np.ones((7, ))
+                    cur_result[0] = j + left_frame_id
+                    cur_result[1] = track_id
+                    cur_result[2:6] = cur_bbox
+
+                    interpolated_track = np.concatenate(
+                        (interpolated_track, cur_result[None]), axis=0)
+
+        interpolated_track = np.concatenate((track, interpolated_track),
+                                            axis=0)
+        return interpolated_track
+
+    def gaussian_smoothed_interpolation(self,
+                                        track: np.ndarray,
+                                        smooth_tau: int = 10) -> np.ndarray:
+        """Gaussian-Smoothed Interpolation.
+
+        This function is proposed in
+        "StrongSORT: Make DeepSORT Great Again"
+        `StrongSORT`_.
+
+        Args:
+            track (ndarray): With shape (N, 7). Each row denotes
+                (frame_id, track_id, x1, y1, x2, y2, score).
+            smooth_tau (int, optional): smoothing parameter in GSI.
+                Defaults to 10.
+
+        Returns:
+            ndarray: The interpolated tracks with shape (N, 7). Each row
+                denotes (frame_id, track_id, x1, y1, x2, y2, score)
+        """
+        len_scale = np.clip(smooth_tau * np.log(smooth_tau**3 / len(track)),
+                            smooth_tau**-1, smooth_tau**2)
+        gpr = GPR(RBF(len_scale, 'fixed'))
+        t = track[:, 0].reshape(-1, 1)
+        x1 = track[:, 2].reshape(-1, 1)
+        y1 = track[:, 3].reshape(-1, 1)
+        x2 = track[:, 4].reshape(-1, 1)
+        y2 = track[:, 5].reshape(-1, 1)
+        gpr.fit(t, x1)
+        x1_gpr = gpr.predict(t)
+        gpr.fit(t, y1)
+        y1_gpr = gpr.predict(t)
+        gpr.fit(t, x2)
+        x2_gpr = gpr.predict(t)
+        gpr.fit(t, y2)
+        y2_gpr = gpr.predict(t)
+        gsi_track = [[
+            t[i, 0], track[i, 1], x1_gpr[i], y1_gpr[i], x2_gpr[i], y2_gpr[i],
+            track[i, 6]
+        ] for i in range(len(t))]
+        return np.array(gsi_track)
+
+    def forward(self, pred_tracks: np.ndarray) -> np.ndarray:
+        """Forward function.
+
+        pred_tracks (ndarray): With shape (N, 7). Each row denotes
+            (frame_id, track_id, x1, y1, x2, y2, score).
+
+        Returns:
+            ndarray: The interpolated tracks with shape (N, 7). Each row
+            denotes (frame_id, track_id, x1, y1, x2, y2, score).
+        """
+        max_track_id = int(np.max(pred_tracks[:, 1]))
+        min_track_id = int(np.min(pred_tracks[:, 1]))
+
+        # perform interpolation for each track
+        interpolated_tracks = []
+        for track_id in range(min_track_id, max_track_id + 1):
+            inds = pred_tracks[:, 1] == track_id
+            track = pred_tracks[inds]
+            num_frames = len(track)
+            if num_frames <= 2:
+                continue
+
+            if num_frames > self.min_num_frames:
+                interpolated_track = self._interpolate_track(
+                    track, track_id, self.max_num_frames)
+            else:
+                interpolated_track = track
+
+            if self.use_gsi:
+                interpolated_track = self.gaussian_smoothed_interpolation(
+                    interpolated_track, self.smooth_tau)
+
+            interpolated_tracks.append(interpolated_track)
+
+        interpolated_tracks = np.concatenate(interpolated_tracks)
+        return interpolated_tracks[interpolated_tracks[:, 0].argsort()]
diff --git a/mmdetection/mmdet/models/task_modules/tracking/kalman_filter.py b/mmdetection/mmdet/models/task_modules/tracking/kalman_filter.py
new file mode 100644
index 00000000..a8ae1416
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/tracking/kalman_filter.py
@@ -0,0 +1,267 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Tuple
+
+import numpy as np
+import torch
+
+try:
+    import scipy.linalg
+    HAS_SCIPY = True
+except ImportError:
+    HAS_SCIPY = False
+
+from mmdet.registry import TASK_UTILS
+
+
+@TASK_UTILS.register_module()
+class KalmanFilter:
+    """A simple Kalman filter for tracking bounding boxes in image space.
+
+    The implementation is referred to https://github.com/nwojke/deep_sort.
+
+    Args:
+        center_only (bool): If True, distance computation is done with
+            respect to the bounding box center position only.
+            Defaults to False.
+        use_nsa (bool): Whether to use the NSA (Noise Scale Adaptive) Kalman
+            Filter, which adaptively modulates the noise scale according to
+            the quality of detections. More details in
+            https://arxiv.org/abs/2202.11983. Defaults to False.
+    """
+    chi2inv95 = {
+        1: 3.8415,
+        2: 5.9915,
+        3: 7.8147,
+        4: 9.4877,
+        5: 11.070,
+        6: 12.592,
+        7: 14.067,
+        8: 15.507,
+        9: 16.919
+    }
+
+    def __init__(self, center_only: bool = False, use_nsa: bool = False):
+        if not HAS_SCIPY:
+            raise RuntimeError('sscikit-learn is not installed,\
+                 please install it by: pip install scikit-learn')
+        self.center_only = center_only
+        if self.center_only:
+            self.gating_threshold = self.chi2inv95[2]
+        else:
+            self.gating_threshold = self.chi2inv95[4]
+
+        self.use_nsa = use_nsa
+        ndim, dt = 4, 1.
+
+        # Create Kalman filter model matrices.
+        self._motion_mat = np.eye(2 * ndim, 2 * ndim)
+        for i in range(ndim):
+            self._motion_mat[i, ndim + i] = dt
+        self._update_mat = np.eye(ndim, 2 * ndim)
+
+        # Motion and observation uncertainty are chosen relative to the current
+        # state estimate. These weights control the amount of uncertainty in
+        # the model. This is a bit hacky.
+        self._std_weight_position = 1. / 20
+        self._std_weight_velocity = 1. / 160
+
+    def initiate(self, measurement: np.array) -> Tuple[np.array, np.array]:
+        """Create track from unassociated measurement.
+
+        Args:
+            measurement (ndarray):  Bounding box coordinates (x, y, a, h) with
+            center position (x, y), aspect ratio a, and height h.
+
+        Returns:
+             (ndarray, ndarray): Returns the mean vector (8 dimensional) and
+                covariance matrix (8x8 dimensional) of the new track.
+                Unobserved velocities are initialized to 0 mean.
+        """
+        mean_pos = measurement
+        mean_vel = np.zeros_like(mean_pos)
+        mean = np.r_[mean_pos, mean_vel]
+
+        std = [
+            2 * self._std_weight_position * measurement[3],
+            2 * self._std_weight_position * measurement[3], 1e-2,
+            2 * self._std_weight_position * measurement[3],
+            10 * self._std_weight_velocity * measurement[3],
+            10 * self._std_weight_velocity * measurement[3], 1e-5,
+            10 * self._std_weight_velocity * measurement[3]
+        ]
+        covariance = np.diag(np.square(std))
+        return mean, covariance
+
+    def predict(self, mean: np.array,
+                covariance: np.array) -> Tuple[np.array, np.array]:
+        """Run Kalman filter prediction step.
+
+        Args:
+            mean (ndarray): The 8 dimensional mean vector of the object
+                state at the previous time step.
+
+            covariance (ndarray): The 8x8 dimensional covariance matrix
+                of the object state at the previous time step.
+
+        Returns:
+            (ndarray, ndarray): Returns the mean vector and covariance
+                matrix of the predicted state. Unobserved velocities are
+                initialized to 0 mean.
+        """
+        std_pos = [
+            self._std_weight_position * mean[3],
+            self._std_weight_position * mean[3], 1e-2,
+            self._std_weight_position * mean[3]
+        ]
+        std_vel = [
+            self._std_weight_velocity * mean[3],
+            self._std_weight_velocity * mean[3], 1e-5,
+            self._std_weight_velocity * mean[3]
+        ]
+        motion_cov = np.diag(np.square(np.r_[std_pos, std_vel]))
+
+        mean = np.dot(self._motion_mat, mean)
+        covariance = np.linalg.multi_dot(
+            (self._motion_mat, covariance, self._motion_mat.T)) + motion_cov
+
+        return mean, covariance
+
+    def project(self,
+                mean: np.array,
+                covariance: np.array,
+                bbox_score: float = 0.) -> Tuple[np.array, np.array]:
+        """Project state distribution to measurement space.
+
+        Args:
+            mean (ndarray): The state's mean vector (8 dimensional array).
+            covariance (ndarray): The state's covariance matrix (8x8
+                dimensional).
+            bbox_score (float): The confidence score of the bbox.
+                Defaults to 0.
+
+        Returns:
+            (ndarray, ndarray):  Returns the projected mean and covariance
+            matrix of the given state estimate.
+        """
+        std = [
+            self._std_weight_position * mean[3],
+            self._std_weight_position * mean[3], 1e-1,
+            self._std_weight_position * mean[3]
+        ]
+
+        if self.use_nsa:
+            std = [(1 - bbox_score) * x for x in std]
+
+        innovation_cov = np.diag(np.square(std))
+
+        mean = np.dot(self._update_mat, mean)
+        covariance = np.linalg.multi_dot(
+            (self._update_mat, covariance, self._update_mat.T))
+        return mean, covariance + innovation_cov
+
+    def update(self,
+               mean: np.array,
+               covariance: np.array,
+               measurement: np.array,
+               bbox_score: float = 0.) -> Tuple[np.array, np.array]:
+        """Run Kalman filter correction step.
+
+        Args:
+            mean (ndarray): The predicted state's mean vector (8 dimensional).
+            covariance (ndarray): The state's covariance matrix (8x8
+                dimensional).
+            measurement (ndarray): The 4 dimensional measurement vector
+                (x, y, a, h), where (x, y) is the center position, a the
+                aspect ratio, and h the height of the bounding box.
+            bbox_score (float): The confidence score of the bbox.
+                Defaults to 0.
+
+        Returns:
+             (ndarray, ndarray): Returns the measurement-corrected state
+             distribution.
+        """
+        projected_mean, projected_cov = \
+            self.project(mean, covariance, bbox_score)
+
+        chol_factor, lower = scipy.linalg.cho_factor(
+            projected_cov, lower=True, check_finite=False)
+        kalman_gain = scipy.linalg.cho_solve((chol_factor, lower),
+                                             np.dot(covariance,
+                                                    self._update_mat.T).T,
+                                             check_finite=False).T
+        innovation = measurement - projected_mean
+
+        new_mean = mean + np.dot(innovation, kalman_gain.T)
+        new_covariance = covariance - np.linalg.multi_dot(
+            (kalman_gain, projected_cov, kalman_gain.T))
+        return new_mean, new_covariance
+
+    def gating_distance(self,
+                        mean: np.array,
+                        covariance: np.array,
+                        measurements: np.array,
+                        only_position: bool = False) -> np.array:
+        """Compute gating distance between state distribution and measurements.
+
+        A suitable distance threshold can be obtained from `chi2inv95`. If
+        `only_position` is False, the chi-square distribution has 4 degrees of
+        freedom, otherwise 2.
+
+        Args:
+            mean (ndarray): Mean vector over the state distribution (8
+                dimensional).
+            covariance (ndarray): Covariance of the state distribution (8x8
+                dimensional).
+            measurements (ndarray): An Nx4 dimensional matrix of N
+                measurements, each in format (x, y, a, h) where (x, y) is the
+                bounding box center position, a the aspect ratio, and h the
+                height.
+            only_position (bool, optional): If True, distance computation is
+                done with respect to the bounding box center position only.
+                Defaults to False.
+
+        Returns:
+            ndarray: Returns an array of length N, where the i-th element
+            contains the squared Mahalanobis distance between
+            (mean, covariance) and `measurements[i]`.
+        """
+        mean, covariance = self.project(mean, covariance)
+        if only_position:
+            mean, covariance = mean[:2], covariance[:2, :2]
+            measurements = measurements[:, :2]
+
+        cholesky_factor = np.linalg.cholesky(covariance)
+        d = measurements - mean
+        z = scipy.linalg.solve_triangular(
+            cholesky_factor,
+            d.T,
+            lower=True,
+            check_finite=False,
+            overwrite_b=True)
+        squared_maha = np.sum(z * z, axis=0)
+        return squared_maha
+
+    def track(self, tracks: dict,
+              bboxes: torch.Tensor) -> Tuple[dict, np.array]:
+        """Track forward.
+
+        Args:
+            tracks (dict[int:dict]): Track buffer.
+            bboxes (Tensor): Detected bounding boxes.
+
+        Returns:
+            (dict[int:dict], ndarray): Updated tracks and bboxes.
+        """
+        costs = []
+        for id, track in tracks.items():
+            track.mean, track.covariance = self.predict(
+                track.mean, track.covariance)
+            gating_distance = self.gating_distance(track.mean,
+                                                   track.covariance,
+                                                   bboxes.cpu().numpy(),
+                                                   self.center_only)
+            costs.append(gating_distance)
+
+        costs = np.stack(costs, 0)
+        costs[costs > self.gating_threshold] = np.nan
+        return tracks, costs
diff --git a/mmdetection/mmdet/models/task_modules/tracking/similarity.py b/mmdetection/mmdet/models/task_modules/tracking/similarity.py
new file mode 100644
index 00000000..730e43b8
--- /dev/null
+++ b/mmdetection/mmdet/models/task_modules/tracking/similarity.py
@@ -0,0 +1,34 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+import torch.nn.functional as F
+from torch import Tensor
+
+
+def embed_similarity(key_embeds: Tensor,
+                     ref_embeds: Tensor,
+                     method: str = 'dot_product',
+                     temperature: int = -1) -> Tensor:
+    """Calculate feature similarity from embeddings.
+
+    Args:
+        key_embeds (Tensor): Shape (N1, C).
+        ref_embeds (Tensor): Shape (N2, C).
+        method (str, optional): Method to calculate the similarity,
+            options are 'dot_product' and 'cosine'. Defaults to
+            'dot_product'.
+        temperature (int, optional): Softmax temperature. Defaults to -1.
+
+    Returns:
+        Tensor: Similarity matrix of shape (N1, N2).
+    """
+    assert method in ['dot_product', 'cosine']
+
+    if method == 'cosine':
+        key_embeds = F.normalize(key_embeds, p=2, dim=1)
+        ref_embeds = F.normalize(ref_embeds, p=2, dim=1)
+
+    similarity = torch.mm(key_embeds, ref_embeds.T)
+
+    if temperature > 0:
+        similarity /= float(temperature)
+    return similarity
diff --git a/mmdetection/mmdet/models/test_time_augs/__init__.py b/mmdetection/mmdet/models/test_time_augs/__init__.py
new file mode 100644
index 00000000..f5e4926e
--- /dev/null
+++ b/mmdetection/mmdet/models/test_time_augs/__init__.py
@@ -0,0 +1,10 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .det_tta import DetTTAModel
+from .merge_augs import (merge_aug_bboxes, merge_aug_masks,
+                         merge_aug_proposals, merge_aug_results,
+                         merge_aug_scores)
+
+__all__ = [
+    'merge_aug_bboxes', 'merge_aug_masks', 'merge_aug_proposals',
+    'merge_aug_scores', 'merge_aug_results', 'DetTTAModel'
+]
diff --git a/mmdetection/mmdet/models/test_time_augs/det_tta.py b/mmdetection/mmdet/models/test_time_augs/det_tta.py
new file mode 100644
index 00000000..95f91db9
--- /dev/null
+++ b/mmdetection/mmdet/models/test_time_augs/det_tta.py
@@ -0,0 +1,144 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple
+
+import torch
+from mmcv.ops import batched_nms
+from mmengine.model import BaseTTAModel
+from mmengine.registry import MODELS
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.structures import DetDataSample
+from mmdet.structures.bbox import bbox_flip
+
+
+@MODELS.register_module()
+class DetTTAModel(BaseTTAModel):
+    """Merge augmented detection results, only bboxes corresponding score under
+    flipping and multi-scale resizing can be processed now.
+
+    Examples:
+        >>> tta_model = dict(
+        >>>     type='DetTTAModel',
+        >>>     tta_cfg=dict(nms=dict(
+        >>>                     type='nms',
+        >>>                     iou_threshold=0.5),
+        >>>                     max_per_img=100))
+        >>>
+        >>> tta_pipeline = [
+        >>>     dict(type='LoadImageFromFile',
+        >>>          backend_args=None),
+        >>>     dict(
+        >>>         type='TestTimeAug',
+        >>>         transforms=[[
+        >>>             dict(type='Resize',
+        >>>                  scale=(1333, 800),
+        >>>                  keep_ratio=True),
+        >>>         ], [
+        >>>             dict(type='RandomFlip', prob=1.),
+        >>>             dict(type='RandomFlip', prob=0.)
+        >>>         ], [
+        >>>             dict(
+        >>>                 type='PackDetInputs',
+        >>>                 meta_keys=('img_id', 'img_path', 'ori_shape',
+        >>>                         'img_shape', 'scale_factor', 'flip',
+        >>>                         'flip_direction'))
+        >>>         ]])]
+    """
+
+    def __init__(self, tta_cfg=None, **kwargs):
+        super().__init__(**kwargs)
+        self.tta_cfg = tta_cfg
+
+    def merge_aug_bboxes(self, aug_bboxes: List[Tensor],
+                         aug_scores: List[Tensor],
+                         img_metas: List[str]) -> Tuple[Tensor, Tensor]:
+        """Merge augmented detection bboxes and scores.
+
+        Args:
+            aug_bboxes (list[Tensor]): shape (n, 4*#class)
+            aug_scores (list[Tensor] or None): shape (n, #class)
+        Returns:
+            tuple[Tensor]: ``bboxes`` with shape (n,4), where
+            4 represent (tl_x, tl_y, br_x, br_y)
+            and ``scores`` with shape (n,).
+        """
+        recovered_bboxes = []
+        for bboxes, img_info in zip(aug_bboxes, img_metas):
+            ori_shape = img_info['ori_shape']
+            flip = img_info['flip']
+            flip_direction = img_info['flip_direction']
+            if flip:
+                bboxes = bbox_flip(
+                    bboxes=bboxes,
+                    img_shape=ori_shape,
+                    direction=flip_direction)
+            recovered_bboxes.append(bboxes)
+        bboxes = torch.cat(recovered_bboxes, dim=0)
+        if aug_scores is None:
+            return bboxes
+        else:
+            scores = torch.cat(aug_scores, dim=0)
+            return bboxes, scores
+
+    def merge_preds(self, data_samples_list: List[List[DetDataSample]]):
+        """Merge batch predictions of enhanced data.
+
+        Args:
+            data_samples_list (List[List[DetDataSample]]): List of predictions
+                of all enhanced data. The outer list indicates images, and the
+                inner list corresponds to the different views of one image.
+                Each element of the inner list is a ``DetDataSample``.
+        Returns:
+            List[DetDataSample]: Merged batch prediction.
+        """
+        merged_data_samples = []
+        for data_samples in data_samples_list:
+            merged_data_samples.append(self._merge_single_sample(data_samples))
+        return merged_data_samples
+
+    def _merge_single_sample(
+            self, data_samples: List[DetDataSample]) -> DetDataSample:
+        """Merge predictions which come form the different views of one image
+        to one prediction.
+
+        Args:
+            data_samples (List[DetDataSample]): List of predictions
+            of enhanced data which come form one image.
+        Returns:
+            List[DetDataSample]: Merged prediction.
+        """
+        aug_bboxes = []
+        aug_scores = []
+        aug_labels = []
+        img_metas = []
+        # TODO: support instance segmentation TTA
+        assert data_samples[0].pred_instances.get('masks', None) is None, \
+            'TTA of instance segmentation does not support now.'
+        for data_sample in data_samples:
+            aug_bboxes.append(data_sample.pred_instances.bboxes)
+            aug_scores.append(data_sample.pred_instances.scores)
+            aug_labels.append(data_sample.pred_instances.labels)
+            img_metas.append(data_sample.metainfo)
+
+        merged_bboxes, merged_scores = self.merge_aug_bboxes(
+            aug_bboxes, aug_scores, img_metas)
+        merged_labels = torch.cat(aug_labels, dim=0)
+
+        if merged_bboxes.numel() == 0:
+            return data_samples[0]
+
+        det_bboxes, keep_idxs = batched_nms(merged_bboxes, merged_scores,
+                                            merged_labels, self.tta_cfg.nms)
+
+        det_bboxes = det_bboxes[:self.tta_cfg.max_per_img]
+        det_labels = merged_labels[keep_idxs][:self.tta_cfg.max_per_img]
+
+        results = InstanceData()
+        _det_bboxes = det_bboxes.clone()
+        results.bboxes = _det_bboxes[:, :-1]
+        results.scores = _det_bboxes[:, -1]
+        results.labels = det_labels
+        det_results = data_samples[0]
+        det_results.pred_instances = results
+        return det_results
diff --git a/mmdetection/mmdet/models/test_time_augs/merge_augs.py b/mmdetection/mmdet/models/test_time_augs/merge_augs.py
new file mode 100644
index 00000000..5935a861
--- /dev/null
+++ b/mmdetection/mmdet/models/test_time_augs/merge_augs.py
@@ -0,0 +1,219 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import warnings
+from typing import List, Optional, Union
+
+import numpy as np
+import torch
+from mmcv.ops import nms
+from mmengine.config import ConfigDict
+from torch import Tensor
+
+from mmdet.structures.bbox import bbox_mapping_back
+
+
+# TODO remove this, never be used in mmdet
+def merge_aug_proposals(aug_proposals, img_metas, cfg):
+    """Merge augmented proposals (multiscale, flip, etc.)
+
+    Args:
+        aug_proposals (list[Tensor]): proposals from different testing
+            schemes, shape (n, 5). Note that they are not rescaled to the
+            original image size.
+
+        img_metas (list[dict]): list of image info dict where each dict has:
+            'img_shape', 'scale_factor', 'flip', and may also contain
+            'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
+            For details on the values of these keys see
+            `mmdet/datasets/pipelines/formatting.py:Collect`.
+
+        cfg (dict): rpn test config.
+
+    Returns:
+        Tensor: shape (n, 4), proposals corresponding to original image scale.
+    """
+
+    cfg = copy.deepcopy(cfg)
+
+    # deprecate arguments warning
+    if 'nms' not in cfg or 'max_num' in cfg or 'nms_thr' in cfg:
+        warnings.warn(
+            'In rpn_proposal or test_cfg, '
+            'nms_thr has been moved to a dict named nms as '
+            'iou_threshold, max_num has been renamed as max_per_img, '
+            'name of original arguments and the way to specify '
+            'iou_threshold of NMS will be deprecated.')
+    if 'nms' not in cfg:
+        cfg.nms = ConfigDict(dict(type='nms', iou_threshold=cfg.nms_thr))
+    if 'max_num' in cfg:
+        if 'max_per_img' in cfg:
+            assert cfg.max_num == cfg.max_per_img, f'You set max_num and ' \
+                f'max_per_img at the same time, but get {cfg.max_num} ' \
+                f'and {cfg.max_per_img} respectively' \
+                f'Please delete max_num which will be deprecated.'
+        else:
+            cfg.max_per_img = cfg.max_num
+    if 'nms_thr' in cfg:
+        assert cfg.nms.iou_threshold == cfg.nms_thr, f'You set ' \
+            f'iou_threshold in nms and ' \
+            f'nms_thr at the same time, but get ' \
+            f'{cfg.nms.iou_threshold} and {cfg.nms_thr}' \
+            f' respectively. Please delete the nms_thr ' \
+            f'which will be deprecated.'
+
+    recovered_proposals = []
+    for proposals, img_info in zip(aug_proposals, img_metas):
+        img_shape = img_info['img_shape']
+        scale_factor = img_info['scale_factor']
+        flip = img_info['flip']
+        flip_direction = img_info['flip_direction']
+        _proposals = proposals.clone()
+        _proposals[:, :4] = bbox_mapping_back(_proposals[:, :4], img_shape,
+                                              scale_factor, flip,
+                                              flip_direction)
+        recovered_proposals.append(_proposals)
+    aug_proposals = torch.cat(recovered_proposals, dim=0)
+    merged_proposals, _ = nms(aug_proposals[:, :4].contiguous(),
+                              aug_proposals[:, -1].contiguous(),
+                              cfg.nms.iou_threshold)
+    scores = merged_proposals[:, 4]
+    _, order = scores.sort(0, descending=True)
+    num = min(cfg.max_per_img, merged_proposals.shape[0])
+    order = order[:num]
+    merged_proposals = merged_proposals[order, :]
+    return merged_proposals
+
+
+# TODO remove this, never be used in mmdet
+def merge_aug_bboxes(aug_bboxes, aug_scores, img_metas, rcnn_test_cfg):
+    """Merge augmented detection bboxes and scores.
+
+    Args:
+        aug_bboxes (list[Tensor]): shape (n, 4*#class)
+        aug_scores (list[Tensor] or None): shape (n, #class)
+        img_shapes (list[Tensor]): shape (3, ).
+        rcnn_test_cfg (dict): rcnn test config.
+
+    Returns:
+        tuple: (bboxes, scores)
+    """
+    recovered_bboxes = []
+    for bboxes, img_info in zip(aug_bboxes, img_metas):
+        img_shape = img_info[0]['img_shape']
+        scale_factor = img_info[0]['scale_factor']
+        flip = img_info[0]['flip']
+        flip_direction = img_info[0]['flip_direction']
+        bboxes = bbox_mapping_back(bboxes, img_shape, scale_factor, flip,
+                                   flip_direction)
+        recovered_bboxes.append(bboxes)
+    bboxes = torch.stack(recovered_bboxes).mean(dim=0)
+    if aug_scores is None:
+        return bboxes
+    else:
+        scores = torch.stack(aug_scores).mean(dim=0)
+        return bboxes, scores
+
+
+def merge_aug_results(aug_batch_results, aug_batch_img_metas):
+    """Merge augmented detection results, only bboxes corresponding score under
+    flipping and multi-scale resizing can be processed now.
+
+    Args:
+        aug_batch_results (list[list[[obj:`InstanceData`]]):
+            Detection results of multiple images with
+            different augmentations.
+            The outer list indicate the augmentation . The inter
+            list indicate the batch dimension.
+            Each item usually contains the following keys.
+
+            - scores (Tensor): Classification scores, in shape
+              (num_instance,)
+            - labels (Tensor): Labels of bboxes, in shape
+              (num_instances,).
+            - bboxes (Tensor): In shape (num_instances, 4),
+              the last dimension 4 arrange as (x1, y1, x2, y2).
+        aug_batch_img_metas (list[list[dict]]): The outer list
+            indicates test-time augs (multiscale, flip, etc.)
+            and the inner list indicates
+            images in a batch. Each dict in the list contains
+            information of an image in the batch.
+
+    Returns:
+        batch_results (list[obj:`InstanceData`]): Same with
+        the input `aug_results` except that all bboxes have
+        been mapped to the original scale.
+    """
+    num_augs = len(aug_batch_results)
+    num_imgs = len(aug_batch_results[0])
+
+    batch_results = []
+    aug_batch_results = copy.deepcopy(aug_batch_results)
+    for img_id in range(num_imgs):
+        aug_results = []
+        for aug_id in range(num_augs):
+            img_metas = aug_batch_img_metas[aug_id][img_id]
+            results = aug_batch_results[aug_id][img_id]
+
+            img_shape = img_metas['img_shape']
+            scale_factor = img_metas['scale_factor']
+            flip = img_metas['flip']
+            flip_direction = img_metas['flip_direction']
+            bboxes = bbox_mapping_back(results.bboxes, img_shape, scale_factor,
+                                       flip, flip_direction)
+            results.bboxes = bboxes
+            aug_results.append(results)
+        merged_aug_results = results.cat(aug_results)
+        batch_results.append(merged_aug_results)
+
+    return batch_results
+
+
+def merge_aug_scores(aug_scores):
+    """Merge augmented bbox scores."""
+    if isinstance(aug_scores[0], torch.Tensor):
+        return torch.mean(torch.stack(aug_scores), dim=0)
+    else:
+        return np.mean(aug_scores, axis=0)
+
+
+def merge_aug_masks(aug_masks: List[Tensor],
+                    img_metas: dict,
+                    weights: Optional[Union[list, Tensor]] = None) -> Tensor:
+    """Merge augmented mask prediction.
+
+    Args:
+        aug_masks (list[Tensor]): each has shape
+            (n, c, h, w).
+        img_metas (dict): Image information.
+        weights (list or Tensor): Weight of each aug_masks,
+            the length should be n.
+
+    Returns:
+        Tensor: has shape (n, c, h, w)
+    """
+    recovered_masks = []
+    for i, mask in enumerate(aug_masks):
+        if weights is not None:
+            assert len(weights) == len(aug_masks)
+            weight = weights[i]
+        else:
+            weight = 1
+        flip = img_metas.get('flip', False)
+        if flip:
+            flip_direction = img_metas['flip_direction']
+            if flip_direction == 'horizontal':
+                mask = mask[:, :, :, ::-1]
+            elif flip_direction == 'vertical':
+                mask = mask[:, :, ::-1, :]
+            elif flip_direction == 'diagonal':
+                mask = mask[:, :, :, ::-1]
+                mask = mask[:, :, ::-1, :]
+            else:
+                raise ValueError(
+                    f"Invalid flipping direction '{flip_direction}'")
+        recovered_masks.append(mask[None, :] * weight)
+
+    merged_masks = torch.cat(recovered_masks, 0).mean(dim=0)
+    if weights is not None:
+        merged_masks = merged_masks * len(weights) / sum(weights)
+    return merged_masks
diff --git a/mmdetection/mmdet/models/trackers/__init__.py b/mmdetection/mmdet/models/trackers/__init__.py
new file mode 100644
index 00000000..00284bb7
--- /dev/null
+++ b/mmdetection/mmdet/models/trackers/__init__.py
@@ -0,0 +1,13 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .base_tracker import BaseTracker
+from .byte_tracker import ByteTracker
+from .masktrack_rcnn_tracker import MaskTrackRCNNTracker
+from .ocsort_tracker import OCSORTTracker
+from .quasi_dense_tracker import QuasiDenseTracker
+from .sort_tracker import SORTTracker
+from .strongsort_tracker import StrongSORTTracker
+
+__all__ = [
+    'BaseTracker', 'ByteTracker', 'QuasiDenseTracker', 'SORTTracker',
+    'StrongSORTTracker', 'OCSORTTracker', 'MaskTrackRCNNTracker'
+]
diff --git a/mmdetection/mmdet/models/trackers/base_tracker.py b/mmdetection/mmdet/models/trackers/base_tracker.py
new file mode 100644
index 00000000..0cf18865
--- /dev/null
+++ b/mmdetection/mmdet/models/trackers/base_tracker.py
@@ -0,0 +1,240 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from abc import ABCMeta, abstractmethod
+from typing import List, Optional, Tuple
+
+import torch
+import torch.nn.functional as F
+from addict import Dict
+
+
+class BaseTracker(metaclass=ABCMeta):
+    """Base tracker model.
+
+    Args:
+        momentums (dict[str:float], optional): Momentums to update the buffers.
+            The `str` indicates the name of the buffer while the `float`
+            indicates the momentum. Defaults to None.
+        num_frames_retain (int, optional). If a track is disappeared more than
+            `num_frames_retain` frames, it will be deleted in the memo.
+             Defaults to 10.
+    """
+
+    def __init__(self,
+                 momentums: Optional[dict] = None,
+                 num_frames_retain: int = 10) -> None:
+        super().__init__()
+        if momentums is not None:
+            assert isinstance(momentums, dict), 'momentums must be a dict'
+        self.momentums = momentums
+        self.num_frames_retain = num_frames_retain
+
+        self.reset()
+
+    def reset(self) -> None:
+        """Reset the buffer of the tracker."""
+        self.num_tracks = 0
+        self.tracks = dict()
+
+    @property
+    def empty(self) -> bool:
+        """Whether the buffer is empty or not."""
+        return False if self.tracks else True
+
+    @property
+    def ids(self) -> List[dict]:
+        """All ids in the tracker."""
+        return list(self.tracks.keys())
+
+    @property
+    def with_reid(self) -> bool:
+        """bool: whether the framework has a reid model"""
+        return hasattr(self, 'reid') and self.reid is not None
+
+    def update(self, **kwargs) -> None:
+        """Update the tracker.
+
+        Args:
+            kwargs (dict[str: Tensor | int]): The `str` indicates the
+                name of the input variable. `ids` and `frame_ids` are
+                obligatory in the keys.
+        """
+        memo_items = [k for k, v in kwargs.items() if v is not None]
+        rm_items = [k for k in kwargs.keys() if k not in memo_items]
+        for item in rm_items:
+            kwargs.pop(item)
+        if not hasattr(self, 'memo_items'):
+            self.memo_items = memo_items
+        else:
+            assert memo_items == self.memo_items
+
+        assert 'ids' in memo_items
+        num_objs = len(kwargs['ids'])
+        id_indice = memo_items.index('ids')
+        assert 'frame_ids' in memo_items
+        frame_id = int(kwargs['frame_ids'])
+        if isinstance(kwargs['frame_ids'], int):
+            kwargs['frame_ids'] = torch.tensor([kwargs['frame_ids']] *
+                                               num_objs)
+        # cur_frame_id = int(kwargs['frame_ids'][0])
+        for k, v in kwargs.items():
+            if len(v) != num_objs:
+                raise ValueError('kwargs value must both equal')
+
+        for obj in zip(*kwargs.values()):
+            id = int(obj[id_indice])
+            if id in self.tracks:
+                self.update_track(id, obj)
+            else:
+                self.init_track(id, obj)
+
+        self.pop_invalid_tracks(frame_id)
+
+    def pop_invalid_tracks(self, frame_id: int) -> None:
+        """Pop out invalid tracks."""
+        invalid_ids = []
+        for k, v in self.tracks.items():
+            if frame_id - v['frame_ids'][-1] >= self.num_frames_retain:
+                invalid_ids.append(k)
+        for invalid_id in invalid_ids:
+            self.tracks.pop(invalid_id)
+
+    def update_track(self, id: int, obj: Tuple[torch.Tensor]):
+        """Update a track."""
+        for k, v in zip(self.memo_items, obj):
+            v = v[None]
+            if self.momentums is not None and k in self.momentums:
+                m = self.momentums[k]
+                self.tracks[id][k] = (1 - m) * self.tracks[id][k] + m * v
+            else:
+                self.tracks[id][k].append(v)
+
+    def init_track(self, id: int, obj: Tuple[torch.Tensor]):
+        """Initialize a track."""
+        self.tracks[id] = Dict()
+        for k, v in zip(self.memo_items, obj):
+            v = v[None]
+            if self.momentums is not None and k in self.momentums:
+                self.tracks[id][k] = v
+            else:
+                self.tracks[id][k] = [v]
+
+    @property
+    def memo(self) -> dict:
+        """Return all buffers in the tracker."""
+        outs = Dict()
+        for k in self.memo_items:
+            outs[k] = []
+
+        for id, objs in self.tracks.items():
+            for k, v in objs.items():
+                if k not in outs:
+                    continue
+                if self.momentums is not None and k in self.momentums:
+                    v = v
+                else:
+                    v = v[-1]
+                outs[k].append(v)
+
+        for k, v in outs.items():
+            outs[k] = torch.cat(v, dim=0)
+        return outs
+
+    def get(self,
+            item: str,
+            ids: Optional[list] = None,
+            num_samples: Optional[int] = None,
+            behavior: Optional[str] = None) -> torch.Tensor:
+        """Get the buffer of a specific item.
+
+        Args:
+            item (str): The demanded item.
+            ids (list[int], optional): The demanded ids. Defaults to None.
+            num_samples (int, optional): Number of samples to calculate the
+                results. Defaults to None.
+            behavior (str, optional): Behavior to calculate the results.
+                Options are `mean` | None. Defaults to None.
+
+        Returns:
+            Tensor: The results of the demanded item.
+        """
+        if ids is None:
+            ids = self.ids
+
+        outs = []
+        for id in ids:
+            out = self.tracks[id][item]
+            if isinstance(out, list):
+                if num_samples is not None:
+                    out = out[-num_samples:]
+                    out = torch.cat(out, dim=0)
+                    if behavior == 'mean':
+                        out = out.mean(dim=0, keepdim=True)
+                    elif behavior is None:
+                        out = out[None]
+                    else:
+                        raise NotImplementedError()
+                else:
+                    out = out[-1]
+            outs.append(out)
+        return torch.cat(outs, dim=0)
+
+    @abstractmethod
+    def track(self, *args, **kwargs):
+        """Tracking forward function."""
+        pass
+
+    def crop_imgs(self,
+                  img: torch.Tensor,
+                  meta_info: dict,
+                  bboxes: torch.Tensor,
+                  rescale: bool = False) -> torch.Tensor:
+        """Crop the images according to some bounding boxes. Typically for re-
+        identification sub-module.
+
+        Args:
+            img (Tensor): of shape (T, C, H, W) encoding input image.
+                Typically these should be mean centered and std scaled.
+            meta_info (dict): image information dict where each dict
+                has: 'img_shape', 'scale_factor', 'flip', and may also contain
+                'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
+            bboxes (Tensor): of shape (N, 4) or (N, 5).
+            rescale (bool, optional): If True, the bounding boxes should be
+                rescaled to fit the scale of the image. Defaults to False.
+
+        Returns:
+            Tensor: Image tensor of shape (T, C, H, W).
+        """
+        h, w = meta_info['img_shape']
+        img = img[:, :, :h, :w]
+        if rescale:
+            factor_x, factor_y = meta_info['scale_factor']
+            bboxes[:, :4] *= torch.tensor(
+                [factor_x, factor_y, factor_x, factor_y]).to(bboxes.device)
+        bboxes[:, 0] = torch.clamp(bboxes[:, 0], min=0, max=w - 1)
+        bboxes[:, 1] = torch.clamp(bboxes[:, 1], min=0, max=h - 1)
+        bboxes[:, 2] = torch.clamp(bboxes[:, 2], min=1, max=w)
+        bboxes[:, 3] = torch.clamp(bboxes[:, 3], min=1, max=h)
+
+        crop_imgs = []
+        for bbox in bboxes:
+            x1, y1, x2, y2 = map(int, bbox)
+            if x2 <= x1:
+                x2 = x1 + 1
+            if y2 <= y1:
+                y2 = y1 + 1
+            crop_img = img[:, :, y1:y2, x1:x2]
+            if self.reid.get('img_scale', False):
+                crop_img = F.interpolate(
+                    crop_img,
+                    size=self.reid['img_scale'],
+                    mode='bilinear',
+                    align_corners=False)
+            crop_imgs.append(crop_img)
+
+        if len(crop_imgs) > 0:
+            return torch.cat(crop_imgs, dim=0)
+        elif self.reid.get('img_scale', False):
+            _h, _w = self.reid['img_scale']
+            return img.new_zeros((0, 3, _h, _w))
+        else:
+            return img.new_zeros((0, 3, h, w))
diff --git a/mmdetection/mmdet/models/trackers/byte_tracker.py b/mmdetection/mmdet/models/trackers/byte_tracker.py
new file mode 100644
index 00000000..11f3adc5
--- /dev/null
+++ b/mmdetection/mmdet/models/trackers/byte_tracker.py
@@ -0,0 +1,334 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Tuple
+
+try:
+    import lap
+except ImportError:
+    lap = None
+import numpy as np
+import torch
+from mmengine.structures import InstanceData
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.structures import DetDataSample
+from mmdet.structures.bbox import (bbox_cxcyah_to_xyxy, bbox_overlaps,
+                                   bbox_xyxy_to_cxcyah)
+from .base_tracker import BaseTracker
+
+
+@MODELS.register_module()
+class ByteTracker(BaseTracker):
+    """Tracker for ByteTrack.
+
+    Args:
+        motion (dict): Configuration of motion. Defaults to None.
+        obj_score_thrs (dict): Detection score threshold for matching objects.
+            - high (float): Threshold of the first matching. Defaults to 0.6.
+            - low (float): Threshold of the second matching. Defaults to 0.1.
+        init_track_thr (float): Detection score threshold for initializing a
+            new tracklet. Defaults to 0.7.
+        weight_iou_with_det_scores (bool): Whether using detection scores to
+            weight IOU which is used for matching. Defaults to True.
+        match_iou_thrs (dict): IOU distance threshold for matching between two
+            frames.
+            - high (float): Threshold of the first matching. Defaults to 0.1.
+            - low (float): Threshold of the second matching. Defaults to 0.5.
+            - tentative (float): Threshold of the matching for tentative
+                tracklets. Defaults to 0.3.
+        num_tentatives (int, optional): Number of continuous frames to confirm
+            a track. Defaults to 3.
+    """
+
+    def __init__(self,
+                 motion: Optional[dict] = None,
+                 obj_score_thrs: dict = dict(high=0.6, low=0.1),
+                 init_track_thr: float = 0.7,
+                 weight_iou_with_det_scores: bool = True,
+                 match_iou_thrs: dict = dict(high=0.1, low=0.5, tentative=0.3),
+                 num_tentatives: int = 3,
+                 **kwargs):
+        super().__init__(**kwargs)
+
+        if lap is None:
+            raise RuntimeError('lap is not installed,\
+                 please install it by: pip install lap')
+        if motion is not None:
+            self.motion = TASK_UTILS.build(motion)
+
+        self.obj_score_thrs = obj_score_thrs
+        self.init_track_thr = init_track_thr
+
+        self.weight_iou_with_det_scores = weight_iou_with_det_scores
+        self.match_iou_thrs = match_iou_thrs
+
+        self.num_tentatives = num_tentatives
+
+    @property
+    def confirmed_ids(self) -> List:
+        """Confirmed ids in the tracker."""
+        ids = [id for id, track in self.tracks.items() if not track.tentative]
+        return ids
+
+    @property
+    def unconfirmed_ids(self) -> List:
+        """Unconfirmed ids in the tracker."""
+        ids = [id for id, track in self.tracks.items() if track.tentative]
+        return ids
+
+    def init_track(self, id: int, obj: Tuple[torch.Tensor]) -> None:
+        """Initialize a track."""
+        super().init_track(id, obj)
+        if self.tracks[id].frame_ids[-1] == 0:
+            self.tracks[id].tentative = False
+        else:
+            self.tracks[id].tentative = True
+        bbox = bbox_xyxy_to_cxcyah(self.tracks[id].bboxes[-1])  # size = (1, 4)
+        assert bbox.ndim == 2 and bbox.shape[0] == 1
+        bbox = bbox.squeeze(0).cpu().numpy()
+        self.tracks[id].mean, self.tracks[id].covariance = self.kf.initiate(
+            bbox)
+
+    def update_track(self, id: int, obj: Tuple[torch.Tensor]) -> None:
+        """Update a track."""
+        super().update_track(id, obj)
+        if self.tracks[id].tentative:
+            if len(self.tracks[id]['bboxes']) >= self.num_tentatives:
+                self.tracks[id].tentative = False
+        bbox = bbox_xyxy_to_cxcyah(self.tracks[id].bboxes[-1])  # size = (1, 4)
+        assert bbox.ndim == 2 and bbox.shape[0] == 1
+        bbox = bbox.squeeze(0).cpu().numpy()
+        track_label = self.tracks[id]['labels'][-1]
+        label_idx = self.memo_items.index('labels')
+        obj_label = obj[label_idx]
+        assert obj_label == track_label
+        self.tracks[id].mean, self.tracks[id].covariance = self.kf.update(
+            self.tracks[id].mean, self.tracks[id].covariance, bbox)
+
+    def pop_invalid_tracks(self, frame_id: int) -> None:
+        """Pop out invalid tracks."""
+        invalid_ids = []
+        for k, v in self.tracks.items():
+            # case1: disappeared frames >= self.num_frames_retrain
+            case1 = frame_id - v['frame_ids'][-1] >= self.num_frames_retain
+            # case2: tentative tracks but not matched in this frame
+            case2 = v.tentative and v['frame_ids'][-1] != frame_id
+            if case1 or case2:
+                invalid_ids.append(k)
+        for invalid_id in invalid_ids:
+            self.tracks.pop(invalid_id)
+
+    def assign_ids(
+            self,
+            ids: List[int],
+            det_bboxes: torch.Tensor,
+            det_labels: torch.Tensor,
+            det_scores: torch.Tensor,
+            weight_iou_with_det_scores: Optional[bool] = False,
+            match_iou_thr: Optional[float] = 0.5
+    ) -> Tuple[np.ndarray, np.ndarray]:
+        """Assign ids.
+
+        Args:
+            ids (list[int]): Tracking ids.
+            det_bboxes (Tensor): of shape (N, 4)
+            det_labels (Tensor): of shape (N,)
+            det_scores (Tensor): of shape (N,)
+            weight_iou_with_det_scores (bool, optional): Whether using
+                detection scores to weight IOU which is used for matching.
+                Defaults to False.
+            match_iou_thr (float, optional): Matching threshold.
+                Defaults to 0.5.
+
+        Returns:
+            tuple(np.ndarray, np.ndarray): The assigning ids.
+        """
+        # get track_bboxes
+        track_bboxes = np.zeros((0, 4))
+        for id in ids:
+            track_bboxes = np.concatenate(
+                (track_bboxes, self.tracks[id].mean[:4][None]), axis=0)
+        track_bboxes = torch.from_numpy(track_bboxes).to(det_bboxes)
+        track_bboxes = bbox_cxcyah_to_xyxy(track_bboxes)
+
+        # compute distance
+        ious = bbox_overlaps(track_bboxes, det_bboxes)
+        if weight_iou_with_det_scores:
+            ious *= det_scores
+        # support multi-class association
+        track_labels = torch.tensor([
+            self.tracks[id]['labels'][-1] for id in ids
+        ]).to(det_bboxes.device)
+
+        cate_match = det_labels[None, :] == track_labels[:, None]
+        # to avoid det and track of different categories are matched
+        cate_cost = (1 - cate_match.int()) * 1e6
+
+        dists = (1 - ious + cate_cost).cpu().numpy()
+
+        # bipartite match
+        if dists.size > 0:
+            cost, row, col = lap.lapjv(
+                dists, extend_cost=True, cost_limit=1 - match_iou_thr)
+        else:
+            row = np.zeros(len(ids)).astype(np.int32) - 1
+            col = np.zeros(len(det_bboxes)).astype(np.int32) - 1
+        return row, col
+
+    def track(self, data_sample: DetDataSample, **kwargs) -> InstanceData:
+        """Tracking forward function.
+
+        Args:
+            data_sample (:obj:`DetDataSample`): The data sample.
+                It includes information such as `pred_instances`.
+
+        Returns:
+            :obj:`InstanceData`: Tracking results of the input images.
+            Each InstanceData usually contains ``bboxes``, ``labels``,
+            ``scores`` and ``instances_id``.
+        """
+        metainfo = data_sample.metainfo
+        bboxes = data_sample.pred_instances.bboxes
+        labels = data_sample.pred_instances.labels
+        scores = data_sample.pred_instances.scores
+
+        frame_id = metainfo.get('frame_id', -1)
+        if frame_id == 0:
+            self.reset()
+        if not hasattr(self, 'kf'):
+            self.kf = self.motion
+
+        if self.empty or bboxes.size(0) == 0:
+            valid_inds = scores > self.init_track_thr
+            scores = scores[valid_inds]
+            bboxes = bboxes[valid_inds]
+            labels = labels[valid_inds]
+            num_new_tracks = bboxes.size(0)
+            ids = torch.arange(self.num_tracks,
+                               self.num_tracks + num_new_tracks).to(labels)
+            self.num_tracks += num_new_tracks
+
+        else:
+            # 0. init
+            ids = torch.full((bboxes.size(0), ),
+                             -1,
+                             dtype=labels.dtype,
+                             device=labels.device)
+
+            # get the detection bboxes for the first association
+            first_det_inds = scores > self.obj_score_thrs['high']
+            first_det_bboxes = bboxes[first_det_inds]
+            first_det_labels = labels[first_det_inds]
+            first_det_scores = scores[first_det_inds]
+            first_det_ids = ids[first_det_inds]
+
+            # get the detection bboxes for the second association
+            second_det_inds = (~first_det_inds) & (
+                scores > self.obj_score_thrs['low'])
+            second_det_bboxes = bboxes[second_det_inds]
+            second_det_labels = labels[second_det_inds]
+            second_det_scores = scores[second_det_inds]
+            second_det_ids = ids[second_det_inds]
+
+            # 1. use Kalman Filter to predict current location
+            for id in self.confirmed_ids:
+                # track is lost in previous frame
+                if self.tracks[id].frame_ids[-1] != frame_id - 1:
+                    self.tracks[id].mean[7] = 0
+                (self.tracks[id].mean,
+                 self.tracks[id].covariance) = self.kf.predict(
+                     self.tracks[id].mean, self.tracks[id].covariance)
+
+            # 2. first match
+            first_match_track_inds, first_match_det_inds = self.assign_ids(
+                self.confirmed_ids, first_det_bboxes, first_det_labels,
+                first_det_scores, self.weight_iou_with_det_scores,
+                self.match_iou_thrs['high'])
+            # '-1' mean a detection box is not matched with tracklets in
+            # previous frame
+            valid = first_match_det_inds > -1
+            first_det_ids[valid] = torch.tensor(
+                self.confirmed_ids)[first_match_det_inds[valid]].to(labels)
+
+            first_match_det_bboxes = first_det_bboxes[valid]
+            first_match_det_labels = first_det_labels[valid]
+            first_match_det_scores = first_det_scores[valid]
+            first_match_det_ids = first_det_ids[valid]
+            assert (first_match_det_ids > -1).all()
+
+            first_unmatch_det_bboxes = first_det_bboxes[~valid]
+            first_unmatch_det_labels = first_det_labels[~valid]
+            first_unmatch_det_scores = first_det_scores[~valid]
+            first_unmatch_det_ids = first_det_ids[~valid]
+            assert (first_unmatch_det_ids == -1).all()
+
+            # 3. use unmatched detection bboxes from the first match to match
+            # the unconfirmed tracks
+            (tentative_match_track_inds,
+             tentative_match_det_inds) = self.assign_ids(
+                 self.unconfirmed_ids, first_unmatch_det_bboxes,
+                 first_unmatch_det_labels, first_unmatch_det_scores,
+                 self.weight_iou_with_det_scores,
+                 self.match_iou_thrs['tentative'])
+            valid = tentative_match_det_inds > -1
+            first_unmatch_det_ids[valid] = torch.tensor(self.unconfirmed_ids)[
+                tentative_match_det_inds[valid]].to(labels)
+
+            # 4. second match for unmatched tracks from the first match
+            first_unmatch_track_ids = []
+            for i, id in enumerate(self.confirmed_ids):
+                # tracklet is not matched in the first match
+                case_1 = first_match_track_inds[i] == -1
+                # tracklet is not lost in the previous frame
+                case_2 = self.tracks[id].frame_ids[-1] == frame_id - 1
+                if case_1 and case_2:
+                    first_unmatch_track_ids.append(id)
+
+            second_match_track_inds, second_match_det_inds = self.assign_ids(
+                first_unmatch_track_ids, second_det_bboxes, second_det_labels,
+                second_det_scores, False, self.match_iou_thrs['low'])
+            valid = second_match_det_inds > -1
+            second_det_ids[valid] = torch.tensor(first_unmatch_track_ids)[
+                second_match_det_inds[valid]].to(ids)
+
+            # 5. gather all matched detection bboxes from step 2-4
+            # we only keep matched detection bboxes in second match, which
+            # means the id != -1
+            valid = second_det_ids > -1
+            bboxes = torch.cat(
+                (first_match_det_bboxes, first_unmatch_det_bboxes), dim=0)
+            bboxes = torch.cat((bboxes, second_det_bboxes[valid]), dim=0)
+
+            labels = torch.cat(
+                (first_match_det_labels, first_unmatch_det_labels), dim=0)
+            labels = torch.cat((labels, second_det_labels[valid]), dim=0)
+
+            scores = torch.cat(
+                (first_match_det_scores, first_unmatch_det_scores), dim=0)
+            scores = torch.cat((scores, second_det_scores[valid]), dim=0)
+
+            ids = torch.cat((first_match_det_ids, first_unmatch_det_ids),
+                            dim=0)
+            ids = torch.cat((ids, second_det_ids[valid]), dim=0)
+
+            # 6. assign new ids
+            new_track_inds = ids == -1
+            ids[new_track_inds] = torch.arange(
+                self.num_tracks,
+                self.num_tracks + new_track_inds.sum()).to(labels)
+            self.num_tracks += new_track_inds.sum()
+
+        self.update(
+            ids=ids,
+            bboxes=bboxes,
+            scores=scores,
+            labels=labels,
+            frame_ids=frame_id)
+
+        # update pred_track_instances
+        pred_track_instances = InstanceData()
+        pred_track_instances.bboxes = bboxes
+        pred_track_instances.labels = labels
+        pred_track_instances.scores = scores
+        pred_track_instances.instances_id = ids
+
+        return pred_track_instances
diff --git a/mmdetection/mmdet/models/trackers/masktrack_rcnn_tracker.py b/mmdetection/mmdet/models/trackers/masktrack_rcnn_tracker.py
new file mode 100644
index 00000000..cc167786
--- /dev/null
+++ b/mmdetection/mmdet/models/trackers/masktrack_rcnn_tracker.py
@@ -0,0 +1,189 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List
+
+import torch
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import DetDataSample
+from mmdet.structures.bbox import bbox_overlaps
+from .base_tracker import BaseTracker
+
+
+@MODELS.register_module()
+class MaskTrackRCNNTracker(BaseTracker):
+    """Tracker for MaskTrack R-CNN.
+
+    Args:
+        match_weights (dict[str : float]): The Weighting factor when computing
+        the match score. It contains keys as follows:
+
+            - det_score (float): The coefficient of `det_score` when computing
+                match score.
+            - iou (float): The coefficient of `ious` when computing match
+                score.
+            - det_label (float): The coefficient of `label_deltas` when
+                computing match score.
+    """
+
+    def __init__(self,
+                 match_weights: dict = dict(
+                     det_score=1.0, iou=2.0, det_label=10.0),
+                 **kwargs):
+        super().__init__(**kwargs)
+        self.match_weights = match_weights
+
+    def get_match_score(self, bboxes: Tensor, labels: Tensor, scores: Tensor,
+                        prev_bboxes: Tensor, prev_labels: Tensor,
+                        similarity_logits: Tensor) -> Tensor:
+        """Get the match score.
+
+        Args:
+            bboxes (torch.Tensor): of shape (num_current_bboxes, 4) in
+                [tl_x, tl_y, br_x, br_y] format. Denoting the detection
+                bboxes of current frame.
+            labels (torch.Tensor): of shape (num_current_bboxes, )
+            scores (torch.Tensor): of shape (num_current_bboxes, )
+            prev_bboxes (torch.Tensor): of shape (num_previous_bboxes, 4) in
+                [tl_x, tl_y, br_x, br_y] format.  Denoting the detection bboxes
+                of previous frame.
+            prev_labels (torch.Tensor): of shape (num_previous_bboxes, )
+            similarity_logits (torch.Tensor): of shape (num_current_bboxes,
+                num_previous_bboxes + 1). Denoting the similarity logits from
+                track head.
+
+        Returns:
+            torch.Tensor: The matching score of shape (num_current_bboxes,
+            num_previous_bboxes + 1)
+        """
+        similarity_scores = similarity_logits.softmax(dim=1)
+
+        ious = bbox_overlaps(bboxes, prev_bboxes)
+        iou_dummy = ious.new_zeros(ious.shape[0], 1)
+        ious = torch.cat((iou_dummy, ious), dim=1)
+
+        label_deltas = (labels.view(-1, 1) == prev_labels).float()
+        label_deltas_dummy = label_deltas.new_ones(label_deltas.shape[0], 1)
+        label_deltas = torch.cat((label_deltas_dummy, label_deltas), dim=1)
+
+        match_score = similarity_scores.log()
+        match_score += self.match_weights['det_score'] * \
+            scores.view(-1, 1).log()
+        match_score += self.match_weights['iou'] * ious
+        match_score += self.match_weights['det_label'] * label_deltas
+
+        return match_score
+
+    def assign_ids(self, match_scores: Tensor):
+        num_prev_bboxes = match_scores.shape[1] - 1
+        _, match_ids = match_scores.max(dim=1)
+
+        ids = match_ids.new_zeros(match_ids.shape[0]) - 1
+        best_match_scores = match_scores.new_zeros(num_prev_bboxes) - 1e6
+        for idx, match_id in enumerate(match_ids):
+            if match_id == 0:
+                ids[idx] = self.num_tracks
+                self.num_tracks += 1
+            else:
+                match_score = match_scores[idx, match_id]
+                # TODO: fix the bug where multiple candidate might match
+                # with the same previous object.
+                if match_score > best_match_scores[match_id - 1]:
+                    ids[idx] = self.ids[match_id - 1]
+                    best_match_scores[match_id - 1] = match_score
+        return ids, best_match_scores
+
+    def track(self,
+              model: torch.nn.Module,
+              feats: List[torch.Tensor],
+              data_sample: DetDataSample,
+              rescale=True,
+              **kwargs) -> InstanceData:
+        """Tracking forward function.
+
+        Args:
+            model (nn.Module): VIS model.
+            img (Tensor): of shape (T, C, H, W) encoding input image.
+                Typically these should be mean centered and std scaled.
+                The T denotes the number of key images and usually is 1 in
+                MaskTrackRCNN method.
+            feats (list[Tensor]): Multi level feature maps of `img`.
+            data_sample (:obj:`TrackDataSample`): The data sample.
+                It includes information such as `pred_det_instances`.
+            rescale (bool, optional): If True, the bounding boxes should be
+                rescaled to fit the original scale of the image. Defaults to
+                True.
+
+        Returns:
+            :obj:`InstanceData`: Tracking results of the input images.
+            Each InstanceData usually contains ``bboxes``, ``labels``,
+            ``scores`` and ``instances_id``.
+        """
+        metainfo = data_sample.metainfo
+        bboxes = data_sample.pred_instances.bboxes
+        masks = data_sample.pred_instances.masks
+        labels = data_sample.pred_instances.labels
+        scores = data_sample.pred_instances.scores
+
+        frame_id = metainfo.get('frame_id', -1)
+        # create pred_track_instances
+        pred_track_instances = InstanceData()
+
+        if bboxes.shape[0] == 0:
+            ids = torch.zeros_like(labels)
+            pred_track_instances = data_sample.pred_instances.clone()
+            pred_track_instances.instances_id = ids
+            return pred_track_instances
+
+        rescaled_bboxes = bboxes.clone()
+        if rescale:
+            scale_factor = rescaled_bboxes.new_tensor(
+                metainfo['scale_factor']).repeat((1, 2))
+            rescaled_bboxes = rescaled_bboxes * scale_factor
+        roi_feats, _ = model.track_head.extract_roi_feats(
+            feats, [rescaled_bboxes])
+
+        if self.empty:
+            num_new_tracks = bboxes.size(0)
+            ids = torch.arange(
+                self.num_tracks,
+                self.num_tracks + num_new_tracks,
+                dtype=torch.long)
+            self.num_tracks += num_new_tracks
+        else:
+            prev_bboxes = self.get('bboxes')
+            prev_labels = self.get('labels')
+            prev_roi_feats = self.get('roi_feats')
+
+            similarity_logits = model.track_head.predict(
+                roi_feats, prev_roi_feats)
+            match_scores = self.get_match_score(bboxes, labels, scores,
+                                                prev_bboxes, prev_labels,
+                                                similarity_logits)
+            ids, _ = self.assign_ids(match_scores)
+
+        valid_inds = ids > -1
+        ids = ids[valid_inds]
+        bboxes = bboxes[valid_inds]
+        labels = labels[valid_inds]
+        scores = scores[valid_inds]
+        masks = masks[valid_inds]
+        roi_feats = roi_feats[valid_inds]
+
+        self.update(
+            ids=ids,
+            bboxes=bboxes,
+            labels=labels,
+            scores=scores,
+            masks=masks,
+            roi_feats=roi_feats,
+            frame_ids=frame_id)
+        # update pred_track_instances
+        pred_track_instances.bboxes = bboxes
+        pred_track_instances.masks = masks
+        pred_track_instances.labels = labels
+        pred_track_instances.scores = scores
+        pred_track_instances.instances_id = ids
+
+        return pred_track_instances
diff --git a/mmdetection/mmdet/models/trackers/ocsort_tracker.py b/mmdetection/mmdet/models/trackers/ocsort_tracker.py
new file mode 100644
index 00000000..4e09990c
--- /dev/null
+++ b/mmdetection/mmdet/models/trackers/ocsort_tracker.py
@@ -0,0 +1,531 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Tuple
+
+try:
+    import lap
+except ImportError:
+    lap = None
+import numpy as np
+import torch
+from addict import Dict
+from mmengine.structures import InstanceData
+
+from mmdet.registry import MODELS
+from mmdet.structures import DetDataSample
+from mmdet.structures.bbox import (bbox_cxcyah_to_xyxy, bbox_overlaps,
+                                   bbox_xyxy_to_cxcyah)
+from .sort_tracker import SORTTracker
+
+
+@MODELS.register_module()
+class OCSORTTracker(SORTTracker):
+    """Tracker for OC-SORT.
+
+    Args:
+        motion (dict): Configuration of motion. Defaults to None.
+        obj_score_thrs (float): Detection score threshold for matching objects.
+            Defaults to 0.3.
+        init_track_thr (float): Detection score threshold for initializing a
+            new tracklet. Defaults to 0.7.
+        weight_iou_with_det_scores (bool): Whether using detection scores to
+            weight IOU which is used for matching. Defaults to True.
+        match_iou_thr (float): IOU distance threshold for matching between two
+            frames. Defaults to 0.3.
+        num_tentatives (int, optional): Number of continuous frames to confirm
+            a track. Defaults to 3.
+        vel_consist_weight (float): Weight of the velocity consistency term in
+            association (OCM term in the paper).
+        vel_delta_t (int): The difference of time step for calculating of the
+            velocity direction of tracklets.
+        init_cfg (dict or list[dict], optional): Initialization config dict.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 motion: Optional[dict] = None,
+                 obj_score_thr: float = 0.3,
+                 init_track_thr: float = 0.7,
+                 weight_iou_with_det_scores: bool = True,
+                 match_iou_thr: float = 0.3,
+                 num_tentatives: int = 3,
+                 vel_consist_weight: float = 0.2,
+                 vel_delta_t: int = 3,
+                 **kwargs):
+        if lap is None:
+            raise RuntimeError('lap is not installed,\
+                 please install it by: pip install lap')
+        super().__init__(motion=motion, **kwargs)
+        self.obj_score_thr = obj_score_thr
+        self.init_track_thr = init_track_thr
+
+        self.weight_iou_with_det_scores = weight_iou_with_det_scores
+        self.match_iou_thr = match_iou_thr
+        self.vel_consist_weight = vel_consist_weight
+        self.vel_delta_t = vel_delta_t
+
+        self.num_tentatives = num_tentatives
+
+    @property
+    def unconfirmed_ids(self):
+        """Unconfirmed ids in the tracker."""
+        ids = [id for id, track in self.tracks.items() if track.tentative]
+        return ids
+
+    def init_track(self, id: int, obj: Tuple[torch.Tensor]):
+        """Initialize a track."""
+        super().init_track(id, obj)
+        if self.tracks[id].frame_ids[-1] == 0:
+            self.tracks[id].tentative = False
+        else:
+            self.tracks[id].tentative = True
+        bbox = bbox_xyxy_to_cxcyah(self.tracks[id].bboxes[-1])  # size = (1, 4)
+        assert bbox.ndim == 2 and bbox.shape[0] == 1
+        bbox = bbox.squeeze(0).cpu().numpy()
+        self.tracks[id].mean, self.tracks[id].covariance = self.kf.initiate(
+            bbox)
+        # track.obs maintains the history associated detections to this track
+        self.tracks[id].obs = []
+        bbox_id = self.memo_items.index('bboxes')
+        self.tracks[id].obs.append(obj[bbox_id])
+        # a placefolder to save mean/covariance before losing tracking it
+        # parameters to save: mean, covariance, measurement
+        self.tracks[id].tracked = True
+        self.tracks[id].saved_attr = Dict()
+        self.tracks[id].velocity = torch.tensor(
+            (-1, -1)).to(obj[bbox_id].device)  # placeholder
+
+    def update_track(self, id: int, obj: Tuple[torch.Tensor]):
+        """Update a track."""
+        super().update_track(id, obj)
+        if self.tracks[id].tentative:
+            if len(self.tracks[id]['bboxes']) >= self.num_tentatives:
+                self.tracks[id].tentative = False
+        bbox = bbox_xyxy_to_cxcyah(self.tracks[id].bboxes[-1])  # size = (1, 4)
+        assert bbox.ndim == 2 and bbox.shape[0] == 1
+        bbox = bbox.squeeze(0).cpu().numpy()
+        self.tracks[id].mean, self.tracks[id].covariance = self.kf.update(
+            self.tracks[id].mean, self.tracks[id].covariance, bbox)
+        self.tracks[id].tracked = True
+        bbox_id = self.memo_items.index('bboxes')
+        self.tracks[id].obs.append(obj[bbox_id])
+
+        bbox1 = self.k_step_observation(self.tracks[id])
+        bbox2 = obj[bbox_id]
+        self.tracks[id].velocity = self.vel_direction(bbox1, bbox2).to(
+            obj[bbox_id].device)
+
+    def vel_direction(self, bbox1: torch.Tensor, bbox2: torch.Tensor):
+        """Estimate the direction vector between two boxes."""
+        if bbox1.sum() < 0 or bbox2.sum() < 0:
+            return torch.tensor((-1, -1))
+        cx1, cy1 = (bbox1[0] + bbox1[2]) / 2.0, (bbox1[1] + bbox1[3]) / 2.0
+        cx2, cy2 = (bbox2[0] + bbox2[2]) / 2.0, (bbox2[1] + bbox2[3]) / 2.0
+        speed = torch.tensor([cy2 - cy1, cx2 - cx1])
+        norm = torch.sqrt((speed[0])**2 + (speed[1])**2) + 1e-6
+        return speed / norm
+
+    def vel_direction_batch(self, bboxes1: torch.Tensor,
+                            bboxes2: torch.Tensor):
+        """Estimate the direction vector given two batches of boxes."""
+        cx1, cy1 = (bboxes1[:, 0] + bboxes1[:, 2]) / 2.0, (bboxes1[:, 1] +
+                                                           bboxes1[:, 3]) / 2.0
+        cx2, cy2 = (bboxes2[:, 0] + bboxes2[:, 2]) / 2.0, (bboxes2[:, 1] +
+                                                           bboxes2[:, 3]) / 2.0
+        speed_diff_y = cy2[None, :] - cy1[:, None]
+        speed_diff_x = cx2[None, :] - cx1[:, None]
+        speed = torch.cat((speed_diff_y[..., None], speed_diff_x[..., None]),
+                          dim=-1)
+        norm = torch.sqrt((speed[:, :, 0])**2 + (speed[:, :, 1])**2) + 1e-6
+        speed[:, :, 0] /= norm
+        speed[:, :, 1] /= norm
+        return speed
+
+    def k_step_observation(self, track: Dict):
+        """return the observation k step away before."""
+        obs_seqs = track.obs
+        num_obs = len(obs_seqs)
+        if num_obs == 0:
+            return torch.tensor((-1, -1, -1, -1)).to(track.obs[0].device)
+        elif num_obs > self.vel_delta_t:
+            if obs_seqs[num_obs - 1 - self.vel_delta_t] is not None:
+                return obs_seqs[num_obs - 1 - self.vel_delta_t]
+            else:
+                return self.last_obs(track)
+        else:
+            return self.last_obs(track)
+
+    def ocm_assign_ids(self,
+                       ids: List[int],
+                       det_bboxes: torch.Tensor,
+                       det_labels: torch.Tensor,
+                       det_scores: torch.Tensor,
+                       weight_iou_with_det_scores: Optional[bool] = False,
+                       match_iou_thr: Optional[float] = 0.5):
+        """Apply Observation-Centric Momentum (OCM) to assign ids.
+
+        OCM adds movement direction consistency into the association cost
+        matrix. This term requires no additional assumption but from the
+        same linear motion assumption as the canonical Kalman Filter in SORT.
+
+        Args:
+            ids (list[int]): Tracking ids.
+            det_bboxes (Tensor): of shape (N, 4)
+            det_labels (Tensor): of shape (N,)
+            det_scores (Tensor): of shape (N,)
+            weight_iou_with_det_scores (bool, optional): Whether using
+                detection scores to weight IOU which is used for matching.
+                Defaults to False.
+            match_iou_thr (float, optional): Matching threshold.
+                Defaults to 0.5.
+
+        Returns:
+            tuple(int): The assigning ids.
+
+        OC-SORT uses velocity consistency besides IoU for association
+        """
+        # get track_bboxes
+        track_bboxes = np.zeros((0, 4))
+        for id in ids:
+            track_bboxes = np.concatenate(
+                (track_bboxes, self.tracks[id].mean[:4][None]), axis=0)
+        track_bboxes = torch.from_numpy(track_bboxes).to(det_bboxes)
+        track_bboxes = bbox_cxcyah_to_xyxy(track_bboxes)
+
+        # compute distance
+        ious = bbox_overlaps(track_bboxes, det_bboxes)
+        if weight_iou_with_det_scores:
+            ious *= det_scores
+
+        # support multi-class association
+        track_labels = torch.tensor([
+            self.tracks[id]['labels'][-1] for id in ids
+        ]).to(det_bboxes.device)
+        cate_match = det_labels[None, :] == track_labels[:, None]
+        # to avoid det and track of different categories are matched
+        cate_cost = (1 - cate_match.int()) * 1e6
+
+        dists = (1 - ious + cate_cost).cpu().numpy()
+
+        if len(ids) > 0 and len(det_bboxes) > 0:
+            track_velocities = torch.stack(
+                [self.tracks[id].velocity for id in ids]).to(det_bboxes.device)
+            k_step_observations = torch.stack([
+                self.k_step_observation(self.tracks[id]) for id in ids
+            ]).to(det_bboxes.device)
+            # valid1: if the track has previous observations to estimate speed
+            # valid2: if the associated observation k steps ago is a detection
+            valid1 = track_velocities.sum(dim=1) != -2
+            valid2 = k_step_observations.sum(dim=1) != -4
+            valid = valid1 & valid2
+
+            vel_to_match = self.vel_direction_batch(k_step_observations,
+                                                    det_bboxes)
+            track_velocities = track_velocities[:, None, :].repeat(
+                1, det_bboxes.shape[0], 1)
+
+            angle_cos = (vel_to_match * track_velocities).sum(dim=-1)
+            angle_cos = torch.clamp(angle_cos, min=-1, max=1)
+            angle = torch.acos(angle_cos)  # [0, pi]
+            norm_angle = (angle - np.pi / 2.) / np.pi  # [-0.5, 0.5]
+            valid_matrix = valid[:, None].int().repeat(1, det_bboxes.shape[0])
+            # set non-valid entries 0
+            valid_norm_angle = norm_angle * valid_matrix
+
+            dists += valid_norm_angle.cpu().numpy() * self.vel_consist_weight
+
+        # bipartite match
+        if dists.size > 0:
+            cost, row, col = lap.lapjv(
+                dists, extend_cost=True, cost_limit=1 - match_iou_thr)
+        else:
+            row = np.zeros(len(ids)).astype(np.int32) - 1
+            col = np.zeros(len(det_bboxes)).astype(np.int32) - 1
+        return row, col
+
+    def last_obs(self, track: Dict):
+        """extract the last associated observation."""
+        for bbox in track.obs[::-1]:
+            if bbox is not None:
+                return bbox
+
+    def ocr_assign_ids(self,
+                       track_obs: torch.Tensor,
+                       last_track_labels: torch.Tensor,
+                       det_bboxes: torch.Tensor,
+                       det_labels: torch.Tensor,
+                       det_scores: torch.Tensor,
+                       weight_iou_with_det_scores: Optional[bool] = False,
+                       match_iou_thr: Optional[float] = 0.5):
+        """association for Observation-Centric Recovery.
+
+        As try to recover tracks from being lost whose estimated velocity is
+        out- to-date, we use IoU-only matching strategy.
+
+        Args:
+            track_obs (Tensor): the list of historical associated
+                detections of tracks
+            det_bboxes (Tensor): of shape (N, 5), unmatched detections
+            det_labels (Tensor): of shape (N,)
+            det_scores (Tensor): of shape (N,)
+            weight_iou_with_det_scores (bool, optional): Whether using
+                detection scores to weight IOU which is used for matching.
+                Defaults to False.
+            match_iou_thr (float, optional): Matching threshold.
+                Defaults to 0.5.
+
+        Returns:
+            tuple(int): The assigning ids.
+        """
+        # compute distance
+        ious = bbox_overlaps(track_obs, det_bboxes)
+        if weight_iou_with_det_scores:
+            ious *= det_scores
+
+        # support multi-class association
+        cate_match = det_labels[None, :] == last_track_labels[:, None]
+        # to avoid det and track of different categories are matched
+        cate_cost = (1 - cate_match.int()) * 1e6
+
+        dists = (1 - ious + cate_cost).cpu().numpy()
+
+        # bipartite match
+        if dists.size > 0:
+            cost, row, col = lap.lapjv(
+                dists, extend_cost=True, cost_limit=1 - match_iou_thr)
+        else:
+            row = np.zeros(len(track_obs)).astype(np.int32) - 1
+            col = np.zeros(len(det_bboxes)).astype(np.int32) - 1
+        return row, col
+
+    def online_smooth(self, track: Dict, obj: torch.Tensor):
+        """Once a track is recovered from being lost, online smooth its
+        parameters to fix the error accumulated during being lost.
+
+        NOTE: you can use different virtual trajectory generation
+        strategies, we adopt the naive linear interpolation as default
+        """
+        last_match_bbox = self.last_obs(track)
+        new_match_bbox = obj
+        unmatch_len = 0
+        for bbox in track.obs[::-1]:
+            if bbox is None:
+                unmatch_len += 1
+            else:
+                break
+        bbox_shift_per_step = (new_match_bbox - last_match_bbox) / (
+            unmatch_len + 1)
+        track.mean = track.saved_attr.mean
+        track.covariance = track.saved_attr.covariance
+        for i in range(unmatch_len):
+            virtual_bbox = last_match_bbox + (i + 1) * bbox_shift_per_step
+            virtual_bbox = bbox_xyxy_to_cxcyah(virtual_bbox[None, :])
+            virtual_bbox = virtual_bbox.squeeze(0).cpu().numpy()
+            track.mean, track.covariance = self.kf.update(
+                track.mean, track.covariance, virtual_bbox)
+
+    def track(self, data_sample: DetDataSample, **kwargs) -> InstanceData:
+        """Tracking forward function.
+        NOTE: this implementation is slightly different from the original
+        OC-SORT implementation (https://github.com/noahcao/OC_SORT)that we
+        do association between detections and tentative/non-tentative tracks
+        independently while the original implementation combines them together.
+
+        Args:
+            data_sample (:obj:`DetDataSample`): The data sample.
+                It includes information such as `pred_instances`.
+
+        Returns:
+            :obj:`InstanceData`: Tracking results of the input images.
+            Each InstanceData usually contains ``bboxes``, ``labels``,
+            ``scores`` and ``instances_id``.
+        """
+        metainfo = data_sample.metainfo
+        bboxes = data_sample.pred_instances.bboxes
+        labels = data_sample.pred_instances.labels
+        scores = data_sample.pred_instances.scores
+        frame_id = metainfo.get('frame_id', -1)
+        if frame_id == 0:
+            self.reset()
+        if not hasattr(self, 'kf'):
+            self.kf = self.motion
+
+        if self.empty or bboxes.size(0) == 0:
+            valid_inds = scores > self.init_track_thr
+            scores = scores[valid_inds]
+            bboxes = bboxes[valid_inds]
+            labels = labels[valid_inds]
+            num_new_tracks = bboxes.size(0)
+            ids = torch.arange(self.num_tracks,
+                               self.num_tracks + num_new_tracks).to(labels)
+            self.num_tracks += num_new_tracks
+        else:
+            # 0. init
+            ids = torch.full((bboxes.size(0), ),
+                             -1,
+                             dtype=labels.dtype,
+                             device=labels.device)
+
+            # get the detection bboxes for the first association
+            det_inds = scores > self.obj_score_thr
+            det_bboxes = bboxes[det_inds]
+            det_labels = labels[det_inds]
+            det_scores = scores[det_inds]
+            det_ids = ids[det_inds]
+
+            # 1. predict by Kalman Filter
+            for id in self.confirmed_ids:
+                # track is lost in previous frame
+                if self.tracks[id].frame_ids[-1] != frame_id - 1:
+                    self.tracks[id].mean[7] = 0
+                if self.tracks[id].tracked:
+                    self.tracks[id].saved_attr.mean = self.tracks[id].mean
+                    self.tracks[id].saved_attr.covariance = self.tracks[
+                        id].covariance
+                (self.tracks[id].mean,
+                 self.tracks[id].covariance) = self.kf.predict(
+                     self.tracks[id].mean, self.tracks[id].covariance)
+
+            # 2. match detections and tracks' predicted locations
+            match_track_inds, raw_match_det_inds = self.ocm_assign_ids(
+                self.confirmed_ids, det_bboxes, det_labels, det_scores,
+                self.weight_iou_with_det_scores, self.match_iou_thr)
+            # '-1' mean a detection box is not matched with tracklets in
+            # previous frame
+            valid = raw_match_det_inds > -1
+            det_ids[valid] = torch.tensor(
+                self.confirmed_ids)[raw_match_det_inds[valid]].to(labels)
+
+            match_det_bboxes = det_bboxes[valid]
+            match_det_labels = det_labels[valid]
+            match_det_scores = det_scores[valid]
+            match_det_ids = det_ids[valid]
+            assert (match_det_ids > -1).all()
+
+            # unmatched tracks and detections
+            unmatch_det_bboxes = det_bboxes[~valid]
+            unmatch_det_labels = det_labels[~valid]
+            unmatch_det_scores = det_scores[~valid]
+            unmatch_det_ids = det_ids[~valid]
+            assert (unmatch_det_ids == -1).all()
+
+            # 3. use unmatched detection bboxes from the first match to match
+            # the unconfirmed tracks
+            (tentative_match_track_inds,
+             tentative_match_det_inds) = self.ocm_assign_ids(
+                 self.unconfirmed_ids, unmatch_det_bboxes, unmatch_det_labels,
+                 unmatch_det_scores, self.weight_iou_with_det_scores,
+                 self.match_iou_thr)
+            valid = tentative_match_det_inds > -1
+            unmatch_det_ids[valid] = torch.tensor(self.unconfirmed_ids)[
+                tentative_match_det_inds[valid]].to(labels)
+
+            match_det_bboxes = torch.cat(
+                (match_det_bboxes, unmatch_det_bboxes[valid]), dim=0)
+            match_det_labels = torch.cat(
+                (match_det_labels, unmatch_det_labels[valid]), dim=0)
+            match_det_scores = torch.cat(
+                (match_det_scores, unmatch_det_scores[valid]), dim=0)
+            match_det_ids = torch.cat((match_det_ids, unmatch_det_ids[valid]),
+                                      dim=0)
+            assert (match_det_ids > -1).all()
+
+            unmatch_det_bboxes = unmatch_det_bboxes[~valid]
+            unmatch_det_labels = unmatch_det_labels[~valid]
+            unmatch_det_scores = unmatch_det_scores[~valid]
+            unmatch_det_ids = unmatch_det_ids[~valid]
+            assert (unmatch_det_ids == -1).all()
+
+            all_track_ids = [id for id, _ in self.tracks.items()]
+            unmatched_track_inds = torch.tensor(
+                [ind for ind in all_track_ids if ind not in match_det_ids])
+
+            if len(unmatched_track_inds) > 0:
+                # 4. still some tracks not associated yet, perform OCR
+                last_observations = []
+                for id in unmatched_track_inds:
+                    last_box = self.last_obs(self.tracks[id.item()])
+                    last_observations.append(last_box)
+                last_observations = torch.stack(last_observations)
+                last_track_labels = torch.tensor([
+                    self.tracks[id.item()]['labels'][-1]
+                    for id in unmatched_track_inds
+                ]).to(det_bboxes.device)
+
+                remain_det_ids = torch.full((unmatch_det_bboxes.size(0), ),
+                                            -1,
+                                            dtype=labels.dtype,
+                                            device=labels.device)
+
+                _, ocr_match_det_inds = self.ocr_assign_ids(
+                    last_observations, last_track_labels, unmatch_det_bboxes,
+                    unmatch_det_labels, unmatch_det_scores,
+                    self.weight_iou_with_det_scores, self.match_iou_thr)
+
+                valid = ocr_match_det_inds > -1
+                remain_det_ids[valid] = unmatched_track_inds.clone()[
+                    ocr_match_det_inds[valid]].to(labels)
+
+                ocr_match_det_bboxes = unmatch_det_bboxes[valid]
+                ocr_match_det_labels = unmatch_det_labels[valid]
+                ocr_match_det_scores = unmatch_det_scores[valid]
+                ocr_match_det_ids = remain_det_ids[valid]
+                assert (ocr_match_det_ids > -1).all()
+
+                ocr_unmatch_det_bboxes = unmatch_det_bboxes[~valid]
+                ocr_unmatch_det_labels = unmatch_det_labels[~valid]
+                ocr_unmatch_det_scores = unmatch_det_scores[~valid]
+                ocr_unmatch_det_ids = remain_det_ids[~valid]
+                assert (ocr_unmatch_det_ids == -1).all()
+
+                unmatch_det_bboxes = ocr_unmatch_det_bboxes
+                unmatch_det_labels = ocr_unmatch_det_labels
+                unmatch_det_scores = ocr_unmatch_det_scores
+                unmatch_det_ids = ocr_unmatch_det_ids
+                match_det_bboxes = torch.cat(
+                    (match_det_bboxes, ocr_match_det_bboxes), dim=0)
+                match_det_labels = torch.cat(
+                    (match_det_labels, ocr_match_det_labels), dim=0)
+                match_det_scores = torch.cat(
+                    (match_det_scores, ocr_match_det_scores), dim=0)
+                match_det_ids = torch.cat((match_det_ids, ocr_match_det_ids),
+                                          dim=0)
+
+            # 5. summarize the track results
+            for i in range(len(match_det_ids)):
+                det_bbox = match_det_bboxes[i]
+                track_id = match_det_ids[i].item()
+                if not self.tracks[track_id].tracked:
+                    # the track is lost before this step
+                    self.online_smooth(self.tracks[track_id], det_bbox)
+
+            for track_id in all_track_ids:
+                if track_id not in match_det_ids:
+                    self.tracks[track_id].tracked = False
+                    self.tracks[track_id].obs.append(None)
+
+            bboxes = torch.cat((match_det_bboxes, unmatch_det_bboxes), dim=0)
+            labels = torch.cat((match_det_labels, unmatch_det_labels), dim=0)
+            scores = torch.cat((match_det_scores, unmatch_det_scores), dim=0)
+            ids = torch.cat((match_det_ids, unmatch_det_ids), dim=0)
+            # 6. assign new ids
+            new_track_inds = ids == -1
+
+            ids[new_track_inds] = torch.arange(
+                self.num_tracks,
+                self.num_tracks + new_track_inds.sum()).to(labels)
+            self.num_tracks += new_track_inds.sum()
+
+        self.update(
+            ids=ids,
+            bboxes=bboxes,
+            labels=labels,
+            scores=scores,
+            frame_ids=frame_id)
+
+        # update pred_track_instances
+        pred_track_instances = InstanceData()
+        pred_track_instances.bboxes = bboxes
+        pred_track_instances.labels = labels
+        pred_track_instances.scores = scores
+        pred_track_instances.instances_id = ids
+        return pred_track_instances
diff --git a/mmdetection/mmdet/models/trackers/quasi_dense_tracker.py b/mmdetection/mmdet/models/trackers/quasi_dense_tracker.py
new file mode 100644
index 00000000..c93c3c4c
--- /dev/null
+++ b/mmdetection/mmdet/models/trackers/quasi_dense_tracker.py
@@ -0,0 +1,316 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple
+
+import torch
+import torch.nn.functional as F
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS
+from mmdet.structures import TrackDataSample
+from mmdet.structures.bbox import bbox_overlaps
+from .base_tracker import BaseTracker
+
+
+@MODELS.register_module()
+class QuasiDenseTracker(BaseTracker):
+    """Tracker for Quasi-Dense Tracking.
+
+    Args:
+        init_score_thr (float): The cls_score threshold to
+            initialize a new tracklet. Defaults to 0.8.
+        obj_score_thr (float): The cls_score threshold to
+            update a tracked tracklet. Defaults to 0.5.
+        match_score_thr (float): The match threshold. Defaults to 0.5.
+        memo_tracklet_frames (int): The most frames in a tracklet memory.
+            Defaults to 10.
+        memo_backdrop_frames (int): The most frames in the backdrops.
+            Defaults to 1.
+        memo_momentum (float): The momentum value for embeds updating.
+            Defaults to 0.8.
+        nms_conf_thr (float): The nms threshold for confidence.
+            Defaults to 0.5.
+        nms_backdrop_iou_thr (float): The nms threshold for backdrop IoU.
+            Defaults to 0.3.
+        nms_class_iou_thr (float): The nms threshold for class IoU.
+            Defaults to 0.7.
+        with_cats (bool): Whether to track with the same category.
+            Defaults to True.
+        match_metric (str): The match metric. Defaults to 'bisoftmax'.
+    """
+
+    def __init__(self,
+                 init_score_thr: float = 0.8,
+                 obj_score_thr: float = 0.5,
+                 match_score_thr: float = 0.5,
+                 memo_tracklet_frames: int = 10,
+                 memo_backdrop_frames: int = 1,
+                 memo_momentum: float = 0.8,
+                 nms_conf_thr: float = 0.5,
+                 nms_backdrop_iou_thr: float = 0.3,
+                 nms_class_iou_thr: float = 0.7,
+                 with_cats: bool = True,
+                 match_metric: str = 'bisoftmax',
+                 **kwargs):
+        super().__init__(**kwargs)
+        assert 0 <= memo_momentum <= 1.0
+        assert memo_tracklet_frames >= 0
+        assert memo_backdrop_frames >= 0
+        self.init_score_thr = init_score_thr
+        self.obj_score_thr = obj_score_thr
+        self.match_score_thr = match_score_thr
+        self.memo_tracklet_frames = memo_tracklet_frames
+        self.memo_backdrop_frames = memo_backdrop_frames
+        self.memo_momentum = memo_momentum
+        self.nms_conf_thr = nms_conf_thr
+        self.nms_backdrop_iou_thr = nms_backdrop_iou_thr
+        self.nms_class_iou_thr = nms_class_iou_thr
+        self.with_cats = with_cats
+        assert match_metric in ['bisoftmax', 'softmax', 'cosine']
+        self.match_metric = match_metric
+
+        self.num_tracks = 0
+        self.tracks = dict()
+        self.backdrops = []
+
+    def reset(self):
+        """Reset the buffer of the tracker."""
+        self.num_tracks = 0
+        self.tracks = dict()
+        self.backdrops = []
+
+    def update(self, ids: Tensor, bboxes: Tensor, embeds: Tensor,
+               labels: Tensor, scores: Tensor, frame_id: int) -> None:
+        """Tracking forward function.
+
+        Args:
+            ids (Tensor): of shape(N, ).
+            bboxes (Tensor): of shape (N, 5).
+            embeds (Tensor): of shape (N, 256).
+            labels (Tensor): of shape (N, ).
+            scores (Tensor): of shape (N, ).
+            frame_id (int): The id of current frame, 0-index.
+        """
+        tracklet_inds = ids > -1
+
+        for id, bbox, embed, label, score in zip(ids[tracklet_inds],
+                                                 bboxes[tracklet_inds],
+                                                 embeds[tracklet_inds],
+                                                 labels[tracklet_inds],
+                                                 scores[tracklet_inds]):
+            id = int(id)
+            # update the tracked ones and initialize new tracks
+            if id in self.tracks.keys():
+                velocity = (bbox - self.tracks[id]['bbox']) / (
+                    frame_id - self.tracks[id]['last_frame'])
+                self.tracks[id]['bbox'] = bbox
+                self.tracks[id]['embed'] = (
+                    1 - self.memo_momentum
+                ) * self.tracks[id]['embed'] + self.memo_momentum * embed
+                self.tracks[id]['last_frame'] = frame_id
+                self.tracks[id]['label'] = label
+                self.tracks[id]['score'] = score
+                self.tracks[id]['velocity'] = (
+                    self.tracks[id]['velocity'] * self.tracks[id]['acc_frame']
+                    + velocity) / (
+                        self.tracks[id]['acc_frame'] + 1)
+                self.tracks[id]['acc_frame'] += 1
+            else:
+                self.tracks[id] = dict(
+                    bbox=bbox,
+                    embed=embed,
+                    label=label,
+                    score=score,
+                    last_frame=frame_id,
+                    velocity=torch.zeros_like(bbox),
+                    acc_frame=0)
+        # backdrop update according to IoU
+        backdrop_inds = torch.nonzero(ids == -1, as_tuple=False).squeeze(1)
+        ious = bbox_overlaps(bboxes[backdrop_inds], bboxes)
+        for i, ind in enumerate(backdrop_inds):
+            if (ious[i, :ind] > self.nms_backdrop_iou_thr).any():
+                backdrop_inds[i] = -1
+        backdrop_inds = backdrop_inds[backdrop_inds > -1]
+        # old backdrops would be removed at first
+        self.backdrops.insert(
+            0,
+            dict(
+                bboxes=bboxes[backdrop_inds],
+                embeds=embeds[backdrop_inds],
+                labels=labels[backdrop_inds]))
+
+        # pop memo
+        invalid_ids = []
+        for k, v in self.tracks.items():
+            if frame_id - v['last_frame'] >= self.memo_tracklet_frames:
+                invalid_ids.append(k)
+        for invalid_id in invalid_ids:
+            self.tracks.pop(invalid_id)
+
+        if len(self.backdrops) > self.memo_backdrop_frames:
+            self.backdrops.pop()
+
+    @property
+    def memo(self) -> Tuple[Tensor, ...]:
+        """Get tracks memory."""
+        memo_embeds = []
+        memo_ids = []
+        memo_bboxes = []
+        memo_labels = []
+        # velocity of tracks
+        memo_vs = []
+        # get tracks
+        for k, v in self.tracks.items():
+            memo_bboxes.append(v['bbox'][None, :])
+            memo_embeds.append(v['embed'][None, :])
+            memo_ids.append(k)
+            memo_labels.append(v['label'].view(1, 1))
+            memo_vs.append(v['velocity'][None, :])
+        memo_ids = torch.tensor(memo_ids, dtype=torch.long).view(1, -1)
+        # get backdrops
+        for backdrop in self.backdrops:
+            backdrop_ids = torch.full((1, backdrop['embeds'].size(0)),
+                                      -1,
+                                      dtype=torch.long)
+            backdrop_vs = torch.zeros_like(backdrop['bboxes'])
+            memo_bboxes.append(backdrop['bboxes'])
+            memo_embeds.append(backdrop['embeds'])
+            memo_ids = torch.cat([memo_ids, backdrop_ids], dim=1)
+            memo_labels.append(backdrop['labels'][:, None])
+            memo_vs.append(backdrop_vs)
+
+        memo_bboxes = torch.cat(memo_bboxes, dim=0)
+        memo_embeds = torch.cat(memo_embeds, dim=0)
+        memo_labels = torch.cat(memo_labels, dim=0).squeeze(1)
+        memo_vs = torch.cat(memo_vs, dim=0)
+        return memo_bboxes, memo_labels, memo_embeds, memo_ids.squeeze(
+            0), memo_vs
+
+    def track(self,
+              model: torch.nn.Module,
+              img: torch.Tensor,
+              feats: List[torch.Tensor],
+              data_sample: TrackDataSample,
+              rescale=True,
+              **kwargs) -> InstanceData:
+        """Tracking forward function.
+
+        Args:
+            model (nn.Module): MOT model.
+            img (Tensor): of shape (T, C, H, W) encoding input image.
+                Typically these should be mean centered and std scaled.
+                The T denotes the number of key images and usually is 1 in
+                QDTrack method.
+            feats (list[Tensor]): Multi level feature maps of `img`.
+            data_sample (:obj:`TrackDataSample`): The data sample.
+                It includes information such as `pred_instances`.
+            rescale (bool, optional): If True, the bounding boxes should be
+                rescaled to fit the original scale of the image. Defaults to
+                True.
+
+        Returns:
+            :obj:`InstanceData`: Tracking results of the input images.
+            Each InstanceData usually contains ``bboxes``, ``labels``,
+            ``scores`` and ``instances_id``.
+        """
+        metainfo = data_sample.metainfo
+        bboxes = data_sample.pred_instances.bboxes
+        labels = data_sample.pred_instances.labels
+        scores = data_sample.pred_instances.scores
+
+        frame_id = metainfo.get('frame_id', -1)
+        # create pred_track_instances
+        pred_track_instances = InstanceData()
+
+        # return zero bboxes if there is no track targets
+        if bboxes.shape[0] == 0:
+            ids = torch.zeros_like(labels)
+            pred_track_instances = data_sample.pred_instances.clone()
+            pred_track_instances.instances_id = ids
+            return pred_track_instances
+
+        # get track feats
+        rescaled_bboxes = bboxes.clone()
+        if rescale:
+            scale_factor = rescaled_bboxes.new_tensor(
+                metainfo['scale_factor']).repeat((1, 2))
+            rescaled_bboxes = rescaled_bboxes * scale_factor
+        track_feats = model.track_head.predict(feats, [rescaled_bboxes])
+        # sort according to the object_score
+        _, inds = scores.sort(descending=True)
+        bboxes = bboxes[inds]
+        scores = scores[inds]
+        labels = labels[inds]
+        embeds = track_feats[inds, :]
+
+        # duplicate removal for potential backdrops and cross classes
+        valids = bboxes.new_ones((bboxes.size(0)))
+        ious = bbox_overlaps(bboxes, bboxes)
+        for i in range(1, bboxes.size(0)):
+            thr = self.nms_backdrop_iou_thr if scores[
+                i] < self.obj_score_thr else self.nms_class_iou_thr
+            if (ious[i, :i] > thr).any():
+                valids[i] = 0
+        valids = valids == 1
+        bboxes = bboxes[valids]
+        scores = scores[valids]
+        labels = labels[valids]
+        embeds = embeds[valids, :]
+
+        # init ids container
+        ids = torch.full((bboxes.size(0), ), -1, dtype=torch.long)
+
+        # match if buffer is not empty
+        if bboxes.size(0) > 0 and not self.empty:
+            (memo_bboxes, memo_labels, memo_embeds, memo_ids,
+             memo_vs) = self.memo
+
+            if self.match_metric == 'bisoftmax':
+                feats = torch.mm(embeds, memo_embeds.t())
+                d2t_scores = feats.softmax(dim=1)
+                t2d_scores = feats.softmax(dim=0)
+                match_scores = (d2t_scores + t2d_scores) / 2
+            elif self.match_metric == 'softmax':
+                feats = torch.mm(embeds, memo_embeds.t())
+                match_scores = feats.softmax(dim=1)
+            elif self.match_metric == 'cosine':
+                match_scores = torch.mm(
+                    F.normalize(embeds, p=2, dim=1),
+                    F.normalize(memo_embeds, p=2, dim=1).t())
+            else:
+                raise NotImplementedError
+            # track with the same category
+            if self.with_cats:
+                cat_same = labels.view(-1, 1) == memo_labels.view(1, -1)
+                match_scores *= cat_same.float().to(match_scores.device)
+            # track according to match_scores
+            for i in range(bboxes.size(0)):
+                conf, memo_ind = torch.max(match_scores[i, :], dim=0)
+                id = memo_ids[memo_ind]
+                if conf > self.match_score_thr:
+                    if id > -1:
+                        # keep bboxes with high object score
+                        # and remove background bboxes
+                        if scores[i] > self.obj_score_thr:
+                            ids[i] = id
+                            match_scores[:i, memo_ind] = 0
+                            match_scores[i + 1:, memo_ind] = 0
+                        else:
+                            if conf > self.nms_conf_thr:
+                                ids[i] = -2
+        # initialize new tracks
+        new_inds = (ids == -1) & (scores > self.init_score_thr).cpu()
+        num_news = new_inds.sum()
+        ids[new_inds] = torch.arange(
+            self.num_tracks, self.num_tracks + num_news, dtype=torch.long)
+        self.num_tracks += num_news
+
+        self.update(ids, bboxes, embeds, labels, scores, frame_id)
+        tracklet_inds = ids > -1
+        # update pred_track_instances
+        pred_track_instances.bboxes = bboxes[tracklet_inds]
+        pred_track_instances.labels = labels[tracklet_inds]
+        pred_track_instances.scores = scores[tracklet_inds]
+        pred_track_instances.instances_id = ids[tracklet_inds]
+
+        return pred_track_instances
diff --git a/mmdetection/mmdet/models/trackers/sort_tracker.py b/mmdetection/mmdet/models/trackers/sort_tracker.py
new file mode 100644
index 00000000..c4a4fed9
--- /dev/null
+++ b/mmdetection/mmdet/models/trackers/sort_tracker.py
@@ -0,0 +1,268 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Tuple
+
+import numpy as np
+import torch
+from mmengine.structures import InstanceData
+
+try:
+    import motmetrics
+    from motmetrics.lap import linear_sum_assignment
+except ImportError:
+    motmetrics = None
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.structures import DetDataSample
+from mmdet.structures.bbox import bbox_overlaps, bbox_xyxy_to_cxcyah
+from mmdet.utils import OptConfigType
+from ..utils import imrenormalize
+from .base_tracker import BaseTracker
+
+
+@MODELS.register_module()
+class SORTTracker(BaseTracker):
+    """Tracker for SORT/DeepSORT.
+
+    Args:
+        obj_score_thr (float, optional): Threshold to filter the objects.
+            Defaults to 0.3.
+        motion (dict): Configuration of motion. Defaults to None.
+        reid (dict, optional): Configuration for the ReID model.
+            - num_samples (int, optional): Number of samples to calculate the
+                feature embeddings of a track. Default to 10.
+            - image_scale (tuple, optional): Input scale of the ReID model.
+                Default to (256, 128).
+            - img_norm_cfg (dict, optional): Configuration to normalize the
+                input. Default to None.
+            - match_score_thr (float, optional): Similarity threshold for the
+                matching process. Default to 2.0.
+        match_iou_thr (float, optional): Threshold of the IoU matching process.
+            Defaults to 0.7.
+        num_tentatives (int, optional): Number of continuous frames to confirm
+            a track. Defaults to 3.
+    """
+
+    def __init__(self,
+                 motion: Optional[dict] = None,
+                 obj_score_thr: float = 0.3,
+                 reid: dict = dict(
+                     num_samples=10,
+                     img_scale=(256, 128),
+                     img_norm_cfg=None,
+                     match_score_thr=2.0),
+                 match_iou_thr: float = 0.7,
+                 num_tentatives: int = 3,
+                 **kwargs):
+        if motmetrics is None:
+            raise RuntimeError('motmetrics is not installed,\
+                 please install it by: pip install motmetrics')
+        super().__init__(**kwargs)
+        if motion is not None:
+            self.motion = TASK_UTILS.build(motion)
+            assert self.motion is not None, 'SORT/Deep SORT need KalmanFilter'
+        self.obj_score_thr = obj_score_thr
+        self.reid = reid
+        self.match_iou_thr = match_iou_thr
+        self.num_tentatives = num_tentatives
+
+    @property
+    def confirmed_ids(self) -> List:
+        """Confirmed ids in the tracker."""
+        ids = [id for id, track in self.tracks.items() if not track.tentative]
+        return ids
+
+    def init_track(self, id: int, obj: Tuple[Tensor]) -> None:
+        """Initialize a track."""
+        super().init_track(id, obj)
+        self.tracks[id].tentative = True
+        bbox = bbox_xyxy_to_cxcyah(self.tracks[id].bboxes[-1])  # size = (1, 4)
+        assert bbox.ndim == 2 and bbox.shape[0] == 1
+        bbox = bbox.squeeze(0).cpu().numpy()
+        self.tracks[id].mean, self.tracks[id].covariance = self.kf.initiate(
+            bbox)
+
+    def update_track(self, id: int, obj: Tuple[Tensor]) -> None:
+        """Update a track."""
+        super().update_track(id, obj)
+        if self.tracks[id].tentative:
+            if len(self.tracks[id]['bboxes']) >= self.num_tentatives:
+                self.tracks[id].tentative = False
+        bbox = bbox_xyxy_to_cxcyah(self.tracks[id].bboxes[-1])  # size = (1, 4)
+        assert bbox.ndim == 2 and bbox.shape[0] == 1
+        bbox = bbox.squeeze(0).cpu().numpy()
+        self.tracks[id].mean, self.tracks[id].covariance = self.kf.update(
+            self.tracks[id].mean, self.tracks[id].covariance, bbox)
+
+    def pop_invalid_tracks(self, frame_id: int) -> None:
+        """Pop out invalid tracks."""
+        invalid_ids = []
+        for k, v in self.tracks.items():
+            # case1: disappeared frames >= self.num_frames_retrain
+            case1 = frame_id - v['frame_ids'][-1] >= self.num_frames_retain
+            # case2: tentative tracks but not matched in this frame
+            case2 = v.tentative and v['frame_ids'][-1] != frame_id
+            if case1 or case2:
+                invalid_ids.append(k)
+        for invalid_id in invalid_ids:
+            self.tracks.pop(invalid_id)
+
+    def track(self,
+              model: torch.nn.Module,
+              img: Tensor,
+              data_sample: DetDataSample,
+              data_preprocessor: OptConfigType = None,
+              rescale: bool = False,
+              **kwargs) -> InstanceData:
+        """Tracking forward function.
+
+        Args:
+            model (nn.Module): MOT model.
+            img (Tensor): of shape (T, C, H, W) encoding input image.
+                Typically these should be mean centered and std scaled.
+                The T denotes the number of key images and usually is 1 in
+                SORT method.
+            data_sample (:obj:`TrackDataSample`): The data sample.
+                It includes information such as `pred_det_instances`.
+            data_preprocessor (dict or ConfigDict, optional): The pre-process
+               config of :class:`TrackDataPreprocessor`.  it usually includes,
+                ``pad_size_divisor``, ``pad_value``, ``mean`` and ``std``.
+            rescale (bool, optional): If True, the bounding boxes should be
+                rescaled to fit the original scale of the image. Defaults to
+                False.
+
+        Returns:
+            :obj:`InstanceData`: Tracking results of the input images.
+            Each InstanceData usually contains ``bboxes``, ``labels``,
+            ``scores`` and ``instances_id``.
+        """
+        metainfo = data_sample.metainfo
+        bboxes = data_sample.pred_instances.bboxes
+        labels = data_sample.pred_instances.labels
+        scores = data_sample.pred_instances.scores
+
+        frame_id = metainfo.get('frame_id', -1)
+        if frame_id == 0:
+            self.reset()
+        if not hasattr(self, 'kf'):
+            self.kf = self.motion
+
+        if self.with_reid:
+            if self.reid.get('img_norm_cfg', False):
+                img_norm_cfg = dict(
+                    mean=data_preprocessor['mean'],
+                    std=data_preprocessor['std'],
+                    to_bgr=data_preprocessor['rgb_to_bgr'])
+                reid_img = imrenormalize(img, img_norm_cfg,
+                                         self.reid['img_norm_cfg'])
+            else:
+                reid_img = img.clone()
+
+        valid_inds = scores > self.obj_score_thr
+        bboxes = bboxes[valid_inds]
+        labels = labels[valid_inds]
+        scores = scores[valid_inds]
+
+        if self.empty or bboxes.size(0) == 0:
+            num_new_tracks = bboxes.size(0)
+            ids = torch.arange(
+                self.num_tracks,
+                self.num_tracks + num_new_tracks,
+                dtype=torch.long).to(bboxes.device)
+            self.num_tracks += num_new_tracks
+            if self.with_reid:
+                crops = self.crop_imgs(reid_img, metainfo, bboxes.clone(),
+                                       rescale)
+                if crops.size(0) > 0:
+                    embeds = model.reid(crops, mode='tensor')
+                else:
+                    embeds = crops.new_zeros((0, model.reid.head.out_channels))
+        else:
+            ids = torch.full((bboxes.size(0), ), -1,
+                             dtype=torch.long).to(bboxes.device)
+
+            # motion
+            self.tracks, costs = self.motion.track(self.tracks,
+                                                   bbox_xyxy_to_cxcyah(bboxes))
+
+            active_ids = self.confirmed_ids
+            if self.with_reid:
+                crops = self.crop_imgs(reid_img, metainfo, bboxes.clone(),
+                                       rescale)
+                embeds = model.reid(crops, mode='tensor')
+
+                # reid
+                if len(active_ids) > 0:
+                    track_embeds = self.get(
+                        'embeds',
+                        active_ids,
+                        self.reid.get('num_samples', None),
+                        behavior='mean')
+                    reid_dists = torch.cdist(track_embeds, embeds)
+
+                    # support multi-class association
+                    track_labels = torch.tensor([
+                        self.tracks[id]['labels'][-1] for id in active_ids
+                    ]).to(bboxes.device)
+                    cate_match = labels[None, :] == track_labels[:, None]
+                    cate_cost = (1 - cate_match.int()) * 1e6
+                    reid_dists = (reid_dists + cate_cost).cpu().numpy()
+
+                    valid_inds = [list(self.ids).index(_) for _ in active_ids]
+                    reid_dists[~np.isfinite(costs[valid_inds, :])] = np.nan
+
+                    row, col = linear_sum_assignment(reid_dists)
+                    for r, c in zip(row, col):
+                        dist = reid_dists[r, c]
+                        if not np.isfinite(dist):
+                            continue
+                        if dist <= self.reid['match_score_thr']:
+                            ids[c] = active_ids[r]
+
+            active_ids = [
+                id for id in self.ids if id not in ids
+                and self.tracks[id].frame_ids[-1] == frame_id - 1
+            ]
+            if len(active_ids) > 0:
+                active_dets = torch.nonzero(ids == -1).squeeze(1)
+                track_bboxes = self.get('bboxes', active_ids)
+                ious = bbox_overlaps(track_bboxes, bboxes[active_dets])
+
+                # support multi-class association
+                track_labels = torch.tensor([
+                    self.tracks[id]['labels'][-1] for id in active_ids
+                ]).to(bboxes.device)
+                cate_match = labels[None, active_dets] == track_labels[:, None]
+                cate_cost = (1 - cate_match.int()) * 1e6
+
+                dists = (1 - ious + cate_cost).cpu().numpy()
+
+                row, col = linear_sum_assignment(dists)
+                for r, c in zip(row, col):
+                    dist = dists[r, c]
+                    if dist < 1 - self.match_iou_thr:
+                        ids[active_dets[c]] = active_ids[r]
+
+            new_track_inds = ids == -1
+            ids[new_track_inds] = torch.arange(
+                self.num_tracks,
+                self.num_tracks + new_track_inds.sum(),
+                dtype=torch.long).to(bboxes.device)
+            self.num_tracks += new_track_inds.sum()
+
+        self.update(
+            ids=ids,
+            bboxes=bboxes,
+            scores=scores,
+            labels=labels,
+            embeds=embeds if self.with_reid else None,
+            frame_ids=frame_id)
+
+        # update pred_track_instances
+        pred_track_instances = InstanceData()
+        pred_track_instances.bboxes = bboxes
+        pred_track_instances.labels = labels
+        pred_track_instances.scores = scores
+        pred_track_instances.instances_id = ids
+
+        return pred_track_instances
diff --git a/mmdetection/mmdet/models/trackers/strongsort_tracker.py b/mmdetection/mmdet/models/trackers/strongsort_tracker.py
new file mode 100644
index 00000000..9d707570
--- /dev/null
+++ b/mmdetection/mmdet/models/trackers/strongsort_tracker.py
@@ -0,0 +1,273 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Tuple
+
+import numpy as np
+import torch
+from mmengine.structures import InstanceData
+
+try:
+    import motmetrics
+    from motmetrics.lap import linear_sum_assignment
+except ImportError:
+    motmetrics = None
+from torch import Tensor
+
+from mmdet.models.utils import imrenormalize
+from mmdet.registry import MODELS
+from mmdet.structures import TrackDataSample
+from mmdet.structures.bbox import bbox_overlaps, bbox_xyxy_to_cxcyah
+from mmdet.utils import OptConfigType
+from .sort_tracker import SORTTracker
+
+
+def cosine_distance(x: Tensor, y: Tensor) -> np.ndarray:
+    """compute the cosine distance.
+
+    Args:
+        x (Tensor): embeddings with shape (N,C).
+        y (Tensor): embeddings with shape (M,C).
+
+    Returns:
+        ndarray: cosine distance with shape (N,M).
+    """
+    x = x.cpu().numpy()
+    y = y.cpu().numpy()
+    x = x / np.linalg.norm(x, axis=1, keepdims=True)
+    y = y / np.linalg.norm(y, axis=1, keepdims=True)
+    dists = 1. - np.dot(x, y.T)
+    return dists
+
+
+@MODELS.register_module()
+class StrongSORTTracker(SORTTracker):
+    """Tracker for StrongSORT.
+
+    Args:
+        obj_score_thr (float, optional): Threshold to filter the objects.
+            Defaults to 0.6.
+        motion (dict): Configuration of motion. Defaults to None.
+        reid (dict, optional): Configuration for the ReID model.
+            - num_samples (int, optional): Number of samples to calculate the
+                feature embeddings of a track. Default to None.
+            - image_scale (tuple, optional): Input scale of the ReID model.
+                Default to (256, 128).
+            - img_norm_cfg (dict, optional): Configuration to normalize the
+                input. Default to None.
+            - match_score_thr (float, optional): Similarity threshold for the
+                matching process. Default to 0.3.
+            - motion_weight (float, optional): the weight of the motion cost.
+                Defaults to 0.02.
+        match_iou_thr (float, optional): Threshold of the IoU matching process.
+            Defaults to 0.7.
+        num_tentatives (int, optional): Number of continuous frames to confirm
+            a track. Defaults to 2.
+    """
+
+    def __init__(self,
+                 motion: Optional[dict] = None,
+                 obj_score_thr: float = 0.6,
+                 reid: dict = dict(
+                     num_samples=None,
+                     img_scale=(256, 128),
+                     img_norm_cfg=None,
+                     match_score_thr=0.3,
+                     motion_weight=0.02),
+                 match_iou_thr: float = 0.7,
+                 num_tentatives: int = 2,
+                 **kwargs):
+        if motmetrics is None:
+            raise RuntimeError('motmetrics is not installed,\
+                 please install it by: pip install motmetrics')
+        super().__init__(motion, obj_score_thr, reid, match_iou_thr,
+                         num_tentatives, **kwargs)
+
+    def update_track(self, id: int, obj: Tuple[Tensor]) -> None:
+        """Update a track."""
+        for k, v in zip(self.memo_items, obj):
+            v = v[None]
+            if self.momentums is not None and k in self.momentums:
+                m = self.momentums[k]
+                self.tracks[id][k] = (1 - m) * self.tracks[id][k] + m * v
+            else:
+                self.tracks[id][k].append(v)
+
+        if self.tracks[id].tentative:
+            if len(self.tracks[id]['bboxes']) >= self.num_tentatives:
+                self.tracks[id].tentative = False
+        bbox = bbox_xyxy_to_cxcyah(self.tracks[id].bboxes[-1])  # size = (1, 4)
+        assert bbox.ndim == 2 and bbox.shape[0] == 1
+        bbox = bbox.squeeze(0).cpu().numpy()
+        score = float(self.tracks[id].scores[-1].cpu())
+        self.tracks[id].mean, self.tracks[id].covariance = self.kf.update(
+            self.tracks[id].mean, self.tracks[id].covariance, bbox, score)
+
+    def track(self,
+              model: torch.nn.Module,
+              img: Tensor,
+              data_sample: TrackDataSample,
+              data_preprocessor: OptConfigType = None,
+              rescale: bool = False,
+              **kwargs) -> InstanceData:
+        """Tracking forward function.
+
+        Args:
+            model (nn.Module): MOT model.
+            img (Tensor): of shape (T, C, H, W) encoding input image.
+                Typically these should be mean centered and std scaled.
+                The T denotes the number of key images and usually is 1 in
+                SORT method.
+            feats (list[Tensor]): Multi level feature maps of `img`.
+            data_sample (:obj:`TrackDataSample`): The data sample.
+                It includes information such as `pred_det_instances`.
+            data_preprocessor (dict or ConfigDict, optional): The pre-process
+               config of :class:`TrackDataPreprocessor`.  it usually includes,
+                ``pad_size_divisor``, ``pad_value``, ``mean`` and ``std``.
+            rescale (bool, optional): If True, the bounding boxes should be
+                rescaled to fit the original scale of the image. Defaults to
+                False.
+
+        Returns:
+            :obj:`InstanceData`: Tracking results of the input images.
+            Each InstanceData usually contains ``bboxes``, ``labels``,
+            ``scores`` and ``instances_id``.
+        """
+        metainfo = data_sample.metainfo
+        bboxes = data_sample.pred_instances.bboxes
+        labels = data_sample.pred_instances.labels
+        scores = data_sample.pred_instances.scores
+
+        frame_id = metainfo.get('frame_id', -1)
+        if frame_id == 0:
+            self.reset()
+        if not hasattr(self, 'kf'):
+            self.kf = self.motion
+
+        if self.with_reid:
+            if self.reid.get('img_norm_cfg', False):
+                img_norm_cfg = dict(
+                    mean=data_preprocessor.get('mean', [0, 0, 0]),
+                    std=data_preprocessor.get('std', [1, 1, 1]),
+                    to_bgr=data_preprocessor.get('rgb_to_bgr', False))
+                reid_img = imrenormalize(img, img_norm_cfg,
+                                         self.reid['img_norm_cfg'])
+            else:
+                reid_img = img.clone()
+
+        valid_inds = scores > self.obj_score_thr
+        bboxes = bboxes[valid_inds]
+        labels = labels[valid_inds]
+        scores = scores[valid_inds]
+
+        if self.empty or bboxes.size(0) == 0:
+            num_new_tracks = bboxes.size(0)
+            ids = torch.arange(
+                self.num_tracks,
+                self.num_tracks + num_new_tracks,
+                dtype=torch.long).to(bboxes.device)
+            self.num_tracks += num_new_tracks
+            if self.with_reid:
+                crops = self.crop_imgs(reid_img, metainfo, bboxes.clone(),
+                                       rescale)
+                if crops.size(0) > 0:
+                    embeds = model.reid(crops, mode='tensor')
+                else:
+                    embeds = crops.new_zeros((0, model.reid.head.out_channels))
+        else:
+            ids = torch.full((bboxes.size(0), ), -1,
+                             dtype=torch.long).to(bboxes.device)
+
+            # motion
+            if model.with_cmc:
+                num_samples = 1
+                self.tracks = model.cmc.track(self.last_img, img, self.tracks,
+                                              num_samples, frame_id, metainfo)
+
+            self.tracks, motion_dists = self.motion.track(
+                self.tracks, bbox_xyxy_to_cxcyah(bboxes))
+
+            active_ids = self.confirmed_ids
+            if self.with_reid:
+                crops = self.crop_imgs(reid_img, metainfo, bboxes.clone(),
+                                       rescale)
+                embeds = model.reid(crops, mode='tensor')
+
+                # reid
+                if len(active_ids) > 0:
+                    track_embeds = self.get(
+                        'embeds',
+                        active_ids,
+                        self.reid.get('num_samples', None),
+                        behavior='mean')
+                    reid_dists = cosine_distance(track_embeds, embeds)
+                    valid_inds = [list(self.ids).index(_) for _ in active_ids]
+                    reid_dists[~np.isfinite(motion_dists[
+                        valid_inds, :])] = np.nan
+
+                    weight_motion = self.reid.get('motion_weight')
+                    match_dists = (1 - weight_motion) * reid_dists + \
+                        weight_motion * motion_dists[valid_inds]
+
+                    # support multi-class association
+                    track_labels = torch.tensor([
+                        self.tracks[id]['labels'][-1] for id in active_ids
+                    ]).to(bboxes.device)
+                    cate_match = labels[None, :] == track_labels[:, None]
+                    cate_cost = ((1 - cate_match.int()) * 1e6).cpu().numpy()
+                    match_dists = match_dists + cate_cost
+
+                    row, col = linear_sum_assignment(match_dists)
+                    for r, c in zip(row, col):
+                        dist = match_dists[r, c]
+                        if not np.isfinite(dist):
+                            continue
+                        if dist <= self.reid['match_score_thr']:
+                            ids[c] = active_ids[r]
+
+            active_ids = [
+                id for id in self.ids if id not in ids
+                and self.tracks[id].frame_ids[-1] == frame_id - 1
+            ]
+            if len(active_ids) > 0:
+                active_dets = torch.nonzero(ids == -1).squeeze(1)
+                track_bboxes = self.get('bboxes', active_ids)
+                ious = bbox_overlaps(track_bboxes, bboxes[active_dets])
+
+                # support multi-class association
+                track_labels = torch.tensor([
+                    self.tracks[id]['labels'][-1] for id in active_ids
+                ]).to(bboxes.device)
+                cate_match = labels[None, active_dets] == track_labels[:, None]
+                cate_cost = (1 - cate_match.int()) * 1e6
+
+                dists = (1 - ious + cate_cost).cpu().numpy()
+
+                row, col = linear_sum_assignment(dists)
+                for r, c in zip(row, col):
+                    dist = dists[r, c]
+                    if dist < 1 - self.match_iou_thr:
+                        ids[active_dets[c]] = active_ids[r]
+
+            new_track_inds = ids == -1
+            ids[new_track_inds] = torch.arange(
+                self.num_tracks,
+                self.num_tracks + new_track_inds.sum(),
+                dtype=torch.long).to(bboxes.device)
+            self.num_tracks += new_track_inds.sum()
+
+        self.update(
+            ids=ids,
+            bboxes=bboxes,
+            scores=scores,
+            labels=labels,
+            embeds=embeds if self.with_reid else None,
+            frame_ids=frame_id)
+        self.last_img = img
+
+        # update pred_track_instances
+        pred_track_instances = InstanceData()
+        pred_track_instances.bboxes = bboxes
+        pred_track_instances.labels = labels
+        pred_track_instances.scores = scores
+        pred_track_instances.instances_id = ids
+
+        return pred_track_instances
diff --git a/mmdetection/mmdet/models/tracking_heads/__init__.py b/mmdetection/mmdet/models/tracking_heads/__init__.py
new file mode 100644
index 00000000..bd1f0561
--- /dev/null
+++ b/mmdetection/mmdet/models/tracking_heads/__init__.py
@@ -0,0 +1,11 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .mask2former_track_head import Mask2FormerTrackHead
+from .quasi_dense_embed_head import QuasiDenseEmbedHead
+from .quasi_dense_track_head import QuasiDenseTrackHead
+from .roi_embed_head import RoIEmbedHead
+from .roi_track_head import RoITrackHead
+
+__all__ = [
+    'QuasiDenseEmbedHead', 'QuasiDenseTrackHead', 'Mask2FormerTrackHead',
+    'RoIEmbedHead', 'RoITrackHead'
+]
diff --git a/mmdetection/mmdet/models/tracking_heads/mask2former_track_head.py b/mmdetection/mmdet/models/tracking_heads/mask2former_track_head.py
new file mode 100644
index 00000000..0877241b
--- /dev/null
+++ b/mmdetection/mmdet/models/tracking_heads/mask2former_track_head.py
@@ -0,0 +1,729 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+from collections import defaultdict
+from typing import Dict, List, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import Conv2d
+from mmcv.ops import point_sample
+from mmengine.model import ModuleList
+from mmengine.model.weight_init import caffe2_xavier_init
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.models.dense_heads import AnchorFreeHead, MaskFormerHead
+from mmdet.models.utils import get_uncertain_point_coords_with_randomness
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.structures import TrackDataSample, TrackSampleList
+from mmdet.structures.mask import mask2bbox
+from mmdet.utils import (ConfigType, InstanceList, OptConfigType,
+                         OptMultiConfig, reduce_mean)
+from ..layers import Mask2FormerTransformerDecoder
+
+
+@MODELS.register_module()
+class Mask2FormerTrackHead(MaskFormerHead):
+    """Implements the Mask2Former head.
+
+    See `Masked-attention Mask Transformer for Universal Image
+    Segmentation `_ for details.
+
+    Args:
+        in_channels (list[int]): Number of channels in the input feature map.
+        feat_channels (int): Number of channels for features.
+        out_channels (int): Number of channels for output.
+        num_classes (int): Number of VIS classes.
+        num_queries (int): Number of query in Transformer decoder.
+            Defaults to 100.
+        num_transformer_feat_level (int): Number of feats levels.
+            Defaults to 3.
+        pixel_decoder (:obj:`ConfigDict` or dict): Config for pixel
+            decoder.
+        enforce_decoder_input_project (bool, optional): Whether to add
+            a layer to change the embed_dim of transformer encoder in
+            pixel decoder to the embed_dim of transformer decoder.
+            Defaults to False.
+        transformer_decoder (:obj:`ConfigDict` or dict): Config for
+            transformer decoder.
+        positional_encoding (:obj:`ConfigDict` or dict): Config for
+            transformer decoder position encoding.
+            Defaults to `SinePositionalEncoding3D`.
+        loss_cls (:obj:`ConfigDict` or dict): Config of the classification
+            loss. Defaults to `CrossEntropyLoss`.
+        loss_mask (:obj:`ConfigDict` or dict): Config of the mask loss.
+            Defaults to 'CrossEntropyLoss'.
+        loss_dice (:obj:`ConfigDict` or dict): Config of the dice loss.
+            Defaults to 'DiceLoss'.
+        train_cfg (:obj:`ConfigDict` or dict, optional): Training config of
+            Mask2Former head. Defaults to None.
+        test_cfg (:obj:`ConfigDict` or dict, optional): Testing config of
+            Mask2Former head. Defaults to None.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict], optional): Initialization config dict. Defaults to None.
+    """
+
+    def __init__(self,
+                 in_channels: List[int],
+                 feat_channels: int,
+                 out_channels: int,
+                 num_classes: int,
+                 num_frames: int = 2,
+                 num_queries: int = 100,
+                 num_transformer_feat_level: int = 3,
+                 pixel_decoder: ConfigType = ...,
+                 enforce_decoder_input_project: bool = False,
+                 transformer_decoder: ConfigType = ...,
+                 positional_encoding: ConfigType = dict(
+                     num_feats=128, normalize=True),
+                 loss_cls: ConfigType = dict(
+                     type='CrossEntropyLoss',
+                     use_sigmoid=False,
+                     loss_weight=2.0,
+                     reduction='mean',
+                     class_weight=[1.0] * 133 + [0.1]),
+                 loss_mask: ConfigType = dict(
+                     type='CrossEntropyLoss',
+                     use_sigmoid=True,
+                     reduction='mean',
+                     loss_weight=5.0),
+                 loss_dice: ConfigType = dict(
+                     type='DiceLoss',
+                     use_sigmoid=True,
+                     activate=True,
+                     reduction='mean',
+                     naive_dice=True,
+                     eps=1.0,
+                     loss_weight=5.0),
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None,
+                 **kwargs) -> None:
+        super(AnchorFreeHead, self).__init__(init_cfg=init_cfg)
+        self.num_classes = num_classes
+        self.num_frames = num_frames
+        self.num_queries = num_queries
+        self.num_transformer_feat_level = num_transformer_feat_level
+        self.num_transformer_feat_level = num_transformer_feat_level
+        self.num_heads = transformer_decoder.layer_cfg.cross_attn_cfg.num_heads
+        self.num_transformer_decoder_layers = transformer_decoder.num_layers
+        assert pixel_decoder.encoder.layer_cfg. \
+            self_attn_cfg.num_levels == num_transformer_feat_level
+        pixel_decoder_ = copy.deepcopy(pixel_decoder)
+        pixel_decoder_.update(
+            in_channels=in_channels,
+            feat_channels=feat_channels,
+            out_channels=out_channels)
+        self.pixel_decoder = MODELS.build(pixel_decoder_)
+        self.transformer_decoder = Mask2FormerTransformerDecoder(
+            **transformer_decoder)
+        self.decoder_embed_dims = self.transformer_decoder.embed_dims
+
+        self.decoder_input_projs = ModuleList()
+        # from low resolution to high resolution
+        for _ in range(num_transformer_feat_level):
+            if (self.decoder_embed_dims != feat_channels
+                    or enforce_decoder_input_project):
+                self.decoder_input_projs.append(
+                    Conv2d(
+                        feat_channels, self.decoder_embed_dims, kernel_size=1))
+            else:
+                self.decoder_input_projs.append(nn.Identity())
+        self.decoder_positional_encoding = MODELS.build(positional_encoding)
+        self.query_embed = nn.Embedding(self.num_queries, feat_channels)
+        self.query_feat = nn.Embedding(self.num_queries, feat_channels)
+        # from low resolution to high resolution
+        self.level_embed = nn.Embedding(self.num_transformer_feat_level,
+                                        feat_channels)
+
+        self.cls_embed = nn.Linear(feat_channels, self.num_classes + 1)
+        self.mask_embed = nn.Sequential(
+            nn.Linear(feat_channels, feat_channels), nn.ReLU(inplace=True),
+            nn.Linear(feat_channels, feat_channels), nn.ReLU(inplace=True),
+            nn.Linear(feat_channels, out_channels))
+
+        self.test_cfg = test_cfg
+        self.train_cfg = train_cfg
+        if train_cfg:
+            self.assigner = TASK_UTILS.build(self.train_cfg.assigner)
+            self.sampler = TASK_UTILS.build(
+                # self.train_cfg.sampler, default_args=dict(context=self))
+                self.train_cfg['sampler'],
+                default_args=dict(context=self))
+            self.num_points = self.train_cfg.get('num_points', 12544)
+            self.oversample_ratio = self.train_cfg.get('oversample_ratio', 3.0)
+            self.importance_sample_ratio = self.train_cfg.get(
+                'importance_sample_ratio', 0.75)
+
+        self.class_weight = loss_cls.class_weight
+        self.loss_cls = MODELS.build(loss_cls)
+        self.loss_mask = MODELS.build(loss_mask)
+        self.loss_dice = MODELS.build(loss_dice)
+
+    def init_weights(self) -> None:
+        for m in self.decoder_input_projs:
+            if isinstance(m, Conv2d):
+                caffe2_xavier_init(m, bias=0)
+
+        self.pixel_decoder.init_weights()
+
+        for p in self.transformer_decoder.parameters():
+            if p.dim() > 1:
+                nn.init.xavier_normal_(p)
+
+    def preprocess_gt(self, batch_gt_instances: InstanceList) -> InstanceList:
+        """Preprocess the ground truth for all images.
+
+        It aims to reorganize the `gt`. For example, in the
+        `batch_data_sample.gt_instances.mask`, its shape is
+        `(all_num_gts, h, w)`, but we don't know each gt belongs to which `img`
+        (assume `num_frames` is 2). So, this func used to reshape the `gt_mask`
+        to `(num_gts_per_img, num_frames, h, w)`. In addition, we can't
+        guarantee that the number of instances in these two images is equal,
+        so `-1` refers to nonexistent instances.
+
+        Args:
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``labels``, each is
+                ground truth labels of each bbox, with shape (num_gts, )
+                and ``masks``, each is ground truth masks of each instances
+                of an image, shape (num_gts, h, w).
+
+        Returns:
+            list[obj:`InstanceData`]: each contains the following keys
+
+                - labels (Tensor): Ground truth class indices\
+                    for an image, with shape (n, ), n is the sum of\
+                    number of stuff type and number of instance in an image.
+                - masks (Tensor): Ground truth mask for a\
+                    image, with shape (n, t, h, w).
+        """
+        final_batch_gt_instances = []
+        batch_size = len(batch_gt_instances) // self.num_frames
+        for batch_idx in range(batch_size):
+            pair_gt_insatences = batch_gt_instances[batch_idx *
+                                                    self.num_frames:batch_idx *
+                                                    self.num_frames +
+                                                    self.num_frames]
+
+            assert len(
+                pair_gt_insatences
+            ) > 1, f'mask2former for vis need multi frames to train, \
+                but you only use {len(pair_gt_insatences)} frames'
+
+            _device = pair_gt_insatences[0].labels.device
+
+            for gt_instances in pair_gt_insatences:
+                gt_instances.masks = gt_instances.masks.to_tensor(
+                    dtype=torch.bool, device=_device)
+            all_ins_id = torch.cat([
+                gt_instances.instances_ids
+                for gt_instances in pair_gt_insatences
+            ])
+            all_ins_id = all_ins_id.unique().tolist()
+            map_ins_id = dict()
+            for i, ins_id in enumerate(all_ins_id):
+                map_ins_id[ins_id] = i
+
+            num_instances = len(all_ins_id)
+            mask_shape = [
+                num_instances, self.num_frames,
+                pair_gt_insatences[0].masks.shape[1],
+                pair_gt_insatences[0].masks.shape[2]
+            ]
+            gt_masks_per_video = torch.zeros(
+                mask_shape, dtype=torch.bool, device=_device)
+            gt_ids_per_video = torch.full((num_instances, self.num_frames),
+                                          -1,
+                                          dtype=torch.long,
+                                          device=_device)
+            gt_labels_per_video = torch.full((num_instances, ),
+                                             -1,
+                                             dtype=torch.long,
+                                             device=_device)
+
+            for frame_id in range(self.num_frames):
+                cur_frame_gts = pair_gt_insatences[frame_id]
+                ins_ids = cur_frame_gts.instances_ids.tolist()
+                for i, id in enumerate(ins_ids):
+                    gt_masks_per_video[map_ins_id[id],
+                                       frame_id, :, :] = cur_frame_gts.masks[i]
+                    gt_ids_per_video[map_ins_id[id],
+                                     frame_id] = cur_frame_gts.instances_ids[i]
+                    gt_labels_per_video[
+                        map_ins_id[id]] = cur_frame_gts.labels[i]
+
+            tmp_instances = InstanceData(
+                labels=gt_labels_per_video,
+                masks=gt_masks_per_video.long(),
+                instances_id=gt_ids_per_video)
+            final_batch_gt_instances.append(tmp_instances)
+
+        return final_batch_gt_instances
+
+    def _get_targets_single(self, cls_score: Tensor, mask_pred: Tensor,
+                            gt_instances: InstanceData,
+                            img_meta: dict) -> Tuple[Tensor]:
+        """Compute classification and mask targets for one image.
+
+        Args:
+            cls_score (Tensor): Mask score logits from a single decoder layer
+                for one image. Shape (num_queries, cls_out_channels).
+            mask_pred (Tensor): Mask logits for a single decoder layer for one
+                image. Shape (num_queries, num_frames, h, w).
+            gt_instances (:obj:`InstanceData`): It contains ``labels`` and
+                ``masks``.
+            img_meta (dict): Image informtation.
+
+        Returns:
+            tuple[Tensor]: A tuple containing the following for one image.
+
+                - labels (Tensor): Labels of each image. \
+                    shape (num_queries, ).
+                - label_weights (Tensor): Label weights of each image. \
+                    shape (num_queries, ).
+                - mask_targets (Tensor): Mask targets of each image. \
+                    shape (num_queries, num_frames, h, w).
+                - mask_weights (Tensor): Mask weights of each image. \
+                    shape (num_queries, ).
+                - pos_inds (Tensor): Sampled positive indices for each \
+                    image.
+                - neg_inds (Tensor): Sampled negative indices for each \
+                    image.
+                - sampling_result (:obj:`SamplingResult`): Sampling results.
+        """
+        # (num_gts, )
+        gt_labels = gt_instances.labels
+        # (num_gts, num_frames, h, w)
+        gt_masks = gt_instances.masks
+        # sample points
+        num_queries = cls_score.shape[0]
+        num_gts = gt_labels.shape[0]
+
+        point_coords = torch.rand((1, self.num_points, 2),
+                                  device=cls_score.device)
+
+        # shape (num_queries, num_points)
+        mask_points_pred = point_sample(mask_pred,
+                                        point_coords.repeat(num_queries, 1,
+                                                            1)).flatten(1)
+        # shape (num_gts, num_points)
+        gt_points_masks = point_sample(gt_masks.float(),
+                                       point_coords.repeat(num_gts, 1,
+                                                           1)).flatten(1)
+
+        sampled_gt_instances = InstanceData(
+            labels=gt_labels, masks=gt_points_masks)
+        sampled_pred_instances = InstanceData(
+            scores=cls_score, masks=mask_points_pred)
+        # assign and sample
+        assign_result = self.assigner.assign(
+            pred_instances=sampled_pred_instances,
+            gt_instances=sampled_gt_instances,
+            img_meta=img_meta)
+        pred_instances = InstanceData(scores=cls_score, masks=mask_pred)
+        sampling_result = self.sampler.sample(
+            assign_result=assign_result,
+            pred_instances=pred_instances,
+            gt_instances=gt_instances)
+        pos_inds = sampling_result.pos_inds
+        neg_inds = sampling_result.neg_inds
+
+        # label target
+        labels = gt_labels.new_full((self.num_queries, ),
+                                    self.num_classes,
+                                    dtype=torch.long)
+        labels[pos_inds] = gt_labels[sampling_result.pos_assigned_gt_inds]
+        label_weights = gt_labels.new_ones((self.num_queries, ))
+
+        # mask target
+        mask_targets = gt_masks[sampling_result.pos_assigned_gt_inds]
+        mask_weights = mask_pred.new_zeros((self.num_queries, ))
+        mask_weights[pos_inds] = 1.0
+
+        return (labels, label_weights, mask_targets, mask_weights, pos_inds,
+                neg_inds, sampling_result)
+
+    def _loss_by_feat_single(self, cls_scores: Tensor, mask_preds: Tensor,
+                             batch_gt_instances: List[InstanceData],
+                             batch_img_metas: List[dict]) -> Tuple[Tensor]:
+        """Loss function for outputs from a single decoder layer.
+
+        Args:
+            cls_scores (Tensor): Mask score logits from a single decoder layer
+                for all images. Shape (batch_size, num_queries,
+                cls_out_channels). Note `cls_out_channels` should include
+                background.
+            mask_preds (Tensor): Mask logits for a pixel decoder for all
+                images. Shape (batch_size, num_queries, num_frames,h, w).
+            batch_gt_instances (list[obj:`InstanceData`]): each contains
+                ``labels`` and ``masks``.
+            batch_img_metas (list[dict]): List of image meta information.
+
+        Returns:
+            tuple[Tensor]: Loss components for outputs from a single \
+                decoder layer.
+        """
+        num_imgs = cls_scores.size(0)
+        cls_scores_list = [cls_scores[i] for i in range(num_imgs)]
+        mask_preds_list = [mask_preds[i] for i in range(num_imgs)]
+        (labels_list, label_weights_list, mask_targets_list, mask_weights_list,
+         avg_factor) = self.get_targets(cls_scores_list, mask_preds_list,
+                                        batch_gt_instances, batch_img_metas)
+        # shape (batch_size, num_queries)
+        labels = torch.stack(labels_list, dim=0)
+        # shape (batch_size, num_queries)
+        label_weights = torch.stack(label_weights_list, dim=0)
+        # shape (num_total_gts, num_frames, h, w)
+        mask_targets = torch.cat(mask_targets_list, dim=0)
+        # shape (batch_size, num_queries)
+        mask_weights = torch.stack(mask_weights_list, dim=0)
+
+        # classfication loss
+        # shape (batch_size * num_queries, )
+        cls_scores = cls_scores.flatten(0, 1)
+        labels = labels.flatten(0, 1)
+        label_weights = label_weights.flatten(0, 1)
+
+        class_weight = cls_scores.new_tensor(self.class_weight)
+        loss_cls = self.loss_cls(
+            cls_scores,
+            labels,
+            label_weights,
+            avg_factor=class_weight[labels].sum())
+
+        num_total_masks = reduce_mean(cls_scores.new_tensor([avg_factor]))
+        num_total_masks = max(num_total_masks, 1)
+
+        # extract positive ones
+        # shape (batch_size, num_queries, num_frames, h, w)
+        # -> (num_total_gts, num_frames, h, w)
+        mask_preds = mask_preds[mask_weights > 0]
+
+        if mask_targets.shape[0] == 0:
+            # zero match
+            loss_dice = mask_preds.sum()
+            loss_mask = mask_preds.sum()
+            return loss_cls, loss_mask, loss_dice
+
+        with torch.no_grad():
+            points_coords = get_uncertain_point_coords_with_randomness(
+                mask_preds.flatten(0, 1).unsqueeze(1), None, self.num_points,
+                self.oversample_ratio, self.importance_sample_ratio)
+            # shape (num_total_gts * num_frames, h, w) ->
+            # (num_total_gts, num_points)
+            mask_point_targets = point_sample(
+                mask_targets.flatten(0, 1).unsqueeze(1).float(),
+                points_coords).squeeze(1)
+        # shape (num_total_gts * num_frames, num_points)
+        mask_point_preds = point_sample(
+            mask_preds.flatten(0, 1).unsqueeze(1), points_coords).squeeze(1)
+
+        # dice loss
+        loss_dice = self.loss_dice(
+            mask_point_preds, mask_point_targets, avg_factor=num_total_masks)
+
+        # mask loss
+        # shape (num_total_gts * num_frames, num_points) ->
+        # (num_total_gts * num_frames * num_points, )
+        mask_point_preds = mask_point_preds.reshape(-1)
+        # shape (num_total_gts, num_points) -> (num_total_gts * num_points, )
+        mask_point_targets = mask_point_targets.reshape(-1)
+        loss_mask = self.loss_mask(
+            mask_point_preds,
+            mask_point_targets,
+            avg_factor=num_total_masks * self.num_points / self.num_frames)
+
+        return loss_cls, loss_mask, loss_dice
+
+    def _forward_head(
+        self, decoder_out: Tensor, mask_feature: Tensor,
+        attn_mask_target_size: Tuple[int,
+                                     int]) -> Tuple[Tensor, Tensor, Tensor]:
+        """Forward for head part which is called after every decoder layer.
+
+        Args:
+            decoder_out (Tensor): in shape (num_queries, batch_size, c).
+            mask_feature (Tensor): in shape (batch_size, t, c, h, w).
+            attn_mask_target_size (tuple[int, int]): target attention
+                mask size.
+
+        Returns:
+            tuple: A tuple contain three elements.
+
+                - cls_pred (Tensor): Classification scores in shape \
+                    (batch_size, num_queries, cls_out_channels). \
+                    Note `cls_out_channels` should include background.
+                - mask_pred (Tensor): Mask scores in shape \
+                    (batch_size, num_queries,h, w).
+                - attn_mask (Tensor): Attention mask in shape \
+                    (batch_size * num_heads, num_queries, h, w).
+        """
+        decoder_out = self.transformer_decoder.post_norm(decoder_out)
+        cls_pred = self.cls_embed(decoder_out)
+        mask_embed = self.mask_embed(decoder_out)
+
+        # shape (batch_size, num_queries, t, h, w)
+        mask_pred = torch.einsum('bqc,btchw->bqthw', mask_embed, mask_feature)
+        b, q, t, _, _ = mask_pred.shape
+
+        attn_mask = F.interpolate(
+            mask_pred.flatten(0, 1),
+            attn_mask_target_size,
+            mode='bilinear',
+            align_corners=False).view(b, q, t, attn_mask_target_size[0],
+                                      attn_mask_target_size[1])
+
+        # shape (batch_size, num_queries, t, h, w) ->
+        # (batch_size, num_queries, t*h*w) ->
+        # (batch_size, num_head, num_queries, t*h*w) ->
+        # (batch_size*num_head, num_queries, t*h*w)
+        attn_mask = attn_mask.flatten(2).unsqueeze(1).repeat(
+            (1, self.num_heads, 1, 1)).flatten(0, 1)
+        attn_mask = attn_mask.sigmoid() < 0.5
+        attn_mask = attn_mask.detach()
+
+        return cls_pred, mask_pred, attn_mask
+
+    def forward(
+            self, x: List[Tensor], data_samples: TrackDataSample
+    ) -> Tuple[List[Tensor], List[Tensor]]:
+        """Forward function.
+
+        Args:
+            x (list[Tensor]): Multi scale Features from the
+                upstream network, each is a 4D-tensor.
+            data_samples (List[:obj:`TrackDataSample`]): The Data
+                Samples. It usually includes information such as `gt_instance`.
+
+        Returns:
+            tuple[list[Tensor]]: A tuple contains two elements.
+
+                - cls_pred_list (list[Tensor)]: Classification logits \
+                    for each decoder layer. Each is a 3D-tensor with shape \
+                    (batch_size, num_queries, cls_out_channels). \
+                    Note `cls_out_channels` should include background.
+                - mask_pred_list (list[Tensor]): Mask logits for each \
+                    decoder layer. Each with shape (batch_size, num_queries, \
+                    h, w).
+        """
+        mask_features, multi_scale_memorys = self.pixel_decoder(x)
+        bt, c_m, h_m, w_m = mask_features.shape
+        batch_size = bt // self.num_frames if self.training else 1
+        t = bt // batch_size
+        mask_features = mask_features.view(batch_size, t, c_m, h_m, w_m)
+        # multi_scale_memorys (from low resolution to high resolution)
+        decoder_inputs = []
+        decoder_positional_encodings = []
+        for i in range(self.num_transformer_feat_level):
+            decoder_input = self.decoder_input_projs[i](multi_scale_memorys[i])
+            decoder_input = decoder_input.flatten(2)
+            level_embed = self.level_embed.weight[i][None, :, None]
+            decoder_input = decoder_input + level_embed
+            _, c, hw = decoder_input.shape
+            # shape (batch_size*t, c, h, w) ->
+            # (batch_size, t, c, hw) ->
+            # (batch_size, t*h*w, c)
+            decoder_input = decoder_input.view(batch_size, t, c,
+                                               hw).permute(0, 1, 3,
+                                                           2).flatten(1, 2)
+            # shape (batch_size, c, h, w) -> (h*w, batch_size, c)
+            mask = decoder_input.new_zeros(
+                (batch_size, t) + multi_scale_memorys[i].shape[-2:],
+                dtype=torch.bool)
+            decoder_positional_encoding = self.decoder_positional_encoding(
+                mask)
+            decoder_positional_encoding = decoder_positional_encoding.flatten(
+                3).permute(0, 1, 3, 2).flatten(1, 2)
+            decoder_inputs.append(decoder_input)
+            decoder_positional_encodings.append(decoder_positional_encoding)
+        # shape (num_queries, c) -> (batch_size, num_queries, c)
+        query_feat = self.query_feat.weight.unsqueeze(0).repeat(
+            (batch_size, 1, 1))
+        query_embed = self.query_embed.weight.unsqueeze(0).repeat(
+            (batch_size, 1, 1))
+
+        cls_pred_list = []
+        mask_pred_list = []
+        cls_pred, mask_pred, attn_mask = self._forward_head(
+            query_feat, mask_features, multi_scale_memorys[0].shape[-2:])
+        cls_pred_list.append(cls_pred)
+        mask_pred_list.append(mask_pred)
+
+        for i in range(self.num_transformer_decoder_layers):
+            level_idx = i % self.num_transformer_feat_level
+            # if a mask is all True(all background), then set it all False.
+            attn_mask[torch.where(
+                attn_mask.sum(-1) == attn_mask.shape[-1])] = False
+
+            # cross_attn + self_attn
+            layer = self.transformer_decoder.layers[i]
+            query_feat = layer(
+                query=query_feat,
+                key=decoder_inputs[level_idx],
+                value=decoder_inputs[level_idx],
+                query_pos=query_embed,
+                key_pos=decoder_positional_encodings[level_idx],
+                cross_attn_mask=attn_mask,
+                query_key_padding_mask=None,
+                # here we do not apply masking on padded region
+                key_padding_mask=None)
+            cls_pred, mask_pred, attn_mask = self._forward_head(
+                query_feat, mask_features, multi_scale_memorys[
+                    (i + 1) % self.num_transformer_feat_level].shape[-2:])
+
+            cls_pred_list.append(cls_pred)
+            mask_pred_list.append(mask_pred)
+
+        return cls_pred_list, mask_pred_list
+
+    def loss(
+        self,
+        x: Tuple[Tensor],
+        data_samples: TrackSampleList,
+    ) -> Dict[str, Tensor]:
+        """Perform forward propagation and loss calculation of the track head
+        on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Multi-level features from the upstream
+                network, each is a 4D-tensor.
+            data_samples (List[:obj:`TrackDataSample`]): The Data
+                Samples. It usually includes information such as `gt_instance`.
+
+        Returns:
+            dict[str, Tensor]: a dictionary of loss components
+        """
+        batch_img_metas = []
+        batch_gt_instances = []
+
+        for data_sample in data_samples:
+            video_img_metas = defaultdict(list)
+            for image_idx in range(len(data_sample)):
+                batch_gt_instances.append(data_sample[image_idx].gt_instances)
+                for key, value in data_sample[image_idx].metainfo.items():
+                    video_img_metas[key].append(value)
+            batch_img_metas.append(video_img_metas)
+
+        # forward
+        all_cls_scores, all_mask_preds = self(x, data_samples)
+
+        # preprocess ground truth
+        batch_gt_instances = self.preprocess_gt(batch_gt_instances)
+        # loss
+        losses = self.loss_by_feat(all_cls_scores, all_mask_preds,
+                                   batch_gt_instances, batch_img_metas)
+
+        return losses
+
+    def predict(self,
+                x: Tuple[Tensor],
+                data_samples: TrackDataSample,
+                rescale: bool = True) -> InstanceList:
+        """Test without augmentation.
+
+        Args:
+            x (tuple[Tensor]): Multi-level features from the
+                upstream network, each is a 4D-tensor.
+            data_samples (List[:obj:`TrackDataSample`]): The Data
+                Samples. It usually includes information such as `gt_instance`.
+            rescale (bool, Optional): If False, then returned bboxes and masks
+                will fit the scale of img, otherwise, returned bboxes and masks
+                will fit the scale of original image shape. Defaults to True.
+
+        Returns:
+            list[obj:`InstanceData`]: each contains the following keys
+                - labels (Tensor): Prediction class indices\
+                    for an image, with shape (n, ), n is the sum of\
+                    number of stuff type and number of instance in an image.
+                - masks (Tensor): Prediction mask for a\
+                    image, with shape (n, t, h, w).
+        """
+
+        batch_img_metas = [
+            data_samples[img_idx].metainfo
+            for img_idx in range(len(data_samples))
+        ]
+        all_cls_scores, all_mask_preds = self(x, data_samples)
+        mask_cls_results = all_cls_scores[-1]
+        mask_pred_results = all_mask_preds[-1]
+
+        mask_cls_results = mask_cls_results[0]
+        # upsample masks
+        img_shape = batch_img_metas[0]['batch_input_shape']
+        mask_pred_results = F.interpolate(
+            mask_pred_results[0],
+            size=(img_shape[0], img_shape[1]),
+            mode='bilinear',
+            align_corners=False)
+
+        results = self.predict_by_feat(mask_cls_results, mask_pred_results,
+                                       batch_img_metas)
+        return results
+
+    def predict_by_feat(self,
+                        mask_cls_results: List[Tensor],
+                        mask_pred_results: List[Tensor],
+                        batch_img_metas: List[dict],
+                        rescale: bool = True) -> InstanceList:
+        """Get top-10 predictions.
+
+        Args:
+            mask_cls_results (Tensor): Mask classification logits,\
+                shape (batch_size, num_queries, cls_out_channels).
+                Note `cls_out_channels` should include background.
+            mask_pred_results (Tensor): Mask logits, shape \
+                (batch_size, num_queries, h, w).
+            batch_img_metas (list[dict]): List of image meta information.
+            rescale (bool, Optional): If False, then returned bboxes and masks
+                will fit the scale of img, otherwise, returned bboxes and masks
+                will fit the scale of original image shape. Defaults to True.
+
+        Returns:
+            list[obj:`InstanceData`]: each contains the following keys
+                - labels (Tensor): Prediction class indices\
+                    for an image, with shape (n, ), n is the sum of\
+                    number of stuff type and number of instance in an image.
+                - masks (Tensor): Prediction mask for a\
+                    image, with shape (n, t, h, w).
+        """
+        results = []
+        if len(mask_cls_results) > 0:
+            scores = F.softmax(mask_cls_results, dim=-1)[:, :-1]
+            labels = torch.arange(self.num_classes).unsqueeze(0).repeat(
+                self.num_queries, 1).flatten(0, 1).to(scores.device)
+            # keep top-10 predictions
+            scores_per_image, topk_indices = scores.flatten(0, 1).topk(
+                10, sorted=False)
+            labels_per_image = labels[topk_indices]
+            topk_indices = topk_indices // self.num_classes
+            mask_pred_results = mask_pred_results[topk_indices]
+
+            img_shape = batch_img_metas[0]['img_shape']
+            mask_pred_results = \
+                mask_pred_results[:, :, :img_shape[0], :img_shape[1]]
+            if rescale:
+                # return result in original resolution
+                ori_height, ori_width = batch_img_metas[0]['ori_shape'][:2]
+                mask_pred_results = F.interpolate(
+                    mask_pred_results,
+                    size=(ori_height, ori_width),
+                    mode='bilinear',
+                    align_corners=False)
+
+            masks = mask_pred_results > 0.
+
+            # format top-10 predictions
+            for img_idx in range(len(batch_img_metas)):
+                pred_track_instances = InstanceData()
+
+                pred_track_instances.masks = masks[:, img_idx]
+                pred_track_instances.bboxes = mask2bbox(masks[:, img_idx])
+                pred_track_instances.labels = labels_per_image
+                pred_track_instances.scores = scores_per_image
+                pred_track_instances.instances_id = torch.arange(10)
+
+                results.append(pred_track_instances)
+
+            return results
diff --git a/mmdetection/mmdet/models/tracking_heads/quasi_dense_embed_head.py b/mmdetection/mmdet/models/tracking_heads/quasi_dense_embed_head.py
new file mode 100644
index 00000000..55e3c05b
--- /dev/null
+++ b/mmdetection/mmdet/models/tracking_heads/quasi_dense_embed_head.py
@@ -0,0 +1,347 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Tuple
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule
+from torch import Tensor
+from torch.nn.modules.utils import _pair
+
+from mmdet.models.task_modules import SamplingResult
+from mmdet.registry import MODELS
+from ..task_modules.tracking import embed_similarity
+
+
+@MODELS.register_module()
+class QuasiDenseEmbedHead(BaseModule):
+    """The quasi-dense roi embed head.
+
+    Args:
+        embed_channels (int): The input channel of embed features.
+            Defaults to 256.
+        softmax_temp (int): Softmax temperature. Defaults to -1.
+        loss_track (dict): The loss function for tracking. Defaults to
+            MultiPosCrossEntropyLoss.
+        loss_track_aux (dict): The auxiliary loss function for tracking.
+            Defaults to MarginL2Loss.
+        init_cfg (:obj:`ConfigDict` or dict or list[:obj:`ConfigDict` or \
+            dict]): Initialization config dict.
+    """
+
+    def __init__(self,
+                 num_convs: int = 0,
+                 num_fcs: int = 0,
+                 roi_feat_size: int = 7,
+                 in_channels: int = 256,
+                 conv_out_channels: int = 256,
+                 with_avg_pool: bool = False,
+                 fc_out_channels: int = 1024,
+                 conv_cfg: Optional[dict] = None,
+                 norm_cfg: Optional[dict] = None,
+                 embed_channels: int = 256,
+                 softmax_temp: int = -1,
+                 loss_track: Optional[dict] = None,
+                 loss_track_aux: dict = dict(
+                     type='MarginL2Loss',
+                     sample_ratio=3,
+                     margin=0.3,
+                     loss_weight=1.0,
+                     hard_mining=True),
+                 init_cfg: dict = dict(
+                     type='Xavier',
+                     layer='Linear',
+                     distribution='uniform',
+                     bias=0,
+                     override=dict(
+                         type='Normal',
+                         name='fc_embed',
+                         mean=0,
+                         std=0.01,
+                         bias=0))):
+        super(QuasiDenseEmbedHead, self).__init__(init_cfg=init_cfg)
+        self.num_convs = num_convs
+        self.num_fcs = num_fcs
+        self.roi_feat_size = _pair(roi_feat_size)
+        self.roi_feat_area = self.roi_feat_size[0] * self.roi_feat_size[1]
+        self.in_channels = in_channels
+        self.conv_out_channels = conv_out_channels
+        self.with_avg_pool = with_avg_pool
+        self.fc_out_channels = fc_out_channels
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+
+        if self.with_avg_pool:
+            self.avg_pool = nn.AvgPool2d(self.roi_feat_size)
+        # add convs and fcs
+        self.convs, self.fcs, self.last_layer_dim = self._add_conv_fc_branch(
+            self.num_convs, self.num_fcs, self.in_channels)
+        self.relu = nn.ReLU(inplace=True)
+
+        if loss_track is None:
+            loss_track = dict(
+                type='MultiPosCrossEntropyLoss', loss_weight=0.25)
+
+        self.fc_embed = nn.Linear(self.last_layer_dim, embed_channels)
+        self.softmax_temp = softmax_temp
+        self.loss_track = MODELS.build(loss_track)
+        if loss_track_aux is not None:
+            self.loss_track_aux = MODELS.build(loss_track_aux)
+        else:
+            self.loss_track_aux = None
+
+    def _add_conv_fc_branch(
+            self, num_branch_convs: int, num_branch_fcs: int,
+            in_channels: int) -> Tuple[nn.ModuleList, nn.ModuleList, int]:
+        """Add shared or separable branch. convs -> avg pool (optional) -> fcs.
+
+        Args:
+            num_branch_convs (int): The number of convoluational layers.
+            num_branch_fcs (int): The number of fully connection layers.
+            in_channels (int): The input channel of roi features.
+
+        Returns:
+            Tuple[nn.ModuleList, nn.ModuleList, int]: The convs, fcs and the
+                last layer dimension.
+        """
+        last_layer_dim = in_channels
+        # add branch specific conv layers
+        branch_convs = nn.ModuleList()
+        if num_branch_convs > 0:
+            for i in range(num_branch_convs):
+                conv_in_channels = (
+                    last_layer_dim if i == 0 else self.conv_out_channels)
+                branch_convs.append(
+                    ConvModule(
+                        conv_in_channels,
+                        self.conv_out_channels,
+                        3,
+                        padding=1,
+                        conv_cfg=self.conv_cfg,
+                        norm_cfg=self.norm_cfg))
+            last_layer_dim = self.conv_out_channels
+
+        # add branch specific fc layers
+        branch_fcs = nn.ModuleList()
+        if num_branch_fcs > 0:
+            if not self.with_avg_pool:
+                last_layer_dim *= self.roi_feat_area
+            for i in range(num_branch_fcs):
+                fc_in_channels = (
+                    last_layer_dim if i == 0 else self.fc_out_channels)
+                branch_fcs.append(
+                    nn.Linear(fc_in_channels, self.fc_out_channels))
+            last_layer_dim = self.fc_out_channels
+
+        return branch_convs, branch_fcs, last_layer_dim
+
+    def forward(self, x: Tensor) -> Tensor:
+        """Forward function.
+
+        Args:
+            x (Tensor): The input features from ROI head.
+
+        Returns:
+            Tensor: The embedding feature map.
+        """
+
+        if self.num_convs > 0:
+            for conv in self.convs:
+                x = conv(x)
+        x = x.flatten(1)
+        if self.num_fcs > 0:
+            for fc in self.fcs:
+                x = self.relu(fc(x))
+        x = self.fc_embed(x)
+        return x
+
+    def get_targets(
+            self, gt_match_indices: List[Tensor],
+            key_sampling_results: List[SamplingResult],
+            ref_sampling_results: List[SamplingResult]) -> Tuple[List, List]:
+        """Calculate the track targets and track weights for all samples in a
+        batch according to the sampling_results.
+
+        Args:
+            gt_match_indices (list(Tensor)): Mapping from gt_instance_ids to
+                ref_gt_instance_ids of the same tracklet in a pair of images.
+            key_sampling_results (List[obj:SamplingResult]): Assign results of
+                all images in a batch after sampling.
+            ref_sampling_results (List[obj:SamplingResult]): Assign results of
+                all reference images in a batch after sampling.
+
+        Returns:
+            Tuple[list[Tensor]]: Association results.
+            Containing the following list of Tensors:
+
+                - track_targets (list[Tensor]): The mapping instance ids from
+                    all positive proposals in the key image to all proposals
+                    in the reference image, each tensor in list has
+                    shape (len(key_pos_bboxes), len(ref_bboxes)).
+                - track_weights (list[Tensor]): Loss weights for all positive
+                    proposals in a batch, each tensor in list has
+                    shape (len(key_pos_bboxes),).
+        """
+
+        track_targets = []
+        track_weights = []
+        for _gt_match_indices, key_res, ref_res in zip(gt_match_indices,
+                                                       key_sampling_results,
+                                                       ref_sampling_results):
+            targets = _gt_match_indices.new_zeros(
+                (key_res.pos_bboxes.size(0), ref_res.bboxes.size(0)),
+                dtype=torch.int)
+            _match_indices = _gt_match_indices[key_res.pos_assigned_gt_inds]
+            pos2pos = (_match_indices.view(
+                -1, 1) == ref_res.pos_assigned_gt_inds.view(1, -1)).int()
+            targets[:, :pos2pos.size(1)] = pos2pos
+            weights = (targets.sum(dim=1) > 0).float()
+            track_targets.append(targets)
+            track_weights.append(weights)
+        return track_targets, track_weights
+
+    def match(
+        self, key_embeds: Tensor, ref_embeds: Tensor,
+        key_sampling_results: List[SamplingResult],
+        ref_sampling_results: List[SamplingResult]
+    ) -> Tuple[List[Tensor], List[Tensor]]:
+        """Calculate the dist matrixes for loss measurement.
+
+        Args:
+            key_embeds (Tensor): Embeds of positive bboxes in sampling results
+                of key image.
+            ref_embeds (Tensor): Embeds of all bboxes in sampling results
+                of the reference image.
+            key_sampling_results (List[obj:SamplingResults]): Assign results of
+                all images in a batch after sampling.
+            ref_sampling_results (List[obj:SamplingResults]): Assign results of
+                all reference images in a batch after sampling.
+
+        Returns:
+            Tuple[list[Tensor]]: Calculation results.
+            Containing the following list of Tensors:
+
+                - dists (list[Tensor]): Dot-product dists between
+                    key_embeds and ref_embeds, each tensor in list has
+                    shape (len(key_pos_bboxes), len(ref_bboxes)).
+                - cos_dists (list[Tensor]): Cosine dists between
+                    key_embeds and ref_embeds, each tensor in list has
+                    shape (len(key_pos_bboxes), len(ref_bboxes)).
+        """
+
+        num_key_rois = [res.pos_bboxes.size(0) for res in key_sampling_results]
+        key_embeds = torch.split(key_embeds, num_key_rois)
+        num_ref_rois = [res.bboxes.size(0) for res in ref_sampling_results]
+        ref_embeds = torch.split(ref_embeds, num_ref_rois)
+
+        dists, cos_dists = [], []
+        for key_embed, ref_embed in zip(key_embeds, ref_embeds):
+            dist = embed_similarity(
+                key_embed,
+                ref_embed,
+                method='dot_product',
+                temperature=self.softmax_temp)
+            dists.append(dist)
+            if self.loss_track_aux is not None:
+                cos_dist = embed_similarity(
+                    key_embed, ref_embed, method='cosine')
+                cos_dists.append(cos_dist)
+            else:
+                cos_dists.append(None)
+        return dists, cos_dists
+
+    def loss(self, key_roi_feats: Tensor, ref_roi_feats: Tensor,
+             key_sampling_results: List[SamplingResult],
+             ref_sampling_results: List[SamplingResult],
+             gt_match_indices_list: List[Tensor]) -> dict:
+        """Calculate the track loss and the auxiliary track loss.
+
+        Args:
+            key_roi_feats (Tensor): Embeds of positive bboxes in sampling
+                results of key image.
+            ref_roi_feats (Tensor): Embeds of all bboxes in sampling results
+                of the reference image.
+            key_sampling_results (List[obj:SamplingResults]): Assign results of
+                all images in a batch after sampling.
+            ref_sampling_results (List[obj:SamplingResults]): Assign results of
+                all reference images in a batch after sampling.
+            gt_match_indices_list (list(Tensor)): Mapping from gt_instances_ids
+                to ref_gt_instances_ids of the same tracklet in a pair of
+                images.
+
+        Returns:
+            Dict [str: Tensor]: Calculation results.
+            Containing the following list of Tensors:
+
+                - loss_track (Tensor): Results of loss_track function.
+                - loss_track_aux (Tensor): Results of loss_track_aux function.
+        """
+        key_track_feats = self(key_roi_feats)
+        ref_track_feats = self(ref_roi_feats)
+
+        losses = self.loss_by_feat(key_track_feats, ref_track_feats,
+                                   key_sampling_results, ref_sampling_results,
+                                   gt_match_indices_list)
+        return losses
+
+    def loss_by_feat(self, key_track_feats: Tensor, ref_track_feats: Tensor,
+                     key_sampling_results: List[SamplingResult],
+                     ref_sampling_results: List[SamplingResult],
+                     gt_match_indices_list: List[Tensor]) -> dict:
+        """Calculate the track loss and the auxiliary track loss.
+
+        Args:
+            key_track_feats (Tensor): Embeds of positive bboxes in sampling
+                results of key image.
+            ref_track_feats (Tensor): Embeds of all bboxes in sampling results
+                of the reference image.
+            key_sampling_results (List[obj:SamplingResults]): Assign results of
+                all images in a batch after sampling.
+            ref_sampling_results (List[obj:SamplingResults]): Assign results of
+                all reference images in a batch after sampling.
+            gt_match_indices_list (list(Tensor)): Mapping from instances_ids
+                from key image to reference image of the same tracklet in a
+                pair of images.
+
+        Returns:
+            Dict [str: Tensor]: Calculation results.
+            Containing the following list of Tensors:
+
+                - loss_track (Tensor): Results of loss_track function.
+                - loss_track_aux (Tensor): Results of loss_track_aux function.
+        """
+        dists, cos_dists = self.match(key_track_feats, ref_track_feats,
+                                      key_sampling_results,
+                                      ref_sampling_results)
+        targets, weights = self.get_targets(gt_match_indices_list,
+                                            key_sampling_results,
+                                            ref_sampling_results)
+        losses = dict()
+
+        loss_track = 0.
+        loss_track_aux = 0.
+        for _dists, _cos_dists, _targets, _weights in zip(
+                dists, cos_dists, targets, weights):
+            loss_track += self.loss_track(
+                _dists, _targets, _weights, avg_factor=_weights.sum())
+            if self.loss_track_aux is not None:
+                loss_track_aux += self.loss_track_aux(_cos_dists, _targets)
+        losses['loss_track'] = loss_track / len(dists)
+
+        if self.loss_track_aux is not None:
+            losses['loss_track_aux'] = loss_track_aux / len(dists)
+
+        return losses
+
+    def predict(self, bbox_feats: Tensor) -> Tensor:
+        """Perform forward propagation of the tracking head and predict
+        tracking results on the features of the upstream network.
+
+        Args:
+            bbox_feats: The extracted roi features.
+
+        Returns:
+            Tensor: The extracted track features.
+        """
+        track_feats = self(bbox_feats)
+        return track_feats
diff --git a/mmdetection/mmdet/models/tracking_heads/quasi_dense_track_head.py b/mmdetection/mmdet/models/tracking_heads/quasi_dense_track_head.py
new file mode 100644
index 00000000..bd078dac
--- /dev/null
+++ b/mmdetection/mmdet/models/tracking_heads/quasi_dense_track_head.py
@@ -0,0 +1,178 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional
+
+from mmengine.model import BaseModule
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.structures import TrackSampleList
+from mmdet.structures.bbox import bbox2roi
+from mmdet.utils import InstanceList
+
+
+@MODELS.register_module()
+class QuasiDenseTrackHead(BaseModule):
+    """The quasi-dense track head."""
+
+    def __init__(self,
+                 roi_extractor: Optional[dict] = None,
+                 embed_head: Optional[dict] = None,
+                 regress_head: Optional[dict] = None,
+                 train_cfg: Optional[dict] = None,
+                 test_cfg: Optional[dict] = None,
+                 init_cfg: Optional[dict] = None,
+                 **kwargs):
+        super().__init__(init_cfg=init_cfg)
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+
+        if embed_head is not None:
+            self.init_embed_head(roi_extractor, embed_head)
+
+        if regress_head is not None:
+            raise NotImplementedError('Regression head is not supported yet.')
+
+        self.init_assigner_sampler()
+
+    def init_embed_head(self, roi_extractor, embed_head) -> None:
+        """Initialize ``embed_head``
+
+        Args:
+            roi_extractor (dict, optional): Configuration of roi extractor.
+                Defaults to None.
+            embed_head (dict, optional): Configuration of embed head. Defaults
+                to None.
+        """
+        self.roi_extractor = MODELS.build(roi_extractor)
+        self.embed_head = MODELS.build(embed_head)
+
+    def init_assigner_sampler(self) -> None:
+        """Initialize assigner and sampler."""
+        self.bbox_assigner = None
+        self.bbox_sampler = None
+        if self.train_cfg:
+            self.bbox_assigner = TASK_UTILS.build(self.train_cfg.assigner)
+            self.bbox_sampler = TASK_UTILS.build(
+                self.train_cfg.sampler, default_args=dict(context=self))
+
+    @property
+    def with_track(self) -> bool:
+        """bool: whether the multi-object tracker has an embed head"""
+        return hasattr(self, 'embed_head') and self.embed_head is not None
+
+    def extract_roi_feats(self, feats: List[Tensor],
+                          bboxes: List[Tensor]) -> Tensor:
+        """Extract roi features.
+
+        Args:
+            feats (list[Tensor]): list of multi-level image features.
+            bboxes (list[Tensor]): list of bboxes in sampling result.
+
+        Returns:
+            Tensor: The extracted roi features.
+        """
+        rois = bbox2roi(bboxes)
+        bbox_feats = self.roi_extractor(feats[:self.roi_extractor.num_inputs],
+                                        rois)
+        return bbox_feats
+
+    def loss(self, key_feats: List[Tensor], ref_feats: List[Tensor],
+             rpn_results_list: InstanceList,
+             ref_rpn_results_list: InstanceList, data_samples: TrackSampleList,
+             **kwargs) -> dict:
+        """Calculate losses from a batch of inputs and data samples.
+
+        Args:
+            key_feats (list[Tensor]): list of multi-level image features.
+            ref_feats (list[Tensor]): list of multi-level ref_img features.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals of key img.
+            ref_rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals of ref img.
+            data_samples (list[:obj:`TrackDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance`.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        assert self.with_track
+        num_imgs = len(data_samples)
+        batch_gt_instances = []
+        ref_batch_gt_instances = []
+        batch_gt_instances_ignore = []
+        gt_match_indices_list = []
+        for track_data_sample in data_samples:
+            key_data_sample = track_data_sample.get_key_frames()[0]
+            ref_data_sample = track_data_sample.get_ref_frames()[0]
+            batch_gt_instances.append(key_data_sample.gt_instances)
+            ref_batch_gt_instances.append(ref_data_sample.gt_instances)
+            if 'ignored_instances' in key_data_sample:
+                batch_gt_instances_ignore.append(
+                    key_data_sample.ignored_instances)
+            else:
+                batch_gt_instances_ignore.append(None)
+            # get gt_match_indices
+            ins_ids = key_data_sample.gt_instances.instances_ids.tolist()
+            ref_ins_ids = ref_data_sample.gt_instances.instances_ids.tolist()
+            match_indices = Tensor([
+                ref_ins_ids.index(i) if (i in ref_ins_ids and i > 0) else -1
+                for i in ins_ids
+            ]).to(key_feats[0].device)
+            gt_match_indices_list.append(match_indices)
+
+        key_sampling_results, ref_sampling_results = [], []
+        for i in range(num_imgs):
+            rpn_results = rpn_results_list[i]
+            ref_rpn_results = ref_rpn_results_list[i]
+            # rename ref_rpn_results.bboxes to ref_rpn_results.priors
+            ref_rpn_results.priors = ref_rpn_results.pop('bboxes')
+
+            assign_result = self.bbox_assigner.assign(
+                rpn_results, batch_gt_instances[i],
+                batch_gt_instances_ignore[i])
+            sampling_result = self.bbox_sampler.sample(
+                assign_result,
+                rpn_results,
+                batch_gt_instances[i],
+                feats=[lvl_feat[i][None] for lvl_feat in key_feats])
+            key_sampling_results.append(sampling_result)
+
+            ref_assign_result = self.bbox_assigner.assign(
+                ref_rpn_results, ref_batch_gt_instances[i],
+                batch_gt_instances_ignore[i])
+            ref_sampling_result = self.bbox_sampler.sample(
+                ref_assign_result,
+                ref_rpn_results,
+                ref_batch_gt_instances[i],
+                feats=[lvl_feat[i][None] for lvl_feat in ref_feats])
+            ref_sampling_results.append(ref_sampling_result)
+
+        key_bboxes = [res.pos_bboxes for res in key_sampling_results]
+        key_roi_feats = self.extract_roi_feats(key_feats, key_bboxes)
+        ref_bboxes = [res.bboxes for res in ref_sampling_results]
+        ref_roi_feats = self.extract_roi_feats(ref_feats, ref_bboxes)
+
+        loss_track = self.embed_head.loss(key_roi_feats, ref_roi_feats,
+                                          key_sampling_results,
+                                          ref_sampling_results,
+                                          gt_match_indices_list)
+
+        return loss_track
+
+    def predict(self, feats: List[Tensor],
+                rescaled_bboxes: List[Tensor]) -> Tensor:
+        """Perform forward propagation of the tracking head and predict
+        tracking results on the features of the upstream network.
+
+        Args:
+            feats (list[Tensor]): Multi level feature maps of `img`.
+            rescaled_bboxes (list[Tensor]): list of rescaled bboxes in sampling
+                result.
+
+        Returns:
+            Tensor: The extracted track features.
+        """
+        bbox_feats = self.extract_roi_feats(feats, rescaled_bboxes)
+        track_feats = self.embed_head.predict(bbox_feats)
+        return track_feats
diff --git a/mmdetection/mmdet/models/tracking_heads/roi_embed_head.py b/mmdetection/mmdet/models/tracking_heads/roi_embed_head.py
new file mode 100644
index 00000000..e18b81fb
--- /dev/null
+++ b/mmdetection/mmdet/models/tracking_heads/roi_embed_head.py
@@ -0,0 +1,391 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from collections import defaultdict
+from typing import List, Optional, Tuple
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule
+from mmengine.model import BaseModule
+from torch import Tensor
+from torch.nn.modules.utils import _pair
+
+from mmdet.models.losses import accuracy
+from mmdet.models.task_modules import SamplingResult
+from mmdet.models.task_modules.tracking import embed_similarity
+from mmdet.registry import MODELS
+
+
+@MODELS.register_module()
+class RoIEmbedHead(BaseModule):
+    """The roi embed head.
+
+    This module is used in multi-object tracking methods, such as MaskTrack
+    R-CNN.
+
+    Args:
+        num_convs (int): The number of convoluational layers to embed roi
+            features. Defaults to 0.
+        num_fcs (int): The number of fully connection layers to embed roi
+            features. Defaults to 0.
+        roi_feat_size (int|tuple(int)): The spatial size of roi features.
+            Defaults to 7.
+        in_channels (int): The input channel of roi features. Defaults to 256.
+        conv_out_channels (int): The output channel of roi features after
+            forwarding convoluational layers. Defaults to 256.
+        with_avg_pool (bool): Whether use average pooling before passing roi
+            features into fully connection layers. Defaults to False.
+        fc_out_channels (int): The output channel of roi features after
+            forwarding fully connection layers. Defaults to 1024.
+        conv_cfg (dict): Config dict for convolution layer. Defaults to None,
+            which means using conv2d.
+        norm_cfg (dict): Config dict for normalization layer. Defaults to None.
+        loss_match (dict): The loss function. Defaults to
+            dict(type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)
+        init_cfg (dict): Configuration of initialization. Defaults to None.
+    """
+
+    def __init__(self,
+                 num_convs: int = 0,
+                 num_fcs: int = 0,
+                 roi_feat_size: int = 7,
+                 in_channels: int = 256,
+                 conv_out_channels: int = 256,
+                 with_avg_pool: bool = False,
+                 fc_out_channels: int = 1024,
+                 conv_cfg: Optional[dict] = None,
+                 norm_cfg: Optional[dict] = None,
+                 loss_match: dict = dict(
+                     type='mmdet.CrossEntropyLoss',
+                     use_sigmoid=False,
+                     loss_weight=1.0),
+                 init_cfg: Optional[dict] = None,
+                 **kwargs):
+        super(RoIEmbedHead, self).__init__(init_cfg=init_cfg)
+        self.num_convs = num_convs
+        self.num_fcs = num_fcs
+        self.roi_feat_size = _pair(roi_feat_size)
+        self.roi_feat_area = self.roi_feat_size[0] * self.roi_feat_size[1]
+        self.in_channels = in_channels
+        self.conv_out_channels = conv_out_channels
+        self.with_avg_pool = with_avg_pool
+        self.fc_out_channels = fc_out_channels
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.loss_match = MODELS.build(loss_match)
+        self.fp16_enabled = False
+
+        if self.with_avg_pool:
+            self.avg_pool = nn.AvgPool2d(self.roi_feat_size)
+        # add convs and fcs
+        self.convs, self.fcs, self.last_layer_dim = self._add_conv_fc_branch(
+            self.num_convs, self.num_fcs, self.in_channels)
+        self.relu = nn.ReLU(inplace=True)
+
+    def _add_conv_fc_branch(
+            self, num_branch_convs: int, num_branch_fcs: int,
+            in_channels: int) -> Tuple[nn.ModuleList, nn.ModuleList, int]:
+        """Add shared or separable branch.
+
+        convs -> avg pool (optional) -> fcs
+        """
+        last_layer_dim = in_channels
+        # add branch specific conv layers
+        branch_convs = nn.ModuleList()
+        if num_branch_convs > 0:
+            for i in range(num_branch_convs):
+                conv_in_channels = (
+                    last_layer_dim if i == 0 else self.conv_out_channels)
+                branch_convs.append(
+                    ConvModule(
+                        conv_in_channels,
+                        self.conv_out_channels,
+                        3,
+                        padding=1,
+                        conv_cfg=self.conv_cfg,
+                        norm_cfg=self.norm_cfg))
+            last_layer_dim = self.conv_out_channels
+
+        # add branch specific fc layers
+        branch_fcs = nn.ModuleList()
+        if num_branch_fcs > 0:
+            if not self.with_avg_pool:
+                last_layer_dim *= self.roi_feat_area
+            for i in range(num_branch_fcs):
+                fc_in_channels = (
+                    last_layer_dim if i == 0 else self.fc_out_channels)
+                branch_fcs.append(
+                    nn.Linear(fc_in_channels, self.fc_out_channels))
+            last_layer_dim = self.fc_out_channels
+
+        return branch_convs, branch_fcs, last_layer_dim
+
+    @property
+    def custom_activation(self):
+        return getattr(self.loss_match, 'custom_activation', False)
+
+    def extract_feat(self, x: Tensor,
+                     num_x_per_img: List[int]) -> Tuple[Tensor]:
+        """Extract feature from the input `x`, and split the output to a list.
+
+        Args:
+            x (Tensor): of shape [N, C, H, W]. N is the number of proposals.
+            num_x_per_img (list[int]): The `x` contains proposals of
+                multi-images. `num_x_per_img` denotes the number of proposals
+                for each image.
+
+        Returns:
+            list[Tensor]: Each Tensor denotes the embed features belonging to
+            an image in a batch.
+        """
+        if self.num_convs > 0:
+            for conv in self.convs:
+                x = conv(x)
+
+        if self.num_fcs > 0:
+            if self.with_avg_pool:
+                x = self.avg_pool(x)
+            x = x.flatten(1)
+            for fc in self.fcs:
+                x = self.relu(fc(x))
+        else:
+            x = x.flatten(1)
+
+        x_split = torch.split(x, num_x_per_img, dim=0)
+        return x_split
+
+    def forward(
+            self, x: Tensor, ref_x: Tensor, num_x_per_img: List[int],
+            num_x_per_ref_img: List[int]
+    ) -> Tuple[Tuple[Tensor], Tuple[Tensor]]:
+        """Computing the similarity scores between `x` and `ref_x`.
+
+        Args:
+            x (Tensor): of shape [N, C, H, W]. N is the number of key frame
+                proposals.
+            ref_x (Tensor): of shape [M, C, H, W]. M is the number of reference
+                frame proposals.
+            num_x_per_img (list[int]): The `x` contains proposals of
+                multi-images. `num_x_per_img` denotes the number of proposals
+                for each key image.
+            num_x_per_ref_img (list[int]): The `ref_x` contains proposals of
+                multi-images. `num_x_per_ref_img` denotes the number of
+                proposals for each reference image.
+
+        Returns:
+            tuple[tuple[Tensor], tuple[Tensor]]: Each tuple of tensor denotes
+            the embed features belonging to an image in a batch.
+        """
+        x_split = self.extract_feat(x, num_x_per_img)
+        ref_x_split = self.extract_feat(ref_x, num_x_per_ref_img)
+
+        return x_split, ref_x_split
+
+    def get_targets(self, sampling_results: List[SamplingResult],
+                    gt_instance_ids: List[Tensor],
+                    ref_gt_instance_ids: List[Tensor]) -> Tuple[List, List]:
+        """Calculate the ground truth for all samples in a batch according to
+        the sampling_results.
+
+        Args:
+            sampling_results (List[obj:SamplingResult]): Assign results of
+                all images in a batch after sampling.
+            gt_instance_ids (list[Tensor]): The instance ids of gt_bboxes of
+                all images in a batch, each tensor has shape (num_gt, ).
+            ref_gt_instance_ids (list[Tensor]): The instance ids of gt_bboxes
+                of all reference images in a batch, each tensor has shape
+                (num_gt, ).
+
+        Returns:
+            Tuple[list[Tensor]]: Ground truth for proposals in a batch.
+            Containing the following list of Tensors:
+
+                - track_id_targets (list[Tensor]): The instance ids of
+                  Gt_labels for all proposals in a batch, each tensor in list
+                  has shape (num_proposals,).
+                - track_id_weights (list[Tensor]): Labels_weights for
+                  all proposals in a batch, each tensor in list has
+                  shape (num_proposals,).
+        """
+        track_id_targets = []
+        track_id_weights = []
+
+        for res, gt_instance_id, ref_gt_instance_id in zip(
+                sampling_results, gt_instance_ids, ref_gt_instance_ids):
+            pos_instance_ids = gt_instance_id[res.pos_assigned_gt_inds]
+            pos_match_id = gt_instance_id.new_zeros(len(pos_instance_ids))
+            for i, id in enumerate(pos_instance_ids):
+                if id in ref_gt_instance_id:
+                    pos_match_id[i] = ref_gt_instance_id.tolist().index(id) + 1
+
+            track_id_target = gt_instance_id.new_zeros(
+                len(res.bboxes), dtype=torch.int64)
+            track_id_target[:len(res.pos_bboxes)] = pos_match_id
+            track_id_weight = res.bboxes.new_zeros(len(res.bboxes))
+            track_id_weight[:len(res.pos_bboxes)] = 1.0
+
+            track_id_targets.append(track_id_target)
+            track_id_weights.append(track_id_weight)
+
+        return track_id_targets, track_id_weights
+
+    def loss(
+        self,
+        bbox_feats: Tensor,
+        ref_bbox_feats: Tensor,
+        num_bbox_per_img: int,
+        num_bbox_per_ref_img: int,
+        sampling_results: List[SamplingResult],
+        gt_instance_ids: List[Tensor],
+        ref_gt_instance_ids: List[Tensor],
+        reduction_override: Optional[str] = None,
+    ) -> dict:
+        """Calculate the loss in a batch.
+
+        Args:
+            bbox_feats (Tensor): of shape [N, C, H, W]. N is the number of
+                bboxes.
+            ref_bbox_feats (Tensor): of shape [M, C, H, W]. M is the number of
+                reference bboxes.
+            num_bbox_per_img (list[int]): The `bbox_feats` contains proposals
+                of multi-images. `num_bbox_per_img` denotes the number of
+                proposals for each key image.
+            num_bbox_per_ref_img (list[int]): The `ref_bbox_feats` contains
+                proposals of multi-images. `num_bbox_per_ref_img` denotes the
+                number of proposals for each reference image.
+            sampling_results (List[obj:SamplingResult]): Assign results of
+                all images in a batch after sampling.
+            gt_instance_ids (list[Tensor]): The instance ids of gt_bboxes of
+                all images in a batch, each tensor has shape (num_gt, ).
+            ref_gt_instance_ids (list[Tensor]): The instance ids of gt_bboxes
+                of all reference images in a batch, each tensor has shape
+                (num_gt, ).
+            reduction_override (str, optional): The method used to reduce the
+                loss. Options are "none", "mean" and "sum".
+
+        Returns:
+            dict[str, Tensor]: a dictionary of loss components.
+        """
+        x_split, ref_x_split = self(bbox_feats, ref_bbox_feats,
+                                    num_bbox_per_img, num_bbox_per_ref_img)
+
+        losses = self.loss_by_feat(x_split, ref_x_split, sampling_results,
+                                   gt_instance_ids, ref_gt_instance_ids,
+                                   reduction_override)
+        return losses
+
+    def loss_by_feat(self,
+                     x_split: Tuple[Tensor],
+                     ref_x_split: Tuple[Tensor],
+                     sampling_results: List[SamplingResult],
+                     gt_instance_ids: List[Tensor],
+                     ref_gt_instance_ids: List[Tensor],
+                     reduction_override: Optional[str] = None) -> dict:
+        """Calculate losses.
+
+        Args:
+            x_split (Tensor): The embed features belonging to key image.
+            ref_x_split (Tensor): The embed features belonging to ref image.
+            sampling_results (List[obj:SamplingResult]): Assign results of
+                all images in a batch after sampling.
+            gt_instance_ids (list[Tensor]): The instance ids of gt_bboxes of
+                all images in a batch, each tensor has shape (num_gt, ).
+            ref_gt_instance_ids (list[Tensor]): The instance ids of gt_bboxes
+                of all reference images in a batch, each tensor has shape
+                (num_gt, ).
+            reduction_override (str, optional): The method used to reduce the
+                loss. Options are "none", "mean" and "sum".
+
+        Returns:
+            dict[str, Tensor]: a dictionary of loss components.
+        """
+        track_id_targets, track_id_weights = self.get_targets(
+            sampling_results, gt_instance_ids, ref_gt_instance_ids)
+        assert isinstance(track_id_targets, list)
+        assert isinstance(track_id_weights, list)
+        assert len(track_id_weights) == len(track_id_targets)
+
+        losses = defaultdict(list)
+        similarity_logits = []
+        for one_x, one_ref_x in zip(x_split, ref_x_split):
+            similarity_logit = embed_similarity(
+                one_x, one_ref_x, method='dot_product')
+            dummy = similarity_logit.new_zeros(one_x.shape[0], 1)
+            similarity_logit = torch.cat((dummy, similarity_logit), dim=1)
+            similarity_logits.append(similarity_logit)
+        assert isinstance(similarity_logits, list)
+        assert len(similarity_logits) == len(track_id_targets)
+
+        for similarity_logit, track_id_target, track_id_weight in zip(
+                similarity_logits, track_id_targets, track_id_weights):
+            avg_factor = max(torch.sum(track_id_target > 0).float().item(), 1.)
+            if similarity_logit.numel() > 0:
+                loss_match = self.loss_match(
+                    similarity_logit,
+                    track_id_target,
+                    track_id_weight,
+                    avg_factor=avg_factor,
+                    reduction_override=reduction_override)
+                if isinstance(loss_match, dict):
+                    for key, value in loss_match.items():
+                        losses[key].append(value)
+                else:
+                    losses['loss_match'].append(loss_match)
+
+                valid_index = track_id_weight > 0
+                valid_similarity_logit = similarity_logit[valid_index]
+                valid_track_id_target = track_id_target[valid_index]
+                if self.custom_activation:
+                    match_accuracy = self.loss_match.get_accuracy(
+                        valid_similarity_logit, valid_track_id_target)
+                    for key, value in match_accuracy.items():
+                        losses[key].append(value)
+                else:
+                    losses['match_accuracy'].append(
+                        accuracy(valid_similarity_logit,
+                                 valid_track_id_target))
+
+        for key, value in losses.items():
+            losses[key] = sum(losses[key]) / len(similarity_logits)
+        return losses
+
+    def predict(self, roi_feats: Tensor,
+                prev_roi_feats: Tensor) -> List[Tensor]:
+        """Perform forward propagation of the tracking head and predict
+        tracking results on the features of the upstream network.
+
+        Args:
+            roi_feats (Tensor): Feature map of current images rois.
+            prev_roi_feats (Tensor): Feature map of previous images rois.
+
+        Returns:
+            list[Tensor]: The predicted similarity_logits of each pair of key
+            image and reference image.
+        """
+        x_split, ref_x_split = self(roi_feats, prev_roi_feats,
+                                    [roi_feats.shape[0]],
+                                    [prev_roi_feats.shape[0]])
+
+        similarity_logits = self.predict_by_feat(x_split, ref_x_split)
+
+        return similarity_logits
+
+    def predict_by_feat(self, x_split: Tuple[Tensor],
+                        ref_x_split: Tuple[Tensor]) -> List[Tensor]:
+        """Get similarity_logits.
+
+        Args:
+            x_split (Tensor): The embed features belonging to key image.
+            ref_x_split (Tensor): The embed features belonging to ref image.
+
+        Returns:
+            list[Tensor]: The predicted similarity_logits of each pair of key
+            image and reference image.
+        """
+        similarity_logits = []
+        for one_x, one_ref_x in zip(x_split, ref_x_split):
+            similarity_logit = embed_similarity(
+                one_x, one_ref_x, method='dot_product')
+            dummy = similarity_logit.new_zeros(one_x.shape[0], 1)
+            similarity_logit = torch.cat((dummy, similarity_logit), dim=1)
+            similarity_logits.append(similarity_logit)
+        return similarity_logits
diff --git a/mmdetection/mmdet/models/tracking_heads/roi_track_head.py b/mmdetection/mmdet/models/tracking_heads/roi_track_head.py
new file mode 100644
index 00000000..c51c8100
--- /dev/null
+++ b/mmdetection/mmdet/models/tracking_heads/roi_track_head.py
@@ -0,0 +1,178 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from abc import ABCMeta
+from typing import List, Optional, Tuple
+
+from mmengine.model import BaseModule
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.structures import TrackSampleList
+from mmdet.structures.bbox import bbox2roi
+from mmdet.utils import InstanceList
+
+
+@MODELS.register_module()
+class RoITrackHead(BaseModule, metaclass=ABCMeta):
+    """The roi track head.
+
+    This module is used in multi-object tracking methods, such as MaskTrack
+    R-CNN.
+
+    Args:
+        roi_extractor (dict): Configuration of roi extractor. Defaults to None.
+        embed_head (dict): Configuration of embed head. Defaults to None.
+        train_cfg (dict): Configuration when training. Defaults to None.
+        test_cfg (dict): Configuration when testing. Defaults to None.
+        init_cfg (dict): Configuration of initialization. Defaults to None.
+    """
+
+    def __init__(self,
+                 roi_extractor: Optional[dict] = None,
+                 embed_head: Optional[dict] = None,
+                 regress_head: Optional[dict] = None,
+                 train_cfg: Optional[dict] = None,
+                 test_cfg: Optional[dict] = None,
+                 init_cfg: Optional[dict] = None,
+                 *args,
+                 **kwargs):
+        super().__init__(init_cfg=init_cfg)
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+
+        if embed_head is not None:
+            self.init_embed_head(roi_extractor, embed_head)
+
+        if regress_head is not None:
+            raise NotImplementedError('Regression head is not supported yet.')
+
+        self.init_assigner_sampler()
+
+    def init_embed_head(self, roi_extractor, embed_head) -> None:
+        """Initialize ``embed_head``"""
+        self.roi_extractor = MODELS.build(roi_extractor)
+        self.embed_head = MODELS.build(embed_head)
+
+    def init_assigner_sampler(self) -> None:
+        """Initialize assigner and sampler."""
+        self.bbox_assigner = None
+        self.bbox_sampler = None
+        if self.train_cfg:
+            self.bbox_assigner = TASK_UTILS.build(self.train_cfg.assigner)
+            self.bbox_sampler = TASK_UTILS.build(
+                self.train_cfg.sampler, default_args=dict(context=self))
+
+    @property
+    def with_track(self) -> bool:
+        """bool: whether the multi-object tracker has an embed head"""
+        return hasattr(self, 'embed_head') and self.embed_head is not None
+
+    def extract_roi_feats(
+            self, feats: List[Tensor],
+            bboxes: List[Tensor]) -> Tuple[Tuple[Tensor], List[int]]:
+        """Extract roi features.
+
+        Args:
+            feats (list[Tensor]): list of multi-level image features.
+            bboxes (list[Tensor]): list of bboxes in sampling result.
+
+        Returns:
+            tuple[tuple[Tensor], list[int]]: The extracted roi features and
+            the number of bboxes in each image.
+        """
+        rois = bbox2roi(bboxes)
+        bbox_feats = self.roi_extractor(feats[:self.roi_extractor.num_inputs],
+                                        rois)
+        num_bbox_per_img = [len(bbox) for bbox in bboxes]
+        return bbox_feats, num_bbox_per_img
+
+    def loss(self, key_feats: List[Tensor], ref_feats: List[Tensor],
+             rpn_results_list: InstanceList, data_samples: TrackSampleList,
+             **kwargs) -> dict:
+        """Calculate losses from a batch of inputs and data samples.
+
+        Args:
+            key_feats (list[Tensor]): list of multi-level image features.
+            ref_feats (list[Tensor]): list of multi-level ref_img features.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals.
+            data_samples (list[:obj:`TrackDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance`.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        assert self.with_track
+        batch_gt_instances = []
+        ref_batch_gt_instances = []
+        batch_gt_instances_ignore = []
+        gt_instance_ids = []
+        ref_gt_instance_ids = []
+        for track_data_sample in data_samples:
+            key_data_sample = track_data_sample.get_key_frames()[0]
+            ref_data_sample = track_data_sample.get_ref_frames()[0]
+            batch_gt_instances.append(key_data_sample.gt_instances)
+            ref_batch_gt_instances.append(ref_data_sample.gt_instances)
+            if 'ignored_instances' in key_data_sample:
+                batch_gt_instances_ignore.append(
+                    key_data_sample.ignored_instances)
+            else:
+                batch_gt_instances_ignore.append(None)
+
+            gt_instance_ids.append(key_data_sample.gt_instances.instances_ids)
+            ref_gt_instance_ids.append(
+                ref_data_sample.gt_instances.instances_ids)
+
+        losses = dict()
+        num_imgs = len(data_samples)
+        if batch_gt_instances_ignore is None:
+            batch_gt_instances_ignore = [None] * num_imgs
+        sampling_results = []
+        for i in range(num_imgs):
+            rpn_results = rpn_results_list[i]
+
+            assign_result = self.bbox_assigner.assign(
+                rpn_results, batch_gt_instances[i],
+                batch_gt_instances_ignore[i])
+            sampling_result = self.bbox_sampler.sample(
+                assign_result,
+                rpn_results,
+                batch_gt_instances[i],
+                feats=[lvl_feat[i][None] for lvl_feat in key_feats])
+            sampling_results.append(sampling_result)
+
+        bboxes = [res.bboxes for res in sampling_results]
+        bbox_feats, num_bbox_per_img = self.extract_roi_feats(
+            key_feats, bboxes)
+
+        # batch_size is 1
+        ref_gt_bboxes = [
+            ref_batch_gt_instance.bboxes
+            for ref_batch_gt_instance in ref_batch_gt_instances
+        ]
+        ref_bbox_feats, num_bbox_per_ref_img = self.extract_roi_feats(
+            ref_feats, ref_gt_bboxes)
+
+        loss_track = self.embed_head.loss(bbox_feats, ref_bbox_feats,
+                                          num_bbox_per_img,
+                                          num_bbox_per_ref_img,
+                                          sampling_results, gt_instance_ids,
+                                          ref_gt_instance_ids)
+        losses.update(loss_track)
+
+        return losses
+
+    def predict(self, roi_feats: Tensor,
+                prev_roi_feats: Tensor) -> List[Tensor]:
+        """Perform forward propagation of the tracking head and predict
+        tracking results on the features of the upstream network.
+
+        Args:
+            roi_feats (Tensor): Feature map of current images rois.
+            prev_roi_feats (Tensor): Feature map of previous images rois.
+
+        Returns:
+            list[Tensor]: The predicted similarity_logits of each pair of key
+            image and reference image.
+        """
+        return self.embed_head.predict(roi_feats, prev_roi_feats)[0]
diff --git a/mmdetection/mmdet/models/utils/__init__.py b/mmdetection/mmdet/models/utils/__init__.py
new file mode 100644
index 00000000..a00d9a37
--- /dev/null
+++ b/mmdetection/mmdet/models/utils/__init__.py
@@ -0,0 +1,37 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .gaussian_target import (gather_feat, gaussian_radius,
+                              gen_gaussian_target, get_local_maximum,
+                              get_topk_from_heatmap, transpose_and_gather_feat)
+from .image import imrenormalize
+from .make_divisible import make_divisible
+# Disable yapf because it conflicts with isort.
+# yapf: disable
+from .misc import (align_tensor, aligned_bilinear, center_of_mass,
+                   empty_instances, filter_gt_instances,
+                   filter_scores_and_topk, flip_tensor, generate_coordinate,
+                   images_to_levels, interpolate_as, levels_to_images,
+                   mask2ndarray, multi_apply, relative_coordinate_maps,
+                   rename_loss_dict, reweight_loss_dict,
+                   samplelist_boxtype2tensor, select_single_mlvl,
+                   sigmoid_geometric_mean, unfold_wo_center, unmap,
+                   unpack_gt_instances)
+from .panoptic_gt_processing import preprocess_panoptic_gt
+from .point_sample import (get_uncertain_point_coords_with_randomness,
+                           get_uncertainty)
+from .vlfuse_helper import BertEncoderLayer, VLFuse, permute_and_flatten
+from .wbf import weighted_boxes_fusion
+
+__all__ = [
+    'gaussian_radius', 'gen_gaussian_target', 'make_divisible',
+    'get_local_maximum', 'get_topk_from_heatmap', 'transpose_and_gather_feat',
+    'interpolate_as', 'sigmoid_geometric_mean', 'gather_feat',
+    'preprocess_panoptic_gt', 'get_uncertain_point_coords_with_randomness',
+    'get_uncertainty', 'unpack_gt_instances', 'empty_instances',
+    'center_of_mass', 'filter_scores_and_topk', 'flip_tensor',
+    'generate_coordinate', 'levels_to_images', 'mask2ndarray', 'multi_apply',
+    'select_single_mlvl', 'unmap', 'images_to_levels',
+    'samplelist_boxtype2tensor', 'filter_gt_instances', 'rename_loss_dict',
+    'reweight_loss_dict', 'relative_coordinate_maps', 'aligned_bilinear',
+    'unfold_wo_center', 'imrenormalize', 'VLFuse', 'permute_and_flatten',
+    'BertEncoderLayer', 'align_tensor', 'weighted_boxes_fusion'
+]
diff --git a/mmdetection/mmdet/models/utils/gaussian_target.py b/mmdetection/mmdet/models/utils/gaussian_target.py
new file mode 100644
index 00000000..5bf4d558
--- /dev/null
+++ b/mmdetection/mmdet/models/utils/gaussian_target.py
@@ -0,0 +1,268 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from math import sqrt
+
+import torch
+import torch.nn.functional as F
+
+
+def gaussian2D(radius, sigma=1, dtype=torch.float32, device='cpu'):
+    """Generate 2D gaussian kernel.
+
+    Args:
+        radius (int): Radius of gaussian kernel.
+        sigma (int): Sigma of gaussian function. Default: 1.
+        dtype (torch.dtype): Dtype of gaussian tensor. Default: torch.float32.
+        device (str): Device of gaussian tensor. Default: 'cpu'.
+
+    Returns:
+        h (Tensor): Gaussian kernel with a
+            ``(2 * radius + 1) * (2 * radius + 1)`` shape.
+    """
+    x = torch.arange(
+        -radius, radius + 1, dtype=dtype, device=device).view(1, -1)
+    y = torch.arange(
+        -radius, radius + 1, dtype=dtype, device=device).view(-1, 1)
+
+    h = (-(x * x + y * y) / (2 * sigma * sigma)).exp()
+
+    h[h < torch.finfo(h.dtype).eps * h.max()] = 0
+    return h
+
+
+def gen_gaussian_target(heatmap, center, radius, k=1):
+    """Generate 2D gaussian heatmap.
+
+    Args:
+        heatmap (Tensor): Input heatmap, the gaussian kernel will cover on
+            it and maintain the max value.
+        center (list[int]): Coord of gaussian kernel's center.
+        radius (int): Radius of gaussian kernel.
+        k (int): Coefficient of gaussian kernel. Default: 1.
+
+    Returns:
+        out_heatmap (Tensor): Updated heatmap covered by gaussian kernel.
+    """
+    diameter = 2 * radius + 1
+    gaussian_kernel = gaussian2D(
+        radius, sigma=diameter / 6, dtype=heatmap.dtype, device=heatmap.device)
+
+    x, y = center
+
+    height, width = heatmap.shape[:2]
+
+    left, right = min(x, radius), min(width - x, radius + 1)
+    top, bottom = min(y, radius), min(height - y, radius + 1)
+
+    masked_heatmap = heatmap[y - top:y + bottom, x - left:x + right]
+    masked_gaussian = gaussian_kernel[radius - top:radius + bottom,
+                                      radius - left:radius + right]
+    out_heatmap = heatmap
+    torch.max(
+        masked_heatmap,
+        masked_gaussian * k,
+        out=out_heatmap[y - top:y + bottom, x - left:x + right])
+
+    return out_heatmap
+
+
+def gaussian_radius(det_size, min_overlap):
+    r"""Generate 2D gaussian radius.
+
+    This function is modified from the `official github repo
+    `_.
+
+    Given ``min_overlap``, radius could computed by a quadratic equation
+    according to Vieta's formulas.
+
+    There are 3 cases for computing gaussian radius, details are following:
+
+    - Explanation of figure: ``lt`` and ``br`` indicates the left-top and
+      bottom-right corner of ground truth box. ``x`` indicates the
+      generated corner at the limited position when ``radius=r``.
+
+    - Case1: one corner is inside the gt box and the other is outside.
+
+    .. code:: text
+
+        |<   width   >|
+
+        lt-+----------+         -
+        |  |          |         ^
+        +--x----------+--+
+        |  |          |  |
+        |  |          |  |    height
+        |  | overlap  |  |
+        |  |          |  |
+        |  |          |  |      v
+        +--+---------br--+      -
+           |          |  |
+           +----------+--x
+
+    To ensure IoU of generated box and gt box is larger than ``min_overlap``:
+
+    .. math::
+        \cfrac{(w-r)*(h-r)}{w*h+(w+h)r-r^2} \ge {iou} \quad\Rightarrow\quad
+        {r^2-(w+h)r+\cfrac{1-iou}{1+iou}*w*h} \ge 0 \\
+        {a} = 1,\quad{b} = {-(w+h)},\quad{c} = {\cfrac{1-iou}{1+iou}*w*h}
+        {r} \le \cfrac{-b-\sqrt{b^2-4*a*c}}{2*a}
+
+    - Case2: both two corners are inside the gt box.
+
+    .. code:: text
+
+        |<   width   >|
+
+        lt-+----------+         -
+        |  |          |         ^
+        +--x-------+  |
+        |  |       |  |
+        |  |overlap|  |       height
+        |  |       |  |
+        |  +-------x--+
+        |          |  |         v
+        +----------+-br         -
+
+    To ensure IoU of generated box and gt box is larger than ``min_overlap``:
+
+    .. math::
+        \cfrac{(w-2*r)*(h-2*r)}{w*h} \ge {iou} \quad\Rightarrow\quad
+        {4r^2-2(w+h)r+(1-iou)*w*h} \ge 0 \\
+        {a} = 4,\quad {b} = {-2(w+h)},\quad {c} = {(1-iou)*w*h}
+        {r} \le \cfrac{-b-\sqrt{b^2-4*a*c}}{2*a}
+
+    - Case3: both two corners are outside the gt box.
+
+    .. code:: text
+
+           |<   width   >|
+
+        x--+----------------+
+        |  |                |
+        +-lt-------------+  |   -
+        |  |             |  |   ^
+        |  |             |  |
+        |  |   overlap   |  | height
+        |  |             |  |
+        |  |             |  |   v
+        |  +------------br--+   -
+        |                |  |
+        +----------------+--x
+
+    To ensure IoU of generated box and gt box is larger than ``min_overlap``:
+
+    .. math::
+        \cfrac{w*h}{(w+2*r)*(h+2*r)} \ge {iou} \quad\Rightarrow\quad
+        {4*iou*r^2+2*iou*(w+h)r+(iou-1)*w*h} \le 0 \\
+        {a} = {4*iou},\quad {b} = {2*iou*(w+h)},\quad {c} = {(iou-1)*w*h} \\
+        {r} \le \cfrac{-b+\sqrt{b^2-4*a*c}}{2*a}
+
+    Args:
+        det_size (list[int]): Shape of object.
+        min_overlap (float): Min IoU with ground truth for boxes generated by
+            keypoints inside the gaussian kernel.
+
+    Returns:
+        radius (int): Radius of gaussian kernel.
+    """
+    height, width = det_size
+
+    a1 = 1
+    b1 = (height + width)
+    c1 = width * height * (1 - min_overlap) / (1 + min_overlap)
+    sq1 = sqrt(b1**2 - 4 * a1 * c1)
+    r1 = (b1 - sq1) / (2 * a1)
+
+    a2 = 4
+    b2 = 2 * (height + width)
+    c2 = (1 - min_overlap) * width * height
+    sq2 = sqrt(b2**2 - 4 * a2 * c2)
+    r2 = (b2 - sq2) / (2 * a2)
+
+    a3 = 4 * min_overlap
+    b3 = -2 * min_overlap * (height + width)
+    c3 = (min_overlap - 1) * width * height
+    sq3 = sqrt(b3**2 - 4 * a3 * c3)
+    r3 = (b3 + sq3) / (2 * a3)
+    return min(r1, r2, r3)
+
+
+def get_local_maximum(heat, kernel=3):
+    """Extract local maximum pixel with given kernel.
+
+    Args:
+        heat (Tensor): Target heatmap.
+        kernel (int): Kernel size of max pooling. Default: 3.
+
+    Returns:
+        heat (Tensor): A heatmap where local maximum pixels maintain its
+            own value and other positions are 0.
+    """
+    pad = (kernel - 1) // 2
+    hmax = F.max_pool2d(heat, kernel, stride=1, padding=pad)
+    keep = (hmax == heat).float()
+    return heat * keep
+
+
+def get_topk_from_heatmap(scores, k=20):
+    """Get top k positions from heatmap.
+
+    Args:
+        scores (Tensor): Target heatmap with shape
+            [batch, num_classes, height, width].
+        k (int): Target number. Default: 20.
+
+    Returns:
+        tuple[torch.Tensor]: Scores, indexes, categories and coords of
+            topk keypoint. Containing following Tensors:
+
+        - topk_scores (Tensor): Max scores of each topk keypoint.
+        - topk_inds (Tensor): Indexes of each topk keypoint.
+        - topk_clses (Tensor): Categories of each topk keypoint.
+        - topk_ys (Tensor): Y-coord of each topk keypoint.
+        - topk_xs (Tensor): X-coord of each topk keypoint.
+    """
+    batch, _, height, width = scores.size()
+    topk_scores, topk_inds = torch.topk(scores.view(batch, -1), k)
+    topk_clses = topk_inds // (height * width)
+    topk_inds = topk_inds % (height * width)
+    topk_ys = topk_inds // width
+    topk_xs = (topk_inds % width).int().float()
+    return topk_scores, topk_inds, topk_clses, topk_ys, topk_xs
+
+
+def gather_feat(feat, ind, mask=None):
+    """Gather feature according to index.
+
+    Args:
+        feat (Tensor): Target feature map.
+        ind (Tensor): Target coord index.
+        mask (Tensor | None): Mask of feature map. Default: None.
+
+    Returns:
+        feat (Tensor): Gathered feature.
+    """
+    dim = feat.size(2)
+    ind = ind.unsqueeze(2).repeat(1, 1, dim)
+    feat = feat.gather(1, ind)
+    if mask is not None:
+        mask = mask.unsqueeze(2).expand_as(feat)
+        feat = feat[mask]
+        feat = feat.view(-1, dim)
+    return feat
+
+
+def transpose_and_gather_feat(feat, ind):
+    """Transpose and gather feature according to index.
+
+    Args:
+        feat (Tensor): Target feature map.
+        ind (Tensor): Target coord index.
+
+    Returns:
+        feat (Tensor): Transposed and gathered feature.
+    """
+    feat = feat.permute(0, 2, 3, 1).contiguous()
+    feat = feat.view(feat.size(0), -1, feat.size(3))
+    feat = gather_feat(feat, ind)
+    return feat
diff --git a/mmdetection/mmdet/models/utils/image.py b/mmdetection/mmdet/models/utils/image.py
new file mode 100644
index 00000000..16b5787a
--- /dev/null
+++ b/mmdetection/mmdet/models/utils/image.py
@@ -0,0 +1,52 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Union
+
+import mmcv
+import numpy as np
+import torch
+from torch import Tensor
+
+
+def imrenormalize(img: Union[Tensor, np.ndarray], img_norm_cfg: dict,
+                  new_img_norm_cfg: dict) -> Union[Tensor, np.ndarray]:
+    """Re-normalize the image.
+
+    Args:
+        img (Tensor | ndarray): Input image. If the input is a Tensor, the
+            shape is (1, C, H, W). If the input is a ndarray, the shape
+            is (H, W, C).
+        img_norm_cfg (dict): Original configuration for the normalization.
+        new_img_norm_cfg (dict): New configuration for the normalization.
+
+    Returns:
+        Tensor | ndarray: Output image with the same type and shape of
+        the input.
+    """
+    if isinstance(img, torch.Tensor):
+        assert img.ndim == 4 and img.shape[0] == 1
+        new_img = img.squeeze(0).cpu().numpy().transpose(1, 2, 0)
+        new_img = _imrenormalize(new_img, img_norm_cfg, new_img_norm_cfg)
+        new_img = new_img.transpose(2, 0, 1)[None]
+        return torch.from_numpy(new_img).to(img)
+    else:
+        return _imrenormalize(img, img_norm_cfg, new_img_norm_cfg)
+
+
+def _imrenormalize(img: Union[Tensor, np.ndarray], img_norm_cfg: dict,
+                   new_img_norm_cfg: dict) -> Union[Tensor, np.ndarray]:
+    """Re-normalize the image."""
+    img_norm_cfg = img_norm_cfg.copy()
+    new_img_norm_cfg = new_img_norm_cfg.copy()
+    for k, v in img_norm_cfg.items():
+        if (k == 'mean' or k == 'std') and not isinstance(v, np.ndarray):
+            img_norm_cfg[k] = np.array(v, dtype=img.dtype)
+    # reverse cfg
+    if 'bgr_to_rgb' in img_norm_cfg:
+        img_norm_cfg['rgb_to_bgr'] = img_norm_cfg['bgr_to_rgb']
+        img_norm_cfg.pop('bgr_to_rgb')
+    for k, v in new_img_norm_cfg.items():
+        if (k == 'mean' or k == 'std') and not isinstance(v, np.ndarray):
+            new_img_norm_cfg[k] = np.array(v, dtype=img.dtype)
+    img = mmcv.imdenormalize(img, **img_norm_cfg)
+    img = mmcv.imnormalize(img, **new_img_norm_cfg)
+    return img
diff --git a/mmdetection/mmdet/models/utils/make_divisible.py b/mmdetection/mmdet/models/utils/make_divisible.py
new file mode 100644
index 00000000..ed42c2ee
--- /dev/null
+++ b/mmdetection/mmdet/models/utils/make_divisible.py
@@ -0,0 +1,28 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+def make_divisible(value, divisor, min_value=None, min_ratio=0.9):
+    """Make divisible function.
+
+    This function rounds the channel number to the nearest value that can be
+    divisible by the divisor. It is taken from the original tf repo. It ensures
+    that all layers have a channel number that is divisible by divisor. It can
+    be seen here: https://github.com/tensorflow/models/blob/master/research/slim/nets/mobilenet/mobilenet.py  # noqa
+
+    Args:
+        value (int): The original channel number.
+        divisor (int): The divisor to fully divide the channel number.
+        min_value (int): The minimum value of the output channel.
+            Default: None, means that the minimum value equal to the divisor.
+        min_ratio (float): The minimum ratio of the rounded channel number to
+            the original channel number. Default: 0.9.
+
+    Returns:
+        int: The modified output channel number.
+    """
+
+    if min_value is None:
+        min_value = divisor
+    new_value = max(min_value, int(value + divisor / 2) // divisor * divisor)
+    # Make sure that round down does not go down by more than (1-min_ratio).
+    if new_value < min_ratio * value:
+        new_value += divisor
+    return new_value
diff --git a/mmdetection/mmdet/models/utils/misc.py b/mmdetection/mmdet/models/utils/misc.py
new file mode 100644
index 00000000..2cf42915
--- /dev/null
+++ b/mmdetection/mmdet/models/utils/misc.py
@@ -0,0 +1,697 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from functools import partial
+from typing import List, Optional, Sequence, Tuple, Union
+
+import numpy as np
+import torch
+from mmengine.structures import InstanceData
+from mmengine.utils import digit_version
+from six.moves import map, zip
+from torch import Tensor
+from torch.autograd import Function
+from torch.nn import functional as F
+
+from mmdet.structures import SampleList
+from mmdet.structures.bbox import BaseBoxes, get_box_type, stack_boxes
+from mmdet.structures.mask import BitmapMasks, PolygonMasks
+from mmdet.utils import OptInstanceList
+
+
+class SigmoidGeometricMean(Function):
+    """Forward and backward function of geometric mean of two sigmoid
+    functions.
+
+    This implementation with analytical gradient function substitutes
+    the autograd function of (x.sigmoid() * y.sigmoid()).sqrt(). The
+    original implementation incurs none during gradient backprapagation
+    if both x and y are very small values.
+    """
+
+    @staticmethod
+    def forward(ctx, x, y):
+        x_sigmoid = x.sigmoid()
+        y_sigmoid = y.sigmoid()
+        z = (x_sigmoid * y_sigmoid).sqrt()
+        ctx.save_for_backward(x_sigmoid, y_sigmoid, z)
+        return z
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        x_sigmoid, y_sigmoid, z = ctx.saved_tensors
+        grad_x = grad_output * z * (1 - x_sigmoid) / 2
+        grad_y = grad_output * z * (1 - y_sigmoid) / 2
+        return grad_x, grad_y
+
+
+sigmoid_geometric_mean = SigmoidGeometricMean.apply
+
+
+def interpolate_as(source, target, mode='bilinear', align_corners=False):
+    """Interpolate the `source` to the shape of the `target`.
+
+    The `source` must be a Tensor, but the `target` can be a Tensor or a
+    np.ndarray with the shape (..., target_h, target_w).
+
+    Args:
+        source (Tensor): A 3D/4D Tensor with the shape (N, H, W) or
+            (N, C, H, W).
+        target (Tensor | np.ndarray): The interpolation target with the shape
+            (..., target_h, target_w).
+        mode (str): Algorithm used for interpolation. The options are the
+            same as those in F.interpolate(). Default: ``'bilinear'``.
+        align_corners (bool): The same as the argument in F.interpolate().
+
+    Returns:
+        Tensor: The interpolated source Tensor.
+    """
+    assert len(target.shape) >= 2
+
+    def _interpolate_as(source, target, mode='bilinear', align_corners=False):
+        """Interpolate the `source` (4D) to the shape of the `target`."""
+        target_h, target_w = target.shape[-2:]
+        source_h, source_w = source.shape[-2:]
+        if target_h != source_h or target_w != source_w:
+            source = F.interpolate(
+                source,
+                size=(target_h, target_w),
+                mode=mode,
+                align_corners=align_corners)
+        return source
+
+    if len(source.shape) == 3:
+        source = source[:, None, :, :]
+        source = _interpolate_as(source, target, mode, align_corners)
+        return source[:, 0, :, :]
+    else:
+        return _interpolate_as(source, target, mode, align_corners)
+
+
+def unpack_gt_instances(batch_data_samples: SampleList) -> tuple:
+    """Unpack ``gt_instances``, ``gt_instances_ignore`` and ``img_metas`` based
+    on ``batch_data_samples``
+
+    Args:
+        batch_data_samples (List[:obj:`DetDataSample`]): The Data
+            Samples. It usually includes information such as
+            `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+
+    Returns:
+        tuple:
+
+            - batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            - batch_gt_instances_ignore (list[:obj:`InstanceData`]):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+            - batch_img_metas (list[dict]): Meta information of each image,
+                e.g., image size, scaling factor, etc.
+    """
+    batch_gt_instances = []
+    batch_gt_instances_ignore = []
+    batch_img_metas = []
+    for data_sample in batch_data_samples:
+        batch_img_metas.append(data_sample.metainfo)
+        batch_gt_instances.append(data_sample.gt_instances)
+        if 'ignored_instances' in data_sample:
+            batch_gt_instances_ignore.append(data_sample.ignored_instances)
+        else:
+            batch_gt_instances_ignore.append(None)
+
+    return batch_gt_instances, batch_gt_instances_ignore, batch_img_metas
+
+
+def empty_instances(batch_img_metas: List[dict],
+                    device: torch.device,
+                    task_type: str,
+                    instance_results: OptInstanceList = None,
+                    mask_thr_binary: Union[int, float] = 0,
+                    box_type: Union[str, type] = 'hbox',
+                    use_box_type: bool = False,
+                    num_classes: int = 80,
+                    score_per_cls: bool = False) -> List[InstanceData]:
+    """Handle predicted instances when RoI is empty.
+
+    Note: If ``instance_results`` is not None, it will be modified
+    in place internally, and then return ``instance_results``
+
+    Args:
+        batch_img_metas (list[dict]): List of image information.
+        device (torch.device): Device of tensor.
+        task_type (str): Expected returned task type. it currently
+            supports bbox and mask.
+        instance_results (list[:obj:`InstanceData`]): List of instance
+            results.
+        mask_thr_binary (int, float): mask binarization threshold.
+            Defaults to 0.
+        box_type (str or type): The empty box type. Defaults to `hbox`.
+        use_box_type (bool): Whether to warp boxes with the box type.
+            Defaults to False.
+        num_classes (int): num_classes of bbox_head. Defaults to 80.
+        score_per_cls (bool):  Whether to generate classwise score for
+            the empty instance. ``score_per_cls`` will be True when the model
+            needs to produce raw results without nms. Defaults to False.
+
+    Returns:
+        list[:obj:`InstanceData`]: Detection results of each image
+    """
+    assert task_type in ('bbox', 'mask'), 'Only support bbox and mask,' \
+                                          f' but got {task_type}'
+
+    if instance_results is not None:
+        assert len(instance_results) == len(batch_img_metas)
+
+    results_list = []
+    for img_id in range(len(batch_img_metas)):
+        if instance_results is not None:
+            results = instance_results[img_id]
+            assert isinstance(results, InstanceData)
+        else:
+            results = InstanceData()
+
+        if task_type == 'bbox':
+            _, box_type = get_box_type(box_type)
+            bboxes = torch.zeros(0, box_type.box_dim, device=device)
+            if use_box_type:
+                bboxes = box_type(bboxes, clone=False)
+            results.bboxes = bboxes
+            score_shape = (0, num_classes + 1) if score_per_cls else (0, )
+            results.scores = torch.zeros(score_shape, device=device)
+            results.labels = torch.zeros((0, ),
+                                         device=device,
+                                         dtype=torch.long)
+        else:
+            # TODO: Handle the case where rescale is false
+            img_h, img_w = batch_img_metas[img_id]['ori_shape'][:2]
+            # the type of `im_mask` will be torch.bool or torch.uint8,
+            # where uint8 if for visualization and debugging.
+            im_mask = torch.zeros(
+                0,
+                img_h,
+                img_w,
+                device=device,
+                dtype=torch.bool if mask_thr_binary >= 0 else torch.uint8)
+            results.masks = im_mask
+        results_list.append(results)
+    return results_list
+
+
+def multi_apply(func, *args, **kwargs):
+    """Apply function to a list of arguments.
+
+    Note:
+        This function applies the ``func`` to multiple inputs and
+        map the multiple outputs of the ``func`` into different
+        list. Each list contains the same type of outputs corresponding
+        to different inputs.
+
+    Args:
+        func (Function): A function that will be applied to a list of
+            arguments
+
+    Returns:
+        tuple(list): A tuple containing multiple list, each list contains \
+            a kind of returned results by the function
+    """
+    pfunc = partial(func, **kwargs) if kwargs else func
+    map_results = map(pfunc, *args)
+    return tuple(map(list, zip(*map_results)))
+
+
+def unmap(data, count, inds, fill=0):
+    """Unmap a subset of item (data) back to the original set of items (of size
+    count)"""
+    if data.dim() == 1:
+        ret = data.new_full((count, ), fill)
+        ret[inds.type(torch.bool)] = data
+    else:
+        new_size = (count, ) + data.size()[1:]
+        ret = data.new_full(new_size, fill)
+        ret[inds.type(torch.bool), :] = data
+    return ret
+
+
+def mask2ndarray(mask):
+    """Convert Mask to ndarray..
+
+    Args:
+        mask (:obj:`BitmapMasks` or :obj:`PolygonMasks` or
+        torch.Tensor or np.ndarray): The mask to be converted.
+
+    Returns:
+        np.ndarray: Ndarray mask of shape (n, h, w) that has been converted
+    """
+    if isinstance(mask, (BitmapMasks, PolygonMasks)):
+        mask = mask.to_ndarray()
+    elif isinstance(mask, torch.Tensor):
+        mask = mask.detach().cpu().numpy()
+    elif not isinstance(mask, np.ndarray):
+        raise TypeError(f'Unsupported {type(mask)} data type')
+    return mask
+
+
+def flip_tensor(src_tensor, flip_direction):
+    """flip tensor base on flip_direction.
+
+    Args:
+        src_tensor (Tensor): input feature map, shape (B, C, H, W).
+        flip_direction (str): The flipping direction. Options are
+          'horizontal', 'vertical', 'diagonal'.
+
+    Returns:
+        out_tensor (Tensor): Flipped tensor.
+    """
+    assert src_tensor.ndim == 4
+    valid_directions = ['horizontal', 'vertical', 'diagonal']
+    assert flip_direction in valid_directions
+    if flip_direction == 'horizontal':
+        out_tensor = torch.flip(src_tensor, [3])
+    elif flip_direction == 'vertical':
+        out_tensor = torch.flip(src_tensor, [2])
+    else:
+        out_tensor = torch.flip(src_tensor, [2, 3])
+    return out_tensor
+
+
+def select_single_mlvl(mlvl_tensors, batch_id, detach=True):
+    """Extract a multi-scale single image tensor from a multi-scale batch
+    tensor based on batch index.
+
+    Note: The default value of detach is True, because the proposal gradient
+    needs to be detached during the training of the two-stage model. E.g
+    Cascade Mask R-CNN.
+
+    Args:
+        mlvl_tensors (list[Tensor]): Batch tensor for all scale levels,
+           each is a 4D-tensor.
+        batch_id (int): Batch index.
+        detach (bool): Whether detach gradient. Default True.
+
+    Returns:
+        list[Tensor]: Multi-scale single image tensor.
+    """
+    assert isinstance(mlvl_tensors, (list, tuple))
+    num_levels = len(mlvl_tensors)
+
+    if detach:
+        mlvl_tensor_list = [
+            mlvl_tensors[i][batch_id].detach() for i in range(num_levels)
+        ]
+    else:
+        mlvl_tensor_list = [
+            mlvl_tensors[i][batch_id] for i in range(num_levels)
+        ]
+    return mlvl_tensor_list
+
+
+def filter_scores_and_topk(scores, score_thr, topk, results=None):
+    """Filter results using score threshold and topk candidates.
+
+    Args:
+        scores (Tensor): The scores, shape (num_bboxes, K).
+        score_thr (float): The score filter threshold.
+        topk (int): The number of topk candidates.
+        results (dict or list or Tensor, Optional): The results to
+           which the filtering rule is to be applied. The shape
+           of each item is (num_bboxes, N).
+
+    Returns:
+        tuple: Filtered results
+
+            - scores (Tensor): The scores after being filtered, \
+                shape (num_bboxes_filtered, ).
+            - labels (Tensor): The class labels, shape \
+                (num_bboxes_filtered, ).
+            - anchor_idxs (Tensor): The anchor indexes, shape \
+                (num_bboxes_filtered, ).
+            - filtered_results (dict or list or Tensor, Optional): \
+                The filtered results. The shape of each item is \
+                (num_bboxes_filtered, N).
+    """
+    valid_mask = scores > score_thr
+    scores = scores[valid_mask]
+    valid_idxs = torch.nonzero(valid_mask)
+
+    num_topk = min(topk, valid_idxs.size(0))
+    # torch.sort is actually faster than .topk (at least on GPUs)
+    scores, idxs = scores.sort(descending=True)
+    scores = scores[:num_topk]
+    topk_idxs = valid_idxs[idxs[:num_topk]]
+    keep_idxs, labels = topk_idxs.unbind(dim=1)
+
+    filtered_results = None
+    if results is not None:
+        if isinstance(results, dict):
+            filtered_results = {k: v[keep_idxs] for k, v in results.items()}
+        elif isinstance(results, list):
+            filtered_results = [result[keep_idxs] for result in results]
+        elif isinstance(results, torch.Tensor):
+            filtered_results = results[keep_idxs]
+        else:
+            raise NotImplementedError(f'Only supports dict or list or Tensor, '
+                                      f'but get {type(results)}.')
+    return scores, labels, keep_idxs, filtered_results
+
+
+def center_of_mass(mask, esp=1e-6):
+    """Calculate the centroid coordinates of the mask.
+
+    Args:
+        mask (Tensor): The mask to be calculated, shape (h, w).
+        esp (float): Avoid dividing by zero. Default: 1e-6.
+
+    Returns:
+        tuple[Tensor]: the coordinates of the center point of the mask.
+
+            - center_h (Tensor): the center point of the height.
+            - center_w (Tensor): the center point of the width.
+    """
+    h, w = mask.shape
+    grid_h = torch.arange(h, device=mask.device)[:, None]
+    grid_w = torch.arange(w, device=mask.device)
+    normalizer = mask.sum().float().clamp(min=esp)
+    center_h = (mask * grid_h).sum() / normalizer
+    center_w = (mask * grid_w).sum() / normalizer
+    return center_h, center_w
+
+
+def generate_coordinate(featmap_sizes, device='cuda'):
+    """Generate the coordinate.
+
+    Args:
+        featmap_sizes (tuple): The feature to be calculated,
+            of shape (N, C, W, H).
+        device (str): The device where the feature will be put on.
+    Returns:
+        coord_feat (Tensor): The coordinate feature, of shape (N, 2, W, H).
+    """
+
+    x_range = torch.linspace(-1, 1, featmap_sizes[-1], device=device)
+    y_range = torch.linspace(-1, 1, featmap_sizes[-2], device=device)
+    y, x = torch.meshgrid(y_range, x_range)
+    y = y.expand([featmap_sizes[0], 1, -1, -1])
+    x = x.expand([featmap_sizes[0], 1, -1, -1])
+    coord_feat = torch.cat([x, y], 1)
+
+    return coord_feat
+
+
+def levels_to_images(mlvl_tensor: List[torch.Tensor]) -> List[torch.Tensor]:
+    """Concat multi-level feature maps by image.
+
+    [feature_level0, feature_level1...] -> [feature_image0, feature_image1...]
+    Convert the shape of each element in mlvl_tensor from (N, C, H, W) to
+    (N, H*W , C), then split the element to N elements with shape (H*W, C), and
+    concat elements in same image of all level along first dimension.
+
+    Args:
+        mlvl_tensor (list[Tensor]): list of Tensor which collect from
+            corresponding level. Each element is of shape (N, C, H, W)
+
+    Returns:
+        list[Tensor]: A list that contains N tensors and each tensor is
+            of shape (num_elements, C)
+    """
+    batch_size = mlvl_tensor[0].size(0)
+    batch_list = [[] for _ in range(batch_size)]
+    channels = mlvl_tensor[0].size(1)
+    for t in mlvl_tensor:
+        t = t.permute(0, 2, 3, 1)
+        t = t.view(batch_size, -1, channels).contiguous()
+        for img in range(batch_size):
+            batch_list[img].append(t[img])
+    return [torch.cat(item, 0) for item in batch_list]
+
+
+def images_to_levels(target, num_levels):
+    """Convert targets by image to targets by feature level.
+
+    [target_img0, target_img1] -> [target_level0, target_level1, ...]
+    """
+    target = stack_boxes(target, 0)
+    level_targets = []
+    start = 0
+    for n in num_levels:
+        end = start + n
+        # level_targets.append(target[:, start:end].squeeze(0))
+        level_targets.append(target[:, start:end])
+        start = end
+    return level_targets
+
+
+def samplelist_boxtype2tensor(batch_data_samples: SampleList) -> SampleList:
+    for data_samples in batch_data_samples:
+        if 'gt_instances' in data_samples:
+            bboxes = data_samples.gt_instances.get('bboxes', None)
+            if isinstance(bboxes, BaseBoxes):
+                data_samples.gt_instances.bboxes = bboxes.tensor
+        if 'pred_instances' in data_samples:
+            bboxes = data_samples.pred_instances.get('bboxes', None)
+            if isinstance(bboxes, BaseBoxes):
+                data_samples.pred_instances.bboxes = bboxes.tensor
+        if 'ignored_instances' in data_samples:
+            bboxes = data_samples.ignored_instances.get('bboxes', None)
+            if isinstance(bboxes, BaseBoxes):
+                data_samples.ignored_instances.bboxes = bboxes.tensor
+
+
+_torch_version_div_indexing = (
+    'parrots' not in torch.__version__
+    and digit_version(torch.__version__) >= digit_version('1.8'))
+
+
+def floordiv(dividend, divisor, rounding_mode='trunc'):
+    if _torch_version_div_indexing:
+        return torch.div(dividend, divisor, rounding_mode=rounding_mode)
+    else:
+        return dividend // divisor
+
+
+def _filter_gt_instances_by_score(batch_data_samples: SampleList,
+                                  score_thr: float) -> SampleList:
+    """Filter ground truth (GT) instances by score.
+
+    Args:
+        batch_data_samples (SampleList): The Data
+            Samples. It usually includes information such as
+            `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+        score_thr (float): The score filter threshold.
+
+    Returns:
+        SampleList: The Data Samples filtered by score.
+    """
+    for data_samples in batch_data_samples:
+        assert 'scores' in data_samples.gt_instances, \
+            'there does not exit scores in instances'
+        if data_samples.gt_instances.bboxes.shape[0] > 0:
+            data_samples.gt_instances = data_samples.gt_instances[
+                data_samples.gt_instances.scores > score_thr]
+    return batch_data_samples
+
+
+def _filter_gt_instances_by_size(batch_data_samples: SampleList,
+                                 wh_thr: tuple) -> SampleList:
+    """Filter ground truth (GT) instances by size.
+
+    Args:
+        batch_data_samples (SampleList): The Data
+            Samples. It usually includes information such as
+            `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+        wh_thr (tuple):  Minimum width and height of bbox.
+
+    Returns:
+        SampleList: The Data Samples filtered by score.
+    """
+    for data_samples in batch_data_samples:
+        bboxes = data_samples.gt_instances.bboxes
+        if bboxes.shape[0] > 0:
+            w = bboxes[:, 2] - bboxes[:, 0]
+            h = bboxes[:, 3] - bboxes[:, 1]
+            data_samples.gt_instances = data_samples.gt_instances[
+                (w > wh_thr[0]) & (h > wh_thr[1])]
+    return batch_data_samples
+
+
+def filter_gt_instances(batch_data_samples: SampleList,
+                        score_thr: float = None,
+                        wh_thr: tuple = None):
+    """Filter ground truth (GT) instances by score and/or size.
+
+    Args:
+        batch_data_samples (SampleList): The Data
+            Samples. It usually includes information such as
+            `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+        score_thr (float): The score filter threshold.
+        wh_thr (tuple):  Minimum width and height of bbox.
+
+    Returns:
+        SampleList: The Data Samples filtered by score and/or size.
+    """
+
+    if score_thr is not None:
+        batch_data_samples = _filter_gt_instances_by_score(
+            batch_data_samples, score_thr)
+    if wh_thr is not None:
+        batch_data_samples = _filter_gt_instances_by_size(
+            batch_data_samples, wh_thr)
+    return batch_data_samples
+
+
+def rename_loss_dict(prefix: str, losses: dict) -> dict:
+    """Rename the key names in loss dict by adding a prefix.
+
+    Args:
+        prefix (str): The prefix for loss components.
+        losses (dict):  A dictionary of loss components.
+
+    Returns:
+            dict: A dictionary of loss components with prefix.
+    """
+    return {prefix + k: v for k, v in losses.items()}
+
+
+def reweight_loss_dict(losses: dict, weight: float) -> dict:
+    """Reweight losses in the dict by weight.
+
+    Args:
+        losses (dict):  A dictionary of loss components.
+        weight (float): Weight for loss components.
+
+    Returns:
+            dict: A dictionary of weighted loss components.
+    """
+    for name, loss in losses.items():
+        if 'loss' in name:
+            if isinstance(loss, Sequence):
+                losses[name] = [item * weight for item in loss]
+            else:
+                losses[name] = loss * weight
+    return losses
+
+
+def relative_coordinate_maps(
+    locations: Tensor,
+    centers: Tensor,
+    strides: Tensor,
+    size_of_interest: int,
+    feat_sizes: Tuple[int],
+) -> Tensor:
+    """Generate the relative coordinate maps with feat_stride.
+
+    Args:
+        locations (Tensor): The prior location of mask feature map.
+            It has shape (num_priors, 2).
+        centers (Tensor): The prior points of a object in
+            all feature pyramid. It has shape (num_pos, 2)
+        strides (Tensor): The prior strides of a object in
+            all feature pyramid. It has shape (num_pos, 1)
+        size_of_interest (int): The size of the region used in rel coord.
+        feat_sizes (Tuple[int]): The feature size H and W, which has 2 dims.
+    Returns:
+        rel_coord_feat (Tensor): The coordinate feature
+            of shape (num_pos, 2, H, W).
+    """
+
+    H, W = feat_sizes
+    rel_coordinates = centers.reshape(-1, 1, 2) - locations.reshape(1, -1, 2)
+    rel_coordinates = rel_coordinates.permute(0, 2, 1).float()
+    rel_coordinates = rel_coordinates / (
+        strides[:, None, None] * size_of_interest)
+    return rel_coordinates.reshape(-1, 2, H, W)
+
+
+def aligned_bilinear(tensor: Tensor, factor: int) -> Tensor:
+    """aligned bilinear, used in original implement in CondInst:
+
+    https://github.com/aim-uofa/AdelaiDet/blob/\
+    c0b2092ce72442b0f40972f7c6dda8bb52c46d16/adet/utils/comm.py#L23
+    """
+
+    assert tensor.dim() == 4
+    assert factor >= 1
+    assert int(factor) == factor
+
+    if factor == 1:
+        return tensor
+
+    h, w = tensor.size()[2:]
+    tensor = F.pad(tensor, pad=(0, 1, 0, 1), mode='replicate')
+    oh = factor * h + 1
+    ow = factor * w + 1
+    tensor = F.interpolate(
+        tensor, size=(oh, ow), mode='bilinear', align_corners=True)
+    tensor = F.pad(
+        tensor, pad=(factor // 2, 0, factor // 2, 0), mode='replicate')
+
+    return tensor[:, :, :oh - 1, :ow - 1]
+
+
+def unfold_wo_center(x, kernel_size: int, dilation: int) -> Tensor:
+    """unfold_wo_center, used in original implement in BoxInst:
+
+    https://github.com/aim-uofa/AdelaiDet/blob/\
+    4a3a1f7372c35b48ebf5f6adc59f135a0fa28d60/\
+    adet/modeling/condinst/condinst.py#L53
+    """
+    assert x.dim() == 4
+    assert kernel_size % 2 == 1
+
+    # using SAME padding
+    padding = (kernel_size + (dilation - 1) * (kernel_size - 1)) // 2
+    unfolded_x = F.unfold(
+        x, kernel_size=kernel_size, padding=padding, dilation=dilation)
+    unfolded_x = unfolded_x.reshape(
+        x.size(0), x.size(1), -1, x.size(2), x.size(3))
+    # remove the center pixels
+    size = kernel_size**2
+    unfolded_x = torch.cat(
+        (unfolded_x[:, :, :size // 2], unfolded_x[:, :, size // 2 + 1:]),
+        dim=2)
+
+    return unfolded_x
+
+
+def padding_to(input_tensor: Tensor, max_len: int = 300) -> Tensor:
+    """Pad the first dimension of `input_tensor` to `max_len`.
+
+    Args:
+        input_tensor (Tensor): The tensor to be padded,
+        max_len (int): Padding target size in the first dimension.
+            Default: 300
+    https://github.com/jshilong/DDQ/blob/ddq_detr/projects/models/utils.py#L19
+    Returns:
+        Tensor: The tensor padded with the first dimension size `max_len`.
+    """
+    if max_len is None:
+        return input_tensor
+    num_padding = max_len - len(input_tensor)
+    if input_tensor.dim() > 1:
+        padding = input_tensor.new_zeros(
+            num_padding, *input_tensor.size()[1:], dtype=input_tensor.dtype)
+    else:
+        padding = input_tensor.new_zeros(num_padding, dtype=input_tensor.dtype)
+    output_tensor = torch.cat([input_tensor, padding], dim=0)
+    return output_tensor
+
+
+def align_tensor(inputs: List[Tensor],
+                 max_len: Optional[int] = None) -> Tensor:
+    """Pad each input to `max_len`, then stack them. If `max_len` is None, then
+    it is the max size of the first dimension of each input.
+
+        https://github.com/jshilong/DDQ/blob/ddq_detr/projects/models/\
+        utils.py#L12
+
+    Args:
+        inputs (list[Tensor]): The tensors to be padded,
+            Each input should have the same shape except the first dimension.
+        max_len (int): Padding target size in the first dimension.
+            Default: None
+    Returns:
+        Tensor: Stacked inputs after padding in the first dimension.
+    """
+    if max_len is None:
+        max_len = max([len(item) for item in inputs])
+
+    return torch.stack([padding_to(item, max_len) for item in inputs])
diff --git a/mmdetection/mmdet/models/utils/panoptic_gt_processing.py b/mmdetection/mmdet/models/utils/panoptic_gt_processing.py
new file mode 100644
index 00000000..7a3bc95f
--- /dev/null
+++ b/mmdetection/mmdet/models/utils/panoptic_gt_processing.py
@@ -0,0 +1,70 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Tuple
+
+import torch
+from torch import Tensor
+
+
+def preprocess_panoptic_gt(gt_labels: Tensor, gt_masks: Tensor,
+                           gt_semantic_seg: Tensor, num_things: int,
+                           num_stuff: int) -> Tuple[Tensor, Tensor]:
+    """Preprocess the ground truth for a image.
+
+    Args:
+        gt_labels (Tensor): Ground truth labels of each bbox,
+            with shape (num_gts, ).
+        gt_masks (BitmapMasks): Ground truth masks of each instances
+            of a image, shape (num_gts, h, w).
+        gt_semantic_seg (Tensor | None): Ground truth of semantic
+            segmentation with the shape (1, h, w).
+            [0, num_thing_class - 1] means things,
+            [num_thing_class, num_class-1] means stuff,
+            255 means VOID. It's None when training instance segmentation.
+
+    Returns:
+        tuple[Tensor, Tensor]: a tuple containing the following targets.
+
+            - labels (Tensor): Ground truth class indices for a
+                image, with shape (n, ), n is the sum of number
+                of stuff type and number of instance in a image.
+            - masks (Tensor): Ground truth mask for a image, with
+                shape (n, h, w). Contains stuff and things when training
+                panoptic segmentation, and things only when training
+                instance segmentation.
+    """
+    num_classes = num_things + num_stuff
+    things_masks = gt_masks.to_tensor(
+        dtype=torch.bool, device=gt_labels.device)
+
+    if gt_semantic_seg is None:
+        masks = things_masks.long()
+        return gt_labels, masks
+
+    things_labels = gt_labels
+    gt_semantic_seg = gt_semantic_seg.squeeze(0)
+
+    semantic_labels = torch.unique(
+        gt_semantic_seg,
+        sorted=False,
+        return_inverse=False,
+        return_counts=False)
+    stuff_masks_list = []
+    stuff_labels_list = []
+    for label in semantic_labels:
+        if label < num_things or label >= num_classes:
+            continue
+        stuff_mask = gt_semantic_seg == label
+        stuff_masks_list.append(stuff_mask)
+        stuff_labels_list.append(label)
+
+    if len(stuff_masks_list) > 0:
+        stuff_masks = torch.stack(stuff_masks_list, dim=0)
+        stuff_labels = torch.stack(stuff_labels_list, dim=0)
+        labels = torch.cat([things_labels, stuff_labels], dim=0)
+        masks = torch.cat([things_masks, stuff_masks], dim=0)
+    else:
+        labels = things_labels
+        masks = things_masks
+
+    masks = masks.long()
+    return labels, masks
diff --git a/mmdetection/mmdet/models/utils/point_sample.py b/mmdetection/mmdet/models/utils/point_sample.py
new file mode 100644
index 00000000..1afc957f
--- /dev/null
+++ b/mmdetection/mmdet/models/utils/point_sample.py
@@ -0,0 +1,88 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from mmcv.ops import point_sample
+from torch import Tensor
+
+
+def get_uncertainty(mask_preds: Tensor, labels: Tensor) -> Tensor:
+    """Estimate uncertainty based on pred logits.
+
+    We estimate uncertainty as L1 distance between 0.0 and the logits
+    prediction in 'mask_preds' for the foreground class in `classes`.
+
+    Args:
+        mask_preds (Tensor): mask predication logits, shape (num_rois,
+            num_classes, mask_height, mask_width).
+
+        labels (Tensor): Either predicted or ground truth label for
+            each predicted mask, of length num_rois.
+
+    Returns:
+        scores (Tensor): Uncertainty scores with the most uncertain
+            locations having the highest uncertainty score,
+            shape (num_rois, 1, mask_height, mask_width)
+    """
+    if mask_preds.shape[1] == 1:
+        gt_class_logits = mask_preds.clone()
+    else:
+        inds = torch.arange(mask_preds.shape[0], device=mask_preds.device)
+        gt_class_logits = mask_preds[inds, labels].unsqueeze(1)
+    return -torch.abs(gt_class_logits)
+
+
+def get_uncertain_point_coords_with_randomness(
+        mask_preds: Tensor, labels: Tensor, num_points: int,
+        oversample_ratio: float, importance_sample_ratio: float) -> Tensor:
+    """Get ``num_points`` most uncertain points with random points during
+    train.
+
+    Sample points in [0, 1] x [0, 1] coordinate space based on their
+    uncertainty. The uncertainties are calculated for each point using
+    'get_uncertainty()' function that takes point's logit prediction as
+    input.
+
+    Args:
+        mask_preds (Tensor): A tensor of shape (num_rois, num_classes,
+            mask_height, mask_width) for class-specific or class-agnostic
+            prediction.
+        labels (Tensor): The ground truth class for each instance.
+        num_points (int): The number of points to sample.
+        oversample_ratio (float): Oversampling parameter.
+        importance_sample_ratio (float): Ratio of points that are sampled
+            via importnace sampling.
+
+    Returns:
+        point_coords (Tensor): A tensor of shape (num_rois, num_points, 2)
+            that contains the coordinates sampled points.
+    """
+    assert oversample_ratio >= 1
+    assert 0 <= importance_sample_ratio <= 1
+    batch_size = mask_preds.shape[0]
+    num_sampled = int(num_points * oversample_ratio)
+    point_coords = torch.rand(
+        batch_size, num_sampled, 2, device=mask_preds.device)
+    point_logits = point_sample(mask_preds, point_coords)
+    # It is crucial to calculate uncertainty based on the sampled
+    # prediction value for the points. Calculating uncertainties of the
+    # coarse predictions first and sampling them for points leads to
+    # incorrect results.  To illustrate this: assume uncertainty func(
+    # logits)=-abs(logits), a sampled point between two coarse
+    # predictions with -1 and 1 logits has 0 logits, and therefore 0
+    # uncertainty value. However, if we calculate uncertainties for the
+    # coarse predictions first, both will have -1 uncertainty,
+    # and sampled point will get -1 uncertainty.
+    point_uncertainties = get_uncertainty(point_logits, labels)
+    num_uncertain_points = int(importance_sample_ratio * num_points)
+    num_random_points = num_points - num_uncertain_points
+    idx = torch.topk(
+        point_uncertainties[:, 0, :], k=num_uncertain_points, dim=1)[1]
+    shift = num_sampled * torch.arange(
+        batch_size, dtype=torch.long, device=mask_preds.device)
+    idx += shift[:, None]
+    point_coords = point_coords.view(-1, 2)[idx.view(-1), :].view(
+        batch_size, num_uncertain_points, 2)
+    if num_random_points > 0:
+        rand_roi_coords = torch.rand(
+            batch_size, num_random_points, 2, device=mask_preds.device)
+        point_coords = torch.cat((point_coords, rand_roi_coords), dim=1)
+    return point_coords
diff --git a/mmdetection/mmdet/models/utils/vlfuse_helper.py b/mmdetection/mmdet/models/utils/vlfuse_helper.py
new file mode 100644
index 00000000..76b54de3
--- /dev/null
+++ b/mmdetection/mmdet/models/utils/vlfuse_helper.py
@@ -0,0 +1,773 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# Modified from https://github.com/microsoft/GLIP/blob/main/maskrcnn_benchmark/utils/fuse_helper.py  # noqa
+# and https://github.com/microsoft/GLIP/blob/main/maskrcnn_benchmark/modeling/rpn/modeling_bert.py  # noqa
+import math
+from typing import Dict, Optional, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.checkpoint as checkpoint
+from mmcv.cnn.bricks import DropPath
+from torch import Tensor
+
+try:
+    from transformers import BertConfig, BertPreTrainedModel
+    from transformers.modeling_utils import apply_chunking_to_forward
+    from transformers.models.bert.modeling_bert import \
+        BertAttention as HFBertAttention
+    from transformers.models.bert.modeling_bert import \
+        BertIntermediate as HFBertIntermediate
+    from transformers.models.bert.modeling_bert import \
+        BertOutput as HFBertOutput
+except ImportError:
+    BertConfig = None
+    BertPreTrainedModel = object
+    apply_chunking_to_forward = None
+    HFBertAttention = object
+    HFBertIntermediate = object
+    HFBertOutput = object
+
+MAX_CLAMP_VALUE = 50000
+
+
+def permute_and_flatten(layer: Tensor, N: int, A: int, C: int, H: int,
+                        W: int) -> Tensor:
+    """Permute and then flatten a tensor,
+
+       from size (N, A, C, H, W) to (N, H * W * A, C).
+
+    Args:
+        layer (Tensor): Tensor of shape (N, C, H, W).
+        N (int): Batch size.
+        A (int): Number of attention heads.
+        C (int): Number of channels.
+        H (int): Height of feature map.
+        W (int): Width of feature map.
+
+    Returns:
+        Tensor: A Tensor of shape (N, H * W * A, C).
+    """
+    layer = layer.view(N, A, C, H, W)
+    layer = layer.permute(0, 3, 4, 1, 2)
+    layer = layer.reshape(N, -1, C)
+    return layer
+
+
+def clamp_values(vector: Tensor) -> Tensor:
+    """Clamp the values of a vector to the range [-MAX_CLAMP_VALUE,
+    MAX_CLAMP_VALUE].
+
+    Args:
+        vector (Tensor): Tensor of shape (N, C, H, W).
+
+    Returns:
+        Tensor: A Tensor of shape (N, C, H, W) with clamped values.
+    """
+    vector = torch.clamp(vector, min=-MAX_CLAMP_VALUE, max=MAX_CLAMP_VALUE)
+    return vector
+
+
+class BiMultiHeadAttention(nn.Module):
+    """Bidirectional fusion Multi-Head Attention layer.
+
+    Args:
+        v_dim (int): The dimension of the vision input.
+        l_dim (int): The dimension of the language input.
+        embed_dim (int): The embedding dimension for the attention operation.
+        num_heads (int): The number of attention heads.
+        dropout (float, optional): The dropout probability. Defaults to 0.1.
+    """
+
+    def __init__(self,
+                 v_dim: int,
+                 l_dim: int,
+                 embed_dim: int,
+                 num_heads: int,
+                 dropout: float = 0.1):
+        super(BiMultiHeadAttention, self).__init__()
+
+        self.embed_dim = embed_dim
+        self.num_heads = num_heads
+        self.head_dim = embed_dim // num_heads
+        self.v_dim = v_dim
+        self.l_dim = l_dim
+
+        assert (
+            self.head_dim * self.num_heads == self.embed_dim
+        ), 'embed_dim must be divisible by num_heads ' \
+           f'(got `embed_dim`: {self.embed_dim} ' \
+           f'and `num_heads`: {self.num_heads}).'
+        self.scale = self.head_dim**(-0.5)
+        self.dropout = dropout
+
+        self.v_proj = nn.Linear(self.v_dim, self.embed_dim)
+        self.l_proj = nn.Linear(self.l_dim, self.embed_dim)
+        self.values_v_proj = nn.Linear(self.v_dim, self.embed_dim)
+        self.values_l_proj = nn.Linear(self.l_dim, self.embed_dim)
+
+        self.out_v_proj = nn.Linear(self.embed_dim, self.v_dim)
+        self.out_l_proj = nn.Linear(self.embed_dim, self.l_dim)
+
+        self.stable_softmax_2d = False
+        self.clamp_min_for_underflow = True
+        self.clamp_max_for_overflow = True
+
+        self._reset_parameters()
+
+    def _shape(self, tensor: Tensor, seq_len: int, bsz: int):
+        return tensor.view(bsz, seq_len, self.num_heads,
+                           self.head_dim).transpose(1, 2).contiguous()
+
+    def _reset_parameters(self):
+        nn.init.xavier_uniform_(self.v_proj.weight)
+        self.v_proj.bias.data.fill_(0)
+        nn.init.xavier_uniform_(self.l_proj.weight)
+        self.l_proj.bias.data.fill_(0)
+        nn.init.xavier_uniform_(self.values_v_proj.weight)
+        self.values_v_proj.bias.data.fill_(0)
+        nn.init.xavier_uniform_(self.values_l_proj.weight)
+        self.values_l_proj.bias.data.fill_(0)
+        nn.init.xavier_uniform_(self.out_v_proj.weight)
+        self.out_v_proj.bias.data.fill_(0)
+        nn.init.xavier_uniform_(self.out_l_proj.weight)
+        self.out_l_proj.bias.data.fill_(0)
+
+    def forward(
+        self,
+        vision: Tensor,
+        lang: Tensor,
+        attention_mask_v: Optional[Tensor] = None,
+        attention_mask_l: Optional[Tensor] = None,
+    ) -> Tuple[Tensor, Tensor]:
+        bsz, tgt_len, _ = vision.size()
+
+        query_states = self.v_proj(vision) * self.scale
+        key_states = self._shape(self.l_proj(lang), -1, bsz)
+        value_v_states = self._shape(self.values_v_proj(vision), -1, bsz)
+        value_l_states = self._shape(self.values_l_proj(lang), -1, bsz)
+
+        proj_shape = (bsz * self.num_heads, -1, self.head_dim)
+        query_states = self._shape(query_states, tgt_len,
+                                   bsz).view(*proj_shape)
+        key_states = key_states.view(*proj_shape)
+        value_v_states = value_v_states.view(*proj_shape)
+        value_l_states = value_l_states.view(*proj_shape)
+
+        src_len = key_states.size(1)
+        attn_weights = torch.bmm(query_states, key_states.transpose(1, 2))
+
+        if attn_weights.size() != (bsz * self.num_heads, tgt_len, src_len):
+            raise ValueError(
+                f'Attention weights should be of '
+                f'size {(bsz * self.num_heads, tgt_len, src_len)}, '
+                f'but is {attn_weights.size()}')
+
+        if self.stable_softmax_2d:
+            attn_weights = attn_weights - attn_weights.max()
+
+        if self.clamp_min_for_underflow:
+            # Do not increase -50000, data type half has quite limited range
+            attn_weights = torch.clamp(attn_weights, min=-MAX_CLAMP_VALUE)
+        if self.clamp_max_for_overflow:
+            # Do not increase 50000, data type half has quite limited range
+            attn_weights = torch.clamp(attn_weights, max=MAX_CLAMP_VALUE)
+
+        attn_weights_T = attn_weights.transpose(1, 2)
+        attn_weights_l = (
+            attn_weights_T -
+            torch.max(attn_weights_T, dim=-1, keepdim=True)[0])
+        if self.clamp_min_for_underflow:
+            # Do not increase -50000, data type half has quite limited range
+            attn_weights_l = torch.clamp(attn_weights_l, min=-MAX_CLAMP_VALUE)
+        if self.clamp_max_for_overflow:
+            # Do not increase 50000, data type half has quite limited range
+            attn_weights_l = torch.clamp(attn_weights_l, max=MAX_CLAMP_VALUE)
+
+        if attention_mask_v is not None:
+            attention_mask_v = (
+                attention_mask_v[:, None,
+                                 None, :].repeat(1, self.num_heads, 1,
+                                                 1).flatten(0, 1))
+            attn_weights_l.masked_fill_(attention_mask_v, float('-inf'))
+
+        attn_weights_l = attn_weights_l.softmax(dim=-1)
+
+        if attention_mask_l is not None:
+            assert (attention_mask_l.dim() == 2)
+            attention_mask = attention_mask_l.unsqueeze(1).unsqueeze(1)
+            attention_mask = attention_mask.expand(bsz, 1, tgt_len, src_len)
+            attention_mask = attention_mask.masked_fill(
+                attention_mask == 0, -9e15)
+
+            if attention_mask.size() != (bsz, 1, tgt_len, src_len):
+                raise ValueError('Attention mask should be of '
+                                 f'size {(bsz, 1, tgt_len, src_len)}')
+            attn_weights = attn_weights.view(bsz, self.num_heads, tgt_len,
+                                             src_len) + attention_mask
+            attn_weights = attn_weights.view(bsz * self.num_heads, tgt_len,
+                                             src_len)
+
+        attn_weights_v = nn.functional.softmax(attn_weights, dim=-1)
+
+        attn_probs_v = F.dropout(
+            attn_weights_v, p=self.dropout, training=self.training)
+        attn_probs_l = F.dropout(
+            attn_weights_l, p=self.dropout, training=self.training)
+
+        attn_output_v = torch.bmm(attn_probs_v, value_l_states)
+        attn_output_l = torch.bmm(attn_probs_l, value_v_states)
+
+        if attn_output_v.size() != (bsz * self.num_heads, tgt_len,
+                                    self.head_dim):
+            raise ValueError(
+                '`attn_output_v` should be of '
+                f'size {(bsz, self.num_heads, tgt_len, self.head_dim)}, '
+                f'but is {attn_output_v.size()}')
+
+        if attn_output_l.size() != (bsz * self.num_heads, src_len,
+                                    self.head_dim):
+            raise ValueError(
+                '`attn_output_l` should be of size '
+                f'{(bsz, self.num_heads, src_len, self.head_dim)}, '
+                f'but is {attn_output_l.size()}')
+
+        attn_output_v = attn_output_v.view(bsz, self.num_heads, tgt_len,
+                                           self.head_dim)
+        attn_output_v = attn_output_v.transpose(1, 2)
+        attn_output_v = attn_output_v.reshape(bsz, tgt_len, self.embed_dim)
+
+        attn_output_l = attn_output_l.view(bsz, self.num_heads, src_len,
+                                           self.head_dim)
+        attn_output_l = attn_output_l.transpose(1, 2)
+        attn_output_l = attn_output_l.reshape(bsz, src_len, self.embed_dim)
+
+        attn_output_v = self.out_v_proj(attn_output_v)
+        attn_output_l = self.out_l_proj(attn_output_l)
+
+        return attn_output_v, attn_output_l
+
+
+class BiAttentionBlock(nn.Module):
+    """BiAttentionBlock Module:
+
+    First, multi-level visual features are concat; Then the concat visual
+    feature and lang feature are fused by attention; Finally the newly visual
+    feature are split into multi levels.
+
+    Args:
+        v_dim (int): The dimension of the visual features.
+        l_dim (int): The dimension of the language feature.
+        embed_dim (int): The embedding dimension for the attention operation.
+        num_heads (int): The number of attention heads.
+        dropout (float, optional): The dropout probability. Defaults to 0.1.
+        drop_path (float, optional): The drop path probability.
+            Defaults to 0.0.
+        init_values (float, optional):
+            The initial value for the scaling parameter.
+            Defaults to 1e-4.
+    """
+
+    def __init__(self,
+                 v_dim: int,
+                 l_dim: int,
+                 embed_dim: int,
+                 num_heads: int,
+                 dropout: float = 0.1,
+                 drop_path: float = .0,
+                 init_values: float = 1e-4):
+        super().__init__()
+
+        # pre layer norm
+        self.layer_norm_v = nn.LayerNorm(v_dim)
+        self.layer_norm_l = nn.LayerNorm(l_dim)
+        self.attn = BiMultiHeadAttention(
+            v_dim=v_dim,
+            l_dim=l_dim,
+            embed_dim=embed_dim,
+            num_heads=num_heads,
+            dropout=dropout)
+
+        # add layer scale for training stability
+        self.drop_path = DropPath(
+            drop_path) if drop_path > 0. else nn.Identity()
+        self.gamma_v = nn.Parameter(
+            init_values * torch.ones(v_dim), requires_grad=True)
+        self.gamma_l = nn.Parameter(
+            init_values * torch.ones(l_dim), requires_grad=True)
+
+    def forward(self,
+                vf0: Tensor,
+                vf1: Tensor,
+                vf2: Tensor,
+                vf3: Tensor,
+                vf4: Tensor,
+                lang_feature: Tensor,
+                attention_mask_l=None):
+        visual_features = [vf0, vf1, vf2, vf3, vf4]
+        size_per_level, visual_features_flatten = [], []
+        for i, feat_per_level in enumerate(visual_features):
+            bs, c, h, w = feat_per_level.shape
+            size_per_level.append([h, w])
+            feat = permute_and_flatten(feat_per_level, bs, -1, c, h, w)
+            visual_features_flatten.append(feat)
+        visual_features_flatten = torch.cat(visual_features_flatten, dim=1)
+        new_v, new_lang_feature = self.single_attention_call(
+            visual_features_flatten,
+            lang_feature,
+            attention_mask_l=attention_mask_l)
+        # [bs, N, C] -> [bs, C, N]
+        new_v = new_v.transpose(1, 2).contiguous()
+
+        start = 0
+        # fvfs is mean fusion_visual_features
+        fvfs = []
+        for (h, w) in size_per_level:
+            new_v_per_level = new_v[:, :,
+                                    start:start + h * w].view(bs, -1, h,
+                                                              w).contiguous()
+            fvfs.append(new_v_per_level)
+            start += h * w
+
+        return fvfs[0], fvfs[1], fvfs[2], fvfs[3], fvfs[4], new_lang_feature
+
+    def single_attention_call(
+        self,
+        visual: Tensor,
+        lang: Tensor,
+        attention_mask_v: Optional[Tensor] = None,
+        attention_mask_l: Optional[Tensor] = None,
+    ) -> Tuple[Tensor, Tensor]:
+        """Perform a single attention call between the visual and language
+        inputs.
+
+        Args:
+        visual (Tensor): The visual input tensor.
+        lang (Tensor): The language input tensor.
+        attention_mask_v (Optional[Tensor]):
+            An optional attention mask tensor for the visual input.
+        attention_mask_l (Optional[Tensor]):
+            An optional attention mask tensor for the language input.
+
+        Returns:
+            Tuple[Tensor, Tensor]: A tuple containing the updated
+                visual and language tensors after the attention call.
+        """
+        visual = self.layer_norm_v(visual)
+        lang = self.layer_norm_l(lang)
+        delta_v, delta_l = self.attn(
+            visual,
+            lang,
+            attention_mask_v=attention_mask_v,
+            attention_mask_l=attention_mask_l)
+        # visual, lang = visual + delta_v, l + delta_l
+        visual = visual + self.drop_path(self.gamma_v * delta_v)
+        lang = lang + self.drop_path(self.gamma_l * delta_l)
+        return visual, lang
+
+
+class SingleScaleBiAttentionBlock(BiAttentionBlock):
+    """This is a single-scale implementation of `BiAttentionBlock`.
+
+    The only differenece between it and `BiAttentionBlock` is that the
+    `forward` function of `SingleScaleBiAttentionBlock` only accepts a single
+    flatten visual feature map, while the `forward` function in
+    `BiAttentionBlock` accepts multiple visual feature maps.
+    """
+
+    def forward(self,
+                visual_feature: Tensor,
+                lang_feature: Tensor,
+                attention_mask_v=None,
+                attention_mask_l=None):
+        """Single-scale forward pass.
+
+        Args:
+            visual_feature (Tensor): The visual input tensor. Tensor of
+                shape (bs, patch_len, ch).
+            lang_feature (Tensor): The language input tensor. Tensor of
+                shape (bs, text_len, ch).
+            attention_mask_v (_type_, optional): Visual feature attention
+                mask. Defaults to None.
+            attention_mask_l (_type_, optional): Language feature attention
+                mask.Defaults to None.
+        """
+        new_v, new_lang_feature = self.single_attention_call(
+            visual_feature,
+            lang_feature,
+            attention_mask_v=attention_mask_v,
+            attention_mask_l=attention_mask_l)
+        return new_v, new_lang_feature
+
+
+class VLFuse(nn.Module):
+    """Early Fusion Module.
+
+    Args:
+        v_dim (int): Dimension of visual features.
+        l_dim (int): Dimension of language features.
+        embed_dim (int): The embedding dimension for the attention operation.
+        num_heads (int): Number of attention heads.
+        dropout (float): Dropout probability.
+        drop_path (float): Drop path probability.
+        use_checkpoint (bool): Whether to use PyTorch's checkpoint function.
+    """
+
+    def __init__(self,
+                 v_dim: int = 256,
+                 l_dim: int = 768,
+                 embed_dim: int = 2048,
+                 num_heads: int = 8,
+                 dropout: float = 0.1,
+                 drop_path: float = 0.0,
+                 use_checkpoint: bool = False):
+        super().__init__()
+        self.use_checkpoint = use_checkpoint
+        self.b_attn = BiAttentionBlock(
+            v_dim=v_dim,
+            l_dim=l_dim,
+            embed_dim=embed_dim,
+            num_heads=num_heads,
+            dropout=dropout,
+            drop_path=drop_path,
+            init_values=1.0 / 6.0)
+
+    def forward(self, x: dict) -> dict:
+        """Forward pass of the VLFuse module."""
+        visual_features = x['visual']
+        language_dict_features = x['lang']
+
+        if self.use_checkpoint:
+            # vf is mean visual_features
+            # checkpoint does not allow complex data structures as input,
+            # such as list, so we must split them.
+            vf0, vf1, vf2, vf3, vf4, language_features = checkpoint.checkpoint(
+                self.b_attn, *visual_features,
+                language_dict_features['hidden'],
+                language_dict_features['masks'])
+        else:
+            vf0, vf1, vf2, vf3, vf4, language_features = self.b_attn(
+                *visual_features, language_dict_features['hidden'],
+                language_dict_features['masks'])
+
+        language_dict_features['hidden'] = language_features
+        fused_language_dict_features = language_dict_features
+
+        features_dict = {
+            'visual': [vf0, vf1, vf2, vf3, vf4],
+            'lang': fused_language_dict_features
+        }
+
+        return features_dict
+
+
+class BertEncoderLayer(BertPreTrainedModel):
+    """A modified version of the `BertLayer` class from the
+    `transformers.models.bert.modeling_bert` module.
+
+    Args:
+        config (:class:`~transformers.BertConfig`):
+            The configuration object that
+            contains various parameters for the model.
+        clamp_min_for_underflow (bool, optional):
+            Whether to clamp the minimum value of the hidden states
+             to prevent underflow. Defaults to `False`.
+        clamp_max_for_overflow (bool, optional):
+            Whether to clamp the maximum value of the hidden states
+            to prevent overflow. Defaults to `False`.
+    """
+
+    def __init__(self,
+                 config: BertConfig,
+                 clamp_min_for_underflow: bool = False,
+                 clamp_max_for_overflow: bool = False):
+        super().__init__(config)
+        self.config = config
+        self.chunk_size_feed_forward = config.chunk_size_feed_forward
+        self.seq_len_dim = 1
+
+        self.attention = BertAttention(config, clamp_min_for_underflow,
+                                       clamp_max_for_overflow)
+        self.intermediate = BertIntermediate(config)
+        self.output = BertOutput(config)
+
+    def forward(
+        self, inputs: Dict[str, Dict[str, torch.Tensor]]
+    ) -> Dict[str, Dict[str, torch.Tensor]]:
+        """Applies the BertEncoderLayer to the input features."""
+        language_dict_features = inputs['lang']
+        hidden_states = language_dict_features['hidden']
+        attention_mask = language_dict_features['masks']
+
+        device = hidden_states.device
+        input_shape = hidden_states.size()[:-1]
+        extended_attention_mask = self.get_extended_attention_mask(
+            attention_mask, input_shape, device)
+
+        self_attention_outputs = self.attention(
+            hidden_states,
+            extended_attention_mask,
+            None,
+            output_attentions=False,
+            past_key_value=None)
+        attention_output = self_attention_outputs[0]
+        outputs = self_attention_outputs[1:]
+        layer_output = apply_chunking_to_forward(self.feed_forward_chunk,
+                                                 self.chunk_size_feed_forward,
+                                                 self.seq_len_dim,
+                                                 attention_output)
+        outputs = (layer_output, ) + outputs
+        hidden_states = outputs[0]
+
+        language_dict_features['hidden'] = hidden_states
+
+        features_dict = {
+            'visual': inputs['visual'],
+            'lang': language_dict_features
+        }
+
+        return features_dict
+
+    def feed_forward_chunk(self, attention_output: Tensor) -> Tensor:
+        """Applies the intermediate and output layers of the BertEncoderLayer
+        to a chunk of the input sequence."""
+        intermediate_output = self.intermediate(attention_output)
+        layer_output = self.output(intermediate_output, attention_output)
+        return layer_output
+
+
+# The following code is the same as the Huggingface code,
+# with the only difference being the additional clamp operation.
+class BertSelfAttention(nn.Module):
+    """BERT self-attention layer from Huggingface transformers.
+
+    Compared to the BertSelfAttention of Huggingface, only add the clamp.
+
+    Args:
+        config (:class:`~transformers.BertConfig`):
+            The configuration object that
+            contains various parameters for the model.
+        clamp_min_for_underflow (bool, optional):
+            Whether to clamp the minimum value of the hidden states
+             to prevent underflow. Defaults to `False`.
+        clamp_max_for_overflow (bool, optional):
+            Whether to clamp the maximum value of the hidden states
+            to prevent overflow. Defaults to `False`.
+    """
+
+    def __init__(self,
+                 config: BertConfig,
+                 clamp_min_for_underflow: bool = False,
+                 clamp_max_for_overflow: bool = False):
+        super().__init__()
+        if config.hidden_size % config.num_attention_heads != 0 and \
+                not hasattr(config, 'embedding_size'):
+            raise ValueError(f'The hidden size ({config.hidden_size}) is '
+                             'not a multiple of the number of attention '
+                             f'heads ({config.num_attention_heads})')
+
+        self.num_attention_heads = config.num_attention_heads
+        self.attention_head_size = int(config.hidden_size /
+                                       config.num_attention_heads)
+        self.all_head_size = self.num_attention_heads * \
+            self.attention_head_size
+
+        self.query = nn.Linear(config.hidden_size, self.all_head_size)
+        self.key = nn.Linear(config.hidden_size, self.all_head_size)
+        self.value = nn.Linear(config.hidden_size, self.all_head_size)
+
+        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
+        self.position_embedding_type = getattr(config,
+                                               'position_embedding_type',
+                                               'absolute')
+        if self.position_embedding_type == 'relative_key' or \
+                self.position_embedding_type == 'relative_key_query':
+            self.max_position_embeddings = config.max_position_embeddings
+            self.distance_embedding = nn.Embedding(
+                2 * config.max_position_embeddings - 1,
+                self.attention_head_size)
+        self.clamp_min_for_underflow = clamp_min_for_underflow
+        self.clamp_max_for_overflow = clamp_max_for_overflow
+
+        self.is_decoder = config.is_decoder
+
+    def transpose_for_scores(self, x: Tensor) -> Tensor:
+        """Transpose the dimensions of `x`."""
+        new_x_shape = x.size()[:-1] + (self.num_attention_heads,
+                                       self.attention_head_size)
+        x = x.view(*new_x_shape)
+        return x.permute(0, 2, 1, 3)
+
+    def forward(
+        self,
+        hidden_states: Tensor,
+        attention_mask: Optional[Tensor] = None,
+        head_mask: Optional[Tensor] = None,
+        encoder_hidden_states: Optional[Tensor] = None,
+        encoder_attention_mask: Optional[Tensor] = None,
+        past_key_value: Optional[Tuple[Tensor, Tensor]] = None,
+        output_attentions: bool = False,
+    ) -> Tuple[Tensor, ...]:
+        """Perform a forward pass through the BERT self-attention layer."""
+
+        mixed_query_layer = self.query(hidden_states)
+
+        # If this is instantiated as a cross-attention module, the keys
+        # and values come from an encoder; the attention mask needs to be
+        # such that the encoder's padding tokens are not attended to.
+        is_cross_attention = encoder_hidden_states is not None
+
+        if is_cross_attention and past_key_value is not None:
+            # reuse k,v, cross_attentions
+            key_layer = past_key_value[0]
+            value_layer = past_key_value[1]
+            attention_mask = encoder_attention_mask
+        elif is_cross_attention:
+            key_layer = self.transpose_for_scores(
+                self.key(encoder_hidden_states))
+            value_layer = self.transpose_for_scores(
+                self.value(encoder_hidden_states))
+            attention_mask = encoder_attention_mask
+        elif past_key_value is not None:
+            key_layer = self.transpose_for_scores(self.key(hidden_states))
+            value_layer = self.transpose_for_scores(self.value(hidden_states))
+            key_layer = torch.cat([past_key_value[0], key_layer], dim=2)
+            value_layer = torch.cat([past_key_value[1], value_layer], dim=2)
+        else:
+            key_layer = self.transpose_for_scores(self.key(hidden_states))
+            value_layer = self.transpose_for_scores(self.value(hidden_states))
+
+        query_layer = self.transpose_for_scores(mixed_query_layer)
+
+        if self.is_decoder:
+            past_key_value = (key_layer, value_layer)
+
+        # Take the dot product between "query" and "key"
+        # to get the raw attention scores.
+        attention_scores = torch.matmul(query_layer,
+                                        key_layer.transpose(-1, -2))
+
+        if self.position_embedding_type == 'relative_key' or \
+                self.position_embedding_type == 'relative_key_query':
+            seq_length = hidden_states.size()[1]
+            position_ids_l = torch.arange(
+                seq_length, dtype=torch.long,
+                device=hidden_states.device).view(-1, 1)
+            position_ids_r = torch.arange(
+                seq_length, dtype=torch.long,
+                device=hidden_states.device).view(1, -1)
+            distance = position_ids_l - position_ids_r
+            positional_embedding = self.distance_embedding(
+                distance + self.max_position_embeddings - 1)
+            positional_embedding = positional_embedding.to(
+                dtype=query_layer.dtype)  # fp16 compatibility
+
+            if self.position_embedding_type == 'relative_key':
+                relative_position_scores = torch.einsum(
+                    'bhld,lrd->bhlr', query_layer, positional_embedding)
+                attention_scores = attention_scores + relative_position_scores
+            elif self.position_embedding_type == 'relative_key_query':
+                relative_position_scores_query = torch.einsum(
+                    'bhld,lrd->bhlr', query_layer, positional_embedding)
+                relative_position_scores_key = torch.einsum(
+                    'bhrd,lrd->bhlr', key_layer, positional_embedding)
+                attention_scores = attention_scores + \
+                    relative_position_scores_query + \
+                    relative_position_scores_key
+
+        attention_scores = attention_scores / math.sqrt(
+            self.attention_head_size)
+
+        if self.clamp_min_for_underflow:
+            attention_scores = torch.clamp(
+                attention_scores, min=-MAX_CLAMP_VALUE
+            )  # Do not increase -50000, data type half has quite limited range
+        if self.clamp_max_for_overflow:
+            attention_scores = torch.clamp(
+                attention_scores, max=MAX_CLAMP_VALUE
+            )  # Do not increase 50000, data type half has quite limited range
+
+        if attention_mask is not None:
+            # Apply the attention mask is
+            # (precomputed for all layers in BertModel forward() function)
+            attention_scores = attention_scores + attention_mask
+
+        # Normalize the attention scores to probabilities.
+        attention_probs = nn.Softmax(dim=-1)(attention_scores)
+
+        # This is actually dropping out entire tokens to attend to, which might
+        # seem a bit unusual, but is taken from the original Transformer paper.
+        attention_probs = self.dropout(attention_probs)
+
+        # Mask heads if we want to
+        if head_mask is not None:
+            attention_probs = attention_probs * head_mask
+
+        context_layer = torch.matmul(attention_probs, value_layer)
+
+        context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
+        new_context_layer_shape = context_layer.size()[:-2] + (
+            self.all_head_size, )
+        context_layer = context_layer.view(*new_context_layer_shape)
+
+        outputs = (context_layer,
+                   attention_probs) if output_attentions else (context_layer, )
+
+        if self.is_decoder:
+            outputs = outputs + (past_key_value, )
+        return outputs
+
+
+class BertAttention(HFBertAttention):
+    """BertAttention is made up of self-attention and intermediate+output.
+
+    Compared to the BertAttention of Huggingface, only add the clamp.
+
+    Args:
+        config (:class:`~transformers.BertConfig`):
+            The configuration object that
+            contains various parameters for the model.
+        clamp_min_for_underflow (bool, optional):
+            Whether to clamp the minimum value of the hidden states
+             to prevent underflow. Defaults to `False`.
+        clamp_max_for_overflow (bool, optional):
+            Whether to clamp the maximum value of the hidden states
+            to prevent overflow. Defaults to `False`.
+    """
+
+    def __init__(self,
+                 config: BertConfig,
+                 clamp_min_for_underflow: bool = False,
+                 clamp_max_for_overflow: bool = False):
+        super().__init__(config)
+        self.self = BertSelfAttention(config, clamp_min_for_underflow,
+                                      clamp_max_for_overflow)
+
+
+class BertIntermediate(HFBertIntermediate):
+    """Modified from transformers.models.bert.modeling_bert.BertIntermediate.
+
+    Compared to the BertIntermediate of Huggingface, only add the clamp.
+    """
+
+    def forward(self, hidden_states: Tensor) -> Tensor:
+        hidden_states = self.dense(hidden_states)
+        hidden_states = clamp_values(hidden_states)
+        hidden_states = self.intermediate_act_fn(hidden_states)
+        hidden_states = clamp_values(hidden_states)
+        return hidden_states
+
+
+class BertOutput(HFBertOutput):
+    """Modified from transformers.models.bert.modeling_bert.BertOutput.
+
+    Compared to the BertOutput of Huggingface, only add the clamp.
+    """
+
+    def forward(self, hidden_states: Tensor, input_tensor: Tensor) -> Tensor:
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        hidden_states = clamp_values(hidden_states)
+        hidden_states = self.LayerNorm(hidden_states + input_tensor)
+        hidden_states = clamp_values(hidden_states)
+        return hidden_states
diff --git a/mmdetection/mmdet/models/utils/wbf.py b/mmdetection/mmdet/models/utils/wbf.py
new file mode 100644
index 00000000..b26a2c66
--- /dev/null
+++ b/mmdetection/mmdet/models/utils/wbf.py
@@ -0,0 +1,250 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+import warnings
+from typing import Tuple
+
+import numpy as np
+import torch
+from torch import Tensor
+
+
+# References: https://github.com/ZFTurbo/Weighted-Boxes-Fusion
+def weighted_boxes_fusion(
+        bboxes_list: list,
+        scores_list: list,
+        labels_list: list,
+        weights: list = None,
+        iou_thr: float = 0.55,
+        skip_box_thr: float = 0.0,
+        conf_type: str = 'avg',
+        allows_overflow: bool = False) -> Tuple[Tensor, Tensor, Tensor]:
+    """weighted boxes fusion  is a method for
+    fusing predictions from different object detection models, which utilizes
+    confidence scores of all proposed bounding boxes to construct averaged
+    boxes.
+
+    Args:
+        bboxes_list(list): list of boxes predictions from each model,
+                                    each box is 4 numbers.
+        scores_list(list): list of scores for each model
+        labels_list(list): list of labels for each model
+        weights: list of weights for each model.
+                Default: None, which means weight == 1 for each model
+        iou_thr: IoU value for boxes to be a match
+        skip_box_thr: exclude boxes with score lower than this variable.
+        conf_type: how to calculate confidence in weighted boxes.
+            'avg': average value,
+            'max': maximum value,
+            'box_and_model_avg': box and model wise hybrid weighted average,
+            'absent_model_aware_avg': weighted average that takes into
+                            account the absent model.
+        allows_overflow: false if we want confidence score not exceed 1.0.
+
+    Returns:
+        bboxes(Tensor): boxes coordinates (Order of boxes: x1, y1, x2, y2).
+        scores(Tensor): confidence scores
+        labels(Tensor): boxes labels
+    """
+
+    if weights is None:
+        weights = np.ones(len(bboxes_list))
+    if len(weights) != len(bboxes_list):
+        print('Warning: incorrect number of weights {}. Must be: '
+              '{}. Set weights equal to 1.'.format(
+                  len(weights), len(bboxes_list)))
+        weights = np.ones(len(bboxes_list))
+    weights = np.array(weights)
+
+    if conf_type not in [
+            'avg', 'max', 'box_and_model_avg', 'absent_model_aware_avg'
+    ]:
+        print('Unknown conf_type: {}. Must be "avg", '
+              '"max" or "box_and_model_avg", '
+              'or "absent_model_aware_avg"'.format(conf_type))
+        exit()
+
+    filtered_boxes = prefilter_boxes(bboxes_list, scores_list, labels_list,
+                                     weights, skip_box_thr)
+    if len(filtered_boxes) == 0:
+        return torch.Tensor(), torch.Tensor(), torch.Tensor()
+
+    overall_boxes = []
+
+    for label in filtered_boxes:
+        boxes = filtered_boxes[label]
+        new_boxes = []
+        weighted_boxes = np.empty((0, 8))
+
+        # Clusterize boxes
+        for j in range(0, len(boxes)):
+            index, best_iou = find_matching_box_fast(weighted_boxes, boxes[j],
+                                                     iou_thr)
+
+            if index != -1:
+                new_boxes[index].append(boxes[j])
+                weighted_boxes[index] = get_weighted_box(
+                    new_boxes[index], conf_type)
+            else:
+                new_boxes.append([boxes[j].copy()])
+                weighted_boxes = np.vstack((weighted_boxes, boxes[j].copy()))
+
+        # Rescale confidence based on number of models and boxes
+        for i in range(len(new_boxes)):
+            clustered_boxes = new_boxes[i]
+            if conf_type == 'box_and_model_avg':
+                clustered_boxes = np.array(clustered_boxes)
+                # weighted average for boxes
+                weighted_boxes[i, 1] = weighted_boxes[i, 1] * len(
+                    clustered_boxes) / weighted_boxes[i, 2]
+                # identify unique model index by model index column
+                _, idx = np.unique(clustered_boxes[:, 3], return_index=True)
+                # rescale by unique model weights
+                weighted_boxes[i, 1] = weighted_boxes[i, 1] * clustered_boxes[
+                    idx, 2].sum() / weights.sum()
+            elif conf_type == 'absent_model_aware_avg':
+                clustered_boxes = np.array(clustered_boxes)
+                # get unique model index in the cluster
+                models = np.unique(clustered_boxes[:, 3]).astype(int)
+                # create a mask to get unused model weights
+                mask = np.ones(len(weights), dtype=bool)
+                mask[models] = False
+                # absent model aware weighted average
+                weighted_boxes[
+                    i, 1] = weighted_boxes[i, 1] * len(clustered_boxes) / (
+                        weighted_boxes[i, 2] + weights[mask].sum())
+            elif conf_type == 'max':
+                weighted_boxes[i, 1] = weighted_boxes[i, 1] / weights.max()
+            elif not allows_overflow:
+                weighted_boxes[i, 1] = weighted_boxes[i, 1] * min(
+                    len(weights), len(clustered_boxes)) / weights.sum()
+            else:
+                weighted_boxes[i, 1] = weighted_boxes[i, 1] * len(
+                    clustered_boxes) / weights.sum()
+        overall_boxes.append(weighted_boxes)
+    overall_boxes = np.concatenate(overall_boxes, axis=0)
+    overall_boxes = overall_boxes[overall_boxes[:, 1].argsort()[::-1]]
+
+    bboxes = torch.Tensor(overall_boxes[:, 4:])
+    scores = torch.Tensor(overall_boxes[:, 1])
+    labels = torch.Tensor(overall_boxes[:, 0]).int()
+
+    return bboxes, scores, labels
+
+
+def prefilter_boxes(boxes, scores, labels, weights, thr):
+
+    new_boxes = dict()
+
+    for t in range(len(boxes)):
+
+        if len(boxes[t]) != len(scores[t]):
+            print('Error. Length of boxes arrays not equal to '
+                  'length of scores array: {} != {}'.format(
+                      len(boxes[t]), len(scores[t])))
+            exit()
+
+        if len(boxes[t]) != len(labels[t]):
+            print('Error. Length of boxes arrays not equal to '
+                  'length of labels array: {} != {}'.format(
+                      len(boxes[t]), len(labels[t])))
+            exit()
+
+        for j in range(len(boxes[t])):
+            score = scores[t][j]
+            if score < thr:
+                continue
+            label = int(labels[t][j])
+            box_part = boxes[t][j]
+            x1 = float(box_part[0])
+            y1 = float(box_part[1])
+            x2 = float(box_part[2])
+            y2 = float(box_part[3])
+
+            # Box data checks
+            if x2 < x1:
+                warnings.warn('X2 < X1 value in box. Swap them.')
+                x1, x2 = x2, x1
+            if y2 < y1:
+                warnings.warn('Y2 < Y1 value in box. Swap them.')
+                y1, y2 = y2, y1
+            if (x2 - x1) * (y2 - y1) == 0.0:
+                warnings.warn('Zero area box skipped: {}.'.format(box_part))
+                continue
+
+            # [label, score, weight, model index, x1, y1, x2, y2]
+            b = [
+                int(label),
+                float(score) * weights[t], weights[t], t, x1, y1, x2, y2
+            ]
+
+            if label not in new_boxes:
+                new_boxes[label] = []
+            new_boxes[label].append(b)
+
+    # Sort each list in dict by score and transform it to numpy array
+    for k in new_boxes:
+        current_boxes = np.array(new_boxes[k])
+        new_boxes[k] = current_boxes[current_boxes[:, 1].argsort()[::-1]]
+
+    return new_boxes
+
+
+def get_weighted_box(boxes, conf_type='avg'):
+
+    box = np.zeros(8, dtype=np.float32)
+    conf = 0
+    conf_list = []
+    w = 0
+    for b in boxes:
+        box[4:] += (b[1] * b[4:])
+        conf += b[1]
+        conf_list.append(b[1])
+        w += b[2]
+    box[0] = boxes[0][0]
+    if conf_type in ('avg', 'box_and_model_avg', 'absent_model_aware_avg'):
+        box[1] = conf / len(boxes)
+    elif conf_type == 'max':
+        box[1] = np.array(conf_list).max()
+    box[2] = w
+    box[3] = -1
+    box[4:] /= conf
+
+    return box
+
+
+def find_matching_box_fast(boxes_list, new_box, match_iou):
+
+    def bb_iou_array(boxes, new_box):
+        # bb intersection over union
+        xA = np.maximum(boxes[:, 0], new_box[0])
+        yA = np.maximum(boxes[:, 1], new_box[1])
+        xB = np.minimum(boxes[:, 2], new_box[2])
+        yB = np.minimum(boxes[:, 3], new_box[3])
+
+        interArea = np.maximum(xB - xA, 0) * np.maximum(yB - yA, 0)
+
+        # compute the area of both the prediction and ground-truth rectangles
+        boxAArea = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
+        boxBArea = (new_box[2] - new_box[0]) * (new_box[3] - new_box[1])
+
+        iou = interArea / (boxAArea + boxBArea - interArea)
+
+        return iou
+
+    if boxes_list.shape[0] == 0:
+        return -1, match_iou
+
+    boxes = boxes_list
+
+    ious = bb_iou_array(boxes[:, 4:], new_box[4:])
+
+    ious[boxes[:, 0] != new_box[0]] = -1
+
+    best_idx = np.argmax(ious)
+    best_iou = ious[best_idx]
+
+    if best_iou <= match_iou:
+        best_iou = match_iou
+        best_idx = -1
+
+    return best_idx, best_iou
diff --git a/mmdetection/mmdet/models/vis/__init__.py b/mmdetection/mmdet/models/vis/__init__.py
new file mode 100644
index 00000000..ab63a906
--- /dev/null
+++ b/mmdetection/mmdet/models/vis/__init__.py
@@ -0,0 +1,5 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .mask2former_vis import Mask2FormerVideo
+from .masktrack_rcnn import MaskTrackRCNN
+
+__all__ = ['Mask2FormerVideo', 'MaskTrackRCNN']
diff --git a/mmdetection/mmdet/models/vis/mask2former_vis.py b/mmdetection/mmdet/models/vis/mask2former_vis.py
new file mode 100644
index 00000000..6ab04296
--- /dev/null
+++ b/mmdetection/mmdet/models/vis/mask2former_vis.py
@@ -0,0 +1,120 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Union
+
+from torch import Tensor
+
+from mmdet.models.mot import BaseMOTModel
+from mmdet.registry import MODELS
+from mmdet.structures import TrackDataSample, TrackSampleList
+from mmdet.utils import OptConfigType, OptMultiConfig
+
+
+@MODELS.register_module()
+class Mask2FormerVideo(BaseMOTModel):
+    r"""Implementation of `Masked-attention Mask
+    Transformer for Universal Image Segmentation
+    `_.
+
+    Args:
+        backbone (dict): Configuration of backbone. Defaults to None.
+        track_head (dict): Configuration of track head. Defaults to None.
+        data_preprocessor (dict or ConfigDict, optional): The pre-process
+           config of :class:`TrackDataPreprocessor`.  it usually includes,
+            ``pad_size_divisor``, ``pad_value``, ``mean`` and ``std``.
+            Defaults to None.
+        init_cfg (dict or list[dict]): Configuration of initialization.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 backbone: Optional[dict] = None,
+                 track_head: Optional[dict] = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None):
+        super(BaseMOTModel, self).__init__(
+            data_preprocessor=data_preprocessor, init_cfg=init_cfg)
+
+        if backbone is not None:
+            self.backbone = MODELS.build(backbone)
+
+        if track_head is not None:
+            self.track_head = MODELS.build(track_head)
+
+        self.num_classes = self.track_head.num_classes
+
+    def _load_from_state_dict(self, state_dict, prefix, local_metadata, strict,
+                              missing_keys, unexpected_keys, error_msgs):
+        """Overload in order to load mmdet pretrained ckpt."""
+        for key in list(state_dict):
+            if key.startswith('panoptic_head'):
+                state_dict[key.replace('panoptic',
+                                       'track')] = state_dict.pop(key)
+
+        super()._load_from_state_dict(state_dict, prefix, local_metadata,
+                                      strict, missing_keys, unexpected_keys,
+                                      error_msgs)
+
+    def loss(self, inputs: Tensor, data_samples: TrackSampleList,
+             **kwargs) -> Union[dict, tuple]:
+        """
+        Args:
+            inputs (Tensor): Input images of shape (N, T, C, H, W).
+                These should usually be mean centered and std scaled.
+            data_samples (list[:obj:`TrackDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance`.
+
+        Returns:
+            dict[str, Tensor]: a dictionary of loss components
+        """
+        assert inputs.dim() == 5, 'The img must be 5D Tensor (N, T, C, H, W).'
+        # shape (N * T, C, H, W)
+        img = inputs.flatten(0, 1)
+
+        x = self.backbone(img)
+        losses = self.track_head.loss(x, data_samples)
+
+        return losses
+
+    def predict(self,
+                inputs: Tensor,
+                data_samples: TrackSampleList,
+                rescale: bool = True) -> TrackSampleList:
+        """Predict results from a batch of inputs and data samples with
+        postprocessing.
+
+        Args:
+            inputs (Tensor): of shape (N, T, C, H, W) encoding
+                input images. The N denotes batch size.
+                The T denotes the number of frames in a video.
+            data_samples (list[:obj:`TrackDataSample`]): The batch
+                data samples. It usually includes information such
+                as `video_data_samples`.
+            rescale (bool, Optional): If False, then returned bboxes and masks
+                will fit the scale of img, otherwise, returned bboxes and masks
+                will fit the scale of original image shape. Defaults to True.
+
+        Returns:
+            TrackSampleList: Tracking results of the inputs.
+        """
+        assert inputs.dim() == 5, 'The img must be 5D Tensor (N, T, C, H, W).'
+
+        assert len(data_samples) == 1, \
+            'Mask2former only support 1 batch size per gpu for now.'
+
+        # [T, C, H, W]
+        img = inputs[0]
+        track_data_sample = data_samples[0]
+        feats = self.backbone(img)
+        pred_track_ins_list = self.track_head.predict(feats, track_data_sample,
+                                                      rescale)
+
+        det_data_samples_list = []
+        for idx, pred_track_ins in enumerate(pred_track_ins_list):
+            img_data_sample = track_data_sample[idx]
+            img_data_sample.pred_track_instances = pred_track_ins
+            det_data_samples_list.append(img_data_sample)
+
+        results = TrackDataSample()
+        results.video_data_samples = det_data_samples_list
+        return [results]
diff --git a/mmdetection/mmdet/models/vis/masktrack_rcnn.py b/mmdetection/mmdet/models/vis/masktrack_rcnn.py
new file mode 100644
index 00000000..9c28e7b8
--- /dev/null
+++ b/mmdetection/mmdet/models/vis/masktrack_rcnn.py
@@ -0,0 +1,181 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional
+
+import torch
+from torch import Tensor
+
+from mmdet.models.mot import BaseMOTModel
+from mmdet.registry import MODELS
+from mmdet.structures import TrackSampleList
+from mmdet.utils import OptConfigType, OptMultiConfig
+
+
+@MODELS.register_module()
+class MaskTrackRCNN(BaseMOTModel):
+    """Video Instance Segmentation.
+
+    This video instance segmentor is the implementation of`MaskTrack R-CNN
+    `_.
+
+    Args:
+        detector (dict): Configuration of detector. Defaults to None.
+        track_head (dict): Configuration of track head. Defaults to None.
+        tracker (dict): Configuration of tracker. Defaults to None.
+        data_preprocessor (dict or ConfigDict, optional): The pre-process
+           config of :class:`TrackDataPreprocessor`.  it usually includes,
+            ``pad_size_divisor``, ``pad_value``, ``mean`` and ``std``.
+        init_cfg (dict or list[dict]): Configuration of initialization.
+            Defaults to None.
+    """
+
+    def __init__(self,
+                 detector: Optional[dict] = None,
+                 track_head: Optional[dict] = None,
+                 tracker: Optional[dict] = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None):
+        super().__init__(data_preprocessor, init_cfg)
+
+        if detector is not None:
+            self.detector = MODELS.build(detector)
+        assert hasattr(self.detector, 'roi_head'), \
+            'MaskTrack R-CNN only supports two stage detectors.'
+
+        if track_head is not None:
+            self.track_head = MODELS.build(track_head)
+        if tracker is not None:
+            self.tracker = MODELS.build(tracker)
+
+    def loss(self, inputs: Tensor, data_samples: TrackSampleList,
+             **kwargs) -> dict:
+        """Calculate losses from a batch of inputs and data samples.
+
+        Args:
+            inputs (Dict[str, Tensor]): of shape (N, T, C, H, W) encoding
+                input images. Typically these should be mean centered and std
+                scaled. The N denotes batch size. The T denotes the number of
+                frames.
+            data_samples (list[:obj:`TrackDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance`.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+
+        assert inputs.dim() == 5, 'The img must be 5D Tensor (N, T, C, H, W).'
+        assert inputs.size(1) == 2, \
+            'MaskTrackRCNN can only have 1 key frame and 1 reference frame.'
+
+        # split the data_samples into two aspects: key frames and reference
+        # frames
+        ref_data_samples, key_data_samples = [], []
+        key_frame_inds, ref_frame_inds = [], []
+
+        # set cat_id of gt_labels to 0 in RPN
+        for track_data_sample in data_samples:
+            key_data_sample = track_data_sample.get_key_frames()[0]
+            key_data_samples.append(key_data_sample)
+            ref_data_sample = track_data_sample.get_ref_frames()[0]
+            ref_data_samples.append(ref_data_sample)
+            key_frame_inds.append(track_data_sample.key_frames_inds[0])
+            ref_frame_inds.append(track_data_sample.ref_frames_inds[0])
+
+        key_frame_inds = torch.tensor(key_frame_inds, dtype=torch.int64)
+        ref_frame_inds = torch.tensor(ref_frame_inds, dtype=torch.int64)
+        batch_inds = torch.arange(len(inputs))
+        key_imgs = inputs[batch_inds, key_frame_inds].contiguous()
+        ref_imgs = inputs[batch_inds, ref_frame_inds].contiguous()
+
+        x = self.detector.extract_feat(key_imgs)
+        ref_x = self.detector.extract_feat(ref_imgs)
+
+        losses = dict()
+
+        # RPN forward and loss
+        if self.detector.with_rpn:
+            proposal_cfg = self.detector.train_cfg.get(
+                'rpn_proposal', self.detector.test_cfg.rpn)
+
+            rpn_losses, rpn_results_list = self.detector.rpn_head. \
+                loss_and_predict(x,
+                                 key_data_samples,
+                                 proposal_cfg=proposal_cfg,
+                                 **kwargs)
+
+            # avoid get same name with roi_head loss
+            keys = rpn_losses.keys()
+            for key in keys:
+                if 'loss' in key and 'rpn' not in key:
+                    rpn_losses[f'rpn_{key}'] = rpn_losses.pop(key)
+            losses.update(rpn_losses)
+        else:
+            # TODO: Not support currently, should have a check at Fast R-CNN
+            assert key_data_samples[0].get('proposals', None) is not None
+            # use pre-defined proposals in InstanceData for the second stage
+            # to extract ROI features.
+            rpn_results_list = [
+                key_data_sample.proposals
+                for key_data_sample in key_data_samples
+            ]
+
+        losses_detect = self.detector.roi_head.loss(x, rpn_results_list,
+                                                    key_data_samples, **kwargs)
+        losses.update(losses_detect)
+
+        losses_track = self.track_head.loss(x, ref_x, rpn_results_list,
+                                            data_samples, **kwargs)
+        losses.update(losses_track)
+
+        return losses
+
+    def predict(self,
+                inputs: Tensor,
+                data_samples: TrackSampleList,
+                rescale: bool = True,
+                **kwargs) -> TrackSampleList:
+        """Test without augmentation.
+
+        Args:
+            inputs (Tensor): of shape (N, T, C, H, W) encoding
+                input images. The N denotes batch size.
+                The T denotes the number of frames in a video.
+            data_samples (list[:obj:`TrackDataSample`]): The batch
+                data samples. It usually includes information such
+                as `video_data_samples`.
+            rescale (bool, Optional): If False, then returned bboxes and masks
+                will fit the scale of img, otherwise, returned bboxes and masks
+                will fit the scale of original image shape. Defaults to True.
+
+        Returns:
+            TrackSampleList: Tracking results of the inputs.
+        """
+        assert inputs.dim() == 5, 'The img must be 5D Tensor (N, T, C, H, W).'
+
+        assert len(data_samples) == 1, \
+            'MaskTrackRCNN only support 1 batch size per gpu for now.'
+
+        track_data_sample = data_samples[0]
+        video_len = len(track_data_sample)
+        if track_data_sample[0].frame_id == 0:
+            self.tracker.reset()
+
+        for frame_id in range(video_len):
+            img_data_sample = track_data_sample[frame_id]
+            single_img = inputs[:, frame_id].contiguous()
+            x = self.detector.extract_feat(single_img)
+
+            rpn_results_list = self.detector.rpn_head.predict(
+                x, [img_data_sample])
+            # det_results List[InstanceData]
+            det_results = self.detector.roi_head.predict(
+                x, rpn_results_list, [img_data_sample], rescale=rescale)
+            assert len(det_results) == 1, 'Batch inference is not supported.'
+            assert 'masks' in det_results[0], 'There are no mask results.'
+
+            img_data_sample.pred_instances = det_results[0]
+            frame_pred_track_instances = self.tracker.track(
+                model=self, feats=x, data_sample=img_data_sample, **kwargs)
+            img_data_sample.pred_track_instances = frame_pred_track_instances
+
+        return [track_data_sample]
diff --git a/mmdetection/mmdet/registry.py b/mmdetection/mmdet/registry.py
new file mode 100644
index 00000000..3a5b2b28
--- /dev/null
+++ b/mmdetection/mmdet/registry.py
@@ -0,0 +1,121 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+"""MMDetection provides 17 registry nodes to support using modules across
+projects. Each node is a child of the root registry in MMEngine.
+
+More details can be found at
+https://mmengine.readthedocs.io/en/latest/tutorials/registry.html.
+"""
+
+from mmengine.registry import DATA_SAMPLERS as MMENGINE_DATA_SAMPLERS
+from mmengine.registry import DATASETS as MMENGINE_DATASETS
+from mmengine.registry import EVALUATOR as MMENGINE_EVALUATOR
+from mmengine.registry import HOOKS as MMENGINE_HOOKS
+from mmengine.registry import LOG_PROCESSORS as MMENGINE_LOG_PROCESSORS
+from mmengine.registry import LOOPS as MMENGINE_LOOPS
+from mmengine.registry import METRICS as MMENGINE_METRICS
+from mmengine.registry import MODEL_WRAPPERS as MMENGINE_MODEL_WRAPPERS
+from mmengine.registry import MODELS as MMENGINE_MODELS
+from mmengine.registry import \
+    OPTIM_WRAPPER_CONSTRUCTORS as MMENGINE_OPTIM_WRAPPER_CONSTRUCTORS
+from mmengine.registry import OPTIM_WRAPPERS as MMENGINE_OPTIM_WRAPPERS
+from mmengine.registry import OPTIMIZERS as MMENGINE_OPTIMIZERS
+from mmengine.registry import PARAM_SCHEDULERS as MMENGINE_PARAM_SCHEDULERS
+from mmengine.registry import \
+    RUNNER_CONSTRUCTORS as MMENGINE_RUNNER_CONSTRUCTORS
+from mmengine.registry import RUNNERS as MMENGINE_RUNNERS
+from mmengine.registry import TASK_UTILS as MMENGINE_TASK_UTILS
+from mmengine.registry import TRANSFORMS as MMENGINE_TRANSFORMS
+from mmengine.registry import VISBACKENDS as MMENGINE_VISBACKENDS
+from mmengine.registry import VISUALIZERS as MMENGINE_VISUALIZERS
+from mmengine.registry import \
+    WEIGHT_INITIALIZERS as MMENGINE_WEIGHT_INITIALIZERS
+from mmengine.registry import Registry
+
+# manage all kinds of runners like `EpochBasedRunner` and `IterBasedRunner`
+RUNNERS = Registry(
+    'runner', parent=MMENGINE_RUNNERS, locations=['mmdet.engine.runner'])
+# manage runner constructors that define how to initialize runners
+RUNNER_CONSTRUCTORS = Registry(
+    'runner constructor',
+    parent=MMENGINE_RUNNER_CONSTRUCTORS,
+    locations=['mmdet.engine.runner'])
+# manage all kinds of loops like `EpochBasedTrainLoop`
+LOOPS = Registry(
+    'loop', parent=MMENGINE_LOOPS, locations=['mmdet.engine.runner'])
+# manage all kinds of hooks like `CheckpointHook`
+HOOKS = Registry(
+    'hook', parent=MMENGINE_HOOKS, locations=['mmdet.engine.hooks'])
+
+# manage data-related modules
+DATASETS = Registry(
+    'dataset', parent=MMENGINE_DATASETS, locations=['mmdet.datasets'])
+DATA_SAMPLERS = Registry(
+    'data sampler',
+    parent=MMENGINE_DATA_SAMPLERS,
+    locations=['mmdet.datasets.samplers'])
+TRANSFORMS = Registry(
+    'transform',
+    parent=MMENGINE_TRANSFORMS,
+    locations=['mmdet.datasets.transforms'])
+
+# manage all kinds of modules inheriting `nn.Module`
+MODELS = Registry('model', parent=MMENGINE_MODELS, locations=['mmdet.models'])
+# manage all kinds of model wrappers like 'MMDistributedDataParallel'
+MODEL_WRAPPERS = Registry(
+    'model_wrapper',
+    parent=MMENGINE_MODEL_WRAPPERS,
+    locations=['mmdet.models'])
+# manage all kinds of weight initialization modules like `Uniform`
+WEIGHT_INITIALIZERS = Registry(
+    'weight initializer',
+    parent=MMENGINE_WEIGHT_INITIALIZERS,
+    locations=['mmdet.models'])
+
+# manage all kinds of optimizers like `SGD` and `Adam`
+OPTIMIZERS = Registry(
+    'optimizer',
+    parent=MMENGINE_OPTIMIZERS,
+    locations=['mmdet.engine.optimizers'])
+# manage optimizer wrapper
+OPTIM_WRAPPERS = Registry(
+    'optim_wrapper',
+    parent=MMENGINE_OPTIM_WRAPPERS,
+    locations=['mmdet.engine.optimizers'])
+# manage constructors that customize the optimization hyperparameters.
+OPTIM_WRAPPER_CONSTRUCTORS = Registry(
+    'optimizer constructor',
+    parent=MMENGINE_OPTIM_WRAPPER_CONSTRUCTORS,
+    locations=['mmdet.engine.optimizers'])
+# manage all kinds of parameter schedulers like `MultiStepLR`
+PARAM_SCHEDULERS = Registry(
+    'parameter scheduler',
+    parent=MMENGINE_PARAM_SCHEDULERS,
+    locations=['mmdet.engine.schedulers'])
+# manage all kinds of metrics
+METRICS = Registry(
+    'metric', parent=MMENGINE_METRICS, locations=['mmdet.evaluation'])
+# manage evaluator
+EVALUATOR = Registry(
+    'evaluator', parent=MMENGINE_EVALUATOR, locations=['mmdet.evaluation'])
+
+# manage task-specific modules like anchor generators and box coders
+TASK_UTILS = Registry(
+    'task util', parent=MMENGINE_TASK_UTILS, locations=['mmdet.models'])
+
+# manage visualizer
+VISUALIZERS = Registry(
+    'visualizer',
+    parent=MMENGINE_VISUALIZERS,
+    locations=['mmdet.visualization'])
+# manage visualizer backend
+VISBACKENDS = Registry(
+    'vis_backend',
+    parent=MMENGINE_VISBACKENDS,
+    locations=['mmdet.visualization'])
+
+# manage logprocessor
+LOG_PROCESSORS = Registry(
+    'log_processor',
+    parent=MMENGINE_LOG_PROCESSORS,
+    # TODO: update the location when mmdet has its own log processor
+    locations=['mmdet.engine'])
diff --git a/mmdetection/mmdet/structures/__init__.py b/mmdetection/mmdet/structures/__init__.py
new file mode 100644
index 00000000..381c6a4f
--- /dev/null
+++ b/mmdetection/mmdet/structures/__init__.py
@@ -0,0 +1,10 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .det_data_sample import DetDataSample, OptSampleList, SampleList
+from .reid_data_sample import ReIDDataSample
+from .track_data_sample import (OptTrackSampleList, TrackDataSample,
+                                TrackSampleList)
+
+__all__ = [
+    'DetDataSample', 'SampleList', 'OptSampleList', 'TrackDataSample',
+    'TrackSampleList', 'OptTrackSampleList', 'ReIDDataSample'
+]
diff --git a/mmdetection/mmdet/structures/bbox/__init__.py b/mmdetection/mmdet/structures/bbox/__init__.py
new file mode 100644
index 00000000..4d531986
--- /dev/null
+++ b/mmdetection/mmdet/structures/bbox/__init__.py
@@ -0,0 +1,25 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .base_boxes import BaseBoxes
+from .bbox_overlaps import bbox_overlaps
+from .box_type import (autocast_box_type, convert_box_type, get_box_type,
+                       register_box, register_box_converter)
+from .horizontal_boxes import HorizontalBoxes
+from .transforms import bbox_cxcyah_to_xyxy  # noqa: E501
+from .transforms import (bbox2corner, bbox2distance, bbox2result, bbox2roi,
+                         bbox_cxcywh_to_xyxy, bbox_flip, bbox_mapping,
+                         bbox_mapping_back, bbox_project, bbox_rescale,
+                         bbox_xyxy_to_cxcyah, bbox_xyxy_to_cxcywh, cat_boxes,
+                         corner2bbox, distance2bbox, empty_box_as,
+                         find_inside_bboxes, get_box_tensor, get_box_wh,
+                         roi2bbox, scale_boxes, stack_boxes)
+
+__all__ = [
+    'bbox_overlaps', 'bbox_flip', 'bbox_mapping', 'bbox_mapping_back',
+    'bbox2roi', 'roi2bbox', 'bbox2result', 'distance2bbox', 'bbox2distance',
+    'bbox_rescale', 'bbox_cxcywh_to_xyxy', 'bbox_xyxy_to_cxcywh',
+    'find_inside_bboxes', 'bbox2corner', 'corner2bbox', 'bbox_project',
+    'BaseBoxes', 'convert_box_type', 'get_box_type', 'register_box',
+    'register_box_converter', 'HorizontalBoxes', 'autocast_box_type',
+    'cat_boxes', 'stack_boxes', 'scale_boxes', 'get_box_wh', 'get_box_tensor',
+    'empty_box_as', 'bbox_xyxy_to_cxcyah', 'bbox_cxcyah_to_xyxy'
+]
diff --git a/mmdetection/mmdet/structures/bbox/base_boxes.py b/mmdetection/mmdet/structures/bbox/base_boxes.py
new file mode 100644
index 00000000..0ed66766
--- /dev/null
+++ b/mmdetection/mmdet/structures/bbox/base_boxes.py
@@ -0,0 +1,549 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from abc import ABCMeta, abstractmethod, abstractproperty, abstractstaticmethod
+from typing import List, Optional, Sequence, Tuple, Type, TypeVar, Union
+
+import numpy as np
+import torch
+from torch import BoolTensor, Tensor
+
+from mmdet.structures.mask.structures import BitmapMasks, PolygonMasks
+
+T = TypeVar('T')
+DeviceType = Union[str, torch.device]
+IndexType = Union[slice, int, list, torch.LongTensor, torch.cuda.LongTensor,
+                  torch.BoolTensor, torch.cuda.BoolTensor, np.ndarray]
+MaskType = Union[BitmapMasks, PolygonMasks]
+
+
+class BaseBoxes(metaclass=ABCMeta):
+    """The base class for 2D box types.
+
+    The functions of ``BaseBoxes`` lie in three fields:
+
+    - Verify the boxes shape.
+    - Support tensor-like operations.
+    - Define abstract functions for 2D boxes.
+
+    In ``__init__`` , ``BaseBoxes`` verifies the validity of the data shape
+    w.r.t ``box_dim``. The tensor with the dimension >= 2 and the length
+    of the last dimension being ``box_dim`` will be regarded as valid.
+    ``BaseBoxes`` will restore them at the field ``tensor``. It's necessary
+    to override ``box_dim`` in subclass to guarantee the data shape is
+    correct.
+
+    There are many basic tensor-like functions implemented in ``BaseBoxes``.
+    In most cases, users can operate ``BaseBoxes`` instance like a normal
+    tensor. To protect the validity of data shape, All tensor-like functions
+    cannot modify the last dimension of ``self.tensor``.
+
+    When creating a new box type, users need to inherit from ``BaseBoxes``
+    and override abstract methods and specify the ``box_dim``. Then, register
+    the new box type by using the decorator ``register_box_type``.
+
+    Args:
+        data (Tensor or np.ndarray or Sequence): The box data with shape
+            (..., box_dim).
+        dtype (torch.dtype, Optional): data type of boxes. Defaults to None.
+        device (str or torch.device, Optional): device of boxes.
+            Default to None.
+        clone (bool): Whether clone ``boxes`` or not. Defaults to True.
+    """
+
+    # Used to verify the last dimension length
+    # Should override it in subclass.
+    box_dim: int = 0
+
+    def __init__(self,
+                 data: Union[Tensor, np.ndarray, Sequence],
+                 dtype: Optional[torch.dtype] = None,
+                 device: Optional[DeviceType] = None,
+                 clone: bool = True) -> None:
+        if isinstance(data, (np.ndarray, Tensor, Sequence)):
+            data = torch.as_tensor(data)
+        else:
+            raise TypeError('boxes should be Tensor, ndarray, or Sequence, ',
+                            f'but got {type(data)}')
+
+        if device is not None or dtype is not None:
+            data = data.to(dtype=dtype, device=device)
+        # Clone the data to avoid potential bugs
+        if clone:
+            data = data.clone()
+        # handle the empty input like []
+        if data.numel() == 0:
+            data = data.reshape((-1, self.box_dim))
+
+        assert data.dim() >= 2 and data.size(-1) == self.box_dim, \
+            ('The boxes dimension must >= 2 and the length of the last '
+             f'dimension must be {self.box_dim}, but got boxes with '
+             f'shape {data.shape}.')
+        self.tensor = data
+
+    def convert_to(self, dst_type: Union[str, type]) -> 'BaseBoxes':
+        """Convert self to another box type.
+
+        Args:
+            dst_type (str or type): destination box type.
+
+        Returns:
+            :obj:`BaseBoxes`: destination box type object .
+        """
+        from .box_type import convert_box_type
+        return convert_box_type(self, dst_type=dst_type)
+
+    def empty_boxes(self: T,
+                    dtype: Optional[torch.dtype] = None,
+                    device: Optional[DeviceType] = None) -> T:
+        """Create empty box.
+
+        Args:
+            dtype (torch.dtype, Optional): data type of boxes.
+            device (str or torch.device, Optional): device of boxes.
+
+        Returns:
+            T: empty boxes with shape of (0, box_dim).
+        """
+        empty_box = self.tensor.new_zeros(
+            0, self.box_dim, dtype=dtype, device=device)
+        return type(self)(empty_box, clone=False)
+
+    def fake_boxes(self: T,
+                   sizes: Tuple[int],
+                   fill: float = 0,
+                   dtype: Optional[torch.dtype] = None,
+                   device: Optional[DeviceType] = None) -> T:
+        """Create fake boxes with specific sizes and fill values.
+
+        Args:
+            sizes (Tuple[int]): The size of fake boxes. The last value must
+                be equal with ``self.box_dim``.
+            fill (float): filling value. Defaults to 0.
+            dtype (torch.dtype, Optional): data type of boxes.
+            device (str or torch.device, Optional): device of boxes.
+
+        Returns:
+            T: Fake boxes with shape of ``sizes``.
+        """
+        fake_boxes = self.tensor.new_full(
+            sizes, fill, dtype=dtype, device=device)
+        return type(self)(fake_boxes, clone=False)
+
+    def __getitem__(self: T, index: IndexType) -> T:
+        """Rewrite getitem to protect the last dimension shape."""
+        boxes = self.tensor
+        if isinstance(index, np.ndarray):
+            index = torch.as_tensor(index, device=self.device)
+        if isinstance(index, Tensor) and index.dtype == torch.bool:
+            assert index.dim() < boxes.dim()
+        elif isinstance(index, tuple):
+            assert len(index) < boxes.dim()
+            # `Ellipsis`(...) is commonly used in index like [None, ...].
+            # When `Ellipsis` is in index, it must be the last item.
+            if Ellipsis in index:
+                assert index[-1] is Ellipsis
+
+        boxes = boxes[index]
+        if boxes.dim() == 1:
+            boxes = boxes.reshape(1, -1)
+        return type(self)(boxes, clone=False)
+
+    def __setitem__(self: T, index: IndexType, values: Union[Tensor, T]) -> T:
+        """Rewrite setitem to protect the last dimension shape."""
+        assert type(values) is type(self), \
+            'The value to be set must be the same box type as self'
+        values = values.tensor
+
+        if isinstance(index, np.ndarray):
+            index = torch.as_tensor(index, device=self.device)
+        if isinstance(index, Tensor) and index.dtype == torch.bool:
+            assert index.dim() < self.tensor.dim()
+        elif isinstance(index, tuple):
+            assert len(index) < self.tensor.dim()
+            # `Ellipsis`(...) is commonly used in index like [None, ...].
+            # When `Ellipsis` is in index, it must be the last item.
+            if Ellipsis in index:
+                assert index[-1] is Ellipsis
+
+        self.tensor[index] = values
+
+    def __len__(self) -> int:
+        """Return the length of self.tensor first dimension."""
+        return self.tensor.size(0)
+
+    def __deepcopy__(self, memo):
+        """Only clone the ``self.tensor`` when applying deepcopy."""
+        cls = self.__class__
+        other = cls.__new__(cls)
+        memo[id(self)] = other
+        other.tensor = self.tensor.clone()
+        return other
+
+    def __repr__(self) -> str:
+        """Return a strings that describes the object."""
+        return self.__class__.__name__ + '(\n' + str(self.tensor) + ')'
+
+    def new_tensor(self, *args, **kwargs) -> Tensor:
+        """Reload ``new_tensor`` from self.tensor."""
+        return self.tensor.new_tensor(*args, **kwargs)
+
+    def new_full(self, *args, **kwargs) -> Tensor:
+        """Reload ``new_full`` from self.tensor."""
+        return self.tensor.new_full(*args, **kwargs)
+
+    def new_empty(self, *args, **kwargs) -> Tensor:
+        """Reload ``new_empty`` from self.tensor."""
+        return self.tensor.new_empty(*args, **kwargs)
+
+    def new_ones(self, *args, **kwargs) -> Tensor:
+        """Reload ``new_ones`` from self.tensor."""
+        return self.tensor.new_ones(*args, **kwargs)
+
+    def new_zeros(self, *args, **kwargs) -> Tensor:
+        """Reload ``new_zeros`` from self.tensor."""
+        return self.tensor.new_zeros(*args, **kwargs)
+
+    def size(self, dim: Optional[int] = None) -> Union[int, torch.Size]:
+        """Reload new_zeros from self.tensor."""
+        # self.tensor.size(dim) cannot work when dim=None.
+        return self.tensor.size() if dim is None else self.tensor.size(dim)
+
+    def dim(self) -> int:
+        """Reload ``dim`` from self.tensor."""
+        return self.tensor.dim()
+
+    @property
+    def device(self) -> torch.device:
+        """Reload ``device`` from self.tensor."""
+        return self.tensor.device
+
+    @property
+    def dtype(self) -> torch.dtype:
+        """Reload ``dtype`` from self.tensor."""
+        return self.tensor.dtype
+
+    @property
+    def shape(self) -> torch.Size:
+        return self.tensor.shape
+
+    def numel(self) -> int:
+        """Reload ``numel`` from self.tensor."""
+        return self.tensor.numel()
+
+    def numpy(self) -> np.ndarray:
+        """Reload ``numpy`` from self.tensor."""
+        return self.tensor.numpy()
+
+    def to(self: T, *args, **kwargs) -> T:
+        """Reload ``to`` from self.tensor."""
+        return type(self)(self.tensor.to(*args, **kwargs), clone=False)
+
+    def cpu(self: T) -> T:
+        """Reload ``cpu`` from self.tensor."""
+        return type(self)(self.tensor.cpu(), clone=False)
+
+    def cuda(self: T, *args, **kwargs) -> T:
+        """Reload ``cuda`` from self.tensor."""
+        return type(self)(self.tensor.cuda(*args, **kwargs), clone=False)
+
+    def clone(self: T) -> T:
+        """Reload ``clone`` from self.tensor."""
+        return type(self)(self.tensor)
+
+    def detach(self: T) -> T:
+        """Reload ``detach`` from self.tensor."""
+        return type(self)(self.tensor.detach(), clone=False)
+
+    def view(self: T, *shape: Tuple[int]) -> T:
+        """Reload ``view`` from self.tensor."""
+        return type(self)(self.tensor.view(shape), clone=False)
+
+    def reshape(self: T, *shape: Tuple[int]) -> T:
+        """Reload ``reshape`` from self.tensor."""
+        return type(self)(self.tensor.reshape(shape), clone=False)
+
+    def expand(self: T, *sizes: Tuple[int]) -> T:
+        """Reload ``expand`` from self.tensor."""
+        return type(self)(self.tensor.expand(sizes), clone=False)
+
+    def repeat(self: T, *sizes: Tuple[int]) -> T:
+        """Reload ``repeat`` from self.tensor."""
+        return type(self)(self.tensor.repeat(sizes), clone=False)
+
+    def transpose(self: T, dim0: int, dim1: int) -> T:
+        """Reload ``transpose`` from self.tensor."""
+        ndim = self.tensor.dim()
+        assert dim0 != -1 and dim0 != ndim - 1
+        assert dim1 != -1 and dim1 != ndim - 1
+        return type(self)(self.tensor.transpose(dim0, dim1), clone=False)
+
+    def permute(self: T, *dims: Tuple[int]) -> T:
+        """Reload ``permute`` from self.tensor."""
+        assert dims[-1] == -1 or dims[-1] == self.tensor.dim() - 1
+        return type(self)(self.tensor.permute(dims), clone=False)
+
+    def split(self: T,
+              split_size_or_sections: Union[int, Sequence[int]],
+              dim: int = 0) -> List[T]:
+        """Reload ``split`` from self.tensor."""
+        assert dim != -1 and dim != self.tensor.dim() - 1
+        boxes_list = self.tensor.split(split_size_or_sections, dim=dim)
+        return [type(self)(boxes, clone=False) for boxes in boxes_list]
+
+    def chunk(self: T, chunks: int, dim: int = 0) -> List[T]:
+        """Reload ``chunk`` from self.tensor."""
+        assert dim != -1 and dim != self.tensor.dim() - 1
+        boxes_list = self.tensor.chunk(chunks, dim=dim)
+        return [type(self)(boxes, clone=False) for boxes in boxes_list]
+
+    def unbind(self: T, dim: int = 0) -> T:
+        """Reload ``unbind`` from self.tensor."""
+        assert dim != -1 and dim != self.tensor.dim() - 1
+        boxes_list = self.tensor.unbind(dim=dim)
+        return [type(self)(boxes, clone=False) for boxes in boxes_list]
+
+    def flatten(self: T, start_dim: int = 0, end_dim: int = -2) -> T:
+        """Reload ``flatten`` from self.tensor."""
+        assert end_dim != -1 and end_dim != self.tensor.dim() - 1
+        return type(self)(self.tensor.flatten(start_dim, end_dim), clone=False)
+
+    def squeeze(self: T, dim: Optional[int] = None) -> T:
+        """Reload ``squeeze`` from self.tensor."""
+        boxes = self.tensor.squeeze() if dim is None else \
+            self.tensor.squeeze(dim)
+        return type(self)(boxes, clone=False)
+
+    def unsqueeze(self: T, dim: int) -> T:
+        """Reload ``unsqueeze`` from self.tensor."""
+        assert dim != -1 and dim != self.tensor.dim()
+        return type(self)(self.tensor.unsqueeze(dim), clone=False)
+
+    @classmethod
+    def cat(cls: Type[T], box_list: Sequence[T], dim: int = 0) -> T:
+        """Cancatenates a box instance list into one single box instance.
+        Similar to ``torch.cat``.
+
+        Args:
+            box_list (Sequence[T]): A sequence of box instances.
+            dim (int): The dimension over which the box are concatenated.
+                Defaults to 0.
+
+        Returns:
+            T: Concatenated box instance.
+        """
+        assert isinstance(box_list, Sequence)
+        if len(box_list) == 0:
+            raise ValueError('box_list should not be a empty list.')
+
+        assert dim != -1 and dim != box_list[0].dim() - 1
+        assert all(isinstance(boxes, cls) for boxes in box_list)
+
+        th_box_list = [boxes.tensor for boxes in box_list]
+        return cls(torch.cat(th_box_list, dim=dim), clone=False)
+
+    @classmethod
+    def stack(cls: Type[T], box_list: Sequence[T], dim: int = 0) -> T:
+        """Concatenates a sequence of tensors along a new dimension. Similar to
+        ``torch.stack``.
+
+        Args:
+            box_list (Sequence[T]): A sequence of box instances.
+            dim (int): Dimension to insert. Defaults to 0.
+
+        Returns:
+            T: Concatenated box instance.
+        """
+        assert isinstance(box_list, Sequence)
+        if len(box_list) == 0:
+            raise ValueError('box_list should not be a empty list.')
+
+        assert dim != -1 and dim != box_list[0].dim()
+        assert all(isinstance(boxes, cls) for boxes in box_list)
+
+        th_box_list = [boxes.tensor for boxes in box_list]
+        return cls(torch.stack(th_box_list, dim=dim), clone=False)
+
+    @abstractproperty
+    def centers(self) -> Tensor:
+        """Return a tensor representing the centers of boxes."""
+        pass
+
+    @abstractproperty
+    def areas(self) -> Tensor:
+        """Return a tensor representing the areas of boxes."""
+        pass
+
+    @abstractproperty
+    def widths(self) -> Tensor:
+        """Return a tensor representing the widths of boxes."""
+        pass
+
+    @abstractproperty
+    def heights(self) -> Tensor:
+        """Return a tensor representing the heights of boxes."""
+        pass
+
+    @abstractmethod
+    def flip_(self,
+              img_shape: Tuple[int, int],
+              direction: str = 'horizontal') -> None:
+        """Flip boxes horizontally or vertically in-place.
+
+        Args:
+            img_shape (Tuple[int, int]): A tuple of image height and width.
+            direction (str): Flip direction, options are "horizontal",
+                "vertical" and "diagonal". Defaults to "horizontal"
+        """
+        pass
+
+    @abstractmethod
+    def translate_(self, distances: Tuple[float, float]) -> None:
+        """Translate boxes in-place.
+
+        Args:
+            distances (Tuple[float, float]): translate distances. The first
+                is horizontal distance and the second is vertical distance.
+        """
+        pass
+
+    @abstractmethod
+    def clip_(self, img_shape: Tuple[int, int]) -> None:
+        """Clip boxes according to the image shape in-place.
+
+        Args:
+            img_shape (Tuple[int, int]): A tuple of image height and width.
+        """
+        pass
+
+    @abstractmethod
+    def rotate_(self, center: Tuple[float, float], angle: float) -> None:
+        """Rotate all boxes in-place.
+
+        Args:
+            center (Tuple[float, float]): Rotation origin.
+            angle (float): Rotation angle represented in degrees. Positive
+                values mean clockwise rotation.
+        """
+        pass
+
+    @abstractmethod
+    def project_(self, homography_matrix: Union[Tensor, np.ndarray]) -> None:
+        """Geometric transformat boxes in-place.
+
+        Args:
+            homography_matrix (Tensor or np.ndarray]):
+                Shape (3, 3) for geometric transformation.
+        """
+        pass
+
+    @abstractmethod
+    def rescale_(self, scale_factor: Tuple[float, float]) -> None:
+        """Rescale boxes w.r.t. rescale_factor in-place.
+
+        Note:
+            Both ``rescale_`` and ``resize_`` will enlarge or shrink boxes
+            w.r.t ``scale_facotr``. The difference is that ``resize_`` only
+            changes the width and the height of boxes, but ``rescale_`` also
+            rescales the box centers simultaneously.
+
+        Args:
+            scale_factor (Tuple[float, float]): factors for scaling boxes.
+                The length should be 2.
+        """
+        pass
+
+    @abstractmethod
+    def resize_(self, scale_factor: Tuple[float, float]) -> None:
+        """Resize the box width and height w.r.t scale_factor in-place.
+
+        Note:
+            Both ``rescale_`` and ``resize_`` will enlarge or shrink boxes
+            w.r.t ``scale_facotr``. The difference is that ``resize_`` only
+            changes the width and the height of boxes, but ``rescale_`` also
+            rescales the box centers simultaneously.
+
+        Args:
+            scale_factor (Tuple[float, float]): factors for scaling box
+                shapes. The length should be 2.
+        """
+        pass
+
+    @abstractmethod
+    def is_inside(self,
+                  img_shape: Tuple[int, int],
+                  all_inside: bool = False,
+                  allowed_border: int = 0) -> BoolTensor:
+        """Find boxes inside the image.
+
+        Args:
+            img_shape (Tuple[int, int]): A tuple of image height and width.
+            all_inside (bool): Whether the boxes are all inside the image or
+                part inside the image. Defaults to False.
+            allowed_border (int): Boxes that extend beyond the image shape
+                boundary by more than ``allowed_border`` are considered
+                "outside" Defaults to 0.
+        Returns:
+            BoolTensor: A BoolTensor indicating whether the box is inside
+            the image. Assuming the original boxes have shape (m, n, box_dim),
+            the output has shape (m, n).
+        """
+        pass
+
+    @abstractmethod
+    def find_inside_points(self,
+                           points: Tensor,
+                           is_aligned: bool = False) -> BoolTensor:
+        """Find inside box points. Boxes dimension must be 2.
+
+        Args:
+            points (Tensor): Points coordinates. Has shape of (m, 2).
+            is_aligned (bool): Whether ``points`` has been aligned with boxes
+                or not. If True, the length of boxes and ``points`` should be
+                the same. Defaults to False.
+
+        Returns:
+            BoolTensor: A BoolTensor indicating whether a point is inside
+            boxes. Assuming the boxes has shape of (n, box_dim), if
+            ``is_aligned`` is False. The index has shape of (m, n). If
+            ``is_aligned`` is True, m should be equal to n and the index has
+            shape of (m, ).
+        """
+        pass
+
+    @abstractstaticmethod
+    def overlaps(boxes1: 'BaseBoxes',
+                 boxes2: 'BaseBoxes',
+                 mode: str = 'iou',
+                 is_aligned: bool = False,
+                 eps: float = 1e-6) -> Tensor:
+        """Calculate overlap between two set of boxes with their types
+        converted to the present box type.
+
+        Args:
+            boxes1 (:obj:`BaseBoxes`): BaseBoxes with shape of (m, box_dim)
+                or empty.
+            boxes2 (:obj:`BaseBoxes`): BaseBoxes with shape of (n, box_dim)
+                or empty.
+            mode (str): "iou" (intersection over union), "iof" (intersection
+                over foreground). Defaults to "iou".
+            is_aligned (bool): If True, then m and n must be equal. Defaults
+                to False.
+            eps (float): A value added to the denominator for numerical
+                stability. Defaults to 1e-6.
+
+        Returns:
+            Tensor: shape (m, n) if ``is_aligned`` is False else shape (m,)
+        """
+        pass
+
+    @abstractstaticmethod
+    def from_instance_masks(masks: MaskType) -> 'BaseBoxes':
+        """Create boxes from instance masks.
+
+        Args:
+            masks (:obj:`BitmapMasks` or :obj:`PolygonMasks`): BitmapMasks or
+                PolygonMasks instance with length of n.
+
+        Returns:
+            :obj:`BaseBoxes`: Converted boxes with shape of (n, box_dim).
+        """
+        pass
diff --git a/mmdetection/mmdet/structures/bbox/bbox_overlaps.py b/mmdetection/mmdet/structures/bbox/bbox_overlaps.py
new file mode 100644
index 00000000..8e3435d2
--- /dev/null
+++ b/mmdetection/mmdet/structures/bbox/bbox_overlaps.py
@@ -0,0 +1,199 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+
+
+def fp16_clamp(x, min=None, max=None):
+    if not x.is_cuda and x.dtype == torch.float16:
+        # clamp for cpu float16, tensor fp16 has no clamp implementation
+        return x.float().clamp(min, max).half()
+
+    return x.clamp(min, max)
+
+
+def bbox_overlaps(bboxes1, bboxes2, mode='iou', is_aligned=False, eps=1e-6):
+    """Calculate overlap between two set of bboxes.
+
+    FP16 Contributed by https://github.com/open-mmlab/mmdetection/pull/4889
+    Note:
+        Assume bboxes1 is M x 4, bboxes2 is N x 4, when mode is 'iou',
+        there are some new generated variable when calculating IOU
+        using bbox_overlaps function:
+
+        1) is_aligned is False
+            area1: M x 1
+            area2: N x 1
+            lt: M x N x 2
+            rb: M x N x 2
+            wh: M x N x 2
+            overlap: M x N x 1
+            union: M x N x 1
+            ious: M x N x 1
+
+            Total memory:
+                S = (9 x N x M + N + M) * 4 Byte,
+
+            When using FP16, we can reduce:
+                R = (9 x N x M + N + M) * 4 / 2 Byte
+                R large than (N + M) * 4 * 2 is always true when N and M >= 1.
+                Obviously, N + M <= N * M < 3 * N * M, when N >=2 and M >=2,
+                           N + 1 < 3 * N, when N or M is 1.
+
+            Given M = 40 (ground truth), N = 400000 (three anchor boxes
+            in per grid, FPN, R-CNNs),
+                R = 275 MB (one times)
+
+            A special case (dense detection), M = 512 (ground truth),
+                R = 3516 MB = 3.43 GB
+
+            When the batch size is B, reduce:
+                B x R
+
+            Therefore, CUDA memory runs out frequently.
+
+            Experiments on GeForce RTX 2080Ti (11019 MiB):
+
+            |   dtype   |   M   |   N   |   Use    |   Real   |   Ideal   |
+            |:----:|:----:|:----:|:----:|:----:|:----:|
+            |   FP32   |   512 | 400000 | 8020 MiB |   --   |   --   |
+            |   FP16   |   512 | 400000 |   4504 MiB | 3516 MiB | 3516 MiB |
+            |   FP32   |   40 | 400000 |   1540 MiB |   --   |   --   |
+            |   FP16   |   40 | 400000 |   1264 MiB |   276MiB   | 275 MiB |
+
+        2) is_aligned is True
+            area1: N x 1
+            area2: N x 1
+            lt: N x 2
+            rb: N x 2
+            wh: N x 2
+            overlap: N x 1
+            union: N x 1
+            ious: N x 1
+
+            Total memory:
+                S = 11 x N * 4 Byte
+
+            When using FP16, we can reduce:
+                R = 11 x N * 4 / 2 Byte
+
+        So do the 'giou' (large than 'iou').
+
+        Time-wise, FP16 is generally faster than FP32.
+
+        When gpu_assign_thr is not -1, it takes more time on cpu
+        but not reduce memory.
+        There, we can reduce half the memory and keep the speed.
+
+    If ``is_aligned`` is ``False``, then calculate the overlaps between each
+    bbox of bboxes1 and bboxes2, otherwise the overlaps between each aligned
+    pair of bboxes1 and bboxes2.
+
+    Args:
+        bboxes1 (Tensor): shape (B, m, 4) in  format or empty.
+        bboxes2 (Tensor): shape (B, n, 4) in  format or empty.
+            B indicates the batch dim, in shape (B1, B2, ..., Bn).
+            If ``is_aligned`` is ``True``, then m and n must be equal.
+        mode (str): "iou" (intersection over union), "iof" (intersection over
+            foreground) or "giou" (generalized intersection over union).
+            Default "iou".
+        is_aligned (bool, optional): If True, then m and n must be equal.
+            Default False.
+        eps (float, optional): A value added to the denominator for numerical
+            stability. Default 1e-6.
+
+    Returns:
+        Tensor: shape (m, n) if ``is_aligned`` is False else shape (m,)
+
+    Example:
+        >>> bboxes1 = torch.FloatTensor([
+        >>>     [0, 0, 10, 10],
+        >>>     [10, 10, 20, 20],
+        >>>     [32, 32, 38, 42],
+        >>> ])
+        >>> bboxes2 = torch.FloatTensor([
+        >>>     [0, 0, 10, 20],
+        >>>     [0, 10, 10, 19],
+        >>>     [10, 10, 20, 20],
+        >>> ])
+        >>> overlaps = bbox_overlaps(bboxes1, bboxes2)
+        >>> assert overlaps.shape == (3, 3)
+        >>> overlaps = bbox_overlaps(bboxes1, bboxes2, is_aligned=True)
+        >>> assert overlaps.shape == (3, )
+
+    Example:
+        >>> empty = torch.empty(0, 4)
+        >>> nonempty = torch.FloatTensor([[0, 0, 10, 9]])
+        >>> assert tuple(bbox_overlaps(empty, nonempty).shape) == (0, 1)
+        >>> assert tuple(bbox_overlaps(nonempty, empty).shape) == (1, 0)
+        >>> assert tuple(bbox_overlaps(empty, empty).shape) == (0, 0)
+    """
+
+    assert mode in ['iou', 'iof', 'giou'], f'Unsupported mode {mode}'
+    # Either the boxes are empty or the length of boxes' last dimension is 4
+    assert (bboxes1.size(-1) == 4 or bboxes1.size(0) == 0)
+    assert (bboxes2.size(-1) == 4 or bboxes2.size(0) == 0)
+
+    # Batch dim must be the same
+    # Batch dim: (B1, B2, ... Bn)
+    assert bboxes1.shape[:-2] == bboxes2.shape[:-2]
+    batch_shape = bboxes1.shape[:-2]
+
+    rows = bboxes1.size(-2)
+    cols = bboxes2.size(-2)
+    if is_aligned:
+        assert rows == cols
+
+    if rows * cols == 0:
+        if is_aligned:
+            return bboxes1.new(batch_shape + (rows, ))
+        else:
+            return bboxes1.new(batch_shape + (rows, cols))
+
+    area1 = (bboxes1[..., 2] - bboxes1[..., 0]) * (
+        bboxes1[..., 3] - bboxes1[..., 1])
+    area2 = (bboxes2[..., 2] - bboxes2[..., 0]) * (
+        bboxes2[..., 3] - bboxes2[..., 1])
+
+    if is_aligned:
+        lt = torch.max(bboxes1[..., :2], bboxes2[..., :2])  # [B, rows, 2]
+        rb = torch.min(bboxes1[..., 2:], bboxes2[..., 2:])  # [B, rows, 2]
+
+        wh = fp16_clamp(rb - lt, min=0)
+        overlap = wh[..., 0] * wh[..., 1]
+
+        if mode in ['iou', 'giou']:
+            union = area1 + area2 - overlap
+        else:
+            union = area1
+        if mode == 'giou':
+            enclosed_lt = torch.min(bboxes1[..., :2], bboxes2[..., :2])
+            enclosed_rb = torch.max(bboxes1[..., 2:], bboxes2[..., 2:])
+    else:
+        lt = torch.max(bboxes1[..., :, None, :2],
+                       bboxes2[..., None, :, :2])  # [B, rows, cols, 2]
+        rb = torch.min(bboxes1[..., :, None, 2:],
+                       bboxes2[..., None, :, 2:])  # [B, rows, cols, 2]
+
+        wh = fp16_clamp(rb - lt, min=0)
+        overlap = wh[..., 0] * wh[..., 1]
+
+        if mode in ['iou', 'giou']:
+            union = area1[..., None] + area2[..., None, :] - overlap
+        else:
+            union = area1[..., None]
+        if mode == 'giou':
+            enclosed_lt = torch.min(bboxes1[..., :, None, :2],
+                                    bboxes2[..., None, :, :2])
+            enclosed_rb = torch.max(bboxes1[..., :, None, 2:],
+                                    bboxes2[..., None, :, 2:])
+
+    eps = union.new_tensor([eps])
+    union = torch.max(union, eps)
+    ious = overlap / union
+    if mode in ['iou', 'iof']:
+        return ious
+    # calculate gious
+    enclose_wh = fp16_clamp(enclosed_rb - enclosed_lt, min=0)
+    enclose_area = enclose_wh[..., 0] * enclose_wh[..., 1]
+    enclose_area = torch.max(enclose_area, eps)
+    gious = ious - (enclose_area - union) / enclose_area
+    return gious
diff --git a/mmdetection/mmdet/structures/bbox/box_type.py b/mmdetection/mmdet/structures/bbox/box_type.py
new file mode 100644
index 00000000..c7eb5494
--- /dev/null
+++ b/mmdetection/mmdet/structures/bbox/box_type.py
@@ -0,0 +1,296 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Callable, Optional, Tuple, Type, Union
+
+import numpy as np
+import torch
+from torch import Tensor
+
+from .base_boxes import BaseBoxes
+
+BoxType = Union[np.ndarray, Tensor, BaseBoxes]
+
+box_types: dict = {}
+_box_type_to_name: dict = {}
+box_converters: dict = {}
+
+
+def _register_box(name: str, box_type: Type, force: bool = False) -> None:
+    """Register a box type.
+
+    Args:
+        name (str): The name of box type.
+        box_type (type): Box mode class to be registered.
+        force (bool): Whether to override an existing class with the same
+            name. Defaults to False.
+    """
+    assert issubclass(box_type, BaseBoxes)
+    name = name.lower()
+
+    if not force and (name in box_types or box_type in _box_type_to_name):
+        raise KeyError(f'box type {name} has been registered')
+    elif name in box_types:
+        _box_type = box_types.pop(name)
+        _box_type_to_name.pop(_box_type)
+    elif box_type in _box_type_to_name:
+        _name = _box_type_to_name.pop(box_type)
+        box_types.pop(_name)
+
+    box_types[name] = box_type
+    _box_type_to_name[box_type] = name
+
+
+def register_box(name: str,
+                 box_type: Type = None,
+                 force: bool = False) -> Union[Type, Callable]:
+    """Register a box type.
+
+    A record will be added to ``bbox_types``, whose key is the box type name
+    and value is the box type itself. Simultaneously, a reverse dictionary
+    ``_box_type_to_name`` will be updated. It can be used as a decorator or
+    a normal function.
+
+    Args:
+        name (str): The name of box type.
+        bbox_type (type, Optional): Box type class to be registered.
+            Defaults to None.
+        force (bool): Whether to override the existing box type with the same
+            name. Defaults to False.
+
+    Examples:
+        >>> from mmdet.structures.bbox import register_box
+        >>> from mmdet.structures.bbox import BaseBoxes
+
+        >>> # as a decorator
+        >>> @register_box('hbox')
+        >>> class HorizontalBoxes(BaseBoxes):
+        >>>     pass
+
+        >>> # as a normal function
+        >>> class RotatedBoxes(BaseBoxes):
+        >>>     pass
+        >>> register_box('rbox', RotatedBoxes)
+    """
+    if not isinstance(force, bool):
+        raise TypeError(f'force must be a boolean, but got {type(force)}')
+
+    # use it as a normal method: register_box(name, box_type=BoxCls)
+    if box_type is not None:
+        _register_box(name=name, box_type=box_type, force=force)
+        return box_type
+
+    # use it as a decorator: @register_box(name)
+    def _register(cls):
+        _register_box(name=name, box_type=cls, force=force)
+        return cls
+
+    return _register
+
+
+def _register_box_converter(src_type: Union[str, type],
+                            dst_type: Union[str, type],
+                            converter: Callable,
+                            force: bool = False) -> None:
+    """Register a box converter.
+
+    Args:
+        src_type (str or type): source box type name or class.
+        dst_type (str or type): destination box type name or class.
+        converter (Callable): Convert function.
+        force (bool): Whether to override the existing box type with the same
+            name. Defaults to False.
+    """
+    assert callable(converter)
+    src_type_name, _ = get_box_type(src_type)
+    dst_type_name, _ = get_box_type(dst_type)
+
+    converter_name = src_type_name + '2' + dst_type_name
+    if not force and converter_name in box_converters:
+        raise KeyError(f'The box converter from {src_type_name} to '
+                       f'{dst_type_name} has been registered.')
+
+    box_converters[converter_name] = converter
+
+
+def register_box_converter(src_type: Union[str, type],
+                           dst_type: Union[str, type],
+                           converter: Optional[Callable] = None,
+                           force: bool = False) -> Callable:
+    """Register a box converter.
+
+    A record will be added to ``box_converter``, whose key is
+    '{src_type_name}2{dst_type_name}' and value is the convert function.
+    It can be used as a decorator or a normal function.
+
+    Args:
+        src_type (str or type): source box type name or class.
+        dst_type (str or type): destination box type name or class.
+        converter (Callable): Convert function. Defaults to None.
+        force (bool): Whether to override the existing box type with the same
+            name. Defaults to False.
+
+    Examples:
+        >>> from mmdet.structures.bbox import register_box_converter
+        >>> # as a decorator
+        >>> @register_box_converter('hbox', 'rbox')
+        >>> def converter_A(boxes):
+        >>>     pass
+
+        >>> # as a normal function
+        >>> def converter_B(boxes):
+        >>>     pass
+        >>> register_box_converter('rbox', 'hbox', converter_B)
+    """
+    if not isinstance(force, bool):
+        raise TypeError(f'force must be a boolean, but got {type(force)}')
+
+    # use it as a normal method:
+    # register_box_converter(src_type, dst_type, converter=Func)
+    if converter is not None:
+        _register_box_converter(
+            src_type=src_type,
+            dst_type=dst_type,
+            converter=converter,
+            force=force)
+        return converter
+
+    # use it as a decorator: @register_box_converter(name)
+    def _register(func):
+        _register_box_converter(
+            src_type=src_type, dst_type=dst_type, converter=func, force=force)
+        return func
+
+    return _register
+
+
+def get_box_type(box_type: Union[str, type]) -> Tuple[str, type]:
+    """get both box type name and class.
+
+    Args:
+        box_type (str or type): Single box type name or class.
+
+    Returns:
+        Tuple[str, type]: A tuple of box type name and class.
+    """
+    if isinstance(box_type, str):
+        type_name = box_type.lower()
+        assert type_name in box_types, \
+            f"Box type {type_name} hasn't been registered in box_types."
+        type_cls = box_types[type_name]
+    elif issubclass(box_type, BaseBoxes):
+        assert box_type in _box_type_to_name, \
+            f"Box type {box_type} hasn't been registered in box_types."
+        type_name = _box_type_to_name[box_type]
+        type_cls = box_type
+    else:
+        raise KeyError('box_type must be a str or class inheriting from '
+                       f'BaseBoxes, but got {type(box_type)}.')
+    return type_name, type_cls
+
+
+def convert_box_type(boxes: BoxType,
+                     *,
+                     src_type: Union[str, type] = None,
+                     dst_type: Union[str, type] = None) -> BoxType:
+    """Convert boxes from source type to destination type.
+
+    If ``boxes`` is a instance of BaseBoxes, the ``src_type`` will be set
+    as the type of ``boxes``.
+
+    Args:
+        boxes (np.ndarray or Tensor or :obj:`BaseBoxes`): boxes need to
+            convert.
+        src_type (str or type, Optional): source box type. Defaults to None.
+        dst_type (str or type, Optional): destination box type. Defaults to
+            None.
+
+    Returns:
+        Union[np.ndarray, Tensor, :obj:`BaseBoxes`]: Converted boxes. It's type
+        is consistent with the input's type.
+    """
+    assert dst_type is not None
+    dst_type_name, dst_type_cls = get_box_type(dst_type)
+
+    is_box_cls = False
+    is_numpy = False
+    if isinstance(boxes, BaseBoxes):
+        src_type_name, _ = get_box_type(type(boxes))
+        is_box_cls = True
+    elif isinstance(boxes, (Tensor, np.ndarray)):
+        assert src_type is not None
+        src_type_name, _ = get_box_type(src_type)
+        if isinstance(boxes, np.ndarray):
+            is_numpy = True
+    else:
+        raise TypeError('boxes must be a instance of BaseBoxes, Tensor or '
+                        f'ndarray, but get {type(boxes)}.')
+
+    if src_type_name == dst_type_name:
+        return boxes
+
+    converter_name = src_type_name + '2' + dst_type_name
+    assert converter_name in box_converters, \
+        "Convert function hasn't been registered in box_converters."
+    converter = box_converters[converter_name]
+
+    if is_box_cls:
+        boxes = converter(boxes.tensor)
+        return dst_type_cls(boxes)
+    elif is_numpy:
+        boxes = converter(torch.from_numpy(boxes))
+        return boxes.numpy()
+    else:
+        return converter(boxes)
+
+
+def autocast_box_type(dst_box_type='hbox') -> Callable:
+    """A decorator which automatically casts results['gt_bboxes'] to the
+    destination box type.
+
+    It commenly used in mmdet.datasets.transforms to make the transforms up-
+    compatible with the np.ndarray type of results['gt_bboxes'].
+
+    The speed of processing of np.ndarray and BaseBoxes data are the same:
+
+    - np.ndarray: 0.0509 img/s
+    - BaseBoxes: 0.0551 img/s
+
+    Args:
+        dst_box_type (str): Destination box type.
+    """
+    _, box_type_cls = get_box_type(dst_box_type)
+
+    def decorator(func: Callable) -> Callable:
+
+        def wrapper(self, results: dict, *args, **kwargs) -> dict:
+            if ('gt_bboxes' not in results
+                    or isinstance(results['gt_bboxes'], BaseBoxes)):
+                return func(self, results)
+            elif isinstance(results['gt_bboxes'], np.ndarray):
+                results['gt_bboxes'] = box_type_cls(
+                    results['gt_bboxes'], clone=False)
+                if 'mix_results' in results:
+                    for res in results['mix_results']:
+                        if isinstance(res['gt_bboxes'], np.ndarray):
+                            res['gt_bboxes'] = box_type_cls(
+                                res['gt_bboxes'], clone=False)
+
+                _results = func(self, results, *args, **kwargs)
+
+                # In some cases, the function will process gt_bboxes in-place
+                # Simultaneously convert inputting and outputting gt_bboxes
+                # back to np.ndarray
+                if isinstance(_results, dict) and 'gt_bboxes' in _results:
+                    if isinstance(_results['gt_bboxes'], BaseBoxes):
+                        _results['gt_bboxes'] = _results['gt_bboxes'].numpy()
+                if isinstance(results['gt_bboxes'], BaseBoxes):
+                    results['gt_bboxes'] = results['gt_bboxes'].numpy()
+                return _results
+            else:
+                raise TypeError(
+                    "auto_box_type requires results['gt_bboxes'] to "
+                    'be BaseBoxes or np.ndarray, but got '
+                    f"{type(results['gt_bboxes'])}")
+
+        return wrapper
+
+    return decorator
diff --git a/mmdetection/mmdet/structures/bbox/horizontal_boxes.py b/mmdetection/mmdet/structures/bbox/horizontal_boxes.py
new file mode 100644
index 00000000..b3a78518
--- /dev/null
+++ b/mmdetection/mmdet/structures/bbox/horizontal_boxes.py
@@ -0,0 +1,432 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Tuple, TypeVar, Union
+
+import cv2
+import numpy as np
+import torch
+from torch import BoolTensor, Tensor
+
+from mmdet.structures.mask.structures import BitmapMasks, PolygonMasks
+from .base_boxes import BaseBoxes
+from .bbox_overlaps import bbox_overlaps
+from .box_type import register_box
+
+T = TypeVar('T')
+DeviceType = Union[str, torch.device]
+MaskType = Union[BitmapMasks, PolygonMasks]
+
+
+@register_box(name='hbox')
+class HorizontalBoxes(BaseBoxes):
+    """The horizontal box class used in MMDetection by default.
+
+    The ``box_dim`` of ``HorizontalBoxes`` is 4, which means the length of
+    the last dimension of the data should be 4. Two modes of box data are
+    supported in ``HorizontalBoxes``:
+
+    - 'xyxy': Each row of data indicates (x1, y1, x2, y2), which are the
+      coordinates of the left-top and right-bottom points.
+    - 'cxcywh': Each row of data indicates (x, y, w, h), where (x, y) are the
+      coordinates of the box centers and (w, h) are the width and height.
+
+    ``HorizontalBoxes`` only restores 'xyxy' mode of data. If the the data is
+    in 'cxcywh' mode, users need to input ``in_mode='cxcywh'`` and The code
+    will convert the 'cxcywh' data to 'xyxy' automatically.
+
+    Args:
+        data (Tensor or np.ndarray or Sequence): The box data with shape of
+            (..., 4).
+        dtype (torch.dtype, Optional): data type of boxes. Defaults to None.
+        device (str or torch.device, Optional): device of boxes.
+            Default to None.
+        clone (bool): Whether clone ``boxes`` or not. Defaults to True.
+        mode (str, Optional): the mode of boxes. If it is 'cxcywh', the
+            `data` will be converted to 'xyxy' mode. Defaults to None.
+    """
+
+    box_dim: int = 4
+
+    def __init__(self,
+                 data: Union[Tensor, np.ndarray],
+                 dtype: torch.dtype = None,
+                 device: DeviceType = None,
+                 clone: bool = True,
+                 in_mode: Optional[str] = None) -> None:
+        super().__init__(data=data, dtype=dtype, device=device, clone=clone)
+        if isinstance(in_mode, str):
+            if in_mode not in ('xyxy', 'cxcywh'):
+                raise ValueError(f'Get invalid mode {in_mode}.')
+            if in_mode == 'cxcywh':
+                self.tensor = self.cxcywh_to_xyxy(self.tensor)
+
+    @staticmethod
+    def cxcywh_to_xyxy(boxes: Tensor) -> Tensor:
+        """Convert box coordinates from (cx, cy, w, h) to (x1, y1, x2, y2).
+
+        Args:
+            boxes (Tensor): cxcywh boxes tensor with shape of (..., 4).
+
+        Returns:
+            Tensor: xyxy boxes tensor with shape of (..., 4).
+        """
+        ctr, wh = boxes.split((2, 2), dim=-1)
+        return torch.cat([(ctr - wh / 2), (ctr + wh / 2)], dim=-1)
+
+    @staticmethod
+    def xyxy_to_cxcywh(boxes: Tensor) -> Tensor:
+        """Convert box coordinates from (x1, y1, x2, y2) to (cx, cy, w, h).
+
+        Args:
+            boxes (Tensor): xyxy boxes tensor with shape of (..., 4).
+
+        Returns:
+            Tensor: cxcywh boxes tensor with shape of (..., 4).
+        """
+        xy1, xy2 = boxes.split((2, 2), dim=-1)
+        return torch.cat([(xy2 + xy1) / 2, (xy2 - xy1)], dim=-1)
+
+    @property
+    def cxcywh(self) -> Tensor:
+        """Return a tensor representing the cxcywh boxes."""
+        return self.xyxy_to_cxcywh(self.tensor)
+
+    @property
+    def centers(self) -> Tensor:
+        """Return a tensor representing the centers of boxes."""
+        boxes = self.tensor
+        return (boxes[..., :2] + boxes[..., 2:]) / 2
+
+    @property
+    def areas(self) -> Tensor:
+        """Return a tensor representing the areas of boxes."""
+        boxes = self.tensor
+        return (boxes[..., 2] - boxes[..., 0]) * (
+            boxes[..., 3] - boxes[..., 1])
+
+    @property
+    def widths(self) -> Tensor:
+        """Return a tensor representing the widths of boxes."""
+        boxes = self.tensor
+        return boxes[..., 2] - boxes[..., 0]
+
+    @property
+    def heights(self) -> Tensor:
+        """Return a tensor representing the heights of boxes."""
+        boxes = self.tensor
+        return boxes[..., 3] - boxes[..., 1]
+
+    def flip_(self,
+              img_shape: Tuple[int, int],
+              direction: str = 'horizontal') -> None:
+        """Flip boxes horizontally or vertically in-place.
+
+        Args:
+            img_shape (Tuple[int, int]): A tuple of image height and width.
+            direction (str): Flip direction, options are "horizontal",
+                "vertical" and "diagonal". Defaults to "horizontal"
+        """
+        assert direction in ['horizontal', 'vertical', 'diagonal']
+        flipped = self.tensor
+        boxes = flipped.clone()
+        if direction == 'horizontal':
+            flipped[..., 0] = img_shape[1] - boxes[..., 2]
+            flipped[..., 2] = img_shape[1] - boxes[..., 0]
+        elif direction == 'vertical':
+            flipped[..., 1] = img_shape[0] - boxes[..., 3]
+            flipped[..., 3] = img_shape[0] - boxes[..., 1]
+        else:
+            flipped[..., 0] = img_shape[1] - boxes[..., 2]
+            flipped[..., 1] = img_shape[0] - boxes[..., 3]
+            flipped[..., 2] = img_shape[1] - boxes[..., 0]
+            flipped[..., 3] = img_shape[0] - boxes[..., 1]
+
+    def translate_(self, distances: Tuple[float, float]) -> None:
+        """Translate boxes in-place.
+
+        Args:
+            distances (Tuple[float, float]): translate distances. The first
+                is horizontal distance and the second is vertical distance.
+        """
+        boxes = self.tensor
+        assert len(distances) == 2
+        self.tensor = boxes + boxes.new_tensor(distances).repeat(2)
+
+    def clip_(self, img_shape: Tuple[int, int]) -> None:
+        """Clip boxes according to the image shape in-place.
+
+        Args:
+            img_shape (Tuple[int, int]): A tuple of image height and width.
+        """
+        boxes = self.tensor
+        boxes[..., 0::2] = boxes[..., 0::2].clamp(0, img_shape[1])
+        boxes[..., 1::2] = boxes[..., 1::2].clamp(0, img_shape[0])
+
+    def rotate_(self, center: Tuple[float, float], angle: float) -> None:
+        """Rotate all boxes in-place.
+
+        Args:
+            center (Tuple[float, float]): Rotation origin.
+            angle (float): Rotation angle represented in degrees. Positive
+                values mean clockwise rotation.
+        """
+        boxes = self.tensor
+        rotation_matrix = boxes.new_tensor(
+            cv2.getRotationMatrix2D(center, -angle, 1))
+
+        corners = self.hbox2corner(boxes)
+        corners = torch.cat(
+            [corners, corners.new_ones(*corners.shape[:-1], 1)], dim=-1)
+        corners_T = torch.transpose(corners, -1, -2)
+        corners_T = torch.matmul(rotation_matrix, corners_T)
+        corners = torch.transpose(corners_T, -1, -2)
+        self.tensor = self.corner2hbox(corners)
+
+    def project_(self, homography_matrix: Union[Tensor, np.ndarray]) -> None:
+        """Geometric transformat boxes in-place.
+
+        Args:
+            homography_matrix (Tensor or np.ndarray]):
+                Shape (3, 3) for geometric transformation.
+        """
+        boxes = self.tensor
+        if isinstance(homography_matrix, np.ndarray):
+            homography_matrix = boxes.new_tensor(homography_matrix)
+        corners = self.hbox2corner(boxes)
+        corners = torch.cat(
+            [corners, corners.new_ones(*corners.shape[:-1], 1)], dim=-1)
+        corners_T = torch.transpose(corners, -1, -2)
+        corners_T = torch.matmul(homography_matrix, corners_T)
+        corners = torch.transpose(corners_T, -1, -2)
+        # Convert to homogeneous coordinates by normalization
+        corners = corners[..., :2] / corners[..., 2:3]
+        self.tensor = self.corner2hbox(corners)
+
+    @staticmethod
+    def hbox2corner(boxes: Tensor) -> Tensor:
+        """Convert box coordinates from (x1, y1, x2, y2) to corners ((x1, y1),
+        (x2, y1), (x1, y2), (x2, y2)).
+
+        Args:
+            boxes (Tensor): Horizontal box tensor with shape of (..., 4).
+
+        Returns:
+            Tensor: Corner tensor with shape of (..., 4, 2).
+        """
+        x1, y1, x2, y2 = torch.split(boxes, 1, dim=-1)
+        corners = torch.cat([x1, y1, x2, y1, x1, y2, x2, y2], dim=-1)
+        return corners.reshape(*corners.shape[:-1], 4, 2)
+
+    @staticmethod
+    def corner2hbox(corners: Tensor) -> Tensor:
+        """Convert box coordinates from corners ((x1, y1), (x2, y1), (x1, y2),
+        (x2, y2)) to (x1, y1, x2, y2).
+
+        Args:
+            corners (Tensor): Corner tensor with shape of (..., 4, 2).
+
+        Returns:
+            Tensor: Horizontal box tensor with shape of (..., 4).
+        """
+        if corners.numel() == 0:
+            return corners.new_zeros((0, 4))
+        min_xy = corners.min(dim=-2)[0]
+        max_xy = corners.max(dim=-2)[0]
+        return torch.cat([min_xy, max_xy], dim=-1)
+
+    def rescale_(self, scale_factor: Tuple[float, float]) -> None:
+        """Rescale boxes w.r.t. rescale_factor in-place.
+
+        Note:
+            Both ``rescale_`` and ``resize_`` will enlarge or shrink boxes
+            w.r.t ``scale_facotr``. The difference is that ``resize_`` only
+            changes the width and the height of boxes, but ``rescale_`` also
+            rescales the box centers simultaneously.
+
+        Args:
+            scale_factor (Tuple[float, float]): factors for scaling boxes.
+                The length should be 2.
+        """
+        boxes = self.tensor
+        assert len(scale_factor) == 2
+        scale_factor = boxes.new_tensor(scale_factor).repeat(2)
+        self.tensor = boxes * scale_factor
+
+    def resize_(self, scale_factor: Tuple[float, float]) -> None:
+        """Resize the box width and height w.r.t scale_factor in-place.
+
+        Note:
+            Both ``rescale_`` and ``resize_`` will enlarge or shrink boxes
+            w.r.t ``scale_facotr``. The difference is that ``resize_`` only
+            changes the width and the height of boxes, but ``rescale_`` also
+            rescales the box centers simultaneously.
+
+        Args:
+            scale_factor (Tuple[float, float]): factors for scaling box
+                shapes. The length should be 2.
+        """
+        boxes = self.tensor
+        assert len(scale_factor) == 2
+        ctrs = (boxes[..., 2:] + boxes[..., :2]) / 2
+        wh = boxes[..., 2:] - boxes[..., :2]
+        scale_factor = boxes.new_tensor(scale_factor)
+        wh = wh * scale_factor
+        xy1 = ctrs - 0.5 * wh
+        xy2 = ctrs + 0.5 * wh
+        self.tensor = torch.cat([xy1, xy2], dim=-1)
+
+    def is_inside(self,
+                  img_shape: Tuple[int, int],
+                  all_inside: bool = False,
+                  allowed_border: int = 0) -> BoolTensor:
+        """Find boxes inside the image.
+
+        Args:
+            img_shape (Tuple[int, int]): A tuple of image height and width.
+            all_inside (bool): Whether the boxes are all inside the image or
+                part inside the image. Defaults to False.
+            allowed_border (int): Boxes that extend beyond the image shape
+                boundary by more than ``allowed_border`` are considered
+                "outside" Defaults to 0.
+        Returns:
+            BoolTensor: A BoolTensor indicating whether the box is inside
+            the image. Assuming the original boxes have shape (m, n, 4),
+            the output has shape (m, n).
+        """
+        img_h, img_w = img_shape
+        boxes = self.tensor
+        if all_inside:
+            return (boxes[:, 0] >= -allowed_border) & \
+                (boxes[:, 1] >= -allowed_border) & \
+                (boxes[:, 2] < img_w + allowed_border) & \
+                (boxes[:, 3] < img_h + allowed_border)
+        else:
+            return (boxes[..., 0] < img_w + allowed_border) & \
+                (boxes[..., 1] < img_h + allowed_border) & \
+                (boxes[..., 2] > -allowed_border) & \
+                (boxes[..., 3] > -allowed_border)
+
+    def find_inside_points(self,
+                           points: Tensor,
+                           is_aligned: bool = False) -> BoolTensor:
+        """Find inside box points. Boxes dimension must be 2.
+
+        Args:
+            points (Tensor): Points coordinates. Has shape of (m, 2).
+            is_aligned (bool): Whether ``points`` has been aligned with boxes
+                or not. If True, the length of boxes and ``points`` should be
+                the same. Defaults to False.
+
+        Returns:
+            BoolTensor: A BoolTensor indicating whether a point is inside
+            boxes. Assuming the boxes has shape of (n, 4), if ``is_aligned``
+            is False. The index has shape of (m, n). If ``is_aligned`` is
+            True, m should be equal to n and the index has shape of (m, ).
+        """
+        boxes = self.tensor
+        assert boxes.dim() == 2, 'boxes dimension must be 2.'
+
+        if not is_aligned:
+            boxes = boxes[None, :, :]
+            points = points[:, None, :]
+        else:
+            assert boxes.size(0) == points.size(0)
+
+        x_min, y_min, x_max, y_max = boxes.unbind(dim=-1)
+        return (points[..., 0] >= x_min) & (points[..., 0] <= x_max) & \
+            (points[..., 1] >= y_min) & (points[..., 1] <= y_max)
+
+    def create_masks(self, img_shape: Tuple[int, int]) -> BitmapMasks:
+        """
+        Args:
+            img_shape (Tuple[int, int]): A tuple of image height and width.
+
+        Returns:
+            :obj:`BitmapMasks`: Converted masks
+        """
+        img_h, img_w = img_shape
+        boxes = self.tensor
+
+        xmin, ymin = boxes[:, 0:1], boxes[:, 1:2]
+        xmax, ymax = boxes[:, 2:3], boxes[:, 3:4]
+        gt_masks = np.zeros((len(boxes), img_h, img_w), dtype=np.uint8)
+        for i in range(len(boxes)):
+            gt_masks[i,
+                     int(ymin[i]):int(ymax[i]),
+                     int(xmin[i]):int(xmax[i])] = 1
+        return BitmapMasks(gt_masks, img_h, img_w)
+
+    @staticmethod
+    def overlaps(boxes1: BaseBoxes,
+                 boxes2: BaseBoxes,
+                 mode: str = 'iou',
+                 is_aligned: bool = False,
+                 eps: float = 1e-6) -> Tensor:
+        """Calculate overlap between two set of boxes with their types
+        converted to ``HorizontalBoxes``.
+
+        Args:
+            boxes1 (:obj:`BaseBoxes`): BaseBoxes with shape of (m, box_dim)
+                or empty.
+            boxes2 (:obj:`BaseBoxes`): BaseBoxes with shape of (n, box_dim)
+                or empty.
+            mode (str): "iou" (intersection over union), "iof" (intersection
+                over foreground). Defaults to "iou".
+            is_aligned (bool): If True, then m and n must be equal. Defaults
+                to False.
+            eps (float): A value added to the denominator for numerical
+                stability. Defaults to 1e-6.
+
+        Returns:
+            Tensor: shape (m, n) if ``is_aligned`` is False else shape (m,)
+        """
+        boxes1 = boxes1.convert_to('hbox')
+        boxes2 = boxes2.convert_to('hbox')
+        return bbox_overlaps(
+            boxes1.tensor,
+            boxes2.tensor,
+            mode=mode,
+            is_aligned=is_aligned,
+            eps=eps)
+
+    @staticmethod
+    def from_instance_masks(masks: MaskType) -> 'HorizontalBoxes':
+        """Create horizontal boxes from instance masks.
+
+        Args:
+            masks (:obj:`BitmapMasks` or :obj:`PolygonMasks`): BitmapMasks or
+                PolygonMasks instance with length of n.
+
+        Returns:
+            :obj:`HorizontalBoxes`: Converted boxes with shape of (n, 4).
+        """
+        num_masks = len(masks)
+        boxes = np.zeros((num_masks, 4), dtype=np.float32)
+        if isinstance(masks, BitmapMasks):
+            x_any = masks.masks.any(axis=1)
+            y_any = masks.masks.any(axis=2)
+            for idx in range(num_masks):
+                x = np.where(x_any[idx, :])[0]
+                y = np.where(y_any[idx, :])[0]
+                if len(x) > 0 and len(y) > 0:
+                    # use +1 for x_max and y_max so that the right and bottom
+                    # boundary of instance masks are fully included by the box
+                    boxes[idx, :] = np.array(
+                        [x[0], y[0], x[-1] + 1, y[-1] + 1], dtype=np.float32)
+        elif isinstance(masks, PolygonMasks):
+            for idx, poly_per_obj in enumerate(masks.masks):
+                # simply use a number that is big enough for comparison with
+                # coordinates
+                xy_min = np.array([masks.width * 2, masks.height * 2],
+                                  dtype=np.float32)
+                xy_max = np.zeros(2, dtype=np.float32)
+                for p in poly_per_obj:
+                    xy = np.array(p).reshape(-1, 2).astype(np.float32)
+                    xy_min = np.minimum(xy_min, np.min(xy, axis=0))
+                    xy_max = np.maximum(xy_max, np.max(xy, axis=0))
+                boxes[idx, :2] = xy_min
+                boxes[idx, 2:] = xy_max
+        else:
+            raise TypeError(
+                '`masks` must be `BitmapMasks`  or `PolygonMasks`, '
+                f'but got {type(masks)}.')
+        return HorizontalBoxes(boxes)
diff --git a/mmdetection/mmdet/structures/bbox/transforms.py b/mmdetection/mmdet/structures/bbox/transforms.py
new file mode 100644
index 00000000..287e6aa6
--- /dev/null
+++ b/mmdetection/mmdet/structures/bbox/transforms.py
@@ -0,0 +1,498 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Sequence, Tuple, Union
+
+import numpy as np
+import torch
+from torch import Tensor
+
+from mmdet.structures.bbox import BaseBoxes
+
+
+def find_inside_bboxes(bboxes: Tensor, img_h: int, img_w: int) -> Tensor:
+    """Find bboxes as long as a part of bboxes is inside the image.
+
+    Args:
+        bboxes (Tensor): Shape (N, 4).
+        img_h (int): Image height.
+        img_w (int): Image width.
+
+    Returns:
+        Tensor: Index of the remaining bboxes.
+    """
+    inside_inds = (bboxes[:, 0] < img_w) & (bboxes[:, 2] > 0) \
+        & (bboxes[:, 1] < img_h) & (bboxes[:, 3] > 0)
+    return inside_inds
+
+
+def bbox_flip(bboxes: Tensor,
+              img_shape: Tuple[int],
+              direction: str = 'horizontal') -> Tensor:
+    """Flip bboxes horizontally or vertically.
+
+    Args:
+        bboxes (Tensor): Shape (..., 4*k)
+        img_shape (Tuple[int]): Image shape.
+        direction (str): Flip direction, options are "horizontal", "vertical",
+            "diagonal". Default: "horizontal"
+
+    Returns:
+        Tensor: Flipped bboxes.
+    """
+    assert bboxes.shape[-1] % 4 == 0
+    assert direction in ['horizontal', 'vertical', 'diagonal']
+    flipped = bboxes.clone()
+    if direction == 'horizontal':
+        flipped[..., 0::4] = img_shape[1] - bboxes[..., 2::4]
+        flipped[..., 2::4] = img_shape[1] - bboxes[..., 0::4]
+    elif direction == 'vertical':
+        flipped[..., 1::4] = img_shape[0] - bboxes[..., 3::4]
+        flipped[..., 3::4] = img_shape[0] - bboxes[..., 1::4]
+    else:
+        flipped[..., 0::4] = img_shape[1] - bboxes[..., 2::4]
+        flipped[..., 1::4] = img_shape[0] - bboxes[..., 3::4]
+        flipped[..., 2::4] = img_shape[1] - bboxes[..., 0::4]
+        flipped[..., 3::4] = img_shape[0] - bboxes[..., 1::4]
+    return flipped
+
+
+def bbox_mapping(bboxes: Tensor,
+                 img_shape: Tuple[int],
+                 scale_factor: Union[float, Tuple[float]],
+                 flip: bool,
+                 flip_direction: str = 'horizontal') -> Tensor:
+    """Map bboxes from the original image scale to testing scale."""
+    new_bboxes = bboxes * bboxes.new_tensor(scale_factor)
+    if flip:
+        new_bboxes = bbox_flip(new_bboxes, img_shape, flip_direction)
+    return new_bboxes
+
+
+def bbox_mapping_back(bboxes: Tensor,
+                      img_shape: Tuple[int],
+                      scale_factor: Union[float, Tuple[float]],
+                      flip: bool,
+                      flip_direction: str = 'horizontal') -> Tensor:
+    """Map bboxes from testing scale to original image scale."""
+    new_bboxes = bbox_flip(bboxes, img_shape,
+                           flip_direction) if flip else bboxes
+    new_bboxes = new_bboxes.view(-1, 4) / new_bboxes.new_tensor(scale_factor)
+    return new_bboxes.view(bboxes.shape)
+
+
+def bbox2roi(bbox_list: List[Union[Tensor, BaseBoxes]]) -> Tensor:
+    """Convert a list of bboxes to roi format.
+
+    Args:
+        bbox_list (List[Union[Tensor, :obj:`BaseBoxes`]): a list of bboxes
+            corresponding to a batch of images.
+
+    Returns:
+        Tensor: shape (n, box_dim + 1), where ``box_dim`` depends on the
+        different box types. For example, If the box type in ``bbox_list``
+        is HorizontalBoxes, the output shape is (n, 5). Each row of data
+        indicates [batch_ind, x1, y1, x2, y2].
+    """
+    rois_list = []
+    for img_id, bboxes in enumerate(bbox_list):
+        bboxes = get_box_tensor(bboxes)
+        img_inds = bboxes.new_full((bboxes.size(0), 1), img_id)
+        rois = torch.cat([img_inds, bboxes], dim=-1)
+        rois_list.append(rois)
+    rois = torch.cat(rois_list, 0)
+    return rois
+
+
+def roi2bbox(rois: Tensor) -> List[Tensor]:
+    """Convert rois to bounding box format.
+
+    Args:
+        rois (Tensor): RoIs with the shape (n, 5) where the first
+            column indicates batch id of each RoI.
+
+    Returns:
+        List[Tensor]: Converted boxes of corresponding rois.
+    """
+    bbox_list = []
+    img_ids = torch.unique(rois[:, 0].cpu(), sorted=True)
+    for img_id in img_ids:
+        inds = (rois[:, 0] == img_id.item())
+        bbox = rois[inds, 1:]
+        bbox_list.append(bbox)
+    return bbox_list
+
+
+# TODO remove later
+def bbox2result(bboxes: Union[Tensor, np.ndarray], labels: Union[Tensor,
+                                                                 np.ndarray],
+                num_classes: int) -> List[np.ndarray]:
+    """Convert detection results to a list of numpy arrays.
+
+    Args:
+        bboxes (Tensor | np.ndarray): shape (n, 5)
+        labels (Tensor | np.ndarray): shape (n, )
+        num_classes (int): class number, including background class
+
+    Returns:
+        List(np.ndarray]): bbox results of each class
+    """
+    if bboxes.shape[0] == 0:
+        return [np.zeros((0, 5), dtype=np.float32) for i in range(num_classes)]
+    else:
+        if isinstance(bboxes, torch.Tensor):
+            bboxes = bboxes.detach().cpu().numpy()
+            labels = labels.detach().cpu().numpy()
+        return [bboxes[labels == i, :] for i in range(num_classes)]
+
+
+def distance2bbox(
+    points: Tensor,
+    distance: Tensor,
+    max_shape: Optional[Union[Sequence[int], Tensor,
+                              Sequence[Sequence[int]]]] = None
+) -> Tensor:
+    """Decode distance prediction to bounding box.
+
+    Args:
+        points (Tensor): Shape (B, N, 2) or (N, 2).
+        distance (Tensor): Distance from the given point to 4
+            boundaries (left, top, right, bottom). Shape (B, N, 4) or (N, 4)
+        max_shape (Union[Sequence[int], Tensor, Sequence[Sequence[int]]],
+            optional): Maximum bounds for boxes, specifies
+            (H, W, C) or (H, W). If priors shape is (B, N, 4), then
+            the max_shape should be a Sequence[Sequence[int]]
+            and the length of max_shape should also be B.
+
+    Returns:
+        Tensor: Boxes with shape (N, 4) or (B, N, 4)
+    """
+
+    x1 = points[..., 0] - distance[..., 0]
+    y1 = points[..., 1] - distance[..., 1]
+    x2 = points[..., 0] + distance[..., 2]
+    y2 = points[..., 1] + distance[..., 3]
+
+    bboxes = torch.stack([x1, y1, x2, y2], -1)
+
+    if max_shape is not None:
+        if bboxes.dim() == 2 and not torch.onnx.is_in_onnx_export():
+            # speed up
+            bboxes[:, 0::2].clamp_(min=0, max=max_shape[1])
+            bboxes[:, 1::2].clamp_(min=0, max=max_shape[0])
+            return bboxes
+
+        # clip bboxes with dynamic `min` and `max` for onnx
+        if torch.onnx.is_in_onnx_export():
+            # TODO: delete
+            from mmdet.core.export import dynamic_clip_for_onnx
+            x1, y1, x2, y2 = dynamic_clip_for_onnx(x1, y1, x2, y2, max_shape)
+            bboxes = torch.stack([x1, y1, x2, y2], dim=-1)
+            return bboxes
+        if not isinstance(max_shape, torch.Tensor):
+            max_shape = x1.new_tensor(max_shape)
+        max_shape = max_shape[..., :2].type_as(x1)
+        if max_shape.ndim == 2:
+            assert bboxes.ndim == 3
+            assert max_shape.size(0) == bboxes.size(0)
+
+        min_xy = x1.new_tensor(0)
+        max_xy = torch.cat([max_shape, max_shape],
+                           dim=-1).flip(-1).unsqueeze(-2)
+        bboxes = torch.where(bboxes < min_xy, min_xy, bboxes)
+        bboxes = torch.where(bboxes > max_xy, max_xy, bboxes)
+
+    return bboxes
+
+
+def bbox2distance(points: Tensor,
+                  bbox: Tensor,
+                  max_dis: Optional[float] = None,
+                  eps: float = 0.1) -> Tensor:
+    """Decode bounding box based on distances.
+
+    Args:
+        points (Tensor): Shape (n, 2) or (b, n, 2), [x, y].
+        bbox (Tensor): Shape (n, 4) or (b, n, 4), "xyxy" format
+        max_dis (float, optional): Upper bound of the distance.
+        eps (float): a small value to ensure target < max_dis, instead <=
+
+    Returns:
+        Tensor: Decoded distances.
+    """
+    left = points[..., 0] - bbox[..., 0]
+    top = points[..., 1] - bbox[..., 1]
+    right = bbox[..., 2] - points[..., 0]
+    bottom = bbox[..., 3] - points[..., 1]
+    if max_dis is not None:
+        left = left.clamp(min=0, max=max_dis - eps)
+        top = top.clamp(min=0, max=max_dis - eps)
+        right = right.clamp(min=0, max=max_dis - eps)
+        bottom = bottom.clamp(min=0, max=max_dis - eps)
+    return torch.stack([left, top, right, bottom], -1)
+
+
+def bbox_rescale(bboxes: Tensor, scale_factor: float = 1.0) -> Tensor:
+    """Rescale bounding box w.r.t. scale_factor.
+
+    Args:
+        bboxes (Tensor): Shape (n, 4) for bboxes or (n, 5) for rois
+        scale_factor (float): rescale factor
+
+    Returns:
+        Tensor: Rescaled bboxes.
+    """
+    if bboxes.size(1) == 5:
+        bboxes_ = bboxes[:, 1:]
+        inds_ = bboxes[:, 0]
+    else:
+        bboxes_ = bboxes
+    cx = (bboxes_[:, 0] + bboxes_[:, 2]) * 0.5
+    cy = (bboxes_[:, 1] + bboxes_[:, 3]) * 0.5
+    w = bboxes_[:, 2] - bboxes_[:, 0]
+    h = bboxes_[:, 3] - bboxes_[:, 1]
+    w = w * scale_factor
+    h = h * scale_factor
+    x1 = cx - 0.5 * w
+    x2 = cx + 0.5 * w
+    y1 = cy - 0.5 * h
+    y2 = cy + 0.5 * h
+    if bboxes.size(1) == 5:
+        rescaled_bboxes = torch.stack([inds_, x1, y1, x2, y2], dim=-1)
+    else:
+        rescaled_bboxes = torch.stack([x1, y1, x2, y2], dim=-1)
+    return rescaled_bboxes
+
+
+def bbox_cxcywh_to_xyxy(bbox: Tensor) -> Tensor:
+    """Convert bbox coordinates from (cx, cy, w, h) to (x1, y1, x2, y2).
+
+    Args:
+        bbox (Tensor): Shape (n, 4) for bboxes.
+
+    Returns:
+        Tensor: Converted bboxes.
+    """
+    cx, cy, w, h = bbox.split((1, 1, 1, 1), dim=-1)
+    bbox_new = [(cx - 0.5 * w), (cy - 0.5 * h), (cx + 0.5 * w), (cy + 0.5 * h)]
+    return torch.cat(bbox_new, dim=-1)
+
+
+def bbox_xyxy_to_cxcywh(bbox: Tensor) -> Tensor:
+    """Convert bbox coordinates from (x1, y1, x2, y2) to (cx, cy, w, h).
+
+    Args:
+        bbox (Tensor): Shape (n, 4) for bboxes.
+
+    Returns:
+        Tensor: Converted bboxes.
+    """
+    x1, y1, x2, y2 = bbox.split((1, 1, 1, 1), dim=-1)
+    bbox_new = [(x1 + x2) / 2, (y1 + y2) / 2, (x2 - x1), (y2 - y1)]
+    return torch.cat(bbox_new, dim=-1)
+
+
+def bbox2corner(bboxes: torch.Tensor) -> torch.Tensor:
+    """Convert bbox coordinates from (x1, y1, x2, y2) to corners ((x1, y1),
+    (x2, y1), (x1, y2), (x2, y2)).
+
+    Args:
+        bboxes (Tensor): Shape (n, 4) for bboxes.
+    Returns:
+        Tensor: Shape (n*4, 2) for corners.
+    """
+    x1, y1, x2, y2 = torch.split(bboxes, 1, dim=1)
+    return torch.cat([x1, y1, x2, y1, x1, y2, x2, y2], dim=1).reshape(-1, 2)
+
+
+def corner2bbox(corners: torch.Tensor) -> torch.Tensor:
+    """Convert bbox coordinates from corners ((x1, y1), (x2, y1), (x1, y2),
+    (x2, y2)) to (x1, y1, x2, y2).
+
+    Args:
+        corners (Tensor): Shape (n*4, 2) for corners.
+    Returns:
+        Tensor: Shape (n, 4) for bboxes.
+    """
+    corners = corners.reshape(-1, 4, 2)
+    min_xy = corners.min(dim=1)[0]
+    max_xy = corners.max(dim=1)[0]
+    return torch.cat([min_xy, max_xy], dim=1)
+
+
+def bbox_project(
+    bboxes: Union[torch.Tensor, np.ndarray],
+    homography_matrix: Union[torch.Tensor, np.ndarray],
+    img_shape: Optional[Tuple[int, int]] = None
+) -> Union[torch.Tensor, np.ndarray]:
+    """Geometric transformation for bbox.
+
+    Args:
+        bboxes (Union[torch.Tensor, np.ndarray]): Shape (n, 4) for bboxes.
+        homography_matrix (Union[torch.Tensor, np.ndarray]):
+            Shape (3, 3) for geometric transformation.
+        img_shape (Tuple[int, int], optional): Image shape. Defaults to None.
+    Returns:
+        Union[torch.Tensor, np.ndarray]: Converted bboxes.
+    """
+    bboxes_type = type(bboxes)
+    if bboxes_type is np.ndarray:
+        bboxes = torch.from_numpy(bboxes)
+    if isinstance(homography_matrix, np.ndarray):
+        homography_matrix = torch.from_numpy(homography_matrix)
+    corners = bbox2corner(bboxes)
+    corners = torch.cat(
+        [corners, corners.new_ones(corners.shape[0], 1)], dim=1)
+    corners = torch.matmul(homography_matrix, corners.t()).t()
+    # Convert to homogeneous coordinates by normalization
+    corners = corners[:, :2] / corners[:, 2:3]
+    bboxes = corner2bbox(corners)
+    if img_shape is not None:
+        bboxes[:, 0::2] = bboxes[:, 0::2].clamp(0, img_shape[1])
+        bboxes[:, 1::2] = bboxes[:, 1::2].clamp(0, img_shape[0])
+    if bboxes_type is np.ndarray:
+        bboxes = bboxes.numpy()
+    return bboxes
+
+
+def cat_boxes(data_list: List[Union[Tensor, BaseBoxes]],
+              dim: int = 0) -> Union[Tensor, BaseBoxes]:
+    """Concatenate boxes with type of tensor or box type.
+
+    Args:
+        data_list (List[Union[Tensor, :obj:`BaseBoxes`]]): A list of tensors
+            or box types need to be concatenated.
+            dim (int): The dimension over which the box are concatenated.
+                Defaults to 0.
+
+    Returns:
+        Union[Tensor, :obj`BaseBoxes`]: Concatenated results.
+    """
+    if data_list and isinstance(data_list[0], BaseBoxes):
+        return data_list[0].cat(data_list, dim=dim)
+    else:
+        return torch.cat(data_list, dim=dim)
+
+
+def stack_boxes(data_list: List[Union[Tensor, BaseBoxes]],
+                dim: int = 0) -> Union[Tensor, BaseBoxes]:
+    """Stack boxes with type of tensor or box type.
+
+    Args:
+        data_list (List[Union[Tensor, :obj:`BaseBoxes`]]): A list of tensors
+            or box types need to be stacked.
+            dim (int): The dimension over which the box are stacked.
+                Defaults to 0.
+
+    Returns:
+        Union[Tensor, :obj`BaseBoxes`]: Stacked results.
+    """
+    if data_list and isinstance(data_list[0], BaseBoxes):
+        return data_list[0].stack(data_list, dim=dim)
+    else:
+        return torch.stack(data_list, dim=dim)
+
+
+def scale_boxes(boxes: Union[Tensor, BaseBoxes],
+                scale_factor: Tuple[float, float]) -> Union[Tensor, BaseBoxes]:
+    """Scale boxes with type of tensor or box type.
+
+    Args:
+        boxes (Tensor or :obj:`BaseBoxes`): boxes need to be scaled. Its type
+            can be a tensor or a box type.
+        scale_factor (Tuple[float, float]): factors for scaling boxes.
+            The length should be 2.
+
+    Returns:
+        Union[Tensor, :obj:`BaseBoxes`]: Scaled boxes.
+    """
+    if isinstance(boxes, BaseBoxes):
+        boxes.rescale_(scale_factor)
+        return boxes
+    else:
+        # Tensor boxes will be treated as horizontal boxes
+        repeat_num = int(boxes.size(-1) / 2)
+        scale_factor = boxes.new_tensor(scale_factor).repeat((1, repeat_num))
+        return boxes * scale_factor
+
+
+def get_box_wh(boxes: Union[Tensor, BaseBoxes]) -> Tuple[Tensor, Tensor]:
+    """Get the width and height of boxes with type of tensor or box type.
+
+    Args:
+        boxes (Tensor or :obj:`BaseBoxes`): boxes with type of tensor
+            or box type.
+
+    Returns:
+        Tuple[Tensor, Tensor]: the width and height of boxes.
+    """
+    if isinstance(boxes, BaseBoxes):
+        w = boxes.widths
+        h = boxes.heights
+    else:
+        # Tensor boxes will be treated as horizontal boxes by defaults
+        w = boxes[:, 2] - boxes[:, 0]
+        h = boxes[:, 3] - boxes[:, 1]
+    return w, h
+
+
+def get_box_tensor(boxes: Union[Tensor, BaseBoxes]) -> Tensor:
+    """Get tensor data from box type boxes.
+
+    Args:
+        boxes (Tensor or BaseBoxes): boxes with type of tensor or box type.
+            If its type is a tensor, the boxes will be directly returned.
+            If its type is a box type, the `boxes.tensor` will be returned.
+
+    Returns:
+        Tensor: boxes tensor.
+    """
+    if isinstance(boxes, BaseBoxes):
+        boxes = boxes.tensor
+    return boxes
+
+
+def empty_box_as(boxes: Union[Tensor, BaseBoxes]) -> Union[Tensor, BaseBoxes]:
+    """Generate empty box according to input ``boxes` type and device.
+
+    Args:
+        boxes (Tensor or :obj:`BaseBoxes`): boxes with type of tensor
+            or box type.
+
+    Returns:
+        Union[Tensor, BaseBoxes]: Generated empty box.
+    """
+    if isinstance(boxes, BaseBoxes):
+        return boxes.empty_boxes()
+    else:
+        # Tensor boxes will be treated as horizontal boxes by defaults
+        return boxes.new_zeros(0, 4)
+
+
+def bbox_xyxy_to_cxcyah(bboxes: torch.Tensor) -> torch.Tensor:
+    """Convert bbox coordinates from (x1, y1, x2, y2) to (cx, cy, ratio, h).
+
+    Args:
+        bbox (Tensor): Shape (n, 4) for bboxes.
+
+    Returns:
+        Tensor: Converted bboxes.
+    """
+    cx = (bboxes[:, 2] + bboxes[:, 0]) / 2
+    cy = (bboxes[:, 3] + bboxes[:, 1]) / 2
+    w = bboxes[:, 2] - bboxes[:, 0]
+    h = bboxes[:, 3] - bboxes[:, 1]
+    xyah = torch.stack([cx, cy, w / h, h], -1)
+    return xyah
+
+
+def bbox_cxcyah_to_xyxy(bboxes: torch.Tensor) -> torch.Tensor:
+    """Convert bbox coordinates from (cx, cy, ratio, h) to (x1, y1, x2, y2).
+
+    Args:
+        bbox (Tensor): Shape (n, 4) for bboxes.
+    Returns:
+        Tensor: Converted bboxes.
+    """
+    cx, cy, ratio, h = bboxes.split((1, 1, 1, 1), dim=-1)
+    w = ratio * h
+    x1y1x2y2 = [cx - w / 2.0, cy - h / 2.0, cx + w / 2.0, cy + h / 2.0]
+    return torch.cat(x1y1x2y2, dim=-1)
diff --git a/mmdetection/mmdet/structures/det_data_sample.py b/mmdetection/mmdet/structures/det_data_sample.py
new file mode 100644
index 00000000..37dd7472
--- /dev/null
+++ b/mmdetection/mmdet/structures/det_data_sample.py
@@ -0,0 +1,237 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional
+
+from mmengine.structures import BaseDataElement, InstanceData, PixelData
+
+
+class DetDataSample(BaseDataElement):
+    """A data structure interface of MMDetection. They are used as interfaces
+    between different components.
+
+    The attributes in ``DetDataSample`` are divided into several parts:
+
+        - ``proposals``(InstanceData): Region proposals used in two-stage
+            detectors.
+        - ``gt_instances``(InstanceData): Ground truth of instance annotations.
+        - ``pred_instances``(InstanceData): Instances of detection predictions.
+        - ``pred_track_instances``(InstanceData): Instances of tracking
+            predictions.
+        - ``ignored_instances``(InstanceData): Instances to be ignored during
+            training/testing.
+        - ``gt_panoptic_seg``(PixelData): Ground truth of panoptic
+            segmentation.
+        - ``pred_panoptic_seg``(PixelData): Prediction of panoptic
+           segmentation.
+        - ``gt_sem_seg``(PixelData): Ground truth of semantic segmentation.
+        - ``pred_sem_seg``(PixelData): Prediction of semantic segmentation.
+
+    Examples:
+         >>> import torch
+         >>> import numpy as np
+         >>> from mmengine.structures import InstanceData
+         >>> from mmdet.structures import DetDataSample
+
+         >>> data_sample = DetDataSample()
+         >>> img_meta = dict(img_shape=(800, 1196),
+         ...                 pad_shape=(800, 1216))
+         >>> gt_instances = InstanceData(metainfo=img_meta)
+         >>> gt_instances.bboxes = torch.rand((5, 4))
+         >>> gt_instances.labels = torch.rand((5,))
+         >>> data_sample.gt_instances = gt_instances
+         >>> assert 'img_shape' in data_sample.gt_instances.metainfo_keys()
+         >>> len(data_sample.gt_instances)
+         5
+         >>> print(data_sample)
+        
+        ) at 0x7f21fb1b9880>
+         >>> pred_instances = InstanceData(metainfo=img_meta)
+         >>> pred_instances.bboxes = torch.rand((5, 4))
+         >>> pred_instances.scores = torch.rand((5,))
+         >>> data_sample = DetDataSample(pred_instances=pred_instances)
+         >>> assert 'pred_instances' in data_sample
+
+         >>> pred_track_instances = InstanceData(metainfo=img_meta)
+         >>> pred_track_instances.bboxes = torch.rand((5, 4))
+         >>> pred_track_instances.scores = torch.rand((5,))
+         >>> data_sample = DetDataSample(
+         ...    pred_track_instances=pred_track_instances)
+         >>> assert 'pred_track_instances' in data_sample
+
+         >>> data_sample = DetDataSample()
+         >>> gt_instances_data = dict(
+         ...                        bboxes=torch.rand(2, 4),
+         ...                        labels=torch.rand(2),
+         ...                        masks=np.random.rand(2, 2, 2))
+         >>> gt_instances = InstanceData(**gt_instances_data)
+         >>> data_sample.gt_instances = gt_instances
+         >>> assert 'gt_instances' in data_sample
+         >>> assert 'masks' in data_sample.gt_instances
+
+         >>> data_sample = DetDataSample()
+         >>> gt_panoptic_seg_data = dict(panoptic_seg=torch.rand(2, 4))
+         >>> gt_panoptic_seg = PixelData(**gt_panoptic_seg_data)
+         >>> data_sample.gt_panoptic_seg = gt_panoptic_seg
+         >>> print(data_sample)
+        
+            gt_panoptic_seg: 
+        ) at 0x7f66c2bb7280>
+        >>> data_sample = DetDataSample()
+        >>> gt_segm_seg_data = dict(segm_seg=torch.rand(2, 2, 2))
+        >>> gt_segm_seg = PixelData(**gt_segm_seg_data)
+        >>> data_sample.gt_segm_seg = gt_segm_seg
+        >>> assert 'gt_segm_seg' in data_sample
+        >>> assert 'segm_seg' in data_sample.gt_segm_seg
+    """
+
+    @property
+    def proposals(self) -> InstanceData:
+        return self._proposals
+
+    @proposals.setter
+    def proposals(self, value: InstanceData):
+        self.set_field(value, '_proposals', dtype=InstanceData)
+
+    @proposals.deleter
+    def proposals(self):
+        del self._proposals
+
+    @property
+    def gt_instances(self) -> InstanceData:
+        return self._gt_instances
+
+    @gt_instances.setter
+    def gt_instances(self, value: InstanceData):
+        self.set_field(value, '_gt_instances', dtype=InstanceData)
+
+    @gt_instances.deleter
+    def gt_instances(self):
+        del self._gt_instances
+
+    @property
+    def pred_instances(self) -> InstanceData:
+        return self._pred_instances
+
+    @pred_instances.setter
+    def pred_instances(self, value: InstanceData):
+        self.set_field(value, '_pred_instances', dtype=InstanceData)
+
+    @pred_instances.deleter
+    def pred_instances(self):
+        del self._pred_instances
+
+    # directly add ``pred_track_instances`` in ``DetDataSample``
+    # so that the ``TrackDataSample`` does not bother to access the
+    # instance-level information.
+    @property
+    def pred_track_instances(self) -> InstanceData:
+        return self._pred_track_instances
+
+    @pred_track_instances.setter
+    def pred_track_instances(self, value: InstanceData):
+        self.set_field(value, '_pred_track_instances', dtype=InstanceData)
+
+    @pred_track_instances.deleter
+    def pred_track_instances(self):
+        del self._pred_track_instances
+
+    @property
+    def ignored_instances(self) -> InstanceData:
+        return self._ignored_instances
+
+    @ignored_instances.setter
+    def ignored_instances(self, value: InstanceData):
+        self.set_field(value, '_ignored_instances', dtype=InstanceData)
+
+    @ignored_instances.deleter
+    def ignored_instances(self):
+        del self._ignored_instances
+
+    @property
+    def gt_panoptic_seg(self) -> PixelData:
+        return self._gt_panoptic_seg
+
+    @gt_panoptic_seg.setter
+    def gt_panoptic_seg(self, value: PixelData):
+        self.set_field(value, '_gt_panoptic_seg', dtype=PixelData)
+
+    @gt_panoptic_seg.deleter
+    def gt_panoptic_seg(self):
+        del self._gt_panoptic_seg
+
+    @property
+    def pred_panoptic_seg(self) -> PixelData:
+        return self._pred_panoptic_seg
+
+    @pred_panoptic_seg.setter
+    def pred_panoptic_seg(self, value: PixelData):
+        self.set_field(value, '_pred_panoptic_seg', dtype=PixelData)
+
+    @pred_panoptic_seg.deleter
+    def pred_panoptic_seg(self):
+        del self._pred_panoptic_seg
+
+    @property
+    def gt_sem_seg(self) -> PixelData:
+        return self._gt_sem_seg
+
+    @gt_sem_seg.setter
+    def gt_sem_seg(self, value: PixelData):
+        self.set_field(value, '_gt_sem_seg', dtype=PixelData)
+
+    @gt_sem_seg.deleter
+    def gt_sem_seg(self):
+        del self._gt_sem_seg
+
+    @property
+    def pred_sem_seg(self) -> PixelData:
+        return self._pred_sem_seg
+
+    @pred_sem_seg.setter
+    def pred_sem_seg(self, value: PixelData):
+        self.set_field(value, '_pred_sem_seg', dtype=PixelData)
+
+    @pred_sem_seg.deleter
+    def pred_sem_seg(self):
+        del self._pred_sem_seg
+
+
+SampleList = List[DetDataSample]
+OptSampleList = Optional[SampleList]
diff --git a/mmdetection/mmdet/structures/mask/__init__.py b/mmdetection/mmdet/structures/mask/__init__.py
new file mode 100644
index 00000000..f7839470
--- /dev/null
+++ b/mmdetection/mmdet/structures/mask/__init__.py
@@ -0,0 +1,11 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .mask_target import mask_target
+from .structures import (BaseInstanceMasks, BitmapMasks, PolygonMasks,
+                         bitmap_to_polygon, polygon_to_bitmap)
+from .utils import encode_mask_results, mask2bbox, split_combined_polys
+
+__all__ = [
+    'split_combined_polys', 'mask_target', 'BaseInstanceMasks', 'BitmapMasks',
+    'PolygonMasks', 'encode_mask_results', 'mask2bbox', 'polygon_to_bitmap',
+    'bitmap_to_polygon'
+]
diff --git a/mmdetection/mmdet/structures/mask/mask_target.py b/mmdetection/mmdet/structures/mask/mask_target.py
new file mode 100644
index 00000000..b2fc5f18
--- /dev/null
+++ b/mmdetection/mmdet/structures/mask/mask_target.py
@@ -0,0 +1,127 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import numpy as np
+import torch
+from torch.nn.modules.utils import _pair
+
+
+def mask_target(pos_proposals_list, pos_assigned_gt_inds_list, gt_masks_list,
+                cfg):
+    """Compute mask target for positive proposals in multiple images.
+
+    Args:
+        pos_proposals_list (list[Tensor]): Positive proposals in multiple
+            images, each has shape (num_pos, 4).
+        pos_assigned_gt_inds_list (list[Tensor]): Assigned GT indices for each
+            positive proposals, each has shape (num_pos,).
+        gt_masks_list (list[:obj:`BaseInstanceMasks`]): Ground truth masks of
+            each image.
+        cfg (dict): Config dict that specifies the mask size.
+
+    Returns:
+        Tensor: Mask target of each image, has shape (num_pos, w, h).
+
+    Example:
+        >>> from mmengine.config import Config
+        >>> import mmdet
+        >>> from mmdet.data_elements.mask import BitmapMasks
+        >>> from mmdet.data_elements.mask.mask_target import *
+        >>> H, W = 17, 18
+        >>> cfg = Config({'mask_size': (13, 14)})
+        >>> rng = np.random.RandomState(0)
+        >>> # Positive proposals (tl_x, tl_y, br_x, br_y) for each image
+        >>> pos_proposals_list = [
+        >>>     torch.Tensor([
+        >>>         [ 7.2425,  5.5929, 13.9414, 14.9541],
+        >>>         [ 7.3241,  3.6170, 16.3850, 15.3102],
+        >>>     ]),
+        >>>     torch.Tensor([
+        >>>         [ 4.8448, 6.4010, 7.0314, 9.7681],
+        >>>         [ 5.9790, 2.6989, 7.4416, 4.8580],
+        >>>         [ 0.0000, 0.0000, 0.1398, 9.8232],
+        >>>     ]),
+        >>> ]
+        >>> # Corresponding class index for each proposal for each image
+        >>> pos_assigned_gt_inds_list = [
+        >>>     torch.LongTensor([7, 0]),
+        >>>     torch.LongTensor([5, 4, 1]),
+        >>> ]
+        >>> # Ground truth mask for each true object for each image
+        >>> gt_masks_list = [
+        >>>     BitmapMasks(rng.rand(8, H, W), height=H, width=W),
+        >>>     BitmapMasks(rng.rand(6, H, W), height=H, width=W),
+        >>> ]
+        >>> mask_targets = mask_target(
+        >>>     pos_proposals_list, pos_assigned_gt_inds_list,
+        >>>     gt_masks_list, cfg)
+        >>> assert mask_targets.shape == (5,) + cfg['mask_size']
+    """
+    cfg_list = [cfg for _ in range(len(pos_proposals_list))]
+    mask_targets = map(mask_target_single, pos_proposals_list,
+                       pos_assigned_gt_inds_list, gt_masks_list, cfg_list)
+    mask_targets = list(mask_targets)
+    if len(mask_targets) > 0:
+        mask_targets = torch.cat(mask_targets)
+    return mask_targets
+
+
+def mask_target_single(pos_proposals, pos_assigned_gt_inds, gt_masks, cfg):
+    """Compute mask target for each positive proposal in the image.
+
+    Args:
+        pos_proposals (Tensor): Positive proposals.
+        pos_assigned_gt_inds (Tensor): Assigned GT inds of positive proposals.
+        gt_masks (:obj:`BaseInstanceMasks`): GT masks in the format of Bitmap
+            or Polygon.
+        cfg (dict): Config dict that indicate the mask size.
+
+    Returns:
+        Tensor: Mask target of each positive proposals in the image.
+
+    Example:
+        >>> from mmengine.config import Config
+        >>> import mmdet
+        >>> from mmdet.data_elements.mask import BitmapMasks
+        >>> from mmdet.data_elements.mask.mask_target import *  # NOQA
+        >>> H, W = 32, 32
+        >>> cfg = Config({'mask_size': (7, 11)})
+        >>> rng = np.random.RandomState(0)
+        >>> # Masks for each ground truth box (relative to the image)
+        >>> gt_masks_data = rng.rand(3, H, W)
+        >>> gt_masks = BitmapMasks(gt_masks_data, height=H, width=W)
+        >>> # Predicted positive boxes in one image
+        >>> pos_proposals = torch.FloatTensor([
+        >>>     [ 16.2,   5.5, 19.9, 20.9],
+        >>>     [ 17.3,  13.6, 19.3, 19.3],
+        >>>     [ 14.8,  16.4, 17.0, 23.7],
+        >>>     [  0.0,   0.0, 16.0, 16.0],
+        >>>     [  4.0,   0.0, 20.0, 16.0],
+        >>> ])
+        >>> # For each predicted proposal, its assignment to a gt mask
+        >>> pos_assigned_gt_inds = torch.LongTensor([0, 1, 2, 1, 1])
+        >>> mask_targets = mask_target_single(
+        >>>     pos_proposals, pos_assigned_gt_inds, gt_masks, cfg)
+        >>> assert mask_targets.shape == (5,) + cfg['mask_size']
+    """
+    device = pos_proposals.device
+    mask_size = _pair(cfg.mask_size)
+    binarize = not cfg.get('soft_mask_target', False)
+    num_pos = pos_proposals.size(0)
+    if num_pos > 0:
+        proposals_np = pos_proposals.cpu().numpy()
+        maxh, maxw = gt_masks.height, gt_masks.width
+        proposals_np[:, [0, 2]] = np.clip(proposals_np[:, [0, 2]], 0, maxw)
+        proposals_np[:, [1, 3]] = np.clip(proposals_np[:, [1, 3]], 0, maxh)
+        pos_assigned_gt_inds = pos_assigned_gt_inds.cpu().numpy()
+
+        mask_targets = gt_masks.crop_and_resize(
+            proposals_np,
+            mask_size,
+            device=device,
+            inds=pos_assigned_gt_inds,
+            binarize=binarize).to_ndarray()
+
+        mask_targets = torch.from_numpy(mask_targets).float().to(device)
+    else:
+        mask_targets = pos_proposals.new_zeros((0, ) + mask_size)
+
+    return mask_targets
diff --git a/mmdetection/mmdet/structures/mask/structures.py b/mmdetection/mmdet/structures/mask/structures.py
new file mode 100644
index 00000000..b4fdd275
--- /dev/null
+++ b/mmdetection/mmdet/structures/mask/structures.py
@@ -0,0 +1,1193 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import itertools
+from abc import ABCMeta, abstractmethod
+from typing import Sequence, Type, TypeVar
+
+import cv2
+import mmcv
+import numpy as np
+import pycocotools.mask as maskUtils
+import shapely.geometry as geometry
+import torch
+from mmcv.ops.roi_align import roi_align
+
+T = TypeVar('T')
+
+
+class BaseInstanceMasks(metaclass=ABCMeta):
+    """Base class for instance masks."""
+
+    @abstractmethod
+    def rescale(self, scale, interpolation='nearest'):
+        """Rescale masks as large as possible while keeping the aspect ratio.
+        For details can refer to `mmcv.imrescale`.
+
+        Args:
+            scale (tuple[int]): The maximum size (h, w) of rescaled mask.
+            interpolation (str): Same as :func:`mmcv.imrescale`.
+
+        Returns:
+            BaseInstanceMasks: The rescaled masks.
+        """
+
+    @abstractmethod
+    def resize(self, out_shape, interpolation='nearest'):
+        """Resize masks to the given out_shape.
+
+        Args:
+            out_shape: Target (h, w) of resized mask.
+            interpolation (str): See :func:`mmcv.imresize`.
+
+        Returns:
+            BaseInstanceMasks: The resized masks.
+        """
+
+    @abstractmethod
+    def flip(self, flip_direction='horizontal'):
+        """Flip masks alone the given direction.
+
+        Args:
+            flip_direction (str): Either 'horizontal' or 'vertical'.
+
+        Returns:
+            BaseInstanceMasks: The flipped masks.
+        """
+
+    @abstractmethod
+    def pad(self, out_shape, pad_val):
+        """Pad masks to the given size of (h, w).
+
+        Args:
+            out_shape (tuple[int]): Target (h, w) of padded mask.
+            pad_val (int): The padded value.
+
+        Returns:
+            BaseInstanceMasks: The padded masks.
+        """
+
+    @abstractmethod
+    def crop(self, bbox):
+        """Crop each mask by the given bbox.
+
+        Args:
+            bbox (ndarray): Bbox in format [x1, y1, x2, y2], shape (4, ).
+
+        Return:
+            BaseInstanceMasks: The cropped masks.
+        """
+
+    @abstractmethod
+    def crop_and_resize(self,
+                        bboxes,
+                        out_shape,
+                        inds,
+                        device,
+                        interpolation='bilinear',
+                        binarize=True):
+        """Crop and resize masks by the given bboxes.
+
+        This function is mainly used in mask targets computation.
+        It firstly align mask to bboxes by assigned_inds, then crop mask by the
+        assigned bbox and resize to the size of (mask_h, mask_w)
+
+        Args:
+            bboxes (Tensor): Bboxes in format [x1, y1, x2, y2], shape (N, 4)
+            out_shape (tuple[int]): Target (h, w) of resized mask
+            inds (ndarray): Indexes to assign masks to each bbox,
+                shape (N,) and values should be between [0, num_masks - 1].
+            device (str): Device of bboxes
+            interpolation (str): See `mmcv.imresize`
+            binarize (bool): if True fractional values are rounded to 0 or 1
+                after the resize operation. if False and unsupported an error
+                will be raised. Defaults to True.
+
+        Return:
+            BaseInstanceMasks: the cropped and resized masks.
+        """
+
+    @abstractmethod
+    def expand(self, expanded_h, expanded_w, top, left):
+        """see :class:`Expand`."""
+
+    @property
+    @abstractmethod
+    def areas(self):
+        """ndarray: areas of each instance."""
+
+    @abstractmethod
+    def to_ndarray(self):
+        """Convert masks to the format of ndarray.
+
+        Return:
+            ndarray: Converted masks in the format of ndarray.
+        """
+
+    @abstractmethod
+    def to_tensor(self, dtype, device):
+        """Convert masks to the format of Tensor.
+
+        Args:
+            dtype (str): Dtype of converted mask.
+            device (torch.device): Device of converted masks.
+
+        Returns:
+            Tensor: Converted masks in the format of Tensor.
+        """
+
+    @abstractmethod
+    def translate(self,
+                  out_shape,
+                  offset,
+                  direction='horizontal',
+                  border_value=0,
+                  interpolation='bilinear'):
+        """Translate the masks.
+
+        Args:
+            out_shape (tuple[int]): Shape for output mask, format (h, w).
+            offset (int | float): The offset for translate.
+            direction (str): The translate direction, either "horizontal"
+                or "vertical".
+            border_value (int | float): Border value. Default 0.
+            interpolation (str): Same as :func:`mmcv.imtranslate`.
+
+        Returns:
+            Translated masks.
+        """
+
+    def shear(self,
+              out_shape,
+              magnitude,
+              direction='horizontal',
+              border_value=0,
+              interpolation='bilinear'):
+        """Shear the masks.
+
+        Args:
+            out_shape (tuple[int]): Shape for output mask, format (h, w).
+            magnitude (int | float): The magnitude used for shear.
+            direction (str): The shear direction, either "horizontal"
+                or "vertical".
+            border_value (int | tuple[int]): Value used in case of a
+                constant border. Default 0.
+            interpolation (str): Same as in :func:`mmcv.imshear`.
+
+        Returns:
+            ndarray: Sheared masks.
+        """
+
+    @abstractmethod
+    def rotate(self, out_shape, angle, center=None, scale=1.0, border_value=0):
+        """Rotate the masks.
+
+        Args:
+            out_shape (tuple[int]): Shape for output mask, format (h, w).
+            angle (int | float): Rotation angle in degrees. Positive values
+                mean counter-clockwise rotation.
+            center (tuple[float], optional): Center point (w, h) of the
+                rotation in source image. If not specified, the center of
+                the image will be used.
+            scale (int | float): Isotropic scale factor.
+            border_value (int | float): Border value. Default 0 for masks.
+
+        Returns:
+            Rotated masks.
+        """
+
+    def get_bboxes(self, dst_type='hbb'):
+        """Get the certain type boxes from masks.
+
+        Please refer to ``mmdet.structures.bbox.box_type`` for more details of
+        the box type.
+
+        Args:
+            dst_type: Destination box type.
+
+        Returns:
+            :obj:`BaseBoxes`: Certain type boxes.
+        """
+        from ..bbox import get_box_type
+        _, box_type_cls = get_box_type(dst_type)
+        return box_type_cls.from_instance_masks(self)
+
+    @classmethod
+    @abstractmethod
+    def cat(cls: Type[T], masks: Sequence[T]) -> T:
+        """Concatenate a sequence of masks into one single mask instance.
+
+        Args:
+            masks (Sequence[T]): A sequence of mask instances.
+
+        Returns:
+            T: Concatenated mask instance.
+        """
+
+
+class BitmapMasks(BaseInstanceMasks):
+    """This class represents masks in the form of bitmaps.
+
+    Args:
+        masks (ndarray): ndarray of masks in shape (N, H, W), where N is
+            the number of objects.
+        height (int): height of masks
+        width (int): width of masks
+
+    Example:
+        >>> from mmdet.data_elements.mask.structures import *  # NOQA
+        >>> num_masks, H, W = 3, 32, 32
+        >>> rng = np.random.RandomState(0)
+        >>> masks = (rng.rand(num_masks, H, W) > 0.1).astype(np.int64)
+        >>> self = BitmapMasks(masks, height=H, width=W)
+
+        >>> # demo crop_and_resize
+        >>> num_boxes = 5
+        >>> bboxes = np.array([[0, 0, 30, 10.0]] * num_boxes)
+        >>> out_shape = (14, 14)
+        >>> inds = torch.randint(0, len(self), size=(num_boxes,))
+        >>> device = 'cpu'
+        >>> interpolation = 'bilinear'
+        >>> new = self.crop_and_resize(
+        ...     bboxes, out_shape, inds, device, interpolation)
+        >>> assert len(new) == num_boxes
+        >>> assert new.height, new.width == out_shape
+    """
+
+    def __init__(self, masks, height, width):
+        self.height = height
+        self.width = width
+        if len(masks) == 0:
+            self.masks = np.empty((0, self.height, self.width), dtype=np.uint8)
+        else:
+            assert isinstance(masks, (list, np.ndarray))
+            if isinstance(masks, list):
+                assert isinstance(masks[0], np.ndarray)
+                assert masks[0].ndim == 2  # (H, W)
+            else:
+                assert masks.ndim == 3  # (N, H, W)
+
+            self.masks = np.stack(masks).reshape(-1, height, width)
+            assert self.masks.shape[1] == self.height
+            assert self.masks.shape[2] == self.width
+
+    def __getitem__(self, index):
+        """Index the BitmapMask.
+
+        Args:
+            index (int | ndarray): Indices in the format of integer or ndarray.
+
+        Returns:
+            :obj:`BitmapMasks`: Indexed bitmap masks.
+        """
+        masks = self.masks[index].reshape(-1, self.height, self.width)
+        return BitmapMasks(masks, self.height, self.width)
+
+    def __iter__(self):
+        return iter(self.masks)
+
+    def __repr__(self):
+        s = self.__class__.__name__ + '('
+        s += f'num_masks={len(self.masks)}, '
+        s += f'height={self.height}, '
+        s += f'width={self.width})'
+        return s
+
+    def __len__(self):
+        """Number of masks."""
+        return len(self.masks)
+
+    def rescale(self, scale, interpolation='nearest'):
+        """See :func:`BaseInstanceMasks.rescale`."""
+        if len(self.masks) == 0:
+            new_w, new_h = mmcv.rescale_size((self.width, self.height), scale)
+            rescaled_masks = np.empty((0, new_h, new_w), dtype=np.uint8)
+        else:
+            rescaled_masks = np.stack([
+                mmcv.imrescale(mask, scale, interpolation=interpolation)
+                for mask in self.masks
+            ])
+        height, width = rescaled_masks.shape[1:]
+        return BitmapMasks(rescaled_masks, height, width)
+
+    def resize(self, out_shape, interpolation='nearest'):
+        """See :func:`BaseInstanceMasks.resize`."""
+        if len(self.masks) == 0:
+            resized_masks = np.empty((0, *out_shape), dtype=np.uint8)
+        else:
+            resized_masks = np.stack([
+                mmcv.imresize(
+                    mask, out_shape[::-1], interpolation=interpolation)
+                for mask in self.masks
+            ])
+        return BitmapMasks(resized_masks, *out_shape)
+
+    def flip(self, flip_direction='horizontal'):
+        """See :func:`BaseInstanceMasks.flip`."""
+        assert flip_direction in ('horizontal', 'vertical', 'diagonal')
+
+        if len(self.masks) == 0:
+            flipped_masks = self.masks
+        else:
+            flipped_masks = np.stack([
+                mmcv.imflip(mask, direction=flip_direction)
+                for mask in self.masks
+            ])
+        return BitmapMasks(flipped_masks, self.height, self.width)
+
+    def pad(self, out_shape, pad_val=0):
+        """See :func:`BaseInstanceMasks.pad`."""
+        if len(self.masks) == 0:
+            padded_masks = np.empty((0, *out_shape), dtype=np.uint8)
+        else:
+            padded_masks = np.stack([
+                mmcv.impad(mask, shape=out_shape, pad_val=pad_val)
+                for mask in self.masks
+            ])
+        return BitmapMasks(padded_masks, *out_shape)
+
+    def crop(self, bbox):
+        """See :func:`BaseInstanceMasks.crop`."""
+        assert isinstance(bbox, np.ndarray)
+        assert bbox.ndim == 1
+
+        # clip the boundary
+        bbox = bbox.copy()
+        bbox[0::2] = np.clip(bbox[0::2], 0, self.width)
+        bbox[1::2] = np.clip(bbox[1::2], 0, self.height)
+        x1, y1, x2, y2 = bbox
+        w = np.maximum(x2 - x1, 1)
+        h = np.maximum(y2 - y1, 1)
+
+        if len(self.masks) == 0:
+            cropped_masks = np.empty((0, h, w), dtype=np.uint8)
+        else:
+            cropped_masks = self.masks[:, y1:y1 + h, x1:x1 + w]
+        return BitmapMasks(cropped_masks, h, w)
+
+    def crop_and_resize(self,
+                        bboxes,
+                        out_shape,
+                        inds,
+                        device='cpu',
+                        interpolation='bilinear',
+                        binarize=True):
+        """See :func:`BaseInstanceMasks.crop_and_resize`."""
+        if len(self.masks) == 0:
+            empty_masks = np.empty((0, *out_shape), dtype=np.uint8)
+            return BitmapMasks(empty_masks, *out_shape)
+
+        # convert bboxes to tensor
+        if isinstance(bboxes, np.ndarray):
+            bboxes = torch.from_numpy(bboxes).to(device=device)
+        if isinstance(inds, np.ndarray):
+            inds = torch.from_numpy(inds).to(device=device)
+
+        num_bbox = bboxes.shape[0]
+        fake_inds = torch.arange(
+            num_bbox, device=device).to(dtype=bboxes.dtype)[:, None]
+        rois = torch.cat([fake_inds, bboxes], dim=1)  # Nx5
+        rois = rois.to(device=device)
+        if num_bbox > 0:
+            gt_masks_th = torch.from_numpy(self.masks).to(device).index_select(
+                0, inds).to(dtype=rois.dtype)
+            targets = roi_align(gt_masks_th[:, None, :, :], rois, out_shape,
+                                1.0, 0, 'avg', True).squeeze(1)
+            if binarize:
+                resized_masks = (targets >= 0.5).cpu().numpy()
+            else:
+                resized_masks = targets.cpu().numpy()
+        else:
+            resized_masks = []
+        return BitmapMasks(resized_masks, *out_shape)
+
+    def expand(self, expanded_h, expanded_w, top, left):
+        """See :func:`BaseInstanceMasks.expand`."""
+        if len(self.masks) == 0:
+            expanded_mask = np.empty((0, expanded_h, expanded_w),
+                                     dtype=np.uint8)
+        else:
+            expanded_mask = np.zeros((len(self), expanded_h, expanded_w),
+                                     dtype=np.uint8)
+            expanded_mask[:, top:top + self.height,
+                          left:left + self.width] = self.masks
+        return BitmapMasks(expanded_mask, expanded_h, expanded_w)
+
+    def translate(self,
+                  out_shape,
+                  offset,
+                  direction='horizontal',
+                  border_value=0,
+                  interpolation='bilinear'):
+        """Translate the BitmapMasks.
+
+        Args:
+            out_shape (tuple[int]): Shape for output mask, format (h, w).
+            offset (int | float): The offset for translate.
+            direction (str): The translate direction, either "horizontal"
+                or "vertical".
+            border_value (int | float): Border value. Default 0 for masks.
+            interpolation (str): Same as :func:`mmcv.imtranslate`.
+
+        Returns:
+            BitmapMasks: Translated BitmapMasks.
+
+        Example:
+            >>> from mmdet.data_elements.mask.structures import BitmapMasks
+            >>> self = BitmapMasks.random(dtype=np.uint8)
+            >>> out_shape = (32, 32)
+            >>> offset = 4
+            >>> direction = 'horizontal'
+            >>> border_value = 0
+            >>> interpolation = 'bilinear'
+            >>> # Note, There seem to be issues when:
+            >>> # * the mask dtype is not supported by cv2.AffineWarp
+            >>> new = self.translate(out_shape, offset, direction,
+            >>>                      border_value, interpolation)
+            >>> assert len(new) == len(self)
+            >>> assert new.height, new.width == out_shape
+        """
+        if len(self.masks) == 0:
+            translated_masks = np.empty((0, *out_shape), dtype=np.uint8)
+        else:
+            masks = self.masks
+            if masks.shape[-2:] != out_shape:
+                empty_masks = np.zeros((masks.shape[0], *out_shape),
+                                       dtype=masks.dtype)
+                min_h = min(out_shape[0], masks.shape[1])
+                min_w = min(out_shape[1], masks.shape[2])
+                empty_masks[:, :min_h, :min_w] = masks[:, :min_h, :min_w]
+                masks = empty_masks
+            translated_masks = mmcv.imtranslate(
+                masks.transpose((1, 2, 0)),
+                offset,
+                direction,
+                border_value=border_value,
+                interpolation=interpolation)
+            if translated_masks.ndim == 2:
+                translated_masks = translated_masks[:, :, None]
+            translated_masks = translated_masks.transpose(
+                (2, 0, 1)).astype(self.masks.dtype)
+        return BitmapMasks(translated_masks, *out_shape)
+
+    def shear(self,
+              out_shape,
+              magnitude,
+              direction='horizontal',
+              border_value=0,
+              interpolation='bilinear'):
+        """Shear the BitmapMasks.
+
+        Args:
+            out_shape (tuple[int]): Shape for output mask, format (h, w).
+            magnitude (int | float): The magnitude used for shear.
+            direction (str): The shear direction, either "horizontal"
+                or "vertical".
+            border_value (int | tuple[int]): Value used in case of a
+                constant border.
+            interpolation (str): Same as in :func:`mmcv.imshear`.
+
+        Returns:
+            BitmapMasks: The sheared masks.
+        """
+        if len(self.masks) == 0:
+            sheared_masks = np.empty((0, *out_shape), dtype=np.uint8)
+        else:
+            sheared_masks = mmcv.imshear(
+                self.masks.transpose((1, 2, 0)),
+                magnitude,
+                direction,
+                border_value=border_value,
+                interpolation=interpolation)
+            if sheared_masks.ndim == 2:
+                sheared_masks = sheared_masks[:, :, None]
+            sheared_masks = sheared_masks.transpose(
+                (2, 0, 1)).astype(self.masks.dtype)
+        return BitmapMasks(sheared_masks, *out_shape)
+
+    def rotate(self,
+               out_shape,
+               angle,
+               center=None,
+               scale=1.0,
+               border_value=0,
+               interpolation='bilinear'):
+        """Rotate the BitmapMasks.
+
+        Args:
+            out_shape (tuple[int]): Shape for output mask, format (h, w).
+            angle (int | float): Rotation angle in degrees. Positive values
+                mean counter-clockwise rotation.
+            center (tuple[float], optional): Center point (w, h) of the
+                rotation in source image. If not specified, the center of
+                the image will be used.
+            scale (int | float): Isotropic scale factor.
+            border_value (int | float): Border value. Default 0 for masks.
+            interpolation (str): Same as in :func:`mmcv.imrotate`.
+
+        Returns:
+            BitmapMasks: Rotated BitmapMasks.
+        """
+        if len(self.masks) == 0:
+            rotated_masks = np.empty((0, *out_shape), dtype=self.masks.dtype)
+        else:
+            rotated_masks = mmcv.imrotate(
+                self.masks.transpose((1, 2, 0)),
+                angle,
+                center=center,
+                scale=scale,
+                border_value=border_value,
+                interpolation=interpolation)
+            if rotated_masks.ndim == 2:
+                # case when only one mask, (h, w)
+                rotated_masks = rotated_masks[:, :, None]  # (h, w, 1)
+            rotated_masks = rotated_masks.transpose(
+                (2, 0, 1)).astype(self.masks.dtype)
+        return BitmapMasks(rotated_masks, *out_shape)
+
+    @property
+    def areas(self):
+        """See :py:attr:`BaseInstanceMasks.areas`."""
+        return self.masks.sum((1, 2))
+
+    def to_ndarray(self):
+        """See :func:`BaseInstanceMasks.to_ndarray`."""
+        return self.masks
+
+    def to_tensor(self, dtype, device):
+        """See :func:`BaseInstanceMasks.to_tensor`."""
+        return torch.tensor(self.masks, dtype=dtype, device=device)
+
+    @classmethod
+    def random(cls,
+               num_masks=3,
+               height=32,
+               width=32,
+               dtype=np.uint8,
+               rng=None):
+        """Generate random bitmap masks for demo / testing purposes.
+
+        Example:
+            >>> from mmdet.data_elements.mask.structures import BitmapMasks
+            >>> self = BitmapMasks.random()
+            >>> print('self = {}'.format(self))
+            self = BitmapMasks(num_masks=3, height=32, width=32)
+        """
+        from mmdet.utils.util_random import ensure_rng
+        rng = ensure_rng(rng)
+        masks = (rng.rand(num_masks, height, width) > 0.1).astype(dtype)
+        self = cls(masks, height=height, width=width)
+        return self
+
+    @classmethod
+    def cat(cls: Type[T], masks: Sequence[T]) -> T:
+        """Concatenate a sequence of masks into one single mask instance.
+
+        Args:
+            masks (Sequence[BitmapMasks]): A sequence of mask instances.
+
+        Returns:
+            BitmapMasks: Concatenated mask instance.
+        """
+        assert isinstance(masks, Sequence)
+        if len(masks) == 0:
+            raise ValueError('masks should not be an empty list.')
+        assert all(isinstance(m, cls) for m in masks)
+
+        mask_array = np.concatenate([m.masks for m in masks], axis=0)
+        return cls(mask_array, *mask_array.shape[1:])
+
+
+class PolygonMasks(BaseInstanceMasks):
+    """This class represents masks in the form of polygons.
+
+    Polygons is a list of three levels. The first level of the list
+    corresponds to objects, the second level to the polys that compose the
+    object, the third level to the poly coordinates
+
+    Args:
+        masks (list[list[ndarray]]): The first level of the list
+            corresponds to objects, the second level to the polys that
+            compose the object, the third level to the poly coordinates
+        height (int): height of masks
+        width (int): width of masks
+
+    Example:
+        >>> from mmdet.data_elements.mask.structures import *  # NOQA
+        >>> masks = [
+        >>>     [ np.array([0, 0, 10, 0, 10, 10., 0, 10, 0, 0]) ]
+        >>> ]
+        >>> height, width = 16, 16
+        >>> self = PolygonMasks(masks, height, width)
+
+        >>> # demo translate
+        >>> new = self.translate((16, 16), 4., direction='horizontal')
+        >>> assert np.all(new.masks[0][0][1::2] == masks[0][0][1::2])
+        >>> assert np.all(new.masks[0][0][0::2] == masks[0][0][0::2] + 4)
+
+        >>> # demo crop_and_resize
+        >>> num_boxes = 3
+        >>> bboxes = np.array([[0, 0, 30, 10.0]] * num_boxes)
+        >>> out_shape = (16, 16)
+        >>> inds = torch.randint(0, len(self), size=(num_boxes,))
+        >>> device = 'cpu'
+        >>> interpolation = 'bilinear'
+        >>> new = self.crop_and_resize(
+        ...     bboxes, out_shape, inds, device, interpolation)
+        >>> assert len(new) == num_boxes
+        >>> assert new.height, new.width == out_shape
+    """
+
+    def __init__(self, masks, height, width):
+        assert isinstance(masks, list)
+        if len(masks) > 0:
+            assert isinstance(masks[0], list)
+            assert isinstance(masks[0][0], np.ndarray)
+
+        self.height = height
+        self.width = width
+        self.masks = masks
+
+    def __getitem__(self, index):
+        """Index the polygon masks.
+
+        Args:
+            index (ndarray | List): The indices.
+
+        Returns:
+            :obj:`PolygonMasks`: The indexed polygon masks.
+        """
+        if isinstance(index, np.ndarray):
+            if index.dtype == bool:
+                index = np.where(index)[0].tolist()
+            else:
+                index = index.tolist()
+        if isinstance(index, list):
+            masks = [self.masks[i] for i in index]
+        else:
+            try:
+                masks = self.masks[index]
+            except Exception:
+                raise ValueError(
+                    f'Unsupported input of type {type(index)} for indexing!')
+        if len(masks) and isinstance(masks[0], np.ndarray):
+            masks = [masks]  # ensure a list of three levels
+        return PolygonMasks(masks, self.height, self.width)
+
+    def __iter__(self):
+        return iter(self.masks)
+
+    def __repr__(self):
+        s = self.__class__.__name__ + '('
+        s += f'num_masks={len(self.masks)}, '
+        s += f'height={self.height}, '
+        s += f'width={self.width})'
+        return s
+
+    def __len__(self):
+        """Number of masks."""
+        return len(self.masks)
+
+    def rescale(self, scale, interpolation=None):
+        """see :func:`BaseInstanceMasks.rescale`"""
+        new_w, new_h = mmcv.rescale_size((self.width, self.height), scale)
+        if len(self.masks) == 0:
+            rescaled_masks = PolygonMasks([], new_h, new_w)
+        else:
+            rescaled_masks = self.resize((new_h, new_w))
+        return rescaled_masks
+
+    def resize(self, out_shape, interpolation=None):
+        """see :func:`BaseInstanceMasks.resize`"""
+        if len(self.masks) == 0:
+            resized_masks = PolygonMasks([], *out_shape)
+        else:
+            h_scale = out_shape[0] / self.height
+            w_scale = out_shape[1] / self.width
+            resized_masks = []
+            for poly_per_obj in self.masks:
+                resized_poly = []
+                for p in poly_per_obj:
+                    p = p.copy()
+                    p[0::2] = p[0::2] * w_scale
+                    p[1::2] = p[1::2] * h_scale
+                    resized_poly.append(p)
+                resized_masks.append(resized_poly)
+            resized_masks = PolygonMasks(resized_masks, *out_shape)
+        return resized_masks
+
+    def flip(self, flip_direction='horizontal'):
+        """see :func:`BaseInstanceMasks.flip`"""
+        assert flip_direction in ('horizontal', 'vertical', 'diagonal')
+        if len(self.masks) == 0:
+            flipped_masks = PolygonMasks([], self.height, self.width)
+        else:
+            flipped_masks = []
+            for poly_per_obj in self.masks:
+                flipped_poly_per_obj = []
+                for p in poly_per_obj:
+                    p = p.copy()
+                    if flip_direction == 'horizontal':
+                        p[0::2] = self.width - p[0::2]
+                    elif flip_direction == 'vertical':
+                        p[1::2] = self.height - p[1::2]
+                    else:
+                        p[0::2] = self.width - p[0::2]
+                        p[1::2] = self.height - p[1::2]
+                    flipped_poly_per_obj.append(p)
+                flipped_masks.append(flipped_poly_per_obj)
+            flipped_masks = PolygonMasks(flipped_masks, self.height,
+                                         self.width)
+        return flipped_masks
+
+    def crop(self, bbox):
+        """see :func:`BaseInstanceMasks.crop`"""
+        assert isinstance(bbox, np.ndarray)
+        assert bbox.ndim == 1
+
+        # clip the boundary
+        bbox = bbox.copy()
+        bbox[0::2] = np.clip(bbox[0::2], 0, self.width)
+        bbox[1::2] = np.clip(bbox[1::2], 0, self.height)
+        x1, y1, x2, y2 = bbox
+        w = np.maximum(x2 - x1, 1)
+        h = np.maximum(y2 - y1, 1)
+
+        if len(self.masks) == 0:
+            cropped_masks = PolygonMasks([], h, w)
+        else:
+            # reference: https://github.com/facebookresearch/fvcore/blob/main/fvcore/transforms/transform.py  # noqa
+            crop_box = geometry.box(x1, y1, x2, y2).buffer(0.0)
+            cropped_masks = []
+            # suppress shapely warnings util it incorporates GEOS>=3.11.2
+            # reference: https://github.com/shapely/shapely/issues/1345
+            initial_settings = np.seterr()
+            np.seterr(invalid='ignore')
+            for poly_per_obj in self.masks:
+                cropped_poly_per_obj = []
+                for p in poly_per_obj:
+                    p = p.copy()
+                    p = geometry.Polygon(p.reshape(-1, 2)).buffer(0.0)
+                    # polygon must be valid to perform intersection.
+                    if not p.is_valid:
+                        continue
+                    cropped = p.intersection(crop_box)
+                    if cropped.is_empty:
+                        continue
+                    if isinstance(cropped,
+                                  geometry.collection.BaseMultipartGeometry):
+                        cropped = cropped.geoms
+                    else:
+                        cropped = [cropped]
+                    # one polygon may be cropped to multiple ones
+                    for poly in cropped:
+                        # ignore lines or points
+                        if not isinstance(
+                                poly, geometry.Polygon) or not poly.is_valid:
+                            continue
+                        coords = np.asarray(poly.exterior.coords)
+                        # remove an extra identical vertex at the end
+                        coords = coords[:-1]
+                        coords[:, 0] -= x1
+                        coords[:, 1] -= y1
+                        cropped_poly_per_obj.append(coords.reshape(-1))
+                # a dummy polygon to avoid misalignment between masks and boxes
+                if len(cropped_poly_per_obj) == 0:
+                    cropped_poly_per_obj = [np.array([0, 0, 0, 0, 0, 0])]
+                cropped_masks.append(cropped_poly_per_obj)
+            np.seterr(**initial_settings)
+            cropped_masks = PolygonMasks(cropped_masks, h, w)
+        return cropped_masks
+
+    def pad(self, out_shape, pad_val=0):
+        """padding has no effect on polygons`"""
+        return PolygonMasks(self.masks, *out_shape)
+
+    def expand(self, *args, **kwargs):
+        """TODO: Add expand for polygon"""
+        raise NotImplementedError
+
+    def crop_and_resize(self,
+                        bboxes,
+                        out_shape,
+                        inds,
+                        device='cpu',
+                        interpolation='bilinear',
+                        binarize=True):
+        """see :func:`BaseInstanceMasks.crop_and_resize`"""
+        out_h, out_w = out_shape
+        if len(self.masks) == 0:
+            return PolygonMasks([], out_h, out_w)
+
+        if not binarize:
+            raise ValueError('Polygons are always binary, '
+                             'setting binarize=False is unsupported')
+
+        resized_masks = []
+        for i in range(len(bboxes)):
+            mask = self.masks[inds[i]]
+            bbox = bboxes[i, :]
+            x1, y1, x2, y2 = bbox
+            w = np.maximum(x2 - x1, 1)
+            h = np.maximum(y2 - y1, 1)
+            h_scale = out_h / max(h, 0.1)  # avoid too large scale
+            w_scale = out_w / max(w, 0.1)
+
+            resized_mask = []
+            for p in mask:
+                p = p.copy()
+                # crop
+                # pycocotools will clip the boundary
+                p[0::2] = p[0::2] - bbox[0]
+                p[1::2] = p[1::2] - bbox[1]
+
+                # resize
+                p[0::2] = p[0::2] * w_scale
+                p[1::2] = p[1::2] * h_scale
+                resized_mask.append(p)
+            resized_masks.append(resized_mask)
+        return PolygonMasks(resized_masks, *out_shape)
+
+    def translate(self,
+                  out_shape,
+                  offset,
+                  direction='horizontal',
+                  border_value=None,
+                  interpolation=None):
+        """Translate the PolygonMasks.
+
+        Example:
+            >>> self = PolygonMasks.random(dtype=np.int64)
+            >>> out_shape = (self.height, self.width)
+            >>> new = self.translate(out_shape, 4., direction='horizontal')
+            >>> assert np.all(new.masks[0][0][1::2] == self.masks[0][0][1::2])
+            >>> assert np.all(new.masks[0][0][0::2] == self.masks[0][0][0::2] + 4)  # noqa: E501
+        """
+        assert border_value is None or border_value == 0, \
+            'Here border_value is not '\
+            f'used, and defaultly should be None or 0. got {border_value}.'
+        if len(self.masks) == 0:
+            translated_masks = PolygonMasks([], *out_shape)
+        else:
+            translated_masks = []
+            for poly_per_obj in self.masks:
+                translated_poly_per_obj = []
+                for p in poly_per_obj:
+                    p = p.copy()
+                    if direction == 'horizontal':
+                        p[0::2] = np.clip(p[0::2] + offset, 0, out_shape[1])
+                    elif direction == 'vertical':
+                        p[1::2] = np.clip(p[1::2] + offset, 0, out_shape[0])
+                    translated_poly_per_obj.append(p)
+                translated_masks.append(translated_poly_per_obj)
+            translated_masks = PolygonMasks(translated_masks, *out_shape)
+        return translated_masks
+
+    def shear(self,
+              out_shape,
+              magnitude,
+              direction='horizontal',
+              border_value=0,
+              interpolation='bilinear'):
+        """See :func:`BaseInstanceMasks.shear`."""
+        if len(self.masks) == 0:
+            sheared_masks = PolygonMasks([], *out_shape)
+        else:
+            sheared_masks = []
+            if direction == 'horizontal':
+                shear_matrix = np.stack([[1, magnitude],
+                                         [0, 1]]).astype(np.float32)
+            elif direction == 'vertical':
+                shear_matrix = np.stack([[1, 0], [magnitude,
+                                                  1]]).astype(np.float32)
+            for poly_per_obj in self.masks:
+                sheared_poly = []
+                for p in poly_per_obj:
+                    p = np.stack([p[0::2], p[1::2]], axis=0)  # [2, n]
+                    new_coords = np.matmul(shear_matrix, p)  # [2, n]
+                    new_coords[0, :] = np.clip(new_coords[0, :], 0,
+                                               out_shape[1])
+                    new_coords[1, :] = np.clip(new_coords[1, :], 0,
+                                               out_shape[0])
+                    sheared_poly.append(
+                        new_coords.transpose((1, 0)).reshape(-1))
+                sheared_masks.append(sheared_poly)
+            sheared_masks = PolygonMasks(sheared_masks, *out_shape)
+        return sheared_masks
+
+    def rotate(self,
+               out_shape,
+               angle,
+               center=None,
+               scale=1.0,
+               border_value=0,
+               interpolation='bilinear'):
+        """See :func:`BaseInstanceMasks.rotate`."""
+        if len(self.masks) == 0:
+            rotated_masks = PolygonMasks([], *out_shape)
+        else:
+            rotated_masks = []
+            rotate_matrix = cv2.getRotationMatrix2D(center, -angle, scale)
+            for poly_per_obj in self.masks:
+                rotated_poly = []
+                for p in poly_per_obj:
+                    p = p.copy()
+                    coords = np.stack([p[0::2], p[1::2]], axis=1)  # [n, 2]
+                    # pad 1 to convert from format [x, y] to homogeneous
+                    # coordinates format [x, y, 1]
+                    coords = np.concatenate(
+                        (coords, np.ones((coords.shape[0], 1), coords.dtype)),
+                        axis=1)  # [n, 3]
+                    rotated_coords = np.matmul(
+                        rotate_matrix[None, :, :],
+                        coords[:, :, None])[..., 0]  # [n, 2, 1] -> [n, 2]
+                    rotated_coords[:, 0] = np.clip(rotated_coords[:, 0], 0,
+                                                   out_shape[1])
+                    rotated_coords[:, 1] = np.clip(rotated_coords[:, 1], 0,
+                                                   out_shape[0])
+                    rotated_poly.append(rotated_coords.reshape(-1))
+                rotated_masks.append(rotated_poly)
+            rotated_masks = PolygonMasks(rotated_masks, *out_shape)
+        return rotated_masks
+
+    def to_bitmap(self):
+        """convert polygon masks to bitmap masks."""
+        bitmap_masks = self.to_ndarray()
+        return BitmapMasks(bitmap_masks, self.height, self.width)
+
+    @property
+    def areas(self):
+        """Compute areas of masks.
+
+        This func is modified from `detectron2
+        `_.
+        The function only works with Polygons using the shoelace formula.
+
+        Return:
+            ndarray: areas of each instance
+        """  # noqa: W501
+        area = []
+        for polygons_per_obj in self.masks:
+            area_per_obj = 0
+            for p in polygons_per_obj:
+                area_per_obj += self._polygon_area(p[0::2], p[1::2])
+            area.append(area_per_obj)
+        return np.asarray(area)
+
+    def _polygon_area(self, x, y):
+        """Compute the area of a component of a polygon.
+
+        Using the shoelace formula:
+        https://stackoverflow.com/questions/24467972/calculate-area-of-polygon-given-x-y-coordinates
+
+        Args:
+            x (ndarray): x coordinates of the component
+            y (ndarray): y coordinates of the component
+
+        Return:
+            float: the are of the component
+        """  # noqa: 501
+        return 0.5 * np.abs(
+            np.dot(x, np.roll(y, 1)) - np.dot(y, np.roll(x, 1)))
+
+    def to_ndarray(self):
+        """Convert masks to the format of ndarray."""
+        if len(self.masks) == 0:
+            return np.empty((0, self.height, self.width), dtype=np.uint8)
+        bitmap_masks = []
+        for poly_per_obj in self.masks:
+            bitmap_masks.append(
+                polygon_to_bitmap(poly_per_obj, self.height, self.width))
+        return np.stack(bitmap_masks)
+
+    def to_tensor(self, dtype, device):
+        """See :func:`BaseInstanceMasks.to_tensor`."""
+        if len(self.masks) == 0:
+            return torch.empty((0, self.height, self.width),
+                               dtype=dtype,
+                               device=device)
+        ndarray_masks = self.to_ndarray()
+        return torch.tensor(ndarray_masks, dtype=dtype, device=device)
+
+    @classmethod
+    def random(cls,
+               num_masks=3,
+               height=32,
+               width=32,
+               n_verts=5,
+               dtype=np.float32,
+               rng=None):
+        """Generate random polygon masks for demo / testing purposes.
+
+        Adapted from [1]_
+
+        References:
+            .. [1] https://gitlab.kitware.com/computer-vision/kwimage/-/blob/928cae35ca8/kwimage/structs/polygon.py#L379  # noqa: E501
+
+        Example:
+            >>> from mmdet.data_elements.mask.structures import PolygonMasks
+            >>> self = PolygonMasks.random()
+            >>> print('self = {}'.format(self))
+        """
+        from mmdet.utils.util_random import ensure_rng
+        rng = ensure_rng(rng)
+
+        def _gen_polygon(n, irregularity, spikeyness):
+            """Creates the polygon by sampling points on a circle around the
+            centre.  Random noise is added by varying the angular spacing
+            between sequential points, and by varying the radial distance of
+            each point from the centre.
+
+            Based on original code by Mike Ounsworth
+
+            Args:
+                n (int): number of vertices
+                irregularity (float): [0,1] indicating how much variance there
+                    is in the angular spacing of vertices. [0,1] will map to
+                    [0, 2pi/numberOfVerts]
+                spikeyness (float): [0,1] indicating how much variance there is
+                    in each vertex from the circle of radius aveRadius. [0,1]
+                    will map to [0, aveRadius]
+
+            Returns:
+                a list of vertices, in CCW order.
+            """
+            from scipy.stats import truncnorm
+
+            # Generate around the unit circle
+            cx, cy = (0.0, 0.0)
+            radius = 1
+
+            tau = np.pi * 2
+
+            irregularity = np.clip(irregularity, 0, 1) * 2 * np.pi / n
+            spikeyness = np.clip(spikeyness, 1e-9, 1)
+
+            # generate n angle steps
+            lower = (tau / n) - irregularity
+            upper = (tau / n) + irregularity
+            angle_steps = rng.uniform(lower, upper, n)
+
+            # normalize the steps so that point 0 and point n+1 are the same
+            k = angle_steps.sum() / (2 * np.pi)
+            angles = (angle_steps / k).cumsum() + rng.uniform(0, tau)
+
+            # Convert high and low values to be wrt the standard normal range
+            # https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.truncnorm.html
+            low = 0
+            high = 2 * radius
+            mean = radius
+            std = spikeyness
+            a = (low - mean) / std
+            b = (high - mean) / std
+            tnorm = truncnorm(a=a, b=b, loc=mean, scale=std)
+
+            # now generate the points
+            radii = tnorm.rvs(n, random_state=rng)
+            x_pts = cx + radii * np.cos(angles)
+            y_pts = cy + radii * np.sin(angles)
+
+            points = np.hstack([x_pts[:, None], y_pts[:, None]])
+
+            # Scale to 0-1 space
+            points = points - points.min(axis=0)
+            points = points / points.max(axis=0)
+
+            # Randomly place within 0-1 space
+            points = points * (rng.rand() * .8 + .2)
+            min_pt = points.min(axis=0)
+            max_pt = points.max(axis=0)
+
+            high = (1 - max_pt)
+            low = (0 - min_pt)
+            offset = (rng.rand(2) * (high - low)) + low
+            points = points + offset
+            return points
+
+        def _order_vertices(verts):
+            """
+            References:
+                https://stackoverflow.com/questions/1709283/how-can-i-sort-a-coordinate-list-for-a-rectangle-counterclockwise
+            """
+            mlat = verts.T[0].sum() / len(verts)
+            mlng = verts.T[1].sum() / len(verts)
+
+            tau = np.pi * 2
+            angle = (np.arctan2(mlat - verts.T[0], verts.T[1] - mlng) +
+                     tau) % tau
+            sortx = angle.argsort()
+            verts = verts.take(sortx, axis=0)
+            return verts
+
+        # Generate a random exterior for each requested mask
+        masks = []
+        for _ in range(num_masks):
+            exterior = _order_vertices(_gen_polygon(n_verts, 0.9, 0.9))
+            exterior = (exterior * [(width, height)]).astype(dtype)
+            masks.append([exterior.ravel()])
+
+        self = cls(masks, height, width)
+        return self
+
+    @classmethod
+    def cat(cls: Type[T], masks: Sequence[T]) -> T:
+        """Concatenate a sequence of masks into one single mask instance.
+
+        Args:
+            masks (Sequence[PolygonMasks]): A sequence of mask instances.
+
+        Returns:
+            PolygonMasks: Concatenated mask instance.
+        """
+        assert isinstance(masks, Sequence)
+        if len(masks) == 0:
+            raise ValueError('masks should not be an empty list.')
+        assert all(isinstance(m, cls) for m in masks)
+
+        mask_list = list(itertools.chain(*[m.masks for m in masks]))
+        return cls(mask_list, masks[0].height, masks[0].width)
+
+
+def polygon_to_bitmap(polygons, height, width):
+    """Convert masks from the form of polygons to bitmaps.
+
+    Args:
+        polygons (list[ndarray]): masks in polygon representation
+        height (int): mask height
+        width (int): mask width
+
+    Return:
+        ndarray: the converted masks in bitmap representation
+    """
+    rles = maskUtils.frPyObjects(polygons, height, width)
+    rle = maskUtils.merge(rles)
+    bitmap_mask = maskUtils.decode(rle).astype(bool)
+    return bitmap_mask
+
+
+def bitmap_to_polygon(bitmap):
+    """Convert masks from the form of bitmaps to polygons.
+
+    Args:
+        bitmap (ndarray): masks in bitmap representation.
+
+    Return:
+        list[ndarray]: the converted mask in polygon representation.
+        bool: whether the mask has holes.
+    """
+    bitmap = np.ascontiguousarray(bitmap).astype(np.uint8)
+    # cv2.RETR_CCOMP: retrieves all of the contours and organizes them
+    #   into a two-level hierarchy. At the top level, there are external
+    #   boundaries of the components. At the second level, there are
+    #   boundaries of the holes. If there is another contour inside a hole
+    #   of a connected component, it is still put at the top level.
+    # cv2.CHAIN_APPROX_NONE: stores absolutely all the contour points.
+    outs = cv2.findContours(bitmap, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)
+    contours = outs[-2]
+    hierarchy = outs[-1]
+    if hierarchy is None:
+        return [], False
+    # hierarchy[i]: 4 elements, for the indexes of next, previous,
+    # parent, or nested contours. If there is no corresponding contour,
+    # it will be -1.
+    with_hole = (hierarchy.reshape(-1, 4)[:, 3] >= 0).any()
+    contours = [c.reshape(-1, 2) for c in contours]
+    return contours, with_hole
diff --git a/mmdetection/mmdet/structures/mask/utils.py b/mmdetection/mmdet/structures/mask/utils.py
new file mode 100644
index 00000000..6bd445e4
--- /dev/null
+++ b/mmdetection/mmdet/structures/mask/utils.py
@@ -0,0 +1,77 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import numpy as np
+import pycocotools.mask as mask_util
+import torch
+from mmengine.utils import slice_list
+
+
+def split_combined_polys(polys, poly_lens, polys_per_mask):
+    """Split the combined 1-D polys into masks.
+
+    A mask is represented as a list of polys, and a poly is represented as
+    a 1-D array. In dataset, all masks are concatenated into a single 1-D
+    tensor. Here we need to split the tensor into original representations.
+
+    Args:
+        polys (list): a list (length = image num) of 1-D tensors
+        poly_lens (list): a list (length = image num) of poly length
+        polys_per_mask (list): a list (length = image num) of poly number
+            of each mask
+
+    Returns:
+        list: a list (length = image num) of list (length = mask num) of \
+            list (length = poly num) of numpy array.
+    """
+    mask_polys_list = []
+    for img_id in range(len(polys)):
+        polys_single = polys[img_id]
+        polys_lens_single = poly_lens[img_id].tolist()
+        polys_per_mask_single = polys_per_mask[img_id].tolist()
+
+        split_polys = slice_list(polys_single, polys_lens_single)
+        mask_polys = slice_list(split_polys, polys_per_mask_single)
+        mask_polys_list.append(mask_polys)
+    return mask_polys_list
+
+
+# TODO: move this function to more proper place
+def encode_mask_results(mask_results):
+    """Encode bitmap mask to RLE code.
+
+    Args:
+        mask_results (list): bitmap mask results.
+
+    Returns:
+        list | tuple: RLE encoded mask.
+    """
+    encoded_mask_results = []
+    for mask in mask_results:
+        encoded_mask_results.append(
+            mask_util.encode(
+                np.array(mask[:, :, np.newaxis], order='F',
+                         dtype='uint8'))[0])  # encoded with RLE
+    return encoded_mask_results
+
+
+def mask2bbox(masks):
+    """Obtain tight bounding boxes of binary masks.
+
+    Args:
+        masks (Tensor): Binary mask of shape (n, h, w).
+
+    Returns:
+        Tensor: Bboxe with shape (n, 4) of \
+            positive region in binary mask.
+    """
+    N = masks.shape[0]
+    bboxes = masks.new_zeros((N, 4), dtype=torch.float32)
+    x_any = torch.any(masks, dim=1)
+    y_any = torch.any(masks, dim=2)
+    for i in range(N):
+        x = torch.where(x_any[i, :])[0]
+        y = torch.where(y_any[i, :])[0]
+        if len(x) > 0 and len(y) > 0:
+            bboxes[i, :] = bboxes.new_tensor(
+                [x[0], y[0], x[-1] + 1, y[-1] + 1])
+
+    return bboxes
diff --git a/mmdetection/mmdet/structures/reid_data_sample.py b/mmdetection/mmdet/structures/reid_data_sample.py
new file mode 100644
index 00000000..69958eec
--- /dev/null
+++ b/mmdetection/mmdet/structures/reid_data_sample.py
@@ -0,0 +1,123 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from numbers import Number
+from typing import Sequence, Union
+
+import mmengine
+import numpy as np
+import torch
+from mmengine.structures import BaseDataElement, LabelData
+
+
+def format_label(value: Union[torch.Tensor, np.ndarray, Sequence, int],
+                 num_classes: int = None) -> LabelData:
+    """Convert label of various python types to :obj:`mmengine.LabelData`.
+
+    Supported types are: :class:`numpy.ndarray`, :class:`torch.Tensor`,
+    :class:`Sequence`, :class:`int`.
+
+    Args:
+        value (torch.Tensor | numpy.ndarray | Sequence | int): Label value.
+        num_classes (int, optional): The number of classes. If not None, set
+            it to the metainfo. Defaults to None.
+
+    Returns:
+        :obj:`mmengine.LabelData`: The foramtted label data.
+    """
+
+    # Handle single number
+    if isinstance(value, (torch.Tensor, np.ndarray)) and value.ndim == 0:
+        value = int(value.item())
+
+    if isinstance(value, np.ndarray):
+        value = torch.from_numpy(value)
+    elif isinstance(value, Sequence) and not mmengine.utils.is_str(value):
+        value = torch.tensor(value)
+    elif isinstance(value, int):
+        value = torch.LongTensor([value])
+    elif not isinstance(value, torch.Tensor):
+        raise TypeError(f'Type {type(value)} is not an available label type.')
+
+    metainfo = {}
+    if num_classes is not None:
+        metainfo['num_classes'] = num_classes
+        if value.max() >= num_classes:
+            raise ValueError(f'The label data ({value}) should not '
+                             f'exceed num_classes ({num_classes}).')
+    label = LabelData(label=value, metainfo=metainfo)
+    return label
+
+
+class ReIDDataSample(BaseDataElement):
+    """A data structure interface of ReID task.
+
+    It's used as interfaces between different components.
+
+    Meta field:
+        img_shape (Tuple): The shape of the corresponding input image.
+            Used for visualization.
+        ori_shape (Tuple): The original shape of the corresponding image.
+            Used for visualization.
+        num_classes (int): The number of all categories.
+            Used for label format conversion.
+
+    Data field:
+        gt_label (LabelData): The ground truth label.
+        pred_label (LabelData): The predicted label.
+        scores (torch.Tensor): The outputs of model.
+    """
+
+    @property
+    def gt_label(self):
+        return self._gt_label
+
+    @gt_label.setter
+    def gt_label(self, value: LabelData):
+        self.set_field(value, '_gt_label', dtype=LabelData)
+
+    @gt_label.deleter
+    def gt_label(self):
+        del self._gt_label
+
+    def set_gt_label(
+        self, value: Union[np.ndarray, torch.Tensor, Sequence[Number], Number]
+    ) -> 'ReIDDataSample':
+        """Set label of ``gt_label``."""
+        label = format_label(value, self.get('num_classes'))
+        if 'gt_label' in self:  # setting for the second time
+            self.gt_label.label = label.label
+        else:  # setting for the first time
+            self.gt_label = label
+        return self
+
+    def set_gt_score(self, value: torch.Tensor) -> 'ReIDDataSample':
+        """Set score of ``gt_label``."""
+        assert isinstance(value, torch.Tensor), \
+            f'The value should be a torch.Tensor but got {type(value)}.'
+        assert value.ndim == 1, \
+            f'The dims of value should be 1, but got {value.ndim}.'
+
+        if 'num_classes' in self:
+            assert value.size(0) == self.num_classes, \
+                f"The length of value ({value.size(0)}) doesn't "\
+                f'match the num_classes ({self.num_classes}).'
+            metainfo = {'num_classes': self.num_classes}
+        else:
+            metainfo = {'num_classes': value.size(0)}
+
+        if 'gt_label' in self:  # setting for the second time
+            self.gt_label.score = value
+        else:  # setting for the first time
+            self.gt_label = LabelData(score=value, metainfo=metainfo)
+        return self
+
+    @property
+    def pred_feature(self):
+        return self._pred_feature
+
+    @pred_feature.setter
+    def pred_feature(self, value: torch.Tensor):
+        self.set_field(value, '_pred_feature', dtype=torch.Tensor)
+
+    @pred_feature.deleter
+    def pred_feature(self):
+        del self._pred_feature
diff --git a/mmdetection/mmdet/structures/track_data_sample.py b/mmdetection/mmdet/structures/track_data_sample.py
new file mode 100644
index 00000000..d005a5a4
--- /dev/null
+++ b/mmdetection/mmdet/structures/track_data_sample.py
@@ -0,0 +1,273 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Sequence
+
+import numpy as np
+import torch
+from mmengine.structures import BaseDataElement
+
+from .det_data_sample import DetDataSample
+
+
+class TrackDataSample(BaseDataElement):
+    """A data structure interface of tracking task in MMDetection. It is used
+    as interfaces between different components.
+
+    This data structure can be viewd as a wrapper of multiple DetDataSample to
+    some extent. Specifically, it only contains a property:
+    ``video_data_samples`` which is a list of DetDataSample, each of which
+    corresponds to a single frame. If you want to get the property of a single
+    frame, you must first get the corresponding ``DetDataSample`` by indexing
+    and then get the property of the frame, such as ``gt_instances``,
+    ``pred_instances`` and so on. As for metainfo, it differs from
+    ``DetDataSample`` in that each value corresponds to the metainfo key is a
+    list where each element corresponds to information of a single frame.
+
+    Examples:
+        >>> import torch
+        >>> from mmengine.structures import InstanceData
+        >>> from mmdet.structures import DetDataSample, TrackDataSample
+        >>> track_data_sample = TrackDataSample()
+        >>> # set the 1st frame
+        >>> frame1_data_sample = DetDataSample(metainfo=dict(
+        ...         img_shape=(100, 100), frame_id=0))
+        >>> frame1_gt_instances = InstanceData()
+        >>> frame1_gt_instances.bbox = torch.zeros([2, 4])
+        >>> frame1_data_sample.gt_instances = frame1_gt_instances
+        >>> # set the 2nd frame
+        >>> frame2_data_sample = DetDataSample(metainfo=dict(
+        ...         img_shape=(100, 100), frame_id=1))
+        >>> frame2_gt_instances = InstanceData()
+        >>> frame2_gt_instances.bbox = torch.ones([3, 4])
+        >>> frame2_data_sample.gt_instances = frame2_gt_instances
+        >>> track_data_sample.video_data_samples = [frame1_data_sample,
+        ...                                         frame2_data_sample]
+        >>> # set metainfo for track_data_sample
+        >>> track_data_sample.set_metainfo(dict(key_frames_inds=[0]))
+        >>> track_data_sample.set_metainfo(dict(ref_frames_inds=[1]))
+        >>> print(track_data_sample)
+        
+                ) at 0x7f64bd223340>, 
+                ) at 0x7f64bd1346d0>]
+        ) at 0x7f64bd2237f0>
+        >>> print(len(track_data_sample))
+        2
+        >>> key_data_sample = track_data_sample.get_key_frames()
+        >>> print(key_data_sample[0].frame_id)
+        0
+        >>> ref_data_sample = track_data_sample.get_ref_frames()
+        >>> print(ref_data_sample[0].frame_id)
+        1
+        >>> frame1_data_sample = track_data_sample[0]
+        >>> print(frame1_data_sample.gt_instances.bbox)
+        tensor([[0., 0., 0., 0.],
+                [0., 0., 0., 0.]])
+        >>> # Tensor-like methods
+        >>> cuda_track_data_sample = track_data_sample.to('cuda')
+        >>> cuda_track_data_sample = track_data_sample.cuda()
+        >>> cpu_track_data_sample = track_data_sample.cpu()
+        >>> cpu_track_data_sample = track_data_sample.to('cpu')
+        >>> fp16_instances = cuda_track_data_sample.to(
+        ...     device=None, dtype=torch.float16, non_blocking=False,
+        ...     copy=False, memory_format=torch.preserve_format)
+    """
+
+    @property
+    def video_data_samples(self) -> List[DetDataSample]:
+        return self._video_data_samples
+
+    @video_data_samples.setter
+    def video_data_samples(self, value: List[DetDataSample]):
+        if isinstance(value, DetDataSample):
+            value = [value]
+        assert isinstance(value, list), 'video_data_samples must be a list'
+        assert isinstance(
+            value[0], DetDataSample
+        ), 'video_data_samples must be a list of DetDataSample, but got '
+        f'{value[0]}'
+        self.set_field(value, '_video_data_samples', dtype=list)
+
+    @video_data_samples.deleter
+    def video_data_samples(self):
+        del self._video_data_samples
+
+    def __getitem__(self, index):
+        assert hasattr(self,
+                       '_video_data_samples'), 'video_data_samples not set'
+        return self._video_data_samples[index]
+
+    def get_key_frames(self):
+        assert hasattr(self, 'key_frames_inds'), \
+            'key_frames_inds not set'
+        assert isinstance(self.key_frames_inds, Sequence)
+        key_frames_info = []
+        for index in self.key_frames_inds:
+            key_frames_info.append(self[index])
+        return key_frames_info
+
+    def get_ref_frames(self):
+        assert hasattr(self, 'ref_frames_inds'), \
+            'ref_frames_inds not set'
+        ref_frames_info = []
+        assert isinstance(self.ref_frames_inds, Sequence)
+        for index in self.ref_frames_inds:
+            ref_frames_info.append(self[index])
+        return ref_frames_info
+
+    def __len__(self):
+        return len(self._video_data_samples) if hasattr(
+            self, '_video_data_samples') else 0
+
+    # TODO: add UT for this Tensor-like method
+    # Tensor-like methods
+    def to(self, *args, **kwargs) -> 'BaseDataElement':
+        """Apply same name function to all tensors in data_fields."""
+        new_data = self.new()
+        for k, v_list in self.items():
+            data_list = []
+            for v in v_list:
+                if hasattr(v, 'to'):
+                    v = v.to(*args, **kwargs)
+                    data_list.append(v)
+            if len(data_list) > 0:
+                new_data.set_data({f'{k}': data_list})
+        return new_data
+
+    # Tensor-like methods
+    def cpu(self) -> 'BaseDataElement':
+        """Convert all tensors to CPU in data."""
+        new_data = self.new()
+        for k, v_list in self.items():
+            data_list = []
+            for v in v_list:
+                if isinstance(v, (torch.Tensor, BaseDataElement)):
+                    v = v.cpu()
+                    data_list.append(v)
+            if len(data_list) > 0:
+                new_data.set_data({f'{k}': data_list})
+        return new_data
+
+    # Tensor-like methods
+    def cuda(self) -> 'BaseDataElement':
+        """Convert all tensors to GPU in data."""
+        new_data = self.new()
+        for k, v_list in self.items():
+            data_list = []
+            for v in v_list:
+                if isinstance(v, (torch.Tensor, BaseDataElement)):
+                    v = v.cuda()
+                    data_list.append(v)
+            if len(data_list) > 0:
+                new_data.set_data({f'{k}': data_list})
+        return new_data
+
+    # Tensor-like methods
+    def npu(self) -> 'BaseDataElement':
+        """Convert all tensors to NPU in data."""
+        new_data = self.new()
+        for k, v_list in self.items():
+            data_list = []
+            for v in v_list:
+                if isinstance(v, (torch.Tensor, BaseDataElement)):
+                    v = v.npu()
+                    data_list.append(v)
+            if len(data_list) > 0:
+                new_data.set_data({f'{k}': data_list})
+        return new_data
+
+    # Tensor-like methods
+    def detach(self) -> 'BaseDataElement':
+        """Detach all tensors in data."""
+        new_data = self.new()
+        for k, v_list in self.items():
+            data_list = []
+            for v in v_list:
+                if isinstance(v, (torch.Tensor, BaseDataElement)):
+                    v = v.detach()
+                    data_list.append(v)
+            if len(data_list) > 0:
+                new_data.set_data({f'{k}': data_list})
+        return new_data
+
+    # Tensor-like methods
+    def numpy(self) -> 'BaseDataElement':
+        """Convert all tensors to np.ndarray in data."""
+        new_data = self.new()
+        for k, v_list in self.items():
+            data_list = []
+            for v in v_list:
+                if isinstance(v, (torch.Tensor, BaseDataElement)):
+                    v = v.detach().cpu().numpy()
+                    data_list.append(v)
+            if len(data_list) > 0:
+                new_data.set_data({f'{k}': data_list})
+        return new_data
+
+    def to_tensor(self) -> 'BaseDataElement':
+        """Convert all np.ndarray to tensor in data."""
+        new_data = self.new()
+        for k, v_list in self.items():
+            data_list = []
+            for v in v_list:
+                if isinstance(v, np.ndarray):
+                    v = torch.from_numpy(v)
+                elif isinstance(v, BaseDataElement):
+                    v = v.to_tensor()
+                data_list.append(v)
+            if len(data_list) > 0:
+                new_data.set_data({f'{k}': data_list})
+        return new_data
+
+    # Tensor-like methods
+    def clone(self) -> 'BaseDataElement':
+        """Deep copy the current data element.
+
+        Returns:
+            BaseDataElement: The copy of current data element.
+        """
+        clone_data = self.__class__()
+        clone_data.set_metainfo(dict(self.metainfo_items()))
+
+        for k, v_list in self.items():
+            clone_item_list = []
+            for v in v_list:
+                clone_item_list.append(v.clone())
+            clone_data.set_data({k: clone_item_list})
+        return clone_data
+
+
+TrackSampleList = List[TrackDataSample]
+OptTrackSampleList = Optional[TrackSampleList]
diff --git a/mmdetection/mmdet/testing/__init__.py b/mmdetection/mmdet/testing/__init__.py
new file mode 100644
index 00000000..766fb471
--- /dev/null
+++ b/mmdetection/mmdet/testing/__init__.py
@@ -0,0 +1,12 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from ._fast_stop_training_hook import FastStopTrainingHook  # noqa: F401,F403
+from ._utils import (demo_mm_inputs, demo_mm_proposals,
+                     demo_mm_sampling_results, demo_track_inputs,
+                     get_detector_cfg, get_roi_head_cfg, random_boxes,
+                     replace_to_ceph)
+
+__all__ = [
+    'demo_mm_inputs', 'get_detector_cfg', 'get_roi_head_cfg',
+    'demo_mm_proposals', 'demo_mm_sampling_results', 'replace_to_ceph',
+    'demo_track_inputs', 'VideoDataSampleFeeder', 'random_boxes'
+]
diff --git a/mmdetection/mmdet/testing/_fast_stop_training_hook.py b/mmdetection/mmdet/testing/_fast_stop_training_hook.py
new file mode 100644
index 00000000..f8e3d114
--- /dev/null
+++ b/mmdetection/mmdet/testing/_fast_stop_training_hook.py
@@ -0,0 +1,27 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.hooks import Hook
+
+from mmdet.registry import HOOKS
+
+
+@HOOKS.register_module()
+class FastStopTrainingHook(Hook):
+    """Set runner's epoch information to the model."""
+
+    def __init__(self, by_epoch, save_ckpt=False, stop_iter_or_epoch=5):
+        self.by_epoch = by_epoch
+        self.save_ckpt = save_ckpt
+        self.stop_iter_or_epoch = stop_iter_or_epoch
+
+    def after_train_iter(self, runner, batch_idx: int, data_batch: None,
+                         outputs: None) -> None:
+        if self.save_ckpt and self.by_epoch:
+            # If it is epoch-based and want to save weights,
+            # we must run at least 1 epoch.
+            return
+        if runner.iter >= self.stop_iter_or_epoch:
+            raise RuntimeError('quick exit')
+
+    def after_train_epoch(self, runner) -> None:
+        if runner.epoch >= self.stop_iter_or_epoch - 1:
+            raise RuntimeError('quick exit')
diff --git a/mmdetection/mmdet/testing/_utils.py b/mmdetection/mmdet/testing/_utils.py
new file mode 100644
index 00000000..c4d3a86d
--- /dev/null
+++ b/mmdetection/mmdet/testing/_utils.py
@@ -0,0 +1,469 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+from os.path import dirname, exists, join
+
+import numpy as np
+import torch
+from mmengine.config import Config
+from mmengine.dataset import pseudo_collate
+from mmengine.structures import InstanceData, PixelData
+
+from mmdet.utils.util_random import ensure_rng
+from ..registry import TASK_UTILS
+from ..structures import DetDataSample, TrackDataSample
+from ..structures.bbox import HorizontalBoxes
+
+
+def _get_config_directory():
+    """Find the predefined detector config directory."""
+    try:
+        # Assume we are running in the source mmdetection repo
+        repo_dpath = dirname(dirname(dirname(__file__)))
+    except NameError:
+        # For IPython development when this __file__ is not defined
+        import mmdet
+        repo_dpath = dirname(dirname(mmdet.__file__))
+    config_dpath = join(repo_dpath, 'configs')
+    if not exists(config_dpath):
+        raise Exception('Cannot find config path')
+    return config_dpath
+
+
+def _get_config_module(fname):
+    """Load a configuration as a python module."""
+    config_dpath = _get_config_directory()
+    config_fpath = join(config_dpath, fname)
+    config_mod = Config.fromfile(config_fpath)
+    return config_mod
+
+
+def get_detector_cfg(fname):
+    """Grab configs necessary to create a detector.
+
+    These are deep copied to allow for safe modification of parameters without
+    influencing other tests.
+    """
+    config = _get_config_module(fname)
+    model = copy.deepcopy(config.model)
+    return model
+
+
+def get_roi_head_cfg(fname):
+    """Grab configs necessary to create a roi_head.
+
+    These are deep copied to allow for safe modification of parameters without
+    influencing other tests.
+    """
+    config = _get_config_module(fname)
+    model = copy.deepcopy(config.model)
+
+    roi_head = model.roi_head
+    train_cfg = None if model.train_cfg is None else model.train_cfg.rcnn
+    test_cfg = None if model.test_cfg is None else model.test_cfg.rcnn
+    roi_head.update(dict(train_cfg=train_cfg, test_cfg=test_cfg))
+    return roi_head
+
+
+def _rand_bboxes(rng, num_boxes, w, h):
+    cx, cy, bw, bh = rng.rand(num_boxes, 4).T
+
+    tl_x = ((cx * w) - (w * bw / 2)).clip(0, w)
+    tl_y = ((cy * h) - (h * bh / 2)).clip(0, h)
+    br_x = ((cx * w) + (w * bw / 2)).clip(0, w)
+    br_y = ((cy * h) + (h * bh / 2)).clip(0, h)
+
+    bboxes = np.vstack([tl_x, tl_y, br_x, br_y]).T
+    return bboxes
+
+
+def _rand_masks(rng, num_boxes, bboxes, img_w, img_h):
+    from mmdet.structures.mask import BitmapMasks
+    masks = np.zeros((num_boxes, img_h, img_w))
+    for i, bbox in enumerate(bboxes):
+        bbox = bbox.astype(np.int32)
+        mask = (rng.rand(1, bbox[3] - bbox[1], bbox[2] - bbox[0]) >
+                0.3).astype(np.int64)
+        masks[i:i + 1, bbox[1]:bbox[3], bbox[0]:bbox[2]] = mask
+    return BitmapMasks(masks, height=img_h, width=img_w)
+
+
+def demo_mm_inputs(batch_size=2,
+                   image_shapes=(3, 128, 128),
+                   num_items=None,
+                   num_classes=10,
+                   sem_seg_output_strides=1,
+                   with_mask=False,
+                   with_semantic=False,
+                   use_box_type=False,
+                   device='cpu',
+                   texts=None,
+                   custom_entities=False):
+    """Create a superset of inputs needed to run test or train batches.
+
+    Args:
+        batch_size (int): batch size. Defaults to 2.
+        image_shapes (List[tuple], Optional): image shape.
+            Defaults to (3, 128, 128)
+        num_items (None | List[int]): specifies the number
+            of boxes in each batch item. Default to None.
+        num_classes (int): number of different labels a
+            box might have. Defaults to 10.
+        with_mask (bool): Whether to return mask annotation.
+            Defaults to False.
+        with_semantic (bool): whether to return semantic.
+            Defaults to False.
+        device (str): Destination device type. Defaults to cpu.
+    """
+    rng = np.random.RandomState(0)
+
+    if isinstance(image_shapes, list):
+        assert len(image_shapes) == batch_size
+    else:
+        image_shapes = [image_shapes] * batch_size
+
+    if isinstance(num_items, list):
+        assert len(num_items) == batch_size
+
+    if texts is not None:
+        assert batch_size == len(texts)
+
+    packed_inputs = []
+    for idx in range(batch_size):
+        image_shape = image_shapes[idx]
+        c, h, w = image_shape
+
+        image = rng.randint(0, 255, size=image_shape, dtype=np.uint8)
+
+        mm_inputs = dict()
+        mm_inputs['inputs'] = torch.from_numpy(image).to(device)
+
+        img_meta = {
+            'img_id': idx,
+            'img_shape': image_shape[1:],
+            'ori_shape': image_shape[1:],
+            'filename': '.png',
+            'scale_factor': np.array([1.1, 1.2]),
+            'flip': False,
+            'flip_direction': None,
+            'border': [1, 1, 1, 1]  # Only used by CenterNet
+        }
+
+        if texts:
+            img_meta['text'] = texts[idx]
+            img_meta['custom_entities'] = custom_entities
+
+        data_sample = DetDataSample()
+        data_sample.set_metainfo(img_meta)
+
+        # gt_instances
+        gt_instances = InstanceData()
+        if num_items is None:
+            num_boxes = rng.randint(1, 10)
+        else:
+            num_boxes = num_items[idx]
+
+        bboxes = _rand_bboxes(rng, num_boxes, w, h)
+        labels = rng.randint(1, num_classes, size=num_boxes)
+        # TODO: remove this part when all model adapted with BaseBoxes
+        if use_box_type:
+            gt_instances.bboxes = HorizontalBoxes(bboxes, dtype=torch.float32)
+        else:
+            gt_instances.bboxes = torch.FloatTensor(bboxes)
+        gt_instances.labels = torch.LongTensor(labels)
+
+        if with_mask:
+            masks = _rand_masks(rng, num_boxes, bboxes, w, h)
+            gt_instances.masks = masks
+
+        # TODO: waiting for ci to be fixed
+        # masks = np.random.randint(0, 2, (len(bboxes), h, w), dtype=np.uint8)
+        # gt_instances.mask = BitmapMasks(masks, h, w)
+
+        data_sample.gt_instances = gt_instances
+
+        # ignore_instances
+        ignore_instances = InstanceData()
+        bboxes = _rand_bboxes(rng, num_boxes, w, h)
+        if use_box_type:
+            ignore_instances.bboxes = HorizontalBoxes(
+                bboxes, dtype=torch.float32)
+        else:
+            ignore_instances.bboxes = torch.FloatTensor(bboxes)
+        data_sample.ignored_instances = ignore_instances
+
+        # gt_sem_seg
+        if with_semantic:
+            # assume gt_semantic_seg using scale 1/8 of the img
+            gt_semantic_seg = torch.from_numpy(
+                np.random.randint(
+                    0,
+                    num_classes, (1, h // sem_seg_output_strides,
+                                  w // sem_seg_output_strides),
+                    dtype=np.uint8))
+            gt_sem_seg_data = dict(sem_seg=gt_semantic_seg)
+            data_sample.gt_sem_seg = PixelData(**gt_sem_seg_data)
+
+        mm_inputs['data_samples'] = data_sample.to(device)
+
+        # TODO: gt_ignore
+
+        packed_inputs.append(mm_inputs)
+    data = pseudo_collate(packed_inputs)
+    return data
+
+
+def demo_mm_proposals(image_shapes, num_proposals, device='cpu'):
+    """Create a list of fake porposals.
+
+    Args:
+        image_shapes (list[tuple[int]]): Batch image shapes.
+        num_proposals (int): The number of fake proposals.
+    """
+    rng = np.random.RandomState(0)
+
+    results = []
+    for img_shape in image_shapes:
+        result = InstanceData()
+        w, h = img_shape[1:]
+        proposals = _rand_bboxes(rng, num_proposals, w, h)
+        result.bboxes = torch.from_numpy(proposals).float()
+        result.scores = torch.from_numpy(rng.rand(num_proposals)).float()
+        result.labels = torch.zeros(num_proposals).long()
+        results.append(result.to(device))
+    return results
+
+
+def demo_mm_sampling_results(proposals_list,
+                             batch_gt_instances,
+                             batch_gt_instances_ignore=None,
+                             assigner_cfg=None,
+                             sampler_cfg=None,
+                             feats=None):
+    """Create sample results that can be passed to BBoxHead.get_targets."""
+    assert len(proposals_list) == len(batch_gt_instances)
+    if batch_gt_instances_ignore is None:
+        batch_gt_instances_ignore = [None for _ in batch_gt_instances]
+    else:
+        assert len(batch_gt_instances_ignore) == len(batch_gt_instances)
+
+    default_assigner_cfg = dict(
+        type='MaxIoUAssigner',
+        pos_iou_thr=0.5,
+        neg_iou_thr=0.5,
+        min_pos_iou=0.5,
+        ignore_iof_thr=-1)
+    assigner_cfg = assigner_cfg if assigner_cfg is not None \
+        else default_assigner_cfg
+    default_sampler_cfg = dict(
+        type='RandomSampler',
+        num=512,
+        pos_fraction=0.25,
+        neg_pos_ub=-1,
+        add_gt_as_proposals=True)
+    sampler_cfg = sampler_cfg if sampler_cfg is not None \
+        else default_sampler_cfg
+    bbox_assigner = TASK_UTILS.build(assigner_cfg)
+    bbox_sampler = TASK_UTILS.build(sampler_cfg)
+
+    sampling_results = []
+    for i in range(len(batch_gt_instances)):
+        if feats is not None:
+            feats = [lvl_feat[i][None] for lvl_feat in feats]
+        # rename proposals.bboxes to proposals.priors
+        proposals = proposals_list[i]
+        proposals.priors = proposals.pop('bboxes')
+
+        assign_result = bbox_assigner.assign(proposals, batch_gt_instances[i],
+                                             batch_gt_instances_ignore[i])
+        sampling_result = bbox_sampler.sample(
+            assign_result, proposals, batch_gt_instances[i], feats=feats)
+        sampling_results.append(sampling_result)
+
+    return sampling_results
+
+
+def demo_track_inputs(batch_size=1,
+                      num_frames=2,
+                      key_frames_inds=None,
+                      image_shapes=(3, 128, 128),
+                      num_items=None,
+                      num_classes=1,
+                      with_mask=False,
+                      with_semantic=False):
+    """Create a superset of inputs needed to run test or train batches.
+
+    Args:
+        batch_size (int): batch size. Default to 1.
+        num_frames (int): The number of frames.
+        key_frames_inds (List): The indices of key frames.
+        image_shapes (List[tuple], Optional): image shape.
+            Default to (3, 128, 128)
+        num_items (None | List[int]): specifies the number
+            of boxes in each batch item. Default to None.
+        num_classes (int): number of different labels a
+            box might have. Default to 1.
+        with_mask (bool): Whether to return mask annotation.
+            Defaults to False.
+        with_semantic (bool): whether to return semantic.
+            Default to False.
+    """
+    rng = np.random.RandomState(0)
+
+    # Make sure the length of image_shapes is equal to ``batch_size``
+    if isinstance(image_shapes, list):
+        assert len(image_shapes) == batch_size
+    else:
+        image_shapes = [image_shapes] * batch_size
+
+    packed_inputs = []
+    for idx in range(batch_size):
+        mm_inputs = dict(inputs=dict())
+        _, h, w = image_shapes[idx]
+
+        imgs = rng.randint(
+            0, 255, size=(num_frames, *image_shapes[idx]), dtype=np.uint8)
+        mm_inputs['inputs'] = torch.from_numpy(imgs)
+
+        img_meta = {
+            'img_id': idx,
+            'img_shape': image_shapes[idx][-2:],
+            'ori_shape': image_shapes[idx][-2:],
+            'filename': '.png',
+            'scale_factor': np.array([1.1, 1.2]),
+            'flip': False,
+            'flip_direction': None,
+            'is_video_data': True,
+        }
+
+        video_data_samples = []
+        for i in range(num_frames):
+            data_sample = DetDataSample()
+            img_meta['frame_id'] = i
+            data_sample.set_metainfo(img_meta)
+
+            # gt_instances
+            gt_instances = InstanceData()
+            if num_items is None:
+                num_boxes = rng.randint(1, 10)
+            else:
+                num_boxes = num_items[idx]
+
+            bboxes = _rand_bboxes(rng, num_boxes, w, h)
+            labels = rng.randint(0, num_classes, size=num_boxes)
+            instances_id = rng.randint(100, num_classes + 100, size=num_boxes)
+            gt_instances.bboxes = torch.FloatTensor(bboxes)
+            gt_instances.labels = torch.LongTensor(labels)
+            gt_instances.instances_ids = torch.LongTensor(instances_id)
+
+            if with_mask:
+                masks = _rand_masks(rng, num_boxes, bboxes, w, h)
+                gt_instances.masks = masks
+
+            data_sample.gt_instances = gt_instances
+            # ignore_instances
+            ignore_instances = InstanceData()
+            bboxes = _rand_bboxes(rng, num_boxes, w, h)
+            ignore_instances.bboxes = bboxes
+            data_sample.ignored_instances = ignore_instances
+
+            video_data_samples.append(data_sample)
+
+        track_data_sample = TrackDataSample()
+        track_data_sample.video_data_samples = video_data_samples
+        if key_frames_inds is not None:
+            assert isinstance(
+                key_frames_inds,
+                list) and len(key_frames_inds) < num_frames and max(
+                    key_frames_inds) < num_frames
+            ref_frames_inds = [
+                i for i in range(num_frames) if i not in key_frames_inds
+            ]
+            track_data_sample.set_metainfo(
+                dict(key_frames_inds=key_frames_inds))
+            track_data_sample.set_metainfo(
+                dict(ref_frames_inds=ref_frames_inds))
+        mm_inputs['data_samples'] = track_data_sample
+
+        # TODO: gt_ignore
+        packed_inputs.append(mm_inputs)
+    data = pseudo_collate(packed_inputs)
+    return data
+
+
+def random_boxes(num=1, scale=1, rng=None):
+    """Simple version of ``kwimage.Boxes.random``
+    Returns:
+        Tensor: shape (n, 4) in x1, y1, x2, y2 format.
+    References:
+        https://gitlab.kitware.com/computer-vision/kwimage/blob/master/kwimage/structs/boxes.py#L1390 # noqa: E501
+    Example:
+        >>> num = 3
+        >>> scale = 512
+        >>> rng = 0
+        >>> boxes = random_boxes(num, scale, rng)
+        >>> print(boxes)
+        tensor([[280.9925, 278.9802, 308.6148, 366.1769],
+                [216.9113, 330.6978, 224.0446, 456.5878],
+                [405.3632, 196.3221, 493.3953, 270.7942]])
+    """
+    rng = ensure_rng(rng)
+
+    tlbr = rng.rand(num, 4).astype(np.float32)
+
+    tl_x = np.minimum(tlbr[:, 0], tlbr[:, 2])
+    tl_y = np.minimum(tlbr[:, 1], tlbr[:, 3])
+    br_x = np.maximum(tlbr[:, 0], tlbr[:, 2])
+    br_y = np.maximum(tlbr[:, 1], tlbr[:, 3])
+
+    tlbr[:, 0] = tl_x * scale
+    tlbr[:, 1] = tl_y * scale
+    tlbr[:, 2] = br_x * scale
+    tlbr[:, 3] = br_y * scale
+
+    boxes = torch.from_numpy(tlbr)
+    return boxes
+
+
+# TODO: Support full ceph
+def replace_to_ceph(cfg):
+    backend_args = dict(
+        backend='petrel',
+        path_mapping=dict({
+            './data/': 's3://openmmlab/datasets/detection/',
+            'data/': 's3://openmmlab/datasets/detection/'
+        }))
+
+    # TODO: name is a reserved interface, which will be used later.
+    def _process_pipeline(dataset, name):
+
+        def replace_img(pipeline):
+            if pipeline['type'] == 'LoadImageFromFile':
+                pipeline['backend_args'] = backend_args
+
+        def replace_ann(pipeline):
+            if pipeline['type'] == 'LoadAnnotations' or pipeline[
+                    'type'] == 'LoadPanopticAnnotations':
+                pipeline['backend_args'] = backend_args
+
+        if 'pipeline' in dataset:
+            replace_img(dataset.pipeline[0])
+            replace_ann(dataset.pipeline[1])
+            if 'dataset' in dataset:
+                # dataset wrapper
+                replace_img(dataset.dataset.pipeline[0])
+                replace_ann(dataset.dataset.pipeline[1])
+        else:
+            # dataset wrapper
+            replace_img(dataset.dataset.pipeline[0])
+            replace_ann(dataset.dataset.pipeline[1])
+
+    def _process_evaluator(evaluator, name):
+        if evaluator['type'] == 'CocoPanopticMetric':
+            evaluator['backend_args'] = backend_args
+
+    # half ceph
+    _process_pipeline(cfg.train_dataloader.dataset, cfg.filename)
+    _process_pipeline(cfg.val_dataloader.dataset, cfg.filename)
+    _process_pipeline(cfg.test_dataloader.dataset, cfg.filename)
+    _process_evaluator(cfg.val_evaluator, cfg.filename)
+    _process_evaluator(cfg.test_evaluator, cfg.filename)
diff --git a/mmdetection/mmdet/utils/__init__.py b/mmdetection/mmdet/utils/__init__.py
new file mode 100644
index 00000000..449a890b
--- /dev/null
+++ b/mmdetection/mmdet/utils/__init__.py
@@ -0,0 +1,28 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .collect_env import collect_env
+from .compat_config import compat_cfg
+from .dist_utils import (all_reduce_dict, allreduce_grads, reduce_mean,
+                         sync_random_seed)
+from .logger import get_caller_name, log_img_scale
+from .memory import AvoidCUDAOOM, AvoidOOM
+from .misc import (find_latest_checkpoint, get_test_pipeline_cfg,
+                   update_data_root)
+from .mot_error_visualize import imshow_mot_errors
+from .replace_cfg_vals import replace_cfg_vals
+from .setup_env import (register_all_modules, setup_cache_size_limit_of_dynamo,
+                        setup_multi_processes)
+from .split_batch import split_batch
+from .typing_utils import (ConfigType, InstanceList, MultiConfig,
+                           OptConfigType, OptInstanceList, OptMultiConfig,
+                           OptPixelList, PixelList, RangeType)
+
+__all__ = [
+    'collect_env', 'find_latest_checkpoint', 'update_data_root',
+    'setup_multi_processes', 'get_caller_name', 'log_img_scale', 'compat_cfg',
+    'split_batch', 'register_all_modules', 'replace_cfg_vals', 'AvoidOOM',
+    'AvoidCUDAOOM', 'all_reduce_dict', 'allreduce_grads', 'reduce_mean',
+    'sync_random_seed', 'ConfigType', 'InstanceList', 'MultiConfig',
+    'OptConfigType', 'OptInstanceList', 'OptMultiConfig', 'OptPixelList',
+    'PixelList', 'RangeType', 'get_test_pipeline_cfg',
+    'setup_cache_size_limit_of_dynamo', 'imshow_mot_errors'
+]
diff --git a/mmdetection/mmdet/utils/benchmark.py b/mmdetection/mmdet/utils/benchmark.py
new file mode 100644
index 00000000..5419b2d1
--- /dev/null
+++ b/mmdetection/mmdet/utils/benchmark.py
@@ -0,0 +1,529 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import time
+from functools import partial
+from typing import List, Optional, Union
+
+import numpy as np
+import torch
+import torch.nn as nn
+from mmcv.cnn import fuse_conv_bn
+# TODO need update
+# from mmcv.runner import wrap_fp16_model
+from mmengine import MMLogger
+from mmengine.config import Config
+from mmengine.device import get_max_cuda_memory
+from mmengine.dist import get_world_size
+from mmengine.runner import Runner, load_checkpoint
+from mmengine.utils.dl_utils import set_multi_processing
+from torch.nn.parallel import DistributedDataParallel
+
+from mmdet.registry import DATASETS, MODELS
+
+try:
+    import psutil
+except ImportError:
+    psutil = None
+
+
+def custom_round(value: Union[int, float],
+                 factor: Union[int, float],
+                 precision: int = 2) -> float:
+    """Custom round function."""
+    return round(value / factor, precision)
+
+
+gb_round = partial(custom_round, factor=1024**3)
+
+
+def print_log(msg: str, logger: Optional[MMLogger] = None) -> None:
+    """Print a log message."""
+    if logger is None:
+        print(msg, flush=True)
+    else:
+        logger.info(msg)
+
+
+def print_process_memory(p: psutil.Process,
+                         logger: Optional[MMLogger] = None) -> None:
+    """print process memory info."""
+    mem_used = gb_round(psutil.virtual_memory().used)
+    memory_full_info = p.memory_full_info()
+    uss_mem = gb_round(memory_full_info.uss)
+    if hasattr(memory_full_info, 'pss'):
+        pss_mem = gb_round(memory_full_info.pss)
+
+    for children in p.children():
+        child_mem_info = children.memory_full_info()
+        uss_mem += gb_round(child_mem_info.uss)
+        if hasattr(child_mem_info, 'pss'):
+            pss_mem += gb_round(child_mem_info.pss)
+
+    process_count = 1 + len(p.children())
+
+    log_msg = f'(GB) mem_used: {mem_used:.2f} | uss: {uss_mem:.2f} | '
+    if hasattr(memory_full_info, 'pss'):
+        log_msg += f'pss: {pss_mem:.2f} | '
+    log_msg += f'total_proc: {process_count}'
+    print_log(log_msg, logger)
+
+
+class BaseBenchmark:
+    """The benchmark base class.
+
+    The ``run`` method is an external calling interface, and it will
+    call the ``run_once`` method ``repeat_num`` times for benchmarking.
+    Finally, call the ``average_multiple_runs`` method to further process
+    the results of multiple runs.
+
+    Args:
+        max_iter (int): maximum iterations of benchmark.
+        log_interval (int): interval of logging.
+        num_warmup (int): Number of Warmup.
+        logger (MMLogger, optional): Formatted logger used to record messages.
+    """
+
+    def __init__(self,
+                 max_iter: int,
+                 log_interval: int,
+                 num_warmup: int,
+                 logger: Optional[MMLogger] = None):
+        self.max_iter = max_iter
+        self.log_interval = log_interval
+        self.num_warmup = num_warmup
+        self.logger = logger
+
+    def run(self, repeat_num: int = 1) -> dict:
+        """benchmark entry method.
+
+        Args:
+            repeat_num (int): Number of repeat benchmark.
+                Defaults to 1.
+        """
+        assert repeat_num >= 1
+
+        results = []
+        for _ in range(repeat_num):
+            results.append(self.run_once())
+
+        results = self.average_multiple_runs(results)
+        return results
+
+    def run_once(self) -> dict:
+        """Executes the benchmark once."""
+        raise NotImplementedError()
+
+    def average_multiple_runs(self, results: List[dict]) -> dict:
+        """Average the results of multiple runs."""
+        raise NotImplementedError()
+
+
+class InferenceBenchmark(BaseBenchmark):
+    """The inference benchmark class. It will be statistical inference FPS,
+    CUDA memory and CPU memory information.
+
+    Args:
+        cfg (mmengine.Config): config.
+        checkpoint (str): Accept local filepath, URL, ``torchvision://xxx``,
+            ``open-mmlab://xxx``.
+        distributed (bool): distributed testing flag.
+        is_fuse_conv_bn (bool): Whether to fuse conv and bn, this will
+            slightly increase the inference speed.
+        max_iter (int): maximum iterations of benchmark. Defaults to 2000.
+        log_interval (int): interval of logging. Defaults to 50.
+        num_warmup (int): Number of Warmup. Defaults to 5.
+        logger (MMLogger, optional): Formatted logger used to record messages.
+    """
+
+    def __init__(self,
+                 cfg: Config,
+                 checkpoint: str,
+                 distributed: bool,
+                 is_fuse_conv_bn: bool,
+                 max_iter: int = 2000,
+                 log_interval: int = 50,
+                 num_warmup: int = 5,
+                 logger: Optional[MMLogger] = None):
+        super().__init__(max_iter, log_interval, num_warmup, logger)
+
+        assert get_world_size(
+        ) == 1, 'Inference benchmark does not allow distributed multi-GPU'
+
+        self.cfg = copy.deepcopy(cfg)
+        self.distributed = distributed
+
+        if psutil is None:
+            raise ImportError('psutil is not installed, please install it by: '
+                              'pip install psutil')
+
+        self._process = psutil.Process()
+        env_cfg = self.cfg.get('env_cfg')
+        if env_cfg.get('cudnn_benchmark'):
+            torch.backends.cudnn.benchmark = True
+
+        mp_cfg: dict = env_cfg.get('mp_cfg', {})
+        set_multi_processing(**mp_cfg, distributed=self.distributed)
+
+        print_log('before build: ', self.logger)
+        print_process_memory(self._process, self.logger)
+
+        self.model = self._init_model(checkpoint, is_fuse_conv_bn)
+
+        # Because multiple processes will occupy additional CPU resources,
+        # FPS statistics will be more unstable when num_workers is not 0.
+        # It is reasonable to set num_workers to 0.
+        dataloader_cfg = cfg.test_dataloader
+        dataloader_cfg['num_workers'] = 0
+        dataloader_cfg['batch_size'] = 1
+        dataloader_cfg['persistent_workers'] = False
+        self.data_loader = Runner.build_dataloader(dataloader_cfg)
+
+        print_log('after build: ', self.logger)
+        print_process_memory(self._process, self.logger)
+
+    def _init_model(self, checkpoint: str, is_fuse_conv_bn: bool) -> nn.Module:
+        """Initialize the model."""
+        model = MODELS.build(self.cfg.model)
+        # TODO need update
+        # fp16_cfg = self.cfg.get('fp16', None)
+        # if fp16_cfg is not None:
+        #     wrap_fp16_model(model)
+
+        load_checkpoint(model, checkpoint, map_location='cpu')
+        if is_fuse_conv_bn:
+            model = fuse_conv_bn(model)
+
+        model = model.cuda()
+
+        if self.distributed:
+            model = DistributedDataParallel(
+                model,
+                device_ids=[torch.cuda.current_device()],
+                broadcast_buffers=False,
+                find_unused_parameters=False)
+
+        model.eval()
+        return model
+
+    def run_once(self) -> dict:
+        """Executes the benchmark once."""
+        pure_inf_time = 0
+        fps = 0
+
+        for i, data in enumerate(self.data_loader):
+
+            if (i + 1) % self.log_interval == 0:
+                print_log('==================================', self.logger)
+
+            torch.cuda.synchronize()
+            start_time = time.perf_counter()
+
+            with torch.no_grad():
+                self.model.test_step(data)
+
+            torch.cuda.synchronize()
+            elapsed = time.perf_counter() - start_time
+
+            if i >= self.num_warmup:
+                pure_inf_time += elapsed
+                if (i + 1) % self.log_interval == 0:
+                    fps = (i + 1 - self.num_warmup) / pure_inf_time
+                    cuda_memory = get_max_cuda_memory()
+
+                    print_log(
+                        f'Done image [{i + 1:<3}/{self.max_iter}], '
+                        f'fps: {fps:.1f} img/s, '
+                        f'times per image: {1000 / fps:.1f} ms/img, '
+                        f'cuda memory: {cuda_memory} MB', self.logger)
+                    print_process_memory(self._process, self.logger)
+
+            if (i + 1) == self.max_iter:
+                fps = (i + 1 - self.num_warmup) / pure_inf_time
+                break
+
+        return {'fps': fps}
+
+    def average_multiple_runs(self, results: List[dict]) -> dict:
+        """Average the results of multiple runs."""
+        print_log('============== Done ==================', self.logger)
+
+        fps_list_ = [round(result['fps'], 1) for result in results]
+        avg_fps_ = sum(fps_list_) / len(fps_list_)
+        outputs = {'avg_fps': avg_fps_, 'fps_list': fps_list_}
+
+        if len(fps_list_) > 1:
+            times_pre_image_list_ = [
+                round(1000 / result['fps'], 1) for result in results
+            ]
+            avg_times_pre_image_ = sum(times_pre_image_list_) / len(
+                times_pre_image_list_)
+
+            print_log(
+                f'Overall fps: {fps_list_}[{avg_fps_:.1f}] img/s, '
+                'times per image: '
+                f'{times_pre_image_list_}[{avg_times_pre_image_:.1f}] '
+                'ms/img', self.logger)
+        else:
+            print_log(
+                f'Overall fps: {fps_list_[0]:.1f} img/s, '
+                f'times per image: {1000 / fps_list_[0]:.1f} ms/img',
+                self.logger)
+
+        print_log(f'cuda memory: {get_max_cuda_memory()} MB', self.logger)
+        print_process_memory(self._process, self.logger)
+
+        return outputs
+
+
+class DataLoaderBenchmark(BaseBenchmark):
+    """The dataloader benchmark class. It will be statistical inference FPS and
+    CPU memory information.
+
+    Args:
+        cfg (mmengine.Config): config.
+        distributed (bool): distributed testing flag.
+        dataset_type (str): benchmark data type, only supports ``train``,
+            ``val`` and ``test``.
+        max_iter (int): maximum iterations of benchmark. Defaults to 2000.
+        log_interval (int): interval of logging. Defaults to 50.
+        num_warmup (int): Number of Warmup. Defaults to 5.
+        logger (MMLogger, optional): Formatted logger used to record messages.
+    """
+
+    def __init__(self,
+                 cfg: Config,
+                 distributed: bool,
+                 dataset_type: str,
+                 max_iter: int = 2000,
+                 log_interval: int = 50,
+                 num_warmup: int = 5,
+                 logger: Optional[MMLogger] = None):
+        super().__init__(max_iter, log_interval, num_warmup, logger)
+
+        assert dataset_type in ['train', 'val', 'test'], \
+            'dataset_type only supports train,' \
+            f' val and test, but got {dataset_type}'
+        assert get_world_size(
+        ) == 1, 'Dataloader benchmark does not allow distributed multi-GPU'
+
+        self.cfg = copy.deepcopy(cfg)
+        self.distributed = distributed
+
+        if psutil is None:
+            raise ImportError('psutil is not installed, please install it by: '
+                              'pip install psutil')
+        self._process = psutil.Process()
+
+        mp_cfg = self.cfg.get('env_cfg', {}).get('mp_cfg')
+        if mp_cfg is not None:
+            set_multi_processing(distributed=self.distributed, **mp_cfg)
+        else:
+            set_multi_processing(distributed=self.distributed)
+
+        print_log('before build: ', self.logger)
+        print_process_memory(self._process, self.logger)
+
+        if dataset_type == 'train':
+            self.data_loader = Runner.build_dataloader(cfg.train_dataloader)
+        elif dataset_type == 'test':
+            self.data_loader = Runner.build_dataloader(cfg.test_dataloader)
+        else:
+            self.data_loader = Runner.build_dataloader(cfg.val_dataloader)
+
+        self.batch_size = self.data_loader.batch_size
+        self.num_workers = self.data_loader.num_workers
+
+        print_log('after build: ', self.logger)
+        print_process_memory(self._process, self.logger)
+
+    def run_once(self) -> dict:
+        """Executes the benchmark once."""
+        pure_inf_time = 0
+        fps = 0
+
+        # benchmark with 2000 image and take the average
+        start_time = time.perf_counter()
+        for i, data in enumerate(self.data_loader):
+            elapsed = time.perf_counter() - start_time
+
+            if (i + 1) % self.log_interval == 0:
+                print_log('==================================', self.logger)
+
+            if i >= self.num_warmup:
+                pure_inf_time += elapsed
+                if (i + 1) % self.log_interval == 0:
+                    fps = (i + 1 - self.num_warmup) / pure_inf_time
+
+                    print_log(
+                        f'Done batch [{i + 1:<3}/{self.max_iter}], '
+                        f'fps: {fps:.1f} batch/s, '
+                        f'times per batch: {1000 / fps:.1f} ms/batch, '
+                        f'batch size: {self.batch_size}, num_workers: '
+                        f'{self.num_workers}', self.logger)
+                    print_process_memory(self._process, self.logger)
+
+            if (i + 1) == self.max_iter:
+                fps = (i + 1 - self.num_warmup) / pure_inf_time
+                break
+
+            start_time = time.perf_counter()
+
+        return {'fps': fps}
+
+    def average_multiple_runs(self, results: List[dict]) -> dict:
+        """Average the results of multiple runs."""
+        print_log('============== Done ==================', self.logger)
+
+        fps_list_ = [round(result['fps'], 1) for result in results]
+        avg_fps_ = sum(fps_list_) / len(fps_list_)
+        outputs = {'avg_fps': avg_fps_, 'fps_list': fps_list_}
+
+        if len(fps_list_) > 1:
+            times_pre_image_list_ = [
+                round(1000 / result['fps'], 1) for result in results
+            ]
+            avg_times_pre_image_ = sum(times_pre_image_list_) / len(
+                times_pre_image_list_)
+
+            print_log(
+                f'Overall fps: {fps_list_}[{avg_fps_:.1f}] img/s, '
+                'times per batch: '
+                f'{times_pre_image_list_}[{avg_times_pre_image_:.1f}] '
+                f'ms/batch, batch size: {self.batch_size}, num_workers: '
+                f'{self.num_workers}', self.logger)
+        else:
+            print_log(
+                f'Overall fps: {fps_list_[0]:.1f} batch/s, '
+                f'times per batch: {1000 / fps_list_[0]:.1f} ms/batch, '
+                f'batch size: {self.batch_size}, num_workers: '
+                f'{self.num_workers}', self.logger)
+
+        print_process_memory(self._process, self.logger)
+
+        return outputs
+
+
+class DatasetBenchmark(BaseBenchmark):
+    """The dataset benchmark class. It will be statistical inference FPS, FPS
+    pre transform and CPU memory information.
+
+    Args:
+        cfg (mmengine.Config): config.
+        dataset_type (str): benchmark data type, only supports ``train``,
+            ``val`` and ``test``.
+        max_iter (int): maximum iterations of benchmark. Defaults to 2000.
+        log_interval (int): interval of logging. Defaults to 50.
+        num_warmup (int): Number of Warmup. Defaults to 5.
+        logger (MMLogger, optional): Formatted logger used to record messages.
+    """
+
+    def __init__(self,
+                 cfg: Config,
+                 dataset_type: str,
+                 max_iter: int = 2000,
+                 log_interval: int = 50,
+                 num_warmup: int = 5,
+                 logger: Optional[MMLogger] = None):
+        super().__init__(max_iter, log_interval, num_warmup, logger)
+        assert dataset_type in ['train', 'val', 'test'], \
+            'dataset_type only supports train,' \
+            f' val and test, but got {dataset_type}'
+        assert get_world_size(
+        ) == 1, 'Dataset benchmark does not allow distributed multi-GPU'
+        self.cfg = copy.deepcopy(cfg)
+
+        if dataset_type == 'train':
+            dataloader_cfg = copy.deepcopy(cfg.train_dataloader)
+        elif dataset_type == 'test':
+            dataloader_cfg = copy.deepcopy(cfg.test_dataloader)
+        else:
+            dataloader_cfg = copy.deepcopy(cfg.val_dataloader)
+
+        dataset_cfg = dataloader_cfg.pop('dataset')
+        dataset = DATASETS.build(dataset_cfg)
+        if hasattr(dataset, 'full_init'):
+            dataset.full_init()
+        self.dataset = dataset
+
+    def run_once(self) -> dict:
+        """Executes the benchmark once."""
+        pure_inf_time = 0
+        fps = 0
+
+        total_index = list(range(len(self.dataset)))
+        np.random.shuffle(total_index)
+
+        start_time = time.perf_counter()
+        for i, idx in enumerate(total_index):
+            if (i + 1) % self.log_interval == 0:
+                print_log('==================================', self.logger)
+
+            get_data_info_start_time = time.perf_counter()
+            data_info = self.dataset.get_data_info(idx)
+            get_data_info_elapsed = time.perf_counter(
+            ) - get_data_info_start_time
+
+            if (i + 1) % self.log_interval == 0:
+                print_log(f'get_data_info - {get_data_info_elapsed * 1000} ms',
+                          self.logger)
+
+            for t in self.dataset.pipeline.transforms:
+                transform_start_time = time.perf_counter()
+                data_info = t(data_info)
+                transform_elapsed = time.perf_counter() - transform_start_time
+
+                if (i + 1) % self.log_interval == 0:
+                    print_log(
+                        f'{t.__class__.__name__} - '
+                        f'{transform_elapsed * 1000} ms', self.logger)
+
+                if data_info is None:
+                    break
+
+            elapsed = time.perf_counter() - start_time
+
+            if i >= self.num_warmup:
+                pure_inf_time += elapsed
+                if (i + 1) % self.log_interval == 0:
+                    fps = (i + 1 - self.num_warmup) / pure_inf_time
+
+                    print_log(
+                        f'Done img [{i + 1:<3}/{self.max_iter}], '
+                        f'fps: {fps:.1f} img/s, '
+                        f'times per img: {1000 / fps:.1f} ms/img', self.logger)
+
+            if (i + 1) == self.max_iter:
+                fps = (i + 1 - self.num_warmup) / pure_inf_time
+                break
+
+            start_time = time.perf_counter()
+
+        return {'fps': fps}
+
+    def average_multiple_runs(self, results: List[dict]) -> dict:
+        """Average the results of multiple runs."""
+        print_log('============== Done ==================', self.logger)
+
+        fps_list_ = [round(result['fps'], 1) for result in results]
+        avg_fps_ = sum(fps_list_) / len(fps_list_)
+        outputs = {'avg_fps': avg_fps_, 'fps_list': fps_list_}
+
+        if len(fps_list_) > 1:
+            times_pre_image_list_ = [
+                round(1000 / result['fps'], 1) for result in results
+            ]
+            avg_times_pre_image_ = sum(times_pre_image_list_) / len(
+                times_pre_image_list_)
+
+            print_log(
+                f'Overall fps: {fps_list_}[{avg_fps_:.1f}] img/s, '
+                'times per img: '
+                f'{times_pre_image_list_}[{avg_times_pre_image_:.1f}] '
+                'ms/img', self.logger)
+        else:
+            print_log(
+                f'Overall fps: {fps_list_[0]:.1f} img/s, '
+                f'times per img: {1000 / fps_list_[0]:.1f} ms/img',
+                self.logger)
+
+        return outputs
diff --git a/mmdetection/mmdet/utils/collect_env.py b/mmdetection/mmdet/utils/collect_env.py
new file mode 100644
index 00000000..b0eed80f
--- /dev/null
+++ b/mmdetection/mmdet/utils/collect_env.py
@@ -0,0 +1,17 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmengine.utils import get_git_hash
+from mmengine.utils.dl_utils import collect_env as collect_base_env
+
+import mmdet
+
+
+def collect_env():
+    """Collect the information of the running environments."""
+    env_info = collect_base_env()
+    env_info['MMDetection'] = mmdet.__version__ + '+' + get_git_hash()[:7]
+    return env_info
+
+
+if __name__ == '__main__':
+    for name, val in collect_env().items():
+        print(f'{name}: {val}')
diff --git a/mmdetection/mmdet/utils/compat_config.py b/mmdetection/mmdet/utils/compat_config.py
new file mode 100644
index 00000000..133adb65
--- /dev/null
+++ b/mmdetection/mmdet/utils/compat_config.py
@@ -0,0 +1,139 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import warnings
+
+from mmengine.config import ConfigDict
+
+
+def compat_cfg(cfg):
+    """This function would modify some filed to keep the compatibility of
+    config.
+
+    For example, it will move some args which will be deprecated to the correct
+    fields.
+    """
+    cfg = copy.deepcopy(cfg)
+    cfg = compat_imgs_per_gpu(cfg)
+    cfg = compat_loader_args(cfg)
+    cfg = compat_runner_args(cfg)
+    return cfg
+
+
+def compat_runner_args(cfg):
+    if 'runner' not in cfg:
+        cfg.runner = ConfigDict({
+            'type': 'EpochBasedRunner',
+            'max_epochs': cfg.total_epochs
+        })
+        warnings.warn(
+            'config is now expected to have a `runner` section, '
+            'please set `runner` in your config.', UserWarning)
+    else:
+        if 'total_epochs' in cfg:
+            assert cfg.total_epochs == cfg.runner.max_epochs
+    return cfg
+
+
+def compat_imgs_per_gpu(cfg):
+    cfg = copy.deepcopy(cfg)
+    if 'imgs_per_gpu' in cfg.data:
+        warnings.warn('"imgs_per_gpu" is deprecated in MMDet V2.0. '
+                      'Please use "samples_per_gpu" instead')
+        if 'samples_per_gpu' in cfg.data:
+            warnings.warn(
+                f'Got "imgs_per_gpu"={cfg.data.imgs_per_gpu} and '
+                f'"samples_per_gpu"={cfg.data.samples_per_gpu}, "imgs_per_gpu"'
+                f'={cfg.data.imgs_per_gpu} is used in this experiments')
+        else:
+            warnings.warn('Automatically set "samples_per_gpu"="imgs_per_gpu"='
+                          f'{cfg.data.imgs_per_gpu} in this experiments')
+        cfg.data.samples_per_gpu = cfg.data.imgs_per_gpu
+    return cfg
+
+
+def compat_loader_args(cfg):
+    """Deprecated sample_per_gpu in cfg.data."""
+
+    cfg = copy.deepcopy(cfg)
+    if 'train_dataloader' not in cfg.data:
+        cfg.data['train_dataloader'] = ConfigDict()
+    if 'val_dataloader' not in cfg.data:
+        cfg.data['val_dataloader'] = ConfigDict()
+    if 'test_dataloader' not in cfg.data:
+        cfg.data['test_dataloader'] = ConfigDict()
+
+    # special process for train_dataloader
+    if 'samples_per_gpu' in cfg.data:
+
+        samples_per_gpu = cfg.data.pop('samples_per_gpu')
+        assert 'samples_per_gpu' not in \
+               cfg.data.train_dataloader, ('`samples_per_gpu` are set '
+                                           'in `data` field and ` '
+                                           'data.train_dataloader` '
+                                           'at the same time. '
+                                           'Please only set it in '
+                                           '`data.train_dataloader`. ')
+        cfg.data.train_dataloader['samples_per_gpu'] = samples_per_gpu
+
+    if 'persistent_workers' in cfg.data:
+
+        persistent_workers = cfg.data.pop('persistent_workers')
+        assert 'persistent_workers' not in \
+               cfg.data.train_dataloader, ('`persistent_workers` are set '
+                                           'in `data` field and ` '
+                                           'data.train_dataloader` '
+                                           'at the same time. '
+                                           'Please only set it in '
+                                           '`data.train_dataloader`. ')
+        cfg.data.train_dataloader['persistent_workers'] = persistent_workers
+
+    if 'workers_per_gpu' in cfg.data:
+
+        workers_per_gpu = cfg.data.pop('workers_per_gpu')
+        cfg.data.train_dataloader['workers_per_gpu'] = workers_per_gpu
+        cfg.data.val_dataloader['workers_per_gpu'] = workers_per_gpu
+        cfg.data.test_dataloader['workers_per_gpu'] = workers_per_gpu
+
+    # special process for val_dataloader
+    if 'samples_per_gpu' in cfg.data.val:
+        # keep default value of `sample_per_gpu` is 1
+        assert 'samples_per_gpu' not in \
+               cfg.data.val_dataloader, ('`samples_per_gpu` are set '
+                                         'in `data.val` field and ` '
+                                         'data.val_dataloader` at '
+                                         'the same time. '
+                                         'Please only set it in '
+                                         '`data.val_dataloader`. ')
+        cfg.data.val_dataloader['samples_per_gpu'] = \
+            cfg.data.val.pop('samples_per_gpu')
+    # special process for val_dataloader
+
+    # in case the test dataset is concatenated
+    if isinstance(cfg.data.test, dict):
+        if 'samples_per_gpu' in cfg.data.test:
+            assert 'samples_per_gpu' not in \
+                   cfg.data.test_dataloader, ('`samples_per_gpu` are set '
+                                              'in `data.test` field and ` '
+                                              'data.test_dataloader` '
+                                              'at the same time. '
+                                              'Please only set it in '
+                                              '`data.test_dataloader`. ')
+
+            cfg.data.test_dataloader['samples_per_gpu'] = \
+                cfg.data.test.pop('samples_per_gpu')
+
+    elif isinstance(cfg.data.test, list):
+        for ds_cfg in cfg.data.test:
+            if 'samples_per_gpu' in ds_cfg:
+                assert 'samples_per_gpu' not in \
+                       cfg.data.test_dataloader, ('`samples_per_gpu` are set '
+                                                  'in `data.test` field and ` '
+                                                  'data.test_dataloader` at'
+                                                  ' the same time. '
+                                                  'Please only set it in '
+                                                  '`data.test_dataloader`. ')
+        samples_per_gpu = max(
+            [ds_cfg.pop('samples_per_gpu', 1) for ds_cfg in cfg.data.test])
+        cfg.data.test_dataloader['samples_per_gpu'] = samples_per_gpu
+
+    return cfg
diff --git a/mmdetection/mmdet/utils/contextmanagers.py b/mmdetection/mmdet/utils/contextmanagers.py
new file mode 100644
index 00000000..fa12bfca
--- /dev/null
+++ b/mmdetection/mmdet/utils/contextmanagers.py
@@ -0,0 +1,122 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import asyncio
+import contextlib
+import logging
+import os
+import time
+from typing import List
+
+import torch
+
+logger = logging.getLogger(__name__)
+
+DEBUG_COMPLETED_TIME = bool(os.environ.get('DEBUG_COMPLETED_TIME', False))
+
+
+@contextlib.asynccontextmanager
+async def completed(trace_name='',
+                    name='',
+                    sleep_interval=0.05,
+                    streams: List[torch.cuda.Stream] = None):
+    """Async context manager that waits for work to complete on given CUDA
+    streams."""
+    if not torch.cuda.is_available():
+        yield
+        return
+
+    stream_before_context_switch = torch.cuda.current_stream()
+    if not streams:
+        streams = [stream_before_context_switch]
+    else:
+        streams = [s if s else stream_before_context_switch for s in streams]
+
+    end_events = [
+        torch.cuda.Event(enable_timing=DEBUG_COMPLETED_TIME) for _ in streams
+    ]
+
+    if DEBUG_COMPLETED_TIME:
+        start = torch.cuda.Event(enable_timing=True)
+        stream_before_context_switch.record_event(start)
+
+        cpu_start = time.monotonic()
+    logger.debug('%s %s starting, streams: %s', trace_name, name, streams)
+    grad_enabled_before = torch.is_grad_enabled()
+    try:
+        yield
+    finally:
+        current_stream = torch.cuda.current_stream()
+        assert current_stream == stream_before_context_switch
+
+        if DEBUG_COMPLETED_TIME:
+            cpu_end = time.monotonic()
+        for i, stream in enumerate(streams):
+            event = end_events[i]
+            stream.record_event(event)
+
+        grad_enabled_after = torch.is_grad_enabled()
+
+        # observed change of torch.is_grad_enabled() during concurrent run of
+        # async_test_bboxes code
+        assert (grad_enabled_before == grad_enabled_after
+                ), 'Unexpected is_grad_enabled() value change'
+
+        are_done = [e.query() for e in end_events]
+        logger.debug('%s %s completed: %s streams: %s', trace_name, name,
+                     are_done, streams)
+        with torch.cuda.stream(stream_before_context_switch):
+            while not all(are_done):
+                await asyncio.sleep(sleep_interval)
+                are_done = [e.query() for e in end_events]
+                logger.debug(
+                    '%s %s completed: %s streams: %s',
+                    trace_name,
+                    name,
+                    are_done,
+                    streams,
+                )
+
+        current_stream = torch.cuda.current_stream()
+        assert current_stream == stream_before_context_switch
+
+        if DEBUG_COMPLETED_TIME:
+            cpu_time = (cpu_end - cpu_start) * 1000
+            stream_times_ms = ''
+            for i, stream in enumerate(streams):
+                elapsed_time = start.elapsed_time(end_events[i])
+                stream_times_ms += f' {stream} {elapsed_time:.2f} ms'
+            logger.info('%s %s %.2f ms %s', trace_name, name, cpu_time,
+                        stream_times_ms)
+
+
+@contextlib.asynccontextmanager
+async def concurrent(streamqueue: asyncio.Queue,
+                     trace_name='concurrent',
+                     name='stream'):
+    """Run code concurrently in different streams.
+
+    :param streamqueue: asyncio.Queue instance.
+
+    Queue tasks define the pool of streams used for concurrent execution.
+    """
+    if not torch.cuda.is_available():
+        yield
+        return
+
+    initial_stream = torch.cuda.current_stream()
+
+    with torch.cuda.stream(initial_stream):
+        stream = await streamqueue.get()
+        assert isinstance(stream, torch.cuda.Stream)
+
+        try:
+            with torch.cuda.stream(stream):
+                logger.debug('%s %s is starting, stream: %s', trace_name, name,
+                             stream)
+                yield
+                current = torch.cuda.current_stream()
+                assert current == stream
+                logger.debug('%s %s has finished, stream: %s', trace_name,
+                             name, stream)
+        finally:
+            streamqueue.task_done()
+            streamqueue.put_nowait(stream)
diff --git a/mmdetection/mmdet/utils/dist_utils.py b/mmdetection/mmdet/utils/dist_utils.py
new file mode 100644
index 00000000..2f2c8614
--- /dev/null
+++ b/mmdetection/mmdet/utils/dist_utils.py
@@ -0,0 +1,184 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import functools
+import pickle
+import warnings
+from collections import OrderedDict
+
+import numpy as np
+import torch
+import torch.distributed as dist
+from mmengine.dist import get_dist_info
+from torch._utils import (_flatten_dense_tensors, _take_tensors,
+                          _unflatten_dense_tensors)
+
+
+def _allreduce_coalesced(tensors, world_size, bucket_size_mb=-1):
+    if bucket_size_mb > 0:
+        bucket_size_bytes = bucket_size_mb * 1024 * 1024
+        buckets = _take_tensors(tensors, bucket_size_bytes)
+    else:
+        buckets = OrderedDict()
+        for tensor in tensors:
+            tp = tensor.type()
+            if tp not in buckets:
+                buckets[tp] = []
+            buckets[tp].append(tensor)
+        buckets = buckets.values()
+
+    for bucket in buckets:
+        flat_tensors = _flatten_dense_tensors(bucket)
+        dist.all_reduce(flat_tensors)
+        flat_tensors.div_(world_size)
+        for tensor, synced in zip(
+                bucket, _unflatten_dense_tensors(flat_tensors, bucket)):
+            tensor.copy_(synced)
+
+
+def allreduce_grads(params, coalesce=True, bucket_size_mb=-1):
+    """Allreduce gradients.
+
+    Args:
+        params (list[torch.Parameters]): List of parameters of a model
+        coalesce (bool, optional): Whether allreduce parameters as a whole.
+            Defaults to True.
+        bucket_size_mb (int, optional): Size of bucket, the unit is MB.
+            Defaults to -1.
+    """
+    grads = [
+        param.grad.data for param in params
+        if param.requires_grad and param.grad is not None
+    ]
+    world_size = dist.get_world_size()
+    if coalesce:
+        _allreduce_coalesced(grads, world_size, bucket_size_mb)
+    else:
+        for tensor in grads:
+            dist.all_reduce(tensor.div_(world_size))
+
+
+def reduce_mean(tensor):
+    """"Obtain the mean of tensor on different GPUs."""
+    if not (dist.is_available() and dist.is_initialized()):
+        return tensor
+    tensor = tensor.clone()
+    dist.all_reduce(tensor.div_(dist.get_world_size()), op=dist.ReduceOp.SUM)
+    return tensor
+
+
+def obj2tensor(pyobj, device='cuda'):
+    """Serialize picklable python object to tensor."""
+    storage = torch.ByteStorage.from_buffer(pickle.dumps(pyobj))
+    return torch.ByteTensor(storage).to(device=device)
+
+
+def tensor2obj(tensor):
+    """Deserialize tensor to picklable python object."""
+    return pickle.loads(tensor.cpu().numpy().tobytes())
+
+
+@functools.lru_cache()
+def _get_global_gloo_group():
+    """Return a process group based on gloo backend, containing all the ranks
+    The result is cached."""
+    if dist.get_backend() == 'nccl':
+        return dist.new_group(backend='gloo')
+    else:
+        return dist.group.WORLD
+
+
+def all_reduce_dict(py_dict, op='sum', group=None, to_float=True):
+    """Apply all reduce function for python dict object.
+
+    The code is modified from https://github.com/Megvii-
+    BaseDetection/YOLOX/blob/main/yolox/utils/allreduce_norm.py.
+
+    NOTE: make sure that py_dict in different ranks has the same keys and
+    the values should be in the same shape. Currently only supports
+    nccl backend.
+
+    Args:
+        py_dict (dict): Dict to be applied all reduce op.
+        op (str): Operator, could be 'sum' or 'mean'. Default: 'sum'
+        group (:obj:`torch.distributed.group`, optional): Distributed group,
+            Default: None.
+        to_float (bool): Whether to convert all values of dict to float.
+            Default: True.
+
+    Returns:
+        OrderedDict: reduced python dict object.
+    """
+    warnings.warn(
+        'group` is deprecated. Currently only supports NCCL backend.')
+    _, world_size = get_dist_info()
+    if world_size == 1:
+        return py_dict
+
+    # all reduce logic across different devices.
+    py_key = list(py_dict.keys())
+    if not isinstance(py_dict, OrderedDict):
+        py_key_tensor = obj2tensor(py_key)
+        dist.broadcast(py_key_tensor, src=0)
+        py_key = tensor2obj(py_key_tensor)
+
+    tensor_shapes = [py_dict[k].shape for k in py_key]
+    tensor_numels = [py_dict[k].numel() for k in py_key]
+
+    if to_float:
+        warnings.warn('Note: the "to_float" is True, you need to '
+                      'ensure that the behavior is reasonable.')
+        flatten_tensor = torch.cat(
+            [py_dict[k].flatten().float() for k in py_key])
+    else:
+        flatten_tensor = torch.cat([py_dict[k].flatten() for k in py_key])
+
+    dist.all_reduce(flatten_tensor, op=dist.ReduceOp.SUM)
+    if op == 'mean':
+        flatten_tensor /= world_size
+
+    split_tensors = [
+        x.reshape(shape) for x, shape in zip(
+            torch.split(flatten_tensor, tensor_numels), tensor_shapes)
+    ]
+    out_dict = {k: v for k, v in zip(py_key, split_tensors)}
+    if isinstance(py_dict, OrderedDict):
+        out_dict = OrderedDict(out_dict)
+    return out_dict
+
+
+def sync_random_seed(seed=None, device='cuda'):
+    """Make sure different ranks share the same seed.
+
+    All workers must call this function, otherwise it will deadlock.
+    This method is generally used in `DistributedSampler`,
+    because the seed should be identical across all processes
+    in the distributed group.
+
+    In distributed sampling, different ranks should sample non-overlapped
+    data in the dataset. Therefore, this function is used to make sure that
+    each rank shuffles the data indices in the same order based
+    on the same seed. Then different ranks could use different indices
+    to select non-overlapped data from the same data list.
+
+    Args:
+        seed (int, Optional): The seed. Default to None.
+        device (str): The device where the seed will be put on.
+            Default to 'cuda'.
+
+    Returns:
+        int: Seed to be used.
+    """
+    if seed is None:
+        seed = np.random.randint(2**31)
+    assert isinstance(seed, int)
+
+    rank, world_size = get_dist_info()
+
+    if world_size == 1:
+        return seed
+
+    if rank == 0:
+        random_num = torch.tensor(seed, dtype=torch.int32, device=device)
+    else:
+        random_num = torch.tensor(0, dtype=torch.int32, device=device)
+    dist.broadcast(random_num, src=0)
+    return random_num.item()
diff --git a/mmdetection/mmdet/utils/large_image.py b/mmdetection/mmdet/utils/large_image.py
new file mode 100644
index 00000000..f1f07c2b
--- /dev/null
+++ b/mmdetection/mmdet/utils/large_image.py
@@ -0,0 +1,104 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Sequence, Tuple
+
+import torch
+from mmcv.ops import batched_nms
+from mmengine.structures import InstanceData
+
+from mmdet.structures import DetDataSample, SampleList
+
+
+def shift_rbboxes(bboxes: torch.Tensor, offset: Sequence[int]):
+    """Shift rotated bboxes with offset.
+
+    Args:
+        bboxes (Tensor): The rotated bboxes need to be translated.
+            With shape (n, 5), which means (x, y, w, h, a).
+        offset (Sequence[int]): The translation offsets with shape of (2, ).
+    Returns:
+        Tensor: Shifted rotated bboxes.
+    """
+    offset_tensor = bboxes.new_tensor(offset)
+    shifted_bboxes = bboxes.clone()
+    shifted_bboxes[:, 0:2] = shifted_bboxes[:, 0:2] + offset_tensor
+    return shifted_bboxes
+
+
+def shift_predictions(det_data_samples: SampleList,
+                      offsets: Sequence[Tuple[int, int]],
+                      src_image_shape: Tuple[int, int]) -> SampleList:
+    """Shift predictions to the original image.
+
+    Args:
+        det_data_samples (List[:obj:`DetDataSample`]): A list of patch results.
+        offsets (Sequence[Tuple[int, int]]): Positions of the left top points
+            of patches.
+        src_image_shape (Tuple[int, int]): A (height, width) tuple of the large
+            image's width and height.
+    Returns:
+        (List[:obj:`DetDataSample`]): shifted results.
+    """
+    try:
+        from sahi.slicing import shift_bboxes, shift_masks
+    except ImportError:
+        raise ImportError('Please run "pip install -U sahi" '
+                          'to install sahi first for large image inference.')
+
+    assert len(det_data_samples) == len(
+        offsets), 'The `results` should has the ' 'same length with `offsets`.'
+    shifted_predictions = []
+    for det_data_sample, offset in zip(det_data_samples, offsets):
+        pred_inst = det_data_sample.pred_instances.clone()
+
+        # Check bbox type
+        if pred_inst.bboxes.size(-1) == 4:
+            # Horizontal bboxes
+            shifted_bboxes = shift_bboxes(pred_inst.bboxes, offset)
+        elif pred_inst.bboxes.size(-1) == 5:
+            # Rotated bboxes
+            shifted_bboxes = shift_rbboxes(pred_inst.bboxes, offset)
+        else:
+            raise NotImplementedError
+
+        # shift bboxes and masks
+        pred_inst.bboxes = shifted_bboxes
+        if 'masks' in det_data_sample:
+            pred_inst.masks = shift_masks(pred_inst.masks, offset,
+                                          src_image_shape)
+
+        shifted_predictions.append(pred_inst.clone())
+
+    shifted_predictions = InstanceData.cat(shifted_predictions)
+
+    return shifted_predictions
+
+
+def merge_results_by_nms(results: SampleList, offsets: Sequence[Tuple[int,
+                                                                      int]],
+                         src_image_shape: Tuple[int, int],
+                         nms_cfg: dict) -> DetDataSample:
+    """Merge patch results by nms.
+
+    Args:
+        results (List[:obj:`DetDataSample`]): A list of patch results.
+        offsets (Sequence[Tuple[int, int]]): Positions of the left top points
+            of patches.
+        src_image_shape (Tuple[int, int]): A (height, width) tuple of the large
+            image's width and height.
+        nms_cfg (dict): it should specify nms type and other parameters
+            like `iou_threshold`.
+    Returns:
+        :obj:`DetDataSample`: merged results.
+    """
+    shifted_instances = shift_predictions(results, offsets, src_image_shape)
+
+    _, keeps = batched_nms(
+        boxes=shifted_instances.bboxes,
+        scores=shifted_instances.scores,
+        idxs=shifted_instances.labels,
+        nms_cfg=nms_cfg)
+    merged_instances = shifted_instances[keeps]
+
+    merged_result = results[0].clone()
+    merged_result.pred_instances = merged_instances
+    return merged_result
diff --git a/mmdetection/mmdet/utils/logger.py b/mmdetection/mmdet/utils/logger.py
new file mode 100644
index 00000000..9fec08bb
--- /dev/null
+++ b/mmdetection/mmdet/utils/logger.py
@@ -0,0 +1,49 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import inspect
+
+from mmengine.logging import print_log
+
+
+def get_caller_name():
+    """Get name of caller method."""
+    # this_func_frame = inspect.stack()[0][0]  # i.e., get_caller_name
+    # callee_frame = inspect.stack()[1][0]  # e.g., log_img_scale
+    caller_frame = inspect.stack()[2][0]  # e.g., caller of log_img_scale
+    caller_method = caller_frame.f_code.co_name
+    try:
+        caller_class = caller_frame.f_locals['self'].__class__.__name__
+        return f'{caller_class}.{caller_method}'
+    except KeyError:  # caller is a function
+        return caller_method
+
+
+def log_img_scale(img_scale, shape_order='hw', skip_square=False):
+    """Log image size.
+
+    Args:
+        img_scale (tuple): Image size to be logged.
+        shape_order (str, optional): The order of image shape.
+            'hw' for (height, width) and 'wh' for (width, height).
+            Defaults to 'hw'.
+        skip_square (bool, optional): Whether to skip logging for square
+            img_scale. Defaults to False.
+
+    Returns:
+        bool: Whether to have done logging.
+    """
+    if shape_order == 'hw':
+        height, width = img_scale
+    elif shape_order == 'wh':
+        width, height = img_scale
+    else:
+        raise ValueError(f'Invalid shape_order {shape_order}.')
+
+    if skip_square and (height == width):
+        return False
+
+    caller = get_caller_name()
+    print_log(
+        f'image shape: height={height}, width={width} in {caller}',
+        logger='current')
+
+    return True
diff --git a/mmdetection/mmdet/utils/memory.py b/mmdetection/mmdet/utils/memory.py
new file mode 100644
index 00000000..b6f9cbc7
--- /dev/null
+++ b/mmdetection/mmdet/utils/memory.py
@@ -0,0 +1,212 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+from collections import abc
+from contextlib import contextmanager
+from functools import wraps
+
+import torch
+from mmengine.logging import MMLogger
+
+
+def cast_tensor_type(inputs, src_type=None, dst_type=None):
+    """Recursively convert Tensor in inputs from ``src_type`` to ``dst_type``.
+
+    Args:
+        inputs: Inputs that to be casted.
+        src_type (torch.dtype | torch.device): Source type.
+        src_type (torch.dtype | torch.device): Destination type.
+
+    Returns:
+        The same type with inputs, but all contained Tensors have been cast.
+    """
+    assert dst_type is not None
+    if isinstance(inputs, torch.Tensor):
+        if isinstance(dst_type, torch.device):
+            # convert Tensor to dst_device
+            if hasattr(inputs, 'to') and \
+                    hasattr(inputs, 'device') and \
+                    (inputs.device == src_type or src_type is None):
+                return inputs.to(dst_type)
+            else:
+                return inputs
+        else:
+            # convert Tensor to dst_dtype
+            if hasattr(inputs, 'to') and \
+                    hasattr(inputs, 'dtype') and \
+                    (inputs.dtype == src_type or src_type is None):
+                return inputs.to(dst_type)
+            else:
+                return inputs
+        # we need to ensure that the type of inputs to be casted are the same
+        # as the argument `src_type`.
+    elif isinstance(inputs, abc.Mapping):
+        return type(inputs)({
+            k: cast_tensor_type(v, src_type=src_type, dst_type=dst_type)
+            for k, v in inputs.items()
+        })
+    elif isinstance(inputs, abc.Iterable):
+        return type(inputs)(
+            cast_tensor_type(item, src_type=src_type, dst_type=dst_type)
+            for item in inputs)
+    # TODO: Currently not supported
+    # elif isinstance(inputs, InstanceData):
+    #     for key, value in inputs.items():
+    #         inputs[key] = cast_tensor_type(
+    #             value, src_type=src_type, dst_type=dst_type)
+    #     return inputs
+    else:
+        return inputs
+
+
+@contextmanager
+def _ignore_torch_cuda_oom():
+    """A context which ignores CUDA OOM exception from pytorch.
+
+    Code is modified from
+      # noqa: E501
+    """
+    try:
+        yield
+    except RuntimeError as e:
+        # NOTE: the string may change?
+        if 'CUDA out of memory. ' in str(e):
+            pass
+        else:
+            raise
+
+
+class AvoidOOM:
+    """Try to convert inputs to FP16 and CPU if got a PyTorch's CUDA Out of
+    Memory error. It will do the following steps:
+
+        1. First retry after calling `torch.cuda.empty_cache()`.
+        2. If that still fails, it will then retry by converting inputs
+          to FP16.
+        3. If that still fails trying to convert inputs to CPUs.
+          In this case, it expects the function to dispatch to
+          CPU implementation.
+
+    Args:
+        to_cpu (bool): Whether to convert outputs to CPU if get an OOM
+            error. This will slow down the code significantly.
+            Defaults to True.
+        test (bool): Skip `_ignore_torch_cuda_oom` operate that can use
+            lightweight data in unit test, only used in
+            test unit. Defaults to False.
+
+    Examples:
+        >>> from mmdet.utils.memory import AvoidOOM
+        >>> AvoidCUDAOOM = AvoidOOM()
+        >>> output = AvoidOOM.retry_if_cuda_oom(
+        >>>     some_torch_function)(input1, input2)
+        >>> # To use as a decorator
+        >>> # from mmdet.utils import AvoidCUDAOOM
+        >>> @AvoidCUDAOOM.retry_if_cuda_oom
+        >>> def function(*args, **kwargs):
+        >>>     return None
+    ```
+
+    Note:
+        1. The output may be on CPU even if inputs are on GPU. Processing
+            on CPU will slow down the code significantly.
+        2. When converting inputs to CPU, it will only look at each argument
+            and check if it has `.device` and `.to` for conversion. Nested
+            structures of tensors are not supported.
+        3. Since the function might be called more than once, it has to be
+            stateless.
+    """
+
+    def __init__(self, to_cpu=True, test=False):
+        self.to_cpu = to_cpu
+        self.test = test
+
+    def retry_if_cuda_oom(self, func):
+        """Makes a function retry itself after encountering pytorch's CUDA OOM
+        error.
+
+        The implementation logic is referred to
+        https://github.com/facebookresearch/detectron2/blob/main/detectron2/utils/memory.py
+
+        Args:
+            func: a stateless callable that takes tensor-like objects
+                as arguments.
+        Returns:
+            func: a callable which retries `func` if OOM is encountered.
+        """  # noqa: W605
+
+        @wraps(func)
+        def wrapped(*args, **kwargs):
+
+            # raw function
+            if not self.test:
+                with _ignore_torch_cuda_oom():
+                    return func(*args, **kwargs)
+
+                # Clear cache and retry
+                torch.cuda.empty_cache()
+                with _ignore_torch_cuda_oom():
+                    return func(*args, **kwargs)
+
+            # get the type and device of first tensor
+            dtype, device = None, None
+            values = args + tuple(kwargs.values())
+            for value in values:
+                if isinstance(value, torch.Tensor):
+                    dtype = value.dtype
+                    device = value.device
+                    break
+            if dtype is None or device is None:
+                raise ValueError('There is no tensor in the inputs, '
+                                 'cannot get dtype and device.')
+
+            # Convert to FP16
+            fp16_args = cast_tensor_type(args, dst_type=torch.half)
+            fp16_kwargs = cast_tensor_type(kwargs, dst_type=torch.half)
+            logger = MMLogger.get_current_instance()
+            logger.warning(f'Attempting to copy inputs of {str(func)} '
+                           'to FP16 due to CUDA OOM')
+
+            # get input tensor type, the output type will same as
+            # the first parameter type.
+            with _ignore_torch_cuda_oom():
+                output = func(*fp16_args, **fp16_kwargs)
+                output = cast_tensor_type(
+                    output, src_type=torch.half, dst_type=dtype)
+                if not self.test:
+                    return output
+            logger.warning('Using FP16 still meet CUDA OOM')
+
+            # Try on CPU. This will slow down the code significantly,
+            # therefore print a notice.
+            if self.to_cpu:
+                logger.warning(f'Attempting to copy inputs of {str(func)} '
+                               'to CPU due to CUDA OOM')
+                cpu_device = torch.empty(0).device
+                cpu_args = cast_tensor_type(args, dst_type=cpu_device)
+                cpu_kwargs = cast_tensor_type(kwargs, dst_type=cpu_device)
+
+                # convert outputs to GPU
+                with _ignore_torch_cuda_oom():
+                    logger.warning(f'Convert outputs to GPU (device={device})')
+                    output = func(*cpu_args, **cpu_kwargs)
+                    output = cast_tensor_type(
+                        output, src_type=cpu_device, dst_type=device)
+                    return output
+
+                warnings.warn('Cannot convert output to GPU due to CUDA OOM, '
+                              'the output is now on CPU, which might cause '
+                              'errors if the output need to interact with GPU '
+                              'data in subsequent operations')
+                logger.warning('Cannot convert output to GPU due to '
+                               'CUDA OOM, the output is on CPU now.')
+
+                return func(*cpu_args, **cpu_kwargs)
+            else:
+                # may still get CUDA OOM error
+                return func(*args, **kwargs)
+
+        return wrapped
+
+
+# To use AvoidOOM as a decorator
+AvoidCUDAOOM = AvoidOOM()
diff --git a/mmdetection/mmdet/utils/misc.py b/mmdetection/mmdet/utils/misc.py
new file mode 100644
index 00000000..8dfb3944
--- /dev/null
+++ b/mmdetection/mmdet/utils/misc.py
@@ -0,0 +1,149 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import glob
+import os
+import os.path as osp
+import urllib
+import warnings
+from typing import Union
+
+import torch
+from mmengine.config import Config, ConfigDict
+from mmengine.logging import print_log
+from mmengine.utils import scandir
+
+IMG_EXTENSIONS = ('.jpg', '.jpeg', '.png', '.ppm', '.bmp', '.pgm', '.tif',
+                  '.tiff', '.webp')
+
+
+def find_latest_checkpoint(path, suffix='pth'):
+    """Find the latest checkpoint from the working directory.
+
+    Args:
+        path(str): The path to find checkpoints.
+        suffix(str): File extension.
+            Defaults to pth.
+
+    Returns:
+        latest_path(str | None): File path of the latest checkpoint.
+    References:
+        .. [1] https://github.com/microsoft/SoftTeacher
+                  /blob/main/ssod/utils/patch.py
+    """
+    if not osp.exists(path):
+        warnings.warn('The path of checkpoints does not exist.')
+        return None
+    if osp.exists(osp.join(path, f'latest.{suffix}')):
+        return osp.join(path, f'latest.{suffix}')
+
+    checkpoints = glob.glob(osp.join(path, f'*.{suffix}'))
+    if len(checkpoints) == 0:
+        warnings.warn('There are no checkpoints in the path.')
+        return None
+    latest = -1
+    latest_path = None
+    for checkpoint in checkpoints:
+        count = int(osp.basename(checkpoint).split('_')[-1].split('.')[0])
+        if count > latest:
+            latest = count
+            latest_path = checkpoint
+    return latest_path
+
+
+def update_data_root(cfg, logger=None):
+    """Update data root according to env MMDET_DATASETS.
+
+    If set env MMDET_DATASETS, update cfg.data_root according to
+    MMDET_DATASETS. Otherwise, using cfg.data_root as default.
+
+    Args:
+        cfg (:obj:`Config`): The model config need to modify
+        logger (logging.Logger | str | None): the way to print msg
+    """
+    assert isinstance(cfg, Config), \
+        f'cfg got wrong type: {type(cfg)}, expected mmengine.Config'
+
+    if 'MMDET_DATASETS' in os.environ:
+        dst_root = os.environ['MMDET_DATASETS']
+        print_log(f'MMDET_DATASETS has been set to be {dst_root}.'
+                  f'Using {dst_root} as data root.')
+    else:
+        return
+
+    assert isinstance(cfg, Config), \
+        f'cfg got wrong type: {type(cfg)}, expected mmengine.Config'
+
+    def update(cfg, src_str, dst_str):
+        for k, v in cfg.items():
+            if isinstance(v, ConfigDict):
+                update(cfg[k], src_str, dst_str)
+            if isinstance(v, str) and src_str in v:
+                cfg[k] = v.replace(src_str, dst_str)
+
+    update(cfg.data, cfg.data_root, dst_root)
+    cfg.data_root = dst_root
+
+
+def get_test_pipeline_cfg(cfg: Union[str, ConfigDict]) -> ConfigDict:
+    """Get the test dataset pipeline from entire config.
+
+    Args:
+        cfg (str or :obj:`ConfigDict`): the entire config. Can be a config
+            file or a ``ConfigDict``.
+
+    Returns:
+        :obj:`ConfigDict`: the config of test dataset.
+    """
+    if isinstance(cfg, str):
+        cfg = Config.fromfile(cfg)
+
+    def _get_test_pipeline_cfg(dataset_cfg):
+        if 'pipeline' in dataset_cfg:
+            return dataset_cfg.pipeline
+        # handle dataset wrapper
+        elif 'dataset' in dataset_cfg:
+            return _get_test_pipeline_cfg(dataset_cfg.dataset)
+        # handle dataset wrappers like ConcatDataset
+        elif 'datasets' in dataset_cfg:
+            return _get_test_pipeline_cfg(dataset_cfg.datasets[0])
+
+        raise RuntimeError('Cannot find `pipeline` in `test_dataloader`')
+
+    return _get_test_pipeline_cfg(cfg.test_dataloader.dataset)
+
+
+def get_file_list(source_root: str) -> [list, dict]:
+    """Get file list.
+
+    Args:
+        source_root (str): image or video source path
+
+    Return:
+        source_file_path_list (list): A list for all source file.
+        source_type (dict): Source type: file or url or dir.
+    """
+    is_dir = os.path.isdir(source_root)
+    is_url = source_root.startswith(('http:/', 'https:/'))
+    is_file = os.path.splitext(source_root)[-1].lower() in IMG_EXTENSIONS
+
+    source_file_path_list = []
+    if is_dir:
+        # when input source is dir
+        for file in scandir(source_root, IMG_EXTENSIONS, recursive=True):
+            source_file_path_list.append(os.path.join(source_root, file))
+    elif is_url:
+        # when input source is url
+        filename = os.path.basename(
+            urllib.parse.unquote(source_root).split('?')[0])
+        file_save_path = os.path.join(os.getcwd(), filename)
+        print(f'Downloading source file to {file_save_path}')
+        torch.hub.download_url_to_file(source_root, file_save_path)
+        source_file_path_list = [file_save_path]
+    elif is_file:
+        # when input source is single image
+        source_file_path_list = [source_root]
+    else:
+        print('Cannot find image file.')
+
+    source_type = dict(is_dir=is_dir, is_url=is_url, is_file=is_file)
+
+    return source_file_path_list, source_type
diff --git a/mmdetection/mmdet/utils/mot_error_visualize.py b/mmdetection/mmdet/utils/mot_error_visualize.py
new file mode 100644
index 00000000..01bf8645
--- /dev/null
+++ b/mmdetection/mmdet/utils/mot_error_visualize.py
@@ -0,0 +1,273 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+from typing import Union
+
+try:
+    import seaborn as sns
+except ImportError:
+    sns = None
+import cv2
+import matplotlib.pyplot as plt
+import mmcv
+import numpy as np
+from matplotlib.patches import Rectangle
+from mmengine.utils import mkdir_or_exist
+
+
+def imshow_mot_errors(*args, backend: str = 'cv2', **kwargs):
+    """Show the wrong tracks on the input image.
+
+    Args:
+        backend (str, optional): Backend of visualization.
+            Defaults to 'cv2'.
+    """
+    if backend == 'cv2':
+        return _cv2_show_wrong_tracks(*args, **kwargs)
+    elif backend == 'plt':
+        return _plt_show_wrong_tracks(*args, **kwargs)
+    else:
+        raise NotImplementedError()
+
+
+def _cv2_show_wrong_tracks(img: Union[str, np.ndarray],
+                           bboxes: np.ndarray,
+                           ids: np.ndarray,
+                           error_types: np.ndarray,
+                           thickness: int = 2,
+                           font_scale: float = 0.4,
+                           text_width: int = 10,
+                           text_height: int = 15,
+                           show: bool = False,
+                           wait_time: int = 100,
+                           out_file: str = None) -> np.ndarray:
+    """Show the wrong tracks with opencv.
+
+    Args:
+        img (str or ndarray): The image to be displayed.
+        bboxes (ndarray): A ndarray of shape (k, 5).
+        ids (ndarray): A ndarray of shape (k, ).
+        error_types (ndarray): A ndarray of shape (k, ), where 0 denotes
+            false positives, 1 denotes false negative and 2 denotes ID switch.
+        thickness (int, optional): Thickness of lines.
+            Defaults to 2.
+        font_scale (float, optional): Font scale to draw id and score.
+            Defaults to 0.4.
+        text_width (int, optional): Width to draw id and score.
+            Defaults to 10.
+        text_height (int, optional): Height to draw id and score.
+            Defaults to 15.
+        show (bool, optional): Whether to show the image on the fly.
+            Defaults to False.
+        wait_time (int, optional): Value of waitKey param.
+            Defaults to 100.
+        out_file (str, optional): The filename to write the image.
+            Defaults to None.
+
+    Returns:
+        ndarray: Visualized image.
+    """
+    if sns is None:
+        raise ImportError('please run pip install seaborn')
+    assert bboxes.ndim == 2, \
+        f' bboxes ndim should be 2, but its ndim is {bboxes.ndim}.'
+    assert ids.ndim == 1, \
+        f' ids ndim should be 1, but its ndim is {ids.ndim}.'
+    assert error_types.ndim == 1, \
+        f' error_types ndim should be 1, but its ndim is {error_types.ndim}.'
+    assert bboxes.shape[0] == ids.shape[0], \
+        'bboxes.shape[0] and ids.shape[0] should have the same length.'
+    assert bboxes.shape[1] == 5, \
+        f' bboxes.shape[1] should be 5, but its {bboxes.shape[1]}.'
+
+    bbox_colors = sns.color_palette()
+    # red, yellow, blue
+    bbox_colors = [bbox_colors[3], bbox_colors[1], bbox_colors[0]]
+    bbox_colors = [[int(255 * _c) for _c in bbox_color][::-1]
+                   for bbox_color in bbox_colors]
+
+    if isinstance(img, str):
+        img = mmcv.imread(img)
+    else:
+        assert img.ndim == 3
+
+    img_shape = img.shape
+    bboxes[:, 0::2] = np.clip(bboxes[:, 0::2], 0, img_shape[1])
+    bboxes[:, 1::2] = np.clip(bboxes[:, 1::2], 0, img_shape[0])
+
+    for bbox, error_type, id in zip(bboxes, error_types, ids):
+        x1, y1, x2, y2 = bbox[:4].astype(np.int32)
+        score = float(bbox[-1])
+
+        # bbox
+        bbox_color = bbox_colors[error_type]
+        cv2.rectangle(img, (x1, y1), (x2, y2), bbox_color, thickness=thickness)
+
+        # FN does not have id and score
+        if error_type == 1:
+            continue
+
+        # score
+        text = '{:.02f}'.format(score)
+        width = (len(text) - 1) * text_width
+        img[y1:y1 + text_height, x1:x1 + width, :] = bbox_color
+        cv2.putText(
+            img,
+            text, (x1, y1 + text_height - 2),
+            cv2.FONT_HERSHEY_COMPLEX,
+            font_scale,
+            color=(0, 0, 0))
+
+        # id
+        text = str(id)
+        width = len(text) * text_width
+        img[y1 + text_height:y1 + text_height * 2,
+            x1:x1 + width, :] = bbox_color
+        cv2.putText(
+            img,
+            str(id), (x1, y1 + text_height * 2 - 2),
+            cv2.FONT_HERSHEY_COMPLEX,
+            font_scale,
+            color=(0, 0, 0))
+
+    if show:
+        mmcv.imshow(img, wait_time=wait_time)
+    if out_file is not None:
+        mmcv.imwrite(img, out_file)
+
+    return img
+
+
+def _plt_show_wrong_tracks(img: Union[str, np.ndarray],
+                           bboxes: np.ndarray,
+                           ids: np.ndarray,
+                           error_types: np.ndarray,
+                           thickness: float = 0.1,
+                           font_scale: float = 3.0,
+                           text_width: int = 8,
+                           text_height: int = 13,
+                           show: bool = False,
+                           wait_time: int = 100,
+                           out_file: str = None) -> np.ndarray:
+    """Show the wrong tracks with matplotlib.
+
+    Args:
+        img (str or ndarray): The image to be displayed.
+        bboxes (ndarray): A ndarray of shape (k, 5).
+        ids (ndarray): A ndarray of shape (k, ).
+        error_types (ndarray): A ndarray of shape (k, ), where 0 denotes
+            false positives, 1 denotes false negative and 2 denotes ID switch.
+        thickness (float, optional): Thickness of lines.
+            Defaults to 0.1.
+        font_scale (float, optional): Font scale to draw id and score.
+            Defaults to 3.0.
+        text_width (int, optional): Width to draw id and score.
+            Defaults to 8.
+        text_height (int, optional): Height to draw id and score.
+            Defaults to 13.
+        show (bool, optional): Whether to show the image on the fly.
+            Defaults to False.
+        wait_time (int, optional): Value of waitKey param.
+            Defaults to 100.
+        out_file (str, optional): The filename to write the image.
+            Defaults to None.
+
+    Returns:
+        ndarray: Original image.
+    """
+    assert bboxes.ndim == 2, \
+        f' bboxes ndim should be 2, but its ndim is {bboxes.ndim}.'
+    assert ids.ndim == 1, \
+        f' ids ndim should be 1, but its ndim is {ids.ndim}.'
+    assert error_types.ndim == 1, \
+        f' error_types ndim should be 1, but its ndim is {error_types.ndim}.'
+    assert bboxes.shape[0] == ids.shape[0], \
+        'bboxes.shape[0] and ids.shape[0] should have the same length.'
+    assert bboxes.shape[1] == 5, \
+        f' bboxes.shape[1] should be 5, but its {bboxes.shape[1]}.'
+
+    bbox_colors = sns.color_palette()
+    # red, yellow, blue
+    bbox_colors = [bbox_colors[3], bbox_colors[1], bbox_colors[0]]
+
+    if isinstance(img, str):
+        img = plt.imread(img)
+    else:
+        assert img.ndim == 3
+        img = mmcv.bgr2rgb(img)
+
+    img_shape = img.shape
+    bboxes[:, 0::2] = np.clip(bboxes[:, 0::2], 0, img_shape[1])
+    bboxes[:, 1::2] = np.clip(bboxes[:, 1::2], 0, img_shape[0])
+
+    plt.imshow(img)
+    plt.gca().set_axis_off()
+    plt.autoscale(False)
+    plt.subplots_adjust(
+        top=1, bottom=0, right=1, left=0, hspace=None, wspace=None)
+    plt.margins(0, 0)
+    plt.gca().xaxis.set_major_locator(plt.NullLocator())
+    plt.gca().yaxis.set_major_locator(plt.NullLocator())
+    plt.rcParams['figure.figsize'] = img_shape[1], img_shape[0]
+
+    for bbox, error_type, id in zip(bboxes, error_types, ids):
+        x1, y1, x2, y2, score = bbox
+        w, h = int(x2 - x1), int(y2 - y1)
+        left_top = (int(x1), int(y1))
+
+        # bbox
+        plt.gca().add_patch(
+            Rectangle(
+                left_top,
+                w,
+                h,
+                thickness,
+                edgecolor=bbox_colors[error_type],
+                facecolor='none'))
+
+        # FN does not have id and score
+        if error_type == 1:
+            continue
+
+        # score
+        text = '{:.02f}'.format(score)
+        width = len(text) * text_width
+        plt.gca().add_patch(
+            Rectangle((left_top[0], left_top[1]),
+                      width,
+                      text_height,
+                      thickness,
+                      edgecolor=bbox_colors[error_type],
+                      facecolor=bbox_colors[error_type]))
+
+        plt.text(
+            left_top[0],
+            left_top[1] + text_height + 2,
+            text,
+            fontsize=font_scale)
+
+        # id
+        text = str(id)
+        width = len(text) * text_width
+        plt.gca().add_patch(
+            Rectangle((left_top[0], left_top[1] + text_height + 1),
+                      width,
+                      text_height,
+                      thickness,
+                      edgecolor=bbox_colors[error_type],
+                      facecolor=bbox_colors[error_type]))
+        plt.text(
+            left_top[0],
+            left_top[1] + 2 * (text_height + 1),
+            text,
+            fontsize=font_scale)
+
+    if out_file is not None:
+        mkdir_or_exist(osp.abspath(osp.dirname(out_file)))
+        plt.savefig(out_file, dpi=300, bbox_inches='tight', pad_inches=0.0)
+
+    if show:
+        plt.draw()
+        plt.pause(wait_time / 1000.)
+
+    plt.clf()
+    return img
diff --git a/mmdetection/mmdet/utils/profiling.py b/mmdetection/mmdet/utils/profiling.py
new file mode 100644
index 00000000..2f53f456
--- /dev/null
+++ b/mmdetection/mmdet/utils/profiling.py
@@ -0,0 +1,40 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import contextlib
+import sys
+import time
+
+import torch
+
+if sys.version_info >= (3, 7):
+
+    @contextlib.contextmanager
+    def profile_time(trace_name,
+                     name,
+                     enabled=True,
+                     stream=None,
+                     end_stream=None):
+        """Print time spent by CPU and GPU.
+
+        Useful as a temporary context manager to find sweet spots of code
+        suitable for async implementation.
+        """
+        if (not enabled) or not torch.cuda.is_available():
+            yield
+            return
+        stream = stream if stream else torch.cuda.current_stream()
+        end_stream = end_stream if end_stream else stream
+        start = torch.cuda.Event(enable_timing=True)
+        end = torch.cuda.Event(enable_timing=True)
+        stream.record_event(start)
+        try:
+            cpu_start = time.monotonic()
+            yield
+        finally:
+            cpu_end = time.monotonic()
+            end_stream.record_event(end)
+            end.synchronize()
+            cpu_time = (cpu_end - cpu_start) * 1000
+            gpu_time = start.elapsed_time(end)
+            msg = f'{trace_name} {name} cpu_time {cpu_time:.2f} ms '
+            msg += f'gpu_time {gpu_time:.2f} ms stream {stream}'
+            print(msg, end_stream)
diff --git a/mmdetection/mmdet/utils/replace_cfg_vals.py b/mmdetection/mmdet/utils/replace_cfg_vals.py
new file mode 100644
index 00000000..a3331a36
--- /dev/null
+++ b/mmdetection/mmdet/utils/replace_cfg_vals.py
@@ -0,0 +1,70 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import re
+
+from mmengine.config import Config
+
+
+def replace_cfg_vals(ori_cfg):
+    """Replace the string "${key}" with the corresponding value.
+
+    Replace the "${key}" with the value of ori_cfg.key in the config. And
+    support replacing the chained ${key}. Such as, replace "${key0.key1}"
+    with the value of cfg.key0.key1. Code is modified from `vars.py
+    < https://github.com/microsoft/SoftTeacher/blob/main/ssod/utils/vars.py>`_  # noqa: E501
+
+    Args:
+        ori_cfg (mmengine.config.Config):
+            The origin config with "${key}" generated from a file.
+
+    Returns:
+        updated_cfg [mmengine.config.Config]:
+            The config with "${key}" replaced by the corresponding value.
+    """
+
+    def get_value(cfg, key):
+        for k in key.split('.'):
+            cfg = cfg[k]
+        return cfg
+
+    def replace_value(cfg):
+        if isinstance(cfg, dict):
+            return {key: replace_value(value) for key, value in cfg.items()}
+        elif isinstance(cfg, list):
+            return [replace_value(item) for item in cfg]
+        elif isinstance(cfg, tuple):
+            return tuple([replace_value(item) for item in cfg])
+        elif isinstance(cfg, str):
+            # the format of string cfg may be:
+            # 1) "${key}", which will be replaced with cfg.key directly
+            # 2) "xxx${key}xxx" or "xxx${key1}xxx${key2}xxx",
+            # which will be replaced with the string of the cfg.key
+            keys = pattern_key.findall(cfg)
+            values = [get_value(ori_cfg, key[2:-1]) for key in keys]
+            if len(keys) == 1 and keys[0] == cfg:
+                # the format of string cfg is "${key}"
+                cfg = values[0]
+            else:
+                for key, value in zip(keys, values):
+                    # the format of string cfg is
+                    # "xxx${key}xxx" or "xxx${key1}xxx${key2}xxx"
+                    assert not isinstance(value, (dict, list, tuple)), \
+                        f'for the format of string cfg is ' \
+                        f"'xxxxx${key}xxxxx' or 'xxx${key}xxx${key}xxx', " \
+                        f"the type of the value of '${key}' " \
+                        f'can not be dict, list, or tuple' \
+                        f'but you input {type(value)} in {cfg}'
+                    cfg = cfg.replace(key, str(value))
+            return cfg
+        else:
+            return cfg
+
+    # the pattern of string "${key}"
+    pattern_key = re.compile(r'\$\{[a-zA-Z\d_.]*\}')
+    # the type of ori_cfg._cfg_dict is mmengine.config.ConfigDict
+    updated_cfg = Config(
+        replace_value(ori_cfg._cfg_dict), filename=ori_cfg.filename)
+    # replace the model with model_wrapper
+    if updated_cfg.get('model_wrapper', None) is not None:
+        updated_cfg.model = updated_cfg.model_wrapper
+        updated_cfg.pop('model_wrapper')
+    return updated_cfg
diff --git a/mmdetection/mmdet/utils/setup_env.py b/mmdetection/mmdet/utils/setup_env.py
new file mode 100644
index 00000000..a7b37845
--- /dev/null
+++ b/mmdetection/mmdet/utils/setup_env.py
@@ -0,0 +1,118 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import datetime
+import logging
+import os
+import platform
+import warnings
+
+import cv2
+import torch.multiprocessing as mp
+from mmengine import DefaultScope
+from mmengine.logging import print_log
+from mmengine.utils import digit_version
+
+
+def setup_cache_size_limit_of_dynamo():
+    """Setup cache size limit of dynamo.
+
+    Note: Due to the dynamic shape of the loss calculation and
+    post-processing parts in the object detection algorithm, these
+    functions must be compiled every time they are run.
+    Setting a large value for torch._dynamo.config.cache_size_limit
+    may result in repeated compilation, which can slow down training
+    and testing speed. Therefore, we need to set the default value of
+    cache_size_limit smaller. An empirical value is 4.
+    """
+
+    import torch
+    if digit_version(torch.__version__) >= digit_version('2.0.0'):
+        if 'DYNAMO_CACHE_SIZE_LIMIT' in os.environ:
+            import torch._dynamo
+            cache_size_limit = int(os.environ['DYNAMO_CACHE_SIZE_LIMIT'])
+            torch._dynamo.config.cache_size_limit = cache_size_limit
+            print_log(
+                f'torch._dynamo.config.cache_size_limit is force '
+                f'set to {cache_size_limit}.',
+                logger='current',
+                level=logging.WARNING)
+
+
+def setup_multi_processes(cfg):
+    """Setup multi-processing environment variables."""
+    # set multi-process start method as `fork` to speed up the training
+    if platform.system() != 'Windows':
+        mp_start_method = cfg.get('mp_start_method', 'fork')
+        current_method = mp.get_start_method(allow_none=True)
+        if current_method is not None and current_method != mp_start_method:
+            warnings.warn(
+                f'Multi-processing start method `{mp_start_method}` is '
+                f'different from the previous setting `{current_method}`.'
+                f'It will be force set to `{mp_start_method}`. You can change '
+                f'this behavior by changing `mp_start_method` in your config.')
+        mp.set_start_method(mp_start_method, force=True)
+
+    # disable opencv multithreading to avoid system being overloaded
+    opencv_num_threads = cfg.get('opencv_num_threads', 0)
+    cv2.setNumThreads(opencv_num_threads)
+
+    # setup OMP threads
+    # This code is referred from https://github.com/pytorch/pytorch/blob/master/torch/distributed/run.py  # noqa
+    workers_per_gpu = cfg.data.get('workers_per_gpu', 1)
+    if 'train_dataloader' in cfg.data:
+        workers_per_gpu = \
+            max(cfg.data.train_dataloader.get('workers_per_gpu', 1),
+                workers_per_gpu)
+
+    if 'OMP_NUM_THREADS' not in os.environ and workers_per_gpu > 1:
+        omp_num_threads = 1
+        warnings.warn(
+            f'Setting OMP_NUM_THREADS environment variable for each process '
+            f'to be {omp_num_threads} in default, to avoid your system being '
+            f'overloaded, please further tune the variable for optimal '
+            f'performance in your application as needed.')
+        os.environ['OMP_NUM_THREADS'] = str(omp_num_threads)
+
+    # setup MKL threads
+    if 'MKL_NUM_THREADS' not in os.environ and workers_per_gpu > 1:
+        mkl_num_threads = 1
+        warnings.warn(
+            f'Setting MKL_NUM_THREADS environment variable for each process '
+            f'to be {mkl_num_threads} in default, to avoid your system being '
+            f'overloaded, please further tune the variable for optimal '
+            f'performance in your application as needed.')
+        os.environ['MKL_NUM_THREADS'] = str(mkl_num_threads)
+
+
+def register_all_modules(init_default_scope: bool = True) -> None:
+    """Register all modules in mmdet into the registries.
+
+    Args:
+        init_default_scope (bool): Whether initialize the mmdet default scope.
+            When `init_default_scope=True`, the global default scope will be
+            set to `mmdet`, and all registries will build modules from mmdet's
+            registry node. To understand more about the registry, please refer
+            to https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/registry.md
+            Defaults to True.
+    """  # noqa
+    import mmdet.datasets  # noqa: F401,F403
+    import mmdet.engine  # noqa: F401,F403
+    import mmdet.evaluation  # noqa: F401,F403
+    import mmdet.models  # noqa: F401,F403
+    import mmdet.visualization  # noqa: F401,F403
+
+    if init_default_scope:
+        never_created = DefaultScope.get_current_instance() is None \
+                        or not DefaultScope.check_instance_created('mmdet')
+        if never_created:
+            DefaultScope.get_instance('mmdet', scope_name='mmdet')
+            return
+        current_scope = DefaultScope.get_current_instance()
+        if current_scope.scope_name != 'mmdet':
+            warnings.warn('The current default scope '
+                          f'"{current_scope.scope_name}" is not "mmdet", '
+                          '`register_all_modules` will force the current'
+                          'default scope to be "mmdet". If this is not '
+                          'expected, please set `init_default_scope=False`.')
+            # avoid name conflict
+            new_instance_name = f'mmdet-{datetime.datetime.now()}'
+            DefaultScope.get_instance(new_instance_name, scope_name='mmdet')
diff --git a/mmdetection/mmdet/utils/split_batch.py b/mmdetection/mmdet/utils/split_batch.py
new file mode 100644
index 00000000..0276fb33
--- /dev/null
+++ b/mmdetection/mmdet/utils/split_batch.py
@@ -0,0 +1,45 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+
+
+def split_batch(img, img_metas, kwargs):
+    """Split data_batch by tags.
+
+    Code is modified from
+     # noqa: E501
+
+    Args:
+        img (Tensor): of shape (N, C, H, W) encoding input images.
+            Typically these should be mean centered and std scaled.
+        img_metas (list[dict]): List of image info dict where each dict
+            has: 'img_shape', 'scale_factor', 'flip', and may also contain
+            'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
+            For details on the values of these keys, see
+            :class:`mmdet.datasets.pipelines.Collect`.
+        kwargs (dict): Specific to concrete implementation.
+
+    Returns:
+        data_groups (dict): a dict that data_batch splited by tags,
+            such as 'sup', 'unsup_teacher', and 'unsup_student'.
+    """
+
+    # only stack img in the batch
+    def fuse_list(obj_list, obj):
+        return torch.stack(obj_list) if isinstance(obj,
+                                                   torch.Tensor) else obj_list
+
+    # select data with tag from data_batch
+    def select_group(data_batch, current_tag):
+        group_flag = [tag == current_tag for tag in data_batch['tag']]
+        return {
+            k: fuse_list([vv for vv, gf in zip(v, group_flag) if gf], v)
+            for k, v in data_batch.items()
+        }
+
+    kwargs.update({'img': img, 'img_metas': img_metas})
+    kwargs.update({'tag': [meta['tag'] for meta in img_metas]})
+    tags = list(set(kwargs['tag']))
+    data_groups = {tag: select_group(kwargs, tag) for tag in tags}
+    for tag, group in data_groups.items():
+        group.pop('tag')
+    return data_groups
diff --git a/mmdetection/mmdet/utils/typing_utils.py b/mmdetection/mmdet/utils/typing_utils.py
new file mode 100644
index 00000000..6caf6de5
--- /dev/null
+++ b/mmdetection/mmdet/utils/typing_utils.py
@@ -0,0 +1,22 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+"""Collecting some commonly used type hint in mmdetection."""
+from typing import List, Optional, Sequence, Tuple, Union
+
+from mmengine.config import ConfigDict
+from mmengine.structures import InstanceData, PixelData
+
+# TODO: Need to avoid circular import with assigner and sampler
+# Type hint of config data
+ConfigType = Union[ConfigDict, dict]
+OptConfigType = Optional[ConfigType]
+# Type hint of one or more config data
+MultiConfig = Union[ConfigType, List[ConfigType]]
+OptMultiConfig = Optional[MultiConfig]
+
+InstanceList = List[InstanceData]
+OptInstanceList = Optional[InstanceList]
+
+PixelList = List[PixelData]
+OptPixelList = Optional[PixelList]
+
+RangeType = Sequence[Tuple[int, int]]
diff --git a/mmdetection/mmdet/utils/util_mixins.py b/mmdetection/mmdet/utils/util_mixins.py
new file mode 100644
index 00000000..b83b6617
--- /dev/null
+++ b/mmdetection/mmdet/utils/util_mixins.py
@@ -0,0 +1,105 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+"""This module defines the :class:`NiceRepr` mixin class, which defines a
+``__repr__`` and ``__str__`` method that only depend on a custom ``__nice__``
+method, which you must define. This means you only have to overload one
+function instead of two.  Furthermore, if the object defines a ``__len__``
+method, then the ``__nice__`` method defaults to something sensible, otherwise
+it is treated as abstract and raises ``NotImplementedError``.
+
+To use simply have your object inherit from :class:`NiceRepr`
+(multi-inheritance should be ok).
+
+This code was copied from the ubelt library: https://github.com/Erotemic/ubelt
+
+Example:
+    >>> # Objects that define __nice__ have a default __str__ and __repr__
+    >>> class Student(NiceRepr):
+    ...    def __init__(self, name):
+    ...        self.name = name
+    ...    def __nice__(self):
+    ...        return self.name
+    >>> s1 = Student('Alice')
+    >>> s2 = Student('Bob')
+    >>> print(f's1 = {s1}')
+    >>> print(f's2 = {s2}')
+    s1 = 
+    s2 = 
+
+Example:
+    >>> # Objects that define __len__ have a default __nice__
+    >>> class Group(NiceRepr):
+    ...    def __init__(self, data):
+    ...        self.data = data
+    ...    def __len__(self):
+    ...        return len(self.data)
+    >>> g = Group([1, 2, 3])
+    >>> print(f'g = {g}')
+    g = 
+"""
+import warnings
+
+
+class NiceRepr:
+    """Inherit from this class and define ``__nice__`` to "nicely" print your
+    objects.
+
+    Defines ``__str__`` and ``__repr__`` in terms of ``__nice__`` function
+    Classes that inherit from :class:`NiceRepr` should redefine ``__nice__``.
+    If the inheriting class has a ``__len__``, method then the default
+    ``__nice__`` method will return its length.
+
+    Example:
+        >>> class Foo(NiceRepr):
+        ...    def __nice__(self):
+        ...        return 'info'
+        >>> foo = Foo()
+        >>> assert str(foo) == ''
+        >>> assert repr(foo).startswith('>> class Bar(NiceRepr):
+        ...    pass
+        >>> bar = Bar()
+        >>> import pytest
+        >>> with pytest.warns(None) as record:
+        >>>     assert 'object at' in str(bar)
+        >>>     assert 'object at' in repr(bar)
+
+    Example:
+        >>> class Baz(NiceRepr):
+        ...    def __len__(self):
+        ...        return 5
+        >>> baz = Baz()
+        >>> assert str(baz) == ''
+    """
+
+    def __nice__(self):
+        """str: a "nice" summary string describing this module"""
+        if hasattr(self, '__len__'):
+            # It is a common pattern for objects to use __len__ in __nice__
+            # As a convenience we define a default __nice__ for these objects
+            return str(len(self))
+        else:
+            # In all other cases force the subclass to overload __nice__
+            raise NotImplementedError(
+                f'Define the __nice__ method for {self.__class__!r}')
+
+    def __repr__(self):
+        """str: the string of the module"""
+        try:
+            nice = self.__nice__()
+            classname = self.__class__.__name__
+            return f'<{classname}({nice}) at {hex(id(self))}>'
+        except NotImplementedError as ex:
+            warnings.warn(str(ex), category=RuntimeWarning)
+            return object.__repr__(self)
+
+    def __str__(self):
+        """str: the string of the module"""
+        try:
+            classname = self.__class__.__name__
+            nice = self.__nice__()
+            return f'<{classname}({nice})>'
+        except NotImplementedError as ex:
+            warnings.warn(str(ex), category=RuntimeWarning)
+            return object.__repr__(self)
diff --git a/mmdetection/mmdet/utils/util_random.py b/mmdetection/mmdet/utils/util_random.py
new file mode 100644
index 00000000..dc1ecb6c
--- /dev/null
+++ b/mmdetection/mmdet/utils/util_random.py
@@ -0,0 +1,34 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+"""Helpers for random number generators."""
+import numpy as np
+
+
+def ensure_rng(rng=None):
+    """Coerces input into a random number generator.
+
+    If the input is None, then a global random state is returned.
+
+    If the input is a numeric value, then that is used as a seed to construct a
+    random state. Otherwise the input is returned as-is.
+
+    Adapted from [1]_.
+
+    Args:
+        rng (int | numpy.random.RandomState | None):
+            if None, then defaults to the global rng. Otherwise this can be an
+            integer or a RandomState class
+    Returns:
+        (numpy.random.RandomState) : rng -
+            a numpy random number generator
+
+    References:
+        .. [1] https://gitlab.kitware.com/computer-vision/kwarray/blob/master/kwarray/util_random.py#L270  # noqa: E501
+    """
+
+    if rng is None:
+        rng = np.random.mtrand._rand
+    elif isinstance(rng, int):
+        rng = np.random.RandomState(rng)
+    else:
+        rng = rng
+    return rng
diff --git a/mmdetection/mmdet/version.py b/mmdetection/mmdet/version.py
new file mode 100644
index 00000000..47989fc0
--- /dev/null
+++ b/mmdetection/mmdet/version.py
@@ -0,0 +1,27 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+__version__ = '3.3.0'
+short_version = __version__
+
+
+def parse_version_info(version_str):
+    """Parse a version string into a tuple.
+
+    Args:
+        version_str (str): The version string.
+    Returns:
+        tuple[int | str]: The version info, e.g., "1.3.0" is parsed into
+            (1, 3, 0), and "2.0.0rc1" is parsed into (2, 0, 0, 'rc1').
+    """
+    version_info = []
+    for x in version_str.split('.'):
+        if x.isdigit():
+            version_info.append(int(x))
+        elif x.find('rc') != -1:
+            patch_version = x.split('rc')
+            version_info.append(int(patch_version[0]))
+            version_info.append(f'rc{patch_version[1]}')
+    return tuple(version_info)
+
+
+version_info = parse_version_info(__version__)
diff --git a/mmdetection/mmdet/visualization/__init__.py b/mmdetection/mmdet/visualization/__init__.py
new file mode 100644
index 00000000..a7edaed9
--- /dev/null
+++ b/mmdetection/mmdet/visualization/__init__.py
@@ -0,0 +1,8 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .local_visualizer import DetLocalVisualizer, TrackLocalVisualizer
+from .palette import get_palette, jitter_color, palette_val
+
+__all__ = [
+    'palette_val', 'get_palette', 'DetLocalVisualizer', 'jitter_color',
+    'TrackLocalVisualizer'
+]
diff --git a/mmdetection/mmdet/visualization/local_visualizer.py b/mmdetection/mmdet/visualization/local_visualizer.py
new file mode 100644
index 00000000..cc6521c5
--- /dev/null
+++ b/mmdetection/mmdet/visualization/local_visualizer.py
@@ -0,0 +1,699 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, List, Optional, Tuple, Union
+
+import cv2
+import mmcv
+import numpy as np
+
+try:
+    import seaborn as sns
+except ImportError:
+    sns = None
+import torch
+from mmengine.dist import master_only
+from mmengine.structures import InstanceData, PixelData
+from mmengine.visualization import Visualizer
+
+from ..evaluation import INSTANCE_OFFSET
+from ..registry import VISUALIZERS
+from ..structures import DetDataSample
+from ..structures.mask import BitmapMasks, PolygonMasks, bitmap_to_polygon
+from .palette import _get_adaptive_scales, get_palette, jitter_color
+
+
+@VISUALIZERS.register_module()
+class DetLocalVisualizer(Visualizer):
+    """MMDetection Local Visualizer.
+
+    Args:
+        name (str): Name of the instance. Defaults to 'visualizer'.
+        image (np.ndarray, optional): the origin image to draw. The format
+            should be RGB. Defaults to None.
+        vis_backends (list, optional): Visual backend config list.
+            Defaults to None.
+        save_dir (str, optional): Save file dir for all storage backends.
+            If it is None, the backend storage will not save any data.
+        bbox_color (str, tuple(int), optional): Color of bbox lines.
+            The tuple of color should be in BGR order. Defaults to None.
+        text_color (str, tuple(int), optional): Color of texts.
+            The tuple of color should be in BGR order.
+            Defaults to (200, 200, 200).
+        mask_color (str, tuple(int), optional): Color of masks.
+            The tuple of color should be in BGR order.
+            Defaults to None.
+        line_width (int, float): The linewidth of lines.
+            Defaults to 3.
+        alpha (int, float): The transparency of bboxes or mask.
+            Defaults to 0.8.
+
+    Examples:
+        >>> import numpy as np
+        >>> import torch
+        >>> from mmengine.structures import InstanceData
+        >>> from mmdet.structures import DetDataSample
+        >>> from mmdet.visualization import DetLocalVisualizer
+
+        >>> det_local_visualizer = DetLocalVisualizer()
+        >>> image = np.random.randint(0, 256,
+        ...                     size=(10, 12, 3)).astype('uint8')
+        >>> gt_instances = InstanceData()
+        >>> gt_instances.bboxes = torch.Tensor([[1, 2, 2, 5]])
+        >>> gt_instances.labels = torch.randint(0, 2, (1,))
+        >>> gt_det_data_sample = DetDataSample()
+        >>> gt_det_data_sample.gt_instances = gt_instances
+        >>> det_local_visualizer.add_datasample('image', image,
+        ...                         gt_det_data_sample)
+        >>> det_local_visualizer.add_datasample(
+        ...                       'image', image, gt_det_data_sample,
+        ...                        out_file='out_file.jpg')
+        >>> det_local_visualizer.add_datasample(
+        ...                        'image', image, gt_det_data_sample,
+        ...                         show=True)
+        >>> pred_instances = InstanceData()
+        >>> pred_instances.bboxes = torch.Tensor([[2, 4, 4, 8]])
+        >>> pred_instances.labels = torch.randint(0, 2, (1,))
+        >>> pred_det_data_sample = DetDataSample()
+        >>> pred_det_data_sample.pred_instances = pred_instances
+        >>> det_local_visualizer.add_datasample('image', image,
+        ...                         gt_det_data_sample,
+        ...                         pred_det_data_sample)
+    """
+
+    def __init__(self,
+                 name: str = 'visualizer',
+                 image: Optional[np.ndarray] = None,
+                 vis_backends: Optional[Dict] = None,
+                 save_dir: Optional[str] = None,
+                 bbox_color: Optional[Union[str, Tuple[int]]] = None,
+                 text_color: Optional[Union[str,
+                                            Tuple[int]]] = (200, 200, 200),
+                 mask_color: Optional[Union[str, Tuple[int]]] = None,
+                 line_width: Union[int, float] = 3,
+                 alpha: float = 0.8) -> None:
+        super().__init__(
+            name=name,
+            image=image,
+            vis_backends=vis_backends,
+            save_dir=save_dir)
+        self.bbox_color = bbox_color
+        self.text_color = text_color
+        self.mask_color = mask_color
+        self.line_width = line_width
+        self.alpha = alpha
+        # Set default value. When calling
+        # `DetLocalVisualizer().dataset_meta=xxx`,
+        # it will override the default value.
+        self.dataset_meta = {}
+
+    def _draw_instances(self, image: np.ndarray, instances: ['InstanceData'],
+                        classes: Optional[List[str]],
+                        palette: Optional[List[tuple]]) -> np.ndarray:
+        """Draw instances of GT or prediction.
+
+        Args:
+            image (np.ndarray): The image to draw.
+            instances (:obj:`InstanceData`): Data structure for
+                instance-level annotations or predictions.
+            classes (List[str], optional): Category information.
+            palette (List[tuple], optional): Palette information
+                corresponding to the category.
+
+        Returns:
+            np.ndarray: the drawn image which channel is RGB.
+        """
+        self.set_image(image)
+
+        if 'bboxes' in instances and instances.bboxes.sum() > 0:
+            bboxes = instances.bboxes
+            labels = instances.labels
+
+            max_label = int(max(labels) if len(labels) > 0 else 0)
+            text_palette = get_palette(self.text_color, max_label + 1)
+            text_colors = [text_palette[label] for label in labels]
+
+            bbox_color = palette if self.bbox_color is None \
+                else self.bbox_color
+            bbox_palette = get_palette(bbox_color, max_label + 1)
+            colors = [bbox_palette[label] for label in labels]
+            self.draw_bboxes(
+                bboxes,
+                edge_colors=colors,
+                alpha=self.alpha,
+                line_widths=self.line_width)
+
+            positions = bboxes[:, :2] + self.line_width
+            areas = (bboxes[:, 3] - bboxes[:, 1]) * (
+                bboxes[:, 2] - bboxes[:, 0])
+            scales = _get_adaptive_scales(areas)
+
+            for i, (pos, label) in enumerate(zip(positions, labels)):
+                if 'label_names' in instances:
+                    label_text = instances.label_names[i]
+                else:
+                    label_text = classes[
+                        label] if classes is not None else f'class {label}'
+                if 'scores' in instances:
+                    score = round(float(instances.scores[i]) * 100, 1)
+                    label_text += f': {score}'
+
+                self.draw_texts(
+                    label_text,
+                    pos,
+                    colors=text_colors[i],
+                    font_sizes=int(13 * scales[i]),
+                    bboxes=[{
+                        'facecolor': 'black',
+                        'alpha': 0.8,
+                        'pad': 0.7,
+                        'edgecolor': 'none'
+                    }])
+
+        if 'masks' in instances:
+            labels = instances.labels
+            masks = instances.masks
+            if isinstance(masks, torch.Tensor):
+                masks = masks.numpy()
+            elif isinstance(masks, (PolygonMasks, BitmapMasks)):
+                masks = masks.to_ndarray()
+
+            masks = masks.astype(bool)
+
+            max_label = int(max(labels) if len(labels) > 0 else 0)
+            mask_color = palette if self.mask_color is None \
+                else self.mask_color
+            mask_palette = get_palette(mask_color, max_label + 1)
+            colors = [jitter_color(mask_palette[label]) for label in labels]
+            text_palette = get_palette(self.text_color, max_label + 1)
+            text_colors = [text_palette[label] for label in labels]
+
+            polygons = []
+            for i, mask in enumerate(masks):
+                contours, _ = bitmap_to_polygon(mask)
+                polygons.extend(contours)
+            self.draw_polygons(polygons, edge_colors='w', alpha=self.alpha)
+            self.draw_binary_masks(masks, colors=colors, alphas=self.alpha)
+
+            if len(labels) > 0 and \
+                    ('bboxes' not in instances or
+                     instances.bboxes.sum() == 0):
+                # instances.bboxes.sum()==0 represent dummy bboxes.
+                # A typical example of SOLO does not exist bbox branch.
+                areas = []
+                positions = []
+                for mask in masks:
+                    _, _, stats, centroids = cv2.connectedComponentsWithStats(
+                        mask.astype(np.uint8), connectivity=8)
+                    if stats.shape[0] > 1:
+                        largest_id = np.argmax(stats[1:, -1]) + 1
+                        positions.append(centroids[largest_id])
+                        areas.append(stats[largest_id, -1])
+                areas = np.stack(areas, axis=0)
+                scales = _get_adaptive_scales(areas)
+
+                for i, (pos, label) in enumerate(zip(positions, labels)):
+                    if 'label_names' in instances:
+                        label_text = instances.label_names[i]
+                    else:
+                        label_text = classes[
+                            label] if classes is not None else f'class {label}'
+                    if 'scores' in instances:
+                        score = round(float(instances.scores[i]) * 100, 1)
+                        label_text += f': {score}'
+
+                    self.draw_texts(
+                        label_text,
+                        pos,
+                        colors=text_colors[i],
+                        font_sizes=int(13 * scales[i]),
+                        horizontal_alignments='center',
+                        bboxes=[{
+                            'facecolor': 'black',
+                            'alpha': 0.8,
+                            'pad': 0.7,
+                            'edgecolor': 'none'
+                        }])
+        return self.get_image()
+
+    def _draw_panoptic_seg(self, image: np.ndarray,
+                           panoptic_seg: ['PixelData'],
+                           classes: Optional[List[str]],
+                           palette: Optional[List]) -> np.ndarray:
+        """Draw panoptic seg of GT or prediction.
+
+        Args:
+            image (np.ndarray): The image to draw.
+            panoptic_seg (:obj:`PixelData`): Data structure for
+                pixel-level annotations or predictions.
+            classes (List[str], optional): Category information.
+
+        Returns:
+            np.ndarray: the drawn image which channel is RGB.
+        """
+        # TODO: Is there a way to bypass？
+        num_classes = len(classes)
+
+        panoptic_seg_data = panoptic_seg.sem_seg[0]
+
+        ids = np.unique(panoptic_seg_data)[::-1]
+
+        if 'label_names' in panoptic_seg:
+            # open set panoptic segmentation
+            classes = panoptic_seg.metainfo['label_names']
+            ignore_index = panoptic_seg.metainfo.get('ignore_index',
+                                                     len(classes))
+            ids = ids[ids != ignore_index]
+        else:
+            # for VOID label
+            ids = ids[ids != num_classes]
+
+        labels = np.array([id % INSTANCE_OFFSET for id in ids], dtype=np.int64)
+        segms = (panoptic_seg_data[None] == ids[:, None, None])
+
+        max_label = int(max(labels) if len(labels) > 0 else 0)
+
+        mask_color = palette if self.mask_color is None \
+            else self.mask_color
+        mask_palette = get_palette(mask_color, max_label + 1)
+        colors = [mask_palette[label] for label in labels]
+
+        self.set_image(image)
+
+        # draw segm
+        polygons = []
+        for i, mask in enumerate(segms):
+            contours, _ = bitmap_to_polygon(mask)
+            polygons.extend(contours)
+        self.draw_polygons(polygons, edge_colors='w', alpha=self.alpha)
+        self.draw_binary_masks(segms, colors=colors, alphas=self.alpha)
+
+        # draw label
+        areas = []
+        positions = []
+        for mask in segms:
+            _, _, stats, centroids = cv2.connectedComponentsWithStats(
+                mask.astype(np.uint8), connectivity=8)
+            max_id = np.argmax(stats[1:, -1]) + 1
+            positions.append(centroids[max_id])
+            areas.append(stats[max_id, -1])
+        areas = np.stack(areas, axis=0)
+        scales = _get_adaptive_scales(areas)
+
+        text_palette = get_palette(self.text_color, max_label + 1)
+        text_colors = [text_palette[label] for label in labels]
+
+        for i, (pos, label) in enumerate(zip(positions, labels)):
+            label_text = classes[label]
+
+            self.draw_texts(
+                label_text,
+                pos,
+                colors=text_colors[i],
+                font_sizes=int(13 * scales[i]),
+                bboxes=[{
+                    'facecolor': 'black',
+                    'alpha': 0.8,
+                    'pad': 0.7,
+                    'edgecolor': 'none'
+                }],
+                horizontal_alignments='center')
+        return self.get_image()
+
+    def _draw_sem_seg(self, image: np.ndarray, sem_seg: PixelData,
+                      classes: Optional[List],
+                      palette: Optional[List]) -> np.ndarray:
+        """Draw semantic seg of GT or prediction.
+
+        Args:
+            image (np.ndarray): The image to draw.
+            sem_seg (:obj:`PixelData`): Data structure for pixel-level
+                annotations or predictions.
+            classes (list, optional): Input classes for result rendering, as
+                the prediction of segmentation model is a segment map with
+                label indices, `classes` is a list which includes items
+                responding to the label indices. If classes is not defined,
+                visualizer will take `cityscapes` classes by default.
+                Defaults to None.
+            palette (list, optional): Input palette for result rendering, which
+                is a list of color palette responding to the classes.
+                Defaults to None.
+
+        Returns:
+            np.ndarray: the drawn image which channel is RGB.
+        """
+        sem_seg_data = sem_seg.sem_seg
+        if isinstance(sem_seg_data, torch.Tensor):
+            sem_seg_data = sem_seg_data.numpy()
+
+        # 0 ~ num_class, the value 0 means background
+        ids = np.unique(sem_seg_data)
+        ignore_index = sem_seg.metainfo.get('ignore_index', 255)
+        ids = ids[ids != ignore_index]
+
+        if 'label_names' in sem_seg:
+            # open set semseg
+            label_names = sem_seg.metainfo['label_names']
+        else:
+            label_names = classes
+
+        labels = np.array(ids, dtype=np.int64)
+        colors = [palette[label] for label in labels]
+
+        self.set_image(image)
+
+        # draw semantic masks
+        for i, (label, color) in enumerate(zip(labels, colors)):
+            masks = sem_seg_data == label
+            self.draw_binary_masks(masks, colors=[color], alphas=self.alpha)
+            label_text = label_names[label]
+            _, _, stats, centroids = cv2.connectedComponentsWithStats(
+                masks[0].astype(np.uint8), connectivity=8)
+            if stats.shape[0] > 1:
+                largest_id = np.argmax(stats[1:, -1]) + 1
+                centroids = centroids[largest_id]
+
+                areas = stats[largest_id, -1]
+                scales = _get_adaptive_scales(areas)
+
+                self.draw_texts(
+                    label_text,
+                    centroids,
+                    colors=(255, 255, 255),
+                    font_sizes=int(13 * scales),
+                    horizontal_alignments='center',
+                    bboxes=[{
+                        'facecolor': 'black',
+                        'alpha': 0.8,
+                        'pad': 0.7,
+                        'edgecolor': 'none'
+                    }])
+
+        return self.get_image()
+
+    @master_only
+    def add_datasample(
+            self,
+            name: str,
+            image: np.ndarray,
+            data_sample: Optional['DetDataSample'] = None,
+            draw_gt: bool = True,
+            draw_pred: bool = True,
+            show: bool = False,
+            wait_time: float = 0,
+            # TODO: Supported in mmengine's Viusalizer.
+            out_file: Optional[str] = None,
+            pred_score_thr: float = 0.3,
+            step: int = 0) -> None:
+        """Draw datasample and save to all backends.
+
+        - If GT and prediction are plotted at the same time, they are
+        displayed in a stitched image where the left image is the
+        ground truth and the right image is the prediction.
+        - If ``show`` is True, all storage backends are ignored, and
+        the images will be displayed in a local window.
+        - If ``out_file`` is specified, the drawn image will be
+        saved to ``out_file``. t is usually used when the display
+        is not available.
+
+        Args:
+            name (str): The image identifier.
+            image (np.ndarray): The image to draw.
+            data_sample (:obj:`DetDataSample`, optional): A data
+                sample that contain annotations and predictions.
+                Defaults to None.
+            draw_gt (bool): Whether to draw GT DetDataSample. Default to True.
+            draw_pred (bool): Whether to draw Prediction DetDataSample.
+                Defaults to True.
+            show (bool): Whether to display the drawn image. Default to False.
+            wait_time (float): The interval of show (s). Defaults to 0.
+            out_file (str): Path to output file. Defaults to None.
+            pred_score_thr (float): The threshold to visualize the bboxes
+                and masks. Defaults to 0.3.
+            step (int): Global step value to record. Defaults to 0.
+        """
+        image = image.clip(0, 255).astype(np.uint8)
+        classes = self.dataset_meta.get('classes', None)
+        palette = self.dataset_meta.get('palette', None)
+
+        gt_img_data = None
+        pred_img_data = None
+
+        if data_sample is not None:
+            data_sample = data_sample.cpu()
+
+        if draw_gt and data_sample is not None:
+            gt_img_data = image
+            if 'gt_instances' in data_sample:
+                gt_img_data = self._draw_instances(image,
+                                                   data_sample.gt_instances,
+                                                   classes, palette)
+            if 'gt_sem_seg' in data_sample:
+                gt_img_data = self._draw_sem_seg(gt_img_data,
+                                                 data_sample.gt_sem_seg,
+                                                 classes, palette)
+
+            if 'gt_panoptic_seg' in data_sample:
+                assert classes is not None, 'class information is ' \
+                                            'not provided when ' \
+                                            'visualizing panoptic ' \
+                                            'segmentation results.'
+                gt_img_data = self._draw_panoptic_seg(
+                    gt_img_data, data_sample.gt_panoptic_seg, classes, palette)
+
+        if draw_pred and data_sample is not None:
+            pred_img_data = image
+            if 'pred_instances' in data_sample:
+                pred_instances = data_sample.pred_instances
+                pred_instances = pred_instances[
+                    pred_instances.scores > pred_score_thr]
+                pred_img_data = self._draw_instances(image, pred_instances,
+                                                     classes, palette)
+
+            if 'pred_sem_seg' in data_sample:
+                pred_img_data = self._draw_sem_seg(pred_img_data,
+                                                   data_sample.pred_sem_seg,
+                                                   classes, palette)
+
+            if 'pred_panoptic_seg' in data_sample:
+                assert classes is not None, 'class information is ' \
+                                            'not provided when ' \
+                                            'visualizing panoptic ' \
+                                            'segmentation results.'
+                pred_img_data = self._draw_panoptic_seg(
+                    pred_img_data, data_sample.pred_panoptic_seg.numpy(),
+                    classes, palette)
+
+        if gt_img_data is not None and pred_img_data is not None:
+            drawn_img = np.concatenate((gt_img_data, pred_img_data), axis=1)
+        elif gt_img_data is not None:
+            drawn_img = gt_img_data
+        elif pred_img_data is not None:
+            drawn_img = pred_img_data
+        else:
+            # Display the original image directly if nothing is drawn.
+            drawn_img = image
+
+        # It is convenient for users to obtain the drawn image.
+        # For example, the user wants to obtain the drawn image and
+        # save it as a video during video inference.
+        self.set_image(drawn_img)
+
+        if show:
+            self.show(drawn_img, win_name=name, wait_time=wait_time)
+
+        if out_file is not None:
+            mmcv.imwrite(drawn_img[..., ::-1], out_file)
+        else:
+            self.add_image(name, drawn_img, step)
+
+
+def random_color(seed):
+    """Random a color according to the input seed."""
+    if sns is None:
+        raise RuntimeError('motmetrics is not installed,\
+                 please install it by: pip install seaborn')
+    np.random.seed(seed)
+    colors = sns.color_palette()
+    color = colors[np.random.choice(range(len(colors)))]
+    color = tuple([int(255 * c) for c in color])
+    return color
+
+
+@VISUALIZERS.register_module()
+class TrackLocalVisualizer(Visualizer):
+    """Tracking Local Visualizer for the MOT, VIS tasks.
+
+    Args:
+        name (str): Name of the instance. Defaults to 'visualizer'.
+        image (np.ndarray, optional): the origin image to draw. The format
+            should be RGB. Defaults to None.
+        vis_backends (list, optional): Visual backend config list.
+            Defaults to None.
+        save_dir (str, optional): Save file dir for all storage backends.
+            If it is None, the backend storage will not save any data.
+        line_width (int, float): The linewidth of lines.
+            Defaults to 3.
+        alpha (int, float): The transparency of bboxes or mask.
+                Defaults to 0.8.
+    """
+
+    def __init__(self,
+                 name: str = 'visualizer',
+                 image: Optional[np.ndarray] = None,
+                 vis_backends: Optional[Dict] = None,
+                 save_dir: Optional[str] = None,
+                 line_width: Union[int, float] = 3,
+                 alpha: float = 0.8) -> None:
+        super().__init__(name, image, vis_backends, save_dir)
+        self.line_width = line_width
+        self.alpha = alpha
+        # Set default value. When calling
+        # `TrackLocalVisualizer().dataset_meta=xxx`,
+        # it will override the default value.
+        self.dataset_meta = {}
+
+    def _draw_instances(self, image: np.ndarray,
+                        instances: InstanceData) -> np.ndarray:
+        """Draw instances of GT or prediction.
+
+        Args:
+            image (np.ndarray): The image to draw.
+            instances (:obj:`InstanceData`): Data structure for
+                instance-level annotations or predictions.
+        Returns:
+            np.ndarray: the drawn image which channel is RGB.
+        """
+        self.set_image(image)
+        classes = self.dataset_meta.get('classes', None)
+
+        # get colors and texts
+        # for the MOT and VIS tasks
+        colors = [random_color(_id) for _id in instances.instances_id]
+        categories = [
+            classes[label] if classes is not None else f'cls{label}'
+            for label in instances.labels
+        ]
+        if 'scores' in instances:
+            texts = [
+                f'{category_name}\n{instance_id} | {score:.2f}'
+                for category_name, instance_id, score in zip(
+                    categories, instances.instances_id, instances.scores)
+            ]
+        else:
+            texts = [
+                f'{category_name}\n{instance_id}' for category_name,
+                instance_id in zip(categories, instances.instances_id)
+            ]
+
+        # draw bboxes and texts
+        if 'bboxes' in instances:
+            # draw bboxes
+            bboxes = instances.bboxes.clone()
+            self.draw_bboxes(
+                bboxes,
+                edge_colors=colors,
+                alpha=self.alpha,
+                line_widths=self.line_width)
+            # draw texts
+            if texts is not None:
+                positions = bboxes[:, :2] + self.line_width
+                areas = (bboxes[:, 3] - bboxes[:, 1]) * (
+                    bboxes[:, 2] - bboxes[:, 0])
+                scales = _get_adaptive_scales(areas.cpu().numpy())
+                for i, pos in enumerate(positions):
+                    self.draw_texts(
+                        texts[i],
+                        pos,
+                        colors='black',
+                        font_sizes=int(13 * scales[i]),
+                        bboxes=[{
+                            'facecolor': [c / 255 for c in colors[i]],
+                            'alpha': 0.8,
+                            'pad': 0.7,
+                            'edgecolor': 'none'
+                        }])
+
+        # draw masks
+        if 'masks' in instances:
+            masks = instances.masks
+            polygons = []
+            for i, mask in enumerate(masks):
+                contours, _ = bitmap_to_polygon(mask)
+                polygons.extend(contours)
+            self.draw_polygons(polygons, edge_colors='w', alpha=self.alpha)
+            self.draw_binary_masks(masks, colors=colors, alphas=self.alpha)
+
+        return self.get_image()
+
+    @master_only
+    def add_datasample(
+            self,
+            name: str,
+            image: np.ndarray,
+            data_sample: DetDataSample = None,
+            draw_gt: bool = True,
+            draw_pred: bool = True,
+            show: bool = False,
+            wait_time: int = 0,
+            # TODO: Supported in mmengine's Viusalizer.
+            out_file: Optional[str] = None,
+            pred_score_thr: float = 0.3,
+            step: int = 0) -> None:
+        """Draw datasample and save to all backends.
+
+        - If GT and prediction are plotted at the same time, they are
+        displayed in a stitched image where the left image is the
+        ground truth and the right image is the prediction.
+        - If ``show`` is True, all storage backends are ignored, and
+        the images will be displayed in a local window.
+        - If ``out_file`` is specified, the drawn image will be
+        saved to ``out_file``. t is usually used when the display
+        is not available.
+        Args:
+            name (str): The image identifier.
+            image (np.ndarray): The image to draw.
+            data_sample (OptTrackSampleList): A data
+                sample that contain annotations and predictions.
+                Defaults to None.
+            draw_gt (bool): Whether to draw GT TrackDataSample.
+                Default to True.
+            draw_pred (bool): Whether to draw Prediction TrackDataSample.
+                Defaults to True.
+            show (bool): Whether to display the drawn image. Default to False.
+            wait_time (int): The interval of show (s). Defaults to 0.
+            out_file (str): Path to output file. Defaults to None.
+            pred_score_thr (float): The threshold to visualize the bboxes
+                and masks. Defaults to 0.3.
+            step (int): Global step value to record. Defaults to 0.
+        """
+        gt_img_data = None
+        pred_img_data = None
+
+        if data_sample is not None:
+            data_sample = data_sample.cpu()
+
+        if draw_gt and data_sample is not None:
+            assert 'gt_instances' in data_sample
+            gt_img_data = self._draw_instances(image, data_sample.gt_instances)
+
+        if draw_pred and data_sample is not None:
+            assert 'pred_track_instances' in data_sample
+            pred_instances = data_sample.pred_track_instances
+            if 'scores' in pred_instances:
+                pred_instances = pred_instances[
+                    pred_instances.scores > pred_score_thr].cpu()
+            pred_img_data = self._draw_instances(image, pred_instances)
+
+        if gt_img_data is not None and pred_img_data is not None:
+            drawn_img = np.concatenate((gt_img_data, pred_img_data), axis=1)
+        elif gt_img_data is not None:
+            drawn_img = gt_img_data
+        else:
+            drawn_img = pred_img_data
+
+        if show:
+            self.show(drawn_img, win_name=name, wait_time=wait_time)
+
+        if out_file is not None:
+            mmcv.imwrite(drawn_img[..., ::-1], out_file)
+        else:
+            self.add_image(name, drawn_img, step)
diff --git a/mmdetection/mmdet/visualization/palette.py b/mmdetection/mmdet/visualization/palette.py
new file mode 100644
index 00000000..3c402c08
--- /dev/null
+++ b/mmdetection/mmdet/visualization/palette.py
@@ -0,0 +1,108 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple, Union
+
+import mmcv
+import numpy as np
+from mmengine.utils import is_str
+
+
+def palette_val(palette: List[tuple]) -> List[tuple]:
+    """Convert palette to matplotlib palette.
+
+    Args:
+        palette (List[tuple]): A list of color tuples.
+
+    Returns:
+        List[tuple[float]]: A list of RGB matplotlib color tuples.
+    """
+    new_palette = []
+    for color in palette:
+        color = [c / 255 for c in color]
+        new_palette.append(tuple(color))
+    return new_palette
+
+
+def get_palette(palette: Union[List[tuple], str, tuple],
+                num_classes: int) -> List[Tuple[int]]:
+    """Get palette from various inputs.
+
+    Args:
+        palette (list[tuple] | str | tuple): palette inputs.
+        num_classes (int): the number of classes.
+
+    Returns:
+        list[tuple[int]]: A list of color tuples.
+    """
+    assert isinstance(num_classes, int)
+
+    if isinstance(palette, list):
+        dataset_palette = palette
+    elif isinstance(palette, tuple):
+        dataset_palette = [palette] * num_classes
+    elif palette == 'random' or palette is None:
+        state = np.random.get_state()
+        # random color
+        np.random.seed(42)
+        palette = np.random.randint(0, 256, size=(num_classes, 3))
+        np.random.set_state(state)
+        dataset_palette = [tuple(c) for c in palette]
+    elif palette == 'coco':
+        from mmdet.datasets import CocoDataset, CocoPanopticDataset
+        dataset_palette = CocoDataset.METAINFO['palette']
+        if len(dataset_palette) < num_classes:
+            dataset_palette = CocoPanopticDataset.METAINFO['palette']
+    elif palette == 'citys':
+        from mmdet.datasets import CityscapesDataset
+        dataset_palette = CityscapesDataset.METAINFO['palette']
+    elif palette == 'voc':
+        from mmdet.datasets import VOCDataset
+        dataset_palette = VOCDataset.METAINFO['palette']
+    elif is_str(palette):
+        dataset_palette = [mmcv.color_val(palette)[::-1]] * num_classes
+    else:
+        raise TypeError(f'Invalid type for palette: {type(palette)}')
+
+    assert len(dataset_palette) >= num_classes, \
+        'The length of palette should not be less than `num_classes`.'
+    return dataset_palette
+
+
+def _get_adaptive_scales(areas: np.ndarray,
+                         min_area: int = 800,
+                         max_area: int = 30000) -> np.ndarray:
+    """Get adaptive scales according to areas.
+
+    The scale range is [0.5, 1.0]. When the area is less than
+    ``min_area``, the scale is 0.5 while the area is larger than
+    ``max_area``, the scale is 1.0.
+
+    Args:
+        areas (ndarray): The areas of bboxes or masks with the
+            shape of (n, ).
+        min_area (int): Lower bound areas for adaptive scales.
+            Defaults to 800.
+        max_area (int): Upper bound areas for adaptive scales.
+            Defaults to 30000.
+
+    Returns:
+        ndarray: The adaotive scales with the shape of (n, ).
+    """
+    scales = 0.5 + (areas - min_area) // (max_area - min_area)
+    scales = np.clip(scales, 0.5, 1.0)
+    return scales
+
+
+def jitter_color(color: tuple) -> tuple:
+    """Randomly jitter the given color in order to better distinguish instances
+    with the same class.
+
+    Args:
+        color (tuple): The RGB color tuple. Each value is between [0, 255].
+
+    Returns:
+        tuple: The jittered color tuple.
+    """
+    jitter = np.random.rand(3)
+    jitter = (jitter / np.linalg.norm(jitter) - 0.5) * 0.5 * 255
+    color = np.clip(jitter + color, 0, 255).astype(np.uint8)
+    return tuple(color)
diff --git a/mmdetection/model-index.yml b/mmdetection/model-index.yml
new file mode 100644
index 00000000..d4b4392b
--- /dev/null
+++ b/mmdetection/model-index.yml
@@ -0,0 +1,102 @@
+Import:
+  - configs/albu_example/metafile.yml
+  - configs/atss/metafile.yml
+  - configs/autoassign/metafile.yml
+  - configs/boxinst/metafile.yml
+  - configs/carafe/metafile.yml
+  - configs/cascade_rcnn/metafile.yml
+  - configs/cascade_rpn/metafile.yml
+  - configs/centernet/metafile.yml
+  - configs/centripetalnet/metafile.yml
+  - configs/condinst/metafile.yml
+  - configs/conditional_detr/metafile.yml
+  - configs/cornernet/metafile.yml
+  - configs/convnext/metafile.yml
+  - configs/crowddet/metafile.yml
+  - configs/dab_detr/metafile.yml
+  - configs/dcn/metafile.yml
+  - configs/dcnv2/metafile.yml
+  - configs/ddod/metafile.yml
+  - configs/deformable_detr/metafile.yml
+  - configs/detectors/metafile.yml
+  - configs/detr/metafile.yml
+  - configs/dino/metafile.yml
+  - configs/double_heads/metafile.yml
+  - configs/dyhead/metafile.yml
+  - configs/dynamic_rcnn/metafile.yml
+  - configs/efficientnet/metafile.yml
+  - configs/empirical_attention/metafile.yml
+  - configs/faster_rcnn/metafile.yml
+  - configs/fcos/metafile.yml
+  - configs/foveabox/metafile.yml
+  - configs/fpg/metafile.yml
+  - configs/free_anchor/metafile.yml
+  - configs/fsaf/metafile.yml
+  - configs/gcnet/metafile.yml
+  - configs/gfl/metafile.yml
+  - configs/ghm/metafile.yml
+  - configs/gn/metafile.yml
+  - configs/gn+ws/metafile.yml
+  - configs/grid_rcnn/metafile.yml
+  - configs/groie/metafile.yml
+  - configs/guided_anchoring/metafile.yml
+  - configs/hrnet/metafile.yml
+  - configs/htc/metafile.yml
+  - configs/instaboost/metafile.yml
+  - configs/lad/metafile.yml
+  - configs/ld/metafile.yml
+  - configs/libra_rcnn/metafile.yml
+  - configs/lvis/metafile.yml
+  - configs/mask2former/metafile.yml
+  - configs/mask_rcnn/metafile.yml
+  - configs/maskformer/metafile.yml
+  - configs/ms_rcnn/metafile.yml
+  - configs/nas_fcos/metafile.yml
+  - configs/nas_fpn/metafile.yml
+  - configs/openimages/metafile.yml
+  - configs/paa/metafile.yml
+  - configs/pafpn/metafile.yml
+  - configs/panoptic_fpn/metafile.yml
+  - configs/pvt/metafile.yml
+  - configs/pisa/metafile.yml
+  - configs/point_rend/metafile.yml
+  - configs/queryinst/metafile.yml
+  - configs/regnet/metafile.yml
+  - configs/reppoints/metafile.yml
+  - configs/res2net/metafile.yml
+  - configs/resnest/metafile.yml
+  - configs/resnet_strikes_back/metafile.yml
+  - configs/retinanet/metafile.yml
+  - configs/rpn/metafile.yml
+  - configs/rtmdet/metafile.yml
+  - configs/sabl/metafile.yml
+  - configs/scnet/metafile.yml
+  - configs/scratch/metafile.yml
+  - configs/seesaw_loss/metafile.yml
+  - configs/simple_copy_paste/metafile.yml
+  - configs/soft_teacher/metafile.yml
+  - configs/sparse_rcnn/metafile.yml
+  - configs/solo/metafile.yml
+  - configs/solov2/metafile.yml
+  - configs/ssd/metafile.yml
+  - configs/strong_baselines/metafile.yml
+  - configs/swin/metafile.yml
+  - configs/tridentnet/metafile.yml
+  - configs/tood/metafile.yml
+  - configs/vfnet/metafile.yml
+  - configs/yolact/metafile.yml
+  - configs/yolo/metafile.yml
+  - configs/yolof/metafile.yml
+  - configs/yolox/metafile.yml
+  - configs/bytetrack/metafile.yml
+  - configs/strongsort/metafile.yml
+  - configs/ocsort/metafile.yml
+  - configs/sort/metafile.yml
+  - configs/deepsort/metafile.yml
+  - configs/qdtrack/metafile.yml
+  - configs/mask2former_vis/metafile.yml
+  - configs/masktrack_rcnn/metafile.yml
+  - configs/glip/metafile.yml
+  - configs/ddq/metafile.yml
+  - configs/grounding_dino/metafile.yml
+  - configs/mm_grounding_dino/metafile.yml
diff --git a/mmdetection/projects/AlignDETR/README.md b/mmdetection/projects/AlignDETR/README.md
new file mode 100644
index 00000000..33690fe0
--- /dev/null
+++ b/mmdetection/projects/AlignDETR/README.md
@@ -0,0 +1,33 @@
+# AlignDETR
+
+> [Align-DETR: Improving DETR with Simple IoU-aware BCE loss](https://arxiv.org/abs/2304.07527)
+
+
+
+## Abstract
+
+DETR has set up a simple end-to-end pipeline for object detection by formulating this task as a set prediction problem, showing promising potential. However, despite the significant progress in improving DETR, this paper identifies a problem of misalignment in the output distribution, which prevents the best-regressed samples from being assigned with high confidence, hindering the model's accuracy. We propose a metric, recall of best-regressed samples, to quantitively evaluate the misalignment problem. Observing its importance, we propose a novel Align-DETR that incorporates a localization precision-aware classification loss in optimization. The proposed loss, IA-BCE, guides the training of DETR to build a strong correlation between classification score and localization precision. We also adopt the mixed-matching strategy, to facilitate DETR-based detectors with faster training convergence while keeping an end-to-end scheme. Moreover, to overcome the dramatic decrease in sample quality induced by the sparsity of queries, we introduce a prime sample weighting mechanism to suppress the interference of unimportant samples. Extensive experiments are conducted with very competitive results reported. In particular, it delivers a 46 (+3.8)% AP on the DAB-DETR baseline with the ResNet-50 backbone and reaches a new SOTA performance of 50.2% AP in the 1x setting on the COCO validation set when employing the strong baseline DINO.
+
+![image](https://github.com/open-mmlab/mmdetection/assets/33146359/5a4fa664-b4c6-487d-b6d8-22be9d59a2bc)
+
+## Results and Models
+
+| Backbone |    Model    | Lr schd | box AP |                       Config                       |                                                                                                                                                                    Download                                                                                                                                                                    |
+| :------: | :---------: | :-----: | :----: | :------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+|   R-50   | DINO-4scale |   12e   |  50.5  | [config](./align_detr-4scale_r50_8xb2-12e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/align_detr/align_detr-4scale_r50_8xb2-12e_coco/align_detr-4scale_r50_8xb2-12e_coco_20230914_095734-61f921af.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/align_detr/align_detr-4scale_r50_8xb2-12e_coco/align_detr-4scale_r50_8xb2-12e_coco_20230914_095734.log.json) |
+|   R-50   | DINO-4scale |   24e   |  51.4  | [config](./align_detr-4scale_r50_8xb2-24e_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/align_detr/align_detr-4scale_r50_8xb2-24e_coco/align_detr-4scale_r50_8xb2-24e_coco_20230919_152414-f4b6cf76.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/align_detr/align_detr-4scale_r50_8xb2-24e_coco/align_detr-4scale_r50_8xb2-24e_coco_20230919_152414.log.json) |
+
+## Citation
+
+We provide the config files for AlignDETR: [Align-DETR: Improving DETR with Simple IoU-aware BCE loss](https://arxiv.org/abs/2304.07527).
+
+```latex
+@misc{cai2023aligndetr,
+      title={Align-DETR: Improving DETR with Simple IoU-aware BCE loss},
+      author={Zhi Cai and Songtao Liu and Guodong Wang and Zheng Ge and Xiangyu Zhang and Di Huang},
+      year={2023},
+      eprint={2304.07527},
+      archivePrefix={arXiv},
+      primaryClass={cs.CV}
+}
+```
diff --git a/mmdetection/projects/AlignDETR/align_detr/__init__.py b/mmdetection/projects/AlignDETR/align_detr/__init__.py
new file mode 100644
index 00000000..26a49b52
--- /dev/null
+++ b/mmdetection/projects/AlignDETR/align_detr/__init__.py
@@ -0,0 +1,5 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .align_detr_head import AlignDETRHead
+from .mixed_hungarian_assigner import MixedHungarianAssigner
+
+__all__ = ['AlignDETRHead', 'MixedHungarianAssigner']
diff --git a/mmdetection/projects/AlignDETR/align_detr/align_detr_head.py b/mmdetection/projects/AlignDETR/align_detr/align_detr_head.py
new file mode 100644
index 00000000..c06d1bd4
--- /dev/null
+++ b/mmdetection/projects/AlignDETR/align_detr/align_detr_head.py
@@ -0,0 +1,508 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Any, Dict, List, Tuple, Union
+
+import torch
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.models.dense_heads import DINOHead
+from mmdet.registry import MODELS
+from mmdet.structures.bbox import (bbox_cxcywh_to_xyxy, bbox_overlaps,
+                                   bbox_xyxy_to_cxcywh)
+from mmdet.utils import InstanceList
+from .utils import KeysRecorder
+
+
+@MODELS.register_module()
+class AlignDETRHead(DINOHead):
+    r"""Head of the Align-DETR: Improving DETR with Simple IoU-aware BCE loss
+
+    Code is modified from the `official github repo
+    `_.
+
+    More details can be found in the `paper
+    `_ .
+
+    Args:
+        all_layers_num_gt_repeat List[int]: Number to repeat gt for 1-to-k
+            matching between ground truth and predictions of each decoder
+            layer. Only used for matching queries, not for denoising queries.
+            Element count is `num_pred_layer`. If `as_two_stage` is True, then
+            the last element is for encoder output, and the others for
+            decoder layers. Otherwise, all elements are for decoder layers.
+            Defaults to a list of `1` for the last decoder layer and `2` for
+            the others.
+        alpha (float): Hyper-parameter of classification loss that controls
+            the proportion of each item to calculate `t`, the weighted
+            geometric average of the confident score and the IoU score, to
+            align classification and regression scores. Defaults to `0.25`.
+        gamma (float): Hyper-parameter of classification loss to do the hard
+            negative mining. Defaults to `2.0`.
+        tau (float): Hyper-parameter of classification and regression losses,
+            it is the temperature controlling the sharpness of the function
+            to calculate positive sample weight. Defaults to `1.5`.
+    """
+
+    def __init__(self,
+                 *args,
+                 all_layers_num_gt_repeat: List[int] = None,
+                 alpha: float = 0.25,
+                 gamma: float = 2.0,
+                 tau: float = 1.5,
+                 **kwargs) -> None:
+        self.all_layers_num_gt_repeat = all_layers_num_gt_repeat
+        self.alpha = alpha
+        self.gamma = gamma
+        self.tau = tau
+        self.weight_table = torch.zeros(
+            len(all_layers_num_gt_repeat), max(all_layers_num_gt_repeat))
+        for layer_index, num_gt_repeat in enumerate(all_layers_num_gt_repeat):
+            self.weight_table[layer_index][:num_gt_repeat] = torch.exp(
+                -torch.arange(num_gt_repeat) / tau)
+
+        super().__init__(*args, **kwargs)
+        assert len(self.all_layers_num_gt_repeat) == self.num_pred_layer
+
+    def loss_by_feat(self, all_layers_cls_scores: Tensor, *args,
+                     **kwargs) -> Any:
+        """Loss function.
+            AlignDETR: This method is based on `DINOHead.loss_by_feat`.
+
+        Args:
+            all_layers_cls_scores (Tensor): Classification scores of all
+                decoder layers, has shape (num_decoder_layers, bs,
+                num_queries_total, cls_out_channels), where
+                `num_queries_total` is the sum of `num_denoising_queries`
+                and `num_matching_queries`.
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        # Wrap `all_layers_cls_scores` with KeysRecorder to record its
+        #   `__getitem__` keys and get decoder layer index.
+        all_layers_cls_scores = KeysRecorder(all_layers_cls_scores)
+        result = super(AlignDETRHead,
+                       self).loss_by_feat(all_layers_cls_scores, *args,
+                                          **kwargs)
+        return result
+
+    def loss_by_feat_single(self, cls_scores: Union[KeysRecorder, Tensor],
+                            bbox_preds: Tensor,
+                            batch_gt_instances: InstanceList,
+                            batch_img_metas: List[dict]) -> Tuple[Tensor]:
+        """Loss function for outputs from a single decoder layer of a single
+        feature level.
+            AlignDETR: This method is based on `DINOHead.loss_by_feat_single`.
+
+        Args:
+            cls_scores (Union[KeysRecorder, Tensor]): Box score logits from a
+                single decoder layer for all images, has shape (bs,
+                num_queries, cls_out_channels).
+            bbox_preds (Tensor): Sigmoid outputs from a single decoder layer
+                for all images, with normalized coordinate (cx, cy, w, h) and
+                shape (bs, num_queries, 4).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+
+        Returns:
+            Tuple[Tensor]: A tuple including `loss_cls`, `loss_box` and
+            `loss_iou`.
+        """
+        # AlignDETR: Get layer_index.
+        if isinstance(cls_scores, KeysRecorder):
+            # Outputs are from decoder layer. Get layer_index from
+            #   `__getitem__` keys history.
+            keys = [key for key in cls_scores.keys if isinstance(key, int)]
+            assert len(keys) == 1, \
+                'Failed to extract key from cls_scores.keys: {}'.format(keys)
+            layer_index = keys[0]
+            # Get dn_cls_scores tensor.
+            cls_scores = cls_scores.obj
+        else:
+            # Outputs are from encoder layer.
+            layer_index = self.num_pred_layer - 1
+
+        for img_meta in batch_img_metas:
+            img_meta['layer_index'] = layer_index
+
+        results = super(AlignDETRHead, self).loss_by_feat_single(
+            cls_scores,
+            bbox_preds,
+            batch_gt_instances=batch_gt_instances,
+            batch_img_metas=batch_img_metas)
+        return results
+
+    def get_targets(self, cls_scores_list: List[Tensor],
+                    bbox_preds_list: List[Tensor],
+                    batch_gt_instances: InstanceList,
+                    batch_img_metas: List[dict]) -> tuple:
+        """Compute regression and classification targets for a batch image.
+
+        Outputs from a single decoder layer of a single feature level are used.
+        AlignDETR: This method is based on `DETRHead.get_targets`.
+
+        Args:
+            cls_scores_list (list[Tensor]): Box score logits from a single
+                decoder layer for each image, has shape [num_queries,
+                cls_out_channels].
+            bbox_preds_list (list[Tensor]): Sigmoid outputs from a single
+                decoder layer for each image, with normalized coordinate
+                (cx, cy, w, h) and shape [num_queries, 4].
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+
+        Returns:
+            tuple: a tuple containing the following targets.
+
+            - labels_list (list[Tensor]): Labels for all images.
+            - label_weights_list (list[Tensor]): Label weights for all images.
+            - bbox_targets_list (list[Tensor]): BBox targets for all images.
+            - bbox_weights_list (list[Tensor]): BBox weights for all images.
+            - num_total_pos (int): Number of positive samples in all images.
+            - num_total_neg (int): Number of negative samples in all images.
+        """
+        results = super(AlignDETRHead,
+                        self).get_targets(cls_scores_list, bbox_preds_list,
+                                          batch_gt_instances, batch_img_metas)
+
+        # AlignDETR: `num_total_pos` for matching queries is the number of
+        #   unique gt bboxes in the batch. Refer to AlignDETR official code:
+        #   https://github.com/FelixCaae/AlignDETR/blob/8c2b1806026e1b33fe1c282577de1647e352d7f0/aligndetr/criterions/base_criterion.py#L195C15-L195C15  # noqa: E501
+        num_total_pos = sum(
+            len(gt_instances) for gt_instances in batch_gt_instances)
+
+        results = list(results)
+        results[-2] = num_total_pos
+        return tuple(results)
+
+    def _get_targets_single(self, cls_score: Tensor, bbox_pred: Tensor,
+                            gt_instances: InstanceData,
+                            img_meta: dict) -> tuple:
+        """Compute regression and classification targets for one image.
+
+        Outputs from a single decoder layer of a single feature level are used.
+        AlignDETR: This method is based on `DETRHead._get_targets_single`.
+
+        Args:
+            cls_score (Tensor): Box score logits from a single decoder layer
+                for one image. Shape [num_queries, cls_out_channels].
+            bbox_pred (Tensor): Sigmoid outputs from a single decoder layer
+                for one image, with normalized coordinate (cx, cy, w, h) and
+                shape [num_queries, 4].
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It should includes ``bboxes`` and ``labels``
+                attributes.
+            img_meta (dict): Meta information for one image.
+            layer_index (int): Decoder layer index for the outputs. Defaults
+                to `-1`.
+
+        Returns:
+            tuple[Tensor]: a tuple containing the following for one image.
+
+            - labels (Tensor): Labels of each image.
+            - label_weights (Tensor]): Label weights of each image.
+            - bbox_targets (Tensor): BBox targets of each image.
+            - bbox_weights (Tensor): BBox weights of each image.
+            - pos_inds (Tensor): Sampled positive indices for each image.
+            - neg_inds (Tensor): Sampled negative indices for each image.
+        """
+        img_h, img_w = img_meta['img_shape']
+        factor = bbox_pred.new_tensor([img_w, img_h, img_w,
+                                       img_h]).unsqueeze(0)
+        # convert bbox_pred from xywh, normalized to xyxy, unnormalized
+        bbox_pred = bbox_cxcywh_to_xyxy(bbox_pred)
+        bbox_pred = bbox_pred * factor
+
+        pred_instances = InstanceData(scores=cls_score, bboxes=bbox_pred)
+
+        # assigner and sampler
+        # AlignDETR: Get `k` of current layer.
+        layer_index = img_meta['layer_index']
+        num_gt_repeat = self.all_layers_num_gt_repeat[layer_index]
+        assign_result = self.assigner.assign(
+            pred_instances=pred_instances,
+            gt_instances=gt_instances,
+            img_meta=img_meta,
+            k=num_gt_repeat)
+
+        gt_bboxes = gt_instances.bboxes
+        gt_labels = gt_instances.labels
+        pos_inds = torch.nonzero(
+            assign_result.gt_inds > 0, as_tuple=False).squeeze(-1).unique()
+        neg_inds = torch.nonzero(
+            assign_result.gt_inds == 0, as_tuple=False).squeeze(-1).unique()
+        pos_assigned_gt_inds = assign_result.gt_inds[pos_inds] - 1
+        pos_gt_bboxes = gt_bboxes[pos_assigned_gt_inds.long(), :]
+
+        # AlignDETR: Get label targets, label weights, and bbox weights.
+        target_results = self._get_align_detr_targets_single(
+            cls_score,
+            bbox_pred,
+            gt_labels,
+            pos_gt_bboxes,
+            pos_inds,
+            pos_assigned_gt_inds,
+            layer_index,
+            is_matching_queries=True)
+
+        label_targets, label_weights, bbox_weights = target_results
+
+        # bbox targets
+        bbox_targets = torch.zeros_like(bbox_pred, dtype=gt_bboxes.dtype)
+
+        # DETR regress the relative position of boxes (cxcywh) in the image.
+        # Thus the learning target should be normalized by the image size, also
+        # the box format should be converted from defaultly x1y1x2y2 to cxcywh.
+        pos_gt_bboxes_normalized = pos_gt_bboxes / factor
+        pos_gt_bboxes_targets = bbox_xyxy_to_cxcywh(pos_gt_bboxes_normalized)
+        bbox_targets[pos_inds] = pos_gt_bboxes_targets
+        return (label_targets, label_weights, bbox_targets, bbox_weights,
+                pos_inds, neg_inds)
+
+    def _loss_dn_single(self, dn_cls_scores: KeysRecorder,
+                        dn_bbox_preds: Tensor,
+                        batch_gt_instances: InstanceList,
+                        batch_img_metas: List[dict],
+                        dn_meta: Dict[str, int]) -> Tuple[Tensor]:
+        """Denoising loss for outputs from a single decoder layer.
+            AlignDETR: This method is based on `DINOHead._loss_dn_single`.
+
+        Args:
+            dn_cls_scores (KeysRecorder): Classification scores of a single
+                decoder layer in denoising part, has shape (bs,
+                num_denoising_queries, cls_out_channels).
+            dn_bbox_preds (Tensor): Regression outputs of a single decoder
+                layer in denoising part. Each is a 4D-tensor with normalized
+                coordinate format (cx, cy, w, h) and has shape
+                (bs, num_denoising_queries, 4).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            dn_meta (Dict[str, int]): The dictionary saves information about
+              group collation, including 'num_denoising_queries' and
+              'num_denoising_groups'. It will be used for split outputs of
+              denoising and matching parts and loss calculation.
+
+        Returns:
+            Tuple[Tensor]: A tuple including `loss_cls`, `loss_box` and
+            `loss_iou`.
+        """
+        # AlignDETR: Get dn_cls_scores tensor.
+        dn_cls_scores = dn_cls_scores.obj
+
+        # AlignDETR: Add layer outputs to meta info because they are not
+        #   variables of method `_get_dn_targets_single`.
+        for image_index, img_meta in enumerate(batch_img_metas):
+            img_meta['dn_cls_score'] = dn_cls_scores[image_index]
+            img_meta['dn_bbox_pred'] = dn_bbox_preds[image_index]
+
+        results = super()._loss_dn_single(dn_cls_scores, dn_bbox_preds,
+                                          batch_gt_instances, batch_img_metas,
+                                          dn_meta)
+        return results
+
+    def _get_dn_targets_single(self, gt_instances: InstanceData,
+                               img_meta: dict, dn_meta: Dict[str,
+                                                             int]) -> tuple:
+        """Get targets in denoising part for one image.
+            AlignDETR: This method is based on
+            `DINOHead._get_dn_targets_single`.
+            and 1) Added passing `dn_cls_score`, `dn_bbox_pred` to this
+            method; 2) Modified the way to get targets.
+        Args:
+            dn_cls_score (Tensor): Box score logits from a single decoder
+            layer in denoising part for one image, has shape
+                [num_denoising_queries, cls_out_channels].
+            dn_bbox_pred (Tensor): Sigmoid outputs from a single decoder
+            layer in denoising part for one image, with
+                normalized coordinate (cx, cy, w, h) and shape
+                [num_denoising_queries, 4].
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It should includes ``bboxes`` and ``labels``
+                attributes.
+            img_meta (dict): Meta information for one image.
+            dn_meta (Dict[str, int]): The dictionary saves information about
+              group collation, including 'num_denoising_queries' and
+              'num_denoising_groups'. It will be used for split outputs of
+              denoising and matching parts and loss calculation.
+
+        Returns:
+            tuple[Tensor]: a tuple containing the following for one image.
+
+            - labels (Tensor): Labels of each image.
+            - label_weights (Tensor]): Label weights of each image.
+            - bbox_targets (Tensor): BBox targets of each image.
+            - bbox_weights (Tensor): BBox weights of each image.
+            - pos_inds (Tensor): Sampled positive indices for each image.
+            - neg_inds (Tensor): Sampled negative indices for each image.
+        """
+        gt_bboxes = gt_instances.bboxes
+        gt_labels = gt_instances.labels
+        num_groups = dn_meta['num_denoising_groups']
+        num_denoising_queries = dn_meta['num_denoising_queries']
+        num_queries_each_group = int(num_denoising_queries / num_groups)
+        device = gt_bboxes.device
+
+        if len(gt_labels) > 0:
+            t = torch.arange(len(gt_labels), dtype=torch.long, device=device)
+            t = t.unsqueeze(0).repeat(num_groups, 1)
+            pos_assigned_gt_inds = t.flatten()
+            pos_inds = torch.arange(
+                num_groups, dtype=torch.long, device=device)
+            pos_inds = pos_inds.unsqueeze(1) * num_queries_each_group + t
+            pos_inds = pos_inds.flatten()
+        else:
+            pos_inds = pos_assigned_gt_inds = \
+                gt_bboxes.new_tensor([], dtype=torch.long)
+
+        neg_inds = pos_inds + num_queries_each_group // 2
+
+        # AlignDETR: Get meta info and layer outputs.
+        img_h, img_w = img_meta['img_shape']
+        dn_cls_score = img_meta['dn_cls_score']
+        dn_bbox_pred = img_meta['dn_bbox_pred']
+        factor = dn_bbox_pred.new_tensor([img_w, img_h, img_w,
+                                          img_h]).unsqueeze(0)
+
+        # AlignDETR: Convert dn_bbox_pred from xywh, normalized to xyxy,
+        #   unnormalized.
+        dn_bbox_pred = bbox_cxcywh_to_xyxy(dn_bbox_pred)
+        dn_bbox_pred = dn_bbox_pred * factor
+
+        # AlignDETR: Get label targets, label weights, and bbox weights.
+        target_results = self._get_align_detr_targets_single(
+            dn_cls_score, dn_bbox_pred, gt_labels,
+            gt_bboxes.repeat([num_groups, 1]), pos_inds, pos_assigned_gt_inds)
+
+        label_targets, label_weights, bbox_weights = target_results
+
+        # bbox targets
+        bbox_targets = torch.zeros(num_denoising_queries, 4, device=device)
+
+        # DETR regress the relative position of boxes (cxcywh) in the image.
+        # Thus the learning target should be normalized by the image size, also
+        # the box format should be converted from defaultly x1y1x2y2 to cxcywh.
+        gt_bboxes_normalized = gt_bboxes / factor
+        gt_bboxes_targets = bbox_xyxy_to_cxcywh(gt_bboxes_normalized)
+        bbox_targets[pos_inds] = gt_bboxes_targets.repeat([num_groups, 1])
+
+        return (label_targets, label_weights, bbox_targets, bbox_weights,
+                pos_inds, neg_inds)
+
+    def _get_align_detr_targets_single(self,
+                                       cls_score: Tensor,
+                                       bbox_pred: Tensor,
+                                       gt_labels: Tensor,
+                                       pos_gt_bboxes: Tensor,
+                                       pos_inds: Tensor,
+                                       pos_assigned_gt_inds: Tensor,
+                                       layer_index: int = -1,
+                                       is_matching_queries: bool = False):
+        '''AlignDETR: Get label targets, label weights, and bbox weights based
+            on `t`, the weighted geometric average of the confident score and
+            the IoU score, to align classification and regression scores.
+
+        Args:
+            cls_score (Tensor): Box score logits from the last encoder layer
+                or a single decoder layer for one image. Shape
+                [num_queries or num_denoising_queries, cls_out_channels].
+            bbox_pred (Tensor): Sigmoid outputs from the last encoder layer
+                or a single decoder layer for one image, with unnormalized
+                coordinate (x, y, x, y) and shape
+                [num_queries or num_denoising_queries, 4].
+            gt_labels (Tensor): Ground truth classification labels for one
+                image, has shape [num_gt].
+            pos_gt_bboxes (Tensor): Positive ground truth bboxes for one
+                image, with unnormalized coordinate (x, y, x, y) and shape
+                [num_positive, 4].
+            pos_inds (Tensor): Positive prediction box indices, has shape
+                [num_positive].
+            pos_assigned_gt_inds Tensor: Positive ground truth box indices,
+                has shape [num_positive].
+            layer_index (int): decoder layer index for the outputs. Defaults
+                to `-1`.
+            is_matching_queries (bool): The outputs are from matching
+                queries or denoising queries. Defaults to `False`.
+
+        Returns:
+            tuple[Tensor]: a tuple containing the following for one image.
+
+            - label_targets (Tensor): Labels of one image. Shape
+                [num_queries or num_denoising_queries, cls_out_channels].
+            - label_weights (Tensor): Label weights of one image. Shape
+                [num_queries or num_denoising_queries, cls_out_channels].
+            - bbox_weights (Tensor): BBox weights of one image. Shape
+                [num_queries or num_denoising_queries, 4].
+        '''
+
+        # Classification loss
+        # =           1 * BCE(prob, t * rank_weights) for positive sample;
+        # = prob**gamma * BCE(prob,                0) for negative sample.
+        # That is,
+        # label_targets = 0                for negative sample;
+        #               = t * rank_weights for positive sample.
+        # label_weights = pred**gamma for negative sample;
+        #               = 1           for positive sample.
+        cls_prob = cls_score.sigmoid()
+        label_targets = torch.zeros_like(
+            cls_score, device=pos_gt_bboxes.device)
+        label_weights = cls_prob**self.gamma
+
+        bbox_weights = torch.zeros_like(bbox_pred, dtype=pos_gt_bboxes.dtype)
+
+        if len(pos_inds) == 0:
+            return label_targets, label_weights, bbox_weights
+
+        pos_cls_score_inds = (pos_inds, gt_labels[pos_assigned_gt_inds])
+        iou_scores = bbox_overlaps(
+            bbox_pred[pos_inds], pos_gt_bboxes, is_aligned=True)
+
+        # t (Tensor): The weighted geometric average of the confident score
+        #   and the IoU score, to align classification and regression scores.
+        #   Shape [num_positive].
+        t = (
+            cls_prob[pos_cls_score_inds]**self.alpha *
+            iou_scores**(1 - self.alpha))
+        t = torch.clamp(t, 0.01).detach()
+
+        # Calculate rank_weights for matching queries.
+        if is_matching_queries:
+            # rank_weights (Tensor): Weights of each group of predictions
+            #   assigned to the same positive gt bbox. Shape [num_positive].
+            rank_weights = torch.zeros_like(t, dtype=self.weight_table.dtype)
+
+            assert 0 <= layer_index < len(self.weight_table), layer_index
+            rank_to_weight = self.weight_table[layer_index].to(
+                rank_weights.device)
+            unique_gt_inds = torch.unique(pos_assigned_gt_inds)
+
+            # For each positive gt bbox, get all predictions assigned to it,
+            #   then calculate rank weights for this group of predictions.
+            for gt_index in unique_gt_inds:
+                pred_group_cond = pos_assigned_gt_inds == gt_index
+                # Weights are based on their rank sorted by t in the group.
+                pred_group = t[pred_group_cond]
+                indices = pred_group.sort(descending=True)[1]
+                group_weights = torch.zeros_like(
+                    indices, dtype=self.weight_table.dtype)
+                group_weights[indices] = rank_to_weight[:len(indices)]
+                rank_weights[pred_group_cond] = group_weights
+
+            t = t * rank_weights
+            pos_bbox_weights = rank_weights.unsqueeze(-1).repeat(
+                1, bbox_pred.size(-1))
+            bbox_weights[pos_inds] = pos_bbox_weights
+        else:
+            bbox_weights[pos_inds] = 1.0
+
+        label_targets[pos_cls_score_inds] = t
+        label_weights[pos_cls_score_inds] = 1.0
+
+        return label_targets, label_weights, bbox_weights
diff --git a/mmdetection/projects/AlignDETR/align_detr/mixed_hungarian_assigner.py b/mmdetection/projects/AlignDETR/align_detr/mixed_hungarian_assigner.py
new file mode 100644
index 00000000..cc31b5e6
--- /dev/null
+++ b/mmdetection/projects/AlignDETR/align_detr/mixed_hungarian_assigner.py
@@ -0,0 +1,162 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Union
+
+import torch
+from mmengine import ConfigDict
+from mmengine.structures import InstanceData
+from scipy.optimize import linear_sum_assignment
+from torch import Tensor
+
+from mmdet.models.task_modules import AssignResult, BaseAssigner
+from mmdet.registry import TASK_UTILS
+
+
+@TASK_UTILS.register_module()
+class MixedHungarianAssigner(BaseAssigner):
+    """Computes 1-to-k matching between ground truth and predictions.
+
+    This class computes an assignment between the targets and the predictions
+    based on the costs. The costs are weighted sum of some components.
+    For DETR the costs are weighted sum of classification cost, regression L1
+    cost and regression iou cost. The targets don't include the no_object, so
+    generally there are more predictions than targets. After the 1-to-k
+    gt-pred matching, the un-matched are treated as backgrounds. Thus
+    each query prediction will be assigned with `0` or a positive integer
+    indicating the ground truth index:
+
+    - 0: negative sample, no assigned gt
+    - positive integer: positive sample, index (1-based) of assigned gt
+
+    Args:
+        match_costs (:obj:`ConfigDict` or dict or \
+            List[Union[:obj:`ConfigDict`, dict]]): Match cost configs.
+    """
+
+    def __init__(
+        self, match_costs: Union[List[Union[dict, ConfigDict]], dict,
+                                 ConfigDict]
+    ) -> None:
+
+        if isinstance(match_costs, dict):
+            match_costs = [match_costs]
+        elif isinstance(match_costs, list):
+            assert len(match_costs) > 0, \
+                'match_costs must not be a empty list.'
+
+        self.match_costs = [
+            TASK_UTILS.build(match_cost) for match_cost in match_costs
+        ]
+
+    def assign(self,
+               pred_instances: InstanceData,
+               gt_instances: InstanceData,
+               img_meta: Optional[dict] = None,
+               k: int = 1,
+               **kwargs) -> AssignResult:
+        """Computes 1-to-k gt-pred matching based on the weighted costs.
+
+        This method assign each query prediction to a ground truth or
+        background. The `assigned_gt_inds` with -1 means don't care,
+        0 means negative sample, and positive number is the index (1-based)
+        of assigned gt.
+        The assignment is done in the following steps, the order matters.
+
+        1. Assign every prediction to -1.
+        2. Compute the weighted costs, each cost has shape
+            (num_preds, num_gts).
+        3. Update k according to num_preds and num_gts, then repeat
+            costs k times to shape: (num_preds, k * num_gts), so that each
+            gt will match k predictions.
+        4. Do Hungarian matching on CPU based on the costs.
+        5. Assign all to 0 (background) first, then for each matched pair
+           between predictions and gts, treat this prediction as foreground
+           and assign the corresponding gt index (plus 1) to it.
+
+        Args:
+            pred_instances (:obj:`InstanceData`): Instances of model
+                predictions. It includes ``priors``, and the priors can
+                be anchors or points, or the bboxes predicted by the
+                previous stage, has shape (n, 4). The bboxes predicted by
+                the current model or stage will be named ``bboxes``,
+                ``labels``, and ``scores``, the same as the ``InstanceData``
+                in other places. It may includes ``masks``, with shape
+                (n, h, w) or (n, l).
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes``, with shape (k, 4),
+                ``labels``, with shape (k, ) and ``masks``, with shape
+                (k, h, w) or (k, l).
+            img_meta (dict): Image information for one image.
+
+        Returns:
+            :obj:`AssignResult`: The assigned result.
+        """
+        assert isinstance(gt_instances.labels, Tensor)
+        num_gts, num_preds = len(gt_instances), len(pred_instances)
+        gt_labels = gt_instances.labels
+        device = gt_labels.device
+
+        # 1. Assign -1 by default.
+        assigned_gt_inds = torch.full((num_preds, ),
+                                      -1,
+                                      dtype=torch.long,
+                                      device=device)
+        assigned_labels = torch.full((num_preds, ),
+                                     -1,
+                                     dtype=torch.long,
+                                     device=device)
+
+        if num_gts == 0 or num_preds == 0:
+            # No ground truth or boxes, return empty assignment.
+            if num_gts == 0:
+                # No ground truth, assign all to background.
+                assigned_gt_inds[:] = 0
+            return AssignResult(
+                num_gts=num_gts,
+                gt_inds=assigned_gt_inds,
+                max_overlaps=None,
+                labels=assigned_labels)
+
+        # 2. Compute weighted costs.
+        cost_list = []
+        for match_cost in self.match_costs:
+            cost = match_cost(
+                pred_instances=pred_instances,
+                gt_instances=gt_instances,
+                img_meta=img_meta)
+            cost_list.append(cost)
+        cost = torch.stack(cost_list).sum(dim=0)
+
+        # 3. Update k according to num_preds and num_gts,  then
+        #   repeat the ground truth k times to perform 1-to-k gt-pred
+        #   matching. For example, if num_preds = 900, num_gts = 3, then
+        #   there are only 3 gt-pred pairs in sum for 1-1 matching.
+        #   However, for 1-k gt-pred matching, if k = 4, then each
+        #   gt is assigned 4 unique predictions, so there would be 12
+        #   gt-pred pairs in sum.
+        k = max(1, min(k, num_preds // num_gts))
+        cost = cost.repeat(1, k)
+
+        # 4. Do Hungarian matching on CPU using linear_sum_assignment.
+        cost = cost.detach().cpu()
+        if linear_sum_assignment is None:
+            raise ImportError('Please run "pip install scipy" '
+                              'to install scipy first.')
+
+        matched_row_inds, matched_col_inds = linear_sum_assignment(cost)
+        matched_row_inds = torch.from_numpy(matched_row_inds).to(device)
+        matched_col_inds = torch.from_numpy(matched_col_inds).to(device)
+
+        matched_col_inds = matched_col_inds % num_gts
+        # 5. Assign backgrounds and foregrounds.
+        # Assign all indices to backgrounds first.
+        assigned_gt_inds[:] = 0
+        # Assign foregrounds based on matching results.
+        assigned_gt_inds[matched_row_inds] = matched_col_inds + 1
+        assigned_labels[matched_row_inds] = gt_labels[matched_col_inds]
+        assign_result = AssignResult(
+            num_gts=k * num_gts,
+            gt_inds=assigned_gt_inds,
+            max_overlaps=None,
+            labels=assigned_labels)
+
+        return assign_result
diff --git a/mmdetection/projects/AlignDETR/align_detr/utils.py b/mmdetection/projects/AlignDETR/align_detr/utils.py
new file mode 100644
index 00000000..5a3c17ec
--- /dev/null
+++ b/mmdetection/projects/AlignDETR/align_detr/utils.py
@@ -0,0 +1,34 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Any, List, Optional
+
+
+class KeysRecorder:
+    """Wrap object to record its `__getitem__` keys in the history.
+
+    Args:
+        obj (object): Any object that supports `__getitem__`.
+        keys (List): List of keys already recorded. Default to None.
+    """
+
+    def __init__(self, obj: Any, keys: Optional[List[Any]] = None) -> None:
+        self.obj = obj
+
+        if keys is None:
+            keys = []
+        self.keys = keys
+
+    def __getitem__(self, key: Any) -> 'KeysRecorder':
+        """Wrap method `__getitem__`  to record its keys.
+
+        Args:
+            key: Key that is passed to the object.
+
+        Returns:
+            result (KeysRecorder): KeysRecorder instance that wraps sub_obj.
+        """
+        sub_obj = self.obj.__getitem__(key)
+        keys = self.keys.copy()
+        keys.append(key)
+        # Create a KeysRecorder instance from the sub_obj.
+        result = KeysRecorder(sub_obj, keys)
+        return result
diff --git a/mmdetection/projects/AlignDETR/configs/align_detr-4scale_r50_8xb2-12e_coco.py b/mmdetection/projects/AlignDETR/configs/align_detr-4scale_r50_8xb2-12e_coco.py
new file mode 100644
index 00000000..0fe06990
--- /dev/null
+++ b/mmdetection/projects/AlignDETR/configs/align_detr-4scale_r50_8xb2-12e_coco.py
@@ -0,0 +1,185 @@
+_base_ = [
+    '../../../configs/_base_/datasets/coco_detection.py',
+    '../../../configs/_base_/default_runtime.py'
+]
+custom_imports = dict(
+    imports=['projects.AlignDETR.align_detr'], allow_failed_imports=False)
+
+model = dict(
+    type='DINO',
+    num_queries=900,  # num_matching_queries
+    with_box_refine=True,
+    as_two_stage=True,
+    data_preprocessor=dict(
+        type='DetDataPreprocessor',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        bgr_to_rgb=True,
+        pad_size_divisor=1),
+    backbone=dict(
+        type='ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(1, 2, 3),
+        # AlignDETR: Only freeze stem.
+        frozen_stages=0,
+        norm_cfg=dict(type='FrozenBN', requires_grad=False),
+        norm_eval=True,
+        style='pytorch',
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),
+    neck=dict(
+        type='ChannelMapper',
+        in_channels=[512, 1024, 2048],
+        kernel_size=1,
+        out_channels=256,
+        # AlignDETR: Add conv bias.
+        bias=True,
+        act_cfg=None,
+        norm_cfg=dict(type='GN', num_groups=32),
+        num_outs=4),
+    encoder=dict(
+        num_layers=6,
+        layer_cfg=dict(
+            self_attn_cfg=dict(embed_dims=256, num_levels=4,
+                               dropout=0.0),  # 0.1 for DeformDETR
+            ffn_cfg=dict(
+                embed_dims=256,
+                feedforward_channels=2048,  # 1024 for DeformDETR
+                ffn_drop=0.0))),  # 0.1 for DeformDETR
+    decoder=dict(
+        num_layers=6,
+        return_intermediate=True,
+        layer_cfg=dict(
+            self_attn_cfg=dict(embed_dims=256, num_heads=8,
+                               dropout=0.0),  # 0.1 for DeformDETR
+            cross_attn_cfg=dict(embed_dims=256, num_levels=4,
+                                dropout=0.0),  # 0.1 for DeformDETR
+            ffn_cfg=dict(
+                embed_dims=256,
+                feedforward_channels=2048,  # 1024 for DeformDETR
+                ffn_drop=0.0)),  # 0.1 for DeformDETR
+        post_norm_cfg=None),
+    positional_encoding=dict(
+        num_feats=128,
+        normalize=True,
+        # AlignDETR: Set offset and temperature the same as DeformDETR.
+        offset=-0.5,  # -0.5 for DeformDETR
+        temperature=10000),  # 10000 for DeformDETR
+    bbox_head=dict(
+        type='AlignDETRHead',
+        # AlignDETR: First 6 elements of `all_layers_num_gt_repeat` are for
+        #   decoder layers' outputs. The last element is for encoder layer.
+        all_layers_num_gt_repeat=[2, 2, 2, 2, 2, 1, 2],
+        alpha=0.25,
+        gamma=2.0,
+        tau=1.5,
+        num_classes=80,
+        sync_cls_avg_factor=True,
+        loss_cls=dict(
+            type='CrossEntropyLoss', use_sigmoid=True,
+            loss_weight=1.0),  # 2.0 in DeformDETR
+        loss_bbox=dict(type='L1Loss', loss_weight=5.0),
+        loss_iou=dict(type='GIoULoss', loss_weight=2.0)),
+    dn_cfg=dict(  # TODO: Move to model.train_cfg ?
+        label_noise_scale=0.5,
+        box_noise_scale=1.0,  # 0.4 for DN-DETR
+        group_cfg=dict(dynamic=True, num_groups=None,
+                       num_dn_queries=100)),  # TODO: half num_dn_queries
+    # training and testing settings
+    train_cfg=dict(
+        assigner=dict(
+            type='MixedHungarianAssigner',
+            match_costs=[
+                dict(type='FocalLossCost', weight=2.0),
+                dict(type='BBoxL1Cost', weight=5.0, box_format='xywh'),
+                dict(type='IoUCost', iou_mode='giou', weight=2.0)
+            ])),
+    test_cfg=dict(max_per_img=300))  # 100 for DeformDETR
+
+# train_pipeline, NOTE the img_scale and the Pad's size_divisor is different
+# from the default setting in mmdet.
+train_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=_base_.backend_args),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(
+        type='RandomChoice',
+        transforms=[
+            [
+                dict(
+                    type='RandomChoiceResize',
+                    scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333),
+                            (608, 1333), (640, 1333), (672, 1333), (704, 1333),
+                            (736, 1333), (768, 1333), (800, 1333)],
+                    keep_ratio=True)
+            ],
+            [
+                dict(
+                    type='RandomChoiceResize',
+                    # The radio of all image in train dataset < 7
+                    # follow the original implement
+                    scales=[(400, 4200), (500, 4200), (600, 4200)],
+                    keep_ratio=True),
+                dict(
+                    type='RandomCrop',
+                    crop_type='absolute_range',
+                    crop_size=(384, 600),
+                    allow_negative_crop=True),
+                dict(
+                    type='RandomChoiceResize',
+                    scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333),
+                            (608, 1333), (640, 1333), (672, 1333), (704, 1333),
+                            (736, 1333), (768, 1333), (800, 1333)],
+                    keep_ratio=True)
+            ]
+        ]),
+    dict(type='PackDetInputs')
+]
+train_dataloader = dict(
+    dataset=dict(
+        # AlignDETR: Filter empty gt.
+        filter_cfg=dict(filter_empty_gt=True),
+        pipeline=train_pipeline))
+
+# optimizer
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW',
+        lr=0.0001,  # 0.0002 for DeformDETR
+        weight_decay=0.0001),
+    clip_grad=dict(max_norm=0.1, norm_type=2),
+    paramwise_cfg=dict(
+        custom_keys={'backbone': dict(lr_mult=0.1)},
+        # AlignDETR: No norm decay.
+        norm_decay_mult=0.0)
+)  # custom_keys contains sampling_offsets and reference_points in DeformDETR  # noqa
+
+# learning policy
+max_epochs = 12
+train_cfg = dict(
+    type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1)
+
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+
+param_scheduler = [
+    dict(
+        type='LinearLR',
+        start_factor=0.0001,
+        by_epoch=False,
+        begin=0,
+        end=2000),
+    dict(
+        type='MultiStepLR',
+        begin=0,
+        end=max_epochs,
+        by_epoch=True,
+        milestones=[11],
+        gamma=0.1)
+]
+
+# NOTE: `auto_scale_lr` is for automatically scaling LR,
+# USER SHOULD NOT CHANGE ITS VALUES.
+# base_batch_size = (8 GPUs) x (2 samples per GPU)
+auto_scale_lr = dict(base_batch_size=16)
diff --git a/mmdetection/projects/AlignDETR/configs/align_detr-4scale_r50_8xb2-24e_coco.py b/mmdetection/projects/AlignDETR/configs/align_detr-4scale_r50_8xb2-24e_coco.py
new file mode 100644
index 00000000..f62114ce
--- /dev/null
+++ b/mmdetection/projects/AlignDETR/configs/align_detr-4scale_r50_8xb2-24e_coco.py
@@ -0,0 +1,19 @@
+_base_ = './align_detr-4scale_r50_8xb2-12e_coco.py'
+max_epochs = 24
+train_cfg = dict(
+    type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1)
+param_scheduler = [
+    dict(
+        type='LinearLR',
+        start_factor=0.0001,
+        by_epoch=False,
+        begin=0,
+        end=2000),
+    dict(
+        type='MultiStepLR',
+        begin=0,
+        end=max_epochs,
+        by_epoch=True,
+        milestones=[20],
+        gamma=0.1)
+]
diff --git a/mmdetection/projects/CO-DETR/README.md b/mmdetection/projects/CO-DETR/README.md
new file mode 100644
index 00000000..787592ad
--- /dev/null
+++ b/mmdetection/projects/CO-DETR/README.md
@@ -0,0 +1,32 @@
+# CO-DETR
+
+> [DETRs with Collaborative Hybrid Assignments Training](https://arxiv.org/abs/2211.12860)
+
+
+
+## Abstract
+
+In this paper, we provide the observation that too few queries assigned as positive samples in DETR with one-to-one set matching leads to sparse supervision on the encoder's output which considerably hurt the discriminative feature learning of the encoder and vice visa for attention learning in the decoder. To alleviate this, we present a novel collaborative hybrid assignments training scheme, namely Co-DETR, to learn more efficient and effective DETR-based detectors from versatile label assignment manners. This new training scheme can easily enhance the encoder's learning ability in end-to-end detectors by training the multiple parallel auxiliary heads supervised by one-to-many label assignments such as ATSS and Faster RCNN. In addition, we conduct extra customized positive queries by extracting the positive coordinates from these auxiliary heads to improve the training efficiency of positive samples in the decoder. In inference, these auxiliary heads are discarded and thus our method introduces no additional parameters and computational cost to the original detector while requiring no hand-crafted non-maximum suppression (NMS). We conduct extensive experiments to evaluate the effectiveness of the proposed approach on DETR variants, including DAB-DETR, Deformable-DETR, and DINO-Deformable-DETR. The state-of-the-art DINO-Deformable-DETR with Swin-L can be improved from 58.5% to 59.5% AP on COCO val. Surprisingly, incorporated with ViT-L backbone, we achieve 66.0% AP on COCO test-dev and 67.9% AP on LVIS val, outperforming previous methods by clear margins with much fewer model sizes.
+
+
    
+
+
    
+
+## Results and Models
+
+|   Model   | Backbone | Epochs | Aug  |            Dataset            | box AP |                                 Config                                 |                                                                                                                                                     Download                                                                                                                                                      |
+| :-------: | :------: | :----: | :--: | :---------------------------: | :----: | :--------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+|  Co-DINO  |   R50    |   12   | LSJ  |             COCO              |  52.0  |    [config](configs/codino/co_dino_5scale_r50_lsj_8xb2_1x_coco.py)     | [model](https://download.openmmlab.com/mmdetection/v3.0/codetr/co_dino_5scale_r50_lsj_8xb2_1x_coco/co_dino_5scale_r50_lsj_8xb2_1x_coco-69a72d67.pth)\\ [log](https://download.openmmlab.com/mmdetection/v3.0/codetr/co_dino_5scale_r50_lsj_8xb2_1x_coco/co_dino_5scale_r50_lsj_8xb2_1x_coco_20230818_150457.json) |
+| Co-DINO\* |   R50    |   12   | DETR |             COCO              |  52.1  |      [config](configs/codino/co_dino_5scale_r50_8xb2_1x_coco.py)       |                                                                                                      [model](https://download.openmmlab.com/mmdetection/v3.0/codetr/co_dino_5scale_r50_1x_coco-7481f903.pth)                                                                                                      |
+| Co-DINO\* |   R50    |   36   | LSJ  |             COCO              |  54.8  |    [config](configs/codino/co_dino_5scale_r50_lsj_8xb2_3x_coco.py)     |                                                                                                    [model](https://download.openmmlab.com/mmdetection/v3.0/codetr/co_dino_5scale_lsj_r50_3x_coco-fe5a6829.pth)                                                                                                    |
+| Co-DINO\* |  Swin-L  |   12   | DETR |             COCO              |  58.9  |    [config](configs/codino/co_dino_5scale_swin_l_16xb1_1x_coco.py)     |                                                                                                  [model](https://download.openmmlab.com/mmdetection/v3.0/codetr/co_dino_5scale_swin_large_1x_coco-27c13da4.pth)                                                                                                   |
+| Co-DINO\* |  Swin-L  |   12   | LSJ  |             COCO              |  59.3  |  [config](configs/codino/co_dino_5scale_swin_l_lsj_16xb1_1x_coco.py)   |                                                                                                [model](https://download.openmmlab.com/mmdetection/v3.0/codetr/co_dino_5scale_lsj_swin_large_1x_coco-3af73af2.pth)                                                                                                 |
+| Co-DINO\* |  Swin-L  |   36   | DETR |             COCO              |  60.0  |    [config](configs/codino/co_dino_5scale_swin_l_16xb1_3x_coco.py)     |                                                                                                  [model](https://download.openmmlab.com/mmdetection/v3.0/codetr/co_dino_5scale_swin_large_3x_coco-d7a6d8af.pth)                                                                                                   |
+| Co-DINO\* |  Swin-L  |   36   | LSJ  |             COCO              |  60.7  |  [config](configs/codino/co_dino_5scale_swin_l_lsj_16xb1_3x_coco.py)   |                                                                                                [model](https://download.openmmlab.com/mmdetection/v3.0/codetr/co_dino_5scale_lsj_swin_large_1x_coco-3af73af2.pth)                                                                                                 |
+| Co-DINO\* |  Swin-L  |   16   | DETR | Objects365 pre-trained + COCO |  64.1  | [config](configs/codino/co_dino_5scale_swin_l_16xb1_16e_o365tococo.py) |                                                                                               [model](https://download.openmmlab.com/mmdetection/v3.0/codetr/co_dino_5scale_swin_large_16e_o365tococo-614254c9.pth)                                                                                               |
+
+Note
+
+- Models labeled * are not trained by us, but from [CO-DETR](https://github.com/Sense-X/Co-DETR) official website.
+- We find that the performance is unstable and may fluctuate by about 0.3 mAP.
+- If you want to save GPU memory by enabling checkpointing, please use the `pip install fairscale` command.
diff --git a/mmdetection/projects/CO-DETR/codetr/__init__.py b/mmdetection/projects/CO-DETR/codetr/__init__.py
new file mode 100644
index 00000000..2ca4c02d
--- /dev/null
+++ b/mmdetection/projects/CO-DETR/codetr/__init__.py
@@ -0,0 +1,13 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .co_atss_head import CoATSSHead
+from .co_dino_head import CoDINOHead
+from .co_roi_head import CoStandardRoIHead
+from .codetr import CoDETR
+from .transformer import (CoDinoTransformer, DetrTransformerDecoderLayer,
+                          DetrTransformerEncoder, DinoTransformerDecoder)
+
+__all__ = [
+    'CoDETR', 'CoDinoTransformer', 'DinoTransformerDecoder', 'CoDINOHead',
+    'CoATSSHead', 'CoStandardRoIHead', 'DetrTransformerEncoder',
+    'DetrTransformerDecoderLayer'
+]
diff --git a/mmdetection/projects/CO-DETR/codetr/co_atss_head.py b/mmdetection/projects/CO-DETR/codetr/co_atss_head.py
new file mode 100644
index 00000000..c6ae0180
--- /dev/null
+++ b/mmdetection/projects/CO-DETR/codetr/co_atss_head.py
@@ -0,0 +1,153 @@
+from typing import List
+
+import torch
+from torch import Tensor
+
+from mmdet.models.dense_heads import ATSSHead
+from mmdet.models.utils import images_to_levels, multi_apply
+from mmdet.registry import MODELS
+from mmdet.utils import InstanceList, OptInstanceList, reduce_mean
+
+
+@MODELS.register_module()
+class CoATSSHead(ATSSHead):
+
+    def loss_by_feat(
+            self,
+            cls_scores: List[Tensor],
+            bbox_preds: List[Tensor],
+            centernesses: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> dict:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level
+                Has shape (N, num_anchors * num_classes, H, W)
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level with shape (N, num_anchors * 4, H, W)
+            centernesses (list[Tensor]): Centerness for each scale
+                level with shape (N, num_anchors * 1, H, W)
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], Optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        assert len(featmap_sizes) == self.prior_generator.num_levels
+
+        device = cls_scores[0].device
+        anchor_list, valid_flag_list = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+
+        cls_reg_targets = self.get_targets(
+            anchor_list,
+            valid_flag_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore)
+
+        (anchor_list, labels_list, label_weights_list, bbox_targets_list,
+         bbox_weights_list, avg_factor, ori_anchors, ori_labels,
+         ori_bbox_targets) = cls_reg_targets
+
+        avg_factor = reduce_mean(
+            torch.tensor(avg_factor, dtype=torch.float, device=device)).item()
+
+        losses_cls, losses_bbox, loss_centerness, \
+            bbox_avg_factor = multi_apply(
+                self.loss_by_feat_single,
+                anchor_list,
+                cls_scores,
+                bbox_preds,
+                centernesses,
+                labels_list,
+                label_weights_list,
+                bbox_targets_list,
+                avg_factor=avg_factor)
+
+        bbox_avg_factor = sum(bbox_avg_factor)
+        bbox_avg_factor = reduce_mean(bbox_avg_factor).clamp_(min=1).item()
+        losses_bbox = list(map(lambda x: x / bbox_avg_factor, losses_bbox))
+
+        # diff
+        pos_coords = (ori_anchors, ori_labels, ori_bbox_targets, 'atss')
+        return dict(
+            loss_cls=losses_cls,
+            loss_bbox=losses_bbox,
+            loss_centerness=loss_centerness,
+            pos_coords=pos_coords)
+
+    def get_targets(self,
+                    anchor_list: List[List[Tensor]],
+                    valid_flag_list: List[List[Tensor]],
+                    batch_gt_instances: InstanceList,
+                    batch_img_metas: List[dict],
+                    batch_gt_instances_ignore: OptInstanceList = None,
+                    unmap_outputs: bool = True) -> tuple:
+        """Get targets for ATSS head.
+
+        This method is almost the same as `AnchorHead.get_targets()`. Besides
+        returning the targets as the parent method does, it also returns the
+        anchors as the first element of the returned tuple.
+        """
+        num_imgs = len(batch_img_metas)
+        assert len(anchor_list) == len(valid_flag_list) == num_imgs
+
+        # anchor number of multi levels
+        num_level_anchors = [anchors.size(0) for anchors in anchor_list[0]]
+        num_level_anchors_list = [num_level_anchors] * num_imgs
+
+        # concat all level anchors and flags to a single tensor
+        for i in range(num_imgs):
+            assert len(anchor_list[i]) == len(valid_flag_list[i])
+            anchor_list[i] = torch.cat(anchor_list[i])
+            valid_flag_list[i] = torch.cat(valid_flag_list[i])
+
+        # compute targets for each image
+        if batch_gt_instances_ignore is None:
+            batch_gt_instances_ignore = [None] * num_imgs
+        (all_anchors, all_labels, all_label_weights, all_bbox_targets,
+         all_bbox_weights, pos_inds_list, neg_inds_list,
+         sampling_results_list) = multi_apply(
+             self._get_targets_single,
+             anchor_list,
+             valid_flag_list,
+             num_level_anchors_list,
+             batch_gt_instances,
+             batch_img_metas,
+             batch_gt_instances_ignore,
+             unmap_outputs=unmap_outputs)
+        # Get `avg_factor` of all images, which calculate in `SamplingResult`.
+        # When using sampling method, avg_factor is usually the sum of
+        # positive and negative priors. When using `PseudoSampler`,
+        # `avg_factor` is usually equal to the number of positive priors.
+        avg_factor = sum(
+            [results.avg_factor for results in sampling_results_list])
+        # split targets to a list w.r.t. multiple levels
+        anchors_list = images_to_levels(all_anchors, num_level_anchors)
+        labels_list = images_to_levels(all_labels, num_level_anchors)
+        label_weights_list = images_to_levels(all_label_weights,
+                                              num_level_anchors)
+        bbox_targets_list = images_to_levels(all_bbox_targets,
+                                             num_level_anchors)
+        bbox_weights_list = images_to_levels(all_bbox_weights,
+                                             num_level_anchors)
+
+        # diff
+        ori_anchors = all_anchors
+        ori_labels = all_labels
+        ori_bbox_targets = all_bbox_targets
+        return (anchors_list, labels_list, label_weights_list,
+                bbox_targets_list, bbox_weights_list, avg_factor, ori_anchors,
+                ori_labels, ori_bbox_targets)
diff --git a/mmdetection/projects/CO-DETR/codetr/co_dino_head.py b/mmdetection/projects/CO-DETR/codetr/co_dino_head.py
new file mode 100644
index 00000000..192acf97
--- /dev/null
+++ b/mmdetection/projects/CO-DETR/codetr/co_dino_head.py
@@ -0,0 +1,677 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+from typing import List
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import Linear
+from mmcv.ops import batched_nms
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.models import DINOHead
+from mmdet.models.layers import CdnQueryGenerator
+from mmdet.models.layers.transformer import inverse_sigmoid
+from mmdet.models.utils import multi_apply
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.structures.bbox import (bbox_cxcywh_to_xyxy, bbox_overlaps,
+                                   bbox_xyxy_to_cxcywh)
+from mmdet.utils import InstanceList, reduce_mean
+
+
+@MODELS.register_module()
+class CoDINOHead(DINOHead):
+
+    def __init__(self,
+                 *args,
+                 num_query=900,
+                 transformer=None,
+                 in_channels=2048,
+                 max_pos_coords=300,
+                 dn_cfg=None,
+                 use_zero_padding=False,
+                 positional_encoding=dict(
+                     type='SinePositionalEncoding',
+                     num_feats=128,
+                     normalize=True),
+                 **kwargs):
+        self.with_box_refine = True
+        self.mixed_selection = True
+        self.in_channels = in_channels
+        self.max_pos_coords = max_pos_coords
+        self.positional_encoding = positional_encoding
+        self.num_query = num_query
+        self.use_zero_padding = use_zero_padding
+
+        if 'two_stage_num_proposals' in transformer:
+            assert transformer['two_stage_num_proposals'] == num_query, \
+                'two_stage_num_proposals must be equal to num_query for DINO'
+        else:
+            transformer['two_stage_num_proposals'] = num_query
+        transformer['as_two_stage'] = True
+        if self.mixed_selection:
+            transformer['mixed_selection'] = self.mixed_selection
+        self.transformer = transformer
+        self.act_cfg = transformer.get('act_cfg',
+                                       dict(type='ReLU', inplace=True))
+
+        super().__init__(*args, **kwargs)
+
+        self.activate = MODELS.build(self.act_cfg)
+        self.positional_encoding = MODELS.build(self.positional_encoding)
+        self.init_denoising(dn_cfg)
+
+    def _init_layers(self):
+        self.transformer = MODELS.build(self.transformer)
+        self.embed_dims = self.transformer.embed_dims
+        assert hasattr(self.positional_encoding, 'num_feats')
+        num_feats = self.positional_encoding.num_feats
+        assert num_feats * 2 == self.embed_dims, 'embed_dims should' \
+            f' be exactly 2 times of num_feats. Found {self.embed_dims}' \
+            f' and {num_feats}.'
+        """Initialize classification branch and regression branch of head."""
+        fc_cls = Linear(self.embed_dims, self.cls_out_channels)
+        reg_branch = []
+        for _ in range(self.num_reg_fcs):
+            reg_branch.append(Linear(self.embed_dims, self.embed_dims))
+            reg_branch.append(nn.ReLU())
+        reg_branch.append(Linear(self.embed_dims, 4))
+        reg_branch = nn.Sequential(*reg_branch)
+
+        def _get_clones(module, N):
+            return nn.ModuleList([copy.deepcopy(module) for i in range(N)])
+
+        # last reg_branch is used to generate proposal from
+        # encode feature map when as_two_stage is True.
+        num_pred = (self.transformer.decoder.num_layers + 1) if \
+            self.as_two_stage else self.transformer.decoder.num_layers
+
+        self.cls_branches = _get_clones(fc_cls, num_pred)
+        self.reg_branches = _get_clones(reg_branch, num_pred)
+
+        self.downsample = nn.Sequential(
+            nn.Conv2d(
+                self.embed_dims,
+                self.embed_dims,
+                kernel_size=3,
+                stride=2,
+                padding=1), nn.GroupNorm(32, self.embed_dims))
+
+    def init_denoising(self, dn_cfg):
+        if dn_cfg is not None:
+            dn_cfg['num_classes'] = self.num_classes
+            dn_cfg['num_matching_queries'] = self.num_query
+            dn_cfg['embed_dims'] = self.embed_dims
+        self.dn_generator = CdnQueryGenerator(**dn_cfg)
+
+    def forward(self,
+                mlvl_feats,
+                img_metas,
+                dn_label_query=None,
+                dn_bbox_query=None,
+                attn_mask=None):
+        batch_size = mlvl_feats[0].size(0)
+        input_img_h, input_img_w = img_metas[0]['batch_input_shape']
+        img_masks = mlvl_feats[0].new_ones(
+            (batch_size, input_img_h, input_img_w))
+        for img_id in range(batch_size):
+            img_h, img_w = img_metas[img_id]['img_shape']
+            img_masks[img_id, :img_h, :img_w] = 0
+
+        mlvl_masks = []
+        mlvl_positional_encodings = []
+        for feat in mlvl_feats:
+            mlvl_masks.append(
+                F.interpolate(img_masks[None],
+                              size=feat.shape[-2:]).to(torch.bool).squeeze(0))
+            mlvl_positional_encodings.append(
+                self.positional_encoding(mlvl_masks[-1]))
+
+        query_embeds = None
+        hs, inter_references, topk_score, topk_anchor, enc_outputs = \
+            self.transformer(
+                mlvl_feats,
+                mlvl_masks,
+                query_embeds,
+                mlvl_positional_encodings,
+                dn_label_query,
+                dn_bbox_query,
+                attn_mask,
+                reg_branches=self.reg_branches if self.with_box_refine else None,  # noqa:E501
+                cls_branches=self.cls_branches if self.as_two_stage else None  # noqa:E501
+            )
+        outs = []
+        num_level = len(mlvl_feats)
+        start = 0
+        for lvl in range(num_level):
+            bs, c, h, w = mlvl_feats[lvl].shape
+            end = start + h * w
+            feat = enc_outputs[start:end].permute(1, 2, 0).contiguous()
+            start = end
+            outs.append(feat.reshape(bs, c, h, w))
+        outs.append(self.downsample(outs[-1]))
+
+        hs = hs.permute(0, 2, 1, 3)
+
+        if dn_label_query is not None and dn_label_query.size(1) == 0:
+            # NOTE: If there is no target in the image, the parameters of
+            # label_embedding won't be used in producing loss, which raises
+            # RuntimeError when using distributed mode.
+            hs[0] += self.dn_generator.label_embedding.weight[0, 0] * 0.0
+
+        outputs_classes = []
+        outputs_coords = []
+
+        for lvl in range(hs.shape[0]):
+            reference = inter_references[lvl]
+            reference = inverse_sigmoid(reference, eps=1e-3)
+            outputs_class = self.cls_branches[lvl](hs[lvl])
+            tmp = self.reg_branches[lvl](hs[lvl])
+            if reference.shape[-1] == 4:
+                tmp += reference
+            else:
+                assert reference.shape[-1] == 2
+                tmp[..., :2] += reference
+            outputs_coord = tmp.sigmoid()
+            outputs_classes.append(outputs_class)
+            outputs_coords.append(outputs_coord)
+
+        outputs_classes = torch.stack(outputs_classes)
+        outputs_coords = torch.stack(outputs_coords)
+
+        return outputs_classes, outputs_coords, topk_score, topk_anchor, outs
+
+    def predict(self,
+                feats: List[Tensor],
+                batch_data_samples: SampleList,
+                rescale: bool = True) -> InstanceList:
+        batch_img_metas = [
+            data_samples.metainfo for data_samples in batch_data_samples
+        ]
+        outs = self.forward(feats, batch_img_metas)
+
+        predictions = self.predict_by_feat(
+            *outs, batch_img_metas=batch_img_metas, rescale=rescale)
+
+        return predictions
+
+    def predict_by_feat(self,
+                        all_cls_scores,
+                        all_bbox_preds,
+                        enc_cls_scores,
+                        enc_bbox_preds,
+                        enc_outputs,
+                        batch_img_metas,
+                        rescale=True):
+
+        cls_scores = all_cls_scores[-1]
+        bbox_preds = all_bbox_preds[-1]
+
+        result_list = []
+        for img_id in range(len(batch_img_metas)):
+            cls_score = cls_scores[img_id]
+            bbox_pred = bbox_preds[img_id]
+            img_meta = batch_img_metas[img_id]
+            results = self._predict_by_feat_single(cls_score, bbox_pred,
+                                                   img_meta, rescale)
+            result_list.append(results)
+        return result_list
+
+    def _predict_by_feat_single(self,
+                                cls_score: Tensor,
+                                bbox_pred: Tensor,
+                                img_meta: dict,
+                                rescale: bool = True) -> InstanceData:
+        """Transform outputs from the last decoder layer into bbox predictions
+        for each image.
+
+        Args:
+            cls_score (Tensor): Box score logits from the last decoder layer
+                for each image. Shape [num_queries, cls_out_channels].
+            bbox_pred (Tensor): Sigmoid outputs from the last decoder layer
+                for each image, with coordinate format (cx, cy, w, h) and
+                shape [num_queries, 4].
+            img_meta (dict): Image meta info.
+            rescale (bool): If True, return boxes in original image
+                space. Default True.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        assert len(cls_score) == len(bbox_pred)  # num_queries
+        max_per_img = self.test_cfg.get('max_per_img', self.num_query)
+        score_thr = self.test_cfg.get('score_thr', 0)
+        with_nms = self.test_cfg.get('nms', None)
+
+        img_shape = img_meta['img_shape']
+        # exclude background
+        if self.loss_cls.use_sigmoid:
+            cls_score = cls_score.sigmoid()
+            scores, indexes = cls_score.view(-1).topk(max_per_img)
+            det_labels = indexes % self.num_classes
+            bbox_index = indexes // self.num_classes
+            bbox_pred = bbox_pred[bbox_index]
+        else:
+            scores, det_labels = F.softmax(cls_score, dim=-1)[..., :-1].max(-1)
+            scores, bbox_index = scores.topk(max_per_img)
+            bbox_pred = bbox_pred[bbox_index]
+            det_labels = det_labels[bbox_index]
+
+        if score_thr > 0:
+            valid_mask = scores > score_thr
+            scores = scores[valid_mask]
+            bbox_pred = bbox_pred[valid_mask]
+            det_labels = det_labels[valid_mask]
+
+        det_bboxes = bbox_cxcywh_to_xyxy(bbox_pred)
+        det_bboxes[:, 0::2] = det_bboxes[:, 0::2] * img_shape[1]
+        det_bboxes[:, 1::2] = det_bboxes[:, 1::2] * img_shape[0]
+        det_bboxes[:, 0::2].clamp_(min=0, max=img_shape[1])
+        det_bboxes[:, 1::2].clamp_(min=0, max=img_shape[0])
+        if rescale:
+            assert img_meta.get('scale_factor') is not None
+            det_bboxes /= det_bboxes.new_tensor(
+                img_meta['scale_factor']).repeat((1, 2))
+
+        results = InstanceData()
+        results.bboxes = det_bboxes
+        results.scores = scores
+        results.labels = det_labels
+
+        if with_nms and results.bboxes.numel() > 0:
+            det_bboxes, keep_idxs = batched_nms(results.bboxes, results.scores,
+                                                results.labels,
+                                                self.test_cfg.nms)
+            results = results[keep_idxs]
+            results.scores = det_bboxes[:, -1]
+            results = results[:max_per_img]
+
+        return results
+
+    def loss(self, x, batch_data_samples):
+        assert self.dn_generator is not None, '"dn_cfg" must be set'
+
+        batch_gt_instances = []
+        batch_img_metas = []
+        for data_sample in batch_data_samples:
+            batch_img_metas.append(data_sample.metainfo)
+            batch_gt_instances.append(data_sample.gt_instances)
+
+        dn_label_query, dn_bbox_query, attn_mask, dn_meta = \
+            self.dn_generator(batch_data_samples)
+
+        outs = self(x, batch_img_metas, dn_label_query, dn_bbox_query,
+                    attn_mask)
+
+        loss_inputs = outs[:-1] + (batch_gt_instances, batch_img_metas,
+                                   dn_meta)
+        losses = self.loss_by_feat(*loss_inputs)
+        enc_outputs = outs[-1]
+        return losses, enc_outputs
+
+    def forward_aux(self, mlvl_feats, img_metas, aux_targets, head_idx):
+        """Forward function.
+
+        Args:
+            mlvl_feats (tuple[Tensor]): Features from the upstream
+                network, each is a 4D-tensor with shape
+                (N, C, H, W).
+            img_metas (list[dict]): List of image information.
+
+        Returns:
+            all_cls_scores (Tensor): Outputs from the classification head, \
+                shape [nb_dec, bs, num_query, cls_out_channels]. Note \
+                cls_out_channels should includes background.
+            all_bbox_preds (Tensor): Sigmoid outputs from the regression \
+                head with normalized coordinate format (cx, cy, w, h). \
+                Shape [nb_dec, bs, num_query, 4].
+            enc_outputs_class (Tensor): The score of each point on encode \
+                feature map, has shape (N, h*w, num_class). Only when \
+                as_two_stage is True it would be returned, otherwise \
+                `None` would be returned.
+            enc_outputs_coord (Tensor): The proposal generate from the \
+                encode feature map, has shape (N, h*w, 4). Only when \
+                as_two_stage is True it would be returned, otherwise \
+                `None` would be returned.
+        """
+        aux_coords, aux_labels, aux_targets, aux_label_weights, \
+            aux_bbox_weights, aux_feats, attn_masks = aux_targets
+        batch_size = mlvl_feats[0].size(0)
+        input_img_h, input_img_w = img_metas[0]['batch_input_shape']
+        img_masks = mlvl_feats[0].new_ones(
+            (batch_size, input_img_h, input_img_w))
+        for img_id in range(batch_size):
+            img_h, img_w = img_metas[img_id]['img_shape']
+            img_masks[img_id, :img_h, :img_w] = 0
+
+        mlvl_masks = []
+        mlvl_positional_encodings = []
+        for feat in mlvl_feats:
+            mlvl_masks.append(
+                F.interpolate(img_masks[None],
+                              size=feat.shape[-2:]).to(torch.bool).squeeze(0))
+            mlvl_positional_encodings.append(
+                self.positional_encoding(mlvl_masks[-1]))
+
+        query_embeds = None
+        hs, inter_references = self.transformer.forward_aux(
+            mlvl_feats,
+            mlvl_masks,
+            query_embeds,
+            mlvl_positional_encodings,
+            aux_coords,
+            pos_feats=aux_feats,
+            reg_branches=self.reg_branches if self.with_box_refine else None,
+            cls_branches=self.cls_branches if self.as_two_stage else None,
+            return_encoder_output=True,
+            attn_masks=attn_masks,
+            head_idx=head_idx)
+
+        hs = hs.permute(0, 2, 1, 3)
+        outputs_classes = []
+        outputs_coords = []
+
+        for lvl in range(hs.shape[0]):
+            reference = inter_references[lvl]
+            reference = inverse_sigmoid(reference, eps=1e-3)
+            outputs_class = self.cls_branches[lvl](hs[lvl])
+            tmp = self.reg_branches[lvl](hs[lvl])
+            if reference.shape[-1] == 4:
+                tmp += reference
+            else:
+                assert reference.shape[-1] == 2
+                tmp[..., :2] += reference
+            outputs_coord = tmp.sigmoid()
+            outputs_classes.append(outputs_class)
+            outputs_coords.append(outputs_coord)
+
+        outputs_classes = torch.stack(outputs_classes)
+        outputs_coords = torch.stack(outputs_coords)
+
+        return outputs_classes, outputs_coords, None, None
+
+    def loss_aux(self,
+                 x,
+                 pos_coords=None,
+                 head_idx=0,
+                 batch_data_samples=None):
+        batch_gt_instances = []
+        batch_img_metas = []
+        for data_sample in batch_data_samples:
+            batch_img_metas.append(data_sample.metainfo)
+            batch_gt_instances.append(data_sample.gt_instances)
+
+        gt_bboxes = [b.bboxes for b in batch_gt_instances]
+        gt_labels = [b.labels for b in batch_gt_instances]
+
+        aux_targets = self.get_aux_targets(pos_coords, batch_img_metas, x,
+                                           head_idx)
+        outs = self.forward_aux(x[:-1], batch_img_metas, aux_targets, head_idx)
+        outs = outs + aux_targets
+        if gt_labels is None:
+            loss_inputs = outs + (gt_bboxes, batch_img_metas)
+        else:
+            loss_inputs = outs + (gt_bboxes, gt_labels, batch_img_metas)
+        losses = self.loss_aux_by_feat(*loss_inputs)
+        return losses
+
+    def get_aux_targets(self, pos_coords, img_metas, mlvl_feats, head_idx):
+        coords, labels, targets = pos_coords[:3]
+        head_name = pos_coords[-1]
+        bs, c = len(coords), mlvl_feats[0].shape[1]
+        max_num_coords = 0
+        all_feats = []
+        for i in range(bs):
+            label = labels[i]
+            feats = [
+                feat[i].reshape(c, -1).transpose(1, 0) for feat in mlvl_feats
+            ]
+            feats = torch.cat(feats, dim=0)
+            bg_class_ind = self.num_classes
+            pos_inds = ((label >= 0)
+                        & (label < bg_class_ind)).nonzero().squeeze(1)
+            max_num_coords = max(max_num_coords, len(pos_inds))
+            all_feats.append(feats)
+        max_num_coords = min(self.max_pos_coords, max_num_coords)
+        max_num_coords = max(9, max_num_coords)
+
+        if self.use_zero_padding:
+            attn_masks = []
+            label_weights = coords[0].new_zeros([bs, max_num_coords])
+        else:
+            attn_masks = None
+            label_weights = coords[0].new_ones([bs, max_num_coords])
+        bbox_weights = coords[0].new_zeros([bs, max_num_coords, 4])
+
+        aux_coords, aux_labels, aux_targets, aux_feats = [], [], [], []
+
+        for i in range(bs):
+            coord, label, target = coords[i], labels[i], targets[i]
+            feats = all_feats[i]
+            if 'rcnn' in head_name:
+                feats = pos_coords[-2][i]
+                num_coords_per_point = 1
+            else:
+                num_coords_per_point = coord.shape[0] // feats.shape[0]
+            feats = feats.unsqueeze(1).repeat(1, num_coords_per_point, 1)
+            feats = feats.reshape(feats.shape[0] * num_coords_per_point,
+                                  feats.shape[-1])
+            img_meta = img_metas[i]
+            img_h, img_w = img_meta['img_shape']
+            factor = coord.new_tensor([img_w, img_h, img_w,
+                                       img_h]).unsqueeze(0)
+            bg_class_ind = self.num_classes
+            pos_inds = ((label >= 0)
+                        & (label < bg_class_ind)).nonzero().squeeze(1)
+            neg_inds = (label == bg_class_ind).nonzero().squeeze(1)
+            if pos_inds.shape[0] > max_num_coords:
+                indices = torch.randperm(
+                    pos_inds.shape[0])[:max_num_coords].cuda()
+                pos_inds = pos_inds[indices]
+
+            coord = bbox_xyxy_to_cxcywh(coord[pos_inds] / factor)
+            label = label[pos_inds]
+            target = bbox_xyxy_to_cxcywh(target[pos_inds] / factor)
+            feat = feats[pos_inds]
+
+            if self.use_zero_padding:
+                label_weights[i][:len(label)] = 1
+                bbox_weights[i][:len(label)] = 1
+                attn_mask = torch.zeros([
+                    max_num_coords,
+                    max_num_coords,
+                ]).bool().to(coord.device)
+            else:
+                bbox_weights[i][:len(label)] = 1
+
+            if coord.shape[0] < max_num_coords:
+                padding_shape = max_num_coords - coord.shape[0]
+                if self.use_zero_padding:
+                    padding_coord = coord.new_zeros([padding_shape, 4])
+                    padding_label = label.new_ones([padding_shape
+                                                    ]) * self.num_classes
+                    padding_target = target.new_zeros([padding_shape, 4])
+                    padding_feat = feat.new_zeros([padding_shape, c])
+                    attn_mask[coord.shape[0]:, 0:coord.shape[0], ] = True
+                    attn_mask[:, coord.shape[0]:, ] = True
+                else:
+                    indices = torch.randperm(
+                        neg_inds.shape[0])[:padding_shape].cuda()
+                    neg_inds = neg_inds[indices]
+                    padding_coord = bbox_xyxy_to_cxcywh(coords[i][neg_inds] /
+                                                        factor)
+                    padding_label = labels[i][neg_inds]
+                    padding_target = bbox_xyxy_to_cxcywh(targets[i][neg_inds] /
+                                                         factor)
+                    padding_feat = feats[neg_inds]
+                coord = torch.cat((coord, padding_coord), dim=0)
+                label = torch.cat((label, padding_label), dim=0)
+                target = torch.cat((target, padding_target), dim=0)
+                feat = torch.cat((feat, padding_feat), dim=0)
+            if self.use_zero_padding:
+                attn_masks.append(attn_mask.unsqueeze(0))
+            aux_coords.append(coord.unsqueeze(0))
+            aux_labels.append(label.unsqueeze(0))
+            aux_targets.append(target.unsqueeze(0))
+            aux_feats.append(feat.unsqueeze(0))
+
+        if self.use_zero_padding:
+            attn_masks = torch.cat(
+                attn_masks, dim=0).unsqueeze(1).repeat(1, 8, 1, 1)
+            attn_masks = attn_masks.reshape(bs * 8, max_num_coords,
+                                            max_num_coords)
+        else:
+            attn_masks = None
+
+        aux_coords = torch.cat(aux_coords, dim=0)
+        aux_labels = torch.cat(aux_labels, dim=0)
+        aux_targets = torch.cat(aux_targets, dim=0)
+        aux_feats = torch.cat(aux_feats, dim=0)
+        aux_label_weights = label_weights
+        aux_bbox_weights = bbox_weights
+        return (aux_coords, aux_labels, aux_targets, aux_label_weights,
+                aux_bbox_weights, aux_feats, attn_masks)
+
+    def loss_aux_by_feat(self,
+                         all_cls_scores,
+                         all_bbox_preds,
+                         enc_cls_scores,
+                         enc_bbox_preds,
+                         aux_coords,
+                         aux_labels,
+                         aux_targets,
+                         aux_label_weights,
+                         aux_bbox_weights,
+                         aux_feats,
+                         attn_masks,
+                         gt_bboxes_list,
+                         gt_labels_list,
+                         img_metas,
+                         gt_bboxes_ignore=None):
+        num_dec_layers = len(all_cls_scores)
+        all_labels = [aux_labels for _ in range(num_dec_layers)]
+        all_label_weights = [aux_label_weights for _ in range(num_dec_layers)]
+        all_bbox_targets = [aux_targets for _ in range(num_dec_layers)]
+        all_bbox_weights = [aux_bbox_weights for _ in range(num_dec_layers)]
+        img_metas_list = [img_metas for _ in range(num_dec_layers)]
+        all_gt_bboxes_ignore_list = [
+            gt_bboxes_ignore for _ in range(num_dec_layers)
+        ]
+
+        losses_cls, losses_bbox, losses_iou = multi_apply(
+            self._loss_aux_by_feat_single, all_cls_scores, all_bbox_preds,
+            all_labels, all_label_weights, all_bbox_targets, all_bbox_weights,
+            img_metas_list, all_gt_bboxes_ignore_list)
+
+        loss_dict = dict()
+        # loss of proposal generated from encode feature map.
+
+        # loss from the last decoder layer
+        loss_dict['loss_cls_aux'] = losses_cls[-1]
+        loss_dict['loss_bbox_aux'] = losses_bbox[-1]
+        loss_dict['loss_iou_aux'] = losses_iou[-1]
+        # loss from other decoder layers
+        num_dec_layer = 0
+        for loss_cls_i, loss_bbox_i, loss_iou_i in zip(losses_cls[:-1],
+                                                       losses_bbox[:-1],
+                                                       losses_iou[:-1]):
+            loss_dict[f'd{num_dec_layer}.loss_cls_aux'] = loss_cls_i
+            loss_dict[f'd{num_dec_layer}.loss_bbox_aux'] = loss_bbox_i
+            loss_dict[f'd{num_dec_layer}.loss_iou_aux'] = loss_iou_i
+            num_dec_layer += 1
+        return loss_dict
+
+    def _loss_aux_by_feat_single(self,
+                                 cls_scores,
+                                 bbox_preds,
+                                 labels,
+                                 label_weights,
+                                 bbox_targets,
+                                 bbox_weights,
+                                 img_metas,
+                                 gt_bboxes_ignore_list=None):
+        num_imgs = cls_scores.size(0)
+        num_q = cls_scores.size(1)
+
+        try:
+            labels = labels.reshape(num_imgs * num_q)
+            label_weights = label_weights.reshape(num_imgs * num_q)
+            bbox_targets = bbox_targets.reshape(num_imgs * num_q, 4)
+            bbox_weights = bbox_weights.reshape(num_imgs * num_q, 4)
+        except Exception:
+            return cls_scores.mean() * 0, cls_scores.mean(
+            ) * 0, cls_scores.mean() * 0
+
+        bg_class_ind = self.num_classes
+        num_total_pos = len(
+            ((labels >= 0) & (labels < bg_class_ind)).nonzero().squeeze(1))
+        num_total_neg = num_imgs * num_q - num_total_pos
+
+        # classification loss
+        cls_scores = cls_scores.reshape(-1, self.cls_out_channels)
+        # construct weighted avg_factor to match with the official DETR repo
+        cls_avg_factor = num_total_pos * 1.0 + \
+            num_total_neg * self.bg_cls_weight
+        if self.sync_cls_avg_factor:
+            cls_avg_factor = reduce_mean(
+                cls_scores.new_tensor([cls_avg_factor]))
+        cls_avg_factor = max(cls_avg_factor, 1)
+
+        bg_class_ind = self.num_classes
+        pos_inds = ((labels >= 0)
+                    & (labels < bg_class_ind)).nonzero().squeeze(1)
+        scores = label_weights.new_zeros(labels.shape)
+        pos_bbox_targets = bbox_targets[pos_inds]
+        pos_decode_bbox_targets = bbox_cxcywh_to_xyxy(pos_bbox_targets)
+        pos_bbox_pred = bbox_preds.reshape(-1, 4)[pos_inds]
+        pos_decode_bbox_pred = bbox_cxcywh_to_xyxy(pos_bbox_pred)
+        scores[pos_inds] = bbox_overlaps(
+            pos_decode_bbox_pred.detach(),
+            pos_decode_bbox_targets,
+            is_aligned=True)
+        loss_cls = self.loss_cls(
+            cls_scores, (labels, scores),
+            weight=label_weights,
+            avg_factor=cls_avg_factor)
+
+        # Compute the average number of gt boxes across all gpus, for
+        # normalization purposes
+        num_total_pos = loss_cls.new_tensor([num_total_pos])
+        num_total_pos = torch.clamp(reduce_mean(num_total_pos), min=1).item()
+
+        # construct factors used for rescale bboxes
+        factors = []
+        for img_meta, bbox_pred in zip(img_metas, bbox_preds):
+            img_h, img_w = img_meta['img_shape']
+            factor = bbox_pred.new_tensor([img_w, img_h, img_w,
+                                           img_h]).unsqueeze(0).repeat(
+                                               bbox_pred.size(0), 1)
+            factors.append(factor)
+        factors = torch.cat(factors, 0)
+
+        # DETR regress the relative position of boxes (cxcywh) in the image,
+        # thus the learning target is normalized by the image size. So here
+        # we need to re-scale them for calculating IoU loss
+        bbox_preds = bbox_preds.reshape(-1, 4)
+        bboxes = bbox_cxcywh_to_xyxy(bbox_preds) * factors
+        bboxes_gt = bbox_cxcywh_to_xyxy(bbox_targets) * factors
+
+        # regression IoU loss, defaultly GIoU loss
+        loss_iou = self.loss_iou(
+            bboxes, bboxes_gt, bbox_weights, avg_factor=num_total_pos)
+
+        # regression L1 loss
+        loss_bbox = self.loss_bbox(
+            bbox_preds, bbox_targets, bbox_weights, avg_factor=num_total_pos)
+        return loss_cls, loss_bbox, loss_iou
diff --git a/mmdetection/projects/CO-DETR/codetr/co_roi_head.py b/mmdetection/projects/CO-DETR/codetr/co_roi_head.py
new file mode 100644
index 00000000..9aafb53b
--- /dev/null
+++ b/mmdetection/projects/CO-DETR/codetr/co_roi_head.py
@@ -0,0 +1,108 @@
+from typing import List, Tuple
+
+import torch
+from torch import Tensor
+
+from mmdet.models.roi_heads import StandardRoIHead
+from mmdet.models.task_modules.samplers import SamplingResult
+from mmdet.models.utils import unpack_gt_instances
+from mmdet.registry import MODELS
+from mmdet.structures import DetDataSample
+from mmdet.structures.bbox import bbox2roi
+from mmdet.utils import InstanceList
+
+
+@MODELS.register_module()
+class CoStandardRoIHead(StandardRoIHead):
+
+    def loss(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
+             batch_data_samples: List[DetDataSample]) -> dict:
+        max_proposal = 2000
+
+        assert len(rpn_results_list) == len(batch_data_samples)
+        outputs = unpack_gt_instances(batch_data_samples)
+        batch_gt_instances, batch_gt_instances_ignore, _ = outputs
+
+        # assign gts and sample proposals
+        num_imgs = len(batch_data_samples)
+        sampling_results = []
+        for i in range(num_imgs):
+            # rename rpn_results.bboxes to rpn_results.priors
+            rpn_results = rpn_results_list[i]
+            rpn_results.priors = rpn_results.pop('bboxes')
+
+            assign_result = self.bbox_assigner.assign(
+                rpn_results, batch_gt_instances[i],
+                batch_gt_instances_ignore[i])
+            sampling_result = self.bbox_sampler.sample(
+                assign_result,
+                rpn_results,
+                batch_gt_instances[i],
+                feats=[lvl_feat[i][None] for lvl_feat in x])
+            sampling_results.append(sampling_result)
+
+        losses = dict()
+        # bbox head forward and loss
+        if self.with_bbox:
+            bbox_results = self.bbox_loss(x, sampling_results)
+            losses.update(bbox_results['loss_bbox'])
+
+            bbox_targets = bbox_results['bbox_targets']
+            for res in sampling_results:
+                max_proposal = min(max_proposal, res.bboxes.shape[0])
+            ori_coords = bbox2roi([res.bboxes for res in sampling_results])
+            ori_proposals, ori_labels, \
+                ori_bbox_targets, ori_bbox_feats = [], [], [], []
+            for i in range(num_imgs):
+                idx = (ori_coords[:, 0] == i).nonzero().squeeze(1)
+                idx = idx[:max_proposal]
+                ori_proposal = ori_coords[idx][:, 1:].unsqueeze(0)
+                ori_label = bbox_targets[0][idx].unsqueeze(0)
+                ori_bbox_target = bbox_targets[2][idx].unsqueeze(0)
+                ori_bbox_feat = bbox_results['bbox_feats'].mean(-1).mean(-1)
+                ori_bbox_feat = ori_bbox_feat[idx].unsqueeze(0)
+                ori_proposals.append(ori_proposal)
+                ori_labels.append(ori_label)
+                ori_bbox_targets.append(ori_bbox_target)
+                ori_bbox_feats.append(ori_bbox_feat)
+            ori_coords = torch.cat(ori_proposals, dim=0)
+            ori_labels = torch.cat(ori_labels, dim=0)
+            ori_bbox_targets = torch.cat(ori_bbox_targets, dim=0)
+            ori_bbox_feats = torch.cat(ori_bbox_feats, dim=0)
+            pos_coords = (ori_coords, ori_labels, ori_bbox_targets,
+                          ori_bbox_feats, 'rcnn')
+            losses.update(pos_coords=pos_coords)
+
+        return losses
+
+    def bbox_loss(self, x: Tuple[Tensor],
+                  sampling_results: List[SamplingResult]) -> dict:
+        """Perform forward propagation and loss calculation of the bbox head on
+        the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            sampling_results (list["obj:`SamplingResult`]): Sampling results.
+
+        Returns:
+            dict[str, Tensor]: Usually returns a dictionary with keys:
+
+                - `cls_score` (Tensor): Classification scores.
+                - `bbox_pred` (Tensor): Box energies / deltas.
+                - `bbox_feats` (Tensor): Extract bbox RoI features.
+                - `loss_bbox` (dict): A dictionary of bbox loss components.
+        """
+        rois = bbox2roi([res.priors for res in sampling_results])
+        bbox_results = self._bbox_forward(x, rois)
+
+        bbox_loss_and_target = self.bbox_head.loss_and_target(
+            cls_score=bbox_results['cls_score'],
+            bbox_pred=bbox_results['bbox_pred'],
+            rois=rois,
+            sampling_results=sampling_results,
+            rcnn_train_cfg=self.train_cfg)
+
+        bbox_results.update(loss_bbox=bbox_loss_and_target['loss_bbox'])
+        # diff
+        bbox_results.update(bbox_targets=bbox_loss_and_target['bbox_targets'])
+        return bbox_results
diff --git a/mmdetection/projects/CO-DETR/codetr/codetr.py b/mmdetection/projects/CO-DETR/codetr/codetr.py
new file mode 100644
index 00000000..82826f64
--- /dev/null
+++ b/mmdetection/projects/CO-DETR/codetr/codetr.py
@@ -0,0 +1,320 @@
+import copy
+from typing import Tuple, Union
+
+import torch
+import torch.nn as nn
+from torch import Tensor
+
+from mmdet.models.detectors.base import BaseDetector
+from mmdet.registry import MODELS
+from mmdet.structures import OptSampleList, SampleList
+from mmdet.utils import InstanceList, OptConfigType, OptMultiConfig
+
+
+@MODELS.register_module()
+class CoDETR(BaseDetector):
+
+    def __init__(
+            self,
+            backbone,
+            neck=None,
+            query_head=None,  # detr head
+            rpn_head=None,  # two-stage rpn
+            roi_head=[None],  # two-stage
+            bbox_head=[None],  # one-stage
+            train_cfg=[None, None],
+            test_cfg=[None, None],
+            # Control whether to consider positive samples
+            # from the auxiliary head as additional positive queries.
+            with_pos_coord=True,
+            use_lsj=True,
+            eval_module='detr',
+            # Evaluate the Nth head.
+            eval_index=0,
+            data_preprocessor: OptConfigType = None,
+            init_cfg: OptMultiConfig = None):
+        super(CoDETR, self).__init__(
+            data_preprocessor=data_preprocessor, init_cfg=init_cfg)
+        self.with_pos_coord = with_pos_coord
+        self.use_lsj = use_lsj
+
+        assert eval_module in ['detr', 'one-stage', 'two-stage']
+        self.eval_module = eval_module
+
+        self.backbone = MODELS.build(backbone)
+        if neck is not None:
+            self.neck = MODELS.build(neck)
+        # Module index for evaluation
+        self.eval_index = eval_index
+        head_idx = 0
+        if query_head is not None:
+            query_head.update(train_cfg=train_cfg[head_idx] if (
+                train_cfg is not None and train_cfg[head_idx] is not None
+            ) else None)
+            query_head.update(test_cfg=test_cfg[head_idx])
+            self.query_head = MODELS.build(query_head)
+            self.query_head.init_weights()
+            head_idx += 1
+
+        if rpn_head is not None:
+            rpn_train_cfg = train_cfg[head_idx].rpn if (
+                train_cfg is not None
+                and train_cfg[head_idx] is not None) else None
+            rpn_head_ = rpn_head.copy()
+            rpn_head_.update(
+                train_cfg=rpn_train_cfg, test_cfg=test_cfg[head_idx].rpn)
+            self.rpn_head = MODELS.build(rpn_head_)
+            self.rpn_head.init_weights()
+
+        self.roi_head = nn.ModuleList()
+        for i in range(len(roi_head)):
+            if roi_head[i]:
+                rcnn_train_cfg = train_cfg[i + head_idx].rcnn if (
+                    train_cfg
+                    and train_cfg[i + head_idx] is not None) else None
+                roi_head[i].update(train_cfg=rcnn_train_cfg)
+                roi_head[i].update(test_cfg=test_cfg[i + head_idx].rcnn)
+                self.roi_head.append(MODELS.build(roi_head[i]))
+                self.roi_head[-1].init_weights()
+
+        self.bbox_head = nn.ModuleList()
+        for i in range(len(bbox_head)):
+            if bbox_head[i]:
+                bbox_head[i].update(
+                    train_cfg=train_cfg[i + head_idx + len(self.roi_head)] if (
+                        train_cfg and train_cfg[i + head_idx +
+                                                len(self.roi_head)] is not None
+                    ) else None)
+                bbox_head[i].update(test_cfg=test_cfg[i + head_idx +
+                                                      len(self.roi_head)])
+                self.bbox_head.append(MODELS.build(bbox_head[i]))
+                self.bbox_head[-1].init_weights()
+
+        self.head_idx = head_idx
+        self.train_cfg = train_cfg
+        self.test_cfg = test_cfg
+
+    @property
+    def with_rpn(self):
+        """bool: whether the detector has RPN"""
+        return hasattr(self, 'rpn_head') and self.rpn_head is not None
+
+    @property
+    def with_query_head(self):
+        """bool: whether the detector has a RoI head"""
+        return hasattr(self, 'query_head') and self.query_head is not None
+
+    @property
+    def with_roi_head(self):
+        """bool: whether the detector has a RoI head"""
+        return hasattr(self, 'roi_head') and self.roi_head is not None and len(
+            self.roi_head) > 0
+
+    @property
+    def with_shared_head(self):
+        """bool: whether the detector has a shared head in the RoI Head"""
+        return hasattr(self, 'roi_head') and self.roi_head[0].with_shared_head
+
+    @property
+    def with_bbox(self):
+        """bool: whether the detector has a bbox head"""
+        return ((hasattr(self, 'roi_head') and self.roi_head is not None
+                 and len(self.roi_head) > 0)
+                or (hasattr(self, 'bbox_head') and self.bbox_head is not None
+                    and len(self.bbox_head) > 0))
+
+    def extract_feat(self, batch_inputs: Tensor) -> Tuple[Tensor]:
+        """Extract features.
+
+        Args:
+            batch_inputs (Tensor): Image tensor, has shape (bs, dim, H, W).
+
+        Returns:
+            tuple[Tensor]: Tuple of feature maps from neck. Each feature map
+            has shape (bs, dim, H, W).
+        """
+        x = self.backbone(batch_inputs)
+        if self.with_neck:
+            x = self.neck(x)
+        return x
+
+    def _forward(self,
+                 batch_inputs: Tensor,
+                 batch_data_samples: OptSampleList = None):
+        pass
+
+    def loss(self, batch_inputs: Tensor,
+             batch_data_samples: SampleList) -> Union[dict, list]:
+        batch_input_shape = batch_data_samples[0].batch_input_shape
+        if self.use_lsj:
+            for data_samples in batch_data_samples:
+                img_metas = data_samples.metainfo
+                input_img_h, input_img_w = batch_input_shape
+                img_metas['img_shape'] = [input_img_h, input_img_w]
+
+        x = self.extract_feat(batch_inputs)
+
+        losses = dict()
+
+        def upd_loss(losses, idx, weight=1):
+            new_losses = dict()
+            for k, v in losses.items():
+                new_k = '{}{}'.format(k, idx)
+                if isinstance(v, list) or isinstance(v, tuple):
+                    new_losses[new_k] = [i * weight for i in v]
+                else:
+                    new_losses[new_k] = v * weight
+            return new_losses
+
+        # DETR encoder and decoder forward
+        if self.with_query_head:
+            bbox_losses, x = self.query_head.loss(x, batch_data_samples)
+            losses.update(bbox_losses)
+
+        # RPN forward and loss
+        if self.with_rpn:
+            proposal_cfg = self.train_cfg[self.head_idx].get(
+                'rpn_proposal', self.test_cfg[self.head_idx].rpn)
+
+            rpn_data_samples = copy.deepcopy(batch_data_samples)
+            # set cat_id of gt_labels to 0 in RPN
+            for data_sample in rpn_data_samples:
+                data_sample.gt_instances.labels = \
+                    torch.zeros_like(data_sample.gt_instances.labels)
+
+            rpn_losses, proposal_list = self.rpn_head.loss_and_predict(
+                x, rpn_data_samples, proposal_cfg=proposal_cfg)
+
+            # avoid get same name with roi_head loss
+            keys = rpn_losses.keys()
+            for key in list(keys):
+                if 'loss' in key and 'rpn' not in key:
+                    rpn_losses[f'rpn_{key}'] = rpn_losses.pop(key)
+
+            losses.update(rpn_losses)
+        else:
+            assert batch_data_samples[0].get('proposals', None) is not None
+            # use pre-defined proposals in InstanceData for the second stage
+            # to extract ROI features.
+            proposal_list = [
+                data_sample.proposals for data_sample in batch_data_samples
+            ]
+
+        positive_coords = []
+        for i in range(len(self.roi_head)):
+            roi_losses = self.roi_head[i].loss(x, proposal_list,
+                                               batch_data_samples)
+            if self.with_pos_coord:
+                positive_coords.append(roi_losses.pop('pos_coords'))
+            else:
+                if 'pos_coords' in roi_losses.keys():
+                    roi_losses.pop('pos_coords')
+            roi_losses = upd_loss(roi_losses, idx=i)
+            losses.update(roi_losses)
+
+        for i in range(len(self.bbox_head)):
+            bbox_losses = self.bbox_head[i].loss(x, batch_data_samples)
+            if self.with_pos_coord:
+                pos_coords = bbox_losses.pop('pos_coords')
+                positive_coords.append(pos_coords)
+            else:
+                if 'pos_coords' in bbox_losses.keys():
+                    bbox_losses.pop('pos_coords')
+            bbox_losses = upd_loss(bbox_losses, idx=i + len(self.roi_head))
+            losses.update(bbox_losses)
+
+        if self.with_pos_coord and len(positive_coords) > 0:
+            for i in range(len(positive_coords)):
+                bbox_losses = self.query_head.loss_aux(x, positive_coords[i],
+                                                       i, batch_data_samples)
+                bbox_losses = upd_loss(bbox_losses, idx=i)
+                losses.update(bbox_losses)
+
+        return losses
+
+    def predict(self,
+                batch_inputs: Tensor,
+                batch_data_samples: SampleList,
+                rescale: bool = True) -> SampleList:
+        """Predict results from a batch of inputs and data samples with post-
+        processing.
+
+        Args:
+            batch_inputs (Tensor): Inputs, has shape (bs, dim, H, W).
+            batch_data_samples (List[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+            rescale (bool): Whether to rescale the results.
+                Defaults to True.
+
+        Returns:
+            list[:obj:`DetDataSample`]: Detection results of the input images.
+            Each DetDataSample usually contain 'pred_instances'. And the
+            `pred_instances` usually contains following keys.
+
+            - scores (Tensor): Classification scores, has a shape
+              (num_instance, )
+            - labels (Tensor): Labels of bboxes, has a shape
+              (num_instances, ).
+            - bboxes (Tensor): Has a shape (num_instances, 4),
+              the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        assert self.eval_module in ['detr', 'one-stage', 'two-stage']
+
+        if self.use_lsj:
+            for data_samples in batch_data_samples:
+                img_metas = data_samples.metainfo
+                input_img_h, input_img_w = img_metas['batch_input_shape']
+                img_metas['img_shape'] = [input_img_h, input_img_w]
+
+        img_feats = self.extract_feat(batch_inputs)
+        if self.with_bbox and self.eval_module == 'one-stage':
+            results_list = self.predict_bbox_head(
+                img_feats, batch_data_samples, rescale=rescale)
+        elif self.with_roi_head and self.eval_module == 'two-stage':
+            results_list = self.predict_roi_head(
+                img_feats, batch_data_samples, rescale=rescale)
+        else:
+            results_list = self.predict_query_head(
+                img_feats, batch_data_samples, rescale=rescale)
+
+        batch_data_samples = self.add_pred_to_datasample(
+            batch_data_samples, results_list)
+        return batch_data_samples
+
+    def predict_query_head(self,
+                           mlvl_feats: Tuple[Tensor],
+                           batch_data_samples: SampleList,
+                           rescale: bool = True) -> InstanceList:
+        return self.query_head.predict(
+            mlvl_feats, batch_data_samples=batch_data_samples, rescale=rescale)
+
+    def predict_roi_head(self,
+                         mlvl_feats: Tuple[Tensor],
+                         batch_data_samples: SampleList,
+                         rescale: bool = True) -> InstanceList:
+        assert self.with_bbox, 'Bbox head must be implemented.'
+        if self.with_query_head:
+            batch_img_metas = [
+                data_samples.metainfo for data_samples in batch_data_samples
+            ]
+            results = self.query_head.forward(mlvl_feats, batch_img_metas)
+            mlvl_feats = results[-1]
+        rpn_results_list = self.rpn_head.predict(
+            mlvl_feats, batch_data_samples, rescale=False)
+        return self.roi_head[self.eval_index].predict(
+            mlvl_feats, rpn_results_list, batch_data_samples, rescale=rescale)
+
+    def predict_bbox_head(self,
+                          mlvl_feats: Tuple[Tensor],
+                          batch_data_samples: SampleList,
+                          rescale: bool = True) -> InstanceList:
+        assert self.with_bbox, 'Bbox head must be implemented.'
+        if self.with_query_head:
+            batch_img_metas = [
+                data_samples.metainfo for data_samples in batch_data_samples
+            ]
+            results = self.query_head.forward(mlvl_feats, batch_img_metas)
+            mlvl_feats = results[-1]
+        return self.bbox_head[self.eval_index].predict(
+            mlvl_feats, batch_data_samples, rescale=rescale)
diff --git a/mmdetection/projects/CO-DETR/codetr/transformer.py b/mmdetection/projects/CO-DETR/codetr/transformer.py
new file mode 100644
index 00000000..009f94a8
--- /dev/null
+++ b/mmdetection/projects/CO-DETR/codetr/transformer.py
@@ -0,0 +1,1376 @@
+import math
+import warnings
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import build_norm_layer
+from mmcv.cnn.bricks.transformer import (BaseTransformerLayer,
+                                         TransformerLayerSequence,
+                                         build_transformer_layer_sequence)
+from mmcv.ops import MultiScaleDeformableAttention
+from mmengine.model import BaseModule
+from mmengine.model.weight_init import xavier_init
+from torch.nn.init import normal_
+
+from mmdet.models.layers.transformer import inverse_sigmoid
+from mmdet.registry import MODELS
+
+try:
+    from fairscale.nn.checkpoint import checkpoint_wrapper
+except Exception:
+    checkpoint_wrapper = None
+
+# In order to save the cost and effort of reproduction,
+# I did not refactor it into the style of mmdet 3.x DETR.
+
+
+class Transformer(BaseModule):
+    """Implements the DETR transformer.
+
+    Following the official DETR implementation, this module copy-paste
+    from torch.nn.Transformer with modifications:
+
+        * positional encodings are passed in MultiheadAttention
+        * extra LN at the end of encoder is removed
+        * decoder returns a stack of activations from all decoding layers
+
+    See `paper: End-to-End Object Detection with Transformers
+    `_ for details.
+
+    Args:
+        encoder (`mmcv.ConfigDict` | Dict): Config of
+            TransformerEncoder. Defaults to None.
+        decoder ((`mmcv.ConfigDict` | Dict)): Config of
+            TransformerDecoder. Defaults to None
+        init_cfg (obj:`mmcv.ConfigDict`): The Config for initialization.
+            Defaults to None.
+    """
+
+    def __init__(self, encoder=None, decoder=None, init_cfg=None):
+        super(Transformer, self).__init__(init_cfg=init_cfg)
+        self.encoder = build_transformer_layer_sequence(encoder)
+        self.decoder = build_transformer_layer_sequence(decoder)
+        self.embed_dims = self.encoder.embed_dims
+
+    def init_weights(self):
+        # follow the official DETR to init parameters
+        for m in self.modules():
+            if hasattr(m, 'weight') and m.weight.dim() > 1:
+                xavier_init(m, distribution='uniform')
+        self._is_init = True
+
+    def forward(self, x, mask, query_embed, pos_embed):
+        """Forward function for `Transformer`.
+
+        Args:
+            x (Tensor): Input query with shape [bs, c, h, w] where
+                c = embed_dims.
+            mask (Tensor): The key_padding_mask used for encoder and decoder,
+                with shape [bs, h, w].
+            query_embed (Tensor): The query embedding for decoder, with shape
+                [num_query, c].
+            pos_embed (Tensor): The positional encoding for encoder and
+                decoder, with the same shape as `x`.
+
+        Returns:
+            tuple[Tensor]: results of decoder containing the following tensor.
+
+                - out_dec: Output from decoder. If return_intermediate_dec \
+                      is True output has shape [num_dec_layers, bs,
+                      num_query, embed_dims], else has shape [1, bs, \
+                      num_query, embed_dims].
+                - memory: Output results from encoder, with shape \
+                      [bs, embed_dims, h, w].
+        """
+        bs, c, h, w = x.shape
+        # use `view` instead of `flatten` for dynamically exporting to ONNX
+        x = x.view(bs, c, -1).permute(2, 0, 1)  # [bs, c, h, w] -> [h*w, bs, c]
+        pos_embed = pos_embed.view(bs, c, -1).permute(2, 0, 1)
+        query_embed = query_embed.unsqueeze(1).repeat(
+            1, bs, 1)  # [num_query, dim] -> [num_query, bs, dim]
+        mask = mask.view(bs, -1)  # [bs, h, w] -> [bs, h*w]
+        memory = self.encoder(
+            query=x,
+            key=None,
+            value=None,
+            query_pos=pos_embed,
+            query_key_padding_mask=mask)
+        target = torch.zeros_like(query_embed)
+        # out_dec: [num_layers, num_query, bs, dim]
+        out_dec = self.decoder(
+            query=target,
+            key=memory,
+            value=memory,
+            key_pos=pos_embed,
+            query_pos=query_embed,
+            key_padding_mask=mask)
+        out_dec = out_dec.transpose(1, 2)
+        memory = memory.permute(1, 2, 0).reshape(bs, c, h, w)
+        return out_dec, memory
+
+
+@MODELS.register_module(force=True)
+class DeformableDetrTransformerDecoder(TransformerLayerSequence):
+    """Implements the decoder in DETR transformer.
+
+    Args:
+        return_intermediate (bool): Whether to return intermediate outputs.
+        coder_norm_cfg (dict): Config of last normalization layer. Default：
+            `LN`.
+    """
+
+    def __init__(self, *args, return_intermediate=False, **kwargs):
+
+        super(DeformableDetrTransformerDecoder, self).__init__(*args, **kwargs)
+        self.return_intermediate = return_intermediate
+
+    def forward(self,
+                query,
+                *args,
+                reference_points=None,
+                valid_ratios=None,
+                reg_branches=None,
+                **kwargs):
+        """Forward function for `TransformerDecoder`.
+
+        Args:
+            query (Tensor): Input query with shape
+                `(num_query, bs, embed_dims)`.
+            reference_points (Tensor): The reference
+                points of offset. has shape
+                (bs, num_query, 4) when as_two_stage,
+                otherwise has shape ((bs, num_query, 2).
+            valid_ratios (Tensor): The radios of valid
+                points on the feature map, has shape
+                (bs, num_levels, 2)
+            reg_branch: (obj:`nn.ModuleList`): Used for
+                refining the regression results. Only would
+                be passed when with_box_refine is True,
+                otherwise would be passed a `None`.
+
+        Returns:
+            Tensor: Results with shape [1, num_query, bs, embed_dims] when
+                return_intermediate is `False`, otherwise it has shape
+                [num_layers, num_query, bs, embed_dims].
+        """
+        output = query
+        intermediate = []
+        intermediate_reference_points = []
+        for lid, layer in enumerate(self.layers):
+            if reference_points.shape[-1] == 4:
+                reference_points_input = reference_points[:, :, None] * \
+                    torch.cat([valid_ratios, valid_ratios], -1)[:, None]
+            else:
+                assert reference_points.shape[-1] == 2
+                reference_points_input = reference_points[:, :, None] * \
+                    valid_ratios[:, None]
+            output = layer(
+                output,
+                *args,
+                reference_points=reference_points_input,
+                **kwargs)
+            output = output.permute(1, 0, 2)
+
+            if reg_branches is not None:
+                tmp = reg_branches[lid](output)
+                if reference_points.shape[-1] == 4:
+                    new_reference_points = tmp + inverse_sigmoid(
+                        reference_points)
+                    new_reference_points = new_reference_points.sigmoid()
+                else:
+                    assert reference_points.shape[-1] == 2
+                    new_reference_points = tmp
+                    new_reference_points[..., :2] = tmp[
+                        ..., :2] + inverse_sigmoid(reference_points)
+                    new_reference_points = new_reference_points.sigmoid()
+                reference_points = new_reference_points.detach()
+
+            output = output.permute(1, 0, 2)
+            if self.return_intermediate:
+                intermediate.append(output)
+                intermediate_reference_points.append(reference_points)
+
+        if self.return_intermediate:
+            return torch.stack(intermediate), torch.stack(
+                intermediate_reference_points)
+
+        return output, reference_points
+
+
+@MODELS.register_module(force=True)
+class DeformableDetrTransformer(Transformer):
+    """Implements the DeformableDETR transformer.
+
+    Args:
+        as_two_stage (bool): Generate query from encoder features.
+            Default: False.
+        num_feature_levels (int): Number of feature maps from FPN:
+            Default: 4.
+        two_stage_num_proposals (int): Number of proposals when set
+            `as_two_stage` as True. Default: 300.
+    """
+
+    def __init__(self,
+                 as_two_stage=False,
+                 num_feature_levels=4,
+                 two_stage_num_proposals=300,
+                 **kwargs):
+        super(DeformableDetrTransformer, self).__init__(**kwargs)
+        self.as_two_stage = as_two_stage
+        self.num_feature_levels = num_feature_levels
+        self.two_stage_num_proposals = two_stage_num_proposals
+        self.embed_dims = self.encoder.embed_dims
+        self.init_layers()
+
+    def init_layers(self):
+        """Initialize layers of the DeformableDetrTransformer."""
+        self.level_embeds = nn.Parameter(
+            torch.Tensor(self.num_feature_levels, self.embed_dims))
+
+        if self.as_two_stage:
+            self.enc_output = nn.Linear(self.embed_dims, self.embed_dims)
+            self.enc_output_norm = nn.LayerNorm(self.embed_dims)
+            self.pos_trans = nn.Linear(self.embed_dims * 2,
+                                       self.embed_dims * 2)
+            self.pos_trans_norm = nn.LayerNorm(self.embed_dims * 2)
+        else:
+            self.reference_points = nn.Linear(self.embed_dims, 2)
+
+    def init_weights(self):
+        """Initialize the transformer weights."""
+        for p in self.parameters():
+            if p.dim() > 1:
+                nn.init.xavier_uniform_(p)
+        for m in self.modules():
+            if isinstance(m, MultiScaleDeformableAttention):
+                m.init_weights()
+        if not self.as_two_stage:
+            xavier_init(self.reference_points, distribution='uniform', bias=0.)
+        normal_(self.level_embeds)
+
+    def gen_encoder_output_proposals(self, memory, memory_padding_mask,
+                                     spatial_shapes):
+        """Generate proposals from encoded memory.
+
+        Args:
+            memory (Tensor) : The output of encoder,
+                has shape (bs, num_key, embed_dim).  num_key is
+                equal the number of points on feature map from
+                all level.
+            memory_padding_mask (Tensor): Padding mask for memory.
+                has shape (bs, num_key).
+            spatial_shapes (Tensor): The shape of all feature maps.
+                has shape (num_level, 2).
+
+        Returns:
+            tuple: A tuple of feature map and bbox prediction.
+
+                - output_memory (Tensor): The input of decoder,  \
+                    has shape (bs, num_key, embed_dim).  num_key is \
+                    equal the number of points on feature map from \
+                    all levels.
+                - output_proposals (Tensor): The normalized proposal \
+                    after a inverse sigmoid, has shape \
+                    (bs, num_keys, 4).
+        """
+
+        N, S, C = memory.shape
+        proposals = []
+        _cur = 0
+        for lvl, (H, W) in enumerate(spatial_shapes):
+            mask_flatten_ = memory_padding_mask[:, _cur:(_cur + H * W)].view(
+                N, H, W, 1)
+            valid_H = torch.sum(~mask_flatten_[:, :, 0, 0], 1)
+            valid_W = torch.sum(~mask_flatten_[:, 0, :, 0], 1)
+
+            grid_y, grid_x = torch.meshgrid(
+                torch.linspace(
+                    0, H - 1, H, dtype=torch.float32, device=memory.device),
+                torch.linspace(
+                    0, W - 1, W, dtype=torch.float32, device=memory.device))
+            grid = torch.cat([grid_x.unsqueeze(-1), grid_y.unsqueeze(-1)], -1)
+
+            scale = torch.cat([valid_W.unsqueeze(-1),
+                               valid_H.unsqueeze(-1)], 1).view(N, 1, 1, 2)
+            grid = (grid.unsqueeze(0).expand(N, -1, -1, -1) + 0.5) / scale
+            wh = torch.ones_like(grid) * 0.05 * (2.0**lvl)
+            proposal = torch.cat((grid, wh), -1).view(N, -1, 4)
+            proposals.append(proposal)
+            _cur += (H * W)
+        output_proposals = torch.cat(proposals, 1)
+        output_proposals_valid = ((output_proposals > 0.01) &
+                                  (output_proposals < 0.99)).all(
+                                      -1, keepdim=True)
+        output_proposals = torch.log(output_proposals / (1 - output_proposals))
+        output_proposals = output_proposals.masked_fill(
+            memory_padding_mask.unsqueeze(-1), float('inf'))
+        output_proposals = output_proposals.masked_fill(
+            ~output_proposals_valid, float('inf'))
+
+        output_memory = memory
+        output_memory = output_memory.masked_fill(
+            memory_padding_mask.unsqueeze(-1), float(0))
+        output_memory = output_memory.masked_fill(~output_proposals_valid,
+                                                  float(0))
+        output_memory = self.enc_output_norm(self.enc_output(output_memory))
+        return output_memory, output_proposals
+
+    @staticmethod
+    def get_reference_points(spatial_shapes, valid_ratios, device):
+        """Get the reference points used in decoder.
+
+        Args:
+            spatial_shapes (Tensor): The shape of all
+                feature maps, has shape (num_level, 2).
+            valid_ratios (Tensor): The radios of valid
+                points on the feature map, has shape
+                (bs, num_levels, 2)
+            device (obj:`device`): The device where
+                reference_points should be.
+
+        Returns:
+            Tensor: reference points used in decoder, has \
+                shape (bs, num_keys, num_levels, 2).
+        """
+        reference_points_list = []
+        for lvl, (H, W) in enumerate(spatial_shapes):
+            ref_y, ref_x = torch.meshgrid(
+                torch.linspace(
+                    0.5, H - 0.5, H, dtype=torch.float32, device=device),
+                torch.linspace(
+                    0.5, W - 0.5, W, dtype=torch.float32, device=device))
+            ref_y = ref_y.reshape(-1)[None] / (
+                valid_ratios[:, None, lvl, 1] * H)
+            ref_x = ref_x.reshape(-1)[None] / (
+                valid_ratios[:, None, lvl, 0] * W)
+            ref = torch.stack((ref_x, ref_y), -1)
+            reference_points_list.append(ref)
+        reference_points = torch.cat(reference_points_list, 1)
+        reference_points = reference_points[:, :, None] * valid_ratios[:, None]
+        return reference_points
+
+    def get_valid_ratio(self, mask):
+        """Get the valid radios of feature maps of all  level."""
+        _, H, W = mask.shape
+        valid_H = torch.sum(~mask[:, :, 0], 1)
+        valid_W = torch.sum(~mask[:, 0, :], 1)
+        valid_ratio_h = valid_H.float() / H
+        valid_ratio_w = valid_W.float() / W
+        valid_ratio = torch.stack([valid_ratio_w, valid_ratio_h], -1)
+        return valid_ratio
+
+    def get_proposal_pos_embed(self,
+                               proposals,
+                               num_pos_feats=128,
+                               temperature=10000):
+        """Get the position embedding of proposal."""
+        scale = 2 * math.pi
+        dim_t = torch.arange(
+            num_pos_feats, dtype=torch.float32, device=proposals.device)
+        dim_t = temperature**(2 * (dim_t // 2) / num_pos_feats)
+        # N, L, 4
+        proposals = proposals.sigmoid() * scale
+        # N, L, 4, 128
+        pos = proposals[:, :, :, None] / dim_t
+        # N, L, 4, 64, 2
+        pos = torch.stack((pos[:, :, :, 0::2].sin(), pos[:, :, :, 1::2].cos()),
+                          dim=4).flatten(2)
+        return pos
+
+    def forward(self,
+                mlvl_feats,
+                mlvl_masks,
+                query_embed,
+                mlvl_pos_embeds,
+                reg_branches=None,
+                cls_branches=None,
+                **kwargs):
+        """Forward function for `Transformer`.
+
+        Args:
+            mlvl_feats (list(Tensor)): Input queries from
+                different level. Each element has shape
+                [bs, embed_dims, h, w].
+            mlvl_masks (list(Tensor)): The key_padding_mask from
+                different level used for encoder and decoder,
+                each element has shape  [bs, h, w].
+            query_embed (Tensor): The query embedding for decoder,
+                with shape [num_query, c].
+            mlvl_pos_embeds (list(Tensor)): The positional encoding
+                of feats from different level, has the shape
+                 [bs, embed_dims, h, w].
+            reg_branches (obj:`nn.ModuleList`): Regression heads for
+                feature maps from each decoder layer. Only would
+                be passed when
+                `with_box_refine` is True. Default to None.
+            cls_branches (obj:`nn.ModuleList`): Classification heads
+                for feature maps from each decoder layer. Only would
+                 be passed when `as_two_stage`
+                 is True. Default to None.
+
+
+        Returns:
+            tuple[Tensor]: results of decoder containing the following tensor.
+
+                - inter_states: Outputs from decoder. If
+                    return_intermediate_dec is True output has shape \
+                      (num_dec_layers, bs, num_query, embed_dims), else has \
+                      shape (1, bs, num_query, embed_dims).
+                - init_reference_out: The initial value of reference \
+                    points, has shape (bs, num_queries, 4).
+                - inter_references_out: The internal value of reference \
+                    points in decoder, has shape \
+                    (num_dec_layers, bs,num_query, embed_dims)
+                - enc_outputs_class: The classification score of \
+                    proposals generated from \
+                    encoder's feature maps, has shape \
+                    (batch, h*w, num_classes). \
+                    Only would be returned when `as_two_stage` is True, \
+                    otherwise None.
+                - enc_outputs_coord_unact: The regression results \
+                    generated from encoder's feature maps., has shape \
+                    (batch, h*w, 4). Only would \
+                    be returned when `as_two_stage` is True, \
+                    otherwise None.
+        """
+        assert self.as_two_stage or query_embed is not None
+
+        feat_flatten = []
+        mask_flatten = []
+        lvl_pos_embed_flatten = []
+        spatial_shapes = []
+        for lvl, (feat, mask, pos_embed) in enumerate(
+                zip(mlvl_feats, mlvl_masks, mlvl_pos_embeds)):
+            bs, c, h, w = feat.shape
+            spatial_shape = (h, w)
+            spatial_shapes.append(spatial_shape)
+            feat = feat.flatten(2).transpose(1, 2)
+            mask = mask.flatten(1)
+            pos_embed = pos_embed.flatten(2).transpose(1, 2)
+            lvl_pos_embed = pos_embed + self.level_embeds[lvl].view(1, 1, -1)
+            lvl_pos_embed_flatten.append(lvl_pos_embed)
+            feat_flatten.append(feat)
+            mask_flatten.append(mask)
+        feat_flatten = torch.cat(feat_flatten, 1)
+        mask_flatten = torch.cat(mask_flatten, 1)
+        lvl_pos_embed_flatten = torch.cat(lvl_pos_embed_flatten, 1)
+        spatial_shapes = torch.as_tensor(
+            spatial_shapes, dtype=torch.long, device=feat_flatten.device)
+        level_start_index = torch.cat((spatial_shapes.new_zeros(
+            (1, )), spatial_shapes.prod(1).cumsum(0)[:-1]))
+        valid_ratios = torch.stack(
+            [self.get_valid_ratio(m) for m in mlvl_masks], 1)
+
+        reference_points = \
+            self.get_reference_points(spatial_shapes,
+                                      valid_ratios,
+                                      device=feat.device)
+
+        feat_flatten = feat_flatten.permute(1, 0, 2)  # (H*W, bs, embed_dims)
+        lvl_pos_embed_flatten = lvl_pos_embed_flatten.permute(
+            1, 0, 2)  # (H*W, bs, embed_dims)
+        memory = self.encoder(
+            query=feat_flatten,
+            key=None,
+            value=None,
+            query_pos=lvl_pos_embed_flatten,
+            query_key_padding_mask=mask_flatten,
+            spatial_shapes=spatial_shapes,
+            reference_points=reference_points,
+            level_start_index=level_start_index,
+            valid_ratios=valid_ratios,
+            **kwargs)
+
+        memory = memory.permute(1, 0, 2)
+        bs, _, c = memory.shape
+        if self.as_two_stage:
+            output_memory, output_proposals = \
+                self.gen_encoder_output_proposals(
+                    memory, mask_flatten, spatial_shapes)
+            enc_outputs_class = cls_branches[self.decoder.num_layers](
+                output_memory)
+            enc_outputs_coord_unact = \
+                reg_branches[
+                    self.decoder.num_layers](output_memory) + output_proposals
+
+            topk = self.two_stage_num_proposals
+            # We only use the first channel in enc_outputs_class as foreground,
+            # the other (num_classes - 1) channels are actually not used.
+            # Its targets are set to be 0s, which indicates the first
+            # class (foreground) because we use [0, num_classes - 1] to
+            # indicate class labels, background class is indicated by
+            # num_classes (similar convention in RPN).
+            # See https://github.com/open-mmlab/mmdetection/blob/master/mmdet/models/dense_heads/deformable_detr_head.py#L241 # noqa
+            # This follows the official implementation of Deformable DETR.
+            topk_proposals = torch.topk(
+                enc_outputs_class[..., 0], topk, dim=1)[1]
+            topk_coords_unact = torch.gather(
+                enc_outputs_coord_unact, 1,
+                topk_proposals.unsqueeze(-1).repeat(1, 1, 4))
+            topk_coords_unact = topk_coords_unact.detach()
+            reference_points = topk_coords_unact.sigmoid()
+            init_reference_out = reference_points
+            pos_trans_out = self.pos_trans_norm(
+                self.pos_trans(self.get_proposal_pos_embed(topk_coords_unact)))
+            query_pos, query = torch.split(pos_trans_out, c, dim=2)
+        else:
+            query_pos, query = torch.split(query_embed, c, dim=1)
+            query_pos = query_pos.unsqueeze(0).expand(bs, -1, -1)
+            query = query.unsqueeze(0).expand(bs, -1, -1)
+            reference_points = self.reference_points(query_pos).sigmoid()
+            init_reference_out = reference_points
+
+        # decoder
+        query = query.permute(1, 0, 2)
+        memory = memory.permute(1, 0, 2)
+        query_pos = query_pos.permute(1, 0, 2)
+        inter_states, inter_references = self.decoder(
+            query=query,
+            key=None,
+            value=memory,
+            query_pos=query_pos,
+            key_padding_mask=mask_flatten,
+            reference_points=reference_points,
+            spatial_shapes=spatial_shapes,
+            level_start_index=level_start_index,
+            valid_ratios=valid_ratios,
+            reg_branches=reg_branches,
+            **kwargs)
+
+        inter_references_out = inter_references
+        if self.as_two_stage:
+            return inter_states, init_reference_out,\
+                inter_references_out, enc_outputs_class,\
+                enc_outputs_coord_unact
+        return inter_states, init_reference_out, \
+            inter_references_out, None, None
+
+
+@MODELS.register_module()
+class CoDeformableDetrTransformerDecoder(TransformerLayerSequence):
+    """Implements the decoder in DETR transformer.
+
+    Args:
+        return_intermediate (bool): Whether to return intermediate outputs.
+        coder_norm_cfg (dict): Config of last normalization layer. Default：
+            `LN`.
+    """
+
+    def __init__(self,
+                 *args,
+                 return_intermediate=False,
+                 look_forward_twice=False,
+                 **kwargs):
+
+        super(CoDeformableDetrTransformerDecoder,
+              self).__init__(*args, **kwargs)
+        self.return_intermediate = return_intermediate
+        self.look_forward_twice = look_forward_twice
+
+    def forward(self,
+                query,
+                *args,
+                reference_points=None,
+                valid_ratios=None,
+                reg_branches=None,
+                **kwargs):
+        """Forward function for `TransformerDecoder`.
+
+        Args:
+            query (Tensor): Input query with shape
+                `(num_query, bs, embed_dims)`.
+            reference_points (Tensor): The reference
+                points of offset. has shape
+                (bs, num_query, 4) when as_two_stage,
+                otherwise has shape ((bs, num_query, 2).
+            valid_ratios (Tensor): The radios of valid
+                points on the feature map, has shape
+                (bs, num_levels, 2)
+            reg_branch: (obj:`nn.ModuleList`): Used for
+                refining the regression results. Only would
+                be passed when with_box_refine is True,
+                otherwise would be passed a `None`.
+
+        Returns:
+            Tensor: Results with shape [1, num_query, bs, embed_dims] when
+                return_intermediate is `False`, otherwise it has shape
+                [num_layers, num_query, bs, embed_dims].
+        """
+        output = query
+        intermediate = []
+        intermediate_reference_points = []
+        for lid, layer in enumerate(self.layers):
+            if reference_points.shape[-1] == 4:
+                reference_points_input = reference_points[:, :, None] * \
+                    torch.cat([valid_ratios, valid_ratios], -1)[:, None]
+            else:
+                assert reference_points.shape[-1] == 2
+                reference_points_input = reference_points[:, :, None] * \
+                    valid_ratios[:, None]
+            output = layer(
+                output,
+                *args,
+                reference_points=reference_points_input,
+                **kwargs)
+            output = output.permute(1, 0, 2)
+
+            if reg_branches is not None:
+                tmp = reg_branches[lid](output)
+                if reference_points.shape[-1] == 4:
+                    new_reference_points = tmp + inverse_sigmoid(
+                        reference_points)
+                    new_reference_points = new_reference_points.sigmoid()
+                else:
+                    assert reference_points.shape[-1] == 2
+                    new_reference_points = tmp
+                    new_reference_points[..., :2] = tmp[
+                        ..., :2] + inverse_sigmoid(reference_points)
+                    new_reference_points = new_reference_points.sigmoid()
+                reference_points = new_reference_points.detach()
+
+            output = output.permute(1, 0, 2)
+            if self.return_intermediate:
+                intermediate.append(output)
+                intermediate_reference_points.append(
+                    new_reference_points if self.
+                    look_forward_twice else reference_points)
+        if self.return_intermediate:
+            return torch.stack(intermediate), torch.stack(
+                intermediate_reference_points)
+
+        return output, reference_points
+
+
+@MODELS.register_module()
+class CoDeformableDetrTransformer(DeformableDetrTransformer):
+
+    def __init__(self,
+                 mixed_selection=True,
+                 with_pos_coord=True,
+                 with_coord_feat=True,
+                 num_co_heads=1,
+                 **kwargs):
+        self.mixed_selection = mixed_selection
+        self.with_pos_coord = with_pos_coord
+        self.with_coord_feat = with_coord_feat
+        self.num_co_heads = num_co_heads
+        super(CoDeformableDetrTransformer, self).__init__(**kwargs)
+        self._init_layers()
+
+    def _init_layers(self):
+        """Initialize layers of the CoDeformableDetrTransformer."""
+        if self.with_pos_coord:
+            if self.num_co_heads > 0:
+                # bug: this code should be 'self.head_pos_embed =
+                # nn.Embedding(self.num_co_heads, self.embed_dims)',
+                # we keep this bug for reproducing our results with ResNet-50.
+                # You can fix this bug when reproducing results with
+                # swin transformer.
+                self.head_pos_embed = nn.Embedding(self.num_co_heads, 1, 1,
+                                                   self.embed_dims)
+                self.aux_pos_trans = nn.ModuleList()
+                self.aux_pos_trans_norm = nn.ModuleList()
+                self.pos_feats_trans = nn.ModuleList()
+                self.pos_feats_norm = nn.ModuleList()
+                for i in range(self.num_co_heads):
+                    self.aux_pos_trans.append(
+                        nn.Linear(self.embed_dims * 2, self.embed_dims * 2))
+                    self.aux_pos_trans_norm.append(
+                        nn.LayerNorm(self.embed_dims * 2))
+                    if self.with_coord_feat:
+                        self.pos_feats_trans.append(
+                            nn.Linear(self.embed_dims, self.embed_dims))
+                        self.pos_feats_norm.append(
+                            nn.LayerNorm(self.embed_dims))
+
+    def get_proposal_pos_embed(self,
+                               proposals,
+                               num_pos_feats=128,
+                               temperature=10000):
+        """Get the position embedding of proposal."""
+        num_pos_feats = self.embed_dims // 2
+        scale = 2 * math.pi
+        dim_t = torch.arange(
+            num_pos_feats, dtype=torch.float32, device=proposals.device)
+        dim_t = temperature**(2 * (dim_t // 2) / num_pos_feats)
+        # N, L, 4
+        proposals = proposals.sigmoid() * scale
+        # N, L, 4, 128
+        pos = proposals[:, :, :, None] / dim_t
+        # N, L, 4, 64, 2
+        pos = torch.stack((pos[:, :, :, 0::2].sin(), pos[:, :, :, 1::2].cos()),
+                          dim=4).flatten(2)
+        return pos
+
+    def forward(self,
+                mlvl_feats,
+                mlvl_masks,
+                query_embed,
+                mlvl_pos_embeds,
+                reg_branches=None,
+                cls_branches=None,
+                return_encoder_output=False,
+                attn_masks=None,
+                **kwargs):
+        """Forward function for `Transformer`.
+
+        Args:
+            mlvl_feats (list(Tensor)): Input queries from
+                different level. Each element has shape
+                [bs, embed_dims, h, w].
+            mlvl_masks (list(Tensor)): The key_padding_mask from
+                different level used for encoder and decoder,
+                each element has shape  [bs, h, w].
+            query_embed (Tensor): The query embedding for decoder,
+                with shape [num_query, c].
+            mlvl_pos_embeds (list(Tensor)): The positional encoding
+                of feats from different level, has the shape
+                 [bs, embed_dims, h, w].
+            reg_branches (obj:`nn.ModuleList`): Regression heads for
+                feature maps from each decoder layer. Only would
+                be passed when
+                `with_box_refine` is True. Default to None.
+            cls_branches (obj:`nn.ModuleList`): Classification heads
+                for feature maps from each decoder layer. Only would
+                 be passed when `as_two_stage`
+                 is True. Default to None.
+
+
+        Returns:
+            tuple[Tensor]: results of decoder containing the following tensor.
+
+                - inter_states: Outputs from decoder. If
+                    return_intermediate_dec is True output has shape \
+                      (num_dec_layers, bs, num_query, embed_dims), else has \
+                      shape (1, bs, num_query, embed_dims).
+                - init_reference_out: The initial value of reference \
+                    points, has shape (bs, num_queries, 4).
+                - inter_references_out: The internal value of reference \
+                    points in decoder, has shape \
+                    (num_dec_layers, bs,num_query, embed_dims)
+                - enc_outputs_class: The classification score of \
+                    proposals generated from \
+                    encoder's feature maps, has shape \
+                    (batch, h*w, num_classes). \
+                    Only would be returned when `as_two_stage` is True, \
+                    otherwise None.
+                - enc_outputs_coord_unact: The regression results \
+                    generated from encoder's feature maps., has shape \
+                    (batch, h*w, 4). Only would \
+                    be returned when `as_two_stage` is True, \
+                    otherwise None.
+        """
+        assert self.as_two_stage or query_embed is not None
+
+        feat_flatten = []
+        mask_flatten = []
+        lvl_pos_embed_flatten = []
+        spatial_shapes = []
+        for lvl, (feat, mask, pos_embed) in enumerate(
+                zip(mlvl_feats, mlvl_masks, mlvl_pos_embeds)):
+            bs, c, h, w = feat.shape
+            spatial_shape = (h, w)
+            spatial_shapes.append(spatial_shape)
+            feat = feat.flatten(2).transpose(1, 2)
+            mask = mask.flatten(1)
+            pos_embed = pos_embed.flatten(2).transpose(1, 2)
+            lvl_pos_embed = pos_embed + self.level_embeds[lvl].view(1, 1, -1)
+            lvl_pos_embed_flatten.append(lvl_pos_embed)
+            feat_flatten.append(feat)
+            mask_flatten.append(mask)
+        feat_flatten = torch.cat(feat_flatten, 1)
+        mask_flatten = torch.cat(mask_flatten, 1)
+        lvl_pos_embed_flatten = torch.cat(lvl_pos_embed_flatten, 1)
+        spatial_shapes = torch.as_tensor(
+            spatial_shapes, dtype=torch.long, device=feat_flatten.device)
+        level_start_index = torch.cat((spatial_shapes.new_zeros(
+            (1, )), spatial_shapes.prod(1).cumsum(0)[:-1]))
+        valid_ratios = torch.stack(
+            [self.get_valid_ratio(m) for m in mlvl_masks], 1)
+
+        reference_points = \
+            self.get_reference_points(spatial_shapes,
+                                      valid_ratios,
+                                      device=feat.device)
+
+        feat_flatten = feat_flatten.permute(1, 0, 2)  # (H*W, bs, embed_dims)
+        lvl_pos_embed_flatten = lvl_pos_embed_flatten.permute(
+            1, 0, 2)  # (H*W, bs, embed_dims)
+        memory = self.encoder(
+            query=feat_flatten,
+            key=None,
+            value=None,
+            query_pos=lvl_pos_embed_flatten,
+            query_key_padding_mask=mask_flatten,
+            spatial_shapes=spatial_shapes,
+            reference_points=reference_points,
+            level_start_index=level_start_index,
+            valid_ratios=valid_ratios,
+            **kwargs)
+
+        memory = memory.permute(1, 0, 2)
+        bs, _, c = memory.shape
+        if self.as_two_stage:
+            output_memory, output_proposals = \
+                self.gen_encoder_output_proposals(
+                    memory, mask_flatten, spatial_shapes)
+            enc_outputs_class = cls_branches[self.decoder.num_layers](
+                output_memory)
+            enc_outputs_coord_unact = \
+                reg_branches[
+                    self.decoder.num_layers](output_memory) + output_proposals
+
+            topk = self.two_stage_num_proposals
+            topk = query_embed.shape[0]
+            topk_proposals = torch.topk(
+                enc_outputs_class[..., 0], topk, dim=1)[1]
+            topk_coords_unact = torch.gather(
+                enc_outputs_coord_unact, 1,
+                topk_proposals.unsqueeze(-1).repeat(1, 1, 4))
+            topk_coords_unact = topk_coords_unact.detach()
+            reference_points = topk_coords_unact.sigmoid()
+            init_reference_out = reference_points
+            pos_trans_out = self.pos_trans_norm(
+                self.pos_trans(self.get_proposal_pos_embed(topk_coords_unact)))
+
+            if not self.mixed_selection:
+                query_pos, query = torch.split(pos_trans_out, c, dim=2)
+            else:
+                # query_embed here is the content embed for deformable DETR
+                query = query_embed.unsqueeze(0).expand(bs, -1, -1)
+                query_pos, _ = torch.split(pos_trans_out, c, dim=2)
+        else:
+            query_pos, query = torch.split(query_embed, c, dim=1)
+            query_pos = query_pos.unsqueeze(0).expand(bs, -1, -1)
+            query = query.unsqueeze(0).expand(bs, -1, -1)
+            reference_points = self.reference_points(query_pos).sigmoid()
+            init_reference_out = reference_points
+
+        # decoder
+        query = query.permute(1, 0, 2)
+        memory = memory.permute(1, 0, 2)
+        query_pos = query_pos.permute(1, 0, 2)
+        inter_states, inter_references = self.decoder(
+            query=query,
+            key=None,
+            value=memory,
+            query_pos=query_pos,
+            key_padding_mask=mask_flatten,
+            reference_points=reference_points,
+            spatial_shapes=spatial_shapes,
+            level_start_index=level_start_index,
+            valid_ratios=valid_ratios,
+            reg_branches=reg_branches,
+            attn_masks=attn_masks,
+            **kwargs)
+
+        inter_references_out = inter_references
+        if self.as_two_stage:
+            if return_encoder_output:
+                return inter_states, init_reference_out,\
+                    inter_references_out, enc_outputs_class,\
+                    enc_outputs_coord_unact, memory
+            return inter_states, init_reference_out,\
+                inter_references_out, enc_outputs_class,\
+                enc_outputs_coord_unact
+        if return_encoder_output:
+            return inter_states, init_reference_out, \
+                inter_references_out, None, None, memory
+        return inter_states, init_reference_out, \
+            inter_references_out, None, None
+
+    def forward_aux(self,
+                    mlvl_feats,
+                    mlvl_masks,
+                    query_embed,
+                    mlvl_pos_embeds,
+                    pos_anchors,
+                    pos_feats=None,
+                    reg_branches=None,
+                    cls_branches=None,
+                    return_encoder_output=False,
+                    attn_masks=None,
+                    head_idx=0,
+                    **kwargs):
+        feat_flatten = []
+        mask_flatten = []
+        spatial_shapes = []
+        for lvl, (feat, mask, pos_embed) in enumerate(
+                zip(mlvl_feats, mlvl_masks, mlvl_pos_embeds)):
+            bs, c, h, w = feat.shape
+            spatial_shape = (h, w)
+            spatial_shapes.append(spatial_shape)
+            feat = feat.flatten(2).transpose(1, 2)
+            mask = mask.flatten(1)
+            feat_flatten.append(feat)
+            mask_flatten.append(mask)
+        feat_flatten = torch.cat(feat_flatten, 1)
+        mask_flatten = torch.cat(mask_flatten, 1)
+        spatial_shapes = torch.as_tensor(
+            spatial_shapes, dtype=torch.long, device=feat_flatten.device)
+        level_start_index = torch.cat((spatial_shapes.new_zeros(
+            (1, )), spatial_shapes.prod(1).cumsum(0)[:-1]))
+        valid_ratios = torch.stack(
+            [self.get_valid_ratio(m) for m in mlvl_masks], 1)
+
+        feat_flatten = feat_flatten.permute(1, 0, 2)  # (H*W, bs, embed_dims)
+
+        memory = feat_flatten
+        memory = memory.permute(1, 0, 2)
+        bs, _, c = memory.shape
+
+        topk_coords_unact = inverse_sigmoid(pos_anchors)
+        reference_points = pos_anchors
+        init_reference_out = reference_points
+        if self.num_co_heads > 0:
+            pos_trans_out = self.aux_pos_trans_norm[head_idx](
+                self.aux_pos_trans[head_idx](
+                    self.get_proposal_pos_embed(topk_coords_unact)))
+            query_pos, query = torch.split(pos_trans_out, c, dim=2)
+            if self.with_coord_feat:
+                query = query + self.pos_feats_norm[head_idx](
+                    self.pos_feats_trans[head_idx](pos_feats))
+                query_pos = query_pos + self.head_pos_embed.weight[head_idx]
+
+        # decoder
+        query = query.permute(1, 0, 2)
+        memory = memory.permute(1, 0, 2)
+        query_pos = query_pos.permute(1, 0, 2)
+        inter_states, inter_references = self.decoder(
+            query=query,
+            key=None,
+            value=memory,
+            query_pos=query_pos,
+            key_padding_mask=mask_flatten,
+            reference_points=reference_points,
+            spatial_shapes=spatial_shapes,
+            level_start_index=level_start_index,
+            valid_ratios=valid_ratios,
+            reg_branches=reg_branches,
+            attn_masks=attn_masks,
+            **kwargs)
+
+        inter_references_out = inter_references
+        return inter_states, init_reference_out, \
+            inter_references_out
+
+
+def build_MLP(input_dim, hidden_dim, output_dim, num_layers):
+    assert num_layers > 1, \
+        f'num_layers should be greater than 1 but got {num_layers}'
+    h = [hidden_dim] * (num_layers - 1)
+    layers = list()
+    for n, k in zip([input_dim] + h[:-1], h):
+        layers.extend((nn.Linear(n, k), nn.ReLU()))
+    # Note that the relu func of MLP in original DETR repo is set
+    # 'inplace=False', however the ReLU cfg of FFN in mmdet is set
+    # 'inplace=True' by default.
+    layers.append(nn.Linear(hidden_dim, output_dim))
+    return nn.Sequential(*layers)
+
+
+@MODELS.register_module()
+class DinoTransformerDecoder(DeformableDetrTransformerDecoder):
+
+    def __init__(self, *args, **kwargs):
+        super(DinoTransformerDecoder, self).__init__(*args, **kwargs)
+        self._init_layers()
+
+    def _init_layers(self):
+        self.ref_point_head = build_MLP(self.embed_dims * 2, self.embed_dims,
+                                        self.embed_dims, 2)
+        self.norm = nn.LayerNorm(self.embed_dims)
+
+    @staticmethod
+    def gen_sineembed_for_position(pos_tensor, pos_feat):
+        # n_query, bs, _ = pos_tensor.size()
+        # sineembed_tensor = torch.zeros(n_query, bs, 256)
+        scale = 2 * math.pi
+        dim_t = torch.arange(
+            pos_feat, dtype=torch.float32, device=pos_tensor.device)
+        dim_t = 10000**(2 * (dim_t // 2) / pos_feat)
+        x_embed = pos_tensor[:, :, 0] * scale
+        y_embed = pos_tensor[:, :, 1] * scale
+        pos_x = x_embed[:, :, None] / dim_t
+        pos_y = y_embed[:, :, None] / dim_t
+        pos_x = torch.stack((pos_x[:, :, 0::2].sin(), pos_x[:, :, 1::2].cos()),
+                            dim=3).flatten(2)
+        pos_y = torch.stack((pos_y[:, :, 0::2].sin(), pos_y[:, :, 1::2].cos()),
+                            dim=3).flatten(2)
+        if pos_tensor.size(-1) == 2:
+            pos = torch.cat((pos_y, pos_x), dim=2)
+        elif pos_tensor.size(-1) == 4:
+            w_embed = pos_tensor[:, :, 2] * scale
+            pos_w = w_embed[:, :, None] / dim_t
+            pos_w = torch.stack(
+                (pos_w[:, :, 0::2].sin(), pos_w[:, :, 1::2].cos()),
+                dim=3).flatten(2)
+
+            h_embed = pos_tensor[:, :, 3] * scale
+            pos_h = h_embed[:, :, None] / dim_t
+            pos_h = torch.stack(
+                (pos_h[:, :, 0::2].sin(), pos_h[:, :, 1::2].cos()),
+                dim=3).flatten(2)
+
+            pos = torch.cat((pos_y, pos_x, pos_w, pos_h), dim=2)
+        else:
+            raise ValueError('Unknown pos_tensor shape(-1):{}'.format(
+                pos_tensor.size(-1)))
+        return pos
+
+    def forward(self,
+                query,
+                *args,
+                reference_points=None,
+                valid_ratios=None,
+                reg_branches=None,
+                **kwargs):
+        output = query
+        intermediate = []
+        intermediate_reference_points = [reference_points]
+        for lid, layer in enumerate(self.layers):
+            if reference_points.shape[-1] == 4:
+                reference_points_input = \
+                    reference_points[:, :, None] * torch.cat(
+                        [valid_ratios, valid_ratios], -1)[:, None]
+            else:
+                assert reference_points.shape[-1] == 2
+                reference_points_input = \
+                    reference_points[:, :, None] * valid_ratios[:, None]
+
+            query_sine_embed = self.gen_sineembed_for_position(
+                reference_points_input[:, :, 0, :], self.embed_dims // 2)
+            query_pos = self.ref_point_head(query_sine_embed)
+
+            query_pos = query_pos.permute(1, 0, 2)
+            output = layer(
+                output,
+                *args,
+                query_pos=query_pos,
+                reference_points=reference_points_input,
+                **kwargs)
+            output = output.permute(1, 0, 2)
+
+            if reg_branches is not None:
+                tmp = reg_branches[lid](output)
+                assert reference_points.shape[-1] == 4
+                new_reference_points = tmp + inverse_sigmoid(
+                    reference_points, eps=1e-3)
+                new_reference_points = new_reference_points.sigmoid()
+                reference_points = new_reference_points.detach()
+
+            output = output.permute(1, 0, 2)
+            if self.return_intermediate:
+                intermediate.append(self.norm(output))
+                intermediate_reference_points.append(new_reference_points)
+                # NOTE this is for the "Look Forward Twice" module,
+                # in the DeformDETR, reference_points was appended.
+
+        if self.return_intermediate:
+            return torch.stack(intermediate), torch.stack(
+                intermediate_reference_points)
+
+        return output, reference_points
+
+
+@MODELS.register_module()
+class CoDinoTransformer(CoDeformableDetrTransformer):
+
+    def __init__(self, *args, **kwargs):
+        super(CoDinoTransformer, self).__init__(*args, **kwargs)
+
+    def init_layers(self):
+        """Initialize layers of the DinoTransformer."""
+        self.level_embeds = nn.Parameter(
+            torch.Tensor(self.num_feature_levels, self.embed_dims))
+        self.enc_output = nn.Linear(self.embed_dims, self.embed_dims)
+        self.enc_output_norm = nn.LayerNorm(self.embed_dims)
+        self.query_embed = nn.Embedding(self.two_stage_num_proposals,
+                                        self.embed_dims)
+
+    def _init_layers(self):
+        if self.with_pos_coord:
+            if self.num_co_heads > 0:
+                self.aux_pos_trans = nn.ModuleList()
+                self.aux_pos_trans_norm = nn.ModuleList()
+                self.pos_feats_trans = nn.ModuleList()
+                self.pos_feats_norm = nn.ModuleList()
+                for i in range(self.num_co_heads):
+                    self.aux_pos_trans.append(
+                        nn.Linear(self.embed_dims * 2, self.embed_dims))
+                    self.aux_pos_trans_norm.append(
+                        nn.LayerNorm(self.embed_dims))
+                    if self.with_coord_feat:
+                        self.pos_feats_trans.append(
+                            nn.Linear(self.embed_dims, self.embed_dims))
+                        self.pos_feats_norm.append(
+                            nn.LayerNorm(self.embed_dims))
+
+    def init_weights(self):
+        super().init_weights()
+        nn.init.normal_(self.query_embed.weight.data)
+
+    def forward(self,
+                mlvl_feats,
+                mlvl_masks,
+                query_embed,
+                mlvl_pos_embeds,
+                dn_label_query,
+                dn_bbox_query,
+                attn_mask,
+                reg_branches=None,
+                cls_branches=None,
+                **kwargs):
+        assert self.as_two_stage and query_embed is None, \
+            'as_two_stage must be True for DINO'
+
+        feat_flatten = []
+        mask_flatten = []
+        lvl_pos_embed_flatten = []
+        spatial_shapes = []
+        for lvl, (feat, mask, pos_embed) in enumerate(
+                zip(mlvl_feats, mlvl_masks, mlvl_pos_embeds)):
+            bs, c, h, w = feat.shape
+            spatial_shape = (h, w)
+            spatial_shapes.append(spatial_shape)
+            feat = feat.flatten(2).transpose(1, 2)
+            mask = mask.flatten(1)
+            pos_embed = pos_embed.flatten(2).transpose(1, 2)
+            lvl_pos_embed = pos_embed + self.level_embeds[lvl].view(1, 1, -1)
+            lvl_pos_embed_flatten.append(lvl_pos_embed)
+            feat_flatten.append(feat)
+            mask_flatten.append(mask)
+        feat_flatten = torch.cat(feat_flatten, 1)
+        mask_flatten = torch.cat(mask_flatten, 1)
+        lvl_pos_embed_flatten = torch.cat(lvl_pos_embed_flatten, 1)
+        spatial_shapes = torch.as_tensor(
+            spatial_shapes, dtype=torch.long, device=feat_flatten.device)
+        level_start_index = torch.cat((spatial_shapes.new_zeros(
+            (1, )), spatial_shapes.prod(1).cumsum(0)[:-1]))
+        valid_ratios = torch.stack(
+            [self.get_valid_ratio(m) for m in mlvl_masks], 1)
+
+        reference_points = self.get_reference_points(
+            spatial_shapes, valid_ratios, device=feat.device)
+
+        feat_flatten = feat_flatten.permute(1, 0, 2)  # (H*W, bs, embed_dims)
+        lvl_pos_embed_flatten = lvl_pos_embed_flatten.permute(
+            1, 0, 2)  # (H*W, bs, embed_dims)
+        memory = self.encoder(
+            query=feat_flatten,
+            key=None,
+            value=None,
+            query_pos=lvl_pos_embed_flatten,
+            query_key_padding_mask=mask_flatten,
+            spatial_shapes=spatial_shapes,
+            reference_points=reference_points,
+            level_start_index=level_start_index,
+            valid_ratios=valid_ratios,
+            **kwargs)
+        memory = memory.permute(1, 0, 2)
+        bs, _, c = memory.shape
+
+        output_memory, output_proposals = self.gen_encoder_output_proposals(
+            memory, mask_flatten, spatial_shapes)
+        enc_outputs_class = cls_branches[self.decoder.num_layers](
+            output_memory)
+        enc_outputs_coord_unact = reg_branches[self.decoder.num_layers](
+            output_memory) + output_proposals
+        cls_out_features = cls_branches[self.decoder.num_layers].out_features
+        topk = self.two_stage_num_proposals
+        # NOTE In DeformDETR, enc_outputs_class[..., 0] is used for topk
+        topk_indices = torch.topk(enc_outputs_class.max(-1)[0], topk, dim=1)[1]
+
+        topk_score = torch.gather(
+            enc_outputs_class, 1,
+            topk_indices.unsqueeze(-1).repeat(1, 1, cls_out_features))
+        topk_coords_unact = torch.gather(
+            enc_outputs_coord_unact, 1,
+            topk_indices.unsqueeze(-1).repeat(1, 1, 4))
+        topk_anchor = topk_coords_unact.sigmoid()
+        topk_coords_unact = topk_coords_unact.detach()
+
+        query = self.query_embed.weight[:, None, :].repeat(1, bs,
+                                                           1).transpose(0, 1)
+        # NOTE the query_embed here is not spatial query as in DETR.
+        # It is actually content query, which is named tgt in other
+        # DETR-like models
+        if dn_label_query is not None:
+            query = torch.cat([dn_label_query, query], dim=1)
+        if dn_bbox_query is not None:
+            reference_points = torch.cat([dn_bbox_query, topk_coords_unact],
+                                         dim=1)
+        else:
+            reference_points = topk_coords_unact
+        reference_points = reference_points.sigmoid()
+        # decoder
+        query = query.permute(1, 0, 2)
+        memory = memory.permute(1, 0, 2)
+        inter_states, inter_references = self.decoder(
+            query=query,
+            key=None,
+            value=memory,
+            attn_masks=attn_mask,
+            key_padding_mask=mask_flatten,
+            reference_points=reference_points,
+            spatial_shapes=spatial_shapes,
+            level_start_index=level_start_index,
+            valid_ratios=valid_ratios,
+            reg_branches=reg_branches,
+            **kwargs)
+
+        inter_references_out = inter_references
+
+        return inter_states, inter_references_out, \
+            topk_score, topk_anchor, memory
+
+    def forward_aux(self,
+                    mlvl_feats,
+                    mlvl_masks,
+                    query_embed,
+                    mlvl_pos_embeds,
+                    pos_anchors,
+                    pos_feats=None,
+                    reg_branches=None,
+                    cls_branches=None,
+                    return_encoder_output=False,
+                    attn_masks=None,
+                    head_idx=0,
+                    **kwargs):
+        feat_flatten = []
+        mask_flatten = []
+        spatial_shapes = []
+        for lvl, (feat, mask, pos_embed) in enumerate(
+                zip(mlvl_feats, mlvl_masks, mlvl_pos_embeds)):
+            bs, c, h, w = feat.shape
+            spatial_shape = (h, w)
+            spatial_shapes.append(spatial_shape)
+            feat = feat.flatten(2).transpose(1, 2)
+            mask = mask.flatten(1)
+            feat_flatten.append(feat)
+            mask_flatten.append(mask)
+        feat_flatten = torch.cat(feat_flatten, 1)
+        mask_flatten = torch.cat(mask_flatten, 1)
+        spatial_shapes = torch.as_tensor(
+            spatial_shapes, dtype=torch.long, device=feat_flatten.device)
+        level_start_index = torch.cat((spatial_shapes.new_zeros(
+            (1, )), spatial_shapes.prod(1).cumsum(0)[:-1]))
+        valid_ratios = torch.stack(
+            [self.get_valid_ratio(m) for m in mlvl_masks], 1)
+
+        feat_flatten = feat_flatten.permute(1, 0, 2)  # (H*W, bs, embed_dims)
+
+        memory = feat_flatten
+        memory = memory.permute(1, 0, 2)
+        bs, _, c = memory.shape
+
+        topk_coords_unact = inverse_sigmoid(pos_anchors)
+        reference_points = pos_anchors
+        if self.num_co_heads > 0:
+            pos_trans_out = self.aux_pos_trans_norm[head_idx](
+                self.aux_pos_trans[head_idx](
+                    self.get_proposal_pos_embed(topk_coords_unact)))
+            query = pos_trans_out
+            if self.with_coord_feat:
+                query = query + self.pos_feats_norm[head_idx](
+                    self.pos_feats_trans[head_idx](pos_feats))
+
+        # decoder
+        query = query.permute(1, 0, 2)
+        memory = memory.permute(1, 0, 2)
+        inter_states, inter_references = self.decoder(
+            query=query,
+            key=None,
+            value=memory,
+            attn_masks=None,
+            key_padding_mask=mask_flatten,
+            reference_points=reference_points,
+            spatial_shapes=spatial_shapes,
+            level_start_index=level_start_index,
+            valid_ratios=valid_ratios,
+            reg_branches=reg_branches,
+            **kwargs)
+
+        inter_references_out = inter_references
+
+        return inter_states, inter_references_out
+
+
+@MODELS.register_module()
+class DetrTransformerEncoder(TransformerLayerSequence):
+    """TransformerEncoder of DETR.
+
+    Args:
+        post_norm_cfg (dict): Config of last normalization layer. Default：
+            `LN`. Only used when `self.pre_norm` is `True`
+    """
+
+    def __init__(self,
+                 *args,
+                 post_norm_cfg=dict(type='LN'),
+                 with_cp=-1,
+                 **kwargs):
+        super(DetrTransformerEncoder, self).__init__(*args, **kwargs)
+        if post_norm_cfg is not None:
+            self.post_norm = build_norm_layer(
+                post_norm_cfg, self.embed_dims)[1] if self.pre_norm else None
+        else:
+            assert not self.pre_norm, f'Use prenorm in ' \
+                                      f'{self.__class__.__name__},' \
+                                      f'Please specify post_norm_cfg'
+            self.post_norm = None
+        self.with_cp = with_cp
+        if self.with_cp > 0:
+            if checkpoint_wrapper is None:
+                warnings.warn('If you want to reduce GPU memory usage, \
+                              please install fairscale by executing the \
+                              following command: pip install fairscale.')
+                return
+            for i in range(self.with_cp):
+                self.layers[i] = checkpoint_wrapper(self.layers[i])
+
+
+@MODELS.register_module()
+class DetrTransformerDecoderLayer(BaseTransformerLayer):
+    """Implements decoder layer in DETR transformer.
+
+    Args:
+        attn_cfgs (list[`mmcv.ConfigDict`] | list[dict] | dict )):
+            Configs for self_attention or cross_attention, the order
+            should be consistent with it in `operation_order`. If it is
+            a dict, it would be expand to the number of attention in
+            `operation_order`.
+        feedforward_channels (int): The hidden dimension for FFNs.
+        ffn_dropout (float): Probability of an element to be zeroed
+            in ffn. Default 0.0.
+        operation_order (tuple[str]): The execution order of operation
+            in transformer. Such as ('self_attn', 'norm', 'ffn', 'norm').
+            Default：None
+        act_cfg (dict): The activation config for FFNs. Default: `LN`
+        norm_cfg (dict): Config dict for normalization layer.
+            Default: `LN`.
+        ffn_num_fcs (int): The number of fully-connected layers in FFNs.
+            Default：2.
+    """
+
+    def __init__(self,
+                 attn_cfgs,
+                 feedforward_channels,
+                 ffn_dropout=0.0,
+                 operation_order=None,
+                 act_cfg=dict(type='ReLU', inplace=True),
+                 norm_cfg=dict(type='LN'),
+                 ffn_num_fcs=2,
+                 **kwargs):
+        super(DetrTransformerDecoderLayer, self).__init__(
+            attn_cfgs=attn_cfgs,
+            feedforward_channels=feedforward_channels,
+            ffn_dropout=ffn_dropout,
+            operation_order=operation_order,
+            act_cfg=act_cfg,
+            norm_cfg=norm_cfg,
+            ffn_num_fcs=ffn_num_fcs,
+            **kwargs)
+        assert len(operation_order) == 6
+        assert set(operation_order) == set(
+            ['self_attn', 'norm', 'cross_attn', 'ffn'])
diff --git a/mmdetection/projects/CO-DETR/configs/codino/co_dino_5scale_r50_8xb2_1x_coco.py b/mmdetection/projects/CO-DETR/configs/codino/co_dino_5scale_r50_8xb2_1x_coco.py
new file mode 100644
index 00000000..1a413043
--- /dev/null
+++ b/mmdetection/projects/CO-DETR/configs/codino/co_dino_5scale_r50_8xb2_1x_coco.py
@@ -0,0 +1,68 @@
+_base_ = './co_dino_5scale_r50_lsj_8xb2_1x_coco.py'
+
+model = dict(
+    use_lsj=False, data_preprocessor=dict(pad_mask=False, batch_augments=None))
+
+# train_pipeline, NOTE the img_scale and the Pad's size_divisor is different
+# from the default setting in mmdet.
+train_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=_base_.backend_args),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(
+        type='RandomChoice',
+        transforms=[
+            [
+                dict(
+                    type='RandomChoiceResize',
+                    scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333),
+                            (608, 1333), (640, 1333), (672, 1333), (704, 1333),
+                            (736, 1333), (768, 1333), (800, 1333)],
+                    keep_ratio=True)
+            ],
+            [
+                dict(
+                    type='RandomChoiceResize',
+                    # The radio of all image in train dataset < 7
+                    # follow the original implement
+                    scales=[(400, 4200), (500, 4200), (600, 4200)],
+                    keep_ratio=True),
+                dict(
+                    type='RandomCrop',
+                    crop_type='absolute_range',
+                    crop_size=(384, 600),
+                    allow_negative_crop=True),
+                dict(
+                    type='RandomChoiceResize',
+                    scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333),
+                            (608, 1333), (640, 1333), (672, 1333), (704, 1333),
+                            (736, 1333), (768, 1333), (800, 1333)],
+                    keep_ratio=True)
+            ]
+        ]),
+    dict(type='PackDetInputs')
+]
+
+train_dataloader = dict(
+    dataset=dict(
+        _delete_=True,
+        type=_base_.dataset_type,
+        data_root=_base_.data_root,
+        ann_file='annotations/instances_train2017.json',
+        data_prefix=dict(img='train2017/'),
+        filter_cfg=dict(filter_empty_gt=False, min_size=32),
+        pipeline=train_pipeline,
+        backend_args=_base_.backend_args))
+
+test_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=_base_.backend_args),
+    dict(type='Resize', scale=(1333, 800), keep_ratio=True),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(
+        type='PackDetInputs',
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+
+val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader
diff --git a/mmdetection/projects/CO-DETR/configs/codino/co_dino_5scale_r50_lsj_8xb2_1x_coco.py b/mmdetection/projects/CO-DETR/configs/codino/co_dino_5scale_r50_lsj_8xb2_1x_coco.py
new file mode 100644
index 00000000..876b90f8
--- /dev/null
+++ b/mmdetection/projects/CO-DETR/configs/codino/co_dino_5scale_r50_lsj_8xb2_1x_coco.py
@@ -0,0 +1,359 @@
+_base_ = 'mmdet::common/ssj_scp_270k_coco-instance.py'
+
+custom_imports = dict(
+    imports=['projects.CO-DETR.codetr'], allow_failed_imports=False)
+
+# model settings
+num_dec_layer = 6
+loss_lambda = 2.0
+num_classes = 80
+
+image_size = (1024, 1024)
+batch_augments = [
+    dict(type='BatchFixedSizePad', size=image_size, pad_mask=True)
+]
+model = dict(
+    type='CoDETR',
+    # If using the lsj augmentation,
+    # it is recommended to set it to True.
+    use_lsj=True,
+    # detr: 52.1
+    # one-stage: 49.4
+    # two-stage: 47.9
+    eval_module='detr',  # in ['detr', 'one-stage', 'two-stage']
+    data_preprocessor=dict(
+        type='DetDataPreprocessor',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        bgr_to_rgb=True,
+        pad_mask=True,
+        batch_augments=batch_augments),
+    backbone=dict(
+        type='ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type='BN', requires_grad=False),
+        norm_eval=True,
+        style='pytorch',
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),
+    neck=dict(
+        type='ChannelMapper',
+        in_channels=[256, 512, 1024, 2048],
+        kernel_size=1,
+        out_channels=256,
+        act_cfg=None,
+        norm_cfg=dict(type='GN', num_groups=32),
+        num_outs=5),
+    query_head=dict(
+        type='CoDINOHead',
+        num_query=900,
+        num_classes=num_classes,
+        in_channels=2048,
+        as_two_stage=True,
+        dn_cfg=dict(
+            label_noise_scale=0.5,
+            box_noise_scale=1.0,
+            group_cfg=dict(dynamic=True, num_groups=None, num_dn_queries=100)),
+        transformer=dict(
+            type='CoDinoTransformer',
+            with_coord_feat=False,
+            num_co_heads=2,  # ATSS Aux Head + Faster RCNN Aux Head
+            num_feature_levels=5,
+            encoder=dict(
+                type='DetrTransformerEncoder',
+                num_layers=6,
+                # number of layers that use checkpoint.
+                # The maximum value for the setting is num_layers.
+                # FairScale must be installed for it to work.
+                with_cp=4,
+                transformerlayers=dict(
+                    type='BaseTransformerLayer',
+                    attn_cfgs=dict(
+                        type='MultiScaleDeformableAttention',
+                        embed_dims=256,
+                        num_levels=5,
+                        dropout=0.0),
+                    feedforward_channels=2048,
+                    ffn_dropout=0.0,
+                    operation_order=('self_attn', 'norm', 'ffn', 'norm'))),
+            decoder=dict(
+                type='DinoTransformerDecoder',
+                num_layers=6,
+                return_intermediate=True,
+                transformerlayers=dict(
+                    type='DetrTransformerDecoderLayer',
+                    attn_cfgs=[
+                        dict(
+                            type='MultiheadAttention',
+                            embed_dims=256,
+                            num_heads=8,
+                            dropout=0.0),
+                        dict(
+                            type='MultiScaleDeformableAttention',
+                            embed_dims=256,
+                            num_levels=5,
+                            dropout=0.0),
+                    ],
+                    feedforward_channels=2048,
+                    ffn_dropout=0.0,
+                    operation_order=('self_attn', 'norm', 'cross_attn', 'norm',
+                                     'ffn', 'norm')))),
+        positional_encoding=dict(
+            type='SinePositionalEncoding',
+            num_feats=128,
+            temperature=20,
+            normalize=True),
+        loss_cls=dict(  # Different from the DINO
+            type='QualityFocalLoss',
+            use_sigmoid=True,
+            beta=2.0,
+            loss_weight=1.0),
+        loss_bbox=dict(type='L1Loss', loss_weight=5.0),
+        loss_iou=dict(type='GIoULoss', loss_weight=2.0)),
+    rpn_head=dict(
+        type='RPNHead',
+        in_channels=256,
+        feat_channels=256,
+        anchor_generator=dict(
+            type='AnchorGenerator',
+            octave_base_scale=4,
+            scales_per_octave=3,
+            ratios=[0.5, 1.0, 2.0],
+            strides=[4, 8, 16, 32, 64, 128]),
+        bbox_coder=dict(
+            type='DeltaXYWHBBoxCoder',
+            target_means=[.0, .0, .0, .0],
+            target_stds=[1.0, 1.0, 1.0, 1.0]),
+        loss_cls=dict(
+            type='CrossEntropyLoss',
+            use_sigmoid=True,
+            loss_weight=1.0 * num_dec_layer * loss_lambda),
+        loss_bbox=dict(
+            type='L1Loss', loss_weight=1.0 * num_dec_layer * loss_lambda)),
+    roi_head=[
+        dict(
+            type='CoStandardRoIHead',
+            bbox_roi_extractor=dict(
+                type='SingleRoIExtractor',
+                roi_layer=dict(
+                    type='RoIAlign', output_size=7, sampling_ratio=0),
+                out_channels=256,
+                featmap_strides=[4, 8, 16, 32, 64],
+                finest_scale=56),
+            bbox_head=dict(
+                type='Shared2FCBBoxHead',
+                in_channels=256,
+                fc_out_channels=1024,
+                roi_feat_size=7,
+                num_classes=num_classes,
+                bbox_coder=dict(
+                    type='DeltaXYWHBBoxCoder',
+                    target_means=[0., 0., 0., 0.],
+                    target_stds=[0.1, 0.1, 0.2, 0.2]),
+                reg_class_agnostic=False,
+                reg_decoded_bbox=True,
+                loss_cls=dict(
+                    type='CrossEntropyLoss',
+                    use_sigmoid=False,
+                    loss_weight=1.0 * num_dec_layer * loss_lambda),
+                loss_bbox=dict(
+                    type='GIoULoss',
+                    loss_weight=10.0 * num_dec_layer * loss_lambda)))
+    ],
+    bbox_head=[
+        dict(
+            type='CoATSSHead',
+            num_classes=num_classes,
+            in_channels=256,
+            stacked_convs=1,
+            feat_channels=256,
+            anchor_generator=dict(
+                type='AnchorGenerator',
+                ratios=[1.0],
+                octave_base_scale=8,
+                scales_per_octave=1,
+                strides=[4, 8, 16, 32, 64, 128]),
+            bbox_coder=dict(
+                type='DeltaXYWHBBoxCoder',
+                target_means=[.0, .0, .0, .0],
+                target_stds=[0.1, 0.1, 0.2, 0.2]),
+            loss_cls=dict(
+                type='FocalLoss',
+                use_sigmoid=True,
+                gamma=2.0,
+                alpha=0.25,
+                loss_weight=1.0 * num_dec_layer * loss_lambda),
+            loss_bbox=dict(
+                type='GIoULoss',
+                loss_weight=2.0 * num_dec_layer * loss_lambda),
+            loss_centerness=dict(
+                type='CrossEntropyLoss',
+                use_sigmoid=True,
+                loss_weight=1.0 * num_dec_layer * loss_lambda)),
+    ],
+    # model training and testing settings
+    train_cfg=[
+        dict(
+            assigner=dict(
+                type='HungarianAssigner',
+                match_costs=[
+                    dict(type='FocalLossCost', weight=2.0),
+                    dict(type='BBoxL1Cost', weight=5.0, box_format='xywh'),
+                    dict(type='IoUCost', iou_mode='giou', weight=2.0)
+                ])),
+        dict(
+            rpn=dict(
+                assigner=dict(
+                    type='MaxIoUAssigner',
+                    pos_iou_thr=0.7,
+                    neg_iou_thr=0.3,
+                    min_pos_iou=0.3,
+                    match_low_quality=True,
+                    ignore_iof_thr=-1),
+                sampler=dict(
+                    type='RandomSampler',
+                    num=256,
+                    pos_fraction=0.5,
+                    neg_pos_ub=-1,
+                    add_gt_as_proposals=False),
+                allowed_border=-1,
+                pos_weight=-1,
+                debug=False),
+            rpn_proposal=dict(
+                nms_pre=4000,
+                max_per_img=1000,
+                nms=dict(type='nms', iou_threshold=0.7),
+                min_bbox_size=0),
+            rcnn=dict(
+                assigner=dict(
+                    type='MaxIoUAssigner',
+                    pos_iou_thr=0.5,
+                    neg_iou_thr=0.5,
+                    min_pos_iou=0.5,
+                    match_low_quality=False,
+                    ignore_iof_thr=-1),
+                sampler=dict(
+                    type='RandomSampler',
+                    num=512,
+                    pos_fraction=0.25,
+                    neg_pos_ub=-1,
+                    add_gt_as_proposals=True),
+                pos_weight=-1,
+                debug=False)),
+        dict(
+            assigner=dict(type='ATSSAssigner', topk=9),
+            allowed_border=-1,
+            pos_weight=-1,
+            debug=False)
+    ],
+    test_cfg=[
+        # Deferent from the DINO, we use the NMS.
+        dict(
+            max_per_img=300,
+            # NMS can improve the mAP by 0.2.
+            nms=dict(type='soft_nms', iou_threshold=0.8)),
+        dict(
+            rpn=dict(
+                nms_pre=1000,
+                max_per_img=1000,
+                nms=dict(type='nms', iou_threshold=0.7),
+                min_bbox_size=0),
+            rcnn=dict(
+                score_thr=0.0,
+                nms=dict(type='nms', iou_threshold=0.5),
+                max_per_img=100)),
+        dict(
+            # atss bbox head:
+            nms_pre=1000,
+            min_bbox_size=0,
+            score_thr=0.0,
+            nms=dict(type='nms', iou_threshold=0.6),
+            max_per_img=100),
+        # soft-nms is also supported for rcnn testing
+        # e.g., nms=dict(type='soft_nms', iou_threshold=0.5, min_score=0.05)
+    ])
+
+# LSJ + CopyPaste
+load_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
+    dict(
+        type='RandomResize',
+        scale=image_size,
+        ratio_range=(0.1, 2.0),
+        keep_ratio=True),
+    dict(
+        type='RandomCrop',
+        crop_type='absolute_range',
+        crop_size=image_size,
+        recompute_bbox=True,
+        allow_negative_crop=True),
+    dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='Pad', size=image_size, pad_val=dict(img=(114, 114, 114))),
+]
+
+train_pipeline = [
+    dict(type='CopyPaste', max_num_pasted=100),
+    dict(type='PackDetInputs')
+]
+
+train_dataloader = dict(
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    dataset=dict(
+        pipeline=train_pipeline,
+        dataset=dict(
+            filter_cfg=dict(filter_empty_gt=False), pipeline=load_pipeline)))
+
+# follow ViTDet
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=image_size, keep_ratio=True),  # diff
+    dict(type='Pad', size=image_size, pad_val=dict(img=(114, 114, 114))),
+    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
+    dict(
+        type='PackDetInputs',
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+
+val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(type='AdamW', lr=2e-4, weight_decay=0.0001),
+    clip_grad=dict(max_norm=0.1, norm_type=2),
+    paramwise_cfg=dict(custom_keys={'backbone': dict(lr_mult=0.1)}))
+
+val_evaluator = dict(metric='bbox')
+test_evaluator = val_evaluator
+
+max_epochs = 12
+train_cfg = dict(
+    _delete_=True,
+    type='EpochBasedTrainLoop',
+    max_epochs=max_epochs,
+    val_interval=1)
+
+param_scheduler = [
+    dict(
+        type='MultiStepLR',
+        begin=0,
+        end=max_epochs,
+        by_epoch=True,
+        milestones=[11],
+        gamma=0.1)
+]
+
+default_hooks = dict(
+    checkpoint=dict(by_epoch=True, interval=1, max_keep_ckpts=3))
+log_processor = dict(by_epoch=True)
+
+# NOTE: `auto_scale_lr` is for automatically scaling LR,
+# USER SHOULD NOT CHANGE ITS VALUES.
+# base_batch_size = (8 GPUs) x (2 samples per GPU)
+auto_scale_lr = dict(base_batch_size=16)
diff --git a/mmdetection/projects/CO-DETR/configs/codino/co_dino_5scale_r50_lsj_8xb2_3x_coco.py b/mmdetection/projects/CO-DETR/configs/codino/co_dino_5scale_r50_lsj_8xb2_3x_coco.py
new file mode 100644
index 00000000..9a9fc34f
--- /dev/null
+++ b/mmdetection/projects/CO-DETR/configs/codino/co_dino_5scale_r50_lsj_8xb2_3x_coco.py
@@ -0,0 +1,4 @@
+_base_ = ['co_dino_5scale_r50_lsj_8xb2_1x_coco.py']
+
+param_scheduler = [dict(milestones=[30])]
+train_cfg = dict(max_epochs=36)
diff --git a/mmdetection/projects/CO-DETR/configs/codino/co_dino_5scale_swin_l_16xb1_16e_o365tococo.py b/mmdetection/projects/CO-DETR/configs/codino/co_dino_5scale_swin_l_16xb1_16e_o365tococo.py
new file mode 100644
index 00000000..77821c38
--- /dev/null
+++ b/mmdetection/projects/CO-DETR/configs/codino/co_dino_5scale_swin_l_16xb1_16e_o365tococo.py
@@ -0,0 +1,115 @@
+_base_ = ['co_dino_5scale_r50_8xb2_1x_coco.py']
+
+pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_large_patch4_window12_384_22k.pth'  # noqa
+load_from = 'https://download.openmmlab.com/mmdetection/v3.0/codetr/co_dino_5scale_swin_large_16e_o365tococo-614254c9.pth'  # noqa
+
+# model settings
+model = dict(
+    backbone=dict(
+        _delete_=True,
+        type='SwinTransformer',
+        pretrain_img_size=384,
+        embed_dims=192,
+        depths=[2, 2, 18, 2],
+        num_heads=[6, 12, 24, 48],
+        window_size=12,
+        mlp_ratio=4,
+        qkv_bias=True,
+        qk_scale=None,
+        drop_rate=0.,
+        attn_drop_rate=0.,
+        drop_path_rate=0.3,
+        patch_norm=True,
+        out_indices=(0, 1, 2, 3),
+        # Please only add indices that would be used
+        # in FPN, otherwise some parameter will not be used
+        with_cp=True,
+        convert_weights=True,
+        init_cfg=dict(type='Pretrained', checkpoint=pretrained)),
+    neck=dict(in_channels=[192, 384, 768, 1536]),
+    query_head=dict(
+        dn_cfg=dict(box_noise_scale=0.4, group_cfg=dict(num_dn_queries=500)),
+        transformer=dict(encoder=dict(with_cp=6))))
+
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(
+        type='RandomChoice',
+        transforms=[
+            [
+                dict(
+                    type='RandomChoiceResize',
+                    scales=[(480, 2048), (512, 2048), (544, 2048), (576, 2048),
+                            (608, 2048), (640, 2048), (672, 2048), (704, 2048),
+                            (736, 2048), (768, 2048), (800, 2048), (832, 2048),
+                            (864, 2048), (896, 2048), (928, 2048), (960, 2048),
+                            (992, 2048), (1024, 2048), (1056, 2048),
+                            (1088, 2048), (1120, 2048), (1152, 2048),
+                            (1184, 2048), (1216, 2048), (1248, 2048),
+                            (1280, 2048), (1312, 2048), (1344, 2048),
+                            (1376, 2048), (1408, 2048), (1440, 2048),
+                            (1472, 2048), (1504, 2048), (1536, 2048)],
+                    keep_ratio=True)
+            ],
+            [
+                dict(
+                    type='RandomChoiceResize',
+                    # The radio of all image in train dataset < 7
+                    # follow the original implement
+                    scales=[(400, 4200), (500, 4200), (600, 4200)],
+                    keep_ratio=True),
+                dict(
+                    type='RandomCrop',
+                    crop_type='absolute_range',
+                    crop_size=(384, 600),
+                    allow_negative_crop=True),
+                dict(
+                    type='RandomChoiceResize',
+                    scales=[(480, 2048), (512, 2048), (544, 2048), (576, 2048),
+                            (608, 2048), (640, 2048), (672, 2048), (704, 2048),
+                            (736, 2048), (768, 2048), (800, 2048), (832, 2048),
+                            (864, 2048), (896, 2048), (928, 2048), (960, 2048),
+                            (992, 2048), (1024, 2048), (1056, 2048),
+                            (1088, 2048), (1120, 2048), (1152, 2048),
+                            (1184, 2048), (1216, 2048), (1248, 2048),
+                            (1280, 2048), (1312, 2048), (1344, 2048),
+                            (1376, 2048), (1408, 2048), (1440, 2048),
+                            (1472, 2048), (1504, 2048), (1536, 2048)],
+                    keep_ratio=True)
+            ]
+        ]),
+    dict(type='PackDetInputs')
+]
+
+train_dataloader = dict(
+    batch_size=1, num_workers=1, dataset=dict(pipeline=train_pipeline))
+
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 1280), keep_ratio=True),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(
+        type='PackDetInputs',
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+
+val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+optim_wrapper = dict(optimizer=dict(lr=1e-4))
+
+max_epochs = 16
+train_cfg = dict(max_epochs=max_epochs)
+
+param_scheduler = [
+    dict(
+        type='MultiStepLR',
+        begin=0,
+        end=max_epochs,
+        by_epoch=True,
+        milestones=[8],
+        gamma=0.1)
+]
diff --git a/mmdetection/projects/CO-DETR/configs/codino/co_dino_5scale_swin_l_16xb1_1x_coco.py b/mmdetection/projects/CO-DETR/configs/codino/co_dino_5scale_swin_l_16xb1_1x_coco.py
new file mode 100644
index 00000000..d4a87346
--- /dev/null
+++ b/mmdetection/projects/CO-DETR/configs/codino/co_dino_5scale_swin_l_16xb1_1x_coco.py
@@ -0,0 +1,31 @@
+_base_ = ['co_dino_5scale_r50_8xb2_1x_coco.py']
+
+pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_large_patch4_window12_384_22k.pth'  # noqa
+
+# model settings
+model = dict(
+    backbone=dict(
+        _delete_=True,
+        type='SwinTransformer',
+        pretrain_img_size=384,
+        embed_dims=192,
+        depths=[2, 2, 18, 2],
+        num_heads=[6, 12, 24, 48],
+        window_size=12,
+        mlp_ratio=4,
+        qkv_bias=True,
+        qk_scale=None,
+        drop_rate=0.,
+        attn_drop_rate=0.,
+        drop_path_rate=0.3,
+        patch_norm=True,
+        out_indices=(0, 1, 2, 3),
+        # Please only add indices that would be used
+        # in FPN, otherwise some parameter will not be used
+        with_cp=False,
+        convert_weights=True,
+        init_cfg=dict(type='Pretrained', checkpoint=pretrained)),
+    neck=dict(in_channels=[192, 384, 768, 1536]),
+    query_head=dict(transformer=dict(encoder=dict(with_cp=6))))
+
+train_dataloader = dict(batch_size=1, num_workers=1)
diff --git a/mmdetection/projects/CO-DETR/configs/codino/co_dino_5scale_swin_l_16xb1_3x_coco.py b/mmdetection/projects/CO-DETR/configs/codino/co_dino_5scale_swin_l_16xb1_3x_coco.py
new file mode 100644
index 00000000..c2fce29b
--- /dev/null
+++ b/mmdetection/projects/CO-DETR/configs/codino/co_dino_5scale_swin_l_16xb1_3x_coco.py
@@ -0,0 +1,6 @@
+_base_ = ['co_dino_5scale_swin_l_16xb1_1x_coco.py']
+# model settings
+model = dict(backbone=dict(drop_path_rate=0.6))
+
+param_scheduler = [dict(milestones=[30])]
+train_cfg = dict(max_epochs=36)
diff --git a/mmdetection/projects/CO-DETR/configs/codino/co_dino_5scale_swin_l_lsj_16xb1_1x_coco.py b/mmdetection/projects/CO-DETR/configs/codino/co_dino_5scale_swin_l_lsj_16xb1_1x_coco.py
new file mode 100644
index 00000000..4a9b3688
--- /dev/null
+++ b/mmdetection/projects/CO-DETR/configs/codino/co_dino_5scale_swin_l_lsj_16xb1_1x_coco.py
@@ -0,0 +1,72 @@
+_base_ = ['co_dino_5scale_r50_lsj_8xb2_1x_coco.py']
+
+image_size = (1280, 1280)
+batch_augments = [
+    dict(type='BatchFixedSizePad', size=image_size, pad_mask=True)
+]
+pretrained = 'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_large_patch4_window12_384_22k.pth'  # noqa
+
+# model settings
+model = dict(
+    data_preprocessor=dict(batch_augments=batch_augments),
+    backbone=dict(
+        _delete_=True,
+        type='SwinTransformer',
+        pretrain_img_size=384,
+        embed_dims=192,
+        depths=[2, 2, 18, 2],
+        num_heads=[6, 12, 24, 48],
+        window_size=12,
+        mlp_ratio=4,
+        qkv_bias=True,
+        qk_scale=None,
+        drop_rate=0.,
+        attn_drop_rate=0.,
+        drop_path_rate=0.3,
+        patch_norm=True,
+        out_indices=(0, 1, 2, 3),
+        # Please only add indices that would be used
+        # in FPN, otherwise some parameter will not be used
+        with_cp=False,
+        convert_weights=True,
+        init_cfg=dict(type='Pretrained', checkpoint=pretrained)),
+    neck=dict(in_channels=[192, 384, 768, 1536]),
+    query_head=dict(transformer=dict(encoder=dict(with_cp=6))))
+
+load_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
+    dict(
+        type='RandomResize',
+        scale=image_size,
+        ratio_range=(0.1, 2.0),
+        keep_ratio=True),
+    dict(
+        type='RandomCrop',
+        crop_type='absolute_range',
+        crop_size=image_size,
+        recompute_bbox=True,
+        allow_negative_crop=True),
+    dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='Pad', size=image_size, pad_val=dict(img=(114, 114, 114))),
+]
+
+train_dataloader = dict(
+    batch_size=1,
+    num_workers=1,
+    dataset=dict(dataset=dict(pipeline=load_pipeline)))
+
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=image_size, keep_ratio=True),
+    dict(type='Pad', size=image_size, pad_val=dict(img=(114, 114, 114))),
+    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
+    dict(
+        type='PackDetInputs',
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+
+val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader
diff --git a/mmdetection/projects/CO-DETR/configs/codino/co_dino_5scale_swin_l_lsj_16xb1_3x_coco.py b/mmdetection/projects/CO-DETR/configs/codino/co_dino_5scale_swin_l_lsj_16xb1_3x_coco.py
new file mode 100644
index 00000000..bf9cd4f4
--- /dev/null
+++ b/mmdetection/projects/CO-DETR/configs/codino/co_dino_5scale_swin_l_lsj_16xb1_3x_coco.py
@@ -0,0 +1,7 @@
+_base_ = ['co_dino_5scale_swin_l_lsj_16xb1_1x_coco.py']
+
+model = dict(backbone=dict(drop_path_rate=0.5))
+
+param_scheduler = [dict(type='MultiStepLR', milestones=[30])]
+
+train_cfg = dict(max_epochs=36)
diff --git a/mmdetection/projects/ConvNeXt-V2/README.md b/mmdetection/projects/ConvNeXt-V2/README.md
new file mode 100644
index 00000000..7a9f56cd
--- /dev/null
+++ b/mmdetection/projects/ConvNeXt-V2/README.md
@@ -0,0 +1,37 @@
+# ConvNeXt-V2
+
+> [ConvNeXt V2: Co-designing and Scaling ConvNets with Masked Autoencoders](http://arxiv.org/abs/2301.00808)
+
+## Abstract
+
+Driven by improved architectures and better representation learning frameworks, the field of visual recognition has enjoyed rapid modernization and performance boost in the early 2020s. For example, modern ConvNets, represented by ConvNeXt \[52\], have demonstrated strong performance in various scenarios. While these models were originally designed for supervised learning with ImageNet labels, they can also potentially benefit from self-supervised learning techniques such as masked autoencoders (MAE) . However, we found that simply combining these two approaches leads to subpar performance. In this paper, we propose a fully convolutional masked autoencoder framework and a new Global Response Normalization (GRN) layer that can be added to the ConvNeXt architecture to enhance inter-channel feature competition. This co-design of self-supervised learning techniques and architectural improvement results in a new model family called ConvNeXt V2, which significantly improves the performance of pure ConvNets on various recognition benchmarks, including ImageNet classification, COCO detection, and ADE20K segmentation. We also provide pre-trained ConvNeXt V2 models of various sizes, ranging from an efficient 3.7Mparameter Atto model with 76.7% top-1 accuracy on Im-ageNet, to a 650M Huge model that achieves a state-of-theart 88.9% accuracy using only public training data.
+
+
    
+
+
    
+
+## Results and models
+
+|   Method   |   Backbone    | Pretrain | Lr schd | Augmentation | Mem (GB) | box AP | mask AP |                            Config                            |                                                                                                                                                                                        Download                                                                                                                                                                                         |
+| :--------: | :-----------: | :------: | :-----: | :----------: | :------: | :----: | :-----: | :----------------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+| Mask R-CNN | ConvNeXt-V2-B |  FCMAE   |   3x    |     LSJ      |   22.5   |  52.9  |  46.4   | [config](./mask-rcnn_convnext-v2-b_fpn_lsj-3x-fcmae_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/convnextv2/mask-rcnn_convnext-v2-b_fpn_lsj-3x-fcmae_coco/mask-rcnn_convnext-v2-b_fpn_lsj-3x-fcmae_coco_20230113_110947-757ee2dd.pth)  \| [log](https://download.openmmlab.com/mmdetection/v3.0/convnextv2/mask-rcnn_convnext-v2-b_fpn_lsj-3x-fcmae_coco/mask-rcnn_convnext-v2-b_fpn_lsj-3x-fcmae_coco_20230113_110947.log.json) |
+
+**Note**:
+
+- This is a pre-release version of ConvNeXt-V2 object detection. The official finetuning setting of ConvNeXt-V2 has not been released yet.
+- ConvNeXt backbone needs to install [MMPretrain](https://github.com/open-mmlab/mmpretrain/) first, which has abundant backbones for downstream tasks.
+
+```shell
+pip install mmpretrain
+```
+
+## Citation
+
+```bibtex
+@article{Woo2023ConvNeXtV2,
+  title={ConvNeXt V2: Co-designing and Scaling ConvNets with Masked Autoencoders},
+  author={Sanghyun Woo, Shoubhik Debnath, Ronghang Hu, Xinlei Chen, Zhuang Liu, In So Kweon and Saining Xie},
+  year={2023},
+  journal={arXiv preprint arXiv:2301.00808},
+}
+```
diff --git a/mmdetection/projects/ConvNeXt-V2/configs/mask-rcnn_convnext-v2-b_fpn_lsj-3x-fcmae_coco.py b/mmdetection/projects/ConvNeXt-V2/configs/mask-rcnn_convnext-v2-b_fpn_lsj-3x-fcmae_coco.py
new file mode 100644
index 00000000..59e89550
--- /dev/null
+++ b/mmdetection/projects/ConvNeXt-V2/configs/mask-rcnn_convnext-v2-b_fpn_lsj-3x-fcmae_coco.py
@@ -0,0 +1,92 @@
+_base_ = [
+    'mmdet::_base_/models/mask-rcnn_r50_fpn.py',
+    'mmdet::_base_/datasets/coco_instance.py',
+    'mmdet::_base_/schedules/schedule_1x.py',
+    'mmdet::_base_/default_runtime.py'
+]
+
+# please install the mmpretrain
+# import mmpretrain.models to trigger register_module in mmpretrain
+custom_imports = dict(
+    imports=['mmpretrain.models'], allow_failed_imports=False)
+checkpoint_file = 'https://download.openmmlab.com/mmclassification/v0/convnext-v2/convnext-v2-base_3rdparty-fcmae_in1k_20230104-8a798eaf.pth'  # noqa
+image_size = (1024, 1024)
+
+model = dict(
+    backbone=dict(
+        _delete_=True,
+        type='mmpretrain.ConvNeXt',
+        arch='base',
+        out_indices=[0, 1, 2, 3],
+        # TODO: verify stochastic depth rate {0.1, 0.2, 0.3, 0.4}
+        drop_path_rate=0.4,
+        layer_scale_init_value=0.,  # disable layer scale when using GRN
+        gap_before_final_norm=False,
+        use_grn=True,  # V2 uses GRN
+        init_cfg=dict(
+            type='Pretrained', checkpoint=checkpoint_file,
+            prefix='backbone.')),
+    neck=dict(in_channels=[128, 256, 512, 1024]),
+    test_cfg=dict(
+        rpn=dict(nms=dict(type='nms')),  # TODO: does RPN use soft_nms?
+        rcnn=dict(nms=dict(type='soft_nms'))))
+
+train_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=_base_.backend_args),
+    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
+    dict(
+        type='RandomResize',
+        scale=image_size,
+        ratio_range=(0.1, 2.0),
+        keep_ratio=True),
+    dict(
+        type='RandomCrop',
+        crop_type='absolute_range',
+        crop_size=image_size,
+        recompute_bbox=True,
+        allow_negative_crop=True),
+    dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs')
+]
+
+train_dataloader = dict(
+    batch_size=4,  # total_batch_size 32 = 8 GPUS x 4 images
+    num_workers=8,
+    dataset=dict(pipeline=train_pipeline))
+
+max_epochs = 36
+train_cfg = dict(max_epochs=max_epochs)
+
+# learning rate
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0,
+        end=1000),
+    dict(
+        type='MultiStepLR',
+        begin=0,
+        end=max_epochs,
+        by_epoch=True,
+        milestones=[27, 33],
+        gamma=0.1)
+]
+
+# Enable automatic-mixed-precision training with AmpOptimWrapper.
+optim_wrapper = dict(
+    type='AmpOptimWrapper',
+    constructor='LearningRateDecayOptimizerConstructor',
+    paramwise_cfg={
+        'decay_rate': 0.95,
+        'decay_type': 'layer_wise',  # TODO: sweep layer-wise lr decay?
+        'num_layers': 12
+    },
+    optimizer=dict(
+        _delete_=True,
+        type='AdamW',
+        lr=0.0001,
+        betas=(0.9, 0.999),
+        weight_decay=0.05,
+    ))
+
+default_hooks = dict(checkpoint=dict(max_keep_ckpts=1))
diff --git a/mmdetection/projects/Detic/README.md b/mmdetection/projects/Detic/README.md
new file mode 100644
index 00000000..98cd705b
--- /dev/null
+++ b/mmdetection/projects/Detic/README.md
@@ -0,0 +1,156 @@
+# Note: This project has been deprecated, please use [Detic_new](../Detic_new).
+
+# Detecting Twenty-thousand Classes using Image-level Supervision
+
+## Description
+
+**Detic**: A **Det**ector with **i**mage **c**lasses that can use image-level labels to easily train detectors.
+
+
      
    
+
+> [**Detecting Twenty-thousand Classes using Image-level Supervision**](http://arxiv.org/abs/2201.02605),
+> Xingyi Zhou, Rohit Girdhar, Armand Joulin, Philipp Krähenbühl, Ishan Misra,
+> *ECCV 2022 ([arXiv 2201.02605](http://arxiv.org/abs/2201.02605))*
+
+## Usage
+
+
+
+## Installation
+
+Detic requires to install CLIP.
+
+```shell
+pip install git+https://github.com/openai/CLIP.git
+```
+
+### Demo
+
+#### Inference with existing dataset vocabulary embeddings
+
+First, go to the Detic project folder.
+
+```shell
+cd projects/Detic
+```
+
+Then, download the pre-computed CLIP embeddings from [dataset metainfo](https://github.com/facebookresearch/Detic/tree/main/datasets/metadata) to the `datasets/metadata` folder.
+The CLIP embeddings will be loaded to the zero-shot classifier during inference.
+For example, you can download LVIS's class name embeddings with the following command:
+
+```shell
+wget -P datasets/metadata https://raw.githubusercontent.com/facebookresearch/Detic/main/datasets/metadata/lvis_v1_clip_a%2Bcname.npy
+```
+
+You can run demo like this:
+
+```shell
+python demo.py \
+  ${IMAGE_PATH} \
+  ${CONFIG_PATH} \
+  ${MODEL_PATH} \
+  --show \
+  --score-thr 0.5 \
+  --dataset lvis
+```
+
+![image](https://user-images.githubusercontent.com/12907710/213624759-f0a2ba0c-0f5c-4424-a350-5ba5349e5842.png)
+
+### Inference with custom vocabularies
+
+- Detic can detects any class given class names by using CLIP.
+
+You can detect custom classes with `--class-name` command:
+
+```
+python demo.py \
+  ${IMAGE_PATH} \
+  ${CONFIG_PATH} \
+  ${MODEL_PATH} \
+  --show \
+  --score-thr 0.3 \
+  --class-name headphone webcam paper coffe
+```
+
+![image](https://user-images.githubusercontent.com/12907710/213624637-e9e8a313-9821-4782-a18a-4408c876852b.png)
+
+Note that `headphone`, `paper` and `coffe` (typo intended) are not LVIS classes. Despite the misspelled class name, Detic can produce a reasonable detection for `coffe`.
+
+## Results
+
+Here we only provide the Detic Swin-B model for the open vocabulary demo. Multi-dataset training and open-vocabulary testing will be supported in the future.
+
+To find more variants, please visit the [official model zoo](https://github.com/facebookresearch/Detic/blob/main/docs/MODEL_ZOO.md).
+
+| Backbone |       Training data        |                                Config                                 |                                                                                      Download                                                                                      |
+| :------: | :------------------------: | :-------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+|  Swin-B  | ImageNet-21K & LVIS & COCO | [config](./configs/detic_centernet2_swin-b_fpn_4x_lvis-coco-in21k.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/detic/detic_centernet2_swin-b_fpn_4x_lvis-coco-in21k/detic_centernet2_swin-b_fpn_4x_lvis-coco-in21k_20230120-0d301978.pth) |
+
+## Citation
+
+If you find Detic is useful in your research or applications, please consider giving a star 🌟 to the [official repository](https://github.com/facebookresearch/Detic) and citing Detic by the following BibTeX entry.
+
+```BibTeX
+@inproceedings{zhou2022detecting,
+  title={Detecting Twenty-thousand Classes using Image-level Supervision},
+  author={Zhou, Xingyi and Girdhar, Rohit and Joulin, Armand and Kr{\"a}henb{\"u}hl, Philipp and Misra, Ishan},
+  booktitle={ECCV},
+  year={2022}
+}
+
+```
+
+## Checklist
+
+
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+
+    
+
+  - [x] Basic docstrings & proper citation
+
+    
+
+  - [x] Test-time correctness
+
+    
+
+  - [x] A full README
+
+    
+
+- [ ] Milestone 2: Indicates a successful model implementation.
+
+  - [ ] Training-time correctness
+
+    
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+
+    
+
+  - [ ] Unit tests
+
+    
+
+  - [ ] Code polishing
+
+    
+
+  - [ ] Metafile.yml
+
+    
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+  
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmdetection/projects/Detic/configs/detic_centernet2_swin-b_fpn_4x_lvis-coco-in21k.py b/mmdetection/projects/Detic/configs/detic_centernet2_swin-b_fpn_4x_lvis-coco-in21k.py
new file mode 100644
index 00000000..d554c40e
--- /dev/null
+++ b/mmdetection/projects/Detic/configs/detic_centernet2_swin-b_fpn_4x_lvis-coco-in21k.py
@@ -0,0 +1,298 @@
+_base_ = 'mmdet::common/lsj-200e_coco-detection.py'
+
+custom_imports = dict(
+    imports=['projects.Detic.detic'], allow_failed_imports=False)
+
+image_size = (1024, 1024)
+batch_augments = [dict(type='BatchFixedSizePad', size=image_size)]
+
+cls_layer = dict(
+    type='ZeroShotClassifier',
+    zs_weight_path='rand',
+    zs_weight_dim=512,
+    use_bias=0.0,
+    norm_weight=True,
+    norm_temperature=50.0)
+reg_layer = [
+    dict(type='Linear', in_features=1024, out_features=1024),
+    dict(type='ReLU', inplace=True),
+    dict(type='Linear', in_features=1024, out_features=4)
+]
+
+num_classes = 22047
+
+model = dict(
+    type='CascadeRCNN',
+    data_preprocessor=dict(
+        type='DetDataPreprocessor',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        bgr_to_rgb=True,
+        pad_size_divisor=32,
+        batch_augments=batch_augments),
+    backbone=dict(
+        type='SwinTransformer',
+        embed_dims=128,
+        depths=[2, 2, 18, 2],
+        num_heads=[4, 8, 16, 32],
+        window_size=7,
+        mlp_ratio=4,
+        qkv_bias=True,
+        qk_scale=None,
+        drop_rate=0.,
+        attn_drop_rate=0.,
+        drop_path_rate=0.3,
+        patch_norm=True,
+        out_indices=(1, 2, 3),
+        with_cp=False),
+    neck=dict(
+        type='FPN',
+        in_channels=[256, 512, 1024],
+        out_channels=256,
+        start_level=0,
+        add_extra_convs='on_output',
+        num_outs=5,
+        init_cfg=dict(type='Caffe2Xavier', layer='Conv2d'),
+        relu_before_extra_convs=True),
+    rpn_head=dict(
+        type='CenterNetRPNHead',
+        num_classes=1,
+        in_channels=256,
+        stacked_convs=4,
+        feat_channels=256,
+        strides=[8, 16, 32, 64, 128],
+        conv_bias=True,
+        norm_cfg=dict(type='GN', num_groups=32, requires_grad=True),
+        loss_cls=dict(
+            type='GaussianFocalLoss',
+            pos_weight=0.25,
+            neg_weight=0.75,
+            loss_weight=1.0),
+        loss_bbox=dict(type='GIoULoss', loss_weight=2.0),
+    ),
+    roi_head=dict(
+        type='DeticRoIHead',
+        num_stages=3,
+        stage_loss_weights=[1, 0.5, 0.25],
+        bbox_roi_extractor=dict(
+            type='SingleRoIExtractor',
+            roi_layer=dict(
+                type='RoIAlign',
+                output_size=7,
+                sampling_ratio=0,
+                use_torchvision=True),
+            out_channels=256,
+            featmap_strides=[8, 16, 32],
+            # approximately equal to
+            # canonical_box_size=224, canonical_level=4 in D2
+            finest_scale=112),
+        bbox_head=[
+            dict(
+                type='DeticBBoxHead',
+                in_channels=256,
+                fc_out_channels=1024,
+                roi_feat_size=7,
+                num_classes=num_classes,
+                cls_predictor_cfg=cls_layer,
+                reg_predictor_cfg=reg_layer,
+                bbox_coder=dict(
+                    type='DeltaXYWHBBoxCoder',
+                    target_means=[0., 0., 0., 0.],
+                    target_stds=[0.1, 0.1, 0.2, 0.2]),
+                reg_class_agnostic=True,
+                loss_cls=dict(
+                    type='CrossEntropyLoss', use_sigmoid=True,
+                    loss_weight=1.0),
+                loss_bbox=dict(type='SmoothL1Loss', beta=1.0,
+                               loss_weight=1.0)),
+            dict(
+                type='DeticBBoxHead',
+                in_channels=256,
+                fc_out_channels=1024,
+                roi_feat_size=7,
+                num_classes=num_classes,
+                cls_predictor_cfg=cls_layer,
+                reg_predictor_cfg=reg_layer,
+                bbox_coder=dict(
+                    type='DeltaXYWHBBoxCoder',
+                    target_means=[0., 0., 0., 0.],
+                    target_stds=[0.05, 0.05, 0.1, 0.1]),
+                reg_class_agnostic=True,
+                loss_cls=dict(
+                    type='CrossEntropyLoss', use_sigmoid=True,
+                    loss_weight=1.0),
+                loss_bbox=dict(type='SmoothL1Loss', beta=1.0,
+                               loss_weight=1.0)),
+            dict(
+                type='DeticBBoxHead',
+                in_channels=256,
+                fc_out_channels=1024,
+                roi_feat_size=7,
+                num_classes=num_classes,
+                cls_predictor_cfg=cls_layer,
+                reg_predictor_cfg=reg_layer,
+                bbox_coder=dict(
+                    type='DeltaXYWHBBoxCoder',
+                    target_means=[0., 0., 0., 0.],
+                    target_stds=[0.033, 0.033, 0.067, 0.067]),
+                reg_class_agnostic=True,
+                loss_cls=dict(
+                    type='CrossEntropyLoss', use_sigmoid=True,
+                    loss_weight=1.0),
+                loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0))
+        ],
+        mask_roi_extractor=dict(
+            type='SingleRoIExtractor',
+            roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0),
+            out_channels=256,
+            featmap_strides=[8, 16, 32],
+            # approximately equal to
+            # canonical_box_size=224, canonical_level=4 in D2
+            finest_scale=112),
+        mask_head=dict(
+            type='FCNMaskHead',
+            num_convs=4,
+            in_channels=256,
+            conv_out_channels=256,
+            class_agnostic=True,
+            num_classes=num_classes,
+            loss_mask=dict(
+                type='CrossEntropyLoss', use_mask=True, loss_weight=1.0))),
+    # model training and testing settings
+    train_cfg=dict(
+        rpn=dict(
+            assigner=dict(
+                type='MaxIoUAssigner',
+                pos_iou_thr=0.7,
+                neg_iou_thr=0.3,
+                min_pos_iou=0.3,
+                match_low_quality=True,
+                ignore_iof_thr=-1),
+            sampler=dict(
+                type='RandomSampler',
+                num=256,
+                pos_fraction=0.5,
+                neg_pos_ub=-1,
+                add_gt_as_proposals=False),
+            allowed_border=0,
+            pos_weight=-1,
+            debug=False),
+        rpn_proposal=dict(
+            nms_pre=2000,
+            max_per_img=2000,
+            nms=dict(type='nms', iou_threshold=0.7),
+            min_bbox_size=0),
+        rcnn=[
+            dict(
+                assigner=dict(
+                    type='MaxIoUAssigner',
+                    pos_iou_thr=0.6,
+                    neg_iou_thr=0.6,
+                    min_pos_iou=0.6,
+                    match_low_quality=False,
+                    ignore_iof_thr=-1),
+                sampler=dict(
+                    type='RandomSampler',
+                    num=512,
+                    pos_fraction=0.25,
+                    neg_pos_ub=-1,
+                    add_gt_as_proposals=True),
+                mask_size=28,
+                pos_weight=-1,
+                debug=False),
+            dict(
+                assigner=dict(
+                    type='MaxIoUAssigner',
+                    pos_iou_thr=0.7,
+                    neg_iou_thr=0.7,
+                    min_pos_iou=0.7,
+                    match_low_quality=False,
+                    ignore_iof_thr=-1),
+                sampler=dict(
+                    type='RandomSampler',
+                    num=512,
+                    pos_fraction=0.25,
+                    neg_pos_ub=-1,
+                    add_gt_as_proposals=True),
+                mask_size=28,
+                pos_weight=-1,
+                debug=False),
+            dict(
+                assigner=dict(
+                    type='MaxIoUAssigner',
+                    pos_iou_thr=0.8,
+                    neg_iou_thr=0.8,
+                    min_pos_iou=0.8,
+                    match_low_quality=False,
+                    ignore_iof_thr=-1),
+                sampler=dict(
+                    type='RandomSampler',
+                    num=512,
+                    pos_fraction=0.25,
+                    neg_pos_ub=-1,
+                    add_gt_as_proposals=True),
+                mask_size=28,
+                pos_weight=-1,
+                debug=False)
+        ]),
+    test_cfg=dict(
+        rpn=dict(
+            score_thr=0.0001,
+            nms_pre=1000,
+            max_per_img=256,
+            nms=dict(type='nms', iou_threshold=0.9),
+            min_bbox_size=0),
+        rcnn=dict(
+            score_thr=0.02,
+            nms=dict(type='nms', iou_threshold=0.5),
+            max_per_img=300,
+            mask_thr_binary=0.5)))
+
+backend = 'pillow'
+test_pipeline = [
+    dict(
+        type='LoadImageFromFile',
+        backend_args=_base_.backend_args,
+        imdecode_backend=backend),
+    dict(type='Resize', scale=(1333, 800), keep_ratio=True, backend=backend),
+    dict(
+        type='LoadAnnotations',
+        with_bbox=True,
+        with_mask=True,
+        poly2mask=False),
+    dict(
+        type='PackDetInputs',
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+
+train_dataloader = dict(batch_size=8, num_workers=4)
+val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader
+# Enable automatic-mixed-precision training with AmpOptimWrapper.
+optim_wrapper = dict(
+    type='AmpOptimWrapper',
+    optimizer=dict(
+        type='SGD', lr=0.01 * 4, momentum=0.9, weight_decay=0.00004),
+    paramwise_cfg=dict(norm_decay_mult=0.))
+
+param_scheduler = [
+    dict(
+        type='LinearLR',
+        start_factor=0.00025,
+        by_epoch=False,
+        begin=0,
+        end=4000),
+    dict(
+        type='MultiStepLR',
+        begin=0,
+        end=25,
+        by_epoch=True,
+        milestones=[22, 24],
+        gamma=0.1)
+]
+
+# NOTE: `auto_scale_lr` is for automatically scaling LR,
+# USER SHOULD NOT CHANGE ITS VALUES.
+# base_batch_size = (8 GPUs) x (8 samples per GPU)
+auto_scale_lr = dict(base_batch_size=64)
diff --git a/mmdetection/projects/Detic/demo.py b/mmdetection/projects/Detic/demo.py
new file mode 100644
index 00000000..d5c80c9a
--- /dev/null
+++ b/mmdetection/projects/Detic/demo.py
@@ -0,0 +1,142 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os
+import urllib
+from argparse import ArgumentParser
+
+import mmcv
+import torch
+from mmengine.logging import print_log
+from mmengine.utils import ProgressBar, scandir
+
+from mmdet.apis import inference_detector, init_detector
+from mmdet.registry import VISUALIZERS
+from mmdet.utils import register_all_modules
+
+IMG_EXTENSIONS = ('.jpg', '.jpeg', '.png', '.ppm', '.bmp', '.pgm', '.tif',
+                  '.tiff', '.webp')
+
+
+def get_file_list(source_root: str) -> [list, dict]:
+    """Get file list.
+
+    Args:
+        source_root (str): image or video source path
+
+    Return:
+        source_file_path_list (list): A list for all source file.
+        source_type (dict): Source type: file or url or dir.
+    """
+    is_dir = os.path.isdir(source_root)
+    is_url = source_root.startswith(('http:/', 'https:/'))
+    is_file = os.path.splitext(source_root)[-1].lower() in IMG_EXTENSIONS
+
+    source_file_path_list = []
+    if is_dir:
+        # when input source is dir
+        for file in scandir(source_root, IMG_EXTENSIONS, recursive=True):
+            source_file_path_list.append(os.path.join(source_root, file))
+    elif is_url:
+        # when input source is url
+        filename = os.path.basename(
+            urllib.parse.unquote(source_root).split('?')[0])
+        file_save_path = os.path.join(os.getcwd(), filename)
+        print(f'Downloading source file to {file_save_path}')
+        torch.hub.download_url_to_file(source_root, file_save_path)
+        source_file_path_list = [file_save_path]
+    elif is_file:
+        # when input source is single image
+        source_file_path_list = [source_root]
+    else:
+        print('Cannot find image file.')
+
+    source_type = dict(is_dir=is_dir, is_url=is_url, is_file=is_file)
+
+    return source_file_path_list, source_type
+
+
+def parse_args():
+    parser = ArgumentParser()
+    parser.add_argument(
+        'img', help='Image path, include image file, dir and URL.')
+    parser.add_argument('config', help='Config file')
+    parser.add_argument('checkpoint', help='Checkpoint file')
+    parser.add_argument(
+        '--out-dir', default='./output', help='Path to output file')
+    parser.add_argument(
+        '--device', default='cuda:0', help='Device used for inference')
+    parser.add_argument(
+        '--show', action='store_true', help='Show the detection results')
+    parser.add_argument(
+        '--score-thr', type=float, default=0.3, help='Bbox score threshold')
+    parser.add_argument(
+        '--dataset', type=str, help='dataset name to load the text embedding')
+    parser.add_argument(
+        '--class-name', nargs='+', type=str, help='custom class names')
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+
+    # register all modules in mmdet into the registries
+    register_all_modules()
+
+    # build the model from a config file and a checkpoint file
+    model = init_detector(args.config, args.checkpoint, device=args.device)
+
+    if not os.path.exists(args.out_dir) and not args.show:
+        os.mkdir(args.out_dir)
+
+    # init visualizer
+    visualizer = VISUALIZERS.build(model.cfg.visualizer)
+    visualizer.dataset_meta = model.dataset_meta
+
+    # get file list
+    files, source_type = get_file_list(args.img)
+    from detic.utils import (get_class_names, get_text_embeddings,
+                             reset_cls_layer_weight)
+
+    # class name embeddings
+    if args.class_name:
+        dataset_classes = args.class_name
+    elif args.dataset:
+        dataset_classes = get_class_names(args.dataset)
+    embedding = get_text_embeddings(
+        dataset=args.dataset, custom_vocabulary=args.class_name)
+    visualizer.dataset_meta['classes'] = dataset_classes
+    reset_cls_layer_weight(model, embedding)
+
+    # start detector inference
+    progress_bar = ProgressBar(len(files))
+    for file in files:
+        result = inference_detector(model, file)
+
+        img = mmcv.imread(file)
+        img = mmcv.imconvert(img, 'bgr', 'rgb')
+
+        if source_type['is_dir']:
+            filename = os.path.relpath(file, args.img).replace('/', '_')
+        else:
+            filename = os.path.basename(file)
+        out_file = None if args.show else os.path.join(args.out_dir, filename)
+
+        progress_bar.update()
+
+        visualizer.add_datasample(
+            filename,
+            img,
+            data_sample=result,
+            draw_gt=False,
+            show=args.show,
+            wait_time=0,
+            out_file=out_file,
+            pred_score_thr=args.score_thr)
+
+    if not args.show:
+        print_log(
+            f'\nResults have been saved at {os.path.abspath(args.out_dir)}')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmdetection/projects/Detic/detic/__init__.py b/mmdetection/projects/Detic/detic/__init__.py
new file mode 100644
index 00000000..d0ad0702
--- /dev/null
+++ b/mmdetection/projects/Detic/detic/__init__.py
@@ -0,0 +1,9 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .centernet_rpn_head import CenterNetRPNHead
+from .detic_bbox_head import DeticBBoxHead
+from .detic_roi_head import DeticRoIHead
+from .zero_shot_classifier import ZeroShotClassifier
+
+__all__ = [
+    'CenterNetRPNHead', 'DeticBBoxHead', 'DeticRoIHead', 'ZeroShotClassifier'
+]
diff --git a/mmdetection/projects/Detic/detic/centernet_rpn_head.py b/mmdetection/projects/Detic/detic/centernet_rpn_head.py
new file mode 100644
index 00000000..765d6dfb
--- /dev/null
+++ b/mmdetection/projects/Detic/detic/centernet_rpn_head.py
@@ -0,0 +1,196 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+from typing import List, Sequence, Tuple
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import Scale
+from mmengine import ConfigDict
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.models.dense_heads import CenterNetUpdateHead
+from mmdet.models.utils import multi_apply
+from mmdet.registry import MODELS
+
+INF = 1000000000
+RangeType = Sequence[Tuple[int, int]]
+
+
+@MODELS.register_module(force=True)  # avoid bug
+class CenterNetRPNHead(CenterNetUpdateHead):
+    """CenterNetUpdateHead is an improved version of CenterNet in CenterNet2.
+
+    Paper link ``_.
+    """
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        self._init_reg_convs()
+        self._init_predictor()
+
+    def _init_predictor(self) -> None:
+        """Initialize predictor layers of the head."""
+        self.conv_cls = nn.Conv2d(
+            self.feat_channels, self.num_classes, 3, padding=1)
+        self.conv_reg = nn.Conv2d(self.feat_channels, 4, 3, padding=1)
+
+    def forward(self, x: Tuple[Tensor]) -> Tuple[List[Tensor], List[Tensor]]:
+        """Forward features from the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+
+        Returns:
+            tuple: A tuple of each level outputs.
+
+            - cls_scores (list[Tensor]): Box scores for each scale level, \
+            each is a 4D-tensor, the channel number is num_classes.
+            - bbox_preds (list[Tensor]): Box energies / deltas for each \
+            scale level, each is a 4D-tensor, the channel number is 4.
+        """
+        res = multi_apply(self.forward_single, x, self.scales, self.strides)
+        return res
+
+    def forward_single(self, x: Tensor, scale: Scale,
+                       stride: int) -> Tuple[Tensor, Tensor]:
+        """Forward features of a single scale level.
+
+        Args:
+            x (Tensor): FPN feature maps of the specified stride.
+            scale (:obj:`mmcv.cnn.Scale`): Learnable scale module to resize
+                the bbox prediction.
+            stride (int): The corresponding stride for feature maps.
+
+        Returns:
+            tuple: scores for each class, bbox predictions of
+            input feature maps.
+        """
+        for m in self.reg_convs:
+            x = m(x)
+        cls_score = self.conv_cls(x)
+        bbox_pred = self.conv_reg(x)
+        # scale the bbox_pred of different level
+        # float to avoid overflow when enabling FP16
+        bbox_pred = scale(bbox_pred).float()
+        # bbox_pred needed for gradient computation has been modified
+        # by F.relu(bbox_pred) when run with PyTorch 1.10. So replace
+        # F.relu(bbox_pred) with bbox_pred.clamp(min=0)
+        bbox_pred = bbox_pred.clamp(min=0)
+        if not self.training:
+            bbox_pred *= stride
+        return cls_score, bbox_pred  # score aligned, box larger
+
+    def _predict_by_feat_single(self,
+                                cls_score_list: List[Tensor],
+                                bbox_pred_list: List[Tensor],
+                                score_factor_list: List[Tensor],
+                                mlvl_priors: List[Tensor],
+                                img_meta: dict,
+                                cfg: ConfigDict,
+                                rescale: bool = False,
+                                with_nms: bool = True) -> InstanceData:
+        """Transform a single image's features extracted from the head into
+        bbox results.
+
+        Args:
+            cls_score_list (list[Tensor]): Box scores from all scale
+                levels of a single image, each item has shape
+                (num_priors * num_classes, H, W).
+            bbox_pred_list (list[Tensor]): Box energies / deltas from
+                all scale levels of a single image, each item has shape
+                (num_priors * 4, H, W).
+            score_factor_list (list[Tensor]): Score factor from all scale
+                levels of a single image, each item has shape
+                (num_priors * 1, H, W).
+            mlvl_priors (list[Tensor]): Each element in the list is
+                the priors of a single level in feature pyramid. In all
+                anchor-based methods, it has shape (num_priors, 4). In
+                all anchor-free methods, it has shape (num_priors, 2)
+                when `with_stride=True`, otherwise it still has shape
+                (num_priors, 4).
+            img_meta (dict): Image meta info.
+            cfg (mmengine.Config): Test / postprocessing configuration,
+                if None, test_cfg would be used.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            with_nms (bool): If True, do nms before return boxes.
+                Defaults to True.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+
+        cfg = self.test_cfg if cfg is None else cfg
+        cfg = copy.deepcopy(cfg)
+        nms_pre = cfg.get('nms_pre', -1)
+
+        mlvl_bbox_preds = []
+        mlvl_valid_priors = []
+        mlvl_scores = []
+        mlvl_labels = []
+
+        for level_idx, (cls_score, bbox_pred, score_factor, priors) in \
+                enumerate(zip(cls_score_list, bbox_pred_list,
+                              score_factor_list, mlvl_priors)):
+
+            assert cls_score.size()[-2:] == bbox_pred.size()[-2:]
+
+            dim = self.bbox_coder.encode_size
+            bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, dim)
+            cls_score = cls_score.permute(1, 2,
+                                          0).reshape(-1, self.cls_out_channels)
+            heatmap = cls_score.sigmoid()
+            score_thr = cfg.get('score_thr', 0)
+
+            candidate_inds = heatmap > score_thr  # 0.05
+            pre_nms_top_n = candidate_inds.sum()  # N
+            pre_nms_top_n = pre_nms_top_n.clamp(max=nms_pre)  # N
+
+            heatmap = heatmap[candidate_inds]  # n
+
+            candidate_nonzeros = candidate_inds.nonzero()  # n
+            box_loc = candidate_nonzeros[:, 0]  # n
+            labels = candidate_nonzeros[:, 1]  # n
+
+            bbox_pred = bbox_pred[box_loc]  # n x 4
+            per_grids = priors[box_loc]  # n x 2
+
+            if candidate_inds.sum().item() > pre_nms_top_n.item():
+                heatmap, top_k_indices = \
+                    heatmap.topk(pre_nms_top_n, sorted=False)
+                labels = labels[top_k_indices]
+                bbox_pred = bbox_pred[top_k_indices]
+                per_grids = per_grids[top_k_indices]
+
+            bboxes = self.bbox_coder.decode(per_grids, bbox_pred)
+            # avoid invalid boxes in RoI heads
+            bboxes[:, 2] = torch.max(bboxes[:, 2], bboxes[:, 0] + 0.01)
+            bboxes[:, 3] = torch.max(bboxes[:, 3], bboxes[:, 1] + 0.01)
+
+            mlvl_bbox_preds.append(bboxes)
+            mlvl_valid_priors.append(priors)
+            mlvl_scores.append(torch.sqrt(heatmap))
+            mlvl_labels.append(labels)
+
+        results = InstanceData()
+        results.bboxes = torch.cat(mlvl_bbox_preds)
+        results.scores = torch.cat(mlvl_scores)
+        results.labels = torch.cat(mlvl_labels)
+
+        return self._bbox_post_process(
+            results=results,
+            cfg=cfg,
+            rescale=rescale,
+            with_nms=with_nms,
+            img_meta=img_meta)
diff --git a/mmdetection/projects/Detic/detic/detic_bbox_head.py b/mmdetection/projects/Detic/detic/detic_bbox_head.py
new file mode 100644
index 00000000..9408cbe0
--- /dev/null
+++ b/mmdetection/projects/Detic/detic/detic_bbox_head.py
@@ -0,0 +1,112 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Union
+
+from mmengine.config import ConfigDict
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.models.layers import multiclass_nms
+from mmdet.models.roi_heads.bbox_heads import Shared2FCBBoxHead
+from mmdet.models.utils import empty_instances
+from mmdet.registry import MODELS
+from mmdet.structures.bbox import get_box_tensor, scale_boxes
+
+
+@MODELS.register_module(force=True)  # avoid bug
+class DeticBBoxHead(Shared2FCBBoxHead):
+
+    def __init__(self,
+                 *args,
+                 init_cfg: Optional[Union[dict, ConfigDict]] = None,
+                 **kwargs) -> None:
+        super().__init__(*args, init_cfg=init_cfg, **kwargs)
+        # reconstruct fc_cls and fc_reg since input channels are changed
+        assert self.with_cls
+        cls_channels = self.num_classes
+        cls_predictor_cfg_ = self.cls_predictor_cfg.copy()
+        cls_predictor_cfg_.update(
+            in_features=self.cls_last_dim, out_features=cls_channels)
+        self.fc_cls = MODELS.build(cls_predictor_cfg_)
+
+    def _predict_by_feat_single(
+            self,
+            roi: Tensor,
+            cls_score: Tensor,
+            bbox_pred: Tensor,
+            img_meta: dict,
+            rescale: bool = False,
+            rcnn_test_cfg: Optional[ConfigDict] = None) -> InstanceData:
+        """Transform a single image's features extracted from the head into
+        bbox results.
+
+        Args:
+            roi (Tensor): Boxes to be transformed. Has shape (num_boxes, 5).
+                last dimension 5 arrange as (batch_index, x1, y1, x2, y2).
+            cls_score (Tensor): Box scores, has shape
+                (num_boxes, num_classes + 1).
+            bbox_pred (Tensor): Box energies / deltas.
+                has shape (num_boxes, num_classes * 4).
+            img_meta (dict): image information.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            rcnn_test_cfg (obj:`ConfigDict`): `test_cfg` of Bbox Head.
+                Defaults to None
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image\
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        results = InstanceData()
+        if roi.shape[0] == 0:
+            return empty_instances([img_meta],
+                                   roi.device,
+                                   task_type='bbox',
+                                   instance_results=[results],
+                                   box_type=self.predict_box_type,
+                                   use_box_type=False,
+                                   num_classes=self.num_classes,
+                                   score_per_cls=rcnn_test_cfg is None)[0]
+        scores = cls_score
+        img_shape = img_meta['img_shape']
+        num_rois = roi.size(0)
+
+        num_classes = 1 if self.reg_class_agnostic else self.num_classes
+        roi = roi.repeat_interleave(num_classes, dim=0)
+        bbox_pred = bbox_pred.view(-1, self.bbox_coder.encode_size)
+        bboxes = self.bbox_coder.decode(
+            roi[..., 1:], bbox_pred, max_shape=img_shape)
+
+        if rescale and bboxes.size(0) > 0:
+            assert img_meta.get('scale_factor') is not None
+            scale_factor = [1 / s for s in img_meta['scale_factor']]
+            bboxes = scale_boxes(bboxes, scale_factor)
+
+        # Get the inside tensor when `bboxes` is a box type
+        bboxes = get_box_tensor(bboxes)
+        box_dim = bboxes.size(-1)
+        bboxes = bboxes.view(num_rois, -1)
+
+        if rcnn_test_cfg is None:
+            # This means that it is aug test.
+            # It needs to return the raw results without nms.
+            results.bboxes = bboxes
+            results.scores = scores
+        else:
+            det_bboxes, det_labels = multiclass_nms(
+                bboxes,
+                scores,
+                rcnn_test_cfg.score_thr,
+                rcnn_test_cfg.nms,
+                rcnn_test_cfg.max_per_img,
+                box_dim=box_dim)
+            results.bboxes = det_bboxes[:, :-1]
+            results.scores = det_bboxes[:, -1]
+            results.labels = det_labels
+        return results
diff --git a/mmdetection/projects/Detic/detic/detic_roi_head.py b/mmdetection/projects/Detic/detic/detic_roi_head.py
new file mode 100644
index 00000000..a09c11c6
--- /dev/null
+++ b/mmdetection/projects/Detic/detic/detic_roi_head.py
@@ -0,0 +1,326 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Sequence, Tuple
+
+import torch
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.models.roi_heads import CascadeRoIHead
+from mmdet.models.task_modules.samplers import SamplingResult
+from mmdet.models.test_time_augs import merge_aug_masks
+from mmdet.models.utils.misc import empty_instances
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.structures.bbox import bbox2roi, get_box_tensor
+from mmdet.utils import ConfigType, InstanceList, MultiConfig
+
+
+@MODELS.register_module(force=True)  # avoid bug
+class DeticRoIHead(CascadeRoIHead):
+
+    def init_mask_head(self, mask_roi_extractor: MultiConfig,
+                       mask_head: MultiConfig) -> None:
+        """Initialize mask head and mask roi extractor.
+
+        Args:
+            mask_head (dict): Config of mask in mask head.
+            mask_roi_extractor (:obj:`ConfigDict`, dict or list):
+                Config of mask roi extractor.
+        """
+        self.mask_head = MODELS.build(mask_head)
+
+        if mask_roi_extractor is not None:
+            self.share_roi_extractor = False
+            self.mask_roi_extractor = MODELS.build(mask_roi_extractor)
+        else:
+            self.share_roi_extractor = True
+            self.mask_roi_extractor = self.bbox_roi_extractor
+
+    def _refine_roi(self, x: Tuple[Tensor], rois: Tensor,
+                    batch_img_metas: List[dict],
+                    num_proposals_per_img: Sequence[int], **kwargs) -> tuple:
+        """Multi-stage refinement of RoI.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            rois (Tensor): shape (n, 5), [batch_ind, x1, y1, x2, y2]
+            batch_img_metas (list[dict]): List of image information.
+            num_proposals_per_img (sequence[int]): number of proposals
+                in each image.
+
+        Returns:
+            tuple:
+
+               - rois (Tensor): Refined RoI.
+               - cls_scores (list[Tensor]): Average predicted
+                   cls score per image.
+               - bbox_preds (list[Tensor]): Bbox branch predictions
+                   for the last stage of per image.
+        """
+        # "ms" in variable names means multi-stage
+        ms_scores = []
+        for stage in range(self.num_stages):
+            bbox_results = self._bbox_forward(
+                stage=stage, x=x, rois=rois, **kwargs)
+
+            # split batch bbox prediction back to each image
+            cls_scores = bbox_results['cls_score'].sigmoid()
+            bbox_preds = bbox_results['bbox_pred']
+
+            rois = rois.split(num_proposals_per_img, 0)
+            cls_scores = cls_scores.split(num_proposals_per_img, 0)
+            ms_scores.append(cls_scores)
+            bbox_preds = bbox_preds.split(num_proposals_per_img, 0)
+
+            if stage < self.num_stages - 1:
+                bbox_head = self.bbox_head[stage]
+                refine_rois_list = []
+                for i in range(len(batch_img_metas)):
+                    if rois[i].shape[0] > 0:
+                        bbox_label = cls_scores[i][:, :-1].argmax(dim=1)
+                        # Refactor `bbox_head.regress_by_class` to only accept
+                        # box tensor without img_idx concatenated.
+                        refined_bboxes = bbox_head.regress_by_class(
+                            rois[i][:, 1:], bbox_label, bbox_preds[i],
+                            batch_img_metas[i])
+                        refined_bboxes = get_box_tensor(refined_bboxes)
+                        refined_rois = torch.cat(
+                            [rois[i][:, [0]], refined_bboxes], dim=1)
+                        refine_rois_list.append(refined_rois)
+                rois = torch.cat(refine_rois_list)
+        # ms_scores aligned
+        # average scores of each image by stages
+        cls_scores = [
+            sum([score[i] for score in ms_scores]) / float(len(ms_scores))
+            for i in range(len(batch_img_metas))
+        ]  # aligned
+        return rois, cls_scores, bbox_preds
+
+    def _bbox_forward(self, stage: int, x: Tuple[Tensor],
+                      rois: Tensor) -> dict:
+        """Box head forward function used in both training and testing.
+
+        Args:
+            stage (int): The current stage in Cascade RoI Head.
+            x (tuple[Tensor]): List of multi-level img features.
+            rois (Tensor): RoIs with the shape (n, 5) where the first
+                column indicates batch id of each RoI.
+
+        Returns:
+             dict[str, Tensor]: Usually returns a dictionary with keys:
+
+                - `cls_score` (Tensor): Classification scores.
+                - `bbox_pred` (Tensor): Box energies / deltas.
+                - `bbox_feats` (Tensor): Extract bbox RoI features.
+        """
+        bbox_roi_extractor = self.bbox_roi_extractor[stage]
+        bbox_head = self.bbox_head[stage]
+        bbox_feats = bbox_roi_extractor(x[:bbox_roi_extractor.num_inputs],
+                                        rois)
+        # do not support caffe_c4 model anymore
+        cls_score, bbox_pred = bbox_head(bbox_feats)
+
+        bbox_results = dict(
+            cls_score=cls_score, bbox_pred=bbox_pred, bbox_feats=bbox_feats)
+        return bbox_results
+
+    def predict_bbox(self,
+                     x: Tuple[Tensor],
+                     batch_img_metas: List[dict],
+                     rpn_results_list: InstanceList,
+                     rcnn_test_cfg: ConfigType,
+                     rescale: bool = False,
+                     **kwargs) -> InstanceList:
+        """Perform forward propagation of the bbox head and predict detection
+        results on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Feature maps of all scale level.
+            batch_img_metas (list[dict]): List of image information.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals.
+            rcnn_test_cfg (obj:`ConfigDict`): `test_cfg` of R-CNN.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        proposals = [res.bboxes for res in rpn_results_list]
+        proposal_scores = [res.scores for res in rpn_results_list]
+        num_proposals_per_img = tuple(len(p) for p in proposals)
+        rois = bbox2roi(proposals)
+
+        if rois.shape[0] == 0:
+            return empty_instances(
+                batch_img_metas,
+                rois.device,
+                task_type='bbox',
+                box_type=self.bbox_head[-1].predict_box_type,
+                num_classes=self.bbox_head[-1].num_classes,
+                score_per_cls=rcnn_test_cfg is None)
+        # rois aligned
+        rois, cls_scores, bbox_preds = self._refine_roi(
+            x=x,
+            rois=rois,
+            batch_img_metas=batch_img_metas,
+            num_proposals_per_img=num_proposals_per_img,
+            **kwargs)
+
+        # score reweighting in centernet2
+        cls_scores = [(s * ps[:, None])**0.5
+                      for s, ps in zip(cls_scores, proposal_scores)]
+        cls_scores = [
+            s * (s == s[:, :-1].max(dim=1)[0][:, None]).float()
+            for s in cls_scores
+        ]
+
+        # fast_rcnn_inference
+        results_list = self.bbox_head[-1].predict_by_feat(
+            rois=rois,
+            cls_scores=cls_scores,
+            bbox_preds=bbox_preds,
+            batch_img_metas=batch_img_metas,
+            rescale=rescale,
+            rcnn_test_cfg=rcnn_test_cfg)
+        return results_list
+
+    def _mask_forward(self, x: Tuple[Tensor], rois: Tensor) -> dict:
+        """Mask head forward function used in both training and testing.
+
+        Args:
+            stage (int): The current stage in Cascade RoI Head.
+            x (tuple[Tensor]): Tuple of multi-level img features.
+            rois (Tensor): RoIs with the shape (n, 5) where the first
+                column indicates batch id of each RoI.
+
+        Returns:
+            dict: Usually returns a dictionary with keys:
+
+                - `mask_preds` (Tensor): Mask prediction.
+        """
+        mask_feats = self.mask_roi_extractor(
+            x[:self.mask_roi_extractor.num_inputs], rois)
+        # do not support caffe_c4 model anymore
+        mask_preds = self.mask_head(mask_feats)
+
+        mask_results = dict(mask_preds=mask_preds)
+        return mask_results
+
+    def mask_loss(self, x, sampling_results: List[SamplingResult],
+                  batch_gt_instances: InstanceList) -> dict:
+        """Run forward function and calculate loss for mask head in training.
+
+        Args:
+            x (tuple[Tensor]): Tuple of multi-level img features.
+            sampling_results (list["obj:`SamplingResult`]): Sampling results.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes``, ``labels``, and
+                ``masks`` attributes.
+
+        Returns:
+            dict: Usually returns a dictionary with keys:
+
+                - `mask_preds` (Tensor): Mask prediction.
+                - `loss_mask` (dict): A dictionary of mask loss components.
+        """
+        pos_rois = bbox2roi([res.pos_priors for res in sampling_results])
+        mask_results = self._mask_forward(x, pos_rois)
+
+        mask_loss_and_target = self.mask_head.loss_and_target(
+            mask_preds=mask_results['mask_preds'],
+            sampling_results=sampling_results,
+            batch_gt_instances=batch_gt_instances,
+            rcnn_train_cfg=self.train_cfg[-1])
+        mask_results.update(mask_loss_and_target)
+
+        return mask_results
+
+    def loss(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
+             batch_data_samples: SampleList) -> dict:
+        """Perform forward propagation and loss calculation of the detection
+        roi on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components
+        """
+        raise NotImplementedError
+
+    def predict_mask(self,
+                     x: Tuple[Tensor],
+                     batch_img_metas: List[dict],
+                     results_list: List[InstanceData],
+                     rescale: bool = False) -> List[InstanceData]:
+        """Perform forward propagation of the mask head and predict detection
+        results on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Feature maps of all scale level.
+            batch_img_metas (list[dict]): List of image information.
+            results_list (list[:obj:`InstanceData`]): Detection results of
+                each image.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+                - masks (Tensor): Has a shape (num_instances, H, W).
+        """
+        bboxes = [res.bboxes for res in results_list]
+        mask_rois = bbox2roi(bboxes)
+        if mask_rois.shape[0] == 0:
+            results_list = empty_instances(
+                batch_img_metas,
+                mask_rois.device,
+                task_type='mask',
+                instance_results=results_list,
+                mask_thr_binary=self.test_cfg.mask_thr_binary)
+            return results_list
+
+        num_mask_rois_per_img = [len(res) for res in results_list]
+        aug_masks = []
+        mask_results = self._mask_forward(x, mask_rois)
+        mask_preds = mask_results['mask_preds']
+        # split batch mask prediction back to each image
+        mask_preds = mask_preds.split(num_mask_rois_per_img, 0)
+        aug_masks.append([m.sigmoid().detach() for m in mask_preds])
+
+        merged_masks = []
+        for i in range(len(batch_img_metas)):
+            aug_mask = [mask[i] for mask in aug_masks]
+            merged_mask = merge_aug_masks(aug_mask, batch_img_metas[i])
+            merged_masks.append(merged_mask)
+        results_list = self.mask_head.predict_by_feat(
+            mask_preds=merged_masks,
+            results_list=results_list,
+            batch_img_metas=batch_img_metas,
+            rcnn_test_cfg=self.test_cfg,
+            rescale=rescale,
+            activate_map=True)
+        return results_list
diff --git a/mmdetection/projects/Detic/detic/text_encoder.py b/mmdetection/projects/Detic/detic/text_encoder.py
new file mode 100644
index 00000000..f0024efa
--- /dev/null
+++ b/mmdetection/projects/Detic/detic/text_encoder.py
@@ -0,0 +1,50 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Union
+
+import torch
+import torch.nn as nn
+
+
+class CLIPTextEncoder(nn.Module):
+
+    def __init__(self, model_name='ViT-B/32'):
+        super().__init__()
+        import clip
+        from clip.simple_tokenizer import SimpleTokenizer
+        self.tokenizer = SimpleTokenizer()
+        pretrained_model, _ = clip.load(model_name, device='cpu')
+        self.clip = pretrained_model
+
+    @property
+    def device(self):
+        return self.clip.device
+
+    @property
+    def dtype(self):
+        return self.clip.dtype
+
+    def tokenize(self,
+                 texts: Union[str, List[str]],
+                 context_length: int = 77) -> torch.LongTensor:
+        if isinstance(texts, str):
+            texts = [texts]
+
+        sot_token = self.tokenizer.encoder['<|startoftext|>']
+        eot_token = self.tokenizer.encoder['<|endoftext|>']
+        all_tokens = [[sot_token] + self.tokenizer.encode(text) + [eot_token]
+                      for text in texts]
+        result = torch.zeros(len(all_tokens), context_length, dtype=torch.long)
+
+        for i, tokens in enumerate(all_tokens):
+            if len(tokens) > context_length:
+                st = torch.randint(len(tokens) - context_length + 1,
+                                   (1, ))[0].item()
+                tokens = tokens[st:st + context_length]
+            result[i, :len(tokens)] = torch.tensor(tokens)
+
+        return result
+
+    def forward(self, text):
+        text = self.tokenize(text)
+        text_features = self.clip.encode_text(text)
+        return text_features
diff --git a/mmdetection/projects/Detic/detic/utils.py b/mmdetection/projects/Detic/detic/utils.py
new file mode 100644
index 00000000..56d4fd42
--- /dev/null
+++ b/mmdetection/projects/Detic/detic/utils.py
@@ -0,0 +1,78 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import numpy as np
+import torch
+import torch.nn.functional as F
+from mmengine.logging import print_log
+
+from .text_encoder import CLIPTextEncoder
+
+# download from
+# https://github.com/facebookresearch/Detic/tree/main/datasets/metadata
+DATASET_EMBEDDINGS = {
+    'lvis': 'datasets/metadata/lvis_v1_clip_a+cname.npy',
+    'objects365': 'datasets/metadata/o365_clip_a+cnamefix.npy',
+    'openimages': 'datasets/metadata/oid_clip_a+cname.npy',
+    'coco': 'datasets/metadata/coco_clip_a+cname.npy',
+}
+
+
+def get_text_embeddings(dataset=None,
+                        custom_vocabulary=None,
+                        prompt_prefix='a '):
+    assert (dataset is None) ^ (custom_vocabulary is None), \
+        'Either `dataset` or `custom_vocabulary` should be specified.'
+    if dataset:
+        if dataset in DATASET_EMBEDDINGS:
+            return DATASET_EMBEDDINGS[dataset]
+        else:
+            custom_vocabulary = get_class_names(dataset)
+
+    text_encoder = CLIPTextEncoder()
+    text_encoder.eval()
+    texts = [prompt_prefix + x for x in custom_vocabulary]
+    print_log(
+        f'Computing text embeddings for {len(custom_vocabulary)} classes.')
+    embeddings = text_encoder(texts).detach().permute(1, 0).contiguous().cpu()
+    return embeddings
+
+
+def get_class_names(dataset):
+    if dataset == 'coco':
+        from mmdet.datasets import CocoDataset
+        class_names = CocoDataset.METAINFO['classes']
+    elif dataset == 'cityscapes':
+        from mmdet.datasets import CityscapesDataset
+        class_names = CityscapesDataset.METAINFO['classes']
+    elif dataset == 'voc':
+        from mmdet.datasets import VOCDataset
+        class_names = VOCDataset.METAINFO['classes']
+    elif dataset == 'openimages':
+        from mmdet.datasets import OpenImagesDataset
+        class_names = OpenImagesDataset.METAINFO['classes']
+    elif dataset == 'lvis':
+        from mmdet.datasets import LVISV1Dataset
+        class_names = LVISV1Dataset.METAINFO['classes']
+    else:
+        raise TypeError(f'Invalid type for dataset name: {type(dataset)}')
+    return class_names
+
+
+def reset_cls_layer_weight(model, weight):
+    if type(weight) == str:
+        print_log(f'Resetting cls_layer_weight from file: {weight}')
+        zs_weight = torch.tensor(
+            np.load(weight),
+            dtype=torch.float32).permute(1, 0).contiguous()  # D x C
+    else:
+        zs_weight = weight
+    zs_weight = torch.cat(
+        [zs_weight, zs_weight.new_zeros(
+            (zs_weight.shape[0], 1))], dim=1)  # D x (C + 1)
+    zs_weight = F.normalize(zs_weight, p=2, dim=0)
+    zs_weight = zs_weight.to('cuda')
+    num_classes = zs_weight.shape[-1]
+
+    for bbox_head in model.roi_head.bbox_head:
+        bbox_head.num_classes = num_classes
+        del bbox_head.fc_cls.zs_weight
+        bbox_head.fc_cls.zs_weight = zs_weight
diff --git a/mmdetection/projects/Detic/detic/zero_shot_classifier.py b/mmdetection/projects/Detic/detic/zero_shot_classifier.py
new file mode 100644
index 00000000..35c9e492
--- /dev/null
+++ b/mmdetection/projects/Detic/detic/zero_shot_classifier.py
@@ -0,0 +1,73 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+import numpy as np
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+from mmdet.registry import MODELS
+
+
+@MODELS.register_module(force=True)  # avoid bug
+class ZeroShotClassifier(nn.Module):
+
+    def __init__(
+        self,
+        in_features: int,
+        out_features: int,  # num_classes
+        zs_weight_path: str,
+        zs_weight_dim: int = 512,
+        use_bias: float = 0.0,
+        norm_weight: bool = True,
+        norm_temperature: float = 50.0,
+    ):
+        super().__init__()
+        num_classes = out_features
+        self.norm_weight = norm_weight
+        self.norm_temperature = norm_temperature
+
+        self.use_bias = use_bias < 0
+        if self.use_bias:
+            self.cls_bias = nn.Parameter(torch.ones(1) * use_bias)
+
+        self.linear = nn.Linear(in_features, zs_weight_dim)
+
+        if zs_weight_path == 'rand':
+            zs_weight = torch.randn((zs_weight_dim, num_classes))
+            nn.init.normal_(zs_weight, std=0.01)
+        else:
+            zs_weight = torch.tensor(
+                np.load(zs_weight_path),
+                dtype=torch.float32).permute(1, 0).contiguous()  # D x C
+        zs_weight = torch.cat(
+            [zs_weight, zs_weight.new_zeros(
+                (zs_weight_dim, 1))], dim=1)  # D x (C + 1)
+
+        if self.norm_weight:
+            zs_weight = F.normalize(zs_weight, p=2, dim=0)
+
+        if zs_weight_path == 'rand':
+            self.zs_weight = nn.Parameter(zs_weight)
+        else:
+            self.register_buffer('zs_weight', zs_weight)
+
+        assert self.zs_weight.shape[1] == num_classes + 1, self.zs_weight.shape
+
+    def forward(self, x, classifier=None):
+        '''
+        Inputs:
+            x: B x D'
+            classifier_info: (C', C' x D)
+        '''
+        x = self.linear(x)
+        if classifier is not None:
+            zs_weight = classifier.permute(1, 0).contiguous()  # D x C'
+            zs_weight = F.normalize(zs_weight, p=2, dim=0) \
+                if self.norm_weight else zs_weight
+        else:
+            zs_weight = self.zs_weight
+        if self.norm_weight:
+            x = self.norm_temperature * F.normalize(x, p=2, dim=1)
+        x = torch.mm(x, zs_weight)
+        if self.use_bias:
+            x = x + self.cls_bias
+        return x
diff --git a/mmdetection/projects/Detic_new/README.md b/mmdetection/projects/Detic_new/README.md
new file mode 100644
index 00000000..3c7714c3
--- /dev/null
+++ b/mmdetection/projects/Detic_new/README.md
@@ -0,0 +1,248 @@
+# Detecting Twenty-thousand Classes using Image-level Supervision
+
+## Description
+
+**Detic**: A **Det**ector with **i**mage **c**lasses that can use image-level labels to easily train detectors.
+
+
      
    
+
+> [**Detecting Twenty-thousand Classes using Image-level Supervision**](http://arxiv.org/abs/2201.02605),
+> Xingyi Zhou, Rohit Girdhar, Armand Joulin, Philipp Krähenbühl, Ishan Misra,
+> *ECCV 2022 ([arXiv 2201.02605](http://arxiv.org/abs/2201.02605))*
+
+## Usage
+
+
+
+## Installation
+
+Detic requires to install CLIP.
+
+```shell
+pip install git+https://github.com/openai/CLIP.git
+```
+
+## Prepare Datasets
+
+It is recommended to download and extract the dataset somewhere outside the project directory and symlink the dataset root to `$MMDETECTION/data` as below. If your folder structure is different, you may need to change the corresponding paths in config files.
+
+### LVIS
+
+LVIS dataset is adopted as box-labeled data,  [LVIS](https://www.lvisdataset.org/) is available from official website or mirror.  You need to generate `lvis_v1_train_norare.json` according to the [official prepare datasets](https://github.com/facebookresearch/Detic/blob/main/datasets/README.md#coco-and-lvis) for open-vocabulary LVIS, which removes the labels of 337 rare-class from training. You can also download [lvis_v1_train_norare.json](https://download.openmmlab.com/mmdetection/v3.0/detic/data/lvis/annotations/lvis_v1_train_norare.json) from our backup. The directory should be like this.
+
+```shell
+mmdetection
+├── data
+│   ├── lvis
+│   │   ├── annotations
+│   │   |	├── lvis_v1_train.json
+│   │   |	├── lvis_v1_val.json
+│   │   |	├── lvis_v1_train_norare.json
+│   │   ├── train2017
+│   │   ├── val2017
+```
+
+### ImageNet-LVIS
+
+ImageNet-LVIS is adopted as image-labeled data. You can download [ImageNet-21K](https://www.image-net.org/download.php) dataset from the official website.  Then you need to unzip the overlapping classes of LVIS and convert them into LVIS annotation format according to the [official prepare datasets](https://github.com/facebookresearch/Detic/blob/main/datasets/README.md#imagenet-21k). The directory should be like this.
+
+```shell
+mmdetection
+├── data
+│   ├── imagenet
+│   │   ├── annotations
+│   │   |	├── imagenet_lvis_image_info.json
+│   │   ├── ImageNet-21K
+│   │   |	├── n00007846
+│   │   |	├── n01318894
+│   │   |	├── ...
+```
+
+### Metadata
+
+`data/metadata/` is the preprocessed meta-data (included in the repo). Please follow the [official instruction](https://github.com/facebookresearch/Detic/blob/main/datasets/README.md#metadata) to pre-process the  LVIS dataset. You will generate `lvis_v1_train_cat_info.json` for Federated loss, which contains the frequency of each category of training set of LVIS. In addition, `lvis_v1_clip_a+cname.npy` is the pre-computed CLIP embeddings for each category of LVIS. You can also choose to directly download [lvis_v1_train_cat_info](https://download.openmmlab.com/mmdetection/v3.0/detic/data/metadata/lvis_v1_train_cat_info.json) and [lvis_v1_clip_a+cname.npy](https://download.openmmlab.com/mmdetection/v3.0/detic/data/metadata/lvis_v1_clip_a%2Bcname.npy) form our backup. The directory should be like this.
+
+```shell
+mmdetection
+├── data
+│   ├── metadata
+│   │   ├── lvis_v1_train_cat_info.json
+│   │   ├── lvis_v1_clip_a+cname.npy
+```
+
+## Demo
+
+Here we provide the Detic model for the open vocabulary demo.  This model is trained on combined LVIS-COCO and ImageNet-21K for better demo purposes. LVIS models do not detect persons well due to its federated annotation protocol. LVIS+COCO models give better visual results.
+
+| Backbone |         Training data          |                                Config                                 |                                                                                      Download                                                                                      |
+| :------: | :----------------------------: | :-------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+|  Swin-B  | LVIS  &  COCO  &  ImageNet-21K | [config](./configs/detic_centernet2_swin-b_fpn_4x_lvis_coco_in21k.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/detic/detic_centernet2_swin-b_fpn_4x_lvis-coco-in21k/detic_centernet2_swin-b_fpn_4x_lvis-coco-in21k_20230120-0d301978.pth) |
+
+You can also download other models from  [official model zoo](https://github.com/facebookresearch/Detic/blob/main/docs/MODEL_ZOO.md), and convert the format by run
+
+```shell
+python tools/model_converters/detic_to_mmdet.py --src /path/to/detic_weight.pth --dst /path/to/mmdet_weight.pth
+```
+
+### Inference with existing dataset vocabulary
+
+You can detect classes of existing dataset  with `--texts` command:
+
+```shell
+python demo/image_demo.py \
+  ${IMAGE_PATH} \
+  ${CONFIG_PATH} \
+  ${MODEL_PATH} \
+  --texts lvis \
+  --pred-score-thr 0.5 \
+  --palette 'random'
+```
+
+![image](https://user-images.githubusercontent.com/12907710/213624759-f0a2ba0c-0f5c-4424-a350-5ba5349e5842.png)
+
+### Inference with custom vocabularies
+
+Detic can detects any class given class names by using CLIP. You can detect customized classes with `--texts` command:
+
+```shell
+python demo/image_demo.py \
+  ${IMAGE_PATH} \
+  ${CONFIG_PATH} \
+  ${MODEL_PATH} \
+  --texts 'headphone . webcam . paper . coffe.' \
+  --pred-score-thr 0.3 \
+  --palette 'random'
+```
+
+![image](https://user-images.githubusercontent.com/12907710/213624637-e9e8a313-9821-4782-a18a-4408c876852b.png)
+
+Note that `headphone`, `paper` and `coffe` (typo intended) are not LVIS classes. Despite the misspelled class name, Detic can produce a reasonable detection for `coffe`.
+
+## Models and Results
+
+### Training
+
+There are two stages in the whole training process. The first stage is to train a model using images with box labels as the baseline. The second stage is to finetune from the baseline model and leverage image-labeled data.
+
+#### First stage
+
+To train the baseline with box-supervised, run
+
+```shell
+bash ./tools/dist_train.sh projects/Detic_new/detic_centernet2_r50_fpn_4x_lvis_boxsup.py 8
+```
+
+|                                         Model (Config)                                          | mask mAP | mask mAP(official) | mask mAP_rare | mask mAP_rare(officical) |
+| :---------------------------------------------------------------------------------------------: | :------: | :----------------: | :-----------: | :----------------------: |
+| [detic_centernet2_r50_fpn_4x_lvis_boxsup](./configs/detic_centernet2_r50_fpn_4x_lvis_boxsup.py) |   31.6   |        31.5        |     26.6      |           25.6           |
+
+#### Second stage
+
+The second stage uses  both object detection and image classification datasets.
+
+##### Multi-Datasets Config
+
+We provide improved dataset_wrapper `ConcatDataset` to concatenate multiple datasets, all datasets could have different annotation types and different pipelines (e.g., image_size). You can also obtain the index of `dataset_source` for each sample through ` get_dataset_source` . We provide sampler `MultiDataSampler` to custom the ratios of different datasets. Beside, we provide batch_sampler `MultiDataAspectRatioBatchSampler` to enable different datasets to have different batchsizes.  The config of multiple datasets is as follows:
+
+```python
+dataset_det = dict(
+    type='ClassBalancedDataset',
+    oversample_thr=1e-3,
+    dataset=dict(
+        type='LVISV1Dataset',
+        data_root='data/lvis/',
+        ann_file='annotations/lvis_v1_train.json',
+        data_prefix=dict(img=''),
+        filter_cfg=dict(filter_empty_gt=True, min_size=32),
+        pipeline=train_pipeline_det,
+        backend_args=backend_args))
+
+dataset_cls = dict(
+    type='ImageNetLVISV1Dataset',
+    data_root='data/imagenet',
+    ann_file='annotations/imagenet_lvis_image_info.json',
+    data_prefix=dict(img='ImageNet-LVIS/'),
+    pipeline=train_pipeline_cls,
+    backend_args=backend_args)
+
+train_dataloader = dict(
+    batch_size=[8, 32],
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(
+        type='MultiDataSampler',
+        dataset_ratio=[1, 4]),
+    batch_sampler=dict(
+        type='MultiDataAspectRatioBatchSampler',
+        num_datasets=2),
+    dataset=dict(
+        type='ConcatDataset',
+        datasets=[dataset_det, dataset_cls]))
+```
+
+###### Note:
+
+- If the one of the  multiple datasets is `ConcatDataset` , it is still considered as a dataset for `num_datasets` in `MultiDataAspectRatioBatchSampler`.
+
+To finetune the baseline model with image-labeled data， run:
+
+```shell
+bash ./tools/dist_train.sh projects/Detic_new/detic_centernet2_r50_fpn_4x_lvis_in21k-lvis.py 8
+```
+
+|                                             Model (Config)                                              | mask mAP | mask mAP(official) | mask mAP_rare | mask mAP_rare(officical) |
+| :-----------------------------------------------------------------------------------------------------: | :------: | :----------------: | :-----------: | :----------------------: |
+| [detic_centernet2_r50_fpn_4x_lvis_in21k-lvis](./configs/detic_centernet2_r50_fpn_4x_lvis_in21k-lvis.py) |   32.9   |        33.2        |     30.9      |           29.7           |
+
+#### Standard LVIS Results
+
+|                                                Model (Config)                                                 | mask mAP | mask mAP(official) | mask mAP_rare | mask mAP_rare(officical) |                                                                                                                                                                                     Download                                                                                                                                                                                     |
+| :-----------------------------------------------------------------------------------------------------------: | :------: | :----------------: | :-----------: | :----------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+|        [detic_centernet2_r50_fpn_4x_lvis_boxsup](./configs/detic_centernet2_r50_fpn_4x_lvis_boxsup.py)        |   31.6   |        31.5        |     26.6      |           25.6           |               [model](https://download.openmmlab.com/mmdetection/v3.0/detic/detic_centernet2_r50_fpn_4x_lvis_boxsup/detic_centernet2_r50_fpn_4x_lvis_boxsup_20230911_233514-54116677.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/detic/detic_centernet2_r50_fpn_4x_lvis_boxsup/detic_centernet2_r50_fpn_4x_lvis_boxsup_20230911_233514.log.json)               |
+|    [detic_centernet2_r50_fpn_4x_lvis_in21k-lvis](./configs/detic_centernet2_r50_fpn_4x_lvis_in21k-lvis.py)    |   32.9   |        33.2        |     30.9      |           29.7           |       [model](https://download.openmmlab.com/mmdetection/v3.0/detic/detic_centernet2_r50_fpn_4x_lvis_in21k-lvis/detic_centernet2_r50_fpn_4x_lvis_in21k-lvis_20230912_040619-9e7a3258.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/detic/detic_centernet2_r50_fpn_4x_lvis_in21k-lvis/detic_centernet2_r50_fpn_4x_lvis_in21k-lvis_20230912_040619.log.json)       |
+|     [detic_centernet2_swin-b_fpn_4x_lvis_boxsup](./configs/detic_centernet2_swin-b_fpn_4x_lvis_boxsup.py)     |   40.7   |        40.7        |     38.0      |           35.9           |         [model](https://download.openmmlab.com/mmdetection/v3.0/detic/detic_centernet2_swin-b_fpn_4x_lvis_boxsup/detic_centernet2_swin-b_fpn_4x_lvis_boxsup_20230825_061737-328e85f9.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/detic/detic_centernet2_swin-b_fpn_4x_lvis_boxsup/detic_centernet2_swin-b_fpn_4x_lvis_boxsup_20230825_061737.log.json)         |
+| [detic_centernet2_swin-b_fpn_4x_lvis_in21k-lvis](./configs/detic_centernet2_swin-b_fpn_4x_lvis_in21k-lvis.py) |   41.7   |        41.7        |     41.7      |           41.7           | [model](https://download.openmmlab.com/mmdetection/v3.0/detic/detic_centernet2_swin-b_fpn_4x_lvis_in21k-lvis/detic_centernet2_swin-b_fpn_4x_lvis_in21k-lvis_20230926_235410-0c152391.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/detic/detic_centernet2_swin-b_fpn_4x_lvis_in21k-lvis/detic_centernet2_swin-b_fpn_4x_lvis_in21k-lvis_20230926_235410.log.json) |
+
+#### Open-vocabulary LVIS Results
+
+|                                                  Model (Config)                                                   | mask mAP | mask mAP(official) | mask mAP_rare | mask mAP_rare(officical) |                                                                                                                                                                                         Download                                                                                                                                                                                         |
+| :---------------------------------------------------------------------------------------------------------------: | :------: | :----------------: | :-----------: | :----------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+|     [detic_centernet2_r50_fpn_4x_lvis-base_boxsup](./configs/detic_centernet2_r50_fpn_4x_lvis-base_boxsup.py)     |   30.4   |        30.2        |     16.2      |           16.4           |         [model](https://download.openmmlab.com/mmdetection/v3.0/detic/detic_centernet2_r50_fpn_4x_lvis-base_boxsup/detic_centernet2_r50_fpn_4x_lvis-base_boxsup_20230921_180638-c1685ee2.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/detic/detic_centernet2_r50_fpn_4x_lvis-base_boxsup/detic_centernet2_r50_fpn_4x_lvis-base_boxsup_20230921_180638.log.json)         |
+| [detic_centernet2_r50_fpn_4x_lvis-base_in21k-lvis](./configs/detic_centernet2_r50_fpn_4x_lvis-base_in21k-lvis.py) |   32.6   |        32.4        |     27.4      |           24.9           | [model](https://download.openmmlab.com/mmdetection/v3.0/detic/detic_centernet2_r50_fpn_4x_lvis-base_in21k-lvis/detic_centernet2_r50_fpn_4x_lvis-base_in21k-lvis_20230925_014315-2d2cc8b7.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/detic/detic_centernet2_r50_fpn_4x_lvis-base_in21k-lvis/detic_centernet2_r50_fpn_4x_lvis-base_in21k-lvis_20230925_014315.log.json) |
+
+### Testing
+
+#### Test Command
+
+To evaluate a model with a trained model, run
+
+```shell
+python ./tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE}
+```
+
+#### Open-vocabulary LVIS Results
+
+The models are converted from the official model zoo.
+
+|                                                     Model (Config)                                                      | mask mAP | mask mAP_novel |                                                                                      Download                                                                                       |
+| :---------------------------------------------------------------------------------------------------------------------: | :------: | :------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+|     [detic_centernet2_swin-b_fpn_4x_lvis-base_boxsup](./configs/detic_centernet2_swin-b_fpn_4x_lvis-base_boxsup.py)     |   38.4   |      21.9      |     [model](https://download.openmmlab.com/mmdetection/v3.0/detic/detic_centernet2_swin-b_fpn_4x_lvis-base_boxsup/detic_centernet2_swin-b_fpn_4x_lvis-base_boxsup-481281c8.pth)     |
+| [detic_centernet2_swin-b_fpn_4x_lvis-base_in21k-lvis](./configs/detic_centernet2_swin-b_fpn_4x_lvis-base_in21k-lvis.py) |   40.7   |      34.0      | [model](https://download.openmmlab.com/mmdetection/v3.0/detic/detic_centernet2_swin-b_fpn_4x_lvis-base_in21k-lvis/detic_centernet2_swin-b_fpn_4x_lvis-base_in21k-lvis-ec91245d.pth) |
+
+###### Note:
+
+- The open-vocabulary LVIS setup is LVIS without rare class annotations in training, termed `lvisbase`. We evaluate rare classes as novel classes in testing.
+- ` in21k-lvis` denotes that the model use the overlap classes between ImageNet-21K and LVIS as image-labeled data.
+
+## Citation
+
+If you find Detic is useful in your research or applications, please consider giving a star 🌟 to the [official repository](https://github.com/facebookresearch/Detic) and citing Detic by the following BibTeX entry.
+
+```BibTeX
+@inproceedings{zhou2022detecting,
+  title={Detecting Twenty-thousand Classes using Image-level Supervision},
+  author={Zhou, Xingyi and Girdhar, Rohit and Joulin, Armand and Kr{\"a}henb{\"u}hl, Philipp and Misra, Ishan},
+  booktitle={ECCV},
+  year={2022}
+}
+```
diff --git a/mmdetection/projects/Detic_new/configs/detic_centernet2_r50_fpn_4x_lvis-base_boxsup.py b/mmdetection/projects/Detic_new/configs/detic_centernet2_r50_fpn_4x_lvis-base_boxsup.py
new file mode 100644
index 00000000..8ca57b77
--- /dev/null
+++ b/mmdetection/projects/Detic_new/configs/detic_centernet2_r50_fpn_4x_lvis-base_boxsup.py
@@ -0,0 +1,9 @@
+_base_ = './detic_centernet2_r50_fpn_4x_lvis_boxsup.py'
+
+# 'lvis_v1_train_norare.json' is the annotations of lvis_v1
+# removing the labels of 337 rare-class
+train_dataloader = dict(
+    dataset=dict(
+        type='ClassBalancedDataset',
+        oversample_thr=1e-3,
+        dataset=dict(ann_file='annotations/lvis_v1_train_norare.json')))
diff --git a/mmdetection/projects/Detic_new/configs/detic_centernet2_r50_fpn_4x_lvis-base_in21k-lvis.py b/mmdetection/projects/Detic_new/configs/detic_centernet2_r50_fpn_4x_lvis-base_in21k-lvis.py
new file mode 100644
index 00000000..034acb6e
--- /dev/null
+++ b/mmdetection/projects/Detic_new/configs/detic_centernet2_r50_fpn_4x_lvis-base_in21k-lvis.py
@@ -0,0 +1,93 @@
+_base_ = './detic_centernet2_r50_fpn_4x_lvis_boxsup.py'
+dataset_type = ['LVISV1Dataset', 'ImageNetLVISV1Dataset']
+image_size_det = (640, 640)
+image_size_cls = (320, 320)
+
+# backend = 'pillow'
+backend_args = None
+
+train_pipeline_det = [
+    dict(type='LoadImageFromFile', backend_args=backend_args),
+    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
+    dict(
+        type='RandomResize',
+        scale=image_size_det,
+        ratio_range=(0.1, 2.0),
+        keep_ratio=True),
+    dict(
+        type='RandomCrop',
+        crop_type='absolute_range',
+        crop_size=image_size_det,
+        recompute_bbox=True,
+        allow_negative_crop=True),
+    dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs')
+]
+
+train_pipeline_cls = [
+    dict(type='LoadImageFromFile', backend_args=backend_args),
+    dict(type='LoadAnnotations', with_bbox=False, with_label=True),
+    dict(
+        type='RandomResize',
+        scale=image_size_cls,
+        ratio_range=(0.5, 1.5),
+        keep_ratio=True),
+    dict(
+        type='RandomCrop',
+        crop_type='absolute_range',
+        crop_size=image_size_cls,
+        recompute_bbox=False,
+        bbox_clip_border=False,
+        allow_negative_crop=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs')
+]
+
+# 'lvis_v1_train_norare.json' is the annotations of lvis_v1
+# removing the labels of 337 rare-class
+dataset_det = dict(
+    type='ClassBalancedDataset',
+    oversample_thr=1e-3,
+    dataset=dict(
+        type='LVISV1Dataset',
+        data_root='data/lvis/',
+        ann_file='annotations/lvis_v1_train_norare.json',
+        data_prefix=dict(img=''),
+        filter_cfg=dict(filter_empty_gt=True, min_size=32),
+        pipeline=train_pipeline_det,
+        backend_args=backend_args))
+
+dataset_cls = dict(
+    type='ImageNetLVISV1Dataset',
+    data_root='data/imagenet',
+    ann_file='annotations/imagenet_lvis_image_info.json',
+    data_prefix=dict(img='ImageNet-LVIS/'),
+    pipeline=train_pipeline_cls,
+    backend_args=backend_args)
+
+train_dataloader = dict(
+    _delete_=True,
+    batch_size=[8, 32],
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type='MultiDataSampler', dataset_ratio=[1, 4]),
+    batch_sampler=dict(
+        type='MultiDataAspectRatioBatchSampler', num_datasets=2),
+    dataset=dict(type='ConcatDataset', datasets=[dataset_det, dataset_cls]))
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0,
+        end=1000),
+    dict(
+        type='CosineAnnealingLR',
+        begin=0,
+        by_epoch=False,
+        T_max=90000,
+    )
+]
+
+load_from = './first_stage/detic_centernet2_r50_fpn_4x_lvis-base_boxsup.pth'
+
+find_unused_parameters = True
diff --git a/mmdetection/projects/Detic_new/configs/detic_centernet2_r50_fpn_4x_lvis_boxsup.py b/mmdetection/projects/Detic_new/configs/detic_centernet2_r50_fpn_4x_lvis_boxsup.py
new file mode 100644
index 00000000..a11be374
--- /dev/null
+++ b/mmdetection/projects/Detic_new/configs/detic_centernet2_r50_fpn_4x_lvis_boxsup.py
@@ -0,0 +1,410 @@
+_base_ = 'mmdet::_base_/default_runtime.py'
+dataset_type = 'LVISV1Dataset'
+custom_imports = dict(
+    imports=['projects.Detic_new.detic'], allow_failed_imports=False)
+
+num_classes = 1203
+lvis_cat_frequency_info = 'data/metadata/lvis_v1_train_cat_info.json'
+
+# 'data/metadata/lvis_v1_clip_a+cname.npy' is pre-computed
+# CLIP embeddings for each category
+cls_layer = dict(
+    type='ZeroShotClassifier',
+    zs_weight_path='data/metadata/lvis_v1_clip_a+cname.npy',
+    zs_weight_dim=512,
+    use_bias=0.0,
+    norm_weight=True,
+    norm_temperature=50.0)
+reg_layer = [
+    dict(type='Linear', in_features=1024, out_features=1024),
+    dict(type='ReLU', inplace=True),
+    dict(type='Linear', in_features=1024, out_features=4)
+]
+
+model = dict(
+    type='Detic',
+    data_preprocessor=dict(
+        type='DetDataPreprocessor',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        bgr_to_rgb=True,
+        pad_size_divisor=32),
+    backbone=dict(
+        type='ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(1, 2, 3),
+        norm_cfg=dict(type='BN', requires_grad=False),
+        norm_eval=True,
+        init_cfg=dict(
+            type='Pretrained',
+            checkpoint='https://miil-public-eu.oss-eu-central-1.aliyuncs.com/'
+            'model-zoo/ImageNet_21K_P/models/resnet50_miil_21k.pth')),
+    neck=dict(
+        type='FPN',
+        in_channels=[512, 1024, 2048],
+        out_channels=256,
+        start_level=0,
+        add_extra_convs='on_output',
+        num_outs=5,
+        init_cfg=dict(type='Caffe2Xavier', layer='Conv2d'),
+        relu_before_extra_convs=True),
+    rpn_head=dict(
+        type='CenterNetRPNHead',
+        num_classes=1,
+        in_channels=256,
+        stacked_convs=4,
+        feat_channels=256,
+        strides=[8, 16, 32, 64, 128],
+        conv_bias=True,
+        norm_cfg=dict(type='GN', num_groups=32, requires_grad=True),
+        loss_cls=dict(
+            type='HeatmapFocalLoss',
+            alpha=0.25,
+            beta=4.0,
+            gamma=2.0,
+            pos_weight=0.5,
+            neg_weight=0.5,
+            loss_weight=1.0,
+            ignore_high_fp=0.85,
+        ),
+        loss_bbox=dict(type='GIoULoss', eps=1e-6, loss_weight=1.0),
+    ),
+    roi_head=dict(
+        type='DeticRoIHead',
+        num_stages=3,
+        stage_loss_weights=[1.0, 1.0, 1.0],
+        bbox_roi_extractor=dict(
+            type='SingleRoIExtractor',
+            roi_layer=dict(
+                type='RoIAlign',
+                output_size=7,
+                sampling_ratio=0,
+                use_torchvision=True),
+            out_channels=256,
+            featmap_strides=[8, 16, 32],
+            # approximately equal to
+            # canonical_box_size=224, canonical_level=4 in D2
+            finest_scale=112),
+        bbox_head=[
+            dict(
+                type='DeticBBoxHead',
+                in_channels=256,
+                fc_out_channels=1024,
+                roi_feat_size=7,
+                num_classes=num_classes,
+                cls_predictor_cfg=cls_layer,
+                reg_predictor_cfg=reg_layer,
+                use_fed_loss=True,
+                cat_freq_path=lvis_cat_frequency_info,
+                bbox_coder=dict(
+                    type='DeltaXYWHBBoxCoder',
+                    target_means=[0., 0., 0., 0.],
+                    target_stds=[0.1, 0.1, 0.2, 0.2]),
+                reg_class_agnostic=True,
+                loss_cls=dict(
+                    type='CrossEntropyLoss', use_sigmoid=True,
+                    loss_weight=1.0),
+                loss_bbox=dict(type='SmoothL1Loss', beta=0.1,
+                               loss_weight=1.0)),
+            dict(
+                type='DeticBBoxHead',
+                in_channels=256,
+                fc_out_channels=1024,
+                roi_feat_size=7,
+                num_classes=num_classes,
+                cls_predictor_cfg=cls_layer,
+                reg_predictor_cfg=reg_layer,
+                use_fed_loss=True,
+                cat_freq_path=lvis_cat_frequency_info,
+                bbox_coder=dict(
+                    type='DeltaXYWHBBoxCoder',
+                    target_means=[0., 0., 0., 0.],
+                    target_stds=[0.05, 0.05, 0.1, 0.1]),
+                reg_class_agnostic=True,
+                loss_cls=dict(
+                    type='CrossEntropyLoss', use_sigmoid=True,
+                    loss_weight=1.0),
+                loss_bbox=dict(type='SmoothL1Loss', beta=0.1,
+                               loss_weight=1.0)),
+            dict(
+                type='DeticBBoxHead',
+                in_channels=256,
+                fc_out_channels=1024,
+                roi_feat_size=7,
+                num_classes=num_classes,
+                cls_predictor_cfg=cls_layer,
+                reg_predictor_cfg=reg_layer,
+                use_fed_loss=True,
+                cat_freq_path=lvis_cat_frequency_info,
+                bbox_coder=dict(
+                    type='DeltaXYWHBBoxCoder',
+                    target_means=[0., 0., 0., 0.],
+                    target_stds=[0.033, 0.033, 0.067, 0.067]),
+                reg_class_agnostic=True,
+                loss_cls=dict(
+                    type='CrossEntropyLoss', use_sigmoid=True,
+                    loss_weight=1.0),
+                loss_bbox=dict(type='SmoothL1Loss', beta=0.1, loss_weight=1.0))
+        ],
+        mask_roi_extractor=dict(
+            type='SingleRoIExtractor',
+            roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0),
+            out_channels=256,
+            featmap_strides=[8, 16, 32],
+            # approximately equal to
+            # canonical_box_size=224, canonical_level=4 in D2
+            finest_scale=112),
+        mask_head=dict(
+            type='FCNMaskHead',
+            num_convs=4,
+            in_channels=256,
+            conv_out_channels=256,
+            class_agnostic=True,
+            num_classes=num_classes,
+            loss_mask=dict(
+                type='CrossEntropyLoss', use_mask=True, loss_weight=1.0))),
+    # model training and testing settings
+    train_cfg=dict(
+        rpn=dict(
+            assigner=dict(
+                type='MaxIoUAssigner',
+                pos_iou_thr=0.7,
+                neg_iou_thr=0.3,
+                min_pos_iou=0.3,
+                match_low_quality=True,
+                ignore_iof_thr=-1),
+            sampler=dict(
+                type='RandomSampler',
+                num=256,
+                pos_fraction=0.5,
+                neg_pos_ub=-1,
+                add_gt_as_proposals=False),
+            allowed_border=0,
+            pos_weight=-1,
+            debug=False),
+        rpn_proposal=dict(
+            score_thr=0.0001,
+            nms_pre=4000,
+            max_per_img=2000,
+            nms=dict(type='nms', iou_threshold=0.9),
+            min_bbox_size=0),
+        rcnn=[
+            dict(
+                assigner=dict(
+                    type='MaxIoUAssigner',
+                    pos_iou_thr=0.6,
+                    neg_iou_thr=0.6,
+                    min_pos_iou=0.6,
+                    match_low_quality=False,
+                    ignore_iof_thr=-1),
+                sampler=dict(
+                    type='RandomSampler',
+                    num=512,
+                    pos_fraction=0.25,
+                    neg_pos_ub=-1,
+                    add_gt_as_proposals=True),
+                mask_size=28,
+                pos_weight=-1,
+                debug=False),
+            dict(
+                assigner=dict(
+                    type='MaxIoUAssigner',
+                    pos_iou_thr=0.7,
+                    neg_iou_thr=0.7,
+                    min_pos_iou=0.7,
+                    match_low_quality=False,
+                    ignore_iof_thr=-1),
+                sampler=dict(
+                    type='RandomSampler',
+                    num=512,
+                    pos_fraction=0.25,
+                    neg_pos_ub=-1,
+                    add_gt_as_proposals=False),
+                mask_size=28,
+                pos_weight=-1,
+                debug=False),
+            dict(
+                assigner=dict(
+                    type='MaxIoUAssigner',
+                    pos_iou_thr=0.8,
+                    neg_iou_thr=0.8,
+                    min_pos_iou=0.8,
+                    match_low_quality=False,
+                    ignore_iof_thr=-1),
+                sampler=dict(
+                    type='RandomSampler',
+                    num=512,
+                    pos_fraction=0.25,
+                    neg_pos_ub=-1,
+                    add_gt_as_proposals=False),
+                mask_size=28,
+                pos_weight=-1,
+                debug=False)
+        ]),
+    test_cfg=dict(
+        rpn=dict(
+            score_thr=0.0001,
+            nms_pre=1000,
+            max_per_img=256,
+            nms=dict(type='nms', iou_threshold=0.9),
+            min_bbox_size=0),
+        rcnn=dict(
+            score_thr=0.02,
+            nms=dict(type='nms', iou_threshold=0.5),
+            max_per_img=300,
+            mask_thr_binary=0.5)))
+
+# backend = 'pillow'
+backend_args = None
+
+train_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=backend_args),
+    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
+    dict(
+        type='RandomResize',
+        scale=(640, 640),
+        ratio_range=(0.1, 2.0),
+        keep_ratio=True),
+    dict(
+        type='RandomCrop',
+        crop_type='absolute_range',
+        crop_size=(640, 640),
+        recompute_bbox=True,
+        allow_negative_crop=True),
+    dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs')
+]
+
+test_pipeline = [
+    dict(
+        type='LoadImageFromFile',
+        backend_args=backend_args,
+        imdecode_backend=backend_args),
+    dict(
+        type='Resize',
+        scale=(1333, 800),
+        keep_ratio=True,
+        backend=backend_args),
+    dict(
+        type='LoadAnnotations',
+        with_bbox=True,
+        with_mask=True,
+        poly2mask=False),
+    dict(
+        type='PackDetInputs',
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor', 'text', 'custom_entities'))
+]
+
+val_pipeline = [
+    dict(
+        type='LoadImageFromFile',
+        backend_args=backend_args,
+        imdecode_backend=backend_args),
+    dict(
+        type='Resize',
+        scale=(1333, 800),
+        keep_ratio=True,
+        backend=backend_args),
+    dict(
+        type='LoadAnnotations',
+        with_bbox=True,
+        with_mask=True,
+        poly2mask=False),
+    dict(
+        type='PackDetInputs',
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+
+train_dataloader = dict(
+    batch_size=8,
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    batch_sampler=dict(type='AspectRatioBatchSampler'),
+    dataset=dict(
+        type='ClassBalancedDataset',
+        oversample_thr=1e-3,
+        dataset=dict(
+            type='LVISV1Dataset',
+            data_root='data/lvis/',
+            ann_file='annotations/lvis_v1_train_norare.json',
+            data_prefix=dict(img=''),
+            filter_cfg=dict(filter_empty_gt=True, min_size=32),
+            pipeline=train_pipeline,
+            backend_args=backend_args)))
+
+val_dataloader = dict(
+    batch_size=8,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    pin_memory=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='LVISV1Dataset',
+        data_root='data/lvis/',
+        ann_file='annotations/lvis_v1_val.json',
+        data_prefix=dict(img=''),
+        pipeline=val_pipeline,
+        return_classes=False))
+
+test_dataloader = dict(
+    batch_size=8,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    pin_memory=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='LVISV1Dataset',
+        data_root='data/lvis/',
+        ann_file='annotations/lvis_v1_val.json',
+        data_prefix=dict(img=''),
+        pipeline=test_pipeline,
+        return_classes=True))
+
+val_evaluator = dict(
+    type='LVISMetric',
+    ann_file='data/lvis/annotations/lvis_v1_val.json',
+    metric=['bbox', 'segm'])
+test_evaluator = val_evaluator
+
+# training schedule for 90k with batch_size of 64
+# with total batch_size of 16, 90k iters is equivalent to '1x' (12 epochs)
+# with total batch_size of 64, 90k iters is equivalent to '4x'
+max_iter = 90000
+train_cfg = dict(
+    type='IterBasedTrainLoop', max_iters=max_iter, val_interval=90000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+
+# Enable automatic-mixed-precision training with AmpOptimWrapper.
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='AdamW', lr=0.0002, weight_decay=0.0001),
+    paramwise_cfg=dict(norm_decay_mult=0.),
+    clip_grad=dict(max_norm=1.0, norm_type=2))
+
+param_scheduler = [
+    dict(
+        type='LinearLR',
+        start_factor=0.0001,
+        by_epoch=False,
+        begin=0,
+        end=10000),
+    dict(
+        type='CosineAnnealingLR',
+        begin=0,
+        by_epoch=False,
+        T_max=max_iter,
+    )
+]
+
+# only keep latest 5 checkpoints
+default_hooks = dict(
+    checkpoint=dict(by_epoch=False, interval=30000, max_keep_ckpts=5),
+    logger=dict(type='LoggerHook', interval=50))
diff --git a/mmdetection/projects/Detic_new/configs/detic_centernet2_r50_fpn_4x_lvis_in21k-lvis.py b/mmdetection/projects/Detic_new/configs/detic_centernet2_r50_fpn_4x_lvis_in21k-lvis.py
new file mode 100644
index 00000000..ce97ed6d
--- /dev/null
+++ b/mmdetection/projects/Detic_new/configs/detic_centernet2_r50_fpn_4x_lvis_in21k-lvis.py
@@ -0,0 +1,91 @@
+_base_ = './detic_centernet2_r50_fpn_4x_lvis_boxsup.py'
+dataset_type = ['LVISV1Dataset', 'ImageNetLVISV1Dataset']
+image_size_det = (640, 640)
+image_size_cls = (320, 320)
+
+# backend = 'pillow'
+backend_args = None
+
+train_pipeline_det = [
+    dict(type='LoadImageFromFile', backend_args=backend_args),
+    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
+    dict(
+        type='RandomResize',
+        scale=image_size_det,
+        ratio_range=(0.1, 2.0),
+        keep_ratio=True),
+    dict(
+        type='RandomCrop',
+        crop_type='absolute_range',
+        crop_size=image_size_det,
+        recompute_bbox=True,
+        allow_negative_crop=True),
+    dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs')
+]
+
+train_pipeline_cls = [
+    dict(type='LoadImageFromFile', backend_args=backend_args),
+    dict(type='LoadAnnotations', with_bbox=False, with_label=True),
+    dict(
+        type='RandomResize',
+        scale=image_size_cls,
+        ratio_range=(0.5, 1.5),
+        keep_ratio=True),
+    dict(
+        type='RandomCrop',
+        crop_type='absolute_range',
+        crop_size=image_size_cls,
+        recompute_bbox=False,
+        bbox_clip_border=False,
+        allow_negative_crop=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs')
+]
+
+dataset_det = dict(
+    type='ClassBalancedDataset',
+    oversample_thr=1e-3,
+    dataset=dict(
+        type='LVISV1Dataset',
+        data_root='data/lvis/',
+        ann_file='annotations/lvis_v1_train.json',
+        data_prefix=dict(img=''),
+        filter_cfg=dict(filter_empty_gt=True, min_size=32),
+        pipeline=train_pipeline_det,
+        backend_args=backend_args))
+
+dataset_cls = dict(
+    type='ImageNetLVISV1Dataset',
+    data_root='data/imagenet',
+    ann_file='annotations/imagenet_lvis_image_info.json',
+    data_prefix=dict(img='ImageNet-LVIS/'),
+    pipeline=train_pipeline_cls,
+    backend_args=backend_args)
+
+train_dataloader = dict(
+    _delete_=True,
+    batch_size=[8, 32],
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type='MultiDataSampler', dataset_ratio=[1, 4]),
+    batch_sampler=dict(
+        type='MultiDataAspectRatioBatchSampler', num_datasets=2),
+    dataset=dict(type='ConcatDataset', datasets=[dataset_det, dataset_cls]))
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0,
+        end=1000),
+    dict(
+        type='CosineAnnealingLR',
+        begin=0,
+        by_epoch=False,
+        T_max=90000,
+    )
+]
+
+load_from = './first_stage/detic_centernet2_r50_fpn_4x_lvis_boxsup.pth'
+
+find_unused_parameters = True
diff --git a/mmdetection/projects/Detic_new/configs/detic_centernet2_swin-b_fpn_4x_lvis-base_boxsup.py b/mmdetection/projects/Detic_new/configs/detic_centernet2_swin-b_fpn_4x_lvis-base_boxsup.py
new file mode 100644
index 00000000..efedd111
--- /dev/null
+++ b/mmdetection/projects/Detic_new/configs/detic_centernet2_swin-b_fpn_4x_lvis-base_boxsup.py
@@ -0,0 +1,9 @@
+_base_ = './detic_centernet2_swin-b_fpn_4x_lvis_boxsup.py'
+
+# 'lvis_v1_train_norare.json' is the annotations of lvis_v1
+# removing the labels of 337 rare-class
+train_dataloader = dict(
+    dataset=dict(
+        type='ClassBalancedDataset',
+        oversample_thr=1e-3,
+        dataset=dict(ann_file='annotations/lvis_v1_train_norare.json')))
diff --git a/mmdetection/projects/Detic_new/configs/detic_centernet2_swin-b_fpn_4x_lvis-base_in21k-lvis.py b/mmdetection/projects/Detic_new/configs/detic_centernet2_swin-b_fpn_4x_lvis-base_in21k-lvis.py
new file mode 100644
index 00000000..1df70970
--- /dev/null
+++ b/mmdetection/projects/Detic_new/configs/detic_centernet2_swin-b_fpn_4x_lvis-base_in21k-lvis.py
@@ -0,0 +1,118 @@
+_base_ = './detic_centernet2_r50_fpn_4x_lvis_in21k-lvis.py'
+
+image_size_det = (896, 896)
+image_size_cls = (448, 448)
+
+model = dict(
+    backbone=dict(
+        _delete_=True,
+        type='SwinTransformer',
+        embed_dims=128,
+        depths=[2, 2, 18, 2],
+        num_heads=[4, 8, 16, 32],
+        window_size=7,
+        mlp_ratio=4,
+        qkv_bias=True,
+        qk_scale=None,
+        drop_rate=0.,
+        attn_drop_rate=0.,
+        drop_path_rate=0.3,
+        patch_norm=True,
+        out_indices=(1, 2, 3),
+        with_cp=False),
+    neck=dict(in_channels=[256, 512, 1024]))
+
+backend_args = None
+train_pipeline_det = [
+    dict(type='LoadImageFromFile', backend_args=backend_args),
+    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
+    dict(
+        type='RandomResize',
+        scale=image_size_det,
+        ratio_range=(0.1, 2.0),
+        keep_ratio=True),
+    dict(
+        type='RandomCrop',
+        crop_type='absolute_range',
+        crop_size=image_size_det,
+        recompute_bbox=True,
+        allow_negative_crop=True),
+    dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs')
+]
+
+train_pipeline_cls = [
+    dict(type='LoadImageFromFile', backend_args=backend_args),
+    dict(type='LoadAnnotations', with_bbox=False, with_label=True),
+    dict(
+        type='RandomResize',
+        scale=image_size_cls,
+        ratio_range=(0.5, 1.5),
+        keep_ratio=True),
+    dict(
+        type='RandomCrop',
+        crop_type='absolute_range',
+        crop_size=image_size_cls,
+        recompute_bbox=False,
+        bbox_clip_border=False,
+        allow_negative_crop=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs')
+]
+
+# 'lvis_v1_train_norare.json' is the annotations of lvis_v1
+# removing the labels of 337 rare-class
+dataset_det = dict(
+    type='ClassBalancedDataset',
+    oversample_thr=1e-3,
+    dataset=dict(
+        type='LVISV1Dataset',
+        data_root='data/lvis/',
+        ann_file='annotations/lvis_v1_train_norare.json',
+        data_prefix=dict(img=''),
+        filter_cfg=dict(filter_empty_gt=True, min_size=32),
+        pipeline=train_pipeline_det,
+        backend_args=backend_args))
+
+dataset_cls = dict(
+    type='ImageNetLVISV1Dataset',
+    data_root='data/imagenet',
+    ann_file='annotations/imagenet_lvis_image_info.json',
+    data_prefix=dict(img='ImageNet-LVIS/'),
+    pipeline=train_pipeline_cls,
+    backend_args=backend_args)
+
+train_dataloader = dict(
+    _delete_=True,
+    batch_size=[4, 16],
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type='MultiDataSampler', dataset_ratio=[1, 4]),
+    batch_sampler=dict(
+        type='MultiDataAspectRatioBatchSampler', num_datasets=2),
+    dataset=dict(type='ConcatDataset', datasets=[dataset_det, dataset_cls]))
+
+# training schedule for 180k
+max_iter = 180000
+train_cfg = dict(
+    type='IterBasedTrainLoop', max_iters=max_iter, val_interval=180000)
+
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0001))
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0,
+        end=1000),
+    dict(
+        type='CosineAnnealingLR',
+        begin=0,
+        by_epoch=False,
+        T_max=max_iter,
+    )
+]
+
+load_from = './first_stage/detic_centernet2_swin-b_fpn_4x_lvis-base_boxsup.pth'
+find_unused_parameters = True
diff --git a/mmdetection/projects/Detic_new/configs/detic_centernet2_swin-b_fpn_4x_lvis_boxsup.py b/mmdetection/projects/Detic_new/configs/detic_centernet2_swin-b_fpn_4x_lvis_boxsup.py
new file mode 100644
index 00000000..ce04a815
--- /dev/null
+++ b/mmdetection/projects/Detic_new/configs/detic_centernet2_swin-b_fpn_4x_lvis_boxsup.py
@@ -0,0 +1,78 @@
+_base_ = './detic_centernet2_r50_fpn_4x_lvis_boxsup.py'
+
+model = dict(
+    backbone=dict(
+        _delete_=True,
+        type='SwinTransformer',
+        embed_dims=128,
+        depths=[2, 2, 18, 2],
+        num_heads=[4, 8, 16, 32],
+        window_size=7,
+        mlp_ratio=4,
+        qkv_bias=True,
+        qk_scale=None,
+        drop_rate=0.,
+        attn_drop_rate=0.,
+        drop_path_rate=0.3,
+        patch_norm=True,
+        out_indices=(1, 2, 3),
+        with_cp=False,
+        convert_weights=True,
+        init_cfg=dict(
+            type='Pretrained',
+            checkpoint='https://github.com/SwinTransformer/storage/releases/'
+            'download/v1.0.0/swin_base_patch4_window7_224_22k.pth')),
+    neck=dict(in_channels=[256, 512, 1024]))
+
+# backend = 'pillow'
+backend_args = None
+
+train_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=backend_args),
+    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
+    dict(
+        type='RandomResize',
+        scale=(896, 896),
+        ratio_range=(0.1, 2.0),
+        keep_ratio=True),
+    dict(
+        type='RandomCrop',
+        crop_type='absolute_range',
+        crop_size=(896, 896),
+        recompute_bbox=True,
+        allow_negative_crop=True),
+    dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs')
+]
+
+train_dataloader = dict(
+    dataset=dict(
+        type='ClassBalancedDataset',
+        oversample_thr=1e-3,
+        dataset=dict(pipeline=train_pipeline)))
+
+# training schedule for 180k
+max_iter = 180000
+train_cfg = dict(
+    type='IterBasedTrainLoop', max_iters=max_iter, val_interval=180000)
+
+# Enable automatic-mixed-precision training with AmpOptimWrapper.
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0001))
+
+param_scheduler = [
+    dict(
+        type='LinearLR',
+        start_factor=0.0001,
+        by_epoch=False,
+        begin=0,
+        end=10000),
+    dict(
+        type='CosineAnnealingLR',
+        begin=0,
+        by_epoch=False,
+        T_max=max_iter,
+    )
+]
diff --git a/mmdetection/projects/Detic_new/configs/detic_centernet2_swin-b_fpn_4x_lvis_coco_in21k.py b/mmdetection/projects/Detic_new/configs/detic_centernet2_swin-b_fpn_4x_lvis_coco_in21k.py
new file mode 100644
index 00000000..a9ab2c69
--- /dev/null
+++ b/mmdetection/projects/Detic_new/configs/detic_centernet2_swin-b_fpn_4x_lvis_coco_in21k.py
@@ -0,0 +1,2 @@
+# not support training, only for testing
+_base_ = './detic_centernet2_swin-b_fpn_4x_lvis_in21k-lvis.py'
diff --git a/mmdetection/projects/Detic_new/configs/detic_centernet2_swin-b_fpn_4x_lvis_in21k-lvis.py b/mmdetection/projects/Detic_new/configs/detic_centernet2_swin-b_fpn_4x_lvis_in21k-lvis.py
new file mode 100644
index 00000000..de358ac3
--- /dev/null
+++ b/mmdetection/projects/Detic_new/configs/detic_centernet2_swin-b_fpn_4x_lvis_in21k-lvis.py
@@ -0,0 +1,116 @@
+_base_ = './detic_centernet2_r50_fpn_4x_lvis_in21k-lvis.py'
+
+image_size_det = (896, 896)
+image_size_cls = (448, 448)
+
+model = dict(
+    backbone=dict(
+        _delete_=True,
+        type='SwinTransformer',
+        embed_dims=128,
+        depths=[2, 2, 18, 2],
+        num_heads=[4, 8, 16, 32],
+        window_size=7,
+        mlp_ratio=4,
+        qkv_bias=True,
+        qk_scale=None,
+        drop_rate=0.,
+        attn_drop_rate=0.,
+        drop_path_rate=0.3,
+        patch_norm=True,
+        out_indices=(1, 2, 3),
+        with_cp=False),
+    neck=dict(in_channels=[256, 512, 1024]))
+
+backend_args = None
+train_pipeline_det = [
+    dict(type='LoadImageFromFile', backend_args=backend_args),
+    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
+    dict(
+        type='RandomResize',
+        scale=image_size_det,
+        ratio_range=(0.1, 2.0),
+        keep_ratio=True),
+    dict(
+        type='RandomCrop',
+        crop_type='absolute_range',
+        crop_size=image_size_det,
+        recompute_bbox=True,
+        allow_negative_crop=True),
+    dict(type='FilterAnnotations', min_gt_bbox_wh=(1e-2, 1e-2)),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs')
+]
+
+train_pipeline_cls = [
+    dict(type='LoadImageFromFile', backend_args=backend_args),
+    dict(type='LoadAnnotations', with_bbox=False, with_label=True),
+    dict(
+        type='RandomResize',
+        scale=image_size_cls,
+        ratio_range=(0.5, 1.5),
+        keep_ratio=True),
+    dict(
+        type='RandomCrop',
+        crop_type='absolute_range',
+        crop_size=image_size_cls,
+        recompute_bbox=False,
+        bbox_clip_border=False,
+        allow_negative_crop=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs')
+]
+
+dataset_det = dict(
+    type='ClassBalancedDataset',
+    oversample_thr=1e-3,
+    dataset=dict(
+        type='LVISV1Dataset',
+        data_root='data/lvis/',
+        ann_file='annotations/lvis_v1_train.json',
+        data_prefix=dict(img=''),
+        filter_cfg=dict(filter_empty_gt=True, min_size=32),
+        pipeline=train_pipeline_det,
+        backend_args=backend_args))
+
+dataset_cls = dict(
+    type='ImageNetLVISV1Dataset',
+    data_root='data/imagenet',
+    ann_file='annotations/imagenet_lvis_image_info.json',
+    data_prefix=dict(img='ImageNet-LVIS/'),
+    pipeline=train_pipeline_cls,
+    backend_args=backend_args)
+
+train_dataloader = dict(
+    _delete_=True,
+    batch_size=[4, 16],
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type='MultiDataSampler', dataset_ratio=[1, 4]),
+    batch_sampler=dict(
+        type='MultiDataAspectRatioBatchSampler', num_datasets=2),
+    dataset=dict(type='ConcatDataset', datasets=[dataset_det, dataset_cls]))
+
+# training schedule for 180k
+max_iter = 180000
+train_cfg = dict(
+    type='IterBasedTrainLoop', max_iters=max_iter, val_interval=180000)
+
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0001))
+
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0,
+        end=1000),
+    dict(
+        type='CosineAnnealingLR',
+        begin=0,
+        by_epoch=False,
+        T_max=max_iter,
+    )
+]
+
+load_from = './first_stage/detic_centernet2_swin-b_fpn_4x_lvis_boxsup.pth'
+find_unused_parameters = True
diff --git a/mmdetection/projects/Detic_new/detic/__init__.py b/mmdetection/projects/Detic_new/detic/__init__.py
new file mode 100644
index 00000000..e4b0d7bb
--- /dev/null
+++ b/mmdetection/projects/Detic_new/detic/__init__.py
@@ -0,0 +1,13 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .centernet_rpn_head import CenterNetRPNHead
+from .detic import Detic
+from .detic_bbox_head import DeticBBoxHead
+from .detic_roi_head import DeticRoIHead
+from .heatmap_focal_loss import HeatmapFocalLoss
+from .imagenet_lvis import ImageNetLVISV1Dataset
+from .zero_shot_classifier import ZeroShotClassifier
+
+__all__ = [
+    'CenterNetRPNHead', 'Detic', 'DeticBBoxHead', 'DeticRoIHead',
+    'ZeroShotClassifier', 'HeatmapFocalLoss', 'ImageNetLVISV1Dataset'
+]
diff --git a/mmdetection/projects/Detic_new/detic/centernet_rpn_head.py b/mmdetection/projects/Detic_new/detic/centernet_rpn_head.py
new file mode 100644
index 00000000..62987282
--- /dev/null
+++ b/mmdetection/projects/Detic_new/detic/centernet_rpn_head.py
@@ -0,0 +1,573 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+from typing import Dict, List, Optional, Sequence, Tuple
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import Scale
+from mmengine import ConfigDict
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.models.dense_heads import CenterNetUpdateHead
+from mmdet.models.utils import unpack_gt_instances
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.structures.bbox import bbox2distance
+from mmdet.utils import (ConfigType, InstanceList, OptConfigType,
+                         OptInstanceList, reduce_mean)
+from .iou_loss import IOULoss
+
+# from .heatmap_focal_loss import binary_heatmap_focal_loss_jit
+INF = 1000000000
+RangeType = Sequence[Tuple[int, int]]
+
+
+@MODELS.register_module()
+class CenterNetRPNHead(CenterNetUpdateHead):
+    """CenterNetUpdateHead is an improved version of CenterNet in CenterNet2.
+
+    Paper link ``_.
+    Args:
+        num_classes (int): Number of categories excluding the background
+            category.
+        in_channels (int): Number of channel in the input feature map.
+        regress_ranges (Sequence[Tuple[int, int]]): Regress range of multiple
+            level points.
+        hm_min_radius (int): Heatmap target minimum radius of cls branch.
+            Defaults to 4.
+        hm_min_overlap (float): Heatmap target minimum overlap of cls branch.
+            Defaults to 0.8.
+        more_pos_thresh (float): The filtering threshold when the cls branch
+            adds more positive samples. Defaults to 0.2.
+        more_pos_topk (int): The maximum number of additional positive samples
+            added to each gt. Defaults to 9.
+        soft_weight_on_reg (bool): Whether to use the soft target of the
+            cls branch as the soft weight of the bbox branch.
+            Defaults to False.
+        loss_cls (:obj:`ConfigDict` or dict): Config of cls loss. Defaults to
+            dict(type='GaussianFocalLoss', loss_weight=1.0)
+        loss_bbox (:obj:`ConfigDict` or dict): Config of bbox loss. Defaults to
+             dict(type='GIoULoss', loss_weight=2.0).
+        norm_cfg (:obj:`ConfigDict` or dict, optional): dictionary to construct
+            and config norm layer.  Defaults to
+            ``norm_cfg=dict(type='GN', num_groups=32, requires_grad=True)``.
+        train_cfg (:obj:`ConfigDict` or dict, optional): Training config.
+            Unused in CenterNet. Reserved for compatibility with
+            SingleStageDetector.
+        test_cfg (:obj:`ConfigDict` or dict, optional): Testing config
+            of CenterNet.
+    """
+
+    def __init__(self,
+                 num_classes: int,
+                 in_channels: int,
+                 regress_ranges: RangeType = ((0, 80), (64, 160), (128, 320),
+                                              (256, 640), (512, INF)),
+                 hm_min_radius: int = 4,
+                 hm_min_overlap: float = 0.8,
+                 more_pos: bool = False,
+                 more_pos_thresh: float = 0.2,
+                 more_pos_topk: int = 9,
+                 soft_weight_on_reg: bool = False,
+                 not_clamp_box: bool = False,
+                 loss_cls: ConfigType = dict(
+                     type='HeatmapFocalLoss',
+                     alpha=0.25,
+                     beta=4.0,
+                     gamma=2.0,
+                     pos_weight=1.0,
+                     neg_weight=1.0,
+                     sigmoid_clamp=1e-4,
+                     ignore_high_fp=-1.0,
+                     loss_weight=1.0,
+                 ),
+                 loss_bbox: ConfigType = dict(
+                     type='GIoULoss', loss_weight=2.0),
+                 norm_cfg: OptConfigType = dict(
+                     type='GN', num_groups=32, requires_grad=True),
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 **kwargs) -> None:
+        super().__init__(
+            num_classes=num_classes,
+            in_channels=in_channels,
+            # loss_bbox=loss_bbox,
+            loss_cls=loss_cls,
+            norm_cfg=norm_cfg,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            **kwargs)
+        self.soft_weight_on_reg = soft_weight_on_reg
+        self.hm_min_radius = hm_min_radius
+        self.more_pos_thresh = more_pos_thresh
+        self.more_pos_topk = more_pos_topk
+        self.more_pos = more_pos
+        self.not_clamp_box = not_clamp_box
+        self.delta = (1 - hm_min_overlap) / (1 + hm_min_overlap)
+        self.loss_bbox = IOULoss('giou')
+
+        # GaussianFocalLoss must be sigmoid mode
+        self.use_sigmoid_cls = True
+        self.cls_out_channels = num_classes
+
+        self.regress_ranges = regress_ranges
+        self.scales = nn.ModuleList([Scale(1.0) for _ in self.strides])
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        self._init_reg_convs()
+        self._init_predictor()
+
+    def forward_single(self, x: Tensor, scale: Scale,
+                       stride: int) -> Tuple[Tensor, Tensor]:
+        """Forward features of a single scale level.
+
+        Args:
+            x (Tensor): FPN feature maps of the specified stride.
+            scale (:obj:`mmcv.cnn.Scale`): Learnable scale module to resize
+                the bbox prediction.
+            stride (int): The corresponding stride for feature maps.
+
+        Returns:
+            tuple: scores for each class, bbox predictions of
+            input feature maps.
+        """
+        for m in self.reg_convs:
+            x = m(x)
+        cls_score = self.conv_cls(x)
+        bbox_pred = self.conv_reg(x)
+        # scale the bbox_pred of different level
+        # float to avoid overflow when enabling FP16
+        bbox_pred = scale(bbox_pred).float()
+        # bbox_pred needed for gradient computation has been modified
+        # by F.relu(bbox_pred) when run with PyTorch 1.10. So replace
+        # F.relu(bbox_pred) with bbox_pred.clamp(min=0)
+        bbox_pred = bbox_pred.clamp(min=0)
+        return cls_score, bbox_pred  # score aligned, box larger
+
+    def loss_by_feat(
+        self,
+        cls_scores: List[Tensor],
+        bbox_preds: List[Tensor],
+        batch_gt_instances: InstanceList,
+        batch_img_metas: List[dict],
+        batch_gt_instances_ignore: OptInstanceList = None
+    ) -> Dict[str, Tensor]:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level,
+                each is a 4D-tensor, the channel number is num_classes.
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level, each is a 4D-tensor, the channel number is 4.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance.  It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+
+        num_imgs = cls_scores[0].size(0)
+        assert len(cls_scores) == len(bbox_preds)
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        all_level_points = self.prior_generator.grid_priors(
+            featmap_sizes,
+            dtype=bbox_preds[0].dtype,
+            device=bbox_preds[0].device)
+
+        # 1 flatten outputs
+        flatten_cls_scores = [
+            cls_score.permute(0, 2, 3, 1).reshape(-1, self.cls_out_channels)
+            for cls_score in cls_scores
+        ]
+        flatten_bbox_preds = [
+            bbox_pred.permute(0, 2, 3, 1).reshape(-1, 4)
+            for bbox_pred in bbox_preds
+        ]
+        flatten_cls_scores = torch.cat(flatten_cls_scores)
+        flatten_bbox_preds = torch.cat(flatten_bbox_preds)
+
+        # repeat points to align with bbox_preds
+        flatten_points = torch.cat(
+            [points.repeat(num_imgs, 1) for points in all_level_points])
+
+        assert (torch.isfinite(flatten_bbox_preds).all().item())
+
+        # 2 calc reg and cls branch targets
+        cls_targets, bbox_targets = self.get_targets(all_level_points,
+                                                     batch_gt_instances)
+
+        # 3 pos index for cls branch
+        featmap_sizes = flatten_points.new_tensor(featmap_sizes)
+
+        if self.more_pos:
+            pos_inds, cls_labels = self.add_cls_pos_inds(
+                flatten_points, flatten_bbox_preds, featmap_sizes,
+                batch_gt_instances)
+        else:
+            pos_inds = self._get_label_inds(batch_gt_instances,
+                                            batch_img_metas, featmap_sizes)
+
+        # 4 calc cls loss
+        if pos_inds is None:
+            # num_gts=0
+            num_pos_cls = bbox_preds[0].new_tensor(0, dtype=torch.float)
+        else:
+            num_pos_cls = bbox_preds[0].new_tensor(
+                len(pos_inds), dtype=torch.float)
+        num_pos_cls = max(reduce_mean(num_pos_cls), 1.0)
+
+        cat_agn_cls_targets = cls_targets.max(dim=1)[0]  # M
+
+        cls_pos_loss, cls_neg_loss = self.loss_cls(
+            flatten_cls_scores.squeeze(1), cat_agn_cls_targets, pos_inds,
+            num_pos_cls)
+
+        # 5 calc reg loss
+        pos_bbox_inds = torch.nonzero(
+            bbox_targets.max(dim=1)[0] >= 0).squeeze(1)
+        pos_bbox_preds = flatten_bbox_preds[pos_bbox_inds]
+        pos_bbox_targets = bbox_targets[pos_bbox_inds]
+
+        bbox_weight_map = cls_targets.max(dim=1)[0]
+        bbox_weight_map = bbox_weight_map[pos_bbox_inds]
+        bbox_weight_map = bbox_weight_map if self.soft_weight_on_reg \
+            else torch.ones_like(bbox_weight_map)
+
+        num_pos_bbox = max(reduce_mean(bbox_weight_map.sum()), 1.0)
+
+        if len(pos_bbox_inds) > 0:
+            bbox_loss = self.loss_bbox(
+                pos_bbox_preds,
+                pos_bbox_targets,
+                bbox_weight_map,
+                reduction='sum') / num_pos_bbox
+        else:
+            bbox_loss = flatten_bbox_preds.sum() * 0
+
+        return dict(
+            loss_bbox=bbox_loss,
+            loss_cls_pos=cls_pos_loss,
+            loss_cls_neg=cls_neg_loss)
+
+    def loss_and_predict(
+        self,
+        x: Tuple[Tensor],
+        batch_data_samples: SampleList,
+        proposal_cfg: Optional[ConfigDict] = None
+    ) -> Tuple[dict, InstanceList]:
+        """Perform forward propagation of the head, then calculate loss and
+        predictions from the features and data samples.
+
+        Args:
+            x (tuple[Tensor]): Features from FPN.
+            batch_data_samples (list[:obj:`DetDataSample`]): Each item contains
+                the meta information of each image and corresponding
+                annotations.
+            proposal_cfg (ConfigDict, optional): Test / postprocessing
+                configuration, if None, test_cfg would be used.
+                Defaults to None.
+
+        Returns:
+            tuple: the return value is a tuple contains:
+
+                - losses: (dict[str, Tensor]): A dictionary of loss components.
+                - predictions (list[:obj:`InstanceData`]): Detection
+                  results of each image after the post process.
+        """
+        outputs = unpack_gt_instances(batch_data_samples)
+        (batch_gt_instances, batch_gt_instances_ignore,
+         batch_img_metas) = outputs
+
+        outs = self(x)
+
+        loss_inputs = outs + (batch_gt_instances, batch_img_metas,
+                              batch_gt_instances_ignore)
+        losses = self.loss_by_feat(*loss_inputs)
+        predictions = self.predict_by_feat(
+            *outs, batch_img_metas=batch_img_metas, cfg=proposal_cfg)
+        return losses, predictions
+
+    def _predict_by_feat_single(self,
+                                cls_score_list: List[Tensor],
+                                bbox_pred_list: List[Tensor],
+                                score_factor_list: List[Tensor],
+                                mlvl_priors: List[Tensor],
+                                img_meta: dict,
+                                cfg: ConfigDict,
+                                rescale: bool = False,
+                                with_nms: bool = True) -> InstanceData:
+        """Transform a single image's features extracted from the head into
+        bbox results.
+
+        Args:
+            cls_score_list (list[Tensor]): Box scores from all scale
+                levels of a single image, each item has shape
+                (num_priors * num_classes, H, W).
+            bbox_pred_list (list[Tensor]): Box energies / deltas from
+                all scale levels of a single image, each item has shape
+                (num_priors * 4, H, W).
+            score_factor_list (list[Tensor]): Score factor from all scale
+                levels of a single image, each item has shape
+                (num_priors * 1, H, W).
+            mlvl_priors (list[Tensor]): Each element in the list is
+                the priors of a single level in feature pyramid. In all
+                anchor-based methods, it has shape (num_priors, 4). In
+                all anchor-free methods, it has shape (num_priors, 2)
+                when `with_stride=True`, otherwise it still has shape
+                (num_priors, 4).
+            img_meta (dict): Image meta info.
+            cfg (mmengine.Config): Test / postprocessing configuration,
+                if None, test_cfg would be used.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            with_nms (bool): If True, do nms before return boxes.
+                Defaults to True.
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+
+        cfg = self.test_cfg if cfg is None else cfg
+        cfg = copy.deepcopy(cfg)
+        nms_pre = cfg.get('nms_pre', -1)
+
+        mlvl_bbox_preds = []
+        mlvl_valid_priors = []
+        mlvl_scores = []
+        mlvl_labels = []
+
+        for level_idx, (cls_score, bbox_pred, score_factor, priors) in \
+                enumerate(zip(cls_score_list, bbox_pred_list,
+                              score_factor_list, mlvl_priors)):
+
+            assert cls_score.size()[-2:] == bbox_pred.size()[-2:]
+
+            bbox_pred = bbox_pred * self.strides[level_idx]
+
+            dim = self.bbox_coder.encode_size
+            bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, dim)
+            cls_score = cls_score.permute(1, 2,
+                                          0).reshape(-1, self.cls_out_channels)
+            heatmap = cls_score.sigmoid()
+            score_thr = cfg.get('score_thr', 0)
+
+            candidate_inds = heatmap > score_thr  # 0.05
+            pre_nms_top_n = candidate_inds.sum()  # N
+            pre_nms_top_n = pre_nms_top_n.clamp(max=nms_pre)  # N
+
+            heatmap = heatmap[candidate_inds]  # n
+
+            candidate_nonzeros = candidate_inds.nonzero()  # n
+            box_loc = candidate_nonzeros[:, 0]  # n
+            labels = candidate_nonzeros[:, 1]  # n
+
+            bbox_pred = bbox_pred[box_loc]  # n x 4
+            per_grids = priors[box_loc]  # n x 2
+
+            if candidate_inds.sum().item() > pre_nms_top_n.item():
+                heatmap, top_k_indices = \
+                    heatmap.topk(pre_nms_top_n, sorted=False)
+                labels = labels[top_k_indices]
+                bbox_pred = bbox_pred[top_k_indices]
+                per_grids = per_grids[top_k_indices]
+
+            bboxes = torch.stack([
+                per_grids[:, 0] - bbox_pred[:, 0],
+                per_grids[:, 1] - bbox_pred[:, 1],
+                per_grids[:, 0] + bbox_pred[:, 2],
+                per_grids[:, 1] + bbox_pred[:, 3],
+            ],
+                                 dim=1)  # n x 4
+
+            # avoid invalid boxes in RoI heads
+            bboxes[:, 2] = torch.max(bboxes[:, 2], bboxes[:, 0] + 0.01)
+            bboxes[:, 3] = torch.max(bboxes[:, 3], bboxes[:, 1] + 0.01)
+
+            # bboxes = self.bbox_coder.decode(per_grids, bbox_pred)
+            # # avoid invalid boxes in RoI heads
+            # bboxes[:, 2] = torch.max(bboxes[:, 2], bboxes[:, 0] + 0.01)
+            # bboxes[:, 3] = torch.max(bboxes[:, 3], bboxes[:, 1] + 0.01)
+
+            mlvl_bbox_preds.append(bboxes)
+            mlvl_valid_priors.append(priors)
+            mlvl_scores.append(torch.sqrt(heatmap))
+            mlvl_labels.append(labels)
+
+        results = InstanceData()
+        results.bboxes = torch.cat(mlvl_bbox_preds)
+        results.scores = torch.cat(mlvl_scores)
+        results.labels = torch.cat(mlvl_labels)
+
+        return self._bbox_post_process(
+            results=results,
+            cfg=cfg,
+            rescale=rescale,
+            with_nms=with_nms,
+            img_meta=img_meta)
+
+    def _get_label_inds(self, batch_gt_instances, batch_img_metas,
+                        shapes_per_level):
+        '''
+        Inputs:
+            batch_gt_instances: [n_i], sum n_i = N
+            shapes_per_level: L x 2 [(h_l, w_l)]_L
+        Returns:
+            pos_inds: N'
+            labels: N'
+        '''
+        pos_inds = []
+        L = len(self.strides)
+        B = len(batch_gt_instances)
+        shapes_per_level = shapes_per_level.long()
+        loc_per_level = (shapes_per_level[:, 0] *
+                         shapes_per_level[:, 1]).long()  # L
+        level_bases = []
+        s = 0
+        for i in range(L):
+            level_bases.append(s)
+            s = s + B * loc_per_level[i]
+        level_bases = shapes_per_level.new_tensor(level_bases).long()  # L
+        strides_default = shapes_per_level.new_tensor(
+            self.strides).float()  # L
+        for im_i in range(B):
+            targets_per_im = batch_gt_instances[im_i]
+            if hasattr(targets_per_im, 'bboxes'):
+                bboxes = targets_per_im.bboxes  # n x 4
+            else:
+                bboxes = targets_per_im.labels.new_tensor(
+                    [], dtype=torch.float).reshape(-1, 4)
+            n = bboxes.shape[0]
+            centers = ((bboxes[:, [0, 1]] + bboxes[:, [2, 3]]) / 2)  # n x 2
+            centers = centers.view(n, 1, 2).expand(n, L, 2).contiguous()
+            if self.not_clamp_box:
+                h, w = batch_img_metas[im_i]._image_size
+                centers[:, :, 0].clamp_(min=0).clamp_(max=w - 1)
+                centers[:, :, 1].clamp_(min=0).clamp_(max=h - 1)
+            strides = strides_default.view(1, L, 1).expand(n, L, 2)
+            centers_inds = (centers / strides).long()  # n x L x 2
+            Ws = shapes_per_level[:, 1].view(1, L).expand(n, L)
+            pos_ind = level_bases.view(1, L).expand(n, L) \
+                + im_i * loc_per_level.view(1, L).expand(n, L) \
+                + centers_inds[:, :, 1] * Ws + centers_inds[:, :, 0]  # n x L
+            is_cared_in_the_level = self.assign_fpn_level(bboxes)
+            pos_ind = pos_ind[is_cared_in_the_level].view(-1)
+
+            pos_inds.append(pos_ind)  # n'
+        pos_inds = torch.cat(pos_inds, dim=0).long()
+        return pos_inds  # N, N
+
+    def assign_fpn_level(self, boxes):
+        '''
+        Inputs:
+            boxes: n x 4
+            size_ranges: L x 2
+        Return:
+            is_cared_in_the_level: n x L
+        '''
+        size_ranges = boxes.new_tensor(self.regress_ranges).view(
+            len(self.regress_ranges), 2)  # L x 2
+        crit = ((boxes[:, 2:] - boxes[:, :2])**2).sum(dim=1)**0.5 / 2  # n
+        n, L = crit.shape[0], size_ranges.shape[0]
+        crit = crit.view(n, 1).expand(n, L)
+        size_ranges_expand = size_ranges.view(1, L, 2).expand(n, L, 2)
+        is_cared_in_the_level = (crit >= size_ranges_expand[:, :, 0]) & \
+            (crit <= size_ranges_expand[:, :, 1])
+        return is_cared_in_the_level
+
+    def _get_targets_single(self, gt_instances: InstanceData, points: Tensor,
+                            regress_ranges: Tensor,
+                            strides: Tensor) -> Tuple[Tensor, Tensor]:
+        """Compute classification and bbox targets for a single image."""
+        num_points = points.size(0)
+        num_gts = len(gt_instances)
+        gt_labels = gt_instances.labels
+
+        if not hasattr(gt_instances, 'bboxes'):
+            gt_bboxes = gt_labels.new_tensor([], dtype=torch.float)
+        else:
+            gt_bboxes = gt_instances.bboxes
+
+        if not hasattr(gt_instances, 'bboxes') or num_gts == 0:
+            return gt_labels.new_full((num_points,
+                                       self.num_classes),
+                                      self.num_classes,
+                                      dtype=torch.float), \
+                   gt_bboxes.new_full((num_points, 4), -1)
+
+        # Calculate the regression tblr target corresponding to all points
+        points = points[:, None].expand(num_points, num_gts, 2)
+        gt_bboxes = gt_bboxes[None].expand(num_points, num_gts, 4)
+        strides = strides[:, None, None].expand(num_points, num_gts, 2)
+
+        bbox_target = bbox2distance(points, gt_bboxes)  # M x N x 4
+
+        # condition1: inside a gt bbox
+        inside_gt_bbox_mask = bbox_target.min(dim=2)[0] > 0  # M x N
+
+        # condition2: Calculate the nearest points from
+        # the upper, lower, left and right ranges from
+        # the center of the gt bbox
+        centers = ((gt_bboxes[..., [0, 1]] + gt_bboxes[..., [2, 3]]) / 2)
+        centers_discret = ((centers / strides).int() * strides).float() + \
+            strides / 2
+
+        centers_discret_dist = points - centers_discret
+        dist_x = centers_discret_dist[..., 0].abs()
+        dist_y = centers_discret_dist[..., 1].abs()
+        inside_gt_center3x3_mask = (dist_x <= strides[..., 0]) & \
+                                   (dist_y <= strides[..., 0])
+
+        # condition3： limit the regression range for each location
+        bbox_target_wh = bbox_target[..., :2] + bbox_target[..., 2:]
+        crit = (bbox_target_wh**2).sum(dim=2)**0.5 / 2
+        inside_fpn_level_mask = (crit >= regress_ranges[:, [0]]) & \
+                                (crit <= regress_ranges[:, [1]])
+        bbox_target_mask = inside_gt_bbox_mask & \
+            inside_gt_center3x3_mask & \
+            inside_fpn_level_mask
+
+        # Calculate the distance weight map
+        gt_center_peak_mask = ((centers_discret_dist**2).sum(dim=2) == 0)
+        weighted_dist = ((points - centers)**2).sum(dim=2)  # M x N
+        weighted_dist[gt_center_peak_mask] = 0
+
+        areas = (gt_bboxes[..., 2] - gt_bboxes[..., 0]) * (
+            gt_bboxes[..., 3] - gt_bboxes[..., 1])
+        radius = self.delta**2 * 2 * areas
+        radius = torch.clamp(radius, min=self.hm_min_radius**2)
+        weighted_dist = weighted_dist / radius
+
+        # Calculate bbox_target
+        bbox_weighted_dist = weighted_dist.clone()
+        bbox_weighted_dist[bbox_target_mask == 0] = INF * 1.0
+        min_dist, min_inds = bbox_weighted_dist.min(dim=1)
+        bbox_target = bbox_target[range(len(bbox_target)),
+                                  min_inds]  # M x N x 4 --> M x 4
+        bbox_target[min_dist == INF] = -INF
+
+        # Convert to feature map scale
+        bbox_target /= strides[:, 0, :].repeat(1, 2)
+
+        # Calculate cls_target
+        cls_target = self._create_heatmaps_from_dist(weighted_dist, gt_labels)
+
+        return cls_target, bbox_target
diff --git a/mmdetection/projects/Detic_new/detic/detic.py b/mmdetection/projects/Detic_new/detic/detic.py
new file mode 100644
index 00000000..7028690a
--- /dev/null
+++ b/mmdetection/projects/Detic_new/detic/detic.py
@@ -0,0 +1,274 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+from typing import List, Union
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmengine.logging import print_log
+from torch import Tensor
+
+from mmdet.datasets import LVISV1Dataset
+from mmdet.models.detectors.cascade_rcnn import CascadeRCNN
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+
+
+class CLIPTextEncoder(nn.Module):
+
+    def __init__(self, model_name='ViT-B/32'):
+        super().__init__()
+        import clip
+        from clip.simple_tokenizer import SimpleTokenizer
+        self.tokenizer = SimpleTokenizer()
+        pretrained_model, _ = clip.load(model_name, device='cpu')
+        self.clip = pretrained_model
+
+    @property
+    def device(self):
+        return self.clip.device
+
+    @property
+    def dtype(self):
+        return self.clip.dtype
+
+    def tokenize(self,
+                 texts: Union[str, List[str]],
+                 context_length: int = 77) -> torch.LongTensor:
+        if isinstance(texts, str):
+            texts = [texts]
+
+        sot_token = self.tokenizer.encoder['<|startoftext|>']
+        eot_token = self.tokenizer.encoder['<|endoftext|>']
+        all_tokens = [[sot_token] + self.tokenizer.encode(text) + [eot_token]
+                      for text in texts]
+        result = torch.zeros(len(all_tokens), context_length, dtype=torch.long)
+
+        for i, tokens in enumerate(all_tokens):
+            if len(tokens) > context_length:
+                st = torch.randint(len(tokens) - context_length + 1,
+                                   (1, ))[0].item()
+                tokens = tokens[st:st + context_length]
+            result[i, :len(tokens)] = torch.tensor(tokens)
+
+        return result
+
+    def forward(self, text):
+        text = self.tokenize(text)
+        text_features = self.clip.encode_text(text)
+        return text_features
+
+
+def get_class_weight(original_caption, prompt_prefix='a '):
+    if isinstance(original_caption, str):
+        if original_caption == 'coco':
+            from mmdet.datasets import CocoDataset
+            class_names = CocoDataset.METAINFO['classes']
+        elif original_caption == 'cityscapes':
+            from mmdet.datasets import CityscapesDataset
+            class_names = CityscapesDataset.METAINFO['classes']
+        elif original_caption == 'voc':
+            from mmdet.datasets import VOCDataset
+            class_names = VOCDataset.METAINFO['classes']
+        elif original_caption == 'openimages':
+            from mmdet.datasets import OpenImagesDataset
+            class_names = OpenImagesDataset.METAINFO['classes']
+        elif original_caption == 'lvis':
+            from mmdet.datasets import LVISV1Dataset
+            class_names = LVISV1Dataset.METAINFO['classes']
+        else:
+            if not original_caption.endswith('.'):
+                original_caption = original_caption + ' . '
+            original_caption = original_caption.split(' . ')
+            class_names = list(filter(lambda x: len(x) > 0, original_caption))
+
+    # for test.py
+    else:
+        class_names = list(original_caption)
+
+    text_encoder = CLIPTextEncoder()
+    text_encoder.eval()
+    texts = [prompt_prefix + x for x in class_names]
+    print_log(f'Computing text embeddings for {len(class_names)} classes.')
+    embeddings = text_encoder(texts).detach().permute(1, 0).contiguous().cpu()
+    return class_names, embeddings
+
+
+def reset_cls_layer_weight(roi_head, weight):
+    if type(weight) == str:
+        print_log(f'Resetting cls_layer_weight from file: {weight}')
+        zs_weight = torch.tensor(
+            np.load(weight),
+            dtype=torch.float32).permute(1, 0).contiguous()  # D x C
+    else:
+        zs_weight = weight
+    zs_weight = torch.cat(
+        [zs_weight, zs_weight.new_zeros(
+            (zs_weight.shape[0], 1))], dim=1)  # D x (C + 1)
+    zs_weight = F.normalize(zs_weight, p=2, dim=0)
+    zs_weight = zs_weight.to('cuda')
+    num_classes = zs_weight.shape[-1]
+
+    for bbox_head in roi_head.bbox_head:
+        bbox_head.num_classes = num_classes
+        del bbox_head.fc_cls.zs_weight
+        bbox_head.fc_cls.zs_weight = zs_weight
+
+
+@MODELS.register_module()
+class Detic(CascadeRCNN):
+
+    def __init__(self,
+                 with_image_labels: bool = False,
+                 sync_caption_batch: bool = False,
+                 fp16: bool = False,
+                 roi_head_name: str = '',
+                 cap_batch_ratio: int = 4,
+                 with_caption: bool = False,
+                 dynamic_classifier: bool = False,
+                 **kwargs) -> None:
+        super().__init__(**kwargs)
+
+        self._entities = LVISV1Dataset.METAINFO['classes']
+        self._text_prompts = None
+        # Turn on co-training with classification data
+        self.with_image_labels = with_image_labels
+        # Caption losses
+        self.with_caption = with_caption
+        # synchronize across GPUs to enlarge # "classes"
+        self.sync_caption_batch = sync_caption_batch
+        # Ratio between detection data and caption data
+        self.cap_batch_ratio = cap_batch_ratio
+        self.fp16 = fp16
+        self.roi_head_name = roi_head_name
+        # dynamic class sampling when training with 21K classes,
+        # Federated loss is enabled when DYNAMIC_CLASSIFIER is on
+        self.dynamic_classifier = dynamic_classifier
+        self.return_proposal = False
+        if self.dynamic_classifier:
+            self.freq_weight = kwargs.pop('freq_weight')
+            self.num_classes = kwargs.pop('num_classes')
+            self.num_sample_cats = kwargs.pop('num_sample_cats')
+
+    def loss(self, batch_inputs: Tensor,
+             batch_data_samples: SampleList) -> dict:
+        """Calculate losses from a batch of inputs and data samples.
+
+        Args:
+            batch_inputs (Tensor): Input images of shape (N, C, H, W).
+                These should usually be mean centered and std scaled.
+            batch_data_samples (List[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            dict: A dictionary of loss components
+        """
+
+        x = self.extract_feat(batch_inputs)
+        losses = dict()
+
+        # RPN forward and loss
+        if self.with_rpn:
+            proposal_cfg = self.train_cfg.get('rpn_proposal',
+                                              self.test_cfg.rpn)
+            rpn_data_samples = copy.deepcopy(batch_data_samples)
+            # set cat_id of gt_labels to 0 in RPN
+            for data_sample in rpn_data_samples:
+                data_sample.gt_instances.labels = \
+                    torch.zeros_like(data_sample.gt_instances.labels)
+
+            rpn_losses, rpn_results_list = self.rpn_head.loss_and_predict(
+                x, rpn_data_samples, proposal_cfg=proposal_cfg)
+
+            # avoid get same name with roi_head loss
+            keys = rpn_losses.keys()
+            for key in list(keys):
+                if 'loss' in key and 'rpn' not in key:
+                    rpn_losses[f'rpn_{key}'] = rpn_losses.pop(key)
+            losses.update(rpn_losses)
+            # if not hasattr(batch_data_samples[0].gt_instances, 'bboxes'):
+            #     losses.update({k: v * 0 for k, v in rpn_losses.items()})
+            # else:
+            #     losses.update(rpn_losses)
+        else:
+            assert batch_data_samples[0].get('proposals', None) is not None
+            # use pre-defined proposals in InstanceData for the second stage
+            # to extract ROI features.
+            rpn_results_list = [
+                data_sample.proposals for data_sample in batch_data_samples
+            ]
+
+        roi_losses = self.roi_head.loss(x, rpn_results_list,
+                                        batch_data_samples)
+
+        losses.update(roi_losses)
+
+        return losses
+
+    def predict(self,
+                batch_inputs: Tensor,
+                batch_data_samples: SampleList,
+                rescale: bool = True) -> SampleList:
+        """Predict results from a batch of inputs and data samples with post-
+        processing.
+
+        Args:
+            batch_inputs (Tensor): Inputs with shape (N, C, H, W).
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            rescale (bool): Whether to rescale the results.
+                Defaults to True.
+
+        Returns:
+            list[:obj:`DetDataSample`]: Return the detection results of the
+            input images. The returns value is DetDataSample,
+            which usually contain 'pred_instances'. And the
+            ``pred_instances`` usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                    (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                    (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                    the last dimension 4 arrange as (x1, y1, x2, y2).
+                - masks (Tensor): Has a shape (num_instances, H, W).
+        """
+        # For single image inference
+        if 'custom_entities' in batch_data_samples[0]:
+            text_prompts = batch_data_samples[0].text
+            if text_prompts != self._text_prompts:
+                self._text_prompts = text_prompts
+                class_names, zs_weight = get_class_weight(text_prompts)
+                self._entities = class_names
+                reset_cls_layer_weight(self.roi_head, zs_weight)
+
+        assert self.with_bbox, 'Bbox head must be implemented.'
+
+        x = self.extract_feat(batch_inputs)
+
+        # If there are no pre-defined proposals, use RPN to get proposals
+        if batch_data_samples[0].get('proposals', None) is None:
+            rpn_results_list = self.rpn_head.predict(
+                x, batch_data_samples, rescale=False)
+        else:
+            rpn_results_list = [
+                data_sample.proposals for data_sample in batch_data_samples
+            ]
+
+        results_list = self.roi_head.predict(
+            x, rpn_results_list, batch_data_samples, rescale=rescale)
+
+        for data_sample, pred_instances in zip(batch_data_samples,
+                                               results_list):
+            if len(pred_instances) > 0:
+                label_names = []
+                for labels in pred_instances.labels:
+                    label_names.append(self._entities[labels])
+                # for visualization
+                pred_instances.label_names = label_names
+            data_sample.pred_instances = pred_instances
+
+        return batch_data_samples
diff --git a/mmdetection/projects/Detic_new/detic/detic_bbox_head.py b/mmdetection/projects/Detic_new/detic/detic_bbox_head.py
new file mode 100644
index 00000000..8779494b
--- /dev/null
+++ b/mmdetection/projects/Detic_new/detic/detic_bbox_head.py
@@ -0,0 +1,434 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import json
+from typing import List, Optional
+
+import torch
+from mmengine.config import ConfigDict
+from mmengine.structures import InstanceData
+from torch import Tensor
+from torch.nn import functional as F
+
+from mmdet.models.layers import multiclass_nms
+from mmdet.models.losses import accuracy
+from mmdet.models.roi_heads.bbox_heads import Shared2FCBBoxHead
+from mmdet.models.utils import empty_instances
+from mmdet.registry import MODELS
+from mmdet.structures.bbox import get_box_tensor, scale_boxes
+from mmdet.utils import ConfigType, InstanceList
+
+
+def load_class_freq(path='datasets/metadata/lvis_v1_train_cat_info.json',
+                    freq_weight=0.5):
+    cat_info = json.load(open(path, 'r'))
+    cat_info = torch.tensor(
+        [c['image_count'] for c in sorted(cat_info, key=lambda x: x['id'])])
+    freq_weight = cat_info.float()**freq_weight
+    return freq_weight
+
+
+def get_fed_loss_inds(labels, num_sample_cats, C, weight=None):
+
+    appeared = torch.unique(labels)  # C'
+    prob = appeared.new_ones(C + 1).float()
+    prob[-1] = 0
+    if len(appeared) < num_sample_cats:
+        if weight is not None:
+            prob[:C] = weight.float().clone()
+        prob[appeared] = 0
+        more_appeared = torch.multinomial(
+            prob, num_sample_cats - len(appeared), replacement=False)
+        appeared = torch.cat([appeared, more_appeared])
+    return appeared
+
+
+@MODELS.register_module()
+class DeticBBoxHead(Shared2FCBBoxHead):
+
+    def __init__(self,
+                 image_loss_weight: float = 0.1,
+                 use_fed_loss: bool = False,
+                 cat_freq_path: str = '',
+                 fed_loss_freq_weight: float = 0.5,
+                 fed_loss_num_cat: int = 50,
+                 cls_predictor_cfg: ConfigType = dict(
+                     type='ZeroShotClassifier'),
+                 *args,
+                 **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        # reconstruct fc_cls and fc_reg since input channels are changed
+        assert self.with_cls
+
+        self.cls_predictor_cfg = cls_predictor_cfg
+        cls_channels = self.num_classes
+        self.cls_predictor_cfg.update(
+            in_features=self.cls_last_dim, out_features=cls_channels)
+        self.fc_cls = MODELS.build(self.cls_predictor_cfg)
+
+        self.init_cfg += [
+            dict(type='Caffe2Xavier', override=dict(name='reg_fcs'))
+        ]
+
+        self.image_loss_weight = image_loss_weight
+        self.use_fed_loss = use_fed_loss
+        self.cat_freq_path = cat_freq_path
+        self.fed_loss_freq_weight = fed_loss_freq_weight
+        self.fed_loss_num_cat = fed_loss_num_cat
+
+        if self.use_fed_loss:
+            freq_weight = load_class_freq(cat_freq_path, fed_loss_freq_weight)
+            self.register_buffer('freq_weight', freq_weight)
+        else:
+            self.freq_weight = None
+
+    def _predict_by_feat_single(
+            self,
+            roi: Tensor,
+            cls_score: Tensor,
+            bbox_pred: Tensor,
+            img_meta: dict,
+            rescale: bool = False,
+            rcnn_test_cfg: Optional[ConfigDict] = None) -> InstanceData:
+        """Transform a single image's features extracted from the head into
+        bbox results.
+
+        Args:
+            roi (Tensor): Boxes to be transformed. Has shape (num_boxes, 5).
+                last dimension 5 arrange as (batch_index, x1, y1, x2, y2).
+            cls_score (Tensor): Box scores, has shape
+                (num_boxes, num_classes + 1).
+            bbox_pred (Tensor): Box energies / deltas.
+                has shape (num_boxes, num_classes * 4).
+            img_meta (dict): image information.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+            rcnn_test_cfg (obj:`ConfigDict`): `test_cfg` of Bbox Head.
+                Defaults to None
+
+        Returns:
+            :obj:`InstanceData`: Detection results of each image\
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        results = InstanceData()
+        if roi.shape[0] == 0:
+            return empty_instances([img_meta],
+                                   roi.device,
+                                   task_type='bbox',
+                                   instance_results=[results],
+                                   box_type=self.predict_box_type,
+                                   use_box_type=False,
+                                   num_classes=self.num_classes,
+                                   score_per_cls=rcnn_test_cfg is None)[0]
+        scores = cls_score
+        img_shape = img_meta['img_shape']
+        num_rois = roi.size(0)
+
+        num_classes = 1 if self.reg_class_agnostic else self.num_classes
+        roi = roi.repeat_interleave(num_classes, dim=0)
+        bbox_pred = bbox_pred.view(-1, self.bbox_coder.encode_size)
+        bboxes = self.bbox_coder.decode(
+            roi[..., 1:], bbox_pred, max_shape=img_shape)
+
+        if rescale and bboxes.size(0) > 0:
+            assert img_meta.get('scale_factor') is not None
+            scale_factor = [1 / s for s in img_meta['scale_factor']]
+            bboxes = scale_boxes(bboxes, scale_factor)
+
+        # Get the inside tensor when `bboxes` is a box type
+        bboxes = get_box_tensor(bboxes)
+        box_dim = bboxes.size(-1)
+        bboxes = bboxes.view(num_rois, -1)
+
+        if rcnn_test_cfg is None:
+            # This means that it is aug test.
+            # It needs to return the raw results without nms.
+            results.bboxes = bboxes
+            results.scores = scores
+        else:
+            det_bboxes, det_labels = multiclass_nms(
+                bboxes,
+                scores,
+                rcnn_test_cfg.score_thr,
+                rcnn_test_cfg.nms,
+                rcnn_test_cfg.max_per_img,
+                box_dim=box_dim)
+            results.bboxes = det_bboxes[:, :-1]
+            results.scores = det_bboxes[:, -1]
+            results.labels = det_labels
+        return results
+
+    def loss(self,
+             cls_score: Tensor,
+             bbox_pred: Tensor,
+             rois: Tensor,
+             labels: Tensor,
+             label_weights: Tensor,
+             bbox_targets: Tensor,
+             bbox_weights: Tensor,
+             reduction_override: Optional[str] = None) -> dict:
+        """Calculate the loss based on the network predictions and targets.
+
+        Args:
+            cls_score (Tensor): Classification prediction
+                results of all class, has shape
+                (batch_size * num_proposals_single_image, num_classes)
+            bbox_pred (Tensor): Regression prediction results,
+                has shape
+                (batch_size * num_proposals_single_image, 4), the last
+                dimension 4 represents [tl_x, tl_y, br_x, br_y].
+            rois (Tensor): RoIs with the shape
+                (batch_size * num_proposals_single_image, 5) where the first
+                column indicates batch id of each RoI.
+            labels (Tensor): Gt_labels for all proposals in a batch, has
+                shape (batch_size * num_proposals_single_image, ).
+            label_weights (Tensor): Labels_weights for all proposals in a
+                batch, has shape (batch_size * num_proposals_single_image, ).
+            bbox_targets (Tensor): Regression target for all proposals in a
+                batch, has shape (batch_size * num_proposals_single_image, 4),
+                the last dimension 4 represents [tl_x, tl_y, br_x, br_y].
+            bbox_weights (Tensor): Regression weights for all proposals in a
+                batch, has shape (batch_size * num_proposals_single_image, 4).
+            reduction_override (str, optional): The reduction
+                method used to override the original reduction
+                method of the loss. Options are "none",
+                "mean" and "sum". Defaults to None,
+
+        Returns:
+            dict: A dictionary of loss.
+        """
+
+        losses = dict()
+
+        if cls_score is not None:
+
+            if cls_score.numel() > 0:
+                loss_cls_ = self.sigmoid_cross_entropy_loss(cls_score, labels)
+                if isinstance(loss_cls_, dict):
+                    losses.update(loss_cls_)
+                else:
+                    losses['loss_cls'] = loss_cls_
+                if self.custom_activation:
+                    acc_ = self.loss_cls.get_accuracy(cls_score, labels)
+                    losses.update(acc_)
+                else:
+                    losses['acc'] = accuracy(cls_score, labels)
+        if bbox_pred is not None:
+            bg_class_ind = self.num_classes
+            # 0~self.num_classes-1 are FG, self.num_classes is BG
+            pos_inds = (labels >= 0) & (labels < bg_class_ind)
+            # do not perform bounding box regression for BG anymore.
+            if pos_inds.any():
+                if self.reg_decoded_bbox:
+                    # When the regression loss (e.g. `IouLoss`,
+                    # `GIouLoss`, `DIouLoss`) is applied directly on
+                    # the decoded bounding boxes, it decodes the
+                    # already encoded coordinates to absolute format.
+                    bbox_pred = self.bbox_coder.decode(rois[:, 1:], bbox_pred)
+                    bbox_pred = get_box_tensor(bbox_pred)
+                if self.reg_class_agnostic:
+                    pos_bbox_pred = bbox_pred.view(
+                        bbox_pred.size(0), -1)[pos_inds.type(torch.bool)]
+                else:
+                    pos_bbox_pred = bbox_pred.view(
+                        bbox_pred.size(0), self.num_classes,
+                        -1)[pos_inds.type(torch.bool),
+                            labels[pos_inds.type(torch.bool)]]
+
+                losses['loss_bbox'] = self.loss_bbox(
+                    pos_bbox_pred,
+                    bbox_targets[pos_inds.type(torch.bool)],
+                    bbox_weights[pos_inds.type(torch.bool)],
+                    avg_factor=bbox_targets.size(0),
+                    reduction_override=reduction_override)
+            else:
+                losses['loss_bbox'] = bbox_pred[pos_inds].sum()
+        return losses
+
+    def sigmoid_cross_entropy_loss(self, cls_score, labels):
+        if cls_score.numel() == 0:
+            return cls_score.new_zeros(
+                [1])[0]  # This is more robust than .sum() * 0.
+        B = cls_score.shape[0]
+        C = cls_score.shape[1] - 1
+
+        target = cls_score.new_zeros(B, C + 1)
+        target[range(len(labels)), labels] = 1  # B x (C + 1)
+        target = target[:, :C]  # B x C
+
+        weight = 1
+        if self.use_fed_loss and (self.freq_weight is not None):  # fedloss
+            appeared = get_fed_loss_inds(
+                labels,
+                num_sample_cats=self.fed_loss_num_cat,
+                C=C,
+                weight=self.freq_weight)
+            appeared_mask = appeared.new_zeros(C + 1)
+            appeared_mask[appeared] = 1  # C + 1
+            appeared_mask = appeared_mask[:C]
+            fed_w = appeared_mask.view(1, C).expand(B, C)
+            weight = weight * fed_w.float()
+        # if self.ignore_zero_cats and (self.freq_weight is not None):
+        #     w = (self.freq_weight.view(-1) > 1e-4).float()
+        #     weight = weight * w.view(1, C).expand(B, C)
+        #     # import pdb; pdb.set_trace()
+
+        cls_loss = F.binary_cross_entropy_with_logits(
+            cls_score[:, :-1], target, reduction='none')  # B x C
+        loss = torch.sum(cls_loss * weight) / B
+        return loss
+
+    def image_label_losses(self, cls_score, sampling_results, image_labels):
+        '''
+        Inputs:
+            cls_score: N x (C + 1)
+            image_labels B x 1
+        '''
+        num_inst_per_image = [
+            len(pred_instances) for pred_instances in sampling_results
+        ]
+        cls_score = cls_score.split(
+            num_inst_per_image, dim=0)  # B x n x (C + 1)
+        B = len(cls_score)
+        loss = cls_score[0].new_zeros([1])[0]
+        for (score, labels, pred_instances) in zip(cls_score, image_labels,
+                                                   sampling_results):
+            if score.shape[0] == 0:
+                loss += score.new_zeros([1])[0]
+                continue
+            # find out max-size idx
+            bboxes = pred_instances.bboxes
+            areas = (bboxes[:, 2] - bboxes[:, 0]) * (
+                bboxes[:, 3] - bboxes[:, 1])
+            idx = areas[:-1].argmax().item() if len(areas) > 1 else 0
+
+            for label in labels:
+                target = score.new_zeros(score.shape[1])
+                target[label] = 1
+                loss_i = F.binary_cross_entropy_with_logits(
+                    score[idx], target, reduction='sum')
+                loss += loss_i / len(labels)
+        loss = loss / B
+
+        return loss * self.image_loss_weight
+
+    def refine_bboxes(self, bbox_results: dict,
+                      batch_img_metas: List[dict]) -> InstanceList:
+        """Refine bboxes during training.
+
+        Args:
+            bbox_results (dict): Usually is a dictionary with keys:
+
+                - `cls_score` (Tensor): Classification scores.
+                - `bbox_pred` (Tensor): Box energies / deltas.
+                - `rois` (Tensor): RoIs with the shape (n, 5) where the first
+                  column indicates batch id of each RoI.
+                - `bbox_targets` (tuple):  Ground truth for proposals in a
+                  single image. Containing the following list of Tensors:
+                  (labels, label_weights, bbox_targets, bbox_weights)
+            batch_img_metas (List[dict]): List of image information.
+
+        Returns:
+            list[:obj:`InstanceData`]: Refined bboxes of each image.
+
+        Example:
+            >>> # xdoctest: +REQUIRES(module:kwarray)
+            >>> import numpy as np
+            >>> from mmdet.models.task_modules.samplers.
+            ... sampling_result import random_boxes
+            >>> from mmdet.models.task_modules.samplers import SamplingResult
+            >>> self = BBoxHead(reg_class_agnostic=True)
+            >>> n_roi = 2
+            >>> n_img = 4
+            >>> scale = 512
+            >>> rng = np.random.RandomState(0)
+            ... batch_img_metas = [{'img_shape': (scale, scale)}
+            >>>                     for _ in range(n_img)]
+            >>> sampling_results = [SamplingResult.random(rng=10)
+            ...                     for _ in range(n_img)]
+            >>> # Create rois in the expected format
+            >>> roi_boxes = random_boxes(n_roi, scale=scale, rng=rng)
+            >>> img_ids = torch.randint(0, n_img, (n_roi,))
+            >>> img_ids = img_ids.float()
+            >>> rois = torch.cat([img_ids[:, None], roi_boxes], dim=1)
+            >>> # Create other args
+            >>> labels = torch.randint(0, 81, (scale,)).long()
+            >>> bbox_preds = random_boxes(n_roi, scale=scale, rng=rng)
+            >>> cls_score = torch.randn((scale, 81))
+            ... # For each image, pretend random positive boxes are gts
+            >>> bbox_targets = (labels, None, None, None)
+            ... bbox_results = dict(rois=rois, bbox_pred=bbox_preds,
+            ...                     cls_score=cls_score,
+            ...                     bbox_targets=bbox_targets)
+            >>> bboxes_list = self.refine_bboxes(sampling_results,
+            ...                                  bbox_results,
+            ...                                  batch_img_metas)
+            >>> print(bboxes_list)
+        """
+        # bbox_targets is a tuple
+        cls_scores = bbox_results['cls_score']
+        rois = bbox_results['rois']
+        bbox_preds = bbox_results['bbox_pred']
+        if self.custom_activation:
+            # TODO: Create a SeasawBBoxHead to simplified logic in BBoxHead
+            cls_scores = self.loss_cls.get_activation(cls_scores)
+        if cls_scores.numel() == 0:
+            return None
+        if cls_scores.shape[-1] == self.num_classes + 1:
+            # remove background class
+            cls_scores = cls_scores[:, :-1]
+        elif cls_scores.shape[-1] != self.num_classes:
+            raise ValueError('The last dim of `cls_scores` should equal to '
+                             '`num_classes` or `num_classes + 1`,'
+                             f'but got {cls_scores.shape[-1]}.')
+
+        img_ids = rois[:, 0].long().unique(sorted=True)
+        assert img_ids.numel() <= len(batch_img_metas)
+
+        results_list = []
+        for i in range(len(batch_img_metas)):
+            inds = torch.nonzero(
+                rois[:, 0] == i, as_tuple=False).squeeze(dim=1)
+
+            bboxes_ = rois[inds, 1:]
+            bbox_pred_ = bbox_preds[inds]
+            img_meta_ = batch_img_metas[i]
+
+            bboxes = self.regress(bboxes_, bbox_pred_, img_meta_)
+
+            # don't filter gt bboxes like D2
+            results = InstanceData(bboxes=bboxes)
+            results_list.append(results)
+
+        return results_list
+
+    def regress(self, priors: Tensor, bbox_pred: Tensor,
+                img_meta: dict) -> Tensor:
+        """Regress the bbox for the predicted class. Used in Cascade R-CNN.
+
+        Args:
+            priors (Tensor): Priors from `rpn_head` or last stage
+                `bbox_head`, has shape (num_proposals, 4).
+            label (Tensor): Only used when `self.reg_class_agnostic`
+                is False, has shape (num_proposals, ).
+            bbox_pred (Tensor): Regression prediction of
+                current stage `bbox_head`. When `self.reg_class_agnostic`
+                is False, it has shape (n, num_classes * 4), otherwise
+                it has shape (n, 4).
+            img_meta (dict): Image meta info.
+
+        Returns:
+            Tensor: Regressed bboxes, the same shape as input rois.
+        """
+        reg_dim = self.bbox_coder.encode_size
+        assert bbox_pred.size()[1] == reg_dim
+
+        max_shape = img_meta['img_shape']
+        regressed_bboxes = self.bbox_coder.decode(
+            priors, bbox_pred, max_shape=max_shape)
+        return regressed_bboxes
diff --git a/mmdetection/projects/Detic_new/detic/detic_roi_head.py b/mmdetection/projects/Detic_new/detic/detic_roi_head.py
new file mode 100644
index 00000000..35785cda
--- /dev/null
+++ b/mmdetection/projects/Detic_new/detic/detic_roi_head.py
@@ -0,0 +1,440 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Sequence, Tuple
+
+import torch
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.models.roi_heads import CascadeRoIHead
+from mmdet.models.task_modules.samplers import SamplingResult
+from mmdet.models.test_time_augs import merge_aug_masks
+from mmdet.models.utils import empty_instances, unpack_gt_instances
+from mmdet.registry import MODELS
+from mmdet.structures import SampleList
+from mmdet.structures.bbox import bbox2roi, get_box_tensor
+from mmdet.utils import ConfigType, InstanceList, MultiConfig
+
+
+@MODELS.register_module()
+class DeticRoIHead(CascadeRoIHead):
+
+    def __init__(
+        self,
+        *,
+        mult_proposal_score: bool = False,
+        with_image_labels: bool = False,
+        add_image_box: bool = False,
+        image_box_size: float = 1.0,
+        ws_num_props: int = 128,
+        add_feature_to_prop: bool = False,
+        mask_weight: float = 1.0,
+        one_class_per_proposal: bool = False,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.mult_proposal_score = mult_proposal_score
+        self.with_image_labels = with_image_labels
+        self.add_image_box = add_image_box
+        self.image_box_size = image_box_size
+        self.ws_num_props = ws_num_props
+        self.add_feature_to_prop = add_feature_to_prop
+        self.mask_weight = mask_weight
+        self.one_class_per_proposal = one_class_per_proposal
+
+    def init_mask_head(self, mask_roi_extractor: MultiConfig,
+                       mask_head: MultiConfig) -> None:
+        """Initialize mask head and mask roi extractor.
+
+        Args:
+            mask_head (dict): Config of mask in mask head.
+            mask_roi_extractor (:obj:`ConfigDict`, dict or list):
+                Config of mask roi extractor.
+        """
+        self.mask_head = MODELS.build(mask_head)
+
+        if mask_roi_extractor is not None:
+            self.share_roi_extractor = False
+            self.mask_roi_extractor = MODELS.build(mask_roi_extractor)
+        else:
+            self.share_roi_extractor = True
+            self.mask_roi_extractor = self.bbox_roi_extractor
+
+    def _refine_roi(self, x: Tuple[Tensor], rois: Tensor,
+                    batch_img_metas: List[dict],
+                    num_proposals_per_img: Sequence[int], **kwargs) -> tuple:
+        """Multi-stage refinement of RoI.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            rois (Tensor): shape (n, 5), [batch_ind, x1, y1, x2, y2]
+            batch_img_metas (list[dict]): List of image information.
+            num_proposals_per_img (sequence[int]): number of proposals
+                in each image.
+
+        Returns:
+            tuple:
+
+               - rois (Tensor): Refined RoI.
+               - cls_scores (list[Tensor]): Average predicted
+                   cls score per image.
+               - bbox_preds (list[Tensor]): Bbox branch predictions
+                   for the last stage of per image.
+        """
+        # "ms" in variable names means multi-stage
+        ms_scores = []
+        for stage in range(self.num_stages):
+            bbox_results = self._bbox_forward(
+                stage=stage, x=x, rois=rois, **kwargs)
+
+            # split batch bbox prediction back to each image
+            cls_scores = bbox_results['cls_score'].sigmoid()
+            bbox_preds = bbox_results['bbox_pred']
+
+            rois = rois.split(num_proposals_per_img, 0)
+            cls_scores = cls_scores.split(num_proposals_per_img, 0)
+            ms_scores.append(cls_scores)
+            bbox_preds = bbox_preds.split(num_proposals_per_img, 0)
+
+            if stage < self.num_stages - 1:
+                bbox_head = self.bbox_head[stage]
+                refine_rois_list = []
+                for i in range(len(batch_img_metas)):
+                    if rois[i].shape[0] > 0:
+                        bbox_label = cls_scores[i][:, :-1].argmax(dim=1)
+                        # Refactor `bbox_head.regress_by_class` to only accept
+                        # box tensor without img_idx concatenated.
+                        refined_bboxes = bbox_head.regress_by_class(
+                            rois[i][:, 1:], bbox_label, bbox_preds[i],
+                            batch_img_metas[i])
+                        refined_bboxes = get_box_tensor(refined_bboxes)
+                        refined_rois = torch.cat(
+                            [rois[i][:, [0]], refined_bboxes], dim=1)
+                        refine_rois_list.append(refined_rois)
+                rois = torch.cat(refine_rois_list)
+        # ms_scores aligned
+        # average scores of each image by stages
+        cls_scores = [
+            sum([score[i] for score in ms_scores]) / float(len(ms_scores))
+            for i in range(len(batch_img_metas))
+        ]  # aligned
+        return rois, cls_scores, bbox_preds
+
+    def predict_bbox(self,
+                     x: Tuple[Tensor],
+                     batch_img_metas: List[dict],
+                     rpn_results_list: InstanceList,
+                     rcnn_test_cfg: ConfigType,
+                     rescale: bool = False,
+                     **kwargs) -> InstanceList:
+        """Perform forward propagation of the bbox head and predict detection
+        results on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Feature maps of all scale level.
+            batch_img_metas (list[dict]): List of image information.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals.
+            rcnn_test_cfg (obj:`ConfigDict`): `test_cfg` of R-CNN.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+        """
+        proposals = [res.bboxes for res in rpn_results_list]
+        proposal_scores = [res.scores for res in rpn_results_list]
+        num_proposals_per_img = tuple(len(p) for p in proposals)
+        rois = bbox2roi(proposals)
+
+        if rois.shape[0] == 0:
+            return empty_instances(
+                batch_img_metas,
+                rois.device,
+                task_type='bbox',
+                box_type=self.bbox_head[-1].predict_box_type,
+                num_classes=self.bbox_head[-1].num_classes,
+                score_per_cls=rcnn_test_cfg is None)
+        # rois aligned
+        rois, cls_scores, bbox_preds = self._refine_roi(
+            x=x,
+            rois=rois,
+            batch_img_metas=batch_img_metas,
+            num_proposals_per_img=num_proposals_per_img,
+            **kwargs)
+
+        # score reweighting in centernet2
+        cls_scores = [(s * ps[:, None])**0.5
+                      for s, ps in zip(cls_scores, proposal_scores)]
+        # # for demo
+        # cls_scores = [
+        #     s * (s == s[:, :-1].max(dim=1)[0][:, None]).float()
+        #     for s in cls_scores
+        # ]
+
+        # fast_rcnn_inference
+        results_list = self.bbox_head[-1].predict_by_feat(
+            rois=rois,
+            cls_scores=cls_scores,
+            bbox_preds=bbox_preds,
+            batch_img_metas=batch_img_metas,
+            rescale=rescale,
+            rcnn_test_cfg=rcnn_test_cfg)
+        return results_list
+
+    def _mask_forward(self, x: Tuple[Tensor], rois: Tensor) -> dict:
+        """Mask head forward function used in both training and testing.
+
+        Args:
+            stage (int): The current stage in Cascade RoI Head.
+            x (tuple[Tensor]): Tuple of multi-level img features.
+            rois (Tensor): RoIs with the shape (n, 5) where the first
+                column indicates batch id of each RoI.
+
+        Returns:
+            dict: Usually returns a dictionary with keys:
+
+                - `mask_preds` (Tensor): Mask prediction.
+        """
+        mask_feats = self.mask_roi_extractor(
+            x[:self.mask_roi_extractor.num_inputs], rois)
+        # do not support caffe_c4 model anymore
+        mask_preds = self.mask_head(mask_feats)
+
+        mask_results = dict(mask_preds=mask_preds)
+        return mask_results
+
+    def mask_loss(self, x, sampling_results: List[SamplingResult],
+                  batch_gt_instances: InstanceList) -> dict:
+        """Run forward function and calculate loss for mask head in training.
+
+        Args:
+            x (tuple[Tensor]): Tuple of multi-level img features.
+            sampling_results (list["obj:`SamplingResult`]): Sampling results.
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes``, ``labels``, and
+                ``masks`` attributes.
+
+        Returns:
+            dict: Usually returns a dictionary with keys:
+
+                - `mask_preds` (Tensor): Mask prediction.
+                - `loss_mask` (dict): A dictionary of mask loss components.
+        """
+        pos_rois = bbox2roi([res.pos_priors for res in sampling_results])
+        mask_results = self._mask_forward(x, pos_rois)
+
+        mask_loss_and_target = self.mask_head.loss_and_target(
+            mask_preds=mask_results['mask_preds'],
+            sampling_results=sampling_results,
+            batch_gt_instances=batch_gt_instances,
+            rcnn_train_cfg=self.train_cfg[-1])
+        mask_results.update(mask_loss_and_target)
+
+        return mask_results
+
+    def loss(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
+             batch_data_samples: SampleList) -> dict:
+        """Perform forward propagation and loss calculation of the detection
+        roi on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): List of multi-level img features.
+            rpn_results_list (list[:obj:`InstanceData`]): List of region
+                proposals.
+            batch_data_samples (list[:obj:`DetDataSample`]): The batch
+                data samples. It usually includes information such
+                as `gt_instance` or `gt_panoptic_seg` or `gt_sem_seg`.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components
+        """
+        assert len(rpn_results_list) == len(batch_data_samples)
+        outputs = unpack_gt_instances(batch_data_samples)
+        batch_gt_instances, batch_gt_instances_ignore, batch_img_metas \
+            = outputs
+
+        num_imgs = len(batch_data_samples)
+        image_labels = [x.gt_instances.labels for x in batch_data_samples]
+        losses = dict()
+        results_list = rpn_results_list
+
+        for stage in range(self.num_stages):
+            self.current_stage = stage
+            stage_loss_weight = self.stage_loss_weights[stage]
+            if hasattr(batch_gt_instances[0], 'bboxes'):
+                # assign gts and sample proposals
+                sampling_results = []
+                if self.with_bbox or self.with_mask:
+                    bbox_assigner = self.bbox_assigner[stage]
+                    bbox_sampler = self.bbox_sampler[stage]
+
+                    for i in range(num_imgs):
+                        results = results_list[i]
+                        # rename rpn_results.bboxes to rpn_results.priors
+                        results.priors = results.pop('bboxes')
+
+                        assign_result = bbox_assigner.assign(
+                            results, batch_gt_instances[i],
+                            batch_gt_instances_ignore[i])
+
+                        sampling_result = bbox_sampler.sample(
+                            assign_result,
+                            results,
+                            batch_gt_instances[i],
+                            feats=[lvl_feat[i][None] for lvl_feat in x])
+
+                        sampling_results.append(sampling_result)
+
+                # bbox head forward and loss
+                bbox_results = self.bbox_loss(stage, x, sampling_results)
+
+                for name, value in bbox_results['loss_bbox'].items():
+                    losses[f's{stage}.{name}'] = (
+                        value * stage_loss_weight if 'loss' in name else value)
+                losses[f's{stage}.image_loss'] = x[0].new_zeros([1])[0]
+
+                # mask head forward and loss
+                # D2 only forward stage.0
+                if self.with_mask and stage == 0:
+                    mask_results = self.mask_loss(x, sampling_results,
+                                                  batch_gt_instances)
+                    for name, value in mask_results['loss_mask'].items():
+                        losses[name] = (
+                            value *
+                            stage_loss_weight if 'loss' in name else value)
+
+            else:
+                # get ws_num_props pred_instances for each image
+                sampling_results = [
+                    pred_instances[:self.ws_num_props]
+                    for pred_instances in results_list
+                ]
+                for i, pred_instances in enumerate(sampling_results):
+                    pred_instances.bboxes = pred_instances.bboxes.detach()
+                bbox_results = self.image_loss(stage, x, sampling_results,
+                                               image_labels)
+                losses[f's{stage}.image_loss'] = bbox_results['image_loss']
+
+                for name in ['loss_cls', 'loss_bbox']:
+                    losses[f's{stage}.{name}'] = x[0].new_zeros([1])[0]
+                if stage == 0:
+                    losses['loss_mask'] = x[0].new_zeros([1])[0]
+
+            # refine bboxes
+            if stage < self.num_stages - 1:
+                bbox_head = self.bbox_head[stage]
+                with torch.no_grad():
+                    results_list = bbox_head.refine_bboxes(
+                        bbox_results, batch_img_metas)
+                    # Empty proposal
+                    if results_list is None:
+                        break
+
+        return losses
+
+    def image_loss(self, stage: int, x: Tuple[Tensor],
+                   sampling_results: List[SamplingResult],
+                   image_labels) -> dict:
+        """Run forward function and calculate loss for box head in training.
+
+        Args:
+            stage (int): The current stage in Cascade RoI Head.
+            x (tuple[Tensor]): List of multi-level img features.
+            sampling_results (list["obj:`SamplingResult`]): Sampling results.
+
+        Returns:
+            dict: Usually returns a dictionary with keys:
+
+                - `cls_score` (Tensor): Classification scores.
+                - `bbox_pred` (Tensor): Box energies / deltas.
+                - `bbox_feats` (Tensor): Extract bbox RoI features.
+                - `loss_bbox` (dict): A dictionary of bbox loss components.
+                - `rois` (Tensor): RoIs with the shape (n, 5) where the first
+                  column indicates batch id of each RoI.
+                - `bbox_targets` (tuple):  Ground truth for proposals in a
+                  single image. Containing the following list of Tensors:
+                  (labels, label_weights, bbox_targets, bbox_weights)
+        """
+        bbox_head = self.bbox_head[stage]
+        rois = bbox2roi([res.bboxes for res in sampling_results])
+        bbox_results = self._bbox_forward(stage, x, rois)
+        bbox_results.update(rois=rois)
+
+        image_loss = bbox_head.image_label_losses(
+            cls_score=bbox_results['cls_score'],
+            sampling_results=sampling_results,
+            image_labels=image_labels)
+        bbox_results.update(dict(image_loss=image_loss))
+
+        return bbox_results
+
+    def predict_mask(self,
+                     x: Tuple[Tensor],
+                     batch_img_metas: List[dict],
+                     results_list: List[InstanceData],
+                     rescale: bool = False) -> List[InstanceData]:
+        """Perform forward propagation of the mask head and predict detection
+        results on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Feature maps of all scale level.
+            batch_img_metas (list[dict]): List of image information.
+            results_list (list[:obj:`InstanceData`]): Detection results of
+                each image.
+            rescale (bool): If True, return boxes in original image space.
+                Defaults to False.
+
+        Returns:
+            list[:obj:`InstanceData`]: Detection results of each image
+            after the post process.
+            Each item usually contains following keys.
+
+                - scores (Tensor): Classification scores, has a shape
+                  (num_instance, )
+                - labels (Tensor): Labels of bboxes, has a shape
+                  (num_instances, ).
+                - bboxes (Tensor): Has a shape (num_instances, 4),
+                  the last dimension 4 arrange as (x1, y1, x2, y2).
+                - masks (Tensor): Has a shape (num_instances, H, W).
+        """
+        bboxes = [res.bboxes for res in results_list]
+        mask_rois = bbox2roi(bboxes)
+        if mask_rois.shape[0] == 0:
+            results_list = empty_instances(
+                batch_img_metas,
+                mask_rois.device,
+                task_type='mask',
+                instance_results=results_list,
+                mask_thr_binary=self.test_cfg.mask_thr_binary)
+            return results_list
+
+        num_mask_rois_per_img = [len(res) for res in results_list]
+        aug_masks = []
+        mask_results = self._mask_forward(x, mask_rois)
+        mask_preds = mask_results['mask_preds']
+        # split batch mask prediction back to each image
+        mask_preds = mask_preds.split(num_mask_rois_per_img, 0)
+        aug_masks.append([m.sigmoid().detach() for m in mask_preds])
+
+        merged_masks = []
+        for i in range(len(batch_img_metas)):
+            aug_mask = [mask[i] for mask in aug_masks]
+            merged_mask = merge_aug_masks(aug_mask, batch_img_metas[i])
+            merged_masks.append(merged_mask)
+        results_list = self.mask_head.predict_by_feat(
+            mask_preds=merged_masks,
+            results_list=results_list,
+            batch_img_metas=batch_img_metas,
+            rcnn_test_cfg=self.test_cfg,
+            rescale=rescale,
+            activate_map=True)
+        return results_list
diff --git a/mmdetection/projects/Detic_new/detic/heatmap_focal_loss.py b/mmdetection/projects/Detic_new/detic/heatmap_focal_loss.py
new file mode 100644
index 00000000..021a5b22
--- /dev/null
+++ b/mmdetection/projects/Detic_new/detic/heatmap_focal_loss.py
@@ -0,0 +1,131 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Union
+
+import torch
+import torch.nn as nn
+from torch import Tensor
+
+from mmdet.registry import MODELS
+
+
+# support class-agnostic heatmap_focal_loss
+def heatmap_focal_loss_with_pos_inds(
+        pred: Tensor,
+        targets: Tensor,
+        pos_inds: Tensor,
+        alpha: float = 2.0,
+        beta: float = 4.0,
+        gamma: float = 4.0,
+        sigmoid_clamp: float = 1e-4,
+        ignore_high_fp: float = -1.0,
+        pos_weight: float = 1.0,
+        neg_weight: float = 1.0,
+        avg_factor: Optional[Union[int, float]] = None) -> Tensor:
+
+    pred = torch.clamp(
+        pred.sigmoid_(), min=sigmoid_clamp, max=1 - sigmoid_clamp)
+
+    neg_weights = torch.pow(1 - targets, beta)
+
+    pos_pred = pred[pos_inds]
+    pos_loss = torch.log(pos_pred) * torch.pow(1 - pos_pred, gamma)
+    neg_loss = torch.log(1 - pred) * torch.pow(pred, gamma) * neg_weights
+    if ignore_high_fp > 0:
+        not_high_fp = (pred < ignore_high_fp).float()
+        neg_loss = not_high_fp * neg_loss
+
+    pos_loss = -pos_loss.sum()
+    neg_loss = -neg_loss.sum()
+    if alpha >= 0:
+        pos_loss = alpha * pos_loss
+        neg_loss = (1 - alpha) * neg_loss
+
+    pos_loss = pos_weight * pos_loss / avg_factor
+    neg_loss = neg_weight * neg_loss / avg_factor
+
+    return pos_loss, neg_loss
+
+
+@MODELS.register_module()
+class HeatmapFocalLoss(nn.Module):
+    """GaussianFocalLoss is a variant of focal loss.
+
+    More details can be found in the `paper
+    `_
+    Code is modified from `kp_utils.py
+    `_  # noqa: E501
+    Please notice that the target in GaussianFocalLoss is a gaussian heatmap,
+    not 0/1 binary target.
+
+    Args:
+        alpha (float): Power of prediction.
+        gamma (float): Power of target for negative samples.
+        reduction (str): Options are "none", "mean" and "sum".
+        loss_weight (float): Loss weight of current loss.
+        pos_weight(float): Positive sample loss weight. Defaults to 1.0.
+        neg_weight(float): Negative sample loss weight. Defaults to 1.0.
+    """
+
+    def __init__(
+        self,
+        alpha: float = 2.0,
+        beta: float = 4.0,
+        gamma: float = 4.0,
+        sigmoid_clamp: float = 1e-4,
+        ignore_high_fp: float = -1.0,
+        loss_weight: float = 1.0,
+        pos_weight: float = 1.0,
+        neg_weight: float = 1.0,
+    ) -> None:
+        super().__init__()
+        self.alpha = alpha
+        self.beta = beta
+        self.gamma = gamma
+        self.sigmoid_clamp = sigmoid_clamp
+        self.ignore_high_fp = ignore_high_fp
+        self.loss_weight = loss_weight
+        self.pos_weight = pos_weight
+        self.neg_weight = neg_weight
+
+    def forward(self,
+                pred: Tensor,
+                target: Tensor,
+                pos_inds: Optional[Tensor] = None,
+                avg_factor: Optional[Union[int, float]] = None) -> Tensor:
+        """Forward function.
+
+        If you want to manually determine which positions are
+        positive samples, you can set the pos_index and pos_label
+        parameter. Currently, only the CenterNet update version uses
+        the parameter.
+
+        Args:
+            pred (torch.Tensor): The prediction. The shape is (N, num_classes).
+            target (torch.Tensor): The learning target of the prediction
+                in gaussian distribution. The shape is (N, num_classes).
+            pos_inds (torch.Tensor): The positive sample index.
+                Defaults to None.
+            pos_labels (torch.Tensor): The label corresponding to the positive
+                sample index. Defaults to None.
+            weight (torch.Tensor, optional): The weight of loss for each
+                prediction. Defaults to None.
+            avg_factor (int, float, optional): Average factor that is used to
+                average the loss. Defaults to None.
+            reduction_override (str, optional): The reduction method used to
+                override the original reduction method of the loss.
+                Defaults to None.
+        """
+
+        pos_loss, neg_loss = heatmap_focal_loss_with_pos_inds(
+            pred,
+            target,
+            pos_inds,
+            alpha=self.alpha,
+            beta=self.beta,
+            gamma=self.gamma,
+            sigmoid_clamp=self.sigmoid_clamp,
+            ignore_high_fp=self.ignore_high_fp,
+            pos_weight=self.pos_weight,
+            neg_weight=self.neg_weight,
+            avg_factor=avg_factor)
+        return pos_loss, neg_loss
diff --git a/mmdetection/projects/Detic_new/detic/imagenet_lvis.py b/mmdetection/projects/Detic_new/detic/imagenet_lvis.py
new file mode 100644
index 00000000..3375a086
--- /dev/null
+++ b/mmdetection/projects/Detic_new/detic/imagenet_lvis.py
@@ -0,0 +1,395 @@
+# Copyright (c) OpenMMLab. All rights reserved.METAINFO
+import copy
+import os.path as osp
+import pickle
+import warnings
+from typing import List, Union
+
+from mmengine.fileio import get_local_path
+
+from mmdet.datasets import LVISV1Dataset
+from mmdet.registry import DATASETS
+
+
+@DATASETS.register_module()
+class ImageNetLVISV1Dataset(LVISV1Dataset):
+    """LVIS v1 dataset for detection."""
+
+    METAINFO = {
+        'classes':
+        ('aerosol_can', 'air_conditioner', 'airplane', 'alarm_clock',
+         'alcohol', 'alligator', 'almond', 'ambulance', 'amplifier', 'anklet',
+         'antenna', 'apple', 'applesauce', 'apricot', 'apron', 'aquarium',
+         'arctic_(type_of_shoe)', 'armband', 'armchair', 'armoire', 'armor',
+         'artichoke', 'trash_can', 'ashtray', 'asparagus', 'atomizer',
+         'avocado', 'award', 'awning', 'ax', 'baboon', 'baby_buggy',
+         'basketball_backboard', 'backpack', 'handbag', 'suitcase', 'bagel',
+         'bagpipe', 'baguet', 'bait', 'ball', 'ballet_skirt', 'balloon',
+         'bamboo', 'banana', 'Band_Aid', 'bandage', 'bandanna', 'banjo',
+         'banner', 'barbell', 'barge', 'barrel', 'barrette', 'barrow',
+         'baseball_base', 'baseball', 'baseball_bat', 'baseball_cap',
+         'baseball_glove', 'basket', 'basketball', 'bass_horn', 'bat_(animal)',
+         'bath_mat', 'bath_towel', 'bathrobe', 'bathtub', 'batter_(food)',
+         'battery', 'beachball', 'bead', 'bean_curd', 'beanbag', 'beanie',
+         'bear', 'bed', 'bedpan', 'bedspread', 'cow', 'beef_(food)', 'beeper',
+         'beer_bottle', 'beer_can', 'beetle', 'bell', 'bell_pepper', 'belt',
+         'belt_buckle', 'bench', 'beret', 'bib', 'Bible', 'bicycle', 'visor',
+         'billboard', 'binder', 'binoculars', 'bird', 'birdfeeder', 'birdbath',
+         'birdcage', 'birdhouse', 'birthday_cake', 'birthday_card',
+         'pirate_flag', 'black_sheep', 'blackberry', 'blackboard', 'blanket',
+         'blazer', 'blender', 'blimp', 'blinker', 'blouse', 'blueberry',
+         'gameboard', 'boat', 'bob', 'bobbin', 'bobby_pin', 'boiled_egg',
+         'bolo_tie', 'deadbolt', 'bolt', 'bonnet', 'book', 'bookcase',
+         'booklet', 'bookmark', 'boom_microphone', 'boot', 'bottle',
+         'bottle_opener', 'bouquet', 'bow_(weapon)',
+         'bow_(decorative_ribbons)', 'bow-tie', 'bowl', 'pipe_bowl',
+         'bowler_hat', 'bowling_ball', 'box', 'boxing_glove', 'suspenders',
+         'bracelet', 'brass_plaque', 'brassiere', 'bread-bin', 'bread',
+         'breechcloth', 'bridal_gown', 'briefcase', 'broccoli', 'broach',
+         'broom', 'brownie', 'brussels_sprouts', 'bubble_gum', 'bucket',
+         'horse_buggy', 'bull', 'bulldog', 'bulldozer', 'bullet_train',
+         'bulletin_board', 'bulletproof_vest', 'bullhorn', 'bun', 'bunk_bed',
+         'buoy', 'burrito', 'bus_(vehicle)', 'business_card', 'butter',
+         'butterfly', 'button', 'cab_(taxi)', 'cabana', 'cabin_car', 'cabinet',
+         'locker', 'cake', 'calculator', 'calendar', 'calf', 'camcorder',
+         'camel', 'camera', 'camera_lens', 'camper_(vehicle)', 'can',
+         'can_opener', 'candle', 'candle_holder', 'candy_bar', 'candy_cane',
+         'walking_cane', 'canister', 'canoe', 'cantaloup', 'canteen',
+         'cap_(headwear)', 'bottle_cap', 'cape', 'cappuccino',
+         'car_(automobile)', 'railcar_(part_of_a_train)', 'elevator_car',
+         'car_battery', 'identity_card', 'card', 'cardigan', 'cargo_ship',
+         'carnation', 'horse_carriage', 'carrot', 'tote_bag', 'cart', 'carton',
+         'cash_register', 'casserole', 'cassette', 'cast', 'cat',
+         'cauliflower', 'cayenne_(spice)', 'CD_player', 'celery',
+         'cellular_telephone', 'chain_mail', 'chair', 'chaise_longue',
+         'chalice', 'chandelier', 'chap', 'checkbook', 'checkerboard',
+         'cherry', 'chessboard', 'chicken_(animal)', 'chickpea',
+         'chili_(vegetable)', 'chime', 'chinaware', 'crisp_(potato_chip)',
+         'poker_chip', 'chocolate_bar', 'chocolate_cake', 'chocolate_milk',
+         'chocolate_mousse', 'choker', 'chopping_board', 'chopstick',
+         'Christmas_tree', 'slide', 'cider', 'cigar_box', 'cigarette',
+         'cigarette_case', 'cistern', 'clarinet', 'clasp', 'cleansing_agent',
+         'cleat_(for_securing_rope)', 'clementine', 'clip', 'clipboard',
+         'clippers_(for_plants)', 'cloak', 'clock', 'clock_tower',
+         'clothes_hamper', 'clothespin', 'clutch_bag', 'coaster', 'coat',
+         'coat_hanger', 'coatrack', 'cock', 'cockroach', 'cocoa_(beverage)',
+         'coconut', 'coffee_maker', 'coffee_table', 'coffeepot', 'coil',
+         'coin', 'colander', 'coleslaw', 'coloring_material',
+         'combination_lock', 'pacifier', 'comic_book', 'compass',
+         'computer_keyboard', 'condiment', 'cone', 'control',
+         'convertible_(automobile)', 'sofa_bed', 'cooker', 'cookie',
+         'cooking_utensil', 'cooler_(for_food)', 'cork_(bottle_plug)',
+         'corkboard', 'corkscrew', 'edible_corn', 'cornbread', 'cornet',
+         'cornice', 'cornmeal', 'corset', 'costume', 'cougar', 'coverall',
+         'cowbell', 'cowboy_hat', 'crab_(animal)', 'crabmeat', 'cracker',
+         'crape', 'crate', 'crayon', 'cream_pitcher', 'crescent_roll', 'crib',
+         'crock_pot', 'crossbar', 'crouton', 'crow', 'crowbar', 'crown',
+         'crucifix', 'cruise_ship', 'police_cruiser', 'crumb', 'crutch',
+         'cub_(animal)', 'cube', 'cucumber', 'cufflink', 'cup', 'trophy_cup',
+         'cupboard', 'cupcake', 'hair_curler', 'curling_iron', 'curtain',
+         'cushion', 'cylinder', 'cymbal', 'dagger', 'dalmatian', 'dartboard',
+         'date_(fruit)', 'deck_chair', 'deer', 'dental_floss', 'desk',
+         'detergent', 'diaper', 'diary', 'die', 'dinghy', 'dining_table',
+         'tux', 'dish', 'dish_antenna', 'dishrag', 'dishtowel', 'dishwasher',
+         'dishwasher_detergent', 'dispenser', 'diving_board', 'Dixie_cup',
+         'dog', 'dog_collar', 'doll', 'dollar', 'dollhouse', 'dolphin',
+         'domestic_ass', 'doorknob', 'doormat', 'doughnut', 'dove',
+         'dragonfly', 'drawer', 'underdrawers', 'dress', 'dress_hat',
+         'dress_suit', 'dresser', 'drill', 'drone', 'dropper',
+         'drum_(musical_instrument)', 'drumstick', 'duck', 'duckling',
+         'duct_tape', 'duffel_bag', 'dumbbell', 'dumpster', 'dustpan', 'eagle',
+         'earphone', 'earplug', 'earring', 'easel', 'eclair', 'eel', 'egg',
+         'egg_roll', 'egg_yolk', 'eggbeater', 'eggplant', 'electric_chair',
+         'refrigerator', 'elephant', 'elk', 'envelope', 'eraser', 'escargot',
+         'eyepatch', 'falcon', 'fan', 'faucet', 'fedora', 'ferret',
+         'Ferris_wheel', 'ferry', 'fig_(fruit)', 'fighter_jet', 'figurine',
+         'file_cabinet', 'file_(tool)', 'fire_alarm', 'fire_engine',
+         'fire_extinguisher', 'fire_hose', 'fireplace', 'fireplug',
+         'first-aid_kit', 'fish', 'fish_(food)', 'fishbowl', 'fishing_rod',
+         'flag', 'flagpole', 'flamingo', 'flannel', 'flap', 'flash',
+         'flashlight', 'fleece', 'flip-flop_(sandal)', 'flipper_(footwear)',
+         'flower_arrangement', 'flute_glass', 'foal', 'folding_chair',
+         'food_processor', 'football_(American)', 'football_helmet',
+         'footstool', 'fork', 'forklift', 'freight_car', 'French_toast',
+         'freshener', 'frisbee', 'frog', 'fruit_juice', 'frying_pan', 'fudge',
+         'funnel', 'futon', 'gag', 'garbage', 'garbage_truck', 'garden_hose',
+         'gargle', 'gargoyle', 'garlic', 'gasmask', 'gazelle', 'gelatin',
+         'gemstone', 'generator', 'giant_panda', 'gift_wrap', 'ginger',
+         'giraffe', 'cincture', 'glass_(drink_container)', 'globe', 'glove',
+         'goat', 'goggles', 'goldfish', 'golf_club', 'golfcart',
+         'gondola_(boat)', 'goose', 'gorilla', 'gourd', 'grape', 'grater',
+         'gravestone', 'gravy_boat', 'green_bean', 'green_onion', 'griddle',
+         'grill', 'grits', 'grizzly', 'grocery_bag', 'guitar', 'gull', 'gun',
+         'hairbrush', 'hairnet', 'hairpin', 'halter_top', 'ham', 'hamburger',
+         'hammer', 'hammock', 'hamper', 'hamster', 'hair_dryer', 'hand_glass',
+         'hand_towel', 'handcart', 'handcuff', 'handkerchief', 'handle',
+         'handsaw', 'hardback_book', 'harmonium', 'hat', 'hatbox', 'veil',
+         'headband', 'headboard', 'headlight', 'headscarf', 'headset',
+         'headstall_(for_horses)', 'heart', 'heater', 'helicopter', 'helmet',
+         'heron', 'highchair', 'hinge', 'hippopotamus', 'hockey_stick', 'hog',
+         'home_plate_(baseball)', 'honey', 'fume_hood', 'hook', 'hookah',
+         'hornet', 'horse', 'hose', 'hot-air_balloon', 'hotplate', 'hot_sauce',
+         'hourglass', 'houseboat', 'hummingbird', 'hummus', 'polar_bear',
+         'icecream', 'popsicle', 'ice_maker', 'ice_pack', 'ice_skate',
+         'igniter', 'inhaler', 'iPod', 'iron_(for_clothing)', 'ironing_board',
+         'jacket', 'jam', 'jar', 'jean', 'jeep', 'jelly_bean', 'jersey',
+         'jet_plane', 'jewel', 'jewelry', 'joystick', 'jumpsuit', 'kayak',
+         'keg', 'kennel', 'kettle', 'key', 'keycard', 'kilt', 'kimono',
+         'kitchen_sink', 'kitchen_table', 'kite', 'kitten', 'kiwi_fruit',
+         'knee_pad', 'knife', 'knitting_needle', 'knob', 'knocker_(on_a_door)',
+         'koala', 'lab_coat', 'ladder', 'ladle', 'ladybug', 'lamb_(animal)',
+         'lamb-chop', 'lamp', 'lamppost', 'lampshade', 'lantern', 'lanyard',
+         'laptop_computer', 'lasagna', 'latch', 'lawn_mower', 'leather',
+         'legging_(clothing)', 'Lego', 'legume', 'lemon', 'lemonade',
+         'lettuce', 'license_plate', 'life_buoy', 'life_jacket', 'lightbulb',
+         'lightning_rod', 'lime', 'limousine', 'lion', 'lip_balm', 'liquor',
+         'lizard', 'log', 'lollipop', 'speaker_(stereo_equipment)', 'loveseat',
+         'machine_gun', 'magazine', 'magnet', 'mail_slot', 'mailbox_(at_home)',
+         'mallard', 'mallet', 'mammoth', 'manatee', 'mandarin_orange',
+         'manger', 'manhole', 'map', 'marker', 'martini', 'mascot',
+         'mashed_potato', 'masher', 'mask', 'mast', 'mat_(gym_equipment)',
+         'matchbox', 'mattress', 'measuring_cup', 'measuring_stick',
+         'meatball', 'medicine', 'melon', 'microphone', 'microscope',
+         'microwave_oven', 'milestone', 'milk', 'milk_can', 'milkshake',
+         'minivan', 'mint_candy', 'mirror', 'mitten', 'mixer_(kitchen_tool)',
+         'money', 'monitor_(computer_equipment) computer_monitor', 'monkey',
+         'motor', 'motor_scooter', 'motor_vehicle', 'motorcycle',
+         'mound_(baseball)', 'mouse_(computer_equipment)', 'mousepad',
+         'muffin', 'mug', 'mushroom', 'music_stool', 'musical_instrument',
+         'nailfile', 'napkin', 'neckerchief', 'necklace', 'necktie', 'needle',
+         'nest', 'newspaper', 'newsstand', 'nightshirt',
+         'nosebag_(for_animals)', 'noseband_(for_animals)', 'notebook',
+         'notepad', 'nut', 'nutcracker', 'oar', 'octopus_(food)',
+         'octopus_(animal)', 'oil_lamp', 'olive_oil', 'omelet', 'onion',
+         'orange_(fruit)', 'orange_juice', 'ostrich', 'ottoman', 'oven',
+         'overalls_(clothing)', 'owl', 'packet', 'inkpad', 'pad', 'paddle',
+         'padlock', 'paintbrush', 'painting', 'pajamas', 'palette',
+         'pan_(for_cooking)', 'pan_(metal_container)', 'pancake', 'pantyhose',
+         'papaya', 'paper_plate', 'paper_towel', 'paperback_book',
+         'paperweight', 'parachute', 'parakeet', 'parasail_(sports)',
+         'parasol', 'parchment', 'parka', 'parking_meter', 'parrot',
+         'passenger_car_(part_of_a_train)', 'passenger_ship', 'passport',
+         'pastry', 'patty_(food)', 'pea_(food)', 'peach', 'peanut_butter',
+         'pear', 'peeler_(tool_for_fruit_and_vegetables)', 'wooden_leg',
+         'pegboard', 'pelican', 'pen', 'pencil', 'pencil_box',
+         'pencil_sharpener', 'pendulum', 'penguin', 'pennant', 'penny_(coin)',
+         'pepper', 'pepper_mill', 'perfume', 'persimmon', 'person', 'pet',
+         'pew_(church_bench)', 'phonebook', 'phonograph_record', 'piano',
+         'pickle', 'pickup_truck', 'pie', 'pigeon', 'piggy_bank', 'pillow',
+         'pin_(non_jewelry)', 'pineapple', 'pinecone', 'ping-pong_ball',
+         'pinwheel', 'tobacco_pipe', 'pipe', 'pistol', 'pita_(bread)',
+         'pitcher_(vessel_for_liquid)', 'pitchfork', 'pizza', 'place_mat',
+         'plate', 'platter', 'playpen', 'pliers', 'plow_(farm_equipment)',
+         'plume', 'pocket_watch', 'pocketknife', 'poker_(fire_stirring_tool)',
+         'pole', 'polo_shirt', 'poncho', 'pony', 'pool_table', 'pop_(soda)',
+         'postbox_(public)', 'postcard', 'poster', 'pot', 'flowerpot',
+         'potato', 'potholder', 'pottery', 'pouch', 'power_shovel', 'prawn',
+         'pretzel', 'printer', 'projectile_(weapon)', 'projector', 'propeller',
+         'prune', 'pudding', 'puffer_(fish)', 'puffin', 'pug-dog', 'pumpkin',
+         'puncher', 'puppet', 'puppy', 'quesadilla', 'quiche', 'quilt',
+         'rabbit', 'race_car', 'racket', 'radar', 'radiator', 'radio_receiver',
+         'radish', 'raft', 'rag_doll', 'raincoat', 'ram_(animal)', 'raspberry',
+         'rat', 'razorblade', 'reamer_(juicer)', 'rearview_mirror', 'receipt',
+         'recliner', 'record_player', 'reflector', 'remote_control',
+         'rhinoceros', 'rib_(food)', 'rifle', 'ring', 'river_boat', 'road_map',
+         'robe', 'rocking_chair', 'rodent', 'roller_skate', 'Rollerblade',
+         'rolling_pin', 'root_beer', 'router_(computer_equipment)',
+         'rubber_band', 'runner_(carpet)', 'plastic_bag',
+         'saddle_(on_an_animal)', 'saddle_blanket', 'saddlebag', 'safety_pin',
+         'sail', 'salad', 'salad_plate', 'salami', 'salmon_(fish)',
+         'salmon_(food)', 'salsa', 'saltshaker', 'sandal_(type_of_shoe)',
+         'sandwich', 'satchel', 'saucepan', 'saucer', 'sausage', 'sawhorse',
+         'saxophone', 'scale_(measuring_instrument)', 'scarecrow', 'scarf',
+         'school_bus', 'scissors', 'scoreboard', 'scraper', 'screwdriver',
+         'scrubbing_brush', 'sculpture', 'seabird', 'seahorse', 'seaplane',
+         'seashell', 'sewing_machine', 'shaker', 'shampoo', 'shark',
+         'sharpener', 'Sharpie', 'shaver_(electric)', 'shaving_cream', 'shawl',
+         'shears', 'sheep', 'shepherd_dog', 'sherbert', 'shield', 'shirt',
+         'shoe', 'shopping_bag', 'shopping_cart', 'short_pants', 'shot_glass',
+         'shoulder_bag', 'shovel', 'shower_head', 'shower_cap',
+         'shower_curtain', 'shredder_(for_paper)', 'signboard', 'silo', 'sink',
+         'skateboard', 'skewer', 'ski', 'ski_boot', 'ski_parka', 'ski_pole',
+         'skirt', 'skullcap', 'sled', 'sleeping_bag', 'sling_(bandage)',
+         'slipper_(footwear)', 'smoothie', 'snake', 'snowboard', 'snowman',
+         'snowmobile', 'soap', 'soccer_ball', 'sock', 'sofa', 'softball',
+         'solar_array', 'sombrero', 'soup', 'soup_bowl', 'soupspoon',
+         'sour_cream', 'soya_milk', 'space_shuttle', 'sparkler_(fireworks)',
+         'spatula', 'spear', 'spectacles', 'spice_rack', 'spider', 'crawfish',
+         'sponge', 'spoon', 'sportswear', 'spotlight', 'squid_(food)',
+         'squirrel', 'stagecoach', 'stapler_(stapling_machine)', 'starfish',
+         'statue_(sculpture)', 'steak_(food)', 'steak_knife', 'steering_wheel',
+         'stepladder', 'step_stool', 'stereo_(sound_system)', 'stew',
+         'stirrer', 'stirrup', 'stool', 'stop_sign', 'brake_light', 'stove',
+         'strainer', 'strap', 'straw_(for_drinking)', 'strawberry',
+         'street_sign', 'streetlight', 'string_cheese', 'stylus', 'subwoofer',
+         'sugar_bowl', 'sugarcane_(plant)', 'suit_(clothing)', 'sunflower',
+         'sunglasses', 'sunhat', 'surfboard', 'sushi', 'mop', 'sweat_pants',
+         'sweatband', 'sweater', 'sweatshirt', 'sweet_potato', 'swimsuit',
+         'sword', 'syringe', 'Tabasco_sauce', 'table-tennis_table', 'table',
+         'table_lamp', 'tablecloth', 'tachometer', 'taco', 'tag', 'taillight',
+         'tambourine', 'army_tank', 'tank_(storage_vessel)',
+         'tank_top_(clothing)', 'tape_(sticky_cloth_or_paper)', 'tape_measure',
+         'tapestry', 'tarp', 'tartan', 'tassel', 'tea_bag', 'teacup',
+         'teakettle', 'teapot', 'teddy_bear', 'telephone', 'telephone_booth',
+         'telephone_pole', 'telephoto_lens', 'television_camera',
+         'television_set', 'tennis_ball', 'tennis_racket', 'tequila',
+         'thermometer', 'thermos_bottle', 'thermostat', 'thimble', 'thread',
+         'thumbtack', 'tiara', 'tiger', 'tights_(clothing)', 'timer',
+         'tinfoil', 'tinsel', 'tissue_paper', 'toast_(food)', 'toaster',
+         'toaster_oven', 'toilet', 'toilet_tissue', 'tomato', 'tongs',
+         'toolbox', 'toothbrush', 'toothpaste', 'toothpick', 'cover',
+         'tortilla', 'tow_truck', 'towel', 'towel_rack', 'toy',
+         'tractor_(farm_equipment)', 'traffic_light', 'dirt_bike',
+         'trailer_truck', 'train_(railroad_vehicle)', 'trampoline', 'tray',
+         'trench_coat', 'triangle_(musical_instrument)', 'tricycle', 'tripod',
+         'trousers', 'truck', 'truffle_(chocolate)', 'trunk', 'vat', 'turban',
+         'turkey_(food)', 'turnip', 'turtle', 'turtleneck_(clothing)',
+         'typewriter', 'umbrella', 'underwear', 'unicycle', 'urinal', 'urn',
+         'vacuum_cleaner', 'vase', 'vending_machine', 'vent', 'vest',
+         'videotape', 'vinegar', 'violin', 'vodka', 'volleyball', 'vulture',
+         'waffle', 'waffle_iron', 'wagon', 'wagon_wheel', 'walking_stick',
+         'wall_clock', 'wall_socket', 'wallet', 'walrus', 'wardrobe',
+         'washbasin', 'automatic_washer', 'watch', 'water_bottle',
+         'water_cooler', 'water_faucet', 'water_heater', 'water_jug',
+         'water_gun', 'water_scooter', 'water_ski', 'water_tower',
+         'watering_can', 'watermelon', 'weathervane', 'webcam', 'wedding_cake',
+         'wedding_ring', 'wet_suit', 'wheel', 'wheelchair', 'whipped_cream',
+         'whistle', 'wig', 'wind_chime', 'windmill', 'window_box_(for_plants)',
+         'windshield_wiper', 'windsock', 'wine_bottle', 'wine_bucket',
+         'wineglass', 'blinder_(for_horses)', 'wok', 'wolf', 'wooden_spoon',
+         'wreath', 'wrench', 'wristband', 'wristlet', 'yacht', 'yogurt',
+         'yoke_(animal_equipment)', 'zebra', 'zucchini'),
+        'palette':
+        None
+    }
+
+    def get_data_info(self, idx: int) -> dict:
+        """Get annotation by index and automatically call ``full_init`` if the
+        dataset has not been fully initialized.
+
+        Args:
+            idx (int): The index of data.
+
+        Returns:
+            dict: The idx-th annotation of the dataset.
+        """
+        if self.serialize_data:
+            start_addr = 0 if idx == 0 else self.data_address[idx - 1].item()
+            end_addr = self.data_address[idx].item()
+            bytes = memoryview(
+                self.data_bytes[start_addr:end_addr])  # type: ignore
+            data_info = pickle.loads(bytes)  # type: ignore
+        else:
+            data_info = copy.deepcopy(self.data_list[idx])
+
+        # Some codebase needs `sample_idx` of data information. Here we convert
+        # the idx to a positive number and save it in data information.
+        if idx >= 0:
+            data_info['sample_idx'] = idx
+        else:
+            data_info['sample_idx'] = len(self) + idx
+
+        return data_info
+
+    def load_data_list(self) -> List[dict]:
+        """Load annotations from an annotation file named as ``self.ann_file``
+
+        Returns:
+            List[dict]: A list of annotation.
+        """  # noqa: E501
+        try:
+            import lvis
+            if getattr(lvis, '__version__', '0') >= '10.5.3':
+                warnings.warn(
+                    'mmlvis is deprecated, please install official lvis-api by "pip install git+https://github.com/lvis-dataset/lvis-api.git"',  # noqa: E501
+                    UserWarning)
+            from lvis import LVIS
+        except ImportError:
+            raise ImportError(
+                'Package lvis is not installed. Please run "pip install git+https://github.com/lvis-dataset/lvis-api.git".'  # noqa: E501
+            )
+        with get_local_path(
+                self.ann_file, backend_args=self.backend_args) as local_path:
+            self.lvis = LVIS(local_path)
+        self.cat_ids = self.lvis.get_cat_ids()
+        self.cat2label = {cat_id: i for i, cat_id in enumerate(self.cat_ids)}
+        self.cat_img_map = copy.deepcopy(self.lvis.cat_img_map)
+        img_ids = self.lvis.get_img_ids()
+        data_list = []
+        total_ann_ids = []
+        for img_id in img_ids:
+            raw_img_info = self.lvis.load_imgs([img_id])[0]
+            raw_img_info['img_id'] = img_id
+
+            ann_ids = self.lvis.get_ann_ids(img_ids=[img_id])
+            total_ann_ids.extend(ann_ids)
+            parsed_data_info = self.parse_data_info(
+                {'raw_img_info': raw_img_info})
+            data_list.append(parsed_data_info)
+        if self.ANN_ID_UNIQUE:
+            assert len(set(total_ann_ids)) == len(
+                total_ann_ids
+            ), f"Annotation ids in '{self.ann_file}' are not unique!"
+
+        del self.lvis
+        # print(data_list)
+        return data_list
+
+    def parse_data_info(self, raw_data_info: dict) -> Union[dict, List[dict]]:
+        """Parse raw annotation to target format.
+
+        Args:
+            raw_data_info (dict): Raw data information load from ``ann_file``
+
+        Returns:
+            Union[dict, List[dict]]: Parsed annotation.
+        """
+        img_info = raw_data_info['raw_img_info']
+
+        data_info = {}
+
+        # TODO: need to change data_prefix['img'] to data_prefix['img_path']
+        img_path = osp.join(self.data_prefix['img'], img_info['file_name'])
+        if self.data_prefix.get('seg', None):
+            seg_map_path = osp.join(
+                self.data_prefix['seg'],
+                img_info['file_name'].rsplit('.', 1)[0] + self.seg_map_suffix)
+        else:
+            seg_map_path = None
+        data_info['img_path'] = img_path
+        data_info['img_id'] = img_info['img_id']
+        data_info['seg_map_path'] = seg_map_path
+        data_info['height'] = img_info['height']
+        data_info['width'] = img_info['width']
+
+        if self.return_classes:
+            data_info['text'] = self.metainfo['classes']
+            data_info['custom_entities'] = True
+
+        instances = []
+        image_labels = [
+            self.cat2label[x] for x in img_info['pos_category_ids']
+        ]
+        for image_label in image_labels:
+            instance = {}
+            instance['bbox_label'] = image_label
+            instances.append(instance)
+        data_info['instances'] = instances
+
+        return data_info
+
+    def get_cat_ids(self, idx: int) -> List[int]:
+        """Get COCO category ids by index.
+
+        Args:
+            idx (int): Index of data.
+
+        Returns:
+            List[int]: All categories in the image of specified index.
+        """
+        data_info = self.get_data_info(idx)
+        image_labels = []
+        for instance in data_info['instances']:
+            image_labels.append(instance['bbox_label'])
+
+        return image_labels
diff --git a/mmdetection/projects/Detic_new/detic/iou_loss.py b/mmdetection/projects/Detic_new/detic/iou_loss.py
new file mode 100644
index 00000000..349545cf
--- /dev/null
+++ b/mmdetection/projects/Detic_new/detic/iou_loss.py
@@ -0,0 +1,125 @@
+import torch
+from torch import nn
+
+
+# support calculate  IOULoss with box_pred
+class IOULoss(nn.Module):
+
+    def __init__(self, loc_loss_type='iou'):
+        super(IOULoss, self).__init__()
+        self.loc_loss_type = loc_loss_type
+
+    def forward(self, pred, target, weight=None, reduction='sum'):
+        pred_left = pred[:, 0]
+        pred_top = pred[:, 1]
+        pred_right = pred[:, 2]
+        pred_bottom = pred[:, 3]
+
+        target_left = target[:, 0]
+        target_top = target[:, 1]
+        target_right = target[:, 2]
+        target_bottom = target[:, 3]
+
+        target_aera = (target_left + target_right) * (
+            target_top + target_bottom)
+        pred_aera = (pred_left + pred_right) * (pred_top + pred_bottom)
+
+        w_intersect = torch.min(pred_left, target_left) + torch.min(
+            pred_right, target_right)
+        h_intersect = torch.min(pred_bottom, target_bottom) + torch.min(
+            pred_top, target_top)
+
+        g_w_intersect = torch.max(pred_left, target_left) + torch.max(
+            pred_right, target_right)
+        g_h_intersect = torch.max(pred_bottom, target_bottom) + torch.max(
+            pred_top, target_top)
+        ac_uion = g_w_intersect * g_h_intersect
+
+        area_intersect = w_intersect * h_intersect
+        area_union = target_aera + pred_aera - area_intersect
+
+        ious = (area_intersect + 1.0) / (area_union + 1.0)
+        gious = ious - (ac_uion - area_union) / ac_uion
+        if self.loc_loss_type == 'iou':
+            losses = -torch.log(ious)
+        elif self.loc_loss_type == 'linear_iou':
+            losses = 1 - ious
+        elif self.loc_loss_type == 'giou':
+            losses = 1 - gious
+        else:
+            raise NotImplementedError
+
+        if weight is not None:
+            losses = losses * weight
+        else:
+            losses = losses
+
+        if reduction == 'sum':
+            return losses.sum()
+        elif reduction == 'batch':
+            return losses.sum(dim=[1])
+        elif reduction == 'none':
+            return losses
+        else:
+            raise NotImplementedError
+
+
+def giou_loss(
+    boxes1: torch.Tensor,
+    boxes2: torch.Tensor,
+    reduction: str = 'none',
+    eps: float = 1e-7,
+) -> torch.Tensor:
+    """Generalized Intersection over Union Loss (Hamid Rezatofighi et.
+
+    al)
+    https://arxiv.org/abs/1902.09630
+    Gradient-friendly IoU loss with an additional penalty that is
+    non-zero when the boxes do not overlap and scales with the size
+    of their smallest enclosing box. This loss is symmetric, so the
+    boxes1 and boxes2 arguments are interchangeable.
+    Args:
+        boxes1, boxes2 (Tensor): box locations in XYXY format, shape
+        (N, 4) or (4,).
+        reduction: 'none' | 'mean' | 'sum'
+                 'none': No reduction will be applied to the output.
+                 'mean': The output will be averaged.
+                 'sum': The output will be summed.
+        eps (float): small number to prevent division by zero
+    """
+
+    x1, y1, x2, y2 = boxes1.unbind(dim=-1)
+    x1g, y1g, x2g, y2g = boxes2.unbind(dim=-1)
+
+    assert (x2 >= x1).all(), 'bad box: x1 larger than x2'
+    assert (y2 >= y1).all(), 'bad box: y1 larger than y2'
+
+    # Intersection keypoints
+    xkis1 = torch.max(x1, x1g)
+    ykis1 = torch.max(y1, y1g)
+    xkis2 = torch.min(x2, x2g)
+    ykis2 = torch.min(y2, y2g)
+
+    intsctk = torch.zeros_like(x1)
+    mask = (ykis2 > ykis1) & (xkis2 > xkis1)
+    intsctk[mask] = (xkis2[mask] - xkis1[mask]) * (ykis2[mask] - ykis1[mask])
+    unionk = (x2 - x1) * (y2 - y1) + (x2g - x1g) * (y2g - y1g) - intsctk
+    iouk = intsctk / (unionk + eps)
+
+    # smallest enclosing box
+    xc1 = torch.min(x1, x1g)
+    yc1 = torch.min(y1, y1g)
+    xc2 = torch.max(x2, x2g)
+    yc2 = torch.max(y2, y2g)
+
+    area_c = (xc2 - xc1) * (yc2 - yc1)
+    miouk = iouk - ((area_c - unionk) / (area_c + eps))
+
+    loss = 1 - miouk
+
+    if reduction == 'mean':
+        loss = loss.mean()
+    elif reduction == 'sum':
+        loss = loss.sum()
+
+    return loss
diff --git a/mmdetection/projects/Detic_new/detic/zero_shot_classifier.py b/mmdetection/projects/Detic_new/detic/zero_shot_classifier.py
new file mode 100644
index 00000000..cb9946d5
--- /dev/null
+++ b/mmdetection/projects/Detic_new/detic/zero_shot_classifier.py
@@ -0,0 +1,73 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+import numpy as np
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+from mmdet.registry import MODELS
+
+
+@MODELS.register_module()
+class ZeroShotClassifier(nn.Module):
+
+    def __init__(
+        self,
+        in_features: int,
+        out_features: int,  # num_classes
+        zs_weight_path: str,
+        zs_weight_dim: int = 512,
+        use_bias: float = 0.0,
+        norm_weight: bool = True,
+        norm_temperature: float = 50.0,
+    ):
+        super().__init__()
+        num_classes = out_features
+        self.norm_weight = norm_weight
+        self.norm_temperature = norm_temperature
+
+        self.use_bias = use_bias < 0
+        if self.use_bias:
+            self.cls_bias = nn.Parameter(torch.ones(1) * use_bias)
+
+        self.linear = nn.Linear(in_features, zs_weight_dim)
+
+        if zs_weight_path == 'rand':
+            zs_weight = torch.randn((zs_weight_dim, num_classes))
+            nn.init.normal_(zs_weight, std=0.01)
+        else:
+            zs_weight = torch.tensor(
+                np.load(zs_weight_path),
+                dtype=torch.float32).permute(1, 0).contiguous()  # D x C
+        zs_weight = torch.cat(
+            [zs_weight, zs_weight.new_zeros(
+                (zs_weight_dim, 1))], dim=1)  # D x (C + 1)
+
+        if self.norm_weight:
+            zs_weight = F.normalize(zs_weight, p=2, dim=0)
+
+        if zs_weight_path == 'rand':
+            self.zs_weight = nn.Parameter(zs_weight)
+        else:
+            self.register_buffer('zs_weight', zs_weight)
+
+        assert self.zs_weight.shape[1] == num_classes + 1, self.zs_weight.shape
+
+    def forward(self, x, classifier=None):
+        '''
+        Inputs:
+            x: B x D'
+            classifier_info: (C', C' x D)
+        '''
+        x = self.linear(x)
+        if classifier is not None:
+            zs_weight = classifier.permute(1, 0).contiguous()  # D x C'
+            zs_weight = F.normalize(zs_weight, p=2, dim=0) \
+                if self.norm_weight else zs_weight
+        else:
+            zs_weight = self.zs_weight
+        if self.norm_weight:
+            x = self.norm_temperature * F.normalize(x, p=2, dim=1)
+        x = torch.mm(x, zs_weight)
+        if self.use_bias:
+            x = x + self.cls_bias
+        return x
diff --git a/mmdetection/projects/DiffusionDet/README.md b/mmdetection/projects/DiffusionDet/README.md
new file mode 100644
index 00000000..5542d9a5
--- /dev/null
+++ b/mmdetection/projects/DiffusionDet/README.md
@@ -0,0 +1,172 @@
+## Description
+
+This is an implementation of [DiffusionDet](https://github.com/ShoufaChen/DiffusionDet) based on [MMDetection](https://github.com/open-mmlab/mmdetection/tree/main), [MMCV](https://github.com/open-mmlab/mmcv), and [MMEngine](https://github.com/open-mmlab/mmengine).
+
+
    
+
+
    
+
+## Usage
+
+
+
+### Comparison of results
+
+1. Download the [DiffusionDet released model](https://github.com/ShoufaChen/DiffusionDet#models).
+
+2. Convert model from DiffusionDet version to MMDetection version. We give a [sample script](model_converters/diffusiondet_resnet_to_mmdet.py)
+   to convert `DiffusionDet-resnet50` model. Users can download the corresponding models from [here](https://github.com/ShoufaChen/DiffusionDet/releases/download/v0.1/diffdet_coco_res50.pth).
+
+   ```shell
+   python projects/DiffusionDet/model_converters/diffusiondet_resnet_to_mmdet.py ${DiffusionDet ckpt path} ${MMDetectron ckpt path}
+   ```
+
+3. Testing the model in MMDetection.
+
+   ```shell
+   python tools/test.py projects/DiffusionDet/configs/diffusiondet_r50_fpn_500-proposals_1-step_crop-ms-480-800-450k_coco.py ${CHECKPOINT_PATH}
+   ```
+
+**Note:** During inference time, DiffusionDet will randomly generate noisy boxes,
+which may affect the AP results. If users want to get the same result every inference time, setting seed is a good way.
+We give a table to compare the inference results on `ResNet50-500-proposals` between DiffusionDet and MMDetection.
+
+|                                                         Config                                                          | Step |    AP     |
+| :---------------------------------------------------------------------------------------------------------------------: | :--: | :-------: |
+| [DiffusionDet](https://github.com/ShoufaChen/DiffusionDet/blob/main/configs/diffdet.coco.res50.yaml) (released results) |  1   |   45.5    |
+|      [DiffusionDet](https://github.com/ShoufaChen/DiffusionDet/blob/main/configs/diffdet.coco.res50.yaml) (seed=0)      |  1   |   45.66   |
+|         [MMDetection](configs/diffusiondet_r50_fpn_500-proposals_1-step_crop-ms-480-800-450k_coco.py) (seed=0)          |  1   |   45.7    |
+|       [MMDetection](configs/diffusiondet_r50_fpn_500-proposals_1-step_crop-ms-480-800-450k_coco.py) (random seed)       |  1   | 45.6~45.8 |
+| [DiffusionDet](https://github.com/ShoufaChen/DiffusionDet/blob/main/configs/diffdet.coco.res50.yaml) (released results) |  4   |   46.1    |
+|      [DiffusionDet](https://github.com/ShoufaChen/DiffusionDet/blob/main/configs/diffdet.coco.res50.yaml) (seed=0)      |  4   |   46.38   |
+|         [MMDetection](configs/diffusiondet_r50_fpn_500-proposals_1-step_crop-ms-480-800-450k_coco.py) (seed=0)          |  4   |   46.4    |
+|       [MMDetection](configs/diffusiondet_r50_fpn_500-proposals_1-step_crop-ms-480-800-450k_coco.py) (random seed)       |  4   | 46.2~46.4 |
+
+- `seed=0` means hard set seed before generating random boxes.
+  ```python
+  # hard set seed=0 before generating random boxes
+  seed = 0
+  random.seed(seed)
+  torch.manual_seed(seed)
+  # torch.cuda.manual_seed(seed)
+  torch.cuda.manual_seed_all(seed)
+  ...
+  noise_bboxes_raw = torch.randn(
+      (self.num_proposals, 4),
+      device=device)
+  ...
+  ```
+- `random seed` means do not hard set seed before generating random boxes.
+
+### Training commands
+
+In MMDetection's root directory, run the following command to train the model:
+
+```bash
+python tools/train.py projects/DiffusionDet/configs/diffusiondet_r50_fpn_500-proposals_1-step_crop-ms-480-800-450k_coco.py
+```
+
+For multi-gpu training, run:
+
+```bash
+python -m torch.distributed.launch --nnodes=1 --node_rank=0 --nproc_per_node=${NUM_GPUS} --master_port=29506 --master_addr="127.0.0.1" tools/train.py projects/DiffusionDet/configs/diffusiondet_r50_fpn_500-proposals_1-step_crop-ms-480-800-450k_coco.py
+```
+
+### Testing commands
+
+In MMDetection's root directory, run the following command to test the model:
+
+```bash
+# for 1 step inference
+# test command
+python tools/test.py projects/DiffusionDet/configs/diffusiondet_r50_fpn_500-proposals_1-step_crop-ms-480-800-450k_coco.py ${CHECKPOINT_PATH}
+
+# for 4 steps inference
+
+# test command
+python tools/test.py projects/DiffusionDet/configs/diffusiondet_r50_fpn_500-proposals_1-step_crop-ms-480-800-450k_coco.py ${CHECKPOINT_PATH} --cfg-options model.bbox_head.sampling_timesteps=4
+```
+
+**Note:** There is no difference between 1 step or 4 steps (or other multi-step) during training. Users can set different steps during inference through `--cfg-options model.bbox_head.sampling_timesteps=${STEPS}`, but larger `sampling_timesteps` will affect the inference time.
+
+## Results
+
+Here we provide the baseline version of DiffusionDet with ResNet50 backbone.
+
+To find more variants, please visit the [official model zoo](https://github.com/ShoufaChen/DiffusionDet#models).
+
+| Backbone |  Style  | Lr schd | AP (Step=1) | AP (Step=4) |                                           Config                                           |                                                                                                                                                                                                                                      Download                                                                                                                                                                                                                                      |
+| :------: | :-----: | :-----: | :---------: | :---------: | :----------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+|   R-50   | PyTorch |  450k   |    44.5     |    46.2     | [config](./configs/diffusiondet_r50_fpn_500-proposals_1-step_crop-ms-480-800-450k_coco.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/diffusiondet/diffusiondet_r50_fpn_500-proposals_1-step_crop-ms-480-800-450k_coco/diffusiondet_r50_fpn_500-proposals_1-step_crop-ms-480-800-450k_coco_20230215_090925-7d6ed504.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/diffusiondet/diffusiondet_r50_fpn_500-proposals_1-step_crop-ms-480-800-450k_coco/diffusiondet_r50_fpn_500-proposals_1-step_crop-ms-480-800-450k_coco_20230215_090925.log.json) |
+
+## License
+
+DiffusionDet is under the [CC-BY-NC 4.0 license](https://github.com/ShoufaChen/DiffusionDet/blob/main/LICENSE). Users should be careful about adopting these features in any commercial matters.
+
+## Citation
+
+If you find DiffusionDet is useful in your research or applications, please consider giving a star 🌟 to the [official repository](https://github.com/ShoufaChen/DiffusionDet) and citing DiffusionDet by the following BibTeX entry.
+
+```BibTeX
+@article{chen2022diffusiondet,
+      title={DiffusionDet: Diffusion Model for Object Detection},
+      author={Chen, Shoufa and Sun, Peize and Song, Yibing and Luo, Ping},
+      journal={arXiv preprint arXiv:2211.09788},
+      year={2022}
+}
+```
+
+## Checklist
+
+
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+
+    
+
+  - [x] Basic docstrings & proper citation
+
+    
+
+  - [x] Test-time correctness
+
+    
+
+  - [x] A full README
+
+    
+
+- [x] Milestone 2: Indicates a successful model implementation.
+
+  - [x] Training-time correctness
+
+    
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+
+    
+
+  - [ ] Unit tests
+
+    
+
+  - [ ] Code polishing
+
+    
+
+  - [ ] Metafile.yml
+
+    
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+  
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmdetection/projects/DiffusionDet/configs/diffusiondet_r50_fpn_500-proposals_1-step_crop-ms-480-800-450k_coco.py b/mmdetection/projects/DiffusionDet/configs/diffusiondet_r50_fpn_500-proposals_1-step_crop-ms-480-800-450k_coco.py
new file mode 100644
index 00000000..187cdc39
--- /dev/null
+++ b/mmdetection/projects/DiffusionDet/configs/diffusiondet_r50_fpn_500-proposals_1-step_crop-ms-480-800-450k_coco.py
@@ -0,0 +1,185 @@
+_base_ = [
+    'mmdet::_base_/datasets/coco_detection.py',
+    'mmdet::_base_/schedules/schedule_1x.py',
+    'mmdet::_base_/default_runtime.py'
+]
+
+custom_imports = dict(
+    imports=['projects.DiffusionDet.diffusiondet'], allow_failed_imports=False)
+
+# model settings
+model = dict(
+    type='DiffusionDet',
+    data_preprocessor=dict(
+        type='DetDataPreprocessor',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        bgr_to_rgb=True,
+        pad_size_divisor=32),
+    backbone=dict(
+        type='ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type='BN', requires_grad=True),
+        norm_eval=True,
+        style='pytorch',
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),
+    neck=dict(
+        type='FPN',
+        in_channels=[256, 512, 1024, 2048],
+        out_channels=256,
+        num_outs=4),
+    bbox_head=dict(
+        type='DynamicDiffusionDetHead',
+        num_classes=80,
+        feat_channels=256,
+        num_proposals=500,
+        num_heads=6,
+        deep_supervision=True,
+        prior_prob=0.01,
+        snr_scale=2.0,
+        sampling_timesteps=1,
+        ddim_sampling_eta=1.0,
+        single_head=dict(
+            type='SingleDiffusionDetHead',
+            num_cls_convs=1,
+            num_reg_convs=3,
+            dim_feedforward=2048,
+            num_heads=8,
+            dropout=0.0,
+            act_cfg=dict(type='ReLU', inplace=True),
+            dynamic_conv=dict(dynamic_dim=64, dynamic_num=2)),
+        roi_extractor=dict(
+            type='SingleRoIExtractor',
+            roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=2),
+            out_channels=256,
+            featmap_strides=[4, 8, 16, 32]),
+        # criterion
+        criterion=dict(
+            type='DiffusionDetCriterion',
+            num_classes=80,
+            assigner=dict(
+                type='DiffusionDetMatcher',
+                match_costs=[
+                    dict(
+                        type='FocalLossCost',
+                        alpha=0.25,
+                        gamma=2.0,
+                        weight=2.0,
+                        eps=1e-8),
+                    dict(type='BBoxL1Cost', weight=5.0, box_format='xyxy'),
+                    dict(type='IoUCost', iou_mode='giou', weight=2.0)
+                ],
+                center_radius=2.5,
+                candidate_topk=5),
+            loss_cls=dict(
+                type='FocalLoss',
+                use_sigmoid=True,
+                alpha=0.25,
+                gamma=2.0,
+                reduction='sum',
+                loss_weight=2.0),
+            loss_bbox=dict(type='L1Loss', reduction='sum', loss_weight=5.0),
+            loss_giou=dict(type='GIoULoss', reduction='sum',
+                           loss_weight=2.0))),
+    test_cfg=dict(
+        use_nms=True,
+        score_thr=0.5,
+        min_bbox_size=0,
+        nms=dict(type='nms', iou_threshold=0.5),
+    ))
+
+backend = 'pillow'
+train_pipeline = [
+    dict(
+        type='LoadImageFromFile',
+        backend_args=_base_.backend_args,
+        imdecode_backend=backend),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(
+        type='RandomChoice',
+        transforms=[[
+            dict(
+                type='RandomChoiceResize',
+                scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333),
+                        (608, 1333), (640, 1333), (672, 1333), (704, 1333),
+                        (736, 1333), (768, 1333), (800, 1333)],
+                keep_ratio=True,
+                backend=backend),
+        ],
+                    [
+                        dict(
+                            type='RandomChoiceResize',
+                            scales=[(400, 1333), (500, 1333), (600, 1333)],
+                            keep_ratio=True,
+                            backend=backend),
+                        dict(
+                            type='RandomCrop',
+                            crop_type='absolute_range',
+                            crop_size=(384, 600),
+                            allow_negative_crop=True),
+                        dict(
+                            type='RandomChoiceResize',
+                            scales=[(480, 1333), (512, 1333), (544, 1333),
+                                    (576, 1333), (608, 1333), (640, 1333),
+                                    (672, 1333), (704, 1333), (736, 1333),
+                                    (768, 1333), (800, 1333)],
+                            keep_ratio=True,
+                            backend=backend)
+                    ]]),
+    dict(type='PackDetInputs')
+]
+
+test_pipeline = [
+    dict(
+        type='LoadImageFromFile',
+        backend_args=_base_.backend_args,
+        imdecode_backend=backend),
+    dict(type='Resize', scale=(1333, 800), keep_ratio=True, backend=backend),
+    # If you don't have a gt annotation, delete the pipeline
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(
+        type='PackDetInputs',
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+train_dataloader = dict(
+    sampler=dict(type='InfiniteSampler'),
+    dataset=dict(
+        filter_cfg=dict(filter_empty_gt=False, min_size=1e-5),
+        pipeline=train_pipeline))
+
+val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+# optimizer
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(
+        _delete_=True, type='AdamW', lr=0.000025, weight_decay=0.0001),
+    clip_grad=dict(max_norm=1.0, norm_type=2))
+train_cfg = dict(
+    _delete_=True,
+    type='IterBasedTrainLoop',
+    max_iters=450000,
+    val_interval=75000)
+
+# learning rate
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=0.01, by_epoch=False, begin=0, end=1000),
+    dict(
+        type='MultiStepLR',
+        begin=0,
+        end=450000,
+        by_epoch=False,
+        milestones=[350000, 420000],
+        gamma=0.1)
+]
+
+default_hooks = dict(
+    checkpoint=dict(by_epoch=False, interval=75000, max_keep_ckpts=3))
+log_processor = dict(by_epoch=False)
diff --git a/mmdetection/projects/DiffusionDet/diffusiondet/__init__.py b/mmdetection/projects/DiffusionDet/diffusiondet/__init__.py
new file mode 100644
index 00000000..35d60322
--- /dev/null
+++ b/mmdetection/projects/DiffusionDet/diffusiondet/__init__.py
@@ -0,0 +1,10 @@
+from .diffusiondet import DiffusionDet
+from .head import (DynamicConv, DynamicDiffusionDetHead,
+                   SingleDiffusionDetHead, SinusoidalPositionEmbeddings)
+from .loss import DiffusionDetCriterion, DiffusionDetMatcher
+
+__all__ = [
+    'DiffusionDet', 'DynamicDiffusionDetHead', 'SingleDiffusionDetHead',
+    'SinusoidalPositionEmbeddings', 'DynamicConv', 'DiffusionDetCriterion',
+    'DiffusionDetMatcher'
+]
diff --git a/mmdetection/projects/DiffusionDet/diffusiondet/diffusiondet.py b/mmdetection/projects/DiffusionDet/diffusiondet/diffusiondet.py
new file mode 100644
index 00000000..5a46ddf7
--- /dev/null
+++ b/mmdetection/projects/DiffusionDet/diffusiondet/diffusiondet.py
@@ -0,0 +1,26 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.models import SingleStageDetector
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+
+
+@MODELS.register_module()
+class DiffusionDet(SingleStageDetector):
+    """Implementation of `DiffusionDet <>`_"""
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/projects/DiffusionDet/diffusiondet/head.py b/mmdetection/projects/DiffusionDet/diffusiondet/head.py
new file mode 100644
index 00000000..794c9c9f
--- /dev/null
+++ b/mmdetection/projects/DiffusionDet/diffusiondet/head.py
@@ -0,0 +1,1034 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+# Modified from https://github.com/ShoufaChen/DiffusionDet/blob/main/diffusiondet/detector.py   # noqa
+# Modified from https://github.com/ShoufaChen/DiffusionDet/blob/main/diffusiondet/head.py   # noqa
+
+# This work is licensed under the CC-BY-NC 4.0 License.
+# Users should be careful about adopting these features in any commercial matters.    # noqa
+# For more details, please refer to https://github.com/ShoufaChen/DiffusionDet/blob/main/LICENSE    # noqa
+
+import copy
+import math
+import random
+import warnings
+from typing import Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import build_activation_layer
+from mmcv.ops import batched_nms
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.structures import SampleList
+from mmdet.structures.bbox import (bbox2roi, bbox_cxcywh_to_xyxy,
+                                   bbox_xyxy_to_cxcywh, get_box_wh,
+                                   scale_boxes)
+from mmdet.utils import InstanceList
+
+_DEFAULT_SCALE_CLAMP = math.log(100000.0 / 16)
+
+
+def cosine_beta_schedule(timesteps, s=0.008):
+    """Cosine schedule as proposed in
+    https://openreview.net/forum?id=-NEXDKk8gZ."""
+    steps = timesteps + 1
+    x = torch.linspace(0, timesteps, steps, dtype=torch.float64)
+    alphas_cumprod = torch.cos(
+        ((x / timesteps) + s) / (1 + s) * math.pi * 0.5)**2
+    alphas_cumprod = alphas_cumprod / alphas_cumprod[0]
+    betas = 1 - (alphas_cumprod[1:] / alphas_cumprod[:-1])
+    return torch.clip(betas, 0, 0.999)
+
+
+def extract(a, t, x_shape):
+    """extract the appropriate t index for a batch of indices."""
+    batch_size = t.shape[0]
+    out = a.gather(-1, t)
+    return out.reshape(batch_size, *((1, ) * (len(x_shape) - 1)))
+
+
+class SinusoidalPositionEmbeddings(nn.Module):
+
+    def __init__(self, dim):
+        super().__init__()
+        self.dim = dim
+
+    def forward(self, time):
+        device = time.device
+        half_dim = self.dim // 2
+        embeddings = math.log(10000) / (half_dim - 1)
+        embeddings = torch.exp(
+            torch.arange(half_dim, device=device) * -embeddings)
+        embeddings = time[:, None] * embeddings[None, :]
+        embeddings = torch.cat((embeddings.sin(), embeddings.cos()), dim=-1)
+        return embeddings
+
+
+@MODELS.register_module()
+class DynamicDiffusionDetHead(nn.Module):
+
+    def __init__(self,
+                 num_classes=80,
+                 feat_channels=256,
+                 num_proposals=500,
+                 num_heads=6,
+                 prior_prob=0.01,
+                 snr_scale=2.0,
+                 timesteps=1000,
+                 sampling_timesteps=1,
+                 self_condition=False,
+                 box_renewal=True,
+                 use_ensemble=True,
+                 deep_supervision=True,
+                 ddim_sampling_eta=1.0,
+                 criterion=dict(
+                     type='DiffusionDetCriterion',
+                     num_classes=80,
+                     assigner=dict(
+                         type='DiffusionDetMatcher',
+                         match_costs=[
+                             dict(
+                                 type='FocalLossCost',
+                                 alpha=2.0,
+                                 gamma=0.25,
+                                 weight=2.0),
+                             dict(
+                                 type='BBoxL1Cost',
+                                 weight=5.0,
+                                 box_format='xyxy'),
+                             dict(type='IoUCost', iou_mode='giou', weight=2.0)
+                         ],
+                         center_radius=2.5,
+                         candidate_topk=5),
+                 ),
+                 single_head=dict(
+                     type='DiffusionDetHead',
+                     num_cls_convs=1,
+                     num_reg_convs=3,
+                     dim_feedforward=2048,
+                     num_heads=8,
+                     dropout=0.0,
+                     act_cfg=dict(type='ReLU'),
+                     dynamic_conv=dict(dynamic_dim=64, dynamic_num=2)),
+                 roi_extractor=dict(
+                     type='SingleRoIExtractor',
+                     roi_layer=dict(
+                         type='RoIAlign', output_size=7, sampling_ratio=2),
+                     out_channels=256,
+                     featmap_strides=[4, 8, 16, 32]),
+                 test_cfg=None,
+                 **kwargs) -> None:
+        super().__init__()
+        self.roi_extractor = MODELS.build(roi_extractor)
+
+        self.num_classes = num_classes
+        self.num_classes = num_classes
+        self.feat_channels = feat_channels
+        self.num_proposals = num_proposals
+        self.num_heads = num_heads
+        # Build Diffusion
+        assert isinstance(timesteps, int), 'The type of `timesteps` should ' \
+                                           f'be int but got {type(timesteps)}'
+        assert sampling_timesteps <= timesteps
+        self.timesteps = timesteps
+        self.sampling_timesteps = sampling_timesteps
+        self.snr_scale = snr_scale
+
+        self.ddim_sampling = self.sampling_timesteps < self.timesteps
+        self.ddim_sampling_eta = ddim_sampling_eta
+        self.self_condition = self_condition
+        self.box_renewal = box_renewal
+        self.use_ensemble = use_ensemble
+
+        self._build_diffusion()
+
+        # Build assigner
+        assert criterion.get('assigner', None) is not None
+        assigner = TASK_UTILS.build(criterion.get('assigner'))
+        # Init parameters.
+        self.use_focal_loss = assigner.use_focal_loss
+        self.use_fed_loss = assigner.use_fed_loss
+
+        # build criterion
+        criterion.update(deep_supervision=deep_supervision)
+        self.criterion = TASK_UTILS.build(criterion)
+
+        # Build Dynamic Head.
+        single_head_ = single_head.copy()
+        single_head_num_classes = single_head_.get('num_classes', None)
+        if single_head_num_classes is None:
+            single_head_.update(num_classes=num_classes)
+        else:
+            if single_head_num_classes != num_classes:
+                warnings.warn(
+                    'The `num_classes` of `DynamicDiffusionDetHead` and '
+                    '`SingleDiffusionDetHead` should be same, changing '
+                    f'`single_head.num_classes` to {num_classes}')
+                single_head_.update(num_classes=num_classes)
+
+        single_head_feat_channels = single_head_.get('feat_channels', None)
+        if single_head_feat_channels is None:
+            single_head_.update(feat_channels=feat_channels)
+        else:
+            if single_head_feat_channels != feat_channels:
+                warnings.warn(
+                    'The `feat_channels` of `DynamicDiffusionDetHead` and '
+                    '`SingleDiffusionDetHead` should be same, changing '
+                    f'`single_head.feat_channels` to {feat_channels}')
+                single_head_.update(feat_channels=feat_channels)
+
+        default_pooler_resolution = roi_extractor['roi_layer'].get(
+            'output_size')
+        assert default_pooler_resolution is not None
+        single_head_pooler_resolution = single_head_.get('pooler_resolution')
+        if single_head_pooler_resolution is None:
+            single_head_.update(pooler_resolution=default_pooler_resolution)
+        else:
+            if single_head_pooler_resolution != default_pooler_resolution:
+                warnings.warn(
+                    'The `pooler_resolution` of `DynamicDiffusionDetHead` '
+                    'and `SingleDiffusionDetHead` should be same, changing '
+                    f'`single_head.pooler_resolution` to {num_classes}')
+                single_head_.update(
+                    pooler_resolution=default_pooler_resolution)
+
+        single_head_.update(
+            use_focal_loss=self.use_focal_loss, use_fed_loss=self.use_fed_loss)
+        single_head_module = MODELS.build(single_head_)
+
+        self.num_heads = num_heads
+        self.head_series = nn.ModuleList(
+            [copy.deepcopy(single_head_module) for _ in range(num_heads)])
+
+        self.deep_supervision = deep_supervision
+
+        # Gaussian random feature embedding layer for time
+        time_dim = feat_channels * 4
+        self.time_mlp = nn.Sequential(
+            SinusoidalPositionEmbeddings(feat_channels),
+            nn.Linear(feat_channels, time_dim), nn.GELU(),
+            nn.Linear(time_dim, time_dim))
+
+        self.prior_prob = prior_prob
+        self.test_cfg = test_cfg
+        self.use_nms = self.test_cfg.get('use_nms', True)
+        self._init_weights()
+
+    def _init_weights(self):
+        # init all parameters.
+        bias_value = -math.log((1 - self.prior_prob) / self.prior_prob)
+        for p in self.parameters():
+            if p.dim() > 1:
+                nn.init.xavier_uniform_(p)
+
+            # initialize the bias for focal loss and fed loss.
+            if self.use_focal_loss or self.use_fed_loss:
+                if p.shape[-1] == self.num_classes or \
+                        p.shape[-1] == self.num_classes + 1:
+                    nn.init.constant_(p, bias_value)
+
+    def _build_diffusion(self):
+        betas = cosine_beta_schedule(self.timesteps)
+        alphas = 1. - betas
+        alphas_cumprod = torch.cumprod(alphas, dim=0)
+        alphas_cumprod_prev = F.pad(alphas_cumprod[:-1], (1, 0), value=1.)
+
+        self.register_buffer('betas', betas)
+        self.register_buffer('alphas_cumprod', alphas_cumprod)
+        self.register_buffer('alphas_cumprod_prev', alphas_cumprod_prev)
+
+        # calculations for diffusion q(x_t | x_{t-1}) and others
+        self.register_buffer('sqrt_alphas_cumprod', torch.sqrt(alphas_cumprod))
+        self.register_buffer('sqrt_one_minus_alphas_cumprod',
+                             torch.sqrt(1. - alphas_cumprod))
+        self.register_buffer('log_one_minus_alphas_cumprod',
+                             torch.log(1. - alphas_cumprod))
+        self.register_buffer('sqrt_recip_alphas_cumprod',
+                             torch.sqrt(1. / alphas_cumprod))
+        self.register_buffer('sqrt_recipm1_alphas_cumprod',
+                             torch.sqrt(1. / alphas_cumprod - 1))
+
+        # calculations for posterior q(x_{t-1} | x_t, x_0)
+        # equal to 1. / (1. / (1. - alpha_cumprod_tm1) + alpha_t / beta_t)
+        posterior_variance = betas * (1. - alphas_cumprod_prev) / (
+            1. - alphas_cumprod)
+        self.register_buffer('posterior_variance', posterior_variance)
+
+        # log calculation clipped because the posterior variance is 0 at
+        # the beginning of the diffusion chain
+        self.register_buffer('posterior_log_variance_clipped',
+                             torch.log(posterior_variance.clamp(min=1e-20)))
+        self.register_buffer(
+            'posterior_mean_coef1',
+            betas * torch.sqrt(alphas_cumprod_prev) / (1. - alphas_cumprod))
+        self.register_buffer('posterior_mean_coef2',
+                             (1. - alphas_cumprod_prev) * torch.sqrt(alphas) /
+                             (1. - alphas_cumprod))
+
+    def forward(self, features, init_bboxes, init_t, init_features=None):
+        time = self.time_mlp(init_t, )
+
+        inter_class_logits = []
+        inter_pred_bboxes = []
+
+        bs = len(features[0])
+        bboxes = init_bboxes
+
+        if init_features is not None:
+            init_features = init_features[None].repeat(1, bs, 1)
+            proposal_features = init_features.clone()
+        else:
+            proposal_features = None
+
+        for head_idx, single_head in enumerate(self.head_series):
+            class_logits, pred_bboxes, proposal_features = single_head(
+                features, bboxes, proposal_features, self.roi_extractor, time)
+            if self.deep_supervision:
+                inter_class_logits.append(class_logits)
+                inter_pred_bboxes.append(pred_bboxes)
+            bboxes = pred_bboxes.detach()
+
+        if self.deep_supervision:
+            return torch.stack(inter_class_logits), torch.stack(
+                inter_pred_bboxes)
+        else:
+            return class_logits[None, ...], pred_bboxes[None, ...]
+
+    def loss(self, x: Tuple[Tensor], batch_data_samples: SampleList) -> dict:
+        """Perform forward propagation and loss calculation of the detection
+        head on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Features from the upstream network, each is
+                a 4D-tensor.
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        prepare_outputs = self.prepare_training_targets(batch_data_samples)
+        (batch_gt_instances, batch_pred_instances, batch_gt_instances_ignore,
+         batch_img_metas) = prepare_outputs
+
+        batch_diff_bboxes = torch.stack([
+            pred_instances.diff_bboxes_abs
+            for pred_instances in batch_pred_instances
+        ])
+        batch_time = torch.stack(
+            [pred_instances.time for pred_instances in batch_pred_instances])
+
+        pred_logits, pred_bboxes = self(x, batch_diff_bboxes, batch_time)
+
+        output = {
+            'pred_logits': pred_logits[-1],
+            'pred_boxes': pred_bboxes[-1]
+        }
+        if self.deep_supervision:
+            output['aux_outputs'] = [{
+                'pred_logits': a,
+                'pred_boxes': b
+            } for a, b in zip(pred_logits[:-1], pred_bboxes[:-1])]
+
+        losses = self.criterion(output, batch_gt_instances, batch_img_metas)
+        return losses
+
+    def prepare_training_targets(self, batch_data_samples):
+        # hard-setting seed to keep results same (if necessary)
+        # random.seed(0)
+        # torch.manual_seed(0)
+        # torch.cuda.manual_seed_all(0)
+        # torch.backends.cudnn.deterministic = True
+        # torch.backends.cudnn.benchmark = False
+
+        batch_gt_instances = []
+        batch_pred_instances = []
+        batch_gt_instances_ignore = []
+        batch_img_metas = []
+        for data_sample in batch_data_samples:
+            img_meta = data_sample.metainfo
+            gt_instances = data_sample.gt_instances
+
+            gt_bboxes = gt_instances.bboxes
+            h, w = img_meta['img_shape']
+            image_size = gt_bboxes.new_tensor([w, h, w, h])
+
+            norm_gt_bboxes = gt_bboxes / image_size
+            norm_gt_bboxes_cxcywh = bbox_xyxy_to_cxcywh(norm_gt_bboxes)
+            pred_instances = self.prepare_diffusion(norm_gt_bboxes_cxcywh,
+                                                    image_size)
+
+            gt_instances.set_metainfo(dict(image_size=image_size))
+            gt_instances.norm_bboxes_cxcywh = norm_gt_bboxes_cxcywh
+
+            batch_gt_instances.append(gt_instances)
+            batch_pred_instances.append(pred_instances)
+            batch_img_metas.append(data_sample.metainfo)
+            if 'ignored_instances' in data_sample:
+                batch_gt_instances_ignore.append(data_sample.ignored_instances)
+            else:
+                batch_gt_instances_ignore.append(None)
+        return (batch_gt_instances, batch_pred_instances,
+                batch_gt_instances_ignore, batch_img_metas)
+
+    def prepare_diffusion(self, gt_boxes, image_size):
+        device = gt_boxes.device
+        time = torch.randint(
+            0, self.timesteps, (1, ), dtype=torch.long, device=device)
+        noise = torch.randn(self.num_proposals, 4, device=device)
+
+        num_gt = gt_boxes.shape[0]
+        if num_gt < self.num_proposals:
+            # 3 * sigma = 1/2 --> sigma: 1/6
+            box_placeholder = torch.randn(
+                self.num_proposals - num_gt, 4, device=device) / 6. + 0.5
+            box_placeholder[:, 2:] = torch.clip(
+                box_placeholder[:, 2:], min=1e-4)
+            x_start = torch.cat((gt_boxes, box_placeholder), dim=0)
+        else:
+            select_mask = [True] * self.num_proposals + \
+                          [False] * (num_gt - self.num_proposals)
+            random.shuffle(select_mask)
+            x_start = gt_boxes[select_mask]
+
+        x_start = (x_start * 2. - 1.) * self.snr_scale
+
+        # noise sample
+        x = self.q_sample(x_start=x_start, time=time, noise=noise)
+
+        x = torch.clamp(x, min=-1 * self.snr_scale, max=self.snr_scale)
+        x = ((x / self.snr_scale) + 1) / 2.
+
+        diff_bboxes = bbox_cxcywh_to_xyxy(x)
+        # convert to abs bboxes
+        diff_bboxes_abs = diff_bboxes * image_size
+
+        metainfo = dict(time=time.squeeze(-1))
+        pred_instances = InstanceData(metainfo=metainfo)
+        pred_instances.diff_bboxes = diff_bboxes
+        pred_instances.diff_bboxes_abs = diff_bboxes_abs
+        pred_instances.noise = noise
+        return pred_instances
+
+    # forward diffusion
+    def q_sample(self, x_start, time, noise=None):
+        if noise is None:
+            noise = torch.randn_like(x_start)
+
+        x_start_shape = x_start.shape
+
+        sqrt_alphas_cumprod_t = extract(self.sqrt_alphas_cumprod, time,
+                                        x_start_shape)
+        sqrt_one_minus_alphas_cumprod_t = extract(
+            self.sqrt_one_minus_alphas_cumprod, time, x_start_shape)
+
+        return sqrt_alphas_cumprod_t * x_start + \
+            sqrt_one_minus_alphas_cumprod_t * noise
+
+    def predict(self,
+                x: Tuple[Tensor],
+                batch_data_samples: SampleList,
+                rescale: bool = False) -> InstanceList:
+        """Perform forward propagation of the detection head and predict
+        detection results on the features of the upstream network.
+
+        Args:
+            x (tuple[Tensor]): Multi-level features from the
+                upstream network, each is a 4D-tensor.
+            batch_data_samples (List[:obj:`DetDataSample`]): The Data
+                Samples. It usually includes information such as
+                `gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
+            rescale (bool, optional): Whether to rescale the results.
+                Defaults to False.
+
+        Returns:
+            list[obj:`InstanceData`]: Detection results of each image
+            after the post process.
+        """
+        # hard-setting seed to keep results same (if necessary)
+        # seed = 0
+        # random.seed(seed)
+        # torch.manual_seed(seed)
+        # torch.cuda.manual_seed_all(seed)
+
+        device = x[-1].device
+
+        batch_img_metas = [
+            data_samples.metainfo for data_samples in batch_data_samples
+        ]
+
+        (time_pairs, batch_noise_bboxes, batch_noise_bboxes_raw,
+         batch_image_size) = self.prepare_testing_targets(
+             batch_img_metas, device)
+
+        predictions = self.predict_by_feat(
+            x,
+            time_pairs=time_pairs,
+            batch_noise_bboxes=batch_noise_bboxes,
+            batch_noise_bboxes_raw=batch_noise_bboxes_raw,
+            batch_image_size=batch_image_size,
+            device=device,
+            batch_img_metas=batch_img_metas)
+        return predictions
+
+    def predict_by_feat(self,
+                        x,
+                        time_pairs,
+                        batch_noise_bboxes,
+                        batch_noise_bboxes_raw,
+                        batch_image_size,
+                        device,
+                        batch_img_metas=None,
+                        cfg=None,
+                        rescale=True):
+
+        batch_size = len(batch_img_metas)
+
+        cfg = self.test_cfg if cfg is None else cfg
+        cfg = copy.deepcopy(cfg)
+
+        ensemble_score, ensemble_label, ensemble_coord = [], [], []
+        for time, time_next in time_pairs:
+            batch_time = torch.full((batch_size, ),
+                                    time,
+                                    device=device,
+                                    dtype=torch.long)
+            # self_condition = x_start if self.self_condition else None
+            pred_logits, pred_bboxes = self(x, batch_noise_bboxes, batch_time)
+
+            x_start = pred_bboxes[-1]
+
+            x_start = x_start / batch_image_size[:, None, :]
+            x_start = bbox_xyxy_to_cxcywh(x_start)
+            x_start = (x_start * 2 - 1.) * self.snr_scale
+            x_start = torch.clamp(
+                x_start, min=-1 * self.snr_scale, max=self.snr_scale)
+            pred_noise = self.predict_noise_from_start(batch_noise_bboxes_raw,
+                                                       batch_time, x_start)
+            pred_noise_list, x_start_list = [], []
+            noise_bboxes_list, num_remain_list = [], []
+            if self.box_renewal:  # filter
+                score_thr = cfg.get('score_thr', 0)
+                for img_id in range(batch_size):
+                    score_per_image = pred_logits[-1][img_id]
+
+                    score_per_image = torch.sigmoid(score_per_image)
+                    value, _ = torch.max(score_per_image, -1, keepdim=False)
+                    keep_idx = value > score_thr
+
+                    num_remain_list.append(torch.sum(keep_idx))
+                    pred_noise_list.append(pred_noise[img_id, keep_idx, :])
+                    x_start_list.append(x_start[img_id, keep_idx, :])
+                    noise_bboxes_list.append(batch_noise_bboxes[img_id,
+                                                                keep_idx, :])
+            if time_next < 0:
+                # Not same as original DiffusionDet
+                if self.use_ensemble and self.sampling_timesteps > 1:
+                    box_pred_per_image, scores_per_image, labels_per_image = \
+                        self.inference(
+                            box_cls=pred_logits[-1],
+                            box_pred=pred_bboxes[-1],
+                            cfg=cfg,
+                            device=device)
+                    ensemble_score.append(scores_per_image)
+                    ensemble_label.append(labels_per_image)
+                    ensemble_coord.append(box_pred_per_image)
+                continue
+
+            alpha = self.alphas_cumprod[time]
+            alpha_next = self.alphas_cumprod[time_next]
+
+            sigma = self.ddim_sampling_eta * ((1 - alpha / alpha_next) *
+                                              (1 - alpha_next) /
+                                              (1 - alpha)).sqrt()
+            c = (1 - alpha_next - sigma**2).sqrt()
+
+            batch_noise_bboxes_list = []
+            batch_noise_bboxes_raw_list = []
+            for idx in range(batch_size):
+                pred_noise = pred_noise_list[idx]
+                x_start = x_start_list[idx]
+                noise_bboxes = noise_bboxes_list[idx]
+                num_remain = num_remain_list[idx]
+                noise = torch.randn_like(noise_bboxes)
+
+                noise_bboxes = x_start * alpha_next.sqrt() + \
+                    c * pred_noise + sigma * noise
+
+                if self.box_renewal:  # filter
+                    # replenish with randn boxes
+                    if num_remain < self.num_proposals:
+                        noise_bboxes = torch.cat(
+                            (noise_bboxes,
+                             torch.randn(
+                                 self.num_proposals - num_remain,
+                                 4,
+                                 device=device)),
+                            dim=0)
+                    else:
+                        select_mask = [True] * self.num_proposals + \
+                                      [False] * (num_remain -
+                                                 self.num_proposals)
+                        random.shuffle(select_mask)
+                        noise_bboxes = noise_bboxes[select_mask]
+
+                    # raw noise boxes
+                    batch_noise_bboxes_raw_list.append(noise_bboxes)
+                    # resize to xyxy
+                    noise_bboxes = torch.clamp(
+                        noise_bboxes,
+                        min=-1 * self.snr_scale,
+                        max=self.snr_scale)
+                    noise_bboxes = ((noise_bboxes / self.snr_scale) + 1) / 2
+                    noise_bboxes = bbox_cxcywh_to_xyxy(noise_bboxes)
+                    noise_bboxes = noise_bboxes * batch_image_size[idx]
+
+                batch_noise_bboxes_list.append(noise_bboxes)
+            batch_noise_bboxes = torch.stack(batch_noise_bboxes_list)
+            batch_noise_bboxes_raw = torch.stack(batch_noise_bboxes_raw_list)
+            if self.use_ensemble and self.sampling_timesteps > 1:
+                box_pred_per_image, scores_per_image, labels_per_image = \
+                    self.inference(
+                        box_cls=pred_logits[-1],
+                        box_pred=pred_bboxes[-1],
+                        cfg=cfg,
+                        device=device)
+                ensemble_score.append(scores_per_image)
+                ensemble_label.append(labels_per_image)
+                ensemble_coord.append(box_pred_per_image)
+        if self.use_ensemble and self.sampling_timesteps > 1:
+            steps = len(ensemble_score)
+            results_list = []
+            for idx in range(batch_size):
+                ensemble_score_per_img = [
+                    ensemble_score[i][idx] for i in range(steps)
+                ]
+                ensemble_label_per_img = [
+                    ensemble_label[i][idx] for i in range(steps)
+                ]
+                ensemble_coord_per_img = [
+                    ensemble_coord[i][idx] for i in range(steps)
+                ]
+
+                scores_per_image = torch.cat(ensemble_score_per_img, dim=0)
+                labels_per_image = torch.cat(ensemble_label_per_img, dim=0)
+                box_pred_per_image = torch.cat(ensemble_coord_per_img, dim=0)
+
+                if self.use_nms:
+                    det_bboxes, keep_idxs = batched_nms(
+                        box_pred_per_image, scores_per_image, labels_per_image,
+                        cfg.nms)
+                    box_pred_per_image = box_pred_per_image[keep_idxs]
+                    labels_per_image = labels_per_image[keep_idxs]
+                    scores_per_image = det_bboxes[:, -1]
+                results = InstanceData()
+                results.bboxes = box_pred_per_image
+                results.scores = scores_per_image
+                results.labels = labels_per_image
+            results_list.append(results)
+        else:
+            box_cls = pred_logits[-1]
+            box_pred = pred_bboxes[-1]
+            results_list = self.inference(box_cls, box_pred, cfg, device)
+        if rescale:
+            results_list = self.do_results_post_process(
+                results_list, cfg, batch_img_metas=batch_img_metas)
+        return results_list
+
+    @staticmethod
+    def do_results_post_process(results_list, cfg, batch_img_metas=None):
+        processed_results = []
+        for results, img_meta in zip(results_list, batch_img_metas):
+            assert img_meta.get('scale_factor') is not None
+            scale_factor = [1 / s for s in img_meta['scale_factor']]
+            results.bboxes = scale_boxes(results.bboxes, scale_factor)
+            # clip w, h
+            h, w = img_meta['ori_shape']
+            results.bboxes[:, 0::2] = results.bboxes[:, 0::2].clamp(
+                min=0, max=w)
+            results.bboxes[:, 1::2] = results.bboxes[:, 1::2].clamp(
+                min=0, max=h)
+
+            # filter small size bboxes
+            if cfg.get('min_bbox_size', 0) >= 0:
+                w, h = get_box_wh(results.bboxes)
+                valid_mask = (w > cfg.min_bbox_size) & (h > cfg.min_bbox_size)
+                if not valid_mask.all():
+                    results = results[valid_mask]
+            processed_results.append(results)
+
+        return processed_results
+
+    def prepare_testing_targets(self, batch_img_metas, device):
+        # [-1, 0, 1, 2, ..., T-1] when sampling_timesteps == timesteps
+        times = torch.linspace(
+            -1, self.timesteps - 1, steps=self.sampling_timesteps + 1)
+        times = list(reversed(times.int().tolist()))
+        # [(T-1, T-2), (T-2, T-3), ..., (1, 0), (0, -1)]
+        time_pairs = list(zip(times[:-1], times[1:]))
+
+        noise_bboxes_list = []
+        noise_bboxes_raw_list = []
+        image_size_list = []
+        for img_meta in batch_img_metas:
+            h, w = img_meta['img_shape']
+            image_size = torch.tensor([w, h, w, h],
+                                      dtype=torch.float32,
+                                      device=device)
+            noise_bboxes_raw = torch.randn((self.num_proposals, 4),
+                                           device=device)
+            noise_bboxes = torch.clamp(
+                noise_bboxes_raw, min=-1 * self.snr_scale, max=self.snr_scale)
+            noise_bboxes = ((noise_bboxes / self.snr_scale) + 1) / 2
+            noise_bboxes = bbox_cxcywh_to_xyxy(noise_bboxes)
+            noise_bboxes = noise_bboxes * image_size
+
+            noise_bboxes_raw_list.append(noise_bboxes_raw)
+            noise_bboxes_list.append(noise_bboxes)
+            image_size_list.append(image_size[None])
+        batch_noise_bboxes = torch.stack(noise_bboxes_list)
+        batch_image_size = torch.cat(image_size_list)
+        batch_noise_bboxes_raw = torch.stack(noise_bboxes_raw_list)
+        return (time_pairs, batch_noise_bboxes, batch_noise_bboxes_raw,
+                batch_image_size)
+
+    def predict_noise_from_start(self, x_t, t, x0):
+        results = (extract(
+            self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t - x0) / \
+                  extract(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape)
+        return results
+
+    def inference(self, box_cls, box_pred, cfg, device):
+        """
+        Args:
+            box_cls (Tensor): tensor of shape (batch_size, num_proposals, K).
+                The tensor predicts the classification probability for
+                each proposal.
+            box_pred (Tensor): tensors of shape (batch_size, num_proposals, 4).
+                The tensor predicts 4-vector (x,y,w,h) box
+                regression values for every proposal
+
+        Returns:
+            results (List[Instances]): a list of #images elements.
+        """
+        results = []
+
+        if self.use_focal_loss or self.use_fed_loss:
+            scores = torch.sigmoid(box_cls)
+            labels = torch.arange(
+                self.num_classes,
+                device=device).unsqueeze(0).repeat(self.num_proposals,
+                                                   1).flatten(0, 1)
+            box_pred_list = []
+            scores_list = []
+            labels_list = []
+            for i, (scores_per_image,
+                    box_pred_per_image) in enumerate(zip(scores, box_pred)):
+
+                scores_per_image, topk_indices = scores_per_image.flatten(
+                    0, 1).topk(
+                        self.num_proposals, sorted=False)
+                labels_per_image = labels[topk_indices]
+                box_pred_per_image = box_pred_per_image.view(-1, 1, 4).repeat(
+                    1, self.num_classes, 1).view(-1, 4)
+                box_pred_per_image = box_pred_per_image[topk_indices]
+
+                if self.use_ensemble and self.sampling_timesteps > 1:
+                    box_pred_list.append(box_pred_per_image)
+                    scores_list.append(scores_per_image)
+                    labels_list.append(labels_per_image)
+                    continue
+
+                if self.use_nms:
+                    det_bboxes, keep_idxs = batched_nms(
+                        box_pred_per_image, scores_per_image, labels_per_image,
+                        cfg.nms)
+                    box_pred_per_image = box_pred_per_image[keep_idxs]
+                    labels_per_image = labels_per_image[keep_idxs]
+                    # some nms would reweight the score, such as softnms
+                    scores_per_image = det_bboxes[:, -1]
+                result = InstanceData()
+                result.bboxes = box_pred_per_image
+                result.scores = scores_per_image
+                result.labels = labels_per_image
+                results.append(result)
+
+        else:
+            # For each box we assign the best class or the second
+            # best if the best on is `no_object`.
+            scores, labels = F.softmax(box_cls, dim=-1)[:, :, :-1].max(-1)
+
+            for i, (scores_per_image, labels_per_image,
+                    box_pred_per_image) in enumerate(
+                        zip(scores, labels, box_pred)):
+                if self.use_ensemble and self.sampling_timesteps > 1:
+                    return box_pred_per_image, scores_per_image, \
+                           labels_per_image
+
+                if self.use_nms:
+                    det_bboxes, keep_idxs = batched_nms(
+                        box_pred_per_image, scores_per_image, labels_per_image,
+                        cfg.nms)
+                    box_pred_per_image = box_pred_per_image[keep_idxs]
+                    labels_per_image = labels_per_image[keep_idxs]
+                    # some nms would reweight the score, such as softnms
+                    scores_per_image = det_bboxes[:, -1]
+
+                result = InstanceData()
+                result.bboxes = box_pred_per_image
+                result.scores = scores_per_image
+                result.labels = labels_per_image
+                results.append(result)
+        if self.use_ensemble and self.sampling_timesteps > 1:
+            return box_pred_list, scores_list, labels_list
+        else:
+            return results
+
+
+@MODELS.register_module()
+class SingleDiffusionDetHead(nn.Module):
+
+    def __init__(
+        self,
+        num_classes=80,
+        feat_channels=256,
+        dim_feedforward=2048,
+        num_cls_convs=1,
+        num_reg_convs=3,
+        num_heads=8,
+        dropout=0.0,
+        pooler_resolution=7,
+        scale_clamp=_DEFAULT_SCALE_CLAMP,
+        bbox_weights=(2.0, 2.0, 1.0, 1.0),
+        use_focal_loss=True,
+        use_fed_loss=False,
+        act_cfg=dict(type='ReLU', inplace=True),
+        dynamic_conv=dict(dynamic_dim=64, dynamic_num=2)
+    ) -> None:
+        super().__init__()
+        self.feat_channels = feat_channels
+
+        # Dynamic
+        self.self_attn = nn.MultiheadAttention(
+            feat_channels, num_heads, dropout=dropout)
+        self.inst_interact = DynamicConv(
+            feat_channels=feat_channels,
+            pooler_resolution=pooler_resolution,
+            dynamic_dim=dynamic_conv['dynamic_dim'],
+            dynamic_num=dynamic_conv['dynamic_num'])
+
+        self.linear1 = nn.Linear(feat_channels, dim_feedforward)
+        self.dropout = nn.Dropout(dropout)
+        self.linear2 = nn.Linear(dim_feedforward, feat_channels)
+
+        self.norm1 = nn.LayerNorm(feat_channels)
+        self.norm2 = nn.LayerNorm(feat_channels)
+        self.norm3 = nn.LayerNorm(feat_channels)
+        self.dropout1 = nn.Dropout(dropout)
+        self.dropout2 = nn.Dropout(dropout)
+        self.dropout3 = nn.Dropout(dropout)
+
+        self.activation = build_activation_layer(act_cfg)
+
+        # block time mlp
+        self.block_time_mlp = nn.Sequential(
+            nn.SiLU(), nn.Linear(feat_channels * 4, feat_channels * 2))
+
+        # cls.
+        cls_module = list()
+        for _ in range(num_cls_convs):
+            cls_module.append(nn.Linear(feat_channels, feat_channels, False))
+            cls_module.append(nn.LayerNorm(feat_channels))
+            cls_module.append(nn.ReLU(inplace=True))
+        self.cls_module = nn.ModuleList(cls_module)
+
+        # reg.
+        reg_module = list()
+        for _ in range(num_reg_convs):
+            reg_module.append(nn.Linear(feat_channels, feat_channels, False))
+            reg_module.append(nn.LayerNorm(feat_channels))
+            reg_module.append(nn.ReLU(inplace=True))
+        self.reg_module = nn.ModuleList(reg_module)
+
+        # pred.
+        self.use_focal_loss = use_focal_loss
+        self.use_fed_loss = use_fed_loss
+        if self.use_focal_loss or self.use_fed_loss:
+            self.class_logits = nn.Linear(feat_channels, num_classes)
+        else:
+            self.class_logits = nn.Linear(feat_channels, num_classes + 1)
+        self.bboxes_delta = nn.Linear(feat_channels, 4)
+        self.scale_clamp = scale_clamp
+        self.bbox_weights = bbox_weights
+
+    def forward(self, features, bboxes, pro_features, pooler, time_emb):
+        """
+        :param bboxes: (N, num_boxes, 4)
+        :param pro_features: (N, num_boxes, feat_channels)
+        """
+
+        N, num_boxes = bboxes.shape[:2]
+
+        # roi_feature.
+        proposal_boxes = list()
+        for b in range(N):
+            proposal_boxes.append(bboxes[b])
+        rois = bbox2roi(proposal_boxes)
+
+        roi_features = pooler(features, rois)
+
+        if pro_features is None:
+            pro_features = roi_features.view(N, num_boxes, self.feat_channels,
+                                             -1).mean(-1)
+
+        roi_features = roi_features.view(N * num_boxes, self.feat_channels,
+                                         -1).permute(2, 0, 1)
+
+        # self_att.
+        pro_features = pro_features.view(N, num_boxes,
+                                         self.feat_channels).permute(1, 0, 2)
+        pro_features2 = self.self_attn(
+            pro_features, pro_features, value=pro_features)[0]
+        pro_features = pro_features + self.dropout1(pro_features2)
+        pro_features = self.norm1(pro_features)
+
+        # inst_interact.
+        pro_features = pro_features.view(
+            num_boxes, N,
+            self.feat_channels).permute(1, 0,
+                                        2).reshape(1, N * num_boxes,
+                                                   self.feat_channels)
+        pro_features2 = self.inst_interact(pro_features, roi_features)
+        pro_features = pro_features + self.dropout2(pro_features2)
+        obj_features = self.norm2(pro_features)
+
+        # obj_feature.
+        obj_features2 = self.linear2(
+            self.dropout(self.activation(self.linear1(obj_features))))
+        obj_features = obj_features + self.dropout3(obj_features2)
+        obj_features = self.norm3(obj_features)
+
+        fc_feature = obj_features.transpose(0, 1).reshape(N * num_boxes, -1)
+
+        scale_shift = self.block_time_mlp(time_emb)
+        scale_shift = torch.repeat_interleave(scale_shift, num_boxes, dim=0)
+        scale, shift = scale_shift.chunk(2, dim=1)
+        fc_feature = fc_feature * (scale + 1) + shift
+
+        cls_feature = fc_feature.clone()
+        reg_feature = fc_feature.clone()
+        for cls_layer in self.cls_module:
+            cls_feature = cls_layer(cls_feature)
+        for reg_layer in self.reg_module:
+            reg_feature = reg_layer(reg_feature)
+        class_logits = self.class_logits(cls_feature)
+        bboxes_deltas = self.bboxes_delta(reg_feature)
+        pred_bboxes = self.apply_deltas(bboxes_deltas, bboxes.view(-1, 4))
+
+        return (class_logits.view(N, num_boxes,
+                                  -1), pred_bboxes.view(N, num_boxes,
+                                                        -1), obj_features)
+
+    def apply_deltas(self, deltas, boxes):
+        """Apply transformation `deltas` (dx, dy, dw, dh) to `boxes`.
+
+        Args:
+            deltas (Tensor): transformation deltas of shape (N, k*4),
+                where k >= 1. deltas[i] represents k potentially
+                different class-specific box transformations for
+                the single box boxes[i].
+            boxes (Tensor): boxes to transform, of shape (N, 4)
+        """
+        boxes = boxes.to(deltas.dtype)
+
+        widths = boxes[:, 2] - boxes[:, 0]
+        heights = boxes[:, 3] - boxes[:, 1]
+        ctr_x = boxes[:, 0] + 0.5 * widths
+        ctr_y = boxes[:, 1] + 0.5 * heights
+
+        wx, wy, ww, wh = self.bbox_weights
+        dx = deltas[:, 0::4] / wx
+        dy = deltas[:, 1::4] / wy
+        dw = deltas[:, 2::4] / ww
+        dh = deltas[:, 3::4] / wh
+
+        # Prevent sending too large values into torch.exp()
+        dw = torch.clamp(dw, max=self.scale_clamp)
+        dh = torch.clamp(dh, max=self.scale_clamp)
+
+        pred_ctr_x = dx * widths[:, None] + ctr_x[:, None]
+        pred_ctr_y = dy * heights[:, None] + ctr_y[:, None]
+        pred_w = torch.exp(dw) * widths[:, None]
+        pred_h = torch.exp(dh) * heights[:, None]
+
+        pred_boxes = torch.zeros_like(deltas)
+        pred_boxes[:, 0::4] = pred_ctr_x - 0.5 * pred_w  # x1
+        pred_boxes[:, 1::4] = pred_ctr_y - 0.5 * pred_h  # y1
+        pred_boxes[:, 2::4] = pred_ctr_x + 0.5 * pred_w  # x2
+        pred_boxes[:, 3::4] = pred_ctr_y + 0.5 * pred_h  # y2
+
+        return pred_boxes
+
+
+class DynamicConv(nn.Module):
+
+    def __init__(self,
+                 feat_channels: int,
+                 dynamic_dim: int = 64,
+                 dynamic_num: int = 2,
+                 pooler_resolution: int = 7) -> None:
+        super().__init__()
+
+        self.feat_channels = feat_channels
+        self.dynamic_dim = dynamic_dim
+        self.dynamic_num = dynamic_num
+        self.num_params = self.feat_channels * self.dynamic_dim
+        self.dynamic_layer = nn.Linear(self.feat_channels,
+                                       self.dynamic_num * self.num_params)
+
+        self.norm1 = nn.LayerNorm(self.dynamic_dim)
+        self.norm2 = nn.LayerNorm(self.feat_channels)
+
+        self.activation = nn.ReLU(inplace=True)
+
+        num_output = self.feat_channels * pooler_resolution**2
+        self.out_layer = nn.Linear(num_output, self.feat_channels)
+        self.norm3 = nn.LayerNorm(self.feat_channels)
+
+    def forward(self, pro_features: Tensor, roi_features: Tensor) -> Tensor:
+        """Forward function.
+
+        Args:
+            pro_features: (1,  N * num_boxes, self.feat_channels)
+            roi_features: (49, N * num_boxes, self.feat_channels)
+
+        Returns:
+        """
+        features = roi_features.permute(1, 0, 2)
+        parameters = self.dynamic_layer(pro_features).permute(1, 0, 2)
+
+        param1 = parameters[:, :, :self.num_params].view(
+            -1, self.feat_channels, self.dynamic_dim)
+        param2 = parameters[:, :,
+                            self.num_params:].view(-1, self.dynamic_dim,
+                                                   self.feat_channels)
+
+        features = torch.bmm(features, param1)
+        features = self.norm1(features)
+        features = self.activation(features)
+
+        features = torch.bmm(features, param2)
+        features = self.norm2(features)
+        features = self.activation(features)
+
+        features = features.flatten(1)
+        features = self.out_layer(features)
+        features = self.norm3(features)
+        features = self.activation(features)
+
+        return features
diff --git a/mmdetection/projects/DiffusionDet/diffusiondet/loss.py b/mmdetection/projects/DiffusionDet/diffusiondet/loss.py
new file mode 100644
index 00000000..3d532f1f
--- /dev/null
+++ b/mmdetection/projects/DiffusionDet/diffusiondet/loss.py
@@ -0,0 +1,341 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+# Modified from https://github.com/ShoufaChen/DiffusionDet/blob/main/diffusiondet/loss.py   # noqa
+
+# This work is licensed under the CC-BY-NC 4.0 License.
+# Users should be careful about adopting these features in any commercial matters.  # noqa
+# For more details, please refer to https://github.com/ShoufaChen/DiffusionDet/blob/main/LICENSE    # noqa
+
+from typing import List, Tuple, Union
+
+import torch
+import torch.nn as nn
+from mmengine.config import ConfigDict
+from mmengine.structures import InstanceData
+from torch import Tensor
+
+from mmdet.registry import MODELS, TASK_UTILS
+from mmdet.structures.bbox import bbox_cxcywh_to_xyxy, bbox_xyxy_to_cxcywh
+from mmdet.utils import ConfigType
+
+
+@TASK_UTILS.register_module()
+class DiffusionDetCriterion(nn.Module):
+
+    def __init__(
+            self,
+            num_classes,
+            assigner: Union[ConfigDict, nn.Module],
+            deep_supervision=True,
+            loss_cls=dict(
+                type='FocalLoss',
+                use_sigmoid=True,
+                alpha=0.25,
+                gamma=2.0,
+                reduction='sum',
+                loss_weight=2.0),
+            loss_bbox=dict(type='L1Loss', reduction='sum', loss_weight=5.0),
+            loss_giou=dict(type='GIoULoss', reduction='sum', loss_weight=2.0),
+    ):
+
+        super().__init__()
+        self.num_classes = num_classes
+
+        if isinstance(assigner, nn.Module):
+            self.assigner = assigner
+        else:
+            self.assigner = TASK_UTILS.build(assigner)
+
+        self.deep_supervision = deep_supervision
+
+        self.loss_cls = MODELS.build(loss_cls)
+        self.loss_bbox = MODELS.build(loss_bbox)
+        self.loss_giou = MODELS.build(loss_giou)
+
+    def forward(self, outputs, batch_gt_instances, batch_img_metas):
+        batch_indices = self.assigner(outputs, batch_gt_instances,
+                                      batch_img_metas)
+        # Compute all the requested losses
+        loss_cls = self.loss_classification(outputs, batch_gt_instances,
+                                            batch_indices)
+        loss_bbox, loss_giou = self.loss_boxes(outputs, batch_gt_instances,
+                                               batch_indices)
+
+        losses = dict(
+            loss_cls=loss_cls, loss_bbox=loss_bbox, loss_giou=loss_giou)
+
+        if self.deep_supervision:
+            assert 'aux_outputs' in outputs
+            for i, aux_outputs in enumerate(outputs['aux_outputs']):
+                batch_indices = self.assigner(aux_outputs, batch_gt_instances,
+                                              batch_img_metas)
+                loss_cls = self.loss_classification(aux_outputs,
+                                                    batch_gt_instances,
+                                                    batch_indices)
+                loss_bbox, loss_giou = self.loss_boxes(aux_outputs,
+                                                       batch_gt_instances,
+                                                       batch_indices)
+                tmp_losses = dict(
+                    loss_cls=loss_cls,
+                    loss_bbox=loss_bbox,
+                    loss_giou=loss_giou)
+                for name, value in tmp_losses.items():
+                    losses[f's.{i}.{name}'] = value
+        return losses
+
+    def loss_classification(self, outputs, batch_gt_instances, indices):
+        assert 'pred_logits' in outputs
+        src_logits = outputs['pred_logits']
+        target_classes_list = [
+            gt.labels[J] for gt, (_, J) in zip(batch_gt_instances, indices)
+        ]
+        target_classes = torch.full(
+            src_logits.shape[:2],
+            self.num_classes,
+            dtype=torch.int64,
+            device=src_logits.device)
+        for idx in range(len(batch_gt_instances)):
+            target_classes[idx, indices[idx][0]] = target_classes_list[idx]
+
+        src_logits = src_logits.flatten(0, 1)
+        target_classes = target_classes.flatten(0, 1)
+        # comp focal loss.
+        num_instances = max(torch.cat(target_classes_list).shape[0], 1)
+        loss_cls = self.loss_cls(
+            src_logits,
+            target_classes,
+        ) / num_instances
+        return loss_cls
+
+    def loss_boxes(self, outputs, batch_gt_instances, indices):
+        assert 'pred_boxes' in outputs
+        pred_boxes = outputs['pred_boxes']
+
+        target_bboxes_norm_list = [
+            gt.norm_bboxes_cxcywh[J]
+            for gt, (_, J) in zip(batch_gt_instances, indices)
+        ]
+        target_bboxes_list = [
+            gt.bboxes[J] for gt, (_, J) in zip(batch_gt_instances, indices)
+        ]
+
+        pred_bboxes_list = []
+        pred_bboxes_norm_list = []
+        for idx in range(len(batch_gt_instances)):
+            pred_bboxes_list.append(pred_boxes[idx, indices[idx][0]])
+            image_size = batch_gt_instances[idx].image_size
+            pred_bboxes_norm_list.append(pred_boxes[idx, indices[idx][0]] /
+                                         image_size)
+
+        pred_boxes_cat = torch.cat(pred_bboxes_list)
+        pred_boxes_norm_cat = torch.cat(pred_bboxes_norm_list)
+        target_bboxes_cat = torch.cat(target_bboxes_list)
+        target_bboxes_norm_cat = torch.cat(target_bboxes_norm_list)
+
+        if len(pred_boxes_cat) > 0:
+            num_instances = pred_boxes_cat.shape[0]
+
+            loss_bbox = self.loss_bbox(
+                pred_boxes_norm_cat,
+                bbox_cxcywh_to_xyxy(target_bboxes_norm_cat)) / num_instances
+            loss_giou = self.loss_giou(pred_boxes_cat,
+                                       target_bboxes_cat) / num_instances
+        else:
+            loss_bbox = pred_boxes.sum() * 0
+            loss_giou = pred_boxes.sum() * 0
+        return loss_bbox, loss_giou
+
+
+@TASK_UTILS.register_module()
+class DiffusionDetMatcher(nn.Module):
+    """This class computes an assignment between the targets and the
+    predictions of the network For efficiency reasons, the targets don't
+    include the no_object.
+
+    Because of this, in general, there are more predictions than targets. In
+    this case, we do a 1-to-k (dynamic) matching of the best predictions, while
+    the others are un-matched (and thus treated as non-objects).
+    """
+
+    def __init__(self,
+                 match_costs: Union[List[Union[dict, ConfigDict]], dict,
+                                    ConfigDict],
+                 center_radius: float = 2.5,
+                 candidate_topk: int = 5,
+                 iou_calculator: ConfigType = dict(type='BboxOverlaps2D'),
+                 **kwargs):
+        super().__init__()
+
+        self.center_radius = center_radius
+        self.candidate_topk = candidate_topk
+
+        if isinstance(match_costs, dict):
+            match_costs = [match_costs]
+        elif isinstance(match_costs, list):
+            assert len(match_costs) > 0, \
+                'match_costs must not be a empty list.'
+        self.use_focal_loss = False
+        self.use_fed_loss = False
+        for _match_cost in match_costs:
+            if _match_cost.get('type') == 'FocalLossCost':
+                self.use_focal_loss = True
+            if _match_cost.get('type') == 'FedLoss':
+                self.use_fed_loss = True
+                raise NotImplementedError
+
+        self.match_costs = [
+            TASK_UTILS.build(match_cost) for match_cost in match_costs
+        ]
+        self.iou_calculator = TASK_UTILS.build(iou_calculator)
+
+    def forward(self, outputs, batch_gt_instances, batch_img_metas):
+        assert 'pred_logits' in outputs and 'pred_boxes' in outputs
+
+        pred_logits = outputs['pred_logits']
+        pred_bboxes = outputs['pred_boxes']
+        batch_size = len(batch_gt_instances)
+
+        assert batch_size == pred_logits.shape[0] == pred_bboxes.shape[0]
+        batch_indices = []
+        for i in range(batch_size):
+            pred_instances = InstanceData()
+            pred_instances.bboxes = pred_bboxes[i, ...]
+            pred_instances.scores = pred_logits[i, ...]
+            gt_instances = batch_gt_instances[i]
+            img_meta = batch_img_metas[i]
+            indices = self.single_assigner(pred_instances, gt_instances,
+                                           img_meta)
+            batch_indices.append(indices)
+        return batch_indices
+
+    def single_assigner(self, pred_instances, gt_instances, img_meta):
+        with torch.no_grad():
+            gt_bboxes = gt_instances.bboxes
+            pred_bboxes = pred_instances.bboxes
+            num_gt = gt_bboxes.size(0)
+
+            if num_gt == 0:  # empty object in key frame
+                valid_mask = pred_bboxes.new_zeros((pred_bboxes.shape[0], ),
+                                                   dtype=torch.bool)
+                matched_gt_inds = pred_bboxes.new_zeros((gt_bboxes.shape[0], ),
+                                                        dtype=torch.long)
+                return valid_mask, matched_gt_inds
+
+            valid_mask, is_in_boxes_and_center = \
+                self.get_in_gt_and_in_center_info(
+                    bbox_xyxy_to_cxcywh(pred_bboxes),
+                    bbox_xyxy_to_cxcywh(gt_bboxes)
+                )
+
+            cost_list = []
+            for match_cost in self.match_costs:
+                cost = match_cost(
+                    pred_instances=pred_instances,
+                    gt_instances=gt_instances,
+                    img_meta=img_meta)
+                cost_list.append(cost)
+
+            pairwise_ious = self.iou_calculator(pred_bboxes, gt_bboxes)
+
+            cost_list.append((~is_in_boxes_and_center) * 100.0)
+            cost_matrix = torch.stack(cost_list).sum(0)
+            cost_matrix[~valid_mask] = cost_matrix[~valid_mask] + 10000.0
+
+            fg_mask_inboxes, matched_gt_inds = \
+                self.dynamic_k_matching(
+                    cost_matrix, pairwise_ious, num_gt)
+        return fg_mask_inboxes, matched_gt_inds
+
+    def get_in_gt_and_in_center_info(
+            self, pred_bboxes: Tensor,
+            gt_bboxes: Tensor) -> Tuple[Tensor, Tensor]:
+        """Get the information of which prior is in gt bboxes and gt center
+        priors."""
+        xy_target_gts = bbox_cxcywh_to_xyxy(gt_bboxes)  # (x1, y1, x2, y2)
+
+        pred_bboxes_center_x = pred_bboxes[:, 0].unsqueeze(1)
+        pred_bboxes_center_y = pred_bboxes[:, 1].unsqueeze(1)
+
+        # whether the center of each anchor is inside a gt box
+        b_l = pred_bboxes_center_x > xy_target_gts[:, 0].unsqueeze(0)
+        b_r = pred_bboxes_center_x < xy_target_gts[:, 2].unsqueeze(0)
+        b_t = pred_bboxes_center_y > xy_target_gts[:, 1].unsqueeze(0)
+        b_b = pred_bboxes_center_y < xy_target_gts[:, 3].unsqueeze(0)
+        # (b_l.long()+b_r.long()+b_t.long()+b_b.long())==4 [300,num_gt] ,
+        is_in_boxes = ((b_l.long() + b_r.long() + b_t.long() +
+                        b_b.long()) == 4)
+        is_in_boxes_all = is_in_boxes.sum(1) > 0  # [num_query]
+        # in fixed center
+        center_radius = 2.5
+        # Modified to self-adapted sampling --- the center size depends
+        # on the size of the gt boxes
+        # https://github.com/dulucas/UVO_Challenge/blob/main/Track1/detection/mmdet/core/bbox/assigners/rpn_sim_ota_assigner.py#L212    # noqa
+        b_l = pred_bboxes_center_x > (
+            gt_bboxes[:, 0] -
+            (center_radius *
+             (xy_target_gts[:, 2] - xy_target_gts[:, 0]))).unsqueeze(0)
+        b_r = pred_bboxes_center_x < (
+            gt_bboxes[:, 0] +
+            (center_radius *
+             (xy_target_gts[:, 2] - xy_target_gts[:, 0]))).unsqueeze(0)
+        b_t = pred_bboxes_center_y > (
+            gt_bboxes[:, 1] -
+            (center_radius *
+             (xy_target_gts[:, 3] - xy_target_gts[:, 1]))).unsqueeze(0)
+        b_b = pred_bboxes_center_y < (
+            gt_bboxes[:, 1] +
+            (center_radius *
+             (xy_target_gts[:, 3] - xy_target_gts[:, 1]))).unsqueeze(0)
+
+        is_in_centers = ((b_l.long() + b_r.long() + b_t.long() +
+                          b_b.long()) == 4)
+        is_in_centers_all = is_in_centers.sum(1) > 0
+
+        is_in_boxes_anchor = is_in_boxes_all | is_in_centers_all
+        is_in_boxes_and_center = (is_in_boxes & is_in_centers)
+
+        return is_in_boxes_anchor, is_in_boxes_and_center
+
+    def dynamic_k_matching(self, cost: Tensor, pairwise_ious: Tensor,
+                           num_gt: int) -> Tuple[Tensor, Tensor]:
+        """Use IoU and matching cost to calculate the dynamic top-k positive
+        targets."""
+        matching_matrix = torch.zeros_like(cost)
+        # select candidate topk ious for dynamic-k calculation
+        candidate_topk = min(self.candidate_topk, pairwise_ious.size(0))
+        topk_ious, _ = torch.topk(pairwise_ious, candidate_topk, dim=0)
+        # calculate dynamic k for each gt
+        dynamic_ks = torch.clamp(topk_ious.sum(0).int(), min=1)
+        for gt_idx in range(num_gt):
+            _, pos_idx = torch.topk(
+                cost[:, gt_idx], k=dynamic_ks[gt_idx], largest=False)
+            matching_matrix[:, gt_idx][pos_idx] = 1
+
+        del topk_ious, dynamic_ks, pos_idx
+
+        prior_match_gt_mask = matching_matrix.sum(1) > 1
+        if prior_match_gt_mask.sum() > 0:
+            _, cost_argmin = torch.min(cost[prior_match_gt_mask, :], dim=1)
+            matching_matrix[prior_match_gt_mask, :] *= 0
+            matching_matrix[prior_match_gt_mask, cost_argmin] = 1
+
+        while (matching_matrix.sum(0) == 0).any():
+            matched_query_id = matching_matrix.sum(1) > 0
+            cost[matched_query_id] += 100000.0
+            unmatch_id = torch.nonzero(
+                matching_matrix.sum(0) == 0, as_tuple=False).squeeze(1)
+            for gt_idx in unmatch_id:
+                pos_idx = torch.argmin(cost[:, gt_idx])
+                matching_matrix[:, gt_idx][pos_idx] = 1.0
+            if (matching_matrix.sum(1) > 1).sum() > 0:
+                _, cost_argmin = torch.min(cost[prior_match_gt_mask], dim=1)
+                matching_matrix[prior_match_gt_mask] *= 0
+                matching_matrix[prior_match_gt_mask, cost_argmin, ] = 1
+
+        assert not (matching_matrix.sum(0) == 0).any()
+        # get foreground mask inside box and center prior
+        fg_mask_inboxes = matching_matrix.sum(1) > 0
+        matched_gt_inds = matching_matrix[fg_mask_inboxes, :].argmax(1)
+
+        return fg_mask_inboxes, matched_gt_inds
diff --git a/mmdetection/projects/DiffusionDet/model_converters/diffusiondet_resnet_to_mmdet.py b/mmdetection/projects/DiffusionDet/model_converters/diffusiondet_resnet_to_mmdet.py
new file mode 100644
index 00000000..101abd83
--- /dev/null
+++ b/mmdetection/projects/DiffusionDet/model_converters/diffusiondet_resnet_to_mmdet.py
@@ -0,0 +1,88 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+from collections import OrderedDict
+
+import numpy as np
+import torch
+from mmengine.fileio import load
+
+
+def convert(src, dst):
+    if src.endswith('pth'):
+        src_model = torch.load(src)
+    else:
+        src_model = load(src)
+
+    dst_state_dict = OrderedDict()
+    for k, v in src_model['model'].items():
+        key_name_split = k.split('.')
+        if 'backbone.fpn_lateral' in k:
+            lateral_id = int(key_name_split[-2][-1])
+            name = f'neck.lateral_convs.{lateral_id - 2}.' \
+                   f'conv.{key_name_split[-1]}'
+        elif 'backbone.fpn_output' in k:
+            lateral_id = int(key_name_split[-2][-1])
+            name = f'neck.fpn_convs.{lateral_id - 2}.conv.' \
+                   f'{key_name_split[-1]}'
+        elif 'backbone.bottom_up.stem.conv1.norm.' in k:
+            name = f'backbone.bn1.{key_name_split[-1]}'
+        elif 'backbone.bottom_up.stem.conv1.' in k:
+            name = f'backbone.conv1.{key_name_split[-1]}'
+        elif 'backbone.bottom_up.res' in k:
+            # weight_type = key_name_split[-1]
+            res_id = int(key_name_split[2][-1]) - 1
+            # deal with short cut
+            if 'shortcut' in key_name_split[4]:
+                if 'shortcut' == key_name_split[-2]:
+                    name = f'backbone.layer{res_id}.' \
+                           f'{key_name_split[3]}.downsample.0.' \
+                           f'{key_name_split[-1]}'
+                elif 'shortcut' == key_name_split[-3]:
+                    name = f'backbone.layer{res_id}.' \
+                           f'{key_name_split[3]}.downsample.1.' \
+                           f'{key_name_split[-1]}'
+                else:
+                    print(f'Unvalid key {k}')
+            # deal with conv
+            elif 'conv' in key_name_split[-2]:
+                conv_id = int(key_name_split[-2][-1])
+                name = f'backbone.layer{res_id}.{key_name_split[3]}' \
+                       f'.conv{conv_id}.{key_name_split[-1]}'
+            # deal with BN
+            elif key_name_split[-2] == 'norm':
+                conv_id = int(key_name_split[-3][-1])
+                name = f'backbone.layer{res_id}.{key_name_split[3]}.' \
+                       f'bn{conv_id}.{key_name_split[-1]}'
+            else:
+                print(f'{k} is invalid')
+
+        elif key_name_split[0] == 'head':
+            # d2: head.xxx -> mmdet: bbox_head.xxx
+            name = f'bbox_{k}'
+        else:
+            # some base parameters such as beta will not convert
+            print(f'{k} is not converted!!')
+            continue
+
+        if not isinstance(v, np.ndarray) and not isinstance(v, torch.Tensor):
+            raise ValueError(
+                'Unsupported type found in checkpoint! {}: {}'.format(
+                    k, type(v)))
+        if not isinstance(v, torch.Tensor):
+            dst_state_dict[name] = torch.from_numpy(v)
+        else:
+            dst_state_dict[name] = v
+    mmdet_model = dict(state_dict=dst_state_dict, meta=dict())
+    torch.save(mmdet_model, dst)
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Convert model keys')
+    parser.add_argument('src', help='src detectron model path')
+    parser.add_argument('dst', help='save path')
+    args = parser.parse_args()
+    convert(args.src, args.dst)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmdetection/projects/EfficientDet/README.md b/mmdetection/projects/EfficientDet/README.md
new file mode 100644
index 00000000..36f4ed40
--- /dev/null
+++ b/mmdetection/projects/EfficientDet/README.md
@@ -0,0 +1,154 @@
+# EfficientDet
+
+> [**EfficientDet: Scalable and Efficient Object Detection**](https://arxiv.org/pdf/1911.09070.pdf),
+> Mingxing Tan, Ruoming Pang, Quoc V. Le,
+> *CVPR 2020*
+
+## Abstract
+
+This is an implementation of [EfficientDet](https://github.com/google/automl) based on [MMDetection](https://github.com/open-mmlab/mmdetection/tree/main), [MMCV](https://github.com/open-mmlab/mmcv), and [MMEngine](https://github.com/open-mmlab/mmengine).
+
    
+EfficientDet a new family of object detectors, which consistently achieve much better efficiency than prior art across a wide
+spectrum of resource constraints.
+In particular, with single model and single-scale, EfficientDet-D7 achieves stateof-the-art 55.1 AP on COCO test-dev with 77M parameters and 410B FLOP.
+
    
+BiFPN is a simple yet highly effective weighted bi-directional feature pyramid network, which introduces learnable weights to learn the importance of different input features, while repeatedly applying topdown and bottom-up multi-scale feature fusion.
+
    
+In contrast to other feature pyramid network, such as FPN, FPN + PAN, NAS-FPN, BiFPN achieves  the best accuracy with fewer parameters and FLOPs.
+
+
    
+
+
    
+
+## Usage
+
+## Official TensorFlow Model
+
+This project also supports [official tensorflow model](https://github.com/google/automl), it uses 90 categories and yxyx box encoding in training. If you want to use the original model weight to get official results, please refer to the following steps.
+
+### Model conversion
+
+Firstly, download EfficientDet [weights](https://github.com/google/automl/tree/master/efficientdet) and unzip,  please use the following command
+
+```bash
+tar -xzvf {EFFICIENTDET_WEIGHT}
+```
+
+Then, install tensorflow, please use the following command
+
+```bash
+pip install tensorflow-gpu==2.6.0
+```
+
+Lastly, convert weights from tensorflow to pytorch, please use the following command
+
+```bash
+python projects/EfficientDet/convert_tf_to_pt.py --backbone {BACKBONE_NAME} --tensorflow_weight {TENSORFLOW_WEIGHT_PATH} --out_weight {OUT_PATH}
+```
+
+### Testing commands
+
+In MMDetection's root directory, run the following command to test the model:
+
+```bash
+python tools/test.py projects/EfficientDet/configs/tensorflow/efficientdet_effb0_bifpn_8xb16-crop512-300e_coco_tf.py ${CHECKPOINT_PATH}
+```
+
+## Reproduce Model
+
+For convenience, we recommend the current implementation version, it uses 80 categories and xyxy encoding in training. On this basis, a higher result was finally achieved.
+
+### Training commands
+
+In MMDetection's root directory, run the following command to train the model:
+
+```bash
+python tools/train.py projects/EfficientDet/configs/efficientdet_effb3_bifpn_8xb16-crop896-300e_coco.py
+```
+
+### Testing commands
+
+In MMDetection's root directory, run the following command to test the model:
+
+```bash
+python tools/test.py projects/EfficientDet/configs/efficientdet_effb3_bifpn_8xb16-crop896-300e_coco.py ${CHECKPOINT_PATH}
+```
+
+## Results
+
+Based on mmdetection, this project aligns the accuracy of the [official model](https://github.com/google/automl).
+
+|                                                        Method                                                        |    Backbone     | Pretrained Model |  Training set  |   Test set   | Epoch | Val Box AP | Official AP |                                                                                                                                                                                                Download                                                                                                                                                                                                |
+| :------------------------------------------------------------------------------------------------------------------: | :-------------: | :--------------: | :------------: | :----------: | :---: | :--------: | :---------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+| [efficientdet-d0\*](projects/EfficientDet/configs/tensorflow/efficientdet_effb0_bifpn_8xb16-crop512-300e_coco_tf.py) | efficientnet-b0 |     ImageNet     | COCO2017 Train | COCO2017 Val |  300  |    34.4    |    34.3     |                                                                                                                                                                                                                                                                                                                                                                                                        |
+|         [efficientdet-d3](projects/EfficientDet/configs/efficientdet_effb3_bifpn_8xb16-crop896-300e_coco.py)         | efficientnet-b3 |     ImageNet     | COCO2017 Train | COCO2017 Val |  300  |    47.2    |    46.8     | [model](https://download.openmmlab.com/mmdetection/v3.0/efficientdet/efficientdet_effb3_bifpn_8xb16-crop896-300e_coco/efficientdet_effb3_bifpn_8xb16-crop896-300e_coco_20230223_122457-e6f7a833.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/efficientdet/efficientdet_effb3_bifpn_8xb16-crop896-300e_coco/efficientdet_effb3_bifpn_8xb16-crop896-300e_coco_20230223_122457.log.json) |
+
+**Note**:
+\*means use [official tensorflow model](https://github.com/google/automl) weights to test.
+
+## Citation
+
+```BibTeX
+@inproceedings{tan2020efficientdet,
+  title={Efficientdet: Scalable and efficient object detection},
+  author={Tan, Mingxing and Pang, Ruoming and Le, Quoc V},
+  booktitle={Proceedings of the IEEE/CVF conference on computer vision and pattern recognition},
+  pages={10781--10790},
+  year={2020}
+}
+```
+
+## Checklist
+
+
+
+- [x] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
+
+  - [x] Finish the code
+
+    
+
+  - [x] Basic docstrings & proper citation
+
+    
+
+  - [x] Test-time correctness
+
+    
+
+  - [x] A full README
+
+    
+
+- [x] Milestone 2: Indicates a successful model implementation.
+
+  - [x] Training-time correctness
+
+    
+
+- [ ] Milestone 3: Good to be a part of our core package!
+
+  - [ ] Type hints and docstrings
+
+    
+
+  - [ ] Unit tests
+
+    
+
+  - [ ] Code polishing
+
+    
+
+  - [ ] Metafile.yml
+
+    
+
+- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
+
+  
+
+- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/mmdetection/projects/EfficientDet/configs/efficientdet_effb0_bifpn_8xb16-crop512-300e_coco.py b/mmdetection/projects/EfficientDet/configs/efficientdet_effb0_bifpn_8xb16-crop512-300e_coco.py
new file mode 100644
index 00000000..c7a3b309
--- /dev/null
+++ b/mmdetection/projects/EfficientDet/configs/efficientdet_effb0_bifpn_8xb16-crop512-300e_coco.py
@@ -0,0 +1,171 @@
+_base_ = [
+    'mmdet::_base_/datasets/coco_detection.py',
+    'mmdet::_base_/schedules/schedule_1x.py',
+    'mmdet::_base_/default_runtime.py'
+]
+custom_imports = dict(
+    imports=['projects.EfficientDet.efficientdet'], allow_failed_imports=False)
+
+image_size = 512
+batch_augments = [
+    dict(type='BatchFixedSizePad', size=(image_size, image_size))
+]
+dataset_type = 'CocoDataset'
+evalute_type = 'CocoMetric'
+norm_cfg = dict(type='SyncBN', requires_grad=True, eps=1e-3, momentum=0.01)
+checkpoint = 'https://download.openmmlab.com/mmclassification/v0/efficientnet/efficientnet-b0_3rdparty_8xb32-aa-advprop_in1k_20220119-26434485.pth'  # noqa
+model = dict(
+    type='EfficientDet',
+    data_preprocessor=dict(
+        type='DetDataPreprocessor',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        bgr_to_rgb=True,
+        pad_size_divisor=image_size,
+        batch_augments=batch_augments),
+    backbone=dict(
+        type='EfficientNet',
+        arch='b0',
+        drop_path_rate=0.2,
+        out_indices=(3, 4, 5),
+        frozen_stages=0,
+        conv_cfg=dict(type='Conv2dSamePadding'),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        init_cfg=dict(
+            type='Pretrained', prefix='backbone', checkpoint=checkpoint)),
+    neck=dict(
+        type='BiFPN',
+        num_stages=3,
+        in_channels=[40, 112, 320],
+        out_channels=64,
+        start_level=0,
+        norm_cfg=norm_cfg),
+    bbox_head=dict(
+        type='EfficientDetSepBNHead',
+        num_classes=80,
+        num_ins=5,
+        in_channels=64,
+        feat_channels=64,
+        stacked_convs=3,
+        norm_cfg=norm_cfg,
+        anchor_generator=dict(
+            type='AnchorGenerator',
+            octave_base_scale=4,
+            scales_per_octave=3,
+            ratios=[1.0, 0.5, 2.0],
+            strides=[8, 16, 32, 64, 128],
+            center_offset=0.5),
+        bbox_coder=dict(
+            type='DeltaXYWHBBoxCoder',
+            target_means=[.0, .0, .0, .0],
+            target_stds=[1.0, 1.0, 1.0, 1.0]),
+        loss_cls=dict(
+            type='FocalLoss',
+            use_sigmoid=True,
+            gamma=1.5,
+            alpha=0.25,
+            loss_weight=1.0),
+        loss_bbox=dict(type='HuberLoss', beta=0.1, loss_weight=50)),
+    # training and testing settings
+    train_cfg=dict(
+        assigner=dict(
+            type='MaxIoUAssigner',
+            pos_iou_thr=0.5,
+            neg_iou_thr=0.5,
+            min_pos_iou=0,
+            ignore_iof_thr=-1),
+        sampler=dict(
+            type='PseudoSampler'),  # Focal loss should use PseudoSampler
+        allowed_border=-1,
+        pos_weight=-1,
+        debug=False),
+    test_cfg=dict(
+        nms_pre=1000,
+        min_bbox_size=0,
+        score_thr=0.05,
+        nms=dict(
+            type='soft_nms',
+            iou_threshold=0.3,
+            sigma=0.5,
+            min_score=1e-3,
+            method='gaussian'),
+        max_per_img=100))
+
+# dataset settings
+train_pipeline = [
+    dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(
+        type='RandomResize',
+        scale=(image_size, image_size),
+        ratio_range=(0.1, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=(image_size, image_size)),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}),
+    dict(type='Resize', scale=(image_size, image_size), keep_ratio=True),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(
+        type='PackDetInputs',
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=8,
+    dataset=dict(type=dataset_type, pipeline=train_pipeline))
+val_dataloader = dict(dataset=dict(type=dataset_type, pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type=evalute_type)
+test_evaluator = val_evaluator
+
+optim_wrapper = dict(
+    optimizer=dict(lr=0.16, weight_decay=4e-5),
+    paramwise_cfg=dict(
+        norm_decay_mult=0, bias_decay_mult=0, bypass_duplicate=True),
+    clip_grad=dict(max_norm=10, norm_type=2))
+
+# learning policy
+max_epochs = 300
+param_scheduler = [
+    dict(type='LinearLR', start_factor=0.1, by_epoch=False, begin=0, end=917),
+    dict(
+        type='CosineAnnealingLR',
+        eta_min=0.0,
+        begin=1,
+        T_max=299,
+        end=300,
+        by_epoch=True,
+        convert_to_iter_based=True)
+]
+train_cfg = dict(max_epochs=max_epochs, val_interval=1)
+
+vis_backends = [
+    dict(type='LocalVisBackend'),
+    dict(type='TensorboardVisBackend')
+]
+visualizer = dict(
+    type='DetLocalVisualizer', vis_backends=vis_backends, name='visualizer')
+
+default_hooks = dict(checkpoint=dict(type='CheckpointHook', interval=15))
+custom_hooks = [
+    dict(
+        type='EMAHook',
+        ema_type='ExpMomentumEMA',
+        momentum=0.0002,
+        update_buffers=True,
+        priority=49)
+]
+# cudnn_benchmark=True can accelerate fix-size training
+env_cfg = dict(cudnn_benchmark=True)
+
+# NOTE: `auto_scale_lr` is for automatically scaling LR,
+# USER SHOULD NOT CHANGE ITS VALUES.
+# base_batch_size = (8 GPUs) x (16 samples per GPU)
+auto_scale_lr = dict(base_batch_size=128)
diff --git a/mmdetection/projects/EfficientDet/configs/efficientdet_effb3_bifpn_8xb16-crop896-300e_coco-90cls.py b/mmdetection/projects/EfficientDet/configs/efficientdet_effb3_bifpn_8xb16-crop896-300e_coco-90cls.py
new file mode 100644
index 00000000..fe82a5e1
--- /dev/null
+++ b/mmdetection/projects/EfficientDet/configs/efficientdet_effb3_bifpn_8xb16-crop896-300e_coco-90cls.py
@@ -0,0 +1,171 @@
+_base_ = [
+    'mmdet::_base_/datasets/coco_detection.py',
+    'mmdet::_base_/schedules/schedule_1x.py',
+    'mmdet::_base_/default_runtime.py'
+]
+custom_imports = dict(
+    imports=['projects.EfficientDet.efficientdet'], allow_failed_imports=False)
+
+image_size = 896
+batch_augments = [
+    dict(type='BatchFixedSizePad', size=(image_size, image_size))
+]
+dataset_type = 'Coco90Dataset'
+evalute_type = 'Coco90Metric'
+norm_cfg = dict(type='SyncBN', requires_grad=True, eps=1e-3, momentum=0.01)
+checkpoint = 'https://download.openmmlab.com/mmclassification/v0/efficientnet/efficientnet-b3_3rdparty_8xb32-aa-advprop_in1k_20220119-53b41118.pth'  # noqa
+model = dict(
+    type='EfficientDet',
+    data_preprocessor=dict(
+        type='DetDataPreprocessor',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        bgr_to_rgb=True,
+        pad_size_divisor=image_size,
+        batch_augments=batch_augments),
+    backbone=dict(
+        type='EfficientNet',
+        arch='b3',
+        drop_path_rate=0.3,
+        out_indices=(3, 4, 5),
+        frozen_stages=0,
+        conv_cfg=dict(type='Conv2dSamePadding'),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        init_cfg=dict(
+            type='Pretrained', prefix='backbone', checkpoint=checkpoint)),
+    neck=dict(
+        type='BiFPN',
+        num_stages=6,
+        in_channels=[48, 136, 384],
+        out_channels=160,
+        start_level=0,
+        norm_cfg=norm_cfg),
+    bbox_head=dict(
+        type='EfficientDetSepBNHead',
+        num_classes=90,
+        num_ins=5,
+        in_channels=160,
+        feat_channels=160,
+        stacked_convs=4,
+        norm_cfg=norm_cfg,
+        anchor_generator=dict(
+            type='AnchorGenerator',
+            octave_base_scale=4,
+            scales_per_octave=3,
+            ratios=[1.0, 0.5, 2.0],
+            strides=[8, 16, 32, 64, 128],
+            center_offset=0.5),
+        bbox_coder=dict(
+            type='DeltaXYWHBBoxCoder',
+            target_means=[.0, .0, .0, .0],
+            target_stds=[1.0, 1.0, 1.0, 1.0]),
+        loss_cls=dict(
+            type='FocalLoss',
+            use_sigmoid=True,
+            gamma=1.5,
+            alpha=0.25,
+            loss_weight=1.0),
+        loss_bbox=dict(type='HuberLoss', beta=0.1, loss_weight=50)),
+    # training and testing settings
+    train_cfg=dict(
+        assigner=dict(
+            type='MaxIoUAssigner',
+            pos_iou_thr=0.5,
+            neg_iou_thr=0.5,
+            min_pos_iou=0,
+            ignore_iof_thr=-1),
+        sampler=dict(
+            type='PseudoSampler'),  # Focal loss should use PseudoSampler
+        allowed_border=-1,
+        pos_weight=-1,
+        debug=False),
+    test_cfg=dict(
+        nms_pre=1000,
+        min_bbox_size=0,
+        score_thr=0.05,
+        nms=dict(
+            type='soft_nms',
+            iou_threshold=0.3,
+            sigma=0.5,
+            min_score=1e-3,
+            method='gaussian'),
+        max_per_img=100))
+
+# dataset settings
+train_pipeline = [
+    dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(
+        type='RandomResize',
+        scale=(image_size, image_size),
+        ratio_range=(0.1, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=(image_size, image_size)),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}),
+    dict(type='Resize', scale=(image_size, image_size), keep_ratio=True),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(
+        type='PackDetInputs',
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=8,
+    dataset=dict(type=dataset_type, pipeline=train_pipeline))
+val_dataloader = dict(dataset=dict(type=dataset_type, pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type=evalute_type)
+test_evaluator = val_evaluator
+
+optim_wrapper = dict(
+    optimizer=dict(lr=0.16, weight_decay=4e-5),
+    paramwise_cfg=dict(
+        norm_decay_mult=0, bias_decay_mult=0, bypass_duplicate=True),
+    clip_grad=dict(max_norm=10, norm_type=2))
+
+# learning policy
+max_epochs = 300
+param_scheduler = [
+    dict(type='LinearLR', start_factor=0.1, by_epoch=False, begin=0, end=917),
+    dict(
+        type='CosineAnnealingLR',
+        eta_min=0.0,
+        begin=1,
+        T_max=299,
+        end=300,
+        by_epoch=True,
+        convert_to_iter_based=True)
+]
+train_cfg = dict(max_epochs=max_epochs, val_interval=1)
+
+vis_backends = [
+    dict(type='LocalVisBackend'),
+    dict(type='TensorboardVisBackend')
+]
+visualizer = dict(
+    type='DetLocalVisualizer', vis_backends=vis_backends, name='visualizer')
+
+default_hooks = dict(checkpoint=dict(type='CheckpointHook', interval=15))
+custom_hooks = [
+    dict(
+        type='EMAHook',
+        ema_type='ExpMomentumEMA',
+        momentum=0.0002,
+        update_buffers=True,
+        priority=49)
+]
+# cudnn_benchmark=True can accelerate fix-size training
+env_cfg = dict(cudnn_benchmark=True)
+
+# NOTE: `auto_scale_lr` is for automatically scaling LR,
+# USER SHOULD NOT CHANGE ITS VALUES.
+# base_batch_size = (8 GPUs) x (16 samples per GPU)
+auto_scale_lr = dict(base_batch_size=128)
diff --git a/mmdetection/projects/EfficientDet/configs/efficientdet_effb3_bifpn_8xb16-crop896-300e_coco.py b/mmdetection/projects/EfficientDet/configs/efficientdet_effb3_bifpn_8xb16-crop896-300e_coco.py
new file mode 100644
index 00000000..2079e2ac
--- /dev/null
+++ b/mmdetection/projects/EfficientDet/configs/efficientdet_effb3_bifpn_8xb16-crop896-300e_coco.py
@@ -0,0 +1,171 @@
+_base_ = [
+    'mmdet::_base_/datasets/coco_detection.py',
+    'mmdet::_base_/schedules/schedule_1x.py',
+    'mmdet::_base_/default_runtime.py'
+]
+custom_imports = dict(
+    imports=['projects.EfficientDet.efficientdet'], allow_failed_imports=False)
+
+image_size = 896
+batch_augments = [
+    dict(type='BatchFixedSizePad', size=(image_size, image_size))
+]
+dataset_type = 'CocoDataset'
+evalute_type = 'CocoMetric'
+norm_cfg = dict(type='SyncBN', requires_grad=True, eps=1e-3, momentum=0.01)
+checkpoint = 'https://download.openmmlab.com/mmclassification/v0/efficientnet/efficientnet-b3_3rdparty_8xb32-aa-advprop_in1k_20220119-53b41118.pth'  # noqa
+model = dict(
+    type='EfficientDet',
+    data_preprocessor=dict(
+        type='DetDataPreprocessor',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        bgr_to_rgb=True,
+        pad_size_divisor=image_size,
+        batch_augments=batch_augments),
+    backbone=dict(
+        type='EfficientNet',
+        arch='b3',
+        drop_path_rate=0.3,
+        out_indices=(3, 4, 5),
+        frozen_stages=0,
+        conv_cfg=dict(type='Conv2dSamePadding'),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        init_cfg=dict(
+            type='Pretrained', prefix='backbone', checkpoint=checkpoint)),
+    neck=dict(
+        type='BiFPN',
+        num_stages=6,
+        in_channels=[48, 136, 384],
+        out_channels=160,
+        start_level=0,
+        norm_cfg=norm_cfg),
+    bbox_head=dict(
+        type='EfficientDetSepBNHead',
+        num_classes=80,
+        num_ins=5,
+        in_channels=160,
+        feat_channels=160,
+        stacked_convs=4,
+        norm_cfg=norm_cfg,
+        anchor_generator=dict(
+            type='AnchorGenerator',
+            octave_base_scale=4,
+            scales_per_octave=3,
+            ratios=[1.0, 0.5, 2.0],
+            strides=[8, 16, 32, 64, 128],
+            center_offset=0.5),
+        bbox_coder=dict(
+            type='DeltaXYWHBBoxCoder',
+            target_means=[.0, .0, .0, .0],
+            target_stds=[1.0, 1.0, 1.0, 1.0]),
+        loss_cls=dict(
+            type='FocalLoss',
+            use_sigmoid=True,
+            gamma=1.5,
+            alpha=0.25,
+            loss_weight=1.0),
+        loss_bbox=dict(type='HuberLoss', beta=0.1, loss_weight=50)),
+    # training and testing settings
+    train_cfg=dict(
+        assigner=dict(
+            type='MaxIoUAssigner',
+            pos_iou_thr=0.5,
+            neg_iou_thr=0.5,
+            min_pos_iou=0,
+            ignore_iof_thr=-1),
+        sampler=dict(
+            type='PseudoSampler'),  # Focal loss should use PseudoSampler
+        allowed_border=-1,
+        pos_weight=-1,
+        debug=False),
+    test_cfg=dict(
+        nms_pre=1000,
+        min_bbox_size=0,
+        score_thr=0.05,
+        nms=dict(
+            type='soft_nms',
+            iou_threshold=0.3,
+            sigma=0.5,
+            min_score=1e-3,
+            method='gaussian'),
+        max_per_img=100))
+
+# dataset settings
+train_pipeline = [
+    dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(
+        type='RandomResize',
+        scale=(image_size, image_size),
+        ratio_range=(0.1, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=(image_size, image_size)),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}),
+    dict(type='Resize', scale=(image_size, image_size), keep_ratio=True),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(
+        type='PackDetInputs',
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=8,
+    dataset=dict(type=dataset_type, pipeline=train_pipeline))
+val_dataloader = dict(dataset=dict(type=dataset_type, pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type=evalute_type)
+test_evaluator = val_evaluator
+
+optim_wrapper = dict(
+    optimizer=dict(lr=0.16, weight_decay=4e-5),
+    paramwise_cfg=dict(
+        norm_decay_mult=0, bias_decay_mult=0, bypass_duplicate=True),
+    clip_grad=dict(max_norm=10, norm_type=2))
+
+# learning policy
+max_epochs = 300
+param_scheduler = [
+    dict(type='LinearLR', start_factor=0.1, by_epoch=False, begin=0, end=917),
+    dict(
+        type='CosineAnnealingLR',
+        eta_min=0.0,
+        begin=1,
+        T_max=299,
+        end=300,
+        by_epoch=True,
+        convert_to_iter_based=True)
+]
+train_cfg = dict(max_epochs=max_epochs, val_interval=1)
+
+vis_backends = [
+    dict(type='LocalVisBackend'),
+    dict(type='TensorboardVisBackend')
+]
+visualizer = dict(
+    type='DetLocalVisualizer', vis_backends=vis_backends, name='visualizer')
+
+default_hooks = dict(checkpoint=dict(type='CheckpointHook', interval=15))
+custom_hooks = [
+    dict(
+        type='EMAHook',
+        ema_type='ExpMomentumEMA',
+        momentum=0.0002,
+        update_buffers=True,
+        priority=49)
+]
+# cudnn_benchmark=True can accelerate fix-size training
+env_cfg = dict(cudnn_benchmark=True)
+
+# NOTE: `auto_scale_lr` is for automatically scaling LR,
+# USER SHOULD NOT CHANGE ITS VALUES.
+# base_batch_size = (8 GPUs) x (16 samples per GPU)
+auto_scale_lr = dict(base_batch_size=128)
diff --git a/mmdetection/projects/EfficientDet/configs/tensorflow/efficientdet_effb0_bifpn_8xb16-crop512-300e_coco_tf.py b/mmdetection/projects/EfficientDet/configs/tensorflow/efficientdet_effb0_bifpn_8xb16-crop512-300e_coco_tf.py
new file mode 100644
index 00000000..bf3d3fc1
--- /dev/null
+++ b/mmdetection/projects/EfficientDet/configs/tensorflow/efficientdet_effb0_bifpn_8xb16-crop512-300e_coco_tf.py
@@ -0,0 +1,171 @@
+_base_ = [
+    'mmdet::_base_/datasets/coco_detection.py',
+    'mmdet::_base_/schedules/schedule_1x.py',
+    'mmdet::_base_/default_runtime.py'
+]
+custom_imports = dict(
+    imports=['projects.EfficientDet.efficientdet'], allow_failed_imports=False)
+
+image_size = 512
+batch_augments = [
+    dict(type='BatchFixedSizePad', size=(image_size, image_size))
+]
+dataset_type = 'Coco90Dataset'
+evalute_type = 'Coco90Metric'
+norm_cfg = dict(type='SyncBN', requires_grad=True, eps=1e-3, momentum=0.01)
+checkpoint = 'https://download.openmmlab.com/mmclassification/v0/efficientnet/efficientnet-b0_3rdparty_8xb32-aa-advprop_in1k_20220119-26434485.pth'  # noqa
+model = dict(
+    type='EfficientDet',
+    data_preprocessor=dict(
+        type='DetDataPreprocessor',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        bgr_to_rgb=True,
+        pad_size_divisor=image_size,
+        batch_augments=batch_augments),
+    backbone=dict(
+        type='EfficientNet',
+        arch='b0',
+        drop_path_rate=0.2,
+        out_indices=(3, 4, 5),
+        frozen_stages=0,
+        conv_cfg=dict(type='Conv2dSamePadding'),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        init_cfg=dict(
+            type='Pretrained', prefix='backbone', checkpoint=checkpoint)),
+    neck=dict(
+        type='BiFPN',
+        num_stages=3,
+        in_channels=[40, 112, 320],
+        out_channels=64,
+        start_level=0,
+        norm_cfg=norm_cfg),
+    bbox_head=dict(
+        type='EfficientDetSepBNHead',
+        num_classes=90,
+        num_ins=5,
+        in_channels=64,
+        feat_channels=64,
+        stacked_convs=3,
+        norm_cfg=norm_cfg,
+        anchor_generator=dict(
+            type='YXYXAnchorGenerator',
+            octave_base_scale=4,
+            scales_per_octave=3,
+            ratios=[1.0, 0.5, 2.0],
+            strides=[8, 16, 32, 64, 128],
+            center_offset=0.5),
+        bbox_coder=dict(
+            type='YXYXDeltaXYWHBBoxCoder',
+            target_means=[.0, .0, .0, .0],
+            target_stds=[1.0, 1.0, 1.0, 1.0]),
+        loss_cls=dict(
+            type='FocalLoss',
+            use_sigmoid=True,
+            gamma=1.5,
+            alpha=0.25,
+            loss_weight=1.0),
+        loss_bbox=dict(type='HuberLoss', beta=0.1, loss_weight=50)),
+    # training and testing settings
+    train_cfg=dict(
+        assigner=dict(
+            type='TransMaxIoUAssigner',
+            pos_iou_thr=0.5,
+            neg_iou_thr=0.5,
+            min_pos_iou=0,
+            ignore_iof_thr=-1),
+        sampler=dict(
+            type='PseudoSampler'),  # Focal loss should use PseudoSampler
+        allowed_border=-1,
+        pos_weight=-1,
+        debug=False),
+    test_cfg=dict(
+        nms_pre=1000,
+        min_bbox_size=0,
+        score_thr=0.05,
+        nms=dict(
+            type='soft_nms',
+            iou_threshold=0.3,
+            sigma=0.5,
+            min_score=1e-3,
+            method='gaussian'),
+        max_per_img=100))
+
+# dataset settings
+train_pipeline = [
+    dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(
+        type='RandomResize',
+        scale=(image_size, image_size),
+        ratio_range=(0.1, 2.0),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=(image_size, image_size)),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile', backend_args={{_base_.backend_args}}),
+    dict(type='Resize', scale=(image_size, image_size), keep_ratio=True),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(
+        type='PackDetInputs',
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+
+train_dataloader = dict(
+    batch_size=16,
+    num_workers=8,
+    dataset=dict(type=dataset_type, pipeline=train_pipeline))
+val_dataloader = dict(dataset=dict(type=dataset_type, pipeline=test_pipeline))
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type=evalute_type)
+test_evaluator = val_evaluator
+
+optim_wrapper = dict(
+    optimizer=dict(lr=0.16, weight_decay=4e-5),
+    paramwise_cfg=dict(
+        norm_decay_mult=0, bias_decay_mult=0, bypass_duplicate=True),
+    clip_grad=dict(max_norm=10, norm_type=2))
+
+# learning policy
+max_epochs = 300
+param_scheduler = [
+    dict(type='LinearLR', start_factor=0.1, by_epoch=False, begin=0, end=917),
+    dict(
+        type='CosineAnnealingLR',
+        eta_min=0.0,
+        begin=1,
+        T_max=299,
+        end=300,
+        by_epoch=True,
+        convert_to_iter_based=True)
+]
+train_cfg = dict(max_epochs=max_epochs, val_interval=1)
+
+vis_backends = [
+    dict(type='LocalVisBackend'),
+    dict(type='TensorboardVisBackend')
+]
+visualizer = dict(
+    type='DetLocalVisualizer', vis_backends=vis_backends, name='visualizer')
+
+default_hooks = dict(checkpoint=dict(type='CheckpointHook', interval=15))
+custom_hooks = [
+    dict(
+        type='EMAHook',
+        ema_type='ExpMomentumEMA',
+        momentum=0.0002,
+        update_buffers=True,
+        priority=49)
+]
+# cudnn_benchmark=True can accelerate fix-size training
+env_cfg = dict(cudnn_benchmark=True)
+
+# NOTE: `auto_scale_lr` is for automatically scaling LR,
+# USER SHOULD NOT CHANGE ITS VALUES.
+# base_batch_size = (8 GPUs) x (16 samples per GPU)
+auto_scale_lr = dict(base_batch_size=128)
diff --git a/mmdetection/projects/EfficientDet/convert_tf_to_pt.py b/mmdetection/projects/EfficientDet/convert_tf_to_pt.py
new file mode 100644
index 00000000..f3b127f2
--- /dev/null
+++ b/mmdetection/projects/EfficientDet/convert_tf_to_pt.py
@@ -0,0 +1,626 @@
+import argparse
+
+import numpy as np
+import torch
+from tensorflow.python.training import py_checkpoint_reader
+
+torch.set_printoptions(precision=20)
+
+
+def tf2pth(v):
+    if v.ndim == 4:
+        return np.ascontiguousarray(v.transpose(3, 2, 0, 1))
+    elif v.ndim == 2:
+        return np.ascontiguousarray(v.transpose())
+    return v
+
+
+def convert_key(model_name, bifpn_repeats, weights):
+
+    p6_w1 = [
+        torch.tensor([-1e4, -1e4], dtype=torch.float64)
+        for _ in range(bifpn_repeats)
+    ]
+    p5_w1 = [
+        torch.tensor([-1e4, -1e4], dtype=torch.float64)
+        for _ in range(bifpn_repeats)
+    ]
+    p4_w1 = [
+        torch.tensor([-1e4, -1e4], dtype=torch.float64)
+        for _ in range(bifpn_repeats)
+    ]
+    p3_w1 = [
+        torch.tensor([-1e4, -1e4], dtype=torch.float64)
+        for _ in range(bifpn_repeats)
+    ]
+    p4_w2 = [
+        torch.tensor([-1e4, -1e4, -1e4], dtype=torch.float64)
+        for _ in range(bifpn_repeats)
+    ]
+    p5_w2 = [
+        torch.tensor([-1e4, -1e4, -1e4], dtype=torch.float64)
+        for _ in range(bifpn_repeats)
+    ]
+    p6_w2 = [
+        torch.tensor([-1e4, -1e4, -1e4], dtype=torch.float64)
+        for _ in range(bifpn_repeats)
+    ]
+    p7_w2 = [
+        torch.tensor([-1e4, -1e4], dtype=torch.float64)
+        for _ in range(bifpn_repeats)
+    ]
+    idx2key = {
+        0: '1.0',
+        1: '2.0',
+        2: '2.1',
+        3: '3.0',
+        4: '3.1',
+        5: '4.0',
+        6: '4.1',
+        7: '4.2',
+        8: '4.3',
+        9: '4.4',
+        10: '4.5',
+        11: '5.0',
+        12: '5.1',
+        13: '5.2',
+        14: '5.3',
+        15: '5.4'
+    }
+    m = dict()
+    for k, v in weights.items():
+
+        if 'Exponential' in k or 'global_step' in k:
+            continue
+
+        seg = k.split('/')
+        if len(seg) == 1:
+            continue
+        if seg[2] == 'depthwise_conv2d':
+            v = v.transpose(1, 0)
+
+        if seg[0] == model_name:
+            if seg[1] == 'stem':
+                prefix = 'backbone.layers.0'
+                mapping = {
+                    'conv2d/kernel': 'conv.weight',
+                    'tpu_batch_normalization/beta': 'bn.bias',
+                    'tpu_batch_normalization/gamma': 'bn.weight',
+                    'tpu_batch_normalization/moving_mean': 'bn.running_mean',
+                    'tpu_batch_normalization/moving_variance':
+                    'bn.running_var',
+                }
+                suffix = mapping['/'.join(seg[2:])]
+                m[prefix + '.' + suffix] = v
+
+            elif seg[1].startswith('blocks_'):
+                idx = int(seg[1][7:])
+                prefix = '.'.join(['backbone', 'layers', idx2key[idx]])
+                base_mapping = {
+                    'depthwise_conv2d/depthwise_kernel':
+                    'depthwise_conv.conv.weight',
+                    'se/conv2d/kernel': 'se.conv1.conv.weight',
+                    'se/conv2d/bias': 'se.conv1.conv.bias',
+                    'se/conv2d_1/kernel': 'se.conv2.conv.weight',
+                    'se/conv2d_1/bias': 'se.conv2.conv.bias'
+                }
+                if idx == 0:
+                    mapping = {
+                        'conv2d/kernel':
+                        'linear_conv.conv.weight',
+                        'tpu_batch_normalization/beta':
+                        'depthwise_conv.bn.bias',
+                        'tpu_batch_normalization/gamma':
+                        'depthwise_conv.bn.weight',
+                        'tpu_batch_normalization/moving_mean':
+                        'depthwise_conv.bn.running_mean',
+                        'tpu_batch_normalization/moving_variance':
+                        'depthwise_conv.bn.running_var',
+                        'tpu_batch_normalization_1/beta':
+                        'linear_conv.bn.bias',
+                        'tpu_batch_normalization_1/gamma':
+                        'linear_conv.bn.weight',
+                        'tpu_batch_normalization_1/moving_mean':
+                        'linear_conv.bn.running_mean',
+                        'tpu_batch_normalization_1/moving_variance':
+                        'linear_conv.bn.running_var',
+                    }
+                else:
+                    mapping = {
+                        'depthwise_conv2d/depthwise_kernel':
+                        'depthwise_conv.conv.weight',
+                        'conv2d/kernel':
+                        'expand_conv.conv.weight',
+                        'conv2d_1/kernel':
+                        'linear_conv.conv.weight',
+                        'tpu_batch_normalization/beta':
+                        'expand_conv.bn.bias',
+                        'tpu_batch_normalization/gamma':
+                        'expand_conv.bn.weight',
+                        'tpu_batch_normalization/moving_mean':
+                        'expand_conv.bn.running_mean',
+                        'tpu_batch_normalization/moving_variance':
+                        'expand_conv.bn.running_var',
+                        'tpu_batch_normalization_1/beta':
+                        'depthwise_conv.bn.bias',
+                        'tpu_batch_normalization_1/gamma':
+                        'depthwise_conv.bn.weight',
+                        'tpu_batch_normalization_1/moving_mean':
+                        'depthwise_conv.bn.running_mean',
+                        'tpu_batch_normalization_1/moving_variance':
+                        'depthwise_conv.bn.running_var',
+                        'tpu_batch_normalization_2/beta':
+                        'linear_conv.bn.bias',
+                        'tpu_batch_normalization_2/gamma':
+                        'linear_conv.bn.weight',
+                        'tpu_batch_normalization_2/moving_mean':
+                        'linear_conv.bn.running_mean',
+                        'tpu_batch_normalization_2/moving_variance':
+                        'linear_conv.bn.running_var',
+                    }
+                mapping.update(base_mapping)
+                suffix = mapping['/'.join(seg[2:])]
+                m[prefix + '.' + suffix] = v
+        elif seg[0] == 'resample_p6':
+            prefix = 'neck.bifpn.0.p5_to_p6.0'
+            mapping = {
+                'conv2d/kernel': 'down_conv.weight',
+                'conv2d/bias': 'down_conv.bias',
+                'bn/beta': 'bn.bias',
+                'bn/gamma': 'bn.weight',
+                'bn/moving_mean': 'bn.running_mean',
+                'bn/moving_variance': 'bn.running_var',
+            }
+            suffix = mapping['/'.join(seg[1:])]
+            m[prefix + '.' + suffix] = v
+        elif seg[0] == 'fpn_cells':
+            fpn_idx = int(seg[1][5:])
+            prefix = '.'.join(['neck', 'bifpn', str(fpn_idx)])
+            fnode_id = int(seg[2][5])
+            if fnode_id == 0:
+                mapping = {
+                    'op_after_combine5/conv/depthwise_kernel':
+                    'conv6_up.depthwise_conv.weight',
+                    'op_after_combine5/conv/pointwise_kernel':
+                    'conv6_up.pointwise_conv.weight',
+                    'op_after_combine5/conv/bias':
+                    'conv6_up.pointwise_conv.bias',
+                    'op_after_combine5/bn/beta':
+                    'conv6_up.bn.bias',
+                    'op_after_combine5/bn/gamma':
+                    'conv6_up.bn.weight',
+                    'op_after_combine5/bn/moving_mean':
+                    'conv6_up.bn.running_mean',
+                    'op_after_combine5/bn/moving_variance':
+                    'conv6_up.bn.running_var',
+                }
+                if seg[3] != 'WSM' and seg[3] != 'WSM_1':
+                    suffix = mapping['/'.join(seg[3:])]
+                    if 'depthwise_conv' in suffix:
+                        v = v.transpose(1, 0)
+                    m[prefix + '.' + suffix] = v
+                elif seg[3] == 'WSM':
+                    p6_w1[fpn_idx][0] = v
+                elif seg[3] == 'WSM_1':
+                    p6_w1[fpn_idx][1] = v
+                if torch.min(p6_w1[fpn_idx]) > -1e4:
+                    m[prefix + '.p6_w1'] = p6_w1[fpn_idx]
+            elif fnode_id == 1:
+                base_mapping = {
+                    'op_after_combine6/conv/depthwise_kernel':
+                    'conv5_up.depthwise_conv.weight',
+                    'op_after_combine6/conv/pointwise_kernel':
+                    'conv5_up.pointwise_conv.weight',
+                    'op_after_combine6/conv/bias':
+                    'conv5_up.pointwise_conv.bias',
+                    'op_after_combine6/bn/beta':
+                    'conv5_up.bn.bias',
+                    'op_after_combine6/bn/gamma':
+                    'conv5_up.bn.weight',
+                    'op_after_combine6/bn/moving_mean':
+                    'conv5_up.bn.running_mean',
+                    'op_after_combine6/bn/moving_variance':
+                    'conv5_up.bn.running_var',
+                }
+                if fpn_idx == 0:
+                    mapping = {
+                        'resample_0_2_6/conv2d/kernel':
+                        'p5_down_channel.down_conv.weight',
+                        'resample_0_2_6/conv2d/bias':
+                        'p5_down_channel.down_conv.bias',
+                        'resample_0_2_6/bn/beta':
+                        'p5_down_channel.bn.bias',
+                        'resample_0_2_6/bn/gamma':
+                        'p5_down_channel.bn.weight',
+                        'resample_0_2_6/bn/moving_mean':
+                        'p5_down_channel.bn.running_mean',
+                        'resample_0_2_6/bn/moving_variance':
+                        'p5_down_channel.bn.running_var',
+                    }
+                    base_mapping.update(mapping)
+                if seg[3] != 'WSM' and seg[3] != 'WSM_1':
+                    suffix = base_mapping['/'.join(seg[3:])]
+                    if 'depthwise_conv' in suffix:
+                        v = v.transpose(1, 0)
+                    m[prefix + '.' + suffix] = v
+                elif seg[3] == 'WSM':
+                    p5_w1[fpn_idx][0] = v
+                elif seg[3] == 'WSM_1':
+                    p5_w1[fpn_idx][1] = v
+                if torch.min(p5_w1[fpn_idx]) > -1e4:
+                    m[prefix + '.p5_w1'] = p5_w1[fpn_idx]
+            elif fnode_id == 2:
+                base_mapping = {
+                    'op_after_combine7/conv/depthwise_kernel':
+                    'conv4_up.depthwise_conv.weight',
+                    'op_after_combine7/conv/pointwise_kernel':
+                    'conv4_up.pointwise_conv.weight',
+                    'op_after_combine7/conv/bias':
+                    'conv4_up.pointwise_conv.bias',
+                    'op_after_combine7/bn/beta':
+                    'conv4_up.bn.bias',
+                    'op_after_combine7/bn/gamma':
+                    'conv4_up.bn.weight',
+                    'op_after_combine7/bn/moving_mean':
+                    'conv4_up.bn.running_mean',
+                    'op_after_combine7/bn/moving_variance':
+                    'conv4_up.bn.running_var',
+                }
+                if fpn_idx == 0:
+                    mapping = {
+                        'resample_0_1_7/conv2d/kernel':
+                        'p4_down_channel.down_conv.weight',
+                        'resample_0_1_7/conv2d/bias':
+                        'p4_down_channel.down_conv.bias',
+                        'resample_0_1_7/bn/beta':
+                        'p4_down_channel.bn.bias',
+                        'resample_0_1_7/bn/gamma':
+                        'p4_down_channel.bn.weight',
+                        'resample_0_1_7/bn/moving_mean':
+                        'p4_down_channel.bn.running_mean',
+                        'resample_0_1_7/bn/moving_variance':
+                        'p4_down_channel.bn.running_var',
+                    }
+                    base_mapping.update(mapping)
+                if seg[3] != 'WSM' and seg[3] != 'WSM_1':
+                    suffix = base_mapping['/'.join(seg[3:])]
+                    if 'depthwise_conv' in suffix:
+                        v = v.transpose(1, 0)
+                    m[prefix + '.' + suffix] = v
+                elif seg[3] == 'WSM':
+                    p4_w1[fpn_idx][0] = v
+                elif seg[3] == 'WSM_1':
+                    p4_w1[fpn_idx][1] = v
+                if torch.min(p4_w1[fpn_idx]) > -1e4:
+                    m[prefix + '.p4_w1'] = p4_w1[fpn_idx]
+            elif fnode_id == 3:
+
+                base_mapping = {
+                    'op_after_combine8/conv/depthwise_kernel':
+                    'conv3_up.depthwise_conv.weight',
+                    'op_after_combine8/conv/pointwise_kernel':
+                    'conv3_up.pointwise_conv.weight',
+                    'op_after_combine8/conv/bias':
+                    'conv3_up.pointwise_conv.bias',
+                    'op_after_combine8/bn/beta':
+                    'conv3_up.bn.bias',
+                    'op_after_combine8/bn/gamma':
+                    'conv3_up.bn.weight',
+                    'op_after_combine8/bn/moving_mean':
+                    'conv3_up.bn.running_mean',
+                    'op_after_combine8/bn/moving_variance':
+                    'conv3_up.bn.running_var',
+                }
+                if fpn_idx == 0:
+                    mapping = {
+                        'resample_0_0_8/conv2d/kernel':
+                        'p3_down_channel.down_conv.weight',
+                        'resample_0_0_8/conv2d/bias':
+                        'p3_down_channel.down_conv.bias',
+                        'resample_0_0_8/bn/beta':
+                        'p3_down_channel.bn.bias',
+                        'resample_0_0_8/bn/gamma':
+                        'p3_down_channel.bn.weight',
+                        'resample_0_0_8/bn/moving_mean':
+                        'p3_down_channel.bn.running_mean',
+                        'resample_0_0_8/bn/moving_variance':
+                        'p3_down_channel.bn.running_var',
+                    }
+                    base_mapping.update(mapping)
+                if seg[3] != 'WSM' and seg[3] != 'WSM_1':
+                    suffix = base_mapping['/'.join(seg[3:])]
+                    if 'depthwise_conv' in suffix:
+                        v = v.transpose(1, 0)
+                    m[prefix + '.' + suffix] = v
+                elif seg[3] == 'WSM':
+                    p3_w1[fpn_idx][0] = v
+                elif seg[3] == 'WSM_1':
+                    p3_w1[fpn_idx][1] = v
+                if torch.min(p3_w1[fpn_idx]) > -1e4:
+                    m[prefix + '.p3_w1'] = p3_w1[fpn_idx]
+            elif fnode_id == 4:
+                base_mapping = {
+                    'op_after_combine9/conv/depthwise_kernel':
+                    'conv4_down.depthwise_conv.weight',
+                    'op_after_combine9/conv/pointwise_kernel':
+                    'conv4_down.pointwise_conv.weight',
+                    'op_after_combine9/conv/bias':
+                    'conv4_down.pointwise_conv.bias',
+                    'op_after_combine9/bn/beta':
+                    'conv4_down.bn.bias',
+                    'op_after_combine9/bn/gamma':
+                    'conv4_down.bn.weight',
+                    'op_after_combine9/bn/moving_mean':
+                    'conv4_down.bn.running_mean',
+                    'op_after_combine9/bn/moving_variance':
+                    'conv4_down.bn.running_var',
+                }
+                if fpn_idx == 0:
+                    mapping = {
+                        'resample_0_1_9/conv2d/kernel':
+                        'p4_level_connection.down_conv.weight',
+                        'resample_0_1_9/conv2d/bias':
+                        'p4_level_connection.down_conv.bias',
+                        'resample_0_1_9/bn/beta':
+                        'p4_level_connection.bn.bias',
+                        'resample_0_1_9/bn/gamma':
+                        'p4_level_connection.bn.weight',
+                        'resample_0_1_9/bn/moving_mean':
+                        'p4_level_connection.bn.running_mean',
+                        'resample_0_1_9/bn/moving_variance':
+                        'p4_level_connection.bn.running_var',
+                    }
+                    base_mapping.update(mapping)
+                if seg[3] != 'WSM' and seg[3] != 'WSM_1' and seg[3] != 'WSM_2':
+                    suffix = base_mapping['/'.join(seg[3:])]
+                    if 'depthwise_conv' in suffix:
+                        v = v.transpose(1, 0)
+                    m[prefix + '.' + suffix] = v
+                elif seg[3] == 'WSM':
+                    p4_w2[fpn_idx][0] = v
+                elif seg[3] == 'WSM_1':
+                    p4_w2[fpn_idx][1] = v
+                elif seg[3] == 'WSM_2':
+                    p4_w2[fpn_idx][2] = v
+                if torch.min(p4_w2[fpn_idx]) > -1e4:
+                    m[prefix + '.p4_w2'] = p4_w2[fpn_idx]
+            elif fnode_id == 5:
+                base_mapping = {
+                    'op_after_combine10/conv/depthwise_kernel':
+                    'conv5_down.depthwise_conv.weight',
+                    'op_after_combine10/conv/pointwise_kernel':
+                    'conv5_down.pointwise_conv.weight',
+                    'op_after_combine10/conv/bias':
+                    'conv5_down.pointwise_conv.bias',
+                    'op_after_combine10/bn/beta':
+                    'conv5_down.bn.bias',
+                    'op_after_combine10/bn/gamma':
+                    'conv5_down.bn.weight',
+                    'op_after_combine10/bn/moving_mean':
+                    'conv5_down.bn.running_mean',
+                    'op_after_combine10/bn/moving_variance':
+                    'conv5_down.bn.running_var',
+                }
+                if fpn_idx == 0:
+                    mapping = {
+                        'resample_0_2_10/conv2d/kernel':
+                        'p5_level_connection.down_conv.weight',
+                        'resample_0_2_10/conv2d/bias':
+                        'p5_level_connection.down_conv.bias',
+                        'resample_0_2_10/bn/beta':
+                        'p5_level_connection.bn.bias',
+                        'resample_0_2_10/bn/gamma':
+                        'p5_level_connection.bn.weight',
+                        'resample_0_2_10/bn/moving_mean':
+                        'p5_level_connection.bn.running_mean',
+                        'resample_0_2_10/bn/moving_variance':
+                        'p5_level_connection.bn.running_var',
+                    }
+                    base_mapping.update(mapping)
+                if seg[3] != 'WSM' and seg[3] != 'WSM_1' and seg[3] != 'WSM_2':
+                    suffix = base_mapping['/'.join(seg[3:])]
+                    if 'depthwise_conv' in suffix:
+                        v = v.transpose(1, 0)
+                    m[prefix + '.' + suffix] = v
+                elif seg[3] == 'WSM':
+                    p5_w2[fpn_idx][0] = v
+                elif seg[3] == 'WSM_1':
+                    p5_w2[fpn_idx][1] = v
+                elif seg[3] == 'WSM_2':
+                    p5_w2[fpn_idx][2] = v
+                if torch.min(p5_w2[fpn_idx]) > -1e4:
+                    m[prefix + '.p5_w2'] = p5_w2[fpn_idx]
+            elif fnode_id == 6:
+                base_mapping = {
+                    'op_after_combine11/conv/depthwise_kernel':
+                    'conv6_down.depthwise_conv.weight',
+                    'op_after_combine11/conv/pointwise_kernel':
+                    'conv6_down.pointwise_conv.weight',
+                    'op_after_combine11/conv/bias':
+                    'conv6_down.pointwise_conv.bias',
+                    'op_after_combine11/bn/beta':
+                    'conv6_down.bn.bias',
+                    'op_after_combine11/bn/gamma':
+                    'conv6_down.bn.weight',
+                    'op_after_combine11/bn/moving_mean':
+                    'conv6_down.bn.running_mean',
+                    'op_after_combine11/bn/moving_variance':
+                    'conv6_down.bn.running_var',
+                }
+                if seg[3] != 'WSM' and seg[3] != 'WSM_1' and seg[3] != 'WSM_2':
+                    suffix = base_mapping['/'.join(seg[3:])]
+                    if 'depthwise_conv' in suffix:
+                        v = v.transpose(1, 0)
+                    m[prefix + '.' + suffix] = v
+                elif seg[3] == 'WSM':
+                    p6_w2[fpn_idx][0] = v
+                elif seg[3] == 'WSM_1':
+                    p6_w2[fpn_idx][1] = v
+                elif seg[3] == 'WSM_2':
+                    p6_w2[fpn_idx][2] = v
+                if torch.min(p6_w2[fpn_idx]) > -1e4:
+                    m[prefix + '.p6_w2'] = p6_w2[fpn_idx]
+            elif fnode_id == 7:
+                base_mapping = {
+                    'op_after_combine12/conv/depthwise_kernel':
+                    'conv7_down.depthwise_conv.weight',
+                    'op_after_combine12/conv/pointwise_kernel':
+                    'conv7_down.pointwise_conv.weight',
+                    'op_after_combine12/conv/bias':
+                    'conv7_down.pointwise_conv.bias',
+                    'op_after_combine12/bn/beta':
+                    'conv7_down.bn.bias',
+                    'op_after_combine12/bn/gamma':
+                    'conv7_down.bn.weight',
+                    'op_after_combine12/bn/moving_mean':
+                    'conv7_down.bn.running_mean',
+                    'op_after_combine12/bn/moving_variance':
+                    'conv7_down.bn.running_var',
+                }
+                if seg[3] != 'WSM' and seg[3] != 'WSM_1' and seg[3] != 'WSM_2':
+                    suffix = base_mapping['/'.join(seg[3:])]
+                    if 'depthwise_conv' in suffix:
+                        v = v.transpose(1, 0)
+                    m[prefix + '.' + suffix] = v
+                elif seg[3] == 'WSM':
+                    p7_w2[fpn_idx][0] = v
+                elif seg[3] == 'WSM_1':
+                    p7_w2[fpn_idx][1] = v
+                if torch.min(p7_w2[fpn_idx]) > -1e4:
+                    m[prefix + '.p7_w2'] = p7_w2[fpn_idx]
+        elif seg[0] == 'box_net':
+            if 'box-predict' in seg[1]:
+                prefix = '.'.join(['bbox_head', 'reg_header'])
+                base_mapping = {
+                    'depthwise_kernel': 'depthwise_conv.weight',
+                    'pointwise_kernel': 'pointwise_conv.weight',
+                    'bias': 'pointwise_conv.bias'
+                }
+                suffix = base_mapping['/'.join(seg[2:])]
+                if 'depthwise_conv' in suffix:
+                    v = v.transpose(1, 0)
+                m[prefix + '.' + suffix] = v
+            elif 'bn' in seg[1]:
+                bbox_conv_idx = int(seg[1][4])
+                bbox_bn_idx = int(seg[1][9]) - 3
+                prefix = '.'.join([
+                    'bbox_head', 'reg_bn_list',
+                    str(bbox_conv_idx),
+                    str(bbox_bn_idx)
+                ])
+                base_mapping = {
+                    'beta': 'bias',
+                    'gamma': 'weight',
+                    'moving_mean': 'running_mean',
+                    'moving_variance': 'running_var'
+                }
+                suffix = base_mapping['/'.join(seg[2:])]
+                m[prefix + '.' + suffix] = v
+            else:
+                bbox_conv_idx = int(seg[1][4])
+                prefix = '.'.join(
+                    ['bbox_head', 'reg_conv_list',
+                     str(bbox_conv_idx)])
+                base_mapping = {
+                    'depthwise_kernel': 'depthwise_conv.weight',
+                    'pointwise_kernel': 'pointwise_conv.weight',
+                    'bias': 'pointwise_conv.bias'
+                }
+                suffix = base_mapping['/'.join(seg[2:])]
+                if 'depthwise_conv' in suffix:
+                    v = v.transpose(1, 0)
+                m[prefix + '.' + suffix] = v
+        elif seg[0] == 'class_net':
+            if 'class-predict' in seg[1]:
+                prefix = '.'.join(['bbox_head', 'cls_header'])
+                base_mapping = {
+                    'depthwise_kernel': 'depthwise_conv.weight',
+                    'pointwise_kernel': 'pointwise_conv.weight',
+                    'bias': 'pointwise_conv.bias'
+                }
+                suffix = base_mapping['/'.join(seg[2:])]
+                if 'depthwise_conv' in suffix:
+                    v = v.transpose(1, 0)
+                m[prefix + '.' + suffix] = v
+            elif 'bn' in seg[1]:
+                cls_conv_idx = int(seg[1][6])
+                cls_bn_idx = int(seg[1][11]) - 3
+                prefix = '.'.join([
+                    'bbox_head', 'cls_bn_list',
+                    str(cls_conv_idx),
+                    str(cls_bn_idx)
+                ])
+                base_mapping = {
+                    'beta': 'bias',
+                    'gamma': 'weight',
+                    'moving_mean': 'running_mean',
+                    'moving_variance': 'running_var'
+                }
+                suffix = base_mapping['/'.join(seg[2:])]
+                m[prefix + '.' + suffix] = v
+            else:
+                cls_conv_idx = int(seg[1][6])
+                prefix = '.'.join(
+                    ['bbox_head', 'cls_conv_list',
+                     str(cls_conv_idx)])
+                base_mapping = {
+                    'depthwise_kernel': 'depthwise_conv.weight',
+                    'pointwise_kernel': 'pointwise_conv.weight',
+                    'bias': 'pointwise_conv.bias'
+                }
+                suffix = base_mapping['/'.join(seg[2:])]
+                if 'depthwise_conv' in suffix:
+                    v = v.transpose(1, 0)
+                m[prefix + '.' + suffix] = v
+    return m
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='convert efficientdet weight from tensorflow to pytorch')
+    parser.add_argument(
+        '--backbone',
+        type=str,
+        help='efficientnet model name, like efficientnet-b0')
+    parser.add_argument(
+        '--tensorflow_weight',
+        type=str,
+        help='efficientdet tensorflow weight name, like efficientdet-d0/model')
+    parser.add_argument(
+        '--out_weight',
+        type=str,
+        help='efficientdet pytorch weight name like demo.pth')
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    model_name = args.backbone
+    ori_weight_name = args.tensorflow_weight
+    out_name = args.out_weight
+
+    repeat_map = {
+        0: 3,
+        1: 4,
+        2: 5,
+        3: 6,
+        4: 7,
+        5: 7,
+        6: 8,
+        7: 8,
+    }
+
+    reader = py_checkpoint_reader.NewCheckpointReader(ori_weight_name)
+    weights = {
+        n: torch.as_tensor(tf2pth(reader.get_tensor(n)))
+        for (n, _) in reader.get_variable_to_shape_map().items()
+    }
+    bifpn_repeats = repeat_map[int(model_name[14])]
+    out = convert_key(model_name, bifpn_repeats, weights)
+    result = {'state_dict': out}
+    torch.save(result, out_name)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/mmdetection/projects/EfficientDet/efficientdet/__init__.py b/mmdetection/projects/EfficientDet/efficientdet/__init__.py
new file mode 100644
index 00000000..b6c66bcc
--- /dev/null
+++ b/mmdetection/projects/EfficientDet/efficientdet/__init__.py
@@ -0,0 +1,16 @@
+from .bifpn import BiFPN
+from .efficientdet import EfficientDet
+from .efficientdet_head import EfficientDetSepBNHead
+from .huber_loss import HuberLoss
+from .tensorflow.anchor_generator import YXYXAnchorGenerator
+from .tensorflow.coco_90class import Coco90Dataset
+from .tensorflow.coco_90metric import Coco90Metric
+from .tensorflow.trans_max_iou_assigner import TransMaxIoUAssigner
+from .tensorflow.yxyx_bbox_coder import YXYXDeltaXYWHBBoxCoder
+from .utils import Conv2dSamePadding
+
+__all__ = [
+    'EfficientDet', 'BiFPN', 'HuberLoss', 'EfficientDetSepBNHead',
+    'Conv2dSamePadding', 'Coco90Dataset', 'Coco90Metric',
+    'YXYXAnchorGenerator', 'TransMaxIoUAssigner', 'YXYXDeltaXYWHBBoxCoder'
+]
diff --git a/mmdetection/projects/EfficientDet/efficientdet/bifpn.py b/mmdetection/projects/EfficientDet/efficientdet/bifpn.py
new file mode 100644
index 00000000..56356c3c
--- /dev/null
+++ b/mmdetection/projects/EfficientDet/efficientdet/bifpn.py
@@ -0,0 +1,306 @@
+from typing import List
+
+import torch
+import torch.nn as nn
+from mmcv.cnn.bricks import Swish
+from mmengine.model import BaseModule
+
+from mmdet.registry import MODELS
+from mmdet.utils import MultiConfig, OptConfigType
+from .utils import DepthWiseConvBlock, DownChannelBlock, MaxPool2dSamePadding
+
+
+class BiFPNStage(nn.Module):
+    """
+        in_channels: List[int], input dim for P3, P4, P5
+        out_channels: int, output dim for P2 - P7
+        first_time: int, whether is the first bifpnstage
+        conv_bn_act_pattern: bool, whether use conv_bn_act_pattern
+        norm_cfg: (:obj:`ConfigDict` or dict, optional): Config dict for
+            normalization layer.
+        epsilon: float, hyperparameter in fusion features
+    """
+
+    def __init__(self,
+                 in_channels: List[int],
+                 out_channels: int,
+                 first_time: bool = False,
+                 apply_bn_for_resampling: bool = True,
+                 conv_bn_act_pattern: bool = False,
+                 norm_cfg: OptConfigType = dict(
+                     type='BN', momentum=1e-2, eps=1e-3),
+                 epsilon: float = 1e-4) -> None:
+        super().__init__()
+        assert isinstance(in_channels, list)
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.first_time = first_time
+        self.apply_bn_for_resampling = apply_bn_for_resampling
+        self.conv_bn_act_pattern = conv_bn_act_pattern
+        self.norm_cfg = norm_cfg
+        self.epsilon = epsilon
+
+        if self.first_time:
+            self.p5_down_channel = DownChannelBlock(
+                self.in_channels[-1],
+                self.out_channels,
+                apply_norm=self.apply_bn_for_resampling,
+                conv_bn_act_pattern=self.conv_bn_act_pattern,
+                norm_cfg=norm_cfg)
+            self.p4_down_channel = DownChannelBlock(
+                self.in_channels[-2],
+                self.out_channels,
+                apply_norm=self.apply_bn_for_resampling,
+                conv_bn_act_pattern=self.conv_bn_act_pattern,
+                norm_cfg=norm_cfg)
+            self.p3_down_channel = DownChannelBlock(
+                self.in_channels[-3],
+                self.out_channels,
+                apply_norm=self.apply_bn_for_resampling,
+                conv_bn_act_pattern=self.conv_bn_act_pattern,
+                norm_cfg=norm_cfg)
+            self.p5_to_p6 = nn.Sequential(
+                DownChannelBlock(
+                    self.in_channels[-1],
+                    self.out_channels,
+                    apply_norm=self.apply_bn_for_resampling,
+                    conv_bn_act_pattern=self.conv_bn_act_pattern,
+                    norm_cfg=norm_cfg), MaxPool2dSamePadding(3, 2))
+            self.p6_to_p7 = MaxPool2dSamePadding(3, 2)
+            self.p4_level_connection = DownChannelBlock(
+                self.in_channels[-2],
+                self.out_channels,
+                apply_norm=self.apply_bn_for_resampling,
+                conv_bn_act_pattern=self.conv_bn_act_pattern,
+                norm_cfg=norm_cfg)
+            self.p5_level_connection = DownChannelBlock(
+                self.in_channels[-1],
+                self.out_channels,
+                apply_norm=self.apply_bn_for_resampling,
+                conv_bn_act_pattern=self.conv_bn_act_pattern,
+                norm_cfg=norm_cfg)
+
+        self.p6_upsample = nn.Upsample(scale_factor=2, mode='nearest')
+        self.p5_upsample = nn.Upsample(scale_factor=2, mode='nearest')
+        self.p4_upsample = nn.Upsample(scale_factor=2, mode='nearest')
+        self.p3_upsample = nn.Upsample(scale_factor=2, mode='nearest')
+
+        # bottom to up: feature map down_sample module
+        self.p4_down_sample = MaxPool2dSamePadding(3, 2)
+        self.p5_down_sample = MaxPool2dSamePadding(3, 2)
+        self.p6_down_sample = MaxPool2dSamePadding(3, 2)
+        self.p7_down_sample = MaxPool2dSamePadding(3, 2)
+
+        # Fuse Conv Layers
+        self.conv6_up = DepthWiseConvBlock(
+            out_channels,
+            out_channels,
+            apply_norm=self.apply_bn_for_resampling,
+            conv_bn_act_pattern=self.conv_bn_act_pattern,
+            norm_cfg=norm_cfg)
+        self.conv5_up = DepthWiseConvBlock(
+            out_channels,
+            out_channels,
+            apply_norm=self.apply_bn_for_resampling,
+            conv_bn_act_pattern=self.conv_bn_act_pattern,
+            norm_cfg=norm_cfg)
+        self.conv4_up = DepthWiseConvBlock(
+            out_channels,
+            out_channels,
+            apply_norm=self.apply_bn_for_resampling,
+            conv_bn_act_pattern=self.conv_bn_act_pattern,
+            norm_cfg=norm_cfg)
+        self.conv3_up = DepthWiseConvBlock(
+            out_channels,
+            out_channels,
+            apply_norm=self.apply_bn_for_resampling,
+            conv_bn_act_pattern=self.conv_bn_act_pattern,
+            norm_cfg=norm_cfg)
+        self.conv4_down = DepthWiseConvBlock(
+            out_channels,
+            out_channels,
+            apply_norm=self.apply_bn_for_resampling,
+            conv_bn_act_pattern=self.conv_bn_act_pattern,
+            norm_cfg=norm_cfg)
+        self.conv5_down = DepthWiseConvBlock(
+            out_channels,
+            out_channels,
+            apply_norm=self.apply_bn_for_resampling,
+            conv_bn_act_pattern=self.conv_bn_act_pattern,
+            norm_cfg=norm_cfg)
+        self.conv6_down = DepthWiseConvBlock(
+            out_channels,
+            out_channels,
+            apply_norm=self.apply_bn_for_resampling,
+            conv_bn_act_pattern=self.conv_bn_act_pattern,
+            norm_cfg=norm_cfg)
+        self.conv7_down = DepthWiseConvBlock(
+            out_channels,
+            out_channels,
+            apply_norm=self.apply_bn_for_resampling,
+            conv_bn_act_pattern=self.conv_bn_act_pattern,
+            norm_cfg=norm_cfg)
+        # weights
+        self.p6_w1 = nn.Parameter(
+            torch.ones(2, dtype=torch.float32), requires_grad=True)
+        self.p6_w1_relu = nn.ReLU()
+        self.p5_w1 = nn.Parameter(
+            torch.ones(2, dtype=torch.float32), requires_grad=True)
+        self.p5_w1_relu = nn.ReLU()
+        self.p4_w1 = nn.Parameter(
+            torch.ones(2, dtype=torch.float32), requires_grad=True)
+        self.p4_w1_relu = nn.ReLU()
+        self.p3_w1 = nn.Parameter(
+            torch.ones(2, dtype=torch.float32), requires_grad=True)
+        self.p3_w1_relu = nn.ReLU()
+
+        self.p4_w2 = nn.Parameter(
+            torch.ones(3, dtype=torch.float32), requires_grad=True)
+        self.p4_w2_relu = nn.ReLU()
+        self.p5_w2 = nn.Parameter(
+            torch.ones(3, dtype=torch.float32), requires_grad=True)
+        self.p5_w2_relu = nn.ReLU()
+        self.p6_w2 = nn.Parameter(
+            torch.ones(3, dtype=torch.float32), requires_grad=True)
+        self.p6_w2_relu = nn.ReLU()
+        self.p7_w2 = nn.Parameter(
+            torch.ones(2, dtype=torch.float32), requires_grad=True)
+        self.p7_w2_relu = nn.ReLU()
+
+        self.swish = Swish()
+
+    def combine(self, x):
+        if not self.conv_bn_act_pattern:
+            x = self.swish(x)
+
+        return x
+
+    def forward(self, x):
+        if self.first_time:
+            p3, p4, p5 = x
+            # build feature map P6
+            p6_in = self.p5_to_p6(p5)
+            # build feature map P7
+            p7_in = self.p6_to_p7(p6_in)
+
+            p3_in = self.p3_down_channel(p3)
+            p4_in = self.p4_down_channel(p4)
+            p5_in = self.p5_down_channel(p5)
+
+        else:
+            p3_in, p4_in, p5_in, p6_in, p7_in = x
+
+        # Weights for P6_0 and P7_0 to P6_1
+        p6_w1 = self.p6_w1_relu(self.p6_w1)
+        weight = p6_w1 / (torch.sum(p6_w1, dim=0) + self.epsilon)
+        # Connections for P6_0 and P7_0 to P6_1 respectively
+        p6_up = self.conv6_up(
+            self.combine(weight[0] * p6_in +
+                         weight[1] * self.p6_upsample(p7_in)))
+
+        # Weights for P5_0 and P6_1 to P5_1
+        p5_w1 = self.p5_w1_relu(self.p5_w1)
+        weight = p5_w1 / (torch.sum(p5_w1, dim=0) + self.epsilon)
+        # Connections for P5_0 and P6_1 to P5_1 respectively
+        p5_up = self.conv5_up(
+            self.combine(weight[0] * p5_in +
+                         weight[1] * self.p5_upsample(p6_up)))
+
+        # Weights for P4_0 and P5_1 to P4_1
+        p4_w1 = self.p4_w1_relu(self.p4_w1)
+        weight = p4_w1 / (torch.sum(p4_w1, dim=0) + self.epsilon)
+        # Connections for P4_0 and P5_1 to P4_1 respectively
+        p4_up = self.conv4_up(
+            self.combine(weight[0] * p4_in +
+                         weight[1] * self.p4_upsample(p5_up)))
+
+        # Weights for P3_0 and P4_1 to P3_2
+        p3_w1 = self.p3_w1_relu(self.p3_w1)
+        weight = p3_w1 / (torch.sum(p3_w1, dim=0) + self.epsilon)
+        # Connections for P3_0 and P4_1 to P3_2 respectively
+        p3_out = self.conv3_up(
+            self.combine(weight[0] * p3_in +
+                         weight[1] * self.p3_upsample(p4_up)))
+
+        if self.first_time:
+            p4_in = self.p4_level_connection(p4)
+            p5_in = self.p5_level_connection(p5)
+
+        # Weights for P4_0, P4_1 and P3_2 to P4_2
+        p4_w2 = self.p4_w2_relu(self.p4_w2)
+        weight = p4_w2 / (torch.sum(p4_w2, dim=0) + self.epsilon)
+        # Connections for P4_0, P4_1 and P3_2 to P4_2 respectively
+        p4_out = self.conv4_down(
+            self.combine(weight[0] * p4_in + weight[1] * p4_up +
+                         weight[2] * self.p4_down_sample(p3_out)))
+
+        # Weights for P5_0, P5_1 and P4_2 to P5_2
+        p5_w2 = self.p5_w2_relu(self.p5_w2)
+        weight = p5_w2 / (torch.sum(p5_w2, dim=0) + self.epsilon)
+        # Connections for P5_0, P5_1 and P4_2 to P5_2 respectively
+        p5_out = self.conv5_down(
+            self.combine(weight[0] * p5_in + weight[1] * p5_up +
+                         weight[2] * self.p5_down_sample(p4_out)))
+
+        # Weights for P6_0, P6_1 and P5_2 to P6_2
+        p6_w2 = self.p6_w2_relu(self.p6_w2)
+        weight = p6_w2 / (torch.sum(p6_w2, dim=0) + self.epsilon)
+        # Connections for P6_0, P6_1 and P5_2 to P6_2 respectively
+        p6_out = self.conv6_down(
+            self.combine(weight[0] * p6_in + weight[1] * p6_up +
+                         weight[2] * self.p6_down_sample(p5_out)))
+
+        # Weights for P7_0 and P6_2 to P7_2
+        p7_w2 = self.p7_w2_relu(self.p7_w2)
+        weight = p7_w2 / (torch.sum(p7_w2, dim=0) + self.epsilon)
+        # Connections for P7_0 and P6_2 to P7_2
+        p7_out = self.conv7_down(
+            self.combine(weight[0] * p7_in +
+                         weight[1] * self.p7_down_sample(p6_out)))
+        return p3_out, p4_out, p5_out, p6_out, p7_out
+
+
+@MODELS.register_module()
+class BiFPN(BaseModule):
+    """
+        num_stages: int, bifpn number of repeats
+        in_channels: List[int], input dim for P3, P4, P5
+        out_channels: int, output dim for P2 - P7
+        start_level: int, Index of input features in backbone
+        epsilon: float, hyperparameter in fusion features
+        apply_bn_for_resampling: bool, whether use bn after resampling
+        conv_bn_act_pattern: bool, whether use conv_bn_act_pattern
+        norm_cfg: (:obj:`ConfigDict` or dict, optional): Config dict for
+            normalization layer.
+        init_cfg: MultiConfig: init method
+    """
+
+    def __init__(self,
+                 num_stages: int,
+                 in_channels: List[int],
+                 out_channels: int,
+                 start_level: int = 0,
+                 epsilon: float = 1e-4,
+                 apply_bn_for_resampling: bool = True,
+                 conv_bn_act_pattern: bool = False,
+                 norm_cfg: OptConfigType = dict(
+                     type='BN', momentum=1e-2, eps=1e-3),
+                 init_cfg: MultiConfig = None) -> None:
+        super().__init__(init_cfg=init_cfg)
+        self.start_level = start_level
+        self.bifpn = nn.Sequential(*[
+            BiFPNStage(
+                in_channels=in_channels,
+                out_channels=out_channels,
+                first_time=True if _ == 0 else False,
+                apply_bn_for_resampling=apply_bn_for_resampling,
+                conv_bn_act_pattern=conv_bn_act_pattern,
+                norm_cfg=norm_cfg,
+                epsilon=epsilon) for _ in range(num_stages)
+        ])
+
+    def forward(self, x):
+        x = x[self.start_level:]
+        x = self.bifpn(x)
+
+        return x
diff --git a/mmdetection/projects/EfficientDet/efficientdet/efficientdet.py b/mmdetection/projects/EfficientDet/efficientdet/efficientdet.py
new file mode 100644
index 00000000..84e1778f
--- /dev/null
+++ b/mmdetection/projects/EfficientDet/efficientdet/efficientdet.py
@@ -0,0 +1,25 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from mmdet.models.detectors.single_stage import SingleStageDetector
+from mmdet.registry import MODELS
+from mmdet.utils import ConfigType, OptConfigType, OptMultiConfig
+
+
+@MODELS.register_module()
+class EfficientDet(SingleStageDetector):
+
+    def __init__(self,
+                 backbone: ConfigType,
+                 neck: ConfigType,
+                 bbox_head: ConfigType,
+                 train_cfg: OptConfigType = None,
+                 test_cfg: OptConfigType = None,
+                 data_preprocessor: OptConfigType = None,
+                 init_cfg: OptMultiConfig = None) -> None:
+        super().__init__(
+            backbone=backbone,
+            neck=neck,
+            bbox_head=bbox_head,
+            train_cfg=train_cfg,
+            test_cfg=test_cfg,
+            data_preprocessor=data_preprocessor,
+            init_cfg=init_cfg)
diff --git a/mmdetection/projects/EfficientDet/efficientdet/efficientdet_head.py b/mmdetection/projects/EfficientDet/efficientdet/efficientdet_head.py
new file mode 100644
index 00000000..ae3efbe2
--- /dev/null
+++ b/mmdetection/projects/EfficientDet/efficientdet/efficientdet_head.py
@@ -0,0 +1,261 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Tuple
+
+import torch
+import torch.nn as nn
+from mmcv.cnn.bricks import Swish, build_norm_layer
+from mmengine.model import bias_init_with_prob
+from torch import Tensor
+
+from mmdet.models.dense_heads.anchor_head import AnchorHead
+from mmdet.models.utils import images_to_levels, multi_apply
+from mmdet.registry import MODELS
+from mmdet.structures.bbox import cat_boxes, get_box_tensor
+from mmdet.utils import (InstanceList, OptConfigType, OptInstanceList,
+                         OptMultiConfig, reduce_mean)
+from .utils import DepthWiseConvBlock
+
+
+@MODELS.register_module()
+class EfficientDetSepBNHead(AnchorHead):
+    """EfficientDetHead with separate BN.
+
+    num_classes (int): Number of categories num_ins (int):  Number of the input
+    feature map. in_channels (int): Number of channels in the input feature
+    map. feat_channels (int): Number of hidden channels. stacked_convs (int):
+    Number of repetitions of conv norm_cfg (dict): Config dict for
+    normalization layer. anchor_generator (dict): Config dict for anchor
+    generator bbox_coder (dict): Config of bounding box coder. loss_cls (dict):
+    Config of classification loss. loss_bbox (dict): Config of localization
+    loss. train_cfg (dict): Training config of anchor head. test_cfg (dict):
+    Testing config of anchor head. init_cfg (dict or list[dict], optional):
+    Initialization config dict.
+    """
+
+    def __init__(self,
+                 num_classes: int,
+                 num_ins: int,
+                 in_channels: int,
+                 feat_channels: int,
+                 stacked_convs: int = 3,
+                 norm_cfg: OptConfigType = dict(
+                     type='BN', momentum=1e-2, eps=1e-3),
+                 init_cfg: OptMultiConfig = None,
+                 **kwargs) -> None:
+        self.num_ins = num_ins
+        self.stacked_convs = stacked_convs
+        self.norm_cfg = norm_cfg
+        super().__init__(
+            num_classes=num_classes,
+            in_channels=in_channels,
+            feat_channels=feat_channels,
+            init_cfg=init_cfg,
+            **kwargs)
+
+    def _init_layers(self) -> None:
+        """Initialize layers of the head."""
+        self.reg_conv_list = nn.ModuleList()
+        self.cls_conv_list = nn.ModuleList()
+        for i in range(self.stacked_convs):
+            channels = self.in_channels if i == 0 else self.feat_channels
+            self.reg_conv_list.append(
+                DepthWiseConvBlock(
+                    channels, self.feat_channels, apply_norm=False))
+            self.cls_conv_list.append(
+                DepthWiseConvBlock(
+                    channels, self.feat_channels, apply_norm=False))
+
+        self.reg_bn_list = nn.ModuleList([
+            nn.ModuleList([
+                build_norm_layer(
+                    self.norm_cfg, num_features=self.feat_channels)[1]
+                for j in range(self.num_ins)
+            ]) for i in range(self.stacked_convs)
+        ])
+
+        self.cls_bn_list = nn.ModuleList([
+            nn.ModuleList([
+                build_norm_layer(
+                    self.norm_cfg, num_features=self.feat_channels)[1]
+                for j in range(self.num_ins)
+            ]) for i in range(self.stacked_convs)
+        ])
+
+        self.cls_header = DepthWiseConvBlock(
+            self.in_channels,
+            self.num_base_priors * self.cls_out_channels,
+            apply_norm=False)
+        self.reg_header = DepthWiseConvBlock(
+            self.in_channels, self.num_base_priors * 4, apply_norm=False)
+        self.swish = Swish()
+
+    def init_weights(self) -> None:
+        """Initialize weights of the head."""
+        for m in self.reg_conv_list:
+            nn.init.constant_(m.pointwise_conv.bias, 0.0)
+        for m in self.cls_conv_list:
+            nn.init.constant_(m.pointwise_conv.bias, 0.0)
+        bias_cls = bias_init_with_prob(0.01)
+        nn.init.constant_(self.cls_header.pointwise_conv.bias, bias_cls)
+        nn.init.constant_(self.reg_header.pointwise_conv.bias, 0.0)
+
+    def forward_single_bbox(self, feat: Tensor, level_id: int,
+                            i: int) -> Tensor:
+        conv_op = self.reg_conv_list[i]
+        bn = self.reg_bn_list[i][level_id]
+
+        feat = conv_op(feat)
+        feat = bn(feat)
+        feat = self.swish(feat)
+
+        return feat
+
+    def forward_single_cls(self, feat: Tensor, level_id: int,
+                           i: int) -> Tensor:
+        conv_op = self.cls_conv_list[i]
+        bn = self.cls_bn_list[i][level_id]
+
+        feat = conv_op(feat)
+        feat = bn(feat)
+        feat = self.swish(feat)
+
+        return feat
+
+    def forward(self, feats: Tuple[Tensor]) -> tuple:
+        cls_scores = []
+        bbox_preds = []
+        for level_id in range(self.num_ins):
+            feat = feats[level_id]
+            for i in range(self.stacked_convs):
+                feat = self.forward_single_bbox(feat, level_id, i)
+            bbox_pred = self.reg_header(feat)
+            bbox_preds.append(bbox_pred)
+        for level_id in range(self.num_ins):
+            feat = feats[level_id]
+            for i in range(self.stacked_convs):
+                feat = self.forward_single_cls(feat, level_id, i)
+            cls_score = self.cls_header(feat)
+            cls_scores.append(cls_score)
+
+        return cls_scores, bbox_preds
+
+    def loss_by_feat(
+            self,
+            cls_scores: List[Tensor],
+            bbox_preds: List[Tensor],
+            batch_gt_instances: InstanceList,
+            batch_img_metas: List[dict],
+            batch_gt_instances_ignore: OptInstanceList = None) -> dict:
+        """Calculate the loss based on the features extracted by the detection
+        head.
+
+        Args:
+            cls_scores (list[Tensor]): Box scores for each scale level
+                has shape (N, num_anchors * num_classes, H, W).
+            bbox_preds (list[Tensor]): Box energies / deltas for each scale
+                level with shape (N, num_anchors * 4, H, W).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict: A dictionary of loss components.
+        """
+        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
+        assert len(featmap_sizes) == self.prior_generator.num_levels
+
+        device = cls_scores[0].device
+
+        anchor_list, valid_flag_list = self.get_anchors(
+            featmap_sizes, batch_img_metas, device=device)
+        cls_reg_targets = self.get_targets(
+            anchor_list,
+            valid_flag_list,
+            batch_gt_instances,
+            batch_img_metas,
+            batch_gt_instances_ignore=batch_gt_instances_ignore)
+        (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,
+         avg_factor) = cls_reg_targets
+
+        # anchor number of multi levels
+        num_level_anchors = [anchors.size(0) for anchors in anchor_list[0]]
+        # concat all level anchors and flags to a single tensor
+        concat_anchor_list = []
+        for i in range(len(anchor_list)):
+            concat_anchor_list.append(cat_boxes(anchor_list[i]))
+        all_anchor_list = images_to_levels(concat_anchor_list,
+                                           num_level_anchors)
+
+        avg_factor = reduce_mean(
+            torch.tensor(avg_factor, dtype=torch.float, device=device)).item()
+        avg_factor = max(avg_factor, 1.0)
+        losses_cls, losses_bbox = multi_apply(
+            self.loss_by_feat_single,
+            cls_scores,
+            bbox_preds,
+            all_anchor_list,
+            labels_list,
+            label_weights_list,
+            bbox_targets_list,
+            bbox_weights_list,
+            avg_factor=avg_factor)
+        return dict(loss_cls=losses_cls, loss_bbox=losses_bbox)
+
+    def loss_by_feat_single(self, cls_score: Tensor, bbox_pred: Tensor,
+                            anchors: Tensor, labels: Tensor,
+                            label_weights: Tensor, bbox_targets: Tensor,
+                            bbox_weights: Tensor, avg_factor: int) -> tuple:
+        """Calculate the loss of a single scale level based on the features
+        extracted by the detection head.
+
+        Args:
+            cls_score (Tensor): Box scores for each scale level
+                Has shape (N, num_anchors * num_classes, H, W).
+            bbox_pred (Tensor): Box energies / deltas for each scale
+                level with shape (N, num_anchors * 4, H, W).
+            anchors (Tensor): Box reference for each scale level with shape
+                (N, num_total_anchors, 4).
+            labels (Tensor): Labels of each anchors with shape
+                (N, num_total_anchors).
+            label_weights (Tensor): Label weights of each anchor with shape
+                (N, num_total_anchors)
+            bbox_targets (Tensor): BBox regression targets of each anchor
+                weight shape (N, num_total_anchors, 4).
+            bbox_weights (Tensor): BBox regression loss weights of each anchor
+                with shape (N, num_total_anchors, 4).
+            avg_factor (int): Average factor that is used to average the loss.
+
+        Returns:
+            tuple: loss components.
+        """
+
+        # classification loss
+        labels = labels.reshape(-1)
+        label_weights = label_weights.reshape(-1)
+        cls_score = cls_score.permute(0, 2, 3,
+                                      1).reshape(-1, self.cls_out_channels)
+        loss_cls = self.loss_cls(
+            cls_score, labels, label_weights, avg_factor=avg_factor)
+        # regression loss
+        target_dim = bbox_targets.size(-1)
+        bbox_targets = bbox_targets.reshape(-1, target_dim)
+        bbox_weights = bbox_weights.reshape(-1, target_dim)
+        bbox_pred = bbox_pred.permute(0, 2, 3,
+                                      1).reshape(-1,
+                                                 self.bbox_coder.encode_size)
+        if self.reg_decoded_bbox:
+            # When the regression loss (e.g. `IouLoss`, `GIouLoss`)
+            # is applied directly on the decoded bounding boxes, it
+            # decodes the already encoded coordinates to absolute format.
+            anchors = anchors.reshape(-1, anchors.size(-1))
+            bbox_pred = self.bbox_coder.decode(anchors, bbox_pred)
+            bbox_pred = get_box_tensor(bbox_pred)
+        loss_bbox = self.loss_bbox(
+            bbox_pred, bbox_targets, bbox_weights, avg_factor=avg_factor * 4)
+        return loss_cls, loss_bbox
diff --git a/mmdetection/projects/EfficientDet/efficientdet/huber_loss.py b/mmdetection/projects/EfficientDet/efficientdet/huber_loss.py
new file mode 100644
index 00000000..091963fa
--- /dev/null
+++ b/mmdetection/projects/EfficientDet/efficientdet/huber_loss.py
@@ -0,0 +1,91 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional
+
+import torch
+import torch.nn as nn
+from torch import Tensor
+
+from mmdet.models.losses.utils import weighted_loss
+from mmdet.registry import MODELS
+
+
+@weighted_loss
+def huber_loss(pred: Tensor, target: Tensor, beta: float = 1.0) -> Tensor:
+    """Huber loss.
+
+    Args:
+        pred (Tensor): The prediction.
+        target (Tensor): The learning target of the prediction.
+        beta (float, optional): The threshold in the piecewise function.
+            Defaults to 1.0.
+
+    Returns:
+        Tensor: Calculated loss
+    """
+    assert beta > 0
+    if target.numel() == 0:
+        return pred.sum() * 0
+
+    assert pred.size() == target.size()
+    diff = torch.abs(pred - target)
+    loss = torch.where(diff < beta, 0.5 * diff * diff,
+                       beta * diff - 0.5 * beta * beta)
+    return loss
+
+
+@MODELS.register_module()
+class HuberLoss(nn.Module):
+    """Huber loss.
+
+    Args:
+        beta (float, optional): The threshold in the piecewise function.
+            Defaults to 1.0.
+        reduction (str, optional): The method to reduce the loss.
+            Options are "none", "mean" and "sum". Defaults to "mean".
+        loss_weight (float, optional): The weight of loss.
+    """
+
+    def __init__(self,
+                 beta: float = 1.0,
+                 reduction: str = 'mean',
+                 loss_weight: float = 1.0) -> None:
+        super().__init__()
+        self.beta = beta
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+
+    def forward(self,
+                pred: Tensor,
+                target: Tensor,
+                weight: Optional[Tensor] = None,
+                avg_factor: Optional[int] = None,
+                reduction_override: Optional[str] = None,
+                **kwargs) -> Tensor:
+        """Forward function.
+
+        Args:
+            pred (Tensor): The prediction.
+            target (Tensor): The learning target of the prediction.
+            weight (Tensor, optional): The weight of loss for each
+                prediction. Defaults to None.
+            avg_factor (int, optional): Average factor that is used to average
+                the loss. Defaults to None.
+            reduction_override (str, optional): The reduction method used to
+                override the original reduction method of the loss.
+                Defaults to None.
+
+        Returns:
+            Tensor: Calculated loss
+        """
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (
+            reduction_override if reduction_override else self.reduction)
+        loss_bbox = self.loss_weight * huber_loss(
+            pred,
+            target,
+            weight,
+            beta=self.beta,
+            reduction=reduction,
+            avg_factor=avg_factor,
+            **kwargs)
+        return loss_bbox
diff --git a/mmdetection/projects/EfficientDet/efficientdet/tensorflow/anchor_generator.py b/mmdetection/projects/EfficientDet/efficientdet/tensorflow/anchor_generator.py
new file mode 100644
index 00000000..51936a34
--- /dev/null
+++ b/mmdetection/projects/EfficientDet/efficientdet/tensorflow/anchor_generator.py
@@ -0,0 +1,109 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional, Tuple, Union
+
+import torch
+from torch import Tensor
+
+from mmdet.models.task_modules.prior_generators.anchor_generator import \
+    AnchorGenerator
+from mmdet.registry import TASK_UTILS
+from mmdet.structures.bbox import HorizontalBoxes
+
+DeviceType = Union[str, torch.device]
+
+
+@TASK_UTILS.register_module()
+class YXYXAnchorGenerator(AnchorGenerator):
+
+    def gen_single_level_base_anchors(self,
+                                      base_size: Union[int, float],
+                                      scales: Tensor,
+                                      ratios: Tensor,
+                                      center: Optional[Tuple[float]] = None) \
+            -> Tensor:
+        """Generate base anchors of a single level.
+
+        Args:
+            base_size (int | float): Basic size of an anchor.
+            scales (torch.Tensor): Scales of the anchor.
+            ratios (torch.Tensor): The ratio between the height
+                and width of anchors in a single level.
+            center (tuple[float], optional): The center of the base anchor
+                related to a single feature grid. Defaults to None.
+
+        Returns:
+            torch.Tensor: Anchors in a single-level feature maps.
+        """
+
+        w = base_size
+        h = base_size
+        if center is None:
+            x_center = self.center_offset * w
+            y_center = self.center_offset * h
+        else:
+            x_center, y_center = center
+
+        h_ratios = torch.sqrt(ratios)
+        w_ratios = 1 / h_ratios
+        if self.scale_major:
+            ws = (w * scales[:, None] * w_ratios[None, :]).view(-1)
+            hs = (h * scales[:, None] * h_ratios[None, :]).view(-1)
+        else:
+            ws = (w * scales[:, None] * w_ratios[None, :]).view(-1)
+            hs = (h * scales[:, None] * h_ratios[None, :]).view(-1)
+
+        # use float anchor and the anchor's center is aligned with the
+        # pixel center
+        base_anchors = [
+            y_center - 0.5 * hs,
+            x_center - 0.5 * ws,
+            y_center + 0.5 * hs,
+            x_center + 0.5 * ws,
+        ]
+        base_anchors = torch.stack(base_anchors, dim=-1)
+
+        return base_anchors
+
+    def single_level_grid_priors(self,
+                                 featmap_size: Tuple[int, int],
+                                 level_idx: int,
+                                 dtype: torch.dtype = torch.float32,
+                                 device: DeviceType = 'cuda') -> Tensor:
+        """Generate grid anchors of a single level.
+
+        Note:
+            This function is usually called by method ``self.grid_priors``.
+
+        Args:
+            featmap_size (tuple[int, int]): Size of the feature maps.
+            level_idx (int): The index of corresponding feature map level.
+            dtype (obj:`torch.dtype`): Date type of points.Defaults to
+                ``torch.float32``.
+            device (str | torch.device): The device the tensor will be put on.
+                Defaults to 'cuda'.
+
+        Returns:
+            torch.Tensor: Anchors in the overall feature maps.
+        """
+        base_anchors = self.base_anchors[level_idx].to(device).to(dtype)
+        feat_h, feat_w = featmap_size
+        stride_w, stride_h = self.strides[level_idx]
+        # First create Range with the default dtype, than convert to
+        # target `dtype` for onnx exporting.
+        shift_x = torch.arange(0, feat_w, device=device).to(dtype) * stride_w
+        shift_y = torch.arange(0, feat_h, device=device).to(dtype) * stride_h
+
+        shift_xx, shift_yy = self._meshgrid(shift_x, shift_y)
+        shifts = torch.stack([shift_yy, shift_xx, shift_yy, shift_xx], dim=-1)
+        # first feat_w elements correspond to the first row of shifts
+        # add A anchors (1, A, 4) to K shifts (K, 1, 4) to get
+        # shifted anchors (K, A, 4), reshape to (K*A, 4)
+
+        all_anchors = base_anchors[None, :, :] + shifts[:, None, :]
+        all_anchors = all_anchors.view(-1, 4)
+        # first A rows correspond to A anchors of (0, 0) in feature map,
+        # then (0, 1), (0, 2), ...
+        if self.use_box_type:
+            all_anchors = HorizontalBoxes(all_anchors)
+
+        return all_anchors
diff --git a/mmdetection/projects/EfficientDet/efficientdet/tensorflow/api_wrappers/__init__.py b/mmdetection/projects/EfficientDet/efficientdet/tensorflow/api_wrappers/__init__.py
new file mode 100644
index 00000000..a27afc46
--- /dev/null
+++ b/mmdetection/projects/EfficientDet/efficientdet/tensorflow/api_wrappers/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from .coco_api import COCO, COCOeval, COCOPanoptic
+
+__all__ = ['COCO', 'COCOeval', 'COCOPanoptic']
diff --git a/mmdetection/projects/EfficientDet/efficientdet/tensorflow/api_wrappers/coco_api.py b/mmdetection/projects/EfficientDet/efficientdet/tensorflow/api_wrappers/coco_api.py
new file mode 100644
index 00000000..142f27d7
--- /dev/null
+++ b/mmdetection/projects/EfficientDet/efficientdet/tensorflow/api_wrappers/coco_api.py
@@ -0,0 +1,145 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+# This file add snake case alias for coco api
+
+import warnings
+from collections import defaultdict
+from typing import List, Optional, Union
+
+import pycocotools
+from pycocotools.coco import COCO as _COCO
+from pycocotools.cocoeval import COCOeval as _COCOeval
+
+
+class COCO(_COCO):
+    """This class is almost the same as official pycocotools package.
+
+    It implements some snake case function aliases. So that the COCO class has
+    the same interface as LVIS class.
+    """
+
+    def __init__(self, annotation_file=None):
+        if getattr(pycocotools, '__version__', '0') >= '12.0.2':
+            warnings.warn(
+                'mmpycocotools is deprecated. Please install official pycocotools by "pip install pycocotools"',  # noqa: E501
+                UserWarning)
+        super().__init__(annotation_file=annotation_file)
+        self.img_ann_map = self.imgToAnns
+        self.cat_img_map = self.catToImgs
+
+    def get_ann_ids(self, img_ids=[], cat_ids=[], area_rng=[], iscrowd=None):
+        return self.getAnnIds(img_ids, cat_ids, area_rng, iscrowd)
+
+    def get_cat_ids(self, cat_names=[], sup_names=[], cat_ids=[]):
+        cat_ids_coco = self.getCatIds(cat_names, sup_names, cat_ids)
+        if None in cat_names:
+            index = [i for i, v in enumerate(cat_names) if v is not None]
+            cat_ids = list(range(len(cat_names)))
+            for i in range(len(index)):
+                cat_ids[index[i]] = cat_ids_coco[i]
+            return cat_ids
+        else:
+            return cat_ids_coco
+
+    def get_img_ids(self, img_ids=[], cat_ids=[]):
+        return self.getImgIds(img_ids, cat_ids)
+
+    def load_anns(self, ids):
+        return self.loadAnns(ids)
+
+    def load_cats(self, ids):
+        return self.loadCats(ids)
+
+    def load_imgs(self, ids):
+        return self.loadImgs(ids)
+
+
+# just for the ease of import
+COCOeval = _COCOeval
+
+
+class COCOPanoptic(COCO):
+    """This wrapper is for loading the panoptic style annotation file.
+
+    The format is shown in the CocoPanopticDataset class.
+
+    Args:
+        annotation_file (str, optional): Path of annotation file.
+            Defaults to None.
+    """
+
+    def __init__(self, annotation_file: Optional[str] = None) -> None:
+        super(COCOPanoptic, self).__init__(annotation_file)
+
+    def createIndex(self) -> None:
+        """Create index."""
+        # create index
+        print('creating index...')
+        # anns stores 'segment_id -> annotation'
+        anns, cats, imgs = {}, {}, {}
+        img_to_anns, cat_to_imgs = defaultdict(list), defaultdict(list)
+        if 'annotations' in self.dataset:
+            for ann in self.dataset['annotations']:
+                for seg_ann in ann['segments_info']:
+                    # to match with instance.json
+                    seg_ann['image_id'] = ann['image_id']
+                    img_to_anns[ann['image_id']].append(seg_ann)
+                    # segment_id is not unique in coco dataset orz...
+                    # annotations from different images but
+                    # may have same segment_id
+                    if seg_ann['id'] in anns.keys():
+                        anns[seg_ann['id']].append(seg_ann)
+                    else:
+                        anns[seg_ann['id']] = [seg_ann]
+
+            # filter out annotations from other images
+            img_to_anns_ = defaultdict(list)
+            for k, v in img_to_anns.items():
+                img_to_anns_[k] = [x for x in v if x['image_id'] == k]
+            img_to_anns = img_to_anns_
+
+        if 'images' in self.dataset:
+            for img_info in self.dataset['images']:
+                img_info['segm_file'] = img_info['file_name'].replace(
+                    'jpg', 'png')
+                imgs[img_info['id']] = img_info
+
+        if 'categories' in self.dataset:
+            for cat in self.dataset['categories']:
+                cats[cat['id']] = cat
+
+        if 'annotations' in self.dataset and 'categories' in self.dataset:
+            for ann in self.dataset['annotations']:
+                for seg_ann in ann['segments_info']:
+                    cat_to_imgs[seg_ann['category_id']].append(ann['image_id'])
+
+        print('index created!')
+
+        self.anns = anns
+        self.imgToAnns = img_to_anns
+        self.catToImgs = cat_to_imgs
+        self.imgs = imgs
+        self.cats = cats
+
+    def load_anns(self,
+                  ids: Union[List[int], int] = []) -> Optional[List[dict]]:
+        """Load anns with the specified ids.
+
+        ``self.anns`` is a list of annotation lists instead of a
+        list of annotations.
+
+        Args:
+            ids (Union[List[int], int]): Integer ids specifying anns.
+
+        Returns:
+            anns (List[dict], optional): Loaded ann objects.
+        """
+        anns = []
+
+        if hasattr(ids, '__iter__') and hasattr(ids, '__len__'):
+            # self.anns is a list of annotation lists instead of
+            # a list of annotations
+            for id in ids:
+                anns += self.anns[id]
+            return anns
+        elif type(ids) == int:
+            return self.anns[ids]
diff --git a/mmdetection/projects/EfficientDet/efficientdet/tensorflow/coco_90class.py b/mmdetection/projects/EfficientDet/efficientdet/tensorflow/coco_90class.py
new file mode 100644
index 00000000..d2996ccb
--- /dev/null
+++ b/mmdetection/projects/EfficientDet/efficientdet/tensorflow/coco_90class.py
@@ -0,0 +1,198 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import copy
+import os.path as osp
+from typing import List, Union
+
+from mmengine.fileio import get_local_path
+
+from mmdet.datasets.base_det_dataset import BaseDetDataset
+from mmdet.registry import DATASETS
+from .api_wrappers import COCO
+
+
+@DATASETS.register_module()
+class Coco90Dataset(BaseDetDataset):
+    """Dataset for COCO."""
+
+    METAINFO = {
+        'classes':
+        ('person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train',
+         'truck', 'boat', 'traffic light', 'fire hydrant', None, 'stop sign',
+         'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep',
+         'cow', 'elephant', 'bear', 'zebra', 'giraffe', None, 'backpack',
+         'umbrella', None, None, 'handbag', 'tie', 'suitcase', 'frisbee',
+         'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat',
+         'baseball glove', 'skateboard', 'surfboard', 'tennis racket',
+         'bottle', None, 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl',
+         'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot',
+         'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch', 'potted plant',
+         'bed', None, 'dining table', None, None, 'toilet', None, 'tv',
+         'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',
+         'oven', 'toaster', 'sink', 'refrigerator', None, 'book', 'clock',
+         'vase', 'scissors', 'teddy bear', 'hair drier', 'toothbrush'),
+        # palette is a list of color tuples, which is used for visualization.
+        'palette':
+        [(220, 20, 60), (119, 11, 32), (0, 0, 142), (0, 0, 230), (106, 0, 228),
+         (0, 60, 100), (0, 80, 100), (0, 0, 70), (0, 0, 192), (250, 170, 30),
+         (100, 170, 30), None, (220, 220, 0), (175, 116, 175), (250, 0, 30),
+         (165, 42, 42), (255, 77, 255), (0, 226, 252), (182, 182, 255),
+         (0, 82, 0), (120, 166, 157), (110, 76, 0), (174, 57, 255),
+         (199, 100, 0), (72, 0, 118), None,
+         (255, 179, 240), (0, 125, 92), None, None, (209, 0, 151),
+         (188, 208, 182), (0, 220, 176), (255, 99, 164), (92, 0, 73),
+         (133, 129, 255), (78, 180, 255), (0, 228, 0), (174, 255, 243),
+         (45, 89, 255), (134, 134, 103), (145, 148, 174), (255, 208, 186),
+         (197, 226, 255), None, (171, 134, 1), (109, 63, 54), (207, 138, 255),
+         (151, 0, 95), (9, 80, 61), (84, 105, 51), (74, 65, 105),
+         (166, 196, 102), (208, 195, 210), (255, 109, 65), (0, 143, 149),
+         (179, 0, 194), (209, 99, 106), (5, 121, 0), (227, 255, 205),
+         (147, 186, 208), (153, 69, 1), (3, 95, 161), (163, 255, 0),
+         (119, 0, 170), None, (0, 182, 199), None, None, (0, 165, 120), None,
+         (183, 130, 88), (95, 32, 0), (130, 114, 135), (110, 129, 133),
+         (166, 74, 118), (219, 142, 185), (79, 210, 114), (178, 90, 62),
+         (65, 70, 15), (127, 167, 115), (59, 105, 106), None, (142, 108, 45),
+         (196, 172, 0), (95, 54, 80), (128, 76, 255), (201, 57, 1),
+         (246, 0, 122), (191, 162, 208)]
+    }
+    COCOAPI = COCO
+    # ann_id is unique in coco dataset.
+    ANN_ID_UNIQUE = True
+
+    def load_data_list(self) -> List[dict]:
+        """Load annotations from an annotation file named as ``self.ann_file``
+
+        Returns:
+            List[dict]: A list of annotation.
+        """  # noqa: E501
+        with get_local_path(
+                self.ann_file, backend_args=self.backend_args) as local_path:
+            self.coco = self.COCOAPI(local_path)
+        # The order of returned `cat_ids` will not
+        # change with the order of the `classes`
+        self.cat_ids = self.coco.get_cat_ids(
+            cat_names=self.metainfo['classes'])
+        self.cat2label = {cat_id: i for i, cat_id in enumerate(self.cat_ids)}
+        self.cat_img_map = copy.deepcopy(self.coco.cat_img_map)
+
+        img_ids = self.coco.get_img_ids()
+        data_list = []
+        total_ann_ids = []
+        for img_id in img_ids:
+            raw_img_info = self.coco.load_imgs([img_id])[0]
+            raw_img_info['img_id'] = img_id
+
+            ann_ids = self.coco.get_ann_ids(img_ids=[img_id])
+            raw_ann_info = self.coco.load_anns(ann_ids)
+            total_ann_ids.extend(ann_ids)
+
+            parsed_data_info = self.parse_data_info({
+                'raw_ann_info':
+                raw_ann_info,
+                'raw_img_info':
+                raw_img_info
+            })
+            data_list.append(parsed_data_info)
+        if self.ANN_ID_UNIQUE:
+            assert len(set(total_ann_ids)) == len(
+                total_ann_ids
+            ), f"Annotation ids in '{self.ann_file}' are not unique!"
+
+        del self.coco
+
+        return data_list
+
+    def parse_data_info(self, raw_data_info: dict) -> Union[dict, List[dict]]:
+        """Parse raw annotation to target format.
+
+        Args:
+            raw_data_info (dict): Raw data information load from ``ann_file``
+
+        Returns:
+            Union[dict, List[dict]]: Parsed annotation.
+        """
+        img_info = raw_data_info['raw_img_info']
+        ann_info = raw_data_info['raw_ann_info']
+
+        data_info = {}
+
+        # TODO: need to change data_prefix['img'] to data_prefix['img_path']
+        img_path = osp.join(self.data_prefix['img'], img_info['file_name'])
+        if self.data_prefix.get('seg', None):
+            seg_map_path = osp.join(
+                self.data_prefix['seg'],
+                img_info['file_name'].rsplit('.', 1)[0] + self.seg_map_suffix)
+        else:
+            seg_map_path = None
+        data_info['img_path'] = img_path
+        data_info['img_id'] = img_info['img_id']
+        data_info['seg_map_path'] = seg_map_path
+        data_info['height'] = img_info['height']
+        data_info['width'] = img_info['width']
+
+        instances = []
+        for i, ann in enumerate(ann_info):
+            instance = {}
+
+            if ann.get('ignore', False):
+                continue
+            x1, y1, w, h = ann['bbox']
+            inter_w = max(0, min(x1 + w, img_info['width']) - max(x1, 0))
+            inter_h = max(0, min(y1 + h, img_info['height']) - max(y1, 0))
+            if inter_w * inter_h == 0:
+                continue
+            if ann['area'] <= 0 or w < 1 or h < 1:
+                continue
+            if ann['category_id'] not in self.cat_ids:
+                continue
+            bbox = [x1, y1, x1 + w, y1 + h]
+
+            if ann.get('iscrowd', False):
+                instance['ignore_flag'] = 1
+            else:
+                instance['ignore_flag'] = 0
+            instance['bbox'] = bbox
+            instance['bbox_label'] = self.cat2label[ann['category_id']]
+
+            if ann.get('segmentation', None):
+                instance['mask'] = ann['segmentation']
+
+            instances.append(instance)
+        data_info['instances'] = instances
+        return data_info
+
+    def filter_data(self) -> List[dict]:
+        """Filter annotations according to filter_cfg.
+
+        Returns:
+            List[dict]: Filtered results.
+        """
+        if self.test_mode:
+            return self.data_list
+
+        if self.filter_cfg is None:
+            return self.data_list
+
+        filter_empty_gt = self.filter_cfg.get('filter_empty_gt', False)
+        min_size = self.filter_cfg.get('min_size', 0)
+
+        # obtain images that contain annotation
+        ids_with_ann = set(data_info['img_id'] for data_info in self.data_list)
+        # obtain images that contain annotations of the required categories
+        ids_in_cat = set()
+        for i, class_id in enumerate(self.cat_ids):
+            ids_in_cat |= set(self.cat_img_map[class_id])
+        # merge the image id sets of the two conditions and use the merged set
+        # to filter out images if self.filter_empty_gt=True
+        ids_in_cat &= ids_with_ann
+
+        valid_data_infos = []
+        for i, data_info in enumerate(self.data_list):
+            img_id = data_info['img_id']
+            width = data_info['width']
+            height = data_info['height']
+            if filter_empty_gt and img_id not in ids_in_cat:
+                continue
+            if min(width, height) >= min_size:
+                valid_data_infos.append(data_info)
+
+        return valid_data_infos
diff --git a/mmdetection/projects/EfficientDet/efficientdet/tensorflow/coco_90metric.py b/mmdetection/projects/EfficientDet/efficientdet/tensorflow/coco_90metric.py
new file mode 100644
index 00000000..eed65224
--- /dev/null
+++ b/mmdetection/projects/EfficientDet/efficientdet/tensorflow/coco_90metric.py
@@ -0,0 +1,540 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import datetime
+import itertools
+import os.path as osp
+import tempfile
+from collections import OrderedDict
+from typing import Dict, List, Optional, Sequence, Union
+
+import numpy as np
+from mmengine.evaluator import BaseMetric
+from mmengine.fileio import dump, get_local_path, load
+from mmengine.logging import MMLogger
+from terminaltables import AsciiTable
+
+from mmdet.evaluation.functional import eval_recalls
+from mmdet.registry import METRICS
+from mmdet.structures.mask import encode_mask_results
+from .api_wrappers import COCO, COCOeval
+
+
+@METRICS.register_module()
+class Coco90Metric(BaseMetric):
+    """COCO evaluation metric.
+
+    Evaluate AR, AP, and mAP for detection tasks including proposal/box
+    detection and instance segmentation. Please refer to
+    https://cocodataset.org/#detection-eval for more details.
+
+    Args:
+        ann_file (str, optional): Path to the coco format annotation file.
+            If not specified, ground truth annotations from the dataset will
+            be converted to coco format. Defaults to None.
+        metric (str | List[str]): Metrics to be evaluated. Valid metrics
+            include 'bbox', 'segm', 'proposal', and 'proposal_fast'.
+            Defaults to 'bbox'.
+        classwise (bool): Whether to evaluate the metric class-wise.
+            Defaults to False.
+        proposal_nums (Sequence[int]): Numbers of proposals to be evaluated.
+            Defaults to (100, 300, 1000).
+        iou_thrs (float | List[float], optional): IoU threshold to compute AP
+            and AR. If not specified, IoUs from 0.5 to 0.95 will be used.
+            Defaults to None.
+        metric_items (List[str], optional): Metric result names to be
+            recorded in the evaluation result. Defaults to None.
+        format_only (bool): Format the output results without perform
+            evaluation. It is useful when you want to format the result
+            to a specific format and submit it to the test server.
+            Defaults to False.
+        outfile_prefix (str, optional): The prefix of json files. It includes
+            the file path and the prefix of filename, e.g., "a/b/prefix".
+            If not specified, a temp file will be created. Defaults to None.
+        backend_args (dict, optional): Arguments to instantiate the
+            corresponding backend. Defaults to None.
+        collect_device (str): Device name used for collecting results from
+            different ranks during distributed training. Must be 'cpu' or
+            'gpu'. Defaults to 'cpu'.
+        prefix (str, optional): The prefix that will be added in the metric
+            names to disambiguate homonymous metrics of different evaluators.
+            If prefix is not provided in the argument, self.default_prefix
+            will be used instead. Defaults to None.
+    """
+    default_prefix: Optional[str] = 'coco'
+
+    def __init__(self,
+                 ann_file: Optional[str] = None,
+                 metric: Union[str, List[str]] = 'bbox',
+                 classwise: bool = False,
+                 proposal_nums: Sequence[int] = (100, 300, 1000),
+                 iou_thrs: Optional[Union[float, Sequence[float]]] = None,
+                 metric_items: Optional[Sequence[str]] = None,
+                 format_only: bool = False,
+                 outfile_prefix: Optional[str] = None,
+                 backend_args: dict = None,
+                 collect_device: str = 'cpu',
+                 prefix: Optional[str] = None) -> None:
+        super().__init__(collect_device=collect_device, prefix=prefix)
+        # coco evaluation metrics
+        self.metrics = metric if isinstance(metric, list) else [metric]
+        allowed_metrics = ['bbox', 'segm', 'proposal', 'proposal_fast']
+        for metric in self.metrics:
+            if metric not in allowed_metrics:
+                raise KeyError(
+                    "metric should be one of 'bbox', 'segm', 'proposal', "
+                    f"'proposal_fast', but got {metric}.")
+
+        # do class wise evaluation, default False
+        self.classwise = classwise
+
+        # proposal_nums used to compute recall or precision.
+        self.proposal_nums = list(proposal_nums)
+
+        # iou_thrs used to compute recall or precision.
+        if iou_thrs is None:
+            iou_thrs = np.linspace(
+                .5, 0.95, int(np.round((0.95 - .5) / .05)) + 1, endpoint=True)
+        self.iou_thrs = iou_thrs
+        self.metric_items = metric_items
+        self.format_only = format_only
+        if self.format_only:
+            assert outfile_prefix is not None, 'outfile_prefix must be not'
+            'None when format_only is True, otherwise the result files will'
+            'be saved to a temp directory which will be cleaned up at the end.'
+
+        self.outfile_prefix = outfile_prefix
+
+        self.backend_args = backend_args
+
+        # if ann_file is not specified,
+        # initialize coco api with the converted dataset
+        if ann_file is not None:
+            with get_local_path(
+                    ann_file, backend_args=self.backend_args) as local_path:
+                self._coco_api = COCO(local_path)
+        else:
+            self._coco_api = None
+
+        # handle dataset lazy init
+        self.cat_ids = None
+        self.img_ids = None
+
+    def fast_eval_recall(self,
+                         results: List[dict],
+                         proposal_nums: Sequence[int],
+                         iou_thrs: Sequence[float],
+                         logger: Optional[MMLogger] = None) -> np.ndarray:
+        """Evaluate proposal recall with COCO's fast_eval_recall.
+
+        Args:
+            results (List[dict]): Results of the dataset.
+            proposal_nums (Sequence[int]): Proposal numbers used for
+                evaluation.
+            iou_thrs (Sequence[float]): IoU thresholds used for evaluation.
+            logger (MMLogger, optional): Logger used for logging the recall
+                summary.
+        Returns:
+            np.ndarray: Averaged recall results.
+        """
+        gt_bboxes = []
+        pred_bboxes = [result['bboxes'] for result in results]
+        for i in range(len(self.img_ids)):
+            ann_ids = self._coco_api.get_ann_ids(img_ids=self.img_ids[i])
+            ann_info = self._coco_api.load_anns(ann_ids)
+            if len(ann_info) == 0:
+                gt_bboxes.append(np.zeros((0, 4)))
+                continue
+            bboxes = []
+            for ann in ann_info:
+                if ann.get('ignore', False) or ann['iscrowd']:
+                    continue
+                x1, y1, w, h = ann['bbox']
+                bboxes.append([x1, y1, x1 + w, y1 + h])
+            bboxes = np.array(bboxes, dtype=np.float32)
+            if bboxes.shape[0] == 0:
+                bboxes = np.zeros((0, 4))
+            gt_bboxes.append(bboxes)
+
+        recalls = eval_recalls(
+            gt_bboxes, pred_bboxes, proposal_nums, iou_thrs, logger=logger)
+        ar = recalls.mean(axis=1)
+        return ar
+
+    def xyxy2xywh(self, bbox: np.ndarray) -> list:
+        """Convert ``xyxy`` style bounding boxes to ``xywh`` style for COCO
+        evaluation.
+
+        Args:
+            bbox (numpy.ndarray): The bounding boxes, shape (4, ), in
+                ``xyxy`` order.
+
+        Returns:
+            list[float]: The converted bounding boxes, in ``xywh`` order.
+        """
+
+        _bbox: List = bbox.tolist()
+        return [
+            _bbox[0],
+            _bbox[1],
+            _bbox[2] - _bbox[0],
+            _bbox[3] - _bbox[1],
+        ]
+
+    def results2json(self, results: Sequence[dict],
+                     outfile_prefix: str) -> dict:
+        """Dump the detection results to a COCO style json file.
+
+        There are 3 types of results: proposals, bbox predictions, mask
+        predictions, and they have different data types. This method will
+        automatically recognize the type, and dump them to json files.
+
+        Args:
+            results (Sequence[dict]): Testing results of the
+                dataset.
+            outfile_prefix (str): The filename prefix of the json files. If the
+                prefix is "somepath/xxx", the json files will be named
+                "somepath/xxx.bbox.json", "somepath/xxx.segm.json",
+                "somepath/xxx.proposal.json".
+
+        Returns:
+            dict: Possible keys are "bbox", "segm", "proposal", and
+            values are corresponding filenames.
+        """
+        bbox_json_results = []
+        segm_json_results = [] if 'masks' in results[0] else None
+        for idx, result in enumerate(results):
+            image_id = result.get('img_id', idx)
+            labels = result['labels']
+            bboxes = result['bboxes']
+            scores = result['scores']
+            # bbox results
+            for i, label in enumerate(labels):
+                data = dict()
+                data['image_id'] = image_id
+                data['bbox'] = self.xyxy2xywh(bboxes[i])
+                data['score'] = float(scores[i])
+                data['category_id'] = self.cat_ids[label]
+                bbox_json_results.append(data)
+
+            if segm_json_results is None:
+                continue
+
+            # segm results
+            masks = result['masks']
+            mask_scores = result.get('mask_scores', scores)
+            for i, label in enumerate(labels):
+                data = dict()
+                data['image_id'] = image_id
+                data['bbox'] = self.xyxy2xywh(bboxes[i])
+                data['score'] = float(mask_scores[i])
+                data['category_id'] = self.cat_ids[label]
+                if isinstance(masks[i]['counts'], bytes):
+                    masks[i]['counts'] = masks[i]['counts'].decode()
+                data['segmentation'] = masks[i]
+                segm_json_results.append(data)
+
+        result_files = dict()
+        result_files['bbox'] = f'{outfile_prefix}.bbox.json'
+        result_files['proposal'] = f'{outfile_prefix}.bbox.json'
+        dump(bbox_json_results, result_files['bbox'])
+
+        if segm_json_results is not None:
+            result_files['segm'] = f'{outfile_prefix}.segm.json'
+            dump(segm_json_results, result_files['segm'])
+
+        return result_files
+
+    def gt_to_coco_json(self, gt_dicts: Sequence[dict],
+                        outfile_prefix: str) -> str:
+        """Convert ground truth to coco format json file.
+
+        Args:
+            gt_dicts (Sequence[dict]): Ground truth of the dataset.
+            outfile_prefix (str): The filename prefix of the json files. If the
+                prefix is "somepath/xxx", the json file will be named
+                "somepath/xxx.gt.json".
+        Returns:
+            str: The filename of the json file.
+        """
+        categories = [
+            dict(id=id, name=name)
+            for id, name in enumerate(self.dataset_meta['classes'])
+        ]
+        image_infos = []
+        annotations = []
+
+        for idx, gt_dict in enumerate(gt_dicts):
+            img_id = gt_dict.get('img_id', idx)
+            image_info = dict(
+                id=img_id,
+                width=gt_dict['width'],
+                height=gt_dict['height'],
+                file_name='')
+            image_infos.append(image_info)
+            for ann in gt_dict['anns']:
+                label = ann['bbox_label']
+                bbox = ann['bbox']
+                coco_bbox = [
+                    bbox[0],
+                    bbox[1],
+                    bbox[2] - bbox[0],
+                    bbox[3] - bbox[1],
+                ]
+
+                annotation = dict(
+                    id=len(annotations) +
+                    1,  # coco api requires id starts with 1
+                    image_id=img_id,
+                    bbox=coco_bbox,
+                    iscrowd=ann.get('ignore_flag', 0),
+                    category_id=int(label),
+                    area=coco_bbox[2] * coco_bbox[3])
+                if ann.get('mask', None):
+                    mask = ann['mask']
+                    # area = mask_util.area(mask)
+                    if isinstance(mask, dict) and isinstance(
+                            mask['counts'], bytes):
+                        mask['counts'] = mask['counts'].decode()
+                    annotation['segmentation'] = mask
+                    # annotation['area'] = float(area)
+                annotations.append(annotation)
+
+        info = dict(
+            date_created=str(datetime.datetime.now()),
+            description='Coco json file converted by mmdet CocoMetric.')
+        coco_json = dict(
+            info=info,
+            images=image_infos,
+            categories=categories,
+            licenses=None,
+        )
+        if len(annotations) > 0:
+            coco_json['annotations'] = annotations
+        converted_json_path = f'{outfile_prefix}.gt.json'
+        dump(coco_json, converted_json_path)
+        return converted_json_path
+
+    # TODO: data_batch is no longer needed, consider adjusting the
+    #  parameter position
+    def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
+        """Process one batch of data samples and predictions. The processed
+        results should be stored in ``self.results``, which will be used to
+        compute the metrics when all batches have been processed.
+
+        Args:
+            data_batch (dict): A batch of data from the dataloader.
+            data_samples (Sequence[dict]): A batch of data samples that
+                contain annotations and predictions.
+        """
+        for data_sample in data_samples:
+            result = dict()
+            pred = data_sample['pred_instances']
+            result['img_id'] = data_sample['img_id']
+            result['bboxes'] = pred['bboxes'].cpu().numpy()
+            result['scores'] = pred['scores'].cpu().numpy()
+            result['labels'] = pred['labels'].cpu().numpy()
+            # encode mask to RLE
+            if 'masks' in pred:
+                result['masks'] = encode_mask_results(
+                    pred['masks'].detach().cpu().numpy())
+            # some detectors use different scores for bbox and mask
+            if 'mask_scores' in pred:
+                result['mask_scores'] = pred['mask_scores'].cpu().numpy()
+
+            # parse gt
+            gt = dict()
+            gt['width'] = data_sample['ori_shape'][1]
+            gt['height'] = data_sample['ori_shape'][0]
+            gt['img_id'] = data_sample['img_id']
+            if self._coco_api is None:
+                # TODO: Need to refactor to support LoadAnnotations
+                assert 'instances' in data_sample, \
+                    'ground truth is required for evaluation when ' \
+                    '`ann_file` is not provided'
+                gt['anns'] = data_sample['instances']
+            # add converted result to the results list
+            self.results.append((gt, result))
+
+    def compute_metrics(self, results: list) -> Dict[str, float]:
+        """Compute the metrics from processed results.
+
+        Args:
+            results (list): The processed results of each batch.
+
+        Returns:
+            Dict[str, float]: The computed metrics. The keys are the names of
+            the metrics, and the values are corresponding results.
+        """
+        logger: MMLogger = MMLogger.get_current_instance()
+
+        # split gt and prediction list
+        gts, preds = zip(*results)
+
+        tmp_dir = None
+        if self.outfile_prefix is None:
+            tmp_dir = tempfile.TemporaryDirectory()
+            outfile_prefix = osp.join(tmp_dir.name, 'results')
+        else:
+            outfile_prefix = self.outfile_prefix
+
+        if self._coco_api is None:
+            # use converted gt json file to initialize coco api
+            logger.info('Converting ground truth to coco format...')
+            coco_json_path = self.gt_to_coco_json(
+                gt_dicts=gts, outfile_prefix=outfile_prefix)
+            self._coco_api = COCO(coco_json_path)
+
+            # handle lazy init
+        if self.cat_ids is None:
+            self.cat_ids = self._coco_api.get_cat_ids(
+                cat_names=self.dataset_meta['classes'])
+        if self.img_ids is None:
+            self.img_ids = self._coco_api.get_img_ids()
+
+        # convert predictions to coco format and dump to json file
+        result_files = self.results2json(preds, outfile_prefix)
+
+        eval_results = OrderedDict()
+        if self.format_only:
+            logger.info('results are saved in '
+                        f'{osp.dirname(outfile_prefix)}')
+            return eval_results
+
+        for metric in self.metrics:
+            logger.info(f'Evaluating {metric}...')
+
+            # TODO: May refactor fast_eval_recall to an independent metric?
+            # fast eval recall
+            if metric == 'proposal_fast':
+                ar = self.fast_eval_recall(
+                    preds, self.proposal_nums, self.iou_thrs, logger=logger)
+                log_msg = []
+                for i, num in enumerate(self.proposal_nums):
+                    eval_results[f'AR@{num}'] = ar[i]
+                    log_msg.append(f'\nAR@{num}\t{ar[i]:.4f}')
+                log_msg = ''.join(log_msg)
+                logger.info(log_msg)
+                continue
+
+            # evaluate proposal, bbox and segm
+            iou_type = 'bbox' if metric == 'proposal' else metric
+            if metric not in result_files:
+                raise KeyError(f'{metric} is not in results')
+            try:
+                predictions = load(result_files[metric])
+                if iou_type == 'segm':
+                    # Refer to https://github.com/cocodataset/cocoapi/blob/master/PythonAPI/pycocotools/coco.py#L331  # noqa
+                    # When evaluating mask AP, if the results contain bbox,
+                    # cocoapi will use the box area instead of the mask area
+                    # for calculating the instance area. Though the overall AP
+                    # is not affected, this leads to different
+                    # small/medium/large mask AP results.
+                    for x in predictions:
+                        x.pop('bbox')
+                coco_dt = self._coco_api.loadRes(predictions)
+
+            except IndexError:
+                logger.error(
+                    'The testing results of the whole dataset is empty.')
+                break
+
+            coco_eval = COCOeval(self._coco_api, coco_dt, iou_type)
+
+            coco_eval.params.catIds = self.cat_ids
+            coco_eval.params.imgIds = self.img_ids
+            coco_eval.params.maxDets = list(self.proposal_nums)
+            coco_eval.params.iouThrs = self.iou_thrs
+
+            # mapping of cocoEval.stats
+            coco_metric_names = {
+                'mAP': 0,
+                'mAP_50': 1,
+                'mAP_75': 2,
+                'mAP_s': 3,
+                'mAP_m': 4,
+                'mAP_l': 5,
+                'AR@100': 6,
+                'AR@300': 7,
+                'AR@1000': 8,
+                'AR_s@1000': 9,
+                'AR_m@1000': 10,
+                'AR_l@1000': 11
+            }
+            metric_items = self.metric_items
+            if metric_items is not None:
+                for metric_item in metric_items:
+                    if metric_item not in coco_metric_names:
+                        raise KeyError(
+                            f'metric item "{metric_item}" is not supported')
+
+            if metric == 'proposal':
+                coco_eval.params.useCats = 0
+                coco_eval.evaluate()
+                coco_eval.accumulate()
+                coco_eval.summarize()
+                if metric_items is None:
+                    metric_items = [
+                        'AR@100', 'AR@300', 'AR@1000', 'AR_s@1000',
+                        'AR_m@1000', 'AR_l@1000'
+                    ]
+
+                for item in metric_items:
+                    val = float(
+                        f'{coco_eval.stats[coco_metric_names[item]]:.3f}')
+                    eval_results[item] = val
+            else:
+                coco_eval.evaluate()
+                coco_eval.accumulate()
+                coco_eval.summarize()
+                if self.classwise:  # Compute per-category AP
+                    # Compute per-category AP
+                    # from https://github.com/facebookresearch/detectron2/
+                    precisions = coco_eval.eval['precision']
+                    # precision: (iou, recall, cls, area range, max dets)
+                    assert len(self.cat_ids) == precisions.shape[2]
+
+                    results_per_category = []
+                    for idx, cat_id in enumerate(self.cat_ids):
+                        # area range index 0: all area ranges
+                        # max dets index -1: typically 100 per image
+                        nm = self._coco_api.loadCats(cat_id)[0]
+                        precision = precisions[:, :, idx, 0, -1]
+                        precision = precision[precision > -1]
+                        if precision.size:
+                            ap = np.mean(precision)
+                        else:
+                            ap = float('nan')
+                        results_per_category.append(
+                            (f'{nm["name"]}', f'{round(ap, 3)}'))
+                        eval_results[f'{nm["name"]}_precision'] = round(ap, 3)
+
+                    num_columns = min(6, len(results_per_category) * 2)
+                    results_flatten = list(
+                        itertools.chain(*results_per_category))
+                    headers = ['category', 'AP'] * (num_columns // 2)
+                    results_2d = itertools.zip_longest(*[
+                        results_flatten[i::num_columns]
+                        for i in range(num_columns)
+                    ])
+                    table_data = [headers]
+                    table_data += [result for result in results_2d]
+                    table = AsciiTable(table_data)
+                    logger.info('\n' + table.table)
+
+                if metric_items is None:
+                    metric_items = [
+                        'mAP', 'mAP_50', 'mAP_75', 'mAP_s', 'mAP_m', 'mAP_l'
+                    ]
+
+                for metric_item in metric_items:
+                    key = f'{metric}_{metric_item}'
+                    val = coco_eval.stats[coco_metric_names[metric_item]]
+                    eval_results[key] = float(f'{round(val, 3)}')
+
+                ap = coco_eval.stats[:6]
+                logger.info(f'{metric}_mAP_copypaste: {ap[0]:.3f} '
+                            f'{ap[1]:.3f} {ap[2]:.3f} {ap[3]:.3f} '
+                            f'{ap[4]:.3f} {ap[5]:.3f}')
+
+        if tmp_dir is not None:
+            tmp_dir.cleanup()
+        return eval_results
diff --git a/mmdetection/projects/EfficientDet/efficientdet/tensorflow/trans_max_iou_assigner.py b/mmdetection/projects/EfficientDet/efficientdet/tensorflow/trans_max_iou_assigner.py
new file mode 100644
index 00000000..10fc45b5
--- /dev/null
+++ b/mmdetection/projects/EfficientDet/efficientdet/tensorflow/trans_max_iou_assigner.py
@@ -0,0 +1,110 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Optional
+
+import torch
+from mmengine.structures import InstanceData
+
+from mmdet.models.task_modules.assigners.assign_result import AssignResult
+from mmdet.models.task_modules.assigners.max_iou_assigner import MaxIoUAssigner
+from mmdet.registry import TASK_UTILS
+
+
+@TASK_UTILS.register_module()
+class TransMaxIoUAssigner(MaxIoUAssigner):
+
+    def assign(self,
+               pred_instances: InstanceData,
+               gt_instances: InstanceData,
+               gt_instances_ignore: Optional[InstanceData] = None,
+               **kwargs) -> AssignResult:
+        """Assign gt to bboxes.
+
+        This method assign a gt bbox to every bbox (proposal/anchor), each bbox
+        will be assigned with -1, or a semi-positive number. -1 means negative
+        sample, semi-positive number is the index (0-based) of assigned gt.
+        The assignment is done in following steps, the order matters.
+
+        1. assign every bbox to the background
+        2. assign proposals whose iou with all gts < neg_iou_thr to 0
+        3. for each bbox, if the iou with its nearest gt >= pos_iou_thr,
+           assign it to that bbox
+        4. for each gt bbox, assign its nearest proposals (may be more than
+           one) to itself
+
+        Args:
+            pred_instances (:obj:`InstanceData`): Instances of model
+                predictions. It includes ``priors``, and the priors can
+                be anchors or points, or the bboxes predicted by the
+                previous stage, has shape (n, 4). The bboxes predicted by
+                the current model or stage will be named ``bboxes``,
+                ``labels``, and ``scores``, the same as the ``InstanceData``
+                in other places.
+            gt_instances (:obj:`InstanceData`): Ground truth of instance
+                annotations. It usually includes ``bboxes``, with shape (k, 4),
+                and ``labels``, with shape (k, ).
+            gt_instances_ignore (:obj:`InstanceData`, optional): Instances
+                to be ignored during training. It includes ``bboxes``
+                attribute data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            :obj:`AssignResult`: The assign result.
+
+        Example:
+            >>> from mmengine.structures import InstanceData
+            >>> self = MaxIoUAssigner(0.5, 0.5)
+            >>> pred_instances = InstanceData()
+            >>> pred_instances.priors = torch.Tensor([[0, 0, 10, 10],
+            ...                                      [10, 10, 20, 20]])
+            >>> gt_instances = InstanceData()
+            >>> gt_instances.bboxes = torch.Tensor([[0, 0, 10, 9]])
+            >>> gt_instances.labels = torch.Tensor([0])
+            >>> assign_result = self.assign(pred_instances, gt_instances)
+            >>> expected_gt_inds = torch.LongTensor([1, 0])
+            >>> assert torch.all(assign_result.gt_inds == expected_gt_inds)
+        """
+        gt_bboxes = gt_instances.bboxes
+        priors = pred_instances.priors
+        gt_labels = gt_instances.labels
+        if gt_instances_ignore is not None:
+            gt_bboxes_ignore = gt_instances_ignore.bboxes
+        else:
+            gt_bboxes_ignore = None
+
+        assign_on_cpu = True if (self.gpu_assign_thr > 0) and (
+            gt_bboxes.shape[0] > self.gpu_assign_thr) else False
+        # compute overlap and assign gt on CPU when number of GT is large
+        if assign_on_cpu:
+            device = priors.device
+            priors = priors.cpu()
+            gt_bboxes = gt_bboxes.cpu()
+            gt_labels = gt_labels.cpu()
+            if gt_bboxes_ignore is not None:
+                gt_bboxes_ignore = gt_bboxes_ignore.cpu()
+
+        trans_priors = torch.cat([
+            priors[..., 1].view(-1, 1), priors[..., 0].view(-1, 1),
+            priors[..., 3].view(-1, 1), priors[..., 2].view(-1, 1)
+        ],
+                                 dim=-1)
+        overlaps = self.iou_calculator(gt_bboxes, trans_priors)
+
+        if (self.ignore_iof_thr > 0 and gt_bboxes_ignore is not None
+                and gt_bboxes_ignore.numel() > 0 and trans_priors.numel() > 0):
+            if self.ignore_wrt_candidates:
+                ignore_overlaps = self.iou_calculator(
+                    trans_priors, gt_bboxes_ignore, mode='iof')
+                ignore_max_overlaps, _ = ignore_overlaps.max(dim=1)
+            else:
+                ignore_overlaps = self.iou_calculator(
+                    gt_bboxes_ignore, trans_priors, mode='iof')
+                ignore_max_overlaps, _ = ignore_overlaps.max(dim=0)
+            overlaps[:, ignore_max_overlaps > self.ignore_iof_thr] = -1
+
+        assign_result = self.assign_wrt_overlaps(overlaps, gt_labels)
+        if assign_on_cpu:
+            assign_result.gt_inds = assign_result.gt_inds.to(device)
+            assign_result.max_overlaps = assign_result.max_overlaps.to(device)
+            if assign_result.labels is not None:
+                assign_result.labels = assign_result.labels.to(device)
+        return assign_result
diff --git a/mmdetection/projects/EfficientDet/efficientdet/tensorflow/yxyx_bbox_coder.py b/mmdetection/projects/EfficientDet/efficientdet/tensorflow/yxyx_bbox_coder.py
new file mode 100644
index 00000000..63e23300
--- /dev/null
+++ b/mmdetection/projects/EfficientDet/efficientdet/tensorflow/yxyx_bbox_coder.py
@@ -0,0 +1,369 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import warnings
+
+import numpy as np
+import torch
+
+from mmdet.models.task_modules.coders.delta_xywh_bbox_coder import \
+    DeltaXYWHBBoxCoder
+from mmdet.registry import TASK_UTILS
+from mmdet.structures.bbox import HorizontalBoxes, get_box_tensor
+
+
+@TASK_UTILS.register_module()
+class YXYXDeltaXYWHBBoxCoder(DeltaXYWHBBoxCoder):
+
+    def encode(self, bboxes, gt_bboxes):
+        """Get box regression transformation deltas that can be used to
+        transform the ``bboxes`` into the ``gt_bboxes``.
+
+        Args:
+            bboxes (torch.Tensor or :obj:`BaseBoxes`): Source boxes,
+                e.g., object proposals.
+            gt_bboxes (torch.Tensor or :obj:`BaseBoxes`): Target of the
+                transformation, e.g., ground-truth boxes.
+
+        Returns:
+            torch.Tensor: Box transformation deltas
+        """
+        bboxes = get_box_tensor(bboxes)
+        gt_bboxes = get_box_tensor(gt_bboxes)
+        assert bboxes.size(0) == gt_bboxes.size(0)
+        assert bboxes.size(-1) == gt_bboxes.size(-1) == 4
+        encoded_bboxes = YXbbox2delta(bboxes, gt_bboxes, self.means, self.stds)
+        return encoded_bboxes
+
+    def decode(self,
+               bboxes,
+               pred_bboxes,
+               max_shape=None,
+               wh_ratio_clip=16 / 1000):
+        """Apply transformation `pred_bboxes` to `boxes`.
+
+        Args:
+            bboxes (torch.Tensor or :obj:`BaseBoxes`): Basic boxes. Shape
+                (B, N, 4) or (N, 4)
+            pred_bboxes (Tensor): Encoded offsets with respect to each roi.
+               Has shape (B, N, num_classes * 4) or (B, N, 4) or
+               (N, num_classes * 4) or (N, 4). Note N = num_anchors * W * H
+               when rois is a grid of anchors.Offset encoding follows [1]_.
+            max_shape (Sequence[int] or torch.Tensor or Sequence[
+               Sequence[int]],optional): Maximum bounds for boxes, specifies
+               (H, W, C) or (H, W). If bboxes shape is (B, N, 4), then
+               the max_shape should be a Sequence[Sequence[int]]
+               and the length of max_shape should also be B.
+            wh_ratio_clip (float, optional): The allowed ratio between
+                width and height.
+
+        Returns:
+            Union[torch.Tensor, :obj:`BaseBoxes`]: Decoded boxes.
+        """
+        bboxes = get_box_tensor(bboxes)
+        assert pred_bboxes.size(0) == bboxes.size(0)
+        if pred_bboxes.ndim == 3:
+            assert pred_bboxes.size(1) == bboxes.size(1)
+
+        if pred_bboxes.ndim == 2 and not torch.onnx.is_in_onnx_export():
+            # single image decode
+            decoded_bboxes = YXdelta2bbox(bboxes, pred_bboxes, self.means,
+                                          self.stds, max_shape, wh_ratio_clip,
+                                          self.clip_border, self.add_ctr_clamp,
+                                          self.ctr_clamp)
+        else:
+            if pred_bboxes.ndim == 3 and not torch.onnx.is_in_onnx_export():
+                warnings.warn(
+                    'DeprecationWarning: onnx_delta2bbox is deprecated '
+                    'in the case of batch decoding and non-ONNX, '
+                    'please use “delta2bbox” instead. In order to improve '
+                    'the decoding speed, the batch function will no '
+                    'longer be supported. ')
+            decoded_bboxes = YXonnx_delta2bbox(bboxes, pred_bboxes, self.means,
+                                               self.stds, max_shape,
+                                               wh_ratio_clip, self.clip_border,
+                                               self.add_ctr_clamp,
+                                               self.ctr_clamp)
+
+        if self.use_box_type:
+            assert decoded_bboxes.size(-1) == 4, \
+                ('Cannot warp decoded boxes with box type when decoded boxes'
+                 'have shape of (N, num_classes * 4)')
+            decoded_bboxes = HorizontalBoxes(decoded_bboxes)
+        return decoded_bboxes
+
+
+def YXdelta2bbox(rois,
+                 deltas,
+                 means=(0., 0., 0., 0.),
+                 stds=(1., 1., 1., 1.),
+                 max_shape=None,
+                 hw_ratio_clip=1000 / 16,
+                 clip_border=True,
+                 add_ctr_clamp=False,
+                 ctr_clamp=32):
+    """Apply deltas to shift/scale base boxes.
+
+    Typically the rois are anchor or proposed bounding boxes and the deltas are
+    network outputs used to shift/scale those boxes.
+    This is the inverse function of :func:`bbox2delta`.
+
+    Args:
+        rois (Tensor): Boxes to be transformed. Has shape (N, 4).
+        deltas (Tensor): Encoded offsets relative to each roi.
+            Has shape (N, num_classes * 4) or (N, 4). Note
+            N = num_base_anchors * W * H, when rois is a grid of
+            anchors. Offset encoding follows [1]_.
+        means (Sequence[float]): Denormalizing means for delta coordinates.
+            Default (0., 0., 0., 0.).
+        stds (Sequence[float]): Denormalizing standard deviation for delta
+            coordinates. Default (1., 1., 1., 1.).
+        max_shape (tuple[int, int]): Maximum bounds for boxes, specifies
+           (H, W). Default None.
+        wh_ratio_clip (float): Maximum aspect ratio for boxes. Default
+            16 / 1000.
+        clip_border (bool, optional): Whether clip the objects outside the
+            border of the image. Default True.
+        add_ctr_clamp (bool): Whether to add center clamp. When set to True,
+            the center of the prediction bounding box will be clamped to
+            avoid being too far away from the center of the anchor.
+            Only used by YOLOF. Default False.
+        ctr_clamp (int): the maximum pixel shift to clamp. Only used by YOLOF.
+            Default 32.
+
+    Returns:
+        Tensor: Boxes with shape (N, num_classes * 4) or (N, 4), where 4
+           represent tl_x, tl_y, br_x, br_y.
+
+    References:
+        .. [1] https://arxiv.org/abs/1311.2524
+
+    Example:
+        >>> rois = torch.Tensor([[ 0.,  0.,  1.,  1.],
+        >>>                      [ 0.,  0.,  1.,  1.],
+        >>>                      [ 0.,  0.,  1.,  1.],
+        >>>                      [ 5.,  5.,  5.,  5.]])
+        >>> deltas = torch.Tensor([[  0.,   0.,   0.,   0.],
+        >>>                        [  1.,   1.,   1.,   1.],
+        >>>                        [  0.,   0.,   2.,  -1.],
+        >>>                        [ 0.7, -1.9, -0.5,  0.3]])
+        >>> delta2bbox(rois, deltas, max_shape=(32, 32, 3))
+        tensor([[0.0000, 0.0000, 1.0000, 1.0000],
+                [0.1409, 0.1409, 2.8591, 2.8591],
+                [0.0000, 0.3161, 4.1945, 0.6839],
+                [5.0000, 5.0000, 5.0000, 5.0000]])
+    """
+    num_bboxes, num_classes = deltas.size(0), deltas.size(1) // 4
+    if num_bboxes == 0:
+        return deltas
+
+    deltas = deltas.reshape(-1, 4)
+
+    means = deltas.new_tensor(means).view(1, -1)
+    stds = deltas.new_tensor(stds).view(1, -1)
+    denorm_deltas = deltas * stds + means
+
+    dyx = denorm_deltas[:, :2]
+    dhw = denorm_deltas[:, 2:]
+
+    # Compute width/height of each roi
+    rois_ = rois.repeat(1, num_classes).reshape(-1, 4)
+    pyx = ((rois_[:, :2] + rois_[:, 2:]) * 0.5)
+    phw = (rois_[:, 2:] - rois_[:, :2])
+
+    dyx_hw = phw * dyx
+
+    max_ratio = np.abs(np.log(hw_ratio_clip))
+    if add_ctr_clamp:
+        dyx_hw = torch.clamp(dyx_hw, max=ctr_clamp, min=-ctr_clamp)
+        dhw = torch.clamp(dhw, max=max_ratio)
+    else:
+        dhw = dhw.clamp(min=-max_ratio, max=max_ratio)
+
+    gyx = pyx + dyx_hw
+    ghw = phw * dhw.exp()
+    y1x1 = gyx - (ghw * 0.5)
+    y2x2 = gyx + (ghw * 0.5)
+    ymin, xmin = y1x1[:, 0].reshape(-1, 1), y1x1[:, 1].reshape(-1, 1)
+    ymax, xmax = y2x2[:, 0].reshape(-1, 1), y2x2[:, 1].reshape(-1, 1)
+    bboxes = torch.cat([xmin, ymin, xmax, ymax], dim=-1)
+    if clip_border and max_shape is not None:
+        bboxes[..., 0::2].clamp_(min=0, max=max_shape[1])
+        bboxes[..., 1::2].clamp_(min=0, max=max_shape[0])
+    bboxes = bboxes.reshape(num_bboxes, -1)
+    return bboxes
+
+
+def YXbbox2delta(proposals, gt, means=(0., 0., 0., 0.), stds=(1., 1., 1., 1.)):
+    """Compute deltas of proposals w.r.t. gt.
+
+    We usually compute the deltas of x, y, w, h of proposals w.r.t ground
+    truth bboxes to get regression target.
+    This is the inverse function of :func:`delta2bbox`.
+
+    Args:
+        proposals (Tensor): Boxes to be transformed, shape (N, ..., 4)
+        gt (Tensor): Gt bboxes to be used as base, shape (N, ..., 4)
+        means (Sequence[float]): Denormalizing means for delta coordinates
+        stds (Sequence[float]): Denormalizing standard deviation for delta
+            coordinates
+
+    Returns:
+        Tensor: deltas with shape (N, 4), where columns represent dx, dy,
+            dw, dh.
+    """
+    assert proposals.size() == gt.size()
+
+    proposals = proposals.float()
+    gt = gt.float()
+    py = (proposals[..., 0] + proposals[..., 2]) * 0.5
+    px = (proposals[..., 1] + proposals[..., 3]) * 0.5
+    ph = proposals[..., 2] - proposals[..., 0]
+    pw = proposals[..., 3] - proposals[..., 1]
+
+    gx = (gt[..., 0] + gt[..., 2]) * 0.5
+    gy = (gt[..., 1] + gt[..., 3]) * 0.5
+    gw = gt[..., 2] - gt[..., 0]
+    gh = gt[..., 3] - gt[..., 1]
+
+    dx = (gx - px) / pw
+    dy = (gy - py) / ph
+    dw = torch.log(gw / pw)
+    dh = torch.log(gh / ph)
+    deltas = torch.stack([dy, dx, dh, dw], dim=-1)
+
+    means = deltas.new_tensor(means).unsqueeze(0)
+    stds = deltas.new_tensor(stds).unsqueeze(0)
+    deltas = deltas.sub_(means).div_(stds)
+
+    return deltas
+
+
+def YXonnx_delta2bbox(rois,
+                      deltas,
+                      means=(0., 0., 0., 0.),
+                      stds=(1., 1., 1., 1.),
+                      max_shape=None,
+                      wh_ratio_clip=16 / 1000,
+                      clip_border=True,
+                      add_ctr_clamp=False,
+                      ctr_clamp=32):
+    """Apply deltas to shift/scale base boxes.
+
+    Typically the rois are anchor or proposed bounding boxes and the deltas are
+    network outputs used to shift/scale those boxes.
+    This is the inverse function of :func:`bbox2delta`.
+
+    Args:
+        rois (Tensor): Boxes to be transformed. Has shape (N, 4) or (B, N, 4)
+        deltas (Tensor): Encoded offsets with respect to each roi.
+            Has shape (B, N, num_classes * 4) or (B, N, 4) or
+            (N, num_classes * 4) or (N, 4). Note N = num_anchors * W * H
+            when rois is a grid of anchors.Offset encoding follows [1]_.
+        means (Sequence[float]): Denormalizing means for delta coordinates.
+            Default (0., 0., 0., 0.).
+        stds (Sequence[float]): Denormalizing standard deviation for delta
+            coordinates. Default (1., 1., 1., 1.).
+        max_shape (Sequence[int] or torch.Tensor or Sequence[
+            Sequence[int]],optional): Maximum bounds for boxes, specifies
+            (H, W, C) or (H, W). If rois shape is (B, N, 4), then
+            the max_shape should be a Sequence[Sequence[int]]
+            and the length of max_shape should also be B. Default None.
+        wh_ratio_clip (float): Maximum aspect ratio for boxes.
+            Default 16 / 1000.
+        clip_border (bool, optional): Whether clip the objects outside the
+            border of the image. Default True.
+        add_ctr_clamp (bool): Whether to add center clamp, when added, the
+            predicted box is clamped is its center is too far away from
+            the original anchor's center. Only used by YOLOF. Default False.
+        ctr_clamp (int): the maximum pixel shift to clamp. Only used by YOLOF.
+            Default 32.
+
+    Returns:
+        Tensor: Boxes with shape (B, N, num_classes * 4) or (B, N, 4) or
+           (N, num_classes * 4) or (N, 4), where 4 represent
+           tl_x, tl_y, br_x, br_y.
+
+    References:
+        .. [1] https://arxiv.org/abs/1311.2524
+
+    Example:
+        >>> rois = torch.Tensor([[ 0.,  0.,  1.,  1.],
+        >>>                      [ 0.,  0.,  1.,  1.],
+        >>>                      [ 0.,  0.,  1.,  1.],
+        >>>                      [ 5.,  5.,  5.,  5.]])
+        >>> deltas = torch.Tensor([[  0.,   0.,   0.,   0.],
+        >>>                        [  1.,   1.,   1.,   1.],
+        >>>                        [  0.,   0.,   2.,  -1.],
+        >>>                        [ 0.7, -1.9, -0.5,  0.3]])
+        >>> delta2bbox(rois, deltas, max_shape=(32, 32, 3))
+        tensor([[0.0000, 0.0000, 1.0000, 1.0000],
+                [0.1409, 0.1409, 2.8591, 2.8591],
+                [0.0000, 0.3161, 4.1945, 0.6839],
+                [5.0000, 5.0000, 5.0000, 5.0000]])
+    """
+    means = deltas.new_tensor(means).view(1,
+                                          -1).repeat(1,
+                                                     deltas.size(-1) // 4)
+    stds = deltas.new_tensor(stds).view(1, -1).repeat(1, deltas.size(-1) // 4)
+    denorm_deltas = deltas * stds + means
+    dy = denorm_deltas[..., 0::4]
+    dx = denorm_deltas[..., 1::4]
+    dh = denorm_deltas[..., 2::4]
+    dw = denorm_deltas[..., 3::4]
+
+    y1, x1 = rois[..., 0], rois[..., 1]
+    y2, x2 = rois[..., 2], rois[..., 3]
+    # Compute center of each roi
+    px = ((x1 + x2) * 0.5).unsqueeze(-1).expand_as(dx)
+    py = ((y1 + y2) * 0.5).unsqueeze(-1).expand_as(dy)
+    # Compute width/height of each roi
+    pw = (x2 - x1).unsqueeze(-1).expand_as(dw)
+    ph = (y2 - y1).unsqueeze(-1).expand_as(dh)
+
+    dx_width = pw * dx
+    dy_height = ph * dy
+
+    max_ratio = np.abs(np.log(wh_ratio_clip))
+    if add_ctr_clamp:
+        dx_width = torch.clamp(dx_width, max=ctr_clamp, min=-ctr_clamp)
+        dy_height = torch.clamp(dy_height, max=ctr_clamp, min=-ctr_clamp)
+        dw = torch.clamp(dw, max=max_ratio)
+        dh = torch.clamp(dh, max=max_ratio)
+    else:
+        dw = dw.clamp(min=-max_ratio, max=max_ratio)
+        dh = dh.clamp(min=-max_ratio, max=max_ratio)
+    # Use exp(network energy) to enlarge/shrink each roi
+    gw = pw * dw.exp()
+    gh = ph * dh.exp()
+    # Use network energy to shift the center of each roi
+    gx = px + dx_width
+    gy = py + dy_height
+    # Convert center-xy/width/height to top-left, bottom-right
+    x1 = gx - gw * 0.5
+    y1 = gy - gh * 0.5
+    x2 = gx + gw * 0.5
+    y2 = gy + gh * 0.5
+
+    bboxes = torch.stack([x1, y1, x2, y2], dim=-1).view(deltas.size())
+
+    if clip_border and max_shape is not None:
+        # clip bboxes with dynamic `min` and `max` for onnx
+        if torch.onnx.is_in_onnx_export():
+            from mmdet.core.export import dynamic_clip_for_onnx
+            x1, y1, x2, y2 = dynamic_clip_for_onnx(x1, y1, x2, y2, max_shape)
+            bboxes = torch.stack([x1, y1, x2, y2], dim=-1).view(deltas.size())
+            return bboxes
+        if not isinstance(max_shape, torch.Tensor):
+            max_shape = x1.new_tensor(max_shape)
+        max_shape = max_shape[..., :2].type_as(x1)
+        if max_shape.ndim == 2:
+            assert bboxes.ndim == 3
+            assert max_shape.size(0) == bboxes.size(0)
+
+        min_xy = x1.new_tensor(0)
+        max_xy = torch.cat(
+            [max_shape] * (deltas.size(-1) // 2),
+            dim=-1).flip(-1).unsqueeze(-2)
+        bboxes = torch.where(bboxes < min_xy, min_xy, bboxes)
+        bboxes = torch.where(bboxes > max_xy, max_xy, bboxes)
+
+    return bboxes
diff --git a/mmdetection/projects/EfficientDet/efficientdet/utils.py b/mmdetection/projects/EfficientDet/efficientdet/utils.py
new file mode 100644
index 00000000..9c30a01f
--- /dev/null
+++ b/mmdetection/projects/EfficientDet/efficientdet/utils.py
@@ -0,0 +1,154 @@
+import math
+from typing import Tuple, Union
+
+import torch
+import torch.nn as nn
+from mmcv.cnn.bricks import Swish, build_norm_layer
+from torch.nn import functional as F
+from torch.nn.init import _calculate_fan_in_and_fan_out, trunc_normal_
+
+from mmdet.registry import MODELS
+from mmdet.utils import OptConfigType
+
+
+def variance_scaling_trunc(tensor, gain=1.):
+    fan_in, _ = _calculate_fan_in_and_fan_out(tensor)
+    gain /= max(1.0, fan_in)
+    std = math.sqrt(gain) / .87962566103423978
+    return trunc_normal_(tensor, 0., std)
+
+
+@MODELS.register_module()
+class Conv2dSamePadding(nn.Conv2d):
+
+    def __init__(self,
+                 in_channels: int,
+                 out_channels: int,
+                 kernel_size: Union[int, Tuple[int, int]],
+                 stride: Union[int, Tuple[int, int]] = 1,
+                 padding: Union[int, Tuple[int, int]] = 0,
+                 dilation: Union[int, Tuple[int, int]] = 1,
+                 groups: int = 1,
+                 bias: bool = True):
+        super().__init__(in_channels, out_channels, kernel_size, stride, 0,
+                         dilation, groups, bias)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        img_h, img_w = x.size()[-2:]
+        kernel_h, kernel_w = self.weight.size()[-2:]
+        extra_w = (math.ceil(img_w / self.stride[1]) -
+                   1) * self.stride[1] - img_w + kernel_w
+        extra_h = (math.ceil(img_h / self.stride[0]) -
+                   1) * self.stride[0] - img_h + kernel_h
+
+        left = extra_w // 2
+        right = extra_w - left
+        top = extra_h // 2
+        bottom = extra_h - top
+        x = F.pad(x, [left, right, top, bottom])
+        return F.conv2d(x, self.weight, self.bias, self.stride, self.padding,
+                        self.dilation, self.groups)
+
+
+class MaxPool2dSamePadding(nn.Module):
+
+    def __init__(self,
+                 kernel_size: Union[int, Tuple[int, int]] = 3,
+                 stride: Union[int, Tuple[int, int]] = 2,
+                 **kwargs):
+        super().__init__()
+        self.pool = nn.MaxPool2d(kernel_size, stride, **kwargs)
+        self.stride = self.pool.stride
+        self.kernel_size = self.pool.kernel_size
+
+        if isinstance(self.stride, int):
+            self.stride = [self.stride] * 2
+        if isinstance(self.kernel_size, int):
+            self.kernel_size = [self.kernel_size] * 2
+
+    def forward(self, x):
+        h, w = x.shape[-2:]
+
+        extra_h = (math.ceil(w / self.stride[1]) -
+                   1) * self.stride[1] - w + self.kernel_size[1]
+        extra_v = (math.ceil(h / self.stride[0]) -
+                   1) * self.stride[0] - h + self.kernel_size[0]
+
+        left = extra_h // 2
+        right = extra_h - left
+        top = extra_v // 2
+        bottom = extra_v - top
+
+        x = F.pad(x, [left, right, top, bottom])
+        x = self.pool(x)
+
+        return x
+
+
+class DepthWiseConvBlock(nn.Module):
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        apply_norm: bool = True,
+        conv_bn_act_pattern: bool = False,
+        norm_cfg: OptConfigType = dict(type='BN', momentum=1e-2, eps=1e-3)
+    ) -> None:
+        super(DepthWiseConvBlock, self).__init__()
+        self.depthwise_conv = Conv2dSamePadding(
+            in_channels,
+            in_channels,
+            kernel_size=3,
+            stride=1,
+            groups=in_channels,
+            bias=False)
+        self.pointwise_conv = Conv2dSamePadding(
+            in_channels, out_channels, kernel_size=1, stride=1)
+
+        self.apply_norm = apply_norm
+        if self.apply_norm:
+            self.bn = build_norm_layer(norm_cfg, num_features=out_channels)[1]
+
+        self.apply_activation = conv_bn_act_pattern
+        if self.apply_activation:
+            self.swish = Swish()
+
+    def forward(self, x):
+        x = self.depthwise_conv(x)
+        x = self.pointwise_conv(x)
+        if self.apply_norm:
+            x = self.bn(x)
+        if self.apply_activation:
+            x = self.swish(x)
+
+        return x
+
+
+class DownChannelBlock(nn.Module):
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        apply_norm: bool = True,
+        conv_bn_act_pattern: bool = False,
+        norm_cfg: OptConfigType = dict(type='BN', momentum=1e-2, eps=1e-3)
+    ) -> None:
+        super(DownChannelBlock, self).__init__()
+        self.down_conv = Conv2dSamePadding(in_channels, out_channels, 1)
+        self.apply_norm = apply_norm
+        if self.apply_norm:
+            self.bn = build_norm_layer(norm_cfg, num_features=out_channels)[1]
+        self.apply_activation = conv_bn_act_pattern
+        if self.apply_activation:
+            self.swish = Swish()
+
+    def forward(self, x):
+        x = self.down_conv(x)
+        if self.apply_norm:
+            x = self.bn(x)
+        if self.apply_activation:
+            x = self.swish(x)
+
+        return x
diff --git a/mmdetection/projects/HDINO/README.md b/mmdetection/projects/HDINO/README.md
new file mode 100644
index 00000000..078ca429
--- /dev/null
+++ b/mmdetection/projects/HDINO/README.md
@@ -0,0 +1,35 @@
+# H-DETR
+
+> [DETRs with Hybrid Matching](https://arxiv.org/abs/2207.13080)
+
+
+
+## Abstract
+
+One-to-one set matching is a key design for DETR to establish its end-to-end capability, so that object detection does not require a hand-crafted NMS (non-maximum suppression) to remove duplicate detections. This end-to-end signature is important for the versatility of DETR, and it has been generalized to broader vision tasks. However, we note that there are few queries assigned as positive samples and the one-to-one set matching significantly reduces the training efficacy of positive samples. We propose a simple yet effective method based on a hybrid matching scheme that combines the original one-to-one matching branch with an auxiliary one-to-many matching branch during training. Our hybrid strategy has been shown to significantly improve accuracy. In inference, only the original one-to-one match branch is used, thus maintaining the end-to-end merit and the same inference efficiency of DETR. The method is named H-DETR, and it shows that a wide range of representative DETR methods can be consistently improved across a wide range of visual tasks, including DeformableDETR, PETRv2, PETR, and TransTrack, among others.
+
+
    
+
+
    
+
+## Results and Models
+
+| Backbone |     Model     | Lr schd | box AP |                     Config                     | Download |
+| :------: | :-----------: | :-----: | :----: | :--------------------------------------------: | :------: |
+|   R-50   | H-DINO-4scale |   12e   |  48.0  | [config](./h-dino-4scale_r50_8xb2-12e_coco.py) |          |
+
+### NOTE
+
+1. We are based on `DINO` rather than `Deformable DETR` to support the `Hybrid Matching` algorithm.
+2. We found that directly applying Hybrid Matching to the DINO algorithm results in a significant decrease in performance. If you have any other insights or suggestions, please feel free to comment or submit a pull request (PR).
+
+## Citation
+
+```latex
+@article{jia2022detrs,
+  title={DETRs with Hybrid Matching},
+  author={Jia, Ding and Yuan, Yuhui and He, Haodi and Wu, Xiaopei and Yu, Haojun and Lin, Weihong and Sun, Lei and Zhang, Chao and Hu, Han},
+  journal={arXiv preprint arXiv:2207.13080},
+  year={2022}
+}
+```
diff --git a/mmdetection/projects/HDINO/__init__.py b/mmdetection/projects/HDINO/__init__.py
new file mode 100644
index 00000000..f8c3478b
--- /dev/null
+++ b/mmdetection/projects/HDINO/__init__.py
@@ -0,0 +1,4 @@
+from .h_dino import HDINO
+from .h_dino_head import HybridDINOHead
+
+__all__ = ['HDINO', 'HybridDINOHead']
diff --git a/mmdetection/projects/HDINO/h-dino-4scale_r50_8xb2-12e_coco.py b/mmdetection/projects/HDINO/h-dino-4scale_r50_8xb2-12e_coco.py
new file mode 100644
index 00000000..7b16b48d
--- /dev/null
+++ b/mmdetection/projects/HDINO/h-dino-4scale_r50_8xb2-12e_coco.py
@@ -0,0 +1,168 @@
+_base_ = [
+    '../../configs/_base_/datasets/coco_detection.py',
+    '../../configs/_base_/default_runtime.py'
+]
+
+custom_imports = dict(imports=['projects.HDINO'], allow_failed_imports=False)
+
+model = dict(
+    type='HDINO',
+    num_queries=1800,  # num_total_queries: 900+900
+    with_box_refine=True,
+    as_two_stage=True,
+    data_preprocessor=dict(
+        type='DetDataPreprocessor',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        bgr_to_rgb=True,
+        pad_size_divisor=1),
+    backbone=dict(
+        type='ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type='BN', requires_grad=False),
+        norm_eval=True,
+        style='pytorch',
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),
+    neck=dict(
+        type='ChannelMapper',
+        in_channels=[512, 1024, 2048],
+        kernel_size=1,
+        out_channels=256,
+        act_cfg=None,
+        norm_cfg=dict(type='GN', num_groups=32),
+        num_outs=4),
+    encoder=dict(
+        num_layers=6,
+        layer_cfg=dict(
+            self_attn_cfg=dict(embed_dims=256, num_levels=4,
+                               dropout=0.0),  # 0.1 for DeformDETR
+            ffn_cfg=dict(
+                embed_dims=256,
+                feedforward_channels=2048,  # 1024 for DeformDETR
+                ffn_drop=0.0))),  # 0.1 for DeformDETR
+    decoder=dict(
+        num_layers=6,
+        return_intermediate=True,
+        layer_cfg=dict(
+            self_attn_cfg=dict(embed_dims=256, num_heads=8,
+                               dropout=0.0),  # 0.1 for DeformDETR
+            cross_attn_cfg=dict(embed_dims=256, num_levels=4,
+                                dropout=0.0),  # 0.1 for DeformDETR
+            ffn_cfg=dict(
+                embed_dims=256,
+                feedforward_channels=2048,  # 1024 for DeformDETR
+                ffn_drop=0.0)),  # 0.1 for DeformDETR
+        post_norm_cfg=None),
+    positional_encoding=dict(
+        num_feats=128,
+        normalize=True,
+        offset=0.0,  # -0.5 for DeformDETR
+        temperature=20),  # 10000 for DeformDETR
+    bbox_head=dict(
+        type='HybridDINOHead',
+        num_classes=80,
+        sync_cls_avg_factor=True,
+        num_query_one2one=900,
+        k_one2many=2,
+        loss_cls=dict(
+            type='FocalLoss',
+            use_sigmoid=True,
+            gamma=2.0,
+            alpha=0.25,
+            loss_weight=1.0),  # 2.0 in DeformDETR
+        loss_bbox=dict(type='L1Loss', loss_weight=5.0),
+        loss_iou=dict(type='GIoULoss', loss_weight=2.0)),
+    dn_cfg=dict(
+        label_noise_scale=0.5,
+        box_noise_scale=1.0,  # 0.4 for DN-DETR
+        group_cfg=dict(dynamic=True, num_groups=None, num_dn_queries=100)),
+    # training and testing settings
+    train_cfg=dict(
+        assigner=dict(
+            type='HungarianAssigner',
+            match_costs=[
+                dict(type='FocalLossCost', weight=2.0),
+                dict(type='BBoxL1Cost', weight=5.0, box_format='xywh'),
+                dict(type='IoUCost', iou_mode='giou', weight=2.0)
+            ])),
+    test_cfg=dict(max_per_img=300))  # 100 for DeformDETR
+
+# train_pipeline, NOTE the img_scale and the Pad's size_divisor is different
+# from the default setting in mmdet.
+train_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=_base_.backend_args),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(
+        type='RandomChoice',
+        transforms=[
+            [
+                dict(
+                    type='RandomChoiceResize',
+                    scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333),
+                            (608, 1333), (640, 1333), (672, 1333), (704, 1333),
+                            (736, 1333), (768, 1333), (800, 1333)],
+                    keep_ratio=True)
+            ],
+            [
+                dict(
+                    type='RandomChoiceResize',
+                    # The radio of all image in train dataset < 7
+                    # follow the original implement
+                    scales=[(400, 4200), (500, 4200), (600, 4200)],
+                    keep_ratio=True),
+                dict(
+                    type='RandomCrop',
+                    crop_type='absolute_range',
+                    crop_size=(384, 600),
+                    allow_negative_crop=True),
+                dict(
+                    type='RandomChoiceResize',
+                    scales=[(480, 1333), (512, 1333), (544, 1333), (576, 1333),
+                            (608, 1333), (640, 1333), (672, 1333), (704, 1333),
+                            (736, 1333), (768, 1333), (800, 1333)],
+                    keep_ratio=True)
+            ]
+        ]),
+    dict(type='PackDetInputs')
+]
+train_dataloader = dict(
+    dataset=dict(
+        filter_cfg=dict(filter_empty_gt=False), pipeline=train_pipeline))
+
+# optimizer
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW',
+        lr=0.0001,  # 0.0002 for DeformDETR
+        weight_decay=0.0001),
+    clip_grad=dict(max_norm=0.1, norm_type=2),
+    paramwise_cfg=dict(custom_keys={'backbone': dict(lr_mult=0.1)})
+)  # custom_keys contains sampling_offsets and reference_points in DeformDETR  # noqa
+
+# learning policy
+max_epochs = 12
+train_cfg = dict(
+    type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1)
+
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+
+param_scheduler = [
+    dict(
+        type='MultiStepLR',
+        begin=0,
+        end=max_epochs,
+        by_epoch=True,
+        milestones=[11],
+        gamma=0.1)
+]
+
+# NOTE: `auto_scale_lr` is for automatically scaling LR,
+# USER SHOULD NOT CHANGE ITS VALUES.
+# base_batch_size = (8 GPUs) x (2 samples per GPU)
+auto_scale_lr = dict(base_batch_size=16)
diff --git a/mmdetection/projects/HDINO/h_dino.py b/mmdetection/projects/HDINO/h_dino.py
new file mode 100644
index 00000000..3f9d116d
--- /dev/null
+++ b/mmdetection/projects/HDINO/h_dino.py
@@ -0,0 +1,149 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Tuple
+
+import torch
+from torch import Tensor, nn
+from torch.nn.init import normal_
+
+from mmdet.models.detectors import DINO, DeformableDETR
+from mmdet.models.detectors.deformable_detr import \
+    MultiScaleDeformableAttention
+from mmdet.registry import MODELS
+from mmdet.structures import OptSampleList
+from mmdet.utils import OptConfigType
+
+
+@MODELS.register_module()
+class HDINO(DINO):
+
+    def __init__(self,
+                 *args,
+                 bbox_head: OptConfigType = None,
+                 **kwargs) -> None:
+        self.method = 0
+        self.num_query_one2one = bbox_head['num_query_one2one']
+        super(HDINO, self).__init__(*args, bbox_head=bbox_head, **kwargs)
+
+    def _init_layers(self) -> None:
+        super(HDINO, self)._init_layers()
+        self.query_embedding = None
+        if self.method == 1:
+            self.query_map = nn.Linear(self.embed_dims, self.embed_dims)
+        else:
+            self.pos_trans_fc = nn.Linear(self.embed_dims * 2, self.embed_dims)
+            self.pos_trans_norm = nn.LayerNorm(self.embed_dims)
+
+    def init_weights(self) -> None:
+        super(DeformableDETR, self).init_weights()
+        """Initialize weights for Transformer and other components."""
+        for coder in self.encoder, self.decoder:
+            for p in coder.parameters():
+                if p.dim() > 1:
+                    nn.init.xavier_uniform_(p)
+        for m in self.modules():
+            if isinstance(m, MultiScaleDeformableAttention):
+                m.init_weights()
+        nn.init.xavier_uniform_(self.memory_trans_fc.weight)
+        normal_(self.level_embed)
+
+        if self.method == 1:
+            nn.init.xavier_uniform_(self.query_map.weight)
+        else:
+            nn.init.xavier_uniform_(self.pos_trans_fc.weight)
+
+    def pre_decoder(
+        self,
+        memory: Tensor,
+        memory_mask: Tensor,
+        spatial_shapes: Tensor,
+        batch_data_samples: OptSampleList = None,
+    ) -> Tuple[dict, dict]:
+
+        bs, _, c = memory.shape
+        cls_out_features = self.bbox_head.cls_branches[
+            self.decoder.num_layers].out_features
+
+        output_memory, output_proposals = self.gen_encoder_output_proposals(
+            memory, memory_mask, spatial_shapes)
+        enc_outputs_class = self.bbox_head.cls_branches[
+            self.decoder.num_layers](
+                output_memory)
+        enc_outputs_coord_unact = self.bbox_head.reg_branches[
+            self.decoder.num_layers](output_memory) + output_proposals
+
+        # NOTE The DINO selects top-k proposals according to scores of
+        # multi-class classification, while DeformDETR, where the input
+        # is `enc_outputs_class[..., 0]` selects according to scores of
+        # binary classification.
+        topk_indices = torch.topk(
+            enc_outputs_class.max(-1)[0], k=self.num_queries, dim=1)[1]
+        topk_score = torch.gather(
+            enc_outputs_class, 1,
+            topk_indices.unsqueeze(-1).repeat(1, 1, cls_out_features))
+        topk_coords_unact = torch.gather(
+            enc_outputs_coord_unact, 1,
+            topk_indices.unsqueeze(-1).repeat(1, 1, 4))
+        topk_coords = topk_coords_unact.sigmoid()
+        topk_coords_unact = topk_coords_unact.detach()
+
+        # We only made changes here.
+        # -------------------------------------
+        if self.method == 1:
+            map_memory = self.query_map(memory.detach())
+            query = torch.gather(
+                map_memory, 1,
+                topk_indices.unsqueeze(-1).repeat(1, 1, self.embed_dims))
+        else:
+            pos_trans_out = self.pos_trans_fc(
+                self.get_proposal_pos_embed(topk_coords_unact))
+            query = self.pos_trans_norm(pos_trans_out)
+        # -------------------------------------
+
+        if self.training:
+            dn_label_query, dn_bbox_query, dn_mask, dn_meta = \
+                self.dn_query_generator(batch_data_samples)
+            query = torch.cat([dn_label_query, query], dim=1)
+            reference_points = torch.cat([dn_bbox_query, topk_coords_unact],
+                                         dim=1)
+        else:
+            reference_points = topk_coords_unact
+            dn_mask, dn_meta = None, None
+        reference_points = reference_points.sigmoid()
+
+        decoder_inputs_dict = dict(
+            query=query,
+            memory=memory,
+            reference_points=reference_points,
+            dn_mask=dn_mask)
+        # NOTE DINO calculates encoder losses on scores and coordinates
+        # of selected top-k encoder queries, while DeformDETR is of all
+        # encoder queries.
+        head_inputs_dict = dict(
+            enc_outputs_class=topk_score,
+            enc_outputs_coord=topk_coords,
+            dn_meta=dn_meta) if self.training else dict()
+
+        # We only made changes here.
+        # -------------------------------------
+        if self.training:
+            # train: num_denoising_queries + num_query_one2one
+            # + num_query_one2many
+            dn_mask = decoder_inputs_dict['dn_mask']
+            num_denoising_queries = head_inputs_dict['dn_meta'][
+                'num_denoising_queries']
+            num_query_one2one = num_denoising_queries + self.num_query_one2one
+            # dn_mask[num_query_one2one:, :num_query_one2one] = True
+            dn_mask[num_denoising_queries:num_query_one2one,
+                    num_query_one2one:] = True
+            decoder_inputs_dict['dn_mask'] = dn_mask
+        else:
+            # test: num_query_one2one
+            # + num_query_one2many
+            query = decoder_inputs_dict['query']
+            reference_points = decoder_inputs_dict['reference_points']
+            num_query_one2many = self.num_queries - self.num_query_one2one
+            decoder_inputs_dict['query'] = query[:num_query_one2many]
+            decoder_inputs_dict[
+                'reference_points'] = reference_points[:num_query_one2many]
+        # -------------------------------------
+        return decoder_inputs_dict, head_inputs_dict
diff --git a/mmdetection/projects/HDINO/h_dino_head.py b/mmdetection/projects/HDINO/h_dino_head.py
new file mode 100644
index 00000000..aa1d0867
--- /dev/null
+++ b/mmdetection/projects/HDINO/h_dino_head.py
@@ -0,0 +1,112 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import Dict, List
+
+from torch import Tensor
+
+from mmdet.models.dense_heads.dino_head import DINOHead
+from mmdet.models.utils import multi_apply
+from mmdet.registry import MODELS
+from mmdet.utils import InstanceList, OptInstanceList
+
+
+@MODELS.register_module()
+class HybridDINOHead(DINOHead):
+    """Head of the Hybrid Matching."""
+
+    def __init__(self,
+                 *args,
+                 num_query_one2one: int = 900,
+                 k_one2many: int = 2,
+                 **kwargs) -> None:
+        self.num_query_one2one = num_query_one2one
+        self.k_one2many = k_one2many
+        super().__init__(*args, **kwargs)
+
+    def loss_by_feat(
+        self,
+        all_layers_cls_scores: Tensor,
+        all_layers_bbox_preds: Tensor,
+        enc_cls_scores: Tensor,
+        enc_bbox_preds: Tensor,
+        batch_gt_instances: InstanceList,
+        batch_img_metas: List[dict],
+        dn_meta: Dict[str, int],
+        batch_gt_instances_ignore: OptInstanceList = None
+    ) -> Dict[str, Tensor]:
+        """Loss function.
+
+        Args:
+            all_layers_cls_scores (Tensor): Classification scores of all
+                decoder layers, has shape (num_decoder_layers, bs,
+                num_queries_total, cls_out_channels), where
+                `num_queries_total` is the sum of `num_denoising_queries`
+                and `num_matching_queries`.
+            all_layers_bbox_preds (Tensor): Regression outputs of all decoder
+                layers. Each is a 4D-tensor with normalized coordinate format
+                (cx, cy, w, h) and has shape (num_decoder_layers, bs,
+                num_queries_total, 4).
+            enc_cls_scores (Tensor): The score of each point on encode
+                feature map, has shape (bs, num_feat_points, cls_out_channels).
+            enc_bbox_preds (Tensor): The proposal generate from the encode
+                feature map, has shape (bs, num_feat_points, 4) with the last
+                dimension arranged as (cx, cy, w, h).
+            batch_gt_instances (list[:obj:`InstanceData`]): Batch of
+                gt_instance. It usually includes ``bboxes`` and ``labels``
+                attributes.
+            batch_img_metas (list[dict]): Meta information of each image, e.g.,
+                image size, scaling factor, etc.
+            dn_meta (Dict[str, int]): The dictionary saves information about
+                group collation, including 'num_denoising_queries' and
+                'num_denoising_groups'. It will be used for split outputs of
+                denoising and matching parts and loss calculation.
+            batch_gt_instances_ignore (list[:obj:`InstanceData`], optional):
+                Batch of gt_instances_ignore. It includes ``bboxes`` attribute
+                data that is ignored during training and testing.
+                Defaults to None.
+
+        Returns:
+            dict[str, Tensor]: A dictionary of loss components.
+        """
+        # train: num_denoising_queries + num_query_one2one
+        # + num_query_one2many
+        num_query_one2one = dn_meta[
+            'num_denoising_queries'] + self.num_query_one2one
+        outputs_classes_one2one = \
+            all_layers_cls_scores[:, :, 0: num_query_one2one, :]
+        outputs_coords_one2one = \
+            all_layers_bbox_preds[:, :, 0: num_query_one2one, :]
+        # hybrid-matching part
+        outputs_classes_one2many = \
+            all_layers_cls_scores[:, :, num_query_one2one:, :]
+        outputs_coords_one2many = \
+            all_layers_bbox_preds[:, :, num_query_one2one:, :]
+
+        loss_dict = super(HybridDINOHead, self).loss_by_feat(
+            outputs_classes_one2one, outputs_coords_one2one, enc_cls_scores,
+            enc_bbox_preds, batch_gt_instances, batch_img_metas, dn_meta,
+            batch_gt_instances_ignore)
+
+        o2m_batch_gt_instances = []
+        for gt_instance in batch_gt_instances:
+            bboxes = gt_instance.bboxes.repeat(self.k_one2many, 1)
+            labels = gt_instance.labels.repeat(self.k_one2many)
+            new_gt_instance = gt_instance.new(bboxes=bboxes, labels=labels)
+            o2m_batch_gt_instances.append(new_gt_instance)
+
+        losses_cls_o2m, losses_bbox_o2m, losses_iou_o2m = multi_apply(
+            self.loss_by_feat_single,
+            outputs_classes_one2many,
+            outputs_coords_one2many,
+            batch_gt_instances=o2m_batch_gt_instances,
+            batch_img_metas=batch_img_metas)
+
+        loss_dict['loss_cls_o2m'] = losses_cls_o2m[-1]
+        loss_dict['loss_bbox_o2m'] = losses_bbox_o2m[-1]
+        loss_dict['loss_iou_o2m'] = losses_iou_o2m[-1]
+        for num_dec_layer, (loss_cls_i, loss_bbox_i, loss_iou_i) in \
+                enumerate(zip(losses_cls_o2m[:-1], losses_bbox_o2m[:-1],
+                              losses_iou_o2m[:-1])):
+            loss_dict[f'd{num_dec_layer}.loss_cls_o2m'] = loss_cls_i
+            loss_dict[f'd{num_dec_layer}.loss_bbox_o2m'] = loss_bbox_i
+            loss_dict[f'd{num_dec_layer}.loss_iou_o2m'] = loss_iou_i
+        return loss_dict
diff --git a/mmdetection/projects/LabelStudio/backend_template/_wsgi.py b/mmdetection/projects/LabelStudio/backend_template/_wsgi.py
new file mode 100644
index 00000000..1f8fb68c
--- /dev/null
+++ b/mmdetection/projects/LabelStudio/backend_template/_wsgi.py
@@ -0,0 +1,145 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import json
+import logging
+import logging.config
+import os
+
+logging.config.dictConfig({
+    'version': 1,
+    'formatters': {
+        'standard': {
+            'format':
+            '[%(asctime)s] [%(levelname)s] [%(name)s::%(funcName)s::%(lineno)d] %(message)s'  # noqa E501
+        }
+    },
+    'handlers': {
+        'console': {
+            'class': 'logging.StreamHandler',
+            'level': 'DEBUG',
+            'stream': 'ext://sys.stdout',
+            'formatter': 'standard'
+        }
+    },
+    'root': {
+        'level': 'ERROR',
+        'handlers': ['console'],
+        'propagate': True
+    }
+})
+
+_DEFAULT_CONFIG_PATH = os.path.join(os.path.dirname(__file__), 'config.json')
+
+
+def get_kwargs_from_config(config_path=_DEFAULT_CONFIG_PATH):
+    if not os.path.exists(config_path):
+        return dict()
+    with open(config_path) as f:
+        config = json.load(f)
+    assert isinstance(config, dict)
+    return config
+
+
+if __name__ == '__main__':
+
+    from label_studio_ml.api import init_app
+
+    from projects.LabelStudio.backend_template.mmdetection import MMDetection
+
+    parser = argparse.ArgumentParser(description='Label studio')
+    parser.add_argument(
+        '-p',
+        '--port',
+        dest='port',
+        type=int,
+        default=9090,
+        help='Server port')
+    parser.add_argument(
+        '--host', dest='host', type=str, default='0.0.0.0', help='Server host')
+    parser.add_argument(
+        '--kwargs',
+        '--with',
+        dest='kwargs',
+        metavar='KEY=VAL',
+        nargs='+',
+        type=lambda kv: kv.split('='),
+        help='Additional LabelStudioMLBase model initialization kwargs')
+    parser.add_argument(
+        '-d',
+        '--debug',
+        dest='debug',
+        action='store_true',
+        help='Switch debug mode')
+    parser.add_argument(
+        '--log-level',
+        dest='log_level',
+        choices=['DEBUG', 'INFO', 'WARNING', 'ERROR'],
+        default=None,
+        help='Logging level')
+    parser.add_argument(
+        '--model-dir',
+        dest='model_dir',
+        default=os.path.dirname(__file__),
+        help='Directory models are store',
+    )
+    parser.add_argument(
+        '--check',
+        dest='check',
+        action='store_true',
+        help='Validate model instance before launching server')
+
+    args = parser.parse_args()
+
+    # setup logging level
+    if args.log_level:
+        logging.root.setLevel(args.log_level)
+
+    def isfloat(value):
+        try:
+            float(value)
+            return True
+        except ValueError:
+            return False
+
+    def parse_kwargs():
+        param = dict()
+        for k, v in args.kwargs:
+            if v.isdigit():
+                param[k] = int(v)
+            elif v == 'True' or v == 'true':
+                param[k] = True
+            elif v == 'False' or v == 'False':
+                param[k] = False
+            elif isfloat(v):
+                param[k] = float(v)
+            else:
+                param[k] = v
+        return param
+
+    kwargs = get_kwargs_from_config()
+
+    if args.kwargs:
+        kwargs.update(parse_kwargs())
+
+    if args.check:
+        print('Check "' + MMDetection.__name__ + '" instance creation..')
+        model = MMDetection(**kwargs)
+
+    app = init_app(
+        model_class=MMDetection,
+        model_dir=os.environ.get('MODEL_DIR', args.model_dir),
+        redis_queue=os.environ.get('RQ_QUEUE_NAME', 'default'),
+        redis_host=os.environ.get('REDIS_HOST', 'localhost'),
+        redis_port=os.environ.get('REDIS_PORT', 6379),
+        **kwargs)
+
+    app.run(host=args.host, port=args.port, debug=args.debug)
+
+else:
+    # for uWSGI use
+    app = init_app(
+        model_class=MMDetection,
+        model_dir=os.environ.get('MODEL_DIR', os.path.dirname(__file__)),
+        redis_queue=os.environ.get('RQ_QUEUE_NAME', 'default'),
+        redis_host=os.environ.get('REDIS_HOST', 'localhost'),
+        redis_port=os.environ.get('REDIS_PORT', 6379))
diff --git a/mmdetection/projects/LabelStudio/backend_template/mmdetection.py b/mmdetection/projects/LabelStudio/backend_template/mmdetection.py
new file mode 100644
index 00000000..f25e80e8
--- /dev/null
+++ b/mmdetection/projects/LabelStudio/backend_template/mmdetection.py
@@ -0,0 +1,148 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import io
+import json
+import logging
+import os
+from urllib.parse import urlparse
+
+import boto3
+from botocore.exceptions import ClientError
+from label_studio_ml.model import LabelStudioMLBase
+from label_studio_ml.utils import (DATA_UNDEFINED_NAME, get_image_size,
+                                   get_single_tag_keys)
+from label_studio_tools.core.utils.io import get_data_dir
+
+from mmdet.apis import inference_detector, init_detector
+
+logger = logging.getLogger(__name__)
+
+
+class MMDetection(LabelStudioMLBase):
+    """Object detector based on https://github.com/open-mmlab/mmdetection."""
+
+    def __init__(self,
+                 config_file=None,
+                 checkpoint_file=None,
+                 image_dir=None,
+                 labels_file=None,
+                 score_threshold=0.5,
+                 device='cpu',
+                 **kwargs):
+
+        super(MMDetection, self).__init__(**kwargs)
+        config_file = config_file or os.environ['config_file']
+        checkpoint_file = checkpoint_file or os.environ['checkpoint_file']
+        self.config_file = config_file
+        self.checkpoint_file = checkpoint_file
+        self.labels_file = labels_file
+        # default Label Studio image upload folder
+        upload_dir = os.path.join(get_data_dir(), 'media', 'upload')
+        self.image_dir = image_dir or upload_dir
+        logger.debug(
+            f'{self.__class__.__name__} reads images from {self.image_dir}')
+        if self.labels_file and os.path.exists(self.labels_file):
+            self.label_map = json_load(self.labels_file)
+        else:
+            self.label_map = {}
+
+        self.from_name, self.to_name, self.value, self.labels_in_config = get_single_tag_keys(  # noqa E501
+            self.parsed_label_config, 'RectangleLabels', 'Image')
+        schema = list(self.parsed_label_config.values())[0]
+        self.labels_in_config = set(self.labels_in_config)
+
+        # Collect label maps from `predicted_values="airplane,car"` attribute in